diff --git a/.circleci/config.yml b/.circleci/config.yml index cbdf7256a4f..38c2560c4dc 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -68,6 +68,16 @@ executors: architecture: "amd64" platform: "linux/amd64" + machine_large_executor_amd64: + machine: + image: ubuntu-2204:2024.01.1 # https://circleci.com/developer/machine/image/ubuntu-2204 + docker_layer_caching: true + resource_class: large + working_directory: ~/project + environment: + architecture: "amd64" + platform: "linux/amd64" + machine_executor_arm64: machine: image: ubuntu-2204:2024.01.1 # https://circleci.com/developer/machine/image/ubuntu-2204 @@ -237,13 +247,23 @@ jobs: path: build/test-results spotless: - executor: small_executor + executor: medium_executor steps: - prepare - run: name: Spotless command: | - ./gradlew --no-daemon --parallel checkMavenCoordinateCollisions spotlessCheck checkModuleDependencies + ./gradlew --no-daemon --parallel spotlessCheck + - notify + + moduleChecks: + executor: small_executor + steps: + - prepare + - run: + name: Module Checks + command: | + ./gradlew --no-daemon --parallel checkMavenCoordinateCollisions checkModuleDependencies - notify dockerScan: @@ -343,8 +363,8 @@ jobs: path: build/test-results acceptanceTests: - parallelism: 5 - executor: machine_executor_amd64 + parallelism: 4 + executor: machine_large_executor_amd64 steps: - install_java_21 - prepare @@ -562,12 +582,17 @@ workflows: filters: tags: &filters-release-tags only: /^[0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z0-9]+)?/ + - moduleChecks: + filters: + tags: + <<: *filters-release-tags - spotless: filters: tags: <<: *filters-release-tags - windowsBuild: requires: + - moduleChecks - spotless filters: tags: @@ -630,6 +655,7 @@ workflows: - acceptanceTests - referenceTests - extractAPISpec + - moduleChecks - spotless - windowsBuild context: @@ -649,6 +675,7 @@ workflows: - acceptanceTests - referenceTests - extractAPISpec + - moduleChecks - spotless - windowsBuild context: @@ -668,6 +695,7 @@ workflows: - acceptanceTests - referenceTests - extractAPISpec + - moduleChecks - spotless - windowsBuild context: @@ -700,6 +728,7 @@ workflows: - acceptanceTests - referenceTests - extractAPISpec + - moduleChecks - spotless - windowsBuild nightly: diff --git a/.codespell/.codespellrc b/.codespell/.codespellrc index 5255128dffb..95aa2b2749f 100644 --- a/.codespell/.codespellrc +++ b/.codespell/.codespellrc @@ -1,5 +1,5 @@ [codespell] -skip = .git,package-lock.json,LOG.old.* +skip = .git,package-lock.json,LOG.old.*,venv count = quiet-level = 3 ignore-words = ./.codespell/wordlist.txt \ No newline at end of file diff --git a/.github/workflows/codespell.yml b/.github/workflows/codespell.yml index 1511fd18304..d3a8b072166 100644 --- a/.github/workflows/codespell.yml +++ b/.github/workflows/codespell.yml @@ -16,8 +16,13 @@ jobs: - name: Checkout the repository uses: actions/checkout@v4 - - name: Install prerequisites - run: pip install codespell + - name: Set up a Python venv and install prerequisites + run: | + python3 -m venv venv + source venv/bin/activate + pip install codespell - name: Spell check - run: codespell --config=./.codespell/.codespellrc \ No newline at end of file + run: | + source venv/bin/activate + codespell --config=./.codespell/.codespellrc \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md index 79bdb0f879d..1e0c6f219ec 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,18 +4,12 @@ ## Current Releases -For information on changes in released versions of Teku, see -the [releases page](https://github.com/Consensys/teku/releases). - ## Unreleased Changes ### Breaking Changes ### Additions and Improvements -- Increased the executor queue default maximum size to 40_000 (previously 20_000), and other queues to 10_000 (previously 5_000). If you have custom settings for these queues, check to ensure they're still required. -- Added `peers_direction_current` libp2p metric to track the number of peers by direction (inbound and outbound). -- Deposit tree snapshots will be loaded from database as a default unless custom snapshot has been provided. -- Added hidden option `--Xdeposit-contract-logs-syncing-enabled` to allow disabling the syncing of the deposit contract logs from the EL. This is useful when running a non-validating node. It is advisable to be used alongside with `--Xeth1-missing-deposits-event-logging-enabled=false` to avoid unnecessary logging of missing deposits. -- Updated the bootnodes for Chiado and Gnosis networks +- improve block publishing performance, especially relevant with locally produced blocks ### Bug Fixes +- Added a startup script for unix systems to ensure that when jemalloc is installed the script sets the LD_PRELOAD environment variable to the use the jemalloc library diff --git a/acceptance-tests/build.gradle b/acceptance-tests/build.gradle index 93c1a6dbfbc..f732ec2b4fa 100644 --- a/acceptance-tests/build.gradle +++ b/acceptance-tests/build.gradle @@ -19,6 +19,7 @@ dependencies { testFixturesImplementation project(':infrastructure:metrics') testFixturesImplementation testFixtures(project(':infrastructure:async')) testFixturesImplementation project(':teku') + testFixturesImplementation project(':ethereum:json-types') testFixturesImplementation project(':infrastructure:crypto') testFixturesImplementation project(':infrastructure:time') @@ -27,7 +28,7 @@ dependencies { testFixturesImplementation 'io.libp2p:jvm-libp2p' testFixturesImplementation 'org.apache.commons:commons-lang3' testFixturesImplementation 'commons-io:commons-io' - testFixturesImplementation 'org.apache.tuweni:tuweni-bytes' + testFixturesImplementation 'io.tmio:tuweni-bytes' testFixturesImplementation 'org.junit.jupiter:junit-jupiter-api' testFixturesImplementation 'org.testcontainers:testcontainers' testFixturesImplementation 'org.testcontainers:junit-jupiter' diff --git a/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/BlockProposalAcceptanceTest.java b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/BlockProposalAcceptanceTest.java index 653381860dc..762a10959b8 100644 --- a/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/BlockProposalAcceptanceTest.java +++ b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/BlockProposalAcceptanceTest.java @@ -21,8 +21,9 @@ import java.util.Arrays; import java.util.Locale; import org.apache.tuweni.bytes.Bytes32; -import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.schema.eip7594.SignedBeaconBlockEip7594; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import tech.pegasys.teku.infrastructure.bytes.Bytes20; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.test.acceptance.dsl.AcceptanceTestBase; import tech.pegasys.teku.test.acceptance.dsl.GenesisGenerator.InitialStateData; @@ -34,8 +35,9 @@ public class BlockProposalAcceptanceTest extends AcceptanceTestBase { private static final URL JWT_FILE = Resources.getResource("auth/ee-jwt-secret.hex"); - @Test - void shouldHaveCorrectFeeRecipientAndGraffiti() throws Exception { + @ParameterizedTest(name = "ssz_encode={0}") + @ValueSource(booleans = {true, false}) + void shouldHaveCorrectFeeRecipientAndGraffiti(final boolean useSszBlocks) throws Exception { final String networkName = "swift"; final ValidatorKeystores validatorKeystores = @@ -45,10 +47,7 @@ void shouldHaveCorrectFeeRecipientAndGraffiti() throws Exception { createGenesisGenerator() .network(networkName) .withAltairEpoch(UInt64.ZERO) - .withBellatrixEpoch(UInt64.ONE) - .withCapellaEpoch(UInt64.valueOf(2)) - .withDenebEpoch(UInt64.valueOf(3)) - .withEip7594Epoch(UInt64.valueOf(4)) + .withBellatrixEpoch(UInt64.ZERO) .validatorKeys(validatorKeystores, validatorKeystores) .generate(); @@ -61,14 +60,8 @@ void shouldHaveCorrectFeeRecipientAndGraffiti() throws Exception { .withJwtSecretFile(JWT_FILE) .withNetwork(networkName) .withInitialState(genesis) - .withRealNetwork() .withAltairEpoch(UInt64.ZERO) - .withBellatrixEpoch(UInt64.ONE) - .withCapellaEpoch(UInt64.valueOf(2)) - .withDenebEpoch(UInt64.valueOf(3)) - .withEip7594Epoch(UInt64.valueOf(4)) - .withTotalTerminalDifficulty(0) - .withTrustedSetupFromClasspath("mainnet-trusted-setup.txt") + .withBellatrixEpoch(UInt64.ZERO) .withValidatorProposerDefaultFeeRecipient(defaultFeeRecipient) .build()); final TekuValidatorNode validatorClient = @@ -78,6 +71,7 @@ void shouldHaveCorrectFeeRecipientAndGraffiti() throws Exception { .withValidatorProposerDefaultFeeRecipient(defaultFeeRecipient) .withInteropModeDisabled() .withBeaconNodes(beaconNode) + .withBeaconNodeSszBlocksEnabled(useSszBlocks) .withGraffiti(userGraffiti) .withNetwork("auto") .build()); @@ -85,15 +79,18 @@ void shouldHaveCorrectFeeRecipientAndGraffiti() throws Exception { beaconNode.start(); validatorClient.start(); - beaconNode.waitForEpochAtOrAbove(4); beaconNode.waitForBlockSatisfying( block -> { - assertThat(block).isInstanceOf(SignedBeaconBlockEip7594.class); - final SignedBeaconBlockEip7594 eip7594Block = (SignedBeaconBlockEip7594) block; - assertThat( - eip7594Block.getMessage().getBody().executionPayload.feeRecipient.toHexString()) + final Bytes20 feeRecipient = + block + .getMessage() + .getBody() + .getOptionalExecutionPayload() + .orElseThrow() + .getFeeRecipient(); + assertThat(feeRecipient.toHexString().toLowerCase(Locale.ROOT)) .isEqualTo(defaultFeeRecipient.toLowerCase(Locale.ROOT)); - final Bytes32 graffiti = eip7594Block.getMessage().getBody().graffiti; + final Bytes32 graffiti = block.getMessage().getBody().getGraffiti(); final String graffitiMessage = new String( Arrays.copyOfRange( diff --git a/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/CapellaRemoteSignerAcceptanceTest.java b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/CapellaRemoteSignerAcceptanceTest.java new file mode 100644 index 00000000000..032080fd4b5 --- /dev/null +++ b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/CapellaRemoteSignerAcceptanceTest.java @@ -0,0 +1,132 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.test.acceptance; + +import com.google.common.io.Resources; +import java.net.URL; +import java.util.Map; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.ethereum.execution.types.Eth1Address; +import tech.pegasys.teku.infrastructure.time.SystemTimeProvider; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.test.acceptance.dsl.AcceptanceTestBase; +import tech.pegasys.teku.test.acceptance.dsl.BesuDockerVersion; +import tech.pegasys.teku.test.acceptance.dsl.BesuNode; +import tech.pegasys.teku.test.acceptance.dsl.GenesisGenerator.InitialStateData; +import tech.pegasys.teku.test.acceptance.dsl.TekuBeaconNode; +import tech.pegasys.teku.test.acceptance.dsl.TekuNodeConfig; +import tech.pegasys.teku.test.acceptance.dsl.TekuNodeConfigBuilder; +import tech.pegasys.teku.test.acceptance.dsl.Web3SignerNode; +import tech.pegasys.teku.test.acceptance.dsl.tools.ValidatorKeysApi; +import tech.pegasys.teku.test.acceptance.dsl.tools.deposits.ValidatorKeystores; + +public class CapellaRemoteSignerAcceptanceTest extends AcceptanceTestBase { + + private static final String NETWORK_NAME = "swift"; + public static final Eth1Address WITHDRAWAL_ADDRESS = + Eth1Address.fromHexString("0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"); + private static final URL JWT_FILE = Resources.getResource("auth/ee-jwt-secret.hex"); + + @Test + void capellaWithRemoteSigner() throws Exception { + final UInt64 currentTime = new SystemTimeProvider().getTimeInSeconds(); + final int genesisTime = + currentTime.intValue() + 30; // genesis needs added time for nodes to startup + + final Web3SignerNode web3SignerNode = + createWeb3SignerNode( + config -> + config + .withNetwork(NETWORK_NAME) + .withAltairEpoch(UInt64.ZERO) + .withBellatrixEpoch(UInt64.ZERO) + .withCapellaEpoch(UInt64.ZERO)); + + web3SignerNode.start(); + final ValidatorKeysApi signerApi = web3SignerNode.getValidatorKeysApi(); + final BesuNode besuNode = createBesuNode(genesisTime); + besuNode.start(); + + final ValidatorKeystores validatorKeys = + createTekuDepositSender(NETWORK_NAME).generateValidatorKeys(4, WITHDRAWAL_ADDRESS); + + signerApi.addLocalValidatorsAndExpect(validatorKeys, "imported"); + signerApi.assertLocalValidatorListing(validatorKeys.getPublicKeys()); + + final InitialStateData initialStateData = + createGenesisGenerator() + .network(NETWORK_NAME) + .withGenesisTime(genesisTime) + .genesisDelaySeconds(0) + .withAltairEpoch(UInt64.ZERO) + .withBellatrixEpoch(UInt64.ZERO) + .withCapellaEpoch(UInt64.ZERO) + .withTotalTerminalDifficulty(0) + .genesisExecutionPayloadHeaderSource(besuNode::createGenesisExecutionPayload) + .validatorKeys(validatorKeys) + .generate(); + + final TekuBeaconNode tekuNode = + createTekuBeaconNode( + beaconNode( + genesisTime, besuNode, initialStateData, web3SignerNode.getValidatorRestApiUrl())); + + tekuNode.start(); + + tekuNode.waitForNextEpoch(); + tekuNode.waitForNewBlock(); + tekuNode.waitForFullSyncCommitteeAggregate(); + } + + private BesuNode createBesuNode(final int genesisTime) { + final int shanghai = + genesisTime + 2; // 4 slots, 2 seconds each (swift) - activate Prague on first slot + final Map genesisOverrides = Map.of("shanghaiTime", String.valueOf(shanghai)); + + return createBesuNode( + BesuDockerVersion.STABLE, + config -> + config + .withMergeSupport() + .withGenesisFile("besu/mergedGenesis.json") + .withP2pEnabled(true) + .withJwtTokenAuthorization(JWT_FILE), + genesisOverrides); + } + + private static TekuNodeConfig beaconNode( + final int genesisTime, + final BesuNode besuNode, + final InitialStateData initialStateData, + final String signerUrl) + throws Exception { + return TekuNodeConfigBuilder.createBeaconNode() + .withInitialState(initialStateData) + .withInteropModeDisabled() + .withNetwork(NETWORK_NAME) + .withAltairEpoch(UInt64.ZERO) + .withBellatrixEpoch(UInt64.ZERO) + .withCapellaEpoch(UInt64.ZERO) + .withTotalTerminalDifficulty(0) + .withGenesisTime(genesisTime) + .withExecutionEngine(besuNode) + .withJwtSecretFile(JWT_FILE) + .withExternalSignerUrl(signerUrl) + .withExternalSignerPublicKeys("external-signer") + .withValidatorProposerDefaultFeeRecipient("0xFE3B557E8Fb62b89F4916B721be55cEb828dBd73") + .withStartupTargetPeerCount(0) + .withRealNetwork() + .build(); + } +} diff --git a/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/CapellaUpgradeAcceptanceTest.java b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/CapellaUpgradeAcceptanceTest.java index 807b5172f53..0c0f9c2d00a 100644 --- a/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/CapellaUpgradeAcceptanceTest.java +++ b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/CapellaUpgradeAcceptanceTest.java @@ -16,7 +16,6 @@ import com.google.common.io.Resources; import java.net.URL; import java.util.Map; -import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import tech.pegasys.teku.infrastructure.time.SystemTimeProvider; import tech.pegasys.teku.infrastructure.unsigned.UInt64; @@ -27,22 +26,15 @@ import tech.pegasys.teku.test.acceptance.dsl.TekuBeaconNode; import tech.pegasys.teku.test.acceptance.dsl.TekuNodeConfigBuilder; -/** - * The test is based on `shanghaiTime` in Besu EL genesis config as the only option to start - * Shanghai on Besu. There is a bit of magic on assumption of node starting time, which should be - * eliminated when there will be an option `shanghaiBlock`. When it's available, please, upgrade the - * test to use it instead of time. - */ public class CapellaUpgradeAcceptanceTest extends AcceptanceTestBase { private final SystemTimeProvider timeProvider = new SystemTimeProvider(); private static final URL JWT_FILE = Resources.getResource("auth/ee-jwt-secret.hex"); @Test - @Disabled("Switch to shanghaiBlock Besu genesis when it's available and enable") void shouldUpgradeToCapella() throws Exception { final UInt64 currentTime = timeProvider.getTimeInSeconds(); - final int genesisTime = currentTime.plus(30).intValue(); // magic node startup time + final int genesisTime = currentTime.plus(60).intValue(); // magic node startup time final int shanghaiTime = genesisTime + 4 * 2; // 4 slots, 2 seconds each final Map genesisOverrides = Map.of("shanghaiTime", String.valueOf(shanghaiTime)); @@ -59,6 +51,15 @@ void shouldUpgradeToCapella() throws Exception { genesisOverrides); primaryEL.start(); + TekuBeaconNode primaryNode = + createTekuBeaconNode( + beaconNodeConfigWithForks(genesisTime, primaryEL) + .withStartupTargetPeerCount(0) + .build()); + + primaryNode.start(); + primaryNode.waitForMilestone(SpecMilestone.CAPELLA); + BesuNode secondaryEL = createBesuNode( BesuDockerVersion.STABLE, @@ -72,15 +73,6 @@ void shouldUpgradeToCapella() throws Exception { secondaryEL.start(); secondaryEL.addPeer(primaryEL); - TekuBeaconNode primaryNode = - createTekuBeaconNode( - beaconNodeConfigWithForks(genesisTime, primaryEL) - .withStartupTargetPeerCount(0) - .build()); - - primaryNode.start(); - primaryNode.waitForMilestone(SpecMilestone.CAPELLA); - final int primaryNodeGenesisTime = primaryNode.getGenesisTime().intValue(); TekuBeaconNode lateJoiningNode = diff --git a/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/DenebRemoteSignerAcceptanceTest.java b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/DenebRemoteSignerAcceptanceTest.java new file mode 100644 index 00000000000..92e4ab08ec0 --- /dev/null +++ b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/DenebRemoteSignerAcceptanceTest.java @@ -0,0 +1,134 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.test.acceptance; + +import com.google.common.io.Resources; +import java.net.URL; +import java.util.Map; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.ethereum.execution.types.Eth1Address; +import tech.pegasys.teku.infrastructure.time.SystemTimeProvider; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.test.acceptance.dsl.AcceptanceTestBase; +import tech.pegasys.teku.test.acceptance.dsl.BesuDockerVersion; +import tech.pegasys.teku.test.acceptance.dsl.BesuNode; +import tech.pegasys.teku.test.acceptance.dsl.GenesisGenerator.InitialStateData; +import tech.pegasys.teku.test.acceptance.dsl.TekuBeaconNode; +import tech.pegasys.teku.test.acceptance.dsl.TekuNodeConfig; +import tech.pegasys.teku.test.acceptance.dsl.TekuNodeConfigBuilder; +import tech.pegasys.teku.test.acceptance.dsl.Web3SignerNode; +import tech.pegasys.teku.test.acceptance.dsl.tools.ValidatorKeysApi; +import tech.pegasys.teku.test.acceptance.dsl.tools.deposits.ValidatorKeystores; + +public class DenebRemoteSignerAcceptanceTest extends AcceptanceTestBase { + + private static final String NETWORK_NAME = "swift"; + public static final Eth1Address WITHDRAWAL_ADDRESS = + Eth1Address.fromHexString("0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"); + private static final URL JWT_FILE = Resources.getResource("auth/ee-jwt-secret.hex"); + + @Test + void denebWithRemoteSigner() throws Exception { + final UInt64 currentTime = new SystemTimeProvider().getTimeInSeconds(); + final int genesisTime = + currentTime.intValue() + 30; // genesis in 30 seconds to give node time to start + + final Web3SignerNode web3SignerNode = + createWeb3SignerNode( + config -> + config + .withNetwork(NETWORK_NAME) + .withAltairEpoch(UInt64.ZERO) + .withBellatrixEpoch(UInt64.ZERO) + .withCapellaEpoch(UInt64.ZERO) + .withDenebEpoch(UInt64.ZERO) + .withTrustedSetupFromClasspath("mainnet-trusted-setup.txt")); + + web3SignerNode.start(); + final ValidatorKeysApi signerApi = web3SignerNode.getValidatorKeysApi(); + final BesuNode besuNode = createBesuNode(genesisTime); + besuNode.start(); + + final ValidatorKeystores validatorKeys = + createTekuDepositSender(NETWORK_NAME).generateValidatorKeys(4, WITHDRAWAL_ADDRESS); + + signerApi.addLocalValidatorsAndExpect(validatorKeys, "imported"); + signerApi.assertLocalValidatorListing(validatorKeys.getPublicKeys()); + + final InitialStateData initialStateData = + createGenesisGenerator() + .network(NETWORK_NAME) + .withGenesisTime(genesisTime) + .genesisDelaySeconds(0) + .withAltairEpoch(UInt64.ZERO) + .withBellatrixEpoch(UInt64.ZERO) + .withCapellaEpoch(UInt64.ZERO) + .withDenebEpoch(UInt64.ZERO) + .withTotalTerminalDifficulty(0) + .genesisExecutionPayloadHeaderSource(besuNode::createGenesisExecutionPayload) + .validatorKeys(validatorKeys) + .generate(); + + final TekuBeaconNode tekuNode = + createTekuBeaconNode( + beaconNode( + genesisTime, besuNode, initialStateData, web3SignerNode.getValidatorRestApiUrl())); + + tekuNode.start(); + + tekuNode.waitForNextEpoch(); + tekuNode.waitForNewBlock(); + tekuNode.waitForFullSyncCommitteeAggregate(); + } + + private BesuNode createBesuNode(final int genesisTime) { + final Map genesisOverrides = Map.of("cancunTime", String.valueOf(genesisTime)); + + return createBesuNode( + BesuDockerVersion.STABLE, + config -> + config + .withMergeSupport() + .withGenesisFile("besu/mergedGenesis.json") + .withP2pEnabled(true) + .withJwtTokenAuthorization(JWT_FILE), + genesisOverrides); + } + + private static TekuNodeConfig beaconNode( + final int genesisTime, + final BesuNode besuNode, + final InitialStateData initialStateData, + final String signerUrl) + throws Exception { + return TekuNodeConfigBuilder.createBeaconNode() + .withInitialState(initialStateData) + .withInteropModeDisabled() + .withNetwork(NETWORK_NAME) + .withAltairEpoch(UInt64.ZERO) + .withBellatrixEpoch(UInt64.ZERO) + .withCapellaEpoch(UInt64.ZERO) + .withDenebEpoch(UInt64.ZERO) + .withTotalTerminalDifficulty(0) + .withGenesisTime(genesisTime) + .withExecutionEngine(besuNode) + .withJwtSecretFile(JWT_FILE) + .withExternalSignerUrl(signerUrl) + .withExternalSignerPublicKeys("external-signer") + .withValidatorProposerDefaultFeeRecipient("0xFE3B557E8Fb62b89F4916B721be55cEb828dBd73") + .withStartupTargetPeerCount(0) + .withRealNetwork() + .build(); + } +} diff --git a/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/DenebUpgradeAcceptanceTest.java b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/DenebUpgradeAcceptanceTest.java index d125505a27a..a9c0e1f80e8 100644 --- a/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/DenebUpgradeAcceptanceTest.java +++ b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/DenebUpgradeAcceptanceTest.java @@ -16,7 +16,6 @@ import com.google.common.io.Resources; import java.net.URL; import java.util.Map; -import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import tech.pegasys.teku.infrastructure.time.SystemTimeProvider; import tech.pegasys.teku.infrastructure.unsigned.UInt64; @@ -27,22 +26,15 @@ import tech.pegasys.teku.test.acceptance.dsl.TekuBeaconNode; import tech.pegasys.teku.test.acceptance.dsl.TekuNodeConfigBuilder; -/** - * The test is based on `shanghaiTime` and `cancunTime` in Besu EL genesis config as the only option - * to start these forks on Besu. There is a bit of magic on assumption of node starting time, which - * should be eliminated when there will be an options `shanghaiBlock` and `cancunBlock`. When it's - * available, please, upgrade the test to use them instead of time and enable it. - */ public class DenebUpgradeAcceptanceTest extends AcceptanceTestBase { private final SystemTimeProvider timeProvider = new SystemTimeProvider(); private static final URL JWT_FILE = Resources.getResource("auth/ee-jwt-secret.hex"); @Test - @Disabled("Switch Besu genesis to shanghaiBlock and cancunBlock when it's available and enable") void shouldUpgradeToDeneb() throws Exception { final UInt64 currentTime = timeProvider.getTimeInSeconds(); - final int genesisTime = currentTime.plus(30).intValue(); // magic node startup time + final int genesisTime = currentTime.plus(60).intValue(); // magic node startup time final int epochDuration = 4 * 2; // 4 slots, 2 seconds each for swift final int shanghaiTime = genesisTime + epochDuration; final Map genesisOverrides = @@ -64,6 +56,15 @@ void shouldUpgradeToDeneb() throws Exception { genesisOverrides); primaryEL.start(); + TekuBeaconNode primaryNode = + createTekuBeaconNode( + beaconNodeWithTrustedSetup(genesisTime, primaryEL) + .withStartupTargetPeerCount(0) + .build()); + + primaryNode.start(); + primaryNode.waitForMilestone(SpecMilestone.DENEB); + BesuNode secondaryEL = createBesuNode( BesuDockerVersion.STABLE, @@ -77,15 +78,6 @@ void shouldUpgradeToDeneb() throws Exception { secondaryEL.start(); secondaryEL.addPeer(primaryEL); - TekuBeaconNode primaryNode = - createTekuBeaconNode( - beaconNodeWithTrustedSetup(genesisTime, primaryEL) - .withStartupTargetPeerCount(0) - .build()); - - primaryNode.start(); - primaryNode.waitForMilestone(SpecMilestone.DENEB); - final int primaryNodeGenesisTime = primaryNode.getGenesisTime().intValue(); TekuBeaconNode lateJoiningNode = @@ -112,7 +104,6 @@ private static TekuNodeConfigBuilder beaconNodeWithTrustedSetup( .withRealNetwork() .withJwtSecretFile(JWT_FILE) .withDenebEpoch(UInt64.valueOf(2)) - .withTrustedSetupFromClasspath("mainnet-trusted-setup.txt") .withTotalTerminalDifficulty(0); } } diff --git a/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/ElectraUpgradeAcceptanceTest.java b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/ElectraUpgradeAcceptanceTest.java new file mode 100644 index 00000000000..438f09bc409 --- /dev/null +++ b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/ElectraUpgradeAcceptanceTest.java @@ -0,0 +1,117 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.test.acceptance; + +import com.google.common.io.Resources; +import java.net.URL; +import java.util.Map; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.ethereum.execution.types.Eth1Address; +import tech.pegasys.teku.infrastructure.time.SystemTimeProvider; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.test.acceptance.dsl.AcceptanceTestBase; +import tech.pegasys.teku.test.acceptance.dsl.BesuDockerVersion; +import tech.pegasys.teku.test.acceptance.dsl.BesuNode; +import tech.pegasys.teku.test.acceptance.dsl.GenesisGenerator.InitialStateData; +import tech.pegasys.teku.test.acceptance.dsl.TekuBeaconNode; +import tech.pegasys.teku.test.acceptance.dsl.TekuNodeConfig; +import tech.pegasys.teku.test.acceptance.dsl.TekuNodeConfigBuilder; +import tech.pegasys.teku.test.acceptance.dsl.tools.deposits.ValidatorKeystores; + +@Disabled("Won't work until we update Engine API for Electra + EL changes") +public class ElectraUpgradeAcceptanceTest extends AcceptanceTestBase { + + private static final String NETWORK_NAME = "swift"; + public static final Eth1Address WITHDRAWAL_ADDRESS = + Eth1Address.fromHexString("0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"); + private static final URL JWT_FILE = Resources.getResource("auth/ee-jwt-secret.hex"); + + @Test + void upgradeFromDeneb() throws Exception { + final UInt64 currentTime = new SystemTimeProvider().getTimeInSeconds(); + final int genesisTime = + currentTime.intValue() + 30; // genesis in 30 seconds to give node time to start + + final BesuNode besuNode = createBesuNode(genesisTime); + besuNode.start(); + + final ValidatorKeystores validatorKeys = + createTekuDepositSender(NETWORK_NAME).generateValidatorKeys(4, WITHDRAWAL_ADDRESS); + + final InitialStateData initialStateData = + createGenesisGenerator() + .network(NETWORK_NAME) + .withGenesisTime(genesisTime) + .genesisDelaySeconds(0) + .withAltairEpoch(UInt64.ZERO) + .withBellatrixEpoch(UInt64.ZERO) + .withCapellaEpoch(UInt64.ZERO) + .withDenebEpoch(UInt64.ZERO) + .withElectraEpoch(UInt64.ONE) + .withTotalTerminalDifficulty(0) + .genesisExecutionPayloadHeaderSource(besuNode::createGenesisExecutionPayload) + .validatorKeys(validatorKeys) + .generate(); + + final TekuBeaconNode tekuNode = + createTekuBeaconNode(beaconNode(genesisTime, besuNode, initialStateData, validatorKeys)); + tekuNode.start(); + + tekuNode.waitForMilestone(SpecMilestone.ELECTRA); + tekuNode.waitForNewBlock(); + } + + private BesuNode createBesuNode(final int genesisTime) { + final int pragueTime = + genesisTime + 4 * 2; // 4 slots, 2 seconds each (swift) - activate Prague on first slot + final Map genesisOverrides = Map.of("pragueTime", String.valueOf(pragueTime)); + + return createBesuNode( + BesuDockerVersion.STABLE, + config -> + config + .withMergeSupport() + .withGenesisFile("besu/pragueGenesis.json") + .withP2pEnabled(true) + .withJwtTokenAuthorization(JWT_FILE), + genesisOverrides); + } + + private static TekuNodeConfig beaconNode( + final int genesisTime, + final BesuNode besuNode, + final InitialStateData initialStateData, + final ValidatorKeystores validatorKeys) + throws Exception { + return TekuNodeConfigBuilder.createBeaconNode() + .withInitialState(initialStateData) + .withNetwork(NETWORK_NAME) + .withAltairEpoch(UInt64.ZERO) + .withBellatrixEpoch(UInt64.ZERO) + .withCapellaEpoch(UInt64.ZERO) + .withDenebEpoch(UInt64.ZERO) + .withElectraEpoch(UInt64.ONE) + .withTotalTerminalDifficulty(0) + .withGenesisTime(genesisTime) + .withExecutionEngine(besuNode) + .withJwtSecretFile(JWT_FILE) + .withReadOnlyKeystorePath(validatorKeys) + .withValidatorProposerDefaultFeeRecipient("0xFE3B557E8Fb62b89F4916B721be55cEb828dBd73") + .withStartupTargetPeerCount(0) + .withRealNetwork() + .build(); + } +} diff --git a/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/ExecutionLayerTriggeredExitAcceptanceTest.java b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/ExecutionLayerTriggeredExitAcceptanceTest.java new file mode 100644 index 00000000000..98328f7e9bd --- /dev/null +++ b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/ExecutionLayerTriggeredExitAcceptanceTest.java @@ -0,0 +1,128 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.test.acceptance; + +import com.google.common.io.Resources; +import java.net.URL; +import java.util.Map; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.ethereum.execution.types.Eth1Address; +import tech.pegasys.teku.infrastructure.time.SystemTimeProvider; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.test.acceptance.dsl.AcceptanceTestBase; +import tech.pegasys.teku.test.acceptance.dsl.BesuDockerVersion; +import tech.pegasys.teku.test.acceptance.dsl.BesuNode; +import tech.pegasys.teku.test.acceptance.dsl.GenesisGenerator.InitialStateData; +import tech.pegasys.teku.test.acceptance.dsl.TekuBeaconNode; +import tech.pegasys.teku.test.acceptance.dsl.TekuNodeConfig; +import tech.pegasys.teku.test.acceptance.dsl.TekuNodeConfigBuilder; +import tech.pegasys.teku.test.acceptance.dsl.tools.deposits.ValidatorKeys; +import tech.pegasys.teku.test.acceptance.dsl.tools.deposits.ValidatorKeystores; + +public class ExecutionLayerTriggeredExitAcceptanceTest extends AcceptanceTestBase { + + private static final String NETWORK_NAME = "swift"; + private static final URL JWT_FILE = Resources.getResource("auth/ee-jwt-secret.hex"); + + @Test + @Disabled("Won't work until we update Engine API for Electra") + void triggerValidatorExitWithFullWithdrawal() throws Exception { + final UInt64 currentTime = new SystemTimeProvider().getTimeInSeconds(); + final int genesisTime = + currentTime.intValue() + 30; // genesis in 30 seconds to give node time to start + + final BesuNode besuNode = createBesuNode(genesisTime); + besuNode.start(); + + final String eth1Address = + besuNode.getRichBenefactorAddress(); // used as withdrawal_credentials + final String eth1PrivateKey = + besuNode.getRichBenefactorKey(); // key for withdrawal_credentials account + + final ValidatorKeystores validatorKeys = + createTekuDepositSender(NETWORK_NAME) + .generateValidatorKeys(4, Eth1Address.fromHexString(eth1Address)); + + final InitialStateData initialStateData = + createGenesisGenerator() + .network(NETWORK_NAME) + .withGenesisTime(genesisTime) + .genesisDelaySeconds(0) + .withAltairEpoch(UInt64.ZERO) + .withBellatrixEpoch(UInt64.ZERO) + .withCapellaEpoch(UInt64.ZERO) + .withDenebEpoch(UInt64.ZERO) + .withElectraEpoch(UInt64.ZERO) + .withTotalTerminalDifficulty(0) + .genesisExecutionPayloadHeaderSource(besuNode::createGenesisExecutionPayload) + .validatorKeys(validatorKeys) + .generate(); + + final TekuBeaconNode tekuNode = + createTekuBeaconNode(beaconNode(genesisTime, besuNode, initialStateData, validatorKeys)); + tekuNode.start(); + // Ensures validator is active long enough to exit + tekuNode.waitForNewFinalization(); + + final ValidatorKeys validator = validatorKeys.getValidatorKeys().get(0); + final BLSPublicKey validatorPubkey = validator.getValidatorKey().getPublicKey(); + + besuNode.createWithdrawalRequest(eth1PrivateKey, validatorPubkey, UInt64.ZERO); + + // Wait for validator exit confirmation + tekuNode.waitForLogMessageContaining( + "has changed status from active_ongoing to active_exiting"); + } + + private BesuNode createBesuNode(final int genesisTime) { + final Map genesisOverrides = Map.of("pragueTime", String.valueOf(genesisTime)); + + return createBesuNode( + BesuDockerVersion.STABLE, + config -> + config + .withMergeSupport() + .withGenesisFile("besu/pragueGenesis.json") + .withP2pEnabled(true) + .withJwtTokenAuthorization(JWT_FILE), + genesisOverrides); + } + + private static TekuNodeConfig beaconNode( + final int genesisTime, + final BesuNode besuNode, + final InitialStateData initialStateData, + final ValidatorKeystores validatorKeys) + throws Exception { + return TekuNodeConfigBuilder.createBeaconNode() + .withInitialState(initialStateData) + .withNetwork(NETWORK_NAME) + .withAltairEpoch(UInt64.ZERO) + .withBellatrixEpoch(UInt64.ZERO) + .withCapellaEpoch(UInt64.ZERO) + .withDenebEpoch(UInt64.ZERO) + .withElectraEpoch(UInt64.ZERO) + .withTotalTerminalDifficulty(0) + .withGenesisTime(genesisTime) + .withExecutionEngine(besuNode) + .withJwtSecretFile(JWT_FILE) + .withReadOnlyKeystorePath(validatorKeys) + .withValidatorProposerDefaultFeeRecipient("0xFE3B557E8Fb62b89F4916B721be55cEb828dBd73") + .withStartupTargetPeerCount(0) + .withRealNetwork() + .build(); + } +} diff --git a/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/MergedGenesisAcceptanceTest.java b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/MergedGenesisAcceptanceTest.java index 4eedea654d0..38380c7f1c6 100644 --- a/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/MergedGenesisAcceptanceTest.java +++ b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/MergedGenesisAcceptanceTest.java @@ -55,7 +55,7 @@ void setup() throws Exception { .withAltairEpoch(UInt64.ZERO) .withBellatrixEpoch(UInt64.ZERO) .withTotalTerminalDifficulty(0) - .genesisPayloadSource(eth1Node) + .genesisExecutionPayloadHeaderSource(eth1Node::createGenesisExecutionPayload) .validatorKeys(validatorKeys) .generate(); tekuNode = diff --git a/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/MergedGenesisInteropModeAcceptanceTest.java b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/MergedGenesisInteropModeAcceptanceTest.java new file mode 100644 index 00000000000..e03c37cc2ed --- /dev/null +++ b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/MergedGenesisInteropModeAcceptanceTest.java @@ -0,0 +1,102 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.test.acceptance; + +import static org.assertj.core.api.Fail.fail; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.test.acceptance.dsl.AcceptanceTestBase; +import tech.pegasys.teku.test.acceptance.dsl.TekuBeaconNode; +import tech.pegasys.teku.test.acceptance.dsl.TekuNodeConfig; +import tech.pegasys.teku.test.acceptance.dsl.TekuNodeConfigBuilder; + +public class MergedGenesisInteropModeAcceptanceTest extends AcceptanceTestBase { + + @ParameterizedTest + @EnumSource(SpecMilestone.class) + public void startFromMergedStatePerMilestoneUsingTerminalBlockHash( + final SpecMilestone specMilestone) throws Exception { + if (specMilestone.isGreaterThanOrEqualTo(SpecMilestone.CAPELLA)) { + final TekuNodeConfig config = + createTekuNodeBuilderForMilestone(specMilestone) + .withTerminalBlockHash( + "0x00000000000000000000000000000000000000000000000000000000000000aa") + .withStubExecutionEngine() + .build(); + + final TekuBeaconNode node = createTekuBeaconNode(config); + + node.start(); + node.waitForNonDefaultExecutionPayload(); + node.waitForNewBlock(); + } + } + + @ParameterizedTest + @EnumSource(SpecMilestone.class) + public void startFromMergedStatePerMilestoneUsingTotalDifficultySimulation( + final SpecMilestone specMilestone) throws Exception { + if (specMilestone.isGreaterThanOrEqualTo(SpecMilestone.CAPELLA)) { + final TekuNodeConfig config = + createTekuNodeBuilderForMilestone(specMilestone).withStubExecutionEngine().build(); + + final TekuBeaconNode node = createTekuBeaconNode(config); + + node.start(); + node.waitForNonDefaultExecutionPayload(); + node.waitForNewBlock(); + } + } + + private static TekuNodeConfigBuilder createTekuNodeBuilderForMilestone( + final SpecMilestone specMilestone) throws Exception { + final TekuNodeConfigBuilder tekuNodeConfigBuilder = + TekuNodeConfigBuilder.createBeaconNode() + .withRealNetwork() + .withNetwork("minimal") + .withAltairEpoch(UInt64.ZERO) + .withBellatrixEpoch(UInt64.ZERO) + .withTotalTerminalDifficulty(0) + .withStartupTargetPeerCount(0) + .withInteropNumberOfValidators(64) + .withValidatorProposerDefaultFeeRecipient("0xFE3B557E8Fb62b89F4916B721be55cEb828dBd73"); + + switch (specMilestone) { + // We do not need to consider PHASE0, ALTAIR or BELLATRIX as they are all pre-Merge + // milestones + case CAPELLA: + tekuNodeConfigBuilder.withCapellaEpoch(UInt64.ZERO); + break; + case DENEB: + tekuNodeConfigBuilder.withCapellaEpoch(UInt64.ZERO); + tekuNodeConfigBuilder.withDenebEpoch(UInt64.ZERO); + break; + case ELECTRA: + tekuNodeConfigBuilder.withCapellaEpoch(UInt64.ZERO); + tekuNodeConfigBuilder.withDenebEpoch(UInt64.ZERO); + tekuNodeConfigBuilder.withElectraEpoch(UInt64.ZERO); + break; + default: + // Test will reach this whenever a new milestone is added and isn't mapped on the switch. + // This is a way to force us to always remember to validate that a new milestone can start + // from a merged + // state. + fail("Milestone %s not used on merged genesis interop test", specMilestone); + } + return tekuNodeConfigBuilder; + } +} diff --git a/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/RemoteValidatorCompatibilityAcceptanceTest.java b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/RemoteValidatorCompatibilityAcceptanceTest.java index 5980eae48be..862291aa32f 100644 --- a/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/RemoteValidatorCompatibilityAcceptanceTest.java +++ b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/RemoteValidatorCompatibilityAcceptanceTest.java @@ -29,7 +29,7 @@ public class RemoteValidatorCompatibilityAcceptanceTest extends AcceptanceTestBa @Test void shouldRunUpdatedValidatorAgainstOldBeaconNode() throws Exception { - verifyCompatibility(TekuDockerVersion.V23_9_0, TekuDockerVersion.LOCAL_BUILD); + verifyCompatibility(TekuDockerVersion.V24_2_0, TekuDockerVersion.LOCAL_BUILD); } @Test diff --git a/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/ValidatorClientServiceAcceptanceTest.java b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/ValidatorClientServiceAcceptanceTest.java index 8fef3fb4c24..644c53dac80 100644 --- a/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/ValidatorClientServiceAcceptanceTest.java +++ b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/ValidatorClientServiceAcceptanceTest.java @@ -49,6 +49,23 @@ void shouldFailWithNoValidatorKeysWhenExitOptionEnabledOnBeaconNode() throws Exc "No loaded validators when --exit-when-no-validator-keys-enabled option is true"); } + @Test + void shouldFailWithNoValidatorKeysSourceProvidedOnValidatorClient() throws Exception { + final TekuBeaconNode beaconNode = createTekuBeaconNode(); + + final TekuValidatorNode validatorClient = + createValidatorNode( + TekuNodeConfigBuilder.createValidatorClient() + .withInteropModeDisabled() + .withBeaconNodes(beaconNode) + .build()); + beaconNode.start(); + validatorClient.startWithFailure( + "No validator keys source provided, should provide local or remote keys otherwise enable the key-manager" + + " api to start the validator client"); + beaconNode.stop(); + } + @Test void bn_shouldFailIfValidatorKeyLocked(@TempDir final Path tempDir) throws Exception { final String networkName = "swift"; @@ -145,6 +162,7 @@ void shouldFailWithNoValidatorKeysWhenExitOptionEnabledOnValidatorClient() throw TekuNodeConfigBuilder.createValidatorClient() .withInteropModeDisabled() .withBeaconNodes(beaconNode) + .withValidatorApiEnabled() .withExitWhenNoValidatorKeysEnabled(true) .build()); beaconNode.start(); diff --git a/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/ValidatorConsolidationAcceptanceTest.java b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/ValidatorConsolidationAcceptanceTest.java new file mode 100644 index 00000000000..70c6f96c7d8 --- /dev/null +++ b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/ValidatorConsolidationAcceptanceTest.java @@ -0,0 +1,140 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.test.acceptance; + +import com.google.common.io.Resources; +import java.net.URL; +import java.util.Map; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.ethereum.execution.types.Eth1Address; +import tech.pegasys.teku.infrastructure.time.SystemTimeProvider; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.test.acceptance.dsl.AcceptanceTestBase; +import tech.pegasys.teku.test.acceptance.dsl.BesuDockerVersion; +import tech.pegasys.teku.test.acceptance.dsl.BesuNode; +import tech.pegasys.teku.test.acceptance.dsl.GenesisGenerator.InitialStateData; +import tech.pegasys.teku.test.acceptance.dsl.TekuBeaconNode; +import tech.pegasys.teku.test.acceptance.dsl.TekuNodeConfig; +import tech.pegasys.teku.test.acceptance.dsl.TekuNodeConfigBuilder; +import tech.pegasys.teku.test.acceptance.dsl.tools.deposits.ValidatorKeys; +import tech.pegasys.teku.test.acceptance.dsl.tools.deposits.ValidatorKeystores; + +public class ValidatorConsolidationAcceptanceTest extends AcceptanceTestBase { + + private static final String NETWORK_NAME = "swift"; + private static final URL JWT_FILE = Resources.getResource("auth/ee-jwt-secret.hex"); + + @Test + @Disabled("Flaky test - under investigation") + void consolidateValidator() throws Exception { + final UInt64 currentTime = new SystemTimeProvider().getTimeInSeconds(); + final int genesisTime = + currentTime.intValue() + 30; // genesis in 30 seconds to give node time to start + + final BesuNode besuNode = createBesuNode(genesisTime); + besuNode.start(); + + final String eth1Address = + besuNode.getRichBenefactorAddress(); // used as withdrawal_credentials + final String eth1PrivateKey = + besuNode.getRichBenefactorKey(); // key for withdrawal_credentials account + + // 192 validators (32 eth each) is the minimum number required to enable us to have enough limit + // to consolidate + final ValidatorKeystores validatorKeys = + createTekuDepositSender(NETWORK_NAME) + .generateValidatorKeys(192, Eth1Address.fromHexString(eth1Address)); + + final InitialStateData initialStateData = + createGenesisGenerator() + .network(NETWORK_NAME) + .withGenesisTime(genesisTime) + .genesisDelaySeconds(0) + .withAltairEpoch(UInt64.ZERO) + .withBellatrixEpoch(UInt64.ZERO) + .withCapellaEpoch(UInt64.ZERO) + .withDenebEpoch(UInt64.ZERO) + .withElectraEpoch(UInt64.ZERO) + .withTotalTerminalDifficulty(0) + .genesisExecutionPayloadHeaderSource(besuNode::createGenesisExecutionPayload) + .validatorKeys(validatorKeys) + .generate(); + + final TekuBeaconNode tekuNode = + createTekuBeaconNode(beaconNode(genesisTime, besuNode, initialStateData, validatorKeys)); + tekuNode.start(); + // Ensures sourceValidator is active long enough to exit + tekuNode.waitForNewFinalization(); + + final ValidatorKeys sourceValidator = validatorKeys.getValidatorKeys().get(0); + final BLSPublicKey sourceValidatorPubkey = sourceValidator.getValidatorKey().getPublicKey(); + + final ValidatorKeys targetValidator = validatorKeys.getValidatorKeys().get(1); + final BLSPublicKey targetValidatorPubkey = targetValidator.getValidatorKey().getPublicKey(); + + besuNode.createConsolidationRequest( + eth1PrivateKey, sourceValidatorPubkey, targetValidatorPubkey); + waitForValidatorExit(tekuNode, sourceValidatorPubkey); + } + + private void waitForValidatorExit( + final TekuBeaconNode tekuNode, final BLSPublicKey validatorPubkey) { + final String pubKeySubstring = validatorPubkey.toHexString().substring(2, 9); + tekuNode.waitForLogMessageContaining( + "Validator " + + pubKeySubstring + + " has changed status from active_ongoing to active_exiting"); + } + + private BesuNode createBesuNode(final int genesisTime) { + final Map genesisOverrides = Map.of("pragueTime", String.valueOf(genesisTime)); + + return createBesuNode( + BesuDockerVersion.STABLE, + config -> + config + .withMergeSupport() + .withGenesisFile("besu/pragueGenesis.json") + .withP2pEnabled(true) + .withJwtTokenAuthorization(JWT_FILE), + genesisOverrides); + } + + private static TekuNodeConfig beaconNode( + final int genesisTime, + final BesuNode besuNode, + final InitialStateData initialStateData, + final ValidatorKeystores validatorKeys) + throws Exception { + return TekuNodeConfigBuilder.createBeaconNode() + .withInitialState(initialStateData) + .withNetwork(NETWORK_NAME) + .withAltairEpoch(UInt64.ZERO) + .withBellatrixEpoch(UInt64.ZERO) + .withCapellaEpoch(UInt64.ZERO) + .withDenebEpoch(UInt64.ZERO) + .withElectraEpoch(UInt64.ZERO) + .withTotalTerminalDifficulty(0) + .withGenesisTime(genesisTime) + .withExecutionEngine(besuNode) + .withJwtSecretFile(JWT_FILE) + .withReadOnlyKeystorePath(validatorKeys) + .withValidatorProposerDefaultFeeRecipient("0xFE3B557E8Fb62b89F4916B721be55cEb828dBd73") + .withStartupTargetPeerCount(0) + .withRealNetwork() + .build(); + } +} diff --git a/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/validatorslashing/MultiPeersStandAloneVcBlocksAcceptanceTest.java b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/validatorslashing/MultiPeersStandAloneVcBlocksAcceptanceTest.java index abe7d557cb7..c63f5532783 100644 --- a/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/validatorslashing/MultiPeersStandAloneVcBlocksAcceptanceTest.java +++ b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/validatorslashing/MultiPeersStandAloneVcBlocksAcceptanceTest.java @@ -17,7 +17,6 @@ import org.junit.jupiter.params.provider.MethodSource; import tech.pegasys.teku.bls.BLSKeyPair; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.test.acceptance.dsl.TekuBeaconNode; import tech.pegasys.teku.test.acceptance.dsl.TekuNodeConfigBuilder; import tech.pegasys.teku.test.acceptance.dsl.TekuValidatorNode; @@ -39,8 +38,7 @@ public class MultiPeersStandAloneVcBlocksAcceptanceTest shouldShutDownWhenOwnedValidatorSlashed_StandAloneVC_MultiplePeers_SlashingThroughBlock_NoSlashingEventsGossip( final SlashingEventType slashingEventType) throws Exception { - final int genesisTime = timeProvider.getTimeInSeconds().plus(10).intValue(); - final UInt64 altairEpoch = UInt64.valueOf(100); + final int genesisTime = timeProvider.getTimeInSeconds().plus(30).intValue(); final TekuBeaconNode firstTekuNode = createTekuBeaconNode( @@ -48,34 +46,17 @@ public class MultiPeersStandAloneVcBlocksAcceptanceTest .withGenesisTime(genesisTime) .withNetwork(network) .withRealNetwork() - .withAltairEpoch(altairEpoch) + .withSubscribeAllSubnetsEnabled() .withInteropValidators(0, 32) .build()); - firstTekuNode.start(); - - firstTekuNode.waitForEpochAtOrAbove(2); - - final int slashedValidatorIndex = 34; - final BLSKeyPair slashedValidatorKeyPair = getBlsKeyPair(slashedValidatorIndex); - final int slotInThirdEpoch = - firstTekuNode.getSpec().forMilestone(SpecMilestone.ALTAIR).getSlotsPerEpoch() * 2 + 3; - - postSlashing( - firstTekuNode, - UInt64.valueOf(slotInThirdEpoch), - UInt64.valueOf(slashedValidatorIndex), - slashedValidatorKeyPair.getSecretKey(), - slashingEventType); - final TekuBeaconNode secondBeaconNode = createTekuBeaconNode( TekuNodeConfigBuilder.createBeaconNode() .withGenesisTime(genesisTime) .withNetwork(network) .withRealNetwork() - .withRealNetwork() - .withAltairEpoch(altairEpoch) + .withSubscribeAllSubnetsEnabled() .withPeers(firstTekuNode) .build()); @@ -89,10 +70,23 @@ public class MultiPeersStandAloneVcBlocksAcceptanceTest .withBeaconNodes(secondBeaconNode) .build()); + firstTekuNode.start(); secondBeaconNode.start(); - secondValidatorClient.start(); + firstTekuNode.waitForEpochAtOrAbove(1); + + final int slashedValidatorIndex = 34; + final BLSKeyPair slashedValidatorKeyPair = getBlsKeyPair(slashedValidatorIndex); + final int slotInSecondEpoch = firstTekuNode.getSpec().getGenesisSpec().getSlotsPerEpoch() + 3; + + postSlashing( + firstTekuNode, + UInt64.valueOf(slotInSecondEpoch), + UInt64.valueOf(slashedValidatorIndex), + slashedValidatorKeyPair.getSecretKey(), + slashingEventType); + secondValidatorClient.waitForLogMessageContaining( String.format(slashingActionLog, slashedValidatorKeyPair.getPublicKey().toHexString())); diff --git a/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/validatorslashing/ValidatorSlashingDetectionAcceptanceTest.java b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/validatorslashing/ValidatorSlashingDetectionAcceptanceTest.java index 22d2c7f2665..7259cdbd201 100644 --- a/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/validatorslashing/ValidatorSlashingDetectionAcceptanceTest.java +++ b/acceptance-tests/src/acceptance-test/java/tech/pegasys/teku/test/acceptance/validatorslashing/ValidatorSlashingDetectionAcceptanceTest.java @@ -47,11 +47,11 @@ public class ValidatorSlashingDetectionAcceptanceTest extends AcceptanceTestBase final String slashingActionLog = "Validator slashing detection is enabled and validator(s) with public key(s) %s detected as slashed. " + "Shutting down..."; - final int shutdownWaitingSeconds = 60; + final int shutdownWaitingSeconds = 90; enum SlashingEventType { PROPOSER_SLASHING, - ATTESTER_SLASHING; + ATTESTER_SLASHING } static Stream getSlashingEventTypes() { @@ -72,10 +72,10 @@ void postSlashing( final SlashingEventType slashingEventType) throws IOException { switch (slashingEventType) { - case ATTESTER_SLASHING -> tekuNode.postAttesterSlashing( - slashingSlot, slashedIndex, slashedValidatorSecretKey); - case PROPOSER_SLASHING -> tekuNode.postProposerSlashing( - slashingSlot, slashedIndex, slashedValidatorSecretKey); + case ATTESTER_SLASHING -> + tekuNode.postAttesterSlashing(slashingSlot, slashedIndex, slashedValidatorSecretKey); + case PROPOSER_SLASHING -> + tekuNode.postProposerSlashing(slashingSlot, slashedIndex, slashedValidatorSecretKey); } } } diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/BesuDockerVersion.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/BesuDockerVersion.java index 0d4535d84a8..093f87b8a57 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/BesuDockerVersion.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/BesuDockerVersion.java @@ -14,7 +14,8 @@ package tech.pegasys.teku.test.acceptance.dsl; public enum BesuDockerVersion { - STABLE("23.10.1"); + STABLE("24.9.1"), + DEVELOP("develop"); private final String version; diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/BesuNode.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/BesuNode.java index 3e28f867512..044dc133182 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/BesuNode.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/BesuNode.java @@ -13,7 +13,6 @@ package tech.pegasys.teku.test.acceptance.dsl; -import com.fasterxml.jackson.databind.JavaType; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.dataformat.toml.TomlMapper; import com.google.common.io.Resources; @@ -23,6 +22,7 @@ import java.net.URI; import java.net.URL; import java.nio.charset.StandardCharsets; +import java.time.Duration; import java.util.ArrayList; import java.util.HashMap; import java.util.List; @@ -36,10 +36,17 @@ import org.testcontainers.containers.Network; import org.testcontainers.containers.wait.strategy.HttpWaitStrategy; import org.testcontainers.utility.MountableFile; +import org.web3j.crypto.Credentials; +import org.web3j.protocol.core.methods.response.TransactionReceipt; +import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.ethereum.execution.types.Eth1Address; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.async.Waiter; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; import tech.pegasys.teku.spec.datastructures.interop.MergedGenesisTestBuilder; +import tech.pegasys.teku.test.acceptance.dsl.executionrequests.ExecutionRequestsService; public class BesuNode extends Node { @@ -119,6 +126,20 @@ public Eth1Address getDepositContractAddress() { return Eth1Address.fromHexString("0xdddddddddddddddddddddddddddddddddddddddd"); } + /* + Defined on https://eips.ethereum.org/EIPS/eip-7002 (WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS) + */ + public Eth1Address getWithdrawalRequestContractAddress() { + return Eth1Address.fromHexString("0x00A3ca265EBcb825B45F985A16CEFB49958cE017"); + } + + /* + Defined on https://eips.ethereum.org/EIPS/eip-7251 (CONSOLIDATION_REQUEST_PREDEPLOY_ADDRESS) + */ + public Eth1Address getConsolidationRequestContractAddress() { + return Eth1Address.fromHexString("0x00b42dbF2194e931E80326D950320f7d9Dbeac02"); + } + public String getInternalJsonRpcUrl() { return "http://" + nodeAlias + ":" + JSON_RPC_PORT; } @@ -131,10 +152,6 @@ public String getInternalEngineJsonRpcUrl() { return "http://" + nodeAlias + ":" + ENGINE_JSON_RPC_PORT; } - public String getInternalEngineWebsocketsRpcUrl() { - return "ws://" + nodeAlias + ":" + ENGINE_JSON_RPC_PORT; - } - private String getInternalP2pUrl(final String nodeId) { return "enode://" + nodeId + "@" + getInternalIpAddress() + ":" + P2P_PORT; } @@ -149,15 +166,9 @@ private String getInternalIpAddress() { private String fetchEnodeUrl() throws Exception { final URI baseUri = new URI(getExternalJsonRpcUrl()); final String response = - httpClient.post(baseUri, "", JSON_PROVIDER.objectToJSON(new Request("admin_nodeInfo"))); - final ObjectMapper objectMapper = JSON_PROVIDER.getObjectMapper(); - final JavaType nodeInfoResponseType = - objectMapper - .getTypeFactory() - .constructParametricType(Response.class, NodeInfoResponse.class); - final Response nodeInfoResponse = - objectMapper.readValue(response, nodeInfoResponseType); - return getInternalP2pUrl(nodeInfoResponse.result.id); + httpClient.post( + baseUri, "", OBJECT_MAPPER.writeValueAsString(new Request("admin_nodeInfo"))); + return getInternalP2pUrl(OBJECT_MAPPER.readTree(response).get("result").get("id").asText()); } public Boolean addPeer(final BesuNode node) throws Exception { @@ -165,13 +176,12 @@ public Boolean addPeer(final BesuNode node) throws Exception { final URI baseUri = new URI(getExternalJsonRpcUrl()); final String response = httpClient.post( - baseUri, "", JSON_PROVIDER.objectToJSON(new Request("admin_addPeer", enode))); - final ObjectMapper objectMapper = JSON_PROVIDER.getObjectMapper(); - final JavaType removePeerResponseType = - objectMapper.getTypeFactory().constructParametricType(Response.class, Boolean.class); - final Response removePeerResponse = - objectMapper.readValue(response, removePeerResponseType); - return removePeerResponse.result; + baseUri, "", OBJECT_MAPPER.writeValueAsString(new Request("admin_addPeer", enode))); + return OBJECT_MAPPER.readTree(response).get("result").asBoolean(); + } + + public String getRichBenefactorAddress() { + return "0xfe3b557e8fb62b89f4916b721be55ceb828dbd73"; } public String getRichBenefactorKey() { @@ -189,6 +199,62 @@ public ExecutionPayloadHeader createGenesisExecutionPayload(final Spec spec) { } } + /** + * Sends a transaction to the withdrawal request contract in the execution layer to create a + * withdrawal request. + * + * @param eth1PrivateKey the private key of the eth1 account that will sign the transaction to the + * withdrawal contract (has to match the validator withdrawal credentials) + * @param publicKey validator public key + * @param amountInGwei the amount for the withdrawal request (zero for full withdrawal, greater + * than zero for partial withdrawal) + */ + public void createWithdrawalRequest( + final String eth1PrivateKey, final BLSPublicKey publicKey, final UInt64 amountInGwei) + throws Exception { + final Credentials eth1Credentials = Credentials.create(eth1PrivateKey); + try (final ExecutionRequestsService executionRequestsService = + new ExecutionRequestsService( + getExternalJsonRpcUrl(), + eth1Credentials, + getWithdrawalRequestContractAddress(), + getConsolidationRequestContractAddress())) { + + final SafeFuture future = + executionRequestsService.createWithdrawalRequest(publicKey, amountInGwei); + Waiter.waitFor(future, Duration.ofMinutes(1)); + } + } + + /** + * Sends a transaction to the consolidation request contract in the execution layer to create a + * consolidation request. + * + * @param eth1PrivateKey the private key of the eth1 account that will sign the transaction to the + * consolidation contract (has to match the source validator withdrawal credentials) + * @param sourceValidatorPublicKey source validator public key + * @param targetValidatorPublicKey target validator public key + */ + public void createConsolidationRequest( + final String eth1PrivateKey, + final BLSPublicKey sourceValidatorPublicKey, + final BLSPublicKey targetValidatorPublicKey) + throws Exception { + final Credentials eth1Credentials = Credentials.create(eth1PrivateKey); + try (final ExecutionRequestsService executionRequestsService = + new ExecutionRequestsService( + getExternalJsonRpcUrl(), + eth1Credentials, + getWithdrawalRequestContractAddress(), + getConsolidationRequestContractAddress())) { + + final SafeFuture future = + executionRequestsService.createConsolidationRequest( + sourceValidatorPublicKey, targetValidatorPublicKey); + Waiter.waitFor(future, Duration.ofMinutes(1)); + } + } + @SuppressWarnings("unused") private static class Request { @@ -198,23 +264,13 @@ private static class Request { private static final AtomicInteger ID_COUNTER = new AtomicInteger(0); public final int id; - public Request(String method, String... params) { + public Request(final String method, final String... params) { this.method = method; this.params = params; this.id = ID_COUNTER.incrementAndGet(); } } - private static class Response { - - public T result; - } - - private static class NodeInfoResponse { - - public String id; - } - public static class Config { private static final String[] MERGE_RPC_MODULES = new String[] {"ETH,NET,WEB3,ENGINE,ADMIN"}; @@ -252,7 +308,7 @@ public BesuNode.Config withMergeSupport() { } public BesuNode.Config withJwtTokenAuthorization(final URL jwtFile) { - configMap.put("engine-jwt-enabled", Boolean.TRUE); + configMap.put("engine-jwt-disabled", Boolean.FALSE); configMap.put("engine-jwt-secret", JWT_SECRET_FILE_PATH); this.maybeJwtFile = Optional.of(jwtFile); return this; diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/ExternalMetricNode.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/ExternalMetricNode.java index 0a970387c43..a5fa2f84734 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/ExternalMetricNode.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/ExternalMetricNode.java @@ -16,7 +16,6 @@ import static org.assertj.core.api.Assertions.assertThat; import com.fasterxml.jackson.databind.JsonNode; -import com.fasterxml.jackson.databind.ObjectMapper; import com.google.common.collect.ImmutableList; import java.io.IOException; import java.net.URI; @@ -42,7 +41,7 @@ public class ExternalMetricNode extends Node { private boolean started = false; - private ExternalMetricNode(Network network, ImageFromDockerfile image) { + private ExternalMetricNode(final Network network, final ImageFromDockerfile image) { super(network, image, LOG); container.withWorkingDirectory(WORKING_DIRECTORY).withExposedPorts(STUB_PORT); } @@ -71,8 +70,7 @@ public String getResponse() throws URISyntaxException, IOException { private List> getPublishedObjects() throws URISyntaxException, IOException { String response = getResponse(); LOG.debug("Metric data was published " + response); - final ObjectMapper mapper = JSON_PROVIDER.getObjectMapper(); - JsonNode node = mapper.readTree(response); + JsonNode node = OBJECT_MAPPER.readTree(response); final List> result = new ArrayList<>(); assertThat(node.isArray()).isTrue(); for (JsonNode child : ImmutableList.copyOf(node.elements())) { diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/GenesisGenerator.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/GenesisGenerator.java index 5a196b5fc85..4b1dad82f78 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/GenesisGenerator.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/GenesisGenerator.java @@ -19,6 +19,7 @@ import java.util.Collections; import java.util.Optional; import java.util.function.Consumer; +import java.util.function.Function; import java.util.stream.Stream; import org.apache.tuweni.units.bigints.UInt256; import tech.pegasys.teku.infrastructure.time.SystemTimeProvider; @@ -26,6 +27,7 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecFactory; import tech.pegasys.teku.spec.config.builder.SpecConfigBuilder; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; import tech.pegasys.teku.spec.datastructures.interop.GenesisStateBuilder; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.test.acceptance.dsl.tools.deposits.ValidatorKeystores; @@ -35,8 +37,10 @@ public class GenesisGenerator { private final SystemTimeProvider timeProvider = new SystemTimeProvider(); private String network; private ValidatorKeystores validatorKeys; - private Optional genesisPayloadSource = Optional.empty(); + private Optional> genesisExecutionPayloadHeaderSource = + Optional.empty(); private int genesisDelaySeconds = 10; + private Optional genesisTime = Optional.empty(); private Consumer specConfigModifier = builder -> {}; public GenesisGenerator network(final String network) { @@ -44,6 +48,11 @@ public GenesisGenerator network(final String network) { return this; } + public GenesisGenerator withGenesisTime(final Integer genesisTime) { + this.genesisTime = Optional.of(genesisTime); + return this; + } + public GenesisGenerator withAltairEpoch(final UInt64 altairForkEpoch) { specConfigModifier = specConfigModifier.andThen( @@ -80,12 +89,12 @@ public GenesisGenerator withDenebEpoch(final UInt64 denebForkEpoch) { return this; } - public GenesisGenerator withEip7594Epoch(final UInt64 eip7594ForkEpoch) { + public GenesisGenerator withElectraEpoch(final UInt64 electraForkEpoch) { specConfigModifier = specConfigModifier.andThen( specConfigBuilder -> - specConfigBuilder.eip7594Builder( - eip7594Builder -> eip7594Builder.eip7594ForkEpoch(eip7594ForkEpoch))); + specConfigBuilder.electraBuilder( + electraBuilder -> electraBuilder.electraForkEpoch(electraForkEpoch))); return this; } @@ -115,8 +124,9 @@ public GenesisGenerator genesisDelaySeconds(final int genesisDelaySeconds) { return this; } - public GenesisGenerator genesisPayloadSource(final BesuNode genesisPayloadSource) { - this.genesisPayloadSource = Optional.of(genesisPayloadSource); + public GenesisGenerator genesisExecutionPayloadHeaderSource( + final Function genesisExecutionPayloadHeaderSource) { + this.genesisExecutionPayloadHeaderSource = Optional.of(genesisExecutionPayloadHeaderSource); return this; } @@ -125,16 +135,20 @@ public InitialStateData generate() { final GenesisStateBuilder genesisBuilder = new GenesisStateBuilder(); genesisBuilder .spec(spec) - .genesisTime(timeProvider.getTimeInSeconds().plus(genesisDelaySeconds)); + .genesisTime( + genesisTime + .map(UInt64::valueOf) + .orElse(timeProvider.getTimeInSeconds().plus(genesisDelaySeconds))); validatorKeys .getValidatorKeys() .forEach( validator -> genesisBuilder.addValidator( validator.getValidatorKey(), validator.getWithdrawalCredentials())); - genesisPayloadSource.ifPresent( - source -> - genesisBuilder.executionPayloadHeader(source.createGenesisExecutionPayload(spec))); + + genesisExecutionPayloadHeaderSource.ifPresent( + source -> genesisBuilder.executionPayloadHeader(source.apply(spec))); + return new InitialStateData(genesisBuilder.build()); } diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/Node.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/Node.java index daea4c333d2..833de80aaf8 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/Node.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/Node.java @@ -29,7 +29,6 @@ import java.net.URI; import java.net.URL; import java.nio.file.Files; -import java.time.Duration; import java.util.List; import java.util.Locale; import java.util.concurrent.TimeUnit; @@ -44,7 +43,6 @@ import org.testcontainers.images.PullPolicy; import org.testcontainers.images.builder.ImageFromDockerfile; import tech.pegasys.teku.infrastructure.async.Waiter; -import tech.pegasys.teku.provider.JsonProvider; import tech.pegasys.teku.test.acceptance.dsl.metrics.MetricConditions.MetricLabelsCondition; import tech.pegasys.teku.test.acceptance.dsl.metrics.MetricConditions.MetricNameCondition; import tech.pegasys.teku.test.acceptance.dsl.metrics.MetricConditions.MetricValuesCondition; @@ -56,7 +54,7 @@ public abstract class Node { private static final Logger LOG = LogManager.getLogger(); public static final String TEKU_DOCKER_IMAGE_NAME = "consensys/teku"; - protected static final JsonProvider JSON_PROVIDER = new JsonProvider(); + protected static final ObjectMapper OBJECT_MAPPER = new ObjectMapper(); protected final SimpleHttpClient httpClient = new SimpleHttpClient(); protected static final int REST_API_PORT = 9051; protected static final int METRICS_PORT = 8008; @@ -88,10 +86,7 @@ protected Node(final Network network, final String dockerImage, final Logger log getClass().getSimpleName().toLowerCase(Locale.US) + NODE_UNIQUIFIER.incrementAndGet(); this.container = new NodeContainer(dockerImage) - .withImagePullPolicy( - dockerImage.endsWith(TekuDockerVersion.LOCAL_BUILD.getVersion()) - ? PullPolicy.defaultPolicy() - : PullPolicy.ageBased(Duration.ofMinutes(5))) + .withImagePullPolicy(PullPolicy.defaultPolicy()) .withNetwork(network) .withNetworkAliases(nodeAlias) .withLogConsumer(frame -> log.debug(frame.getUtf8String().trim())); @@ -251,7 +246,7 @@ protected static File copyToTmpFile(final URL fileUrl) throws Exception { } /** Copies contents of the given directory into node's working directory. */ - public void copyContentsToWorkingDirectory(File tarFile) { + public void copyContentsToWorkingDirectory(final File tarFile) { container.withExpandedTarballToContainer(tarFile, WORKING_DIRECTORY); } diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/SentryNodesConfig.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/SentryNodesConfig.java index af0ee01bbe0..10d09c14d1c 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/SentryNodesConfig.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/SentryNodesConfig.java @@ -14,13 +14,13 @@ package tech.pegasys.teku.test.acceptance.dsl; import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.stream.Collectors; -import tech.pegasys.teku.provider.JsonProvider; public class SentryNodesConfig { @@ -37,7 +37,7 @@ private SentryNodesConfig( this.attestationPublisherNodes = attestationPublisherNodes; } - public String toJson(final JsonProvider jsonProvider) throws JsonProcessingException { + public String toJson(final ObjectMapper objectMapper) throws JsonProcessingException { final HashMap config = new HashMap<>(); final Map beaconNodes = new HashMap<>(); @@ -55,7 +55,7 @@ public String toJson(final JsonProvider jsonProvider) throws JsonProcessingExcep config.put("beacon_nodes", beaconNodes); - return jsonProvider.objectToJSON(config); + return objectMapper.writeValueAsString(config); } public static class Builder { @@ -64,7 +64,7 @@ public static class Builder { private List blockHandlerNodes = new ArrayList<>(); private List attestationPublisherNodes = new ArrayList<>(); - public Builder withDutiesProviders(TekuBeaconNode... nodes) { + public Builder withDutiesProviders(final TekuBeaconNode... nodes) { dutiesProviderNodes = Arrays.stream(nodes) .map(TekuBeaconNode::getBeaconRestApiUrl) @@ -72,7 +72,7 @@ public Builder withDutiesProviders(TekuBeaconNode... nodes) { return this; } - public Builder withBlockHandlers(TekuBeaconNode... nodes) { + public Builder withBlockHandlers(final TekuBeaconNode... nodes) { blockHandlerNodes = Arrays.stream(nodes) .map(TekuBeaconNode::getBeaconRestApiUrl) @@ -80,7 +80,7 @@ public Builder withBlockHandlers(TekuBeaconNode... nodes) { return this; } - public Builder withAttestationPublisher(TekuBeaconNode... nodes) { + public Builder withAttestationPublisher(final TekuBeaconNode... nodes) { attestationPublisherNodes = Arrays.stream(nodes) .map(TekuBeaconNode::getBeaconRestApiUrl) diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/SimpleHttpClient.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/SimpleHttpClient.java index d4af0315f0b..042caedc3ac 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/SimpleHttpClient.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/SimpleHttpClient.java @@ -44,13 +44,13 @@ public String get(final URI baseUrl, final String path) throws IOException { return this.get(baseUrl, path, Collections.emptyMap()); } - public String get(final URI baseUrl, final String path, Map headers) + public String get(final URI baseUrl, final String path, final Map headers) throws IOException { final ResponseBody body = getResponseBody(baseUrl, path, headers); return body.string(); } - public Bytes getAsBytes(final URI baseUrl, final String path, Map headers) + public Bytes getAsBytes(final URI baseUrl, final String path, final Map headers) throws IOException { final ResponseBody body = getResponseBody(baseUrl, path, headers); return Bytes.wrap(body.bytes()); @@ -79,7 +79,10 @@ public String post(final URI baseUrl, final String path, final String jsonBody) } public String post( - final URI baseUrl, final String path, final String jsonBody, Map headers) + final URI baseUrl, + final String path, + final String jsonBody, + final Map headers) throws IOException { final RequestBody requestBody = RequestBody.create(jsonBody, JSON); final Request.Builder builder = @@ -98,7 +101,10 @@ public String post( } public String delete( - final URI baseUrl, final String path, final String jsonBody, Map headers) + final URI baseUrl, + final String path, + final String jsonBody, + final Map headers) throws IOException { final RequestBody requestBody = RequestBody.create(jsonBody, JSON); diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TekuBeaconNode.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TekuBeaconNode.java index cec4c8294f7..ca23f2793ce 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TekuBeaconNode.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TekuBeaconNode.java @@ -19,11 +19,13 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.fail; +import static tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition.listOf; import static tech.pegasys.teku.test.acceptance.dsl.metrics.MetricConditions.withLabelValueSubstring; import static tech.pegasys.teku.test.acceptance.dsl.metrics.MetricConditions.withNameEqualsTo; import static tech.pegasys.teku.test.acceptance.dsl.metrics.MetricConditions.withValueGreaterThan; import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; import it.unimi.dsi.fastutil.objects.Object2BooleanMap; import it.unimi.dsi.fastutil.objects.Object2BooleanOpenHashMap; import java.io.File; @@ -31,16 +33,14 @@ import java.time.Duration; import java.util.ArrayList; import java.util.Collection; -import java.util.Collections; import java.util.List; import java.util.Map; import java.util.Optional; import java.util.Set; import java.util.concurrent.atomic.AtomicReference; import java.util.function.Function; -import java.util.function.Predicate; -import java.util.stream.Collectors; import java.util.stream.IntStream; +import java.util.stream.Stream; import org.apache.commons.lang3.tuple.Pair; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; @@ -49,48 +49,35 @@ import org.assertj.core.api.ThrowingConsumer; import org.testcontainers.containers.Network; import org.testcontainers.containers.wait.strategy.HttpWaitStrategy; +import tech.pegasys.teku.api.migrated.ValidatorLivenessAtEpoch; import tech.pegasys.teku.api.response.v1.EventType; -import tech.pegasys.teku.api.response.v1.HeadEvent; -import tech.pegasys.teku.api.response.v1.beacon.FinalityCheckpointsResponse; -import tech.pegasys.teku.api.response.v1.beacon.GenesisData; -import tech.pegasys.teku.api.response.v1.beacon.GetBlockRootResponse; -import tech.pegasys.teku.api.response.v1.beacon.GetGenesisResponse; -import tech.pegasys.teku.api.response.v1.beacon.GetStateFinalityCheckpointsResponse; -import tech.pegasys.teku.api.response.v1.beacon.GetStateValidatorResponse; -import tech.pegasys.teku.api.response.v1.node.SyncingResponse; -import tech.pegasys.teku.api.response.v1.validator.PostValidatorLivenessResponse; -import tech.pegasys.teku.api.response.v1.validator.ValidatorLiveness; -import tech.pegasys.teku.api.response.v2.beacon.GetBlockResponseV2; -import tech.pegasys.teku.api.schema.AttestationData; -import tech.pegasys.teku.api.schema.AttesterSlashing; -import tech.pegasys.teku.api.schema.BLSSignature; -import tech.pegasys.teku.api.schema.BeaconBlockHeader; -import tech.pegasys.teku.api.schema.Checkpoint; -import tech.pegasys.teku.api.schema.IndexedAttestation; -import tech.pegasys.teku.api.schema.ProposerSlashing; -import tech.pegasys.teku.api.schema.SignedBeaconBlock; -import tech.pegasys.teku.api.schema.SignedBeaconBlockHeader; -import tech.pegasys.teku.api.schema.altair.SignedBeaconBlockAltair; -import tech.pegasys.teku.api.schema.altair.SignedContributionAndProof; -import tech.pegasys.teku.api.schema.bellatrix.SignedBeaconBlockBellatrix; -import tech.pegasys.teku.api.schema.interfaces.SignedBlock; import tech.pegasys.teku.bls.BLS; import tech.pegasys.teku.bls.BLSKeyPair; import tech.pegasys.teku.bls.BLSSecretKey; +import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.ethereum.execution.types.Eth1Address; +import tech.pegasys.teku.ethereum.json.types.SharedApiTypes; import tech.pegasys.teku.infrastructure.json.JsonUtil; import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; -import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszBitvectorSchema; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecFactory; import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock; +import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlockHeader; +import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; +import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockHeader; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; +import tech.pegasys.teku.spec.datastructures.operations.AttestationData; +import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; +import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestation; +import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestationSchema; +import tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing; import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChange; +import tech.pegasys.teku.spec.datastructures.state.Checkpoint; import tech.pegasys.teku.spec.datastructures.state.Fork; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; -import tech.pegasys.teku.spec.datastructures.state.Validator; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.bellatrix.BeaconStateBellatrix; import tech.pegasys.teku.spec.generator.BlsToExecutionChangeGenerator; @@ -139,22 +126,13 @@ public Spec getSpec() { } public void waitForContributionAndProofEvent() { - waitForContributionAndProofEvent(proof -> true); - } - - public void waitForContributionAndProofEvent( - final Predicate condition) { waitFor( - () -> { - final List events = getContributionAndProofEvents(); - assertThat(events.stream().filter(condition).findAny()) - .describedAs( - "Did not find contribution and proof event matching condition in %s", events) - .isPresent(); - }); + () -> + assertThat(countContributionAndProofEvents() > 0L) + .describedAs("Did not find contribution and proof events")); } - private List getContributionAndProofEvents() { + private long countContributionAndProofEvents() { return maybeEventStreamListener .map( eventStreamListener -> @@ -164,21 +142,8 @@ private List getContributionAndProofEvents() { packedMessage .getEvent() .equals(EventType.contribution_and_proof.name())) - .map(this::optionalProof) - .flatMap(Optional::stream) - .collect(Collectors.toList())) - .orElse(Collections.emptyList()); - } - - private Optional optionalProof( - final Eth2EventHandler.PackedMessage packedMessage) { - try { - return Optional.of( - JSON_PROVIDER.jsonToObject( - packedMessage.getMessageEvent().getData(), SignedContributionAndProof.class)); - } catch (JsonProcessingException e) { - return Optional.empty(); - } + .count()) + .orElse(0L); } public void waitForGenesis() { @@ -210,9 +175,9 @@ private List getSlotsFromHeadEvents() { private Optional getSlotFromHeadEvent( final Eth2EventHandler.PackedMessage packedMessage) { try { - return Optional.of( - JSON_PROVIDER.jsonToObject(packedMessage.getMessageEvent().getData(), HeadEvent.class) - .slot); + final JsonNode node = OBJECT_MAPPER.readTree(packedMessage.getMessageEvent().getData()); + final UInt64 slot = UInt64.valueOf(node.get("slot").asText()); + return Optional.of(slot); } catch (JsonProcessingException e) { LOG.error("Failed to process head event", e); return Optional.empty(); @@ -220,7 +185,7 @@ private Optional getSlotFromHeadEvent( } public void checkValidatorLiveness( - final int epoch, final int totalValidatorCount, ValidatorLivenessExpectation... args) + final int epoch, final int totalValidatorCount, final ValidatorLivenessExpectation... args) throws IOException { final List validators = new ArrayList<>(); for (UInt64 i = UInt64.ZERO; i.isLessThan(totalValidatorCount); i = i.increment()) { @@ -234,18 +199,21 @@ public void checkValidatorLiveness( } private Object2BooleanMap getValidatorLivenessAtEpoch( - final UInt64 epoch, List validators) throws IOException { + final UInt64 epoch, final List validators) throws IOException { final String response = httpClient.post( getRestApiUrl(), getValidatorLivenessUrl(epoch), - JSON_PROVIDER.objectToJSON(validators)); - final PostValidatorLivenessResponse livenessResponse = - JSON_PROVIDER.jsonToObject(response, PostValidatorLivenessResponse.class); + OBJECT_MAPPER.writeValueAsString(validators.stream().map(UInt64::toString).toList())); + final DeserializableTypeDefinition> type = + SharedApiTypes.withDataWrapper( + "listOfLiveness", listOf(ValidatorLivenessAtEpoch.getJsonTypeDefinition())); + + final List livenessResponse = JsonUtil.parse(response, type); final Object2BooleanMap output = new Object2BooleanOpenHashMap(); - for (ValidatorLiveness entry : livenessResponse.data) { - output.put(entry.index, entry.isLive); + for (ValidatorLivenessAtEpoch entry : livenessResponse) { + output.put(entry.index(), entry.isLive()); } return output; } @@ -258,14 +226,17 @@ public void postProposerSlashing( randomSignedBeaconBlockHeader(slot, index, secretKey, signingRootUtil, forkInfo); final SignedBeaconBlockHeader header2 = randomSignedBeaconBlockHeader(slot, index, secretKey, signingRootUtil, forkInfo); - final ProposerSlashing proposerSlashing = new ProposerSlashing(header1, header2); - final String body = JSON_PROVIDER.objectToJSON(proposerSlashing); + LOG.debug("Inserting proposer slashing for index {} at slot {}", index, slot); + final String body = + JsonUtil.serialize( + new ProposerSlashing(header1, header2), + ProposerSlashing.SSZ_SCHEMA.getJsonTypeDefinition()); httpClient.post(getRestApiUrl(), POST_PROPOSER_SLASHING_URL, body); } private ForkInfo getForkInfo(final UInt64 slot) throws IOException { final Fork fork = spec.getForkSchedule().getFork(spec.computeEpochAtSlot(slot)); - final Bytes32 genesisValidatorRoot = fetchGenesis().getGenesisValidatorsRoot(); + final Bytes32 genesisValidatorRoot = getGenesisValidatorsRoot(); return new ForkInfo(fork, genesisValidatorRoot); } @@ -283,12 +254,18 @@ public void postAttesterSlashing( randomIndexedAttestation( slashingSlot, slashedIndex, slashedValidatorSecretKey, signingRootUtil, forkInfo); final AttesterSlashing attesterSlashing = - new AttesterSlashing(indexedAttestation1, indexedAttestation2); - final String body = JSON_PROVIDER.objectToJSON(attesterSlashing); + spec.getGenesisSchemaDefinitions() + .getAttesterSlashingSchema() + .create(indexedAttestation1, indexedAttestation2); + LOG.debug("Inserting attester slashing for index {} at slot {}", slashedIndex, slashingSlot); + final String body = + JsonUtil.serialize( + attesterSlashing, + spec.getGenesisSchemaDefinitions().getAttesterSlashingSchema().getJsonTypeDefinition()); httpClient.post(getRestApiUrl(), POST_ATTESTER_SLASHING_URL, body); } - private static IndexedAttestation randomIndexedAttestation( + private IndexedAttestation randomIndexedAttestation( final UInt64 slot, final UInt64 index, final BLSSecretKey secretKey, @@ -301,13 +278,18 @@ private static IndexedAttestation randomIndexedAttestation( Bytes32.random(), new Checkpoint(UInt64.valueOf(1), Bytes32.random()), new Checkpoint(UInt64.valueOf(2), Bytes32.random())); + final BLSSignature blsSignature1 = - new BLSSignature( - BLS.sign( - secretKey, - signingRootUtil.signingRootForSignAttestationData( - attestationData.asInternalAttestationData(), forkInfo))); - return new IndexedAttestation(List.of(index), attestationData, blsSignature1); + BLS.sign( + secretKey, + signingRootUtil.signingRootForSignAttestationData(attestationData, forkInfo)); + + final IndexedAttestationSchema schema = + spec.getGenesisSchemaDefinitions().getIndexedAttestationSchema(); + return schema.create( + Stream.of(index).collect(schema.getAttestingIndicesSchema().collectorUnboxed()), + attestationData, + blsSignature1); } private SignedBeaconBlockHeader randomSignedBeaconBlockHeader( @@ -320,10 +302,9 @@ private SignedBeaconBlockHeader randomSignedBeaconBlockHeader( new BeaconBlockHeader(slot, index, Bytes32.random(), Bytes32.random(), Bytes32.random()); final Bytes blockHeaderSigningRoot = - signingRootUtil.signingRootForSignBlockHeader( - beaconBlockHeader.asInternalBeaconBlockHeader(), forkInfo); - final BLSSignature blsSignature = new BLSSignature(BLS.sign(secretKey, blockHeaderSigningRoot)); - return new SignedBeaconBlockHeader(beaconBlockHeader, blsSignature); + signingRootUtil.signingRootForSignBlockHeader(beaconBlockHeader, forkInfo); + return new SignedBeaconBlockHeader( + beaconBlockHeader, BLS.sign(secretKey, blockHeaderSigningRoot)); } public void submitBlsToExecutionChange( @@ -342,7 +323,7 @@ public void submitBlsToExecutionChange( UInt64.valueOf(currentEpoch)); final DeserializableTypeDefinition> jsonTypeDefinition = - DeserializableTypeDefinition.listOf( + listOf( SchemaDefinitionsCapella.required( spec.atEpoch(UInt64.valueOf(currentEpoch)).getSchemaDefinitions()) .getSignedBlsToExecutionChangeSchema() @@ -352,7 +333,7 @@ public void submitBlsToExecutionChange( httpClient.post(getRestApiUrl(), "/eth/v1/beacon/pool/bls_to_execution_changes", body); } - public void waitForBlsToExecutionChangeEventForValidator(int validatorIndex) { + public void waitForBlsToExecutionChangeEventForValidator(final int validatorIndex) { if (maybeEventStreamListener.isEmpty()) { fail( "Must start listening to events before waiting for them... Try calling TekuNode.startEventListener(..)!"); @@ -366,18 +347,32 @@ public void waitForBlsToExecutionChangeEventForValidator(int validatorIndex) { waitFor( () -> { - final List - blsToExecutionChanges = - getEventsOfTypeFromEventStream( - EventType.bls_to_execution_change, this::mapBlsToExecutionChangeFromEvent); - assertThat(blsToExecutionChanges.stream()) - .anyMatch(m -> UInt64.valueOf(validatorIndex).equals(m.message.validatorIndex)); + final List blsToExecutionChanges = + getEventsOfTypeFromEventStream( + EventType.bls_to_execution_change, this::getValidatorIdsFromBlsChange); + assertThat(blsToExecutionChanges.stream()).anyMatch(m -> validatorIndex == m); }); } - private SyncingResponse fetchSyncStatus() throws IOException { - String syncingData = httpClient.get(getRestApiUrl(), "/eth/v1/node/syncing"); - return JSON_PROVIDER.jsonToObject(syncingData, SyncingResponse.class); + private JsonNode fetchSyncingStatus() throws IOException { + final String syncingData = httpClient.get(getRestApiUrl(), "/eth/v1/node/syncing"); + return OBJECT_MAPPER.readTree(syncingData).get("data"); + } + + private boolean getStatusElOffline() throws IOException { + try { + return fetchSyncingStatus().get("el_offline").asBoolean(); + } catch (JsonProcessingException e) { + throw new RuntimeException(e); + } + } + + private boolean getStatusIsSyncing() throws IOException { + try { + return fetchSyncingStatus().get("is_syncing").asBoolean(); + } catch (JsonProcessingException e) { + throw new RuntimeException(e); + } } private List getEventsOfTypeFromEventStream( @@ -392,15 +387,12 @@ private List getEventsOfTypeFromEventStream( .orElseGet(List::of); } - private tech.pegasys.teku.api.schema.capella.SignedBlsToExecutionChange - mapBlsToExecutionChangeFromEvent(final Eth2EventHandler.PackedMessage packedMessage) { + private Integer getValidatorIdsFromBlsChange(final PackedMessage packedMessage) { try { - return JSON_PROVIDER.jsonToObject( - packedMessage.getMessageEvent().getData(), - tech.pegasys.teku.api.schema.capella.SignedBlsToExecutionChange.class); + final JsonNode jsonNode = OBJECT_MAPPER.readTree(packedMessage.getMessageEvent().getData()); + return jsonNode.get("message").get("validator_index").asInt(); } catch (JsonProcessingException e) { - LOG.error("Failed to process bls_to_execution_change event", e); - return null; + throw new RuntimeException(e); } } @@ -412,15 +404,25 @@ public void waitForGenesisTime(final UInt64 expectedGenesisTime) { waitFor(() -> assertThat(fetchGenesisTime()).isEqualTo(expectedGenesisTime)); } - private GenesisData fetchGenesis() throws IOException { - String genesisTime = httpClient.get(getRestApiUrl(), "/eth/v1/beacon/genesis"); - final GetGenesisResponse response = - JSON_PROVIDER.jsonToObject(genesisTime, GetGenesisResponse.class); - return response.data; + public Bytes32 getGenesisValidatorsRoot() throws IOException { + try { + return Bytes32.fromHexString(fetchGenesis().get("genesis_validators_root").asText()); + } catch (JsonProcessingException e) { + throw new RuntimeException(e); + } + } + + private JsonNode fetchGenesis() throws IOException { + final String syncingData = httpClient.get(getRestApiUrl(), "/eth/v1/beacon/genesis"); + return OBJECT_MAPPER.readTree(syncingData).get("data"); } private UInt64 fetchGenesisTime() throws IOException { - return fetchGenesis().genesisTime; + try { + return UInt64.valueOf(fetchGenesis().get("genesis_time").asText()); + } catch (JsonProcessingException e) { + throw new RuntimeException(e); + } } public UInt64 getGenesisTime() throws IOException { @@ -428,10 +430,6 @@ public UInt64 getGenesisTime() throws IOException { return fetchGenesisTime(); } - public Bytes32 getGenesisValidatorsRoot() throws IOException { - return fetchGenesis().getGenesisValidatorsRoot(); - } - public void waitForNewBlock() { final Bytes32 startingBlockRoot = waitForBeaconHead(null); waitFor(() -> assertThat(fetchBeaconHeadRoot().orElseThrow()).isNotEqualTo(startingBlockRoot)); @@ -446,11 +444,11 @@ public void waitForNonOptimisticBlock() { } public void waitForNewFinalization() { - UInt64 startingFinalizedEpoch = waitForChainHead().finalized.epoch; + final UInt64 startingFinalizedEpoch = getFinalizedEpoch().orElse(UInt64.ZERO); LOG.debug("Wait for finalized block"); waitFor( () -> - assertThat(fetchStateFinalityCheckpoints().orElseThrow().finalized.epoch) + assertThat(getFinalizedEpoch().orElse(UInt64.ZERO)) .isNotEqualTo(startingFinalizedEpoch), 9, MINUTES); @@ -465,32 +463,31 @@ public void waitForNonDefaultExecutionPayload() { waitFor( () -> { - final Optional block = fetchHeadBlock(); + final Optional block = fetchHeadBlock(); assertThat(block).isPresent(); - assertThat(block.get()).isInstanceOf(SignedBeaconBlockBellatrix.class); - - final SignedBeaconBlockBellatrix bellatrixBlock = - (SignedBeaconBlockBellatrix) block.get(); - final ExecutionPayload executionPayload = - bellatrixBlock - .getMessage() - .getBody() - .executionPayload - .asInternalExecutionPayload(spec, bellatrixBlock.getMessage().slot); - assertThat(executionPayload.isDefault()).describedAs("Is default payload").isFalse(); - LOG.debug( - "Non default execution payload found at slot " + bellatrixBlock.getMessage().slot); + checkExecutionPayloadInBlock(block.get()); }, 5, MINUTES); } - public void waitForBlockSatisfying(final ThrowingConsumer assertions) { + private void checkExecutionPayloadInBlock(final SignedBeaconBlock signedBlock) { + final BeaconBlock beaconBlock = signedBlock.getMessage(); + final UInt64 slot = beaconBlock.getSlot(); + final Optional maybeExecutionPayload = + beaconBlock.getBody().getOptionalExecutionPayload(); + + assertThat(maybeExecutionPayload).isPresent(); + assertThat(maybeExecutionPayload.get().isDefault()).describedAs("Is default payload").isFalse(); + LOG.debug("Non default execution payload found at slot " + slot); + } + + public void waitForBlockSatisfying(final ThrowingConsumer assertions) { LOG.debug("Wait for a block satisfying certain assertions"); waitFor( () -> { - final Optional block = fetchHeadBlock(); + final Optional block = fetchHeadBlock(); assertThat(block).isPresent(); assertThat(block.get()).satisfies(assertions); }, @@ -518,19 +515,20 @@ public void waitForFullSyncCommitteeAggregate() { LOG.debug("Wait for full sync committee aggregates"); waitFor( () -> { - final Optional block = fetchHeadBlock(); - assertThat(block).isPresent(); - assertThat(block.get()).isInstanceOf(SignedBeaconBlockAltair.class); + final Optional maybeBlock = fetchHeadBlock(); + assertThat(maybeBlock).isPresent(); + final SignedBeaconBlock block = maybeBlock.get(); - final SignedBeaconBlockAltair altairBlock = (SignedBeaconBlockAltair) block.get(); - final int syncCommitteeSize = spec.getSyncCommitteeSize(altairBlock.getMessage().slot); - final SszBitvectorSchema syncCommitteeSchema = - SszBitvectorSchema.create(syncCommitteeSize); + final int syncCommitteeSize = spec.getSyncCommitteeSize(block.getMessage().getSlot()); - final Bytes syncCommitteeBits = - altairBlock.getMessage().getBody().syncAggregate.syncCommitteeBits; - final int actualSyncBitCount = - syncCommitteeSchema.sszDeserialize(syncCommitteeBits).getBitCount(); + final SszBitvector syncCommitteeBits = + block + .getMessage() + .getBody() + .getOptionalSyncAggregate() + .orElseThrow() + .getSyncCommitteeBits(); + final int actualSyncBitCount = syncCommitteeBits.getBitCount(); final double percentageOfBitsSet = actualSyncBitCount == syncCommitteeSize ? 1.0 @@ -580,49 +578,50 @@ private Optional> fetchBeaconHeadRootData() throws IOExce if (result.isEmpty()) { return Optional.empty(); } - - final GetBlockRootResponse response = - JSON_PROVIDER.jsonToObject(result, GetBlockRootResponse.class); - - return Optional.of(Pair.of(response.data.root, response.execution_optimistic)); + final JsonNode jsonNode = OBJECT_MAPPER.readTree(result); + final Bytes32 root = Bytes32.fromHexString(jsonNode.get("data").get("root").asText()); + final boolean executionOptimistic = jsonNode.get("execution_optimistic").asBoolean(); + return Optional.of(Pair.of(root, executionOptimistic)); } private Optional fetchBeaconHeadRoot() throws IOException { return fetchBeaconHeadRootData().map(Pair::getLeft); } - private FinalityCheckpointsResponse waitForChainHead() { - LOG.debug("Waiting for chain head"); - final AtomicReference chainHead = new AtomicReference<>(null); - waitFor( - () -> { - final Optional fetchCheckpoints = - fetchStateFinalityCheckpoints(); - assertThat(fetchCheckpoints).isPresent(); - chainHead.set(fetchCheckpoints.get()); - }); - LOG.debug("Retrieved chain head: {}", chainHead.get()); - return chainHead.get(); - } - - private Optional fetchStateFinalityCheckpoints() throws IOException { - final String result = - httpClient.get(getRestApiUrl(), "/eth/v1/beacon/states/head/finality_checkpoints"); - if (result.isEmpty()) { + private Optional getFinalizedEpoch() { + try { + final String result = + httpClient.get(getRestApiUrl(), "/eth/v1/beacon/states/head/finality_checkpoints"); + if (result.isEmpty()) { + return Optional.empty(); + } + + final JsonNode jsonNode = OBJECT_MAPPER.readTree(result); + final UInt64 finalizedEpoch = + UInt64.valueOf(jsonNode.get("data").get("finalized").get("epoch").asText()); + return Optional.of(finalizedEpoch); + } catch (final IOException e) { + LOG.error("Failed to fetch finalized epoch", e); return Optional.empty(); } - final GetStateFinalityCheckpointsResponse response = - JSON_PROVIDER.jsonToObject(result, GetStateFinalityCheckpointsResponse.class); - return Optional.of(response.data); } - private Optional fetchHeadBlock() throws IOException { + private Optional fetchHeadBlock() throws IOException { final String blockId = "head"; final String result = httpClient.get(getRestApiUrl(), "/eth/v2/beacon/blocks/" + blockId); if (result.isEmpty()) { return Optional.empty(); } else { - return Optional.of(JSON_PROVIDER.jsonToObject(result, GetBlockResponseV2.class).data); + JsonNode jsonNode = OBJECT_MAPPER.readTree(result); + final UInt64 slot = UInt64.valueOf(jsonNode.get("data").get("message").get("slot").asText()); + final DeserializableTypeDefinition jsonTypeDefinition = + SharedApiTypes.withDataWrapper( + "block", + spec.atSlot(slot) + .getSchemaDefinitions() + .getSignedBeaconBlockSchema() + .getJsonTypeDefinition()); + return Optional.of(JsonUtil.parse(result, jsonTypeDefinition)); } } @@ -643,22 +642,21 @@ private Optional fetchState(final String stateId) throws IOExceptio } } - private Optional fetchValidator(final int validatorId) throws IOException { + private Optional fetchValidatorWithdrawalCredentials(final int validatorId) + throws IOException { final String result = - httpClient.get( - getRestApiUrl(), - "/eth/v1/beacon/states/head/validators/" + validatorId, - Map.of("Accept", "application/octet-stream")); + httpClient.get(getRestApiUrl(), "/eth/v1/beacon/states/head/validators/" + validatorId); if (result.isEmpty()) { return Optional.empty(); } else { - final GetStateValidatorResponse response = - JSON_PROVIDER.jsonToObject(result, GetStateValidatorResponse.class); - return Optional.of(response.data.validator.asInternalValidator()); + final JsonNode jsonNode = OBJECT_MAPPER.readTree(result); + return Optional.of( + Bytes32.fromHexString( + jsonNode.get("data").get("validator").get("withdrawal_credentials").asText())); } } - public void waitForValidators(int numberOfValidators) { + public void waitForValidators(final int numberOfValidators) { waitFor( () -> { Optional maybeState = fetchHeadState(); @@ -672,18 +670,17 @@ public void waitForValidatorWithCredentials( final int validatorIndex, final Eth1Address executionAddress) { waitFor( () -> { - final Optional maybeValidator = fetchValidator(validatorIndex); - assertThat(maybeValidator).isPresent(); - Validator validator = maybeValidator.get(); - final Bytes32 withdrawalCredentials = validator.getWithdrawalCredentials(); - assertThat(withdrawalCredentials) + final Optional maybeWithdrawalCredentials = + fetchValidatorWithdrawalCredentials(validatorIndex); + assertThat(maybeWithdrawalCredentials).isPresent(); + assertThat(maybeWithdrawalCredentials.get()) .isEqualTo( BlockProcessorCapella.getWithdrawalAddressFromEth1Address(executionAddress)); }); } public void waitForAttestationBeingGossiped( - int validatorSeparationIndex, int totalValidatorCount) { + final int validatorSeparationIndex, final int totalValidatorCount) { List node1Validators = IntStream.range(0, validatorSeparationIndex).mapToObj(UInt64::valueOf).toList(); List node2Validators = @@ -692,22 +689,22 @@ public void waitForAttestationBeingGossiped( .toList(); waitFor( () -> { - final Optional maybeBlock = fetchHeadBlock(); + final Optional maybeBlock = fetchHeadBlock(); final Optional maybeState = fetchHeadState(); assertThat(maybeBlock).isPresent(); assertThat(maybeState).isPresent(); - SignedBeaconBlock block = (SignedBeaconBlock) maybeBlock.get(); + final SignedBeaconBlock block = maybeBlock.get(); BeaconState state = maybeState.get(); // Check that the fetched block and state are in sync assertThat(state.getLatestBlockHeader().getParentRoot()) - .isEqualTo(block.getMessage().parent_root); + .isEqualTo(block.getMessage().getParentRoot()); - UInt64 proposerIndex = block.getMessage().proposer_index; + UInt64 proposerIndex = block.getMessage().getProposerIndex(); Set attesterIndicesInAttestations = - block.getMessage().getBody().attestations.stream() - .map(a -> spec.getAttestingIndices(state, a.asInternalAttestation(spec))) + block.getMessage().getBody().getAttestations().stream() + .map(a -> spec.getAttestingIndices(state, a)) .flatMap(Collection::stream) .map(UInt64::valueOf) .collect(toSet()); @@ -769,14 +766,14 @@ public void waitForAggregateGossipReceived() { } public void expectNodeNotSyncing() throws IOException { - assertThat(fetchSyncStatus().data.isSyncing).isFalse(); + assertThat(getStatusIsSyncing()).isFalse(); } public void expectElOffline() throws IOException { - assertThat(fetchSyncStatus().data.elOffline).isTrue(); + assertThat(getStatusElOffline()).isTrue(); } public void expectElOnline() throws IOException { - assertThat(fetchSyncStatus().data.elOffline).isFalse(); + assertThat(getStatusElOffline()).isFalse(); } } diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TekuDockerVersion.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TekuDockerVersion.java index f4dd49451d8..660a9692187 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TekuDockerVersion.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TekuDockerVersion.java @@ -16,7 +16,7 @@ public enum TekuDockerVersion { LOCAL_BUILD("develop"), LAST_RELEASE("latest"), - V23_9_0("23.9.0"); + V24_2_0("24.2.0"); private final String version; diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TekuNode.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TekuNode.java index da271f820d7..6040f0599b2 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TekuNode.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TekuNode.java @@ -40,7 +40,10 @@ public abstract class TekuNode extends Node { protected Optional maybeEventStreamListener = Optional.empty(); protected TekuNode( - Network network, String dockerImageName, TekuDockerVersion dockerImageVersion, Logger log) { + final Network network, + final String dockerImageName, + final TekuDockerVersion dockerImageVersion, + final Logger log) { super(network, dockerImageName, dockerImageVersion, log); } @@ -135,7 +138,7 @@ public void waitForOwnedValidatorCount(final int expectedValidatorCount) { }); } - private String getEventUrl(List events) { + private String getEventUrl(final List events) { final String eventTypes = events.isEmpty() ? "" diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TekuNodeConfig.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TekuNodeConfig.java index 42dace7d1ba..6df249e432d 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TekuNodeConfig.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TekuNodeConfig.java @@ -46,14 +46,14 @@ public class TekuNodeConfig { private final Map writableMountPoints; public TekuNodeConfig( - Map configMap, + final Map configMap, final Consumer specConfigModifier, final Optional maybePrivateKey, final Optional maybePeerId, final Map writableMountPoints, final Map readOnlyMountPoints, final List tarballsToCopy, - Map configFileMap) { + final Map configFileMap) { this.configMap = configMap; this.specConfigModifier = specConfigModifier; this.maybePrivateKey = maybePrivateKey; diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TekuNodeConfigBuilder.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TekuNodeConfigBuilder.java index 42a826c3801..a123d2e9506 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TekuNodeConfigBuilder.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TekuNodeConfigBuilder.java @@ -14,11 +14,12 @@ package tech.pegasys.teku.test.acceptance.dsl; import static java.nio.charset.StandardCharsets.UTF_8; +import static org.assertj.core.api.Assertions.assertThat; import static tech.pegasys.teku.test.acceptance.dsl.Node.DATA_PATH; -import static tech.pegasys.teku.test.acceptance.dsl.Node.JSON_PROVIDER; import static tech.pegasys.teku.test.acceptance.dsl.Node.JWT_SECRET_FILE_PATH; import static tech.pegasys.teku.test.acceptance.dsl.Node.METRICS_PORT; import static tech.pegasys.teku.test.acceptance.dsl.Node.NETWORK_FILE_PATH; +import static tech.pegasys.teku.test.acceptance.dsl.Node.OBJECT_MAPPER; import static tech.pegasys.teku.test.acceptance.dsl.Node.P2P_PORT; import static tech.pegasys.teku.test.acceptance.dsl.Node.PRIVATE_KEY_FILE_PATH; import static tech.pegasys.teku.test.acceptance.dsl.Node.REST_API_PORT; @@ -55,6 +56,7 @@ import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.apache.tuweni.bytes.Bytes; +import org.apache.tuweni.bytes.Bytes32; import org.apache.tuweni.units.bigints.UInt256; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.networks.Eth2NetworkConfiguration; @@ -145,13 +147,37 @@ public TekuNodeConfigBuilder withCapellaEpoch(final UInt64 capellaForkEpoch) { return this; } + public TekuNodeConfigBuilder withDenebEpoch(final UInt64 denebForkEpoch) { + mustBe(NodeType.BEACON_NODE); + LOG.debug("Xnetwork-deneb-fork-epoch={}", denebForkEpoch); + configMap.put("Xnetwork-deneb-fork-epoch", denebForkEpoch.toString()); + specConfigModifier = + specConfigModifier.andThen( + specConfigBuilder -> + specConfigBuilder.denebBuilder( + denebBuilder -> denebBuilder.denebForkEpoch(denebForkEpoch))); + return this; + } + + public TekuNodeConfigBuilder withElectraEpoch(final UInt64 electraForkEpoch) { + mustBe(NodeType.BEACON_NODE); + LOG.debug("Xnetwork-electra-fork-epoch={}", electraForkEpoch); + configMap.put("Xnetwork-electra-fork-epoch", electraForkEpoch.toString()); + specConfigModifier = + specConfigModifier.andThen( + specConfigBuilder -> + specConfigBuilder.electraBuilder( + electraBuilder -> electraBuilder.electraForkEpoch(electraForkEpoch))); + return this; + } + public TekuNodeConfigBuilder withTrustedSetupFromClasspath(final String trustedSetup) throws Exception { mustBe(NodeType.BEACON_NODE); LOG.debug("Xtrusted-setup={}", TRUSTED_SETUP_FILE); configMap.put("Xtrusted-setup", TRUSTED_SETUP_FILE); final URL trustedSetupResource = Eth2NetworkConfiguration.class.getResource(trustedSetup); - assert trustedSetupResource != null; + assertThat(trustedSetupResource).isNotNull(); configFileMap.put(copyToTmpFile(trustedSetupResource), TRUSTED_SETUP_FILE); return this; } @@ -171,29 +197,32 @@ public TekuNodeConfigBuilder withJwtSecretFile(final URL jwtFile) throws Excepti return this; } - public TekuNodeConfigBuilder withDenebEpoch(final UInt64 denebForkEpoch) { - + public TekuNodeConfigBuilder withTerminalBlockHash(final String terminalBlockHash) { mustBe(NodeType.BEACON_NODE); - LOG.debug("Xnetwork-deneb-fork-epoch={}", denebForkEpoch); - configMap.put("Xnetwork-deneb-fork-epoch", denebForkEpoch.toString()); + + LOG.debug("Xnetwork-terminal-block-hash-override={}", terminalBlockHash); + configMap.put("Xnetwork-terminal-block-hash-override", terminalBlockHash); + specConfigModifier = specConfigModifier.andThen( specConfigBuilder -> - specConfigBuilder.denebBuilder( - denebBuilder -> denebBuilder.denebForkEpoch(denebForkEpoch))); + specConfigBuilder.bellatrixBuilder( + bellatrixBuilder -> + bellatrixBuilder.terminalBlockHash( + Bytes32.fromHexString(terminalBlockHash)))); return this; } - public TekuNodeConfigBuilder withEip7594Epoch(final UInt64 eip7594ForkEpoch) { + public TekuNodeConfigBuilder withEip7594Epoch(final UInt64 eip7594Epoch) { mustBe(NodeType.BEACON_NODE); - LOG.debug("Xnetwork-das-fork-epoch={}", eip7594ForkEpoch); - configMap.put("Xnetwork-das-fork-epoch", eip7594ForkEpoch.toString()); + LOG.debug("Xnetwork-das-fork-epoch={}", eip7594Epoch); + configMap.put("Xnetwork-das-fork-epoch", eip7594Epoch.toString()); specConfigModifier = specConfigModifier.andThen( specConfigBuilder -> specConfigBuilder.eip7594Builder( - eip7594Builder -> eip7594Builder.eip7594ForkEpoch(eip7594ForkEpoch))); + eip7594Builder -> eip7594Builder.eip7594ForkEpoch(eip7594Epoch))); return this; } @@ -335,7 +364,7 @@ public TekuNodeConfigBuilder withSpecifiedBearerToken(final String password) thr } public TekuNodeConfigBuilder withWritableKeystorePath( - ValidatorKeystores keystores, Path tempDir) { + final ValidatorKeystores keystores, final Path tempDir) { LOG.debug("Xinterop-enabled=false"); configMap.put("Xinterop-enabled", false); final String keysFolder = "/" + keystores.getKeysDirectoryName(); @@ -402,6 +431,12 @@ public TekuNodeConfigBuilder withDoppelgangerDetectionEnabled() { return this; } + public TekuNodeConfigBuilder withSubscribeAllSubnetsEnabled() { + LOG.debug("p2p-subscribe-all-subnets-enabled=true"); + configMap.put("p2p-subscribe-all-subnets-enabled", true); + return this; + } + public TekuNodeConfigBuilder withDepositsFrom(final BesuNode eth1Node) { mustBe(NodeType.BEACON_NODE); configMap.put("Xinterop-enabled", false); @@ -451,7 +486,7 @@ public TekuNodeConfigBuilder withSentryNodes(final SentryNodesConfig sentryNodes sentryNodesConfigFile.deleteOnExit(); try (FileWriter fw = new FileWriter(sentryNodesConfigFile, StandardCharsets.UTF_8)) { - fw.write(sentryNodesConfig.toJson(JSON_PROVIDER)); + fw.write(sentryNodesConfig.toJson(OBJECT_MAPPER)); } } catch (IOException e) { throw new RuntimeException("Error creating sentry nodes configuration file", e); @@ -495,6 +530,12 @@ public TekuNodeConfigBuilder withExternalSignerUrl(final String externalSignerUr return this; } + public TekuNodeConfigBuilder withExternalSignerPublicKeys(final String publicKeysList) { + LOG.debug("validators-external-signer-public-keys={}", publicKeysList); + configMap.put("validators-external-signer-public-keys", publicKeysList); + return this; + } + public TekuNodeConfigBuilder withValidatorProposerDefaultFeeRecipient( final String validatorProposerDefaultFeeRecipient) { LOG.debug("validators-proposer-default-fee-recipient={}", validatorProposerDefaultFeeRecipient); @@ -503,6 +544,12 @@ public TekuNodeConfigBuilder withValidatorProposerDefaultFeeRecipient( return this; } + public TekuNodeConfigBuilder withBeaconNodeSszBlocksEnabled(final boolean enabled) { + LOG.debug("beacon-node-ssz-blocks-enabled={}", enabled); + configMap.put("beacon-node-ssz-blocks-enabled", enabled); + return this; + } + public TekuNodeConfigBuilder withStartupTargetPeerCount(final int startupTargetPeerCount) { mustBe(NodeType.BEACON_NODE); LOG.debug("Xstartup-target-peer-count={}", startupTargetPeerCount); @@ -526,7 +573,7 @@ public TekuNodeConfigBuilder withStubExecutionEngine() { return this; } - public TekuNodeConfigBuilder withGenesisTime(int time) { + public TekuNodeConfigBuilder withGenesisTime(final int time) { mustBe(NodeType.BEACON_NODE); LOG.debug("Xinterop-genesis-time={}", time); configMap.put("Xinterop-genesis-time", time); @@ -539,7 +586,7 @@ public TekuNodeConfigBuilder withGraffiti(final String graffiti) { return this; } - private TekuNodeConfigBuilder withPrivateKey(PrivKey privKey) throws IOException { + private TekuNodeConfigBuilder withPrivateKey(final PrivKey privKey) throws IOException { mustBe(NodeType.BEACON_NODE); this.maybePrivKey = Optional.ofNullable(privKey); this.maybePeerId = maybePrivKey.map(privateKey -> PeerId.fromPubKey(privateKey.publicKey())); diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TekuVoluntaryExit.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TekuVoluntaryExit.java index b69d7d2d49f..9deb465f66c 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TekuVoluntaryExit.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TekuVoluntaryExit.java @@ -44,7 +44,7 @@ private TekuVoluntaryExit(final Network network, final TekuVoluntaryExit.Config } public static TekuVoluntaryExit create( - final Network network, Consumer configOptions) { + final Network network, final Consumer configOptions) { final TekuVoluntaryExit.Config config = new TekuVoluntaryExit.Config(); configOptions.accept(config); @@ -54,7 +54,7 @@ public static TekuVoluntaryExit create( return node; } - public TekuVoluntaryExit withValidatorKeystores(ValidatorKeystores validatorKeystores) + public TekuVoluntaryExit withValidatorKeystores(final ValidatorKeystores validatorKeystores) throws Exception { this.config.withValidatorKeys( WORKING_DIRECTORY @@ -96,7 +96,7 @@ public void stop() { } public static class Config { - private Map configMap = new HashMap<>(); + private final Map configMap = new HashMap<>(); public Config() { configMap.put("log-destination", "console"); diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TrustingSimpleHttpsClient.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TrustingSimpleHttpsClient.java index d59e4840f31..a191e84143d 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TrustingSimpleHttpsClient.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/TrustingSimpleHttpsClient.java @@ -32,10 +32,10 @@ public class TrustingSimpleHttpsClient extends SimpleHttpClient { new TrustManager[] { new X509TrustManager() { @Override - public void checkClientTrusted(X509Certificate[] chain, String authType) {} + public void checkClientTrusted(final X509Certificate[] chain, final String authType) {} @Override - public void checkServerTrusted(X509Certificate[] chain, String authType) + public void checkServerTrusted(final X509Certificate[] chain, final String authType) throws CertificateException { for (X509Certificate certificate : chain) { @@ -62,10 +62,10 @@ public X509Certificate[] getAcceptedIssuers() { private static final X509TrustManager TRUST_MANAGER = new X509TrustManager() { @Override - public void checkClientTrusted(X509Certificate[] chain, String authType) {} + public void checkClientTrusted(final X509Certificate[] chain, final String authType) {} @Override - public void checkServerTrusted(X509Certificate[] chain, String authType) {} + public void checkServerTrusted(final X509Certificate[] chain, final String authType) {} @Override public X509Certificate[] getAcceptedIssuers() { diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/Web3SignerNode.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/Web3SignerNode.java index f572d7488a1..e5e4c55a206 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/Web3SignerNode.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/Web3SignerNode.java @@ -40,7 +40,7 @@ public class Web3SignerNode extends Node { private Set configFiles; private Web3SignerNode(final Network network, final Web3SignerNode.Config config) { - super(network, "consensys/web3signer:22.4.0", LOG); + super(network, "consensys/web3signer:develop", LOG); container .withExposedPorts(HTTP_API_PORT) .withLogConsumer(frame -> LOG.debug(frame.getUtf8String().trim())) @@ -50,7 +50,7 @@ private Web3SignerNode(final Network network, final Web3SignerNode.Config config } public static Web3SignerNode create( - final Network network, Consumer configOptions) { + final Network network, final Consumer configOptions) { final Web3SignerNode.Config config = new Web3SignerNode.Config(); configOptions.accept(config); @@ -110,7 +110,7 @@ private URI getSignerUrl() { } public static class Config { - private Map configMap = new HashMap<>(); + private final Map configMap = new HashMap<>(); private final Map configFileMap = new HashMap<>(); public Config() { @@ -131,6 +131,27 @@ public Web3SignerNode.Config withAltairEpoch(final UInt64 altairSlot) { return this; } + public Web3SignerNode.Config withBellatrixEpoch(final UInt64 bellatrixSlot) { + configMap.put("eth2.Xnetwork-bellatrix-fork-epoch", bellatrixSlot.toString()); + return this; + } + + public Web3SignerNode.Config withCapellaEpoch(final UInt64 capellaSlot) { + configMap.put("eth2.Xnetwork-capella-fork-epoch", capellaSlot.toString()); + return this; + } + + public Web3SignerNode.Config withDenebEpoch(final UInt64 denebSlot) { + configMap.put("eth2.Xnetwork-deneb-fork-epoch", denebSlot.toString()); + return this; + } + + public Web3SignerNode.Config withTrustedSetupFromClasspath( + final String trustedSetupFromClasspath) { + configMap.put("eth2.Xtrusted-setup", trustedSetupFromClasspath); + return this; + } + public void writeConfigFile() throws Exception { final File configFile = File.createTempFile("config", ".yaml"); configFile.deleteOnExit(); diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/executionrequests/ConsolidationRequestContract.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/executionrequests/ConsolidationRequestContract.java new file mode 100644 index 00000000000..e2f130b781a --- /dev/null +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/executionrequests/ConsolidationRequestContract.java @@ -0,0 +1,72 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.test.acceptance.dsl.executionrequests; + +import java.math.BigInteger; +import org.apache.tuweni.bytes.Bytes; +import org.apache.tuweni.units.bigints.UInt256; +import org.web3j.protocol.Web3j; +import org.web3j.protocol.core.DefaultBlockParameter; +import org.web3j.protocol.core.methods.request.Transaction; +import org.web3j.protocol.core.methods.response.EthSendTransaction; +import org.web3j.tx.TransactionManager; +import org.web3j.utils.Async; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.ethereum.execution.types.Eth1Address; +import tech.pegasys.teku.infrastructure.async.SafeFuture; + +/* + Wrapper classed based on https://github.com/lightclient/sys-asm/blob/main/src/consolidations/main.eas +*/ +public class ConsolidationRequestContract { + + private final Eth1Address contractAddress; + private final TransactionManager transactionManager; + private final Web3j web3j; + + public ConsolidationRequestContract( + final Eth1Address contractAddress, + final Web3j web3j, + final TransactionManager transactionManager) { + this.contractAddress = contractAddress; + this.web3j = web3j; + this.transactionManager = transactionManager; + } + + public SafeFuture getExcessConsolidationRequests() { + return SafeFuture.of( + web3j + .ethCall( + Transaction.createEthCallTransaction( + Eth1Address.ZERO.toHexString(), contractAddress.toHexString(), ""), + DefaultBlockParameter.valueOf("latest")) + .sendAsync() + .thenApply(response -> UInt256.fromHexString(response.getResult()).toInt())); + } + + public SafeFuture createConsolidationRequest( + final BLSPublicKey sourcePublicKey, final BLSPublicKey targetPublicKey) { + final BigInteger gasPrice = BigInteger.valueOf(1_000); + final BigInteger gasLimit = BigInteger.valueOf(1_000_000); + final Bytes data = + Bytes.concatenate(sourcePublicKey.toBytesCompressed(), targetPublicKey.toBytesCompressed()); + final BigInteger value = BigInteger.valueOf(2); // has to be more than current fee (0) + + return SafeFuture.of( + Async.run( + () -> + transactionManager.sendTransaction( + gasPrice, gasLimit, contractAddress.toHexString(), data.toHexString(), value))); + } +} diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/executionrequests/ExecutionRequestsService.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/executionrequests/ExecutionRequestsService.java new file mode 100644 index 00000000000..919e8877b2c --- /dev/null +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/executionrequests/ExecutionRequestsService.java @@ -0,0 +1,143 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.test.acceptance.dsl.executionrequests; + +import static org.assertj.core.api.Assertions.assertThat; + +import com.google.common.util.concurrent.ThreadFactoryBuilder; +import java.util.Optional; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; +import okhttp3.ConnectionPool; +import okhttp3.OkHttpClient; +import org.web3j.crypto.Credentials; +import org.web3j.protocol.Web3j; +import org.web3j.protocol.core.methods.response.EthGetTransactionReceipt; +import org.web3j.protocol.core.methods.response.TransactionReceipt; +import org.web3j.protocol.http.HttpService; +import org.web3j.tx.FastRawTransactionManager; +import org.web3j.tx.TransactionManager; +import org.web3j.tx.response.PollingTransactionReceiptProcessor; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.ethereum.execution.types.Eth1Address; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.async.Waiter; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; + +public class ExecutionRequestsService implements AutoCloseable { + + // Increase the poll rate for tx receipts but keep the default 10 min timeout. + private static final int POLL_INTERVAL_MILLIS = 2000; + private static final int MAX_POLL_ATTEMPTS = 300; + + // private final WithdrawalRequestTransactionSender sender; + private final OkHttpClient httpClient; + private final ScheduledExecutorService executorService; + private final Web3j web3j; + private final WithdrawalRequestContract withdrawalRequestContract; + private final ConsolidationRequestContract consolidationRequestContract; + + public ExecutionRequestsService( + final String eth1NodeUrl, + final Credentials eth1Credentials, + final Eth1Address withdrawalRequestAddress, + final Eth1Address consolidationRequestAddress) { + this.httpClient = new OkHttpClient.Builder().connectionPool(new ConnectionPool()).build(); + this.executorService = + Executors.newScheduledThreadPool( + 1, + new ThreadFactoryBuilder() + .setDaemon(true) + .setNameFormat("web3j-executionRequests-%d") + .build()); + this.web3j = Web3j.build(new HttpService(eth1NodeUrl, httpClient), 1000, executorService); + + final TransactionManager transactionManager = + new FastRawTransactionManager( + web3j, + eth1Credentials, + new PollingTransactionReceiptProcessor(web3j, POLL_INTERVAL_MILLIS, MAX_POLL_ATTEMPTS)); + + this.withdrawalRequestContract = + new WithdrawalRequestContract(withdrawalRequestAddress, web3j, transactionManager); + this.consolidationRequestContract = + new ConsolidationRequestContract(consolidationRequestAddress, web3j, transactionManager); + } + + @Override + public void close() { + web3j.shutdown(); + httpClient.dispatcher().executorService().shutdownNow(); + httpClient.connectionPool().evictAll(); + executorService.shutdownNow(); + } + + public SafeFuture createWithdrawalRequest( + final BLSPublicKey publicKey, final UInt64 amount) { + // Sanity check that we can interact with the contract + Waiter.waitFor( + () -> + assertThat(withdrawalRequestContract.getExcessWithdrawalRequests().get()).isEqualTo(0)); + + return withdrawalRequestContract + .createWithdrawalRequest(publicKey, amount) + .thenCompose( + response -> { + final String txHash = response.getResult(); + waitForSuccessfulTransaction(txHash); + return getTransactionReceipt(txHash); + }); + } + + public SafeFuture createConsolidationRequest( + final BLSPublicKey sourceValidatorPubkey, final BLSPublicKey targetValidatorPubkey) { + // Sanity check that we can interact with the contract + Waiter.waitFor( + () -> + assertThat(consolidationRequestContract.getExcessConsolidationRequests().get()) + .isEqualTo(0)); + + return consolidationRequestContract + .createConsolidationRequest(sourceValidatorPubkey, targetValidatorPubkey) + .thenCompose( + response -> { + final String txHash = response.getResult(); + waitForSuccessfulTransaction(txHash); + return getTransactionReceipt(txHash); + }); + } + + private SafeFuture getTransactionReceipt(final String txHash) { + return SafeFuture.of( + web3j + .ethGetTransactionReceipt(txHash) + .sendAsync() + .thenApply(EthGetTransactionReceipt::getTransactionReceipt) + .thenApply(Optional::orElseThrow)); + } + + private void waitForSuccessfulTransaction(final String txHash) { + Waiter.waitFor( + () -> { + final TransactionReceipt transactionReceipt = + web3j.ethGetTransactionReceipt(txHash).send().getTransactionReceipt().orElseThrow(); + if (!"0x1".equals(transactionReceipt.getStatus())) { + throw new RuntimeException("Transaction failed"); + } + }, + 1, + TimeUnit.MINUTES); + } +} diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/executionrequests/WithdrawalRequestContract.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/executionrequests/WithdrawalRequestContract.java new file mode 100644 index 00000000000..10d221e781b --- /dev/null +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/executionrequests/WithdrawalRequestContract.java @@ -0,0 +1,74 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.test.acceptance.dsl.executionrequests; + +import java.math.BigInteger; +import org.apache.tuweni.bytes.Bytes; +import org.apache.tuweni.units.bigints.UInt256; +import org.hyperledger.besu.datatypes.GWei; +import org.web3j.protocol.Web3j; +import org.web3j.protocol.core.DefaultBlockParameter; +import org.web3j.protocol.core.methods.request.Transaction; +import org.web3j.protocol.core.methods.response.EthSendTransaction; +import org.web3j.tx.TransactionManager; +import org.web3j.utils.Async; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.ethereum.execution.types.Eth1Address; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; + +/* + Wrapper classed based on https://github.com/lightclient/sys-asm/blob/main/src/withdrawals/main.eas +*/ +public class WithdrawalRequestContract { + + private final Eth1Address contractAddress; + private final TransactionManager transactionManager; + private final Web3j web3j; + + public WithdrawalRequestContract( + final Eth1Address contractAddress, + final Web3j web3j, + final TransactionManager transactionManager) { + this.contractAddress = contractAddress; + this.web3j = web3j; + this.transactionManager = transactionManager; + } + + public SafeFuture getExcessWithdrawalRequests() { + return SafeFuture.of( + web3j + .ethCall( + Transaction.createEthCallTransaction( + Eth1Address.ZERO.toHexString(), contractAddress.toHexString(), ""), + DefaultBlockParameter.valueOf("latest")) + .sendAsync() + .thenApply(response -> UInt256.fromHexString(response.getResult()).toInt())); + } + + public SafeFuture createWithdrawalRequest( + final BLSPublicKey publicKey, final UInt64 amount) { + final BigInteger gasPrice = BigInteger.valueOf(1_000); + final BigInteger gasLimit = BigInteger.valueOf(1_000_000); + final Bytes data = + Bytes.concatenate(publicKey.toBytesCompressed(), GWei.of(amount.longValue()).toBytes()); + final BigInteger value = BigInteger.valueOf(2); // has to be more than current fee (0) + + return SafeFuture.of( + Async.run( + () -> + transactionManager.sendTransaction( + gasPrice, gasLimit, contractAddress.toHexString(), data.toHexString(), value))); + } +} diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/metrics/MetricConditions.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/metrics/MetricConditions.java index 6426700fa75..d66e5ab0814 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/metrics/MetricConditions.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/metrics/MetricConditions.java @@ -67,26 +67,26 @@ public static MetricLabelsCondition withLabelValueSubstring( }; } - public static MetricValuesCondition withValueEqualTo(double value) { + public static MetricValuesCondition withValueEqualTo(final double value) { return (actualValue) -> DoubleMath.fuzzyEquals(actualValue, value, DOUBLE_COMPARE_TOLERANCE); } - public static MetricValuesCondition withValueGreaterThan(double value) { + public static MetricValuesCondition withValueGreaterThan(final double value) { return (actualValue) -> DoubleMath.fuzzyCompare(actualValue, value, DOUBLE_COMPARE_TOLERANCE) > 0; } - public static MetricValuesCondition withValueGreaterThanOrEqualTo(double value) { + public static MetricValuesCondition withValueGreaterThanOrEqualTo(final double value) { return (actualValue) -> DoubleMath.fuzzyCompare(actualValue, value, DOUBLE_COMPARE_TOLERANCE) >= 0; } - public static MetricValuesCondition withValueLessThan(double value) { + public static MetricValuesCondition withValueLessThan(final double value) { return (actualValue) -> DoubleMath.fuzzyCompare(actualValue, value, DOUBLE_COMPARE_TOLERANCE) < 0; } - public static MetricValuesCondition withValueLessThanOrEqualTo(double value) { + public static MetricValuesCondition withValueLessThanOrEqualTo(final double value) { return (actualValue) -> DoubleMath.fuzzyCompare(actualValue, value, DOUBLE_COMPARE_TOLERANCE) <= 0; } diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/metrics/MetricFetcher.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/metrics/MetricFetcher.java index 8db3a18be38..68b91ca6421 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/metrics/MetricFetcher.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/metrics/MetricFetcher.java @@ -89,7 +89,7 @@ private List fetchAllMetricsFromEndpoint() { } } - public static MetricValue parse(String line) { + public static MetricValue parse(final String line) { if (line.contains("{")) { final String metricName = line.substring(0, line.indexOf("{")); diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/ValidatorKeysApi.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/ValidatorKeysApi.java index f4977930caf..312315f7a22 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/ValidatorKeysApi.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/ValidatorKeysApi.java @@ -16,6 +16,7 @@ import static org.assertj.core.api.AssertionsForClassTypes.assertThat; import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; import com.google.common.base.Suppliers; import java.io.IOException; import java.net.URI; @@ -33,7 +34,6 @@ import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.ethereum.execution.types.Eth1Address; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.provider.JsonProvider; import tech.pegasys.teku.test.acceptance.dsl.SimpleHttpClient; import tech.pegasys.teku.test.acceptance.dsl.tools.deposits.ValidatorKeystores; @@ -45,7 +45,7 @@ public class ValidatorKeysApi { private static final String REMOTE_KEYS_URL = "/eth/v1/remotekeys"; public static final String VOLUNTARY_EXIT_URL = "/eth/v1/validator/{pubkey}/voluntary_exit"; - private final JsonProvider jsonProvider = new JsonProvider(); + private final ObjectMapper objectMapper = new ObjectMapper(); private final SimpleHttpClient httpClient; private final Supplier validatorUri; private final Supplier apiPasswordSupplier; @@ -63,7 +63,7 @@ public void addLocalValidatorsAndExpect( final ValidatorKeystores validatorKeystores, final String expectedStatus) throws IOException { final Path tempDir = Files.createTempDirectory("validator-keys-api"); final JsonNode addResult = - jsonProvider.getObjectMapper().readTree(addLocalValidators(validatorKeystores, tempDir)); + objectMapper.readTree(addLocalValidators(validatorKeystores, tempDir)); assertThat(addResult.get("data").size()).isEqualTo(validatorKeystores.getValidatorCount()); checkStatus(addResult.get("data"), expectedStatus); tempDir.toFile().delete(); @@ -73,7 +73,7 @@ public void generateVoluntaryExitAndCheckValidatorIndex( final BLSPublicKey publicKey, final int validatorIndex) throws IOException { final UInt64 epoch = UInt64.ONE; final String value = getPostVoluntaryExitString(publicKey, Optional.of(epoch)); - final JsonNode result = jsonProvider.getObjectMapper().readTree(value).get("data"); + final JsonNode result = objectMapper.readTree(value).get("data"); final JsonNode message = result.get("message"); assertThat(message.get("epoch").asText()).isEqualTo(String.valueOf(epoch)); assertThat(message.get("validator_index").asText()).isEqualTo(String.valueOf(validatorIndex)); @@ -105,21 +105,19 @@ public void addGasLimit(final BLSPublicKey publicKey, final UInt64 gasLimit) thr public void addRemoteValidatorsAndExpect( final List expectedKeys, final String signerUrl, final String expectedStatus) throws IOException { - final JsonNode addResult = - jsonProvider.getObjectMapper().readTree(addRemoteValidators(expectedKeys, signerUrl)); + final JsonNode addResult = objectMapper.readTree(addRemoteValidators(expectedKeys, signerUrl)); assertThat(addResult.get("data").size()).isEqualTo(expectedKeys.size()); checkStatus(addResult.get("data"), expectedStatus); } public void removeLocalValidatorAndCheckStatus( final BLSPublicKey publicKey, final String expectedStatus) throws IOException { - final JsonNode removeResult = - jsonProvider.getObjectMapper().readTree(removeLocalValidator(publicKey)); + final JsonNode removeResult = objectMapper.readTree(removeLocalValidator(publicKey)); assertThat(removeResult.get("data").size()).isEqualTo(1); checkStatus(removeResult.get("data"), expectedStatus); if (expectedStatus.equals("deleted") || expectedStatus.equals("not_active")) { final JsonNode slashingProtection = - jsonProvider.getObjectMapper().readTree(removeResult.get("slashing_protection").asText()); + objectMapper.readTree(removeResult.get("slashing_protection").asText()); final JsonNode slashingData = slashingProtection.get("data"); assertThat(slashingData.size()).isEqualTo(1); assertThat(slashingData.get(0).get("pubkey").asText()).isEqualTo(publicKey.toString()); @@ -128,15 +126,14 @@ public void removeLocalValidatorAndCheckStatus( public void removeRemoteValidatorAndCheckStatus( final BLSPublicKey publicKey, final String expectedStatus) throws IOException { - final JsonNode removeResult = - jsonProvider.getObjectMapper().readTree(removeRemoteValidator(publicKey)); + final JsonNode removeResult = objectMapper.readTree(removeRemoteValidator(publicKey)); assertThat(removeResult.get("data").size()).isEqualTo(1); checkStatus(removeResult.get("data"), expectedStatus); } public void assertLocalValidatorListing(final List expectedKeys) throws IOException { - final JsonNode result = jsonProvider.getObjectMapper().readTree(getLocalValidatorListing()); + final JsonNode result = objectMapper.readTree(getLocalValidatorListing()); final JsonNode data = result.get("data"); assertThat(data.isArray()).isTrue(); final List expectedKeyStrings = @@ -154,7 +151,7 @@ public void assertLocalValidatorListing(final List expectedKeys) public void assertRemoteValidatorListing(final List expectedKeys) throws IOException { - final JsonNode result = jsonProvider.getObjectMapper().readTree(getRemoteValidatorListing()); + final JsonNode result = objectMapper.readTree(getRemoteValidatorListing()); final JsonNode data = result.get("data"); assertThat(data.isArray()).isTrue(); final List expectedKeyStrings = @@ -188,8 +185,7 @@ public void assertValidatorFeeRecipient( final BLSPublicKey publicKey, final String expectedEthAddress) throws IOException { final String result = - jsonProvider - .getObjectMapper() + objectMapper .readTree(getLocalFeeRecipient(publicKey)) .get("data") .get("ethaddress") @@ -200,12 +196,7 @@ public void assertValidatorFeeRecipient( public void assertValidatorGasLimit(final BLSPublicKey publicKey, final UInt64 expectedGasLimit) throws IOException { final String result = - jsonProvider - .getObjectMapper() - .readTree(getLocalGasLimit(publicKey)) - .get("data") - .get("gas_limit") - .asText(); + objectMapper.readTree(getLocalGasLimit(publicKey)).get("data").get("gas_limit").asText(); final UInt64 gasLimit = UInt64.valueOf(result); assertThat(gasLimit).isEqualTo(expectedGasLimit); } @@ -232,7 +223,7 @@ private String addLocalValidators(final ValidatorKeystores validatorKeystores, f final List passwords = validatorKeystores.getPasswords(); final String body = - jsonProvider.objectToJSON(Map.of("keystores", keystores, "passwords", passwords)); + objectMapper.writeValueAsString(Map.of("keystores", keystores, "passwords", passwords)); final String result = httpClient.post(validatorUri.get(), LOCAL_KEYS_URL, body, authHeaders()); LOG.debug("POST Keys: " + result); @@ -242,7 +233,8 @@ private String addLocalValidators(final ValidatorKeystores validatorKeystores, f private void addFeeRecipientToValidator( final BLSPublicKey publicKey, final Eth1Address feeRecipient) throws IOException { - final String body = jsonProvider.objectToJSON(Map.of("ethaddress", feeRecipient.toHexString())); + final String body = + objectMapper.writeValueAsString(Map.of("ethaddress", feeRecipient.toHexString())); final String result = httpClient.post(validatorUri.get(), getFeeRecipientUrl(publicKey), body, authHeaders()); @@ -252,7 +244,7 @@ private void addFeeRecipientToValidator( private void addGasLimitToValidator(final BLSPublicKey publicKey, final UInt64 gasLimit) throws IOException { - final String body = jsonProvider.objectToJSON(Map.of("gas_limit", gasLimit.toString())); + final String body = objectMapper.writeValueAsString(Map.of("gas_limit", gasLimit.toString())); final String result = httpClient.post(validatorUri.get(), getGasLimitUrl(publicKey), body, authHeaders()); @@ -263,10 +255,8 @@ private String addRemoteValidators(final List publicKeys, final St throws IOException { List> requestPayload = - publicKeys.stream() - .map(k -> remotePostRequestBody(k, signerUrl)) - .collect(Collectors.toList()); - final String body = jsonProvider.objectToJSON(Map.of("remote_keys", requestPayload)); + publicKeys.stream().map(k -> remotePostRequestBody(k, signerUrl)).toList(); + final String body = objectMapper.writeValueAsString(Map.of("remote_keys", requestPayload)); final String result = httpClient.post(validatorUri.get(), REMOTE_KEYS_URL, body, authHeaders()); LOG.debug("POST REMOTE Keys: " + result); @@ -279,7 +269,8 @@ private Map remotePostRequestBody( } private String removeLocalValidator(final BLSPublicKey publicKey) throws IOException { - final String body = jsonProvider.objectToJSON(Map.of("pubkeys", List.of(publicKey.toString()))); + final String body = + objectMapper.writeValueAsString(Map.of("pubkeys", List.of(publicKey.toString()))); final String result = httpClient.delete(validatorUri.get(), LOCAL_KEYS_URL, body, authHeaders()); LOG.debug("DELETE LOCAL Keys: " + result); @@ -287,7 +278,8 @@ private String removeLocalValidator(final BLSPublicKey publicKey) throws IOExcep } private String removeRemoteValidator(final BLSPublicKey publicKey) throws IOException { - final String body = jsonProvider.objectToJSON(Map.of("pubkeys", List.of(publicKey.toString()))); + final String body = + objectMapper.writeValueAsString(Map.of("pubkeys", List.of(publicKey.toString()))); final String result = httpClient.delete(validatorUri.get(), REMOTE_KEYS_URL, body, authHeaders()); LOG.debug("DELETE REMOTE Keys: " + result); diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/deposits/DepositGenerator.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/deposits/DepositGenerator.java index b9b71a61b1e..ce283381845 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/deposits/DepositGenerator.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/deposits/DepositGenerator.java @@ -14,7 +14,6 @@ package tech.pegasys.teku.test.acceptance.dsl.tools.deposits; import java.util.List; -import java.util.stream.Collectors; import org.web3j.crypto.Credentials; import org.web3j.protocol.core.methods.response.TransactionReceipt; import tech.pegasys.teku.ethereum.execution.types.Eth1Address; @@ -40,14 +39,12 @@ public SafeFuture sendDeposits(final ValidatorKeystores validators) { return SafeFuture.of( () -> { final List> transactionReceipts = - validators.getValidatorKeys().stream() - .map(this::sendDeposit) - .collect(Collectors.toList()); + validators.getValidatorKeys().stream().map(this::sendDeposit).toList(); return SafeFuture.allOf(transactionReceipts.toArray(SafeFuture[]::new)); }); } - private SafeFuture sendDeposit(ValidatorKeys validatorKeys) { + private SafeFuture sendDeposit(final ValidatorKeys validatorKeys) { return depositSenderService.sendDeposit(validatorKeys); } diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/deposits/DepositSenderService.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/deposits/DepositSenderService.java index 32049d2f5e9..415715d7500 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/deposits/DepositSenderService.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/deposits/DepositSenderService.java @@ -58,7 +58,7 @@ public void close() { executorService.shutdownNow(); } - public SafeFuture sendDeposit(ValidatorKeys validatorKeys) { + public SafeFuture sendDeposit(final ValidatorKeys validatorKeys) { final BLSKeyPair validatorKey = validatorKeys.getValidatorKey(); return sender.sendDepositTransaction( validatorKey, validatorKeys.getWithdrawalCredentials(), amount); diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/deposits/DepositTransactionSender.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/deposits/DepositTransactionSender.java index 080889a8207..0205e4778de 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/deposits/DepositTransactionSender.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/deposits/DepositTransactionSender.java @@ -62,7 +62,9 @@ public DepositTransactionSender( } public SafeFuture sendDepositTransaction( - BLSKeyPair validatorKeyPair, final Bytes32 withdrawalCredentials, final UInt64 amountInGwei) { + final BLSKeyPair validatorKeyPair, + final Bytes32 withdrawalCredentials, + final UInt64 amountInGwei) { final DepositData depositData = depositGenerator.createDepositData(validatorKeyPair, amountInGwei, withdrawalCredentials); diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/deposits/ValidatorKeys.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/deposits/ValidatorKeys.java index 3025eebe204..462d7328046 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/deposits/ValidatorKeys.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/deposits/ValidatorKeys.java @@ -22,7 +22,7 @@ public class ValidatorKeys { private final BLSKeyPair validatorKey; - private boolean locked = false; + private final boolean locked; private final Bytes32 withdrawalCredentials; private final Optional withdrawalKey; diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/deposits/ValidatorKeystoreGenerator.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/deposits/ValidatorKeystoreGenerator.java index 508a9f46cab..32534b4f17b 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/deposits/ValidatorKeystoreGenerator.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/deposits/ValidatorKeystoreGenerator.java @@ -30,10 +30,10 @@ public class ValidatorKeystoreGenerator { private final Path passwordsOutputPath; public ValidatorKeystoreGenerator( - String validatorKeyPassword, - Path keysOutputPath, - Path passwordsOutputPath, - Consumer commandOutput) { + final String validatorKeyPassword, + final Path keysOutputPath, + final Path passwordsOutputPath, + final Consumer commandOutput) { // Withdrawal key password is unnecessary for this mode of running. this.encryptedKeystoreWriter = new EncryptedKeystoreWriter( @@ -67,7 +67,7 @@ public void generateKeystoreAndPasswordFiles(final List validator } } - public void createDirectory(Path directoryPath) { + public void createDirectory(final Path directoryPath) { try { Files.createDirectories(directoryPath); } catch (IOException e) { diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/deposits/ValidatorKeystores.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/deposits/ValidatorKeystores.java index 4c08280311d..38d8e69e2a5 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/deposits/ValidatorKeystores.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/dsl/tools/deposits/ValidatorKeystores.java @@ -55,7 +55,7 @@ public class ValidatorKeystores { Optional maybeTarball = Optional.empty(); - public ValidatorKeystores(List validatorKeys) { + public ValidatorKeystores(final List validatorKeys) { this.validatorKeys = validatorKeys; } @@ -150,7 +150,7 @@ public void writeToTempDir(final Path tempDir) { keystoreGenerator.generateKeystoreAndPasswordFiles(validatorKeys); } - private static void copyDirectoryToTarFile(Path inputDirectoryPath, Path outputPath) + private static void copyDirectoryToTarFile(final Path inputDirectoryPath, final Path outputPath) throws IOException { File outputFile = outputPath.toFile(); diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/stubServer/RemoteMetricsServiceStub.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/stubServer/RemoteMetricsServiceStub.java index 4fb800c13e3..e07d11f507a 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/stubServer/RemoteMetricsServiceStub.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/stubServer/RemoteMetricsServiceStub.java @@ -19,9 +19,9 @@ import java.net.InetSocketAddress; public class RemoteMetricsServiceStub { - private HttpServer server; + private final HttpServer server; - public RemoteMetricsServiceStub(InetSocketAddress inetSocketAddress) throws IOException { + public RemoteMetricsServiceStub(final InetSocketAddress inetSocketAddress) throws IOException { server = HttpServer.create(inetSocketAddress, 0); } @@ -36,7 +36,7 @@ public void stopServer() { } } - public void registerHandler(String uriToHandle, HttpHandler httpHandler) { + public void registerHandler(final String uriToHandle, final HttpHandler httpHandler) { server.createContext(uriToHandle, httpHandler); } } diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/stubServer/ReplyHandler.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/stubServer/ReplyHandler.java index ba8575a6f42..6dc0fac85da 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/stubServer/ReplyHandler.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/stubServer/ReplyHandler.java @@ -23,12 +23,12 @@ public class ReplyHandler implements HttpHandler { SuccessHandler incoming; - public ReplyHandler(SuccessHandler incoming) { + public ReplyHandler(final SuccessHandler incoming) { this.incoming = incoming; } @Override - public void handle(HttpExchange exchange) throws IOException { + public void handle(final HttpExchange exchange) throws IOException { String response = incoming.getResponse(); exchange.getResponseHeaders().add("Content-Type", "application/json"); exchange.sendResponseHeaders(HttpURLConnection.HTTP_OK, response.length()); diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/stubServer/StubServer.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/stubServer/StubServer.java index e97f885cc96..f97b165de78 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/stubServer/StubServer.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/stubServer/StubServer.java @@ -17,7 +17,7 @@ public class StubServer { - public static void main(String[] args) throws Throwable { + public static void main(final String[] args) throws Throwable { RemoteMetricsServiceStub remoteMetricsServiceStub = new RemoteMetricsServiceStub(new InetSocketAddress(8001)); SuccessHandler handler = new SuccessHandler(); diff --git a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/stubServer/SuccessHandler.java b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/stubServer/SuccessHandler.java index 3983368c70b..3ad3de031d5 100644 --- a/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/stubServer/SuccessHandler.java +++ b/acceptance-tests/src/testFixtures/java/tech/pegasys/teku/test/acceptance/stubServer/SuccessHandler.java @@ -30,7 +30,7 @@ public String getResponse() { } @Override - public void handle(HttpExchange exchange) throws IOException { + public void handle(final HttpExchange exchange) throws IOException { InputStream is = exchange.getRequestBody(); this.responseBody = new String(is.readAllBytes(), StandardCharsets.UTF_8); String response = "ok"; diff --git a/acceptance-tests/src/testFixtures/resources/besu/pragueGenesis.json b/acceptance-tests/src/testFixtures/resources/besu/pragueGenesis.json new file mode 100644 index 00000000000..212da5532ae --- /dev/null +++ b/acceptance-tests/src/testFixtures/resources/besu/pragueGenesis.json @@ -0,0 +1,109 @@ +{ + "config": { + "chainId": 5, + "homesteadBlock": 0, + "eip150Block": 0, + "eip155Block": 0, + "eip158Block": 0, + "byzantiumBlock": 0, + "constantinopleBlock": 0, + "petersburgBlock": 0, + "istanbulBlock": 0, + "berlinBlock": 0, + "londonBlock": 0, + "terminalTotalDifficulty": 0, + "shanghaiTime": 0, + "cancunTime": 0, + "ethash": { + "fixeddifficulty": 100 + } + }, + "nonce":"0x42", + "timestamp":"0x0", + "extraData":"0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa", + "gasLimit":"0x1fffffffffffff", + "difficulty":"0x01", + "mixHash":"0x0000000000000000000000000000000000000000000000000000000000000000", + "coinbase":"0x0000000000000000000000000000000000000000", + "baseFeePerGas": "0x01", + "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000", + "alloc":{ + "fe3b557e8fb62b89f4916b721be55ceb828dbd73": { + "privateKey": "8f2a55949038a9610f50fb23b5883af3b4ecb3c3bb792cbcefbd1542c692be63", + "comment": "private key and this comment are ignored. In a real chain, the private key should NOT be stored", + "balance": "0xffffad78ebc5ac6200000" + }, + "0xa4664C40AACeBD82A2Db79f0ea36C06Bc6A19Adb": { + "balance": "1000000000000000000000000000" + }, + "0x23618e81E3f5cdF7f54C3d65f7FBc0aBf5B21E8f": { + "comment": "This is the account used to sign the transactions that create a validator exit, and consolidation request", + "balance": "1000000000000000000000000000" + }, + "0x00A3ca265EBcb825B45F985A16CEFB49958cE017": { + "comment": "This is the runtime bytecode for the Withdrawal Request Smart Contract. It was created from the deployment transaction in EIP-7002 (https://eips.ethereum.org/EIPS/eip-7002#deployment)", + "balance": "0", + "code": "0x3373fffffffffffffffffffffffffffffffffffffffe146090573615156028575f545f5260205ff35b36603814156101215760115f54600182026001905f5b5f82111560595781019083028483029004916001019190603e565b90939004341061012157600154600101600155600354806003026004013381556001015f3581556001016020359055600101600355005b6003546002548082038060101160a4575060105b5f5b81811460dd5780604c02838201600302600401805490600101805490600101549160601b83528260140152906034015260010160a6565b910180921460ed579060025560f8565b90505f6002555f6003555b5f5460015460028282011161010f5750505f610115565b01600290035b5f555f600155604c025ff35b5f5ffd", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000000": "0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000001": "0000000000000000000000000000000000000000000000000000000000000001", + "0x0000000000000000000000000000000000000000000000000000000000000002": "0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000003": "0000000000000000000000000000000000000000000000000000000000000001", + "0x0000000000000000000000000000000000000000000000000000000000000004": "000000000000000000000000a4664C40AACeBD82A2Db79f0ea36C06Bc6A19Adb", + "0x0000000000000000000000000000000000000000000000000000000000000005": "b10a4a15bf67b328c9b101d09e5c6ee6672978fdad9ef0d9e2ceffaee9922355", + "0x0000000000000000000000000000000000000000000000000000000000000006": "5d8601f0cb3bcc4ce1af9864779a416e00000000000000000000000000000000" + } + }, + "0x00b42dbF2194e931E80326D950320f7d9Dbeac02": { + "comment": "This is the runtime bytecode for the Consolidation Request Smart Contract. It was created from the deployment transaction in EIP-7251 (https://eips.ethereum.org/EIPS/eip-7251#deployment)", + "balance": "0", + "code": "0x3373fffffffffffffffffffffffffffffffffffffffe146098573615156028575f545f5260205ff35b36606014156101445760115f54600182026001905f5b5f82111560595781019083028483029004916001019190603e565b90939004341061014457600154600101600155600354806004026004013381556001015f35815560010160203581556001016040359055600101600355005b6003546002548082038060011160ac575060015b5f5b81811460f15780607402838201600402600401805490600101805490600101805490600101549260601b84529083601401528260340152906054015260010160ae565b9101809214610103579060025561010e565b90505f6002555f6003555b5f548061049d141561011d57505f5b6001546001828201116101325750505f610138565b01600190035b5f555f6001556074025ff35b5f5ffd", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000000": "0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000001": "0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000002": "0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000003": "0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000004": "0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000005": "0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000006": "0000000000000000000000000000000000000000000000000000000000000000" + } + }, + "0x4242424242424242424242424242424242424242": { + "balance": "0", + "code": "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", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000022": "0xf5a5fd42d16a20302798ef6ed309979b43003d2320d9f0e8ea9831a92759fb4b", + "0x0000000000000000000000000000000000000000000000000000000000000023": "0xdb56114e00fdd4c1f85c892bf35ac9a89289aaecb1ebd0a96cde606a748b5d71", + "0x0000000000000000000000000000000000000000000000000000000000000024": "0xc78009fdf07fc56a11f122370658a353aaa542ed63e44c4bc15ff4cd105ab33c", + "0x0000000000000000000000000000000000000000000000000000000000000025": "0x536d98837f2dd165a55d5eeae91485954472d56f246df256bf3cae19352a123c", + "0x0000000000000000000000000000000000000000000000000000000000000026": "0x9efde052aa15429fae05bad4d0b1d7c64da64d03d7a1854a588c2cb8430c0d30", + "0x0000000000000000000000000000000000000000000000000000000000000027": "0xd88ddfeed400a8755596b21942c1497e114c302e6118290f91e6772976041fa1", + "0x0000000000000000000000000000000000000000000000000000000000000028": "0x87eb0ddba57e35f6d286673802a4af5975e22506c7cf4c64bb6be5ee11527f2c", + "0x0000000000000000000000000000000000000000000000000000000000000029": "0x26846476fd5fc54a5d43385167c95144f2643f533cc85bb9d16b782f8d7db193", + "0x000000000000000000000000000000000000000000000000000000000000002a": "0x506d86582d252405b840018792cad2bf1259f1ef5aa5f887e13cb2f0094f51e1", + "0x000000000000000000000000000000000000000000000000000000000000002b": "0xffff0ad7e659772f9534c195c815efc4014ef1e1daed4404c06385d11192e92b", + "0x000000000000000000000000000000000000000000000000000000000000002c": "0x6cf04127db05441cd833107a52be852868890e4317e6a02ab47683aa75964220", + "0x000000000000000000000000000000000000000000000000000000000000002d": "0xb7d05f875f140027ef5118a2247bbb84ce8f2f0f1123623085daf7960c329f5f", + "0x000000000000000000000000000000000000000000000000000000000000002e": "0xdf6af5f5bbdb6be9ef8aa618e4bf8073960867171e29676f8b284dea6a08a85e", + "0x000000000000000000000000000000000000000000000000000000000000002f": "0xb58d900f5e182e3c50ef74969ea16c7726c549757cc23523c369587da7293784", + "0x0000000000000000000000000000000000000000000000000000000000000030": "0xd49a7502ffcfb0340b1d7885688500ca308161a7f96b62df9d083b71fcc8f2bb", + "0x0000000000000000000000000000000000000000000000000000000000000031": "0x8fe6b1689256c0d385f42f5bbe2027a22c1996e110ba97c171d3e5948de92beb", + "0x0000000000000000000000000000000000000000000000000000000000000032": "0x8d0d63c39ebade8509e0ae3c9c3876fb5fa112be18f905ecacfecb92057603ab", + "0x0000000000000000000000000000000000000000000000000000000000000033": "0x95eec8b2e541cad4e91de38385f2e046619f54496c2382cb6cacd5b98c26f5a4", + "0x0000000000000000000000000000000000000000000000000000000000000034": "0xf893e908917775b62bff23294dbbe3a1cd8e6cc1c35b4801887b646a6f81f17f", + "0x0000000000000000000000000000000000000000000000000000000000000035": "0xcddba7b592e3133393c16194fac7431abf2f5485ed711db282183c819e08ebaa", + "0x0000000000000000000000000000000000000000000000000000000000000036": "0x8a8d7fe3af8caa085a7639a832001457dfb9128a8061142ad0335629ff23ff9c", + "0x0000000000000000000000000000000000000000000000000000000000000037": "0xfeb3c337d7a51a6fbf00b9e34c52e1c9195c969bd4e7a0bfd51d5c5bed9c1167", + "0x0000000000000000000000000000000000000000000000000000000000000038": "0xe71f0aa83cc32edfbefa9f4d3e0174ca85182eec9f3a09f6a6c0df6377a510d7", + "0x0000000000000000000000000000000000000000000000000000000000000039": "0x31206fa80a50bb6abe29085058f16212212a60eec8f049fecb92d8c8e0a84bc0", + "0x000000000000000000000000000000000000000000000000000000000000003a": "0x21352bfecbeddde993839f614c3dac0a3ee37543f9b412b16199dc158e23b544", + "0x000000000000000000000000000000000000000000000000000000000000003b": "0x619e312724bb6d7c3153ed9de791d764a366b389af13c58bf8a8d90481a46765", + "0x000000000000000000000000000000000000000000000000000000000000003c": "0x7cdd2986268250628d0c10e385c58c6191e6fbe05191bcc04f133f2cea72c1c4", + "0x000000000000000000000000000000000000000000000000000000000000003d": "0x848930bd7ba8cac54661072113fb278869e07bb8587f91392933374d017bcbe1", + "0x000000000000000000000000000000000000000000000000000000000000003e": "0x8869ff2c22b28cc10510d9853292803328be4fb0e80495e8bb8d271f5b889636", + "0x000000000000000000000000000000000000000000000000000000000000003f": "0xb5fe28e79f1b850f8658246ce9b6a1e7b49fc06db7143e8fe0b4f2b0c5523a5c", + "0x0000000000000000000000000000000000000000000000000000000000000040": "0x985e929f70af28d0bdd1a90a808f977f597c7c778c489e98d3bd8910d31ac0f7" + } + } + } +} \ No newline at end of file diff --git a/beacon/pow/build.gradle b/beacon/pow/build.gradle index 80e89168f32..d5e8f10e189 100644 --- a/beacon/pow/build.gradle +++ b/beacon/pow/build.gradle @@ -18,7 +18,7 @@ dependencies { api 'org.web3j:core' - implementation 'org.apache.tuweni:tuweni-units' + implementation 'io.tmio:tuweni-units' testImplementation testFixtures(project(':infrastructure:async')) testImplementation testFixtures(project(':infrastructure:time')) diff --git a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/AbstractMonitorableEth1Provider.java b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/AbstractMonitorableEth1Provider.java index d833c503649..bdeba1f3275 100644 --- a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/AbstractMonitorableEth1Provider.java +++ b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/AbstractMonitorableEth1Provider.java @@ -30,16 +30,16 @@ protected enum Result { protected Result lastCallResult = Result.FAILED; protected Result lastValidationResult = Result.FAILED; - protected AbstractMonitorableEth1Provider(TimeProvider timeProvider) { + protected AbstractMonitorableEth1Provider(final TimeProvider timeProvider) { this.timeProvider = timeProvider; } - protected synchronized void updateLastValidation(Result result) { + protected synchronized void updateLastValidation(final Result result) { lastValidationTime = timeProvider.getTimeInSeconds(); lastValidationResult = result; } - protected synchronized void updateLastCall(Result result) { + protected synchronized void updateLastCall(final Result result) { lastCallTime = timeProvider.getTimeInSeconds(); lastCallResult = result; } diff --git a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/DepositEventsAccessor.java b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/DepositEventsAccessor.java index eaf0bcca2b4..074a200ad45 100644 --- a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/DepositEventsAccessor.java +++ b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/DepositEventsAccessor.java @@ -27,13 +27,13 @@ public class DepositEventsAccessor { private final Eth1Provider eth1Provider; private final String contractAddress; - public DepositEventsAccessor(Eth1Provider eth1Provider, String contractAddress) { + public DepositEventsAccessor(final Eth1Provider eth1Provider, final String contractAddress) { this.eth1Provider = eth1Provider; this.contractAddress = contractAddress; } public SafeFuture> depositEventInRange( - DefaultBlockParameter startBlock, DefaultBlockParameter endBlock) { + final DefaultBlockParameter startBlock, final DefaultBlockParameter endBlock) { final EthFilter filter = new EthFilter(startBlock, endBlock, this.contractAddress); filter.addSingleTopic(EventEncoder.encode(DepositContract.DEPOSITEVENT_EVENT)); return SafeFuture.of( diff --git a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/DepositFetcher.java b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/DepositFetcher.java index e38414e2acb..5cd9a691ec7 100644 --- a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/DepositFetcher.java +++ b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/DepositFetcher.java @@ -84,7 +84,7 @@ public DepositFetcher( // Inclusive on both sides public synchronized SafeFuture fetchDepositsInRange( - BigInteger fromBlockNumber, BigInteger toBlockNumber) { + final BigInteger fromBlockNumber, final BigInteger toBlockNumber) { checkArgument( fromBlockNumber.compareTo(toBlockNumber) <= 0, "From block number (%s) must be less than or equal to block number (%s)", @@ -161,16 +161,17 @@ private SafeFuture processDepositsInBatch( } private SafeFuture postDepositEvents( - List> blockRequests, - Map> depositEventsByBlock, - BigInteger fromBlock, - BigInteger toBlock) { + final List> blockRequests, + final Map> + depositEventsByBlock, + final BigInteger fromBlock, + final BigInteger toBlock) { LOG.trace("Posting deposit events for {} blocks", depositEventsByBlock.size()); BigInteger from = fromBlock; // First process completed requests using iteration. // Avoid StackOverflowException when there is a long string of requests already completed. - while (!blockRequests.isEmpty() && blockRequests.get(0).isDone()) { - final EthBlock.Block block = blockRequests.remove(0).join(); + while (!blockRequests.isEmpty() && blockRequests.getFirst().isDone()) { + final EthBlock.Block block = blockRequests.removeFirst().join(); // Fetch any empty blocks between this deposit block and the previous one (or start of range) final BigInteger to = block.getNumber().subtract(BigInteger.ONE); @@ -220,7 +221,7 @@ private DepositsFromBlockEvent createDepositFromBlockEvent( } private List> getListOfEthBlockFutures( - Set neededBlockHashes) { + final Set neededBlockHashes) { return neededBlockHashes.stream() .map(BlockNumberAndHash::getHash) .map(eth1Provider::getGuaranteedEth1Block) @@ -229,7 +230,7 @@ private List> getListOfEthBlockFutures( private NavigableMap> groupDepositEventResponsesByBlockHash( - List events) { + final List events) { return events.stream() .collect( groupingBy( @@ -239,7 +240,7 @@ private List> getListOfEthBlockFutures( toList())); } - private void postDeposits(DepositsFromBlockEvent event) { + private void postDeposits(final DepositsFromBlockEvent event) { eth1EventsChannel.onDepositsFromBlock(event); } diff --git a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/DepositProcessingController.java b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/DepositProcessingController.java index 7545d5a0722..ca8be5a4e47 100644 --- a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/DepositProcessingController.java +++ b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/DepositProcessingController.java @@ -51,13 +51,13 @@ public class DepositProcessingController { private final Eth1BlockFetcher eth1BlockFetcher; public DepositProcessingController( - SpecConfig config, - Eth1Provider eth1Provider, - Eth1EventsChannel eth1EventsChannel, - AsyncRunner asyncRunner, - DepositFetcher depositFetcher, - Eth1BlockFetcher eth1BlockFetcher, - Eth1HeadTracker headTracker) { + final SpecConfig config, + final Eth1Provider eth1Provider, + final Eth1EventsChannel eth1EventsChannel, + final AsyncRunner asyncRunner, + final DepositFetcher depositFetcher, + final Eth1BlockFetcher eth1BlockFetcher, + final Eth1HeadTracker headTracker) { this.config = config; this.eth1Provider = eth1Provider; this.eth1EventsChannel = eth1EventsChannel; @@ -73,7 +73,7 @@ public synchronized void switchToBlockByBlockMode() { } // inclusive of start block - public synchronized void startSubscription(BigInteger subscriptionStartBlock) { + public synchronized void startSubscription(final BigInteger subscriptionStartBlock) { LOG.debug("Starting subscription at block {}", subscriptionStartBlock); latestSuccessfullyQueriedBlock = subscriptionStartBlock.subtract(BigInteger.ONE); newBlockSubscription = headTracker.subscribe(this::onNewCanonicalBlockNumber); @@ -89,7 +89,7 @@ public synchronized SafeFuture fetchDepositsInRange( return depositFetcher.fetchDepositsInRange(fromBlockNumber, toBlockNumber); } - private synchronized void onNewCanonicalBlockNumber(UInt64 newCanonicalBlockNumber) { + private synchronized void onNewCanonicalBlockNumber(final UInt64 newCanonicalBlockNumber) { this.latestCanonicalBlockNumber = newCanonicalBlockNumber.bigIntegerValue(); fetchLatestSubscriptionDeposits(); } @@ -165,7 +165,8 @@ private boolean isActiveOrAlreadyQueriedLatestCanonicalBlock() { return active || latestCanonicalBlockNumber.compareTo(latestSuccessfullyQueriedBlock) <= 0; } - private synchronized void onSubscriptionDepositRequestSuccessful(BigInteger requestToBlock) { + private synchronized void onSubscriptionDepositRequestSuccessful( + final BigInteger requestToBlock) { active = false; latestSuccessfullyQueriedBlock = requestToBlock; if (latestCanonicalBlockNumber.compareTo(latestSuccessfullyQueriedBlock) > 0) { @@ -177,12 +178,12 @@ private synchronized void onSubscriptionDepositRequestSuccessful(BigInteger requ } private synchronized void onSubscriptionDepositRequestFailed( - Throwable err, BigInteger fromBlock) { + final Throwable err, final BigInteger fromBlock) { onSubscriptionDepositRequestFailed(err, fromBlock, fromBlock); } private synchronized void onSubscriptionDepositRequestFailed( - Throwable err, BigInteger fromBlock, BigInteger toBlock) { + final Throwable err, final BigInteger fromBlock, final BigInteger toBlock) { active = false; if (Throwables.getRootCause(err) instanceof InvalidDepositEventsException) { diff --git a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/DepositSnapshotFileLoader.java b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/DepositSnapshotFileLoader.java index e0d725a46f4..c8bec492e92 100644 --- a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/DepositSnapshotFileLoader.java +++ b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/DepositSnapshotFileLoader.java @@ -46,7 +46,6 @@ public record DepositSnapshotResource(String resource, boolean required) {} public static final Map DEFAULT_SNAPSHOT_RESOURCE_PATHS = Map.of( Eth2Network.GNOSIS, "gnosis.ssz", - Eth2Network.PRATER, "goerli.ssz", Eth2Network.MAINNET, "mainnet.ssz", Eth2Network.SEPOLIA, "sepolia.ssz", Eth2Network.LUKSO, "lukso.ssz", @@ -80,7 +79,7 @@ public LoadDepositSnapshotResult loadDepositSnapshot() { "Deposit tree snapshot loaded from " + sanitizedUrl + " is not a correct snapshot", e); } else { - LOG.warn("Failed to load deposit tree snapshot from " + sanitizedUrl, e); + LOG.warn("Failed to load deposit tree snapshot from " + sanitizedUrl, e.getMessage()); } if (isRequired) { @@ -98,7 +97,9 @@ private DepositTreeSnapshot loadFromUrl(final String path) throws IOException { ResourceLoader.urlOrFile("application/octet-stream, application/json") .loadBytes(path) .orElseThrow( - () -> new FileNotFoundException(String.format("File '%s' not found", path))); + () -> + new FileNotFoundException( + String.format("Failed to load deposit tree snapshot from %s", path))); try { return parseSszDepositSnapshotTreeData(snapshotData); diff --git a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/ErrorTrackingEth1Provider.java b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/ErrorTrackingEth1Provider.java index db4a60c8984..0217962c0d7 100644 --- a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/ErrorTrackingEth1Provider.java +++ b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/ErrorTrackingEth1Provider.java @@ -96,7 +96,7 @@ public SafeFuture ethSyncing() { } @Override - public SafeFuture>> ethGetLogs(EthFilter ethFilter) { + public SafeFuture>> ethGetLogs(final EthFilter ethFilter) { return logStatus(delegate.ethGetLogs(ethFilter)); } diff --git a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/Eth1BlockFetcher.java b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/Eth1BlockFetcher.java index 910eca0c31c..5290c135358 100644 --- a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/Eth1BlockFetcher.java +++ b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/Eth1BlockFetcher.java @@ -147,11 +147,11 @@ private void backfillEth1Blocks(final UInt64 nextBlockToRequest) { error -> LOG.error("Unexpected error while back-filling ETH1 blocks", error)); } - private boolean isAboveLowerBound(UInt64 timestamp) { + private boolean isAboveLowerBound(final UInt64 timestamp) { return timestamp.compareTo(getCacheRangeLowerBound(timeProvider.getTimeInSeconds())) >= 0; } - private UInt64 getCacheRangeLowerBound(UInt64 currentTime) { + private UInt64 getCacheRangeLowerBound(final UInt64 currentTime) { return currentTime.compareTo(cacheDuration) > 0 ? currentTime.minus(cacheDuration) : ZERO; } } diff --git a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/Eth1Provider.java b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/Eth1Provider.java index 595caadf49f..10d891c2d0e 100644 --- a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/Eth1Provider.java +++ b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/Eth1Provider.java @@ -34,7 +34,7 @@ public interface Eth1Provider { SafeFuture> getEth1BlockWithRetry( UInt64 blockNumber, Duration retryDelay, int maxRetries); - default SafeFuture> getEth1BlockWithRetry(UInt64 blockNumber) { + default SafeFuture> getEth1BlockWithRetry(final UInt64 blockNumber) { return getEth1BlockWithRetry(blockNumber, Duration.ofSeconds(5), 2); } @@ -43,7 +43,7 @@ default SafeFuture> getEth1BlockWithRetry(UInt64 blockNumber) { SafeFuture> getEth1BlockWithRetry( String blockHash, Duration retryDelay, int maxRetries); - default SafeFuture> getEth1BlockWithRetry(String blockHash) { + default SafeFuture> getEth1BlockWithRetry(final String blockHash) { return getEth1BlockWithRetry(blockHash, Duration.ofSeconds(5), 2); } diff --git a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/FallbackAwareEth1Provider.java b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/FallbackAwareEth1Provider.java index b86ccd7baa4..ee1ed5792e8 100644 --- a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/FallbackAwareEth1Provider.java +++ b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/FallbackAwareEth1Provider.java @@ -131,7 +131,7 @@ public SafeFuture ethSyncing() { } @Override - public SafeFuture>> ethGetLogs(EthFilter ethFilter) { + public SafeFuture>> ethGetLogs(final EthFilter ethFilter) { return run(eth1Provider -> eth1Provider.ethGetLogs(ethFilter)); } diff --git a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/MinimumGenesisTimeBlockFinder.java b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/MinimumGenesisTimeBlockFinder.java index 36c94a77549..ea4b424fb1d 100644 --- a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/MinimumGenesisTimeBlockFinder.java +++ b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/MinimumGenesisTimeBlockFinder.java @@ -46,9 +46,9 @@ public class MinimumGenesisTimeBlockFinder { private final Optional eth1DepositContractDeployBlock; public MinimumGenesisTimeBlockFinder( - SpecConfig config, - Eth1Provider eth1Provider, - Optional eth1DepositContractDeployBlock) { + final SpecConfig config, + final Eth1Provider eth1Provider, + final Optional eth1DepositContractDeployBlock) { this.config = config; this.eth1Provider = eth1Provider; this.eth1DepositContractDeployBlock = eth1DepositContractDeployBlock; @@ -191,12 +191,15 @@ private boolean blockIsAtOrAfterMinGenesis(final SpecConfig config, final EthBlo } private void traceWithBlock( - final String message, final EthBlock.Block block, Object... otherArgs) { + final String message, final EthBlock.Block block, final Object... otherArgs) { logWithBlock(Level.TRACE, message, block, otherArgs); } private void logWithBlock( - final Level level, final String message, final EthBlock.Block block, Object... otherArgs) { + final Level level, + final String message, + final EthBlock.Block block, + final Object... otherArgs) { final Object[] args = new Object[otherArgs.length + 3]; System.arraycopy(otherArgs, 0, args, 0, otherArgs.length); @@ -211,16 +214,18 @@ private UInt64 calculateMinGenesisTimeThreshold() { return config.getMinGenesisTime().minusMinZero(config.getGenesisDelay()); } - static UInt64 calculateCandidateGenesisTimestamp(SpecConfig config, BigInteger eth1Timestamp) { + static UInt64 calculateCandidateGenesisTimestamp( + final SpecConfig config, final BigInteger eth1Timestamp) { return UInt64.valueOf(eth1Timestamp).plus(config.getGenesisDelay()); } - static int compareBlockTimestampToMinGenesisTime(SpecConfig config, EthBlock.Block block) { + static int compareBlockTimestampToMinGenesisTime( + final SpecConfig config, final EthBlock.Block block) { return calculateCandidateGenesisTimestamp(config, block.getTimestamp()) .compareTo(config.getMinGenesisTime()); } - static Boolean isBlockAfterMinGenesis(SpecConfig config, EthBlock.Block block) { + static Boolean isBlockAfterMinGenesis(final SpecConfig config, final EthBlock.Block block) { int comparison = compareBlockTimestampToMinGenesisTime(config, block); // If block timestamp is greater than min genesis time, // min genesis block must be in the future @@ -228,7 +233,7 @@ static Boolean isBlockAfterMinGenesis(SpecConfig config, EthBlock.Block block) { } static void notifyMinGenesisTimeBlockReached( - Eth1EventsChannel eth1EventsChannel, EthBlock.Block block) { + final Eth1EventsChannel eth1EventsChannel, final EthBlock.Block block) { MinGenesisTimeBlockEvent event = new MinGenesisTimeBlockEvent( UInt64.valueOf(block.getTimestamp()), diff --git a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/ThrottlingEth1Provider.java b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/ThrottlingEth1Provider.java index 5028cee4beb..0dad37ed2a0 100644 --- a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/ThrottlingEth1Provider.java +++ b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/ThrottlingEth1Provider.java @@ -106,7 +106,7 @@ public SafeFuture ethSyncing() { } @Override - public SafeFuture>> ethGetLogs(EthFilter ethFilter) { + public SafeFuture>> ethGetLogs(final EthFilter ethFilter) { return taskQueue.queueTask(() -> delegate.ethGetLogs(ethFilter)); } } diff --git a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/ValidatingEth1EventsPublisher.java b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/ValidatingEth1EventsPublisher.java index df207bd7b77..f3fc1c5f992 100644 --- a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/ValidatingEth1EventsPublisher.java +++ b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/ValidatingEth1EventsPublisher.java @@ -60,7 +60,7 @@ private void assertDepositEventIsValid(final DepositsFromBlockEvent event) { } @Override - public void onInitialDepositTreeSnapshot(DepositTreeSnapshot depositTreeSnapshot) { + public void onInitialDepositTreeSnapshot(final DepositTreeSnapshot depositTreeSnapshot) { delegate.onInitialDepositTreeSnapshot(depositTreeSnapshot); } } diff --git a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/Web3jEth1Provider.java b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/Web3jEth1Provider.java index 34a972805a6..afbc3c48d40 100644 --- a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/Web3jEth1Provider.java +++ b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/Web3jEth1Provider.java @@ -181,7 +181,7 @@ public SafeFuture getGuaranteedLatestEth1Block() { @Override public SafeFuture ethCall( - final String from, String to, String data, final UInt64 blockNumber) { + final String from, final String to, final String data, final UInt64 blockNumber) { return SafeFuture.of( web3j .ethCall( @@ -203,7 +203,7 @@ public SafeFuture ethSyncing() { @Override @SuppressWarnings({"unchecked", "rawtypes"}) - public SafeFuture>> ethGetLogs(EthFilter ethFilter) { + public SafeFuture>> ethGetLogs(final EthFilter ethFilter) { return sendAsync(web3j.ethGetLogs(ethFilter)) .thenApply(EthLog::getLogs) .thenApply(logs -> (List>) (List) logs); diff --git a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/contract/DepositContract.java b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/contract/DepositContract.java index c2a5a08e93a..60216aaeb69 100644 --- a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/contract/DepositContract.java +++ b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/contract/DepositContract.java @@ -57,23 +57,23 @@ public class DepositContract extends Contract { new TypeReference() {})); protected DepositContract( - String contractAddress, - Web3j web3j, - TransactionManager transactionManager, - ContractGasProvider contractGasProvider) { + final String contractAddress, + final Web3j web3j, + final TransactionManager transactionManager, + final ContractGasProvider contractGasProvider) { super(BINARY, contractAddress, web3j, transactionManager, contractGasProvider); } - public static EventValuesWithLog staticExtractDepositEventWithLog(Log log) { + public static EventValuesWithLog staticExtractDepositEventWithLog(final Log log) { return staticExtractEventParametersWithLog(DEPOSITEVENT_EVENT, log); } public RemoteFunctionCall deposit( - byte[] pubkey, - byte[] withdrawalCredentials, - byte[] signature, - byte[] depositDataRoot, - BigInteger weiValue) { + final byte[] pubkey, + final byte[] withdrawalCredentials, + final byte[] signature, + final byte[] depositDataRoot, + final BigInteger weiValue) { final Function function = new Function( FUNC_DEPOSIT, @@ -87,10 +87,10 @@ public RemoteFunctionCall deposit( } public static DepositContract load( - String contractAddress, - Web3j web3j, - TransactionManager transactionManager, - ContractGasProvider contractGasProvider) { + final String contractAddress, + final Web3j web3j, + final TransactionManager transactionManager, + final ContractGasProvider contractGasProvider) { return new DepositContract(contractAddress, web3j, transactionManager, contractGasProvider); } diff --git a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/exception/Eth1RequestException.java b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/exception/Eth1RequestException.java index c859824607f..0cd4d67a06a 100644 --- a/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/exception/Eth1RequestException.java +++ b/beacon/pow/src/main/java/tech/pegasys/teku/beacon/pow/exception/Eth1RequestException.java @@ -24,7 +24,7 @@ public Eth1RequestException() { super("Some eth1 endpoints threw an Exception or no eth1 endpoints available"); } - public static boolean shouldTryWithSmallerRange(Throwable err) { + public static boolean shouldTryWithSmallerRange(final Throwable err) { return ExceptionUtil.hasCause( err, SocketTimeoutException.class, diff --git a/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/DepositProcessingControllerTest.java b/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/DepositProcessingControllerTest.java index ab9320858fe..e6b458ede93 100644 --- a/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/DepositProcessingControllerTest.java +++ b/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/DepositProcessingControllerTest.java @@ -53,7 +53,7 @@ public class DepositProcessingControllerTest { private DepositProcessingController depositProcessingController; private void createDepositProcessingController(final Consumer configModifier) { - final SpecConfig config = SpecConfigLoader.loadConfig("minimal", configModifier); + final SpecConfig config = SpecConfigLoader.loadConfig("minimal", configModifier).specConfig(); depositProcessingController = new DepositProcessingController( config, @@ -199,7 +199,8 @@ void shouldNotFetchDepositsWhenCanonicalHeadIsBeforeLatestSuccessfullyQueriedBlo verifyNoInteractions(depositFetcher); } - private void mockBlockForEth1Provider(String blockHash, long blockNumber, long timestamp) { + private void mockBlockForEth1Provider( + final String blockHash, final long blockNumber, final long timestamp) { EthBlock.Block block = mock(EthBlock.Block.class); when(block.getTimestamp()).thenReturn(BigInteger.valueOf(timestamp)); when(block.getNumber()).thenReturn(BigInteger.valueOf(blockNumber)); @@ -209,7 +210,7 @@ private void mockBlockForEth1Provider(String blockHash, long blockNumber, long t } @SuppressWarnings("unchecked") - private void pushLatestCanonicalBlockWithNumber(long latestBlockNumber) { + private void pushLatestCanonicalBlockWithNumber(final long latestBlockNumber) { final ArgumentCaptor> captor = ArgumentCaptor.forClass(ValueObserver.class); verify(headTracker).subscribe(captor.capture()); diff --git a/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/DepositSnapshotFileLoaderTest.java b/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/DepositSnapshotFileLoaderTest.java index 47796d4f74d..a7d5e602100 100644 --- a/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/DepositSnapshotFileLoaderTest.java +++ b/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/DepositSnapshotFileLoaderTest.java @@ -122,7 +122,7 @@ public void shouldThrowException_whenRequiredResourceInChainFails() { assertThatThrownBy(() -> depositSnapshotLoader.loadDepositSnapshot()) .isInstanceOf(InvalidConfigurationException.class) - .hasMessageContaining("File '/foo/empty2' not found"); + .hasMessageContaining("Failed to load deposit tree snapshot from /foo/empty2"); } @Test @@ -135,7 +135,7 @@ public void shouldThrowException_whenFirstRequiredResourceInChainFails() { assertThatThrownBy(() -> depositSnapshotLoader.loadDepositSnapshot()) .isInstanceOf(InvalidConfigurationException.class) - .hasMessageContaining("File '/foo/empty1' not found"); + .hasMessageContaining("Failed to load deposit tree snapshot from /foo/empty1"); } @Test diff --git a/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/DepositsFetcherTest.java b/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/DepositsFetcherTest.java index b50e4745954..ad67ed77fc0 100644 --- a/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/DepositsFetcherTest.java +++ b/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/DepositsFetcherTest.java @@ -200,7 +200,8 @@ void shouldReduceBatchSizeWhenRequestIsRejected() { verifyNoMoreInteractions(depositEventsAccessor); } - private void mockBlockForEth1Provider(String blockHash, long blockNumber, long timestamp) { + private void mockBlockForEth1Provider( + final String blockHash, final long blockNumber, final long timestamp) { EthBlock.Block block = mock(EthBlock.Block.class); when(block.getTimestamp()).thenReturn(BigInteger.valueOf(timestamp)); when(block.getNumber()).thenReturn(BigInteger.valueOf(blockNumber)); @@ -210,7 +211,7 @@ private void mockBlockForEth1Provider(String blockHash, long blockNumber, long t } private SafeFuture> mockContractEventsInRange( - long fromBlockNumber, long toBlockNumber) { + final long fromBlockNumber, final long toBlockNumber) { SafeFuture> safeFuture = new SafeFuture<>(); doReturn(safeFuture) .when(depositEventsAccessor) @@ -227,7 +228,7 @@ private SafeFuture> mockContract } private DepositContract.DepositEventEventResponse mockDepositEventEventResponse( - long index, String blockHash, long blockNumber) { + final long index, final String blockHash, final long blockNumber) { Log log = mock(Log.class); when(log.getBlockHash()).thenReturn(blockHash); when(log.getBlockNumber()).thenReturn(BigInteger.valueOf(blockNumber)); diff --git a/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/Eth1BlockFetcherTest.java b/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/Eth1BlockFetcherTest.java index d3baacd2a89..9b734c36462 100644 --- a/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/Eth1BlockFetcherTest.java +++ b/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/Eth1BlockFetcherTest.java @@ -200,7 +200,7 @@ void shouldFetchBlocksLaterThanOneWhichWasBeforeTheCachePeriod() { blockFetcher.fetch(BigInteger.valueOf(6), BigInteger.valueOf(6)); verifyNoMoreInteractions(eth1Provider); - // When block 5 complete, it should request block 6 + // When block 5 is complete, it should request block 6 block5Future.complete(Optional.of(block5)); verify(eth1Provider).getEth1Block(UInt64.valueOf(6)); verifyNoMoreInteractions(eth1Provider); diff --git a/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/Eth1DepositManagerTest.java b/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/Eth1DepositManagerTest.java index 51665e1ea3b..8ef46c440de 100644 --- a/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/Eth1DepositManagerTest.java +++ b/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/Eth1DepositManagerTest.java @@ -56,9 +56,10 @@ class Eth1DepositManagerTest { private static final int MIN_GENESIS_BLOCK_TIMESTAMP = 10_000; private final SpecConfig config = SpecConfigLoader.loadConfig( - "minimal", - builder -> - builder.minGenesisTime(UInt64.valueOf(10_300)).genesisDelay(UInt64.valueOf(300))); + "minimal", + builder -> + builder.minGenesisTime(UInt64.valueOf(10_300)).genesisDelay(UInt64.valueOf(300))) + .specConfig(); private final Spec spec = TestSpecFactory.createMinimalBellatrix(); private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); diff --git a/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/FallbackAwareEth1ProviderTest.java b/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/FallbackAwareEth1ProviderTest.java index 1d6921c9cd6..d2b2a24abea 100644 --- a/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/FallbackAwareEth1ProviderTest.java +++ b/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/FallbackAwareEth1ProviderTest.java @@ -182,7 +182,7 @@ void shouldFallbackOnGetGuaranteedEth1Block_byHash() final SafeFuture blockByHash = fallbackAwareEth1Provider.getGuaranteedEth1Block(""); - // we expect a delayed action after all nodes has been contacted + // we expect a delayed action after all nodes have been contacted assertThat(asyncRunner.hasDelayedActions()).isTrue(); verify(node1, atLeastOnce()).getEth1Block(""); verify(node2, atLeastOnce()).getEth1Block(""); @@ -318,7 +318,7 @@ private static SafeFuture>> readyProviderGetLogs() { } private static SafeFuture>> failingProviderGetLogsWithError( - Throwable error) { + final Throwable error) { final SafeFuture>> logListSafeFuture = new SafeFuture<>(); logListSafeFuture.completeExceptionally(error); return logListSafeFuture; diff --git a/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/MinimumGenesisTimeBlockFinderTest.java b/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/MinimumGenesisTimeBlockFinderTest.java index babb31aac61..c772925166c 100644 --- a/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/MinimumGenesisTimeBlockFinderTest.java +++ b/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/MinimumGenesisTimeBlockFinderTest.java @@ -38,7 +38,8 @@ public class MinimumGenesisTimeBlockFinderTest { // Setup so genesis time for a block will be blockTime + 2 private final SpecConfig config = - SpecConfigLoader.loadConfig("minimal", builder -> builder.genesisDelay(UInt64.valueOf(2))); + SpecConfigLoader.loadConfig("minimal", builder -> builder.genesisDelay(UInt64.valueOf(2))) + .specConfig(); private final Eth1Provider eth1Provider = mock(Eth1Provider.class); private final StubAsyncRunner asyncRunner = new StubAsyncRunner(); @@ -303,7 +304,8 @@ private void withMinGenesisTime( final long minGenesisTime, final Optional eth1DepositContractDeployBlock) { final SpecConfig config = SpecConfigLoader.loadConfig( - "minimal", builder -> builder.minGenesisTime(UInt64.valueOf(minGenesisTime))); + "minimal", builder -> builder.minGenesisTime(UInt64.valueOf(minGenesisTime))) + .specConfig(); minimumGenesisTimeBlockFinder = new MinimumGenesisTimeBlockFinder(config, eth1Provider, eth1DepositContractDeployBlock); } diff --git a/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/TimeBasedEth1HeadTrackerTest.java b/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/TimeBasedEth1HeadTrackerTest.java index 9bf93c83f36..f661c0332ae 100644 --- a/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/TimeBasedEth1HeadTrackerTest.java +++ b/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/TimeBasedEth1HeadTrackerTest.java @@ -326,7 +326,7 @@ private List withBlockTimestamps(final long... timestamps) { } when(eth1Provider.getGuaranteedLatestEth1Block()) - .thenReturn(SafeFuture.completedFuture(blocks.get(blocks.size() - 1))); + .thenReturn(SafeFuture.completedFuture(blocks.getLast())); return blocks; } } diff --git a/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/Web3jEth1ProviderTest.java b/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/Web3jEth1ProviderTest.java index 47bd77f6384..0aec67d75ad 100644 --- a/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/Web3jEth1ProviderTest.java +++ b/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/Web3jEth1ProviderTest.java @@ -170,13 +170,13 @@ void needsToBeValidatedChecks() { // advance less then required timeProvider.advanceTimeBySeconds( - Constants.ETH1_INVALID_ENDPOINT_CHECK_INTERVAL.getSeconds() - 10); + Constants.ETH1_INVALID_ENDPOINT_CHECK_INTERVAL.toSeconds() - 10); // just failed, no need to validate assertThat(provider.needsToBeValidated()).isFalse(); // advance to go after - timeProvider.advanceTimeBySeconds(Constants.ETH1_INVALID_ENDPOINT_CHECK_INTERVAL.getSeconds()); + timeProvider.advanceTimeBySeconds(Constants.ETH1_INVALID_ENDPOINT_CHECK_INTERVAL.toSeconds()); // after the interval needs to be validated assertThat(provider.needsToBeValidated()).isTrue(); @@ -186,8 +186,7 @@ void needsToBeValidatedChecks() { // just validated, no need to validate assertThat(provider.needsToBeValidated()).isFalse(); - timeProvider.advanceTimeBySeconds( - Constants.ETH1_VALID_ENDPOINT_CHECK_INTERVAL.getSeconds() + 1); + timeProvider.advanceTimeBySeconds(Constants.ETH1_VALID_ENDPOINT_CHECK_INTERVAL.toSeconds() + 1); // after the interval needs to be validated assertThat(provider.needsToBeValidated()).isTrue(); @@ -198,13 +197,13 @@ void needsToBeValidatedChecks() { // advance less then required timeProvider.advanceTimeBySeconds( - Constants.ETH1_FAILED_ENDPOINT_CHECK_INTERVAL.getSeconds() - 10); + Constants.ETH1_FAILED_ENDPOINT_CHECK_INTERVAL.toSeconds() - 10); // just failed a call, no need to validate assertThat(provider.needsToBeValidated()).isFalse(); // advance to go after - timeProvider.advanceTimeBySeconds(Constants.ETH1_FAILED_ENDPOINT_CHECK_INTERVAL.getSeconds()); + timeProvider.advanceTimeBySeconds(Constants.ETH1_FAILED_ENDPOINT_CHECK_INTERVAL.toSeconds()); // after the interval needs to be validated assertThat(provider.needsToBeValidated()).isTrue(); @@ -223,7 +222,7 @@ void shouldThrowRejectedRequestExceptionWhenInfuraRejectsRequestWithTooManyLogs( .isCompletedExceptionallyWith(RejectedRequestException.class); } - private void prepareRequestWithSyncingResponse(Request request, boolean isSyncing) { + private void prepareRequestWithSyncingResponse(final Request request, final boolean isSyncing) { EthSyncing response = new EthSyncing(); EthSyncing.Result result = new EthSyncing.Result(); result.setSyncing(isSyncing); @@ -231,17 +230,17 @@ private void prepareRequestWithSyncingResponse(Request request, boolean isSyncin when(request.sendAsync()).thenReturn(SafeFuture.completedFuture(response)); } - private void prepareRequestWithChainidResponse(Request request, String chainId) { + private void prepareRequestWithChainidResponse(final Request request, final String chainId) { EthChainId response = new EthChainId(); response.setResult(chainId); when(request.sendAsync()).thenReturn(SafeFuture.completedFuture(response)); } - private void prepareFailingRequestByException(Request request) { + private void prepareFailingRequestByException(final Request request) { when(request.sendAsync()).thenReturn(SafeFuture.failedFuture(new RuntimeException("error"))); } - private void prepareFailingRequestWithChainidJRPCError(Request request) { + private void prepareFailingRequestWithChainidJRPCError(final Request request) { EthChainId response = new EthChainId(); response.setError(new Response.Error(-100, "error message")); when(request.sendAsync()).thenReturn(SafeFuture.completedFuture(response)); diff --git a/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/api/Eth1DataCachePeriodCalculatorTest.java b/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/api/Eth1DataCachePeriodCalculatorTest.java index 3fda54f1c23..fec0393b382 100644 --- a/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/api/Eth1DataCachePeriodCalculatorTest.java +++ b/beacon/pow/src/test/java/tech/pegasys/teku/beacon/pow/api/Eth1DataCachePeriodCalculatorTest.java @@ -21,7 +21,7 @@ import tech.pegasys.teku.spec.config.SpecConfigLoader; class Eth1DataCachePeriodCalculatorTest { - private final SpecConfig config = SpecConfigLoader.loadConfig("minimal"); + private final SpecConfig config = SpecConfigLoader.loadConfig("minimal").specConfig(); @Test void shouldCalculateCachePeriodForMinimalConstantsFromFollowDistance() { diff --git a/beacon/sync/build.gradle b/beacon/sync/build.gradle index 35a17772b5b..63feb29193d 100644 --- a/beacon/sync/build.gradle +++ b/beacon/sync/build.gradle @@ -16,7 +16,7 @@ dependencies { implementation project(':storage:api') implementation project(':infrastructure:events') - implementation 'org.apache.tuweni:tuweni-bytes' + implementation 'io.tmio:tuweni-bytes' testImplementation testFixtures(project(':ethereum:spec')) testImplementation testFixtures(project(':ethereum:statetransition')) diff --git a/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/DefaultSyncServiceFactory.java b/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/DefaultSyncServiceFactory.java index 883355b4e9d..98a0154b26c 100644 --- a/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/DefaultSyncServiceFactory.java +++ b/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/DefaultSyncServiceFactory.java @@ -85,7 +85,7 @@ public DefaultSyncServiceFactory( final RecentChainData recentChainData, final CombinedChainDataClient combinedChainDataClient, final StorageUpdateChannel storageUpdateChannel, - SyncPreImportBlockChannel syncPreImportBlockChannel, + final SyncPreImportBlockChannel syncPreImportBlockChannel, final Eth2P2PNetwork p2pNetwork, final BlockImporter blockImporter, final BlobSidecarManager blobSidecarManager, diff --git a/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/NoopSyncService.java b/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/NoopSyncService.java index 86b12a26d09..4e342290802 100644 --- a/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/NoopSyncService.java +++ b/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/NoopSyncService.java @@ -76,7 +76,7 @@ public long subscribeToSyncChanges(final SyncSubscriber subscriber) { } @Override - public long subscribeToSyncStateChangesAndUpdate(SyncStateSubscriber subscriber) { + public long subscribeToSyncStateChangesAndUpdate(final SyncStateSubscriber subscriber) { final long subscriptionId = subscribeToSyncStateChanges(subscriber); subscriber.onSyncStateChange(getCurrentSyncState()); return subscriptionId; @@ -116,7 +116,7 @@ public void cancelRecentBlobSidecarRequest(final BlobIdentifier blobIdentifier) } @Override - public void onOptimisticHeadChanged(boolean isSyncingOptimistically) { + public void onOptimisticHeadChanged(final boolean isSyncingOptimistically) { // No-op } diff --git a/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/events/SyncStateTracker.java b/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/events/SyncStateTracker.java index cf565392416..432c4e78747 100644 --- a/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/events/SyncStateTracker.java +++ b/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/events/SyncStateTracker.java @@ -124,7 +124,7 @@ public long subscribeToSyncStateChangesAndUpdate(final SyncStateSubscriber subsc } @Override - public boolean unsubscribeFromSyncStateChanges(long subscriberId) { + public boolean unsubscribeFromSyncStateChanges(final long subscriberId) { return subscribers.unsubscribe(subscriberId); } diff --git a/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/fetch/FetchResult.java b/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/fetch/FetchResult.java index e5b99026a08..9446fcc0352 100644 --- a/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/fetch/FetchResult.java +++ b/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/fetch/FetchResult.java @@ -40,7 +40,7 @@ public static FetchResult createSuccessful(final T result) { return new FetchResult<>(Optional.empty(), Status.SUCCESSFUL, Optional.of(result)); } - public static FetchResult createSuccessful(final Eth2Peer peer, T result) { + public static FetchResult createSuccessful(final Eth2Peer peer, final T result) { return new FetchResult<>(Optional.of(peer), Status.SUCCESSFUL, Optional.of(result)); } diff --git a/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/fetch/FetchTaskFactory.java b/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/fetch/FetchTaskFactory.java index 59ed080c7a1..f9fd8832b6d 100644 --- a/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/fetch/FetchTaskFactory.java +++ b/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/fetch/FetchTaskFactory.java @@ -20,13 +20,13 @@ public interface FetchTaskFactory { - default FetchBlockTask createFetchBlockTask(Bytes32 blockRoot) { + default FetchBlockTask createFetchBlockTask(final Bytes32 blockRoot) { return createFetchBlockTask(blockRoot, Optional.empty()); } FetchBlockTask createFetchBlockTask(Bytes32 blockRoot, Optional preferredPeer); - default FetchBlobSidecarTask createFetchBlobSidecarTask(BlobIdentifier blobIdentifier) { + default FetchBlobSidecarTask createFetchBlobSidecarTask(final BlobIdentifier blobIdentifier) { return createFetchBlobSidecarTask(blobIdentifier, Optional.empty()); } diff --git a/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/forward/multipeer/batches/SyncSourceBatch.java b/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/forward/multipeer/batches/SyncSourceBatch.java index 0a13576d000..76f35a79e2f 100644 --- a/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/forward/multipeer/batches/SyncSourceBatch.java +++ b/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/forward/multipeer/batches/SyncSourceBatch.java @@ -103,12 +103,12 @@ public UInt64 getCount() { @Override public Optional getFirstBlock() { - return blocks.isEmpty() ? Optional.empty() : Optional.of(blocks.get(0)); + return blocks.isEmpty() ? Optional.empty() : Optional.of(blocks.getFirst()); } @Override public Optional getLastBlock() { - return blocks.isEmpty() ? Optional.empty() : Optional.of(blocks.get(blocks.size() - 1)); + return blocks.isEmpty() ? Optional.empty() : Optional.of(blocks.getLast()); } @Override @@ -328,8 +328,7 @@ private void onRequestComplete( blobSidecarsByBlockRoot.putAll(newBlobSidecarsByBlockRoot); } - if (newBlocks.isEmpty() - || newBlocks.get(newBlocks.size() - 1).getSlot().equals(getLastSlot())) { + if (newBlocks.isEmpty() || newBlocks.getLast().getSlot().equals(getLastSlot())) { complete = true; } } @@ -362,8 +361,8 @@ private boolean validateNewBlocks(final List newBlocks) { if (blocks.isEmpty() || newBlocks.isEmpty()) { return true; } - final SignedBeaconBlock previousBlock = blocks.get(blocks.size() - 1); - final SignedBeaconBlock firstNewBlock = newBlocks.get(0); + final SignedBeaconBlock previousBlock = blocks.getLast(); + final SignedBeaconBlock firstNewBlock = newBlocks.getFirst(); if (!firstNewBlock.getParentRoot().equals(previousBlock.getRoot())) { LOG.debug( "Marking batch invalid because new blocks do not form a chain with previous blocks"); diff --git a/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/forward/multipeer/chains/SyncSourceFactory.java b/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/forward/multipeer/chains/SyncSourceFactory.java index a47d15d5c39..e4a1a823a1b 100644 --- a/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/forward/multipeer/chains/SyncSourceFactory.java +++ b/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/forward/multipeer/chains/SyncSourceFactory.java @@ -45,7 +45,8 @@ public SyncSource getOrCreateSyncSource(final Eth2Peer peer, final Spec spec) { // Limit request rate to just a little under what we'd accept final int maxBlocksPerMinute = this.maxBlocksPerMinute - batchSize - 1; final Optional maxBlobSidecarsPerMinute = - spec.getMaxBlobsPerBlock().map(maxBlobsPerBlock -> maxBlocksPerMinute * maxBlobsPerBlock); + spec.getMaxBlobsPerBlockForHighestMilestone() + .map(maxBlobsPerBlock -> maxBlocksPerMinute * maxBlobsPerBlock); final Optional maxDataColumnSidecarsPerMinute = spec.getNumberOfDataColumns() .map(dataColumnsPerBlock -> maxBlocksPerMinute * dataColumnsPerBlock.intValue()); diff --git a/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/forward/singlepeer/SyncManager.java b/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/forward/singlepeer/SyncManager.java index 6acfdfc96f4..984b35a9b65 100644 --- a/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/forward/singlepeer/SyncManager.java +++ b/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/forward/singlepeer/SyncManager.java @@ -259,14 +259,14 @@ Optional findBestSyncPeer() { .thenComparing(p -> Math.random())); } - private void onNewPeer(Eth2Peer peer) { + private void onNewPeer(final Eth2Peer peer) { if (isPeerSyncSuitable(peer)) { LOG.trace("New peer connected ({}), schedule sync.", peer.getId()); startOrScheduleSync(); } } - private boolean isPeerSyncSuitable(Eth2Peer peer) { + private boolean isPeerSyncSuitable(final Eth2Peer peer) { UInt64 ourFinalizedEpoch = recentChainData.getFinalizedEpoch(); LOG.trace( "Looking for suitable peer (out of {}) with finalized epoch > {}.", diff --git a/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/gossip/AbstractFetchService.java b/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/gossip/AbstractFetchService.java index b647fb9f3b8..fa407ea6e34 100644 --- a/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/gossip/AbstractFetchService.java +++ b/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/gossip/AbstractFetchService.java @@ -49,7 +49,7 @@ public abstract class AbstractFetchService, private final AsyncRunner asyncRunner; private final int maxConcurrentRequests; - protected AbstractFetchService(final AsyncRunner asyncRunner, int maxConcurrentRequests) { + protected AbstractFetchService(final AsyncRunner asyncRunner, final int maxConcurrentRequests) { this.asyncRunner = asyncRunner; this.maxConcurrentRequests = maxConcurrentRequests; } diff --git a/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/gossip/blobs/RecentBlobSidecarsFetchService.java b/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/gossip/blobs/RecentBlobSidecarsFetchService.java index 4bdfcc9d670..f523bcf94f1 100644 --- a/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/gossip/blobs/RecentBlobSidecarsFetchService.java +++ b/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/gossip/blobs/RecentBlobSidecarsFetchService.java @@ -60,7 +60,8 @@ public static RecentBlobSidecarsFetchService create( final FetchTaskFactory fetchTaskFactory, final Spec spec) { final int maxConcurrentRequests = - RecentBlocksFetchService.MAX_CONCURRENT_REQUESTS * spec.getMaxBlobsPerBlock().orElse(1); + RecentBlocksFetchService.MAX_CONCURRENT_REQUESTS + * spec.getMaxBlobsPerBlockForHighestMilestone().orElse(1); return new RecentBlobSidecarsFetchService( asyncRunner, blockBlobSidecarsTrackersPool, diff --git a/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/historical/ReconstructHistoricalStatesService.java b/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/historical/ReconstructHistoricalStatesService.java index 7b4fef07280..5916be87242 100644 --- a/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/historical/ReconstructHistoricalStatesService.java +++ b/beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/historical/ReconstructHistoricalStatesService.java @@ -147,7 +147,7 @@ protected SafeFuture doStart() { }); } - private SafeFuture applyNextBlock(Context context) { + private SafeFuture applyNextBlock(final Context context) { if (context.checkStopApplyBlock()) { statusLogger.reconstructHistoricalStatesServiceComplete(); stopped.complete(null); @@ -188,7 +188,7 @@ private static class Context { private UInt64 slot; private final UInt64 anchorSlot; - Context(BeaconState currentState, UInt64 slot, UInt64 anchorSlot) { + Context(final BeaconState currentState, final UInt64 slot, final UInt64 anchorSlot) { this.currentState = currentState; this.slot = slot; this.anchorSlot = anchorSlot; diff --git a/beacon/sync/src/test/java/tech/pegasys/teku/beacon/sync/forward/multipeer/batches/SyncSourceBatchTest.java b/beacon/sync/src/test/java/tech/pegasys/teku/beacon/sync/forward/multipeer/batches/SyncSourceBatchTest.java index d03a0d9c8b8..e39607046e2 100644 --- a/beacon/sync/src/test/java/tech/pegasys/teku/beacon/sync/forward/multipeer/batches/SyncSourceBatchTest.java +++ b/beacon/sync/src/test/java/tech/pegasys/teku/beacon/sync/forward/multipeer/batches/SyncSourceBatchTest.java @@ -378,7 +378,7 @@ protected void requestError(final Batch batch, final Throwable error) { /** Get the most recent sync source for a batch. */ private StubSyncSource getSyncSource(final Batch batch) { final List syncSources = this.syncSources.get(batch); - return syncSources.get(syncSources.size() - 1); + return syncSources.getLast(); } @Test diff --git a/beacon/sync/src/test/java/tech/pegasys/teku/beacon/sync/forward/singlepeer/PeerSyncTest.java b/beacon/sync/src/test/java/tech/pegasys/teku/beacon/sync/forward/singlepeer/PeerSyncTest.java index 9d430d8686c..8a7b4144545 100644 --- a/beacon/sync/src/test/java/tech/pegasys/teku/beacon/sync/forward/singlepeer/PeerSyncTest.java +++ b/beacon/sync/src/test/java/tech/pegasys/teku/beacon/sync/forward/singlepeer/PeerSyncTest.java @@ -554,20 +554,22 @@ void sync_blocksAndBlobSidecarsForDeneb() { @Test void sync_blobSidecarsWhenEndSlotInEpoch7594() { - final UInt64 eip7594ForkEpoch = UInt64.valueOf(101); + final UInt64 eip7594Epoch = UInt64.valueOf(101); final Spec spec = - TestSpecFactory.createMinimalEip7594( + TestSpecFactory.createMinimalElectraEip7594( builder -> builder .denebBuilder(denebBuilder -> denebBuilder.denebForkEpoch(denebForkEpoch)) + .electraBuilder( + electraBuilder -> electraBuilder.electraForkEpoch(denebForkEpoch)) .eip7594Builder( - eip7594Builder -> eip7594Builder.eip7594ForkEpoch(eip7594ForkEpoch))); + eip7594Builder -> eip7594Builder.eip7594ForkEpoch(eip7594Epoch))); when(recentChainData.getFinalizedEpoch()).thenReturn(denebForkEpoch); when(blobSidecarManager.isAvailabilityRequiredAtSlot(any())) .thenAnswer( args -> { final UInt64 slot = args.getArgument(0); - if (spec.atSlot(slot).getMilestone().equals(SpecMilestone.DENEB)) { + if (spec.atSlot(slot).getMilestone().isGreaterThanOrEqualTo(SpecMilestone.DENEB)) { return true; } return false; @@ -593,7 +595,7 @@ void sync_blobSidecarsWhenEndSlotInEpoch7594() { final UInt64 slotsPerEpochMinimal = UInt64.valueOf(8); final UInt64 denebLastSlot = denebFirstSlot.plus(slotsPerEpochMinimal); - assertThat(spec.atSlot(denebLastSlot).getMilestone().equals(SpecMilestone.EIP7594)).isTrue(); + assertThat(spec.atSlot(denebLastSlot).getMilestone().equals(SpecMilestone.ELECTRA)).isTrue(); assertThat(denebPeerSlotsAhead.isGreaterThan(slotsPerEpochMinimal)).isTrue(); verify(peer).requestBlobSidecarsByRange(eq(denebSecondSlot), eq(denebPeerSlotsAhead), any()); diff --git a/beacon/sync/src/test/java/tech/pegasys/teku/beacon/sync/forward/singlepeer/RetryDelayFunctionTest.java b/beacon/sync/src/test/java/tech/pegasys/teku/beacon/sync/forward/singlepeer/RetryDelayFunctionTest.java index 6760e19cec7..1f5f2c6a583 100644 --- a/beacon/sync/src/test/java/tech/pegasys/teku/beacon/sync/forward/singlepeer/RetryDelayFunctionTest.java +++ b/beacon/sync/src/test/java/tech/pegasys/teku/beacon/sync/forward/singlepeer/RetryDelayFunctionTest.java @@ -42,7 +42,7 @@ public void createExponentialRetry() { } private void assertRetryDelay( - RetryDelayFunction retryFn, final int retries, final Duration expectedResult) { + final RetryDelayFunction retryFn, final int retries, final Duration expectedResult) { assertThat(retryFn.getRetryDelay(retries).toMillis()).isEqualTo(expectedResult.toMillis()); } } diff --git a/beacon/sync/src/testFixtures/java/tech/pegasys/teku/beacon/sync/SyncingNodeManager.java b/beacon/sync/src/testFixtures/java/tech/pegasys/teku/beacon/sync/SyncingNodeManager.java index 8ebe443b6ae..b94030b4214 100644 --- a/beacon/sync/src/testFixtures/java/tech/pegasys/teku/beacon/sync/SyncingNodeManager.java +++ b/beacon/sync/src/testFixtures/java/tech/pegasys/teku/beacon/sync/SyncingNodeManager.java @@ -51,7 +51,6 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; -import tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel; import tech.pegasys.teku.spec.executionlayer.ExecutionLayerChannel; import tech.pegasys.teku.spec.executionlayer.ExecutionLayerChannelStub; import tech.pegasys.teku.spec.logic.common.statetransition.results.BlockImportResult; @@ -85,6 +84,7 @@ public class SyncingNodeManager { private final BlockGossipChannel blockGossipChannel; private SyncingNodeManager( + final AsyncRunner asyncRunner, final EventChannels eventChannels, final RecentChainData recentChainData, final BeaconChainUtil chainUtil, @@ -95,7 +95,7 @@ private SyncingNodeManager( this.chainUtil = chainUtil; this.eth2P2PNetwork = eth2P2PNetwork; this.syncService = syncService; - this.blockGossipChannel = eventChannels.getPublisher(BlockGossipChannel.class); + this.blockGossipChannel = eventChannels.getPublisher(BlockGossipChannel.class, asyncRunner); } @SuppressWarnings("FutureReturnValueIgnored") @@ -146,6 +146,7 @@ public static SyncingNodeManager create( final BlockImporter blockImporter = new BlockImporter( + asyncRunner, spec, receivedBlockEventsChannelPublisher, recentChainData, @@ -208,8 +209,7 @@ public static SyncingNodeManager create( BlockBlobSidecarsTrackersPool.NOOP, syncService, fetchBlockTaskFactory); - recentBlocksFetcher.subscribeBlockFetched( - block -> blockManager.importBlock(block, BroadcastValidationLevel.NOT_REQUIRED)); + recentBlocksFetcher.subscribeBlockFetched(blockManager::importBlock); eventChannels.subscribe(ReceivedBlockEventsChannel.class, recentBlocksFetcher); recentBlocksFetcher.start().join(); @@ -217,12 +217,12 @@ public static SyncingNodeManager create( syncService.start().join(); return new SyncingNodeManager( - eventChannels, recentChainData, chainUtil, eth2P2PNetwork, syncService); + asyncRunner, eventChannels, recentChainData, chainUtil, eth2P2PNetwork, syncService); } public SafeFuture connect(final SyncingNodeManager peer) { final PeerAddress peerAddress = - eth2P2PNetwork.createPeerAddress(peer.network().getNodeAddress()); + eth2P2PNetwork.createPeerAddress(peer.network().getNodeAddresses().get(0)); return eth2P2PNetwork.connect(peerAddress); } @@ -252,6 +252,6 @@ public void setSlot(final UInt64 slot) { } public void gossipBlock(final SignedBeaconBlock block) { - blockGossipChannel.publishBlock(block); + blockGossipChannel.publishBlock(block).ifExceptionGetsHereRaiseABug(); } } diff --git a/beacon/validator/build.gradle b/beacon/validator/build.gradle index d069f585e01..e100f1d6407 100644 --- a/beacon/validator/build.gradle +++ b/beacon/validator/build.gradle @@ -33,8 +33,8 @@ dependencies { implementation project(':ethereum:json-types') implementation 'it.unimi.dsi:fastutil' - implementation 'org.apache.tuweni:tuweni-bytes' - implementation 'org.apache.tuweni:tuweni-ssz' + implementation 'io.tmio:tuweni-bytes' + implementation 'io.tmio:tuweni-ssz' testImplementation project(':infrastructure:metrics') testImplementation testFixtures(project(':ethereum:spec')) diff --git a/beacon/validator/src/integrationTest/java/tech/pegasys/teku/validator/coordinator/ValidatorApiHandlerIntegrationTest.java b/beacon/validator/src/integrationTest/java/tech/pegasys/teku/validator/coordinator/ValidatorApiHandlerIntegrationTest.java index 82ce6764121..59e69f36e37 100644 --- a/beacon/validator/src/integrationTest/java/tech/pegasys/teku/validator/coordinator/ValidatorApiHandlerIntegrationTest.java +++ b/beacon/validator/src/integrationTest/java/tech/pegasys/teku/validator/coordinator/ValidatorApiHandlerIntegrationTest.java @@ -15,40 +15,59 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.doAnswer; import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.async.SafeFutureAssert.assertThatSafeFuture; import static tech.pegasys.teku.infrastructure.async.SafeFutureAssert.safeJoin; import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ONE; +import static tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel.NOT_REQUIRED; +import java.util.List; import java.util.Optional; +import java.util.stream.IntStream; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestTemplate; import tech.pegasys.teku.api.ChainDataProvider; +import tech.pegasys.teku.api.NetworkDataProvider; import tech.pegasys.teku.api.NodeDataProvider; import tech.pegasys.teku.beacon.sync.events.SyncState; import tech.pegasys.teku.beacon.sync.events.SyncStateProvider; import tech.pegasys.teku.beacon.sync.events.SyncStateTracker; import tech.pegasys.teku.ethereum.performance.trackers.BlockProductionAndPublishingPerformanceFactory; +import tech.pegasys.teku.infrastructure.async.AsyncRunner; +import tech.pegasys.teku.infrastructure.async.DelayedExecutorAsyncRunner; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.metrics.StubMetricsSystem; import tech.pegasys.teku.infrastructure.metrics.Validator.ValidatorDutyMetricUtils; +import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.time.SystemTimeProvider; import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.networking.eth2.P2PConfig; import tech.pegasys.teku.networking.eth2.gossip.BlobSidecarGossipChannel; import tech.pegasys.teku.networking.eth2.gossip.BlockGossipChannel; import tech.pegasys.teku.networking.eth2.gossip.DataColumnSidecarGossipChannel; import tech.pegasys.teku.networking.eth2.gossip.subnets.AttestationTopicSubscriber; import tech.pegasys.teku.networking.eth2.gossip.subnets.SyncCommitteeSubscriptionManager; -import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.SpecVersion; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider.SpecContext; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.Blob; +import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockAndState; +import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockContainer; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; import tech.pegasys.teku.spec.datastructures.state.Checkpoint; +import tech.pegasys.teku.spec.datastructures.type.SszKZGProof; +import tech.pegasys.teku.spec.logic.common.statetransition.results.BlockImportResult; +import tech.pegasys.teku.spec.logic.versions.deneb.helpers.MiscHelpersDeneb; import tech.pegasys.teku.statetransition.attestation.AggregatingAttestationPool; import tech.pegasys.teku.statetransition.attestation.AttestationManager; import tech.pegasys.teku.statetransition.blobs.BlockBlobSidecarsTrackersPool; import tech.pegasys.teku.statetransition.block.BlockImportChannel; +import tech.pegasys.teku.statetransition.block.BlockImportChannel.BlockImportAndBroadcastValidationResults; import tech.pegasys.teku.statetransition.forkchoice.ForkChoiceTrigger; import tech.pegasys.teku.statetransition.forkchoice.ProposersDataManager; import tech.pegasys.teku.statetransition.synccommittee.SyncCommitteeContributionPool; @@ -58,16 +77,19 @@ import tech.pegasys.teku.storage.server.StateStorageMode; import tech.pegasys.teku.storage.storageSystem.InMemoryStorageSystemBuilder; import tech.pegasys.teku.storage.storageSystem.StorageSystem; +import tech.pegasys.teku.validator.api.SendSignedBlockResult; import tech.pegasys.teku.validator.coordinator.performance.DefaultPerformanceTracker; +import tech.pegasys.teku.validator.coordinator.publisher.MilestoneBasedBlockPublisher; +@TestSpecContext(milestone = {SpecMilestone.PHASE0, SpecMilestone.DENEB}) public class ValidatorApiHandlerIntegrationTest { + private final AsyncRunner asyncRunner = DelayedExecutorAsyncRunner.create(); // Use full storage system private final StorageSystem storageSystem = InMemoryStorageSystemBuilder.buildDefault(StateStorageMode.ARCHIVE); private final CombinedChainDataClient combinedChainDataClient = storageSystem.combinedChainDataClient(); - private final Spec spec = TestSpecFactory.createMinimalPhase0(); // Other dependencies are mocked, but these can be updated as needed private final SyncStateProvider syncStateProvider = mock(SyncStateTracker.class); @@ -89,6 +111,7 @@ public class ValidatorApiHandlerIntegrationTest { mock(DataColumnSidecarGossipChannel.class); private final ChainDataProvider chainDataProvider = mock(ChainDataProvider.class); private final NodeDataProvider nodeDataProvider = mock(NodeDataProvider.class); + private final NetworkDataProvider networkDataProvider = mock(NetworkDataProvider.class); private final ForkChoiceTrigger forkChoiceTrigger = mock(ForkChoiceTrigger.class); private final ProposersDataManager proposersDataManager = mock(ProposersDataManager.class); @@ -101,45 +124,93 @@ public class ValidatorApiHandlerIntegrationTest { mock(SyncCommitteeSubscriptionManager.class); private final DutyMetrics dutyMetrics = mock(DutyMetrics.class); - private final ValidatorApiHandler handler = - new ValidatorApiHandler( - chainDataProvider, - nodeDataProvider, - combinedChainDataClient, - syncStateProvider, - blockFactory, - blockImportChannel, - blockGossipChannel, - blockBlobSidecarsTrackersPool, - blobSidecarGossipChannel, - dataColumnSidecarGossipChannel, - attestationPool, - attestationManager, - attestationTopicSubscriber, - activeValidatorTracker, - dutyMetrics, - performanceTracker, - spec, - forkChoiceTrigger, - proposersDataManager, - syncCommitteeMessagePool, - syncCommitteeContributionPool, - syncCommitteeSubscriptionManager, - new BlockProductionAndPublishingPerformanceFactory( - new SystemTimeProvider(), __ -> UInt64.ZERO, true, 0, 0)); + + private ValidatorApiHandler handler; @BeforeEach - public void setup() { + public void setup(final SpecContext specContext) { when(syncStateProvider.getCurrentSyncState()).thenReturn(SyncState.IN_SYNC); when(forkChoiceTrigger.prepareForAttestationProduction(any())).thenReturn(SafeFuture.COMPLETE); when(dutyMetrics.getValidatorDutyMetric()) .thenReturn(ValidatorDutyMetricUtils.createValidatorDutyMetric(new StubMetricsSystem())); + + when(blockGossipChannel.publishBlock(any())).thenReturn(SafeFuture.COMPLETE); + when(blobSidecarGossipChannel.publishBlobSidecar(any())).thenReturn(SafeFuture.COMPLETE); + when(blobSidecarGossipChannel.publishBlobSidecars(any())).thenReturn(SafeFuture.COMPLETE); + + doAnswer(invocation -> SafeFuture.completedFuture(invocation.getArgument(0))) + .when(blockFactory) + .unblindSignedBlockIfBlinded(any(), any()); + + // BlobSidecar builder + doAnswer( + invocation -> { + final SignedBlockContainer blockContainer = invocation.getArgument(0); + final SpecVersion asspecVersion = + specContext.getSpec().forMilestone(SpecMilestone.DENEB); + if (asspecVersion == null) { + return List.of(); + } + final MiscHelpersDeneb miscHelpersDeneb = + MiscHelpersDeneb.required(asspecVersion.miscHelpers()); + if (blockContainer.getBlobs().isEmpty()) { + return List.of(); + } + final SszList blobs = blockContainer.getBlobs().orElseThrow(); + final SszList proofs = blockContainer.getKzgProofs().orElseThrow(); + return IntStream.range(0, blobs.size()) + .mapToObj( + index -> + miscHelpersDeneb.constructBlobSidecar( + blockContainer.getSignedBlock(), + UInt64.valueOf(index), + blobs.get(index), + proofs.get(index))) + .toList(); + }) + .when(blockFactory) + .createBlobSidecars(any()); + + handler = + new ValidatorApiHandler( + chainDataProvider, + nodeDataProvider, + networkDataProvider, + combinedChainDataClient, + syncStateProvider, + blockFactory, + attestationPool, + attestationManager, + attestationTopicSubscriber, + activeValidatorTracker, + dutyMetrics, + performanceTracker, + specContext.getSpec(), + forkChoiceTrigger, + proposersDataManager, + syncCommitteeMessagePool, + syncCommitteeContributionPool, + syncCommitteeSubscriptionManager, + new BlockProductionAndPublishingPerformanceFactory( + new SystemTimeProvider(), __ -> UInt64.ZERO, true, 0, 0, 0, 0), + new MilestoneBasedBlockPublisher( + asyncRunner, + specContext.getSpec(), + blockFactory, + blockImportChannel, + blockGossipChannel, + blockBlobSidecarsTrackersPool, + blobSidecarGossipChannel, + dataColumnSidecarGossipChannel, + dutyMetrics, + P2PConfig.DEFAULT_GOSSIP_BLOBS_AFTER_BLOCK_ENABLED)); } - @Test - public void createAttestationData_withRecentBlockAvailable() { + @TestTemplate + public void createAttestationData_withRecentBlockAvailable(final SpecContext specContext) { + specContext.assumeIsNotOneOf(SpecMilestone.DENEB); final UInt64 targetEpoch = UInt64.valueOf(3); - final UInt64 targetEpochStartSlot = spec.computeStartSlotAtEpoch(targetEpoch); + final UInt64 targetEpochStartSlot = specContext.getSpec().computeStartSlotAtEpoch(targetEpoch); final UInt64 targetSlot = targetEpochStartSlot.plus(2); final SignedBlockAndState genesis = chainUpdater.initializeGenesis(); @@ -168,12 +239,14 @@ public void createAttestationData_withRecentBlockAvailable() { assertThat(attestation.getTarget()).isEqualTo(expectedTarget); } - @Test - public void createUnsignedAttestation_withLatestBlockFromAnOldEpoch() { + @TestTemplate + public void createUnsignedAttestation_withLatestBlockFromAnOldEpoch( + final SpecContext specContext) { + specContext.assumeIsNotOneOf(SpecMilestone.DENEB); final UInt64 latestEpoch = UInt64.valueOf(2); - final UInt64 latestSlot = spec.computeStartSlotAtEpoch(latestEpoch).plus(ONE); + final UInt64 latestSlot = specContext.getSpec().computeStartSlotAtEpoch(latestEpoch).plus(ONE); final UInt64 targetEpoch = UInt64.valueOf(latestEpoch.longValue() + 3); - final UInt64 targetEpochStartSlot = spec.computeStartSlotAtEpoch(targetEpoch); + final UInt64 targetEpochStartSlot = specContext.getSpec().computeStartSlotAtEpoch(targetEpoch); final UInt64 targetSlot = targetEpochStartSlot.plus(2); final SignedBlockAndState genesis = chainUpdater.initializeGenesis(); @@ -197,4 +270,27 @@ public void createUnsignedAttestation_withLatestBlockFromAnOldEpoch() { assertThat(attestation.getSource()).isEqualTo(genesisCheckpoint); assertThat(attestation.getTarget()).isEqualTo(expectedTarget); } + + @TestTemplate + void sendSignedBlock_shouldImportAndPublishBlock(final SpecContext specContext) { + final SignedBeaconBlock block = specContext.getDataStructureUtil().randomSignedBeaconBlock(5); + + when(blockImportChannel.importBlock(block, NOT_REQUIRED)) + .thenReturn(prepareBlockImportResult(BlockImportResult.successful(block))); + final SafeFuture result = handler.sendSignedBlock(block, NOT_REQUIRED); + assertThat(result).isCompletedWithValue(SendSignedBlockResult.success(block.getRoot())); + + if (specContext.getSpecMilestone() == SpecMilestone.DENEB) { + verify(blobSidecarGossipChannel).publishBlobSidecars(any()); + } + verify(blockGossipChannel).publishBlock(block); + verify(blockImportChannel).importBlock(block, NOT_REQUIRED); + } + + private SafeFuture prepareBlockImportResult( + final BlockImportResult blockImportResult) { + return SafeFuture.completedFuture( + new BlockImportAndBroadcastValidationResults( + SafeFuture.completedFuture(blockImportResult))); + } } diff --git a/beacon/validator/src/jmh/java/tech/pegasys/teku/validator/coordinator/DepositProviderBenchmark.java b/beacon/validator/src/jmh/java/tech/pegasys/teku/validator/coordinator/DepositProviderBenchmark.java index ae392ea42e9..b3f3c4c83e7 100644 --- a/beacon/validator/src/jmh/java/tech/pegasys/teku/validator/coordinator/DepositProviderBenchmark.java +++ b/beacon/validator/src/jmh/java/tech/pegasys/teku/validator/coordinator/DepositProviderBenchmark.java @@ -68,7 +68,7 @@ public class DepositProviderBenchmark { new DepositProvider( metricsSystem, mock(RecentChainData.class), - new Eth1DataCache(metricsSystem, new Eth1VotingPeriod(spec)), + new Eth1DataCache(spec, metricsSystem, new Eth1VotingPeriod(spec)), mock(StorageUpdateChannel.class), mock(Eth1DepositStorageChannel.class), spec, diff --git a/beacon/validator/src/jmh/java/tech/pegasys/teku/validator/coordinator/duties/AttesterDutiesGeneraterBenchmark.java b/beacon/validator/src/jmh/java/tech/pegasys/teku/validator/coordinator/duties/AttesterDutiesGeneraterBenchmark.java index 8487003f74e..6107a355341 100644 --- a/beacon/validator/src/jmh/java/tech/pegasys/teku/validator/coordinator/duties/AttesterDutiesGeneraterBenchmark.java +++ b/beacon/validator/src/jmh/java/tech/pegasys/teku/validator/coordinator/duties/AttesterDutiesGeneraterBenchmark.java @@ -35,6 +35,7 @@ import org.openjdk.jmh.annotations.Warmup; import org.openjdk.jmh.infra.Blackhole; import tech.pegasys.teku.benchmarks.gen.KeyFileGenerator; +import tech.pegasys.teku.bls.BLSConstants; import tech.pegasys.teku.bls.BLSKeyPair; import tech.pegasys.teku.ethereum.json.types.validator.AttesterDuties; import tech.pegasys.teku.ethereum.json.types.validator.AttesterDuty; @@ -79,43 +80,56 @@ public class AttesterDutiesGeneraterBenchmark { IntList validatorIndices = new IntArrayList(); - @Param({"800000"}) - int validatorsCount = 800_000; + @Param({"20000"}) + int validatorsCount = 20_000; - @Param({"500000"}) - int querySize = 50_000; + @Param({"20000"}) + int querySize = 20_000; @Setup(Level.Trial) public void init() { + BLSConstants.disableBLSVerification(); List validatorKeys = KeyFileGenerator.readValidatorKeys(validatorsCount); state = BeaconStateBellatrix.required( new GenesisStateBuilder() .spec(spec) - .signDeposits(false) + .signDeposits(true) .addValidators(validatorKeys) .build()); final MutableBeaconStateBellatrix mutableState = state.createWritableCopy(); mutableState.setSlot(UInt64.ONE); state = mutableState.commitChanges(); + System.out.println("active validators: " + state.getValidators().size()); + for (int i = 0; i < querySize; i++) { validatorIndices.add(i); } attesterDutiesGenerator = new AttesterDutiesGenerator(spec); - System.out.println("Done!"); epoch = spec.computeEpochAtSlot(state.getSlot()).increment(); + + int generatedDuties = computeAttesterDuties().getDuties().size(); + if (generatedDuties == 0) { + throw new IllegalStateException("No duties generated, check the state"); + } + + System.out.println("computed duties: " + computeAttesterDuties().getDuties().size()); + System.out.println("Done!"); } @Benchmark @Warmup(iterations = 5, time = 2000, timeUnit = TimeUnit.MILLISECONDS) @Measurement(iterations = 10) public void computeAttesterDuties(Blackhole bh) { - AttesterDuties attesterDutiesFromIndicesAndState = - attesterDutiesGenerator.getAttesterDutiesFromIndicesAndState( - state, epoch, validatorIndices, false); + final AttesterDuties attesterDutiesFromIndicesAndState = computeAttesterDuties(); bh.consume(attesterDutiesFromIndicesAndState); } + + private AttesterDuties computeAttesterDuties() { + return attesterDutiesGenerator.getAttesterDutiesFromIndicesAndState( + state, epoch, validatorIndices, false); + } } diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/BlockFactory.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/BlockFactory.java index 208ee6c30b1..4014ae76754 100644 --- a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/BlockFactory.java +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/BlockFactory.java @@ -36,15 +36,13 @@ SafeFuture createUnsignedBlock( UInt64 proposalSlot, BLSSignature randaoReveal, Optional optionalGraffiti, - Optional requestedBlinded, Optional requestedBuilderBoostFactor, BlockProductionPerformance blockProductionPerformance); SafeFuture unblindSignedBlockIfBlinded( SignedBeaconBlock maybeBlindedBlock, BlockPublishingPerformance blockPublishingPerformance); - List createBlobSidecars( - SignedBlockContainer blockContainer, BlockPublishingPerformance blockPublishingPerformance); + List createBlobSidecars(SignedBlockContainer blockContainer); List createDataColumnSidecars( SignedBlockContainer blockContainer, List blobs); diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/BlockFactoryDeneb.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/BlockFactoryDeneb.java index ee35b270828..fbe29cbc279 100644 --- a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/BlockFactoryDeneb.java +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/BlockFactoryDeneb.java @@ -18,7 +18,6 @@ import org.apache.tuweni.bytes.Bytes32; import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.ethereum.performance.trackers.BlockProductionPerformance; -import tech.pegasys.teku.ethereum.performance.trackers.BlockPublishingPerformance; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; @@ -44,7 +43,6 @@ public SafeFuture createUnsignedBlock( final UInt64 proposalSlot, final BLSSignature randaoReveal, final Optional optionalGraffiti, - final Optional requestedBlinded, final Optional requestedBuilderBoostFactor, final BlockProductionPerformance blockProductionPerformance) { return super.createUnsignedBlock( @@ -52,7 +50,6 @@ public SafeFuture createUnsignedBlock( proposalSlot, randaoReveal, optionalGraffiti, - requestedBlinded, requestedBuilderBoostFactor, blockProductionPerformance) .thenCompose( @@ -71,12 +68,8 @@ public SafeFuture createUnsignedBlock( } @Override - public List createBlobSidecars( - final SignedBlockContainer blockContainer, - final BlockPublishingPerformance blockPublishingPerformance) { - return operationSelector - .createBlobSidecarsSelector(blockPublishingPerformance) - .apply(blockContainer); + public List createBlobSidecars(final SignedBlockContainer blockContainer) { + return operationSelector.createBlobSidecarsSelector().apply(blockContainer); } private BlockContents createBlockContents( diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/BlockFactoryEip7594.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/BlockFactoryEip7594.java index cd4dc713218..ec21d7a5751 100644 --- a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/BlockFactoryEip7594.java +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/BlockFactoryEip7594.java @@ -19,7 +19,7 @@ import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.Blob; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSidecar; import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockContainer; -import tech.pegasys.teku.spec.logic.versions.eip7594.helpers.MiscHelpersEip7594; +import tech.pegasys.teku.spec.logic.versions.feature.eip7594.helpers.MiscHelpersEip7594; public class BlockFactoryEip7594 extends BlockFactoryDeneb { private final KZG kzg; @@ -32,7 +32,7 @@ public BlockFactoryEip7594( @Override public List createDataColumnSidecars( - final SignedBlockContainer blockContainer, List blobs) { + final SignedBlockContainer blockContainer, final List blobs) { final MiscHelpersEip7594 miscHelpersEip7594 = MiscHelpersEip7594.required(spec.atSlot(blockContainer.getSlot()).miscHelpers()); return miscHelpersEip7594.constructDataColumnSidecars( diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/BlockFactoryPhase0.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/BlockFactoryPhase0.java index df85bdc5580..dd135f4b8ff 100644 --- a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/BlockFactoryPhase0.java +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/BlockFactoryPhase0.java @@ -54,7 +54,6 @@ public SafeFuture createUnsignedBlock( final UInt64 proposalSlot, final BLSSignature randaoReveal, final Optional optionalGraffiti, - final Optional requestedBlinded, final Optional requestedBuilderBoostFactor, final BlockProductionPerformance blockProductionPerformance) { checkArgument( @@ -78,7 +77,6 @@ public SafeFuture createUnsignedBlock( blockSlotState, randaoReveal, optionalGraffiti, - requestedBlinded, requestedBuilderBoostFactor, blockProductionPerformance), blockProductionPerformance) @@ -108,15 +106,13 @@ public SafeFuture unblindSignedBlockIfBlinded( } @Override - public List createBlobSidecars( - final SignedBlockContainer blockContainer, - final BlockPublishingPerformance blockPublishingPerformance) { + public List createBlobSidecars(final SignedBlockContainer blockContainer) { return Collections.emptyList(); } @Override public List createDataColumnSidecars( - final SignedBlockContainer blockContainer, List blobs) { + final SignedBlockContainer blockContainer, final List blobs) { return Collections.emptyList(); } } diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/BlockOperationSelectorFactory.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/BlockOperationSelectorFactory.java index 5e7e8bce826..7eff3b34f13 100644 --- a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/BlockOperationSelectorFactory.java +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/BlockOperationSelectorFactory.java @@ -39,11 +39,17 @@ import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockUnblinder; import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockContainer; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodyBuilder; +import tech.pegasys.teku.spec.datastructures.blocks.versions.deneb.BlockContentsSchema; +import tech.pegasys.teku.spec.datastructures.builder.BuilderBid; import tech.pegasys.teku.spec.datastructures.builder.BuilderPayload; import tech.pegasys.teku.spec.datastructures.execution.BlobsBundle; +import tech.pegasys.teku.spec.datastructures.execution.BuilderBidOrFallbackData; +import tech.pegasys.teku.spec.datastructures.execution.BuilderPayloadOrFallbackData; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadContext; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadResult; -import tech.pegasys.teku.spec.datastructures.execution.HeaderWithFallbackData; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; import tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing; @@ -110,7 +116,6 @@ public Function> createSelector( final BeaconState blockSlotState, final BLSSignature randaoReveal, final Optional optionalGraffiti, - final Optional requestedBlinded, final Optional requestedBuilderBoostFactor, final BlockProductionPerformance blockProductionPerformance) { @@ -156,25 +161,28 @@ public Function> createSelector( // Optional fields introduced in later forks - // Sync aggregate + // Post-Altair: Sync aggregate if (bodyBuilder.supportsSyncAggregate()) { bodyBuilder.syncAggregate( contributionPool.createSyncAggregateForBlock(blockSlotState.getSlot(), parentRoot)); } - // BLS to Execution changes + // Post-Capella: BLS to Execution changes if (bodyBuilder.supportsBlsToExecutionChanges()) { bodyBuilder.blsToExecutionChanges( blsToExecutionChangePool.getItemsForBlock(blockSlotState)); } - // Execution Payload / Execution Payload Header / KZG Commitments - final SafeFuture completionFuture; - if (bodyBuilder.supportsExecutionPayload()) { - final SchemaDefinitions schemaDefinitions = - spec.atSlot(blockSlotState.getSlot()).getSchemaDefinitions(); + final SchemaDefinitions schemaDefinitions = + spec.atSlot(blockSlotState.getSlot()).getSchemaDefinitions(); + + final SafeFuture blockProductionComplete; - completionFuture = + // In `setExecutionData` the following fields are set: + // Post-Bellatrix: Execution Payload / Execution Payload Header + // Post-Deneb: KZG Commitments + if (bodyBuilder.supportsExecutionPayload()) { + blockProductionComplete = forkChoiceNotifier .getPayloadId(parentRoot, blockSlotState.getSlot()) .thenCompose( @@ -182,27 +190,25 @@ public Function> createSelector( setExecutionData( executionPayloadContext, bodyBuilder, - requestedBlinded, requestedBuilderBoostFactor, - schemaDefinitions, + SchemaDefinitionsBellatrix.required(schemaDefinitions), blockSlotState, blockProductionPerformance)); } else { - completionFuture = SafeFuture.COMPLETE; + blockProductionComplete = SafeFuture.COMPLETE; } blockProductionPerformance.beaconBlockPrepared(); - return completionFuture; + return blockProductionComplete; }; } private SafeFuture setExecutionData( final Optional executionPayloadContext, final BeaconBlockBodyBuilder bodyBuilder, - final Optional requestedBlinded, final Optional requestedBuilderBoostFactor, - final SchemaDefinitions schemaDefinitions, + final SchemaDefinitionsBellatrix schemaDefinitions, final BeaconState blockSlotState, final BlockProductionPerformance blockProductionPerformance) { @@ -213,46 +219,20 @@ private SafeFuture setExecutionData( blockSlotState.getSlot())); } - // if requestedBlinded has been specified, we strictly follow it otherwise, we should run - // Builder - // flow (blinded) only if we have a validator registration - final boolean shouldTryBuilderFlow = - requestedBlinded.orElseGet( - () -> - executionPayloadContext - .map(ExecutionPayloadContext::isValidatorRegistrationPresent) - .orElse(false)); - - // we should try to return unblinded content only if no explicit "blindness" has been requested - // and builder flow fallbacks to local - final Function setUnblindedContentIfBuilderFallbacks = - headerWithFallbackData -> - headerWithFallbackData.getFallbackData().isPresent() && requestedBlinded.isEmpty(); - - // Pre-Deneb: Execution Payload / Execution Payload Header - if (!bodyBuilder.supportsKzgCommitments()) { - if (shouldTryBuilderFlow) { - return builderSetPayloadHeader( - setUnblindedContentIfBuilderFallbacks, - bodyBuilder, - schemaDefinitions, - blockSlotState, - executionPayloadContext, - requestedBuilderBoostFactor, - blockProductionPerformance); - } else { - return builderSetPayload( - bodyBuilder, - schemaDefinitions, - blockSlotState, - executionPayloadContext, - blockProductionPerformance); - } + // pre-Merge Execution Payload / Execution Payload Header + if (executionPayloadContext.isEmpty()) { + bodyBuilder.executionPayload(schemaDefinitions.getExecutionPayloadSchema().getDefault()); + return SafeFuture.COMPLETE; } - // Post-Deneb: Execution Payload / Execution Payload Header + KZG Commitments + // We should run Builder flow (blinded) only if we have a validator registration + final boolean shouldTryBuilderFlow = + executionPayloadContext + .map(ExecutionPayloadContext::isValidatorRegistrationPresent) + .orElse(false); + final ExecutionPayloadResult executionPayloadResult = - executionLayerBlockProductionManager.initiateBlockAndBlobsProduction( + executionLayerBlockProductionManager.initiateBlockProduction( executionPayloadContext.orElseThrow(), blockSlotState, shouldTryBuilderFlow, @@ -261,153 +241,141 @@ private SafeFuture setExecutionData( return SafeFuture.allOf( cacheExecutionPayloadValue(executionPayloadResult, blockSlotState), - builderSetPayloadPostMerge( - bodyBuilder, setUnblindedContentIfBuilderFallbacks, executionPayloadResult), - builderSetKzgCommitments( - bodyBuilder, - setUnblindedContentIfBuilderFallbacks, - schemaDefinitions, - executionPayloadResult)); + setPayloadOrPayloadHeader(bodyBuilder, executionPayloadResult), + setKzgCommitments(bodyBuilder, schemaDefinitions, executionPayloadResult), + setExecutionRequests(bodyBuilder, executionPayloadResult)); } private SafeFuture cacheExecutionPayloadValue( final ExecutionPayloadResult executionPayloadResult, final BeaconState blockSlotState) { return executionPayloadResult .getExecutionPayloadValueFuture() - .map( - futureValue -> - futureValue.thenAccept( - value -> - BeaconStateCache.getSlotCaches(blockSlotState) - .setBlockExecutionValue(value))) - .orElse(SafeFuture.COMPLETE); + .thenAccept( + blockExecutionValue -> + BeaconStateCache.getSlotCaches(blockSlotState) + .setBlockExecutionValue(blockExecutionValue)); } - private SafeFuture builderSetPayloadPostMerge( + private SafeFuture setPayloadOrPayloadHeader( final BeaconBlockBodyBuilder bodyBuilder, - final Function setUnblindedContentIfBuilderFallbacks, final ExecutionPayloadResult executionPayloadResult) { - final boolean isLocalFlow = executionPayloadResult.getExecutionPayloadFuture().isPresent(); - - if (isLocalFlow) { + if (executionPayloadResult.isFromLocalFlow()) { + // local, non-blinded flow return executionPayloadResult - .getExecutionPayloadFuture() - .get() + .getExecutionPayloadFutureFromLocalFlow() + .orElseThrow() .thenAccept(bodyBuilder::executionPayload); } - - // builder flow + // builder, blinded flow return executionPayloadResult - .getHeaderWithFallbackDataFuture() + .getBuilderBidOrFallbackDataFuture() .orElseThrow() .thenAccept( - headerWithFallbackData -> { - if (setUnblindedContentIfBuilderFallbacks.apply(headerWithFallbackData)) { + builderBidOrFallbackData -> { + // we should try to return unblinded content only if no explicit "blindness" has been + // requested and builder flow fallbacks to local + if (builderBidOrFallbackData.getFallbackData().isPresent()) { bodyBuilder.executionPayload( - headerWithFallbackData.getFallbackData().orElseThrow().getExecutionPayload()); + builderBidOrFallbackData.getFallbackDataRequired().getExecutionPayload()); } else { - bodyBuilder.executionPayloadHeader( - headerWithFallbackData.getExecutionPayloadHeader()); + final ExecutionPayloadHeader executionPayloadHeader = + builderBidOrFallbackData + .getBuilderBid() + // from the builder bid + .map(BuilderBid::getHeader) + // from the local fallback + .orElseThrow(); + bodyBuilder.executionPayloadHeader(executionPayloadHeader); } }); } - private SafeFuture builderSetPayload( + private SafeFuture setKzgCommitments( final BeaconBlockBodyBuilder bodyBuilder, final SchemaDefinitions schemaDefinitions, - final BeaconState blockSlotState, - final Optional executionPayloadContext, - final BlockProductionPerformance blockProductionPerformance) { - if (executionPayloadContext.isEmpty()) { - // preMergePayload - bodyBuilder.executionPayload( - SchemaDefinitionsBellatrix.required(schemaDefinitions) - .getExecutionPayloadSchema() - .getDefault()); + final ExecutionPayloadResult executionPayloadResult) { + if (!bodyBuilder.supportsKzgCommitments()) { return SafeFuture.COMPLETE; } + final BlobKzgCommitmentsSchema blobKzgCommitmentsSchema = + SchemaDefinitionsDeneb.required(schemaDefinitions).getBlobKzgCommitmentsSchema(); + final SafeFuture> blobKzgCommitments; + if (executionPayloadResult.isFromLocalFlow()) { + // local, non-blinded flow + blobKzgCommitments = + executionPayloadResult + .getBlobsBundleFutureFromLocalFlow() + .orElseThrow() + .thenApply(Optional::orElseThrow) + .thenApply(blobKzgCommitmentsSchema::createFromBlobsBundle); + } else { + // builder, blinded flow + blobKzgCommitments = + executionPayloadResult + .getBuilderBidOrFallbackDataFuture() + .orElseThrow() + .thenApply( + builderBidOrFallbackData -> + getBlobKzgCommitmentsFromBuilderFlow( + builderBidOrFallbackData, blobKzgCommitmentsSchema)); + } - final ExecutionPayloadResult executionPayloadResult = - executionLayerBlockProductionManager.initiateBlockProduction( - executionPayloadContext.get(), - blockSlotState, - false, - Optional.empty(), - blockProductionPerformance); + return blobKzgCommitments.thenAccept(bodyBuilder::blobKzgCommitments); + } - return SafeFuture.allOf( - cacheExecutionPayloadValue(executionPayloadResult, blockSlotState), - executionPayloadResult - .getExecutionPayloadFuture() - .orElseThrow() - .thenAccept(bodyBuilder::executionPayload)); + private SszList getBlobKzgCommitmentsFromBuilderFlow( + final BuilderBidOrFallbackData builderBidOrFallbackData, + final BlobKzgCommitmentsSchema blobKzgCommitmentsSchema) { + return builderBidOrFallbackData + .getBuilderBid() + // from the builder bid + .map(BuilderBid::getOptionalBlobKzgCommitments) + // from the local fallback + .orElseGet( + () -> + builderBidOrFallbackData + .getFallbackDataRequired() + .getBlobsBundle() + .map(blobKzgCommitmentsSchema::createFromBlobsBundle)) + .orElseThrow(); } - private SafeFuture builderSetPayloadHeader( - final Function setUnblindedContentIfBuilderFallbacks, + private SafeFuture setExecutionRequests( final BeaconBlockBodyBuilder bodyBuilder, - final SchemaDefinitions schemaDefinitions, - final BeaconState blockSlotState, - final Optional executionPayloadContext, - final Optional requestedBuilderBoostFactor, - final BlockProductionPerformance blockProductionPerformance) { - if (executionPayloadContext.isEmpty()) { - // preMergePayloadHeader - bodyBuilder.executionPayloadHeader( - SchemaDefinitionsBellatrix.required(schemaDefinitions) - .getExecutionPayloadHeaderSchema() - .getHeaderOfDefaultPayload()); + final ExecutionPayloadResult executionPayloadResult) { + if (!bodyBuilder.supportsExecutionRequests()) { return SafeFuture.COMPLETE; } + final SafeFuture executionRequests; + if (executionPayloadResult.isFromLocalFlow()) { + // local, non-blinded flow + executionRequests = + executionPayloadResult + .getExecutionRequestsFutureFromLocalFlow() + .orElseThrow() + .thenApply(Optional::orElseThrow); + } else { + // builder, blinded flow + executionRequests = + executionPayloadResult + .getBuilderBidOrFallbackDataFuture() + .orElseThrow() + .thenApply(this::getExecutionRequestsFromBuilderFlow); + } - final ExecutionPayloadResult executionPayloadResult = - executionLayerBlockProductionManager.initiateBlockProduction( - executionPayloadContext.get(), - blockSlotState, - true, - requestedBuilderBoostFactor, - blockProductionPerformance); - - return SafeFuture.allOf( - cacheExecutionPayloadValue(executionPayloadResult, blockSlotState), - executionPayloadResult - .getHeaderWithFallbackDataFuture() - .orElseThrow() - .thenAccept( - headerWithFallbackData -> { - if (setUnblindedContentIfBuilderFallbacks.apply(headerWithFallbackData)) { - bodyBuilder.executionPayload( - headerWithFallbackData - .getFallbackData() - .orElseThrow() - .getExecutionPayload()); - return; - } - bodyBuilder.executionPayloadHeader( - headerWithFallbackData.getExecutionPayloadHeader()); - })); + return executionRequests.thenAccept(bodyBuilder::executionRequests); } - private SafeFuture builderSetKzgCommitments( - final BeaconBlockBodyBuilder bodyBuilder, - final Function setUnblindedContentIfBuilderFallbacks, - final SchemaDefinitions schemaDefinitions, - final ExecutionPayloadResult executionPayloadResult) { - final BlobKzgCommitmentsSchema blobKzgCommitmentsSchema = - SchemaDefinitionsDeneb.required(schemaDefinitions).getBlobKzgCommitmentsSchema(); - - if (executionPayloadResult.getExecutionPayloadFuture().isPresent()) { - // local flow - return getExecutionBlobsBundle(executionPayloadResult) - .thenApply(blobKzgCommitmentsSchema::createFromBlobsBundle) - .thenAccept(bodyBuilder::blobKzgCommitments); - } - - // builder flow - return getBuilderBlobKzgCommitments( - blobKzgCommitmentsSchema, executionPayloadResult, setUnblindedContentIfBuilderFallbacks) - .thenAccept(bodyBuilder::blobKzgCommitments); + private ExecutionRequests getExecutionRequestsFromBuilderFlow( + final BuilderBidOrFallbackData builderBidOrFallbackData) { + return builderBidOrFallbackData + .getBuilderBid() + // from the builder bid + .flatMap(BuilderBid::getOptionalExecutionRequests) + // from the local fallback + .or(() -> builderBidOrFallbackData.getFallbackDataRequired().getExecutionRequests()) + .orElseThrow(); } public Consumer createBlockUnblinderSelector( @@ -435,156 +403,129 @@ public Consumer createBlockUnblinderSelector( () -> executionLayerBlockProductionManager .getUnblindedPayload(signedBlindedBlock, blockPublishingPerformance) - .thenApply(BuilderPayload::getExecutionPayload)); + .thenApply(this::getExecutionPayloadFromBuilderFlow)); } }; } + private ExecutionPayload getExecutionPayloadFromBuilderFlow( + final BuilderPayloadOrFallbackData builderPayloadOrFallbackData) { + return builderPayloadOrFallbackData + .getBuilderPayload() + // from the builder payload + .map(BuilderPayload::getExecutionPayload) + // from the local fallback + .orElseGet( + () -> builderPayloadOrFallbackData.getFallbackDataRequired().getExecutionPayload()); + } + public Function> createBlobsBundleSelector() { - return block -> getCachedExecutionBlobsBundle(block.getSlot()); + return block -> { + final UInt64 slot = block.getSlot(); + final ExecutionPayloadResult executionPayloadResult = + executionLayerBlockProductionManager + .getCachedPayloadResult(slot) + .orElseThrow( + () -> + new IllegalStateException( + "ExecutionPayloadResult hasn't been cached for slot " + slot)); + + if (executionPayloadResult.isFromLocalFlow()) { + // we performed a non-blinded flow, so the bundle must be in + // getBlobsBundleFutureFromNonBlindedFlow + return executionPayloadResult + .getBlobsBundleFutureFromLocalFlow() + .orElseThrow() + .thenApply(Optional::orElseThrow); + } else { + // we performed a blinded flow, so the bundle must be in the FallbackData in + // getBuilderBidOrFallbackDataFuture + return executionPayloadResult + .getBuilderBidOrFallbackDataFuture() + .orElseThrow() + .thenApply( + builderBidOrFallbackData -> + builderBidOrFallbackData.getFallbackDataRequired().getBlobsBundle()) + .thenApply(Optional::orElseThrow); + } + }; } - public Function> createBlobSidecarsSelector( - final BlockPublishingPerformance blockPublishingPerformance) { + public Function> createBlobSidecarsSelector() { return blockContainer -> { final UInt64 slot = blockContainer.getSlot(); final SignedBeaconBlock block = blockContainer.getSignedBlock(); - final MiscHelpersDeneb miscHelpersDeneb = - MiscHelpersDeneb.required(spec.atSlot(slot).miscHelpers()); - final SszList blobs; final SszList proofs; - final SszList blockCommitments = - block.getMessage().getBody().getOptionalBlobKzgCommitments().orElseThrow(); if (blockContainer.isBlinded()) { - // need to use the builder BlobsBundle for the blinded flow, because the - // blobs and the proofs wouldn't be part of the BlockContainer - final tech.pegasys.teku.spec.datastructures.builder.BlobsBundle blobsBundle = - getCachedBuilderBlobsBundle(slot); - - blobs = blobsBundle.getBlobs(); - proofs = blobsBundle.getProofs(); - - // consistency check because the BlobsBundle comes from an external source (a builder) - checkState( - blobsBundle.getCommitments().hashTreeRoot().equals(blockCommitments.hashTreeRoot()), - "Commitments in the builder BlobsBundle don't match the commitments in the block"); - checkState( - blockCommitments.size() == proofs.size(), - "The number of proofs in BlobsBundle doesn't match the number of commitments in the block"); - checkState( - blockCommitments.size() == blobs.size(), - "The number of blobs in BlobsBundle doesn't match the number of commitments in the block"); + // need to use the builder BlobsBundle or the local fallback for the blinded flow, because + // the blobs and the proofs wouldn't be part of the BlockContainer. + final BuilderPayloadOrFallbackData builderPayloadOrFallbackData = + executionLayerBlockProductionManager + .getCachedUnblindedPayload(slot) + .orElseThrow( + () -> + new IllegalStateException( + "BuilderPayloadOrFallbackData hasn't been cached for slot " + slot)); + + final Optional maybeBuilderPayload = + builderPayloadOrFallbackData.getBuilderPayload(); + + if (maybeBuilderPayload.isPresent()) { + // from the builder payload + final tech.pegasys.teku.spec.datastructures.builder.BlobsBundle blobsBundle = + maybeBuilderPayload.get().getOptionalBlobsBundle().orElseThrow(); + // consistency checks because the BlobsBundle comes from an external source (a builder) + verifyBuilderBlobsBundle(blobsBundle, block); + blobs = blobsBundle.getBlobs(); + proofs = blobsBundle.getProofs(); + } else { + // from the local fallback + final BlobsBundle blobsBundle = + builderPayloadOrFallbackData.getFallbackDataRequired().getBlobsBundle().orElseThrow(); + final BlockContentsSchema blockContentsSchema = + SchemaDefinitionsDeneb.required(spec.atSlot(slot).getSchemaDefinitions()) + .getBlockContentsSchema(); + blobs = blockContentsSchema.getBlobsSchema().createFromElements(blobsBundle.getBlobs()); + proofs = + blockContentsSchema + .getKzgProofsSchema() + .createFromElements( + blobsBundle.getProofs().stream().map(SszKZGProof::new).toList()); + } + } else { blobs = blockContainer.getBlobs().orElseThrow(); proofs = blockContainer.getKzgProofs().orElseThrow(); } - final List blobSidecars = - IntStream.range(0, blobs.size()) - .mapToObj( - index -> - miscHelpersDeneb.constructBlobSidecar( - block, UInt64.valueOf(index), blobs.get(index), proofs.get(index))) - .toList(); - - blockPublishingPerformance.blobSidecarsPrepared(); + final MiscHelpersDeneb miscHelpersDeneb = + MiscHelpersDeneb.required(spec.atSlot(slot).miscHelpers()); - return blobSidecars; + return IntStream.range(0, blobs.size()) + .mapToObj( + index -> + miscHelpersDeneb.constructBlobSidecar( + block, UInt64.valueOf(index), blobs.get(index), proofs.get(index))) + .toList(); }; } - private SafeFuture getExecutionBlobsBundle( - final ExecutionPayloadResult executionPayloadResult) { - return executionPayloadResult - .getBlobsBundleFuture() - .orElseThrow(this::executionBlobsBundleIsNotAvailableException) - .thenApply( - blobsBundle -> - blobsBundle.orElseThrow(this::executionBlobsBundleIsNotAvailableException)); - } - - private SafeFuture getCachedExecutionBlobsBundle(final UInt64 slot) { - final ExecutionPayloadResult executionPayloadResult = - executionLayerBlockProductionManager - .getCachedPayloadResult(slot) - .orElseThrow( - () -> - new IllegalStateException( - "ExecutionPayloadResult hasn't been cached for slot " + slot)); - - final SafeFuture> blobsBundleFuture; - if (executionPayloadResult.getExecutionPayloadFuture().isPresent()) { - // we performed a local flow, so the bundle must be in getBlobsBundleFuture - blobsBundleFuture = - executionPayloadResult - .getBlobsBundleFuture() - .orElseThrow(() -> executionBlobsBundleIsNotAvailableException(slot)); - } else { - // we performed a builder flow, so the bundle must be in getHeaderWithFallbackDataFuture - blobsBundleFuture = - executionPayloadResult - .getHeaderWithFallbackDataFuture() - .orElseThrow(() -> executionBlobsBundleIsNotAvailableException(slot)) - .thenApply( - headerWithFallbackData -> - headerWithFallbackData - .getFallbackData() - .orElseThrow(() -> executionBlobsBundleIsNotAvailableException(slot)) - .getBlobsBundle()); - } - - return blobsBundleFuture.thenApply( - blobsBundle -> - blobsBundle.orElseThrow(() -> executionBlobsBundleIsNotAvailableException(slot))); - } - - private IllegalStateException executionBlobsBundleIsNotAvailableException() { - return new IllegalStateException("execution BlobsBundle is not available"); - } - - private IllegalStateException executionBlobsBundleIsNotAvailableException(final UInt64 slot) { - return new IllegalStateException("execution BlobsBundle is not available for slot " + slot); - } - - private SafeFuture> getBuilderBlobKzgCommitments( - final BlobKzgCommitmentsSchema blobKzgCommitmentsSchema, - final ExecutionPayloadResult executionPayloadResult, - final Function setUnblindedContentIfBuilderFallbacks) { - - return executionPayloadResult - .getHeaderWithFallbackDataFuture() - .orElseThrow() - .thenApply( - headerWithFallbackData -> { - if (setUnblindedContentIfBuilderFallbacks.apply(headerWithFallbackData)) { - return blobKzgCommitmentsSchema.createFromBlobsBundle( - headerWithFallbackData - .getFallbackData() - .orElseThrow() - .getBlobsBundle() - .orElseThrow()); - } - return headerWithFallbackData - .getBlobKzgCommitments() - .orElseThrow( - () -> - new IllegalStateException( - "builder BlobKzgCommitments are not available")); - }); - } - - private tech.pegasys.teku.spec.datastructures.builder.BlobsBundle getCachedBuilderBlobsBundle( - final UInt64 slot) { - return executionLayerBlockProductionManager - .getCachedUnblindedPayload(slot) - .orElseThrow( - () -> new IllegalStateException("BuilderPayload hasn't been cached for slot " + slot)) - .getOptionalBlobsBundle() - .orElseThrow( - () -> - new IllegalStateException("builder BlobsBundle is not available for slot " + slot)); + private void verifyBuilderBlobsBundle( + final tech.pegasys.teku.spec.datastructures.builder.BlobsBundle blobsBundle, + final SignedBeaconBlock block) { + final SszList blockCommitments = + block.getMessage().getBody().getOptionalBlobKzgCommitments().orElseThrow(); + checkState( + blobsBundle.getCommitments().hashTreeRoot().equals(blockCommitments.hashTreeRoot()), + "Commitments in the builder BlobsBundle don't match the commitments in the block"); + checkState( + blockCommitments.size() == blobsBundle.getProofs().size(), + "The number of proofs in the builder BlobsBundle doesn't match the number of commitments in the block"); + checkState( + blockCommitments.size() == blobsBundle.getBlobs().size(), + "The number of blobs in the builder BlobsBundle doesn't match the number of commitments in the block"); } } diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/DepositProvider.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/DepositProvider.java index db98ba13296..db6d0ebdb3c 100644 --- a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/DepositProvider.java +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/DepositProvider.java @@ -103,13 +103,13 @@ public synchronized void onDepositsFromBlock(final DepositsFromBlockEvent event) event.getDeposits().stream() .map(depositUtil::convertDepositEventToOperationDeposit) .forEach( - deposit -> { + depositWithIndex -> { if (!recentChainData.isPreGenesis()) { - LOG.debug("About to process deposit: {}", deposit.getIndex()); + LOG.debug("About to process deposit: {}", depositWithIndex.index()); } - depositNavigableMap.put(deposit.getIndex(), deposit); - depositMerkleTree.pushLeaf(deposit.getData().hashTreeRoot()); + depositNavigableMap.put(depositWithIndex.index(), depositWithIndex); + depositMerkleTree.pushLeaf(depositWithIndex.deposit().getData().hashTreeRoot()); }); depositCounter.inc(event.getDeposits().size()); eth1DataCache.onBlockWithDeposit( @@ -184,6 +184,9 @@ public void onSlot(final UInt64 slot) { .get() .thenAccept( state -> { + if (spec.isFormerDepositMechanismDisabled(state)) { + return; + } // We want to verify our Beacon Node view of the eth1 deposits. // So we want to check if it has the necessary deposit data to propose a block final UInt64 eth1DepositCount = state.getEth1Data().getDepositCount(); @@ -208,6 +211,18 @@ public synchronized SszList getDeposits( final BeaconState state, final Eth1Data eth1Data) { final long maxDeposits = spec.getMaxDeposits(state); final SszListSchema depositsSchema = depositsSchemaCache.get(maxDeposits); + return getDepositsWithIndex(state, eth1Data).stream() + .map(DepositWithIndex::deposit) + .collect(depositsSchema.collector()); + } + + public synchronized List getDepositsWithIndex( + final BeaconState state, final Eth1Data eth1Data) { + final long maxDeposits = spec.getMaxDeposits(state); + // no Eth1 deposits needed if already transitioned to the EIP-6110 mechanism + if (spec.isFormerDepositMechanismDisabled(state)) { + return emptyList(); + } final UInt64 eth1DepositCount; if (spec.isEnoughVotesToUpdateEth1Data(state, eth1Data, 1)) { eth1DepositCount = eth1Data.getDepositCount(); @@ -217,11 +232,24 @@ public synchronized SszList getDeposits( final UInt64 eth1DepositIndex = state.getEth1DepositIndex(); final UInt64 eth1PendingDepositCount = - eth1DepositCount.minusMinZero(eth1DepositIndex).min(maxDeposits); + state + .toVersionElectra() + .map( + stateElectra -> { + // EIP-6110 + final UInt64 eth1DepositIndexLimit = + eth1DepositCount.min(stateElectra.getDepositRequestsStartIndex()); + return eth1DepositIndexLimit.minusMinZero(eth1DepositIndex).min(maxDeposits); + }) + .orElseGet( + () -> { + // Phase0 + return eth1DepositCount.minusMinZero(eth1DepositIndex).min(maxDeposits); + }); // No deposits to include if (eth1PendingDepositCount.isZero()) { - return depositsSchema.createFromElements(emptyList()); + return emptyList(); } // We need to have all the deposits that can be included in the state available to ensure @@ -230,7 +258,7 @@ public synchronized SszList getDeposits( final UInt64 toDepositIndex = eth1DepositIndex.plus(eth1PendingDepositCount); - return getDepositsWithProof(eth1DepositIndex, toDepositIndex, eth1DepositCount, depositsSchema); + return getDepositsWithProof(eth1DepositIndex, toDepositIndex, eth1DepositCount); } protected synchronized List getAvailableDeposits() { @@ -263,11 +291,8 @@ public synchronized int getDepositMapSize() { * @param toDepositIndex exclusive * @param eth1DepositCount number of deposits in the merkle tree according to Eth1Data in state */ - private SszList getDepositsWithProof( - final UInt64 fromDepositIndex, - final UInt64 toDepositIndex, - final UInt64 eth1DepositCount, - final SszListSchema depositsSchema) { + private List getDepositsWithProof( + final UInt64 fromDepositIndex, final UInt64 toDepositIndex, final UInt64 eth1DepositCount) { final AtomicReference expectedDepositIndex = new AtomicReference<>(fromDepositIndex); final SszBytes32VectorSchema depositProofSchema = Deposit.SSZ_SCHEMA.getProofSchema(); if (depositMerkleTree.getDepositCount() < eth1DepositCount.intValue()) { @@ -281,17 +306,19 @@ private SszList getDepositsWithProof( .values() .stream() .map( - deposit -> { - if (!deposit.getIndex().equals(expectedDepositIndex.get())) { + depositWithIndex -> { + if (!depositWithIndex.index().equals(expectedDepositIndex.get())) { throw MissingDepositsException.missingRange( - expectedDepositIndex.get(), deposit.getIndex()); + expectedDepositIndex.get(), depositWithIndex.index()); } - expectedDepositIndex.set(deposit.getIndex().plus(ONE)); + expectedDepositIndex.set(depositWithIndex.index().plus(ONE)); SszBytes32Vector proof = - depositProofSchema.of(merkleTree.getProof(deposit.getIndex().intValue())); - return new DepositWithIndex(proof, deposit.getData(), deposit.getIndex()); + depositProofSchema.of(merkleTree.getProof(depositWithIndex.index().intValue())); + return new DepositWithIndex( + new Deposit(proof, depositWithIndex.deposit().getData()), + depositWithIndex.index()); }) - .collect(depositsSchema.collector()); + .toList(); } @Override @@ -303,7 +330,7 @@ public synchronized void onInitialDepositTreeSnapshot( private static class DepositsSchemaCache { private SszListSchema cachedSchema; - public SszListSchema get(long maxDeposits) { + public SszListSchema get(final long maxDeposits) { SszListSchema cachedSchemaLoc = cachedSchema; if (cachedSchemaLoc == null || maxDeposits != cachedSchemaLoc.getMaxLength()) { cachedSchemaLoc = SszListSchema.create(Deposit.SSZ_SCHEMA, maxDeposits); diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/DutyMetrics.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/DutyMetrics.java index c42d7cc2270..0466da1113d 100644 --- a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/DutyMetrics.java +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/DutyMetrics.java @@ -45,7 +45,7 @@ public class DutyMetrics { final RecentChainData recentChainData, final MetricsCountersByIntervals attestationTimings, final MetricsCountersByIntervals blockTimings, - LabelledMetric validatorDutyMetric, + final LabelledMetric validatorDutyMetric, final Spec spec) { this.timeProvider = timeProvider; this.recentChainData = recentChainData; @@ -64,7 +64,7 @@ public static DutyMetrics create( MetricsCountersByIntervals.create( TekuMetricCategory.VALIDATOR, metricsSystem, - "attestation_publication_delay", + "attestation_publication_delay_total", "Counter of attestations published in different time intervals after their due time", Collections.emptyList(), Map.of(List.of(), List.of(1L, 500L, 1000L, 2000L, 3000L, 4000L, 5000L, 8000L))); @@ -72,7 +72,7 @@ public static DutyMetrics create( MetricsCountersByIntervals.create( TekuMetricCategory.VALIDATOR, metricsSystem, - "block_publication_delay", + "block_publication_delay_total", "Counter of blocks published in different time intervals after their due time", Collections.emptyList(), Map.of(List.of(), List.of(1L, 500L, 1000L, 2000L, 3000L, 4000L, 5000L, 8000L, 12000L))); diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/Eth1DataCache.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/Eth1DataCache.java index 81e0977eac0..d688d0e057e 100644 --- a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/Eth1DataCache.java +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/Eth1DataCache.java @@ -28,6 +28,7 @@ import tech.pegasys.teku.infrastructure.metrics.SettableGauge; import tech.pegasys.teku.infrastructure.metrics.TekuMetricCategory; import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.blocks.Eth1Data; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; @@ -39,6 +40,7 @@ public class Eth1DataCache { static final String VOTES_CURRENT_METRIC_NAME = "eth1_current_period_votes_current"; static final String VOTES_BEST_METRIC_NAME = "eth1_current_period_votes_best"; + private final Spec spec; private final Eth1VotingPeriod eth1VotingPeriod; private final UInt64 cacheDuration; @@ -50,7 +52,9 @@ public class Eth1DataCache { private final SettableGauge currentPeriodVotesBest; private final SettableGauge currentPeriodVotesMax; - public Eth1DataCache(final MetricsSystem metricsSystem, final Eth1VotingPeriod eth1VotingPeriod) { + public Eth1DataCache( + final Spec spec, final MetricsSystem metricsSystem, final Eth1VotingPeriod eth1VotingPeriod) { + this.spec = spec; this.eth1VotingPeriod = eth1VotingPeriod; cacheDuration = eth1VotingPeriod.getCacheDurationInSeconds(); metricsSystem.createIntegerGauge( @@ -111,6 +115,10 @@ public void onEth1Block( } public Eth1Data getEth1Vote(final BeaconState state) { + if (spec.isFormerDepositMechanismDisabled(state)) { + // no need for a real vote when Eth1 polling has been disabled + return state.getEth1Data(); + } final NavigableMap votesToConsider = getVotesToConsider(state.getSlot(), state.getGenesisTime(), state.getEth1Data()); // Avoid using .values() directly as it has O(n) lookup which gets expensive fast @@ -134,6 +142,10 @@ public Collection getAllEth1Blocks() { } public void updateMetrics(final BeaconState state) { + if (spec.isFormerDepositMechanismDisabled(state)) { + // no need to update metrics when Eth1 polling has been disabled + return; + } final Eth1Data currentEth1Data = state.getEth1Data(); // Avoid using .values() directly as it has O(n) lookup which gets expensive fast final Set knownBlocks = diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/Eth1DataProvider.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/Eth1DataProvider.java index 425d8fae35c..7f3e440b333 100644 --- a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/Eth1DataProvider.java +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/Eth1DataProvider.java @@ -34,7 +34,8 @@ public class Eth1DataProvider { private final Eth1DataCache eth1DataCache; private final DepositProvider depositProvider; - public Eth1DataProvider(Eth1DataCache eth1DataCache, DepositProvider depositProvider) { + public Eth1DataProvider( + final Eth1DataCache eth1DataCache, final DepositProvider depositProvider) { this.eth1DataCache = eth1DataCache; this.depositProvider = depositProvider; } diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/Eth1Vote.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/Eth1Vote.java index ef4fd08c278..d75bd70c16c 100644 --- a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/Eth1Vote.java +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/Eth1Vote.java @@ -20,7 +20,7 @@ public class Eth1Vote implements Comparable { private int vote = 0; private final int index; - public Eth1Vote(int index) { + public Eth1Vote(final int index) { this.index = index; } @@ -35,7 +35,7 @@ public int getVoteCount() { // Greater vote number, or in case of a tie, // smallest index number wins @Override - public int compareTo(Eth1Vote eth1Vote) { + public int compareTo(final Eth1Vote eth1Vote) { if (this.vote > eth1Vote.vote) { return 1; } else if (this.vote < eth1Vote.vote) { diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/GraffitiBuilder.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/GraffitiBuilder.java index 611803cf3a3..f2bddbc70bf 100644 --- a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/GraffitiBuilder.java +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/GraffitiBuilder.java @@ -20,7 +20,6 @@ import java.util.Arrays; import java.util.Locale; import java.util.Optional; -import java.util.concurrent.atomic.AtomicReference; import java.util.stream.Collectors; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; @@ -38,22 +37,19 @@ * according to the clientGraffitiAppendFormat configuration. */ public class GraffitiBuilder implements ExecutionClientVersionChannel { + private static final Logger LOG = LogManager.getLogger(); private static final String SPACE = " "; + private volatile Optional executionClientVersion = Optional.empty(); + private final ClientGraffitiAppendFormat clientGraffitiAppendFormat; private final ClientVersion consensusClientVersion; - private final AtomicReference executionClientVersion; - private final Optional defaultUserGraffiti; - public GraffitiBuilder( - final ClientGraffitiAppendFormat clientGraffitiAppendFormat, - final Optional defaultUserGraffiti) { + public GraffitiBuilder(final ClientGraffitiAppendFormat clientGraffitiAppendFormat) { this.clientGraffitiAppendFormat = clientGraffitiAppendFormat; this.consensusClientVersion = createTekuClientVersion(); - this.executionClientVersion = new AtomicReference<>(ClientVersion.UNKNOWN); - this.defaultUserGraffiti = defaultUserGraffiti; } private ClientVersion createTekuClientVersion() { @@ -72,10 +68,19 @@ public ClientVersion getConsensusClientVersion() { @Override public void onExecutionClientVersion(final ClientVersion executionClientVersion) { - this.executionClientVersion.set(executionClientVersion); - final Optional defaultGraffiti = Optional.of(buildGraffiti(defaultUserGraffiti)); - EVENT_LOG.logDefaultGraffiti( - extractGraffiti(defaultGraffiti, calculateGraffitiLength(defaultGraffiti))); + this.executionClientVersion = Optional.of(executionClientVersion); + logGraffitiWatermark(); + } + + @Override + public void onExecutionClientVersionNotAvailable() { + logGraffitiWatermark(); + } + + private void logGraffitiWatermark() { + final Optional graffitiWatermark = Optional.of(buildGraffiti(Optional.empty())); + EVENT_LOG.logGraffitiWatermark( + extractGraffiti(graffitiWatermark, calculateGraffitiLength(graffitiWatermark))); } public Bytes32 buildGraffiti(final Optional userGraffiti) { @@ -85,6 +90,11 @@ public Bytes32 buildGraffiti(final Optional userGraffiti) { return switch (clientGraffitiAppendFormat) { case AUTO -> { final int clientInfoLength = Bytes32.SIZE - 1 - userGraffitiLength; + // Could drop SPACE's `-1` in a corner case + if (clientInfoLength == 3) { + yield joinNonEmpty( + "", extractGraffiti(userGraffiti, userGraffitiLength), formatClientsInfo(4)); + } yield joinNonEmpty( SPACE, extractGraffiti(userGraffiti, userGraffitiLength), @@ -92,6 +102,11 @@ yield joinNonEmpty( } case CLIENT_CODES -> { final int clientInfoLength = Integer.min(Bytes32.SIZE - 1 - userGraffitiLength, 4); + // Could drop SPACE's `-1` in a corner case + if (clientInfoLength == 3) { + yield joinNonEmpty( + "", extractGraffiti(userGraffiti, userGraffitiLength), formatClientsInfo(4)); + } yield joinNonEmpty( SPACE, extractGraffiti(userGraffiti, userGraffitiLength), @@ -128,56 +143,62 @@ protected Bytes32 joinNonEmpty(final String delimiter, final String... parts) { @VisibleForTesting protected String formatClientsInfo(final int length) { - final boolean isElInfoAvailable = !ClientVersion.UNKNOWN.equals(executionClientVersion.get()); - final String safeConsensusCode = extractClientCodeSafely(consensusClientVersion); - final String safeExecutionCode = - isElInfoAvailable ? extractClientCodeSafely(executionClientVersion.get()) : ""; + final String consensusCode = consensusClientVersion.code(); + final String executionCode = getExecutionCodeSafely(); // LH1be52536BU0f91a674 if (length >= 20) { return String.format( "%s%s%s%s", - safeConsensusCode, - consensusClientVersion.commit().toUnprefixedHexString(), - safeExecutionCode, - isElInfoAvailable ? executionClientVersion.get().commit().toUnprefixedHexString() : ""); + consensusCode, + getCommit(consensusClientVersion), + executionCode, + executionClientVersion.map(this::getCommit).orElse("")); } // LH1be5BU0f91 if (length >= 12) { return String.format( "%s%s%s%s", - safeConsensusCode, - consensusClientVersion.commit().toUnprefixedHexString().substring(0, 4), - safeExecutionCode, - isElInfoAvailable - ? executionClientVersion.get().commit().toUnprefixedHexString().substring(0, 4) - : ""); + consensusCode, + getCommit(consensusClientVersion, 4), + executionCode, + executionClientVersion.map(clientVersion -> getCommit(clientVersion, 4)).orElse("")); } // LH1bBU0f if (length >= 8) { return String.format( "%s%s%s%s", - safeConsensusCode, - consensusClientVersion.commit().toUnprefixedHexString().substring(0, 2), - safeExecutionCode, - isElInfoAvailable - ? executionClientVersion.get().commit().toUnprefixedHexString().substring(0, 2) - : ""); + consensusCode, + getCommit(consensusClientVersion, 2), + executionCode, + executionClientVersion.map(clientVersion -> getCommit(clientVersion, 2)).orElse("")); } // LHBU if (length >= 4) { - return String.format("%s%s", safeConsensusCode, isElInfoAvailable ? safeExecutionCode : ""); + return String.format("%s%s", consensusCode, executionCode); } return ""; } - protected String extractClientCodeSafely(final ClientVersion clientVersion) { - final boolean isValid = - clientVersion.code() != null - && clientVersion.code().length() >= 2 - && clientVersion.code().substring(0, 2).matches("[a-zA-Z]{2}"); - return isValid - ? clientVersion.code().substring(0, 2).toUpperCase(Locale.ROOT) - : ClientVersion.UNKNOWN.code(); + private String getExecutionCodeSafely() { + return executionClientVersion + .map( + clientVersion -> { + final String code = clientVersion.code(); + final boolean isValid = + code != null && code.length() >= 2 && code.substring(0, 2).matches("[a-zA-Z]{2}"); + return isValid + ? code.substring(0, 2).toUpperCase(Locale.ROOT) + : ClientVersion.UNKNOWN_CLIENT_CODE; + }) + .orElse(""); + } + + private String getCommit(final ClientVersion clientVersion) { + return clientVersion.commit().toUnprefixedHexString(); + } + + private String getCommit(final ClientVersion clientVersion, final int length) { + return getCommit(clientVersion).substring(0, length); } } diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/MilestoneBasedBlockFactory.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/MilestoneBasedBlockFactory.java index 4f2e1cb4be1..2bc3f346565 100644 --- a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/MilestoneBasedBlockFactory.java +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/MilestoneBasedBlockFactory.java @@ -14,7 +14,8 @@ package tech.pegasys.teku.validator.coordinator; import com.google.common.base.Suppliers; -import java.util.HashMap; +import java.util.Collections; +import java.util.EnumMap; import java.util.List; import java.util.Map; import java.util.Optional; @@ -38,7 +39,8 @@ public class MilestoneBasedBlockFactory implements BlockFactory { - private final Map registeredFactories = new HashMap<>(); + private final Map registeredFactories = + new EnumMap<>(SpecMilestone.class); private final Spec spec; @@ -50,17 +52,13 @@ public MilestoneBasedBlockFactory( // Not needed for all milestones final Supplier blockFactoryDenebSupplier = Suppliers.memoize(() -> new BlockFactoryDeneb(spec, operationSelector)); - final Supplier blockFactoryEip7594Supplier = - Suppliers.memoize(() -> new BlockFactoryEip7594(spec, operationSelector, kzg)); // Populate forks factories spec.getEnabledMilestones() .forEach( forkAndSpecMilestone -> { final SpecMilestone milestone = forkAndSpecMilestone.getSpecMilestone(); - if (milestone.isGreaterThanOrEqualTo(SpecMilestone.EIP7594)) { - registeredFactories.put(milestone, blockFactoryEip7594Supplier.get()); - } else if (milestone.equals(SpecMilestone.DENEB)) { + if (milestone.equals(SpecMilestone.DENEB)) { registeredFactories.put(milestone, blockFactoryDenebSupplier.get()); } else { registeredFactories.put(milestone, blockFactoryPhase0); @@ -74,7 +72,6 @@ public SafeFuture createUnsignedBlock( final UInt64 proposalSlot, final BLSSignature randaoReveal, final Optional optionalGraffiti, - final Optional requestedBlinded, final Optional requestedBuilderBoostFactor, final BlockProductionPerformance blockProductionPerformance) { final SpecMilestone milestone = getMilestone(proposalSlot); @@ -85,7 +82,6 @@ public SafeFuture createUnsignedBlock( proposalSlot, randaoReveal, optionalGraffiti, - requestedBlinded, requestedBuilderBoostFactor, blockProductionPerformance); } @@ -101,20 +97,15 @@ public SafeFuture unblindSignedBlockIfBlinded( } @Override - public List createBlobSidecars( - final SignedBlockContainer blockContainer, - BlockPublishingPerformance blockPublishingPerformance) { + public List createBlobSidecars(final SignedBlockContainer blockContainer) { final SpecMilestone milestone = getMilestone(blockContainer.getSlot()); - return registeredFactories - .get(milestone) - .createBlobSidecars(blockContainer, blockPublishingPerformance); + return registeredFactories.get(milestone).createBlobSidecars(blockContainer); } @Override public List createDataColumnSidecars( - final SignedBlockContainer blockContainer, List blobs) { - final SpecMilestone milestone = getMilestone(blockContainer.getSlot()); - return registeredFactories.get(milestone).createDataColumnSidecars(blockContainer, blobs); + final SignedBlockContainer blockContainer, final List blobs) { + return Collections.emptyList(); } private SpecMilestone getMilestone(final UInt64 slot) { diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/MilestoneWithFeaturesBlockFactory.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/MilestoneWithFeaturesBlockFactory.java new file mode 100644 index 00000000000..3b2296adbbd --- /dev/null +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/MilestoneWithFeaturesBlockFactory.java @@ -0,0 +1,115 @@ +/* + * Copyright Consensys Software Inc., 2023 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.coordinator; + +import com.google.common.base.Suppliers; +import java.util.List; +import java.util.Optional; +import java.util.TreeMap; +import java.util.function.Supplier; +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.bls.BLSSignature; +import tech.pegasys.teku.ethereum.performance.trackers.BlockProductionPerformance; +import tech.pegasys.teku.ethereum.performance.trackers.BlockPublishingPerformance; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.kzg.KZG; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecFeature; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.config.features.Eip7594; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.Blob; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; +import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSidecar; +import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; +import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockContainer; +import tech.pegasys.teku.spec.datastructures.metadata.BlockContainerAndMetaData; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; + +public class MilestoneWithFeaturesBlockFactory implements BlockFactory { + + private final TreeMap registeredFactories = new TreeMap<>(); + + private final Spec spec; + + public MilestoneWithFeaturesBlockFactory( + final Spec spec, final BlockOperationSelectorFactory operationSelector, final KZG kzg) { + this.spec = spec; + final BlockFactoryPhase0 blockFactoryPhase0 = new BlockFactoryPhase0(spec, operationSelector); + + // Not needed for all milestones + final Supplier blockFactoryDenebSupplier = + Suppliers.memoize(() -> new BlockFactoryDeneb(spec, operationSelector)); + final Supplier blockFactoryEip7594Supplier = + Suppliers.memoize(() -> new BlockFactoryEip7594(spec, operationSelector, kzg)); + + // Populate forks factories + registeredFactories.put(UInt64.ZERO, blockFactoryPhase0); + if (spec.isMilestoneSupported(SpecMilestone.DENEB)) { + registeredFactories.put( + spec.getForkSchedule().getFork(SpecMilestone.DENEB).getEpoch(), + blockFactoryDenebSupplier.get()); + } + if (spec.isFeatureScheduled(SpecFeature.EIP7594)) { + registeredFactories.put( + // TODO: don't like to pull Electra for this + Eip7594.required(spec.forMilestone(SpecMilestone.ELECTRA).getConfig()) + .getEip7594FeatureEpoch(), + blockFactoryEip7594Supplier.get()); + } + } + + // TODO: test + private BlockFactory getFactoryForSlot(final UInt64 slot) { + return registeredFactories.headMap(spec.computeEpochAtSlot(slot), true).lastEntry().getValue(); + } + + @Override + public SafeFuture createUnsignedBlock( + final BeaconState blockSlotState, + final UInt64 proposalSlot, + final BLSSignature randaoReveal, + final Optional optionalGraffiti, + final Optional requestedBuilderBoostFactor, + final BlockProductionPerformance blockProductionPerformance) { + return getFactoryForSlot(proposalSlot) + .createUnsignedBlock( + blockSlotState, + proposalSlot, + randaoReveal, + optionalGraffiti, + requestedBuilderBoostFactor, + blockProductionPerformance); + } + + @Override + public SafeFuture unblindSignedBlockIfBlinded( + final SignedBeaconBlock maybeBlindedBlock, + final BlockPublishingPerformance blockPublishingPerformance) { + return getFactoryForSlot(maybeBlindedBlock.getSlot()) + .unblindSignedBlockIfBlinded(maybeBlindedBlock, blockPublishingPerformance); + } + + @Override + public List createBlobSidecars(final SignedBlockContainer blockContainer) { + return getFactoryForSlot(blockContainer.getSlot()).createBlobSidecars(blockContainer); + } + + @Override + public List createDataColumnSidecars( + final SignedBlockContainer blockContainer, final List blobs) { + return getFactoryForSlot(blockContainer.getSlot()) + .createDataColumnSidecars(blockContainer, blobs); + } +} diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/ValidatorApiHandler.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/ValidatorApiHandler.java index 506d9d49eda..04648dd04fb 100644 --- a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/ValidatorApiHandler.java +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/ValidatorApiHandler.java @@ -21,6 +21,8 @@ import static tech.pegasys.teku.infrastructure.metrics.Validator.ValidatorDutyMetricUtils.startTimer; import static tech.pegasys.teku.infrastructure.metrics.Validator.ValidatorDutyMetricsSteps.CREATE; import static tech.pegasys.teku.spec.config.SpecConfig.GENESIS_SLOT; +import static tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel.EQUIVOCATION; +import static tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel.GOSSIP; import com.google.common.annotations.VisibleForTesting; import it.unimi.dsi.fastutil.ints.IntCollection; @@ -39,6 +41,7 @@ import org.apache.tuweni.bytes.Bytes32; import org.hyperledger.besu.plugin.services.metrics.OperationTimer; import tech.pegasys.teku.api.ChainDataProvider; +import tech.pegasys.teku.api.NetworkDataProvider; import tech.pegasys.teku.api.NodeDataProvider; import tech.pegasys.teku.api.migrated.ValidatorLivenessAtEpoch; import tech.pegasys.teku.api.response.v1.beacon.ValidatorStatus; @@ -46,6 +49,7 @@ import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.ethereum.json.types.beacon.StateValidatorData; +import tech.pegasys.teku.ethereum.json.types.node.PeerCount; import tech.pegasys.teku.ethereum.json.types.validator.AttesterDuties; import tech.pegasys.teku.ethereum.json.types.validator.BeaconCommitteeSelectionProof; import tech.pegasys.teku.ethereum.json.types.validator.ProposerDuties; @@ -53,15 +57,14 @@ import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeDuties; import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeDuty; import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSelectionProof; +import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.ethereum.performance.trackers.BlockProductionAndPublishingPerformanceFactory; import tech.pegasys.teku.ethereum.performance.trackers.BlockProductionPerformance; import tech.pegasys.teku.ethereum.performance.trackers.BlockPublishingPerformance; import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.collections.LimitedMap; import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.networking.eth2.gossip.BlobSidecarGossipChannel; -import tech.pegasys.teku.networking.eth2.gossip.BlockGossipChannel; -import tech.pegasys.teku.networking.eth2.gossip.DataColumnSidecarGossipChannel; import tech.pegasys.teku.networking.eth2.gossip.subnets.AttestationTopicSubscriber; import tech.pegasys.teku.networking.eth2.gossip.subnets.SyncCommitteeSubscriptionManager; import tech.pegasys.teku.spec.Spec; @@ -80,15 +83,13 @@ import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeContribution; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeMessage; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.ValidatableSyncCommitteeMessage; -import tech.pegasys.teku.spec.datastructures.operations.versions.bellatrix.BeaconPreparableProposer; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.datastructures.validator.BeaconPreparableProposer; import tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel; import tech.pegasys.teku.spec.datastructures.validator.SubnetSubscription; import tech.pegasys.teku.spec.logic.common.util.SyncCommitteeUtil; import tech.pegasys.teku.statetransition.attestation.AggregatingAttestationPool; import tech.pegasys.teku.statetransition.attestation.AttestationManager; -import tech.pegasys.teku.statetransition.blobs.BlockBlobSidecarsTrackersPool; -import tech.pegasys.teku.statetransition.block.BlockImportChannel; import tech.pegasys.teku.statetransition.forkchoice.ForkChoiceTrigger; import tech.pegasys.teku.statetransition.forkchoice.ProposersDataManager; import tech.pegasys.teku.statetransition.synccommittee.SyncCommitteeContributionPool; @@ -99,12 +100,10 @@ import tech.pegasys.teku.validator.api.NodeSyncingException; import tech.pegasys.teku.validator.api.SendSignedBlockResult; import tech.pegasys.teku.validator.api.SubmitDataError; -import tech.pegasys.teku.validator.api.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.validator.api.ValidatorApiChannel; import tech.pegasys.teku.validator.coordinator.duties.AttesterDutiesGenerator; import tech.pegasys.teku.validator.coordinator.performance.PerformanceTracker; import tech.pegasys.teku.validator.coordinator.publisher.BlockPublisher; -import tech.pegasys.teku.validator.coordinator.publisher.MilestoneBasedBlockPublisher; public class ValidatorApiHandler implements ValidatorApiChannel { @@ -117,10 +116,14 @@ public class ValidatorApiHandler implements ValidatorApiChannel { */ private static final int DUTY_EPOCH_TOLERANCE = 1; + private final Map>> + localBlockProductionBySlotCache = LimitedMap.createSynchronizedLRU(2); + private final BlockProductionAndPublishingPerformanceFactory blockProductionAndPublishingPerformanceFactory; private final ChainDataProvider chainDataProvider; private final NodeDataProvider nodeDataProvider; + private final NetworkDataProvider networkDataProvider; private final CombinedChainDataClient combinedChainDataClient; private final SyncStateProvider syncStateProvider; private final BlockFactory blockFactory; @@ -143,14 +146,10 @@ public class ValidatorApiHandler implements ValidatorApiChannel { public ValidatorApiHandler( final ChainDataProvider chainDataProvider, final NodeDataProvider nodeDataProvider, + final NetworkDataProvider networkDataProvider, final CombinedChainDataClient combinedChainDataClient, final SyncStateProvider syncStateProvider, final BlockFactory blockFactory, - final BlockImportChannel blockImportChannel, - final BlockGossipChannel blockGossipChannel, - final BlockBlobSidecarsTrackersPool blockBlobSidecarsTrackersPool, - final BlobSidecarGossipChannel blobSidecarGossipChannel, - final DataColumnSidecarGossipChannel dataColumnSidecarGossipChannel, final AggregatingAttestationPool attestationPool, final AttestationManager attestationManager, final AttestationTopicSubscriber attestationTopicSubscriber, @@ -164,11 +163,13 @@ public ValidatorApiHandler( final SyncCommitteeContributionPool syncCommitteeContributionPool, final SyncCommitteeSubscriptionManager syncCommitteeSubscriptionManager, final BlockProductionAndPublishingPerformanceFactory - blockProductionAndPublishingPerformanceFactory) { + blockProductionAndPublishingPerformanceFactory, + final BlockPublisher blockPublisher) { this.blockProductionAndPublishingPerformanceFactory = blockProductionAndPublishingPerformanceFactory; this.chainDataProvider = chainDataProvider; this.nodeDataProvider = nodeDataProvider; + this.networkDataProvider = networkDataProvider; this.combinedChainDataClient = combinedChainDataClient; this.syncStateProvider = syncStateProvider; this.blockFactory = blockFactory; @@ -184,17 +185,7 @@ public ValidatorApiHandler( this.syncCommitteeContributionPool = syncCommitteeContributionPool; this.syncCommitteeSubscriptionManager = syncCommitteeSubscriptionManager; this.proposersDataManager = proposersDataManager; - this.blockPublisher = - new MilestoneBasedBlockPublisher( - spec, - blockFactory, - blockImportChannel, - blockGossipChannel, - blockBlobSidecarsTrackersPool, - blobSidecarGossipChannel, - dataColumnSidecarGossipChannel, - performanceTracker, - dutyMetrics); + this.blockPublisher = blockPublisher; this.attesterDutiesGenerator = new AttesterDutiesGenerator(spec); } @@ -295,9 +286,14 @@ public SafeFuture> getProposerDuties(final UInt64 epoch optionalState.map(state -> getProposerDutiesFromIndicesAndState(state, epoch))); } + @Override + public SafeFuture> getPeerCount() { + return SafeFuture.completedFuture(Optional.of(networkDataProvider.getPeerCount())); + } + @Override public SafeFuture>> getValidatorStatuses( - Collection validatorIdentifiers) { + final Collection validatorIdentifiers) { return isSyncActive() ? SafeFuture.completedFuture(Optional.empty()) : chainDataProvider @@ -316,12 +312,34 @@ public SafeFuture>> getValidatorStat StateValidatorData::getStatus)))); } + /** + * Block would be produced only once per slot. Any additional calls to this method for the same + * slot would return the same {@link SafeFuture} as the first one. The only exception is when the + * block production fails. In this case, the next call would attempt to produce the block again. + */ @Override public SafeFuture> createUnsignedBlock( final UInt64 slot, final BLSSignature randaoReveal, final Optional graffiti, - final Optional requestedBlinded, + final Optional requestedBuilderBoostFactor) { + return localBlockProductionBySlotCache + .computeIfAbsent( + slot, + __ -> + createUnsignedBlockInternal( + slot, randaoReveal, graffiti, requestedBuilderBoostFactor)) + .whenException( + __ -> { + // allow further block production attempts for this slot + localBlockProductionBySlotCache.remove(slot); + }); + } + + public SafeFuture> createUnsignedBlockInternal( + final UInt64 slot, + final BLSSignature randaoReveal, + final Optional graffiti, final Optional requestedBuilderBoostFactor) { LOG.info("Creating unsigned block for slot {}", slot); performanceTracker.reportBlockProductionAttempt(spec.computeEpochAtSlot(slot)); @@ -343,10 +361,15 @@ public SafeFuture> createUnsignedBlock( slot, randaoReveal, graffiti, - requestedBlinded, requestedBuilderBoostFactor, blockSlotState, blockProductionPerformance)) + .thenPeek( + maybeBlock -> + maybeBlock.ifPresent( + block -> + performanceTracker.saveProducedBlock( + block.blockContainer().getBlock().getSlotAndBlockRoot()))) .alwaysRun(blockProductionPerformance::complete); } @@ -354,7 +377,6 @@ private SafeFuture> createBlock( final UInt64 slot, final BLSSignature randaoReveal, final Optional graffiti, - final Optional requestedBlinded, final Optional requestedBuilderBoostFactor, final Optional maybeBlockSlotState, final BlockProductionPerformance blockProductionPerformance) { @@ -376,7 +398,6 @@ private SafeFuture> createBlock( slot, randaoReveal, graffiti, - requestedBlinded, requestedBuilderBoostFactor, blockProductionPerformance) .thenApply(Optional::of); @@ -479,13 +500,15 @@ private AttestationData createAttestationData( @Override public SafeFuture> createAggregate( - final UInt64 slot, final Bytes32 attestationHashTreeRoot) { + final UInt64 slot, + final Bytes32 attestationHashTreeRoot, + final Optional committeeIndex) { if (isSyncActive()) { return NodeSyncingException.failedFuture(); } return SafeFuture.completedFuture( attestationPool - .createAggregateFor(attestationHashTreeRoot) + .createAggregateFor(attestationHashTreeRoot, committeeIndex) .filter(attestation -> attestation.getData().getSlot().equals(slot)) .map(ValidatableAttestation::getAttestation)); } @@ -493,6 +516,9 @@ public SafeFuture> createAggregate( @Override public SafeFuture> createSyncCommitteeContribution( final UInt64 slot, final int subcommitteeIndex, final Bytes32 beaconBlockRoot) { + if (isSyncActive()) { + return NodeSyncingException.failedFuture(); + } return SafeFuture.completedFuture( syncCommitteeMessagePool.createContribution(slot, beaconBlockRoot, subcommitteeIndex)); } @@ -532,13 +558,13 @@ private void processSyncCommitteeSubnetSubscriptions( final Collection subscriptions) { for (final SyncCommitteeSubnetSubscription subscription : subscriptions) { // untilEpoch is exclusive, so it will unsubscribe at the first slot of the specified index - final UInt64 untilEpoch = subscription.getUntilEpoch(); + final UInt64 untilEpoch = subscription.untilEpoch(); final UInt64 unsubscribeSlot = spec.computeStartSlotAtEpoch(untilEpoch); final SyncCommitteeUtil syncCommitteeUtil = spec.getSyncCommitteeUtilRequired(spec.computeStartSlotAtEpoch(untilEpoch)); - final IntSet syncCommitteeIndices = subscription.getSyncCommitteeIndices(); + final IntSet syncCommitteeIndices = subscription.syncCommitteeIndices(); performanceTracker.saveExpectedSyncCommitteeParticipant( - subscription.getValidatorIndex(), syncCommitteeIndices, untilEpoch.decrement()); + subscription.validatorIndex(), syncCommitteeIndices, untilEpoch.decrement()); syncCommitteeUtil .getSyncSubcommittees(syncCommitteeIndices) .forEach(index -> syncCommitteeSubscriptionManager.subscribe(index, unsubscribeSlot)); @@ -547,7 +573,7 @@ private void processSyncCommitteeSubnetSubscriptions( @Override public SafeFuture subscribeToPersistentSubnets( - Set subnetSubscriptions) { + final Set subnetSubscriptions) { return SafeFuture.fromRunnable( () -> attestationTopicSubscriber.subscribeToPersistentSubnets(subnetSubscriptions)); } @@ -634,7 +660,13 @@ public SafeFuture sendSignedBlock( maybeBlindedBlockContainer.getSlot()); return blockPublisher .sendSignedBlock( - maybeBlindedBlockContainer, broadcastValidationLevel, blockPublishingPerformance) + maybeBlindedBlockContainer, + // do only EQUIVOCATION validation when GOSSIP validation has been requested and the + // block has been locally created + broadcastValidationLevel == GOSSIP && isLocallyCreatedBlock(maybeBlindedBlockContainer) + ? EQUIVOCATION + : broadcastValidationLevel, + blockPublishingPerformance) .exceptionally( ex -> { final String reason = getRootCauseMessage(ex); @@ -840,6 +872,23 @@ private List getProposalSlotsForEpoch(final BeaconState state, fin return proposerSlots; } + private boolean isLocallyCreatedBlock(final SignedBlockContainer signedBlockContainer) { + final SafeFuture> localBlockProduction = + localBlockProductionBySlotCache.get(signedBlockContainer.getSlot()); + if (localBlockProduction == null || !localBlockProduction.isCompletedNormally()) { + return false; + } + return localBlockProduction + .getImmediately() + .map( + blockContainerAndMetaData -> + blockContainerAndMetaData + .blockContainer() + .getRoot() + .equals(signedBlockContainer.getRoot())) + .orElse(false); + } + @Override public SafeFuture>> getBeaconCommitteeSelectionProof( final List requests) { diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/duties/AttesterDutiesGenerator.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/duties/AttesterDutiesGenerator.java index 46502b517e6..c9cd594e4f1 100644 --- a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/duties/AttesterDutiesGenerator.java +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/duties/AttesterDutiesGenerator.java @@ -13,10 +13,10 @@ package tech.pegasys.teku.validator.coordinator.duties; +import it.unimi.dsi.fastutil.ints.Int2ObjectMap; import it.unimi.dsi.fastutil.ints.IntCollection; import java.util.ArrayList; import java.util.List; -import java.util.Map; import java.util.Optional; import org.apache.tuweni.bytes.Bytes32; import tech.pegasys.teku.ethereum.json.types.validator.AttesterDuties; @@ -30,7 +30,7 @@ public class AttesterDutiesGenerator { private final Spec spec; - public AttesterDutiesGenerator(Spec spec) { + public AttesterDutiesGenerator(final Spec spec) { this.spec = spec; } @@ -49,22 +49,22 @@ public AttesterDuties getAttesterDutiesFromIndicesAndState( private List createAttesterDuties( final BeaconState state, final UInt64 epoch, final IntCollection validatorIndices) { - final List> maybeAttesterDutyList = new ArrayList<>(); + final List attesterDutyList = new ArrayList<>(); final BeaconStateAccessors beaconStateAccessors = spec.atEpoch(epoch).beaconStateAccessors(); final UInt64 committeeCountPerSlot = beaconStateAccessors.getCommitteeCountPerSlot(state, epoch); - final Map validatorIndexToCommitteeAssignmentMap = + final Int2ObjectMap validatorIndexToCommitteeAssignmentMap = spec.getValidatorIndexToCommitteeAssignmentMap(state, epoch); - for (final Integer validatorIndex : validatorIndices) { + for (final int validatorIndex : validatorIndices) { final CommitteeAssignment committeeAssignment = validatorIndexToCommitteeAssignmentMap.get(validatorIndex); if (committeeAssignment != null) { - maybeAttesterDutyList.add( - attesterDutyFromCommitteeAssignment( - committeeAssignment, validatorIndex, committeeCountPerSlot, state)); + attesterDutyFromCommitteeAssignment( + committeeAssignment, validatorIndex, committeeCountPerSlot, state) + .ifPresent(attesterDutyList::add); } } - return maybeAttesterDutyList.stream().filter(Optional::isPresent).map(Optional::get).toList(); + return attesterDutyList; } private Optional attesterDutyFromCommitteeAssignment( @@ -78,10 +78,10 @@ private Optional attesterDutyFromCommitteeAssignment( new AttesterDuty( publicKey, validatorIndex, - committeeAssignment.getCommittee().size(), - committeeAssignment.getCommitteeIndex().intValue(), + committeeAssignment.committee().size(), + committeeAssignment.committeeIndex().intValue(), committeeCountPerSlot.intValue(), - committeeAssignment.getCommittee().indexOf(validatorIndex), - committeeAssignment.getSlot())); + committeeAssignment.committee().indexOf(validatorIndex), + committeeAssignment.slot())); } } diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/performance/AttestationPerformance.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/performance/AttestationPerformance.java index bb538a028f7..ccf4c689aca 100644 --- a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/performance/AttestationPerformance.java +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/performance/AttestationPerformance.java @@ -30,15 +30,15 @@ public class AttestationPerformance { final int correctHeadBlockCount; public AttestationPerformance( - UInt64 epoch, - int numberOfExpectedAttestations, - int numberOfProducedAttestations, - int numberOfIncludedAttestations, - int inclusionDistanceMax, - int inclusionDistanceMin, - double inclusionDistanceAverage, - int correctTargetCount, - int correctHeadBlockCount) { + final UInt64 epoch, + final int numberOfExpectedAttestations, + final int numberOfProducedAttestations, + final int numberOfIncludedAttestations, + final int inclusionDistanceMax, + final int inclusionDistanceMin, + final double inclusionDistanceAverage, + final int correctTargetCount, + final int correctHeadBlockCount) { this.epoch = epoch; this.numberOfExpectedAttestations = numberOfExpectedAttestations; this.numberOfProducedAttestations = numberOfProducedAttestations; @@ -50,12 +50,13 @@ public AttestationPerformance( this.correctHeadBlockCount = correctHeadBlockCount; } - public static AttestationPerformance empty(UInt64 epoch, int numberOfExpectedAttestations) { + public static AttestationPerformance empty( + final UInt64 epoch, final int numberOfExpectedAttestations) { return new AttestationPerformance(epoch, numberOfExpectedAttestations, 0, 0, 0, 0, 0, 0, 0); } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/performance/BlockPerformance.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/performance/BlockPerformance.java index dac19b9f5d6..b5bf8f4947f 100644 --- a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/performance/BlockPerformance.java +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/performance/BlockPerformance.java @@ -25,10 +25,10 @@ public class BlockPerformance { final int numberOfProducedBlocks; public BlockPerformance( - UInt64 epoch, - int numberOfExpectedBlocks, - int numberOfIncludedBlocks, - int numberOfProducedBlocks) { + final UInt64 epoch, + final int numberOfExpectedBlocks, + final int numberOfIncludedBlocks, + final int numberOfProducedBlocks) { this.epoch = epoch; this.numberOfExpectedBlocks = numberOfExpectedBlocks; this.numberOfIncludedBlocks = numberOfIncludedBlocks; @@ -36,7 +36,7 @@ public BlockPerformance( } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/performance/DefaultPerformanceTracker.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/performance/DefaultPerformanceTracker.java index 3ff741b8110..381229ffca5 100644 --- a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/performance/DefaultPerformanceTracker.java +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/performance/DefaultPerformanceTracker.java @@ -16,6 +16,7 @@ import static com.google.common.base.Preconditions.checkArgument; import com.google.common.annotations.VisibleForTesting; +import it.unimi.dsi.fastutil.ints.Int2IntMap; import it.unimi.dsi.fastutil.ints.IntArrayList; import it.unimi.dsi.fastutil.ints.IntList; import it.unimi.dsi.fastutil.ints.IntSet; @@ -42,7 +43,6 @@ import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.logging.StatusLogger; import tech.pegasys.teku.infrastructure.metrics.SettableGauge; -import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock; @@ -51,6 +51,7 @@ import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeMessage; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.statetransition.attestation.utils.AttestationBitsAggregator; import tech.pegasys.teku.storage.client.CombinedChainDataClient; import tech.pegasys.teku.validator.api.ValidatorPerformanceTrackingMode; import tech.pegasys.teku.validator.coordinator.ActiveValidatorTracker; @@ -169,6 +170,9 @@ private SafeFuture reportBlockPerformance(final UInt64 currentEpoch) { validatorPerformanceMetrics.updateBlockPerformanceMetrics(blockPerformance); } } + }) + .alwaysRun( + () -> { producedBlocksByEpoch.headMap(blockProductionEpoch, true).clear(); blockProductionAttemptsByEpoch.headMap(blockProductionEpoch, true).clear(); }); @@ -208,8 +212,8 @@ private SafeFuture reportAttestationPerformance(final UInt64 currentEpoch) { validatorPerformanceMetrics.updateAttestationPerformanceMetrics( attestationPerformance); } - producedAttestationsByEpoch.headMap(analyzedEpoch, true).clear(); - }); + }) + .alwaysRun(() -> producedAttestationsByEpoch.headMap(analyzedEpoch, true).clear()); } private SafeFuture getBlockPerformanceForEpoch(final UInt64 currentEpoch) { @@ -250,6 +254,11 @@ private SafeFuture getBlockPerformanceForEpoch(final UInt64 cu private boolean isInHistoricBlockRoots( final BeaconState state, final SlotAndBlockRoot producedBlock) { + LOG.debug( + "Checking if block {} is in historic block roots {} of the state {}", + producedBlock, + state.getBlockRoots(), + state.hashTreeRoot()); return producedBlock.getSlot().isLessThan(state.getSlot()) && spec.getBlockRootAtSlot(state, producedBlock.getSlot()) .equals(producedBlock.getBlockRoot()); @@ -295,16 +304,23 @@ private AttestationPerformance calculateAttestationPerformance( // Pre-process attestations included on chain to group them by // data hash to inclusion slot to aggregation bitlist - final Map> slotAndBitlistsByAttestationDataHash = - new HashMap<>(); + final Map> + slotAndBitlistsByAttestationDataHash = new HashMap<>(); for (Map.Entry> entry : attestationsIncludedOnChain.entrySet()) { + final Optional committeesSize = + Optional.of(spec.getBeaconCommitteesSize(state, entry.getKey())); for (Attestation attestation : entry.getValue()) { final Bytes32 attestationDataHash = attestation.getData().hashTreeRoot(); - final NavigableMap slotToBitlists = + final NavigableMap slotToBitlists = slotAndBitlistsByAttestationDataHash.computeIfAbsent( attestationDataHash, __ -> new TreeMap<>()); slotToBitlists.merge( - entry.getKey(), attestation.getAggregationBits(), SszBitlist::nullableOr); + entry.getKey(), + AttestationBitsAggregator.of(attestation, committeesSize), + (firstBitsAggregator, secondBitsAggregator) -> { + firstBitsAggregator.or(secondBitsAggregator); + return firstBitsAggregator; + }); } } @@ -314,10 +330,10 @@ private AttestationPerformance calculateAttestationPerformance( if (!slotAndBitlistsByAttestationDataHash.containsKey(sentAttestationDataHash)) { continue; } - final NavigableMap slotAndBitlists = + final NavigableMap slotAndBitlists = slotAndBitlistsByAttestationDataHash.get(sentAttestationDataHash); for (UInt64 slot : slotAndBitlists.keySet()) { - if (slotAndBitlists.get(slot).isSuperSetOf(sentAttestation.getAggregationBits())) { + if (slotAndBitlists.get(slot).isSuperSetOf(sentAttestation)) { inclusionDistances.add(slot.minus(sentAttestationSlot).intValue()); break; } @@ -415,15 +431,15 @@ public void saveProducedAttestation(final Attestation attestation) { } @Override - public void saveProducedBlock(final SignedBeaconBlock block) { - final UInt64 epoch = spec.computeEpochAtSlot(block.getSlot()); + public void saveProducedBlock(final SlotAndBlockRoot slotAndBlockRoot) { + final UInt64 epoch = spec.computeEpochAtSlot(slotAndBlockRoot.getSlot()); final Set blocksInEpoch = producedBlocksByEpoch.computeIfAbsent(epoch, __ -> concurrentSet()); - blocksInEpoch.add(block.getSlotAndBlockRoot()); + blocksInEpoch.add(slotAndBlockRoot); } @Override - public void reportBlockProductionAttempt(UInt64 epoch) { + public void reportBlockProductionAttempt(final UInt64 epoch) { final AtomicInteger numberOfBlockProductionAttempts = blockProductionAttemptsByEpoch.computeIfAbsent(epoch, __ -> new AtomicInteger(0)); numberOfBlockProductionAttempts.incrementAndGet(); diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/performance/NoOpPerformanceTracker.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/performance/NoOpPerformanceTracker.java index 69e28006dcc..988b07a8f62 100644 --- a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/performance/NoOpPerformanceTracker.java +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/performance/NoOpPerformanceTracker.java @@ -15,7 +15,7 @@ import it.unimi.dsi.fastutil.ints.IntSet; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; +import tech.pegasys.teku.spec.datastructures.blocks.SlotAndBlockRoot; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeMessage; @@ -28,7 +28,7 @@ public void start(final UInt64 nodeStartSlot) {} public void saveProducedAttestation(final Attestation attestation) {} @Override - public void saveProducedBlock(final SignedBeaconBlock block) {} + public void saveProducedBlock(final SlotAndBlockRoot slotAndBlockRoot) {} @Override public void reportBlockProductionAttempt(final UInt64 epoch) {} diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/performance/PerformanceTracker.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/performance/PerformanceTracker.java index 955d3d45216..58aa7785781 100644 --- a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/performance/PerformanceTracker.java +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/performance/PerformanceTracker.java @@ -16,7 +16,7 @@ import it.unimi.dsi.fastutil.ints.IntSet; import tech.pegasys.teku.ethereum.events.SlotEventsChannel; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; +import tech.pegasys.teku.spec.datastructures.blocks.SlotAndBlockRoot; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeMessage; @@ -26,7 +26,7 @@ public interface PerformanceTracker extends SlotEventsChannel { void saveProducedAttestation(Attestation attestation); - void saveProducedBlock(SignedBeaconBlock block); + void saveProducedBlock(SlotAndBlockRoot slotAndBlockRoot); void reportBlockProductionAttempt(UInt64 epoch); diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/publisher/AbstractBlockPublisher.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/publisher/AbstractBlockPublisher.java index ee70f300bb4..bb59dac5566 100644 --- a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/publisher/AbstractBlockPublisher.java +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/publisher/AbstractBlockPublisher.java @@ -16,11 +16,15 @@ import static tech.pegasys.teku.infrastructure.logging.ValidatorLogger.VALIDATOR_LOGGER; import static tech.pegasys.teku.spec.logic.common.statetransition.results.BlockImportResult.FailureReason.FAILED_BROADCAST_VALIDATION; +import com.google.common.base.Suppliers; import java.util.List; +import java.util.function.Supplier; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import tech.pegasys.teku.ethereum.performance.trackers.BlockPublishingPerformance; +import tech.pegasys.teku.infrastructure.async.AsyncRunner; import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.networking.eth2.gossip.BlockGossipChannel; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockContainer; @@ -32,25 +36,32 @@ import tech.pegasys.teku.validator.api.SendSignedBlockResult; import tech.pegasys.teku.validator.coordinator.BlockFactory; import tech.pegasys.teku.validator.coordinator.DutyMetrics; -import tech.pegasys.teku.validator.coordinator.performance.PerformanceTracker; public abstract class AbstractBlockPublisher implements BlockPublisher { private static final Logger LOG = LogManager.getLogger(); + private final AsyncRunner asyncRunner; + + private final boolean gossipBlobsAfterBlock; + protected final BlockFactory blockFactory; protected final BlockImportChannel blockImportChannel; - protected final PerformanceTracker performanceTracker; + protected final BlockGossipChannel blockGossipChannel; protected final DutyMetrics dutyMetrics; public AbstractBlockPublisher( + final AsyncRunner asyncRunner, final BlockFactory blockFactory, + final BlockGossipChannel blockGossipChannel, final BlockImportChannel blockImportChannel, - final PerformanceTracker performanceTracker, - final DutyMetrics dutyMetrics) { + final DutyMetrics dutyMetrics, + final boolean gossipBlobsAfterBlock) { + this.asyncRunner = asyncRunner; this.blockFactory = blockFactory; this.blockImportChannel = blockImportChannel; - this.performanceTracker = performanceTracker; + this.blockGossipChannel = blockGossipChannel; this.dutyMetrics = dutyMetrics; + this.gossipBlobsAfterBlock = gossipBlobsAfterBlock; } @Override @@ -60,32 +71,32 @@ public SafeFuture sendSignedBlock( final BlockPublishingPerformance blockPublishingPerformance) { return blockFactory .unblindSignedBlockIfBlinded(blockContainer.getSignedBlock(), blockPublishingPerformance) - .thenPeek(performanceTracker::saveProducedBlock) .thenCompose( - signedBlock -> { - // creating blob sidecars after unblinding the block to ensure in the blinded flow we - // will have the cached builder payload - final List blobSidecars = - blockFactory.createBlobSidecars(blockContainer, blockPublishingPerformance); - return gossipAndImportUnblindedSignedBlockAndBlobSidecars( - signedBlock, blobSidecars, broadcastValidationLevel, blockPublishingPerformance); - }) - .thenCompose(result -> calculateResult(blockContainer, result)); + // creating blob sidecars after unblinding the block to ensure in the blinded flow we + // will have the cached builder payload + signedBlock -> + gossipAndImportUnblindedSignedBlockAndBlobSidecars( + signedBlock, + Suppliers.memoize(() -> blockFactory.createBlobSidecars(blockContainer)), + broadcastValidationLevel, + blockPublishingPerformance)) + .thenCompose(result -> calculateResult(blockContainer, result, blockPublishingPerformance)); } private SafeFuture gossipAndImportUnblindedSignedBlockAndBlobSidecars( final SignedBeaconBlock block, - final List blobSidecars, + final Supplier> blobSidecars, final BroadcastValidationLevel broadcastValidationLevel, final BlockPublishingPerformance blockPublishingPerformance) { if (broadcastValidationLevel == BroadcastValidationLevel.NOT_REQUIRED) { // when broadcast validation is disabled, we can publish the block (and blob sidecars) // immediately and then import - publishBlockAndBlobSidecars(block, blobSidecars, blockPublishingPerformance); - return importBlockAndBlobSidecars( - block, blobSidecars, broadcastValidationLevel, blockPublishingPerformance); + publishBlockAndBlobs(block, blobSidecars, blockPublishingPerformance); + + importBlobSidecars(blobSidecars.get(), blockPublishingPerformance); + return importBlock(block, broadcastValidationLevel, blockPublishingPerformance); } // when broadcast validation is enabled, we need to wait for the validation to complete before @@ -93,15 +104,21 @@ public SafeFuture sendSignedBlock( final SafeFuture blockImportAndBroadcastValidationResults = - importBlockAndBlobSidecars( - block, blobSidecars, broadcastValidationLevel, blockPublishingPerformance); + importBlock(block, broadcastValidationLevel, blockPublishingPerformance); + + // prepare and import blob sidecars in parallel with block import + asyncRunner + .runAsync(() -> importBlobSidecars(blobSidecars.get(), blockPublishingPerformance)) + .finish( + error -> + LOG.error("Failed to import blob sidecars for slot {}", block.getSlot(), error)); blockImportAndBroadcastValidationResults .thenCompose(BlockImportAndBroadcastValidationResults::broadcastValidationResult) .thenAccept( broadcastValidationResult -> { if (broadcastValidationResult == BroadcastValidationResult.SUCCESS) { - publishBlockAndBlobSidecars(block, blobSidecars, blockPublishingPerformance); + publishBlockAndBlobs(block, blobSidecars, blockPublishingPerformance); LOG.debug("Block (and blob sidecars) publishing initiated"); } else { LOG.warn( @@ -120,20 +137,40 @@ public SafeFuture sendSignedBlock( return blockImportAndBroadcastValidationResults; } - abstract SafeFuture importBlockAndBlobSidecars( + private void publishBlockAndBlobs( + final SignedBeaconBlock block, + final Supplier> blobSidecars, + final BlockPublishingPerformance blockPublishingPerformance) { + + if (gossipBlobsAfterBlock) { + publishBlock(block, blockPublishingPerformance) + .always(() -> publishBlobSidecars(blobSidecars.get(), block, blockPublishingPerformance)); + } else { + publishBlock(block, blockPublishingPerformance).ifExceptionGetsHereRaiseABug(); + publishBlobSidecars(blobSidecars.get(), block, blockPublishingPerformance); + } + } + + abstract SafeFuture importBlock( SignedBeaconBlock block, - List blobSidecars, BroadcastValidationLevel broadcastValidationLevel, BlockPublishingPerformance blockPublishingPerformance); - abstract void publishBlockAndBlobSidecars( - SignedBeaconBlock block, + abstract void importBlobSidecars( + List blobSidecars, BlockPublishingPerformance blockPublishingPerformance); + + abstract SafeFuture publishBlock( + SignedBeaconBlock block, BlockPublishingPerformance blockPublishingPerformance); + + abstract void publishBlobSidecars( List blobSidecars, + SignedBeaconBlock block, BlockPublishingPerformance blockPublishingPerformance); private SafeFuture calculateResult( final SignedBlockContainer maybeBlindedBlockContainer, - final BlockImportAndBroadcastValidationResults blockImportAndBroadcastValidationResults) { + final BlockImportAndBroadcastValidationResults blockImportAndBroadcastValidationResults, + final BlockPublishingPerformance blockPublishingPerformance) { // broadcast validation can fail earlier than block import. // The assumption is that in that block import will fail but not as fast @@ -155,6 +192,7 @@ private SafeFuture calculateResult( .blockImportResult() .thenApply( importResult -> { + blockPublishingPerformance.blockImportCompleted(); if (importResult.isSuccessful()) { LOG.trace( "Successfully imported proposed block: {}", diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/publisher/BlockPublisherDeneb.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/publisher/BlockPublisherDeneb.java index 2eee9a561d9..c7f90daeb98 100644 --- a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/publisher/BlockPublisherDeneb.java +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/publisher/BlockPublisherDeneb.java @@ -15,59 +15,59 @@ import java.util.List; import tech.pegasys.teku.ethereum.performance.trackers.BlockPublishingPerformance; -import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.async.AsyncRunner; import tech.pegasys.teku.networking.eth2.gossip.BlobSidecarGossipChannel; import tech.pegasys.teku.networking.eth2.gossip.BlockGossipChannel; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; -import tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel; +import tech.pegasys.teku.statetransition.blobs.BlobSidecarManager.RemoteOrigin; import tech.pegasys.teku.statetransition.blobs.BlockBlobSidecarsTrackersPool; import tech.pegasys.teku.statetransition.block.BlockImportChannel; -import tech.pegasys.teku.statetransition.block.BlockImportChannel.BlockImportAndBroadcastValidationResults; import tech.pegasys.teku.validator.coordinator.BlockFactory; import tech.pegasys.teku.validator.coordinator.DutyMetrics; -import tech.pegasys.teku.validator.coordinator.performance.PerformanceTracker; -public class BlockPublisherDeneb extends AbstractBlockPublisher { +public class BlockPublisherDeneb extends BlockPublisherPhase0 { - private final BlockBlobSidecarsTrackersPool blockBlobSidecarsTrackersPool; - private final BlockGossipChannel blockGossipChannel; - private final BlobSidecarGossipChannel blobSidecarGossipChannel; + protected final BlockBlobSidecarsTrackersPool blockBlobSidecarsTrackersPool; + protected final BlobSidecarGossipChannel blobSidecarGossipChannel; public BlockPublisherDeneb( + final AsyncRunner asyncRunner, final BlockFactory blockFactory, final BlockImportChannel blockImportChannel, final BlockGossipChannel blockGossipChannel, final BlockBlobSidecarsTrackersPool blockBlobSidecarsTrackersPool, final BlobSidecarGossipChannel blobSidecarGossipChannel, - final PerformanceTracker performanceTracker, - final DutyMetrics dutyMetrics) { - super(blockFactory, blockImportChannel, performanceTracker, dutyMetrics); + final DutyMetrics dutyMetrics, + final boolean gossipBlobsAfterBlock) { + super( + asyncRunner, + blockFactory, + blockGossipChannel, + blockImportChannel, + dutyMetrics, + gossipBlobsAfterBlock); this.blockBlobSidecarsTrackersPool = blockBlobSidecarsTrackersPool; - this.blockGossipChannel = blockGossipChannel; this.blobSidecarGossipChannel = blobSidecarGossipChannel; } @Override - SafeFuture importBlockAndBlobSidecars( - final SignedBeaconBlock block, + void importBlobSidecars( final List blobSidecars, - final BroadcastValidationLevel broadcastValidationLevel, final BlockPublishingPerformance blockPublishingPerformance) { - // provide blobs for the block before importing it - blockBlobSidecarsTrackersPool.onCompletedBlockAndBlobSidecars(block, blobSidecars); - return blockImportChannel - .importBlock(block, broadcastValidationLevel) - .thenPeek(__ -> blockPublishingPerformance.blockImportCompleted()); + blobSidecars.forEach( + blobSidecar -> + blockBlobSidecarsTrackersPool.onNewBlobSidecar( + blobSidecar, RemoteOrigin.LOCAL_PROPOSAL)); + blockPublishingPerformance.blobSidecarsImportCompleted(); } @Override - void publishBlockAndBlobSidecars( - final SignedBeaconBlock block, + void publishBlobSidecars( final List blobSidecars, - BlockPublishingPerformance blockPublishingPerformance) { - blockGossipChannel.publishBlock(block); - blobSidecarGossipChannel.publishBlobSidecars(blobSidecars); - blockPublishingPerformance.blockAndBlobSidecarsPublishingInitiated(); + final SignedBeaconBlock block, + final BlockPublishingPerformance blockPublishingPerformance) { + blockPublishingPerformance.blobSidecarsPublishingInitiated(); + blobSidecarGossipChannel.publishBlobSidecars(blobSidecars).ifExceptionGetsHereRaiseABug(); } } diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/publisher/BlockPublisherEip7594.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/publisher/BlockPublisherEip7594.java index 3f17d5507e2..a350901d14b 100644 --- a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/publisher/BlockPublisherEip7594.java +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/publisher/BlockPublisherEip7594.java @@ -15,59 +15,54 @@ import java.util.List; import tech.pegasys.teku.ethereum.performance.trackers.BlockPublishingPerformance; -import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.async.AsyncRunner; import tech.pegasys.teku.networking.eth2.gossip.BlockGossipChannel; import tech.pegasys.teku.networking.eth2.gossip.DataColumnSidecarGossipChannel; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.Blob; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSidecar; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; -import tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel; import tech.pegasys.teku.statetransition.block.BlockImportChannel; -import tech.pegasys.teku.statetransition.block.BlockImportChannel.BlockImportAndBroadcastValidationResults; import tech.pegasys.teku.validator.coordinator.BlockFactory; import tech.pegasys.teku.validator.coordinator.DutyMetrics; -import tech.pegasys.teku.validator.coordinator.performance.PerformanceTracker; -public class BlockPublisherEip7594 extends AbstractBlockPublisher { +public class BlockPublisherEip7594 extends BlockPublisherPhase0 { - private final BlockGossipChannel blockGossipChannel; private final DataColumnSidecarGossipChannel dataColumnSidecarGossipChannel; public BlockPublisherEip7594( + final AsyncRunner asyncRunner, final BlockFactory blockFactory, final BlockImportChannel blockImportChannel, final BlockGossipChannel blockGossipChannel, final DataColumnSidecarGossipChannel dataColumnSidecarGossipChannel, - final PerformanceTracker performanceTracker, - final DutyMetrics dutyMetrics) { - super(blockFactory, blockImportChannel, performanceTracker, dutyMetrics); - this.blockGossipChannel = blockGossipChannel; + final DutyMetrics dutyMetrics, + final boolean gossipBlobsAfterBlock) { + super( + asyncRunner, + blockFactory, + blockGossipChannel, + blockImportChannel, + dutyMetrics, + gossipBlobsAfterBlock); this.dataColumnSidecarGossipChannel = dataColumnSidecarGossipChannel; } @Override - SafeFuture importBlockAndBlobSidecars( - final SignedBeaconBlock block, + void importBlobSidecars( final List blobSidecars, - final BroadcastValidationLevel broadcastValidationLevel, final BlockPublishingPerformance blockPublishingPerformance) { // TODO: DataColumnSidecars pool fill up - return blockImportChannel - .importBlock(block, broadcastValidationLevel) - .thenPeek(__ -> blockPublishingPerformance.blockImportCompleted()); } @Override - void publishBlockAndBlobSidecars( - final SignedBeaconBlock block, + void publishBlobSidecars( final List blobSidecars, - BlockPublishingPerformance blockPublishingPerformance) { - blockGossipChannel.publishBlock(block); + final SignedBeaconBlock block, + final BlockPublishingPerformance blockPublishingPerformance) { List blobs = blobSidecars.stream().map(BlobSidecar::getBlob).toList(); final List dataColumnSidecars = blockFactory.createDataColumnSidecars(block, blobs); dataColumnSidecarGossipChannel.publishDataColumnSidecars(dataColumnSidecars); - blockPublishingPerformance.blockAndBlobSidecarsPublishingInitiated(); } } diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/publisher/BlockPublisherPhase0.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/publisher/BlockPublisherPhase0.java index 21ca2b370b1..9823e374928 100644 --- a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/publisher/BlockPublisherPhase0.java +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/publisher/BlockPublisherPhase0.java @@ -15,6 +15,7 @@ import java.util.List; import tech.pegasys.teku.ethereum.performance.trackers.BlockPublishingPerformance; +import tech.pegasys.teku.infrastructure.async.AsyncRunner; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.networking.eth2.gossip.BlockGossipChannel; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; @@ -24,38 +25,52 @@ import tech.pegasys.teku.statetransition.block.BlockImportChannel.BlockImportAndBroadcastValidationResults; import tech.pegasys.teku.validator.coordinator.BlockFactory; import tech.pegasys.teku.validator.coordinator.DutyMetrics; -import tech.pegasys.teku.validator.coordinator.performance.PerformanceTracker; public class BlockPublisherPhase0 extends AbstractBlockPublisher { - private final BlockGossipChannel blockGossipChannel; public BlockPublisherPhase0( + final AsyncRunner asyncRunner, final BlockFactory blockFactory, final BlockGossipChannel blockGossipChannel, final BlockImportChannel blockImportChannel, - final PerformanceTracker performanceTracker, - final DutyMetrics dutyMetrics) { - super(blockFactory, blockImportChannel, performanceTracker, dutyMetrics); - this.blockGossipChannel = blockGossipChannel; + final DutyMetrics dutyMetrics, + final boolean gossipBlobsAfterBlock) { + super( + asyncRunner, + blockFactory, + blockGossipChannel, + blockImportChannel, + dutyMetrics, + gossipBlobsAfterBlock); } @Override - SafeFuture importBlockAndBlobSidecars( + SafeFuture importBlock( final SignedBeaconBlock block, - final List blobSidecars, final BroadcastValidationLevel broadcastValidationLevel, final BlockPublishingPerformance blockPublishingPerformance) { - return blockImportChannel - .importBlock(block, broadcastValidationLevel) - .thenPeek(__ -> blockPublishingPerformance.blockImportCompleted()); + return blockImportChannel.importBlock(block, broadcastValidationLevel); } @Override - void publishBlockAndBlobSidecars( - final SignedBeaconBlock block, + void importBlobSidecars( final List blobSidecars, final BlockPublishingPerformance blockPublishingPerformance) { - blockGossipChannel.publishBlock(block); + // No-op for phase 0 + } + + @Override + SafeFuture publishBlock( + final SignedBeaconBlock block, final BlockPublishingPerformance blockPublishingPerformance) { blockPublishingPerformance.blockPublishingInitiated(); + return blockGossipChannel.publishBlock(block); + } + + @Override + void publishBlobSidecars( + final List blobSidecars, + final SignedBeaconBlock block, + final BlockPublishingPerformance blockPublishingPerformance) { + // No-op for phase 0 } } diff --git a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/publisher/MilestoneBasedBlockPublisher.java b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/publisher/MilestoneBasedBlockPublisher.java index b8fcbcb0531..fe57a43592c 100644 --- a/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/publisher/MilestoneBasedBlockPublisher.java +++ b/beacon/validator/src/main/java/tech/pegasys/teku/validator/coordinator/publisher/MilestoneBasedBlockPublisher.java @@ -14,10 +14,11 @@ package tech.pegasys.teku.validator.coordinator.publisher; import com.google.common.base.Suppliers; -import java.util.HashMap; +import java.util.EnumMap; import java.util.Map; import java.util.function.Supplier; import tech.pegasys.teku.ethereum.performance.trackers.BlockPublishingPerformance; +import tech.pegasys.teku.infrastructure.async.AsyncRunner; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.networking.eth2.gossip.BlobSidecarGossipChannel; import tech.pegasys.teku.networking.eth2.gossip.BlockGossipChannel; @@ -31,14 +32,15 @@ import tech.pegasys.teku.validator.api.SendSignedBlockResult; import tech.pegasys.teku.validator.coordinator.BlockFactory; import tech.pegasys.teku.validator.coordinator.DutyMetrics; -import tech.pegasys.teku.validator.coordinator.performance.PerformanceTracker; public class MilestoneBasedBlockPublisher implements BlockPublisher { private final Spec spec; - private final Map registeredPublishers = new HashMap<>(); + private final Map registeredPublishers = + new EnumMap<>(SpecMilestone.class); public MilestoneBasedBlockPublisher( + final AsyncRunner asyncRunner, final Spec spec, final BlockFactory blockFactory, final BlockImportChannel blockImportChannel, @@ -46,42 +48,49 @@ public MilestoneBasedBlockPublisher( final BlockBlobSidecarsTrackersPool blockBlobSidecarsTrackersPool, final BlobSidecarGossipChannel blobSidecarGossipChannel, final DataColumnSidecarGossipChannel dataColumnSidecarGossipChannel, - final PerformanceTracker performanceTracker, - final DutyMetrics dutyMetrics) { + final DutyMetrics dutyMetrics, + final boolean gossipBlobsAfterBlock) { this.spec = spec; final BlockPublisherPhase0 blockPublisherPhase0 = new BlockPublisherPhase0( - blockFactory, blockGossipChannel, blockImportChannel, performanceTracker, dutyMetrics); + asyncRunner, + blockFactory, + blockGossipChannel, + blockImportChannel, + dutyMetrics, + gossipBlobsAfterBlock); // Not needed for all milestones final Supplier blockAndBlobSidecarsPublisherSupplier = Suppliers.memoize( () -> new BlockPublisherDeneb( + asyncRunner, blockFactory, blockImportChannel, blockGossipChannel, blockBlobSidecarsTrackersPool, blobSidecarGossipChannel, - performanceTracker, - dutyMetrics)); + dutyMetrics, + gossipBlobsAfterBlock)); final Supplier blockAndDataColumnSidecarsPublisherSupplier = Suppliers.memoize( () -> new BlockPublisherEip7594( + asyncRunner, blockFactory, blockImportChannel, blockGossipChannel, dataColumnSidecarGossipChannel, - performanceTracker, - dutyMetrics)); + dutyMetrics, + gossipBlobsAfterBlock)); // Populate forks publishers spec.getEnabledMilestones() .forEach( forkAndSpecMilestone -> { final SpecMilestone milestone = forkAndSpecMilestone.getSpecMilestone(); - if (milestone.equals(SpecMilestone.EIP7594)) { + if (milestone.equals(SpecMilestone.ELECTRA)) { registeredPublishers.put( milestone, blockAndDataColumnSidecarsPublisherSupplier.get()); } else if (milestone.equals(SpecMilestone.DENEB)) { @@ -96,7 +105,7 @@ public MilestoneBasedBlockPublisher( public SafeFuture sendSignedBlock( final SignedBlockContainer blockContainer, final BroadcastValidationLevel broadcastValidationLevel, - BlockPublishingPerformance blockPublishingPerformance) { + final BlockPublishingPerformance blockPublishingPerformance) { final SpecMilestone blockMilestone = spec.atSlot(blockContainer.getSlot()).getMilestone(); return registeredPublishers .get(blockMilestone) diff --git a/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/AbstractBlockFactoryTest.java b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/AbstractBlockFactoryTest.java index bdcd0f95592..a1c18b1f188 100644 --- a/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/AbstractBlockFactoryTest.java +++ b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/AbstractBlockFactoryTest.java @@ -33,6 +33,7 @@ import org.apache.tuweni.units.bigints.UInt256; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; +import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.bls.BLSSignatureVerifier; import tech.pegasys.teku.ethereum.performance.trackers.BlockProductionPerformance; @@ -53,12 +54,15 @@ import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.SyncAggregate; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.bellatrix.BeaconBlockBodyBellatrix; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.bellatrix.BlindedBeaconBlockBodyBellatrix; +import tech.pegasys.teku.spec.datastructures.builder.BuilderBid; import tech.pegasys.teku.spec.datastructures.builder.BuilderPayload; import tech.pegasys.teku.spec.datastructures.execution.BlobsBundle; +import tech.pegasys.teku.spec.datastructures.execution.BuilderBidOrFallbackData; +import tech.pegasys.teku.spec.datastructures.execution.BuilderPayloadOrFallbackData; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadResult; -import tech.pegasys.teku.spec.datastructures.execution.HeaderWithFallbackData; +import tech.pegasys.teku.spec.datastructures.execution.GetPayloadResponse; import tech.pegasys.teku.spec.datastructures.metadata.BlockContainerAndMetaData; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; @@ -120,7 +124,7 @@ public abstract class AbstractBlockFactoryTest { protected ExecutionPayloadResult cachedExecutionPayloadResult = null; protected GraffitiBuilder graffitiBuilder = - new GraffitiBuilder(ClientGraffitiAppendFormat.DISABLED, Optional.empty()); + new GraffitiBuilder(ClientGraffitiAppendFormat.DISABLED); @BeforeAll public static void initSession() { @@ -192,12 +196,17 @@ protected BlockContainerAndMetaData assertBlockCreated( when(voluntaryExitPool.getItemsForBlock(any(), any(), any())).thenReturn(voluntaryExits); when(blsToExecutionChangePool.getItemsForBlock(any())).thenReturn(blsToExecutionChanges); when(eth1DataCache.getEth1Vote(any())).thenReturn(ETH1_DATA); - when(forkChoiceNotifier.getPayloadId(any(), any())) - .thenReturn( - SafeFuture.completedFuture( - Optional.of(dataStructureUtil.randomPayloadExecutionContext(false)))); - - setupExecutionLayerBlockAndBlobsProduction(); + if (blinded) { + when(forkChoiceNotifier.getPayloadId(any(), any())) + .thenReturn( + SafeFuture.completedFuture( + Optional.of(dataStructureUtil.randomPayloadExecutionContext(false, true)))); + } else { + when(forkChoiceNotifier.getPayloadId(any(), any())) + .thenReturn( + SafeFuture.completedFuture( + Optional.of(dataStructureUtil.randomPayloadExecutionContext(false)))); + } final BLSSignature randaoReveal = dataStructureUtil.randomSignature(); final Bytes32 bestBlockRoot = recentChainData.getBestBlockRoot().orElseThrow(); @@ -209,7 +218,6 @@ protected BlockContainerAndMetaData assertBlockCreated( when(syncCommitteeContributionPool.createSyncAggregateForBlock(newSlot, bestBlockRoot)) .thenAnswer(invocation -> createEmptySyncAggregate(spec)); - executionPayloadBuilder.accept(blockSlotState); final UInt256 blockExecutionValue; final UInt64 blockProposerRewards; @@ -217,16 +225,18 @@ protected BlockContainerAndMetaData assertBlockCreated( if (milestone.isGreaterThanOrEqualTo(SpecMilestone.BELLATRIX)) { blockExecutionValue = dataStructureUtil.randomUInt256(); blockProposerRewards = dataStructureUtil.randomUInt64(); - - // inject values into slot caches + // increase block proposer rewards to test the consensus block value final SlotCaches slotCaches = BeaconStateCache.getSlotCaches(blockSlotState); - slotCaches.setBlockExecutionValue(blockExecutionValue); slotCaches.increaseBlockProposerRewards(blockProposerRewards); } else { blockExecutionValue = UInt256.ZERO; blockProposerRewards = UInt64.ZERO; } + setupExecutionLayerBlockAndBlobsProduction(spec, blockExecutionValue); + + executionPayloadBuilder.accept(blockSlotState); + final BlockContainerAndMetaData blockContainerAndMetaData = safeJoin( blockFactory.createUnsignedBlock( @@ -234,7 +244,6 @@ protected BlockContainerAndMetaData assertBlockCreated( newSlot, randaoReveal, Optional.empty(), - Optional.of(blinded), Optional.empty(), BlockProductionPerformance.NOOP)); @@ -291,7 +300,8 @@ protected SignedBeaconBlock assertBlockUnblinded( // no need to prepare blobs bundle when only testing block unblinding when(executionLayer.getUnblindedPayload(blindedBlock, BlockPublishingPerformance.NOOP)) - .thenReturn(SafeFuture.completedFuture(executionPayload)); + .thenReturn( + SafeFuture.completedFuture(BuilderPayloadOrFallbackData.create(executionPayload))); final SignedBeaconBlock unblindedBlock = blockFactory @@ -365,10 +375,9 @@ protected BlockAndBlobSidecars createBlockAndBlobSidecars( // simulate caching of the builder payload when(executionLayer.getCachedUnblindedPayload(signedBlockContainer.getSlot())) - .thenReturn(builderPayload); + .thenReturn(builderPayload.map(BuilderPayloadOrFallbackData::create)); - final List blobSidecars = - blockFactory.createBlobSidecars(signedBlockContainer, BlockPublishingPerformance.NOOP); + final List blobSidecars = blockFactory.createBlobSidecars(signedBlockContainer); return new BlockAndBlobSidecars(signedBlockContainer, blobSidecars); } @@ -446,63 +455,42 @@ protected BuilderPayload prepareBuilderPayload(final Spec spec, final int blobsC return builderPayload; } - private void setupExecutionLayerBlockAndBlobsProduction() { - // pre Deneb + private void setupExecutionLayerBlockAndBlobsProduction(final Spec spec, final UInt256 value) { + // non-blinded when(executionLayer.initiateBlockProduction(any(), any(), eq(false), any(), any())) .thenAnswer( args -> { final ExecutionPayloadResult executionPayloadResult = - new ExecutionPayloadResult( + ExecutionPayloadResult.createForLocalFlow( args.getArgument(0), - Optional.of(SafeFuture.completedFuture(executionPayload)), - Optional.empty(), - Optional.empty(), - Optional.empty()); + SafeFuture.completedFuture( + blobsBundle + .map( + bundle -> + new GetPayloadResponse( + executionPayload, value, bundle, false)) + .orElseGet(() -> new GetPayloadResponse(executionPayload, value)))); cachedExecutionPayloadResult = executionPayloadResult; return executionPayloadResult; }); + // blinded when(executionLayer.initiateBlockProduction(any(), any(), eq(true), any(), any())) .thenAnswer( args -> { + final BuilderBid builderBid = + SchemaDefinitionsBellatrix.required(spec.getGenesisSchemaDefinitions()) + .getBuilderBidSchema() + .createBuilderBid( + builder -> { + builder.header(executionPayloadHeader); + builderBlobKzgCommitments.ifPresent(builder::blobKzgCommitments); + builder.value(value); + builder.publicKey(BLSPublicKey.empty()); + }); final ExecutionPayloadResult executionPayloadResult = - new ExecutionPayloadResult( - args.getArgument(0), - Optional.empty(), - Optional.empty(), - Optional.of( - SafeFuture.completedFuture( - HeaderWithFallbackData.create(executionPayloadHeader))), - Optional.empty()); - cachedExecutionPayloadResult = executionPayloadResult; - return executionPayloadResult; - }); - // post Deneb - when(executionLayer.initiateBlockAndBlobsProduction(any(), any(), eq(false), any(), any())) - .thenAnswer( - args -> { - final ExecutionPayloadResult executionPayloadResult = - new ExecutionPayloadResult( - args.getArgument(0), - Optional.of(SafeFuture.completedFuture(executionPayload)), - Optional.of(SafeFuture.completedFuture(blobsBundle)), - Optional.empty(), - Optional.empty()); - cachedExecutionPayloadResult = executionPayloadResult; - return executionPayloadResult; - }); - when(executionLayer.initiateBlockAndBlobsProduction(any(), any(), eq(true), any(), any())) - .thenAnswer( - args -> { - final ExecutionPayloadResult executionPayloadResult = - new ExecutionPayloadResult( + ExecutionPayloadResult.createForBuilderFlow( args.getArgument(0), - Optional.empty(), - Optional.empty(), - Optional.of( - SafeFuture.completedFuture( - HeaderWithFallbackData.create( - executionPayloadHeader, builderBlobKzgCommitments))), - Optional.empty()); + SafeFuture.completedFuture(BuilderBidOrFallbackData.create(builderBid))); cachedExecutionPayloadResult = executionPayloadResult; return executionPayloadResult; }); diff --git a/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/BlockOperationSelectorFactoryTest.java b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/BlockOperationSelectorFactoryTest.java index 8dddab4934d..cd18566109b 100644 --- a/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/BlockOperationSelectorFactoryTest.java +++ b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/BlockOperationSelectorFactoryTest.java @@ -33,6 +33,8 @@ import org.apache.tuweni.units.bigints.UInt256; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.ethereum.performance.trackers.BlockProductionPerformance; import tech.pegasys.teku.ethereum.performance.trackers.BlockPublishingPerformance; @@ -54,15 +56,19 @@ import tech.pegasys.teku.spec.datastructures.blocks.blockbody.common.AbstractSignedBeaconBlockUnblinder; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.SyncAggregate; import tech.pegasys.teku.spec.datastructures.blocks.versions.deneb.SignedBlockContents; +import tech.pegasys.teku.spec.datastructures.builder.BuilderBid; import tech.pegasys.teku.spec.datastructures.builder.BuilderPayload; import tech.pegasys.teku.spec.datastructures.execution.BlobsBundle; +import tech.pegasys.teku.spec.datastructures.execution.BuilderBidOrFallbackData; +import tech.pegasys.teku.spec.datastructures.execution.BuilderPayloadOrFallbackData; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadContext; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadResult; import tech.pegasys.teku.spec.datastructures.execution.FallbackData; import tech.pegasys.teku.spec.datastructures.execution.FallbackReason; -import tech.pegasys.teku.spec.datastructures.execution.HeaderWithFallbackData; +import tech.pegasys.teku.spec.datastructures.execution.GetPayloadResponse; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; import tech.pegasys.teku.spec.datastructures.operations.Deposit; @@ -94,7 +100,7 @@ import tech.pegasys.teku.validator.api.ClientGraffitiAppendFormat; class BlockOperationSelectorFactoryTest { - private final Spec spec = TestSpecFactory.createMinimalDeneb(); + private final Spec spec = TestSpecFactory.createMinimalElectra(); private final Spec specBellatrix = TestSpecFactory.createMinimalBellatrix(); private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); @@ -170,16 +176,11 @@ class BlockOperationSelectorFactoryTest { .getExecutionPayloadSchema() .getDefault(); - private final ExecutionPayloadHeader executionPayloadHeaderOfDefaultPayload = - SchemaDefinitionsBellatrix.required(specBellatrix.getGenesisSpec().getSchemaDefinitions()) - .getExecutionPayloadHeaderSchema() - .getHeaderOfDefaultPayload(); - private final CapturingBeaconBlockBodyBuilder bodyBuilder = - new CapturingBeaconBlockBodyBuilder(false); + new CapturingBeaconBlockBodyBuilder(false, false); private final GraffitiBuilder graffitiBuilder = - new GraffitiBuilder(ClientGraffitiAppendFormat.DISABLED, Optional.empty()); + new GraffitiBuilder(ClientGraffitiAppendFormat.DISABLED); private final BlockOperationSelectorFactory factory = new BlockOperationSelectorFactory( @@ -251,7 +252,6 @@ void shouldNotSelectOperationsWhenNoneAreAvailable() { dataStructureUtil.randomSignature(), Optional.empty(), Optional.empty(), - Optional.empty(), BlockProductionPerformance.NOOP) .apply(bodyBuilder)); @@ -298,7 +298,6 @@ void shouldIncludeValidOperations() { randaoReveal, Optional.of(defaultGraffiti), Optional.empty(), - Optional.empty(), BlockProductionPerformance.NOOP) .apply(bodyBuilder)); @@ -386,7 +385,6 @@ void shouldNotIncludeInvalidOperations() { randaoReveal, Optional.of(defaultGraffiti), Optional.empty(), - Optional.empty(), BlockProductionPerformance.NOOP) .apply(bodyBuilder)); @@ -417,35 +415,12 @@ void shouldIncludeDefaultExecutionPayload() { blockSlotState, dataStructureUtil.randomSignature(), Optional.empty(), - Optional.of(false), Optional.empty(), BlockProductionPerformance.NOOP) .apply(bodyBuilder)); assertThat(bodyBuilder.executionPayload).isEqualTo(defaultExecutionPayload); } - @Test - void shouldIncludeExecutionPayloadHeaderOfDefaultPayload() { - final UInt64 slot = UInt64.ONE; - final BeaconState blockSlotState = dataStructureUtil.randomBeaconStatePreMerge(slot); - when(forkChoiceNotifier.getPayloadId(any(), any())) - .thenReturn(SafeFuture.completedFuture(Optional.empty())); - - safeJoin( - factoryBellatrix - .createSelector( - parentRoot, - blockSlotState, - dataStructureUtil.randomSignature(), - Optional.empty(), - Optional.of(true), - Optional.empty(), - BlockProductionPerformance.NOOP) - .apply(bodyBuilder)); - assertThat(bodyBuilder.executionPayloadHeader) - .isEqualTo(executionPayloadHeaderOfDefaultPayload); - } - @Test void shouldIncludeNonDefaultExecutionPayload() { final UInt64 slot = UInt64.ONE; @@ -466,7 +441,6 @@ void shouldIncludeNonDefaultExecutionPayload() { blockSlotState, dataStructureUtil.randomSignature(), Optional.empty(), - Optional.of(false), Optional.empty(), BlockProductionPerformance.NOOP) .apply(bodyBuilder)); @@ -485,9 +459,16 @@ void shouldIncludeExecutionPayloadHeaderIfBlindedBlockRequested() { dataStructureUtil.randomExecutionPayloadHeader(); final UInt256 blockExecutionValue = dataStructureUtil.randomUInt256(); + final ExecutionPayloadContext executionPayloadContextWithValidatorRegistration = + dataStructureUtil.randomPayloadExecutionContext(false, true); + when(forkChoiceNotifier.getPayloadId(any(), any())) + .thenReturn( + SafeFuture.completedFuture( + Optional.of(executionPayloadContextWithValidatorRegistration))); + prepareBlockProductionWithPayloadHeader( randomExecutionPayloadHeader, - executionPayloadContext, + executionPayloadContextWithValidatorRegistration, blockSlotState, Optional.of(blockExecutionValue)); @@ -498,7 +479,6 @@ void shouldIncludeExecutionPayloadHeaderIfBlindedBlockRequested() { blockSlotState, dataStructureUtil.randomSignature(), Optional.empty(), - Optional.of(true), Optional.empty(), BlockProductionPerformance.NOOP) .apply(bodyBuilder)); @@ -529,7 +509,6 @@ void shouldIncludeExecutionPayloadIfUnblindedBlockRequested() { blockSlotState, dataStructureUtil.randomSignature(), Optional.empty(), - Optional.of(false), Optional.empty(), BlockProductionPerformance.NOOP) .apply(bodyBuilder)); @@ -561,7 +540,6 @@ void shouldIncludeExecutionPayloadIfRequestedBlindedIsEmpty() { dataStructureUtil.randomSignature(), Optional.empty(), Optional.empty(), - Optional.empty(), BlockProductionPerformance.NOOP) .apply(bodyBuilder)); @@ -583,10 +561,7 @@ void shouldIncludeExecutionPayloadIfRequestedBlindedIsEmptyAndBuilderFlowFallsBa final ExecutionPayload randomExecutionPayload = dataStructureUtil.randomExecutionPayload(); final UInt256 blockExecutionValue = dataStructureUtil.randomUInt256(); prepareBlindedBlockProductionWithFallBack( - randomExecutionPayload, - executionPayloadContext, - blockSlotState, - Optional.of(blockExecutionValue)); + randomExecutionPayload, executionPayloadContext, blockSlotState, blockExecutionValue); safeJoin( factory @@ -596,7 +571,6 @@ void shouldIncludeExecutionPayloadIfRequestedBlindedIsEmptyAndBuilderFlowFallsBa dataStructureUtil.randomSignature(), Optional.empty(), Optional.empty(), - Optional.empty(), BlockProductionPerformance.NOOP) .apply(bodyBuilder)); @@ -628,7 +602,7 @@ void shouldIncludeExecutionPayloadIfRequestedBlindedIsEmptyAndBuilderFlowFallsBa executionPayloadContext, blockSlotState, blobsBundle, - Optional.of(blockExecutionValue)); + blockExecutionValue); safeJoin( factory @@ -638,7 +612,6 @@ void shouldIncludeExecutionPayloadIfRequestedBlindedIsEmptyAndBuilderFlowFallsBa dataStructureUtil.randomSignature(), Optional.empty(), Optional.empty(), - Optional.empty(), BlockProductionPerformance.NOOP) .apply(bodyBuilder)); @@ -651,15 +624,25 @@ void shouldIncludeExecutionPayloadIfRequestedBlindedIsEmptyAndBuilderFlowFallsBa .hasSameElementsAs(blobsBundle.getCommitments()); } - @Test - void shouldUnblindSignedBlindedBeaconBlock() { + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void shouldUnblindSignedBlindedBeaconBlock(final boolean useLocalFallback) { final ExecutionPayload randomExecutionPayload = dataStructureUtil.randomExecutionPayload(); final SignedBeaconBlock blindedSignedBlock = dataStructureUtil.randomSignedBlindedBeaconBlock(); final CapturingBeaconBlockUnblinder blockUnblinder = new CapturingBeaconBlockUnblinder(spec.getGenesisSchemaDefinitions(), blindedSignedBlock); + final BuilderPayloadOrFallbackData builderPayloadOrFallbackData; + if (useLocalFallback) { + final FallbackData fallbackData = + new FallbackData( + new GetPayloadResponse(randomExecutionPayload), FallbackReason.BUILDER_ERROR); + builderPayloadOrFallbackData = BuilderPayloadOrFallbackData.create(fallbackData); + } else { + builderPayloadOrFallbackData = BuilderPayloadOrFallbackData.create(randomExecutionPayload); + } when(executionLayer.getUnblindedPayload(blindedSignedBlock, BlockPublishingPerformance.NOOP)) - .thenReturn(SafeFuture.completedFuture(randomExecutionPayload)); + .thenReturn(SafeFuture.completedFuture(builderPayloadOrFallbackData)); factory.createBlockUnblinderSelector(BlockPublishingPerformance.NOOP).accept(blockUnblinder); @@ -681,7 +664,7 @@ void shouldIncludeKzgCommitmentsInBlock() { executionPayloadContext, blockSlotState, blobsBundle, - Optional.of(blockExecutionValue)); + blockExecutionValue); final CapturingBeaconBlockBodyBuilder bodyBuilder = new CapturingBeaconBlockBodyBuilder(true); @@ -692,7 +675,6 @@ void shouldIncludeKzgCommitmentsInBlock() { blockSlotState, dataStructureUtil.randomSignature(), Optional.empty(), - Optional.of(false), Optional.empty(), BlockProductionPerformance.NOOP) .apply(bodyBuilder)); @@ -717,12 +699,19 @@ void shouldIncludeKzgCommitmentsInBlindedBlock() { final SszList blobKzgCommitments = dataStructureUtil.randomBlobKzgCommitments(); + final ExecutionPayloadContext executionPayloadContextWithValidatorRegistration = + dataStructureUtil.randomPayloadExecutionContext(false, true); + when(forkChoiceNotifier.getPayloadId(any(), any())) + .thenReturn( + SafeFuture.completedFuture( + Optional.of(executionPayloadContextWithValidatorRegistration))); + prepareBlindedBlockAndBlobsProduction( randomExecutionPayloadHeader, - executionPayloadContext, + executionPayloadContextWithValidatorRegistration, blockSlotState, blobKzgCommitments, - Optional.of(blockExecutionValue)); + blockExecutionValue); final CapturingBeaconBlockBodyBuilder bodyBuilder = new CapturingBeaconBlockBodyBuilder(true); @@ -733,7 +722,6 @@ void shouldIncludeKzgCommitmentsInBlindedBlock() { blockSlotState, dataStructureUtil.randomSignature(), Optional.empty(), - Optional.of(true), Optional.empty(), BlockProductionPerformance.NOOP) .apply(bodyBuilder)); @@ -754,8 +742,7 @@ void shouldGetBlobsBundleForLocallyProducedBlocks() { block.getSlot(), dataStructureUtil.randomExecutionPayload(), dataStructureUtil.randomPayloadExecutionContext(false), - expectedBlobsBundle, - Optional.empty()); + expectedBlobsBundle); final BlobsBundle blobsBundle = safeJoin(factory.createBlobsBundleSelector().apply(block)); @@ -771,11 +758,9 @@ void shouldGetBlobsBundleForLocallyProducedBlocksViaFallback() { // the BlobsBundle is stored in the header with fallback prepareCachedPayloadHeaderWithFallbackResult( block.getSlot(), - dataStructureUtil.randomExecutionPayloadHeader(), dataStructureUtil.randomExecutionPayload(), dataStructureUtil.randomPayloadExecutionContext(false), - expectedBlobsBundle, - Optional.empty()); + expectedBlobsBundle); final BlobsBundle blobsBundle = safeJoin(factory.createBlobsBundleSelector().apply(block)); @@ -790,9 +775,7 @@ void shouldCreateBlobSidecarsForBlockContents() { MiscHelpersDeneb.required(spec.atSlot(signedBlockContents.getSlot()).miscHelpers()); final List blobSidecars = - factory - .createBlobSidecarsSelector(BlockPublishingPerformance.NOOP) - .apply(signedBlockContents); + factory.createBlobSidecarsSelector().apply(signedBlockContents); final SszList expectedBlobs = signedBlockContents.getBlobs().orElseThrow(); final SszList expectedProofs = signedBlockContents.getKzgProofs().orElseThrow(); @@ -834,13 +817,9 @@ void shouldFailCreatingBlobSidecarsIfBuilderBlobsBundleCommitmentsRootIsNotConsi prepareCachedBuilderPayload( signedBlindedBeaconBlock.getSlot(), dataStructureUtil.randomExecutionPayload(), - Optional.of(blobsBundle)); + blobsBundle); - assertThatThrownBy( - () -> - factory - .createBlobSidecarsSelector(BlockPublishingPerformance.NOOP) - .apply(signedBlindedBeaconBlock)) + assertThatThrownBy(() -> factory.createBlobSidecarsSelector().apply(signedBlindedBeaconBlock)) .isInstanceOf(IllegalStateException.class) .hasMessage( "Commitments in the builder BlobsBundle don't match the commitments in the block"); @@ -859,16 +838,12 @@ void shouldFailCreatingBlobSidecarsIfBuilderBlobsBundleProofsIsNotConsistent() { prepareCachedBuilderPayload( signedBlindedBeaconBlock.getSlot(), dataStructureUtil.randomExecutionPayload(), - Optional.of(blobsBundle)); + blobsBundle); - assertThatThrownBy( - () -> - factory - .createBlobSidecarsSelector(BlockPublishingPerformance.NOOP) - .apply(signedBlindedBeaconBlock)) + assertThatThrownBy(() -> factory.createBlobSidecarsSelector().apply(signedBlindedBeaconBlock)) .isInstanceOf(IllegalStateException.class) .hasMessage( - "The number of blobs in BlobsBundle doesn't match the number of commitments in the block"); + "The number of blobs in the builder BlobsBundle doesn't match the number of commitments in the block"); } @Test @@ -884,39 +859,42 @@ void shouldFailCreatingBlobSidecarsIfBuilderBlobsBundleBlobsIsNotConsistent() { prepareCachedBuilderPayload( signedBlindedBeaconBlock.getSlot(), dataStructureUtil.randomExecutionPayload(), - Optional.of(blobsBundle)); + blobsBundle); - assertThatThrownBy( - () -> - factory - .createBlobSidecarsSelector(BlockPublishingPerformance.NOOP) - .apply(signedBlindedBeaconBlock)) + assertThatThrownBy(() -> factory.createBlobSidecarsSelector().apply(signedBlindedBeaconBlock)) .isInstanceOf(IllegalStateException.class) .hasMessage( - "The number of proofs in BlobsBundle doesn't match the number of commitments in the block"); + "The number of proofs in the builder BlobsBundle doesn't match the number of commitments in the block"); } - @Test - void shouldCreateBlobSidecarsForBlindedBlock() { + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void shouldCreateBlobSidecarsForBlindedBlock(final boolean useLocalFallback) { final SszList commitments = dataStructureUtil.randomBlobKzgCommitments(3); final SignedBeaconBlock signedBlindedBeaconBlock = dataStructureUtil.randomSignedBlindedBeaconBlockWithCommitments(commitments); + final UInt64 slot = signedBlindedBeaconBlock.getSlot(); - final MiscHelpersDeneb miscHelpersDeneb = - MiscHelpersDeneb.required(spec.atSlot(signedBlindedBeaconBlock.getSlot()).miscHelpers()); - + final ExecutionPayload executionPayload = dataStructureUtil.randomExecutionPayload(); final tech.pegasys.teku.spec.datastructures.builder.BlobsBundle blobsBundle = dataStructureUtil.randomBuilderBlobsBundle(commitments); - prepareCachedBuilderPayload( - signedBlindedBeaconBlock.getSlot(), - dataStructureUtil.randomExecutionPayload(), - Optional.of(blobsBundle)); + if (useLocalFallback) { + final BlobsBundle localFallbackBlobsBundle = + new BlobsBundle( + blobsBundle.getCommitments().stream() + .map(SszKZGCommitment::getKZGCommitment) + .toList(), + blobsBundle.getProofs().stream().map(SszKZGProof::getKZGProof).toList(), + blobsBundle.getBlobs().stream().toList()); + prepareCachedFallbackData(slot, executionPayload, localFallbackBlobsBundle); + } else { + + prepareCachedBuilderPayload(slot, executionPayload, blobsBundle); + } final List blobSidecars = - factory - .createBlobSidecarsSelector(BlockPublishingPerformance.NOOP) - .apply(signedBlindedBeaconBlock); + factory.createBlobSidecarsSelector().apply(signedBlindedBeaconBlock); final SszList expectedBlobs = blobsBundle.getBlobs(); final SszList expectedProofs = blobsBundle.getProofs(); @@ -927,8 +905,10 @@ void shouldCreateBlobSidecarsForBlindedBlock() { .getOptionalBlobKzgCommitments() .orElseThrow(); - assertThat(blobSidecars).hasSize(expectedBlobs.size()); + final MiscHelpersDeneb miscHelpersDeneb = + MiscHelpersDeneb.required(spec.atSlot(slot).miscHelpers()); + assertThat(blobSidecars).hasSize(expectedBlobs.size()); IntStream.range(0, blobSidecars.size()) .forEach( index -> { @@ -959,7 +939,6 @@ void shouldThrowWhenExecutionPayloadContextNotProvided() { blockSlotState, dataStructureUtil.randomSignature(), Optional.empty(), - Optional.of(false), Optional.empty(), BlockProductionPerformance.NOOP) .apply(bodyBuilder)) @@ -968,11 +947,111 @@ void shouldThrowWhenExecutionPayloadContextNotProvided() { "ExecutionPayloadContext is not provided for production of post-merge block at slot 1"); } + @Test + void shouldGetExecutionRequestsForLocallyProducedBlocks() { + final UInt64 slot = UInt64.valueOf(2); + final BeaconState blockSlotState = dataStructureUtil.randomBeaconState(slot); + final SignedVoluntaryExit voluntaryExit = dataStructureUtil.randomSignedVoluntaryExit(); + final ProposerSlashing proposerSlashing = dataStructureUtil.randomProposerSlashing(); + final AttesterSlashing attesterSlashing = dataStructureUtil.randomAttesterSlashing(); + final SignedContributionAndProof contribution = + dataStructureUtil.randomSignedContributionAndProof(1, parentRoot); + final SignedBlsToExecutionChange blsToExecutionChange = + dataStructureUtil.randomSignedBlsToExecutionChange(); + addToPool(voluntaryExitPool, voluntaryExit); + addToPool(proposerSlashingPool, proposerSlashing); + addToPool(attesterSlashingPool, attesterSlashing); + assertThat(contributionPool.addLocal(contribution)).isCompletedWithValue(ACCEPT); + addToPool(blsToExecutionChangePool, blsToExecutionChange); + + final CapturingBeaconBlockBodyBuilder bodyBuilder = + new CapturingBeaconBlockBodyBuilder(true, true); + + final ExecutionPayload randomExecutionPayload = dataStructureUtil.randomExecutionPayload(); + final UInt256 blockExecutionValue = dataStructureUtil.randomUInt256(); + + final ExecutionRequests expectedExecutionRequests = dataStructureUtil.randomExecutionRequests(); + + prepareBlockWithBlobsAndExecutionRequestsProduction( + randomExecutionPayload, + executionPayloadContext, + blockSlotState, + dataStructureUtil.randomBlobsBundle(), + expectedExecutionRequests, + blockExecutionValue); + + safeJoin( + factory + .createSelector( + parentRoot, + blockSlotState, + randaoReveal, + Optional.of(defaultGraffiti), + Optional.empty(), + BlockProductionPerformance.NOOP) + .apply(bodyBuilder)); + + assertThat(bodyBuilder.randaoReveal).isEqualTo(randaoReveal); + assertThat(bodyBuilder.graffiti).isEqualTo(defaultGraffiti); + assertThat(bodyBuilder.proposerSlashings).containsOnly(proposerSlashing); + assertThat(bodyBuilder.attesterSlashings).containsOnly(attesterSlashing); + assertThat(bodyBuilder.voluntaryExits).containsOnly(voluntaryExit); + assertThat(bodyBuilder.syncAggregate) + .isEqualTo( + spec.getSyncCommitteeUtilRequired(slot) + .createSyncAggregate(List.of(contribution.getMessage().getContribution()))); + assertThat(bodyBuilder.blsToExecutionChanges).containsOnly(blsToExecutionChange); + assertThat(bodyBuilder.executionRequests).isEqualTo(expectedExecutionRequests); + } + + @Test + void shouldIncludeExecutionRequestsInBlindedBlock() { + final UInt64 slot = UInt64.valueOf(2); + final BeaconState blockSlotState = dataStructureUtil.randomBeaconState(slot); + + final ExecutionRequests executionRequests = dataStructureUtil.randomExecutionRequests(); + + final ExecutionPayloadContext executionPayloadContextWithValidatorRegistration = + dataStructureUtil.randomPayloadExecutionContext(false, true); + when(forkChoiceNotifier.getPayloadId(any(), any())) + .thenReturn( + SafeFuture.completedFuture( + Optional.of(executionPayloadContextWithValidatorRegistration))); + + prepareBlindedBlockWithBlobsAndExecutionRequestsProduction( + dataStructureUtil.randomExecutionPayloadHeader(), + executionPayloadContextWithValidatorRegistration, + blockSlotState, + dataStructureUtil.randomBlobKzgCommitments(), + executionRequests, + dataStructureUtil.randomUInt256()); + + final CapturingBeaconBlockBodyBuilder bodyBuilder = + new CapturingBeaconBlockBodyBuilder(true, true); + + safeJoin( + factory + .createSelector( + parentRoot, + blockSlotState, + dataStructureUtil.randomSignature(), + Optional.empty(), + Optional.empty(), + BlockProductionPerformance.NOOP) + .apply(bodyBuilder)); + + assertThat(bodyBuilder.executionRequests).isEqualTo(executionRequests); + } + private void prepareBlockProductionWithPayload( final ExecutionPayload executionPayload, final ExecutionPayloadContext executionPayloadContext, final BeaconState blockSlotState, final Optional executionPayloadValue) { + final GetPayloadResponse getPayloadResponse = + executionPayloadValue + .map(value -> new GetPayloadResponse(executionPayload, value)) + .orElse(new GetPayloadResponse(executionPayload)); when(executionLayer.initiateBlockProduction( executionPayloadContext, blockSlotState, @@ -980,12 +1059,8 @@ private void prepareBlockProductionWithPayload( Optional.empty(), BlockProductionPerformance.NOOP)) .thenReturn( - new ExecutionPayloadResult( - executionPayloadContext, - Optional.of(SafeFuture.completedFuture(executionPayload)), - Optional.empty(), - Optional.empty(), - executionPayloadValue.map(SafeFuture::completedFuture))); + ExecutionPayloadResult.createForLocalFlow( + executionPayloadContext, SafeFuture.completedFuture(getPayloadResponse))); } private void prepareBlockProductionWithPayloadHeader( @@ -993,6 +1068,12 @@ private void prepareBlockProductionWithPayloadHeader( final ExecutionPayloadContext executionPayloadContext, final BeaconState blockSlotState, final Optional executionPayloadValue) { + final BuilderBid builderBid = + dataStructureUtil.randomBuilderBid( + builder -> { + builder.header(executionPayloadHeader); + executionPayloadValue.ifPresent(builder::value); + }); when(executionLayer.initiateBlockProduction( executionPayloadContext, blockSlotState, @@ -1000,30 +1081,21 @@ private void prepareBlockProductionWithPayloadHeader( Optional.empty(), BlockProductionPerformance.NOOP)) .thenReturn( - new ExecutionPayloadResult( + ExecutionPayloadResult.createForBuilderFlow( executionPayloadContext, - Optional.empty(), - Optional.empty(), - Optional.of( - SafeFuture.completedFuture( - HeaderWithFallbackData.create(executionPayloadHeader))), - executionPayloadValue.map(SafeFuture::completedFuture))); + SafeFuture.completedFuture(BuilderBidOrFallbackData.create(builderBid)))); } private void prepareBlindedBlockProductionWithFallBack( final ExecutionPayload executionPayload, final ExecutionPayloadContext executionPayloadContext, final BeaconState blockSlotState, - final Optional executionPayloadValue) { - final HeaderWithFallbackData headerWithFallbackData = - HeaderWithFallbackData.create( - dataStructureUtil.randomExecutionPayloadHeader(), - Optional.empty(), + final UInt256 executionPayloadValue) { + final BuilderBidOrFallbackData builderBidOrFallbackData = + BuilderBidOrFallbackData.create( new FallbackData( - executionPayload, - Optional.empty(), + new GetPayloadResponse(executionPayload, executionPayloadValue), FallbackReason.SHOULD_OVERRIDE_BUILDER_FLAG_IS_TRUE)); - when(executionLayer.initiateBlockProduction( executionPayloadContext, blockSlotState, @@ -1031,12 +1103,8 @@ private void prepareBlindedBlockProductionWithFallBack( Optional.empty(), BlockProductionPerformance.NOOP)) .thenReturn( - new ExecutionPayloadResult( - executionPayloadContext, - Optional.empty(), - Optional.empty(), - Optional.of(SafeFuture.completedFuture(headerWithFallbackData)), - executionPayloadValue.map(SafeFuture::completedFuture))); + ExecutionPayloadResult.createForBuilderFlow( + executionPayloadContext, SafeFuture.completedFuture(builderBidOrFallbackData))); } private void prepareBlockAndBlobsProduction( @@ -1044,20 +1112,48 @@ private void prepareBlockAndBlobsProduction( final ExecutionPayloadContext executionPayloadContext, final BeaconState blockSlotState, final BlobsBundle blobsBundle, - final Optional executionPayloadValue) { - when(executionLayer.initiateBlockAndBlobsProduction( + final UInt256 executionPayloadValue) { + when(executionLayer.initiateBlockProduction( executionPayloadContext, blockSlotState, false, Optional.empty(), BlockProductionPerformance.NOOP)) .thenReturn( - new ExecutionPayloadResult( + ExecutionPayloadResult.createForLocalFlow( executionPayloadContext, - Optional.of(SafeFuture.completedFuture(executionPayload)), - Optional.of(SafeFuture.completedFuture(Optional.of(blobsBundle))), - Optional.empty(), - executionPayloadValue.map(SafeFuture::completedFuture))); + SafeFuture.completedFuture( + new GetPayloadResponse( + executionPayload, + executionPayloadValue, + blobsBundle, + false, + dataStructureUtil.randomExecutionRequests())))); + } + + private void prepareBlockWithBlobsAndExecutionRequestsProduction( + final ExecutionPayload executionPayload, + final ExecutionPayloadContext executionPayloadContext, + final BeaconState blockSlotState, + final BlobsBundle blobsBundle, + final ExecutionRequests executionRequests, + final UInt256 executionPayloadValue) { + when(executionLayer.initiateBlockProduction( + executionPayloadContext, + blockSlotState, + false, + Optional.empty(), + BlockProductionPerformance.NOOP)) + .thenReturn( + ExecutionPayloadResult.createForLocalFlow( + executionPayloadContext, + SafeFuture.completedFuture( + new GetPayloadResponse( + executionPayload, + executionPayloadValue, + blobsBundle, + false, + executionRequests)))); } private void prepareBlindedBlockAndBlobsProduction( @@ -1065,22 +1161,51 @@ private void prepareBlindedBlockAndBlobsProduction( final ExecutionPayloadContext executionPayloadContext, final BeaconState blockSlotState, final SszList blobKzgCommitments, - final Optional executionPayloadValue) { - final HeaderWithFallbackData headerWithFallbackData = - HeaderWithFallbackData.create(executionPayloadHeader, Optional.of(blobKzgCommitments)); - when(executionLayer.initiateBlockAndBlobsProduction( + final UInt256 executionPayloadValue) { + final BuilderBidOrFallbackData builderBidOrFallbackData = + BuilderBidOrFallbackData.create( + dataStructureUtil.randomBuilderBid( + builder -> { + builder.header(executionPayloadHeader); + builder.blobKzgCommitments(blobKzgCommitments); + builder.value(executionPayloadValue); + })); + when(executionLayer.initiateBlockProduction( executionPayloadContext, blockSlotState, true, Optional.empty(), BlockProductionPerformance.NOOP)) .thenReturn( - new ExecutionPayloadResult( - executionPayloadContext, - Optional.empty(), - Optional.empty(), - Optional.of(SafeFuture.completedFuture(headerWithFallbackData)), - executionPayloadValue.map(SafeFuture::completedFuture))); + ExecutionPayloadResult.createForBuilderFlow( + executionPayloadContext, SafeFuture.completedFuture(builderBidOrFallbackData))); + } + + private void prepareBlindedBlockWithBlobsAndExecutionRequestsProduction( + final ExecutionPayloadHeader executionPayloadHeader, + final ExecutionPayloadContext executionPayloadContext, + final BeaconState blockSlotState, + final SszList blobKzgCommitments, + final ExecutionRequests executionRequests, + final UInt256 executionPayloadValue) { + final BuilderBidOrFallbackData builderBidOrFallbackData = + BuilderBidOrFallbackData.create( + dataStructureUtil.randomBuilderBid( + builder -> { + builder.header(executionPayloadHeader); + builder.blobKzgCommitments(blobKzgCommitments); + builder.executionRequests(executionRequests); + builder.value(executionPayloadValue); + })); + when(executionLayer.initiateBlockProduction( + executionPayloadContext, + blockSlotState, + true, + Optional.empty(), + BlockProductionPerformance.NOOP)) + .thenReturn( + ExecutionPayloadResult.createForBuilderFlow( + executionPayloadContext, SafeFuture.completedFuture(builderBidOrFallbackData))); } private void prepareBlindedBlockAndBlobsProductionWithFallBack( @@ -1088,99 +1213,84 @@ private void prepareBlindedBlockAndBlobsProductionWithFallBack( final ExecutionPayloadContext executionPayloadContext, final BeaconState blockSlotState, final BlobsBundle blobsBundle, - final Optional executionPayloadValue) { - final HeaderWithFallbackData headerWithFallbackData = - HeaderWithFallbackData.create( - dataStructureUtil.randomExecutionPayloadHeader(), - Optional.of(dataStructureUtil.randomBlobKzgCommitments()), + final UInt256 executionPayloadValue) { + final BuilderBidOrFallbackData builderBidOrFallbackData = + BuilderBidOrFallbackData.create( new FallbackData( - executionPayload, - Optional.of(blobsBundle), + new GetPayloadResponse(executionPayload, executionPayloadValue, blobsBundle, false), FallbackReason.SHOULD_OVERRIDE_BUILDER_FLAG_IS_TRUE)); - when(executionLayer.initiateBlockAndBlobsProduction( + when(executionLayer.initiateBlockProduction( executionPayloadContext, blockSlotState, true, Optional.empty(), BlockProductionPerformance.NOOP)) .thenReturn( - new ExecutionPayloadResult( - executionPayloadContext, - Optional.empty(), - Optional.empty(), - Optional.of(SafeFuture.completedFuture(headerWithFallbackData)), - executionPayloadValue.map(SafeFuture::completedFuture))); + ExecutionPayloadResult.createForBuilderFlow( + executionPayloadContext, SafeFuture.completedFuture(builderBidOrFallbackData))); } private void prepareCachedPayloadResult( final UInt64 slot, final ExecutionPayload executionPayload, final ExecutionPayloadContext executionPayloadContext, - final BlobsBundle blobsBundle, - final Optional executionPayloadValue) { + final BlobsBundle blobsBundle) { when(executionLayer.getCachedPayloadResult(slot)) .thenReturn( Optional.of( - new ExecutionPayloadResult( + ExecutionPayloadResult.createForLocalFlow( executionPayloadContext, - Optional.of(SafeFuture.completedFuture(executionPayload)), - Optional.of(SafeFuture.completedFuture(Optional.of(blobsBundle))), - Optional.empty(), - executionPayloadValue.map(SafeFuture::completedFuture)))); + SafeFuture.completedFuture( + new GetPayloadResponse( + executionPayload, UInt256.ZERO, blobsBundle, false))))); } private void prepareCachedPayloadHeaderWithFallbackResult( final UInt64 slot, - final ExecutionPayloadHeader executionPayloadHeader, final ExecutionPayload executionPayload, final ExecutionPayloadContext executionPayloadContext, - final BlobsBundle blobsBundle, - final Optional executionPayloadValue) { - - final SszList sszKZGCommitments = - SchemaDefinitionsDeneb.required(spec.atSlot(slot).getSchemaDefinitions()) - .getBlobKzgCommitmentsSchema() - .createFromBlobsBundle(blobsBundle); - + final BlobsBundle blobsBundle) { + final BuilderBidOrFallbackData builderBidOrFallbackData = + BuilderBidOrFallbackData.create( + new FallbackData( + new GetPayloadResponse(executionPayload, UInt256.ZERO, blobsBundle, false), + FallbackReason.SHOULD_OVERRIDE_BUILDER_FLAG_IS_TRUE)); when(executionLayer.getCachedPayloadResult(slot)) .thenReturn( Optional.of( - new ExecutionPayloadResult( + ExecutionPayloadResult.createForBuilderFlow( executionPayloadContext, - Optional.empty(), - Optional.empty(), - Optional.of( - SafeFuture.completedFuture( - HeaderWithFallbackData.create( - executionPayloadHeader, - Optional.of(sszKZGCommitments), - new FallbackData( - executionPayload, - Optional.of(blobsBundle), - FallbackReason.SHOULD_OVERRIDE_BUILDER_FLAG_IS_TRUE)))), - executionPayloadValue.map(SafeFuture::completedFuture)))); + SafeFuture.completedFuture(builderBidOrFallbackData)))); } private void prepareCachedBuilderPayload( final UInt64 slot, final ExecutionPayload executionPayload, - final Optional blobsBundle) { + final tech.pegasys.teku.spec.datastructures.builder.BlobsBundle blobsBundle) { final BuilderPayload builderPayload = - blobsBundle - .map( - bundle -> - (BuilderPayload) - SchemaDefinitionsDeneb.required(spec.atSlot(slot).getSchemaDefinitions()) - .getExecutionPayloadAndBlobsBundleSchema() - .create(executionPayload, bundle)) - .orElse(executionPayload); - when(executionLayer.getCachedUnblindedPayload(slot)).thenReturn(Optional.of(builderPayload)); + SchemaDefinitionsDeneb.required(spec.atSlot(slot).getSchemaDefinitions()) + .getExecutionPayloadAndBlobsBundleSchema() + .create(executionPayload, blobsBundle); + when(executionLayer.getCachedUnblindedPayload(slot)) + .thenReturn(Optional.of(BuilderPayloadOrFallbackData.create(builderPayload))); + } + + private void prepareCachedFallbackData( + final UInt64 slot, final ExecutionPayload executionPayload, final BlobsBundle blobsBundle) { + when(executionLayer.getCachedUnblindedPayload(slot)) + .thenReturn( + Optional.of( + BuilderPayloadOrFallbackData.create( + new FallbackData( + new GetPayloadResponse(executionPayload, UInt256.ZERO, blobsBundle, false), + FallbackReason.BUILDER_ERROR)))); } private static class CapturingBeaconBlockBodyBuilder implements BeaconBlockBodyBuilder { private final boolean supportsKzgCommitments; + private final boolean supportExecutionRequests; protected BLSSignature randaoReveal; protected Bytes32 graffiti; @@ -1192,9 +1302,17 @@ private static class CapturingBeaconBlockBodyBuilder implements BeaconBlockBodyB protected ExecutionPayload executionPayload; protected ExecutionPayloadHeader executionPayloadHeader; protected SszList blobKzgCommitments; + protected ExecutionRequests executionRequests; public CapturingBeaconBlockBodyBuilder(final boolean supportsKzgCommitments) { this.supportsKzgCommitments = supportsKzgCommitments; + this.supportExecutionRequests = false; + } + + public CapturingBeaconBlockBodyBuilder( + final boolean supportsKzgCommitments, final boolean supportExecutionRequests) { + this.supportsKzgCommitments = supportsKzgCommitments; + this.supportExecutionRequests = supportExecutionRequests; } @Override @@ -1271,6 +1389,12 @@ public BeaconBlockBodyBuilder blsToExecutionChanges( return this; } + @Override + public BeaconBlockBodyBuilder executionRequests(final ExecutionRequests executionRequests) { + this.executionRequests = executionRequests; + return this; + } + @Override public Boolean supportsSyncAggregate() { return true; @@ -1291,6 +1415,11 @@ public Boolean supportsKzgCommitments() { return supportsKzgCommitments; } + @Override + public boolean supportsExecutionRequests() { + return supportExecutionRequests; + } + @Override public BeaconBlockBodyBuilder blobKzgCommitments( final SszList blobKzgCommitments) { diff --git a/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/DepositProviderTest.java b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/DepositProviderTest.java index a26e0cf3b34..344fa198e73 100644 --- a/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/DepositProviderTest.java +++ b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/DepositProviderTest.java @@ -46,11 +46,11 @@ import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.datastructures.blocks.Eth1Data; import tech.pegasys.teku.spec.datastructures.operations.Deposit; -import tech.pegasys.teku.spec.datastructures.operations.DepositData; import tech.pegasys.teku.spec.datastructures.operations.DepositWithIndex; import tech.pegasys.teku.spec.datastructures.state.AnchorPoint; import tech.pegasys.teku.spec.datastructures.state.Checkpoint; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.MutableBeaconStateElectra; import tech.pegasys.teku.spec.datastructures.util.DepositUtil; import tech.pegasys.teku.spec.datastructures.util.MerkleTree; import tech.pegasys.teku.spec.networks.Eth2Network; @@ -129,7 +129,7 @@ void numberOfDepositsThatCanBeIncludedLessThanMaxDeposits() { mockDepositsFromEth1Block(0, 10); mockDepositsFromEth1Block(10, 20); - SszList deposits = depositProvider.getDeposits(state, randomEth1Data); + List deposits = depositProvider.getDepositsWithIndex(state, randomEth1Data); assertThat(deposits).hasSize(15); checkThatDepositProofIsValid(deposits); } @@ -154,9 +154,11 @@ void numberOfDepositsGetsAdjustedAccordingToOurEth1DataVote() { .collect(SszListSchema.create(Eth1Data.SSZ_SCHEMA, 32).collector()); state = state.updated(mutableState -> mutableState.setEth1DataVotes(et1hDataVotes)); - SszList deposits = depositProvider.getDeposits(state, newEth1Data); + List deposits = depositProvider.getDepositsWithIndex(state, newEth1Data); assertThat(deposits).hasSize(25); checkThatDepositProofIsValid(deposits); + assertThat(deposits.stream().map(DepositWithIndex::deposit)) + .containsExactlyElementsOf(depositProvider.getDeposits(state, newEth1Data)); } @Test @@ -168,9 +170,45 @@ void numberOfDepositsThatCanBeIncludedMoreThanMaxDeposits() { mockDepositsFromEth1Block(0, 10); mockDepositsFromEth1Block(10, 20); - SszList deposits = depositProvider.getDeposits(state, randomEth1Data); + List deposits = depositProvider.getDepositsWithIndex(state, randomEth1Data); assertThat(deposits).hasSize(10); checkThatDepositProofIsValid(deposits); + assertThat(deposits.stream().map(DepositWithIndex::deposit)) + .containsExactlyElementsOf(depositProvider.getDeposits(state, randomEth1Data)); + } + + @Test + void noDepositsIncludedIfFormerDepositMechanismHasBeenDisabled() { + setup(16, SpecMilestone.ELECTRA); + updateStateEth1DepositIndex(5); + updateStateDepositRequestsStartIndex(5); + + final SszList deposits = depositProvider.getDeposits(state, randomEth1Data); + + assertThat(deposits).isEmpty(); + } + + @Test + void getsRemainingEth1PendingDepositsIfElectraIsEnabled() { + setup(16, SpecMilestone.ELECTRA); + updateStateEth1DepositIndex(5); + updateStateEth1DataDepositCount(20); + // 16th deposit is using the new mechanism + updateStateDepositRequestsStartIndex(16); + + mockDepositsFromEth1Block(0, 10); + mockDepositsFromEth1Block(10, 20); + + final List deposits = + depositProvider.getDepositsWithIndex(state, randomEth1Data); + + // the pending Eth1 deposits (deposit_requests_start_index - eth1_deposit_index) + // we need to process eth1_deposit_index deposit (5) up to 16 (exclusive) so 11 is the + // expected size + assertThat(deposits).hasSize(11); + checkThatDepositProofIsValid(deposits); + assertThat(deposits.stream().map(DepositWithIndex::deposit)) + .containsExactlyElementsOf(depositProvider.getDeposits(state, randomEth1Data)); } @Test @@ -217,7 +255,11 @@ void shouldNotifyEth1DataCacheOfDepositBlocks() { depositProvider.onDepositsFromBlock(event); depositMerkleTree.add( - depositUtil.convertDepositEventToOperationDeposit(deposit).getData().hashTreeRoot()); + depositUtil + .convertDepositEventToOperationDeposit(deposit) + .deposit() + .getData() + .hashTreeRoot()); verify(eth1DataCache) .onBlockWithDeposit( event.getBlockNumber(), @@ -273,6 +315,21 @@ void shouldLogAnEventOnSlotWhenAllDepositsRequiredForStateNotAvailable() { verify(eventLogger).eth1DepositDataNotAvailable(UInt64.valueOf(9), UInt64.valueOf(10)); } + @Test + void + shouldNotLogAnEventOnSlotIfFormerDepositMechanismIsDisabled_EvenIfAllDepositsRequiredForStateNotAvailable() { + setup(1, SpecMilestone.ELECTRA); + mockDepositsFromEth1Block(0, 8); + updateStateEth1DepositIndex(5); + updateStateDepositRequestsStartIndex(5); + updateStateEth1DataDepositCount(10); + when(recentChainData.getBestState()).thenReturn(Optional.of(SafeFuture.completedFuture(state))); + + depositProvider.onSlot(UInt64.ONE); + + verifyNoInteractions(eventLogger); + } + @Test void shouldNotLogAnEventOnSlotWhenAllDepositsRequiredForStateAvailable() { setup(1); @@ -435,35 +492,34 @@ void whenCallingForFinalizedSnapshotAndSnapshotAvailable_SnapshotReturned() { .isEqualTo(UInt64.valueOf(30)); } - private void checkThatDepositProofIsValid(SszList deposits) { + private void checkThatDepositProofIsValid(final List depositsWithIndex) { final SpecVersion genesisSpec = spec.getGenesisSpec(); - deposits.forEach( - deposit -> + depositsWithIndex.forEach( + depositWithIndex -> assertThat( genesisSpec .predicates() .isValidMerkleBranch( - deposit.getData().hashTreeRoot(), - deposit.getProof(), + depositWithIndex.deposit().getData().hashTreeRoot(), + depositWithIndex.deposit().getProof(), genesisSpec.getConfig().getDepositContractTreeDepth() + 1, - ((DepositWithIndex) deposit).getIndex().intValue(), + depositWithIndex.index().intValue(), depositMerkleTree.getRoot())) .withFailMessage("Expected proof to be valid but was not") .isTrue()); } - private void createDepositEvents(int n) { + private void createDepositEvents(final int n) { allSeenDepositsList = IntStream.range(0, n) .mapToObj(i -> dataStructureUtil.randomDepositEvent(UInt64.valueOf(i))) .collect(Collectors.toList()); } - private void mockDepositsFromEth1Block(int startIndex, int n) { + private void mockDepositsFromEth1Block(final int startIndex, final int n) { allSeenDepositsList.subList(startIndex, n).stream() .map(depositUtil::convertDepositEventToOperationDeposit) - .map(Deposit::getData) - .map(DepositData::hashTreeRoot) + .map(depositWithIndex -> depositWithIndex.deposit().getData().hashTreeRoot()) .forEachOrdered(depositMerkleTree::add); DepositsFromBlockEvent depositsFromBlockEvent = mock(DepositsFromBlockEvent.class); @@ -473,11 +529,11 @@ private void mockDepositsFromEth1Block(int startIndex, int n) { depositProvider.onDepositsFromBlock(depositsFromBlockEvent); } - private void updateStateEth1Data(Eth1Data eth1Data) { + private void updateStateEth1Data(final Eth1Data eth1Data) { state = state.updated(mutableState -> mutableState.setEth1Data(eth1Data)); } - private void updateStateEth1DataDepositCount(int n) { + private void updateStateEth1DataDepositCount(final int n) { final Eth1Data eth1Data = new Eth1Data( dataStructureUtil.randomBytes32(), @@ -486,7 +542,15 @@ private void updateStateEth1DataDepositCount(int n) { updateStateEth1Data(eth1Data); } - private void updateStateEth1DepositIndex(int n) { + private void updateStateEth1DepositIndex(final int n) { state = state.updated(mutableState -> mutableState.setEth1DepositIndex(UInt64.valueOf(n))); } + + private void updateStateDepositRequestsStartIndex(final int n) { + state = + state.updated( + mutableState -> + MutableBeaconStateElectra.required(mutableState) + .setDepositRequestsStartIndex(UInt64.valueOf(n))); + } } diff --git a/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/DutyMetricsTest.java b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/DutyMetricsTest.java index cd880c13b56..5e1f3926f33 100644 --- a/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/DutyMetricsTest.java +++ b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/DutyMetricsTest.java @@ -45,7 +45,7 @@ class DutyMetricsTest { private final MetricsSystem metricsSystem = new StubMetricsSystem(); - private DutyMetrics createMetrics(Spec spec) { + private DutyMetrics createMetrics(final Spec spec) { return new DutyMetrics( timeProvider, recentChainData, @@ -64,7 +64,7 @@ void setUp() { @EnumSource( value = Eth2Network.class, names = {"MAINNET", "MINIMAL", "GNOSIS"}) - void shouldRecordDelayWhenAttestationIsPublishedLate(Eth2Network eth2Network) { + void shouldRecordDelayWhenAttestationIsPublishedLate(final Eth2Network eth2Network) { Spec spec = getSpec(eth2Network); DutyMetrics metrics = createMetrics(spec); @@ -82,7 +82,7 @@ void shouldRecordDelayWhenAttestationIsPublishedLate(Eth2Network eth2Network) { @EnumSource( value = Eth2Network.class, names = {"MAINNET", "MINIMAL", "GNOSIS"}) - void shouldRecordZeroDelayWhenAttestationIsPublishedEarly(Eth2Network eth2Network) { + void shouldRecordZeroDelayWhenAttestationIsPublishedEarly(final Eth2Network eth2Network) { Spec spec = getSpec(eth2Network); DutyMetrics metrics = createMetrics(spec); @@ -99,7 +99,7 @@ void shouldRecordZeroDelayWhenAttestationIsPublishedEarly(Eth2Network eth2Networ @EnumSource( value = Eth2Network.class, names = {"MAINNET", "MINIMAL", "GNOSIS"}) - void shouldRecordDelayWhenBlockIsPublishedLate(Eth2Network eth2Network) { + void shouldRecordDelayWhenBlockIsPublishedLate(final Eth2Network eth2Network) { Spec spec = getSpec(eth2Network); DutyMetrics metrics = createMetrics(spec); @@ -117,7 +117,7 @@ void shouldRecordDelayWhenBlockIsPublishedLate(Eth2Network eth2Network) { @EnumSource( value = Eth2Network.class, names = {"MAINNET", "MINIMAL", "GNOSIS"}) - void shouldRecordZeroDelayWhenBlockIsPublishedEarly(Eth2Network eth2Network) { + void shouldRecordZeroDelayWhenBlockIsPublishedEarly(final Eth2Network eth2Network) { Spec spec = getSpec(eth2Network); DutyMetrics metrics = createMetrics(spec); @@ -130,7 +130,7 @@ void shouldRecordZeroDelayWhenBlockIsPublishedEarly(Eth2Network eth2Network) { verify(blockTimings).recordValue(0); } - private Spec getSpec(Eth2Network eth2Network) { + private Spec getSpec(final Eth2Network eth2Network) { return TestSpecFactory.create(SpecMilestone.PHASE0, eth2Network); } diff --git a/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/Eth1DataCacheTest.java b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/Eth1DataCacheTest.java index 0419e6ce86d..ba6e5027341 100644 --- a/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/Eth1DataCacheTest.java +++ b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/Eth1DataCacheTest.java @@ -67,7 +67,7 @@ void setUp() { when(eth1VotingPeriod.getSpecRangeLowerBound(SLOT, GENESIS_TIME)) .thenReturn(VOTING_PERIOD_START); when(eth1VotingPeriod.getSpecRangeUpperBound(SLOT, GENESIS_TIME)).thenReturn(VOTING_PERIOD_END); - eth1DataCache = new Eth1DataCache(metricsSystem, eth1VotingPeriod); + eth1DataCache = new Eth1DataCache(spec, metricsSystem, eth1VotingPeriod); } // Add tests for eth1 block with no votes @@ -215,6 +215,17 @@ void noValidVotesInThisPeriod_eth1ChainNotLive() { assertThat(eth1DataCache.getEth1Vote(beaconState)).isEqualTo(stateEth1Data); } + @Test + void shouldReturnStateEth1Data_ifFormerDepositMechanismHasBeenDisabled() { + final Spec spec = mock(Spec.class); + eth1DataCache = new Eth1DataCache(spec, new StubMetricsSystem(), eth1VotingPeriod); + final BeaconState beaconState = createBeaconStateWithVotes(createEth1Data(STATE_DEPOSIT_COUNT)); + + when(spec.isFormerDepositMechanismDisabled(beaconState)).thenReturn(true); + + assertThat(eth1DataCache.getEth1Vote(beaconState)).isEqualTo(beaconState.getEth1Data()); + } + @Test void shouldPruneOldBlocksWhenNewerOnesReceived() { final UInt64 olderBlockTimestamp = ZERO; @@ -254,6 +265,24 @@ void shouldUpdateMetrics() { assertGaugeValue(Eth1DataCache.VOTES_BEST_METRIC_NAME, 4); } + @Test + void shouldNotUpdateMetrics_ifFormerDepositMechanismHasBeenDisabled() { + final Spec spec = mock(Spec.class); + eth1DataCache = new Eth1DataCache(spec, new StubMetricsSystem(), eth1VotingPeriod); + final BeaconState beaconState = getStateForMetricsAssertions(); + + when(spec.isFormerDepositMechanismDisabled(beaconState)).thenReturn(true); + + eth1DataCache.updateMetrics(beaconState); + + // all gauge values are 0 + assertGaugeValue(Eth1DataCache.VOTES_TOTAL_METRIC_NAME, 0); + assertGaugeValue(Eth1DataCache.VOTES_MAX_METRIC_NAME, 0); + assertGaugeValue(Eth1DataCache.VOTES_UNKNOWN_METRIC_NAME, 0); + assertGaugeValue(Eth1DataCache.VOTES_CURRENT_METRIC_NAME, 0); + assertGaugeValue(Eth1DataCache.VOTES_BEST_METRIC_NAME, 0); + } + @Test void shouldIncludeUnknownBlocksWhenCalculatingVoteBestMetric() { // Metric needs to indicate when a block will be voted in which happens even when unknown diff --git a/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/Eth1DataProviderTest.java b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/Eth1DataProviderTest.java index 6cfe1bd6130..3f436c4c519 100644 --- a/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/Eth1DataProviderTest.java +++ b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/Eth1DataProviderTest.java @@ -70,7 +70,7 @@ public void setup() { assertThat(slotsInVotingPeriod).isEqualTo(SLOTS_IN_VOTING_PERIOD_ASSERTION); final Eth1VotingPeriod eth1VotingPeriod = new Eth1VotingPeriod(spec); - final Eth1DataCache eth1DataCache = new Eth1DataCache(metricsSystem, eth1VotingPeriod); + final Eth1DataCache eth1DataCache = new Eth1DataCache(spec, metricsSystem, eth1VotingPeriod); final DepositProvider depositProvider = new DepositProvider( new StubMetricsSystem(), @@ -167,7 +167,7 @@ public void whenSeveralVotes_eth1VotesBreakdownSortedDescending() { assertThat(votedOnce).contains(eth1Data2, eth1Data3); } - private SszList createEth1DataVotes(Eth1Data... eth1Data) { + private SszList createEth1DataVotes(final Eth1Data... eth1Data) { final List eth1DataList = new ArrayList<>(Arrays.asList(eth1Data)); return spec.atSlot(state.getSlot()) .getSchemaDefinitions() diff --git a/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/Eth1VotingPeriodTest.java b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/Eth1VotingPeriodTest.java index 0a1bc722d67..4c47ab83127 100644 --- a/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/Eth1VotingPeriodTest.java +++ b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/Eth1VotingPeriodTest.java @@ -22,11 +22,12 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.config.SpecConfigAndParent; import tech.pegasys.teku.spec.config.SpecConfigLoader; class Eth1VotingPeriodTest { - final SpecConfig specConfig = + final SpecConfigAndParent specConfig = SpecConfigLoader.loadConfig( "minimal", b -> diff --git a/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/GraffitiBuilderTest.java b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/GraffitiBuilderTest.java index 734da134a1c..849eec474ed 100644 --- a/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/GraffitiBuilderTest.java +++ b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/GraffitiBuilderTest.java @@ -37,17 +37,17 @@ public class GraffitiBuilderTest { private ClientGraffitiAppendFormat clientGraffitiAppendFormat = AUTO; - private Optional userGraffiti = Optional.empty(); - private GraffitiBuilder graffitiBuilder = - new GraffitiBuilder(clientGraffitiAppendFormat, userGraffiti); + private GraffitiBuilder graffitiBuilder = new GraffitiBuilder(clientGraffitiAppendFormat); private static final ClientVersion TEKU_CLIENT_VERSION = - new GraffitiBuilder(DISABLED, Optional.empty()).getConsensusClientVersion(); + new GraffitiBuilder(DISABLED).getConsensusClientVersion(); private static final ClientVersion BESU_CLIENT_VERSION = new ClientVersion("BU", "Besu", "23.4.1", Bytes4.fromHexString("abcdef12")); private final String asciiGraffiti0 = ""; private static final String ASCII_GRAFFITI_20 = "I've proposed ablock"; + private static final String ASCII_GRAFFITI_27 = "27 bytes of user's graffiti"; + private static final String ASCII_GRAFFITI_28 = "28 bytes of user's graffiti!"; private final String asciiGraffiti32 = "I've proposed a good Teku block!"; private static final String UTF_8_GRAFFITI_4 = "\uD83D\uDE80"; @@ -56,43 +56,39 @@ public class GraffitiBuilderTest { @BeforeEach public void setup() { this.clientGraffitiAppendFormat = AUTO; - this.userGraffiti = Optional.empty(); - this.graffitiBuilder = new GraffitiBuilder(clientGraffitiAppendFormat, userGraffiti); + this.graffitiBuilder = new GraffitiBuilder(clientGraffitiAppendFormat); } @Test - public void onExecutionClientVersion_shouldLogDefaultGraffiti() { + public void onExecutionClientVersion_shouldLogGraffitiWatermark() { + this.graffitiBuilder = new GraffitiBuilder(clientGraffitiAppendFormat); try (final LogCaptor logCaptor = LogCaptor.forClass(EventLogger.class)) { graffitiBuilder.onExecutionClientVersion(BESU_CLIENT_VERSION); logCaptor.assertInfoLog( - "Default graffiti to use when building block without external VC: \"TK" + "Using graffiti watermark: \"TK" + TEKU_CLIENT_VERSION.commit().toUnprefixedHexString() + "BUabcdef12\". " - + "To change check validator graffiti options."); + + "This will be appended to any user-defined graffiti or used if none is defined. Refer to validator graffiti options to customize."); } } @Test - public void onExecutionClientVersion_shouldLogDefaultMergedGraffiti() { - this.graffitiBuilder = - new GraffitiBuilder( - clientGraffitiAppendFormat, Optional.of(Bytes32Parser.toBytes32(ASCII_GRAFFITI_20))); + public void onExecutionClientVersionNotAvailable_shouldLogGraffitiWatermark() { try (final LogCaptor logCaptor = LogCaptor.forClass(EventLogger.class)) { - graffitiBuilder.onExecutionClientVersion(BESU_CLIENT_VERSION); + graffitiBuilder.onExecutionClientVersionNotAvailable(); logCaptor.assertInfoLog( - "Default graffiti to use when building block without external VC: \"I've proposed ablock TK" - + TEKU_CLIENT_VERSION.commit().toUnprefixedHexString().substring(0, 2) - + "BUab\". " - + "To change check validator graffiti options."); + "Using graffiti watermark: \"TK" + + TEKU_CLIENT_VERSION.commit().toUnprefixedHexString() + + "\". This will be appended to any user-defined graffiti or used if none is defined. Refer to validator graffiti options to customize."); } } @Test public void buildGraffiti_shouldNotFail() { this.graffitiBuilder = - new GraffitiBuilder(clientGraffitiAppendFormat, userGraffiti) { + new GraffitiBuilder(clientGraffitiAppendFormat) { @Override - protected int calculateGraffitiLength(Optional graffiti) { + protected int calculateGraffitiLength(final Optional graffiti) { throw new RuntimeException(""); } }; @@ -103,11 +99,9 @@ protected int calculateGraffitiLength(Optional graffiti) { @Test public void buildGraffiti_shouldPreferCallInput() { - final Bytes32 defaultGraffiti = Bytes32Parser.toBytes32(asciiGraffiti32); final Bytes32 userGraffiti = Bytes32Parser.toBytes32(ASCII_GRAFFITI_20); final Bytes32 expectedGraffiti = Bytes32Parser.toBytes32(ASCII_GRAFFITI_20 + " TK"); - this.graffitiBuilder = new GraffitiBuilder(CLIENT_CODES, Optional.of(defaultGraffiti)); - graffitiBuilder.onExecutionClientVersion(ClientVersion.UNKNOWN); + this.graffitiBuilder = new GraffitiBuilder(CLIENT_CODES); assertThat(graffitiBuilder.buildGraffiti(Optional.of(userGraffiti))) .isEqualTo(expectedGraffiti); } @@ -118,7 +112,7 @@ public void buildGraffiti_shouldProvideCorrectOutput( final ClientGraffitiAppendFormat clientGraffitiAppendFormat, final Optional maybeUserGraffiti, final String expectedGraffiti) { - this.graffitiBuilder = new GraffitiBuilder(clientGraffitiAppendFormat, userGraffiti); + this.graffitiBuilder = new GraffitiBuilder(clientGraffitiAppendFormat); graffitiBuilder.onExecutionClientVersion(BESU_CLIENT_VERSION); final Bytes32 expectedGraffitiBytes = Bytes32Parser.toBytes32(expectedGraffiti); assertThat( @@ -139,8 +133,7 @@ public void buildGraffiti_shouldProvideCorrectOutput_whenElInfoNa( final ClientGraffitiAppendFormat clientGraffitiAppendFormat, final Optional maybeUserGraffiti, final String expectedGraffiti) { - this.graffitiBuilder = new GraffitiBuilder(clientGraffitiAppendFormat, userGraffiti); - graffitiBuilder.onExecutionClientVersion(ClientVersion.UNKNOWN); + this.graffitiBuilder = new GraffitiBuilder(clientGraffitiAppendFormat); final Bytes32 expectedGraffitiBytes = Bytes32Parser.toBytes32(expectedGraffiti); assertThat( new String( @@ -339,8 +332,6 @@ public void formatClientInfo_shouldSkipClientsInfo_whenNotEnoughSpace() { @Test public void formatClientInfo_shouldRenderClClientNameAndFullCommit_whenElInfoNotAvailable() { - graffitiBuilder.onExecutionClientVersion(ClientVersion.UNKNOWN); - // 20: LH1be52536BU0f91a674 assertThat(graffitiBuilder.formatClientsInfo(30)) .isEqualTo( @@ -354,8 +345,6 @@ public void formatClientInfo_shouldRenderClClientNameAndFullCommit_whenElInfoNot @Test public void formatClientInfo_shouldRenderClClientNameAndHalfCommit_whenElInfoNotAvailable() { - graffitiBuilder.onExecutionClientVersion(ClientVersion.UNKNOWN); - // 12: LH1be5BU0f91 assertThat(graffitiBuilder.formatClientsInfo(19)) .isEqualTo( @@ -371,8 +360,6 @@ public void formatClientInfo_shouldRenderClClientNameAndHalfCommit_whenElInfoNot @Test public void formatClientInfo_shouldRenderClClientNameAnd1stCommitByte_whenElInfoNotAvailable() { - graffitiBuilder.onExecutionClientVersion(ClientVersion.UNKNOWN); - // 8: LH1bBU0f assertThat(graffitiBuilder.formatClientsInfo(11)) .isEqualTo( @@ -388,8 +375,6 @@ public void formatClientInfo_shouldRenderClClientNameAnd1stCommitByte_whenElInfo @Test public void formatClientInfo_shouldRenderClClientName_whenElInfoNotAvailable() { - graffitiBuilder.onExecutionClientVersion(ClientVersion.UNKNOWN); - // 4: LHBU assertThat(graffitiBuilder.formatClientsInfo(7)) .isEqualTo(TEKU_CLIENT_VERSION.code()) @@ -401,8 +386,6 @@ public void formatClientInfo_shouldRenderClClientName_whenElInfoNotAvailable() { @Test public void formatClientInfo_shouldSkipClientsInfo_whenNotEnoughSpaceAndElInfoNotAvailable() { - graffitiBuilder.onExecutionClientVersion(ClientVersion.UNKNOWN); - // Empty assertThat(graffitiBuilder.formatClientsInfo(3)) .isEqualTo("") @@ -541,6 +524,14 @@ private static Stream getBuildGraffitiFixtures() { + TEKU_CLIENT_VERSION.commit().toUnprefixedHexString().substring(0, 2) + BESU_CLIENT_VERSION.code() + BESU_CLIENT_VERSION.commit().toUnprefixedHexString().substring(0, 2)), + Arguments.of( + AUTO, + Optional.of(ASCII_GRAFFITI_27), + ASCII_GRAFFITI_27 + " " + TEKU_CLIENT_VERSION.code() + BESU_CLIENT_VERSION.code()), + Arguments.of( + AUTO, + Optional.of(ASCII_GRAFFITI_28), + ASCII_GRAFFITI_28 + TEKU_CLIENT_VERSION.code() + BESU_CLIENT_VERSION.code()), Arguments.of( CLIENT_CODES, Optional.empty(), @@ -557,6 +548,14 @@ private static Stream getBuildGraffitiFixtures() { CLIENT_CODES, Optional.of(ASCII_GRAFFITI_20), ASCII_GRAFFITI_20 + " " + TEKU_CLIENT_VERSION.code() + BESU_CLIENT_VERSION.code()), + Arguments.of( + CLIENT_CODES, + Optional.of(ASCII_GRAFFITI_27), + ASCII_GRAFFITI_27 + " " + TEKU_CLIENT_VERSION.code() + BESU_CLIENT_VERSION.code()), + Arguments.of( + CLIENT_CODES, + Optional.of(ASCII_GRAFFITI_28), + ASCII_GRAFFITI_28 + TEKU_CLIENT_VERSION.code() + BESU_CLIENT_VERSION.code()), Arguments.of(DISABLED, Optional.empty(), ""), Arguments.of(DISABLED, Optional.of("small"), "small"), Arguments.of(DISABLED, Optional.of(UTF_8_GRAFFITI_4), UTF_8_GRAFFITI_4), @@ -589,6 +588,12 @@ private static Stream getBuildGraffitiFixturesElInfoNa() { + " " + TEKU_CLIENT_VERSION.code() + TEKU_CLIENT_VERSION.commit().toUnprefixedHexString().substring(0, 2)), + Arguments.of( + AUTO, + Optional.of(ASCII_GRAFFITI_27), + ASCII_GRAFFITI_27 + " " + TEKU_CLIENT_VERSION.code()), + Arguments.of( + AUTO, Optional.of(ASCII_GRAFFITI_28), ASCII_GRAFFITI_28 + TEKU_CLIENT_VERSION.code()), Arguments.of(CLIENT_CODES, Optional.empty(), TEKU_CLIENT_VERSION.code()), Arguments.of(CLIENT_CODES, Optional.of("small"), "small " + TEKU_CLIENT_VERSION.code()), Arguments.of( @@ -599,6 +604,14 @@ private static Stream getBuildGraffitiFixturesElInfoNa() { CLIENT_CODES, Optional.of(ASCII_GRAFFITI_20), ASCII_GRAFFITI_20 + " " + TEKU_CLIENT_VERSION.code()), + Arguments.of( + CLIENT_CODES, + Optional.of(ASCII_GRAFFITI_27), + ASCII_GRAFFITI_27 + " " + TEKU_CLIENT_VERSION.code()), + Arguments.of( + CLIENT_CODES, + Optional.of(ASCII_GRAFFITI_28), + ASCII_GRAFFITI_28 + TEKU_CLIENT_VERSION.code()), Arguments.of(DISABLED, Optional.empty(), ""), Arguments.of(DISABLED, Optional.of("small"), "small"), Arguments.of(DISABLED, Optional.of(UTF_8_GRAFFITI_4), UTF_8_GRAFFITI_4), diff --git a/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/ValidatorApiHandlerTest.java b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/ValidatorApiHandlerTest.java index 4b0064117e9..d882571c41d 100644 --- a/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/ValidatorApiHandlerTest.java +++ b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/ValidatorApiHandlerTest.java @@ -24,6 +24,7 @@ import static org.mockito.Mockito.inOrder; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoInteractions; import static org.mockito.Mockito.verifyNoMoreInteractions; @@ -33,8 +34,9 @@ import static tech.pegasys.teku.infrastructure.async.SafeFutureAssert.safeJoin; import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ONE; import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ZERO; +import static tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel.EQUIVOCATION; +import static tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel.GOSSIP; import static tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel.NOT_REQUIRED; -import static tech.pegasys.teku.spec.logic.common.statetransition.results.BlockImportResult.FailureReason.DOES_NOT_DESCEND_FROM_LATEST_FINALIZED; import it.unimi.dsi.fastutil.ints.IntList; import it.unimi.dsi.fastutil.ints.IntSet; @@ -50,9 +52,9 @@ import org.apache.tuweni.bytes.Bytes32; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import org.mockito.ArgumentCaptor; import org.mockito.InOrder; import tech.pegasys.teku.api.ChainDataProvider; +import tech.pegasys.teku.api.NetworkDataProvider; import tech.pegasys.teku.api.NodeDataProvider; import tech.pegasys.teku.api.migrated.ValidatorLivenessAtEpoch; import tech.pegasys.teku.api.response.v1.beacon.ValidatorStatus; @@ -66,6 +68,7 @@ import tech.pegasys.teku.ethereum.json.types.validator.ProposerDuties; import tech.pegasys.teku.ethereum.json.types.validator.ProposerDuty; import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeDuties; +import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.ethereum.performance.trackers.BlockProductionAndPublishingPerformanceFactory; import tech.pegasys.teku.ethereum.performance.trackers.BlockProductionPerformance; import tech.pegasys.teku.infrastructure.async.SafeFuture; @@ -75,11 +78,6 @@ import tech.pegasys.teku.infrastructure.ssz.SszMutableList; import tech.pegasys.teku.infrastructure.time.StubTimeProvider; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.kzg.KZGCommitment; -import tech.pegasys.teku.kzg.KZGProof; -import tech.pegasys.teku.networking.eth2.gossip.BlobSidecarGossipChannel; -import tech.pegasys.teku.networking.eth2.gossip.BlockGossipChannel; -import tech.pegasys.teku.networking.eth2.gossip.DataColumnSidecarGossipChannel; import tech.pegasys.teku.networking.eth2.gossip.subnets.AttestationTopicSubscriber; import tech.pegasys.teku.networking.eth2.gossip.subnets.SyncCommitteeSubscriptionManager; import tech.pegasys.teku.spec.Spec; @@ -88,12 +86,8 @@ import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.config.SpecConfigAltair; import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; -import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.Blob; -import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockAndState; -import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockContainer; -import tech.pegasys.teku.spec.datastructures.blocks.versions.deneb.SignedBlockContents; import tech.pegasys.teku.spec.datastructures.builder.SignedValidatorRegistration; import tech.pegasys.teku.spec.datastructures.builder.ValidatorRegistration; import tech.pegasys.teku.spec.datastructures.metadata.BlockContainerAndMetaData; @@ -102,22 +96,16 @@ import tech.pegasys.teku.spec.datastructures.operations.AttestationData; import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SignedContributionAndProof; +import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeContribution; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeMessage; import tech.pegasys.teku.spec.datastructures.state.Checkpoint; import tech.pegasys.teku.spec.datastructures.state.CheckpointState; import tech.pegasys.teku.spec.datastructures.state.Validator; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; -import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; -import tech.pegasys.teku.spec.datastructures.type.SszKZGProof; -import tech.pegasys.teku.spec.logic.common.statetransition.results.BlockImportResult; import tech.pegasys.teku.spec.logic.common.util.SyncCommitteeUtil; -import tech.pegasys.teku.spec.logic.versions.deneb.helpers.MiscHelpersDeneb; import tech.pegasys.teku.spec.util.DataStructureUtil; import tech.pegasys.teku.statetransition.attestation.AggregatingAttestationPool; import tech.pegasys.teku.statetransition.attestation.AttestationManager; -import tech.pegasys.teku.statetransition.blobs.BlockBlobSidecarsTrackersPool; -import tech.pegasys.teku.statetransition.block.BlockImportChannel; -import tech.pegasys.teku.statetransition.block.BlockImportChannel.BlockImportAndBroadcastValidationResults; import tech.pegasys.teku.statetransition.forkchoice.ForkChoiceTrigger; import tech.pegasys.teku.statetransition.forkchoice.ProposersDataManager; import tech.pegasys.teku.statetransition.synccommittee.SyncCommitteeContributionPool; @@ -129,8 +117,8 @@ import tech.pegasys.teku.validator.api.NodeSyncingException; import tech.pegasys.teku.validator.api.SendSignedBlockResult; import tech.pegasys.teku.validator.api.SubmitDataError; -import tech.pegasys.teku.validator.api.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.validator.coordinator.performance.DefaultPerformanceTracker; +import tech.pegasys.teku.validator.coordinator.publisher.BlockPublisher; class ValidatorApiHandlerTest { @@ -145,18 +133,12 @@ class ValidatorApiHandlerTest { private final AttestationTopicSubscriber attestationTopicSubscriptions = mock(AttestationTopicSubscriber.class); private final ActiveValidatorTracker activeValidatorTracker = mock(ActiveValidatorTracker.class); - private final BlockImportChannel blockImportChannel = mock(BlockImportChannel.class); - private final BlockGossipChannel blockGossipChannel = mock(BlockGossipChannel.class); - private final BlockBlobSidecarsTrackersPool blockBlobSidecarsTrackersPool = - mock(BlockBlobSidecarsTrackersPool.class); - private final BlobSidecarGossipChannel blobSidecarGossipChannel = - mock(BlobSidecarGossipChannel.class); - private final DataColumnSidecarGossipChannel dataColumnSidecarGossipChannel = - mock(DataColumnSidecarGossipChannel.class); + private final BlockPublisher blockPublisher = mock(BlockPublisher.class); private final DefaultPerformanceTracker performanceTracker = mock(DefaultPerformanceTracker.class); private final ChainDataProvider chainDataProvider = mock(ChainDataProvider.class); private final NodeDataProvider nodeDataProvider = mock(NodeDataProvider.class); + private final NetworkDataProvider networkDataProvider = mock(NetworkDataProvider.class); private final DutyMetrics dutyMetrics = mock(DutyMetrics.class); private final ForkChoiceTrigger forkChoiceTrigger = mock(ForkChoiceTrigger.class); private final ProposersDataManager proposersDataManager = mock(ProposersDataManager.class); @@ -167,17 +149,9 @@ class ValidatorApiHandlerTest { private final SyncCommitteeSubscriptionManager syncCommitteeSubscriptionManager = mock(SyncCommitteeSubscriptionManager.class); - @SuppressWarnings("unchecked") - private final ArgumentCaptor> blobSidecarsCaptor1 = - ArgumentCaptor.forClass(List.class); - - @SuppressWarnings("unchecked") - private final ArgumentCaptor> blobSidecarsCaptor2 = - ArgumentCaptor.forClass(List.class); - private final BlockProductionAndPublishingPerformanceFactory blockProductionPerformanceFactory = new BlockProductionAndPublishingPerformanceFactory( - StubTimeProvider.withTimeInMillis(0), __ -> ZERO, false, 0, 0); + StubTimeProvider.withTimeInMillis(0), __ -> ZERO, false, 0, 0, 0, 0); private Spec spec; private UInt64 epochStartSlot; @@ -198,14 +172,10 @@ public void setUp() { new ValidatorApiHandler( chainDataProvider, nodeDataProvider, + networkDataProvider, chainDataClient, syncStateProvider, blockFactory, - blockImportChannel, - blockGossipChannel, - blockBlobSidecarsTrackersPool, - blobSidecarGossipChannel, - dataColumnSidecarGossipChannel, attestationPool, attestationManager, attestationTopicSubscriptions, @@ -218,7 +188,8 @@ public void setUp() { syncCommitteeMessagePool, syncCommitteeContributionPool, syncCommitteeSubscriptionManager, - blockProductionPerformanceFactory); + blockProductionPerformanceFactory, + blockPublisher); when(syncStateProvider.getCurrentSyncState()).thenReturn(SyncState.IN_SYNC); when(forkChoiceTrigger.prepareForBlockProduction(any(), any())).thenReturn(SafeFuture.COMPLETE); @@ -453,14 +424,10 @@ void getSyncCommitteeDuties_shouldNotUseEpochPriorToFork() { new ValidatorApiHandler( chainDataProvider, nodeDataProvider, + networkDataProvider, chainDataClient, syncStateProvider, blockFactory, - blockImportChannel, - blockGossipChannel, - blockBlobSidecarsTrackersPool, - blobSidecarGossipChannel, - dataColumnSidecarGossipChannel, attestationPool, attestationManager, attestationTopicSubscriptions, @@ -473,7 +440,8 @@ void getSyncCommitteeDuties_shouldNotUseEpochPriorToFork() { syncCommitteeMessagePool, syncCommitteeContributionPool, syncCommitteeSubscriptionManager, - blockProductionPerformanceFactory); + blockProductionPerformanceFactory, + blockPublisher); // Best state is still in Phase0 final BeaconState state = dataStructureUtil.stateBuilderPhase0().slot(previousEpochStartSlot.minus(1)).build(); @@ -495,11 +463,7 @@ public void createUnsignedBlock_shouldFailWhenNodeIsSyncing() { nodeIsSyncing(); final SafeFuture> result = validatorApiHandler.createUnsignedBlock( - ONE, - dataStructureUtil.randomSignature(), - Optional.empty(), - Optional.of(false), - Optional.of(ONE)); + ONE, dataStructureUtil.randomSignature(), Optional.empty(), Optional.of(ONE)); assertThat(result).isCompletedExceptionally(); assertThatThrownBy(result::get).hasRootCauseInstanceOf(NodeSyncingException.class); @@ -516,11 +480,7 @@ public void createUnsignedBlock_shouldFailWhenParentBlockIsOptimistic() { final SafeFuture> result = validatorApiHandler.createUnsignedBlock( - newSlot, - dataStructureUtil.randomSignature(), - Optional.empty(), - Optional.of(false), - Optional.of(ONE)); + newSlot, dataStructureUtil.randomSignature(), Optional.empty(), Optional.of(ONE)); assertThat(result).isCompletedExceptionally(); assertThatThrownBy(result::get).hasRootCauseInstanceOf(NodeSyncingException.class); @@ -542,7 +502,6 @@ public void createUnsignedBlock_shouldCreateBlock() { newSlot, randaoReveal, Optional.empty(), - Optional.of(false), Optional.of(ONE), BlockProductionPerformance.NOOP)) .thenReturn(SafeFuture.completedFuture(blockContainerAndMetaData)); @@ -550,20 +509,78 @@ public void createUnsignedBlock_shouldCreateBlock() { // even if passing a non-empty requestedBlinded and requestedBuilderBoostFactor isn't a valid // combination, // we still want to check that all parameters are passed down the line to the block factory - final SafeFuture> result = + SafeFuture> result = validatorApiHandler.createUnsignedBlock( - newSlot, randaoReveal, Optional.empty(), Optional.of(false), Optional.of(ONE)); + newSlot, randaoReveal, Optional.empty(), Optional.of(ONE)); + + assertThat(result).isCompletedWithValue(Optional.of(blockContainerAndMetaData)); + // further calls in the same slot should return the same block + result = + validatorApiHandler.createUnsignedBlock( + newSlot, randaoReveal, Optional.empty(), Optional.of(ONE)); + + assertThat(result).isCompletedWithValue(Optional.of(blockContainerAndMetaData)); + + // only produced once verify(blockFactory) .createUnsignedBlock( blockSlotState, newSlot, randaoReveal, Optional.empty(), - Optional.of(false), Optional.of(ONE), BlockProductionPerformance.NOOP); + + verify(performanceTracker).reportBlockProductionAttempt(spec.computeEpochAtSlot(newSlot)); + verify(performanceTracker) + .saveProducedBlock( + blockContainerAndMetaData.blockContainer().getBlock().getSlotAndBlockRoot()); + } + + @Test + public void createUnsignedBlock_shouldAllowProducingBlockTwiceIfFirstAttemptFailed() { + final UInt64 newSlot = UInt64.valueOf(25); + final BeaconState blockSlotState = dataStructureUtil.randomBeaconState(newSlot); + final BLSSignature randaoReveal = dataStructureUtil.randomSignature(); + final BlockContainerAndMetaData blockContainerAndMetaData = + dataStructureUtil.randomBlockContainerAndMetaData(newSlot); + + when(chainDataClient.getStateForBlockProduction(newSlot, false)) + .thenReturn(SafeFuture.completedFuture(Optional.of(blockSlotState))); + when(blockFactory.createUnsignedBlock( + blockSlotState, + newSlot, + randaoReveal, + Optional.empty(), + Optional.of(ONE), + BlockProductionPerformance.NOOP)) + .thenThrow(new IllegalStateException("oopsy")) + .thenReturn(SafeFuture.completedFuture(blockContainerAndMetaData)); + + // first call should fail + SafeFuture> result = + validatorApiHandler.createUnsignedBlock( + newSlot, randaoReveal, Optional.empty(), Optional.of(ONE)); + + assertThat(result).isCompletedExceptionally(); + + // second call in the same slot should succeed and return the block + result = + validatorApiHandler.createUnsignedBlock( + newSlot, randaoReveal, Optional.empty(), Optional.of(ONE)); + assertThat(result).isCompletedWithValue(Optional.of(blockContainerAndMetaData)); + + // attempted to produce twice + verify(blockFactory, times(2)) + .createUnsignedBlock( + blockSlotState, + newSlot, + randaoReveal, + Optional.empty(), + Optional.of(ONE), + BlockProductionPerformance.NOOP); } @Test @@ -695,7 +712,18 @@ public void createAggregate_shouldFailWhenNodeIsSyncing() { nodeIsSyncing(); final SafeFuture> result = validatorApiHandler.createAggregate( - ONE, dataStructureUtil.randomAttestationData().hashTreeRoot()); + ONE, dataStructureUtil.randomAttestationData().hashTreeRoot(), Optional.empty()); + + assertThat(result).isCompletedExceptionally(); + assertThatThrownBy(result::get).hasRootCauseInstanceOf(NodeSyncingException.class); + } + + @Test + public void createSyncCommitteeContribution() { + nodeIsSyncing(); + final SafeFuture> result = + validatorApiHandler.createSyncCommitteeContribution( + ONE, 0, dataStructureUtil.randomBytes32()); assertThat(result).isCompletedExceptionally(); assertThatThrownBy(result::get).hasRootCauseInstanceOf(NodeSyncingException.class); @@ -705,12 +733,15 @@ public void createAggregate_shouldFailWhenNodeIsSyncing() { public void createAggregate_shouldReturnAggregateFromAttestationPool() { final AttestationData attestationData = dataStructureUtil.randomAttestationData(); final Optional aggregate = Optional.of(dataStructureUtil.randomAttestation()); - when(attestationPool.createAggregateFor(eq(attestationData.hashTreeRoot()))) + when(attestationPool.createAggregateFor( + eq(attestationData.hashTreeRoot()), eq(Optional.empty()))) .thenReturn(aggregate.map(attestation -> ValidatableAttestation.from(spec, attestation))); assertThat( validatorApiHandler.createAggregate( - aggregate.get().getData().getSlot(), attestationData.hashTreeRoot())) + aggregate.get().getData().getSlot(), + attestationData.hashTreeRoot(), + Optional.empty())) .isCompletedWithValue(aggregate); } @@ -841,143 +872,76 @@ private ValidatableAttestation validatableAttestationOf(final Attestation validA } @Test - public void sendSignedBlock_shouldConvertSuccessfulResult() { + public void sendSignedBlock_shouldPublish() { final SignedBeaconBlock block = dataStructureUtil.randomSignedBeaconBlock(5); - when(blockImportChannel.importBlock(block, NOT_REQUIRED)) - .thenReturn(prepareBlockImportResult(BlockImportResult.successful(block))); + when(blockPublisher.sendSignedBlock(eq(block), eq(NOT_REQUIRED), any())) + .thenReturn(SafeFuture.completedFuture(SendSignedBlockResult.success(block.getRoot()))); final SafeFuture result = validatorApiHandler.sendSignedBlock(block, NOT_REQUIRED); - verify(blockGossipChannel).publishBlock(block); - verify(blockImportChannel).importBlock(block, NOT_REQUIRED); assertThat(result).isCompletedWithValue(SendSignedBlockResult.success(block.getRoot())); } @Test - public void sendSignedBlock_shouldConvertFailedResult() { + public void sendSignedBlock_shouldCatchPublishFailure() { final SignedBeaconBlock block = dataStructureUtil.randomSignedBeaconBlock(5); - when(blockImportChannel.importBlock(block, NOT_REQUIRED)) - .thenReturn(prepareBlockImportResult(BlockImportResult.FAILED_INVALID_ANCESTRY)); + when(blockPublisher.sendSignedBlock(eq(block), eq(NOT_REQUIRED), any())) + .thenReturn(SafeFuture.failedFuture(new RuntimeException("Failed to publish block"))); final SafeFuture result = validatorApiHandler.sendSignedBlock(block, NOT_REQUIRED); - verify(blockGossipChannel).publishBlock(block); - verify(blockImportChannel).importBlock(block, NOT_REQUIRED); assertThat(result) - .isCompletedWithValue( - SendSignedBlockResult.notImported(DOES_NOT_DESCEND_FROM_LATEST_FINALIZED.name())); + .isCompletedWithValue(SendSignedBlockResult.rejected("Failed to publish block")); } @Test - public void sendSignedBlock_shouldConvertKnownBlockResult() { - final SignedBeaconBlock block = dataStructureUtil.randomSignedBeaconBlock(5); - when(blockImportChannel.importBlock(block, NOT_REQUIRED)) - .thenReturn(prepareBlockImportResult(BlockImportResult.knownBlock(block, false))); - final SafeFuture result = - validatorApiHandler.sendSignedBlock(block, NOT_REQUIRED); + public void + sendSignedBlock_shouldOnlyDoEquivocationValidationIfBlockIsLocallyCreatedAngGossipValidationRequested() { + // creating a block first in order to cache the block root + final UInt64 newSlot = UInt64.valueOf(25); + final BeaconState blockSlotState = dataStructureUtil.randomBeaconState(newSlot); + final BLSSignature randaoReveal = dataStructureUtil.randomSignature(); + final BlockContainerAndMetaData blockContainerAndMetaData = + dataStructureUtil.randomBlockContainerAndMetaData(newSlot); - verify(blockGossipChannel).publishBlock(block); - verify(blockImportChannel).importBlock(block, NOT_REQUIRED); - assertThat(result).isCompletedWithValue(SendSignedBlockResult.success(block.getRoot())); - } + when(chainDataClient.getStateForBlockProduction(newSlot, false)) + .thenReturn(SafeFuture.completedFuture(Optional.of(blockSlotState))); + when(blockFactory.createUnsignedBlock( + blockSlotState, + newSlot, + randaoReveal, + Optional.empty(), + Optional.of(ONE), + BlockProductionPerformance.NOOP)) + .thenReturn(SafeFuture.completedFuture(blockContainerAndMetaData)); - @Test - public void sendSignedBlock_shouldConvertBlockContentsSuccessfulResult() { - setupDeneb(); - final SignedBlockContents blockContents = - dataStructureUtil.randomSignedBlockContents(UInt64.valueOf(5)); - final SignedBeaconBlock block = blockContents.getSignedBlock(); - final List expectedBlobSidecars = - BlobSidecarSummary.fromSignedBlockContents(blockContents); - - when(blockImportChannel.importBlock(block, NOT_REQUIRED)) - .thenReturn(prepareBlockImportResult(BlockImportResult.successful(block))); - final SafeFuture result = - validatorApiHandler.sendSignedBlock(blockContents, NOT_REQUIRED); - - verify(blobSidecarGossipChannel).publishBlobSidecars(blobSidecarsCaptor1.capture()); - assertThat(BlobSidecarSummary.fromBlobSidecars(blobSidecarsCaptor1.getValue())) - .isEqualTo(expectedBlobSidecars); - verify(blockBlobSidecarsTrackersPool) - .onCompletedBlockAndBlobSidecars(eq(block), blobSidecarsCaptor2.capture()); - assertThat(BlobSidecarSummary.fromBlobSidecars(blobSidecarsCaptor2.getValue())) - .isEqualTo(expectedBlobSidecars); - verify(blockGossipChannel).publishBlock(block); - verify(blockImportChannel).importBlock(block, NOT_REQUIRED); - assertThat(result).isCompletedWithValue(SendSignedBlockResult.success(block.getRoot())); - } + assertThat( + validatorApiHandler.createUnsignedBlock( + newSlot, randaoReveal, Optional.empty(), Optional.of(ONE))) + .isCompleted(); - @Test - public void sendSignedBlock_shouldConvertBlockContentsFailedResult() { - setupDeneb(); - final SignedBlockContents blockContents = - dataStructureUtil.randomSignedBlockContents(UInt64.valueOf(5)); - final SignedBeaconBlock block = blockContents.getSignedBlock(); - final List expectedBlobSidecars = - BlobSidecarSummary.fromSignedBlockContents(blockContents); - - when(blockImportChannel.importBlock(block, NOT_REQUIRED)) - .thenReturn(prepareBlockImportResult(BlockImportResult.FAILED_INVALID_ANCESTRY)); + final SignedBeaconBlock block = + dataStructureUtil + .getSpec() + .atSlot(newSlot) + .getSchemaDefinitions() + .getSignedBeaconBlockSchema() + .create( + blockContainerAndMetaData.blockContainer().getBlock(), + dataStructureUtil.randomSignature()); + + when(blockPublisher.sendSignedBlock(eq(block), eq(EQUIVOCATION), any())) + .thenReturn(SafeFuture.completedFuture(SendSignedBlockResult.success(block.getRoot()))); + + // require GOSSIP validation final SafeFuture result = - validatorApiHandler.sendSignedBlock(blockContents, NOT_REQUIRED); - - verify(blobSidecarGossipChannel).publishBlobSidecars(blobSidecarsCaptor1.capture()); - assertThat(BlobSidecarSummary.fromBlobSidecars(blobSidecarsCaptor1.getValue())) - .isEqualTo(expectedBlobSidecars); - verify(blockBlobSidecarsTrackersPool) - .onCompletedBlockAndBlobSidecars(eq(block), blobSidecarsCaptor2.capture()); - assertThat(BlobSidecarSummary.fromBlobSidecars(blobSidecarsCaptor2.getValue())) - .isEqualTo(expectedBlobSidecars); - verify(blockGossipChannel).publishBlock(block); - verify(blockImportChannel).importBlock(block, NOT_REQUIRED); - assertThat(result) - .isCompletedWithValue( - SendSignedBlockResult.notImported(DOES_NOT_DESCEND_FROM_LATEST_FINALIZED.name())); - } + validatorApiHandler.sendSignedBlock(block, GOSSIP); - @Test - public void sendSignedBlockForDeneb_shouldConvertBlockContentsKnownBlockResult() { - setupDeneb(); - final SignedBlockContents blockContents = - dataStructureUtil.randomSignedBlockContents(UInt64.valueOf(5)); - final SignedBeaconBlock block = blockContents.getSignedBlock(); - final List expectedBlobSidecars = - BlobSidecarSummary.fromSignedBlockContents(blockContents); - - when(blockImportChannel.importBlock(block, NOT_REQUIRED)) - .thenReturn(prepareBlockImportResult(BlockImportResult.knownBlock(block, false))); - final SafeFuture result = - validatorApiHandler.sendSignedBlock(blockContents, NOT_REQUIRED); - - verify(blobSidecarGossipChannel).publishBlobSidecars(blobSidecarsCaptor1.capture()); - assertThat(BlobSidecarSummary.fromBlobSidecars(blobSidecarsCaptor1.getValue())) - .isEqualTo(expectedBlobSidecars); - verify(blockBlobSidecarsTrackersPool) - .onCompletedBlockAndBlobSidecars(eq(block), blobSidecarsCaptor2.capture()); - assertThat(BlobSidecarSummary.fromBlobSidecars(blobSidecarsCaptor2.getValue())) - .isEqualTo(expectedBlobSidecars); - verify(blockGossipChannel).publishBlock(block); - verify(blockImportChannel).importBlock(block, NOT_REQUIRED); assertThat(result).isCompletedWithValue(SendSignedBlockResult.success(block.getRoot())); - } - @Test - public void sendSignedBlock_shouldGossipAndImportEmptyBlobSidecarsWhenBlobsDoNotExist() { - setupDeneb(); - final SignedBeaconBlock block = dataStructureUtil.randomSignedBeaconBlock(5); - - when(blockImportChannel.importBlock(block, NOT_REQUIRED)) - .thenReturn(prepareBlockImportResult(BlockImportResult.successful(block))); - final SafeFuture result = - validatorApiHandler.sendSignedBlock(block, NOT_REQUIRED); - safeJoin(result); - - verify(blockBlobSidecarsTrackersPool).onCompletedBlockAndBlobSidecars(block, List.of()); - verify(blobSidecarGossipChannel).publishBlobSidecars(List.of()); - verify(blockGossipChannel).publishBlock(block); - verify(blockImportChannel).importBlock(block, NOT_REQUIRED); - assertThat(result).isCompletedWithValue(SendSignedBlockResult.success(block.getRoot())); + // for locally created blocks, the validation level should have been changed to EQUIVOCATION + verify(blockPublisher).sendSignedBlock(eq(block), eq(EQUIVOCATION), any()); } @Test @@ -1215,11 +1179,11 @@ public void getSyncCommitteeSelectionProofShouldNotBeImplementedByBeaconNode() { } private boolean validatorIsLive( - List validatorLivenessAtEpochs, UInt64 validatorIndex) { + final List validatorLivenessAtEpochs, final UInt64 validatorIndex) { return validatorLivenessAtEpochs.stream() .anyMatch( validatorLivenessAtEpoch -> - validatorLivenessAtEpoch.getIndex().equals(validatorIndex) + validatorLivenessAtEpoch.index().equals(validatorIndex) && validatorLivenessAtEpoch.isLive()); } @@ -1290,110 +1254,4 @@ private void setupValidatorsState( when(chainDataProvider.getStateValidators("head", validators, new HashSet<>())) .thenReturn(SafeFuture.completedFuture(Optional.of(stateValidators))); } - - private void setupDeneb() { - this.spec = TestSpecFactory.createMinimalDeneb(); - this.epochStartSlot = spec.computeStartSlotAtEpoch(EPOCH); - this.previousEpochStartSlot = spec.computeStartSlotAtEpoch(PREVIOUS_EPOCH); - this.dataStructureUtil = new DataStructureUtil(spec); - this.validatorApiHandler = - new ValidatorApiHandler( - chainDataProvider, - nodeDataProvider, - chainDataClient, - syncStateProvider, - blockFactory, - blockImportChannel, - blockGossipChannel, - blockBlobSidecarsTrackersPool, - blobSidecarGossipChannel, - dataColumnSidecarGossipChannel, - attestationPool, - attestationManager, - attestationTopicSubscriptions, - activeValidatorTracker, - dutyMetrics, - performanceTracker, - spec, - forkChoiceTrigger, - proposersDataManager, - syncCommitteeMessagePool, - syncCommitteeContributionPool, - syncCommitteeSubscriptionManager, - blockProductionPerformanceFactory); - - // BlobSidecar builder - doAnswer( - invocation -> { - final SignedBlockContainer blockContainer = invocation.getArgument(0); - final MiscHelpersDeneb miscHelpersDeneb = - MiscHelpersDeneb.required(spec.forMilestone(SpecMilestone.DENEB).miscHelpers()); - if (blockContainer.getBlobs().isEmpty()) { - return List.of(); - } - final SszList blobs = blockContainer.getBlobs().orElseThrow(); - final SszList proofs = blockContainer.getKzgProofs().orElseThrow(); - return IntStream.range(0, blobs.size()) - .mapToObj( - index -> - miscHelpersDeneb.constructBlobSidecar( - blockContainer.getSignedBlock(), - UInt64.valueOf(index), - blobs.get(index), - proofs.get(index))) - .toList(); - }) - .when(blockFactory) - .createBlobSidecars(any(), any()); - } - - private SafeFuture prepareBlockImportResult( - final BlockImportResult blockImportResult) { - return SafeFuture.completedFuture( - new BlockImportAndBroadcastValidationResults( - SafeFuture.completedFuture(blockImportResult))); - } - - private record BlobSidecarSummary( - Blob blob, KZGProof kzgProof, KZGCommitment commitment, Bytes32 blockRoot) { - static List fromSignedBlockContents( - final SignedBlockContents signedBlockContents) { - final List blobs = signedBlockContents.getBlobs().orElseThrow().asList(); - final List proofs = - signedBlockContents.getKzgProofs().orElseThrow().stream() - .map(SszKZGProof::getKZGProof) - .toList(); - final List commitments = - signedBlockContents - .getSignedBlock() - .getMessage() - .getBody() - .getOptionalBlobKzgCommitments() - .orElseThrow() - .stream() - .map(SszKZGCommitment::getKZGCommitment) - .toList(); - return IntStream.range(0, blobs.size()) - .mapToObj( - index -> - new BlobSidecarSummary( - blobs.get(index), - proofs.get(index), - commitments.get(index), - signedBlockContents.getRoot())) - .toList(); - } - - static List fromBlobSidecars(final List blobSidecars) { - return blobSidecars.stream() - .map( - blobSidecar -> - new BlobSidecarSummary( - blobSidecar.getBlob(), - blobSidecar.getKZGProof(), - blobSidecar.getKZGCommitment(), - blobSidecar.getBlockRoot())) - .toList(); - } - } } diff --git a/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/performance/DefaultPerformanceTrackerTest.java b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/performance/DefaultPerformanceTrackerTest.java index 84ebdd0974c..1fee82b765d 100644 --- a/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/performance/DefaultPerformanceTrackerTest.java +++ b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/performance/DefaultPerformanceTrackerTest.java @@ -24,39 +24,37 @@ import static tech.pegasys.teku.validator.coordinator.performance.DefaultPerformanceTracker.ATTESTATION_INCLUSION_RANGE; import java.util.List; +import java.util.Optional; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestTemplate; import tech.pegasys.infrastructure.logging.LogCaptor; import tech.pegasys.teku.bls.BLSKeyGenerator; import tech.pegasys.teku.bls.BLSKeyPair; -import tech.pegasys.teku.bls.BLSTestUtil; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.logging.StatusLogger; import tech.pegasys.teku.infrastructure.metrics.SettableGauge; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider; import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockAndState; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.generator.AttestationGenerator; import tech.pegasys.teku.spec.generator.ChainBuilder; import tech.pegasys.teku.spec.util.DataStructureUtil; +import tech.pegasys.teku.storage.client.ChainHead; import tech.pegasys.teku.storage.client.ChainUpdater; +import tech.pegasys.teku.storage.client.CombinedChainDataClient; import tech.pegasys.teku.storage.storageSystem.InMemoryStorageSystemBuilder; import tech.pegasys.teku.storage.storageSystem.StorageSystem; import tech.pegasys.teku.validator.api.ValidatorPerformanceTrackingMode; import tech.pegasys.teku.validator.coordinator.ActiveValidatorTracker; +@TestSpecContext(milestone = {SpecMilestone.PHASE0, SpecMilestone.ELECTRA}) public class DefaultPerformanceTrackerTest { private static final List VALIDATOR_KEYS = BLSKeyGenerator.generateKeyPairs(64); - private final Spec spec = TestSpecFactory.createMinimalPhase0(); - protected StorageSystem storageSystem = InMemoryStorageSystemBuilder.buildDefault(spec); - protected ChainBuilder chainBuilder = ChainBuilder.create(spec, VALIDATOR_KEYS); - protected ChainUpdater chainUpdater = - new ChainUpdater(storageSystem.recentChainData(), chainBuilder); - - private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); private final StatusLogger log = mock(StatusLogger.class); private final ActiveValidatorTracker validatorTracker = mock(ActiveValidatorTracker.class); private final SyncCommitteePerformanceTracker syncCommitteePerformanceTracker = @@ -64,19 +62,34 @@ public class DefaultPerformanceTrackerTest { private final ValidatorPerformanceMetrics validatorPerformanceMetrics = mock(ValidatorPerformanceMetrics.class); - private final DefaultPerformanceTracker performanceTracker = - new DefaultPerformanceTracker( - storageSystem.combinedChainDataClient(), - log, - validatorPerformanceMetrics, - ValidatorPerformanceTrackingMode.ALL, - validatorTracker, - syncCommitteePerformanceTracker, - spec, - mock(SettableGauge.class)); + private Spec spec; + private StorageSystem storageSystem; + private ChainBuilder chainBuilder; + private ChainUpdater chainUpdater; + private DataStructureUtil dataStructureUtil; + private DefaultPerformanceTracker performanceTracker; @BeforeEach - void beforeEach() { + void beforeEach(final TestSpecInvocationContextProvider.SpecContext specContext) { + spec = specContext.getSpec(); + dataStructureUtil = specContext.getDataStructureUtil(); + + storageSystem = InMemoryStorageSystemBuilder.buildDefault(spec); + chainBuilder = ChainBuilder.create(spec, VALIDATOR_KEYS); + + chainUpdater = new ChainUpdater(storageSystem.recentChainData(), chainBuilder, spec); + + performanceTracker = + new DefaultPerformanceTracker( + storageSystem.combinedChainDataClient(), + log, + validatorPerformanceMetrics, + ValidatorPerformanceTrackingMode.ALL, + validatorTracker, + syncCommitteePerformanceTracker, + spec, + mock(SettableGauge.class)); + when(validatorTracker.getNumberOfValidatorsForEpoch(any())).thenReturn(0); when(syncCommitteePerformanceTracker.calculatePerformance(any())) .thenReturn( @@ -85,45 +98,50 @@ void beforeEach() { performanceTracker.start(UInt64.ZERO); } - @Test + @TestTemplate void shouldDisplayPerfectBlockInclusion() { chainUpdater.updateBestBlock(chainUpdater.advanceChainUntil(10)); performanceTracker.reportBlockProductionAttempt(spec.computeEpochAtSlot(UInt64.valueOf(1))); performanceTracker.reportBlockProductionAttempt(spec.computeEpochAtSlot(UInt64.valueOf(2))); - performanceTracker.saveProducedBlock(chainUpdater.chainBuilder.getBlockAtSlot(1)); - performanceTracker.saveProducedBlock(chainUpdater.chainBuilder.getBlockAtSlot(2)); + performanceTracker.saveProducedBlock( + chainUpdater.chainBuilder.getBlockAtSlot(1).getSlotAndBlockRoot()); + performanceTracker.saveProducedBlock( + chainUpdater.chainBuilder.getBlockAtSlot(2).getSlotAndBlockRoot()); performanceTracker.onSlot(spec.computeStartSlotAtEpoch(UInt64.ONE)); BlockPerformance expectedBlockPerformance = new BlockPerformance(UInt64.ZERO, 2, 2, 2); verify(log).performance(expectedBlockPerformance.toString()); } - @Test + @TestTemplate void shouldDisplayBlockInclusionWhenProducedBlockIsChainHead() { final UInt64 lastSlot = spec.computeStartSlotAtEpoch(UInt64.ONE); final SignedBlockAndState bestBlock = chainUpdater.advanceChainUntil(2); chainUpdater.updateBestBlock(bestBlock); performanceTracker.reportBlockProductionAttempt(spec.computeEpochAtSlot(bestBlock.getSlot())); - performanceTracker.saveProducedBlock(bestBlock.getBlock()); + performanceTracker.saveProducedBlock(bestBlock.getBlock().getSlotAndBlockRoot()); performanceTracker.onSlot(lastSlot); BlockPerformance expectedBlockPerformance = new BlockPerformance(UInt64.ZERO, 1, 1, 1); verify(log).performance(expectedBlockPerformance.toString()); } - @Test + @TestTemplate void shouldDisplayOneMissedBlock() { chainUpdater.updateBestBlock(chainUpdater.advanceChainUntil(10)); performanceTracker.reportBlockProductionAttempt(spec.computeEpochAtSlot(UInt64.valueOf(1))); performanceTracker.reportBlockProductionAttempt(spec.computeEpochAtSlot(UInt64.valueOf(2))); performanceTracker.reportBlockProductionAttempt(spec.computeEpochAtSlot(UInt64.valueOf(3))); - performanceTracker.saveProducedBlock(chainUpdater.chainBuilder.getBlockAtSlot(1)); - performanceTracker.saveProducedBlock(chainUpdater.chainBuilder.getBlockAtSlot(2)); - performanceTracker.saveProducedBlock(dataStructureUtil.randomSignedBeaconBlock(3)); + performanceTracker.saveProducedBlock( + chainUpdater.chainBuilder.getBlockAtSlot(1).getSlotAndBlockRoot()); + performanceTracker.saveProducedBlock( + chainUpdater.chainBuilder.getBlockAtSlot(2).getSlotAndBlockRoot()); + performanceTracker.saveProducedBlock( + dataStructureUtil.randomSignedBeaconBlock(3).getSlotAndBlockRoot()); performanceTracker.onSlot(spec.computeStartSlotAtEpoch(UInt64.ONE)); BlockPerformance expectedBlockPerformance = new BlockPerformance(UInt64.ZERO, 3, 2, 3); verify(log).performance(expectedBlockPerformance.toString()); } - @Test + @TestTemplate void shouldDisplayPerfectAttestationInclusion() { chainUpdater.updateBestBlock(chainUpdater.advanceChainUntil(1)); @@ -146,7 +164,7 @@ void shouldDisplayPerfectAttestationInclusion() { verify(log).performance(expectedAttestationPerformance.toString()); } - @Test + @TestTemplate void shouldDisplayInclusionDistanceOfMax2Min1() { chainUpdater.updateBestBlock(chainUpdater.advanceChainUntil(1)); @@ -175,7 +193,7 @@ void shouldDisplayInclusionDistanceOfMax2Min1() { verify(log).performance(expectedAttestationPerformance.toString()); } - @Test + @TestTemplate void shouldDisplayIncorrectTargetRoot() { chainUpdater.updateBestBlock(chainUpdater.advanceChainUntil(1)); @@ -214,7 +232,7 @@ void shouldDisplayIncorrectTargetRoot() { verify(log).performance(expectedAttestationPerformance.toString()); } - @Test + @TestTemplate void shouldDisplayIncorrectHeadBlockRoot() { chainUpdater.updateBestBlock(chainUpdater.advanceChainUntil(1)); @@ -230,7 +248,9 @@ void shouldDisplayIncorrectHeadBlockRoot() { chainUpdater.saveBlock(blockAndState1); chainUpdater.updateBestBlock(blockAndState1); - SignedBlockAndState blockAndState = chainUpdaterFork.advanceChainUntil(8); + chainUpdaterFork.advanceChainUntil(7); + SignedBlockAndState blockAndState = chainBuilder.getBlockAndStateAtSlot(8); + chainUpdaterFork.updateBestBlock(blockAndState); ChainBuilder.BlockOptions block2Options = ChainBuilder.BlockOptions.create(); AttestationGenerator attestationGenerator = new AttestationGenerator(spec, chainBuilder.getValidatorKeys()); @@ -253,27 +273,60 @@ void shouldDisplayIncorrectHeadBlockRoot() { verify(log).performance(expectedAttestationPerformance.toString()); } - @Test + @TestTemplate void shouldClearOldSentObjects() { chainUpdater.updateBestBlock(chainUpdater.advanceChainUntil(10)); performanceTracker.reportBlockProductionAttempt(spec.computeEpochAtSlot(UInt64.valueOf(1))); performanceTracker.reportBlockProductionAttempt(spec.computeEpochAtSlot(UInt64.valueOf(2))); - performanceTracker.saveProducedBlock(chainUpdater.chainBuilder.getBlockAtSlot(1)); - performanceTracker.saveProducedBlock(chainUpdater.chainBuilder.getBlockAtSlot(2)); - performanceTracker.saveProducedAttestation( - spec.getGenesisSchemaDefinitions() - .getAttestationSchema() - .create( - dataStructureUtil.randomBitlist(), - dataStructureUtil.randomAttestationData(UInt64.ONE), - BLSTestUtil.randomSignature(0))); + performanceTracker.saveProducedBlock( + chainUpdater.chainBuilder.getBlockAtSlot(1).getSlotAndBlockRoot()); + performanceTracker.saveProducedBlock( + chainUpdater.chainBuilder.getBlockAtSlot(2).getSlotAndBlockRoot()); + performanceTracker.saveProducedAttestation(dataStructureUtil.randomAttestation(UInt64.ONE)); performanceTracker.onSlot(spec.computeStartSlotAtEpoch(UInt64.valueOf(2))); assertThat(performanceTracker.producedAttestationsByEpoch).isEmpty(); assertThat(performanceTracker.producedBlocksByEpoch).isEmpty(); assertThat(performanceTracker.blockProductionAttemptsByEpoch).isEmpty(); } - @Test + @TestTemplate + void shouldClearObjectsAfterFailure() { + chainUpdater.updateBestBlock(chainUpdater.advanceChainUntil(10)); + final CombinedChainDataClient combinedChainDataClientMock = mock(CombinedChainDataClient.class); + // Make the attestation performance calculation fail + when(combinedChainDataClientMock.getBestState()) + .thenReturn(Optional.of(SafeFuture.failedFuture(new IllegalArgumentException("failure")))); + final ChainHead chainHeadMock = mock(ChainHead.class); + // Make the block performance calculation fail + when(chainHeadMock.asStateAndBlockSummary()) + .thenReturn(SafeFuture.failedFuture(new IllegalArgumentException("failure"))); + when(combinedChainDataClientMock.getChainHead()).thenReturn(Optional.of(chainHeadMock)); + performanceTracker = + new DefaultPerformanceTracker( + combinedChainDataClientMock, + log, + validatorPerformanceMetrics, + ValidatorPerformanceTrackingMode.ALL, + validatorTracker, + syncCommitteePerformanceTracker, + spec, + mock(SettableGauge.class)); + performanceTracker.start(UInt64.ZERO); + performanceTracker.reportBlockProductionAttempt(spec.computeEpochAtSlot(UInt64.valueOf(1))); + performanceTracker.reportBlockProductionAttempt(spec.computeEpochAtSlot(UInt64.valueOf(2))); + performanceTracker.saveProducedBlock( + chainUpdater.chainBuilder.getBlockAtSlot(1).getSlotAndBlockRoot()); + performanceTracker.saveProducedBlock( + chainUpdater.chainBuilder.getBlockAtSlot(2).getSlotAndBlockRoot()); + performanceTracker.saveProducedAttestation(dataStructureUtil.randomAttestation(UInt64.ZERO)); + performanceTracker.saveProducedAttestation(dataStructureUtil.randomAttestation(UInt64.ONE)); + performanceTracker.onSlot(spec.computeStartSlotAtEpoch(UInt64.valueOf(2))); + assertThat(performanceTracker.producedAttestationsByEpoch).isEmpty(); + assertThat(performanceTracker.producedBlocksByEpoch).isEmpty(); + assertThat(performanceTracker.blockProductionAttemptsByEpoch).isEmpty(); + } + + @TestTemplate void shouldNotCountDuplicateAttestationsIncludedOnChain() { chainUpdater.updateBestBlock(chainUpdater.advanceChainUntil(1)); @@ -301,7 +354,7 @@ void shouldNotCountDuplicateAttestationsIncludedOnChain() { verify(log).performance(expectedAttestationPerformance.toString()); } - @Test + @TestTemplate void shouldNotSkipValidationForAttestationsWithSameDataButDifferentBitlists() { chainUpdater.updateBestBlock(chainUpdater.advanceChainUntil(1)); @@ -335,7 +388,7 @@ void shouldNotSkipValidationForAttestationsWithSameDataButDifferentBitlists() { verify(log).performance(expectedAttestationPerformance.toString()); } - @Test + @TestTemplate void shouldReportExpectedAttestationOnlyForTheGivenEpoch() { when(validatorTracker.getNumberOfValidatorsForEpoch(UInt64.valueOf(2))).thenReturn(2); when(validatorTracker.getNumberOfValidatorsForEpoch(UInt64.valueOf(3))).thenReturn(1); @@ -347,14 +400,14 @@ void shouldReportExpectedAttestationOnlyForTheGivenEpoch() { verify(log).performance(expectedAttestationPerformance.toString()); } - @Test + @TestTemplate void shouldNotReportAttestationPerformanceIfNoValidatorsInEpoch() { when(validatorTracker.getNumberOfValidatorsForEpoch(UInt64.valueOf(2))).thenReturn(0); performanceTracker.onSlot(spec.computeStartSlotAtEpoch(ATTESTATION_INCLUSION_RANGE.plus(2))); verify(log, never()).performance(anyString()); } - @Test + @TestTemplate void shouldReportSyncCommitteePerformance() { final UInt64 epoch = UInt64.valueOf(2); final SyncCommitteePerformance performance = new SyncCommitteePerformance(epoch, 10, 9, 8, 7); @@ -366,7 +419,7 @@ void shouldReportSyncCommitteePerformance() { verify(validatorPerformanceMetrics).updateSyncCommitteePerformance(performance); } - @Test + @TestTemplate void shouldHandleErrorsWhenReportTasksFail() { chainUpdater.updateBestBlock(chainUpdater.advanceChainUntil(1)); final Attestation attestation = createAttestationForParentBlockOnSlot(1); @@ -391,7 +444,7 @@ void shouldHandleErrorsWhenReportTasksFail() { * @param slot the slot of the block being attested * @return the created attestation */ - private Attestation createAttestationForParentBlockOnSlot(int slot) { + private Attestation createAttestationForParentBlockOnSlot(final int slot) { Attestation attestationForBlock1 = createAttestation(slot + 1, slot); ChainBuilder.BlockOptions block2Options = ChainBuilder.BlockOptions.create(); block2Options.addAttestation(attestationForBlock1); @@ -402,7 +455,9 @@ private Attestation createAttestationForParentBlockOnSlot(int slot) { } private Attestation createAttestation( - ChainBuilder chainBuilder, int validForBlockAtSlot, int vouchingForBlockAtSlot) { + final ChainBuilder chainBuilder, + final int validForBlockAtSlot, + final int vouchingForBlockAtSlot) { return chainBuilder .streamValidAttestationsForBlockAtSlot(validForBlockAtSlot) .filter( @@ -414,7 +469,8 @@ private Attestation createAttestation( .orElseThrow(); } - private Attestation createAttestation(int validForBlockAtSlot, int vouchingForBlockAtSlot) { + private Attestation createAttestation( + final int validForBlockAtSlot, final int vouchingForBlockAtSlot) { return createAttestation(chainBuilder, validForBlockAtSlot, vouchingForBlockAtSlot); } } diff --git a/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/publisher/AbstractBlockPublisherTest.java b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/publisher/AbstractBlockPublisherTest.java index 525a494599b..0b682ef444a 100644 --- a/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/publisher/AbstractBlockPublisherTest.java +++ b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/publisher/AbstractBlockPublisherTest.java @@ -13,6 +13,8 @@ package tech.pegasys.teku.validator.coordinator.publisher; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; import static org.mockito.Mockito.spy; @@ -24,7 +26,10 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import tech.pegasys.teku.ethereum.performance.trackers.BlockPublishingPerformance; +import tech.pegasys.teku.infrastructure.async.AsyncRunner; import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.async.StubAsyncRunner; +import tech.pegasys.teku.networking.eth2.gossip.BlockGossipChannel; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; @@ -32,6 +37,7 @@ import tech.pegasys.teku.spec.datastructures.blocks.versions.deneb.SignedBlockContents; import tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel; import tech.pegasys.teku.spec.logic.common.statetransition.results.BlockImportResult; +import tech.pegasys.teku.spec.logic.common.statetransition.results.BlockImportResult.FailureReason; import tech.pegasys.teku.spec.util.DataStructureUtil; import tech.pegasys.teku.statetransition.block.BlockImportChannel; import tech.pegasys.teku.statetransition.block.BlockImportChannel.BlockImportAndBroadcastValidationResults; @@ -39,20 +45,25 @@ import tech.pegasys.teku.validator.api.SendSignedBlockResult; import tech.pegasys.teku.validator.coordinator.BlockFactory; import tech.pegasys.teku.validator.coordinator.DutyMetrics; -import tech.pegasys.teku.validator.coordinator.performance.PerformanceTracker; public class AbstractBlockPublisherTest { - private final Spec spec = TestSpecFactory.createMinimalEip7594(); + private final StubAsyncRunner asyncRunner = new StubAsyncRunner(); + private final Spec spec = TestSpecFactory.createMinimalElectraEip7594(); private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); private final BlockFactory blockFactory = mock(BlockFactory.class); + private final BlockGossipChannel blockGossipChannel = mock(BlockGossipChannel.class); private final BlockImportChannel blockImportChannel = mock(BlockImportChannel.class); - private final PerformanceTracker performanceTracker = mock(PerformanceTracker.class); private final DutyMetrics dutyMetrics = mock(DutyMetrics.class); private final AbstractBlockPublisher blockPublisher = spy( new BlockPublisherTest( - blockFactory, blockImportChannel, performanceTracker, dutyMetrics)); + asyncRunner, + blockFactory, + blockGossipChannel, + blockImportChannel, + dutyMetrics, + false)); final SignedBlockContents signedBlockContents = dataStructureUtil.randomSignedBlockContents(); final SignedBeaconBlock signedBlock = signedBlockContents.getSignedBlock(); @@ -60,25 +71,19 @@ public class AbstractBlockPublisherTest { @BeforeEach public void setUp() { + when(blockPublisher.publishBlock(any(), any())).thenReturn(SafeFuture.COMPLETE); when(blockFactory.unblindSignedBlockIfBlinded(signedBlock, BlockPublishingPerformance.NOOP)) .thenReturn(SafeFuture.completedFuture(signedBlock)); - when(blockFactory.createBlobSidecars(signedBlockContents, BlockPublishingPerformance.NOOP)) - .thenReturn(blobSidecars); + when(blockFactory.createBlobSidecars(signedBlockContents)).thenReturn(blobSidecars); } @Test public void sendSignedBlock_shouldPublishImmediatelyAndImportWhenBroadcastValidationIsNotRequired() { - when(blockPublisher.importBlockAndBlobSidecars( - signedBlock, - blobSidecars, - BroadcastValidationLevel.NOT_REQUIRED, - BlockPublishingPerformance.NOOP)) - .thenReturn( - SafeFuture.completedFuture( - new BlockImportAndBroadcastValidationResults( - SafeFuture.completedFuture(BlockImportResult.successful(signedBlock))))); + when(blockPublisher.importBlock( + signedBlock, BroadcastValidationLevel.NOT_REQUIRED, BlockPublishingPerformance.NOOP)) + .thenReturn(prepareBlockImportResult(BlockImportResult.successful(signedBlock))); assertThatSafeFuture( blockPublisher.sendSignedBlock( @@ -87,29 +92,24 @@ public void setUp() { BlockPublishingPerformance.NOOP)) .isCompletedWithValue(SendSignedBlockResult.success(signedBlockContents.getRoot())); + verify(blockPublisher).publishBlock(signedBlock, BlockPublishingPerformance.NOOP); verify(blockPublisher) - .publishBlockAndBlobSidecars(signedBlock, blobSidecars, BlockPublishingPerformance.NOOP); + .publishBlobSidecars(blobSidecars, signedBlock, BlockPublishingPerformance.NOOP); verify(blockPublisher) - .importBlockAndBlobSidecars( - signedBlock, - blobSidecars, - BroadcastValidationLevel.NOT_REQUIRED, - BlockPublishingPerformance.NOOP); + .importBlock( + signedBlock, BroadcastValidationLevel.NOT_REQUIRED, BlockPublishingPerformance.NOOP); + verify(blockPublisher).importBlobSidecars(blobSidecars, BlockPublishingPerformance.NOOP); } @Test public void sendSignedBlock_shouldWaitToPublishWhenBroadcastValidationIsSpecified() { final SafeFuture validationResult = new SafeFuture<>(); - when(blockPublisher.importBlockAndBlobSidecars( + when(blockPublisher.importBlock( signedBlock, - blobSidecars, BroadcastValidationLevel.CONSENSUS_AND_EQUIVOCATION, BlockPublishingPerformance.NOOP)) .thenReturn( - SafeFuture.completedFuture( - new BlockImportAndBroadcastValidationResults( - SafeFuture.completedFuture(BlockImportResult.successful(signedBlock)), - validationResult))); + prepareBlockImportResult(BlockImportResult.successful(signedBlock), validationResult)); final SafeFuture sendSignedBlockResult = blockPublisher.sendSignedBlock( @@ -118,21 +118,26 @@ public void sendSignedBlock_shouldWaitToPublishWhenBroadcastValidationIsSpecifie BlockPublishingPerformance.NOOP); assertThatSafeFuture(sendSignedBlockResult).isNotCompleted(); + assertThat(asyncRunner.hasDelayedActions()).isTrue(); + verify(blockPublisher, never()).importBlobSidecars(any(), any()); + asyncRunner.executeDueActions(); + verify(blockPublisher).importBlobSidecars(blobSidecars, BlockPublishingPerformance.NOOP); verify(blockPublisher) - .importBlockAndBlobSidecars( + .importBlock( signedBlock, - blobSidecars, BroadcastValidationLevel.CONSENSUS_AND_EQUIVOCATION, BlockPublishingPerformance.NOOP); + verify(blockPublisher, never()).publishBlock(signedBlock, BlockPublishingPerformance.NOOP); verify(blockPublisher, never()) - .publishBlockAndBlobSidecars(signedBlock, blobSidecars, BlockPublishingPerformance.NOOP); + .publishBlobSidecars(blobSidecars, signedBlock, BlockPublishingPerformance.NOOP); validationResult.complete(BroadcastValidationResult.SUCCESS); + verify(blockPublisher).publishBlock(signedBlock, BlockPublishingPerformance.NOOP); verify(blockPublisher) - .publishBlockAndBlobSidecars(signedBlock, blobSidecars, BlockPublishingPerformance.NOOP); + .publishBlobSidecars(blobSidecars, signedBlock, BlockPublishingPerformance.NOOP); assertThatSafeFuture(sendSignedBlockResult) .isCompletedWithValue(SendSignedBlockResult.success(signedBlockContents.getRoot())); } @@ -140,9 +145,8 @@ public void sendSignedBlock_shouldWaitToPublishWhenBroadcastValidationIsSpecifie @Test public void sendSignedBlock_shouldNotPublishWhenBroadcastValidationFails() { final SafeFuture validationResult = new SafeFuture<>(); - when(blockPublisher.importBlockAndBlobSidecars( + when(blockPublisher.importBlock( signedBlock, - blobSidecars, BroadcastValidationLevel.CONSENSUS_AND_EQUIVOCATION, BlockPublishingPerformance.NOOP)) .thenReturn( @@ -157,49 +161,153 @@ public void sendSignedBlock_shouldNotPublishWhenBroadcastValidationFails() { BroadcastValidationLevel.CONSENSUS_AND_EQUIVOCATION, BlockPublishingPerformance.NOOP); + assertThat(asyncRunner.hasDelayedActions()).isTrue(); assertThatSafeFuture(sendSignedBlockResult).isNotCompleted(); verify(blockPublisher) - .importBlockAndBlobSidecars( + .importBlock( signedBlock, - blobSidecars, BroadcastValidationLevel.CONSENSUS_AND_EQUIVOCATION, BlockPublishingPerformance.NOOP); + verify(blockPublisher, never()).publishBlock(signedBlock, BlockPublishingPerformance.NOOP); verify(blockPublisher, never()) - .publishBlockAndBlobSidecars(signedBlock, blobSidecars, BlockPublishingPerformance.NOOP); + .publishBlobSidecars(blobSidecars, signedBlock, BlockPublishingPerformance.NOOP); validationResult.complete(BroadcastValidationResult.CONSENSUS_FAILURE); + verify(blockPublisher, never()).publishBlock(signedBlock, BlockPublishingPerformance.NOOP); verify(blockPublisher, never()) - .publishBlockAndBlobSidecars(signedBlock, blobSidecars, BlockPublishingPerformance.NOOP); + .publishBlobSidecars(blobSidecars, signedBlock, BlockPublishingPerformance.NOOP); + assertThatSafeFuture(sendSignedBlockResult) .isCompletedWithValue( SendSignedBlockResult.rejected("FAILED_BROADCAST_VALIDATION: CONSENSUS_FAILURE")); } + @Test + public void sendSignedBlock_shouldPublishBlobsAfterBlockWhenOptionIsEnabled() { + final AbstractBlockPublisher blockPublisher = + spy( + new BlockPublisherTest( + asyncRunner, + blockFactory, + blockGossipChannel, + blockImportChannel, + dutyMetrics, + true)); + + SafeFuture publishBlockFuture = new SafeFuture<>(); + when(blockPublisher.publishBlock(any(), any())).thenReturn(publishBlockFuture); + + when(blockPublisher.importBlock( + signedBlock, BroadcastValidationLevel.NOT_REQUIRED, BlockPublishingPerformance.NOOP)) + .thenReturn(prepareBlockImportResult(BlockImportResult.successful(signedBlock))); + + assertThatSafeFuture( + blockPublisher.sendSignedBlock( + signedBlockContents, + BroadcastValidationLevel.NOT_REQUIRED, + BlockPublishingPerformance.NOOP)) + .isCompletedWithValue(SendSignedBlockResult.success(signedBlockContents.getRoot())); + + verify(blockPublisher).publishBlock(signedBlock, BlockPublishingPerformance.NOOP); + verify(blockPublisher, never()) + .publishBlobSidecars(blobSidecars, signedBlock, BlockPublishingPerformance.NOOP); + + // Complete block publishing + publishBlockFuture.complete(null); + + verify(blockPublisher) + .publishBlobSidecars(blobSidecars, signedBlock, BlockPublishingPerformance.NOOP); + + verify(blockPublisher) + .importBlock( + signedBlock, BroadcastValidationLevel.NOT_REQUIRED, BlockPublishingPerformance.NOOP); + verify(blockPublisher).importBlobSidecars(blobSidecars, BlockPublishingPerformance.NOOP); + } + + @Test + public void sendSignedBlock_shouldReturnNotImportedWhenBlockImportFails() { + when(blockPublisher.importBlock( + signedBlock, BroadcastValidationLevel.NOT_REQUIRED, BlockPublishingPerformance.NOOP)) + .thenReturn( + prepareBlockImportResult( + BlockImportResult.failedStateTransition(new RuntimeException("Failed")))); + + assertThatSafeFuture( + blockPublisher.sendSignedBlock( + signedBlockContents, + BroadcastValidationLevel.NOT_REQUIRED, + BlockPublishingPerformance.NOOP)) + .isCompletedWithValue( + SendSignedBlockResult.notImported(FailureReason.FAILED_STATE_TRANSITION.name())); + + verify(blockPublisher).publishBlock(signedBlock, BlockPublishingPerformance.NOOP); + verify(blockPublisher) + .publishBlobSidecars(blobSidecars, signedBlock, BlockPublishingPerformance.NOOP); + verify(blockPublisher) + .importBlock( + signedBlock, BroadcastValidationLevel.NOT_REQUIRED, BlockPublishingPerformance.NOOP); + verify(blockPublisher).importBlobSidecars(blobSidecars, BlockPublishingPerformance.NOOP); + } + + private SafeFuture prepareBlockImportResult( + final BlockImportResult blockImportResult) { + return SafeFuture.completedFuture( + new BlockImportAndBroadcastValidationResults( + SafeFuture.completedFuture(blockImportResult))); + } + + private SafeFuture prepareBlockImportResult( + final BlockImportResult blockImportResult, + final SafeFuture broadcastValidationResult) { + return SafeFuture.completedFuture( + new BlockImportAndBroadcastValidationResults( + SafeFuture.completedFuture(blockImportResult), broadcastValidationResult)); + } + private static class BlockPublisherTest extends AbstractBlockPublisher { public BlockPublisherTest( + final AsyncRunner asyncRunner, final BlockFactory blockFactory, + final BlockGossipChannel blockGossipChannel, final BlockImportChannel blockImportChannel, - final PerformanceTracker performanceTracker, - final DutyMetrics dutyMetrics) { - super(blockFactory, blockImportChannel, performanceTracker, dutyMetrics); + final DutyMetrics dutyMetrics, + final boolean gossipBlobsAfterBlock) { + super( + asyncRunner, + blockFactory, + blockGossipChannel, + blockImportChannel, + dutyMetrics, + gossipBlobsAfterBlock); } @Override - SafeFuture importBlockAndBlobSidecars( + SafeFuture importBlock( final SignedBeaconBlock block, - final List blobSidecars, final BroadcastValidationLevel broadcastValidationLevel, final BlockPublishingPerformance blockPublishingPerformance) { return null; } @Override - void publishBlockAndBlobSidecars( + void importBlobSidecars( + final List blobSidecars, + final BlockPublishingPerformance blockPublishingPerformance) {} + + @Override + SafeFuture publishBlock( final SignedBeaconBlock block, + final BlockPublishingPerformance blockPublishingPerformance) { + return null; + } + + @Override + void publishBlobSidecars( final List blobSidecars, + final SignedBeaconBlock block, final BlockPublishingPerformance blockPublishingPerformance) {} } } diff --git a/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/publisher/BlockPublisherDenebTest.java b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/publisher/BlockPublisherDenebTest.java new file mode 100644 index 00000000000..30a0e6a0be6 --- /dev/null +++ b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/publisher/BlockPublisherDenebTest.java @@ -0,0 +1,76 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.coordinator.publisher; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.util.List; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.ethereum.performance.trackers.BlockPublishingPerformance; +import tech.pegasys.teku.infrastructure.async.AsyncRunner; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.networking.eth2.gossip.BlobSidecarGossipChannel; +import tech.pegasys.teku.networking.eth2.gossip.BlockGossipChannel; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; +import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; +import tech.pegasys.teku.statetransition.blobs.BlobSidecarManager.RemoteOrigin; +import tech.pegasys.teku.statetransition.blobs.BlockBlobSidecarsTrackersPool; +import tech.pegasys.teku.statetransition.block.BlockImportChannel; +import tech.pegasys.teku.validator.coordinator.BlockFactory; +import tech.pegasys.teku.validator.coordinator.DutyMetrics; + +class BlockPublisherDenebTest { + private final BlockBlobSidecarsTrackersPool blockBlobSidecarsTrackersPool = + mock(BlockBlobSidecarsTrackersPool.class); + private final BlobSidecarGossipChannel blobSidecarGossipChannel = + mock(BlobSidecarGossipChannel.class); + private final BlockPublisherDeneb blockPublisherDeneb = + new BlockPublisherDeneb( + mock(AsyncRunner.class), + mock(BlockFactory.class), + mock(BlockImportChannel.class), + mock(BlockGossipChannel.class), + blockBlobSidecarsTrackersPool, + blobSidecarGossipChannel, + mock(DutyMetrics.class), + true); + + private final BlobSidecar blobSidecar = mock(BlobSidecar.class); + private final List blobSidecars = List.of(blobSidecar); + + @BeforeEach + void setUp() { + when(blobSidecarGossipChannel.publishBlobSidecars(any())).thenReturn(SafeFuture.COMPLETE); + } + + @Test + void importBlobSidecars_shouldTrackBlobSidecars() { + blockPublisherDeneb.importBlobSidecars(blobSidecars, BlockPublishingPerformance.NOOP); + + verify(blockBlobSidecarsTrackersPool) + .onNewBlobSidecar(blobSidecar, RemoteOrigin.LOCAL_PROPOSAL); + } + + @Test + void publishBlobSidecars_shouldPublishBlobSidecars() { + blockPublisherDeneb.publishBlobSidecars( + blobSidecars, mock(SignedBeaconBlock.class), BlockPublishingPerformance.NOOP); + + verify(blobSidecarGossipChannel).publishBlobSidecars(blobSidecars); + } +} diff --git a/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/publisher/BlockPublisherPhase0Test.java b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/publisher/BlockPublisherPhase0Test.java new file mode 100644 index 00000000000..230d33e2142 --- /dev/null +++ b/beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/publisher/BlockPublisherPhase0Test.java @@ -0,0 +1,70 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.coordinator.publisher; + +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static tech.pegasys.teku.infrastructure.async.SafeFutureAssert.safeJoin; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.ethereum.performance.trackers.BlockPublishingPerformance; +import tech.pegasys.teku.infrastructure.async.AsyncRunner; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.networking.eth2.gossip.BlockGossipChannel; +import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; +import tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel; +import tech.pegasys.teku.statetransition.block.BlockImportChannel; +import tech.pegasys.teku.validator.coordinator.BlockFactory; +import tech.pegasys.teku.validator.coordinator.DutyMetrics; + +class BlockPublisherPhase0Test { + private final BlockGossipChannel blockGossipChannel = mock(BlockGossipChannel.class); + private final BlockImportChannel blockImportChannel = mock(BlockImportChannel.class); + + private final BlockPublisherPhase0 blockPublisherPhase0 = + new BlockPublisherPhase0( + mock(AsyncRunner.class), + mock(BlockFactory.class), + blockGossipChannel, + blockImportChannel, + mock(DutyMetrics.class), + false); + + private final SignedBeaconBlock signedBlock = mock(SignedBeaconBlock.class); + + @BeforeEach + void setUp() { + when(blockGossipChannel.publishBlock(signedBlock)).thenReturn(SafeFuture.COMPLETE); + when(blockImportChannel.importBlock(signedBlock, BroadcastValidationLevel.NOT_REQUIRED)) + .thenReturn(SafeFuture.completedFuture(null)); + } + + @Test + void importBlock_shouldImportBlock() { + safeJoin( + blockPublisherPhase0.importBlock( + signedBlock, BroadcastValidationLevel.NOT_REQUIRED, BlockPublishingPerformance.NOOP)); + + verify(blockImportChannel).importBlock(signedBlock, BroadcastValidationLevel.NOT_REQUIRED); + } + + @Test + void publishBlock_shouldPublishBlock() { + safeJoin(blockPublisherPhase0.publishBlock(signedBlock, BlockPublishingPerformance.NOOP)); + + verify(blockGossipChannel).publishBlock(signedBlock); + } +} diff --git a/build.gradle b/build.gradle index cf5ce234f2d..d6df0daff8e 100644 --- a/build.gradle +++ b/build.gradle @@ -4,6 +4,8 @@ import tech.pegasys.teku.depcheck.DepCheckPlugin import java.text.SimpleDateFormat +import groovy.json.JsonSlurper + import static tech.pegasys.teku.repackage.Repackage.repackage buildscript { @@ -22,11 +24,11 @@ buildscript { plugins { id 'com.diffplug.spotless' version '6.25.0' id 'com.github.ben-manes.versions' version '0.51.0' - id 'com.github.jk1.dependency-license-report' version '2.8' + id 'com.github.jk1.dependency-license-report' version '2.9' id 'io.spring.dependency-management' version '1.1.6' - id 'net.ltgt.errorprone' version '4.0.1' apply false + id 'net.ltgt.errorprone' version '4.1.0' apply false id 'de.undercouch.download' version '5.6.0' - id 'org.ajoberstar.grgit' version '5.2.2' + id 'org.ajoberstar.grgit' version '5.3.0' } rootProject.version = calculatePublishVersion() @@ -196,7 +198,7 @@ allprojects { endWithNewline() licenseHeaderFile "${rootDir}/gradle/spotless.java.license" // See gradle.properties for exports/opens flags required by JDK 16 and Google Java Format plugin - googleJavaFormat('1.17.0') + googleJavaFormat('1.23.0') } } @@ -232,6 +234,7 @@ allprojects { check('InlineMeSuggester', net.ltgt.gradle.errorprone.CheckSeverity.OFF) check('CanIgnoreReturnValueSuggester', net.ltgt.gradle.errorprone.CheckSeverity.OFF) check('DirectInvocationOnMock', net.ltgt.gradle.errorprone.CheckSeverity.OFF) + check('DistinctVarargsChecker', net.ltgt.gradle.errorprone.CheckSeverity.OFF) // We don't apply strict javadoc requirements yet check('EmptyBlockTag', net.ltgt.gradle.errorprone.CheckSeverity.OFF) @@ -244,22 +247,28 @@ allprojects { check('ReferenceComparison', net.ltgt.gradle.errorprone.CheckSeverity.WARN) // These checks are imported from errorprone-checks dependency but not required in Teku - check('MethodInputParametersMustBeFinal', net.ltgt.gradle.errorprone.CheckSeverity.OFF) check('BannedMethod', net.ltgt.gradle.errorprone.CheckSeverity.OFF) check('ExperimentalCliOptionMustBeCorrectlyDisplayed', net.ltgt.gradle.errorprone.CheckSeverity.OFF) // These are experimental checks that we want enabled - check('MissingBraces', net.ltgt.gradle.errorprone.CheckSeverity.WARN) - check('InsecureCryptoUsage', net.ltgt.gradle.errorprone.CheckSeverity.WARN) - check('WildcardImport', net.ltgt.gradle.errorprone.CheckSeverity.WARN) + check('ClassName', net.ltgt.gradle.errorprone.CheckSeverity.WARN) check('DeduplicateConstants', net.ltgt.gradle.errorprone.CheckSeverity.WARN) - check('RedundantOverride', net.ltgt.gradle.errorprone.CheckSeverity.WARN) - check('RedundantThrows', net.ltgt.gradle.errorprone.CheckSeverity.WARN) - check('UnnecessarilyFullyQualified', net.ltgt.gradle.errorprone.CheckSeverity.WARN) + check('FieldCanBeFinal', net.ltgt.gradle.errorprone.CheckSeverity.WARN) check('InitializeInline', net.ltgt.gradle.errorprone.CheckSeverity.WARN) - check('ClassName', net.ltgt.gradle.errorprone.CheckSeverity.WARN) + check('InsecureCryptoUsage', net.ltgt.gradle.errorprone.CheckSeverity.WARN) check('InterfaceWithOnlyStatics', net.ltgt.gradle.errorprone.CheckSeverity.WARN) + check('MethodInputParametersMustBeFinal', net.ltgt.gradle.errorprone.CheckSeverity.WARN) + check('MissingBraces', net.ltgt.gradle.errorprone.CheckSeverity.WARN) + check('NonFinalStaticField', net.ltgt.gradle.errorprone.CheckSeverity.WARN) check('PackageLocation', net.ltgt.gradle.errorprone.CheckSeverity.WARN) + check('RedundantOverride', net.ltgt.gradle.errorprone.CheckSeverity.WARN) + check('RedundantThrows', net.ltgt.gradle.errorprone.CheckSeverity.WARN) + check('StringFormatWithLiteral', net.ltgt.gradle.errorprone.CheckSeverity.WARN) + check('TruthContainsExactlyElementsInUsage', net.ltgt.gradle.errorprone.CheckSeverity.WARN) + check('UnnecessarilyFullyQualified', net.ltgt.gradle.errorprone.CheckSeverity.WARN) + check('UnnecessaryTestMethodPrefix', net.ltgt.gradle.errorprone.CheckSeverity.WARN) + check('UseCorrectAssertInTests', net.ltgt.gradle.errorprone.CheckSeverity.WARN) + check('WildcardImport', net.ltgt.gradle.errorprone.CheckSeverity.WARN) } options.encoding = 'UTF-8' @@ -315,7 +324,8 @@ allprojects { } } -def refTestVersion = 'v1.5.0-alpha.5' // Arbitrary change to refresh cache number: 1 +def nightly = System.getenv("NIGHTLY") != null +def refTestVersion = nightly ? "nightly" : "v1.5.0-alpha.8" def blsRefTestVersion = 'v0.1.2' def slashingProtectionInterchangeRefTestVersion = 'v5.3.0' def refTestBaseUrl = 'https://github.com/ethereum/consensus-spec-tests/releases/download' @@ -326,7 +336,87 @@ def blsRefTestDownloadDir = "${buildDir}/blsRefTests/${blsRefTestVersion}" def slashingProtectionInterchangeRefTestDownloadDir = "${buildDir}/slashingProtectionInterchangeRefTests/${slashingProtectionInterchangeRefTestVersion}" def refTestExpandDir = "${project.rootDir}/eth-reference-tests/src/referenceTest/resources/consensus-spec-tests/" -task downloadEthRefTests(type: Download) { +def downloadFile(String url, String token, File outputFile) { + println "Download ${outputFile.getName()} (${url})" + def connection = new URL(url).openConnection() + connection.setRequestProperty("Authorization", "token ${token}") + connection.getInputStream().withCloseable { inputStream -> + outputFile.withOutputStream { outputStream -> + outputStream << inputStream + } + } +} + +def downloadArtifacts(String repo, Long runId, String token, String downloadDir) { + def artifactsApiUrl = "https://api.github.com/repos/${repo}/actions/runs/${runId}/artifacts" + def connection = new URL(artifactsApiUrl).openConnection() + connection.setRequestProperty("Authorization", "token ${token}") + connection.setRequestProperty("Accept", "application/vnd.github.v3+json") + + def response = new JsonSlurper().parse(connection.getInputStream()) + if (response.artifacts && response.artifacts.size() > 0) { + response.artifacts.each { artifact -> + // We can skip the log file + if (artifact.name.contains("consensustestgen.log")) { + return + } + + def fileOutput = new File(downloadDir, "${artifact.name}.zip") + downloadFile(artifact.archive_download_url, token, fileOutput) + ant.unzip(src: fileOutput, dest: downloadDir) + fileOutput.delete() + } + return true + } + return false +} + +static def getLatestRunId(String repo, String workflow, String branch, String token) { + def apiUrl = "https://api.github.com/repos/${repo}/actions/workflows/${workflow}/runs?branch=${branch}&status=success&per_page=1" + def connection = new URL(apiUrl).openConnection() + connection.setRequestProperty("Authorization", "token ${token}") + connection.setRequestProperty("Accept", "application/vnd.github.v3+json") + + // Query & parse the ID out of the response + def response = new JsonSlurper().parse(connection.getInputStream()) + if (response.workflow_runs && response.workflow_runs.size() > 0) { + return response.workflow_runs[0].id + } + return null +} + +task downloadEthRefTestsNightly { + doLast { + def repo = "ethereum/consensus-specs" + def workflowFileName = "generate_vectors.yml" + def branch = "dev" + + // We need a GitHub API token to download the artifacts + def githubToken = System.getenv("GITHUB_TOKEN") + if (!githubToken) { + println "Error: GITHUB_TOKEN environment variable is not set" + return + } + + // Get the latest workflow run ID + def runId = getLatestRunId(repo, workflowFileName, branch, githubToken) + if (!runId) { + println "Error: Failed to get latest run ID" + return + } + + // Create the download directory + file(refTestDownloadDir).mkdirs() + + // Download artifacts for the run + def success = downloadArtifacts(repo, runId, githubToken, refTestDownloadDir) + if (!success) { + println "Error: Failed to download artifacts" + } + } +} + +task downloadEthRefTestsStable(type: Download) { src([ "${refTestBaseUrl}/${refTestVersion}/general.tar.gz", "${refTestBaseUrl}/${refTestVersion}/minimal.tar.gz", @@ -336,6 +426,14 @@ task downloadEthRefTests(type: Download) { overwrite false } +task downloadEthRefTests { + if (nightly) { + dependsOn tasks.findByName("downloadEthRefTestsNightly") + } else { + dependsOn tasks.findByName("downloadEthRefTestsStable") + } +} + task downloadBlsRefTests(type: Download) { src([ "${blsRefTestBaseUrl}/${blsRefTestVersion}/bls_tests_yaml.tar.gz" @@ -476,11 +574,11 @@ task autocomplete(type: JavaExec) { } installDist { - dependsOn checkLicense, autocomplete + dependsOn checkLicense, startScripts, autocomplete } distTar { - dependsOn checkLicense, autocomplete + dependsOn checkLicense, startScripts, autocomplete doFirst { delete fileTree(dir: 'build/distributions', include: '*.tar.gz') } @@ -493,7 +591,7 @@ distTar { } distZip { - dependsOn checkLicense, autocomplete + dependsOn checkLicense, startScripts, autocomplete doFirst { delete fileTree(dir: 'build/distributions', include: '*.zip') } @@ -505,6 +603,8 @@ distZip { startScripts { + unixStartScriptGenerator.template = resources.text.fromFile("${projectDir}/teku/src/main/scripts/unixStartScript.txt") + def shortenWindowsClasspath = { line -> line = line.replaceAll(/^set CLASSPATH=.*$/, "set CLASSPATH=%APP_HOME%/lib/*") } @@ -841,6 +941,11 @@ subprojects { propertyTestRuntimeOnly.extendsFrom testRuntimeOnly referenceTestRuntimeOnly.extendsFrom testRuntimeOnly + // exclude until Besu dependencies start using io.consensys.protocols:jc-kzg-4844 + implementation { + exclude(group: "tech.pegasys", module: "jc-kzg-4844") + } + // Details at https://github.com/Hakky54/log-captor#using-log-captor-alongside-with-other-logging-libraries testImplementation { exclude(group: "org.apache.logging.log4j", module: "log4j-slf4j-impl") @@ -879,7 +984,7 @@ subprojects { runtimeOnly 'org.apache.logging.log4j:log4j-core' runtimeOnly 'org.apache.logging.log4j:log4j-slf4j-impl' - testImplementation 'org.apache.tuweni:tuweni-junit' + testImplementation 'io.tmio:tuweni-junit' testImplementation 'org.assertj:assertj-core' testImplementation 'org.mockito:mockito-core' testImplementation 'org.junit.jupiter:junit-jupiter-api' diff --git a/data/beaconrestapi/build.gradle b/data/beaconrestapi/build.gradle index b743075279c..64d2f16aa84 100644 --- a/data/beaconrestapi/build.gradle +++ b/data/beaconrestapi/build.gradle @@ -28,7 +28,7 @@ dependencies { implementation 'io.swagger.core.v3:swagger-annotations' implementation 'io.github.classgraph:classgraph' implementation 'io.javalin:javalin' - implementation 'org.apache.tuweni:tuweni-units' + implementation 'io.tmio:tuweni-units' implementation 'org.webjars:swagger-ui' testImplementation testFixtures(project(':storage')) diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/AbstractDataBackedRestAPIIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/AbstractDataBackedRestAPIIntegrationTest.java index 205edb94528..7dac81607bd 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/AbstractDataBackedRestAPIIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/AbstractDataBackedRestAPIIntegrationTest.java @@ -23,6 +23,7 @@ import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import java.io.IOException; import java.util.ArrayList; @@ -38,6 +39,7 @@ import okhttp3.Request; import okhttp3.RequestBody; import okhttp3.Response; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.AfterEach; import tech.pegasys.teku.api.DataProvider; import tech.pegasys.teku.api.RewardCalculator; @@ -53,7 +55,6 @@ import tech.pegasys.teku.infrastructure.time.SystemTimeProvider; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.networking.eth2.Eth2P2PNetwork; -import tech.pegasys.teku.provider.JsonProvider; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.TestSpecFactory; @@ -157,7 +158,7 @@ public abstract class AbstractDataBackedRestAPIIntegrationTest { protected ChainBuilder chainBuilder; protected ChainUpdater chainUpdater; - protected final JsonProvider jsonProvider = new JsonProvider(); + protected static final ObjectMapper OBJECT_MAPPER = new ObjectMapper(); protected DataProvider dataProvider; protected BeaconRestApi beaconRestApi; @@ -219,7 +220,7 @@ private void setupStorage( new SystemTimeProvider()); } - private void setupAndStartRestAPI(BeaconRestApiConfig config) { + private void setupAndStartRestAPI(final BeaconRestApiConfig config) { combinedChainDataClient = storageSystem.combinedChainDataClient(); dataProvider = DataProvider.builder() @@ -261,7 +262,7 @@ private void setupAndStartRestAPI() { setupAndStartRestAPI(CONFIG); } - protected void startPreGenesisRestAPIWithConfig(BeaconRestApiConfig config) { + protected void startPreGenesisRestAPIWithConfig(final BeaconRestApiConfig config) { setupStorage(StateStorageMode.ARCHIVE, false, SpecMilestone.PHASE0); // Start API setupAndStartRestAPI(config); @@ -296,17 +297,17 @@ protected void startRestAPIAtGenesis( setupAndStartRestAPI(config); } - public List createBlocksAtSlots(long... slots) { + public List createBlocksAtSlots(final long... slots) { final UInt64[] unsignedSlots = Arrays.stream(slots).mapToObj(UInt64::valueOf).toArray(UInt64[]::new); return createBlocksAtSlots(unsignedSlots); } - public void setCurrentSlot(long slot) { + public void setCurrentSlot(final long slot) { chainUpdater.setCurrentSlot(UInt64.valueOf(slot)); } - public List createBlocksAtSlots(UInt64... slots) { + public List createBlocksAtSlots(final UInt64... slots) { final ArrayList results = new ArrayList<>(); for (UInt64 slot : slots) { final SignedBlockAndState block = chainUpdater.advanceChain(slot); @@ -316,7 +317,7 @@ public List createBlocksAtSlots(UInt64... slots) { return results; } - public SignedBlockAndState finalizeChainAtEpoch(UInt64 epoch) { + public SignedBlockAndState finalizeChainAtEpoch(final UInt64 epoch) { return chainUpdater.finalizeEpoch(epoch); } @@ -378,7 +379,7 @@ protected String getUrl(final String path) { } protected Response getResponse( - final String route, Map getParams, final String contentType) + final String route, final Map getParams, final String contentType) throws IOException { return getResponse(route + prepareQueryParams(getParams), contentType); } @@ -435,7 +436,7 @@ protected Response postSsz( return client.newCall(requestBuilder.build()).execute(); } - protected String mapToJson(Map postParams) throws JsonProcessingException { + protected String mapToJson(final Map postParams) throws JsonProcessingException { return objectMapper.writer().writeValueAsString(postParams); } @@ -454,6 +455,17 @@ private String prepareQueryParams(final Map params) { .collect(Collectors.joining("&")); } + protected JsonNode getResponseData(final Response response) throws IOException { + final JsonNode body = OBJECT_MAPPER.readTree(response.body().string()); + return body.get("data"); + } + + protected void checkEmptyBodyToRoute(final String route, final int expectedResponseCode) + throws IOException { + final Response response = post(route, OBJECT_MAPPER.writeValueAsString("")); + Assertions.assertThat(response.code()).isEqualTo(expectedResponseCode); + } + @AfterEach public void tearDown() { assertThat(beaconRestApi.stop()).isCompleted(); diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/BadRequest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/BadRequest.java index 9fceb9d834d..8828d6330e2 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/BadRequest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/BadRequest.java @@ -21,7 +21,8 @@ public class BadRequest { private final String message; @JsonCreator - public BadRequest(@JsonProperty("code") Integer code, @JsonProperty("message") String message) { + public BadRequest( + @JsonProperty("code") final Integer code, @JsonProperty("message") final String message) { this.code = code; this.message = message; } diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/PostBlindedAndUnblindedBlockTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/beacon/PostBlindedAndUnblindedBlockTest.java similarity index 79% rename from data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/PostBlindedAndUnblindedBlockTest.java rename to data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/beacon/PostBlindedAndUnblindedBlockTest.java index f89d688a1ad..e8609905565 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/PostBlindedAndUnblindedBlockTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/beacon/PostBlindedAndUnblindedBlockTest.java @@ -11,12 +11,12 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.beaconrestapi.v1.validator; +package tech.pegasys.teku.beaconrestapi.beacon; import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.when; -import static tech.pegasys.teku.beaconrestapi.v1.validator.PostBlindedAndUnblindedBlockTest.Version.V1; -import static tech.pegasys.teku.beaconrestapi.v1.validator.PostBlindedAndUnblindedBlockTest.Version.V2; +import static tech.pegasys.teku.beaconrestapi.beacon.PostBlindedAndUnblindedBlockTest.Version.V1; +import static tech.pegasys.teku.beaconrestapi.beacon.PostBlindedAndUnblindedBlockTest.Version.V2; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import java.io.IOException; @@ -58,37 +58,30 @@ public static Stream postBlockCases() { .flatMap( route -> Stream.of( - // route, useSsz, versionHeader - Arguments.of(route, false, Optional.empty()), - // Methods using Eth-Consensus-Version header (only for SSZ, we could add it for - // json too when we start using it) - Arguments.of(route, true, Optional.empty()), - - // deneb header on bellatrix will fall back to ssz slot based selector, because - // deneb is not configured. - // It is irrelevant for json, because we currently always use the slot based - // selector. - Arguments.of(route, true, Optional.of("deneb")))) + // route, useSsz, set consensus header + Arguments.of(route, false, true), + Arguments.of(route, false, false), + Arguments.of(route, true, false), + Arguments.of(route, true, true))) .map( args -> { final String route = (String) args.get()[0]; final boolean isBlindedBlock = route.contains("blinded"); final Version version = route.contains("/v2/") ? V2 : V1; final boolean useSsz = (boolean) args.get()[1]; - @SuppressWarnings("unchecked") - final Optional versionHeader = (Optional) args.get()[2]; - return Arguments.of(version, isBlindedBlock, route, useSsz, versionHeader); + final boolean setConsensusHeader = (boolean) args.get()[2]; + return Arguments.of(version, isBlindedBlock, route, useSsz, setConsensusHeader); }); } - @ParameterizedTest(name = "version:{0}_blinded:{1}_ssz:{3}_versionHeader:{4}") + @ParameterizedTest(name = "version:{0}_blinded:{1}_ssz:{3}_setConsensusHeader:{4}") @MethodSource("postBlockCases") - void shouldReturnOk( + void preDeneb( final Version version, final boolean isBlindedBlock, final String route, final boolean useSsz, - final Optional versionHeader) + final boolean setConsensusHeader) throws IOException { startRestAPIAtGenesis(SpecMilestone.BELLATRIX); @@ -111,17 +104,20 @@ void shouldReturnOk( prepareResponse(request, version); - postRequestAndAssert(route, request, signedBeaconBlockSchema, versionHeader, useSsz, version); + final Optional consensusHeader = + setConsensusHeader ? Optional.of(SpecMilestone.BELLATRIX.name()) : Optional.empty(); + + postRequestAndAssert(route, request, signedBeaconBlockSchema, consensusHeader, useSsz, version); } - @ParameterizedTest(name = "version:{0}_blinded:{1}_ssz:{3}_versionHeader:{4}") + @ParameterizedTest(name = "version:{0}_blinded:{1}_ssz:{3}_setConsensusHeader:{4}") @MethodSource("postBlockCases") - void shouldReturnOkPostDeneb( + void postDeneb( final Version version, final boolean isBlindedBlock, final String route, final boolean useSsz, - final Optional versionHeader) + final boolean setConsensusHeader) throws IOException { startRestAPIAtGenesis(SpecMilestone.DENEB); dataStructureUtil = new DataStructureUtil(spec); @@ -143,8 +139,11 @@ void shouldReturnOkPostDeneb( prepareResponse(request, version); + final Optional consensusHeader = + setConsensusHeader ? Optional.of(SpecMilestone.DENEB.name()) : Optional.empty(); + postRequestAndAssert( - route, request, signedBlockContainerSchema, versionHeader, useSsz, version); + route, request, signedBlockContainerSchema, consensusHeader, useSsz, version); } private void prepareResponse(final SignedBeaconBlock request, final Version version) { @@ -153,7 +152,11 @@ private void prepareResponse(final SignedBeaconBlock request, final Version vers request, BroadcastValidationLevel.CONSENSUS_AND_EQUIVOCATION)) .thenReturn(SafeFuture.completedFuture(SendSignedBlockResult.success(request.getRoot()))); } else { - when(validatorApiChannel.sendSignedBlock(request, BroadcastValidationLevel.NOT_REQUIRED)) + final BroadcastValidationLevel broadcastValidationLevel = + request.isBlinded() + ? BroadcastValidationLevel.NOT_REQUIRED + : BroadcastValidationLevel.GOSSIP; + when(validatorApiChannel.sendSignedBlock(request, broadcastValidationLevel)) .thenReturn(SafeFuture.completedFuture(SendSignedBlockResult.success(request.getRoot()))); } } @@ -164,7 +167,11 @@ private void prepareResponse(final SignedBlockContainer request, final Version v request, BroadcastValidationLevel.CONSENSUS_AND_EQUIVOCATION)) .thenReturn(SafeFuture.completedFuture(SendSignedBlockResult.success(request.getRoot()))); } else { - when(validatorApiChannel.sendSignedBlock(request, BroadcastValidationLevel.NOT_REQUIRED)) + final BroadcastValidationLevel broadcastValidationLevel = + request.isBlinded() + ? BroadcastValidationLevel.NOT_REQUIRED + : BroadcastValidationLevel.GOSSIP; + when(validatorApiChannel.sendSignedBlock(request, broadcastValidationLevel)) .thenReturn(SafeFuture.completedFuture(SendSignedBlockResult.success(request.getRoot()))); } } diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/beacon/SwaggerUiTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/beacon/SwaggerUiTest.java index f3beb9827ef..aea102688f2 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/beacon/SwaggerUiTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/beacon/SwaggerUiTest.java @@ -63,7 +63,7 @@ public void shouldContainInitializerWithPatchedJsonSchemaLink() throws IOExcepti assertThat(response.body().string()).contains(JSON_SCHEMA_PATH); } - private void checkPath(String path) { + private void checkPath(final String path) { try { Response response = getResponse(path); assertThat(response.code()).as("Check deep link (%s)", path).isEqualTo(200); @@ -72,7 +72,7 @@ private void checkPath(String path) { } } - private static Set findAssets(String url) throws IOException { + private static Set findAssets(final String url) throws IOException { Set links = new HashSet<>(); diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/tekuv1/beacon/GetDepositsIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/tekuv1/beacon/GetDepositsIntegrationTest.java index 545edff0b8d..c5bba4fc1da 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/tekuv1/beacon/GetDepositsIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/tekuv1/beacon/GetDepositsIntegrationTest.java @@ -18,13 +18,13 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import com.fasterxml.jackson.databind.JsonNode; import java.io.IOException; import java.util.ArrayList; import java.util.List; import okhttp3.Response; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.response.v1.teku.GetDepositsResponse; import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; import tech.pegasys.teku.beaconrestapi.handlers.tekuv1.beacon.GetDeposits; import tech.pegasys.teku.infrastructure.json.JsonUtil; @@ -46,10 +46,10 @@ public void shouldReturnEmptyListWhenNoDeposits() throws IOException { when(eth1DataProvider.getAvailableDeposits()).thenReturn(new ArrayList<>()); final Response response = get(); assertThat(response.code()).isEqualTo(SC_OK); - GetDepositsResponse getDepositsResponse = - jsonProvider.jsonToObject(response.body().string(), GetDepositsResponse.class); - assertThat(getDepositsResponse).isNotNull(); - assertThat(getDepositsResponse.data).isEmpty(); + final JsonNode data = getResponseData(response); + assertThat(data).isNotNull(); + assertThat(data.isArray()).isTrue(); + assertThat(data.size()).isZero(); } @Test diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/tekuv1/beacon/GetEth1DataCacheIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/tekuv1/beacon/GetEth1DataCacheIntegrationTest.java index b99ac625dd3..e3f22f8847c 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/tekuv1/beacon/GetEth1DataCacheIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/tekuv1/beacon/GetEth1DataCacheIntegrationTest.java @@ -18,16 +18,18 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import com.fasterxml.jackson.databind.JsonNode; import java.io.IOException; import java.util.ArrayList; import java.util.List; import okhttp3.Response; +import org.apache.tuweni.bytes.Bytes32; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.response.v1.teku.GetEth1DataCacheResponse; import tech.pegasys.teku.api.schema.Eth1Data; import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; import tech.pegasys.teku.beaconrestapi.handlers.tekuv1.beacon.GetEth1DataCache; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.util.DataStructureUtil; @@ -55,10 +57,18 @@ public void shouldReturnAllEth1BlocksFromCache() throws IOException { when(eth1DataProvider.getEth1CachedBlocks()).thenReturn(eth1DataCacheList); final Response response = get(); assertThat(response.code()).isEqualTo(SC_OK); - GetEth1DataCacheResponse getEth1DataResponse = - jsonProvider.jsonToObject(response.body().string(), GetEth1DataCacheResponse.class); - assertThat(getEth1DataResponse).isNotNull(); - assertThat(getEth1DataResponse.data.containsAll(eth1DataCacheBlocks)).isTrue(); + final JsonNode data = getResponseData(response); + assertThat(data.size()).isEqualTo(eth1DataCacheBlocks.size()); + for (int i = 0; i < data.size(); i++) { + final JsonNode block = data.get(i); + final Eth1Data eth1Data = eth1DataCacheBlocks.get(i); + assertThat(Bytes32.fromHexString(block.get("deposit_root").asText())) + .isEqualTo(eth1Data.deposit_root); + assertThat(UInt64.valueOf(block.get("deposit_count").asText())) + .isEqualTo(eth1Data.deposit_count); + assertThat(Bytes32.fromHexString(block.get("block_hash").asText())) + .isEqualTo(eth1Data.block_hash); + } } @Test diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/tekuv1/beacon/GetEth1DataIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/tekuv1/beacon/GetEth1DataIntegrationTest.java index 4a26dc1b452..eee306e1795 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/tekuv1/beacon/GetEth1DataIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/tekuv1/beacon/GetEth1DataIntegrationTest.java @@ -18,11 +18,11 @@ import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import com.fasterxml.jackson.databind.JsonNode; import java.io.IOException; import okhttp3.Response; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.response.v1.teku.GetEth1DataResponse; import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; import tech.pegasys.teku.beaconrestapi.handlers.tekuv1.beacon.GetEth1Data; import tech.pegasys.teku.spec.SpecMilestone; @@ -44,10 +44,11 @@ public void shouldPassVoteToResponse() throws IOException { when(eth1DataProvider.getEth1Vote(any())).thenReturn(eth1Data); final Response response = get(); assertThat(response.code()).isEqualTo(SC_OK); - GetEth1DataResponse getEth1DataResponse = - jsonProvider.jsonToObject(response.body().string(), GetEth1DataResponse.class); - assertThat(getEth1DataResponse).isNotNull(); - assertThat(getEth1DataResponse.data.asInternalEth1Data()).isEqualTo(eth1Data); + final JsonNode data = getResponseData(response); + assertThat(data.get("deposit_root").asText()) + .isEqualTo(eth1Data.getDepositRoot().toHexString()); + assertThat(data.get("deposit_count").asText()).isEqualTo(eth1Data.getDepositCount().toString()); + assertThat(data.get("block_hash").asText()).isEqualTo(eth1Data.getBlockHash().toHexString()); } private Response get() throws IOException { diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetBlockAttestationsIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetBlockAttestationsIntegrationTest.java deleted file mode 100644 index 96e0dd01765..00000000000 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetBlockAttestationsIntegrationTest.java +++ /dev/null @@ -1,60 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.beaconrestapi.v1.beacon; - -import static java.util.stream.Collectors.toList; -import static org.assertj.core.api.Assertions.assertThat; - -import java.io.IOException; -import java.util.List; -import okhttp3.Response; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.response.v1.beacon.GetBlockAttestationsResponse; -import tech.pegasys.teku.api.schema.Attestation; -import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; -import tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.GetBlockAttestations; -import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockAndState; - -public class GetBlockAttestationsIntegrationTest extends AbstractDataBackedRestAPIIntegrationTest { - @BeforeEach - public void setup() { - startRestAPIAtGenesis(); - } - - @Test - public void shouldGetBlockAttestations() throws IOException { - final List created = createBlocksAtSlots(10); - final Response response = get("head"); - - final GetBlockAttestationsResponse body = - jsonProvider.jsonToObject(response.body().string(), GetBlockAttestationsResponse.class); - final List data = body.data; - final List attestations = - created.get(0).getBlock().getMessage().getBody().getAttestations().stream() - .map(Attestation::new) - .collect(toList()); - assertThat(data).isEqualTo(attestations); - } - - @Test - public void shouldGetBlockAttestations_return404WhenBlockRootNotFound() throws IOException { - final Response response = get("0xdeadbeef"); - assertNotFound(response); - } - - public Response get(final String blockIdString) throws IOException { - return getResponse(GetBlockAttestations.ROUTE.replace("{block_id}", blockIdString)); - } -} diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetBlockHeaderIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetBlockHeaderIntegrationTest.java deleted file mode 100644 index e45753c424a..00000000000 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetBlockHeaderIntegrationTest.java +++ /dev/null @@ -1,67 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.beaconrestapi.v1.beacon; - -import static org.assertj.core.api.Assertions.assertThat; - -import java.io.IOException; -import java.util.List; -import okhttp3.Response; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.response.v1.beacon.BlockHeader; -import tech.pegasys.teku.api.response.v1.beacon.GetBlockHeaderResponse; -import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; -import tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.GetBlockHeader; -import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockAndState; -import tech.pegasys.teku.spec.generator.ChainBuilder; - -public class GetBlockHeaderIntegrationTest extends AbstractDataBackedRestAPIIntegrationTest { - @BeforeEach - public void setup() { - startRestAPIAtGenesis(); - } - - @Test - public void shouldGetBlockHeader() throws IOException { - final List created = createBlocksAtSlots(10); - final Response response = get("head"); - - final GetBlockHeaderResponse body = - jsonProvider.jsonToObject(response.body().string(), GetBlockHeaderResponse.class); - final BlockHeader data = body.data; - assertThat(data).isEqualTo(new BlockHeader(created.get(0).getBlock(), true)); - } - - @Test - public void shouldGetNonCanonicalBlockHeader() throws IOException { - createBlocksAtSlots(10); - final ChainBuilder fork = chainBuilder.fork(); - SignedBlockAndState forked = fork.generateNextBlock(); - SignedBlockAndState canonical = chainBuilder.generateNextBlock(1); - chainUpdater.saveBlock(forked); - chainUpdater.updateBestBlock(canonical); - - final Response response = get(forked.getRoot().toHexString()); - - final GetBlockHeaderResponse body = - jsonProvider.jsonToObject(response.body().string(), GetBlockHeaderResponse.class); - - assertThat(body.data.canonical).isFalse(); - } - - public Response get(final String blockIdString) throws IOException { - return getResponse(GetBlockHeader.ROUTE.replace("{block_id}", blockIdString)); - } -} diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetBlockHeadersIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetBlockHeadersIntegrationTest.java index 288859529c9..72a64c4e9c4 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetBlockHeadersIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetBlockHeadersIntegrationTest.java @@ -16,17 +16,16 @@ import static org.assertj.core.api.Assertions.assertThat; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import com.fasterxml.jackson.databind.JsonNode; import java.io.IOException; import java.util.ArrayList; import java.util.List; import java.util.Map; -import java.util.stream.Collectors; import okhttp3.Response; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.ValueSource; -import tech.pegasys.teku.api.response.v1.beacon.GetBlockHeadersResponse; import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; import tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.GetBlockHeaders; import tech.pegasys.teku.infrastructure.unsigned.UInt64; @@ -52,11 +51,10 @@ public void shouldGetBlockHeaders() throws IOException { final Response response = get(); - final GetBlockHeadersResponse body = - jsonProvider.jsonToObject(response.body().string(), GetBlockHeadersResponse.class); - - assertThat(body.data.size()).isGreaterThan(0); - assertThat(body.data.get(0).root).isEqualTo(head.getRoot()); + final JsonNode responseBody = OBJECT_MAPPER.readTree(response.body().string()); + final JsonNode data = responseBody.get("data"); + assertThat(data.size()).isGreaterThan(0); + assertThat(data.get(0).get("root").asText()).isEqualTo(head.getRoot().toHexString()); } @Test @@ -67,10 +65,10 @@ public void shouldGetBlockHeadersBySlot() throws IOException { SignedBlockAndState head = chainBuilder.generateNextBlock(); chainUpdater.updateBestBlock(head); - final GetBlockHeadersResponse body = get(parent.getSlot()); + final JsonNode data = get(parent.getSlot()); - assertThat(body.data.size()).isGreaterThan(0); - assertThat(body.data.get(0).root).isEqualTo(parent.getRoot()); + assertThat(data.size()).isGreaterThan(0); + assertThat(data.get(0).get("root").asText()).isEqualTo(parent.getRoot().toHexString()); } @ParameterizedTest(name = "finalized={0}") @@ -79,37 +77,30 @@ public void shouldGetNonCanonicalHeadersBySlot(final boolean isFinalized) throws setupData(); // PRE: we have a non-canonical block and a canonical block at the same slot - final SignedBeaconBlock canonical = - canonicalBlockAndStateList.get(canonicalBlockAndStateList.size() - 1).getBlock(); + final SignedBeaconBlock canonical = canonicalBlockAndStateList.getLast().getBlock(); final SignedBeaconBlock forked = nonCanonicalBlockAndStateList.get(1).getBlock(); assertThat(forked.getSlot()).isEqualTo(canonical.getSlot()); if (isFinalized) { chainUpdater.finalizeEpoch(2); } - final GetBlockHeadersResponse body = get(nonCanonicalBlockAndStateList.get(1).getSlot()); - - assertThat(body.data.size()).isGreaterThan(1); - assertThat( - body.data.stream() - .map(header -> String.format("%s:%s", header.root, header.canonical)) - .collect(Collectors.toList())) - .containsExactlyInAnyOrder( - String.format("%s:%s", canonical.getRoot(), true), - String.format("%s:%s", forked.getRoot(), false)); + final JsonNode data = get(nonCanonicalBlockAndStateList.get(1).getSlot()); + + assertThat(data.size()).isGreaterThan(1); + assertThat(data.get(0).get("root").asText()).isEqualTo(forked.getRoot().toHexString()); + assertThat(data.get(0).get("canonical").asBoolean()).isFalse(); + assertThat(data.get(1).get("root").asText()).isEqualTo(canonical.getRoot().toHexString()); + assertThat(data.get(1).get("canonical").asBoolean()).isTrue(); } private void setupData() { canonicalBlockAndStateList.addAll(createBlocksAtSlots(10)); final ChainBuilder fork = chainBuilder.fork(); nonCanonicalBlockAndStateList.add(fork.generateNextBlock()); - chainUpdater.saveBlock( - nonCanonicalBlockAndStateList.get(nonCanonicalBlockAndStateList.size() - 1)); + chainUpdater.saveBlock(nonCanonicalBlockAndStateList.getLast()); nonCanonicalBlockAndStateList.add(fork.generateNextBlock()); - chainUpdater.saveBlock( - nonCanonicalBlockAndStateList.get(nonCanonicalBlockAndStateList.size() - 1)); + chainUpdater.saveBlock(nonCanonicalBlockAndStateList.getLast()); canonicalBlockAndStateList.add(chainBuilder.generateNextBlock(1)); - chainUpdater.updateBestBlock( - canonicalBlockAndStateList.get(canonicalBlockAndStateList.size() - 1)); + chainUpdater.updateBestBlock(canonicalBlockAndStateList.getLast()); chainUpdater.advanceChain(32); } @@ -117,9 +108,9 @@ public Response get() throws IOException { return getResponse(GetBlockHeaders.ROUTE); } - public GetBlockHeadersResponse get(final UInt64 slot) throws IOException { + private JsonNode get(final UInt64 slot) throws IOException { final Response response = getResponse(GetBlockHeaders.ROUTE, Map.of("slot", slot.toString())); assertThat(response.code()).isEqualTo(SC_OK); - return jsonProvider.jsonToObject(response.body().string(), GetBlockHeadersResponse.class); + return getResponseData(response); } } diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetBlockRootIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetBlockRootIntegrationTest.java index cb9b3eb2302..f0ca00ba6a9 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetBlockRootIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetBlockRootIntegrationTest.java @@ -15,14 +15,13 @@ import static org.assertj.core.api.Assertions.assertThat; +import com.fasterxml.jackson.databind.JsonNode; import java.io.IOException; import java.util.List; import okhttp3.Response; import org.apache.tuweni.bytes.Bytes32; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.response.v1.beacon.GetBlockRootResponse; -import tech.pegasys.teku.api.schema.Root; import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; import tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.GetBlockRoot; import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockAndState; @@ -38,12 +37,11 @@ public void shouldGetBlockRoot() throws IOException { final List created = createBlocksAtSlots(10); final Response response = get("head"); - final GetBlockRootResponse body = - jsonProvider.jsonToObject(response.body().string(), GetBlockRootResponse.class); - final Root data = body.data; - final Bytes32 blockRoot = created.get(0).getRoot(); - assertThat(data).isEqualTo(new Root(blockRoot)); - assertThat(body.execution_optimistic).isFalse(); // Bellatrix not enabled + final JsonNode responseBody = OBJECT_MAPPER.readTree(response.body().string()); + + final Bytes32 blockRoot = Bytes32.fromHexString(responseBody.get("data").get("root").asText()); + assertThat(blockRoot).isEqualTo(created.getLast().getBlock().getRoot()); + assertThat(responseBody.get("execution_optimistic").asBoolean()).isFalse(); } @Test diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetBlsToExecutionChangesIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetBlsToExecutionChangesIntegrationTest.java index 9b5f375f418..8a86f689d88 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetBlsToExecutionChangesIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetBlsToExecutionChangesIntegrationTest.java @@ -19,22 +19,29 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import com.fasterxml.jackson.databind.JsonNode; -import com.fasterxml.jackson.databind.type.CollectionType; import java.io.IOException; +import java.util.ArrayList; import java.util.List; import java.util.Map; import java.util.Optional; -import java.util.Set; -import java.util.stream.Collectors; import okhttp3.Response; +import org.apache.tuweni.bytes.Bytes; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; import tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.GetBlsToExecutionChanges; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.bytes.Bytes20; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.datastructures.operations.BlsToExecutionChange; +import tech.pegasys.teku.spec.datastructures.operations.BlsToExecutionChangeSchema; import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChange; +import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChangeSchema; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsCapella; import tech.pegasys.teku.spec.util.DataStructureUtil; import tech.pegasys.teku.statetransition.validation.InternalValidationResult; @@ -52,8 +59,8 @@ public void beforeEach() { @Test void getBlsToExecutionChangesFromPoolReturnsOk() throws IOException { - final Set expectedOperations = - Set.of( + final List expectedOperations = + List.of( dataStructureUtil.randomSignedBlsToExecutionChange(), dataStructureUtil.randomSignedBlsToExecutionChange(), dataStructureUtil.randomSignedBlsToExecutionChange()); @@ -66,10 +73,7 @@ void getBlsToExecutionChangesFromPoolReturnsOk() throws IOException { Response response = getResponse(GetBlsToExecutionChanges.ROUTE); assertThat(response.code()).isEqualTo(SC_OK); - - final List operationsInResponse = readListFromResponse(response); - assertThat(operationsInResponse).hasSize(expectedOperations.size()); - assertThat(operationsInResponse).hasSameElementsAs(expectedOperations); + checkResponseContainsExactly(getResponseData(response), expectedOperations); } @Test @@ -87,26 +91,34 @@ void getLocalBlsToExecutionChangesFromPool() throws IOException { getResponse(GetBlsToExecutionChanges.ROUTE, Map.of("locally_submitted", "true")); assertThat(response.code()).isEqualTo(SC_OK); - final List operationsInResponse = readListFromResponse(response); - assertThat(operationsInResponse).hasSize(1); - assertThat(operationsInResponse).containsExactly(localChange); + checkResponseContainsExactly(getResponseData(response), List.of(localChange)); } - private List readListFromResponse(final Response response) - throws IOException { - final JsonNode body = jsonProvider.jsonToObject(response.body().string(), JsonNode.class); - final CollectionType collectionType = - jsonProvider - .getObjectMapper() - .getTypeFactory() - .constructCollectionType( - List.class, tech.pegasys.teku.api.schema.capella.SignedBlsToExecutionChange.class); - - final List data = - jsonProvider.getObjectMapper().treeToValue(body.get("data"), collectionType); - - return data.stream() - .map(op -> op.asInternalSignedBlsToExecutionChange(spec.getGenesisSpec())) - .collect(Collectors.toList()); + private void checkResponseContainsExactly( + final JsonNode data, final List blsChanges) { + assertThat(data.size()).isEqualTo(blsChanges.size()); + + final BlsToExecutionChangeSchema blsToExecutionChangeSchema = + SchemaDefinitionsCapella.required(spec.getGenesisSchemaDefinitions()) + .getBlsToExecutionChangeSchema(); + final SignedBlsToExecutionChangeSchema signedBlsToExecutionChangeSchema = + SchemaDefinitionsCapella.required(spec.getGenesisSchemaDefinitions()) + .getSignedBlsToExecutionChangeSchema(); + final List response = new ArrayList<>(); + for (int i = 0; i < blsChanges.size(); i++) { + final BlsToExecutionChange message = + blsToExecutionChangeSchema.create( + UInt64.valueOf(data.get(i).get("message").get("validator_index").asText()), + BLSPublicKey.fromHexString( + data.get(i).get("message").get("from_bls_pubkey").asText()), + Bytes20.fromHexString( + data.get(i).get("message").get("to_execution_address").asText())); + response.add( + signedBlsToExecutionChangeSchema.create( + message, + BLSSignature.fromBytesCompressed( + Bytes.fromHexString(data.get(i).get("signature").asText())))); + } + assertThat(response).hasSameElementsAs(blsChanges); } } diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetFinalizedBlockRootIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetFinalizedBlockRootIntegrationTest.java index 1bbea492232..dac311533ed 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetFinalizedBlockRootIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetFinalizedBlockRootIntegrationTest.java @@ -48,7 +48,7 @@ void shouldReturnNotFoundWhenBlockIsNotFinalized() throws IOException { Assertions.assertThat(response.code()).isEqualTo(SC_NOT_FOUND); } - private Response get(UInt64 slot) throws IOException { + private Response get(final UInt64 slot) throws IOException { return getResponse(GetFinalizedBlockRoot.ROUTE.replace("{slot}", slot.toString())); } } diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetForkIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetForkIntegrationTest.java index 9c1052cc443..8038ea21bca 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetForkIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetForkIntegrationTest.java @@ -17,14 +17,14 @@ import static tech.pegasys.teku.infrastructure.async.SafeFutureAssert.safeJoin; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import com.fasterxml.jackson.databind.JsonNode; import java.io.IOException; import okhttp3.Response; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.response.v1.beacon.GetStateForkResponse; -import tech.pegasys.teku.api.schema.Fork; import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; import tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.GetStateFork; +import tech.pegasys.teku.spec.datastructures.state.Fork; public class GetForkIntegrationTest extends AbstractDataBackedRestAPIIntegrationTest { @BeforeEach @@ -38,12 +38,14 @@ public void shouldGetForkChoiceAtEmptyHeadSlot() throws IOException { setCurrentSlot(13); final Response response = get("head"); assertThat(response.code()).isEqualTo(SC_OK); - final GetStateForkResponse body = - jsonProvider.jsonToObject(response.body().string(), GetStateForkResponse.class); - final Fork data = body.data; + final JsonNode data = getResponseData(response); - final Fork expected = new Fork(safeJoin(recentChainData.getBestState().get()).getFork()); - assertThat(expected).isEqualTo(data); + final Fork expected = safeJoin(recentChainData.getBestState().get()).getFork(); + assertThat(data.get("current_version").asText()) + .isEqualTo(expected.getCurrentVersion().toHexString()); + assertThat(data.get("previous_version").asText()) + .isEqualTo(expected.getPreviousVersion().toHexString()); + assertThat(data.get("epoch").asText()).isEqualTo(expected.getEpoch().toString()); } public Response get(final String stateIdString) throws IOException { diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetStateCommitteesTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetStateCommitteesTest.java index ce7f3e91a38..a8ef54b70bc 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetStateCommitteesTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetStateCommitteesTest.java @@ -17,20 +17,15 @@ import static org.assertj.core.api.Assertions.assertThat; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; -import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ZERO; +import com.fasterxml.jackson.databind.JsonNode; import java.io.IOException; -import java.util.List; import java.util.Map; import okhttp3.Response; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.response.v1.beacon.EpochCommitteeResponse; -import tech.pegasys.teku.api.response.v1.beacon.GetStateCommitteesResponse; import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; -import tech.pegasys.teku.beaconrestapi.BadRequest; import tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.GetStateCommittees; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; public class GetStateCommitteesTest extends AbstractDataBackedRestAPIIntegrationTest { @@ -43,25 +38,20 @@ public void setup() { public void shouldGetCommitteesWithNoQueryParameters() throws IOException { final Response response = get("head", emptyMap()); assertThat(response.code()).isEqualTo(SC_OK); - final GetStateCommitteesResponse body = - jsonProvider.jsonToObject(response.body().string(), GetStateCommitteesResponse.class); - final List data = body.data; - assertThat(data).isNotEmpty(); + final JsonNode data = getResponseData(response); + assertThat(data.size()).isGreaterThan(0); } @Test public void shouldGetCommitteesForNextEpoch() throws IOException { final Response response = get("head", Map.of("epoch", "1")); assertThat(response.code()).isEqualTo(SC_OK); - final GetStateCommitteesResponse body = - jsonProvider.jsonToObject(response.body().string(), GetStateCommitteesResponse.class); - final List data = body.data; - data.forEach( - committee -> { - assertThat(committee.slot) - .isGreaterThanOrEqualTo(UInt64.valueOf(specConfig.getSlotsPerEpoch())); - assertThat(committee.slot).isLessThan(UInt64.valueOf(specConfig.getSlotsPerEpoch() * 2L)); - }); + final JsonNode data = getResponseData(response); + for (int i = 0; i < data.size(); i++) { + assertThat(data.get(i).get("slot").asInt()) + .isGreaterThanOrEqualTo(specConfig.getSlotsPerEpoch()); + assertThat(data.get(i).get("slot").asLong()).isLessThan(specConfig.getSlotsPerEpoch() * 2L); + } assertThat(data.size()).isEqualTo(8); } @@ -69,44 +59,41 @@ public void shouldGetCommitteesForNextEpoch() throws IOException { public void shouldGetCommitteesForSingleIndex() throws IOException { final Response response = get("head", Map.of("index", "0")); assertThat(response.code()).isEqualTo(SC_OK); - final GetStateCommitteesResponse body = - jsonProvider.jsonToObject(response.body().string(), GetStateCommitteesResponse.class); - final List data = body.data; - data.forEach(committee -> assertThat(committee.index).isEqualTo(ZERO)); + final JsonNode data = getResponseData(response); assertThat(data.size()).isEqualTo(8); + for (int i = 0; i < data.size(); i++) { + assertThat(data.get(i).get("index").asInt()).isZero(); + } } @Test public void shouldGetCommitteesForSingleIndexAndSlotAndEpoch() throws IOException { final Response response = get("head", Map.of("index", "0", "slot", "9", "epoch", "1")); assertThat(response.code()).isEqualTo(SC_OK); - final GetStateCommitteesResponse body = - jsonProvider.jsonToObject(response.body().string(), GetStateCommitteesResponse.class); - final List data = body.data; - data.forEach( - committee -> { - assertThat(committee.index).isEqualTo(ZERO); - assertThat(committee.slot).isEqualTo(UInt64.valueOf(9)); - }); + final JsonNode data = getResponseData(response); assertThat(data.size()).isEqualTo(1); + assertThat(data.get(0).get("index").asInt()).isZero(); + assertThat(data.get(0).get("slot").asInt()).isEqualTo(9); + assertThat(data.get(0).get("validators").size()).isEqualTo(2); } @Test public void shouldGetBadRequestIfSlotAndEpochDontAlign() throws IOException { final Response response = get("head", Map.of("slot", "1", "epoch", "1")); assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); - final BadRequest body = jsonProvider.jsonToObject(response.body().string(), BadRequest.class); - assertThat(body.getCode()).isEqualTo(SC_BAD_REQUEST); - assertThat(body.getMessage()).isEqualToIgnoringCase("Slot 1 is not in epoch 1"); + final JsonNode body = OBJECT_MAPPER.readTree(response.body().string()); + assertThat(body.get("code").asInt()).isEqualTo(SC_BAD_REQUEST); + assertThat(body.get("message").asText()).isEqualToIgnoringCase("Slot 1 is not in epoch 1"); } @Test public void shouldGetBadRequestIfEpochTooFarInFuture() throws IOException { final Response response = get("head", Map.of("epoch", "1024000")); assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); - final BadRequest body = jsonProvider.jsonToObject(response.body().string(), BadRequest.class); - assertThat(body.getCode()).isEqualTo(SC_BAD_REQUEST); - assertThat(body.getMessage()).startsWith("Epoch 1024000 is too far ahead "); + + final JsonNode body = OBJECT_MAPPER.readTree(response.body().string()); + assertThat(body.get("code").asInt()).isEqualTo(SC_BAD_REQUEST); + assertThat(body.get("message").asText()).startsWith("Epoch 1024000 is too far ahead "); } public Response get(final String stateIdString, final Map query) diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetStateFinalityCheckpointsTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetStateFinalityCheckpointsTest.java index 1e161548de1..5df9c8a7294 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetStateFinalityCheckpointsTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetStateFinalityCheckpointsTest.java @@ -14,14 +14,12 @@ package tech.pegasys.teku.beaconrestapi.v1.beacon; import static org.assertj.core.api.Assertions.assertThat; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import com.fasterxml.jackson.databind.JsonNode; import java.io.IOException; import okhttp3.Response; +import org.apache.tuweni.bytes.Bytes32; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.response.v1.beacon.FinalityCheckpointsResponse; -import tech.pegasys.teku.api.response.v1.beacon.GetStateFinalityCheckpointsResponse; -import tech.pegasys.teku.api.schema.Checkpoint; import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; import tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.GetStateFinalityCheckpoints; @@ -31,16 +29,16 @@ public class GetStateFinalityCheckpointsTest extends AbstractDataBackedRestAPIIn public void shouldGetEmptyCheckpointsAtGenesis() throws IOException { startRestAPIAtGenesis(); final Response response = get("genesis"); + final JsonNode data = getResponseData(response); - assertThat(response.code()).isEqualTo(SC_OK); - final GetStateFinalityCheckpointsResponse body = - jsonProvider.jsonToObject( - response.body().string(), GetStateFinalityCheckpointsResponse.class); - final FinalityCheckpointsResponse data = body.data; + checkIsEmpty(data.get("current_justified")); + checkIsEmpty(data.get("previous_justified")); + checkIsEmpty(data.get("finalized")); + } - assertThat(data.current_justified).isEqualTo(Checkpoint.EMPTY); - assertThat(data.previous_justified).isEqualTo(Checkpoint.EMPTY); - assertThat(data.finalized).isEqualTo(Checkpoint.EMPTY); + private void checkIsEmpty(final JsonNode node) { + assertThat(node.get("root").asText()).isEqualTo(Bytes32.ZERO.toHexString()); + assertThat(node.get("epoch").asInt()).isZero(); } public Response get(final String stateIdString) throws IOException { diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetStateRootIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetStateRootIntegrationTest.java index 1df8de6608f..eb43338c9cd 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetStateRootIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetStateRootIntegrationTest.java @@ -17,12 +17,12 @@ import static tech.pegasys.teku.infrastructure.async.SafeFutureAssert.safeJoin; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import com.fasterxml.jackson.databind.JsonNode; import java.io.IOException; import okhttp3.Response; import org.apache.tuweni.bytes.Bytes32; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.response.v1.beacon.GetStateRootResponse; import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; import tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.GetStateRoot; @@ -44,10 +44,9 @@ public void shouldStateRootAtEmptyHeadSlot() throws IOException { .orElse(Bytes32.ZERO); final Response response = get("head"); assertThat(response.code()).isEqualTo(SC_OK); - final GetStateRootResponse body = - jsonProvider.jsonToObject(response.body().string(), GetStateRootResponse.class); + final JsonNode data = getResponseData(response); - assertThat(body.data.root.toHexString()).isEqualTo(chainHeadStateRoot.toHexString()); + assertThat(data.get("root").asText()).isEqualTo(chainHeadStateRoot.toHexString()); } public Response get(final String stateIdString) throws IOException { diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetStateValidatorBalancesIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetStateValidatorBalancesIntegrationTest.java index 7e1953585fd..ce2761faa01 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetStateValidatorBalancesIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetStateValidatorBalancesIntegrationTest.java @@ -16,17 +16,15 @@ import static org.assertj.core.api.Assertions.assertThat; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import com.fasterxml.jackson.databind.JsonNode; import java.io.IOException; import java.util.Collections; import java.util.Map; import okhttp3.Response; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.response.v1.beacon.GetStateValidatorBalancesResponse; -import tech.pegasys.teku.api.response.v1.beacon.ValidatorBalanceResponse; import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; import tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.GetStateValidatorBalances; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; public class GetStateValidatorBalancesIntegrationTest extends AbstractDataBackedRestAPIIntegrationTest { @@ -40,32 +38,28 @@ public void setup() { public void queryFiltersCanRemoveAllResults() throws IOException { final Response response = get("head", Map.of("id", "1024000")); assertThat(response.code()).isEqualTo(SC_OK); - final GetStateValidatorBalancesResponse body = - jsonProvider.jsonToObject( - response.body().string(), GetStateValidatorBalancesResponse.class); - assertThat(body.data).isEmpty(); + final JsonNode data = getResponseData(response); + assertThat(data).isEmpty(); } @Test public void queryFiltersCanFilterOnValidatorId() throws IOException { final Response response = get("genesis", Map.of("id", "1,16")); assertThat(response.code()).isEqualTo(SC_OK); - final GetStateValidatorBalancesResponse body = - jsonProvider.jsonToObject( - response.body().string(), GetStateValidatorBalancesResponse.class); - assertThat(body.data) - .containsExactly( - new ValidatorBalanceResponse(UInt64.valueOf(1), specConfig.getMaxEffectiveBalance())); + + final JsonNode data = getResponseData(response); + assertThat(data.get(0).get("index").asInt()).isEqualTo(1); + assertThat(data.get(0).get("balance").asLong()) + .isEqualTo(specConfig.getMaxEffectiveBalance().longValue()); + assertThat(data.size()).isEqualTo(1); } @Test public void shouldReturnAllBalancesWithoutQueryParameter() throws IOException { final Response response = get("finalized", Collections.emptyMap()); assertThat(response.code()).isEqualTo(SC_OK); - final GetStateValidatorBalancesResponse body = - jsonProvider.jsonToObject( - response.body().string(), GetStateValidatorBalancesResponse.class); - assertThat(body.data).hasSize(16); + final JsonNode data = getResponseData(response); + assertThat(data).hasSize(16); } public Response get(final String stateIdString, final Map query) diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetStateValidatorIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetStateValidatorIntegrationTest.java index 9b84365ed22..16720bd7a54 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetStateValidatorIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/GetStateValidatorIntegrationTest.java @@ -18,14 +18,13 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import com.fasterxml.jackson.databind.JsonNode; import java.io.IOException; import okhttp3.Response; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.response.v1.beacon.GetStateValidatorResponse; import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; import tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.GetStateValidator; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; public class GetStateValidatorIntegrationTest extends AbstractDataBackedRestAPIIntegrationTest { @BeforeEach @@ -37,9 +36,8 @@ public void setup() { public void shouldGetValidatorResponseForKnownValidatorFromKnownState() throws IOException { final Response response = get("genesis", "1"); assertThat(response.code()).isEqualTo(SC_OK); - final GetStateValidatorResponse body = - jsonProvider.jsonToObject(response.body().string(), GetStateValidatorResponse.class); - assertThat(body.data.index).isEqualTo(UInt64.ONE); + final JsonNode data = getResponseData(response); + assertThat(data.get("index").asInt()).isEqualTo(1); } @Test diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/PostAttesterSlashingIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/PostAttesterSlashingIntegrationTest.java index 5bd019b3d96..142d14ee5b4 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/PostAttesterSlashingIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/PostAttesterSlashingIntegrationTest.java @@ -18,16 +18,18 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import okhttp3.Response; -import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.schema.AttesterSlashing; import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; import tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.PostAttesterSlashing; import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.json.JsonUtil; import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; import tech.pegasys.teku.spec.util.DataStructureUtil; import tech.pegasys.teku.statetransition.validation.InternalValidationResult; @@ -43,44 +45,41 @@ public void setup() { @Test public void shouldReturnBadRequestWhenRequestBodyIsEmpty() throws Exception { - Response response = post(PostAttesterSlashing.ROUTE, jsonProvider.objectToJSON("")); - Assertions.assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); + checkEmptyBodyToRoute(PostAttesterSlashing.ROUTE, SC_BAD_REQUEST); } @Test public void shouldReturnBadRequestWhenRequestBodyIsInvalid() throws Exception { - Response response = - post(PostAttesterSlashing.ROUTE, jsonProvider.objectToJSON("{\"foo\": \"bar\"}")); - assertThat(response.code()).isEqualTo(400); + final Response response = post(PostAttesterSlashing.ROUTE, "{\"foo\": \"bar\"}"); + assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); } @Test public void shouldReturnServerErrorWhenUnexpectedErrorHappens() throws Exception { - final tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing slashing = - dataStructureUtil.randomAttesterSlashing(); - - final AttesterSlashing schemaSlashing = new AttesterSlashing(slashing); - + final AttesterSlashing slashing = dataStructureUtil.randomAttesterSlashing(); doThrow(new RuntimeException()).when(attesterSlashingPool).addLocal(slashing); - Response response = post(PostAttesterSlashing.ROUTE, jsonProvider.objectToJSON(schemaSlashing)); - assertThat(response.code()).isEqualTo(500); + final Response response = + post( + PostAttesterSlashing.ROUTE, + JsonUtil.serialize(slashing, slashing.getSchema().getJsonTypeDefinition())); + assertThat(response.code()).isEqualTo(SC_INTERNAL_SERVER_ERROR); } @Test public void shouldReturnSuccessWhenRequestBodyIsValid() throws Exception { - final tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing slashing = - dataStructureUtil.randomAttesterSlashing(); - - final AttesterSlashing schemaSlashing = new AttesterSlashing(slashing); + final AttesterSlashing slashing = dataStructureUtil.randomAttesterSlashing(); when(attesterSlashingPool.addLocal(slashing)) .thenReturn(SafeFuture.completedFuture(InternalValidationResult.ACCEPT)); - Response response = post(PostAttesterSlashing.ROUTE, jsonProvider.objectToJSON(schemaSlashing)); + final Response response = + post( + PostAttesterSlashing.ROUTE, + JsonUtil.serialize(slashing, slashing.getSchema().getJsonTypeDefinition())); verify(attesterSlashingPool).addLocal(slashing); - assertThat(response.code()).isEqualTo(200); + assertThat(response.code()).isEqualTo(SC_OK); } } diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/PostBlsToExecutionChangesIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/PostBlsToExecutionChangesIntegrationTest.java index 085eac610a1..73ddc21e05d 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/PostBlsToExecutionChangesIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/PostBlsToExecutionChangesIntegrationTest.java @@ -18,18 +18,21 @@ import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition.listOf; +import com.fasterxml.jackson.databind.JsonNode; import java.io.IOException; import java.util.List; import okhttp3.Response; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.schema.capella.SignedBlsToExecutionChange; import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; import tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.PostBlsToExecutionChanges; import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.json.JsonUtil; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChange; import tech.pegasys.teku.spec.util.DataStructureUtil; import tech.pegasys.teku.statetransition.validation.InternalValidationResult; @@ -47,34 +50,33 @@ public void beforeEach() { @Test void postValidBlsToExecutionReturnsOk() throws IOException { - final tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChange item = - dataStructureUtil.randomSignedBlsToExecutionChange(); - final List requestBody = - List.of(new SignedBlsToExecutionChange(item)); - + final SignedBlsToExecutionChange item = dataStructureUtil.randomSignedBlsToExecutionChange(); when(validator.validateForGossip(any())) .thenReturn(SafeFuture.completedFuture(InternalValidationResult.ACCEPT)); - Response response = - post(PostBlsToExecutionChanges.ROUTE, jsonProvider.objectToJSON(requestBody)); + final Response response = + post( + PostBlsToExecutionChanges.ROUTE, + JsonUtil.serialize(List.of(item), listOf(item.getSchema().getJsonTypeDefinition()))); assertThat(response.code()).isEqualTo(SC_OK); } @Test void postInvalidBlsToExecutionReturnsBadRequest() throws IOException { - final tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChange item = - dataStructureUtil.randomSignedBlsToExecutionChange(); - final List requestBody = - List.of(new SignedBlsToExecutionChange(item)); + final SignedBlsToExecutionChange item = dataStructureUtil.randomSignedBlsToExecutionChange(); when(validator.validateForGossip(any())) .thenReturn(SafeFuture.completedFuture(InternalValidationResult.reject("Invalid!"))); - Response response = - post(PostBlsToExecutionChanges.ROUTE, jsonProvider.objectToJSON(requestBody)); + final Response response = + post( + PostBlsToExecutionChanges.ROUTE, + JsonUtil.serialize(List.of(item), listOf(item.getSchema().getJsonTypeDefinition()))); + final JsonNode body = OBJECT_MAPPER.readTree(response.body().string()); assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); - assertThat(response.body().string()).contains("Invalid!"); + assertThat(body.get("failures").get(0).get("index").asInt()).isZero(); + assertThat(body.get("failures").get(0).get("message").asText()).isEqualTo("Invalid!"); } } diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/PostProposerSlashingIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/PostProposerSlashingIntegrationTest.java index bce76742490..fc1814dd53c 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/PostProposerSlashingIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/PostProposerSlashingIntegrationTest.java @@ -18,16 +18,18 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import okhttp3.Response; -import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.schema.ProposerSlashing; import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; import tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.PostProposerSlashing; import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.json.JsonUtil; import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing; import tech.pegasys.teku.spec.util.DataStructureUtil; import tech.pegasys.teku.statetransition.validation.InternalValidationResult; @@ -43,44 +45,42 @@ public void setup() { @Test public void shouldReturnBadRequestWhenRequestBodyIsEmpty() throws Exception { - Response response = post(PostProposerSlashing.ROUTE, jsonProvider.objectToJSON("")); - Assertions.assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); + checkEmptyBodyToRoute(PostProposerSlashing.ROUTE, SC_BAD_REQUEST); } @Test public void shouldReturnBadRequestWhenRequestBodyIsInvalid() throws Exception { - Response response = - post(PostProposerSlashing.ROUTE, jsonProvider.objectToJSON("{\"foo\": \"bar\"}")); - assertThat(response.code()).isEqualTo(400); + final Response response = post(PostProposerSlashing.ROUTE, "{\"foo\": \"bar\"}"); + assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); } @Test public void shouldReturnServerErrorWhenUnexpectedErrorHappens() throws Exception { - final tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing slashing = - dataStructureUtil.randomProposerSlashing(); - - final ProposerSlashing schemaSlashing = new ProposerSlashing(slashing); + final ProposerSlashing slashing = dataStructureUtil.randomProposerSlashing(); doThrow(new RuntimeException()).when(proposerSlashingPool).addLocal(slashing); - Response response = post(PostProposerSlashing.ROUTE, jsonProvider.objectToJSON(schemaSlashing)); - assertThat(response.code()).isEqualTo(500); + final Response response = + post( + PostProposerSlashing.ROUTE, + JsonUtil.serialize(slashing, slashing.getSchema().getJsonTypeDefinition())); + + assertThat(response.code()).isEqualTo(SC_INTERNAL_SERVER_ERROR); } @Test public void shouldReturnSuccessWhenRequestBodyIsValid() throws Exception { - final tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing slashing = - dataStructureUtil.randomProposerSlashing(); - - final ProposerSlashing schemaSlashing = new ProposerSlashing(slashing); - + final ProposerSlashing slashing = dataStructureUtil.randomProposerSlashing(); when(proposerSlashingPool.addLocal(slashing)) .thenReturn(SafeFuture.completedFuture(InternalValidationResult.ACCEPT)); - Response response = post(PostProposerSlashing.ROUTE, jsonProvider.objectToJSON(schemaSlashing)); + final Response response = + post( + PostProposerSlashing.ROUTE, + JsonUtil.serialize(slashing, slashing.getSchema().getJsonTypeDefinition())); verify(proposerSlashingPool).addLocal(slashing); - assertThat(response.code()).isEqualTo(200); + assertThat(response.code()).isEqualTo(SC_OK); } } diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/PostSyncCommitteesIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/PostSyncCommitteesIntegrationTest.java index b8da4f2c02d..c48e8440477 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/PostSyncCommitteesIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/PostSyncCommitteesIntegrationTest.java @@ -18,22 +18,21 @@ import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition.listOf; +import com.fasterxml.jackson.databind.JsonNode; import java.io.IOException; -import java.util.Collections; import java.util.List; -import java.util.stream.Collectors; import okhttp3.Response; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.response.v1.beacon.PostDataFailureResponse; -import tech.pegasys.teku.api.schema.BLSSignature; -import tech.pegasys.teku.api.schema.altair.SyncCommitteeMessage; import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; import tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.PostSyncCommittees; import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.json.JsonUtil; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeMessage; import tech.pegasys.teku.spec.util.DataStructureUtil; import tech.pegasys.teku.validator.api.SubmitDataError; @@ -43,46 +42,38 @@ public class PostSyncCommitteesIntegrationTest extends AbstractDataBackedRestAPI @Test void shouldSubmitSyncCommitteesAndGetResponse() throws IOException { spec = TestSpecFactory.createMinimalAltair(); - DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); + final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); startRestAPIAtGenesis(SpecMilestone.ALTAIR); - final List requestBody = - List.of( - new SyncCommitteeMessage( - UInt64.ONE, - dataStructureUtil.randomBytes32(), - dataStructureUtil.randomUInt64(), - new BLSSignature(dataStructureUtil.randomSignature()))); + final SyncCommitteeMessage message = dataStructureUtil.randomSyncCommitteeMessage(); final SafeFuture> future = SafeFuture.completedFuture(List.of(new SubmitDataError(UInt64.ZERO, ERROR_MESSAGE))); - when(validatorApiChannel.sendSyncCommitteeMessages( - requestBody.get(0).asInternalCommitteeSignature(spec).stream() - .collect(Collectors.toList()))) - .thenReturn(future); - Response response = post(PostSyncCommittees.ROUTE, jsonProvider.objectToJSON(requestBody)); + when(validatorApiChannel.sendSyncCommitteeMessages(any())).thenReturn(future); + final Response response = + post( + PostSyncCommittees.ROUTE, + JsonUtil.serialize( + List.of(dataStructureUtil.randomSyncCommitteeMessage()), + listOf(message.getSchema().getJsonTypeDefinition()))); assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); - final PostDataFailureResponse responseBody = - jsonProvider.jsonToObject(response.body().string(), PostDataFailureResponse.class); - - assertThat(responseBody.failures.get(0).message).isEqualTo(ERROR_MESSAGE); + final JsonNode body = OBJECT_MAPPER.readTree(response.body().string()); + assertThat(body.get("failures").get(0).get("message").asText()).isEqualTo(ERROR_MESSAGE); } @Test void shouldGet200OkWhenThereAreNoErrors() throws Exception { spec = TestSpecFactory.createMinimalAltair(); - DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); + final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); startRestAPIAtGenesis(SpecMilestone.ALTAIR); - final List requestBody = - List.of( - new SyncCommitteeMessage( - UInt64.ONE, - dataStructureUtil.randomBytes32(), - dataStructureUtil.randomUInt64(), - new BLSSignature(dataStructureUtil.randomSignature()))); - final SafeFuture> future = - SafeFuture.completedFuture(Collections.emptyList()); + final SyncCommitteeMessage message = dataStructureUtil.randomSyncCommitteeMessage(); + final SafeFuture> future = SafeFuture.completedFuture(List.of()); when(validatorApiChannel.sendSyncCommitteeMessages(any())).thenReturn(future); - Response response = post(PostSyncCommittees.ROUTE, jsonProvider.objectToJSON(requestBody)); + final Response response = + post( + PostSyncCommittees.ROUTE, + JsonUtil.serialize( + List.of(dataStructureUtil.randomSyncCommitteeMessage()), + listOf(message.getSchema().getJsonTypeDefinition()))); assertThat(response.code()).isEqualTo(SC_OK); assertThat(response.body().string()).isEmpty(); @@ -92,15 +83,13 @@ void shouldGet200OkWhenThereAreNoErrors() throws Exception { void phase0SlotCausesBadRequest() throws IOException { startRestAPIAtGenesis(SpecMilestone.PHASE0); spec = TestSpecFactory.createMinimalPhase0(); - DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); - final List requestBody = - List.of( - new SyncCommitteeMessage( - UInt64.ONE, - dataStructureUtil.randomBytes32(), - dataStructureUtil.randomUInt64(), - new BLSSignature(dataStructureUtil.randomSignature()))); - Response response = post(PostSyncCommittees.ROUTE, jsonProvider.objectToJSON(requestBody)); + final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); + final Response response = + post( + PostSyncCommittees.ROUTE, + String.format( + "[{\"slot\":\"1\",\"beacon_block_root\":\"%s\",\"validator_index\":\"1\",\"signature\":\"%s\"}]", + dataStructureUtil.randomBytes32(), dataStructureUtil.randomSignature())); assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); assertThat(response.body().string()) .contains("Could not create sync committee signature at phase0 slot 1"); diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/PostVoluntaryExitIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/PostVoluntaryExitIntegrationTest.java index fdae8c8b0d2..4b7edcb8217 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/PostVoluntaryExitIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/beacon/PostVoluntaryExitIntegrationTest.java @@ -24,11 +24,12 @@ import okhttp3.Response; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.schema.SignedVoluntaryExit; import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; import tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.PostVoluntaryExit; import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.json.JsonUtil; import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; import tech.pegasys.teku.spec.util.DataStructureUtil; import tech.pegasys.teku.statetransition.validation.InternalValidationResult; @@ -44,56 +45,55 @@ public void setup() { @Test public void shouldReturnBadRequestWhenRequestBodyIsInvalid() throws Exception { - Response response = - post(PostVoluntaryExit.ROUTE, jsonProvider.objectToJSON("{\"foo\": \"bar\"}")); + final Response response = post(PostVoluntaryExit.ROUTE, "{\"foo\": \"bar\"}"); assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); } @Test public void shouldReturnBadRequestWhenRequestBodyIsEmpty() throws Exception { - Response response = post(PostVoluntaryExit.ROUTE, jsonProvider.objectToJSON("")); - assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); + checkEmptyBodyToRoute(PostVoluntaryExit.ROUTE, SC_BAD_REQUEST); } @Test public void shouldIncludeRejectReasonWhenOperationValidatorRejectsOperation() throws Exception { - final tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit signedVoluntaryExit = - dataStructureUtil.randomSignedVoluntaryExit(); - - final SignedVoluntaryExit schemaExit = new SignedVoluntaryExit(signedVoluntaryExit); - + final SignedVoluntaryExit signedVoluntaryExit = dataStructureUtil.randomSignedVoluntaryExit(); when(voluntaryExitPool.addLocal(signedVoluntaryExit)) .thenReturn(SafeFuture.completedFuture(InternalValidationResult.reject("the reason"))); - Response response = post(PostVoluntaryExit.ROUTE, jsonProvider.objectToJSON(schemaExit)); + final Response response = + post( + PostVoluntaryExit.ROUTE, + JsonUtil.serialize( + signedVoluntaryExit, signedVoluntaryExit.getSchema().getJsonTypeDefinition())); assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); assertThat(response.body().string()).contains("the reason"); } @Test public void shouldReturnServerErrorWhenUnexpectedErrorHappens() throws Exception { - final tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit signedVoluntaryExit = - dataStructureUtil.randomSignedVoluntaryExit(); - - final SignedVoluntaryExit schemaExit = new SignedVoluntaryExit(signedVoluntaryExit); - + final SignedVoluntaryExit signedVoluntaryExit = dataStructureUtil.randomSignedVoluntaryExit(); doThrow(new RuntimeException()).when(voluntaryExitPool).addLocal(signedVoluntaryExit); - Response response = post(PostVoluntaryExit.ROUTE, jsonProvider.objectToJSON(schemaExit)); + final Response response = + post( + PostVoluntaryExit.ROUTE, + JsonUtil.serialize( + signedVoluntaryExit, signedVoluntaryExit.getSchema().getJsonTypeDefinition())); assertThat(response.code()).isEqualTo(SC_INTERNAL_SERVER_ERROR); } @Test public void shouldReturnSuccessWhenRequestBodyIsValid() throws Exception { - final tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit signedVoluntaryExit = - dataStructureUtil.randomSignedVoluntaryExit(); - - final SignedVoluntaryExit schemaExit = new SignedVoluntaryExit(signedVoluntaryExit); + final SignedVoluntaryExit signedVoluntaryExit = dataStructureUtil.randomSignedVoluntaryExit(); when(voluntaryExitPool.addLocal(signedVoluntaryExit)) .thenReturn(SafeFuture.completedFuture(InternalValidationResult.ACCEPT)); - Response response = post(PostVoluntaryExit.ROUTE, jsonProvider.objectToJSON(schemaExit)); + final Response response = + post( + PostVoluntaryExit.ROUTE, + JsonUtil.serialize( + signedVoluntaryExit, signedVoluntaryExit.getSchema().getJsonTypeDefinition())); verify(voluntaryExitPool).addLocal(signedVoluntaryExit); diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/node/GetIdentityIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/node/GetIdentityIntegrationTest.java index 1c8ff0233e8..922ad62a986 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/node/GetIdentityIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/node/GetIdentityIntegrationTest.java @@ -17,6 +17,7 @@ import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import com.fasterxml.jackson.databind.JsonNode; import java.io.IOException; import java.util.Collections; import java.util.List; @@ -24,9 +25,6 @@ import okhttp3.Response; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.response.v1.node.Identity; -import tech.pegasys.teku.api.response.v1.node.IdentityResponse; -import tech.pegasys.teku.api.schema.Metadata; import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; import tech.pegasys.teku.beaconrestapi.handlers.v1.node.GetIdentity; import tech.pegasys.teku.infrastructure.unsigned.UInt64; @@ -48,8 +46,8 @@ public class GetIdentityIntegrationTest extends AbstractDataBackedRestAPIIntegra void setup() { when(eth2P2PNetwork.getNodeId()).thenReturn(node1); when(eth2P2PNetwork.getEnr()).thenReturn(Optional.of(enr)); - when(eth2P2PNetwork.getNodeAddress()).thenReturn(address); - when(eth2P2PNetwork.getDiscoveryAddress()).thenReturn(Optional.of(discoveryAddress)); + when(eth2P2PNetwork.getNodeAddresses()).thenReturn(List.of(address)); + when(eth2P2PNetwork.getDiscoveryAddresses()).thenReturn(Optional.of(List.of(discoveryAddress))); } @Test @@ -62,18 +60,10 @@ public void shouldReturnNetworkIdentity() throws Exception { when(eth2P2PNetwork.getMetadata()).thenReturn(metadataMessage); - final Response response = get(); + final Response response = getResponse(GetIdentity.ROUTE); assertThat(response.code()).isEqualTo(SC_OK); - final IdentityResponse identityResponse = - jsonProvider.jsonToObject(response.body().string(), IdentityResponse.class); - assertThat(identityResponse.data) - .isEqualTo( - new Identity( - node1.toBase58(), - enr, - List.of(address), - List.of(discoveryAddress), - new Metadata(metadataMessage))); + checkResponseData( + response, "{\"seq_number\":\"4666673844721362956\",\"attnets\":\"0x0288000000000000\"}"); } @Test @@ -87,23 +77,16 @@ public void shouldReturnNetworkIdentityAltair() throws Exception { when(eth2P2PNetwork.getMetadata()).thenReturn(metadataMessage); - final Response response = get(); + final Response response = getResponse(GetIdentity.ROUTE); assertThat(response.code()).isEqualTo(SC_OK); - final IdentityResponse identityResponse = - jsonProvider.jsonToObject(response.body().string(), IdentityResponse.class); - assertThat(identityResponse.data) - .isEqualTo( - new Identity( - node1.toBase58(), - enr, - List.of(address), - List.of(discoveryAddress), - new Metadata(metadataMessage))); + checkResponseData( + response, + "{\"seq_number\":\"4666673844721362956\",\"attnets\":\"0x0288000000000000\",\"syncnets\":\"0x0f\"}"); } @Test public void shouldReturnNetworkIdentityEip7594() throws Exception { - startRestAPIAtGenesis(SpecMilestone.EIP7594); + startRestAPIAtGenesis(SpecMilestone.ELECTRA); final MetadataMessage metadataMessage = spec.getGenesisSchemaDefinitions() @@ -112,21 +95,21 @@ public void shouldReturnNetworkIdentityEip7594() throws Exception { when(eth2P2PNetwork.getMetadata()).thenReturn(metadataMessage); - final Response response = get(); + final Response response = getResponse(GetIdentity.ROUTE); assertThat(response.code()).isEqualTo(SC_OK); - final IdentityResponse identityResponse = - jsonProvider.jsonToObject(response.body().string(), IdentityResponse.class); - assertThat(identityResponse.data) - .isEqualTo( - new Identity( - node1.toBase58(), - enr, - List.of(address), - List.of(discoveryAddress), - new Metadata(metadataMessage))); + checkResponseData( + response, + "{\"seq_number\":\"4666673844721362956\",\"attnets\":\"0x0288000000000000\",\"syncnets\":\"0x0f\"}"); } - private Response get() throws IOException { - return getResponse(GetIdentity.ROUTE); + private void checkResponseData(final Response response, final String metadata) + throws IOException { + final JsonNode data = getResponseData(response); + + assertThat(data.get("peer_id").asText()).isEqualTo(node1.toBase58()); + assertThat(data.get("enr").asText()).isEqualTo(enr); + assertThat(data.get("p2p_addresses").get(0).asText()).isEqualTo(address); + assertThat(data.get("discovery_addresses").get(0).asText()).isEqualTo(discoveryAddress); + assertThat(data.get("metadata").toString()).isEqualTo(metadata); } } diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/node/GetPeerByIdIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/node/GetPeerByIdIntegrationTest.java index 9408ac08455..511a45adef7 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/node/GetPeerByIdIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/node/GetPeerByIdIntegrationTest.java @@ -19,14 +19,11 @@ import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import com.fasterxml.jackson.databind.JsonNode; import java.io.IOException; import java.util.Optional; import okhttp3.Response; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.response.v1.node.Direction; -import tech.pegasys.teku.api.response.v1.node.Peer; -import tech.pegasys.teku.api.response.v1.node.PeerResponse; -import tech.pegasys.teku.api.response.v1.node.State; import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; import tech.pegasys.teku.beaconrestapi.handlers.v1.node.GetPeerById; import tech.pegasys.teku.networking.eth2.peers.Eth2Peer; @@ -51,16 +48,13 @@ public void shouldGetPeerById() throws IOException { final Response response = get("QmYyQSo1c1Ym7orWxLYvCrM2EmxFTANf8wXmmE7DWjhx5N"); assertThat(response.code()).isEqualTo(SC_OK); - final PeerResponse peerResponse = - jsonProvider.jsonToObject(response.body().string(), PeerResponse.class); - assertThat(peerResponse.data) - .isEqualTo( - new Peer( - node1.toBase58(), - null, - "/ip/1.2.3.4/tcp/4242/p2p/aeiou", - State.connected, - Direction.outbound)); + final JsonNode data = getResponseData(response); + assertThat(data.get("peer_id").asText()).isEqualTo(node1.toBase58()); + assertThat(data.get("enr")).isNull(); + assertThat(data.get("last_seen_p2p_address").asText()) + .isEqualTo("/ip/1.2.3.4/tcp/4242/p2p/aeiou"); + assertThat(data.get("state").asText()).isEqualTo("connected"); + assertThat(data.get("direction").asText()).isEqualTo("outbound"); } private Response get(final String peerId) throws IOException { diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/node/GetSyncingIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/node/GetSyncingIntegrationTest.java index fc85c8e0065..d61a02d6cd1 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/node/GetSyncingIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/node/GetSyncingIntegrationTest.java @@ -17,11 +17,10 @@ import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import com.fasterxml.jackson.databind.JsonNode; import java.io.IOException; import okhttp3.Response; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.response.v1.node.Syncing; -import tech.pegasys.teku.api.response.v1.node.SyncingResponse; import tech.pegasys.teku.beacon.sync.events.SyncState; import tech.pegasys.teku.beacon.sync.events.SyncingStatus; import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; @@ -35,13 +34,7 @@ public void shouldGetSyncStatusWhenSyncing() throws IOException { startRestAPIAtGenesis(); when(syncService.getSyncStatus()).thenReturn(getSyncStatus(true, 1, 10, 15)); when(syncService.getCurrentSyncState()).thenReturn(SyncState.SYNCING); - - final Response response = get(); - assertThat(response.code()).isEqualTo(SC_OK); - final SyncingResponse syncingResponse = - jsonProvider.jsonToObject(response.body().string(), SyncingResponse.class); - assertThat(syncingResponse.data) - .isEqualTo(new Syncing(UInt64.valueOf(10), UInt64.valueOf(5), true, false)); + verifyData(10, 5, true, false); } @Test @@ -49,14 +42,7 @@ public void shouldGetSyncStatusWhenNotSyncing() throws IOException { startRestAPIAtGenesis(); when(syncService.getSyncStatus()).thenReturn(getSyncStatus(false, 6, 11, 16)); when(syncService.getCurrentSyncState()).thenReturn(SyncState.IN_SYNC); - - final Response response = get(); - assertThat(response.code()).isEqualTo(SC_OK); - final SyncingResponse syncingResponse = - jsonProvider.jsonToObject(response.body().string(), SyncingResponse.class); - assertThat(syncingResponse.data) - // 0 sync distance because we're not syncing. - .isEqualTo(new Syncing(UInt64.valueOf(11), UInt64.ZERO, false, false)); + verifyData(11, 0, false, false); } @Test @@ -66,17 +52,20 @@ public void shouldGetSyncStatusWhenElOffline() throws IOException { when(syncService.getCurrentSyncState()).thenReturn(SyncState.SYNCING); // update EL availability dataProvider.getExecutionClientDataProvider().onAvailabilityUpdated(false); + verifyData(10, 5, true, true); + } - final Response response = get(); + private void verifyData( + final int headSlot, final int syncDistance, final boolean isSyncing, final boolean elOffline) + throws IOException { + final Response response = getResponse(GetSyncing.ROUTE); assertThat(response.code()).isEqualTo(SC_OK); - final SyncingResponse syncingResponse = - jsonProvider.jsonToObject(response.body().string(), SyncingResponse.class); - assertThat(syncingResponse.data) - .isEqualTo(new Syncing(UInt64.valueOf(10), UInt64.valueOf(5), true, true)); - } + final JsonNode data = getResponseData(response); - private Response get() throws IOException { - return getResponse(GetSyncing.ROUTE); + assertThat(data.get("head_slot").asInt()).isEqualTo(headSlot); + assertThat(data.get("sync_distance").asInt()).isEqualTo(syncDistance); + assertThat(data.get("is_syncing").asBoolean()).isEqualTo(isSyncing); + assertThat(data.get("el_offline").asBoolean()).isEqualTo(elOffline); } private SyncingStatus getSyncStatus( diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/node/GetVersionIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/node/GetVersionIntegrationTest.java index de135e6c406..fc076ba87e9 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/node/GetVersionIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/node/GetVersionIntegrationTest.java @@ -16,10 +16,10 @@ import static org.assertj.core.api.Assertions.assertThat; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import com.fasterxml.jackson.databind.JsonNode; import java.io.IOException; import okhttp3.Response; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.response.v1.node.VersionResponse; import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; import tech.pegasys.teku.beaconrestapi.handlers.v1.node.GetVersion; @@ -30,9 +30,8 @@ public void shouldGetVersionFromRunningServer() throws IOException { startRestAPIAtGenesis(); final Response response = get(); assertThat(response.code()).isEqualTo(SC_OK); - final VersionResponse versionResponse = - jsonProvider.jsonToObject(response.body().string(), VersionResponse.class); - assertThat(versionResponse.data.version).startsWith("teku/"); + final JsonNode data = getResponseData(response); + assertThat(data.get("version").asText()).startsWith("teku/"); } private Response get() throws IOException { diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/rewards/GetAttestationRewardsIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/rewards/GetAttestationRewardsIntegrationTest.java index 122cafc37c3..86be3da6fac 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/rewards/GetAttestationRewardsIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/rewards/GetAttestationRewardsIntegrationTest.java @@ -95,7 +95,7 @@ private Response sendGetAttestationRewardsRequest( final long epoch, final List validatorIds) { try { final String requestBody = - validatorIds != null ? jsonProvider.objectToJSON(validatorIds) : ""; + validatorIds != null ? OBJECT_MAPPER.writeValueAsString(validatorIds) : ""; return post( GetAttestationRewards.ROUTE.replace("{epoch}", String.valueOf(epoch)), requestBody); } catch (IOException e) { diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/rewards/GetSyncCommitteeRewardsIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/rewards/GetSyncCommitteeRewardsIntegrationTest.java index daf3fb85fae..ac8f835fb4e 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/rewards/GetSyncCommitteeRewardsIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/rewards/GetSyncCommitteeRewardsIntegrationTest.java @@ -62,11 +62,8 @@ public void setup() { @Test public void handleEmptyRequestBodyList() throws IOException { - final List requestBody = List.of(); final Response response1 = - post( - GetSyncCommitteeRewards.ROUTE.replace("{block_id}", "head"), - jsonProvider.objectToJSON(requestBody)); + post(GetSyncCommitteeRewards.ROUTE.replace("{block_id}", "head"), "[]"); final SyncCommitteeRewardData data = new SyncCommitteeRewardData(false, false); data.increaseReward(0, 11180L); @@ -99,10 +96,10 @@ public void handleEmptyRequestBodyList() throws IOException { @Test public void shouldReturnBadRequestWhenOutOfValidatorRange() throws IOException { final List requestBody = List.of("9a"); - Response response = + final Response response = post( GetSyncCommitteeRewards.ROUTE.replace("{block_id}", "head"), - jsonProvider.objectToJSON(requestBody)); + OBJECT_MAPPER.writeValueAsString(requestBody)); assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); assertThat(response.body().string()) @@ -113,10 +110,10 @@ public void shouldReturnBadRequestWhenOutOfValidatorRange() throws IOException { @SuppressWarnings("unchecked") public void shouldReturnValueOnlyForValidatorsInCommittee() throws Exception { final List requestBody = List.of("1", "6", "0"); - Response response = + final Response response = post( GetSyncCommitteeRewards.ROUTE.replace("{block_id}", "head"), - jsonProvider.objectToJSON(requestBody)); + OBJECT_MAPPER.writeValueAsString(requestBody)); final Map body = JsonTestUtil.parse(response.body().string()); final ArrayList> data = @@ -133,10 +130,10 @@ public void shouldReturnValueOnlyForValidatorsInCommittee() throws Exception { @Test public void shouldReturnValueOnlyForValidatorsPublicKeysInCommittee() throws IOException { final List requestBody = getPubKeysRequestBody(0, 6); - Response response = + final Response response = post( GetSyncCommitteeRewards.ROUTE.replace("{block_id}", "head"), - jsonProvider.objectToJSON(requestBody)); + OBJECT_MAPPER.writeValueAsString(requestBody)); final SyncCommitteeRewardData data = new SyncCommitteeRewardData(false, false); data.increaseReward(3, 11180L); @@ -147,7 +144,7 @@ public void shouldReturnValueOnlyForValidatorsPublicKeysInCommittee() throws IOE assertThat(response.body().string()).isEqualTo(expectedResponse); } - private List getPubKeysRequestBody(int... committeeIndices) { + private List getPubKeysRequestBody(final int... committeeIndices) { final UInt64 slot = chainBuilder.getLatestSlot(); final UInt64 epoch = spec.computeEpochAtSlot(slot); final SszVector committee = diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/GetNewBlockIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/GetNewBlockIntegrationTest.java deleted file mode 100644 index 02de89e8227..00000000000 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/GetNewBlockIntegrationTest.java +++ /dev/null @@ -1,145 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.beaconrestapi.v1.validator; - -import static java.nio.charset.StandardCharsets.UTF_8; -import static org.assertj.core.api.AssertionsForClassTypes.assertThat; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.when; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; -import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ONE; - -import com.google.common.io.Resources; -import java.io.IOException; -import java.util.Map; -import java.util.Optional; -import java.util.stream.Stream; -import okhttp3.Response; -import org.apache.tuweni.bytes.Bytes; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.Arguments; -import org.junit.jupiter.params.provider.MethodSource; -import tech.pegasys.teku.api.exceptions.ServiceUnavailableException; -import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; -import tech.pegasys.teku.beaconrestapi.handlers.v1.validator.GetNewBlindedBlock; -import tech.pegasys.teku.beaconrestapi.handlers.v2.validator.GetNewBlock; -import tech.pegasys.teku.bls.BLSSignature; -import tech.pegasys.teku.infrastructure.async.SafeFuture; -import tech.pegasys.teku.infrastructure.http.ContentTypes; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.SpecMilestone; -import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock; -import tech.pegasys.teku.spec.datastructures.metadata.BlockContainerAndMetaData; -import tech.pegasys.teku.spec.util.DataStructureUtil; -import tech.pegasys.teku.storage.client.ChainDataUnavailableException; -import tech.pegasys.teku.validator.coordinator.MissingDepositsException; - -public class GetNewBlockIntegrationTest extends AbstractDataBackedRestAPIIntegrationTest { - private DataStructureUtil dataStructureUtil; - private BLSSignature signature; - private BlockContainerAndMetaData blockContainerAndMetaData; - - public static Stream getNewBlockCases() { - return Stream.of( - Arguments.of(GetNewBlock.ROUTE.replace("{slot}", "1"), false), - Arguments.of(GetNewBlindedBlock.ROUTE.replace("{slot}", "1"), true)); - } - - @BeforeEach - void setup() { - startRestAPIAtGenesis(SpecMilestone.ALTAIR); - dataStructureUtil = new DataStructureUtil(spec); - blockContainerAndMetaData = dataStructureUtil.randomBlockContainerAndMetaData(ONE); - signature = blockContainerAndMetaData.blockContainer().getBlock().getBody().getRandaoReveal(); - } - - @ParameterizedTest(name = "blinded_{1}") - @MethodSource("getNewBlockCases") - void shouldGetUnsignedBlock_asJson(final String route, final boolean isBlindedBlock) - throws IOException { - when(validatorApiChannel.createUnsignedBlock( - eq(UInt64.ONE), eq(signature), any(), eq(Optional.of(isBlindedBlock)), any())) - .thenReturn(SafeFuture.completedFuture(Optional.of(blockContainerAndMetaData))); - Response response = get(route, signature, ContentTypes.JSON); - assertThat(response.code()).isEqualTo(SC_OK); - final String body = response.body().string(); - assertThat(body) - .isEqualTo( - Resources.toString( - Resources.getResource(GetNewBlockIntegrationTest.class, "newBlock.json"), UTF_8)); - } - - @ParameterizedTest(name = "blinded_{1}") - @MethodSource("getNewBlockCases") - void shouldGetUnsignedBlock_asOctet(final String route, final boolean isBlindedBlock) - throws IOException { - when(validatorApiChannel.createUnsignedBlock( - eq(UInt64.ONE), eq(signature), any(), eq(Optional.of(isBlindedBlock)), any())) - .thenReturn(SafeFuture.completedFuture(Optional.of(blockContainerAndMetaData))); - Response response = get(route, signature, ContentTypes.OCTET_STREAM); - assertThat(response.code()).isEqualTo(SC_OK); - BeaconBlock block = spec.deserializeBeaconBlock(Bytes.of(response.body().bytes())); - assertThat(block).isEqualTo(blockContainerAndMetaData.blockContainer().getBlock()); - } - - @ParameterizedTest(name = "blinded_{1}") - @MethodSource("getNewBlockCases") - void shouldShowNoContent(final String route, final boolean isBlindedBlock) throws IOException { - when(validatorApiChannel.createUnsignedBlock( - eq(UInt64.ONE), eq(signature), any(), eq(Optional.of(isBlindedBlock)), any())) - .thenReturn(SafeFuture.failedFuture(new ChainDataUnavailableException())); - Response response = get(route, signature, ContentTypes.OCTET_STREAM); - assertThat(response.code()).isEqualTo(SC_NO_CONTENT); - assertThat(response.body().string()).isEqualTo(""); - } - - @ParameterizedTest(name = "blinded_{1}") - @MethodSource("getNewBlockCases") - void shouldShowUnavailable(final String route, final boolean isBlindedBlock) throws IOException { - when(validatorApiChannel.createUnsignedBlock( - eq(UInt64.ONE), eq(signature), any(), eq(Optional.of(isBlindedBlock)), any())) - .thenReturn(SafeFuture.failedFuture(new ServiceUnavailableException())); - Response response = get(route, signature, ContentTypes.OCTET_STREAM); - assertThat(response.code()).isEqualTo(SC_SERVICE_UNAVAILABLE); - assertThat(response.body().string()) - .isEqualTo( - "{\"code\":503,\"message\":\"Beacon node is currently syncing and not serving requests\"}"); - } - - @ParameterizedTest(name = "blinded_{1}") - @MethodSource("getNewBlockCases") - void shouldNotStackTraceForMissingDeposits(final String route, final boolean isBlindedBlock) - throws IOException { - when(validatorApiChannel.createUnsignedBlock( - eq(UInt64.ONE), eq(signature), any(), eq(Optional.of(isBlindedBlock)), any())) - .thenReturn( - SafeFuture.failedFuture( - MissingDepositsException.missingRange(UInt64.valueOf(1), UInt64.valueOf(10)))); - Response response = get(route, signature, ContentTypes.OCTET_STREAM); - assertThat(response.code()).isEqualTo(SC_INTERNAL_SERVER_ERROR); - assertThat(response.body().string()) - .isEqualTo( - "{\"code\":500,\"message\":\"Unable to create block because ETH1 deposits are not available. Missing deposits 1 to 10\"}"); - } - - public Response get(final String route, final BLSSignature signature, final String contentType) - throws IOException { - return getResponse(route, Map.of("randao_reveal", signature.toString()), contentType); - } -} diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/GetSyncCommitteeContributionIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/GetSyncCommitteeContributionIntegrationTest.java deleted file mode 100644 index 215c9657041..00000000000 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/GetSyncCommitteeContributionIntegrationTest.java +++ /dev/null @@ -1,108 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.beaconrestapi.v1.validator; - -import static org.assertj.core.api.AssertionsForClassTypes.assertThat; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.when; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; -import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ONE; - -import it.unimi.dsi.fastutil.ints.IntList; -import java.io.IOException; -import java.util.Map; -import java.util.Optional; -import okhttp3.Response; -import org.apache.tuweni.bytes.Bytes32; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.ValueSource; -import tech.pegasys.teku.api.response.v1.validator.GetSyncCommitteeContributionResponse; -import tech.pegasys.teku.api.schema.BLSSignature; -import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; -import tech.pegasys.teku.beaconrestapi.handlers.v1.validator.GetSyncCommitteeContribution; -import tech.pegasys.teku.infrastructure.async.SafeFuture; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.SpecMilestone; -import tech.pegasys.teku.spec.constants.NetworkConstants; -import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeContribution; - -public class GetSyncCommitteeContributionIntegrationTest - extends AbstractDataBackedRestAPIIntegrationTest { - final Bytes32 blockRoot = Bytes32.random(); - BLSSignature sig = BLSSignature.empty(); - - @BeforeEach - void setup() { - startRestAPIAtGenesis(SpecMilestone.ALTAIR); - } - - @Test - void shouldReturnNotFoundIfNotCreated() throws IOException { - final SafeFuture> future = - SafeFuture.completedFuture(Optional.empty()); - - when(validatorApiChannel.createSyncCommitteeContribution(eq(ONE), eq(1), eq(blockRoot))) - .thenReturn(future); - final Response response = get(ONE, 1, blockRoot); - assertThat(response.code()).isEqualTo(SC_NOT_FOUND); - } - - @ParameterizedTest - @ValueSource( - ints = { - Integer.MIN_VALUE, - -1, - NetworkConstants.SYNC_COMMITTEE_SUBNET_COUNT, - Integer.MAX_VALUE - }) - void shouldRejectOutOfRangeSubcommitteeIndex(final int subcommittee) throws IOException { - Response response = get(ONE, subcommittee, blockRoot); - assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); - assertThat(response.body().string()).contains(subcommittee + " is outside of this range."); - } - - @Test - void shouldReturnResultIfCreatedSuccessfully() throws IOException { - final SafeFuture> future = - SafeFuture.completedFuture( - Optional.of( - spec.getSyncCommitteeUtilRequired(ONE) - .createSyncCommitteeContribution( - ONE, blockRoot, ONE, IntList.of(1), sig.asInternalBLSSignature()))); - - when(validatorApiChannel.createSyncCommitteeContribution(eq(ONE), eq(1), eq(blockRoot))) - .thenReturn(future); - final Response response = get(ONE, 1, blockRoot); - assertThat(response.code()).isEqualTo(SC_OK); - final GetSyncCommitteeContributionResponse r = - jsonProvider.jsonToObject( - response.body().string(), GetSyncCommitteeContributionResponse.class); - assertThat(r.data.slot).isEqualTo(ONE); - assertThat(r.data.beaconBlockRoot).isEqualTo(blockRoot); - } - - public Response get(final UInt64 slot, final Integer subcommitteeIndex, final Bytes32 blockRoot) - throws IOException { - return getResponse( - GetSyncCommitteeContribution.ROUTE, - Map.of( - "slot", slot.toString(), - "subcommittee_index", subcommitteeIndex.toString(), - "beacon_block_root", blockRoot.toHexString())); - } -} diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/PostAttesterDutiesIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/PostAttesterDutiesIntegrationTest.java index 71b63c8f1ed..894421b19e7 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/PostAttesterDutiesIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/PostAttesterDutiesIntegrationTest.java @@ -52,9 +52,7 @@ void shouldGiveDecentErrorIfEmptyArray() throws IOException { when(syncService.getCurrentSyncState()).thenReturn(SyncState.IN_SYNC); - Response response = - post( - PostAttesterDuties.ROUTE.replace("{epoch}", "1"), jsonProvider.objectToJSON(List.of())); + Response response = post(PostAttesterDuties.ROUTE.replace("{epoch}", "1"), "[]"); assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); assertThat(response.body().string()) @@ -71,10 +69,7 @@ void shouldBeOkWithCorrectInput() throws IOException { SafeFuture.completedFuture( Optional.of(new AttesterDuties(false, Bytes32.ZERO, List.of())))); - Response response = - post( - PostAttesterDuties.ROUTE.replace("{epoch}", "1"), - jsonProvider.objectToJSON(List.of(1))); + final Response response = post(PostAttesterDuties.ROUTE.replace("{epoch}", "1"), "[1]"); assertThat(response.code()).isEqualTo(SC_OK); assertThat(response.body().string()) diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/PostPrepareBeaconProposerTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/PostPrepareBeaconProposerTest.java index 28aefed1399..5224b4dfffb 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/PostPrepareBeaconProposerTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/PostPrepareBeaconProposerTest.java @@ -17,7 +17,6 @@ import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.verifyNoInteractions; import static org.mockito.Mockito.when; -import static tech.pegasys.teku.beaconrestapi.handlers.v1.validator.PostPrepareBeaconProposer.BEACON_PREPARABLE_PROPOSER_TYPE; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; @@ -34,7 +33,7 @@ import tech.pegasys.teku.infrastructure.json.JsonUtil; import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; import tech.pegasys.teku.spec.SpecMilestone; -import tech.pegasys.teku.spec.datastructures.operations.versions.bellatrix.BeaconPreparableProposer; +import tech.pegasys.teku.spec.datastructures.validator.BeaconPreparableProposer; import tech.pegasys.teku.spec.util.DataStructureUtil; public class PostPrepareBeaconProposerTest extends AbstractDataBackedRestAPIIntegrationTest { @@ -56,7 +55,7 @@ void shouldReturnOk() throws IOException { post( PostPrepareBeaconProposer.ROUTE, JsonUtil.serialize( - request, DeserializableTypeDefinition.listOf(BEACON_PREPARABLE_PROPOSER_TYPE)))) { + request, DeserializableTypeDefinition.listOf(BeaconPreparableProposer.SSZ_DATA)))) { assertThat(response.code()).isEqualTo(SC_OK); } diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/PostSyncCommitteeSubscriptionsIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/PostSyncCommitteeSubscriptionsIntegrationTest.java index 27834b2382a..1580b28f112 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/PostSyncCommitteeSubscriptionsIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/PostSyncCommitteeSubscriptionsIntegrationTest.java @@ -18,14 +18,10 @@ import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; -import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ONE; import java.io.IOException; -import java.util.List; import okhttp3.Response; -import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.schema.altair.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; import tech.pegasys.teku.beaconrestapi.handlers.v1.validator.PostSyncCommitteeSubscriptions; import tech.pegasys.teku.infrastructure.async.SafeFuture; @@ -37,19 +33,18 @@ public class PostSyncCommitteeSubscriptionsIntegrationTest @Test public void shouldReturnBadRequestWhenRequestBodyIsEmpty() throws Exception { startRestAPIAtGenesis(SpecMilestone.ALTAIR); - Response response = post(PostSyncCommitteeSubscriptions.ROUTE, jsonProvider.objectToJSON("")); - Assertions.assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); + checkEmptyBodyToRoute(PostSyncCommitteeSubscriptions.ROUTE, SC_BAD_REQUEST); } @Test void shouldPostSubscriptions() throws IOException { when(validatorApiChannel.subscribeToSyncCommitteeSubnets(any())) .thenReturn(SafeFuture.COMPLETE); - final List validators = - List.of(new SyncCommitteeSubnetSubscription(ONE, List.of(ONE), ONE)); startRestAPIAtGenesis(SpecMilestone.ALTAIR); - Response response = - post(PostSyncCommitteeSubscriptions.ROUTE, jsonProvider.objectToJSON(validators)); + final Response response = + post( + PostSyncCommitteeSubscriptions.ROUTE, + "[{\"validator_index\":\"1\",\"sync_committee_indices\":[\"1\"],\"until_epoch\":\"1\"}]"); assertThat(response.code()).isEqualTo(SC_OK); } } diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/PostSyncDutiesIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/PostSyncDutiesIntegrationTest.java index 7fda607c1bd..fb097d8e757 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/PostSyncDutiesIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/PostSyncDutiesIntegrationTest.java @@ -44,9 +44,7 @@ public class PostSyncDutiesIntegrationTest extends AbstractDataBackedRestAPIInte public void shouldReturnBadRequestWhenRequestBodyIsEmpty() throws Exception { startRestAPIAtGenesis(SpecMilestone.ALTAIR); when(syncService.getCurrentSyncState()).thenReturn(SyncState.IN_SYNC); - Response response = - post(PostSyncDuties.ROUTE.replace("{epoch}", "1"), jsonProvider.objectToJSON("")); - Assertions.assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); + checkEmptyBodyToRoute(PostSyncDuties.ROUTE.replace("{epoch}", "1"), SC_BAD_REQUEST); } @Test @@ -64,8 +62,10 @@ void shouldGetSyncCommitteeDuties() throws IOException { when(syncService.getCurrentSyncState()).thenReturn(SyncState.IN_SYNC); when(validatorApiChannel.getSyncCommitteeDuties(ONE, validators)).thenReturn(out); - Response response = - post(PostSyncDuties.ROUTE.replace("{epoch}", "1"), jsonProvider.objectToJSON(validators)); + final Response response = + post( + PostSyncDuties.ROUTE.replace("{epoch}", "1"), + OBJECT_MAPPER.writeValueAsString(validators)); Assertions.assertThat(response.code()).isEqualTo(SC_OK); final SyncCommitteeDuties committeeDuties = diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/PostValidatorLivenessIntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/PostValidatorLivenessIntegrationTest.java index b1819212de6..0435c712639 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/PostValidatorLivenessIntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v1/validator/PostValidatorLivenessIntegrationTest.java @@ -20,11 +20,10 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; +import com.fasterxml.jackson.databind.JsonNode; import java.io.IOException; import okhttp3.Response; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.response.v1.validator.PostValidatorLivenessResponse; -import tech.pegasys.teku.api.response.v1.validator.ValidatorLiveness; import tech.pegasys.teku.beacon.sync.events.SyncState; import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; import tech.pegasys.teku.beaconrestapi.handlers.v1.validator.PostValidatorLiveness; @@ -38,16 +37,14 @@ public class PostValidatorLivenessIntegrationTest extends AbstractDataBackedRest public void shouldReturnBadRequestWhenRequestBodyIsEmpty() throws Exception { startRestAPIAtGenesis(SpecMilestone.ALTAIR); when(syncService.getCurrentSyncState()).thenReturn(SyncState.IN_SYNC); - Response response = post(PostValidatorLiveness.ROUTE, jsonProvider.objectToJSON("")); - assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); + checkEmptyBodyToRoute(PostValidatorLiveness.ROUTE, SC_BAD_REQUEST); } @Test public void shouldReturnUnavailableWhenChainDataNotAvailable() throws Exception { startRestAPIAtGenesis(SpecMilestone.ALTAIR); when(syncService.getCurrentSyncState()).thenReturn(SyncState.SYNCING); - Response response = post(PostValidatorLiveness.ROUTE, jsonProvider.objectToJSON("")); - assertThat(response.code()).isEqualTo(SC_SERVICE_UNAVAILABLE); + checkEmptyBodyToRoute(PostValidatorLiveness.ROUTE, SC_SERVICE_UNAVAILABLE); } @Test @@ -59,12 +56,13 @@ public void shouldDetectActiveValidator() throws IOException { setCurrentSlot(12); when(syncService.getCurrentSyncState()).thenReturn(SyncState.IN_SYNC); - Response response = + final Response response = post(getValidatorLivenessUrl(epoch), String.format("[\"%s\"]", validatorIndex)); assertThat(response.code()).isEqualTo(SC_OK); - final PostValidatorLivenessResponse result = - jsonProvider.jsonToObject(response.body().string(), PostValidatorLivenessResponse.class); - assertThat(result.data.get(0)).isEqualTo(new ValidatorLiveness(validatorIndex, true)); + final JsonNode data = getResponseData(response); + assertThat(data.get(0).get("index").asInt()).isEqualTo(validatorIndex.intValue()); + assertThat(data.get(0).get("is_live").asBoolean()).isTrue(); + assertThat(data.size()).isEqualTo(1); } private String getValidatorLivenessUrl(final UInt64 epoch) { diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v2/beacon/GetBlockV2IntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v2/beacon/GetBlockV2IntegrationTest.java index 31763fbf05d..9f25a3f3311 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v2/beacon/GetBlockV2IntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v2/beacon/GetBlockV2IntegrationTest.java @@ -19,6 +19,7 @@ import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONTENT_ENCODING; +import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.JsonNode; import java.io.ByteArrayInputStream; import java.io.IOException; @@ -26,17 +27,14 @@ import java.util.List; import java.util.zip.GZIPInputStream; import okhttp3.Response; -import org.apache.tuweni.bytes.Bytes; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.response.v2.beacon.GetBlockResponseV2; -import tech.pegasys.teku.api.schema.SignedBeaconBlock; import tech.pegasys.teku.api.schema.Version; -import tech.pegasys.teku.api.schema.altair.SignedBeaconBlockAltair; -import tech.pegasys.teku.api.schema.phase0.SignedBeaconBlockPhase0; import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; import tech.pegasys.teku.beaconrestapi.handlers.v2.beacon.GetBlock; import tech.pegasys.teku.infrastructure.http.ContentTypes; +import tech.pegasys.teku.infrastructure.json.JsonUtil; import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockAndState; public class GetBlockV2IntegrationTest extends AbstractDataBackedRestAPIIntegrationTest { @@ -46,17 +44,20 @@ public void shouldGetBlock() throws IOException { startRestAPIAtGenesis(SpecMilestone.PHASE0); final List created = createBlocksAtSlots(10); final Response response = get("head"); + final JsonNode body = OBJECT_MAPPER.readTree(response.body().string()); - final GetBlockResponseV2 body = - jsonProvider.jsonToObject(response.body().string(), GetBlockResponseV2.class); - - assertThat(body.getVersion()).isEqualTo(Version.phase0); - assertThat(body.data).isInstanceOf(SignedBeaconBlockPhase0.class); - final SignedBeaconBlockPhase0 data = (SignedBeaconBlockPhase0) body.getData(); - final SignedBlockAndState block = created.get(0); - assertThat(data).isEqualTo(SignedBeaconBlock.create(block.getBlock())); - + assertThat(body.get("version").asText()).isEqualTo(Version.phase0.name()); + assertThat(body.get("data").get("message").get("parent_root").asText()) + .isEqualTo(created.get(0).getBlock().getMessage().getParentRoot().toHexString()); + assertThat(body.get("data").get("message").get("state_root").asText()) + .isEqualTo(created.get(0).getBlock().getMessage().getStateRoot().toHexString()); assertThat(response.header(HEADER_CONSENSUS_VERSION)).isEqualTo(Version.phase0.name()); + + // this is the most practical way to compare the block to that created, but its secondary to + // comparing state root and parent root. + final SignedBeaconBlock block = + getSignedBeaconBlock(SpecMilestone.PHASE0, body.get("data").toString()); + assertThat(block).isEqualTo(created.get(0).getBlock()); } @Test @@ -64,20 +65,30 @@ public void shouldGetAltairBlock() throws IOException { startRestAPIAtGenesis(SpecMilestone.ALTAIR); final List created = createBlocksAtSlots(10); final Response response = get("head"); + final JsonNode body = OBJECT_MAPPER.readTree(response.body().string()); - final GetBlockResponseV2 body = - jsonProvider.jsonToObject(response.body().string(), GetBlockResponseV2.class); - - assertThat(body.getVersion()).isEqualTo(Version.altair); - assertThat(body.getData()).isInstanceOf(SignedBeaconBlockAltair.class); - final SignedBeaconBlockAltair data = (SignedBeaconBlockAltair) body.getData(); - assertThat(data.signature.toHexString()) - .isEqualTo(created.get(0).getBlock().getSignature().toString()); - assertThat(data.getMessage().asInternalBeaconBlock(spec).getRoot().toHexString()) - .isEqualTo(created.get(0).getBlock().getMessage().getRoot().toHexString()); - assertThat(data.getMessage().getBody().syncAggregate.syncCommitteeBits) - .isEqualTo(Bytes.fromHexString("0x00000000")); + assertThat(body.get("version").asText()).isEqualTo(Version.altair.name()); + assertThat(body.get("data").get("message").get("parent_root").asText()) + .isEqualTo(created.get(0).getBlock().getMessage().getParentRoot().toHexString()); + assertThat(body.get("data").get("message").get("state_root").asText()) + .isEqualTo(created.get(0).getBlock().getMessage().getStateRoot().toHexString()); assertThat(response.header(HEADER_CONSENSUS_VERSION)).isEqualTo(Version.altair.name()); + + // this is the most practical way to compare the block to that created, but its secondary to + // comparing state root and parent root. + final SignedBeaconBlock block = + getSignedBeaconBlock(SpecMilestone.ALTAIR, body.get("data").toString()); + assertThat(block).isEqualTo(created.get(0).getBlock()); + } + + private SignedBeaconBlock getSignedBeaconBlock(final SpecMilestone milestone, final String data) + throws JsonProcessingException { + return JsonUtil.parse( + data, + spec.forMilestone(milestone) + .getSchemaDefinitions() + .getSignedBeaconBlockSchema() + .getJsonTypeDefinition()); } @Test @@ -100,14 +111,14 @@ public void shouldGetAltairBlockAsGzip() throws IOException { // Decompress response final byte[] responseBody = response.body().bytes(); - GZIPInputStream gis = new GZIPInputStream(new ByteArrayInputStream(responseBody)); - byte[] bytesResult = gis.readAllBytes(); - String block = new String(bytesResult, StandardCharsets.UTF_8); + final GZIPInputStream gis = new GZIPInputStream(new ByteArrayInputStream(responseBody)); + final byte[] bytesResult = gis.readAllBytes(); + final String block = new String(bytesResult, StandardCharsets.UTF_8); // Check block signatures are equivalent to ensure same block - JsonNode node = jsonProvider.getObjectMapper().readTree(block); - String blockSignature = node.get("data").get("signature").asText(); - String expectedSignature = + final JsonNode node = OBJECT_MAPPER.readTree(block); + final String blockSignature = node.get("data").get("signature").asText(); + final String expectedSignature = chainBuilder.getLatestBlockAndState().getBlock().getSignature().toString(); assertThat(blockSignature).isEqualTo(expectedSignature); } diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v2/beacon/PostAttestationsV2IntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v2/beacon/PostAttestationsV2IntegrationTest.java new file mode 100644 index 00000000000..f468e7651d1 --- /dev/null +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v2/beacon/PostAttestationsV2IntegrationTest.java @@ -0,0 +1,166 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.beaconrestapi.v2.beacon; + +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.mockito.Mockito.when; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; + +import com.fasterxml.jackson.databind.JsonNode; +import java.util.Collections; +import java.util.List; +import java.util.Locale; +import java.util.Optional; +import okhttp3.Response; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; +import tech.pegasys.teku.beaconrestapi.handlers.v2.beacon.PostAttestationsV2; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.json.JsonTestUtil; +import tech.pegasys.teku.infrastructure.json.JsonUtil; +import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.util.DataStructureUtil; +import tech.pegasys.teku.validator.api.SubmitDataError; + +@TestSpecContext(milestone = {SpecMilestone.PHASE0, SpecMilestone.ELECTRA}) +public class PostAttestationsV2IntegrationTest extends AbstractDataBackedRestAPIIntegrationTest { + + private DataStructureUtil dataStructureUtil; + private SpecMilestone specMilestone; + private SerializableTypeDefinition> attestationsListTypeDef; + + @BeforeEach + void setup(final TestSpecInvocationContextProvider.SpecContext specContext) { + spec = specContext.getSpec(); + specMilestone = specContext.getSpecMilestone(); + startRestAPIAtGenesis(specMilestone); + dataStructureUtil = specContext.getDataStructureUtil(); + attestationsListTypeDef = + SerializableTypeDefinition.listOf( + spec.getGenesisSchemaDefinitions() + .getAttestationSchema() + .castTypeToAttestationSchema() + .getJsonTypeDefinition()); + } + + @TestTemplate + void shouldPostAttestations_NoErrors() throws Exception { + final List attestations = + List.of(dataStructureUtil.randomAttestation(), dataStructureUtil.randomAttestation()); + + when(validatorApiChannel.sendSignedAttestations(attestations)) + .thenReturn(SafeFuture.completedFuture(Collections.emptyList())); + + final Response response = + post( + PostAttestationsV2.ROUTE, + JsonUtil.serialize(attestations, attestationsListTypeDef), + Collections.emptyMap(), + Optional.of(specMilestone.name().toLowerCase(Locale.ROOT))); + + assertThat(response.code()).isEqualTo(SC_OK); + assertThat(response.body().string()).isEmpty(); + } + + @TestTemplate + void shouldPartiallyPostAttestations_ReturnsErrors() throws Exception { + final SubmitDataError firstSubmitDataError = + new SubmitDataError(UInt64.ZERO, "Bad attestation"); + final SubmitDataError secondSubmitDataError = + new SubmitDataError(UInt64.ONE, "Very bad attestation"); + + final List attestations = + List.of( + dataStructureUtil.randomAttestation(), + dataStructureUtil.randomAttestation(), + dataStructureUtil.randomAttestation()); + + when(validatorApiChannel.sendSignedAttestations(attestations)) + .thenReturn( + SafeFuture.completedFuture(List.of(firstSubmitDataError, secondSubmitDataError))); + + final Response response = + post( + PostAttestationsV2.ROUTE, + JsonUtil.serialize(attestations, attestationsListTypeDef), + Collections.emptyMap(), + Optional.of(specMilestone.name().toLowerCase(Locale.ROOT))); + + assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); + final JsonNode resultAsJsonNode = JsonTestUtil.parseAsJsonNode(response.body().string()); + + assertThat(resultAsJsonNode.get("message").asText()) + .isEqualTo("Some items failed to publish, refer to errors for details"); + assertThat(resultAsJsonNode.get("failures").size()).isEqualTo(2); + assertThat(resultAsJsonNode.get("failures").get(0).get("index").asText()) + .isEqualTo(firstSubmitDataError.index().toString()); + assertThat(resultAsJsonNode.get("failures").get(0).get("message").asText()) + .isEqualTo(firstSubmitDataError.message()); + assertThat(resultAsJsonNode.get("failures").get(1).get("index").asText()) + .isEqualTo(secondSubmitDataError.index().toString()); + assertThat(resultAsJsonNode.get("failures").get(1).get("message").asText()) + .isEqualTo(secondSubmitDataError.message()); + } + + @TestTemplate + void shouldFailWhenMissingConsensusHeader() throws Exception { + final List attestations = + List.of(dataStructureUtil.randomAttestation(), dataStructureUtil.randomAttestation()); + + when(validatorApiChannel.sendSignedAttestations(attestations)) + .thenReturn(SafeFuture.completedFuture(Collections.emptyList())); + + final Response response = + post(PostAttestationsV2.ROUTE, JsonUtil.serialize(attestations, attestationsListTypeDef)); + + assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); + + final JsonNode resultAsJsonNode = JsonTestUtil.parseAsJsonNode(response.body().string()); + assertThat(resultAsJsonNode.get("message").asText()) + .isEqualTo("Missing required header value for (%s)", HEADER_CONSENSUS_VERSION); + } + + @TestTemplate + void shouldFailWhenBadConsensusHeaderValue() throws Exception { + final List attestations = + List.of(dataStructureUtil.randomAttestation(), dataStructureUtil.randomAttestation()); + + when(validatorApiChannel.sendSignedAttestations(attestations)) + .thenReturn(SafeFuture.completedFuture(Collections.emptyList())); + final String badConsensusHeaderValue = "NonExistingMileStone"; + final Response response = + post( + PostAttestationsV2.ROUTE, + JsonUtil.serialize(attestations, attestationsListTypeDef), + Collections.emptyMap(), + Optional.of(badConsensusHeaderValue)); + + assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); + + final JsonNode resultAsJsonNode = JsonTestUtil.parseAsJsonNode(response.body().string()); + assertThat(resultAsJsonNode.get("message").asText()) + .isEqualTo( + String.format( + "Invalid value for (%s) header: %s", + HEADER_CONSENSUS_VERSION, badConsensusHeaderValue)); + } +} diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v2/beacon/PostAttesterSlashingV2IntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v2/beacon/PostAttesterSlashingV2IntegrationTest.java new file mode 100644 index 00000000000..ec8a79a9c54 --- /dev/null +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v2/beacon/PostAttesterSlashingV2IntegrationTest.java @@ -0,0 +1,149 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.beaconrestapi.v2.beacon; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; +import static tech.pegasys.teku.spec.SpecMilestone.ELECTRA; +import static tech.pegasys.teku.spec.SpecMilestone.PHASE0; + +import com.fasterxml.jackson.databind.JsonNode; +import java.util.Collections; +import java.util.Locale; +import java.util.Optional; +import okhttp3.Response; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; +import tech.pegasys.teku.beaconrestapi.handlers.v2.beacon.PostAttesterSlashingV2; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.json.JsonTestUtil; +import tech.pegasys.teku.infrastructure.json.JsonUtil; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider; +import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; +import tech.pegasys.teku.spec.util.DataStructureUtil; +import tech.pegasys.teku.statetransition.validation.InternalValidationResult; + +@TestSpecContext(milestone = {PHASE0, ELECTRA}) +public class PostAttesterSlashingV2IntegrationTest + extends AbstractDataBackedRestAPIIntegrationTest { + + private DataStructureUtil dataStructureUtil; + private SpecMilestone specMilestone; + + @BeforeEach + void setup(final TestSpecInvocationContextProvider.SpecContext specContext) { + spec = specContext.getSpec(); + specMilestone = specContext.getSpecMilestone(); + startRestAPIAtGenesis(specMilestone); + dataStructureUtil = specContext.getDataStructureUtil(); + } + + @TestTemplate + public void shouldReturnBadRequestWhenRequestBodyIsEmpty() throws Exception { + checkEmptyBodyToRoute(PostAttesterSlashingV2.ROUTE, SC_BAD_REQUEST); + } + + @TestTemplate + public void shouldReturnBadRequestWhenRequestBodyIsInvalid() throws Exception { + final Response response = + post( + PostAttesterSlashingV2.ROUTE, + "{\"foo\": \"bar\"}", + Collections.emptyMap(), + Optional.of(specMilestone.name().toLowerCase(Locale.ROOT))); + assertThat(response.code()).isEqualTo(400); + } + + @TestTemplate + public void shouldReturnServerErrorWhenUnexpectedErrorHappens() throws Exception { + final AttesterSlashing slashing = dataStructureUtil.randomAttesterSlashing(); + + doThrow(new RuntimeException()).when(attesterSlashingPool).addLocal(slashing); + + final Response response = + post( + PostAttesterSlashingV2.ROUTE, + JsonUtil.serialize(slashing, slashing.getSchema().getJsonTypeDefinition()), + Collections.emptyMap(), + Optional.of(specMilestone.name().toLowerCase(Locale.ROOT))); + assertThat(response.code()).isEqualTo(500); + } + + @TestTemplate + public void shouldReturnSuccessWhenRequestBodyIsValid() throws Exception { + final AttesterSlashing slashing = dataStructureUtil.randomAttesterSlashing(); + + when(attesterSlashingPool.addLocal(slashing)) + .thenReturn(SafeFuture.completedFuture(InternalValidationResult.ACCEPT)); + + final Response response = + post( + PostAttesterSlashingV2.ROUTE, + JsonUtil.serialize(slashing, slashing.getSchema().getJsonTypeDefinition()), + Collections.emptyMap(), + Optional.of(specMilestone.name().toLowerCase(Locale.ROOT))); + + verify(attesterSlashingPool).addLocal(slashing); + + assertThat(response.code()).isEqualTo(200); + } + + @TestTemplate + void shouldFailWhenMissingConsensusHeader() throws Exception { + final AttesterSlashing slashing = dataStructureUtil.randomAttesterSlashing(); + + final Response response = + post( + PostAttesterSlashingV2.ROUTE, + JsonUtil.serialize(slashing, slashing.getSchema().getJsonTypeDefinition())); + + assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); + + final JsonNode resultAsJsonNode = JsonTestUtil.parseAsJsonNode(response.body().string()); + assertThat(resultAsJsonNode.get("message").asText()) + .isEqualTo("Missing required header value for (%s)", HEADER_CONSENSUS_VERSION); + } + + @TestTemplate + void shouldFailWhenBadConsensusHeaderValue() throws Exception { + + final AttesterSlashing slashing = dataStructureUtil.randomAttesterSlashing(); + + when(attesterSlashingPool.addLocal(slashing)) + .thenReturn(SafeFuture.completedFuture(InternalValidationResult.ACCEPT)); + final String badConsensusHeaderValue = "NonExistingMileStone"; + final Response response = + post( + PostAttesterSlashingV2.ROUTE, + JsonUtil.serialize(slashing, slashing.getSchema().getJsonTypeDefinition()), + Collections.emptyMap(), + Optional.of(badConsensusHeaderValue)); + + assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); + + final JsonNode resultAsJsonNode = JsonTestUtil.parseAsJsonNode(response.body().string()); + assertThat(resultAsJsonNode.get("message").asText()) + .isEqualTo( + String.format( + "Invalid value for (%s) header: %s", + HEADER_CONSENSUS_VERSION, badConsensusHeaderValue)); + } +} diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v2/validator/PostAggregateAndProofsV2IntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v2/validator/PostAggregateAndProofsV2IntegrationTest.java new file mode 100644 index 00000000000..d29e2f8fb32 --- /dev/null +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v2/validator/PostAggregateAndProofsV2IntegrationTest.java @@ -0,0 +1,161 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.beaconrestapi.v2.validator; + +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.mockito.ArgumentMatchers.anyList; +import static org.mockito.Mockito.when; +import static tech.pegasys.teku.api.ValidatorDataProvider.PARTIAL_PUBLISH_FAILURE_MESSAGE; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; +import static tech.pegasys.teku.spec.SpecMilestone.ELECTRA; +import static tech.pegasys.teku.spec.SpecMilestone.PHASE0; + +import com.fasterxml.jackson.databind.JsonNode; +import java.util.Collections; +import java.util.List; +import java.util.Locale; +import java.util.Optional; +import okhttp3.Response; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.beaconrestapi.AbstractDataBackedRestAPIIntegrationTest; +import tech.pegasys.teku.beaconrestapi.handlers.v2.validator.PostAggregateAndProofsV2; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.json.JsonTestUtil; +import tech.pegasys.teku.infrastructure.json.JsonUtil; +import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider; +import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof; +import tech.pegasys.teku.spec.util.DataStructureUtil; +import tech.pegasys.teku.validator.api.SubmitDataError; + +@TestSpecContext(milestone = {PHASE0, ELECTRA}) +public class PostAggregateAndProofsV2IntegrationTest + extends AbstractDataBackedRestAPIIntegrationTest { + + private DataStructureUtil dataStructureUtil; + private SpecMilestone specMilestone; + private SerializableTypeDefinition> aggregateAndProofsListTypeDef; + + @BeforeEach + void setup(final TestSpecInvocationContextProvider.SpecContext specContext) { + spec = specContext.getSpec(); + specMilestone = specContext.getSpecMilestone(); + startRestAPIAtGenesis(specMilestone); + dataStructureUtil = specContext.getDataStructureUtil(); + aggregateAndProofsListTypeDef = + SerializableTypeDefinition.listOf( + spec.getGenesisSchemaDefinitions() + .getSignedAggregateAndProofSchema() + .getJsonTypeDefinition()); + } + + @TestTemplate + void shouldPostAggregateAndProofs() throws Exception { + when(validatorApiChannel.sendAggregateAndProofs(anyList())) + .thenReturn(SafeFuture.completedFuture(Collections.emptyList())); + + final List aggregateAndProofs = + List.of( + dataStructureUtil.randomSignedAggregateAndProof(), + dataStructureUtil.randomSignedAggregateAndProof()); + + final Response response = + post( + PostAggregateAndProofsV2.ROUTE, + JsonUtil.serialize(aggregateAndProofs, aggregateAndProofsListTypeDef), + Collections.emptyMap(), + Optional.of(specMilestone.name().toLowerCase(Locale.ROOT))); + + assertThat(response.code()).isEqualTo(SC_OK); + assertThat(response.body().string()).isEmpty(); + } + + @TestTemplate + void shouldReturnBadRequestWhenInvalidAggregateAndProofs() throws Exception { + final SubmitDataError firstSubmitDataError = + new SubmitDataError(UInt64.ZERO, "Bad aggregate and proofs"); + when(validatorApiChannel.sendAggregateAndProofs(anyList())) + .thenReturn(SafeFuture.completedFuture(List.of(firstSubmitDataError))); + final List aggregateAndProofs = + List.of( + dataStructureUtil.randomSignedAggregateAndProof(), + dataStructureUtil.randomSignedAggregateAndProof()); + final Response response = + post( + PostAggregateAndProofsV2.ROUTE, + JsonUtil.serialize(aggregateAndProofs, aggregateAndProofsListTypeDef), + Collections.emptyMap(), + Optional.of(specMilestone.name().toLowerCase(Locale.ROOT))); + assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); + + final JsonNode resultAsJsonNode = JsonTestUtil.parseAsJsonNode(response.body().string()); + assertThat(resultAsJsonNode.get("message").asText()).isEqualTo(PARTIAL_PUBLISH_FAILURE_MESSAGE); + } + + @TestTemplate + void shouldFailWhenMissingConsensusHeader() throws Exception { + when(validatorApiChannel.sendAggregateAndProofs(anyList())) + .thenReturn(SafeFuture.completedFuture(Collections.emptyList())); + + final List aggregateAndProofs = + List.of( + dataStructureUtil.randomSignedAggregateAndProof(), + dataStructureUtil.randomSignedAggregateAndProof()); + + final Response response = + post( + PostAggregateAndProofsV2.ROUTE, + JsonUtil.serialize(aggregateAndProofs, aggregateAndProofsListTypeDef)); + + assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); + + final JsonNode resultAsJsonNode = JsonTestUtil.parseAsJsonNode(response.body().string()); + assertThat(resultAsJsonNode.get("message").asText()) + .isEqualTo( + String.format("Missing required header value for (%s)", HEADER_CONSENSUS_VERSION)); + } + + @TestTemplate + void shouldFailWhenBadConsensusHeaderValue() throws Exception { + when(validatorApiChannel.sendAggregateAndProofs(anyList())) + .thenReturn(SafeFuture.completedFuture(Collections.emptyList())); + + final List aggregateAndProofs = + List.of( + dataStructureUtil.randomSignedAggregateAndProof(), + dataStructureUtil.randomSignedAggregateAndProof()); + final String badConsensusHeaderValue = "NonExistingMileStone"; + final Response response = + post( + PostAggregateAndProofsV2.ROUTE, + JsonUtil.serialize(aggregateAndProofs, aggregateAndProofsListTypeDef), + Collections.emptyMap(), + Optional.of(badConsensusHeaderValue)); + + assertThat(response.code()).isEqualTo(SC_BAD_REQUEST); + + final JsonNode resultAsJsonNode = JsonTestUtil.parseAsJsonNode(response.body().string()); + assertThat(resultAsJsonNode.get("message").asText()) + .isEqualTo( + String.format( + "Invalid value for (%s) header: %s", + HEADER_CONSENSUS_VERSION, badConsensusHeaderValue)); + } +} diff --git a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v3/GetNewBlockV3IntegrationTest.java b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v3/GetNewBlockV3IntegrationTest.java index dc96d6e607a..b8ce8defb5b 100644 --- a/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v3/GetNewBlockV3IntegrationTest.java +++ b/data/beaconrestapi/src/integration-test/java/tech/pegasys/teku/beaconrestapi/v3/GetNewBlockV3IntegrationTest.java @@ -76,8 +76,7 @@ void shouldGetUnBlindedBeaconBlockAsJson() throws Exception { dataStructureUtil.randomBlockContainerAndMetaData(ONE); final BLSSignature signature = blockContainerAndMetaData.blockContainer().getBlock().getBody().getRandaoReveal(); - when(validatorApiChannel.createUnsignedBlock( - eq(UInt64.ONE), eq(signature), any(), any(), any())) + when(validatorApiChannel.createUnsignedBlock(eq(UInt64.ONE), eq(signature), any(), any())) .thenReturn(SafeFuture.completedFuture(Optional.of(blockContainerAndMetaData))); Response response = get(signature, ContentTypes.JSON); assertResponseWithHeaders( @@ -100,8 +99,7 @@ void shouldGetUnblindedBeaconBlockAsSsz() throws IOException { dataStructureUtil.randomBlockContainerAndMetaData(ONE); final BLSSignature signature = blockContainerAndMetaData.blockContainer().getBlock().getBody().getRandaoReveal(); - when(validatorApiChannel.createUnsignedBlock( - eq(UInt64.ONE), eq(signature), any(), any(), any())) + when(validatorApiChannel.createUnsignedBlock(eq(UInt64.ONE), eq(signature), any(), any())) .thenReturn(SafeFuture.completedFuture(Optional.of(blockContainerAndMetaData))); Response response = get(signature, ContentTypes.OCTET_STREAM); assertResponseWithHeaders( @@ -123,8 +121,7 @@ void shouldGetBlindedBeaconBlockAsJson() throws Exception { dataStructureUtil.randomBlindedBlockContainerAndMetaData(ONE); final BLSSignature signature = blockContainerAndMetaData.blockContainer().getBlock().getBody().getRandaoReveal(); - when(validatorApiChannel.createUnsignedBlock( - eq(UInt64.ONE), eq(signature), any(), any(), any())) + when(validatorApiChannel.createUnsignedBlock(eq(UInt64.ONE), eq(signature), any(), any())) .thenReturn(SafeFuture.completedFuture(Optional.of(blockContainerAndMetaData))); Response response = get(signature, ContentTypes.JSON); assertResponseWithHeaders( @@ -148,8 +145,7 @@ void shouldGetBlindedBeaconBlockAsSsz() throws IOException { final BeaconBlock blindedBeaconBlock = blockContainerAndMetaData.blockContainer().getBlock(); final BLSSignature signature = blockContainerAndMetaData.blockContainer().getBlock().getBody().getRandaoReveal(); - when(validatorApiChannel.createUnsignedBlock( - eq(UInt64.ONE), eq(signature), any(), any(), any())) + when(validatorApiChannel.createUnsignedBlock(eq(UInt64.ONE), eq(signature), any(), any())) .thenReturn(SafeFuture.completedFuture(Optional.of(blockContainerAndMetaData))); Response response = get(signature, ContentTypes.OCTET_STREAM); assertResponseWithHeaders( @@ -172,8 +168,7 @@ void shouldGetUnBlindedBlockContentPostDenebAsJson() throws Exception { dataStructureUtil.randomBlockContainerAndMetaData(blockContents, ONE); final BLSSignature signature = blockContainerAndMetaData.blockContainer().getBlock().getBody().getRandaoReveal(); - when(validatorApiChannel.createUnsignedBlock( - eq(UInt64.ONE), eq(signature), any(), any(), any())) + when(validatorApiChannel.createUnsignedBlock(eq(UInt64.ONE), eq(signature), any(), any())) .thenReturn(SafeFuture.completedFuture(Optional.of(blockContainerAndMetaData))); Response response = get(signature, ContentTypes.JSON); assertResponseWithHeaders( @@ -196,8 +191,7 @@ void shouldGetUnBlindedBlockContentPostDenebAsSsz() throws IOException { final BlockContainerAndMetaData blockContainerAndMetaData = dataStructureUtil.randomBlockContainerAndMetaData(blockContents, ONE); final BLSSignature signature = blockContents.getBlock().getBody().getRandaoReveal(); - when(validatorApiChannel.createUnsignedBlock( - eq(UInt64.ONE), eq(signature), any(), any(), any())) + when(validatorApiChannel.createUnsignedBlock(eq(UInt64.ONE), eq(signature), any(), any())) .thenReturn(SafeFuture.completedFuture(Optional.of(blockContainerAndMetaData))); Response response = get(signature, ContentTypes.OCTET_STREAM); assertResponseWithHeaders( @@ -217,8 +211,7 @@ void shouldGetUnBlindedBlockContentPostDenebAsSsz() throws IOException { void shouldFailWhenNoBlockProduced() throws IOException { final BeaconBlock beaconBlock = dataStructureUtil.randomBeaconBlock(ONE); final BLSSignature signature = beaconBlock.getBlock().getBody().getRandaoReveal(); - when(validatorApiChannel.createUnsignedBlock( - eq(UInt64.ONE), eq(signature), any(), any(), any())) + when(validatorApiChannel.createUnsignedBlock(eq(UInt64.ONE), eq(signature), any(), any())) .thenReturn(SafeFuture.completedFuture(Optional.empty())); Response response = get(signature, ContentTypes.JSON); assertThat(response.code()).isEqualTo(SC_INTERNAL_SERVER_ERROR); @@ -247,8 +240,8 @@ private String getExpectedBlockAsJson( } private void assertResponseWithHeaders( - Response response, - boolean blinded, + final Response response, + final boolean blinded, final UInt256 executionPayloadValue, final UInt256 consensusBlockValue) { assertThat(response.code()).isEqualTo(SC_OK); diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_blinded_blocks.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_blinded_blocks.json index d6a2e1a3f47..56df6225beb 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_blinded_blocks.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_blinded_blocks.json @@ -3,13 +3,14 @@ "tags" : [ "Beacon", "Validator Required Api" ], "operationId" : "publishBlindedBlock", "summary" : "Publish a signed blinded block", - "description" : "Submit a signed blinded beacon block to the beacon node to be broadcast and imported. The beacon node performs the required validation.", + "description" : "Instructs the beacon node to use the components of the `SignedBlindedBeaconBlock` to construct and publish a `SignedBeaconBlock` by swapping out the `transactions_root` for the corresponding full list of `transactions`. The beacon node should broadcast a newly constructed `SignedBeaconBlock` to the beacon network, to be included in the beacon chain. The beacon node is not required to validate the signed `BeaconBlock`, and a successful response (20X) only indicates that the broadcast has been successful. The beacon node is expected to integrate the new block into its state, and therefore validate the block internally, however blocks which fail the validation are still broadcast but a different status code is returned (202). Pre-Bellatrix, this endpoint will accept a `SignedBeaconBlock`.", + "deprecated" : true, "parameters" : [ { "name" : "Eth-Consensus-Version", "in" : "header", "schema" : { "type" : "string", - "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "eip7594" ], + "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "electra" ], "description" : "Version of the block being submitted, if using SSZ encoding." } } ], @@ -30,14 +31,14 @@ }, { "$ref" : "#/components/schemas/SignedBeaconBlockAltair" }, { - "$ref" : "#/components/schemas/SignedBlindedBlockBellatrix" + "$ref" : "#/components/schemas/SignedBlindedBeaconBlockBellatrix" }, { - "$ref" : "#/components/schemas/SignedBlindedBlockCapella" + "$ref" : "#/components/schemas/SignedBlindedBeaconBlockCapella" }, { - "$ref" : "#/components/schemas/SignedBlindedBlockDeneb" + "$ref" : "#/components/schemas/SignedBlindedBeaconBlockDeneb" }, { - "$ref" : "#/components/schemas/SignedBlindedBlockEip7594" - } ] + "$ref" : "#/components/schemas/SignedBlindedBeaconBlockElectra" + } ] } } } @@ -81,6 +82,10 @@ } } }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "500" : { "description" : "Internal server error", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_blinded_blocks_{block_id}.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_blinded_blocks_{block_id}.json index 2b063ca6bd2..32866e570a8 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_blinded_blocks_{block_id}.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_blinded_blocks_{block_id}.json @@ -17,6 +17,24 @@ "responses" : { "200" : { "description" : "Request successful", + "headers" : { + "Eth-Consensus-Version": { + "description": "Required in response so client can deserialize returned json or ssz data more effectively.", + "required": true, + "schema": { + "type": "string", + "enum": [ + "phase0", + "altair", + "bellatrix", + "capella", + "deneb", + "electra" + ], + "example": "phase0" + } + } + }, "content" : { "application/json" : { "schema" : { @@ -41,6 +59,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_blob_sidecars_{block_id}.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_blob_sidecars_{block_id}.json index 2b808010920..a4d380e0510 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_blob_sidecars_{block_id}.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_blob_sidecars_{block_id}.json @@ -30,6 +30,24 @@ "responses" : { "200" : { "description" : "Request successful", + "headers" : { + "Eth-Consensus-Version": { + "description": "Required in response so client can deserialize returned json or ssz data more effectively.", + "required": true, + "schema": { + "type": "string", + "enum": [ + "phase0", + "altair", + "bellatrix", + "capella", + "deneb", + "electra" + ], + "example": "phase0" + } + } + }, "content" : { "application/json" : { "schema" : { @@ -54,6 +72,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_blocks.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_blocks.json index d1f0d93c593..703cca02f5b 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_blocks.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_blocks.json @@ -3,13 +3,14 @@ "tags" : [ "Beacon", "Validator Required Api" ], "operationId" : "publishBlock", "summary" : "Publish a signed block", - "description" : "Submit a signed beacon block to the beacon node to be broadcast and imported. After Deneb, this additionally instructs the beacon node to broadcast and import all given blobs. The beacon node performs the required validation.", + "description" : "Instructs the beacon node to broadcast a newly signed beacon block to the beacon network, to be included in the beacon chain. A success response (20x) indicates that the block passed gossip validation and was successfully broadcast onto the network. The beacon node is also expected to integrate the block into the state, but may broadcast it before doing so, so as to aid timely delivery of the block. Should the block fail full validation, a separate success response code (202) is used to indicate that the block was successfully broadcast but failed integration. After Deneb, this additionally instructs the beacon node to broadcast all given signed blobs.", + "deprecated" : true, "parameters" : [ { "name" : "Eth-Consensus-Version", "in" : "header", "schema" : { "type" : "string", - "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "eip7594" ], + "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "electra" ], "description" : "Version of the block being submitted, if using SSZ encoding." } } ], @@ -36,7 +37,7 @@ }, { "$ref" : "#/components/schemas/SignedBlockContentsDeneb" }, { - "$ref" : "#/components/schemas/SignedBlockContentsEip7594" + "$ref" : "#/components/schemas/SignedBlockContentsElectra" } ] } } @@ -81,6 +82,10 @@ } } }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "500" : { "description" : "Internal server error", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_blocks_{block_id}_attestations.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_blocks_{block_id}_attestations.json index bd78cd3de98..2a4047df2a5 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_blocks_{block_id}_attestations.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_blocks_{block_id}_attestations.json @@ -4,6 +4,7 @@ "operationId" : "getBlockAttestations", "summary" : "Get block attestations", "description" : "Retrieves attestations included in requested block.", + "deprecated" : true, "parameters" : [ { "name" : "block_id", "required" : true, @@ -35,6 +36,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_blocks_{block_id}_root.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_blocks_{block_id}_root.json index 2fc38022f5a..db95fb1a9b4 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_blocks_{block_id}_root.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_blocks_{block_id}_root.json @@ -35,6 +35,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_genesis.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_genesis.json index 205f17c6b9e..c9db831fcc1 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_genesis.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_genesis.json @@ -19,6 +19,20 @@ "description" : "Chain genesis info is not yet known", "content" : { } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_headers.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_headers.json index 78c6475b857..678ea981bcb 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_headers.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_headers.json @@ -34,6 +34,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_headers_{block_id}.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_headers_{block_id}.json index c7565952793..26c40d542f3 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_headers_{block_id}.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_headers_{block_id}.json @@ -35,6 +35,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_light_client_bootstrap_{block_root}.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_light_client_bootstrap_{block_root}.json index 30320a3ea98..0980272aafd 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_light_client_bootstrap_{block_root}.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_light_client_bootstrap_{block_root}.json @@ -1,6 +1,6 @@ { "get" : { - "tags" : ["Beacon", "Experimental"], + "tags" : [ "Beacon", "Experimental" ], "operationId" : "getLightClientBootstrap", "summary" : "Get light client bootstrap data for the requested block root.", "description" : "Requests the LightClientBootstrap structure corresponding to a given post-Altair beacon block root. Depending on the `Accept` header it can be returned either as JSON or SSZ-serialized bytes.", @@ -32,7 +32,7 @@ } } }, - "404": { + "404" : { "description" : "Not found", "content" : { "application/json" : { @@ -42,7 +42,7 @@ } } }, - "406": { + "406" : { "description" : "Not acceptable", "content" : { "application/json" : { @@ -55,14 +55,28 @@ "501" : { "description" : "Not implemented", "content" : { - "application/json": { + "application/json" : { "schema" : { "$ref" : "#/components/schemas/HttpErrorResponse" } } } }, - "400": { + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, + "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { "application/json" : { @@ -75,7 +89,7 @@ "500" : { "description" : "Internal server error", "content" : { - "application/json": { + "application/json" : { "schema" : { "$ref" : "#/components/schemas/HttpErrorResponse" } diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_light_client_updates.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_light_client_updates.json index 7b0a5b2cf60..56fb7296377 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_light_client_updates.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_light_client_updates.json @@ -44,7 +44,7 @@ "bellatrix", "capella", "deneb", - "eip7594" + "electra" ] }, "data": { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_pool_attestations.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_pool_attestations.json index 49ca1d93cf0..13db5d39d15 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_pool_attestations.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_pool_attestations.json @@ -4,6 +4,7 @@ "operationId" : "getPoolAttestations", "summary" : "Get Attestations from operations pool", "description" : "Retrieves attestations known by the node but not necessarily incorporated into any block.", + "deprecated" : true, "parameters" : [ { "name" : "slot", "in" : "query", @@ -67,7 +68,7 @@ "schema" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/Attestation" + "$ref" : "#/components/schemas/AttestationPhase0" } } } @@ -88,6 +89,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "500" : { "description" : "Internal server error", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_pool_attester_slashings.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_pool_attester_slashings.json index 1cb019152a4..ce379bec771 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_pool_attester_slashings.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_pool_attester_slashings.json @@ -4,6 +4,7 @@ "operationId" : "getPoolAttesterSlashings", "summary" : "Get AttesterSlashings from operations pool", "description" : "Retrieves attester slashings known by the node but not necessarily incorporated into any block.", + "deprecated" : true, "responses" : { "200" : { "description" : "Request successful", @@ -46,7 +47,7 @@ "content" : { "application/json" : { "schema" : { - "$ref" : "#/components/schemas/AttesterSlashing" + "$ref" : "#/components/schemas/AttesterSlashingPhase0" } } } diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_pool_sync_committees.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_pool_sync_committees.json index b596eedc4b4..50334eaab83 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_pool_sync_committees.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_pool_sync_committees.json @@ -37,6 +37,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "500" : { "description" : "Internal server error", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_rewards_attestations_{epoch}.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_rewards_attestations_{epoch}.json index d93f1135d5d..f7e2fe6955f 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_rewards_attestations_{epoch}.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_rewards_attestations_{epoch}.json @@ -1,85 +1,84 @@ { - "post": { - "tags": [ - "Beacon", - "Rewards" - ], - "operationId": "getAttestationsRewards", - "summary": "Get attestations rewards", - "description": "Retrieve attestation reward info for validators specified by array of public keys or validator index. If no array is provided, return reward info for every validator.", - "parameters": [ - { - "name": "epoch", - "required": true, - "in": "path", - "schema": { - "type": "string", - "description": "`uint64` Epoch number to query.", - "example": "1", - "format": "uint64" - } + "post" : { + "tags" : [ "Beacon", "Rewards" ], + "operationId" : "getAttestationsRewards", + "summary" : "Get attestations rewards", + "description" : "Retrieve attestation reward info for validators specified by array of public keys or validator index. If no array is provided, return reward info for every validator.", + "parameters" : [ { + "name" : "epoch", + "required" : true, + "in" : "path", + "schema" : { + "type" : "string", + "description" : "`uint64` Epoch number to query.", + "example" : "1", + "format" : "uint64" } - ], - "requestBody": { - "required": false, - "content": { - "application/json": { - "schema": { - "type": "array", - "items": { - "type": "string" + } ], + "requestBody" : { + "required" : false, + "content" : { + "application/json" : { + "schema" : { + "type" : "array", + "items" : { + "type" : "string" } } } } }, - "responses": { - "200": { - "description": "Request successful", - "content": { - "application/json": { - "schema": { - "$ref": "#/components/schemas/GetAttestationRewards" + "responses" : { + "200" : { + "description" : "Request successful", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/GetAttestationRewards" } } } }, - "400": { - "description": "The request could not be processed, check the response for more information.", - "content": { - "application/json": { - "schema": { - "$ref": "#/components/schemas/HttpErrorResponse" + "404" : { + "description" : "Not found", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" } } } }, - "404": { - "description": "Not found", - "content": { - "application/json": { - "schema": { - "$ref": "#/components/schemas/HttpErrorResponse" + "500" : { + "description" : "Internal server error", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" } } } }, - "500": { - "description": "Internal server error", - "content": { - "application/json": { - "schema": { - "$ref": "#/components/schemas/HttpErrorResponse" + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" } } } }, - "501": { - "description": "Not implemented", - "content": { - "application/json": { - "schema": { - "$ref": "#/components/schemas/HttpErrorResponse" + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, + "400" : { + "description" : "The request could not be processed, check the response for more information.", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" } } } diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_rewards_blocks_{block_id}.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_rewards_blocks_{block_id}.json index 5f463d97310..56146bf105b 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_rewards_blocks_{block_id}.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_rewards_blocks_{block_id}.json @@ -1,6 +1,6 @@ { "get" : { - "tags" : [ "Beacon", "Rewards"], + "tags" : [ "Beacon", "Rewards" ], "operationId" : "getBlockRewards", "summary" : "Get block rewards", "description" : "Retrieve block reward info for a single block.", @@ -45,6 +45,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_rewards_sync_committee_{block_id}.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_rewards_sync_committee_{block_id}.json index ba65d242dd7..42e17b758ef 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_rewards_sync_committee_{block_id}.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_rewards_sync_committee_{block_id}.json @@ -15,7 +15,7 @@ } } ], "requestBody" : { - "required": false, + "required" : false, "content" : { "application/json" : { "schema" : { @@ -58,6 +58,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_committees.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_committees.json index 02cbc3a9d05..f1223307dd9 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_committees.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_committees.json @@ -62,6 +62,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_finality_checkpoints.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_finality_checkpoints.json index 52da596567e..532892ba326 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_finality_checkpoints.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_finality_checkpoints.json @@ -59,6 +59,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_fork.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_fork.json index 92555750486..9030a0e671d 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_fork.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_fork.json @@ -35,6 +35,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_randao.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_randao.json index 9ed20d8fcf4..53b197f563c 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_randao.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_randao.json @@ -44,6 +44,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_root.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_root.json index 6e00296b7d6..76587e9af10 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_root.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_root.json @@ -35,6 +35,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_sync_committees.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_sync_committees.json index 47a13f66bb2..a7e54f80d3f 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_sync_committees.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_sync_committees.json @@ -44,6 +44,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_validator_balances.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_validator_balances.json index 2ecefd5a7ea..fc5839b55df 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_validator_balances.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_validator_balances.json @@ -46,6 +46,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { @@ -84,7 +98,7 @@ } } ], "requestBody" : { - "required": false, + "required" : false, "content" : { "application/json" : { "schema" : { @@ -117,6 +131,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_validators.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_validators.json index 3a0c74ac22e..0facd6f9e12 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_validators.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_validators.json @@ -59,6 +59,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { @@ -126,6 +140,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_validators_{validator_id}.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_validators_{validator_id}.json index b0917077fc1..d9f5f2d3a6e 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_validators_{validator_id}.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_beacon_states_{state_id}_validators_{validator_id}.json @@ -44,6 +44,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_builder_states_{state_id}_expected_withdrawals.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_builder_states_{state_id}_expected_withdrawals.json index 05c9c548c8c..363d0f0cee5 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_builder_states_{state_id}_expected_withdrawals.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_builder_states_{state_id}_expected_withdrawals.json @@ -54,6 +54,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_checkpoint_finalized_blocks_{slot}_root.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_checkpoint_finalized_blocks_{slot}_root.json index 3979d96a70e..f7e7ac8fd82 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_checkpoint_finalized_blocks_{slot}_root.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_checkpoint_finalized_blocks_{slot}_root.json @@ -36,6 +36,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_checkpoint_finalized_state.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_checkpoint_finalized_state.json index 20018aa0e25..fb9b638b954 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_checkpoint_finalized_state.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_checkpoint_finalized_state.json @@ -26,6 +26,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_debug_fork_choice.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_debug_fork_choice.json index fd89ed37355..c0d7bfb15f2 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_debug_fork_choice.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_debug_fork_choice.json @@ -63,7 +63,7 @@ }, "validity" : { "type" : "string", - "enum" : [ "VALID", "INVALID", "OPTIMISTIC" ] + "enum" : [ "valid", "invalid", "optimistic" ] }, "execution_block_hash" : { "type" : "string", @@ -91,6 +91,10 @@ } } }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "503" : { "description" : "Beacon node is currently syncing and not serving requests.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_events.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_events.json index 4fcf93bc570..5a007f68729 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_events.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_events.json @@ -24,6 +24,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_node_health.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_node_health.json index 0ec02da4584..8e1d8e5629a 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_node_health.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_node_health.json @@ -17,6 +17,10 @@ "description" : "Node is ready", "content" : { } }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "206" : { "description" : "Node is syncing but can serve incomplete data", "content" : { } diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_aggregate_and_proofs.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_aggregate_and_proofs.json index b6a236f1eba..4566706fa2f 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_aggregate_and_proofs.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_aggregate_and_proofs.json @@ -4,13 +4,14 @@ "operationId" : "publishAggregateAndProofs", "summary" : "Publish multiple aggregate and proofs", "description" : "Verifies given aggregate and proofs and publishes it on appropriate gossipsub topic.", + "deprecated" : true, "requestBody" : { "content" : { "application/json" : { "schema" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/SignedAggregateAndProof" + "$ref" : "#/components/schemas/SignedAggregateAndProofPhase0" } } } @@ -21,6 +22,20 @@ "description" : "Successfully published aggregate.", "content" : { } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_aggregate_attestation.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_aggregate_attestation.json index 7c227e015fe..62fc8c2e0f4 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_aggregate_attestation.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_aggregate_attestation.json @@ -4,6 +4,7 @@ "operationId" : "getAggregatedAttestation", "summary" : "Get aggregated attestation", "description" : "Aggregates all attestations matching given attestation data root and slot.", + "deprecated" : true, "parameters" : [ { "name" : "attestation_data_root", "required" : true, @@ -46,6 +47,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_beacon_committee_subscriptions.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_beacon_committee_subscriptions.json index b5551e1b368..0fcbe2a13dc 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_beacon_committee_subscriptions.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_beacon_committee_subscriptions.json @@ -31,6 +31,10 @@ } } }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_blinded_blocks_{slot}.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_blinded_blocks_{slot}.json deleted file mode 100644 index 154aefed021..00000000000 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_blinded_blocks_{slot}.json +++ /dev/null @@ -1,76 +0,0 @@ -{ - "get" : { - "tags" : [ "Validator", "Validator Required Api"], - "operationId" : "produceBlindedBlock", - "summary" : "Produce unsigned blinded block", - "description" : "Requests a beacon node to produce a valid blinded block, which can then be signed by a validator. A blinded block is a block with only a transactions root, rather than a full transactions list.\n\nMetadata in the response indicates the type of block produced, and the supported types of block will be added to as forks progress.\n\nPre-Bellatrix, this endpoint will return a `BeaconBlock`.", - "parameters" : [ { - "name" : "slot", - "required" : true, - "in" : "path", - "schema" : { - "type" : "string", - "description" : "The slot for which the block should be proposed.", - "example" : "1", - "format" : "uint64" - } - }, { - "name" : "randao_reveal", - "required" : true, - "in" : "query", - "schema" : { - "type" : "string", - "description" : "`BLSSignature Hex` BLS12-381 signature for the current epoch.", - "example" : "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505", - "format" : "byte" - } - }, { - "name" : "graffiti", - "in" : "query", - "schema" : { - "type" : "string", - "description" : "`Bytes32 Hex` Graffiti.", - "example" : "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", - "format" : "byte" - } - } ], - "responses" : { - "200" : { - "description" : "Request successful", - "content" : { - "application/json" : { - "schema" : { - "$ref" : "#/components/schemas/GetNewBlindedBlockResponse" - } - }, - "application/octet-stream" : { - "schema" : { - "type" : "string", - "format" : "binary" - } - } - } - }, - "400" : { - "description" : "The request could not be processed, check the response for more information.", - "content" : { - "application/json" : { - "schema" : { - "$ref" : "#/components/schemas/HttpErrorResponse" - } - } - } - }, - "500" : { - "description" : "Internal server error", - "content" : { - "application/json" : { - "schema" : { - "$ref" : "#/components/schemas/HttpErrorResponse" - } - } - } - } - } - } -} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_contribution_and_proofs.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_contribution_and_proofs.json index b073abc9e68..923728e309d 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_contribution_and_proofs.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_contribution_and_proofs.json @@ -21,6 +21,20 @@ "description" : "Successful response", "content" : { } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_duties_attester_{epoch}.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_duties_attester_{epoch}.json index 806517eb7cc..7a8a38ee290 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_duties_attester_{epoch}.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_duties_attester_{epoch}.json @@ -41,6 +41,10 @@ } } }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "503" : { "description" : "Beacon node is currently syncing and not serving requests.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_duties_proposer_{epoch}.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_duties_proposer_{epoch}.json index 9e7f62c8701..96505763b60 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_duties_proposer_{epoch}.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_duties_proposer_{epoch}.json @@ -36,6 +36,10 @@ } } }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_duties_sync_{epoch}.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_duties_sync_{epoch}.json index 4161fd54948..9b3d65a3bb9 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_duties_sync_{epoch}.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_duties_sync_{epoch}.json @@ -51,6 +51,10 @@ } } }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_liveness_{epoch}.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_liveness_{epoch}.json index 10da5efaf76..a845f9b6406 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_liveness_{epoch}.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_liveness_{epoch}.json @@ -51,6 +51,10 @@ } } }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_prepare_beacon_proposer.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_prepare_beacon_proposer.json index 9b9fa00701e..8d7bd4ffebf 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_prepare_beacon_proposer.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_prepare_beacon_proposer.json @@ -35,6 +35,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "500" : { "description" : "Internal server error", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_register_validator.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_register_validator.json index 43979c5c5b1..802ad1eb56f 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_register_validator.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_register_validator.json @@ -37,6 +37,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "500" : { "description" : "Internal server error", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_sync_committee_subscriptions.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_sync_committee_subscriptions.json index 81c6bff367b..a32174d4e40 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_sync_committee_subscriptions.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v1_validator_sync_committee_subscriptions.json @@ -21,6 +21,20 @@ "description" : "Successful response", "content" : { } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_beacon_blinded_blocks.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_beacon_blinded_blocks.json index 6b4120efcba..1cb1edbd7d8 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_beacon_blinded_blocks.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_beacon_blinded_blocks.json @@ -11,7 +11,8 @@ "type" : "string", "description" : "Level of validation that must be applied to a block before it is broadcast. Possible values:\n- **`gossip`** (default): lightweight gossip checks only\n- **`consensus`**: full consensus checks, including validation of all signatures and blocks fields _except_ for the execution payload transactions.\n- **`consensus_and_equivocation`**: the same as `consensus`, with an extra equivocation check immediately before the block is broadcast. If the block is found to be an\n equivocation it fails validation.\nIf the block fails the requested level of a validation a 400 status MUST be returned immediately and the block MUST NOT be broadcast to the network.\nIf validation succeeds, the block must still be fully verified before it is incorporated into the state and a 20x status is returned to the caller.", "example" : "consensus_and_equivocation", - "format" : "string" + "format" : "string", + "enum" : [ "gossip", "consensus", "consensus_and_equivocation" ] } }, { "name" : "Eth-Consensus-Version", @@ -19,7 +20,7 @@ "in" : "header", "schema" : { "type" : "string", - "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "eip7594" ], + "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "electra" ], "description" : "Version of the block being submitted." } } ], @@ -40,14 +41,14 @@ }, { "$ref" : "#/components/schemas/SignedBeaconBlockAltair" }, { - "$ref" : "#/components/schemas/SignedBlindedBlockBellatrix" + "$ref" : "#/components/schemas/SignedBlindedBeaconBlockBellatrix" }, { - "$ref" : "#/components/schemas/SignedBlindedBlockCapella" + "$ref" : "#/components/schemas/SignedBlindedBeaconBlockCapella" }, { - "$ref" : "#/components/schemas/SignedBlindedBlockDeneb" + "$ref" : "#/components/schemas/SignedBlindedBeaconBlockDeneb" }, { - "$ref" : "#/components/schemas/SignedBlindedBlockEip7594" - } ] + "$ref" : "#/components/schemas/SignedBlindedBeaconBlockElectra" + } ] } } } @@ -82,7 +83,7 @@ } }, "503" : { - "description" : "Beacon node is currently syncing.", + "description" : "Beacon node is currently syncing and not serving requests", "content" : { "application/json" : { "schema" : { @@ -91,6 +92,10 @@ } } }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "500" : { "description" : "Internal server error", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_beacon_blocks.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_beacon_blocks.json index f968fef7455..91bea9a6f03 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_beacon_blocks.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_beacon_blocks.json @@ -11,7 +11,8 @@ "type" : "string", "description" : "Level of validation that must be applied to a block before it is broadcast. Possible values:\n- **`gossip`** (default): lightweight gossip checks only\n- **`consensus`**: full consensus checks, including validation of all signatures and blocks fields _except_ for the execution payload transactions.\n- **`consensus_and_equivocation`**: the same as `consensus`, with an extra equivocation check immediately before the block is broadcast. If the block is found to be an\n equivocation it fails validation.\nIf the block fails the requested level of a validation a 400 status MUST be returned immediately and the block MUST NOT be broadcast to the network.\nIf validation succeeds, the block must still be fully verified before it is incorporated into the state and a 20x status is returned to the caller.", "example" : "consensus_and_equivocation", - "format" : "string" + "format" : "string", + "enum" : [ "gossip", "consensus", "consensus_and_equivocation" ] } }, { "name" : "Eth-Consensus-Version", @@ -19,7 +20,7 @@ "in" : "header", "schema" : { "type" : "string", - "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "eip7594" ], + "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "electra" ], "description" : "Version of the block being submitted." } } ], @@ -46,8 +47,8 @@ }, { "$ref" : "#/components/schemas/SignedBlockContentsDeneb" }, { - "$ref" : "#/components/schemas/SignedBlockContentsEip7594" - } ] + "$ref" : "#/components/schemas/SignedBlockContentsElectra" + } ] } } } @@ -82,7 +83,7 @@ } }, "503" : { - "description" : "Beacon node is currently syncing.", + "description" : "Beacon node is currently syncing and not serving requests", "content" : { "application/json" : { "schema" : { @@ -91,6 +92,10 @@ } } }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "500" : { "description" : "Internal server error", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_beacon_blocks_{block_id}.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_beacon_blocks_{block_id}.json index 33df40e3b9c..aa73172281e 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_beacon_blocks_{block_id}.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_beacon_blocks_{block_id}.json @@ -18,21 +18,31 @@ "200" : { "description" : "Request successful", "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/GetBlockV2Response" + } + }, "application/octet-stream" : { "schema" : { "type" : "string", "format" : "binary" } - }, + } + } + }, + "404" : { + "description" : "Not found", + "content" : { "application/json" : { "schema" : { - "$ref" : "#/components/schemas/GetBlockV2Response" + "$ref" : "#/components/schemas/HttpErrorResponse" } } } }, - "404" : { - "description" : "Not found", + "503" : { + "description" : "Service unavailable", "content" : { "application/json" : { "schema" : { @@ -41,6 +51,10 @@ } } }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_beacon_blocks_{block_id}_attestations.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_beacon_blocks_{block_id}_attestations.json new file mode 100644 index 00000000000..c73cde0e358 --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_beacon_blocks_{block_id}_attestations.json @@ -0,0 +1,92 @@ +{ + "get" : { + "tags" : [ "Beacon" ], + "operationId" : "getBlockAttestationsV2", + "summary" : "Get block attestations", + "description" : "Retrieves attestations included in requested block.", + "parameters" : [ { + "name" : "block_id", + "required" : true, + "in" : "path", + "schema" : { + "type" : "string", + "description" : "Block identifier. Can be one of: \"head\" (canonical head in node's view), \"genesis\", \"finalized\", <slot>, <hex encoded blockRoot with 0x prefix>.", + "example" : "head" + } + } ], + "responses" : { + "200" : { + "description" : "Request successful", + "headers" : { + "Eth-Consensus-Version": { + "description": "Required in response so client can deserialize returned json or ssz data more effectively.", + "required": true, + "schema": { + "type": "string", + "enum": [ + "phase0", + "altair", + "bellatrix", + "capella", + "deneb", + "electra" + ], + "example": "phase0" + } + } + }, + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/GetBlockAttestationsResponseV2" + } + } + } + }, + "404" : { + "description" : "Not found", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, + "400" : { + "description" : "The request could not be processed, check the response for more information.", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "500" : { + "description" : "Internal server error", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + } + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_beacon_pool_attestations.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_beacon_pool_attestations.json new file mode 100644 index 00000000000..5f652893c81 --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_beacon_pool_attestations.json @@ -0,0 +1,151 @@ +{ + "get" : { + "tags" : [ "Beacon" ], + "operationId" : "getPoolAttestationsV2", + "summary" : "Get Attestations from operations pool", + "description" : "Retrieves attestations known by the node but not necessarily incorporated into any block.", + "parameters" : [ { + "name" : "slot", + "in" : "query", + "schema" : { + "type" : "string", + "description" : "`UInt64` Slot to query in the canonical chain.", + "example" : "1", + "format" : "uint64" + } + }, { + "name" : "committee_index", + "in" : "query", + "schema" : { + "type" : "string", + "description" : "`uint64` Committee index to query.", + "example" : "1", + "format" : "uint64" + } + } ], + "responses" : { + "200" : { + "description" : "Request successful", + "headers" : { + "Eth-Consensus-Version": { + "description": "Required in response so client can deserialize returned json or ssz data more effectively.", + "required": true, + "schema": { + "type": "string", + "enum": [ + "phase0", + "altair", + "bellatrix", + "capella", + "deneb", + "electra" + ], + "example": "phase0" + } + } + }, + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/GetPoolAttestationsV2Response" + } + } + } + }, + "400" : { + "description" : "The request could not be processed, check the response for more information.", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "500" : { + "description" : "Internal server error", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + } + } + }, + "post" : { + "tags" : [ "Beacon", "Validator Required Api", "Experimental" ], + "operationId" : "submitPoolAttestationsV2", + "summary" : "Submit Attestation objects to node", + "description" : "Submits Attestation objects to the node. Each attestation in the request body is processed individually.\nIf an attestation is validated successfully, the node MUST publish that attestation on the appropriate subnet.\nIf one or more attestations fail validation, the node MUST return a 400 error with details of which attestations have failed, and why.", + "parameters" : [ { + "name" : "Eth-Consensus-Version", + "required" : true, + "in" : "header", + "schema" : { + "type" : "string", + "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "electra" ], + "description" : "Version of the attestations being submitted." + } + } ], + "requestBody" : { + "content" : { + "application/json" : { + "schema" : { + "type" : "array", + "items" : { + "title" : "SignedAttestation", + "type" : "object", + "oneOf" : [ { + "$ref" : "#/components/schemas/AttestationPhase0" + }, { + "$ref" : "#/components/schemas/AttestationElectra" + } ] + } + } + } + } + }, + "responses" : { + "200" : { + "description" : "Attestations are stored in pool and broadcast on appropriate subnet", + "content" : { } + }, + "400" : { + "description" : "Errors with one or more attestations", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/ErrorListBadRequest" + } + } + } + }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, + "500" : { + "description" : "Internal server error", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + } + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_beacon_pool_attester_slashings.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_beacon_pool_attester_slashings.json new file mode 100644 index 00000000000..9562ee1a45b --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_beacon_pool_attester_slashings.json @@ -0,0 +1,114 @@ +{ + "get" : { + "tags" : [ "Beacon" ], + "operationId" : "getPoolAttesterSlashingsV2", + "summary" : "Get AttesterSlashings from operations pool", + "description" : "Retrieves attester slashings known by the node but not necessarily incorporated into any block.", + "responses" : { + "200" : { + "description" : "Request successful", + "headers" : { + "Eth-Consensus-Version": { + "description": "Required in response so client can deserialize returned json or ssz data more effectively.", + "required": true, + "schema": { + "type": "string", + "enum": [ + "phase0", + "altair", + "bellatrix", + "capella", + "deneb", + "electra" + ], + "example": "phase0" + } + } + }, + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/GetPoolAttesterSlashingsV2Response" + } + } + } + }, + "400" : { + "description" : "The request could not be processed, check the response for more information.", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "500" : { + "description" : "Internal server error", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + } + } + }, + "post" : { + "tags" : [ "Beacon" ], + "operationId" : "submitPoolAttesterSlashingsV2", + "summary" : "Submit AttesterSlashing object to node's pool", + "description" : "Submits AttesterSlashing object to node's pool. Upon successful validation the node MUST broadcast it to network.", + "parameters" : [ { + "name" : "Eth-Consensus-Version", + "required" : true, + "in" : "header", + "schema" : { + "type" : "string", + "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "electra" ], + "description" : "Version of the attester slashing being submitted." + } + } ], + "requestBody" : { + "content" : { + "application/json" : { + "schema" : { + "type" : "object", + "oneOf" : [ { + "$ref" : "#/components/schemas/AttesterSlashingElectra" + }, { + "$ref" : "#/components/schemas/AttesterSlashingPhase0" + } ] + } + } + } + }, + "responses" : { + "200" : { + "description" : "Success", + "content" : { } + }, + "400" : { + "description" : "The request could not be processed, check the response for more information.", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "500" : { + "description" : "Internal server error", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + } + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_debug_beacon_heads.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_debug_beacon_heads.json index 050413736e4..d74935c3dc0 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_debug_beacon_heads.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_debug_beacon_heads.json @@ -24,6 +24,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_debug_beacon_states_{state_id}.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_debug_beacon_states_{state_id}.json index 9faa0508494..a803cb0fe24 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_debug_beacon_states_{state_id}.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_debug_beacon_states_{state_id}.json @@ -17,22 +17,50 @@ "responses" : { "200" : { "description" : "Request successful", + "headers" : { + "Eth-Consensus-Version": { + "description": "Required in response so client can deserialize returned json or ssz data more effectively.", + "required": true, + "schema": { + "type": "string", + "enum": [ + "phase0", + "altair", + "bellatrix", + "capella", + "deneb", + "electra" + ], + "example": "phase0" + } + } + }, "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/GetStateV2Response" + } + }, "application/octet-stream" : { "schema" : { "type" : "string", "format" : "binary" } - }, + } + } + }, + "404" : { + "description" : "Not found", + "content" : { "application/json" : { "schema" : { - "$ref" : "#/components/schemas/GetStateV2Response" + "$ref" : "#/components/schemas/HttpErrorResponse" } } } }, - "404" : { - "description" : "Not found", + "503" : { + "description" : "Service unavailable", "content" : { "application/json" : { "schema" : { @@ -41,6 +69,10 @@ } } }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_validator_aggregate_and_proofs.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_validator_aggregate_and_proofs.json new file mode 100644 index 00000000000..88123b6bfc9 --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_validator_aggregate_and_proofs.json @@ -0,0 +1,76 @@ +{ + "post" : { + "tags" : [ "Validator", "Validator Required Api" ], + "operationId" : "publishAggregateAndProofsV2", + "summary" : "Publish multiple aggregate and proofs", + "description" : "Verifies given aggregate and proofs and publishes it on appropriate gossipsub topic.", + "parameters" : [ { + "name" : "Eth-Consensus-Version", + "required" : true, + "in" : "header", + "schema" : { + "type" : "string", + "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "electra" ], + "description" : "Version of the aggregate and proofs being submitted." + } + } ], + "requestBody" : { + "content" : { + "application/json" : { + "schema" : { + "type" : "array", + "items" : { + "title" : "SignedAggregateAndProof", + "type" : "object", + "oneOf" : [ { + "$ref" : "#/components/schemas/SignedAggregateAndProofPhase0" + }, { + "$ref" : "#/components/schemas/SignedAggregateAndProofElectra" + } ] + } + } + } + } + }, + "responses" : { + "200" : { + "description" : "Attestations are stored in pool and broadcast on appropriate subnet", + "content" : { } + }, + "400" : { + "description" : "Invalid request syntax.", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, + "500" : { + "description" : "Internal server error", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + } + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_validator_aggregate_attestation.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_validator_aggregate_attestation.json new file mode 100644 index 00000000000..08fb7006ac2 --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_validator_aggregate_attestation.json @@ -0,0 +1,113 @@ +{ + "get" : { + "tags" : [ "Validator", "Validator Required Api" ], + "operationId" : "getAggregatedAttestationV2", + "summary" : "Get aggregated attestation", + "description" : "Aggregates all attestations matching given attestation data root, slot and committee index.\nA 503 error must be returned if the block identified by the response\n`beacon_block_root` is optimistic (i.e. the aggregated attestation attests\nto a block that has not been fully verified by an execution engine).\nA 404 error must be returned if no attestation is available for the requested\n`attestation_data_root`.", + "parameters" : [ { + "name" : "attestation_data_root", + "required" : true, + "in" : "query", + "schema" : { + "type" : "string", + "description" : "`String` HashTreeRoot of AttestationData that validator wants aggregated.", + "example" : "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", + "format" : "byte" + } + }, { + "name" : "slot", + "required" : true, + "in" : "query", + "schema" : { + "type" : "string", + "description" : "`uint64` value representing slot", + "example" : "1", + "format" : "uint64" + } + }, { + "name" : "committee_index", + "required" : true, + "in" : "query", + "schema" : { + "type" : "string", + "description" : "`uint64` Committee index to query.", + "example" : "1", + "format" : "uint64" + } + } ], + "responses" : { + "200" : { + "description" : "Request successful", + "headers" : { + "Eth-Consensus-Version": { + "description": "Required in response so client can deserialize returned json or ssz data more effectively.", + "required": true, + "schema": { + "type": "string", + "enum": [ + "phase0", + "altair", + "bellatrix", + "capella", + "deneb", + "electra" + ], + "example": "phase0" + } + } + }, + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/GetAggregatedAttestationResponseV2" + } + } + } + }, + "404" : { + "description" : "Not found", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, + "400" : { + "description" : "The request could not be processed, check the response for more information.", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "500" : { + "description" : "Internal server error", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + } + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_validator_blocks_{slot}.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_validator_blocks_{slot}.json deleted file mode 100644 index 908688b48d8..00000000000 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v2_validator_blocks_{slot}.json +++ /dev/null @@ -1,76 +0,0 @@ -{ - "get" : { - "tags" : [ "Validator", "Validator Required Api" ], - "operationId" : "produceBlockV2", - "summary" : "Produce a new block, without signature.", - "description" : "Requests a beacon node to produce a valid block, which can then be signed by a validator.\nMetadata in the response indicates the type of block produced, and the supported types of block will be added to as forks progress.", - "parameters" : [ { - "name" : "slot", - "required" : true, - "in" : "path", - "schema" : { - "type" : "string", - "description" : "The slot for which the block should be proposed.", - "example" : "1", - "format" : "uint64" - } - }, { - "name" : "randao_reveal", - "required" : true, - "in" : "query", - "schema" : { - "type" : "string", - "description" : "`BLSSignature Hex` BLS12-381 signature for the current epoch.", - "example" : "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505", - "format" : "byte" - } - }, { - "name" : "graffiti", - "in" : "query", - "schema" : { - "type" : "string", - "description" : "`Bytes32 Hex` Graffiti.", - "example" : "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", - "format" : "byte" - } - } ], - "responses" : { - "200" : { - "description" : "Request successful", - "content" : { - "application/json" : { - "schema" : { - "$ref" : "#/components/schemas/ProduceBlockV2Response" - } - }, - "application/octet-stream" : { - "schema" : { - "type" : "string", - "format" : "binary" - } - } - } - }, - "400" : { - "description" : "The request could not be processed, check the response for more information.", - "content" : { - "application/json" : { - "schema" : { - "$ref" : "#/components/schemas/HttpErrorResponse" - } - } - } - }, - "500" : { - "description" : "Internal server error", - "content" : { - "application/json" : { - "schema" : { - "$ref" : "#/components/schemas/HttpErrorResponse" - } - } - } - } - } - } -} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v3_validator_blocks_{slot}.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v3_validator_blocks_{slot}.json index 0ee02a55cc5..637b5477b3d 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v3_validator_blocks_{slot}.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_eth_v3_validator_blocks_{slot}.json @@ -33,13 +33,6 @@ "example" : "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", "format" : "byte" } - }, { - "name" : "skip_randao_verification", - "in" : "query", - "schema" : { - "type" : "boolean", - "description" : "Skip verification of the `randao_reveal` value. If this flag is set then the\n `randao_reveal` must be set to the point at infinity (`0xc0..00`). This query parameter\n is a flag and does not take a value" - } }, { "name" : "builder_boost_factor", "in" : "query", @@ -49,10 +42,61 @@ "example" : "1", "format" : "uint64" } + }, { + "name" : "skip_randao_verification", + "allowEmptyValue" : true, + "in" : "query", + "schema" : { + "type" : "string", + "description" : "Skip verification of the `randao_reveal` value. Ignored in the Teku implementation.", + "minLength" : 0, + "maxLength" : 0 + } } ], "responses" : { "200" : { "description" : "Request successful", + "headers": { + "Eth-Consensus-Version": { + "description": "Required in response so client can deserialize returned json or ssz data more effectively.", + "required": true, + "schema": { + "type": "string", + "enum": [ + "phase0", + "altair", + "bellatrix", + "capella", + "deneb", + "electra" + ], + "example": "phase0" + } + }, + "Eth-Execution-Payload-Blinded": { + "description": "Required in response so client can deserialize returned json or ssz data to the correct object.", + "required": true, + "schema": { + "type": "boolean" + } + }, + "Eth-Execution-Payload-Value": { + "description": "Execution payload value in Wei. Required in response so client can determine relative value of execution payloads.", + "required": true, + "schema": { + "type": "string", + "example": "1" + } + }, + "Eth-Consensus-Block-Value": { + "description": "Consensus rewards paid to the proposer for this block, in Wei. Required in response so client can determine relative value of consensus blocks.", + "required": true, + "schema": { + "type": "string", + "example": "1" + } + } + }, "content" : { "application/json" : { "schema" : { @@ -67,6 +111,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_admin_readiness.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_admin_readiness.json index ed19d5284a1..acec39512ab 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_admin_readiness.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_admin_readiness.json @@ -33,6 +33,10 @@ "description" : "Node is ready", "content" : { } }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "503" : { "description" : "Node not initialized or having issues", "content" : { } diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_beacon_blob_sidecars_{slot}.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_beacon_blob_sidecars_{slot}.json index 8d40058ba91..b060398a95c 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_beacon_blob_sidecars_{slot}.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_beacon_blob_sidecars_{slot}.json @@ -55,6 +55,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_beacon_blocks_{block_id}_state.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_beacon_blocks_{block_id}_state.json index adabb7f5043..b083741205e 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_beacon_blocks_{block_id}_state.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_beacon_blocks_{block_id}_state.json @@ -36,6 +36,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_beacon_blocks_{slot}.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_beacon_blocks_{slot}.json index 874812d667d..5a3c6dadfce 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_beacon_blocks_{slot}.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_beacon_blocks_{slot}.json @@ -46,6 +46,10 @@ } } }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_beacon_pool_eth1data.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_beacon_pool_eth1data.json index b202ab69a60..8c1c0b5eff3 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_beacon_pool_eth1data.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_beacon_pool_eth1data.json @@ -25,6 +25,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_beacon_state_finalized_slot_before_{slot}.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_beacon_state_finalized_slot_before_{slot}.json new file mode 100644 index 00000000000..ad20ed7bcbf --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_beacon_state_finalized_slot_before_{slot}.json @@ -0,0 +1,75 @@ +{ + "get" : { + "tags" : [ "Teku" ], + "operationId" : "GetFinalizedStateSlotBefore", + "summary" : "Get the closest stored state index", + "description" : "Get the State slot closest to the specified slot.", + "parameters" : [ { + "name" : "slot", + "required" : true, + "in" : "path", + "schema" : { + "type" : "string", + "description" : "At or before the specified slot", + "example" : "1", + "format" : "uint64" + } + } ], + "responses" : { + "200" : { + "description" : "Request successful", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/Slot" + } + } + } + }, + "503" : { + "description" : "Beacon node is currently syncing and not serving requests.", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "404" : { + "description" : "Not found", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, + "400" : { + "description" : "The request could not be processed, check the response for more information.", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "500" : { + "description" : "Internal server error", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + } + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_beacon_state_{state_id}_eth1voting.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_beacon_state_{state_id}_eth1voting.json index 92f18c3f9ce..ca53f153796 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_beacon_state_{state_id}_eth1voting.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_beacon_state_{state_id}_eth1voting.json @@ -35,6 +35,20 @@ } } }, + "503" : { + "description" : "Service unavailable", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "400" : { "description" : "The request could not be processed, check the response for more information.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_validator_inclusion_{epoch}_global.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_validator_inclusion_{epoch}_global.json index e09ee44415a..604129524ae 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_validator_inclusion_{epoch}_global.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_validator_inclusion_{epoch}_global.json @@ -26,6 +26,10 @@ } } }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "503" : { "description" : "Beacon node is currently syncing and not serving requests.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_validator_inclusion_{epoch}_{validator_id}.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_validator_inclusion_{epoch}_{validator_id}.json index 7093bb35b6d..f7c8a81748d 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_validator_inclusion_{epoch}_{validator_id}.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/paths/_teku_v1_validator_inclusion_{epoch}_{validator_id}.json @@ -36,6 +36,10 @@ } } }, + "204" : { + "description" : "Data is unavailable because the chain has not yet reached genesis", + "content" : { } + }, "503" : { "description" : "Beacon node is currently syncing and not serving requests.", "content" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/AggregateAndProofElectra.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/AggregateAndProofElectra.json new file mode 100644 index 00000000000..173020cc52f --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/AggregateAndProofElectra.json @@ -0,0 +1,26 @@ +{ + "title": "AggregateAndProofElectra", + "type": "object", + "required": [ + "aggregator_index", + "aggregate", + "selection_proof" + ], + "properties": { + "aggregator_index": { + "type": "string", + "description": "unsigned 64 bit integer", + "example": "1", + "format": "uint64" + }, + "aggregate": { + "$ref": "#/components/schemas/AttestationElectra" + }, + "selection_proof": { + "type": "string", + "pattern": "^0x[a-fA-F0-9]{2,}$", + "description": "SSZ hexadecimal", + "format": "bytes" + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/AggregateAndProof.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/AggregateAndProofPhase0.json similarity index 83% rename from data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/AggregateAndProof.json rename to data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/AggregateAndProofPhase0.json index 7a63add700b..7a8041fbe65 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/AggregateAndProof.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/AggregateAndProofPhase0.json @@ -1,5 +1,5 @@ { - "title" : "AggregateAndProof", + "title" : "AggregateAndProofPhase0", "type" : "object", "required" : [ "aggregator_index", "aggregate", "selection_proof" ], "properties" : { @@ -10,7 +10,7 @@ "format" : "uint64" }, "aggregate" : { - "$ref" : "#/components/schemas/Attestation" + "$ref" : "#/components/schemas/AttestationPhase0" }, "selection_proof" : { "type" : "string", diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/AttestationElectra.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/AttestationElectra.json new file mode 100644 index 00000000000..59d61a7c416 --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/AttestationElectra.json @@ -0,0 +1,28 @@ +{ + "title" : "AttestationElectra", + "type" : "object", + "required" : [ "aggregation_bits", "data", "signature", "committee_bits" ], + "properties" : { + "aggregation_bits" : { + "type" : "string", + "pattern" : "^0x[a-fA-F0-9]{2,}$", + "description" : "SSZ hexadecimal", + "format" : "bytes" + }, + "data" : { + "$ref" : "#/components/schemas/AttestationData" + }, + "signature" : { + "type" : "string", + "pattern" : "^0x[a-fA-F0-9]{2,}$", + "description" : "SSZ hexadecimal", + "format" : "bytes" + }, + "committee_bits" : { + "type" : "string", + "pattern" : "^0x[a-fA-F0-9]{2,}$", + "description" : "SSZ hexadecimal", + "format" : "bytes" + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/Attestation.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/AttestationPhase0.json similarity index 93% rename from data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/Attestation.json rename to data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/AttestationPhase0.json index b66acc1e1b8..980a5264304 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/Attestation.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/AttestationPhase0.json @@ -1,5 +1,5 @@ { - "title" : "Attestation", + "title" : "AttestationPhase0", "type" : "object", "required" : [ "aggregation_bits", "data", "signature" ], "properties" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/AttesterSlashing.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/AttesterSlashing.json deleted file mode 100644 index aa1b3c06657..00000000000 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/AttesterSlashing.json +++ /dev/null @@ -1,13 +0,0 @@ -{ - "title" : "AttesterSlashing", - "type" : "object", - "required" : [ "attestation_1", "attestation_2" ], - "properties" : { - "attestation_1" : { - "$ref" : "#/components/schemas/IndexedAttestation" - }, - "attestation_2" : { - "$ref" : "#/components/schemas/IndexedAttestation" - } - } -} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/AttesterSlashingElectra.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/AttesterSlashingElectra.json new file mode 100644 index 00000000000..52f0614976a --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/AttesterSlashingElectra.json @@ -0,0 +1,13 @@ +{ + "title" : "AttesterSlashingElectra", + "type" : "object", + "required" : [ "attestation_1", "attestation_2" ], + "properties" : { + "attestation_1" : { + "$ref" : "#/components/schemas/IndexedAttestationElectra" + }, + "attestation_2" : { + "$ref" : "#/components/schemas/IndexedAttestationElectra" + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/AttesterSlashingPhase0.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/AttesterSlashingPhase0.json new file mode 100644 index 00000000000..2d725a9578e --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/AttesterSlashingPhase0.json @@ -0,0 +1,13 @@ +{ + "title" : "AttesterSlashingPhase0", + "type" : "object", + "required" : [ "attestation_1", "attestation_2" ], + "properties" : { + "attestation_1" : { + "$ref" : "#/components/schemas/IndexedAttestationPhase0" + }, + "attestation_2" : { + "$ref" : "#/components/schemas/IndexedAttestationPhase0" + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyAltair.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyAltair.json index 81711198741..ebf9191eb57 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyAltair.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyAltair.json @@ -27,13 +27,13 @@ "attester_slashings" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/AttesterSlashing" + "$ref" : "#/components/schemas/AttesterSlashingPhase0" } }, "attestations" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/Attestation" + "$ref" : "#/components/schemas/AttestationPhase0" } }, "deposits" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyBellatrix.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyBellatrix.json index 0f4f883b4d3..b081e329a2f 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyBellatrix.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyBellatrix.json @@ -27,13 +27,13 @@ "attester_slashings" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/AttesterSlashing" + "$ref" : "#/components/schemas/AttesterSlashingPhase0" } }, "attestations" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/Attestation" + "$ref" : "#/components/schemas/AttestationPhase0" } }, "deposits" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyCapella.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyCapella.json index 13c55b40f0f..814ba7763ad 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyCapella.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyCapella.json @@ -27,13 +27,13 @@ "attester_slashings" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/AttesterSlashing" + "$ref" : "#/components/schemas/AttesterSlashingPhase0" } }, "attestations" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/Attestation" + "$ref" : "#/components/schemas/AttestationPhase0" } }, "deposits" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyDeneb.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyDeneb.json index 7cdad1ed069..05101be93d1 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyDeneb.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyDeneb.json @@ -27,13 +27,13 @@ "attester_slashings" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/AttesterSlashing" + "$ref" : "#/components/schemas/AttesterSlashingPhase0" } }, "attestations" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/Attestation" + "$ref" : "#/components/schemas/AttestationPhase0" } }, "deposits" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyEip7594.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyElectra.json similarity index 81% rename from data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyEip7594.json rename to data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyElectra.json index 5548476b61b..b81448f9d00 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyEip7594.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyElectra.json @@ -1,7 +1,7 @@ { - "title" : "BeaconBlockBodyEip7594", + "title" : "BeaconBlockBodyElectra", "type" : "object", - "required" : [ "randao_reveal", "eth1_data", "graffiti", "proposer_slashings", "attester_slashings", "attestations", "deposits", "voluntary_exits", "sync_aggregate", "execution_payload", "bls_to_execution_changes", "blob_kzg_commitments" ], + "required" : [ "randao_reveal", "eth1_data", "graffiti", "proposer_slashings", "attester_slashings", "attestations", "deposits", "voluntary_exits", "sync_aggregate", "execution_payload", "bls_to_execution_changes", "blob_kzg_commitments", "execution_requests" ], "properties" : { "randao_reveal" : { "type" : "string", @@ -27,13 +27,13 @@ "attester_slashings" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/AttesterSlashing" + "$ref" : "#/components/schemas/AttesterSlashingElectra" } }, "attestations" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/Attestation" + "$ref" : "#/components/schemas/AttestationElectra" } }, "deposits" : { @@ -52,7 +52,7 @@ "$ref" : "#/components/schemas/SyncAggregate" }, "execution_payload" : { - "$ref" : "#/components/schemas/ExecutionPayloadEip7594" + "$ref" : "#/components/schemas/ExecutionPayloadDeneb" }, "bls_to_execution_changes" : { "type" : "array", @@ -68,6 +68,9 @@ "description" : "Bytes48 hexadecimal", "format" : "bytes" } + }, + "execution_requests" : { + "$ref" : "#/components/schemas/ExecutionRequestsElectra" } } } \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyPhase0.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyPhase0.json index a968c3fc69f..180cae54b91 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyPhase0.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockBodyPhase0.json @@ -27,13 +27,13 @@ "attester_slashings" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/AttesterSlashing" + "$ref" : "#/components/schemas/AttesterSlashingPhase0" } }, "attestations" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/Attestation" + "$ref" : "#/components/schemas/AttestationPhase0" } }, "deposits" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBlockDeneb.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockElectra.json similarity index 90% rename from data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBlockDeneb.json rename to data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockElectra.json index dfa1babf2a7..227ae04b0f5 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBlockDeneb.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockElectra.json @@ -1,5 +1,5 @@ { - "title" : "BlindedBlockDeneb", + "title" : "BeaconBlockElectra", "type" : "object", "required" : [ "slot", "proposer_index", "parent_root", "state_root", "body" ], "properties" : { @@ -28,7 +28,7 @@ "format" : "byte" }, "body" : { - "$ref" : "#/components/schemas/BlindedBlockBodyDeneb" + "$ref" : "#/components/schemas/BeaconBlockBodyElectra" } } } \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconStateEip7594.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconStateElectra.json similarity index 73% rename from data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconStateEip7594.json rename to data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconStateElectra.json index 47c73566deb..a776461b6c6 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconStateEip7594.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconStateElectra.json @@ -1,7 +1,7 @@ { - "title" : "BeaconStateEip7594", + "title" : "BeaconStateElectra", "type" : "object", - "required" : [ "genesis_time", "genesis_validators_root", "slot", "fork", "latest_block_header", "block_roots", "state_roots", "historical_roots", "eth1_data", "eth1_data_votes", "eth1_deposit_index", "validators", "balances", "randao_mixes", "slashings", "previous_epoch_participation", "current_epoch_participation", "justification_bits", "previous_justified_checkpoint", "current_justified_checkpoint", "finalized_checkpoint", "inactivity_scores", "current_sync_committee", "next_sync_committee", "latest_execution_payload_header", "next_withdrawal_index", "next_withdrawal_validator_index", "historical_summaries" ], + "required" : [ "genesis_time", "genesis_validators_root", "slot", "fork", "latest_block_header", "block_roots", "state_roots", "historical_roots", "eth1_data", "eth1_data_votes", "eth1_deposit_index", "validators", "balances", "randao_mixes", "slashings", "previous_epoch_participation", "current_epoch_participation", "justification_bits", "previous_justified_checkpoint", "current_justified_checkpoint", "finalized_checkpoint", "inactivity_scores", "current_sync_committee", "next_sync_committee", "latest_execution_payload_header", "next_withdrawal_index", "next_withdrawal_validator_index", "historical_summaries", "deposit_requests_start_index", "deposit_balance_to_consume", "exit_balance_to_consume", "earliest_exit_epoch", "consolidation_balance_to_consume", "earliest_consolidation_epoch", "pending_deposits", "pending_partial_withdrawals", "pending_consolidations" ], "properties" : { "genesis_time" : { "type" : "string", @@ -151,7 +151,7 @@ "$ref" : "#/components/schemas/SyncCommittee" }, "latest_execution_payload_header" : { - "$ref" : "#/components/schemas/ExecutionPayloadHeaderEip7594" + "$ref" : "#/components/schemas/ExecutionPayloadHeaderDeneb" }, "next_withdrawal_index" : { "type" : "string", @@ -170,6 +170,60 @@ "items" : { "$ref" : "#/components/schemas/HistoricalSummary" } + }, + "deposit_requests_start_index" : { + "type" : "string", + "description" : "unsigned 64 bit integer", + "example" : "1", + "format" : "uint64" + }, + "deposit_balance_to_consume" : { + "type" : "string", + "description" : "unsigned 64 bit integer", + "example" : "1", + "format" : "uint64" + }, + "exit_balance_to_consume" : { + "type" : "string", + "description" : "unsigned 64 bit integer", + "example" : "1", + "format" : "uint64" + }, + "earliest_exit_epoch" : { + "type" : "string", + "description" : "unsigned 64 bit integer", + "example" : "1", + "format" : "uint64" + }, + "consolidation_balance_to_consume" : { + "type" : "string", + "description" : "unsigned 64 bit integer", + "example" : "1", + "format" : "uint64" + }, + "earliest_consolidation_epoch" : { + "type" : "string", + "description" : "unsigned 64 bit integer", + "example" : "1", + "format" : "uint64" + }, + "pending_deposits" : { + "type" : "array", + "items" : { + "$ref" : "#/components/schemas/PendingDeposit" + } + }, + "pending_partial_withdrawals" : { + "type" : "array", + "items" : { + "$ref" : "#/components/schemas/PendingPartialWithdrawal" + } + }, + "pending_consolidations" : { + "type" : "array", + "items" : { + "$ref" : "#/components/schemas/PendingConsolidation" + } } } } \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBeaconBlockBellatrix.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBeaconBlockBellatrix.json new file mode 100644 index 00000000000..44488aad10e --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBeaconBlockBellatrix.json @@ -0,0 +1,34 @@ +{ + "title" : "BlindedBeaconBlockBellatrix", + "type" : "object", + "required" : [ "slot", "proposer_index", "parent_root", "state_root", "body" ], + "properties" : { + "slot" : { + "type" : "string", + "description" : "unsigned 64 bit integer", + "example" : "1", + "format" : "uint64" + }, + "proposer_index" : { + "type" : "string", + "description" : "unsigned 64 bit integer", + "example" : "1", + "format" : "uint64" + }, + "parent_root" : { + "type" : "string", + "description" : "Bytes32 hexadecimal", + "example" : "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", + "format" : "byte" + }, + "state_root" : { + "type" : "string", + "description" : "Bytes32 hexadecimal", + "example" : "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", + "format" : "byte" + }, + "body" : { + "$ref" : "#/components/schemas/BlindedBeaconBlockBodyBellatrix" + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBlockBodyBellatrix.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBeaconBlockBodyBellatrix.json similarity index 89% rename from data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBlockBodyBellatrix.json rename to data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBeaconBlockBodyBellatrix.json index d9ab161695b..827dfd1f802 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBlockBodyBellatrix.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBeaconBlockBodyBellatrix.json @@ -1,5 +1,5 @@ { - "title" : "BlindedBlockBodyBellatrix", + "title" : "BlindedBeaconBlockBodyBellatrix", "type" : "object", "required" : [ "randao_reveal", "eth1_data", "graffiti", "proposer_slashings", "attester_slashings", "attestations", "deposits", "voluntary_exits", "sync_aggregate", "execution_payload_header" ], "properties" : { @@ -27,13 +27,13 @@ "attester_slashings" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/AttesterSlashing" + "$ref" : "#/components/schemas/AttesterSlashingPhase0" } }, "attestations" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/Attestation" + "$ref" : "#/components/schemas/AttestationPhase0" } }, "deposits" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBlockBodyCapella.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBeaconBlockBodyCapella.json similarity index 90% rename from data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBlockBodyCapella.json rename to data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBeaconBlockBodyCapella.json index 709a51b760b..99f839ff19d 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBlockBodyCapella.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBeaconBlockBodyCapella.json @@ -1,5 +1,5 @@ { - "title" : "BlindedBlockBodyCapella", + "title" : "BlindedBeaconBlockBodyCapella", "type" : "object", "required" : [ "randao_reveal", "eth1_data", "graffiti", "proposer_slashings", "attester_slashings", "attestations", "deposits", "voluntary_exits", "sync_aggregate", "execution_payload_header", "bls_to_execution_changes" ], "properties" : { @@ -27,13 +27,13 @@ "attester_slashings" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/AttesterSlashing" + "$ref" : "#/components/schemas/AttesterSlashingPhase0" } }, "attestations" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/Attestation" + "$ref" : "#/components/schemas/AttestationPhase0" } }, "deposits" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBlockBodyDeneb.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBeaconBlockBodyDeneb.json similarity index 92% rename from data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBlockBodyDeneb.json rename to data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBeaconBlockBodyDeneb.json index 00361b19622..22165d4a0ed 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBlockBodyDeneb.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBeaconBlockBodyDeneb.json @@ -1,5 +1,5 @@ { - "title" : "BlindedBlockBodyDeneb", + "title" : "BlindedBeaconBlockBodyDeneb", "type" : "object", "required" : [ "randao_reveal", "eth1_data", "graffiti", "proposer_slashings", "attester_slashings", "attestations", "deposits", "voluntary_exits", "sync_aggregate", "execution_payload_header", "bls_to_execution_changes", "blob_kzg_commitments" ], "properties" : { @@ -27,13 +27,13 @@ "attester_slashings" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/AttesterSlashing" + "$ref" : "#/components/schemas/AttesterSlashingPhase0" } }, "attestations" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/Attestation" + "$ref" : "#/components/schemas/AttestationPhase0" } }, "deposits" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBlockBodyEip7594.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBeaconBlockBodyElectra.json similarity index 81% rename from data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBlockBodyEip7594.json rename to data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBeaconBlockBodyElectra.json index 7bd1771f56c..5b23a9f8683 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBlockBodyEip7594.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBeaconBlockBodyElectra.json @@ -1,7 +1,7 @@ { - "title" : "BlindedBlockBodyEip7594", + "title" : "BlindedBeaconBlockBodyElectra", "type" : "object", - "required" : [ "randao_reveal", "eth1_data", "graffiti", "proposer_slashings", "attester_slashings", "attestations", "deposits", "voluntary_exits", "sync_aggregate", "execution_payload_header", "bls_to_execution_changes", "blob_kzg_commitments" ], + "required" : [ "randao_reveal", "eth1_data", "graffiti", "proposer_slashings", "attester_slashings", "attestations", "deposits", "voluntary_exits", "sync_aggregate", "execution_payload_header", "bls_to_execution_changes", "blob_kzg_commitments", "execution_requests" ], "properties" : { "randao_reveal" : { "type" : "string", @@ -27,13 +27,13 @@ "attester_slashings" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/AttesterSlashing" + "$ref" : "#/components/schemas/AttesterSlashingElectra" } }, "attestations" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/Attestation" + "$ref" : "#/components/schemas/AttestationElectra" } }, "deposits" : { @@ -52,7 +52,7 @@ "$ref" : "#/components/schemas/SyncAggregate" }, "execution_payload_header" : { - "$ref" : "#/components/schemas/ExecutionPayloadHeaderEip7594" + "$ref" : "#/components/schemas/ExecutionPayloadHeaderDeneb" }, "bls_to_execution_changes" : { "type" : "array", @@ -68,6 +68,9 @@ "description" : "Bytes48 hexadecimal", "format" : "bytes" } + }, + "execution_requests" : { + "$ref" : "#/components/schemas/ExecutionRequestsElectra" } } } \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockEip7594.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBeaconBlockCapella.json similarity index 88% rename from data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockEip7594.json rename to data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBeaconBlockCapella.json index 99775d037e8..b254a00efb4 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BeaconBlockEip7594.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBeaconBlockCapella.json @@ -1,5 +1,5 @@ { - "title" : "BeaconBlockEip7594", + "title" : "BlindedBeaconBlockCapella", "type" : "object", "required" : [ "slot", "proposer_index", "parent_root", "state_root", "body" ], "properties" : { @@ -28,7 +28,7 @@ "format" : "byte" }, "body" : { - "$ref" : "#/components/schemas/BeaconBlockBodyEip7594" + "$ref" : "#/components/schemas/BlindedBeaconBlockBodyCapella" } } } \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBlockCapella.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBeaconBlockDeneb.json similarity index 89% rename from data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBlockCapella.json rename to data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBeaconBlockDeneb.json index 7f22389b7b8..d201f7cf56b 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBlockCapella.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBeaconBlockDeneb.json @@ -1,5 +1,5 @@ { - "title" : "BlindedBlockCapella", + "title" : "BlindedBeaconBlockDeneb", "type" : "object", "required" : [ "slot", "proposer_index", "parent_root", "state_root", "body" ], "properties" : { @@ -28,7 +28,7 @@ "format" : "byte" }, "body" : { - "$ref" : "#/components/schemas/BlindedBlockBodyCapella" + "$ref" : "#/components/schemas/BlindedBeaconBlockBodyDeneb" } } } \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBlockBellatrix.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBeaconBlockElectra.json similarity index 88% rename from data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBlockBellatrix.json rename to data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBeaconBlockElectra.json index 532eeac0a87..f3e4a22f90b 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBlockBellatrix.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBeaconBlockElectra.json @@ -1,5 +1,5 @@ { - "title" : "BlindedBlockBellatrix", + "title" : "BlindedBeaconBlockElectra", "type" : "object", "required" : [ "slot", "proposer_index", "parent_root", "state_root", "body" ], "properties" : { @@ -28,7 +28,7 @@ "format" : "byte" }, "body" : { - "$ref" : "#/components/schemas/BlindedBlockBodyBellatrix" + "$ref" : "#/components/schemas/BlindedBeaconBlockBodyElectra" } } } \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBlockEip7594.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBlockEip7594.json deleted file mode 100644 index c6c35b11df9..00000000000 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlindedBlockEip7594.json +++ /dev/null @@ -1,34 +0,0 @@ -{ - "title" : "BlindedBlockEip7594", - "type" : "object", - "required" : [ "slot", "proposer_index", "parent_root", "state_root", "body" ], - "properties" : { - "slot" : { - "type" : "string", - "description" : "unsigned 64 bit integer", - "example" : "1", - "format" : "uint64" - }, - "proposer_index" : { - "type" : "string", - "description" : "unsigned 64 bit integer", - "example" : "1", - "format" : "uint64" - }, - "parent_root" : { - "type" : "string", - "description" : "Bytes32 hexadecimal", - "example" : "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", - "format" : "byte" - }, - "state_root" : { - "type" : "string", - "description" : "Bytes32 hexadecimal", - "example" : "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", - "format" : "byte" - }, - "body" : { - "$ref" : "#/components/schemas/BlindedBlockBodyEip7594" - } - } -} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlockContentsEip7594.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlockContentsElectra.json similarity index 85% rename from data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlockContentsEip7594.json rename to data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlockContentsElectra.json index 762b399d7c9..49df0784a17 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlockContentsEip7594.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/BlockContentsElectra.json @@ -1,10 +1,10 @@ { - "title" : "BlockContentsEip7594", + "title" : "BlockContentsElectra", "type" : "object", "required" : [ "block", "kzg_proofs", "blobs" ], "properties" : { "block" : { - "$ref" : "#/components/schemas/BeaconBlockEip7594" + "$ref" : "#/components/schemas/BeaconBlockElectra" }, "kzg_proofs" : { "type" : "array", diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/ConsolidationRequest.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/ConsolidationRequest.json new file mode 100644 index 00000000000..8718b24e028 --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/ConsolidationRequest.json @@ -0,0 +1,25 @@ +{ + "title" : "ConsolidationRequest", + "type" : "object", + "required" : [ "source_address", "source_pubkey", "target_pubkey" ], + "properties" : { + "source_address" : { + "type" : "string", + "pattern" : "^0x[a-fA-F0-9]{2,}$", + "description" : "SSZ hexadecimal", + "format" : "bytes" + }, + "source_pubkey" : { + "type" : "string", + "pattern" : "^0x[a-fA-F0-9]{2,}$", + "description" : "Bytes48 hexadecimal", + "format" : "bytes" + }, + "target_pubkey" : { + "type" : "string", + "pattern" : "^0x[a-fA-F0-9]{2,}$", + "description" : "Bytes48 hexadecimal", + "format" : "bytes" + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/DepositRequest.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/DepositRequest.json new file mode 100644 index 00000000000..5dca2c975fb --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/DepositRequest.json @@ -0,0 +1,37 @@ +{ + "title" : "DepositRequest", + "type" : "object", + "required" : [ "pubkey", "withdrawal_credentials", "amount", "signature", "index" ], + "properties" : { + "pubkey" : { + "type" : "string", + "pattern" : "^0x[a-fA-F0-9]{2,}$", + "description" : "Bytes48 hexadecimal", + "format" : "bytes" + }, + "withdrawal_credentials" : { + "type" : "string", + "description" : "Bytes32 hexadecimal", + "example" : "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", + "format" : "byte" + }, + "amount" : { + "type" : "string", + "description" : "unsigned 64 bit integer", + "example" : "1", + "format" : "uint64" + }, + "signature" : { + "type" : "string", + "pattern" : "^0x[a-fA-F0-9]{2,}$", + "description" : "SSZ hexadecimal", + "format" : "bytes" + }, + "index" : { + "type" : "string", + "description" : "unsigned 64 bit integer", + "example" : "1", + "format" : "uint64" + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/ExecutionPayloadEip7594.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/ExecutionPayloadEip7594.json deleted file mode 100644 index 3fb3656b007..00000000000 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/ExecutionPayloadEip7594.json +++ /dev/null @@ -1,112 +0,0 @@ -{ - "title" : "ExecutionPayloadEip7594", - "type" : "object", - "required" : [ "parent_hash", "fee_recipient", "state_root", "receipts_root", "logs_bloom", "prev_randao", "block_number", "gas_limit", "gas_used", "timestamp", "extra_data", "base_fee_per_gas", "block_hash", "transactions", "withdrawals", "blob_gas_used", "excess_blob_gas" ], - "properties" : { - "parent_hash" : { - "type" : "string", - "description" : "Bytes32 hexadecimal", - "example" : "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", - "format" : "byte" - }, - "fee_recipient" : { - "type" : "string", - "pattern" : "^0x[a-fA-F0-9]{2,}$", - "description" : "SSZ hexadecimal", - "format" : "bytes" - }, - "state_root" : { - "type" : "string", - "description" : "Bytes32 hexadecimal", - "example" : "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", - "format" : "byte" - }, - "receipts_root" : { - "type" : "string", - "description" : "Bytes32 hexadecimal", - "example" : "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", - "format" : "byte" - }, - "logs_bloom" : { - "type" : "string", - "pattern" : "^0x[a-fA-F0-9]{2,}$", - "description" : "SSZ hexadecimal", - "format" : "bytes" - }, - "prev_randao" : { - "type" : "string", - "description" : "Bytes32 hexadecimal", - "example" : "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", - "format" : "byte" - }, - "block_number" : { - "type" : "string", - "description" : "unsigned 64 bit integer", - "example" : "1", - "format" : "uint64" - }, - "gas_limit" : { - "type" : "string", - "description" : "unsigned 64 bit integer", - "example" : "1", - "format" : "uint64" - }, - "gas_used" : { - "type" : "string", - "description" : "unsigned 64 bit integer", - "example" : "1", - "format" : "uint64" - }, - "timestamp" : { - "type" : "string", - "description" : "unsigned 64 bit integer", - "example" : "1", - "format" : "uint64" - }, - "extra_data" : { - "type" : "string", - "pattern" : "^0x[a-fA-F0-9]{2,}$", - "description" : "SSZ encoded byte list", - "format" : "bytes" - }, - "base_fee_per_gas" : { - "type" : "string", - "description" : "unsigned 256 bit integer", - "example" : "1", - "format" : "uint256" - }, - "block_hash" : { - "type" : "string", - "description" : "Bytes32 hexadecimal", - "example" : "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", - "format" : "byte" - }, - "transactions" : { - "type" : "array", - "items" : { - "type" : "string", - "pattern" : "^0x[a-fA-F0-9]{2,}$", - "description" : "SSZ encoded byte list", - "format" : "bytes" - } - }, - "withdrawals" : { - "type" : "array", - "items" : { - "$ref" : "#/components/schemas/Withdrawal" - } - }, - "blob_gas_used" : { - "type" : "string", - "description" : "unsigned 64 bit integer", - "example" : "1", - "format" : "uint64" - }, - "excess_blob_gas" : { - "type" : "string", - "description" : "unsigned 64 bit integer", - "example" : "1", - "format" : "uint64" - } - } -} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/ExecutionPayloadHeaderEip7594.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/ExecutionPayloadHeaderEip7594.json deleted file mode 100644 index 57b79c56181..00000000000 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/ExecutionPayloadHeaderEip7594.json +++ /dev/null @@ -1,109 +0,0 @@ -{ - "title" : "ExecutionPayloadHeaderEip7594", - "type" : "object", - "required" : [ "parent_hash", "fee_recipient", "state_root", "receipts_root", "logs_bloom", "prev_randao", "block_number", "gas_limit", "gas_used", "timestamp", "extra_data", "base_fee_per_gas", "block_hash", "transactions_root", "withdrawals_root", "blob_gas_used", "excess_blob_gas" ], - "properties" : { - "parent_hash" : { - "type" : "string", - "description" : "Bytes32 hexadecimal", - "example" : "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", - "format" : "byte" - }, - "fee_recipient" : { - "type" : "string", - "pattern" : "^0x[a-fA-F0-9]{2,}$", - "description" : "SSZ hexadecimal", - "format" : "bytes" - }, - "state_root" : { - "type" : "string", - "description" : "Bytes32 hexadecimal", - "example" : "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", - "format" : "byte" - }, - "receipts_root" : { - "type" : "string", - "description" : "Bytes32 hexadecimal", - "example" : "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", - "format" : "byte" - }, - "logs_bloom" : { - "type" : "string", - "pattern" : "^0x[a-fA-F0-9]{2,}$", - "description" : "SSZ hexadecimal", - "format" : "bytes" - }, - "prev_randao" : { - "type" : "string", - "description" : "Bytes32 hexadecimal", - "example" : "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", - "format" : "byte" - }, - "block_number" : { - "type" : "string", - "description" : "unsigned 64 bit integer", - "example" : "1", - "format" : "uint64" - }, - "gas_limit" : { - "type" : "string", - "description" : "unsigned 64 bit integer", - "example" : "1", - "format" : "uint64" - }, - "gas_used" : { - "type" : "string", - "description" : "unsigned 64 bit integer", - "example" : "1", - "format" : "uint64" - }, - "timestamp" : { - "type" : "string", - "description" : "unsigned 64 bit integer", - "example" : "1", - "format" : "uint64" - }, - "extra_data" : { - "type" : "string", - "pattern" : "^0x[a-fA-F0-9]{2,}$", - "description" : "SSZ encoded byte list", - "format" : "bytes" - }, - "base_fee_per_gas" : { - "type" : "string", - "description" : "unsigned 256 bit integer", - "example" : "1", - "format" : "uint256" - }, - "block_hash" : { - "type" : "string", - "description" : "Bytes32 hexadecimal", - "example" : "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", - "format" : "byte" - }, - "transactions_root" : { - "type" : "string", - "description" : "Bytes32 hexadecimal", - "example" : "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", - "format" : "byte" - }, - "withdrawals_root" : { - "type" : "string", - "description" : "Bytes32 hexadecimal", - "example" : "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", - "format" : "byte" - }, - "blob_gas_used" : { - "type" : "string", - "description" : "unsigned 64 bit integer", - "example" : "1", - "format" : "uint64" - }, - "excess_blob_gas" : { - "type" : "string", - "description" : "unsigned 64 bit integer", - "example" : "1", - "format" : "uint64" - } - } -} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/ExecutionRequestsElectra.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/ExecutionRequestsElectra.json new file mode 100644 index 00000000000..68bf9caf123 --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/ExecutionRequestsElectra.json @@ -0,0 +1,25 @@ +{ + "title" : "ExecutionRequestsElectra", + "type" : "object", + "required" : [ "deposits", "withdrawals", "consolidations" ], + "properties" : { + "deposits" : { + "type" : "array", + "items" : { + "$ref" : "#/components/schemas/DepositRequest" + } + }, + "withdrawals" : { + "type" : "array", + "items" : { + "$ref" : "#/components/schemas/WithdrawalRequest" + } + }, + "consolidations" : { + "type" : "array", + "items" : { + "$ref" : "#/components/schemas/ConsolidationRequest" + } + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetAggregatedAttestationResponse.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetAggregatedAttestationResponse.json index de97b916c1c..902782d5a40 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetAggregatedAttestationResponse.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetAggregatedAttestationResponse.json @@ -4,7 +4,7 @@ "required" : [ "data" ], "properties" : { "data" : { - "$ref" : "#/components/schemas/Attestation" + "$ref" : "#/components/schemas/AttestationElectra" } } } \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetAggregatedAttestationResponseV2.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetAggregatedAttestationResponseV2.json new file mode 100644 index 00000000000..9cb12c68428 --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetAggregatedAttestationResponseV2.json @@ -0,0 +1,19 @@ +{ + "title" : "GetAggregatedAttestationResponseV2", + "type" : "object", + "required" : [ "version", "data" ], + "properties" : { + "version" : { + "type" : "string", + "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "electra" ] + }, + "data" : { + "type" : "object", + "oneOf" : [ { + "$ref" : "#/components/schemas/AttestationElectra" + }, { + "$ref" : "#/components/schemas/AttestationPhase0" + } ] + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetAllBlocksAtSlotResponse.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetAllBlocksAtSlotResponse.json index 04cdd34b0a8..80cd5b0740b 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetAllBlocksAtSlotResponse.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetAllBlocksAtSlotResponse.json @@ -5,7 +5,7 @@ "properties" : { "version" : { "type" : "string", - "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "eip7594" ] + "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "electra" ] }, "data" : { "type" : "array", @@ -27,7 +27,7 @@ }, { "$ref" : "#/components/schemas/BeaconBlockDeneb" }, { - "$ref" : "#/components/schemas/BeaconBlockEip7594" + "$ref" : "#/components/schemas/BeaconBlockElectra" } ] }, "signature" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetBlindedBlockResponse.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetBlindedBlockResponse.json index 5142d0303ac..36777047ed8 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetBlindedBlockResponse.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetBlindedBlockResponse.json @@ -5,7 +5,7 @@ "properties" : { "version" : { "type" : "string", - "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "eip7594" ] + "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "electra" ] }, "execution_optimistic" : { "type" : "boolean" @@ -21,13 +21,13 @@ }, { "$ref" : "#/components/schemas/SignedBeaconBlockAltair" }, { - "$ref" : "#/components/schemas/SignedBlindedBlockBellatrix" + "$ref" : "#/components/schemas/SignedBlindedBeaconBlockBellatrix" }, { - "$ref" : "#/components/schemas/SignedBlindedBlockCapella" + "$ref" : "#/components/schemas/SignedBlindedBeaconBlockCapella" }, { - "$ref" : "#/components/schemas/SignedBlindedBlockDeneb" + "$ref" : "#/components/schemas/SignedBlindedBeaconBlockDeneb" }, { - "$ref" : "#/components/schemas/SignedBlindedBlockEip7594" + "$ref" : "#/components/schemas/SignedBlindedBeaconBlockElectra" } ] } } diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetBlobSidecarsResponse.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetBlobSidecarsResponse.json index 0e4e5ba8d5c..03a7a2c46d7 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetBlobSidecarsResponse.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetBlobSidecarsResponse.json @@ -3,6 +3,16 @@ "type" : "object", "required" : [ "data" ], "properties" : { + "version" : { + "type" : "string", + "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "electra" ] + }, + "execution_optimistic" : { + "type" : "boolean" + }, + "finalized" : { + "type" : "boolean" + }, "data" : { "type" : "array", "items" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetBlockAttestationsResponse.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetBlockAttestationsResponse.json index 316e89ddf91..3fec1cc9cdc 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetBlockAttestationsResponse.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetBlockAttestationsResponse.json @@ -12,7 +12,7 @@ "data" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/Attestation" + "$ref" : "#/components/schemas/AttestationElectra" } } } diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetBlockAttestationsResponseV2.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetBlockAttestationsResponseV2.json new file mode 100644 index 00000000000..0ab64e88a12 --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetBlockAttestationsResponseV2.json @@ -0,0 +1,31 @@ +{ + "title" : "GetBlockAttestationsResponseV2", + "type" : "object", + "required" : [ "execution_optimistic", "finalized", "version", "data" ], + "properties" : { + "execution_optimistic" : { + "type" : "boolean" + }, + "finalized" : { + "type" : "boolean" + }, + "version" : { + "type" : "string", + "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "electra" ] + }, + "data" : { + "type" : "object", + "oneOf" : [ { + "type" : "array", + "items" : { + "$ref" : "#/components/schemas/AttestationElectra" + } + }, { + "type" : "array", + "items" : { + "$ref" : "#/components/schemas/AttestationPhase0" + } + } ] + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetBlockV2Response.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetBlockV2Response.json index fb7d2a7fdc7..87ad068b65f 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetBlockV2Response.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetBlockV2Response.json @@ -5,7 +5,7 @@ "properties" : { "version" : { "type" : "string", - "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "eip7594" ] + "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "electra" ] }, "execution_optimistic" : { "type" : "boolean" @@ -27,7 +27,7 @@ }, { "$ref" : "#/components/schemas/SignedBeaconBlockDeneb" }, { - "$ref" : "#/components/schemas/SignedBeaconBlockEip7594" + "$ref" : "#/components/schemas/SignedBeaconBlockElectra" } ] } } diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetLightClientBootstrapResponse.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetLightClientBootstrapResponse.json index faddc373e92..2d83bbbbbab 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetLightClientBootstrapResponse.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetLightClientBootstrapResponse.json @@ -5,7 +5,7 @@ "properties" : { "version" : { "type" : "string", - "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "eip7594" ] + "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "electra" ] }, "data" : { "$ref" : "#/components/schemas/LightClientBootstrap" diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetNewBlindedBlockResponse.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetNewBlindedBlockResponse.json deleted file mode 100644 index 581f563c0a2..00000000000 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetNewBlindedBlockResponse.json +++ /dev/null @@ -1,28 +0,0 @@ -{ - "title" : "GetNewBlindedBlockResponse", - "type" : "object", - "required" : [ "data", "version" ], - "properties" : { - "data" : { - "title" : "BlindedBlock", - "type" : "object", - "oneOf" : [ { - "$ref" : "#/components/schemas/BeaconBlockPhase0" - }, { - "$ref" : "#/components/schemas/BeaconBlockAltair" - }, { - "$ref" : "#/components/schemas/BlindedBlockBellatrix" - }, { - "$ref" : "#/components/schemas/BlindedBlockCapella" - }, { - "$ref" : "#/components/schemas/BlindedBlockDeneb" - }, { - "$ref" : "#/components/schemas/BlindedBlockEip7594" - } ] - }, - "version" : { - "type" : "string", - "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "eip7594" ] - } - } -} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetPoolAttestationsResponse.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetPoolAttestationsResponse.json index a40c2b37a28..3be21c2b1bc 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetPoolAttestationsResponse.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetPoolAttestationsResponse.json @@ -6,7 +6,7 @@ "data" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/Attestation" + "$ref" : "#/components/schemas/AttestationElectra" } } } diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetPoolAttestationsV2Response.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetPoolAttestationsV2Response.json new file mode 100644 index 00000000000..80756cfe9c9 --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetPoolAttestationsV2Response.json @@ -0,0 +1,23 @@ +{ + "title" : "GetPoolAttestationsV2Response", + "type" : "object", + "required" : [ "version", "data" ], + "properties" : { + "version" : { + "type" : "string", + "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "electra" ] + }, + "data" : { + "type" : "array", + "items" : { + "title" : "Attestation", + "type" : "object", + "oneOf" : [ { + "$ref" : "#/components/schemas/AttestationPhase0" + }, { + "$ref" : "#/components/schemas/AttestationElectra" + } ] + } + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetPoolAttesterSlashingsResponse.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetPoolAttesterSlashingsResponse.json index 198a746336b..832509e4385 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetPoolAttesterSlashingsResponse.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetPoolAttesterSlashingsResponse.json @@ -6,7 +6,7 @@ "data" : { "type" : "array", "items" : { - "$ref" : "#/components/schemas/AttesterSlashing" + "$ref" : "#/components/schemas/AttesterSlashingPhase0" } } } diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetPoolAttesterSlashingsV2Response.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetPoolAttesterSlashingsV2Response.json new file mode 100644 index 00000000000..f7d37298367 --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetPoolAttesterSlashingsV2Response.json @@ -0,0 +1,25 @@ +{ + "title" : "GetPoolAttesterSlashingsV2Response", + "type" : "object", + "required" : [ "version", "data" ], + "properties" : { + "version" : { + "type" : "string", + "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "electra" ] + }, + "data" : { + "type" : "object", + "oneOf" : [ { + "type" : "array", + "items" : { + "$ref" : "#/components/schemas/AttesterSlashingElectra" + } + }, { + "type" : "array", + "items" : { + "$ref" : "#/components/schemas/AttesterSlashingPhase0" + } + } ] + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetStateV2Response.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetStateV2Response.json index fcd39d7f559..27b011ce585 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetStateV2Response.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/GetStateV2Response.json @@ -5,7 +5,7 @@ "properties" : { "version" : { "type" : "string", - "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "eip7594" ] + "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "electra" ] }, "execution_optimistic" : { "type" : "boolean" @@ -27,7 +27,7 @@ }, { "$ref" : "#/components/schemas/BeaconStateDeneb" }, { - "$ref" : "#/components/schemas/BeaconStateEip7594" + "$ref" : "#/components/schemas/BeaconStateElectra" } ] } } diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/IndexedAttestationElectra.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/IndexedAttestationElectra.json new file mode 100644 index 00000000000..ba7920d14c6 --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/IndexedAttestationElectra.json @@ -0,0 +1,25 @@ +{ + "title" : "IndexedAttestationElectra", + "type" : "object", + "required" : [ "attesting_indices", "data", "signature" ], + "properties" : { + "attesting_indices" : { + "type" : "array", + "items" : { + "type" : "string", + "description" : "unsigned 64 bit integer", + "example" : "1", + "format" : "uint64" + } + }, + "data" : { + "$ref" : "#/components/schemas/AttestationData" + }, + "signature" : { + "type" : "string", + "pattern" : "^0x[a-fA-F0-9]{2,}$", + "description" : "SSZ hexadecimal", + "format" : "bytes" + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/IndexedAttestation.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/IndexedAttestationPhase0.json similarity index 93% rename from data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/IndexedAttestation.json rename to data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/IndexedAttestationPhase0.json index b1519c468cf..e9aa8a04467 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/IndexedAttestation.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/IndexedAttestationPhase0.json @@ -1,5 +1,5 @@ { - "title" : "IndexedAttestation", + "title" : "IndexedAttestationPhase0", "type" : "object", "required" : [ "attesting_indices", "data", "signature" ], "properties" : { diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/PendingConsolidation.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/PendingConsolidation.json new file mode 100644 index 00000000000..aa9b77f2895 --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/PendingConsolidation.json @@ -0,0 +1,19 @@ +{ + "title" : "PendingConsolidation", + "type" : "object", + "required" : [ "source_index", "target_index" ], + "properties" : { + "source_index" : { + "type" : "string", + "description" : "unsigned 64 bit integer", + "example" : "1", + "format" : "uint64" + }, + "target_index" : { + "type" : "string", + "description" : "unsigned 64 bit integer", + "example" : "1", + "format" : "uint64" + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/PendingDeposit.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/PendingDeposit.json new file mode 100644 index 00000000000..27ec4a2f0cf --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/PendingDeposit.json @@ -0,0 +1,43 @@ +{ + "title": "PendingDeposit", + "type": "object", + "required": [ + "pubkey", + "withdrawal_credentials", + "amount", + "signature", + "slot" + ], + "properties": { + "pubkey": { + "type": "string", + "pattern": "^0x[a-fA-F0-9]{2,}$", + "description": "Bytes48 hexadecimal", + "format": "bytes" + }, + "withdrawal_credentials": { + "type": "string", + "description": "Bytes32 hexadecimal", + "example": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", + "format": "byte" + }, + "amount": { + "type": "string", + "description": "unsigned 64 bit integer", + "example": "1", + "format": "uint64" + }, + "signature": { + "type": "string", + "pattern": "^0x[a-fA-F0-9]{2,}$", + "description": "SSZ hexadecimal", + "format": "bytes" + }, + "slot": { + "type": "string", + "description": "unsigned 64 bit integer", + "example": "1", + "format": "uint64" + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/PendingPartialWithdrawal.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/PendingPartialWithdrawal.json new file mode 100644 index 00000000000..8347212c107 --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/PendingPartialWithdrawal.json @@ -0,0 +1,25 @@ +{ + "title" : "PendingPartialWithdrawal", + "type" : "object", + "required" : [ "index", "amount", "withdrawable_epoch" ], + "properties" : { + "index" : { + "type" : "string", + "description" : "unsigned 64 bit integer", + "example" : "1", + "format" : "uint64" + }, + "amount" : { + "type" : "string", + "description" : "unsigned 64 bit integer", + "example" : "1", + "format" : "uint64" + }, + "withdrawable_epoch" : { + "type" : "string", + "description" : "unsigned 64 bit integer", + "example" : "1", + "format" : "uint64" + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/ProduceBlockV2Response.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/ProduceBlockV2Response.json deleted file mode 100644 index 578217383a2..00000000000 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/ProduceBlockV2Response.json +++ /dev/null @@ -1,28 +0,0 @@ -{ - "title" : "ProduceBlockV2Response", - "type" : "object", - "required" : [ "data", "version" ], - "properties" : { - "data" : { - "title" : "Block", - "type" : "object", - "oneOf" : [ { - "$ref" : "#/components/schemas/BeaconBlockPhase0" - }, { - "$ref" : "#/components/schemas/BeaconBlockAltair" - }, { - "$ref" : "#/components/schemas/BeaconBlockBellatrix" - }, { - "$ref" : "#/components/schemas/BeaconBlockCapella" - }, { - "$ref" : "#/components/schemas/BlockContentsDeneb" - }, { - "$ref" : "#/components/schemas/BlockContentsEip7594" - } ] - }, - "version" : { - "type" : "string", - "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "eip7594" ] - } - } -} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/ProduceBlockV3Response.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/ProduceBlockV3Response.json index 1b50ae401dc..eede3e02bbf 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/ProduceBlockV3Response.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/ProduceBlockV3Response.json @@ -5,7 +5,7 @@ "properties" : { "version" : { "type" : "string", - "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "eip7594" ] + "enum" : [ "phase0", "altair", "bellatrix", "capella", "deneb", "electra" ] }, "execution_payload_blinded" : { "type" : "boolean" @@ -32,20 +32,20 @@ }, { "$ref" : "#/components/schemas/BeaconBlockBellatrix" }, { - "$ref" : "#/components/schemas/BlindedBlockBellatrix" + "$ref" : "#/components/schemas/BlindedBeaconBlockBellatrix" }, { "$ref" : "#/components/schemas/BeaconBlockCapella" }, { - "$ref" : "#/components/schemas/BlindedBlockCapella" + "$ref" : "#/components/schemas/BlindedBeaconBlockCapella" }, { "$ref" : "#/components/schemas/BlockContentsDeneb" }, { - "$ref" : "#/components/schemas/BlindedBlockDeneb" + "$ref" : "#/components/schemas/BlindedBeaconBlockDeneb" }, { - "$ref" : "#/components/schemas/BlockContentsEip7594" + "$ref" : "#/components/schemas/BlockContentsElectra" }, { - "$ref" : "#/components/schemas/BlindedBlockEip7594" - } ] + "$ref" : "#/components/schemas/BlindedBeaconBlockElectra" + } ] } } } \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlindedBlockBellatrix.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedAggregateAndProofElectra.json similarity index 71% rename from data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlindedBlockBellatrix.json rename to data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedAggregateAndProofElectra.json index ede21a3fed2..8f574eab894 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlindedBlockBellatrix.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedAggregateAndProofElectra.json @@ -1,10 +1,10 @@ { - "title" : "SignedBlindedBlockBellatrix", + "title" : "SignedAggregateAndProofElectra", "type" : "object", "required" : [ "message", "signature" ], "properties" : { "message" : { - "$ref" : "#/components/schemas/BlindedBlockBellatrix" + "$ref" : "#/components/schemas/AggregateAndProofElectra" }, "signature" : { "type" : "string", diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlindedBlockCapella.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedAggregateAndProofPhase0.json similarity index 71% rename from data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlindedBlockCapella.json rename to data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedAggregateAndProofPhase0.json index ae08a6b409f..cf94a6e946f 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlindedBlockCapella.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedAggregateAndProofPhase0.json @@ -1,10 +1,10 @@ { - "title" : "SignedBlindedBlockCapella", + "title" : "SignedAggregateAndProofPhase0", "type" : "object", "required" : [ "message", "signature" ], "properties" : { "message" : { - "$ref" : "#/components/schemas/BlindedBlockCapella" + "$ref" : "#/components/schemas/AggregateAndProofPhase0" }, "signature" : { "type" : "string", diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBeaconBlockEip7594.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBeaconBlockElectra.json similarity index 73% rename from data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBeaconBlockEip7594.json rename to data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBeaconBlockElectra.json index 87cdc1176c2..f4bd8db4511 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBeaconBlockEip7594.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBeaconBlockElectra.json @@ -1,10 +1,10 @@ { - "title" : "SignedBeaconBlockEip7594", + "title" : "SignedBeaconBlockElectra", "type" : "object", "required" : [ "message", "signature" ], "properties" : { "message" : { - "$ref" : "#/components/schemas/BeaconBlockEip7594" + "$ref" : "#/components/schemas/BeaconBlockElectra" }, "signature" : { "type" : "string", diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlindedBeaconBlockBellatrix.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlindedBeaconBlockBellatrix.json new file mode 100644 index 00000000000..183df221bc2 --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlindedBeaconBlockBellatrix.json @@ -0,0 +1,16 @@ +{ + "title" : "SignedBlindedBeaconBlockBellatrix", + "type" : "object", + "required" : [ "message", "signature" ], + "properties" : { + "message" : { + "$ref" : "#/components/schemas/BlindedBeaconBlockBellatrix" + }, + "signature" : { + "type" : "string", + "pattern" : "^0x[a-fA-F0-9]{2,}$", + "description" : "SSZ hexadecimal", + "format" : "bytes" + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlindedBeaconBlockCapella.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlindedBeaconBlockCapella.json new file mode 100644 index 00000000000..c84a847408a --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlindedBeaconBlockCapella.json @@ -0,0 +1,16 @@ +{ + "title" : "SignedBlindedBeaconBlockCapella", + "type" : "object", + "required" : [ "message", "signature" ], + "properties" : { + "message" : { + "$ref" : "#/components/schemas/BlindedBeaconBlockCapella" + }, + "signature" : { + "type" : "string", + "pattern" : "^0x[a-fA-F0-9]{2,}$", + "description" : "SSZ hexadecimal", + "format" : "bytes" + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedAggregateAndProof.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlindedBeaconBlockDeneb.json similarity index 71% rename from data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedAggregateAndProof.json rename to data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlindedBeaconBlockDeneb.json index 6c9d7432d01..99f7ca57520 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedAggregateAndProof.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlindedBeaconBlockDeneb.json @@ -1,10 +1,10 @@ { - "title" : "SignedAggregateAndProof", + "title" : "SignedBlindedBeaconBlockDeneb", "type" : "object", "required" : [ "message", "signature" ], "properties" : { "message" : { - "$ref" : "#/components/schemas/AggregateAndProof" + "$ref" : "#/components/schemas/BlindedBeaconBlockDeneb" }, "signature" : { "type" : "string", diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlindedBeaconBlockElectra.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlindedBeaconBlockElectra.json new file mode 100644 index 00000000000..47bf0ef75ab --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlindedBeaconBlockElectra.json @@ -0,0 +1,16 @@ +{ + "title" : "SignedBlindedBeaconBlockElectra", + "type" : "object", + "required" : [ "message", "signature" ], + "properties" : { + "message" : { + "$ref" : "#/components/schemas/BlindedBeaconBlockElectra" + }, + "signature" : { + "type" : "string", + "pattern" : "^0x[a-fA-F0-9]{2,}$", + "description" : "SSZ hexadecimal", + "format" : "bytes" + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlindedBlockDeneb.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlindedBlockDeneb.json deleted file mode 100644 index ddc21f20966..00000000000 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlindedBlockDeneb.json +++ /dev/null @@ -1,16 +0,0 @@ -{ - "title" : "SignedBlindedBlockDeneb", - "type" : "object", - "required" : [ "message", "signature" ], - "properties" : { - "message" : { - "$ref" : "#/components/schemas/BlindedBlockDeneb" - }, - "signature" : { - "type" : "string", - "pattern" : "^0x[a-fA-F0-9]{2,}$", - "description" : "SSZ hexadecimal", - "format" : "bytes" - } - } -} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlindedBlockEip7594.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlindedBlockEip7594.json deleted file mode 100644 index 7cbe0739c80..00000000000 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlindedBlockEip7594.json +++ /dev/null @@ -1,16 +0,0 @@ -{ - "title" : "SignedBlindedBlockEip7594", - "type" : "object", - "required" : [ "message", "signature" ], - "properties" : { - "message" : { - "$ref" : "#/components/schemas/BlindedBlockEip7594" - }, - "signature" : { - "type" : "string", - "pattern" : "^0x[a-fA-F0-9]{2,}$", - "description" : "SSZ hexadecimal", - "format" : "bytes" - } - } -} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlockContentsEip7594.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlockContentsElectra.json similarity index 84% rename from data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlockContentsEip7594.json rename to data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlockContentsElectra.json index f4a9e559bda..c1e294612a3 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlockContentsEip7594.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/SignedBlockContentsElectra.json @@ -1,10 +1,10 @@ { - "title" : "SignedBlockContentsEip7594", + "title" : "SignedBlockContentsElectra", "type" : "object", "required" : [ "signed_block", "kzg_proofs", "blobs" ], "properties" : { "signed_block" : { - "$ref" : "#/components/schemas/SignedBeaconBlockEip7594" + "$ref" : "#/components/schemas/SignedBeaconBlockElectra" }, "kzg_proofs" : { "type" : "array", diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/Slot.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/Slot.json new file mode 100644 index 00000000000..dd7873f8de2 --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/Slot.json @@ -0,0 +1,13 @@ +{ + "title" : "Slot", + "type" : "object", + "required" : [ "data" ], + "properties" : { + "data" : { + "type" : "string", + "description" : "unsigned 64 bit integer", + "example" : "1", + "format" : "uint64" + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/WithdrawalRequest.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/WithdrawalRequest.json new file mode 100644 index 00000000000..41b37f68341 --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/beacon/schema/WithdrawalRequest.json @@ -0,0 +1,25 @@ +{ + "title" : "WithdrawalRequest", + "type" : "object", + "required" : [ "source_address", "validator_pubkey", "amount" ], + "properties" : { + "source_address" : { + "type" : "string", + "pattern" : "^0x[a-fA-F0-9]{2,}$", + "description" : "SSZ hexadecimal", + "format" : "bytes" + }, + "validator_pubkey" : { + "type" : "string", + "pattern" : "^0x[a-fA-F0-9]{2,}$", + "description" : "Bytes48 hexadecimal", + "format" : "bytes" + }, + "amount" : { + "type" : "string", + "description" : "unsigned 64 bit integer", + "example" : "1", + "format" : "uint64" + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlindedBlockBELLATRIX.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlindedBlockBELLATRIX.json index bd6629653ea..64339eddd8a 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlindedBlockBELLATRIX.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlindedBlockBELLATRIX.json @@ -1,8 +1,8 @@ { "version": "bellatrix", "execution_payload_blinded": true, - "execution_payload_value": "82868883583976095934942218774802763456161238965616818389917973339530742580660", - "consensus_block_value": "81744492456258793280520536666094060462558404863190111969507816784424614128915", + "execution_payload_value": "73092283800700793286468708950267523415056945357667839430375913972420161943176", + "consensus_block_value": "110698795530499877737280254001850075711411497370695181962707136225646562110", "data": { "slot": "1", "proposer_index": "4666673844721362956", @@ -44,174 +44,174 @@ { "attestation_1": { "attesting_indices": [ - "4585702132744102314", "4590659586689121994", - "4589007099177470570" + "4589007099177470570", + "4580744678799082634" ], "data": { - "slot": "4580744678799082634", - "index": "4579092195582398506", - "beacon_block_root": "0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c", + "slot": "4579092195582398506", + "index": "4584049649527418186", + "beacon_block_root": "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06", "source": { - "epoch": "533461240", - "root": "0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565" + "epoch": "538655350", + "root": "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0" }, "target": { - "epoch": "538462976", - "root": "0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650" + "epoch": "539040099", + "root": "0xda533c406bf3482d8e6e992e756be34172a8c47fc1cc0018350bfe98c946deda" } }, - "signature": "0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc" + "signature": "0x8bfc6e1a1c76bdafb4d491ce02a35effde6d7362eb32c03f119c47c12fb2b49e7656bbd4702ba02560fd7fe117f2c74e02142ce46176ebf269d5b34a48a65525e35db6cc446965e86e22e9d8adf5abe92315690b6de5f4591769487539fed52a" }, "attestation_2": { "attesting_indices": [ - "4585702132744102314", "4590659586689121994", - "4589007099177470570" + "4589007099177470570", + "4580744678799082634" ], "data": { - "slot": "4620404293179370891", - "index": "4618751809962686763", - "beacon_block_root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b", + "slot": "4618751809962686763", + "index": "4623709263907706443", + "beacon_block_root": "0x27d82440eb21c640637a36dcc38e35768bb4c0c79aefa300ec0f0cba32cabb05", "source": { - "epoch": "538078227", - "root": "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb" + "epoch": "537116355", + "root": "0x999e0140abe701de220ca2e0b9c3b044b1c6ba33e0a3985dfe16a16b510f0846" }, "target": { - "epoch": "536923980", - "root": "0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5" + "epoch": "537501104", + "root": "0x735c0d406b5043543786d38912b287aaa4c0bc0f731247e9a3141adb9c4d9930" } }, - "signature": "0xa32991816eb9f297553b4732309a4cdba7b33287264611715b0ab3319bca19e581da6e2659912a4e0e94aafc01c488e30ffc96ed14e2a726b9d3c618405ee0bf54bf6ae7f2097465cb27ab8132ec24eb93d3c9159475304082f7f0e452b93b65" + "signature": "0xb2213ef588828a7c18cdc781d0ed2516fd3e11de625f191aae7ae4be8b1ad2cc217728c65a500aedea276d345f09fd3212b009568a6549f5f40ead6d7ec4d0f3f329c00a1b4bca59068ee0555c94aec91bebc18365ca0b2d6692557b4b0c4267" } } ], "attestations": [ { - "aggregation_bits": "0xfa79cdb89d0d51c5cdd001b7425c6d726750a9d5f89ade6ed9890ce3a706140c399a5e10c90a819094b65322dac7501f7c75471e69d4567358d8ca75f7c1b3133ebecf006b369a1f36efc5f2b706d5922ff98c58a1825a53a864376658f816600cf021cea843d4396502bb9c74d1510afe26036f89f783b4f5c7bacb6649c46f217a6af835f312d6fa253d2bbc83c07993f4f10de2ed2d952689379dbe4f794c1a1055a6b364d68e038deec9667f576b3b9eca5fcadd6298f181e1edb876efc3d0975ae14ae9a0ad2f1836d4c3f1080a96d8ab7c43b34bb2eda895ff66be698b363cfa4be33da3ec94a1a7a90672fd12c4a59916bb937e78476e4f08e4f4031001", + "aggregation_bits": "0x907c35a14e5afee2fffc1703230dbe923ea49766c5af5277f432d84b3c2323d8a5a8dc131a8cbb3c69aad1172537e0826b0f4ee1639f650b91bbeab0eaf337f9472742d6f8443c1eb7c62f5f876f5f154689fb6548800c39b12a8d1f2585230fc372dfe5bc46a4c4358fb1ebb547796df094800159f2c9d982d61666d8a188e3b665900ce8f564188f269b5265d345893085d41f43a030337dedcafbef1245fb43c6c44b9891c2ff5f157069435c52c7fc457d5ec218f5d2ca50e69cae88c863b56e53213d92d7f6357a56344a4c2b80b58249b494d992f3c78d7440fe6b69d32ff3c1c29dbea8d0aebc1347743dac65bb66529f27dcf476baa3774d1e5c69dd01", "data": { - "slot": "4605531939934246443", - "index": "4610489389584298827", - "beacon_block_root": "0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b", + "slot": "4608836906367614699", + "index": "4547695001580498185", + "beacon_block_root": "0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2", "source": { - "epoch": "529421377", - "root": "0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2" - }, - "target": { "epoch": "529806126", "root": "0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd" + }, + "target": { + "epoch": "528651879", + "root": "0xe24dff3e29e762b4488e615619483884c44b8f4b37239b5cdc4a3bd7d9b48c1d" } }, - "signature": "0x8f8d16b39e14569aab1b712e5c19ed51afe3600a6b017e8ab432f43a02ee720a733c33ef087d2f3653a9701e8d8a836301655b9195c0373b775c88ba1368e5d55354a70a3096bd26dee29dddbe7a4820e2b1653e84122beacbc01af7d93e6bdc" + "signature": "0x913ce44a60f20df0261b53d8031d13f3a8d51cf53ba5eb65735ae960623c48acd56286b31ecd74cdaf51f66b2b2331fa0e907e8cb9d4dde513ca29cc34ee9925301bb541055a8daef33bb3e1fb8442a4a033f93f86933bc35fd2ce34a569a6ef" }, { - "aggregation_bits": "0x4ac567b296efbf7cf3209e87096a7a1a50fd523400113f917f6584a5a306f06b2d8da9ae858d47ff2594010089838efe41f19a78d9aae27c2ffde26f278b8681db9d091eb72e7cab3e449dfccd46a270693e1f88f197324e57bfd45573315cf9fb60d770937b32f7c0c6ce1581ec51e6b60f71acfde304dc917f2e0aa7872038b7d9140d15f7927c23a0490a74c2b0aca2773fed9217067e4444f9ca93874e4ff8407111c3efdb138b97c6d4957b6a70ec1debb283e3d0eb1cfef068adcffbf057d20fdc339eae03f0fa2613abdde8158a7fc40c3cfd1117eb6f8c4ae21d6b2ab4b57ae9a8653a34451aee6418c0c3609dc937293f5f5b346a7ab1a0d144185101", + "aggregation_bits": "0xae44a59e9b57b7141da75dba9d385b795ba84317f41948621bf98a34f92168838b72a9678bc58de000cf466104613975fb1490c591f0ee9055cce4aaa2ff0eb5a26c8b9e20b6a386d9e9f7964a3ebb957e3c6b0124271c279496235101a29fbf18ac7be6749a8b1f230bb5131e97b28c06683ca9a6cb6129b2a25b4f539f7f5e41cc1997c5b4a57d51dbce5ad4ab746a403e5270c785b76d47475c0ee6c309e33dad08193c3f8e40e9414096276bfb5708c84359dd51eb54ca67dd7a6eb5645801fb83811b4c11eb5b240e9d0bc0847ae7abfa235c7d6cc5f7eca53bce62b1b987b7c11ef54592399882d7983eb3c6a58ff636f52b4007afbc0d66bfe9d9276a01", "data": { - "slot": "4544390030852162633", - "index": "4542737547635478505", - "beacon_block_root": "0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd", + "slot": "4532822644040406441", + "index": "4537780097985426121", + "beacon_block_root": "0x0890f33e697e213e331430adc059611ed0518d6fa4b4ecd0384dc2678e76fb32", "source": { - "epoch": "527690007", - "root": "0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8" + "epoch": "527112883", + "root": "0x7a56d03e29445ddbf2a59bb1b68edcecf66387dbea68e12d4a545719acbb4773" }, "target": { - "epoch": "528074756", - "root": "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8" + "epoch": "527497632", + "root": "0x5414dc3ee9ac9e510720cd5a0e7db352e95d89b77dd78fb9ef51d088f8f9d85d" } }, - "signature": "0x90309dd491ae6ed51917dc305a3d4ae68d0a0d4792c7eb59c193bd03605bd94e61cab37502de0ad3e6162bc02427bba80a798b3670d5de82a854094016cc298b265371345c0e3ac49fd44bbb9ba0d4fcea0c1a80cecb60e93921d907e8c48120" + "signature": "0xa3f0d1902ab93bc710c2af70da7699b79480ee062fc8add2cc1c6ddce56d54706ef91f581ec0f94cee95fc4be146005f174e2e77733d71ef59e53a12eb852e09e4334af2c27120e506ebab9c04e2b2f99045d40bd1372618173cf6df4ad21f86" }, { - "aggregation_bits": "0xe8c9759f0840f980ae956b15fc383d992e7d4420d12ba5bf32f669f446ac6fa388e20e5ce96e9266dd98840179d2cde3cabd9a8bafab5dec9c2e89f7f78c989e690548603984803b80c82d7b76443194576a1ce49da5cfe56f56e83b745fb01b5f18ccc86d88f5a22d927e64ff0b8e880893abcddec45b268531c4a0697537dae643a24b1a36432f37d42962553bd39af71f37e0429b81470c11316aa39db074aa3f1df4124e7cb203debed60b885ffb9b27e46a1434e81bbd56566632d0729c0822ac415cbb67f25973667d88e58df9c2f058a0ae7f118c98cc448453b6fbe590363bd17ed62c2f808df61f2a9e593235eeb56db74b9dd15980189a5271468301", + "aggregation_bits": "0xe2e8a45105213f0f211443b26e3a23df7f899eb9b3ddd40b5f51905f90441f98eaa0d2b9ed7dddf5b4089188c41388cb5702236640399f914245bc085459f40d628a99fd663a4429e9b46e61dc8beb6ae3757aaeffc6db49c374cc93d1e663989d84fa7b4aa499a8b5d34ec5fea94bcdb33af829c6260d2a88a6be97e89baa6215949a4ef124436f685d4ee683c0c27f0ac7aefd77f4b305842d1cf2d08d9b7f4e501a38b81014fcbcec2156d5abbd1010afe4a596164e4659c6dd794639199119b4a3f2ec4f3b4d6a084bdedf66dfdcc1be1c522d9bf72663b7cc1a8746c3737e20ef7ee1b7863f89ab600a35772b4eede0424b8b69bcd27a6b354252a0147701", "data": { - "slot": "4529517677607038185", - "index": "4574134745932346122", - "beacon_block_root": "0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947", + "slot": "4575787224854062954", + "index": "4567524808770642314", + "beacon_block_root": "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", "source": { - "epoch": "532884117", - "root": "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31" + "epoch": "532114619", + "root": "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c" }, "target": { - "epoch": "531729870", - "root": "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672" + "epoch": "530960372", + "root": "0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c" } }, - "signature": "0x8c40f51a99fce6ebb9a4db5e80d715fff319e7ae523e46afb5d03c000d427e23c7a39e77e2af53851706283c8ca91d680997cb459386fbdff52c4d0ecf498e173717a838a792b210bdffaf476538628584a133899bf30dd5ce7056463b8cd683" + "signature": "0x8166b2ed13e982e6b9f05d30f42681b826099135a533d2614ef5f4f59811714245db0e1821a644859559f97ec1e614bf08b2edb294fa2edc1527f46596399534af23c98613e1b74c01871bf1dd2af9618bc0ba23ddfce8026b897cdbba8c1bce" } ], "deposits": [ { "proof": [ - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c" + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587" ], "data": { - "pubkey": "0xb1f8f6e731dbf6b4e3265fb857c7190adbfc7e6cc95ce2e8bda72be8b6ea3459f862310a2484c3b0ee33b30920f18c1d", - "withdrawal_credentials": "0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c", + "pubkey": "0x83b9036200e9e907c86ede7f98b23297389e8af19d403466e00f1946867db735d8620019e28aa42739f49c65b78a2806", + "withdrawal_credentials": "0x49452e3f298a688d9e7627fb7c01941b923397bb84dd548b6e411f9506aed1c7", "amount": "32000000000", - "signature": "0xb594382214f5bdd375de66c45e1c61a526c7b73fb166c72433bbd9c2a7ad6881244e61cc6427e0206a50b762a129d8830e8708c55761d61ce9e3b19c1bee13bc55daa13bdb07118efdbf57a588b8a64e6392d14f935e53b68933e3355b35acdb" + "signature": "0x86e6ad7c26352727d310e10f7c745a0725636f63013f70c5a442489946dcd1c85665cd3539fe9d8fe6f6b49b5b7f13a50af2a2b98a7d385417c98e5d74273e67cc3bd8f8544dc3697124c8176835745659182eab37f3ebe0a881ff4e7f62bc31" } } ], "voluntary_exits": [ { "message": { - "epoch": "4562567354825622634", - "validator_index": "4564219838042306762" + "epoch": "4555957421958886121", + "validator_index": "4557609905175570249" }, - "signature": "0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e" + "signature": "0xaacffaf60c8253477ecad70de8589f2ef7670d0b0dc446d4baac3b465a901d3e64bb6d2c3d8bdb58aed45ac30466261416d152d5ae242204201bf6decfddde697ae0c5d44cf31ca3d43aa18f2799461fc1ee14dbf905b1e31f242fd31c083c5a" } ], "sync_aggregate": { "sync_committee_bits": "0x01000000", - "sync_committee_signature": "0x919ee45cc18456f6e85da6bc21c2e40f44f9a887932c73ea9ad354f88e56d4ec0a8c396ed143082c8e31d697b877a2a215d2966d91c7beb156bf7ab5777e210012f70dcd5f7657808a82cba51e194be994f917150ebdb9e5c57476f1edb47206" + "sync_committee_signature": "0x86e947b46923b26125a7dab3240481ddc1b910c1e6393b90df6e2de3809b8b35e450dc8264ecedd8f6bfc736e7114d841428b2469441d2d1d501015eb99e0d7090f11a1185b566dc42f94b79d0a08b22718a39b57e912a304419361108434ec8" }, "execution_payload_header": { - "parent_hash": "0xf8eb5a3ea82ccf3c1be1ac153e3f77f273a07343291711b9de6b9dbebc4c9b49", - "fee_recipient": "0xbf886c3ec849316e3b187793c3a4398b6097768d", - "state_root": "0xd2a9663e689510b3305bdebe972d4e58669a751fbc85bf448269162e078b2c34", - "receipts_root": "0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9", - "logs_bloom": "0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d078748f9069c96e9d6a2801cf607000a52447e46e1bef4e056ee30d4bd3517aaf7bf65ba04dd28c3a4a14b8dc72a300f051722a6814fa3931d90a82d23285d4c1127b6c67bbc4f8682ddbf9b31eb3114c26dccc5330109d6f17799339c2d7ed7e4e3a7de5d515106aaec7be6d78be3e21806d6d30c39b77c75dcf354b63033fb200b3b9dc023d948278f0956c0ee99323da0162f2a84b6a95749d2fa1d4e089af416d412ccd992683f7e41f7b496ca04f9f463806e3643d1c07f39d2a65f84e97b7dfaafac740d1e03f30923a4270fcf651ad2ca3737859a524e86e02229a55abd1a7", - "prev_randao": "0x0c0d553e4878ae811024144112c88bbf79a372d5dfdf39730cede08696ad52d4", - "block_number": "4489858063226749928", - "gas_limit": "4481595642848361992", - "gas_used": "4479943159631677864", - "timestamp": "4484900609281730248", - "extra_data": "0x6bb2373e68f20adada72181a3474f2c098b26daf6fcb0516f0723270da91e789", - "base_fee_per_gas": "91973405088222260025272995045243630915786868313949746451634391325697029602367", - "block_hash": "0xde78143e27b846779904841e2aa96d8fbec4671bb57ffa72037ac721f8d633ca", - "transactions_root": "0xa415263e48d5a8a8ba3b4e9caf0e3028abbb6a65922580447af6fcc869b40d2a" + "parent_hash": "0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874", + "fee_recipient": "0x0c0d553e4878ae811024144112c88bbf79a372d5", + "state_root": "0x1f2e4f3ee8c38dc605677b6ce650a08c7fa6716795a8622d396e244f710e0a5f", + "receipts_root": "0x7ed3313e083eea1ecfb57f4508fd068e9fb56c4125942ed01ef47538b5f29e14", + "logs_bloom": "0x91f42b3ea889c963c4f8e670db851b5ba5b86bd3dc5c578a4c75b9008f53569fed0e82445821ecdf1e306d211dc4b3e042d5813f11ce16132211c523a92d723ffdaaf2175eaa77a1937f2e9f27b5e5b0f1bd3b77dbc94c7215fa1065d6066ea59bf2b95b8fe2ef820d9cf6a10c93f04f98db135751e1d8972d2427113953334f5634914e66e00af04d50d4de255bb0540ed3627a6f64073f81a28f777cba3a4ff145230e8103befc67e3ae2e8c72518ea18fa75495daac19c0f5c5094c84853de2b6ba4e2275c8a941cfb1a29f5a24ba911dd636080b0859abaa198dda14a860d4d29306b038ddd219c708ed837583079254b70c7095ac70984894735b79f7f9", + "prev_randao": "0x58913d3ec8a62b95e52fb1ee60ebddf392af6e1db902dd5bc3f1eea7003130ff", + "block_number": "4483248126065046120", + "gas_limit": "4474985709981625479", + "gas_used": "4473333226764941351", + "timestamp": "4478290672120026440", + "extra_data": "0xb736203ee72088edaf7eb5c7839744f5b1be69f748eea8fea77740914415c5b4", + "base_fee_per_gas": "81744492456258793280520536666094060462558404863190111969507816784424614128915", + "block_hash": "0xc7dab83ea972daeec7b1385f04b22e210f708323c38b84160159653a163f259e", + "transactions_root": "0x8e77ca3ec98f3c20e7e802dd8917f1b9fc66866da0310ae878d59ae1871cfffd" } } } diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlindedBlockCAPELLA.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlindedBlockCAPELLA.json index b558556cb00..ffb467d49c7 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlindedBlockCAPELLA.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlindedBlockCAPELLA.json @@ -1,8 +1,8 @@ { "version": "capella", "execution_payload_blinded": true, - "execution_payload_value": "88677020700304810645440566841637878262529476175194619039964273754320504476000", - "consensus_block_value": "97329229382821934560616955555843179541672300274000903186674420273110117157099", + "execution_payload_value": "7495532986413849817267215758148158394038672421876771029699707700121804844683", + "consensus_block_value": "16147741642076749126162712127389114255573229005697131290860120949861914404374", "data": { "slot": "1", "proposer_index": "4666673844721362956", @@ -44,304 +44,304 @@ { "attestation_1": { "attesting_indices": [ - "4585702132744102314", "4590659586689121994", - "4589007099177470570" + "4589007099177470570", + "4580744678799082634" ], "data": { - "slot": "4580744678799082634", - "index": "4579092195582398506", - "beacon_block_root": "0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c", + "slot": "4579092195582398506", + "index": "4584049649527418186", + "beacon_block_root": "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06", "source": { - "epoch": "533461240", - "root": "0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565" + "epoch": "538655350", + "root": "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0" }, "target": { - "epoch": "538462976", - "root": "0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650" + "epoch": "539040099", + "root": "0xda533c406bf3482d8e6e992e756be34172a8c47fc1cc0018350bfe98c946deda" } }, - "signature": "0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc" + "signature": "0x8bfc6e1a1c76bdafb4d491ce02a35effde6d7362eb32c03f119c47c12fb2b49e7656bbd4702ba02560fd7fe117f2c74e02142ce46176ebf269d5b34a48a65525e35db6cc446965e86e22e9d8adf5abe92315690b6de5f4591769487539fed52a" }, "attestation_2": { "attesting_indices": [ - "4585702132744102314", "4590659586689121994", - "4589007099177470570" + "4589007099177470570", + "4580744678799082634" ], "data": { - "slot": "4620404293179370891", - "index": "4618751809962686763", - "beacon_block_root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b", + "slot": "4618751809962686763", + "index": "4623709263907706443", + "beacon_block_root": "0x27d82440eb21c640637a36dcc38e35768bb4c0c79aefa300ec0f0cba32cabb05", "source": { - "epoch": "538078227", - "root": "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb" + "epoch": "537116355", + "root": "0x999e0140abe701de220ca2e0b9c3b044b1c6ba33e0a3985dfe16a16b510f0846" }, "target": { - "epoch": "536923980", - "root": "0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5" + "epoch": "537501104", + "root": "0x735c0d406b5043543786d38912b287aaa4c0bc0f731247e9a3141adb9c4d9930" } }, - "signature": "0xa32991816eb9f297553b4732309a4cdba7b33287264611715b0ab3319bca19e581da6e2659912a4e0e94aafc01c488e30ffc96ed14e2a726b9d3c618405ee0bf54bf6ae7f2097465cb27ab8132ec24eb93d3c9159475304082f7f0e452b93b65" + "signature": "0xb2213ef588828a7c18cdc781d0ed2516fd3e11de625f191aae7ae4be8b1ad2cc217728c65a500aedea276d345f09fd3212b009568a6549f5f40ead6d7ec4d0f3f329c00a1b4bca59068ee0555c94aec91bebc18365ca0b2d6692557b4b0c4267" } } ], "attestations": [ { - "aggregation_bits": "0xfa79cdb89d0d51c5cdd001b7425c6d726750a9d5f89ade6ed9890ce3a706140c399a5e10c90a819094b65322dac7501f7c75471e69d4567358d8ca75f7c1b3133ebecf006b369a1f36efc5f2b706d5922ff98c58a1825a53a864376658f816600cf021cea843d4396502bb9c74d1510afe26036f89f783b4f5c7bacb6649c46f217a6af835f312d6fa253d2bbc83c07993f4f10de2ed2d952689379dbe4f794c1a1055a6b364d68e038deec9667f576b3b9eca5fcadd6298f181e1edb876efc3d0975ae14ae9a0ad2f1836d4c3f1080a96d8ab7c43b34bb2eda895ff66be698b363cfa4be33da3ec94a1a7a90672fd12c4a59916bb937e78476e4f08e4f4031001", + "aggregation_bits": "0x907c35a14e5afee2fffc1703230dbe923ea49766c5af5277f432d84b3c2323d8a5a8dc131a8cbb3c69aad1172537e0826b0f4ee1639f650b91bbeab0eaf337f9472742d6f8443c1eb7c62f5f876f5f154689fb6548800c39b12a8d1f2585230fc372dfe5bc46a4c4358fb1ebb547796df094800159f2c9d982d61666d8a188e3b665900ce8f564188f269b5265d345893085d41f43a030337dedcafbef1245fb43c6c44b9891c2ff5f157069435c52c7fc457d5ec218f5d2ca50e69cae88c863b56e53213d92d7f6357a56344a4c2b80b58249b494d992f3c78d7440fe6b69d32ff3c1c29dbea8d0aebc1347743dac65bb66529f27dcf476baa3774d1e5c69dd01", "data": { - "slot": "4605531939934246443", - "index": "4610489389584298827", - "beacon_block_root": "0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b", + "slot": "4608836906367614699", + "index": "4547695001580498185", + "beacon_block_root": "0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2", "source": { - "epoch": "529421377", - "root": "0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2" - }, - "target": { "epoch": "529806126", "root": "0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd" + }, + "target": { + "epoch": "528651879", + "root": "0xe24dff3e29e762b4488e615619483884c44b8f4b37239b5cdc4a3bd7d9b48c1d" } }, - "signature": "0x8f8d16b39e14569aab1b712e5c19ed51afe3600a6b017e8ab432f43a02ee720a733c33ef087d2f3653a9701e8d8a836301655b9195c0373b775c88ba1368e5d55354a70a3096bd26dee29dddbe7a4820e2b1653e84122beacbc01af7d93e6bdc" + "signature": "0x913ce44a60f20df0261b53d8031d13f3a8d51cf53ba5eb65735ae960623c48acd56286b31ecd74cdaf51f66b2b2331fa0e907e8cb9d4dde513ca29cc34ee9925301bb541055a8daef33bb3e1fb8442a4a033f93f86933bc35fd2ce34a569a6ef" }, { - "aggregation_bits": "0x4ac567b296efbf7cf3209e87096a7a1a50fd523400113f917f6584a5a306f06b2d8da9ae858d47ff2594010089838efe41f19a78d9aae27c2ffde26f278b8681db9d091eb72e7cab3e449dfccd46a270693e1f88f197324e57bfd45573315cf9fb60d770937b32f7c0c6ce1581ec51e6b60f71acfde304dc917f2e0aa7872038b7d9140d15f7927c23a0490a74c2b0aca2773fed9217067e4444f9ca93874e4ff8407111c3efdb138b97c6d4957b6a70ec1debb283e3d0eb1cfef068adcffbf057d20fdc339eae03f0fa2613abdde8158a7fc40c3cfd1117eb6f8c4ae21d6b2ab4b57ae9a8653a34451aee6418c0c3609dc937293f5f5b346a7ab1a0d144185101", + "aggregation_bits": "0xae44a59e9b57b7141da75dba9d385b795ba84317f41948621bf98a34f92168838b72a9678bc58de000cf466104613975fb1490c591f0ee9055cce4aaa2ff0eb5a26c8b9e20b6a386d9e9f7964a3ebb957e3c6b0124271c279496235101a29fbf18ac7be6749a8b1f230bb5131e97b28c06683ca9a6cb6129b2a25b4f539f7f5e41cc1997c5b4a57d51dbce5ad4ab746a403e5270c785b76d47475c0ee6c309e33dad08193c3f8e40e9414096276bfb5708c84359dd51eb54ca67dd7a6eb5645801fb83811b4c11eb5b240e9d0bc0847ae7abfa235c7d6cc5f7eca53bce62b1b987b7c11ef54592399882d7983eb3c6a58ff636f52b4007afbc0d66bfe9d9276a01", "data": { - "slot": "4544390030852162633", - "index": "4542737547635478505", - "beacon_block_root": "0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd", + "slot": "4532822644040406441", + "index": "4537780097985426121", + "beacon_block_root": "0x0890f33e697e213e331430adc059611ed0518d6fa4b4ecd0384dc2678e76fb32", "source": { - "epoch": "527690007", - "root": "0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8" + "epoch": "527112883", + "root": "0x7a56d03e29445ddbf2a59bb1b68edcecf66387dbea68e12d4a545719acbb4773" }, "target": { - "epoch": "528074756", - "root": "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8" + "epoch": "527497632", + "root": "0x5414dc3ee9ac9e510720cd5a0e7db352e95d89b77dd78fb9ef51d088f8f9d85d" } }, - "signature": "0x90309dd491ae6ed51917dc305a3d4ae68d0a0d4792c7eb59c193bd03605bd94e61cab37502de0ad3e6162bc02427bba80a798b3670d5de82a854094016cc298b265371345c0e3ac49fd44bbb9ba0d4fcea0c1a80cecb60e93921d907e8c48120" + "signature": "0xa3f0d1902ab93bc710c2af70da7699b79480ee062fc8add2cc1c6ddce56d54706ef91f581ec0f94cee95fc4be146005f174e2e77733d71ef59e53a12eb852e09e4334af2c27120e506ebab9c04e2b2f99045d40bd1372618173cf6df4ad21f86" }, { - "aggregation_bits": "0xe8c9759f0840f980ae956b15fc383d992e7d4420d12ba5bf32f669f446ac6fa388e20e5ce96e9266dd98840179d2cde3cabd9a8bafab5dec9c2e89f7f78c989e690548603984803b80c82d7b76443194576a1ce49da5cfe56f56e83b745fb01b5f18ccc86d88f5a22d927e64ff0b8e880893abcddec45b268531c4a0697537dae643a24b1a36432f37d42962553bd39af71f37e0429b81470c11316aa39db074aa3f1df4124e7cb203debed60b885ffb9b27e46a1434e81bbd56566632d0729c0822ac415cbb67f25973667d88e58df9c2f058a0ae7f118c98cc448453b6fbe590363bd17ed62c2f808df61f2a9e593235eeb56db74b9dd15980189a5271468301", + "aggregation_bits": "0xe2e8a45105213f0f211443b26e3a23df7f899eb9b3ddd40b5f51905f90441f98eaa0d2b9ed7dddf5b4089188c41388cb5702236640399f914245bc085459f40d628a99fd663a4429e9b46e61dc8beb6ae3757aaeffc6db49c374cc93d1e663989d84fa7b4aa499a8b5d34ec5fea94bcdb33af829c6260d2a88a6be97e89baa6215949a4ef124436f685d4ee683c0c27f0ac7aefd77f4b305842d1cf2d08d9b7f4e501a38b81014fcbcec2156d5abbd1010afe4a596164e4659c6dd794639199119b4a3f2ec4f3b4d6a084bdedf66dfdcc1be1c522d9bf72663b7cc1a8746c3737e20ef7ee1b7863f89ab600a35772b4eede0424b8b69bcd27a6b354252a0147701", "data": { - "slot": "4529517677607038185", - "index": "4574134745932346122", - "beacon_block_root": "0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947", + "slot": "4575787224854062954", + "index": "4567524808770642314", + "beacon_block_root": "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", "source": { - "epoch": "532884117", - "root": "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31" + "epoch": "532114619", + "root": "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c" }, "target": { - "epoch": "531729870", - "root": "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672" + "epoch": "530960372", + "root": "0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c" } }, - "signature": "0x8c40f51a99fce6ebb9a4db5e80d715fff319e7ae523e46afb5d03c000d427e23c7a39e77e2af53851706283c8ca91d680997cb459386fbdff52c4d0ecf498e173717a838a792b210bdffaf476538628584a133899bf30dd5ce7056463b8cd683" + "signature": "0x8166b2ed13e982e6b9f05d30f42681b826099135a533d2614ef5f4f59811714245db0e1821a644859559f97ec1e614bf08b2edb294fa2edc1527f46596399534af23c98613e1b74c01871bf1dd2af9618bc0ba23ddfce8026b897cdbba8c1bce" } ], "deposits": [ { "proof": [ - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c" + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587" ], "data": { - "pubkey": "0xb1f8f6e731dbf6b4e3265fb857c7190adbfc7e6cc95ce2e8bda72be8b6ea3459f862310a2484c3b0ee33b30920f18c1d", - "withdrawal_credentials": "0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c", + "pubkey": "0x83b9036200e9e907c86ede7f98b23297389e8af19d403466e00f1946867db735d8620019e28aa42739f49c65b78a2806", + "withdrawal_credentials": "0x49452e3f298a688d9e7627fb7c01941b923397bb84dd548b6e411f9506aed1c7", "amount": "32000000000", - "signature": "0xb594382214f5bdd375de66c45e1c61a526c7b73fb166c72433bbd9c2a7ad6881244e61cc6427e0206a50b762a129d8830e8708c55761d61ce9e3b19c1bee13bc55daa13bdb07118efdbf57a588b8a64e6392d14f935e53b68933e3355b35acdb" + "signature": "0x86e6ad7c26352727d310e10f7c745a0725636f63013f70c5a442489946dcd1c85665cd3539fe9d8fe6f6b49b5b7f13a50af2a2b98a7d385417c98e5d74273e67cc3bd8f8544dc3697124c8176835745659182eab37f3ebe0a881ff4e7f62bc31" } } ], "voluntary_exits": [ { "message": { - "epoch": "4562567354825622634", - "validator_index": "4564219838042306762" + "epoch": "4555957421958886121", + "validator_index": "4557609905175570249" }, - "signature": "0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e" + "signature": "0xaacffaf60c8253477ecad70de8589f2ef7670d0b0dc446d4baac3b465a901d3e64bb6d2c3d8bdb58aed45ac30466261416d152d5ae242204201bf6decfddde697ae0c5d44cf31ca3d43aa18f2799461fc1ee14dbf905b1e31f242fd31c083c5a" } ], "sync_aggregate": { "sync_committee_bits": "0x01000000", - "sync_committee_signature": "0x919ee45cc18456f6e85da6bc21c2e40f44f9a887932c73ea9ad354f88e56d4ec0a8c396ed143082c8e31d697b877a2a215d2966d91c7beb156bf7ab5777e210012f70dcd5f7657808a82cba51e194be994f917150ebdb9e5c57476f1edb47206" + "sync_committee_signature": "0x86e947b46923b26125a7dab3240481ddc1b910c1e6393b90df6e2de3809b8b35e450dc8264ecedd8f6bfc736e7114d841428b2469441d2d1d501015eb99e0d7090f11a1185b566dc42f94b79d0a08b22718a39b57e912a304419361108434ec8" }, "execution_payload_header": { - "parent_hash": "0xf8eb5a3ea82ccf3c1be1ac153e3f77f273a07343291711b9de6b9dbebc4c9b49", - "fee_recipient": "0xbf886c3ec849316e3b187793c3a4398b6097768d", - "state_root": "0xd2a9663e689510b3305bdebe972d4e58669a751fbc85bf448269162e078b2c34", - "receipts_root": "0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9", - "logs_bloom": "0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d078748f9069c96e9d6a2801cf607000a52447e46e1bef4e056ee30d4bd3517aaf7bf65ba04dd28c3a4a14b8dc72a300f051722a6814fa3931d90a82d23285d4c1127b6c67bbc4f8682ddbf9b31eb3114c26dccc5330109d6f17799339c2d7ed7e4e3a7de5d515106aaec7be6d78be3e21806d6d30c39b77c75dcf354b63033fb200b3b9dc023d948278f0956c0ee99323da0162f2a84b6a95749d2fa1d4e089af416d412ccd992683f7e41f7b496ca04f9f463806e3643d1c07f39d2a65f84e97b7dfaafac740d1e03f30923a4270fcf651ad2ca3737859a524e86e02229a55abd1a7", - "prev_randao": "0x0c0d553e4878ae811024144112c88bbf79a372d5dfdf39730cede08696ad52d4", - "block_number": "4489858063226749928", - "gas_limit": "4481595642848361992", - "gas_used": "4479943159631677864", - "timestamp": "4484900609281730248", - "extra_data": "0x6bb2373e68f20adada72181a3474f2c098b26daf6fcb0516f0723270da91e789", - "base_fee_per_gas": "91973405088222260025272995045243630915786868313949746451634391325697029602367", - "block_hash": "0xde78143e27b846779904841e2aa96d8fbec4671bb57ffa72037ac721f8d633ca", - "transactions_root": "0xa415263e48d5a8a8ba3b4e9caf0e3028abbb6a65922580447af6fcc869b40d2a", - "withdrawals_root": "0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be" + "parent_hash": "0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874", + "fee_recipient": "0x0c0d553e4878ae811024144112c88bbf79a372d5", + "state_root": "0x1f2e4f3ee8c38dc605677b6ce650a08c7fa6716795a8622d396e244f710e0a5f", + "receipts_root": "0x7ed3313e083eea1ecfb57f4508fd068e9fb56c4125942ed01ef47538b5f29e14", + "logs_bloom": "0x91f42b3ea889c963c4f8e670db851b5ba5b86bd3dc5c578a4c75b9008f53569fed0e82445821ecdf1e306d211dc4b3e042d5813f11ce16132211c523a92d723ffdaaf2175eaa77a1937f2e9f27b5e5b0f1bd3b77dbc94c7215fa1065d6066ea59bf2b95b8fe2ef820d9cf6a10c93f04f98db135751e1d8972d2427113953334f5634914e66e00af04d50d4de255bb0540ed3627a6f64073f81a28f777cba3a4ff145230e8103befc67e3ae2e8c72518ea18fa75495daac19c0f5c5094c84853de2b6ba4e2275c8a941cfb1a29f5a24ba911dd636080b0859abaa198dda14a860d4d29306b038ddd219c708ed837583079254b70c7095ac70984894735b79f7f9", + "prev_randao": "0x58913d3ec8a62b95e52fb1ee60ebddf392af6e1db902dd5bc3f1eea7003130ff", + "block_number": "4483248126065046120", + "gas_limit": "4474985709981625479", + "gas_used": "4473333226764941351", + "timestamp": "4478290672120026440", + "extra_data": "0xb736203ee72088edaf7eb5c7839744f5b1be69f748eea8fea77740914415c5b4", + "base_fee_per_gas": "81744492456258793280520536666094060462558404863190111969507816784424614128915", + "block_hash": "0xc7dab83ea972daeec7b1385f04b22e210f708323c38b84160159653a163f259e", + "transactions_root": "0x8e77ca3ec98f3c20e7e802dd8917f1b9fc66866da0310ae878d59ae1871cfffd", + "withdrawals_root": "0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9" }, "bls_to_execution_changes": [ { "message": { - "validator_index": "1728135", - "from_bls_pubkey": "0xb039b0181d6aa181417c62124db1c686d254153f7b6776cd37c10adc1debf0b71448548d1206f977f6eaa54f6d890ac2", - "to_execution_address": "0x003ea73e885578bda77a6ee17f4c6c88227980d9" + "validator_index": "958637", + "from_bls_pubkey": "0x89ca6fbbaafb3c27a42f70699f42e3f79d3b7681b103e5b393042efa90512aa9e590fccb0b654a5c1590bbe675aa584e", + "to_execution_address": "0x4dc28f3e0884f5d07b860b8fce6fbebc3b857c21" }, - "signature": "0xb1fb6d05f91d3f90fc29c037776e0b5746fc39adefdd86b51b8a3b269be3d02366c644dc9126cda52f99041c691034f91141ef5110d064e5d583c644f4813c1aabc250021df9fe591214db995eacb0a1cba0a2b43f88b4aef2930d04bb99be3e" + "signature": "0xa207b627176533d6fc3670d6c4a48afff107ef6bf9d7520b0f77162bf7df5505aa3a17c08ee53067daad827b75ef333015a61a81b421ec8888ff31dc50994121420862d11926782bf6983aab5f6f39c17264a77943dd6618d85444c56d469c19" }, { "message": { - "validator_index": "2804390", - "from_bls_pubkey": "0x912c280adf321fbdcd522490a5431a7c2e0e716841b1a3819edf322fd46ab90681663c156f382055a914732e156d85dd", - "to_execution_address": "0x26809b3ec8ec364791003d38265e95222e7f7efd" + "validator_index": "2034892", + "from_bls_pubkey": "0xb384518c8bde1118e66c725854a5919c4a5c0453e8eb822fed707aa5c636e6e2a2aa56c95966817ec67ebadf6c77b44a", + "to_execution_address": "0x7304843e481bb45a660cdae57581e756478b7a45" }, - "signature": "0xa969744aa463b0294e265f1fa92f9c9ef277afeb7ed667017e0a914bc57382d94c52f4411a135094e52636b63942e86e184ce0dd10e22ec86abbabe23396063fa873ecfc0ee3e16a5535f6422cf3f134e4d2de39464f038dd9521bb9d9a1ec80" + "signature": "0xaf85c50db6dad8c04b9a22611e3174fdc57a3cfe255164e0361897353984556c3e7b91b040ec3b59cc29d774aaacf4b204e4e1960b9dd5bf9b72f8c3e09bdd64753a65084567c10b229784fe46be3de016c8add60d84c970943d221882294028" }, { "message": { - "validator_index": "2419641", - "from_bls_pubkey": "0x98192fd09a845d194a35781b711d801c9ce08060445a81cdb38d45bfb82c776d0e9b6083eedc0a106c9c922ee3bc906c", - "to_execution_address": "0x2fda834311b58db49107ebef3efd6ab3f5f751f2" + "validator_index": "2742020", + "from_bls_pubkey": "0xb2bffd7d93c4b1e46b3f4511f97de3ac70e2f9b2e3428b26ad7864d9f71bbca34904c81dbcc1dc2ffd1c02bfa016b096", + "to_execution_address": "0x7b5e6c4391e30ac86613889d8c20bde70e044e3a" }, - "signature": "0xa864cf37cc41e0ea0c8cd4ae1d6d0bb833ddc583b3e389808da50acd9a3c49c59a2d4b038446feece5a6083d251e45530622aa80cc6bb57d7df907a39e1fa40885ab29ce25f3788860dab9a97050a48079c20176d6bd7e11720790679ade7638" + "signature": "0xa2a6993708f79d7b3db30c3968aaf4b706400145cf70fded02b06d54922e54a4c1db14d63860cc632d0b2a8c15efc5280bc57ceed454838f2a0848e03e610e130309d8012aa5eddc1fa84b509fc8178a685baaa0413ec58709e738aae430491d" }, { "message": { - "validator_index": "1587773", - "from_bls_pubkey": "0xa5234d7dc8fe8544bcad85f8ca6548172425616038825239877450fa6144ba23923065a1c3d3a8fbd687ac593e11b4d9", - "to_execution_address": "0x551c7843514c4c3e7c8db946e50e944d01fe4f16" + "validator_index": "818276", + "from_bls_pubkey": "0x94e2d4cf94fb757578c496885af2075c26e2483eeffa6e894ac791f7c1945b0fbf9a6f7860736db93e03d511c4b08516", + "to_execution_address": "0xa2a06043d17ac951519956f43432e6811a0a4c5e" }, - "signature": "0x92ddc8deeee37b1eeb83436e230c4dbfbda6a26fcd4b046c7556fba6391650f7824e0355adfbd38b0ee232030feca3780dcb2990998184ec505207f3d4123bdc38ea5a8de44474bbec65e619b8a853670fd3ae4a08a50ca1c3bd2c81739b92a1" + "signature": "0xa8b4b8e92e67565ec430f2fdda94ed0f6f06d8cb302770191d614b795d194e4728c11e72162f25e04d0f7dda1dcd54da0d8a7c39e71e945873168ffa294da70dd1acbc1902a2fb1598267df5d277a0f95592967ea222ab0706571001c315eb2b" }, { "message": { - "validator_index": "1203025", - "from_bls_pubkey": "0xaf01ad2d54129b76339febd98494d79dc8dbace659dbeb3aeae85f9a2a94b23da0170f08f5233cdb136991686441e54c", - "to_execution_address": "0x14673d43914005ef102bc2f829676150401c46ca" + "validator_index": "433527", + "from_bls_pubkey": "0xa5041469fc5f6a944fda64e7ab422c1479ab9d0de12a2f3ac7292dfe368408cbc6d2b0ff519b521427da731e7378806e", + "to_execution_address": "0xfdc8e14312fb98663ed87639047022e291c761d2" }, - "signature": "0xa34f07f9c38b8cf4781d0d1bc1d204860500aaa70a1ec6b1ca9a73d3fdbaace7c56c6bd9edc5eaf5898324494060496c016d716d51dec591c1854e84470529bd98a6fecdd74d012c8d8b677f32bd2febf0677c238361bcaa39e32056dafcaf67" + "signature": "0xb66c9d2c80f5a12930f0899b9ff3d1a6a37e0f9edb279ced767eca8ef0380227681b15bd3850a00a383491ed1d8e869310f10edea2b912278e1e2ec1cfaaba8c0981af2e40fd233a9fd2f67ec56540c66e062212ee2781593a4714914e15cb52" }, { "message": { - "validator_index": "2435262", - "from_bls_pubkey": "0xb508746a00c15709b84343dbc90c7033f121615b7ac2ebbb356adc69bc7dfdf1cc1607b1f5e577476b02a89043b0a6fb", - "to_execution_address": "0xd786ed43d263dadc5352a8e25d5ef94784c163ae" + "validator_index": "1665765", + "from_bls_pubkey": "0x9105e2e35c7861d3fee37cb3bf07e8fdf3e0911d251cb11b956d4edbbd62a951c7ac9854677ce19a7748a503c307028c", + "to_execution_address": "0x240bd643529257f0285e4590ab814b7c9dcd5ff6" }, - "signature": "0x92806dee8cfa7784e16b97ea6b32613fe6c41bbb7d0f03838a6dbebc90961bffb9f67ae8046ac1b3fc19e477d76e26ac0d5e613a0c87ff18649a50d75a8b09f8d72f0f056aa0078eb99c68f00b08535e242cd0db5639223f9c3adb71183bd0bb" + "signature": "0xb3b0b28bedcc6e28d433c2a577204a9f7ecfc2fd4e3067ddcb65caebf7fd32d0389dd1db836600b0ee19a2ac8b6d0a660788a42abfde02bd5bddfdbe8cdde83a890ce69ee178ea314cfd9c06e5507ffe5cc4a685004f955219fcbbbec6fdd144" }, { "message": { - "validator_index": "2050514", - "from_bls_pubkey": "0x802775e14fda679e4594ca8ccda68a706957fe82c10e66d258eafd21fe5b2877c226092004f82874fb4022d73b74eea6", - "to_execution_address": "0x96d1b2431158938de8efb094a1b6c64ac3df5962" + "validator_index": "1281016", + "from_bls_pubkey": "0xaae4f1779eb7e006a9d0195e39af1f14a05b017a4a351ee1f3c22929929fb510cae4ba8e01b6d2444a66e388e655d92c", + "to_execution_address": "0xe3559b43918610a1bdfb4d42efd9187fdceb55aa" }, - "signature": "0xa2695a1a43803793a6a1e80b15798147d8a63da5c8a6ee3e18dabd190255f48cbe36c33e3ffa372e11b19605cd2282a3136a2662cd3c8f9d3d0345ec1593b4241a0ee66c0d626da3db5cc6bd7d1119063922633c1c2987d69839af6ac37eb675" + "signature": "0xa3acdd589f44c5b4201ae54cd119add73b60bcaca91f9e5d028669dd9b52f3ce15c20bb0ec39ff9ddfe96d5c1ce979c10376d36f4840a04cd90ed9d4348fa4a53f0f00e35bfab055a102ce3b6306255ffba3ef9ce7e1548048139d574478ebbf" }, { "message": { - "validator_index": "126769", - "from_bls_pubkey": "0xa1b20c565a67fc79e0dc4d8a335d9d3c7cba0865cec80a8f7f49bf610e20ab39afac693fe60778de840444b3ead514a2", - "to_execution_address": "0xbc13a74351ef5117d2757feb48c8efe4cfe55786" + "validator_index": "2201289", + "from_bls_pubkey": "0x842bb38ef27bafce4e8aa9abd3e31286da4d36eb87ff6a2fc4de272e4878230a7ac7a723bf3f76101ab2c2a642550eff", + "to_execution_address": "0x6cbad342d091b8c64ee004060b06d3bbb052340e" }, - "signature": "0x9113b44632e0dac2168c83f2be8634d2eabe9b81ab5d426c31ffc119f3fc577c16edb82f50b13be7174eca9adbc2dc560f1ad4bd15a414e44a5ce7b330e8645f58cb50204f6e4ab4bd7c9315b355c97a5862e05f5140c61bd1a4de061855f0db" + "signature": "0xabd643eedb5dfcc8f2db27bcfd59f6359517cec81ab4d5ff08bd5fd246ba120883c047e0cffc1d215104169a335628180df5779f128772f899546fd260328d4a4368a044c3e2037f4284624728dc94e05467b1559aad3077cf9557bf62fc56e2" }, { "message": { - "validator_index": "2586038", - "from_bls_pubkey": "0x83b8e297b2e5b17d8b30acc4586741cbe2f1f9de15b53add4e41cf23fd6f9034de02c5159eb4212e575a3255d681220b", - "to_execution_address": "0xdf80b0429057f4630e72700a013b4e8ad6642e7a" + "validator_index": "1816540", + "from_bls_pubkey": "0x990cf4f3bf6ede0aaef3010026465f98f381860535ce007b87879afbf2c955c13d07d7c2d91e22fddd8ef5531f8bd22c", + "to_execution_address": "0x2b0599420f867177e37d0db84f5ea0beef702ac2" }, - "signature": "0x8ac01bb60be2b4f4ae1847cdd5f95d3af16fd4cff3fa9d0da17d72f31a2cce4251e51907a63cb8ab9842a784cda7c40e0a93c536c8321a8abd889e3ed438d8653b77d0d06d3fc61f38b235f0e4c57c9dca562593216d94bfaf903d109eeb3e84" + "signature": "0xac8ebc3beb6cfc97c27f286e0d2e582707cbcb972d0898a41831b2d1393a684ce54ce54dc9128dc3988930ae4d92b4ed0a51b2bf639d8fd8e62e40ceac222362d9bb67f9d1b8419f3123dac1bb2e4e0cccb5c7c0985c83bd0501ed610935aa96" }, { "message": { - "validator_index": "662293", - "from_bls_pubkey": "0xa9701b9f205890357cd0b75c121c25306bd409e007ad97323af8b41aa535a8227f82fa8537f8e1e9a89a216a53aeeab9", - "to_execution_address": "0x05c3a442cfeeb2edf8f73e61a84c7724e26a2c9e" + "validator_index": "2892795", + "from_bls_pubkey": "0xa0695f8f6f65e3d8401e144eb382eaed73f9ec56be6de71dadb917af79a08ff7b74967dd4f4766ed77f7bc2fc01cfa38", + "to_execution_address": "0x51478d424f1d3001cd03dc0ef66fc958fb7628e6" }, - "signature": "0xa3779a97b60b64b43f1249ac6e49af7a02d87608ccbcca01b26cb226baf3d0a135b6d98d008f4417e714a1512ce07fbb18c6e491fa2e6cad5e1d9e29f56aedb856073cfa6f90cc9b21db6b3ea9cb35f3c9ec47ad48996650941b4b8d5e6355b7" + "signature": "0xa18c2c70d886e11a592393a7bef6fb3a515100e1436763854eb96fca9c031a959e4c105be367a10ea87c3d1a8bce821303470a1d6053cd89139bbd86fd7bbdd3e377b331884bedb0f9b10eafcb3272561fc5d71b96b219d7fe3aacd6e1558c97" }, { "message": { - "validator_index": "277544", - "from_bls_pubkey": "0xae86d94e3803aa062745028c91f9eaeb957af12e0d1e1c479c3ee78dfa76d792c8778507bbe0f1aded55e48d10b94a8f", - "to_execution_address": "0x61eb2543106f8202e5365fa6788ab38459284212" + "validator_index": "2664029", + "from_bls_pubkey": "0x97e268878248299c9e4d2c86957935d6cddb83900dbb6d4e52a935bcda58978f6fd33e0dc891cea14da0feafd5173762", + "to_execution_address": "0xad6f0e43909dff15ba42fc53c6ad05b972343e5a" }, - "signature": "0x831796f518dd44cbddc77db8d223ab502edc7bab53c2795edb3879e4f79171f13e4b7d5c5f354e06314c6c1fec3988f703234fb99488ef541062ef7f8a89f77bd18b82f79db2328ec0cd6db498f5ab4412800e9e4a351fad3d609a192b0eae61" + "signature": "0xa2010187045aa6d63130c7ff23464438af57c3e42eaa90823205936a94c47713b68bd93d3b6837947e277ece630a6d200d428979548f340f6f71ca33e8731e059a8c20f75d71d36caebbbf6fde28f37a919353dedb7b7c7e4dbcda553e5bbee5" }, { "message": { - "validator_index": "1509782", - "from_bls_pubkey": "0x8c1cba560684965a1d17efcc10ac3e688808a44a655caef64fe19b0f11be06e324d48651b6d9663e33964737affaca25", - "to_execution_address": "0x872d1a435006418cd0bc2dfd1f9cdc1e652e4036" + "validator_index": "740284", + "from_bls_pubkey": "0x8aec1b1f595063af33939f3c3322ad38d2e1de1b11fbc8a9d04235dc7fc9792e1c88e51452d337855d254a71f42816e8", + "to_execution_address": "0xd3b10243d034be9fa5c8caaa6ebf2e537e3a3c7e" }, - "signature": "0x8b8974bfbed37e66501f80a64e0d81d27723e76fb46afb5e94398a6b956254aabd7e9af026d996dee341f804951284140ba20654abb8af117f23f4afa0144a7ea57076a4a0fbc727d1f1111edf829a8cdca542799d24a5021c103ba2a23c75de" + "signature": "0xa0ba14bb9ce5877d9f9d607da9b2fd2d629a1de42d6d3beb5a8f4c1661aa1d6863e01de14c548be8a9df222efc6373be1290581da81c76d71bfada1d07481d7b7de94290efd640aadca41d6b4d4f81091f4c459b454bd6e333eaa35c60faacf5" }, { "message": { - "validator_index": "1125033", - "from_bls_pubkey": "0xa127dd51be074dce1f11b15a9040d935aae14a0b073a7ab906edc1327f477e8213d96f738690b3f650a479dac373cbed", - "to_execution_address": "0x4678df4290faf93c645a36af63f4a921a44c36ea" + "validator_index": "355536", + "from_bls_pubkey": "0xa912f4ad989d87e777e45af7c265b430daf0b39345987506d4158cdee406847f294fc7745154eb52abf0934a5e1866ee", + "to_execution_address": "0xf51e0c420e9d60ece0c4bbc926328df885b91272" }, - "signature": "0x8657c885c3361cd4a58769798bf4baa0424238c9a2c5b20b79b6079ca67198cfdbc407cb9e4799663bc54543f1a74df8044006e589cfb7b5914cf77fb175cfb959b29861d42c3da17eb66102ad8afc8f20fb5e7f52934c385018e3db3bed9181" + "signature": "0xa7f77c7fc98b1c3a364dcac68b5cff112f7745e6dd41918ba56a6fa6945507e0ce245334e22d4581f49bda913baa2a6b1176b44d52168151b3aff9a625dcdebad1899747c42c4a43cf31f49124fc0d4543e4485592c243c5300b79214398b770" }, { "message": { - "validator_index": "2045306", - "from_bls_pubkey": "0xa67a1e9a2522bca1507faa25403c3ba020af65ffe839656e87f957438ceec07d5d8a91658e9fe6efe8703f1b5d24ffe3", - "to_execution_address": "0xcfdc1742cf05a262f63eed727f20645e78b3144e" + "validator_index": "1275809", + "from_bls_pubkey": "0xa77e90361be2a534a386cb689d6d763a98bea5f23f325b553a762648668e4adb4991fb5f41ad7ece1578f082a5c01b5e", + "to_execution_address": "0x1c6100424e341f76cb4a8a20cd43b69291bf1096" }, - "signature": "0x8dc84218c00f49ed40442f962e7afeb1a8c2ef5f4ed0aa8eda187ace69d22cd62b759e44754a66edf611383434b0d7bb18ca3eace8402fdeaeb7a5ee16639ac7133defc018719cfdf5a771449cab814076545f41f6662202d42deda5857c93f2" + "signature": "0xad188010cb0db88e067c2699030353a1c215ae9adf083916ee2069a805e0f2cd00c76db9250a859106dbbff4430b4dd114d6293c4b3c2e9cfd31f07949f04e53f63423a08b56d7247772d07959d5d92b17bd8c7c0b294b71d3db903d56509177" }, { "message": { - "validator_index": "1660558", - "from_bls_pubkey": "0xa2cd1e8619ea096ad3130c8f2dfa725c44cc8aa06de4f186d87ecaa92251bee9bc08ae465d6ea48b145a4f70f0729e42", - "to_execution_address": "0x8e27dd410efa5a138adcf524c3783161b7d10a02" + "validator_index": "891060", + "from_bls_pubkey": "0xb4582d56f8ad9dcc77eb5413558e63a6b562e42534c579a85384e7d7d6ff8974ff933d05a444c1d2784945f4cd1c952e", + "to_execution_address": "0xdbabc5418e28d8265fe892d2129c8395d0dd064a" }, - "signature": "0x97f8c4c02c4241858c09d9f2926670619f01a2e88fe50b3f3456c7db24c1c470a30eb58790400f29abdb9a9db63e075315d7e7b359848e76d4c637247b6a2ae492bb237e4aad36764ebbc93a0836cc4962e51681e15f00dfa1429311b1140e4d" + "signature": "0xa7f07c5a20159b029b2dac119315a0d439c541e63b0d1f6d377fd2867e5559d6b6302eb609d5796fab97cbca121ddf400c840b9ffa60dbcd89c6d441f84aff2cca1f68fd9e258a969b0d511ad1d90c0c783dde3c093ee8cd56cf6f70a61fd77a" }, { "message": { - "validator_index": "2736813", - "from_bls_pubkey": "0x96057456506ff35b37222395a6cf87fec4386244d7ee0ecadd11c96e8f7975a312b6826bd69e069eed2e88fbae21439d", - "to_execution_address": "0xb469d1414e91199d7562c47b6a8a5afbc3d70826" + "validator_index": "2123298", + "from_bls_pubkey": "0xa5849044acc283563bd9b40fe9b01a8c079093829fc3837cddf20a8f9c13e59629251481406f415c8e2df65285ddb41f", + "to_execution_address": "0x9ecb7542cf4bad14a20f79bc45931b8d1483242e" }, - "signature": "0x8734759600f9bdcc5a05f0c70f90062f0d0056ed8af19e4777fe4d5b67267fb33d2617d4630fd75822d0f1b60c70650a17fe6d16ec4fe2d4fdd2fd3433c357470dd8276a069a5402372a83091f40217805da560122e3d9ba5a98034b21191439" + "signature": "0x81df97c3071aac41af79494001a1c4404b5121776a71d6cbe3b8eef000e803f59edd2fff33331d2ea037faa919ddd6a115e09bead88d7c8f23368628f306e3a244f2ce0a54e4472d29e4b79eced6da3e5ab40177e96fa0d94d97f5e07d2e6e95" } ] } diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlindedBlockDENEB.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlindedBlockDENEB.json index b19f6743bc6..28fc27d9620 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlindedBlockDENEB.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlindedBlockDENEB.json @@ -44,313 +44,309 @@ { "attestation_1": { "attesting_indices": [ - "4585702132744102314", "4590659586689121994", - "4589007099177470570" + "4589007099177470570", + "4580744678799082634" ], "data": { - "slot": "4580744678799082634", - "index": "4579092195582398506", - "beacon_block_root": "0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c", + "slot": "4579092195582398506", + "index": "4584049649527418186", + "beacon_block_root": "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06", "source": { - "epoch": "533461240", - "root": "0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565" + "epoch": "538655350", + "root": "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0" }, "target": { - "epoch": "538462976", - "root": "0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650" + "epoch": "539040099", + "root": "0xda533c406bf3482d8e6e992e756be34172a8c47fc1cc0018350bfe98c946deda" } }, - "signature": "0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc" + "signature": "0x8bfc6e1a1c76bdafb4d491ce02a35effde6d7362eb32c03f119c47c12fb2b49e7656bbd4702ba02560fd7fe117f2c74e02142ce46176ebf269d5b34a48a65525e35db6cc446965e86e22e9d8adf5abe92315690b6de5f4591769487539fed52a" }, "attestation_2": { "attesting_indices": [ - "4585702132744102314", "4590659586689121994", - "4589007099177470570" + "4589007099177470570", + "4580744678799082634" ], "data": { - "slot": "4620404293179370891", - "index": "4618751809962686763", - "beacon_block_root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b", + "slot": "4618751809962686763", + "index": "4623709263907706443", + "beacon_block_root": "0x27d82440eb21c640637a36dcc38e35768bb4c0c79aefa300ec0f0cba32cabb05", "source": { - "epoch": "538078227", - "root": "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb" + "epoch": "537116355", + "root": "0x999e0140abe701de220ca2e0b9c3b044b1c6ba33e0a3985dfe16a16b510f0846" }, "target": { - "epoch": "536923980", - "root": "0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5" + "epoch": "537501104", + "root": "0x735c0d406b5043543786d38912b287aaa4c0bc0f731247e9a3141adb9c4d9930" } }, - "signature": "0xa32991816eb9f297553b4732309a4cdba7b33287264611715b0ab3319bca19e581da6e2659912a4e0e94aafc01c488e30ffc96ed14e2a726b9d3c618405ee0bf54bf6ae7f2097465cb27ab8132ec24eb93d3c9159475304082f7f0e452b93b65" + "signature": "0xb2213ef588828a7c18cdc781d0ed2516fd3e11de625f191aae7ae4be8b1ad2cc217728c65a500aedea276d345f09fd3212b009568a6549f5f40ead6d7ec4d0f3f329c00a1b4bca59068ee0555c94aec91bebc18365ca0b2d6692557b4b0c4267" } } ], "attestations": [ { - "aggregation_bits": "0xfa79cdb89d0d51c5cdd001b7425c6d726750a9d5f89ade6ed9890ce3a706140c399a5e10c90a819094b65322dac7501f7c75471e69d4567358d8ca75f7c1b3133ebecf006b369a1f36efc5f2b706d5922ff98c58a1825a53a864376658f816600cf021cea843d4396502bb9c74d1510afe26036f89f783b4f5c7bacb6649c46f217a6af835f312d6fa253d2bbc83c07993f4f10de2ed2d952689379dbe4f794c1a1055a6b364d68e038deec9667f576b3b9eca5fcadd6298f181e1edb876efc3d0975ae14ae9a0ad2f1836d4c3f1080a96d8ab7c43b34bb2eda895ff66be698b363cfa4be33da3ec94a1a7a90672fd12c4a59916bb937e78476e4f08e4f4031001", + "aggregation_bits": "0x907c35a14e5afee2fffc1703230dbe923ea49766c5af5277f432d84b3c2323d8a5a8dc131a8cbb3c69aad1172537e0826b0f4ee1639f650b91bbeab0eaf337f9472742d6f8443c1eb7c62f5f876f5f154689fb6548800c39b12a8d1f2585230fc372dfe5bc46a4c4358fb1ebb547796df094800159f2c9d982d61666d8a188e3b665900ce8f564188f269b5265d345893085d41f43a030337dedcafbef1245fb43c6c44b9891c2ff5f157069435c52c7fc457d5ec218f5d2ca50e69cae88c863b56e53213d92d7f6357a56344a4c2b80b58249b494d992f3c78d7440fe6b69d32ff3c1c29dbea8d0aebc1347743dac65bb66529f27dcf476baa3774d1e5c69dd01", "data": { - "slot": "4605531939934246443", - "index": "4610489389584298827", - "beacon_block_root": "0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b", + "slot": "4608836906367614699", + "index": "4547695001580498185", + "beacon_block_root": "0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2", "source": { - "epoch": "529421377", - "root": "0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2" - }, - "target": { "epoch": "529806126", "root": "0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd" + }, + "target": { + "epoch": "528651879", + "root": "0xe24dff3e29e762b4488e615619483884c44b8f4b37239b5cdc4a3bd7d9b48c1d" } }, - "signature": "0x8f8d16b39e14569aab1b712e5c19ed51afe3600a6b017e8ab432f43a02ee720a733c33ef087d2f3653a9701e8d8a836301655b9195c0373b775c88ba1368e5d55354a70a3096bd26dee29dddbe7a4820e2b1653e84122beacbc01af7d93e6bdc" + "signature": "0x913ce44a60f20df0261b53d8031d13f3a8d51cf53ba5eb65735ae960623c48acd56286b31ecd74cdaf51f66b2b2331fa0e907e8cb9d4dde513ca29cc34ee9925301bb541055a8daef33bb3e1fb8442a4a033f93f86933bc35fd2ce34a569a6ef" }, { - "aggregation_bits": "0x4ac567b296efbf7cf3209e87096a7a1a50fd523400113f917f6584a5a306f06b2d8da9ae858d47ff2594010089838efe41f19a78d9aae27c2ffde26f278b8681db9d091eb72e7cab3e449dfccd46a270693e1f88f197324e57bfd45573315cf9fb60d770937b32f7c0c6ce1581ec51e6b60f71acfde304dc917f2e0aa7872038b7d9140d15f7927c23a0490a74c2b0aca2773fed9217067e4444f9ca93874e4ff8407111c3efdb138b97c6d4957b6a70ec1debb283e3d0eb1cfef068adcffbf057d20fdc339eae03f0fa2613abdde8158a7fc40c3cfd1117eb6f8c4ae21d6b2ab4b57ae9a8653a34451aee6418c0c3609dc937293f5f5b346a7ab1a0d144185101", + "aggregation_bits": "0xae44a59e9b57b7141da75dba9d385b795ba84317f41948621bf98a34f92168838b72a9678bc58de000cf466104613975fb1490c591f0ee9055cce4aaa2ff0eb5a26c8b9e20b6a386d9e9f7964a3ebb957e3c6b0124271c279496235101a29fbf18ac7be6749a8b1f230bb5131e97b28c06683ca9a6cb6129b2a25b4f539f7f5e41cc1997c5b4a57d51dbce5ad4ab746a403e5270c785b76d47475c0ee6c309e33dad08193c3f8e40e9414096276bfb5708c84359dd51eb54ca67dd7a6eb5645801fb83811b4c11eb5b240e9d0bc0847ae7abfa235c7d6cc5f7eca53bce62b1b987b7c11ef54592399882d7983eb3c6a58ff636f52b4007afbc0d66bfe9d9276a01", "data": { - "slot": "4544390030852162633", - "index": "4542737547635478505", - "beacon_block_root": "0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd", + "slot": "4532822644040406441", + "index": "4537780097985426121", + "beacon_block_root": "0x0890f33e697e213e331430adc059611ed0518d6fa4b4ecd0384dc2678e76fb32", "source": { - "epoch": "527690007", - "root": "0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8" + "epoch": "527112883", + "root": "0x7a56d03e29445ddbf2a59bb1b68edcecf66387dbea68e12d4a545719acbb4773" }, "target": { - "epoch": "528074756", - "root": "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8" + "epoch": "527497632", + "root": "0x5414dc3ee9ac9e510720cd5a0e7db352e95d89b77dd78fb9ef51d088f8f9d85d" } }, - "signature": "0x90309dd491ae6ed51917dc305a3d4ae68d0a0d4792c7eb59c193bd03605bd94e61cab37502de0ad3e6162bc02427bba80a798b3670d5de82a854094016cc298b265371345c0e3ac49fd44bbb9ba0d4fcea0c1a80cecb60e93921d907e8c48120" + "signature": "0xa3f0d1902ab93bc710c2af70da7699b79480ee062fc8add2cc1c6ddce56d54706ef91f581ec0f94cee95fc4be146005f174e2e77733d71ef59e53a12eb852e09e4334af2c27120e506ebab9c04e2b2f99045d40bd1372618173cf6df4ad21f86" }, { - "aggregation_bits": "0xe8c9759f0840f980ae956b15fc383d992e7d4420d12ba5bf32f669f446ac6fa388e20e5ce96e9266dd98840179d2cde3cabd9a8bafab5dec9c2e89f7f78c989e690548603984803b80c82d7b76443194576a1ce49da5cfe56f56e83b745fb01b5f18ccc86d88f5a22d927e64ff0b8e880893abcddec45b268531c4a0697537dae643a24b1a36432f37d42962553bd39af71f37e0429b81470c11316aa39db074aa3f1df4124e7cb203debed60b885ffb9b27e46a1434e81bbd56566632d0729c0822ac415cbb67f25973667d88e58df9c2f058a0ae7f118c98cc448453b6fbe590363bd17ed62c2f808df61f2a9e593235eeb56db74b9dd15980189a5271468301", + "aggregation_bits": "0xe2e8a45105213f0f211443b26e3a23df7f899eb9b3ddd40b5f51905f90441f98eaa0d2b9ed7dddf5b4089188c41388cb5702236640399f914245bc085459f40d628a99fd663a4429e9b46e61dc8beb6ae3757aaeffc6db49c374cc93d1e663989d84fa7b4aa499a8b5d34ec5fea94bcdb33af829c6260d2a88a6be97e89baa6215949a4ef124436f685d4ee683c0c27f0ac7aefd77f4b305842d1cf2d08d9b7f4e501a38b81014fcbcec2156d5abbd1010afe4a596164e4659c6dd794639199119b4a3f2ec4f3b4d6a084bdedf66dfdcc1be1c522d9bf72663b7cc1a8746c3737e20ef7ee1b7863f89ab600a35772b4eede0424b8b69bcd27a6b354252a0147701", "data": { - "slot": "4529517677607038185", - "index": "4574134745932346122", - "beacon_block_root": "0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947", + "slot": "4575787224854062954", + "index": "4567524808770642314", + "beacon_block_root": "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", "source": { - "epoch": "532884117", - "root": "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31" + "epoch": "532114619", + "root": "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c" }, "target": { - "epoch": "531729870", - "root": "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672" + "epoch": "530960372", + "root": "0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c" } }, - "signature": "0x8c40f51a99fce6ebb9a4db5e80d715fff319e7ae523e46afb5d03c000d427e23c7a39e77e2af53851706283c8ca91d680997cb459386fbdff52c4d0ecf498e173717a838a792b210bdffaf476538628584a133899bf30dd5ce7056463b8cd683" + "signature": "0x8166b2ed13e982e6b9f05d30f42681b826099135a533d2614ef5f4f59811714245db0e1821a644859559f97ec1e614bf08b2edb294fa2edc1527f46596399534af23c98613e1b74c01871bf1dd2af9618bc0ba23ddfce8026b897cdbba8c1bce" } ], "deposits": [ { "proof": [ - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c" + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587" ], "data": { - "pubkey": "0xb1f8f6e731dbf6b4e3265fb857c7190adbfc7e6cc95ce2e8bda72be8b6ea3459f862310a2484c3b0ee33b30920f18c1d", - "withdrawal_credentials": "0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c", + "pubkey": "0x83b9036200e9e907c86ede7f98b23297389e8af19d403466e00f1946867db735d8620019e28aa42739f49c65b78a2806", + "withdrawal_credentials": "0x49452e3f298a688d9e7627fb7c01941b923397bb84dd548b6e411f9506aed1c7", "amount": "32000000000", - "signature": "0xb594382214f5bdd375de66c45e1c61a526c7b73fb166c72433bbd9c2a7ad6881244e61cc6427e0206a50b762a129d8830e8708c55761d61ce9e3b19c1bee13bc55daa13bdb07118efdbf57a588b8a64e6392d14f935e53b68933e3355b35acdb" + "signature": "0x86e6ad7c26352727d310e10f7c745a0725636f63013f70c5a442489946dcd1c85665cd3539fe9d8fe6f6b49b5b7f13a50af2a2b98a7d385417c98e5d74273e67cc3bd8f8544dc3697124c8176835745659182eab37f3ebe0a881ff4e7f62bc31" } } ], "voluntary_exits": [ { "message": { - "epoch": "4562567354825622634", - "validator_index": "4564219838042306762" + "epoch": "4555957421958886121", + "validator_index": "4557609905175570249" }, - "signature": "0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e" + "signature": "0xaacffaf60c8253477ecad70de8589f2ef7670d0b0dc446d4baac3b465a901d3e64bb6d2c3d8bdb58aed45ac30466261416d152d5ae242204201bf6decfddde697ae0c5d44cf31ca3d43aa18f2799461fc1ee14dbf905b1e31f242fd31c083c5a" } ], "sync_aggregate": { "sync_committee_bits": "0x01000000", - "sync_committee_signature": "0x919ee45cc18456f6e85da6bc21c2e40f44f9a887932c73ea9ad354f88e56d4ec0a8c396ed143082c8e31d697b877a2a215d2966d91c7beb156bf7ab5777e210012f70dcd5f7657808a82cba51e194be994f917150ebdb9e5c57476f1edb47206" + "sync_committee_signature": "0x86e947b46923b26125a7dab3240481ddc1b910c1e6393b90df6e2de3809b8b35e450dc8264ecedd8f6bfc736e7114d841428b2469441d2d1d501015eb99e0d7090f11a1185b566dc42f94b79d0a08b22718a39b57e912a304419361108434ec8" }, "execution_payload_header": { - "parent_hash": "0xf8eb5a3ea82ccf3c1be1ac153e3f77f273a07343291711b9de6b9dbebc4c9b49", - "fee_recipient": "0xbf886c3ec849316e3b187793c3a4398b6097768d", - "state_root": "0xd2a9663e689510b3305bdebe972d4e58669a751fbc85bf448269162e078b2c34", - "receipts_root": "0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9", - "logs_bloom": "0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d078748f9069c96e9d6a2801cf607000a52447e46e1bef4e056ee30d4bd3517aaf7bf65ba04dd28c3a4a14b8dc72a300f051722a6814fa3931d90a82d23285d4c1127b6c67bbc4f8682ddbf9b31eb3114c26dccc5330109d6f17799339c2d7ed7e4e3a7de5d515106aaec7be6d78be3e21806d6d30c39b77c75dcf354b63033fb200b3b9dc023d948278f0956c0ee99323da0162f2a84b6a95749d2fa1d4e089af416d412ccd992683f7e41f7b496ca04f9f463806e3643d1c07f39d2a65f84e97b7dfaafac740d1e03f30923a4270fcf651ad2ca3737859a524e86e02229a55abd1a7", - "prev_randao": "0x0c0d553e4878ae811024144112c88bbf79a372d5dfdf39730cede08696ad52d4", - "block_number": "4489858063226749928", - "gas_limit": "4481595642848361992", - "gas_used": "4479943159631677864", - "timestamp": "4484900609281730248", - "extra_data": "0x6bb2373e68f20adada72181a3474f2c098b26daf6fcb0516f0723270da91e789", - "base_fee_per_gas": "91973405088222260025272995045243630915786868313949746451634391325697029602367", - "block_hash": "0xde78143e27b846779904841e2aa96d8fbec4671bb57ffa72037ac721f8d633ca", - "transactions_root": "0xa415263e48d5a8a8ba3b4e9caf0e3028abbb6a65922580447af6fcc869b40d2a", - "withdrawals_root": "0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be", - "blob_gas_used": "4476638188903342311", - "excess_blob_gas": "4521255257228650249" + "parent_hash": "0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874", + "fee_recipient": "0x0c0d553e4878ae811024144112c88bbf79a372d5", + "state_root": "0x1f2e4f3ee8c38dc605677b6ce650a08c7fa6716795a8622d396e244f710e0a5f", + "receipts_root": "0x7ed3313e083eea1ecfb57f4508fd068e9fb56c4125942ed01ef47538b5f29e14", + "logs_bloom": "0x91f42b3ea889c963c4f8e670db851b5ba5b86bd3dc5c578a4c75b9008f53569fed0e82445821ecdf1e306d211dc4b3e042d5813f11ce16132211c523a92d723ffdaaf2175eaa77a1937f2e9f27b5e5b0f1bd3b77dbc94c7215fa1065d6066ea59bf2b95b8fe2ef820d9cf6a10c93f04f98db135751e1d8972d2427113953334f5634914e66e00af04d50d4de255bb0540ed3627a6f64073f81a28f777cba3a4ff145230e8103befc67e3ae2e8c72518ea18fa75495daac19c0f5c5094c84853de2b6ba4e2275c8a941cfb1a29f5a24ba911dd636080b0859abaa198dda14a860d4d29306b038ddd219c708ed837583079254b70c7095ac70984894735b79f7f9", + "prev_randao": "0x58913d3ec8a62b95e52fb1ee60ebddf392af6e1db902dd5bc3f1eea7003130ff", + "block_number": "4483248126065046120", + "gas_limit": "4474985709981625479", + "gas_used": "4473333226764941351", + "timestamp": "4478290672120026440", + "extra_data": "0xb736203ee72088edaf7eb5c7839744f5b1be69f748eea8fea77740914415c5b4", + "base_fee_per_gas": "81744492456258793280520536666094060462558404863190111969507816784424614128915", + "block_hash": "0xc7dab83ea972daeec7b1385f04b22e210f708323c38b84160159653a163f259e", + "transactions_root": "0x8e77ca3ec98f3c20e7e802dd8917f1b9fc66866da0310ae878d59ae1871cfffd", + "withdrawals_root": "0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9", + "blob_gas_used": "4522907744740301673", + "excess_blob_gas": "4514645320066946440" }, "bls_to_execution_changes": [ { "message": { - "validator_index": "573888", - "from_bls_pubkey": "0xb8343e90edaecc9df1223293465ec067b3c9804f43e25817d27f1f4785bc5f554462032370781d9c65ab27bcc3d21415", - "to_execution_address": "0xdafbb23e48beb933bcf49f8ad83a43ee157382b5" + "validator_index": "2804390", + "from_bls_pubkey": "0x912c280adf321fbdcd522490a5431a7c2e0e716841b1a3819edf322fd46ab90681663c156f382055a914732e156d85dd", + "to_execution_address": "0x26809b3ec8ec364791003d38265e95222e7f7efd" }, - "signature": "0xa519e1354ad927358404a58bdc19113e5fd97d5cc19943888e22105ee943ca216a14898283fc3712500ba767de00022905e4198939b44a5f5a43fa0c87252969c56a26345135572101b257f87245a5e42fb2407a0ee67a6c2d039bf908b9aa8b" + "signature": "0xa969744aa463b0294e265f1fa92f9c9ef277afeb7ed667017e0a914bc57382d94c52f4411a135094e52636b63942e86e184ce0dd10e22ec86abbabe23396063fa873ecfc0ee3e16a5535f6422cf3f134e4d2de39464f038dd9521bb9d9a1ec80" }, { "message": { - "validator_index": "189139", - "from_bls_pubkey": "0xa9ddce0cab5b51d3d2c710396b85e3fd7a87f1738fb5cfd5a7b25dbb483c167a80e785cb4ca7250c14a60cc282b1d9b8", - "to_execution_address": "0x9946783e88b272e45092a83c1c9310f154917869" + "validator_index": "2419641", + "from_bls_pubkey": "0x98192fd09a845d194a35781b711d801c9ce08060445a81cdb38d45bfb82c776d0e9b6083eedc0a106c9c922ee3bc906c", + "to_execution_address": "0x2fda834311b58db49107ebef3efd6ab3f5f751f2" }, - "signature": "0x8edfb3b9ed80067d0626019a1be330bac43c7ecd813f7ce781d0e6e34fb583803e9d2b047ad3294d6d3a54d020c68231085f7d9085d0afefb047def063a4698277e66d4a560f4b5bbd16586976f0bcf90177c00abd4a1b4cbd0ac393e5b904b5" + "signature": "0xa864cf37cc41e0ea0c8cd4ae1d6d0bb833ddc583b3e389808da50acd9a3c49c59a2d4b038446feece5a6083d251e45530622aa80cc6bb57d7df907a39e1fa40885ab29ce25f3788860dab9a97050a48079c20176d6bd7e11720790679ade7638" }, { "message": { - "validator_index": "2357271", - "from_bls_pubkey": "0xa287d120292890ab1aa49bae1e3cd88bb160b5640f18c64f1aabae5990616e53099fe61698c3b812e2bc2ae6b6965960", - "to_execution_address": "0x09988f43d11dcf2aa7811c9997eb4119e8f153ce" + "validator_index": "1587773", + "from_bls_pubkey": "0xa5234d7dc8fe8544bcad85f8ca6548172425616038825239877450fa6144ba23923065a1c3d3a8fbd687ac593e11b4d9", + "to_execution_address": "0x551c7843514c4c3e7c8db946e50e944d01fe4f16" }, - "signature": "0x8ca190827c66ff26c1fa594eae169b7efbd84c9456304f2194df7b0c204b0a29ac53034c9b20e4977b8e8b46d6b246da03a9337d3bf5e6f7ac941407a2a3437d7e2c0dcacda29b7623141833e02b4b12350ccaf8b27dbf96b3c520078f49efe2" + "signature": "0x92ddc8deeee37b1eeb83436e230c4dbfbda6a26fcd4b046c7556fba6391650f7824e0355adfbd38b0ee232030feca3780dcb2990998184ec505207f3d4123bdc38ea5a8de44474bbec65e619b8a853670fd3ae4a08a50ca1c3bd2c81739b92a1" }, { "message": { - "validator_index": "1972522", - "from_bls_pubkey": "0x8db8ee645b614f990839e4d98fdbf921263bb62cd917fb4eff9084dff23d7cc453f6cc645ad8b869aa9d31a6b9560630", - "to_execution_address": "0xc8e25443111288db3b1f254bdb430f1c27104a82" + "validator_index": "1203025", + "from_bls_pubkey": "0xaf01ad2d54129b76339febd98494d79dc8dbace659dbeb3aeae85f9a2a94b23da0170f08f5233cdb136991686441e54c", + "to_execution_address": "0x14673d43914005ef102bc2f829676150401c46ca" }, - "signature": "0xb0c3172e9bab8d04faa5d27f9818c36ad61a71b114f5bd9dbe77306be3edef2bcb56c215511ba76145006daec95f24be0f1f0dd24377cf7b440b5cdc7d0b520d6b64c539eaacaf14875d49c293af5974751bb0ce2daafde3bd01e097a466e75f" + "signature": "0xa34f07f9c38b8cf4781d0d1bc1d204860500aaa70a1ec6b1ca9a73d3fdbaace7c56c6bd9edc5eaf5898324494060496c016d716d51dec591c1854e84470529bd98a6fecdd74d012c8d8b677f32bd2febf0677c238361bcaa39e32056dafcaf67" }, { "message": { - "validator_index": "48778", - "from_bls_pubkey": "0x8ba697cdd6f8c34a1fb96a4c88f03360d19515ccc4e1ea24aa5e80075d821059806a0047e6bbf5d908d312d1902aff5d", - "to_execution_address": "0xee24494351a9466526a5f3a1825538b6331648a6" + "validator_index": "2435262", + "from_bls_pubkey": "0xb508746a00c15709b84343dbc90c7033f121615b7ac2ebbb356adc69bc7dfdf1cc1607b1f5e577476b02a89043b0a6fb", + "to_execution_address": "0xd786ed43d263dadc5352a8e25d5ef94784c163ae" }, - "signature": "0x87fadfd11bc5612e06c59d576c91599bc21095531fcc27a177967de7b521c377ee7a2b10d0fadf38779089929cfe136518757803c369b4ce94873e28d7d9cdf54c31a53ed86b07f76ea6104ee65d76de02267a4b736c949785ef233cbb73ad4a" + "signature": "0x92806dee8cfa7784e16b97ea6b32613fe6c41bbb7d0f03838a6dbebc90961bffb9f67ae8046ac1b3fc19e477d76e26ac0d5e613a0c87ff18649a50d75a8b09f8d72f0f056aa0078eb99c68f00b08535e242cd0db5639223f9c3adb71183bd0bb" }, { "message": { - "validator_index": "2820011", - "from_bls_pubkey": "0xa32a5f28ae7d36f888820160335232fc42ef994b4f93acf6a8659762b2ec52ca79354cc07c73a229b529bfcebc705eff", - "to_execution_address": "0x4a4dca439229167a13e413e752937416aad35d1a" + "validator_index": "2050514", + "from_bls_pubkey": "0x802775e14fda679e4594ca8ccda68a706957fe82c10e66d258eafd21fe5b2877c226092004f82874fb4022d73b74eea6", + "to_execution_address": "0x96d1b2431158938de8efb094a1b6c64ac3df5962" }, - "signature": "0xa2089742415bdf32fa2dde853661a095ac24d273413687ae04fabb99ae2982700bcdb885d239e32543ffb95763a43e690cb1bf3a33df40d24e12c46d150e9c59dd63f960dec39712dabf74c08a55ba1bcb6db664ff9d5b2261da353e4374466c" + "signature": "0xa2695a1a43803793a6a1e80b15798147d8a63da5c8a6ee3e18dabd190255f48cbe36c33e3ffa372e11b19605cd2282a3136a2662cd3c8f9d3d0345ec1593b4241a0ee66c0d626da3db5cc6bd7d1119063922633c1c2987d69839af6ac37eb675" }, { "message": { - "validator_index": "896267", - "from_bls_pubkey": "0xb679b4b686530827b2a201eb2b18454e9a5758d7257737b29bb215b9f354c2ff57e912b19d4a051556187aa24c97371b", - "to_execution_address": "0x708fbe43d1c0d403fd69e23dfaa49db0b6d95b3e" + "validator_index": "126769", + "from_bls_pubkey": "0xa1b20c565a67fc79e0dc4d8a335d9d3c7cba0865cec80a8f7f49bf610e20ab39afac693fe60778de840444b3ead514a2", + "to_execution_address": "0xbc13a74351ef5117d2757feb48c8efe4cfe55786" }, - "signature": "0x8da9cee45a3046b209da332512a6b4e4d7c89768f55998eb79ee236b4fb1fbcea87e0bba7b05d19ea7b8c5ea6dc0081e17a7ad0ec41566a0c6d9e127b87691e1d5b823fd178069e3f30091dcdbb44c36408656941755177c45bc976bf270289d" + "signature": "0x9113b44632e0dac2168c83f2be8634d2eabe9b81ab5d426c31ffc119f3fc577c16edb82f50b13be7174eca9adbc2dc560f1ad4bd15a414e44a5ce7b330e8645f58cb50204f6e4ab4bd7c9315b355c97a5862e05f5140c61bd1a4de061855f0db" }, { "message": { - "validator_index": "511518", - "from_bls_pubkey": "0x83b8c61b63de768821cbd82ee3c67c81bb848163d6af0186ffe1ca3936d283bb4cab886f3fbc7f6336fec3da8d542c76", - "to_execution_address": "0x92fcc742102977503966d35cb217fc55bd583232" + "validator_index": "2586038", + "from_bls_pubkey": "0x83b8e297b2e5b17d8b30acc4586741cbe2f1f9de15b53add4e41cf23fd6f9034de02c5159eb4212e575a3255d681220b", + "to_execution_address": "0xdf80b0429057f4630e72700a013b4e8ad6642e7a" }, - "signature": "0x8c90298abaed4b5124cff46e41c9a4ed2b2baa0d2089add6b64c70dc7547f1a83bed76aba1fac6d36605beea72734b490b7b98994c7c65fdb436286b0df898731f6ad536e5a603da85ec8cc4488b94dc8c61e11363d1cc18733382dca51c7008" + "signature": "0x8ac01bb60be2b4f4ae1847cdd5f95d3af16fd4cff3fa9d0da17d72f31a2cce4251e51907a63cb8ab9842a784cda7c40e0a93c536c8321a8abd889e3ed438d8653b77d0d06d3fc61f38b235f0e4c57c9dca562593216d94bfaf903d109eeb3e84" }, { "message": { - "validator_index": "1431791", - "from_bls_pubkey": "0xa532ee397fdd9e388888d90f712e13b085ad5043402debe1caf3dabbb514ed0d06f7c897e4e2795fd018cd672bfa8948", - "to_execution_address": "0xb83ebc4250c035da23eca1b3592925f0c95e3056" + "validator_index": "662293", + "from_bls_pubkey": "0xa9701b9f205890357cd0b75c121c25306bd409e007ad97323af8b41aa535a8227f82fa8537f8e1e9a89a216a53aeeab9", + "to_execution_address": "0x05c3a442cfeeb2edf8f73e61a84c7724e26a2c9e" }, - "signature": "0x8fb8cb9373db269dd2a05fe0a07484db022a95b06c03807426a352499fcb65c55f8c388fd4cddbdd9936d5fe5ac5898e0d8b58ae09a73bdc7e584fe9940d3aa967607a0c4a1ad1ce5ccc0ad83f63a273e140ae0510f709cd0c214b645d68e3f4" + "signature": "0xa3779a97b60b64b43f1249ac6e49af7a02d87608ccbcca01b26cb226baf3d0a135b6d98d008f4417e714a1512ce07fbb18c6e491fa2e6cad5e1d9e29f56aedb856073cfa6f90cc9b21db6b3ea9cb35f3c9ec47ad48996650941b4b8d5e6355b7" }, { "message": { - "validator_index": "1047042", - "from_bls_pubkey": "0xb7d85608c3cf919ee72c0481283b468c2825850f6f6028c000cb19bff464556973909667d0353582d673e1049795f20c", - "to_execution_address": "0x778981428fb4ee8ab889aa659e81f2f2087d260a" + "validator_index": "277544", + "from_bls_pubkey": "0xae86d94e3803aa062745028c91f9eaeb957af12e0d1e1c479c3ee78dfa76d792c8778507bbe0f1aded55e48d10b94a8f", + "to_execution_address": "0x61eb2543106f8202e5365fa6788ab38459284212" }, - "signature": "0xa1079cff71763f60894927a0ac68cfff88642e5ec4e11d1f63ce7d7b15f2567842c80c0238a0f6e4d38ac2a9d09787c50c87daba460e05a0336332f1d37b65fed7526c5eb51a84d3a0169d09ddaf271d13710d22469e8dffde8859d50a2dd0a1" + "signature": "0x831796f518dd44cbddc77db8d223ab502edc7bab53c2795edb3879e4f79171f13e4b7d5c5f354e06314c6c1fec3988f703234fb99488ef541062ef7f8a89f77bd18b82f79db2328ec0cd6db498f5ab4412800e9e4a351fad3d609a192b0eae61" }, { "message": { - "validator_index": "2279280", - "from_bls_pubkey": "0xa46cb4c6f51759dd36e897cf8f5f8a774dbb5968defec8bcd85b9ec0f3d873a6569fabde6c6cf3fa5dc77e910bc39938", - "to_execution_address": "0x3aa93143d0d7c378fbb0904fd1788aea4c2244ee" + "validator_index": "1509782", + "from_bls_pubkey": "0x8c1cba560684965a1d17efcc10ac3e688808a44a655caef64fe19b0f11be06e324d48651b6d9663e33964737affaca25", + "to_execution_address": "0x872d1a435006418cd0bc2dfd1f9cdc1e652e4036" }, - "signature": "0x988ea703ce8fcbd5bc7811c49e1eede7061ce461966a9a52f03afdecb157f065a1993fd71ea29c6769121610fc9e3e190eff938fb8c2f77dcf5f511208ad23cf427c05dd207b6c6004ba2a1ee3b6a84949e39db4ef1ee254635d3527010f7794" + "signature": "0x8b8974bfbed37e66501f80a64e0d81d27723e76fb46afb5e94398a6b956254aabd7e9af026d996dee341f804951284140ba20654abb8af117f23f4afa0144a7ea57076a4a0fbc727d1f1111edf829a8cdca542799d24a5021c103ba2a23c75de" }, { "message": { - "validator_index": "1894531", - "from_bls_pubkey": "0xa18343c3306dae4ff3c78428069a4ae7876f0ad620219648b99b4bfaeea1d7898df50d508533e756f5903efbdf585076", - "to_execution_address": "0xf9f3f64210cc7c298f4e990115d157ed8b403aa2" + "validator_index": "1125033", + "from_bls_pubkey": "0xa127dd51be074dce1f11b15a9040d935aae14a0b073a7ab906edc1327f477e8213d96f738690b3f650a479dac373cbed", + "to_execution_address": "0x4678df4290faf93c645a36af63f4a921a44c36ea" }, - "signature": "0xa120e4f3144799db31e7487d25cbe6d8724f0076f23fdd7ff1f00b24b304a93a97862a3ebecb5e1b91018a0496a3c4020004b5d49571f4b9a3faf0f9d8f1f067d7005b5600db18872732313acf1350e1bec278384f3e0fe28d43f00203ae10e7" + "signature": "0x8657c885c3361cd4a58769798bf4baa0424238c9a2c5b20b79b6079ca67198cfdbc407cb9e4799663bc54543f1a74df8044006e589cfb7b5914cf77fb175cfb959b29861d42c3da17eb66102ad8afc8f20fb5e7f52934c385018e3db3bed9181" }, { "message": { - "validator_index": "2970787", - "from_bls_pubkey": "0xb23734206f673528ad12bad1b7815a9db722d7a5afffdfac97e17d453fcd2616a804619bd9f8db50b9547a357b1f5813", - "to_execution_address": "0x2036eb4250633bb379d46758bce28087974638c6" + "validator_index": "2045306", + "from_bls_pubkey": "0xa67a1e9a2522bca1507faa25403c3ba020af65ffe839656e87f957438ceec07d5d8a91658e9fe6efe8703f1b5d24ffe3", + "to_execution_address": "0xcfdc1742cf05a262f63eed727f20645e78b3144e" }, - "signature": "0x8de01f498b48fd1df0c20529228b7e8616c7bfc35457d392404110e394db4c884dad325363be1f2a83ac383486cdea460e78e89a728ac9464f71dfbc685ac8be3fb9ecb21d67a6c105354c58bfb78f2adf7ee65f5a4d7fbe5989e522b52daccf" + "signature": "0x8dc84218c00f49ed40442f962e7afeb1a8c2ef5f4ed0aa8eda187ace69d22cd62b759e44754a66edf611383434b0d7bb18ca3eace8402fdeaeb7a5ee16639ac7133defc018719cfdf5a771449cab814076545f41f6662202d42deda5857c93f2" }, { "message": { - "validator_index": "2430055", - "from_bls_pubkey": "0xb490d2df5759bb5115690df9aa805cddc1787b17fc3984ec400d03ccd5c6da6dbc54a724816ccf0c86b4b23e4daf0b17", - "to_execution_address": "0x42a3f4418ecbddffb5d058777555df2c9ec50eba" + "validator_index": "1660558", + "from_bls_pubkey": "0xa2cd1e8619ea096ad3130c8f2dfa725c44cc8aa06de4f186d87ecaa92251bee9bc08ae465d6ea48b145a4f70f0729e42", + "to_execution_address": "0x8e27dd410efa5a138adcf524c3783161b7d10a02" }, - "signature": "0x909ac7032213a33af76294ec19617f3fd9859bb22201e0502ae7187debe740c5cb0367ef03e944eab7fdc5ab23d303f916904a1ca5f7aadbcfbab89bdd82931dd7ff3e0efdd1135698f54774989ddd6d8ee07bebff863718c927072564a547bb" + "signature": "0x97f8c4c02c4241858c09d9f2926670619f01a2e88fe50b3f3456c7db24c1c470a30eb58790400f29abdb9a9db63e075315d7e7b359848e76d4c637247b6a2ae492bb237e4aad36764ebbc93a0836cc4962e51681e15f00dfa1429311b1140e4d" }, { "message": { - "validator_index": "506311", - "from_bls_pubkey": "0xa2810855686190fded08fbafafc427d3540a58c2b391c0d05a71be7a4d1aff2b4ea501c8e4c1ebb79cb49f1991ada976", - "to_execution_address": "0x68e5e841ce629c89a05627ce1c6708c7aacb0cde" + "validator_index": "2736813", + "from_bls_pubkey": "0x96057456506ff35b37222395a6cf87fec4386244d7ee0ecadd11c96e8f7975a312b6826bd69e069eed2e88fbae21439d", + "to_execution_address": "0xb469d1414e91199d7562c47b6a8a5afbc3d70826" }, - "signature": "0xa108770fd60463dfc982d8725440e47c54730329420bcf05a969e4937d06e468385b53c4a5f6c69e55a775f358fa0948171dedf3bb0ccc1679280251b7abe4cc644e10b46bcdaddd590951541bda68373c8a8dcbfb86d3cb97822a5dfc21f481" + "signature": "0x8734759600f9bdcc5a05f0c70f90062f0d0056ed8af19e4777fe4d5b67267fb33d2617d4630fd75822d0f1b60c70650a17fe6d16ec4fe2d4fdd2fd3433c357470dd8276a069a5402372a83091f40217805da560122e3d9ba5a98034b21191439" }, { "message": { - "validator_index": "121562", - "from_bls_pubkey": "0x8deafeba9f0184ffa1f3d1422b9d97d6975fc4d5a21df265b48b6e831d6aee5a6236b3d5fb9e03cab1e0795f3dd45206", - "to_execution_address": "0xc40d6a420fe36b9e8d954713eca4442721892252" + "validator_index": "2508047", + "from_bls_pubkey": "0xa22369476f4df72eaf9b15045c8986378cfe5dc68d31bffe0ba6095277b0e3320eefdff2756b96a81b49486a6f82d75f", + "to_execution_address": "0x109252428f11e9b162a1e4c03bc8965b3a951e9a" }, - "signature": "0xb489851f8a8fd535ee14505b9ae32ab27cd8d5e637236f491f71bfc987316491ef3f1b7670378875580eb247993d82511128502ea093d108730e070bb8c5919b39e78893139b3f1a499e885b15d385073e227d6a4e85ba0413ab9e2481d0b8da" + "signature": "0x81e23861cdfd31d1421bef1f77bbf68ca5579fd9d2790637fb395458e46477f9e53d0426e0b3d15ad7854fcd9206007e0ab75fe079579775fe8420250a31c2214c316f398e1bc319aa0c3130fa6d80902d7f68954aa3a7c663569aaa0d9731ca" } ], "blob_kzg_commitments": [ - "0xb1ec6f426f978c599752e0e7181c305a1b8623c06088b5480b9aad7fe5f419d6c81a8f6862abe50a5e8cadf8649d347c", - "0x109252428f11e9b162a1e4c03bc8965b3a951e9aef7381ebf01fff6828d9ae8bbeb86d42469047b0c205fd55488427fc", - "0x23b34c422f5dc8f657e44bec0e51ab2840981d2ca63caaa51da14231033a661656d833a140f1279e0a1e40020f4c8be2", - "0xea4f5e424f7a2a28771b166a93b66dc12d8f207683e22f77941d78d8741740768f79e18451ce86d434d576fdbaf45f2f", "0xfd705842efc5096d6c5e7d95673f828e34921f0839ab5831c29ebba04e78f7002799a7e34b2f67c27bedb9a981bcc315", "0x5d163b420f4066c536ad816e89ebe88f53a11ae2c99624d4a7240d8a925c8cb61d3786bd2f14c967df66090765a3b695" ] diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlindedBlockEIP7594.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlindedBlockEIP7594.json deleted file mode 100644 index ee89ad769bd..00000000000 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlindedBlockEIP7594.json +++ /dev/null @@ -1 +0,0 @@ -{"version":"eip7594","execution_payload_blinded":true,"execution_payload_value":"50756583220288449835724789919752990744036228048165053817930899246206127260481","consensus_block_value":"24799950324699182119107049583125116496986047597328004586475399986067975839137","data":{"slot":"1","proposer_index":"4666673844721362956","parent_root":"0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef","state_root":"0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e","body":{"randao_reveal":"0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71","eth1_data":{"deposit_root":"0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f","deposit_count":"4658411424342975020","block_hash":"0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379"},"graffiti":"0x0000000000000000000000000000000000000000000000000000000000000000","proposer_slashings":[{"signed_header_1":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b","state_root":"0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb","body_root":"0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486"},"signature":"0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483"},"signed_header_2":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6","state_root":"0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26","body_root":"0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1"},"signature":"0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1"}}],"attester_slashings":[{"attestation_1":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4580744678799082634","index":"4579092195582398506","beacon_block_root":"0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c","source":{"epoch":"533461240","root":"0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565"},"target":{"epoch":"538462976","root":"0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650"}},"signature":"0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc"},"attestation_2":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4620404293179370891","index":"4618751809962686763","beacon_block_root":"0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b","source":{"epoch":"538078227","root":"0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb"},"target":{"epoch":"536923980","root":"0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5"}},"signature":"0xa32991816eb9f297553b4732309a4cdba7b33287264611715b0ab3319bca19e581da6e2659912a4e0e94aafc01c488e30ffc96ed14e2a726b9d3c618405ee0bf54bf6ae7f2097465cb27ab8132ec24eb93d3c9159475304082f7f0e452b93b65"}}],"attestations":[{"aggregation_bits":"0xfa79cdb89d0d51c5cdd001b7425c6d726750a9d5f89ade6ed9890ce3a706140c399a5e10c90a819094b65322dac7501f7c75471e69d4567358d8ca75f7c1b3133ebecf006b369a1f36efc5f2b706d5922ff98c58a1825a53a864376658f816600cf021cea843d4396502bb9c74d1510afe26036f89f783b4f5c7bacb6649c46f217a6af835f312d6fa253d2bbc83c07993f4f10de2ed2d952689379dbe4f794c1a1055a6b364d68e038deec9667f576b3b9eca5fcadd6298f181e1edb876efc3d0975ae14ae9a0ad2f1836d4c3f1080a96d8ab7c43b34bb2eda895ff66be698b363cfa4be33da3ec94a1a7a90672fd12c4a59916bb937e78476e4f08e4f4031001","data":{"slot":"4605531939934246443","index":"4610489389584298827","beacon_block_root":"0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b","source":{"epoch":"529421377","root":"0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2"},"target":{"epoch":"529806126","root":"0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd"}},"signature":"0x8f8d16b39e14569aab1b712e5c19ed51afe3600a6b017e8ab432f43a02ee720a733c33ef087d2f3653a9701e8d8a836301655b9195c0373b775c88ba1368e5d55354a70a3096bd26dee29dddbe7a4820e2b1653e84122beacbc01af7d93e6bdc"},{"aggregation_bits":"0x4ac567b296efbf7cf3209e87096a7a1a50fd523400113f917f6584a5a306f06b2d8da9ae858d47ff2594010089838efe41f19a78d9aae27c2ffde26f278b8681db9d091eb72e7cab3e449dfccd46a270693e1f88f197324e57bfd45573315cf9fb60d770937b32f7c0c6ce1581ec51e6b60f71acfde304dc917f2e0aa7872038b7d9140d15f7927c23a0490a74c2b0aca2773fed9217067e4444f9ca93874e4ff8407111c3efdb138b97c6d4957b6a70ec1debb283e3d0eb1cfef068adcffbf057d20fdc339eae03f0fa2613abdde8158a7fc40c3cfd1117eb6f8c4ae21d6b2ab4b57ae9a8653a34451aee6418c0c3609dc937293f5f5b346a7ab1a0d144185101","data":{"slot":"4544390030852162633","index":"4542737547635478505","beacon_block_root":"0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd","source":{"epoch":"527690007","root":"0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8"},"target":{"epoch":"528074756","root":"0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8"}},"signature":"0x90309dd491ae6ed51917dc305a3d4ae68d0a0d4792c7eb59c193bd03605bd94e61cab37502de0ad3e6162bc02427bba80a798b3670d5de82a854094016cc298b265371345c0e3ac49fd44bbb9ba0d4fcea0c1a80cecb60e93921d907e8c48120"},{"aggregation_bits":"0xe8c9759f0840f980ae956b15fc383d992e7d4420d12ba5bf32f669f446ac6fa388e20e5ce96e9266dd98840179d2cde3cabd9a8bafab5dec9c2e89f7f78c989e690548603984803b80c82d7b76443194576a1ce49da5cfe56f56e83b745fb01b5f18ccc86d88f5a22d927e64ff0b8e880893abcddec45b268531c4a0697537dae643a24b1a36432f37d42962553bd39af71f37e0429b81470c11316aa39db074aa3f1df4124e7cb203debed60b885ffb9b27e46a1434e81bbd56566632d0729c0822ac415cbb67f25973667d88e58df9c2f058a0ae7f118c98cc448453b6fbe590363bd17ed62c2f808df61f2a9e593235eeb56db74b9dd15980189a5271468301","data":{"slot":"4529517677607038185","index":"4574134745932346122","beacon_block_root":"0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947","source":{"epoch":"532884117","root":"0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31"},"target":{"epoch":"531729870","root":"0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672"}},"signature":"0x8c40f51a99fce6ebb9a4db5e80d715fff319e7ae523e46afb5d03c000d427e23c7a39e77e2af53851706283c8ca91d680997cb459386fbdff52c4d0ecf498e173717a838a792b210bdffaf476538628584a133899bf30dd5ce7056463b8cd683"}],"deposits":[{"proof":["0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c"],"data":{"pubkey":"0xb1f8f6e731dbf6b4e3265fb857c7190adbfc7e6cc95ce2e8bda72be8b6ea3459f862310a2484c3b0ee33b30920f18c1d","withdrawal_credentials":"0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c","amount":"32000000000","signature":"0xb594382214f5bdd375de66c45e1c61a526c7b73fb166c72433bbd9c2a7ad6881244e61cc6427e0206a50b762a129d8830e8708c55761d61ce9e3b19c1bee13bc55daa13bdb07118efdbf57a588b8a64e6392d14f935e53b68933e3355b35acdb"}}],"voluntary_exits":[{"message":{"epoch":"4562567354825622634","validator_index":"4564219838042306762"},"signature":"0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e"}],"sync_aggregate":{"sync_committee_bits":"0x01000000","sync_committee_signature":"0x919ee45cc18456f6e85da6bc21c2e40f44f9a887932c73ea9ad354f88e56d4ec0a8c396ed143082c8e31d697b877a2a215d2966d91c7beb156bf7ab5777e210012f70dcd5f7657808a82cba51e194be994f917150ebdb9e5c57476f1edb47206"},"execution_payload_header":{"parent_hash":"0xf8eb5a3ea82ccf3c1be1ac153e3f77f273a07343291711b9de6b9dbebc4c9b49","fee_recipient":"0xbf886c3ec849316e3b187793c3a4398b6097768d","state_root":"0xd2a9663e689510b3305bdebe972d4e58669a751fbc85bf448269162e078b2c34","receipts_root":"0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9","logs_bloom":"0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d078748f9069c96e9d6a2801cf607000a52447e46e1bef4e056ee30d4bd3517aaf7bf65ba04dd28c3a4a14b8dc72a300f051722a6814fa3931d90a82d23285d4c1127b6c67bbc4f8682ddbf9b31eb3114c26dccc5330109d6f17799339c2d7ed7e4e3a7de5d515106aaec7be6d78be3e21806d6d30c39b77c75dcf354b63033fb200b3b9dc023d948278f0956c0ee99323da0162f2a84b6a95749d2fa1d4e089af416d412ccd992683f7e41f7b496ca04f9f463806e3643d1c07f39d2a65f84e97b7dfaafac740d1e03f30923a4270fcf651ad2ca3737859a524e86e02229a55abd1a7","prev_randao":"0x0c0d553e4878ae811024144112c88bbf79a372d5dfdf39730cede08696ad52d4","block_number":"4489858063226749928","gas_limit":"4481595642848361992","gas_used":"4479943159631677864","timestamp":"4484900609281730248","extra_data":"0x6bb2373e68f20adada72181a3474f2c098b26daf6fcb0516f0723270da91e789","base_fee_per_gas":"91973405088222260025272995045243630915786868313949746451634391325697029602367","block_hash":"0xde78143e27b846779904841e2aa96d8fbec4671bb57ffa72037ac721f8d633ca","transactions_root":"0xa415263e48d5a8a8ba3b4e9caf0e3028abbb6a65922580447af6fcc869b40d2a","withdrawals_root":"0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be","blob_gas_used":"4476638188903342311","excess_blob_gas":"4521255257228650249"},"bls_to_execution_changes":[{"message":{"validator_index":"573888","from_bls_pubkey":"0xb8343e90edaecc9df1223293465ec067b3c9804f43e25817d27f1f4785bc5f554462032370781d9c65ab27bcc3d21415","to_execution_address":"0xdafbb23e48beb933bcf49f8ad83a43ee157382b5"},"signature":"0xa519e1354ad927358404a58bdc19113e5fd97d5cc19943888e22105ee943ca216a14898283fc3712500ba767de00022905e4198939b44a5f5a43fa0c87252969c56a26345135572101b257f87245a5e42fb2407a0ee67a6c2d039bf908b9aa8b"},{"message":{"validator_index":"189139","from_bls_pubkey":"0xa9ddce0cab5b51d3d2c710396b85e3fd7a87f1738fb5cfd5a7b25dbb483c167a80e785cb4ca7250c14a60cc282b1d9b8","to_execution_address":"0x9946783e88b272e45092a83c1c9310f154917869"},"signature":"0x8edfb3b9ed80067d0626019a1be330bac43c7ecd813f7ce781d0e6e34fb583803e9d2b047ad3294d6d3a54d020c68231085f7d9085d0afefb047def063a4698277e66d4a560f4b5bbd16586976f0bcf90177c00abd4a1b4cbd0ac393e5b904b5"},{"message":{"validator_index":"2357271","from_bls_pubkey":"0xa287d120292890ab1aa49bae1e3cd88bb160b5640f18c64f1aabae5990616e53099fe61698c3b812e2bc2ae6b6965960","to_execution_address":"0x09988f43d11dcf2aa7811c9997eb4119e8f153ce"},"signature":"0x8ca190827c66ff26c1fa594eae169b7efbd84c9456304f2194df7b0c204b0a29ac53034c9b20e4977b8e8b46d6b246da03a9337d3bf5e6f7ac941407a2a3437d7e2c0dcacda29b7623141833e02b4b12350ccaf8b27dbf96b3c520078f49efe2"},{"message":{"validator_index":"1972522","from_bls_pubkey":"0x8db8ee645b614f990839e4d98fdbf921263bb62cd917fb4eff9084dff23d7cc453f6cc645ad8b869aa9d31a6b9560630","to_execution_address":"0xc8e25443111288db3b1f254bdb430f1c27104a82"},"signature":"0xb0c3172e9bab8d04faa5d27f9818c36ad61a71b114f5bd9dbe77306be3edef2bcb56c215511ba76145006daec95f24be0f1f0dd24377cf7b440b5cdc7d0b520d6b64c539eaacaf14875d49c293af5974751bb0ce2daafde3bd01e097a466e75f"},{"message":{"validator_index":"48778","from_bls_pubkey":"0x8ba697cdd6f8c34a1fb96a4c88f03360d19515ccc4e1ea24aa5e80075d821059806a0047e6bbf5d908d312d1902aff5d","to_execution_address":"0xee24494351a9466526a5f3a1825538b6331648a6"},"signature":"0x87fadfd11bc5612e06c59d576c91599bc21095531fcc27a177967de7b521c377ee7a2b10d0fadf38779089929cfe136518757803c369b4ce94873e28d7d9cdf54c31a53ed86b07f76ea6104ee65d76de02267a4b736c949785ef233cbb73ad4a"},{"message":{"validator_index":"2820011","from_bls_pubkey":"0xa32a5f28ae7d36f888820160335232fc42ef994b4f93acf6a8659762b2ec52ca79354cc07c73a229b529bfcebc705eff","to_execution_address":"0x4a4dca439229167a13e413e752937416aad35d1a"},"signature":"0xa2089742415bdf32fa2dde853661a095ac24d273413687ae04fabb99ae2982700bcdb885d239e32543ffb95763a43e690cb1bf3a33df40d24e12c46d150e9c59dd63f960dec39712dabf74c08a55ba1bcb6db664ff9d5b2261da353e4374466c"},{"message":{"validator_index":"896267","from_bls_pubkey":"0xb679b4b686530827b2a201eb2b18454e9a5758d7257737b29bb215b9f354c2ff57e912b19d4a051556187aa24c97371b","to_execution_address":"0x708fbe43d1c0d403fd69e23dfaa49db0b6d95b3e"},"signature":"0x8da9cee45a3046b209da332512a6b4e4d7c89768f55998eb79ee236b4fb1fbcea87e0bba7b05d19ea7b8c5ea6dc0081e17a7ad0ec41566a0c6d9e127b87691e1d5b823fd178069e3f30091dcdbb44c36408656941755177c45bc976bf270289d"},{"message":{"validator_index":"511518","from_bls_pubkey":"0x83b8c61b63de768821cbd82ee3c67c81bb848163d6af0186ffe1ca3936d283bb4cab886f3fbc7f6336fec3da8d542c76","to_execution_address":"0x92fcc742102977503966d35cb217fc55bd583232"},"signature":"0x8c90298abaed4b5124cff46e41c9a4ed2b2baa0d2089add6b64c70dc7547f1a83bed76aba1fac6d36605beea72734b490b7b98994c7c65fdb436286b0df898731f6ad536e5a603da85ec8cc4488b94dc8c61e11363d1cc18733382dca51c7008"},{"message":{"validator_index":"1431791","from_bls_pubkey":"0xa532ee397fdd9e388888d90f712e13b085ad5043402debe1caf3dabbb514ed0d06f7c897e4e2795fd018cd672bfa8948","to_execution_address":"0xb83ebc4250c035da23eca1b3592925f0c95e3056"},"signature":"0x8fb8cb9373db269dd2a05fe0a07484db022a95b06c03807426a352499fcb65c55f8c388fd4cddbdd9936d5fe5ac5898e0d8b58ae09a73bdc7e584fe9940d3aa967607a0c4a1ad1ce5ccc0ad83f63a273e140ae0510f709cd0c214b645d68e3f4"},{"message":{"validator_index":"1047042","from_bls_pubkey":"0xb7d85608c3cf919ee72c0481283b468c2825850f6f6028c000cb19bff464556973909667d0353582d673e1049795f20c","to_execution_address":"0x778981428fb4ee8ab889aa659e81f2f2087d260a"},"signature":"0xa1079cff71763f60894927a0ac68cfff88642e5ec4e11d1f63ce7d7b15f2567842c80c0238a0f6e4d38ac2a9d09787c50c87daba460e05a0336332f1d37b65fed7526c5eb51a84d3a0169d09ddaf271d13710d22469e8dffde8859d50a2dd0a1"},{"message":{"validator_index":"2279280","from_bls_pubkey":"0xa46cb4c6f51759dd36e897cf8f5f8a774dbb5968defec8bcd85b9ec0f3d873a6569fabde6c6cf3fa5dc77e910bc39938","to_execution_address":"0x3aa93143d0d7c378fbb0904fd1788aea4c2244ee"},"signature":"0x988ea703ce8fcbd5bc7811c49e1eede7061ce461966a9a52f03afdecb157f065a1993fd71ea29c6769121610fc9e3e190eff938fb8c2f77dcf5f511208ad23cf427c05dd207b6c6004ba2a1ee3b6a84949e39db4ef1ee254635d3527010f7794"},{"message":{"validator_index":"1894531","from_bls_pubkey":"0xa18343c3306dae4ff3c78428069a4ae7876f0ad620219648b99b4bfaeea1d7898df50d508533e756f5903efbdf585076","to_execution_address":"0xf9f3f64210cc7c298f4e990115d157ed8b403aa2"},"signature":"0xa120e4f3144799db31e7487d25cbe6d8724f0076f23fdd7ff1f00b24b304a93a97862a3ebecb5e1b91018a0496a3c4020004b5d49571f4b9a3faf0f9d8f1f067d7005b5600db18872732313acf1350e1bec278384f3e0fe28d43f00203ae10e7"},{"message":{"validator_index":"2970787","from_bls_pubkey":"0xb23734206f673528ad12bad1b7815a9db722d7a5afffdfac97e17d453fcd2616a804619bd9f8db50b9547a357b1f5813","to_execution_address":"0x2036eb4250633bb379d46758bce28087974638c6"},"signature":"0x8de01f498b48fd1df0c20529228b7e8616c7bfc35457d392404110e394db4c884dad325363be1f2a83ac383486cdea460e78e89a728ac9464f71dfbc685ac8be3fb9ecb21d67a6c105354c58bfb78f2adf7ee65f5a4d7fbe5989e522b52daccf"},{"message":{"validator_index":"2430055","from_bls_pubkey":"0xb490d2df5759bb5115690df9aa805cddc1787b17fc3984ec400d03ccd5c6da6dbc54a724816ccf0c86b4b23e4daf0b17","to_execution_address":"0x42a3f4418ecbddffb5d058777555df2c9ec50eba"},"signature":"0x909ac7032213a33af76294ec19617f3fd9859bb22201e0502ae7187debe740c5cb0367ef03e944eab7fdc5ab23d303f916904a1ca5f7aadbcfbab89bdd82931dd7ff3e0efdd1135698f54774989ddd6d8ee07bebff863718c927072564a547bb"},{"message":{"validator_index":"506311","from_bls_pubkey":"0xa2810855686190fded08fbafafc427d3540a58c2b391c0d05a71be7a4d1aff2b4ea501c8e4c1ebb79cb49f1991ada976","to_execution_address":"0x68e5e841ce629c89a05627ce1c6708c7aacb0cde"},"signature":"0xa108770fd60463dfc982d8725440e47c54730329420bcf05a969e4937d06e468385b53c4a5f6c69e55a775f358fa0948171dedf3bb0ccc1679280251b7abe4cc644e10b46bcdaddd590951541bda68373c8a8dcbfb86d3cb97822a5dfc21f481"},{"message":{"validator_index":"121562","from_bls_pubkey":"0x8deafeba9f0184ffa1f3d1422b9d97d6975fc4d5a21df265b48b6e831d6aee5a6236b3d5fb9e03cab1e0795f3dd45206","to_execution_address":"0xc40d6a420fe36b9e8d954713eca4442721892252"},"signature":"0xb489851f8a8fd535ee14505b9ae32ab27cd8d5e637236f491f71bfc987316491ef3f1b7670378875580eb247993d82511128502ea093d108730e070bb8c5919b39e78893139b3f1a499e885b15d385073e227d6a4e85ba0413ab9e2481d0b8da"}],"blob_kzg_commitments":["0xb1ec6f426f978c599752e0e7181c305a1b8623c06088b5480b9aad7fe5f419d6c81a8f6862abe50a5e8cadf8649d347c","0x109252428f11e9b162a1e4c03bc8965b3a951e9aef7381ebf01fff6828d9ae8bbeb86d42469047b0c205fd55488427fc","0x23b34c422f5dc8f657e44bec0e51ab2840981d2ca63caaa51da14231033a661656d833a140f1279e0a1e40020f4c8be2","0xea4f5e424f7a2a28771b166a93b66dc12d8f207683e22f77941d78d8741740768f79e18451ce86d434d576fdbaf45f2f","0xfd705842efc5096d6c5e7d95673f828e34921f0839ab5831c29ebba04e78f7002799a7e34b2f67c27bedb9a981bcc315","0x5d163b420f4066c536ad816e89ebe88f53a11ae2c99624d4a7240d8a925c8cb61d3786bd2f14c967df66090765a3b695"]}}} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlindedBlockELECTRA.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlindedBlockELECTRA.json new file mode 100644 index 00000000000..3224d4c64ab --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlindedBlockELECTRA.json @@ -0,0 +1,391 @@ +{ + "version": "electra", + "execution_payload_blinded": true, + "execution_payload_value": "52335047088093692175629908587741169571103578927521980677976976500308305025762", + "consensus_block_value": "60987255743756591490802410911397502078420277537860810465656654307850393571949", + "data": { + "slot": "1", + "proposer_index": "4666673844721362956", + "parent_root": "0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef", + "state_root": "0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e", + "body": { + "randao_reveal": "0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71", + "eth1_data": { + "deposit_root": "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f", + "deposit_count": "4658411424342975020", + "block_hash": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + }, + "graffiti": "0x0000000000000000000000000000000000000000000000000000000000000000", + "proposer_slashings": [ + { + "signed_header_1": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b", + "state_root": "0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb", + "body_root": "0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486" + }, + "signature": "0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483" + }, + "signed_header_2": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6", + "state_root": "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "body_root": "0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1" + }, + "signature": "0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1" + } + } + ], + "attester_slashings": [ + { + "attestation_1": { + "attesting_indices": [ + "4590659586689121994", + "4589007099177470570", + "4580744678799082634" + ], + "data": { + "slot": "4579092195582398506", + "index": "4584049649527418186", + "beacon_block_root": "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06", + "source": { + "epoch": "538655350", + "root": "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0" + }, + "target": { + "epoch": "539040099", + "root": "0xda533c406bf3482d8e6e992e756be34172a8c47fc1cc0018350bfe98c946deda" + } + }, + "signature": "0x8bfc6e1a1c76bdafb4d491ce02a35effde6d7362eb32c03f119c47c12fb2b49e7656bbd4702ba02560fd7fe117f2c74e02142ce46176ebf269d5b34a48a65525e35db6cc446965e86e22e9d8adf5abe92315690b6de5f4591769487539fed52a" + }, + "attestation_2": { + "attesting_indices": [ + "4590659586689121994", + "4589007099177470570", + "4580744678799082634" + ], + "data": { + "slot": "4618751809962686763", + "index": "4623709263907706443", + "beacon_block_root": "0x27d82440eb21c640637a36dcc38e35768bb4c0c79aefa300ec0f0cba32cabb05", + "source": { + "epoch": "537116355", + "root": "0x999e0140abe701de220ca2e0b9c3b044b1c6ba33e0a3985dfe16a16b510f0846" + }, + "target": { + "epoch": "537501104", + "root": "0x735c0d406b5043543786d38912b287aaa4c0bc0f731247e9a3141adb9c4d9930" + } + }, + "signature": "0xb2213ef588828a7c18cdc781d0ed2516fd3e11de625f191aae7ae4be8b1ad2cc217728c65a500aedea276d345f09fd3212b009568a6549f5f40ead6d7ec4d0f3f329c00a1b4bca59068ee0555c94aec91bebc18365ca0b2d6692557b4b0c4267" + } + } + ], + "attestations": [ + { + "aggregation_bits": "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", + "data": { + "slot": "4608836906367614699", + "index": "4547695001580498185", + "beacon_block_root": "0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2", + "source": { + "epoch": "529806126", + "root": "0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd" + }, + "target": { + "epoch": "528651879", + "root": "0xe24dff3e29e762b4488e615619483884c44b8f4b37239b5cdc4a3bd7d9b48c1d" + } + }, + "signature": "0x913ce44a60f20df0261b53d8031d13f3a8d51cf53ba5eb65735ae960623c48acd56286b31ecd74cdaf51f66b2b2331fa0e907e8cb9d4dde513ca29cc34ee9925301bb541055a8daef33bb3e1fb8442a4a033f93f86933bc35fd2ce34a569a6ef", + "committee_bits": "0x0c" + }, + { + "aggregation_bits": "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", + "data": { + "slot": "4537780097985426121", + "index": "4536127614768741993", + "beacon_block_root": "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8", + "source": { + "epoch": "526920509", + "root": "0x41f3e13e4961bf0c12dd652f3bf49e85e35a8a25c70e67ffc1d08cc01d9921d3" + }, + "target": { + "epoch": "527305258", + "root": "0x51977a3f0ab3110e2a10e9c6bd0e89b1410ca45142ac42171bb2b169efc281bc" + } + }, + "signature": "0xa17225b5e5319618e77f5b93350430acfadd8ae12a279f1a4176cc7ad1de7ecfc8670988519713fbac8f702cca29bddb14ff1463dae3abb53ddb0c025cd69c8cfb0f5298ab241c06ddb840c7a260f3dbd37120826b13b17e22d086148ebdbab1", + "committee_bits": "0x02" + }, + { + "aggregation_bits": "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", + "data": { + "slot": "4565872325553958186", + "index": "4570829775204010570", + "beacon_block_root": "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", + "source": { + "epoch": "530960372", + "root": "0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c" + }, + "target": { + "epoch": "531345121", + "root": "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587" + } + }, + "signature": "0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e", + "committee_bits": "0x06" + } + ], + "deposits": [ + { + "proof": [ + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27" + ], + "data": { + "pubkey": "0xa56023832292eec3040299a0164c844769e854beba275c44e4960ab2da7ee11db36674e1e2fa2615bc5e247a2759a472", + "withdrawal_credentials": "0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be", + "amount": "32000000000", + "signature": "0xa9900942897c434e743c2b0210ec3266920ec6a624ed13b3637c640c7f79ba57a240a7e6a48cf587f71b9007616972821680ff0ca62c4cd47d50145bac76df28d9fbf3f56c98a5e8bd61b8cb41bdc02e3179ea961c2949c0803c108425dfa29d" + } + } + ], + "voluntary_exits": [ + { + "message": { + "epoch": "4498120483605137864", + "validator_index": "4493163029660118184" + }, + "signature": "0x86e947b46923b26125a7dab3240481ddc1b910c1e6393b90df6e2de3809b8b35e450dc8264ecedd8f6bfc736e7114d841428b2469441d2d1d501015eb99e0d7090f11a1185b566dc42f94b79d0a08b22718a39b57e912a304419361108434ec8" + } + ], + "sync_aggregate": { + "sync_committee_bits": "0x01000000", + "sync_committee_signature": "0xb2c1728d5efb4c0577aff84d84d5b0b2a89c22e1a97f2fb468442a8c2f84eb0912077b32ddd66ac5ce05168ab26168e40ddb8dadbed42b229c34e78cc757421908ab6159082952a43133f5333ad2f8382930bead6ab4f0e91c95ed9c66f634f1" + }, + "execution_payload_header": { + "parent_hash": "0x7ed3313e083eea1ecfb57f4508fd068e9fb56c4125942ed01ef47538b5f29e14", + "fee_recipient": "0x91f42b3ea889c963c4f8e670db851b5ba5b86bd3", + "state_root": "0x58913d3ec8a62b95e52fb1ee60ebddf392af6e1db902dd5bc3f1eea7003130ff", + "receipts_root": "0x6bb2373e68f20adada72181a3474f2c098b26daf6fcb0516f0723270da91e789", + "logs_bloom": "0xcb571a3e876c6732a4c11cf3562059c2b8c16889ffb6d1b8d5f883591e767c3fb46dd46047448da9f4783626721bdf9308a2cefba364d5b6b2653a014d0c2bf6f7722e4c3bbe594bb639fb9b0489d49f463e19d5547ce33fc497f70c977a3205fedaf8ccc0bdc1801c8a18154948c8e670813e0c98f6e92e20d4327c71f2de5e7aaf1df92739504e383a1977928614c2078d5a61289ac612f9e3b08ea9406604db94fb2a3424f245843ce722c6edaaf79085661b750ed7b62cf57a68de63b899dbde6c169f2a65bd5b0e808bdf22c850136f4c1421be8865b50aa17c03735c41f4b4ec5a973ad30c7db09d4a6894284b9f19eafb8189121738fda9d6e0d393f7", + "prev_randao": "0xde78143e27b846779904841e2aa96d8fbec4671bb57ffa72037ac721f8d633ca", + "block_number": "4478290672120026440", + "gas_limit": "4476638188903342311", + "gas_used": "4521255257228650249", + "timestamp": "4519602774011966121", + "extra_data": "0x8e77ca3ec98f3c20e7e802dd8917f1b9fc66866da0310ae878d59ae1871cfffd", + "base_fee_per_gas": "73092283800700793286468708950267523415056945357667839430375913972420161943176", + "block_hash": "0x003ea73e885578bda77a6ee17f4c6c88227980d9e6e5fe448bdc2f93a5614b3e", + "transactions_root": "0x135fa13e28a157029cbdd50c53d58055287c7f6b9dae27ffb95d735b7fc202c9", + "withdrawals_root": "0x1f2e4f3ee8c38dc605677b6ce650a08c7fa6716795a8622d396e244f710e0a5f", + "blob_gas_used": "4517950290795281992", + "excess_blob_gas": "4516297807578597864" + }, + "bls_to_execution_changes": [ + { + "message": { + "validator_index": "2996764", + "from_bls_pubkey": "0xa2cd8bc71b19dea2f97e5918a5ad8205b4937a07537f9d84206f15ad383c25e65249dbb53d559acb700bb4f59297896c", + "to_execution_address": "0xac67723e28fe512946d50f68f01b25be5a9477fb" + }, + "signature": "0x99f5bc997861976d73013dd4c06f42a2318912e5e075a2746840bb34134e7f4765ba88dec12f4bd5d2fa24d7bc2c17ce105bfb796108064499faaa4d4b3e17db6e62bc88f8e0a6243105b01c00302c3d9f81f5e790d6a6951532ac94c19d1114" + }, + { + "message": { + "validator_index": "2164897", + "from_bls_pubkey": "0xaa4811100ca7dc5c90d84205000ffd9d70eaa3c650ff0391ce7c3f5eed59f12e4ac5e080f4ee6e30354294ebca28c93d", + "to_execution_address": "0x1cb989437169ae6f9cc483c46a7456e6eff45260" + }, + "signature": "0x833c3424606fa52c035536e38b8c677a1b922a8d35cc38b55e6f057725893ff621d9f49153fcda3af9d7cde737ee0c830e3189e94a62a8d655c328f7b3c77142c53a3e9f6029e16d22ace761f8e60f4b28f2b487821be3272e1905598649f1a0" + }, + { + "message": { + "validator_index": "1780148", + "from_bls_pubkey": "0x98d6103215e3916a0cff3af6b6f29f22374a32d87d440a302e18a9e2daa80b32a2824798030f6a2e06ab612b07c41f74", + "to_execution_address": "0xdb034f43b15d672031628c76afcc23e92d134914" + }, + "signature": "0xa2f3dc0cbadf0807f2d864d0c98c2e474972419b1ef936d0c68976eb732a146c8bd86194e95381d1b9245530b1f138cc0de425bd6478bc56a394619e1192a114680c4e9f8b0278816bd4f5df9e24cc31ca73cf5eb26da54eebf958966d4a957f" + }, + { + "message": { + "validator_index": "2856403", + "from_bls_pubkey": "0xac60d2ec631e27b37f4f5541319b94c8cf82299d71ae4139039cbc1d0c30c71a075cb62166801ccd0a56f0bc29edcdae", + "to_execution_address": "0x01464343f1f425aa1be85acd56de4c833a194738" + }, + "signature": "0x818852c88a6e16f2294cb51803a155dcac4f6ec5ee0d095e8890be8907201ee1c8790abb6d5f05faa2b3d8d9a03972800a04fc1666d877c7cbfb62c387d6e119f8f827ea2ba94d5b6429b33d6f3770b79999da3cb8ed17f2c8977234bd2a1cdc" + }, + { + "message": { + "validator_index": "2627637", + "from_bls_pubkey": "0x92f00f85478ad1224c1be3a9b9230444411e9a2beeb6304e5c1fba1b7b54c9ecc3965abeb3385e4916040260544b2580", + "to_execution_address": "0x5d6ec4433175f5be08277b12261c89e3b0d65cac" + }, + "signature": "0x8b13ef837950d00a469eae427c1fea111ea85e0dfd63c09bdc02aec208523ec4c805595639d50e183dc893022f60abd8118d62c836b6d4de057967f80184532c1c3a25b26c51926a07e55d2ba264de6fd22eb0665668cc7280bbcdfdfdb3c0b6" + }, + { + "message": { + "validator_index": "703892", + "from_bls_pubkey": "0x8939b0ed4fd0659427739e525d6990c02614d703d12c5adaa5f8aeedf64fb9ce66e769d83f9ec61ec05c6074d5095955", + "to_execution_address": "0x83b0b843710cb448f2ac4969cd2db27dbddc5ad0" + }, + "signature": "0x8f65a298124021cf26323bea9328da795a7f2134f42c21e28617a1b663c568058fa3ddff9a71948362e7380cfb591ec9062f735067b1a32bd2b88e9c2d5c3404348a194098c30f55f8cc050b305bc4c2baeb2a6e4ab1d49833bd7ec4943367f0" + }, + { + "message": { + "validator_index": "319143", + "from_bls_pubkey": "0x8f5f289f8ae538eca9f393fd7ed1a5432ba4c145b700075d1a8ea9530ec8cba3b91511e78662d0f2bed026a1b86d6d2b", + "to_execution_address": "0xa51dc242b07456952ea93a8886a01023c35b31c4" + }, + "signature": "0xa23a1e6d9410ecb12fe95fbdb3b12962bd46855fa46ccd7b2fe75696cd4b1788302d6fc3bc1c1bc6f8080d0025b3fdc9139a3b141407213b8123563622773e9b385473bcd03f149b0ea21e52626382dba56b95a2204178c2c454001c79289afb" + }, + { + "message": { + "validator_index": "1239417", + "from_bls_pubkey": "0xace9988853ce03390f8d5c93fa51e3a5f5b056bef4ed1f437a86c59fb687be25d0e6f4be5beeec4bc04806e93c3eebf7", + "to_execution_address": "0xcb5fb642f00b151f192f09df2db239bdd0612fe8" + }, + "signature": "0xa0053dab17b7e0ba64416b1c95b6c56ecb7f39ccc272cd57a347054fab6781ab8d834eda1a4e57ac5b037d3b71945d1805216ba518aefad29922f57f1b3149151d4266ae944b579de5399a209e482a19d3fd7e9c02069e7a01ab2e9a59477326" + }, + { + "message": { + "validator_index": "854668", + "from_bls_pubkey": "0x85a2763ffc316d21106869ce72f88e6e5aa3ffcb84689aea186a7de5056f0fa98f50ce3bcfb8a96d33585c472748b014", + "to_execution_address": "0x8aaa7b422f00cecfadcc1191710a07c00e80259c" + }, + "signature": "0x84ff1208ba8c36a14bcf8c5d3c9d9e22dd6d69f7053eaba3ce96cf7ca324ec3c3a2bd097053788b7dc64d7dbccc30ebd07fbaf41e95ae397751f8aadbc4d84219038b55e1fb3785a8f7ceebe05d629ce2c9c407bb9be6c66c0d26c14b3a7c3c2" + }, + { + "message": { + "validator_index": "2086906", + "from_bls_pubkey": "0x8f220bb09673d250a17cdd562f33ca615e83e293a43e1313a9c3e9438c218cfa9a803426d29e9bffdd884daecf7e0ac6", + "to_execution_address": "0x4dca2b437023a3bdf0f3f77aa4019fb753254380" + }, + "signature": "0x81d6211b8ee9652820795832982520799ba2eab947083a2c6e56d9cdf1e678b1c1a6c8a108ece8b1c23b234a208e6e281477d55c41fc3d04027032277fa0922a0370e76db742037a0688697f618b8b7780cbfb3725f78bf9c5f94876d9d1957a" + }, + { + "message": { + "validator_index": "1702157", + "from_bls_pubkey": "0xb63a024e98bf28daf9bf8bdcb7c89d823f29e65e362a923afec6c78aef21559a12d2c5cdf81998630ac418034c0e58ed", + "to_execution_address": "0x0c15f142b0175c6e8491002de9596cba91433934" + }, + "signature": "0xa386f611424c8ec936f7ef72da9d526823e3bd03f3452131910b7c5ae646a989c276001faa9398ff3ce9050cc0282c5003ee9357b8485f4c52a4321e9c5150d39cebf18546badc0a22d7d881a08bfcd1e76c4a7c9c8cd7f85da5270877698c7a" + }, + { + "message": { + "validator_index": "2778412", + "from_bls_pubkey": "0x90961673ed2682e726960a035e0d1e050ff0754225f97fb7501110e474cee35f7ed1bdeb70eebc97a59abbd7217bc691", + "to_execution_address": "0x3357e542f0ae1af86f17cf83906b95549e493758" + }, + "signature": "0x9590d1d0c5216aeacaa19bb58a4a66a6430e554a0b020e2977be2421bcd089fb47bccbe10f2baac88dee33fc625dd5441217042918ac793c0aa2aba45a379decdb018b7bdd277f2a66b122a95aa1974cb05208e00801ed52f7f86b671c372e2f" + }, + { + "message": { + "validator_index": "2237681", + "from_bls_pubkey": "0xa63d491bd47a8f4caf987b7a22f228dc709f8f4a0d8ac25ed72a18cbe2b2da7662daafbe182b33c81e14eac70bc2f0d5", + "to_execution_address": "0x55c4ee412e17bd44aa13c0a248def3f9a4c80d4c" + }, + "signature": "0x8e4e43252f668d04559aa2ecf1ae7605a054c1fc2d5b0a9b77f9b091b8fd851ef5a02d54ed31a66053144d0319d8f4ac11185d05cd68099841cc554c99de314a291e83c4bd166b924240d4851d8ff63a05c62def40f8b839f087a60db6ef5172" + }, + { + "message": { + "validator_index": "313936", + "from_bls_pubkey": "0x856c75ede282fb092c2c5ce1511945d4eb5026a095e7ebb8ab6a231ef8884390141d100ecc904fdd58b1f2f0e07b1630", + "to_execution_address": "0x7b06e3416eae7bce95998ef9f0ef1c94b1ce0b70" + }, + "signature": "0xa31249a2500d0428a2b38100b6db1191f1014087af8e58cdc025e28fc9e2aa5f08c74036c1c99b5e6b9f96c250700e2505201e2d4657bff1de53e01ac3c28f2f6624da4e953c9d08b0011e547902197fc5317daa051526f68684f16e1608ff33" + }, + { + "message": { + "validator_index": "2929187", + "from_bls_pubkey": "0xaa842a4b0acf1250c953110bfa6025bc646043fc268749af5274dd0197f06eafd7f5ec00e2d21a01b8a420e8178bf74d", + "to_execution_address": "0xd72e6442af2e4be382d8ae3ec02d59f4278c21e4" + }, + "signature": "0xa29e82672b9b023ec4496bc5ba26cd0e12ae4e168591a2412dc2c62cfbf0466710810999921e34e7249e3a4700c837ec115bb6bee111a50c55a1af9d2f996bb6600a4767e23781cf4eb177845372b39df6156906f9e24c5b908920161a44d8fa" + }, + { + "message": { + "validator_index": "1161425", + "from_bls_pubkey": "0xaf50133072b8d7a0ab9318facb15087021cdde3205929004ecae6df99d4cc111517fb629146398eb345a028d413624ac", + "to_execution_address": "0xfd705842efc5096d6c5e7d95673f828e34921f08" + }, + "signature": "0xa34048285c5a03bac9edfcf306e845a8cc0f8e7f7b4c5590dce0146b30b5a4d6340855b4384b53cc72b4ac5bb9b372590a7f7eca40e78ef3ae9b0e9dfe020abc94d161627ff642df1386143f221aee8ba432f4e7affa7736c65a01e6f342cd4d" + } + ], + "blob_kzg_commitments": [ + "0x36d44642cfa8a73b4c27b317e2d9bff5469b1cbe5c05d35f4b2286f9dd9a1da1edf7f9ff3b52088c513683aed613efc8", + "0x49f540426ff48680416a1a43b562d4c24d9e1b5012cefb1979a3c9c1b8fbd42b8517c05e35b3e879984ec65a9ddb52af", + "0xa99a23428f6ee3d80bb91e1cd80e3bc46cad162aa2b9c7bc5e291babfcdf69e17bb59e3819984a1ffcc715b881c2452f" + ], + "execution_requests": { + "deposits": [ + { + "pubkey": "0x82265d267f8473b8b95581d5cff9b19c81ca410538259c96c7418ef433e3c0a89d8ce7f7b91dc0789ceddd7e5f8f1f45", + "withdrawal_credentials": "0x010000000000000000000000594150410d114a888823a4369a4c1e9b4d1af3b1", + "amount": "4704680975884967085", + "signature": "0xb710f44c80db8d91f996614df20b5e9293a578f28f55e4cd65f017063fa9e36eead8417ff871fda70f6f8238fa906376066788d928178215cf5b285a0630956453a2b53fd2ecdd614e247a7c89502de682385310134924ee896501d9a1a5265a", + "index": "4707985942318335341" + }, + { + "pubkey": "0xaacb0e7f3717c59e23c32cb07ce03be33c2bb8366da2d27a9954b77f2c9198a1b5f3aea585faffcdfa4800b592c4d5d8", + "withdrawal_credentials": "0x0100000000000000000000007f8344414da8081272a9728d415e47355920f1d5", + "amount": "4701376009451598829", + "signature": "0xa9bf2689fe47ca9ac1fb90da3b08259115adab480b4f387669f209ee7747f7451af8f61e4a9c057bc33ffc18f0b08c3407be0a59b8c61c741572f5d28e2a1f6af0fc17db7c3f48901c9267606c3d7831a3d3647b885946fc95fb5689d24f7b8d", + "index": "4691461101561559469" + } + ], + "withdrawals": [ + { + "source_address": "0x3ece09418d9cc1c206477b3f86b61438983ee789", + "validator_pubkey": "0xb7fbe0486f002e790bb3d674b4259c18c6bf66510576e381e128aee6c2de771d3d5c9dda65b4078b058b2667f30e1637", + "amount": "4689808622639842637" + } + ], + "consolidations": [ + { + "source_address": "0x3a51a841aea2347f293797ab3448ea96efec0124", + "source_pubkey": "0x88f8fa6c349ee56559e614799a5788c17fdcde24ea5922a7c7fe6bed8df5c0140aeebbb46d0cadc7a9107e98344194f1", + "target_pubkey": "0x97995c0a4cf28bb77bfea20753ecd1e3b3469492921c9542d99a1e81355f6d09ea4cbcb35e3b8f1240e8261d20da657b" + } + ] + } + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockALTAIR.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockALTAIR.json index 1775d571d18..4e122e4a0ad 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockALTAIR.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockALTAIR.json @@ -1,8 +1,8 @@ { "version": "altair", "execution_payload_blinded": false, - "execution_payload_value": "103937209672754665403787198569491094139065692110747940607714578099263077344190", - "consensus_block_value": "112589418355271787712050062579209845950498186500797149782960719646608166001481", + "execution_payload_value": "97018133078155618461019972296033033900313459619348511176420591618712941397383", + "consensus_block_value": "24488860921568589833674783643659563715590202190620421246032537774195917789757", "data": { "slot": "1", "proposer_index": "4666673844721362956", @@ -49,19 +49,19 @@ "4589007099177470570" ], "data": { - "slot": "4580744678799082634", - "index": "4579092195582398506", - "beacon_block_root": "0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c", + "slot": "1", + "index": "4580744678799082634", + "beacon_block_root": "0x17348c3f2ad0733f4b47b34442744b4a2e03a79b1f52c8e8922ee71060a05b1c", "source": { - "epoch": "533461240", - "root": "0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565" + "epoch": "533653615", + "root": "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06" }, "target": { - "epoch": "538462976", - "root": "0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650" + "epoch": "538655350", + "root": "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0" } }, - "signature": "0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc" + "signature": "0xaffb36fe3e48b5c29794f85515b9a3adcd4206fec6dddac6926d0e985d96a9ade0e427f911d56dd90f2644af13e9740509147d149defa9b0763eecba616e0815e9a91c25178860be7d4196a9814781a4576ba7bc6398ef16b9bd5f88c4143bfb" }, "attestation_2": { "attesting_indices": [ @@ -70,132 +70,132 @@ "4589007099177470570" ], "data": { - "slot": "4620404293179370891", - "index": "4618751809962686763", - "beacon_block_root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b", + "slot": "1", + "index": "4628666713557758827", + "beacon_block_root": "0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390", "source": { - "epoch": "538078227", - "root": "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb" + "epoch": "537693478", + "root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b" }, "target": { - "epoch": "536923980", - "root": "0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5" + "epoch": "538078227", + "root": "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb" } }, - "signature": "0xa32991816eb9f297553b4732309a4cdba7b33287264611715b0ab3319bca19e581da6e2659912a4e0e94aafc01c488e30ffc96ed14e2a726b9d3c618405ee0bf54bf6ae7f2097465cb27ab8132ec24eb93d3c9159475304082f7f0e452b93b65" + "signature": "0xb7720f152c38d7172a82186892a68440bc4d285cc8aa92c1f017f93d5f61a29cf51670e4f944648bd8df82d4d6eae00615073d439389cdf35fbd7670a07ef8407c7c71a16be062fff16f351737ac99f006817ba43a295fe5286dfb4ba7116e07" } } ], "attestations": [ { - "aggregation_bits": "0xfa79cdb89d0d51c5cdd001b7425c6d726750a9d5f89ade6ed9890ce3a706140c399a5e10c90a819094b65322dac7501f7c75471e69d4567358d8ca75f7c1b3133ebecf006b369a1f36efc5f2b706d5922ff98c58a1825a53a864376658f816600cf021cea843d4396502bb9c74d1510afe26036f89f783b4f5c7bacb6649c46f217a6af835f312d6fa253d2bbc83c07993f4f10de2ed2d952689379dbe4f794c1a1055a6b364d68e038deec9667f576b3b9eca5fcadd6298f181e1edb876efc3d0975ae14ae9a0ad2f1836d4c3f1080a96d8ab7c43b34bb2eda895ff66be698b363cfa4be33da3ec94a1a7a90672fd12c4a59916bb937e78476e4f08e4f4031001", + "aggregation_bits": "0x88e3aeac2cb7509e753b73880be4e95da67b35193a1a8d916d3a5f3b61c59b6d90d866ae7ee81a10a9ea025ade39ad5b978bd20bd2d2031d61e8aa7b5090b08248dbcac0698c25ea7b858ae37e5347010aa764962e4f70513d9e2488a9808d0510dcb3dc9385cc9c28ba4a1eae314e5c3372b3d2387836dc0750553f84b1b490b7fffcb2824b614596050fa2ffed45b30b7db4e67cd782cf0446b5448ed43cb01991cde29c15b0a29dcafdbf29840045c4a3d7e58b93ff391e3ae281185e49aeeed12188548d0dc8e904edc1c8a9831577d08b0c708dbb1784cef981e8363efb46d26f039c2561792d1a2e81218eec593aefaa25bb280fbdd25f8103381a51c601", "data": { - "slot": "4605531939934246443", - "index": "4610489389584298827", - "beacon_block_root": "0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b", + "slot": "1", + "index": "4615446843529318507", + "beacon_block_root": "0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6", "source": { - "epoch": "529421377", - "root": "0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2" + "epoch": "536154483", + "root": "0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0" }, "target": { - "epoch": "529806126", - "root": "0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd" + "epoch": "536539231", + "root": "0x82a81c3f096d065c7e3f5d7df79bd182a53c9471a737cfb9f7c4e9ed95d0f767" } }, - "signature": "0x8f8d16b39e14569aab1b712e5c19ed51afe3600a6b017e8ab432f43a02ee720a733c33ef087d2f3653a9701e8d8a836301655b9195c0373b775c88ba1368e5d55354a70a3096bd26dee29dddbe7a4820e2b1653e84122beacbc01af7d93e6bdc" + "signature": "0xa9aef1e37252740dedc5fc9886810459f7484555aa59fb3876803fc4924149cb471ffbbd9be5324d952efafc3de4c5f705dd02134916b2afa02194fe90a8d1e8f58ebcfe0d33d0b8a97e71a3f7591cb82c37ba531c059a684b581d3857f05e3c" }, { - "aggregation_bits": "0x4ac567b296efbf7cf3209e87096a7a1a50fd523400113f917f6584a5a306f06b2d8da9ae858d47ff2594010089838efe41f19a78d9aae27c2ffde26f278b8681db9d091eb72e7cab3e449dfccd46a270693e1f88f197324e57bfd45573315cf9fb60d770937b32f7c0c6ce1581ec51e6b60f71acfde304dc917f2e0aa7872038b7d9140d15f7927c23a0490a74c2b0aca2773fed9217067e4444f9ca93874e4ff8407111c3efdb138b97c6d4957b6a70ec1debb283e3d0eb1cfef068adcffbf057d20fdc339eae03f0fa2613abdde8158a7fc40c3cfd1117eb6f8c4ae21d6b2ab4b57ae9a8653a34451aee6418c0c3609dc937293f5f5b346a7ab1a0d144185101", + "aggregation_bits": "0x0aa2e4365aad4ec5115dbc42fc6bcda2a0739e4b8c6c07334b99338ec990c7dc93162171b1ed0afe8b1f151348438523b428076a646db8375993d417cd79f1854f796992a8aea702eb3180373e7ff4b4c53ef3b306a5af7f82ba3a4a362af88084e7d166dd0ed5026019cd4f2c4fad16566f927d0dceb14203e8abc293267466c487eb2b108ae043792ff8e8c56e9fbb26d98381ad35e70558cc74f74d1d5a7de764645e15298f90a9a4292e58188deba564756775d54bad38de697be7659cde395c60f403933083c4e71881c26d15c83a61359fbecd1c12d8f31c0d440c128c416e09ee2d3fe64b8a4c737c2f604756d08d8c1f77d4623404e031805797412b01", "data": { - "slot": "4544390030852162633", - "index": "4542737547635478505", - "beacon_block_root": "0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd", + "slot": "1", + "index": "4549347484797182313", + "beacon_block_root": "0xcf2c053f899b836f534bfa2a45bf23b7be4890b9815a72a2aec9f70eff53d592", "source": { - "epoch": "527690007", - "root": "0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8" + "epoch": "528459505", + "root": "0xa8ea103f4904c5e568c52bd49eadfa1cb142929514c9202e53c7707e4a92667d" }, "target": { - "epoch": "528074756", - "root": "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8" + "epoch": "528844253", + "root": "0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd" } }, - "signature": "0x90309dd491ae6ed51917dc305a3d4ae68d0a0d4792c7eb59c193bd03605bd94e61cab37502de0ad3e6162bc02427bba80a798b3670d5de82a854094016cc298b265371345c0e3ac49fd44bbb9ba0d4fcea0c1a80cecb60e93921d907e8c48120" + "signature": "0x8f5c34de9e22ceaa7e8d165fc0553b32f02188539e89e2cc91e2eb9077645986550d872ee3403204ae5d554eae3cac12124e18d2324bccc814775316aaef352abc0450812b3ca9fde96ecafa911b3b8bfddca8db4027f08e29c22a9c370ad933" }, { - "aggregation_bits": "0xe8c9759f0840f980ae956b15fc383d992e7d4420d12ba5bf32f669f446ac6fa388e20e5ce96e9266dd98840179d2cde3cabd9a8bafab5dec9c2e89f7f78c989e690548603984803b80c82d7b76443194576a1ce49da5cfe56f56e83b745fb01b5f18ccc86d88f5a22d927e64ff0b8e880893abcddec45b268531c4a0697537dae643a24b1a36432f37d42962553bd39af71f37e0429b81470c11316aa39db074aa3f1df4124e7cb203debed60b885ffb9b27e46a1434e81bbd56566632d0729c0822ac415cbb67f25973667d88e58df9c2f058a0ae7f118c98cc448453b6fbe590363bd17ed62c2f808df61f2a9e593235eeb56db74b9dd15980189a5271468301", + "aggregation_bits": "0xd664cfc4f928592f21ca9fae84cd2a15d4acf76e0d2cbb493324ae9cb25757559fc4b060414cbfd84de047d4f04da4aa6669e83b9b8418d348bfc46b3fef684ffbf0162da3c6258f690b14c94cf448280b646c140b24928defd2d12434dbbbd0afbea5e5661fcac8116699ec8a059acf084ab956ab0eaf508ab7d3e4bd352a80f6b8ff73b4b24753a865991c45c9d9f0e1675e7327ccaaeb146bc3d0a4db2d7e607930579fc38a41d5019f222166cea9ebebfe0dd7b875fa612ecb7bb80f83718702da59fd2687d445048ac99f25b5f088fe931ec4bbf9ecdfc169844c00bc69fe38c0110fc59105233b29f6ddecb7968065fd7ef787e41d3545fefe30314fa401", "data": { - "slot": "4529517677607038185", - "index": "4574134745932346122", - "beacon_block_root": "0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947", + "slot": "1", + "index": "4536127614768741993", + "beacon_block_root": "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8", "source": { - "epoch": "532884117", - "root": "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31" + "epoch": "526920509", + "root": "0x41f3e13e4961bf0c12dd652f3bf49e85e35a8a25c70e67ffc1d08cc01d9921d3" }, "target": { - "epoch": "531729870", - "root": "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672" + "epoch": "527305258", + "root": "0x51977a3f0ab3110e2a10e9c6bd0e89b1410ca45142ac42171bb2b169efc281bc" } }, - "signature": "0x8c40f51a99fce6ebb9a4db5e80d715fff319e7ae523e46afb5d03c000d427e23c7a39e77e2af53851706283c8ca91d680997cb459386fbdff52c4d0ecf498e173717a838a792b210bdffaf476538628584a133899bf30dd5ce7056463b8cd683" + "signature": "0xa17225b5e5319618e77f5b93350430acfadd8ae12a279f1a4176cc7ad1de7ecfc8670988519713fbac8f702cca29bddb14ff1463dae3abb53ddb0c025cd69c8cfb0f5298ab241c06ddb840c7a260f3dbd37120826b13b17e22d086148ebdbab1" } ], "deposits": [ { "proof": [ - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c" + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7" ], "data": { - "pubkey": "0xb1f8f6e731dbf6b4e3265fb857c7190adbfc7e6cc95ce2e8bda72be8b6ea3459f862310a2484c3b0ee33b30920f18c1d", - "withdrawal_credentials": "0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c", + "pubkey": "0x90b2ffa8992560bca2080afa9b3adc904ce9085a8c2cc897282f20378bdf3cdc0a74100f226ea698e07d4afe50d8ff54", + "withdrawal_credentials": "0x9d1b633f8ae18e21ff1b86740b32dbe55a18a0991bcfe5ffd2b6bf8a59465fe7", "amount": "32000000000", - "signature": "0xb594382214f5bdd375de66c45e1c61a526c7b73fb166c72433bbd9c2a7ad6881244e61cc6427e0206a50b762a129d8830e8708c55761d61ce9e3b19c1bee13bc55daa13bdb07118efdbf57a588b8a64e6392d14f935e53b68933e3355b35acdb" + "signature": "0x978f1439422f6e539e93927a7754e7f9866fbe5832da066bb8fec5041a6818bbfe7e79747a963eec57f76924aeb591d0133ffae96de0793f02d13a13e1f7286a7940e48093ceb832b58e9d6bff9adfc1e8f59367d905633d743cd62ccbd2b27c" } } ], "voluntary_exits": [ { "message": { - "epoch": "4562567354825622634", - "validator_index": "4564219838042306762" + "epoch": "4570829775204010570", + "validator_index": "4565872325553958186" }, - "signature": "0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e" + "signature": "0x8c2c3b368bc00b3853e6df352e816dd910016db953ac77cc1565e3c22f1c0b24c59f24ea9e8ca406aa95b23368d163e80baa6de3f8f7ac19ee78c976d2ae5a21c86fa1762cc959bc734379055cb7aa1de36eae00541936b8c2ee908c770d41ff" } ], "sync_aggregate": { "sync_committee_bits": "0x01000000", - "sync_committee_signature": "0x919ee45cc18456f6e85da6bc21c2e40f44f9a887932c73ea9ad354f88e56d4ec0a8c396ed143082c8e31d697b877a2a215d2966d91c7beb156bf7ab5777e210012f70dcd5f7657808a82cba51e194be994f917150ebdb9e5c57476f1edb47206" + "sync_committee_signature": "0x8166b2ed13e982e6b9f05d30f42681b826099135a533d2614ef5f4f59811714245db0e1821a644859559f97ec1e614bf08b2edb294fa2edc1527f46596399534af23c98613e1b74c01871bf1dd2af9618bc0ba23ddfce8026b897cdbba8c1bce" } } } diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockBELLATRIX.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockBELLATRIX.json index bd42aac2d10..89eacd2fefe 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockBELLATRIX.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockBELLATRIX.json @@ -1,8 +1,8 @@ { "version": "bellatrix", "execution_payload_blinded": false, - "execution_payload_value": "52023957684963099890197642648275639090111315264223959376921672476998293165950", - "consensus_block_value": "60676166367585534490104448136534361130429539983797769693516783501557375651593", + "execution_payload_value": "77980583678911331500982012325662529031716803992400496249212189458466616229150", + "consensus_block_value": "52023957684963099890197642648275639090111315264223959376921672476998293165950", "data": { "slot": "1", "proposer_index": "4666673844721362956", @@ -49,19 +49,19 @@ "4589007099177470570" ], "data": { - "slot": "4580744678799082634", - "index": "4579092195582398506", - "beacon_block_root": "0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c", + "slot": "1", + "index": "4580744678799082634", + "beacon_block_root": "0x17348c3f2ad0733f4b47b34442744b4a2e03a79b1f52c8e8922ee71060a05b1c", "source": { - "epoch": "533461240", - "root": "0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565" + "epoch": "533653615", + "root": "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06" }, "target": { - "epoch": "538462976", - "root": "0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650" + "epoch": "538655350", + "root": "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0" } }, - "signature": "0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc" + "signature": "0xaffb36fe3e48b5c29794f85515b9a3adcd4206fec6dddac6926d0e985d96a9ade0e427f911d56dd90f2644af13e9740509147d149defa9b0763eecba616e0815e9a91c25178860be7d4196a9814781a4576ba7bc6398ef16b9bd5f88c4143bfb" }, "attestation_2": { "attesting_indices": [ @@ -70,156 +70,158 @@ "4589007099177470570" ], "data": { - "slot": "4620404293179370891", - "index": "4618751809962686763", - "beacon_block_root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b", + "slot": "1", + "index": "4628666713557758827", + "beacon_block_root": "0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390", "source": { - "epoch": "538078227", - "root": "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb" + "epoch": "537693478", + "root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b" }, "target": { - "epoch": "536923980", - "root": "0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5" + "epoch": "538078227", + "root": "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb" } }, - "signature": "0xa32991816eb9f297553b4732309a4cdba7b33287264611715b0ab3319bca19e581da6e2659912a4e0e94aafc01c488e30ffc96ed14e2a726b9d3c618405ee0bf54bf6ae7f2097465cb27ab8132ec24eb93d3c9159475304082f7f0e452b93b65" + "signature": "0xb7720f152c38d7172a82186892a68440bc4d285cc8aa92c1f017f93d5f61a29cf51670e4f944648bd8df82d4d6eae00615073d439389cdf35fbd7670a07ef8407c7c71a16be062fff16f351737ac99f006817ba43a295fe5286dfb4ba7116e07" } } ], "attestations": [ { - "aggregation_bits": "0xfa79cdb89d0d51c5cdd001b7425c6d726750a9d5f89ade6ed9890ce3a706140c399a5e10c90a819094b65322dac7501f7c75471e69d4567358d8ca75f7c1b3133ebecf006b369a1f36efc5f2b706d5922ff98c58a1825a53a864376658f816600cf021cea843d4396502bb9c74d1510afe26036f89f783b4f5c7bacb6649c46f217a6af835f312d6fa253d2bbc83c07993f4f10de2ed2d952689379dbe4f794c1a1055a6b364d68e038deec9667f576b3b9eca5fcadd6298f181e1edb876efc3d0975ae14ae9a0ad2f1836d4c3f1080a96d8ab7c43b34bb2eda895ff66be698b363cfa4be33da3ec94a1a7a90672fd12c4a59916bb937e78476e4f08e4f4031001", + "aggregation_bits": "0x88e3aeac2cb7509e753b73880be4e95da67b35193a1a8d916d3a5f3b61c59b6d90d866ae7ee81a10a9ea025ade39ad5b978bd20bd2d2031d61e8aa7b5090b08248dbcac0698c25ea7b858ae37e5347010aa764962e4f70513d9e2488a9808d0510dcb3dc9385cc9c28ba4a1eae314e5c3372b3d2387836dc0750553f84b1b490b7fffcb2824b614596050fa2ffed45b30b7db4e67cd782cf0446b5448ed43cb01991cde29c15b0a29dcafdbf29840045c4a3d7e58b93ff391e3ae281185e49aeeed12188548d0dc8e904edc1c8a9831577d08b0c708dbb1784cef981e8363efb46d26f039c2561792d1a2e81218eec593aefaa25bb280fbdd25f8103381a51c601", "data": { - "slot": "4605531939934246443", - "index": "4610489389584298827", - "beacon_block_root": "0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b", + "slot": "1", + "index": "4615446843529318507", + "beacon_block_root": "0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6", "source": { - "epoch": "529421377", - "root": "0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2" + "epoch": "536154483", + "root": "0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0" }, "target": { - "epoch": "529806126", - "root": "0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd" + "epoch": "536539231", + "root": "0x82a81c3f096d065c7e3f5d7df79bd182a53c9471a737cfb9f7c4e9ed95d0f767" } }, - "signature": "0x8f8d16b39e14569aab1b712e5c19ed51afe3600a6b017e8ab432f43a02ee720a733c33ef087d2f3653a9701e8d8a836301655b9195c0373b775c88ba1368e5d55354a70a3096bd26dee29dddbe7a4820e2b1653e84122beacbc01af7d93e6bdc" + "signature": "0xa9aef1e37252740dedc5fc9886810459f7484555aa59fb3876803fc4924149cb471ffbbd9be5324d952efafc3de4c5f705dd02134916b2afa02194fe90a8d1e8f58ebcfe0d33d0b8a97e71a3f7591cb82c37ba531c059a684b581d3857f05e3c" }, { - "aggregation_bits": "0x4ac567b296efbf7cf3209e87096a7a1a50fd523400113f917f6584a5a306f06b2d8da9ae858d47ff2594010089838efe41f19a78d9aae27c2ffde26f278b8681db9d091eb72e7cab3e449dfccd46a270693e1f88f197324e57bfd45573315cf9fb60d770937b32f7c0c6ce1581ec51e6b60f71acfde304dc917f2e0aa7872038b7d9140d15f7927c23a0490a74c2b0aca2773fed9217067e4444f9ca93874e4ff8407111c3efdb138b97c6d4957b6a70ec1debb283e3d0eb1cfef068adcffbf057d20fdc339eae03f0fa2613abdde8158a7fc40c3cfd1117eb6f8c4ae21d6b2ab4b57ae9a8653a34451aee6418c0c3609dc937293f5f5b346a7ab1a0d144185101", + "aggregation_bits": "0x0aa2e4365aad4ec5115dbc42fc6bcda2a0739e4b8c6c07334b99338ec990c7dc93162171b1ed0afe8b1f151348438523b428076a646db8375993d417cd79f1854f796992a8aea702eb3180373e7ff4b4c53ef3b306a5af7f82ba3a4a362af88084e7d166dd0ed5026019cd4f2c4fad16566f927d0dceb14203e8abc293267466c487eb2b108ae043792ff8e8c56e9fbb26d98381ad35e70558cc74f74d1d5a7de764645e15298f90a9a4292e58188deba564756775d54bad38de697be7659cde395c60f403933083c4e71881c26d15c83a61359fbecd1c12d8f31c0d440c128c416e09ee2d3fe64b8a4c737c2f604756d08d8c1f77d4623404e031805797412b01", "data": { - "slot": "4544390030852162633", - "index": "4542737547635478505", - "beacon_block_root": "0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd", + "slot": "1", + "index": "4549347484797182313", + "beacon_block_root": "0xcf2c053f899b836f534bfa2a45bf23b7be4890b9815a72a2aec9f70eff53d592", "source": { - "epoch": "527690007", - "root": "0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8" + "epoch": "528459505", + "root": "0xa8ea103f4904c5e568c52bd49eadfa1cb142929514c9202e53c7707e4a92667d" }, "target": { - "epoch": "528074756", - "root": "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8" + "epoch": "528844253", + "root": "0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd" } }, - "signature": "0x90309dd491ae6ed51917dc305a3d4ae68d0a0d4792c7eb59c193bd03605bd94e61cab37502de0ad3e6162bc02427bba80a798b3670d5de82a854094016cc298b265371345c0e3ac49fd44bbb9ba0d4fcea0c1a80cecb60e93921d907e8c48120" + "signature": "0x8f5c34de9e22ceaa7e8d165fc0553b32f02188539e89e2cc91e2eb9077645986550d872ee3403204ae5d554eae3cac12124e18d2324bccc814775316aaef352abc0450812b3ca9fde96ecafa911b3b8bfddca8db4027f08e29c22a9c370ad933" }, { - "aggregation_bits": "0xe8c9759f0840f980ae956b15fc383d992e7d4420d12ba5bf32f669f446ac6fa388e20e5ce96e9266dd98840179d2cde3cabd9a8bafab5dec9c2e89f7f78c989e690548603984803b80c82d7b76443194576a1ce49da5cfe56f56e83b745fb01b5f18ccc86d88f5a22d927e64ff0b8e880893abcddec45b268531c4a0697537dae643a24b1a36432f37d42962553bd39af71f37e0429b81470c11316aa39db074aa3f1df4124e7cb203debed60b885ffb9b27e46a1434e81bbd56566632d0729c0822ac415cbb67f25973667d88e58df9c2f058a0ae7f118c98cc448453b6fbe590363bd17ed62c2f808df61f2a9e593235eeb56db74b9dd15980189a5271468301", + "aggregation_bits": "0xd664cfc4f928592f21ca9fae84cd2a15d4acf76e0d2cbb493324ae9cb25757559fc4b060414cbfd84de047d4f04da4aa6669e83b9b8418d348bfc46b3fef684ffbf0162da3c6258f690b14c94cf448280b646c140b24928defd2d12434dbbbd0afbea5e5661fcac8116699ec8a059acf084ab956ab0eaf508ab7d3e4bd352a80f6b8ff73b4b24753a865991c45c9d9f0e1675e7327ccaaeb146bc3d0a4db2d7e607930579fc38a41d5019f222166cea9ebebfe0dd7b875fa612ecb7bb80f83718702da59fd2687d445048ac99f25b5f088fe931ec4bbf9ecdfc169844c00bc69fe38c0110fc59105233b29f6ddecb7968065fd7ef787e41d3545fefe30314fa401", "data": { - "slot": "4529517677607038185", - "index": "4574134745932346122", - "beacon_block_root": "0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947", + "slot": "1", + "index": "4536127614768741993", + "beacon_block_root": "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8", "source": { - "epoch": "532884117", - "root": "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31" + "epoch": "526920509", + "root": "0x41f3e13e4961bf0c12dd652f3bf49e85e35a8a25c70e67ffc1d08cc01d9921d3" }, "target": { - "epoch": "531729870", - "root": "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672" + "epoch": "527305258", + "root": "0x51977a3f0ab3110e2a10e9c6bd0e89b1410ca45142ac42171bb2b169efc281bc" } }, - "signature": "0x8c40f51a99fce6ebb9a4db5e80d715fff319e7ae523e46afb5d03c000d427e23c7a39e77e2af53851706283c8ca91d680997cb459386fbdff52c4d0ecf498e173717a838a792b210bdffaf476538628584a133899bf30dd5ce7056463b8cd683" + "signature": "0xa17225b5e5319618e77f5b93350430acfadd8ae12a279f1a4176cc7ad1de7ecfc8670988519713fbac8f702cca29bddb14ff1463dae3abb53ddb0c025cd69c8cfb0f5298ab241c06ddb840c7a260f3dbd37120826b13b17e22d086148ebdbab1" } ], "deposits": [ { "proof": [ - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c" + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7" ], "data": { - "pubkey": "0xb1f8f6e731dbf6b4e3265fb857c7190adbfc7e6cc95ce2e8bda72be8b6ea3459f862310a2484c3b0ee33b30920f18c1d", - "withdrawal_credentials": "0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c", + "pubkey": "0x90b2ffa8992560bca2080afa9b3adc904ce9085a8c2cc897282f20378bdf3cdc0a74100f226ea698e07d4afe50d8ff54", + "withdrawal_credentials": "0x9d1b633f8ae18e21ff1b86740b32dbe55a18a0991bcfe5ffd2b6bf8a59465fe7", "amount": "32000000000", - "signature": "0xb594382214f5bdd375de66c45e1c61a526c7b73fb166c72433bbd9c2a7ad6881244e61cc6427e0206a50b762a129d8830e8708c55761d61ce9e3b19c1bee13bc55daa13bdb07118efdbf57a588b8a64e6392d14f935e53b68933e3355b35acdb" + "signature": "0x978f1439422f6e539e93927a7754e7f9866fbe5832da066bb8fec5041a6818bbfe7e79747a963eec57f76924aeb591d0133ffae96de0793f02d13a13e1f7286a7940e48093ceb832b58e9d6bff9adfc1e8f59367d905633d743cd62ccbd2b27c" } } ], "voluntary_exits": [ { "message": { - "epoch": "4562567354825622634", - "validator_index": "4564219838042306762" + "epoch": "4570829775204010570", + "validator_index": "4565872325553958186" }, - "signature": "0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e" + "signature": "0x8c2c3b368bc00b3853e6df352e816dd910016db953ac77cc1565e3c22f1c0b24c59f24ea9e8ca406aa95b23368d163e80baa6de3f8f7ac19ee78c976d2ae5a21c86fa1762cc959bc734379055cb7aa1de36eae00541936b8c2ee908c770d41ff" } ], "sync_aggregate": { "sync_committee_bits": "0x01000000", - "sync_committee_signature": "0x919ee45cc18456f6e85da6bc21c2e40f44f9a887932c73ea9ad354f88e56d4ec0a8c396ed143082c8e31d697b877a2a215d2966d91c7beb156bf7ab5777e210012f70dcd5f7657808a82cba51e194be994f917150ebdb9e5c57476f1edb47206" + "sync_committee_signature": "0x8166b2ed13e982e6b9f05d30f42681b826099135a533d2614ef5f4f59811714245db0e1821a644859559f97ec1e614bf08b2edb294fa2edc1527f46596399534af23c98613e1b74c01871bf1dd2af9618bc0ba23ddfce8026b897cdbba8c1bce" }, "execution_payload": { - "parent_hash": "0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be", - "fee_recipient": "0xf8eb5a3ea82ccf3c1be1ac153e3f77f273a07343", - "state_root": "0xbf886c3ec849316e3b187793c3a4398b6097768d06bd968a54e8d2652d2a75a9", - "receipts_root": "0xd2a9663e689510b3305bdebe972d4e58669a751fbc85bf448269162e078b2c34", - "logs_bloom": "0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9f770a36a743c8a3abab61dc439ddc0604dd5015b1ed3835787d9565dee0f3e64b25de4c097defe3001f483a4b6feac22b992cada114bfc709d483b4d94f07bb0a1c4fb9e93ca3c31f4b9683753ba33ffd971777e301367f1edfe6809da491535c711a7877b4c97fd1a756136c412b4f3c4471ba439607333623558a63030f2cb6bc2ba885822672de14ea697d44fbcde134b6909208466be0b4c981658ba30f999c991aca746c3331766af1ee10cbe69624066708ae086999a0a3853eb777b3f9f0455cfd98a98c7719710515b97c596d2b662d353a90206e470c523d4374853", - "prev_randao": "0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874", - "block_number": "4491510546443434056", - "gas_limit": "4489858063226749928", - "gas_used": "4481595642848361992", - "timestamp": "4479943159631677864", - "extra_data": "0x58913d3ec8a62b95e52fb1ee60ebddf392af6e1db902dd5bc3f1eea7003130ff", - "base_fee_per_gas": "48712354854557871613352262057776104244427151172201944877932608112921551169417", - "block_hash": "0xcb571a3e876c6732a4c11cf3562059c2b8c16889ffb6d1b8d5f883591e767c3f", + "parent_hash": "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "fee_recipient": "0x3624343f893e8948a933c0cfa8787f4e8c309829", + "state_root": "0x49452e3f298a688d9e7627fb7c01941b923397bb84dd548b6e411f9506aed1c7", + "receipts_root": "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "logs_bloom": "0x23033a3fe9f2a903b4f058a4d4ef6a81852d9997184c0317133f980452ec62b2b061e83c58b49a2152d35e2d52dec57a103ce8a251c901ef2fab683582825ff8b0b008f76d24edc9c1ae40d0e75942618263f7d7986e9bccf1329656466d543e00b24a93476cb3f928af4367c6625a9cf341db27bc452836499a1efdd2c9eb5e912927c2878fe39fe1a2b36a44c10572cd0437fa4fd7e83a9db691bfbf5b9fcaeb8b2ea9d2b89eeffc8cf98d5b66f53e527f376d29bf250544a9eeb288757962a5fc0eae509665d2b90702b12b5caa0913916a48e650fd430ceafdde0d71da95ee9ceba330c6cb0412771d5275464afa7adcac63634c91ceb521f22e12b844c9", + "prev_randao": "0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be", + "block_number": "4493163029660118184", + "gas_limit": "4498120483605137864", + "gas_used": "4496467996093486440", + "timestamp": "4488205580010065800", + "extra_data": "0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874", + "base_fee_per_gas": "5451311522429616772243425117521481983710813629341562216088296324789550535380", + "block_hash": "0x1f2e4f3ee8c38dc605677b6ce650a08c7fa6716795a8622d396e244f710e0a5f", "transactions": [ - "0xb736203ee72088", - "0xc7dab83ea972da", - "0xa198c43e69db1b", - "0x135fa13e28a157", - "0xed1cad3ee80999", - "0x60e3893ea8cfd4", - "0x39a1953e683816", - "0xac67723e28fe51" + "0x58913d3ec8a62b", + "0xcb571a3e876c67", + "0xa415263e48d5a8", + "0xb4b9be3e0927fb", + "0x8e77ca3ec98f3c", + "0x003ea73e885578", + "0xdafbb23e48beb9", + "0x4dc28f3e0884f5", + "0x26809b3ec8ec36", + "0x9946783e88b272" ] } } diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockCAPELLA.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockCAPELLA.json index 14fdd21891b..32180d55183 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockCAPELLA.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockCAPELLA.json @@ -1,8 +1,8 @@ { "version": "capella", "execution_payload_blinded": false, - "execution_payload_value": "83632285808730419317736499381296317955001824334926037771558613552994642479128", - "consensus_block_value": "57675659814887085414906793581496838358932359404946407426484785971220606657144", + "execution_payload_value": "74980077153067520008840907606684269865797132424920269178020536721452757553550", + "consensus_block_value": "83632285808730419317736499381296317955001824334926037771558613552994642479128", "data": { "slot": "1", "proposer_index": "4666673844721362956", @@ -49,19 +49,19 @@ "4589007099177470570" ], "data": { - "slot": "4580744678799082634", - "index": "4579092195582398506", - "beacon_block_root": "0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c", + "slot": "1", + "index": "4580744678799082634", + "beacon_block_root": "0x17348c3f2ad0733f4b47b34442744b4a2e03a79b1f52c8e8922ee71060a05b1c", "source": { - "epoch": "533461240", - "root": "0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565" + "epoch": "533653615", + "root": "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06" }, "target": { - "epoch": "538462976", - "root": "0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650" + "epoch": "538655350", + "root": "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0" } }, - "signature": "0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc" + "signature": "0xaffb36fe3e48b5c29794f85515b9a3adcd4206fec6dddac6926d0e985d96a9ade0e427f911d56dd90f2644af13e9740509147d149defa9b0763eecba616e0815e9a91c25178860be7d4196a9814781a4576ba7bc6398ef16b9bd5f88c4143bfb" }, "attestation_2": { "attesting_indices": [ @@ -70,294 +70,296 @@ "4589007099177470570" ], "data": { - "slot": "4620404293179370891", - "index": "4618751809962686763", - "beacon_block_root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b", + "slot": "1", + "index": "4628666713557758827", + "beacon_block_root": "0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390", "source": { - "epoch": "538078227", - "root": "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb" + "epoch": "537693478", + "root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b" }, "target": { - "epoch": "536923980", - "root": "0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5" + "epoch": "538078227", + "root": "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb" } }, - "signature": "0xa32991816eb9f297553b4732309a4cdba7b33287264611715b0ab3319bca19e581da6e2659912a4e0e94aafc01c488e30ffc96ed14e2a726b9d3c618405ee0bf54bf6ae7f2097465cb27ab8132ec24eb93d3c9159475304082f7f0e452b93b65" + "signature": "0xb7720f152c38d7172a82186892a68440bc4d285cc8aa92c1f017f93d5f61a29cf51670e4f944648bd8df82d4d6eae00615073d439389cdf35fbd7670a07ef8407c7c71a16be062fff16f351737ac99f006817ba43a295fe5286dfb4ba7116e07" } } ], "attestations": [ { - "aggregation_bits": "0xfa79cdb89d0d51c5cdd001b7425c6d726750a9d5f89ade6ed9890ce3a706140c399a5e10c90a819094b65322dac7501f7c75471e69d4567358d8ca75f7c1b3133ebecf006b369a1f36efc5f2b706d5922ff98c58a1825a53a864376658f816600cf021cea843d4396502bb9c74d1510afe26036f89f783b4f5c7bacb6649c46f217a6af835f312d6fa253d2bbc83c07993f4f10de2ed2d952689379dbe4f794c1a1055a6b364d68e038deec9667f576b3b9eca5fcadd6298f181e1edb876efc3d0975ae14ae9a0ad2f1836d4c3f1080a96d8ab7c43b34bb2eda895ff66be698b363cfa4be33da3ec94a1a7a90672fd12c4a59916bb937e78476e4f08e4f4031001", + "aggregation_bits": "0x88e3aeac2cb7509e753b73880be4e95da67b35193a1a8d916d3a5f3b61c59b6d90d866ae7ee81a10a9ea025ade39ad5b978bd20bd2d2031d61e8aa7b5090b08248dbcac0698c25ea7b858ae37e5347010aa764962e4f70513d9e2488a9808d0510dcb3dc9385cc9c28ba4a1eae314e5c3372b3d2387836dc0750553f84b1b490b7fffcb2824b614596050fa2ffed45b30b7db4e67cd782cf0446b5448ed43cb01991cde29c15b0a29dcafdbf29840045c4a3d7e58b93ff391e3ae281185e49aeeed12188548d0dc8e904edc1c8a9831577d08b0c708dbb1784cef981e8363efb46d26f039c2561792d1a2e81218eec593aefaa25bb280fbdd25f8103381a51c601", "data": { - "slot": "4605531939934246443", - "index": "4610489389584298827", - "beacon_block_root": "0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b", + "slot": "1", + "index": "4615446843529318507", + "beacon_block_root": "0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6", "source": { - "epoch": "529421377", - "root": "0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2" + "epoch": "536154483", + "root": "0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0" }, "target": { - "epoch": "529806126", - "root": "0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd" + "epoch": "536539231", + "root": "0x82a81c3f096d065c7e3f5d7df79bd182a53c9471a737cfb9f7c4e9ed95d0f767" } }, - "signature": "0x8f8d16b39e14569aab1b712e5c19ed51afe3600a6b017e8ab432f43a02ee720a733c33ef087d2f3653a9701e8d8a836301655b9195c0373b775c88ba1368e5d55354a70a3096bd26dee29dddbe7a4820e2b1653e84122beacbc01af7d93e6bdc" + "signature": "0xa9aef1e37252740dedc5fc9886810459f7484555aa59fb3876803fc4924149cb471ffbbd9be5324d952efafc3de4c5f705dd02134916b2afa02194fe90a8d1e8f58ebcfe0d33d0b8a97e71a3f7591cb82c37ba531c059a684b581d3857f05e3c" }, { - "aggregation_bits": "0x4ac567b296efbf7cf3209e87096a7a1a50fd523400113f917f6584a5a306f06b2d8da9ae858d47ff2594010089838efe41f19a78d9aae27c2ffde26f278b8681db9d091eb72e7cab3e449dfccd46a270693e1f88f197324e57bfd45573315cf9fb60d770937b32f7c0c6ce1581ec51e6b60f71acfde304dc917f2e0aa7872038b7d9140d15f7927c23a0490a74c2b0aca2773fed9217067e4444f9ca93874e4ff8407111c3efdb138b97c6d4957b6a70ec1debb283e3d0eb1cfef068adcffbf057d20fdc339eae03f0fa2613abdde8158a7fc40c3cfd1117eb6f8c4ae21d6b2ab4b57ae9a8653a34451aee6418c0c3609dc937293f5f5b346a7ab1a0d144185101", + "aggregation_bits": "0x0aa2e4365aad4ec5115dbc42fc6bcda2a0739e4b8c6c07334b99338ec990c7dc93162171b1ed0afe8b1f151348438523b428076a646db8375993d417cd79f1854f796992a8aea702eb3180373e7ff4b4c53ef3b306a5af7f82ba3a4a362af88084e7d166dd0ed5026019cd4f2c4fad16566f927d0dceb14203e8abc293267466c487eb2b108ae043792ff8e8c56e9fbb26d98381ad35e70558cc74f74d1d5a7de764645e15298f90a9a4292e58188deba564756775d54bad38de697be7659cde395c60f403933083c4e71881c26d15c83a61359fbecd1c12d8f31c0d440c128c416e09ee2d3fe64b8a4c737c2f604756d08d8c1f77d4623404e031805797412b01", "data": { - "slot": "4544390030852162633", - "index": "4542737547635478505", - "beacon_block_root": "0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd", + "slot": "1", + "index": "4549347484797182313", + "beacon_block_root": "0xcf2c053f899b836f534bfa2a45bf23b7be4890b9815a72a2aec9f70eff53d592", "source": { - "epoch": "527690007", - "root": "0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8" + "epoch": "528459505", + "root": "0xa8ea103f4904c5e568c52bd49eadfa1cb142929514c9202e53c7707e4a92667d" }, "target": { - "epoch": "528074756", - "root": "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8" + "epoch": "528844253", + "root": "0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd" } }, - "signature": "0x90309dd491ae6ed51917dc305a3d4ae68d0a0d4792c7eb59c193bd03605bd94e61cab37502de0ad3e6162bc02427bba80a798b3670d5de82a854094016cc298b265371345c0e3ac49fd44bbb9ba0d4fcea0c1a80cecb60e93921d907e8c48120" + "signature": "0x8f5c34de9e22ceaa7e8d165fc0553b32f02188539e89e2cc91e2eb9077645986550d872ee3403204ae5d554eae3cac12124e18d2324bccc814775316aaef352abc0450812b3ca9fde96ecafa911b3b8bfddca8db4027f08e29c22a9c370ad933" }, { - "aggregation_bits": "0xe8c9759f0840f980ae956b15fc383d992e7d4420d12ba5bf32f669f446ac6fa388e20e5ce96e9266dd98840179d2cde3cabd9a8bafab5dec9c2e89f7f78c989e690548603984803b80c82d7b76443194576a1ce49da5cfe56f56e83b745fb01b5f18ccc86d88f5a22d927e64ff0b8e880893abcddec45b268531c4a0697537dae643a24b1a36432f37d42962553bd39af71f37e0429b81470c11316aa39db074aa3f1df4124e7cb203debed60b885ffb9b27e46a1434e81bbd56566632d0729c0822ac415cbb67f25973667d88e58df9c2f058a0ae7f118c98cc448453b6fbe590363bd17ed62c2f808df61f2a9e593235eeb56db74b9dd15980189a5271468301", + "aggregation_bits": "0xd664cfc4f928592f21ca9fae84cd2a15d4acf76e0d2cbb493324ae9cb25757559fc4b060414cbfd84de047d4f04da4aa6669e83b9b8418d348bfc46b3fef684ffbf0162da3c6258f690b14c94cf448280b646c140b24928defd2d12434dbbbd0afbea5e5661fcac8116699ec8a059acf084ab956ab0eaf508ab7d3e4bd352a80f6b8ff73b4b24753a865991c45c9d9f0e1675e7327ccaaeb146bc3d0a4db2d7e607930579fc38a41d5019f222166cea9ebebfe0dd7b875fa612ecb7bb80f83718702da59fd2687d445048ac99f25b5f088fe931ec4bbf9ecdfc169844c00bc69fe38c0110fc59105233b29f6ddecb7968065fd7ef787e41d3545fefe30314fa401", "data": { - "slot": "4529517677607038185", - "index": "4574134745932346122", - "beacon_block_root": "0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947", + "slot": "1", + "index": "4536127614768741993", + "beacon_block_root": "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8", "source": { - "epoch": "532884117", - "root": "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31" + "epoch": "526920509", + "root": "0x41f3e13e4961bf0c12dd652f3bf49e85e35a8a25c70e67ffc1d08cc01d9921d3" }, "target": { - "epoch": "531729870", - "root": "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672" + "epoch": "527305258", + "root": "0x51977a3f0ab3110e2a10e9c6bd0e89b1410ca45142ac42171bb2b169efc281bc" } }, - "signature": "0x8c40f51a99fce6ebb9a4db5e80d715fff319e7ae523e46afb5d03c000d427e23c7a39e77e2af53851706283c8ca91d680997cb459386fbdff52c4d0ecf498e173717a838a792b210bdffaf476538628584a133899bf30dd5ce7056463b8cd683" + "signature": "0xa17225b5e5319618e77f5b93350430acfadd8ae12a279f1a4176cc7ad1de7ecfc8670988519713fbac8f702cca29bddb14ff1463dae3abb53ddb0c025cd69c8cfb0f5298ab241c06ddb840c7a260f3dbd37120826b13b17e22d086148ebdbab1" } ], "deposits": [ { "proof": [ - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c" + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7" ], "data": { - "pubkey": "0xb1f8f6e731dbf6b4e3265fb857c7190adbfc7e6cc95ce2e8bda72be8b6ea3459f862310a2484c3b0ee33b30920f18c1d", - "withdrawal_credentials": "0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c", + "pubkey": "0x90b2ffa8992560bca2080afa9b3adc904ce9085a8c2cc897282f20378bdf3cdc0a74100f226ea698e07d4afe50d8ff54", + "withdrawal_credentials": "0x9d1b633f8ae18e21ff1b86740b32dbe55a18a0991bcfe5ffd2b6bf8a59465fe7", "amount": "32000000000", - "signature": "0xb594382214f5bdd375de66c45e1c61a526c7b73fb166c72433bbd9c2a7ad6881244e61cc6427e0206a50b762a129d8830e8708c55761d61ce9e3b19c1bee13bc55daa13bdb07118efdbf57a588b8a64e6392d14f935e53b68933e3355b35acdb" + "signature": "0x978f1439422f6e539e93927a7754e7f9866fbe5832da066bb8fec5041a6818bbfe7e79747a963eec57f76924aeb591d0133ffae96de0793f02d13a13e1f7286a7940e48093ceb832b58e9d6bff9adfc1e8f59367d905633d743cd62ccbd2b27c" } } ], "voluntary_exits": [ { "message": { - "epoch": "4562567354825622634", - "validator_index": "4564219838042306762" + "epoch": "4570829775204010570", + "validator_index": "4565872325553958186" }, - "signature": "0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e" + "signature": "0x8c2c3b368bc00b3853e6df352e816dd910016db953ac77cc1565e3c22f1c0b24c59f24ea9e8ca406aa95b23368d163e80baa6de3f8f7ac19ee78c976d2ae5a21c86fa1762cc959bc734379055cb7aa1de36eae00541936b8c2ee908c770d41ff" } ], "sync_aggregate": { "sync_committee_bits": "0x01000000", - "sync_committee_signature": "0x919ee45cc18456f6e85da6bc21c2e40f44f9a887932c73ea9ad354f88e56d4ec0a8c396ed143082c8e31d697b877a2a215d2966d91c7beb156bf7ab5777e210012f70dcd5f7657808a82cba51e194be994f917150ebdb9e5c57476f1edb47206" + "sync_committee_signature": "0x8166b2ed13e982e6b9f05d30f42681b826099135a533d2614ef5f4f59811714245db0e1821a644859559f97ec1e614bf08b2edb294fa2edc1527f46596399534af23c98613e1b74c01871bf1dd2af9618bc0ba23ddfce8026b897cdbba8c1bce" }, "execution_payload": { - "parent_hash": "0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be", - "fee_recipient": "0xf8eb5a3ea82ccf3c1be1ac153e3f77f273a07343", - "state_root": "0xbf886c3ec849316e3b187793c3a4398b6097768d06bd968a54e8d2652d2a75a9", - "receipts_root": "0xd2a9663e689510b3305bdebe972d4e58669a751fbc85bf448269162e078b2c34", - "logs_bloom": "0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9f770a36a743c8a3abab61dc439ddc0604dd5015b1ed3835787d9565dee0f3e64b25de4c097defe3001f483a4b6feac22b992cada114bfc709d483b4d94f07bb0a1c4fb9e93ca3c31f4b9683753ba33ffd971777e301367f1edfe6809da491535c711a7877b4c97fd1a756136c412b4f3c4471ba439607333623558a63030f2cb6bc2ba885822672de14ea697d44fbcde134b6909208466be0b4c981658ba30f999c991aca746c3331766af1ee10cbe69624066708ae086999a0a3853eb777b3f9f0455cfd98a98c7719710515b97c596d2b662d353a90206e470c523d4374853", - "prev_randao": "0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874", - "block_number": "4491510546443434056", - "gas_limit": "4489858063226749928", - "gas_used": "4481595642848361992", - "timestamp": "4479943159631677864", - "extra_data": "0x58913d3ec8a62b95e52fb1ee60ebddf392af6e1db902dd5bc3f1eea7003130ff", - "base_fee_per_gas": "48712354854557871613352262057776104244427151172201944877932608112921551169417", - "block_hash": "0xcb571a3e876c6732a4c11cf3562059c2b8c16889ffb6d1b8d5f883591e767c3f", + "parent_hash": "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "fee_recipient": "0x3624343f893e8948a933c0cfa8787f4e8c309829", + "state_root": "0x49452e3f298a688d9e7627fb7c01941b923397bb84dd548b6e411f9506aed1c7", + "receipts_root": "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "logs_bloom": "0x23033a3fe9f2a903b4f058a4d4ef6a81852d9997184c0317133f980452ec62b2b061e83c58b49a2152d35e2d52dec57a103ce8a251c901ef2fab683582825ff8b0b008f76d24edc9c1ae40d0e75942618263f7d7986e9bccf1329656466d543e00b24a93476cb3f928af4367c6625a9cf341db27bc452836499a1efdd2c9eb5e912927c2878fe39fe1a2b36a44c10572cd0437fa4fd7e83a9db691bfbf5b9fcaeb8b2ea9d2b89eeffc8cf98d5b66f53e527f376d29bf250544a9eeb288757962a5fc0eae509665d2b90702b12b5caa0913916a48e650fd430ceafdde0d71da95ee9ceba330c6cb0412771d5275464afa7adcac63634c91ceb521f22e12b844c9", + "prev_randao": "0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be", + "block_number": "4493163029660118184", + "gas_limit": "4498120483605137864", + "gas_used": "4496467996093486440", + "timestamp": "4488205580010065800", + "extra_data": "0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874", + "base_fee_per_gas": "5451311522429616772243425117521481983710813629341562216088296324789550535380", + "block_hash": "0x1f2e4f3ee8c38dc605677b6ce650a08c7fa6716795a8622d396e244f710e0a5f", "transactions": [ - "0xb736203ee72088", - "0xc7dab83ea972da", - "0xa198c43e69db1b", - "0x135fa13e28a157", - "0xed1cad3ee80999", - "0x60e3893ea8cfd4", - "0x39a1953e683816", - "0xac67723e28fe51" + "0x58913d3ec8a62b", + "0xcb571a3e876c67", + "0xa415263e48d5a8", + "0xb4b9be3e0927fb", + "0x8e77ca3ec98f3c", + "0x003ea73e885578", + "0xdafbb23e48beb9", + "0x4dc28f3e0884f5", + "0x26809b3ec8ec36", + "0x9946783e88b272" ], "withdrawals": [ { - "index": "4864971916622804241", - "validator_index": "2164897", - "address": "0x09988f43d11dcf2aa7811c9997eb4119e8f153ce", - "amount": "4866624404134455665" + "index": "4503077933255190248", + "validator_index": "2357271", + "address": "0x42fb7d43b1006df9874a521b12867f80fbfa5084", + "amount": "4868276887351139793" } ] }, "bls_to_execution_changes": [ { "message": { - "validator_index": "1780148", - "from_bls_pubkey": "0x98d6103215e3916a0cff3af6b6f29f22374a32d87d440a302e18a9e2daa80b32a2824798030f6a2e06ab612b07c41f74", - "to_execution_address": "0xdb034f43b15d672031628c76afcc23e92d134914" + "validator_index": "1972522", + "from_bls_pubkey": "0x8db8ee645b614f990839e4d98fdbf921263bb62cd917fb4eff9084dff23d7cc453f6cc645ad8b869aa9d31a6b9560630", + "to_execution_address": "0xc8e25443111288db3b1f254bdb430f1c27104a82" }, - "signature": "0xa2f3dc0cbadf0807f2d864d0c98c2e474972419b1ef936d0c68976eb732a146c8bd86194e95381d1b9245530b1f138cc0de425bd6478bc56a394619e1192a114680c4e9f8b0278816bd4f5df9e24cc31ca73cf5eb26da54eebf958966d4a957f" + "signature": "0xb0c3172e9bab8d04faa5d27f9818c36ad61a71b114f5bd9dbe77306be3edef2bcb56c215511ba76145006daec95f24be0f1f0dd24377cf7b440b5cdc7d0b520d6b64c539eaacaf14875d49c293af5974751bb0ce2daafde3bd01e097a466e75f" }, { "message": { - "validator_index": "2856403", - "from_bls_pubkey": "0xac60d2ec631e27b37f4f5541319b94c8cf82299d71ae4139039cbc1d0c30c71a075cb62166801ccd0a56f0bc29edcdae", - "to_execution_address": "0x01464343f1f425aa1be85acd56de4c833a194738" + "validator_index": "48778", + "from_bls_pubkey": "0x8ba697cdd6f8c34a1fb96a4c88f03360d19515ccc4e1ea24aa5e80075d821059806a0047e6bbf5d908d312d1902aff5d", + "to_execution_address": "0xee24494351a9466526a5f3a1825538b6331648a6" }, - "signature": "0x818852c88a6e16f2294cb51803a155dcac4f6ec5ee0d095e8890be8907201ee1c8790abb6d5f05faa2b3d8d9a03972800a04fc1666d877c7cbfb62c387d6e119f8f827ea2ba94d5b6429b33d6f3770b79999da3cb8ed17f2c8977234bd2a1cdc" + "signature": "0x87fadfd11bc5612e06c59d576c91599bc21095531fcc27a177967de7b521c377ee7a2b10d0fadf38779089929cfe136518757803c369b4ce94873e28d7d9cdf54c31a53ed86b07f76ea6104ee65d76de02267a4b736c949785ef233cbb73ad4a" }, { "message": { - "validator_index": "2627637", - "from_bls_pubkey": "0x92f00f85478ad1224c1be3a9b9230444411e9a2beeb6304e5c1fba1b7b54c9ecc3965abeb3385e4916040260544b2580", - "to_execution_address": "0x5d6ec4433175f5be08277b12261c89e3b0d65cac" + "validator_index": "2820011", + "from_bls_pubkey": "0xa32a5f28ae7d36f888820160335232fc42ef994b4f93acf6a8659762b2ec52ca79354cc07c73a229b529bfcebc705eff", + "to_execution_address": "0x4a4dca439229167a13e413e752937416aad35d1a" }, - "signature": "0x8b13ef837950d00a469eae427c1fea111ea85e0dfd63c09bdc02aec208523ec4c805595639d50e183dc893022f60abd8118d62c836b6d4de057967f80184532c1c3a25b26c51926a07e55d2ba264de6fd22eb0665668cc7280bbcdfdfdb3c0b6" + "signature": "0xa2089742415bdf32fa2dde853661a095ac24d273413687ae04fabb99ae2982700bcdb885d239e32543ffb95763a43e690cb1bf3a33df40d24e12c46d150e9c59dd63f960dec39712dabf74c08a55ba1bcb6db664ff9d5b2261da353e4374466c" }, { "message": { - "validator_index": "703892", - "from_bls_pubkey": "0x8939b0ed4fd0659427739e525d6990c02614d703d12c5adaa5f8aeedf64fb9ce66e769d83f9ec61ec05c6074d5095955", - "to_execution_address": "0x83b0b843710cb448f2ac4969cd2db27dbddc5ad0" + "validator_index": "896267", + "from_bls_pubkey": "0xb679b4b686530827b2a201eb2b18454e9a5758d7257737b29bb215b9f354c2ff57e912b19d4a051556187aa24c97371b", + "to_execution_address": "0x708fbe43d1c0d403fd69e23dfaa49db0b6d95b3e" }, - "signature": "0x8f65a298124021cf26323bea9328da795a7f2134f42c21e28617a1b663c568058fa3ddff9a71948362e7380cfb591ec9062f735067b1a32bd2b88e9c2d5c3404348a194098c30f55f8cc050b305bc4c2baeb2a6e4ab1d49833bd7ec4943367f0" + "signature": "0x8da9cee45a3046b209da332512a6b4e4d7c89768f55998eb79ee236b4fb1fbcea87e0bba7b05d19ea7b8c5ea6dc0081e17a7ad0ec41566a0c6d9e127b87691e1d5b823fd178069e3f30091dcdbb44c36408656941755177c45bc976bf270289d" }, { "message": { - "validator_index": "319143", - "from_bls_pubkey": "0x8f5f289f8ae538eca9f393fd7ed1a5432ba4c145b700075d1a8ea9530ec8cba3b91511e78662d0f2bed026a1b86d6d2b", - "to_execution_address": "0xa51dc242b07456952ea93a8886a01023c35b31c4" + "validator_index": "511518", + "from_bls_pubkey": "0x83b8c61b63de768821cbd82ee3c67c81bb848163d6af0186ffe1ca3936d283bb4cab886f3fbc7f6336fec3da8d542c76", + "to_execution_address": "0x92fcc742102977503966d35cb217fc55bd583232" }, - "signature": "0xa23a1e6d9410ecb12fe95fbdb3b12962bd46855fa46ccd7b2fe75696cd4b1788302d6fc3bc1c1bc6f8080d0025b3fdc9139a3b141407213b8123563622773e9b385473bcd03f149b0ea21e52626382dba56b95a2204178c2c454001c79289afb" + "signature": "0x8c90298abaed4b5124cff46e41c9a4ed2b2baa0d2089add6b64c70dc7547f1a83bed76aba1fac6d36605beea72734b490b7b98994c7c65fdb436286b0df898731f6ad536e5a603da85ec8cc4488b94dc8c61e11363d1cc18733382dca51c7008" }, { "message": { - "validator_index": "1239417", - "from_bls_pubkey": "0xace9988853ce03390f8d5c93fa51e3a5f5b056bef4ed1f437a86c59fb687be25d0e6f4be5beeec4bc04806e93c3eebf7", - "to_execution_address": "0xcb5fb642f00b151f192f09df2db239bdd0612fe8" + "validator_index": "1431791", + "from_bls_pubkey": "0xa532ee397fdd9e388888d90f712e13b085ad5043402debe1caf3dabbb514ed0d06f7c897e4e2795fd018cd672bfa8948", + "to_execution_address": "0xb83ebc4250c035da23eca1b3592925f0c95e3056" }, - "signature": "0xa0053dab17b7e0ba64416b1c95b6c56ecb7f39ccc272cd57a347054fab6781ab8d834eda1a4e57ac5b037d3b71945d1805216ba518aefad29922f57f1b3149151d4266ae944b579de5399a209e482a19d3fd7e9c02069e7a01ab2e9a59477326" + "signature": "0x8fb8cb9373db269dd2a05fe0a07484db022a95b06c03807426a352499fcb65c55f8c388fd4cddbdd9936d5fe5ac5898e0d8b58ae09a73bdc7e584fe9940d3aa967607a0c4a1ad1ce5ccc0ad83f63a273e140ae0510f709cd0c214b645d68e3f4" }, { "message": { - "validator_index": "854668", - "from_bls_pubkey": "0x85a2763ffc316d21106869ce72f88e6e5aa3ffcb84689aea186a7de5056f0fa98f50ce3bcfb8a96d33585c472748b014", - "to_execution_address": "0x8aaa7b422f00cecfadcc1191710a07c00e80259c" + "validator_index": "1047042", + "from_bls_pubkey": "0xb7d85608c3cf919ee72c0481283b468c2825850f6f6028c000cb19bff464556973909667d0353582d673e1049795f20c", + "to_execution_address": "0x778981428fb4ee8ab889aa659e81f2f2087d260a" }, - "signature": "0x84ff1208ba8c36a14bcf8c5d3c9d9e22dd6d69f7053eaba3ce96cf7ca324ec3c3a2bd097053788b7dc64d7dbccc30ebd07fbaf41e95ae397751f8aadbc4d84219038b55e1fb3785a8f7ceebe05d629ce2c9c407bb9be6c66c0d26c14b3a7c3c2" + "signature": "0xa1079cff71763f60894927a0ac68cfff88642e5ec4e11d1f63ce7d7b15f2567842c80c0238a0f6e4d38ac2a9d09787c50c87daba460e05a0336332f1d37b65fed7526c5eb51a84d3a0169d09ddaf271d13710d22469e8dffde8859d50a2dd0a1" }, { "message": { - "validator_index": "2086906", - "from_bls_pubkey": "0x8f220bb09673d250a17cdd562f33ca615e83e293a43e1313a9c3e9438c218cfa9a803426d29e9bffdd884daecf7e0ac6", - "to_execution_address": "0x4dca2b437023a3bdf0f3f77aa4019fb753254380" + "validator_index": "2279280", + "from_bls_pubkey": "0xa46cb4c6f51759dd36e897cf8f5f8a774dbb5968defec8bcd85b9ec0f3d873a6569fabde6c6cf3fa5dc77e910bc39938", + "to_execution_address": "0x3aa93143d0d7c378fbb0904fd1788aea4c2244ee" }, - "signature": "0x81d6211b8ee9652820795832982520799ba2eab947083a2c6e56d9cdf1e678b1c1a6c8a108ece8b1c23b234a208e6e281477d55c41fc3d04027032277fa0922a0370e76db742037a0688697f618b8b7780cbfb3725f78bf9c5f94876d9d1957a" + "signature": "0x988ea703ce8fcbd5bc7811c49e1eede7061ce461966a9a52f03afdecb157f065a1993fd71ea29c6769121610fc9e3e190eff938fb8c2f77dcf5f511208ad23cf427c05dd207b6c6004ba2a1ee3b6a84949e39db4ef1ee254635d3527010f7794" }, { "message": { - "validator_index": "1702157", - "from_bls_pubkey": "0xb63a024e98bf28daf9bf8bdcb7c89d823f29e65e362a923afec6c78aef21559a12d2c5cdf81998630ac418034c0e58ed", - "to_execution_address": "0x0c15f142b0175c6e8491002de9596cba91433934" + "validator_index": "1894531", + "from_bls_pubkey": "0xa18343c3306dae4ff3c78428069a4ae7876f0ad620219648b99b4bfaeea1d7898df50d508533e756f5903efbdf585076", + "to_execution_address": "0xf9f3f64210cc7c298f4e990115d157ed8b403aa2" }, - "signature": "0xa386f611424c8ec936f7ef72da9d526823e3bd03f3452131910b7c5ae646a989c276001faa9398ff3ce9050cc0282c5003ee9357b8485f4c52a4321e9c5150d39cebf18546badc0a22d7d881a08bfcd1e76c4a7c9c8cd7f85da5270877698c7a" + "signature": "0xa120e4f3144799db31e7487d25cbe6d8724f0076f23fdd7ff1f00b24b304a93a97862a3ebecb5e1b91018a0496a3c4020004b5d49571f4b9a3faf0f9d8f1f067d7005b5600db18872732313acf1350e1bec278384f3e0fe28d43f00203ae10e7" }, { "message": { - "validator_index": "2778412", - "from_bls_pubkey": "0x90961673ed2682e726960a035e0d1e050ff0754225f97fb7501110e474cee35f7ed1bdeb70eebc97a59abbd7217bc691", - "to_execution_address": "0x3357e542f0ae1af86f17cf83906b95549e493758" + "validator_index": "2970787", + "from_bls_pubkey": "0xb23734206f673528ad12bad1b7815a9db722d7a5afffdfac97e17d453fcd2616a804619bd9f8db50b9547a357b1f5813", + "to_execution_address": "0x2036eb4250633bb379d46758bce28087974638c6" }, - "signature": "0x9590d1d0c5216aeacaa19bb58a4a66a6430e554a0b020e2977be2421bcd089fb47bccbe10f2baac88dee33fc625dd5441217042918ac793c0aa2aba45a379decdb018b7bdd277f2a66b122a95aa1974cb05208e00801ed52f7f86b671c372e2f" + "signature": "0x8de01f498b48fd1df0c20529228b7e8616c7bfc35457d392404110e394db4c884dad325363be1f2a83ac383486cdea460e78e89a728ac9464f71dfbc685ac8be3fb9ecb21d67a6c105354c58bfb78f2adf7ee65f5a4d7fbe5989e522b52daccf" }, { "message": { - "validator_index": "2237681", - "from_bls_pubkey": "0xa63d491bd47a8f4caf987b7a22f228dc709f8f4a0d8ac25ed72a18cbe2b2da7662daafbe182b33c81e14eac70bc2f0d5", - "to_execution_address": "0x55c4ee412e17bd44aa13c0a248def3f9a4c80d4c" + "validator_index": "2430055", + "from_bls_pubkey": "0xb490d2df5759bb5115690df9aa805cddc1787b17fc3984ec400d03ccd5c6da6dbc54a724816ccf0c86b4b23e4daf0b17", + "to_execution_address": "0x42a3f4418ecbddffb5d058777555df2c9ec50eba" }, - "signature": "0x8e4e43252f668d04559aa2ecf1ae7605a054c1fc2d5b0a9b77f9b091b8fd851ef5a02d54ed31a66053144d0319d8f4ac11185d05cd68099841cc554c99de314a291e83c4bd166b924240d4851d8ff63a05c62def40f8b839f087a60db6ef5172" + "signature": "0x909ac7032213a33af76294ec19617f3fd9859bb22201e0502ae7187debe740c5cb0367ef03e944eab7fdc5ab23d303f916904a1ca5f7aadbcfbab89bdd82931dd7ff3e0efdd1135698f54774989ddd6d8ee07bebff863718c927072564a547bb" }, { "message": { - "validator_index": "313936", - "from_bls_pubkey": "0x856c75ede282fb092c2c5ce1511945d4eb5026a095e7ebb8ab6a231ef8884390141d100ecc904fdd58b1f2f0e07b1630", - "to_execution_address": "0x7b06e3416eae7bce95998ef9f0ef1c94b1ce0b70" + "validator_index": "506311", + "from_bls_pubkey": "0xa2810855686190fded08fbafafc427d3540a58c2b391c0d05a71be7a4d1aff2b4ea501c8e4c1ebb79cb49f1991ada976", + "to_execution_address": "0x68e5e841ce629c89a05627ce1c6708c7aacb0cde" }, - "signature": "0xa31249a2500d0428a2b38100b6db1191f1014087af8e58cdc025e28fc9e2aa5f08c74036c1c99b5e6b9f96c250700e2505201e2d4657bff1de53e01ac3c28f2f6624da4e953c9d08b0011e547902197fc5317daa051526f68684f16e1608ff33" + "signature": "0xa108770fd60463dfc982d8725440e47c54730329420bcf05a969e4937d06e468385b53c4a5f6c69e55a775f358fa0948171dedf3bb0ccc1679280251b7abe4cc644e10b46bcdaddd590951541bda68373c8a8dcbfb86d3cb97822a5dfc21f481" }, { "message": { - "validator_index": "2929187", - "from_bls_pubkey": "0xaa842a4b0acf1250c953110bfa6025bc646043fc268749af5274dd0197f06eafd7f5ec00e2d21a01b8a420e8178bf74d", - "to_execution_address": "0xd72e6442af2e4be382d8ae3ec02d59f4278c21e4" + "validator_index": "121562", + "from_bls_pubkey": "0x8deafeba9f0184ffa1f3d1422b9d97d6975fc4d5a21df265b48b6e831d6aee5a6236b3d5fb9e03cab1e0795f3dd45206", + "to_execution_address": "0xc40d6a420fe36b9e8d954713eca4442721892252" }, - "signature": "0xa29e82672b9b023ec4496bc5ba26cd0e12ae4e168591a2412dc2c62cfbf0466710810999921e34e7249e3a4700c837ec115bb6bee111a50c55a1af9d2f996bb6600a4767e23781cf4eb177845372b39df6156906f9e24c5b908920161a44d8fa" + "signature": "0xb489851f8a8fd535ee14505b9ae32ab27cd8d5e637236f491f71bfc987316491ef3f1b7670378875580eb247993d82511128502ea093d108730e070bb8c5919b39e78893139b3f1a499e885b15d385073e227d6a4e85ba0413ab9e2481d0b8da" }, { "message": { - "validator_index": "1161425", - "from_bls_pubkey": "0xaf50133072b8d7a0ab9318facb15087021cdde3205929004ecae6df99d4cc111517fb629146398eb345a028d413624ac", - "to_execution_address": "0xfd705842efc5096d6c5e7d95673f828e34921f08" + "validator_index": "1353800", + "from_bls_pubkey": "0x97e217a0c3c7827753099f05459884b90c0fcc97c4c7b8144b06a29c3787cb2672cc36437d19f5d1a07d175683d345ae", + "to_execution_address": "0xea4f5e424f7a2a28771b166a93b66dc12d8f2076" }, - "signature": "0xa34048285c5a03bac9edfcf306e845a8cc0f8e7f7b4c5590dce0146b30b5a4d6340855b4384b53cc72b4ac5bb9b372590a7f7eca40e78ef3ae9b0e9dfe020abc94d161627ff642df1386143f221aee8ba432f4e7affa7736c65a01e6f342cd4d" + "signature": "0x90261b9bbd447453cb0f85f40b0a16dd1f39c09f48b866601f7f7f01a3b5fb3ba84c04b6d6708930c9d174891b68d2bc187b888dba79f8f85ffab9f786bf8f2fe79315714da578940bfaf09e181e3a784c95a906591cf4d6091a7ad45909cf83" }, { "message": { - "validator_index": "776676", - "from_bls_pubkey": "0x8671285e05b25760c453c12261a1fe347a2cb3fface5eca837364a24da41645a547999b471acfac8f43989f4f1d7eaa4", - "to_execution_address": "0xbcbb1d422fbac21d01fc8547ab974f9172b015bc" + "validator_index": "969051", + "from_bls_pubkey": "0xb3520fa89ea41f471ce87dc8aed9b9f2c9999ea5c94f6ecbb925c4aa4d139883ddda3647424fdddacad7948e9015934e", + "to_execution_address": "0xa99a23428f6ee3d80bb91e1cd80e3bc46cad162a" }, - "signature": "0x91637965215d68f27949e164adb593958a4e7f451efdc129cf78dc59baba87086bfcd637a0490f2f6c556bb0ae2f39ec114f84c900cd874755732f64b889588ddb0fb445e031dbb708916fe0b23c38f3d465e3b55b0292d31096efe3ad6e556b" + "signature": "0x95365a7224ad80f38191cdc1b726ce0884b032e2acc86bb51019b70dbe7a2b176cb2938cfade8dc4d4e463f5ca125ff60a50f416e050c1dd4a7ddaabe5983052a12a0597bcf16adc1efb4091ebc57563389afd97af6b99bc5fbd805f59a8766f" }, { "message": { - "validator_index": "1696950", - "from_bls_pubkey": "0xb6deeb8bd3ab7aac208e55e1657b6379313f7e77897e6f6f3882c2d84548c94a20fd1b23f4f4bb8a66fd7f5780ca6985", - "to_execution_address": "0x452056416dc56a4392e03c0bc7c309ce4717f41f" + "validator_index": "1889324", + "from_bls_pubkey": "0x843c787e604d000e4415cf369a541fcf9b351327cbd0e56940ba071167c0bff9aaeb005105146152746a0ed76df62bff", + "to_execution_address": "0x32ff5b41cd798bfe9d9dd5dff33af5004014f58d" }, - "signature": "0xa6db392c592dfd0dbe1c60583888a00f93fe400e99d66c06c1b9aa7106f7ec1aeb1fcf6cdfd0cbe0fd22bc578ebe6a7b075676526dcdcd40118961c03b8721f92ca9d3123b21174d5f2d809b40d980593b4da522f95b9de9f4ff4856fb0f6d0e" + "signature": "0x8daefba6498ad8c68f592546366a9e21f0a3e7044297efa3162f7c171b46b73a03ba872e6c7801ab17f5a80f3bcaeaea0f1e0e11a7488603c9e40df1e2d56deb5d087c70e17a1bc626f113ed000514dc2a65857feec2e52539a00142ca88d0f7" } ] } diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockContentsDENEB.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockContentsDENEB.json index 2ab2a49733f..928500fd404 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockContentsDENEB.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockContentsDENEB.json @@ -1,8 +1,8 @@ { "version": "deneb", "execution_payload_blinded": false, - "execution_payload_value": "11103013652248291612222159278156471032005615587981889885338966324871092985294", - "consensus_block_value": "19755222334871137581966673778023884694586692954373005173000436914838007452761", + "execution_payload_value": "9074003755965027577898412849272089981780862548198517622930893380413065004589", + "consensus_block_value": "52335047088093692175629908587741169571103578927521980677976976500308305025762", "data": { "block": { "slot": "1", @@ -50,19 +50,19 @@ "4589007099177470570" ], "data": { - "slot": "4580744678799082634", - "index": "4579092195582398506", - "beacon_block_root": "0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c", + "slot": "1", + "index": "4580744678799082634", + "beacon_block_root": "0x17348c3f2ad0733f4b47b34442744b4a2e03a79b1f52c8e8922ee71060a05b1c", "source": { - "epoch": "533461240", - "root": "0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565" + "epoch": "533653615", + "root": "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06" }, "target": { - "epoch": "538462976", - "root": "0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650" + "epoch": "538655350", + "root": "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0" } }, - "signature": "0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc" + "signature": "0xaffb36fe3e48b5c29794f85515b9a3adcd4206fec6dddac6926d0e985d96a9ade0e427f911d56dd90f2644af13e9740509147d149defa9b0763eecba616e0815e9a91c25178860be7d4196a9814781a4576ba7bc6398ef16b9bd5f88c4143bfb" }, "attestation_2": { "attesting_indices": [ @@ -71,311 +71,319 @@ "4589007099177470570" ], "data": { - "slot": "4620404293179370891", - "index": "4618751809962686763", - "beacon_block_root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b", + "slot": "1", + "index": "4628666713557758827", + "beacon_block_root": "0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390", "source": { - "epoch": "538078227", - "root": "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb" + "epoch": "537693478", + "root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b" }, "target": { - "epoch": "536923980", - "root": "0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5" + "epoch": "538078227", + "root": "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb" } }, - "signature": "0xa32991816eb9f297553b4732309a4cdba7b33287264611715b0ab3319bca19e581da6e2659912a4e0e94aafc01c488e30ffc96ed14e2a726b9d3c618405ee0bf54bf6ae7f2097465cb27ab8132ec24eb93d3c9159475304082f7f0e452b93b65" + "signature": "0xb7720f152c38d7172a82186892a68440bc4d285cc8aa92c1f017f93d5f61a29cf51670e4f944648bd8df82d4d6eae00615073d439389cdf35fbd7670a07ef8407c7c71a16be062fff16f351737ac99f006817ba43a295fe5286dfb4ba7116e07" } } ], "attestations": [ { - "aggregation_bits": "0xfa79cdb89d0d51c5cdd001b7425c6d726750a9d5f89ade6ed9890ce3a706140c399a5e10c90a819094b65322dac7501f7c75471e69d4567358d8ca75f7c1b3133ebecf006b369a1f36efc5f2b706d5922ff98c58a1825a53a864376658f816600cf021cea843d4396502bb9c74d1510afe26036f89f783b4f5c7bacb6649c46f217a6af835f312d6fa253d2bbc83c07993f4f10de2ed2d952689379dbe4f794c1a1055a6b364d68e038deec9667f576b3b9eca5fcadd6298f181e1edb876efc3d0975ae14ae9a0ad2f1836d4c3f1080a96d8ab7c43b34bb2eda895ff66be698b363cfa4be33da3ec94a1a7a90672fd12c4a59916bb937e78476e4f08e4f4031001", + "aggregation_bits": "0x88e3aeac2cb7509e753b73880be4e95da67b35193a1a8d916d3a5f3b61c59b6d90d866ae7ee81a10a9ea025ade39ad5b978bd20bd2d2031d61e8aa7b5090b08248dbcac0698c25ea7b858ae37e5347010aa764962e4f70513d9e2488a9808d0510dcb3dc9385cc9c28ba4a1eae314e5c3372b3d2387836dc0750553f84b1b490b7fffcb2824b614596050fa2ffed45b30b7db4e67cd782cf0446b5448ed43cb01991cde29c15b0a29dcafdbf29840045c4a3d7e58b93ff391e3ae281185e49aeeed12188548d0dc8e904edc1c8a9831577d08b0c708dbb1784cef981e8363efb46d26f039c2561792d1a2e81218eec593aefaa25bb280fbdd25f8103381a51c601", "data": { - "slot": "4605531939934246443", - "index": "4610489389584298827", - "beacon_block_root": "0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b", + "slot": "1", + "index": "4615446843529318507", + "beacon_block_root": "0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6", "source": { - "epoch": "529421377", - "root": "0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2" + "epoch": "536154483", + "root": "0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0" }, "target": { - "epoch": "529806126", - "root": "0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd" + "epoch": "536539231", + "root": "0x82a81c3f096d065c7e3f5d7df79bd182a53c9471a737cfb9f7c4e9ed95d0f767" } }, - "signature": "0x8f8d16b39e14569aab1b712e5c19ed51afe3600a6b017e8ab432f43a02ee720a733c33ef087d2f3653a9701e8d8a836301655b9195c0373b775c88ba1368e5d55354a70a3096bd26dee29dddbe7a4820e2b1653e84122beacbc01af7d93e6bdc" + "signature": "0xa9aef1e37252740dedc5fc9886810459f7484555aa59fb3876803fc4924149cb471ffbbd9be5324d952efafc3de4c5f705dd02134916b2afa02194fe90a8d1e8f58ebcfe0d33d0b8a97e71a3f7591cb82c37ba531c059a684b581d3857f05e3c" }, { - "aggregation_bits": "0x4ac567b296efbf7cf3209e87096a7a1a50fd523400113f917f6584a5a306f06b2d8da9ae858d47ff2594010089838efe41f19a78d9aae27c2ffde26f278b8681db9d091eb72e7cab3e449dfccd46a270693e1f88f197324e57bfd45573315cf9fb60d770937b32f7c0c6ce1581ec51e6b60f71acfde304dc917f2e0aa7872038b7d9140d15f7927c23a0490a74c2b0aca2773fed9217067e4444f9ca93874e4ff8407111c3efdb138b97c6d4957b6a70ec1debb283e3d0eb1cfef068adcffbf057d20fdc339eae03f0fa2613abdde8158a7fc40c3cfd1117eb6f8c4ae21d6b2ab4b57ae9a8653a34451aee6418c0c3609dc937293f5f5b346a7ab1a0d144185101", + "aggregation_bits": "0x0aa2e4365aad4ec5115dbc42fc6bcda2a0739e4b8c6c07334b99338ec990c7dc93162171b1ed0afe8b1f151348438523b428076a646db8375993d417cd79f1854f796992a8aea702eb3180373e7ff4b4c53ef3b306a5af7f82ba3a4a362af88084e7d166dd0ed5026019cd4f2c4fad16566f927d0dceb14203e8abc293267466c487eb2b108ae043792ff8e8c56e9fbb26d98381ad35e70558cc74f74d1d5a7de764645e15298f90a9a4292e58188deba564756775d54bad38de697be7659cde395c60f403933083c4e71881c26d15c83a61359fbecd1c12d8f31c0d440c128c416e09ee2d3fe64b8a4c737c2f604756d08d8c1f77d4623404e031805797412b01", "data": { - "slot": "4544390030852162633", - "index": "4542737547635478505", - "beacon_block_root": "0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd", + "slot": "1", + "index": "4549347484797182313", + "beacon_block_root": "0xcf2c053f899b836f534bfa2a45bf23b7be4890b9815a72a2aec9f70eff53d592", "source": { - "epoch": "527690007", - "root": "0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8" + "epoch": "528459505", + "root": "0xa8ea103f4904c5e568c52bd49eadfa1cb142929514c9202e53c7707e4a92667d" }, "target": { - "epoch": "528074756", - "root": "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8" + "epoch": "528844253", + "root": "0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd" } }, - "signature": "0x90309dd491ae6ed51917dc305a3d4ae68d0a0d4792c7eb59c193bd03605bd94e61cab37502de0ad3e6162bc02427bba80a798b3670d5de82a854094016cc298b265371345c0e3ac49fd44bbb9ba0d4fcea0c1a80cecb60e93921d907e8c48120" + "signature": "0x8f5c34de9e22ceaa7e8d165fc0553b32f02188539e89e2cc91e2eb9077645986550d872ee3403204ae5d554eae3cac12124e18d2324bccc814775316aaef352abc0450812b3ca9fde96ecafa911b3b8bfddca8db4027f08e29c22a9c370ad933" }, { - "aggregation_bits": "0xe8c9759f0840f980ae956b15fc383d992e7d4420d12ba5bf32f669f446ac6fa388e20e5ce96e9266dd98840179d2cde3cabd9a8bafab5dec9c2e89f7f78c989e690548603984803b80c82d7b76443194576a1ce49da5cfe56f56e83b745fb01b5f18ccc86d88f5a22d927e64ff0b8e880893abcddec45b268531c4a0697537dae643a24b1a36432f37d42962553bd39af71f37e0429b81470c11316aa39db074aa3f1df4124e7cb203debed60b885ffb9b27e46a1434e81bbd56566632d0729c0822ac415cbb67f25973667d88e58df9c2f058a0ae7f118c98cc448453b6fbe590363bd17ed62c2f808df61f2a9e593235eeb56db74b9dd15980189a5271468301", + "aggregation_bits": "0xd664cfc4f928592f21ca9fae84cd2a15d4acf76e0d2cbb493324ae9cb25757559fc4b060414cbfd84de047d4f04da4aa6669e83b9b8418d348bfc46b3fef684ffbf0162da3c6258f690b14c94cf448280b646c140b24928defd2d12434dbbbd0afbea5e5661fcac8116699ec8a059acf084ab956ab0eaf508ab7d3e4bd352a80f6b8ff73b4b24753a865991c45c9d9f0e1675e7327ccaaeb146bc3d0a4db2d7e607930579fc38a41d5019f222166cea9ebebfe0dd7b875fa612ecb7bb80f83718702da59fd2687d445048ac99f25b5f088fe931ec4bbf9ecdfc169844c00bc69fe38c0110fc59105233b29f6ddecb7968065fd7ef787e41d3545fefe30314fa401", "data": { - "slot": "4529517677607038185", - "index": "4574134745932346122", - "beacon_block_root": "0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947", + "slot": "1", + "index": "4536127614768741993", + "beacon_block_root": "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8", "source": { - "epoch": "532884117", - "root": "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31" + "epoch": "526920509", + "root": "0x41f3e13e4961bf0c12dd652f3bf49e85e35a8a25c70e67ffc1d08cc01d9921d3" }, "target": { - "epoch": "531729870", - "root": "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672" + "epoch": "527305258", + "root": "0x51977a3f0ab3110e2a10e9c6bd0e89b1410ca45142ac42171bb2b169efc281bc" } }, - "signature": "0x8c40f51a99fce6ebb9a4db5e80d715fff319e7ae523e46afb5d03c000d427e23c7a39e77e2af53851706283c8ca91d680997cb459386fbdff52c4d0ecf498e173717a838a792b210bdffaf476538628584a133899bf30dd5ce7056463b8cd683" + "signature": "0xa17225b5e5319618e77f5b93350430acfadd8ae12a279f1a4176cc7ad1de7ecfc8670988519713fbac8f702cca29bddb14ff1463dae3abb53ddb0c025cd69c8cfb0f5298ab241c06ddb840c7a260f3dbd37120826b13b17e22d086148ebdbab1" } ], "deposits": [ { "proof": [ - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c" + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7" ], "data": { - "pubkey": "0xb1f8f6e731dbf6b4e3265fb857c7190adbfc7e6cc95ce2e8bda72be8b6ea3459f862310a2484c3b0ee33b30920f18c1d", - "withdrawal_credentials": "0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c", + "pubkey": "0x90b2ffa8992560bca2080afa9b3adc904ce9085a8c2cc897282f20378bdf3cdc0a74100f226ea698e07d4afe50d8ff54", + "withdrawal_credentials": "0x9d1b633f8ae18e21ff1b86740b32dbe55a18a0991bcfe5ffd2b6bf8a59465fe7", "amount": "32000000000", - "signature": "0xb594382214f5bdd375de66c45e1c61a526c7b73fb166c72433bbd9c2a7ad6881244e61cc6427e0206a50b762a129d8830e8708c55761d61ce9e3b19c1bee13bc55daa13bdb07118efdbf57a588b8a64e6392d14f935e53b68933e3355b35acdb" + "signature": "0x978f1439422f6e539e93927a7754e7f9866fbe5832da066bb8fec5041a6818bbfe7e79747a963eec57f76924aeb591d0133ffae96de0793f02d13a13e1f7286a7940e48093ceb832b58e9d6bff9adfc1e8f59367d905633d743cd62ccbd2b27c" } } ], "voluntary_exits": [ { "message": { - "epoch": "4562567354825622634", - "validator_index": "4564219838042306762" + "epoch": "4570829775204010570", + "validator_index": "4565872325553958186" }, - "signature": "0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e" + "signature": "0x8c2c3b368bc00b3853e6df352e816dd910016db953ac77cc1565e3c22f1c0b24c59f24ea9e8ca406aa95b23368d163e80baa6de3f8f7ac19ee78c976d2ae5a21c86fa1762cc959bc734379055cb7aa1de36eae00541936b8c2ee908c770d41ff" } ], "sync_aggregate": { "sync_committee_bits": "0x01000000", - "sync_committee_signature": "0x919ee45cc18456f6e85da6bc21c2e40f44f9a887932c73ea9ad354f88e56d4ec0a8c396ed143082c8e31d697b877a2a215d2966d91c7beb156bf7ab5777e210012f70dcd5f7657808a82cba51e194be994f917150ebdb9e5c57476f1edb47206" + "sync_committee_signature": "0x8166b2ed13e982e6b9f05d30f42681b826099135a533d2614ef5f4f59811714245db0e1821a644859559f97ec1e614bf08b2edb294fa2edc1527f46596399534af23c98613e1b74c01871bf1dd2af9618bc0ba23ddfce8026b897cdbba8c1bce" }, "execution_payload": { - "parent_hash": "0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be", - "fee_recipient": "0xf8eb5a3ea82ccf3c1be1ac153e3f77f273a07343", - "state_root": "0xbf886c3ec849316e3b187793c3a4398b6097768d06bd968a54e8d2652d2a75a9", - "receipts_root": "0xd2a9663e689510b3305bdebe972d4e58669a751fbc85bf448269162e078b2c34", - "logs_bloom": "0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9f770a36a743c8a3abab61dc439ddc0604dd5015b1ed3835787d9565dee0f3e64b25de4c097defe3001f483a4b6feac22b992cada114bfc709d483b4d94f07bb0a1c4fb9e93ca3c31f4b9683753ba33ffd971777e301367f1edfe6809da491535c711a7877b4c97fd1a756136c412b4f3c4471ba439607333623558a63030f2cb6bc2ba885822672de14ea697d44fbcde134b6909208466be0b4c981658ba30f999c991aca746c3331766af1ee10cbe69624066708ae086999a0a3853eb777b3f9f0455cfd98a98c7719710515b97c596d2b662d353a90206e470c523d4374853", - "prev_randao": "0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874", - "block_number": "4491510546443434056", - "gas_limit": "4489858063226749928", - "gas_used": "4481595642848361992", - "timestamp": "4479943159631677864", - "extra_data": "0x58913d3ec8a62b95e52fb1ee60ebddf392af6e1db902dd5bc3f1eea7003130ff", - "base_fee_per_gas": "48712354854557871613352262057776104244427151172201944877932608112921551169417", - "block_hash": "0xcb571a3e876c6732a4c11cf3562059c2b8c16889ffb6d1b8d5f883591e767c3f", + "parent_hash": "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "fee_recipient": "0x3624343f893e8948a933c0cfa8787f4e8c309829", + "state_root": "0x49452e3f298a688d9e7627fb7c01941b923397bb84dd548b6e411f9506aed1c7", + "receipts_root": "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "logs_bloom": "0x23033a3fe9f2a903b4f058a4d4ef6a81852d9997184c0317133f980452ec62b2b061e83c58b49a2152d35e2d52dec57a103ce8a251c901ef2fab683582825ff8b0b008f76d24edc9c1ae40d0e75942618263f7d7986e9bccf1329656466d543e00b24a93476cb3f928af4367c6625a9cf341db27bc452836499a1efdd2c9eb5e912927c2878fe39fe1a2b36a44c10572cd0437fa4fd7e83a9db691bfbf5b9fcaeb8b2ea9d2b89eeffc8cf98d5b66f53e527f376d29bf250544a9eeb288757962a5fc0eae509665d2b90702b12b5caa0913916a48e650fd430ceafdde0d71da95ee9ceba330c6cb0412771d5275464afa7adcac63634c91ceb521f22e12b844c9", + "prev_randao": "0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be", + "block_number": "4493163029660118184", + "gas_limit": "4498120483605137864", + "gas_used": "4496467996093486440", + "timestamp": "4488205580010065800", + "extra_data": "0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874", + "base_fee_per_gas": "5451311522429616772243425117521481983710813629341562216088296324789550535380", + "block_hash": "0x1f2e4f3ee8c38dc605677b6ce650a08c7fa6716795a8622d396e244f710e0a5f", "transactions": [ - "0xb736203ee72088", - "0xc7dab83ea972da", - "0xa198c43e69db1b", - "0x135fa13e28a157", - "0xed1cad3ee80999", - "0x60e3893ea8cfd4", - "0x39a1953e683816", - "0xac67723e28fe51" + "0x58913d3ec8a62b", + "0xcb571a3e876c67", + "0xa415263e48d5a8", + "0xb4b9be3e0927fb", + "0x8e77ca3ec98f3c", + "0x003ea73e885578", + "0xdafbb23e48beb9", + "0x4dc28f3e0884f5", + "0x26809b3ec8ec36", + "0x9946783e88b272" ], "withdrawals": [ { - "index": "4864971916622804241", - "validator_index": "2164897", - "address": "0x09988f43d11dcf2aa7811c9997eb4119e8f153ce", - "amount": "4866624404134455665" + "index": "4503077933255190248", + "validator_index": "2357271", + "address": "0x42fb7d43b1006df9874a521b12867f80fbfa5084", + "amount": "4868276887351139793" } ], - "blob_gas_used": "4858361979461100433", - "excess_blob_gas": "4856709496244416305" + "blob_gas_used": "4866624404134455665", + "excess_blob_gas": "4858361979461100433" }, "bls_to_execution_changes": [ { "message": { - "validator_index": "625901", - "from_bls_pubkey": "0x8b772ee4cbcc67f534f33102671346cc3d0ddecc1a81f0350f68dd3210681c9e4bf907b49211cbd390bfadc7f285214a", - "to_execution_address": "0xb5c15a4371c6a89646dcbd1f07bbfa4e210d4bf0" + "validator_index": "818276", + "from_bls_pubkey": "0x94e2d4cf94fb757578c496885af2075c26e2483eeffa6e894ac791f7c1945b0fbf9a6f7860736db93e03d511c4b08516", + "to_execution_address": "0xa2a06043d17ac951519956f43432e6811a0a4c5e" }, - "signature": "0x85cc5356a9646f0ffd512b7d2e7d3242c81303a415e61b490d28635896aef1f2db03ae8a1439908d03cc131515ef83f003dd7b36ce480c43f4495ffd339b2b9d1e5461309a02ce193202f27d216a4f0e13f7b47295f3e1a44c8f0e8ae8e1e5a8" + "signature": "0xa8b4b8e92e67565ec430f2fdda94ed0f6f06d8cb302770191d614b795d194e4728c11e72162f25e04d0f7dda1dcd54da0d8a7c39e71e945873168ffa294da70dd1acbc1902a2fb1598267df5d277a0f95592967ea222ab0706571001c315eb2b" }, { "message": { - "validator_index": "241152", - "from_bls_pubkey": "0x8183f3f5071394e20f83599fe297dfda37f77a040362da8f8fe926a451eb9cfd917e953c51b81619f8e4925fa6177b49", - "to_execution_address": "0x10eadb43b24678ab331bde64d7f836af97ca6064" + "validator_index": "433527", + "from_bls_pubkey": "0xa5041469fc5f6a944fda64e7ab422c1479ab9d0de12a2f3ac7292dfe368408cbc6d2b0ff519b521427da731e7378806e", + "to_execution_address": "0xfdc8e14312fb98663ed87639047022e291c761d2" }, - "signature": "0xa19b99131e621d31846245039e99d6540418acc08844a3996544cca2d9965f8a24cc49cf695bd78959a784e1b5646b480b88aec749a62ea934ed3001af50bb8babfb15bb9df1f3d57abd738f65de02b77398c82302f500218675cd96ee3b2357" + "signature": "0xb66c9d2c80f5a12930f0899b9ff3d1a6a37e0f9edb279ced767eca8ef0380227681b15bd3850a00a383491ed1d8e869310f10edea2b912278e1e2ec1cfaaba8c0981af2e40fd233a9fd2f67ec56540c66e062212ee2781593a4714914e15cb52" }, { "message": { - "validator_index": "1473390", - "from_bls_pubkey": "0xa83cbdf40e5c4bdb4e9802d94d765c70150d9926521b0ec4d273e788b83a9f304694e75d2e381ce631b24121ffecc9d4", - "to_execution_address": "0x372cd043f2dd36351da1acbb7f0a6049a4d05e88" + "validator_index": "1665765", + "from_bls_pubkey": "0x9105e2e35c7861d3fee37cb3bf07e8fdf3e0911d251cb11b956d4edbbd62a951c7ac9854677ce19a7748a503c307028c", + "to_execution_address": "0x240bd643529257f0285e4590ab814b7c9dcd5ff6" }, - "signature": "0x998cb975f863e95fd53ee74c5beb85c19b8b3858773432a371e6a3f229f67b653165adf3bbaa6015dec12a1d13cc9d5c080915c55c921fb056fd32e9da643d96dcbe83ccd456b3072dce2610d7b96e69488468c83d26b7251a466571a5424351" + "signature": "0xb3b0b28bedcc6e28d433c2a577204a9f7ecfc2fd4e3067ddcb65caebf7fd32d0389dd1db836600b0ee19a2ac8b6d0a660788a42abfde02bd5bddfdbe8cdde83a890ce69ee178ea314cfd9c06e5507ffe5cc4a685004f955219fcbbbec6fdd144" }, { "message": { - "validator_index": "1088641", - "from_bls_pubkey": "0xa7f8aff7b912b6363efb810f2b661643624ab914b034e78d72397ef84fa04862dee94c9b2f46b872fe852f197f558fce", - "to_execution_address": "0xf676954331d2efe5b23eb56dc3622d4ce2ee543c" + "validator_index": "1281016", + "from_bls_pubkey": "0xaae4f1779eb7e006a9d0195e39af1f14a05b017a4a351ee1f3c22929929fb510cae4ba8e01b6d2444a66e388e655d92c", + "to_execution_address": "0xe3559b43918610a1bdfb4d42efd9187fdceb55aa" }, - "signature": "0x94773ae9e3d605ba2612dbea934955e7af438154f7572136c97bc3f858144ab833aa7bf6caee2a2c4ad066d36b1d0c3501359ff577de486f81a5210258cf63ff45bb0cf91526eca949dfee984c6757a957f9c7ddfb8b599d3cfbec0b778e9396" + "signature": "0xa3acdd589f44c5b4201ae54cd119add73b60bcaca91f9e5d028669dd9b52f3ce15c20bb0ec39ff9ddfe96d5c1ce979c10376d36f4840a04cd90ed9d4348fa4a53f0f00e35bfab055a102ce3b6306255ffba3ef9ce7e1548048139d574478ebbf" }, { "message": { - "validator_index": "2008914", - "from_bls_pubkey": "0xa6c59055cc0bed5baf1a815f59d9d1cbd7aba1a4fb8d83de7310ad85640524318110a6a16f5bc141a81c34e103d9b7be", - "to_execution_address": "0x7fdbcd4270dd970b44236c31de8ee788b75533a0" + "validator_index": "2201289", + "from_bls_pubkey": "0x842bb38ef27bafce4e8aa9abd3e31286da4d36eb87ff6a2fc4de272e4878230a7ac7a723bf3f76101ab2c2a642550eff", + "to_execution_address": "0x6cbad342d091b8c64ee004060b06d3bbb052340e" }, - "signature": "0xa28a524424e49283f416545acfa1dc063866bfe9892c60370705cd8133fa949d724421b1ffff5a757d573391ab2cd9fb043022aa8354e4e93c91d126cb40f9ca7f7be8e8293be5a97b0eeb79df9c051f90e4d97c9157efd9b64125cddfc257f3" + "signature": "0xabd643eedb5dfcc8f2db27bcfd59f6359517cec81ab4d5ff08bd5fd246ba120883c047e0cffc1d215104169a335628180df5779f128772f899546fd260328d4a4368a044c3e2037f4284624728dc94e05467b1559aad3077cf9557bf62fc56e2" }, { "message": { - "validator_index": "1624165", - "from_bls_pubkey": "0x83190d18858cb148b28aa89911959562dca6653f220f8b4878a5d580958dbb3ca184d97880f7c2bf0fa970cd41b70dce", - "to_execution_address": "0x3e269342afd150bcd8c074e323e7b48bf5732954" + "validator_index": "1816540", + "from_bls_pubkey": "0x990cf4f3bf6ede0aaef3010026465f98f381860535ce007b87879afbf2c955c13d07d7c2d91e22fddd8ef5531f8bd22c", + "to_execution_address": "0x2b0599420f867177e37d0db84f5ea0beef702ac2" }, - "signature": "0xb469d5c6626f1c42e7e914ecaf79388360d2ad196f2edc1f7b6088422b4f32f43f36b12898bcccc46c5ed15285ff0cd503f0ba5f6def9b4c1e523e941f1de95263bcdb014637c359464eb2cb974e06faa164827b21ee15dd68b2375b7e76a700" + "signature": "0xac8ebc3beb6cfc97c27f286e0d2e582707cbcb972d0898a41831b2d1393a684ce54ce54dc9128dc3988930ae4d92b4ed0a51b2bf639d8fd8e62e40ceac222362d9bb67f9d1b8419f3123dac1bb2e4e0cccb5c7c0985c83bd0501ed610935aa96" }, { "message": { - "validator_index": "2700421", - "from_bls_pubkey": "0xb7ff61729743df75a8b0b7e5b95617b9aa407e2e6a30cd8101c6a4c851b2cc366cb80e68a19a23e19625a596fdd1ec61", - "to_execution_address": "0x64688742ef680f46c246433acaf8dd25027a2778" + "validator_index": "2892795", + "from_bls_pubkey": "0xa0695f8f6f65e3d8401e144eb382eaed73f9ec56be6de71dadb917af79a08ff7b74967dd4f4766ed77f7bc2fc01cfa38", + "to_execution_address": "0x51478d424f1d3001cd03dc0ef66fc958fb7628e6" }, - "signature": "0xb29e4c2b22ba8da0947be521fd1710125a95d9465632c3d2b5cffafe6e7070f4a6bd71385760b2b1670add9981225a18060be73e5f486535919fd3577b7ed850b3108dfa0fcc9215cd9d526295616e09619e07977ac7208edc5a2af93835a18a" + "signature": "0xa18c2c70d886e11a592393a7bef6fb3a515100e1436763854eb96fca9c031a959e4c105be367a10ea87c3d1a8bce821303470a1d6053cd89139bbd86fd7bbdd3e377b331884bedb0f9b10eafcb3272561fc5d71b96b219d7fe3aacd6e1558c97" }, { "message": { - "validator_index": "2471654", - "from_bls_pubkey": "0xab0a4039f2f00ce09018af228a696b7b87c7bfc111e7782bf7a3ffb423c681c04fe335152668abc7d20b6e9a9bc4933d", - "to_execution_address": "0xc090084330e9de5aaf85637f9a361a8678373dec" + "validator_index": "2664029", + "from_bls_pubkey": "0x97e268878248299c9e4d2c86957935d6cddb83900dbb6d4e52a935bcda58978f6fd33e0dc891cea14da0feafd5173762", + "to_execution_address": "0xad6f0e43909dff15ba42fc53c6ad05b972343e5a" }, - "signature": "0x90f650befec00b055e261a38b4ea0bc65a0d71fd735b46f8387f565fb0d31494f90645c40dc07b0f3ee26d7807b82bd914d4d7c81b3ffeaf9a32730ab7cba7265dd09a0e0f94ccdf2ff3bc53d49fe99a488cf7238200ae12e6c59960e71d5877" + "signature": "0xa2010187045aa6d63130c7ff23464438af57c3e42eaa90823205936a94c47713b68bd93d3b6837947e277ece630a6d200d428979548f340f6f71ca33e8731e059a8c20f75d71d36caebbbf6fde28f37a919353dedb7b7c7e4dbcda553e5bbee5" }, { "message": { - "validator_index": "547910", - "from_bls_pubkey": "0x83e4d3825bf069cd0b19ca5072eda2f7d141de02c9e65f9c0733c18252c1552cda074eb613e1f435a880262de2a4672f", - "to_execution_address": "0xe6d2fc4270809de49a0b32d641484320853d3b10" + "validator_index": "740284", + "from_bls_pubkey": "0x8aec1b1f595063af33939f3c3322ad38d2e1de1b11fbc8a9d04235dc7fc9792e1c88e51452d337855d254a71f42816e8", + "to_execution_address": "0xd3b10243d034be9fa5c8caaa6ebf2e537e3a3c7e" }, - "signature": "0xb9b292bb598db604142750cb641cc511a9081656efb8271132d7e0de30554dfed4b16e418100d9085951c1502d6ab657179da8804cb08f1c69b1210ce94bdf6a0b66976233a34a0acfb4b947cdc192cdbb8576a3453e50143e7afecc8cbd264e" + "signature": "0xa0ba14bb9ce5877d9f9d607da9b2fd2d629a1de42d6d3beb5a8f4c1661aa1d6863e01de14c548be8a9df222efc6373be1290581da81c76d71bfada1d07481d7b7de94290efd640aadca41d6b4d4f81091f4c459b454bd6e333eaa35c60faacf5" }, { "message": { - "validator_index": "163161", - "from_bls_pubkey": "0x86c03ea323e3551ef39c8c4e5355c4d3a2cceea3c8acb3d947b39e245d2ffcab53b4479c670d8b268828fd4fee89eae7", - "to_execution_address": "0x08400642aee83f31d60723f5fabaa1c58bbc1104" + "validator_index": "355536", + "from_bls_pubkey": "0xa912f4ad989d87e777e45af7c265b430daf0b39345987506d4158cdee406847f294fc7745154eb52abf0934a5e1866ee", + "to_execution_address": "0xf51e0c420e9d60ece0c4bbc926328df885b91272" }, - "signature": "0xb58eaaba3ba51d7098d65fbec3829ace78576a2276fd9c97c293aabdb634a2c50f52611f48088da5d4a5b5fa2c5f4c0513d8dd91c8534b50a7b8ae0072583612610ada0c81a261641c66ac542428cedf20f1b954ad03505fc058b40ce0bf4182" + "signature": "0xa7f77c7fc98b1c3a364dcac68b5cff112f7745e6dd41918ba56a6fa6945507e0ce245334e22d4581f49bda913baa2a6b1176b44d52168151b3aff9a625dcdebad1899747c42c4a43cf31f49124fc0d4543e4485592c243c5300b79214398b770" }, { "message": { - "validator_index": "1083434", - "from_bls_pubkey": "0xb54bda7a570f90c2d38e836a3a256a6a2230a6384a29af7dacac3eff1a981d3f50918e2b546b3d78e72a545870b5ec9e", - "to_execution_address": "0x2f82fa41ee7ffebac08df14ba1ccca5f98c20f28" + "validator_index": "1275809", + "from_bls_pubkey": "0xa77e90361be2a534a386cb689d6d763a98bea5f23f325b553a762648668e4adb4991fb5f41ad7ece1578f082a5c01b5e", + "to_execution_address": "0x1c6100424e341f76cb4a8a20cd43b69291bf1096" }, - "signature": "0xb851b39a32955a7f05acd7707c6859df4ee2b1472996d6a805a61e14415db550a92a7eaaff14a67e858a9d3633306efb12a62ed84f76387a84deefe726afcf2fb744f616f67d144411689343e6e0dea7a88b57449b2cdecb43cf0b5a80887550" + "signature": "0xad188010cb0db88e067c2699030353a1c215ae9adf083916ee2069a805e0f2cd00c76db9250a859106dbbff4430b4dd114d6293c4b3c2e9cfd31f07949f04e53f63423a08b56d7247772d07959d5d92b17bd8c7c0b294b71d3db903d56509177" }, { "message": { - "validator_index": "698685", - "from_bls_pubkey": "0xaa3588a5cb0b5d8eadd316046b661044c97559a4350464e338456c5b728880b4750b94af5fcaf478e3bbc86ac3e12d0b", - "to_execution_address": "0xeeccbf412e74b76b542bfafde5249862d6e005dc" + "validator_index": "891060", + "from_bls_pubkey": "0xb4582d56f8ad9dcc77eb5413558e63a6b562e42534c579a85384e7d7d6ff8974ff933d05a444c1d2784945f4cd1c952e", + "to_execution_address": "0xdbabc5418e28d8265fe892d2129c8395d0dd064a" }, - "signature": "0xb99cdab802f2f2683fabc52c8ea095386730c43694a9a5f7a42033e6dea53f4896092b207f56b1402c5c69937a3e2fb41958e001895bb43c2ee1e360da601e1ac56ffa8bd5371b1dcfe85518f297f94c02cd4981a5961201d2c2fb4d2a15c888" + "signature": "0xa7f07c5a20159b029b2dac119315a0d439c541e63b0d1f6d377fd2867e5559d6b6302eb609d5796fab97cbca121ddf400c840b9ffa60dbcd89c6d441f84aff2cca1f68fd9e258a969b0d511ad1d90c0c783dde3c093ee8cd56cf6f70a61fd77a" }, { "message": { - "validator_index": "1930923", - "from_bls_pubkey": "0xa55017fe14158ad9caf1d11f971b71b1941799466d063c6c77d7e41e20d5b74fd7fbf969243f3f507f8c04a5f76c3722", - "to_execution_address": "0xb1ec6f426f978c599752e0e7181c305a1b8623c0" + "validator_index": "2123298", + "from_bls_pubkey": "0xa5849044acc283563bd9b40fe9b01a8c079093829fc3837cddf20a8f9c13e59629251481406f415c8e2df65285ddb41f", + "to_execution_address": "0x9ecb7542cf4bad14a20f79bc45931b8d1483242e" }, - "signature": "0x917311e1a5f7a689ceee1af61f06519a3e4c6d68a4af6f4d24da0f57a2246c963c964d0e576607222856258c0e34b0b1014b68dfe481454ceaf521bc6f87c15e6a21f6db1c303b2042d5857ad4506f00dcfdfc5e65bbaf1b4ee9fe7ddf7b738e" + "signature": "0x81df97c3071aac41af79494001a1c4404b5121776a71d6cbe3b8eef000e803f59edd2fff33331d2ea037faa919ddd6a115e09bead88d7c8f23368628f306e3a244f2ce0a54e4472d29e4b79eced6da3e5ab40177e96fa0d94d97f5e07d2e6e95" }, { "message": { - "validator_index": "1546174", - "from_bls_pubkey": "0xaa865744dac51436c21adc2a1373eb6b8d407fda20bc67492d80a43812dd2aedee636192b1fa742570ffc2833ec58b29", - "to_execution_address": "0x70373542af8b450a2cf0e8995d74fd5c59a41974" + "validator_index": "1738549", + "from_bls_pubkey": "0x9815cccaf23783a4b1bfa265d2d620e70c76b50b32e1975b909ddc3749fcca44d97e3e7e717a1f2979c3d1e4a70c1ccc", + "to_execution_address": "0x5d163b420f4066c536ad816e89ebe88f53a11ae2" }, - "signature": "0xb875609f4aa01bb03c08b4f13459fa7696b969fc5e8440c89f690478820b8b5b4ad75e7fbf03c4b0e919cdc80b07857604bd81f75128f2bbc61861d0b5a7744e21eb4ad008f05b46be2c2780900a7913abc2cd3591390f29e05e2d5b2dba570b" + "signature": "0xa4fb80ffdea501d608a5e79ed05fd3ff67d39963afeff1b2e0be94811c3497f8b615af4a16e438e23e8cc6c34376a514169ba117403d86a2ebeb85ca0bd638e63ca982ee45c8350d726f228ac03eb8fb584fcc56e8d3877a3756cbb06a7aad43" }, { "message": { - "validator_index": "2622430", - "from_bls_pubkey": "0x99c16f59ffb2e2138feb9b6f1804752cdbfe3796e20c52a3ae489f8348df4c1a9614cb6ce6860bed51544aaa1d22cc80", - "to_execution_address": "0x96792942ef2204941676b7f0048626f766aa1798" + "validator_index": "2814804", + "from_bls_pubkey": "0xa6e3b4975aa42a8e0f86af69da109dfc42eae539bc7bce0be20f733b1fb15107bc42eda74c8788c1feb0aae542a6fd17", + "to_execution_address": "0x83582f424fd7244f213350c530fd112a5fa71806" }, - "signature": "0xb9196e6383fe7a9eac1809c48fe10e45ddf57d6ee7946c22d48873b45064a39e66f861d7b36d82699f4b1858c3ef093f13fd758af1ff4deb2b7e1ffc7a7179306726cc556abddafee546ed2a6d7c4b17a1498494d994ff4188a2edf3c261a683" + "signature": "0x8d5a3a8aded5a58f952ac7bae812991f1b285e1704e87ef9fd8a743aeca8dd30ed7710a1b6c31a1860768704e6ac709316d5e7002605470c7fcf4b2c691f8a897c900cc60e9618daf83af929b7e8474e7f71bd996427c256691c9b90581b1264" }, { "message": { - "validator_index": "2081698", - "from_bls_pubkey": "0x9786334738ef86988505249871273257e40b3e3c47995e751a40a52bc46f915fbaab7e2b1802ca3dcbf2db0567e8c9ae", - "to_execution_address": "0xb8e632412d8ba6e05272a80fbcf8849c6c29ee8b" + "validator_index": "2274073", + "from_bls_pubkey": "0x8d2a58c4d8939845fbbdb04c560d5eb57cca82d7dfed86580867df9faffd4bf8139bffdd1dc92555e6325e18d57afaa3", + "to_execution_address": "0xa5c538418d3fc79b5d2f41e4e96f70cf6626eff9" }, - "signature": "0xafeb0dbcb7463673415ae2897857e5b13c4299ee60273bbc406c38f4e805cf7bc147ad40d7873740f3d261bd592574e618efe8f93cf439d13db8b86ff91918c57578b1080c6e51cf121d816eb3e5a2003ad57799d24f1ddbe495724d9e5a292d" + "signature": "0xaead124a78a24d0bf0a4a7d20c8c4f34e92899d925eb47750d683c474093f4d5a5af0ab36598838b149c0c348bab313e0079198921f7df6009c7e02db76b077b2541c12b71c70cc93b80ee4e150b2ad10ec6ecf6086bb8f70e9b49e4f708946c" } ], "blob_kzg_commitments": [ + "0x92a43e41edf3e75667ecd9b815e75b026023f067694dfe1857d7632d40a159039385cda8415e795cd67a4ef6da317948", "0xf14921410d6e44af323bde913793c2037f32eb41f938cabb3c5db5168485eeb88923ac822543db013af49d53be186cc8", - "0x046b1b41adb923f4277e45bd0b1cd7d08535ead3b001f37569def8de5fe6a543214372e11fa4bbef810ce1ff85e0cfae" + "0x046b1b41adb923f4277e45bd0b1cd7d08535ead3b001f37569def8de5fe6a543214372e11fa4bbef810ce1ff85e0cfae", + "0xcb072d41cdd6852547b50f3b90819969722ced1d8ca77847e05a2e86cfc37fa35ae41fc530811a26acc317fb2f89a4fb" ] } }, "kzg_proofs": [ - "0x3ece09418d9cc1c206477b3f86b61438983ee789d35b6da4f361c337ee08cce3e8a1c4fd0fc75cb95755aa04da37fb61", - "0x51ef03412de8a007fc89e26a593f29059e41e61b8924965e21e30600c869836e7fc18a5c09283da79e6dedb0a2ff5e48" + "0x2bad0f41ed50e27d11041414b22d006b923be8f71c9344eac5e07f6f13a814595082fe9e14667ccb103d67581370977b", + "0x2730ae410e57553a34f42f8060bfd5c9e9e90292e167f747f14061500b71bdb7532d19a0aa2bd2b48dad532d115e112f", + "0x3a51a841aea2347f293797ab3448ea96efec0124973020021fc2a418e5d17442ea4cdffea58cb2a2d4c596d9d8257515", + "0x01eeb941cebf96b04a6e6129b9adac2fdce3046e74d6a5d3963edabf56af4ea224ee8ce2b56911d9fe7ccdd483ce4962" ], "blobs": [ - "0xcb072d41cdd6852547b50f3b90819969722ced1d8ca77847e05a2e86cfc37fa35ae41fc530811a26acc317fb2f89a4fbd13c6876261f3f7aedf916080789e969b18e152f3c9ce7511d6aed2a6c3c7eefc18473742e0343b6ea6965c1e9f240fa5aa4a90a7fd4ce8c81abd7536ffecf3f4d3c78c58d9599280f217e798a2aeda204de9a8cdfbc36868414133bd5f24401e6c476bfc18f14769977e3dab02cce1200d03dcd13c5d92a14b067862f180e96e1f1146e5c017af54a64e68c550cd8d8c43a57e925800dfce50bd9ec8132dfb2f4e0fc1a847e698ce74802072805e4616cebbff8f63a3c45ee4ca2f6c485ae7dbd620e95729e48b9b9ce35e20b5ea1b7342c7494bae28ac5ea53f0c36460c10d3bf324a8f3c9d0850dd3eae4961bd0f6ffc4f077783be568d8f10b0ec275cf3b534274edea591837b4633f4693822f4ed38bffa38b66ea187c2ce69ab30847004c4cbd5acc05319183cbc1ad806aca5a5b85554b23b97383db9238a7ffe5fb945302debc22a2b56dd4aef14410608be16495a4bbc5e2aff1c3a1ab5fe32ecb2ef8827d980b2fe135043818c8aa97423960bf0268c7630cf04138b55d8ff3fd6aafe2d6c1b736098af35349e4e8af8733e6f6c833d5536794281c2141a99d747b5184e45aed7b950187fe9f581a4421f62f804b1f6f7843a5918e75ebc92ae5b398016ecd86f8ce77299f0741c14edc019be00d8268abf8c155f0a596fb36b659a6a3bac4ef2b20cb467524a9145cfd962a5f541069911af19576c5fc40d7407f7f6bea20abb9a04dcf142d067e8cb5c2041535046ca08fa733efab0a0d4483428aaa375ccf570667b9f2c67e1d6745a4f28d8ae4417612705695be23ca538efe142ba3e0850d55117e0138f8457cb7e3e2f8698e0c7f17d8eaf54ed153c537decce8cc5a89c1e8ea9b5d7fb8fbd75ce766e8fe57c5eb502c1de441d47b5adbc54859fb2caf18b291100a270d7b44751036a3ee5db6f84adce47df0f385c234b97f4493c35ba4c0dce3bce0ceb35cad2aa904a54e0184da1174407591a9549cb94e2d82b2076174529dbb3fcac56e5c4540ed2c5118f45726c92cd7fa959a3098f3495d31c184f0eacbc7210e892eac601c4376f7436ee02422fcc4b5e9aab65e950c37c2aa9da9c77e1b99e0083814b483822b861d5d17768264d27dba533bc1ba3b6d8d7800290acc7569a30262d3d65fde783e17472227316d697e1015bf81ce9af142f4865f5d4c376a4169e050bebef066c0f4f4d8fa3ad3e16467eb76cea322cf1f7d9e21169e8e5fd6e4368f5953fbaa0e4be86399eb7d704332ea6b6aecc9ed0c84a6a608e1b41c234dfb1a8cf3b70e370922c3bf5703e1e153a683dfc0dd56aa0e9f25523b3a010833681f6e1ab9d124ec38f745d73c4b05a5703b101dea7b803527e95e556223b059bf8a02645aa6ac09c0c62f85eb366c7360a03e6332427fa7cb7466dc90b94f357c6c0714412c7446fd59c1bf6cdfb8fd2d4e05d5b9d46825a5957001c694587256f71f906c0af1e1ef26beaa7e8947fadc7ece1cdc7ec4054778b7fa2abecf6e14d15ae2d60a5ee7a6e78dad141dfb1137750cc375117cb1fd1de47fae89ffbd2d9a0239a5d92ebde79400f23b755e5e16ccd5bc9c9454265dcb334db1af19a43dd7b966e8493d9b249fcfe80f1815f47f748fd9e84709761f4a0ea7c23f7d9f45a61e60ed41a50dc3dfc7c3be487a558e6cfd544c33ee465318f6d06c7e3cdbbfe995c01db10670b2fcbcfa9da579fc2b796a477ccaa551dade049211002fbc81d368457031af7b523804c94ec420d39d6c9635e964a3e337c957bad69254596ef912526936ffb3a9e739adf27d25bdddc3c180478cea5eaf98e899a2c98dfbf85d7a6babeb38f5eb0882ea6fdda00dc5a47cf0a763b9b9b28c5185283ab7a27716cebc1725c9f050b44908c6e18a0d0787d63220a992fca07ae35605c004804579f3927e0205a83a61cc5272861779fb112b5603146ac5d4ae46e9eb56127bb5fdbcdfdf2849f5ab394556e4c3f10139f90f51aa118cc6027198a1e15d80afd437a1ba3bb361020ff6c167027a75caffe1d679cc223844e84598e18a5519eafc994bddf23c24ce4bfb011ebe7675ee739bad0c685bcb9a49480193876b6f2f37e62b25b7a72fae2eb5a9d5b80acff7a733a6a93ac7c6b440339da4df6498346e791c160c7fd7c91e67572bf8dd086877b3d7d4c9b4f394dbf7f7857fb92ee370da5255571b5b9b24edd383aaf67e34318b5777fb2866d10af8dbacc4f206dcc436112c81e6aa724027af84fb232a4512fa025c3efd2313e040e8111a9f18f248b7fa09256428f41009159af83ee5f68ffaeeb4426ac5981c5ea3b1a46cf2aaa7d67fff51dfff97c9878d7485f32e9a727ddc9342017ab20fa1660f003db1bf99239343dbdff42879e0a6846003cbf3bffd3d71da557b47c5f45eae0a44daa1f818bab038c9bc45a0f03e82373552bb75b732aa71da1c508499a998c283a8f1a0f59844f7444de3179b3de9cb61b41f140b5bff32b1565a9d6144da3137560625be4ba1b95ad6c8477317792751ec3ef8d790139573df08894922056bfeaa6b4fd2398dc8577a11ad285db3e059a9ae86d75def7232a78e568536af95dd9f5e75c0947233e837aeb06cf1606ff47ef82543817fb430cc386a5db1f00a613a5399405ede8003e5e1cd4c3c0b91b43e17094ff513871af0e18b74fbe68178d8705d81a404ef8e8bc3083bd882bd5a7dfdc943acdf25bb2a7c455135314cdb060ec6309f3a44d7f2bfb43ec259abefe70fd440ac7b3273b58f91442277a207a43eccea7a792f44a3158b070c66e41bfaa49ef147639df1d0b3d9076fe1002f8241c0f7ebe038e73b5811dd6b466a2ddb89b7bff1781ef1541645ac359c93a1f20f7c84143142c883f14fa4cbd76a7da3809d4b8e7d3dfccff856b5795ab38aa5d265bee55397113b9ad87525bc042810bc6a363a9bea791b31dd7818ce71101168427de6ce8e7d52e31c7e91dd1b48b7664f862edda684ceaa2e1e5333362823e4d7643552baa7d9b0142266e43d29231cdc2fceb53c4e08dfb9d6a8c669b2590c60a8af30a723a7b834a2b0c09621d76c1c8eee750812a164e329314734af7cddcad960df2e7b7708b5b51926f505255e81d31bd7d0d7ee5d346e077d489e1e03d16ec3795776027f27d87e0bdf69e6e79bbdf1762f89f104d9c9a1afc05bb762d6e5e43bc44e504f5e43262bb61da177a715a052891be8266f541f2b0b0ca6909cb43308b6b06a82a2cf7885ec9c5a6ce4c7595097d006a62434b2c2e6e8a658c56a98e79bab5f733a349add485e629cc29bbcb87ecf44f925d04b4a6f01523825b27e8133f46e5140620d393b38a7d0dbd636b57998fda95c729a1b3a3f08e3e5169ea4391a249fc8f3cf65414bc043be540fd90f1571d37df2389382424cc178c1a5c2aa9312b758e9fc6f5b24ae2787ddfb96de4603a86844aa9266e7e46a598c697293bfe242ad2f142b90097d204dc520c5f1d67aefd4035cfe32864f2fa01fd2ee704261c1d0a779af81a25dc75a1eec23ac07648251577441c040f89164fc9c94215e4c0882ab9bd8116f7d2839087ecf3fcb2bcc92c4a0c6deee66c7efa1ec666527adbdea4776c416bee4448ae536ceb6007d5211d0747fd37b0f3dbf36c48aeebaa4dda5a8d5561f16e490b38293878b19e827f8812862e4c6bc10575fcdca01d4b738166dcfb6474227745877b648d1a9e375632ab0e7f4589d92e42c3214a766cdf00ce267ce1d7558cea44cddbfeca4c2fbeefe378c3281d1ccb04de8fb691f47febf593dce95335a6c67328781dc48538a946b0751d1aafaf762e98534aaead4ad101c61a80efa8295fc4c428611fa7787da30b13cd8fdb30213d39b1a7ce5e61d22a93a9466cdf18108e6ebabd791316d52a93ed7fd9c0c102cfb9b2b195aebc13f486f8e1f2a07dc010aaf2f4ee1404867d0b5ad941214f71e4b8689e0a9d8e2131d4dd393034a478c5c3436f06abb3a7ce4f2d087be49c1e454f17ae746dd192e3d26683ac584d7a22d4549ad94adf95abe4f566757482e518087e9191f72d9d97f5d93fb87b29492199bd491d42a4ff237fcd784d0563135a0bce2ea1a76e34402a46095ed68fbc4bdb4a7ff99fa99643c3cf11f37a06f5119531995916bcff5990b1d1054c77d5a4c4f7676f56649665bf9c4a258b4c318054364ebd46a8a92af1fde425398fe94089459ec409065ecf93677ee439bbd42fab83db936dfd2f63b2bfa67b63e5712f61f4cb64a0f052b7a01b1b7f7351e2e652d41b329aebc9ae12f8cc1633bd4d644cbb000c59dd8e3f46120f3cfde5d139a08b3f75ffa2f495cd7f24de495b627447dc8d7fbf2a0045eb9f651843c25070be3f91e094f6626c1d5528c7d35b135e6683dc01301b1952ea767cec902d5cc4b341edc91a1720649c810510f4570971ec59bdf524576f8ed482c48e9ebfe78cd2e4f2d8742b6139f9959aa27100d94a573d2b436ecec7534310331dd8ee9e37b995e1c7f8869c5edd99cd4fe63993dea0fb5605820251d01ee2c49c8d50feca6b3420f29ba182624460c3f4d639a5b3d8f7e7e61f9c7f17c57ed6bd7c09e88e19295a8e77e216a2def1fa02de887257ff2488c93268b6a8529106ce0d1fbabc0f5153896e738d6140f121a7d034ecdd98894e3a39ebe3f989b600050f53af6a33923bb5bf3e6f54f9f626f6be5cfd952eac541ee54c389fac32fc038fda837f2fc476dad4e0522a93054472d7f5f513d20a4e03f328e2f3594d32f95cb42c373faaae8e2ec4557845a6e82027a46b4d668dc1ebd552aa5402624dd0e193b91b4d59ad6fd06ab5c7854fc9e02b441c798a27fb8a3f035faf9e2008cdc5d7a3198e30a3087fc0d3a76f28c2d614f002e0ab37f8febe55f38bbc3c87289c2198e89750f0ea48d97fef84872551c85a9d5172c360408b5ef113192e086b726e77df0d0640ac4e748d7f7b3456947d8532f410adfdd4b1d3de0c79232d92e3ce726d7c7e72f8b08757594d8608b63fb8c3a21a51ac3b15539f24977ac02cc6ccf30e9da197bd90c46c5bf7e626278b5d45f1ed36c420babe32a89d0bda01fc28ac736e8a2ea111c34f44ecdaeddde58201b4bd0bc6ad8d4d0ef2d77dce1d04db76d65adcb1f03c292c73a88ec09f0e95876c1afd8f34957ac67058d012215a2279f38cf038f13b40143036e86f509e8d95303feeef62fd7b20869c92a97cec162439cab5b409330f99e71b62ca59cc7f38829c21337d75a367799bcd80d249023f09af609205561478f3202501831906bc8eb3abff916111cb426978fb5a32fd8fbe905e9def16c89d902c0ab5d9cbdfb5ccb8b4f6f115e5e9bbfcb5afd42f12360f5b9f762562cb43b6829b6b7d077ceb3ea0d82ab689b89b202934480cd6b5b6c9526d6c77fcc8fa2307e32d1fe7004b75b1ffd2dea2f40472af2df0195140c48d8784cef86fe35b03113a101f93d34f8ee1ac7faf260b8ddad66c17a743a7345891ac4a15dba9792021ecaa10ac9e5aacd99cd420e863bef32c203357894020460bfca3edf02f829aae43970b593136f683f5f9c9015a5f86613c1f8bcade26201db93fd168c6f7f7b1dbc0507d8b1eb8417b1cb3157ead89cb19c4858586c433cfa72bddd9e688b9ad8e759783e213974fd5b1be7678e7f47a23bae5bf9af1b2c9d64663117234ce341915789c9bd1bbc9ada4480a02bebab98c51645f0ee582b7b85d9e7e4342c2de755818acc520ebd4a0de9c85eef7764c1683f6e941f92bf8c99719f0801b924f412a6463fa01c1f98b89830a71b7e8f64d6314d436c8ae9d284130fa147a935026ba57e84db8d0f18046d3b138540c32ac3d097c2b6038396d2ce173f96333fb0484469c52d5f991efd2f3d07172b217a68749cc90d6194c5300e3a61d0b40c335311a958328ea226131521384d6122f2039761dd3919cc27f15750a9aea6cc747c596a477a3358cf9a014020bb9cf78555915ecb35f9815e8a9eb1193be6ff26762c9be70a6d13004a658720855b96162267dff6ae36f00715211d69574a9b5f37716faedb18011bbfa272b1e65ecdb6b4a3655d88528ce8d2db1147358a55f77c0aa3d25a5f1626fa079935a979faf4594698ae59cba9b0a288733cdd735be4430b2c12e60d1c79de56d2b5b3ae3b9fe1be9414ec9fd0cf8b2f9faeab72e4394ffb4ef356c1daceb4dd330d779f357821fab251c0a171ca3747516dce65614aa72b472570e0b18ea71f68d1804ac93b727e0ea98797e2b17465ff1dcac63fa7171bf538736623c3490d2392eb1953243298669fa72fccb1b57f87c9f61f7b5eadea44c68e7d1e790ccdb4e0ea414dda41962702bcc273218fbb56cbffd276e33de23e3766e91233ca13fdee426f6f598616afca14e68a2a3dcf6963632fda85de04f4dd944117b23e0d417bcdc5a5df68621d6431ce6ee21df2c836f7d868366bb5b8ae25fcab9689d4a52cf92e796b56db45924b8101a6315d611c627e119f036b5ff41848e541ae7c517a48f8c2a83f7790b8ccd986a39f5b5eae9fdfac408a756598e4b705ef15a974b5cec1c56b1a4dde87d2582fc131eb633a7f24275e26d24325efbbd3340cb6bed4b6bc05046031c32ab0c83a7ad6ec4cd525830dfac20f567d18ed33fd4171fe2dbd397ac18d62a6df6dafdcdf1fe54e898836ba108e43095d2e27d2884962f160b587f2ffa3459c9043914ca6c34ca5cff4c498867d0d45237673e3431da383540422c8eda6320b612103ac091b7126c989963cf7c5ac400729c34a089848024e222f380c20516d592a8dac61a6e463f3bbdb43af632436d7f379aae8fa5a02d81f4ffe189f84c151345d1f6e877f386ad0c340a0946fa59776c82cc7685efe641aba0aaa33697dfb4ac9d8c102f0e51f6503230b5dc619dfc5d60cca696bec57cbae6d45f15f12742ba2913403db23d8eaaadbf205f2a296e9be2a376ad74e63fa30d22872ab5719c855b0ef968cc21c214d352696b174db5f57345f3b6d81fd05182245549c6b71c9e1237d7038c3d4a3751ad55f2e5e1a98cd2c08913545ff5f6d2d2cb8cdddd70996ba3a65ca07a15b6fc43274800b2278105d3682cfcc5f0b1b6fcfc271344a16a79eb7ef46fca3085b8c9b2c4343d5d80af7490b59cb6725ea48f81dae1e1eb290e2ccaebbdbe3c0955812a239925a05aef5268de747a359d150537408e6a3554847b5e2bf7209686fe0ae360317233ecc03844c9037506a9389c1fae2f0b7a83fa603f38481d73c3140c309e05fe639c3738cef002006adada063e308680e0b37a91aea761f594e74971484858cbd9ef691b803a844d98b968b7ce94a519410e0b9b3f56cc26ffec7ab7fd10226dc8b1adc1e786d204a024c1edac82bb199fd4f5316e769cb1b87a8c9c760b55e010e4ee78722fb2de8253275ebc19c85984f421fdcb5ecba9472c55d1b644daca0ae05ff3d399540ad98414c0e1bcaab54322b8981fad06e082198000f54e2edece3c5c6e8d982efbc14869de59df702c1091ab18d74bf0ba3464aee6c6a17906599ad68c48306d661e9ec20bd166d5e8eec6be8cf852e745368ec243c27506141b2d01a2b9be6a9d877638716d6721889254e220cb2f26e9a65fca2cfcdf40717816205b7e8856ab7b4458b7e325e58f2b2100273285fdf94eb3b8083e4c64c6f4fb0d339168c2a85a91c30b103ae5dd2c748716d32f6b05bfdd6da0ab645ab81d9eb7966371e3665f5accbe5273762d949c3e796c4a958c674dad2d6d222da37d0c5f9503ea7978e4855b2d4ff60e5c45347cf3cf3ab0d977bfa0d2c8cc63db958d82fd783303da7e9bca0a9f0717267b528ad5c7bcf1b1a13a97df17ce4762b89e1f39c424a400031d23c9fe2eb336170aafbe53878f14b8d7c6120fb1f7f09f1cd15851b84121f0e194871c4f8e54f3b31ddf7ad1bcbab12e6bf02a9c0056f11930178937590f581495d2c06e7f9bc014613ee80511efb1e38cf1aea76fef9dbd913d892563da9203e53231db6fc586168e353fb73264c01fd08a3633094703b79e93ae42729d095329ffb02b392232db1d33e8dd034ec5d9de11382fcf12d8bc033deb86b43981c5250d3b3249af7eb4469264768a6e8ab565e01f40094741c92dbd5246e1c6409967e7cb1084793579652096040a127b68103f02d7e1229b44d7d209e1d570640f446ab81df499cdf78a793b242fb4f1d29d575e3e398240b8b87a684734debbbddaebc2b895350250329053aaeec05d5ef631993f57a424da486a7966ca92e080d096ebe31888a8141abc99b177054a64720e6fbfe99889b1067407691f4d0c8a4b575ca4db3867db812119cf97175a9f76d9a9e188c4e898eb8842f0f60ff329e576fe4a64e5357b78f37a5d5318dd0f231a9447cb713a11e3c1cab5f47a68d87d9f62678ae33827a017a46e476575e7ed40577e9d3c8dfcd46753c822f55b992db1eac9ae44b251eab45b1557a376ba8f1d6061a84ad3450c36314c444d1a7f364a817c22cd09a60a46d3b22a995610e32b98546f986046bdc73cc189991dc8ef2820ec9f399f034b0b3df6a9ff882f30531ccbad2e0a72f9a4ee102a5c6f3f73c25b90dcc746a25635dbb69ffd05fa73c47747aab3deb05fc4d320ccd7c18c04f4044dee0adfe85c30190f20582623cb2115df50799908659c584ceeddf8d14cc2762f5ba70d776cd564683feca458e8d162bcc9560cb251492fe8b30a428ad700bc7066844d4b6848966e4f8579998c80dc4a4ef16c4ade33fad57aa1ed30a41c7ad5b578c06467e969e5962ea411dfd81d30e57261889476b01ce87a60c06e6a0507f7d4836d80b2c4162643cf49aaf364978160657dde6134e5dc76d62ad21c272fb90705c1773dac4092b7cbe939207d6317db98775e93f4c1ec41efe7370a1d824722e29b6dab942c874fe7f237c297483a7db9f7c93a8983c133217b031d3caf70fec7e52d738f9f20d926ae60753ddd084df0d08ae2731ef751e7d69f1ee97045ca1f327c279cbbc19b0882f1f5810cecde731728644fb00e23a0f78ad4d0f6c1f0f51924380bec64a9f338fe130d0c3dc9edf848e8e3fe9e26845f22f6707ecc29b1860bb737c406d829ba9a73924e499c2e173e76a2974d563a7ebd87dd9fb5b57faf47066d498e434445d1ab7d9aeedac73a7619949fbbfdf53837119e1f890445e3cb56437befec98639984efb656bfdc556bbfc132ec9787b42e28a01632664de6b600a3cef3e7e0c456330609225ad7df227215f6a8fd2e5cae6531e294729c99555801c1b02ec561451261d98de41325f6a93e9a4e22c69d518d7a005daeca20bf68e36d21e5f3730f7960e5b078af2ff0b5ad2e1a2217780ec25f6ea75ae9f90ae658dc6623557cc8dd253f33d47bd907ac91d3dc5358eee771b1080c7f12b5c08d345dc0f54b1cd02accd713e7107d1167b3383c165c6342034e3ac79cf64ece7eb29cabadc1621f775a5b477473afe7d666059eadb479985bbe936f3609da8e38b284a2d76a961a0f8c64bb63b321e98fb53f6718dd02149fb9e6d7b86dd53dcabd3d92db062cfc8da5e6d97dcbf1935a3a26a1d913172850e04e797a75f4f4147e10a4f438b95674561fab54a26a7423b4479e8a0d1fa14df204cb57510adaa6bac63283046618b3e0693c36fa004e5fa15001c5e2877ff9a7a356de91512b319b2cf9a0b0448915548bbff22da82fca955f0989d46bca8a1a117fbaa42693bd114a002180ffee1bf660fbfa274dfe13e29d759384bd79a81a53fb2d6a36582fe1a1c7925015daff26388f44e826f63c419f66c9aec7b05219bdf8696f7d4b900aca187954b3a6c1b86d0ee5c0e1a4de190ebe890f5c24c941d2bfc5930c2032edb55ee48af8df895dba7bb509322057a60eb9da5c1384177c783098ef467010c566560b0c7e7bba4b158e36484c307ac3b8785adc43bdbd6bbb5c8961ff35deff5d457b37c38283c1b3c6eadc3984bd23b07330d02ab93da1e44ff743f15ff5732e262a28fe55ea86f4e66af2adad8585a52c69c95e4b36599c5d4f11667c5aaabf38cf41331f230c9d3465a06661de5fb6623032a1437dad85048631c9b065da219c521f0effca3890c0ccd969bc7bf5f6370d684d116000ef9361cfb7f2b417d1e648662900adfd1f9d4149105327c311e1ccef80e1dd5705a056311d31b67462734de797089010832491f9dd4a990fb4eefd8f05795b2b5363e5af1e261ee2be49b8f9784c1f159c5346fd9291af2ae46eaf7695f77c79d21b89ee201303bff50cfb1f54d894235320cbe5431e6cc1e38f15474dee45e673d147f5ec8b13ab80528731d213355cd694a99930cfc238410892ab8c214cc5807a898952753c6ef16074771bc6cc899e4da360f8d6a76fadf26b8eeac051e3b342456e84be7c06386e20ca32e0be2d3c60130b4be038b02d2d3ac64bf91eedc9c8a446e4fd93b764360343b0dfda6fc14748e6442d62800b627287bbcbdb98c3a457372bcd0cdaebba0bc15fbdcc157f8919b727887d2bb17dcaf29755d2ba033701cf2df734735fb1acfe07ede2d6913f52d287bd891e0e7793e788767baf2f7a8a222ec311e5a5daca0a0290fd97fe6c4c541e9df7f7fb4e3dd056d92ba5e6df489e7ea3e380ecdbd352c0d2616284483a46f80c2fd8c71be1682d914c6462c8e715d802b406895a0a0b0825bc3b7d54231d687f4805fd1fadb3469a3020fccb23c527dc24922c284532d410381c2af79668f0a4e6d352d0180759f054ea23fb788c841165d1910ab29f4c3e22fa6f6e1ba26e27bb6adfd41af3335dccfec41ff4677efe76fd06db4dd2f017e3400931af31d9197e94be32c626fb772c75ed2a4d1486cd270ee0b31bd5870d4a935f6f98d67edefcef83ed036c075b6ad6dc1e219db34e34abbfdd08bc06048c3ebeec409ed9a4c0b805aa3a8cec0acec134d949f02ff8a33a769d8b20aa0aa1a8e8dbb140d56360712213d2bd778027f4ccd5bb9442c1028c449b90bad70a48ccc18aed7150e0eeac467f9422cec8ec39b7042555b0ced3a47bcf4ce75d0f99219128cedcdcffca50dc6ce54b505e4b18208e3c1b6efc3340be4a572020f5ec12c4a1f47ea7f06e949fed60c69cb45660de67140f809d3170d59588e47b4d4268005652e9c65c94639f64be9d72ca3ac48c6331877241248f1280c2c0cb7d8dad43037d90185b415803ffbada1216acbc4ce35a4be2064757b6789486d03c4eaaca5377fafc9be4927307242fb175150169a585c0b4b86e8174f65a75a513131cd7e2fb32e01e90d198b64c330b36f0a5854002bd17ca77e53f15a89154b525ec47c54d47ba514fda8b80f5e1dda40aea7e7fb78370fd1725f77d945b603749d607a26c88777f9a1068f9ce2b51568d9a3387539989d8b0f94f2e942aabd2bd134f1d6d1b6e94355cdaac1d87b3f544df272fce702986986eabcce483001e654168e6c48615a26a8785728480b801941bd6500dbb7a561768069feb8db02d28fa3d51421541ee748e7075654919d1c9c30f04585aed7221d18455cc2135a636ab8d855bf505b35b6df5e1c42509a69c4ff7d304112abccca9866d0469307e4e4faf811418ab24e2588c7d17a1ca3cf6cdc93ed08c2dbb4f28a4fa1c8eccbd0a250bd8f882abb3fb6ed9dd4a7e04d1c78026cd50ed006251f9c1c316001cef93b63b6f79ace4cc9707fe71a0f1a281098ada29281021d3a212146006d8991a1892573fa85049ab48b939bd0ef5a95e6c79ff2e2e754a54f118ff0176f913d14f3478590e3d31aa02fdf7b46bcc6fd8a239d01036874cfa017ffcc3d38f73271f2c195063f33478f3d017db3b4994cd5e5f03c17ff45560980b089936ef0f2a0a74e89c7129021c7a0f8be8a94a0be6789e5c523255d32104f85d2832c8355b154edb496d24b91c15aa91568babb0008214d6e659a861ca66982e11e640b10120c61222c7a398d41c75b21d570629e8dfdfec41d2340e04164529f488eb88b6baeb2e464642216d28d3bf768c41dc0bfa0503224c73e7e4439c4535a180f0c0a93aa7c79c343013a55d95904a20b3abccda024cec2e51ecf7949e619f5662517db594deceecd92ae94a9812cce5ceac140d04c00b7d0d4740778ae28b069831b7d922022e063e8cecd8475c6a4d7677839c5ea7ace4e2f72088bd44b6598ff828b6cbbd6a2a033b21124f3b47655000f8ce829b37ee29c5493df413007c6071d16c182df328fc492f2abe71ac94407cd5ea68dcb42c29d3b8278218c739b54d34bb22fee3c31e4dfea1d7844b02574ed12f06d7d2f5ac61df97af0bfec13f0102f2194457cfb7ec0d1e19978fe0dd1df18bc830587c691bb6db11e59b3fe8b9344356f92fb559f502c443b350528794899828565845b042a6b0a3f18a47e28a121da515a531cb8230af5fb973532275aedbfd38c6d1e1e1fde18c85cf18b0adca33e93b21c20bfd5a28a75f502fcd362da75353a9c4b1d6a729064184972022fea55553133a717b519fa13e108ede4a565a9a4a895d090416dcdd3abfa52028cdb57994a0de84ccfa3227e279c7eaadddee42a5979cf3a517b4d5a4ffa9e0477253d648b66919ceacb408e7d9cbd2efe70b3cd8b0720c3b11c31c2e8f19e42972147f364b3425136b77bdae592cb531322278b3940cc3934b4c1eb70e9edbac8fe78007a5a10edbb1c59cd0ee75e4254ac5666a1239369abc2e6ed4a73fc0768df1817a07b0324db18464e2b3c4028c603d883ba6d67fa1c82afc62eb38e86d25b31f8062198a65a2514fa07d4ce4608ad4a561d3eef6304e8cd9b89083acc54fd130f38133fbcd74576eb5e2d79512343ceda357e05b01111168b759fed6d01d3d1f5df2cddad9ee78313acf0481c76ab89e5d07f380d0e3c050babad65162a37c20994f74c00360b392204a5559a1980247e56be4b31d0c438db0dabb7ec74390010068fd77e260df8feaf944b2c562a4c4c43e5b48b6a03f184b767c94ac8e6ece95744bf15caca03d18ebfef3e04003314b33e1e48fd8e966ba17bd8c386d5a859813fb87c2bef039880b79439f2770c430e75e720d626326d502ef47ad5f19bd6f9686cb140eb83545bc9a5bca932928b2c23a301c86ff112249f7fc9e682f171183af7410a7c75c02ce31f302e2682927e069779e4c6a7512ba9b23583c719cbdbae696761a8ab97ca3e13a28eb41cab10c73efe00a64adaa0b718b94a5545140c7847f07ecf5f70f3f529f564d6a6a37831c8fdb17974fa70821157689bed26e9b80bfb84b8ab23824b185f9ccbe9a1006f96c1a553e20c6b745103b2864ca8d60f9f80959212c675a32f3719f6b20fa140bf208997f779004f5ed86e4ae23db865e6ae3f7cf62fd0d9d0141c9b52979b818f02e09b3a48b379159e3dbef0d1ef0334134e781f168de6ef3d7a491f30c93e03b17b3bd33c964d25a0d596ffe72fbdd0943fad3ab233839765058cf13aed7f4dfb787f128c809792d49bfc59019489793ff56b57fbc4d465babc60a6ae9f785628f0dce919d77d345246a88e11b1d2dedd5ec16b6e08f30b45a1a69e54a03637b9c0fc6d4a0df1351708bbf10290d025643046cc667984ce9647553f15a50bbffb22a758623fd0971ffffc194bc4c4652aea76b806578c09c880da7254f5e0f16ce9378a7788f5accbde09618f10952bf7bd1dceaf98f6a8c6b46b245e645b82eb9bf384f1f56f9c96103967594b43f9d91a3f920bc963aef4c771c6e27c365fbad6b0eb993a4be21cc5bb90db7504c2d5e988eea30935af16a677ce83ef852553978c0b3d8367cf72af8083c53645705bc57bac0bc1de5692cc2c3470969ca70861cb51da0e0e06cb64eaaa282bbe5f94b564fd96b516e1fc6d1ef610a0306c79639cd0646c21fe6c9a4ab46cbfd6df7c3bc5f5a39688a0f908c394c5b2f42fd20c2fbd13800284fbbb61165482f9b5ceb4f60c73365a79688c5594b01b465de0b16ef342b285360b94d7851024299abb62ad9e8ff6ee67e462c6ff935ac09af435c370e3e99d080901bf7d679319bb779d7e6cc82808f691ffb9e2bd9c7e3c95dc68d67b34b5c370f0bbbde6ea4c3794feb419b86696c93dc625ce04f993ce00af4cebb83d0581531a50c9282038a5298c8caedd214e15cb689d59d47ecb8f801fde198ef8a3332e37286729a73f8bd22e681745ee5723f213cc9b496a11f18ad4f1efe51b631b10aa0022aa7b70e875fcb0a4bf4943d24e05e6b25f0fff1ab6c5a49ee254135211d9ddcba64236abe121d789ace1b812bf64183e2c4ee3667a142a7cae50364319aee1f2d975f33935755b5e5199476a117b1ee52ba249e3c44a9185dcffac2ef5f9fc7151cb4ceb1bfbdf9fc2d20d7203a02cd09e1e72d359e9ddd558b579a6beb318e2124b2d8dd7e8fc2d5cbcee5a9079522df5e9642e07703c2fe9024014924e1824d0c404e11aedfecbc9a479628f664fab4b0a4c1da749bc793d75c631959f43daab97861ab4c9c2a29f97a760a22e9501f8948680f245b93e909160904d0e3ceb0dfe3a61078899bd82c4193d7451de6725937869238b0a2ad7b6d11247099e03884f895459d27f8ee1729178478f4e1a812d739f6729209283c4eb6f0af9d411caea7d82e93bfa673c84f0a1d4848dddf6f0301c23ba73ead2a8e6b4632b75c7a6b972f0dc819702fec62fdf7874ac737d3e4a8f02b5134caf3830bff870a41e2881ed97f80e71fae39b5e6bb496f126f337b6dbdd649cf81ff33dc52f67b7cfb36f7be32b4c014ff7afed13f98bd4430abce4966aa6a4ce4992bccd65a82eda3f9b0d35eb874ee614cd3cb8c8c9909c45433e8bbeda7fd5ff8b5333755cac0397615e625a7eb8070603a2d0231db40405b0de39a2b739b8e3e314268ce34f50addc333347ccaddd28abe6e4479cf8d6a1633051b3dfdb4416f19b295395228c04dde7e3f3d62dfaa8088513bea18a6f9b2aa53b576c60ec77f9cf9663cee5c8201c7aa4b1f242d04787c78eb9aa94afd3d12a927dd32f4579c439160ec69fd40c99951a4bd28f38b5da481ac6328c7ddb7621a432d3ab8a7b87dd2a71e6b9caee505ede3e89a2ef77803a91c6e643404fe589f3014d1419c1cd94a6dfa06084acc590fcc9aafe146666456143c938664393dab6283b06f3ed3df63097f81921a0047975c24fb7acadb7ce0b0922e9e0c00e6a589829f040185ff3c5c63d35845c1f8bbe410d011e6d12e9a5165345a451eea5f8c8dc1ac968bf7635e5b2cbd58148f33f1f265bb8dba74059dcec732a9d965de85b10507c4b1e77a2571687fea10648d63a81ce280209dfe4c99b33f01467402f8e77bcec2f7c2605684a482e352fa551972e480303a2b9182dc91ef6b01f4f077b6965cfd9311ea98b95155a9e9bdaf744854441f3259c5a6009f643bc91685f2ee36d7e4171abaef9346db73fca05001c24d7bf426d262449b1df5eb1ed495987c9717804d2a987913b36429fdde118475f9bbcb4884384262d3cd5264053cdea9471df65cbab7c11f70e389bab55e09de43f5ce80ab69baff247bacbef20c5c5d023f9de3d8b299d55a59eaece4b6dcfa02f2871ca132082284520744e93ffdf1805b03f6edefd93051bba45ebacc75c2f518c7f9ed1dbe05c50a3358f2d6e7e7e2a135f1438bcb7493497229b686c635ff55819d8cd2ac2e554dd93b3cdb9557fadd35b5f8bfea2bb3586d1b0d5ca3797d440e2791e7f2ec4cef2bc419fbb4cf883c76c1187ae8f76e2982dc556c8cf206a5c7470c6dfee242905d6d5d2010fbeb96841153d8b6d640124f5401c3efda813a8484d5b648bd891c057e0144f6fc54c55f22ef6aa48a72d476e541178787b1a852f4693bd995c0bd17a23f61c9a0560d181aaa3f2ff587b5f1b8f7db7ba453336597b29a95b506067b4c17811187e1440ec29fb9e4b1ba7907f09a9b0a86a1064eec5847fad6e5cb942efbc8da00a1baec8f4eabf13321c3ff352dd0b0d315a9b389113aa4467587fc9985824bceefc47796bbfb816221a99889571e5e256bfcb5a805d253e31b777fe903d1b37432ce0eb7f04c0df0da80d00a22c4e70d3d7c799e26103fdb06ce1651732ee63af286dea55e8630d4bd1ceccd52bcc30d242c93438f8e958cb06041fcac7cb2d186889fb6ca602e8e9db52290daad78f30c0eccd498e921c40fba7c0546d14fb2e3ef1d2f54c4e4829c7d53b13765a730805b16294cd4ad4e52d98456eafe15f0ab109523500d1cd1065d74a42a4389611b27bd40b6874ec20bc2909f8fd7ca03204551817ba6565abcf9a01460bc5b2e3211301768a0520b01badd34f52e303ccc601a45166ba1f9ccfa5c43168497d63bc246be0380637288400f726e449f6c85c5a02be25d557070743165d9a816ee41bc072f2271515b96bfd7a70b295fb4d4e5310c5758b290a59050bb8431e5ec997d91d1e7ce4171699055a3806e171b123014b04f30a383a133cce893e43edadb7c970f135b9c59bed7ecd753dfc23c1371f308c7051c4e7d38036cbc50bc162a9cb560af9edcb0c9452aa2a1ce9ab37b58b2e5a27b3131c052c6a8fe1008d46137f1a6f496d4d80b16ccd619a5ea58be7c726f0d359268e09df932ca5a5edc5836a6e4d513c815b0f3f98dea546b08222797b2bb2bcbd07e6fca61611ee120c4e730562bfefa070763e7d8f963f4332c7ebb1bd692eb3f4462b349ef6c33a2edb68bb8a542f279d9c659c15251d4e58588ba2e827529e163fd64d051081fb5b56774d45453b5e8197af6ff38a65ac35236c396055a0cb9601ad7c9c9b785ede21b5a21caa633e2bc09d873414d36754bdc4c67391e382f02622c4d92c6ecaefb19ba446d88e9cced4b657a0d2d4cae37a6cdfe0ddba9d6dc1eeb69b121abeb64183a7f4a1b5a8e4ee0113ca520d43940c63cdf1301a6e2fa38a9b0aa6aa5aed552f63182c66bc4c958c988f2bd2131da74c90c9f5caf4fdbcb7a0c9113ebeff27437b9f3d427948cbe96fd900afd8d571eb6dff5ce567576af6216aa56a2eabe3c69767aa7e376d7eacd5ad1ae3d70d7dab12ecc15c097ad411fc5295b8126818a50d6dc266c4e41eeed7e801e0240b2c1b424ad3724d625390f18d1b24bf28df3017f67bd670977ecd822baccd92dbd16c170da03e51f7d8451f2d4a9e0e37fc9b9cbc65bf6f194de91cd4a00477613bf5d58d232ca1dfffc1803a848bcd3ab47e8c584ca88475a7e9731129943b4604b049736e7c4fb84cdc84637e45f4b22256c46ce42a022f3cf438630dc0c1bcdfbab7f413c25aa88d31b2d2dc96b16b9f028958b973181575396d199b7d943d71d65e5a1564648a099f5be9ff4145bb27468f6f16c473c1f167dea4acf8eaa6eceb87dd1f1fb7265dc964cb5579aa8fcf4b94fa9ef32adc5e35b3ca370e7b6a7881264a93839d377a9716ef92681297f51d8682cfeafd7e5fdb070d75d31bb3374909047272083239b3032388aa2e0d552c3c28b126e451cf979ada0b0c38acf5929a510da5850c540dfdbbe8cf4bf716ccbf0a9e39eb3a1d2a8857cfb41055a6d4300efb27867e6d5816dd37dc3bd9b3b524fe134865bbdf5818d17f7bcf895429ef25a4d8f471fd8aba0b40ca102dce83f114398d67540d6c9a2eb542692ca0cf357d85eb1ca19860d081ec06a7272d3718bee3d6988c74b151f18ea05097a2a7a2250f68e09a0ed7eeef17f0ff93a6b47e79ae04507128fa71950660f8c3eab9a102e8ab3ea746b4a1a1e85c6ccf15431765dd8d02ad971b2c66c90126cf45ae8d3f3ee32a4699febd359e148730750f8924a2fb028ded6dca164f3514c533546039b794b242a17ec65c4953ff62ceaa68e5986b8f902d4eddb27a6265df3b1ef3bd831574942446604fc24b3382fd8600822f0f305b339f77b77324e69ecea2cfc217136589c227d7ee56a09afc317da90406ac652462447b678dc91f6b071990f5060ce9f18939b2c115ec008aaf4ab30d3e1da8fe57a8f5ac02d3baa16ae2cfc791d537497757583e4f3990be900edddd1cceb48f6a368c19057ab13fb0ffabd88015141420a0c415e38aab0434cc5d075a412d140ce1f8d71d27528ec696d3dd06c7d1ef7df84a70335299078bec7c07f38d85c8789d96a027fa117e7b71286e83bcac0be1846c4e24fafdd8bbbcba4a62da421136e3fd0239462f99a67fef4f2b176f068f32bc7f6160265b62ea885da6e689fcfd31b196ae0f24b84051912ccdcf676a782fd3e1415322ba470b934b9c83fdf6aa88d9e42493e8e1919deacb2330b141bc6e55d90218affd9418976fce16edcd98ec121d9abe050281bf2c39695ac77c66280637c3e8f1fd5ceccd35ff1ad358b9e848e71fb4775e1c334e7328c16e25f356ecfa986f0245d9c7e392659b23644c07a3e47d4b60f7a41c0b8b9dabea97a53987a7594f45a7dcce8031c7bc6ab7c35c81b1e58e893ac2c175504eb5833cb0d31217319b969ccd8861985a31bb50ddfb887a613bb8b4060a17f2e74f5e7b7e6bdc04ef5c44a4f162ffcaa1c56c2f677dc076f646ceaa99079f2fd83ba1e42f0da7bc0710d93df22cc9263cd62a487180bcd88c54bdc4ac6925028b12ecc6780820a2a025b6404b9beb7e04d4527ceb25dc088f4149346007fadbafbf1daea96e6382a5837e9cc1c5a9b8aec6a2aece91953ada9a9a01db5b05e26b016b84949790e1cfff50cc18a7456a7ec4374ff96cd2ae0a24a167a802b9c0e8edc44f639e6eb6bde9d286fca2783e9e7edcf8d8655c356653466ade4090fe416b8fc539e22046b17f0a757bfa7b1e16b3a7f9d3ab59bfa7d46f102d7a20ee6cb4a72ea887eb11587709fa7e56a1645cbbeae02675d914b703d2ebb8b9b9a159daba558bf307090379675563437b9904fe6f6c937c70ffe77592d88e2e97823540ec79f25189700ea38caa32b1957d1c7b096fcf7ce57bb470ba1e92a89f6d6a1ecc7f09115133d404ccb60c74be615e426f8a1bb7edc4056e795f011fb677affe9ddad266138c67214e40f4c4dd0f7efa6dd6ca71f948089e37f8112d9abb4242efe7b1c76b3b8572cb8792bd5ec67b5c65cfcd7510dd366378c5ac9058d32d9c7db7636e01bc97e6164780e0270817b51626848ebebec1d38c6f0aaa4bdf48936d7909dcbb266b5b78064b9123433168c34a320f1037b63916abc801ac3c8a05d10c555307b93027d7d2bc97588f2e6a9bcd784c9ef05393581715bfb04d139f7d68bd5a292fbe92b49ee39e920829c57bee141fac52cd145da4b53240f5546733d8dd3da5648959f6d7f4b89a841915fdf50264527348a3e4aa094d30a898331348c88bb0ecbc2d81fc70d8ffa7ee0ed231d47cbc72565b2a209a261736352f65182096b794e632a337da566f9be9f475aeabce74513f09768f7276ababb85baf3348f6f1022d804e52e86e9de37d212b08de42c19370b17ec3471cb5f05a0b1c61cc0607e3ada6238063c0bd1d608249eda1c40f44150a9d49649a8d031f65300d7366c252a2224cd3b6d18ba2651add2b98c772265efdcd386e9730f422e6d2021277d8802bea2461da89e351557f946433bf2d2f492985e65c5bdc00c1dea1ce55e2baaf35e6b8616cb4e908d058ffbc30a6518ec7624f73605642764eef99c628127d0eb4730bd4af81c48405e51c2b647869e2f92e45591099473577920cf04bb5c81994e13271ae06e4b300773a3414b63664da474d66f15b55006f92e63d013fe2762bf642f8eab9dab7f4f3213902e77d1d151c2fcc467539f2738e46e15b66bd7a8f6a071de8f8c5191a5398a90513e37cfe4f75302de796c0677b63a6e8a721cf39698ea3478346f359252cb9d146d6d8903820e63151e6ab9720c397e5c0dee7991483726cfc080e3b0a546f161390b3196028bbf37a063f2599c0612d34113ab70058a6596ede3b4338dd2caf0e1ed2c707d103decd5c40e4d5623050ca7667d4b541efffc3646945f9a900fa517f789ba0cacdb9d78576ec188301110ed3cf173001c4494d3f2de32ac065c4f8d05c524f2565a4cb9522907a43a5a3cf633a9a617e33fe3edfd5debda74473a58a23c9721395f5fee851e265d5e6949f6589e0ae325f012fdc37b93719522dfcca76f4157c4ec36a84697a1a90973b56a8a9b16e63e8909ddcbe7c32fc24d828b40a047c5d9efb2f068dac2d5776ee9033306e6f2cdad9670e8385dcb59da955d8207a9dff1d810e26c30005512d002afb578b715adaac522f658c77c778e833b65c02a3f64651ecc5f94c5deddfafc9a35197a915ab2485257339d7bc26387a45fb9a6df5547f55924b78c63b03d2535717393f5c47ca0d281708e76a43756093bf330c709fb9f732299823927af273a936f2d04c24215a77d355247e46b9246f263e480e9522220b48ca2b833216198c4205ec40618dc0a58c0a205947958726b3ca1ceec2814f8a78e8ea24b40ff853dfc799b7f034f76fa4670043eef44e5267b736b69134960cc6f540a76a8f07cd9ad3ce0f04d49c256731ffe5ec63c2b2b7237878a2d1364b82ee603a95b5015f02fdf912447caea18d94e91d98a12f1c90d67a64f524115d1e7753451ff1e541a9b47a4fa0dd11d3d5dfa0167d8768733883054a44062d47f3bf73ecd86376c2107a2543bf060ed5f3679bba0b4941ba2ce299eb3a8e341d5cd6f0e7c9d9bb96a454c4555982d1975db26271b0fb142c3a63e820775af5b1c3854eaa989e80423ddb93a30856ea18b351132ef7273d6a73d659c97ae3e1d787dde5d63f21d48bda2ec29757aecd2bc5b4e0cd91dd9eb8cdc9868ef9628e31d46a60088c6389ff8771f75618f352d27c878fc65b651c4a7981be762c6c3892d6373fe71ba8b8859daec9f94e963525252bf924b5351f9d4661844715233beeeeab5590dcae3a06cedd4697382f97ccd9398bdbce3e16e8aa550db8dbf29adbbc7a4a4b3c152f1db6a66e1f395a7b081cffc860c2fdf195354bc673aebe7ba22cea19918d1c7bdfdcceb505ba654a49d04dc49d8e06a5d2880bcdecd1cba9dde5d99362542e44af58c885bb430b50582622ab2c54deac2727e773fec60e11abbd20dbee77f376208aabbafa5b533c102e0c38e76a108228a86bc05fb318456c0e07e98992b83fed9e0224e0f249a4a51a763ec52a62292f2606efe5759dfc1617df07f3d92693face3108d668587f7f7677230b82eaa628f7d9ed96106e9015c4fe56eb590ea96c85f3a04e77f1a99fc90c60c8b29b82710244de8b52ce7eb783a84a1c7b1b7bcbe753964e86ba629b743902a6d17e49c2457b99a3eb3fea3108c32a4e10d74a376dd38dc73885cf23c2cf2c05e0790e2c5b7f270554381830199a91ee633d19ad77dc98c2393b781e7159936d9bfae524120e477231baf4f3d644f0e6ff8d2d5b2184c15a9455c84d39e1004c5c4968a46da9ed6924768b0611b809c329b39305b0a28487209891890c2cd2009e98335099cfbf1a27ea907892fd75274dc59a7a60ac51b7ce9085871647793e0a1f68b8a7669725e8f1d8b285832098cebb54177c570d3adcc9be33bd2dfcb721ab2ca42b060430cb5dded651f9c88e00521a5cea08917b3ab5369923b1741fdc28286efe38c846797140af93b981e134840591b0342a0eb316505af1b88f74d9820971c5095b102b9e3f301453337924ce767a115c178592194eb9606b0ea3fe210084082d67cf16684388de5c1a5827818e1d3f170f1fe44dd830d5c84771970f4287ebe34a35ac2955c0d76346f0f61db794d0a4b84088807b9c7ccda3be57678900dd4297048852a4ec796a19caf49a19f46dcd31bfafc027f1bc392112d65791c7cbdf958349d301ed9425cc7a2fe5253e648689fa85ecb18570b8d27859699cc2b50bbebeb3a262bd36dbe9ea9fb70e6813a245c813ce4feb32385bb41424efb2a1a3419bc4ab62561d8bd2ec58194b6e6809de2da5281e5640f376b928785311563581b9abffbf1d54d23923a3701779d56d41eb3b16a095a9cf717e087b94fa5eac9427cbd9dbe6decda6373f1ef1107a1f4dd5d8bb369dde77ad191827052c35fcc5e32bdf3d83941af56048011c636db75800a6aaaa9cd1c92030a1cbfb0f9844132f10060de38af2d539711920965c92abba4b3ba8a83401d3b376c44dda6cbdb0af8dbd9bc5b6524ae794ba472eefab0157facf40f3934f65f2e1e1dbb4b44f82635940d8f9a0052b8fd6692182a3470cc7f23066944e6b87f3b2a204fc6b21a5622f79db2e536aa41ec989013f15f8f005982672e2affc7e278e032e8b6482e67180825d54ded0b66059707dfddf01c652530ba15aabb6a565d12f41196d984a654f963d8b1c50b264745ef1e58fcb1b3bd54e9219fd56e83aaad12ca557e185526836fea5900ac234a416fd6452086e757dcbc9e3b0bf498837185ff2b02184935b70443985f260dc1c7d03f0588fb58bf35d2fbe51da5e71d0cb50153b9fe498e6635b3ccd3fddbef3c0aad91f5ed8553a66901644fbd19acaf1f60f7d96788cb49db039c8f3db3d7b0b5e360b183544c8b81b7c0c0adfb85992517ef9b2c6c3a06b550f8cfad3affc97cdd00b721b7a6e0de6e784c9da6d622ce052def18b02e50a813f56b291a64a636b2e3e5d4fb8182968954239a7785a4429a33fbf338ddd730ed1a6e4b385e557efa3b56f8a17b0d6fd6aae2f4133904434842f4e610b4d92fabfa6862d69acf8d479e5fef892aa4266f291fa3461739610f744246d3a4aece6fdbbe8c75b5411d9205a9bba62117446e11a0a224eb9754de56391e16f41159a026d579ddd1fe18176b4216526086da6319768423c767f812dd854fcebb3cd7fecf5919eba90899419196181df1ef471ca6b07dc228668c4bf15012ffc9e5b233131e50f310e489cce856b0cbcf826f9b707b8cebcde9733caafc7a2edb47ab9ddb52b0568b92669f4be00f4b011be70f4d5fd0ae7a49a70f55837b0cfd13e96674d6eee35ea5d8e08c728a0e4ac5870c06fc4154f1f8920b1fe1d66065666b50c236209370e95e13b12ff68e9353f748b916b8a71e07c6c90513108ad50e534c44e8ce933e48eff16e8e318c89ec95c6c948895e8c12981b64c588dc8a3e5d5be9d64f6d74d92c52ea5c572da84feed296e33790a8b8410538e701e4a8c137e77ba6bebb7310ed8e8cef7a875260f4fd379b30bd85c23ce2e93329be137d1b95316cb59a8278c1e502b1ae664730b8de88ae6343b3dadf547276816a052d735d436bf2364e90243f94ee6c633c28818130dcb72955b3fc27e9d00556ab6db435548bf0083c1fe35f75256d948f4fc456e322c579ee827f551a0ae543ba612595f180ffdbf72e3a9dfa47b25d0123fca5f728d09929bb754abada3c1363fc29387d92af88f51c094df2289a275aef54500db18c1af3e3427bc8fad7f8b09ab2de0524626088accb2dff507bcef8bbab513f7814c08dd27bde964722326d3bb0af95ceb8d14cca602b9dbead4596762ff914a858d9c6b61e6c908c87a333e623070ce9d8bfed7e04779d337bf5ed8266abfa7eaf9cb07fd782ff02b0173adcc4a123a4d4d43a53489b75d4c4533a16723d5deb6191325b3cb46ca306b59789d258b204759ba1dfe92f8c254a360f257ba398a870b1a447f3cc2784f1f0391e233a6774e050ca7397223126b0a5f6d33a349f9e902130d68ad1631e9b8f605a00b1fa977fd77f454fc05c9f61e00f085b7af7bdcc268e7d303c8d87083b709dfe7016b6ac1ebda9446e9585277a972a8b04d8f8f24bd685ea7c5eea104286afe249c13b5246921b02d36f96f235f83d4b0b4b2ea9837359406d7936371bca1f4c5fc4aefcebc8784cf297a33229e2717bb2dde4e9e232b5411188476357dec4ef1043c84bb847d780e9a097be9062ffb3852e58e4cdff3d5be8513556fd90afc7108a71ebb86433114ca1b5de0d740fa7434431ccb19547f859a7fbc70499c5c33fe77dbf05671c2ca4eeaf5e4372ea31f1813f5da61d5c2e3fa272f41c13ba6c940c299524e19615f033b3bc55053ebccba37f64a04a33bda31805f1bf3c761ebde43f92ed104f2c70d61b1c9391150752cf3d2803ab41b6f7dccdbec6181b0f07bd2daa3e5c27f39f3a98827b2aa44f6377119f6a89dca2babfb82d943e80e59c05380241a83c2b0bca89e8dab0de88d5b065ab92da4449b043043b634847f475a23bcf9bbf6686c2b111b9ba45325615125bdecfeea62d14bc96290b8ff62008e08fabd5db2be6efd14e466d30231f8274d124419d7b6e0c7011d248e41c66e561d4ee1adc9a1ff4175f2f61f5accbeea71a88bfe010c636170ab65d16d9a9f154920289d9f7629beb9a1c8ee31d785daa10e1ec455f5f7ce01eef9edf81d46d5307d29d524ee3c6140754cbb3b800036e9316f712c03bcd13ac3bd6136b93917bf8fd17efeff4bc9166f6882aad24692b62b83ae8c61d881d5ca3d4f0db4f135a548de584f6fadd7cf01f3fc8d7755c3417a74c2dda6f4aa0bbd3de0bc750d5578c3641e1d8e7c55c7da3baa6a408d54b74af0e1ac8cbd3820b93378da72cfe14b8b4c3d8cb819a8853e80aad87731912af3b8cd5d2564b3f9edc9b6f3889da3eb7ad0dc6b2ea695357576693304ea1c90b822c1e0e21fccdfc7604a7e4a815c17970134cc868a195ed1c718a41f431c438398b0c76ba5f9ad5e8892ffa8aaf961eb413099f6f148522f8ffa10c82eedd63217d854cdb6240d388912967ee9539624c96b73084a470968de7bbb107d6f37d8b1995c1291648691deb34eb33580c35d24744131c74a50163a1f972e6add593b0bac14a87ccb804eb5d8ef1d27b05257b26033e2e0b088391a37a36f0f3400b8e0982a4340437c56703e24cb7fa2c81926b93256d02264b56c70d14cef2b51ab7c8bbb28aa791ba826b02f099da314d809acf85d16ca506a0f2d436d6cc14662416f07d80cddcea522899771081e8fbf359544dbf69487a65aaee7c04e4d35b7255ef912b9a832296307692debba09465ad4ec70f68aeefb940fc5cf422ded52325fdf2c8c0172ba1b6e07dc931293707cf3c32a6131411b791076fa58fc38d40575eb57622241e131f8abd7f2eccf7f731d8c85c7ff3031bbafa6af855bbaf650fc57639b9840e5bf9a010e1f120c6969e4724c7be46f667f9599891f4a6730595a49fd9d90db7b94978646d4aa64856058cf3614d9d68fdc4d00de640e2a2378fbc6145132f3d1b2df9d7bef30aeeaaa6d1c0eec861ad06053b089f3ad65ae9da16569a40de917d1457adef1eff7f36fb36969a4fbbfe88ae9fea850f66062c7027daf0897da36db804d398215cf992a5abcb89e6d433c51c7cd7c6515da958eb702f1f0b31f9e6efe64a6eb51a35c2c8a1a708210a30f9b9192f3fcc144649a7964fc57575e285d851efe9a08efad180a3b9fbaf9bf6dc725e32c46f4746929b2fbc33a2ec5ef2fa8def0a21005f765351328f514472b24b450d5572eb8258d58f489195c3f899e07737d3805a696e042bd13a72814ee77aa9b67a7549f93ac20c1957a47b3861a658a573726bf7027db703a88ea40c7796e8a379216fb9e7ff976f966769e5044852cdd9dc8f4f52eff8790112452e357e8eca9d9e6ccda93dba99eea7aa05f73e25b6d0c57dadabe3ecaef02e7341030dd96241f842e0a8be7a46b98efc69e322f4b4d4ae2f910f13e7821dfd1fd5c9b195b106d1172ce9bd417d30384ac47c0a8d0ccc1410df6b890d1426e649ce31e6c51beafbefc120faf93894619bdd98e390106ffc30a1855d70e5b3a64f4e0b86ff12035019e9dc2e6706d7eee30e6c56b1d67376fe75ee13e0a1f13510f9c5826cc10335c6580a7adf8e64bdd904abe2b3a31bfd130e7c742106c8ce957416363ee4341b9380844a6eb2754a6d51b875a4f399062e05a47c492f87cbf11c332063636db50ad2932e2bfbac04d74f465309684c9710a20f470b8167edc7e0491042400e222e55b9e3030c3bd87e98f4c6f61cc2ca94a473679022a707665114245f58019ff7247cbbcf62afc34969e6965d990a01c10bec996829ef8b3e7e7784a0c50a91d87ad8efcccb633effe8499bf4525adea2aeb3c635bc5fa80df665cacf5a09d47e671d1ee0aa99aa5c049ef2bcf0b036d3d8674fe84f7237330478c6391a4678f6dc010aa7f286f49cc4d32cce209f3f8f22c260510c562bec1a297e32af9599924dddf3a5d1b728abb8a5c78a199f42f1ef360d760c46939127082058a6a2d74204c61d2518769a350fb1cd104c020e020ed002f1dca3072988546c2469a7e01b9a4d24428d19d3673825522a4dab4743f7e3b06c6ef73d2602c4fbde9274ceed291ffd789675b3a3c1d9d1543ab94f6c10618ce37d42fd49b05fe9ea3977c3b4037c961bb7d75f5e26cbf3494c2c49c0468f3f48aee29460e0b293fa58556567972a6b66f7cbe0b9dad393cd96ef0ecd9b6fbbc0ea167a095be969f62ab05c13033206809b8929ac3ffbf3d4b7ee56be05eb36258f7b468323183b64adb1b4b837654d3e5cc4b65cf80b692747815deadeb7493a09f20a74a662109be5e0adac645737f8bbbcd11fe11ba9ee66c1818f2a6ea33e9bc7e6a16bc14164e11abc1397844ccd57ffb74b2d21862f518255ff33c9376a5a4e55c686ef58f8f2bbbac14dda0f077673fefe14454dc62f19d5906a34442de77306844fdd06709ef5915c1e1f54871dd06d920caa53e2490818fe38da3e80ccd7e6af63ca6a70a4c8a4d36bec4f54cb942ff1fa874eeaa21f77afcdfad2c264db2fa9a19ec1c7129b617bfaf24ca4662e62fad0be1575bb0c928329a32998f3bf33c4ca40bd3aa2d28cfa9d03c8aaf3f6ed688913e901b98e5688f035427f95d2ec764d4de5d7cc79120a5a9cc792a0154a8a2b491c823ffde8ee8ee0c35559e8f958a8337f455bc8552cbafa53a9e429c618f2116907aec69c2823fa5cb680e0c0f748f595a41b1fc1d9e802cfbf2f049914957bbe6c677e1df24103f36aea9da1999b87f9cb2fad31675d3dbf4f79de5758f2da31f6299c4e8332a4de8834ff53f42c95499c57e49a420c6c03a0aa3fde96fd1a493d3543404bdcc17b4e1f49de3a7cc7a5cb29c8289c360fdd7568ba360d888c9232053770f8f1d39510efad38313a2034982db07fe24eb463ed2bfebf13516d08b978578bec50022330fe6e1103504fb1350994456fdf366043fd86e777be5ac840915434c687d96afcc86cf501e31dc8e9c13093cffb8baf4dd45cab81e4404b78cb48cbbfd472d75249aee5396bb174282e80a779ff4b46ba1451fa8dec5b37d416a29a73886d25164b151f9b6b292d7d19f5f45ddf45906fe2893ae64a04678ba0394a21c614449e7f54f830639255561e204448d44c4a0b20dd008133881edf4b66a2a3f8598fbced2033c7fd81c2718c55ae7e81ea1a4210e81339250dafd0ae4ee240643b55b134dcc29375db8fa81f4a583645bb2a715cdd867ef53fca5098787f2059bd6b56200cdd399c4ae68f29c8be50d7e4e5a0b010b285eeb469194ac3d0ee1240c068c4c6e1666dba66f83a29b7af51eddc55a4cd2dbeeb44abc4127403e4b69ba9e6d3cd907e278bdbe781bc40964e95ddbd940eb7ccc394ee7d6d6615412fa171fa2147eecf6e103d0d106dafbde09e051d2e69753d368ced8d20d977e4e4dafb965458f3b27c3fed214e814343d000cd564801ac392c1f86fec047c271c23e2ca6db085b3905c26679c4890784e719983b38b3e260c0c2e8771d7ce66810764bfacd0997e6cef6726f21dce6ad7c1d7bd6d37d0bbc0f188a6af36ee016154bb4a3c574c67bf38a2ffffbb3110e4fa2544979622a3e00c4f86d0dd64fc9cf1c5ede73ddf1c2cc92b61224982eab2b57ba5a4e188e8ac0a8361d4d259b8caf32fcd1125dc8719564c3365a16ca0ba93e1fd46fcdba15e4e561894ac1ba71a24fed7eb0f8b2e9fb4c1a2753501368c15f6048148f91a251aaf22f5689d89556e0a3e3f377da9e90a3bbb12b933d593796a6cdf8842120da4a952b9d9f440112c7e363cb8052809e9ddd106645c26faa9838eee341d05e3a411679451db2e7f465a160c5aba045c66c2bff31fb73828279c6c472c718c62dfeb6d710630267632f1b61f82f769071575ec7b3ce4faaf4aa2fdcd252cc944d6edf6119174eb99dc6b2c74b45b0630997728922a68439b3496ccfa91c0e0ff670216710d4f45c2b544cc47aa4ad1e4f5bc57fa4e2a6963330de749e8a189494fc83594a20b9d0332cb83f91e69dfed2d2eec4433f86b137db31b2981c8a7ae9713bab3a3142ffb36a47e0cf02647f1aa2930cf3b00ad569ec388ff2e33f9d1ed6872e50f7ecb4028471d8a122d15a0f9fd6092905737761a917a28c262d2235382dcb2f07f26207b7f3b3c2df450ddcd7099cb1576988655009afb84dcea2425d13645fbf0b8fbfcebc6795c301111ee398cc628b74848080c6b3c86a8398698f66211e3d030fb4180a57fc15ea01999860e5554dca37c2b421b8b39d4e1b7c049982d00c171e70305ec8f043bb18c367772bd578971b17e43a0b08ef22eb9fc53e6ba4689255693956451de4ca33aa5a0b129aac5fdc48c4526e02196a13b2a54870c1093dc86df2165291257d725488b67e11b7dc1a45691ce4790d90b6b50be0277e16bbe9303ecf58900e8136006349cd855019b089b06be8a4dd9bdec8bb71ff12f46cad7b90d486e1dcdf97fce8b5e5dbf85962c08957bfe8f37c2e7e59ca7f01a77a7ac90f07b7f249b88a0d2f52eeec0a246cb82c39ec50a972a286879f82c3cfb05e23dd5b79bd927b31c9ecc398372d2acda132ace2136236caf30916731f5ee8e90f8508eb9810d04795ada61d482f7b1cdfcf80d97d709cc437fdc73e91614652a53c7b461052c522d15e21a668cd42e5ce86e5eba54f8dbd0b784c8905a5135eba9f70939db2785409c1814671c9284132c62aac51ca706ab1c670fb1e631d709dc70ec546ee669e893a3b2a8663dc53195bd054b1e4f2c089498931706617d4db014e153b113979fbb225c3c01456c8d49fe3ba1cf2c4f3f24deb3ec493476e8f79c8974f49e6163f524917f09fea68bdbb6aee3c9ff4fa1f23425578b1f7cba3c13eb24e23ae10b86aed7a0c3202d67ce0a849f578fbafc78470555a43d965c8a5904c4badd04f031ba75e71c47a9496e342588a123a21e56fbbcb442cb8898aba1b48f8544b7474db2fb477874b1f90d020dcd54098ee295e7b257ebadd52d08f3f1f8f16c13fe93f99e0fd48a4f1f7256e6eab71376a38dd4cd281fe84c0629ab4fd8111aa9e5a06264b0a6d2196170a4fa112415cf1f7241c77096262d3ccbf8d43cea54d18028b71af8c777dbdb8e77f07bc268a7229ce24d72b235d493545e23cf15e612d0af33253c5b0bcdb6beecd94a3e6ad383091df8779888ff4a6e34ed0259df96d853081644f6005dd6223493cbd4fc2951088b06bee4b49c5f8527bc901511add45adb18fd2f3088ef31177135cf03d132227df6e186f429b0f1b507f2ff946040b4432d405956c27d696c3f41fae7995c4e75e4c124a6a6978fb39bd956431c34414d313561936e5d35a28f3121166e9e28a8bef553cc13e7a9c84ee2213d5fbfbafbbb1cceeae70ca63b5726eb82cb656c83474c158c845e2cef08eea965813550c0c78a42c319d60d4bded5ba1f51c23a23e8f540b0be0739f919ef72e3879ea3052d5c3e6ca862a3fdfd045a665bbfc2db5247fd276b146509e0157ca109be9ea8ecf0a993a97cd60eaf584bd5b0a4bbb2f53ded82d6211416be9c70cf2362b7784a7541cdecfd1950e85a966d3ef0c0e23c307f784104a36c62acc0607eec9dbab7432513d42f8429cdccc233e41a085ba553a762c17b552b5d124f8b6047fda78da9ab40bc1dcd112ca081af517a183d9f025dc0b07444c706c47d4ad5b8e7eb97980f94f59be0184d323370f2d1256240ec64b2afb5dc86b667e8dedf45c8286f0fbf344c05705d10a21385ea646ed2c6974d7f341dd805495e0949c0973471a342dba720f1ad985c5b5705239b854cebe50612acd0fdb4f6065bd24795c7cfb6d0f35a1064a491dd31eb89668bc4c4037a28772aff5f557a3744853d2241c0e78a251d2e3d64a612a5dcad8dfc31dff534ce63ab194081872244b1d2b683b3cb9c8ca5cae1a249ad27a892bbaf1378f92bedaae2a23c2391265f6827c1ac8db91c6908cd6939803f84cc5faa05031f2bc526c69cf8edfadf3ec302df027127044f6c439bce5e643ab90bbb0751cf95eee36a57afb8a11bf910f89ac45c1acd042664b792de64a23ce6b255e167b052214f2d9e79a3766e54d0b38f7fba00c0f5c8e1a810f735fdb0241c5d21464cff1cbb8d00f51db52c63729b0558101cb59c2b87bd0ac7cfcabc655e081bd3dafc8921958955b5e267e6ecc9620b9d5955c5005f83379c7d727eafc80f271c43db015196663a46b9829578f7d1b0e1b2bb8b9101eac6fca2f39b535730509665e381ded26a6ea9dcb514127fc2ad01a1f9764350c6aa8f7d6021f9caac0f39e78eade2c08a3808e48a3bb34d68ba7c6b9363d7404f6f95635caf936ac71984b90be12cb1613c3a0e63abfefb39f674fd013eab88a1a373aaa3f9a1c24c3ac24bbd13d620adeacec2f1b557f0720cf360328d88f73dd2148f82954de507411bcab98a5db4d081a4d3be93a06c9168dabb04cdc9f887091f305a1846c848fe460f4c5bb9b54f9e2e4da5ea18d8d97a7faecd98e00046f442e82186715e664ff3f573bd04f2575bce8554a4166bd10c1240d5a586a42682251de00fccf43a3b2f87622eb6fe3303de06d114939fc5a54d19d98d23b63920a6e53622112ba01e6d1bfe628741d74f52dcf270c66e44ff21aa8a69310d728183c0d3c3079afae8ede3620a7991583b13d2e3944b71a08945fb0c3baa8a29f7a0f2fe438cdaac68a77a5e609cea72606e28a41a866c7100e4587828c8849a596e0a1039b129a1a7f706f38f8c7901eb445389c044b5120fdbb75a86a20365803474f7ce9157c457b73dd8e5c1368818d769b81fda14230537b333b2711f0f4b4801b465af07884f7d03f8d22865ad484f07aeb2258b059be143f8bc8360803966c2dd7ff48a611625c0f2bea68aba9d6e7ebb2b475d61c6b4e091e52b388494b89b1c01b7c44981ea8298aa76e41e2dfd6c811bf65da19e63895be336894a264a87adbc539d3c5facee70a287eceabfdfed79e7b7417651eb5aa700aebde882e790e4533d7ebc352886360147405523f5e26e106e1e50277eb03805f316d4e0b034a56498344d0d41585882801c39091d12ffc8f6eae9971a80c9f07ebc6c81deefea07bf60fa4da33c79243ead93780a1b21dcd9f0bb6e40968585cd8c70a9798141a0454acfab57c9eedbd1a306cec39d9be33ba785ff75908da23fdb82290c8f4bf85a895c2317ea441573e0594cf24389ce915bca6a8ffa766efe14ad76881f3eb19d773806728ab8071a80f53c63c1dab7ce6151f2e9bec85129bedb52eca46401c1c37c171c14bdd7824a68a05c4ad20c0643a65d0d2e80c1d8575e05601b9ac29ad444b8ef9a7a89824fe46ea7708803bc86986e653e8ed9bf866823d41ad2d074e132247a7049c3177ec06871d269615e40b965054958c7764192e85f9691b8bbc6ebbd22813a60e122f6766888b3919f7fe196a7743504b8e4591fe26a72b564a7976b3f4d8ed2e486a49bb1cafb0bae1fab0d5b34f35f1acb9c99a6cca100a55c6503a8883c56ce5a8b729dd6a80a8236f74191bb52db116d2039121a606fd48e05c89a6b6ff3143693413cb97591bb9266dc7d0d8752411d0c889797856195132cf503880551ac3445993345f3c3ca4be18afa59baf7662c6de1751ffaff9bd6145c7a8612572ea94f857724048c5c6513e560ae889d6d9fb32905de3ccbae23f90f83865ba1a6ec044dc9a8629045ecea600c9d81d16ca9321790c9dd79baa19d22eefddcc16990d9c31db8167b65c01a577662abc6a1caa20affa2032713b0c4705edb4253a299e9294df401903c749a171e3bfd0fabcca077d5f2e6d03c20b97e4e6072db7df9729cae0756932d48240eaf11e52a91d32bdd43a45527d577c864249f007e2328561681d21e00a64cb9f61669c3d96562274e509632aa78ffc1cb26cab97edea39b00440fb38ea6231c227e6a6c4e8481dd8957b9f117bde47cf964881a942619ec5261e6450b66af52ca534ba724bc2b79a468151d2c9b9e4fede355d60970231544cbd3587c08392877e0d3b32cf1c68b3f3d64d4ade194998ca28c53b3ede98a8a6f334499a43fad7210abc005fab38752d0bf46ce8bc43bdf46142daeae56e12ca2c3b490112db34d68307188c7f04583d54439d714bc1a5c86deb2f4c14953e2e16e271f37a35274551960011f5f810e936e882923d49f459b4665c049f53f0398b872f5d9f166d24cbb9a3b71815c40e05f9f8b24fa361659227cbca882a809b63a3d6f1e8a0c8869e81f5b9866d97c4a4301c8b5bbd2fcb1d36208333cb2a152bc81993bf229ae7d886387860c61d8a26ac39bef826869bff1350a0dba284aa88b108918d1e32ac7a4d0652fb9404076dc0ef5f21c6fa99f30491122fcf98417f00d01ce262596ba70426436a82533328ca0814eb56694ba07a3c85ceeb7970ebb706946ac202e96f689d32bf3a609f88f4c8d176a4e483f367e798b8f16dcf838831576a1c5dbae72ebd162c9bace60457530d07d2cf6ecadca1d9ad673a0970567dae5064b47a9149f05aae33da8b37c97ce74f589be789ca8420c7d4b98669190f5895caffc10d25227719f6fcf5070bfe44a22f29d2244efbae008bfdced7745431f852fa0ff31a65c2554751953840d284b3078694b14aa2149cb177d232121c5885ace32c67daf62ce44d70faa8839f4405330db1dfb982cdf0c3b9f3e8a9578e7d4d466ca8e7488360700992e7e0c0af995b3ae9c39abce414b3c309e7c637d66634b040a8674792759c23074ade29d19a0a0cda71b892a443fc924a5eb248cf53a835df6151ed88523cfb058342fb67d00168ccad50e55185eba49aeacc4bc6bec8ed399ab57a855da41a9940df7d92dab3af5e472c8e71fab89a4793e019dcc88c56a39b0f889f17f1249cefb530f5063b727022c7a634cfbd463b5dfef96a9f7416fe4504ec3fe50a5d6f0aff329a9ba39c2edbc9a62393edd5f84c676a7d9e86229a4b5991be8853cb8caf897698929f15f5a48d29b6afc0a2b24e5d26401f84ca23d568d85e9a57f0c34c895683e831425ab2682b457fd65b2144a1355a52d6578b726d399f69efbd23f60575a64b45c5bb28a3ce32ff31c6e63d49b94c006d9c315aa89e10535a0a43909d999b049851ef73f47627f1d0222fca6a2cc1991160bfe95bef08a6243fc71472f880fb7d11854e61eb2200f0d2e2180b579d0f750473596f75029f31a0f1ba6fdba2fb8854f01f7eeab2327d66e6ddc3382dc10fef829ebad3beaf84335b8d2fd7ad46c6aff5a8f1b6494d71cae0197cf1c7a195b4cfc12cd247fbb3de2e1f27d9289044d89f775bbdc4b8841a3bf8a1107bcd4e64db66836155b686c2d60d4de6b92e67f6ede0e198834bfcb83b492d50bbeace22ea6a93ed5ac1999eaddd516802e44555df2fb349bac3ae423152acad9314cd7990c9d2ee783c17052b62c2f158deca94de0f63d30f0d5dba66dd6f32940630f1791aec151aa25013b9f7ac64c0a0b57ad250a1d39b562a1bfe6782a36f8ef1a812e28a93afd5f40e0317c8d828f31c19cffaeec41631e4d81c29d987fc76f4a8989dc0a514e46853c94f7c9fa30b24c3b557e7b03910c99bf72e33fe5b3d4384ce37efd0718b40df1c4f8d4e062d4e103ef12cbc5b14b62ffea9c700a52f63df6199a0fa18eef77be4bd79c955fe36c398d7394921c6c2bf70fe5550db27bfa776914bf06d84a478d5077224e996c6163afdbbf37d7ec9b9f6673688dbce8d14ade71037774b166065bb6fd01514632da1e02ec19cf44fad364a4fa01ba8e6945ac93c4fd2109a0bb3cfad4a9ac1fda638e0cedd6694ab8820552ad60fe9c2d80db865dbfc42c24e0e766e7cde66c55e0e03749b8975ee76d824bfa13f373ce49fd1020131ecf089134568764717b2506e9dcbaf5d17bbc7b5575ad41f9a9bd2bdb0dd16d5cc2c3add64a9a00265bcf2eb4e1afc7ae2c1297e3dc6361dee6b2fe515d291ccef8b14006be1850dd125c33b2d7cb49f578e61f73551323ddd7280fcb1454cd401293779cd590ea0748d9584cff642d5b0bdceb4f8682a56403de5105e473edd7700c2ca746a46f221ad74cbd29053c562db9d63eaccdfc1f3157a820211bd0639f25fcb46688f51e74eb313cfaeca9abb9e6e2a2b2e308f86f5b351dbcd5aa834ac9f25bb487c71d7f2fbccc578d38a7d1f4e9f5b2099c098174c1406e9c5f1c2d4ac0bced7e740f33bf5d46f90d2924f412dd765b54f1c993722f14d66217ee17da8204225f2d1a3b3d8364d5c7fed11099952f383273d3cce700ebd48bac52ab131f2f09b073dc844ee0f1e8cb115f558135b45be2d11406acea266f6fe56e7170288c530918e7da1bcc60355af172bde9173e6ff7695c945a79a9a4dc7e60c6d159c8909a8808dcd1ad62126b96a2e1935104c4d9fa79a3d2c5253393063363fb9d7dc4a26f437a217950ed2a66c81c65c1f39943ad70e7b63944f8c785a56f16a88bbcf9a18aedc13a765973046ae2e9b02872c66973f6ed63cab5a1fb0ab62d1cbbc3875d9cafe8b493e45bf6150ccd04cced457fa59c23dd384ebea7cff3b1476d59cad796a7d60b247ba814e3f664fd356c7799d9df463c912caf246d48f7695a2d551c20254a823e4854ce7b85248778556907c9360a1b366e7752d773b58ca0bc4b3b3bac0a4622e50e3b5f7e261bb3c0f9517dac662a17921111acec89eca493e8c724dc5f4cbf5cb8fd4149a92fd2ef5c22e64515579be4e8caafd572f18966f8a6d0ec963eceffeaf6b8c190389cec9878d50417fefa9b5dcf608155b73be85e2de357807649466ec797b0df372e6d0b32dc502d31fc9c457dab81792655868f8e3f43f20a5903c222ad8041de4908e2dfc063600b432c683d09390b9c5ff6149b852c46ec030199f1c6ee853b17aca3ed8a947a15a864034d94819b222fcf0ccf1826d91038b15a4428c81dff3b3ca4175c018bba46274758da459d3a5d3fa7b08aaf8bb1fb019f15db459d486a369131922566cc355ed8e477d6ea322450ac7e82d44296d98ab8dc87364208c93eea3ceb5e21181cd74e8cc65e3c111d0af42e7cc66772da3926f0bcf369efd77f82cfa541990a13afb706281ab50aa23fecbcf89667519d5e20b8cf1213f1b0db01cad7e0eb6489451305b8d2598cd7b617c8f9103313617211b1c1dc6752c906635e75ddfc0018f0d7db6ec18fd39deb8a82e2f1c0f81044173ed3db304b94c67766c223f3a57a356bfdfe1ea416eda76fef17eb8840a63f864bae385b36a9b8620a28bcb9ec1e2aac44f793483d5e3f8271fae608d3706063c152347b524f3919b7a8f98034fba46a0ff43d0e29e25097a9120540ff18feeac52ec74512913aea646c9d39a79f67eb28e92ef08de98f12a58ba236476c0c09d00c5114fd381ff42d1f3c1c4eb3006784ce22ca5a7f3c6d5c548d733c4796e289c150661f5af7aa341c4f24364f2489c739a7dab117a0b6818231846c2e344d83c34d5c0b46ce53da9ee090a4e971f4a4ae174771151b0e9fd0297a5d68ff53b416793e6912148d4574af645bc323bc06b0a0974b480d2b85511d6a9aaa0ab4cf350ef517108fc638e7fbe6ed08f0e908dcf23670e529d709b33deecfabb96265e32790ddd5abc238e0ec21251a78f8c39c6ef6c3bc956e16aa0aa3f82c6904d50c90c0a7c074180374a16574a9fe59e737588aa9ac8464066238a9994bb97410290d5b5c0bf4b5545a90c57da5c1f2234713095a96e9bd5509b8260f2f74412ebdd2dc39e045570007cc97a61e419a66e37b72cd5432939fd5eac3e8627b2eccf005e1c7052a12555f1ff8bb9af09fe20c33223378f794ec18f92d56705eb1415cbaac570977cfd445bc46a7884c41ec191b5ffac7fd8251422095a3883d75a27a66a314096bc83a7662a432c61134a33650d16acde5b1dde38b31c65263d8906992d1a47f780ed26b7a79dd6961226d3fa003cde86b8bd917f7b9f82d916ee0e06e6259b3d7031c4c9df1c042ef274080e4e722b3290f55dfe4ea677b517c088c152befaad7e0c60f687a84c0f553bd22a74f70ae5f4e0654b707efc0c37e662f6f1fdfc9a330f463454962358e2c1b552d7593866cee77c74e53e4b63ea150431fdb3e76f553cffd0ed33ba43829e0735674ad643da787292398f592d449f8ee5f1b316af3fc735a0454be8cd2386dc0bfcc1a1731c83450fba314223e8d1c8d6c42e69252b424259a4b9767f839586e43e2fb0f9eb2befa7ec57383f1b68c24f4d72c9fa655d1bd12fcb8c4d1809611397d4d7c695c13aae153929631c47a7e1002929fb28fed99a5edae3d945777b7d44a91f5e3ce8da8cd27596eb3e99dc46913125a74669779386902ae9d796e34a15a06906ea604db871e475b0f0b25d181fc583397b20dab5200af63e299ae70599f714741962835fe98ad5e9346799a9dd292cff59d76d6ff05a73990d993bd5372760c0ae332eb13fbfc183568d064664fccccd329f60bcd0e68ce3353de7d49107ff401e8e3ba0730218551748fa32753e33883a8140ee8789f486194bcaa8418354e8491d1e54125ee12a1207db4815f07a53b427512aee1de5bde1ba6ff630e8a9c29e105b730499cf24656c4de8418caf80272dc72a4ac607f8fdf05d7b5dc4fbae66cedad1b1255a32ab6c63f6bcabf66aa898608eb80dc88f6c6b401a14c61a8b6dd95a8fe7acf16db13bf8f93e2af240c2ace2bb5c96b1de52f4423b28f5ac8e3723ca78f7efcfb12f233e8f17355c9e8cc22923b367eaa2169185d2bb9e1851b7b2c038b9ec302960e3af6e6b2af71fd3c4f84e639ded821395352e3427fb015deed324361cf2a87d78642517ae20f2e181027258ac5aba9588eced7860608bf96c3753ace696f88ed5279b7c9a685e954facf83a501be12f3659917468ebd842f7a003ef36862ecaa0cdc9d414b6c3fb9b1a01847284f3b2ad340ce25f9ea944c868513612b880296da4674a844ac79616fe24af5db12a19156e40b2d0e43a62273324baea4860ff0ed730d684e466e3dd8db4e7520f4f7b1f24a5a47217c1ffaa07c31f27979d22ca5663b101bf0278f231b6d52bf3ea188f6cd4fc64b3745b253572d4a2efd906f7e2800d19466f670916e515cbce0c30598e217dd34666b3d11ad10595fc38315da41bd01ae97714b31052b26dab56a8d5e4c58246a71051e503602c211c2252c8d98ef9cc1057d60f8715c872e0ffa795d42f11748a1d6f17507b1af0d5058f6439e50be8306e342288bd719c7e881963e11d697728b72e32570734d4bc0866bb4f8a82a82bfb159056006bd5d7feea31c04a367dd86b335df05cc4d6f4ef4b5a00d3cc634021e61ddbe4f151d38ddd62d9ea4b06468cbbdebf39065576e27b2a91c771d9e6952e95d05db09750ce8583e6fbb7df50919649eea9acdb6d0f575f1d079db7b5b3bd53a353443ffeb8dc4fa0ce740465efba9e14772c3c2ae0cc48d74215507cf12dd2487d6b273c67aac0afb494b1f13711c1653ea07ef2ef19cca2f7bff45fb280c10f6700bad2fd614fb8b2758330472e440a6fb5fbaf45ca93cfee4f3e94e2941ca7ced43bdcf6bf5f804b4028800963a8a1e78158b2d8bcfa343b071c253e5b1e1ffe0161211f5bb5b8e8e496ea4caec0bee63749bac82a49d2acc59bc5f8163db1d0f84a9be87c8ffba63120b4a90dbefa8d84ef6e7a9f32737d9b37235b9b3b95f1a4e568431ef70b086a56f52747dde67587983e8f93af3b60a274ff6d4cfd2834e7d148314f9e439462d4249455bbd59604d247ff52c85f965853a08d13df7dcafdc6d6bed230650623cf6a4cb94bd5edb28e05022312b7a423fddd02d53e8ff1f79eecfc79e8ddf4d449525a859ba86ceea208c21e1bc6569ea6f68d6be1e397528a9a1c90eaed8d71e1714576fe78c3a79ff58ae8d2e26d6c11ba68ffce084d700cc086b0c4ed16d874ae43db0cfaab63ea056b8b6f3dde422eb276be1a90393dc440b24a412c4699e4dfb168aa35cbaa79fb7889331fdae0e4a38cc16df24d5db75b395d839b6c368969c057ed7f0e4a38ecf6090c15a71ad16b3a695d70177e0f9a8781b454e0f4d8b3f1aa212fdd2297f2349ca037b1ac8414cc22f32a30c12796d27d673a5e498abcf15206d123bb1a04fd89381ee8a4dffd9f6067c2aee5d8daf6ee60ddeb2fa4799c8b5fe4a1cb9ec5391f45ff2a4cf86848813271ad5f0b6656a1c7e488207cbe47f32bd8ac241e3191926a2bc030464fd04a1d035f5bd60a39abc3c215bb7918293ffaa8d454f5745eb183c1e1645572045d0d7b42dfdf45907fe8931dde753c94a93551df16c4ba266edf4646311c69f801344c10ca901783e91f8dc13d61cc9fefda307b626dec1017b19a7f48abb9eb3b2fb7ce4026d183413c865b9a8d3b4955ef5b05c8c469838ccfee237f6785af0494a071e09bab3909a0f72ebe653c4316c8f5bb3b5e02d4ca0549c353f96459947b73c4c075d85c52eb81bcafc151134f15c7e5b394ab53dea47e19c74b236ea702c2b3d072097534c47159aba672f824afcc42ab68e98864f75e1fc46b48ca95c6c746e5797240e6579adc9d4348653e91d934d4c644fefaaab807e8c9a6a54f5d818d60ba648c55cacbba7625fa7a9d432257a2278108f8b7e8f93bfdc6c9bfd8964e67a1227b20c1abfb261a82afd236ba88cdfcaaf6eb3a8935c7e5b7a8f86b3f810bf2a0432c0e2ba252f28cd968504e4d5311d3c81993e4af90ce19270785c2bd23979fcd9b9e798cf1357d782bce84d3f4a6c2da5e8b04d93cd31bdaa0e65377b0b894eb1ac751d51b3a50b0b1c9ca4285d7e3629ff9e89b5cdac762f59ddf6869dba686c41bfb5949ba59f29107c688c267f0be06f79666e397c4604bcab214219282dd79527abb2bdc10176964dce895facaf2681f4d6cde35556916e834af5ef991d39b95c857bec866da2be1b05ec4c121c61ae4ab18bc2cb32f5fb2a148c518b61623042a5915f7c90bf2e66e9a730585159244ffe05702c1565c31259eab73ed83c75ab6252358cc121a19f7f92d59c269d48502852aaf3586b7a3b3fbd5de2a83073e636ceebfb8cf163fccfc30963676f2eca33cfd4cafea7a66c729bc0c402680b16beb6e7f49627d790fd321b8e122123e96b8272195f9125bbfeb42599ff01915c9978f19c16f2f1bfb219626eccaf24dc2c8bb0256e95a45f852812ccd9904fd67baeb4be6b48bdf93c96b6ddd55664f7b525dbc433e628ddc550d3e7e8d30164ecb9420291bfd6c9f1d4f56b1a58caa62d08e69b582e8977b502f608167a584586958db56c88ef35b7c2809b27a370304160e6efea64f2f99ec1cf62badd7783c2e3ef2442df4e6cc9ebbb2d1f2825470a5b9606bdf963cd0464f5d31917792b94d4a383c5194cc217b3907ff694ec6c24ecd416ff9d2f5f3f81c38aeb76e95861bb496494efd602d37fedf594f37b251c7c22c9f6fe7ed71145d8b9a2764810231666c1148fef0c07d8417aa31fbdf8a1412648f6e2cc1faff3975c69708ae9b555e195fc8e2cc259a003071f5351452b4c2ae1f43a6839e97da80bfffc998aa5ee880504d3364549e22b44001908e3eab19d346be5f6e3840275e1eda9d1f1fc18891584084c88838bb7338acd6a954be690f65411ee93ebfeae6ec7d68290e52cf9f40376be2b319228ee1174324e56f9393f7a6a1ab9b53ec6be5bec72351fb951d5f67673ac4dcb026f5112ce3fae63736b627a1c55c74e736c1ccd58c79a47eb522c2364e266894f7197f1e0bf0c0e3c8d92f3e6e1f85532c61d5262cfc143896db54f1ecf5dcb1d5c661ebff96676376cf9ee408886bac00268e4b0d3349dcf10404d44bc025cfb3e543ff77027302816ab7d45a6bfe8a2858ac6d6810a91c42c2b860baaa6c480de3d64c55325807aff4d53e6a5b0e49e33a36e5ea9d97a555ed564bd0dfc5dc5d01ebf9b9d4380bcb3dbb76523c10d40d74b65440618aed227e8b837e0e01be5a92050a209e2091f169761dc6380a056951f7a78db971f6fb9a1286afcebe98438b36e33d589a1fa315a52b41b1a107471cac2605d2e16c5495f19ddcdd78f45d2bfc15d5280c1479b9d552e852d4671e2d4c553eccc304efee9e0294f241e53b049a9634a292c235fdb46dec60035e8769d661f1f97cfec6348ff7c588ad4d95b0d543b30636251842fda2aaa4aedb88932a4839dbf5462771697173e1a4d8a2af1bb0f2347f5b81b583bcfa10c968506fe00b6ca35c1d93da658d0be1f781acb588cc0c0f62de1e076795d20373a353e7575de3f6ee85ded6a9a9142259ec2e1ad855ec861717a6a3660b63e125d73cb3e249a16d0d55ea57067d768b02ec0b4af49b18c2dd9d5ea341193b2a4ab2f8780a27903910530b7e2e233e7919bd5e85b9cb43628b66980d66aff1493ee1b8d478b81400ac28b7ee27dccb7e2e1c54d820d14d8f1135016e10bd978319530503c41a947d04d0bca3023dc9708abdaba55afb54dc5e0c8d4838d5751c1cf27bf14365e5d1782b1d36baa2fd65b2162fb8bf62df28a0fb221ac5f7ea81534017976cb02eb2e3060c9e39aa77148ad2ccbde2047209fe51631ca8daba5175580113be568a91de461e54784ba8704d10fe3ff868285f6a89d2567940d64e58aab6548915a9ba89ddf16aef9f21236426415520f90448a0e15c12e5a281985664e006fbd13d84eb46c3ab7896cf92132877af98ed7e7351cf1a44e51538b66f1778e00d0c52504627ae2d1e45a6b3e6e59ad1447f32371acc7224dc03bd82ce6fa63101c1564b45fe3afddc0819142a4c11731d4326a8f65d09cb9335e8b7a85ef0f90969ac6d995623ab1efbc8b0d9e264f4cd6164b6fc16b7658249104ba862f01bae561dfaf221889448c77bffebaf780f44fd7a8c3b59a94acef7b2e1ceada3a7ce06c79cdde081b82183476994523ef593bdfb960a8836e005b1785471ed318d5d72e432f189a7f00e40acc8d85a17c631c4cdb369ef0ad50fb366c7101422454901149fd721c7f261a20ee8097ea4918677133e5fed05fba06fbd5dbc211f830a6f03f95be3cd37b6437a92e257a61f06955240edab4b44e465d39f18e7035aa329d9fa3148f6f28241e48be115274de0b328ed75652516e19a8d8783d52889eed5c8d55c70e5ae4e33bc2640f79a62416f7e140d9062f0ebefc579deeedbb91b26696ed7a9413dac9093aaedc766b46f2c70339744c0c885bcca3bfa03edf8f44683a454661903d7f94cb0899d872a9bc78fd9d72476dd89f6127504e8379a068014605dd9ac09939ffaa6a39aea4b74c1581901c3e2c6c1955532810bfcebbf247fd9e95c6a81650fe922da70f2e945b5d3bc561199adfd918741e163934742d43165094520a3a0d5c83797c949db54241f6bdbce82e51586fd8cd04fd74c5187083bb830e9ce43b77cfd8a2d90ff7e3698b14765cca29fcf047cd6c5946bc58400ee10aafd28d44bf7ccf51006cf22cb0a6416a4c847c3386c9cd9c62cce75097c17d9f4b39008e3af18f0c2db0b54fa4588997320d607af3b95b056d2ec7d54e241f6be059183b03f226470b4e253b0779f704ac9ee34249323cc2963ba511b14373b8cd35484dc6f1b84c45979d1551d99506fb7b813f70bea0a23c1f94b6018e9fc5564ee1a946afaad90e3aa57c2b47467e8702312ca463ab3683257b5bf37ca8e7243d677ed823cf9d9acdc214f55eea7b584a7ad4f4f6fcfdd08f68ee301034a2c3dc6c06e5c1f483a26ec784412ec38a9f562dbfc4c347d05179997ad31731b62301bec36c036c2de46b205055a6320d2bd69e9a4c8220fe73cbe91cee4e2d3118c0d7cf7d486189a1020224adde4843f5738c3e169e87756a429ee505466436da49f10bbf0524d11e2b7d137827c7fb95b70adb84cce46aac81ba92911dd1918651179beb42b57b2375d2ee16ec827ac9751eb647f36ea4763855827e10cd249a051c404e6937ec7ff4935aa06552d2f5d0e3abe95e3a8b46569cf8adce04e37d985def4b6219b8823d688b601dedcb9ec9647f454967925f4f7bd973a7ce65f558a522d705176381718093543f6a76ee5e81ec09b02a5a4871154218842b13ae5aa143fbd86858555b13ffb0bc46a9343f8b553b7bab314d47860259b2fc74baaebacf561cbdb9dc9b6f15593e1d13600877d9b1f3ed3ffc0e9ad4e77e38a40c2c4aae992ad45577e676746ae779eb8b18c599978947a9aa3c7050e69f279bfcc76d900827dab98b4d94e4b3e773016dee83f9edea147cec0f3a0c6f6ff5d8c67e001800fcd7d9009f7f3335def6abe5190ea9076aac0c1e3887080ef61c000acc76f16ba9d53dc5d05f9ca70be61375bc65640bb4c6addf88d28644c57c004db3a1024de387fa497d1ec4f454836bc4994f6476d7d75f93be40ac06a21bed77589a4e3b00a3fd0470fe98bb15c4e91ab88fa4989a1227e052c3de3cffe7d454285835df372d5fec41c774cec27dcbe790e94b132210353161119f4348fcd41391b34376316a7a000618b9b35c942f3cd1c5b460e755f8369b28be6cfb3122ca4ad7de51e2398ac105b3bd26b2945e50aa9fcf49ff3371624d48317a940df7ef2f62b457bc0466b48dd450957264f1fcb19bda70b0b5e06c73987328474d2ae0a5bbfe822c8fc5e1c9e639a210f2554053eab3c7599e03cfdcee58a189a4b15d955c5b5e694e2357b22427a5740e64bcced75e16a9ac9049616471066f6e7b09f30e278d9118eea607fe2e287fda0f37cbabad79219e9e5f25aca1ecd160d9ecd76512451a4a3c635f4e96695b72ca1c76ba64dff1acebd8ee5e60db4e8a2df329f0e6d08dba9ba740b9dcdba1c0ccf83349958c1b82bd3e89ac1cd00e25aa6fd4e7430b9a1aeb9050bd28a54aa35bfee0286197e8d535603a25afbb6108bc92905f6fe76e9562bf8e500d2170cc0f83a127d26db23885d3468d590229c326f53d3137ec6ccf12d9a1174b5ee1084f8142bcf24cf8bd5a6c86ecc6fd11a9f015cb2e43b1239c2a07348a9f9f84d66f182a8ddfc9c5834cc7084cb178a05cfcd1ad572865a00545755f96ecda89747309d8b41b4b6950bac4c9d34e3409a094eeeb1403490c7fdad62a95033a6dd7dd39f6e50b8d7ac0d804763a6c65dc763e93b3bd5c349b5cb1de15a2269ec92af634f9d01e2031bf28703fb9263580e2dccd83e6a60ecaead2c7b5a7e317fbcaa5a8506dd3e60a439cb3c1f58b407bc3900ce53ca555edbe1bcd61b3446e91e03ee527088098c2880ebbf69302168fa9c6a4b1f1b49b0f1bf7b2ef61719b9207af64b63a77429646833c3b6242bda29c934eeef3fe05207f363b8077c54f8dac053d202aeac2dd91d52d6351cf2d7d28d9a4327e48ce70c13fb05bf4106b7b09c1afe6b2b14cf1701c48deaa5ed14f35a8a8a1b843c28548fd60de382e8774ec079ce861fae85f53108eec364a0c1177013d7271f8c33240151b750a5b6c30b2d10af35ca9f375ea29c1e24439b2a67d61ac072e1b480ae4edb6a98bc99a591e01a3e19c329a131c08e97ec7738be0af7d219a16efd91b39ee8b3f79aec3affba1364f1b8362d309e8d04cf7e7d342bb362c6f7e9d9402d13bf65f3eaa4efaadcc34d6d593a380669f861a2dc7bda0420c41a20ac4ab4370efd9d6b1cad5ca1f2e33e1c83408de9396dd7ce6c2eb86d54c387db958e4fcb15b185f8e8ba70fb6d56f0b44a110bc42b5ed63265ff8757ad4cd604ce917e3028a1efff72b477633b644113a79905f8f1192bfa383eeec556b213dd6a9b4908d835775a067eb9db539b5506ecd2f38d476e9337871d04338bd379a70bc3a24f254b4b45c22fe193664e8d9a106e9e6ac86d7dd408712561c727830599ac12ee3fc2a713ddd9e443943a80f22928d94e34b8227e3c91bfde0263011fa8c71f2019f33bc7cdc1ee194d4e2d75a683f984294d5ac67fcca5ac7e40e5f9eb309f193654bb1d2bd858e7821285c4eb4f66d844b00309d2deef37f3da896d52859caeb75743203df0e0a2206315a141dfffcdb5ef69d7506cd9ad060f566c778c86a9f3cb2b4b65ca641e7015704c374782ecf65ee224fd09e291d58d119fabfcf89e51f901cf0a172368076177263dad6d35d6ae34e9b1e0f0d5d137c8c4d787b78b4579aaab17846afbaf095a0d3ae60ddaeaf144a9643bf9e471a1bb82c30ef3f7c44e1f7a24c2ebb01701503b816b1e0bd438419003cc54fc18336ca3726e00f961e7a02cad8e903632583a3de253aefc27d7bf3098a27a3d34c38cde80917fdc241ff49a9c969f0fbcdecd2b53abdbc4e4803a4e98b64f8b947f3e0f4eff30f54a90cfc54f55497f89f036ab882d315553b6c01c536eb25cda219036cdfe4a2d56ac33051ab86818ebc9d99f11a67a69f17c870e7c2a1e35776c467d93af110581e49374b468d3c9d3c354bfac13910632a6f7a73c260059edfef61e6ae33b4af2c46f2ff992bbdde386911129b5d51f07c7d6e02507285a0eefadb413e583446ed6944e10fd891d1a17aa83514b97abc794f19e47e1a5f68132a60ce7821255756e28c4c453ee5c656d006559b8ab638dd0a88f0fa0b39e2c626b158eae4f4b1c3e73364c6bb50beae74fd0a71df9e345e14dd1dd2efdf94e27bf258530a2b5b012f47de10e27ef990956878911de4c47699344cb6e190bc791961804c92f6a6587a265a62fa9d714e04f0245e7943e81b0799f9a1f313950dd59b158c8c0ca7d707400ff67da298a8b757076e81cd64ff9207d0aea9a6dca5e57b61229fd6056c1bdde63d9b5910d5496017ab947c972cb1843f197cb6d9ad677daea885f1a8b381fe5253b54b41d978370baf651b306e9f4096e0596b6d75dab79c8c89fbb49605497454e26efb4ba67822237c7b13f0dbcb482f1f02fddca266cc570fb3ccd7f80161a26da98a665abd20c1b5fbddfda85b5cbb25f73b02880121120d65a5c8af1b9ffd5424e951bcbdd975be5ec0938e1e259bb10021bb38e51ea38aab4a3a0452234ecb6df9c71c01f10f9df1b0b4d7a0ca9e81d98f4bc28b2565267cab91d356677cb76bf2736b1eafd729022b1e1341441b46db81091a5588f392864aa27e0e6921341e67f8c08c0e678ca5f6fe94b4bf372569b79298dfc79a13e32b926adca4fb10329424d403621bc7ceb2cbf39ba33a342a3cce79f06db803115a9380ff5c074d63ddad866c36842eb51b298927a007031448335cec4dc650459cb0adfebfd0a3afa4b559615245e88a4729f7cb7ffc104547b6c5df2bc3fc0838446225c016fb58e57ef13ef5fb708353c69e06aa9e51af124c9d170c299b27d8f01410ae1df5b73cfa9ac4b7d9172a3b9a28328a17af92a32ab049ada7d8edf21dbd48e82063de4a3ac144b0d17f08d450fd6a4c5285c7cbcd2d4def67f0b7490a59f3312bcc0995757865bc66219d2736cf83a2a925d9bc4d2a6328b335d05b806a8a823deae553f6f6701264c8a1a5900f0a837853f067c41e0fab778c9de61975ab60142c9fd73b15367c0b14a2e82b755a148dc88d0056657ffe49ef21cdc883f3190c35c56b9cd378dd8ef9e106967bc53571b0142cf0c0858b30edc8000da1eb699c5bfde4e9d1f2e7fc3d94a916e3c358b82c25a8fad21fc0bd258645d8600562a4298542f6d7e31e23fd6064542d3b9c06d1c67103a48febbace43eba155a7a447dd840d594e328c49283c07f222d25b512863b7e7210455ec32a1d6959a49456eea316081c41bc916028ce42a4c55a5ed2c901f1a9bd14e452f01731b4ca2df1077c1bef36c753c5da39f459a7b2b465dcfaa2e6e443a4839b5e8672a0be2b75adf2a2c8e9b7cb00c767587e741da626f7541d53fb6c61fb54aad2b047d00f65330ba24d04c37a205bbd19905779aca35764e71e56c2e38b28973cdf2ca184e36ac72686f9d64ec1505a5da11b6fc7884a142cc1946d011439e7d909e21d6a7c64a41bff550fdaff8bcc287a3df9df72cb4dfdf7209bb6a6fccc9326532f0960e35ff20bf4b449ccd9be7408a94eb91ebe5e26b09dd452734e700f9deb3b7b6984c44eb721867f81d3310548fbcf88c085c7fa62ccd388581dab4d966dcb23ae3a1090ffe66ae1030671fceca0362d503b6a8915c4b855b2023ef610cea494614fa1b6027863ee91beed489825742d53d842dbfcca98e68fd520f2dcf9f83dd1b535e7012ee6758ced513b7566c376474caa18d60a002f1778ef90965c0d180575adca068ba87eae9fa7894b43976031780192869cd4131f70f95271596edc57bf2ac526b2678313f9241552579efd7e914b3d26c2f586338a59ae2636ec47f00b1a461e515916168a3816d142b84142be7f14de6ab855b7d30b30e641974478c61d852cd8d385eee8baabe15134ac672cbe85a3a8856fd0125e6d4836c5778e482efe06c3903983f77615e8937e034d18b34aa18f34b0be510588194c122f1b6c746d00de6645eabeda5f1b762d3484463c6bf1c7c1413ff0c59da9d75102c2b95e2347f06f186864348d627a412aa78847e95ca985478f84dc3dac6681d808887319441302b8c9825b094f8cf7388ef929606f21dffdf4d96a9e93e80559d67ec9e8ccb9ee785f213f35387fc47400e25dc4d1bc83d7ed8c355e99b263096d547f5ec23ad3b9d5be03a4a7c04004d514bbb20debae908de4197b792c7fc0787ce90650160fedd90347c63a608e13bd8041931ecf79350a29161f948545f34baed613dbbded887b00b7d98b7eac890c4c5fd1f27e61dc2f2c9ba4bc0c2dc1dafc0bfb499f0e6404b342bb009d102cf71f60f2b51d4e1522a12fa33048b77f9ac9c0a008084e7cbbfd3426510a92b186174de1ec7716b99ba2b5669d52c5c8764861e047d2cfd23b8e0442a03a12613cf10fb573950c0145de4c35186a59d241fba953e8ba0fe1fd9a6bd0596ab210d4f0de5dc886b38e4ada424cc9dfc01a89226db83ab3857fff744db404effa98672a6c3dac49ee67117e4c4a19ebade5b62ec0c7d91727782732f54e21c98d09e7886f00ec42891d1a4b22a39036c05a74de4ae0f4c72d570a0ae9d2f6eb55e0e3d4e52e7fc2d3ad6862f34641623c036cd172d19af7d7dae935d72aeca5a1aa5221287630e363820d6118663d3f5ddbb67452e28c77d3243f6aba8607bcc1a7b81dcde00e3aedea562224a79607acf8c5760b61d4b801ef5f95c593460192d483528263b7667b6782fbf3da5084fd3be320f19e0d2391359f70756e24c8e48934466406c0c1446c98f591064d2963288272cbc89957e5a7ab898efb4cd3e13ac3d7c92141ccc6a6bb8f8118cf2748dfd0646aabd94c8167cf5d00cf12a8276a0d2413dd63e8e405dffb331a16392377cc820f50b66b633d612c090dbde7443a0710328ad3fb79a12f1394c3adb9da4536830e88f3e8ae60fc35211957772e7801302db2dc38d0c87d94bca5130c7e47f04210b3280aabe19c8c0dd450ba130533ef329d515b881585d3f8f9b06433187e251f437cb2046a9b21b5554fa68223d467daeb263c3666c457f373a3ccc88cc9954eb0b821b323828c58c9fb8f1d9092bbf12f8fba061e1ad08a76d281f5ce9f56f5b66c06c2389eaf746f8bbab82210dc82b374a219a4f5fece714337c4ae0441d1643020af7d3953c39527bca5adb181ee458de80929937d0581dae29ee3aad8e654c1a8ea6fbccf4a2679fc6c75bf338f69633d88fcf2d6e2b3923efb864d823efa5a2b8b86f55d233c922d87a7028047702e6a992e7aa143377799be0d4b5f36541c6e8419b765f42942480a51cd5623061ad58df4ba72403966f7e5bd95b4a0d271ca57403cb7552499e013ec7cea6cb6bc3ac16823b925d2ce9eeec1413240b5c511ac27793c4eb7c02e3533dd31accb65252de6c1869f10076c341026ab68a5089948af58650c05c077174fae17959d02a5b19eaa946692b4cda1c0ec6e6aeffaf055e210cf0224385391f69bb76da5c3db9b0cf7cdbc9d8a696931a48ce542b7484cc77c3d1cdd25e8f4a0da7335f3c57c5eb88df6e20cd1c5a5a7d023da65d43cbc6974bf2f854dd09f8ca0dcadb0220bc58d69a5781fc0a1021cb6e357c9a6cb88e4833a6c053c904d9ba29c8324da93d45720e8556d5a0a5ff01ca6e91ea81cc371d1f15dcaacc1e033f09ad0fbdbeccc69bf3fafd15758af2e47dd2842a2cafb7d742baa38858bab449676d91a5b65353ca854bb847cb35679a06ffabc7e7aa86ed70e667195f7f290867f2c4b2ba9ce90bd821e738db9ed8dfd3c8b5548c2bd0cf2c3c17d7add97e631597ef155fd8c9cfabba9b107dc27b647db41c20144533d95e3335b79a77a809afaea900e61bbe1f346875d59524fc1c427e6936d42d1303839720b103cb74f00dfcc878bcddf289ce11d081814748a23293457a38be77c46d09aa56558da1844d381bcf947a5f3de1ad42ff80356eed96975dbc22f67dbc0c7afa786a3800f7a88ff04202b3be1abccc6da3e3fb870218e013fd3e77580adbb4c9139c8caa59d323769ca02c17bc900d1a083d2ab85cf6f90242fa07e0741bd1e4f8450a477f8d87e0c7a1ecd3b453a8a6587958362d1e2150a94c10b4c34cc204f6597b5dce094566bb12df6c8c9fe5c76e0b9d6bbf3acacda43220ebebb6c9f46e586abb7ac2580a3248579f3580a39558c1171f94021aee86846a53f261ff08a62aa5e8d6c2b23605ab87360464d2e9210566b205d66d85cbd64443a541cfe42ce8c0abaf08b7262f8b0764634df90efb70306e8772d15cc630a7f98fe379913786919ee38ec021c0b753a8cec6b1be16a79eded1ec8894a1b2b28ec97690e4cbccb5d2a8c69a8550594c4bcf082770d94edd3f8e5c8ad6d5b6287481977c3607b30a8632c104a1b9f3b56400389ef633f29ffa52a400598696ed856be2f968f47033e7a80f345e1f83b7745b9feb6f433797300389cab06afb8caa6df6963dac2a18eaa46b53bd945f5d8c4f51f782909b0059e3dbfa733095b403313537fcb915632ca28efc1ee5f1190665a841ee876717edf4d257ac7e1bb6ae78459469fe5e03ea183bc15e4c4b3dce6fb65966060a9c246bcbdb1905c109156014b80d8be4ad01325ea6bd2761833b92cf66c4116d56c24a9a3545419fc7cce2d482ca2f0c5609475da49ce90486779204a184191e8cf0863f4862e32d2d09504727c2b49cba72a0162707daaf4677448ed89458558c2d2d48aa02fd8b1f9b8b64ae8dfa84d9bf23d9910d6ee1a8830ae2ec7232012748726c2698633ca1813e6372c37ae974c7e39ab5ef3f1ef451ae65539ba5fb336cb2fe3bc7f0f95f0a59efa4cde2a59409c5025c17f29455ac147f97472d79083fb6909a898a7326828856c710c3ad0414a86dc4e2860d5daa8d0ad47cac91040ccfccab201d136875825e32628c5cd2f6cbf31b3ff70e7e79c3183e6a3c7d07019ce009d8f06dbd80477492ce55d2d2c85a970813121692b589339917f8bff77a8aff019805a05cb1bfe565b024f01b3c52312379ee4f53510f4fbf631f093e62637318485e9fa67552e17f16b16387423a6678ca7a89e30e35fb1e532bfb47977769820166879c1d5c09897ae07737c25be80979f2ec46880a5f37aead6b046f3d2bab11d9f764eba2837dc7700c0d5a699149ba44b5e4c7b30620f015eb6b3f71b9b2ccdbe5c8b32d8f2cb08d2c3136cc69a101b636087139920385b58df4fb0ad1e92f29a9b60e1ed5b8554a398df40688ee4a467b637805e29d589d001de29a39575483a2c11770db1a3e39825199e0ce0135a638896c0e74c0b42eeee635dfdc36b1cf939ebec13a9d9a9c736f9349f51eecc414724ef342d16f7997560ea58f752e89a5a8a7837a61dee83620d12cef7ee44005fbf9899e4a6bc150f43146a4360772205d9c35c1d9a493bf5de49ec2cd644515631ea2233962c5404e035657517caf15df8b90d84de868c366371d11ace09e04cec6fe2ec007a15b757d4fe7d056b98a741bc05f5988e00a3f51cf2030231002c572c8e5937564137f4056b0713ac74107c70d686c202edb2e2afcfd6149323ab4bef9337deabaa104ae5cf527c8a5e2a4919f224a2e05f93f902561bc8c69136b9c88efdbd83a1fa215411899901d1b00462cb88b884be8c09b7b62b2ddb8b69e1b4ea51f4539d67af1b3e2a2d65549ee46c7dd1925349ac5339aa7274e7ef465c2ee724e743a60b032f929cf21dd65ebef253cb62f7cb0a5a2c2a4f34b62abbd7545b783ea5926ee9dd687e4a0412e938500497470c4d97b3a03bf64ab039704f212516ab943cee137411b585c630429b670c43b024190a609ff98ba812ad381d3f399c51e99f6bbc19b43d438ea9114aa6fa6465939b1499f4798aacf8b6fda2edf49eb72da66b0459811b7c989025ca4d5eaa69912f9cbdf7abddcfb67279bb9aff54467308079b30eb995f3fc9231337d54be3dde6c59e9963d6d1d8eafb68279e9ce94ae4dd48c5aa7b35ee34564f06bf2c50ca71f5f0836e76e168e14fe3aaeb59b5ae90b01a211028db9eacaecd122ec4761f68e13bca442627e2352aa0d52e4510cf96046de253a51cbed07630a78dca4bf4b07eaca0388c45c23a4d908c3f1a87044c76d24c40f6156f33e87799ccc90bc801e2167e8fa7fb376100816d5d2f08facde413b82dbd5ca367fb9ac2eb39133535735632cf774d9eb509d82440888d2f37015caad31f7c8a4ea816f7d3584cd8f6e6b76e0fef8a4e8926018c17d686f7af73c65cefcc573755c08ec5b4b19d796a7499192655366477afcc51339982aaa5992aaacfc7293ce289c5b2950526735ab1b425ac942b2e87383d7202cb663ab6cf16d702fe58797003047eefd08d60c316f295d6675fcc3abe7bec85275743d76bdf5a70a380be97fd957b1c9668202b9997ebd75120281e9826ce9a3185fcc9559474a923ac4c29052b7651a6ce9710f30a424353004e42d8f370243fbcc1d80b083064ceea8f096790015de6d0c1b348fcc5be85dd2962aae563cce0b5d2f6bad5372c50a314a4dd0bf26139127078155aea42219a5189564e8d99a48422061c264e9e37958b557fc83e7f554b8dd9be548c4e958c8dee4988b4d304a32407265f52f7dd97197d04a7eb1a405d463d1e7b8f1d00416f04318887c58b9a39d678f712ac8fec89d8325b3583748ce1ff8c51c1bfe794085581287eda9d45cada83b1f3c0d6d15081ba1babc78952f5bdc2f89322808ed77159bdbe586eb51e5ffedda1e9ee2bcde3ff410a2abb6fbfc84970d7501749e8aee2c5bb72ae5d364cb28e44585cae5be90f7f634064d48f655b6c8dd2c776fd3a41fc6c084bb0e04f0f7b91d8dca59265ea9e2d7d94c233b32050d37d23e9dd35e36c0e24efbd764966507bb373638694eac7f1faf7ac9814445957b20e9e105e715596b0346cdde5205a0caff9a78bb66c63f1ef8f52c4203f8c879920d9fedbac324ba14d2c260da6a8cd4c3353df879627b615dabcbaf59e510eb9531d8f00b2de41e0fe881a1cfb026248d79f510a90c224214dfd5a79c983b714954fd86f2a3bdb41b67d73985f246e7fb8d504e74f9fa6a1faba4cd17dff12b62658586db59053cb13ff281cad17f5682cbffccd77d75b6d478804f8c4e3bd8edca589ba6e895341ef7114cfaf46af8404249e0109209c68587b70df0bc12ac92da0b3004cab8bafd2985d68b820552c6346a44f55828f5b26b041e19c40a602263e95360e19ee89600f88e57a91c962c99c94a388fbc89c28d44e5c6450219d224cd670ff068be9cc012819a1bca25109bfa69951e3b44d0a77e41a7e3e8232d54ce9b8020c0d2c23f688a848c00f4a1188fdb9a9043b1cb4a397e8b8393b5e41aba87f17dfe4d2164b4adc635281ea924ba31ba92d0dec558210dfed3a020f3125e687d77e7f170af6a1f2854cb4b9f84c20e5877f856018a003dcfbf6d3325cea2cb6962f02fbeb194e5a1aa52a733334568cfb43d8211eb0369fcfd19b0005376b541f61890508f0025e2fbd18168e14700c0646fd3185a525a8a839c102b988687a7cf53ea2983bf756192e4f32f6f1bfe8ac4195fff0df3d5880be808e80acc35c5ee7e34af5bf4d865ba990de4740ed193b886c04d0904917a961f79030be491e936ece6c2f8f1296846716737bbefc6b6454e6e32aa4005cae6dac17e6e3bb730f07939d7d1a924520a682643c360006a1577e01922d8dfc8027baca5fd08e20c473bbb446d6a5bf45f14c5273df8ac28f6262a2cf29304f5b68e59c3f4173b24cdb00680ecedb5e4a3d2334e9234b91b5be3e8f4724e5fe31047e78b8362623ff590949f7fb853afb70122b75b3e586ed961ab744fb9fd3de4fbc1734f7cc2f39620ef00ecc6ebe47f4f82eee77a1360abe831dd07742bb849c0d099f1ccf64b6e1bc8c20b8d031b65159c29b8ee49f12f3f2a446f728ab81a07f09d759aceef9d2cb3374b449763d7c43bce067049fa672e49aa2eb361be77576cb9dde3b63426f7866b2e8a0d1bc563d4213aa96b987991e3ce3f469c3441116fb39c0b950e71aea653c84e902c2419a42774ebe01f30f6686a73a3327aa1418fd71c525c10cc3eb648441325166dc92dc507d1122c78cd6194ec50f8648187f8e83820e88ae5057bf65f781e071ec3991cf7afc8fbe52bd34ba4d907691108da28c221e55f511beb04eb1cc16c387bcfac82dc77012d1a2a53e41347dc44730febfe2fd34d0929ad5b4ecc3522bf595a2f94bb6973a97510d3cdb7bd82501836e0250c6a51e8d38a0700fd22423e966b5c51a5a1b2d960cd81d245b8ad320aa030e4e9ea372eb49777109f874940248bb58f97ac92dd43135f3c3df1bc2854d7bfdac928a500de0efea03ab1d4d8afc93759b8c4e7fc5c5d6ea5a23abe343ea3741da4519fe5f9283f645e67c01aaa855e6da8f24321e13e3c7dd6613da0a1c12db662c2294aed6c7e285ea6e29f651530bfa5167759ac456589bb4713754dc61f20ac6f9700133d89476183df0543e825f47d0339568252c75e2d6728027bd2b4cd7dad04b903a35334c113d86dedf0a1e8501560efde8880eac643ac5b5216aba1965fd78eee9b3af5b771d2fba66a4b2823ee299e563861ecf87a38d77e4e1b75b1dc3b7c816745a25e38c35aa54b1d7940426700876100777071b392d3af44958f0e54e2619badebfb1012357ef6284f6edece5997b83473cdd68be9fff27743d398350435fd6b90a22b4cbfa3fc0f57ee51570d49474e1ca979130054723f32aa10e38b386586e61fbd782cf10300ed50e6392898100f81ec25553f958bee0b488f23036b2b61593adc2c3647218ca617cf2cd7eb570b067787bed1e2b716eb30297b5c44e164e43f580d99383a17c827bb75edd66dcce3144b5c24aa0bfde353148e6afe59df9ae462e696c63fa3cd0c32b15f6824cba2c5f7336bab100f77f586e7656d4325217127e2742d54c1e40a678ec80b4d19a4523a7c1f0e2c82206a99746a68d19f3241a9b0fbc02d0f70016c4ae6f9e15b9d359d117a8502bdcaa0b402f7c13da01b9283a4f7d84826871dee681b39bd8914cfe68afa848ce6567d57b873d01e893da164e1bbcdba21745ce603ed2dffbce4ec97bde484ccfa19033dcea486d61b8d1a5eba9b04b8e735dee70e86bb8647bea04458bf5659115b4f2dc6361c9c7e17d76447700c1f34fd07f61534f41c25a566c175d5892e16da6303fc3b46e2dd76eb990a18ca9af9b3760c53ea5936d8709b5eb1b5df741144c1b1b4a6ff1b625e063737f4b42d0f72c1c270beae6bb84b43ac51b3d0343fc0d14fbecfe12191131f38cd69233848070cb6f369550cbc36208094672025a466237a4bf20cba18ef731c465fa74b057669a20fca416cd0851838042a820781c2728ff3afa0046ee0d85800c57a5d04760e56a06379cfe65eed72039c4d4502558594a88bc4cea3e75555f00bfc29b7f053e819da2315f63e41b9692143becd14d4c8026e400e589a15105fa63adbae8389de86792b845374eed0205f60fb9ce705367924a5079fa2a3bfa78f9344bc03982816af6d5befa5adb42fc1c437e62b3ac4fddc04e1603e7b0ef7c55d453cf6731f4e8d7b0734460c6a85f7a5f1b231239dfaac3ba3b4bfe5c907c6a624a81660efb44aea1f8125b32f237454f526bdf0e7dd0ac8eb610a291eba1afff7e9d1ff17a2c0338e7de1fcbdfaef4f14e7870a28385433d1d81906ba2bc8566725cc39ecf7ec2680c66ddc93f2e26bfa82bd9ac8f04a0abc9d7a8773a8dfe95f9d5cea3bb771e807d391138a070e04d3417fe89e3b8f65365dce1f4864ef3c881f0b6691ba16838b3e69b92670f540b03562826dc92b02f4994b18d2708d2987e619ccac694408660ee4106bfb5f6ce645ee38b2240bea942d3b4f8dc9d3fa6f34f92827e189405cf146af15a2d655cdf420e9484b80ace4a27b4685a3dd99e5fecf6867dd17ecc6e9a6f2926629c79901e916ad5cbc2698c6fd8146664dcac6e6f91953b34593944d71c8152ded0841abac57e4a358dccba946362dd5c776755d83ff64c40de78489e5c3922af7769845c48c5b5bd1dfc4b7f0466bf9760d0b4ab17313278db13f9f978497e6e3242306fced4048064bb66e29955f4e85ec0bb9799ab0af865629e8ee6c389190923f6a15e424b2bc478dc1339e188ba7de6b2106642e21e0e31641a5a88e9ba270a75c43b3eb4a1aa80527e2691c2590a7f591365f701024b243654d838016ff74734cb0f559522d0f89e021c9cf517aa067aa1d5c15f000952ae9c80ece58533f15bcf8e5c59f65a99a116de416dda164d79b80dee2cdc79b24f8cf199cd28c4df96aac79b7431675d1d6581a09a5c78d2e8c5b603c86ee61efb16e76f7c15e00c320cf4b8122f91aa3a9082ed2ebb180d2a05c64509590ef7cc783900ab1bfaf544d5c571c40a8568104b5c51afaa749c9a46558e538eb29afc04254ff436ccf1525bd81d07425ef0b692e3992bdf888edb60e48f048e1d3e026b364c7e16323299d55f573e9533f59a055b07328746f03ad205f5f08781e5eaa32a24430670485aff84b4b097c4e974b9e912018f0cac0e01b3cc2325bc92e3bef008c3180b41f9b6e89d48ec97887a194402a72c6221aecb112bab656d3d3f76caf3c0d78c3a168f4e506f0cda79683552c65f852e46672499e5be0ddbadac6028d25365e8350d8ba68d1b5fb1a94eb112edf0d769f2e747de4ec31864e686a5cf0b2a9078d22026552e2392bc048118e37d3471753b1d39cc7a8cc8a0d1ddff9bdde7b8854305d8f5701dd191c718da751f42e9dc97ca0296972164818f5e1aece9cbfbdcdf29742ab8607e6c2db2dc8eaa9067705a178595ca23cc3b0058b22a6fd20c62002a781d9b82c9560ae24747517c995bd55ce99a8574f1f4b3a0551798133846e46b4c0711b998f5113bbc05609c8ece92229079cf6f3272e738d0a85558c20a5cc246781f80a20cbd1b5d524218cf65fde89f46dbf18caa3a70d71b4753d8564b1bf52deaef3f79392287135db9c2f7f10f168b1a6a69ab9edda7d97ec2be1f2d31c53418fc7aa4cd38a667c47d599ed91a79e97d9e94c9189577ba9ab08284143e6af3052f13048ca7f1aba8fca396474518302984c3a41667c89e7b56891ff96239dba70d565f4bce806faa492978b88033b674e0be4449a971cb7969617c2a6bacbffe9d089d28a873761aeea42e8128c9d8019bc6a7dd9df7b1c5f3cf934518dd88d3f46c1ff6eadd04c13564ad781dfb2d11ddf14c2f6d64141a3f23a614520db89b29a954d3a3086c03a50c49a362239f85c30cb00d7d7df4a321622010083dbaa0b7d70ea872622255a144a76b31826cff21e9dee779617818203bbe46e45540478ee249aaeb90357edcf78dbc0df1f61e4a03c48ecca82c40bfc5466eca3b8a0444d637e70b29904b24d70a65baefeaaea9580a26fba0b550a8702ef84b6eceb8210476fab43eb5c4048576a7e0b522ee30ee0caf3d372e863141a8bb85cc7eddffacbe38bfc120e9b9cd6cd1752dd53d01afdb7c91fcb10a905b98e2ad39654384a4f6a04babc9350869af7bf95179e932d180a48d4fcf26c063c4af15c9b4fb3d018b18be5aad507e8d30afffaa9abcbcf971b91fb424d6dcac8ce772e89396ef3cd1e634d32169264b9b3365ef409800a84a1dab8accd44ddc3c223d40a130342fbfae768bd30dcb503c480b488d784ec0ddcd8659fb8a12c584631a339cd73b99226b1e94a2859406edf14eaad36c09a05572f7350df3a5bf8e7765f286444cc67647b10ea05c05a3c380722dd8fbb97623a09b14de6fcb7d4a803255cc9cdf8b031265b42073723b25b722347a42a52bd2a3b67f5db29ea6411c9d04c9e130e8b2e43c70c1d4604980e5e704e705295d5b9906efb1e6500e355c397e5bea63e7716fa1296b92a3dbd39f5fa08de79290c67274fe794e595d08a5138099c5ec8d848431c41ef66da71e6dcadc047cecde82ff9419430482e6ee9af350b66f34677e1babc03dfa58c094bbe0475ca65b894b0f8d5b3c8bcbd4424c6d93407c3be00618e46e6764fb55fe755c2596849f45cd460e3473e87909fcbbb4d42ee4a0c83e54615878065d150b1996952fbb04834161a6a28f30e6a0bc204f6e4a820acf4f2717b97ff83243c51c87f7cf7dacf325157f28090f6c0dec0d7623f4e73beabcb6ab45ee01e27886e73c5a4fd29071021cc08501df672adec40926cb95fc0e558c66733f656c41f0cd784cf3d72edabd21e7aec647128d57942f5f793a1b441a323ba054a00e5edf40fccb1a9a0b786e477037bad04e5f360b5a561306b5c43db62ddd5b8b31e633803ea37f725bf4817514878be81ef6c23dc7ea0346eb0d4f1849039e2059ff6b608cdfe72cf90390ee6ff34371751e69fd9569a145f01c0c0b505db663d94a0beaaf2d9a2f76dc97fe87651359ca8cdf67d6bad5c7d0636c34233f87622665eb70c704eb838250af659b4484b3af4cf7e1b312acceaa74c5e80aae2b0c10ab0dfca3a1ad30ae3311fadcae4c6ef4060c95516d53fdb8179b9dfad7e4f3ca41b196542a913f87d19ae9020c547a4e437b71c7c676ce7f41927b765c7a8ff5daac4861a9e7d50cdbfca05c7dfa5c904cf9c45150c690c17ed1c7fc149fcfd3069afbdee51aa87ccc712a444f827c3b0e776741de609220098bc85c9a691c2cfe90e72384c4ba6a8f6292d982d0a8dc4032f475b880ad2bb23ec5ae315277b7cc08d3138ce7c7958b5dad1966d545e1de8eff4ad7b085aa279fe76d1deaf50f405689f8348e8690b95c6ca34fc003f67248ad3fabc4da2f8ecebdd04df62a9ecd8979b11e2b6248ec5a626b9f272ccef83e874ab3c6b737fae1ac12d0a192ed8d811730ef75380bf9e1cf057ba3ca6779b944e915fa3d40859b761d6e5fbaccaab112b6a94ff465318120d3093363df1424b1df07e24dd41689db5390884335c7a763983fd30d16b52aa793412e5fe7812a176a46513829ebbcf9075a3c7f95c722f3c8829c999060ec2c01a9e2f1798ecb63ad8d5652bbc178155aef518f90444b8812b411536d33200d402f366421071fed77a038d199fa4ac6cb8d6f4470ba5a5740b25a15bcf4876a52ea09b69048b0e93bf17f0e5e56d3e09622e4195bacf413cc3e6d9ddedfed024ca8944034fe2874438ae36a86de4cbf7857bdb5ca9fe3824ef4d80cd21a71882766535723c68093fbf59638ae85bdc7ca64f77af35f4559d9053eb2362b901d80541e5dcacce344f471cbed5978bc183edd0cca745764ee925a71aa49d4dcd9f96fb0437d60cc307d5ef8ec2b11100a0153717e716cd9fc3792b99db21a3b99008c765777cdda8cb5841a894faec47a3ed51e3b218467b99a7772f6dab9b02cd96ae2f347b404b48dd70c1cebf01fdc9de012e8ee5b2c2221155660f313c727e3d0a681fe9f9c3518251a186b3974fc01bbcd26772e7146e0a43d9e87d308144730cc81df30d365308af18241ddbe401e50b4ab8723deab1d1f45834db460716a936e3f1c94a32c544c4cc14745d0f569d0db828c211c17400cfdd565cf07b78f5e19db5a2bc2b5cb4c1d13ec092976a3ff24a9d5d455ade036f4ad1dbc2c62e4ab9f39bd739fce0834c153c0b5014cf2381e9bc16be05445221feb75af99fc1953b0eb5abd778e5d4fd98a8c454d3d2ec933150b6e5fe410469379a3ff280833c3eabae117016c7b7e07c0d3bbf5107dc95c611b327d9f32f7d4603e5ae24f26667d3ca1a259eb150f6d93232954469cb0af0c9fb75fc1de5c88fff02559897bdb3e08660d8f193e1b36ce22e3d3172820788cf94c5315af1695e4fc2afdbcc4cf1d4acd0b0e038ff810f654704969425b63948f28f3f99a3b18631b3ac1100754500c9c0990bf60b3c0545279aa2e40cd30fc20950968b9ea9d8ef74de4060fea7f73d13c1d9a22eb5131f7c9280ef643253000f0a0dc36989629796faa310a162db70851d7dc9602f6e8c30e72b039b37b915b1c2ad9fd94283861c5b8a459595edc7f3e20644dbe56f6fb172db68bc5ce2257601925996f6ccba217fc8ec08b578757d0c8cb71c82262df975f9539eaf28688554cfb9027ab7083f88b8c3aa090649f7da599f01a7ac9d4313ac87da51be45c8cc735483db22a7bdbbcafcd42de4000a4f3adae96854bd1cd5edf46af81badcc7f9255afd6a9b81d04a6d64390fdd5adb3c8ebb3cfa168f32636d3f46dbff43b056033445ec4bc2471d8c6aef6fe3b7211d6636a5815ad78d8b1f5a10f3ae70afb5ed7cd19ba127bb3171a0df6cd0f26b7dd1ddc74c678db9e0b5fbd4f8fd2c0849c10d5e464f8daa0112cc97c4fae01b8894afc06ceb25f8fc4552632e3b454c3fc600e4bc3aef6b3cc98a7497ead696d4775d3e88006e7aa1c7b13d278e02862977773125bae868a9809b26ed131beefebf7fe677aebc04c8ba68ddd00b19e0e24ea69af6b1564678e7f07d5f219709f688e38c376b47ebbc7878014382c95f876ff19ccf0b92eb0a13d0eb8c57ac29f8ffc23b1fdae979f61513dced5a7e6550d9de0ca7489c17040b42528bd253457e8f7acd9dc9d6083e9edd172cacea2dfa9a95739b320a3d38310a18782338af093c7935772183959a981a500ce9f53530177c8610bc5b3aef050850eecccd9dc414c633ec798d8f3ec3a61893e3f15f17604fcbdc22995f4c701404843acbc4c3462ef107a42548bdab24ab24eb6a9ffe82c457b17abab42e7024e95db1011b854cfa64779accd3cdb60db3684f9fa468d1151fd22e9235439f993a8f81e435b582f78d08d37ba8693e28e6186d0ae93dd53c25a8cec1a8db64dfc0905e622b5f48fc58bb5bb59ce6b1a98953c79893794f0dbdd0a3fe274f5dbc8941887b70724afe6cc4d9642dba8666bc93c205d88b8cd8885b8a15c314bb2e8f9ce3555da790d06dd0d63e05a1473d2058a882d5ebb4ddd84344b9b147c858c3a6e0d79798746b97ad1e9615c35678ce7a27c0097a379c8c195d7360ffcb9262f5df4927250619153330bdad318735321e0e28c934a940a562d545a37bf24fe05ea07f318cf0a048df7b54618aafc7ef8228f9bb8a828af1219111a479ae57cbb604a850489ec7a41462fc8689bef5fc7d32b76ef31e538f7a5227b1c33fd6ea4718de39033910afcb5379262def1e27a30d4312542d665bd82bc833a818076e7e7d28a5b68894e3e26d7078aac7efa13eb39fccb99d1f24ec2d0c745de8b1502b09daec869c22cfb69d901ca1f2ad1291870d357ea240d48ae9c2889a657d0432eed397ef740ce1dc24577ec5a8fca646db539c172d9317e690de9736910144ee5dc0ae932b2efff275b9e2142abe702d0d78707ac1e12776226cc16aa54c19a6c225bb79384c8f367db237dc3a53955330b7aa905aeb4ed95d3ada82f7a73f3b6e3945dec7a2bbe0baf4578af4bac43c74d742db2397450a1d1e902e6fcdff9a89f88907eeb2f17152c756e21bb97c576b3c49c8338ab41a595ef224eb9f3a0ff2216cc1f1da72b8889a42078043768b632db03d8a0d517f85e95ac7ed4a5af86c3dfd16d74dd1cc6498a32dec157cfa2cc07f49564b15da8dc1765b473d2419f5b8c201363ab7db7a5f4ab62e7542e6f2ad10239c06e52cf1037b772a5d14616c071821b4ba6d8c642be77a14db5d1230a5f48eeae5167b35b8c31341ee9034baa3e8258c85528abbd14e8fbb89493ac14c5e3c0153ec5bad80804abaa298ea55060eed511ae5f02d48831615f546837f73373d67788c52d7786869179c3535d276d595e65b4e1bb36cfeaa62eeed3e2d9379ebb450d75c97879b30a9f5e928f83d39c0faf1e07534f308f7155ac70bc8d348dc019011a22401ba792738fdea51a6851ffdef39ed9816401add0f46c0f0c416e657324a8d598da257fb0109f0c983557ef9eae65d2b5010395ff4e0703215df0d6c3054c8ee37813106c079139c31b51125a2892db2faebe4d80c719895bbdca7addc4e3d4cffefc0f57374302f06126e0c89e4e2906043d0cd75c8b9c9c92348c185b80b38d9e8d04deb79942b35d82fa727a34d0b96ff2cea12dd9cfdf436bc8bec3ea27a1ac18ef0f6d4bd315b45421d918d6dfbe5b2fa65ab7972b178a322b90801b66c113149d6c4164d0bf884e3739c1384dfda9ae8cea92e95c343f4cbb72dec2ea6d0b9a88fcdfc32fd62369561e1753ad94d30ad08ec20934b9fa03679f0ec25d2364ea4854789da784345ef42ed294bf6c064309d3d2c47269c7a4f0dda0b1445a6fe49265e8f9e46ddb2d17eb3e5ac85c3f3ea5a1c6fdeaf75601eba12b5a85b96490c93f8232127c159a994c107bbbf3ae43fdac0429edc819edc51af73bb82629961e228679adcbf4ab7f7b56bf362bae7dffb242d206248ac3ea8850084b9e87c642815351afaa522c5b0803644c8f277e675db915116fcbe0e869c32673fd3e92a6e2451101e64a2bc05e3f991da5a0b886c0c1238f4c7725b24dd631f027c38f4aaf2c6643dfdd7cc961fe03459afe059dba5bc35cb71376e76611769e3333f81f604fcee4248c35ad649e3a1187b81fc1b502cfac75363d35280579d983d12bf9a5f91d88869b3361f1244d8fcd6829598ea4b2577dcbe7bf80bf71aefe3d290a6f9dfcbadffa944f0f9a3a655f962423a084f179234d66a0899ec7dec5cd1af9ebb265fc12673b1bfc4c777cf41d7bcd3b539f6231fead70b6b79bb21d9fc77ef6a02913ef88507488586c7c7cda781f07c8e6d1385f37e8da1a3f9b6b731f977b226ab4f840bdfc8a91f614550bccb1099c8587c12981889710b9a576ecb241cbcf217a523bb23c1b26e6180f7e0b3768d64d212a158c59ff1345bd538539d2efac99293d3321a786988068ccb02d5410fda349568a5cb688afd1bda7820cd16ee0f249ea0242ae316dfdab80f90f09d7e0023684347b299b9580562921aa6b15009f0a9bb911e8d6d609de9e3df0a8cb6a7675e30e76594c4528bc8c7c3575b2b3e8794577cb42d6e845a6fdecf462c106210fc7275f051e4cd42b4304f3f6dfc7690b3aba7549865bc683fcc1a45a5105b9f08cd34911cfbd423db8d6ce503e2d916e83205578b9ba94c733406c50d79508ad9472d0a291cb6505f706d5e9c2ca24b5fa5b77a1e9ea2c5f390a1cda2ac76b8adf3e8e4d387ce408e1a3b970fc7bbac9493d2961bb4dff6e44ee682b175454e133cfa74f2c679afe605351ac6e0e3d3656477fa2cb72f1bcb9f8686ed3dec9cadd1e3ede3efc1462437716dc67936f3ace31d033f92ddaeaeaf219acfda4e21e67f2fd81a75216d69e1ca7a8f1e56232d21e366b9c2008819273d944daa34ec3e0629283c1b11657f66947a4bfd6fe4cf40c12db5e3fbbc8d60deff8d99acf4997322c685a06bf3d7fdb5a5b3d0a7e92083c8716a5a2a876dd3a0181a858b9de4c4f027ea33f70113560ecf41d37f33a7fd0fa85bcfb77253a519bb645457787528fcc78181fbb2aa5552a630f1ebf5443fe984b3f5d45a0c13caf4ceb2906b11a48481eed5ee6259c73e62373451cbb5769d03760a123fd8bb01018c1cd780e1fd6b602d4326d251ff417913e3e935cac37d5cd109d95872f3cf5e7a11c73c7338f5d55300f7ee45aa757c164f985d1e5841d58337b137b7e047dee7233b0f6a1e104bd04537b99722e63f86b7fa6421186e40c4b0f8b8d51df25b9cfdb7c78a393794431e97ca8584b9fa7102e7c9f7eb0aa425cabdd49293953b90cb73a091a300e57d235ca251b0f8ffe177ae4243ba4b1b4ee085e3ab07acf5cd296deb39bae17cdd2ac65284eb35f0bb4158e33e66f80d7632156e3679b44b6d24773902e4e6d08033f7fec7d165c6b1b467c76da00623d1366828d0a2ec4b55b6197d24d6bee204763ffc5d226798b36258759e537e80adfa492e06b7a41f1c782fa2712d3fa20aee100e35001cb788486dacf0628637b320aac4de22715fd0fc6e36697b6f85184ae4fde5d2f0d419938756af3796b759c1de74983927b54fe14aa8cf9eacf98b213f02176371de3d766abbe52cc5b2f784ad158bc2413d2c77c3f0c83936de2fc1e99193ca97dcf49f1a41cf42dd2e35582eae612f662b80a92a26ce6ac44a0f1cb35354be8d3f8b5aadc95737c339615cb27f4147f504a767569379d31c8549ca862bb783c6974598fa253098726e7e5166f8ec469a8f39c0f3d37c6b8f22f4dc4f36b6c19aeaae3309a3d7d5215f99898211c08659b01b3a85c061d82c0bb079070f2ba22b31798c63cf078c0b06401e38d76e9683deb3b1719ede4dab2986af89128ec2cae9bb78a5203b229693d498676d4ad08072ae85e5810e1a84f4a2269c728175f7a5b93507ea0a62ff925758a9784104753a225bf13f0b3b19e13399ab330fea31631eb88b269e627d974851a1a782ae0e39b24dfd73540e6ade3d5ffad53d4cc22ac793cb5af2108ca68e7ef229dd0235b4a53fb47d3e4920e523c753efd162365a2cfdea5f878a74e6d28924309734ac2e591b69870aed655ab1f44a64325aa4950e13d70d6c67e2c6f1d4b04f4c6a50553a177142bd82c9b0d9bf9570a7ffc5d09e73c590ddeceef40f0c36481c52d745c8e0997a33525fe94609277f4d583d278737b790af638680fc59b525cc9b1437a1b8c155d60a11f98f16762275ac6ff71e1833caabf6228e6e9ec3421d5640b2b6b9f126bc20da2f4f1f027ddeca6de507b9ee04edc340744c2a161984c9346dc6c1c2870d816b16be8d606c722c18ceafdf0f946b19fa0bfe0aea7c0aa0fd662ce9985ec444c7a0efe1bf83f407dcc0d5924f083d197d2bb00c4c6a9fe4a7e0374736adc8efcacba8e0b274f99138593cf647fa07728402cd2c9f21e391d670bb908ada6a555fea69c78717aff7940ffd8323637ca0fd269c98e552195f89df8fa6b385b847fa9ff785de9682721abaf6625fa88e455321765598a32a5a2903231cc87418ef7e89233485655307b189f6e708173ddb450159cb2246fcf94945293772eb77eec7f8da31fb350b77ffeb3ddbcd7b74675df87659f257942d561fc8f74515e06bc32471bb5ad5420c577a153a1db90de97d5e98cac8732ad70934696542b9c6ffc491f19472826ff51c1574ad5c2996dc2ef3144a4b74743bc2bb373128767e4ad12698791bb07cafcbd048b0a94040b6b2b072681148ad82e0cb848844a672f485f685d482f3c400b73a41233aa20412a4b059a36751a1def7fd75527e760125b045eb3e103592ec68c21c8db3631ccf15911cd32a063442caf4823d2e9f68b605aa49b64eb687ae1d705a62ebb93ed221dbeaf12d4e4a0f52e30c5276db7a631bfdb528a4ddea1ebc4ba392191368d24a9c0acdc40ccfe8c6f683e7da57aab47142799dfc2551373ec599a4e635fa326ce74093b8961c71e49da43405611d1943d7846bc9b280e33870d39feb0c1a435a471229b484037627a65e2d45a43c348a5ec6bd75acff164f4002de34de5ea9d062ef6ca8a6231e32259c94d201e9b46b73994f63414274635e1dc31e1dc52e413b5afaa4efb789e447c3b592793226b6629f5b696150dfe70ed27c4674c8c46af6a23cc0a215c2848a6e83a86667d03a626a4b79d1894526f977026b0bfd2ca00e06f66274819cd7ce731b1676d91fdf0d91f7c9c2b700521b42a92de500b64f1b734d8808d89f98e419a32871cc86cc2d5c0369a980d47173ccf0cea9e8094b29b110fe7d0d9c113f06506b86603f71d53e34ad127b167079c571c2014b746353f5f8fa19f5c8b0441aa5960ebdf9e05fedbbe31326ed24d95a2c49e7c1349b3755483e4eebeb53cfd4f98f8749e2905d20906da83dc6865ae64cbd8ec4df62656092d60a6299ffb60caff8dc74e10a8069783a60eb8897233869217f8ea19cc6f0a53b3fa198666a4849741bf1585010cbbe69c6cd467bbc61033f536350daa0e6ec3f397fa9a04144879cbbea89624978f097e320eda28810ee5e21d715e07909dd5299cc70a42b91c9af36d58e5aabeca4b3c122478c9a2fc2aa3234511ecc644e7d06147ebf192661217c844ae3227f07a7fcda1ab4fd3b3a9cd3790acab70192d5a1aa2b8c35d413aaa7a942ada3fcb391ff8465791f2e70f4e8928d755b96cd4ab386283d1ec5ccdaf93c961ca8e4481ad8a93da0979a1f2e59c3c3a42d0b85e9cab27051812dcaf42808d97a90de444ea4464825568520ea5b350bd8d8c9c5479e89791f716f8db0f5b8e6e2696927d4ee0c8eab6cb68ee768112f59621f7e984c55440b2c46a76d98a47b3705e6cdd82127e7194c8809794337dcb7ee315f1702404bcf2fce005f5b0cf82be85b637e65fb59bf83e98720ec707fdae1b2687e66cb2d943e2f74fcce7052bc9b049380cbe143d10fae56148afd70350ed5c3803d7197b9590866c5d51b8b24db6035e3b061841ae70369a79cc316fd44987f6d8859845bc653636b8f59d718c5b124ced373e33ca15f0952eb2a3726df5f320e971df66f0d9ab5d84f13d81ca20296e518bac05fc382139c53d9fad929be908af23a4f74ee8c10a79f41d19d21df49bca53312102773908f37c82c97df31ad2163edf8b54079a25e70fd2196fee59e06db2d07c40ba50253fe44591aff4ca4affd8612769b182172ed5c723f4ae5ec9871845563bcb1da284d54a936a1b935bbfabcb1c537df61144c4e697b508baad159a1d281d71fe967376043336bdfdfa9f072c54bec635b0320a60c98c4e72254b1064a53522b3590fd7744d5c6d66255aa2d715bce63c16978f477955a90e8b0e0cf5d57444b0202f68b8386e71d235a1303dbd40fc18862357d06d725432bb7998f3e9f0fd265affc119f4bd45b3209ad0c2a6a244ddc21d2c469847eab2705ccd02fe649527007fba67d3e131c57d5d44f6421e04bb7edea01ec6bfc07b8bb8312fd5ae627f3d02cc87cd36ed7b0276fc997854fefd7f545dbb4ac555d04844eeb180504f34c9b1cb7edb5953af0a66f25866ca7eef1e80bdb768cccbbff3ebcff708f1e6bf7806f06982ae287a1122532b2465f1e13cf8bfdb824876dbdc4c1a966ed9f76bab512722b8ddee7c8892f9b55bf40ae7da66440e4633768278392a17c578c3725b37be83cf51c9f64f13b92e6ea581f204079ae00e8966545b38e8c8bcdfbec4d32d5694feb871662ef6778f658e556bdc2c5e8dc6cc189d6c050bf7ab45e39543012c015e863ca50aff19221e25a96d2bbcaa84548061cb0e0e2a3b0b838e14ab52aeaff6712dae57e63aafecc8293f10b094df8ab0f4442ef69fcc6399f3ebe613645a8ff61b8315d9b8d9843708b8fe96fa54256752291f123dfae1271b74f20c237471d3e7e106f80e710a1581a28b10a3890b38c3d5f2efc93719f473b1d25996cb498bbdbb3fd87fc4076af5523452abd588b7643c76ca59690a6bf385fee914a99ee56aa0fc0110417a2393fa9aa645d994fe45605a166d562819c6b58200c860126dc38fc77050e445918d767eebc77a9929948820fae36ee93190a192b52193cef214e34a16f94d27e6e59d0a120a285cdad6fc43d0c04b71083ed8b075a3950106ac40d756537aabbbc34ffca01475d1b63c5cc3a8ba95ff9964e21c7ef4bd4c8268cb8d8b746fcb8d5dc47a301f72abe5f7e19bc39f3b1d0132e9bd6548895fff610054804867893b71e275eede526496aa2801188822f404ee1a549115dac05d9cf432f66b40548a4c9bcf1c25416079e33e1cd2d7b9d8870aef54bd1bc6f440cce48722d73f05a1658f9491cd748243aa1ee5cf111dd013c4ab787abaaec28e2b49782b586d038d837d0e34fdea3a2d1cda39237aadc85952cfa9aa979d5cf25ddf6fb0dd1477be763e8986b056a376180faf93884d4ea9a83eb906961f8e5c655c0b4191367f88614f39169a24bbdcfc73b51b2ba8be79c65bf49a1b18e67fa6b8b6e1c1ef09a4902cd10a51ac3327728f9868d82d65e497657c44a8460452fd47728b9e2648ace3fef89ccfe8869f48ed8a5f72b1712866c30838bc78d090e10fa6aac002b4a2c55d0a9b4152449064626c94f8ce6f27d81d907e0ea266389b0da79f86fc4869b52728e622b398cdba3137d40a86c0e782672e721355f00d875e963e3e8ddb4b5eb308f5ad12172a5d24099c3bb29a120a378044d35579166b7c8e511fca757140db8e509a0eb20197e68d9f324b4277d014967610410a1fdbffa61416743d6ee9a59c152b3ea6ae193c28439f967987389e9461be81f937ad9a33b75d46afb5bc8c60768d78cf1339dd9724fbb5aad874a010b0c70e70307e3cc7e0ea8dea1e4ca3bc3987188415380f02901c3aeba6e88c38e224ab94234693f026a6535f6540214d3675979a1da549330a99a6c64d18e9e6cc42a2ade9fc59599776a370abd11002dd9919af97c67aa8c8f70eb0d0299ccb15b93acea24e27ee321cba83f3cf2336adbbc5177617bd6e35b4371655f53bf4b95059523260aef86eda2384a63bf1aabe130238aed38f306f10e558a7a5bb1d875a0e80bfa3a3a2b2f2151c106e1dd9388cf00bb994e4d7cab74149b3e81d64a355072435bdb72bdaee8cbfe0d12e91da4ec4d613fe93044b3187720bb00c1704e61ee3c2765a39b9bbf92fac2b110074a3cad7be790b372d225223668178b4f71a85485ac5370b9193874d6b7289c86d1e41cbbf0446f760604c131e57a14c9a053a4d34dda00b9cb844e2f9371c093d1f53c59f0b627005d5168cb0102bdd629fd4324b56532787ffb79296a128d4f49ed8a6ea5666f1f32e9d2f40731f839500d010de605094f229ad4667f039d6b24eb004b307088435653dd112baffbdd1e6d860f009b633f110422cf499d1a42d06cfdb0fa483528a096d5a12b74760838bd52bc88fcc868e9f7eeea8f02b762e825ed59533dbe5e46ac65e4d83043471caa13672c6b943449d01d8555cc1d01373852fe56b0b5ee987a7d676bf60cc3198b9b23d8c8cf285488c61ad2286174fdbb2981eed09a675d1cc7262644877afc84b843c4e929f36c1761bcabf2ab6e6bd866c658e9e4d16bd911e8c2386c4ab256f24c59c289c2e4357f8a7cede16f21cb2ca65ba69238f27c1919257fca139d57383f4cf7c7bba3066bea4815879204868f1cadba9e156871f46b684db9e3f108b1429bcebf41ced68cc06ab2239337b3b1ec5d9914015ef18c05d69f881fa283f598676f31907872d6e7455730f80cc7ef98ba442892ce03cdd939ea30179e175d87229e9592533e1b37bec0c63716b8739d6d1b9542ded71c686c8a4152012f76918f9e4219196cb1e0bf5ebc6032f67bc6249477a5f2c0b3707573b0e27a0b124e9f795835de1387df955c35e4774facf71015c513d7a29050cd6465519c4380b162bf0310eb99cfe7b3089fee44c63c148cbc352f48b123b30cef88056a033c7169fe64e1bf337e0af48968093fd4b16b02f9cd5e8d1679c3235b2299127b961268ca3f9711fcb1114fe19fca2cc8a03755b9a1c2f2a6725726eeec65253d2ebc48af048f2e21fd90ed4e43b722001ceea1b722814639fed77db5db174aa9c7734d8c061f12173ca668acb13f9edcfc364eb6fcc968dc2da6bfc914aa817c797fbaa0fa6b7fa0963c8c524f941773b65bb0d9852e61f80bb9d20dd34f10f63d86697848c02907b3244482391e759d825ccbcdc94ede790b5fea64778260944490404908d81a379c6ceb90ebe9deddbe7f9643dd1c3cd5e6da5cebc6b7440673f28aef1b65900227cbe009d12a8f2a9f4a7f1e0a63966f2f04b17d13bd9d01de8683edbe2a3b522f1512aee786290f9bebe297d9a5055103bd031c4f2aa19f32521ed2044eb203b0e26e3ec48b9a32b2c2d1c9d38c080b016b480a0f70e758974f0362af5b3c8e38bc17f1500ae5dac7b649c986c721239469e289a14803ee73d3aa1947bee0627610b95e54ad8317a24d9ce4eeb064b2715d9b00f375129ee20a58ebabe8583f4c3d0207616df142c2a84c5f5a04e2410e6d233ce4523e7f6259d2390c3d57e7941404202ef010b117c622c91e9d1c322e29b1f7b9c6f1ecbc3d03a889c2fec47fc6e825c06900643eaf505e2fb49bd96aa6b8645f500b177e4b2697360575c564dd4ac94db7116c71dc277e1562525b0cf1cff40cc7652b1cefa148ba706b822dccd3750a39ee414cad2a61832087343dcac150c92c56ec5f523951a0268ca81c11a3d973ea5849fff31a467e94834e3f7bc4ba455b3605137ec6a78189f9be56f5e0218c42892392073690d1d708e217d14a989e75df839fbd88341a83e9b24eba211235e5b9f6e772ae502c7be918f641ddc93dab2519dffaf8e085fce9a0b51d1e1e18589f32be27117fbd6a65b641065ea1a31f6fab857fb5feba64c9844d33d0f8a7290995242643e9afe4d09f6d71f7155f7416bfe498c66c0d5a9585c0a18248fe960be0cb4a512b6370e7a6eada0750e86fec8cf46f52fced349d2f0f8fcf0147b7f5f009cd913b136f9e1655be3c514ab6c009f260cfd3e3b8567522d6475249c8849b9ae29e5426b4f2c4d2306e9057f202a693b6e66c22529f1212f305865fea766e402c2b93f6a072ed2f8cb9f56428141c886f8100f5af698b5cd25f05dfb1f5d361955d1309b4da8a73118f5ba354b2b15934f72364f21844ef36bdc7be7c47d17869704d0ccfd1a5b4477de4f040d0c540359a5fc87d24d69580d2d67a781026f92c261b8e32c67221c976c2800abeee4eac24ea61ca651b3d17d1b62f0d49c27ba13d9dd2ea041cb9ac98b2024dcba32637991eee52ec66efa0d53b7324d5447684af99d0d5375361d84541788ac7bdaa2301317a06ea74fac76c9784b13b5b4b12dbc7b7bf4f5083ae1ebf2b6fcf5040fdf1044895f711b0d552711c15e4e03190563d8c565c27c7d1ff40f20fd8eec5c418396726daa95f9a9c0697cfe80e1961e633b283e977b98208dfeafb982c9de5553b6f7f93d833c571da7a6d29d013c4c62fb4b49716d54ebe4ae768a6a9e84de9ebe94d8a6ce4fa611be91525498c261435ab004e064a028586f23a1139feee40cbe9ed2e9165dc36663580771ca4eb84266d022289337a7225e0980a52b2c31323db7246033d23e1318300deca36ead2232740a362eb4d99f305180189a67d5057d2ffe5176258c03543e97477223236836fb5660325d551b72f74cfc47cca3655ff40661b854837211206b3e9c5ffca6ed9556faa9a055319c38648eae69b1aa2b08d4c27641e0d13a3962c250eda4defd548bb664f736bfaa169c2073b3dc4da143744b8e4bc442bd4fea4aa72387e680ac2cd948e2fc630db69acfad83429c0a14e7475d73339e41ec84730b2997ea3d8aa43aa8cccb90186a5b89e031c67b4130a12856db940dce7846ea0dc3c7f7e565111a43e26f29586bae6358668f3fd8ca0cfc4cb83433d21b59aef4dc9298a5c2c7bfe252d5b4655cb742f3ce898cd89b04b9099fc3e25fdc7c9ea4ff74819d71cbefb510901d24f46ecf83bfe24dca385a59e9a4d56992b27f57beee704d1485592cd9d15502835e1ebe4d158eb9f49552c497f8626866c5c9620880894a734c5fc8b4007f962b27e664546ac4640b3824892c6f4639843dd3b4808b485660e1ffc91a528b12b9cb3ba275c28068b9917e693401c2eabec2ab7baf833cca86c6119d4eeb9db45e6564138b61ff95bc4400b4715af9c649f0723d15df7678e1d89e95605dfa501d34fd9a0b6745bb8282bf6e5d6e746ce6c9de46cefc09b8975c6642873e8c72ea377537e7209af77a94c251b37a9e768d82b969c5979081bf3e5b8f60d5610b6b6e8f2997c408208da88891920049b653b3600b102da89b96bd24b8441d2cb523bee56a9c62df33695a8179fd0328fa8d7744834df371d704899b0a1566c38140126074e67532e1a01690d6c150536775c16cc92322115d79154f7930f59f5b56acc154dc655819bd609031149bc661cea0f27433523108754b03fe77585ff6bf3b1c1702af6bb5c139cbd96711e1045423810a1daf7ed453f62dcc8c8f454f78dc5879742bcc2ad16084bf4d5ce92beaecde9a718e295a27557853b2cab7bd94b9b0f2b4219d4fe2eb6f1e6418860ad8a35cb1a8bf685ab4f84212fe41bf93c0b1340a8055452fbac234f8a08d43558dd366927592f35be5a91f38bf928c4e5c0649fda753f0ee9bdaef5e81c612fab3f6f9c915228757446c54184824ef5622d025b62d970dc260adb38fe730c56890ef270a73ed66744dd05d6c8350df5173ae541212f3ceeee94a02ddb1a1966bf25395593225d5d4acb16766ff6ff500ace8367999e1abe21e90576954eba08f3898fd910a629d72b92dd6935874f1b226037ec2fbf6df56e9829cb1ff36631d2853ad2efca68c0bbf16c18f2e6f3344ca9bb46cbabaea84e18eb4e71df744a19b8a076b44acf11de96871850c3f42af483cb42317980d6b9c62f21c31990a044a37ffb0257122f5e04de682ef9e492d6fb22e97646bd120ce79a03c5c14623328f4a057dffbf9c5700c529b540095e6296924a12b6f803bb2f47ad620115d5a271c87b16e0053dbbdd99bd9f8ea18331d2f6ebc5ef1aa426c3930b91baeeda9516f666bf3df90d2ebe1dd02b518e96af6d139cb1546a2345200e75ccad46bb187b6833ad11316e83a06e6281f27c246d6f7842d8ce2ff1a53d8b91da3a8144760c336dbe8a0ce53f3beb90cdc8381d076aaa1275b681bafebe430460ada8700ed976e5f82a0a5b5af470c51ca2ba7e3ee19ba982aae970e5b93cfe9ed8d493b65782dcdc2450d92d8bcc97c71f0dc3d35374a015280d57f0949898f121a41b5f926070dc70779de621990cd5e3a691fc5e8a0d923e97d46539948ac5a0d3cb55290a728bec1e49d231434da59aabc7b06c66038dd4df987296567ed92da6ac37abd4bd99cab4b8d4ab43a059b8ee8b95b7801c97392f83f3b6339538d03dff137f6436644072ee0d5145dbf6ddc2205f71a4f12bcc3ef4498f3801b95d113b5159d75d3363f130d11370c9ae841452dd934ea0ca27c935c00cef67b857f624ca174dc5f32fd03aa70f4ea29a5ee4f179c32c6096e586060500ec72c0d398dba9aab05544e700c595d184eb9a1e5e2bdea97aae84f491572bf5e15c3e879384e1c4490207393bdc4bf6ac1cab605c4c1c87ab19eaa973640de8373db1d276abafa27b5cc47c6acac5ffc826b4a795f8a0b3dcb0cdaa3895a8a5a6b1481330fbfdf82bcb4ee73f401685605562be941f6a6e23d266d419996476cf8d810c07961e1c884982bd4af13a2466fe4bda19d9bafd51d670ea83684b19a0cfbee6fdbb49726fdf9cc0c81cb39e21cd3e4d4c9983463d79a9483f3f1f6060c1e0317cd32f3f5aecb721a0dfa1c011ad34f46bef452beabf2f5a1a78191464ff18f01cba355392f6f0cf17db347e4abec19fb9b8f24e12c6c171bed4cab2aa23a45d2b697af0cb003a835febb8ff1c7b1e1f823a36c35c287b293a499e4dbc6b0985b516ea47271046dcc4104c16f9840c5bb3ad32389294fcb696f9e6bd0f1a56fe8c5eff6e14837dc36fc351df6fb15eccd6bce4575f0ab702e3557982e4982631f1d75c07d1eebae67675090d206b088d6657e8207fb0dc1cda2697e826c0e2b0bcba034f17286ef42c0542c027c007c8979c8b43102626d2ba5192749eb8df2d921a7f37dd465257ac702be775baf041c1ede403c0f5834c7f04d65b8caa9ac94d9262dea6b0aaed542a58c544f2d24466e1dbc3a04fa0f327ba47556022ba6668e9115a270989d457aee96673c96a363a681804c13920fba0297dc680085e60c4124708eb1a5c045bde4debfb863e2faaaa30d4544e117b882af34fe233027acd46f2fd80f589939dade965e8defd8ca7e4a5932f2a50358c0ccde5a41d46b9b92716e0f00d47166a890411e3cc6f884ce8b71194e72de88c276c6dc234385a8a53b44f20dfbdd1a7f2717b475c9d482677c122cdbd233005343acfe044309fb9f2d345e557a4664bc764149a122bb1abb7011acf0c4ace0834aa8ff16298901f2bc3ccd0929576c4234c1895805abb162cdbfab397d75a125abd6d7fd4311c478cdc61deeb66a39f4440e2feb41504c9467a7dc377e2549501f608f51163b8eeb99f74adeaa4d163c19c5fcdba7ee2baf7542a8bbfe23ecdfa050c121615c226e2c272947b1f2568719f3dd5f3867f7b70f91e06fa0c2a3f11dee0f6bfe9c8e02677d30aa3af288c722d451e328c10bd13fae704d7688e0693d8194a58bfd4b129cf7dd1d6aef5ff012139f84b5e0d2c7a2c697255b670f6f33c2e037e49886e8b65839ca533cd77b65df5494c3556a879812631c98d506eda55bfcfe6baa4d35f4c59c6e8b5713e5df69791c546c77a404b64d28db059612a135e5cb2923f18d2a12f1db021d87314e9a6555c6e8c0d39ea727957db7ddd39b7a7de2b1d701e8a2f92f7638c4c1624f10b62eea190a70d301a7831a59cf658c887e7ce090402381d023b9b505140232c1e9cae22ab6f7335f516575774cc40c40fc456489477dbc650ab2dd01ec9fe0c43effd8deed8a7724bd83b0b2e5308f6340de1822e11aa81cf7820bc36048de231ed77d205d720bda8479d3b325aba2f8495c31d7cd840b7f8ee00075e71453b8ef125d0f219633f7a8b6a1dca97c47dd08c732c03224cbc9fb94a4ab959b28747fa3ff742a05bbc086fec0ab07ae5303829cbe2409cd2036cffc1053a57b369e352fdecb2b73341dfde92f0fa392e703654c2df0ae326401ca8af22228d47ed84391234225b3ca80d2610c1f2738f2fc3fbbf80d276b63757b4336aff9cc7a0191593f62c442a152f128aafa47fac5ea6ac1f6f8af754b73f8410870080d77429e48484b18bcc46d9a50f9c1d1f2bceff7ac630716ae2043e533225bff4200ddd7d52ea38e64ab9f3fc03ce5cd7fed3b72bdbc3d8e5dc7a97fd869e8329d5f89c4abbfacc8a1454652b61045b5c4ee86f9a66ab2f5289c875588df9b755427784e29762b9b7b9e6ff440c1dc3a29ad4d54123ccc089b9c81daabdc6e211fcf48f1e01eff76220c1d25c1f0f037d84e46e71db0e584a81f771d3fa2b234bc6087f0194aa18b68f08bb2738efca74128bc1cd8101f2e221ec674563746da6c3483da4d8eee2f4209a6f7df1cd66f96c0c5aac75d6962400ba0169597391673bd9083aa9ae5804a51fb2b6648c7e050e686536206143a213df138b73138999b660856951946b14070e7d7bccd9085a8d3f02e9774673542e59c8208b654eeb27e944b2263393884bbc4d067b094cc1f63b2494667161e09990f4eeb3410500735a0249eff6ee89ec64efb44c1a08ff6534a69c41c90123e6a6a7b558db672f1a5f97a06fa56fcb78396f40375134fb79e6d11594d7da88c8fc8564f2b6a7b48f7f81c8d02644f1df429aca60a5533aad9337bc2f5f1b2059d61657716792cea84beb61a617f4fc36851ec0602df8c61adbb0aaff11d809b4c8ac27f50d508381d5a2fc7b718adbe5284c74ee24b982d5939f446668651a8d6d513ad83cad1964ded4763957b73c9a377e47e5029c1a647a12d9efc116967dad9015a014b4beebe1afbf1d754fec2be67ace975867b26b3607e45ec714478d6569173106ea42da254d327df91342bf87f71b7b678114e5ad67abbd5b1876031c7aefb8bf93ac52cdceef08e038caaa681bd64b8106f81447d7df56cf8a607d296bc87d110b22a2584b0eb216f9c89c30c1b3fb8790c6496fb3bdbf3c296384885fac0ff627d557f882ce9cbf673361b2cd6ec313d936576876ac98425a92485f42ae584721344090d39722c0472c40d0763e3d5e4c0300154fc122dda45df2326f146fdcff2782715aa41911e2969dfda53eecf74563b4ef8f378d7285ae241a901ca61628775a106a9c40857abfe989d09af5d78993b840263b606f23487e77a646a8616c6457e09489d4434b08278ec9417b59a08adfd282cf75f660290009bb6b4e88f06f6f0d669234c483697f1278ff03a066b4f7dcb575b053542a1e4178f49ceb43b1755c9d6e2fed99d033edf0d5509044fa372b64e79c03a62c16fd2e95fb32f2d3f3b3fe016674cbd317eed3435c69561734e5a1bd8fcfb1eddaa7cc03f0940bd8685a34334dc2d1bae69ea55d3c903c647e7e8e57492736a450495c8c84474970a94ac1662f5184dac8fd0fd489599b9f1ed0a3c406000612d1860a3ea3c27de6c81a466fa4bd1758227fbcb00990a5d02721f599eb67b432e0923ab2cd9da8d506fccdc0b0e46002971dd6f394b397252763790e891c284c26820ef2710ca56e1e22c2ad8606400c1a515b5878e5a3a7c953f2deba43bb8cbaf19de09364c9e4a3165355793e3150a78bd175368af655fb6099f673324960c475795139be3323efc4b05b2207548eb241af557074f339ed0288090bcad59ae1f79c81b7a11ff70be722bca820218ef130e0f231abb7421c1d02090753674bddb91bc0b3749b01c68de01afd4e2e6c307eec29c753826922e2c88029426f0a9864edf60ed9cd87d0b8767294532f7bade9b06770b26b2e17dda7f79683ce5c6dd2c19ac4efd8a549970c73359b56f49e308f9c230ccc2c1d68720f748510fcc28021814d126d368ad6e1e7afef13f8bac81955c345ebb2838d182764be1ef57a25475d22d96b3006be563e26d6846bd8e65e37845288ed39ce6ab63d0dfe1687049cab42f1e856b69193201de15cfc39b2bce1eaa23abbf2f9d891ddda22ee22c29799bd1f8ac78b0e0caa205ab5ba233d7abaa456b2fb190e3d57b46ef810efebc32fdac6d9ffec4c69d446e20aa04253e5a4b6f4a53af28ca0543ab6f12173f060464b8670e56c5f54499969219b75dc2c58518e051858e91fcb43e20738fb81207ed5594f4dc95768607e58fe02e2b619eb04390aa42fb7017fd627949e968efa7cab1e5e6711d9a472a6a4203fe0a3afa76cabda9b8ce064bc3136313fcdcfbccc07092b7fc919d8850731f9b620befa65974869bff23a5779f203bbf86182018aaaeecfee4d4db6efbec06cdb8bb80f52b5d7be8f275eccd9e377817a70ea7e4f44caa8f97df1d1c6395fcbd02ad87de93ab8fa1b0536619bfbfb3ea62aabf9b209178350740dc91f2fee4f16682ed768f97b7ad1d25120b798324681f67e6774513f55d28a58327c662f0c2af9187cfedc0f1e05eff152a322bd45f2c79b9d58bfc6575747b0e2b32439d0bc9133584d0d5b4c1618905e5c88719f53786f9beb095cbd16799851b3dde7cb048e562713189fba653f0705a0cad21d9d6edb8728625250002fc398d21702372e2d616415cd9682627ecadd343dc9152ffa1fb4b721f03294c93c92fcd45ee52f08de4c26fa63e7f16d40c99a43e8c2e908f498eefa1c00acc1e419e649f89e7f2f46d4cde9820cc19c3ebbadc6fa136c896f54d0945feb8111aed99bc62601c083c51b2f257dd4a71cc59a78cd878eecc131be0e33838ea2ab9ab10e09d5f557969a6c34510b8f620403ce8cad8392b23f793fc31b4911d2ef5d1d78fd9b750307a6e94474aec066dff27329cc2ff8d3a6e6902beb22f4cb6a8f554ba3b86e03a12964dbc1066a064e1600080a4e209e21b819de803bd2a5ebc2e66097a8f6249bd6dab3c67e82e5427b156e7e35e65cde088621fa9f1384763a1bb579c76d834bfb9cdb2101c674f010be6b5a72516143463d46a8437fe9867637c328f19a67574bb7edea540e8ad2226bdc312a0edb40b96ace156c6dbf8860e815c86fd46a942d6a0d3fb79d189668be25e4eafcb0c557e2e340fd1cd16df91a64d2ff5be1419b20479daf3634284c0b1c56473f460fd49c322689e4e226a14bcaeb36a251a81fd830c0356f8fcd38599aeeb22b5598afa1a03d7a64f518bfa56df8bf76dc73e31df9b8642231d2358e5c17e3dbb8342f2943fca11e65cab60687221347c4881f7868a6cd8e1d098a8901c0aa3e0cee5cdc0d5372cd901e59cc7ad41e9a370a3182c10a9740c85aa7cbecde459360ef68c5ed57bb2ba81c199050c600df2347c0fabba632b1b6f2068545bbb0dc77b8f4a63e686079221051cc5bea837fe2f3fa7aae68db37c042a13643e4a91e132d1082ec15cb36ca98b458423e3728f1fed440f49c9be5d8182be8262e8ecbab1d55046b3e2c257e834e73b54249a126654be366a9ef7c364a577eaa9e1c3de5f3ba9b41ffee25e2de173799b51a9bb8aa1e0ca2403204df012ef4465a11a34023d2543fa02512fcf7da6a0f672ab2eb57f08db28310ab8aca4224ce2acc753465a8eba4e72fae5a7212dd298d530b835c96dd779cc659ae4f14d01da6d198d3d90ea7eb70866619139eb8c69fe7670fdc704fbee599b4b27c4d216ffcc7a3cda2161c4e91c4029efc4a47f816cac1f230617abb305301ac79b0b4e749c200775f0bff3284ea49e25a22429b12bfa5c60aef555c8b96b565c443af654d209264a6423bcce827eb11eeb2fd5fa363d2d937c676480843b9a4179046e2a93dc29f9e482bdc8369dc8c661d83c13ab99593e3eb4e3044f8afb169a3085770c6a8808e223ae1a1a4fe38decff90e7c851d107e36fa8cee389833c6f94e0301fe3d35c6b355b57ffa53cea221ffe15c88aad391d67cc2e45a65a5cfe670e3dda07b3c45916eb291ab9e1d6e9a0c86f79e9d840924f94c8531d96e16e6ecdfcc4db906e070856cf8d80bd4d2065f97bb930f0309b1dfc14c5747979fea625bbf9a88170984f209a4b2496d15b3c32f5b24bac3f952163dd69484b9705785541105c0a40d307ff6f41d858e6b46eaa4bf16d0947c24e13c3c42a92f40b864246d8824e3c89253748d89fda97a39f831f43336a45b94da9b9f091ab0aeda811f6e377a8248f7034b3c292e5f0eba09fc96ce928dd663cb587d70a34980cb1c572e284d69b45730c511b7d03819a06e0d3aa6d64d39d3d4649b82ca5219bee484eca05b7a9b1a25f58d3f4f7e2108e407b04485993373a75eefd06e36ceaac1114d4d6043b25415112713e452922aa8d346eee42aac4756dba65033005d213a6c04497a4a277bd1c5c1e9b68753fc69025bc59944acdd8e3c4757623bb2321a043088bda10ce90252807dab367b4126ca8645652caa11268794358cc2030ac76011c25301ef4dc3cfb0747cba4f3eb87cc123b7d24bbf47c178adf1e0c5ba53c52c984e749444d3e6fac50d854f32ee4d408efc276aba9ef3311f9281bc003bc04b06f9a7020fc13b27d7f72a6990cd8b6526a25819ea9773363d54e2ae712ced7a0920958fa5ea706a198194a392e4b9dc819dd2d6a8e43d5d306fede8812970048133028ec7a433fc605ddf51d3d3b68e1d081032f29b9a7d6e9da1d635a57a7a7bc66ede0e3724866dc75e1281ff128553370b1887b598ca55169921d74d8696250c1174d48729e511eaa4a7d7aa1a68fc0748a4e766b3d37b3962d3edd18d6d5c6d7fa768be6d38e0d49f23c5254daf2ea0003e49fcac5854859a12d63bdf40488dc4f4fb0a30c89ad719d54ced775e9e491381904f90425e6cce54b4bfbba52e737b0d916f8848ecb1d9658803258c90d7c649b0f5e2e297dd3b414b922960c6ce01f25ce1d079f281d2971b7811b8628016cf5386e495d83440c5404ade8c4b04e7fd4fc29788a9ec52757b5708733c67255209951b2c9bb23b36af1b6847de33a1a37a2104b5f5a9e6560d67d1c588e25caa3d581998a192dada2fd1a34a2304919f131190b2986353c9cfe128c0f4f259746fec180f6b640c79331f434d3a2690f34cc6ed5fefb200b00de0e3efdfeec304f40c5c0141bdf10982b2eb47f41f76f87144ddb61dce3b0a3ddbccc0e1be12b5491d3036447f35a5054eb5a5078911121e9a8e3eb2114130ec861850e0aeec19cb3bdcbf0479dbe386ff6bd611142b1cd7c1ac64d8ca49c917e73ec0570775211367ceabb3f8d154df928eb4e4cc17069953cf19d7ca8b8b84d4a37709bb8debb51e708712bc47fbd07ace40bdc9051e8f0aae7f69c4057c2b29ad13c76d18cd8c60f216dd43ce0b2983d1c90d535bdee1248bc656da0712ea44ed8a1a4fe26761be30415ae145e238830fd50d91000fafc789c2810467c5aaf659fbebbe69ba6ddefd57b9749e5b69ab1638c0133c9189393423def8ef82d7d5b2d0eba797d3fcb508b59bb06a3bb50f81e635f15ae33afd2813f15cde4d68f34bda92b9b812a0100735108c88c2a736e73c31048a6e524c1bf9753e245964bb93c5ba4b201469415ab88fb50d7bb8c859b2339058de4373375f98f2fa69c9c97ce7f79497dd535bfa88cb7907e0bc1e5430c6713a3f94694b031d35793f6cb1b4abae50f1582c510b089a112c2cdb3dd0b73308a0d8aad849345f3ef1d8955f1b97500ff11ebf22761d1fe87a613727f07e50fdb53af1d82d3e0f2b4591ed1e4db3733d05ac6507f28b14c4c6f9f8fa24181ccf7e0dff49a3914704ce18140f0a2c316aefe907bb7cb984c832a49ea1734c3f68e86274dfb2464bce351ad54f3b40be2d5afcf358fe090fe942673c5b7531d441ef7efcc780427783bcb047c59edf4d4db45df9b3d53010459758e2f978063d3094d597720e033cbce74a3cb97dbe848683855d1e3e4c7243870afe39d9505a4fe8322ff2fd1e094cef4b715dd4038518e26f0c955a69ef0e7303219eadf19caa5f9215ed285512d9afaf0be86944d15505318100c82d2b629166ff3eb9d372915f44db36dbd159238b6f924ed81af4e8024f0aaaab2494e23437f83e68521c0791b55a94ecf1718165d06a8e265d394f3a3f4852b46da677d20118e904040cf2efbc6e70324dbfcf3a970a9d0d3bf60dffe2dfc64a2f06470d84c87e3eaec63d484cc50cabb0a7188566411b6127ff25708f06857fe85ec4dd9c876c3938b12ff8b700d01a557f6c6a69b2d6b9c618219b72ae066e566b8e2578eb50ec075e9c94678aaba87a72a2ade2bfb76a110682ca44a7068b7c95441c92db8d0eab4e6ead3cbc7261b935aa1c7612d728270217f8ea98f342735cc236ae356c7fd8c7ae9b16e1cbeaf3475f52eae836c56536344d78e9742bdb67917b9cb4526dbd6e0bd4408d1d0a4463b9264a2400968fb9dbe05c06eab54697b13f927af88d72a5b6f55fc7255f091c3a1befcd30fb66d9f2543a1c5d39d4b7fefb2b2214d3bdb953e9013029d9dacae5116c509fe74943d7edde585e89b66e46d2e04452cc2bec18805b4dade4708a4ea487950c18731328fc7d0574a25446a31fd0606b71ecb2cd7a8a97e65a250f21bb649e81c0ba1929917055fff68b5e803717c2d8d737f637ed17e7e83f2196d7ec5650d6bce6b8d1e87e6904462e9c94823919289da1e25c7bd64055e92dfe1da5e586f57d2a957c7f489466268d340536c815bd5dfbab4da0bacc9086e52be316e7487e9cf347477e135ecf9a1e1759ded4dfecf040e51933fcd636588f7c1da6651a0b5aeaabeacf572f01c8803248b0880f3fd3c26dde042014eb67616d554bb57a0530f40e49378ac549f6d00607764fe4cbc70df03a9e0690edce2f75e87675de94ac46234a3da608142f51d844a6df1a24bfe2d60e949ca4dc10974b5476652df7a542cf3202de23f8796167abad1b708e13439746990cfdc903dd17fee3afde7a779a497b5a6a6fb2f1c60dda404ebfbcfd94579792fe9e9ee63f226aa68c7f53ca2d39f0d2029adbe27c2afa7bd737f8ca570521281b1e99476d5ac04f999ef8172a5e49998591084aa3c9a3a77aed438c5382c2a47e6f35d026285c4fac9877f3f9b97b0b29d08286e3ef40ff19f84ae58da923824f19607a9874ae9fc145489944e54ac336154ed8d2b0b72ae39ab76f47809b4210064a9a2ac650694ad38efafc3ef298536f254f73364a676aeb6f1211a6cca29aeb52b356c08a7dc5778a7038cef303687d92ff079f21dd3d60c03dc6fa6b48e3b73d440a50eb8f095fbdab7b8d2e579d4e89f90887b5e95a548f1167389cd8256d256b5d8a32d72e4a01d269d9660a3872b03421aa41e4fac01d033cec9029f7359b119d8c53b0707a8c45d612165af52d946452f5f03d7af4fb48c17714e60b6a48b07c4fe81d8648a3da1647c06bb20b1a92e74b9caca4c7c29eddb4ba6a669afb3ab5af07b1275d27fe66f08b18996918764f83a7505ac94d717791e363308a4d048968a61663bc4b458b815b3ff227162a334592c2d47cd113fc8aac832d5745fb39b07638ad4e8f7d6b1891ea79f17ff7a61b33928bde90e8d98d0faad04bf93d5f806d6b512cfa372b17cc92f813b16cd1d1360a2b61ae29ff952331674bac52c33627a272a93f6f25ff946ea97e4cc53656b4c89da03e703560c61bff237ac4aa694769f6dfff952fc47ec4e6036e118d74fa292d2db37c05d9b30611af0bf55b2d00ce31a5883406e6f5a74e3033bfd4b9e5cb25fd8f0cec0d2c199b7a4cb863a1c533c3724cf9f28d68e9c27cf5933bd54d8a57e587899b975e466c2d6daaa730e6af77b85b505dc2c31a63016ecc47acde46a9c7ebf82670b8bade6126fa40209c7e552f1b33cf90cb099900fb60ab2dba1c4da2c735ef9d271b59c1622e96a0628dbe25c11c403f5c0208838d0364482c9bb649561f5a722efabd14fa102cd57b0332c2e3250b48c0307b75630caec3e4019d3d0ec8480bb812020793d0df5eb7e4a3584c945eb5adbc35ccf611fb8236ceea02c3f3cffdbf88698541f3db9f9c70047a8f53e73570ee828764ce0c938e00db0231ac0791b01b619c79056a8271d3b39ba7d8a93025ab09b35eb8d73e05e8cdd3285ab5958786c39d6af32088b1864cfe956ac72ecfb7bf632defa9a371348a6fb550827432ac9bc4a4f3e241810e824cf4fda48d61d49bc4fd6cd70ac265edb6687d862507ed1a0f9befdeb5dd0b829b4407f62d73042c22af203774585b366b99990311b2febb2f5b384e1a69ec92ee167baf22f862ed002476bd752b86e1fcdc198d5825a64b92b8ffc57d9eb95823ea9ddb5b3dffdd01cfa290a843c79aedf81cdf90c19ec2b2bcf2402b132991ddd40ee63f64441938f8135cc9b9d0383a962ffcb5652177c1d90cdd02b75d55e381829f3a325af1997ddda653cef00d7aee774e79eb3dded2d9b5c2144ae4fd842567caaaeb4a27bd1dd374186efa7c3fc85630fb2841a00e4ac4b3c5256902b90f209043d73985507d0c1d0823df365c4587ab9c4960f653248a723afc925f62d0ca85f8115b3c96148bfc595922313868b596803b0df8a3ca293b172fa1fcefd846285e5463810300dcd966edb3b9dbef515d6e3a513b414f1c5066757934ea2eaf7f7335613989e925a56346281a74830b6ee80cf16a0f4ad04498b3b1b3451065917a97d52b701dd29d9e5f8000be480b89a8b98bac3b229b0b1bf8a54891c852f13164ea6eb9512d42c2838084b95548e599ac4b21176283aec74595ee3840a53ad7fbfe5aad77f445efd73ac19cfa51aace1611653ea17a7c4789e5fae66a754cce28c8ac3d4533a901dfd42ec9797374f9f81e20f77d911263af7008a941ff5dd08cc334d19e4ca61eca2e79f1dc33046c28b76073b0826691e78eeb5b0a0ac09962522291adadba4442ff92d693145b5996a1739ce18a7f2c15b5a8e178d2433bbacbe123f46a86494c29b7024bf2d8c94da6d7c0cafea213e257a18edc5bbcc35190f40ee36413c038c34f7a3b48f005ce103aa6a0c598fce72069f9f6f057a871145923b1c0bfd9c56f0eaa6b088d8d2cecb539887f19a6f4fbb5e718447828f4631561df33ca5bac93d037fa02885c331970d7094c44a504bdc42dba8fc12f05cc99448ed60a62308508a9264f40c47d9a145780177793104acb1da9d5452e903a9f3160dd77ba18e9e716aec66c62e5304ad76b6c5540c10f5687c5db04194248d2518f75491ffcf6376be0968e2fa564030d86dfa2b9a6d846a36662770a7c7d8ea300d5f79b1111e5631f6ddc62734ba7fef98788e97b7aaf8e2f9057d2f2b11a269c1d47399791313af8b1939dca939284cdd35badc58bda26e1d466ae5846068cef06244a912c8489f7b635842856a3bac5f3b5aa5e895618bf61fbf0c1915ca02010e5957cb88905d657a6815035e884a5f2895a1a70fc4fabc767a03a122036b6dad402216e3f5a9880d6c2e3807648b7aab6baacf8d2b41d565d5ed779ccf0c6b6d719ce12c7b03f5428f19b4be014a540d6733097518d4d2bbd527a73ecc894c4c5fba12faad1e833062fe27c05b4837a597d3e2ae8615107ab066b7e566d5599fe25c89a74bea9964e3641bacab83c363e37f98265aae425afcb31e155f88e18dee51fcd4f5d3bc605aa19f07736fa746a450d14edb19f345b4ac3e72d6f363929745a7e3f63e251702f181b81359e5e696ec3b9c437406d909ae2948f155dafd695dda7c165f35738391b38cf8752beb18f31a085ade99e907dad00507d246711078f8087ee966d03f5d7eb34d5e5393b7ffe38f1f0847fc041ed0b9620eec684a4b5639ad4d747e6bb6a34149f633300e210db48bb489cde5a4c89d9399c5ab32dab9807e68df42f8cab2ae03088fa8f4dc05fa584866c92f5f1d894d791cdbd5fdee963be3a4d54f7bba56e00f0af4fd1b226be1b5a194eb8af07bd9845dec18fa02f4c1b0df64de6dfafa85fdcfa14696ee140b58d38457657417166da9a4ef583e5ab75a5c0e6d195e3e67ebaf52939bff86448e59246a70fc220894f021e385e14cce10a0694cd05b29db0e4b3bbf50cc57912bc2b324f6bf06fb15cf50e8e3fd901aacb3fe4e1649a7c5622aa87abc919fa60a88a3b5b3e95231a6c777865782b1751817c893cb540ad0ce6274593d8a7b17591f1a6bd663372521eeac4d7fb77ff3d59db920f61e8531cdc4923143ff8e916b2a7475b4ca0c59f68c5b9d14f58d668499364d3455b007d17288c965dc7b292d59bf79eb13cab7cbd2c3ba2e4fb2f4aaa396fc21d2073fef1fefd632746cb77be53df4cec29085fc1f7a37625789bb2d8ca6a83a7d6b0b8c26f44c4d188e4303d7e66a50f620e0d51de5a7f6d2f084236e283c02909ff00e1ddafab7ff93826a39e36fcb3760cfb263c1a9ac748c8bfdb04fbd7ef4cc5adf8c767a65b72e62e23714745fb5dbe559109d3ace3d444f33c844c84c28fdc62bf6b26e67029aa56aa18b69c17d3e713e685d5e8327c279e4d7a5d9d86ea47b3d590a1257a014925db10f36af66db3a873bb915a51af6d222010169872413d15a141215d1e95cab14189af56e8229d8fc90bba488099245d6fc5dd3d5b3040a7a03eecc1e943980b827db0c046c418b41d545297d348ef36cd8b215be0412bc4675d8b16636f2868db9b50b043d63b3f4978981f53ea55ac91b6c57e73d3ec83bb79d2dfe5bd50950d8be5f35b36fcda3b28f8298c0d788205cec446d566ae3d3b020bab608b323717cc1d661e76d04ab8fb27eb16ae660ba43073a4846e1ae1244d64f409562cc46af3df106fa05526729231cbbafd9eec562863ca09acd60e8ef4924fbb23af5803ae304ce45072f5c44657bfe177bccb3b1a4c694d2c0fc317f96b8d23799b575a11b2ff6fae5d32e59cfad8013dc95c889936143302c1c5865ee37fc0b5f87168280171a823409999d0d7cb826cf6dd9fcf70f1799eb46cec71826b2347293a0a35f82fba72f88b59da07cc6c46b9264e16988aab7b7dbf419ed5d47803b0e5ae93db33e5f34eb47e1597a29078b01789cf53fc7d0b3881f9fdb5f2bc928a4ee174e9f3fd8442ee22ae22a29b84e2d18af9c444ba4e053c21c63f0b91e28f63cdcfeef6aca87bf09f9353571d297c01851d3e7ff41a93307859c06f0633226a7ca6cd5c40dc61fbe13228896ad8d7399ef0239abf158374e68ad0a601dbe73381eeaa8870ef012031bce00818c1cf098390750e62c9e3f5a8a5664ff384ae831d77f5f04389560503d2f61f32773c64f81b06782300f472c0e6859a793d613d07865cc2e2f6e2409779196ab1c8571459d44c886daa33acf49483c63e168d95b0e8bb37f98d3ae5cfe1350d5d9886b5120fb8111613762967970eae5668a4bd84f13ac163043f532c92be5c8c97852fab381f7a4ed0a599038ee9ac0a3c798dfb6d5d2452ee092066d1e8c50f4951ce59c7738ac4f409630dae4fc34a631088114db4cf14df058cef289e0ed46e05c46f5f22b40c86385717f06a6bc42de0532c1e3996c4d5d6f589bdbb9d904a29787f5fa8a7768dc2ef1071fd19fd2663f24d0e0b6bf6d3605b9fad851b89de6a692b70cabcb9a7e70cacd8c6c356e67d092c779107e472c91ae4317bb3b4ffa2e753d99185c37fcc52c71bf78a6d0017fd83f8945994716a21d1685a72e83f2224e2885011bf26ea1f4d6bdb64e345b0861739db9d9496d3f06a6e17ea1d02559b778a96f2c09d153c6e3a1a614801c7dc73979f7e611d1d9949a3dc533e4ae2f1de6515302d983856d6b17d6520ff2adb32094e309d782cb309783d1b358ec40b6d6be5dff62cb3e8342e17e2c370fa8485597be12b2e768aafaeed38eb602280dc6a5abaae24f809c5e5675676da64136d9e1f70c800ba1ea028d2ccb6558554ef4ae3fbe449b6b8377de66259e73b6bf0e06d0aab71b2ec62dc311875b18f3cb8cf64c9ab2a1fb3caa776816cf315449ff4bcb92c2e955d661ca8635b1b2d9690e8d51e76b344ddd3433d5fea721373fe02cf4f8a66c3a79242ba213215894e3a4f90071d78c776c80b87caad989166742d7ed2d313eba5be44724909883751e4eb1fe830bc5f45d54be21a7a53321ef07aed60d581ce12e2ad15d9fae6cbbf91aa368580d5f9a5c3d954860faeae9cbb5c9fa784a6ae86a53526635d193c44e97af3153aebf216de79c5576b0006437f57256406facc74155a4a2606a3c5413692a4c283dad40a969cbfb6a77cbef6222a7e82fa40e5523e8789bbe12ede6cf825ca42738d45115482afbfce82377ae959bd52034def57466d0234524f216dcd902eb3ecd468d523e582fcd0be699f6ec35593d4f0cdf5e9b85cf99a5d910136dcc2f7a3bf5d02fbc05ee264775eacbfa8f89e04bb0e5d0b8c2b97193f617f28ce04b0d193bf95a5b78b5056b343aa52978e9bb9984df20ae879bb302e01a53c2561c301853c9b47b092bb2f80df65e11f3ca2c1c6693e42227325673f2573565b98c5724dd6309a2a8699049ee9299b5b681eb93d839e96bcaf534f1cb1146f18c7195985e532f2b55a0f98a460ac963ac657edb808d6aeaec1f554dcf531b6ac33229dfbe22cf63a5003bc78c66077073a51afda86beb67dc0155cfa3c652ad46468b01c885551b44fd135db85ffc1fdfe8dc93bf04522b3eabff3bb4940665727a7d8fad11d2566dd84d58c8076ceb75c3837dd69c29b689e03ef3b15e4a699710eaca8185c4de748246173d873edaf1f6159d23dc2b538a61e5340d40a2c37ba79b35bda21a013cc8888a9be91230c0851e5281af73e1e07f0b517ee3a533d5f51775bb95e006c1d1cb24edf9aec587956853efb8fb917d05f8a581a74108d35427003dee658b90f0f3423e2fde689a2165cf0d504a9f2b6bcfd2d3d2475d941ad330e727d9184abeee6c20a9915b857da40fa2126d61055f8373f9d84351afc4e424c0c29b2c258b8451293c539387a70d601805a682f99abc0fb9aec193abf22f4eb5ebd00b6a1c79c8728e5daa126bbda5fe426c834d0bb9a39f2e7bc0853031b316b5e89ef8ba95771744eb8b4d53b7e4853fa22e1745584f798d1d582d91cba717df29e1c09176f0b93b8fc5926dd2ee04962319c44cd044dbde98cb08192f3551307c4f475c353effdaa70ff0db8b99756a0cca92acc4059ca92bfb6ff8317f3e5ef52727654be3106b3f0fa937a923f5595cb315dbb95a578c9cbe2f96a634c085ea398ed444391a85eb8bb5c3d4e647fbd6b4b6f11e36ecf15388086a787f9a33887cbd4e1ffdcf8e7d543e6f9d0c52ef437d2fb367e1fcd547f92ea799f8f6fc32a08ae26d94e34696d522a884c19f8170c010e2f0677099eb47cbb60bdbdda73255de479c408f616ef575fd034cdcd894e23ee7a830f2e695b07b828c10c2e36910386eeb0611356620fc91b4805bb7fe6b6ec8b61c72a70ec2ce8eb2b9f8911cad295b018d2a762e92b25e024893cb2352ae6e994ea206373dc9e58182379e0669d658268b9e049ccf4745154d9e907de5dd3c79f27b87fd6a65d1c36b1b67455e797489beb7c778f59cf2d978babed0fd2ef6a5fdb62810400f66abb0a5b6d5cce04c2677c39ae3f84891548fc94bc2d0a9f47ae05499fe6127dd9017b84aa83bed3026f692491136164ca720d0fbdbb8aaaf2393177dbe2581bfcd4b9ded8eb7148ed6d2f89c80b285a076027b8162156092fa3a06c1c3ebe6df03d67f1e843ce0ae8e855177f347468195b1982e9f554f227ce3edff1ed2942559e7f0490fa46ec91e09f800bf85c248234f97347f34cf75086bdaf65391ba2672736392c749f05da23ccee44476927b85671175aa238afaecd0a209da7cfd923504af2837f52be5cf50ba9ca79e055be7543ee273e7028c70875ad7780cf66da2499234a17ef9ce1f1523ce0b7f9d4729da7d6f456f09dadb49dedef207b21943a72c4d6c12c8d0646a78b6f89192f36986d0916908461fb83b4d33b06a303107e8808133ed1a84af79a8a7a9494d65938c5d505423b727bec38a405b59e7328ed0f6f0bfe80355978faa9462d2eec995fdeee4cd052aa72faabd9fa10f3dfb2c7fdcf36c38aec042a5f7ad1971c7173abf72eca0eec2df947fd0fb8a80110f3868e0d3b841d8e3c8b10b0e082edf80b62c7a27ae6178981836f305188032b65c44981404945359c6d7e775f31a71b56e09bdca878d9863fc24197a1bb1e5e51276fa4bc1a085683f64921943ed6af68951945ff6fd4035df6279337f1e63fb7142e48a97fbe683295d937c31d4eef7487f7e340919e449d0800d51675b5846f2b8955539988617360f795ead6bd393450f9d5d9436cd5c6835166ae5416663e54c322cf2b184a7b8a354b7bb6c244c066938453e7c952e637496d22deca066aff242a32cc7983ec24839c46c449f9d8fd437cc7e0aac5b73c4d4ef80500fd60a0a320c73598a2cccdec123b60a3822ddd0aafa3171d6824a62dc9c3afc3174e17dd3adacf0b8148c708a02c46a94836cf24340a0d4abbb0fe5fc9eb9c674da8349d78c9936944ccbf2b55793ee8f3d446cd6441ea6165dbea5492a11f9c0e3490257c4cedd248a5beb6631e7c7b6302089e048a655d71327201876b653eae6e51b506eb56d81e282a74811eba0ce04aea5fe150dec01498de185619c8f42c1f45c211c4efb5818799b065914374b5b03b0717fb40f7cd81a5eef276f7406b194600edfba4c6c3ad05dd3c61483dad1b7cba172dd8f8417a4337a25e261ecff0c11c0e0d1e31292e272e301f0f8d7d44c7d9797fb34282b76f58cab41369c7dd0bec38b3af2b3e19fc5f03686fbd741cdaa8181ac3eccae299a50e5bad034ca64d60744d7474df3533cb6c425f720daced2316f34aaa7aab30936cc0b0ac270f83e60af7de2f376405176f8f5b62c853f169f9ba21646da2e17712c8de2cdd1b11a068e3fe4483124f877da4c712a63a814631effdd0743176777b9c8d0cddd00f91623c65b087a0963800a42b77dafd0253b5c24c59f1af25f85320d90ae9f7d8a0e2d8278800af66960ac10ec3b73ea2e8b07267695fd9b481997b28a52971d8d556eb27a111c567267641a29af07b32cd8b067d3c475b724766b00000ce4c9f6b1c582edb1d63cb4ea639d7bd768318f4ce7c413ddd0f5b4230de851253fa05bced6c57f690fd4a4c2856f39e657fcae36e96c82e246343e6c17057b5ac6682cbe420b1ed856951ecd7a50c2c34d32f787e453afad70a75fe0d795895c960ab1747014c7ae5726996c06a563893d8dda55c75bd7670e8f4dd1d25d204f35099248e5e9f13285f263044bad3c05273c4d5ba0964d111e2c3bd757a46a4bcd545b762d1343bd19dc5f7d2688f13b796c48778f44b9fe41f39b4d26c1a4de36f7a19e54b3bc3d659e25c69e95b3e244adcf2c466f0e57773529d221e95689d3675d46ee8b8bb36bbbdf4f5e0aa6e33e960b1e184541961cb946ca162da43e38909453ae2811b5d30e608d40c6eddd925c50989b95d60b48fd75db8edc9be9a7cbb59491b5d1ed24602279eebfcba4853f5209da119e5a6e210570b5be4fe45d6bd03796417a97568efe118b97f9bee7f65c82103215fb58ab0b394cd38d80a8896d5204704a07ae2e46d66f2220e5578d1e3a00e32bb96ca514a9af8d8083d335f55b46daca21edb8ea4df901a8875550790acf5c663440cf8a77ebbb24a5e24264b051a4dfdfd09a127e6397544923c0dbf277c5a15f82da181edf8b78121c4396119f05f5cfdfcc3478b6e6118079a9d092cb80130231eeb45c726083eb627a8e21b3c8399288c26bcbc23a1eb608d3d4b2005075391feafbb7d968dac561d1f9e836039a5f90cf310c2e9c402bcce802bad4a2b2f3cb24d6f3ea2b122885139b53a088727dd15c22548f6d0d522c8fd13a3cbcd574889d1c9d8179a111c60172b36ad9c3cc4986acc29bbe524ff1c7f264a38c65d3eedc1a84f37316704404353adf90013d79fcdcf46228a68005135f8dbe63df7da8fd563a95a322abb18424816d937955104386929b44b6f107f5b9b0eadb79b08497fe974e46ef198b3b5605947fb4afeea617c4ff1172e6aecd88ea1da1e801df86b4363f4d5f8824fa55a558231f77718564b6b9d75055fa2728ff67f56ad655ca40f772ba60b882bb602651f8c2ef11bf761be059056936ee06d4021509edd0f0d07ba65033de05068eaf3be8d1ed536f48a70271af00ce2b72f3f2db86d3d7d10cab1bc79622e4e7f24d27dc4f5b0444ea94c6562f2eed46270a384f3c6e388a40327ef32621741829702cd832b6c70d2d1e933996b8f3dbf56c8debb674fdf641fed79bc86b4708ac6cb5a5e890f8635e074ee9cf9ab7a4f58ebadbc0f1b42885c395e2ed0615ea2cfa564e4f0fd675091428af89829715388b73782dc5068908789b7ea5e973fe55b438e9d36b0263f68d79a20a525d9a68a1c9b394249bac5ed76831dc8265ac749c0d7d997351b5d3c1ae0c2aa2f09c81b22b52f914510b21e14d2df431b03029969cf83f09e7d50e8044aed03bd9bf97c4f61230f2c4188458af5ddaca09ee89e9d88321a1a597619fd4f6799d91f6bf81962ac0ed26779a445bc30d1712a81fc18aaba2c6ec3084783282fa7aa96540b835b0df8a613e126fed56a1541d33bfb087298096a73e4467976c6939b8348fdafee0201e9091dce943231db1ce628c297b4bdb41abaafa4edf4f6a741fbc1d7dec5a5f57c5fc3c84038a47d4824161043f3a248d658ffb11d5fb3d7a9db891dd29b17eb4215533582ce44b548ada6bfdc3a3e755db72241b8f3bf0cdaf6ed95603fc95083a151041bef0673f342114358a89f305f7721ed8db39b1a5c5e77aeb664636fbcd6f485c6dc34595a8be22afa9353d20273d4339be56e96c42b399c3f4fa9389ce924c8e66256cca92d0b0d46a9870bb4ceb5433fa7fde4150d571a69fb27d81b4d437fd239abb489ce29ff06e9017fff91f6240b15ed27582cd7184dd06350727c6af94517ac2ebb6ac38b268dfd5aa00fc40dc0eec581048dfb0ee67497012f2612c84c1d6ce83376016b064cd4c8f50c70409053f474d2e063a9b8c4306ef4cd530bd70150955c08db3e1a1bcd7112667b3cc18a50219f33f87e50d5f07bc709ab1799b7a8e9bfbedc421fa2f79ac88fb48ad3e5828986716944993da51ee7edf01b2e10f77ff25970db0da05fe6d193ec93bc7637ea0229321eba9eb00cbb77327a77b9bee2469697fb3cce99275317cb7865b8ade3d0307210f55f070f100b5615b7e990c1d06bc49b28d3ec6795046cfa3093f542b834fbea12e12f5cdbb3705163069e3f44f95ef18b8023745db2e412c6103f75fd9832dae17fdc425ec228be26c20532576f79db7fb71ff342a3208bd9fbc227fec3333e9788b1b8fae7ad80f1bb788201f0cc241e66440bae7a12578edd18f6515a35927138af9f7fed24eafaf7cb6cad2384ed03bb110dbbeadb282a92575a0b1a8e8e35ff5811dcf242d1bc3097ffc3466345fdf0c7ab159e3bf84c63b4ef2852001bb81526f146dbf246cb51fc00310045b4e4b351be9af3fec2a371f18d3f014b0f1c405b4c53990cb026328e71e2f94b9e2995d7d46a5ab76a76ad8d7ecec0c69eaafc8f16aaf3ac201e947bd0409c658c21d25291df8fd4d30d986059ee3271ab2a3a11613b8baf9cf7932a55b3a6da97b8a980dd87fdc4c7ca06f07794ff1f7770cff1724548b819841389942d0dc04feacffd973bb16604b309340c52e16320a22d876d5908bacca5a39d4c86271301db4798102b053cfdc069c56fc4566fd6138f5f1b1ce1b2899d273f472ff536d1109aa3d29172d41747d383b4d32cbc218a0c18d17582dd67cbd5d93b9e3bff4f7b7f70ba2dd115ddea431351b4c1fceeb1649e3bc473ed8ae5bfdc1890755c04e6821cfbbf1891ee631d19d7c590e8b3dc8427a27bf7b3eae4d7195c47741257ae527f5d561b506dd796847bb106a3994dd4bcc346d843bbfd89af3bd804b184437d1bfe6ca205a187f0a8ad76a9c051a9fb37192648592693b1c1cbea806e8594a4614f8164982710dcbc302c6219d1e247be24542ab32f6111dfe827abdd9c6288d04a88b687bc4e614b222d834aa91936a2824a42198f6ca8647bb1fda5c82c2e11ba82867f073ffe8695371161d8af45dd95cef1a98bb2bab3e8dcbd777e5452fd53d560848e3ca18dd620e9bccc28e2bb3eb669ab2dee486e311f506a929082c89c1e3af6ffd97cdca543be8c219dbc53c2692fae1b836128ad361aeb4f0fdd98f225658a1aefdeeb1ddc58b7e0f047be233f36925eaa5511b550053c1bdc36d47618694bb67573adceabf568b4bf6731d900dd8b0d5bf186f8a9230b27936de301590b6039d511de11852a6191801d5588abc0cc223efb0bc5b282de7f09b9e58e50f76534a86a50f3a5e04a6e3062271c7d9e3973c60d6f4266ad168525b45d011b2afc46a291707d6f14956be3dc8dcbd33e7edd2f5bcf33ab30f0eb2452114ea1018e77fc5fc65a988ad6ce07fefc638d4c0ab564d0fde5cfce3588a6effd556e3fb6c0e08c2df1f1f6714232cf5a7d8963f2d80d319a84496169e3594a3cc4d7b6705209e2b39db14d4d685963231900fe8a4cbe893ba21b4ab8b7418b5d55e944fcbc2203ea435df443ba708f1b329c14ba0f615b9e411c6c948ea8822ee2b72954a851166b4b78bde6e5152ad85bda3a0a28450a44faaa32039a0b73d43e84e009dfee6f2ab9f123a55ece90c463cfb521f3d4f1ff374861be5826312e5e019868a472937346179ab0d069d2655ea7d8bdbabee57206dd467a7df70b970f0857de97d9edfa922c55accd2d0003bdfcae3e29ea52d1383ba9a87edb1aa5f0a6893b4408753073ebd98e1a552673b8630c3c8a809091f1d97ff18423f4f87b4659d6d36eb2f1fc27d19ed7ab87ad31ec31de5a2636ff89334d94b5c6056ba86f3a36d87f52f49f2d9fe856f519b683cc38f982554c4d0b1d39fde1b048f6bb0a3bdb3626114dcc58edc1346a6910247540f691288eb753806068441c947a871c4959d77f65bcf64452030e5891685fb82aef50b7dbc6b5d59cee1f99677bea14eb8b57c15dfa7af6587aad6b91c7fe79b2755f7557a0149d0bb434dc530692824fd6ca954a062b7b88c36c80e7e50efd12d7082bfc1b9972e273dafd5206c849eac253b2c646945dbf7da0c3dee18ca34bc4d9ae49ef7d812037b71bb1e1d486d3770f4b2e1bc5280f8771925559d84f7dc14f372bdc712e158b74cb4097997c49bba996a9e688d83771b08b4f212fe06a3bc84afe4c83d7d8816ddb07a07addbd1fc731cc704d8cb87661854ee8969f04f00089b31abc5d5d435234d0aff57bbd91dcfc59782cbfd20fa2bed3383cf17e0327e26c1790b3e07da03592dd2755c44e67e9424c030fe8dbc4875c0178a3e77faaa77bce6e498337cc4f0e98a7f16525656f39568854439cc1711c0f9cb5967d1923df91d1853e7e99425e721fd5d001faea629767dfdc01f68c41f8214b9cb670115a036e42d4dcd0136994b0ed3a0cee6f88a437ffd7c26acb274efbe7cf2a507fd8a3879d90f3980568c0ce29fd3faddf6537a2683e0377aef5af5745c0e1d76db4dce7a5f0543e90910c44027ff5279bcc954bfc961430cdfadbdb6bdea2867111b29825ded4ff809c54201039f0f23d12599ce6bd1fdbf263c87571a9ce2b41ff64f9c0fccf1cebfcff0935204a44894fe6c89954bbc972dd91f00b766497b5be60fc92aac216f4cb1fd765961f1d9b9a09f5b072d48b82cee91aba955b4a1b21b077e87d12c42210912c26d3a7bccd66b5263e8b53aeecfec7f28303cb44c8037d1239ca6e49428c101a036964698fd83f6f26844da266645d29b561b0b68712b2f95c7ee7f157e668bcc3a871ebd6a6a6f11355106f3a1c28efced254324796021a46b072359b7b0471abfe8f13a414fcaf8b6977a0aea6cea96d2dcbc72d5174f96d7413458bc798aeef468df15572e6298291495c63957e98882fdc08a2338c2a202a078ee2fa81cc2783a4ed7110979137bc1d5a491f72947043d406784f8f276167e745c68ce64a42007230d53cf463eff4082c8f7eccb1a1d097048d11b5bb2c9f2b2c5f77fcab51afeb9c874c93e26f2d532770855bc9dd7c96031e0ad4c6b8af065b2c49fdeab5b17d01e5695d488ca5e919b1613143f5a5dff68d87494a97871488fb22819505de6eea777085a575c363e42dcaa9ec30dc8b0f8968884e93038cb2bda32cb002d963f002889a739cb26a21fbb9012c31353dc3123c25f9b66ef5b3c52373a2fcae8e24bc0b0200b4dd86f088d11fe280d93452633f5c2a54eb205d987d4b7e1d4530dadf0484f59bc65ba760434eeb330110d2dc02595ded947c1fe2695ef308c942fcf1cf6bee6fa00d2089d35df78b1908b63ab2b3c94bf9a8a0b937b92ca1c55655ec820fc2a24d18a001c85985d752a012672764f075838b845ef53fe713fbd3c8c13f098cf8f742dc4a05c30a01bb93e99f2e2c6eb46e02054b70e7d792708ab8c4767e334a4d0135e455d954e534f052340d5afeaf56e52c3e7a53e4dc179ab1973f887ea7819e0fd4ecea6cd81b2d4f08708c720dfac7c84b64e3eea404d97f0161eb439493b4f72ee611653b913476e05c7f19da7ccb969dbf9d9610077be51e2cd6c9cb60fe3b490a1086cff80e5d2067c75e709a20dac6864015aae532a827fd6b441db08045cbf632b78e3c8959101d2f87590dbcb68333b888ccc9ebc4c707acf8a2c3cc52a91edc32a65ca5fe7b6cecd3520c9141dcc1255467e4a0e7cfad9638e2df7287eaaa1080a2b6b4d53689fc0065379bf300736dde9a6128b6324fe8598f1479fdfcd5ef4f408ae95191c07ab3fa2375768158d9b6c58e54757c196b2a76e237b78fcefa397d6a318bef1a0582661b5c9732c1ff7d7917afb308ebd9aed9f134696263038f795306f908668dc7a8767025fbff05bc84db551cb5d50355178972d2b6cc329ece9de761c6a3a54ea4be3f62147401ff1e0a78b8b55b4ebeda49e404eed87f5a1dc3b4fb6a23e3b9c8e4397119b632697a855ffd33914e0901fcbd6b92a200b15f67433f4416fd8a713e1ac6cd9c72d15098c938dca6b3b3c9162464af638f19da232783309ad0a998de7f0d1dfd5fb57bc6cc5a62ff229a984190182f36ca560e9e83a111e14b0f177918bc553bdc16070831e8f75b5acc168224b09a8e757da7218fdf1ce822aa6c114bc2f3b686ac4b58043be1979af22632a03281c2ac55adf397b7a67840f9e478aa0dc24199e2e3ef4ec2ba729e29ff22d5d4d0b939a836d4d8c181512e6381f5af4fce075cfdc6aa02cd36277adbf614f058ba48c84cff048bc7adbdbf0c3b0f622a3c900bd1e2b415b39086a3a3c0919db17db81bf0718dea012990b6804a2f03b499b4270da2ae0ebe095ffec8662d558cc46fd46cc03539d981bb431b490ad2c4add26ea0b51102bd22928e23eeae6c5a8949308122d67e788445e1c009d4b2367da4c5a3d8eaaa11ceeb0f9bbd249864d877bd29f9b7e249f3d66db07c47b2544294ff513fbe56b4f15f0b48886a9348187f50f916c8de361bd1a89600a5db5e8c4433cc246e55601e743bbe4fab3b7aec4e4c7d5a87d8d965bd03e9176a2d540b5f6cd937513004adcb62540d2942e62e53bbcb16b0923c9f55a6799db8ddd9b47a1a864efe98248cc5acbc54ec263d0471ffb3a594344c8239fcc677389542fd71f1928def97a9b282da8cc1486704ed2deacdf64478b27bc2d0560496a7c9325e87262dc5241e949962063bdeb5ed553296cdce7cd38bd681bd3dd74a54843434212aef3a0555bccd553cf38ffe285741b00c8079b8e244b8639aa2302402008861839eb9bd41efcede7040185b71e360ce2086d04f93db17b8a8974922ded1b5fc844e6a1b6e451e0b92f1c96c58704399359490756aad92f73ad21fd94d38e5966a552975260ff4ca52defc9014a56b3684aaea83d53c8b9183ffb6195dd0139084527664ace8bc72611e0d7d416dd311ebf339a2ce22ac5abdd3163457d5fdccba372b697688072f4a2c8daf83c46a73270ee5cd7464dec7516711d9a0524b0844f39bae8f224b4c8da38a0ef338bc0cb67b65cb9341eac47efc9189a2f36f10c70a426de2f4c16836889ad9915d2ac9f86bdbd28a143245a616d7cf4964f420e3f80b4046930a3732fbee4001fded02eff75d6d4493f152cd8360f143bf555438a0ac295ed5f511dc538f31c35104869dac88f9a2ca3ce9db506cf6c0100afea3211f0238cb950fcf53af4325bf754b6729c25070b56ff93cdec281230b5b960ad60d4591c794ae53d39f1743d712336f8aa01b7efe799b5e9221c9bf66ebf9d84821bdaf553e66251fd29b1a85a7e00efa8aafba3f63e6d44d7d1f8e1d476a2d6cbb32175a5260f96984e340fd05a15aebb01d935a2df3210c7732b66a432b4d4bbdb057cab6d46a826157d07fe5aaee13f487779118a46f1a84bb05e09f1a743aa2d09f1d23dbad45fd502cb81aaa208e0a79c860692718067751b8386cd61fdc5024c3b14075a9efb131cb859d698f7fa369e37838717c92bae8ef86d971c7063c74dc85f93c03de32705d26582d4555ab37daa7daddccd370aa6bee98e031d9b1a0e891ae4d41a3463223e781e881d396d96c5a4e26b01919b0240948a261a38d35d74aa929555126adcc6f5fcb41f9a1c51ac342e72ce7a53d2c8a007d791f6435901130616404ba1e058066dce80ee9ad34cdb62ba0fc1a8930794e60a3f125916aea10f8de1c7de228755ba86350cbb86d4ac896f96d2ccda918cd677f524698a7baac0f474cfc5b8086334678d74b999362807f1a6ab790d5e1bb1b81b55d38c6f548b23e719798a37639f16a4eafe5fab4bac4f7a90a2e14bac48f428d4c4a4117600775db28cdf90afb07bf1592f832cb9257fbd9791ea977e6b2b2badbf01ef81bc20aca9610236c7783bb90cbf88f9ea7a8310053ca7662d1d8a45e3bc971b8355e6df98558f6fdfdc6d9932881716788f668873d75342c848d62de003d9a8295cadb4f36f88250482c400b71abfc968d88d2ed0f937957b6d5caa3211f132e7c17c1e2b77f167c8cbcab267c0bf1e9bb71c7d24ce492fc907891c9d26b5531b36b5c49f978be686d057466b6f7763372f6ce63028c6c650b9b3f4735eb82f504c2280640643783265c5a90725a5ac34df444fd780cc7128717f384c5c12e9867d2ee2d0490499b6a20199b862a950ed7e74905525252dc5169900faf4702b9456f4abe311fae5e7861a2b96c7476ac3448cf54f23175873798cfbde67fea38c651f5275caa79f049375460b003359d5ed11bfabbb9a395f86ddeb88037f8041b88f823a51f02ec5897f26dc85d940c25731a3396644762d079224a04fcaf9ccfd7a9a9679db9afcae42da7cea7e877ede084930b0fb9b236bde1126166dc62e9d562c3e48d813c92afcc5b7a5aa5838f0fece767ff09ae05cb6b003e6d2a5f8522e7ea9104d6b54727b20a4a25a224c892b42bf844846a5269811e8e8ced60a282b0c57de819724d8d077ec04351a498ac42b71e6add72c2708da7626bda060d3f604ded35431fca5922865e029b5051aa801646e3f6915d9d7c6c68ebecaecd857c8d069b3f94a62cae7f2dc9230c48594b069c4617cd82e82213066c32286f7da706fb7864f2e236e3dc100e40867515919a97f987553459d4e6bec30fae3b79e452a2f9cbb01112404c91a6e82b5695190c818dd1ce0ae9f41ff58f0a5aa2e5e47f47817667f7af0eda6878824b0aac25fe806e11dfdd8fd0600879eff8743a8a86554259e701c59fac14ab53af52b53426d914787864ef2381dea64e35f0fc94faeacfa56ee7e7a04c2b5f7523505a1ea9a202b4f7ed8198a00a7bdb288234b565848a6a3318a86365618a3c0b77c2d7afe1631ce64bf6a42fce805d217cc1e8ddabede40f4b425904b325c1befd1380da97d063f21aff4b909cf4a2d3e9f65f5fa9dc10b616e3e65f361e5be1d16e02e3a0d5f427aff44dc178a2eaeb4eb984501e96b8694a5b8ddd9c892480ac5ca5dba5d775c1e6341aea9861cc838d84167b95b6f57ad90ed74cce0f01cc40ffa914547aa753c3fc9c4c4bb44ee1846c2fc451b6bc86c159679303b3de2770bd8b185bde058ac2d74c72f79ff1cd1c8bdd4c2be794767753490a964ce045436791afdaf8236a76b52f6004f4c4db7448a78b7d9b9e7c41f283010276d327d041f1c21b916231037aaa17ce81702b806b0a05972f1de91cad426b8a3eedf12676e7d44a6ed984c5c4baf43f4d5c12267e9bd9f0d30059f358810070014c1437f79f451220eefac763819d273c59486494270233b5e5bf23814e35a9ed15472efafaf560d14eb64a5136c4d0ce7869e0bf011d4cadc82c7006566401da558697c05cedc4ade2d14b7f24ba332462a4eb53a297916b1402099b5b5f9968e4fa0f022e51511b5bfde0dfdebf74cb714ae7b58f804093f00e52a67be54db96009073417ed5020a8e15be7b966423965d28e96cf0b6cd3c4f958ce9c7d19d89f716c764955b9e12e86ea9d229063a6123a53cf5370e515f5f880896e619d2af02ee1c051aefca4402cf982f955bee4706c7d1cb298cfd3987bd7ad788c5b0e3b52c76dd72488f2c74a0969a61f471e2ad37a494d4465eefc03c287deb721e4de7ddbe7ff7cb3a29babc0b79266ffc533f0440d57b4b919b2a07f29fa32c6f7233a4178473948b5fb5e4608312c8ce08eb09b13214d1b3d48597c5131920c00e786effa4a94d9b9528c926a366f7e11a60724350ca3ab238b9f26cf907a4614c5a3c4fdeccde9cbc3da3062ef8df5a29554027927bea25c34e4820a7fd8e0b97bef239b106e5b4a3fd5cfd77b28d1d1802ec48973ae32a91f4227bc8dfddd5365240c203f3fd76aedb49a3c511c419bea50ff195ce3b57ccfd28b74865aa2f4a039258ae23e2d1702a6f823da6dc2a02ff23fde632613eb1de6c4e549a714e82841793ae9b4f74c1a25cbd9599f5a447d44cc3f313292a09b24d67815eaacf3aced7312254c4f42adf9488e12170e9546f35f36a55b4f3f9b6e7abf8e4ab86229ad5e0a1bb0846a3e28538100dbf9c0f1bfd05198f2126c2ce146f4a34e4b0b0e9436a4f308a42188e11e6653e855783ab330f018a0fd5d2fffc4076aa5e0a0f7dca4aef878558af2ca6eb732a04eda8f3e5005bc5efd0bbf336558d759a7cf65ddad9b18a01a18de8e6bcdd5bdaa04d4cbab4ecf428238a78785c4219b16139551278e47499eb9c51e4da84ee11e64a141d4ccb7d09fc8b01d7b3abeecc955b73b3759f77178909dde4e68c157f81f82c7db9f2f9897ce823980b779eefd0a58b25a3a938dfde2362bd1507956e296478988449b9df051d1992e7cfab080397b48bbd364e280de89eb985fa49a4fc6263d81b973fdff83c411c9b44e65bac73c96829dac60832adb11439ed9da96a0258be44abc02e0fc49d8fa207f9376cf8ea53ad03a24f13659e01b707136c67374a607d75a948b8e653577c05dffc3fe2f8bc1ea0552f3964cd43956bc22b04ec2df56013174e248f2e91636966722c141cc1320448b8c3e18c576c5bd2b9c7b47a7161ed5da9e6a01a3e8e55b46e4b9f400fe51b5923853d892af86001076088af3368d182805ab0ab02d1c5bfcc77d794dc26f557ec2aa25a6467b4210287cdcdc02f9bc0f732169777cacdd4b211ec0be9c72087bc7fc8f53e1bc697c634f4d89068620744e12a370af8a511299531db93cb102225107838ef59f2de1a79985bebfa56778dba800b6d5645eafffc6501009c8fd429bce0629db514023f96dee1d3f76be9a1072733986f97a7062cbfbb48cda73f9bff0f98ed29e7260b37517d060bb26777685bf659f8b8e591d67f0cc662d87641fb93611832d7fe5dda0b430480cab07e35923f775f071152a6243b61c83d82d688d52b93594155dbcd64cc2f2c2cb5c5c8691b5cf039f07992f854f9f16be1d0e3d1c44809d289fa519bb6f9cf0b1fead8ef3c5c6b2d1a35a604a5d7521202feb0a3e16193200a65c147221dc199c6db4f9b798335857a6eafdc42349f26caec6eba9a9dbf77dea4d56c35ecefee3b6f47804cf681c7d0e68fbf83ca893f122899b6ec395a252023631297ac99733fc0158f52e216242f9b2adf817deffc264108a0366c87987c762643f7033ac24a649322cffe8fa77f7b27699c0c23d747aa5893bc69dd0cb5017d2084748d09056d05bd279d4037fc700717f7d74a732a6162122700877e20e2228075e9b6b8d03a559666491754b5b442a1fab402a778690bdb03bef029262e50318353dad03d1f8089b9fa244d0e766b6ed0d2b3a94c17ff8640abc2e7c683cf976a55be8f93cf6802f3d3a93c3ed18e3ce7ae548eb829143eb291284c10e7e7c46c0047474ca774c80974c9e4d2154e507219830440b56b7491d5aa8eabf03397cda0db1d97ba9ee596d64843285d6aeaea492a8c5cde9204fadd19e6504cc0b3589a0924d6b8ea7458c4f77df570bc61890327bbfb6331f56b0d4e324c870b5cd854f6a3219f61d6b1d3a79bc001d344cdc99bf0fbf90ee14b4abe83022fc13da03872cfc23a02a227f9d257642db153fb24e7d5b273794760172f4f673f4a5a04bbbef9b77b4fb6e4a75341925567f79af66d5968be5502573cfce184e18c0dde7a595a349766ea3682d03e4c46801af4ddab63daab65be3ffebef9f879750c0a6d5eee1efac63e109abd856bac7cea98ac3b63b98c8c990ee85238740723ede918536e900b36e38841150b1bdcd617dbeac9f0299b1cfa1b237b8b3dd1d06be2e46c765abf680b576b2a775ae7489f526c233842357749a25faa85ad65d728dd72a4ef7df85c575c9b36b07c044f0459f4d18793e7897b434daf13b1e85e0dc60c2880b0bb8c8719678521aa44202a8feaf8649a47f23384a347f14cb29cdd1021ff49de31655034865fff5e9a97a5581f64c54d9ed2e84abadbbc133db6c02fcff086a67aab63f87217eae82fc7775aa0fa9d9462a19a64b2e490b064a3af1d84ffa0da4eb931d19ad97cec0d309e009d07c8cc837d97002ebf9760f4a9cdd6a60b3f0073bb77d41e2287e211d8cafa5a0b5c4584d1473499ec2474854ca6db546f5dd4f95b6b3424fae99534b8e3bb3a0605c5634f317602057dd3adc62db32ea5f2c4568237ceb45e54a5203d9efacb6f7b045a8f342483db9b777e702a66344cd0734013899e2f73640519d4a831f24b4b2e61db88fe3797f6ec51a35e00b21a693663da1d484961057d2fbe59211910456490f120a7c9c26dd4eaf963143c92e49ae307a3909c083c29cba3c74c794a7d3b46c7f22785946165e205aa36bc8671dcb0ebb3e2cadff6f87ea2857a6c3d8b3b2397136c04f120e966d473808dca186fa7d874cb2ca9df2d30cff935d2e0ca61d4c3b8c466eab93d4adc000ea991697a8359197d12dd9fe28c666a4c84fbc29dad59f56419be8852602f4782e25d3957a321a04f94eb8280d2256b54db46745514397be42f93c0b02d09c680348659169a63323bf3b7e349e485492243ce42e0b933bec14c7b8feee51401331dab94f89177df5f89ef5ccfb1d27352dffc5e0ca6a696da19786d3bba0426c70aaa7ef47efbe07c4a1e4679ed589cc43f0b1099115be8f450879cd8775437ecd7e1a13521d72e7ad4a2a1051324871925bf05bc10b8e13654f7dd9c7651d85a58da5c99d7cdede20fe44100be06063a55afe39d0d8f1ead5686e76fd7c17f47f5a0533442882e62606a965050e7a3d27f7d8cd9120d59c9140e31cf12c567f2596cb0cbb43f864d65be43abe88ae5cf32b84f00e69a5ade1cbe494ed7c70a1c30598f5a797545194a2f631da958d3e5de560118f2b58da5a726021138a55e8aec51d98ee25f74dfa6e209864dcfb40aec012e18020ce9b800965e532b4f4885ab73824c2ef747def0cf801a12a783fbdd98136ecb63eb197f8a73e05898f3591d82982838cc75f77a8969dfe9d9a1b688a8c17a481c07ac0d3b049a38f9d3d9823cceeffb12a83206f5e532050ccbfe54c3c911e34c2bb84378f9f8806a14d9b9a5381ee88a5639e255bb42a80e0fdb94ed33fa6ed00f6a0d688d82e5ae25b35991c368002f74d89d4a53945177e017e88fff74f4c48851e4dd565625a6ebc3df077b33d0d7b48347a06f7d3085e7c1b0a155af4a4a6de3975135a66983c3ebeb53271b2d39a9d03d1d60abebce56ae97fdb44e82898cf7a5b67c38f4003e108dcae16ec9e592f88fa58b9db772f4f32012ceeb1f4fc34923b6a6e41debf19a9da038af96429d5bee5a2826bdc2e76c5060779326c283fa330d3d1aa59c3cf82f5f3014f8931bf92a9a10eecfa7a0395e7a2046f201080d1412a75a4c461f1a0bc9f108c58e87f949f8bcf17434db3c7b746d78e2b4f7ebafa102b9c81ba9f536433ba91b173f2622a18dfe3822d79ca5f93093d4d17fe0ccf7366200c087039912bd4b03176b6c8db9b739573358448d76cf736e2ebb9bc133fe13998a68c0a00060f3de960c6029a75d99afb2e964880c32e8389cd1b2be8bb89cd680ce2e043916dcaf81e8b6a75f936a0d8c2cef973ed4388a9e621ca7707a64c91be2528c723ef627bfedc8ae2152cdbdb6ac1c7c8a239a4003a8b57824ede4cc3589b5f1b4d1628c8dbc164a39a93376ecd7e6d85f5cbb4ce83bbd4485472956b9c6e3c84d8cf7674529c0eab1cbe68ae6348c6a274c3d0cf89459b80edb5612ebfaef7ec602c00df1ef0ef817f581759be7114a4ce43374e61a1135546f2055691eed65ed1b7ceb6151e9efab8172ab36e4bd417956a70b792c517975ec50d73a7b77d143b91dacadfd5f17a9007fc4c4ef9a317c8615b6a38fe8d84fa345c586b82943636f492a3d8322bb81793ef1cdb2f78381faed4d848b8b056ed86f1dd04625a72b10dc32d7740a0033979bc158afe9b19916140f475b5367f814d55ece5b90a0cc706417519c8f4312ef563b0fe1c5d7ba5c63d13dc03b05282790873db613e6fb45a410cfda4f0cb6228240802ba859b09e2713b438a3fdfda94e633f535baeea281171beca8e8adc2e0846b77fef97aa8b9fd349c8d08e4162d0292818992cccd758a7f3d2b1a871d3225aa4cfbfb360c7823ddf4d69af06bd6c6dd034021dff8cd610961dc2ab16a3e07a0e7b7e63f6c476215b1afb363f428b59c6ab50612cd81e9cc3d0ef63cdf2a63c0adf58d717f49a40d6da779618dc2c41f8fe3fadecbc773b16fa0beda894acc02e16bbadfd6afd66f5efaf20286a5f7db2781143c7fa5c2775d90cffa5027dfb02c5dbf74a1c24567cfbdce2a735cb9b0aea0bc09b4afaf0db9a8bce0c61784b5d032f4ef7d3887f63c41b0d46822add1101f5f8c80db564011a477dfe89525faf10f2f4b6aa168ffa90ebea48a5c703698a9ee6a263a33c08fea21a1026926c7886a310935badc5e1bdb06b09c307720f0b56a209da0fa3a356223415b014b6572985eaa3eba323e4a7343b0691dd988720737233f6f88459e7f2f57b248762794e20451f604163fcf5216a114153b6aafecce6fba28fb4cc785edbdc06efa25708bec02cd342c30ef087a65a0808e4c53341054a2abddb38db5bef9f5a23290af3ef4f321458a121d65c04588bad75da9431865fbf9a3e8ac0fc9cd92550ee9d8505bc8a24a7e41e1bf855cfd587a71bd5022123c8f74dbb37fe0fc11774492f439839d84d483868fd9514826cf09c03d59ce8b703d509625e3d2562f6e455c003040d6543c815c836d5d83d74d6ae9926eeb7f364ec3397d03ceb6c89c6a905d2e63e44bca69f89643b6353e03b0ac49d68ae86f72552a17aa2b244d2985ca388a3602438d84bc157b034b618b39ebe0480bce56e20810db3b7aeb083a75d946ee160062d475e10b500b7468ee95c11362d404a0eaf1620efeb25d0d5991ab68f0c704ab04e336d2a5bf508421ac59fee6fb158715914c7f650323405e475b273d2f4c4c93f5aba08d4e4495a98c5aba3c55e405dd86978381b124106540dc222a790cd03de7f363ee53cf57e48e9e589b539662a9b07a6c02708393889d0001d42347a77e4280f86e9df9ddc25d6e4c347b3ec8645c1b16371cc922d76e74e061e4478887d3ca020a1d3fa5bbb1b9e5f8aa8aa4a2c008bdc9d8c7df1e4e8f74dfacc35c0ca5e2a8fb0c9dad1ac51ba630e5f63d5db4560fd707cb48ced609a065ac84cbc601b0a9d1f38d0a92f86deae699151f8907e0e9354f603ee81a70978047162f0c8dfb977da0118d48cfc44d4b38b57bcbf233847d72b22c5e40624b283a7ec0ffdc528b630af7c8da13b3f720958666e8d2e2ea02c66bd502e32d78ca7668f50f12e30f7573638ee606c7bb80dfbed3b55da1439a8d6e19ac90bcd0e0248045a072d322ee553160b4e0827f564c068512737ee6f46f71821f7bb7a296d18bea49abe2acc587359da06d84809379753dd448c7412247be46f4a178c16817cba3c75d8bdb2902724fcb441ec95b37e2592a38aee0504cf76cb2a55e5671fa5335a5a400c464f3369fc9be7f78c89021842704f6781cc29cb995316b508e91324067c375901c021a4a28f96c9916ec7d2f78736f434062d7fe454bb5003c66fce0c04f5caa9ed6edc697c84f13e9c274c7ffd7cf2a3611510f3100bd5dc6269bbd48ff0cf994840b549dddea6f74fdf70aa98b3660b2e7b5db04129c5bcabafdf4caefcf2a623ad8b8f45a9cf644ac964bd5201e868e3a29348f0dc216455f4db08643128d33797e5a4daebb51e50ab6e56da35c1999b5ddf2efe26b32c570089ceaca6dc512113b346d431c44daa12e1d512ac311595798d849f287ee66cd8414cf1fe5268e06024df0358e33da74092c292fcf777b1c277adda59a16e93f19d6b94c116585974166a47ab53f91727b5e7248090f2f692e1b70a10114890758db86a8590d1d30d588a15571b01d07425f146a2d1ae0ff325206054ee53689709a13beb04647c62493cf92364222ab2781bab03d06cc84ad9625e0a7204e9f7cae5446888ffe25498e00e866239826d6625ba6c34ea96a140c25d66a60a201ab870b6e0b1e47a3d1b3088fb9f6bba7759100d906d220d6f409e08b4688ce0e7fde93512164d1c430c082abbc204b7303c66f49c671967fb24c0df6c6d65424604d159ced5ae844327e4d0b22caae2e3d1aaf0a1b3ad0450e605b59e40d31fbab0923005c9bcd34b6c4ae7d50b0ba8342f5738bf48e2e4b7c9ea33a27c31981ca912ba9f102c0da18862f0bbb58bfa9a233e3729492b2fd082855321b1188f5f88616c2a19d799582871018f68acceefa5800bfb748cad2836b6e56db4472b6237e6ae4f580dc480b2f5434acb149c09964908d934c34f74ff680d28593c58d5db145d224fbe3ed931b77548c73ee168656033636649a449dd03c334c24545300fea49389bb59b1b6c23672295b49ff47842c87754b9647324515104cf27e4b44fc5b894204dd3d3690180dd16b7dbc655dbb54585fee9d0dc79d9285a1c6d84dde9e26296d1c2c8f09e396ad9ea1e09eb231c2f48cab1c6a9edcd3c441cdbc375e172800055a9f4b24ea072575bf5e08ae9d57b2df6de3e2068751985df6dd09d380bd8dfd1ab0d3443d67857bd726c64bde9dbd1d9b639ac9d6d5dbdf027847090c18b2351519ea79091457f5aa8ce909518baa71c23ee677c234302864e8a1fce9cef243c07ae49669ba67679324c05f9545ea837337a86575dc7dd8df0c39a44195438239cf9f35d517d3367ac77fca744e016ae992334c6b21fbd845abc0f11a8a09c08c6bbf116241d497f396ea892c2e9beff2a280e790c8147349f2d33872fbed3ae9c05542f1cfa54b2fc2340985d49597a611e94cb2c3657731895867685d1ad801aa7481550a7e2129fc0b9f8d854005bdce5346126068f5adfd70b46f8459168a0a735186f2561e2cf0bc49ba91bde23dd27d9afe0eac52652f71860c8a7c953734e9b973a810371bde9d04f7b697ea5cb670df49817c32f96d53d2ca94ee72d3bbbfe2b07c2a6e49ee742ecac986efeaea32dad5b4f04ef120a6ee145d879d7830e5f2c402817a42cd80fd2d03415bfb684346a8f8b880ff0c5e0ceb872affa3d22f700e2bb4eb524806a9e2c6deb72b41f10626af2d8e49fc8585612f7a2a73bd24d4aff2a87d6c65245033c57820b9e459e0c781dca745364c6b6d9d36251b7d4d6013cf8387b583ec0a12d01fe0c1064b2b319b0af74839275f284c7fa1bcc22a65f53f9611fa388d3726354f0e6c6f5c6bd003efc376b183a90016b0a6bfaf0f77e9225ad9474bbc9c2f5c7bd9724833c46b581879388bb4bb32f8cb247a6378f715bb455061da15a042ce3f593ae32487114e3f4251e86c4096558e38397cb2cb0a28bdf71f15079c8089049ee90e9f3cbcc4df44ab51bf35dea5655787b06a19c72fefe3bcb4b27f8bb3d09e816fcd1f2e157573c981df32a7a33b7d960ff391868db495a88a8de052bd35465356e46ac2bb83489559f3d71c758da683b53900736cb8b438850652c7471673b01c4879dd50c94183fab232cf65ae830647df4fa22ffd779314c1bf96406a9f23562b9c3def15b62efd664351e32eb9d18c0fe18842fb20a6c1f1650feae6f61ae7ec1e49b677c66bfe75318cd4432f5f69c03d74beae8d226369bd0f8e99a77f0a0bc3d33898f2f4e873b5282425ea083dd6e017931fbacd160cb003c9a72ae9fb230cf22936a5bff07f5c134ce1d4ba62b4714a36923f2e06091ef6ad973d307a061c9b73959397939e394c9f8e40a2c3a5cea729861df4e85250c559af54f968869c5954ffd8a284dc3d3a08b29a7457de15724f31e811857b8ca821bcfa25c7ff6a936bc0cdabbca05ce0823ee9f0573775b0bbd44c1be55164eac296a7c92dbcf5463c267a2a494a106c618a6bfe47be52e0d76e014c6c356b64232ebd010198564bd9641459bfc92f1933ebcdc3e4306a72259af0f3983e7e4e725593fd548e8c7384655d71be878c59c6846eed4b7a800da2a2bd52402887ef22aef5f8211360b9aec6061e40402e101c8afbe4a94676ed457f2f7193705b4ec1f02e7df3f0db5013b6117770d1cc856156456a777b9794863a5d9abadc8e214ee230d55e797675a4e47609d1d1789248bc5afd88dbb8f7ea59306f5a28c6edeab6e58731288e4ead52245e1162f6e69b0f7642cc878e0555ad1591432c74d6f8f21b66a03ca84c989fa0311152d3c14f348cfd9a5af0dbdff90efa8909ea223b1f9ce91040e2f62f1cc0fc1f212e38a12457f768c58043d04da0c585b7862089ef0a3e1c88b5af57973bcc7dd0272245aba0b7fb06ec26ec5f62c4bf2757e60ba4acc795ca13516dd6132c0fbd453aeab3bf5d58dbdb87dde3356afe56f3723741f211ba52f9a2bd77b0b8a1e0d56ea59e9c23bf0b4eeadc6cab0357242487a45c53dad72d613f12d7b27c88822c00bd38a8cda8b850cd3bf111c930d7d594587cbffba1f72def706a0db62c24bcd3b1b43ddbd2508f6d8144b270103c7c197136c1cefc17c6d218ea59e027d402f15176a39564c31af3ba8ad64bd1f8bee34b89ef49eea34bf26ec34b79788a3dc2ba65499f79f13d98cd28086876fbcf01a79380c3ef7ab78138d5040d6d70652818d15da5aabb234f29065172509c691f5a2c0ebe8f11d8ac7b6710cb494bb981032817c1a4c283fa60327e8e0eaf704a9ade5bfdc0135e5756f528ded44e0da4423fe0938abde28763cac7e05e702c2cceebbbcfa6b1aa124b49deb80fe5e087f75ec1d97c5e01f435de5ea66a05555281c30264a2377c232ffffe631accd1494ecad617f8483238306ce67d6966cfb3e9e57e274e9c5bfcd1e52ec066262a24cf698c01e66e95dc015df17b14367acbeb288a549ff98c4795bd80ccbc16d82e47460b802b6224e16b489fd514674d5115f641b3865b5a88deecf268e6f0d508d59baf1a055ece3b9b495099aa0e65dcf323cebd9ab258ab5c8c49c2396088eeb0e4f3cd1144f0c6d437dba6f0306be49da7d196654a6fb71a8696ea17b081d97b33ba04f9aa1140ce31f513a2becdd00810e133dc10dc39580ec62e2259f939d24b1763ddcaeb704bc6610684c012b2b04c0a260b69135c72e013a070fcefdfed779629c28039fd63ab456eb8fe9d236f5492cf4690c5a05821c86f2e9fecd2f877090d7bda1a098fe38a1b69ff55a3d6c70cbc524a31b1c9199e7cb76a05599a931df38f3a407741788b2454368db95aa4261c17270013261c3dd7c67d9ef17bf916c70f18ac427950427120c23fe448d9b2c79e313123cdcfc47355403257b6aa28e13fb3078836502bb21128c8084cf4d46a35a49c4881781fee8bfdf71095c506d1945bfeaed82b46775c0be60441da63c9af0e91f35ea759fcd2cb909f90be4485f5f07a6df72424598b1590ea7f52c15dc62f87cb6d34acae040e2def944eff8242d171967149fd1179c7bef825dd22e8b149ba054329e885efa4479aa7e71568c6d02e1a7befad4044fc14ae261edd9ed9e2552a9c922914cf4f3a61f083d1321d4249153afea9d73be562f846ab9feecf193e425993f66f0baefde6102e7f74db15e9b36c99fb8fd1f6d445c5c3bd69704199b8c02640f56309242ed2acca0e02a0ec7ada2c6954017a8810f8cb88c9f15a34175404a51cc0052863376f4999004c7fb2ae4eace5cf253b2788029a0db7b77cccd2ca2d66627d0ae197adf2874f80a03b2f677d777f6764d278552f0c40648545257deaf7b82617b77a8832a899f844a6002b1f23bbc0f9ddd0c6cc1faee634e196c1dee2678868b99590a2b2dea869ee03c3a38539c126711e48465bd56e67209ea69e2c6aa02c9c0a61244a728d34af4870d4af12bf84a6e3308dc745a045d5e29cab77ebd8664a114855d9da3e70df35ff41f4bc9eece5352117a2ab1dc9326b2dab3b5281ebfe40d42249bc458d1451ae1f5193801a8516977990cdd6a54c7e2ec66981ed3eea62d356993cef627e873c1fb194ec420b1e4ba5feceb7f2777e6e379937f3a29f75997a25826c228ee6fa4de8caf5da2ecb63ee9c1c7e208c3fb4995dcded9425dae69f8222bf05bfd854da4b69bf54b306b77882517faa6090b5812e896999e5036739c0d9f8215cd208f9b61c9e534e207fa53d5ada10cfd8ce9c3f4edb45cbc774b2d999f33c7ae6c06555a53376e16c194f1358d0dd928c1962a7d4ada5482cd3b8b2b2eb889ff7512b1f3b44118197bdb67ca74dc0364346fd4c8776d6bf69101d58b489b5bb897201180d67ce9e81cd2c2bd02bc0d61970e7e5bfa1d1e6219bb396591335ae139a8a3da29d853b6b29e835f64406824e505c8827443b8827c89ecc888758718e06f93dfd6280e6a606d269f96d1d183d9d2f8cb1ab27b0733b1cda954a4851088f59beff780271e24f0849636d05caab7df508a38f92e147e434c611923100c58142671e681f2a168247ffce153db986045eb56c43deec4a29a9a2be2e8de689d41994c97fb06f667481faf272573a3b949038a0423d0a2f4328fa7195910111bfbfe6e076b50d35d2a613308d52ff062d4bbc54373ec2fb0aa725a92822b07a8406f49b829a0238a3be02d061483fcbd53336a957a965fa5f28a2c1f074be21d33fe513c6082850311f3e7c6aac51644ccc321aa45291cb2f96ae8bb2d074a97320c7fd30d25ca593c26d042b6f5e22c0ccc54b43698c20c5dedbf45e1437efe15ebd117b7f87a08a69bf9850921d7643d44b35ca212a15ee747c5c39d1dceeb55c4c7b98d5250b9d38e9800d724c2d34fadb0c6666d7faee8d4733f8ece21d4448de84c23c0ba56c421896703ae41f3f59f04a5aeb1131bb106232d5d8b7087ae9f3b24f9ec5aee4ba1c824c4af49b52d5d285e52248b65b8789864790549ff783ece3e7ff2876319a3f8576bd8a1ba8f47dd408955074c3c3973a9d1764d7d20e7334454abcdf1cfbadf6683e665d9de19a5c8dc4c1bb45f35bec348d9b2f928d2fe90d82a687fde06e71d9c2283f3910447f28fb151a5142966286432c1e1de6d485366cacdbffe809f606bac411d52994fa0ece3a5135b93b931f7a9592601f02fb7c055222686d1386a23bcb513a7908b0f2958077a9ef6ece7cc786a9a2e5454238cc0c1a7f25f099e20734b034c038f5bd727dd443c1c9759929a7ba1303e5b85e176b94e5d7e0ce85059449ee6a5321311bb7e0c7d2936848394262e7d406eae4ecb4d9cbcd85eadf62e31831af30fddd09eb79f8a13aacc9c9096108af8bbbfd53c73bb20c4c34ca94c7bf332f5052c2c1a4ade2c67b60753830f95cb4bf1a6bd4f558353a51f2fb565dfd9dc8db7035fd86b63576884121410677278d1c7aa457cd4498669fe673d23ea20abaf0dcddb094100d2441dfb116785086d1e76078e460086f7f60de6c0b881595ffab13ad1b26b068674f4b81a65e9eec7393a9b47eba142ba8e9e33e5445cb13090933dd87978623a695c757ed424d319fad4a2fc2cb160095428c7a88b86398bc76609bc2d6d86c85e0d6446cc5ba7426c0b8604b6e0a9d090c5e35e59df7c019220298e6544241474a32b3ed1c82056ae26b474330fb355dab30917a89a666a0e7ea3781267b84f341fde918a398621da7390a0c5d58e2aecd4f65173bf7865c17e2f009739e4575f648102928fce2cb4c46efaa2fd4fd4ea2d372600aa52bf5ce378a8fb8d982f0fbb27f325410f51d5ed9f67d2065ccfc26a4536428a8770d3b4742c252d10e74f5098d049d63a3eee478e59b2a28ddb83593b1af0e3c430b5bdc5bc84549a77deb287952f6e2f8a9530ea3d9a3727baeb6a121fcc0d49d8710c31f69634355e0a57606d9b3a1523ca89e617446195c7ce36747da0b2a90932752282aa72f8fea4159bb750000d3ff5368554d46e011bb0f51a6a7054eadd670f4193d3a54f1b81aaa7ed7d982e23c0a2f32b46e0b315a606c2a169c4e28c17b513b0a5da04e54336652d8b71d75b8338f721bbef468c9b6ba65234acf54b1d86b57d49131b7830bc2a6aa50d49406eeb6977ac05a9f3184a9785590717dd62669a7cc8c378c525a55f86de8097dbc6afc69e4540ef3b046d96689aa322880c7b63e9f45462383e3ca4d7c0f5e794cbfdc5053ff3f74231c3081d3da6827822b0c33328a1c4a05f328ad7c229ff30d1530ac66825dd0830dd76eb850626b9203574bd2e7c4f2c911cdd021eee1f0731b2dc0eb51037108172ddfecd0fc74825fd38d31b2960781cf07a292aaa39837c1ff959faa32e943bdb8d09ebe18100293ef5116de1bb06568cbcb084d5664f34226bbdd501607e3c979e75e5f0ba46cdf5cfa9d8501a9f682f6e8af97ebbbef2497aec0d008d4628c8eb024d8255c8cd5f68315e188067a6fe57e259c7635392a6a6b997ab1f26e5b5a7f4d5353ab212811afbb54c69bdb18056c42a65127a5a4db52be5c17c49b6467b304b762d25b5a2531e07f5c3194723033d5c21bfd4a5d8cc77783326e9cb8b36f14b0af6dd04ccf6a6e091ba8990b5ecb60759b5aec6e3a172cca9ad74ef3611efbd89d34bc34ed19cce8f4e86b2eb5f968a7ff273278fb34a84fe7639ee1c7b1f57de448f553c1fd587d4c234b1ddbf553099d445c603989d7cc04a2f88b77c6e24c91e1ba4ed1fc09d39d659e4886ea405bf180734e6583ac8b1b8d4f3a7a7137d5df2f1bb7cbaa4cb0ace89ef4b454a5ca1297930e7df22db484a457b2c97646482c3b90a4932fc7e88505f9b6a9dd1fdffbd44d636739e263185f351ae0047f6740f203c75ebdff6680fc3fb8ee839092ec7070b08426f31c9bdb0853654a41c42234854693fbb6453428e0643d934fe9aafc29016017dc7a3b9ecd8f2ec807650c23da04f61b3cc64f1111d791bb0863ee93ea71e97863405225767b4d1980bd51ca67a97527700ad0f4d12049dad252dcc48a561d9ac9d6bc64c317405a4215e1629b074e769f3b265dbe61c66ac100dc5d6522358e87503afba0dca67a44a49dc4c845ddb57d3ec4be7cade01241f97d377162f3bbcb930ff600d7525df8d4bccbdf48cf52bc54735a8f5c876d4e91959a339502eb81608a89f0dd6b8635febaa3cde823d53e1a409388941cfece9f436c4a0d95d9b63d6ea3614757a42f4042aad13813fc30f5850c9080f324aa61d3d19551e832ad698aba5107bc1d46347bffe4c1161d4afab2a88dedf8a51c3a0e8c427f9000b3481930fcb3794b8f0b6cae9107c45628c5a1eb00dc0c225181972a686461035d47903d51b9ae861c62a0dbb615142e47816b0a074a8883cc2392cd65467fccea698d64602ba746372cf6ea702e4e36f1803cefaf1eea9938e4732df39c06f83a1aff41fd4520fd162a31562a0cd81d7bb3a0a1157cefa08f69c6610643cd0a4debfb4ae8a41a05dbdfacbee0465e356f847a53451e9ce965826c17e2bc6abaf757f0fd82507a116f5fdb6eac34cf47f94ab68a95ac2017719e6ed925cd134fe93daa15e384b2ddf9e265dc579e68859ad5b514a53418f6ebc723b3c32d1cebea46f7f17f457a30c27c5fca3cdd932e2813f0a299834bcc32a73d92231c0aa7f6710d5f6779ad4c6347e32e9e290256927b436b250c9cea0d4286773269a73e1ac435b1eb525c60dbac9ef9accbb2a6f850b8d202f1657e579e2d11d86e10a4311c49857fb2f0187e971c120e2cda6015c07c148119207a8038683a1451955787501f5a3209173748d1666148a7dadc1c3633e08c6981debfd0ee1c0194d16de259c9acc424be07685abb41e2d4526098b4ab3e0baeb5945ef0819b6ae89de5c98ed291c55fddffd82f8d21a88e600e00fdd6a8a7c2d8981021542c30b5d062d6a7e3bac076f71877618bcf981e279b3bab17787c4669c76346bc937d460bb6dce8db2f018091a1182fc1620ff016f010a4eae014584519a7e54314581ab1ce1ee8ddf6acd5b965cafe75c38e9cdc36933b16f7d83d56b1045ad1f3d015a675fd8a572ae1c971aea1af14fb3c715d6d7baca432bda8e7c38a568bc12620f33d36c2f3e221e1223cabe84c170d26d02b604ff43e226473bfc1f0a60394e6fbed07c3ac92663c7d4a88ae2a84a5dad385dd4a8550dc67d6e60812d923a2ca24b1a9b09b28c37d3edb4009c897cd86ea032dc913415370f641ad5ff579da2d78ca37492e08434fa4544211c2a2167904d25017b4d112fc2f92baec2d2f81abe20e6770089742d21df57091d9a403ab7047eb79a68c9edbd35c8054a2e4ca00c1f995e32fe5641d285614a2d892874c90f33eb182452600d6f027c82dff51dfbb41dbd395497c6bb01edab32ed08557122323a913ecefb22060ad3e732e495c7d13213ded28bda2fd60ebae2f80ed7a04e52e395b11e4251adf4130b2bd95d32e3c1f91938fd98a392ba3d496278ad0609e0b02a9c8b91504159ea14afdbd400a2d6f19bca636332b3627e47f958cf9d3df55147fdaf37bc313d6a3a09304b7cee1309453cc42a1a1184f6108e0c541f740f0a5a3e32bf967916a24cb57108f2bc3700af5c56623de3fef6aa278f6c8b04965ac38d1317c227e4102c7fa874321280e0a29b5f1ca14e5f8f728a35b2a45b424e5709a08187779f564ef1726a141003f59e5bebd5f08677f3970e80d8724f9c5adeb849301279873b3d13a0a1ee114ced55144ba1f97eed809ec6010dbf83fc5f9458f810f24909791778d2f21fd9cf862e4588b22d299e79dcf595f59adec62cacf397989ddd46850c9d06ee88c9097bc33732cc2348f881ffd65d4ad80ccf0cc84ef045ea557e00e29716df0e365498639231ae14cfb0f486b2407e8e16195a83220f2f95ebd349741595e41abdcddb91ba8b735fd272274445e8c5980368b8e725cf2abf66402f2ea8992e18b5dd1a830740bf06086dcee176731216904ca1f7e8450f6b27a6a2936658d4fba8294ba4c4a8b330d8dec659605942e9f0a52a277f220d02be4edcb8d99ef0b8e40dc012040af3a5fd06b37ba236e03aa8c67ddef94667d0135359c63b90dec611ebc42041385355b615fc6a0c7f44f469af49fbb226a58523b0b27b063b81a4e3dad3d5d28081d183040120924dd4451012974d67b3e5b4410a60a9d1e17953d49d486c2e3e8fd07b7573e692cc6421a00ec91a21e32757f56017b6811112d8f0d3d7d2f9c142ac28fc25de6ff07fbf5ddc4199f21835496035a11bc6de67bcb5d2422bee7e13e2f971d979727e641af1d0167880fa58ca37e5a6e5e7e41b8cfba9b84e8a9ceb964438e901039a20719a777b565c7c39ff4c3c3737e8df5958f3291544955e240cd48910102f5213c776aa0f4a2f2ff170a57e7bc6eefb953833fcb6cd700ab6300a3ee51780e97663d4df085ab4170589236d5d5c0834c2c2d221f6db3b343f0f909f0ed921d25252971d4305839bee19bf06ad55355a109697685c14c59d5a5c9638b1ed589859e0ad44a2baa94cb9d54d08ab25c8a28ed331a9a1544d11b6eca5b6023f4935c42395a6d05e189ea3d6db6cbbcf13cd0d9e88e015291ae27f3a00487b8f0c843170ed1654cadacac8179470696f6a43c9a216769355d8fc0be48f14a4f018d3ede31eeb264b237a99f838d8d4b26bcc3a8b56414c50ceb1042c69b4144bf7cbcbdc0d9a7e2125ea4fbe2c7f1659a3a75c8a3f20c4c4dea21677dac5cbda492be57ddfed2d00bfab9b100a6e28ba772f5ed4d130140f5b7fcad20c05b1ad22032f2dcef91c92f538787bccfb633e685a7823b3ff21c4a5772a683487b928aa81ca170e46a5f23df080f088bbb6e49bb52033db3dce2aa592e40d51fbd883157660acc1e33c32983e1c41b63845bdbfb2524650cf3ebb054fd6b67e12a549ed0da31dfe5abfd6790287a705c4506e356308a1f34450a74c3a51ffd57152d9a38446e2dfa4cf578871203fcbd2dbb191fa440d5e13eb4fba67f3a4dccf7ce87bbf5e35afa342a2230b5688f6b2b6d46ab24457cc1871cafcf0a108861ffefdbe0f159714cb3d96c06136e69a95543877e97ed01b44b863b2ea0eb1c3eaf2f44395164b5deab98913c50023083207d3fb9728cdd66e0f18bc7637c9a53eec7c45fbf0d6cf4a66c40a17ffe9728305af8a73ce2851bc9a1d60de719f0bcb39998889d08610947c02995596482d63f069115c6fbdd40fed573cdef624e4172922d3c3b7e79528f2f54fa3c1366f015eb237ec38eedd6b24e2088e4c6ffef11044b211564f2dec97c1cad81a0baf7e53d20d47a920684cf78c2a8e9c396a7102fd902818538fa6257fe8e82a018a277a200b7d623c4a4e11571565ca62683b03a21e32ea500474e2bcd6a1fbba3c154c8b5c226d2ea3b5d5fb7e36126aebe1c65905e968e318f697f7eb94cbb9ab346a1483f0006956a51e61613e13f8a782f7a0f025ec716236c226522f54e7fbf5cb51428d2b629819d829cdb96c57b50740c4e396eaa0536d7a32814d4910bb267fecded0d6118bf765258c277ff4bdab746be09ab3dc201f6f7689d3986498b83c22ad25c173eac39cdc930a77e1bfa3680bdd7b61d3b44058442e1478f6ac762d45efdaf30ac9d2b408489881565d103a700b8133f9b456ba60d0107c4054ebd73a0485245b5c0208188dfcee2abd981f3a6f93340596c0778328dcd09d94f856fce5c4376fd9529aafaa1d115efb500d5cc46e3072c0a1a3d9d1a923ce17e5a617f810cd5361ed6523fe09d99329ced89eb5987effc41a4683a454fa76b3df0c2e26595498fd6b23fe7c79908edf89de1c63981730a1c44516e065029e813b5b7552a0afd3ac74cf81070d90bb5bf78cc63828beca13a0761b26e7583289e61a3714e5cb1e7ff97e1c8b357ea733eca3de145cc35b01ebe28d4489eb81f6dc7051c6f3ed95c2af2bf7f4ec7585943e697dbef511afe88dbe5ed0e9dac1e39aecb5e5fba8da3f90026df4aa6faa13bb8d0dac61ba5c67131af28f013588b1ce4ae9bf0296928672668b8d3f6a120fd4ffd019162e37ce5b56a1b5057654efcd9d85718dece6491549967b7d1cd89dac7358704eb6ddc57e8e3aea45fd05d48e3bb9341c0e03cd25b58263de6bc11061fa0dfb5c772c038da97b27d10a5e462847c4ff50ef9a5f18647bd68a7fb202af9cabee0c7fc60b248a9a62ebe987751aaa7e73db0a60eae3026024700a36f95e8fc1bfcef1950a06debf069ea38d01e2d7cf1984338f8bf25843fe4d52f994114232c9a86741b42764873fedf3e1b397c435f4f02b6443d9dceae8e58c4f52523bb84226efbc3be61b83137c43d5c79e0d425afd639fb0a862517fb667aed9116f5c87bef9b75657b4b74ea91622c3a3711c28bf9c06dde8772685ecf12fe0e97effab6eaa2a52e5be1b3d6fba65de6d5bfc3c937de21992b14cc973ab1198cc1dd5657f9cd036a99c1d3590f69dfd4471af49cb5580ec94a859d8512f36b101a3e540b13da8fd34da1df2d933af38eed018efd65fb10ac3a1177fb4caa5e992b28a26494475d4bfb1f0be89d4e2f380deac2c02dc4a672be6061d5e55062e8ac3f533b79e3f72e6b75e701b7464889652f41e2342a54e3ba1d9c659cb294aa336a8e0d177d07b714ba42f0d63c37c96820f0ed19a1f9336b2f538217b7f2953a2fc74df8f38f8d33cf31462fa744d21b42dccfec998c9d83ef5999e169fa746f39cd0e7374ad55346ef91ed514fc5dbaa15641236f69531fd280db498c3f0ba02088108b21d7c0e5a30acb17b10e61c86a017d4bfa2070e1b111533bc4872514e1328c5968b754b7fc407daa5d86040723baece7008068161e6c56db4325b418f66328e24b51ecff4abc11d6cab9e9fa76913fb9e1ccd5cb312c8cbf2a5ac0809fbddf70b7d6d1f925a1a9230f05873af3f45d185d079af4db42a0d086ddafe89a2905b600ac5eced39f0378bf4c11fede792187e9fa694411e06251b77fb6a427f7eddd148da10a4250acebe673dadf81d2b110f0618ee7656eed502568affc88aa0103b65a8d531ef31b2a8dda86f6db5fad00c0579d52798357acabfb5dddd0dfbb2d955757643da1edbd04e341e6e13dbedd8a227d92cd2fea14d0d4182bf2a343c3f50e60cfa2130351696cadd45b110cfa3661156a2262071a1bdf43d2f537a38234f245ca56ff7ebf2f609003c9d19403ede9f80676bd5e635f39e1b95d0baa9c692102ca965936a7b91cc78e6f8cb1ea41bb5eeb7ad4279f4f4a3550d3c28e9841c8926ca17da1c0af0404c0578c43eea32b8b4a8a9c6ae24aa1ebd8b0811c38335bd68ea8f533b017f927737e624dca2bdb167a2521d9f8a2391b4abf705c731e7913a5249042c2b0d2216a8a1a2371d597896094f5286061225a035a050066782169efdb5074209504ec5281ae5351e26ed8b277a83d3f74d7ceddcf0b9ba891909a90bb9fae5cf5fcc880c56341cd14a486c0d62735dc94d11153ca5a08f0d036bda582c3671e63690b17c6f77c4b86e75ff9bcaeba657b127379ed45f87015a25de815cd94580354589ef1383e25a3f80ba1228f05c55bb4c36b86305b7257fbd700889a4ed4ba156c4de03b83438ee10da8827c0786dd167710d9058522f9419551867a349442288fcd996f1b965b1f89f7b25aaafa5fd5a7f5e6830c27600558e76a0a71c67431eb69733c446c440ce052db5ad1a6f6e338e2a511abf48efa44f7950937a73f696b1b5da0b1465589a76e61fee3fe6f5e947fe8150aa78d04c54838773e6d90df28b6f9cca20233c946153dbf4e7fe89b35e0584009f9fd5a29161cb6a29b7c289efb01e5781da2feeb70f1ac468bbc3e12216b9e1f5a876247516936b2c0a307bd78e1bdbf5effbb1a7363db9501a6353c438d61b35eaee9a2012cdc25e54d79ea761df21620c6dad25365b3f9b18c974217e607da609bd4f56935972737b1c111b70ccb60009d66e186cc051d9017cd045d434020e64245107f18b5b7f12c64a4b59d9536b0a8b51361a68cef74aa72ffa6801aa3a77acc6b5d8ad39c22783c951320ea0d2b1669ae80d88988d5f974a0815cb9e6b149f551d227a6ca4536148469a093eff1c44a4c5f1068bdb1c3e09143d6aabc3c28d95d3b4a592b30c55889bdd7c2af626851c749efc3ae830b3532c8f090245c7c994d22050f4a733b7a81ca0ac6a5afc8f4f09e9398a6137b0727506a7520fbdea6c1ff795bdbc61c40f0d6bf40ae69f4b85345dbf092e3913008fa89931da854be7fea30109e5c21be32ceb406d946ca76dc909462cd8265d67978206cee59f8a316a8814baa72c4110a4a092e757fc129d7b06b8483d0136f6ee856af8db9b0ca2b554c227acb11de5154181b2741b0219dda1b36c2aa7e77c1c0713795b82788c9b32f49641297c385f12b527db9971f4f1360affd0a9de7e75cba7b6277638261d2108856b018e22c1126c501bdd5cfcea8144323d1d2ef36bc49cac36c5fb7aeb004dc23c3967457ad9f8c3cb0e4374d9eb1c4738150c95a3d1bf3117e836714a34885c8b907fa510b93fd67da4ace26dadff9e406253c43025ae8e69a49ede9f61735947d13212ced23a1699c7a1ed13d9919e812d01f6a22f5e6464a4afac20dc3841fe95411e3179761cb8d42d47fd542860f545b8b4bc4b95e29f5a280d4e72fa78551850a8547596a960c3e2a9ed8d4f361a4c3e31fbbb704ea1f68dbe34e64c6d856166f38f81cf1431c856e5d93345fee56cfd624feedfd8e083a460a01fb78c1fae704fd1916a0addeca1faaba17c42e10784b8aa6424c5430af8d8b43c3912a9f5bd517550459a93aae048bea91a2d946f0458411358df44ac5ac79f01c19fd44d839d9c8c5396a8ccb6c9df607b4aafeed3efa37fe642454c5a0a54ccb4a86450593c423517419b02c65df329ad1b9a5fec16136e0e71bf37d253811d6bac00c2bb8694e22d4cd4913a297cb4f27851ef6e3dae7463b756b45ccd39fcb34087778a9c52ddc226b5883f00a9d842c4bf17192d605e4ee6fc0fd7ccf7f54beca6de896d300a179cd2ad86e3b03bc6ebf878d419abe18957a802e698f54069d1c79de151831d01c27427c58c926f5e3c04fc2942b6d1a44454c5703d0993362890769d32b9016c37b680340b89d11c041e95c71f3f9a836d453f217076934d898df52f425c69d3b2dc421170c7c2c7049b0eff275089dd0ecd0fe884686a4008cd80ea44a51bcae0c4d21c8b4df759b6d780481cdf23bf280408777206d5131e6c068569dea875927ba31bb7e77e8159dd7ebceab484081539ddc7e65251bf636ce39eb118da0e3c5e1857b6abdc22daa68a981e418fea6d097a916b4a69b01c549a35eaf55d62c35ca21e9f84f9d2812f17c0e03a926f446259d59af1e0489165982d3489ea549e36bd3fd89ffe5c7ab539388831d0f2a6e0c35763458f5a397797ce1c904a5941cd729125cd2c3e20da2eacba6e46a2774c9d1d5d3ff6afb6b62146468692fbdde5f36cc423962c258a03e91cccf4029327adf22d6042849fe05b23a055085771f4a62e987e378b82d70462935edb6c468bf2e7fd71360a19b781da2fa51e9e22cac6b766a14ff73b2f15ac1219dd8916cea0cdfb74ace541c16f4469084397f1404ced2419fabdf194a80200c9b8dad5abd7bbf1e7c0ae6c9d2c1b1791241cb53e67395329046243cef4c1210e54330bea068ee9de71712a70a382d385869869a93c096a58aa1a02a8d5ed1f30a63aa8b23264e1997730253aa87a103fa990cf26f84c566d6d5133bf00ab94f3aaed0f1ffb20908d605eca1eee6eb06cd1175ac181f905f07526e37767c5acd0e7196dad5eea39108764c5e5cea82e467c576dcc5088047f0debc60b1129582d38e3589aacac941c4b1f4a41a2d957675d0feda1e677278c8da7afda496a0a7dc743d1580195bcdc16602fa3ea95925b59101b1375c64a52c394cc66c03d0b685a847fa2f49a38ef186bd9aaccd4b7194ebfc5a6157b1d1631a1bda60bfe565c4ac64edad5f00e984b78f4751d737bf2a097c6febf1ffe03c5f0759721290f2ae17c52bbf094e94f5436ff5dd3b164b337a4d0fede40e73c9659ee3778e17a8d14effc8dd9c34a630343a5eccbb25600b9088f8efded6be4f8e6a758e66c97c8fbb8a55dad82d193bfb5e910a900a925ae791311853dc441c255fee8dcb438aebb4a60e887178eedf59421dffe05d0e466c194ebf0c8e945e6994aac3cc8b9c00f6622432e8d6642ba5dbe652a9195fd4d3d7db52b2cc408b059d580df593d4609a43a6c12358bfd2081e860f15ae175b35fc9eb0389650fb77099a2e73d7e7417f116466120fb407fe3e9d6797711e2ef2db641c706576d5b6bd6930af02f16ee0b5bb4c1a5187faa5e68e73fe5e22f2abfbfe81c4af512030e7395580eef4b6a0747d5c8e14d02853d70576f02eab5f7c4ef692803ddda8acf2fd974dac14a27cc6d91ec32c114a1c14ea46d159b8984fe7bead76367285e5aa9d7cdbb283a0f96bbfbeabc19ba889f3ca770c4e25df0c1b4f5019d3629700b2b7428b9be93d673cc3b32e4532d447fd813b59b4e6c12784326a06dd20be27751d8bb046aa6fac992fcd1d7a5940d7e715b478cc52ae520b948058d54bd79e37c312f6e1c1f8ece4d99e404749dbcad21bf586ad0cf70cc6cd1664125002dcb13ba05ec23b9d80fd0822b9e55f2588fb89ac96d72e7291faabf72ccc7edec5d95b868180b7891ea1597cf1b29bd6e9f7532e9b1917a5fd52f48f4f8b6358efb7b5ecab2090d45132c65d3b738a734c8928d6ab6ef8a823afee0ba9351ab22bdefb08f1a054a4c136697caf26e094feb9e2735e1b1e5c6b1758810ecd6f458ed48e5cad820c490c4e4fdd60e9b3e005da88207fa798edb2ec5610d5a736d7f8962db1215df0740d66cf3c092c549e26637e4d8ad0e453fbca80000b55c8c97c4bc9faf1fd100784e8d163ec99442dac218c7860994e703f977fef2dbfe627f856f1fa7e9d776e90216911e44c139d224f8cba10354b3a99584b2112d380497e6ec77b088f4c2671ede6726549a87eaafca321df416a619d7c8274f0fa6e66fb6938cb7b7a81d5fa1da8ccd919ab63f7b09273b170c82ac18e6a93b6b019404f811cc6554e72835e184adfe560c7c1616bc684f0c42369a457383662f8b37af62974f18e19497a90391f73142be703b00531cd958afad23619bc702ca88dd95dfd7bdc60498146784f44deeb8c77ba82d52cb03e3ca4647010c41c7b3d0758b0dde9ba1077acb16b33ca8d0605d210e87cbdfd678b475d6ce33e02ae266eb74c0adf59958973473343596b6a4b527b36aa9243a48ed525106d142305529e3197db688970ae006097ede218e34fd433926c9147d67a01803fccf2eec8d8cf3e80016dadd5328718f5eb4899a825bc13981e5023e4e7bd07894791ad40e68679fb6aae2030c09fd0272448db247075459325164655716b491c8f11babe2d2ddf443f63aed3450bdf8af14461afc6a8a666781c86845ed01172506da9417105963fecff0666d01aaf1dcd9c61f62598e5240684730b9e748ff4e4c586f3c8b8ee470e770657de64bd014fefa8efa512858519f70c8be716c3f7890b815e8e48905d9162e64cfaf19f5487780668ed53671246205823e24e351ed934b97330ff501ab85f012f0a428f0bbed75f4a6ca0b4fb55807408afdf16a891b8bbf3b7a97b00d9bf64f12e51229843277a714f26166f431e67bd629e6a6404ed784a150deea59c051698c3735580f06426d696bdc43470ed6f6ba5b8f5d9663111509c47fc19ef328c3576ca62e9c2ebd6d7d49424a05ba9826b2b47c2c25a26d409e698b401e2acb4b934c8a14bfde5b4eeb36e82ffcb7432b9f3dbe371bae16f48ba679bdd182bb99001ba277de6b17ef922afa0ceb1bcd8245ef2c97b9277c4f832c0caae148212b86a43cbeb75479bf152c9790093569becb4a7be4d59966a03a8611af2cc64501ade0e794d7976f5f5c28f1fe7c0803353d82906459b82a3be9b35d62c6e509be252286f7235ae53c11d6e2eee39b590d0d31f054c1ee95b5ced7894374a67d7c40d7a80853dd594424aaad59cd0f8c018ea4307ca13e6e84aaf24ccb315d03d973da528472c6ef8748dcd173408a1eed78b4c13a1d6e9f5c41b07f41adc7a800d952845d60b4aef5737b32f233f1c18d672b86ff70866f02dd431dbec9ee9f2aaf2432e05026f1d26292f7d2137568de5cbf013266a25462cc54d3311cd90192d9f18a834ab238b8125ce07d42eb701b3a9a1d5ae10c46e8ddfaf292710d45e15caaab72aa8be2354888f71393f8f2cd4a72c58b57afa20be7cad45347e51104e2ac25b49f59761f0b90db12d00b7633b832dfe252d006ef43f301184faf5e7f3977f8c2ad5d89b8241a0d0434289df613345f2aef21abc44d68b435f2a1fdc2d4e6e05d2bea6fa3a56ff5ccf27f9174d1047b9f60202761e62080f1c99d06634809204cc628377f5f009758acde35bac8c13c206ac0b007f562378a23c0c6cad17c1bd9fc30a1976af719c0fce36cfbb6fef8fae76d3304e11f5c1b82c51fc6ca6079d2a26e1de7a1dfa6cbee0dfc85bb3e6902465ad8181961b0141e3c813138d699e65f58f7ef235841a18493d518dafc6c80061bda1d8cc4b7856086e53b4010905b2f76359fd4d894bb310fd3177c44b31f3e98bd7331093cc468ad7ce9adf4fc38e0b7e280d986e5ce5ff92a4becd9ceea184b4a1181ab26058803eff06b4c6d29981bbc0a20199716e9f22ab9dbf2760d52ccdb07f8914157c79661a00e841d8a4da47ca7d6ccfba1a1df00b0de7ef61abcb2e65197c9b00f6073a6324cfc445a4ba0417aee695d9bcbd09c44ebff0b3bbcc1caa06552372040b642e07fea4afdb23fc186a1577230a0bff562e0f2bbc4cd674ca8e9fb98ff8b6f340324c9860df67a4d08e9c0b0b7cd173b0bfcc7d77cfb8c4f17b251abc41755a2d75e586ecf5d49dd4604c931eaf111bd7e646b3be468b1ad06cf97e7d4ef44dfbe732e532f84279626f7cf168e22de95ee9f5d03c0cb5b412857d78f0fd1976b6d4ed81196dbed8f0309c7a2b9699e5db51b5c3d4cecd78069e3fab8aeb143de17fc89544b24f7cc28439579eb41317344a699d5572945420e0ffbcb2f34cedf852f5f4b8ef896a056f78bb7901ccca3b4f586c2def5f48281fd1a5075360fa1edbe2bfc0742e0fd5936ebd235de653b59202bb19553194c3bd13410fc44c3779d23dc8bbcc2bb68ab5876798b60f1c7cb240cb4405fc30e243616ed6d23ee8ac4fb65232b8b4e83697818dc9cee6719a660a7b69cc53111cfd7ecee14470db91e8a4852de85b071c8f6981a11caa34887187ab719486fc7bee7c267b15c1a22e3349d1049ecf28d3cf35fc115a70acf0ff5990aa23d4131a79a0b39fec15dff1705b8c26ecf76263cd84a8b9c2e08f93783dd26310d66974ba93f8ebe0811b3592a58e07e92934071cf90d9ea7c583dc3b294bf0ab7234226d2899e8878d139367668213f6c8d999948b79315a222439a56d12cf94b260382568347a18be26779de4f52d9eadb5f20769661e824e3a084a73f641870aeac0e7a00932470409c29fdd131646ac05eb2d06d71e37b269e12c28e0459df0fd04206ed79678a82d37f917ffa48a12c96aa90083c6f9313828626693515e57f5d0ec93876f7ef8d44d9fcb6797915f9783a37f2f8214dc6383437fd5dc7e533ff7a13d4b5dce917f17bc434d644a46b4b9e07bbb4f6fe79591dbe15f430d4cf49d839bc00cc79f8d30a1334687bfc0d5c83874c3ba2ee83d78667c2e505bb241cfb1418a4c5cf4c97b1371f457c20d41003034e48c6db1de8e441905f7f393fc8e88264f436d369fc6223d060b9e992023b0a99af9f7300e7c04252f10efec5dfffe4b03814a09e5f00ed60663983c6a097eebd6ff0ddcd432cc17953c951a8bd519feb108903c701e44e8caaa0eca8175c4798e052314cc2eafafe4e068b1c27699b3ea9cd00ae0113259ed954789872cf71f36fd7fb6f97bd8ed989219aee9d2bc77b4c674e402f4ff4f342614fce34bc093f9ecabc362d2000093a3e7f1e3edc9299279bd68e225c610de4dbee64e29c73532dc569519756382d016ed0ce4088743f502237a1400eb72c95ada2ae33e55746b3b4ea9e02e504af72a137837e4e6362603e451898256287f9c910dcec54204f035f9c76a96692780657f1ae8a045ef1382686a0bf8977061516b0f293267cbb1effd0c21642f83d7a134f9342b5e691bd62b43420372997a9764d137f39dff39ffe4aebc1e7ad55e34c386ee955806c9b1b3d305511550bbec18610f50bff8fd17ac28f4d1f0c21f397a5f82bd834096d84c6318cd9f789f09851555a77597be3386612f366d80430952435a570113ccd92a4cd0ebbb38f7684731ba4a5ab29f0e856f2e48fb3f12452578ebe82a7212be66110603b4d7fec0008f28ba478dbc31b27f6b191a57cc990724505248b2b71523dd197de31c2569401943d5087f2971b6126f3059c87a4adbf304f92d63cd1ceaad4e57bec78f668a10e790c645634ec0198cedce6796bab1dca4849a6d647a2cfbe6611b0bbd35e003863e8dee82813f80619a2b80820417d8d469d9c54a88707d6b4e1d46a1fff88757e56870a116da940201aab8feea564a773e25d39442b5f95dec8528fce3e7bd28597382f13416f5e681439f94e3c6df3b730128b7fd41b0fad01484b11886a6624548a820ef815d0e51144372a2cc44aefc5e73fe445311f6407775a8714bf0bc3a65d9c28595c367ec3904b0672ab224ce18fba86decc6d66dbc722543c3566e6035545adf1780dda7444e07ae7f97affb3be56cdcfca4167b9c15474005a39d704584b725a9327d12e6d70704f951c80acae05edca3f231430131cf7c0140f8f151166316149f7fbbb7b00ec7e00280bf39bfaace1f04d60a710e0fcc1192e236c702b8ab82baa33c1c3666951c9f3376747674376d9f3db982e949ddc75e0277d28149eb53c130bcbfb230636163bb9cf77485dfea84fc1218698187b080ac655309078ce77658a88c0cbfec8219ca5367342a30d3f87a121572af0c9050f7de1432bb50046beb76a13fd401bb966e19d8a8d4d94365edbcb8364d2d9750acb2660c115040c80b687d8ea1300bdba83508cf2987e56b8456d10d07148b25435f34ac3fa309d7c87ef567419f7a5f650174ed72eea1fecb72aa884afe8ec596b44088bef4ec1efb397bacd290ff975a47f2a5bd2f643e559a819d9b8cca7c07df966c0bc13b5496da293b8cb6cd79f63357c83e4cf2917e6dcd6a3fa063be063fc73cdb2f7a9c9eb0c574c4bf57145d429267891ec6b3f47cf750b0c715387492101631e2842e815c0dd4eb1fd8d5070e20cd0b8ac58f83ba02fe7f2c96f125f6e290d19cd1a92ba95e11c1dc303c210d499ede268721bea0c64af638762d2255cc4d7278c3b32e823842243e043000a20396bd5c3f1f38b8a14fedec7d4c272e3f2025a2da88c2a07c9e311eacc751362dd97988c3f41a136669fceedc190a1db97c7d98cd568b9f31995bfdbb67f147f7a0300c87a094e1a2532048ef7f0b140d92b218f290ce20cc043c20029ac308e891b0889f63bd1aa3d583b869c464976a4e744a2838435e16e8e7499e448ad0689d79a17b8233d0443778142a799d28126590773b2c245f1b6ed688db7418a5679758d85fca9db16eb08a57262dd36835389a5e0fc84fbd5928cad1c094fe8e65e46e939af68e8e28f7b0eb3ef86e768624090e69811cff2ddb082a75274965cc38ad12af58c8ae9afa2a4f6bf7335f94d2a832734c16d1fd7b34552a2ce6094345f9876a489382d6bb79ed11c202ed0550bac016f5996dba58a928119b3fa73c2b8d4ccc899ef760be9651fa02d79de7d04d4976037366fcfdedde86d1d9e2982718ba01d13e918787de8dfbc39f04a0ae8bc070d4a11d0c1b6092c676ebadd0e65bd6c9888b712c08100933304eb55099e241af5dc7e454aaeb6e2657a4c2b029dec6cdfbcf54d950ad0ca9ce57902c99820158732058a1fbf5322dae7b9ec808d6a0bcc64f1a5cf043528e39508d75d59c3fda9eedd9959992e92cadd490cad6181efeeb9fb8fe695b676c84223fc1b043e823251ad74f38b06734f0295103158ca0507dd4985780c8e275ef6575d1f05f0f96f40f6d74dfde3f116c9860ebb2f43158f088fc2c960adfd8d4d6e35c9c41665a223155fac733694e211ca837ba3f4732f93ba8c3e45e556927e6f9c3a6c0f1a7e8dcb84b72d7b890817bb5da6f73b3648c283ede1c68c207aaf3843dcb95cdaadb6a6b9fb4aee34f2ab381af69509c46a6cadc5e17d4c30aa9c9185d7e5e25d4ac8ca21698408509dcbee8027baa617dd6b2b260e4eef6b5a8f01619c960bff67f6ec93d374cb9c1a77f4ec7b2ed4091be1931c61b75ae515a4dcab5ee5c316886a862272711e3d10e4d67f371854f75345868272b610d23a61431d947286c326fe89cf63f2bd6a38fb6be024d430bce84cf2ea0035dd0f7e9d0e54798ae34a2ec5260a258b7f79e02606590fe35279f099687b6d0a91ba68b6e10f8c5939017f68613d1c73ecc36971e34149e637d9b63edf5a3f8cec30d416dd3c10318ea770508e05129e7460c9f3f1a527acdc9039109462a1ae1bc9710dab478ddbbe7b479ff699b164bc430a9443f9834c2caaabc8f6e8dfb4655f43f3e06c4d0173cbc3fb31970abdc6c2c913cb89395586bdf2f9c4d1ee71f2db21a2ee5be09c89b6932bff9d1003fe3db86e3c0cab062ea02ad0c189e118c7c6383b1693997feff1dc7da5291e515d1c1c892a483ea0b43520a4b337759d5c03863d264f0ee611c8b70529986d683c244f2ebc6fdbbcb002d95d913786a471d75fecefc69b1c5f48b0a4db9d9f2980ad3f5f92206fbf54d709a709e89804fa72ec05b4afe033879348e51445379d311fedf0b9646b4fb6689dedcded4fd64d49a7c9ffb43fc56e7674a51a2a1e8cbda8f07ac24b44e5d8f732364b53f714faade14eb4a35fc705121d9184da20a85e2df09554ddf466cd359bbeba56fdced4513d2b3285ac7274229e6ca41e6d4474e62b6ae13777d4786c5e70b44b73e6366f3269e3ccd4355094492fbd7a189ec757f38d45a74f04d4933723adb090617dae8cce9d074bbaca7ae2ed12659bb401cf2d3479600170b66395af0a7c2e4b340eeb729731c8f80c2622951d8552b2d3cdd3aaa75896107ea218d1b7af4a238d6442a6e7f4c65d300d357468cffbe4936c7329485f1b4b26e919d9617588df02625927ce9704fe877b3d97e8783c4651f9afef113c21ed9fd52231ca60ad7b4d574caa3a4f05db2b75cdf1d38b1d949fd5bbb3e5123d397c2c71add5f8231a07630baf4eff9137f8126e59435f8af99ddbe26006b989033dbb7aaf435378b4a415d8a7d33032fc72aa1d502952d246fa6002263bf822dedbe462183762df5ba40ccb6fdf27b82b4972cb9e67f12bbaf2440bd4b4f5a8555aa2850bfb8dad09138051112195b66756f8dcbf0d202b589854838cd013c13d6d69f080ad58ddffcb3fa9dc8f50028568aaa9190af050d4d3b605c011af950d95dbe7a7b9148db9132866ce76e9393031e7fe08d8987a09efffbd7ced07534c355861194c2a7f6b70a7f045169d38a217899cbbf4606c02a502ee0c4184ab0d7d8c87da2a039914e289020c5672a464dca0b8da245e4e92fa726ce58d34537e32e4392f9b77651edcdf2da941ce632641227a05d5a72d7d61f522e454328380b34e883c3f82928da281540c49d221a026997f1b1ff67a30e8428ede2afe7858bd233d7b151471c2ec612f817f3acd88d29958573eaf870b78a14080607df468cd1351fa031d78c9ef9cc8f6523f199a4f8309397c140e38640d5f795798bcff2cf873719940c33b32f300967533fda419578a40e096a912cb1723fddec31932fa068523ee398eafcb290ba8f33334b687dd49782c5b5a238cab5c9031f158c9bf671f91cea4bcb8f19bf0ccaf45bd4aa60aa7cff09b05a6d4a0ea276e794a3f6e650bfb99bd5379f4230a82bfa85b94739b7645bfe7f1a284454297a69ac4cac782c7b47eacfec10c6489f861ff16ceaf2f82e2ca304c97eec6f04edd05207c91860647fe1b89c29d61f23b8b23b8a0b3b805847b42a4adb3b70f6b8ccebb691b2d2f62e32d694acc579ba83d2b5197fef13076c0786e86bec2d21190c575ecf18cdda0135d32998da030b22b29b4a36fbca9de2b8482909efaff218eea34ecc9645d1ae77d1ebf8f9531fa5bacf7b259a107f7209d9df1c51a6f313528613cfa7833c5efd98d8d9d5471b6c9def751e67658179fc7ddfe6b7e90dbec00690814df95a95a577f17606599673b68d261781b9d9073b049451687e35fd12a3d506c96eee354b71cc29f58a2dfc9e76bdc00824857dc3b47220aab7e90145bd274a8145d771e3a2de5669b5f98d1ebe9a877d5c47de51424ec286a8a101eaaa2d49f7d33f0b462a0fba7e2f15948cd3880ea4ded7e0b6c90aaf8f5c6e2040b2a78241679d63f27076449c65031b1b886e1d36d9458ec9a1f5fdb6f02483c4a6ace842167f0a89619b1b85cc9b6287cc716acc2fc751192c9ddb63ea5ed8de86879d8c1ee540adf308a67ea7ba443673249e6ef606a1ccd6a358f23286cbbf0ad2a6aa3304edcabca1bd402d9bcb9a6c2a5cbbf6b7be00843a8d56299156197c68fd033020c0d060918ffca2b01170bb791e631befb321e77346e8e1914f40dc44e88e571266c3b334771670c38ed1612efef026d757c338facad3a5ed8f572bd1221893af013d632a83202edc33f861c7170f682a454eef75fd22e32d8b63249a84f155099ba571421553f91c9233edf00883e7941b36d7e53b96ff29c427d052a774f592115408cbff4688fa6ceb8ab318dbac29b7f9cda09d2d90f224faf133d7ba6321ab6e06f89cf15d4b78c8f93c57669430489db22dc92dd908349ad985ded39673a12a439ddd68f1e705ab9ee414159d307321952e2ef578ffcd9383d3be777bbbf94b886625cca82be1972d693c290c079582cca6b966eb835793aaf2524f4a6a1ed83998abc49e6c49d83acc49ded4a4e44afcf07efcdcde3f0d120892b1bd29303ded8a0a8f887de06d792be48b42645a7a6091e28a524b6e1c1c37a9e2c9ed833d64d6b728975f628caef20569cfb63f7f70317cb422795a8735355fa779be3c9b0275bfbab122ef6c1ef247577e840ae11af149e42d3303d628d65622f11ccd8dd374d291397d327d80192d92dfd1c372fdf3ad4d33adfe333b1a642447b8fe0e574da02ff90a89f4f57c2fdaebdce9551cd87cebc01cbcc2b058fdda90624e9ab7738d5c25a783bb069b7f0a1a27c105d943cef67e271fae552ec160a175bfdefffa90589acfe1408723ea214992766cbb4d541732b73098165d00d71c2932fb06f7f70680b1e68d5f124df2582055c099293f9f23eaeb3728f8d57b4533d92e14ba777b9546699892a7defa9b1ababe5f59208d50fb1284526c3ed62c929cefdbfce227b36eb166ba3f2081670099c6e8b75519aa9769564027a21db56b0400d1812f382b56a0dd9a72e07937b32cf3a629a35e8a97575f5005125bce19fcb28483d4c24a9c32b99c64c1cf482f90e616fe6814bc1fe866583b900498401c1e9669c95f63dbceee4535f6b72aa5a22520a1dfce337eb7c0aee43fe7a0dab94e12c5c746370182f61e503bf7a0cb6f55e70c81296639bc7aa2bfce67181a13dfe777ac1b09700ec07d607ce8e35da9ff440b271ce34450f3e27d69ca8954b71b3cb461d4cd9b78b51c71cc037a5de0d7fffeb7cd9ac92398c532ae6d4347422dccd724238b1a20c981a9de44b50ce5f729467f44e5f90149325427ca1fc1cee8ac6b27a9e709de0c37760cd5520224032cc1f4218f8eb00c495f4ae81c020606b27eed6b0b9a26ccf48a03fbf700bc06dd7d03426b582353ca0522fb607a639e9ffff0c3c03c266933cecac7e928e820dc9402901e63f7613c963d33a8b61230e87071d821b668c9bc72e266a4b6d40011a18e4fc714b58be93f264bdbca875e9974820399feb6a78a1c1fafe52e1ee10274a9eff51886d4a0869cded3b5400612e9ce3d38487342043927561d4261355ae0d067a1363f1eb35bd30705f72fc7ced702f8c907ddb756d566a94f3d60c215665366457f0d0edab6dc979b3c9919c9c5bdf00e0a6edfaa3d0846c421261f92538e7d1555b2896008e97a9762b9a83a5372b9c6448ea05ab248c8f4b7b50a708fa57f655a48ffa4ce334fe19968cdd94d7c3605e390c94103c0ce40901429a4ee4b63e36afd010ad1060e2c527baa49d45a52ee759c2f2a23a17326e79cc8e2dbe0680e8a1e081c3d3102ad3e046d81694c00a6a59500af402115ade0b69e23c35c513f29236e6345127825136880ef83ddf7627cd5108ddcab672b26b1812f7c5d324ed87d91b297108458474b3bc62176271b1961986f8bfd453b7e284a13f34655c06c4bf57cf4bb9de60f1058016cebd46719a270c23bc5b8fac2b6b0fd793f1948066596dd8a54beb120fd14ffaf9d6f820c62e01040ac99ec71c548be8e0723730596088f77cad02770e144399bd9fa2516765a87f3912173122e9d77d286c6dff8e473e67a42db5a2b18d7fa0f698e8e5d119d04104870985886d2408417d606c92e36d657147945aae6ffb61fe18399456c53639425b54559726afdc128556076426ddb177874399f01df653fa79596b89177a19eeca89a57bbcb1b0709497f7a808e612569b750eada36f8fbc917f48d8b398d9390a416e02de6f228033b17529facccf92de699c43c8715534150160719bac35b373181d23b13f32b2bbd84f9f738c3688f6f6d9f1edb0856ec974ba797d892a78a66c115ada0ac34bc8e466d483fa18614f6f905524e62726a4fbb29367577d7b86cc20d324161d7eff933011722e4b258cb43fbf1847e4e43d4a77b5901734d9507e126415d56e0fb69d36dbcff527d63b9f9a54ceab8ab337f58c4f383e1a3b36fe2557f22d44932f57970394f90a9b6578060348458b5a76754bc3d3313f4d2d3b87050ada14337d8e840519edd4fdbda21e428e437e3255535d29048d7642ef7adf41427db7063d9ac2b418c26b3797b932a6ba6c9d8432ea43680e76d668503ac5923aa7e8fcbb832b3cff65398cde5bc342f371467bf73fd19acf3b3ace6613463d8b2fc7533c9f2d6c2ffea9b8b89109dd7fc27ba27d7eadc667adc1f430af611feb4558a162dc495912f2ad6d8f3b6dee62b861f8f3b6d4e2144f4e97ae0c8c5a461e056c0b97954a0c533bdda1410f77203dc48da5b9162ef8a3097e9df32fce0f5818530bb73bf8b05bcb566a4b41a09c7092b6c3f695d5bf41dc624c3d2762571f42c79b7bf819d1d0dbf36a9e092f3c6f5cca158f4aeb6e48f6e535ba45216f8d175376659e453b086b543364a3c6b00fd874b0f580acbd254c9255dfcd2329fe8f73e050921d4a3a826bb1fffdfa1a54619616c65718cc4013f26812f849f8e587002af74ecf998ca75b1f4a3a336c5575b465bc42d6204847b38e6072c67d343e2560bde0e17ef568632088305c32a336fa6f0f896c2e6128dcf5a6dc784d76d8e836ec695418b1d6d9dea7ea6a376deac8e5c6c8c6d865b80f8fb94b18f3b7df466b2ba00c1782073b3de126af9e4f7bd8f0096e0cb5b13ee2f1dfc72d82a3bdd71f614d95946193446c21d7f56945f8e7e2cc3fc7fdbdc53de814cdde3a714209f6e3ce2c9392182278c3a47b901812fed9b6d35975f09dd651d1ce870d0b24e7e54495230147b7a99ef767af11a2a0397c9215c6b08ed9af51cfae2607327a7316d4a78a592594a880e3b0c4ad4f1b322d1fc4c384bcd0aff71e4595f08b418f386a1e323c07593f80f540162eb023e85ea2f5268fc99d44d819e193aa3ed87226eea9f7963ab34ede1d8e58673af845e02a8f9616d79f18443fc2a3102683b6c98407653a68d4f368a0459c5f1e01304b12cd92ba0cf9d611c79db16cc0ebea8957909ef303f014cdf9c42042b34925f4eac0cbad2713002cc51a90c5a49bc1c563aca185d3c0fddce39df60a00fd6ffdb2cbc7742d17ce540c564292b585c518d459d31bab020c5edc167214f0efe56fd725da62707529d29a62169c497ca36ffaa9de0ff7f66b2fb2ab6df0ff16397b4c5a694fe15fadf33fc28f1934b8022d2041e31c0ce2e4db848a5c37920cd83fc2cb853ddf4ebca455ee214cec55ede007dcf3598090b5e852152d37a78e5ec4c729d0ef527ba47cddd4ba2a14d3c8542ac6e49500cb8073ab64fbab650096f87ffeafa2e967d4fe0c541de34497deed6e626aee2ee549f157c093ecbde705e86624da66af531ffd58c30b3c576974a85da587bc18348120db29c534746c147e874b27d61ec9114e5c69422255f5742d8f984c30bb91208072d183f709e0b67d6c78ba1cf91156498a0342eae04aa8c46dd9e435dfd7d7dddf9fdb625132b28e09807790debc28bc7941ea10265d7c25301af67d4e6a49cda0adb27ff17b6b82d391c950ad1edd47b949e48456875d6855a14ec304ad561a62cb5b97c473483241aab9a820cb715c8a32ddc24e039f9acfc7e3a7898b7c886df9f8c8c5f89f99f81e552d09213541948a904e3a71f3b6787920c310ef3f7188f1adf8358e3a0dfe1664d2babe79dd9cd1a252f956750464ba83bb564baa133a9aa282bbda62b2550b706ffb065b3399fc4b71979a3f1e1c1f8f857315d6a6b896d55b83268697a9501a6fd19e91bef3f2d10f5b089625e451052203468b81ccb5be8ad5e16410b186c2a20ff45729bb12d3a6d3d19de0a08f787517d9ebe8d080c121221cd33748257d7460b45e0988ac60e1d409a6c7242929135f5230589aaf6f25470d09b960fa59f1df54d1964c83e9947b29004338063415ce34745372b39b08b390834237a3fa6509896a8fed52f4db308c689bdd1f115cdf8a9217892d3ba812a1744483157987dad098b77743aadd1ef2fe5efe0262cf355f12b9357519f16ce3c3dca8179e6293e6b2ab0179310cb2ffce3ce650107afe4623841d145a99e91c9f124fc4678b67503cf3cd88d7e390bde898ad3fbc9bf5d2a9afe34acb9703b69ac31e0de046cad439880df70b75eb16095bfc187b095a1f5cb552890843934062e4d83543a9bcfe9544b7c52a43235bd2b95bbae5776b48eee008f76c42efebf8f6645376e2a99d95e744e1164293c09404a415778849ee4ee891f0d5ba5e0e8ad8f2d3cd32eb435ca5cab1a4fcaedda6adf1b03ab42ab8f39e7f8235613aa3c948cdf5234202c88072ca8cd42dc72e4e17f324cb6debcd351684f0f45c65c7e4cc044d3fd3f5c7b17d5840dd56819437e54e9fa014e75bbebcc73027243a3e02d0ac41890d021f6a89a28d061c77d37fd45862af93e514034fb66d8bbba2ec5223ff8e14d7fa73b517b0a7537281124c5c494356c5a9acd2aa45855f04d75db23f5cc4f3f853ab049a3db8fde7ea5df298b22c9df6555cf1d7498b0202273ed7eac8c5df07c0711217e95bbe912326b243fb9ac3236d62c5d7c14667414ae113223c4a2e4bbcb5d7f88222ea6698c0fcb83e1f1fc8b07f130e29b156cce8bda66cca5e181c2d2a90f439125b16ffe34d4f0fe0495b7c77cb54c179825275ec9af77de1507763c6ce3e85222b9ebe2b94803e17a1d58895e40c7a826772fbac381d7506ebba8146a27d24c03e301c9929a8fc9213d633244abe9063004c38df053ab3d590ca3aa7c92a494b9f2d7b105c57583240437ff7d71848e547c72e8a56f1e9aa091454aef8570199a5424ed98582636de481ffe266681a878b386c596d4363b4102e28612c074873f4ed4e20b6080bcd9a9ad73ee9cd9cfd8d4c5d1a2c171f777b0ba58c0f89b31543fc2f74e957fb6fe9e8b36997cfe0ad7966663e5419294ab0fce53e6f9396aff7c2464bd22fc385a02d6d442c128230a3d9ed5b571326da6cf99649bf018de69123967b31c5c3d4881e9fb3314db6d71ba929acb71b1aa5dcecc3c5ae71d953e5a13dc3bec7633762cd06205dcca52414b74d8ff8417380fffd938dcc2dad0324178e40a10c691a3280eef9fb0f0b4c0e8eaa061f987612600eb6c03b1870f5b8cbecf877df52ffe1d4452e705e98bce02d6837c2bb47561ae9f0417887629ff2013d53f23b0dfd2d4a46b4bc58ea918886cbecab40e51d32dc5e382b477f6a7d3bbf9cf8715b3ce387ad0422e4de1ecc8a6014099f9e8a39b659900f2f5831aec3348464f6e67a6e00a89ccafaff6aad04f6402a87ba9447620176e601c4c69c489da04962f589bac57f7d873552afac951327d4bc3e873e9c94e07b86986d0e8d13e6cde266ce5eab04ab9c203fddda8c752220dc0c8362778804bb0c585f307d2534929bc4c41d106cb19dad8314bc7c25b0eca9d1fc3fb168dcd2d0ad49223083c9aabdd477b3e8171a5a54032dfabaf9f4ddd19638e20a10a96aeed0ca50a007ca2755600af4e54df9d9b42032e733a132ee3321d45922b56de6d569f89f24edbe2d0f95313ad068626accc4e2cf3be4558e23a84093869d6fbb7562dc65f476139e7ab3b7257277eeb90f8e2e1e486e6c563adc3e7dff05bbd4891df1344078974f8588faa9ac8d3b05fcb8bf4bba472946a0a6677f44f4a007c3eda976a9e8ffd637876a6c8e456a53f1336da426226195eb83a6409b333098b849e8d5222563dff1350e73880f9fc267f8c9d8c0bc8e14fadfbabd18b3c3cdd52587798393c012a908fe221afa85e4d1339460d8f1501d6662b9af7ed97497b511d20e571e7592ecafea8e8e8ac72abe0246ad8e71e71279ad8842ef27a2409e320ba4b465c6ffae5a9115a51998630981882c31c9bb72bdab631bf1b171350ff9e55226915d1419674b503fe82c4634baba1ae119d574922a5baf7d8647d7927b09bbeb65c3cae68480516ec93d0f2e956e2573cc633c632ad3e913234f6146b5944c21a4eb16115a2f3379d0872d262febddb0a3389863ff0323096ff9dcc982976296b4a82ec65068f5b6ea4bfe3639abfb65c94953f4177566928a78268a1c962d5c603262f253d2ac55aed099fbd4dd6ee3d5311511008b0940f2420197f90a6e57a2a684dbe5260169f0ddaf621ce342e25caed26903f791e514943c777adffe5ea283e4902ab1fbd9e5417450f9d550f03d21ce09a240ec277fece7ac77f62fb1902dd43136d62512ac4c9be131fdc1d0d11228aee544f22b2d8d97dbd3a4f0c9676dc24c2d8af77b175366619659627a11aaff2d88b1411f68feb8c27d32cae391efe2d88bd795328f2fc0440e1dc39dfe382396c58a6295d28bf77de25baaad0ec2668c3559e17a8ebe69bcd92e2ddde8ad50daa6a83df3ebc3b0bdacd07dfffcdc4491c8c4d4df1d6136b0bda76320a61f063e8c36e36260f878e9d1b79a975b9492da095c330c377d5835f85836ae7749e2d6c034a109f0c2af5e5a28fb2a6b266c9c287b87bb8ffabdd1cb42e4f5200a95caeaf6697a957c243d06af47525b336da8040e715cb9c77c1e281c4e32a8e25f2a3ea28a9ed8c6ca73eccdb11dd33eb9b09919443edc544f9b76d1f8505478268e72b5b18ee8017fff75779e59752f94b32f2ff763961621c5da00e0c6be160fd19d7f45162cd6da8da39520ceb7d48a11f7fa6156af06abc1447b183d3b2bb39140a20adb75af19f65f844303445b2b1045b9cb8f632220328ec8423f6ac8df5703971a63ee3d0d3abe9525549fda4dcbbbbdc95a03ebe9fe78a3cd558724e681dd292a7313f02101668ce25a07c8ecd646eb6d3e82e6742ed07a0836e6187c5ba1f71f7fe18273bf1d214eff46818d13fc3dc5515d1b0d191bf005f21da42c0033f6fa26596df1fa55827eb2c7c538779e41a610f099ca8b4b5a4e52946858eb01ee08fa17709360d5cf26a1493903cdb698cf8be8f08dac8f4562c3762cc657b7f86cfaa80e9e9b299dc1e67ce425adf478560e0db50cb1f8ee0c81b158c3d06d06f69a860ef7204d748b0b2db4a62fd02b6592ee02eebaf7c886e9207cd496305b453185fc896006514d57cff7901b338e499f74f3f66acafa67220ccaf5b9f30f451682a7bc0ee125f7c20be2bd944693d36a682a47fdd0de6a79f3976b0bb08ceeeec0a1f37746530a93470e2d8a60bf0358464ba5007084fe2ae0de2249d01461d755c226102636d4e44ff5ec6672ac092da681dbfa8f2ca978aebca124a738486a58a685b0d39978b8017993c74888929a7bf7238c05d03a393ef58707386292de602a2c353d3dcc41345e4636629567ee4960a5e32c98cf4c116e9fb7364c77b5fdf2e66c5d56ff8939cb532f21a75c0b2770ff96cb63a29ea2b17c3cc487ceb265e6078dde0e18ac00cd5af0a3a98e001361e72edc45af9eab6cafa819f6b519a7b14a9b32013d3644d503d49a18f2d9ba6fd4fa3e03265da1f282a803508867fa41c97f04c0cf793635493c0c863184365cbcfd6b99acb1edb84ef8cba12307ac4a00b1c84e57d4cca64f4d1318dcddb2eddf052ab47118ccd95624f0c97fb645c3e3ab60a63a3b22c4cefa4c09e44f426aa741ff390f2f3d933c34cffb94983d6703aa38334b946890092ad5256d873f228fe387bc3cfb36c8fe234a40922d7634bf4703551fa587ee56ea6b4feb2ac7e523a71f0a5265137e8a4c2df263ab47f08b0c3be33ca3d7253a0699fb90a4ce880f49539f9990415fdb1d1b418a70a09f4707dea413af5c620b6f6ab40d5c476535445f3073fb693aaccc9ab13f8b070e9ef06bd5c7c387343045b8979cf98ed8de65992346918880b7d5df9aef8ef14c7d850ba6cce5c811e47eafd6628c26c3f70a03124418fbc88778d9a7fc31e52b9a0be0bd4e9a2dd0906fc2371eae4b0b5b186a4cfba4254bd88b1b58d76d62c3043204b16ef1dd2eb7b1049323fe97182f006f54b9fd1968854d3c80641b5cf0ccbf53904bad894967356657ad8d3c5952667e60bd17a2210d1055c7b34559cfb6c22959dd4fbe27497537067a17c8bed7354ddb3a18299d9fe76d2806ad0045ff2f7d839f19ae303514dfb4ba1ca83c9339aee32b8341a4bfb8be742434e678302952750b4327b05c65af8d5141be4db689a8ccf381f226734adace0532ef5306574a0be3fa595702a1584c6081746d7c608e9bd16b89b4033e0a2ec6e18707630c3b184bf392b8c2c78ac4261ab49ee727748b22fa67054f0e5ddeec6a3185532314deb5873fcd6c76f85b314004e58cd2cf8c74d22a73a7782900033ca50424c60e979dc567716a2c128ad7fcdeca70d138bf68508f7b44f114057ab1e78184960ff00ee249e5b8c67f5e0acdfbdcf33839fb65b9b2414305fd37e242293abde4638903e6e94c713194fa72dbe82bcfe6e04b1b44a00937cc7d3071b04232f3e885768c9b372ee191b513e1efcccc20bb536ed29da6bf49cb3161d8eaedb17c3060c1cc05e4f9326bfa72096e95598836dc5692d79870eceb318c6baf9ac145b19ce5c3ed1e7ba67f0a7694fd246e530f24a911e5f1cf1768ce4b9712e3b24435e854e84d3c695970a88f7cb5502dba8f14437917cdb11ccef387a7723196fe0fb7f391a6b0dc9f5d27c4bce49abb2bcf88b2f63dc991047e3101de8c1ec61b5004993485eacfec09762e4fd2a3c1aa186cb91e56370d8242e1ccd8ae6b5b0cdfb8936ac84ea24a41577b7b0e3aeb391017cd1ff6686771e781d0483e42b5bc40e423cf6a049a6387d56c752fcd6c5869be9bc4da8d05e9eff049f8108ff859e5b4fca8de4b5e1a4efe574b13c7798e408e80464353f1d9cdd147214fe58a263f2ac86444d57cb23677a52401f9c9096a9d0ff0046359403d1b2c14da51975e0ecfa2df05e8e2881f8e55d043db1c4a473c8f8f80f310e4a475312e71ed8d2c95669c81a035655c00fb78a317d7b1ddf5427bb9e3d40ba99ecfe01f0fc9a0ada55b3b28a8e03d26d7a8b3a70534ce2de9ea00db5fcbe66f09509b8339054706bcecf6e04c9887822781c019068b3b5b4170821c41915d86469714c43c82bd869684ba73eda7c2a8ce63ed3704d3c72a712f17140f8fd3a78413d3528e9c81dffd6a69bd808152f42d2b9b609d33c20105340a482133ce8d3a06b42ecfd5d665affd56dadf9801fdeddac08035cc81f29c355a8151d5781033bb66ba282044689bedca203b5d793fdcdd66d2ba86ded86bd038eeb53e20d7cc5bede2fdbe1593e99083eb43bdcb55a58529ebb2deb686cd5e8d148d40b7984fbb20962a55d96475363034d5e9ebbf6dd5bd1a6b3e6900c6397194c54054ec78732b894bc6e2b2b48bf6fd24fa313c8bfe661966355cc97b4eb5bacb45b0a9a2aa0f4fc805c93d3a92ee8fc8abd9afe0dc7f0661547a40ffe65ae386d6abd924e71dbf99cbe7554656a47f15b8849f9e2ef4b689ecaf0cf13c18acb0f6c536d5657fab066cdd8f17949a8ba91fb5376a39c753c0486c99d9ecd8f6efa2a53dc683afe7d0bc0d89edbdc345235c55e52c0d8e48fe3826a343a93abc617396cda7edfe9e8c071ebcef60088e559f307e0e9bf3813cf1d7d3eb9c10ae797605596b710ffb1b867b656abbc6dc7f2676f95b6533fc724e7c6f97c3e1a964e905a60d81591a89cbd57713734e5d552f3ab85ca3a0a18b8d9510642167fb562ecb1ea8afa856b8c89da049be64d8dc4bf65d58521f796261a774a228116f704431b22bb49cdbacd18b5c7fffc16e73a906394fd3ab242d1ebd588ece82342010374467c7288d59251a1c44c691237c5e283b2763d0afe361e36575c7109132f67eae3b85143e38ff09789d65f63686f902824ff130ae843aaa2d1f234662f2a6cb501fd37c362127db75a2d38350f45b9c6f1c9702aa4e4ca836880a6270087a8a3153b0500a1d4958dc8a52c1796e61e2525e388ee248e3f41842b0d890026748ae6b3ed2bf2a1c0a98a477ade8a8f423a0f4a3b25ab52caeaa0a9dcd98ac7938bc0ec31a463484c12fe180389a49f995b95fe16037460e753c6c629c1fa59cb0b809de953bab681049ed8dc6bcf6e1ce4793361d6e3032efe578655511d8b7a9c920b1820488eecd3c043eb0ead7e04c228bd784c375e845e2f2e33911c96b42ce39417431a52194bbf167c2341460efc7641fc119006fa4fc738e3facd7253cdfc4ead335b1de4582f31dbdfc16d77a67ffa8170f680bbd0c6612935be7e47f5f845d5a6e30fc821e6df3d69fa5201578649b5bec80224583deb6115715c9959c16369a77494632c39f8635f10f2dcee17a0476e303237606afbfce3766742affe2f576d455de012dd8a47784054b13b6c62ae69df4a98c1e3da2906a955592cb4ccca5e470f4dd96c4fb2dc8d948397837553d1b99c049f2f2375172703143724d5e342b7f9e7abee42e5bf0405ff9f546a6a1df1e7572135b02c0fa67a25670d87b01e567c5cff84554fab0cf2dedafea4d4b724758505b3945bfba40d10ac0aa7c41ef7abe9756fd4f76c8c71017d21984082cb69b30d73233e6260e5d41d967d0fafd3c2cd2d81142305afbbe5bbce973bb55b9a5e3c4d6a9fff3e043024226288a22142f41b5c83efd18d16d001b837dd996a8f03f9f1a028869d3a0f5aecd811ea28ec3edaa85d5a541b3b0348f71fbebb332f59c3a9b4a34845d3feab3e8473c1c3e69a066b17e656573e885e70f060f9d34b057f134d96ae81a575204ccaa3a0161d26af757e56d046d5e68e8128678ccf30d52e0c481c4a46c3ec4433552c458d4691e53712563f87016b5a47445eaf4d525723325e892c4a0857a66c3885ad807f2d2ea0584dfaec3f9296642943f00f0ba2082b65355b289b7d1a1ea0ccf49ee5c634fa1daed33b83ce2250f85e45d06e7c93b0823446aafefcdec45c5cb412442eee5c4eb8e0cb2c7e7940cbb5ca1d82e5e24727eca7c8491921068b04a26c70558ac4c1a36e197fb9eb40c42bc70d27fd5e0b03005e148afec488e8a1c85b6d7c80df8894ff8006154ffedee2dc37bc0a693d79c4997841ac874d6cd63ba393027c78883b580a7b0b92034556e6f42ae4e8928a19b1b44abb9d6dae317e74354a7db291339ace92a613ecf74500a77bccff4a6d637a880067465d5998537d0b83999103c1f9a636344d053e1381597892ebc73050b485e0f54acac2acc7910d215ad89c89f11ec7c3e09254aa07c3e49f45447d639b9293ad73b8c7c5f0468f83648e4b1670c7e5190cf53f995665a32aeb09ac1991f402b1eaaea8186ec6c92db53ed571711d9285d4534153a51779a6d3951fd34874a6771231f08dc8c69a008b6ec43c35de26f2ee1eb2e458144e847def5b1ca36775db98ae89fd25b181b03a656ff75e2105a6f167aee7dc0a6f0d42fdd104dd29abf052a88b62b129454d710a39aa90b6e75ef8dfd7a426cf4a2b18cbefc644d63ef05f351687e21b6afd40dfddcd05cf50064ee379405d43422015e96d6e9ad0643924fd40fb87a5d8f0d63bcb9cdda5c44e5349230cbe77c8ae763e3a86b9e17072482f91697a45754d819db947b46903f6e9d23d9ae36c3aa0d12915badd0696e5a96c4192f22e69d5223d913242769c75f1b7deb5c3dc5ec20fc20d32530301476e18bfc69291ac6d90cc0b40ba56d8cfd613b5f9604d87d5152e5dd7ee4be4fde12d3317fa980c090c43829e433a097f07ca1abb20fbe8cd56d5e9a16249b5c9dd4260e82a1d816de6de57f570daa80c4f8bdef1a9bdc19666d0d9281d6c244dffb9bb2d4c6cdbcef45717a807beaff689bdc8dcb2a6a68c1e14d1c0407568e7849d4c8ae7bf1d83198080b72f33486b1ac4601d7687098268a08bd1b270ce95ebaaa059b156c6ed9c22ad8afff4733d8ce93d3e353bb52db20511bf3201f7b2b68e929fb7320085c4b08d2b1fa46dbf8660d3daabd0fb9a93741dcf03996f89cf9aa0282e63b23f602df586599c0ca9195e629781943fe5d24a22629c51a6314a349bdb6636c1c263b0630ab450ca008bf4a14af9a0e2348fd37d4e7a5c02b1ab7fdbc740f37d0300a9d7dd74808e024a4846145a3b755c0a5bf5d2aa26c73d6c68d026b1129f49a9f0c6333c682e3930ac0b64482e75b9deaf15e2485c2519852b2209fbbdc6bafa8d04e7b85d75963f527084a824c3fbdae1d28bb11c55d510a0faae8000d82ffc437045f8d8ce4896d63fb0748de2e80272b330bc5912e199ee3ff703b31fbdd0a0e7a048ef73e5ddab294c180df274c291a7ae268e22da71ed66a39435b6ce09b631d841b36fc1cea2f0cd2e0f6820a844d9d43763ee1dced787195d4511e6249e1b969b80225650af2162972f9f2a76f3580e44706c2383f6e72ac46210a04495d4536b030e6bd7019e6c53240dc94082b83af1cc2d763284ba2f9919c2928f9a110dec1d80f0bb3029c3e03a32c47dc8ec944ea5e8ba6419cafcda6886b75b5986b4b9a805c1cf024fe3ce57205b8857c0b76ff42956fd6ad79cb136c1857bb4a9fd81ec75620885cb8fd890d9ae559a54aca76647bd1a5f9786afc3c5a7d1e6a3cd7875f3b2b65a49cd330e49e4e242462fb78cbcf01335cb2775f67e659cd54210d4b6564b5d37fe8a4d50f8679f35bd1784f2a43daa5735090ade57ea3a5c34631d652a21beb96bf69afcc8f6ff53352e44675aa5a3bca48a9af651cd7989756701925661b8647b9affe76663d6442c39661a4492346aec48bbdb318b2e0764cece175c75ccb2c95192ce3967582b8ae17da0811fbbed95f5044e69db9432ce438049740e445dfe8db362bb7aaa7213fa675e0fd4c654bb1e99c03f4b269fa65de56f871a08d6fdf41734b77f75c47c3b7a6107aa56ff3fc98321c0428405575d97c625ddf7f5df1269928287989ccfa6f7f336a37cc155f76f9128deb6eb3e21b80d050d7070ed27d22d97ed0ae51452a74609458f1833cee348e138edc6925083cf2271f7701aeccf94b7ba2353476f6ed5a2d033e1045408eca8be842c30ef997a1a2336e4c3bac78a66218ca3a7f15ad10a557eadcdfff7a4a1993d3c57bbb91d44df454150c4ab6f3ae60c8c05c7ffb913e1488686b93f39b0570ec58470d18d6e325631809e925ffae29b932ae5dafed9a21137a55b879ae3c21dcbc8226b5cf17ef3874f85e8574522adeed2d8ffd9a2108924eb1fe6e73328eb686062c09ee775e07417b931b9f479bced4cb281c5b1c7846aa9c47bbc212613992c2bd14aa70e148b4fa04476221b9232b86ecb4bc6fc36daf764bc3bd818ac09bcf6a530183ce09d393455c45b547358a3cd927ab145d919ca517af2a00bb4a742937a6a66edbc0f42e7ad4ac4208e600a19b9db3da6367d46a8900823cec8d01251d0e7668a6b79896ddcb9a3d4680b01b16eae9851143d10ed679a836d81b7c298936b5742f03508f3bd090c84ea278ede03e970e4b15e68005548f217f969df0dacfeaa3590cbea877ff6c02f23a841ec3ad1ca415fdee6072c5345ba2f4b095e6b956406ca8f1bd06765c4e0596c9cd407bb3171b68534b4cd8bea84ad6b60775fe54f196c198e1720d3da5e278cf460741f57e2ac3fb291691aa2142e90f07c59b3579658fd0c0d86a08d1e64e49db81e05531b5ba1c3f2a6549da985d5fb3051f53f94e5f945d695d222cf2655cde4645f9be510bfa983101076b206a97d2da0e72972aed0c60ec8ca41fea3aa047a7f78e2239e202a0ac5f31e7f1e06166dc25b3f6b44b42243a78012538d62b74257f1d3bcacde97a6f2f3db3e6d356d91a5da2350c5df217c1c3988049384234f794e78d083e9a16208ac0ef1e49b30992c62c0a36db8df202d816440fd66fd48926d56b18952dbabcfa9ddb7cff81bbba3787239cf09dcf14d0b9687d252b19f7270ad9c4c7413113d419a527436888fac34f318860143a1eb8d5fa0e3a4a3496369500fa8d53c147d7d39e0bd288372f0774ceab3f48c5e01b32613f71df936c0b60914d23fe50512adfb257d02e842a40a615993ca1e62be51ac4112f4f0ab3bdcb1c739742627c9e723bfdcc32be2f3b6bd44a783361648a3e7988aab0375ad5a272c5ae38c3e846eb1d36d64b5b770c0b299beecdba068db3222ecacb4c842d4b01c252cb22085f1b22fb9dbe84ae9aeed6cb6e3de01d48bfe09010463806a761748c92620924811f058dae1ce975f933c4ff23c654cb0e388fc098d00eedaa292769339d0fd82c34b4edae059ee19383e2bead1507c69a9c88d1226907f67c7a8343d17b8f939d457164b71caafa26703c75c82f2cd8ca3ad25f3000b5155e1411298f9f7619f13360fdb5a3e33d8cebfff485174f5eb1ffe50431163fef7e87cccc577e52029e052106e36e2c1b549a25ee15371acaf2ca87e4be213b5fc2165802aeae29393a82a8934522b8783010c47d1ec83d21745f3522ebd070f54f40bc470dad377d91ef7dfb47ebf52c2f3f359da4be3c7e594bc9689a774372f6d5b837dabc2ae30bebe1595c28eb85c4a3f3ad84f8d78d5461da64f13cb34d5ecf1a15e3c615526499270cb1b048c4a5f77bf17ab34511439d3a45d1d9e8310c4026487057e205afa6b637f5ad489b73758f12bc8b615e1d8eb94264fa067c331be7d8e41db10db0d0c1422d3a6fb534f7e99c1d8587df349ff713ba948cc258af26f5ee8f41cd81f5ba5797339c2ea079de7ecee0da91c2daa87674c6eb49c403d77148922b7c8be0f2e69ff8781738ce538e9fc14f86c5ff1eab830b198ac4810041074970a6c74fa021e6fd30f433864a03dce0ec64310554f9f2dfbeb6c093a1ff7d71a9ac5aebbe805070903d3b606cf9b1d560e36c64f727c51e722f1b247b6bace7e83f7929d43f315518e0efc224f02ab1345320c53103e1afbb0ae42578e63f392ce99e58addb7ada53bd480e694db4f09b1354e4ebdf0d570c945b9139f523682284144a979904c9be29bccda6d83709201bdfd0660f00b6b7ca447e53c4a23ee4c0c65665ffde4ad96c3a15453dc40c2c7325d7dc6c75d3e3df0746f3a015d729a26cb8da59b8779943f892c58bc52ccbba26b6b3d461b9f2baa4d7f97c25397afffd70ae355159475e0920d9b8cd1ac3a0dcf781a72bfc4b7575a7106d9b2ecc057a3a6fe7005af4e3cad9aa1aed89916ce986ca4cf83c94dfc0e4e22ec1b111b3fd3802064a4f2be91d0e3cef9a52ba7696dbdaaa08f950fb1cdf6f9d5197315c2a6954ed7e922afe7184ead62dfb41ae225aa9af2538af7fa1c55e3cf9550529dc041c3b76d9f5a29fed2154e4a6261461bceacd1ceca356ea2957b1660d0b93305834534fc1d1ca9284c8517dad273da7a0d6784c13e51feaf0a446eb2e9eecdcc033dd463d475ec5292e98605d32d50b983ca940f04aab8c9bd969ab69b3d7d4d158439b5ba1ba8983245a57aa5817f54d9c5e5fe800822911b02d5fbc46cc40d5d0358112f43125ed6dabd4ca4c57f7a2ec17a5db8d5fc65533c8a2cee496c426a72628071f85ba3ee004ce05fb7903d59e5b710724b029d60b13d7f3fad4152062ccce80eb7104b86fc023330176e50e343163c6d817bd33e20d9279e37be2916fa4e7f9581fe097d59f99b071de12f96ca745bf5ceb3fbaf9589f23f6520703086b4d0168b2a72aad455fcd8551c925b44f0c558db849e97fbb90f73e7416301da6875d37be5c59b1bc28eea1057d72e5bddf69c0ba9cbb919edeb9dfd22d853d1b1fa413cba2033ceed6eb534397b8fd0a3ac7fb664896a29198be8aaf1d8c135602b72dd589ae472cb06ec2ea84678f5413bd61e29b09c4c5a5eff722df884d25fad908cf2852fbaa28485aeb14e2113c1ecafc88e8cd4891952aaf975abe461c2e52551b085037003b0d65cb26b94266145fbc6714a660eeff57054e7e15c112b9c1d8135cdcb1aa50739a24a91dd9fc120fe5c2fc1196fc75deb3dba4205ba24db139840f64f089ba31ac24e823bd2c07bf6e8fa8fa897b025304a44bb533abeaf9ff2e9eb9d261b969420c2cb2cda52aa6cbf84ac2e4533a892466199659d19f00e045bf12745916d7dcb2a734011e90315bde1562370cdd64d9b134e73afa61f672f3df20dd7e4b4b93ffb67056d0bf1c5c51dc7f7256050f7167ea6645d1ef8dd2d36dce613f3c35be726d119cf66351891985a5ac83e9708741a4a44d46c6d92a78f16a8cf27d37269c74c78e540560ad304d042c082c16ea4a2fb0200b254439e4f84f274e300f78a23a162fadd7a36046da6d0b00bcd8aa6252fbd81923d3db11d2484def654d60be7028794c9663d63c1d6d5da945f83abcb4672c29d32a486c154768d61ca5e0bed945da7c708115a904a963e4327f3a6014bbee3c78ff3d54002eade6c6cf268468c4d810068c3958fffa4bb93b1782aaccf37014cae98ca09fbef268624a6b84ae8e64dc734261c84ee3e7d186afcfc9ac373bb849cf9116caeeb888226d24499a992f3970ddbfab2945fefa599668411e57dcf4a550e4f5ea34d5d5a79f28f085e33e8577afde67ae942aa75ae8f5699b1e2fd62ff0486c9c927fc5c8ab30ab95d69da108ee7c98a5e0b76d5e77daee75f082335fe2202012686b2fea70893f6628bf71f1b5a38c14628988cb8a434eed608a2067bafcaa535a2ecfe779aa860b919f60ab9c74c59f7bed54891b405e95cecf79da64ab1747d676c58c37d5ee5ef32fd9c760f17bbd522bd3806d3cc50c31b55d60221b668bfa7a169ce1d6f99dd0e5cf6c8b7b18b86cb62ead285a7e0398b1af7874a60d23f2972a694085bb58219236e11413ba80f9362cbc533f5a91149497502ef375ee09514c00e1945fb0edc787295e6bb451b600bc3ed2207cdc0611ffa61b5e79f60abd2ddf75f5a2e53e2d40b411c60d219225716948ffdb0f0ac417c1ef09eb86a3f7623d66f75637440a6216bd23ffe27d0c01658647c3a1f81dd26e6e0c1019e95be1e4cd1be110c54bf1d735c2799c1258c62edd4954eac26b671f01e11f0e3d24889a6f96bb883af778501b119e45f7f33d09ff45020a1240d0052a3cc5391e8b96165c37f42e2ac08293073d447c3053897c4d1b1320f10e4e4d8797a33cb1af308d4fa8ab2b9c07226d41327606c444f0e6b60724d1f6b7e35d5852cfae0950ddc607a898adc60f6c6e0180f3245a475d9d8541a51da910d630b70e4f1a7ee20bc9143483a84897f9099cd5acb5c6efdd9bc2a25888153e33b5f707a1c590b6880ee65fcae38d6067c022eb4926a4c922c60d0fd68cd7d14844df7a364e378d095016eedf583663d75c4e87a5366a1403b80db70a66072c2a26a6dcf2128b87a6dc379fc8e19a866e41c4fc4e8baae2fa25d9deb324cb982e26f589ae6e2c625c82a38f9e37c9cdd4c308e906105d6ca4cdfb56e61584fd703751cbb6c2e2b28a060cec0e4191ceb899b037442a66d845f6f8698b79d2ae4f29a7884c514345742ed8badbb07d264955a36cb4bbc05c41816d9adb88e935ef6be9c923e868c2c45785765af4d161bef18000b3f4f557a48a3330e8cced60b5e4f12ee45a068704a194bbf471e771d06f7c2ad4f6ccf19b99293d15c557f7cfd219ddaccd5dea24a2c45aa71784613b823dcb5d475ce4f9607f749add94d0aac339fd8ccfe63ffab499b68639046f414a9b4cca11e749b30faae901b660d87a9703c90845ad8cbdcd767134c0711526244232493a30af6431628eacb790c1b595e8529922b3408ae3c8176da7e2d6b58396c73d402d35ca1e4d114dfc4bc59891fda72bf7de43e0e806a07eccb8cbb9e066cfbcf0424047fe33916b84e9d1a11e8fa79f46414d23548850c80c9d1385b33e5a11e9750e6154ea72e4bdeef913d557f04ab4baca1c3874d941b44f466d816cf03ae938914224468a655ae8c875a68a8f75fd4c9677ec4a37f23ba8eb4bf90c0d6af6c21238a0cbb0f4751761134223b2dbc3a0554346cc407a585ed3fb1fad7f894d1782366aeed6670d2dea7b892e752e288aa776603c99895876dedf8c55aaaf2529bc52640a97eac48de60215fd159134963267f4481e66d36a6d5bb610baac42c5cb451176537dfed7793dc8712f1f17eb3e524211cf6aa76d2f5a4e3ee884572be5ee8450f37440a6888876de65632c05c5d889129883485a80c7ae458beb3881d5cfe4ec63f5ebc7de829720dfded91ac27c12fb65b25e33dc1556793dcddf89b98e78fd1e7d436a368f0bf0288538313226c4a55f8db44530b8733da9c93b4a12764ae0175cc1eb0f55f091bb408f2b47a44fc02dbe754afbaa84c399b0d585b9f357af9c34be53c73f85611b6c9d5f5324e7ddc481bd223fe7ffecc70b423dcb1a52f6e97e67a839fd1fe1b75ab57865bc86f83c2a750640f112277b936398541eee2f6a05069d990231450bcea6b3c2e3cca2df9d8240ee4c6e517eb77de67bdcc56cdc689452c80558ab298079bd43f5626cbcd446d2a00322021919179ee050c8c5e79ca524a481886fe39ef7be17b2f53ac15d6c9878218ab8b511ac86251e3a7cf3689bbc44343e51da49085f98bfbd998ad905cb5c394bd19d293176f20a46e975e82ce508a3c15a6d13dac5a8239841de7ffcf202df5e4dbc9f654c3e801d9f4e0b3dd8af957cbc2b87ddea90ccae5b0896ceaedd2d30bea8e6f5155d0da95d2a15010175945e0e93a18fb76508b14022fe9de01e3fc8e853256e8121e3c8bc611e776c4a6f51a9395214c9d50c9cb69fa88e1f33b70af28fb6fc0f5c5925ae3d902c62dbbbbd0a2afea0daa17113ef5d1975863d39022656a804ac25698f380fac54dff54d1f7420fdb6221fb149c8d5ecd43924f03cac1c3e808fae31f10e12062fee56c1a938901d2e2de1ae7812014d2f3faf0839bbc66e33a4bd73cee4a305be139bf7fc6ad21e0ffc0f2ceadbf87ea17f1432e11cba63aec7a71455a2f464cd4d4190e9dca3353e79fe5290055155d30f0d2319166dfc1f9d49a0fdd9f5b4485b447545a3248af5824c2e2ea2bbbc351739145a03504af8d679c5bb21fad8e148cb51d08fdfb90f1d3f2e10e28c3091f028445f3c4e165b227dd3be312787077cd7122853fc55229100a7548d4e43e45ddb71e2104258621e4043c2ea97cd2bb6a36ccd38a36168872951c44eb01b92e9e16368f09fc130097f2deea5cd8a5aca9c5638afc5d57c624bc83a51c8f0e0cea5621d0f4d32d40c8ed04770daf11fff798afc0df31fe567330d9ff1c591c80379bac1190e43f855280eb213800bbf560009fe4b9d9f6b7f45046c87eee0103e383ea6ca3abd685e87ed7d0f5a32b8376995b59735294a939cf4c885fa51c00d44c2b8716b20641507178be20a969f2f3a368503d58724db950a3277af70da6680a0a0c1a51ebecfc65af8484fbb43ca98b61cb8b9f5d29b0bd5b095e1586e34db34eb73261ed2290a29644fccf923b7ca25ee5ebda3fc25cbcba401de3cf5ce9360489645ba4545981abd5d67fb36b79f55b2b60d37821dc1c31bd99ce100701e09d7921b419b0cfb66a29bf941010df85efd83dc48b853ee7abab100223afd079881457d3694664b6d54503a9efb68771ce34f70e471be760e3537d76bafc4af796ab09dcf63832a2f3520ceba498cb9acaba6fb0bdb55038557f0443f7304069f68212476b1ada3d3d8498390c01b0bf397c8e43123e33e479e6cc4b38a57bffe93dacd4c6b49f524a644e5f13c5dbe17b6feb3c0f7096da05e5ce7f02b629610e28fc2a168eaaa0f07637c004ad9b003c605b393ce16fa407f5596b44c574651d24b9b7ddcac0526295a40b5171b7ce72d41647d005c69bac046a2d28031e2c32a8dbb1b98396b204ed1fe5ac10819b6fea75cc0b327370896db18ad28b90d6bc4af04681d207756ac5ab910e48d72a7089eb796969c1a058d52f3c1efb166d267f21b8881705548df77484b859281b5ff2a50ac69f792f24688651b9bc91d84b9ab73521fbf4016e88be3524978111fb04127a25a0bd3f2003949dc27225894368008cf19fc5808bedc87c0f99739e84209e38c2effec8dacbadfb93991731741ab4bbfaec88b076f069b065c79ed58925a1f743c95973198b16a7ed9eeb0a43cad03135934f221d0818fe657bfc2798ee35bd5378805aca781ea86830d19dbbaf00474c30bdb09be20c4f96d02319bb1a2b022cbc60eb31c7ea7458635aadbb73884bb8a23b494eda1512b7e131dd084ac153d02985a5fef1909bfb03dfdc9e6e96c77d048283d4cbefb3ade607670346df70085f250abb69aa40e519b9a500e81956a9dc112a1f051053ac0770a9734d804b8a19058f720105bdf8203291c75c8e40c14875c049b823913e9db77a2f537a1a4278b4e88fc91d4f5cd77785e5e9e7a0773a372cbc5051601b7af56b6a88f277a11853305d006a5a514d82d4b965eb7b9e75dc80046e8a41478e6423914c139e3ffb1c1fc02f5ec59d2537c9d0e418db5301ec3d27b793eae10fb705778e8a9fa8341fe5b9620570daa54eb108b3fdf4210328111133c1e07f264db7e83a028d239f9dff76cf7e9d544bca0e65d54d1da8ede27b653fe6fac6045e4e25620c7edb207d408240e4255808f08643424d6ad0d67c859027c3cfc0a077cfa9a6588c5305a41ab7b2f7147ed68fc53f364f61c29f476b9d02b67aaefe97a01a4dcb0462fff295f4fc0ebf99d4cbe7fa393463e6b84e1385e1ac13e94b5e076a6384052bf5fb1881e7aa4cc44b7333b6ecbbf5ece50905cc8f40e948b0b1b9cfb6d053cb1599df024beb4b6a202cfdca9cfb87a0f4ffc50cba4c25b4c1448fb7500094d8f84df410303b6c145797e39f69a0cc6d0bbd360722013965780a8ddc5179e43682bd38cf71e3f8a97b3c932690594278cd61781584f0f1faf1719d2ed0b47cd69c523c5a570cec33b18ff26cb53f8b955393ac67827431f9c51792cc75bbe104bf73e447028c8b1be99f47be3c10c4a6e7603ec8e638898c5ae5984963fe1258767cc45603416ae930b6819d559cddca5e5d7cf0775a6db96cf2933b049ed9867efe4699e9065a863a87cef8aaad9278ecbe2f381937712f68063da2cc77eebdef2a9337bfef2a0aba32c6d342fc2147d44cbfcdd0b63b74a39dddaadd2011133e96c8c0764572dabe0c609d279c7435f9dd936df301f1bd4bf83dd314bd4f37760ce403d56caf6a228babad172ba865a04df0e5c8fd7e04ff8374bf9202beed9051b7fb78fdf3b637a0080bb3f856440bbc496fe47067ff00c73d67aaae953b87cb45cfb55da4d2a4d76daeda28497d035630595b089c4a370a0ef67f3fde68f0e8351500f5012d3e04a4e6ae6418ecbcd2435f29ec14da973d24ec1378160b57d44ba288bf98253f57fe5b1a34decd4f602245effc90e7964936efbfccfeedf840b551abf402c8b8320abb1faf307261ca07396983acff9761a0e337b09af83cd6ac866fa4eb261516f33bf09436910929bea5e1f2eac07ec18b17148ea39fc66951b14d21d48357bcf12a5b864535045c0f2a1fbb4944a33a91f0278c2148708363a95475339994c9260bf289d352f125a19216142cc5c01a7e2d49f5b3d0ea8dd7402ec7f626402273a285c573776edd092b59d14694194dccaf475ffa5c22fb1ffe101acb50f506242f4e589b43049a4b220bf13d92aa0fe690bf873b0865c6d7180dffeb864c2b41d7fb565b93e5f04746cf2235b919e6598f54eaeb7280fef48d913b2037c5930f4c74eb18bb74b92f6db3e73829979d0f067e031866d9a2d640f1070c60bf42ef4dd016b1e1c2143fa6b7edcb6cacd4152a3408ddeead7fb887557b440066644ce5cf34c9e5960fd66e3b513b2153c366039f62af4b10df4dc2678c1498854e837f90796ea9b7e4bc4732ef2072b860701e141b8f0c9eea96e2f4e47c91731ed691d050b14f06269c3e9f2e298216f4de15a5cb8707a409dac4453e23e32ee6aa195787be2b60506b46d92221c6d9a72ee65dc760266ee6eeb0dfd323b2b473d9f4c393650e79b4d0dd44a3fa024e380dcc33670ad749789e4fc6b6ae35ab596291893c10c21f833ea7dfc080299e55da24d8a73698eddc531b6eccf729c6c7288956fdbf98e0b8287c989ea773bb54dfb172a35a2250292d4090ef1b51cf9e008160e3ead99b0dcc712847805d4f896e6a797c5b99199cbb17b4de48c7858447d9b1ce6f26929d6b04348db0a08e7902737df6483395fc9105c9c446f2ba891b9e4439f483bfc1eedf4ec9cb330dd38c4088876c88d740a1c703f52e64dc397178a786c627e17164b1ea44d86818aaa88cd8aeec5d3949f662acbf310a4691bf329a3f9a5cb674b3c577263d97ee97a8318006caabf07aa62733e281dfcc9522fa571a4aca5490357a75db458c4810387e3785a1ddf5c3be8017ed9d4dc89ebb06b63d2c60b816cd5e675ec831bac20ad2333dfb6d33978b543b2e40e84a44fdfd8623a76dca00516af586b2de2d2c2ce6d9c0b815dc51fe8d5499c3935bb4e29a07d80f2070ca21adb1207fec0e8f70babd4ca7f357980858da2fdd5d7b0aa7f498e02a592fa990998814cf2b18fbf46dd224425b86472f50f9b52fae5aa47d7bde8fcae672cf4ac0595f7d956aa11a6f38df8db5f2a2684fb8efdd1aad1e8a9e35b3e5ffb33c3f1661688d59f51fc17af0bb67e0f4277e29f7fbc17d16974724b1a7bbebd82836ae2d309dec168a3c896f796de2c4af7a3466bc69d4121b335ec5bee075da102ced25361417d4939abfcc3a8418b7117bf0b15c4ca51a95ff5efca6227d83d3b77a771b01db442bdf8111781de2544ac1246bfcb1742f8243b900dea4361f99ce35486b0e550e369aa0bc6fc63aa6487dd7f9a35920cccda9602ff832f10206a3455fe31e17c4b42005760a070d3fc0943ffea545c8348e9177569b6f864b430b0387f4bac26fe1afedd3c961a93ee61cdde26e02bbfca3dd11a539e5b9a78e741c6fe24b7d8eccfe95b3b12690d109be7b58e18c9dd4ba45f4830544bc8dfe2f5ab6db5c5dfb716cfc1abf7d962fccc60d102909210eda95ea08c946fd610a97fbfd73b6dc15c81fdaa0dfadd4a4375eefb16c2fafa8666ee4ffd7ea13e65a7b4ce1bb79c02cdd287e19915577e017da8d6a693056156ac355b6ee5709f0def10009d21103e27bcc3f2c72822f22b808ac16c32cd252026dcf91c169f1ec6692fc38fc0dd8a8c76ced341ac89e117acf4535dbc009a66dd9003d142a49bc46a5451c468ec32cc720596f702cca809f22b65c98c601a8a7b826c27a82ab24a1be5bd103577b95f858d2b45a0a26fd459d7a4880b41feee59e8d1ff5f8f8c8505ec96bccc8f31718acd3b5c4eb2a3d4f784c3ae600ed6821e7a165f5a6686a5eb9815900296e4e57aef0764331943cf68212b8d7dc4f93a33f50e5950f79e572cbade6847c548a750625f01d0e7f67fbd83470382746766e09b3ed3a4babb0a3149537625a747a4e55aa43816a1fddf6ee35e5fa3c6f1ec32b1a3320fe0baaac5de707fbb9cd4442e4fe0dbe3c1e56f4b5cfa516071bed5200094469cca55bbc43842d4f957d349cd7ae8f69f31180e4d6edeb5fbc414af8f55a9020a8fd3fc35badfcc34614e53045b92eb76d43224ee7e932eee207cb1f902bed9c27b8b04d9e8fff77a94fd867136f82fb5fe3235e4537edf3c7c2ab86f5af9cbc58a377318ee175bffa01c11e090cde00cf66f161d9b88bd69e0c2689f38ec7998f116b38d190c66d2899179aeb7c399267b655d7b64593d00ea63245679bdcef896e067905b707c16276307f338fe45ba3c4ecc15a31d60974c069cb27d6613649385fac7cb5836d7a47fac936797da905f8ec7acb0e060804b2b22d8aaff7cb1b7c3ea5823babaac02d333fcda342d3cfbed1da0c874843f42db1380e91c88ee0488d012405ad55e93adabfaeeab58069da3adee8aebcd5a1df4f236273ab363322137f7a650aacd7f7a468f41b66196c72eb0b07b9e9900dfc70b6cd6376a282b42bc8cfa16298041c62b2a36b60d0c6c02b70c82c760861c0bc0bb69e734f58dd41cb58629a15a2a95f3e6748b1de176ffa2de6ca927c67f13d105dba77af32b9b1928b8371a2add09c6d267775eb241bf2027694858ef466643f229126d228ca45d48a2e451e3d15b592fbe11432f1dae73e18db20b76c196b580d3b5eb886b8dd0c27c1781aed31d48f2eb4cf6d2cff5990c50d8036ad674441f5fe572d43593fe4b1edc4a1b81d47975a68a1ab61038138c0ff5d7a4808b568fd69267358e7680da87d37622cfdc976a6ac0a6bc0d19d403888715ed4befe88f453c5241cc2d8df0593459ed86a2c8a8f7ab939fe59930fa62da5762da5c37de3ee8da637a671fe2595b0ab5c0262b59ce174bd62e43c759a31c984462a7d99e543298efd7dc5888f4ebcf6d6ed6cc5bb82f0b30711fb7e4380a386f2c77b0aaa367033055740d7eb580595dd2b0137c40e5af01a985aa49702489ae16583b8c45b323f61a34a0d4d0ebb22c05bed63034649428c8b38052817ad26c13183233dd5ac2f982049c2b9b070e8172d59e3128977ec73339a01302021712a7757b85110b3a119b42b2380f17c6a859b4c91ff2bbc68e41313c1a6f7f1ed86b1edbfd083433b2a72209194bb63e744d6489df2f082d95bf4d1657a9fe82c28ffdf079f075df659ee20338115b80e4b6f1f901bd5d0f436fb187ea73dbc4e053da63327a1d86dba9ccee324865b4f35072c7ce3f0ff195849ada05f659a7fe8d4651995cb0730ca80939e478bfe25daa5b1e119db4860e27dd3ecd3ecf576d26dd5c84ce899e74ad4326ac510f93faa929e0c8810fb8eff62de384ba59219e9dd0f8980e8792bb7f182220247633ea02555646daff49117f3cfd5ac029afdd82c9c16adcc37549185c1f8568e16694c399dd035d88226dca9dcacf065a1f9dfc14081dfe66382c272baddc37eb9c36ca8d43c6ffe258bacc86d4132a58685c4423e0a1bd7e41618fcdabd7ce4a958c4c87d0297ca583ddf55600b42cddd277285654e267ed2a10e668cbb410d5b0ee50d337c7d4f5f6b1a3f23692ef758ad0891f9234cb655e83f7823eec040d321c323ce888c8cee4b3acedac78bb9b8686dd6f2c86c077a5b340544a8d5344cfc920e0769e6154915fd985158dbe5c4ec0ad74cd899eacfe0b75ea9e5dcb4b38f7a0571eb96a380dae656d4a88869458cb18a7f108c2b349a3fb1aa11ddeb37100082c8ce1f12e28f4826532de88b40ab64f2a86330f9f9c896e4510d0239d275a059e7644ca728d8cd4a8f0f09d1c98e2177a8468682f54ef1be6b186d4185aea15bcb4c80c5a3c22f425a701800344f84a69e57b373131dc87f8ec004f1905f90dc9d21e91face24ee8955d051efc706567085efe9e814e5e6297f5c96f2a5c693f25c3f7ade40ecc31a9fc314bee0a5bc4bd4ed708f2ecfa4dbb533ce6ac0f0a4575afaaac82756e8618100333e445992ea6916c0deab57e0f5d4c7c35ac5ee105fb24f46899032c5a64511f856818702adda5552ae3e67ec89954163defc1bf95d76c53be2f1aa3839379a14c18ce0c9f26413a39f09d1cf44e6a43f1556f5588e49d6b87be7e90f8ce8211b4ffc26b8f951f8b6dac55cc3b157d00d733e6c785561dfafe8a6ae911f112206c632ed370c24768eda3344b74cdec328a0e27179dad7aa59bb6023f63b4e6daf45fefdbdffebf9b549297ccd64d4750eea7a28ceec4ad0afa9ff41ea7b507558416bd65903606cb9eecd19ddce65b0e143857abf3a01abf1c1f74e0e2740242508cecc2cbe8d37a9a8d9e4f167cfcce7d60e32e8d70f9223af1776775c62cb9ddd443fedbd418c9c7be5afc7671ca50b236f0cb8133a548b0d8e612d0d49202da2346a63357e0a2aad216052834bc059af16b1f39f85b635cf94b7adc61761a50b8255ef0a9b41f1f002a639df0590854a53e43107bdd96fb074c7684da77fb86d899dff36e9b511a5b84857d2519265db2bc95d735af84dbcd252420792a2801217bb9c72f33ab01e7e8e3978eb4c72c1b58736c494e326e1794c14367362f922e2d3dd35b67a780619bca3132d634cc58537d1f588031595129a2a02e3e8821f4c0b7106697314c516de0b41b17a33991e8015d7b963798a7a62c554f97d5fe866c11a16b38eb6ff9a0e1df9183e8ee97efb3d1060827574ae36998261203956832c2c3165b69424d13235639f9068fd30095a79442e71db776f51c6487b9c62ca3f12fd1274660753bbe87765f0eee67d6acfc01ebc9701516e078bb1ec77e0a2dfca8625baea8d164b7b739f18f243a6b2d361b24156d7300ccc86f555a0c4e5fa6421416e616cb4486a180e306b8e4250f2ea2352e3ff306526a5801f4efe223e8694182e0ff21946e3c16d33f3fc2cb78c9440ecb3e53f5c8cc10e309ddf78bceb9a0711bee5f7da4846c5d648f396fc5527b2e803df50a6ec31f6960d16c017dfb00e5a3c728006b1a9becbcb022c09d332593b5062bce82621495003330e68c5320a27d822466d68a07336047b645fe49347c8df4ac27a8fb9d7d847c4d06091cb3e2be9ef4dd06be1571d1c8a6956354b1562362d60a66f1f5d3f85fc02f84f33956c475ba6eaed482bcc61ed2c94cba389c4a1bbedd8833b61ffcceb3f229a3d1fccd09c157bd5ca1d75c53196837ea9d203ae3a31107b5599391248b30c2538c0dbe4deb09f3d358fd66084e77d79efc4f5b105def47d7ed1ccadc52a9c36991224ea8a6ed1f4c2144fea12bc60bca6dd8f4123af7fa0cba869dbffc9de26fee486c9a505befd7dae9442fc41549a040112b9e98fba7260aafa3bf1228ce279e8db6f3cacf60e725637e9d091973bf92e1bb8b3842b73498da152fcb4a56d336a3e4ee086ea12af533287a345431b36a872a1a445bb9826a519088414c85c5432c4da33dbeba71bfb1265a9b11489843d651c7dbd75c9a5cd8628143dc35847e27e0c87570fa117c8a6f26a607e296cc313937fde5663cd5a97e319d09ea0466cbae283018d85eef6b53f84b46c7329e4f4b6647f72b616d8664d2c4245843a7e64ddea9dea0f1a0b0b82f5d16732f4c919f75f322a8758a0bedfe438afebe7f969815fa39fac54ebea970331fe05965b7a0f3448d090819828f4479b8ece6ed4a0d8440a13007c7d2c7aa87cade15005ab7757710bfc2297c74cbd1627ba18f785f0a98bcb6243ec51ce939ed18d1548e3f028af8aebca42108b981a385277fbaf5846216b5bb6006159bb1a7c240a8929fc33871df42e714cbb318c9acbd2dc58a786d8962b8b39bb857b1c789760dbcd6285aa109e26514ac68db57a6fe8f8c9f5a84a3c44458ae1e147d729297dbe1aae0f83c3e575e9b7fd9630e51bf9f9c660e94bbecd27ece29feb1c6af16c0a48ae1f59c7bc67b67294e5d0b3c027844d89bea37220f82a30135a4bf95bac8449f6e0027d853870822318cec5e527c0201426e0824c9097b23a0ff4a6a73dd7075df24f129a50448d26bcb0d4233c1da12c0196b293418a4e3000dfd5690fe4ef7e0aa3f4c84e0b537ec6c325a884e461fc80a0c5ed06df6db91b4b9607b3ae8938ac6b4acfe24524ef9b0cceb59d77c737a331418487d5c9b95a8e2a3e6356f52feb71c9e377ea58a0a90b3d208e54ba90bec50a36e9fe6ebc60776c9e5adac14840264c2eaf4d829e8dc748d3053924431f4cf8177323e16fac1234097aa28e316e67dc4caaaf7258cfe4034becfe7d8bb316bdecff49582458b592383f064ed6757086cd25383c2428cc3c193f0c2e29c862bfb0404b4b536a6f6f360b4ccced9ae02ab6636bf8b95b21a3654070d8e4d48c4a13cf9adf13b647d4e3b8da536c780fb300e66180b3a00c3766f5070b03594142f60f3061a54be305728397e40d251f7f18f94c3d139918d4ebf443e1d5c73cf3f0e5b898ea787a51eb3caa79d1677ea15d0e12e0bcdaa65fd585695429856cdecc3380b1e7593d57aad421467afccc7fa6e6061ef7073d619a0d69eed6f18263092fb26348f98979de2d33a60fe853bdb98c1888f0772c91c4cea37e358850005882e842db0096030b460cc05cdd83e7d51fe730366f563870f73a41a10874722240286411fa6d8c88ab75746fb12b39296ea01d3fe80e12d0ffc1a2feb5336900a5bb09801e6c150244bc4c1ce058ed5a5fa36ce2eb5fbfa9586e6b30a2919d41aa91a663b88865f7629d887a201407012f36b4db792fc1d6691ea69f0aed1667680d561813262d3c302f4c64096c272b77d95a4a010a5dc3e0d108b9c4c21aaa496fd8a1fb3990785eff32fac57f07d70a0292346993c6f24e6dfd70ba5ec6730c423f24d1f6cea631e23a1dda7b707ca0432b01a9e0657a18e3aab8769099e29575b86b2556e797d52b0ef6f6ba17804c36b7fcf03b1983b21b880bc2b4494994115265ed26346e044e326fdf7c99c2cba03cd66215dfcb313713e54ea60caff1a923a341814022fd1385b85ce5e8119eb15d245a226b242902414776672b4f16ff05dcaec140ffc9f6bfc44235f0b2f050f0dc44edc7f3d7b7193804971416fb73e469166ee425d7436ec9846fc8de58d5e5dc0b584cb3a86bc13f140257280c44bfc91ea67e08d90fe0c459dce3415ea5dd630bd3da70ffb3dbebfde4e45bdba2a81f3401d5ee023029f3701cc37dd58fe5969b4a964d5870d34b51adc0baa22f62af18fc3e748db3285936be50a50ae5b9fc280df7feb5c41076e34ebc039766c3640558220a8d97ea3d2787cbc2bb9a4e03dd2b704e60a49005eb7d442a0afabc4d5a0d437218af72ab36e33b51e3048a79d617a49bf285a2942c6049d45d3da01cdfb3cf45bff924f1412ccdc352ede013f27d7d55ba1aca44378736ddc50b4da693828d6e50e28c2395bb07fc1c14f3e922a35f826523e43cb14594d2dad40b65104909acf01f3a997ff7d4d5d0625ef85ac3073d01bcb623b4b15c78fcb824f976043d148133c76cf8ce6a9b835cbe9f0335a73348b906a839e6464384dfb7a2f2f1ab8d55bbe2fc5255b88dab9434220653342441f124fb97554bdfc770f6c8c84091533b17626c0370b161ca36e62b646fee682d89a7510e3f6cabebdd9e74f9c55f75cf16f92473c8e3bfe7e8914460509767c7a2ac6361995d3985608ad46f537b5725ac2f4fe57313c5db92c05d36faf220d10295ef870400d00ddc2cbbc294c631bddc935b6b033a8169d41a4c64c7b4a3f28a9e366794c2ea248b231e85935a8dca6af37be9ed267a29341c4882111f97e8a0277d9f86e7b6a222529826457fcdcaf09d282b862c284451b46eabec40b502ddad8c683558977a5499e763c4c6a26b694d9c07efb877fca1653d76b7eb4af299cb327ed92ca36ddce46c4718ff96c15d585596bf76490a8918197d8130b9e83f91be1ced4c248d802aafb9aa8884ce333e98734995f1c4cb28cb768a73f7056598870d42951b8daff6d9a1d0811a585773ec14b324b81db32affde5bea0d171d1866c31cc1b8e6a64e399605225e0e37909b2d58065b6a6184c42e3fa79aa412133787e6ebe3ca4a03c01cbd91260250ab342322ce8bff263f10a5122b4f5143715cb448e1b7e4190b847beb859e6bc1b30c92ca156c9bdf633a9fbed4718879783905c39901ece61c4119a8e8c6c02217b8e1392f16a0a2cc7e81cd6b5a7cdd9fb9ef0e32c5074290d36d8be2f21b96da94e973d7171e50957d2fe871f774372cc811e263ba00bc7bbd82aaaa48f250943fa5c487f0aec43bba1439dd4b6ebd5bd6ade106c9436d24a503529d451a15601df91e47931fbe0f1ebdf75beb0686295a37d96891b46a15d5dee23b392254fed486df69eceabac974fd9e4781befad94def855ce64f12a1bc7572e2c6f6f6cacf91658255845effeeab8ffc4a84e392ab9089b64e9e59216b5d103265d9031ebef333e11f7224b39ee821619795e53af60c569083f6870719afd368e1a69cf514218c6710386c6cfef5660550ac8fbdb2582411f38f06afa0e81123d96d0f7e883db51be011281c69a11d6b6c7d4d9aea4748ad436530f2fd5c614b4255f329944061e2bb7db8919f3b9bb37a87dc55aa7a73c4c8e64bb3d3344951e3d28b91f929e2fcc296be6a4521ab271b311cff8259b9470c7d18e7e9fec018d831ec3d39462170893fef3762d3a6cb853753790a2266984fdb9931a7d0e176106995d91c838a449b1c3108e49f4878026d44a75803fb2003220bd19df66a7acf4188fd2cd45da3f15e8faa19dafabe6fc7ace38b4ae1414fd12366fd34fc302cce05f738a718327f5ecbbe36a3a536bdbe046d449fa60b8e8b18241c982714942f786fd568e9b0a804971bd4423dac74fb9e8b2850d4e8cda70116f5d4bccb45ad3dd5d8185fcdc406c2286d0f93182b557e425fafb3c950949172a539f07cd41a50c1ddeec64ea1f0e38ae3e62a2b11217d4c187f919c0d09456af02d3f70a88e025bc30eea3dfffe4ce5fa3617b067d09f00036e52dd2f0a7777bb4334727c684fe82e4d1d6e13ca4786d9951d1504dfac79d5a36acf94ba02fb90d76cf5e1a7704e0404d5d905c0f5888eeaa5d8d0116406c85d8a8550fe5cdb1d4182a6b992bc43f1f62e99726f5057872536bb4905ef78189b913228ed4fefb593b8d4beab0059e34724d5eaa1197e19897c22010c656587d99c5f1815c238cdee94ccf9f8d4cd8e7b55fe7346c473fc812a3b1d5d7cc0d9e13c8bce8c3357805ebd034b9aa158e88da2ba042ca04acc0f220dd892c29859a42b662cd6da240c4cc4bfe7af50a8ae1601710b8cd2458abdb7e3fe78f6d55325105aca908b24537ec1b3d690e66ade7d4217e864e5ef1a2a0b22712b5d039879234771fcd0415baadaea72517a113b40bce96fa4f7a0c320b8d9a8842c2bfdd2c86da14be667ce931d38eb99485fcd4304016a22d859b24162402bdc64b2db9c6a490cc6769f7bbd4d4ec5ccda0e5e3c334e156b9578763add6e1815b4f591a82eba19bb4fb6d3a98794587d7c7dfd1f5f62a0594c12858ef3aaa1fc3b21fd69533b62446eef6dabdbc64f36795a7fab3f8ab1823fadb6ef0ddb8cf8555e0744480c36d812dd824542742990dcccf9f62e33df6e81adc6263da9b205aefb17e5d22217acc451711c8c75bb97ae5f471af84238a5bb05d38b684980064fa59ab3d3743de76e483c762f8bad84e64989e12508bc85dca4e40ea3cc79617a1b804a7ba812a501bf0a4b156af8bf8d54a091c3acdff3b5a85ed0e869b1ef6418c1050382b4c740c2a3e5c7a16e3acdb6b5bcc1a10bd1d6949049c72a533b333ed39e3a76779aaa54f713a5f03213dfbcb326714d1c4729ac2905b2f81d0ecff736d97ca16044a06d97e7f5cc3b8e1ef4c8b9c563e2e21f13bce7051edf4f7030e83edd02aa0a3a093a060e24d65ab0e3e88a53b3a27e7b8f4308fdeb0035f3a6f1eca043456371243a8ad492212a7d0e4aee37de96fcf3919918155df9bc556bd96f548352d78a8c147358a591957818e99b606a68d14db5ff5daa39d780f6c52db01099a8b5e99beca552fd6d556e6e04e4e2d0bb5ea6059839c97abdd16e61feeec0fa5395b759077eb79950c7cfbc9ef354b8a21d0132ec4078656027221161d27b030fa809f54eedb9dbabc43bd7ff285b5227995f4169e6fc1e89dedcf7f08141a2d1dc6d3fd12ce24f40c9ba6f3178dbe8c638ee83ddb1dc4897471c2347d3b0923fd2099e42fd19b4a869e92183df8803efda0f40fd089d89fa04dae8888685213399b5e37677d02dcf198be30aecb832873f520ae28783c5b9b9f476d892f1263c47bca9e86c972572433fe11b4eb578674295ce87e9d830ed07900cdf8223511c592c083658dcc7a8ac522bd37dfb7edce5ee4f4c80705344df05474ce18b114be5e101a2dd9ebc562ee75b8f6f1c41252d164c763e768b7f1b43c54fb5b37f729eb49392db4642b9baeb8c74582e9bf9c65e7eac4ec59bf472a9251d0fb64cf1a57319100bfc79e1b39e89e8820236fe878f757c3c49580cb5d00b70a4ae725b2e99a64a30215e309294241733919f53b51d8fd4ac2b91c658c16c047dafa3f5eddf0313dbd48ddeda7c006f9b4dfa071f977189a6d0f3325b82d91baf0f9c3a61243e60b799d278661fe724e153929f0a450fd36ae3b6f76d14e1fa2b256459dd3b16cd6d88075df74bffad30a3d394ed5191cfddf58ccf7534ec6a9cbb3db572ab2c1614add34020b6cf45e2d590d2f7fb8afc7e748705597f26384dda71649f68779e2d727ba97af7016bae09463b6e9e7bbef1f049fe1dd121b52bab73b1d10d6beb3b3be7742d324662f2e90722d59bf5df15052cad59f9e136d294d59bba2c4427df90df50c30d8db1040e1bd1ea72b709b050ae1cee1ee895a4d95d5370a808a18680694051080ba5991dc4037288a34da253f5ea186da6aefc4d20c260412c4ab111201eed551dca376dbd6acc6fca9fb426d3c8d1e37de366f7e20114bd3e39bef2611374c83576bc04e32a65bcaa57ed5447fb78650999eea63bdebe53ad274dbf2c21a179683ef041125ceba560b1795742ddd55b02b97ae0c45ea54d6cf42e8289997331137f2b89ee8c5c09bf4e2676e85c658e7c303aa180354dfa5020e65480a5e5c25bd60ab6383cdf9032b1670e867af803906f20d7ff50806bff53b73ea3bff2d8efa8333eab5f6d0cdfc3f282e5cba209c9eb719b2d4c1f9e92d549b56238eeed859b2838d9de4e459e50e555bdfaf8b8df9e6082adfcc3fa9016d86088b229671c1b2eb8621764d666887e2f7b449f974984b89194e633585228f00567a6eb0ed9d63e35ed5940d3287f67d3c6fb272a311f9cb0e4c6a2e9b740c4b688dfb566b84010e8b26914485dac8b46b604429440f450a29a0bc5c2f9380baee6fddb8bf110275628ff68dc5c6e81a7d25a37a0750c1cde4e55b2db5810717500f469a810c1fb7a2b4aa9221182827bbb89bbc7e6742ed661fd97beb76997397a8a5a2a4f122f416c687d5ebb8ef4716c330a18fabda17f6c8d3b497708a66d44dc1d3b9e87ce3d42eff4cb5a9a81e0e78f550b107c842d36434d2c78596b20b1d96f312de5a8dfef6781b1b392c0794ee584b10dcbf610c1938a12cdea0ca545c67ef7f2bab28467cec0c617c56d003b1343c282c656f016a2b0997ceb477189b8619fe6d27a27031218bad76933f98e0b5d72610f7de75fcc3e87adb541538d1ddf9f20c3ae96439a1ddfb414029dbb5270265f4b0943751e09e3ba40e860683483731363af6898bed34fc144f98df883e95c1ea3bec892dc9ae1f8abe24272900694674c351d664ab30adcd9df10c8ca52693344f0fe00fd68c866b711bd9499040ccc5f051ffcff85d75d962ccd9e6af2daeedffd4493aad435254ca096a80a02193a3eb597f01211fd9aa39e558337b9a8992ae0ce9cc3fd764bf4a3437474c397bfd07f4764ac8f11950e66fbff1d817c785cc5d58f5965d5a15b4df28cbaf334e1c029d30468fd6f9745dcadcf979bb77cb5bd8fd2356006dad5a8dd0c931a9c0afff53940d7301c809dcce84438b00a03f477c0755059261ad8ee07cc0ce31e503eaa6500ffc51f26cf4cf38726ebba60df0df56059e4e9117d64be8a03b28efa75a30672d8d8a9a57525f16f997bee49bfe0bc3832a0ee5c03cc8847ad8c42f35ffa2dcece8f7b5992ca88e861629a4ce18571bb73e955a84c6566cc104f832bfbb757da42766bf007e41f8c5e90ebb416c35f91e65c13ed5f7e7a598a32d8870d1ad7d609a7095d1f66f05805554531339b6395092a9913e4938a3548a4edac9ae7d6dfebc6ae54043a782de21c2f75926a496b8f35cc80ab01f0d6d06b104970d55f5925cf7fb2477605071080cbeb901386d1df0b6a5f2543df497821771a9cfa16dbe8a7305a5c2761d3c3a0b2430d3b187c94a34af4e9c32673ecf4d3fff154a634d7928f251ba8da04bed9493fef94a46efbef27ef3140c7d0acc3e8d5885d01908d6523ff418a35feddbcf2bd9f401fbc9843d5745ab507648b7f17c23aadf76a1594668bed0e3cda8d61ab638a35944aa182109368e2e68231e528cf28b1c71d700b69a9232ff8084f03fa9da1bfe0b9812557e97f580c699a82c36e346fa3e813dce2a24c34d5ba39f03d06d90b70d4570b69956b1b9b82950d4d87855a590e66b4011bb4e02b1874c7bf4aacc44c01741c63dd19d28795470a303307389356462b7baa0b28fbd1bf071bd997be1907e1bc9ba41c875420a5c1bf3be8125d6e83daad9ee577cfaeeaedda7d9ab4c30fd60eab7329f9537ffd8734a71d41e6016349db803a901a555ca3640ebb14fe44440549bf9b7bd6ab6e537a66db77ae161da7c4e1e6eb7dba8ebc88fb83dcdc8d4d46eb24f066e2b26aa2cb4c1ef090215f5534652ab9c94d8e07565c7f851deec6dd4c8749195a533bb25200259b5f90c9423e302962b2277daa079ac001f1c7bcbf4950ee86b18d7c054b80f3660003701541ac6ca57e4c119228675bc858c9ec1ab8a0c85a95519c3a5d32d0923e3c5c25f2075f3e304f14304615eaf1689e497b29e2e6a625e05f322f26c713c2e60a47fefed11de974e389ccad0a65019a79bcbd01f824a6eb5c8662632609dfa6ea65093878328fcdef96e56bdb12d06659cc7196d706c6f77f4f7ba300412f96e2ee16f86bc1f09440ef75568343ae7a753d9458fb56e1ff893c69ceaecc2732c90aa501a64eeb95edc990c2abf2aa7690a9499b03e9ddf28bf8aced4aa51cfbeda8043589155737a54bfd77003c54d622e44aec31da85266fe1530f3260647d8e59b8ee5911b9502925a70ab3d71151d5fc4699eba1817e6f0e44bf8bf38d4260f8e32fbe95fde2cf8114bdfaa6a2180812939d3cb253a59ca69252bc8ada340d2717544477bd5701463be98d500fb04cf3116650a8f75f5887de3dee6a6d53b197fc76dac3cff7bc9d4f7e29eda36ee9937decfb0c07b7dc3ae91493e7e3315c27b8b3550b2ae012db659b11c4c2e25a4d7ce633a5856ab33ee89edc6647a293c8fd16ee3751daa8a401b08817a230ccf12b289252b7e73d9a48a041768b14d03d2b74c0f6dc233874ecd458014739a4ae0ce5d583a1c22dc5de97fdee09abfda3ee4c4bb0cf5e1065ed404e5f4fcef6be752d5f351a870cdebcb2902aafbffdcc43a2f410c59a92523cd6bbcf5c770eeefde1b781868fb43029a73b47c899246ad2d4822139a5b246cac6f5bd3256ebe9815905c2aa71d50c6ffc877ca560b906f7b1a3ef69957b38b936d47ed986bf65b221993e2e7c73ec8382bf7f82eb7bd2006a65c695d68a1a9d95357d58f1710c5495656fb4b165eaba6171f866eb193c6e73bdf697c9913960207a76d9e21a439b7e7eccada8d8880038f004f10fb95b324e03302675d6eae49e09c746ec8bbb4d9f9e2e42b9cbc7582ed5ce3b34722d4db1746830a2b18abef9c9c6b674c6d693c3a5bff6ec918b99ce7a2f5455d19b40ecaf55253012cb9bb5a835362681d7a3f7137bf13552539ba67e64ed0f585a2c2d39751d63f8513cbb17b8c3dba7e4b093903efc8d893f5a7344d447a7fa8f9aebf9a42e6cfba70b148c638effd6dbc714656aa9bf8768c1a373e27b23a15147efbc4b6a72c376bb6cff5ac958e1f3832400123cc6ef841a8077d49ae9a9ec6c49b21148f18e1777406d7ba6204f2fc5c474bc35e338e05b28ffc5574c62015f1eef287f57ae718a8858184ad6da9ed24ff6b4abc22ea1cee87dad2af8916d7e4ceb25906f092996ad46c8c9b1f27392e061ebc5497260c719a9701fcaef06d0d403688141971cab403e4188c638e3c1c1b36409f5f50e6bdcfe08c394a925c068f51190cbe834e7b34e4580dd03d756b68e3b50fe812cba8b3cb8e092defedca76892d7259b826de3079f50d0de717548b83091dc304e5ca6e44c01cc25cf916762bc3163e8acd3c0ff2d1bb60861a3cf9bcbd811f3f4e54abf76de7a04d52cd6d06fd1c717b05edc4e038983f2fe228ac60a16a60cb4921d582b3c9a7a1bba6901d259bc07eca8d8118e85d7c545a0f86aa49c1f94a7ad937d1ada1876147d522b16743aa8828b0eebd7828ed99199a6ddd67e44f63a222ec2326fd95d031398e5d5254e810665c87fd1585e3f342ead1bc92072723fef21fd35e18f8837881fabf969ad2b791785f7ae112d39d53c89407ba7e29b52764acb5d2ac1c316ea975e31ce55d39957a48054350dbca6fb500f4725cad994e1060a109fa7d0f71fb2c1fc1696bc8327b7ccd265caf56674f06ef0a5cfe8af19d15da38581e2cc1418fd432ce8bb9c96708ef35eb9c1328ed7e8457c08572d06f2ab3332dc229e7b4e1e80d085b9d320dc01d6aa0e33288f6f295173460a1d12b4a08618c22ed4b80b9373e4b0352f4710629b9d5712d93fc18617c53bb90b2fda2b00864e9552ba95b272393ebfab3b0d71236ad1588d1af072eaf8b16f49d0eefea6f50d5c62c867313c34107e6abad8f4d86142b45530920a480bd30b809833123930be7c6c99b8ae61c2d4ab2f6a31358eb1a909eead778a4b814ec299b3972050aa75618432782940648814315e657f692d92ed6f2a28d6ad49f69bf716202896d2f56cc25e0485884df69a3493f0a4e1fd142bd52937f2558d49f2f7219aee0942f0726ec7210a58deabb3fe81897aca3fa1414a7d948a79d145f5cc5846785300533cfaf6bee6e0f69be910212b5971e96de3506b286b4d0dc12aa3336692284e4405ccd0a5a7a2e7fc58b8ef7c9fc9861376b2c95e08469581e7173c3d4ac1a752ffd84787c23200c2346ce4b22ca99e2b954273bff6e7fd42d9fff222745cf181ce0f5ebc1095fe6f417c58a0e614d3fb9071c355702858d97e7d38b826d4ff4a0b93b6ae4c24e1f1590f4b42369d0e23e8ae0174d35d69aeaa6730303d42ef56c2c3441a960add81ea7195768aca50f7d59be65223c0c0e60600dde1d7b4f9bbf41be240f3497bb075b4eaeed199ebc2c00da5288579cc968cf9e904d7f2bfc516d9d4b7ca541e12109abcaf02094458c9e02096c34650920dcf6191655036df917691ae68367221e5d65f9495b36783429a3db4cba7df8aab6947b76b93a70840f8406d7d4b8973b19e0963087f09b931db6e9e30a03d645f174e4819e87f60f404d6509d8aa770468380f45b57b702d2a2f412a807c4df74d129bb61e5d1a9f3d0bab9c15cfe6209a39ad494fb5a9013616da48c6a34020ad331257ba1c76775d86139c305dbd27427e3893dda578717d9a7035b7a94e1947f4fa463d67119266a43cae59c09d695130164e1fdd79fb4d3de1b370ef8da5a9973385616a75da70112054b956e2e8e62b94992091ae1f4a1c81666b35a8af8c70bf95910e54a0d722f157cd618d21376a6806645d255986f24e1d2cdea40dd6e32e8b2e4651360e0aca5e5644ebdefd4fed1f5baf0e19065af738a486820cdd392626d89db211e8e5f1f569a55bd7f3905c1dd615e7b849cabf73fd6787460953b50d83e8337b573d45782eefc3835f0fbc03e5c83e74edf62d9c8c1135d8071d9c7071483b80cab2c40844f23da1686b5793f43a8c77e3d4ffe9e4e675fef5b14cb517bc33ffba92c3a550ac3613dc71c338783842ed56dd39f60a9d9fcbfe40820d0eeb6c7ce4c0879574341de560d4e71c4c98b31ca00adbe51680702d8ee1711e5a4c131c6b0b53acdfe03f223de1ba4287fcce808638abed59be1d975b68609b35433ba98ded0b560b990d6fbd9188ee6557118eeaf6e7cf76e4dd3a727a99a9f0a05f3ec445a4f9c90b54e46fa80b0bae5374f0e54cd1de657e7f1d1849072d60ccd33df02da0a70fb7ec802209c9a5e586e9dae7f87e974d8cb942a5d7832c7cf9a098102b22eb212fc8541f2737416264a284a6935b796ce87f83ed36be0a5faac1558e3a8c5996913c2a90cf77d25e2a9c5106065e4e654925b6d33dde4e67b33f6dcb4f7fd4176ea6cf27de3845617947c62aeba4a2433f2566bda2922c6ad8f48f88064652a8aa1496c9612857434053f584c1665b1def0cebe6b44b9c58ac49090a633a9b95a66ed760600c0d188de713b6233ad120bfdb94458ff7b25f208d6f503facfb6191f5e084da699c35008e00b9b613e73ca1edeaab4b1e26dfcad1072f199dacd1d30d52a760a7222d21886fa4647f5213e9f8ff55f3098e95fcb19c30bf5580d1b1e797a291184cc88123cef4dd5970fd7c56dfd79555427e563a999ce1cc66ceb0eb7ab08778b22630ba304f2d60b5226cd14ed2990ca7bebf31317ff0b6f40e76a43005e0695880ecfe40962c745a53d71bec5b436e77cfd9be458e6323ec7cd20afd51a64e5e853cec3fe1bd764e69fb9d4d8e3947385755925e75b6005a03d4eed17260e543084ed319d1f4b6497c1e08c4ebbf07d3532ff2244a0d1c650bd4e1bc6fa64d1cff40325cdf09fe55e197bbaa380ff8fef5ae0be6607730dbf53735b7a96da0f3c8c1ea8306a1ada85c03f2d261185d35b345fec34739b9bb8b0e498dcb7a0716f5ed738965fb03d7aa314167b8817c2e304d2cc0b9ecc966ce57199286d706d66595458881073a8504240221a3741e2370970f83b3542def0ac4dd8b1f24496a201bfd7be6ae5363d01e335cde87a61c97838e78ac35969ba44fc425de12353a73e47d0a91ce82c1a091af1367bb80f529a0519af6b1d6228d5f31725ad4c1d7f370367ea7725c2e6b76d7547c4815e4be83d90d8727b2ff969b1d4977369cc383f3e75d92327ba43a16d33c8c8d18a7545d56e259bf4c9d17a4457541a9b1161d108eeff9f7fc5f81e9ce2d4423606524190092a4ecb84ba03931592bd7ac3919e1b629c96b12c6d710b285c78e988a96cbb917197fdec9e2dd8929a6e6a06e1a85f5322ffbef032704edaa261e0f306bec889f6ee937ece861f0a4b42cfad6d70ad21b7108a6078ca9e43c01f074f37068595a9d30eb87ecbbe9a96af0e6cd62f953ab704721d96d75a3d1fc325bdd074d7daef35fd82463e1022003e6988c22842de30a9d5ac85f73c8200622734a82c3d1422b20500a290ef5323840cdb5b00cb3b65c365ff6583ee1ef77ebd255ae872aa0c9bec83735bbb912c76f6c0cc2b81df4c4271caf64dd87a6abf9909c5aefea670d460fa7d27dd755f048492c86c116e1041952a20b4520d16f2b7e78c978b15817d99f2e7051a088f09c5e8035e876f8fd97aca6b3d97758b657296979f4976696b0e51beb82d15a689efa6b60f867ddcc68cb387cc1556ab8e5a5d908dc337c473d500716b723223408c4e1fb44780bed7ce01c65f0f062fff0f1367e6dcca22876e0656fb968c977e369eff5b36c6303141ef9d6198e622ac8f99cff1e9c7889b080524d0a5be275b09dc1ac32faadf60790e278964ea6384b5d1bece13c8ef66899e7744de940d2f1476ba2cc62caf3f5b17a24afea92857eabbf1977a0ac4e9e115509e22cd176570d42d50105d37a41b5cefd74b30760a38816698c7b867c979429297fc9c2698d2514255daad40e5f6d716b18385aa213e8ddf8f21a3ac7abb3286767a03b101b150d0e0495c492c45ccc0c4f2e0f393c0b66607b5975d3c0bd358b666b33f38594c303147dd0698d60bbb203654d5f2cab1c4b5420eb5e1b28d973f9cb0f03d8f96be4a3ddfdd2ec1677a32cab4a7e0a1ab08f465bce66c8c1fb9307991f5de8f2b5b3403ce67a10a2c9397118316d7fcfd064285cb947975cc9536b2b3146090a7ee4300eff5dcd73d3f7e3590a03d425cd5da9ed55977d5b5e774089a257d15f2de7add1b096e0c38dd95812e1ad0bfba505963823fb4c054cffea31697b7bba49af255dad8b283d66f8f1dca2b551975966c509a4937820052df14dcecf44a8c1159f80fcfdd4d1b1b2e46e2cea467e68b9cbda9ea6a96f9d8b13c8d386d2fe43a7debd80bc89adcabe7677dd4fec1ba551e0dda8b9760a8accaa26aa6e9b1158eeb0719df933cd50d15bd5c60b12bbfdfb8727b0a2e259e7feff449f35289d5899ad836521fece4d5b25166690f20da59b902d636e2126ee69fb69af18f9f732ca754109e46b9e8b6b18ef63bb73624b6f7fa3c549564a3d7ed60d906b423127e2164a1b2f650770dd7ae0cf6289acd2ceb770b9d10e6f030e674f8aa7d434206e98104b10f03d8562dbf8f0dad4a9ab8ce0726bd8f6535308942f5ec24263653990c6e7117b2beb4040d3cc98a674497d5cdd8561bdc17fc526604ee79025175861883fdbb16b26d832323c48ef800ce6f276e7bb356cd1c543f8065536a5f81c9d4f4142601856cc6ba0a6ee1f1b8a49e05a6354aea11fbd9df091a4d252b105dd599a71b82f6be913a618c2d6c4522596c4a028e3c7d6aa73a1b6bd6346fc049d4565ff225601591b2f0b3164b239a00ca7951846b221dbd8e9fca90db69b2e2bb081452ab5448286af3d1ffcb9f1de518e407f45dda2cb253053dfec16b0a120c4a57c7df34d1d369afa521b77403dafc23fc9fc6ae949c28a3dd7f92cc73b5ec5de9258c0b4d19a04842f12c2867da4e917f51649bb489873757a4a69e980a7fc342bb9a740008840b90d64949a9bdc866ceb24842d0863fc16ec69f54ac2b40f40b51e1ee4f49570ccb321ad0eafbc2d89ff92f3f9239f7ec76fb044de39b8e98a4ff38bb43c1699902b7987c938236c79a61337d84083adadb5140e1f7e3a40d9fd0cd560dbf00a9990ab10dce987409dd76605196d3d108985f9526a43e9b704331d0b17cbdc31dc8c1808e0bd446ee7730ff239e3c6fd5c020eb082b5542820a35f27e88b3d07619a450c57d1c696fedda9021d37fe20af92583c8d30be99f23a85a5bcbf4d942ee4200059bc18fc3b7d2d1c352dc66b3fc12f82c635e5fbdf0f1f71903a2ef77f8dfdd3e9f9e6b6ec40e48029a8cc283176d1df1aa4cc8c489c75c3092a9d6a3c1a324380a4f5eaaf27a28a10f4f3df0abb99a04f8d60c0138ae901efe570fc324249b331e73d00b97229d647a7eaf39adec5b41a20a0240fb4d7eae7178ed6ecf3a0c3563045c8afb2ab6e587ba2b872927311c811e94290694e912390564fdc82b944122ba3cb0db9d8f654520056fbbc537a9739f88e13ea517414968661fe51bfca4ed7db88ce8037642aa12342814bfe605d9aca969bea0925bb74b018552d79d5115f0712a46cf13a20d935bfb7b52d8db18456c625632b3a73cfa8c100fe889e532fcd6b60d96f17aaa29f1704906ab3818a263b807f5d952b74f9b2c70fce9bca07d1d3ccc1cd366225e49286cf69368c8a5138588a5823faa3983ea9b9dd9befcf37fcb0131bb8ef8bf8a39e5727cda9856f4e9c4249b2dbbc7aba90d362f3faa47ac39a253a090157fc9824aeec455fd6bb8f45a4ac8d435ccf8291668ef64529e961b97331c764494cd46443c07f3f0ea28ac1c8782f2850cfb1558b464025f3f22863df89fb2b77945121220725a6fd2273d905734e1bd01c6434c7015b17f88522fe45bf7a6807367f2052b98c3fbd7abdf7286c40814298d25bc0c125126f2f5f352962457196843a602ebcb131934c773303f365c63e46a254aac55c00a24fd703f17dfd6dd48479a03696341d17e0b076df04823a9eaf2f1e80933bca819f053d7103f708c0ab82b96f77cd3329cdc6a7efe4182894872135eaf0764be5633423bd25fafcb2d21e85c511fefccb884c4f0454a8dc7f0fe7bc87bafc1cf2b0fbb00f2024da1d7fc3a8b07cfe334561b88006e0938cfdcb826157a7211a20aab24ae487e69fc7916426d40f3928367919f210b691d2ebdde4489076740c3ea6e4842bb7ea82a0c6a4fdfc5a35ed87d74977a91a9ee163a98e93b4a823d01be7cdfacd5698560d381f5d363ba85d1043b8b65173354dfc3979f98f7d046eef43374523568a737bb9459ce9641f4168f2b33f2e7cb2d80f3f5d5de6a92516313f1c98bc36213293ee7ec6a8a9a98cf3231e661e51e6b1a7be89ba20b3009f9547b3025c07cd918de309dd567f43e28f62e9aacbbbb286ea636b54b044ba69061d2a4e09bd442c82c080251f4eecdd44ba4edfbe2fa58616b8dab94485a0ccc114e65f1a295936064970bb27f8280879fb40d2d726f037f0a15230eec9231934342ab8077a42cee8f1b3de32287627bf2e3db56c1d010763fea629bc814d290be98902a5c7037e043f08b614e75e6ec871a0f3bdc85ac96015db4f47495d4b32813c47f4eb30d8be62992bea839e49ca1c12bd8c43c8058d416f6258b0394af0a279385f12a3ea78800e2203d36b2504c0b17da853771d4a78a820c3fdc767be4a5fc33489466d04d8dedbff9ca52503cb7b92615391249495053dd442ddad251a3f3f73f741a07659c246a7effe1ebb9e69e50063cb099634d1da0077d5bb33e4bb6310b77b5309195a0033b2888f19dd1bb250d5dbbca0fcefbb22f13fae12b9a20b64b70479241bdf4fedda037375e6e952150a35086f5ee2240795b5d6383292f4d0d46bf5a3a507fe612f664172a5fc9f98a90d49bfbfafbcfda5ccb05fd817a3590501918cd3be6d99018baed16b6971301a3e17d889e00b7fb7effd612a64f9de3f89c3fa174400779737e9b5c626b09403349bf5212a4a3fa171fa985c62e2b50a024a90c2ecb3605000f05a258872ab257889ec19f9b12847c7e94f152e576921a0212fc73f04186b04a9659c8eef900b8dd76dd20e2d9388cc67372d82c8ce54451986be9d294b2cc48ba2df056ac477a204ad05de49f64f44f665860b46ddd8371426fad88b2441908627d6371ae15b49340f6695e6004a3364eec40be8d1132ee75cba8adb0e9e40683e8d2251d410935237e6294eb1c24bd5444920856974955801dc6fbb77f54dd97eca9624d896270e09930bb6461e3146328b98aa44cd25a1294d62585a488041a9113044309e6b5093f3198c2298c85a906baae47f2de2ebe372548ec9376ee0e2438f13a7a9b2a5577e49852b9013b1af845118416231b7ec3fadf52568e737806c6f72246668f1e4106e632d5a9b6edd4b37f95cf6b542d0d9461303f8864e088171e1c6a3f85e1ffb23fd7aa03fe1d5957df2446856b0cfe4c3294bbf3bfd5d7871cff28d988c17c79c28806c525e958e8e5d40f57f03e1b02039e7061a467f8c86ed68d165b05777c0fe0d9f7c55405ec0eb85941a94b9eea4406aa4299abd44cf660be000f96c405b45012d238a5405206dae20438a11d6db99518d8313b5813778f1d24a182022d179abf4143e802b9d4b6c6bf240ec5b0eba7e0c95eb39c6f50093e7fcf7cd573a6578a67eb6cce0776bc17c90e471eedb8b0f842fc352696b3aaa46de459ba7974727a79ce44345527d14975326569baeab3d7a94be62f0642005b384a946629ffab0dc83cc66848a5ce6c0d8a6385e44ccc7350116f08206ece513608cbb8015d169edfbf0ee868c80037838fa1688296a890b5ff7c7e7a308993a6bd3f395ca3991800747c2a0e69a6dfab0b642954f4085e31f3405dc9a4de46ae49582ad3f1710365cb3269e13877c90b6f5396a90042662742f0f866e92a8124131f292931add417e79772234c19fd7ce7fc5e537bc0cc170f43cbd22c00e915cec35d543eb29846aed68e2861ab733ac54dcc60227edc291bf91fb72ca7282ab0153c8fecb5e858326074bc903c311ac91b09aca290e6091151d1478a9a3055400bd4900344313dbb664c60f6512f00a59efa76b59a7034a190140c40064a7e5140b24e21be48a80c5fc7940b6317d44ef3a89a2656b30812815665354ff906437250ea30d65541128841a2e55fcd83c599370bad12693c17f02765648bb05b550316acfa1406f4255ff7904124cadc8ef46db2352fec8add2e3ac4460552f8bb79e82d2b5414e390284a434e08464684cecfe27ea3a5b938906b0c47bc828a19ff4b1712441fb5bc6814e4705433a67bd145e5a878cb4bcbf0e347c3e1cc1b3ee2130d43eacf35c86c0e1bd4c308fbf80e5663ae4b6f7fd02a41c7c65d926d5214a3b6351d5085d7c342b96e075c745c79ecaf8dcddc6deaa0d3d00048cff016abbcfafb07115085c092cf52444c14f06ab3304a464869f7b7ea4aa673ac038063e4d527a9e1c84ff94a618293bc23cf1dfc69d30dcdf17a5831b3dcdfe15ec4184f6c0457555fb9cbc7243b815e03e133376f4d11bcdb97701af50444e9dce54e633958387a6c1ad32904a78d8c23082ffdb92c533a81f2705df1bc8b0005d8a9c97e00c7df4fce761a5023adf42c35faa6a915692f1913cd82c8b654fc03ab750d55d855edb67b5aa0d6dcc912a44560762d76fd838d0981803a9571eafc8c1fcdff87848808b5eb0350533f7b9174914e5b5e4cb06a258866add46984db06b97a670bcd0b2f13d7c3d3725ef5f8aaa1fcf432a89ac28d641bad68f67112957aacdaf8fb8c3a3a92994756eb65292d07101e73f7c51c669a28f61d875bef9f3cfd78d3ae7395ecd38dfa719f892ff92243c4f031d0cdf633975d01bfcc6ee2fd7ce9feda5fc56e151dded9a67ff5a9af737c89e54050003cdc2704f4e6b9815eb13e3c4560f202176c0f932124d9d9542bd6a3b5a778fa46d5a0d6b1e3b77227262af20c79ae305c8ca264a53ac3ce19b86773d50a9f81e6d4067a34675d4ec18de1e41e7ab7e2acd0e167ba6809b1ead4144c90a5179d36bf1a5bf1a2a360ba71576cbf25ad21913173ac5e00a5ad16e2511bc3f694db5336e7de0d4851914573a9a907a7f557dbc115a17f9a882bd3ad6574601f4d7bddd6902be349ffc0b71be6b661584a981d33e99584811eabb7cceb7aed90fcf47a84419f837003580b3d8c4e0cdaa6552d6a7199c5eb39fe4082195d020c204a52c680d72ebb2a105fe265f29d789458a823c8250e0605464e3987fdcfeeff6794338b63db926d7575d0a02b7be30b836ba8ae8f21ceb58ba48c80e293d366caf0ef7a3cb5cc073533964618623367211b9271ed30bd13d86adf1c7f267f1d4a1c3853e69b7c9e15232d761ce1401e1c9f9fd03767421865ae85a270701f86ac50fe40ad9f975d5ef4290138dc4a475ba0995cbb600d34e4de7cf658efd9f01ac996a2ca88663786f77c4e330aed15121047fd8cac2803db4fb41a9536aa83214974a85d50c8af3fa2c2a4907866d275a071919851e479c7bae5fc2c6890cf3695f4a00ba644dd5811243ef10430039948fada0c4790d413b9fd1700c10f6d16f63c41cc6cee897280c7c767e3e2c2c0c3fd285cfa06d4e14f14aa600dfd396ab9267dde3a169e44d2d02e041b6f7c8f100972c5cb07115c5df580052f9d1257af3bc022d9cc3e010df2dcbe09a287cdf25dd05d8f61708b2e399f789c132083aec2991fca354a6bdc8bc6cbddfc5f6d714792de0eed01a6ecec3befdd2016150ddc2dc6bda91b600c5eec471adb6fa6577e50108557d46b28cbdec51131fafc2caefda31aa9c1e70fc8322617e9a9a6b49dbc8725bd876d56049bb168ba4d90eaa1d88f7b9e0f5a7c99b03a80ea6a685ba7198d9213a9074e97aa15a9ebb5242daf0808307135ca8c72d745d5d05daf6398907364642075cd39ecd2adaa7add5eb90b68b9e7c6b59fb417ebe9215c0ca60dd359a9d73b9af2d00555e1e27651eafb6bd450da5ce7b502e29064ae840d45f8bd49618e2111c1792d97c8235408c286893b5d353a98f65128424298026d2262eef0014db28fa321db58778f2b0fdcca6612ffcb9e1f2b8ac0cb52a93e2664427ab8f1f526f6e4aee4c01819e60daf36ca848afab1e942b64a7ab8f974d6f7613fd60ed4f23434b9c63b6713f657bbe246a803192f03cdc47c0f6ce6e8b209507a0e28b5b4bf27d21b78380f446cff4dfee1a6bd3d4283d8f5bfb95731ac8e66974085d44072b55d8402ef096939812a2d1761cf1ff8be28fb4cbe57570bbdde6f865c950da4bafa802806ec8f44ca39d57056689f22fc71c097f0f8c0f292f564a15b0d8da5777b01788b579882673916735d8866475ff61d5e968c22b24a200bad225f3d0a0f6eaa679fc6544c69df07e97f97aa7e2d0ed62a4c29f0c9e9505793c6e479f10b351372f8f9fd57e6e626ae7cb8d5b55048cce5818109d0b74a808a4f2a57f7d7af7e345fb7350b762ca7ae46eb17ded61ad0daf9099a24be0606f93ab813964273d0ef33d832cab6da3c9084ff098e7223dd7f4b70678b4e289178f7ade7870292c020e5a7f021c8a62e551057cc98f9f7f2bd6361084b7a819c546c2c3d282ef58fc27a927bccd11cc3f379784b40e786e60102a0bd6899a71ace70909beac244bf350c23b5977afc5a4c827194f3d807cfe4396be7f4c59789a1517dcfbc1e608ab24952292870a5ca20a10963fd0f7cf0cdf23451215f6b26c94fb7199187662aa5f224cf6ae593c4af81c45322f2be458a67a8cd07891c33391ece6e5ca54f20505e9ace490ced665f80b463f18b260c78a900dd9caa5a80606897118c04140a97f4eaa5e1a01b3e72321da87409b4f28e1aaf5747ee6ead8b497912559365c4e2b41648055e7c4e1adce567033dd4ce3ff35157fbc430d0e5d1847d4727f8daa5afc30e59861af75dfadb00321eb0f8e0bffad7835e0a77b58660413ef95989268a6c99ad5e7cbf2ab9c5423f450db11edec4cbdb340d37a1df02191c245cced900dff38caf7f62a27d442aea71be32b103bc9a148116383bca3c02c5280b54c95d0a9e1d4646a8265d87254e05a4516cb712494dc50371cf26140b6b6a372e34031e4f987432e1e8a2cd4c3f853cc996d3a8bdaa41f785744aee7f94b18db1d8e9f78d8e8ff313ca4cb938a31dc59c590ae2e2167eac7aab7d8ac438ab3fe51b17e378296fa230298d71606e1aea2a025dcc9bc9c6dcaa6e7bcc61f0663c51912ba65659f1eddad44b9529416e07d7c3a496c743a9b3ba6cf656127cd7f82a3cd7e1caa778579db6a2fd131b30f969a00c57cd717a53715013f6d7d556c8224160bfc7ff677f97f56050ab3d1a7c8c2094216a20d069af62e9d9639620c553a621ef9647a881f93e88622824091efd8f8f6ebbcb06d4f38706a15bb8d448182d06f7931a2862de9ad06aec6781be638325d1bf15ba532097e93245aaf7f4c44711d17149588957b422044085279fe487d1fdc7de5153704b896a232f704b8cabd9d92509ae50bbc31e0000b74504d5fee420920f72bad39fcc900dc50cd70c05060fd2e1229f885a9709228b49653352018509a287d21f3611a74b28fbe34be4d69d4880b195712812173b65462dc5e09f89e45a3f3bc888a781c11051c81e0b9cc10286de4b5f714aad71df710bfc3a8ae99af30fef110a53b2b27686bc44e73bf2a4542c9c8054aef185dda5d3048c63516e29ac57f2ffce422983f743b327af626a9ba500b634e18cd930e0eea1541b467f4392720ce0453f89cf6225d70a84cf111e567fec8a3a5da1dfc45bb3ef7c5b282780057e2bd7101bbf6ef3cb395d9d25c6d0a6392b42f9aa7c173f8eb2a0ba19fffae26e4e1ba8968c2125ccc26f47b990a99aca8d38026080430486dd77f8eecec63e94d39777f91c68be5b0b031ef653f92ff8fc9046f13ed60d49fb463c390a6f121a504a3e31c89288ef60f75411a9de1912a26fb4d3ea03f6f2bf23b6376bc591a4c823a2650fd5da12253e628580f825b34a311cf90d205ff6f27a65b8d25baf5bf4879aeaa7c8f24d705baca807ed88b068e4c26e07265440718b2fdbef08b132afcfaa2559e7dc4e6dea88fb8fe63af63ecac44b66343937dfe945b1cb67d4dd20c7ecefea13ed169c188bc7191064e265db47196e0c4c7734fcdcf2195703289a31eb3ec90fc72ea32622eafc1dd9f1d1407e1eac95b46ee58032455d7b989aee404c1e1104f72253e987e4ebc0a7cf4fd9783a4857253b1104e4ca82ba33a91c1d4c4472fe19cb064dff8a3635b319f9b8c935a7020c6bc46c95f895c09ed36a6607cbaf6c961d99cd62edc2b6606c7da4f6b507e751841370e7e7927cc16fbcaa95d891a4e491bffd0253ac0754873b97bb3cfe7dac728a1bbea22aa0a60dc5eef33fc95c6753b601d563d9eb3b9d0e411ddd17de7d3f304cd720822490a7ed2bbf649d32d4c6d113f1d823acae2064824b90764745b52838b1f191c41b1033cdbeeb3b262c24b700614edd9716a0a6f45354ed9b9fd0cfe6c0ccd17d775001363f02291b4427b4ab3e10967dae824a5ea47efde1d72005b1f8814814a6e813393c469e59dd18ec8922fd0b348eb8d1425dec19c2077a3fca9e04ee8fd323af9f5b999d0e4eb2d624e2d71014c7afeb5074fabf0cc89aebb4738a8ab9b9f21aa5b7681cc8b99ddb999ea2087b90206ff1a66f493171a78ac628f9e2a214fe237c7933f3fcd994ab1923dd594984824bbd3cc2d5c8eb9cffad261c101d27e38bc8435a2c835660566b93c0ca65eb3cb8059a634c0b111d7de7a35c53414fccbd226d81e418ae3903696ad24f361ae4d74aa2fb44589b368f480bf698e9aad7d0960a102edbae519f7ec868412add15bec3eabd95b1a60acf79b2e01c34ccfddd25ca9550d17e7dcc2f12fa4632f5c646dcbc42633bc171e874e0ec54057e6af3449d214c61344cd88fde518844a41376b1e88dd0c38b02bc0a24c8578498797b5c33d3bfd8fe068ac93505ded849e52797672dd934ea1b925dfae6759be5c9c148443132e6de5d24991fc0cb6c0fffae94ce997222c4d48566c58c9e7915185ddaaa0e411fefc20dd381460800a543a3e29042cd4255f38870126c7813c3d3a8564f086e7c3cb630db4e42389b0d46877012f070ef0d4ea49b3099ca9e88a025f4e1e513d72e844b2c04394ac47b771d618a65fba70338625a17c9ef1624358c6265679072813815d2784293093e843d8ab56c7b8cf1daa2f59c1693bbab4a9a418949d571cbc753effb5a657cbbb1baf858b5bde4c8a07408fdc7e28fd28d25a3d48a625b98b1bd39c36a5930804f74689432649ad10eed02afcebad93cc4cc94a03b239d109dc77aa95cf0c0598df9ce04e04bba5ab468a78cfb05a4e497b38ee262c50732b24c0f3dde7fc9834842cfb61898f8fa0e0b8f4821ba418eba1102c7c1ec4c98b1566a1ea3986ce4a1de46e9e9b52a6186d1a4349f60c14c5302d61b800f87d50c2991ae4535cd586fa7c29f0bcdcab4e10ea8580e127b16e8ece28a0be3b15a81189c0d1f0a9611da690705695f7586d8aeadd80a298c69351572a4b3fe2cf0f7a63a69b03f74ffbb40899d624b6e50a1339bab53b55200a65bc7b9ccc03bbeaad12d9b77ba994f8e4ef44934001b879ff9ada1bae5f0955cfc9687639287e5d37dc91749d439f8fa52a6192977873993eff4ba9e34ceba012787b0cb5c9ca76676792c89140d55632733ed866fdf41ec9bd3cdea1f16b9c79db7079363691f957b3a8ede05d3d3ed85e1e85b7ef50523fa817dd29a3889562636aba3bcc489247b1f3838c1cbb0ec9e29b797bec0c738758a80c73466d6917b8aee9e4fe41dd226cb9940273cc3afe83c9b1a51da85c1064e37612619136b9b2b15bb9ce5754ac4fa15980aed5913467c53a467016c194c819230128a9d31c005ddad8a47877540f8d070beac275e18fecbcc4896d3a735a949ba4c3af41211f9d86d226f2b194628cf6596cb3f40110fa1709621d451cea36111ec6bfabc195b9bd46e253814567e63a7e59d2205a2ac713b23cb637e7b1f03ccb4a44c546575b06bad1528b4a505eed6f4fed94ab508023acfe2074e001fa14c3730a5302d0369ee9c4e53e7d55bea2b37c925d0f80a2e9e365815e8807c6f9915a05011e8b6744afdc6b74d6c304ebcc05fb82b5dccab1e794581ffbc61293c7745b2bbaab14c2944d3516a55cb3702a126837e991d9e9c036141f1bace27e425b7d835b70f6e4c20b304779d85ecf84d0813737100f7f8108b3c1e2716c8c4aa50220f4c5b6446a505139dfb4b276bbdf0fc1b342baa438a44cb62bd6122ea09b2f168c116a45ae04e2794c120b74c23515a836a89afae0934c8cd2c2b10fe653d72b14534358e2676ece93f996d398d9e55fdf4b9d5ee06a430f907c38237ec996c42189f2d33a3483674b55f5d73bcd3c68fe68c64f49e0355a67ecd296ee5332b56f4b3fb788df5b9af6eb068fab0ebdf00468a8f25fc62997fcfc1698caeb76e047bc080cbf292560dd0df1f975167e95e7c6eb8841ff7c5219b69a2d9a79b7239cf8cfb0a3395ed6fa4d0eff27dcd0e13a1a6816cae9ee7ce8367c5d6df9501d942cec2e6225ccb5c2f7da017a1273bd103d4b0cb7353c06ccfad3ca75b1f9a7fe8b4cfe447a69fa0307323f08b8005f74c4fe10a77b9c7b01302214064faa293195e18e0c817066b3d55b2a4f86bad2b4da30606e696bb9b4e84c0d72ca7af988460ba077db99e2291583dec987c27531d0cbfc39255c0a62f21754f7cf0d4f62344f5a8fa76b673bec629adfacc392680ff75d470821144c01ccb91c05d0da89106f54da69f7f5b777b6087df79a8018fa25683515242950c8ff71e18c0ad7d88966cfb8968da31f96bac21dd2372be9b4f0e4319180e79e7e39e416baae9ef075900972b69adf3871a69543d711ca5d9155f00ccd1b8526759eba5a3f367a97ba980c0b01ece4fca22818b1e8a10cecf3782441999ff2c4384f34c6e36e7407c50f4a75d687938c6b1bcf9c59d0781cfab5a518434991acacd7016b952f2d23a1173aae30b5cfbb3086077ee598765a99b77a1df8646f6c8eec55a4aeaa46d6d20d0bf032e2b22dcfd1926a0756e96a4e8e675961b73e45477554f66e67f809ea41403c0decc9d3a7a4234c62991ea4aa2d75b2aa065381b4d282f73f04dc2153ccadfb68a10feaffc685949b36504f6910cd45d67009f8926e461f2f8173f2d7715ae4988f7b71f1433e6eed4c0fa28af1e86c0e811b1db0e121bf2b12980c95aa0c7df8f8dbcf8e98a819d50a2acaaac8fa9b43a354fdde4b42b50112600d8df545fee3b51e24bb51dedf17211120569ac8e909e4269fbdd2f00c4d52b5d2b70e7a56c8d2ce3c1442a6b3f85091c867d3f7132f54f130f017d04abfa09fbc87031050368fdf078789f9f305c76f51eb313ff3745410a29a9b3e8ff458407c0b25b7c9315ae2210c78a063fcb40b7868a463c0e38e9098608df7fbabda712ee00d966b0c0dd3bedbbd659202b6be1d5b46aaf399cb996be9e2433132b2fada995303836f81891177159801ada3d2b68977aff89e4031d37c63a43caa1f7be27a398f68333a20ad91b33e0e7b9837c32cf9a6d67a5c987cf2a2f52a0f0848794cf607ebd48ca87b47e7c2e77acd621e3aaacd40b1a1db1d3497defa230967a45b02cd819f3d824277445165b1efc8d12aab01844a1114e38f87420cd3cca6a1d53fe2b7f548525186ce3502f7a513a8307f92f4a3c3c3842def01ec13354b438ba101b9570fe85d1e58f0992b34878ef2b2c306311c436d0f65cc80df9bf593b58828a05af8374d9f656a691bdf4452c34170930ea02a9a1110d7787b3c6442796cf28db5c8d350bc955509811a677787550d70ab6b5b41e51e33fb94f331d75521d38cc288534dc1c49d5ef2d97c8a7f5a9f85d06bdd958b046ce58fad667465b5367c7a80e43d0bf6bbcf112a9a479ee734c9d916d0d35776958f4a78ddfebf606c447d2df48be18a5a8d8c42fbdd34f8f496db070bff2c7df65c78f523aa75c350fcc8429e6aca20762f1cecebac83b50d48ee2346a8d138662c0ab64cc8339cefe4cfd8fcabc699f209bbb659e4b8830fe594aee90c8a4b737463c7bbb5d2f0e36b562b3c2cc8f90f21f9e0ca330415219ed2c274d1014d5653a440ab4b351a9fe2c3b48be41cb8557ef8b20b3a424d2c9b874e0cdbad31a58090a9752aba8c50c83f3bf50a3e56e6b2e1b60c29425eafebc2e426aa1a6c7ec579a1cb3c4b2c5d71a5b816e8b3b8f3ae2ec179f96e9e3fd9d0fdc297a22936b024380d815dee2519027b168be40dc18321f5f0cc54cdbe8b3eb75e4d4357464ae1716de8a119808b06f8a691ef7ab1661d96337a9dc506b5a3c705b219eb730266e35259424dcf7793047f3937cb3ec26c2c7d9bb5b8c7611a2b4eead7066101263ddf0df632c9aa4c99823f37b55f901890c9b4040cf37735d36cf2093fc1d68556921390f67ff7c7eb0bd5bb74029f55d10833e3757b29ed502d187436f921968550269dd75f40ff9d73c90855ee5e5759a8f209d30a77913e23ebd8f83131902135c0676c8853fc49971464e1160778af7be1905d9b4174587518adb7406d34eed3b70f59e66c7d0796b8211c3dbd158a621c0b5b1d8a73e512ca25eeb2096bcfd23cf6c24073af03db1a2dec3c43d2114c5722942bc84f39a814aa542b2377f3095db5f5963af5fc609e35c78b8db296989068f4a7867ff9b40490e205f740e59255546ced435367657c144d8d30b3b6534e64aa6b74720d9ee784e59492ba3569389102e7114f72b48dee33ce347224c534a70fe6327b7248f37ec2ade96bf488b079b98bf9505cadba99c7f4d4d31e2bd6d4c4c46e34c2f38bec3bec413a4d30c9d3dcdce60294f036a6468d474bc78ccabdc2b452508a8bc518402a7dbd974a50d3e25f65d0f7fdaef446c84ff9d0a934553fe2ac03aed062732cece56aae7f0805b5ecbc3c61a3e9edbbb6df1b068b32399dc1d10d34c0ac8a45ad14ca69911864535173044a9c03ad9a100cc5676984ac6593376e9d46bc00608c3491f2f13ad20d0d29fe0cf3f608531271bf6752cdfaa15caa838b4445b5874ad02ad17692305f977b0d63a9c503845765177655c8a491f935d9c2aa045eee14161ab32fb7480282ed4c7155651e0cc0fe1c86afac1572775c5980997fbeeed0124b983728f12609e09361410b57e6c10d85950d1fdc082b36dd2c42a00d59658ad38f7b769b0d477370c0a3b32a86aa2889f11fb2723fd025d94124202f2925db1d136d73d4269ef8214146c2d08ef0fee9377cca7517b76ae4d1c693beaf63cefef8db71725f9c3d780501f2cdb906e9134c5e73ed36d6d7f0e3f3787322c7d0840de5c97aa72915f6227e9ba7235bea9007448906213eec00e5c7cec98379dd538a4a22994c17cd5342358b0b43e95147f005a916d8b156027b99793bb4fc54c8d0ba3a69e89827a515909dc9a09b48db9c66b5596b8874456719a6f8ec3832cbc133c39f3b0f2ed7962b1dfb2bc193dbaee139c35f308d73e751732d930d02183c464afb4bae25451e31b269e66744c1569534bd38bab1da61bc37bb80acf0d657244d776f1a00ae0a463aa926c06b65efb8c86b11d3bfef641449e1a700f6529133e59c161728b143de587d9485be8af5ca1633fb1cfe2befcd8ad43523d5f5ba2619392a4256a3b47ae194f99652b2462c257a5aeb2cf30d8b0134aeb81d3ca95f556d97944e88a2c6bc6e87de0ec5f3bcf553da0fff4a1a81e4c9c840c2b08620a0dfc32ee379a7c157429470e3b04bf4b4016c5aae90ceb03fe778d7dc8ed0e4ab353eda485e5d5e404aa742ebe3ec744c17373d7088fb5172370012ea015dc7556a99c97a74e5e442d9a034572399eb3d24a4ba8ddeb37eb8aee1e8d825df5432cc1e532b796cbce683a0d0d3ca57a3242c638f32408cccd9cac6d0ec76a378f32cfc802e9e8fb92d261b530353a0c1443c64683af6f96f2de3b15629b22040b46fb1b2fae4e1e232bf66820352e1830b25b41d25aceb679737d83f1373027edf6e2d51c8a396b30657a6c23adc025f7064e28646978083f6e2b63da9f84ca3ffe1428fe0dfd6cb5a77cba7b67b13a9f0d97712ebfe27290a051e2e15fd17acd1a97695b1b52d8f0d22232b71ac6a77b6ee71bb5e927ca2d3acd481af50e3cd94862d1dee5d4f4b23ba615880b48e5d1b61f91c766853f3469d3de3421f6ad14bce300ed2b8495bf7ed7d8be28837fbd0fd7580750de61d7f46b23ba77884086bf7a5ed4c446a14604943f3f264a13f50fd89aa26c38ae09a9f152a2dc877851a3fc3f9df2612bb50955cc0a1d715a821da271ecad3db0764b953d0882fa43932c31e5c4dc021c61cea27eba1f5248bfa4e70cbd46bcb270bcd96df02fad5ec48f55426d38b968d1cd99e1010449362a020ea4c3e02600b4d8169f5e46afc653da9b9acb69f9dca4c86c6a155b3820e35cb13834ee12b321abf78333f7d2406bd4a5eadf599c7259bbe1260e3404f1e3d71f297bb9b916d47ffbdc8caa2fed0fd00d23bfd25e3a76c8d0bba4cc15df4570db92e09f7a972e74f7dea15d9feb108fe032fa735dd4d989a9b3ddc5dad825971b8545d75743cb3192e95511421076651ee2eb37a0782f33eb1c81cb4301fa154903653a77da679cc88dfb0afca760023b7cf7118c8fcc6dae7877de453c6a1486d742daa26f345d68e401bff34c90d5a14a026570da78dc1af9659b5acbfd262235b27ec8982560963486ba13cbfddb2cdfb1f0fb2be3c3ee0f24e8fef92f26252b1ed37a2f2c8a49ea03c68a143ebaac2e395bc0b0c46afa4ce46b33dabd2dcae6fdb76fa17429cedc9cc84c469f6f677bbeacb9c7f462a58c2a17fe103f8cfec59e1401d10fe343e5b3a890bc3199940fa4e8c16aef126776e9c9e7b25b9be5392e90ae85a72b1dc5d38350372f30e0c73d7019279085504b61d77d30317156792dcc976c20aba35c1c1dcd0e72ebed6dbd01e4a503bc80049ac0d052b81b5a03b91504a94b457031b04e0a78eeefcfe25ff5aac4317cadc192fff5473e9fb1f14d06ddf409e4f544dc9f4cd95f488d1925d2d93d22dca087802686bf42414c1bf73733518289f43af4dea02e9cb0a6e19c723fe11d99b84eb6e71f174dc1d4060c04b5464ea306d01cc3557e3f9d898192b9925c8e9f656110d4e2968a0122adeb3e3bb6bd1116a07e277d5da10c1b21a145e893de06ae0afdbef4bd4749c50b5d063f3994d8e43c9b667184469a3504fba93f8add2aac947cc0fe9e96bb7f877f035f12e2f88494beb94a7340822495ed71f6d9657a0c97b2bead4cb4d4c81e75f4ddadda85dca7c64569262dbe283fec9b52bd4b099195e2413256ffc04a6c30ed1fb2caa02991bbabefdac829f5182c48faa6d3f190eef116c2539128637910822fa08faa7adaf18845e343a9345f1a0e7c6a33187319c9ed1783cd9aa66034fa3b0433a33424b14f968bce9f03bf37cbc6f4dff037352eb2ed73761d5ac0b0ba16368b628c1b9946500e0da1717022c5ad94a980ede6f2d686c41c83f9fc1057b6a9030f10c13e4aa798652c0321d9a769d3e8eb3c888f2c27eef814b353ce16b4cfeef91fffbb21125f5a6d32ae804017dd3d90dda58525982182cce9bca64acf8503d36c902bd4ccc16170ebaf36d43679a4d21ece239ca83354d1b29efd7f6917e8f67f364b725481eef70dd3ba992b93de8160af8446a7993630594fb07b08ceec763340be34ed029a21ee03f92bbd5277eb9986e306eb7556c8dc6708e9d611585a3960aaa41fa5a257d768bec299c4e087d3dd9f2f4bb4053c6fe6b5d4221ae68394d3a8c13424309f832c239ecf126e70ab9a8aa3a736914af720fb5edd2d5e981cd845bdbc0e1030a4187358534d2ca8d35c56745e1100599087748b1e745f3dfb7288f10a4adc665e009fc17dc2db9e902c4542d6d7cd17083726b89f54c70932873c2db4a6bd8ecafa807e89e78b3b3c796d29f7f8f123615bb9103d68538b153cf94d16853cb4756d7de518d19b2ac567307ab02bc639526213467bf960d7cbb31d65d089d1aedee64a79ad3b21212d71bbd371eb9d10c7fdb0ed0015ec36cf113e52446228d3fbc8eaf13124f8450851af78b004213e5df66e2f142a30a072d1bad21999464cb5c31cfb70f0fcf6014446df6431bb90e7cdaad3273b8cda566c7c83bb7a08ee671fd7ae9a2733af5596938f8dc5b228ec31e5564b9e8c5bf4500d37d809a66f63d78d59c3badae85682b65baa6bb837263e5063b54d3c2617298c4fe40332616d84524562ddb574e95e1adf41f101b7048ff3f33fc81f385f70308196f544db3e171720d66d01e6081e1efb5a23429429245070e9817b59c05a5b7f695f46dc02639d10dcede160411bbdb804bb0fceeb12ae4254e4c778000b6f9b1cea0583da77ddb41a0b474f363a1390cf598db8d4087ec645df74133c19e64932ab96da5bcdec1398b7873e1b55d6975196642b259e78ef28095f90636965d773799eb70e3db00442d2386e3bfb1e88a21866aa4e7865b58b4f98dab951c25469518b3beecce2a9675f0067747f1acddfc660b2773cb4239e3766fd561137e6e4c960eeed493b6b3d516746b656801faa010234fb5151e7baae97fca5963f2f77980f046fb2ba425ae0eb4a87c6e439a8f0d0eee7746058d76a94a6e595d889f825894ecc706d4c3c74d69182e3424b02df96ce8018c748", - "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" + "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", + "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", + "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", + "0x188c15414d0503391cc1ace8dfa4eb9d8b38e96566ca1b30975f3ca739475dceb86238401a059cddc92424ac4ca833952fa3cec6e9e7e7a902c008da3707e0b25499ba740e0c15dff70ca9269301122e88da9af1cf9bb61d7e9143a1eb379c24892fa8a1164e91349593af426a459ab319c45b0c41075b47a80be3b2d6fed1b7dd2c56c5353393ae13f76e5bbd2c75e88867169eb92cbee5e4ce0f4fed3408af38395e9e00461f37e62608cc286785221f8f13778746b271dab8d7b518e11ba966c5449e2172dec007604123803d64264df8efec4f6d6af2f5c8b69bb482d4e296c38bbed592d9e774d968734a04e0d723145229898ed041e314a8bb122cc709ddef33c36e51a83fae8030d6425ee68fd857678400b3336018cdb009f56c92cdb4a8ee13d1532d2c3ac694a4d64e84cb461d8b265495082c4a5117b5180dbd337657827bf8ba39eb207a2013a91ce6f26a13b9767888b6eff654b81da696c131e36823cb71f1b1266fb81fdb1004812ae73ead2d34aeaabcda132c1cc0b01038a0d5c395ddc90d00b7e5935998b9d07b848ad33fa47d2b787996ad80fb491428b53a9bf572ed4d078dbbfa147ebc5226a9e76832b799a6d39a06f678df927da60d8269947a9ac0f80a653aeb3579a994e6fe6fdab1f77227c9137ea169c867daf91a36fdd2b22f6e4dab4441e43b11456d705bf6a955414cd567d7e289ce1971aec28d946c1a52e9f431436ee5f290ef93a48f8d0c01b51c502b10e0a59a702dc2dc8072cd659abea7c35e4448c19057532c1e8318edde3d139a52a7156e3c61b35be4bf8fd8bc708eae73094e61c081cab15c536219952ab7a7328aa4e01a6e60399726e0b386fed530456aee56777abc7839865048e0421cb45b7f15bb97d28e7fce5a02d5e07d2ff501f353f2f8730e6f6ffaa005facde64f90339ca19e5764e0a9c1c9a31720509f2b605b2246c74acdfbcfdffc9472fb102efc618e87a9efde92bf2051c264726833ab1a17674d1e477762f39f69a60677a731011c48079f8728478465e3d1d1cb5d0e55b4569addcb3476921d41fbf7dfa5140ca093b9c8b8b9d7879f1c012f43bf5b08d4f9ddfcd64775c8a7f8fc818cc5448815f4b222fb8f384e221033511364ebe158cc929650d45b750a37899bb41dfc6cd725114aea8ce414f448e37f28f514c2102eade9fd49bdcd91ce2600ac06b7262b40373f2ddc47a5cc440808036ca1426779b1d7816d1ed64005e8af16d0ab169b74dfe5febba7e33379c4bcb3a7e12de84df266ed50baed573dd06b2d597a11216fd285469eca45f06d4e70e8f41e0092b83b40e09daa422bb88a3b12bdc7df20a1e94b40243d53c546bf7e08dbea6ef8235b3439d35557496d7deb34850ebc3201a1c7b5b65e2b8256484261c06bdd363a47b35658f884f12fe88ac713c8dbbd09c46dc6bc36ff5f95099e623724e9b2222654e7871776da9ccdea423838de6200b11540b37195b0146476eb06dbe1aec513504a14b0ac488ad824fb1f906036d0447b87a6cbc6dcc92c35a63f3a45acff54068067fbf974f44d11c414d26bcb00c1c010d19bffb24a954775f0734e9eee9778aae0b90543a060d1a5bbdb020e94e4e767602bc30555f99def4bbb66ecc2fccd1d110acc47eee848a1c54099edd4ff59c9a2ff269a3b012ced50a9ab44bee5cd005bf71d2098989c84442c97d76002624a1f46536692b26e2348b4713e4af8687d93141c17523fb9cf1553db01f661b1915a1f0820b419dfd1a8b9bdcc504c2f818aa9c01c8b9acda8151e3485d03fdc1f4a9b151bfb2f817e363aca804082d90d9a34560cc577cce00b97e847a061da27b8d8e177c78358c26950889c665bc0199f43fc423fa6ed07854f2eb8616a87f719dfe5a1acf0ef25769918f5887b6100fef12786ed512b92096db456a33e23f09a782e1e6067d20d7f4151a5e92de08294ab1d3af5e6c40b6542191102a7d30e5e88dfa9435e12b7cd233e901e638158bb2e7ce82a8abe5def61746ce6121f053817ada8a404c4431a789eb366a0304fb929b1164a885d220ae1cb7fccd472e1639761e30abc82d739d6634a6744fafb493a826ce1daae0944999dbea0509e47f4ad5a9630ace8c3c37134bf7a5892fb1988852a2d07004ed48f5993fb5b5539032708d07d7f18c57f4fea6efb20cdc25aada6f0592866386050e4c9457fb06ee297721f2177374eafde163b34c226ffcf22a5d4e9eb36b53cf417ca0fdeac3ece98b1921f0fede583d07aece09a3b87f8ee95c835a48cf89dc33fa2254ca917e56d7305f65be99254408c6568684edb34ea5f51455ac83267da9ce1297ce987656d79bfa5245b58643ff6a43ae4c5350d843d8d76f50b558cfee242c14317d6746f1963467d79c24b9f1898fc4caa2bf9973f8ab024bfe537e2ba2699a8bd29f019bc2b774ffa82576685bd6b392bdd4a8ac9ec19b20ce5266042ded2c8cc430ae9617c49cf9e1d6eb1819723261bb61f9813e68d4f63c1ecdc89c59db818c7b76b19be7e54a4a44ee78aeeae6a6fbe78ffa87a49b7f75b11dc142e0a1eda102c49898e337151853a09cce38ea5c37adc66e7188b313f1d3b045c195fab2ca1e84a6b3e526870645c9dabd3213ad35c24b6857f1e2d7619d7414ec37c97901321d50ca06657cd0a7e273d08942e02c457640af40e9e1b45f173c9fc15db6aa775edd025ad80b961df64cd3b4493d68db6184fc9f94272b92e132356ca488158462eaa507723897f40885aeb45a07936555f0636bbc600091c8fa5196b8d828720cba46e3f3a17c470831579ebe03a89ec1b327b6ff112a441b20a16f5c47d3209195da905473f05f503e71e82180ae1be57aa5a02c1374db0390439099866bda5e38664d00f63cb9628e8b0a90600f9b4019bddc64ec29df7f0b7f9edc4954a853664ec69cee89dee1de92ff2d4d54c143a036bd1dc499ab80f3c93638e47a30c285274b5dfb75f3bc0eb2ba9c2690971cd372e0e432957464a200fd5c91ab0c6a13b653570bdbb1819a6f600973c8dbd945dcd4d39ffac0603e21fb02d95811b1824fc9cfc6ba1e60f03a6fb7cf578998af36fc2a830fd844e78cbed0f9ee8afa1a03887be36d1f3eba2e6c32fdf4f42884615a74462066908cbe515fc029fefe45a1bad461879bd57559e5dc967a8c7c6fc3a0b2701c9c30b365b4767f0ff83e08f3435970de1d56ca35ed818a0ec64738bd3fc13bb7b64bd0b4b0f507e50b9a99182f609972744f046a76d20bfaa22e0bf8c8a520490277b0ef218c7239814da45a0c82f3b0e6f4fadf8343f9e75211c386658c093c6712ff86400353b099c8ba6433b9f02d6e41d7bb657953d553009e997c0e1e353493cf51ad2b087f99371400c4f5af92b92cc06daee643dc790569bc8ba35b314bf2d264801e2aa6ab2d1b5a1090cb1253a13d974f48c634f0a236894030286d299272008dfb7ad220be03c22ffdfbf4d410d3203f3be1b98af6a40633e21249875ce6c58dcb77b5436461de12a1f3dc01d5b858e5cbbf222f7ce678f0b1a1716c98005e320c366d8736c3675b10e4857feb1f79fb3b31b8909baf5db4ceb2f178310dd9840fba0f4cc71791766c680e77a23e302f0ecec4b6758553b1287ff0432d2581c1addc3b5769e6b512dd68b8c5f0f5957c9df5e354866c6e5e8ea5d7ce7c2cefb27c04ad7f681a7fb969a9105e5219a74d15f90485658ddbf8621e6f149ba0ebccea7153ccddc598c4912c121e8f89d9b88c54342a6f901110c3f7766861ad6b271bbe9f6a3ebc4b518dfcb3cf20a8e79d5b25fa90f33ee895596b52b14345cb158c9eee247a8bc54e1de65cb243349fa8acc6e6f4652339b18fb86b87c9fc87eb0ef2fcceb1a2daf8471c7f759d5e3eae5ae1c2158d1b41bc4e1968d9923b72230e61d2878e492029d122e4e0ce6226c2c76bda66e51283f5f93d429fa5abaff2c6a0d5ee9c07e62c5665c79d7410035d96fc794fa359bdce078f20e642fd5bd27feb59ffede17e78e3d160fa4a82ca5fceb530ca70fee04b9b6e8d59e6e00051c85b351bb90962b7d52a56cd06088a7bdb1a02bb9d052e986ee7153fe2fa9071d4106047d06c81ca4c856a3e8feac64244d900ebd96d11135028ccc5c7e30dd086493faa77c9017c175fa74bf0e62c598472a5fa2afc5e3f520fc3a77be6aac5cb0a1452c826357e9126760fa6228c5be5f1676aa625f78da3bc9a1dd951fa6739f5d6a65c4cab42752f4bd62a0b1949a00240bcaef21c3fd3cbd71e9aa8ccfba21579b161be3b3a3a901ec8d32648c268bc575602a64087e01e8fd6b72e29ca35403818565e1e22b5e6d8bae37dbeec480907d660ed3a3be231d000764c55b5f793a92f52788883df81ecca019667b3740bfba76b1ee1eac18722d615acd6dad0eb6fc05bfb1a2e3d77dc9837a86d006d2af8651fb8997fcffc4daa8980853462f991db46ccc34070df7f671d3729e8334647cbea34a76a6cc31b116eb7684ad3de689047959e60af37d9c2aa495a9cbb20289ed0d2e7507189c72629c8c1e747507a7941e6ef1cb4f0463be5a0d9d7c15558cb9bb04f675072cce5b86b25b363146d39601346162df06f1902a2eadfee64a896e3df0a83629cd441958c5dedd93531efb7d6aa03a47009741e2fd0991987466f5b4ea821013ad1d6f4896cdf2cac491c62fe1576264f20b4d70b6218210883e873d3d04f9d9c06aa0cf68bb054f9009dbb6fe9c22cae2397a2e47b33d0de1404acb08cf922f3d1d7caf76637c5e949cb1dd3b70410f591a643cd2b01ad4fd217a60c08d780f1f2a58856b334b6e0e95c9f8a58b8439e4a2b2292ff212d6fd1bfec7ac298e6ba6be9c5de7a5657325f9cd8a5f814f3094c1d4f067b7ce4f297f8e5f6851d233d384d144016defb65ea3b3f71e2a77a07f694dcb3afbad6d6ad2cbdd634f6a6beff75e9ec06c785e28eb5157ac63a4243dafe5b89a95b927cf83e96a6030e2b904c9751da185cdf052dd3746661fe0d66bf555ab2e2ea6dc0829ced4f939db0c6253ce98142f28e78f04c0e9bec022a92b293828d0fe52aeee4fcb2117b1a26b1c213296ffe1c6c9f9c1a43ab9cb0004a20e55db10666ec5f9de4e477bf06a13897f01573953386e8b35970f71e3ce33799d9e03ae492aedc805305439cf2050c3232763107ee3aca6b69a4f9418d71d5d6d69dd23492a6b9dbd79f03857174b2bdf2b0cc47e964a8ddc262ae38779908032b72c19c01593ded9d4aeb3cb0336e3635c26093d26e2e9165231b4485242154aa4d2ee98775896a8f34dbaff03ce5219334289e6685145d686b871abbe3dd7564ae936efd50cf122a1b2b2fca82fa40078046039158c924485e817c85b0783eda93936822b8bc3ad5515d1f83f5a48a9c8d79e9e50bea58db38fb85c584759516dff6af72c4d026a7398a39dd38d70357a16c914f657b4b7fed3f9fbb31e9f4096d6ffec034a48158c3e889e9fe4946e07f858eadff0dd0bce91958bc59a1ed1685f59dc6909527a5202339ff025efe97c013948bef5a00ecb61d812a3eaa35c259d8fcc4c09837119a42c6aaad5003d95744c8c44b45f0880f524d944137f7d6354ead4676f6271029b4f77eef00b42773de573b7ace51d0fb96fd47de0081b20b66a6f790317af3d7a4bc29c9d966c482b4e162606dcf8836ec36723ba1686d074419b019af2cefd0424f1a84fec2d05d442afd7a1550082c5bd71fed586a50cf955cfb16ae524011eb2ca7d8c9d6951607439b891452151c80fab5ff8bb32a2cbc2bcf8480585d2b920fde881fcf932a006d9cda402278b55ff5471961806237356e153580ca423fd6d34491ba044e83512160154caa3ebc3e537a0b6877340f314ea50a1da07e3baee80f81ce3de4c5825e7c1983c69043cb1f1b55cf5b685d4b2e568dfef87ef97ca0d2d1366427eaabe8b531edc90d84962947ea8d370431b1a471ffbf35d8b347d27ca8e8b91b2ead436c9cd9314a0a69094130f9732bedcedb70ee72fc6f0dd5692db3ffa6b73c64d89fdeb2ef73541e3072640391bf231fbbacd011130aa74f830b5fa1dd3aef688dc0ee0dafcf2199933e259b6837d1fcc1ed5b1acfe8f66ddfaf099a31e50e2d45c2a40aef3f69c046b460791bb84aa1a40d2ab35d98dd5ce42c5fc0101536af6f3aff1228c22c40a3e07064dd5a0ba551c0f37878b91466c4d6d16ec9b822ea803f90090c14370a3f75a5af4822b991e34dacea076457eab379e20e0a4568e14f04b54bad236175f6c462893027ad6cc3d18b322917883512d42889c99a0e55d7ac68443cafd1ade1845c3bb1ad91deaa76955d3f755197ceff318a404fb0816eb48f7349710dc5590660602275c09b6eb8d131d0ece6519abf440bed12cd2c80cacc679b567df103b3b708034d156a4afee5a8f2ed3e26e1f960475b2f2a071f6cb2f6266032fea642acf532e6cf7dab97c245aeb4b2b9014535d9992e01000a631f72379f171d69b0b841b1afb53b1b248b3d4dedcaeee21104ebd1c4dc9da6a65af54a313175a5e1d827e64b5c73ab781a3f90becd9c4c43eebb84e7938582034de716928540f1ab33ca53df8c3b6bbc3a2e5ce7fc9a9c6dcf2251e663f473871be5a97d8a8227a34a4bd0582471dbedf9d5b5ddb3402f48955e32c0a506695ffc2d548cb0bd605482d78c9fe5399c887cb41d7fad08c222e3f958dd943eb352b0f078202e6000f439e89cef7d408c488be21e75014d687e9c22298d13cffad9dcfff57028789f038082b3078fb7d1a7c95aaf267ebc45f494b36ce7a373d7277be2ca984caf09c43e29b8bf869be291b712edb48a10ee3fa54c0cf929037f25724e165bb3ec67cdfb69abc63acc8859e95214ec9f8be8d76c7725f50a5f1825e57d86863382f9d7434eca94660470bd3fea0a52336b6b55d74447773e164196e10acdf29e8672e67bbdb217d211fc2ceb9e7587aa2287184e3f26c9302fcd43dee5d4326b33b5249b5b4c6edc7e68f6f0adafc28e51ccde19679265d141b5a0025d0e06ac68c3a081a480b27c367ba0d3e7dd40469ed53e05e9e5eb3ad94fcaba84df1ed1bd0972e896d3fef68203a0c107cf1eee5cce3c82c67f9e24230ba2d17ff424ded915796467bac19dcc4dc30b0a4e459113cd5410e9f685df52c05114777712edfebb2233bd0c132c9bb37eecd68fea46a94711ca25620ab25b95e66a62aae3d06128d63d34c51d5969d6a09875d1f6f1280b9ea635f1b88307bc1f284ee180d45ca212737d6dbbacfbbb145bbbe18439e807b17a1d16f5c2c0bdcf1fb81a85668ed0377ded5edd87c96c8ff11e89c3fe468ba7ac787f38230751bf56402a362d5e96b77f9b78b1dde661ce3f1dfbf9cccdf63a402a0f00facbb85a93876a694943fd6177a6dae9c7094ce22c6c8073151e05657caffe9099650648ebd4441610005f2a7cfedcf40794087e02f6d0d58f53bbaee19cc6f46cd9dbee625ba1a2e6765dfab8daf87505bbc17ab2dbcacdc2a15a3a785f1035dd27fa46f9b86abde7c1cbe894831375bda0eed3ed648c5c84a640b09489d0e6222c748a53e3d860f8ffc8beaeb73c65e077252f2fec78a3c037418e4aec5e25bddb9eba04ed72f420d6a53e8af7c703801d68377099265af5d64b1a6049ed2a30f8d95d98531887b1ce0a9639bd39fb2e05d90de1f28633ccbaa65fa2f2454a5e9f2a051378ac2169c6c7e1a3306dbc120dd0c0159ab36dcf68ba3e9c89735ad6d8615fbde06eece3730385a8e26c1c2936096c19a61c9ae77a43e0550f9e1ba9f5fd25ca72e0e41e1e024678b4916cb7ea724c992345bb6df6446448991b5850f8588c2dd6ec368514737f34607e05fc4a22cacc93333a60d8f2c98b96a6228a97585816d9683d900c2153e4bfe912220f992a1a70fe0a61abc3b6fabd4642415a04d1c425a62b65bc378b8244f4a4755866e353d9f0832b7d85d9febe287af94e9064fdfd269aad44fd9442b1e1ee6d9d99aa1c55ccc674ca23273a5eb797d332bb34e95fa8263e0816f6f58157679f9b31ab623e5b37fc12c76d3e10a71775cb13ac57633ee51d1058137f4e17a1ba18b4a7b0d7c31375760b7c6b29edf135bbc46549dc04bae019dff43bbb49154080ce3f73588b15fa5795ec101ca38401701eca8584a3408b8a0779de2c2e88c3195cbc487113bee688603804cf6c40e6628256a9b5d61dfb8764e4706c41373cdb7bc586e47a02e7bea1466994c869a9d4e1d8c58e96509861d5152a178b8e964bbb2353ffc3efcfcdecd9a513c2dd3b6844ad28ac1f6e5e2a79242271e4b4ecd1a30620f2551227bee7c5e7cf81c232c4d588a4f1fc3a352ba9ae237fcda2ad30250d8a45ccd4593781a520cf97f21f024e2c9d41edd17ec0ee4ddafdceea4b7d8a8d4be61d7fa6a302fab8c786cc24bf4fdb8da3fb2e90cf3aabc8989713b95b1fe2ea395c0e71c9f0a8e81f618b72f9e96b32ee593152cc80b1b9c56aea500d7c526ba7d98171a9f49083cb420f08877964bd6d9cf074a85713543965de5424a754d05454dde5fe1ac65b73cd87374c7e17597c658d242325424ed25c1dd593ca978693a5cf04c673fd952d6b1fac24a216c2abefe3e956e476151ddd001859415e6164f1290d20acdb4df14b20319b35c0da9b337c007e9586fd52277eb836c48fbd5995cf2b8f5a8a88947f4521c2565c7beff7782f2e9bec04157ddedd4933c4ba2d3283db028c4c593063f0c8cb80f53b3dd1a20dcc9d6337367c8f4310cbccbc8db55c1f1f6133cc2aea8dbd4fa3fcda9eddab9847673c1263d0543428d9264b13334524787480f8edd4bdeae6bc2f654b4da7571f17b36564be5e1f7019042978196dc6857d33bedf70b3d97fff6a4f0193da788cfd912de07cbd357075b98b60f729fc2b53d068fa169ab83a04bad87ea4d2055bcb7e74d6ac65b7c7013b7e14b0fa8e045cf6ee949673c02aa86d56c553a7115f30fcfd56f41ec78c4c4a80248ca73ee7e84035a9b7d3f146de192546f5915d2c88ad63c9abc8e67bea8b6c93c63d9f32d558ae90da01777aff2a1acb004d1531ead77ad6e9bd64fcc3985ac00df9bbaf0ca3df754513eba2769c1a57500c2f9f15677eef600b1c79015b06493f74892bce7952dedc7e475039619e37d74e41cce91c64f3dbca32661af0f50971c457a585cd7a79522e53163c71aea6d740ee556af3e2cd6444de4cbd21270d3032794e00ee31cd1acf510db72dc3c4c18a431bfb7526255c737430bf6d548afc9c42242f1ff3868335020f52f47800725867e5228108fd34151b9945ce28bbba194c4c427990de3683f40ad82932eee44fd7bee0109286eb09a9f8c09bf4d2817430a7c7f2aa3145a44f6f375e71d35d0a366842701cac649e0924f82bd804ddda004d734d5468cf2c51d2d061d927425900a990c793382cb8c97eb60ac9223304ae7130a572223917c58b25bfba7289241c3c7b36f6bc9d6e982a3b65956cac4a967c4ad5d0a74ac0b5450d56ca730cb11b83bfdf585c95c5f646d3e0fd5024a3912537170345e877b76c6e27b3150f52c0b39456d51341b84a9745f723fb378216a7a4feab284f584474baf204eb13d52af94528bf8be28118096ff71f865b49b49c942be2ace2fe1f8059c29155f02df1e36957d4ea0910a89e6252ca0c83bb7a324ecff33e6b80fc4938ac80cca8ae63c9eb4c50b1804af482b6df5172ee9637a43896a3bbc51447084f78e5f4650583f5d6ea9bbe78c00df6046ecb30c83e495313b608803fe6e37dee4e2ba8bd6769f98c44f7bd163f87c320bc2317d9c0a4dce9c1b40b118906d989436fe351421b4897ce5f421c8b7ba85e0a397bf05de774da90ddc8378cac11f138de2446bb0c7feec623222ed476bef686dd1b3cc9178b6f2a18e76a4e5acd59115699e316d31d91ccdfca7f6baca3b478fbd61cde8206528e37e4f1832a58d91e72e89c9db388e310c7e8405c0ebe870535e72d26b1c89edb998149901fc11dd29bb314a644fa82db1c41254fc19a850690fb4451372a6ffbfec919925dd9c532e7c28b8167b44ff449aaf62bb7ee1b8e3f29a7046a214ade13fd5ae25c561834c6fe0cd8da393defad53c34c8b52fa61244b94c52e07d9b4778b21420e70214855e335432d05dfcdff69d9a8128e0d1e2e14de4b9e863de420a4042866719013836dc0a614d7980e2593c937bf57614ad2db2420200975d35655a8e2705b2a47734fc20351c56d849d187b33fe329989f4eebf4dbb7c38bb0a51fe43bc6cf91c29a953df90676557abc6ea5fe5c63db2a051e1acc32e26c447f72876083e33e2e1a12188132ed1b1e00e6b344c042831c7d1504b7c0c2ecb8657be9b8b658804c69bea0ed0ae6600d686867035319fe51f8be67eed88985ab7a258da5c909d3555248b99df81ef98f0d72328211eff52cbfad1da5a82d36cba99efbc237c876620f457d4d606737d255052e0824fe92337f9572eaa6fbc82cabd9c82242d958bcf9ae1aa60f271ba7fd25e65034358e8623d3078fe1116a71580fa8f09975ce93685e3ac05dd6cef1705d361e0bb713173ee3439500e38db9de3990f55d491fa11a95f85af58476505d383679d65a75c64be8520f50ba279edc98f0aa02f4df7cad786dc974504ee208c935743929add97828b78c7a3030aa682ef5cf408c1cb9748ec5d8cdf218437724ca7fcee3af6a0e8e697900b57b0e5242dbb2f21a53057a44ea309632de15d0e2e9a415798fc15c278a10e30de189aae055a0dc193ee78e6abaf1466ef9b8cba11936e0946dbfc9a5a0c46bd0afbfcd57022bb9fb6ed21fb4d28ec01878fd2382a8c92b0c3ec5a5df6c3f73e97676a7b9ec3c86a4b8a8e73be62b4636c8fb27a9fc8e067259c08c4f475b0d181b79ef5e2425fced69edb9f9a6fb89e1b65f9bc1ef508787df46649211b809703d146f6160134c22583559503e6352c6bec5fa753bb71bc3e9ed7aecb6cd4ad9f1692921b4b3bf84b99db68455e4b5a8a60318f8f5986fcf8d43e8c13c9e8f8fc5156dc253dc97c9cf53063cae0feadb6f76c27e1e72f80bb016101d6369eea115db6aaa687f94976277cc054b0228cb94afd8c1394ec009a6f6162dd503e973b557ea04f652e40c0ae264cf272f3773971bb27dfeb9630fa91429c4e9b3b53ce5f41a40cde0d639499d8f6e8277c5e7df7b48f4118e569a18f1afd7f3b5118998904c9192f08fa278113b1ab3d3d1caea4dea6ad4a46bd68c7ef60123cab4b80c99906dd17d27c080371cef940e15d8c77988aa3dcd4b26b9a44600f46d477eaf94e11121ac157f6457a46e7e55825ee8e1e27fc98c00a21e4d3e3631a38f62555074fb586b86c09b1d8bfac99eafbd3daef03c7482f7948e63f5298366623fc02d436ed5bd34d83d11735cee2834eba76ce235c77cebfa7c7491039137cac6754cb9f1cbd2b90ffcb425402794d1f1b3600543f594f00823d30e12b154bdf9e586a0d0af66d022ecdc83b6ad588a6eaa9ca04507e178a371715a49298cb0b2e17d1a9aa61be9c222038eb2809b9e12eebd9d99188f87e6d3d352beffc44d1a612c7aa10cbc90131ea5d78bbda3c624aa6670a7a37b70a1c1cae92a5ba197329abd487d0999952e00f44f808872e8fdd0ce3856de9472d521dc6b6c73dccd4d679f9d8934778d9f9961892e853ff48b6a068f95269d33397d86e50612467894fd0a376549bb59e743d4901bdfdb89cf32c3bdd47e1ea4b800c8b99ea27d1881f37d6d72ecc88bfb8b8bf42fe23d875f88d374881aa11af14f93c07fd3ce246497dd31597fc517c3acffd13623b7a6e4aa9024aafa7685b6271caf16c6d118e1953ec3850531989cd945a15f3897e19d49ea44399aae6a8dd0251f75cfb09a70f08aaea4180781d758c3fbc0013d62db61e5c3b3aafe0d3261bd45d3c835eedc4380f729ed5905386e39cbcf81d86e836da8b8a0e0bc7c13d1094d09f00031c55ec0ffcd66991e77157425ea455fdc8fe16e4108d03170d2da1b5016588b251e28eedd0a3df818c28c2598d05e75478dfcfd23f7d8dbeec7aee72a9de9d6a4afd5105c9f2fa14439afb8cf26e94c871ee57461002473557c75d2ab62f3ed289472b7c10f4baeef711f2453f425be8c7818926fb7aec0f82fa27d37d14a9444bcb596e3213d1499f241088625231a26e528c83236689ae15315ba9a77fccb466b289baf61b9f360b907a2410af479ee42ccbb25995d963c0f0fcd99868c0fbbb89ca9919eed0217b7885c1cd8798c05813a055482f646f7bdf170c755c763f110f4879a6a0601ec4f6e0be725bc240b27dc4eef954112ad6cd43b51de21a33bb135a8479dc365b7dc2d18fe6fd10a40cf482b4ffd50f6755fe555ba3faaa41730f5cf27d31cbff629132ccc9557d19ba5953c1de6a6cc618c9ca9f03a882010f308d65de9f56e28f71a21435c7cb11debf3864800b2de6a1ebef7c3b40d74b8b890f02f84e3bae77a9d431feb95af9c779f081c035add72f42c79893957a7c90c4c4d678aff5f3cdcc82e804f4b8ae1331df17d259c8d6d1f8df8a1777c5611d540ee40a6cd1ce4b9ebcdc1f84c36e39cc911eea537bc3468b68dabbe506095c9b10416c82fe3f8a28f4c873a9de89444b76153446a4aa1c8f6646387b37c09f46444afa36aa43a9a63ff98cd68f1d251ddae09c7bc656ded243c9fea701c76363ae96b2e3ae96f9cf68f8d4e6fe9a1fb95d6e976df3c14bb827f5126b234bac311690224f6a7c41242f535bcfbf321116d1f38a096c35bc96f303e1dfed763a1020ca683c60acb5f04036bfb6c174e753e8e7d15b75775e0ebffe1d5c9be352de1e4c911e817c657eb992a544eeedd9ba45052aa3259aa80e94610f89821929615e48ed2006e32c28ec2e9f3ff32660eb79608b934075a5b70c6f754ae86ed61c2fe2793848615dc3a3da068efe722ec1876f89e4e34a6d88f59915c4c655ee33aa42463293078d88a505927601eac6557b0e63bb4a38c912103f7a685c058cac9fb9e146c339558d3e00408c49d343f9876a175882153d55b01c56c9d1ba795c7a4c0bf2453b1f75c1adbc7a3edd755988477b439a81c2734d1710bf869bc1701f3ed3d2b1b46bf6e38e4851784eb13fa2c9f67ee2436bd914b7d869bdc8cf86de12cae0b2f25b328331d45cf1a3dfce330fc7e01ad29025046720340af353437350af6ca0a7e472e5e4170ab6ca625ef7cf4ee8e36ef141163f94df056de9a0d8b543bbb673ce220427852e5dd64b765252d311026a246e0f5a6513ab4674ed048826960b70963ea3a069ac7d03170d13b1ac30843fb9fa42dc1a1ef2ab04783ad7cae64665899d7a4a5def6a82e23da5745a6c2e56e5a63e8f6f475c16dd29579d7fe9cd943ca82a25d154abf553374ed0fdf1a70376452dde2a3a7a9e10d79e9318f1d57bc2d8ec5821b33c8471c5fca7ff65d63c4e2ba06422e44d5f26d86fc9a5e5e4d6a702e240d30b76efbebf354557a34a5fea8ab75f7b5f0778f38364258a96faaf03285a59679f7250bc04366447b9fc592c27bf95280c8988f0ca6a75b733e35ba8acb8e237e49731b5386d9a90e0558faef1c4593787d15b5566fff0904e91a4a7e4c9b4eaadf321a6dd82a81cd4cb14d213e7c47ab08b9cfdccd3db16623221c8d2f2991cf0199e56a4abfae540c9dfffe3d5207ccea477e3416a332e9ab367d261345279fd5f13fbe3eb0ecc5c3db8462ed24f4b0fca37f4a7c4ef29fcf3e692e779e7e34b761d36d1834c9452a7c91db21bd98d2cf6909de29f312e1fe6c677ff7ae368821286f9039fe2e7d8a61062c189f08d09ea92303a5a961c8717f9263569e77fe262796d75130e11a2f89e1caa61493ebcd9d9ba286171bb5dc9f761d57adccd779b1ec02fdb62d4ddfe08362405bf98bfb80b9f58067e0c934d532606831bebe04e11167b12bda4b6bc06751c69fdab9a0e5870cb6cbc76d843958d61e6b1e3d13f8f670fe95f8ce4858f32a2bb2f3a44131254b5e8471cccf65559a7fc15b450a8fd5191ba6e2923fa76a34e59ae31d2e1d4aeabea46f5409c6d8be1a2c32aab0907b76c44213d925c924e9307c611ad25eea7470101c3916c778c6f5d5c4a50747c22b6c84f7e8acb010792369333696d99648f56a2df2e2101d2b46438050b3faabf2b67719873d9e45458d1cc12f50fc121ba0f3f8ba873e18dafb83242df3e6d1194b413885e4e5d364acb9d067432c6174ca8754107dc69db21b3dfea02a848201ef7cfa324fd64a21af00d764b15f642f5b457937e004440aea92a470f96a2ea0f7f1e8e4d7d2707a06a14751fa4917fb9c871cb7c7998e28e53d894ae451880007f74872a2f27aa388937d7a4dbb43dc643832daa78d11cb8f54473e8de70abe1a1f3fbcc8b6a98163a626d4e91597a988af7030c7ed99a10b94e4407c8b6d8bea095c2197a99030dfa49872eefaea8fa59abb0bc3d2ecd2833128a87727efaf96715606d9f8767ef0c41911bb909b8c36a7100424031a74677ec1b36cab4481a6cf3e56355d2f6d9b44f18de004cff5fae86d7402a4131474e937ffe7ed66f05633eafd9ae07db52561086aa12ba4f0ac366ffcbaa93833902685131ef371fd3823ab6cbd55a23f1912ff4c025f58fb07f70cfeb2fac3c67587c9d583dc453e20a4b018a192e6ab1632db7f6aff96631f18fc212d769eb62ccfc112f702a05d61bf8cfb37c01fcb77ffe370d4374fce042bacd12d51e65e550a85f976fdf097602275120e51ea26c21ecf318ee79eb2beddc5bc6f7b9a10433698a06c964a3e70b1c9dd05710876e9881ff989d39bdb8e4d595668fe3c90e6c0947e83f15e38ff274ee22400b32a620f7aa23e8106e988eba0565c88eb97882b76ef1164b07d17204d29706adde50360be2a185d3ccf78ed5a3784956151545a22b411c2bf9c2c1b8cc1d8ee64fdbbb2e632780e1156198540b840e993e0b15ae770a8213d373a66913a3827e4fd0f8b0b82461b91989a570f5c5f4919d770aa782c4057fd8232f33d2a5de36b2370376c83113d128578efeeeb6ead60bfc2496dd32facbcc8bc8126a827a9b2e259f807c3be096061a122b9ef2354c99505225fb7f39185e643b168d4b56b64624af92675cbd14544eca6d138cd700d4a5e8b930af653e8ce54d6f14da04b1cfb80852dee1cd63098df4ec659d862144223fb8366e7090f064dad4eb946723abe912237296137289fc7a8e62866a92dd61625b546a74c1f26594424412c5a38ecc77a4244ff40e2eb1cfa5e42ef04ead271190a8abc6f495ec3b663126416567c58412a0198f150e43ad12784f87844f7bd2928f75d415bed919323dd0d6b7b99647a424616e3994666a74893d71f917a809e8fb50a93aaab7509cb57e2c8ef22ccd0349d4ff40fa0234d81558702b483b487c4cfb20cb2800832e4bacf7d1c29d0e3a1b534566fd5dd1a6b768c6676af153242b66f0cc9ea5b167c42a6ace47485b620df91de4e9fdc1f88e4e9436d8f3a0bfbbfcc94f57cd74670b1d4dd3eff16ab70915fc273078bc9835325d5c7277ffed5a09f8bf55967206bcc343ba478d8b315e7a21977ee0dbd1dbb5b73896fbf94f1f770cb42bdfa1899dce7c899c228a4211ddecef6882addd4d5653026d5e16074c374c9037452ad522e432d107324cba01611dc5ddc7cb66da10ce135ba318359e912d290611fca0f93ccd996552842fbd849f72945fecbdce24d89f5f0894df7b0ff1d74f970cafae146a767e823999f0ec51077f4db7df2a0b05c9b424f52f545e44191c573656270ce3620dfbbca76859e44836b9d8463a5a9c415ed3a68063897ba6ee47f251b9d05aa969f3ca2f4af1122d0039b3a6e01101faa1ff56c02fde497728677429a4a518497c35cfd12234a6a8067c42d6a87a1260c7f7fd0ea6de887417275f9345c25c7829acf93291ac4a89317b7b3044d9737f3a46f33fc42f3c45581cbbb783c619baea7a72e5ff43c47abe6247aca304ae2e69cf9a12e9e06a8512051cf0157bc192e21897964b133ff167d8a4de34de77df867ca356d85dbe187d2013a8f9e42041b71acd74379f9ca00d63590928934ad637ab2285d5e7b9cb1aceb125407e182c9b6b0e6541552b8b2c19c1b240b65079c3d20a2c3766807d1d86d92af0a02355d443e99cd73a43e1b6203866abcfd56228d6ac9787c5610cd12c77b86243a2a0f207913fe25bbfae6b17206d9cec920983bebe65d06734a692ef4b971570494148643b3ffe214f2c0f8fe709032df64ec8ae99dfb0b3e46db90de49d7a88e427e6450ee8204c5bf8c595e056c20b3cb28b554894468f2db64b2dacbcba0963e99dc05f07209e44cb846cf0938933eb15a674ec5775b7e2a09a276564ccc551251c62f21591390f614074f6cc1ca32c04f41852f460b0c4da8819864f93d7e93d42b8203c6687d43023820e45ac93d0f62575f682cfd19098c05edf8fc09474046cbeb0a88f2168b1647a14dc9d65ef25bb3f4de6aa023f7b5f7a5502fc888819198b85e24bf2e30dcfa723a46fc4af28fd1d97124c3d9e70db688bfde17ea63963984acd8823e51ace8eeef6c8be19b9d21ba6ef319eb87e5b34c8fd8191c9abd88fc76681038102afbed4d7396b0190089c2fab3bc5c8424f349fc71f126daae14748a1be5e5d363f4de57057389c96fe0db2d5aa772b1d69077a95949c6e753a044819e9ddb242ae72c5a773f25405474b56a693b28f6c338ba25ebced5dd8aa20182e97bf607bebaf5e5c758d96c00859fbd09bb38fe2fac825c97b1cd88eac57aa1ece56df892ab101d18e15bcf36c8354cc7d0b7f4dd43bc0bb6274fe4c3678e9284e573e382c76408d64198f17fe4d91fbf053ac9fa640b99bdeac00d1c1ccc8d25aa65c77c748ff2d1a4939731f8fdd45b4b8dc19e0f5ce06fb7fb3db229e79abd058cd868e8da00dd786157a1133ff9cb77015a2d55c0d503ce069c4509f9a58aed6b4db7af84845cf2278be1bb4f220bbf40b6f8dc9e14b575e4fa36ec930a04fba634d12954be728734cf9367b207ae41b824345c31b66b756ed45233a57e82ee6bf66c09810efb73207ed0054429a17d90766f245309609b421308f62787042977639ad7e9ca9c3505ddde7596ccb0d5352e8b959f05b739bf7d907ea7e04830a373346f9a35a511c1e97d0b1b5b001471c653a6e09315a20fd497cb91857b2f09164980a24d2e8d4bfdc9111d6b8ee40f94b85fcd0512b148f3be0e5a3cdd73b1b4f10e3c7455f419b45f438cfd81561d04e15e18573c43958ff0306bd720eed34d09f14120ead693ce385197ba445faa383955ce112fb87257dd4aea90b4b7a8442754f6190a8697fbe36016375d552646ed8904f0bb76fd911d2b492cd188c84b483619f9959b0ebf2489c58c937647933055d794d0664d8a66d6a8c7f33e1d0b99ec4edf456f92e6bc594fcf2961831d1da5b8f62075e259fa000c875a5d6263e89dd6a86ba3203e1d502728d99a17a4ec7c0e55fe1421e4f8965983378a357161c5900d1d99df76ff6234a3d30ba2fbcb6e21d302b9de1481352fa7900fb7b14fb3556c95f9f27177794bf6417e490c8f265b12635cfeb3a1b083632e5abaead90a9c3a1c2c6061def079cd9324763c1ae1d465c8fb1c60f18e19668e7d86b8d2446f52a2e402711619206680111a4a6cf235798f164e82458ac1bb8ab026e3f72ab698959291e909b9db82c4bd89d4d13ce2842833e84c68116d0849cb4add3b5dc9b51fefb1fff48742028284e418f2bb78691f5b6117dec710bf10cdb70effd159da21741dc1fdb06ca2a4270da312fba14c039b3ba9c2025783da5848cc704ca7cac4e1d5d1d9564fbbd64932f5259f2e91fe850146874e221fc6317d1faaec06aa61ba69ebc50ce7f95ff3e667f7dc854471ac528ce2e7dfb527c59dbf769eb940ddc54850df5c3266bf11cbc40cfb635b492b007a9342aa1f889f68de2aa712b64c8d28a50341fc3df1f3c35da4dae857251f3927b1843b96c7f353aa561feef8dfe278e2b7ad766e18cdc4a28c6cf6328728c70a2109b01d8d175ea8a27177509b57e84f3b04a5b6b23727787034dfa27eec5ad975df185350046e47a2dd3fcf5ec3f8bbd79f96bc95ad93cf99ce64193b95e851e948de8a96d9434ff4f7a4a217c0a361b44b719fb20f7a451a670613e74e14895b3cf2686f58f90c9b258778bc2f0f2eedc74bd004231ac5bf409f9107c9ae8542e4d25cd868125f10245075e3b251587449d83b200e1c75392e55dc5bbc41403d205dab71911d033c8349745531477d50fade0e8adfb86e571dd7dee25fac578d026ff0da83e4c61c26438cff5675b11d75889f660573015e89ebc13cefcf0c13515a42208f2c7fa7c489120911003b544c78450ed35e85fb034f97182f4c5787072761dc2c07e6186a2d96a114aee5bb83b72aca03fbfd8db2e232bfe24b2598d4a59b1774b2c2b9f7978d4f57fd229f136f5f5130990f0ccf2a8b155261183b98525476a409fdde9e73b025954768c56872ba9d5a560913281d3ba2cc725103ec0650fd9f857ec167e1374acef67cf8e499505766a305529e3fff3a22b71d879a7c388d6ccd02a4adff7ea8c4c9aadc5aed8c649c5d63c8a716480027c296ea21a0fc39b4d6399fa1c0bd7a7e280230939e332427771914cce33b3637a1877432b3f8cd4596dd56c610d896c7882419cdd3d975982fa75a2cb4c15bac0729ab353f101c91409dcc734d7b0eafe2460a36429cfc64dca22df7be6f996a8b86d6c5d7233f2f1a0080540b04c009355ee175981ef76141292af513774354f19eee30ad8c8859d8a10ce92ce6eaec19a85a22b91d9f4d79aff8fd99e6b2d48991ebf8ee87aa6d916a82064991b7336b019f49c51e42476ef9c07e5ddf2b579d6a2654febb9e6d3da4c551610be8fdf6bcb3ecf6042c54e2361cf92e94dfcfe860f9af7041e47ec60f5fc8e8bb932d44ecd57e4b980bdb07890d84912e5a2f2a961628e2d9f36ca95b46381a21e6ea664c5768fe46b02aaa728f49f9f2d5f2bcac1c11983e3425269e5bc79e695520e5486787d3abdfefe5f4d2055a3efe9546c4c871f3b04b3a00b5766a842cabfeaac64eac31a388bf715a63890537a61973afc582b3366761cfac2d6f84b986770fa9091b0df9c89276f3ff3dda4ad882c1748033082cf3f5df91b5f599bbb5c1e842d50da2f91145f8432398c1d46c5a606c9aa674154c74a34c8b6fe827ddd8b0253f2eff6e3717ce66dda97e83072e1a8d89b381db2100b16be426f2b271fcb9007c1f60d55b2c2ba7dd91cc5bf41052bab76440daa2df55fd41b41e46ec2e738252f557d07b0db7924506cd6fde141025fa779c6e07fcb5dae189912f7cb7bc6db2b8cb2ad226360626d2c6a5c3d31d128adf7eebc1637c063569500636a24c5524e5bceb6c47c2f654523428daea3297c044c0206ac81b01f4ebb97ce33d23af9aede349132493f9a0f82159557c3121b77eebdd76019f34e4fc4b9b259c0f32d1b41a880bd556cc45cadc6219ac72d5961dd01afb8709dae35aba1d901644af5312970467561a60ebe0f0bf75242320d1e4e4afe7fa47fa5b1a55ecc1c6fad97955f5043a08c22867e97754f092af01b44a7ac8c59ab06cca23bfeb430b2aaf21bd12098c2e12b3eda7b7f2032541edccf8bc7879ce13f5afb1f49c2408496fb6ffb7aedc7147c3606e106576144a4a554d88215fa15ce3d0d2a147dc25245c1ec31370d05d3f7eeca93b57931722eb73dd088c0140c1d660ecc8a8028cc1ac7d2605c7f7e2305f3456dab82aecb20a77ed2ee7b97d83866435b95fc4ad55695939367faad3f4fbe6855373aad334a34af9f010c64f41b24e3a5593d3ba472189800641a06aded9addc028d0c13fb2f572f5ed5c450d59b9f59a989c42c46ad9273459f46c223d51416b7139c73502ca5f2800d133ec7ac1846d22b643c6b6f7f00bd31d45cd6dc327f8068c4c163e1995711c8377a4c29e88a33b09b6a71c3f6078c86bf9b6b05947acfc6374f4455e2abf7e5688cd8120bfffde4e1faf7906ddd50f48f48d53323fbe220bb71ee6c29eb9ed4349d3d9c055506d50f72d73187ca2397f50e2ae3970e87abce006893064a175089fb5cd1fc91ebc0ab1e861e588b6102b5ffddc63a4e23b33bdaec772aaf0857a29867542e898da6628c8c1217d045713a0d8b4baa6e1994495f2bb52f3475bae78cae52bd69d3d075100a9bedbf558097924938a6b473f0fcf690739da84bf3628f0313ce30c22957414941056f9ab945c998f2cf79e37c4d86a6589a0eca274280a9bff334e3488c7a64c3a26eab7d4752d726bbaa0fffaffd7c55861cb08ad0e0d44d069afa77355afa0c1d3c891328b24bd7a04a3357abcd292632bd417e6757bca490df0d284345f2e1c1ce47e9ead0bc1385ee0baf706a5394b38f19251f2e39662952ba9079e0506d460b894f317a9adba53f182898cdcdcee566cb4a70d4f7fa3297db73df981c263652c739bddeb5ec977c26a334f446687dc756ce8c5a38c4b125823f1a1c52bceef36fcdfe118a808cf5327b6a5f03cf376e69f8eef61e9521c9390887dfe8ff1bb1cdc9898b143ad991964d9695aa4f16c87167838494d57521a0159597e7f35246c31227a93dc601498529da9d23f5c47a817bdc00b7f0b9224bfb03c1887f5fdf55e8b52ad1f030aadcc0988581d745d8ff6b110ddaf01993ff772c1a6f6f149c079537b3063045574274ffdfffabb96e2c714671176b759037956827eab8f112029d2f4b9ae852859254413f0fa8a67b71ab5e976f1c0107f9c004ae4a31c1c810b8f9df74ecc47e9e738ebe71096f7186b2030b7adae53efcdbe03b472b5ebd6b20d6bfe4f5111e3b1e247a67d5c07762f60102a6b93d4b22760d9c70ac38e05100341f662154599fd90b14eba0a8e7fe5bf4cf0a8b4a9a3bb33e65b62cc99773083197fba7edb3123e4030fe7399d0e9bf5c6fc813436c1e92e36dfb1116392d795ca4165cccc6eb08f8f8051a2c75a84892fef79f9e520d900d4fba59a09491288b2510abcbc0deffc89a377190cbe9b261402cd358b66de219ebb9228967444ff1de30252be29b7f2dc5148babff8801d71982d84152cec03ae2d10886e92426c6f849ce0d02becfb830f8afa5ee5f3b6b15415411b63d79941dbf844641c89e6c7fddb87c0a0996ef14b2973bace920bce10bb99cc6f0489f4608c2400bc4c07be3d6ad7577f8024bad34697efeb40307cfa0e2433a3933e44df29c78d9c8750878d3e224da9d9166bc5053cedfa629db572a18611dcc50f8e484bab7b08cce41f6fa00875acf74b90882d0c3ff0c66db901fd84b4f5851cf049fecd987850ac8f967fe5631a60b86d8cbe76b3f80d2f1bbb40f48036d291b661b5445cc73ec2582208c592b4df7da7aa5fcb33697d10bb9db9f8d41b026740b05f361debc257b749e1ace2a1fac9ac0f6ff21af68c54f90d4516e6565e471b5dba0e89395e2b518e8b60ba415987f7e2414fe29de23c1ea4d9d829e43dab26be8922db4fcc0b099384216238738fc0d2df6e256d6d2729515e2af709c7f0df9a1ea1e7d85bc298938c646c435b9a7cbd4bd429c17f6ba0459f7cc33d23ccb6d21fc8b1ef2d8cd5ac6e7f7b9adf6a099e2c6cd97129956cc7532a4911ea5da9ca63e6e3c9e9584e64eba85c7f3fdf25b6cd5d19574de0e285a47140ca9b25b9b2c195970b973bde8b575d6c983638f7c33c797188a9f3c7675a41b75edfec5460efde9c75119c181ced00f2b9f0be46711647e5871a57ab8382cac7672312ebcba800e402edbeeb46302136feb3d6b0f741f11be1ce6f114276e3f0ad01edde0796c3a5179b75ee9d0aad7ab601ed668eadca16a256fee5476c145ff055280da40eb33633b0b976e2a28c40988e59aebc009fdaf6de8d6673fe3b47b22fab8949651f051a58ce4f1f516b0470a72c116ae9da79193d833de3efa2c743876b33e882c18ed2a546a07730154358e0dc2ea8ed4b64e33152f7025226536a6f9becbad8a2d7b6dfe2ea9737f8739e77e2b6b33b3b9d2f908d77678e0d2e1ab0292723eb1fb34f63043b2c448d5ce93c38e243ba95c4187b97c6f0225cae9519d052d35afebc5c00b9d6226fc9a008c0ae0a001e2677121b7b67ed3b7a5949fac963d858015cd95516bded49c20f25fca15f29a16796d3660eee7d136e28021b4e9a45eb36962355172ada008d258a60c502ee0f261f3ae22e095da04781ac0dbe2a982c11b8d51d97b3c97e80afdba483bee8b5f64f710a5229771cc2a27e627a158a88f89c958c1025b3bdeb33fcd67b3ce66439e1e72019c9f0278f73ff71fd1fff0c4388810d109be4def458e3ecce4ef838dd6443a7cc782b1c1434d165d58b36cec26aeff107d7e2572a7f050764a788d9a85f6b560d1bababcf4113cbb50c9ae929514a9cd939598fcbb8025a0f110214763f978edd9e763fa1b9e9d26a75d72d1af0696d7686574176fea0a6b5c663c41fdc1907a23497c2c7ddc623f77ce4efbe2c630ca653286b877f11b7836a9b96ad8fb86438b486d67c807ad4d6a407c5988076f632da333c510ea2d86cf11dc5e6803347f6fedda65072eed3ff518a82d8a724c366845a31f693e0f6ff954ec6cb86e61af1066d46f66b58aad4e84d96902241542360875009cec151e7831e599f9823c528f8694c733d3d9175bf165d06d2e80380fc00a9f9804fe59abe92f7b49b9985fe242d2bdaa1562e39a93f56df2149a7c8aa5606a7e2d187c7bc070fced42023c8635a1cfe1d974c35ae0979f644f7f24dfd375549920c86edb816362f280a00b2f1de26ffdd413920415e8162acbe687ebcb44f2572a538d63f7c71c8a89e88e7c5b435e9b8d27ce73b0418ed6697c253bf04b724baefe3ea2755e39dea81ff38877d1ad44df053a9ef4041f627e0be9d00ba6ab7fa17e67c04ff489f2dbad402f9a17dd967b4854b668eb6b2552791c73c8b2c73f0cb406015f80cf1f5540511113d0a1be63f3a42a586c115ca38f8dd5374f48aa8ebba174814f7c38fdbb77b8d3244ad170eb188a53310eca1f97b2454c9e6c4dd84b4ff21741dfcdeeff43a7f07fd58bcebce562ab9a1545edc1d76b5e6136632e6481098513ca33f5770cd626ec26017bb1afa6f853fe4e25669f4bace0912aec4ae628b6c004d1167f27df5105f3cacb37ecfb95f8bea253085fedd3636249ffdbfaa795ea1f030892fe12f4784b63e798baa921c8aa91f8352301593a7519682728ba9557785cb45165c7b516ea6649ffac78006be0520930645b26549d40bd5f86932a7f7d4bba55de78de709da241cd3bf8d8c61cf36e65b562066a79faa8189f304e268d4aebceb7bfde0c79f87343dd1514e3636784bdf96428b6a60866d5c843fd0bf68fd0f929aec623ab5b5777fbd764dd31619cb2e651a23c625448e7f5c3b9a5f3d52261e1e7cdf2195cb899425c3bee25e77a3ce087eaa3daea359c107a06ecb43a50f09ea6cd9b2afd368d01ee507d5961d68a77375e9db42327bd3eb3ef36c068fcd5d7eac39553ddc4cc96261e46d5bcde8f1661bddd836fa95ca6ef7f2a46307e367f4a52ad5c062aa2238f638cd685b25aa297aca53a8260f58dfe49b3357a5fae632b41956e1884acff27a560d65ce7411e8233dad14b7fd8f179e1122306dfa4cab9f80654e4c1b6a68fa8f484f605de998d3dadab7751ece8fc61fc53b4716e339707738ef324de1a40f9ff2aeb09d4f35f1bd672f9b3ba72c1e5c082353a3f6c10a04120efc708f57e673423f6e46f3b63025a788496cf888b0f8c2ada95ed62a518a32e5013ac9d2984c25deaf90ebb3088e4d1a882678de884b06ee391845bd06af0dc474ae3677c28ee1f8da35af5b92bb0bab70e6e71d36c04ef2771a67645b39b0356fdd58850eeb271bcad521fcdcafef87e69cc2bbff64d1b172bbfb156b7b0a498966e2512b678ebc2d827e1f92a224a61d4075ce2d2bfd725ea06cbc35be53f78d060f0dc21d8d57e58e667ea7214175026303260b58584778d54b300293a68f7398012c3186fcd0e57f011fcafa0f3b0471ef693d860ba2625c077e8cf2a3d96b766573f46c55c0a71484042511baa47b502c8557a544ee97a15cde5a06ea96c006bd83899403ee937ac1625acaad5d30244748859626eeb8716a7d5114989d820e79fcbc5293820ac7e347d781f4d2f53ad74a13d57e9a5fa8d854b3d6a1adff7cefe3ec1c0c4a6cb82b064525de060e3ec78256ea7f323b531616a625f572bb9968e2f4761f80cff65e1f439532a457e621045385bfba450556238629320656c6919f858b75705a81abdcf11847925063e4fde6e0b5dc7946ccb2e43df54776dafe2d1b603904a9d02d9a2231f11d3f2ed8829e5ed0b71015ec1caafaa3b3debe409fa69704315a5e954c99ba844a3cadd7940f4f17e7b49a5db0e759ce2f96bc001673b755beafdcf3ad1093230f7ac847a80faec74c0d345a63806db50ee42a9553e3c4c9366d5841df0e1220fd0cac39581d8d66185398d7f68f9dcb15d1e7e37483e762cd0d3100062fb90734fea949cfd7316976bcaa57b9d87c9d9507eab8f13594fffa38ef0cf441329e0e8e408918b34de78fb09f937320f69c5743592895a69b35907141ffcc14aa7867828960285879852992c62c8fa93a5f781eb3dd67c8bb25d0464f0f23ea3df2c6935b735c45f649c329d30283f3a9bd6b49c6b1f92a455d2baf5bb90dc87567a9123d9302bb0a1c33a7dfad810cc386a0117e064acda72983b2e57c9c4426930771a9a080df48dc89e1c3f99e539701ed77f0e3e5f18923599eb5f16a583060f35d95705a4a7f0422f82d95cf412f76a7bce0e3a868fe126d4ff56743be0f66756300e7cb8cbd79fa0ea42f18c0e97823c4de4d7912f3aeeadac8af80a50b5a2998685747d6564aaa941a5f785870e6cff1e14d15732340b1a2cd14924afd732b154d17671fea6b1f8abbd1ee8fb8026f7b28bb080924b52f82c13866d3d07c3c8a71e1ac3228cddafff8ec6308b77bba453d7ef318e1454004ca65efc1f8996caa2d22e52e4d884d946e477e17f71609a9ca814812980c649a07775e4dd56631ffaf89de7593796cd3fa3d994bf040adefbac8891ab3022aa32064553e2c626e9780258a7185366d1deee0d7d5b8e123236b425fc1edee5337d2d1df200c5b6877bd3ec10c1057553c919a1020573d6fce326b044d2ca3180f3bffe4de99a118c7322a71c7393fb04da68743692ef6702eeccb9aed947ad0f79f15f74b748ae1d6726452453f755bba0a54eec7d79bca517e4a6b88b49e8fbe691230b646d4f3b7095a84f0c409973dd80fc9e64aff5f07186cfe0040cab6687174de953bf1a2f3cf3172f4afce80a09c52ab289d9a736e560f71da1c7e5909e793b9dc514f7038c2feb053eb75d3ece58644152fa3fb8adb995a187753247deda745c65fc72c8b594bd091d858e4d8a11de6ec96eeb5fd9c6a70f1ca41a5ef1034d90bde5b5f123067f83a19f0f2bd055fa0f1c1fa346cd5407558c5b934cf2adf091bed93d3fd28efe508612787ee78faea81e3f3c71c1bc7faa4512618ff39c9f2f3cc36b16d33fc8be0e78c0db497034e2c59ea0e9402b1b207bb15564798a1f447047206bcd5e70137ec50c7c2500b10caa8a901ba9366241a5a99a98fbdfb100742eebf079e4a56e9f273374de83bbc68c3c9026b1c58700fe16799966411689ca5b8f7e254ba6cf3def91dd8b2dee98cddbe2a8df45bb1b05f651b39ce76328d656dd4332adec2fab8d06a6759fea2ef30db5610f321b9dfd67b86ef0cac3b45f6326b0973336a03ea117c49b3e7cda2817d9eaf0e801eb6e07e047ab9d55af122acaad5bd4353fce11a45c3155c238bb8ab6b486d3a61ba24cd1908b96c94cfff0a0251e6191b2383da9ff1c058c249d8b4f61a8db4de42902162b3f0b79da1a64449391e50184de33f281780a509ce59c7d9583327f8955c9cfe9ecda07e3bbed78d1f955b1652505c221124e6ae54c02c859156701abbfae6ad9aba8d80c1f9f392cb08d2feaf61bcb94ef478901b2b0752eb3cc8fa3c0ce5d5e08e6ddebe4a82834a49d98ad3dab0556c331757e97cebc0883318779f909ac1884ad91e7916366c5d76ac6466d2a370a7b099bc3a3c4318903e5020bcbc916be156d1ee50ce81032dd9ca798fbe13c1ab46305441eded7dd800e2435e0d434a9a160029d2238ee8661dc1545df876bb2410ead66787975eca0537d33a033dfaf86dcb76202f7026fa061c51316ec952ea8824b8ac3c80d94d9cedc59bd24a6ef15682cacc2b11751ecd2271922b58c9aa62819453422a20ef755ee97a82140a312a810d6d9b76ee02a735c4a882c2957a76821e4a5e09cbe9a1070eb19f324c036194b79a3832c8054a087f4511b35244e8e163916d487fdb55ef3028bd5c60fad9a1725e1b23487f9a12b3f89b6c1c7f37acff82842f0d3110f64d8bdad1bb499c89d78368f7da8b8c75c7ac49bbf4b2028d947a0769adcc7e5cff7324d688b8d260866ab261c82c8d7ea7a94dde95214fac595eae366f7ca72287cb2c67fb3121a66e02bf48a9b73cdd9af1420565640e2249394d38ada5b38f988c7d2e88025b5e2540818ede997e7c3ed60c53bb5cc514ae1cea6fe0293214c2d41449b9ab7501a17742050472407ff251a2ac46013fc5416f1a643ffdc483629b28c478f2cf7985709622e28a05d9f60e7f1f595226918d3f565e391780ec704f3505a25dd9ecb5242e0b340a66bb159f0630d883d58d7f3f9ae4ab3f97e53449d0d2edb9634ee25ffc587b9624f451362d7d3155bf2f757be06e20cc709584b91cb1c891876c01e056e1c0a17632587ee2fc8a4a5cc1b582cbc85219e876aac71e463db989c0b6a7cfbc78c992b5264496a2a05fbba45c5cd88bff90d91f63924d70b663ed742bc6f822767d3969d6dad383cd26f72f7364dc163d4f724be28562c4669a795c8ee4fc08e6f438aff9f57af481ac7fb70810016740e169f58faf56af3f864a2a2937164864e79c17dc00701453afff57b685ce3692f73fe29b3b51c431e790da7308be89a399cfcc052834b1cc1c5a86c067a124ac9ef7b8c148de29fb6dfe66b2a3bf9fd4ae47eb1421474f8defce642ea998924a6be7026313899594702c98366806ebca721ddb4bc07141a5d39c114a39c2ce18ee78ca6b6b58dbfb94333d1533fd48a5c331c67c92d75115b49082d4a876d7cd1c55d60b5c8c19cf777b4fa56bf826a178f1fe9425b9e6a16a99f87a0056d158f89248383774048ac66e549902d47a9aac1671ea3eb6f1ed20ca0957fe5aa6fc4b5fce4968d82bb024d337f8f199cfd93e42074fb39d05a8bd94973b09846caf1a2529cd51ae360155c7a64d1f771c1982c810b2028e87389abc7f9b7b5cf2e41fba9e1eaf0238ce8397028d2a0878de65c7761b19b6f10ffcfc056c976a6990c40b4f3a22802cf347cdecc16ce52b70d50a9cd38fb09e3e2c9bb13dc38ec9daf44b7f72d9cda9bfa31ad31cfa378739975c272fdb7b282decf50b7d5ff0367a2b043106f6a5ee8d459bd869923d69eff4c127a90c03934b24c2c6ad2efa239f67e3b242a7757c24468932e7fb5187020eb7ab45009d0b6b45fe149dbd470d66d7e2810f8e97c08bcc8d15b7aa6e693947baffa4e0da46526598c53c49b386096d4e23b66ac57b9015583f3b2a5977596bbc2e60d488e40e74345107fd7a8a7777887ce8bef368aa6e0357e28487db6697b05c190bdcdadbf56626dea3da4feacb4befaaba434b8a4ace431ae86bb15c22235ba0e6fd406d4808a6a0b2822f5f9aa521d32034a45f2f4b25ef53cb14ad129facc68e823420be69787a5169fa1b8cc15a871077413c16376c8e1a8f093519eb6e031b5394c295c4a1c5d281d57d162191319efe78f649a11b78af1c7fc18a2a407b2e78be11defc903e9a6b4ea4507344e34bf57e058ad9ec71a9d599b7feb44f2ce9395fb905cf9455c79b4eabc2cd86cf0bd46c4b3a669c83718454929431df22c53f322069698a83bb05269e3943a860ff46d9c5b01bb29bb34df989107c7252dc48f3808443752e6fbec3ceed6c80321b4304abd2f72cd4aa3fa080fa84da8a606e087af40f7e8d333d9d7fddfefd71f1021d95d13703fd17f40b9e02edddd593f30347c191fd74dd0c519aa6d32570d5e94249188d1a0ebc3182140b0c03726180053ef927c9f9471aabc85958fad7cbb47ebd2d8f9cf22d0228b5eddb009fc3e6f458521976bd558483ffb3d392ac8851403bc466d972ce93d57ac76724a5de2b922b470b23defeb3a6f7fa39adbd6dfb49e51867bed80b72145c6d1c459013ac54559e0a070ca3598f4b7d4ae35ee3098d77840ba8e46c58649eb58a025d9febb4f9101666ff0622181de36a7bc08a4c7edac904f7df904dfafeb08c54842ebba314e1ba9ce244603855bffe1ed8fa9daefb2890c2f35499e8a18f398fcb0438d0f1fa9f731fcd7268b4dbb30e12474fbbce9ad5774bbcb12b4d8be56f8794b790d86d9d7a6d0af119f74ca6e5c587afb920176e76128a5cde12e238c97aecc1c5be80dab5ffe8b565ec3df6753d0f7779a5ad14cc7c25a9b8caa70e8e12e94590d9d5c60f806ce9597a9820e0e5e6a0e23069e4dfc7f4b0caff3075b4e2ef25199df11f7ae14ff0d99068f026ff517a1816a310f0fa1438d9c5fdc815b693c7502732bd1395a46bc9093b567144b83abc2d5d4109d46ec0f73c3fa6757334c9c0d93dcd525f7f30ca080f80b4d1cfca6a2df43f6e0f75743e906fe93f054ff350b690b64e65bf81b85f130de1bc90f7f7e572e22bf60795c7bd09a666a6db5830a9ad21401a46a85fb0088b4c3f510162e9fba20db79a86e380214c98e29d4e587ac004effff03c636f4ff62955e95d9fabf01e2ffe42254b2a4c42bb72c4538e8f397a40f14a32b1852ea21fae5fb66243b8dc464878626d24b99d486f9f53e53684f0f8123cb5502a47044f429e03fa593e16f9952584793f7957d30815622bf5112e981fc20466cc00d3f909ba78e29d3f07e22bc82f8e6f04c436141dbfb3ef57ec3ccdaee0096a10ffeff27f7fa69d8a4fa109bce8442296ae32a027f72e68366092de3a2bd00f51c8c5a003c8e5c1158a41e026df899312a4b87563f67d4625171056d4fa78cc2aa083af225a8ed5f5e1019347369c9f3df754ffb9bb13684fa3f420a2a2d5ec486eeb1102403334c7b90a5ff58d0aef76f9bbf1119ec58f1ce5a61210ee3ec4a4eaa5722f1c84a5366eea7a678707623d2aee2fbc25010d6712a7af8f9f1ddd2f780576608b758164cf6d5f494d0db94982c7f52a4a51656394d6f438d188cc447c6cfc7265353694fd141504f43616760395f054e392635b119b4a2903b5f2f5b63ec83cf2f93c50230e55db2ffbff962100e3857efe8e218f14f036c8655b523ad7c9ccb405670ef44774ba9c9128be6c164d6d75c0cccdf61097cb01b6045e18afd2da53fa9b9118f17ef842a7dd6cb41802debf40cea2f1ae3168d5575b5aeec51e52b2069145a7497b4773951aa01c6fa0e36458a6b61aa54f159967ac7f591a35ef1944e6c2eac6cbf1af4f5550f7582255b4236f78317e94010a967a6f61f262ccea3350be67996bfe92610308e64272b84a4b17bda3d2d15ceb145734488b6a05c4a13934fb7ffb6c5e5af64abe7faa2de53e7b65a03182356aeeb0b48bf903f7c324b0e28af2754719484b1a92dda901ae5b89f305a56818e869acfbcc295dfd07657dca8c71b96157f59b45d307e6bee250ea53913250001addac730f0db254077f44cf5fc0b25bf025df6b0f22a2e92b999458880a2b25b4f3d4688ab83f876bd4210ad2b042ade45f4ec210f980044c5e4dbe4e7c152f116e3b97b550af061f1903e612b9477c5801dbf4096ec64c4ac739a47c54a643679ea391692959ab6ddbf9e15b970842ed6a2bc343de83cd8de159c60dd8d5e4798270438dff0996a8472fec2315710b4bb9f1a36dc9340c9b1b29c1220baaf61b3c7f9147b374239437ce3d51cbe4a57f21ab7143d13b2e54f2567f35afb1f6527c2f5b19a646423083f9aad861cfafc0eb75baf397233fbb3f944cebbccf55aff38b36df0435de995eba8202bd271eb92bb357d2a87a4e2b51cc521232940eb142bdc76827c5694d8d5fbf66ffa1b4f94f8ff08a544d8f226d1fea04683d6e5c019c350d1afe4ef494fb36d2fb4fbbaf646a96c8a14c288fe7b0eb0a3aff1bb1b843c524ee7d20866b957b452a8d39e33a718dd651675879619eaed412abc02ce59072822caf8b32fc25c703cd98bd4b2400e1f1b5bf0d2f76dd3a44562dbf570c7355243556e07c5fc483903050919b3c3060ce5773cd336429e5952f5bef27efe11a4dc0f4dde03488b1e7c24e78cc2ef7412a40ad0f7df40b943bd0476fad3da0cc403f673593eb5031d15d16f32c7409bb27c098a30744368cb8f0ee635be875eb0bf93705bffe089ac7f9bb4729704ce02c6f7d172f522e7115af4816c9e8623355f0ac509dfef46332b9dec9a225bec2c485a9736835d3c67d5190b8d18b9ea781ffa3f5067a18d8f8fce135829e36cedca04fbf906235bd356c5792bd450db71228a005f082bf79147ec514186157117f41a66bef09ad491112ce5fcccc6d36bb5080e281dcdef7dfbf4dd4d0691f00f76deb3880375c08f29d42659333c2586e7dd1fe4ff538a8c1b8aea59d1d8334f8ea4dce13117b5f0953600c1dce6d83570ca4f8c2ef7656a6abda6a4624784e5d38c41578afa9f8ad3cabc56446bbfc1e5acf5607f48aeb85715865211382df355d351f933090f6867e6a55e1b46e4c34347d9646525c18b2ad2d1ec28a9a82d0ad8c3de7a0f0448311a21c369a761aec1be3bde44dcd2ebfbbdfcde91d8175e8b35059eec91bb1d8ef7fc943e61fb43f9cff7dad7f7fc55811152f8099df6e32781d6d7849ae88e4a674382f0cb591a5df11ca6a262803aa7375feeec7d4e2e408e40a9e94ec77665fce364eec13720ffddf65678d4a77efb79e7d88ccb8c44f54e323ab8611062a2ecabb31f155913a74268410fbca3f9e7df47b21a3a854027ac1f34e1b04716ec984c0ed51fa9083987dc82a516edf9bccaf0dd1ec118cec3eeea4215a3180887cfa4b8485373e66beed978b5e738bf8b18029c81c16eb064943b96411673e313321c15afe541e9cf856a46ba42cafdd0d7259823b4ac3d3ea926661cf1e3066269a330d701911f25a027540419fd5eefd57c5d06e39edd5d01b66ac1a934031211d7385b1a2fee01d4b0cc9d3d38fe7992cfdb04efd28e38eb6c605e53b5200885d6ff6042d58cc9b8bc1d3f5111ee4e613de51b243b6289356289ef04b5d9aefa9a7aeaad3c86f2dbbe7c538851b281c552b542de8fff7fa2e8290cab945c0990fe44b6bbb83a9da8535e0d7db6c2154fc766d3804a1d3f22080ac396900b963a2e1ab02a275c7a3b40008b7fbe0c8985227983c2430cab6e3bfa865bd5fe00c0f460f15cda75015dd9df0a168c702ea92e51ec4fb52b88e2fe482bceb47ea622289a51cafb5ff71b1240309ff04358556fb7a3069d72e9a5be4bf036d88be52b86f48604c7ca44c247a95748facd524dc956e44a46e9ee899bdb9f081d5742fe77bbd6eee7bb1c1e1e66fbc9f5cb2efe2740c6390c2ed42d4fd6b9ae61c958d987e2550b390873596405289cb0ed5b7f346707ba3df44e47319db044e8fc9e79cf7eb9ff18ddc2d907da0095ec59131c212564ad6a7e3d28019435481dbdf7bd484ab7b3903925e28f7c5423622692af23b57fc44728a5db9fa595988010157db524f6aa8d72b7f17946419762e2235e78b75cb7c4df007458bd255527abaab4c68e8e7c86ad511814d7e92a280dfd74adb065e4e6a3df64ad4ebf6ccd79707c462e1b8af9678dbb1f9239bd259ce57a88870598780cd301e3cc4cf0b518f5664b4e595858ef1b869c1fb9703477b3bb0b0ad07ea3c2ad7ca830667aa95c403ae75c592b1ce96c7b98e872a051fa94d802673a041b0412fd5178fd3d3aca452a566b3fc8f2cca469c79de7dcbb782b2704b3e39f912250ab0f251b8e151d27ff6eb1937e2c65e333f1b112e3a1b375e903666d53d20395c86ebbaaf092c546d1f70723dbd652daaefbda7ebf42668aa86ddde3dafda0682e3b44570ee1632a458e6c6fa63988b30972946a8f52bb223c37d7b65119877ccf88ce7711294f2d710582b010bece47fdf09ffc91b3d5f44888f9414e5259ca1346e80b46c11203d77610642da23fa53bcc7d887b1748de3f604ae5b51a4c022a3929c80c10ec091bc77e6e203dcce5d996f5e23ce99cde271cb7adcb84a949a8b3a93273104f6d630a5ccb9e02b855aef593c6b0f3cde1bcdc908d3b164f49169986cf028262188907dbcda4e61aeadc472548e195ce5aad940925249f2e8c3a8e615d99ad7f78841452f1833c5e070c3f3f5bd7f901ae00f6ba1a6180cd2d4548de215c51b50fc0a9ba39aaaec497fb75b86626afc06bf08c20049832c6d831fc284618b646d73a553324c576e07178712be9a53ed85abe151adec9cd4415fbdf6a43a2282a72a4297d272290180fe63c772d0bc9095351826c156bc78be77888575f06128b2fdd6080c46e382a92d800400f558687e7a2333f1f441b70be04b0a3389cb147dd83acc4263ab5a31d79876bcf3b087ce147a29fa19c99ddb13c9b87634f0c716a7b9af954dafe687aae9fa6f81676838a9d10fc2b73234f1180e24116affcd059928671f196a3310e44b5de53eb942fc765e8aa7fc3335842ffdf91e5966f5f04b6cda18a3bf0092289c1c6ec92528201dc1461681d331def78633e9182c1cbab5b5aa47b732dd07822ed572631b776e38c01bd240eb9d884fe958fe0dee0f85c092db85c918bb93508d94adf649478e17ae5bf5e1e0d57025a29d38ee9517da22837be03a428cc12ea89a0a6ea05e79459a94ab466ef7b16ef07d947f27023078db9be14fb7665e7735e1b00a1db9ae6e906a7cffceebb8e31bb78b40e586968585b61227d2cb37e2c4ec2b820515709c1760110bb5a9e150ba80997939d03192759755e71cd3abee8eb614b5b0b5d440421eac124274441ca11e8f7e4b857d3ad7f6dda9ed7511c0d4c0655f130db8de34cd4e768fadef1748df6616f3bff7b3320df57e38ca56617fc8519339676f5dcb99992c5ed320098301a2fdc3349b490d004a9a35eb4d82aaef517fd61c7de12e5f4c9cd79183cee4fbbe4d201ba3c9f933ba1b7055382981831afe244db0b3f7c06055471ffba781348a0d998862743fa8695b36429fe9dce59d25858b1770c27d232fbe46876e27eb09326b11adb77e80b6db16c3278d4844ecdd2ffbf00e25ec052b0476a3a49ceea9174ad93e40aed9441fb5e3c040a49391903b26ee367441e9d8e322de4c5306fab2c0d449aee85109039f06d447fb20441b264990452419a3bf0b46ff04dfbbbda761a348e4e3e10f90604bb5fc3f4dfd5dd71120c39ccc991ad33025ac867cfc003249dd0cf4e4a910bf27248a80cbd7311311e4f8cd3a415cd784cc86fd5b271a1fa6f02a74b1ac20188b25209f4d4d52b2cf48ae62b06b825bbc50ddc48eb50ed9aca376e77fcb94646ef1a5ee621fb01cb416f4fdd2fddb5137cf64c9b09feb4e388aae484136dd8a66fbc5345e25a928da6f8335244e5b00c936610621b51d8f9b13c02eda525e398cf57e6991a29ba70399b1f3acc4485b4bec81d183867be8204cb08829da440bd7fe9b48310ab9ee5003d8069342d5de5c9cc407df9beaf2e754f7d9308d28a5a41708925d09b3cd87900ff1e4cc5db3f0f766d6ffa64a724a9d332ca98fda371ae634fc3a8a0cf9d15df37dec8f118ae037a17bc5d306dc17c33d1de24afd6d5b17af2d2accd0348b813da7ec1ad1d22abeea688460f0bc47baf81702607efad0ac2dfb6343a23c63b557b2631f362a91f4964fa6063ef716a4fab8c3bafef4dcc0223b659a5b171eae0a7a27a3315dd0fac75b7566e4e75c014e9eba75a44ebdf785a8b7b2a28200755f9ffe05f1e2d3b86c7b35bce943826fda383cfd693477fd9fa10bd05c397455b3e4a0a823882f880fa7da30afd49fcd4facebcab9310bba99d26876893514d23fd1885e48a39b2beb0e9e72f9ae2d4d9e11c9f4c7f5df7e453e8045e47c73caddaea41cb938a6469d485e57c6904f52ca44447d814656af336b6a2bf592723e4b05912bc60fe2191b1c6de1e3dc3d915315dac693941a1f0b15794399c2e86885de0305757bd8f5afd2c17fe9134af14df7668f8a657fa413dbb535f4d12deea9342b7bf101f677d24fc589aa232dac48ee239c945c92a7d867019d02cda17763ba628940916f7127b4370f748976f8f5744816e131cb89e3e00646b3f46120a2515e77628c7a0b42717ae9981d3bb2d288bc658b92d7f9008b2799535602426216dba265ddb57eae3d66a92a1d0bcfb04ea32f7345f30004226df8ba52496e3c0bb5027dadf28e9eb497a9c91d8a31ace1a136833d4cd85a066e0c98b4423c04ba2b8f9aa57aea1b728bd48a0da5863b7855cb902932f1addb50b7dc3db7d38b4a5e6e4a8f79d1e5766943abdc2f528dc6323b93a4c82dde773b509691dc732953d314e10e439338c2c63742fc14acb989621567f93c42d5ee1739f58631c39820cd8a138addc79fb0615b41851581994b83590fe5c490d3d6aa1dd3ac2078434eb78cb303774a20e2b96df5784d683a2e0e1f88ba539d90965de87d13f09d55e57973e42ae0211622356819c9bb01feda9cbc37b451150ebe08e4a760d172132661d8f9c281cccd766cc54bd39827806583e679f101ee86c32578ffdb4190bdd91d699ab9b6bbba98cf1e2a3912133d758a7cc05900576e66ba4616ffa6c2e9098f13cda592e3615e0c12e5fc612808cf9181161d43e23c2d3256348516139d12a84a0c363b6e1790fbe712f55115ef2dec8d5331a94b41ab84dd03428bcd72656050f1576e8df05946de89cc98cace3b49020283ba7206cb4d39477fa356d6770d25da2e3be4d4938d6aeeb2b260eba936fcc31326a76509b31706f0afa9f34c7aae56ef9c6114bd508ad7e92349be7cd088a5e4aa51383bb282aece42cb36d7e320bade0a1faf8f69393fbfe436424331f7075ea732ba4243ad745515db1a2d77257f6b0852d0d9a0ce8413890c4d959201cc851c59c76e52f2d681e1867d29355203eabbce4c29e8c2187a28e84b52a9862d704de1892fa91e74351592dfd3f2cc14064237ef4dc31d5292f64cc8ebdb98fad1ad699c3c92f3c5895118456042c6371fbacd97cff9cf20d5e6ce60692db371016172996939e5f4674a47c1ffdeb55a859dc07f66d721094f2b6d18f51f597eb77e3f5bd39b319a1c56af4733be7f713d94d482f95dbc87d6e83a4c293288699c2cbbb5f160a6a6afc319f944bff2e2ea62d58f4cf0626519dcabe2f9135f2e53739796e65833cf173b9e17785f870b89fbe10000ba31e0d7bb6cc124c01f6f235e87599eebf2d01a2377cab7bf95b007ad4553400672241892599947918765eb966998433a75f9620d304d1930fdfee6f5a54718e8cb6d9352bb0846128524b3599114563e65d87d529323f33aaf2a3dacd10a6444e22344f8dd1b4fd812530a437495cb96a12d71accf591f11ee1a09ebf45f4af6f2b4ba1473360dd9c978d6e4c2eabbbe7c9a0aebe6633f2231fc37b5592015eb3e20ec0079448b4913cee86b8c817005348d05dfa7b27dd56b491f3caf8cfcd658039b3af1d73089f05d2e4ae20dfbf6bed17d1eb96a4eeb6339fa7eaacb7bad15033b0d617af24a841675a3775cd832de9d69ff2dd423c274402c898325c46c8b0d74e486a5051b22d339badc2d6a15c80e1d0e366cc9df2b8266848ccb6871f1a2dae82efc75767150c2c4099c91900615d3d8831f89e433a7956853990ee2f4062ce37970381950307df7443169ce30624de1df2997eaa7daf616dc503bc573ca2fdcd58c091b0023b70a13ce42a14305de8d2ab10879b0eafcc30a5e58976ca9195e0f537c34bed7bd272f7efd2686143c24d1bfefaeea6541094a6267c7195876fbf8cd459a3ce6ebd67f4ea6ef47a444525f190685f179ef0742e8f40b393d165eafad34614d3991853285845945cf07668dceb740fc0f8583c876b72a87399f09a0f0535a1c851f1deb21e96689a67de166573180199b6696f7f035141183a6d398e087c702fa7c304e54cda51413ce0a3960cd49ecaeb9e2158f7f8732518e7e500c0b84cdab4009497c58d79abf616797a969e32d636ff7e03dc79b79c4f49f25ad434221ff2e6b1d1d1d7c864b072736228296c4e35cf41b3b0328c89c8b8656b7eda84976af355bfd04c6f1f77066403df9fe21fa75c3db707d9f1bd8476791ffb2c2971fd6cc9f77f5061b869ce8e5f423c8b698212d8abfc6feb9e38121e9555a16b4e06cd2f149655d54bc1652b818ed543e5792d8bf8513d050181e575fd70bec7b61113f895a954c6593898e804691a4ae0b716639e4f7ccb1448c8554f7c9e61177f636e1d9e5973fa81f66574cd46c5c3cfa083563d274e632bafc9c939c77d5332ab2bf011f4df22c319b6703af83c2d2821a00092b1a3daf46c9046c4d107e5b664a0cf85ac52f93f0ee5ac69391a975fa6836132f664ea78209c5cbc050c8d7605901f395dd639af716db81cfe31916d5a8b3159ee2db06bf0945207df3f94e50b925cf472baaae52dc099c80e33898275287b02ff2034ff9651e18970759bc62192e23ba713a1cb5cc3382ad33a23e8046149f4cb62b55ce764c688b929fce7475003a5ba3695cece4d990d824022642f4fa6be889b064be78f26994ef9b8fc8adf6c471340c740e1abe5d1fba8e0df8ea0e94cb17afa934f48c04a2a26fe725328e084e88ef358ce1f4974fcb35856ad1557e2ec2fe0fa4539eef51418326afc6537a1d24517c4645c9a2b610cbd4ab1040d9c9fef0fd6ebc27957d6d8952a00a6bce429cb44fb200cd6def43da149ccd642d25774879dec763de44e9575c0b24fd0429e4c88cff64a69009637b2360c8ad7f2d57a9600909997fea920e99c3598dfbed536dcddb5294c988fcefe68c63130afe6439b54f3a9ac77156f245e090cab09adbd2dddd72bec86ae3bd0d7f1706697a814cf6ef6d27906ce1d5821650add10eb5871f8b3cae64af39812da6b01c77c1fb6223b1878b79edbe821004547f07ad542c7a686f293d3bf674d3a5132a03529f62aa2f7b18bd18b328d9bf34a664919faafb37985602a080c2ca14b64609c00251d906dc80ca29382a3d6acef4d1be8c35069dcd6f8fc5b4e9698f18d04e47c98db2e3dbc9377c5008d22dae519caff25c80e082e435296da58a91db7d69b242912a527bede1773fc40fe5230c75a8f6a922c014b2af49fc05d556f7f7cfcfcb462ecc8b703d3e667c68bfea7537d9121fe48c2dc3758f8f474f0fe965558b79ba19003bf324bda58045d2d778414429fb00e4106ff10a8ceac99ab432ac97f43226ae9a74882748822da049efc7fc9793a0fabe25612d78b3ad750e02975399513a5ff70311724d679e35f71a3a2150cbc930bfc645280c9f2969f593905667eeca774d21add9dc514919a165bdf1df5992d88d67791a30f52954cb091264f6fe8aa5eb6763663f9bf31d90b07867c9941f9a563b152e543156dc47bae314add931262bccddd76beaaeb7c9de26a5d9efdc4958c814fc43262d19b648c5017c268df2eb66106528197a0a27227a23e70da8d59aef0ef6a0b80b480a837be6e1a7bc41c2ba0febe549cf7ba00049ae5bd9a04b21aba91aae41f5d8799aaf9c76735b7cdd564bef96e73ae8413e20c38f9bb0c279436a8dd3435ac4c1cfc05482e250a27230c0b5aa95b94f44bfd855ddb8a672ad516ff44575e158d2cde118d78d76421b8551bd60389d0e09b4972abde47fd4709eea9f30edd0b7e556c20bf52c52ae8ea16e5df1d255697cba9f762c15b7693528c6a84fc1ee66d394a8de64d50238144bd7e7abfdfa7e1f7750c35089c1607432998a22ad679ec0f12860afece74bd04a13ee8520f4d5a0f5289d6789f0c54655ed1e783a1f2041f13d3027fa944859e2782fd64619a6255542fab9f22a7b8b5f102af5945a5df47608939ec858ea737b646f7281bb079e17bdcb34a7c22cd24708d44de73e178792e80d2e88404382a74feaff3e9cf2f207768790c2200dc1698934aac2504f83b83a3cf158e0a2d87dd4a30c0436c7351bae3a2be3c1a47e493bb3f3e824c9825337ed29fac1e608f2587e4ad57937f07e63243f94ce5ae5a04edd5745835036630950cb27b404b39694c337c8e9745aa7d40af9edf910d39dbd52d1327557240296ec9ffa229deb1b159cc139b17c6f6ed3edb4f5200bcb605401b43b506ed88765bbe3c63698ed3c689cafc1ac86f79e3b4d2f3a7b862f9e6814d0f3b5c7c275a67f5a132b555b4d1c0aee6c6a04419f14ddc366d582d9fa29396e8191f3e9b8df8b96b6900aa1acffb4c22334f388d86a93f06ad2833393793922325ded576200a675cfe2c9bffd1ebff262011f5df36a27017f5cdebcb68c1a0767a4cd9dea610583953672a1216c7da0e5b58f6f04ec798606a44b34e7b41767fea727b0cb8e6864b117f9f35e2391c162edab2f4bb02159ced99d42ebd25923df175e8cdbc5a92df15cf18003ba1d82161ec61f241a582ca4f184fcce19281953ef279040e3802c66e86d23d65f9ac35ca51c245025364ae96d18dfd2b0432cece312a2663e59ed56664aa6a382a4ffd6dd82a1d528a3c4d51c0958968fa861593bb72bc90f29b66a239353a419bfb46306b17ffe0be3875fcedc2adb89f07faa9ff10e5962f26d64bc05314b4391382147957412f432d33775109992c2ac0f1272202d1ff269f05509d94922f5ab8480ed4fc8f547aaf5a8757d2f32d0762d36f2665478e1571d9aa9cd9044f20dcd161692c69160c91036e47fc53ba19455a1bfdd8203cb9efbbc37aa6eb0c56f97d9475fca24e15dc078cf534c56d952ba873365ac988912b18dacc377ef5dcac4ced159ee3a18eb5871676e54a5d4091c1795b9ac5176bf6e181da00282923776685592a2686633865dbc12857c125de0c7f2f49299f50990b307a77072f463594e8338d3b99f370c8157fd35470030cd64d5cce1f263be510d742256f97cd4bc445f3324647f81d9c5260671d29fc2ccee14a8063931b596d93a4cd656e2710882f1c4f3fc108c10f65cbe885ad58c98ab02a7bc98b17112268ba18257e50b998eccccd704336d6166bbaf1cfac6139018269d9b5a01314350be79a9d6152034b580a43fbab7abfe6e10809337e9cf710d91d35a1cee45d2fc28e41ef6681bc225398755261f30d7bca9e395fabf466f5eb25089b4bc3b59d4e8025f341a4a63ec33f75bd88225814de2b21f34a9cafd72cfdb6c4a5d8f990eade83b28e6f71e524a486d78cb0b9b4d26432042bad243c628ad0d231030a1e559f26ec23ff1601ab0a9111f4676ea3aff4b29acbd41b904f68538ec928e5deeee9d59335378ea0efb4242e8765b7ec3194113129953fa5ed6a9757dab2dd70e6f3834e47379a7534b1a2c5c7b65edd40f98c3c57e42b2e3363d09ec30d03f37421c5f7ee487955334289c3b6e0ba897290c89dea3494426d63fd688545ff8d2a83ce1d67f458bc7e406ae6ea080949a032d82f343149df27067ecfbe19b1e74a00a583f124c04672179b43f7ba51378b48803d4bb33365a6797581fc22bcae39c05f9f09879336b33f40c02184d1b1900ee407e8c3c117ec51993f57e32113f7a4601c678af3f24059f09b69df0bdc6eea9f440eaa519e5463085f62dcb74cace82d58d0b1f6841547cde1dd2b441f19055a9b8755de85bc274c4b6a04f811483028e7bc1a2e1b56ee9bf743a715a49c9a27282eae8fbe3970b50003353a1f2ba5b00ec866f588137b15150ea748da14b2c1fe0692d81b6465db90e66cdeb9e4e77249f370cac29a4c67c7a189d0f5af2f689f2c8c7bd62d1822a023ff5022ffed6ec5b8784c6255eb986aee19136cc3727e86898e26094c25d4eb9b091b24dc1c0fe6edac0d273aaa59b5535f377bf0f1609d623855372f2d89bdd2cc628ca1330fc375401574cdd5892dd8133f9f5887afc7b173d0c28b2249780bbf58ab35d638a5c372cbcdb192adafaf3a1b1ce25e4c575073717272b11a13b8740fd74bcb028c2d360c5ec8cd59ea1191c17a8cb89b97f15bc5f4f840719637b825e8803ff0aa0e5e4874e1df95e260d38504d5f02443ed21ce5872513d9fe46a7bbb879f25e5b97ef001fdc61e6f9f109f482b81910bda656493373938e07309e3b365db08593ce9df1c1b1773bc3786ce9975ea2a14f859adfbff81629ea2ed6233bf24ebd4ef6c217f9c0491c811be9290a5bb64786bfaaecec968923435a72225347aaa59ddc83207332a5ae8f9e82e875c26b4c146224cab52425e8e45069276cc91f19eeff6de3862eca24357af131da0d3f2726547d91620c6a4aee1b0b09774f43c8df5bae2b78f9c0d5532f2e3b59eeace7e16e709f91782732bfa5d9efe895c14c6741fd2cea3bdf36c8b3665f6837b56cf96ed2d1ea9f811ada00fc5a377a9f71c4cca20eb390cca2e01b5284c5dc080c05ba295b6832b867296e6ff8362fa56142653c221612c9e11c7479f660ee6b3a42de379d5e194fdcc2a691a21e6c18d69bb0593a5ec1e87e2ebb097b6554faa3d12b8f5f35fd123a16957e500e1e4408be5b99c5254e0233ff0f2dbf4e083c645078a756c657c96ea9966e72a5136b01b81ab562625d38d1dadb5bf9b713dd9e98c867f011d0154340c7e61ac40e28370207c32c301d876428af1f66b1145994800fadf55fd613922394ff717c2995e158ec823ef323585cb045bf9e5561291f8c5aa1371e13861e82f63ce01fd9105481ffc5214c8af61a885488cd2b95e1282447f4141b1717cd254f75e824aa83f7dd64bd7c04778561b880ccabdf71ed4e1aef833159a810bbb6f4383b8613da5da55032726f0cccf3d10fe227488943b079f4c8a21d71cb5960a038b4394997ab8a18de89c8773897971a9618b2269f5598027c8fd09add5e91f5c3ac91aec5628b3e3f11bbd6cb60f65e3b0d84f06702eca610225230ac94d197da4737137ca6bda4a8fc21883fa9270b8fff8119bfc530a32a67ada375ef01d8cc36ec4bc6c79f18c9d537c979f6b9c72e4c99681d88abfa53fbfb7295b12b1c1886c6cb8c27c5e149fb533cd0a547a2f4deefcf62406046b331dabcff48ba0c8e0207b812752e695b67095f717dd7bc0e14f2857dff00735179f35eda54443bdd1c5575e830e4f325d3433ebabea98cff796a64e40e65b45b3b7217dddb9076669986ba0e776d239bd529a94803246825fb2a3b484760be4beb7cba3937e527fab59ded84c8760fbd541a4f6e7c2bb141c58eefe06a887d01859fa71f2b7ac3411cf623897edb149f01b577205798b27517d0c82bc7161f5933847fae59e42217441136cb58c2aa0761d56fac68987b94add5fef9d41d4e86f54177b9500b27170fd5d8926fa8b11f72ae213bafcf8078b775ac33e7620043c92239f7dc0280163d401db7302786af0496ac7b22d26cf360fc395dbe6b51b333a91162253d38b299c1aa13322c3310f23ace21c4b29a50dab097e735a2e2215779a0a13439b50b4ad3d16fa0d9770aa86642ebad916695917acfd140d184023dbc62d51ad35bc4965a64b362b656ca3e48f7982317400e561aa226331902a2ad8b36af1c281f715a472ae5814a9bc46d43a9c54fcfddc175d0bd47b6aadc275476d733f4937734150ef47c9197b667090e2d329bbbe04c921717ad451ba4720e555b3841ce5ca52d3f40a24bbf2e7ff76651b87427596398abd7656f23fa66ed19f6507a63f99119853c0e931595d9c888360fa374b04ecb6c618014ee0add21055d2cb6cbf177991506454e72b2ae4eceeb88b97db7eba881b089bda0038bb09f0f31f818fa38ab4310746faeecf666cecf82c32894aa428d85089fe4489910a8407000fcc81f979da8259bccfdc32f6834d5c2a25f946808a86b698d87722c175c9f0d5107dba5e7897f436171c551d41bc6078e5c1ddc026af90768a2039c3c36002a457367b633f41dba16c72619683aac167ab71eeda0be888dfb6346008df3a4de12643e68e36592cece70f01bc5fcedc179aad800618f72b0b022b966d135a60071073626914d3df3af4e18c0d0f2bc8fbfc81d940cd39dfa6e2dc3f3180d8c6227ed6ac7f2b2ad761026feeabf0faff5c7e773ac585a48951fc5acc78a0a10054d46046e266cf506b0b865cdc19a9bad3ada8109ab8c3f4214a024ccb63a40853dc3f2fa856aa1718e36b0c8b763c1fd3d69155054ef17d1e191cb496d6ffc8e98442d3694cff175b5a709bc479d6041d2795a0120430c4c5d292a7a95aecab73f0e85bc3874c1bd93115c83b5e275449256d8d0fe35e5b87978564b86f63ce63d3f7d5d672f04c6ddc300dc6f6f99d447707a910c2b63148a9c4e5db0bc837bf22a9b9c9eeaad1a711b7d4df0e39fcccf8810b6cdbc340e1a5805e0e8411e09f12d46d43b04b2c48301143235b10ddf62144233e714d579e91b6f5b2043b3cb264a64ff2ab1f62c770300fd5f90aeaa9bd6efae481dd45c0b1220e0a9af97eba06c9a10893efd1cfe7c3765b8351d720f01b6d848cda7bfb36c476bfc8fab90b010a87b95fa178bf583c21c0aa69896c8d295c8265652ffab73b975db62d9210b5e5d5bef1ceee28d887af316e19aaf0bf87e50b1b6d7ed77b8e0ad4e1d847c66b8923d5bae3c2533eafc980d74f77e3fe45108ee9aa93a3941822f76b7e693f3429de3e7b93f3b969bfb6a44c3551d254d8273e4078bee4c9b77900f0d0a62112c3af3f0ebc368851a8ee3770c54e1bf64e3791d5b0981153791d0aec3adf257ca9aba246046925e8fba0f79194ea72277ab2c4cb12ca186254c096b9bab5982a6ffa32dbc9faa4cdb6de45afa2ab6074346054e5ceb4d97dbb2a071615aadd350ed14163306f52d27cf0a9035e88bf354d0686c93a5ba9ac0e57263ba0f5e88464812563630a2c49f3654c2937a43f68cd2ce058d71ad06e38a99e872930c48b5f5bb6685d9c652a23967cc968f2e5d2908bae111d6d0b89ff4d81b7b70f0f5a71e7d237c6ede4050d9c2cddd43a877d6d5a7e84c0ba0a9fd715c1ac2b6c79f928bcda06bab4c3c5d855717d19f8517763c9a4d86072f39d3a0eb8c7010e491c08d232cb8b1fd1404b9006443f8842ed8e5bb760d2ffddf6d4b3a1cfb5b5d71bf0c1c495d4f3119d6b53c93ba333af90d6bc123f77f556a90ed71c6b8b371347c0cb7eff61f8398282383b61fe9fc04d90ef541a58b5de1dbb33ae28bd7dfd80ffdbcfa5d5e0341cddcc04b3ac5fee51965ce0e1ee2b6ad0f94b3e1754c12a2fab082eb7073aa1edfd476dd2956f8c6286655ea2d5bae2ca914d9aee295046788526938f7ee651722547e53359a03b832596386acb45a3ef51a8f0c7d7c48cd27c29fc648d92cc915cd37ddf9f1973ec21771e3ec170fd134083556693ab50e206fcea03ec27cde16ab26bc1b5600152ad51821de181b5eaa06d410f3d2d76a8885ae19bd9b0c2b862e68b8acc8d8379a9e81d17c10685be228011f31f80f8002609ec9b1c4b4d10ad4ad9208aa5ee206149686d345098fcb4a18425278c6371926b169f71c3c537bf70f89fc45e0935075b24cb6c140e8fd6ca3f2689665a47bd1ff1683b32b656e439aee98df6ef5776c1d3875d0b7e0765f149f92b07120773bd13f2857a5dbfc42e66c6f01691b7eafc3cfc92256f9936be8fcf43e0d5294e469584aedc2c119540ac95013f3234b06debe6ef11dde4084d613feece7f2c912293e842e64c2b1773b58e248de9d6fe07aee00223bb908efef30ccc3104eec3c0aea0e9e816efd6e9d490ab4622987f1119e1e5486bb5a5d3dd82dbd0e85d2e0f8d3665ca99d24cf606842dfa1d76333703d3d9c0471701e09c5a15a8c57a8a0f579704701843d00f674939a46edbb6a7073910501c31ce210f358e94c9a087b63a80124089d78311bb3b46d07b551ba304e2545baa0e2273faa21e5a3528f921e8fa15341653a5b5e63f044a019bd11e9dad89f125f7365986bdd375df53caf115eaf5bea077eb0874656d9590e25db1ba6026ebb7e7c42cbf4eaab7b18f1139faa5515a37a8db7b12173b0e0a89d0f6058a2e95fcddfe75158a56ac27ffdc0dd5a8a0e6a35b414b13dba04128083d046e764ffa84f2fe5ddc541a76d55b9237674beb29df5e3134eca36ecff53ca94da83518c15443abc6cc1eecd1df23fcdc74912ea198e742cbb7b0fce151fe2e97a9ae7dc265ae5df1814a70ac80185e5c4606bd88b276e859b4fd82166f034a272ec41cf0245cd89bfc2587d8830c2ba92ba92e78c38a12d8c444be81571a8c753589ecddf01951222073712fcd0236a4f3e9b12e96228673ed8d045765ae31fe81855247a0849d843680cda0d19c78e473b5cf34aa0f9119d94f2b9ac89e50b8190acb33fa02ca2369d0ee7e1ad9c84f0492f4c8b11806a35620e12e04659be9c99597f33d90a5ac4b5452a2c52118b404cc502411ecaa95d7f45c8a708bf2b79f49250998560ceb4e3231d504ab154b53b2e18566e281e9f1f28446b9733ee66f6d1d38b019fb304c1f74569c214eb3d8e2b599fe9099e3dfd0eed75d6d4b9f5004525f1e71b5930047892967a92273faa6bec25b2c4ce3ffc55bb2311ca20e1d71f876efd288808bc4de56d32b318b2860c085b5ba18f2530b9239dc2e96ccf52ae408226ef611f0aa033762f607f7510434d47616800101ecb5f6596505d0bc81b3bc2ed54d1d979db16028a93e3c6caa2b3ebcc08f05d36584ac79e780ad9872201e79780228cef840d850754e51f2268c22da830486b859110f5febda68748ce797e2f04553438a49ad97abc3365fb82dcdd7e52ed3414ceb1502ac520380e4f6b9381ab1d38bd97149cf9aa296b5c3b512ed6a03c725b6c619aeafd83daf1ad745c0fd05ba9f00af515ebe199ff8a03b620ba800debde41231835e25bc376e8028b38c54a95a147721bc3cdb16b2770a755425d57e886a1a89f5e89bd215e20d7dbd2a0c96fc1ca895f9b5b75a712b12bd9e10ef7aa91f91cb4a7e33ce867100f08008c4d0aa9e25133462548d4558d972f4bf5f2d64b2b1fa1fd3e0728f54045f0f4ec46eebb16e73258016c3435f02ac1504bd20a5c74c90e4f739c277546a5d73159a992cacaec794139e5d0483b533f24aeacf78ab6b165b7f4ed94830c7592935406e3d580ab1dff3691b261482f63392f3e8929168e21df5edd951116b7da2daa6dbd3be2b63792a7f99caad88b3b3296474c7659e1515a4d660a60fa302c2f4a35f047f4e4465a12d261482004d0046c366912c128902ad86ff9ec6f6aa626e9698cdb64e84bf214ccdafb66982dc62206d90f3b7d3fa6ca98d54f9d332cf3846618f7b7cf233a2857746d1fe16bf75d9380452352de2335beb28475a1c4826cb938ee235d084e591cf0c34376752f0042a55794389f64abdfa3bf038ef8394849f7199895c0769736135aa6c38f59229fb8cd512ea484b942cf6a9d01728e76bd5c50e645b25a314117b04f61d3a0f2efcd73d529238c4eaf883830be455d24bad7a2a09e9dc91de969ac54827677aaa7d09b5bb710132f20152da9cb81875a64d6496dc803f99222ad3def3aaf98f054917ba48e12c449c6c965e9b7df843544fbb96ba3cf2b171e26d7c85ea1cc407659c2870861b74a62fc627a76d6dc3250d9b7263f8aee73aa22fe2adfb3326cef156a90fff80eb11b71cd90de7631212cf856cbb32c3274b8ee85731db5613479aa7b2e2c9e2ba413f19d69e9abc44bcc7dd4ae13c915f082fe8257bcecfb8a2f41419a9b91f6039b8ff862178cb8d592a6a705d850eeb815984a1e3409c66612eca2f5f23e59cb5d656ad9f04d93a4296d884eb934353b0e79549fb19f1b1e98b147929e2379d193668c8f55aa37db7b439ada098cf5c7e18f9f26c22b367d096e6e6d53dee6d6a13c4895bf3da06a82c80547047626675291105496dfd4e3c5155ab14bb35c3d236be59d672a2707dff058451174317275d42c6cbe39fbb0f681d99cade0d0f6916eeebc72f13793cf904cc86e2cb5dae2a74b8f0019af0c1281a141ff8c7e7311aade30acdbb0c821d1dbcca53e8bde1c39605658aa55212f3cf9127178cbe982e9b884f491b2127e2d5eb62829bef107918fcaa78ab6afff9e2a95270d8e5d87f1c8baa24255f959714935b9d7acd67c26f9b80c04bb8ab6a9db6f48efbe7104ed5d887cac59d1696a6b26d8c2f9350e09430db7957541a7b6f0598e3972dfa4634817342552ca9a6bacc51fbf66b6f1585020af15563ed756997f26c25f47eb7e6a96a4626ed22a5662d815a23511176c30ed2b201589093c271a3747094a8345f93a641fe3fad8820c3a7fe9a38282ad3d59414c9057854547e199b1719a01055ad136795bce3d6468748ae55932ec8bd37d4e84f83621b1cfc45b80f25bb0d45bbe60217bd1f059876569be21b8c209060a508ebdcc0f9bd7ffc68202acf46ed080267a5b8ba72b819c4fce2f4556adcc4e41a2797b4fbfe83227b63ef4431d0ae1c56d36d5176b19d4b3a8c178443362e3d8a41014bc4478a10cdca67a6f2b6e6dd9d2bdd516f6d7cf1e22712f65fb8d753ebac57e0f528cbc69e98d8a00029705ea4a9135eec3eb503759316e1137e9aab2c8fb6d4b5d376d7c5e54fb527f804c2093ec54dbe56959754c158811f292a11ca44dcfc959d8528af1b6b11a2b7ddda224eb7d83e4e10c82b36bd28436061a2e5dabb78518118ef9b7c6d4add3e4609fe31fb3329a3a836568dd7042c4b9ec29894dfd9159d69861199a6f4ea2642c9d7b5f82b2234e890e7f238363b162f8e07689bc384b24c0406dc28515d4f41a0609a488574c6681c53a70e138274ce9ec1810f6f35a83fadedffcf8b7e5de45cfa155fae95806c8bb88210af0f193033c3befabc40080baa6f9397436636d1da1e4e060cbe6f069c606dbf02553f9d0bfa305dbf4d80f2a0327b41576e8597bc76e2a86a3f03d34302e6f34bf622a18d89a0eae4a7637514e46e4c30ed3ba5cdc2616c5e4b90406aff7cbc81d984c5002a064d3023269fa957783a06e9084bfe9ed11b9c8ace6773e6588cf5a22a5ff6e6133725f6e4e7b75d7927d4ace6d02b5229e2943d5a741d2cb1b97b1a5c6a2e31a846553cdba4c4baa4affac48f9a2652d7d4de9d339d723f574cb52469778bb05db7b687ed08cc7b0226c8ee025ca8df3b4e34df3dadd1cf291c551521a7e782fbe42ec220b579bded1a61f3025e2c222918147ec11b4f5b9f3f7a2059b7dc9c029efaa31ed9b2de9532c33b96d2db776b664c81ebb4f0e141ca799a6b1fd1d12446de2eb6e313017e4bdc288b3900423da1faf24bd285e82ddbb186b33cdca0c8c847f159c343ac00f5efdfedd4ad52cfffc91c55231ecc95fb3faf138f5344885bcc4f9eb63e63c635c548922d9844c7f27a02e10561c53fcdb420700513aab310acb6beacfafc50a256708fa74272bc5efd2cab6e47e103091f6e325ad2eacc3945601836079c71c3fe5fc026fff5bca6a717d461faa251cd0793c87f198f099aa150af040b33d1cc5abe45c36c18c78654785ffbd7f8a83c3aa2221da670d5688741a7fc409e6ba35d3cff8d68d751be712ab507e1ac206c70b1351a544f4e24b87dcbd4567c10344de61765a2bbc48a49bc222c117fe1a13f9b7b3cdb40c73347150a474f1be319a4ed78d84707fcf1107d559f63a6aae3dd4170d3f3fa475a3268f5d04900dc941166501e7764c9dc8471e471868b4bd59af61675b49709f9a5bf430452cb45d011bd93176c9e700120c4c6667e2e2be7258b72ca3adcfa2197914e67987a4079d8687864999c2a9e331dd75bbdcec2d4fb5a0c6cf1393f7a9d1594e5b65a3ea58768fa881fcba4036dce57426d1b2073954c73ce04bbacec360536d0e2438908edb4582154587eef91e46ba7f16765cf3163b73ed9ca4d2cdfbc7c6e2e1ebb7c3fae95264b33ccb67d019bcce11e469d55fbedee9353e106a5764e1e3c0945d796e8f84294839840a9575250fdf38ff55935af1209fa5a872702bd0405eee90f18768d369e665dd0c73f6266dd239b64a462990ba1595ee82431784e95b341b70ff3a34b721b8ea042a87da06466de486283cda50602c956052b5700e0c936bd74254ddbb9690d4d9d0dbd462f175c81e1037064b0a029840bfdd4570c4089878df6e1e13ffdb40d0dc21c40867d2f6ce0f12bde9630400915088dbbde254d58b1ea7ba360a3d0c0cc09fd8a960b04356fd3aa29aa4286981460c43b1f8a6a0460007b6019d4a0c5f7f8a145efe29e733c22205ad871a500b0ccdfa21f021cfa290d031aaab4dba6f50eb34688ea521a672fc20bb7ddfbfeabdde815c348739722447a66fbcd2795c042bd45d3488ab42fdd470022171be20f710d45a92dd1d0d68e0b563a05a3b19092b093992243f5222d6fcb60424cfc2a1c212c5fbf6f2702c727675c015e28b6306063a8158e95971a798fa55208e6e5231a63b755d7ef7bacff8a7d0cdd1aac1606a28d041283999aaac9f62a7f90091491feabe36be816a80b3a4aac995aae1ebc5fe76e885e9ce3cd2ed6201228669045006cc2dd1f6d098598e7a07ef35bc304c807c03e4a8f50ae9736d5d8c603ae985776f9b52bd272eeaa0bb66e86304c42aaefb395082c4c9efd92981cf7c6fd1072e4e1cfaee593899a37d6bc73de7c3d92e130836a9bb2f2863897dc053375d75b46e5da2f8028db09461cb2d5d3d4a2700fba120ec90084a315db4c25348d3c70b202da3ff46e3179bf330b4b740b81d324eedf6c007a3039a0c8515f1b42309aeab6a6f0dded1abba6347991d1bcceaeaf5a9c3aad2558e0a41c0758361bca24b9de6a9bfa6ee978af4b20f0ec29e1b4a94b8e135928613011993ce0ac03c41be72c27f7c28934c710ec1972cb86f73ea4240f7b4084341c0b7ff2578e89fb3b6ed72e7fc1f558ca65fcf0f0e68fafc5583f0d2a19bfbe5ee7ace1e0380bf273c831a929df21f26a4e6c27efc5078de99f4189ade34370f7d0b6f260847650f47e04126e203b671ac2e4b142c44c7a0b115b1a55e298bfb63399c5545b805dd05a94ba9b8ce25da746d1778f566e4275cce068710faba5da3bb42c72aba6892ed9754480394f40227dd4d79152081412324cb1e2ac811ebbfc97ae1ad8e1e608c57b275eb57ebed1b6d61f3906b206b786b746f7c6a5ad8610c9059e18a6a97d184a2f3349634b378441179227fe8ffbc9910f9ac46ad40ec30da04c6cb8adaf8758fc4ecdb49e2370a77481e7df0ba23e6903d15e0e9fa41904225a0e66ef36577a81390a2632db580b664eb1c83b90675ab18b99571a054ab9e18f93e01321605386e9df45c64a19370bfd60f9c2577be7bbc197f5d65572bb68cf1bdcdd81637c274bad40de4b7415f978fa50a94e90ba55e164606831a4a6f5644110b9930f7b5416b20b3ff973cfb88f2b5adb37031bca8d0d67eac3947efb29b0e73568581c4ff564417613af8145bb2278aa7bdaacf7ada1e779f7833ea1778e7d8128063230fbf71a527526ba91bc84da48f02767cfcaf966b5b02ce942e92103f6e59a2e646a85806698ac9300068b4f4f32ab8cd5bd595f441bd00aecee59cb8cfaf19c2acb9e1e88290930ebf594223a8d36d8a5af4a264f06ae0fe12f2a8562f93afb155238cd55ad4a861ee1b5f4e97398fc6b66463b02517c0918bddea03a2f32138d962a59aa34f8f65aed09e421890b0e6ae40daa1167af7ebc13d477fab2b8834d99c4ee2c2115dcd4bbdb650a386f697656c5ec2ecda5a6acef3c912c062ed2e61a28f9c2f92857b4e3e4eeafdcca337a522f6394bd0806faeddf497e452d043b426a47154fbdf3983c33e4817cdd9af465a1057fd4f3b66cfff63743e98f740393b2ad17b003510ef97c56d50ebc9574f48b73b1ccb5c8feaa9adff115d8504b34d22579ae95e91d91edb86155c0022066afdeef4b3c0b5e2063afa17c64eef1860da833f3803cbd7cb51bc3444aa633a6589d82bf7c4a6f1a29c892cb0ff12a0c12920063110f5abee671fafc15bc7af13e5fb7486c76c79110c6a7ae1d0ffd9b5277df520b3b553d6811eb512883d5f4dc195fb95874303f479ce45f9718c5eb43a393cc478183f009ebdde3936abc3b5fc250a0b45e2aee2098f4c779cab264336b24e3e424acd803f0fdc7984bb7ee81d4e265a8c8689f7bcba62e57e0494ab2aa5c177ca70dcb69b9dbc0e06be5e1f7767278fa324f7b95716b7b4ec9e030cf6a4bcc10dbd70b5ecdeb06dad876f334c7e28820407a94be5cda057a5f23c497c1c4cba8a2adb80ccd06a1720b31bab57717d78b5d387a901e2df6370392dd9c6cdedac0262a03ba6de64cb6a9ef831e757a8e82880c9b9567c135ee8500eb7286735e0ff7593b6d5eadf710aa1ea4cbb77832188d2c778a0e9aef2b6215a568fca40f478f3baa02235fc637123f12adc0021b179e04a3a24adca04ad9cd15ee1653c0cbf8453cae7c63aefa09675887810e01ed6cb0997bef53b9f0b0f8ee657ca72f8bcfdffb382f069e8000c2d1f399149becf8855fa7e4eccb1775b8305b938cee6bc4e65b83d1f734b0300c39bae39149762588f4f8a53a4f78550520550e305404d42a5216dfcc0cc7e716875d4287d3d9c6f596fc54f2ed7cef2c8dc3b887828bccf141cd6f7c91618f4721f68afb32033ebad545c76f671f984c6abd51c97a366a72b6e2d1e46975a21858b322767144ebf9727d082f005103d8b18b5eef4173455bede9c14270006397359ea38594ceb88a1659fa5382d078189d3a643915b40a4c317f23bd3a6e5ce59b7770399aabbd76d0e61723ce8f20a72aabe4aaaebcf75a04b9ecdb33f67cb8b3cba1a8854b827d6bd6e488fa0a53f6f4ded08a99a3668d1aa46d084374d6daaa941f6a7bf6bf918faa3c91053344c85878dfe396f9426224543c16057ee5a8c2060c1ceeb58c59b4fb88ef14ced1b4eba85b0512c9a1496953d5b894b69393ae5fdde0da86c5afe336e178466fb8a742088e03a55f5927327b6f05e3a208a242d3a5db15e730224c8239a71068f45f080dd634ad1362d6037f99fb9f80c2ef71ef11b6a60f4475a3b1111a33559ef16322e8b2ef77fda1a9b4f6fab2e15e259d11971e356ead1e5974881337292543af9369de4daf1dc90fe3d745430ef10931c72445852fc7c8982752f87fd661927dc850da89d24a02ee217c85506fc2ee94336d5e04eddcd11cf6d5d4ebfaa2eef18a050d1b9a50f641147d45db83df3f69d5812465cfbfcdd02f9fd3032f79b965523aa312be52c1990749779d22e2f9154513544cb87c01440364c9bcdabe2c5fccdc0b10be82732ec294ed520a002da9c61b2e0d4528e8eb021eacc7b110d2d71d497745039691ce095ee19102838305c91df875bc9cb2362014167239ae0bd396205f8c8e4795982d6f6d330f76b260ac687bac39b6c06d0641c416fa838b44d2c1fe89a4a469851c53144c788109126a07841aa6112968ff33191e3ef3d8467c65d4e329a0f0c2d25038b4a8a5eab0f715646a5493390dcc659c8e80c5cfa138502284a16c7ede2754a12025c349837f3b71934e02eda61afe752ded9b1fa1635f71eefe685abf47a1fcca1da4313cc8f083f6a8d577048531f42e9415cc3aa7730ba4be00437160cf59aa5c8a3f0a660b788a6ce9c06c40b30b7733d9ae859ee18098f6bbe8be4ecead3b921a25f68ebfb018ea30e160e930cf69b7a9ef7f011e23b650e06f9c53aa4eda42dc2891aceb918988a4a92e1572fa4bd5ae912513508b722170ef611c587aa8d66ba3f3040a044160991b5393806c336125e6d64b5213730c09f5d5a712d0078eea820b1596f68a3569ecac8831a68741bd160f7aee5941e91f0308d2bbd4a15c2ec83a760cd817a4d1097fce824d1222059c6ad3cfc20fda5b0cfb903f7000edb1094669ed20898db90f433f83ad9f4866c9fdafbaf58dc65efa1f2c316eb64e4bf0926053c60d1d1cd14bdbe7332f2d5d40fbe9165ccdac1d29a0f8b8ff17113ebbb623c0c80ef2b0d637ef02f2b3b7cd78aa1bbfa6357a07e97764703783cc53ba5466bca6eb4389d933a68d1f65458c3eae355448895e9dff605af98e385c44d34cecc6e6c61042470db297959ed776309b270af7f9cacb248d48f560c34add013a95d99162a99bc414f3fb52510ec442de94ff2f4d8f478530547f6ef23206d040e97bb40c2c3fa6d049ecf803d07f3df3cfb7af10c76e41dc83745b6017f6e32d01f4e09bc03a787ffc814d63c1873beb953bfbde88b1efa8eaa3308cf2ab6fe4e3a7ab7ba745796a5ac3bb62eebb2d4344bad9b3895215311e78d9810103bd1cb32a2dc96d2d1b08873ad1ec4682550a8342d4502664b25b81caa6128b89ac7241c2847fd8e584ee960cc023d12dcc589d4ebdb18442b5f62d58cb9d25972cc4eb6a50b458951096687bde31b354fd15026e2491bf6f832187bfe068bdfdc4dfcf8037e41aa0cdebe2df27aa76a2280fa74ae3fc4da37587be046188dd160c83ba3e624f0324fdb38375b778273ee05d48a694fa1812576ad65a2f58fddc34a96634ff65299098bc67c35163306e8e1ebeb0163cf170eb7cea550d84d4367c29e8aebd44a402c7df360adb1917beeb76e2450ce456f7648dc9ba24a0f798baa55bcf5341badf6ad69de1e0d6798c8aecc1365d5ac5b4ebff29d77f513fa8d7c835b5f986c5a593da3f1b0c90f0914c0b10bfb530f5de1e1903ad9006bc9552d5cbb2ecc25f59091a4a14b4b6b3a3e95b1aad0317c65b8c18d542a93f3883bb83effbefe0a605c6f812da4c882aaf6eaab38ff9dfc2ad3a23ea1984678b5d3931b89fc5d7acb479236fe9eeeec2adb99cd1729095719621fed922bc3b3f40055ed3e7b88564f40572a6dbdaf1b41aff98d650819de135ad98da8751c549a4ed7bf668159d9d74009a3207f0b5934647fcc163cced292b3f67a74b28e1dd51d20c4c29aea0e18a35b1b1f5370ecebeeda0c0ee3551c93dac8d090b8958944b2a11f64256f043712380b6935a9c80e120b5d7edc2bb1a64bdd94a269f896faf7ec6ff5168e576e57ba4602a26813ba063e1a3563eaf4f8fad8d1d37fc9f7bd8edb558ce41ffb765a583e6850e9d9d6610bf663abaafa281aefac2fe125d0de2a812b32bc11f65a93c0d7b27a760e713d09edc2606c8b31764eb7ae7ba70e10b74685f3acfd74c1b8e4d39042c2de7f8249f94983c1e41da68de85cbb1619e642b9a7fcdd2c30b0c1dd0ff1dfb44e1d5e012c52e3698ad61c61044f316067b8e3b302b1c38f8080b20d26536154c55e6aa37d695139007117f583b23ee8b0b6825f75eacf27de354024534f7a258c3227f3c1dcbb69881f208cf0d22a01177e1ffedd1d7f6de628ee2a00c2f6b93d2022f98817147528f0bc94bab557ace974cf3840924bcc23c131287272c5e687b34dcaf066cb04e1853a0ae47f62acbc704be2b47b8c29a41f8993455d20e4717ef7fcd73d8200673905bfadfdc452a5c6132302935085fc280b1c4a9c431f377c3636694d18cdb19ce413f5822c3001184b4ec1813955a412f49437fde2065680ca8b1ca1529314cb78a557c9b81bee7babe46e075f007c0c9838fb7425a3a396dc18eeecbf48c0d2ce2676dbdbe263adb5e7d0015a7fd3ba2370e687b01b63a1ef6bbb2252acd3493ea4d469d9ed80332b547a471ccea2c346f2c597f5b514621e35c0a8cd06c7df6b7b6008daa67a4637a43471472a315b0e9b103f652dcb9daf7d048572cd8ccc05123e54e4e049cdb75b36cf5353d7a5e98e3f5bdf52d86f5f6d9f5d149d11d0b36b10ff85ab4043b048eff85af3bcddb2376ca8cf56433eb7812906a78e4c3c0d4b4d361821bca8a99db350504cd250f65501b7b29b8fc0268b4b785caecf88712240879ded3e1d4396511f35716d165eb1d1a720ad7651d85af7b5796a8e647c8d086d16a56062efeb2d7775290104e79b1b8bb37daeb2be40fc387f95d9e59427368a38773b627975a1b8aa373972386378b69f3c3b3c66cb40c2b518fb0edc184c7be785b7b18c39d3076793599c0bb38cee1a29058ec5855ffc5c2bf56f4fae91312e636b7a6d958272b0b147bae776c3aa550d73a9ab9da83a7b14761e2956d41165d4f7e884441a45a11b37a814e5b904b29faf395f20264e24b395b01af0a5bd3cdc73c79ff73330a49c8db4285d105c802e7ce723a59a794ff5496955807453709e52afc1d54eeadf3d76eed9821ff41cf6768981d7c28f8000e110916dfb7274be6d1a043b98e45560183e8b536be312b03d9d1fcb31cedc49e687661fdbd0fae6d23252c6e493e39db941d3e77f1fbd36c0ab788d9874c872d496324483ea8b378e5fe24ff090d6a604cbd4b774cfa2b861a144b8cd655c9000e36427a5d62bde8748c8ed8e98d3bec9b08267b94bab7eeed4c1fb918f8ccc383f60f4ec029959b206b5fb5fc36ff46127bcdc9ca40a324549db470968c17dbfe35d377f82be6139f37a05dcc1592c2b18373cf5e443c355f000f0eb9d5f5c8378f4b70a6f1c2b1604befb41d60cf66de91ff0f92b375fdd07b05ad82baf7a19f0a280f1a5d1b7bc0dffe18d919172e359c8be9774363fabf86c4f00d446e911ed88df57b114b74555e131030f3d0515e6fe6263b76c1a9d5444b1ad0d7f26d6e3b95c8c95c8d88e68b87475a0be4a62c031362934c6d7ac859ed6e9786de5d833cca3b2ffe8102c3a947e283b53e0a9cccc83694cae94cf32ad3ee7f8dd18bb4a9afeb8509ac94819f5617c7b651dd8083f0444093db832c7f765b58d32eeb963d380806b8f5f167bd49204bb59092fa1a29038a218da43e8f288e31429d0cbc464dcf712d2af6fcadc977e2b9f749fbbb4761ac906d87a4c38c1e125a8802c7034bd74518795e87bb1568c2b6817d7669cf3a05798e186b8e1a59083f9f5589028229b89af7117ba47de92dffafbd08967d99db2126a85a0a9d8514d254091a35b82c90191dfa16d8e8d02d7d087e2a5bbec7bb2b0ecbc94ab47da51960b0181ca45f2165456bb51a4f4eb03b93f13f32373353e245cbbb915493a15b3c918e5974e3f22f311d913f40bba98c5ef717083c1ff6976ea82cf444c735d0a9da1f3c48d6dded85b300dc5cb910acfb16ac43592739c84da8ac4e9f4fe5c128e87e56b47dac0548d66a96d8a0cf41fe8c33e1cd9148424d77adce566e934483965303424184b667da74f9003f058e8067db120a72e746fdd822bfac97816a42a808caee74a43132fa2d82b0e42e5c9fb2b5f0379b40598ee858b9b8e87b03373a31f5a8f34330dd1d39f6d9c41513fbb4b1a1ae62f37c57e921d5e6edad7ff347784fd58997bc003437ed02a399583b3caf0f7e3206bf52a7bdf576b9d9844e404ce8cf2f4bfc181af4dec4d1b2c986f9fea8eaeba8329c671cdbfc49eb21e3a9b8f56014f889041518f64d8145380beee1e9e719f1fdf8685f31de40225291d71f654b77615288d95f5dde5da0b979e7d968a2f3f9ad4df4b872d9e84baefbacc670c35382f9cd249dbb4d7ec091870cdde8f82e12cd23fd0d127d8cc7bf0973649cf2dab582dfe4011984a2b4b06d79be84fda2e1a02b52fb0eac1c4f6665bc28cf74be84562ef1777600c2b90869ec5d5f76bab009b45d20c61f27be26ff59e9ddd94ae1c70e5307f653eaea7c3c8270645eb63bb73676d18ae11c51068a5f6abc2652dce9371e8d91a26d9e89aa82f48d65c0bb4acbbe9359d2e816cbfc37f2b854e61cde45d944032761ca10fe3ca2d26ccd0f89b19704bd25d68e1712ca9b99d0e3a4c33976e6b1b06b0ae683f4eb590a502f73c99e0ed1e2c6acdcc9ac182ffa4bac14f6da5a281ee420cf0cdd5ed20abb50f61b408e2a65babd0ae66bd5f4a66f9d91c5f948dfe73f0daf6d2777cfebd36de850d6c74bdda3e63e70dcb1a29ee97bced179fde495d1117bff1d39e45fd50f31365b5138ce9037683081bf281d694017acef6e3e45d7426a205121c8cc618d5140a851ad8f1f8d0438ffb769554cf3a6c8a560b229d97889b1d33d34ce4524fb0447377dcd45baa259a21d2dea0a901cfff4e50d0658c07e9687824eb30a9904bbd148900667b4ccabf1372e7670fbaf0c2dc8d7b7cba0d03a7aaa69fd5846dcc4e3b0150fbbbb5909545ee103a796e8100d91d6a8f1d47608513898e42ac686219ae7828f04ba6d92c442859411397e0ecc3bc35b6b4ed3f3c56711d1ce9e55f8a39b19819751182a972e5a9cf69a9c6eb1ce00e7ac9e73ef3322afe4b99dc413e37cceb6af569bf64c636584fa7af87e3d5f37743b1f24753348dc702aca57619c8a955117addde47811fb2a6a0805ece1423fc03b73ef0347e222799a19e77338c74a491dc47421b497655d555c1f4d4a6edf9d503c9e9a970a2a3d025080ff9373a8eadb2afca0a2fb6462790bb59a34458070c91c2c3ec1a15ba8eab5ea61e033fe54cff6279a07cfed72fb1a42aed95c1ab42061707aaf209ade4f8ee31514c0a6fbbbf61b08eaf28239f3e181c9e5f25675caeae9d9891967b553765d3eeb018c25e5eb162bc9eac159c5a15510011b0ed65236376eb0399b38c018682378c2636f93436e05e1b13de54ddfb20ae8e40c8bcc96444dc8de58255adfe8ac4349b149eb0a2cdd7e4490e6dac6622414fd535f8f00a40fd8903270038cf8e9fd8e027513175ebf654f9fdaf6247b2ef489cdb046fdd25274f396beade38c8bbee5518cab9b4afa42b76c2f03be40ddb447cfee4fa36c37fcff73eb1cd51069d538ef7992a94ba032ea6fcda20e924799249c2069aa66e3e59aab8479c5b0fd2a46d6fbfc4f0809542d6189f4be1069e3df7e5eaff781fe1ad6634eb3ec6be43073e127dc591f506e5894b39d52ffa44c6d0558ed3a0837657275bdb3eb6e62621fdbe593e11cd4a4b17c89a4df2f3c0e1f5bcd3977c9bdea713b7e6006d7dc5496096e0135c1b93bdbb7c11ad66fd879d8bd15e6900dc7bacdceed6dabc05b580374d4d1c334656c050a039822940522cb9098bc3ad70e6aa0499f01346f10a808c97a2812c2034ad6096d8435a8b392809d558fdc664ebf5705da24056fca2adc819895e91303b6b9d60e33b9c9b69932aa5c164d65c96fbfe718077dce81c30b97b85c42c398648b186bcc00ea461fb4aa541e797fc3ebf6ba881056edcf314bde3c0b9f3539f1ccb3fc087a057f8e6c77f6065285073ba43c8dc469ed7282edf2d65ed4692003da11b0bbab60e2cd27248f919d4f60e9f5083d74fd82cc0fec5c0d7c7756ce81cc98652c8b01d3c7bcc682ff80c9210346c6e3c002be63129d84bf746cea85d902f3714232eb1983ccbbc480e17b9e2170fe7deef56861c17be3991e4f95cc4f7a121c7f409960cb1b3e5ff2f3e1b1872ce33e0644c51403a4cca139b07aef676f7023c870d7ba694973efec959f364e02d30dc962c06fade319ade660187d57f6e537022e591aede2e628234a6b8ea0a2d40572043888568304e96d4635c88a7d9e7c7b3064d8021acb4e10f21e2009bf66f348118718b528735555706368396c110a266e78305f9c3cbbf69eebd4cdacf2db045160fe90741045c76a3db80a4fa470a2e71ec23550355c2e141e965c67e874feedeebc433e90df4807cc58ca44932c1a1cf01342f7cf34c3d43ad9c7c30aa7323c50f9c88ea3a0c0152fa92c9d0134ea2d720b60fafcd963d6791153e7ba13156ebdfd5ebd3dd8ccc7b854a3dba0701d02a676b4dfcef29f33d3380f53228c32212738b74ff7296ab828c44190303db7e4f983652d13bf7677df4a8716f398a3ec97bbb67f8d0cead198a7b1b835ebcd7bdf48e3ba0291355cc7c87cfb15f14e5b6ebdc688b74c398cfb71379bac407513723bc0b2724da6176039b4bc0606fcfb6117b51ecd88763dc0d8c64d24f4788c71ba19c715ed8d8e5aa5d199ce79357152c924b003b5d8764f59275ba733e7775585905a0bff7a091d1845da85a2fbaa12738e565a9ae5a796b22838111e6b29633ed19f3024e44478254711050a47b4bddcd095a653f881c766e77af44a77ca80f0acf1659296f6e960e534f7f15abea56f514d96cf17d6c43c2106023f40b8f685c1e54093742288e31edacdcae75399b9ac7ce5521de773c0999af5fa86b66f4fb2db710484d801ca102831b9fddd0dedf6bd78f42a6a4ec18e80686b33c14f80f00a7ad74c365bb73254651ccfe4b9608c97871f72af1ed13c3b8ff8be86e8b113512d9187c52b4ea3b9c7ff42b64c0c720784144aadc4c87378d3f86ed5295fc242e1cc1b922fba84ddf5a6575c3c1146eaf66796e73f423bae6f395f852b692a4119b66e91ec2769f26807550d1630c01f1b7f7d6dff1c8718ae7b5ca955940996f59101350745cfac504dcf7f584ec28e9b176f67a6fbfb0831f38e10fb0746d8a9316042a2ccae7a405779cca2f7f86a7ac07aef08c5c3bab6c9f462f1cf161bc5815f4acff21470d236c7c7edd90b5ed25df62d2225721c1f9aac62115cbca924feab59a6f6d07abbb260fd98445e76d4a574f4290bf94116f60f1c9102c951003aa8bc149930afecc663b74fb15ffd1fa40b51bd2aad70aae39d0ed979f97d9d5a9bf0d3a0ccbf452077bb2d386c97533aebd342795af74058b598cc5e9da3dc992f1c435465f20ca2aca716183d4f819a438150b36844d1c31f307db08fc402c340a90e01cf23d9e43319e633e96e01cd7ba9ded70fec09846b31e753bf07d7bafad9aa7aeeacdaafdc06fa8f7548fa2db82180a89c90076f1650a69047aa6af54773a793c53a788369f99bd6f54fd5eab096ad2dc5de914e88f1869318cba7fc8fd6cba68feb0412b20bf9d73c29c488d8f36e320d10675dddfc78ec2fd311edc524bc0fee42edc395dcab031d8b6a5fd21853c63aa5facc80e9af0f617cf8fac644a1b024c71830bedc56f0381abc1a3957b3bbda4a30419716abd4adb8bce908e7ee6e665966a831a270da639d1f39b572b52ad519085339b578f72efcac9398e0ebb1319b19aeb52b2f1d922df38f631d5cec11a6e5107ecfc4998cab6c65687712e8bcf2c777013e72bc59439fc48b2a3b212d8d177855362dbd06b1d0e2ee79b7037300d470c044a8dd02c480d3a6f111ad3b7789ff3260e2cc0d7a991e153ca8f77f97ceb76461ec4b2870148db59ba3b69fbb160f8882d4126bdf784575d3983e6d8b249dc99107f3e755f815e754a228ed1bc8840e708b3ef9b96012e92c4d54cee4582aa6189267a3288a638f9c6731de46632ee3054fe6ec252d5868d5603bfd4eab99cf912d5e50a023c16d2d81c55715175270317501adb65b7d379072f8e6d072d74b5cb332594238504338cf1b7eb3bb2a28d9816b3b1da7fa65144214e822a50834443e600d36e284b9ea0d2dd92712600f3244642d030ddc9c8bff1bb933fb036796290ca206bea4987c293c89eaaa97174c4411341cfa463daca5206baee3d10b087b7ac2744f4b4e3da94b8b7e9fe249dfa2fa34b016edce88b8377493fc31e41bb096b0b98beac35bd39f0d3f174bc1a3048af21f749abe6e2cfacb361d176fef926df5dd8f438562e845d4d2a34e75be41934426aaac6c6e890518351229db998db2a105fcef36a2fa8cadf7dd5bd40c59c7e0d7c8938b66997ae8310d41c986ee3a1ed4e6da5c047386f6974f572e599640b3a3e256ceac0f7e047172eede76b3808c49dec270004a8c2f5ca41befc1f1f8c6d5570ee7ada2bac69c1ef22810bc22b7bbf5bb48ad58b7a02a4ef4a8dd6d52be5efb69d51e01db894b77c54d28b86192cc72adcd28eb680e474721ef65a190dbe19e288599e512251699119032c1a54c8045d401d0eac07d0460590073a85a994b92a1bcbe4c947851be34a17b51f7eed4194057018c29093b92424192703dd372293d5b377b1b0abd89c1431d37868d7d7b53566368cbc4f328fb8641b2297e8668fbe72e1263b1b838ffbdd3332308a3364694e95317b3fc26933199f1f3f0498eec6f21eaae54d3e0681c1f36c45accdaa3f9110840c9563b8f162f8fd1bc6151b5b416cd41b5c4c42b445a7b047e5007cc5814f6bd03b0be683b7c49e015334c10aba472e54b247dabd5b175a1d7f3f27354fe2dc98a5ba90b604f8ea2cb17414b49535166356f29fede2404fd3a93722096f54de3e6792d575916a378d1e896c7a53bf2172f2f1e6f5ef9659f79fe9caf541ada4e4543a5a23b08fa2c5721ac7a65fc744da3548dfd944e56af83640ccf2ac43292cca5d135557a016a711c656d7a5ddbdfc51576da28b7e77d18f3a7843d139cf900aaf9cbf8e95942522fa83f323d85adc0e4c1ec17050bfa068cd2a5b20f6f13394f57161885a6a811a250a194a0fe16f04ed44f7ab1273dfeb1d55e77d1993322d2623aae3b1bf405c97fd81101e3802fd7fbd0148acfffed0e62b0566a09ef548ff950faa38263acc0193f813122d3351d2274bb8e621ff73509ec5f8c75a3f9f311e5893bb594218ea9c26f7464fe01e4d1ef83286b20ec82a63c9d264bef7c2eaa7813cf620b2aa6de63be9da47157c9292ec82496a66139c71a1a7220355491e3ff20139eb1ca1c54b8905958a24ac09acef81d6dfd4e4544d73929321cd2d9c8628ab7d15271ff576b8bf2a788dda061a23f3c65923e3f6a155ee3e6100bcd11ffbf7fa51dad9bf7b962314823ac5e8330f27767770e963e4dddce3abfc9dc5225e529e12877b4abf4b82f82f2a8b8b335d4c7b2e34000ab4b4943439d93c66b99ba2e8aea0ae89d014d38d67be973f61d2ae5dbb0dc969aad05e6ae61bd5eb41459a450bf4ec8a6db780e70c68273fb8b9b8fb9dcdd3b5e672e5b44868ff95ac2bbcdde68cc67d20e003754e2753f2ed7e57a3f08362e0041cebce6cb7a24a4c41a21c688395d6f3c2e1cc75faccc318b5e50a5fc5ced8857655294b35ca13faf15cf9328907f6a9c4527f0d3049809e6456eba2171ce9998bf422906d4d5b20bae140e33b7dcff763d2924566f668159e94ef205e8e42b491b3a6d4ea520edd611e2bafbbaac97a8d0ac93051a3c7d0c96c188dbce20b47f9f3e185b2fc776fe35a097b29543fc24dc0b5382ad5cbb5a5b5f18f89ac467a8222d08c0ef6c4fea401f59f28743f46f0d62d37299663a509de520578a94de034198d55317477df2c4f7a1360192b224e1b6ecfe70dbe532776046169461da23c30354b12e7e82e2cae85c5e18d17b6ff1f88a5357a763f7ed4e85f7e8d18d7054b64eb7ca6f6a7cacfccf2f945f579394a4e8227c79ddc8f22a33e0038956a5899b000a51c2e4f2be7e0cd18321a065cb2f0320a8ff688535ff655b4a11815337f05a90cc7cf070cd0b174f6793cfce7f959e87d9564240c7f448173d29575d18b32bf5d194ed906347821ae8e9eb4c139abe94f04264bf8c02f76538566b7ac4139a2774a487e3e7ff3d87214098713da3f5076cff29fe8028b0bbc4deceb7f6593cdb48bad06f86cb0b4c7916e4633a3d4aa635bb8eabc7e0a035778ea1f223ff3f067d750f2ceb67610708a49d5b49a7bdb97e114fa98fb0fe0f62e5346061f4b964f9df3786cc6680b791bc18267b01af8fac11a98dc502f02c1595ce079b4e3af496b8c2de45f131410e4d12a7d0f56ff854a8b72496b690922e6df0451ad32b79631f9b0902ace4ecc1b09653a9f660ca4a7b6eebc00b68ec7a19ee475c1e5dfbf5d526cf3506e2e5e56097b3816cd45dba8a0b95bad6cf07a6538393385f4e44d385016d6a7defbce0c02ae5016dc90e56296c899f2620557b6a0f7f57e08364e2bedf1418a0f7e50e09471c5cd547bf921d1362f6c6ed6db64015b7f8d92a2ef19f326810d945391b92271cfbe1c855f4fdd56d42474d896325a1bb0946d3b8485b9101b94d7772e70272be809da0396a1a182e6672d706d027405e8cb0dedf5109a2ed155982b204239f7214c1cdd8bb8431dbd55f1fe70ac946484d3e89c1497b372ca46d1dfdbb5321b801e0ee23050a21df99886553f52c3f75ea631f4006009e3304685dbaa6f140a6a6f85c10432ff059218a9613e32c79b529070886ca4c9d6a749c9a36d720ad65b2c49417f082409ae4800f15cbede02a9f04c87c2bfc89ae1b298b2191c54db4b36229b5b0d551abd72435eb07dc72cca35309510455ddcf2357080e92abf964f73274ec0f2c71c5ac11a64da82edee89b42fdf97a4b2e13a41424f7e91d52dab60117c14b7b28d6e6e4b3924f54299d8d8526ab14ee12b15bd10ab863712b9096d82ebd3183b703bc1bda3ba6eb755e0711b562dab065573c48ad8f7d4398937411c76d0b575620c8da1c695a29547356fb225e8d48a6a5c4ff54a3f16fe3068784b5e39a67823a8f099562b0cd6f770ddeaea0eb07b2b02a8b157acefe829ecaeb893227201f0ed06bf210a30bc3dbda71a57104f1db8056d683801f8d5425c1d5a3f59868838fa6a267819403e662af5e29db9cec8092ac063c8725f241f87fc1d3c9a69ea5637e3f47688eb383a3347a4d2ea4d99056a8ba85421f23c3890e3e25ce11d87767d552949b127f778b93eee27db86629b246b2d5c8a19790dd1427912af27f2e27ce20ec937bb098d88a03521fbbe74b7d402a031781b03f0eda58608613a19b6792e579efec95c39ed583312e7599eb051574c68f48e370ca9275f88f616f019d85d318f1d31b42c6e1f8150b4c050e8ae4947d7343acadd2ff95a57664e2be7347b563fff706508ad6363fd805777bc01af5426c1589127c5cffb471cd72014a86dd34231b3019fbeaf25ffc9db68951e96a1905e37d67329d38de37134d37b2a14e048c2a633a7b0c5eb8a32978df59922950300ae757f1fd1889881e8b55f31c44a50bffc37f43d5fd213ccc33abe8825f48bf6a9910cbe0a9f8a306472688e1871f97adda55ded23d78f9bb57ac843d8d75ec3e93a965fcf5c3cedd98ba9f513dc4c967a924ac1c73fe5256069aa414dfc8d183bf667ada1f4fd28dd1cc9a2a0c2961ec6d96603a4c018244d2e636b513b7f1f18d0956a659287cc484579037d567bf87f09d835ae7f608b02a9d1981b9afae8561235b4b98451ef033e6ccd35adc6aa482eaefd808ce28876914a4b9cc2bd09717977fe31b210b4cac2c4d3d879c8deb0e5a54152cf268d1b58a1e7a00710486293ecc75279c1efd694245b73a1375f5dce3b69968c713142c4443823cc65aeb2af4df048260343e92779b7ccb78148aea68ed906506b9c6feabc5d0191dc768a6216aed9a32ad9c56196982a15f8171fcd0238dd56dadd78018c90d6823a1fd9a3db3946b47ef44d3a37e0a982e76d4c8dd5a9e34b486404c3f66c5054726f01ba31267703ae35ebacfdc050f2ed12cdd27e4b8c2819eaaf61a2a729575f545d586772653b1767a5ea23b47d6bf13c621cbe96bf47f962306009457d94892cc76cee18820141a0cee2685855c75e4cd1c63e4e7d338d0e117e39b2cc0dfe7b1470ae826230242f9f1bf582eccfa8df4561926550c96f4186b5e25966cdbbeac64d734babd54e9346110870800397c9d83b2527a994c6cde41d99171c1d648b56a7f03acde920c6cdb5399a679a3c49f4eb9dfb25567e71dca4f2eef3c36994d90c0a7f3e6b02bc2dc9d48a9c3629a96f11f9a35e06fd99d809ec17c2c5d295a6f4706451edacc9dfcdf04d2e9eed9c1f2f321ab956afa1340e00380832c548a018a198f0ecaf88489c76ee5f0b87f76af09681495f7c3496e6221e1de2edb5091616dca60edbc09147bdd5d78b52e1f94d738010b70f450f9ee3a657ffc616ca1f7a517151baac6ba00dcedeff5accc2313ab163dc411c816b0e5d84431efff0c58f52d3038556b499eaad20a0163563104b2e50f34e02ef7bda80af4c5713be240a9193881d8d87cd4b8f65a46e10aecec8f1101b9ec4adf7a829551bd3794b9969c4a1a86504efeae2fe43ddc59f0a1575bc6cf1d059c593e627bdbdc758d8b3ac1f2541e5da5e702688785b221955995817f4d4dbee07174ad8f2b98c31047dc9eb47dbca69ee2dd71c186873270a53a411e1157eeaa2c42bcb14c6d9d56aacbcca17f91523e35d88fca7738abd152f22e5006063004adf45bd78cafe45e20b778892ae18f384d34b66448794e63d68fb04513aa6222bafc4ce795255bf9a4bee596edc20e6e9cb613de5d9b023998e583b84ee32a2c97fcc263d7ee2b5ef13ee83fd74a8578d8e883e3dccd4f718185364280d26c0d5f7ae6e48adb5f56733f6b8334c02c47ef0b19236b2de5656d3cae02e50fd55b561d5663ddc169f4d07bea77691841cb42549cbe920c156c60cba096722e544be5f8a15207629bdcfa97f929dd6584b4fd2b068e31195625a61b1a5e125f9bb22b4ccc8b5d1aaf1d0f2cbbca124cbb3d931f06329e66c25f39edfa128ffca21f6149d007a50340998efb6c2e4ad32f09bcc87ff66cef968617c975af2e6625fc72ec196a330d4efca6d9d99a41272d0d82840785fed4b6a261d392a4329421c292a4085ba657be479372e3e5f2e587902d016967427e26eb6cf3ad60b83e5b40a69873b23b5cd8e8547000e465a4103725b9235a57ba92e524aaf525b444d9eecb9a20721466c7614737ba26f238241e1340e96ef336c71661d9ed30003e665365734d90ec811d8250c52e0b8a2b1d09e1df20ffbded374310b1ee2ebac8127659082b9211504c2faf148d18e965df9d5d63646e05a77a3f5bf1a404692fb06581095ef6a1132dbdaac19eaebfde4db19c1402bd7a53c75021b38de4a47a57cc70377f6f5ff17dd6a4983a043684d1a364e57eeadcc97f1d70f27eb53bdee2930c0e9aee9d8f5bf54f20cf75601bd8cd3a700f28be68a32dd9281dc90bb7709aa198b07d1930cc6b0c2ade237f2354fce0001edbcc3759fbc65f67e20efce4766d7936eabceb38fcadf07ee1220d38fd551bcb6f4a676b9333452c8c4f1a654dcbba953fa3efea012c54d672913e003cab0868fb9977c7c562f78ebfc2b0e0b376d4a811de799329fe4ea61b0370266e41c9fbae10e600e6816e86da3f8681a6966b4197cadbc7b927d8bf7d93e3ae4f3e6cc01972f7cb1b4fa55fe610613e8c82b8a394fff67e6b330386c7ffdd9b6f4d34a53bc21b83432ae4392ed51c4c4b732909161e8195d2a15575328c8e770cfe21cd675772a65e31dc8725b078a76d92cd1efa0eda4b568cf79ad1aa45cf0050740ef7552856944a92919efe9c8f551950844c7767c4b97e9b17b03d73b5bf417073caffc6d9c13d74f3500c45058272cf4d706d378934c9b7a03f8e663d617148ba9d810a1a9b3f541cb083ce53e38ea8851ab923061bcdf10017543300bf224ed6292885255b9071d011922d813fe162a61c28ce0b17066a940065709ca03cad6e172726ae041027a724fae9e0a6b14521ffc1954cf0d1edce58e8bd31f80ed55dc15bb68b32ea528cb68ed683f8bac3dc6be413e1e438f2b3bc2722e52ef45730c7b5803678bb0c3ecbcf29c17644d6af6892c7c69138a15e08575562811f7cab6f2fa74c52d2c9d202a4fbb56b2995e66180545c6b53317ba5ed05536c2af044db7f1810a76da12f5068f1bedd80d5c204a722e7c56635cc296bf8ea283316a606f1b5e9d61afd90ffcf0eff53d75cf8e9663a0d6e0991a845a1a65d399e20309d03fcdf5c95a3060d4f37e0aa2c43301087f05dd1f4437702ddab6405cdcb749bca6b22ffc9b6f4ca08e98bf8277287269854c6b63a4d375189dcbd865bd8b8c12806838fdfef91d87c1f708133cc0da7865b1c87497dfae82461a905b78978d65965f93b671e69686c19c1bc726a48c1656f9625012c6675a58d6ce51f55e2b871641e6f16b2dcd6b1f2f768c48cb014bd6452585a6e3315a277d080689d5843bbcfb040ace09e9004a04bb0424b313be3d4d0c06295b128df7ea21603d0f2fd204c1076e4cb3549e3df3e5df3d4ac232f8473648f763f70151534c63078f9a0097fc6129ae57f811e21111f9a0b753c0aca04c5a73bd57a0e13da9b63e56d675283fb787bb2295ebd344edede98d66d2de82e89cb3e7b6470d26dad25d2803151e3fd19f2f538ce36de3d213a2d8be492dd03b554c5d0e4d214cb461711197708a3bfb61f44840139fa6f80597545ace6887572984284adf7795426d6a5530af760563013f1382f7901372bee76271a80ddde69c829dd1840e86fc9dfd7fba92d377de8965654ac45222c7c17724c072e8579aa763c3628bad303c9c0bd156494d112b23a742b52d408a99ddb183fdb5f88e6227eb17cd25ec1fe45237757c8892196517bffe53487b34d3e60ea8166757daaa95186b0a25bbdd2658eccacea4532b18d2914fea9a15d7c55d5c3068d3f4fac95f3ca67a681bcf3dee833b235abe4adcf72d7c59e27a0dbf74345b8c0fbe1bae617bf4dac330a5a9510493d0d6fc4f6532d8ade3ee165d83bb37cf34b54bd02fe32259dd26df5054719a2d240c4bba0ea49b9c1eabc341f2e5566076c2f6999e67646ab65c0e8744804872c4ef125e1478d75397e099c26d6ad34ba3b575af82d01c15a0e58fa2e51037dbb737ca492e4f2bde5e6424ca24ae6ffc36d4423794cbb5fa6506dca3a5898c52093d725b26e5b92ba0a6b7a10d6bd6f50d7951cde9dafe91c5ab537a68024eab3e3b5bfe3c968767ffe28b62d2bcb2f81cafedfcbe9d40c5d20ae0a0416b82cfd74755aeb9fa9864f8c28477ea9ff81ea40b6bf477c92469fcfdf39e898353f3e8146ae358176a41b0a747bc9b19e0f15d6b0db3fce7ef22b896dd26bdb19f2e88ffabd4d9522a72680c20d9a0a1b2dfe912f9503be1a76e0718fe1ab2d7ba42168a5ce68db61f3871ff4efbf548c2195836de8c7578bd6af10d0f4499a111f46d379d6d9fa0654aa083753cd8faea63f2b76a3242e94e31dfd26e8e9325a2c632f8c809da37a71cf618ebc99ae9dc256b56e8894425489c4dd4ac2b56c27b0bbd1642ed07e8ecf8abdb551bf3bbf50a404dc28f97d87c8d2b6d450db8c303946398cd336af8dcb41d19a4f1e0e8c0bec8cafae16b94e4b88880e0f0a2572072e117b22b3e1acaeb17be7c8590d2cad62fd24d71455c08abc3d87a3f99f714a51039845d3ed3b8b6a1b5660580616c92dbbba1aff63c3ff57eac5e9e1ddb5eac25a2d4a43063b454e35caafc58f2555ec2bcf5c4761f7e7d859b60efee0068a48768076567935d9166b677290fed8742ed0ac84407aaabdd0eda8bf118a4686de0a75ff810184aecdc120556c6aa9fdf82d0f11a26620a064ccffcce164f4b2313666f5dfa5588453387a864fc2ae57448b6a0e09d1ab8fce5ee3eab584ae2d25611fcbad2a3653dbad76bbf6f001d27c7880d7764f5c8fdc1f986bdb70412a51f21e8dcf11b54e6d18ec645e118f3e032b0bafcceb427470ba4fe8252119d37ed08cba4a2bb80d650bb83d4cb349adaca78990543c8f68fe778fce670a25632bb58eb4c8b572c1f28d8e2fc62ff56a41bd768d390c07ef11ff85b1fa3a816e0c4fe4e3170fe24d98415dc9980df3fbfdce74ab0d949a81c661ea0f3c8776e78734f507aaf49c08aed87c27d175c9a7126f387f424217bc4e7c3ef80ec6a3cd35a6ba9d16541adde1dc2a3b43b8534e25c93bafb2133b6271a38e96551d629d67212ff096abd197afc505d406e0ceabcddc8420187caa7606a30840795eb6859fc22d2f88fad623ed5e85abf55734e5178808cf95de8a067c0c0402e87261231278ebdcee41d498427fa9f72f9f94320562743a2c96c34355d5551394d8e1ff2d0474fdee948211a90e59b7970d64c10a6569df458e2706a54509c8712e785b0dd0d4b652b90465f35c2b0055a8eb748f69716c2e6b09d29736d8d0f8d080d9058edf7b0958c50743c89512530650ff727039419542fc10e8a0fca0a786b47e1cacae6ea4bdba8a90b3b7dec144e0e982bdda4d0fe4c23f6a7b35ce7f3c22118c965563da2a326a26cd3ef1920b9f8704c23c9795b1af7283e9182085d2f35145ca66ce04b5841f25a51d75fda1377931d7d97c0208f7b7abb90dcd41f84fb967b739f6a2b657b301940e14fc12d15db5c8705b9637b68df23386144219eb54cc731af1d4cf4a6000f11c05d0617188322f6d4f760cb1d7773856ff9759192a7c3dcd55e1763530bf98ae857bcee215bb9a10a929e7077ff2ad3e9057a2730436cd0f07b41856e0aec3c74e442a4d8b598da61b1c65682c2b4008181bbe61eaee78022e59c914c38f2c8355373cf5398a454dd01f997a5b806ec7b17f851b894926a34a85843bc8fb86f84aa335d400bd581d4ce7d38c5c63ea2325a41bf3c9220dc43c0cfec54edd450bdd9a36f9a8d71dba888afcbfb7da45bd8db13afa6a094a284b6802abe5f4b1dbae74e2e605b1e794b5057936cbfef106304d9054e5bf40b079396741ab5550d45c4c045f37970f6dd7b9a6076c7c8d35d5272ac923bccebff2c08b228de8988da581434ee6cacfd6e2eae2f9c7178317e16ff2648ca94d48e36269ac44e6fc01fe37e8c91affedd2fd3f2345c424f8f2155a3c40a8e66520ec2b34858e613dcc6cd4af5155df35c14b451ee09b0c0bc3a3a160b94405b19336488bc2c5bc116a8583b1c7e985c33706ec031a8ecd616eb1026ab6414d2c544d8c3996bd2f1ebdc1b452d036031e89ac08c682047a08d107bed1bf60387b3716ec85a26e443a44459a4b8c38dd2103c3d1f063b5b69fb3e7194c0651f5f969ac031458cf5d07c74aabbbde218bbb30f263134cee3ddb095ddea4a5e4e79f01668f54fff82bd76d1a244eb11bfc71a8553fb86e605c501293d9abb6d323b21a03f2854f8d38e27f6b836ee8050ec13171c9edda7e749431c65a3102b2f645e8dfb144b52a5fce41820b8df91917444b92c85ecabc7baba271b81267c45d936206f9abaa9f4e85ae2f4373559b5fb05b5be8fa8ac07ac65640cc5645338c177d271506c3770b5b041677a81856a39f17d53b2fc5ed10529e19725a80af68870ed7f90c4c6f6c84603a36e6b388942ae6a9b4ae2080ed54755b0c0deaff0c92d4e0babaa6549ddde2f8d29c7ef956534e1eabca89cd581e8df5fe3c291548733d3014aab9e09e0014e6e38765650240b7f05c5b992daa446da133f46c321d56e18fe3061f1ac3ab8705c45227292445058a6738e171d1f345e596e47e714287d578aa0ef0e83278f502154dd1023dc0ddcf51411fd1ce8b4de89ae40669a27743450f21509b68e041c8372f6e0d42c29b7802f698a5378fc360b37b1104dc8eed5c5c60193db59631e0d3ee18a51b8a3ff8469f2165b6e1f20cdb7e2baac2cd8b5d00e24ccfbb2bc19253a3e5b525cfe2fc4c078dc78756cd390ebda4afda402ad40c6f289ef3045b8d687a5214b1db7bf82ac29026fe8efad2cebbcba5e042f3d7b7d4032f28a3653682bc32e28277f964560656c0ff2874599f83348b428f0fbadbc45781f938e4805be145af53a201472e153eac843d09e78c7c5c0ca3248609754690a85b9123326db4ecf84f1eddf272339bff1b2f6316a15a3dfd58f7455d28b68c161546ad107789aee897ca593ec43160d665c865406e1aa1f4ee73c3b1bb56ef484346fb60fc8080b5c0cdad192f8508b298aa04018a0d497aa2d1d3aa97719eedd4aca569c3dc00d85290a5009def3ae7fe0be85e0ef73989e734b0b54a0719fd0ce70476586418564a87a6d460b8e8a074c67a421638bf3fe4a14ada061081bb022b82f38ad9b3c698ce5077aa74eb55ecb53b22440cf776f3be5e06224c7d0b233e10d3eb7c8752a293c9ec1460636ceb666ceb3dd6f9a32467e8bf98a45400ad8b864d53a20ee3bf4ff8e31b45582c0c157737297ceed4b80cea77861be526358bd8865d5539e5bdd240429ef55e117bf9a5cf37d49dd4a6ebac29ad4c588f22776351e90d7a815c1d84b7625345017ae9055a1721577f190ce58df57db73b2f53cc7f987425efd10b726e8ee806ecdf448ecb7e9e371cef1463ece73fc139ed4228c95337569544d075a42f108cdf9434e8e4a61d271e3cee3d82319ea2583e306940c5edc6ff523dc753b5aef5a716396f90cbb11b08c5339e8526e0751ddcc148c5dc0d544a8be06a21747a77abf7084571af6c76508677950b3bd9a853d0a12ba24cf0178af5ec2a7024d402cf5dbf9254162b8b072c54ab778bc9ac58fb13b7bf0ce552e787f5d2d0622f44d7805a517f4b71a5b59c4f0aa854ce910c90dc1274d657918faf7738072d0bb5e72f8a33049a571c5d6a8d76c478e26f23987611f9ab04c263cd35da82697ac4774cce8a66d38647cd63517871fd6ebf6d6d9ab8014e3c2e4ab66120795f3c58544be541d0ce44677b0452642c8e6b03903f14e4bcc4388658319787c63b65280ab78a460ae190d1e600db2bc0f70e678c92eafccfda81739e7da6405b8d96b763ae85fc376b50f625bdbf1e16ac0f3173bed4fe799f616335ca2e0f3fc9c7e97b6007940f4d8b0c9ad71d092143742e896e01461ce5687b5ebb087127c79e7b4493595dea6cb87aef9cef5644f5f37635212ddfdbc403eae3ea8058324358dc4522dd7391311a4c818f6e276421e72c12ac0854eb181e05a7646203975e402ccc79585a1c082b45eee6457abecac71a8eb7ef2d52fed7e84029d1b8051bbb61ab1b966290e419692e0c95e0c8144250a73befa8b45b4a88dfadf477fee3dcd6421d53fa30ba5602c01fc25b91cad420690a1c51b3555b62155a72e19d0293c16ea87d379a012f8093731c548cdb012602473984f7d7a24c260cb8e53e275c58a47ac33dd0387abb350d4fd14cd90e2779eaae11e7125f0678931602d7e890a58b667057676056745828a35e5f785508423dd07246f778853135ac16223c3c4b08cf9cdbc97ef41a41b412456315242436617255c6bd982fc0291f1f8aff83b9c831ac3b6a1b7535d6d22a05892d2eafbdcad27296614a71ee1c28583671a19921991bd260c4d4f4fb59be3ad0e18c0a4abfcdec9c21326573b0ec9bd4b7696f3127a04c8e8ae8cab0546854ba794f259bdb64abde00517d67f929ff7e5966b3069395cbdc826a13e382dec8aadd9b4fac8f9574fa465960d6fe2ef996c27de7c8a6bc10a345162249d513b4d81e5f218f9d7fb855fd126dba3ea7a08ec42b68b3bc49577e72d5479df32a0689eb8d56ed9edb4bbf75d0950a2835c75f114afc064943af3028fca07fb838ae431cf5c2647ec18ad9c0f28527a1dcfddfc36865f55130f6328c95bee7b2d66ad92b9abf72fbbe9d92377e43e1823dcc37d4b672f0ed16c7b249c07c80a4852a5bb6abb32e293edb4ef3bebe82189ea482a77a58b4cdcafba50b1b988004e02597ff019ba5f03b7f2e54fd01cda3c55e047e1a4edbb18b99760341d4927c9c1d4b6c2fac428c4e33057e42f38fd7a6437001b5b4c6eff3428b6656c5286c6066fe072180530dfc202fd72cda9a5ddaf374bd494830f1368999eea48e236662ac61fe4e5d60d560886c8bd41b1353e9b21fa2711dc4b3afb64057482816b1dc9825247d88c31c26155208c0dedbc867e1b085a76dba49bfece4e3eafd84c84fc3746f0bbda46fc86ba982e8889d41dfaf2a9c20748657fbae23d791f86ed89498a078d62e402d2ea95270ce49283789543a0535dd5597ac3584fc79451c45c0211cfea7b72a098eced40d9e226197d94d1b3f588a4a579d21371f046ca725d4d492633712178ba553d0d8631ea540d97bbbaea1ac0ef8376bd291b184f5c342d9c42dba447a8f3f59f41451ac9288501ab61be577a170f5a6f7a730a3da1e416ad586049d4fc40a36ec49104e75b8c1e5b2325bf000c91bf9bb3b79c5f767e940e3bd39e0262dc057f8c1290c248b33f55503da94a3a0cc527a29f9d977872d3016c30c9099a499b28a0c7862ffb3cb1234829de78aa763d271d3d0ae3196995cc8af90673e5218394c7cac96df54399d2e07a01716232561339e1fdcdc65e6b9143b997134391b1666aae3aa3087ef3b31cf824ca26e3ce86a7360fbf7f55bb8df44ab5a69aa45a3c6ef495e2dd92ff08a79065774760ab7013ed6bdb6fe034c624d7de0d0cfb5555feccfed26c9e44c038913c85d3cc4f4f07308b4ce69acb75afd0781dd220b1b0603ef860b4d4cdf5be852b00d5761375c844fd841d6b9c5499c26cbacf4bce0b9db7d9ee94e72122562568a036eda99b56c712e5617ca588e9ac7f283e7c03f87df949d02277b17ad265111a9c1b7ebbd274e0ac2b3267ec409ad8a6b7481862fc082961b2abe9c564a60062ea1efd32c379ccfb464076c881ebd85f367249b01efd0f31e1bb05dd44563265ff41401ae21b53ccc99a415a1b4e2e16a5d217009245853ceb39dd59d7364d2d7b2d5c0a9ee719236f5193fa1c87d9e204d2805d8da64ff371e369f7095912c9c6ac99800ab172b3ace183b41fe63e095fc572eabd0ebb7df7de54ad94ec4ab5fbe8fba7ae953521baf6abc0e1b7165e387c49ba989cebd0e65ffb58da79a677ae23e6d2d3d4970e1d643659388a7a9f6dd4ddb3ccd2f528b5fb92cda8b1f9fd52122c681c1abd9ccb765febdd6e05fb543c64e5026d81b0c66f5e0814c033ce658c84ad991edd6667711802d340e2088ce68506164aa24186cdc7f3a1c645422796256064f7bb4f571ca56f8fb086d47ec9fffd9192861a8d548f0599526ed3c0a725cefa008eec6b5e88dad23f37308dc1b70251e06f4cbf900846432de7ed9a3c762bdadecc63184fbc998cb2727d1313935490cd19fc4a6c125e9d345ff5674d14ce7a38ee16cd5fb3cc5b5bb96cd53b78395c4a1188d9d184e803d4871c8bc39d24433e2a751d44efed6c78da83afdbe632ae8e1277f110fc9d198983d2f53d53a1513f496f05d9870958be791dcc038ada55f20d4db2ba4963cefdad59121e2398f7a86bf69855d9fecafadb4817f73c84ad5f5fe4b8817701bb35c6497a4958220a8bd0dd51277be3e8620c2c4f11a6d5a38f92a0cb903bca7395d8ae76ffbeffc5cdc2926fe53351a862c45fb237ed91d3cc45b5ac148fb2b37e66eaba5235afe5c1004e0f80be0cbc84af6fff3253c5ed80742e99bc6f88d4b34a03382a1721ff14e5d1ce24170d08bf17a5296bb499ec7b02590b2e7453874af89f4d259420d6841dfe354d617dbb29472d8123f3971091c402b67fbcd11977380c178a1226492419513186ae7024136f365c58da0b75f5b78a48f608a81fb68a86ce9ab4b2e4466d814acb08aabe386d715dc38eb5fd289b368f27fa173cdec33b8ae495223d89f007dc3924ce967968064ddab65852c302b22cd967af49d09c0d3e6f62ef9abe46c42c4208d733f14edf11ea3166e7db97b6c5151903ddf3fcf76c139a8d09d6db494495513b4ff1f48ca4bf2e0f498f75c5b22350cff6cdea40706513a689402138ea2a7e424e4a95116e49aa76293b73619d8db7448feea02248e32d649f95662e4506e8cf94b63421fbc326e964b66039781fdf8b1b79a8c4fc6d91199397632788a11fd03353f0da47b9aafa1ddc432431d4b214f9b5acf8131e6a3804540d320bb0d75e0c98220981d0465ab2ead7e012119f382116834cce489447f12f6605c01c611b7d26508867149770165e6e329f5d9cd0466f95c5609c84dfd1ad6259bb026fa4c3d4395fa9c9294bd6b09312976688d444af6aa7d5c03b5a5dac8e2b5cd174bb29d59678f934ca4477275dd797422bbe35040f8fab1dc37f6521dd1be94bf2f95a71b0266a46f534d6b541a1035d3d728728bbe8f6c61d65b88556fc5f394cf25b610c926ee15737b8eaf4f00f16d08298cc631e2078af4f905036b550c42fc81484588e1e4612363d693771b5398afe3dc130fde9008bdeb56b33971b756c9d27e4b6a7fcdb4047a82460979fe04beb28951222628679f688cec3289fdca77a1a0cb7dd04735e9119689666a069ec3411932c4e0857603b6bc393d789e515f6c97a42ca1c0a5c07958f0fc1f737f0bb5f8e4d26f710c8c39804760df8c7abf2f729c46aefc8ab836d3438d5cc2c14cc9f84ee772481283507510ce516ea5a269e2a081c092a2ca6957f74aef6314ba7bccd2c8c87ee348cabb1935a31ec43c1bbd9791b26fa93303f7acc5513c287a398ba9612317fce00478bf6d522bed6f6d7ebf39a751728c5a09caceb224ead2ac34cbb5272df7f5b35591d47a58be60e9c39ff93e4c4c7f1faa1bcdeb698d91fd24679e016eddee4bffbee3ee1b8f44a9ce89372f49b9535c388b305a4b6679c1a1ec4bc99cc3efe3a794dd1e1f73d38005a90a378274ca70d6e2f75a7e94c3e853a3d0160bb9df2283079a36c20c08e073a3061008c90381eba17a32ac7df9a9c5d335a62506ce744b52c96d982f171e44caaaa33d386ad1a3e1e87ef117b4cfe97fddfce9ba5057bca13ddee652c9ed4dda56805a70dbed6c4933f05d040ad291ab3297688db60419d10d5428d49ff7814ce742ea9289477b134de47679b6d4f734ea4348082627a536a3738b0970f97d365b6c4dcb4e2a4521fab2b3fd42fa363d56f8410904862a80044273245e56fdba25e536356d8706209be802f2bd7bce208e97a28f3bd1759fef93f7e361b5640a0d422e13f5183dbda96b43ecc79b24006ddcccda40c7d7c694286017bf2739f3b8b80f554bce2eebd68ccae101dbffd7a8d4b6d8e9f3a575043daef01b54a4025394896e8a475f35fd4de12126cb0c2a842168e4752fb994a23513271f4ef534dae4a07db7621b2559c04320567d5c35dc8080d45ed6f0a2309375e9bf151e360c162cc10583f2b5b936a30f67cfe1be95f7b059cd6baaf140c9f0a0b13434320615575fa24737da9a2c234c37cbf469aa543dadcaf94df124b452839593f135ffad237cc2dc800f5c2fdd9556e2d2a058aa828f890bc28da85c9ef5db6b351fbed5e29fedee2a0305cb5e1b8b0f1a0d38c96b96608ff79a2c708abe7f2e811dada4bc6dbe8dd3464a782554fdce50a034bffbcb4f475b51f253000905537ac2ace32caa93f8de14c4cd29ab146d5e2cb2dac69c2bb064daa902a03666456ca2082d8391eb64f22489c250f94e630e8c5ab87716c7700ced95f33d82d814c4842fce647e634b7b909fa4f9cf9c59915b58704c76b773507ad6225c729218952411c946e095ad28c7f58173930ceafb40000e95078bc7b069acf2b81bfe7a1481438ef68150146b93d5268365ce73c4c42a1b38528d42b365c805c133017f1cbe514b1220ddbafc2e0381e2dfda2148bac02e309972b060b8f66217f3445eab94d6f28e4f56795767fa2abd9ec6c848383c1c09a98401c537ba2a14c8a7d26353447633b4428539d2fb1e349b8c666721209866f62a8c7342a8e740d942b80a6f7c031b87f00c2712dc15db5559deaf3ca8e37c0ce8f200cc970ada57adb80aa3987a376d4b07e72ac7e13bd1a00109de3358944b26aa8479f57356a2679bf2a187bac99d264f04e66929525c0917c81e2d798cf76d6a1ccece03d93698aaf3555fd5ea5835464e4733440f2df5d61fa66e895796de146b67660abf75849663b186b705ae2bc95811a09cd7cab444a6016a7f789e05b1144a631b16346f653e0f194f5a92c133f959c2e90349ace2d98d90998b756c34413eed35201ec748a02325cb7c479290cb2e77c56051f57e99eec0c2bdbe77b51f3c486cd5e9cea34c7ca91cd31112d6af49fca0adfe473da917bb6c4ff971845fe8c0355f59292b2891707d1b3f143f47d5d7dd2087349232e5dc84176fdb66b720fc5d9c0df3c7bf642e63e37c9b627b4144dde2b6f79a3f44a9adfe7259da5f98fb149f2854d4bdb481ef0f7feeabf527922c8e3a749c42ebdbf583efded5958469fb2ec0b35a77baba9f57f62a39a4403291b6b91a7b8da20bdc3645e8f81959fd264620f73b617b89b9c6d6d0f33d66599b5ec1caacda1c1d8c3e79e479b1940b0393dd768495a9f5b33beeffebb5aa70927f7ef67cc45f08ead4b3256ea79d92a1f9b793c2531442a6ebca619cc87bc3028548937a4bbcb22bc60ef33646ae56890e4d15e57ba89d98ddf1f9c176d71df0d2fba08e5457df79f5b395f860d1de4d9d9abc021501c46c6d6556e080904cb5392452892742784ed74b7b01cbee64462451b46fc987eff6c97bda5fefa2b1e483f71eebef22b20cf5bbc7f0dfe70a8956f6c8b06725bfc977051e718e985e12ed1f4d4e3e6dcc9d6e35f03cfac3e6e79bd7922f6182f129cdc39a856bfd664ca856b61c862a70b373933974fcecb70d8bccfb0d4cd71799782f223b5ae45c2a58ced72ca052efaec9093432cb7b570077c9ca1a634da268f68ed50c727b29c9966d747849b4e6124a238e4ed094353fe0411fb404efe7d01b5d9af98eb0b3bc6ed9535ea06d04d36410d93a79d4756cfd5a065830280c1a90ff4495cde506fde24fe8c7aaf4f4cb984518deb5cb7cef3aee93be0fd7e37e4fcdf3a612b6eb186552e51acfafb82bfc69367e7b8c0048b45b299c6aec3b942965548c84c92484602011165a1ee498ba95b9704346eed8bd2cd4952f9c23294054cd160fbac1abb001db97fc908c758fe0505d8bf2b6ca5e86ee84f11d1cc78d0cc67ce2073a97266180d44972e3b04c4015d65311d544d06b6be266fd4f335b2b8746ef1d424106b7cab0391fc23859b797eaa1759da602d17815e7fa3394ca0f6dd36f668c7f8843b0cda94fa8422dd31624fe21ad97177d616cf37b33294dc166315b6fe8445b996150d80eef51d77a750af83486c0e5bcd8b9ac8b4ad42c26fb85f41e72451df88d99ea433217780dcdea9ee52dbc76e519ec586baf0f038a4e353bf8c288e476e8ed68ca3203c6d0b4190790dd5b8aa68576e1b2ed4b4174e248796f5742b8fe3789be1ab3ad8baf9854cbd118a6142da7115601151daace0955b94e9a5c16157cb4bc8210ff2448b93688b6ba12b915cb28683ddd0fd65b4b41492a487f6f76f03e16ee9a61034bafef5ef4cb65542f9247ee65e279af7d2ce53de51cfea680f928e43eed1d2e298c8a74383433750d2afd61f2591af74b1e60ec45fd08966d43672336c86bbd12f21d71839885dd6a15f660c3e3eac0fa8670719a0eab8a5d9e6331ec31af5f45bd2e0396f85a035cae802ea35812f29021d32b6d6ea2c331614855d9dbcfd6aa18685c6ddda99251cc4b2f56b885c8ee2de13d497cdef6365d32356e119776c7178dafcf2a6ae9ea37f26f3b998553242b390f8fe77ecb9fac1c5d3cb186aaf82f31b8e8e5ac9998d6d01b7dbbd0f617163bcb58f3815fcfe5b8bfaef2a970032b5631f68226eb0eb8b805d1a116e87c6686e16ea2ecc3737d6d2e52fa76d8f26c875e048caf58886f4924c951efb5194475834cbd1b7a706163e1ad7ef68846a76b82bab2270ed8622312b49d5fbd5eaec52934e418ff9816e3f7abff0c3b71530f67379fd7724cf9ac8c0d9abbb44c903e0f541f433d3be340ed9152ef3da78e5bdbfd0de69861d4d8f67e208b20abfa23b2fa9e56157ad03e29898482f1fc30462df10eb5cd437c36d46f82eedf8efeba57db9de3db778c1a73b755a54bd53949b46177040e222a9a5226cde39e30e2f284629790d950777476e7ce2757a0eb984829d9868e509ad3bd7741b76213aa86851a4418cbe564dc44c1b383b0e93061c7d7902e343b103f0809e1db037b308fe81f0ed06276dd17cf92d33e09b7240c92efbcd81a28f676481f3363ac32458b01a6efa7c10be72471a87a3ea836d8340d3230240fcac20f3800a34d5da38f58678bed0003b3a19365358639e6bdaf7222fcb03216a30e13b6e219f7693a2d7575fe9f6bb38740104bccdce4b017f19abfb217cbe53603e2446fb6f5f81f4627ca317b5c528e29dea8674d6c09235d6f533f1ed3670d8e4288d0c3da863d12d5c920ca27d45e46946302174886c1eef1559cf25f3b85019ecc535268629408ed1a648d23239fcfa14ac09a85d01519bfbd71deac32760de37f9913f830e4323b2716b0a19b4d1d028ba6fa2726121fe189c1951fd4a33910b2555c0268a1df6da0c744918cdb450d3be4a65bd8565e883aa4fe21dcff4b279ba06deed43b2cd9f883bcf9bc179682d3aa1bd6cd60a7f554158401b8bc442d15d7679716b5213ee5e5492fe2e82bc1ad9651e1fe07fdace1cf45340a30dae51e0b893b20875d77e43be2932cd83da28ba7a240f84d55b8ef3ab75c29859e2c590499ddbada8072b2bc8ef4ba6bd98f11c925535e7c355b0d667f24a13f39298ad0a47aff0de0cad4cbff162051224246ebc29565934319d215ac8faf8d5e1f1ce46bd8e08a2caf104e94d7e8575c0417ab81ed5708275b57e089b9c56a6e469eca201b9fed1279f20d474c0e3c4a82d48ad4f011d4524eb759b3040c92e5e741675fc3567b0783483034bd8240abe5b1bae2bc84d192d5965029a8dd400aff5cc57a2f6ee8ba55a6b8a8e7aa99e17a477112c2376c7681971a862b47c97eb7e978843d286ff13be31deeecdda70b2b10d45559c39ef290e5f09dd48df4a373058faf351836b6a89aee4382e9011ad9ee6ffce15641d5ebab5c1e41a535f576730ef1b6a40625a1aa85b9738d4fac16a4410b9e31a8e3e19cb3fe66b9abc8eb1a0800fa89534488b7ced94f00f4beb45b4e5d812a92be3a6ca4d3feaaf41cbf83371761578fa940a71a5b1e6888736b1fcc0eae2b67e5cb54d357eb88cf5eb85c331af5f0d2e1942504455864267e3360daf466b1c6725b9286bb891b8f5046f72d00230dd4d83c21643ef4838201f372ca23d74d666c0fe7628df65e5c7db5cb45a6c6b92bb8a34d56f53dcbd6e3ce0df8c52b2640c00a17384e3bfe48e2e7f2656b52d3ecf8c6a24dd35b339de6c8cd31c523761149226cdd0109df31b730aab637ad918aa124d9386fda281a0b52b3b10867092974c5341e4f1c977181aad49dd132f80eeab3f3b66f510cb70d20a2a549adc185624f3eb600a8f162da38784fa21c65a1c050b25bcf39b22c02e4e347c0fa14459ff6615ef92a6cb3936a3fee4b7b075de8d71d04b559e47d5a77a1872bff8c61c57af6e8ece6ba85239cf73bb3d36277ac6e003b52beddc1e2b36e41f5f146c1ae80596e70c54164820d13da5e64cdb6611669ad7918cfbe7b72bc07751c749406476b8933d99d03e519291a4e12f53830b92cafdf745f549e1b657b93a1db0359fe13a474d11cd5fb62725ea9fe5889df5261cf36b524b6f1cb243450f8562ffa98b85302a64069a28c4d0aeed0cb079fb5e17c9ae32b767e4e1a39ecfc517c5e58c9c55b7a41a22819bc0278d3f59e04b0ccbaf975765f48154a09bb724e34beb6353cc23689b69f11e5be8a1ad1cabb0605e573db782059e81c34dc4e64731e8df3994d9e3603d56892e83b1030ef9ec9b484d9399bc5853ade815f2aba66197f7cff55b99baee472b28ce1e935fe3409c334c315ba0379f23eac95c811dbffc64c77c443bf1a8e5ed6dbe5bdd76ecdd66296f0bba752ccfdd1a68fb4381b2e7664b21c6fdc27b458b47a222b6283b4c68455e1a6a6d7393390770e97951eae1ecbd451b0e146b3e5a86225c5f6df39e15f3ddac7f01f31e0569f650ca30781a40852b881f15b77072e5201c30671830cf05cc88e32ab58dd631212706ef229a6aad9a6f9e2707bfa69cd8bc0dba1667e753bb4c80b46c62cdcc0074a19135485c05398d6bf371dafa0ae2abc0fe3c1b2f11cb7f09134f8f348aff7c75824ae9961ede029475deea7bb4693dd128110b8ab56a45bcd2cd91a149f10f3f62555812635481a6babed90ca0d1dfca9ca3261afb3d8ba3a2159f81047fc20516b68d3ab471a50d3fbd1b67ee3894d6a87a4104be9e1ce4adb643cf11b1b75d9f9a0b2120c827c5afad080aedf652040be9b5e941bf0c6e16546b6cda84025943706df7f803e168eb78b32d4b26007edcbc9d0df7143b6d847b8ada277729b9de919ef9d1605d6310b0b878e96426583c9b83748bb07bd7b8e3544cf896b7ca082154a172023b5bbc6f5281dce5edbea42ff0a2e2350fe0ba850bb9860e61060c11256204b3031d5b76aa7e9b6a5b65e3dc44ab5f524413d0e1b8ca695ef8d329f390eec2ee45fdf7a284afa68b819ee8d4d024274d526bac0e7f28503c33e7f8e4dde34e860ee6b1ded1281e79f4cfe7f928403baff349d8ff2f1257ef5a046093432b6c5847fbf90374d4de1094dc6cb0ce165b0008ef835b6d45a1bed19976f4ea1b30415fd57ecd44857012d74d0dc41dc9c13be164f44fbec5c0bea0a1936c1fe709dd3576280e33e37cfb6c97e68beec1e87fcf41bdbe999480122af856402e1b51fd2e240b835ecab1f656581547e5a28bab3c54835a8a89c2bb05d28644964519f93ee0acd3e1f17152d1363edfaa3389c12a7b70250c5bfbc5b7f651eba0494b0cf880a48f35200b01148ff6c59b991a12536bd924402770377c6316b656ed374e84d3e55477390ef0b5803d17373ba1751eca2ce3373701359fd95cf780ae7b66509dae534131682a6c77501b6e9ff8911dd23044c78bcfd330e308c37e2ae17077bc3a273af82052f862b4709efee35b4b0f17f709d4e9949bdb3fb9629894a3ff614af4c14edd79ed75112480bdc8ff9dc30f876e07edbc0ec62419864dd612aba9d3a34a00f789db7e710f4bb5ed7d388f9c6b7c888c09d279a47b9a3922b51d05fe412e8c7753e89419528a4d0bbb33cd8f47af90cc49d9f450e17c5979dcbf811ed683597f25cf9854c0399d110157d4e130cd08fe9fabf67491b015b5294aa9e39b57126b2b6133045fd24c5923db150e77e2df95457f5954fcf4a56151f77a525ca55bcba28ad9245ee3152bb5f44c6e36ec31673535179582e357e7f8430f825fa1ec985af6f4d72b406e3a593c30d74431a15b2903e500b1120d2a3d4091d3b469f5ec00c07da44baaa280458d77616c30e0cca22906b5d8c68d3cb6289d033f838b29b342703d2d40e94228d5bc446ffb37195b1d5b1c0dd3906441c8d7fbf52399eade4676a603410defc1b85b238e35da279cd031ca23e6573383cd1cc5041112261063b014f61878162bbf86b62ef175f5f382e3838395829a1ee610fd0311edef6be95904b7f1a3b2b85f210d7ebf24b3b2548a7a158e2b83eb420d21d821099154f3e33d95077917b4d2236719b636e26b09c9f534efcb5a6990e53652b80beea2313d926b5ee4a19eeac65cdb963b50611f86ad8e62b3960935c053f95ebdadabb09c6359a28f0cff7d69a14ce2571c74a48e5dd67716210915b0fa3ba2f20c2401611509dcc52e57b39c5969cf3d42159d2019431e4d1b61946cbab0a84e5c4f9a627cfd388059edf054c35413e77f51ef7465bbd452bfa82854828af2723b0f6e0463276d5ded1ebc9879d3cfed73097e94bc353db99841585c9fe2239fae996550385673179908a594253fe40d3490aa63fd913d04770b05d445f42a42bf2cd7ac515d358b6d5e4ff3e8bb52830464af063c6253ae8c3bda4e4c53eae9b7247ca477c5a24364ed2ddafd572b21554371d8ebe329f30ff897188cd206ad6dfcc0d1af08d54e22bcd67bf98e44d8ff20ef2a83e7c7d59b7503c41d2c14b8aa98e0920efa88a650adc490a5b38b10eaa47f22f9b2cf09f439092d863672207fb32671234cd14ade3239420deea5ae654fb0ab5debafec47976bc45886affc60bcc7efcfc35016e1414f7070991e2d0f721a95ff87b888d7a785739ce94f0dfff175dbca11d219f705e02b7a2e390662a1fee683abb06428e679a952f1d019158ac30867a4f41fa672dce9bdc97b6aa0f64e49c28f4903211956ff1c36ea7bef4ee196216a0e3803a4a3216adcee07fde274cdd9607a82d70d7d1164323a16ca1fe33adc1c531f33c25b3fcf924592efa78d6a217864e083582e18457db41453aed8e945c4bb75b2df2981593ae56e39a286b73ba69dd1d23a3f6edc0de64185aedbd9c8197ad82974a399dfc65e42e0653646e1ad9d5c863168eb846ae84569b558e1dfc414a78490858c709dbc883578680c5bccda9ebc2434f7f7af1f695689b76c28e318d0fd849a835472aaabad8c9aa3ebfb7166afb9690914a6aee115da74e0a0a3c815f33d3e2823587408fea079eb1d67836b01305b17164d8af263525edcab242bf444b3c9bb853e3a8237d9cd78e9d50dc29ca30555567f659d74eb157a9f80449dbc39ff9daf97bd079180a435432942cc6110017a8e6fabb4aba054ea37c237e09babbc25c035981fa7417871b264b9f7c9eb47e883c47f94ada881a87670d03f497b6a4a54906cff2a3d7e20bbb0bc7c581d92c482c2e24c494dfbc7910d2ee87f9f99294ee118210c85e17e372b0461dd797f4ef54fc8c4a1365b570f3107af2a0d517f87619a8ea5d25f173edc05986804446b873ac3d9313aaf2b9f781b6287bdce617b56f9d77145ca22217a83404f338b29076f1fdf9c75da47206d08b60b42da72883a5bc9335b24569a7114b2213497c9c5e8046f947420110f1bf5395dc1be1d94d7f5f7e9e508f55ef083c6c216830b0f2c3bdb7900e60daa7ddf4061ce436c96e21045d480be809f8b2bcf3b64ee9d84164337715605d6bc02948b67767940f577d38b8600bed3af1bd5bccd13382d3f54b9325e01d2b344c81ebed2518ceb1894965faf17394b1efdf6091f1ea3c937515f4ce41ef8ff7feb95fb5f28c3b2e660eb1f51bc305cdfbfe5cde43f97dbed709b82513a88f4da5ac765eb46c36f5c211fb5bdcf18afe6fdc38d5e0732030a51bb3ff84cc2f21eba7a2facfa30aeb572b5d466794dd4ba75db19b17b98b776b876bd7808e4d337205aee1cd15d1eaf8cbbab10f7d79cdfbcb39d8ca5625551f04d64b99e6049738dbbe2ffe3ce23ca0c1a2fcbfa38c3215a62d3bddaff1424fad619c8aaaba334f0350412d6a0a244982306c0254923b87dc14f4ad3236e82511c3324bc37544e0f3f53c68966d559a07a9a899e3a53ec0937e39a532b8a53c0cb116ace4d5d985215b86d1f814796085463da9731fa447c59fc1d0b6c30c3e5db1778968a057f0e5dc4b85d274abd884051b6e7e1b6c4c5a744c90cf7d64581a26268b2f8ef3dc2497f98d22d5fdca2e4d17873324a683999a19524526278072081975a9bf3b5c297ac4e8336cf374cefb67cde451f95602826d5fb2d485826420eb0767fe8e68753b239a37260644d7b729bd05de1f63efcf13b959eddfe755145a71d7bd9fcc7d8f51d25c892360f764dc6d7f5263469a0dd7034d024ca6b35ec84c139ff6598c1fcd2119e229060144e41a5b3529bf5acc0a85b31517a40613bc33d7156f6f421cdabd92e76fb2b4930a3c054f671a3b6e012f443a3e0a265f5ede0fafb8cf752200d55e543b1bb67ffa2dab6f24f23baa96bd445ff56671e0fed39963d7c7616589f305844bfb35cac46a75e6003ce1b4a5e29fad21a03c388dab1654a3a566b60578000250ac1ae45c52a0b3aca7e2ae9082e43bdeb5d7c522dcf944467ed10fc6171d1b6f91b1161a83b5dc6d4d199dbc004007fa54dc0f761d2f34c14466bd657383eebe5133f93bc267309dac04b6129cc50f7739ab316858fc6b6830a61a3bbbc42fcde2a4ab5e74d3352afa80427fdb942e0d6143957b27018962730c24e963acc71a63df3707a625f916bf88a8740ab1bca50ddd5c53e775032a41bbc5d0eac2c59bc4c8081fa4ebe5f5c61b7866c59b69df97f2223c570cee112553e79aaab4a03947079f72248de5725ea57b4f9604b18d11a122a3c913c7b9a8eeb1afbf0e984fc3b9892ffeb286cae17bde2ba11f3736b88a6d9ae4c26a9b4a7c72c1fc03262fc4fe306c729c084f9b53757c6075f39437a58f58f2c86f82c4f0c741ef2bd49d72542fa004a5c3e6f1be15c7713d7a16bc9de4b7c188790ea20b82e7f36d72524f1bce27e37c8e89e715b3157296e45fd5bcedb5169f553327a8b22d5b8aa37abdc5b8c2dfd56dc7e75ea873ea2cd0c528742af3aa960cb786d4f8d59df3ee365d7e2114f886123fe61230724c23afd3f3ff5039beeb67b76829fa5fa1e90b1b364f61266e686828cdd68ba7fe4c29c75ec647f036c1d122c11b54940c09e6b2b11395e3706abecc3b84c72c790ea0149f5eeba652e9dc3cf6420cfeabc0eff665bfd79d54a8de09951b541e7274fee1e969808ee623361d57cdab6de65eb3d9afc381865b7ac3cf5d79f01d1a54df8936a8abfd2fb43930e29cbf7341a937bf1d9e44380ec874a4ebe876cf6886bb1ad1f2edee34b0eab55bc66be9f52fb900aad9102e241dff2363ee2f5c799042d6bc06ed7fb4ab933fb46c1e6894cf6d6bc50c7448fc42647806e23bf3f64a38b4e6484572a7a0ea36bf3233d1b91284be319e834ba560dbe6d3367e44995a32df27ee3bad50372c5539bd85c6d365542fac5a785f76e3b44174863605b18b583618316cbaddcf442d1fff862ef54ec6e66725d68f37b2bc7479bc1c6ec462dbcbb07f754897efc7a1534a66b5ba1b4080584d5a4dda6c03fdecfa66bc3b742c64becac3a8a1f32868965e44493fb7138e4c51f2ebc1ba8d6c2e1299b11d5524fd2361c6504d2b628fcaf0339e209a3f14d81cac229ce986e821a65e12dc362a44ed004d5cf7bbf9f48c6400ab9306870a0f08e88fc95e3aa9ae5afa283080211c31084e087af01dcc1ab2502b890259de0f241431569d457f8da1054007f5591bc4ef0b372dd6641d88b2c11de2c1b9f15d9edfed81e22a4a6703562b7f3fff0bbb796bef76499545464c0045b47266150c45240ad99aaa7f43feddbef2eb8c6cbd3d4fdbebd3c171fa39c1a99e9db715b775bbb5dc3110aa46d34853162a9cf1277df8c8fffde727a465b1142e8c5a2d5001137e3bfeece6c0dde14724e5f8fffe68c02846f638bd13121f965167d68eb7ce9dda994c92678c4d117a19054c31b143f89242b02adfb04c2901dffff5dc26462b9feacaf9f0bb5e59d201ebd0d6a9086240c9dc720d9161b86e27739baf6bcfc78a57d6b15d996848b8547a7c71b3837e8fef5d171ade4b5fb69b1d3715f2ec07bcb96dd11bf45d45996141b4382a02e1828c18d2ae8c5c8bfa808d170e9fbd8639a2caedabbf987566cc923497fe07d440494520c56291141cb5670c0f7befef68f2e28923020b3c141aa20caa87b2dd9241a3772e4e565643837062802c6d249604557eac122ffb1d4df5a7c625b31d66342e460d0bab755b882a133e4250e873648066052851d4fe91bdb4f0b40b124e443a935a1ae75e93a7bd1e1a4ee20f9217cd35fe360c18b7fbe85664cff60a0248175360089652dd0e186b57cfb650ed7563b6fe2014fd4e50ff7f10e0a579daaa9dc03e03268e714b7b2f30ed27b36092d6d87e32a7fb4ce51b741605bf5054dd465a69c162ba4a6ee7e75001c01f2a33836a8cf140dd3e8c967c4ec2c4e09455b37228b8f64ea740160858f259ab6f5aa5fe493c6829358f2d89c183d1f5df1fc09e17a26c078c88f8295c5e0214b85e66946bb7b21947bdc2082ff0507f1fff8dada5556bdb3e5de73f6695e357709365cabc8c57a80c87fd928a0ba1b5621d1c4196eb25a9cb8bfb66f263c66e69817d3e9979eb9d212b64147929c5845b4c589081353ae6800b3d5270adf1f556afc70e732d20bca8f2bd0ed6af94fee0d5c6555284773870829cebc6d6720d4efa204f52f8a044c67dd02730a90fba6adc2370cabe47cdf4d9e8b3cb0019bd507eb0ac4dc966242420cab04a27c350984ba044fac7b4a326e3329fcd12adf6b90e3367137d1dfd6f4deb089a75679eac589c84cc3544c2640b51a70c9530b2cf3e0d3e657c741fd91541becb1b22020c9301937a57237fd32075123d5b2db03afa65ed99aa744a95b282173bb015a4c2849e67158c5d96da26067807ff5f2585adcb5d19a435ad5e2264427e7a29adfde22579ffe816c7a33a30e2892a47f2a2fe25b7e24c8c39f1d5efb9d9e532728e4eb3e8713005169d87dc06d2b261106315f61d06af8ccf8e6cb998c7c3eace6ca4f7e3f617a1a0fc4b03776882258e027427002a29f92a7b80fb72785e585030de6ef5eedec92138ed89cfc253f9c99a5ff37c08edf8c48183f2044d5b9c599a8241c40c35d5e58a1c1f6bce3bbb9babd898a1eecdaf0d6dab067a5d6d45210aa6b397d97045f1720bc7d06c049ec39a23ebea3e5f917a90ee9651f4d79840077b43cc2f16a08a33b0091ff05667442ee1f8b9ec6289e7401077ee0ec17891bc72d94abeac1e2d551af5ffa4b6584614b74d30038853b255bd72aee053d24276edabfc8ae6332723d76546434b4dbf5d88903620799cc8acb867ff50b3bd5e277bb8286a161fcd2b664731807bd663fb3d8046f53ac69aa817c94778bcb978e6abf4a18bf60735c1bdbe757d576154471f91efc8da6986ac8e9da02799addd6d7098afecbe5ce77bdf709d54d3ae907ebaacf3f16cf0d4a2cd4a4f5f229a6a9a0a24a3e08b6ccbb67c57fa92d1287b3f5dd6475f5bdddb77ecbfa5d8122522ee8d03228f1478dd10abd56db7fddd9c0e1db63a1404a4259ce7d06f7c0968b411f0f14274b1b2e8eca8fe84b7762e6ad56f4c81a5a722cb872cd55ce95bad6f4ca97dc1e0b2ed94f1b140f87c4973ff5e5450f0bba71c4f3036dbe4f2b8047c0de550b47607e8948be3e57061bb2aacda0afa3694154e5e943903011e9bd9d667421f65ad327ca769311d93b86473aa5d5d3c068290f2cf36e2d2ae288bf53e8f245b235193266bfd697daf461be08f5f78aead6b74d923991e949e7d3298246093142d03fa9db8ff4a342bc2aceedb3c53a85d47586184c7fc109dc13d8fbcd8aba313b48f7856eaa553a25969ab87b5a853eca6dcf403cd963e414a0f788899a000542e0c175d7e94ee032d7e4ba16e7fb33127cae2663c0fa926a3419501694aeb348b3c508f3cbdf86bd11fc8cd6e42e4cc0280ab4baa9db2850bfae196b248445fbcd99641eda7194bcf84c401a169166b7fb21ded2fabf74af40a4dda02b2390f03af93261c22e68022b048e259b205777d79dc0ae9fe69e784e6458c8c54292f79106e7d97b33169bc0b1b05c9e7ee6decae28be78faf4f217610530a6865a2789a13cabf2226a8101d3c2b7893b46f5539d072282e6bc63bb433cf64987f1af736b583e030a2f374a4d7d0b152eb0324bfe20bf304f4b8cb2ae1117946ebe7cca438cb7677a97a564d8afa34e07ffd50149ee9caf703a4bf44b9b274aaec92cf6825a3afcb1d7820ec3a02bf7de36bbb85015b3b1b331d7aa5139924f22c081b30ad37265df38447ef780673935da0845330837e939455ab454801c2eb1a085909cb3948af6948add75108c1f1b0135919744eb927a0a2024eb9a50967c4def7180cc541595c83dc69e67e71bebfc691b3ccc26e9eef371c11e4db3d8a1e2c80e7be322f5f6cc59cb4dafec7f918a5973d5b0c4aecec55d85af03eb6b8af41472148fb7dffa6b54f0c3d1630565d5abc03ccd8ca8dc358a1f26995f69cc17f27c2ec43ec836c02e2e626ed5488fccdd3bee05f01e4308ee72b6ba650f9b548661eb0f056c1cf3b9f1339a4a48058d90b2d7aa235e803bb614f216bc41c767ce28e4b792cb2deb529b49371fea0fe2010677d4c0396315e8d04ac0fb0350f3462caf3a8da641dc5cffe2ecf476641ea4ad48d60d8517235425656da0018300489eb6ea8c06d8eb0ee6690acc17cdcf91318620019a427e3fc43a817808ad75d5015f9d51b67e5bbd8e3cdfe65f610fe8ae342bded62fe9c0150d05a08a5a6199ac7da866c445eba225485163c04e70e858834406190d942fb327fea41f283db74c1fa853044466535273bc651431cf21f3795c3849379d29eb72c916fe228a295f9ec6ec8d2b8b6cadd8644715fb83c559f72704d0969ea842d6668d88b96865b909813239eec2ce42d1057ae56eb8bcf8ff34a6190cda52ec6ade28be3b0e1203db2176297257a313cf47b98826e507515ccadb16ecd6b7557e29a4c6eb39bc37fd6b253f561cba930727b2662cb7707a87ac7ebd8c826f9c64495a6a9e0b90262330b5a3c6bb542bee947fca23e09c9ded21e286e12523131b760798ebdd4df26dc69f3f61194ab87ede3a6501931e777ad0fbef27c25fc1ba8ea3e3ee05e19463a651432a7d880b58a165cb53af35da774e5cf8a3a6b1e0ba356e00989a395735972ba190786168a65922f41bdd922bbc80dca86c51f15f0343284a8ba54c5b5632779282b7b608ded207bd351b94e42820ae8648edd960cf75813f925f681362b2470f922f13974505db655082201379002f209afef9bb5f90f4019c5a5cc75248c658295ff8b6502aa210773e7fda5ff277875c11cf7a7d47a7d64dbb4f1308715671cf8e2b7aca115347290144edf65a21d12f7a655bccaf66a923e481661d0554a07c469bebcf01d676036eb1177dda2096757c2551ed12848620349c8410fde9f1fe6889869aab356df743c0b5649cf4747d678f03715629220fbbad05b823a6b26ea702bc1aff9be014455039b22a8a8cc17c884c9a5eb750520564d30931fbf7b23e507162e72ae7e11ee6a8aade6f0233b182b9f016e48d456196b03107d8171631fd7ddf39d77f43d5bf1dd248e980969b390ea30a99752d40c3aef70bd82dea6d3c2e66622b06f671f7443a2a70b3f021f7c2b9b6064bb894b1b576d855983d99f9c40b963ec395fae1df20d904cd02b8527e1900fc760e51020023b9d67b9f65a2f4d0963c5c37efd645de2a7202d74026a1557754fe726620a020b8da3df4b1c2661c52915d90d312de233d520b5de503bf52543b1374e8a7f8e92b1a0b5adde13705e42ab8af8475a88ab832a61672d01db9531486ab350f3f46049f511d03ac786dc94b40465d73b57166b013d40d463737e0164e0f481701904ff545bd1056acec4a162c7f6aaeab2c34c398805b0b3b94310b05d28e4a9e4bb2e35c00e8574e8a6a519b6833534282fdbcfffe58bb8b924b2469d3f39bca0dcbb9d318ff0b4948dee60aecd482ca7ab8ae13168db23fa206a5dba0ee090bb2bc4727d930807e7de140df5674caa27edc00276d56b6a1638cd9e305c7033ee158ff9df8aec74200e7fde2724ae6c2c41e0d8e986d93aff9f1f1aa2c693113e8a494bb67486add207667be2ec9d43211de702436eca09c2cda757e4e6d288cddb2b0cdb475210c74bcb885d69d8c90c3d7a0c3196bad4f5c495c52f4348b821909ef6180ddef7f6d9e8829dc917e8f350000cf89093ce242154e3bc73f0920fb116bcb0143c45cca509a04308c6a7269985cab8b6f1f24879a3cf4f019ba66ff4d98a29b1045bacbc4ee512935f59508db3f42401d71181fa2415b0c8656a72742fd4180f01527417130b0fefed9e5b1daed7f50999b7482a0b0f2a5c4e50bb05cae476625e52363427aa6ce948b62986b4cd46950ae23adb85c5e4c1b8f0e164a13174d95d2a27dba091a38f292a4713229b7ca377ac3f12c5aec30fd61ff6e74965951b84e8e6a8da3da82a50353b4328021df8406289c27ed07587711820ea75b7791dd6343dc40511458fee9ae2676750ded0bc5d76305ebc359c2d10f7d10002122787812789ba5dd0a2bae05bda7adffd0178e8cae8b8e56b21bc170be1cb3c91266fdbec0ece4ae7086053fc8bb927acaccd3b4a2b4a299a2488747e8e1ac2882632701d17745e14998315574ffda895868adf409fbf28ba0642186081924b7c21bc708e68afb383a8afad596295a3726f052a0035023ce57dd21f45bdd6a378f8a8ff3b90dec5751130960cd46bd170722624487246d283abe06afd4abc62a4f9f9e57ae90af45231c022cec9a53bc03b7cd1fb7304204a0adaaa5f05ced576b54e8bbc62607ef709d0c82bcd16f42764ba8a302e380ee783d3f19e012ce4ab2ac381e739403a5607b38410b193ec4367e14f718a1b91b8c71b125fc5572d1cc48dd6f2a9de69b465f935907fe24e3d7188475ab44ffdf489dd3328dd95080c286ab14d579356afdd19651f027e846f352182c007ee03427fb2981e1a2602e8e5d046407c28a8cce1801c3144acd148682655e5406733a989fc1a5b38c9876c266ab2d0c5275e3ea9618da20e7f47b5dcb14030fccccb186a90b07e1604c373ec8c22ebff7183273b5cfdabcbff12d939fde45c382e28067d2506170020615f1ef019e37f054a210943d997b066bde1923210203418632dabff344e8610ef5af5349a44280eb3f1d0466fe18b33ec759c4e54e01162c74d9b86292f535d78519a709dcad3185795c905989088f2a26dd9b81ee04c12d997ba04b0462b2dbb18a3991d8617f71a443934ccb53d57bbc0c651cddaaf4811643585fa55ab75b2f236e369d4cfab578d29d62e9c87fa64dfc2152cbf8cf3e06ffebb35406338af5d97f82221c315491fbb0911d799bee2447bcd3993f77caa63b299f476caf64bda103f4d4c8e4adf09c0b2f35873e7f8cfc3463decdf64fda4284b583aa466f889ddaac15f0539678088f6d1246f963589c35c86572d9e9a7ac6c73647c77fd18658663b8fea6ee721cfc532ba7dcda5c231462adce1cf7b77f73f91c1194857459113c872bc7a209ec8a7707f96f5ef1279ccc67796d3ad8e1e42d2c32c5b96809fdc0be412a7bcff79e15c6f52f9875062fa5fcf0d4b67d58b788ecb9dbc602a6e8108d3b5d7f37f699fd99217125c91d0dde055e43b83b99f2c8095a6a261687e17999ac5794182c0f1a4679bfb9d11bda35d1259f194deaefd401b2e1e6bbbf8f277bfce1983055d94ea57015b3f759ae59e24c44a511131611a9b5a829ccc2b03d3f7198819f1cd5cf254184a5a94947f070a91d6089dcf28aa8636bdc691792b4e70955dd6825420a488827bdd7f0284de4e5c1aadb21d470f9cb1960731d7e91e6280abaf3a20cb922367e167676c2d25e533e67d27042706d6651e513e24ca1a60e58198e8181c2decb8256ffbee71a318c79bd5a3affbf26b92ac333048baf02246703e71e2f0c39ea1cddf01832d561e657ab079368cc1e4fa5f203a9e850cc14d1cd9392f4870530c6e54af919eb2cb60b498f8364b79efe2b267680e2bb48baa25b8b86815ba8687ccb11c8dbe17e603b8d4be9351fc77feba9c2d9d6d6afd5c0f2aa9fc8299a0a5b6ed0bc79a27b3de767bbe6dce90c53f556e4c7f896ae9a39c230762634ea05766a12cb6cc8f94a393effe3e424b6f768681a56d307e4094d5c421e3f3fbae2cf68ea9ed65703afa82c5e1fc2635f721def66cc4ed7671b36366740d4e5be2f85546ca94644570a1bf8c3cd2069772385f512046a0e40b9feb60cc2154ac24087a7313d6481e99aed413bcbc751c3edc52227cc19b3ea89e87d02fe2ee4213d8053d7ba0f6f5e2e106678dbf0e9d8ac3fd1f45d006cd78a3450fb8c12834e7eba047fcdcc5292e49b65517a3850a4fbfa198de1eee2eb7a538d109ec6724f3e259e4db7873812c28f63403c878be64aba4b4902638fff14c91f3edfb3213c96d0d6ecad0705a3129d84e2be9643b147a7a1449372c65f1a4ca0e4f5b88cc5cc7ad20747a0bcb99b2d767b29f45ded91d6d2db43d7694d2dedc746870430aaf40868d1f4f300019f0d7c6f3da2dbd6c21b4132640c547c7b4e5d0dd1f73840db048a7e92d990d7ac63a7caf6bcf57bc3e722b1b9b0ab95383680c5d1933bf3467aeec800b725d046e0c4b9bcc02140732b0183639e9cb5e805965e0133bcbe85cda46bd2e26132524fa30f2257585d9e784716cf6a91ed7ae020ac999174b44b65c1a808dfa3775af58ec135cbb35c44db719dbc40ecc133897ae76e66597be141a8c6df7e7acea362416a63873d9e2e25999153466aaa6745c32c580e0ccca2dbc88dab49269a0da610c8e33e8cd7d6a5bb2c4701d194054b54f9270c92f5cce2cec9c3ac0cf1c409dc3dbda4a68e9d8825ec0a6b4160f185acb5345fe2579dba64cd80ce411ec7c30f4f54d2789e5053c91617a790632ebe1d2671f216e7bfc9a5ed4714561f34441c288cbf0cb8013f2e313d8d52e5d96877f814a6d6b10dfa4702a8ad6427710be916776ea0df2c65d7870c7ad6a4f5ad8b3dd5b5da509b0155ea85b6f81d1b321e0c97aca6ea2efbaba74617334e026db2e8ac7d4878174f050659c2be1cc90c9b20ae8bb9050c16f6e5630ea20a6a4a5d5135dff66d79b3efbb77e220f19e95130b1ff4873086b002d927d7d8f0ba0f67b48ec99c89ff224af17379dba0af8599acddf2d1bf83ed4adc4514c08cb1e807b1d8a554ba7d276997876d51e02f48c985efa499d8c5d0538e1530e75f13473fcd3aaad601fcdd041d118ce69a78316e3c7ce2c8f8eee71e53572b565e597713f07c554af4a4990bf81f30ef6dd9a3b41b6e0bae6ed99d1bd108d0eb712a303ee62f95953c0486f321117ed42d3b0c6c91a297dcdf3d32067349ba4af5a5a6bcde65589e1895e28d973bc6e46092e06dafaa4c30c0a98f06e94ee9733b7ef140eefa9009d9a0b157d8ace0e7c0210afaac1b3becdfc579aea669ca9107e3c4b18c6de5a0646df4246cf593f7bb8c65bc626fe530dbeccd2b6119f022113cd1bc164795aeb3bbcecc5a05594cf6b9423ace74324fa711d0209431e7a787b34eff4c14524d54962b2eb1180ea7c6850e9a93500dd00bf6bd19000edc3389907f6fd1ed0ee0e86fbd7d01b46ac0b5449012780dd56223b1228427d701c4ac613381ad9008a4a591734fdfb046af031665d2e6bcfd46de85a461d1d6ed0d78f794f6cd068895d5d9be36655a06872306a3db6b27852f800947ad88dc5889ea2ecd6d82df21ae55ca3f2aaf99bd873901ce22390d1d11209a5b8f1bb2f8d5f38b4483fef773d917e7b7105f32dc19a395883ba7f62cc62b259a091fa06342f6a38dcfdad3a3dba06458fe190f75776d86aa00af940df6df3d1cba690230254e58421f93851fcb8a26c8b2089e7255db2da7f06fb11f37d18334b195ecc1edc6e05d02082763ad030e7bd9573d4a17e3af6d6aa8b0a0f568595c1b82de784e1fa6dd37fee1c43c4d983467b9b70018b0fc2c9242a05e435feab1add4882fa68decb2899c8889db3ccdcf30e2d0915b20a3a568c6d8ad564782c05871a13fdb3a4e4f64efbdc33ebb7da6800ce20c8c4773f38ae22d422902338dc205c87b2ec20556d467aebf6947d231017386f87deaf0f823e9aecd5949cb216e7e7ad128b6083c9c5858fd287229beccd957cf970596d6d350f7862d281d1044901985aa19f2e0c27b64fb5962464cd303bba76046e517b5320ff9507d94a76431fd394fe6bc6a536a8e54f34fcff91039bc582a8f4c8032cddbbec17c1dd7c91e9938ce874eee05279df1ee081c8b40cafbad4378d7a11303200c1d2d5bf54355b1a4ba5fd1ae2f95eb51ee6f54f0ce86aa7c5fcab1a701da0c2669ec2de9c9999e950b42dffda8fe802caff8dedfd54296abe5057afec8fd612d52e9896ceaf2a24220f87b064e8bb9eb2c2e1fe0cc584680b3db63c4c7381edcbca69d63692a4eb588bedf0c5fcf7ec5992f845a712428c368b32a2b4cffbf18847c4882b950f2b3b7c411ed4b3d1072302be7911f88cb8cbf27d43521e815813016e1b90f3928d6e6af52e265ad5bc33de8399677692fce9486427c2b2c9f4e7bf34b2943fa63f5e11957e189dbe59ea741858fb22f1ee6375397dec22a7c3678e86189896f996b230c520f15e8421ca5a237fa7d499ad54fc3655269e5ee26549ca64f65b8f0d1a68bcf1f5cd71eca518ec3ae8ba75ae52443b5339a816b04b10b4f01c8b68a311c0a5fa36d11d65b441a8ece463e57ce65f1d3c3b0c938c8c8049870809255d8b1f10d911ee29d41576f2df0468865b78f1ef9bf4faca0a2acab6cde8937f1437f1cb2943ff93ced5f4bf7242c01e599f8d2b73947bcb00227f75c3ab6d3a3d4b75d04ec60ec53c5a780dfb187ab7bdf1b48411bb1ae8aa50135e4fa7a5a5e3a30f98adcb9b235099874a695568be24a316d7701e0dc440fb383ff475d03d1cd6d27540ca027502730a057365c29c27d4665cf55c7c65a0fc156147297c98f476b9580477a8b24488c1118d05c149fad0b0704d2b68cad3278f526ef16eb46877ae29d7c4103d00ff8ea447fd05cd659445c98d79e761445f2fb6058df6cff5c2f25d1f9711724d8c7e0e1ff2816aa1455232a45966d7d44c8d9e721349473860b65d134c6324fe578bc577c2ddc5db1b75094b3057f9d6736510307a86d7352b81eb2a73326155767dd8205414a63693789e144af5e311aebfc93645646599cf6c27d8c69a597d8beb3118ea18296cab6a80e6fc5e2cd1034c5d9fb17348e111236a08180c9ae5029453383cea98a80e93c9d6c668240d6be6c8ad7798c1ef390512161a18dd11425ac955c4f68e64adc07f63c1ddf7f74ac05384d9a6b5ec50d60afd428518e60da96b4bd036cd0b25d819b5e7c3a2c1b4a760755d52e9e9fa4a57970345a9313bec4770200e56b515a532cad81f99fe55afcb6b156faee0d22d3da5e954f47f84d8c2151ba0b65b907de350d3626902281a6f4a23d35f7b62d94d3e6dbbdf114b9578d8bf5958d5549b2d6cfe6ef3cbfffd9041cfb0ad737ff0355578e9473c95424beb9684089ce121731f8692732b8becab8b8f8ea1ce8c7325b21a5a98fbb5504bdc79a4e8ac9ab87adcc19c497b13707b5ea6306ca77e0a6d72a1532c3d3619cc7b0cb041e12a1310d5e975f1219b2ef07192ed66699f5d66ba4884daecc36a6ce710d2a0981df784ceeeeb73373003510acef95272ae3aff3eb65790c17cf70445de08f3432ed7255616c2e7bb6c261b33f61c2208aa913e045eb1a3d14255b3baabf83a9db756a8221494ae6d50b4ee4758ba08b16ed55617775f95be9f25dd4580c5b9e57675ff021603611dd2aad7923a3b61af8bbbe618bfec2e96c9380fdc5adf192b3ab83a1e83f3ee73f428154d1c4515eb7ea0c504c818504f17661808890227d5626bc6fca4556e33f4aa2d6cb67fd384934eeb93c353630ec74b16071e54e0510fa26cfc2e894e088153aa93a6e1064856e89b618862dafc2a1b88ac9a3dad222468e6091fdb27a67f14ad3fa2c1f043990f6202a41a76a3236cdd1265bb1e89b78f95307898dfe3a85262035a3874d47fac1a2f9b1436b2384df3e72d2bf11890c1b9baea8a8ea04a7f5d5ea5ee5388a716b8e264f85e1deeaefaef94a755de00ae1eb3435aaff37f532bcf2389e47657bea896f2756beee3a93c1a67f48ac2aede8924405dbe028282e72202858583c5b2409367682db27007517b5a1324c43910316b522ab44c2378b1590e87f8b40c3779806a638b4a0b6d2e081a530a5bec5b8a63dd72cb55ea4c2385019c137456734f7ef8e8ead9605fcbb4e2bc2f5c996c464133193e0e96b9e29e4bf92ee8e041f02b3edfbee83b9d8e311316d1f96eb93701d83bb79ab76bf8758d6a990ce1df16d15e8dbcae75c61aead833c839f34c8cda86fa1a85d91192be4a58172ba9ed651e1f1efb683fd235b29973bee64e3bb15c63fe90a715c725a4f35d990f7d6f0815b8ddad40ee2c031c506fb955f24f6f9baa45844a0f2e7519bff35d544c0d2b93a31a50aa2b26ff0037f12254edcb8963184571f356b6719a47c5a6a1a50059769153bab5edc788a033d97d7243a72950f1b773da1c636abb6c2d6202fa986631dc7eeae11c7b936bf9faaa734474c1f1f96e7574c466c6a55ad75e3955d46b00b2cf07bd5c924ce1481ea895bbfa19ff33a0010baaa74e9a482cd3b6596a9bfc80bdb3ef4a93f7aa72dfdb94f237e56b45eba4f69558d003b06b4e61ae208c0984d2ad38cd5a2b3f9db0c17586727bbb6b3343a0fd64c344a45c4782d9f2fd63dd8bd3bbc797d905874449003d993ae12ea30ac0ffd186c632dde127e74dff78c6859ab4d0a0f63725456a1b1d6eb7d9a3a944c5527adf8472ca3269c0d4d96d3c2261d33cf30a8b27af7defdbb0fb5e036ea2ceb199aea85acfd4a0d5da118585a2f7d4892c845bd2e619360f610c13524e0f9f96dc3b8d83f94200bfb78267fe9e66023965519a3cdd06a968db762c73ac9bb0a40df3688ad5a4669d363c25f7c9d4ff19469d6a9d90630a18bfdf04b5d1b27b18ffbdb3fe8005e95396634d01e0d9ba6a42a35c1cec8987398916be340ef7cff7ef55818247e20e3a579c435b6d3c7ff83d170ff855f229acd555d188885fb656b017fcde28f8296d30b45a18eee8517022b16bf2318fe723ee18e2a07bddedfab28765ad132e95db37a6d02ca433993e81b2238a5c40dc7f1ff880d439ef08f9ac44376bf2b6e2eaa9b047c2f1912a80e1670ae2339f0d5112de7c43fd2a92e7206a1aace7f34b4e039db22d09db57a01a5788fcccf1d27e81e7a08de28e2eb717021ff33fcccc8fb8e96b1955f769bfce75f195fe314b2d2393a5a5b1211a6ac5ba9728caeaaa172cb4afb16d41ca1c30c5465b957962fc0190af802241e99e27334bdd16ba7a8db96e526fdd23f244cdb3bef9f10f2a5e90b4953c19bc1e6c635ec1372499830f58768fddb162d9d0d2db5f4737763826f9335f816d4749a1c788ee9ea22f277e3aaf3d49ec161e63a6f6345fef97dd138e71f0fdbd0f20a29e123e58b177eab1900a0e292d792651f248e5ecd87a968f3726ce158b748bb136d0689b40a1edba7fd29fda6bf451d58610fece617af125c53660c9751761deeeb3744f422a112340b6c1ab0c6f828a7509208b621551106dbe14b028e9ed8477f08e8f14ba808b906a911619cdb65aead21d730220c86b113af064900c87466210dbce4b39a1541bfa66c2bd4174af44c0650291cab93e033dc06f05c2d8e711c66aab64faa64387998516e69a92c3491f55a9e143c4bc32cc8070cfd1df2268f553e9c54e8909d6fd9cf2f34c77f21f68f90ab93d8b5c220050497616e47f4ef256f0cbe69204c4c77191c77dbbf73892f3d6726968debe40a6d0baa7824a683607187cc7b8fd8b18c73ad550c19476b067f97de82773985b9b64a1dadb436e753088981e8ddf9b26be72e5754059c528d99a8d1b1d04bc0abe057a6b24fa88aea1158254bd0485998fec2e82a65060742d8b79757605d8859e7195317a44230d14622c3745731229313b7dabcd46ae9b59ad7cdf68070830a472dd59057fb70ed68f8a9e0cf4e7e730133e0b43fff69ec63ea969c92818e98fac602cd3e4d36245accea380b1050523cc41194f5a18c090794152dc8393502a0ce55d28e434370d587dfea556c72849c5a6c9ac0006c504bc9f4bfa10c3ccdaca06cf0a908a848c4afa1cbeaa631a5660c4e3fc1f7b771a177e00ca6e21939dc5c89406ada4f576acd91cc869acd705a5efd3910062e2ac4970ae82c747641414012b60be0727fe103d1bf0ecbfb6ed2db211a69b428315ebfa7ce4c3fb470a64d12bf17002234a0cdc92c7987636d3e8245705f500c770fef71833d9463822572b574f47ec11e04dba2346eba21ca82e25b86e06cdab36beb25bbc18bcbd52067d05bf9e088151b70ce864fa4488e06e235a8032fa345cce803d969db67b008ce56b52b450262246d7e659a9d5a587ab40dfc6a8c0c5f0fb351bbc16365509665e45e04308f5784622abad52cd116a2fefeeab646d0859ec3d897bb0427cf66c33643e187e23924ae0d3a7e2f9a92ab118819ce9d3b6156e965e8e9bcc4d31fb0af5a0457837378a5a79aa29195c9dbd510f0fb68afd8293f49675a588715881fd63b42c14e1ca73c39d6211416199d4a5db3278523829a2fda1b24fc6fae3dc1d33bc27df3cf88704c80bded673838791c2da64c9f60602cf076faabae3df451f61e720f74d47df62b2a72a74403c2565ee4671bc1f2da92697f577f2bda642831590fe9a990515a64d7c7705d14085915e685b83b9125efa50e0f9c00d559f499dee7a3bf52a6bf4a820c4dd72f86719a1d6fdc521de9700a1d5d34fc4b8049e983b472b566a3f176b0aae6cb7daeb82a3d38f161ff44ee811ec1b6218ce95afeee2e04de7cdf4842170e8ac6940e536436d09854756942f76e38162744663f5c17451b6160c1344d50c8c548541b01cc421b7b2d31bd2eddcea991f8862532a7560c3dbcfdd0e2fa9de771458fad594c7c365c8347a826a9ef93a9329e41862b09d6f63db9b293f0bfb16ca78679e6ae056681fe6d5e9753105103a8ac246f55be07698815c7aa9bd7342fc9330b3923c36ff9dc89424ed9a981d1e120ef5238f998f514aaa86aa95c6078fd621196bfa264736f8ebd99bb2b70f997f749170a81582bad69029e8f2198b1089e0104fa741aed9daba2a17fc87f953ace4ebca4415b49f33878210268f35ba1e65e613055d8a85fcc7a3d2e52f8a46bc56fa404bc3600dad49b607e059ac9f5402da622a2f78742655140d526c1b18133891bce06e9682909285dc397f1a2260e5c9b74867b1ee992dcca062dddf40727870ac75e9083fb36fcc452c98c3bc73631222d11e19188881ab654e0b90a3cb94848594754f2402b92f0f4a50e876225ff9c39dea99b6b4ebe91da6da3989130aba3133b220f3d45e86034ff7392f290af29ea4e63d66dd00503b5e0ef5c2ff3e69526ec1fed08ed1979e0e074c26917ed2573522cd2823cd389855eb3036f49a887e814f5500d5a20bd8b15f0bb2ba8f5e36cbefb4b2db123d3f0730fc25ff08db655d84e2d8ca975d40ebb92c791be5f8e513729490a3c3dc91f716f2a447cf71389b23ebb184594ec03e72db6686c5cf803a9fac646282e8340d643e4128b4de947f956d819998cdc495b6cc76f34407f454f3824219d770e02d00ef2f6c62da975eca6ee4b1b2b98834adad8dcb45c31404e0969738cfdce1cc4d3f8cdb824189e56f84c3da16816982c712fd8217525ffda9a1725f195dac6ed3b8caa6adfe26fbdf07fd3061fcc34a31982fe8f574df4f3533eb35dd1463d0a02db54dafeca3a22f8eec5243c41466ed587e00e651571a9971ab1dad6d844157737c53bf7ce765207ba1e17ed1380708330829312d230f657b943156de89e1532e0ac0ba5143cc8bf97bdd37bf2dbc36fdbddb2ac53cc27fba8a3dd8a9095f93c1decf181e9cc1a6f3dd710d9b110de21535e2ce8f745d755fe9ef508797683503e1b74a3de06ffdfac737b0cac1fc51a12644409388071bba4172f4f9e1346f1460478ede1f2d71a9eec3d05ffcc537558c5eeab01c54f672f83da167d3fb17f1d2596223938d7771d73d684191d8e9ae649c9761f3f60c0286c859cf1552e8de2323cbc6ea8ada4608b3d1e41de057cc52ee64296805e392aef08dbeab24c08ae909fb493b4cb7fc78b5c83611d4f0661a3668222fa9bcfdd3de8a9cb37fe1150db7facb4f131ebf720d49a82ae84bd5d4de5eff087586a681dffd8f4c8e38ddb60b916049ad1f805c81218b8a7dcb5fec4b0d044e1aa9ca26980a37ccfa9bfb0a3a753060d7d12a457bb8f3ae54c5aa517d653fd2bf98bf38c441489b9748776db57e6ff4b68ff68765b429f863fb3f044fbd7d26601fd970b68351c785d0ff1718b2d017c39e9531f7217d16d571f46c10922b4fd71c99df9392562fffdfbec858a4a2e69a9c2d823c68282c244b019f6a8cee23a1240e2807a6abac90d728669c61f4d01b4b1e9a40c4e4d6fa99d20c088884dce7a31f05fe921c7530e83eb234c9136d4585fa49bdf809aa40d80b4f07bcd2d4d5eabb06724dfc59e07d359ef0671839beb4e845304e1b953e44512ca624c1eaf61a47ffdd55a57ae54897fbbd2c0b0aef49e3dec01c545b49f14cc87e525b6d1841a5c9c3348a40d80de97aa5e34028ca1d5add907330dc3d587b9d3fe9934f21a669950cceb7e4830d99392df1c9d57c59aa262248643bd7400ee4f56ecef3653c3ad3ba74dba71240c607e9228b15569819023cb13a2a707f6c0106b89092651547813b220719b4067e02c0fa00770ed42b68bab8b7dc70a7cc01e8eb6602ed51d9fa27fb95f62aa6d8b8f6a0bfdb7b80d935ed70b8e29506d7af6ac56dc1e75c0734556aec560f562a64e2969bcdb79c9083439234e1b74ef6409ec8debaa64f0236e8efa7cb95f41044402618eb3f772fdf75a3c62b16140d33b114e8ceacdedd82341bf15901e8bd1fe701c32b871f1d0697c2a6f42e7ffcf64be153edbb97fcf7c46fbce8fba48674018af80899007879cf9d223e85a67ead27b6c06db8833602884d435647cc65780f4380f69e6411778012dff044f2180c592e51331fbe265e98b4c0e3ee9e2e7695e2c1fbcff04ef389c1189b956b3d1f2b7b39b83c9c26e138a7ae9544f00f05add61ef8e031d54ed0196496cdaab3b018617455dcd7baa1184a4765e62ebafe5c9e36b0ce47000f940eac74afc05430fc832d5b1b91096e0e6d12d1ae8487950c09b4d081fbb019634f63ec28c75bf2d940ad5526392fc9265b16bc8745c3417e34bf6790e6aa24dcb2e83070f8d52df35c29a7799e401cd27ec77af373aab68ed7db8f9c809e37f9d5dca8fcdef869de858763f8e15934a48403896d7b537a51552c64592d9d5e0d354a396fe0167556274c127cf09c656a3fc834b5fa0e8e6bf57b5c1db6e00f65dc9709cf8c816e72d023995cd7e6854f5b724203a27737400da60f1d487c19e78cd27e376ed00a8d5b95651f7a53c38495d926940664d4fee49f7018c6f9b8884a5e7f2ed1173e0ddc957065fda270db7e761ffd37e1fa9c5b02a3e9e952db62cf13d14f0ee194c8f393dc6f432e67172672fc00cc65069da53cf9b783b9a01dd628fdaa1e7a99c91c959834ef3ab14292a850cf5dbd6aa5af4ae2d28590f94887f2a953e0825f6555df097001d7c3db120e34ad6bd9439e154faafba1b2c6fc020ffddaca09b715137fd3d86a3e14408dc92619525881ad8ee8dff2e9f06e519b3d20d23edf89b07928315ba042719a1bb653f1fc8bb03ab01329ff5c5a71ee56a0ec4db7e69f4e45fa0a4de471ebc0227d456e54475dfc96519350150ed9633e9f165da562d71e93b32d236a509c3b6ec351a6ad85d4c7bcd250b6793e49c2e0b0a98bfe433f922d51d6a2e583bd78720f584dd23751d7f5de3908f78dad4bddd48c7ad5bb4ebf75e159d125e91361013ae92c99b75da80c7c0d5f69b8fb67def00a23d0f119741d0507f5a230833983c28c4ce6ff23b5a50c4107db7390c067b539b82cab8c036fbd3897f613db24435f5a170fddeb1256ce11c47b53d788023566b1f53652126c8b61566afe2ad95144c30f21f60dd20da1df82e0ed8ec8e3d528b6a8a0ae4001d63e55586cdb134d2687f42efbf175f6ae844c4553b2f82de04bca2de052cb53be39d82bd886113825020f9bf1ce84bd75ec7dc15075fe02bb48033fea18d58a12a4424be09f2d9855ca76276f490fd5cc3ebb45b5b6a3ba5439e09ffce8e22b0bac71ff271aea50d582d9d7efd8157f80d3fa098379357622ea1f76b032e37ae23763f2f937117824cd0c4fbd6e1fc7758f449b845f3a17f735a2aea965c41e3a985fb20442fb2b152313000fa0c13c9df61858eacf6f6320e5aad688b7edddec58dd2f26f6c89dbdff4bce0fd11d4297880aefe06dab8428879ff0ba6ebd3314e0832bd32c23ff10e432cf5b130f12b9d6e9a7e273336d99252b747ed712324d8d8ee76425f55aa574c8f57c762c5b0b9ee17d7e16a60ee56c437d81dd0db3144c04d6d5a84c642febec374c5d15749dfe7ff43af39d2c15b72748e6c3cc8587ae99b845d07fafe47500080cc5b2ea4e7e2d555a330261f7744c61ff7dfe980115f57c369d2ffce293b711b3913f0f2e58df836d2349d6638e4cf6b9a54c289fc92e7e925611fabb7bae4c794c0d771e13a6236fbfb1494a44272ea802e6ec65ed6e5182848b683149187ed5e5df67a0d60f9b904914ebee611d133a06f8ff258e3f5c772ab66de0384b18f229745cf161971fa98d584c8cd4767d4881108eaf6552e8fabc5957a87dbc1fdfc528affa8a3b92afdfc52408da12bdf5f8184ad652d1185dd613a9724e40b133225071f02df00ed0e0eeba13c1dc5ef951ed67d404e14334f64fbb38571d3d7aad9fe2946d542372e649c7cfd7dcf8ef3bf1d181301ba6232419ee72e56599543ed06ca462e6a09bc30aa3186cb2f2adf2ac65c26713945ba83c525e4ecf7ae9e152a629fb90097c0f571470ccf7813559e4eeb4b30b7b77247ff0d32914fd2c9b7da8c58e66fc63d0be28a2e9b5f36e64ae57ca4b10da689bf231e43268350636cb575c14ed127ad1d40798c00407936d3d1074ccb25ce19b00362cc8f84b2158513b9d0294fc52aaa3fac2d16b1f9dfd2aff56d3cdf656cf466fa653771da2f846db329d6146fd8876842b9b82997545479f68224896595fa5a151589fe43d89e8d6ad657cf64175bcd7dc205b57d5358613a6186ea78c441d1312678f635da40927ae1d2bd7e502112131de1b6a2cc547e1c57cadad822e08dc8b7f8c3f65387c0b03e11523825aac2e24072c06598b14488bf3e6a8f1c0166b47e820f569dc6263edc03613e0e18f91642a374c73d4ad1a35e909ae88161cef35e946b1d96040fac4939e3629e6454dfc7a47ce81df103895c55a71104d2b99d6c2f113a2c7b41fc1c694518dbda3e45b9678cc2bfeb6917e386de282ebac723ca57acb1511b179f21ef48d65d9884d20c25774da36ef8283bfe08402292c23ba29738b4ca045c296847740a3c123a0445d85382f72a97b3c4fd621310676e0a2d7aed5c341002f4809413760591f2c3a8beb1eecabd7aa14ca82477915ba76949133bf46446a30f871dc91b83af466134dcdcc9d23d4f6a12869abdd625d063b476d6c4ce68d43524caad1e43dcaac5947932beb0b332b74604ce97d38d903e523cd6d5de6647a261ab013568dd95dc3b9e85d8b39a7f9bebf3bd326bf1e3ae4d04df1b69e9bdfdec716c90a547f769c29d934f6d64672cc6052793f0c477100bec5ff313c9cbc473f3cd5dca08fec85887881516f55c818053dc712e095aba0e1cdff55c9769d4daab9e3ec2df2e4dfdb49365ae264f6732daaf1a90dcf7cafe3b567c411457066337e05d7adfca3f8c3f8cbff443b35046f9ea0ff3e96b05daf89e60cdb84d073fd89d02adf085b38288a503ce8e5f4c17f456741ff31c9a5682efcfd22c03d1b9f6fcc12f4e8da87ab033a07cba350db474d57de34facf41c106740d6d0fb71d09addb20208de3afc20800311709d4cea058972546634e93b5baadbc9362d0d0df20a450982ebd43c02aec3d1cdce111d978df2c537d7dac41f90f08ba5703b84d0fb9d07f395a0cac6ae2ef6e2eca76ffe40909ed29cb5f79edd3d3c97c538112c239d39e870b0ef9f4634f233f04c7e721bf94edea1d5c71c1328643b6487509ed0e99abf599bcd0421dcbe3961e33410183157139635cc64482c9ef49ff263e4a0acc12d5e84cf2ff5b9fee0e2305356ada273c18a7ede411922e1d7991b3e627ed6ffb9f2c815a1ba119a098d73d5ab5505c24811d3c506a21ed431c3f90e9d3117593e79cfeb9ced9d72091758c7d5a75cec9ea96f4b078c0a98ff2ff96dbf81e5bd6d17b02da8e3291b29d29afe80ff912ecc807a001e2a3d4475b9a00917e53ae649ddb1c00e3072132474ddd9beb56a59717f9ccd27a5aeeb78f0e9f796c1e418a93bd6e66018fde4abb17b6782e9dccb3da83d1e8438936023e0b43d523d8d26b9caec42ef18dda1e4a8684724d804ba77c67e1a997e711446a001c7069fdde17960e9d753798fb2e71b5f32e0c53cff786c4aec51cd0563e2b7d9d4903e5c683c77762be8f06894407bee4f567619272e42177d97a2844eae4f13d97205e8a12be4fdf84b5b422670c02e6c0c354d4f9aa33573de200e34953458d3537ff376c0dda18fe07c57656c1825ade76db302528fc2769a9b644736aa1a867b7ae15f4b52e00a4fd789081c5e239fb6d5063400e599efc53338b5630d62455a38251a718eda12038e793cdd64ac4ea722040de1f3e17e5b849923a24699b4012e0882a7337bb6aa5a26df0013a7add054fb5c46590a70de5e65e8af0cc983a75437cabb7ef43eb8910afe494ceab0a78e1110162f583ed297bbb5f8f6e71f250a7a8c4cde5091e336e20570ac6b6a8a7db53e4a8a591542e3d2ac20602a557b8134794dd90fd0a8219007a3119be3395208137049dae339c1bbbf7c187c1549c397bd86450974c531d3b102f7b4a257493df82a3334324a7ae40a99e88df0563ea19213ce1001bd93bd23229f1595ecc33146ac64146e092c7057b4e3204e0de84bc9e3c913d0571520888b0ed78fe5efbfe1401010c790e5b247408a7926fbec94923a62ab251f8a5b7e3ad643b793008e18c58ba208fbd364c764bc24c853f135342f095df1e43f4ab120aee8e428f75b552caf6e17ec7e5e397a7c78356ae136d52f40031f388333a1a0df4e933dfb1128fa82ddd80815f08492817ac73b52b90f78ae1859f433fb911580a9ed4f431183ca3e745577c82595ed99160fe3719f7f9f87df77b169ffc24a7bff603d8d89fdc8977bd7683b8b1482ddce602688f0170b429f9e4f285692006e9c73cc26d560365fd2a08bfc3f307cb04f12e9061da3779d723572245df16c50d2b623861dc5eb70059495136ff5b9959134b52a847474f95f830098cd9cb5f0555e4f72ca07cef106d6bf9d7b6c4dd172803b2bddfbe4fbb5a9a426c6de7a3dc067c0bb7d7460de1eff487a74edfddaf23ecbfb659d8087e6264ed27c3d4b60fe43ca849d0f30e9eeeaee06a149c5a07931db9bf9eb54025ad4b1ff8a5d2ba8baa3261aaf0f64a9a39879ec384e5299d4e186f76f243eecf487c48a058b1544085f6e5b04b93619add531fb98d489a6d34c0a58e99372c5491f42ebd2d074cddb6fa4b37dfd7564989e6217870cfec7af8d4964e764f844b1bf2a69f141a9a21a9eaba162f80007e53adf3557ed7e9da50b49b155292cdfc2833f619f1c88114bcbcdd0929c4f3bef197c6803c386b96daeb4e2e3593e9ce7a3889997bbdb512fc333c191b1eab8496093fa889cc9c37cc9595b53edb03e0165d1a5d3ddde4fd51570002f8aefc220e6809d1cf9ad6b35c1a97d9a1cdbb95fbd295c86a9c146e5c6f7f1ccb59086802025a50772ce2a76e83a7cff626af87ead625940f32a2b398da027884b93c99810675440477ad72cb848ba8ccbdcf246bf959570beb0e506f5274ac154d0e857ddaf390fa53407da4d2fbc80a70616c8fb9b08b3a0615d27f6ad91cb4ab726f72c699b533132412e11f2a79bdb8ff9adec945e9fad3c52447735cec191c74952ad88f438efdf002b7cb7556c0c7366e2eb64bc09d5b807f7c52800c458188b247b00816fd05988714449f0fe1381ad1a193194e7293cbf2143d2801f4ed2d484414bda395bf482a98f95258f55dd4d49cae7894a5ca4020e62e2ba2324b4503bfce5a3e1a4b57729702de71fb67eeb2d31b46723cdc3be19a0ee72a5f98e46ca40d0476580d70b4ba2c8ba1a3bb1957d3d8c22bf06db2dfd49ed9f7257c74a44d311c370294a151566c09a5892945d5d78a6ee2f112692f3babbd3389ad7bc49153182f3e32f7d255c926636119c3c29b3fd63140e51c050419833a04ece95c78ebc4de5005df2048062e3960a0f4bc1e8d0b26ec3fc794dfba9009d3bcc865169c5460c79df6b4eb5744cf4b58b46d79d22e87d413b9814ce76b039958767313861f3d5d6747b54e0b473e3437d68f6613a42cb9b18065b106a955b18c8f485d0275b95780e702e2e2f72aa26ab8c3fd02495ddc10e8b0ca15717449eedde0a46b733b84c5348570398e8cc07aba713942fbf44e08f65d7e9ef7bd00c6928645a301dc5091f754803c4cfaf5d698d26836e2def5680b5a0bc4c3fba6640d406ceb7ee348c006cbac62ed9b616a507b4d33770fb3db8b62b1269fc59258ce4180bf7127974b9097521745f7d59733cd1d2a6df77a684cb7d6fa6e5aef3faa8e2939cf4c057c0c4d94bd8e60cecb96414441b50c2402657c91e48cdac584d5dab77d77a50d6bfaf91dfbf2d336eb4d20cc1b8d679d65168e977f6bd12ddda171bd2dd9579b2164c095a35cd593573484504e49d3412af33b82b3d234cbf0b087c0268db8a93572ca4c2686981425a9eca08cac96b635b5ecae40d821e56dd0475d934334578c966d2252972427da1b9704cdb6c4f69671859973bc125d9616b17758393aafce7d771d16e73f518d3d24f50488c743358076589fd0161643e4d5ae49acd377fde3425a2d2f564cb500c34a888348fd3a5005c73710852b22def5cf4426adbe112ee8a3c14efaa46cb58f986d89daa2f3b94cb18163471367c970abb47963b1b99e17dc094c21b3accb10dbbb66091c0fc66ea5f5008f8f78cacf98bfc1e1d0dbeddc95fd9d160f82e9e937b66ba57ec3b5d023ee84444cb5323a005b67efd1c80f3fd440d9d24c3a208df3b6de139f9419505c68a8e554edb3d37ce4df931dc109946627f73f2a62b6646f8186a4029cc31d84546a7275bc199e8689ec81da5579c791320b42bc4a02c8214f6ba5c6b8bf418a61037eb78b78e1e450b5951736de5bdf9079e34dc2e9914f15a91ef32a3a8722f40245f3302dd11cbf995a4642309791aedb03afcd3c673d2da95eb722d5dc06f137ccc25fcabeeb150469e417aab6c16b29d3629e414f091d300066eb56f8e3828eb66f593d82a5dff78ba232ab22d41d6c60b0388dd90d5e24ea709bd66c29703c6136dc893e757760162d01c475f7c0051e76e3a7c61396c058e95389c733a8da1d96a325178462b04a5a7f0aa5bfd7bc3407b4ba4e8e9178755860fb83ee1927b7a55790569cf16930a1678d7348fb4381eda5d07c4ac4ff852759ffa9d6c4273fa5edbb49d0e345a07513bf23676bd1e7e80e94ba239c2337ad43957108fb01115efaa51651e075cedc5f38e56d5cd870834ba531513e4ce3c29a15e19625622e32ecbea992314be660b0fc23459be0a6a1270d2f6c36c2e954d90f963f28f1b33d5382a281364a5cd553203a3f78e33fa67ff335983d5aaaf2a32f391561c1756017f2398180323f366b2dfd0c5de838f7d2dd33ec6dec4e39ca953820ba05a63284272711e853027b21a7d8d427603a35f178091330a6aefb4888a1820247034d7b5a8947a7cbc93f5a8eb46f5bf602503ac5614c42149a6565869ce3193ce9b51230ee42903c73cdad048b1ed47a1a79630e54995ad36874916ee9a5a3f1298e56aadd557368e3744b7b13f834162b940bba2881b7ea1e92bb3ddf7f75ac5851f7ab3c827b7caeadcb805d9ae02a99e06b8b5b7ec2717b55d932e10a27eb891ead91d38d72bfc6909e378727c8543bf18660a6e527ed8d4e30f4361c126ebed0e22b92459bbc53def79f6795de8b8714c5ab96d2f207ed979f3f358f032048b6d816f507c945a2b6271533a98edc9031dfbbdb589eaac7a83006bbabd675a58cf39e7248767facc95f750a3ab7a81222805fda33781daea536bcdd373ed8c4c1c1e715ff5e97d0d36e76e1f4219d503bc079be1c3cb212f4d5cb6ce3fcfabb8541b47dcac54f3d819568e613979d5f3b7e5a213997427edad7081a5737ff0a7b5ae1a1b90e54a941b0a645458eb6e27b256fc89eb6b0e6180386587a44f064e0767f356ce5c132ec3fdba9587e6b9f60f66b266a4627c6d01b85db516f8e2c5326d5d4bb27f46da55de8627c483dbe07ff689f7c651aef702e9e6213f172fa3e2f8e700fa9725cb8f8fc6408f0176fb0e37e83b66f39c014137875d22ab3e1820d8f33af3f02579c4a836685142a9afe53309d1454731345d032a9aff9999b294ecd160b15eed4b62f3d342024da3e6914486beae1089cb38224acf052814f056ac31fcb2b35eb6deee2dc069cac007a79b2cddd5564b17b15cec48c885772eeea1df26364ab617e04c898e7a893d6a66ba23d26ee30c0157ee692bc740bab788e7d3814c7fb6f31274d20099fb741c15fa63d8abc7c44a96080bb6a7cec8ec34b1908f7835e453780060d01cb7b2229e067dd2f7d55077e550714ea705ded04cc5d08b3f4ed36323408564fff7928f225eac5e2d230a8f035ed29e6ba26b7729fc851aa436839a4cb5f4897318f31723d643e7ea8e6932fd3e025191c69216a2c42768ef59cb025996f2c3161e7204011460e9e834bcacaef14d3042752cc0d09e519587a9d774f44e57a1872d81a2ae15efebe4f8e7f8bceb25bcaa16620315a0b187d319b5d2a5fb61bf6f11049789a806e1c80140ea8b9698755ef6d5f852f3467a5524ee9954f15a647bb781b483f18aeb333b69eb8bce9c7199c55b7bfb56f0e63646375c0f3506dc4bb2e436f1e824c36ed44e0556642cfad417418f80994aa379822bf10203e6ff2cb7cb868dd8883023c02620719c2e4854e4253a7723df4ae3db1873fa494d9539216ae689e00c5ce33686b047ae32a02508654dce6da25081dadc58f029426ba56df8a9c3758fe8aa328642c948fa5b93c40ce52f85c251550ed13e317b306217bfb4dd91dead1409f1f7946f0ad4aa273b679dd98cc5835288c73051486cc7585c737bf4b74a5c9077a936e309c61235f612c1f538f857565b1787bc5084ae222ebf91516f64547d0cbad7474c88fc4c60abf1c5532cae2f22b9a8fd8564327d438afe56c93bbb43bafec04c524fd42c4b010dbe3ac730197a7344e98e48c8f74e6e9f095fcaf6d5d176237a8b6689716ae350045e20b4448317d3c2457e0efd257d19851a897b0864d031d8da9a76d0d576ffa9c62fb33663cd741339f8c0a741a19a71bb86d567cafc35f91a75fdab881f06568c8c43bac3707b5d2db0bdc9418e36bf56ce4d351dd514a495445e99e3f868095bbb1a2750fd330f97d942496741c1c8d21d6603becef1d88ef996d42bde741bf8cc7e8c3b0bc11722e4d0931912499a6aeca498cfbfe4adb9cf52ae0803fa89b64c3c15ba5b18492c4e5aa9615292b92ec16b54b7b3f38dbec834b7051c1140007ffba1857575424947ab2d6e7f367983d9d14ea2cfc2b8b9f606cb14172d04d3ef8e285951d3f6be223301110249919f1fbdd1ff46ac7dbd96982507647b54415115e078163f03079a991d417fa3720e71b396006032914cfb545a18cdd496efa908a327e715f151dfc9d597b83b8c30351e6a1d88fd07e146dd5e62dfc0a797d394392fbd7f3000805d24d3fc2484b843fa719178d8f666f62ed865e34d028749cf6f5e56b90f2b17916655281f382e1b2e5bdc6a5c73be3b21818665bf702147aaf40331ff331bd02cbda435d5336e67001e3f5d3fb53c2843d08c4e55745936bdff74982b21d0b80a50eb5d2d2d28d868df436776642aa764fa248cad583a6e3ca58bc1592d7ce424dc77c94c015e4735b2321e9eb44448540e5f4982356141ba9025f71fd6055e55473ad0309fe82f3da09c095bca3ada9b2d2fb7c6f7805c8b98a2d632cd87ea31704bcaff46f3731d71d427a40b31d545d5ed6464e9dd74e83c689c833ad09bad13647073877e733619718229684395f5c0d6281b15d04627af60802ba2e3326a6d63ccfe6cdb72e698cdd2485bfa64dc318998455248e4a46e7722b6947652e32ac9b9916834513a5989364265d957554a8b1184ba47533be21f079dd07381dd643ef61b8e048f8ec007f49efdd3f431bec35190c9617c5c96cb2306c47afdc2950bc231ed9aa4daceef4efc8cd2b0014ffe9fbb6d41692cf1767b176e5e5dd8ee9e1074f09aa8a00eab6cacd03139de6a6c84d9dd25d3343f1dcb7177a40373010a499ee27b46bb0cea48df26438e86cb2111991f5d018cf44046a4f907619b6c84965bf2090584d621ba45a6caedd22295ba8ec7cff788df6563abd5f606c522e7c84550e4dc0bb305866090808dcbb824c070a276f55ed395b8cca9148a86e631c5af4c001f60691286eda19125ec5e8f2448a5df423a02dee7616fb8347bd004861dad24ab15eb07dc24011f4b5e437a3698b8aa50b8d7cf9b64896b89b80b26ac8bcb6b7694276836b80dbd9a34feeca8beb00f26d5a5fe93cd946c958179019fe873c561dd21fb24c622f5b2f0a9d13b0e0c561fa8df86c1189c2f132298233d61de7760c41f4b7d336fc2feddf77bf465dd5efc89ee81738067d95c1bdcbf1c639797eed8ee28cf1c6516500bf81de646a0173f7ee79393c183c62e0da62b5c76a091d776c825e951e5564aedbb4f8aaa9108daf9875ff27a41043a042360025197a54cb953196d0d38d99cf3118da91b8fc92e61ea0fa4795fd58618b07defc53a664b4aa19f745a186c0d9b57b8d3d36b8a5cd753d06c844a31a785cd455d71373c5448c29645da93d052c6c69368df218bde3856533d78dd42b9a6489cef44c0e370bcc8a116dc443bbf67b247308a43a27a5b424ebfc754e53980070d555519ea8a5a95a7e3f878d3bac5dddf839697b87fed8ff9f1afb830a7c1cb47778be5351286d35452a52a360ee478cd0501d94c548e7192d6b359e6f268569b3b1bba7cf3d4e997a66b50f5fcdb5363ea5229ee54fa44d92c311b05c5719080d3e134c9de8a7222c7bfe814302d8a5bd0c4e2c50264f0943f2030398e3ac0109d0d95feddc604ed519f558c70513e5029b41d0a8254870cc1509e666a895e8893b19f4d3b5db4b4c06f0fca311dfd43322d6b8b68adc28fb7b55422d35ad1cc4f266cbeb797b3749dcc722decb607167c8bfc29dca5f0ec7992e13722e42de0985a8eac1156eff2c637718b472f12140473ae5a01dd02fabb9add26e47326708475f748db485334c5dd38ad1504fc67dca333a7b9db4911ab57f19ffa197449276ccf15a140a1052ee07bce1c18a7a1646aea2fb29f3e8e1a64f20b8f415fddd56c7c6a60cb6b7519d8db20b2e9583412aebd23c2097454c051f602d5a685c4f44107f34d9ad157a6822247241201fac8e0d04899496b46814961d59c529f36590e0e31ec690cc28ec95cdbf55757adc3509c78bea08fcecdb8e605b685cf91390581f57166c391cc99a1ebe7dd02700c9f8d21de160f590e9e2ac921be01d9adff76e9804656e34d3a4a75d438e344855c36c468f99ed91f46328d1540ee33c01182072c96039bb914a6ef58762394800f917781407c42e08c1b6ecdcca4690d810e1f4eece1e14322c0c1505ef6aae923eb643c33210dcbf2a1be2e71e769f5be80563004219f926ea0c81f79ba37fd8790482de53ab7a519d1863a9632c65b48f9a280f5ec04b26290d5cca4cbcf91f76bf5456762433c7ae4ff4fbd0a35f88cdf4f98049b0519ca4c2cec42776af0376dd004c6feb42d65bc183f920b123740977d12c57cd7bdc3bc065a495fe53cc6ac53f32e7e94c8a080f42a3d3fd9a9b50d9fb288d3763a11b90fc5bf177f6ebaf28c74d7c571f73501693c1e78ac072b1ffd9a54e3220176abe80874f15cd8e07c9ce37e515a3d3e2681245dc2d4bd212e33d3d611dda01852a658efb306424c9e3a02a6fc66c2c447fc6ef68538102aa9b01e1653ee1918bf5139f67fe68fe2182eb7d5d82d700c97cda4309de7c9c1a53823d6e26042c7c0664c1d33cffba5dfd61c8fc54d1ecdda993ea376957d282963dfe96e843a403b56ea3c6c74ddbc46a4dfbeb7e6ce39a03b67395515564b321b71ee636af141a0058dcdbfed027a849deccdbf1efbe1aa438edae3e4762a1a222c28036cb9899e4b0a77c23799e7ccdb6fa9e69fefbfdd72caa29d9eec596a8a007c45a4ec1a56769e5c4fb0a4963f0d235ceb143906103f0cd5fe862d80db3a31bf5471a126dbc7c6efd69f09b555f2eb12c4af207e405520f10d032af4c7705ad791f66e8595f0eb5392aa24ac7ce2caa686a63889621382978f1deddc003ac864b39b41f5169cdc9c2e5df3c90f45190606b1f817900afe242304cd749efb1cf1858a3f8d56e71772e2aaccb6f1191817038e6a27c4832430998a2b5216ed47dc3b33bd19dce2e7e0e764a9b99c70ceed487ee69761f78b5210a4c6d79c99cb8108c841524a114c6703c2fc0c9fef376f6dc5df6eb294e3e7c7ec982e99605450f7c29b1be3ecb38118e31cc61e51c3bb382dc1d53bbfd5ac23224a6bbdf69ecd8c5a054815618945cb443b112fe220fbe684d9673b8cba670ea62fc126e1aec0c4115987df508bd2d54bedc376056163911958a1e2481a05c500dde4c3fe54fc6d285679d80ef8a407c04488e6af62950c435981edf0ffd11659440022fd0584b929f513f8e38712dc4e782203e991a873da02b101b71bbe52ff66daaae00005105ccccfd28c377c34071c939651f67f68bcb0c1db84b5cf6ce595145180c5dde553844cd3b9e2fe09dde91771999142cb4a3154b0716f336220429fa108db2d535f5c5f2390aeacd92a1a4d41070e114ce8113b4f4dd891856b5dc83378e6a7aa18bfbd6128449925294cf170f4bc52c380fbe9861bce9428a44a857b23112027d8e6b5f50fdb42a47afe0d624de533aeff1ec4fe91b0c60a4d5eda1331bf100d4092a7cec513229fa297865e15622f86d7b11b3f9a6335110cef81b11e968f4ab3c82ea13fa26a9089fe4f0ae190bdeb7c7af4e5d521830d2bf6341039d36cb5d6ae324065c84647fac2d22e5a9082c5e76cdb17131f4fc61840375726f27684176b4a8493a017b926d63944bfce958616576514dcfa1f06e62c09a45da31c86221a2a501c38842d21d3af3360e8bcc78a9d2676eb023a31cb0061a4a812e7e36dd309a5c27961a264d7cc6b24d6b340c707360eae450bc6a0c4cd6aa97d86f7adbd386640e8bc1b49ebb686046cdcf7d79c8c7bc774173764b6a5f3511a6bd35f334e5fc128941392fab66f8e27ef2fc88fd4968d978dc0b94922226a4d24a641f7aa5c655d0364e35c442c634e8734293c798b8c8df13665b8cb570f31000dd5783caac34ff4d543eec82ab95ca4a791320aff0061834fd322962a2f6ba5bfe528b418626b98f59fb79f3fd9c37a5b185543f85e694e8e904052280d54a1bbf9dda4bd3e8837ed47271047a2f82d15dc034c4fcc3d0ad9cea05308c26c243ce34838ff4a851dee6fd947b904d24dce7e59ff50a47737a9e47a6e26ba25675734796e20e8b2b01eb0f0945b8637312ca2774fe7f54422fbcb0eafa433f57010c471196f720dfb1b84fe62a0c11f88ed73e3150902cbb462a3956c1bc1bd3b092ecd0669b54730dccd7bbc35e3debeff1cf2e26bc15843222cc29951cd846dc6517209aa71a5fa264ed152b82dc50cc750459e725c69bcba4dd17411117922a3d058d538daa598e730f04e7f750d48e5c2570a1cb476e62f912af9cf1d498128935ddfd41a7e15547f7a6cfba51bd974ae197d44d99b9526a590b487d6c9137a4427b33bcc632644ab7b21323a0b673e4f9d5fe693070316dce1e1d9f1ec1dedd31a71f883a7761908b1d473c68d17e966d34625dd3eb000ab68eb427c076daef35f6634419f6c4a4e62648a6e197c86ba57b7d7642f808c2dbcb6f15668598f9af5f02b0061b1f719ca7f436c678624924de6f30c12f0dc9f305c9bb23ef4af85d6215f2d4d05f46a0e95688e421e413d4c09bc6b1d9a45e5d72b7798d09bc1b12dcf5127692b4d24c955ecb5a532148a5b07c74c086cc6041222696401700ae39a08b3c589f5b390201454572a60a650009d0a2e5c3b46a6ad2d434528612721871f10cd4dbb18d96f7a29fec68693e85845dcc397a1ab9998e9efbf36d3c73789b5cb7ee8c570917f5f8fc7dde829ae497a7671214a475020ac4b2a2f0f4334da82ed07bc7ae02b4eb9eae49aad4f83b91df0d4091c7e60c20d6b30ebfcf4ead9c6830dc44e757e68f0ee1aa3e0394ede1dbc3a9ee944048d49105332dfc471a394bb29d0cc3148d21543441249897699a6b725cb8fca9a0f191b65200c16a4b16d89688e386da97ebd63cec9b1d269e47185cd4eafa024dbedd00ddcdba7a293dcb7c965986fa4587f5b3a0f7df1194d09759cbb69cec892aaf5499d47974fb10176c32030c2a1db606a9f7a9dc47a820a7db04acc7b518c3dcfe703f3c9d01f440cbc67b6e3ee3ba9ba25354e1f06f1c0df5c7ed24fab00bf580abe998713869831920bcfee391fe2cf8a8724c8396fa6e9a7942a2e6accf41bab7e1bec451110981620944818e50673a0b8545a14fa9cd9cbc925bd44c05d621644a0295979a1ab8de6379c817f247dcc3b44be9e81f36ab76a7eff928126b169ee8e4788155e2a2e88094052dbeb07892fc3b75ec587a98eb7dd58d4faa9cd18265028cb008531a6a0669fcad8f839e32b87b9e34097b026964b872a5c5fda6c921725634e26979698636c0ed4cf1afd60c1c63c2811b58a14f276dbab5776ff5f2d7c524e48ec14d0342ba5bdd3988b05eaac80747b4479bbde58d2e6ac2b41177223dfe1c04f2699a220fcc2b63158151b494800bdf1e4b0ab101cb184e3f6c2164e16e0344e4a0212cce486277cc25f94dd30b45ec173aa3ae06b968888b666c319468aef67f170ecdc0feabc2739e642b559c3158701b0eb3396daf57a6cc5a56481108479ff0b7002966362e6c48a6574eaf7a80e1caef99417daa6fbd87722c31f266b304df6320c76e9c6187b0ea97e8a0f835a86d8e6128bfab73d0d5322e93ba60ee92859e3900e6990050e6055cce827847ab7dc22e8362baa60f31e36a03448f5cfcf3e0eb8a2cf55d93c3a6661343be47d58e454b97cf5242fc69c0a912e6400e4f83cf7d2dba2a1ab5d12a95aa3ac38cbc967f391691dba2095dde6bb8fc7ed834befca2745297f4bd9563a2eeee4eeb99cd013ac2ad24cc7c4e82e7982998f85e641b6b1d02254a4affdfb4dd3fecda017ec9b24926efe828ab22440774f6c71d78bac9f50110922ef62dfd3938351adb62d3ff896c9c2117462613fa1b1b861a579e60afd10c29940771c417337efbfa8c1f108d116fe51e0e9c00776efdd2fc8c763b5f440aae25b3eb0a23bf699394d6fbb760157ce5983eab92733c4fd0f2ccdf99fb3bb93788d9dbc9eba9f131fbe4b144a8858e2d6e4ec5b9a56ab2676b3d5b8eea11f6e38397aa3073f14e036453c3549ec470085dee66d5a22252a25af4cb2e184a7d5845428f7922141ebcee04806d557d09d6b2212673f1e0b47936cb7699f08d33ce7e8289a3b393d34a7c2be94d517cc2b7db3123c8796f41965a47f7a2d3f9f72909138a8a763750f17d3223b111f85f724686d3a1519ab859b098e3c3b1c4f87f103ae02a401e9d1e22bf4e4c48585c34a6d4e6c7bf9ae8535beb47151f7c3510482289a687776f75f9b3e18f702f87955c29f3e59cecb1c73dee945910c6617c1688ecfe1b037167624fdaeca75989ac0ba6f6377f3bcd19af4512c6cfb9c18ada25b86ac98ee30c37d4c6a09603446ea7ea72a4e08e26b1f811a63a54ad803643440c2cb9f813aaa916dc93969bb09da8811cb506e03e2477a24287dde27917cb10eea5f3c88dc5aff97ced6dbdfcae228b0556dce26ad07c77ee81c8664c82ec3fa09d168e7d2f1999c9bab2247782c02644dae9373f189c6b0f43a70e8b3b0a927afee1f7e6ea9e55710e8524a5f648ee21cd06b272f0ec5d48373b2d78154b4863681e3e110b29ff4d43ea146490d97fce4e9c99a6d198b820f04c2f85511c905a9a9382bb3b235fe7940e97dc22abd345dfe665512abd089526dfe1c4e46e20d7f3629d2c9214943983227872c4df3a5c066bc32d618c07c74ff26197b358d51e5c4c29a179f33881ad5ff4e7e56013a018f8a968a717c0a2c7bdd4dd0ea6beb5c1f939141377d091be335a8d3a90330bb6753b1a0ca9829e2c12bc04b01b2ccd0cb3418360265cefe9f356c2edae8f2a247ded4a4a89e122006fdc1d8feac7b7a24bb01b9dd5ecbb86c8c2b0b57f43f67b3b7d81fc78a0ad20ca42aafcd362230a847bfa61d8fd45e346c6eab073e9d41a8ad8e90e04dfd28d7521f313042ecf567799cc0eb52607a7a2c8537403320af9252476fbb4be8247ca06b89ea55b6ec98f60b14b9b619bff8c6e819fe11840b107e666daddc1412100b6a8cc3090cf85ae6034f93fe421105582b36e36d9008f7cd0763face228337727c9d6c8c76b5b5786a936820e8056ca378ddf9adcf3be81cb39cf0e1e2916a9a149bd6201b9fa65c929b4447e146078fa6a2e58f953cd510217b684a0171fcaa4c137899a973dc47c7415a52a5841aa5d56fc7a1550c828f0f9759318098b2af0f438fe29a3d6573eabc3c52ecdf6c93a17fc5c649c3014426db8b3302171619d2a17878bf93251c1f24041022f527ace11bdab768bb941feb4507e0e4d1b03cdafbc8ed1ded6804870b3984a8f3c065f943467facb31bd3c645c93e2bbe17d1185df86621223cef0e4c4b5fea6a93dab89cc7fea8a5885719e17244385cfa72914e111e18758c284b4808823db76046cd4b7b68724753665e1c176059006f21532806e101bc36fb6340fd8595389a8ec1a029c3d373fcfe61500df220b25ac1007a0492ae854b391287f23106bd37b78ead906cd5f218e58462afce90ac229ce9cb5ca52c54ceb7aba9b40616c9de6cbc302693935c311f111138be14c9ccdbb13a5ba587461fce3fdd30b6e0a74a791173b3ba641002799ec589fe4c5f53118bafbbafd6cb0fddc34282a8096d3852d4fa1f3a507a4b02879f82bea86338b1fcb63af59a395cc24fd4ed767e52958d9b36babdd420708c6ba8a6a4d0ce52933c38223d6e5fe5656a0df36f091c5163ae814fc5fe349330c8645547e1976873178f976001728e2e66a08716b46a0134f5236f24cf9ec7c7983274b575cb667269cadecb6ae7148acdca4ca1f92976007a2f4682f1bf24710d2873ee8189f0932611bd01c51e9169df1a0d7bc9807aee785d9cdbc26643124f64d666fdf38c3ff36fa2161ded8fc31bb819c259f040c8004d9cfea7abbad05304fa875d58f3c24c914936b169de0ee0802ec9c98a647d23c53b0fb4b2b197c32d9b2de01dd4cb41220a1c7f9332ca138f5c97946bfc9fb6dc4a059f8b8095ece1cc28a64204f0bae5309b22aad4f6e4f51a67d3dbf9e3a3296b2d0caaa7bec78a63bd9d71202853b84e1904544e9794ca052650cceca3c95972a520b01a490d748e253dfb934fc006960fd7ebed3853ca03f8678f555f6bd705e26985f83059a24a0d0d3b6fa5cb780c8a688f9d652d2f83b4bdfcdd37325b8f2a14f44fb45fba96150334a04fdad28cadbdc9262f08863e63bc682f73bd8d041b71467dd831ead351ac6defd50550532d82f27cabad9782c5e9199efcc21a5e22ce9e02e191068ccb275c9aa2c4f614d3c69c1173e9b63ecc08268ee0bfd704059b037adc574ee9fef0dc838822aa70fe0faf8723b505411e0ce148d138e0ed5ae0596518e685885d7a92ba3989f9de1eb4fe52dd7483e097d847f5a78ac9980d06c82da7ad5cf2ca972884cf18f1233a8a88f3c643f6fec5d71089da4a50a5dee93a99e2c24ef51fb9cb3345906cac6be8a084865001bd6a5a4cd308382140e045075ae281744da9f45cd1fbc5ae2e5ff2b449cc49fa72fecabe3475ba9f38fc66e1210843f283a7e12cfe36b03f5cd73777bbc8da4f812bb05e3586f4cb2b6c33a5ce751ffab3cf4247939dfd527129a39159af3793534f7fa0e94563aad24081a8dc92c591efca80992cbd3d39f4beb7362e3bba7681fd3e7a05e00ecf2cdcbc91478a5d8e52b4f47d3386999d0595202c82288e53517cf9488e2a4beef178dfec67cb7d786e9d027602cd1b9238bf8e28b9b86d080046ff01581908956f9fb5f828892f4a9e0a041d6bc889ac07e1e79eaf306e431a8bf959dd46b26abab17566273b0339fd74029e3e95cbb5a2b5c4503c59dc88e3accccb8d70a39ee461a605e71c35fe2fc7413678b3e4adfe893f42a90029893fc04aa95ff92263bd37559652abe14eece59a8e50867c26c8be12e91076e597d212b69f4f67f697770e9d3b262b4a762e21a6f5cfd7f635164a07b18d10d05516a0135a7ae5810678977c48ba24294459c5b5c46c521c858237b32f13a8f0dfef9e4d2ba8bf78d175d5fc60e1e016c1108ca079e2075339992188a1991ac515edf125ea75e91dfa099fa72932effd5a7c285c4fb5ea66bd69bc318afdc87dc8aeb5f868c179141dc5224eff21a39f7bc1bd675fc553e2aa5f4c449296174ae52db84e33a329c0c8e45c1f71cb9528bbf3640696eb7ff655712c3bfc11f0b4ec79fc3f7b0ad6350fcca20e77181ed5206ca94903da0df4bd1f48c74a8e4011494739a6600303bc35751b8a9e4ddfa523750eec52608153e4b9a26df24e78f65524581ffcca57dba32c4281a7a03a245d7d86fb74c4c44dccd3d07530a00dcd2a74f9dfd7171aff730767bb4b9ad636208ffa53c116a204a5e77c2861acf96a7a5eee55c068bca547b22f7e2a801f06669fc8e91f484b3be0a5e35d6f1538c019bcbe9a16bf4f214167108412e9c3f0c2623ee4ff4fd29e378f575c371e4c93ffa723b60ee508e84414d64224eb369055bb238827dfb19ee211bd06f710ba4dcfc48cb08343c274e4fc218286082fcde17e2ff2a6f343d57e89105b25598bd840779c754b567ab7946de441a71c29048a488fa1772149006d2fdc404b78cc88f74da9863401d4151268e8f04211e339d84562d2928a6689a43fc3a7b7960e1c9a8f3e7d176395fb138b47f3ab0fe05f09733ea88850a39e3f54fcf528f2e6c43d70995da64727fbb1d9f1780c38e8a8cc86ab28e2c0ebda4140cfc6c5d56e4776bf2db9e303187e1c712aa49ca585ede8e1a605d89c907e5b801af9fe17c2259df821a16b5c9b058bad0a0007ac87207a33203828a4c437abaecf0d355484dc217fd068f80f05fb81b9fc4675c781d3b8267d6a14fa217bc04473d63a37592ff5784738cdc35110d2043f79ffad49cb7d5b1633d312226c605da1730f3f6a856129cb6ef05a9d30f3aa6843774e7ca4f31eb71efe96a855cf1585a3693fe455e2e650d55f34ab009d62deb4c94df78728d6218bc61175b2a0a46260eed578a4ccc602a1a86761efbe2a5d4671c15fef71d08951fb4db4c54f3a0dcf2cbadc8ddae1c0458dda49d6398b7430b27a9a79d443174129fd6fc322466f7db97e47e4eba49c18a3f5112afde907129b3354cfe189696960a318891ac806f102eaf9db8df95cc211d10cbb6927cde603547b97be4f0d3568c901e6f0ee6485b986b1c71b32fc81deedb0051c6fd24d05d2c47b42500a546c26e373675faf9ae46c35e58a8d2a3f6df3161380ecf71fa2e6243d645b58766cc95bff68282014ff8dce3933d7c96c21747ee9d0dc6d569dec57d863e263d6f8496880bf958426b5ffc97e271f6fbb486fc88c654a3e41b6c45cba64fc8c9305afefa260c9be761ddaf71deec7e69bb921fb8e6d97c40dc587f6046adba8dcde0937df92414388873f2d3ead2eae91cfb9c2307fe0309d71242de3e6f57fea87ba6d226d389c7b390dc5df1b037a55afaee911992904ab7ec3cbed54bd4eca0ef222077317e71cb7851c09cafcafc7fccde571793a9943e372e09f829646f89e4ec89d4f1057426cfe120392fbe8b26c8e4a006d099a8a2ca53fdb8bec0aca5c5c38c5f049b07ad43b8da544c9745edcd8523df79587d1e187fe7caea335a9535d2e1385f7cc0b7ab0f6b3e2a2d6f0d8445d6af61e34fee410fa016de5d21d01facb4c1e1d18416644ba49f56744a2c0b86b0a25b2474109e8503bb13be2a84663136ffabb170adda3ca56d7ce29bfe778a4f21a2dbd1c5affe512e134da6eccfd6d47b59edee87d551b2c0245a47a6bf4d0ea2fea65baccc1e05f175722b21ee6269ce403963024012718af3207919c09dfdde17d6392553d2bcbf2fc971d107ceee4e0f3fe9320626b13603158ba2b0f639aa01baf619c92f5c3acd209df2aab5993bc24e703a658e77c2165d3ec81aa112321739470c84132846a0ebe913ad55febabedb6dd836fa1e69690666fee5e448f9a1931291fa11925fa2aedf8381bdc6b5ff1e56987f422f224ac33bc94cc7a7b8edcfbfd6ee7a5c36de0448a274011c712d581aa1e73f73ccac0123344c9d509ffad39a080b915b5465263c89f88216b5290ad7916fa315d79870c9ca3d89a723434878608176dcb22ef5f6d24c9959ab99f1ff88d16e5ed05d6e1795a0cb524746954c3d2d8f3a91d4a40657d4cd8142bab9e4b79d7adabf632832c220034764b22632b23afb229584a8298a85abc4e46fe8aad4d7e26a1ce0199e3e878c8e44fc34ecc83b4facd5769988629f0f43a1b8854c9b0ba70639f99fd60702947e676e9feb27b36de48305d64b0c1a498a25ef5016b4570b15ef63f3e8b12422c49674a3402e84ab40fa977c1d2dbd7a40da1deab7def0e923277721fd095bc1525669c0459f12599ffd037faf033f8783b4af2005a2977c01eb52116573bc8445bc1e75589d7e9eb11b2074f2f8623592b5b78c164443d6c7f1d80ce03715520a7d93d629e0dd7cd2017e4777d4e6aefb4388c44fdaedfcc5905d0a548d183b13e2e743b336058a6bb95b81911e3bac5b000eff3bb992d98f82b2c2fc95aa027030c2c45192064a20b4e8e52b073d6cdb02b63cb0096ac8d98449eb1cc09755341c221b64e8b102fc8124832ccb7b9d9487d18ded10745ee2459f7a6803de62b027f781a45ee06823beb8a3e6b559223e784cdd10985defe0318c63e0b933d4beb347ad17737b61057219ef0e34ab1c63c31f25fd67bde87f35e77da6d200d6faf2c0d8e52f7c215d84d823267e5e942363845d486baac56f5942591373949fa0e24f3d9670638107c143be75a0e74fc83551c92aab27abc4ba5dbaf07271273681cc08ef74b684545824b6384f9b7bbb2a1c58f7f918b0f86ad1830e07faa02d93a595cc55e473acf3fb1ed027e602cd48336d5b08724279db03149480442f7ec5bb6483ffa3b3ab3093f441aa4b060b7ff8a0265da1de11fe1c6e03e2f9044e03c9327f48114d5fc201317cd316049b162aec59c97c69f6f54e20ffde1b4fe6e5cb7275a0dd35eaea50a8c47403240f590e467e1076ec70c317ea588d578e035f57d46e5b57b6c550d7fba192410827d75d13f43376f40f3a920a416bcd2c7a2b351d96d21ed59af274f2e4232b2ae83560a3da82f0cf80659f4c43d3c89377509e207e78210c65d63316a082cc749891033606abebf6090ca43eff82fe5d4ce40f24c658b5b15ab449161a75b1a3af079274046dfedeec84b87c379d1aaead3b0c4f77405b4ee5e40c6fdc7ab6f4e2371b7859926049a774e4413cbbffbe7dbb54eabc01442baa26c469acb43acb54e570a6df1c42c619df3d566430557db314f94e20754a32bf6b99388e6726983a8f9d44ae9fdafc6318fd677c789a7ff6484c465654b3eb233a6068c0af43e30492b2b02592c014cef364ab3dc9a342b29f4f1d5e5f82a08a59b455fa1d4e8189491dc8ed3ad3dfd2faedabe8b73535dc72e8d266e6542a6276e2c2e1788ecfc2f65fa7b754f95e6d9406dee12eeeb391ebe181ef27f6c4c61a8231835f287808f295a6c0316ad985b5f1bce68c93d8432fde8dbfab8307e049b6bb34b7284ab099da795587b8ea9b80d1f9d8e2cd7a84f21244a7d18e3022560ab882d39ff698263de42257b1e31a67794cdb2515834b816a1b100c884639c442892f973570ca32dd24efd08694db73b0a8423837359e612b626154b94717e4966c3b5153ac7a25ec2acb6c946a0993fba1e11d4936e5cfe81151ae096bf9daf9680b94932329f72d4e2172a04cd611feda9203fb86c0518bebd54c3192420bf2520e8d83cc984a7b689d62cbafee7897a67ce145c722574afb4564e473b233ded70bb0b9c6d87aa9acee589fa60341c9150a0e3b842da38625fb42df1e270410d321ed390e12a4c2ef414f949a5fb8df08d284449c22bbaf27b0b271ebe435e31991642ad4edb7c36d0fdc1a4802b4189fed732377dacd74a975929bfb61b4c14ce40a22bbf1514f74c43ebf22c878604b5a0e14b20aa3d6497a2a12c74a28b686f19ad14a62024a0e41fa3e2e653291179682b0afded6bd233e74d72e89fafe80b18b4065554dc8f2c44bb186e151470444b13d88b0da411756b083dc4fe4036a799c11e86f33b56480552088b5a20a5c5adf97ee34a21da3f4d457300e16e5a3c9bfcdbd493170e72db020c849963e0df1f71d545053c81c36a3c1e57c4fc2f3644d9d4401633cd7730388ca71c8b2c280fdd1891b95a440999f94ec9b620baf640e0bcac2f72a33a7e7817c5fe182f6b494458cf92d2336c2acd17189b437051ed1689638161df30bdc852b43794cf274f0155a78a19561dc5d6874b7dd5d2104f52788f419a14e3227e91ccb8fdea0d763a69e919ec859f89a4d32df7a7316ee0fe63c273c2ae703019b56b991cd185db4b57077948804989207bcea480689d2a27056eb12bb2081104af715373a92a278d6096706191c78c464a01a9d57a4130c3c86d8252a972484e9fc40ff005491d1da5d1b9ea519a2a5c87dd41e663f3a79a657945c0a487b1bf14cd02aad967019d9916ef60f0932da57e3d6da124bf0644a5b5a811a1b5ccdc63fad83dc2b8c80553660c2f945c4bcee0409d0c15a65a0ab922b2239d7d5eb6633a339b12a81c0184e97fd382ef2a8816c97c1cc31df5c3022b58a928f65d9e2084335556562d704a68ca66d11cbb0cc1ffc331358ce5e3701aaaab3947331c3e5019c81414540a57d2af259708d9881cce1cac3ad143506ca088b6a53046bad21ceea573e9853d8cb7f7e0c7a946a4de65174591ba4ac7dd51eeb3b182dc8681e841bcf80f96baecd0bd74174bf1a178b72e250a8e42ddff25c8b7c9a2486276baf70413754857957552a9890d88d259fadce485853bdd89f95d3e980a6874b31c2254433d34308925ab1f9c656253ec2ac0eb924b98163f0c4b9f62c87163cf99ef34b53f76344a02632b4a98b6538b87cedfb5816861158206b7c6fe1426dd43a7c7d885338593524bbc8443205a9f129b16e83c93e3f4e5fb08b460e78ab730b5b216cdeb520eff8bb91ad576446214aa3aa484d1608a9e33dcc0b923cf53f8c678070a9c22851854707812f4fb8998d596edd6789fc4808b14ca66b8de0f39f8c5afe3b0a4ec4e1af81691aa173eecc1b91aa315ac5c3e7fca22d9a5172a130f862333c98794786daeee3f4ce749246263d0cfd50538f080e37617adaab1adc8d5998748f1f50f552cc2db40a071978cee8533c3fd8a93e12cea3b4ef347ae35216ca3b985e0b34157a1770ca72e609fa8201bced2608549bbebf11661fcc42601b3fe002b3aa48d6f96fd052fdcde34c9afc8a754960dc190abfb40cc6521a9a933415fee20498d3e09a85daa8a34e8fb16ef6c1763d148cb1eb0a04fddf892fb18cb43b801ad2fc6068773c445ca29ae81382082445d02de0478e3016805208b8330efb721fd2e1446fd7de095ca2393cdc0f4417da3e8966e511e286e039e2d54b5e5b02b0bd11a754480566ba4ae0fb79768ec627618f3dd4dacbbd73329e0b4d631948dce37b112e590e86e8a558076432fda620ea90334125d5d87db7819ccc1760fd6e0411ddd41702ae8f56a8ba93bec84fe8714654858f30f76c5bbd8b6d8d2fbccfefac8a60b6fd5071e2df1d76dbdf1fe61300b346ff353e3bc84035e3392d6b48c9c0535cca4426985fa8b9fb995f2c501b6630fb6c17e2612c7e4fb1cb1adfe0e1efea65e76850b6e967297746748f32f5b1122251167af1de3de2e912e2abdb0553bc5726ce0d75f7d6e46e61ef08a967ac148c4a1c0adb5c2a246c52ea24ec0a85b840a5a8e08a449381dcc6c2469484cdea3324fc1a7b8057e119fed5c092e4ce0f7ffd21968cb272c41d660de1737ae1f781f6fe901873e92cf39817230121532ec7cf2bc6e285b68182ad4de08bd7c3c88d27f091b863e071a626cf11a26d93f61817183b852d287f4e0a38ace157b3e15a326df289f728a7c1d013442485f5829610d292ca4cb6aed83bb232ddfcb3a21827ee372c04fad3720938fdffadf2102443eee6fbd89bff996ef28c5a0f970866fb624e258cff422567ac7dce215d197a63dddf601183d970da8e6a6408f12f3ffff441edefbabed5de5ed1d4ade0105d65c3906151fc2e0d05a82568a4035e0decdf8984a8dcb0d097c9c96a169d38b78ab129066c9c9c43cd60aa7afa2b12847629efa9a958884dfd1ae2ff8fb297703ee37a5a3b7e82aa15b575ac374f0fa8eadc85b4f3d5c409ba8e83d853d384d44e4008e3f05443bc589bfa23f78e87e967cd798ed8f964caa02322d231bb2bedadfaa4ef05c34a75f17f67a7dd9ceaf5bf7f6d57f58ce2eb105530fd1364b08b7aa4179331d87c69d5d90473f283c976a6f20fb100ec0ca04ad59f02fe862cea5bd4eb4c58c0f999eb2045d29e0c74d647ef68832d06de52f4c132e04cdffd4bfc6c84a2b1f7a40f99329d442815ce37f7496a87b7392e871e14393bae97c58f37ffd6e2bc9935235a17f8e7738c6970417b9c1049eb9d73c3885a2e0598a3587d56f97516577784f66d06a18183e9ad2aebc33e9f38e80b7dbf74fa7906381915ce4816b28532b37f6eb7159e0f3dcda667207cb5336d03cd92f6466295dad7e1916f60d26b80352558f32d357d867a1fac8905123bfdfda5207e617482cd38c96cd560ee5a5fcf9b3bd9a00342afcc1b4ae00a2ab04bad3e14034d78989514f4a546d0904c43ff978165cc29187c868bdc4d8ec858d151fc923eb69851173304e7ea0deed7b8c121cf24fdcfd8563d7b8bd0be1173c3de8f77b4db4db8473e964c4f52e9ee40f78d04f5f780d1341e4b581563520e22a0cdca7ab41d8c9d90a5128d0e275b28f55ffdd299f861f5d786c7107215309679f049e2ebea151c7787bdd5da41f9d1e4592a706c41857e412cc62fae3068399669414807dfac28fe8e9ef0a6484ed2cd80d30003aa5e63943da30093cf090d65c843404f5900ca66885631cd4cf25ac137c081db91793d730e1f891f0eeb89c31b682bc40e040aed7b085cced84f528ef26279dddcea22b13ee5efd49ea9527c6d6e8769ca0dd4d682f6bde68a2eb32d9228cd3a7945bc6ba9f736095bd3734b210089febc76026235bd4a346d7982531a9fceafa2617df0745156fa434e493c08e3fe3321a4d4064abf1dd49c7136bcb42df331f5030776e4be6f44a184bf26fce10e21d4a000f5a8bc2b6785f119c70c28290418f4a277afd32f4e34a7f0470c2cb3f7aa9fc1f8980084e9f3a03765e0f5a34f250b6f14891605bcaf446ee2cc5acd7b969887a49a108facc15ee7bc4bff631a5b7f34a0a87bffae0c0940b3c5bd636736cc4ae445b9569d454ea3a4783cc4231f495e78557db050c293c74efc5d032e0a39c95fc891a4acc968097805d07cb542e09c59372a1f4b5d23280c76579385f0334cd43dda5f1905a543d7cb0fe5a2efdfc50a28df9094afbf04afcec8be3f2ffad0fc08f25d23fb3ce463a170fd7c26f75893442a91ebaf4c2b4f7612f8abfa0779c716d5728bc0cbb763110e5fd78a5c46d5dfc9c90fcb11da9d8f130ab901f720e242a226e2f0008eac777823c9ef6ee1e4839f05f89634881f192d6985419a123fc07539582381efcdbd2889ee2ac3b9cb2154f94dd23ed324977734d9c4e3e2df2cdf9f4e5667f343c699230da4bf41e6d2c8bfef9b3629a1b4f28121ff45419520edd204b479f782f30a4597c6994b6dfc47d4be447c198545b7983369346493abdc097ebb42869ed840288a616ecec80519126256314ee1850a48a607adbb21e177952bfce20c622b7f20c97d7f6e7603e8cdb4bc53bb03d07e015bfbdc01b47d703c3082c9af17063332a742c69b59e0f778066664dffce02f0b49ac795994fbe21c0c820ea2cea9d3523c4a9362af2cfb7318b838a2089bfb5c2d978ebe2a6682a2f461292f899ec609bf4a0920624cfbc5353bb397962d7a96f8cd9d667107514fb8edb4e13fb11eca9d5582ddd92b0d01e5c3af8fafef366d46559f99a25fbeb0cee4100f17ea714d319d6af92aec9f1f2c7f753733991b02e38a0204ed05131877b795a260a88bf85d933b8287ed0c612b801c1d8a08f9f8e82eedf87d125da7a8ab99332740accd3128cd8ed1bda0a6edad93b1ff896de84e00dc5c13be0eea937e17f440c0ca4da23705a1a32a90a15d8e12a57b54820d693d10a11f65cfeb0e12bcc1410cbd2b850f1c857864c0dc8e5d750d9844239d30327eb553ef1e11dacf54cb33691acfc423983af6c0dc2d63563e20ac1f087b839b6f22f22c28b8ffe8f8f31262e512f85b2d9e24dae0d2d82b010d5013194626312f81f066bd9f702262269fe41937e09c1773d27f9d0fb881e9b438ac410b9537a98f221f4a47d28b143b8cc578e8fa20a1c890d9e82e588fa39ded692a86c01295c4800198e4aa3fded7317d0f532884fe1e7a261b6f7c94cf43814bc41070536e4d201df35c5e9be6bfa579b660bd8d29900a29beb0312b5b2e7a77ba0d91d06c4a8d97be65537b4ecc578c445351053ff165a053d1b3257a179a5da9304ad4be8e30f8ce1d80bddc99a5ccbf5a69792b95f2bd8cb0979d73261593216b73a97ad987e99ce4ea8bd6bf156cf6c4f33707d1e0b3c00b03c67d6b5c17e0bbeee770816d7f1033195b30408af8975f0908fc6e20306f90054e1b28c108187ad182c61491ccda30c1e5a919c24182551c091ed85b2c6c43e9ff6f83d2db2c53ea9e1041327c4c7acd2fed02b66974facb6dd9c63c8283ec67e6a9e4c33053df9b7864e5221973429032628b6998d052ecaf8e5a38c9fa55d565f94ceef7979e0fd29e9720b4450a4491f9f77d52464ea386f7954576552820fb3ca23657fa5ab59ebcd4e386d5460ffa96eb4a83542f7a04cc37c17ca14a3986b92824c26edfe4e7cdf4ad10ff718c4a9ccb7932184398824ee4ecdd1238e613331608d23253a803045ae508a033cfceaea66887d2006d5aa0e160f23b09adfe5b704c7a25fb33a9ee75605f39db04df75956738c1fee56dcf9878745763f0b2c6ea9cee8589febceb01794be2a5a22fa4124ae891fec39b787af7130ead8e328655928c6e57ca4ff713f75b614692bb523f68ac327b1948344ba2129d65ae835036c8fd9cd939cf19001733febd8db84135dcd85d4fdddabd2927bf1868a9faf9ad971a2bbfaaccadebb2ef09230e974a08f2fd425cc72257f577946df2710d25dda73632ca3d4853a5f997782b6d064d9dcdcf47a8d1369ca6aa9aeec1c4aa54138ead4891db4f3e0927cd345d04e3c2278f5ca84e763fbe711ac98d764ddf9a17c60a7d722144b8c84f3d6c131e92fcb410f01392a6a857653b9c948dc5e75b8aa15d69e745c49c5b9ed00f2d565159cfcb2031030157df20e171c9e96e6ae38887cc9004f1ce307a1aea21a784fc8c574dbcb1779b55da513a68d88a4945ba38db9491c7c86849d134d56a969769eeb787a79a5187c701354579eed71068b22782a412e13efe14e7337c53d2e6cec362af5bdaf7c03252a31affe2502e4f3001fdb4e181152584f91aabe943c099aa614a3161c2dc7f9b03e498ef35a56500e9f10293743ccdd03163b9e4fa0e8c60cb552d78860a7f4bed051aac85f88ca8226bfcfb270218287b35002d2fde97e6c8ec2045eab68ab361809cc3a382d7933ac138fb249367f0f07a7d2afa6ad7ea9b428ff2e1d31dc8a924777ba1df9eb29a5ead11e6795d990afcd9665021d08bcbeacfcb6d70f964d17f578ea1526c8f05b58c4da90ec9049caa81c558ce4c6da66eb53fa8972f14bdc907530b0f07427e522c69f938e600fb8ee6e400df0c44cbb75965641ae58385faac7585619d82ecd44ade42af00f86c8ab1bbd83f56ed5a6507b8bb17c60254269ae6721662201836cd87ae62d539f2abfca5964eaa8ecc37399066c763053ce05ccf16c1fac86347c11cb7e833b064c5e24707789f234e24cf2fb7d9e7b11ff4df4959493e1f9480c40dcbdd43758a38e07dd9fd39be1613b4c1594d808b8ac234b7260923f2ce6e5eb8dfe26a54dbbac1019438a09ff8c145dc2116bcbf7adfbb2aea6f15fbef5878fb04623ef3337e76f6be0b609cf62a1c47381838b068c608b76910a169defa4bae52b9a405b73c40f31a22138abdd1ed74a62b21e67b470bffbc9399b5547a3047206fcc35956980b7259db721f98bb37089f6b3050e95b245d8260cb12ba1ecf6a70df7346e211763f61b65e2eda1e4343e9869af30fe7278af9637155e364d8e9b27f7b4d17ae6f935ccafbf183de4934cbbf4d2862efce7d9dada3b96ef79d308e382740c3428dad9ef3490aff099b9b8137ca3877df036b61aa305bf50f8fe5bc0d6502ec758e25534efd8b5c9f5e8f96f127d88d3a35b4364b1bab15160fd5ad25d5f79c43642e28c042610914403ac556af7fff1544c8d88527c89c2b48e032486ad2017b87c3526f944e0fd2e8d4e5b201b7cb99c23e45d276aca89fcd034f669a64e3419fba41469e0dadb54a6480b4d108b88482cd4aae34c2827a0ea0e0101f59cd8c77f3397632302c8dba062cf22ba697a973f1921b53b192f7976da0fd45f25da9472063ef4dbd3f9fdad90f634ffaeb6bd2646b1e5778310328c7d087d13283b648e081eb2cbae22555c3b1e315b13546a6bc5d3f352255c28f33042b6912b3289c26b9646f11a2c966a6beb2ecf1fb4790c7540d3eab050a6659950d9a9f7e45822732994d8a792e39d09ef55cd1c58fe987a8981ae74be789c6c57167313aabe045778ddcc1ef670da57834243b00d331e3eaf5d879d3157535fc436b0ad7c718bba3886258e97e36d8badadcd610dfcd60b8be0836c9895e3a4690860f755f2ef34694bbc4bfefe3b866b936a9a40e1692218fe77197e92c82140b2274a5093ed7ff01ce7f842abc5d1a83bf739fd4b4fd7a8a9d25020f390d2489fe7dd1b1438061e10e7afd1447b949523b15ef3555a882d489e4cc8ae00faa8595c2ba17310ca88d160dd48628e12c218d6cec4ba194d3169f03851ce862239d0980944e548f211e45dba3cd2a12a9502f80e1c390d490fccf7e423daead9b13a7f3c73f0e5cf4f4764f1328193be1243cecc26007060bb98b6f32962db4db4cf4cf0f24d91a1933c9aee34e6a182a4406d92877c354e4824a268688cf72b1545234390d9f6cf4416eeef2e5ba2ad53d41fc19729c5be00e2a39f2a30ef26f592dc8825e6011f94a92bf7d0c1812a500ba66494d117f1e1d9a19412fe9fbd72cbddb444f2acd20bc4f838cd21918c55f9f20fe1c279bf6ee18039da6231dd6c355b0476b5d85d7cbb3185abccdf2cc935ad6f983971e11c6ff541d375b9ce5ba474aef11445029eed2b6af43710ab1b9f7175a3c4fed9c705fa9d345e85073cd506e2ef6f870a160ed44a553fccb7e501eed9d953ca4b6b8ec3a0de690834e5f9cac04a19d794da0a3e2f1ce7bd26bbc99bfafef6d182eeffc6bbd650b4311f6539b25eee00dc5f13a92fc073cf10dc671de1140802bd86a92800ec150d66cbcbfa2498cd5ffebdbf1362948c368891b931b12925d4f840379dde52cbf367200f7fc927f18c161a86459724c9cd021c8074637824b537e96725ec18c0cbc41b320cb639e476236e801643cc5f07fe1c4bf82f1c249543e857395b3fd086408ec4362fc16c89a8aed8e4973d7f37efa67e9c5f497c0ea8935ef046d4c3160d464a8313be5dc923550bcc76f9b1c4b1bebd9ee8a5b7fefd28f34a7307e11d395fbc6e4e1600d6a686acab7d59d30f830f2854899fc0a721180da544a4777e79331caa2d5addbb38cdc3d1f995f1e78f7ff89700b7b3cbaaf793cdc1d9474abb9ad9e8dea4acb644807a4f29bd4a71348fbc2e6d36f2f6f60ef06dc2d02325961ba93e2ec84b7e9a69567bce2e5dc5d4db276c7b87f803de0dcd3b2896491f7afc58b5ec4017a63e4eeb49932f0652ca3540c72b1ebdb96b53cd715ea40a07c26e0bcc7c037e1403dc46e3f07449e5ef0f4541eb004dc64fa919b206453dadbc84201bf58f2f6b0718832f933a67e7db70c64a250b037c91c60ceef02093caa1ec5b73ae6d296a761f26cd42ece577ef2f7f7ea0be740454db21c19c80525425c67344d36ca546e437d7e69f9eb5c328d7672e83d38b3e201941f928b9f0a9136c9c01814a3b3fb7be8eff4d61bfe2cf92c61f28145d2378f9758d8f361faf83eb32c135177ab8a0db6b6b283f4122be52296e3a742d86059503e6c4789ecef278eeefa2e36802ce6af89ad6dfed4449944d070ca7ab44888d958f1288be646fee8d31f7a24e84e155d45748337aa7498e1f37bddca19db7b4f6e85678ced4236f441e11459827014906067898dbf3cef2fd3656124ddf97552bf20ede8c8f1660706842f409d7ddcda70908a67737506c486a0c60ea44f118853117dac9464b11cb6c1e9184d8f7614bf35e61d908ee81e56047320e359251956e3641c24ba1c51a1b3a576d20614d7eb9baf7b56cda61d30a9488a2c44a93482487a2f3423a36850fbe5c1503f7f04a4a791425851f383b346048bce6e00899fd0c00e6e4a4747964a2bb5d44fe33d65512ca722ea137bc75cc7fbc1badcce0e85da9939ca4c7830ade7e1aa977e69521deed3b807090fc4a6a8c2e8f48b3b66b9f6e15f9a99aaf7354829060fd1341809c061de4f23b12a9b335e9cfa160d1ea34aaf7d9f592ea0f14744f6953c8ce1a176e231a249b3eef955628c7112064d8a3ffc45c6387b0a41393eaebbda255c34df5c1795e0ce4dab58f1ec2c62eb74a56a779454ebaa23fdb4f81ab880f6cc486cc772b59b9f38712747f59979055ff21202505a47fa5506a9a3c99187ba34ddf88f321380254b2d5931aecdd4a1089e81351d6ce54d892112491eaaf370840fd615aae4064555bd208f100e7f909fcd99dae0111aaab344c744da2904dce1295b2ebc4a9e4673b08cd973f07ca88eda3c6f12931cb9f9b49ec5f2070804fc427ca2d57fbd56b65642974c67d9409a53d0a7de0a5b4a5f981f4eb7a493b36fe47faeb7fb60035ded2ee83a59e6b80c55d3e919ee4ece07dde4384833d7f93b69c88312560ac29be97ffc689bfaeff209d1d0026da0dc0698d02e5d6be3a84606cac4eff14e6bf5a3919a396998cb686826a9d45a0aaec03d31b05b3d1fd9f0aeb20cedbb97ba23e6699b46b370b5f57a01f829853ba1da550491bd820e66bb47fd664685f3d08f1dc26dafdf281af9c8b8f32ea5e5b9bb8c947ac7e4ce6dfbd825d3b0c5c4b15a349b90b7d521eb26b01905a454451a9d44cb658f735dd39eb3f8c804cea2c4f552d31cb56ec01e14c1944db0b0b1902a08b02253a7ccbe00ba82adb8b5fd564b0c3c3a4fa6e02ad3703f1c84942d08b380bad51ec60f1ace3e7d5f2b8df31777b63da60c242e8fa0b17a7bcb958715e9d1cd76c3e7e516fa2b2caebe9e4c9b0ef22a3432f8154c9f44aea2f02c516c337dee501d12bca4c26309e0c1c8c3daf9a10548f1a5e667a5d6f0822eb3d8688d2e0682aa2713fcc48d442c2c3a97b0dbd59c5ce6d47c69183aa53d73205d86f714538171a2131922c21240271cdd5e0a69997ee7438cdfd94f0da812b3e5ea77a8729437557e3ab3c405bc69f23e07185845cf22d72dda437193d048eb82d9aaff515707ad16634ec226b561bc8d34eb0e98058ddbdc70356d13728c84413de316b039072df8da1ac25c332f211851673158ea9fd976392f6abc81b156c324dbaa48fd9f1e06aaf53cbbb36e30cb2da5a0f1da689122d27f3f3da3db484541f488303df3afc923e68cb1a5d381ed7ebbbef449e7f93b5d8017cdb540c0d46a087766e2a1fa9f58a226b8ef92bdb35b1733123bbb5d84ffe06c4a43bb349a18ca141eade2ac0e9f23cf04689dd704c064b1ccca23efde6105b51a102dd569eab458d4b2e84e73154b3f035eaa87830d078508a44d6dd3307149ad94b1653e228e8acfd7995e061896e7cb1112c8598721e3168bf1b4e99e44628479a0c1dd2675dd465a95bb58cbe2c59635786552d62f45d9d34256b2dec8336f1e60aba900840b10488a1d0795447f347446e983852e4e1fe72d8af9ab0c81301408d48adfff945b07de8e5ca2e82feceaf6682f8653fc6fc4e62033c2903525a3d344f7941985bacda22502600aa3b8a72e047dab5629057bc743a76304d89e46649450163ede6226de74a704f8e4c331a81b6f2e4a9bdeb47e2449d411e88d2bd49139fef60f6a721f70c40327612cffed8abc2a032878268ef369de3a79c8b4984f0e0c5b18776466bb329958fe92ffe46e411f12addc2019b8ab4ec59cb1f834b85ca00e33408459a16145ceeaad1027435d724bde850303e3b075b76c4642bc161741d43702aecc29554b8e0a20892d60e4eadf2cb7c65db706a9e4c99d91243d3d1aad0a0291970a7630b83921b04b2442350549c87128e2b1c2091fb8176932e47889bf1231bc6c7542e9d41744795108612e0022a25ddb959df9ba14bb7c92d74d89530d66ddbf2c0eb13920f4ec696f63d479860b52eaa89dd993e2970c0a8bb0cc1d215b05166fe81531a3e686153b93ce149cf162e787256e85ca7a1298b55bd459e60fbcc13666297688310bda0c2e3b6798aff414861f775c4166377fbb2c726d26d76d3077e5acca46632cb06ed3f7225731c1a9c6781c4108130611ffa449cc5fda213b2003c64b0ffb653fc607aae01e7a76e646a16a52026bedbc4b6be09a259480678d23c3f895f0a6caf0b15713d41ea5d00010df84ce0c130dd2ca3e739d542ad3b0ecef9d8528cc177f9e8fa660c8feec77bd0416a5c9f57a962f20ed87bd5dc3c6ca79958102ebdb67fe2109a5b6e49212a52027d029e045c8adb3cb7249ee12446c6410b4cd6b768ee568a65d3846b39b4bee50b7e62ab53079ecf2edc18af8fe448ed94b4ef404abcb20100634cf2c2a326c42de704f70ce6e6286dec653df460ac5c4f83e221af80cd15ae9a566077464b8bc6668cad6bb8ac2d3554cc24bbd3aea3b6aca15a18969c46e3d17fd3045eefc7d9e25ce81b26fcfeaa319de064791279c0f11ccb75786914f5d2dab956a616cede132c559d9e3f104b84bc4095a933355deaa498ad76a339cf41c20ade3534e9aa4cea4e90d50591e43cf7de34108a6fcad1b95787302b2c9342d60d795dc1be0c06a0fda8444ac627beb2593b17b5cc7ce638111539d5adafa3ed3220e1aac41482f47be70f2484fd1b460101fbaee1adb7148acaa7188932242a35517ad704dee76f09c59b015ad619921fcf159332969aaf5aa3915fd7322bc6a540b3bc21cd04da4def277e1c371d6c133842fd4c72d67a0afb505c9ec71483340d0ed3cc0caf9528c88675469cd02674050d6f2f55574764ea022c49e2913c4e562f02c2bcb6e7607904070cd7082b9dc6e2fddc1589396066c2f969ec35e4058a9f60a7082d914a683e9a0268213eb0ab2dcd18047f7ba8be4554f01e0ff15d109b20860b11793dcf3ec5c9f41440d7541c5d48aaec9b3aa859f903378df3b2feb60addfce3b57dfa3f8552740f9b711999493ec6ca7b152cb7f44ddf97dc0afd53a8282240c3be69a5e390ae0eaff4630385ac18520608d8c47e7535869a8b96304cf3f9d84ce7b4e95006edc21bd05dd661727d239d06f22b15fdd41ca1cd7938166526a526a826db7d11a578021973b1371fea6eb324e735867454cd9e93556fb8295525912d95e01702eb6399f1601fbe8e8f5a263bcf93d83871a644d4961bfb2f0f82f28ca39573c9d6d541fd2231e11372dbf422586438c8f334c1567729ed4a4a69fedadd9bdc5a2aa2c880a323dd0b81e17e002c9b2c75280070e7a206e248c2e27d76ab1dfe983b9f293ce0461b6a181737501abb88fc32d1ec1235087579f4e7baebd2e8a8544e829f7e9395561f3370e319717e38b61fdb083e72947c9518d008573d031b5329b28d7228527f11f5c1ad0da25a87968e5eed4382c8eb796f05276ff8d69a569429b903ff6ab8cd63f3b09a37ae084df3f9d0c8794438fa114be3a16d26df3ade102ce8ec6f8f52bf10ac7385645300bae9759a0e3cd48b318c88939159a9d45e631eeeb1de92e918f933226fffacd03444a1006b39ad48690a74c5d18f483ad18cfba79849c2d4ab6d78dec220088728637490c6a9b972e29c4a010dba0784e92d76e8d63f7a056864bdeaa54c2f8b64274cfdea2c6f774f83faad4ab68e093c1190d840d1ec5fe655867ff088a53f74f2b5fc53893f8117e6a368b1c3ae305b1ba067c41fe477660d9f4ad4d091dddd51934410a80e747364b2e2738a92c49f8af312d05c63d472ca0f5d402d37300cc0fe8dd728d18b93d1ed908126a3c26f8470f59fc68257743f065bb8ae0e8430375a1cf61c1b288eed1eeafaad946fa449e628d1a1dfd9724048a81bc0de8a230c291b8bba38c188f877aad3072a5336d2b1733a9de6637c887783e6599b0341f05c42f67c118f622168dffd758d7bb9b33772321ebdc5d921a7554caa8dd65655f3be3fc2d62c82e89bf40ddd11171f053b23d4448f60f8cd21a066fc47eaab787616f95fa1851c89e8555cdc76011cbfab3b6383bbb037db85696d657c02a3944c54598c4aed29b485081d5495739afec491d25d009fc9147327d1b31242cf9f6283dc025836da82e800db3085058dac09a4cf1550a7c98f06d7bfb084a39220ee1a4c3412046552a28ecd4da3dbc1e63ecc65ddeb3c47c99eb9667f3474a3e9282f52e3b878629cc9f00653b0c171993ba3298c2604ea31ae949beef926f599ae1780abd8c8ce1d5e5f739c78f1f60651df4d01c7330ebbf0a6f955a77c1bad55f83d47545d7d3bcd2da25c10630e0c07f1c1b4b0929a3c935b4607b219661058b1833928285982c1bc4b09029042fe0a52a0d72c2367fed3a9e50f83540737e0b15814b5e77ae842264123ccbf845d403552ef992f6a8d350677d5dfad74babe2370458d86469569d3c28f5096fbbff6358390aa93759985e42d09c0dd1f28af9a42a77827bcce803be398d0f35469add04a3146177054c16cd2488b05e4a2bffbaa7e83c5515b6d4b096f9611610311b03a04c4a371075dfbacb599ee86e349756a9f2025aa3eea6947fd3c3f51e22f18b1a273b5f178b9102ef2b75126260d8dca75cc7de97f20cdf52dba412e621440ca6e2751d707afe18577eae174bfb1aa784f4609303da4644ad71225ce3b73fef83fadcf61b234d02b8b7277e4c6817aac30c8711b6efc473061d98f306bedc083ab437f986da2344fc9e3a612d9b5472aef7dd9ecc317af25608c04085e7b75a10968641abe9a202fbdf65d7daa0e6cf17911374edd2fefc7e8063399e34382d09ec6748ca0c2fd2a589853414127dcb48b50b1bb5b9829b79789bbed67e05b78b448ca6c8f40b0802919b2a6ba4c1be58c41cb63b009051e205a1311bf0cecc06f23a435dc4c6933050280b1f9c06aad3245c42c0779d13f7e22da2448a6153468de61eb19770ab5e0113ab405345211bbffa26781f716c0bed6c38849f0e6e1370d12bc1f8a8d4b84422abfab66c6a5f80b1a339af52fc54a87abc4a5762a3fc3ac2e6cf677814619e0427d0c8ffa667da3df037110ebc14b9755d5c2e2a72d04ec8a178dbfa4ff8f7e80c221e0423a140ee1e50e6c5ad636a1f1ae373cb106a5410b3823bda27821aa79f5161402317ae3e1476fe95e554290c6d7ccae950edb6c8f966e498d8493878e564d0cacc051f8525a9e20514b209641e71aa5de17324166b9626ace9f5653f0528bbe7ffb314ae30784a4bfc5240335d80e07a687b111899f4c766b5271a62d4640938402113093f85a75c80f3a74a82e90aa7301933fd65a57eb313dbb13017f0b33704de262505a99ad32c773db01eaa1d40611506285541799fb139edde35fa460c061658bdd14e7b9f6ebca49f3738e0d2fd944a632cc0d8b4dfbc6f0c684765a36f6d3cb5bd61d387dc7ca21ad25a6fa125e78126d7ed2f25e14741dd98b14521fcd266252face27e3e3ba2093025b8794d5f72eabd0908c4055c50a2859c309f68d2ef7701db1ac43ceb31ec608301dc6de3a98d03455fd118a7ea11d9d2033ace43f594e46da1d6e0d18119083960715ffaf4c85a302494eef344104599af70bf6d181fc5bed3375219e9907aad42d2dfb3e7b365cebcc41af4f607dda2bbd242d1ffbf4ff2befd78b5625a9662e59cf8b85959d1eb81c719717cd232f8c0fe04e0d184e113a53570820c77f57ddddbc230e55b9f923db77632b730f8d0ecf05bcebd4a77d77e16f2f8a7615e5e93bcc0ea6aaa4feab33fb84d6ad326d680a1f58b723b6e7c740328701b1f94d1c195476d8c44dc9a16481ea4bff3f04052f34bafa7592714655e88a7f0dee720f73db41b300fb9d4906d7a09bf7bfcd04cf237c9941de0ff642aac3ed62b2ed519b263a504b94974bd4dadeeddbeaaa2eb613e27772152d1387e46d41facf9c4df0baa53f5ae7f532da192716cc26e84c09b6f8411deebd9dcc6a7c040723dba54c8419ab62092c0e525666324167488f3bdf4892677b49cfdd976c354ddb8be585eed824015023dde59eb2da13c1836bb29a44901982c077fd889879809cfe81e25452a4c8f5c1c8505e27ee4a3f8ece751370eed5fbecdf9e00893f0d0ab54ae8aeb88dbc16c563a969148d02d97c158d9fbf5bd5e8e8834924415615bd8cf649aa131af54d0e4d14875f5ae48d75984011ace45a1bf35af5dea06953fa19f6fd3f581cfb81f50142453a4aa97d515f568ca8ddecd7c961eaa803c5a33f0b4534f8700078d1ca53ec347e1532bdc1fc81915a2e6505874e7c5545e234c7b9268381749651298e681f090971f4a75d42fe8f3f33e99d53ca3a9443485cf6b245890e2f3bdb00335820f21e7e4c8de51ef20f233ca642d89a38a0e57bb93decaa546fe5a268bdd50d857452060f35fe4e387a37ff51c9f18693d102423f0dfe2209faffd7b246bd190dfe866b304447377a68ce62a43e17b2a68a0c3bf3dc52b73e8fa86dc137465ac753e66e02f7b082d6a56ad5ced823053856b2db5e705819982e2292ac9eeb79f4cdb0c4f38240b1c13676f7f52503301b67e59d00bf6826035101b8e61d11ed2748c804e9a80cb6c723a680c670c218764ea37fcaa04f3eed6e26cf28b780e232771588b43158ddb78133f818911d5ecb6269ccd695fba39421a78867d566861df23b39cdbf9513b15e1a8df3eab156ad1a304f9e01dcc8e9d9b483df6db1fd146fced779c9848f16270152aff3a46f1e82f0ad97d56560bf1073b4d55cd5caceeb399faba60e378284666ed117a47a1251d4eedf2beff240d1f15b3bd75369edaf7c7645f2d50dca5b95eb37a6aa6535551f15538ba4121c12868ad4a6a5f49dbb0f4da2d633b40b32a168ff5c8fa116ea9f9581cf6489f61def93e54cf9dc0b80c9de35e0689582f6d36950312de9ae05a8ee163fa280b9f8e45adc351b80c2d920ded674bf4efbdc3395e076c34dfba3c9ffd7a4b992aac75e406784694abaec90fc633645463d6032d88710899899a225e5eb502e594b483d197baa19d0c0b45e723eb8b9b2422bdb334fdcd9f706fb3ecdb1efe2f34a30b0a74c3b83514d10f7d1c4d9383382b7e2d87fc5d46250e66c4eedb09b7ca381402f54dffd19c8bd2afae976f41ba5a90e429b5c65e69928da9341aa53a697245c0333d33a8f0cb327e38008e875647c51fc9cc74f6b4919f6df1904456f93fac3a8e50a84151043a28febbed94cf532fca96c535bcaf1d1e6089913420b68aceba29e8a5137432cd73a998420d7a9ddf24c78a5d30ba96cf1008a87c10af8bc9a46cd90847025a7ff7c524a2dcc03a03a0150d61fa674e2ef19bcb66d7487274fa82539b2d16cf48ae42687d77a0c9f9893cef7717fdf93976151f8c7eb85ac158d9d3d47fc250ed1df42ce95d2a4e3fbc7e4217b6f6f414976b4189e98c94d6faa42af4618af31a0913d776e7056143cf1f53577a815317e8382ebc8d22399a835c8fa55be6db8bfdbccd1f03eaad87a7ea84969700c5411d3aaead022f12aaeb3bc5a6e1c5c8b40d6d7305c526c29f5faa3feba38b463a72d35708df3ad0f9f6bf4f1bcd056ecaac8dae07521c2becabb2eb364a6ca53c51891f3f301e9191022db78220fc9e27f3e20174f7c1e42ad656feeb07a1d1a895867845bd8cb626d00cdd82c6f2485e8819354f031e1837587016d9f35e0019f21805fb2e860c8932a660f88aa43d7d0f418dfb3fd22992eedc288b23889e295532d72c2be53f1e238a13ff6ac3cd543950953dcc8e1890b4fbbc18a53a135da3ea404e69d5a4e5d50d7ee47c7333c48f9d76e166972b417d3439682b4452c5bff9344bca544dbed6c473361dcccc59a464e1822b47f172256f3f437ba73e5da83e371687b66fe9170bb85fc25d26d08b4585392c8b8d620c9819c95f1add3b5e3bddd39b241d031f81b284d4a4d53177c6192c4a6658fa392236126d88560b6d96dec5af1848eb2a8a33922b9723aecaccf64b2d6dccb4fa81b4162090ca6d289ab557dce21a5942cc48b0611e876849263dbb414ac57ee2af012afb04f23921b3cfeedf269e1298b2218bfc96efcccc028f9f2f3a0e3339a8849d166a91b9e7f64d607b5caf0297ec03248c4fdf3285765863588e4089cced5a5c3d7ebb53eb96552ef34f47a735ed4f1c420f56d9f0f8a7a7822df2910405259215aee34c2b70f0eeef9f1092e56c95ac308e8b858de696680411341ae1f8e2ae059dc08677807d7e433f4ef590e3b7b954f8794ec800421669c6609037d2e0597ea0fe69336ab1df6af711779d1323baca6e385fd6e951a4c7ee3a442226b3251244c263e8f226ebfee3c2c4d87e0f5d128525baf0a913d2babf5b1c138843174cc6faa078847f30a8f2f3a088ecd62511c5e146e42e212d3483f11a6512ed51869984f16dad13ab94678a6595e7586d982b1ab506c699903017ce4b99e0a87a1ae41bfdb39f332ce05c3434eb3e6f7b8fa722fe67a6ea22ab6cc5f5a4944aa425011f3408b1f79cda3a2f4fbb8672aa869f608f876627140a0a5c29d8d2ccd6c10021268ddda07999435e543c94cec6646a8567eb83f29ea688c506edc5ad8307224c283a418928cc09b154e504a71c14d698b0b6dcf50d00153355c1995b79615e9475539ea40e5df3d901e5b68be590a3d3a0c436ebc79ff2714515feb027bedfb932b2dc908303bf546cc34b3d087f064aacdbb834a4b2f6d9796bac8147f1831b00678436078dfabc0bb2ac815c79276651446f050ae2098cadcfd93637295e59032d44f95a4e8a740b0b8408e5a0a3320a6ecb199c05a90095dac47b9eb335c792366f7860df259a15e6c15fb18e0a752c54200073dc68e6d1c22efa2a6d04afec177bdfdffed74f167617f859af6298c20327f1271b6b5014acdc2678207863a4f781c6973d8051b1187c39483ba267a7fa7a3832c2ed34c3ae171e74c87622afb7c0a238da54db639dada73c7338986e171b2d59deba3bc6432b90d32292c73a7d19c72d0a59e08c4fa816c5848424e478eeb93c8bb4dc4ad9ebbd663f994eb8d894f455c5ec90d5bb30ef947e5b762cfb3a76364e52ce9e562b8561c10826c4d2db7a0d0d3c31b4fe4d83f1088461cff72c4e15a61cc4793e457de8579251d64dbae82b91ce3f03a7c972a42a3eee378d53bb75fa307d50f09523758b9d5ce47fa54cd787f7ebe6dcb31f263fb9f372f9258db8ebc0228b42fd17e35dc51c5fc232054f8765dc7a8ae032f266988236837941da6292f6b850626938635844369a9a211033974502b965303827751f7c030bedaca67e511be22cf27ae9d9c4cba43d52f597605094321e1c5aa25dcd3761fcb3362af4f1213ecac4247e7e01010a1b69342568d07ebd2b2eebce50e8f5374fd236be749ab29d2ca809a0b2d1c72e5b6a5b4aab4ad9f36e972057c2cf69716d34134e130056a947a4bfb49353e1a6c82cafe4f84b02cf0e56e6561d6137d1a29fb056fc08a49d959edc68758eb4cf4e8a8dd0730f017cf6190a033d4281519d6af7d3ed5a89c092069b7a5de566118220b525137505f356392e60f2fb05b6f4c50678b63940cb4092b78e8659a07e18a194df2448801921b5769482e4d5ea9e94589dbeb516cea40a9a17e09ca56e6ab203f5c7d58deb8e4d220b24daeb9a77d4578b7e2a5cdc47281b878cf4b1b8f85f072d6dd3ac4698a6819585cd32eabf962b53030d1080b57f79fb61ebba6ae21a84506095fb747e7cfef0471cc2659b88b8c0700a2c8e017e4f586ad40731704affb23b95758543e8249e7dbb5a0c930b1b9a7a76a3753f759c44661d47278b6cd26e6c48ebd22fb4e0c031326fc813de1baeea09728c09b932d747710b7741c6711bb946aed84cc060d6df6340d4ea5361001ff1532ffbca1cd3b3aadafa44a4a836b8c02b99e9765269f72ad947cd1e5fb8892a01c23797cb35869638186c2bedf35546ef671b5167915ec3f27fd5a646562f3506bfe2c01f814e86572631b92da750ddc7dd376b56f7ed040c24fdf279172a0f940fa5fe9f9bceb2580231d4b98abc67091b5a29cc4af16d3d51a52143622884e1d42d876e597b6e46e5b0ac2832825a2441e1ebf993a9fd93d61271d286eacbf7a5ab8dcfc00228322b132d5f96dcc30d3af1d3b78eccdefc7eebd7c421c678040654ce52e5c03c207e649a1749daa13179f0976a4900e20b1cbd2db5f225b68a80e22af2c4489babc2d1c48c08e088e95e0a681f9664c8266479e3990706d70d6a1157b7eae1358b372dc82a9e269ab14cade28f78075edfbdf14bf1b379340fbd2395baba064563746e5c67ad37ca95450d1900a06e6486c15e74fee8255c79ec5d828c33e4598c572db623da7277912ba1a32828124d4191dd8c982ac48ed2cd87f35ca1df40ba7d29f739788c50db47a4c69e50e0c32c27ede04e8aa18ed0ee70e170370db4ac91c42e18c80c8b57d195a66c96b7095660f25fe3c821be27c36865b9c4b9dd539d84ea8a9ece69aa91b78ccb9fed1e95dab6b55dfc378eaf18c5c59dc0e2aa1289945619388113a59e923b32b6cbbd91b2e3f238dfed3c36295e924abdb9ed082140ee94e229b9065b7053291f0c257dce89c56d3be2e39d7213d117e527508f4b7dbcbe199d0ccc96e1c6978062b24aa99e415bbac7d61c37433ad88844164f975e2c24ae0a0787b4375f79a1f14c71817a39d0c0e151bb28548523ede1b09feaa069958f6eff782e0a513144d29f7f655726b7e48a78684c2ec5ed74ff1f14e91f51d7de1e1169b3b6e0ea8b92240dd8d7a026f8b0a34092c0d4fdff562562975ef172fc40d27058d816ba5ab0fdd1ab7d69d89b5500dff97ad314d4cf460de1049bc464525a390ad5846e5a22a1ef47320149c90d7ed45ad2b1d8af0aa17fe65981ac4ba198627d53194aeed152b4bbc2d101cb830d9e12bfcdd3b6d9897a65cdea8214d3fa0e5bbe040e20186f63e85de6cfa7f42eb4ea419f1bbec302092172f131f55e63cd4bc4ad0fb74985cc8e1634e91bb2d08d82d774702182fb5de97dd3964d0e705bd0d9b5470c2842bb3d677242d9a27db06a0740e8b0856448c7c9d38c7e8310fa8cb40d8dda6e2a8af5ab8397eebfdb27e7d97176776f1127da53aa4356b06c4ec9d0196e3e472562d4a36de8e2957afe005ce7e212966b86aabf84c3795e1b096cece65955d4d6f045f2e16c49c6f1912720e6011685f4d10ed296c08da7a8cda68c6e0b70aaca9f00a1564050894fdc23bb283f767a98c342f63a20437b6c14dc76eb6898526e96919cae481226d70c8945fbcd55e9d07a7db9a2d1d51eb10006353e493fc7db1058327219437b0f0a1fdb671094f79665254e17dcfea829650a9961d142fb73d5979997d5217a21b7fc1f73076eff2565bc0acac4d483b870f534ef5b225149d3b967db517ea8861629b668de20118ed8c1e834ae97f185bd09dfb31c21245a33e91aa9f901a007a4a3c937e3f06e167713060bd3f08466bcf13354f24c3f9b66fa929338dc8e0a80a585df7d2f0d7024c926b93ebfa491b623110118db64d2faf0915d6a68b53146c69bebf8da1ab828232e76e5250da8dfb61b3ca910c640408842929361e949a970c0002d3b714a76e5a8e37d314e0a327d38ac29f98e1d0adaafad64be16892ebc2e79616e2764e765433ebe164a7f0f331402838159e0139e4ad5495eb71ca2522111f43102969da6501edfbbbb2ae0fa9dec2a2ab85bd583652089465f081f815ca39952fc06ed1045c885faaad32928871d6367aea7cfd7b970b14c3454c4f5a2f54918c4867dc83d0d78c9f87ad992c95dc5f236dc9cfce3dadbb16e8b71f43c9528b23c708b1977bbbb47d941b9481eb28dc5bb9b4c3fe29e8160dd8a24fe79c3fc1efc5b7238d39e037554a04c78858f542f9e6dd7359bb0e834619fd2ff29720a4fcea2eb6358118c3dc4eb8cddc21f2b81b4e8b22555d068f66ff4d61e22505e4430b0aa7eb11bc9615a2d40ceda954b11c5add0e73e330b6e93525022bce5dec6d5244160aa2588ac9848e4409b92cfef0e32925ee4bb4655e82d084a54c1b4d924c97470b83667dcd77168ce12991e81c0597bd9bcc2daada204bd1cccb3db7fb74f719b6fc6c39fc2f42ebc129306577fe2adb19e6e0a72840dea58091def85dee77f50091d8304d94a1191b465b00de39d7701469dba726a3666bc744883f71aa02e08e64356c7ef816095d195e2a5fa7b7d98d55b34a7c17274c87ad99d9ea29811c206865b00adf21be38afc43d2c4654d354fef8d280a5a1f010c481f6ce105880591803fc50d47d858c18b90f1b6e7609c1b6dfc905b16fa67206d2ff0f5022f344fc33f7bdfd010d79d22f2fb38acda5b86e38f7ddda2a01b2e1fff193234ec673101b1bd4730ddac0a72ef7d27c688ea40121c7f4f5a9116b3de704e9d39baa9c6d0eaef3d4a45fe37f1a2d753cbf557ddb24fdd81d53901b1927a8572f1a009c6fcbacb0b8fad3b16e22b5b02bf92f255513c2dda1951ec2d5552869f8a83038b64c27fd3901577df658b916ccc432084b4d0e2d317d991b04fb88a4667aea7936c5d3b07ea22818da15fe13cd1d924abd607b37a79616cc7a7ef893fcf4e3100fff957ef73323d5ff22e0f15b842b9ed6dced2f0c0658d847b382c93723e10181cfda927cde988593235930ba37a25d304e1dcebb6e09cfaeddcef02bccceec5fa99e51d300369c00ce58c26e68706c9a2246f35296fd5c44323597ef36fe715b93c6e97994deaa2628f30e3d10b099e043c5e2bf99b217e0fb71eae3088f1bb9c6a592c3f1b4b4cbfe2e7b24d32a808655bb43e7a2fb84b6e5b246c1d9e878ce339e8c655988ed1dc340279420a701ed59c8e76209cb64e54f8bd4788c7ac0324c33c2628c4908a38c8bd0fd59059dc245752ea7ee24131e9542502c71bc2be3d2e9b607d060f91b77fa7c270f995a25b39a2499686a7a1f4104513e96110ffd93c185a4f9bde445bb2cad2a1fc85b5c02cf1547370d1cf5aaffb25ba62852d7c743152d14eb7c80511eff3bf37a9bd733f8f611dd220f0a8c3c1969488e750224a6d55c6438e844ed02ecf68e70845951993dad46c6dbeb1942efa03b7ad9875f1cbc927be79a266888382ca86003fffbe10bca1cf77f639c62e963784bcd68ab183e41b2c7c910d7d841cbe1d4e7d8d9fa419326996d8b4dbe0e6443e850033e13d323ce76185953f7523b2470339f63778960887c6aa10a6f3173a6666b2dbeccb132c6812f5f7dcef0e653d478e32c58bedfa9b933593ee128d008bb8a8ff07163a7fe6521dfa09eacb6f6bd9fc76cc3e6c00687846c6f0665f0faea546276cd72ff09efd7a61ff9039a05febe8bb79c77550db762f74756bd6ed9bc410794796cee6391e5038f87baf23173819d61687fcd0cea443b4a06bf285e27432dabc27c64e0c39272284017481f7353d1f1df00cd5eb545d07c5bfe5464f23f89e97fa1bbe2c404ac01f104465fcdf62aea300422b5d545a84cd8295171ff257cb9455a5eb965e4726c5c6d139e4d97d202c2a507c236f9a1411d51e194abb63e363b08f75d7ce715e662e409365a2e6f00fde7cf9260e83c0a0ea4e399506d74bc150d8f7f96761fe83e1a869b71dda6110dc1e5b604bfe0b631328955358903a4c5fd572b36871cb51239723f601f8f4cace252fb349f8628ea362ab01311237fab9ad01034e406f1be48c702f96c57314b8937753f7e3955423e65e2431012b4ae4dce0c22f313cdb747ef31ec428887c2dfd98d0a23266d17454c91518a9029997b1c4e332eb01353853bde5b3eee47b6b0c991ff4e0228eaf7fdda9bf78dd39a0cf7f4c1edaf146736a97460847fe0ed4feac3eecea542c49ecd9d4c97ece33e6b0f99704ad93027d121e31594752bf8325184c87d07b09c3568bbd70f42cc7ba1d752b42d6c9ffee10aba5b966415d46675a2a7e18daed7c2c5fe5ccb2741cc6b7265fc40de6fb261d103ced0077ec5abcae0b6ecb51187d114650f0b7b6be3a721bb3abcdcd765c6621d770d6e18424b4d97e5df65039f65c66d668a499c346146f4ae0d62e20ca0b104fa18c3c2a1cee47d72f2bce2e14969e091741eac214bbd2261da9c306efa0941c1a2926dc15a27c0a19fd549320fed758caf7bbff105463de4b0fa8bbb7aee94edd9aca603118d05c8d8722726008295bbe5519659124d0c5c793bddb73339656f52e1b8c9d2f7e7779e651b224d9c76ce88c44387143d1c8440320b1d81e086f081b9705abd704c2c8ba180b67cdcc0700f387a2ab1cee6aa3f3a9def5d4feb0c4f8a3ce8997d21861aa1393f5f2c4824f83967482ef93aaf0398947edaec5172341760b7308453bc4dda23c9f8a141fa65b7cc548507cc02d72e3a473783e033fd789d0ee57f78a788156d10b8d2991373d1f4f7ba563f5407c8a7b9bf4bb00e77daaf65bc760f633476b3eea247e6cd00f4faa6aab0f089efac0633055ace41a5c8c37de2dc32885e55644e82f6b1d8a5c66cc5df1a5ddc9d40ed5f4c5137f627ff4145d726959609364db76c1ca5a14d17a68bd5b5276dab425e868dfd6744758714c4c153654868f61dfb69e6a39bdc01d168ba03d607989d5c05c35d5074439a3d98ca68195359959d409c44e4b9ca0ac5f21cdd322bc08119275cbd3d727dc14c9d34c4993f67763d6aadfc374a88a311afcc15a5c5b26026ef89a37e64adca35daa40ad8d9d727d0664d341610bbed3a812afd88b6e9f2e54a20e9066e63a794a4950bf80cdd77906ed361ec2b81cd80d209e4ac1d772ac2f1189f12592d99103475da1116178fb55bfd20ec12aac31eb0eec2aaef76366b745de1f933401d7664fddf3901f2882a235287c502816a2d4a1c747d01778706212d688b1aae0c63fe15a946c0d43875c9be8a343a52b6a955ab3e9b0357d6ce2dfae0e810c04ad675cf0abaa7823aa236a7b8b581f5a8a4b95074a727f80fed50b97a2a4b9e26a8481d30d489bacecdb5279c29d563b937ac66f5925df5551a54a35af514953d0a7e2c7e5934ec1ff7dd833f5dde2080678cd6bd6a16713abbae12153d20f118451aaa6b6e2d3cc9ff4322a4ffbf21f45d356cfb3da5294118943676b242b3f7c958cdea832283a0199e895ad647682149b5c41cfe886f9fe1293086e7fefde0669acf0289bb1fd4c200de0a10e0c56aaa2ecbff745442426e3d87914cb1b596258bdf2d5a156082d0c5d27449a55674f287f1644f2b43d47a93f23d65075fae526b00ec0ce38d768f07cbfd593b8a38f7f526cb97d912e14ed82e132324972ba1bc701f7195de4911f7cae33f32a9bfaa072b64130f6272589d685cd6dd95522fd049d680c8633c0905a2e1948630574c14d42f2c9cf1afddff153567dea9b52fc87470fae64c75e10ba2e323ca83c1453f92fa295fc3f1efd958345d67d21db138879709b0e2a080e13d1fd5486be981195f0d0c75b922e14dac365d744269f9a5e416bdc58e97299bdec801fe6ad64fc8bcedc638a502c10c6b42eed7ece5d0d33c1565650166e60df8cc82f584f1160cd638921fa7eb2244769eff6c4a3ca50a7ad70f389c5edbfd76e3c9eef8e8e517a1fd60c64624d9356ebc836bb0f36ee23d09bd96d8f273a1386c1ecae79d33ceec624da5508df163fb77856c2e2c50c33876e4af212bfe34779ac7d5ec11e697befaf28bebe13a7493df34a87d23d29af449106746e029afc2284069f3dc794ae87512de998e685be63ce20c1f657ce680c6d4e7bc93614e51194a82d669c0a6f4c997f54ed35c913017cfb824badcf4cfa29da45cdf4210d074f999adcd6d2da5333031ed867d2566354d1472f2ec902bafd62df2595a8057b818426df98e150839e2797b81e665aca70ae44e92ae5710eca976b03ad314618541216d6fe64b51833f8b2b0fd55f7eb55889d1fec2a984d0b97059d9a1cbe3d1e3b8eccbf949e2079b69a277deeb96e6eeccf5ddbd7a6df164842ab21c5207b0853f7ee5da5c201cff8b14acf9aaa70551306953b8564c2a92df4eb1731d01b7ff7f70ee7c0b1f15f87b885d4707c01f1220c9a711c6c08c78b489e21176a96744854234527a17d6a71850e209750a75ca950a4dcdbfd57e6fab6087e50e31a741761c71ed8ce03d7140c5a0cb769daa39ab0cf3eeebd6772c285f3e307ce0c84f645b74768cf371e12f9a6dfec9e864c5bce9bb556ea889794d62c6e37df80d850fc57c1e4e9a27f663a6f00e8198cb1a15a6d4233481962854805984708c355f7d42c4be57f1e882633fa392df0402d38050de39746122d573dd249e181d2e2ca505f8330625be89230cd10ad73ec13eac2273a849b7b6076b96cf544f5e08b6e44419793dc5e9b81f3342720ab4c7e25b5cac7b5edf27f3ea7b1c2b889d4742b92c183cf35fd5c55c6bdb1db3e11e41b47ebb158f42a8962ff01ccdffbc89b7040f8e5bd5a6470fda4bcfb0f4b5e866b03e31cd9d366a292f9c36a0c0d8b6b98569e5b0f6e92b6b771c8fba2f44eaa9b3ced1357650219b9f1de93df88201edeb491734500dd148f0e3cf818526ca3f5e1a9017f84ebaf681f4044c7d73defac0f552ecac56a2bd078b73b3d3639ae84c19cb8c875213e56965bfd2d95cd1eb3518f0e47bbb65beeb09cd97caea99a4607ae0b5ff53c9df747a3516de86fc362eb89b99dca101f934e93822593a646d700aaf63185e4e7a1e71181d56ff46cca01b227242d1cadd11d0669fa5b8ce8200cc156f51e5808c1a3a3255c65e496ef011b6506fa51f2b807a535d187ab29db1e07330e85e89602a0d9efc344faea14d9fae1ef897cd6bdd5e20b294ac910e383f594b00b7b088efd3a734fa3a45396f52b535e9b3bd3b714769eeddd9dbcb542e5f0afd90a2da407cd02511984de443faa22406d83da6979da53d8d055ee97249a1ec44e23fe3fcca09d2916f16e6c691a70c0571b8dd1adcf7a21d711643472b5e1447367bd920145eb88377740ed5b41a162c51fc1b65bd78e733b6503bb5340029e130c63759a50480045523913f48982cfd07d58359eb98c52cbdbd3ca3428f5fd6f5b5c29d5dae23a41f70c150981f7f5357b673bc1015769346fc9b0acbb140137339a02e101e76c1a8c2e65735a3b61b72fab355b7d2a6f23115fc5322e695bd884efd47066bbcb636b933ed16bb1e6920550645ac12297192701f3551901c31ad5bf3eb1ad4d212aa34517e6ae450d233e089294a4cebbd90848af45f8d99c46c0fd2a23006fcc6577c6e2bd405dd0546b7227c5c1d4b8828102f139ac582e25707924cc8d40c0c4dd404e30e556a02bf5cfd4aaf7a7a4e85410edaef851558a297f540703b05487ff8b60fb819bc227990b4c23e94bdc82b50ca47806a3081dc1c546031904faf2befd2770a03e7305e40fc5b87f291351cbc88a69df5923991fadcca10879216e2a0d6097ef2e6af5bb6d461263f3d86d3596d7a6f66d3cd3c3cc99000cedecb00bc538c7c0f6a521d652ec1c859a47a182613ecc9e088d5d3ed2736ae69c77965b06aade8a0c9e0b40d0a7919852cb2ab79c25b08f5d27cbb5af0fd25df0c902ca9afcbd67b33e13d97030b092a63625cef99df065130035621af640b856ca013917731f956b5040d41f22a5309d945c31f5a670213c8cd2135909d64533bdbb3f8e3ca6f6f22c3a395f811670ed6a2943308a94a6ddf52da9628608d6d9251ca7121bd58fd5e33364ce1fbf15435ee9d79b575b3d0a29ba9b4c9be53f9b1a10f00968a10c8e307584009bd626936af9b772cc6a12893b577009ede7d9e15d11cc4e60823b36e4121da3ef406f8021aa1e042fc2b40ef19f4877a6d9025ece4ba123e22f8cc7a45b87f4da25fecfa0823e4ee90f99055eb154beeaea9b42000b0bf506bf98eb23786c8a849da7ed324bbc68ec9497e6ea7b5affc4c78891114658ec426e975c2fc04e682a958180cbc42fbf26186c213a933252ef0134780b100a52f43de8d53c50fe65c9eb670fd2a6a41b97ab3895b2e04b140b940abc626b59c08c658d94537d26e6fb0b78b5ec781d81c6ebfe98b0922787249dfd36697faf25bed0ac6775dfc1dc88f598e6bc220dd6b2f127949f20dabe9bb40164c2762a9755130f51e9cc9d255dbeed43c097de5e7466fe267e428fe0cc5f8ffb2c5e1df3adada5b5094be02ae90f6280c7d96b08280734e38e4803b1114425a033338f53e40eff1d78ab80db1c0b2755b5a88682e86e5e9437560873f6a8c49a96f2ba50387dd486d846c9f17b4a2f86779a732ae02b721851a10416bcbf71a780de8d1342f07d417608db89046fb0f66b026bc5bdfb4ec869fd6fb481eeb4d1d8642b38e8f3796474c82a08e2c1a7cda3031a0b168b3170bca85862af0e1b6143066a803fdeeacb6bc4fc4f26fa51aab66522007c3a40d8dd86e14b7c27b8d5a35e5556befd17aa98e0ef490323b3e8174896205a3b02dd62b3bf23aaae9ff431f8ab1e6ee8e8a7f9bd70ba3ef414f61f9c7f5ad6cde517019dbbe1cfc26ae473e25d5b04c06d95021c4468daab7eb53b625bd84a88b717eca733d1cd23b559af1e139e0d1258aac46e03932a9d40f4f302999b1d582d2971ac99ef44e7a1d3a3d3a84a94f67e56ae0c98b9d4366eeebec01ee7005b5faf1385f39a2b0855e89fe2aa29ed3259a244d9c3b070365fe3cd2bc379e6c64a0cac455990d9f978a143e8dbca9371891f78dc9709c61d2eba48b5d4982fd64d194ba37b3a2558b9e881ebb2b740134e6977c8fcc7dfc23bb6a9fb92eae314ac2fe48a19506ca74804b3fddb75a3b81035210a2e697001a73b2b2eb220f97a10c1ffe288c2a1d85a23cad6b3596a67d8f277a23c3a4029dba379f1dd72f5760580f8fa34fcbaeea8faff08cd288218d4fdb8b18afe9fc201221b842ee9766b7b188538186f16b4f07084bf6f8cb790d65cf94e4fe619a789b73f7db77669294678902a4773b5e7735b091c155424a0d6126a0118d5da39a638eb64fce3f59f9ea7a246677563ab754a382fed8712486cffa5f243f88dc0cf60ab9076897352a0315c3c31752445c16565385a4b3fd2574fabbb85ada47a3ef74b2411dae623ca1cc6f8f3d3847722591151728fa797f87c628065b9441a74033bd2aebdd6ae837378290e73a4cdeb500ce980954810d7e0d4e7becd56afb3118ffba2bb82af915cd94d7722173970064c8082417ec81dd2746141606fea8387e11b35f5c3fda1c3f62a3a5ff4488bdcc6dbab3ce90319571912f0d08bda2e086f0124f02233c291bcc4f361b012180ce68ae3e70629bc658fb5a4e0dded43e92f2e2031ec60ea7589d5537d989e79e060f3421ee58b1cb4e2bb89771f0b16b7dae24da64d29703d641ba1cc0c4b1204934199c79bd1f418c0eb9dbb280e3fc902c1c4e1c62590bc53b83632d122cedc9f8be93a76f1237c93dd3477c2cf17e7c4a5112476c4eb469b5100a60f9498f8f42de970f6cb295743b577cfee253efcb35ab5360cad04b8dd8f00d4e54ee389fde784061c6badc5ab9ae04a22f718ddf7fea516714dc30b6920cc0a985323f41888590f9942f9253b93bf2727904b1bd096c96e6365f6862c5e0d7ac361526826063ab8de317c495289b802a5e942eaec037ee29c47cb6f1b5702c1290b6c9137c4adb92b9d47354a8043cd866fad1350c51528450e5856fef8fcccefa5f3503c4d6e9a06ae9172412e2b14b929fffba74151f3bd2f14edf4cee0076a3b6b8bb951ebc1cdae33ef12771096fadaefb6560bedaf11b85a712adfa8d6cf59df04ddd2c65a47802d6e188ee529b9c7f72b9781140c8feaeda37ee6e26770605b4d806457055b5b1f889ad672f5345cd84a726ee7525b366f5125662fd242776fbdec2e285a5f6cd13b10f5d2f363d6145076c5fb960538e86a7eb5c582ebe3b28272e1773ca558ab0e90e5f6cb4f6d73196273d8ac64f946aea890eefb90d73dbc2417b7fc2a6a3dbd145621f7e72c7f8a36437bf549c0d7de906a87e319222ca74cc70f4ba1f0b97b77f56b3782e207016039d4f8d283d08d7f1f8261ae7021db653bd9f92b6274c641e23e5e83039fd9e96949d0638fc972678364ce96dec196b5ac249088e969c2b8e6dc62ea6c1f04ee3a326194f13f5476adc7b1d1a8341ccf1b33ac845ab52dc4b9d6c8b73720a8b2385b679a141180aad0d910fbc5a91d972cfc35eef81ce0920e96566ba382d9271d854ffa4404d46ee7dc0c5ffdd03998d1aa61671983db1ed7d71b1245e95cb770e4e188fa3f567f76a4d151d95e88ba591c82c86674ecf2bf27c89e3e3b7c9836a2bc076fcf5d98311cd4267a8d36b00363abf9819ddad3956c51863f23eb196b5b9ee66c244bb25ac16061e09933a99248256ec551292ff85ceada7492bb93b69f80f34793d0cb4a257af8bd44ed1f80c3adab300568717503495f5c3862f39b748203a1d2ca84b16e07c83f521cd14e858b87e3d412a6f0413d4ca30fcb1396d1a2deec7ea90bbfd45289890ea130336f70031cfc0203fa4a97c2d6d17d530b244bf8b598671f9a26d8eccfc46fedbd192cf45c5f6f4196245e23b17dd21abbcda9be370414283a4663af15448d56754c2edc3e037de6ca2c56c83cd635444da1dc8a4109eaa7fba87ec491661bb35288d9a36f925fdd2791d7d6d9e47d98f768eb7b46d4f9860bd731f0ad8075dfe87fa51991db090571d8f42672714ed1c15e92c61ef460fb13f10f6a5ef15cc191981164f94f6e937c56f178cb8c8dd3ccb6dc4346df12106c2696634c9a3565606d67cfd3854f7055b90773f50ae81326128f48536c310c693cda8bee6052d6bd4d4da1c3b6a0e9b2808021460066571c0d620ff857f53c570e89ea33ac510487bb28dcf5417663e17e18f3344a0f42bfb10c4020c126e40d0835acd6ea89473aed501c822886e5495bb76ba908a0652f011f5da3ad254d08adf4b9c50d8656434e11f9159238a8e0137607001b4dc2a871ac229484824a6c125136550a92bebcfc7b9329474803e575f5071dac98ebbd68c61f6c92269e6c6084390f5857310e4a0c3d6737f35f87a4042662a636430ec5c61432870c0e045508670f768939a73f196083f3ba103c9a9761413701fcdd576ae040f688271cc37436cd65a228b61618147d32b530bca00d6a7453fdd65a64bb0584d922f3d010ae091a2aaf4f23bcae07234e6cecf7d8c75895316fcc0423cc14d60bfc1aa9b5636ae14e2cd5485596aac3c44fd687b30fb8f2ccfe12a6424180acccc94548bfde08eb5ef2b9d7b84dc122b8b4287d7b4d10fe63ec368260aca963415da857512056776a32df1aee9bcc296e6617cbca8e75a1f95433e894b62e4df2bb0f1f2050d3108a821f51b7e2ee4bd2c692e5115dcf1dd586bf1fe41ac1194bc8e58ef67a705554facc2705413941f17e1e9c13e4d4d0046642becf7013571b7af2492fa194cc685f26777e858a907ebf9da96768f766d2e01dccc4c6a48117a7db933f15a917e5619542fef0695a4e1137ecf90db58a557444c7a80c7599585ba5e7292a42ecf0e8c7a613c987fadcb5b1ba89ee0d18e2c04a7c544eec3fd9c1b45f09323f50346ff6cf7fbacd60c697ee562a801538952e67e315be7e24fa9c17078ccc7b815d6fe94aba0b29764ecb5e0fc54bda8dcea111ab2b8fd7ec004f12a27385eccb9ce08f036e9f787cd99e993b94f31dcbaf3f35de4aa094d49272367a14c3405226c3380cf9c6481c743b74e2a78997989f4226201cf6dcf73d038440d8046476b5bcc1d8eee446be4ad53c826236babac9decd4cbc055c9bf2155726be71782005c54cf194df96e12f6cfb25fd2e3ac19e36bee73ccf6bcb832124e4d7b6249c58e24e406563745b181cdaac03fcc95c4f5f20a920c8775b29d74483c8354f25f3f5090891f5c9cfa1fd16ebd30fcaab5475aea3e195e2a5018b57664b83a0869f98c33b79d6a73d8696211622ade46be7c02bf36c98f86b8a2cf339ae35675d29074b7134b4c42d2adac5bf771dd00389ea0c9fa044b9dc28cfb12d5203b7afe21ea0df0d2d72ec13ba867eae37b1c57d3f4261d34e8118a5c2d3132d31dd821f6acde70222af3b6b468a437636d89f4806564d4ea5df7eab3bfdcb49518409ba3c477547d94115815eb948d3ded1ae38e350e8cc3a1fb34a8cd0ab435121d28fe0611bc1f0036846f1f4739cf606c9d94c161effa04f8b78ec666eccd8831700d2b0358c20ca36d1cd8206fe0a642981102ba50b73d60c8dd2e9912cf8a3f6720c617976cd9122db031472f786c3d3c5e617ce0990d330c3dbcef0ba2607d6ce66e055816bde3444d40637dc19142b0218da6f8625e269bc4478d2659156bc0000643b65b070b28c31c6c1d36d7576d530149f018a00ccfbf13ba52eb900ad7bbb1f5e0b96c1d95ad068575a2ec5bfa3c6f02170e7a84669081312ab610063b4cd40d5132debb3f9c7f143be5e568b124ce91ebcb56498d215742086cf22eba358fd044f3fe989d6c2d4a6a500cd658ef5e2584005658266c919affc5667b045184b1b46c25b2303bf9f6c850a582ac5ad53674e99e949383cb89c5f3a52861c1f0f07b21935afb85eec3e2aaec3302b1a61bdaad280c4c2c9e29994d84c1eada2d8b9022afe19ccc8fa7534ef1d4877af2bff0d6a6a035f78a4c3962b6d1e01d878b4d93a9aa0401998619689e77f24d6b718a3faa631d0f18cd4f1963ec125e009d78da9b4a1b561329118280b47f11e27c68d5c7e5fb80b34f04806667faac4362da86b420bf0393c1dd6ea1455628733c160cf86c520e075cbcf5b3bc52584d6f76b61c1445de04156c03d64273cce1e94a5f47680f475e939d12eb21fb02e2c8546781f2289ea51a818ff51990dd88726579a4ce683f953f72bda2b9d67125e81619d733ea7859bf3f7f58443a123d8746855925c03851adacfda0c58ecf7f5481780f2180c476415c798eedb8e4e3b873ceccd060a79f479437e2f42e46e7c6f7524c971b48cb7deca232ac5a9a952a92b9161bb166560bc1fe18d51782a811cc045c7afba6d714092ff37598fdd161804ed696c07809da6933dbd1fd56da219ec88038be33a87068777cf401e9f99d785f96299a0b02b4bde8914e7ac88656c257fe3d3148faf1665c0c055f8739926e4ab9d6d092614a7d8669889b263f21e4a7831f1d8efcbc8bb4e212407871912496fd0e64f807cc9695e06f7211d046b6d252a9bdbfdb5996c7d3c1bf38c6fff516f4cbee38846ae0f7299d836b5a0d2540bac6c7135522b328482e4aeb8799f8db2a1d6177bbeca5cf961e2b1ca69d2fbc4f21e103f0a3f16beef23e9bfeea10105bc9ea4dc996976d04a8b586798c1101688a7d1cf101af93fa61a9ceff9aba5b2c23227e6c89996d6253674dcf52376cd54fbf319118d0fbfb34182509589e71145029f7bdca189bc590752af632ac377fbec58cd2bab5fc73df89adb534d27de7d6af1b402a032230bbcc395c45ec1e1e67707a8631644428ecda7be8d163a62b70264f6db3c060adbd89c825880f06ab6cca896dba9ef4cbac4b1b02082e8721a502699aa1d8e8d946f37c2dd650328f29e0b658834e25edd2c8256365e6e397235c5239f10e9f5638cf12609535fd53087a1fe37e976c0224e2ab7c215fdcdaebab61243c447157114aa45278f9f9919c8013f1023565117397cc0ac6c39a230b7d13044396ff6f68048c2f8321298eb676552e71f029ffd7a8fdbd291babb2681d27f22043adb326b34ac1b143b53755b2aa6175c4d4b1e573d915d408ebe8903dab082e2158bc44edaea936c50dfa5725469b14de0c24e6aa73e12a6b5c77d83ed2c271e83f159412eba445dbce421d2079d2b57b543284bafd99708a41725ed72add1b5990cc09f22376db29e7286080fb5f6eb9c33a9ce7cc5dfafc38c2db7b6648f4a812bb3d931fc796148a1433959c8920bb9c63a16fab62470efeda24b69b6315ef77c0897d8cdbd0fc004396a78510b6a04f6547157a9314af904d06b1f80f585cfed0a6a1757e39142ef7dbc217ffad6c7c53a6a87e2e2fc24893834d0f19ad26d572524f4f529bcbc83ff3baf1476b624dc880ac207130fabd9f53c58f66fd54bfe33abf897bf0b5098defc9fda87a98d679081014266cd398800d2f82b0f58776017dfb0a6c9a9d568b770159f13d64a55b8db8472a5f36fb33066d36cd512125462b82d04ef0857193d3956c64c98f6d75e674e779b3d6131ff3272e74f6cd2753d4a841775e69308d3404c6b1dca023ef5b8a77fa6e7198a516e41c7249280e7d9ba4fe941c87cf20d8d05102137311850fd99706f3b13c2da9e0f6d380a7b5e0d972b505529b9e2461234de14461ab0656e745979a1bff4da5e923711313482f11e382d8b6624f7a9caaf77df5aaacef44b4bf87a5403bf474ce1dbbbf8b09aa04a9cb8b8254cf26a76ef5692f69fd2cdae754eb4bfb679a7fcf84db2a1098f694f00de7661f49d09b693bf06250e17b8ea0c45b2c52644298a37398715ed33155f11a92b7c92fdcfa2dd3ef859dda92df8716132a993dec3b6e30858011dea163400c224bdd150f4a433bcbe794a52678cc6891816b15465b1a48047ccf08cc2be03fad4620fe6080a9f190a6c62e7721b72d9a8d42a787d4005e5820ccdb0e1f0d2e78605dfbca3c9506441418bf64dfda18577051a2b6d74f8b3932bb43142362a94165e89f867f9179567a5fbb93e54c2d1c060917aa40b4fedff80b61118a24e3684a48522dbacebe0a7153e5fe51f07141bd81589796144eb7a4878a74c3a810072a2043db0606599eb0fb39dbf1de8c9b4251d490218f2ca287fb51c15138dfcde4567a5729c459d1b3e109d18b5a0bc904897077bacd964b6e1b93c6a1e3ff8b0f8c5c6ba28eb58ef70da2b9f31af3572a963c603cd5ed547fbe6923bace881df416a9c5613de566b18ee451cfd56436ba8d566be9548957f7333d97799ddf4513d520410be496071cafbea035e1e0d3f9f37a497d245222090a8b64415f895c247b2e1fa5f792d04520545da7d51380af944de440263370a2de3cdffb416c038d4700f75b460a620b4e41ea71f7f5ce3dbafb3401e97959943961be3489720ecc0a622420e15b34e91c3aaf17bfb8765059a6cd01a395ca27806a56684e103a3a923fd6ca8529c4b4da198fe2c5cd456e71f355ca986f1900e8e76b916ddb1dda5e92fd9d9f5fb6f70d37c4af3fd0addc5cb27a4061d7b6e071af2eb4079da6099b02daec37f3db3c880867a5f7c59f2941e289c8583e6cb38ac6da5502412f1bd624d062e98ae6eea24863d1c3e160c970c8df8169f81d591db217fa7545e51559d9c8b89891f42d30d44d7a7ea94254b7e9bb5443e2311da4f685e2003d2d6823482ec77c013bc9be12650caea0aa10cd2d023f890e388bd464a68b52e3a2324ae3052d05082a756162a83faed83b0e357fd42e8a9646411125f684255dad820c6e842d06e2621777924843168e63869d22e76bd01ab32da99fac420fe385911e90b9a0cf55fd658a85e18611008614dfd6adacef48566c3d4ab5a2333fce04cbbfe7fc1e3a30fd098793bdf61d23e04023acadc4388c765500bd929ffd5926792db8b53da7c68f90fa5ea9d1a775458040158539290d9f0b0d97a1cf48043e9f9f4782fa01b57db2a26b0f3bfb4cf26962cc96ee8e17c89296e33a2a8cc188e2f281ab99f77e5cdd92da90e162bbd55412b5c1332cc48f60475ab4c33ba4db2a6ff74a566ff3d075effffe8aabfa1280338e348bfe462001ffea646b2a8ada284a52eef26d9ed1dd26614bb4c122c74cbf4fd11c5ced4456ddbaecac891986b25a6b48f35b3fecba07fcc748c01f0d5fed4fbc5db93a218714f17c91856a2689782cb4a8e244ac008cbc7bc443f5e01f557b12b7d8c236cc70bbe2dcc191f471c136d25509da8d59d966e510ef569677d13ca528cd85fc09c7f192711b12e66acb920943be7dd99c8b2176dc9788efa558e6190cb677471317673a9981c197f70643708363665a84379befb18112795b3eaec1263923fcf5b05692a17160e4948609546cbc87eff9e230306e2c94a94c060bf385f41d8e706cc093ac6ac995b46fbf3dda9182120bd716fb2d3589e8d1789b33331a791fdad803030e3f15feb31f7c425219baf7b57a039a3da11cea24a77c38b2c888d37e4cfee9d2eb5f11c03cc216aaa11996c79afff43a9eba1d95da499c107131f3acf8a26946d51cc916bba704c5e6a3fb902f934d03994dd0b49a964a9604980faa825aa19e988d6834caea9eb7a30cb6a24173c7843955e767ac9771537f89b4f3c867e5cf071ec3b3cf1641ae28ccc93e91a6710c7882aab524d820f6f40ee776e22184351734cf006ad1dc49ad6cb7cac125822895d5faea4ac672e50afbd0ab36ead03e350f71f283e52a64eb32b8f9ce07b0e8fab37523989028e08e72e91959cf850fe47555056566cadcbc7fe403c619928a418957a4e795c8d25d7f45131a9027d003cb2aaf5ee9a9884f8b236e6e1ae5fd9ccc2cc14a224bf1c859fb0b8bbd1abc9f26257a10b08030e3ab4c943e7970efff661742f226f67c664cbdff1d314d13f61a59ca74c1494a4f16825d44335082d61b212384c0779dd40b38bb6c826bdcb078eb78c5182e3a3e529366d7e11cf4015a9a13bb1de4384b3e690729602efdb5e941d84ebbb910fbe17b8b488bb2d561187103afb62edbc2e27c9aafd023a5e539055fb1f9b2f0d15f0cda7c55112520ce2a3a897c45af094ad767171878f4bd33adf10fb60d4671744aa1360f7a45c4a51afee31786c6a615adcf155d8651a6a83b01532c4ab0bb5b2ff1df12d0e5e813013e9fd7c49db60921fe98ee44649ed4ca8119641598c61081fbd764d4787cd2a056ad23100d7f9c9a62a5eb20ad83863f63e5618c99f6466e43e9a949cccb57f0eb513c3f1560501c619929d22cdfbbbe08b129ceaa0bad3d6c0468b3d624034d7026e7b543537b1b03104bd23b194547e1abec6da0b85d927b68fb1554617a24900608198b316f1567e67097012fe3ef8c3513439030b0d9369e7b4acb5bc16d64d95cba1f486cd0922671f77ffcaafa1904ef2bcce49a97772a5a5bab4cf7422ff10569982df1b81d314b7888f331fc03f10cda156159ae844dde6718960093e1e28e28ec79446235ba72a9c5a31cf2cc3ef0432aac89ad9a084d2bd3f550786274ccb439370d63d1789a6c1feab4811c33595837b864a021eea4bda27de5ac38ba5ba3e9c5aba3379b6dc2a9bb5a1e01add767b9f09588aab7bba3552fac6ae2d7e43b7f9b08f84876c55da58d79e575525894c9205271405dd2684170c7ff4e87bb2ffa7306df65927b711dc6d01be38f509f3f0169145414e7407937dae0407ab99d2046ef2199ef09f88d51595db390dc8a0fc43a4804662f0d52475a07acb58e35057dd9dd618fee94e7528ce13040a79a91d0d81185005b315ee9979a8e9bd758c466babab1ba075feef470be3f536dd415b0dbaf06dd388b856e8b5e10979b1325da5fdd71280d289fffbcb88a1309b4fe62ad71f03bf61418996dc7248d954498e72d3a9fa2e62865f5e6e024d57fd9a9057dedf48077e81f6081cd1b7f88df7ac5b4ccde603ce4953d7459a7511fbee4ee103d2c97ed308d0d6bf70d9a64504ef63fd8e794aea931eea1c3747de3717ba52e45ce421653a8ddeb2dd2923ed09737118ae6fc160c78a1174482538e23694e3e9b64dfd8692696a7f2592a7585fb845e8871469bce465ac0fa427479ca63c79bf008d6448b2e4647f5ef5c2705c2306a31ccba1b094fef9a6e99763d8623a37f3ad7e787e30409d2e1ca783c4f07c54d5ab889ab58fac26c60973685317b79f2a5cd0fd2806041cd1ecf07146796ff7e76c560f549a4768355deed596ff01448a2388832ba97b87df908c5abe610b138236d357ba1ead2a7752efc3ac270b05335d7cd9948d3698eb782ee9b96545f1c9bdafc574253f4c2f1790a46f13eae3f6d6d8d6eed2869dee3af9120634765ac67431536310616a85cba0d61f765962a76d9b7050580312341c0551fbced97d62f5b2a14604fd3dd4bd2208296f36739f111b202c4f08405281e0aa26430e6ad6541f487e5e010838e5cc6841b403fb6a4b7d9914aa34f6e2110a9119359a1576b17b71d2eddc0dce5189ac4c2c66e0ad703ed2f171ea4beea177876a5665f728cb5bcb62e60526b791f7ddacc1a9acacdbad576021d275397f11a030093a2f0c7d68c414b274542f1aea00eb9d3abc18a26ef534a356aaeb9434c583584a3e017de01a1bd027774c9ce784e1932cff017af8ab5e7626163bf430d4cbf3a94f2bdc16bb70ef9f0236cdaa87d238b54910b618f7a0c6b4e013b5cb87e809d0109d61eeed605160cee791a0e71310ae3466846c64e0feb940ebcdbc327cb8191ab9fe62d7764a74f1d1ae6d263b38168ecfe5e979fb76aea03076314ae34247e7064bff446e69e9aee713681bf33b8f591d2556ec696454d30ee34ac0a26bfb5f7e2b68ccff644e72ef9d1a76e503df60d1f0ce251c222c586fb29b2e571a40f08b87d239a2723adc25aec310626a71547b9b421c553900b07124aed06eef00314f34874e9b11c5de8549d512ae9cd27b6971f577785258c1c8577f4e38868c20d60c63cff9a60dea478977e3244934f68e84fe09075a064db019fe5610ed18eb56845ae35280b3286a0603ec9494ee8ac1c9c99243b39b726c7e910ab84a3c43aaddf0c15cf45bcc5392882a82f4f909b1e496d83947ef4485638f351ebf744a8899bfb1c061306ae5fe48943857753c3a8af90d229c9d6e3031c65a254da1094a9bf556bebd5d6788f03b48d8752265f7f258885ae684e69aacf58d3002877931fad3517a3d95750fb58b91c5c7e850307271c6713147b40471531e819f4d1b7a732f2d12668c1f7ae216ba26524ff78be7d1c6fa54cec4e0b10611afc0ff20b4f7f39ccf787b65ed10f0ac597907ab256c5dae2566c3ce6a3cad6bc6d90f262cdc9b0c15c2a069735bde688b0d62dae74dcdbe56bc1647654bd74ed36ed07761cfbb7dddcabc2c5473db42db06d55f4e262c9d356c7a65f1a38ae0e695faedcccd77b6e9cd935a19fa97f8b3c87b62f29b5ae8ee51e538b39ebd06df2b29537afa0ac0f41a6f268f86f392444f91c681288a1fa26014ccb334ddf17a235e5d366d40b589439e3754318618435dfb2d040fc4d835f2045ab3e34c7786fd7c3653befbe05406efa5cac51b10639bbe888f8864470c407a92dd41dd3b26c8cc944556b12c0aef39067cbc31d3299e8435ce0f991252027dee11655aae8efa7a639c4decde3a8ad58642f479b00af21bb2f89de77be170d61432d6fed1af2115fb14f8c9a9b4dd1f1cc9b75cdef4a0f6db249ea5d5f385974e28a5fcd89f9913eacd0b7a09448ff8bc34fd733dbd1faac00c5680491b70910b9856f68ece7e4a4ddab3c4f2f3c447af08f60deb0d3573feae85f6ee3e96dc766ad086934b9978b8b7c381d1245373e497f5aca3c536acb46a09dc31936d531ba91eb864a943bdae68af20d7143eeb65956c88f5f0ed5a04795cd988c8a6159858e68e3947361cab35e22099b3ed9ed195380a43c78ca220e6f3e97beae4066545a07bac0baffeb8568c98ffdab383e693ce529555654fef6b8cdafaa8454ba7f441e935daa4ae9c0706b283476e1321cad7b23ec17a4d39d0afd2030680d2152bcfb3764d95dd8bc8742cbee91eca6773b0314d4c9a306ba8e8c799a143c8edbb6aab5280022076cd75d6456b4ea9c744d80acd8564aee5a455050b1ed020f791e115dbefe56ddddd2e16de00eeb740b2cc2adb4f9221dec58fac875671139924572a09c034a23e274d67f5e3367ba250f5b587a5cc06cf1b21300862aa9bfecaae9748ed10fe09c427d5730db78478e64281884aa18078f51bd7839c5ef64a9f89fbd1346aa62bf97182d90b54e106fee199bbce79d5709dbc3e77303529dee3346cd5bda021246ca725ad0e8ea9560aeabb798ffdf0440962d5badac87ba91cb1f374cd32ddb0d3a2863a81b675527142dbb8a0f2de281c945ea9e2f2f5934e0e0b8f0f9ea804e59d03a1ce1ee1f20c0f9efec78451385f40729680a5e9ee16b626593e6437907f2f0f32297d0f7bf5d5e022f3d4204751d0fc942c5768fa8ce028ca3292a25a59bbad1f6fe623c5a6382ee2d4d6c541b03ebc8d8ff5ca791f5dead4a73fe6e9ad2cf97a86c5c89ed28a4d4091cddd1d5edbc5a510b42a58e00cb8723a3d62bbb1c39f82ca29a93572c9b1baa32bac5ac3fffff438cfe85cf0e7d47d708d5a4ccc336241649ff993e874064b69359611d18fa68c678b25f0fc2bf15bd05477b2da4e977ca885ec2c4899ab39f888a79604c6c9cd8f4a4aef015eb87853a445c4fcffa7f2d4803b790de032c02f990ca90e73cc0ffc918191c11d4690bde0b4d1ae6691e9c635a4a3e0dee27b293d9833008ce6964e3e3a5ca465acc9a29098ec3179650d85f7684530f735b076b0409d1e9ca4da3af1a827f3b56ea1260a29c184b3ca9eb66fcc32b7025a59d3c39fa9c171641cb1f942339dd605a4bdd084fe6efe79f1619498573fb9b40e398973e9dc27db4d7694424afc4e5df87b72284f6128bf3a8c6e9ba3333459b57b791ebb16808f47626829f8486f57baba5b79e12b00ffaf944e2507d3349302daec26db8e5b5e4fbe8e39cdb0cb48251e674080cd5f2ef5640c8b7f16da63ce2bc3b584b602f6ee7d4df9b24055788e46e7293bdd3b55dbd0daa6339c43f93598431922dcd65a1a4ce6b55015d1a52fb686439f501a136fbf0654a029373d8efd8e458d4cfa63a6a682fc7f834a7dc1b5a1847fa0291857f7b3f6d4963e4a26757b4fe02b763d0f825220d12a4127e641ad434d8e8fab82a84af1bf34dcedd99c52f0d56767e68e2f68b91f24c0bb634bd5bc000c6d25280dd22d8b00642a7490b707ba65c6b2837fb92337be3fc52ed43b909108837413bce5990836c0b8e1bcec16ea4d6fc9265af3fb867a2fc644b32942ff225a9944864ca42e13e88033f7ccc3e5162ba892487aa5e73b4ab3560911bae9854d2adef978c6a4de172171810e59efb19b9c19a807c96ed9627443b078c6b96ddfd163e464f55f83e96f3be7d1443cfb174aec81d0d253872b66622fc794591b4ccb486e4a304f5345f03edc1199b54fb62a1041086ee4c796da9dfe6a3a7d356669cea9b6f817c3c25e7686448b48eafe07a6c0de1189d6d4945d220d2f7bda659232af52d2e23079273dde61f7c66a0180806cce71d9be9c4c416a52ceb4e4793f2ea089c6370871f0310e8ed95728d38b0a6e2c0bc1916430abdc2eda8e2399fec32ce3e3ead4dd0ee9fcd9d57731ceed7d1f729db36a68601a19f6f5f98a47715e7383b918170a0b6f6ae7af891b43c2693fa4aaf136e47155bb22278b9bc1cc3e56c2dd32ea65279b4bc1d3f603b2fb889e91f9dc70b0eb6409465e248546593ba035681cd179d4314de4cedf6409dbe84160165d4186cb5d76b0e82cc607f7cd92da7856399739d7a846d25c9fdb7a5f3305d053b98b02fcc32afa59499b9772b744ae3c8700b1d1b529364e5df642527ad0b921156df30ccd862d0744abbe550ed9af51bdea499cdfa2f4bc2c4975ccf62baa3a3c34f9a942e6fb1e57050753f425a49b102b4549ec142acbf692a4e518093ccaee43df42e6544693b4189e435a59b910fc9a9bb4bc45993434e03978ae3e4f68535866780abbd2654b69c59c27b0a113a53d7686f057295f017eef27414587ddd632c2c6643cc6403c7c535ee27a1000a3f9b40518b363fb73a854b8be55caf78fa31d007ace2f9f18482f51f6fc40c77b4a69ba5dd0f534d4e44eb365ebc36e99f613972f317d85ae41da9535fd6d9c67a55ae0d1f432739baa935f300f62d8136835b94b7b05ca62b4e3826c5759b12d6d83a9c11d90a95ab82f0738a05aadc1258639ee1b7ded5b3370d32240c9022c399250c4c62838ea33028eca01a25d6f91014b4c898283ff96bb25e4340535dce369fb67bc395c857f3f582c35f57499eb100b39d4152b842893c9a9c45c80674da06da8e1a530b37fef80406a52cf024a16dc44ff1a179a53d7de3f759ead1bff008b99a9723e1fe86c60917f7cdd2cc2e78f7d47d8266c74ffc3bf0ba022d3e409aaef094a9dc307e66273bf7af9e3fb4b6219847c8e7b1e93d47967bcfea1216db64fd6fba30677e12e3c6518cb51f47fc39661950f1887b177e8ef4e475a9d932391c7f828aefcb51bc81a65bc4796b3f21a8499c176948b7e864f3824b94815af5bedd752caf80df8c7ab337eb3f08c68198c5f6aa970e7d2a2d65e2c4f3e42f3caebd1f8f9a6692091a19b9c6f40a4118e8fa366f8659d758b6a2bc275d69cc901324693aa939ce569577623e2b6055954d9862261381dcda9560b80e37c5b7dd74936bc35b24e438c5ce4521be3b20265a70b223b26e6436aaeefb4b196e9cd087cc83ffe9b7be658a6c96366e71fd604309b99453810370930ccf0e40f64c19647c7bceea2f183742a4b5c7e31b3182e6d82969f8fc3349fc11ba1ca3720473d961fd5fb8bd67ec9f556f4d83f4dd8be0c70b76ceebe8a06b35bbdbd6b22aa2b2b65ee8bf821dfa7ba188ab91abc05366bf87428ced12474e88b8324b0a6d368844d82e6bf1c987d1d8526fe8b465f09ae14fae9f463bbddf2b044b9bf995d8d4a31ff0cbce91ee1bcd491d8cc222bdee99f8c1aa1ec5187e4554170491f75bd7591389fd7f950e80eff77e554fec12ec0d98560117c05526106968c0d0e8d0c828d67ad7c96aa05b3479d53b279e92607e7dac064332ba603d437b64a72e0b4686dbb99de5acde5c4af220dd7aafec0dd5135398dc7be12b0d400237407c5cc961a7a6bfbb65607127cda141397f06d05839b54550121fcdaa0cc247ac2cd63c5a2b0359b6d0607d1bbac8908bf0ad2794ca97c473f26f414d4a4ae0649bd316ab77373061635da9ebb0b0242918f60066158099cf474956b92fda2ef7648417331b07ba69d9a71138f7831b8f322e008db5851312434fc4dff01fdc8d8a84023888b6e45c2647e348d170a80bc0422a7b5f93cf7e90936adc3f026f131ff612f5a543e2d989d536ad154cc0e391b767d4fa11d26f06943028d880faaf985f5b2eb02b6f707e21d60bb98b6fdaccda532eed5cb0efc3384bc8d84d0d1d9932728a0499f7b4c68eb656c0c47fbc8ae7f6d39d64d5062a2a95cf828f895326e8c5883356ae574563e804e6e41a437f73d5fbdc188c58c88872988dfc70c94eb6323c35ef8b3e468234e89f6ea5214d051756b51be8b77e15efdf9e3f9f747e6be0a30a96d04d4e806548e4b2e8f716d5dcc1520d91834ae7b238d00e014c57ef0b3c3942852cff2c106908699aed2f866adf482c9766a24409f895aed453d2ef5ea141e4492340d9a270648685fb04b8eb525f2745fd22cf77eb64efd9112a9b943e22e455cb80e2d9f2bdc0b4ef879cf472701fa22ba31080ee15de96d5a916b278f9ed5a3e254830a7e6fe3d0892c9c8f5ee74af8833d66d35b29400560f93df7a1c2ae618e4ac29a4253168abacb55aa949860962369544a797f2f3f23b64bf1438f156c6b3e39bdff51c23bd179f284736d88baa49ad92c1578f30cd58181afc1478aa97d89c23eff13f09e8ddd569a0c5c8e8ea3937df80ba15c275ceeb96b10bf8dba9b05b342d293ffe99dbc2e0652c0c5b7d24f290fbd3a3fc1d42775af43289e31f2d3d172cba27ed726664e4fa0b4323676b344779084dddc0a87d6b81777cd7280731243807d9b6a41ede6e32ffa5521e9896bc76d199fe203f4d1a96850935e99270b014d70a5627a331781a1715dbe19d4533b415ca7cf7318b389ba8abcfd66ae61acd28b4d4b52c3a3a67923bb610767bf487df41cd34762683cb13e9a7e6147a8427169995bbe7adfc6a0d8640c4ada924c965a34791cd63bd69967d2f5db09653ed1ffb9e1a7050f1ae2423ebb8ac66b1186744f93c5b1e31ddf13747f778b3d865e8738ce6828d1db6fb56fed055450024942c4e4c8de14a29525318facd680eec66e2b0d53da55405a6dabfc0d1952d5619a1c3ce1340183f2a2df7846b189bc7d5f65c02c306e9e1d6aa38087483e5b53f6e0087f8c6bf3d096a47ce532b3503a52d019ac16bf2214d6311d6d30b5ea284f40ae42a13b802c816aec7cabd93878b36689ffdca0dffdfef5c84d08438eed0927cb83c4bb60aa578552d3d9a172f6977c2e478f75347ede67d0c90f54b633f49670cc5fea6c0f16a6db0672009237014b00172180569f32a49715fd1db18f5052c75b4789dac5de7fa805f4bbd50332efedf867863c4c2673637cbbd8931bf32bf6a4dcd48c5aabc01512d2e2f0e412504ae7e5c74dd4894b40dc79e091f46d8e32cc000d96018d3f7b45e76f75aaa69b34d56313fc6d9b547425099bf7ba4d0cc52fd739850f7d825d0b3e9759e88e4e52265c05e0ad5fa8c7dd8a3a2013660b74da57d63d7fbdfd8ea326750674a0f71b3335b905128a58549f6fb7c6272edd3611b24a626fc9ae48a09d19bceb872932c84b77d77cf5f77d97c59b03252dd64bcb7e60cda1d5f4d36a022adc2a7e4caca6cd297baeacaa2608d77922bd7636cc31c31a32fbe0c8f9bc1d93d9d60c42170264a286d082fe35c618283ba537f5a023c39bbc0755b70d27780521d5e20ce604aefaa5ef3b0e0cbc681c241552c14bb2a3027a74363d158e00364bd3b8ee6a498b992e7c45b189689c80e44a0ac94fa7dd6a6093e56a3ea9021d4fbf45ae0b6236a7a0c9feb9ec5a5fda4506c31a26fb7f770bda6eee92826dad374b43f747532ffac7909184ddb96160860ecab0915d4214a5656be796fa69be156f82065514f6c6846b5a58b1bdd65676ab347ad7af6756fd7071264d45412184e60f148613959c435ce15d1336430d7c2accf2d68970a787de14baec6a931d19af682d75b1fb77d347622bfc049c57135c0a1c40b59da3ceb577eb6dc4ddcd8d8dbe71e4c028f89773e5291e9cb49c5e1626e92bb14256f3a06a0cf783511639884ce29b0c25fd0c0ee854b38afdd348b22f702c30e8bdf76b1db91b2cfa2fb96abb381ccfcd3b30a69416e7e9920c898d3d7282993ec2e78b5f6fd31534024c439675db3a6f90acb08b42edec9a579187a80c8687e0056f94709d06ea72c463e6ce18e4f32e1a92043c713559f42f148658a57847e53d0dc0608a932b58a27a6952361c914669fd5fcb3d100935b954f32064e65d43f9e56f01bab6ab195c05a9add82d220e4a4fdf8e288a6af86fe73b2dcb75ff02021ca165aed413381daac4c16306a7d6f67d8b132036fd7d25e24f7d40849840c2c37ef228bd5c85038e9d88e9269294ba97c9b6f21fd89760bb24729a3647ff56bbcfff4ca2597b10a15be9a28b4e5a4ec6e6ce2a2524e97d42346a01b55dcb3a22820846282be27e4dea9cfec4b7a27b0192631781a074292bfc6db821e32cb2bd296b5324cac6b6d47822f8f89e6bcd266176036f1c7b0ba07cec9e7a11ea63527bba5bdc83c159f1f9c3a8e746205a5b4bdbdd63ffa9c231ba877dfdd819c7ded29d69da758c210ba4aa44baea53f0732ca1d386c29985403ff16fd75a0651adac41b4b113ea8a667403f657354c309f450a9fbe739c05b098d6fddf6cdf8c682b581565a5db863fa9334838c85b5cb4b9148ddf33dc6c4ed6ddb4e01b3d87b695a90e79c627acab441d152fb70cea5811937b44b8c991d80fb2557224723764d434c11de730a3758e73267a0c1b1ea6b9d45163ccdab9eedb1fe6c87aaed0d4f6df7747cb1bc6e0911ffd6c433f3d1780deb5bbcc98859ed7413ae0c3f1243caeb8a7fe09462f699db47073ccc81b501c3300d529ffdf5f25bdc65adccd8326d1c487aa8e0cb021c5f418c88d0816bba42bb0deea290b84ea0dce0c51f9bef3db62a29b18e269466065b3275d8bbb1414e0e2ec2954241fcfe33a9ee5b13e36683a02a6bcb503f888f3f6fe8a24b7bacc9f8eb89226b965818eb9e510ef4f5abbbcdc2c60a9b5d89ea8870c54c8bdfa11fa8441e7554851327ae29f7c6416953a35dc9b4118a571c46efc3470368ead8b567dae7e91c71f15bc87ed8854ccddef696bec6fed4adc61e5285385744b21c51daa4dc1c188ebe5ae7794c5323a9f09cca47f4c4ade28a1451d23b218bcb5b1719aa6ad96182a5f9f46567b1690e25938c747117dfd5ff3568e020764389421766a245466f059c388f1d025fd0af0d64752f64a470fcb89739725072d519c4f2984fd5b5b158857e16b45f0dc0fc519302ca654741664db9c080b2c9a79f556cc72a47cf3fe9fe4766a504187a64ae1337343e6bff1ea24a0b26f63ac3db5b6db8a3b05ce5ea9375bfd192c5b7eea91a3dcc4850c4223e34a63bc8c99cfb0d497683b58caa330a1e0cac0fdc7e6fbad6dc3240eea702b5caf83eefbf6f5df771d87ba6976521878a6fdcdb39f6585613f48ea306c91b215798a47fab3a4ae4d0e728a43cd8cfa94b5374f8039d5fafa3425fdef5015105951b4a345e4ca3964c953ad83456313d2ac1ccc4b6434f36a1a1771237790e5b853b4348c5a1fbbb133e27cdb2fc96595fd44ad2e29924cc83bfeeff7a4040085924e81f412f6568c10ec399165466e4038acd2f75dbfd7cec5186c6a9e6fa357ab0ef7966d681632ea08a2fd46c03fbd68ec07ab07b07059b6f8cdd18b9548886b8c0fff385a17428a2d970e0af457f982d8bcff8cb65bed5c176453b0411ab984f006af8c25e3410227dbc6587cd265df47e9deb802db2f6b28f46b70772c4c51ab659a73f76b16443e5fb93f7ce277c7244be68c0e3368958e706aa84d7de9a88f2baa6627688e4a86ae926c49a42712103eeae3e2bf09c3937ef3526e4cfac4c33e3a9713a2d9d196878fbcaf6972d02b4471e45d5021cf462c7d7f743b2e353add9c094c5a0ba0b5d0001ba89cdb09dff73543e5b7e9d8206fd598a2f6f9e3a433957f16099c5db0afcbaf9c35e588a486a6552e6a3924d44699fbaada132b14e9dc3295a3e9fde8b4eb5d948b9ab7360565f40500108ae6a9bedc8429f5f7b3629e5f1a08b0b756b7ed91dff5078caae5c92d42b70f79f9b30a8087e55f0059bffd9e725c988d7d3571602050bd844b985dc8475bfe85e1e79abe4557d506d00e8c1130f8a7669ecdaff4c7f252b54ae86095cd86478cefb95edde3971d2f2115d55940eccab6a1a5ef4e631bdee292f54393c7da765e0d0198b3e136c26239fed366575850b77e69105351117fb053c52fe0a399bf06905f6121933794c5abc2780ef9856f2f21dd0227bc8cd5db15437d7c43117897e12e24d6c02f263a7da228782b30becc0fdd4ce1ef0686896a343bdd58619a8b64fb21672b464ff62b073c571c76b90b550f878768a4bba18711ae4e167744b73228ebb5ea2caa27655281f542b641b06c74e05c315aa13c63edca26568a38c899e4eba6e3f815a81a9bb60dc9f619ce377e9a806fc9ea1e2098bcc7a6035c567737da27cee436c2ea1e1176448f6a6139518adc310d4946ddee6172e4753b84d6864b8685a3f1050c3abb9a0b7f3f779d5a9963e05ff9853adccce84a41822f71ac1f169de2f32c2f0c4fc8ae3a0ae6cc7346a0e40e373324e5c4e0288983b1f6590e2873032b0f098d5f4660c21e968f62219365acc3e1b73d43469f60b52f3a4a25503cde4ba776b7ef415582325affa251e130d06430544af84d1676317caa7e42fcc0974b276d9ef88769d5e457cd0e0f532b0261a52521c65752103786b5929a5ac72fe71c28b3e70f900134009c2329a2e299089bc21843a152e3a75af900349063731ca647401b56da2c05986f6080981a782a3ca8b03ac8631e89b464106c3fa86bafb5d0216a8620199f5077708a7e6f809d90aa28291d1018861da901715e7136a667410e9c76946b30f0b09fd0d967a2b999a9ecc4c5d7276c9ea0ffc65d4374cc652b59ef70c9e4460a2964717b8f12dc7e1d9270afda90adff8847c59e781b315c06f491cefa3456c8d99c9ede750de6c94b85c851dedbe09936f8173a378ea87d2c9629629b0739426a851cd7a91fbdb337ac1c4159a23fb6a0f93d16e945481833614fb27778aa665044c58f0c77cb809f35ed906e97287f69780b4e3044ec39110b1004f563c973176707d915337bed98827306038f9d80438327e791beb364c6936b3537eb9affcc9663c7e302bfaa9e99171b565ec3b856728ed85027805373d0d66737148790d64cefa12fa18dea20daf9cec8b4663807e3106133cb7bce16a2b97a15a5dac5b156d52082e75dfceab76b4bbc767453bf3ccfad2cb98e8f6082f1552e3944106185d2fb4043adf9ef1d7355b2b77e619fe5c4d0248ee8364c2d4f04c11559fa86fbb8c86f507d8250b84d90192c3a0e35883a07590c7e4f7692179e2c731101722bec293e3fd489abcde78f6fce033a9c0d51500e1b85635de5820311c749fc9abce84cbd7239320c8064bba27e576aab397c5390e8f92001983c67dc1a4017583ebab856783aba06469affdd9558ca0d290397b66d1a8e9147e6a88fa11a59c6c3836cde10e878d62c945128c44cbb6c4b82066a7fea4d2027957fc38e61bd2b43fa4d5a8559ea8efc100182101df50ad668c9e4efb0f48540517438a87fdc53d9e7e7d8ea25ccb1a701db697fda3673157969a6fe776cedf797ac7b2a4424a9dfa878f149ea49bc870e1cf4b634871c774d49567b8f69b79ad8846a6066a00c1aaf50c7d7c9397dc81133ddf20205269ecf6a0e8d0befa766f8fa9ebcfc52ae1f0181aa8fe668460c9a5342bebd478c58be85c80442e38f62cfe80e5b031d6888b8d9af85ebf74ac36ad8e93305507ad42f6ee77e4fb4e495ab0e6890da365d568338da3b85c7bce8f87545f91a08980709cb165d910cf8a8ccedf293c538e0892127af1ce6f47ad8ef3c98c3635478d4871cfbce2b97c1bbe77206606db3e1cbeac950ff426663b8ae6ceaf9ebb3881cba126cb585d46c4da470569c5d5869a1461e774252679980c715b5f1df70249705343329c9fe1c6320eaa6c487b2dba83389e29cd4555306808c6f571161adf89fd388d367fe98b86c2daec5be6e0ef8c3b5213b085e018d55ab688f7836ccae1458c913916ed1a90cbe2ff93a346dd09bc3c4233447df4974e5953eae5f3a39c5d11c23c0b172b0780f9ac1170db18476c55724225043f63f2942b67078b7f063e10a042d16f5c49e0fb104d55eec99a08fbeba9d1b3c05ce92c6b0224a0ce078ee3411590addae5e810f6cd972ede37cd6cb87f7ac4f516aeeb6a8495c3d2ddeadb06b85611d540d2789a1eb8e399bff9c2dd986746d1f130b2c170e154f7345f8bc5e3ba8cd63f3bcb7b4b79d223132f308c2236c6524fbdc1511c2693d57b2f0ca0bc388a64ccdc33c764c67b9f4b304df0aa94376d20970bf0e541f0995fa7a1557ae3ff64b4b1b82dc9f599e71347795fa7c9dc49457aaee23dd9afcbb4b02411a5020ff85936c037509e1f2cffb18bc9bff5acdc6b5de499215428ad3a48fbd173d29f284bc646a7cc550ed6261df69aa1df92426232fed6ada6b662c5830e506d3a8f72f54bf0777735bd10153354bc8c1fc15355bbf59e7b0e0beb390ac1056b0f1f747db20730a981b4fbdd499bbed5d6ff08444b7283d3cebb138c58d1ced381f16bc46c15b681cac8a01798e0450676b1c2780152cf3c8f866364a75185010ea0eb47ce6d3d1ca504e3bebd51b1ed8b84194df51e729c3c96adfc0c21affa68ced02dc2ea199d32e29a569027b86ab791631eacf89dc3e3231599f8a72d5a6b7c8d0b6ab5b934b957cf74354ea7164e6a6385921d5da6f6ade50b4dcb177869679aecdcb650cabd5b95460e85840861a283c9d18991f32efb9549d5a4a95fbe37ef2dc1507434eac52f1b9361c9e1cf1a79857abaf3283f2eca74f1eb6df820e7e320db333cff4381ea5dce0303931f12b3bdfa4a278055c6e9891f0661ed86c14e983c9ca97418734ca6ad056b7584a11ccbe2865ad7e593eb97ecff5b38282eadbd2a655be3fa7828b99a522cf24e1bfe23405cb4a587f53c507c54c3e46543ba281ba9162d855990bb2755ecfb16b0233b3d5a7462279db596f0dc5b8b0cc41c08f604f3e5d35789a94d953311a9e95bd61f5bf670d4ab128cd8d73ac8f303e28eb7b6fe1029657872f4cd90b0067c0ed9a41f56b701d2bbe8d9a1d8875a30596fbe009c55fceb2f90ad93c5e0a3c07366cac595d45a7a177ef0d902e3abc4d2616900684f02315a3be1a66335f764c2e1a9f11bfa91453d287ae5227792926bf0ac0b34696436b097989c98e2dbfef6d9a2c30ae608c83ccbbe5f1a21166525b97b822d6154adb9f7c1907ee268cbe5c1714f7ad4e3ffdac48c658b1a57d750ef17c55db945c65e29d294eebfeabc7fd6f93249aff085227be62f59d1de141a4424687851fd1ce2ec6c1e035eee26347b509392520a0807dff73a162234b1f1125ce193228e79923742150a7349705f4b069de5b0357dff1c44f8987a7b4f8862c69f1b702100ce4399e4cb5918da1d75b7cdbe11f6c6e96182f8b935c5924e55cf149a765c784be3ad222e1c9b5c2ad63f33c008eeaf348dbc4c86538cc9766ac804e26edfba658b11a400f27079b04ac4b9e278e1a83754024656ef81bdae58afbfd119b0717b36c6658e2f66ca361cd7fbc3c0182510b4ff7a8c1990766ca556b26b25238cf0c4c54074f09c39cfc8f8abce0ec74fbe96405076ee0426eb7e328819e5be84cecc7a1069e34e2037671b9cfe9fb359aefae09bb52d3ca3560fdd6396ae226185b67e953fcd0bc4abe27cf1f6cfca64dbab1d9fcf13e4a6e7adf2c6a4a76f067ae49b1df893b8b68fb17f62c0660891b22c4db015f308e4ea3b99054338df7e40d9fc99f905608939ada82079fbd4e466a94cd46757b0a5330308267d7fdfccc472efb1e2f05be32e4c1860f684e797d2b9fdadbfb376eda50ddd4538a85b8f867d105e44ab26164584e3224bf718c8902ba02ad343f48109acdbabf49425186f5f4ee4910cb4099d2b6076d81288d55218cd0009db2bbd712ff9e60143a662ab119a0a39e40bd28f366dd267a991278fa1060a7517344a819e9cf8547d5a6692c57d5c4c006dae4957bb01edc8ee69d6117b5939eaa8b8e0af4f95df25efb3c98d65b4abb96d7032d4847c41ff63578a5c461d9be424cc35ffb7181ed863de2b754a03b4b6ee0f0afd4a3fe326251105a0e7d48b768478a23d04f8b0ce280dbfaa38ddfe88fc5d56d59462ca389fda2c441e9218312494beeb758cbee68eb5e5f28bbde43fdcaef7bc73ff94cc453651c7dea9d7f763c1758e9b95acbf61db9e45eeb0cb7438401a83e14f5289232d51d360d3f208e500bb913931d14cb2c640351da7323ecc073cf976d12ff163e77c0b25c2b7b9b2c4450d4507bf20c28d5d6245c793b0b89f73bdc9d7a26947024398ee9052a9f34536d42d7d76f403442638bcb3ac8b429bb2eccf15efaf73a49d53aa00251e1dd6704667c1793d532e3a751c877dc8051841358d3b1574e35b8a5786f2e5b6d139f29bbd2b7db99fa6efcd445a6390d3d41ed29bcf14a4b5ff261e1be252092aa2a4cb343474a4120d78e84e909657cf3e26d17f86f10c3f006676035b3b462e742ae327a4595e54e84b468b9e80bf19292d3b337bdac30ba6c37b4cf101d35111483119db64082309528981a375f17ad9315bef225ae3215776bf346c57426171a509c59f30d77e6e13ec41f550099b36523b09a681b0965489402c757e594449cab15be7fa00812c689ab27b7f1aa74f6f8329d0f2f1d27642d1df553f2a3053b362fe4f243df6cf36ea5cb93bf7ea7f712a43619427793425b55465836b9bbc1b9936b397685f1cead1a1ef1bdcf88a95e9814d73345cd87df0da628aa01a2aeab5ec4bc38ed931ae80939abca5987ac1855c82fb05aa3c05d7d6cfff3ebc122eea1493932ea89edd3821c4e7b5d00ac2e5509acf0abe0c6c52fa5960aaaf72b8ee02b4d5ab4233ddc2cdddcff220cf49fc7c7f9f7d32c2f7b85a5a3acb4069b6a942b0a3f6834789bc022e04c6f5a44090d0fcfd2907c629b31f3beca46bed722a92314f4850af7c98bf65550131f72003fb8561c43124596ba7af206de2d6569006416626ff841f0f0e15c0e5e0eab24a7ec90df740e8d27fe1568dabfe907daeedb99fcef6c706be45cb483a5696bd0437851f24c902aa1ab62f2c6705fc0bfbc1486dbb19b2218718c6c15c11b792a47ecc5111a666361c4e869373d3a0bcb25fcd6d4c4b5d74633515f2690e575eb9891ad5bcf4d844122911857b5d71995da7e517a1eb2a272dea54c24739ada8d512bad3a81c549c4f06bad352accf4f001f340ce16a67f91b64db4ffcf6c6dc64289687feb6b62cd2ec772023477ba77b2528719e8adcbbb15d3c68a8c4a85136cea4b2becf0acb53095c0062ea86b7179468a8c3565a156e8d507ad9949ace9862f2f65049613a21c23e54cb852f837d7ffc63b80ef1be333aa7bb2662473847bdd3c2bda3e271d6f1ffe8d33537e76c1e31698b190c21289467a3e68c687aaeaefc698b811dc1579f07b164843ec321f05efb996d59ec79482819398e860c4a57bf3010da80990dc5a49ce615e7a644e6f24b65d4cbf3493a5a0f2f4bd107d32216bbaeace90851178d1762f76abf59f40ffb91ccd286ad74457cefdaf10c54d4f731786d748b1e3fc5d7e22f7c774d694a6db4a5278354572016e382b187764551e21ba77163ff1cf877df4fc0462ab3f2f634361b766d73a2b68ad7b500f1a467b71863acea630f0b3901f77c9fe4c57d7cfc70225371b75650b6bb977ddc4a9eff38a80c44968abd644625dc3bdd98e38047b4bf5c5b2df756602c5c4daef0025928e102dc5b224f7bb40f4bef7e7607bd36674495dd28ffc2107549ed4d816345ffa37ac4d002b2d0380217255fe09d5a07683e277c5afe8c6940d77edf223f87c5e7bbbd2955f1351aed0ad721b53dae1f983504e688d565ec5b6608d64c0b3caecd6c31a89ace7089967a79b2f2c711b244fa008adf8b0903c6f28bc88a67167f98e0f83460bd4ebd34a4c299d166b6090e4c98f19f22f8b9dfd0d876e45cb358090f5900e9b19d73472d1edc05f1270b752616046a90efc132c68845623ffd99e61e00b720718cb580df156632b34527b2f4cae62cb1267c934c8bf3a10811e17a212eadc3e6bbc1c388867474e71b5a0a07d9faf213fed723e6e5942286e46d01b4bf4067999dd24bf866ea0f8df634df4fa610180cb63c2e820ec4da68e985363aaa6818d0ba558f4626d983048d98fc9aa674303bc3ff3e8b95c6f86cf584e087c7f309a49d063938374cb1c8565d7c8b020f29fb16c41b6f90e6df85d791456c59ecaf9b50a33b651d8ca1ed54c77ec5723a000ce9e6e46749b43a2ce871aa4bb535b8a40ab7cd9e40598bd22072859cdce72b4c4103fdaa80a9eb2fabd7b3684f7c343cc3135f17aea3060901686c62d1ca3ad73e8fcd9964963c37ca975aedf3e351e41ca198d2e55fdd7d0ec9277a77fff0f9dadf4c16104268cf78fea0aa3feba488420260d9d765fbb16fe30c3b271694f9c57f71ed653b4649091e0382039acafd03d22e66ea62d90a46fa72ca376559e3078da9ae1b28997478e0134e02c3bd329fd11f6f3e22ec647c7240c13414eacb6f2f71850815a8418fe1cb75007ebede2e1c0e845139f8148a036c7ebd971b46b80aae25ff18d920b3fa27c47d0146b74c03eaca2f0b03598b153990c8ff0db93fbd5e3fe9dbcf3a3572a0f7d1d61ad19b75df5f09f070f496052ecd1c791e09d0c5df7c22f363653cfed29611f5225f16835d4a0703b2e98b0f040ffc42d179e5daa43ef667ea7dc094aa9eaa2bab7984ba2585aea5ab214a74ba7cdbf31babae92ba71899ca86d285430b45b64174801cc1462c4f6393ad1269c720d220886357d0343b3185079779ff7f7db8e29b6d4077db2cfccd4cb047b27924900eb26e8d8ec05209cd238b8d468a91be6ef7e7e4eaa0be9eff57028b72efd441271a75dcdf7bc884f63e55dd08308162087e8b380553eb08d5761fcc596b333926e207273fa2472b059869fdd6ba4643a84b78f4f9d3868b22cea6d3fa8929d8de49996cb035cb23358c3e7d6708d6b698e75abeb7300c2128d0803b4f1a5d77b5dd32fc37cbf65776a9d641156b8571fadac69f76b5666021f7e75c3386768524f5525d5c670c38e9908a1f5d1a82303f97ddec33121923ba4fdedfe7ca9be438818baeae6a111065a93c4d633332c7b1ac7b792c8f740693d3d9be8e0122c2142bbcd23d8ef49ef5a160a66b49a649ea5066e96451d273c093b160b077b7e26dc201471ef0c62858c4803461867c705b35333d23af00a84bb315e2bb5788a30cfcb4e4eb2f5a8d80172b24525bd7bcc6ade47a73945646af311cc77de11fbf50801224409bd5041352701cf1c04955c5267476a4f71e605e85ac14ab32083ba94966ad3f6a1404ed9c5eeb1308db0e41ecc44bc85d4e7d3d06d4405e9f6ac11e53d4270d0cdf729c25229d333a8497fb3fb910386fb41f23284d80919a3210c896183e538351cee380b55eef09c94106c063a30d9c1b6e5d85c3b6a42e7515555cd8c2bdd2000a37dd4b0089534e834a1d8f3da7d008312db99eb6dc051fc786d75eb77e79b1024505df86672d90d2032216a42a3a0d0f460a5e8ce0022bc2b116dfb8cbffb01d6a328bff938819324108c65dfc1adc0252e5ce483e69e3433f4195015b93244039afa2b23b61df616620c55a49af96596c27a81ce495ef1d2f2661bceeb3dea1f949a3e7327fa161abc7b7da7f210024a638549fa74730dc921ab4e2c3ef8d1f259777a66dc672a99aae1d2dd28e8be985f6f3c9bf77ac710d28ec3d20b05698ea03ae458817cb3f956fa11cb91b7698806ee48649c210685a8b766ecd152a93acb88f203fc0c49e4e7554736f185f22846851b5c45e83bbc782530c99e56be0814b4183f57b672c4d31110b733510f173c19e2794a8ce42b56cd50dd484b92cb44257b6300423e46ea27d4a08c86763a095b272833724c21a36b5a2d305e481446788161a31dbb1602b68c4b61e97ce543b6a5b3b88fa8c0019d69a70446f8362e7675002aa27e927b978ecc7e526144d0dc44ecd34c7e903ab5241881228ccf748512bd925a9359a397079cb9b73b93a0588982dbd9740d73bad4d7b74a3321b2cf0c9b63b965be561701a14169491402679fbb3dfca7bc0833d2eaeedb8e29fdd0dea52c3e12109c5059a3b15dc7678b759e59b816ce819a235780cdd492a84b98e788dc59cc9573aee6699e96c456e4e4cb88627f651ce6bd8ba81e9e78f825dc9c1e7fc7588f993d5bfcf278644a4a95b8af7fd750be109bb4c7e7e2c4a82aba1a107e6789669a5826c3f6d88700d5b334bd7715e16e8e72beb7858d376249c115a38606e81f8992e049034dca392425377f258809d8df2182d6921ea803ae10922e7dd80a2499b003e2dba2e7190d8475f78aaf1880d260fdc4e1da7fd4b58d411272506c5d3c7e7adc7f0b69d5848b1907cc7e205ba6c2d3fa7e6b8e7114d62cd2da0904762794d9dcf85748eae5a231e7853a47b79cd2445f93a2189fb8b3030d33daa4296db5964fdf59aa74b30285ac89c5f8d45ea9f434fd7ec93ac44ab4919e2da8a62d2c4c5ccb19a915bccef182a954376aaceabb3b5645ae27abc3b2ca066dcb58e306d54fb517a93006f76b3445a28444a0efcebbc744217f0d0696c2d2b1ea5363e30d70ddc71b6cdbf2bd61e4eeb325c33245bfa8dd2df4c4abbb02c36fa794a8fbbf4ca16fa324bc8649ca4bf05b1287d202d8648ede702fe3a5e2ae53d420c2a532ebceec1bb77be2299252320648ceec798807ac1aa37c1d1405a2de81d94fdc555b3ea3b97429ff834d7daa3da7aac014b87746a29462bdb09126c3f194fa80a3842b0b51c10991938508f8d7577acd786414eab393f28a0a24bc7a0787c8e3e2b3f982b163a46da6e0e18027c1eb3c09ad742178f635ba19b241eabbdae40018c46534abc8cb72e16f1f367389ba2bb3c761d39d9a951db745e89a73f4d3266fb379e507ec74eef24bc51077531191638cfb58b513d846e16e16b51cb14c0f65bb406c38b2069ee9597a872acb55ff898977c55dcfb2a55943713606094867e21a4bf2322bfd9288e90e039c810a8102b0818b96ff8de10430ce873cdb0089c84b38520f541349b99150baa56c09bf7b15e108dccfa0c7a36b42e499d1fa64f90cf93e8a337e785407bab9bb6573a28bb5b8cccb4fb371b7fa5575282eee102cdaca79c12a5262ae67b8f91d6fb07a54ac41db3b3aa0bc2ddf8df1b30fbf8c18141160bab84a64939af37aacae58ba4ece29dd53be93e3030ecc11b5c7bc8a12149f029fc4025f37d19d025abe21edfe7021aca575046168d6375ce7174048c80c43601ec3ac6659f9db882e3d5095865f5cf306aa9d6c1e06480436044beebd7731ff7b3473c1548829d725833f4bb63913a308272372adf97977bc9183bf4785f69b02b2fc41835f61f2a9185a2ae352e2eb6995e65444bcc4e3ac6761a7c4752c1f67a2fef8e99870ecd5ee904a21b290510abd404c9e674592d63b4cca6bd5c365727773dc0adaa2df9529295104364dcabeb6e24d6d8265b8bf67e59d64550be6a96ad880a753790b1b444073516c4df14a27ccf16fd1c488c6f54769f2d44cafa89693edf5ceb7f2c89d9439950b2a67cfd7f705a58b3555dcb09edb95115eb73cfb76a5e96e4f545b4beba16be9ba0630dae03c6e2ef7a72ed455227e8e0855858989258f329a3982a76ff21e370913278741909f3f4805733040c0a7b8a98a535805ec19e20897fad16b87b0e271ed7d7efa840d98ea3623e16a8e63b3a8e5b7cd914dd3f1622828fc7dba07d3869b5b373b271a3aac1ea979d824954d9239ded7fe4b2f6bb19ed8d4841944e20bf80e705b2c598db1de30691bc0abe995c165943ff8d27a39599e26a7ddbf2e152cde6e1e1f2b3d6aefea73f82aa7a6b869d146984973ac60d254f9211c9b8800a6db5f54c7a48f6ffbc1bc6a17fb6874e4090293bd34b00b51b093aea6dc9865be99c63b1a509b9a102689971b281e8e52e02311d09479271d71c6f2dccaa8037ac9f03336fdd402a1f7d00073e4ecd35376221b165129f651513545925ef7f08aa6adeddbc40d3c562a896bc714f3a24c2700d35db39b00784639fb27d3b99bd9e0eb4f899855b57a5a0cc08ad2c75e88451ff988d0431cbcb841703af3866e72f1a772758dfe728614365a44f36896f58567349d3fcf158d4381ca8a45383e485c6ce5dc203272c438bf8001871c6d0e8f2dac994baa657480a1ff19a6a131e2ec893a1cb23f4ca52c3720f6a593fd22e76171f152f67c499ce25ce7ba6395458fe559d6321c647137c915638354a7de512050a6dc830db086648ceb2c89ffac0aad7025b333cae40526959892804c36df4ee114382618f6fe1366e1227f2a4da148fbd819b98530a29e34dd305cb30d299155f8a603f94d3abb0b6a4686383087b28f568ae40e7ec133923a800c2b4dc742e6552e072f500540c2b81d727effbfc00e0722f3f138ece7cd86bfe507270d7e15df1a1863faf18b40702c5f80687baab651aefc1ac3b4b0e230f3ea1a6998d4a9313ef6a38f367a5d0f20e935b76ba6e919cac9a74f09228650875239d051f7c7a79c6f327ff18f12f924d38ac434dc5d46d77c06700ec55f4044d0bb4d496f99d6ec65ab073453d2481932db3b387dd192530cd9fcefef5af0c63ce70f8dc3b5843a6ba36c34d447ff9f13b02b1211aa6c6537ec32e7abce71186a8a48f202f5e53ee93db69c252b4e5242feff57d93cc98ef3607548b309227f818a1f28eb51963454a03fca1c9f6b3e35a9057df9170ec767cbd6f572ed3d7e2627c619721d45df9a66e4d9a9fa8fe5412c9c3d8145883377877618765d254040c668647bdb0be6055e332c1de18640c2f6644d54e4e7e547ab51ae0d9e17dd8610b3ee145772e516564a087249227cb8f4a992d2516fd82732798d462f4f225f10b58a6692e202fcbfa258021b975f592ab3ba1b52cda3e7b7d92f82a64b0e40f7e41fb4e867609df0d0df01b3b664f9e5ddc30cc5b2cd149c8483d3309ede85283cb6d0e137ccbde4b98086ccc141e9c30af486d1c784dbe6906eccf9f349a14ed7fe13357b8ce6722281403776b3a795c15e14ec9ba9d5a954664267ff843f6f0351f409e6bfdffc645d9df3878fca6fd78bc59a1b9d0c56097bdb39f103a5aedd84928a7bb458dcfd6f398f2672799a16b312e9a3e2148649e8fc7f1e620e73d9346d51edb54de5afbead6a580274ae35900a0022d9851ebe04c050447260920cffaa2eab57022c95858d703b504b717668c34f597bef3b431cfe4f90bdd6fa7bf5ee142eccd6d04d38bed4bab65600a3c6fa59a44906344e6ee31d226bb8bc263c7579d26ef3759f6b4fe7951e0cbc9efc7623c42c27cc135408afdb6ee154f3577bb670c72ddde93c103c5589e018439d50e27827c3c69635ce3442f5c893ef6783a92672d1d7052cf896d320d0f73a063005d99d8458e966e0500c11ca4ca4d04f6e93eab9e33364433dc67ea87d96658c11816d35d2982160a9c87c1ebb927308243f1d866b460603510687efc0e492a901f13e0eef93d15e3712ef524b4078368759b3e628a8b61db5d2441899c6169e1e3f2fe8736f3a2d2ec0ad3daa6c205a322532ee192ff1e007d16754b69c48fd9776cfc59cd3ebef000e56fdd3950d92555002319b90a5b97e7897ee2f6a234d44f548dba346b40a8f1e79dc053a6f452e8dff5a14e36e5268842def4ad0b64e0d4ca0fa5cbe3033a6875ea5aaed09b83c3f8a8f5f3bf0e46b8dabfaa3a964d3fc7ba0b39ca83f439dad431457bb65585e40d44f61017e1248f72fd32f98eb4e970d1fe36c2a2730d40f9e9621840a2173ad7a867dd60fc03808a533b72738c07a85a9b83af0014721bd77253d4ce76704e8b5271f94402b84823417ce7d1f479a1aa64aa98f353f8cd045000c33893b6c103ac209684f72d307db92df0dd575293ff7e5abf78a6813f9f2c13a2ba1587940607e32d1e15de94105e8b254cc75627059ce5600bcec5d4acef7ccd915074427e4610cdff175fcb997059df46d383bd6328bf066346d1b578f4ed4330c881acaafc5dea893cd44c520e5a008eff857e054205677b3c8364a0af5ebb3c6da7d3941568cf64b97735b18ed8d213ab403efb89f3d4875e10a3cda68ac5d09953634f2531916abb15134d1120f5a8b64a2e2b986d41b49f7faa56a67104a715e40bce189b98a79a9103b95f045689776d6033b277cbd5e52cb13e8dd46e2b6930ad5d57eebab33e602377495741dc8a2a192a6abde06c7946c150ddbca49f13ff50075a58e2e56e0c4c5a89747c79ef31f225f50cee9afa50df4e7af453c5cc8ff5675d67462419b222f114b8728563ebccb75cd79fed8fa4806fa88aacc0d60f28c719903453708376d46f0472b663f094c029b3b221feeb51a36752e52489246f765cac68a42146eff23d3cf7545291d24ccadb533f5aa64d5dbe63d05caa6685c3f476f548c6d40b34d9ca0a493c4f0d60bfac11b211a922d763987fe1e0e46307a60ebd47259b700c201badc66a61fed9922a5c3e169aea0b7f10f9f0819c1c9cb778797acf1c86dd0b21536b703393dfb07a95f6157630e3dcaefbb6470485c34a1e55f31d6e673adfcf72dea8e1bf718366b291c90d47461599d3190584b0c8d54a134da1b8206ce5a01f4732c0211c9adc6ac58d81ef1994bd3e9d41f93ae602adc8a79eba3dcfcd11b72840d671e53a6ffa85aecb4f566049610dc43463bbb8db23544d45a8e4a6239d78475dc7eb74d5704d053639b7c82fcae37679f55941cc456f26bed62f5eda08ffeb44aa56b06792cccde2bebed2a88798bd0106375c5d2af1bda04a3c73c0e054c7aef588c2a448a7de421c0466ad4b5146787b8886cda0ef4af75e643d62a7101a708abcc0aea21ec69eeb08b37fa0a09f7f69d9ec41d4173be56633bdd277f43797d17126cb65caa492ac0e421f2d475e2b3bdf474064a0eb201c7d7323122f08e00e5d68e52dc4028d9aa66bd609296b84add95d370d36e8725d8421f1f701433f83bbb70b1ee64553d3f5b9af24e925079a0701f6e0a4de383dcba6d6985e2e595f3a8dee20ffe17ccde7d6f8b5dc642591fa2a300f40cce45f666af68e4c7b0986d98d64b91ed6f31ec938c5c448ffc244d343ff3d4ac87baaedde74eb2a8edf1e747fe9625a8c779304b46dbb1b7bb6c2b0bb5f72e034184164b9fa921eec9cf8d84d1982aebb1d93fc750b0c95ab4f7fdcdbaf88290e67d5b16436aa3fc0b7bb9c9437e5dc7dccd83ab2fee48c8ace2f7d1c333dcc852b4587145712586bdbec0fbdaad46a65bf78707869f54d5ae574da5a94c4ed16b888c89b94f544d966bf02837ab32002073700bfb441332a3f557b035ef43ac579f1d5d3a5634de7ecb7409ed72fadec072e0dab09087c2cf887a9a280fbbd476bb84ef348feff7eb31eee6193034e24f6c44784d8b407e8218f2355d0aa8276a0dc26acbdb569293442315ea344a04360f6f28f53e7eb343ea20742854d4b70be512a4a4b95b7c6a089d173a145fad3a6e6db43f285161fc768419ebb11d8937d7e4754b99f95c65957b6544d06f1d079ca3ddff1e26d3eaa8404b9f20083962d0b3b64d5bbdcb574bb6f1f0834eb3f631dcc7ccdf020d0c7ec1d388f8832b82d007701f1b061363ef6329f57bae3993e285d1ecb8619e1731726fa5a92e45275345f4d6133f77db4caf4bc66e3bda7bad7ee0771b5c225f6f4dd0bff2c54ca0d0c3538fe00f54909a18bd98208cd5bdce2fffc0b2b95af0dba40bd8dc47b2e94864cc7a60dd6cc2479031c9ed271257941779827a81b8d687a142afaeaf5b9ba9d64aeb9bfbf7b1fad8d3acf0aef35bff29304198461852d9303799cb07eb3c6f33c1f9e3c04cac983b6e7d0fad72fad139fcd7841fd8b73e588abb18c172010d2c23b3cc5f1d02593cad87f5dbac496455a679f32293fc8e03818d8d58f2188776f088122819ae9f2954d5edfe5d6a36464422d2e9cbdac5d319096ca73d32eb7b115df21b545003fe71c132f73cf4d8e0efc855314661448babfd329a4f697e67c58ca21bd83096a808ce89decfae6775b484fdfc59ee81961915a5b18c26f1c57d33bae2cfdd55f5fa64b503ae9111523b3f50f20978425193a5c288dbdf1be80c2302dda06ec7788504ffeb3ff468e943a271a9a123bb02a1ced0322a171620ff7299b36ae09b8bc272a447aa650879012582d7aafcfdcfadd86e326d3d3f715eead57308d9ae6c500b58279bcceb595953e88c8c8fb65f6e882a79c43104b34fac301f305416d42ffef4fb847b5c73985569de006e9282904a1132a13b8d127877964167f550b1b647a77d3a9cc9968415d4752eebc7f4ce5875787a96bc9371861730ef962580c911d8bc9fa2ebee38ad80d0541086c56623e27a29d5fa696230f57eedda416ee414003788ecc52bcba8d79cfd15591d364b063fc17ddd112569c89d03c9055a2a773ef6b13e927c1150879f47e9fff95df2e530726c4b8b01b260376ba4c64d6e3e736e82b9c361b0817d53864d9cd82ceec697dcb052a08834e76ee603294ff5ff36843dc516792a24eb582f9658488b782a2fc7c25057fb2b89c5b2051cb3d9d901dffab48a834a8843435bf9d57083b6c666315be38bb2f8e932143ece60d66dee53ae1155459d85405ba4d4e323c018b06b245fe10e62afe471650f9edf5bd9dcc64d01ee83ae69d26eb19389063b9a3c372f526d69ad8b7f381d5a2139586b56649d4200ba1bc03a84e048f28c1eedb66ea070cbb9aa670a90260c889c194ae73e524abe354416c7e56d57d68b32e406a9380991ba0c062f1a4707b239edb380e9b6da1be59c98368161d9dbd715a41b1a50f4c0bebebc875c39d83c7d166a56cacb5bb0524d438e3218982b0380634d1aca5b633613966bf7f2adab24a186a311ee8048648713d2e84a72ecfee76d0e96ecbfc025b6fff01e648308b3781a24b630a5c065ee98b60043a9b678c26b10da621582a7855def80deb664120b98b6774fbf62d0be0db8c27b13612d0b6d83a4e9a986c153e4ed3ca7f13c448c906ef3467daba7a2a2ef6a2225e0c0ae128e389b39ebc3d422231bc370282c71d1b9a47746408b00246543013ea620841ea045f3adeab30a62e2fd277b2bcf970738fb494c3e575152a28f6b7a0ec6dd04ad3cee1e328d8c5cb8396eed5aa3fd1dc1403cc7bbce125a620f6e7bf14fe86d7ee0949ca8dc7b957abcc59d16a2ab4c9cfa8afe306a5a6c88e33d27675a7db072ec3e1c5fe9d9eb3243b6a42c58585cf95f060a816a7b665ea83b16a4257d1b1f5e2859918e609c3bdaf5b76bfe7c32acdbac1482ba16392663b233483dfd191211d7220efccc0f2ef90c7effdaf87365db92f98d8b6f22b96277ae11d7ad8c77c2bc9c85b4a36ab4c8ef0e5f6a044f52e09243fbd44344f208a6370b1b25458caaeb9139c94afe1f94146c2f47cb1903d4b2f38895f95e18405785740c1bdac5df8de1540f92e883ed527a4e85004ce369fec5454bdb609f1addeffaa9f050e433e7bf968756e191ffafcde0c571d9eab21b0b64403ceb123b0fc43fa63fa2ff8fbb77c57a744120acc9477579bcd93d0cfe75585b1fb09624048f579a92ba4b4812f704af3c77494695aa9bccb2163cef25f7d8c270d047cc3b95aa312196342f4a03badf564434659576341de7c68a274de4eb27ad7d9e06302a9d72d464a663fd655969ce60a770b2cc8dd76591f8fc0d23c17197582c384a38fea464f98d8bc71ce95821f543a0b1fae2f37bcab1c112a8dda7235404fc53ead7cef4172cd918fc5d3647d345cb02320fd61bc52a94db2dea023fb15ec85fa1926484b5f0d05e5f27ece50be6d6441dd867c0bff89d9d79f6a561a489321a3d9705445cd9d4f4e1d8b53fc8be1cc14d6aad70fbfbaf6f492ba5d86e5334d456ba3e3cb8af9a989a4bff48f39386c3cb3d62af9441f9edb500cba423a274f5a405bd8484bd99734f915878ee93c8c624fcaaa316553efbcc49a08995cb500433cf7d8d6288cb4fe226838bcc051833e382a46b19c0b9a13ad76948aa0a9cbba38d2b2f01ee0816b386f8bde66cca65730e2f1038605e3c020ed835122f71520804dfaa28c9afb6ae81165478a627c8cae572f476788261e053edc8a416dcdeb56abb15cb680f186f50205de5ba6fc605e6c36fea375fa5e95a2d5cf217c05766db9008b46f06961b4af031a1093f8de9d506d5f46e95142e2a3391a2709d9316e4b47e3c6078fc68e7eaf0d6229f463fe2518a97d6a44bb4fc1c54c815302df7685149e265fe8a2815d632e0d1c0810c7716a1e1bac5aec1467cc9d9ce8dacb96f6ccec3c50e3c4a0a0b002538c9ca9745f648915dd828abb348e6faca8b526528309a33fcfeb6e8e30763f78d60eb233d3258106890e7fa693055727dbc4892320f9634cd3976507093f26476e9417674ca13fac085c6a879d1eaf4a53fe60f55b4fa3e24ea753580782288bcbec682698d88469820d7be552951b93a4af85a9ba897065b8da13e2089dec9766b4afbb530de1c37aefe79e21f4cb4567b46f94df95529e22e2ae9b59a5d2bfc46a1e243f8fc2e4f4f03c5fbb6c24e78c80a8ff87227139e5e6a18c726700dd947d8f945f12cf1a23cf952e3c85afc5c470c0a55525e845d57150540830cdcddbea6af3f1b66358a756d3e1a0d3e06df012e338695f69" ] } } \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockContentsEIP7594.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockContentsEIP7594.json deleted file mode 100644 index 37ea0fbd18c..00000000000 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockContentsEIP7594.json +++ /dev/null @@ -1 +0,0 @@ -{"version":"eip7594","execution_payload_blinded":false,"execution_payload_value":"11103013652248291612222159278156471032005615587981889885338966324871092985294","consensus_block_value":"19755222334871137581966673778023884694586692954373005173000436914838007452761","data":{"block":{"slot":"1","proposer_index":"4666673844721362956","parent_root":"0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef","state_root":"0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e","body":{"randao_reveal":"0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71","eth1_data":{"deposit_root":"0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f","deposit_count":"4658411424342975020","block_hash":"0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379"},"graffiti":"0x0000000000000000000000000000000000000000000000000000000000000000","proposer_slashings":[{"signed_header_1":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b","state_root":"0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb","body_root":"0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486"},"signature":"0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483"},"signed_header_2":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6","state_root":"0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26","body_root":"0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1"},"signature":"0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1"}}],"attester_slashings":[{"attestation_1":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4580744678799082634","index":"4579092195582398506","beacon_block_root":"0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c","source":{"epoch":"533461240","root":"0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565"},"target":{"epoch":"538462976","root":"0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650"}},"signature":"0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc"},"attestation_2":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4620404293179370891","index":"4618751809962686763","beacon_block_root":"0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b","source":{"epoch":"538078227","root":"0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb"},"target":{"epoch":"536923980","root":"0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5"}},"signature":"0xa32991816eb9f297553b4732309a4cdba7b33287264611715b0ab3319bca19e581da6e2659912a4e0e94aafc01c488e30ffc96ed14e2a726b9d3c618405ee0bf54bf6ae7f2097465cb27ab8132ec24eb93d3c9159475304082f7f0e452b93b65"}}],"attestations":[{"aggregation_bits":"0xfa79cdb89d0d51c5cdd001b7425c6d726750a9d5f89ade6ed9890ce3a706140c399a5e10c90a819094b65322dac7501f7c75471e69d4567358d8ca75f7c1b3133ebecf006b369a1f36efc5f2b706d5922ff98c58a1825a53a864376658f816600cf021cea843d4396502bb9c74d1510afe26036f89f783b4f5c7bacb6649c46f217a6af835f312d6fa253d2bbc83c07993f4f10de2ed2d952689379dbe4f794c1a1055a6b364d68e038deec9667f576b3b9eca5fcadd6298f181e1edb876efc3d0975ae14ae9a0ad2f1836d4c3f1080a96d8ab7c43b34bb2eda895ff66be698b363cfa4be33da3ec94a1a7a90672fd12c4a59916bb937e78476e4f08e4f4031001","data":{"slot":"4605531939934246443","index":"4610489389584298827","beacon_block_root":"0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b","source":{"epoch":"529421377","root":"0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2"},"target":{"epoch":"529806126","root":"0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd"}},"signature":"0x8f8d16b39e14569aab1b712e5c19ed51afe3600a6b017e8ab432f43a02ee720a733c33ef087d2f3653a9701e8d8a836301655b9195c0373b775c88ba1368e5d55354a70a3096bd26dee29dddbe7a4820e2b1653e84122beacbc01af7d93e6bdc"},{"aggregation_bits":"0x4ac567b296efbf7cf3209e87096a7a1a50fd523400113f917f6584a5a306f06b2d8da9ae858d47ff2594010089838efe41f19a78d9aae27c2ffde26f278b8681db9d091eb72e7cab3e449dfccd46a270693e1f88f197324e57bfd45573315cf9fb60d770937b32f7c0c6ce1581ec51e6b60f71acfde304dc917f2e0aa7872038b7d9140d15f7927c23a0490a74c2b0aca2773fed9217067e4444f9ca93874e4ff8407111c3efdb138b97c6d4957b6a70ec1debb283e3d0eb1cfef068adcffbf057d20fdc339eae03f0fa2613abdde8158a7fc40c3cfd1117eb6f8c4ae21d6b2ab4b57ae9a8653a34451aee6418c0c3609dc937293f5f5b346a7ab1a0d144185101","data":{"slot":"4544390030852162633","index":"4542737547635478505","beacon_block_root":"0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd","source":{"epoch":"527690007","root":"0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8"},"target":{"epoch":"528074756","root":"0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8"}},"signature":"0x90309dd491ae6ed51917dc305a3d4ae68d0a0d4792c7eb59c193bd03605bd94e61cab37502de0ad3e6162bc02427bba80a798b3670d5de82a854094016cc298b265371345c0e3ac49fd44bbb9ba0d4fcea0c1a80cecb60e93921d907e8c48120"},{"aggregation_bits":"0xe8c9759f0840f980ae956b15fc383d992e7d4420d12ba5bf32f669f446ac6fa388e20e5ce96e9266dd98840179d2cde3cabd9a8bafab5dec9c2e89f7f78c989e690548603984803b80c82d7b76443194576a1ce49da5cfe56f56e83b745fb01b5f18ccc86d88f5a22d927e64ff0b8e880893abcddec45b268531c4a0697537dae643a24b1a36432f37d42962553bd39af71f37e0429b81470c11316aa39db074aa3f1df4124e7cb203debed60b885ffb9b27e46a1434e81bbd56566632d0729c0822ac415cbb67f25973667d88e58df9c2f058a0ae7f118c98cc448453b6fbe590363bd17ed62c2f808df61f2a9e593235eeb56db74b9dd15980189a5271468301","data":{"slot":"4529517677607038185","index":"4574134745932346122","beacon_block_root":"0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947","source":{"epoch":"532884117","root":"0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31"},"target":{"epoch":"531729870","root":"0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672"}},"signature":"0x8c40f51a99fce6ebb9a4db5e80d715fff319e7ae523e46afb5d03c000d427e23c7a39e77e2af53851706283c8ca91d680997cb459386fbdff52c4d0ecf498e173717a838a792b210bdffaf476538628584a133899bf30dd5ce7056463b8cd683"}],"deposits":[{"proof":["0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c"],"data":{"pubkey":"0xb1f8f6e731dbf6b4e3265fb857c7190adbfc7e6cc95ce2e8bda72be8b6ea3459f862310a2484c3b0ee33b30920f18c1d","withdrawal_credentials":"0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c","amount":"32000000000","signature":"0xb594382214f5bdd375de66c45e1c61a526c7b73fb166c72433bbd9c2a7ad6881244e61cc6427e0206a50b762a129d8830e8708c55761d61ce9e3b19c1bee13bc55daa13bdb07118efdbf57a588b8a64e6392d14f935e53b68933e3355b35acdb"}}],"voluntary_exits":[{"message":{"epoch":"4562567354825622634","validator_index":"4564219838042306762"},"signature":"0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e"}],"sync_aggregate":{"sync_committee_bits":"0x01000000","sync_committee_signature":"0x919ee45cc18456f6e85da6bc21c2e40f44f9a887932c73ea9ad354f88e56d4ec0a8c396ed143082c8e31d697b877a2a215d2966d91c7beb156bf7ab5777e210012f70dcd5f7657808a82cba51e194be994f917150ebdb9e5c57476f1edb47206"},"execution_payload":{"parent_hash":"0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be","fee_recipient":"0xf8eb5a3ea82ccf3c1be1ac153e3f77f273a07343","state_root":"0xbf886c3ec849316e3b187793c3a4398b6097768d06bd968a54e8d2652d2a75a9","receipts_root":"0xd2a9663e689510b3305bdebe972d4e58669a751fbc85bf448269162e078b2c34","logs_bloom":"0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9f770a36a743c8a3abab61dc439ddc0604dd5015b1ed3835787d9565dee0f3e64b25de4c097defe3001f483a4b6feac22b992cada114bfc709d483b4d94f07bb0a1c4fb9e93ca3c31f4b9683753ba33ffd971777e301367f1edfe6809da491535c711a7877b4c97fd1a756136c412b4f3c4471ba439607333623558a63030f2cb6bc2ba885822672de14ea697d44fbcde134b6909208466be0b4c981658ba30f999c991aca746c3331766af1ee10cbe69624066708ae086999a0a3853eb777b3f9f0455cfd98a98c7719710515b97c596d2b662d353a90206e470c523d4374853","prev_randao":"0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874","block_number":"4491510546443434056","gas_limit":"4489858063226749928","gas_used":"4481595642848361992","timestamp":"4479943159631677864","extra_data":"0x58913d3ec8a62b95e52fb1ee60ebddf392af6e1db902dd5bc3f1eea7003130ff","base_fee_per_gas":"48712354854557871613352262057776104244427151172201944877932608112921551169417","block_hash":"0xcb571a3e876c6732a4c11cf3562059c2b8c16889ffb6d1b8d5f883591e767c3f","transactions":["0xb736203ee72088","0xc7dab83ea972da","0xa198c43e69db1b","0x135fa13e28a157","0xed1cad3ee80999","0x60e3893ea8cfd4","0x39a1953e683816","0xac67723e28fe51"],"withdrawals":[{"index":"4864971916622804241","validator_index":"2164897","address":"0x09988f43d11dcf2aa7811c9997eb4119e8f153ce","amount":"4866624404134455665"}],"blob_gas_used":"4858361979461100433","excess_blob_gas":"4856709496244416305"},"bls_to_execution_changes":[{"message":{"validator_index":"625901","from_bls_pubkey":"0x8b772ee4cbcc67f534f33102671346cc3d0ddecc1a81f0350f68dd3210681c9e4bf907b49211cbd390bfadc7f285214a","to_execution_address":"0xb5c15a4371c6a89646dcbd1f07bbfa4e210d4bf0"},"signature":"0x85cc5356a9646f0ffd512b7d2e7d3242c81303a415e61b490d28635896aef1f2db03ae8a1439908d03cc131515ef83f003dd7b36ce480c43f4495ffd339b2b9d1e5461309a02ce193202f27d216a4f0e13f7b47295f3e1a44c8f0e8ae8e1e5a8"},{"message":{"validator_index":"241152","from_bls_pubkey":"0x8183f3f5071394e20f83599fe297dfda37f77a040362da8f8fe926a451eb9cfd917e953c51b81619f8e4925fa6177b49","to_execution_address":"0x10eadb43b24678ab331bde64d7f836af97ca6064"},"signature":"0xa19b99131e621d31846245039e99d6540418acc08844a3996544cca2d9965f8a24cc49cf695bd78959a784e1b5646b480b88aec749a62ea934ed3001af50bb8babfb15bb9df1f3d57abd738f65de02b77398c82302f500218675cd96ee3b2357"},{"message":{"validator_index":"1473390","from_bls_pubkey":"0xa83cbdf40e5c4bdb4e9802d94d765c70150d9926521b0ec4d273e788b83a9f304694e75d2e381ce631b24121ffecc9d4","to_execution_address":"0x372cd043f2dd36351da1acbb7f0a6049a4d05e88"},"signature":"0x998cb975f863e95fd53ee74c5beb85c19b8b3858773432a371e6a3f229f67b653165adf3bbaa6015dec12a1d13cc9d5c080915c55c921fb056fd32e9da643d96dcbe83ccd456b3072dce2610d7b96e69488468c83d26b7251a466571a5424351"},{"message":{"validator_index":"1088641","from_bls_pubkey":"0xa7f8aff7b912b6363efb810f2b661643624ab914b034e78d72397ef84fa04862dee94c9b2f46b872fe852f197f558fce","to_execution_address":"0xf676954331d2efe5b23eb56dc3622d4ce2ee543c"},"signature":"0x94773ae9e3d605ba2612dbea934955e7af438154f7572136c97bc3f858144ab833aa7bf6caee2a2c4ad066d36b1d0c3501359ff577de486f81a5210258cf63ff45bb0cf91526eca949dfee984c6757a957f9c7ddfb8b599d3cfbec0b778e9396"},{"message":{"validator_index":"2008914","from_bls_pubkey":"0xa6c59055cc0bed5baf1a815f59d9d1cbd7aba1a4fb8d83de7310ad85640524318110a6a16f5bc141a81c34e103d9b7be","to_execution_address":"0x7fdbcd4270dd970b44236c31de8ee788b75533a0"},"signature":"0xa28a524424e49283f416545acfa1dc063866bfe9892c60370705cd8133fa949d724421b1ffff5a757d573391ab2cd9fb043022aa8354e4e93c91d126cb40f9ca7f7be8e8293be5a97b0eeb79df9c051f90e4d97c9157efd9b64125cddfc257f3"},{"message":{"validator_index":"1624165","from_bls_pubkey":"0x83190d18858cb148b28aa89911959562dca6653f220f8b4878a5d580958dbb3ca184d97880f7c2bf0fa970cd41b70dce","to_execution_address":"0x3e269342afd150bcd8c074e323e7b48bf5732954"},"signature":"0xb469d5c6626f1c42e7e914ecaf79388360d2ad196f2edc1f7b6088422b4f32f43f36b12898bcccc46c5ed15285ff0cd503f0ba5f6def9b4c1e523e941f1de95263bcdb014637c359464eb2cb974e06faa164827b21ee15dd68b2375b7e76a700"},{"message":{"validator_index":"2700421","from_bls_pubkey":"0xb7ff61729743df75a8b0b7e5b95617b9aa407e2e6a30cd8101c6a4c851b2cc366cb80e68a19a23e19625a596fdd1ec61","to_execution_address":"0x64688742ef680f46c246433acaf8dd25027a2778"},"signature":"0xb29e4c2b22ba8da0947be521fd1710125a95d9465632c3d2b5cffafe6e7070f4a6bd71385760b2b1670add9981225a18060be73e5f486535919fd3577b7ed850b3108dfa0fcc9215cd9d526295616e09619e07977ac7208edc5a2af93835a18a"},{"message":{"validator_index":"2471654","from_bls_pubkey":"0xab0a4039f2f00ce09018af228a696b7b87c7bfc111e7782bf7a3ffb423c681c04fe335152668abc7d20b6e9a9bc4933d","to_execution_address":"0xc090084330e9de5aaf85637f9a361a8678373dec"},"signature":"0x90f650befec00b055e261a38b4ea0bc65a0d71fd735b46f8387f565fb0d31494f90645c40dc07b0f3ee26d7807b82bd914d4d7c81b3ffeaf9a32730ab7cba7265dd09a0e0f94ccdf2ff3bc53d49fe99a488cf7238200ae12e6c59960e71d5877"},{"message":{"validator_index":"547910","from_bls_pubkey":"0x83e4d3825bf069cd0b19ca5072eda2f7d141de02c9e65f9c0733c18252c1552cda074eb613e1f435a880262de2a4672f","to_execution_address":"0xe6d2fc4270809de49a0b32d641484320853d3b10"},"signature":"0xb9b292bb598db604142750cb641cc511a9081656efb8271132d7e0de30554dfed4b16e418100d9085951c1502d6ab657179da8804cb08f1c69b1210ce94bdf6a0b66976233a34a0acfb4b947cdc192cdbb8576a3453e50143e7afecc8cbd264e"},{"message":{"validator_index":"163161","from_bls_pubkey":"0x86c03ea323e3551ef39c8c4e5355c4d3a2cceea3c8acb3d947b39e245d2ffcab53b4479c670d8b268828fd4fee89eae7","to_execution_address":"0x08400642aee83f31d60723f5fabaa1c58bbc1104"},"signature":"0xb58eaaba3ba51d7098d65fbec3829ace78576a2276fd9c97c293aabdb634a2c50f52611f48088da5d4a5b5fa2c5f4c0513d8dd91c8534b50a7b8ae0072583612610ada0c81a261641c66ac542428cedf20f1b954ad03505fc058b40ce0bf4182"},{"message":{"validator_index":"1083434","from_bls_pubkey":"0xb54bda7a570f90c2d38e836a3a256a6a2230a6384a29af7dacac3eff1a981d3f50918e2b546b3d78e72a545870b5ec9e","to_execution_address":"0x2f82fa41ee7ffebac08df14ba1ccca5f98c20f28"},"signature":"0xb851b39a32955a7f05acd7707c6859df4ee2b1472996d6a805a61e14415db550a92a7eaaff14a67e858a9d3633306efb12a62ed84f76387a84deefe726afcf2fb744f616f67d144411689343e6e0dea7a88b57449b2cdecb43cf0b5a80887550"},{"message":{"validator_index":"698685","from_bls_pubkey":"0xaa3588a5cb0b5d8eadd316046b661044c97559a4350464e338456c5b728880b4750b94af5fcaf478e3bbc86ac3e12d0b","to_execution_address":"0xeeccbf412e74b76b542bfafde5249862d6e005dc"},"signature":"0xb99cdab802f2f2683fabc52c8ea095386730c43694a9a5f7a42033e6dea53f4896092b207f56b1402c5c69937a3e2fb41958e001895bb43c2ee1e360da601e1ac56ffa8bd5371b1dcfe85518f297f94c02cd4981a5961201d2c2fb4d2a15c888"},{"message":{"validator_index":"1930923","from_bls_pubkey":"0xa55017fe14158ad9caf1d11f971b71b1941799466d063c6c77d7e41e20d5b74fd7fbf969243f3f507f8c04a5f76c3722","to_execution_address":"0xb1ec6f426f978c599752e0e7181c305a1b8623c0"},"signature":"0x917311e1a5f7a689ceee1af61f06519a3e4c6d68a4af6f4d24da0f57a2246c963c964d0e576607222856258c0e34b0b1014b68dfe481454ceaf521bc6f87c15e6a21f6db1c303b2042d5857ad4506f00dcfdfc5e65bbaf1b4ee9fe7ddf7b738e"},{"message":{"validator_index":"1546174","from_bls_pubkey":"0xaa865744dac51436c21adc2a1373eb6b8d407fda20bc67492d80a43812dd2aedee636192b1fa742570ffc2833ec58b29","to_execution_address":"0x70373542af8b450a2cf0e8995d74fd5c59a41974"},"signature":"0xb875609f4aa01bb03c08b4f13459fa7696b969fc5e8440c89f690478820b8b5b4ad75e7fbf03c4b0e919cdc80b07857604bd81f75128f2bbc61861d0b5a7744e21eb4ad008f05b46be2c2780900a7913abc2cd3591390f29e05e2d5b2dba570b"},{"message":{"validator_index":"2622430","from_bls_pubkey":"0x99c16f59ffb2e2138feb9b6f1804752cdbfe3796e20c52a3ae489f8348df4c1a9614cb6ce6860bed51544aaa1d22cc80","to_execution_address":"0x96792942ef2204941676b7f0048626f766aa1798"},"signature":"0xb9196e6383fe7a9eac1809c48fe10e45ddf57d6ee7946c22d48873b45064a39e66f861d7b36d82699f4b1858c3ef093f13fd758af1ff4deb2b7e1ffc7a7179306726cc556abddafee546ed2a6d7c4b17a1498494d994ff4188a2edf3c261a683"},{"message":{"validator_index":"2081698","from_bls_pubkey":"0x9786334738ef86988505249871273257e40b3e3c47995e751a40a52bc46f915fbaab7e2b1802ca3dcbf2db0567e8c9ae","to_execution_address":"0xb8e632412d8ba6e05272a80fbcf8849c6c29ee8b"},"signature":"0xafeb0dbcb7463673415ae2897857e5b13c4299ee60273bbc406c38f4e805cf7bc147ad40d7873740f3d261bd592574e618efe8f93cf439d13db8b86ff91918c57578b1080c6e51cf121d816eb3e5a2003ad57799d24f1ddbe495724d9e5a292d"}],"blob_kzg_commitments":["0xf14921410d6e44af323bde913793c2037f32eb41f938cabb3c5db5168485eeb88923ac822543db013af49d53be186cc8","0x046b1b41adb923f4277e45bd0b1cd7d08535ead3b001f37569def8de5fe6a543214372e11fa4bbef810ce1ff85e0cfae"]}},"kzg_proofs":["0x3ece09418d9cc1c206477b3f86b61438983ee789d35b6da4f361c337ee08cce3e8a1c4fd0fc75cb95755aa04da37fb61","0x51ef03412de8a007fc89e26a593f29059e41e61b8924965e21e30600c869836e7fc18a5c09283da79e6dedb0a2ff5e48"],"blobs":["0xcb072d41cdd6852547b50f3b90819969722ced1d8ca77847e05a2e86cfc37fa35ae41fc530811a26acc317fb2f89a4fbd13c6876261f3f7aedf916080789e969b18e152f3c9ce7511d6aed2a6c3c7eefc18473742e0343b6ea6965c1e9f240fa5aa4a90a7fd4ce8c81abd7536ffecf3f4d3c78c58d9599280f217e798a2aeda204de9a8cdfbc36868414133bd5f24401e6c476bfc18f14769977e3dab02cce1200d03dcd13c5d92a14b067862f180e96e1f1146e5c017af54a64e68c550cd8d8c43a57e925800dfce50bd9ec8132dfb2f4e0fc1a847e698ce74802072805e4616cebbff8f63a3c45ee4ca2f6c485ae7dbd620e95729e48b9b9ce35e20b5ea1b7342c7494bae28ac5ea53f0c36460c10d3bf324a8f3c9d0850dd3eae4961bd0f6ffc4f077783be568d8f10b0ec275cf3b534274edea591837b4633f4693822f4ed38bffa38b66ea187c2ce69ab30847004c4cbd5acc05319183cbc1ad806aca5a5b85554b23b97383db9238a7ffe5fb945302debc22a2b56dd4aef14410608be16495a4bbc5e2aff1c3a1ab5fe32ecb2ef8827d980b2fe135043818c8aa97423960bf0268c7630cf04138b55d8ff3fd6aafe2d6c1b736098af35349e4e8af8733e6f6c833d5536794281c2141a99d747b5184e45aed7b950187fe9f581a4421f62f804b1f6f7843a5918e75ebc92ae5b398016ecd86f8ce77299f0741c14edc019be00d8268abf8c155f0a596fb36b659a6a3bac4ef2b20cb467524a9145cfd962a5f541069911af19576c5fc40d7407f7f6bea20abb9a04dcf142d067e8cb5c2041535046ca08fa733efab0a0d4483428aaa375ccf570667b9f2c67e1d6745a4f28d8ae4417612705695be23ca538efe142ba3e0850d55117e0138f8457cb7e3e2f8698e0c7f17d8eaf54ed153c537decce8cc5a89c1e8ea9b5d7fb8fbd75ce766e8fe57c5eb502c1de441d47b5adbc54859fb2caf18b291100a270d7b44751036a3ee5db6f84adce47df0f385c234b97f4493c35ba4c0dce3bce0ceb35cad2aa904a54e0184da1174407591a9549cb94e2d82b2076174529dbb3fcac56e5c4540ed2c5118f45726c92cd7fa959a3098f3495d31c184f0eacbc7210e892eac601c4376f7436ee02422fcc4b5e9aab65e950c37c2aa9da9c77e1b99e0083814b483822b861d5d17768264d27dba533bc1ba3b6d8d7800290acc7569a30262d3d65fde783e17472227316d697e1015bf81ce9af142f4865f5d4c376a4169e050bebef066c0f4f4d8fa3ad3e16467eb76cea322cf1f7d9e21169e8e5fd6e4368f5953fbaa0e4be86399eb7d704332ea6b6aecc9ed0c84a6a608e1b41c234dfb1a8cf3b70e370922c3bf5703e1e153a683dfc0dd56aa0e9f25523b3a010833681f6e1ab9d124ec38f745d73c4b05a5703b101dea7b803527e95e556223b059bf8a02645aa6ac09c0c62f85eb366c7360a03e6332427fa7cb7466dc90b94f357c6c0714412c7446fd59c1bf6cdfb8fd2d4e05d5b9d46825a5957001c694587256f71f906c0af1e1ef26beaa7e8947fadc7ece1cdc7ec4054778b7fa2abecf6e14d15ae2d60a5ee7a6e78dad141dfb1137750cc375117cb1fd1de47fae89ffbd2d9a0239a5d92ebde79400f23b755e5e16ccd5bc9c9454265dcb334db1af19a43dd7b966e8493d9b249fcfe80f1815f47f748fd9e84709761f4a0ea7c23f7d9f45a61e60ed41a50dc3dfc7c3be487a558e6cfd544c33ee465318f6d06c7e3cdbbfe995c01db10670b2fcbcfa9da579fc2b796a477ccaa551dade049211002fbc81d368457031af7b523804c94ec420d39d6c9635e964a3e337c957bad69254596ef912526936ffb3a9e739adf27d25bdddc3c180478cea5eaf98e899a2c98dfbf85d7a6babeb38f5eb0882ea6fdda00dc5a47cf0a763b9b9b28c5185283ab7a27716cebc1725c9f050b44908c6e18a0d0787d63220a992fca07ae35605c004804579f3927e0205a83a61cc5272861779fb112b5603146ac5d4ae46e9eb56127bb5fdbcdfdf2849f5ab394556e4c3f10139f90f51aa118cc6027198a1e15d80afd437a1ba3bb361020ff6c167027a75caffe1d679cc223844e84598e18a5519eafc994bddf23c24ce4bfb011ebe7675ee739bad0c685bcb9a49480193876b6f2f37e62b25b7a72fae2eb5a9d5b80acff7a733a6a93ac7c6b440339da4df6498346e791c160c7fd7c91e67572bf8dd086877b3d7d4c9b4f394dbf7f7857fb92ee370da5255571b5b9b24edd383aaf67e34318b5777fb2866d10af8dbacc4f206dcc436112c81e6aa724027af84fb232a4512fa025c3efd2313e040e8111a9f18f248b7fa09256428f41009159af83ee5f68ffaeeb4426ac5981c5ea3b1a46cf2aaa7d67fff51dfff97c9878d7485f32e9a727ddc9342017ab20fa1660f003db1bf99239343dbdff42879e0a6846003cbf3bffd3d71da557b47c5f45eae0a44daa1f818bab038c9bc45a0f03e82373552bb75b732aa71da1c508499a998c283a8f1a0f59844f7444de3179b3de9cb61b41f140b5bff32b1565a9d6144da3137560625be4ba1b95ad6c8477317792751ec3ef8d790139573df08894922056bfeaa6b4fd2398dc8577a11ad285db3e059a9ae86d75def7232a78e568536af95dd9f5e75c0947233e837aeb06cf1606ff47ef82543817fb430cc386a5db1f00a613a5399405ede8003e5e1cd4c3c0b91b43e17094ff513871af0e18b74fbe68178d8705d81a404ef8e8bc3083bd882bd5a7dfdc943acdf25bb2a7c455135314cdb060ec6309f3a44d7f2bfb43ec259abefe70fd440ac7b3273b58f91442277a207a43eccea7a792f44a3158b070c66e41bfaa49ef147639df1d0b3d9076fe1002f8241c0f7ebe038e73b5811dd6b466a2ddb89b7bff1781ef1541645ac359c93a1f20f7c84143142c883f14fa4cbd76a7da3809d4b8e7d3dfccff856b5795ab38aa5d265bee55397113b9ad87525bc042810bc6a363a9bea791b31dd7818ce71101168427de6ce8e7d52e31c7e91dd1b48b7664f862edda684ceaa2e1e5333362823e4d7643552baa7d9b0142266e43d29231cdc2fceb53c4e08dfb9d6a8c669b2590c60a8af30a723a7b834a2b0c09621d76c1c8eee750812a164e329314734af7cddcad960df2e7b7708b5b51926f505255e81d31bd7d0d7ee5d346e077d489e1e03d16ec3795776027f27d87e0bdf69e6e79bbdf1762f89f104d9c9a1afc05bb762d6e5e43bc44e504f5e43262bb61da177a715a052891be8266f541f2b0b0ca6909cb43308b6b06a82a2cf7885ec9c5a6ce4c7595097d006a62434b2c2e6e8a658c56a98e79bab5f733a349add485e629cc29bbcb87ecf44f925d04b4a6f01523825b27e8133f46e5140620d393b38a7d0dbd636b57998fda95c729a1b3a3f08e3e5169ea4391a249fc8f3cf65414bc043be540fd90f1571d37df2389382424cc178c1a5c2aa9312b758e9fc6f5b24ae2787ddfb96de4603a86844aa9266e7e46a598c697293bfe242ad2f142b90097d204dc520c5f1d67aefd4035cfe32864f2fa01fd2ee704261c1d0a779af81a25dc75a1eec23ac07648251577441c040f89164fc9c94215e4c0882ab9bd8116f7d2839087ecf3fcb2bcc92c4a0c6deee66c7efa1ec666527adbdea4776c416bee4448ae536ceb6007d5211d0747fd37b0f3dbf36c48aeebaa4dda5a8d5561f16e490b38293878b19e827f8812862e4c6bc10575fcdca01d4b738166dcfb6474227745877b648d1a9e375632ab0e7f4589d92e42c3214a766cdf00ce267ce1d7558cea44cddbfeca4c2fbeefe378c3281d1ccb04de8fb691f47febf593dce95335a6c67328781dc48538a946b0751d1aafaf762e98534aaead4ad101c61a80efa8295fc4c428611fa7787da30b13cd8fdb30213d39b1a7ce5e61d22a93a9466cdf18108e6ebabd791316d52a93ed7fd9c0c102cfb9b2b195aebc13f486f8e1f2a07dc010aaf2f4ee1404867d0b5ad941214f71e4b8689e0a9d8e2131d4dd393034a478c5c3436f06abb3a7ce4f2d087be49c1e454f17ae746dd192e3d26683ac584d7a22d4549ad94adf95abe4f566757482e518087e9191f72d9d97f5d93fb87b29492199bd491d42a4ff237fcd784d0563135a0bce2ea1a76e34402a46095ed68fbc4bdb4a7ff99fa99643c3cf11f37a06f5119531995916bcff5990b1d1054c77d5a4c4f7676f56649665bf9c4a258b4c318054364ebd46a8a92af1fde425398fe94089459ec409065ecf93677ee439bbd42fab83db936dfd2f63b2bfa67b63e5712f61f4cb64a0f052b7a01b1b7f7351e2e652d41b329aebc9ae12f8cc1633bd4d644cbb000c59dd8e3f46120f3cfde5d139a08b3f75ffa2f495cd7f24de495b627447dc8d7fbf2a0045eb9f651843c25070be3f91e094f6626c1d5528c7d35b135e6683dc01301b1952ea767cec902d5cc4b341edc91a1720649c810510f4570971ec59bdf524576f8ed482c48e9ebfe78cd2e4f2d8742b6139f9959aa27100d94a573d2b436ecec7534310331dd8ee9e37b995e1c7f8869c5edd99cd4fe63993dea0fb5605820251d01ee2c49c8d50feca6b3420f29ba182624460c3f4d639a5b3d8f7e7e61f9c7f17c57ed6bd7c09e88e19295a8e77e216a2def1fa02de887257ff2488c93268b6a8529106ce0d1fbabc0f5153896e738d6140f121a7d034ecdd98894e3a39ebe3f989b600050f53af6a33923bb5bf3e6f54f9f626f6be5cfd952eac541ee54c389fac32fc038fda837f2fc476dad4e0522a93054472d7f5f513d20a4e03f328e2f3594d32f95cb42c373faaae8e2ec4557845a6e82027a46b4d668dc1ebd552aa5402624dd0e193b91b4d59ad6fd06ab5c7854fc9e02b441c798a27fb8a3f035faf9e2008cdc5d7a3198e30a3087fc0d3a76f28c2d614f002e0ab37f8febe55f38bbc3c87289c2198e89750f0ea48d97fef84872551c85a9d5172c360408b5ef113192e086b726e77df0d0640ac4e748d7f7b3456947d8532f410adfdd4b1d3de0c79232d92e3ce726d7c7e72f8b08757594d8608b63fb8c3a21a51ac3b15539f24977ac02cc6ccf30e9da197bd90c46c5bf7e626278b5d45f1ed36c420babe32a89d0bda01fc28ac736e8a2ea111c34f44ecdaeddde58201b4bd0bc6ad8d4d0ef2d77dce1d04db76d65adcb1f03c292c73a88ec09f0e95876c1afd8f34957ac67058d012215a2279f38cf038f13b40143036e86f509e8d95303feeef62fd7b20869c92a97cec162439cab5b409330f99e71b62ca59cc7f38829c21337d75a367799bcd80d249023f09af609205561478f3202501831906bc8eb3abff916111cb426978fb5a32fd8fbe905e9def16c89d902c0ab5d9cbdfb5ccb8b4f6f115e5e9bbfcb5afd42f12360f5b9f762562cb43b6829b6b7d077ceb3ea0d82ab689b89b202934480cd6b5b6c9526d6c77fcc8fa2307e32d1fe7004b75b1ffd2dea2f40472af2df0195140c48d8784cef86fe35b03113a101f93d34f8ee1ac7faf260b8ddad66c17a743a7345891ac4a15dba9792021ecaa10ac9e5aacd99cd420e863bef32c203357894020460bfca3edf02f829aae43970b593136f683f5f9c9015a5f86613c1f8bcade26201db93fd168c6f7f7b1dbc0507d8b1eb8417b1cb3157ead89cb19c4858586c433cfa72bddd9e688b9ad8e759783e213974fd5b1be7678e7f47a23bae5bf9af1b2c9d64663117234ce341915789c9bd1bbc9ada4480a02bebab98c51645f0ee582b7b85d9e7e4342c2de755818acc520ebd4a0de9c85eef7764c1683f6e941f92bf8c99719f0801b924f412a6463fa01c1f98b89830a71b7e8f64d6314d436c8ae9d284130fa147a935026ba57e84db8d0f18046d3b138540c32ac3d097c2b6038396d2ce173f96333fb0484469c52d5f991efd2f3d07172b217a68749cc90d6194c5300e3a61d0b40c335311a958328ea226131521384d6122f2039761dd3919cc27f15750a9aea6cc747c596a477a3358cf9a014020bb9cf78555915ecb35f9815e8a9eb1193be6ff26762c9be70a6d13004a658720855b96162267dff6ae36f00715211d69574a9b5f37716faedb18011bbfa272b1e65ecdb6b4a3655d88528ce8d2db1147358a55f77c0aa3d25a5f1626fa079935a979faf4594698ae59cba9b0a288733cdd735be4430b2c12e60d1c79de56d2b5b3ae3b9fe1be9414ec9fd0cf8b2f9faeab72e4394ffb4ef356c1daceb4dd330d779f357821fab251c0a171ca3747516dce65614aa72b472570e0b18ea71f68d1804ac93b727e0ea98797e2b17465ff1dcac63fa7171bf538736623c3490d2392eb1953243298669fa72fccb1b57f87c9f61f7b5eadea44c68e7d1e790ccdb4e0ea414dda41962702bcc273218fbb56cbffd276e33de23e3766e91233ca13fdee426f6f598616afca14e68a2a3dcf6963632fda85de04f4dd944117b23e0d417bcdc5a5df68621d6431ce6ee21df2c836f7d868366bb5b8ae25fcab9689d4a52cf92e796b56db45924b8101a6315d611c627e119f036b5ff41848e541ae7c517a48f8c2a83f7790b8ccd986a39f5b5eae9fdfac408a756598e4b705ef15a974b5cec1c56b1a4dde87d2582fc131eb633a7f24275e26d24325efbbd3340cb6bed4b6bc05046031c32ab0c83a7ad6ec4cd525830dfac20f567d18ed33fd4171fe2dbd397ac18d62a6df6dafdcdf1fe54e898836ba108e43095d2e27d2884962f160b587f2ffa3459c9043914ca6c34ca5cff4c498867d0d45237673e3431da383540422c8eda6320b612103ac091b7126c989963cf7c5ac400729c34a089848024e222f380c20516d592a8dac61a6e463f3bbdb43af632436d7f379aae8fa5a02d81f4ffe189f84c151345d1f6e877f386ad0c340a0946fa59776c82cc7685efe641aba0aaa33697dfb4ac9d8c102f0e51f6503230b5dc619dfc5d60cca696bec57cbae6d45f15f12742ba2913403db23d8eaaadbf205f2a296e9be2a376ad74e63fa30d22872ab5719c855b0ef968cc21c214d352696b174db5f57345f3b6d81fd05182245549c6b71c9e1237d7038c3d4a3751ad55f2e5e1a98cd2c08913545ff5f6d2d2cb8cdddd70996ba3a65ca07a15b6fc43274800b2278105d3682cfcc5f0b1b6fcfc271344a16a79eb7ef46fca3085b8c9b2c4343d5d80af7490b59cb6725ea48f81dae1e1eb290e2ccaebbdbe3c0955812a239925a05aef5268de747a359d150537408e6a3554847b5e2bf7209686fe0ae360317233ecc03844c9037506a9389c1fae2f0b7a83fa603f38481d73c3140c309e05fe639c3738cef002006adada063e308680e0b37a91aea761f594e74971484858cbd9ef691b803a844d98b968b7ce94a519410e0b9b3f56cc26ffec7ab7fd10226dc8b1adc1e786d204a024c1edac82bb199fd4f5316e769cb1b87a8c9c760b55e010e4ee78722fb2de8253275ebc19c85984f421fdcb5ecba9472c55d1b644daca0ae05ff3d399540ad98414c0e1bcaab54322b8981fad06e082198000f54e2edece3c5c6e8d982efbc14869de59df702c1091ab18d74bf0ba3464aee6c6a17906599ad68c48306d661e9ec20bd166d5e8eec6be8cf852e745368ec243c27506141b2d01a2b9be6a9d877638716d6721889254e220cb2f26e9a65fca2cfcdf40717816205b7e8856ab7b4458b7e325e58f2b2100273285fdf94eb3b8083e4c64c6f4fb0d339168c2a85a91c30b103ae5dd2c748716d32f6b05bfdd6da0ab645ab81d9eb7966371e3665f5accbe5273762d949c3e796c4a958c674dad2d6d222da37d0c5f9503ea7978e4855b2d4ff60e5c45347cf3cf3ab0d977bfa0d2c8cc63db958d82fd783303da7e9bca0a9f0717267b528ad5c7bcf1b1a13a97df17ce4762b89e1f39c424a400031d23c9fe2eb336170aafbe53878f14b8d7c6120fb1f7f09f1cd15851b84121f0e194871c4f8e54f3b31ddf7ad1bcbab12e6bf02a9c0056f11930178937590f581495d2c06e7f9bc014613ee80511efb1e38cf1aea76fef9dbd913d892563da9203e53231db6fc586168e353fb73264c01fd08a3633094703b79e93ae42729d095329ffb02b392232db1d33e8dd034ec5d9de11382fcf12d8bc033deb86b43981c5250d3b3249af7eb4469264768a6e8ab565e01f40094741c92dbd5246e1c6409967e7cb1084793579652096040a127b68103f02d7e1229b44d7d209e1d570640f446ab81df499cdf78a793b242fb4f1d29d575e3e398240b8b87a684734debbbddaebc2b895350250329053aaeec05d5ef631993f57a424da486a7966ca92e080d096ebe31888a8141abc99b177054a64720e6fbfe99889b1067407691f4d0c8a4b575ca4db3867db812119cf97175a9f76d9a9e188c4e898eb8842f0f60ff329e576fe4a64e5357b78f37a5d5318dd0f231a9447cb713a11e3c1cab5f47a68d87d9f62678ae33827a017a46e476575e7ed40577e9d3c8dfcd46753c822f55b992db1eac9ae44b251eab45b1557a376ba8f1d6061a84ad3450c36314c444d1a7f364a817c22cd09a60a46d3b22a995610e32b98546f986046bdc73cc189991dc8ef2820ec9f399f034b0b3df6a9ff882f30531ccbad2e0a72f9a4ee102a5c6f3f73c25b90dcc746a25635dbb69ffd05fa73c47747aab3deb05fc4d320ccd7c18c04f4044dee0adfe85c30190f20582623cb2115df50799908659c584ceeddf8d14cc2762f5ba70d776cd564683feca458e8d162bcc9560cb251492fe8b30a428ad700bc7066844d4b6848966e4f8579998c80dc4a4ef16c4ade33fad57aa1ed30a41c7ad5b578c06467e969e5962ea411dfd81d30e57261889476b01ce87a60c06e6a0507f7d4836d80b2c4162643cf49aaf364978160657dde6134e5dc76d62ad21c272fb90705c1773dac4092b7cbe939207d6317db98775e93f4c1ec41efe7370a1d824722e29b6dab942c874fe7f237c297483a7db9f7c93a8983c133217b031d3caf70fec7e52d738f9f20d926ae60753ddd084df0d08ae2731ef751e7d69f1ee97045ca1f327c279cbbc19b0882f1f5810cecde731728644fb00e23a0f78ad4d0f6c1f0f51924380bec64a9f338fe130d0c3dc9edf848e8e3fe9e26845f22f6707ecc29b1860bb737c406d829ba9a73924e499c2e173e76a2974d563a7ebd87dd9fb5b57faf47066d498e434445d1ab7d9aeedac73a7619949fbbfdf53837119e1f890445e3cb56437befec98639984efb656bfdc556bbfc132ec9787b42e28a01632664de6b600a3cef3e7e0c456330609225ad7df227215f6a8fd2e5cae6531e294729c99555801c1b02ec561451261d98de41325f6a93e9a4e22c69d518d7a005daeca20bf68e36d21e5f3730f7960e5b078af2ff0b5ad2e1a2217780ec25f6ea75ae9f90ae658dc6623557cc8dd253f33d47bd907ac91d3dc5358eee771b1080c7f12b5c08d345dc0f54b1cd02accd713e7107d1167b3383c165c6342034e3ac79cf64ece7eb29cabadc1621f775a5b477473afe7d666059eadb479985bbe936f3609da8e38b284a2d76a961a0f8c64bb63b321e98fb53f6718dd02149fb9e6d7b86dd53dcabd3d92db062cfc8da5e6d97dcbf1935a3a26a1d913172850e04e797a75f4f4147e10a4f438b95674561fab54a26a7423b4479e8a0d1fa14df204cb57510adaa6bac63283046618b3e0693c36fa004e5fa15001c5e2877ff9a7a356de91512b319b2cf9a0b0448915548bbff22da82fca955f0989d46bca8a1a117fbaa42693bd114a002180ffee1bf660fbfa274dfe13e29d759384bd79a81a53fb2d6a36582fe1a1c7925015daff26388f44e826f63c419f66c9aec7b05219bdf8696f7d4b900aca187954b3a6c1b86d0ee5c0e1a4de190ebe890f5c24c941d2bfc5930c2032edb55ee48af8df895dba7bb509322057a60eb9da5c1384177c783098ef467010c566560b0c7e7bba4b158e36484c307ac3b8785adc43bdbd6bbb5c8961ff35deff5d457b37c38283c1b3c6eadc3984bd23b07330d02ab93da1e44ff743f15ff5732e262a28fe55ea86f4e66af2adad8585a52c69c95e4b36599c5d4f11667c5aaabf38cf41331f230c9d3465a06661de5fb6623032a1437dad85048631c9b065da219c521f0effca3890c0ccd969bc7bf5f6370d684d116000ef9361cfb7f2b417d1e648662900adfd1f9d4149105327c311e1ccef80e1dd5705a056311d31b67462734de797089010832491f9dd4a990fb4eefd8f05795b2b5363e5af1e261ee2be49b8f9784c1f159c5346fd9291af2ae46eaf7695f77c79d21b89ee201303bff50cfb1f54d894235320cbe5431e6cc1e38f15474dee45e673d147f5ec8b13ab80528731d213355cd694a99930cfc238410892ab8c214cc5807a898952753c6ef16074771bc6cc899e4da360f8d6a76fadf26b8eeac051e3b342456e84be7c06386e20ca32e0be2d3c60130b4be038b02d2d3ac64bf91eedc9c8a446e4fd93b764360343b0dfda6fc14748e6442d62800b627287bbcbdb98c3a457372bcd0cdaebba0bc15fbdcc157f8919b727887d2bb17dcaf29755d2ba033701cf2df734735fb1acfe07ede2d6913f52d287bd891e0e7793e788767baf2f7a8a222ec311e5a5daca0a0290fd97fe6c4c541e9df7f7fb4e3dd056d92ba5e6df489e7ea3e380ecdbd352c0d2616284483a46f80c2fd8c71be1682d914c6462c8e715d802b406895a0a0b0825bc3b7d54231d687f4805fd1fadb3469a3020fccb23c527dc24922c284532d410381c2af79668f0a4e6d352d0180759f054ea23fb788c841165d1910ab29f4c3e22fa6f6e1ba26e27bb6adfd41af3335dccfec41ff4677efe76fd06db4dd2f017e3400931af31d9197e94be32c626fb772c75ed2a4d1486cd270ee0b31bd5870d4a935f6f98d67edefcef83ed036c075b6ad6dc1e219db34e34abbfdd08bc06048c3ebeec409ed9a4c0b805aa3a8cec0acec134d949f02ff8a33a769d8b20aa0aa1a8e8dbb140d56360712213d2bd778027f4ccd5bb9442c1028c449b90bad70a48ccc18aed7150e0eeac467f9422cec8ec39b7042555b0ced3a47bcf4ce75d0f99219128cedcdcffca50dc6ce54b505e4b18208e3c1b6efc3340be4a572020f5ec12c4a1f47ea7f06e949fed60c69cb45660de67140f809d3170d59588e47b4d4268005652e9c65c94639f64be9d72ca3ac48c6331877241248f1280c2c0cb7d8dad43037d90185b415803ffbada1216acbc4ce35a4be2064757b6789486d03c4eaaca5377fafc9be4927307242fb175150169a585c0b4b86e8174f65a75a513131cd7e2fb32e01e90d198b64c330b36f0a5854002bd17ca77e53f15a89154b525ec47c54d47ba514fda8b80f5e1dda40aea7e7fb78370fd1725f77d945b603749d607a26c88777f9a1068f9ce2b51568d9a3387539989d8b0f94f2e942aabd2bd134f1d6d1b6e94355cdaac1d87b3f544df272fce702986986eabcce483001e654168e6c48615a26a8785728480b801941bd6500dbb7a561768069feb8db02d28fa3d51421541ee748e7075654919d1c9c30f04585aed7221d18455cc2135a636ab8d855bf505b35b6df5e1c42509a69c4ff7d304112abccca9866d0469307e4e4faf811418ab24e2588c7d17a1ca3cf6cdc93ed08c2dbb4f28a4fa1c8eccbd0a250bd8f882abb3fb6ed9dd4a7e04d1c78026cd50ed006251f9c1c316001cef93b63b6f79ace4cc9707fe71a0f1a281098ada29281021d3a212146006d8991a1892573fa85049ab48b939bd0ef5a95e6c79ff2e2e754a54f118ff0176f913d14f3478590e3d31aa02fdf7b46bcc6fd8a239d01036874cfa017ffcc3d38f73271f2c195063f33478f3d017db3b4994cd5e5f03c17ff45560980b089936ef0f2a0a74e89c7129021c7a0f8be8a94a0be6789e5c523255d32104f85d2832c8355b154edb496d24b91c15aa91568babb0008214d6e659a861ca66982e11e640b10120c61222c7a398d41c75b21d570629e8dfdfec41d2340e04164529f488eb88b6baeb2e464642216d28d3bf768c41dc0bfa0503224c73e7e4439c4535a180f0c0a93aa7c79c343013a55d95904a20b3abccda024cec2e51ecf7949e619f5662517db594deceecd92ae94a9812cce5ceac140d04c00b7d0d4740778ae28b069831b7d922022e063e8cecd8475c6a4d7677839c5ea7ace4e2f72088bd44b6598ff828b6cbbd6a2a033b21124f3b47655000f8ce829b37ee29c5493df413007c6071d16c182df328fc492f2abe71ac94407cd5ea68dcb42c29d3b8278218c739b54d34bb22fee3c31e4dfea1d7844b02574ed12f06d7d2f5ac61df97af0bfec13f0102f2194457cfb7ec0d1e19978fe0dd1df18bc830587c691bb6db11e59b3fe8b9344356f92fb559f502c443b350528794899828565845b042a6b0a3f18a47e28a121da515a531cb8230af5fb973532275aedbfd38c6d1e1e1fde18c85cf18b0adca33e93b21c20bfd5a28a75f502fcd362da75353a9c4b1d6a729064184972022fea55553133a717b519fa13e108ede4a565a9a4a895d090416dcdd3abfa52028cdb57994a0de84ccfa3227e279c7eaadddee42a5979cf3a517b4d5a4ffa9e0477253d648b66919ceacb408e7d9cbd2efe70b3cd8b0720c3b11c31c2e8f19e42972147f364b3425136b77bdae592cb531322278b3940cc3934b4c1eb70e9edbac8fe78007a5a10edbb1c59cd0ee75e4254ac5666a1239369abc2e6ed4a73fc0768df1817a07b0324db18464e2b3c4028c603d883ba6d67fa1c82afc62eb38e86d25b31f8062198a65a2514fa07d4ce4608ad4a561d3eef6304e8cd9b89083acc54fd130f38133fbcd74576eb5e2d79512343ceda357e05b01111168b759fed6d01d3d1f5df2cddad9ee78313acf0481c76ab89e5d07f380d0e3c050babad65162a37c20994f74c00360b392204a5559a1980247e56be4b31d0c438db0dabb7ec74390010068fd77e260df8feaf944b2c562a4c4c43e5b48b6a03f184b767c94ac8e6ece95744bf15caca03d18ebfef3e04003314b33e1e48fd8e966ba17bd8c386d5a859813fb87c2bef039880b79439f2770c430e75e720d626326d502ef47ad5f19bd6f9686cb140eb83545bc9a5bca932928b2c23a301c86ff112249f7fc9e682f171183af7410a7c75c02ce31f302e2682927e069779e4c6a7512ba9b23583c719cbdbae696761a8ab97ca3e13a28eb41cab10c73efe00a64adaa0b718b94a5545140c7847f07ecf5f70f3f529f564d6a6a37831c8fdb17974fa70821157689bed26e9b80bfb84b8ab23824b185f9ccbe9a1006f96c1a553e20c6b745103b2864ca8d60f9f80959212c675a32f3719f6b20fa140bf208997f779004f5ed86e4ae23db865e6ae3f7cf62fd0d9d0141c9b52979b818f02e09b3a48b379159e3dbef0d1ef0334134e781f168de6ef3d7a491f30c93e03b17b3bd33c964d25a0d596ffe72fbdd0943fad3ab233839765058cf13aed7f4dfb787f128c809792d49bfc59019489793ff56b57fbc4d465babc60a6ae9f785628f0dce919d77d345246a88e11b1d2dedd5ec16b6e08f30b45a1a69e54a03637b9c0fc6d4a0df1351708bbf10290d025643046cc667984ce9647553f15a50bbffb22a758623fd0971ffffc194bc4c4652aea76b806578c09c880da7254f5e0f16ce9378a7788f5accbde09618f10952bf7bd1dceaf98f6a8c6b46b245e645b82eb9bf384f1f56f9c96103967594b43f9d91a3f920bc963aef4c771c6e27c365fbad6b0eb993a4be21cc5bb90db7504c2d5e988eea30935af16a677ce83ef852553978c0b3d8367cf72af8083c53645705bc57bac0bc1de5692cc2c3470969ca70861cb51da0e0e06cb64eaaa282bbe5f94b564fd96b516e1fc6d1ef610a0306c79639cd0646c21fe6c9a4ab46cbfd6df7c3bc5f5a39688a0f908c394c5b2f42fd20c2fbd13800284fbbb61165482f9b5ceb4f60c73365a79688c5594b01b465de0b16ef342b285360b94d7851024299abb62ad9e8ff6ee67e462c6ff935ac09af435c370e3e99d080901bf7d679319bb779d7e6cc82808f691ffb9e2bd9c7e3c95dc68d67b34b5c370f0bbbde6ea4c3794feb419b86696c93dc625ce04f993ce00af4cebb83d0581531a50c9282038a5298c8caedd214e15cb689d59d47ecb8f801fde198ef8a3332e37286729a73f8bd22e681745ee5723f213cc9b496a11f18ad4f1efe51b631b10aa0022aa7b70e875fcb0a4bf4943d24e05e6b25f0fff1ab6c5a49ee254135211d9ddcba64236abe121d789ace1b812bf64183e2c4ee3667a142a7cae50364319aee1f2d975f33935755b5e5199476a117b1ee52ba249e3c44a9185dcffac2ef5f9fc7151cb4ceb1bfbdf9fc2d20d7203a02cd09e1e72d359e9ddd558b579a6beb318e2124b2d8dd7e8fc2d5cbcee5a9079522df5e9642e07703c2fe9024014924e1824d0c404e11aedfecbc9a479628f664fab4b0a4c1da749bc793d75c631959f43daab97861ab4c9c2a29f97a760a22e9501f8948680f245b93e909160904d0e3ceb0dfe3a61078899bd82c4193d7451de6725937869238b0a2ad7b6d11247099e03884f895459d27f8ee1729178478f4e1a812d739f6729209283c4eb6f0af9d411caea7d82e93bfa673c84f0a1d4848dddf6f0301c23ba73ead2a8e6b4632b75c7a6b972f0dc819702fec62fdf7874ac737d3e4a8f02b5134caf3830bff870a41e2881ed97f80e71fae39b5e6bb496f126f337b6dbdd649cf81ff33dc52f67b7cfb36f7be32b4c014ff7afed13f98bd4430abce4966aa6a4ce4992bccd65a82eda3f9b0d35eb874ee614cd3cb8c8c9909c45433e8bbeda7fd5ff8b5333755cac0397615e625a7eb8070603a2d0231db40405b0de39a2b739b8e3e314268ce34f50addc333347ccaddd28abe6e4479cf8d6a1633051b3dfdb4416f19b295395228c04dde7e3f3d62dfaa8088513bea18a6f9b2aa53b576c60ec77f9cf9663cee5c8201c7aa4b1f242d04787c78eb9aa94afd3d12a927dd32f4579c439160ec69fd40c99951a4bd28f38b5da481ac6328c7ddb7621a432d3ab8a7b87dd2a71e6b9caee505ede3e89a2ef77803a91c6e643404fe589f3014d1419c1cd94a6dfa06084acc590fcc9aafe146666456143c938664393dab6283b06f3ed3df63097f81921a0047975c24fb7acadb7ce0b0922e9e0c00e6a589829f040185ff3c5c63d35845c1f8bbe410d011e6d12e9a5165345a451eea5f8c8dc1ac968bf7635e5b2cbd58148f33f1f265bb8dba74059dcec732a9d965de85b10507c4b1e77a2571687fea10648d63a81ce280209dfe4c99b33f01467402f8e77bcec2f7c2605684a482e352fa551972e480303a2b9182dc91ef6b01f4f077b6965cfd9311ea98b95155a9e9bdaf744854441f3259c5a6009f643bc91685f2ee36d7e4171abaef9346db73fca05001c24d7bf426d262449b1df5eb1ed495987c9717804d2a987913b36429fdde118475f9bbcb4884384262d3cd5264053cdea9471df65cbab7c11f70e389bab55e09de43f5ce80ab69baff247bacbef20c5c5d023f9de3d8b299d55a59eaece4b6dcfa02f2871ca132082284520744e93ffdf1805b03f6edefd93051bba45ebacc75c2f518c7f9ed1dbe05c50a3358f2d6e7e7e2a135f1438bcb7493497229b686c635ff55819d8cd2ac2e554dd93b3cdb9557fadd35b5f8bfea2bb3586d1b0d5ca3797d440e2791e7f2ec4cef2bc419fbb4cf883c76c1187ae8f76e2982dc556c8cf206a5c7470c6dfee242905d6d5d2010fbeb96841153d8b6d640124f5401c3efda813a8484d5b648bd891c057e0144f6fc54c55f22ef6aa48a72d476e541178787b1a852f4693bd995c0bd17a23f61c9a0560d181aaa3f2ff587b5f1b8f7db7ba453336597b29a95b506067b4c17811187e1440ec29fb9e4b1ba7907f09a9b0a86a1064eec5847fad6e5cb942efbc8da00a1baec8f4eabf13321c3ff352dd0b0d315a9b389113aa4467587fc9985824bceefc47796bbfb816221a99889571e5e256bfcb5a805d253e31b777fe903d1b37432ce0eb7f04c0df0da80d00a22c4e70d3d7c799e26103fdb06ce1651732ee63af286dea55e8630d4bd1ceccd52bcc30d242c93438f8e958cb06041fcac7cb2d186889fb6ca602e8e9db52290daad78f30c0eccd498e921c40fba7c0546d14fb2e3ef1d2f54c4e4829c7d53b13765a730805b16294cd4ad4e52d98456eafe15f0ab109523500d1cd1065d74a42a4389611b27bd40b6874ec20bc2909f8fd7ca03204551817ba6565abcf9a01460bc5b2e3211301768a0520b01badd34f52e303ccc601a45166ba1f9ccfa5c43168497d63bc246be0380637288400f726e449f6c85c5a02be25d557070743165d9a816ee41bc072f2271515b96bfd7a70b295fb4d4e5310c5758b290a59050bb8431e5ec997d91d1e7ce4171699055a3806e171b123014b04f30a383a133cce893e43edadb7c970f135b9c59bed7ecd753dfc23c1371f308c7051c4e7d38036cbc50bc162a9cb560af9edcb0c9452aa2a1ce9ab37b58b2e5a27b3131c052c6a8fe1008d46137f1a6f496d4d80b16ccd619a5ea58be7c726f0d359268e09df932ca5a5edc5836a6e4d513c815b0f3f98dea546b08222797b2bb2bcbd07e6fca61611ee120c4e730562bfefa070763e7d8f963f4332c7ebb1bd692eb3f4462b349ef6c33a2edb68bb8a542f279d9c659c15251d4e58588ba2e827529e163fd64d051081fb5b56774d45453b5e8197af6ff38a65ac35236c396055a0cb9601ad7c9c9b785ede21b5a21caa633e2bc09d873414d36754bdc4c67391e382f02622c4d92c6ecaefb19ba446d88e9cced4b657a0d2d4cae37a6cdfe0ddba9d6dc1eeb69b121abeb64183a7f4a1b5a8e4ee0113ca520d43940c63cdf1301a6e2fa38a9b0aa6aa5aed552f63182c66bc4c958c988f2bd2131da74c90c9f5caf4fdbcb7a0c9113ebeff27437b9f3d427948cbe96fd900afd8d571eb6dff5ce567576af6216aa56a2eabe3c69767aa7e376d7eacd5ad1ae3d70d7dab12ecc15c097ad411fc5295b8126818a50d6dc266c4e41eeed7e801e0240b2c1b424ad3724d625390f18d1b24bf28df3017f67bd670977ecd822baccd92dbd16c170da03e51f7d8451f2d4a9e0e37fc9b9cbc65bf6f194de91cd4a00477613bf5d58d232ca1dfffc1803a848bcd3ab47e8c584ca88475a7e9731129943b4604b049736e7c4fb84cdc84637e45f4b22256c46ce42a022f3cf438630dc0c1bcdfbab7f413c25aa88d31b2d2dc96b16b9f028958b973181575396d199b7d943d71d65e5a1564648a099f5be9ff4145bb27468f6f16c473c1f167dea4acf8eaa6eceb87dd1f1fb7265dc964cb5579aa8fcf4b94fa9ef32adc5e35b3ca370e7b6a7881264a93839d377a9716ef92681297f51d8682cfeafd7e5fdb070d75d31bb3374909047272083239b3032388aa2e0d552c3c28b126e451cf979ada0b0c38acf5929a510da5850c540dfdbbe8cf4bf716ccbf0a9e39eb3a1d2a8857cfb41055a6d4300efb27867e6d5816dd37dc3bd9b3b524fe134865bbdf5818d17f7bcf895429ef25a4d8f471fd8aba0b40ca102dce83f114398d67540d6c9a2eb542692ca0cf357d85eb1ca19860d081ec06a7272d3718bee3d6988c74b151f18ea05097a2a7a2250f68e09a0ed7eeef17f0ff93a6b47e79ae04507128fa71950660f8c3eab9a102e8ab3ea746b4a1a1e85c6ccf15431765dd8d02ad971b2c66c90126cf45ae8d3f3ee32a4699febd359e148730750f8924a2fb028ded6dca164f3514c533546039b794b242a17ec65c4953ff62ceaa68e5986b8f902d4eddb27a6265df3b1ef3bd831574942446604fc24b3382fd8600822f0f305b339f77b77324e69ecea2cfc217136589c227d7ee56a09afc317da90406ac652462447b678dc91f6b071990f5060ce9f18939b2c115ec008aaf4ab30d3e1da8fe57a8f5ac02d3baa16ae2cfc791d537497757583e4f3990be900edddd1cceb48f6a368c19057ab13fb0ffabd88015141420a0c415e38aab0434cc5d075a412d140ce1f8d71d27528ec696d3dd06c7d1ef7df84a70335299078bec7c07f38d85c8789d96a027fa117e7b71286e83bcac0be1846c4e24fafdd8bbbcba4a62da421136e3fd0239462f99a67fef4f2b176f068f32bc7f6160265b62ea885da6e689fcfd31b196ae0f24b84051912ccdcf676a782fd3e1415322ba470b934b9c83fdf6aa88d9e42493e8e1919deacb2330b141bc6e55d90218affd9418976fce16edcd98ec121d9abe050281bf2c39695ac77c66280637c3e8f1fd5ceccd35ff1ad358b9e848e71fb4775e1c334e7328c16e25f356ecfa986f0245d9c7e392659b23644c07a3e47d4b60f7a41c0b8b9dabea97a53987a7594f45a7dcce8031c7bc6ab7c35c81b1e58e893ac2c175504eb5833cb0d31217319b969ccd8861985a31bb50ddfb887a613bb8b4060a17f2e74f5e7b7e6bdc04ef5c44a4f162ffcaa1c56c2f677dc076f646ceaa99079f2fd83ba1e42f0da7bc0710d93df22cc9263cd62a487180bcd88c54bdc4ac6925028b12ecc6780820a2a025b6404b9beb7e04d4527ceb25dc088f4149346007fadbafbf1daea96e6382a5837e9cc1c5a9b8aec6a2aece91953ada9a9a01db5b05e26b016b84949790e1cfff50cc18a7456a7ec4374ff96cd2ae0a24a167a802b9c0e8edc44f639e6eb6bde9d286fca2783e9e7edcf8d8655c356653466ade4090fe416b8fc539e22046b17f0a757bfa7b1e16b3a7f9d3ab59bfa7d46f102d7a20ee6cb4a72ea887eb11587709fa7e56a1645cbbeae02675d914b703d2ebb8b9b9a159daba558bf307090379675563437b9904fe6f6c937c70ffe77592d88e2e97823540ec79f25189700ea38caa32b1957d1c7b096fcf7ce57bb470ba1e92a89f6d6a1ecc7f09115133d404ccb60c74be615e426f8a1bb7edc4056e795f011fb677affe9ddad266138c67214e40f4c4dd0f7efa6dd6ca71f948089e37f8112d9abb4242efe7b1c76b3b8572cb8792bd5ec67b5c65cfcd7510dd366378c5ac9058d32d9c7db7636e01bc97e6164780e0270817b51626848ebebec1d38c6f0aaa4bdf48936d7909dcbb266b5b78064b9123433168c34a320f1037b63916abc801ac3c8a05d10c555307b93027d7d2bc97588f2e6a9bcd784c9ef05393581715bfb04d139f7d68bd5a292fbe92b49ee39e920829c57bee141fac52cd145da4b53240f5546733d8dd3da5648959f6d7f4b89a841915fdf50264527348a3e4aa094d30a898331348c88bb0ecbc2d81fc70d8ffa7ee0ed231d47cbc72565b2a209a261736352f65182096b794e632a337da566f9be9f475aeabce74513f09768f7276ababb85baf3348f6f1022d804e52e86e9de37d212b08de42c19370b17ec3471cb5f05a0b1c61cc0607e3ada6238063c0bd1d608249eda1c40f44150a9d49649a8d031f65300d7366c252a2224cd3b6d18ba2651add2b98c772265efdcd386e9730f422e6d2021277d8802bea2461da89e351557f946433bf2d2f492985e65c5bdc00c1dea1ce55e2baaf35e6b8616cb4e908d058ffbc30a6518ec7624f73605642764eef99c628127d0eb4730bd4af81c48405e51c2b647869e2f92e45591099473577920cf04bb5c81994e13271ae06e4b300773a3414b63664da474d66f15b55006f92e63d013fe2762bf642f8eab9dab7f4f3213902e77d1d151c2fcc467539f2738e46e15b66bd7a8f6a071de8f8c5191a5398a90513e37cfe4f75302de796c0677b63a6e8a721cf39698ea3478346f359252cb9d146d6d8903820e63151e6ab9720c397e5c0dee7991483726cfc080e3b0a546f161390b3196028bbf37a063f2599c0612d34113ab70058a6596ede3b4338dd2caf0e1ed2c707d103decd5c40e4d5623050ca7667d4b541efffc3646945f9a900fa517f789ba0cacdb9d78576ec188301110ed3cf173001c4494d3f2de32ac065c4f8d05c524f2565a4cb9522907a43a5a3cf633a9a617e33fe3edfd5debda74473a58a23c9721395f5fee851e265d5e6949f6589e0ae325f012fdc37b93719522dfcca76f4157c4ec36a84697a1a90973b56a8a9b16e63e8909ddcbe7c32fc24d828b40a047c5d9efb2f068dac2d5776ee9033306e6f2cdad9670e8385dcb59da955d8207a9dff1d810e26c30005512d002afb578b715adaac522f658c77c778e833b65c02a3f64651ecc5f94c5deddfafc9a35197a915ab2485257339d7bc26387a45fb9a6df5547f55924b78c63b03d2535717393f5c47ca0d281708e76a43756093bf330c709fb9f732299823927af273a936f2d04c24215a77d355247e46b9246f263e480e9522220b48ca2b833216198c4205ec40618dc0a58c0a205947958726b3ca1ceec2814f8a78e8ea24b40ff853dfc799b7f034f76fa4670043eef44e5267b736b69134960cc6f540a76a8f07cd9ad3ce0f04d49c256731ffe5ec63c2b2b7237878a2d1364b82ee603a95b5015f02fdf912447caea18d94e91d98a12f1c90d67a64f524115d1e7753451ff1e541a9b47a4fa0dd11d3d5dfa0167d8768733883054a44062d47f3bf73ecd86376c2107a2543bf060ed5f3679bba0b4941ba2ce299eb3a8e341d5cd6f0e7c9d9bb96a454c4555982d1975db26271b0fb142c3a63e820775af5b1c3854eaa989e80423ddb93a30856ea18b351132ef7273d6a73d659c97ae3e1d787dde5d63f21d48bda2ec29757aecd2bc5b4e0cd91dd9eb8cdc9868ef9628e31d46a60088c6389ff8771f75618f352d27c878fc65b651c4a7981be762c6c3892d6373fe71ba8b8859daec9f94e963525252bf924b5351f9d4661844715233beeeeab5590dcae3a06cedd4697382f97ccd9398bdbce3e16e8aa550db8dbf29adbbc7a4a4b3c152f1db6a66e1f395a7b081cffc860c2fdf195354bc673aebe7ba22cea19918d1c7bdfdcceb505ba654a49d04dc49d8e06a5d2880bcdecd1cba9dde5d99362542e44af58c885bb430b50582622ab2c54deac2727e773fec60e11abbd20dbee77f376208aabbafa5b533c102e0c38e76a108228a86bc05fb318456c0e07e98992b83fed9e0224e0f249a4a51a763ec52a62292f2606efe5759dfc1617df07f3d92693face3108d668587f7f7677230b82eaa628f7d9ed96106e9015c4fe56eb590ea96c85f3a04e77f1a99fc90c60c8b29b82710244de8b52ce7eb783a84a1c7b1b7bcbe753964e86ba629b743902a6d17e49c2457b99a3eb3fea3108c32a4e10d74a376dd38dc73885cf23c2cf2c05e0790e2c5b7f270554381830199a91ee633d19ad77dc98c2393b781e7159936d9bfae524120e477231baf4f3d644f0e6ff8d2d5b2184c15a9455c84d39e1004c5c4968a46da9ed6924768b0611b809c329b39305b0a28487209891890c2cd2009e98335099cfbf1a27ea907892fd75274dc59a7a60ac51b7ce9085871647793e0a1f68b8a7669725e8f1d8b285832098cebb54177c570d3adcc9be33bd2dfcb721ab2ca42b060430cb5dded651f9c88e00521a5cea08917b3ab5369923b1741fdc28286efe38c846797140af93b981e134840591b0342a0eb316505af1b88f74d9820971c5095b102b9e3f301453337924ce767a115c178592194eb9606b0ea3fe210084082d67cf16684388de5c1a5827818e1d3f170f1fe44dd830d5c84771970f4287ebe34a35ac2955c0d76346f0f61db794d0a4b84088807b9c7ccda3be57678900dd4297048852a4ec796a19caf49a19f46dcd31bfafc027f1bc392112d65791c7cbdf958349d301ed9425cc7a2fe5253e648689fa85ecb18570b8d27859699cc2b50bbebeb3a262bd36dbe9ea9fb70e6813a245c813ce4feb32385bb41424efb2a1a3419bc4ab62561d8bd2ec58194b6e6809de2da5281e5640f376b928785311563581b9abffbf1d54d23923a3701779d56d41eb3b16a095a9cf717e087b94fa5eac9427cbd9dbe6decda6373f1ef1107a1f4dd5d8bb369dde77ad191827052c35fcc5e32bdf3d83941af56048011c636db75800a6aaaa9cd1c92030a1cbfb0f9844132f10060de38af2d539711920965c92abba4b3ba8a83401d3b376c44dda6cbdb0af8dbd9bc5b6524ae794ba472eefab0157facf40f3934f65f2e1e1dbb4b44f82635940d8f9a0052b8fd6692182a3470cc7f23066944e6b87f3b2a204fc6b21a5622f79db2e536aa41ec989013f15f8f005982672e2affc7e278e032e8b6482e67180825d54ded0b66059707dfddf01c652530ba15aabb6a565d12f41196d984a654f963d8b1c50b264745ef1e58fcb1b3bd54e9219fd56e83aaad12ca557e185526836fea5900ac234a416fd6452086e757dcbc9e3b0bf498837185ff2b02184935b70443985f260dc1c7d03f0588fb58bf35d2fbe51da5e71d0cb50153b9fe498e6635b3ccd3fddbef3c0aad91f5ed8553a66901644fbd19acaf1f60f7d96788cb49db039c8f3db3d7b0b5e360b183544c8b81b7c0c0adfb85992517ef9b2c6c3a06b550f8cfad3affc97cdd00b721b7a6e0de6e784c9da6d622ce052def18b02e50a813f56b291a64a636b2e3e5d4fb8182968954239a7785a4429a33fbf338ddd730ed1a6e4b385e557efa3b56f8a17b0d6fd6aae2f4133904434842f4e610b4d92fabfa6862d69acf8d479e5fef892aa4266f291fa3461739610f744246d3a4aece6fdbbe8c75b5411d9205a9bba62117446e11a0a224eb9754de56391e16f41159a026d579ddd1fe18176b4216526086da6319768423c767f812dd854fcebb3cd7fecf5919eba90899419196181df1ef471ca6b07dc228668c4bf15012ffc9e5b233131e50f310e489cce856b0cbcf826f9b707b8cebcde9733caafc7a2edb47ab9ddb52b0568b92669f4be00f4b011be70f4d5fd0ae7a49a70f55837b0cfd13e96674d6eee35ea5d8e08c728a0e4ac5870c06fc4154f1f8920b1fe1d66065666b50c236209370e95e13b12ff68e9353f748b916b8a71e07c6c90513108ad50e534c44e8ce933e48eff16e8e318c89ec95c6c948895e8c12981b64c588dc8a3e5d5be9d64f6d74d92c52ea5c572da84feed296e33790a8b8410538e701e4a8c137e77ba6bebb7310ed8e8cef7a875260f4fd379b30bd85c23ce2e93329be137d1b95316cb59a8278c1e502b1ae664730b8de88ae6343b3dadf547276816a052d735d436bf2364e90243f94ee6c633c28818130dcb72955b3fc27e9d00556ab6db435548bf0083c1fe35f75256d948f4fc456e322c579ee827f551a0ae543ba612595f180ffdbf72e3a9dfa47b25d0123fca5f728d09929bb754abada3c1363fc29387d92af88f51c094df2289a275aef54500db18c1af3e3427bc8fad7f8b09ab2de0524626088accb2dff507bcef8bbab513f7814c08dd27bde964722326d3bb0af95ceb8d14cca602b9dbead4596762ff914a858d9c6b61e6c908c87a333e623070ce9d8bfed7e04779d337bf5ed8266abfa7eaf9cb07fd782ff02b0173adcc4a123a4d4d43a53489b75d4c4533a16723d5deb6191325b3cb46ca306b59789d258b204759ba1dfe92f8c254a360f257ba398a870b1a447f3cc2784f1f0391e233a6774e050ca7397223126b0a5f6d33a349f9e902130d68ad1631e9b8f605a00b1fa977fd77f454fc05c9f61e00f085b7af7bdcc268e7d303c8d87083b709dfe7016b6ac1ebda9446e9585277a972a8b04d8f8f24bd685ea7c5eea104286afe249c13b5246921b02d36f96f235f83d4b0b4b2ea9837359406d7936371bca1f4c5fc4aefcebc8784cf297a33229e2717bb2dde4e9e232b5411188476357dec4ef1043c84bb847d780e9a097be9062ffb3852e58e4cdff3d5be8513556fd90afc7108a71ebb86433114ca1b5de0d740fa7434431ccb19547f859a7fbc70499c5c33fe77dbf05671c2ca4eeaf5e4372ea31f1813f5da61d5c2e3fa272f41c13ba6c940c299524e19615f033b3bc55053ebccba37f64a04a33bda31805f1bf3c761ebde43f92ed104f2c70d61b1c9391150752cf3d2803ab41b6f7dccdbec6181b0f07bd2daa3e5c27f39f3a98827b2aa44f6377119f6a89dca2babfb82d943e80e59c05380241a83c2b0bca89e8dab0de88d5b065ab92da4449b043043b634847f475a23bcf9bbf6686c2b111b9ba45325615125bdecfeea62d14bc96290b8ff62008e08fabd5db2be6efd14e466d30231f8274d124419d7b6e0c7011d248e41c66e561d4ee1adc9a1ff4175f2f61f5accbeea71a88bfe010c636170ab65d16d9a9f154920289d9f7629beb9a1c8ee31d785daa10e1ec455f5f7ce01eef9edf81d46d5307d29d524ee3c6140754cbb3b800036e9316f712c03bcd13ac3bd6136b93917bf8fd17efeff4bc9166f6882aad24692b62b83ae8c61d881d5ca3d4f0db4f135a548de584f6fadd7cf01f3fc8d7755c3417a74c2dda6f4aa0bbd3de0bc750d5578c3641e1d8e7c55c7da3baa6a408d54b74af0e1ac8cbd3820b93378da72cfe14b8b4c3d8cb819a8853e80aad87731912af3b8cd5d2564b3f9edc9b6f3889da3eb7ad0dc6b2ea695357576693304ea1c90b822c1e0e21fccdfc7604a7e4a815c17970134cc868a195ed1c718a41f431c438398b0c76ba5f9ad5e8892ffa8aaf961eb413099f6f148522f8ffa10c82eedd63217d854cdb6240d388912967ee9539624c96b73084a470968de7bbb107d6f37d8b1995c1291648691deb34eb33580c35d24744131c74a50163a1f972e6add593b0bac14a87ccb804eb5d8ef1d27b05257b26033e2e0b088391a37a36f0f3400b8e0982a4340437c56703e24cb7fa2c81926b93256d02264b56c70d14cef2b51ab7c8bbb28aa791ba826b02f099da314d809acf85d16ca506a0f2d436d6cc14662416f07d80cddcea522899771081e8fbf359544dbf69487a65aaee7c04e4d35b7255ef912b9a832296307692debba09465ad4ec70f68aeefb940fc5cf422ded52325fdf2c8c0172ba1b6e07dc931293707cf3c32a6131411b791076fa58fc38d40575eb57622241e131f8abd7f2eccf7f731d8c85c7ff3031bbafa6af855bbaf650fc57639b9840e5bf9a010e1f120c6969e4724c7be46f667f9599891f4a6730595a49fd9d90db7b94978646d4aa64856058cf3614d9d68fdc4d00de640e2a2378fbc6145132f3d1b2df9d7bef30aeeaaa6d1c0eec861ad06053b089f3ad65ae9da16569a40de917d1457adef1eff7f36fb36969a4fbbfe88ae9fea850f66062c7027daf0897da36db804d398215cf992a5abcb89e6d433c51c7cd7c6515da958eb702f1f0b31f9e6efe64a6eb51a35c2c8a1a708210a30f9b9192f3fcc144649a7964fc57575e285d851efe9a08efad180a3b9fbaf9bf6dc725e32c46f4746929b2fbc33a2ec5ef2fa8def0a21005f765351328f514472b24b450d5572eb8258d58f489195c3f899e07737d3805a696e042bd13a72814ee77aa9b67a7549f93ac20c1957a47b3861a658a573726bf7027db703a88ea40c7796e8a379216fb9e7ff976f966769e5044852cdd9dc8f4f52eff8790112452e357e8eca9d9e6ccda93dba99eea7aa05f73e25b6d0c57dadabe3ecaef02e7341030dd96241f842e0a8be7a46b98efc69e322f4b4d4ae2f910f13e7821dfd1fd5c9b195b106d1172ce9bd417d30384ac47c0a8d0ccc1410df6b890d1426e649ce31e6c51beafbefc120faf93894619bdd98e390106ffc30a1855d70e5b3a64f4e0b86ff12035019e9dc2e6706d7eee30e6c56b1d67376fe75ee13e0a1f13510f9c5826cc10335c6580a7adf8e64bdd904abe2b3a31bfd130e7c742106c8ce957416363ee4341b9380844a6eb2754a6d51b875a4f399062e05a47c492f87cbf11c332063636db50ad2932e2bfbac04d74f465309684c9710a20f470b8167edc7e0491042400e222e55b9e3030c3bd87e98f4c6f61cc2ca94a473679022a707665114245f58019ff7247cbbcf62afc34969e6965d990a01c10bec996829ef8b3e7e7784a0c50a91d87ad8efcccb633effe8499bf4525adea2aeb3c635bc5fa80df665cacf5a09d47e671d1ee0aa99aa5c049ef2bcf0b036d3d8674fe84f7237330478c6391a4678f6dc010aa7f286f49cc4d32cce209f3f8f22c260510c562bec1a297e32af9599924dddf3a5d1b728abb8a5c78a199f42f1ef360d760c46939127082058a6a2d74204c61d2518769a350fb1cd104c020e020ed002f1dca3072988546c2469a7e01b9a4d24428d19d3673825522a4dab4743f7e3b06c6ef73d2602c4fbde9274ceed291ffd789675b3a3c1d9d1543ab94f6c10618ce37d42fd49b05fe9ea3977c3b4037c961bb7d75f5e26cbf3494c2c49c0468f3f48aee29460e0b293fa58556567972a6b66f7cbe0b9dad393cd96ef0ecd9b6fbbc0ea167a095be969f62ab05c13033206809b8929ac3ffbf3d4b7ee56be05eb36258f7b468323183b64adb1b4b837654d3e5cc4b65cf80b692747815deadeb7493a09f20a74a662109be5e0adac645737f8bbbcd11fe11ba9ee66c1818f2a6ea33e9bc7e6a16bc14164e11abc1397844ccd57ffb74b2d21862f518255ff33c9376a5a4e55c686ef58f8f2bbbac14dda0f077673fefe14454dc62f19d5906a34442de77306844fdd06709ef5915c1e1f54871dd06d920caa53e2490818fe38da3e80ccd7e6af63ca6a70a4c8a4d36bec4f54cb942ff1fa874eeaa21f77afcdfad2c264db2fa9a19ec1c7129b617bfaf24ca4662e62fad0be1575bb0c928329a32998f3bf33c4ca40bd3aa2d28cfa9d03c8aaf3f6ed688913e901b98e5688f035427f95d2ec764d4de5d7cc79120a5a9cc792a0154a8a2b491c823ffde8ee8ee0c35559e8f958a8337f455bc8552cbafa53a9e429c618f2116907aec69c2823fa5cb680e0c0f748f595a41b1fc1d9e802cfbf2f049914957bbe6c677e1df24103f36aea9da1999b87f9cb2fad31675d3dbf4f79de5758f2da31f6299c4e8332a4de8834ff53f42c95499c57e49a420c6c03a0aa3fde96fd1a493d3543404bdcc17b4e1f49de3a7cc7a5cb29c8289c360fdd7568ba360d888c9232053770f8f1d39510efad38313a2034982db07fe24eb463ed2bfebf13516d08b978578bec50022330fe6e1103504fb1350994456fdf366043fd86e777be5ac840915434c687d96afcc86cf501e31dc8e9c13093cffb8baf4dd45cab81e4404b78cb48cbbfd472d75249aee5396bb174282e80a779ff4b46ba1451fa8dec5b37d416a29a73886d25164b151f9b6b292d7d19f5f45ddf45906fe2893ae64a04678ba0394a21c614449e7f54f830639255561e204448d44c4a0b20dd008133881edf4b66a2a3f8598fbced2033c7fd81c2718c55ae7e81ea1a4210e81339250dafd0ae4ee240643b55b134dcc29375db8fa81f4a583645bb2a715cdd867ef53fca5098787f2059bd6b56200cdd399c4ae68f29c8be50d7e4e5a0b010b285eeb469194ac3d0ee1240c068c4c6e1666dba66f83a29b7af51eddc55a4cd2dbeeb44abc4127403e4b69ba9e6d3cd907e278bdbe781bc40964e95ddbd940eb7ccc394ee7d6d6615412fa171fa2147eecf6e103d0d106dafbde09e051d2e69753d368ced8d20d977e4e4dafb965458f3b27c3fed214e814343d000cd564801ac392c1f86fec047c271c23e2ca6db085b3905c26679c4890784e719983b38b3e260c0c2e8771d7ce66810764bfacd0997e6cef6726f21dce6ad7c1d7bd6d37d0bbc0f188a6af36ee016154bb4a3c574c67bf38a2ffffbb3110e4fa2544979622a3e00c4f86d0dd64fc9cf1c5ede73ddf1c2cc92b61224982eab2b57ba5a4e188e8ac0a8361d4d259b8caf32fcd1125dc8719564c3365a16ca0ba93e1fd46fcdba15e4e561894ac1ba71a24fed7eb0f8b2e9fb4c1a2753501368c15f6048148f91a251aaf22f5689d89556e0a3e3f377da9e90a3bbb12b933d593796a6cdf8842120da4a952b9d9f440112c7e363cb8052809e9ddd106645c26faa9838eee341d05e3a411679451db2e7f465a160c5aba045c66c2bff31fb73828279c6c472c718c62dfeb6d710630267632f1b61f82f769071575ec7b3ce4faaf4aa2fdcd252cc944d6edf6119174eb99dc6b2c74b45b0630997728922a68439b3496ccfa91c0e0ff670216710d4f45c2b544cc47aa4ad1e4f5bc57fa4e2a6963330de749e8a189494fc83594a20b9d0332cb83f91e69dfed2d2eec4433f86b137db31b2981c8a7ae9713bab3a3142ffb36a47e0cf02647f1aa2930cf3b00ad569ec388ff2e33f9d1ed6872e50f7ecb4028471d8a122d15a0f9fd6092905737761a917a28c262d2235382dcb2f07f26207b7f3b3c2df450ddcd7099cb1576988655009afb84dcea2425d13645fbf0b8fbfcebc6795c301111ee398cc628b74848080c6b3c86a8398698f66211e3d030fb4180a57fc15ea01999860e5554dca37c2b421b8b39d4e1b7c049982d00c171e70305ec8f043bb18c367772bd578971b17e43a0b08ef22eb9fc53e6ba4689255693956451de4ca33aa5a0b129aac5fdc48c4526e02196a13b2a54870c1093dc86df2165291257d725488b67e11b7dc1a45691ce4790d90b6b50be0277e16bbe9303ecf58900e8136006349cd855019b089b06be8a4dd9bdec8bb71ff12f46cad7b90d486e1dcdf97fce8b5e5dbf85962c08957bfe8f37c2e7e59ca7f01a77a7ac90f07b7f249b88a0d2f52eeec0a246cb82c39ec50a972a286879f82c3cfb05e23dd5b79bd927b31c9ecc398372d2acda132ace2136236caf30916731f5ee8e90f8508eb9810d04795ada61d482f7b1cdfcf80d97d709cc437fdc73e91614652a53c7b461052c522d15e21a668cd42e5ce86e5eba54f8dbd0b784c8905a5135eba9f70939db2785409c1814671c9284132c62aac51ca706ab1c670fb1e631d709dc70ec546ee669e893a3b2a8663dc53195bd054b1e4f2c089498931706617d4db014e153b113979fbb225c3c01456c8d49fe3ba1cf2c4f3f24deb3ec493476e8f79c8974f49e6163f524917f09fea68bdbb6aee3c9ff4fa1f23425578b1f7cba3c13eb24e23ae10b86aed7a0c3202d67ce0a849f578fbafc78470555a43d965c8a5904c4badd04f031ba75e71c47a9496e342588a123a21e56fbbcb442cb8898aba1b48f8544b7474db2fb477874b1f90d020dcd54098ee295e7b257ebadd52d08f3f1f8f16c13fe93f99e0fd48a4f1f7256e6eab71376a38dd4cd281fe84c0629ab4fd8111aa9e5a06264b0a6d2196170a4fa112415cf1f7241c77096262d3ccbf8d43cea54d18028b71af8c777dbdb8e77f07bc268a7229ce24d72b235d493545e23cf15e612d0af33253c5b0bcdb6beecd94a3e6ad383091df8779888ff4a6e34ed0259df96d853081644f6005dd6223493cbd4fc2951088b06bee4b49c5f8527bc901511add45adb18fd2f3088ef31177135cf03d132227df6e186f429b0f1b507f2ff946040b4432d405956c27d696c3f41fae7995c4e75e4c124a6a6978fb39bd956431c34414d313561936e5d35a28f3121166e9e28a8bef553cc13e7a9c84ee2213d5fbfbafbbb1cceeae70ca63b5726eb82cb656c83474c158c845e2cef08eea965813550c0c78a42c319d60d4bded5ba1f51c23a23e8f540b0be0739f919ef72e3879ea3052d5c3e6ca862a3fdfd045a665bbfc2db5247fd276b146509e0157ca109be9ea8ecf0a993a97cd60eaf584bd5b0a4bbb2f53ded82d6211416be9c70cf2362b7784a7541cdecfd1950e85a966d3ef0c0e23c307f784104a36c62acc0607eec9dbab7432513d42f8429cdccc233e41a085ba553a762c17b552b5d124f8b6047fda78da9ab40bc1dcd112ca081af517a183d9f025dc0b07444c706c47d4ad5b8e7eb97980f94f59be0184d323370f2d1256240ec64b2afb5dc86b667e8dedf45c8286f0fbf344c05705d10a21385ea646ed2c6974d7f341dd805495e0949c0973471a342dba720f1ad985c5b5705239b854cebe50612acd0fdb4f6065bd24795c7cfb6d0f35a1064a491dd31eb89668bc4c4037a28772aff5f557a3744853d2241c0e78a251d2e3d64a612a5dcad8dfc31dff534ce63ab194081872244b1d2b683b3cb9c8ca5cae1a249ad27a892bbaf1378f92bedaae2a23c2391265f6827c1ac8db91c6908cd6939803f84cc5faa05031f2bc526c69cf8edfadf3ec302df027127044f6c439bce5e643ab90bbb0751cf95eee36a57afb8a11bf910f89ac45c1acd042664b792de64a23ce6b255e167b052214f2d9e79a3766e54d0b38f7fba00c0f5c8e1a810f735fdb0241c5d21464cff1cbb8d00f51db52c63729b0558101cb59c2b87bd0ac7cfcabc655e081bd3dafc8921958955b5e267e6ecc9620b9d5955c5005f83379c7d727eafc80f271c43db015196663a46b9829578f7d1b0e1b2bb8b9101eac6fca2f39b535730509665e381ded26a6ea9dcb514127fc2ad01a1f9764350c6aa8f7d6021f9caac0f39e78eade2c08a3808e48a3bb34d68ba7c6b9363d7404f6f95635caf936ac71984b90be12cb1613c3a0e63abfefb39f674fd013eab88a1a373aaa3f9a1c24c3ac24bbd13d620adeacec2f1b557f0720cf360328d88f73dd2148f82954de507411bcab98a5db4d081a4d3be93a06c9168dabb04cdc9f887091f305a1846c848fe460f4c5bb9b54f9e2e4da5ea18d8d97a7faecd98e00046f442e82186715e664ff3f573bd04f2575bce8554a4166bd10c1240d5a586a42682251de00fccf43a3b2f87622eb6fe3303de06d114939fc5a54d19d98d23b63920a6e53622112ba01e6d1bfe628741d74f52dcf270c66e44ff21aa8a69310d728183c0d3c3079afae8ede3620a7991583b13d2e3944b71a08945fb0c3baa8a29f7a0f2fe438cdaac68a77a5e609cea72606e28a41a866c7100e4587828c8849a596e0a1039b129a1a7f706f38f8c7901eb445389c044b5120fdbb75a86a20365803474f7ce9157c457b73dd8e5c1368818d769b81fda14230537b333b2711f0f4b4801b465af07884f7d03f8d22865ad484f07aeb2258b059be143f8bc8360803966c2dd7ff48a611625c0f2bea68aba9d6e7ebb2b475d61c6b4e091e52b388494b89b1c01b7c44981ea8298aa76e41e2dfd6c811bf65da19e63895be336894a264a87adbc539d3c5facee70a287eceabfdfed79e7b7417651eb5aa700aebde882e790e4533d7ebc352886360147405523f5e26e106e1e50277eb03805f316d4e0b034a56498344d0d41585882801c39091d12ffc8f6eae9971a80c9f07ebc6c81deefea07bf60fa4da33c79243ead93780a1b21dcd9f0bb6e40968585cd8c70a9798141a0454acfab57c9eedbd1a306cec39d9be33ba785ff75908da23fdb82290c8f4bf85a895c2317ea441573e0594cf24389ce915bca6a8ffa766efe14ad76881f3eb19d773806728ab8071a80f53c63c1dab7ce6151f2e9bec85129bedb52eca46401c1c37c171c14bdd7824a68a05c4ad20c0643a65d0d2e80c1d8575e05601b9ac29ad444b8ef9a7a89824fe46ea7708803bc86986e653e8ed9bf866823d41ad2d074e132247a7049c3177ec06871d269615e40b965054958c7764192e85f9691b8bbc6ebbd22813a60e122f6766888b3919f7fe196a7743504b8e4591fe26a72b564a7976b3f4d8ed2e486a49bb1cafb0bae1fab0d5b34f35f1acb9c99a6cca100a55c6503a8883c56ce5a8b729dd6a80a8236f74191bb52db116d2039121a606fd48e05c89a6b6ff3143693413cb97591bb9266dc7d0d8752411d0c889797856195132cf503880551ac3445993345f3c3ca4be18afa59baf7662c6de1751ffaff9bd6145c7a8612572ea94f857724048c5c6513e560ae889d6d9fb32905de3ccbae23f90f83865ba1a6ec044dc9a8629045ecea600c9d81d16ca9321790c9dd79baa19d22eefddcc16990d9c31db8167b65c01a577662abc6a1caa20affa2032713b0c4705edb4253a299e9294df401903c749a171e3bfd0fabcca077d5f2e6d03c20b97e4e6072db7df9729cae0756932d48240eaf11e52a91d32bdd43a45527d577c864249f007e2328561681d21e00a64cb9f61669c3d96562274e509632aa78ffc1cb26cab97edea39b00440fb38ea6231c227e6a6c4e8481dd8957b9f117bde47cf964881a942619ec5261e6450b66af52ca534ba724bc2b79a468151d2c9b9e4fede355d60970231544cbd3587c08392877e0d3b32cf1c68b3f3d64d4ade194998ca28c53b3ede98a8a6f334499a43fad7210abc005fab38752d0bf46ce8bc43bdf46142daeae56e12ca2c3b490112db34d68307188c7f04583d54439d714bc1a5c86deb2f4c14953e2e16e271f37a35274551960011f5f810e936e882923d49f459b4665c049f53f0398b872f5d9f166d24cbb9a3b71815c40e05f9f8b24fa361659227cbca882a809b63a3d6f1e8a0c8869e81f5b9866d97c4a4301c8b5bbd2fcb1d36208333cb2a152bc81993bf229ae7d886387860c61d8a26ac39bef826869bff1350a0dba284aa88b108918d1e32ac7a4d0652fb9404076dc0ef5f21c6fa99f30491122fcf98417f00d01ce262596ba70426436a82533328ca0814eb56694ba07a3c85ceeb7970ebb706946ac202e96f689d32bf3a609f88f4c8d176a4e483f367e798b8f16dcf838831576a1c5dbae72ebd162c9bace60457530d07d2cf6ecadca1d9ad673a0970567dae5064b47a9149f05aae33da8b37c97ce74f589be789ca8420c7d4b98669190f5895caffc10d25227719f6fcf5070bfe44a22f29d2244efbae008bfdced7745431f852fa0ff31a65c2554751953840d284b3078694b14aa2149cb177d232121c5885ace32c67daf62ce44d70faa8839f4405330db1dfb982cdf0c3b9f3e8a9578e7d4d466ca8e7488360700992e7e0c0af995b3ae9c39abce414b3c309e7c637d66634b040a8674792759c23074ade29d19a0a0cda71b892a443fc924a5eb248cf53a835df6151ed88523cfb058342fb67d00168ccad50e55185eba49aeacc4bc6bec8ed399ab57a855da41a9940df7d92dab3af5e472c8e71fab89a4793e019dcc88c56a39b0f889f17f1249cefb530f5063b727022c7a634cfbd463b5dfef96a9f7416fe4504ec3fe50a5d6f0aff329a9ba39c2edbc9a62393edd5f84c676a7d9e86229a4b5991be8853cb8caf897698929f15f5a48d29b6afc0a2b24e5d26401f84ca23d568d85e9a57f0c34c895683e831425ab2682b457fd65b2144a1355a52d6578b726d399f69efbd23f60575a64b45c5bb28a3ce32ff31c6e63d49b94c006d9c315aa89e10535a0a43909d999b049851ef73f47627f1d0222fca6a2cc1991160bfe95bef08a6243fc71472f880fb7d11854e61eb2200f0d2e2180b579d0f750473596f75029f31a0f1ba6fdba2fb8854f01f7eeab2327d66e6ddc3382dc10fef829ebad3beaf84335b8d2fd7ad46c6aff5a8f1b6494d71cae0197cf1c7a195b4cfc12cd247fbb3de2e1f27d9289044d89f775bbdc4b8841a3bf8a1107bcd4e64db66836155b686c2d60d4de6b92e67f6ede0e198834bfcb83b492d50bbeace22ea6a93ed5ac1999eaddd516802e44555df2fb349bac3ae423152acad9314cd7990c9d2ee783c17052b62c2f158deca94de0f63d30f0d5dba66dd6f32940630f1791aec151aa25013b9f7ac64c0a0b57ad250a1d39b562a1bfe6782a36f8ef1a812e28a93afd5f40e0317c8d828f31c19cffaeec41631e4d81c29d987fc76f4a8989dc0a514e46853c94f7c9fa30b24c3b557e7b03910c99bf72e33fe5b3d4384ce37efd0718b40df1c4f8d4e062d4e103ef12cbc5b14b62ffea9c700a52f63df6199a0fa18eef77be4bd79c955fe36c398d7394921c6c2bf70fe5550db27bfa776914bf06d84a478d5077224e996c6163afdbbf37d7ec9b9f6673688dbce8d14ade71037774b166065bb6fd01514632da1e02ec19cf44fad364a4fa01ba8e6945ac93c4fd2109a0bb3cfad4a9ac1fda638e0cedd6694ab8820552ad60fe9c2d80db865dbfc42c24e0e766e7cde66c55e0e03749b8975ee76d824bfa13f373ce49fd1020131ecf089134568764717b2506e9dcbaf5d17bbc7b5575ad41f9a9bd2bdb0dd16d5cc2c3add64a9a00265bcf2eb4e1afc7ae2c1297e3dc6361dee6b2fe515d291ccef8b14006be1850dd125c33b2d7cb49f578e61f73551323ddd7280fcb1454cd401293779cd590ea0748d9584cff642d5b0bdceb4f8682a56403de5105e473edd7700c2ca746a46f221ad74cbd29053c562db9d63eaccdfc1f3157a820211bd0639f25fcb46688f51e74eb313cfaeca9abb9e6e2a2b2e308f86f5b351dbcd5aa834ac9f25bb487c71d7f2fbccc578d38a7d1f4e9f5b2099c098174c1406e9c5f1c2d4ac0bced7e740f33bf5d46f90d2924f412dd765b54f1c993722f14d66217ee17da8204225f2d1a3b3d8364d5c7fed11099952f383273d3cce700ebd48bac52ab131f2f09b073dc844ee0f1e8cb115f558135b45be2d11406acea266f6fe56e7170288c530918e7da1bcc60355af172bde9173e6ff7695c945a79a9a4dc7e60c6d159c8909a8808dcd1ad62126b96a2e1935104c4d9fa79a3d2c5253393063363fb9d7dc4a26f437a217950ed2a66c81c65c1f39943ad70e7b63944f8c785a56f16a88bbcf9a18aedc13a765973046ae2e9b02872c66973f6ed63cab5a1fb0ab62d1cbbc3875d9cafe8b493e45bf6150ccd04cced457fa59c23dd384ebea7cff3b1476d59cad796a7d60b247ba814e3f664fd356c7799d9df463c912caf246d48f7695a2d551c20254a823e4854ce7b85248778556907c9360a1b366e7752d773b58ca0bc4b3b3bac0a4622e50e3b5f7e261bb3c0f9517dac662a17921111acec89eca493e8c724dc5f4cbf5cb8fd4149a92fd2ef5c22e64515579be4e8caafd572f18966f8a6d0ec963eceffeaf6b8c190389cec9878d50417fefa9b5dcf608155b73be85e2de357807649466ec797b0df372e6d0b32dc502d31fc9c457dab81792655868f8e3f43f20a5903c222ad8041de4908e2dfc063600b432c683d09390b9c5ff6149b852c46ec030199f1c6ee853b17aca3ed8a947a15a864034d94819b222fcf0ccf1826d91038b15a4428c81dff3b3ca4175c018bba46274758da459d3a5d3fa7b08aaf8bb1fb019f15db459d486a369131922566cc355ed8e477d6ea322450ac7e82d44296d98ab8dc87364208c93eea3ceb5e21181cd74e8cc65e3c111d0af42e7cc66772da3926f0bcf369efd77f82cfa541990a13afb706281ab50aa23fecbcf89667519d5e20b8cf1213f1b0db01cad7e0eb6489451305b8d2598cd7b617c8f9103313617211b1c1dc6752c906635e75ddfc0018f0d7db6ec18fd39deb8a82e2f1c0f81044173ed3db304b94c67766c223f3a57a356bfdfe1ea416eda76fef17eb8840a63f864bae385b36a9b8620a28bcb9ec1e2aac44f793483d5e3f8271fae608d3706063c152347b524f3919b7a8f98034fba46a0ff43d0e29e25097a9120540ff18feeac52ec74512913aea646c9d39a79f67eb28e92ef08de98f12a58ba236476c0c09d00c5114fd381ff42d1f3c1c4eb3006784ce22ca5a7f3c6d5c548d733c4796e289c150661f5af7aa341c4f24364f2489c739a7dab117a0b6818231846c2e344d83c34d5c0b46ce53da9ee090a4e971f4a4ae174771151b0e9fd0297a5d68ff53b416793e6912148d4574af645bc323bc06b0a0974b480d2b85511d6a9aaa0ab4cf350ef517108fc638e7fbe6ed08f0e908dcf23670e529d709b33deecfabb96265e32790ddd5abc238e0ec21251a78f8c39c6ef6c3bc956e16aa0aa3f82c6904d50c90c0a7c074180374a16574a9fe59e737588aa9ac8464066238a9994bb97410290d5b5c0bf4b5545a90c57da5c1f2234713095a96e9bd5509b8260f2f74412ebdd2dc39e045570007cc97a61e419a66e37b72cd5432939fd5eac3e8627b2eccf005e1c7052a12555f1ff8bb9af09fe20c33223378f794ec18f92d56705eb1415cbaac570977cfd445bc46a7884c41ec191b5ffac7fd8251422095a3883d75a27a66a314096bc83a7662a432c61134a33650d16acde5b1dde38b31c65263d8906992d1a47f780ed26b7a79dd6961226d3fa003cde86b8bd917f7b9f82d916ee0e06e6259b3d7031c4c9df1c042ef274080e4e722b3290f55dfe4ea677b517c088c152befaad7e0c60f687a84c0f553bd22a74f70ae5f4e0654b707efc0c37e662f6f1fdfc9a330f463454962358e2c1b552d7593866cee77c74e53e4b63ea150431fdb3e76f553cffd0ed33ba43829e0735674ad643da787292398f592d449f8ee5f1b316af3fc735a0454be8cd2386dc0bfcc1a1731c83450fba314223e8d1c8d6c42e69252b424259a4b9767f839586e43e2fb0f9eb2befa7ec57383f1b68c24f4d72c9fa655d1bd12fcb8c4d1809611397d4d7c695c13aae153929631c47a7e1002929fb28fed99a5edae3d945777b7d44a91f5e3ce8da8cd27596eb3e99dc46913125a74669779386902ae9d796e34a15a06906ea604db871e475b0f0b25d181fc583397b20dab5200af63e299ae70599f714741962835fe98ad5e9346799a9dd292cff59d76d6ff05a73990d993bd5372760c0ae332eb13fbfc183568d064664fccccd329f60bcd0e68ce3353de7d49107ff401e8e3ba0730218551748fa32753e33883a8140ee8789f486194bcaa8418354e8491d1e54125ee12a1207db4815f07a53b427512aee1de5bde1ba6ff630e8a9c29e105b730499cf24656c4de8418caf80272dc72a4ac607f8fdf05d7b5dc4fbae66cedad1b1255a32ab6c63f6bcabf66aa898608eb80dc88f6c6b401a14c61a8b6dd95a8fe7acf16db13bf8f93e2af240c2ace2bb5c96b1de52f4423b28f5ac8e3723ca78f7efcfb12f233e8f17355c9e8cc22923b367eaa2169185d2bb9e1851b7b2c038b9ec302960e3af6e6b2af71fd3c4f84e639ded821395352e3427fb015deed324361cf2a87d78642517ae20f2e181027258ac5aba9588eced7860608bf96c3753ace696f88ed5279b7c9a685e954facf83a501be12f3659917468ebd842f7a003ef36862ecaa0cdc9d414b6c3fb9b1a01847284f3b2ad340ce25f9ea944c868513612b880296da4674a844ac79616fe24af5db12a19156e40b2d0e43a62273324baea4860ff0ed730d684e466e3dd8db4e7520f4f7b1f24a5a47217c1ffaa07c31f27979d22ca5663b101bf0278f231b6d52bf3ea188f6cd4fc64b3745b253572d4a2efd906f7e2800d19466f670916e515cbce0c30598e217dd34666b3d11ad10595fc38315da41bd01ae97714b31052b26dab56a8d5e4c58246a71051e503602c211c2252c8d98ef9cc1057d60f8715c872e0ffa795d42f11748a1d6f17507b1af0d5058f6439e50be8306e342288bd719c7e881963e11d697728b72e32570734d4bc0866bb4f8a82a82bfb159056006bd5d7feea31c04a367dd86b335df05cc4d6f4ef4b5a00d3cc634021e61ddbe4f151d38ddd62d9ea4b06468cbbdebf39065576e27b2a91c771d9e6952e95d05db09750ce8583e6fbb7df50919649eea9acdb6d0f575f1d079db7b5b3bd53a353443ffeb8dc4fa0ce740465efba9e14772c3c2ae0cc48d74215507cf12dd2487d6b273c67aac0afb494b1f13711c1653ea07ef2ef19cca2f7bff45fb280c10f6700bad2fd614fb8b2758330472e440a6fb5fbaf45ca93cfee4f3e94e2941ca7ced43bdcf6bf5f804b4028800963a8a1e78158b2d8bcfa343b071c253e5b1e1ffe0161211f5bb5b8e8e496ea4caec0bee63749bac82a49d2acc59bc5f8163db1d0f84a9be87c8ffba63120b4a90dbefa8d84ef6e7a9f32737d9b37235b9b3b95f1a4e568431ef70b086a56f52747dde67587983e8f93af3b60a274ff6d4cfd2834e7d148314f9e439462d4249455bbd59604d247ff52c85f965853a08d13df7dcafdc6d6bed230650623cf6a4cb94bd5edb28e05022312b7a423fddd02d53e8ff1f79eecfc79e8ddf4d449525a859ba86ceea208c21e1bc6569ea6f68d6be1e397528a9a1c90eaed8d71e1714576fe78c3a79ff58ae8d2e26d6c11ba68ffce084d700cc086b0c4ed16d874ae43db0cfaab63ea056b8b6f3dde422eb276be1a90393dc440b24a412c4699e4dfb168aa35cbaa79fb7889331fdae0e4a38cc16df24d5db75b395d839b6c368969c057ed7f0e4a38ecf6090c15a71ad16b3a695d70177e0f9a8781b454e0f4d8b3f1aa212fdd2297f2349ca037b1ac8414cc22f32a30c12796d27d673a5e498abcf15206d123bb1a04fd89381ee8a4dffd9f6067c2aee5d8daf6ee60ddeb2fa4799c8b5fe4a1cb9ec5391f45ff2a4cf86848813271ad5f0b6656a1c7e488207cbe47f32bd8ac241e3191926a2bc030464fd04a1d035f5bd60a39abc3c215bb7918293ffaa8d454f5745eb183c1e1645572045d0d7b42dfdf45907fe8931dde753c94a93551df16c4ba266edf4646311c69f801344c10ca901783e91f8dc13d61cc9fefda307b626dec1017b19a7f48abb9eb3b2fb7ce4026d183413c865b9a8d3b4955ef5b05c8c469838ccfee237f6785af0494a071e09bab3909a0f72ebe653c4316c8f5bb3b5e02d4ca0549c353f96459947b73c4c075d85c52eb81bcafc151134f15c7e5b394ab53dea47e19c74b236ea702c2b3d072097534c47159aba672f824afcc42ab68e98864f75e1fc46b48ca95c6c746e5797240e6579adc9d4348653e91d934d4c644fefaaab807e8c9a6a54f5d818d60ba648c55cacbba7625fa7a9d432257a2278108f8b7e8f93bfdc6c9bfd8964e67a1227b20c1abfb261a82afd236ba88cdfcaaf6eb3a8935c7e5b7a8f86b3f810bf2a0432c0e2ba252f28cd968504e4d5311d3c81993e4af90ce19270785c2bd23979fcd9b9e798cf1357d782bce84d3f4a6c2da5e8b04d93cd31bdaa0e65377b0b894eb1ac751d51b3a50b0b1c9ca4285d7e3629ff9e89b5cdac762f59ddf6869dba686c41bfb5949ba59f29107c688c267f0be06f79666e397c4604bcab214219282dd79527abb2bdc10176964dce895facaf2681f4d6cde35556916e834af5ef991d39b95c857bec866da2be1b05ec4c121c61ae4ab18bc2cb32f5fb2a148c518b61623042a5915f7c90bf2e66e9a730585159244ffe05702c1565c31259eab73ed83c75ab6252358cc121a19f7f92d59c269d48502852aaf3586b7a3b3fbd5de2a83073e636ceebfb8cf163fccfc30963676f2eca33cfd4cafea7a66c729bc0c402680b16beb6e7f49627d790fd321b8e122123e96b8272195f9125bbfeb42599ff01915c9978f19c16f2f1bfb219626eccaf24dc2c8bb0256e95a45f852812ccd9904fd67baeb4be6b48bdf93c96b6ddd55664f7b525dbc433e628ddc550d3e7e8d30164ecb9420291bfd6c9f1d4f56b1a58caa62d08e69b582e8977b502f608167a584586958db56c88ef35b7c2809b27a370304160e6efea64f2f99ec1cf62badd7783c2e3ef2442df4e6cc9ebbb2d1f2825470a5b9606bdf963cd0464f5d31917792b94d4a383c5194cc217b3907ff694ec6c24ecd416ff9d2f5f3f81c38aeb76e95861bb496494efd602d37fedf594f37b251c7c22c9f6fe7ed71145d8b9a2764810231666c1148fef0c07d8417aa31fbdf8a1412648f6e2cc1faff3975c69708ae9b555e195fc8e2cc259a003071f5351452b4c2ae1f43a6839e97da80bfffc998aa5ee880504d3364549e22b44001908e3eab19d346be5f6e3840275e1eda9d1f1fc18891584084c88838bb7338acd6a954be690f65411ee93ebfeae6ec7d68290e52cf9f40376be2b319228ee1174324e56f9393f7a6a1ab9b53ec6be5bec72351fb951d5f67673ac4dcb026f5112ce3fae63736b627a1c55c74e736c1ccd58c79a47eb522c2364e266894f7197f1e0bf0c0e3c8d92f3e6e1f85532c61d5262cfc143896db54f1ecf5dcb1d5c661ebff96676376cf9ee408886bac00268e4b0d3349dcf10404d44bc025cfb3e543ff77027302816ab7d45a6bfe8a2858ac6d6810a91c42c2b860baaa6c480de3d64c55325807aff4d53e6a5b0e49e33a36e5ea9d97a555ed564bd0dfc5dc5d01ebf9b9d4380bcb3dbb76523c10d40d74b65440618aed227e8b837e0e01be5a92050a209e2091f169761dc6380a056951f7a78db971f6fb9a1286afcebe98438b36e33d589a1fa315a52b41b1a107471cac2605d2e16c5495f19ddcdd78f45d2bfc15d5280c1479b9d552e852d4671e2d4c553eccc304efee9e0294f241e53b049a9634a292c235fdb46dec60035e8769d661f1f97cfec6348ff7c588ad4d95b0d543b30636251842fda2aaa4aedb88932a4839dbf5462771697173e1a4d8a2af1bb0f2347f5b81b583bcfa10c968506fe00b6ca35c1d93da658d0be1f781acb588cc0c0f62de1e076795d20373a353e7575de3f6ee85ded6a9a9142259ec2e1ad855ec861717a6a3660b63e125d73cb3e249a16d0d55ea57067d768b02ec0b4af49b18c2dd9d5ea341193b2a4ab2f8780a27903910530b7e2e233e7919bd5e85b9cb43628b66980d66aff1493ee1b8d478b81400ac28b7ee27dccb7e2e1c54d820d14d8f1135016e10bd978319530503c41a947d04d0bca3023dc9708abdaba55afb54dc5e0c8d4838d5751c1cf27bf14365e5d1782b1d36baa2fd65b2162fb8bf62df28a0fb221ac5f7ea81534017976cb02eb2e3060c9e39aa77148ad2ccbde2047209fe51631ca8daba5175580113be568a91de461e54784ba8704d10fe3ff868285f6a89d2567940d64e58aab6548915a9ba89ddf16aef9f21236426415520f90448a0e15c12e5a281985664e006fbd13d84eb46c3ab7896cf92132877af98ed7e7351cf1a44e51538b66f1778e00d0c52504627ae2d1e45a6b3e6e59ad1447f32371acc7224dc03bd82ce6fa63101c1564b45fe3afddc0819142a4c11731d4326a8f65d09cb9335e8b7a85ef0f90969ac6d995623ab1efbc8b0d9e264f4cd6164b6fc16b7658249104ba862f01bae561dfaf221889448c77bffebaf780f44fd7a8c3b59a94acef7b2e1ceada3a7ce06c79cdde081b82183476994523ef593bdfb960a8836e005b1785471ed318d5d72e432f189a7f00e40acc8d85a17c631c4cdb369ef0ad50fb366c7101422454901149fd721c7f261a20ee8097ea4918677133e5fed05fba06fbd5dbc211f830a6f03f95be3cd37b6437a92e257a61f06955240edab4b44e465d39f18e7035aa329d9fa3148f6f28241e48be115274de0b328ed75652516e19a8d8783d52889eed5c8d55c70e5ae4e33bc2640f79a62416f7e140d9062f0ebefc579deeedbb91b26696ed7a9413dac9093aaedc766b46f2c70339744c0c885bcca3bfa03edf8f44683a454661903d7f94cb0899d872a9bc78fd9d72476dd89f6127504e8379a068014605dd9ac09939ffaa6a39aea4b74c1581901c3e2c6c1955532810bfcebbf247fd9e95c6a81650fe922da70f2e945b5d3bc561199adfd918741e163934742d43165094520a3a0d5c83797c949db54241f6bdbce82e51586fd8cd04fd74c5187083bb830e9ce43b77cfd8a2d90ff7e3698b14765cca29fcf047cd6c5946bc58400ee10aafd28d44bf7ccf51006cf22cb0a6416a4c847c3386c9cd9c62cce75097c17d9f4b39008e3af18f0c2db0b54fa4588997320d607af3b95b056d2ec7d54e241f6be059183b03f226470b4e253b0779f704ac9ee34249323cc2963ba511b14373b8cd35484dc6f1b84c45979d1551d99506fb7b813f70bea0a23c1f94b6018e9fc5564ee1a946afaad90e3aa57c2b47467e8702312ca463ab3683257b5bf37ca8e7243d677ed823cf9d9acdc214f55eea7b584a7ad4f4f6fcfdd08f68ee301034a2c3dc6c06e5c1f483a26ec784412ec38a9f562dbfc4c347d05179997ad31731b62301bec36c036c2de46b205055a6320d2bd69e9a4c8220fe73cbe91cee4e2d3118c0d7cf7d486189a1020224adde4843f5738c3e169e87756a429ee505466436da49f10bbf0524d11e2b7d137827c7fb95b70adb84cce46aac81ba92911dd1918651179beb42b57b2375d2ee16ec827ac9751eb647f36ea4763855827e10cd249a051c404e6937ec7ff4935aa06552d2f5d0e3abe95e3a8b46569cf8adce04e37d985def4b6219b8823d688b601dedcb9ec9647f454967925f4f7bd973a7ce65f558a522d705176381718093543f6a76ee5e81ec09b02a5a4871154218842b13ae5aa143fbd86858555b13ffb0bc46a9343f8b553b7bab314d47860259b2fc74baaebacf561cbdb9dc9b6f15593e1d13600877d9b1f3ed3ffc0e9ad4e77e38a40c2c4aae992ad45577e676746ae779eb8b18c599978947a9aa3c7050e69f279bfcc76d900827dab98b4d94e4b3e773016dee83f9edea147cec0f3a0c6f6ff5d8c67e001800fcd7d9009f7f3335def6abe5190ea9076aac0c1e3887080ef61c000acc76f16ba9d53dc5d05f9ca70be61375bc65640bb4c6addf88d28644c57c004db3a1024de387fa497d1ec4f454836bc4994f6476d7d75f93be40ac06a21bed77589a4e3b00a3fd0470fe98bb15c4e91ab88fa4989a1227e052c3de3cffe7d454285835df372d5fec41c774cec27dcbe790e94b132210353161119f4348fcd41391b34376316a7a000618b9b35c942f3cd1c5b460e755f8369b28be6cfb3122ca4ad7de51e2398ac105b3bd26b2945e50aa9fcf49ff3371624d48317a940df7ef2f62b457bc0466b48dd450957264f1fcb19bda70b0b5e06c73987328474d2ae0a5bbfe822c8fc5e1c9e639a210f2554053eab3c7599e03cfdcee58a189a4b15d955c5b5e694e2357b22427a5740e64bcced75e16a9ac9049616471066f6e7b09f30e278d9118eea607fe2e287fda0f37cbabad79219e9e5f25aca1ecd160d9ecd76512451a4a3c635f4e96695b72ca1c76ba64dff1acebd8ee5e60db4e8a2df329f0e6d08dba9ba740b9dcdba1c0ccf83349958c1b82bd3e89ac1cd00e25aa6fd4e7430b9a1aeb9050bd28a54aa35bfee0286197e8d535603a25afbb6108bc92905f6fe76e9562bf8e500d2170cc0f83a127d26db23885d3468d590229c326f53d3137ec6ccf12d9a1174b5ee1084f8142bcf24cf8bd5a6c86ecc6fd11a9f015cb2e43b1239c2a07348a9f9f84d66f182a8ddfc9c5834cc7084cb178a05cfcd1ad572865a00545755f96ecda89747309d8b41b4b6950bac4c9d34e3409a094eeeb1403490c7fdad62a95033a6dd7dd39f6e50b8d7ac0d804763a6c65dc763e93b3bd5c349b5cb1de15a2269ec92af634f9d01e2031bf28703fb9263580e2dccd83e6a60ecaead2c7b5a7e317fbcaa5a8506dd3e60a439cb3c1f58b407bc3900ce53ca555edbe1bcd61b3446e91e03ee527088098c2880ebbf69302168fa9c6a4b1f1b49b0f1bf7b2ef61719b9207af64b63a77429646833c3b6242bda29c934eeef3fe05207f363b8077c54f8dac053d202aeac2dd91d52d6351cf2d7d28d9a4327e48ce70c13fb05bf4106b7b09c1afe6b2b14cf1701c48deaa5ed14f35a8a8a1b843c28548fd60de382e8774ec079ce861fae85f53108eec364a0c1177013d7271f8c33240151b750a5b6c30b2d10af35ca9f375ea29c1e24439b2a67d61ac072e1b480ae4edb6a98bc99a591e01a3e19c329a131c08e97ec7738be0af7d219a16efd91b39ee8b3f79aec3affba1364f1b8362d309e8d04cf7e7d342bb362c6f7e9d9402d13bf65f3eaa4efaadcc34d6d593a380669f861a2dc7bda0420c41a20ac4ab4370efd9d6b1cad5ca1f2e33e1c83408de9396dd7ce6c2eb86d54c387db958e4fcb15b185f8e8ba70fb6d56f0b44a110bc42b5ed63265ff8757ad4cd604ce917e3028a1efff72b477633b644113a79905f8f1192bfa383eeec556b213dd6a9b4908d835775a067eb9db539b5506ecd2f38d476e9337871d04338bd379a70bc3a24f254b4b45c22fe193664e8d9a106e9e6ac86d7dd408712561c727830599ac12ee3fc2a713ddd9e443943a80f22928d94e34b8227e3c91bfde0263011fa8c71f2019f33bc7cdc1ee194d4e2d75a683f984294d5ac67fcca5ac7e40e5f9eb309f193654bb1d2bd858e7821285c4eb4f66d844b00309d2deef37f3da896d52859caeb75743203df0e0a2206315a141dfffcdb5ef69d7506cd9ad060f566c778c86a9f3cb2b4b65ca641e7015704c374782ecf65ee224fd09e291d58d119fabfcf89e51f901cf0a172368076177263dad6d35d6ae34e9b1e0f0d5d137c8c4d787b78b4579aaab17846afbaf095a0d3ae60ddaeaf144a9643bf9e471a1bb82c30ef3f7c44e1f7a24c2ebb01701503b816b1e0bd438419003cc54fc18336ca3726e00f961e7a02cad8e903632583a3de253aefc27d7bf3098a27a3d34c38cde80917fdc241ff49a9c969f0fbcdecd2b53abdbc4e4803a4e98b64f8b947f3e0f4eff30f54a90cfc54f55497f89f036ab882d315553b6c01c536eb25cda219036cdfe4a2d56ac33051ab86818ebc9d99f11a67a69f17c870e7c2a1e35776c467d93af110581e49374b468d3c9d3c354bfac13910632a6f7a73c260059edfef61e6ae33b4af2c46f2ff992bbdde386911129b5d51f07c7d6e02507285a0eefadb413e583446ed6944e10fd891d1a17aa83514b97abc794f19e47e1a5f68132a60ce7821255756e28c4c453ee5c656d006559b8ab638dd0a88f0fa0b39e2c626b158eae4f4b1c3e73364c6bb50beae74fd0a71df9e345e14dd1dd2efdf94e27bf258530a2b5b012f47de10e27ef990956878911de4c47699344cb6e190bc791961804c92f6a6587a265a62fa9d714e04f0245e7943e81b0799f9a1f313950dd59b158c8c0ca7d707400ff67da298a8b757076e81cd64ff9207d0aea9a6dca5e57b61229fd6056c1bdde63d9b5910d5496017ab947c972cb1843f197cb6d9ad677daea885f1a8b381fe5253b54b41d978370baf651b306e9f4096e0596b6d75dab79c8c89fbb49605497454e26efb4ba67822237c7b13f0dbcb482f1f02fddca266cc570fb3ccd7f80161a26da98a665abd20c1b5fbddfda85b5cbb25f73b02880121120d65a5c8af1b9ffd5424e951bcbdd975be5ec0938e1e259bb10021bb38e51ea38aab4a3a0452234ecb6df9c71c01f10f9df1b0b4d7a0ca9e81d98f4bc28b2565267cab91d356677cb76bf2736b1eafd729022b1e1341441b46db81091a5588f392864aa27e0e6921341e67f8c08c0e678ca5f6fe94b4bf372569b79298dfc79a13e32b926adca4fb10329424d403621bc7ceb2cbf39ba33a342a3cce79f06db803115a9380ff5c074d63ddad866c36842eb51b298927a007031448335cec4dc650459cb0adfebfd0a3afa4b559615245e88a4729f7cb7ffc104547b6c5df2bc3fc0838446225c016fb58e57ef13ef5fb708353c69e06aa9e51af124c9d170c299b27d8f01410ae1df5b73cfa9ac4b7d9172a3b9a28328a17af92a32ab049ada7d8edf21dbd48e82063de4a3ac144b0d17f08d450fd6a4c5285c7cbcd2d4def67f0b7490a59f3312bcc0995757865bc66219d2736cf83a2a925d9bc4d2a6328b335d05b806a8a823deae553f6f6701264c8a1a5900f0a837853f067c41e0fab778c9de61975ab60142c9fd73b15367c0b14a2e82b755a148dc88d0056657ffe49ef21cdc883f3190c35c56b9cd378dd8ef9e106967bc53571b0142cf0c0858b30edc8000da1eb699c5bfde4e9d1f2e7fc3d94a916e3c358b82c25a8fad21fc0bd258645d8600562a4298542f6d7e31e23fd6064542d3b9c06d1c67103a48febbace43eba155a7a447dd840d594e328c49283c07f222d25b512863b7e7210455ec32a1d6959a49456eea316081c41bc916028ce42a4c55a5ed2c901f1a9bd14e452f01731b4ca2df1077c1bef36c753c5da39f459a7b2b465dcfaa2e6e443a4839b5e8672a0be2b75adf2a2c8e9b7cb00c767587e741da626f7541d53fb6c61fb54aad2b047d00f65330ba24d04c37a205bbd19905779aca35764e71e56c2e38b28973cdf2ca184e36ac72686f9d64ec1505a5da11b6fc7884a142cc1946d011439e7d909e21d6a7c64a41bff550fdaff8bcc287a3df9df72cb4dfdf7209bb6a6fccc9326532f0960e35ff20bf4b449ccd9be7408a94eb91ebe5e26b09dd452734e700f9deb3b7b6984c44eb721867f81d3310548fbcf88c085c7fa62ccd388581dab4d966dcb23ae3a1090ffe66ae1030671fceca0362d503b6a8915c4b855b2023ef610cea494614fa1b6027863ee91beed489825742d53d842dbfcca98e68fd520f2dcf9f83dd1b535e7012ee6758ced513b7566c376474caa18d60a002f1778ef90965c0d180575adca068ba87eae9fa7894b43976031780192869cd4131f70f95271596edc57bf2ac526b2678313f9241552579efd7e914b3d26c2f586338a59ae2636ec47f00b1a461e515916168a3816d142b84142be7f14de6ab855b7d30b30e641974478c61d852cd8d385eee8baabe15134ac672cbe85a3a8856fd0125e6d4836c5778e482efe06c3903983f77615e8937e034d18b34aa18f34b0be510588194c122f1b6c746d00de6645eabeda5f1b762d3484463c6bf1c7c1413ff0c59da9d75102c2b95e2347f06f186864348d627a412aa78847e95ca985478f84dc3dac6681d808887319441302b8c9825b094f8cf7388ef929606f21dffdf4d96a9e93e80559d67ec9e8ccb9ee785f213f35387fc47400e25dc4d1bc83d7ed8c355e99b263096d547f5ec23ad3b9d5be03a4a7c04004d514bbb20debae908de4197b792c7fc0787ce90650160fedd90347c63a608e13bd8041931ecf79350a29161f948545f34baed613dbbded887b00b7d98b7eac890c4c5fd1f27e61dc2f2c9ba4bc0c2dc1dafc0bfb499f0e6404b342bb009d102cf71f60f2b51d4e1522a12fa33048b77f9ac9c0a008084e7cbbfd3426510a92b186174de1ec7716b99ba2b5669d52c5c8764861e047d2cfd23b8e0442a03a12613cf10fb573950c0145de4c35186a59d241fba953e8ba0fe1fd9a6bd0596ab210d4f0de5dc886b38e4ada424cc9dfc01a89226db83ab3857fff744db404effa98672a6c3dac49ee67117e4c4a19ebade5b62ec0c7d91727782732f54e21c98d09e7886f00ec42891d1a4b22a39036c05a74de4ae0f4c72d570a0ae9d2f6eb55e0e3d4e52e7fc2d3ad6862f34641623c036cd172d19af7d7dae935d72aeca5a1aa5221287630e363820d6118663d3f5ddbb67452e28c77d3243f6aba8607bcc1a7b81dcde00e3aedea562224a79607acf8c5760b61d4b801ef5f95c593460192d483528263b7667b6782fbf3da5084fd3be320f19e0d2391359f70756e24c8e48934466406c0c1446c98f591064d2963288272cbc89957e5a7ab898efb4cd3e13ac3d7c92141ccc6a6bb8f8118cf2748dfd0646aabd94c8167cf5d00cf12a8276a0d2413dd63e8e405dffb331a16392377cc820f50b66b633d612c090dbde7443a0710328ad3fb79a12f1394c3adb9da4536830e88f3e8ae60fc35211957772e7801302db2dc38d0c87d94bca5130c7e47f04210b3280aabe19c8c0dd450ba130533ef329d515b881585d3f8f9b06433187e251f437cb2046a9b21b5554fa68223d467daeb263c3666c457f373a3ccc88cc9954eb0b821b323828c58c9fb8f1d9092bbf12f8fba061e1ad08a76d281f5ce9f56f5b66c06c2389eaf746f8bbab82210dc82b374a219a4f5fece714337c4ae0441d1643020af7d3953c39527bca5adb181ee458de80929937d0581dae29ee3aad8e654c1a8ea6fbccf4a2679fc6c75bf338f69633d88fcf2d6e2b3923efb864d823efa5a2b8b86f55d233c922d87a7028047702e6a992e7aa143377799be0d4b5f36541c6e8419b765f42942480a51cd5623061ad58df4ba72403966f7e5bd95b4a0d271ca57403cb7552499e013ec7cea6cb6bc3ac16823b925d2ce9eeec1413240b5c511ac27793c4eb7c02e3533dd31accb65252de6c1869f10076c341026ab68a5089948af58650c05c077174fae17959d02a5b19eaa946692b4cda1c0ec6e6aeffaf055e210cf0224385391f69bb76da5c3db9b0cf7cdbc9d8a696931a48ce542b7484cc77c3d1cdd25e8f4a0da7335f3c57c5eb88df6e20cd1c5a5a7d023da65d43cbc6974bf2f854dd09f8ca0dcadb0220bc58d69a5781fc0a1021cb6e357c9a6cb88e4833a6c053c904d9ba29c8324da93d45720e8556d5a0a5ff01ca6e91ea81cc371d1f15dcaacc1e033f09ad0fbdbeccc69bf3fafd15758af2e47dd2842a2cafb7d742baa38858bab449676d91a5b65353ca854bb847cb35679a06ffabc7e7aa86ed70e667195f7f290867f2c4b2ba9ce90bd821e738db9ed8dfd3c8b5548c2bd0cf2c3c17d7add97e631597ef155fd8c9cfabba9b107dc27b647db41c20144533d95e3335b79a77a809afaea900e61bbe1f346875d59524fc1c427e6936d42d1303839720b103cb74f00dfcc878bcddf289ce11d081814748a23293457a38be77c46d09aa56558da1844d381bcf947a5f3de1ad42ff80356eed96975dbc22f67dbc0c7afa786a3800f7a88ff04202b3be1abccc6da3e3fb870218e013fd3e77580adbb4c9139c8caa59d323769ca02c17bc900d1a083d2ab85cf6f90242fa07e0741bd1e4f8450a477f8d87e0c7a1ecd3b453a8a6587958362d1e2150a94c10b4c34cc204f6597b5dce094566bb12df6c8c9fe5c76e0b9d6bbf3acacda43220ebebb6c9f46e586abb7ac2580a3248579f3580a39558c1171f94021aee86846a53f261ff08a62aa5e8d6c2b23605ab87360464d2e9210566b205d66d85cbd64443a541cfe42ce8c0abaf08b7262f8b0764634df90efb70306e8772d15cc630a7f98fe379913786919ee38ec021c0b753a8cec6b1be16a79eded1ec8894a1b2b28ec97690e4cbccb5d2a8c69a8550594c4bcf082770d94edd3f8e5c8ad6d5b6287481977c3607b30a8632c104a1b9f3b56400389ef633f29ffa52a400598696ed856be2f968f47033e7a80f345e1f83b7745b9feb6f433797300389cab06afb8caa6df6963dac2a18eaa46b53bd945f5d8c4f51f782909b0059e3dbfa733095b403313537fcb915632ca28efc1ee5f1190665a841ee876717edf4d257ac7e1bb6ae78459469fe5e03ea183bc15e4c4b3dce6fb65966060a9c246bcbdb1905c109156014b80d8be4ad01325ea6bd2761833b92cf66c4116d56c24a9a3545419fc7cce2d482ca2f0c5609475da49ce90486779204a184191e8cf0863f4862e32d2d09504727c2b49cba72a0162707daaf4677448ed89458558c2d2d48aa02fd8b1f9b8b64ae8dfa84d9bf23d9910d6ee1a8830ae2ec7232012748726c2698633ca1813e6372c37ae974c7e39ab5ef3f1ef451ae65539ba5fb336cb2fe3bc7f0f95f0a59efa4cde2a59409c5025c17f29455ac147f97472d79083fb6909a898a7326828856c710c3ad0414a86dc4e2860d5daa8d0ad47cac91040ccfccab201d136875825e32628c5cd2f6cbf31b3ff70e7e79c3183e6a3c7d07019ce009d8f06dbd80477492ce55d2d2c85a970813121692b589339917f8bff77a8aff019805a05cb1bfe565b024f01b3c52312379ee4f53510f4fbf631f093e62637318485e9fa67552e17f16b16387423a6678ca7a89e30e35fb1e532bfb47977769820166879c1d5c09897ae07737c25be80979f2ec46880a5f37aead6b046f3d2bab11d9f764eba2837dc7700c0d5a699149ba44b5e4c7b30620f015eb6b3f71b9b2ccdbe5c8b32d8f2cb08d2c3136cc69a101b636087139920385b58df4fb0ad1e92f29a9b60e1ed5b8554a398df40688ee4a467b637805e29d589d001de29a39575483a2c11770db1a3e39825199e0ce0135a638896c0e74c0b42eeee635dfdc36b1cf939ebec13a9d9a9c736f9349f51eecc414724ef342d16f7997560ea58f752e89a5a8a7837a61dee83620d12cef7ee44005fbf9899e4a6bc150f43146a4360772205d9c35c1d9a493bf5de49ec2cd644515631ea2233962c5404e035657517caf15df8b90d84de868c366371d11ace09e04cec6fe2ec007a15b757d4fe7d056b98a741bc05f5988e00a3f51cf2030231002c572c8e5937564137f4056b0713ac74107c70d686c202edb2e2afcfd6149323ab4bef9337deabaa104ae5cf527c8a5e2a4919f224a2e05f93f902561bc8c69136b9c88efdbd83a1fa215411899901d1b00462cb88b884be8c09b7b62b2ddb8b69e1b4ea51f4539d67af1b3e2a2d65549ee46c7dd1925349ac5339aa7274e7ef465c2ee724e743a60b032f929cf21dd65ebef253cb62f7cb0a5a2c2a4f34b62abbd7545b783ea5926ee9dd687e4a0412e938500497470c4d97b3a03bf64ab039704f212516ab943cee137411b585c630429b670c43b024190a609ff98ba812ad381d3f399c51e99f6bbc19b43d438ea9114aa6fa6465939b1499f4798aacf8b6fda2edf49eb72da66b0459811b7c989025ca4d5eaa69912f9cbdf7abddcfb67279bb9aff54467308079b30eb995f3fc9231337d54be3dde6c59e9963d6d1d8eafb68279e9ce94ae4dd48c5aa7b35ee34564f06bf2c50ca71f5f0836e76e168e14fe3aaeb59b5ae90b01a211028db9eacaecd122ec4761f68e13bca442627e2352aa0d52e4510cf96046de253a51cbed07630a78dca4bf4b07eaca0388c45c23a4d908c3f1a87044c76d24c40f6156f33e87799ccc90bc801e2167e8fa7fb376100816d5d2f08facde413b82dbd5ca367fb9ac2eb39133535735632cf774d9eb509d82440888d2f37015caad31f7c8a4ea816f7d3584cd8f6e6b76e0fef8a4e8926018c17d686f7af73c65cefcc573755c08ec5b4b19d796a7499192655366477afcc51339982aaa5992aaacfc7293ce289c5b2950526735ab1b425ac942b2e87383d7202cb663ab6cf16d702fe58797003047eefd08d60c316f295d6675fcc3abe7bec85275743d76bdf5a70a380be97fd957b1c9668202b9997ebd75120281e9826ce9a3185fcc9559474a923ac4c29052b7651a6ce9710f30a424353004e42d8f370243fbcc1d80b083064ceea8f096790015de6d0c1b348fcc5be85dd2962aae563cce0b5d2f6bad5372c50a314a4dd0bf26139127078155aea42219a5189564e8d99a48422061c264e9e37958b557fc83e7f554b8dd9be548c4e958c8dee4988b4d304a32407265f52f7dd97197d04a7eb1a405d463d1e7b8f1d00416f04318887c58b9a39d678f712ac8fec89d8325b3583748ce1ff8c51c1bfe794085581287eda9d45cada83b1f3c0d6d15081ba1babc78952f5bdc2f89322808ed77159bdbe586eb51e5ffedda1e9ee2bcde3ff410a2abb6fbfc84970d7501749e8aee2c5bb72ae5d364cb28e44585cae5be90f7f634064d48f655b6c8dd2c776fd3a41fc6c084bb0e04f0f7b91d8dca59265ea9e2d7d94c233b32050d37d23e9dd35e36c0e24efbd764966507bb373638694eac7f1faf7ac9814445957b20e9e105e715596b0346cdde5205a0caff9a78bb66c63f1ef8f52c4203f8c879920d9fedbac324ba14d2c260da6a8cd4c3353df879627b615dabcbaf59e510eb9531d8f00b2de41e0fe881a1cfb026248d79f510a90c224214dfd5a79c983b714954fd86f2a3bdb41b67d73985f246e7fb8d504e74f9fa6a1faba4cd17dff12b62658586db59053cb13ff281cad17f5682cbffccd77d75b6d478804f8c4e3bd8edca589ba6e895341ef7114cfaf46af8404249e0109209c68587b70df0bc12ac92da0b3004cab8bafd2985d68b820552c6346a44f55828f5b26b041e19c40a602263e95360e19ee89600f88e57a91c962c99c94a388fbc89c28d44e5c6450219d224cd670ff068be9cc012819a1bca25109bfa69951e3b44d0a77e41a7e3e8232d54ce9b8020c0d2c23f688a848c00f4a1188fdb9a9043b1cb4a397e8b8393b5e41aba87f17dfe4d2164b4adc635281ea924ba31ba92d0dec558210dfed3a020f3125e687d77e7f170af6a1f2854cb4b9f84c20e5877f856018a003dcfbf6d3325cea2cb6962f02fbeb194e5a1aa52a733334568cfb43d8211eb0369fcfd19b0005376b541f61890508f0025e2fbd18168e14700c0646fd3185a525a8a839c102b988687a7cf53ea2983bf756192e4f32f6f1bfe8ac4195fff0df3d5880be808e80acc35c5ee7e34af5bf4d865ba990de4740ed193b886c04d0904917a961f79030be491e936ece6c2f8f1296846716737bbefc6b6454e6e32aa4005cae6dac17e6e3bb730f07939d7d1a924520a682643c360006a1577e01922d8dfc8027baca5fd08e20c473bbb446d6a5bf45f14c5273df8ac28f6262a2cf29304f5b68e59c3f4173b24cdb00680ecedb5e4a3d2334e9234b91b5be3e8f4724e5fe31047e78b8362623ff590949f7fb853afb70122b75b3e586ed961ab744fb9fd3de4fbc1734f7cc2f39620ef00ecc6ebe47f4f82eee77a1360abe831dd07742bb849c0d099f1ccf64b6e1bc8c20b8d031b65159c29b8ee49f12f3f2a446f728ab81a07f09d759aceef9d2cb3374b449763d7c43bce067049fa672e49aa2eb361be77576cb9dde3b63426f7866b2e8a0d1bc563d4213aa96b987991e3ce3f469c3441116fb39c0b950e71aea653c84e902c2419a42774ebe01f30f6686a73a3327aa1418fd71c525c10cc3eb648441325166dc92dc507d1122c78cd6194ec50f8648187f8e83820e88ae5057bf65f781e071ec3991cf7afc8fbe52bd34ba4d907691108da28c221e55f511beb04eb1cc16c387bcfac82dc77012d1a2a53e41347dc44730febfe2fd34d0929ad5b4ecc3522bf595a2f94bb6973a97510d3cdb7bd82501836e0250c6a51e8d38a0700fd22423e966b5c51a5a1b2d960cd81d245b8ad320aa030e4e9ea372eb49777109f874940248bb58f97ac92dd43135f3c3df1bc2854d7bfdac928a500de0efea03ab1d4d8afc93759b8c4e7fc5c5d6ea5a23abe343ea3741da4519fe5f9283f645e67c01aaa855e6da8f24321e13e3c7dd6613da0a1c12db662c2294aed6c7e285ea6e29f651530bfa5167759ac456589bb4713754dc61f20ac6f9700133d89476183df0543e825f47d0339568252c75e2d6728027bd2b4cd7dad04b903a35334c113d86dedf0a1e8501560efde8880eac643ac5b5216aba1965fd78eee9b3af5b771d2fba66a4b2823ee299e563861ecf87a38d77e4e1b75b1dc3b7c816745a25e38c35aa54b1d7940426700876100777071b392d3af44958f0e54e2619badebfb1012357ef6284f6edece5997b83473cdd68be9fff27743d398350435fd6b90a22b4cbfa3fc0f57ee51570d49474e1ca979130054723f32aa10e38b386586e61fbd782cf10300ed50e6392898100f81ec25553f958bee0b488f23036b2b61593adc2c3647218ca617cf2cd7eb570b067787bed1e2b716eb30297b5c44e164e43f580d99383a17c827bb75edd66dcce3144b5c24aa0bfde353148e6afe59df9ae462e696c63fa3cd0c32b15f6824cba2c5f7336bab100f77f586e7656d4325217127e2742d54c1e40a678ec80b4d19a4523a7c1f0e2c82206a99746a68d19f3241a9b0fbc02d0f70016c4ae6f9e15b9d359d117a8502bdcaa0b402f7c13da01b9283a4f7d84826871dee681b39bd8914cfe68afa848ce6567d57b873d01e893da164e1bbcdba21745ce603ed2dffbce4ec97bde484ccfa19033dcea486d61b8d1a5eba9b04b8e735dee70e86bb8647bea04458bf5659115b4f2dc6361c9c7e17d76447700c1f34fd07f61534f41c25a566c175d5892e16da6303fc3b46e2dd76eb990a18ca9af9b3760c53ea5936d8709b5eb1b5df741144c1b1b4a6ff1b625e063737f4b42d0f72c1c270beae6bb84b43ac51b3d0343fc0d14fbecfe12191131f38cd69233848070cb6f369550cbc36208094672025a466237a4bf20cba18ef731c465fa74b057669a20fca416cd0851838042a820781c2728ff3afa0046ee0d85800c57a5d04760e56a06379cfe65eed72039c4d4502558594a88bc4cea3e75555f00bfc29b7f053e819da2315f63e41b9692143becd14d4c8026e400e589a15105fa63adbae8389de86792b845374eed0205f60fb9ce705367924a5079fa2a3bfa78f9344bc03982816af6d5befa5adb42fc1c437e62b3ac4fddc04e1603e7b0ef7c55d453cf6731f4e8d7b0734460c6a85f7a5f1b231239dfaac3ba3b4bfe5c907c6a624a81660efb44aea1f8125b32f237454f526bdf0e7dd0ac8eb610a291eba1afff7e9d1ff17a2c0338e7de1fcbdfaef4f14e7870a28385433d1d81906ba2bc8566725cc39ecf7ec2680c66ddc93f2e26bfa82bd9ac8f04a0abc9d7a8773a8dfe95f9d5cea3bb771e807d391138a070e04d3417fe89e3b8f65365dce1f4864ef3c881f0b6691ba16838b3e69b92670f540b03562826dc92b02f4994b18d2708d2987e619ccac694408660ee4106bfb5f6ce645ee38b2240bea942d3b4f8dc9d3fa6f34f92827e189405cf146af15a2d655cdf420e9484b80ace4a27b4685a3dd99e5fecf6867dd17ecc6e9a6f2926629c79901e916ad5cbc2698c6fd8146664dcac6e6f91953b34593944d71c8152ded0841abac57e4a358dccba946362dd5c776755d83ff64c40de78489e5c3922af7769845c48c5b5bd1dfc4b7f0466bf9760d0b4ab17313278db13f9f978497e6e3242306fced4048064bb66e29955f4e85ec0bb9799ab0af865629e8ee6c389190923f6a15e424b2bc478dc1339e188ba7de6b2106642e21e0e31641a5a88e9ba270a75c43b3eb4a1aa80527e2691c2590a7f591365f701024b243654d838016ff74734cb0f559522d0f89e021c9cf517aa067aa1d5c15f000952ae9c80ece58533f15bcf8e5c59f65a99a116de416dda164d79b80dee2cdc79b24f8cf199cd28c4df96aac79b7431675d1d6581a09a5c78d2e8c5b603c86ee61efb16e76f7c15e00c320cf4b8122f91aa3a9082ed2ebb180d2a05c64509590ef7cc783900ab1bfaf544d5c571c40a8568104b5c51afaa749c9a46558e538eb29afc04254ff436ccf1525bd81d07425ef0b692e3992bdf888edb60e48f048e1d3e026b364c7e16323299d55f573e9533f59a055b07328746f03ad205f5f08781e5eaa32a24430670485aff84b4b097c4e974b9e912018f0cac0e01b3cc2325bc92e3bef008c3180b41f9b6e89d48ec97887a194402a72c6221aecb112bab656d3d3f76caf3c0d78c3a168f4e506f0cda79683552c65f852e46672499e5be0ddbadac6028d25365e8350d8ba68d1b5fb1a94eb112edf0d769f2e747de4ec31864e686a5cf0b2a9078d22026552e2392bc048118e37d3471753b1d39cc7a8cc8a0d1ddff9bdde7b8854305d8f5701dd191c718da751f42e9dc97ca0296972164818f5e1aece9cbfbdcdf29742ab8607e6c2db2dc8eaa9067705a178595ca23cc3b0058b22a6fd20c62002a781d9b82c9560ae24747517c995bd55ce99a8574f1f4b3a0551798133846e46b4c0711b998f5113bbc05609c8ece92229079cf6f3272e738d0a85558c20a5cc246781f80a20cbd1b5d524218cf65fde89f46dbf18caa3a70d71b4753d8564b1bf52deaef3f79392287135db9c2f7f10f168b1a6a69ab9edda7d97ec2be1f2d31c53418fc7aa4cd38a667c47d599ed91a79e97d9e94c9189577ba9ab08284143e6af3052f13048ca7f1aba8fca396474518302984c3a41667c89e7b56891ff96239dba70d565f4bce806faa492978b88033b674e0be4449a971cb7969617c2a6bacbffe9d089d28a873761aeea42e8128c9d8019bc6a7dd9df7b1c5f3cf934518dd88d3f46c1ff6eadd04c13564ad781dfb2d11ddf14c2f6d64141a3f23a614520db89b29a954d3a3086c03a50c49a362239f85c30cb00d7d7df4a321622010083dbaa0b7d70ea872622255a144a76b31826cff21e9dee779617818203bbe46e45540478ee249aaeb90357edcf78dbc0df1f61e4a03c48ecca82c40bfc5466eca3b8a0444d637e70b29904b24d70a65baefeaaea9580a26fba0b550a8702ef84b6eceb8210476fab43eb5c4048576a7e0b522ee30ee0caf3d372e863141a8bb85cc7eddffacbe38bfc120e9b9cd6cd1752dd53d01afdb7c91fcb10a905b98e2ad39654384a4f6a04babc9350869af7bf95179e932d180a48d4fcf26c063c4af15c9b4fb3d018b18be5aad507e8d30afffaa9abcbcf971b91fb424d6dcac8ce772e89396ef3cd1e634d32169264b9b3365ef409800a84a1dab8accd44ddc3c223d40a130342fbfae768bd30dcb503c480b488d784ec0ddcd8659fb8a12c584631a339cd73b99226b1e94a2859406edf14eaad36c09a05572f7350df3a5bf8e7765f286444cc67647b10ea05c05a3c380722dd8fbb97623a09b14de6fcb7d4a803255cc9cdf8b031265b42073723b25b722347a42a52bd2a3b67f5db29ea6411c9d04c9e130e8b2e43c70c1d4604980e5e704e705295d5b9906efb1e6500e355c397e5bea63e7716fa1296b92a3dbd39f5fa08de79290c67274fe794e595d08a5138099c5ec8d848431c41ef66da71e6dcadc047cecde82ff9419430482e6ee9af350b66f34677e1babc03dfa58c094bbe0475ca65b894b0f8d5b3c8bcbd4424c6d93407c3be00618e46e6764fb55fe755c2596849f45cd460e3473e87909fcbbb4d42ee4a0c83e54615878065d150b1996952fbb04834161a6a28f30e6a0bc204f6e4a820acf4f2717b97ff83243c51c87f7cf7dacf325157f28090f6c0dec0d7623f4e73beabcb6ab45ee01e27886e73c5a4fd29071021cc08501df672adec40926cb95fc0e558c66733f656c41f0cd784cf3d72edabd21e7aec647128d57942f5f793a1b441a323ba054a00e5edf40fccb1a9a0b786e477037bad04e5f360b5a561306b5c43db62ddd5b8b31e633803ea37f725bf4817514878be81ef6c23dc7ea0346eb0d4f1849039e2059ff6b608cdfe72cf90390ee6ff34371751e69fd9569a145f01c0c0b505db663d94a0beaaf2d9a2f76dc97fe87651359ca8cdf67d6bad5c7d0636c34233f87622665eb70c704eb838250af659b4484b3af4cf7e1b312acceaa74c5e80aae2b0c10ab0dfca3a1ad30ae3311fadcae4c6ef4060c95516d53fdb8179b9dfad7e4f3ca41b196542a913f87d19ae9020c547a4e437b71c7c676ce7f41927b765c7a8ff5daac4861a9e7d50cdbfca05c7dfa5c904cf9c45150c690c17ed1c7fc149fcfd3069afbdee51aa87ccc712a444f827c3b0e776741de609220098bc85c9a691c2cfe90e72384c4ba6a8f6292d982d0a8dc4032f475b880ad2bb23ec5ae315277b7cc08d3138ce7c7958b5dad1966d545e1de8eff4ad7b085aa279fe76d1deaf50f405689f8348e8690b95c6ca34fc003f67248ad3fabc4da2f8ecebdd04df62a9ecd8979b11e2b6248ec5a626b9f272ccef83e874ab3c6b737fae1ac12d0a192ed8d811730ef75380bf9e1cf057ba3ca6779b944e915fa3d40859b761d6e5fbaccaab112b6a94ff465318120d3093363df1424b1df07e24dd41689db5390884335c7a763983fd30d16b52aa793412e5fe7812a176a46513829ebbcf9075a3c7f95c722f3c8829c999060ec2c01a9e2f1798ecb63ad8d5652bbc178155aef518f90444b8812b411536d33200d402f366421071fed77a038d199fa4ac6cb8d6f4470ba5a5740b25a15bcf4876a52ea09b69048b0e93bf17f0e5e56d3e09622e4195bacf413cc3e6d9ddedfed024ca8944034fe2874438ae36a86de4cbf7857bdb5ca9fe3824ef4d80cd21a71882766535723c68093fbf59638ae85bdc7ca64f77af35f4559d9053eb2362b901d80541e5dcacce344f471cbed5978bc183edd0cca745764ee925a71aa49d4dcd9f96fb0437d60cc307d5ef8ec2b11100a0153717e716cd9fc3792b99db21a3b99008c765777cdda8cb5841a894faec47a3ed51e3b218467b99a7772f6dab9b02cd96ae2f347b404b48dd70c1cebf01fdc9de012e8ee5b2c2221155660f313c727e3d0a681fe9f9c3518251a186b3974fc01bbcd26772e7146e0a43d9e87d308144730cc81df30d365308af18241ddbe401e50b4ab8723deab1d1f45834db460716a936e3f1c94a32c544c4cc14745d0f569d0db828c211c17400cfdd565cf07b78f5e19db5a2bc2b5cb4c1d13ec092976a3ff24a9d5d455ade036f4ad1dbc2c62e4ab9f39bd739fce0834c153c0b5014cf2381e9bc16be05445221feb75af99fc1953b0eb5abd778e5d4fd98a8c454d3d2ec933150b6e5fe410469379a3ff280833c3eabae117016c7b7e07c0d3bbf5107dc95c611b327d9f32f7d4603e5ae24f26667d3ca1a259eb150f6d93232954469cb0af0c9fb75fc1de5c88fff02559897bdb3e08660d8f193e1b36ce22e3d3172820788cf94c5315af1695e4fc2afdbcc4cf1d4acd0b0e038ff810f654704969425b63948f28f3f99a3b18631b3ac1100754500c9c0990bf60b3c0545279aa2e40cd30fc20950968b9ea9d8ef74de4060fea7f73d13c1d9a22eb5131f7c9280ef643253000f0a0dc36989629796faa310a162db70851d7dc9602f6e8c30e72b039b37b915b1c2ad9fd94283861c5b8a459595edc7f3e20644dbe56f6fb172db68bc5ce2257601925996f6ccba217fc8ec08b578757d0c8cb71c82262df975f9539eaf28688554cfb9027ab7083f88b8c3aa090649f7da599f01a7ac9d4313ac87da51be45c8cc735483db22a7bdbbcafcd42de4000a4f3adae96854bd1cd5edf46af81badcc7f9255afd6a9b81d04a6d64390fdd5adb3c8ebb3cfa168f32636d3f46dbff43b056033445ec4bc2471d8c6aef6fe3b7211d6636a5815ad78d8b1f5a10f3ae70afb5ed7cd19ba127bb3171a0df6cd0f26b7dd1ddc74c678db9e0b5fbd4f8fd2c0849c10d5e464f8daa0112cc97c4fae01b8894afc06ceb25f8fc4552632e3b454c3fc600e4bc3aef6b3cc98a7497ead696d4775d3e88006e7aa1c7b13d278e02862977773125bae868a9809b26ed131beefebf7fe677aebc04c8ba68ddd00b19e0e24ea69af6b1564678e7f07d5f219709f688e38c376b47ebbc7878014382c95f876ff19ccf0b92eb0a13d0eb8c57ac29f8ffc23b1fdae979f61513dced5a7e6550d9de0ca7489c17040b42528bd253457e8f7acd9dc9d6083e9edd172cacea2dfa9a95739b320a3d38310a18782338af093c7935772183959a981a500ce9f53530177c8610bc5b3aef050850eecccd9dc414c633ec798d8f3ec3a61893e3f15f17604fcbdc22995f4c701404843acbc4c3462ef107a42548bdab24ab24eb6a9ffe82c457b17abab42e7024e95db1011b854cfa64779accd3cdb60db3684f9fa468d1151fd22e9235439f993a8f81e435b582f78d08d37ba8693e28e6186d0ae93dd53c25a8cec1a8db64dfc0905e622b5f48fc58bb5bb59ce6b1a98953c79893794f0dbdd0a3fe274f5dbc8941887b70724afe6cc4d9642dba8666bc93c205d88b8cd8885b8a15c314bb2e8f9ce3555da790d06dd0d63e05a1473d2058a882d5ebb4ddd84344b9b147c858c3a6e0d79798746b97ad1e9615c35678ce7a27c0097a379c8c195d7360ffcb9262f5df4927250619153330bdad318735321e0e28c934a940a562d545a37bf24fe05ea07f318cf0a048df7b54618aafc7ef8228f9bb8a828af1219111a479ae57cbb604a850489ec7a41462fc8689bef5fc7d32b76ef31e538f7a5227b1c33fd6ea4718de39033910afcb5379262def1e27a30d4312542d665bd82bc833a818076e7e7d28a5b68894e3e26d7078aac7efa13eb39fccb99d1f24ec2d0c745de8b1502b09daec869c22cfb69d901ca1f2ad1291870d357ea240d48ae9c2889a657d0432eed397ef740ce1dc24577ec5a8fca646db539c172d9317e690de9736910144ee5dc0ae932b2efff275b9e2142abe702d0d78707ac1e12776226cc16aa54c19a6c225bb79384c8f367db237dc3a53955330b7aa905aeb4ed95d3ada82f7a73f3b6e3945dec7a2bbe0baf4578af4bac43c74d742db2397450a1d1e902e6fcdff9a89f88907eeb2f17152c756e21bb97c576b3c49c8338ab41a595ef224eb9f3a0ff2216cc1f1da72b8889a42078043768b632db03d8a0d517f85e95ac7ed4a5af86c3dfd16d74dd1cc6498a32dec157cfa2cc07f49564b15da8dc1765b473d2419f5b8c201363ab7db7a5f4ab62e7542e6f2ad10239c06e52cf1037b772a5d14616c071821b4ba6d8c642be77a14db5d1230a5f48eeae5167b35b8c31341ee9034baa3e8258c85528abbd14e8fbb89493ac14c5e3c0153ec5bad80804abaa298ea55060eed511ae5f02d48831615f546837f73373d67788c52d7786869179c3535d276d595e65b4e1bb36cfeaa62eeed3e2d9379ebb450d75c97879b30a9f5e928f83d39c0faf1e07534f308f7155ac70bc8d348dc019011a22401ba792738fdea51a6851ffdef39ed9816401add0f46c0f0c416e657324a8d598da257fb0109f0c983557ef9eae65d2b5010395ff4e0703215df0d6c3054c8ee37813106c079139c31b51125a2892db2faebe4d80c719895bbdca7addc4e3d4cffefc0f57374302f06126e0c89e4e2906043d0cd75c8b9c9c92348c185b80b38d9e8d04deb79942b35d82fa727a34d0b96ff2cea12dd9cfdf436bc8bec3ea27a1ac18ef0f6d4bd315b45421d918d6dfbe5b2fa65ab7972b178a322b90801b66c113149d6c4164d0bf884e3739c1384dfda9ae8cea92e95c343f4cbb72dec2ea6d0b9a88fcdfc32fd62369561e1753ad94d30ad08ec20934b9fa03679f0ec25d2364ea4854789da784345ef42ed294bf6c064309d3d2c47269c7a4f0dda0b1445a6fe49265e8f9e46ddb2d17eb3e5ac85c3f3ea5a1c6fdeaf75601eba12b5a85b96490c93f8232127c159a994c107bbbf3ae43fdac0429edc819edc51af73bb82629961e228679adcbf4ab7f7b56bf362bae7dffb242d206248ac3ea8850084b9e87c642815351afaa522c5b0803644c8f277e675db915116fcbe0e869c32673fd3e92a6e2451101e64a2bc05e3f991da5a0b886c0c1238f4c7725b24dd631f027c38f4aaf2c6643dfdd7cc961fe03459afe059dba5bc35cb71376e76611769e3333f81f604fcee4248c35ad649e3a1187b81fc1b502cfac75363d35280579d983d12bf9a5f91d88869b3361f1244d8fcd6829598ea4b2577dcbe7bf80bf71aefe3d290a6f9dfcbadffa944f0f9a3a655f962423a084f179234d66a0899ec7dec5cd1af9ebb265fc12673b1bfc4c777cf41d7bcd3b539f6231fead70b6b79bb21d9fc77ef6a02913ef88507488586c7c7cda781f07c8e6d1385f37e8da1a3f9b6b731f977b226ab4f840bdfc8a91f614550bccb1099c8587c12981889710b9a576ecb241cbcf217a523bb23c1b26e6180f7e0b3768d64d212a158c59ff1345bd538539d2efac99293d3321a786988068ccb02d5410fda349568a5cb688afd1bda7820cd16ee0f249ea0242ae316dfdab80f90f09d7e0023684347b299b9580562921aa6b15009f0a9bb911e8d6d609de9e3df0a8cb6a7675e30e76594c4528bc8c7c3575b2b3e8794577cb42d6e845a6fdecf462c106210fc7275f051e4cd42b4304f3f6dfc7690b3aba7549865bc683fcc1a45a5105b9f08cd34911cfbd423db8d6ce503e2d916e83205578b9ba94c733406c50d79508ad9472d0a291cb6505f706d5e9c2ca24b5fa5b77a1e9ea2c5f390a1cda2ac76b8adf3e8e4d387ce408e1a3b970fc7bbac9493d2961bb4dff6e44ee682b175454e133cfa74f2c679afe605351ac6e0e3d3656477fa2cb72f1bcb9f8686ed3dec9cadd1e3ede3efc1462437716dc67936f3ace31d033f92ddaeaeaf219acfda4e21e67f2fd81a75216d69e1ca7a8f1e56232d21e366b9c2008819273d944daa34ec3e0629283c1b11657f66947a4bfd6fe4cf40c12db5e3fbbc8d60deff8d99acf4997322c685a06bf3d7fdb5a5b3d0a7e92083c8716a5a2a876dd3a0181a858b9de4c4f027ea33f70113560ecf41d37f33a7fd0fa85bcfb77253a519bb645457787528fcc78181fbb2aa5552a630f1ebf5443fe984b3f5d45a0c13caf4ceb2906b11a48481eed5ee6259c73e62373451cbb5769d03760a123fd8bb01018c1cd780e1fd6b602d4326d251ff417913e3e935cac37d5cd109d95872f3cf5e7a11c73c7338f5d55300f7ee45aa757c164f985d1e5841d58337b137b7e047dee7233b0f6a1e104bd04537b99722e63f86b7fa6421186e40c4b0f8b8d51df25b9cfdb7c78a393794431e97ca8584b9fa7102e7c9f7eb0aa425cabdd49293953b90cb73a091a300e57d235ca251b0f8ffe177ae4243ba4b1b4ee085e3ab07acf5cd296deb39bae17cdd2ac65284eb35f0bb4158e33e66f80d7632156e3679b44b6d24773902e4e6d08033f7fec7d165c6b1b467c76da00623d1366828d0a2ec4b55b6197d24d6bee204763ffc5d226798b36258759e537e80adfa492e06b7a41f1c782fa2712d3fa20aee100e35001cb788486dacf0628637b320aac4de22715fd0fc6e36697b6f85184ae4fde5d2f0d419938756af3796b759c1de74983927b54fe14aa8cf9eacf98b213f02176371de3d766abbe52cc5b2f784ad158bc2413d2c77c3f0c83936de2fc1e99193ca97dcf49f1a41cf42dd2e35582eae612f662b80a92a26ce6ac44a0f1cb35354be8d3f8b5aadc95737c339615cb27f4147f504a767569379d31c8549ca862bb783c6974598fa253098726e7e5166f8ec469a8f39c0f3d37c6b8f22f4dc4f36b6c19aeaae3309a3d7d5215f99898211c08659b01b3a85c061d82c0bb079070f2ba22b31798c63cf078c0b06401e38d76e9683deb3b1719ede4dab2986af89128ec2cae9bb78a5203b229693d498676d4ad08072ae85e5810e1a84f4a2269c728175f7a5b93507ea0a62ff925758a9784104753a225bf13f0b3b19e13399ab330fea31631eb88b269e627d974851a1a782ae0e39b24dfd73540e6ade3d5ffad53d4cc22ac793cb5af2108ca68e7ef229dd0235b4a53fb47d3e4920e523c753efd162365a2cfdea5f878a74e6d28924309734ac2e591b69870aed655ab1f44a64325aa4950e13d70d6c67e2c6f1d4b04f4c6a50553a177142bd82c9b0d9bf9570a7ffc5d09e73c590ddeceef40f0c36481c52d745c8e0997a33525fe94609277f4d583d278737b790af638680fc59b525cc9b1437a1b8c155d60a11f98f16762275ac6ff71e1833caabf6228e6e9ec3421d5640b2b6b9f126bc20da2f4f1f027ddeca6de507b9ee04edc340744c2a161984c9346dc6c1c2870d816b16be8d606c722c18ceafdf0f946b19fa0bfe0aea7c0aa0fd662ce9985ec444c7a0efe1bf83f407dcc0d5924f083d197d2bb00c4c6a9fe4a7e0374736adc8efcacba8e0b274f99138593cf647fa07728402cd2c9f21e391d670bb908ada6a555fea69c78717aff7940ffd8323637ca0fd269c98e552195f89df8fa6b385b847fa9ff785de9682721abaf6625fa88e455321765598a32a5a2903231cc87418ef7e89233485655307b189f6e708173ddb450159cb2246fcf94945293772eb77eec7f8da31fb350b77ffeb3ddbcd7b74675df87659f257942d561fc8f74515e06bc32471bb5ad5420c577a153a1db90de97d5e98cac8732ad70934696542b9c6ffc491f19472826ff51c1574ad5c2996dc2ef3144a4b74743bc2bb373128767e4ad12698791bb07cafcbd048b0a94040b6b2b072681148ad82e0cb848844a672f485f685d482f3c400b73a41233aa20412a4b059a36751a1def7fd75527e760125b045eb3e103592ec68c21c8db3631ccf15911cd32a063442caf4823d2e9f68b605aa49b64eb687ae1d705a62ebb93ed221dbeaf12d4e4a0f52e30c5276db7a631bfdb528a4ddea1ebc4ba392191368d24a9c0acdc40ccfe8c6f683e7da57aab47142799dfc2551373ec599a4e635fa326ce74093b8961c71e49da43405611d1943d7846bc9b280e33870d39feb0c1a435a471229b484037627a65e2d45a43c348a5ec6bd75acff164f4002de34de5ea9d062ef6ca8a6231e32259c94d201e9b46b73994f63414274635e1dc31e1dc52e413b5afaa4efb789e447c3b592793226b6629f5b696150dfe70ed27c4674c8c46af6a23cc0a215c2848a6e83a86667d03a626a4b79d1894526f977026b0bfd2ca00e06f66274819cd7ce731b1676d91fdf0d91f7c9c2b700521b42a92de500b64f1b734d8808d89f98e419a32871cc86cc2d5c0369a980d47173ccf0cea9e8094b29b110fe7d0d9c113f06506b86603f71d53e34ad127b167079c571c2014b746353f5f8fa19f5c8b0441aa5960ebdf9e05fedbbe31326ed24d95a2c49e7c1349b3755483e4eebeb53cfd4f98f8749e2905d20906da83dc6865ae64cbd8ec4df62656092d60a6299ffb60caff8dc74e10a8069783a60eb8897233869217f8ea19cc6f0a53b3fa198666a4849741bf1585010cbbe69c6cd467bbc61033f536350daa0e6ec3f397fa9a04144879cbbea89624978f097e320eda28810ee5e21d715e07909dd5299cc70a42b91c9af36d58e5aabeca4b3c122478c9a2fc2aa3234511ecc644e7d06147ebf192661217c844ae3227f07a7fcda1ab4fd3b3a9cd3790acab70192d5a1aa2b8c35d413aaa7a942ada3fcb391ff8465791f2e70f4e8928d755b96cd4ab386283d1ec5ccdaf93c961ca8e4481ad8a93da0979a1f2e59c3c3a42d0b85e9cab27051812dcaf42808d97a90de444ea4464825568520ea5b350bd8d8c9c5479e89791f716f8db0f5b8e6e2696927d4ee0c8eab6cb68ee768112f59621f7e984c55440b2c46a76d98a47b3705e6cdd82127e7194c8809794337dcb7ee315f1702404bcf2fce005f5b0cf82be85b637e65fb59bf83e98720ec707fdae1b2687e66cb2d943e2f74fcce7052bc9b049380cbe143d10fae56148afd70350ed5c3803d7197b9590866c5d51b8b24db6035e3b061841ae70369a79cc316fd44987f6d8859845bc653636b8f59d718c5b124ced373e33ca15f0952eb2a3726df5f320e971df66f0d9ab5d84f13d81ca20296e518bac05fc382139c53d9fad929be908af23a4f74ee8c10a79f41d19d21df49bca53312102773908f37c82c97df31ad2163edf8b54079a25e70fd2196fee59e06db2d07c40ba50253fe44591aff4ca4affd8612769b182172ed5c723f4ae5ec9871845563bcb1da284d54a936a1b935bbfabcb1c537df61144c4e697b508baad159a1d281d71fe967376043336bdfdfa9f072c54bec635b0320a60c98c4e72254b1064a53522b3590fd7744d5c6d66255aa2d715bce63c16978f477955a90e8b0e0cf5d57444b0202f68b8386e71d235a1303dbd40fc18862357d06d725432bb7998f3e9f0fd265affc119f4bd45b3209ad0c2a6a244ddc21d2c469847eab2705ccd02fe649527007fba67d3e131c57d5d44f6421e04bb7edea01ec6bfc07b8bb8312fd5ae627f3d02cc87cd36ed7b0276fc997854fefd7f545dbb4ac555d04844eeb180504f34c9b1cb7edb5953af0a66f25866ca7eef1e80bdb768cccbbff3ebcff708f1e6bf7806f06982ae287a1122532b2465f1e13cf8bfdb824876dbdc4c1a966ed9f76bab512722b8ddee7c8892f9b55bf40ae7da66440e4633768278392a17c578c3725b37be83cf51c9f64f13b92e6ea581f204079ae00e8966545b38e8c8bcdfbec4d32d5694feb871662ef6778f658e556bdc2c5e8dc6cc189d6c050bf7ab45e39543012c015e863ca50aff19221e25a96d2bbcaa84548061cb0e0e2a3b0b838e14ab52aeaff6712dae57e63aafecc8293f10b094df8ab0f4442ef69fcc6399f3ebe613645a8ff61b8315d9b8d9843708b8fe96fa54256752291f123dfae1271b74f20c237471d3e7e106f80e710a1581a28b10a3890b38c3d5f2efc93719f473b1d25996cb498bbdbb3fd87fc4076af5523452abd588b7643c76ca59690a6bf385fee914a99ee56aa0fc0110417a2393fa9aa645d994fe45605a166d562819c6b58200c860126dc38fc77050e445918d767eebc77a9929948820fae36ee93190a192b52193cef214e34a16f94d27e6e59d0a120a285cdad6fc43d0c04b71083ed8b075a3950106ac40d756537aabbbc34ffca01475d1b63c5cc3a8ba95ff9964e21c7ef4bd4c8268cb8d8b746fcb8d5dc47a301f72abe5f7e19bc39f3b1d0132e9bd6548895fff610054804867893b71e275eede526496aa2801188822f404ee1a549115dac05d9cf432f66b40548a4c9bcf1c25416079e33e1cd2d7b9d8870aef54bd1bc6f440cce48722d73f05a1658f9491cd748243aa1ee5cf111dd013c4ab787abaaec28e2b49782b586d038d837d0e34fdea3a2d1cda39237aadc85952cfa9aa979d5cf25ddf6fb0dd1477be763e8986b056a376180faf93884d4ea9a83eb906961f8e5c655c0b4191367f88614f39169a24bbdcfc73b51b2ba8be79c65bf49a1b18e67fa6b8b6e1c1ef09a4902cd10a51ac3327728f9868d82d65e497657c44a8460452fd47728b9e2648ace3fef89ccfe8869f48ed8a5f72b1712866c30838bc78d090e10fa6aac002b4a2c55d0a9b4152449064626c94f8ce6f27d81d907e0ea266389b0da79f86fc4869b52728e622b398cdba3137d40a86c0e782672e721355f00d875e963e3e8ddb4b5eb308f5ad12172a5d24099c3bb29a120a378044d35579166b7c8e511fca757140db8e509a0eb20197e68d9f324b4277d014967610410a1fdbffa61416743d6ee9a59c152b3ea6ae193c28439f967987389e9461be81f937ad9a33b75d46afb5bc8c60768d78cf1339dd9724fbb5aad874a010b0c70e70307e3cc7e0ea8dea1e4ca3bc3987188415380f02901c3aeba6e88c38e224ab94234693f026a6535f6540214d3675979a1da549330a99a6c64d18e9e6cc42a2ade9fc59599776a370abd11002dd9919af97c67aa8c8f70eb0d0299ccb15b93acea24e27ee321cba83f3cf2336adbbc5177617bd6e35b4371655f53bf4b95059523260aef86eda2384a63bf1aabe130238aed38f306f10e558a7a5bb1d875a0e80bfa3a3a2b2f2151c106e1dd9388cf00bb994e4d7cab74149b3e81d64a355072435bdb72bdaee8cbfe0d12e91da4ec4d613fe93044b3187720bb00c1704e61ee3c2765a39b9bbf92fac2b110074a3cad7be790b372d225223668178b4f71a85485ac5370b9193874d6b7289c86d1e41cbbf0446f760604c131e57a14c9a053a4d34dda00b9cb844e2f9371c093d1f53c59f0b627005d5168cb0102bdd629fd4324b56532787ffb79296a128d4f49ed8a6ea5666f1f32e9d2f40731f839500d010de605094f229ad4667f039d6b24eb004b307088435653dd112baffbdd1e6d860f009b633f110422cf499d1a42d06cfdb0fa483528a096d5a12b74760838bd52bc88fcc868e9f7eeea8f02b762e825ed59533dbe5e46ac65e4d83043471caa13672c6b943449d01d8555cc1d01373852fe56b0b5ee987a7d676bf60cc3198b9b23d8c8cf285488c61ad2286174fdbb2981eed09a675d1cc7262644877afc84b843c4e929f36c1761bcabf2ab6e6bd866c658e9e4d16bd911e8c2386c4ab256f24c59c289c2e4357f8a7cede16f21cb2ca65ba69238f27c1919257fca139d57383f4cf7c7bba3066bea4815879204868f1cadba9e156871f46b684db9e3f108b1429bcebf41ced68cc06ab2239337b3b1ec5d9914015ef18c05d69f881fa283f598676f31907872d6e7455730f80cc7ef98ba442892ce03cdd939ea30179e175d87229e9592533e1b37bec0c63716b8739d6d1b9542ded71c686c8a4152012f76918f9e4219196cb1e0bf5ebc6032f67bc6249477a5f2c0b3707573b0e27a0b124e9f795835de1387df955c35e4774facf71015c513d7a29050cd6465519c4380b162bf0310eb99cfe7b3089fee44c63c148cbc352f48b123b30cef88056a033c7169fe64e1bf337e0af48968093fd4b16b02f9cd5e8d1679c3235b2299127b961268ca3f9711fcb1114fe19fca2cc8a03755b9a1c2f2a6725726eeec65253d2ebc48af048f2e21fd90ed4e43b722001ceea1b722814639fed77db5db174aa9c7734d8c061f12173ca668acb13f9edcfc364eb6fcc968dc2da6bfc914aa817c797fbaa0fa6b7fa0963c8c524f941773b65bb0d9852e61f80bb9d20dd34f10f63d86697848c02907b3244482391e759d825ccbcdc94ede790b5fea64778260944490404908d81a379c6ceb90ebe9deddbe7f9643dd1c3cd5e6da5cebc6b7440673f28aef1b65900227cbe009d12a8f2a9f4a7f1e0a63966f2f04b17d13bd9d01de8683edbe2a3b522f1512aee786290f9bebe297d9a5055103bd031c4f2aa19f32521ed2044eb203b0e26e3ec48b9a32b2c2d1c9d38c080b016b480a0f70e758974f0362af5b3c8e38bc17f1500ae5dac7b649c986c721239469e289a14803ee73d3aa1947bee0627610b95e54ad8317a24d9ce4eeb064b2715d9b00f375129ee20a58ebabe8583f4c3d0207616df142c2a84c5f5a04e2410e6d233ce4523e7f6259d2390c3d57e7941404202ef010b117c622c91e9d1c322e29b1f7b9c6f1ecbc3d03a889c2fec47fc6e825c06900643eaf505e2fb49bd96aa6b8645f500b177e4b2697360575c564dd4ac94db7116c71dc277e1562525b0cf1cff40cc7652b1cefa148ba706b822dccd3750a39ee414cad2a61832087343dcac150c92c56ec5f523951a0268ca81c11a3d973ea5849fff31a467e94834e3f7bc4ba455b3605137ec6a78189f9be56f5e0218c42892392073690d1d708e217d14a989e75df839fbd88341a83e9b24eba211235e5b9f6e772ae502c7be918f641ddc93dab2519dffaf8e085fce9a0b51d1e1e18589f32be27117fbd6a65b641065ea1a31f6fab857fb5feba64c9844d33d0f8a7290995242643e9afe4d09f6d71f7155f7416bfe498c66c0d5a9585c0a18248fe960be0cb4a512b6370e7a6eada0750e86fec8cf46f52fced349d2f0f8fcf0147b7f5f009cd913b136f9e1655be3c514ab6c009f260cfd3e3b8567522d6475249c8849b9ae29e5426b4f2c4d2306e9057f202a693b6e66c22529f1212f305865fea766e402c2b93f6a072ed2f8cb9f56428141c886f8100f5af698b5cd25f05dfb1f5d361955d1309b4da8a73118f5ba354b2b15934f72364f21844ef36bdc7be7c47d17869704d0ccfd1a5b4477de4f040d0c540359a5fc87d24d69580d2d67a781026f92c261b8e32c67221c976c2800abeee4eac24ea61ca651b3d17d1b62f0d49c27ba13d9dd2ea041cb9ac98b2024dcba32637991eee52ec66efa0d53b7324d5447684af99d0d5375361d84541788ac7bdaa2301317a06ea74fac76c9784b13b5b4b12dbc7b7bf4f5083ae1ebf2b6fcf5040fdf1044895f711b0d552711c15e4e03190563d8c565c27c7d1ff40f20fd8eec5c418396726daa95f9a9c0697cfe80e1961e633b283e977b98208dfeafb982c9de5553b6f7f93d833c571da7a6d29d013c4c62fb4b49716d54ebe4ae768a6a9e84de9ebe94d8a6ce4fa611be91525498c261435ab004e064a028586f23a1139feee40cbe9ed2e9165dc36663580771ca4eb84266d022289337a7225e0980a52b2c31323db7246033d23e1318300deca36ead2232740a362eb4d99f305180189a67d5057d2ffe5176258c03543e97477223236836fb5660325d551b72f74cfc47cca3655ff40661b854837211206b3e9c5ffca6ed9556faa9a055319c38648eae69b1aa2b08d4c27641e0d13a3962c250eda4defd548bb664f736bfaa169c2073b3dc4da143744b8e4bc442bd4fea4aa72387e680ac2cd948e2fc630db69acfad83429c0a14e7475d73339e41ec84730b2997ea3d8aa43aa8cccb90186a5b89e031c67b4130a12856db940dce7846ea0dc3c7f7e565111a43e26f29586bae6358668f3fd8ca0cfc4cb83433d21b59aef4dc9298a5c2c7bfe252d5b4655cb742f3ce898cd89b04b9099fc3e25fdc7c9ea4ff74819d71cbefb510901d24f46ecf83bfe24dca385a59e9a4d56992b27f57beee704d1485592cd9d15502835e1ebe4d158eb9f49552c497f8626866c5c9620880894a734c5fc8b4007f962b27e664546ac4640b3824892c6f4639843dd3b4808b485660e1ffc91a528b12b9cb3ba275c28068b9917e693401c2eabec2ab7baf833cca86c6119d4eeb9db45e6564138b61ff95bc4400b4715af9c649f0723d15df7678e1d89e95605dfa501d34fd9a0b6745bb8282bf6e5d6e746ce6c9de46cefc09b8975c6642873e8c72ea377537e7209af77a94c251b37a9e768d82b969c5979081bf3e5b8f60d5610b6b6e8f2997c408208da88891920049b653b3600b102da89b96bd24b8441d2cb523bee56a9c62df33695a8179fd0328fa8d7744834df371d704899b0a1566c38140126074e67532e1a01690d6c150536775c16cc92322115d79154f7930f59f5b56acc154dc655819bd609031149bc661cea0f27433523108754b03fe77585ff6bf3b1c1702af6bb5c139cbd96711e1045423810a1daf7ed453f62dcc8c8f454f78dc5879742bcc2ad16084bf4d5ce92beaecde9a718e295a27557853b2cab7bd94b9b0f2b4219d4fe2eb6f1e6418860ad8a35cb1a8bf685ab4f84212fe41bf93c0b1340a8055452fbac234f8a08d43558dd366927592f35be5a91f38bf928c4e5c0649fda753f0ee9bdaef5e81c612fab3f6f9c915228757446c54184824ef5622d025b62d970dc260adb38fe730c56890ef270a73ed66744dd05d6c8350df5173ae541212f3ceeee94a02ddb1a1966bf25395593225d5d4acb16766ff6ff500ace8367999e1abe21e90576954eba08f3898fd910a629d72b92dd6935874f1b226037ec2fbf6df56e9829cb1ff36631d2853ad2efca68c0bbf16c18f2e6f3344ca9bb46cbabaea84e18eb4e71df744a19b8a076b44acf11de96871850c3f42af483cb42317980d6b9c62f21c31990a044a37ffb0257122f5e04de682ef9e492d6fb22e97646bd120ce79a03c5c14623328f4a057dffbf9c5700c529b540095e6296924a12b6f803bb2f47ad620115d5a271c87b16e0053dbbdd99bd9f8ea18331d2f6ebc5ef1aa426c3930b91baeeda9516f666bf3df90d2ebe1dd02b518e96af6d139cb1546a2345200e75ccad46bb187b6833ad11316e83a06e6281f27c246d6f7842d8ce2ff1a53d8b91da3a8144760c336dbe8a0ce53f3beb90cdc8381d076aaa1275b681bafebe430460ada8700ed976e5f82a0a5b5af470c51ca2ba7e3ee19ba982aae970e5b93cfe9ed8d493b65782dcdc2450d92d8bcc97c71f0dc3d35374a015280d57f0949898f121a41b5f926070dc70779de621990cd5e3a691fc5e8a0d923e97d46539948ac5a0d3cb55290a728bec1e49d231434da59aabc7b06c66038dd4df987296567ed92da6ac37abd4bd99cab4b8d4ab43a059b8ee8b95b7801c97392f83f3b6339538d03dff137f6436644072ee0d5145dbf6ddc2205f71a4f12bcc3ef4498f3801b95d113b5159d75d3363f130d11370c9ae841452dd934ea0ca27c935c00cef67b857f624ca174dc5f32fd03aa70f4ea29a5ee4f179c32c6096e586060500ec72c0d398dba9aab05544e700c595d184eb9a1e5e2bdea97aae84f491572bf5e15c3e879384e1c4490207393bdc4bf6ac1cab605c4c1c87ab19eaa973640de8373db1d276abafa27b5cc47c6acac5ffc826b4a795f8a0b3dcb0cdaa3895a8a5a6b1481330fbfdf82bcb4ee73f401685605562be941f6a6e23d266d419996476cf8d810c07961e1c884982bd4af13a2466fe4bda19d9bafd51d670ea83684b19a0cfbee6fdbb49726fdf9cc0c81cb39e21cd3e4d4c9983463d79a9483f3f1f6060c1e0317cd32f3f5aecb721a0dfa1c011ad34f46bef452beabf2f5a1a78191464ff18f01cba355392f6f0cf17db347e4abec19fb9b8f24e12c6c171bed4cab2aa23a45d2b697af0cb003a835febb8ff1c7b1e1f823a36c35c287b293a499e4dbc6b0985b516ea47271046dcc4104c16f9840c5bb3ad32389294fcb696f9e6bd0f1a56fe8c5eff6e14837dc36fc351df6fb15eccd6bce4575f0ab702e3557982e4982631f1d75c07d1eebae67675090d206b088d6657e8207fb0dc1cda2697e826c0e2b0bcba034f17286ef42c0542c027c007c8979c8b43102626d2ba5192749eb8df2d921a7f37dd465257ac702be775baf041c1ede403c0f5834c7f04d65b8caa9ac94d9262dea6b0aaed542a58c544f2d24466e1dbc3a04fa0f327ba47556022ba6668e9115a270989d457aee96673c96a363a681804c13920fba0297dc680085e60c4124708eb1a5c045bde4debfb863e2faaaa30d4544e117b882af34fe233027acd46f2fd80f589939dade965e8defd8ca7e4a5932f2a50358c0ccde5a41d46b9b92716e0f00d47166a890411e3cc6f884ce8b71194e72de88c276c6dc234385a8a53b44f20dfbdd1a7f2717b475c9d482677c122cdbd233005343acfe044309fb9f2d345e557a4664bc764149a122bb1abb7011acf0c4ace0834aa8ff16298901f2bc3ccd0929576c4234c1895805abb162cdbfab397d75a125abd6d7fd4311c478cdc61deeb66a39f4440e2feb41504c9467a7dc377e2549501f608f51163b8eeb99f74adeaa4d163c19c5fcdba7ee2baf7542a8bbfe23ecdfa050c121615c226e2c272947b1f2568719f3dd5f3867f7b70f91e06fa0c2a3f11dee0f6bfe9c8e02677d30aa3af288c722d451e328c10bd13fae704d7688e0693d8194a58bfd4b129cf7dd1d6aef5ff012139f84b5e0d2c7a2c697255b670f6f33c2e037e49886e8b65839ca533cd77b65df5494c3556a879812631c98d506eda55bfcfe6baa4d35f4c59c6e8b5713e5df69791c546c77a404b64d28db059612a135e5cb2923f18d2a12f1db021d87314e9a6555c6e8c0d39ea727957db7ddd39b7a7de2b1d701e8a2f92f7638c4c1624f10b62eea190a70d301a7831a59cf658c887e7ce090402381d023b9b505140232c1e9cae22ab6f7335f516575774cc40c40fc456489477dbc650ab2dd01ec9fe0c43effd8deed8a7724bd83b0b2e5308f6340de1822e11aa81cf7820bc36048de231ed77d205d720bda8479d3b325aba2f8495c31d7cd840b7f8ee00075e71453b8ef125d0f219633f7a8b6a1dca97c47dd08c732c03224cbc9fb94a4ab959b28747fa3ff742a05bbc086fec0ab07ae5303829cbe2409cd2036cffc1053a57b369e352fdecb2b73341dfde92f0fa392e703654c2df0ae326401ca8af22228d47ed84391234225b3ca80d2610c1f2738f2fc3fbbf80d276b63757b4336aff9cc7a0191593f62c442a152f128aafa47fac5ea6ac1f6f8af754b73f8410870080d77429e48484b18bcc46d9a50f9c1d1f2bceff7ac630716ae2043e533225bff4200ddd7d52ea38e64ab9f3fc03ce5cd7fed3b72bdbc3d8e5dc7a97fd869e8329d5f89c4abbfacc8a1454652b61045b5c4ee86f9a66ab2f5289c875588df9b755427784e29762b9b7b9e6ff440c1dc3a29ad4d54123ccc089b9c81daabdc6e211fcf48f1e01eff76220c1d25c1f0f037d84e46e71db0e584a81f771d3fa2b234bc6087f0194aa18b68f08bb2738efca74128bc1cd8101f2e221ec674563746da6c3483da4d8eee2f4209a6f7df1cd66f96c0c5aac75d6962400ba0169597391673bd9083aa9ae5804a51fb2b6648c7e050e686536206143a213df138b73138999b660856951946b14070e7d7bccd9085a8d3f02e9774673542e59c8208b654eeb27e944b2263393884bbc4d067b094cc1f63b2494667161e09990f4eeb3410500735a0249eff6ee89ec64efb44c1a08ff6534a69c41c90123e6a6a7b558db672f1a5f97a06fa56fcb78396f40375134fb79e6d11594d7da88c8fc8564f2b6a7b48f7f81c8d02644f1df429aca60a5533aad9337bc2f5f1b2059d61657716792cea84beb61a617f4fc36851ec0602df8c61adbb0aaff11d809b4c8ac27f50d508381d5a2fc7b718adbe5284c74ee24b982d5939f446668651a8d6d513ad83cad1964ded4763957b73c9a377e47e5029c1a647a12d9efc116967dad9015a014b4beebe1afbf1d754fec2be67ace975867b26b3607e45ec714478d6569173106ea42da254d327df91342bf87f71b7b678114e5ad67abbd5b1876031c7aefb8bf93ac52cdceef08e038caaa681bd64b8106f81447d7df56cf8a607d296bc87d110b22a2584b0eb216f9c89c30c1b3fb8790c6496fb3bdbf3c296384885fac0ff627d557f882ce9cbf673361b2cd6ec313d936576876ac98425a92485f42ae584721344090d39722c0472c40d0763e3d5e4c0300154fc122dda45df2326f146fdcff2782715aa41911e2969dfda53eecf74563b4ef8f378d7285ae241a901ca61628775a106a9c40857abfe989d09af5d78993b840263b606f23487e77a646a8616c6457e09489d4434b08278ec9417b59a08adfd282cf75f660290009bb6b4e88f06f6f0d669234c483697f1278ff03a066b4f7dcb575b053542a1e4178f49ceb43b1755c9d6e2fed99d033edf0d5509044fa372b64e79c03a62c16fd2e95fb32f2d3f3b3fe016674cbd317eed3435c69561734e5a1bd8fcfb1eddaa7cc03f0940bd8685a34334dc2d1bae69ea55d3c903c647e7e8e57492736a450495c8c84474970a94ac1662f5184dac8fd0fd489599b9f1ed0a3c406000612d1860a3ea3c27de6c81a466fa4bd1758227fbcb00990a5d02721f599eb67b432e0923ab2cd9da8d506fccdc0b0e46002971dd6f394b397252763790e891c284c26820ef2710ca56e1e22c2ad8606400c1a515b5878e5a3a7c953f2deba43bb8cbaf19de09364c9e4a3165355793e3150a78bd175368af655fb6099f673324960c475795139be3323efc4b05b2207548eb241af557074f339ed0288090bcad59ae1f79c81b7a11ff70be722bca820218ef130e0f231abb7421c1d02090753674bddb91bc0b3749b01c68de01afd4e2e6c307eec29c753826922e2c88029426f0a9864edf60ed9cd87d0b8767294532f7bade9b06770b26b2e17dda7f79683ce5c6dd2c19ac4efd8a549970c73359b56f49e308f9c230ccc2c1d68720f748510fcc28021814d126d368ad6e1e7afef13f8bac81955c345ebb2838d182764be1ef57a25475d22d96b3006be563e26d6846bd8e65e37845288ed39ce6ab63d0dfe1687049cab42f1e856b69193201de15cfc39b2bce1eaa23abbf2f9d891ddda22ee22c29799bd1f8ac78b0e0caa205ab5ba233d7abaa456b2fb190e3d57b46ef810efebc32fdac6d9ffec4c69d446e20aa04253e5a4b6f4a53af28ca0543ab6f12173f060464b8670e56c5f54499969219b75dc2c58518e051858e91fcb43e20738fb81207ed5594f4dc95768607e58fe02e2b619eb04390aa42fb7017fd627949e968efa7cab1e5e6711d9a472a6a4203fe0a3afa76cabda9b8ce064bc3136313fcdcfbccc07092b7fc919d8850731f9b620befa65974869bff23a5779f203bbf86182018aaaeecfee4d4db6efbec06cdb8bb80f52b5d7be8f275eccd9e377817a70ea7e4f44caa8f97df1d1c6395fcbd02ad87de93ab8fa1b0536619bfbfb3ea62aabf9b209178350740dc91f2fee4f16682ed768f97b7ad1d25120b798324681f67e6774513f55d28a58327c662f0c2af9187cfedc0f1e05eff152a322bd45f2c79b9d58bfc6575747b0e2b32439d0bc9133584d0d5b4c1618905e5c88719f53786f9beb095cbd16799851b3dde7cb048e562713189fba653f0705a0cad21d9d6edb8728625250002fc398d21702372e2d616415cd9682627ecadd343dc9152ffa1fb4b721f03294c93c92fcd45ee52f08de4c26fa63e7f16d40c99a43e8c2e908f498eefa1c00acc1e419e649f89e7f2f46d4cde9820cc19c3ebbadc6fa136c896f54d0945feb8111aed99bc62601c083c51b2f257dd4a71cc59a78cd878eecc131be0e33838ea2ab9ab10e09d5f557969a6c34510b8f620403ce8cad8392b23f793fc31b4911d2ef5d1d78fd9b750307a6e94474aec066dff27329cc2ff8d3a6e6902beb22f4cb6a8f554ba3b86e03a12964dbc1066a064e1600080a4e209e21b819de803bd2a5ebc2e66097a8f6249bd6dab3c67e82e5427b156e7e35e65cde088621fa9f1384763a1bb579c76d834bfb9cdb2101c674f010be6b5a72516143463d46a8437fe9867637c328f19a67574bb7edea540e8ad2226bdc312a0edb40b96ace156c6dbf8860e815c86fd46a942d6a0d3fb79d189668be25e4eafcb0c557e2e340fd1cd16df91a64d2ff5be1419b20479daf3634284c0b1c56473f460fd49c322689e4e226a14bcaeb36a251a81fd830c0356f8fcd38599aeeb22b5598afa1a03d7a64f518bfa56df8bf76dc73e31df9b8642231d2358e5c17e3dbb8342f2943fca11e65cab60687221347c4881f7868a6cd8e1d098a8901c0aa3e0cee5cdc0d5372cd901e59cc7ad41e9a370a3182c10a9740c85aa7cbecde459360ef68c5ed57bb2ba81c199050c600df2347c0fabba632b1b6f2068545bbb0dc77b8f4a63e686079221051cc5bea837fe2f3fa7aae68db37c042a13643e4a91e132d1082ec15cb36ca98b458423e3728f1fed440f49c9be5d8182be8262e8ecbab1d55046b3e2c257e834e73b54249a126654be366a9ef7c364a577eaa9e1c3de5f3ba9b41ffee25e2de173799b51a9bb8aa1e0ca2403204df012ef4465a11a34023d2543fa02512fcf7da6a0f672ab2eb57f08db28310ab8aca4224ce2acc753465a8eba4e72fae5a7212dd298d530b835c96dd779cc659ae4f14d01da6d198d3d90ea7eb70866619139eb8c69fe7670fdc704fbee599b4b27c4d216ffcc7a3cda2161c4e91c4029efc4a47f816cac1f230617abb305301ac79b0b4e749c200775f0bff3284ea49e25a22429b12bfa5c60aef555c8b96b565c443af654d209264a6423bcce827eb11eeb2fd5fa363d2d937c676480843b9a4179046e2a93dc29f9e482bdc8369dc8c661d83c13ab99593e3eb4e3044f8afb169a3085770c6a8808e223ae1a1a4fe38decff90e7c851d107e36fa8cee389833c6f94e0301fe3d35c6b355b57ffa53cea221ffe15c88aad391d67cc2e45a65a5cfe670e3dda07b3c45916eb291ab9e1d6e9a0c86f79e9d840924f94c8531d96e16e6ecdfcc4db906e070856cf8d80bd4d2065f97bb930f0309b1dfc14c5747979fea625bbf9a88170984f209a4b2496d15b3c32f5b24bac3f952163dd69484b9705785541105c0a40d307ff6f41d858e6b46eaa4bf16d0947c24e13c3c42a92f40b864246d8824e3c89253748d89fda97a39f831f43336a45b94da9b9f091ab0aeda811f6e377a8248f7034b3c292e5f0eba09fc96ce928dd663cb587d70a34980cb1c572e284d69b45730c511b7d03819a06e0d3aa6d64d39d3d4649b82ca5219bee484eca05b7a9b1a25f58d3f4f7e2108e407b04485993373a75eefd06e36ceaac1114d4d6043b25415112713e452922aa8d346eee42aac4756dba65033005d213a6c04497a4a277bd1c5c1e9b68753fc69025bc59944acdd8e3c4757623bb2321a043088bda10ce90252807dab367b4126ca8645652caa11268794358cc2030ac76011c25301ef4dc3cfb0747cba4f3eb87cc123b7d24bbf47c178adf1e0c5ba53c52c984e749444d3e6fac50d854f32ee4d408efc276aba9ef3311f9281bc003bc04b06f9a7020fc13b27d7f72a6990cd8b6526a25819ea9773363d54e2ae712ced7a0920958fa5ea706a198194a392e4b9dc819dd2d6a8e43d5d306fede8812970048133028ec7a433fc605ddf51d3d3b68e1d081032f29b9a7d6e9da1d635a57a7a7bc66ede0e3724866dc75e1281ff128553370b1887b598ca55169921d74d8696250c1174d48729e511eaa4a7d7aa1a68fc0748a4e766b3d37b3962d3edd18d6d5c6d7fa768be6d38e0d49f23c5254daf2ea0003e49fcac5854859a12d63bdf40488dc4f4fb0a30c89ad719d54ced775e9e491381904f90425e6cce54b4bfbba52e737b0d916f8848ecb1d9658803258c90d7c649b0f5e2e297dd3b414b922960c6ce01f25ce1d079f281d2971b7811b8628016cf5386e495d83440c5404ade8c4b04e7fd4fc29788a9ec52757b5708733c67255209951b2c9bb23b36af1b6847de33a1a37a2104b5f5a9e6560d67d1c588e25caa3d581998a192dada2fd1a34a2304919f131190b2986353c9cfe128c0f4f259746fec180f6b640c79331f434d3a2690f34cc6ed5fefb200b00de0e3efdfeec304f40c5c0141bdf10982b2eb47f41f76f87144ddb61dce3b0a3ddbccc0e1be12b5491d3036447f35a5054eb5a5078911121e9a8e3eb2114130ec861850e0aeec19cb3bdcbf0479dbe386ff6bd611142b1cd7c1ac64d8ca49c917e73ec0570775211367ceabb3f8d154df928eb4e4cc17069953cf19d7ca8b8b84d4a37709bb8debb51e708712bc47fbd07ace40bdc9051e8f0aae7f69c4057c2b29ad13c76d18cd8c60f216dd43ce0b2983d1c90d535bdee1248bc656da0712ea44ed8a1a4fe26761be30415ae145e238830fd50d91000fafc789c2810467c5aaf659fbebbe69ba6ddefd57b9749e5b69ab1638c0133c9189393423def8ef82d7d5b2d0eba797d3fcb508b59bb06a3bb50f81e635f15ae33afd2813f15cde4d68f34bda92b9b812a0100735108c88c2a736e73c31048a6e524c1bf9753e245964bb93c5ba4b201469415ab88fb50d7bb8c859b2339058de4373375f98f2fa69c9c97ce7f79497dd535bfa88cb7907e0bc1e5430c6713a3f94694b031d35793f6cb1b4abae50f1582c510b089a112c2cdb3dd0b73308a0d8aad849345f3ef1d8955f1b97500ff11ebf22761d1fe87a613727f07e50fdb53af1d82d3e0f2b4591ed1e4db3733d05ac6507f28b14c4c6f9f8fa24181ccf7e0dff49a3914704ce18140f0a2c316aefe907bb7cb984c832a49ea1734c3f68e86274dfb2464bce351ad54f3b40be2d5afcf358fe090fe942673c5b7531d441ef7efcc780427783bcb047c59edf4d4db45df9b3d53010459758e2f978063d3094d597720e033cbce74a3cb97dbe848683855d1e3e4c7243870afe39d9505a4fe8322ff2fd1e094cef4b715dd4038518e26f0c955a69ef0e7303219eadf19caa5f9215ed285512d9afaf0be86944d15505318100c82d2b629166ff3eb9d372915f44db36dbd159238b6f924ed81af4e8024f0aaaab2494e23437f83e68521c0791b55a94ecf1718165d06a8e265d394f3a3f4852b46da677d20118e904040cf2efbc6e70324dbfcf3a970a9d0d3bf60dffe2dfc64a2f06470d84c87e3eaec63d484cc50cabb0a7188566411b6127ff25708f06857fe85ec4dd9c876c3938b12ff8b700d01a557f6c6a69b2d6b9c618219b72ae066e566b8e2578eb50ec075e9c94678aaba87a72a2ade2bfb76a110682ca44a7068b7c95441c92db8d0eab4e6ead3cbc7261b935aa1c7612d728270217f8ea98f342735cc236ae356c7fd8c7ae9b16e1cbeaf3475f52eae836c56536344d78e9742bdb67917b9cb4526dbd6e0bd4408d1d0a4463b9264a2400968fb9dbe05c06eab54697b13f927af88d72a5b6f55fc7255f091c3a1befcd30fb66d9f2543a1c5d39d4b7fefb2b2214d3bdb953e9013029d9dacae5116c509fe74943d7edde585e89b66e46d2e04452cc2bec18805b4dade4708a4ea487950c18731328fc7d0574a25446a31fd0606b71ecb2cd7a8a97e65a250f21bb649e81c0ba1929917055fff68b5e803717c2d8d737f637ed17e7e83f2196d7ec5650d6bce6b8d1e87e6904462e9c94823919289da1e25c7bd64055e92dfe1da5e586f57d2a957c7f489466268d340536c815bd5dfbab4da0bacc9086e52be316e7487e9cf347477e135ecf9a1e1759ded4dfecf040e51933fcd636588f7c1da6651a0b5aeaabeacf572f01c8803248b0880f3fd3c26dde042014eb67616d554bb57a0530f40e49378ac549f6d00607764fe4cbc70df03a9e0690edce2f75e87675de94ac46234a3da608142f51d844a6df1a24bfe2d60e949ca4dc10974b5476652df7a542cf3202de23f8796167abad1b708e13439746990cfdc903dd17fee3afde7a779a497b5a6a6fb2f1c60dda404ebfbcfd94579792fe9e9ee63f226aa68c7f53ca2d39f0d2029adbe27c2afa7bd737f8ca570521281b1e99476d5ac04f999ef8172a5e49998591084aa3c9a3a77aed438c5382c2a47e6f35d026285c4fac9877f3f9b97b0b29d08286e3ef40ff19f84ae58da923824f19607a9874ae9fc145489944e54ac336154ed8d2b0b72ae39ab76f47809b4210064a9a2ac650694ad38efafc3ef298536f254f73364a676aeb6f1211a6cca29aeb52b356c08a7dc5778a7038cef303687d92ff079f21dd3d60c03dc6fa6b48e3b73d440a50eb8f095fbdab7b8d2e579d4e89f90887b5e95a548f1167389cd8256d256b5d8a32d72e4a01d269d9660a3872b03421aa41e4fac01d033cec9029f7359b119d8c53b0707a8c45d612165af52d946452f5f03d7af4fb48c17714e60b6a48b07c4fe81d8648a3da1647c06bb20b1a92e74b9caca4c7c29eddb4ba6a669afb3ab5af07b1275d27fe66f08b18996918764f83a7505ac94d717791e363308a4d048968a61663bc4b458b815b3ff227162a334592c2d47cd113fc8aac832d5745fb39b07638ad4e8f7d6b1891ea79f17ff7a61b33928bde90e8d98d0faad04bf93d5f806d6b512cfa372b17cc92f813b16cd1d1360a2b61ae29ff952331674bac52c33627a272a93f6f25ff946ea97e4cc53656b4c89da03e703560c61bff237ac4aa694769f6dfff952fc47ec4e6036e118d74fa292d2db37c05d9b30611af0bf55b2d00ce31a5883406e6f5a74e3033bfd4b9e5cb25fd8f0cec0d2c199b7a4cb863a1c533c3724cf9f28d68e9c27cf5933bd54d8a57e587899b975e466c2d6daaa730e6af77b85b505dc2c31a63016ecc47acde46a9c7ebf82670b8bade6126fa40209c7e552f1b33cf90cb099900fb60ab2dba1c4da2c735ef9d271b59c1622e96a0628dbe25c11c403f5c0208838d0364482c9bb649561f5a722efabd14fa102cd57b0332c2e3250b48c0307b75630caec3e4019d3d0ec8480bb812020793d0df5eb7e4a3584c945eb5adbc35ccf611fb8236ceea02c3f3cffdbf88698541f3db9f9c70047a8f53e73570ee828764ce0c938e00db0231ac0791b01b619c79056a8271d3b39ba7d8a93025ab09b35eb8d73e05e8cdd3285ab5958786c39d6af32088b1864cfe956ac72ecfb7bf632defa9a371348a6fb550827432ac9bc4a4f3e241810e824cf4fda48d61d49bc4fd6cd70ac265edb6687d862507ed1a0f9befdeb5dd0b829b4407f62d73042c22af203774585b366b99990311b2febb2f5b384e1a69ec92ee167baf22f862ed002476bd752b86e1fcdc198d5825a64b92b8ffc57d9eb95823ea9ddb5b3dffdd01cfa290a843c79aedf81cdf90c19ec2b2bcf2402b132991ddd40ee63f64441938f8135cc9b9d0383a962ffcb5652177c1d90cdd02b75d55e381829f3a325af1997ddda653cef00d7aee774e79eb3dded2d9b5c2144ae4fd842567caaaeb4a27bd1dd374186efa7c3fc85630fb2841a00e4ac4b3c5256902b90f209043d73985507d0c1d0823df365c4587ab9c4960f653248a723afc925f62d0ca85f8115b3c96148bfc595922313868b596803b0df8a3ca293b172fa1fcefd846285e5463810300dcd966edb3b9dbef515d6e3a513b414f1c5066757934ea2eaf7f7335613989e925a56346281a74830b6ee80cf16a0f4ad04498b3b1b3451065917a97d52b701dd29d9e5f8000be480b89a8b98bac3b229b0b1bf8a54891c852f13164ea6eb9512d42c2838084b95548e599ac4b21176283aec74595ee3840a53ad7fbfe5aad77f445efd73ac19cfa51aace1611653ea17a7c4789e5fae66a754cce28c8ac3d4533a901dfd42ec9797374f9f81e20f77d911263af7008a941ff5dd08cc334d19e4ca61eca2e79f1dc33046c28b76073b0826691e78eeb5b0a0ac09962522291adadba4442ff92d693145b5996a1739ce18a7f2c15b5a8e178d2433bbacbe123f46a86494c29b7024bf2d8c94da6d7c0cafea213e257a18edc5bbcc35190f40ee36413c038c34f7a3b48f005ce103aa6a0c598fce72069f9f6f057a871145923b1c0bfd9c56f0eaa6b088d8d2cecb539887f19a6f4fbb5e718447828f4631561df33ca5bac93d037fa02885c331970d7094c44a504bdc42dba8fc12f05cc99448ed60a62308508a9264f40c47d9a145780177793104acb1da9d5452e903a9f3160dd77ba18e9e716aec66c62e5304ad76b6c5540c10f5687c5db04194248d2518f75491ffcf6376be0968e2fa564030d86dfa2b9a6d846a36662770a7c7d8ea300d5f79b1111e5631f6ddc62734ba7fef98788e97b7aaf8e2f9057d2f2b11a269c1d47399791313af8b1939dca939284cdd35badc58bda26e1d466ae5846068cef06244a912c8489f7b635842856a3bac5f3b5aa5e895618bf61fbf0c1915ca02010e5957cb88905d657a6815035e884a5f2895a1a70fc4fabc767a03a122036b6dad402216e3f5a9880d6c2e3807648b7aab6baacf8d2b41d565d5ed779ccf0c6b6d719ce12c7b03f5428f19b4be014a540d6733097518d4d2bbd527a73ecc894c4c5fba12faad1e833062fe27c05b4837a597d3e2ae8615107ab066b7e566d5599fe25c89a74bea9964e3641bacab83c363e37f98265aae425afcb31e155f88e18dee51fcd4f5d3bc605aa19f07736fa746a450d14edb19f345b4ac3e72d6f363929745a7e3f63e251702f181b81359e5e696ec3b9c437406d909ae2948f155dafd695dda7c165f35738391b38cf8752beb18f31a085ade99e907dad00507d246711078f8087ee966d03f5d7eb34d5e5393b7ffe38f1f0847fc041ed0b9620eec684a4b5639ad4d747e6bb6a34149f633300e210db48bb489cde5a4c89d9399c5ab32dab9807e68df42f8cab2ae03088fa8f4dc05fa584866c92f5f1d894d791cdbd5fdee963be3a4d54f7bba56e00f0af4fd1b226be1b5a194eb8af07bd9845dec18fa02f4c1b0df64de6dfafa85fdcfa14696ee140b58d38457657417166da9a4ef583e5ab75a5c0e6d195e3e67ebaf52939bff86448e59246a70fc220894f021e385e14cce10a0694cd05b29db0e4b3bbf50cc57912bc2b324f6bf06fb15cf50e8e3fd901aacb3fe4e1649a7c5622aa87abc919fa60a88a3b5b3e95231a6c777865782b1751817c893cb540ad0ce6274593d8a7b17591f1a6bd663372521eeac4d7fb77ff3d59db920f61e8531cdc4923143ff8e916b2a7475b4ca0c59f68c5b9d14f58d668499364d3455b007d17288c965dc7b292d59bf79eb13cab7cbd2c3ba2e4fb2f4aaa396fc21d2073fef1fefd632746cb77be53df4cec29085fc1f7a37625789bb2d8ca6a83a7d6b0b8c26f44c4d188e4303d7e66a50f620e0d51de5a7f6d2f084236e283c02909ff00e1ddafab7ff93826a39e36fcb3760cfb263c1a9ac748c8bfdb04fbd7ef4cc5adf8c767a65b72e62e23714745fb5dbe559109d3ace3d444f33c844c84c28fdc62bf6b26e67029aa56aa18b69c17d3e713e685d5e8327c279e4d7a5d9d86ea47b3d590a1257a014925db10f36af66db3a873bb915a51af6d222010169872413d15a141215d1e95cab14189af56e8229d8fc90bba488099245d6fc5dd3d5b3040a7a03eecc1e943980b827db0c046c418b41d545297d348ef36cd8b215be0412bc4675d8b16636f2868db9b50b043d63b3f4978981f53ea55ac91b6c57e73d3ec83bb79d2dfe5bd50950d8be5f35b36fcda3b28f8298c0d788205cec446d566ae3d3b020bab608b323717cc1d661e76d04ab8fb27eb16ae660ba43073a4846e1ae1244d64f409562cc46af3df106fa05526729231cbbafd9eec562863ca09acd60e8ef4924fbb23af5803ae304ce45072f5c44657bfe177bccb3b1a4c694d2c0fc317f96b8d23799b575a11b2ff6fae5d32e59cfad8013dc95c889936143302c1c5865ee37fc0b5f87168280171a823409999d0d7cb826cf6dd9fcf70f1799eb46cec71826b2347293a0a35f82fba72f88b59da07cc6c46b9264e16988aab7b7dbf419ed5d47803b0e5ae93db33e5f34eb47e1597a29078b01789cf53fc7d0b3881f9fdb5f2bc928a4ee174e9f3fd8442ee22ae22a29b84e2d18af9c444ba4e053c21c63f0b91e28f63cdcfeef6aca87bf09f9353571d297c01851d3e7ff41a93307859c06f0633226a7ca6cd5c40dc61fbe13228896ad8d7399ef0239abf158374e68ad0a601dbe73381eeaa8870ef012031bce00818c1cf098390750e62c9e3f5a8a5664ff384ae831d77f5f04389560503d2f61f32773c64f81b06782300f472c0e6859a793d613d07865cc2e2f6e2409779196ab1c8571459d44c886daa33acf49483c63e168d95b0e8bb37f98d3ae5cfe1350d5d9886b5120fb8111613762967970eae5668a4bd84f13ac163043f532c92be5c8c97852fab381f7a4ed0a599038ee9ac0a3c798dfb6d5d2452ee092066d1e8c50f4951ce59c7738ac4f409630dae4fc34a631088114db4cf14df058cef289e0ed46e05c46f5f22b40c86385717f06a6bc42de0532c1e3996c4d5d6f589bdbb9d904a29787f5fa8a7768dc2ef1071fd19fd2663f24d0e0b6bf6d3605b9fad851b89de6a692b70cabcb9a7e70cacd8c6c356e67d092c779107e472c91ae4317bb3b4ffa2e753d99185c37fcc52c71bf78a6d0017fd83f8945994716a21d1685a72e83f2224e2885011bf26ea1f4d6bdb64e345b0861739db9d9496d3f06a6e17ea1d02559b778a96f2c09d153c6e3a1a614801c7dc73979f7e611d1d9949a3dc533e4ae2f1de6515302d983856d6b17d6520ff2adb32094e309d782cb309783d1b358ec40b6d6be5dff62cb3e8342e17e2c370fa8485597be12b2e768aafaeed38eb602280dc6a5abaae24f809c5e5675676da64136d9e1f70c800ba1ea028d2ccb6558554ef4ae3fbe449b6b8377de66259e73b6bf0e06d0aab71b2ec62dc311875b18f3cb8cf64c9ab2a1fb3caa776816cf315449ff4bcb92c2e955d661ca8635b1b2d9690e8d51e76b344ddd3433d5fea721373fe02cf4f8a66c3a79242ba213215894e3a4f90071d78c776c80b87caad989166742d7ed2d313eba5be44724909883751e4eb1fe830bc5f45d54be21a7a53321ef07aed60d581ce12e2ad15d9fae6cbbf91aa368580d5f9a5c3d954860faeae9cbb5c9fa784a6ae86a53526635d193c44e97af3153aebf216de79c5576b0006437f57256406facc74155a4a2606a3c5413692a4c283dad40a969cbfb6a77cbef6222a7e82fa40e5523e8789bbe12ede6cf825ca42738d45115482afbfce82377ae959bd52034def57466d0234524f216dcd902eb3ecd468d523e582fcd0be699f6ec35593d4f0cdf5e9b85cf99a5d910136dcc2f7a3bf5d02fbc05ee264775eacbfa8f89e04bb0e5d0b8c2b97193f617f28ce04b0d193bf95a5b78b5056b343aa52978e9bb9984df20ae879bb302e01a53c2561c301853c9b47b092bb2f80df65e11f3ca2c1c6693e42227325673f2573565b98c5724dd6309a2a8699049ee9299b5b681eb93d839e96bcaf534f1cb1146f18c7195985e532f2b55a0f98a460ac963ac657edb808d6aeaec1f554dcf531b6ac33229dfbe22cf63a5003bc78c66077073a51afda86beb67dc0155cfa3c652ad46468b01c885551b44fd135db85ffc1fdfe8dc93bf04522b3eabff3bb4940665727a7d8fad11d2566dd84d58c8076ceb75c3837dd69c29b689e03ef3b15e4a699710eaca8185c4de748246173d873edaf1f6159d23dc2b538a61e5340d40a2c37ba79b35bda21a013cc8888a9be91230c0851e5281af73e1e07f0b517ee3a533d5f51775bb95e006c1d1cb24edf9aec587956853efb8fb917d05f8a581a74108d35427003dee658b90f0f3423e2fde689a2165cf0d504a9f2b6bcfd2d3d2475d941ad330e727d9184abeee6c20a9915b857da40fa2126d61055f8373f9d84351afc4e424c0c29b2c258b8451293c539387a70d601805a682f99abc0fb9aec193abf22f4eb5ebd00b6a1c79c8728e5daa126bbda5fe426c834d0bb9a39f2e7bc0853031b316b5e89ef8ba95771744eb8b4d53b7e4853fa22e1745584f798d1d582d91cba717df29e1c09176f0b93b8fc5926dd2ee04962319c44cd044dbde98cb08192f3551307c4f475c353effdaa70ff0db8b99756a0cca92acc4059ca92bfb6ff8317f3e5ef52727654be3106b3f0fa937a923f5595cb315dbb95a578c9cbe2f96a634c085ea398ed444391a85eb8bb5c3d4e647fbd6b4b6f11e36ecf15388086a787f9a33887cbd4e1ffdcf8e7d543e6f9d0c52ef437d2fb367e1fcd547f92ea799f8f6fc32a08ae26d94e34696d522a884c19f8170c010e2f0677099eb47cbb60bdbdda73255de479c408f616ef575fd034cdcd894e23ee7a830f2e695b07b828c10c2e36910386eeb0611356620fc91b4805bb7fe6b6ec8b61c72a70ec2ce8eb2b9f8911cad295b018d2a762e92b25e024893cb2352ae6e994ea206373dc9e58182379e0669d658268b9e049ccf4745154d9e907de5dd3c79f27b87fd6a65d1c36b1b67455e797489beb7c778f59cf2d978babed0fd2ef6a5fdb62810400f66abb0a5b6d5cce04c2677c39ae3f84891548fc94bc2d0a9f47ae05499fe6127dd9017b84aa83bed3026f692491136164ca720d0fbdbb8aaaf2393177dbe2581bfcd4b9ded8eb7148ed6d2f89c80b285a076027b8162156092fa3a06c1c3ebe6df03d67f1e843ce0ae8e855177f347468195b1982e9f554f227ce3edff1ed2942559e7f0490fa46ec91e09f800bf85c248234f97347f34cf75086bdaf65391ba2672736392c749f05da23ccee44476927b85671175aa238afaecd0a209da7cfd923504af2837f52be5cf50ba9ca79e055be7543ee273e7028c70875ad7780cf66da2499234a17ef9ce1f1523ce0b7f9d4729da7d6f456f09dadb49dedef207b21943a72c4d6c12c8d0646a78b6f89192f36986d0916908461fb83b4d33b06a303107e8808133ed1a84af79a8a7a9494d65938c5d505423b727bec38a405b59e7328ed0f6f0bfe80355978faa9462d2eec995fdeee4cd052aa72faabd9fa10f3dfb2c7fdcf36c38aec042a5f7ad1971c7173abf72eca0eec2df947fd0fb8a80110f3868e0d3b841d8e3c8b10b0e082edf80b62c7a27ae6178981836f305188032b65c44981404945359c6d7e775f31a71b56e09bdca878d9863fc24197a1bb1e5e51276fa4bc1a085683f64921943ed6af68951945ff6fd4035df6279337f1e63fb7142e48a97fbe683295d937c31d4eef7487f7e340919e449d0800d51675b5846f2b8955539988617360f795ead6bd393450f9d5d9436cd5c6835166ae5416663e54c322cf2b184a7b8a354b7bb6c244c066938453e7c952e637496d22deca066aff242a32cc7983ec24839c46c449f9d8fd437cc7e0aac5b73c4d4ef80500fd60a0a320c73598a2cccdec123b60a3822ddd0aafa3171d6824a62dc9c3afc3174e17dd3adacf0b8148c708a02c46a94836cf24340a0d4abbb0fe5fc9eb9c674da8349d78c9936944ccbf2b55793ee8f3d446cd6441ea6165dbea5492a11f9c0e3490257c4cedd248a5beb6631e7c7b6302089e048a655d71327201876b653eae6e51b506eb56d81e282a74811eba0ce04aea5fe150dec01498de185619c8f42c1f45c211c4efb5818799b065914374b5b03b0717fb40f7cd81a5eef276f7406b194600edfba4c6c3ad05dd3c61483dad1b7cba172dd8f8417a4337a25e261ecff0c11c0e0d1e31292e272e301f0f8d7d44c7d9797fb34282b76f58cab41369c7dd0bec38b3af2b3e19fc5f03686fbd741cdaa8181ac3eccae299a50e5bad034ca64d60744d7474df3533cb6c425f720daced2316f34aaa7aab30936cc0b0ac270f83e60af7de2f376405176f8f5b62c853f169f9ba21646da2e17712c8de2cdd1b11a068e3fe4483124f877da4c712a63a814631effdd0743176777b9c8d0cddd00f91623c65b087a0963800a42b77dafd0253b5c24c59f1af25f85320d90ae9f7d8a0e2d8278800af66960ac10ec3b73ea2e8b07267695fd9b481997b28a52971d8d556eb27a111c567267641a29af07b32cd8b067d3c475b724766b00000ce4c9f6b1c582edb1d63cb4ea639d7bd768318f4ce7c413ddd0f5b4230de851253fa05bced6c57f690fd4a4c2856f39e657fcae36e96c82e246343e6c17057b5ac6682cbe420b1ed856951ecd7a50c2c34d32f787e453afad70a75fe0d795895c960ab1747014c7ae5726996c06a563893d8dda55c75bd7670e8f4dd1d25d204f35099248e5e9f13285f263044bad3c05273c4d5ba0964d111e2c3bd757a46a4bcd545b762d1343bd19dc5f7d2688f13b796c48778f44b9fe41f39b4d26c1a4de36f7a19e54b3bc3d659e25c69e95b3e244adcf2c466f0e57773529d221e95689d3675d46ee8b8bb36bbbdf4f5e0aa6e33e960b1e184541961cb946ca162da43e38909453ae2811b5d30e608d40c6eddd925c50989b95d60b48fd75db8edc9be9a7cbb59491b5d1ed24602279eebfcba4853f5209da119e5a6e210570b5be4fe45d6bd03796417a97568efe118b97f9bee7f65c82103215fb58ab0b394cd38d80a8896d5204704a07ae2e46d66f2220e5578d1e3a00e32bb96ca514a9af8d8083d335f55b46daca21edb8ea4df901a8875550790acf5c663440cf8a77ebbb24a5e24264b051a4dfdfd09a127e6397544923c0dbf277c5a15f82da181edf8b78121c4396119f05f5cfdfcc3478b6e6118079a9d092cb80130231eeb45c726083eb627a8e21b3c8399288c26bcbc23a1eb608d3d4b2005075391feafbb7d968dac561d1f9e836039a5f90cf310c2e9c402bcce802bad4a2b2f3cb24d6f3ea2b122885139b53a088727dd15c22548f6d0d522c8fd13a3cbcd574889d1c9d8179a111c60172b36ad9c3cc4986acc29bbe524ff1c7f264a38c65d3eedc1a84f37316704404353adf90013d79fcdcf46228a68005135f8dbe63df7da8fd563a95a322abb18424816d937955104386929b44b6f107f5b9b0eadb79b08497fe974e46ef198b3b5605947fb4afeea617c4ff1172e6aecd88ea1da1e801df86b4363f4d5f8824fa55a558231f77718564b6b9d75055fa2728ff67f56ad655ca40f772ba60b882bb602651f8c2ef11bf761be059056936ee06d4021509edd0f0d07ba65033de05068eaf3be8d1ed536f48a70271af00ce2b72f3f2db86d3d7d10cab1bc79622e4e7f24d27dc4f5b0444ea94c6562f2eed46270a384f3c6e388a40327ef32621741829702cd832b6c70d2d1e933996b8f3dbf56c8debb674fdf641fed79bc86b4708ac6cb5a5e890f8635e074ee9cf9ab7a4f58ebadbc0f1b42885c395e2ed0615ea2cfa564e4f0fd675091428af89829715388b73782dc5068908789b7ea5e973fe55b438e9d36b0263f68d79a20a525d9a68a1c9b394249bac5ed76831dc8265ac749c0d7d997351b5d3c1ae0c2aa2f09c81b22b52f914510b21e14d2df431b03029969cf83f09e7d50e8044aed03bd9bf97c4f61230f2c4188458af5ddaca09ee89e9d88321a1a597619fd4f6799d91f6bf81962ac0ed26779a445bc30d1712a81fc18aaba2c6ec3084783282fa7aa96540b835b0df8a613e126fed56a1541d33bfb087298096a73e4467976c6939b8348fdafee0201e9091dce943231db1ce628c297b4bdb41abaafa4edf4f6a741fbc1d7dec5a5f57c5fc3c84038a47d4824161043f3a248d658ffb11d5fb3d7a9db891dd29b17eb4215533582ce44b548ada6bfdc3a3e755db72241b8f3bf0cdaf6ed95603fc95083a151041bef0673f342114358a89f305f7721ed8db39b1a5c5e77aeb664636fbcd6f485c6dc34595a8be22afa9353d20273d4339be56e96c42b399c3f4fa9389ce924c8e66256cca92d0b0d46a9870bb4ceb5433fa7fde4150d571a69fb27d81b4d437fd239abb489ce29ff06e9017fff91f6240b15ed27582cd7184dd06350727c6af94517ac2ebb6ac38b268dfd5aa00fc40dc0eec581048dfb0ee67497012f2612c84c1d6ce83376016b064cd4c8f50c70409053f474d2e063a9b8c4306ef4cd530bd70150955c08db3e1a1bcd7112667b3cc18a50219f33f87e50d5f07bc709ab1799b7a8e9bfbedc421fa2f79ac88fb48ad3e5828986716944993da51ee7edf01b2e10f77ff25970db0da05fe6d193ec93bc7637ea0229321eba9eb00cbb77327a77b9bee2469697fb3cce99275317cb7865b8ade3d0307210f55f070f100b5615b7e990c1d06bc49b28d3ec6795046cfa3093f542b834fbea12e12f5cdbb3705163069e3f44f95ef18b8023745db2e412c6103f75fd9832dae17fdc425ec228be26c20532576f79db7fb71ff342a3208bd9fbc227fec3333e9788b1b8fae7ad80f1bb788201f0cc241e66440bae7a12578edd18f6515a35927138af9f7fed24eafaf7cb6cad2384ed03bb110dbbeadb282a92575a0b1a8e8e35ff5811dcf242d1bc3097ffc3466345fdf0c7ab159e3bf84c63b4ef2852001bb81526f146dbf246cb51fc00310045b4e4b351be9af3fec2a371f18d3f014b0f1c405b4c53990cb026328e71e2f94b9e2995d7d46a5ab76a76ad8d7ecec0c69eaafc8f16aaf3ac201e947bd0409c658c21d25291df8fd4d30d986059ee3271ab2a3a11613b8baf9cf7932a55b3a6da97b8a980dd87fdc4c7ca06f07794ff1f7770cff1724548b819841389942d0dc04feacffd973bb16604b309340c52e16320a22d876d5908bacca5a39d4c86271301db4798102b053cfdc069c56fc4566fd6138f5f1b1ce1b2899d273f472ff536d1109aa3d29172d41747d383b4d32cbc218a0c18d17582dd67cbd5d93b9e3bff4f7b7f70ba2dd115ddea431351b4c1fceeb1649e3bc473ed8ae5bfdc1890755c04e6821cfbbf1891ee631d19d7c590e8b3dc8427a27bf7b3eae4d7195c47741257ae527f5d561b506dd796847bb106a3994dd4bcc346d843bbfd89af3bd804b184437d1bfe6ca205a187f0a8ad76a9c051a9fb37192648592693b1c1cbea806e8594a4614f8164982710dcbc302c6219d1e247be24542ab32f6111dfe827abdd9c6288d04a88b687bc4e614b222d834aa91936a2824a42198f6ca8647bb1fda5c82c2e11ba82867f073ffe8695371161d8af45dd95cef1a98bb2bab3e8dcbd777e5452fd53d560848e3ca18dd620e9bccc28e2bb3eb669ab2dee486e311f506a929082c89c1e3af6ffd97cdca543be8c219dbc53c2692fae1b836128ad361aeb4f0fdd98f225658a1aefdeeb1ddc58b7e0f047be233f36925eaa5511b550053c1bdc36d47618694bb67573adceabf568b4bf6731d900dd8b0d5bf186f8a9230b27936de301590b6039d511de11852a6191801d5588abc0cc223efb0bc5b282de7f09b9e58e50f76534a86a50f3a5e04a6e3062271c7d9e3973c60d6f4266ad168525b45d011b2afc46a291707d6f14956be3dc8dcbd33e7edd2f5bcf33ab30f0eb2452114ea1018e77fc5fc65a988ad6ce07fefc638d4c0ab564d0fde5cfce3588a6effd556e3fb6c0e08c2df1f1f6714232cf5a7d8963f2d80d319a84496169e3594a3cc4d7b6705209e2b39db14d4d685963231900fe8a4cbe893ba21b4ab8b7418b5d55e944fcbc2203ea435df443ba708f1b329c14ba0f615b9e411c6c948ea8822ee2b72954a851166b4b78bde6e5152ad85bda3a0a28450a44faaa32039a0b73d43e84e009dfee6f2ab9f123a55ece90c463cfb521f3d4f1ff374861be5826312e5e019868a472937346179ab0d069d2655ea7d8bdbabee57206dd467a7df70b970f0857de97d9edfa922c55accd2d0003bdfcae3e29ea52d1383ba9a87edb1aa5f0a6893b4408753073ebd98e1a552673b8630c3c8a809091f1d97ff18423f4f87b4659d6d36eb2f1fc27d19ed7ab87ad31ec31de5a2636ff89334d94b5c6056ba86f3a36d87f52f49f2d9fe856f519b683cc38f982554c4d0b1d39fde1b048f6bb0a3bdb3626114dcc58edc1346a6910247540f691288eb753806068441c947a871c4959d77f65bcf64452030e5891685fb82aef50b7dbc6b5d59cee1f99677bea14eb8b57c15dfa7af6587aad6b91c7fe79b2755f7557a0149d0bb434dc530692824fd6ca954a062b7b88c36c80e7e50efd12d7082bfc1b9972e273dafd5206c849eac253b2c646945dbf7da0c3dee18ca34bc4d9ae49ef7d812037b71bb1e1d486d3770f4b2e1bc5280f8771925559d84f7dc14f372bdc712e158b74cb4097997c49bba996a9e688d83771b08b4f212fe06a3bc84afe4c83d7d8816ddb07a07addbd1fc731cc704d8cb87661854ee8969f04f00089b31abc5d5d435234d0aff57bbd91dcfc59782cbfd20fa2bed3383cf17e0327e26c1790b3e07da03592dd2755c44e67e9424c030fe8dbc4875c0178a3e77faaa77bce6e498337cc4f0e98a7f16525656f39568854439cc1711c0f9cb5967d1923df91d1853e7e99425e721fd5d001faea629767dfdc01f68c41f8214b9cb670115a036e42d4dcd0136994b0ed3a0cee6f88a437ffd7c26acb274efbe7cf2a507fd8a3879d90f3980568c0ce29fd3faddf6537a2683e0377aef5af5745c0e1d76db4dce7a5f0543e90910c44027ff5279bcc954bfc961430cdfadbdb6bdea2867111b29825ded4ff809c54201039f0f23d12599ce6bd1fdbf263c87571a9ce2b41ff64f9c0fccf1cebfcff0935204a44894fe6c89954bbc972dd91f00b766497b5be60fc92aac216f4cb1fd765961f1d9b9a09f5b072d48b82cee91aba955b4a1b21b077e87d12c42210912c26d3a7bccd66b5263e8b53aeecfec7f28303cb44c8037d1239ca6e49428c101a036964698fd83f6f26844da266645d29b561b0b68712b2f95c7ee7f157e668bcc3a871ebd6a6a6f11355106f3a1c28efced254324796021a46b072359b7b0471abfe8f13a414fcaf8b6977a0aea6cea96d2dcbc72d5174f96d7413458bc798aeef468df15572e6298291495c63957e98882fdc08a2338c2a202a078ee2fa81cc2783a4ed7110979137bc1d5a491f72947043d406784f8f276167e745c68ce64a42007230d53cf463eff4082c8f7eccb1a1d097048d11b5bb2c9f2b2c5f77fcab51afeb9c874c93e26f2d532770855bc9dd7c96031e0ad4c6b8af065b2c49fdeab5b17d01e5695d488ca5e919b1613143f5a5dff68d87494a97871488fb22819505de6eea777085a575c363e42dcaa9ec30dc8b0f8968884e93038cb2bda32cb002d963f002889a739cb26a21fbb9012c31353dc3123c25f9b66ef5b3c52373a2fcae8e24bc0b0200b4dd86f088d11fe280d93452633f5c2a54eb205d987d4b7e1d4530dadf0484f59bc65ba760434eeb330110d2dc02595ded947c1fe2695ef308c942fcf1cf6bee6fa00d2089d35df78b1908b63ab2b3c94bf9a8a0b937b92ca1c55655ec820fc2a24d18a001c85985d752a012672764f075838b845ef53fe713fbd3c8c13f098cf8f742dc4a05c30a01bb93e99f2e2c6eb46e02054b70e7d792708ab8c4767e334a4d0135e455d954e534f052340d5afeaf56e52c3e7a53e4dc179ab1973f887ea7819e0fd4ecea6cd81b2d4f08708c720dfac7c84b64e3eea404d97f0161eb439493b4f72ee611653b913476e05c7f19da7ccb969dbf9d9610077be51e2cd6c9cb60fe3b490a1086cff80e5d2067c75e709a20dac6864015aae532a827fd6b441db08045cbf632b78e3c8959101d2f87590dbcb68333b888ccc9ebc4c707acf8a2c3cc52a91edc32a65ca5fe7b6cecd3520c9141dcc1255467e4a0e7cfad9638e2df7287eaaa1080a2b6b4d53689fc0065379bf300736dde9a6128b6324fe8598f1479fdfcd5ef4f408ae95191c07ab3fa2375768158d9b6c58e54757c196b2a76e237b78fcefa397d6a318bef1a0582661b5c9732c1ff7d7917afb308ebd9aed9f134696263038f795306f908668dc7a8767025fbff05bc84db551cb5d50355178972d2b6cc329ece9de761c6a3a54ea4be3f62147401ff1e0a78b8b55b4ebeda49e404eed87f5a1dc3b4fb6a23e3b9c8e4397119b632697a855ffd33914e0901fcbd6b92a200b15f67433f4416fd8a713e1ac6cd9c72d15098c938dca6b3b3c9162464af638f19da232783309ad0a998de7f0d1dfd5fb57bc6cc5a62ff229a984190182f36ca560e9e83a111e14b0f177918bc553bdc16070831e8f75b5acc168224b09a8e757da7218fdf1ce822aa6c114bc2f3b686ac4b58043be1979af22632a03281c2ac55adf397b7a67840f9e478aa0dc24199e2e3ef4ec2ba729e29ff22d5d4d0b939a836d4d8c181512e6381f5af4fce075cfdc6aa02cd36277adbf614f058ba48c84cff048bc7adbdbf0c3b0f622a3c900bd1e2b415b39086a3a3c0919db17db81bf0718dea012990b6804a2f03b499b4270da2ae0ebe095ffec8662d558cc46fd46cc03539d981bb431b490ad2c4add26ea0b51102bd22928e23eeae6c5a8949308122d67e788445e1c009d4b2367da4c5a3d8eaaa11ceeb0f9bbd249864d877bd29f9b7e249f3d66db07c47b2544294ff513fbe56b4f15f0b48886a9348187f50f916c8de361bd1a89600a5db5e8c4433cc246e55601e743bbe4fab3b7aec4e4c7d5a87d8d965bd03e9176a2d540b5f6cd937513004adcb62540d2942e62e53bbcb16b0923c9f55a6799db8ddd9b47a1a864efe98248cc5acbc54ec263d0471ffb3a594344c8239fcc677389542fd71f1928def97a9b282da8cc1486704ed2deacdf64478b27bc2d0560496a7c9325e87262dc5241e949962063bdeb5ed553296cdce7cd38bd681bd3dd74a54843434212aef3a0555bccd553cf38ffe285741b00c8079b8e244b8639aa2302402008861839eb9bd41efcede7040185b71e360ce2086d04f93db17b8a8974922ded1b5fc844e6a1b6e451e0b92f1c96c58704399359490756aad92f73ad21fd94d38e5966a552975260ff4ca52defc9014a56b3684aaea83d53c8b9183ffb6195dd0139084527664ace8bc72611e0d7d416dd311ebf339a2ce22ac5abdd3163457d5fdccba372b697688072f4a2c8daf83c46a73270ee5cd7464dec7516711d9a0524b0844f39bae8f224b4c8da38a0ef338bc0cb67b65cb9341eac47efc9189a2f36f10c70a426de2f4c16836889ad9915d2ac9f86bdbd28a143245a616d7cf4964f420e3f80b4046930a3732fbee4001fded02eff75d6d4493f152cd8360f143bf555438a0ac295ed5f511dc538f31c35104869dac88f9a2ca3ce9db506cf6c0100afea3211f0238cb950fcf53af4325bf754b6729c25070b56ff93cdec281230b5b960ad60d4591c794ae53d39f1743d712336f8aa01b7efe799b5e9221c9bf66ebf9d84821bdaf553e66251fd29b1a85a7e00efa8aafba3f63e6d44d7d1f8e1d476a2d6cbb32175a5260f96984e340fd05a15aebb01d935a2df3210c7732b66a432b4d4bbdb057cab6d46a826157d07fe5aaee13f487779118a46f1a84bb05e09f1a743aa2d09f1d23dbad45fd502cb81aaa208e0a79c860692718067751b8386cd61fdc5024c3b14075a9efb131cb859d698f7fa369e37838717c92bae8ef86d971c7063c74dc85f93c03de32705d26582d4555ab37daa7daddccd370aa6bee98e031d9b1a0e891ae4d41a3463223e781e881d396d96c5a4e26b01919b0240948a261a38d35d74aa929555126adcc6f5fcb41f9a1c51ac342e72ce7a53d2c8a007d791f6435901130616404ba1e058066dce80ee9ad34cdb62ba0fc1a8930794e60a3f125916aea10f8de1c7de228755ba86350cbb86d4ac896f96d2ccda918cd677f524698a7baac0f474cfc5b8086334678d74b999362807f1a6ab790d5e1bb1b81b55d38c6f548b23e719798a37639f16a4eafe5fab4bac4f7a90a2e14bac48f428d4c4a4117600775db28cdf90afb07bf1592f832cb9257fbd9791ea977e6b2b2badbf01ef81bc20aca9610236c7783bb90cbf88f9ea7a8310053ca7662d1d8a45e3bc971b8355e6df98558f6fdfdc6d9932881716788f668873d75342c848d62de003d9a8295cadb4f36f88250482c400b71abfc968d88d2ed0f937957b6d5caa3211f132e7c17c1e2b77f167c8cbcab267c0bf1e9bb71c7d24ce492fc907891c9d26b5531b36b5c49f978be686d057466b6f7763372f6ce63028c6c650b9b3f4735eb82f504c2280640643783265c5a90725a5ac34df444fd780cc7128717f384c5c12e9867d2ee2d0490499b6a20199b862a950ed7e74905525252dc5169900faf4702b9456f4abe311fae5e7861a2b96c7476ac3448cf54f23175873798cfbde67fea38c651f5275caa79f049375460b003359d5ed11bfabbb9a395f86ddeb88037f8041b88f823a51f02ec5897f26dc85d940c25731a3396644762d079224a04fcaf9ccfd7a9a9679db9afcae42da7cea7e877ede084930b0fb9b236bde1126166dc62e9d562c3e48d813c92afcc5b7a5aa5838f0fece767ff09ae05cb6b003e6d2a5f8522e7ea9104d6b54727b20a4a25a224c892b42bf844846a5269811e8e8ced60a282b0c57de819724d8d077ec04351a498ac42b71e6add72c2708da7626bda060d3f604ded35431fca5922865e029b5051aa801646e3f6915d9d7c6c68ebecaecd857c8d069b3f94a62cae7f2dc9230c48594b069c4617cd82e82213066c32286f7da706fb7864f2e236e3dc100e40867515919a97f987553459d4e6bec30fae3b79e452a2f9cbb01112404c91a6e82b5695190c818dd1ce0ae9f41ff58f0a5aa2e5e47f47817667f7af0eda6878824b0aac25fe806e11dfdd8fd0600879eff8743a8a86554259e701c59fac14ab53af52b53426d914787864ef2381dea64e35f0fc94faeacfa56ee7e7a04c2b5f7523505a1ea9a202b4f7ed8198a00a7bdb288234b565848a6a3318a86365618a3c0b77c2d7afe1631ce64bf6a42fce805d217cc1e8ddabede40f4b425904b325c1befd1380da97d063f21aff4b909cf4a2d3e9f65f5fa9dc10b616e3e65f361e5be1d16e02e3a0d5f427aff44dc178a2eaeb4eb984501e96b8694a5b8ddd9c892480ac5ca5dba5d775c1e6341aea9861cc838d84167b95b6f57ad90ed74cce0f01cc40ffa914547aa753c3fc9c4c4bb44ee1846c2fc451b6bc86c159679303b3de2770bd8b185bde058ac2d74c72f79ff1cd1c8bdd4c2be794767753490a964ce045436791afdaf8236a76b52f6004f4c4db7448a78b7d9b9e7c41f283010276d327d041f1c21b916231037aaa17ce81702b806b0a05972f1de91cad426b8a3eedf12676e7d44a6ed984c5c4baf43f4d5c12267e9bd9f0d30059f358810070014c1437f79f451220eefac763819d273c59486494270233b5e5bf23814e35a9ed15472efafaf560d14eb64a5136c4d0ce7869e0bf011d4cadc82c7006566401da558697c05cedc4ade2d14b7f24ba332462a4eb53a297916b1402099b5b5f9968e4fa0f022e51511b5bfde0dfdebf74cb714ae7b58f804093f00e52a67be54db96009073417ed5020a8e15be7b966423965d28e96cf0b6cd3c4f958ce9c7d19d89f716c764955b9e12e86ea9d229063a6123a53cf5370e515f5f880896e619d2af02ee1c051aefca4402cf982f955bee4706c7d1cb298cfd3987bd7ad788c5b0e3b52c76dd72488f2c74a0969a61f471e2ad37a494d4465eefc03c287deb721e4de7ddbe7ff7cb3a29babc0b79266ffc533f0440d57b4b919b2a07f29fa32c6f7233a4178473948b5fb5e4608312c8ce08eb09b13214d1b3d48597c5131920c00e786effa4a94d9b9528c926a366f7e11a60724350ca3ab238b9f26cf907a4614c5a3c4fdeccde9cbc3da3062ef8df5a29554027927bea25c34e4820a7fd8e0b97bef239b106e5b4a3fd5cfd77b28d1d1802ec48973ae32a91f4227bc8dfddd5365240c203f3fd76aedb49a3c511c419bea50ff195ce3b57ccfd28b74865aa2f4a039258ae23e2d1702a6f823da6dc2a02ff23fde632613eb1de6c4e549a714e82841793ae9b4f74c1a25cbd9599f5a447d44cc3f313292a09b24d67815eaacf3aced7312254c4f42adf9488e12170e9546f35f36a55b4f3f9b6e7abf8e4ab86229ad5e0a1bb0846a3e28538100dbf9c0f1bfd05198f2126c2ce146f4a34e4b0b0e9436a4f308a42188e11e6653e855783ab330f018a0fd5d2fffc4076aa5e0a0f7dca4aef878558af2ca6eb732a04eda8f3e5005bc5efd0bbf336558d759a7cf65ddad9b18a01a18de8e6bcdd5bdaa04d4cbab4ecf428238a78785c4219b16139551278e47499eb9c51e4da84ee11e64a141d4ccb7d09fc8b01d7b3abeecc955b73b3759f77178909dde4e68c157f81f82c7db9f2f9897ce823980b779eefd0a58b25a3a938dfde2362bd1507956e296478988449b9df051d1992e7cfab080397b48bbd364e280de89eb985fa49a4fc6263d81b973fdff83c411c9b44e65bac73c96829dac60832adb11439ed9da96a0258be44abc02e0fc49d8fa207f9376cf8ea53ad03a24f13659e01b707136c67374a607d75a948b8e653577c05dffc3fe2f8bc1ea0552f3964cd43956bc22b04ec2df56013174e248f2e91636966722c141cc1320448b8c3e18c576c5bd2b9c7b47a7161ed5da9e6a01a3e8e55b46e4b9f400fe51b5923853d892af86001076088af3368d182805ab0ab02d1c5bfcc77d794dc26f557ec2aa25a6467b4210287cdcdc02f9bc0f732169777cacdd4b211ec0be9c72087bc7fc8f53e1bc697c634f4d89068620744e12a370af8a511299531db93cb102225107838ef59f2de1a79985bebfa56778dba800b6d5645eafffc6501009c8fd429bce0629db514023f96dee1d3f76be9a1072733986f97a7062cbfbb48cda73f9bff0f98ed29e7260b37517d060bb26777685bf659f8b8e591d67f0cc662d87641fb93611832d7fe5dda0b430480cab07e35923f775f071152a6243b61c83d82d688d52b93594155dbcd64cc2f2c2cb5c5c8691b5cf039f07992f854f9f16be1d0e3d1c44809d289fa519bb6f9cf0b1fead8ef3c5c6b2d1a35a604a5d7521202feb0a3e16193200a65c147221dc199c6db4f9b798335857a6eafdc42349f26caec6eba9a9dbf77dea4d56c35ecefee3b6f47804cf681c7d0e68fbf83ca893f122899b6ec395a252023631297ac99733fc0158f52e216242f9b2adf817deffc264108a0366c87987c762643f7033ac24a649322cffe8fa77f7b27699c0c23d747aa5893bc69dd0cb5017d2084748d09056d05bd279d4037fc700717f7d74a732a6162122700877e20e2228075e9b6b8d03a559666491754b5b442a1fab402a778690bdb03bef029262e50318353dad03d1f8089b9fa244d0e766b6ed0d2b3a94c17ff8640abc2e7c683cf976a55be8f93cf6802f3d3a93c3ed18e3ce7ae548eb829143eb291284c10e7e7c46c0047474ca774c80974c9e4d2154e507219830440b56b7491d5aa8eabf03397cda0db1d97ba9ee596d64843285d6aeaea492a8c5cde9204fadd19e6504cc0b3589a0924d6b8ea7458c4f77df570bc61890327bbfb6331f56b0d4e324c870b5cd854f6a3219f61d6b1d3a79bc001d344cdc99bf0fbf90ee14b4abe83022fc13da03872cfc23a02a227f9d257642db153fb24e7d5b273794760172f4f673f4a5a04bbbef9b77b4fb6e4a75341925567f79af66d5968be5502573cfce184e18c0dde7a595a349766ea3682d03e4c46801af4ddab63daab65be3ffebef9f879750c0a6d5eee1efac63e109abd856bac7cea98ac3b63b98c8c990ee85238740723ede918536e900b36e38841150b1bdcd617dbeac9f0299b1cfa1b237b8b3dd1d06be2e46c765abf680b576b2a775ae7489f526c233842357749a25faa85ad65d728dd72a4ef7df85c575c9b36b07c044f0459f4d18793e7897b434daf13b1e85e0dc60c2880b0bb8c8719678521aa44202a8feaf8649a47f23384a347f14cb29cdd1021ff49de31655034865fff5e9a97a5581f64c54d9ed2e84abadbbc133db6c02fcff086a67aab63f87217eae82fc7775aa0fa9d9462a19a64b2e490b064a3af1d84ffa0da4eb931d19ad97cec0d309e009d07c8cc837d97002ebf9760f4a9cdd6a60b3f0073bb77d41e2287e211d8cafa5a0b5c4584d1473499ec2474854ca6db546f5dd4f95b6b3424fae99534b8e3bb3a0605c5634f317602057dd3adc62db32ea5f2c4568237ceb45e54a5203d9efacb6f7b045a8f342483db9b777e702a66344cd0734013899e2f73640519d4a831f24b4b2e61db88fe3797f6ec51a35e00b21a693663da1d484961057d2fbe59211910456490f120a7c9c26dd4eaf963143c92e49ae307a3909c083c29cba3c74c794a7d3b46c7f22785946165e205aa36bc8671dcb0ebb3e2cadff6f87ea2857a6c3d8b3b2397136c04f120e966d473808dca186fa7d874cb2ca9df2d30cff935d2e0ca61d4c3b8c466eab93d4adc000ea991697a8359197d12dd9fe28c666a4c84fbc29dad59f56419be8852602f4782e25d3957a321a04f94eb8280d2256b54db46745514397be42f93c0b02d09c680348659169a63323bf3b7e349e485492243ce42e0b933bec14c7b8feee51401331dab94f89177df5f89ef5ccfb1d27352dffc5e0ca6a696da19786d3bba0426c70aaa7ef47efbe07c4a1e4679ed589cc43f0b1099115be8f450879cd8775437ecd7e1a13521d72e7ad4a2a1051324871925bf05bc10b8e13654f7dd9c7651d85a58da5c99d7cdede20fe44100be06063a55afe39d0d8f1ead5686e76fd7c17f47f5a0533442882e62606a965050e7a3d27f7d8cd9120d59c9140e31cf12c567f2596cb0cbb43f864d65be43abe88ae5cf32b84f00e69a5ade1cbe494ed7c70a1c30598f5a797545194a2f631da958d3e5de560118f2b58da5a726021138a55e8aec51d98ee25f74dfa6e209864dcfb40aec012e18020ce9b800965e532b4f4885ab73824c2ef747def0cf801a12a783fbdd98136ecb63eb197f8a73e05898f3591d82982838cc75f77a8969dfe9d9a1b688a8c17a481c07ac0d3b049a38f9d3d9823cceeffb12a83206f5e532050ccbfe54c3c911e34c2bb84378f9f8806a14d9b9a5381ee88a5639e255bb42a80e0fdb94ed33fa6ed00f6a0d688d82e5ae25b35991c368002f74d89d4a53945177e017e88fff74f4c48851e4dd565625a6ebc3df077b33d0d7b48347a06f7d3085e7c1b0a155af4a4a6de3975135a66983c3ebeb53271b2d39a9d03d1d60abebce56ae97fdb44e82898cf7a5b67c38f4003e108dcae16ec9e592f88fa58b9db772f4f32012ceeb1f4fc34923b6a6e41debf19a9da038af96429d5bee5a2826bdc2e76c5060779326c283fa330d3d1aa59c3cf82f5f3014f8931bf92a9a10eecfa7a0395e7a2046f201080d1412a75a4c461f1a0bc9f108c58e87f949f8bcf17434db3c7b746d78e2b4f7ebafa102b9c81ba9f536433ba91b173f2622a18dfe3822d79ca5f93093d4d17fe0ccf7366200c087039912bd4b03176b6c8db9b739573358448d76cf736e2ebb9bc133fe13998a68c0a00060f3de960c6029a75d99afb2e964880c32e8389cd1b2be8bb89cd680ce2e043916dcaf81e8b6a75f936a0d8c2cef973ed4388a9e621ca7707a64c91be2528c723ef627bfedc8ae2152cdbdb6ac1c7c8a239a4003a8b57824ede4cc3589b5f1b4d1628c8dbc164a39a93376ecd7e6d85f5cbb4ce83bbd4485472956b9c6e3c84d8cf7674529c0eab1cbe68ae6348c6a274c3d0cf89459b80edb5612ebfaef7ec602c00df1ef0ef817f581759be7114a4ce43374e61a1135546f2055691eed65ed1b7ceb6151e9efab8172ab36e4bd417956a70b792c517975ec50d73a7b77d143b91dacadfd5f17a9007fc4c4ef9a317c8615b6a38fe8d84fa345c586b82943636f492a3d8322bb81793ef1cdb2f78381faed4d848b8b056ed86f1dd04625a72b10dc32d7740a0033979bc158afe9b19916140f475b5367f814d55ece5b90a0cc706417519c8f4312ef563b0fe1c5d7ba5c63d13dc03b05282790873db613e6fb45a410cfda4f0cb6228240802ba859b09e2713b438a3fdfda94e633f535baeea281171beca8e8adc2e0846b77fef97aa8b9fd349c8d08e4162d0292818992cccd758a7f3d2b1a871d3225aa4cfbfb360c7823ddf4d69af06bd6c6dd034021dff8cd610961dc2ab16a3e07a0e7b7e63f6c476215b1afb363f428b59c6ab50612cd81e9cc3d0ef63cdf2a63c0adf58d717f49a40d6da779618dc2c41f8fe3fadecbc773b16fa0beda894acc02e16bbadfd6afd66f5efaf20286a5f7db2781143c7fa5c2775d90cffa5027dfb02c5dbf74a1c24567cfbdce2a735cb9b0aea0bc09b4afaf0db9a8bce0c61784b5d032f4ef7d3887f63c41b0d46822add1101f5f8c80db564011a477dfe89525faf10f2f4b6aa168ffa90ebea48a5c703698a9ee6a263a33c08fea21a1026926c7886a310935badc5e1bdb06b09c307720f0b56a209da0fa3a356223415b014b6572985eaa3eba323e4a7343b0691dd988720737233f6f88459e7f2f57b248762794e20451f604163fcf5216a114153b6aafecce6fba28fb4cc785edbdc06efa25708bec02cd342c30ef087a65a0808e4c53341054a2abddb38db5bef9f5a23290af3ef4f321458a121d65c04588bad75da9431865fbf9a3e8ac0fc9cd92550ee9d8505bc8a24a7e41e1bf855cfd587a71bd5022123c8f74dbb37fe0fc11774492f439839d84d483868fd9514826cf09c03d59ce8b703d509625e3d2562f6e455c003040d6543c815c836d5d83d74d6ae9926eeb7f364ec3397d03ceb6c89c6a905d2e63e44bca69f89643b6353e03b0ac49d68ae86f72552a17aa2b244d2985ca388a3602438d84bc157b034b618b39ebe0480bce56e20810db3b7aeb083a75d946ee160062d475e10b500b7468ee95c11362d404a0eaf1620efeb25d0d5991ab68f0c704ab04e336d2a5bf508421ac59fee6fb158715914c7f650323405e475b273d2f4c4c93f5aba08d4e4495a98c5aba3c55e405dd86978381b124106540dc222a790cd03de7f363ee53cf57e48e9e589b539662a9b07a6c02708393889d0001d42347a77e4280f86e9df9ddc25d6e4c347b3ec8645c1b16371cc922d76e74e061e4478887d3ca020a1d3fa5bbb1b9e5f8aa8aa4a2c008bdc9d8c7df1e4e8f74dfacc35c0ca5e2a8fb0c9dad1ac51ba630e5f63d5db4560fd707cb48ced609a065ac84cbc601b0a9d1f38d0a92f86deae699151f8907e0e9354f603ee81a70978047162f0c8dfb977da0118d48cfc44d4b38b57bcbf233847d72b22c5e40624b283a7ec0ffdc528b630af7c8da13b3f720958666e8d2e2ea02c66bd502e32d78ca7668f50f12e30f7573638ee606c7bb80dfbed3b55da1439a8d6e19ac90bcd0e0248045a072d322ee553160b4e0827f564c068512737ee6f46f71821f7bb7a296d18bea49abe2acc587359da06d84809379753dd448c7412247be46f4a178c16817cba3c75d8bdb2902724fcb441ec95b37e2592a38aee0504cf76cb2a55e5671fa5335a5a400c464f3369fc9be7f78c89021842704f6781cc29cb995316b508e91324067c375901c021a4a28f96c9916ec7d2f78736f434062d7fe454bb5003c66fce0c04f5caa9ed6edc697c84f13e9c274c7ffd7cf2a3611510f3100bd5dc6269bbd48ff0cf994840b549dddea6f74fdf70aa98b3660b2e7b5db04129c5bcabafdf4caefcf2a623ad8b8f45a9cf644ac964bd5201e868e3a29348f0dc216455f4db08643128d33797e5a4daebb51e50ab6e56da35c1999b5ddf2efe26b32c570089ceaca6dc512113b346d431c44daa12e1d512ac311595798d849f287ee66cd8414cf1fe5268e06024df0358e33da74092c292fcf777b1c277adda59a16e93f19d6b94c116585974166a47ab53f91727b5e7248090f2f692e1b70a10114890758db86a8590d1d30d588a15571b01d07425f146a2d1ae0ff325206054ee53689709a13beb04647c62493cf92364222ab2781bab03d06cc84ad9625e0a7204e9f7cae5446888ffe25498e00e866239826d6625ba6c34ea96a140c25d66a60a201ab870b6e0b1e47a3d1b3088fb9f6bba7759100d906d220d6f409e08b4688ce0e7fde93512164d1c430c082abbc204b7303c66f49c671967fb24c0df6c6d65424604d159ced5ae844327e4d0b22caae2e3d1aaf0a1b3ad0450e605b59e40d31fbab0923005c9bcd34b6c4ae7d50b0ba8342f5738bf48e2e4b7c9ea33a27c31981ca912ba9f102c0da18862f0bbb58bfa9a233e3729492b2fd082855321b1188f5f88616c2a19d799582871018f68acceefa5800bfb748cad2836b6e56db4472b6237e6ae4f580dc480b2f5434acb149c09964908d934c34f74ff680d28593c58d5db145d224fbe3ed931b77548c73ee168656033636649a449dd03c334c24545300fea49389bb59b1b6c23672295b49ff47842c87754b9647324515104cf27e4b44fc5b894204dd3d3690180dd16b7dbc655dbb54585fee9d0dc79d9285a1c6d84dde9e26296d1c2c8f09e396ad9ea1e09eb231c2f48cab1c6a9edcd3c441cdbc375e172800055a9f4b24ea072575bf5e08ae9d57b2df6de3e2068751985df6dd09d380bd8dfd1ab0d3443d67857bd726c64bde9dbd1d9b639ac9d6d5dbdf027847090c18b2351519ea79091457f5aa8ce909518baa71c23ee677c234302864e8a1fce9cef243c07ae49669ba67679324c05f9545ea837337a86575dc7dd8df0c39a44195438239cf9f35d517d3367ac77fca744e016ae992334c6b21fbd845abc0f11a8a09c08c6bbf116241d497f396ea892c2e9beff2a280e790c8147349f2d33872fbed3ae9c05542f1cfa54b2fc2340985d49597a611e94cb2c3657731895867685d1ad801aa7481550a7e2129fc0b9f8d854005bdce5346126068f5adfd70b46f8459168a0a735186f2561e2cf0bc49ba91bde23dd27d9afe0eac52652f71860c8a7c953734e9b973a810371bde9d04f7b697ea5cb670df49817c32f96d53d2ca94ee72d3bbbfe2b07c2a6e49ee742ecac986efeaea32dad5b4f04ef120a6ee145d879d7830e5f2c402817a42cd80fd2d03415bfb684346a8f8b880ff0c5e0ceb872affa3d22f700e2bb4eb524806a9e2c6deb72b41f10626af2d8e49fc8585612f7a2a73bd24d4aff2a87d6c65245033c57820b9e459e0c781dca745364c6b6d9d36251b7d4d6013cf8387b583ec0a12d01fe0c1064b2b319b0af74839275f284c7fa1bcc22a65f53f9611fa388d3726354f0e6c6f5c6bd003efc376b183a90016b0a6bfaf0f77e9225ad9474bbc9c2f5c7bd9724833c46b581879388bb4bb32f8cb247a6378f715bb455061da15a042ce3f593ae32487114e3f4251e86c4096558e38397cb2cb0a28bdf71f15079c8089049ee90e9f3cbcc4df44ab51bf35dea5655787b06a19c72fefe3bcb4b27f8bb3d09e816fcd1f2e157573c981df32a7a33b7d960ff391868db495a88a8de052bd35465356e46ac2bb83489559f3d71c758da683b53900736cb8b438850652c7471673b01c4879dd50c94183fab232cf65ae830647df4fa22ffd779314c1bf96406a9f23562b9c3def15b62efd664351e32eb9d18c0fe18842fb20a6c1f1650feae6f61ae7ec1e49b677c66bfe75318cd4432f5f69c03d74beae8d226369bd0f8e99a77f0a0bc3d33898f2f4e873b5282425ea083dd6e017931fbacd160cb003c9a72ae9fb230cf22936a5bff07f5c134ce1d4ba62b4714a36923f2e06091ef6ad973d307a061c9b73959397939e394c9f8e40a2c3a5cea729861df4e85250c559af54f968869c5954ffd8a284dc3d3a08b29a7457de15724f31e811857b8ca821bcfa25c7ff6a936bc0cdabbca05ce0823ee9f0573775b0bbd44c1be55164eac296a7c92dbcf5463c267a2a494a106c618a6bfe47be52e0d76e014c6c356b64232ebd010198564bd9641459bfc92f1933ebcdc3e4306a72259af0f3983e7e4e725593fd548e8c7384655d71be878c59c6846eed4b7a800da2a2bd52402887ef22aef5f8211360b9aec6061e40402e101c8afbe4a94676ed457f2f7193705b4ec1f02e7df3f0db5013b6117770d1cc856156456a777b9794863a5d9abadc8e214ee230d55e797675a4e47609d1d1789248bc5afd88dbb8f7ea59306f5a28c6edeab6e58731288e4ead52245e1162f6e69b0f7642cc878e0555ad1591432c74d6f8f21b66a03ca84c989fa0311152d3c14f348cfd9a5af0dbdff90efa8909ea223b1f9ce91040e2f62f1cc0fc1f212e38a12457f768c58043d04da0c585b7862089ef0a3e1c88b5af57973bcc7dd0272245aba0b7fb06ec26ec5f62c4bf2757e60ba4acc795ca13516dd6132c0fbd453aeab3bf5d58dbdb87dde3356afe56f3723741f211ba52f9a2bd77b0b8a1e0d56ea59e9c23bf0b4eeadc6cab0357242487a45c53dad72d613f12d7b27c88822c00bd38a8cda8b850cd3bf111c930d7d594587cbffba1f72def706a0db62c24bcd3b1b43ddbd2508f6d8144b270103c7c197136c1cefc17c6d218ea59e027d402f15176a39564c31af3ba8ad64bd1f8bee34b89ef49eea34bf26ec34b79788a3dc2ba65499f79f13d98cd28086876fbcf01a79380c3ef7ab78138d5040d6d70652818d15da5aabb234f29065172509c691f5a2c0ebe8f11d8ac7b6710cb494bb981032817c1a4c283fa60327e8e0eaf704a9ade5bfdc0135e5756f528ded44e0da4423fe0938abde28763cac7e05e702c2cceebbbcfa6b1aa124b49deb80fe5e087f75ec1d97c5e01f435de5ea66a05555281c30264a2377c232ffffe631accd1494ecad617f8483238306ce67d6966cfb3e9e57e274e9c5bfcd1e52ec066262a24cf698c01e66e95dc015df17b14367acbeb288a549ff98c4795bd80ccbc16d82e47460b802b6224e16b489fd514674d5115f641b3865b5a88deecf268e6f0d508d59baf1a055ece3b9b495099aa0e65dcf323cebd9ab258ab5c8c49c2396088eeb0e4f3cd1144f0c6d437dba6f0306be49da7d196654a6fb71a8696ea17b081d97b33ba04f9aa1140ce31f513a2becdd00810e133dc10dc39580ec62e2259f939d24b1763ddcaeb704bc6610684c012b2b04c0a260b69135c72e013a070fcefdfed779629c28039fd63ab456eb8fe9d236f5492cf4690c5a05821c86f2e9fecd2f877090d7bda1a098fe38a1b69ff55a3d6c70cbc524a31b1c9199e7cb76a05599a931df38f3a407741788b2454368db95aa4261c17270013261c3dd7c67d9ef17bf916c70f18ac427950427120c23fe448d9b2c79e313123cdcfc47355403257b6aa28e13fb3078836502bb21128c8084cf4d46a35a49c4881781fee8bfdf71095c506d1945bfeaed82b46775c0be60441da63c9af0e91f35ea759fcd2cb909f90be4485f5f07a6df72424598b1590ea7f52c15dc62f87cb6d34acae040e2def944eff8242d171967149fd1179c7bef825dd22e8b149ba054329e885efa4479aa7e71568c6d02e1a7befad4044fc14ae261edd9ed9e2552a9c922914cf4f3a61f083d1321d4249153afea9d73be562f846ab9feecf193e425993f66f0baefde6102e7f74db15e9b36c99fb8fd1f6d445c5c3bd69704199b8c02640f56309242ed2acca0e02a0ec7ada2c6954017a8810f8cb88c9f15a34175404a51cc0052863376f4999004c7fb2ae4eace5cf253b2788029a0db7b77cccd2ca2d66627d0ae197adf2874f80a03b2f677d777f6764d278552f0c40648545257deaf7b82617b77a8832a899f844a6002b1f23bbc0f9ddd0c6cc1faee634e196c1dee2678868b99590a2b2dea869ee03c3a38539c126711e48465bd56e67209ea69e2c6aa02c9c0a61244a728d34af4870d4af12bf84a6e3308dc745a045d5e29cab77ebd8664a114855d9da3e70df35ff41f4bc9eece5352117a2ab1dc9326b2dab3b5281ebfe40d42249bc458d1451ae1f5193801a8516977990cdd6a54c7e2ec66981ed3eea62d356993cef627e873c1fb194ec420b1e4ba5feceb7f2777e6e379937f3a29f75997a25826c228ee6fa4de8caf5da2ecb63ee9c1c7e208c3fb4995dcded9425dae69f8222bf05bfd854da4b69bf54b306b77882517faa6090b5812e896999e5036739c0d9f8215cd208f9b61c9e534e207fa53d5ada10cfd8ce9c3f4edb45cbc774b2d999f33c7ae6c06555a53376e16c194f1358d0dd928c1962a7d4ada5482cd3b8b2b2eb889ff7512b1f3b44118197bdb67ca74dc0364346fd4c8776d6bf69101d58b489b5bb897201180d67ce9e81cd2c2bd02bc0d61970e7e5bfa1d1e6219bb396591335ae139a8a3da29d853b6b29e835f64406824e505c8827443b8827c89ecc888758718e06f93dfd6280e6a606d269f96d1d183d9d2f8cb1ab27b0733b1cda954a4851088f59beff780271e24f0849636d05caab7df508a38f92e147e434c611923100c58142671e681f2a168247ffce153db986045eb56c43deec4a29a9a2be2e8de689d41994c97fb06f667481faf272573a3b949038a0423d0a2f4328fa7195910111bfbfe6e076b50d35d2a613308d52ff062d4bbc54373ec2fb0aa725a92822b07a8406f49b829a0238a3be02d061483fcbd53336a957a965fa5f28a2c1f074be21d33fe513c6082850311f3e7c6aac51644ccc321aa45291cb2f96ae8bb2d074a97320c7fd30d25ca593c26d042b6f5e22c0ccc54b43698c20c5dedbf45e1437efe15ebd117b7f87a08a69bf9850921d7643d44b35ca212a15ee747c5c39d1dceeb55c4c7b98d5250b9d38e9800d724c2d34fadb0c6666d7faee8d4733f8ece21d4448de84c23c0ba56c421896703ae41f3f59f04a5aeb1131bb106232d5d8b7087ae9f3b24f9ec5aee4ba1c824c4af49b52d5d285e52248b65b8789864790549ff783ece3e7ff2876319a3f8576bd8a1ba8f47dd408955074c3c3973a9d1764d7d20e7334454abcdf1cfbadf6683e665d9de19a5c8dc4c1bb45f35bec348d9b2f928d2fe90d82a687fde06e71d9c2283f3910447f28fb151a5142966286432c1e1de6d485366cacdbffe809f606bac411d52994fa0ece3a5135b93b931f7a9592601f02fb7c055222686d1386a23bcb513a7908b0f2958077a9ef6ece7cc786a9a2e5454238cc0c1a7f25f099e20734b034c038f5bd727dd443c1c9759929a7ba1303e5b85e176b94e5d7e0ce85059449ee6a5321311bb7e0c7d2936848394262e7d406eae4ecb4d9cbcd85eadf62e31831af30fddd09eb79f8a13aacc9c9096108af8bbbfd53c73bb20c4c34ca94c7bf332f5052c2c1a4ade2c67b60753830f95cb4bf1a6bd4f558353a51f2fb565dfd9dc8db7035fd86b63576884121410677278d1c7aa457cd4498669fe673d23ea20abaf0dcddb094100d2441dfb116785086d1e76078e460086f7f60de6c0b881595ffab13ad1b26b068674f4b81a65e9eec7393a9b47eba142ba8e9e33e5445cb13090933dd87978623a695c757ed424d319fad4a2fc2cb160095428c7a88b86398bc76609bc2d6d86c85e0d6446cc5ba7426c0b8604b6e0a9d090c5e35e59df7c019220298e6544241474a32b3ed1c82056ae26b474330fb355dab30917a89a666a0e7ea3781267b84f341fde918a398621da7390a0c5d58e2aecd4f65173bf7865c17e2f009739e4575f648102928fce2cb4c46efaa2fd4fd4ea2d372600aa52bf5ce378a8fb8d982f0fbb27f325410f51d5ed9f67d2065ccfc26a4536428a8770d3b4742c252d10e74f5098d049d63a3eee478e59b2a28ddb83593b1af0e3c430b5bdc5bc84549a77deb287952f6e2f8a9530ea3d9a3727baeb6a121fcc0d49d8710c31f69634355e0a57606d9b3a1523ca89e617446195c7ce36747da0b2a90932752282aa72f8fea4159bb750000d3ff5368554d46e011bb0f51a6a7054eadd670f4193d3a54f1b81aaa7ed7d982e23c0a2f32b46e0b315a606c2a169c4e28c17b513b0a5da04e54336652d8b71d75b8338f721bbef468c9b6ba65234acf54b1d86b57d49131b7830bc2a6aa50d49406eeb6977ac05a9f3184a9785590717dd62669a7cc8c378c525a55f86de8097dbc6afc69e4540ef3b046d96689aa322880c7b63e9f45462383e3ca4d7c0f5e794cbfdc5053ff3f74231c3081d3da6827822b0c33328a1c4a05f328ad7c229ff30d1530ac66825dd0830dd76eb850626b9203574bd2e7c4f2c911cdd021eee1f0731b2dc0eb51037108172ddfecd0fc74825fd38d31b2960781cf07a292aaa39837c1ff959faa32e943bdb8d09ebe18100293ef5116de1bb06568cbcb084d5664f34226bbdd501607e3c979e75e5f0ba46cdf5cfa9d8501a9f682f6e8af97ebbbef2497aec0d008d4628c8eb024d8255c8cd5f68315e188067a6fe57e259c7635392a6a6b997ab1f26e5b5a7f4d5353ab212811afbb54c69bdb18056c42a65127a5a4db52be5c17c49b6467b304b762d25b5a2531e07f5c3194723033d5c21bfd4a5d8cc77783326e9cb8b36f14b0af6dd04ccf6a6e091ba8990b5ecb60759b5aec6e3a172cca9ad74ef3611efbd89d34bc34ed19cce8f4e86b2eb5f968a7ff273278fb34a84fe7639ee1c7b1f57de448f553c1fd587d4c234b1ddbf553099d445c603989d7cc04a2f88b77c6e24c91e1ba4ed1fc09d39d659e4886ea405bf180734e6583ac8b1b8d4f3a7a7137d5df2f1bb7cbaa4cb0ace89ef4b454a5ca1297930e7df22db484a457b2c97646482c3b90a4932fc7e88505f9b6a9dd1fdffbd44d636739e263185f351ae0047f6740f203c75ebdff6680fc3fb8ee839092ec7070b08426f31c9bdb0853654a41c42234854693fbb6453428e0643d934fe9aafc29016017dc7a3b9ecd8f2ec807650c23da04f61b3cc64f1111d791bb0863ee93ea71e97863405225767b4d1980bd51ca67a97527700ad0f4d12049dad252dcc48a561d9ac9d6bc64c317405a4215e1629b074e769f3b265dbe61c66ac100dc5d6522358e87503afba0dca67a44a49dc4c845ddb57d3ec4be7cade01241f97d377162f3bbcb930ff600d7525df8d4bccbdf48cf52bc54735a8f5c876d4e91959a339502eb81608a89f0dd6b8635febaa3cde823d53e1a409388941cfece9f436c4a0d95d9b63d6ea3614757a42f4042aad13813fc30f5850c9080f324aa61d3d19551e832ad698aba5107bc1d46347bffe4c1161d4afab2a88dedf8a51c3a0e8c427f9000b3481930fcb3794b8f0b6cae9107c45628c5a1eb00dc0c225181972a686461035d47903d51b9ae861c62a0dbb615142e47816b0a074a8883cc2392cd65467fccea698d64602ba746372cf6ea702e4e36f1803cefaf1eea9938e4732df39c06f83a1aff41fd4520fd162a31562a0cd81d7bb3a0a1157cefa08f69c6610643cd0a4debfb4ae8a41a05dbdfacbee0465e356f847a53451e9ce965826c17e2bc6abaf757f0fd82507a116f5fdb6eac34cf47f94ab68a95ac2017719e6ed925cd134fe93daa15e384b2ddf9e265dc579e68859ad5b514a53418f6ebc723b3c32d1cebea46f7f17f457a30c27c5fca3cdd932e2813f0a299834bcc32a73d92231c0aa7f6710d5f6779ad4c6347e32e9e290256927b436b250c9cea0d4286773269a73e1ac435b1eb525c60dbac9ef9accbb2a6f850b8d202f1657e579e2d11d86e10a4311c49857fb2f0187e971c120e2cda6015c07c148119207a8038683a1451955787501f5a3209173748d1666148a7dadc1c3633e08c6981debfd0ee1c0194d16de259c9acc424be07685abb41e2d4526098b4ab3e0baeb5945ef0819b6ae89de5c98ed291c55fddffd82f8d21a88e600e00fdd6a8a7c2d8981021542c30b5d062d6a7e3bac076f71877618bcf981e279b3bab17787c4669c76346bc937d460bb6dce8db2f018091a1182fc1620ff016f010a4eae014584519a7e54314581ab1ce1ee8ddf6acd5b965cafe75c38e9cdc36933b16f7d83d56b1045ad1f3d015a675fd8a572ae1c971aea1af14fb3c715d6d7baca432bda8e7c38a568bc12620f33d36c2f3e221e1223cabe84c170d26d02b604ff43e226473bfc1f0a60394e6fbed07c3ac92663c7d4a88ae2a84a5dad385dd4a8550dc67d6e60812d923a2ca24b1a9b09b28c37d3edb4009c897cd86ea032dc913415370f641ad5ff579da2d78ca37492e08434fa4544211c2a2167904d25017b4d112fc2f92baec2d2f81abe20e6770089742d21df57091d9a403ab7047eb79a68c9edbd35c8054a2e4ca00c1f995e32fe5641d285614a2d892874c90f33eb182452600d6f027c82dff51dfbb41dbd395497c6bb01edab32ed08557122323a913ecefb22060ad3e732e495c7d13213ded28bda2fd60ebae2f80ed7a04e52e395b11e4251adf4130b2bd95d32e3c1f91938fd98a392ba3d496278ad0609e0b02a9c8b91504159ea14afdbd400a2d6f19bca636332b3627e47f958cf9d3df55147fdaf37bc313d6a3a09304b7cee1309453cc42a1a1184f6108e0c541f740f0a5a3e32bf967916a24cb57108f2bc3700af5c56623de3fef6aa278f6c8b04965ac38d1317c227e4102c7fa874321280e0a29b5f1ca14e5f8f728a35b2a45b424e5709a08187779f564ef1726a141003f59e5bebd5f08677f3970e80d8724f9c5adeb849301279873b3d13a0a1ee114ced55144ba1f97eed809ec6010dbf83fc5f9458f810f24909791778d2f21fd9cf862e4588b22d299e79dcf595f59adec62cacf397989ddd46850c9d06ee88c9097bc33732cc2348f881ffd65d4ad80ccf0cc84ef045ea557e00e29716df0e365498639231ae14cfb0f486b2407e8e16195a83220f2f95ebd349741595e41abdcddb91ba8b735fd272274445e8c5980368b8e725cf2abf66402f2ea8992e18b5dd1a830740bf06086dcee176731216904ca1f7e8450f6b27a6a2936658d4fba8294ba4c4a8b330d8dec659605942e9f0a52a277f220d02be4edcb8d99ef0b8e40dc012040af3a5fd06b37ba236e03aa8c67ddef94667d0135359c63b90dec611ebc42041385355b615fc6a0c7f44f469af49fbb226a58523b0b27b063b81a4e3dad3d5d28081d183040120924dd4451012974d67b3e5b4410a60a9d1e17953d49d486c2e3e8fd07b7573e692cc6421a00ec91a21e32757f56017b6811112d8f0d3d7d2f9c142ac28fc25de6ff07fbf5ddc4199f21835496035a11bc6de67bcb5d2422bee7e13e2f971d979727e641af1d0167880fa58ca37e5a6e5e7e41b8cfba9b84e8a9ceb964438e901039a20719a777b565c7c39ff4c3c3737e8df5958f3291544955e240cd48910102f5213c776aa0f4a2f2ff170a57e7bc6eefb953833fcb6cd700ab6300a3ee51780e97663d4df085ab4170589236d5d5c0834c2c2d221f6db3b343f0f909f0ed921d25252971d4305839bee19bf06ad55355a109697685c14c59d5a5c9638b1ed589859e0ad44a2baa94cb9d54d08ab25c8a28ed331a9a1544d11b6eca5b6023f4935c42395a6d05e189ea3d6db6cbbcf13cd0d9e88e015291ae27f3a00487b8f0c843170ed1654cadacac8179470696f6a43c9a216769355d8fc0be48f14a4f018d3ede31eeb264b237a99f838d8d4b26bcc3a8b56414c50ceb1042c69b4144bf7cbcbdc0d9a7e2125ea4fbe2c7f1659a3a75c8a3f20c4c4dea21677dac5cbda492be57ddfed2d00bfab9b100a6e28ba772f5ed4d130140f5b7fcad20c05b1ad22032f2dcef91c92f538787bccfb633e685a7823b3ff21c4a5772a683487b928aa81ca170e46a5f23df080f088bbb6e49bb52033db3dce2aa592e40d51fbd883157660acc1e33c32983e1c41b63845bdbfb2524650cf3ebb054fd6b67e12a549ed0da31dfe5abfd6790287a705c4506e356308a1f34450a74c3a51ffd57152d9a38446e2dfa4cf578871203fcbd2dbb191fa440d5e13eb4fba67f3a4dccf7ce87bbf5e35afa342a2230b5688f6b2b6d46ab24457cc1871cafcf0a108861ffefdbe0f159714cb3d96c06136e69a95543877e97ed01b44b863b2ea0eb1c3eaf2f44395164b5deab98913c50023083207d3fb9728cdd66e0f18bc7637c9a53eec7c45fbf0d6cf4a66c40a17ffe9728305af8a73ce2851bc9a1d60de719f0bcb39998889d08610947c02995596482d63f069115c6fbdd40fed573cdef624e4172922d3c3b7e79528f2f54fa3c1366f015eb237ec38eedd6b24e2088e4c6ffef11044b211564f2dec97c1cad81a0baf7e53d20d47a920684cf78c2a8e9c396a7102fd902818538fa6257fe8e82a018a277a200b7d623c4a4e11571565ca62683b03a21e32ea500474e2bcd6a1fbba3c154c8b5c226d2ea3b5d5fb7e36126aebe1c65905e968e318f697f7eb94cbb9ab346a1483f0006956a51e61613e13f8a782f7a0f025ec716236c226522f54e7fbf5cb51428d2b629819d829cdb96c57b50740c4e396eaa0536d7a32814d4910bb267fecded0d6118bf765258c277ff4bdab746be09ab3dc201f6f7689d3986498b83c22ad25c173eac39cdc930a77e1bfa3680bdd7b61d3b44058442e1478f6ac762d45efdaf30ac9d2b408489881565d103a700b8133f9b456ba60d0107c4054ebd73a0485245b5c0208188dfcee2abd981f3a6f93340596c0778328dcd09d94f856fce5c4376fd9529aafaa1d115efb500d5cc46e3072c0a1a3d9d1a923ce17e5a617f810cd5361ed6523fe09d99329ced89eb5987effc41a4683a454fa76b3df0c2e26595498fd6b23fe7c79908edf89de1c63981730a1c44516e065029e813b5b7552a0afd3ac74cf81070d90bb5bf78cc63828beca13a0761b26e7583289e61a3714e5cb1e7ff97e1c8b357ea733eca3de145cc35b01ebe28d4489eb81f6dc7051c6f3ed95c2af2bf7f4ec7585943e697dbef511afe88dbe5ed0e9dac1e39aecb5e5fba8da3f90026df4aa6faa13bb8d0dac61ba5c67131af28f013588b1ce4ae9bf0296928672668b8d3f6a120fd4ffd019162e37ce5b56a1b5057654efcd9d85718dece6491549967b7d1cd89dac7358704eb6ddc57e8e3aea45fd05d48e3bb9341c0e03cd25b58263de6bc11061fa0dfb5c772c038da97b27d10a5e462847c4ff50ef9a5f18647bd68a7fb202af9cabee0c7fc60b248a9a62ebe987751aaa7e73db0a60eae3026024700a36f95e8fc1bfcef1950a06debf069ea38d01e2d7cf1984338f8bf25843fe4d52f994114232c9a86741b42764873fedf3e1b397c435f4f02b6443d9dceae8e58c4f52523bb84226efbc3be61b83137c43d5c79e0d425afd639fb0a862517fb667aed9116f5c87bef9b75657b4b74ea91622c3a3711c28bf9c06dde8772685ecf12fe0e97effab6eaa2a52e5be1b3d6fba65de6d5bfc3c937de21992b14cc973ab1198cc1dd5657f9cd036a99c1d3590f69dfd4471af49cb5580ec94a859d8512f36b101a3e540b13da8fd34da1df2d933af38eed018efd65fb10ac3a1177fb4caa5e992b28a26494475d4bfb1f0be89d4e2f380deac2c02dc4a672be6061d5e55062e8ac3f533b79e3f72e6b75e701b7464889652f41e2342a54e3ba1d9c659cb294aa336a8e0d177d07b714ba42f0d63c37c96820f0ed19a1f9336b2f538217b7f2953a2fc74df8f38f8d33cf31462fa744d21b42dccfec998c9d83ef5999e169fa746f39cd0e7374ad55346ef91ed514fc5dbaa15641236f69531fd280db498c3f0ba02088108b21d7c0e5a30acb17b10e61c86a017d4bfa2070e1b111533bc4872514e1328c5968b754b7fc407daa5d86040723baece7008068161e6c56db4325b418f66328e24b51ecff4abc11d6cab9e9fa76913fb9e1ccd5cb312c8cbf2a5ac0809fbddf70b7d6d1f925a1a9230f05873af3f45d185d079af4db42a0d086ddafe89a2905b600ac5eced39f0378bf4c11fede792187e9fa694411e06251b77fb6a427f7eddd148da10a4250acebe673dadf81d2b110f0618ee7656eed502568affc88aa0103b65a8d531ef31b2a8dda86f6db5fad00c0579d52798357acabfb5dddd0dfbb2d955757643da1edbd04e341e6e13dbedd8a227d92cd2fea14d0d4182bf2a343c3f50e60cfa2130351696cadd45b110cfa3661156a2262071a1bdf43d2f537a38234f245ca56ff7ebf2f609003c9d19403ede9f80676bd5e635f39e1b95d0baa9c692102ca965936a7b91cc78e6f8cb1ea41bb5eeb7ad4279f4f4a3550d3c28e9841c8926ca17da1c0af0404c0578c43eea32b8b4a8a9c6ae24aa1ebd8b0811c38335bd68ea8f533b017f927737e624dca2bdb167a2521d9f8a2391b4abf705c731e7913a5249042c2b0d2216a8a1a2371d597896094f5286061225a035a050066782169efdb5074209504ec5281ae5351e26ed8b277a83d3f74d7ceddcf0b9ba891909a90bb9fae5cf5fcc880c56341cd14a486c0d62735dc94d11153ca5a08f0d036bda582c3671e63690b17c6f77c4b86e75ff9bcaeba657b127379ed45f87015a25de815cd94580354589ef1383e25a3f80ba1228f05c55bb4c36b86305b7257fbd700889a4ed4ba156c4de03b83438ee10da8827c0786dd167710d9058522f9419551867a349442288fcd996f1b965b1f89f7b25aaafa5fd5a7f5e6830c27600558e76a0a71c67431eb69733c446c440ce052db5ad1a6f6e338e2a511abf48efa44f7950937a73f696b1b5da0b1465589a76e61fee3fe6f5e947fe8150aa78d04c54838773e6d90df28b6f9cca20233c946153dbf4e7fe89b35e0584009f9fd5a29161cb6a29b7c289efb01e5781da2feeb70f1ac468bbc3e12216b9e1f5a876247516936b2c0a307bd78e1bdbf5effbb1a7363db9501a6353c438d61b35eaee9a2012cdc25e54d79ea761df21620c6dad25365b3f9b18c974217e607da609bd4f56935972737b1c111b70ccb60009d66e186cc051d9017cd045d434020e64245107f18b5b7f12c64a4b59d9536b0a8b51361a68cef74aa72ffa6801aa3a77acc6b5d8ad39c22783c951320ea0d2b1669ae80d88988d5f974a0815cb9e6b149f551d227a6ca4536148469a093eff1c44a4c5f1068bdb1c3e09143d6aabc3c28d95d3b4a592b30c55889bdd7c2af626851c749efc3ae830b3532c8f090245c7c994d22050f4a733b7a81ca0ac6a5afc8f4f09e9398a6137b0727506a7520fbdea6c1ff795bdbc61c40f0d6bf40ae69f4b85345dbf092e3913008fa89931da854be7fea30109e5c21be32ceb406d946ca76dc909462cd8265d67978206cee59f8a316a8814baa72c4110a4a092e757fc129d7b06b8483d0136f6ee856af8db9b0ca2b554c227acb11de5154181b2741b0219dda1b36c2aa7e77c1c0713795b82788c9b32f49641297c385f12b527db9971f4f1360affd0a9de7e75cba7b6277638261d2108856b018e22c1126c501bdd5cfcea8144323d1d2ef36bc49cac36c5fb7aeb004dc23c3967457ad9f8c3cb0e4374d9eb1c4738150c95a3d1bf3117e836714a34885c8b907fa510b93fd67da4ace26dadff9e406253c43025ae8e69a49ede9f61735947d13212ced23a1699c7a1ed13d9919e812d01f6a22f5e6464a4afac20dc3841fe95411e3179761cb8d42d47fd542860f545b8b4bc4b95e29f5a280d4e72fa78551850a8547596a960c3e2a9ed8d4f361a4c3e31fbbb704ea1f68dbe34e64c6d856166f38f81cf1431c856e5d93345fee56cfd624feedfd8e083a460a01fb78c1fae704fd1916a0addeca1faaba17c42e10784b8aa6424c5430af8d8b43c3912a9f5bd517550459a93aae048bea91a2d946f0458411358df44ac5ac79f01c19fd44d839d9c8c5396a8ccb6c9df607b4aafeed3efa37fe642454c5a0a54ccb4a86450593c423517419b02c65df329ad1b9a5fec16136e0e71bf37d253811d6bac00c2bb8694e22d4cd4913a297cb4f27851ef6e3dae7463b756b45ccd39fcb34087778a9c52ddc226b5883f00a9d842c4bf17192d605e4ee6fc0fd7ccf7f54beca6de896d300a179cd2ad86e3b03bc6ebf878d419abe18957a802e698f54069d1c79de151831d01c27427c58c926f5e3c04fc2942b6d1a44454c5703d0993362890769d32b9016c37b680340b89d11c041e95c71f3f9a836d453f217076934d898df52f425c69d3b2dc421170c7c2c7049b0eff275089dd0ecd0fe884686a4008cd80ea44a51bcae0c4d21c8b4df759b6d780481cdf23bf280408777206d5131e6c068569dea875927ba31bb7e77e8159dd7ebceab484081539ddc7e65251bf636ce39eb118da0e3c5e1857b6abdc22daa68a981e418fea6d097a916b4a69b01c549a35eaf55d62c35ca21e9f84f9d2812f17c0e03a926f446259d59af1e0489165982d3489ea549e36bd3fd89ffe5c7ab539388831d0f2a6e0c35763458f5a397797ce1c904a5941cd729125cd2c3e20da2eacba6e46a2774c9d1d5d3ff6afb6b62146468692fbdde5f36cc423962c258a03e91cccf4029327adf22d6042849fe05b23a055085771f4a62e987e378b82d70462935edb6c468bf2e7fd71360a19b781da2fa51e9e22cac6b766a14ff73b2f15ac1219dd8916cea0cdfb74ace541c16f4469084397f1404ced2419fabdf194a80200c9b8dad5abd7bbf1e7c0ae6c9d2c1b1791241cb53e67395329046243cef4c1210e54330bea068ee9de71712a70a382d385869869a93c096a58aa1a02a8d5ed1f30a63aa8b23264e1997730253aa87a103fa990cf26f84c566d6d5133bf00ab94f3aaed0f1ffb20908d605eca1eee6eb06cd1175ac181f905f07526e37767c5acd0e7196dad5eea39108764c5e5cea82e467c576dcc5088047f0debc60b1129582d38e3589aacac941c4b1f4a41a2d957675d0feda1e677278c8da7afda496a0a7dc743d1580195bcdc16602fa3ea95925b59101b1375c64a52c394cc66c03d0b685a847fa2f49a38ef186bd9aaccd4b7194ebfc5a6157b1d1631a1bda60bfe565c4ac64edad5f00e984b78f4751d737bf2a097c6febf1ffe03c5f0759721290f2ae17c52bbf094e94f5436ff5dd3b164b337a4d0fede40e73c9659ee3778e17a8d14effc8dd9c34a630343a5eccbb25600b9088f8efded6be4f8e6a758e66c97c8fbb8a55dad82d193bfb5e910a900a925ae791311853dc441c255fee8dcb438aebb4a60e887178eedf59421dffe05d0e466c194ebf0c8e945e6994aac3cc8b9c00f6622432e8d6642ba5dbe652a9195fd4d3d7db52b2cc408b059d580df593d4609a43a6c12358bfd2081e860f15ae175b35fc9eb0389650fb77099a2e73d7e7417f116466120fb407fe3e9d6797711e2ef2db641c706576d5b6bd6930af02f16ee0b5bb4c1a5187faa5e68e73fe5e22f2abfbfe81c4af512030e7395580eef4b6a0747d5c8e14d02853d70576f02eab5f7c4ef692803ddda8acf2fd974dac14a27cc6d91ec32c114a1c14ea46d159b8984fe7bead76367285e5aa9d7cdbb283a0f96bbfbeabc19ba889f3ca770c4e25df0c1b4f5019d3629700b2b7428b9be93d673cc3b32e4532d447fd813b59b4e6c12784326a06dd20be27751d8bb046aa6fac992fcd1d7a5940d7e715b478cc52ae520b948058d54bd79e37c312f6e1c1f8ece4d99e404749dbcad21bf586ad0cf70cc6cd1664125002dcb13ba05ec23b9d80fd0822b9e55f2588fb89ac96d72e7291faabf72ccc7edec5d95b868180b7891ea1597cf1b29bd6e9f7532e9b1917a5fd52f48f4f8b6358efb7b5ecab2090d45132c65d3b738a734c8928d6ab6ef8a823afee0ba9351ab22bdefb08f1a054a4c136697caf26e094feb9e2735e1b1e5c6b1758810ecd6f458ed48e5cad820c490c4e4fdd60e9b3e005da88207fa798edb2ec5610d5a736d7f8962db1215df0740d66cf3c092c549e26637e4d8ad0e453fbca80000b55c8c97c4bc9faf1fd100784e8d163ec99442dac218c7860994e703f977fef2dbfe627f856f1fa7e9d776e90216911e44c139d224f8cba10354b3a99584b2112d380497e6ec77b088f4c2671ede6726549a87eaafca321df416a619d7c8274f0fa6e66fb6938cb7b7a81d5fa1da8ccd919ab63f7b09273b170c82ac18e6a93b6b019404f811cc6554e72835e184adfe560c7c1616bc684f0c42369a457383662f8b37af62974f18e19497a90391f73142be703b00531cd958afad23619bc702ca88dd95dfd7bdc60498146784f44deeb8c77ba82d52cb03e3ca4647010c41c7b3d0758b0dde9ba1077acb16b33ca8d0605d210e87cbdfd678b475d6ce33e02ae266eb74c0adf59958973473343596b6a4b527b36aa9243a48ed525106d142305529e3197db688970ae006097ede218e34fd433926c9147d67a01803fccf2eec8d8cf3e80016dadd5328718f5eb4899a825bc13981e5023e4e7bd07894791ad40e68679fb6aae2030c09fd0272448db247075459325164655716b491c8f11babe2d2ddf443f63aed3450bdf8af14461afc6a8a666781c86845ed01172506da9417105963fecff0666d01aaf1dcd9c61f62598e5240684730b9e748ff4e4c586f3c8b8ee470e770657de64bd014fefa8efa512858519f70c8be716c3f7890b815e8e48905d9162e64cfaf19f5487780668ed53671246205823e24e351ed934b97330ff501ab85f012f0a428f0bbed75f4a6ca0b4fb55807408afdf16a891b8bbf3b7a97b00d9bf64f12e51229843277a714f26166f431e67bd629e6a6404ed784a150deea59c051698c3735580f06426d696bdc43470ed6f6ba5b8f5d9663111509c47fc19ef328c3576ca62e9c2ebd6d7d49424a05ba9826b2b47c2c25a26d409e698b401e2acb4b934c8a14bfde5b4eeb36e82ffcb7432b9f3dbe371bae16f48ba679bdd182bb99001ba277de6b17ef922afa0ceb1bcd8245ef2c97b9277c4f832c0caae148212b86a43cbeb75479bf152c9790093569becb4a7be4d59966a03a8611af2cc64501ade0e794d7976f5f5c28f1fe7c0803353d82906459b82a3be9b35d62c6e509be252286f7235ae53c11d6e2eee39b590d0d31f054c1ee95b5ced7894374a67d7c40d7a80853dd594424aaad59cd0f8c018ea4307ca13e6e84aaf24ccb315d03d973da528472c6ef8748dcd173408a1eed78b4c13a1d6e9f5c41b07f41adc7a800d952845d60b4aef5737b32f233f1c18d672b86ff70866f02dd431dbec9ee9f2aaf2432e05026f1d26292f7d2137568de5cbf013266a25462cc54d3311cd90192d9f18a834ab238b8125ce07d42eb701b3a9a1d5ae10c46e8ddfaf292710d45e15caaab72aa8be2354888f71393f8f2cd4a72c58b57afa20be7cad45347e51104e2ac25b49f59761f0b90db12d00b7633b832dfe252d006ef43f301184faf5e7f3977f8c2ad5d89b8241a0d0434289df613345f2aef21abc44d68b435f2a1fdc2d4e6e05d2bea6fa3a56ff5ccf27f9174d1047b9f60202761e62080f1c99d06634809204cc628377f5f009758acde35bac8c13c206ac0b007f562378a23c0c6cad17c1bd9fc30a1976af719c0fce36cfbb6fef8fae76d3304e11f5c1b82c51fc6ca6079d2a26e1de7a1dfa6cbee0dfc85bb3e6902465ad8181961b0141e3c813138d699e65f58f7ef235841a18493d518dafc6c80061bda1d8cc4b7856086e53b4010905b2f76359fd4d894bb310fd3177c44b31f3e98bd7331093cc468ad7ce9adf4fc38e0b7e280d986e5ce5ff92a4becd9ceea184b4a1181ab26058803eff06b4c6d29981bbc0a20199716e9f22ab9dbf2760d52ccdb07f8914157c79661a00e841d8a4da47ca7d6ccfba1a1df00b0de7ef61abcb2e65197c9b00f6073a6324cfc445a4ba0417aee695d9bcbd09c44ebff0b3bbcc1caa06552372040b642e07fea4afdb23fc186a1577230a0bff562e0f2bbc4cd674ca8e9fb98ff8b6f340324c9860df67a4d08e9c0b0b7cd173b0bfcc7d77cfb8c4f17b251abc41755a2d75e586ecf5d49dd4604c931eaf111bd7e646b3be468b1ad06cf97e7d4ef44dfbe732e532f84279626f7cf168e22de95ee9f5d03c0cb5b412857d78f0fd1976b6d4ed81196dbed8f0309c7a2b9699e5db51b5c3d4cecd78069e3fab8aeb143de17fc89544b24f7cc28439579eb41317344a699d5572945420e0ffbcb2f34cedf852f5f4b8ef896a056f78bb7901ccca3b4f586c2def5f48281fd1a5075360fa1edbe2bfc0742e0fd5936ebd235de653b59202bb19553194c3bd13410fc44c3779d23dc8bbcc2bb68ab5876798b60f1c7cb240cb4405fc30e243616ed6d23ee8ac4fb65232b8b4e83697818dc9cee6719a660a7b69cc53111cfd7ecee14470db91e8a4852de85b071c8f6981a11caa34887187ab719486fc7bee7c267b15c1a22e3349d1049ecf28d3cf35fc115a70acf0ff5990aa23d4131a79a0b39fec15dff1705b8c26ecf76263cd84a8b9c2e08f93783dd26310d66974ba93f8ebe0811b3592a58e07e92934071cf90d9ea7c583dc3b294bf0ab7234226d2899e8878d139367668213f6c8d999948b79315a222439a56d12cf94b260382568347a18be26779de4f52d9eadb5f20769661e824e3a084a73f641870aeac0e7a00932470409c29fdd131646ac05eb2d06d71e37b269e12c28e0459df0fd04206ed79678a82d37f917ffa48a12c96aa90083c6f9313828626693515e57f5d0ec93876f7ef8d44d9fcb6797915f9783a37f2f8214dc6383437fd5dc7e533ff7a13d4b5dce917f17bc434d644a46b4b9e07bbb4f6fe79591dbe15f430d4cf49d839bc00cc79f8d30a1334687bfc0d5c83874c3ba2ee83d78667c2e505bb241cfb1418a4c5cf4c97b1371f457c20d41003034e48c6db1de8e441905f7f393fc8e88264f436d369fc6223d060b9e992023b0a99af9f7300e7c04252f10efec5dfffe4b03814a09e5f00ed60663983c6a097eebd6ff0ddcd432cc17953c951a8bd519feb108903c701e44e8caaa0eca8175c4798e052314cc2eafafe4e068b1c27699b3ea9cd00ae0113259ed954789872cf71f36fd7fb6f97bd8ed989219aee9d2bc77b4c674e402f4ff4f342614fce34bc093f9ecabc362d2000093a3e7f1e3edc9299279bd68e225c610de4dbee64e29c73532dc569519756382d016ed0ce4088743f502237a1400eb72c95ada2ae33e55746b3b4ea9e02e504af72a137837e4e6362603e451898256287f9c910dcec54204f035f9c76a96692780657f1ae8a045ef1382686a0bf8977061516b0f293267cbb1effd0c21642f83d7a134f9342b5e691bd62b43420372997a9764d137f39dff39ffe4aebc1e7ad55e34c386ee955806c9b1b3d305511550bbec18610f50bff8fd17ac28f4d1f0c21f397a5f82bd834096d84c6318cd9f789f09851555a77597be3386612f366d80430952435a570113ccd92a4cd0ebbb38f7684731ba4a5ab29f0e856f2e48fb3f12452578ebe82a7212be66110603b4d7fec0008f28ba478dbc31b27f6b191a57cc990724505248b2b71523dd197de31c2569401943d5087f2971b6126f3059c87a4adbf304f92d63cd1ceaad4e57bec78f668a10e790c645634ec0198cedce6796bab1dca4849a6d647a2cfbe6611b0bbd35e003863e8dee82813f80619a2b80820417d8d469d9c54a88707d6b4e1d46a1fff88757e56870a116da940201aab8feea564a773e25d39442b5f95dec8528fce3e7bd28597382f13416f5e681439f94e3c6df3b730128b7fd41b0fad01484b11886a6624548a820ef815d0e51144372a2cc44aefc5e73fe445311f6407775a8714bf0bc3a65d9c28595c367ec3904b0672ab224ce18fba86decc6d66dbc722543c3566e6035545adf1780dda7444e07ae7f97affb3be56cdcfca4167b9c15474005a39d704584b725a9327d12e6d70704f951c80acae05edca3f231430131cf7c0140f8f151166316149f7fbbb7b00ec7e00280bf39bfaace1f04d60a710e0fcc1192e236c702b8ab82baa33c1c3666951c9f3376747674376d9f3db982e949ddc75e0277d28149eb53c130bcbfb230636163bb9cf77485dfea84fc1218698187b080ac655309078ce77658a88c0cbfec8219ca5367342a30d3f87a121572af0c9050f7de1432bb50046beb76a13fd401bb966e19d8a8d4d94365edbcb8364d2d9750acb2660c115040c80b687d8ea1300bdba83508cf2987e56b8456d10d07148b25435f34ac3fa309d7c87ef567419f7a5f650174ed72eea1fecb72aa884afe8ec596b44088bef4ec1efb397bacd290ff975a47f2a5bd2f643e559a819d9b8cca7c07df966c0bc13b5496da293b8cb6cd79f63357c83e4cf2917e6dcd6a3fa063be063fc73cdb2f7a9c9eb0c574c4bf57145d429267891ec6b3f47cf750b0c715387492101631e2842e815c0dd4eb1fd8d5070e20cd0b8ac58f83ba02fe7f2c96f125f6e290d19cd1a92ba95e11c1dc303c210d499ede268721bea0c64af638762d2255cc4d7278c3b32e823842243e043000a20396bd5c3f1f38b8a14fedec7d4c272e3f2025a2da88c2a07c9e311eacc751362dd97988c3f41a136669fceedc190a1db97c7d98cd568b9f31995bfdbb67f147f7a0300c87a094e1a2532048ef7f0b140d92b218f290ce20cc043c20029ac308e891b0889f63bd1aa3d583b869c464976a4e744a2838435e16e8e7499e448ad0689d79a17b8233d0443778142a799d28126590773b2c245f1b6ed688db7418a5679758d85fca9db16eb08a57262dd36835389a5e0fc84fbd5928cad1c094fe8e65e46e939af68e8e28f7b0eb3ef86e768624090e69811cff2ddb082a75274965cc38ad12af58c8ae9afa2a4f6bf7335f94d2a832734c16d1fd7b34552a2ce6094345f9876a489382d6bb79ed11c202ed0550bac016f5996dba58a928119b3fa73c2b8d4ccc899ef760be9651fa02d79de7d04d4976037366fcfdedde86d1d9e2982718ba01d13e918787de8dfbc39f04a0ae8bc070d4a11d0c1b6092c676ebadd0e65bd6c9888b712c08100933304eb55099e241af5dc7e454aaeb6e2657a4c2b029dec6cdfbcf54d950ad0ca9ce57902c99820158732058a1fbf5322dae7b9ec808d6a0bcc64f1a5cf043528e39508d75d59c3fda9eedd9959992e92cadd490cad6181efeeb9fb8fe695b676c84223fc1b043e823251ad74f38b06734f0295103158ca0507dd4985780c8e275ef6575d1f05f0f96f40f6d74dfde3f116c9860ebb2f43158f088fc2c960adfd8d4d6e35c9c41665a223155fac733694e211ca837ba3f4732f93ba8c3e45e556927e6f9c3a6c0f1a7e8dcb84b72d7b890817bb5da6f73b3648c283ede1c68c207aaf3843dcb95cdaadb6a6b9fb4aee34f2ab381af69509c46a6cadc5e17d4c30aa9c9185d7e5e25d4ac8ca21698408509dcbee8027baa617dd6b2b260e4eef6b5a8f01619c960bff67f6ec93d374cb9c1a77f4ec7b2ed4091be1931c61b75ae515a4dcab5ee5c316886a862272711e3d10e4d67f371854f75345868272b610d23a61431d947286c326fe89cf63f2bd6a38fb6be024d430bce84cf2ea0035dd0f7e9d0e54798ae34a2ec5260a258b7f79e02606590fe35279f099687b6d0a91ba68b6e10f8c5939017f68613d1c73ecc36971e34149e637d9b63edf5a3f8cec30d416dd3c10318ea770508e05129e7460c9f3f1a527acdc9039109462a1ae1bc9710dab478ddbbe7b479ff699b164bc430a9443f9834c2caaabc8f6e8dfb4655f43f3e06c4d0173cbc3fb31970abdc6c2c913cb89395586bdf2f9c4d1ee71f2db21a2ee5be09c89b6932bff9d1003fe3db86e3c0cab062ea02ad0c189e118c7c6383b1693997feff1dc7da5291e515d1c1c892a483ea0b43520a4b337759d5c03863d264f0ee611c8b70529986d683c244f2ebc6fdbbcb002d95d913786a471d75fecefc69b1c5f48b0a4db9d9f2980ad3f5f92206fbf54d709a709e89804fa72ec05b4afe033879348e51445379d311fedf0b9646b4fb6689dedcded4fd64d49a7c9ffb43fc56e7674a51a2a1e8cbda8f07ac24b44e5d8f732364b53f714faade14eb4a35fc705121d9184da20a85e2df09554ddf466cd359bbeba56fdced4513d2b3285ac7274229e6ca41e6d4474e62b6ae13777d4786c5e70b44b73e6366f3269e3ccd4355094492fbd7a189ec757f38d45a74f04d4933723adb090617dae8cce9d074bbaca7ae2ed12659bb401cf2d3479600170b66395af0a7c2e4b340eeb729731c8f80c2622951d8552b2d3cdd3aaa75896107ea218d1b7af4a238d6442a6e7f4c65d300d357468cffbe4936c7329485f1b4b26e919d9617588df02625927ce9704fe877b3d97e8783c4651f9afef113c21ed9fd52231ca60ad7b4d574caa3a4f05db2b75cdf1d38b1d949fd5bbb3e5123d397c2c71add5f8231a07630baf4eff9137f8126e59435f8af99ddbe26006b989033dbb7aaf435378b4a415d8a7d33032fc72aa1d502952d246fa6002263bf822dedbe462183762df5ba40ccb6fdf27b82b4972cb9e67f12bbaf2440bd4b4f5a8555aa2850bfb8dad09138051112195b66756f8dcbf0d202b589854838cd013c13d6d69f080ad58ddffcb3fa9dc8f50028568aaa9190af050d4d3b605c011af950d95dbe7a7b9148db9132866ce76e9393031e7fe08d8987a09efffbd7ced07534c355861194c2a7f6b70a7f045169d38a217899cbbf4606c02a502ee0c4184ab0d7d8c87da2a039914e289020c5672a464dca0b8da245e4e92fa726ce58d34537e32e4392f9b77651edcdf2da941ce632641227a05d5a72d7d61f522e454328380b34e883c3f82928da281540c49d221a026997f1b1ff67a30e8428ede2afe7858bd233d7b151471c2ec612f817f3acd88d29958573eaf870b78a14080607df468cd1351fa031d78c9ef9cc8f6523f199a4f8309397c140e38640d5f795798bcff2cf873719940c33b32f300967533fda419578a40e096a912cb1723fddec31932fa068523ee398eafcb290ba8f33334b687dd49782c5b5a238cab5c9031f158c9bf671f91cea4bcb8f19bf0ccaf45bd4aa60aa7cff09b05a6d4a0ea276e794a3f6e650bfb99bd5379f4230a82bfa85b94739b7645bfe7f1a284454297a69ac4cac782c7b47eacfec10c6489f861ff16ceaf2f82e2ca304c97eec6f04edd05207c91860647fe1b89c29d61f23b8b23b8a0b3b805847b42a4adb3b70f6b8ccebb691b2d2f62e32d694acc579ba83d2b5197fef13076c0786e86bec2d21190c575ecf18cdda0135d32998da030b22b29b4a36fbca9de2b8482909efaff218eea34ecc9645d1ae77d1ebf8f9531fa5bacf7b259a107f7209d9df1c51a6f313528613cfa7833c5efd98d8d9d5471b6c9def751e67658179fc7ddfe6b7e90dbec00690814df95a95a577f17606599673b68d261781b9d9073b049451687e35fd12a3d506c96eee354b71cc29f58a2dfc9e76bdc00824857dc3b47220aab7e90145bd274a8145d771e3a2de5669b5f98d1ebe9a877d5c47de51424ec286a8a101eaaa2d49f7d33f0b462a0fba7e2f15948cd3880ea4ded7e0b6c90aaf8f5c6e2040b2a78241679d63f27076449c65031b1b886e1d36d9458ec9a1f5fdb6f02483c4a6ace842167f0a89619b1b85cc9b6287cc716acc2fc751192c9ddb63ea5ed8de86879d8c1ee540adf308a67ea7ba443673249e6ef606a1ccd6a358f23286cbbf0ad2a6aa3304edcabca1bd402d9bcb9a6c2a5cbbf6b7be00843a8d56299156197c68fd033020c0d060918ffca2b01170bb791e631befb321e77346e8e1914f40dc44e88e571266c3b334771670c38ed1612efef026d757c338facad3a5ed8f572bd1221893af013d632a83202edc33f861c7170f682a454eef75fd22e32d8b63249a84f155099ba571421553f91c9233edf00883e7941b36d7e53b96ff29c427d052a774f592115408cbff4688fa6ceb8ab318dbac29b7f9cda09d2d90f224faf133d7ba6321ab6e06f89cf15d4b78c8f93c57669430489db22dc92dd908349ad985ded39673a12a439ddd68f1e705ab9ee414159d307321952e2ef578ffcd9383d3be777bbbf94b886625cca82be1972d693c290c079582cca6b966eb835793aaf2524f4a6a1ed83998abc49e6c49d83acc49ded4a4e44afcf07efcdcde3f0d120892b1bd29303ded8a0a8f887de06d792be48b42645a7a6091e28a524b6e1c1c37a9e2c9ed833d64d6b728975f628caef20569cfb63f7f70317cb422795a8735355fa779be3c9b0275bfbab122ef6c1ef247577e840ae11af149e42d3303d628d65622f11ccd8dd374d291397d327d80192d92dfd1c372fdf3ad4d33adfe333b1a642447b8fe0e574da02ff90a89f4f57c2fdaebdce9551cd87cebc01cbcc2b058fdda90624e9ab7738d5c25a783bb069b7f0a1a27c105d943cef67e271fae552ec160a175bfdefffa90589acfe1408723ea214992766cbb4d541732b73098165d00d71c2932fb06f7f70680b1e68d5f124df2582055c099293f9f23eaeb3728f8d57b4533d92e14ba777b9546699892a7defa9b1ababe5f59208d50fb1284526c3ed62c929cefdbfce227b36eb166ba3f2081670099c6e8b75519aa9769564027a21db56b0400d1812f382b56a0dd9a72e07937b32cf3a629a35e8a97575f5005125bce19fcb28483d4c24a9c32b99c64c1cf482f90e616fe6814bc1fe866583b900498401c1e9669c95f63dbceee4535f6b72aa5a22520a1dfce337eb7c0aee43fe7a0dab94e12c5c746370182f61e503bf7a0cb6f55e70c81296639bc7aa2bfce67181a13dfe777ac1b09700ec07d607ce8e35da9ff440b271ce34450f3e27d69ca8954b71b3cb461d4cd9b78b51c71cc037a5de0d7fffeb7cd9ac92398c532ae6d4347422dccd724238b1a20c981a9de44b50ce5f729467f44e5f90149325427ca1fc1cee8ac6b27a9e709de0c37760cd5520224032cc1f4218f8eb00c495f4ae81c020606b27eed6b0b9a26ccf48a03fbf700bc06dd7d03426b582353ca0522fb607a639e9ffff0c3c03c266933cecac7e928e820dc9402901e63f7613c963d33a8b61230e87071d821b668c9bc72e266a4b6d40011a18e4fc714b58be93f264bdbca875e9974820399feb6a78a1c1fafe52e1ee10274a9eff51886d4a0869cded3b5400612e9ce3d38487342043927561d4261355ae0d067a1363f1eb35bd30705f72fc7ced702f8c907ddb756d566a94f3d60c215665366457f0d0edab6dc979b3c9919c9c5bdf00e0a6edfaa3d0846c421261f92538e7d1555b2896008e97a9762b9a83a5372b9c6448ea05ab248c8f4b7b50a708fa57f655a48ffa4ce334fe19968cdd94d7c3605e390c94103c0ce40901429a4ee4b63e36afd010ad1060e2c527baa49d45a52ee759c2f2a23a17326e79cc8e2dbe0680e8a1e081c3d3102ad3e046d81694c00a6a59500af402115ade0b69e23c35c513f29236e6345127825136880ef83ddf7627cd5108ddcab672b26b1812f7c5d324ed87d91b297108458474b3bc62176271b1961986f8bfd453b7e284a13f34655c06c4bf57cf4bb9de60f1058016cebd46719a270c23bc5b8fac2b6b0fd793f1948066596dd8a54beb120fd14ffaf9d6f820c62e01040ac99ec71c548be8e0723730596088f77cad02770e144399bd9fa2516765a87f3912173122e9d77d286c6dff8e473e67a42db5a2b18d7fa0f698e8e5d119d04104870985886d2408417d606c92e36d657147945aae6ffb61fe18399456c53639425b54559726afdc128556076426ddb177874399f01df653fa79596b89177a19eeca89a57bbcb1b0709497f7a808e612569b750eada36f8fbc917f48d8b398d9390a416e02de6f228033b17529facccf92de699c43c8715534150160719bac35b373181d23b13f32b2bbd84f9f738c3688f6f6d9f1edb0856ec974ba797d892a78a66c115ada0ac34bc8e466d483fa18614f6f905524e62726a4fbb29367577d7b86cc20d324161d7eff933011722e4b258cb43fbf1847e4e43d4a77b5901734d9507e126415d56e0fb69d36dbcff527d63b9f9a54ceab8ab337f58c4f383e1a3b36fe2557f22d44932f57970394f90a9b6578060348458b5a76754bc3d3313f4d2d3b87050ada14337d8e840519edd4fdbda21e428e437e3255535d29048d7642ef7adf41427db7063d9ac2b418c26b3797b932a6ba6c9d8432ea43680e76d668503ac5923aa7e8fcbb832b3cff65398cde5bc342f371467bf73fd19acf3b3ace6613463d8b2fc7533c9f2d6c2ffea9b8b89109dd7fc27ba27d7eadc667adc1f430af611feb4558a162dc495912f2ad6d8f3b6dee62b861f8f3b6d4e2144f4e97ae0c8c5a461e056c0b97954a0c533bdda1410f77203dc48da5b9162ef8a3097e9df32fce0f5818530bb73bf8b05bcb566a4b41a09c7092b6c3f695d5bf41dc624c3d2762571f42c79b7bf819d1d0dbf36a9e092f3c6f5cca158f4aeb6e48f6e535ba45216f8d175376659e453b086b543364a3c6b00fd874b0f580acbd254c9255dfcd2329fe8f73e050921d4a3a826bb1fffdfa1a54619616c65718cc4013f26812f849f8e587002af74ecf998ca75b1f4a3a336c5575b465bc42d6204847b38e6072c67d343e2560bde0e17ef568632088305c32a336fa6f0f896c2e6128dcf5a6dc784d76d8e836ec695418b1d6d9dea7ea6a376deac8e5c6c8c6d865b80f8fb94b18f3b7df466b2ba00c1782073b3de126af9e4f7bd8f0096e0cb5b13ee2f1dfc72d82a3bdd71f614d95946193446c21d7f56945f8e7e2cc3fc7fdbdc53de814cdde3a714209f6e3ce2c9392182278c3a47b901812fed9b6d35975f09dd651d1ce870d0b24e7e54495230147b7a99ef767af11a2a0397c9215c6b08ed9af51cfae2607327a7316d4a78a592594a880e3b0c4ad4f1b322d1fc4c384bcd0aff71e4595f08b418f386a1e323c07593f80f540162eb023e85ea2f5268fc99d44d819e193aa3ed87226eea9f7963ab34ede1d8e58673af845e02a8f9616d79f18443fc2a3102683b6c98407653a68d4f368a0459c5f1e01304b12cd92ba0cf9d611c79db16cc0ebea8957909ef303f014cdf9c42042b34925f4eac0cbad2713002cc51a90c5a49bc1c563aca185d3c0fddce39df60a00fd6ffdb2cbc7742d17ce540c564292b585c518d459d31bab020c5edc167214f0efe56fd725da62707529d29a62169c497ca36ffaa9de0ff7f66b2fb2ab6df0ff16397b4c5a694fe15fadf33fc28f1934b8022d2041e31c0ce2e4db848a5c37920cd83fc2cb853ddf4ebca455ee214cec55ede007dcf3598090b5e852152d37a78e5ec4c729d0ef527ba47cddd4ba2a14d3c8542ac6e49500cb8073ab64fbab650096f87ffeafa2e967d4fe0c541de34497deed6e626aee2ee549f157c093ecbde705e86624da66af531ffd58c30b3c576974a85da587bc18348120db29c534746c147e874b27d61ec9114e5c69422255f5742d8f984c30bb91208072d183f709e0b67d6c78ba1cf91156498a0342eae04aa8c46dd9e435dfd7d7dddf9fdb625132b28e09807790debc28bc7941ea10265d7c25301af67d4e6a49cda0adb27ff17b6b82d391c950ad1edd47b949e48456875d6855a14ec304ad561a62cb5b97c473483241aab9a820cb715c8a32ddc24e039f9acfc7e3a7898b7c886df9f8c8c5f89f99f81e552d09213541948a904e3a71f3b6787920c310ef3f7188f1adf8358e3a0dfe1664d2babe79dd9cd1a252f956750464ba83bb564baa133a9aa282bbda62b2550b706ffb065b3399fc4b71979a3f1e1c1f8f857315d6a6b896d55b83268697a9501a6fd19e91bef3f2d10f5b089625e451052203468b81ccb5be8ad5e16410b186c2a20ff45729bb12d3a6d3d19de0a08f787517d9ebe8d080c121221cd33748257d7460b45e0988ac60e1d409a6c7242929135f5230589aaf6f25470d09b960fa59f1df54d1964c83e9947b29004338063415ce34745372b39b08b390834237a3fa6509896a8fed52f4db308c689bdd1f115cdf8a9217892d3ba812a1744483157987dad098b77743aadd1ef2fe5efe0262cf355f12b9357519f16ce3c3dca8179e6293e6b2ab0179310cb2ffce3ce650107afe4623841d145a99e91c9f124fc4678b67503cf3cd88d7e390bde898ad3fbc9bf5d2a9afe34acb9703b69ac31e0de046cad439880df70b75eb16095bfc187b095a1f5cb552890843934062e4d83543a9bcfe9544b7c52a43235bd2b95bbae5776b48eee008f76c42efebf8f6645376e2a99d95e744e1164293c09404a415778849ee4ee891f0d5ba5e0e8ad8f2d3cd32eb435ca5cab1a4fcaedda6adf1b03ab42ab8f39e7f8235613aa3c948cdf5234202c88072ca8cd42dc72e4e17f324cb6debcd351684f0f45c65c7e4cc044d3fd3f5c7b17d5840dd56819437e54e9fa014e75bbebcc73027243a3e02d0ac41890d021f6a89a28d061c77d37fd45862af93e514034fb66d8bbba2ec5223ff8e14d7fa73b517b0a7537281124c5c494356c5a9acd2aa45855f04d75db23f5cc4f3f853ab049a3db8fde7ea5df298b22c9df6555cf1d7498b0202273ed7eac8c5df07c0711217e95bbe912326b243fb9ac3236d62c5d7c14667414ae113223c4a2e4bbcb5d7f88222ea6698c0fcb83e1f1fc8b07f130e29b156cce8bda66cca5e181c2d2a90f439125b16ffe34d4f0fe0495b7c77cb54c179825275ec9af77de1507763c6ce3e85222b9ebe2b94803e17a1d58895e40c7a826772fbac381d7506ebba8146a27d24c03e301c9929a8fc9213d633244abe9063004c38df053ab3d590ca3aa7c92a494b9f2d7b105c57583240437ff7d71848e547c72e8a56f1e9aa091454aef8570199a5424ed98582636de481ffe266681a878b386c596d4363b4102e28612c074873f4ed4e20b6080bcd9a9ad73ee9cd9cfd8d4c5d1a2c171f777b0ba58c0f89b31543fc2f74e957fb6fe9e8b36997cfe0ad7966663e5419294ab0fce53e6f9396aff7c2464bd22fc385a02d6d442c128230a3d9ed5b571326da6cf99649bf018de69123967b31c5c3d4881e9fb3314db6d71ba929acb71b1aa5dcecc3c5ae71d953e5a13dc3bec7633762cd06205dcca52414b74d8ff8417380fffd938dcc2dad0324178e40a10c691a3280eef9fb0f0b4c0e8eaa061f987612600eb6c03b1870f5b8cbecf877df52ffe1d4452e705e98bce02d6837c2bb47561ae9f0417887629ff2013d53f23b0dfd2d4a46b4bc58ea918886cbecab40e51d32dc5e382b477f6a7d3bbf9cf8715b3ce387ad0422e4de1ecc8a6014099f9e8a39b659900f2f5831aec3348464f6e67a6e00a89ccafaff6aad04f6402a87ba9447620176e601c4c69c489da04962f589bac57f7d873552afac951327d4bc3e873e9c94e07b86986d0e8d13e6cde266ce5eab04ab9c203fddda8c752220dc0c8362778804bb0c585f307d2534929bc4c41d106cb19dad8314bc7c25b0eca9d1fc3fb168dcd2d0ad49223083c9aabdd477b3e8171a5a54032dfabaf9f4ddd19638e20a10a96aeed0ca50a007ca2755600af4e54df9d9b42032e733a132ee3321d45922b56de6d569f89f24edbe2d0f95313ad068626accc4e2cf3be4558e23a84093869d6fbb7562dc65f476139e7ab3b7257277eeb90f8e2e1e486e6c563adc3e7dff05bbd4891df1344078974f8588faa9ac8d3b05fcb8bf4bba472946a0a6677f44f4a007c3eda976a9e8ffd637876a6c8e456a53f1336da426226195eb83a6409b333098b849e8d5222563dff1350e73880f9fc267f8c9d8c0bc8e14fadfbabd18b3c3cdd52587798393c012a908fe221afa85e4d1339460d8f1501d6662b9af7ed97497b511d20e571e7592ecafea8e8e8ac72abe0246ad8e71e71279ad8842ef27a2409e320ba4b465c6ffae5a9115a51998630981882c31c9bb72bdab631bf1b171350ff9e55226915d1419674b503fe82c4634baba1ae119d574922a5baf7d8647d7927b09bbeb65c3cae68480516ec93d0f2e956e2573cc633c632ad3e913234f6146b5944c21a4eb16115a2f3379d0872d262febddb0a3389863ff0323096ff9dcc982976296b4a82ec65068f5b6ea4bfe3639abfb65c94953f4177566928a78268a1c962d5c603262f253d2ac55aed099fbd4dd6ee3d5311511008b0940f2420197f90a6e57a2a684dbe5260169f0ddaf621ce342e25caed26903f791e514943c777adffe5ea283e4902ab1fbd9e5417450f9d550f03d21ce09a240ec277fece7ac77f62fb1902dd43136d62512ac4c9be131fdc1d0d11228aee544f22b2d8d97dbd3a4f0c9676dc24c2d8af77b175366619659627a11aaff2d88b1411f68feb8c27d32cae391efe2d88bd795328f2fc0440e1dc39dfe382396c58a6295d28bf77de25baaad0ec2668c3559e17a8ebe69bcd92e2ddde8ad50daa6a83df3ebc3b0bdacd07dfffcdc4491c8c4d4df1d6136b0bda76320a61f063e8c36e36260f878e9d1b79a975b9492da095c330c377d5835f85836ae7749e2d6c034a109f0c2af5e5a28fb2a6b266c9c287b87bb8ffabdd1cb42e4f5200a95caeaf6697a957c243d06af47525b336da8040e715cb9c77c1e281c4e32a8e25f2a3ea28a9ed8c6ca73eccdb11dd33eb9b09919443edc544f9b76d1f8505478268e72b5b18ee8017fff75779e59752f94b32f2ff763961621c5da00e0c6be160fd19d7f45162cd6da8da39520ceb7d48a11f7fa6156af06abc1447b183d3b2bb39140a20adb75af19f65f844303445b2b1045b9cb8f632220328ec8423f6ac8df5703971a63ee3d0d3abe9525549fda4dcbbbbdc95a03ebe9fe78a3cd558724e681dd292a7313f02101668ce25a07c8ecd646eb6d3e82e6742ed07a0836e6187c5ba1f71f7fe18273bf1d214eff46818d13fc3dc5515d1b0d191bf005f21da42c0033f6fa26596df1fa55827eb2c7c538779e41a610f099ca8b4b5a4e52946858eb01ee08fa17709360d5cf26a1493903cdb698cf8be8f08dac8f4562c3762cc657b7f86cfaa80e9e9b299dc1e67ce425adf478560e0db50cb1f8ee0c81b158c3d06d06f69a860ef7204d748b0b2db4a62fd02b6592ee02eebaf7c886e9207cd496305b453185fc896006514d57cff7901b338e499f74f3f66acafa67220ccaf5b9f30f451682a7bc0ee125f7c20be2bd944693d36a682a47fdd0de6a79f3976b0bb08ceeeec0a1f37746530a93470e2d8a60bf0358464ba5007084fe2ae0de2249d01461d755c226102636d4e44ff5ec6672ac092da681dbfa8f2ca978aebca124a738486a58a685b0d39978b8017993c74888929a7bf7238c05d03a393ef58707386292de602a2c353d3dcc41345e4636629567ee4960a5e32c98cf4c116e9fb7364c77b5fdf2e66c5d56ff8939cb532f21a75c0b2770ff96cb63a29ea2b17c3cc487ceb265e6078dde0e18ac00cd5af0a3a98e001361e72edc45af9eab6cafa819f6b519a7b14a9b32013d3644d503d49a18f2d9ba6fd4fa3e03265da1f282a803508867fa41c97f04c0cf793635493c0c863184365cbcfd6b99acb1edb84ef8cba12307ac4a00b1c84e57d4cca64f4d1318dcddb2eddf052ab47118ccd95624f0c97fb645c3e3ab60a63a3b22c4cefa4c09e44f426aa741ff390f2f3d933c34cffb94983d6703aa38334b946890092ad5256d873f228fe387bc3cfb36c8fe234a40922d7634bf4703551fa587ee56ea6b4feb2ac7e523a71f0a5265137e8a4c2df263ab47f08b0c3be33ca3d7253a0699fb90a4ce880f49539f9990415fdb1d1b418a70a09f4707dea413af5c620b6f6ab40d5c476535445f3073fb693aaccc9ab13f8b070e9ef06bd5c7c387343045b8979cf98ed8de65992346918880b7d5df9aef8ef14c7d850ba6cce5c811e47eafd6628c26c3f70a03124418fbc88778d9a7fc31e52b9a0be0bd4e9a2dd0906fc2371eae4b0b5b186a4cfba4254bd88b1b58d76d62c3043204b16ef1dd2eb7b1049323fe97182f006f54b9fd1968854d3c80641b5cf0ccbf53904bad894967356657ad8d3c5952667e60bd17a2210d1055c7b34559cfb6c22959dd4fbe27497537067a17c8bed7354ddb3a18299d9fe76d2806ad0045ff2f7d839f19ae303514dfb4ba1ca83c9339aee32b8341a4bfb8be742434e678302952750b4327b05c65af8d5141be4db689a8ccf381f226734adace0532ef5306574a0be3fa595702a1584c6081746d7c608e9bd16b89b4033e0a2ec6e18707630c3b184bf392b8c2c78ac4261ab49ee727748b22fa67054f0e5ddeec6a3185532314deb5873fcd6c76f85b314004e58cd2cf8c74d22a73a7782900033ca50424c60e979dc567716a2c128ad7fcdeca70d138bf68508f7b44f114057ab1e78184960ff00ee249e5b8c67f5e0acdfbdcf33839fb65b9b2414305fd37e242293abde4638903e6e94c713194fa72dbe82bcfe6e04b1b44a00937cc7d3071b04232f3e885768c9b372ee191b513e1efcccc20bb536ed29da6bf49cb3161d8eaedb17c3060c1cc05e4f9326bfa72096e95598836dc5692d79870eceb318c6baf9ac145b19ce5c3ed1e7ba67f0a7694fd246e530f24a911e5f1cf1768ce4b9712e3b24435e854e84d3c695970a88f7cb5502dba8f14437917cdb11ccef387a7723196fe0fb7f391a6b0dc9f5d27c4bce49abb2bcf88b2f63dc991047e3101de8c1ec61b5004993485eacfec09762e4fd2a3c1aa186cb91e56370d8242e1ccd8ae6b5b0cdfb8936ac84ea24a41577b7b0e3aeb391017cd1ff6686771e781d0483e42b5bc40e423cf6a049a6387d56c752fcd6c5869be9bc4da8d05e9eff049f8108ff859e5b4fca8de4b5e1a4efe574b13c7798e408e80464353f1d9cdd147214fe58a263f2ac86444d57cb23677a52401f9c9096a9d0ff0046359403d1b2c14da51975e0ecfa2df05e8e2881f8e55d043db1c4a473c8f8f80f310e4a475312e71ed8d2c95669c81a035655c00fb78a317d7b1ddf5427bb9e3d40ba99ecfe01f0fc9a0ada55b3b28a8e03d26d7a8b3a70534ce2de9ea00db5fcbe66f09509b8339054706bcecf6e04c9887822781c019068b3b5b4170821c41915d86469714c43c82bd869684ba73eda7c2a8ce63ed3704d3c72a712f17140f8fd3a78413d3528e9c81dffd6a69bd808152f42d2b9b609d33c20105340a482133ce8d3a06b42ecfd5d665affd56dadf9801fdeddac08035cc81f29c355a8151d5781033bb66ba282044689bedca203b5d793fdcdd66d2ba86ded86bd038eeb53e20d7cc5bede2fdbe1593e99083eb43bdcb55a58529ebb2deb686cd5e8d148d40b7984fbb20962a55d96475363034d5e9ebbf6dd5bd1a6b3e6900c6397194c54054ec78732b894bc6e2b2b48bf6fd24fa313c8bfe661966355cc97b4eb5bacb45b0a9a2aa0f4fc805c93d3a92ee8fc8abd9afe0dc7f0661547a40ffe65ae386d6abd924e71dbf99cbe7554656a47f15b8849f9e2ef4b689ecaf0cf13c18acb0f6c536d5657fab066cdd8f17949a8ba91fb5376a39c753c0486c99d9ecd8f6efa2a53dc683afe7d0bc0d89edbdc345235c55e52c0d8e48fe3826a343a93abc617396cda7edfe9e8c071ebcef60088e559f307e0e9bf3813cf1d7d3eb9c10ae797605596b710ffb1b867b656abbc6dc7f2676f95b6533fc724e7c6f97c3e1a964e905a60d81591a89cbd57713734e5d552f3ab85ca3a0a18b8d9510642167fb562ecb1ea8afa856b8c89da049be64d8dc4bf65d58521f796261a774a228116f704431b22bb49cdbacd18b5c7fffc16e73a906394fd3ab242d1ebd588ece82342010374467c7288d59251a1c44c691237c5e283b2763d0afe361e36575c7109132f67eae3b85143e38ff09789d65f63686f902824ff130ae843aaa2d1f234662f2a6cb501fd37c362127db75a2d38350f45b9c6f1c9702aa4e4ca836880a6270087a8a3153b0500a1d4958dc8a52c1796e61e2525e388ee248e3f41842b0d890026748ae6b3ed2bf2a1c0a98a477ade8a8f423a0f4a3b25ab52caeaa0a9dcd98ac7938bc0ec31a463484c12fe180389a49f995b95fe16037460e753c6c629c1fa59cb0b809de953bab681049ed8dc6bcf6e1ce4793361d6e3032efe578655511d8b7a9c920b1820488eecd3c043eb0ead7e04c228bd784c375e845e2f2e33911c96b42ce39417431a52194bbf167c2341460efc7641fc119006fa4fc738e3facd7253cdfc4ead335b1de4582f31dbdfc16d77a67ffa8170f680bbd0c6612935be7e47f5f845d5a6e30fc821e6df3d69fa5201578649b5bec80224583deb6115715c9959c16369a77494632c39f8635f10f2dcee17a0476e303237606afbfce3766742affe2f576d455de012dd8a47784054b13b6c62ae69df4a98c1e3da2906a955592cb4ccca5e470f4dd96c4fb2dc8d948397837553d1b99c049f2f2375172703143724d5e342b7f9e7abee42e5bf0405ff9f546a6a1df1e7572135b02c0fa67a25670d87b01e567c5cff84554fab0cf2dedafea4d4b724758505b3945bfba40d10ac0aa7c41ef7abe9756fd4f76c8c71017d21984082cb69b30d73233e6260e5d41d967d0fafd3c2cd2d81142305afbbe5bbce973bb55b9a5e3c4d6a9fff3e043024226288a22142f41b5c83efd18d16d001b837dd996a8f03f9f1a028869d3a0f5aecd811ea28ec3edaa85d5a541b3b0348f71fbebb332f59c3a9b4a34845d3feab3e8473c1c3e69a066b17e656573e885e70f060f9d34b057f134d96ae81a575204ccaa3a0161d26af757e56d046d5e68e8128678ccf30d52e0c481c4a46c3ec4433552c458d4691e53712563f87016b5a47445eaf4d525723325e892c4a0857a66c3885ad807f2d2ea0584dfaec3f9296642943f00f0ba2082b65355b289b7d1a1ea0ccf49ee5c634fa1daed33b83ce2250f85e45d06e7c93b0823446aafefcdec45c5cb412442eee5c4eb8e0cb2c7e7940cbb5ca1d82e5e24727eca7c8491921068b04a26c70558ac4c1a36e197fb9eb40c42bc70d27fd5e0b03005e148afec488e8a1c85b6d7c80df8894ff8006154ffedee2dc37bc0a693d79c4997841ac874d6cd63ba393027c78883b580a7b0b92034556e6f42ae4e8928a19b1b44abb9d6dae317e74354a7db291339ace92a613ecf74500a77bccff4a6d637a880067465d5998537d0b83999103c1f9a636344d053e1381597892ebc73050b485e0f54acac2acc7910d215ad89c89f11ec7c3e09254aa07c3e49f45447d639b9293ad73b8c7c5f0468f83648e4b1670c7e5190cf53f995665a32aeb09ac1991f402b1eaaea8186ec6c92db53ed571711d9285d4534153a51779a6d3951fd34874a6771231f08dc8c69a008b6ec43c35de26f2ee1eb2e458144e847def5b1ca36775db98ae89fd25b181b03a656ff75e2105a6f167aee7dc0a6f0d42fdd104dd29abf052a88b62b129454d710a39aa90b6e75ef8dfd7a426cf4a2b18cbefc644d63ef05f351687e21b6afd40dfddcd05cf50064ee379405d43422015e96d6e9ad0643924fd40fb87a5d8f0d63bcb9cdda5c44e5349230cbe77c8ae763e3a86b9e17072482f91697a45754d819db947b46903f6e9d23d9ae36c3aa0d12915badd0696e5a96c4192f22e69d5223d913242769c75f1b7deb5c3dc5ec20fc20d32530301476e18bfc69291ac6d90cc0b40ba56d8cfd613b5f9604d87d5152e5dd7ee4be4fde12d3317fa980c090c43829e433a097f07ca1abb20fbe8cd56d5e9a16249b5c9dd4260e82a1d816de6de57f570daa80c4f8bdef1a9bdc19666d0d9281d6c244dffb9bb2d4c6cdbcef45717a807beaff689bdc8dcb2a6a68c1e14d1c0407568e7849d4c8ae7bf1d83198080b72f33486b1ac4601d7687098268a08bd1b270ce95ebaaa059b156c6ed9c22ad8afff4733d8ce93d3e353bb52db20511bf3201f7b2b68e929fb7320085c4b08d2b1fa46dbf8660d3daabd0fb9a93741dcf03996f89cf9aa0282e63b23f602df586599c0ca9195e629781943fe5d24a22629c51a6314a349bdb6636c1c263b0630ab450ca008bf4a14af9a0e2348fd37d4e7a5c02b1ab7fdbc740f37d0300a9d7dd74808e024a4846145a3b755c0a5bf5d2aa26c73d6c68d026b1129f49a9f0c6333c682e3930ac0b64482e75b9deaf15e2485c2519852b2209fbbdc6bafa8d04e7b85d75963f527084a824c3fbdae1d28bb11c55d510a0faae8000d82ffc437045f8d8ce4896d63fb0748de2e80272b330bc5912e199ee3ff703b31fbdd0a0e7a048ef73e5ddab294c180df274c291a7ae268e22da71ed66a39435b6ce09b631d841b36fc1cea2f0cd2e0f6820a844d9d43763ee1dced787195d4511e6249e1b969b80225650af2162972f9f2a76f3580e44706c2383f6e72ac46210a04495d4536b030e6bd7019e6c53240dc94082b83af1cc2d763284ba2f9919c2928f9a110dec1d80f0bb3029c3e03a32c47dc8ec944ea5e8ba6419cafcda6886b75b5986b4b9a805c1cf024fe3ce57205b8857c0b76ff42956fd6ad79cb136c1857bb4a9fd81ec75620885cb8fd890d9ae559a54aca76647bd1a5f9786afc3c5a7d1e6a3cd7875f3b2b65a49cd330e49e4e242462fb78cbcf01335cb2775f67e659cd54210d4b6564b5d37fe8a4d50f8679f35bd1784f2a43daa5735090ade57ea3a5c34631d652a21beb96bf69afcc8f6ff53352e44675aa5a3bca48a9af651cd7989756701925661b8647b9affe76663d6442c39661a4492346aec48bbdb318b2e0764cece175c75ccb2c95192ce3967582b8ae17da0811fbbed95f5044e69db9432ce438049740e445dfe8db362bb7aaa7213fa675e0fd4c654bb1e99c03f4b269fa65de56f871a08d6fdf41734b77f75c47c3b7a6107aa56ff3fc98321c0428405575d97c625ddf7f5df1269928287989ccfa6f7f336a37cc155f76f9128deb6eb3e21b80d050d7070ed27d22d97ed0ae51452a74609458f1833cee348e138edc6925083cf2271f7701aeccf94b7ba2353476f6ed5a2d033e1045408eca8be842c30ef997a1a2336e4c3bac78a66218ca3a7f15ad10a557eadcdfff7a4a1993d3c57bbb91d44df454150c4ab6f3ae60c8c05c7ffb913e1488686b93f39b0570ec58470d18d6e325631809e925ffae29b932ae5dafed9a21137a55b879ae3c21dcbc8226b5cf17ef3874f85e8574522adeed2d8ffd9a2108924eb1fe6e73328eb686062c09ee775e07417b931b9f479bced4cb281c5b1c7846aa9c47bbc212613992c2bd14aa70e148b4fa04476221b9232b86ecb4bc6fc36daf764bc3bd818ac09bcf6a530183ce09d393455c45b547358a3cd927ab145d919ca517af2a00bb4a742937a6a66edbc0f42e7ad4ac4208e600a19b9db3da6367d46a8900823cec8d01251d0e7668a6b79896ddcb9a3d4680b01b16eae9851143d10ed679a836d81b7c298936b5742f03508f3bd090c84ea278ede03e970e4b15e68005548f217f969df0dacfeaa3590cbea877ff6c02f23a841ec3ad1ca415fdee6072c5345ba2f4b095e6b956406ca8f1bd06765c4e0596c9cd407bb3171b68534b4cd8bea84ad6b60775fe54f196c198e1720d3da5e278cf460741f57e2ac3fb291691aa2142e90f07c59b3579658fd0c0d86a08d1e64e49db81e05531b5ba1c3f2a6549da985d5fb3051f53f94e5f945d695d222cf2655cde4645f9be510bfa983101076b206a97d2da0e72972aed0c60ec8ca41fea3aa047a7f78e2239e202a0ac5f31e7f1e06166dc25b3f6b44b42243a78012538d62b74257f1d3bcacde97a6f2f3db3e6d356d91a5da2350c5df217c1c3988049384234f794e78d083e9a16208ac0ef1e49b30992c62c0a36db8df202d816440fd66fd48926d56b18952dbabcfa9ddb7cff81bbba3787239cf09dcf14d0b9687d252b19f7270ad9c4c7413113d419a527436888fac34f318860143a1eb8d5fa0e3a4a3496369500fa8d53c147d7d39e0bd288372f0774ceab3f48c5e01b32613f71df936c0b60914d23fe50512adfb257d02e842a40a615993ca1e62be51ac4112f4f0ab3bdcb1c739742627c9e723bfdcc32be2f3b6bd44a783361648a3e7988aab0375ad5a272c5ae38c3e846eb1d36d64b5b770c0b299beecdba068db3222ecacb4c842d4b01c252cb22085f1b22fb9dbe84ae9aeed6cb6e3de01d48bfe09010463806a761748c92620924811f058dae1ce975f933c4ff23c654cb0e388fc098d00eedaa292769339d0fd82c34b4edae059ee19383e2bead1507c69a9c88d1226907f67c7a8343d17b8f939d457164b71caafa26703c75c82f2cd8ca3ad25f3000b5155e1411298f9f7619f13360fdb5a3e33d8cebfff485174f5eb1ffe50431163fef7e87cccc577e52029e052106e36e2c1b549a25ee15371acaf2ca87e4be213b5fc2165802aeae29393a82a8934522b8783010c47d1ec83d21745f3522ebd070f54f40bc470dad377d91ef7dfb47ebf52c2f3f359da4be3c7e594bc9689a774372f6d5b837dabc2ae30bebe1595c28eb85c4a3f3ad84f8d78d5461da64f13cb34d5ecf1a15e3c615526499270cb1b048c4a5f77bf17ab34511439d3a45d1d9e8310c4026487057e205afa6b637f5ad489b73758f12bc8b615e1d8eb94264fa067c331be7d8e41db10db0d0c1422d3a6fb534f7e99c1d8587df349ff713ba948cc258af26f5ee8f41cd81f5ba5797339c2ea079de7ecee0da91c2daa87674c6eb49c403d77148922b7c8be0f2e69ff8781738ce538e9fc14f86c5ff1eab830b198ac4810041074970a6c74fa021e6fd30f433864a03dce0ec64310554f9f2dfbeb6c093a1ff7d71a9ac5aebbe805070903d3b606cf9b1d560e36c64f727c51e722f1b247b6bace7e83f7929d43f315518e0efc224f02ab1345320c53103e1afbb0ae42578e63f392ce99e58addb7ada53bd480e694db4f09b1354e4ebdf0d570c945b9139f523682284144a979904c9be29bccda6d83709201bdfd0660f00b6b7ca447e53c4a23ee4c0c65665ffde4ad96c3a15453dc40c2c7325d7dc6c75d3e3df0746f3a015d729a26cb8da59b8779943f892c58bc52ccbba26b6b3d461b9f2baa4d7f97c25397afffd70ae355159475e0920d9b8cd1ac3a0dcf781a72bfc4b7575a7106d9b2ecc057a3a6fe7005af4e3cad9aa1aed89916ce986ca4cf83c94dfc0e4e22ec1b111b3fd3802064a4f2be91d0e3cef9a52ba7696dbdaaa08f950fb1cdf6f9d5197315c2a6954ed7e922afe7184ead62dfb41ae225aa9af2538af7fa1c55e3cf9550529dc041c3b76d9f5a29fed2154e4a6261461bceacd1ceca356ea2957b1660d0b93305834534fc1d1ca9284c8517dad273da7a0d6784c13e51feaf0a446eb2e9eecdcc033dd463d475ec5292e98605d32d50b983ca940f04aab8c9bd969ab69b3d7d4d158439b5ba1ba8983245a57aa5817f54d9c5e5fe800822911b02d5fbc46cc40d5d0358112f43125ed6dabd4ca4c57f7a2ec17a5db8d5fc65533c8a2cee496c426a72628071f85ba3ee004ce05fb7903d59e5b710724b029d60b13d7f3fad4152062ccce80eb7104b86fc023330176e50e343163c6d817bd33e20d9279e37be2916fa4e7f9581fe097d59f99b071de12f96ca745bf5ceb3fbaf9589f23f6520703086b4d0168b2a72aad455fcd8551c925b44f0c558db849e97fbb90f73e7416301da6875d37be5c59b1bc28eea1057d72e5bddf69c0ba9cbb919edeb9dfd22d853d1b1fa413cba2033ceed6eb534397b8fd0a3ac7fb664896a29198be8aaf1d8c135602b72dd589ae472cb06ec2ea84678f5413bd61e29b09c4c5a5eff722df884d25fad908cf2852fbaa28485aeb14e2113c1ecafc88e8cd4891952aaf975abe461c2e52551b085037003b0d65cb26b94266145fbc6714a660eeff57054e7e15c112b9c1d8135cdcb1aa50739a24a91dd9fc120fe5c2fc1196fc75deb3dba4205ba24db139840f64f089ba31ac24e823bd2c07bf6e8fa8fa897b025304a44bb533abeaf9ff2e9eb9d261b969420c2cb2cda52aa6cbf84ac2e4533a892466199659d19f00e045bf12745916d7dcb2a734011e90315bde1562370cdd64d9b134e73afa61f672f3df20dd7e4b4b93ffb67056d0bf1c5c51dc7f7256050f7167ea6645d1ef8dd2d36dce613f3c35be726d119cf66351891985a5ac83e9708741a4a44d46c6d92a78f16a8cf27d37269c74c78e540560ad304d042c082c16ea4a2fb0200b254439e4f84f274e300f78a23a162fadd7a36046da6d0b00bcd8aa6252fbd81923d3db11d2484def654d60be7028794c9663d63c1d6d5da945f83abcb4672c29d32a486c154768d61ca5e0bed945da7c708115a904a963e4327f3a6014bbee3c78ff3d54002eade6c6cf268468c4d810068c3958fffa4bb93b1782aaccf37014cae98ca09fbef268624a6b84ae8e64dc734261c84ee3e7d186afcfc9ac373bb849cf9116caeeb888226d24499a992f3970ddbfab2945fefa599668411e57dcf4a550e4f5ea34d5d5a79f28f085e33e8577afde67ae942aa75ae8f5699b1e2fd62ff0486c9c927fc5c8ab30ab95d69da108ee7c98a5e0b76d5e77daee75f082335fe2202012686b2fea70893f6628bf71f1b5a38c14628988cb8a434eed608a2067bafcaa535a2ecfe779aa860b919f60ab9c74c59f7bed54891b405e95cecf79da64ab1747d676c58c37d5ee5ef32fd9c760f17bbd522bd3806d3cc50c31b55d60221b668bfa7a169ce1d6f99dd0e5cf6c8b7b18b86cb62ead285a7e0398b1af7874a60d23f2972a694085bb58219236e11413ba80f9362cbc533f5a91149497502ef375ee09514c00e1945fb0edc787295e6bb451b600bc3ed2207cdc0611ffa61b5e79f60abd2ddf75f5a2e53e2d40b411c60d219225716948ffdb0f0ac417c1ef09eb86a3f7623d66f75637440a6216bd23ffe27d0c01658647c3a1f81dd26e6e0c1019e95be1e4cd1be110c54bf1d735c2799c1258c62edd4954eac26b671f01e11f0e3d24889a6f96bb883af778501b119e45f7f33d09ff45020a1240d0052a3cc5391e8b96165c37f42e2ac08293073d447c3053897c4d1b1320f10e4e4d8797a33cb1af308d4fa8ab2b9c07226d41327606c444f0e6b60724d1f6b7e35d5852cfae0950ddc607a898adc60f6c6e0180f3245a475d9d8541a51da910d630b70e4f1a7ee20bc9143483a84897f9099cd5acb5c6efdd9bc2a25888153e33b5f707a1c590b6880ee65fcae38d6067c022eb4926a4c922c60d0fd68cd7d14844df7a364e378d095016eedf583663d75c4e87a5366a1403b80db70a66072c2a26a6dcf2128b87a6dc379fc8e19a866e41c4fc4e8baae2fa25d9deb324cb982e26f589ae6e2c625c82a38f9e37c9cdd4c308e906105d6ca4cdfb56e61584fd703751cbb6c2e2b28a060cec0e4191ceb899b037442a66d845f6f8698b79d2ae4f29a7884c514345742ed8badbb07d264955a36cb4bbc05c41816d9adb88e935ef6be9c923e868c2c45785765af4d161bef18000b3f4f557a48a3330e8cced60b5e4f12ee45a068704a194bbf471e771d06f7c2ad4f6ccf19b99293d15c557f7cfd219ddaccd5dea24a2c45aa71784613b823dcb5d475ce4f9607f749add94d0aac339fd8ccfe63ffab499b68639046f414a9b4cca11e749b30faae901b660d87a9703c90845ad8cbdcd767134c0711526244232493a30af6431628eacb790c1b595e8529922b3408ae3c8176da7e2d6b58396c73d402d35ca1e4d114dfc4bc59891fda72bf7de43e0e806a07eccb8cbb9e066cfbcf0424047fe33916b84e9d1a11e8fa79f46414d23548850c80c9d1385b33e5a11e9750e6154ea72e4bdeef913d557f04ab4baca1c3874d941b44f466d816cf03ae938914224468a655ae8c875a68a8f75fd4c9677ec4a37f23ba8eb4bf90c0d6af6c21238a0cbb0f4751761134223b2dbc3a0554346cc407a585ed3fb1fad7f894d1782366aeed6670d2dea7b892e752e288aa776603c99895876dedf8c55aaaf2529bc52640a97eac48de60215fd159134963267f4481e66d36a6d5bb610baac42c5cb451176537dfed7793dc8712f1f17eb3e524211cf6aa76d2f5a4e3ee884572be5ee8450f37440a6888876de65632c05c5d889129883485a80c7ae458beb3881d5cfe4ec63f5ebc7de829720dfded91ac27c12fb65b25e33dc1556793dcddf89b98e78fd1e7d436a368f0bf0288538313226c4a55f8db44530b8733da9c93b4a12764ae0175cc1eb0f55f091bb408f2b47a44fc02dbe754afbaa84c399b0d585b9f357af9c34be53c73f85611b6c9d5f5324e7ddc481bd223fe7ffecc70b423dcb1a52f6e97e67a839fd1fe1b75ab57865bc86f83c2a750640f112277b936398541eee2f6a05069d990231450bcea6b3c2e3cca2df9d8240ee4c6e517eb77de67bdcc56cdc689452c80558ab298079bd43f5626cbcd446d2a00322021919179ee050c8c5e79ca524a481886fe39ef7be17b2f53ac15d6c9878218ab8b511ac86251e3a7cf3689bbc44343e51da49085f98bfbd998ad905cb5c394bd19d293176f20a46e975e82ce508a3c15a6d13dac5a8239841de7ffcf202df5e4dbc9f654c3e801d9f4e0b3dd8af957cbc2b87ddea90ccae5b0896ceaedd2d30bea8e6f5155d0da95d2a15010175945e0e93a18fb76508b14022fe9de01e3fc8e853256e8121e3c8bc611e776c4a6f51a9395214c9d50c9cb69fa88e1f33b70af28fb6fc0f5c5925ae3d902c62dbbbbd0a2afea0daa17113ef5d1975863d39022656a804ac25698f380fac54dff54d1f7420fdb6221fb149c8d5ecd43924f03cac1c3e808fae31f10e12062fee56c1a938901d2e2de1ae7812014d2f3faf0839bbc66e33a4bd73cee4a305be139bf7fc6ad21e0ffc0f2ceadbf87ea17f1432e11cba63aec7a71455a2f464cd4d4190e9dca3353e79fe5290055155d30f0d2319166dfc1f9d49a0fdd9f5b4485b447545a3248af5824c2e2ea2bbbc351739145a03504af8d679c5bb21fad8e148cb51d08fdfb90f1d3f2e10e28c3091f028445f3c4e165b227dd3be312787077cd7122853fc55229100a7548d4e43e45ddb71e2104258621e4043c2ea97cd2bb6a36ccd38a36168872951c44eb01b92e9e16368f09fc130097f2deea5cd8a5aca9c5638afc5d57c624bc83a51c8f0e0cea5621d0f4d32d40c8ed04770daf11fff798afc0df31fe567330d9ff1c591c80379bac1190e43f855280eb213800bbf560009fe4b9d9f6b7f45046c87eee0103e383ea6ca3abd685e87ed7d0f5a32b8376995b59735294a939cf4c885fa51c00d44c2b8716b20641507178be20a969f2f3a368503d58724db950a3277af70da6680a0a0c1a51ebecfc65af8484fbb43ca98b61cb8b9f5d29b0bd5b095e1586e34db34eb73261ed2290a29644fccf923b7ca25ee5ebda3fc25cbcba401de3cf5ce9360489645ba4545981abd5d67fb36b79f55b2b60d37821dc1c31bd99ce100701e09d7921b419b0cfb66a29bf941010df85efd83dc48b853ee7abab100223afd079881457d3694664b6d54503a9efb68771ce34f70e471be760e3537d76bafc4af796ab09dcf63832a2f3520ceba498cb9acaba6fb0bdb55038557f0443f7304069f68212476b1ada3d3d8498390c01b0bf397c8e43123e33e479e6cc4b38a57bffe93dacd4c6b49f524a644e5f13c5dbe17b6feb3c0f7096da05e5ce7f02b629610e28fc2a168eaaa0f07637c004ad9b003c605b393ce16fa407f5596b44c574651d24b9b7ddcac0526295a40b5171b7ce72d41647d005c69bac046a2d28031e2c32a8dbb1b98396b204ed1fe5ac10819b6fea75cc0b327370896db18ad28b90d6bc4af04681d207756ac5ab910e48d72a7089eb796969c1a058d52f3c1efb166d267f21b8881705548df77484b859281b5ff2a50ac69f792f24688651b9bc91d84b9ab73521fbf4016e88be3524978111fb04127a25a0bd3f2003949dc27225894368008cf19fc5808bedc87c0f99739e84209e38c2effec8dacbadfb93991731741ab4bbfaec88b076f069b065c79ed58925a1f743c95973198b16a7ed9eeb0a43cad03135934f221d0818fe657bfc2798ee35bd5378805aca781ea86830d19dbbaf00474c30bdb09be20c4f96d02319bb1a2b022cbc60eb31c7ea7458635aadbb73884bb8a23b494eda1512b7e131dd084ac153d02985a5fef1909bfb03dfdc9e6e96c77d048283d4cbefb3ade607670346df70085f250abb69aa40e519b9a500e81956a9dc112a1f051053ac0770a9734d804b8a19058f720105bdf8203291c75c8e40c14875c049b823913e9db77a2f537a1a4278b4e88fc91d4f5cd77785e5e9e7a0773a372cbc5051601b7af56b6a88f277a11853305d006a5a514d82d4b965eb7b9e75dc80046e8a41478e6423914c139e3ffb1c1fc02f5ec59d2537c9d0e418db5301ec3d27b793eae10fb705778e8a9fa8341fe5b9620570daa54eb108b3fdf4210328111133c1e07f264db7e83a028d239f9dff76cf7e9d544bca0e65d54d1da8ede27b653fe6fac6045e4e25620c7edb207d408240e4255808f08643424d6ad0d67c859027c3cfc0a077cfa9a6588c5305a41ab7b2f7147ed68fc53f364f61c29f476b9d02b67aaefe97a01a4dcb0462fff295f4fc0ebf99d4cbe7fa393463e6b84e1385e1ac13e94b5e076a6384052bf5fb1881e7aa4cc44b7333b6ecbbf5ece50905cc8f40e948b0b1b9cfb6d053cb1599df024beb4b6a202cfdca9cfb87a0f4ffc50cba4c25b4c1448fb7500094d8f84df410303b6c145797e39f69a0cc6d0bbd360722013965780a8ddc5179e43682bd38cf71e3f8a97b3c932690594278cd61781584f0f1faf1719d2ed0b47cd69c523c5a570cec33b18ff26cb53f8b955393ac67827431f9c51792cc75bbe104bf73e447028c8b1be99f47be3c10c4a6e7603ec8e638898c5ae5984963fe1258767cc45603416ae930b6819d559cddca5e5d7cf0775a6db96cf2933b049ed9867efe4699e9065a863a87cef8aaad9278ecbe2f381937712f68063da2cc77eebdef2a9337bfef2a0aba32c6d342fc2147d44cbfcdd0b63b74a39dddaadd2011133e96c8c0764572dabe0c609d279c7435f9dd936df301f1bd4bf83dd314bd4f37760ce403d56caf6a228babad172ba865a04df0e5c8fd7e04ff8374bf9202beed9051b7fb78fdf3b637a0080bb3f856440bbc496fe47067ff00c73d67aaae953b87cb45cfb55da4d2a4d76daeda28497d035630595b089c4a370a0ef67f3fde68f0e8351500f5012d3e04a4e6ae6418ecbcd2435f29ec14da973d24ec1378160b57d44ba288bf98253f57fe5b1a34decd4f602245effc90e7964936efbfccfeedf840b551abf402c8b8320abb1faf307261ca07396983acff9761a0e337b09af83cd6ac866fa4eb261516f33bf09436910929bea5e1f2eac07ec18b17148ea39fc66951b14d21d48357bcf12a5b864535045c0f2a1fbb4944a33a91f0278c2148708363a95475339994c9260bf289d352f125a19216142cc5c01a7e2d49f5b3d0ea8dd7402ec7f626402273a285c573776edd092b59d14694194dccaf475ffa5c22fb1ffe101acb50f506242f4e589b43049a4b220bf13d92aa0fe690bf873b0865c6d7180dffeb864c2b41d7fb565b93e5f04746cf2235b919e6598f54eaeb7280fef48d913b2037c5930f4c74eb18bb74b92f6db3e73829979d0f067e031866d9a2d640f1070c60bf42ef4dd016b1e1c2143fa6b7edcb6cacd4152a3408ddeead7fb887557b440066644ce5cf34c9e5960fd66e3b513b2153c366039f62af4b10df4dc2678c1498854e837f90796ea9b7e4bc4732ef2072b860701e141b8f0c9eea96e2f4e47c91731ed691d050b14f06269c3e9f2e298216f4de15a5cb8707a409dac4453e23e32ee6aa195787be2b60506b46d92221c6d9a72ee65dc760266ee6eeb0dfd323b2b473d9f4c393650e79b4d0dd44a3fa024e380dcc33670ad749789e4fc6b6ae35ab596291893c10c21f833ea7dfc080299e55da24d8a73698eddc531b6eccf729c6c7288956fdbf98e0b8287c989ea773bb54dfb172a35a2250292d4090ef1b51cf9e008160e3ead99b0dcc712847805d4f896e6a797c5b99199cbb17b4de48c7858447d9b1ce6f26929d6b04348db0a08e7902737df6483395fc9105c9c446f2ba891b9e4439f483bfc1eedf4ec9cb330dd38c4088876c88d740a1c703f52e64dc397178a786c627e17164b1ea44d86818aaa88cd8aeec5d3949f662acbf310a4691bf329a3f9a5cb674b3c577263d97ee97a8318006caabf07aa62733e281dfcc9522fa571a4aca5490357a75db458c4810387e3785a1ddf5c3be8017ed9d4dc89ebb06b63d2c60b816cd5e675ec831bac20ad2333dfb6d33978b543b2e40e84a44fdfd8623a76dca00516af586b2de2d2c2ce6d9c0b815dc51fe8d5499c3935bb4e29a07d80f2070ca21adb1207fec0e8f70babd4ca7f357980858da2fdd5d7b0aa7f498e02a592fa990998814cf2b18fbf46dd224425b86472f50f9b52fae5aa47d7bde8fcae672cf4ac0595f7d956aa11a6f38df8db5f2a2684fb8efdd1aad1e8a9e35b3e5ffb33c3f1661688d59f51fc17af0bb67e0f4277e29f7fbc17d16974724b1a7bbebd82836ae2d309dec168a3c896f796de2c4af7a3466bc69d4121b335ec5bee075da102ced25361417d4939abfcc3a8418b7117bf0b15c4ca51a95ff5efca6227d83d3b77a771b01db442bdf8111781de2544ac1246bfcb1742f8243b900dea4361f99ce35486b0e550e369aa0bc6fc63aa6487dd7f9a35920cccda9602ff832f10206a3455fe31e17c4b42005760a070d3fc0943ffea545c8348e9177569b6f864b430b0387f4bac26fe1afedd3c961a93ee61cdde26e02bbfca3dd11a539e5b9a78e741c6fe24b7d8eccfe95b3b12690d109be7b58e18c9dd4ba45f4830544bc8dfe2f5ab6db5c5dfb716cfc1abf7d962fccc60d102909210eda95ea08c946fd610a97fbfd73b6dc15c81fdaa0dfadd4a4375eefb16c2fafa8666ee4ffd7ea13e65a7b4ce1bb79c02cdd287e19915577e017da8d6a693056156ac355b6ee5709f0def10009d21103e27bcc3f2c72822f22b808ac16c32cd252026dcf91c169f1ec6692fc38fc0dd8a8c76ced341ac89e117acf4535dbc009a66dd9003d142a49bc46a5451c468ec32cc720596f702cca809f22b65c98c601a8a7b826c27a82ab24a1be5bd103577b95f858d2b45a0a26fd459d7a4880b41feee59e8d1ff5f8f8c8505ec96bccc8f31718acd3b5c4eb2a3d4f784c3ae600ed6821e7a165f5a6686a5eb9815900296e4e57aef0764331943cf68212b8d7dc4f93a33f50e5950f79e572cbade6847c548a750625f01d0e7f67fbd83470382746766e09b3ed3a4babb0a3149537625a747a4e55aa43816a1fddf6ee35e5fa3c6f1ec32b1a3320fe0baaac5de707fbb9cd4442e4fe0dbe3c1e56f4b5cfa516071bed5200094469cca55bbc43842d4f957d349cd7ae8f69f31180e4d6edeb5fbc414af8f55a9020a8fd3fc35badfcc34614e53045b92eb76d43224ee7e932eee207cb1f902bed9c27b8b04d9e8fff77a94fd867136f82fb5fe3235e4537edf3c7c2ab86f5af9cbc58a377318ee175bffa01c11e090cde00cf66f161d9b88bd69e0c2689f38ec7998f116b38d190c66d2899179aeb7c399267b655d7b64593d00ea63245679bdcef896e067905b707c16276307f338fe45ba3c4ecc15a31d60974c069cb27d6613649385fac7cb5836d7a47fac936797da905f8ec7acb0e060804b2b22d8aaff7cb1b7c3ea5823babaac02d333fcda342d3cfbed1da0c874843f42db1380e91c88ee0488d012405ad55e93adabfaeeab58069da3adee8aebcd5a1df4f236273ab363322137f7a650aacd7f7a468f41b66196c72eb0b07b9e9900dfc70b6cd6376a282b42bc8cfa16298041c62b2a36b60d0c6c02b70c82c760861c0bc0bb69e734f58dd41cb58629a15a2a95f3e6748b1de176ffa2de6ca927c67f13d105dba77af32b9b1928b8371a2add09c6d267775eb241bf2027694858ef466643f229126d228ca45d48a2e451e3d15b592fbe11432f1dae73e18db20b76c196b580d3b5eb886b8dd0c27c1781aed31d48f2eb4cf6d2cff5990c50d8036ad674441f5fe572d43593fe4b1edc4a1b81d47975a68a1ab61038138c0ff5d7a4808b568fd69267358e7680da87d37622cfdc976a6ac0a6bc0d19d403888715ed4befe88f453c5241cc2d8df0593459ed86a2c8a8f7ab939fe59930fa62da5762da5c37de3ee8da637a671fe2595b0ab5c0262b59ce174bd62e43c759a31c984462a7d99e543298efd7dc5888f4ebcf6d6ed6cc5bb82f0b30711fb7e4380a386f2c77b0aaa367033055740d7eb580595dd2b0137c40e5af01a985aa49702489ae16583b8c45b323f61a34a0d4d0ebb22c05bed63034649428c8b38052817ad26c13183233dd5ac2f982049c2b9b070e8172d59e3128977ec73339a01302021712a7757b85110b3a119b42b2380f17c6a859b4c91ff2bbc68e41313c1a6f7f1ed86b1edbfd083433b2a72209194bb63e744d6489df2f082d95bf4d1657a9fe82c28ffdf079f075df659ee20338115b80e4b6f1f901bd5d0f436fb187ea73dbc4e053da63327a1d86dba9ccee324865b4f35072c7ce3f0ff195849ada05f659a7fe8d4651995cb0730ca80939e478bfe25daa5b1e119db4860e27dd3ecd3ecf576d26dd5c84ce899e74ad4326ac510f93faa929e0c8810fb8eff62de384ba59219e9dd0f8980e8792bb7f182220247633ea02555646daff49117f3cfd5ac029afdd82c9c16adcc37549185c1f8568e16694c399dd035d88226dca9dcacf065a1f9dfc14081dfe66382c272baddc37eb9c36ca8d43c6ffe258bacc86d4132a58685c4423e0a1bd7e41618fcdabd7ce4a958c4c87d0297ca583ddf55600b42cddd277285654e267ed2a10e668cbb410d5b0ee50d337c7d4f5f6b1a3f23692ef758ad0891f9234cb655e83f7823eec040d321c323ce888c8cee4b3acedac78bb9b8686dd6f2c86c077a5b340544a8d5344cfc920e0769e6154915fd985158dbe5c4ec0ad74cd899eacfe0b75ea9e5dcb4b38f7a0571eb96a380dae656d4a88869458cb18a7f108c2b349a3fb1aa11ddeb37100082c8ce1f12e28f4826532de88b40ab64f2a86330f9f9c896e4510d0239d275a059e7644ca728d8cd4a8f0f09d1c98e2177a8468682f54ef1be6b186d4185aea15bcb4c80c5a3c22f425a701800344f84a69e57b373131dc87f8ec004f1905f90dc9d21e91face24ee8955d051efc706567085efe9e814e5e6297f5c96f2a5c693f25c3f7ade40ecc31a9fc314bee0a5bc4bd4ed708f2ecfa4dbb533ce6ac0f0a4575afaaac82756e8618100333e445992ea6916c0deab57e0f5d4c7c35ac5ee105fb24f46899032c5a64511f856818702adda5552ae3e67ec89954163defc1bf95d76c53be2f1aa3839379a14c18ce0c9f26413a39f09d1cf44e6a43f1556f5588e49d6b87be7e90f8ce8211b4ffc26b8f951f8b6dac55cc3b157d00d733e6c785561dfafe8a6ae911f112206c632ed370c24768eda3344b74cdec328a0e27179dad7aa59bb6023f63b4e6daf45fefdbdffebf9b549297ccd64d4750eea7a28ceec4ad0afa9ff41ea7b507558416bd65903606cb9eecd19ddce65b0e143857abf3a01abf1c1f74e0e2740242508cecc2cbe8d37a9a8d9e4f167cfcce7d60e32e8d70f9223af1776775c62cb9ddd443fedbd418c9c7be5afc7671ca50b236f0cb8133a548b0d8e612d0d49202da2346a63357e0a2aad216052834bc059af16b1f39f85b635cf94b7adc61761a50b8255ef0a9b41f1f002a639df0590854a53e43107bdd96fb074c7684da77fb86d899dff36e9b511a5b84857d2519265db2bc95d735af84dbcd252420792a2801217bb9c72f33ab01e7e8e3978eb4c72c1b58736c494e326e1794c14367362f922e2d3dd35b67a780619bca3132d634cc58537d1f588031595129a2a02e3e8821f4c0b7106697314c516de0b41b17a33991e8015d7b963798a7a62c554f97d5fe866c11a16b38eb6ff9a0e1df9183e8ee97efb3d1060827574ae36998261203956832c2c3165b69424d13235639f9068fd30095a79442e71db776f51c6487b9c62ca3f12fd1274660753bbe87765f0eee67d6acfc01ebc9701516e078bb1ec77e0a2dfca8625baea8d164b7b739f18f243a6b2d361b24156d7300ccc86f555a0c4e5fa6421416e616cb4486a180e306b8e4250f2ea2352e3ff306526a5801f4efe223e8694182e0ff21946e3c16d33f3fc2cb78c9440ecb3e53f5c8cc10e309ddf78bceb9a0711bee5f7da4846c5d648f396fc5527b2e803df50a6ec31f6960d16c017dfb00e5a3c728006b1a9becbcb022c09d332593b5062bce82621495003330e68c5320a27d822466d68a07336047b645fe49347c8df4ac27a8fb9d7d847c4d06091cb3e2be9ef4dd06be1571d1c8a6956354b1562362d60a66f1f5d3f85fc02f84f33956c475ba6eaed482bcc61ed2c94cba389c4a1bbedd8833b61ffcceb3f229a3d1fccd09c157bd5ca1d75c53196837ea9d203ae3a31107b5599391248b30c2538c0dbe4deb09f3d358fd66084e77d79efc4f5b105def47d7ed1ccadc52a9c36991224ea8a6ed1f4c2144fea12bc60bca6dd8f4123af7fa0cba869dbffc9de26fee486c9a505befd7dae9442fc41549a040112b9e98fba7260aafa3bf1228ce279e8db6f3cacf60e725637e9d091973bf92e1bb8b3842b73498da152fcb4a56d336a3e4ee086ea12af533287a345431b36a872a1a445bb9826a519088414c85c5432c4da33dbeba71bfb1265a9b11489843d651c7dbd75c9a5cd8628143dc35847e27e0c87570fa117c8a6f26a607e296cc313937fde5663cd5a97e319d09ea0466cbae283018d85eef6b53f84b46c7329e4f4b6647f72b616d8664d2c4245843a7e64ddea9dea0f1a0b0b82f5d16732f4c919f75f322a8758a0bedfe438afebe7f969815fa39fac54ebea970331fe05965b7a0f3448d090819828f4479b8ece6ed4a0d8440a13007c7d2c7aa87cade15005ab7757710bfc2297c74cbd1627ba18f785f0a98bcb6243ec51ce939ed18d1548e3f028af8aebca42108b981a385277fbaf5846216b5bb6006159bb1a7c240a8929fc33871df42e714cbb318c9acbd2dc58a786d8962b8b39bb857b1c789760dbcd6285aa109e26514ac68db57a6fe8f8c9f5a84a3c44458ae1e147d729297dbe1aae0f83c3e575e9b7fd9630e51bf9f9c660e94bbecd27ece29feb1c6af16c0a48ae1f59c7bc67b67294e5d0b3c027844d89bea37220f82a30135a4bf95bac8449f6e0027d853870822318cec5e527c0201426e0824c9097b23a0ff4a6a73dd7075df24f129a50448d26bcb0d4233c1da12c0196b293418a4e3000dfd5690fe4ef7e0aa3f4c84e0b537ec6c325a884e461fc80a0c5ed06df6db91b4b9607b3ae8938ac6b4acfe24524ef9b0cceb59d77c737a331418487d5c9b95a8e2a3e6356f52feb71c9e377ea58a0a90b3d208e54ba90bec50a36e9fe6ebc60776c9e5adac14840264c2eaf4d829e8dc748d3053924431f4cf8177323e16fac1234097aa28e316e67dc4caaaf7258cfe4034becfe7d8bb316bdecff49582458b592383f064ed6757086cd25383c2428cc3c193f0c2e29c862bfb0404b4b536a6f6f360b4ccced9ae02ab6636bf8b95b21a3654070d8e4d48c4a13cf9adf13b647d4e3b8da536c780fb300e66180b3a00c3766f5070b03594142f60f3061a54be305728397e40d251f7f18f94c3d139918d4ebf443e1d5c73cf3f0e5b898ea787a51eb3caa79d1677ea15d0e12e0bcdaa65fd585695429856cdecc3380b1e7593d57aad421467afccc7fa6e6061ef7073d619a0d69eed6f18263092fb26348f98979de2d33a60fe853bdb98c1888f0772c91c4cea37e358850005882e842db0096030b460cc05cdd83e7d51fe730366f563870f73a41a10874722240286411fa6d8c88ab75746fb12b39296ea01d3fe80e12d0ffc1a2feb5336900a5bb09801e6c150244bc4c1ce058ed5a5fa36ce2eb5fbfa9586e6b30a2919d41aa91a663b88865f7629d887a201407012f36b4db792fc1d6691ea69f0aed1667680d561813262d3c302f4c64096c272b77d95a4a010a5dc3e0d108b9c4c21aaa496fd8a1fb3990785eff32fac57f07d70a0292346993c6f24e6dfd70ba5ec6730c423f24d1f6cea631e23a1dda7b707ca0432b01a9e0657a18e3aab8769099e29575b86b2556e797d52b0ef6f6ba17804c36b7fcf03b1983b21b880bc2b4494994115265ed26346e044e326fdf7c99c2cba03cd66215dfcb313713e54ea60caff1a923a341814022fd1385b85ce5e8119eb15d245a226b242902414776672b4f16ff05dcaec140ffc9f6bfc44235f0b2f050f0dc44edc7f3d7b7193804971416fb73e469166ee425d7436ec9846fc8de58d5e5dc0b584cb3a86bc13f140257280c44bfc91ea67e08d90fe0c459dce3415ea5dd630bd3da70ffb3dbebfde4e45bdba2a81f3401d5ee023029f3701cc37dd58fe5969b4a964d5870d34b51adc0baa22f62af18fc3e748db3285936be50a50ae5b9fc280df7feb5c41076e34ebc039766c3640558220a8d97ea3d2787cbc2bb9a4e03dd2b704e60a49005eb7d442a0afabc4d5a0d437218af72ab36e33b51e3048a79d617a49bf285a2942c6049d45d3da01cdfb3cf45bff924f1412ccdc352ede013f27d7d55ba1aca44378736ddc50b4da693828d6e50e28c2395bb07fc1c14f3e922a35f826523e43cb14594d2dad40b65104909acf01f3a997ff7d4d5d0625ef85ac3073d01bcb623b4b15c78fcb824f976043d148133c76cf8ce6a9b835cbe9f0335a73348b906a839e6464384dfb7a2f2f1ab8d55bbe2fc5255b88dab9434220653342441f124fb97554bdfc770f6c8c84091533b17626c0370b161ca36e62b646fee682d89a7510e3f6cabebdd9e74f9c55f75cf16f92473c8e3bfe7e8914460509767c7a2ac6361995d3985608ad46f537b5725ac2f4fe57313c5db92c05d36faf220d10295ef870400d00ddc2cbbc294c631bddc935b6b033a8169d41a4c64c7b4a3f28a9e366794c2ea248b231e85935a8dca6af37be9ed267a29341c4882111f97e8a0277d9f86e7b6a222529826457fcdcaf09d282b862c284451b46eabec40b502ddad8c683558977a5499e763c4c6a26b694d9c07efb877fca1653d76b7eb4af299cb327ed92ca36ddce46c4718ff96c15d585596bf76490a8918197d8130b9e83f91be1ced4c248d802aafb9aa8884ce333e98734995f1c4cb28cb768a73f7056598870d42951b8daff6d9a1d0811a585773ec14b324b81db32affde5bea0d171d1866c31cc1b8e6a64e399605225e0e37909b2d58065b6a6184c42e3fa79aa412133787e6ebe3ca4a03c01cbd91260250ab342322ce8bff263f10a5122b4f5143715cb448e1b7e4190b847beb859e6bc1b30c92ca156c9bdf633a9fbed4718879783905c39901ece61c4119a8e8c6c02217b8e1392f16a0a2cc7e81cd6b5a7cdd9fb9ef0e32c5074290d36d8be2f21b96da94e973d7171e50957d2fe871f774372cc811e263ba00bc7bbd82aaaa48f250943fa5c487f0aec43bba1439dd4b6ebd5bd6ade106c9436d24a503529d451a15601df91e47931fbe0f1ebdf75beb0686295a37d96891b46a15d5dee23b392254fed486df69eceabac974fd9e4781befad94def855ce64f12a1bc7572e2c6f6f6cacf91658255845effeeab8ffc4a84e392ab9089b64e9e59216b5d103265d9031ebef333e11f7224b39ee821619795e53af60c569083f6870719afd368e1a69cf514218c6710386c6cfef5660550ac8fbdb2582411f38f06afa0e81123d96d0f7e883db51be011281c69a11d6b6c7d4d9aea4748ad436530f2fd5c614b4255f329944061e2bb7db8919f3b9bb37a87dc55aa7a73c4c8e64bb3d3344951e3d28b91f929e2fcc296be6a4521ab271b311cff8259b9470c7d18e7e9fec018d831ec3d39462170893fef3762d3a6cb853753790a2266984fdb9931a7d0e176106995d91c838a449b1c3108e49f4878026d44a75803fb2003220bd19df66a7acf4188fd2cd45da3f15e8faa19dafabe6fc7ace38b4ae1414fd12366fd34fc302cce05f738a718327f5ecbbe36a3a536bdbe046d449fa60b8e8b18241c982714942f786fd568e9b0a804971bd4423dac74fb9e8b2850d4e8cda70116f5d4bccb45ad3dd5d8185fcdc406c2286d0f93182b557e425fafb3c950949172a539f07cd41a50c1ddeec64ea1f0e38ae3e62a2b11217d4c187f919c0d09456af02d3f70a88e025bc30eea3dfffe4ce5fa3617b067d09f00036e52dd2f0a7777bb4334727c684fe82e4d1d6e13ca4786d9951d1504dfac79d5a36acf94ba02fb90d76cf5e1a7704e0404d5d905c0f5888eeaa5d8d0116406c85d8a8550fe5cdb1d4182a6b992bc43f1f62e99726f5057872536bb4905ef78189b913228ed4fefb593b8d4beab0059e34724d5eaa1197e19897c22010c656587d99c5f1815c238cdee94ccf9f8d4cd8e7b55fe7346c473fc812a3b1d5d7cc0d9e13c8bce8c3357805ebd034b9aa158e88da2ba042ca04acc0f220dd892c29859a42b662cd6da240c4cc4bfe7af50a8ae1601710b8cd2458abdb7e3fe78f6d55325105aca908b24537ec1b3d690e66ade7d4217e864e5ef1a2a0b22712b5d039879234771fcd0415baadaea72517a113b40bce96fa4f7a0c320b8d9a8842c2bfdd2c86da14be667ce931d38eb99485fcd4304016a22d859b24162402bdc64b2db9c6a490cc6769f7bbd4d4ec5ccda0e5e3c334e156b9578763add6e1815b4f591a82eba19bb4fb6d3a98794587d7c7dfd1f5f62a0594c12858ef3aaa1fc3b21fd69533b62446eef6dabdbc64f36795a7fab3f8ab1823fadb6ef0ddb8cf8555e0744480c36d812dd824542742990dcccf9f62e33df6e81adc6263da9b205aefb17e5d22217acc451711c8c75bb97ae5f471af84238a5bb05d38b684980064fa59ab3d3743de76e483c762f8bad84e64989e12508bc85dca4e40ea3cc79617a1b804a7ba812a501bf0a4b156af8bf8d54a091c3acdff3b5a85ed0e869b1ef6418c1050382b4c740c2a3e5c7a16e3acdb6b5bcc1a10bd1d6949049c72a533b333ed39e3a76779aaa54f713a5f03213dfbcb326714d1c4729ac2905b2f81d0ecff736d97ca16044a06d97e7f5cc3b8e1ef4c8b9c563e2e21f13bce7051edf4f7030e83edd02aa0a3a093a060e24d65ab0e3e88a53b3a27e7b8f4308fdeb0035f3a6f1eca043456371243a8ad492212a7d0e4aee37de96fcf3919918155df9bc556bd96f548352d78a8c147358a591957818e99b606a68d14db5ff5daa39d780f6c52db01099a8b5e99beca552fd6d556e6e04e4e2d0bb5ea6059839c97abdd16e61feeec0fa5395b759077eb79950c7cfbc9ef354b8a21d0132ec4078656027221161d27b030fa809f54eedb9dbabc43bd7ff285b5227995f4169e6fc1e89dedcf7f08141a2d1dc6d3fd12ce24f40c9ba6f3178dbe8c638ee83ddb1dc4897471c2347d3b0923fd2099e42fd19b4a869e92183df8803efda0f40fd089d89fa04dae8888685213399b5e37677d02dcf198be30aecb832873f520ae28783c5b9b9f476d892f1263c47bca9e86c972572433fe11b4eb578674295ce87e9d830ed07900cdf8223511c592c083658dcc7a8ac522bd37dfb7edce5ee4f4c80705344df05474ce18b114be5e101a2dd9ebc562ee75b8f6f1c41252d164c763e768b7f1b43c54fb5b37f729eb49392db4642b9baeb8c74582e9bf9c65e7eac4ec59bf472a9251d0fb64cf1a57319100bfc79e1b39e89e8820236fe878f757c3c49580cb5d00b70a4ae725b2e99a64a30215e309294241733919f53b51d8fd4ac2b91c658c16c047dafa3f5eddf0313dbd48ddeda7c006f9b4dfa071f977189a6d0f3325b82d91baf0f9c3a61243e60b799d278661fe724e153929f0a450fd36ae3b6f76d14e1fa2b256459dd3b16cd6d88075df74bffad30a3d394ed5191cfddf58ccf7534ec6a9cbb3db572ab2c1614add34020b6cf45e2d590d2f7fb8afc7e748705597f26384dda71649f68779e2d727ba97af7016bae09463b6e9e7bbef1f049fe1dd121b52bab73b1d10d6beb3b3be7742d324662f2e90722d59bf5df15052cad59f9e136d294d59bba2c4427df90df50c30d8db1040e1bd1ea72b709b050ae1cee1ee895a4d95d5370a808a18680694051080ba5991dc4037288a34da253f5ea186da6aefc4d20c260412c4ab111201eed551dca376dbd6acc6fca9fb426d3c8d1e37de366f7e20114bd3e39bef2611374c83576bc04e32a65bcaa57ed5447fb78650999eea63bdebe53ad274dbf2c21a179683ef041125ceba560b1795742ddd55b02b97ae0c45ea54d6cf42e8289997331137f2b89ee8c5c09bf4e2676e85c658e7c303aa180354dfa5020e65480a5e5c25bd60ab6383cdf9032b1670e867af803906f20d7ff50806bff53b73ea3bff2d8efa8333eab5f6d0cdfc3f282e5cba209c9eb719b2d4c1f9e92d549b56238eeed859b2838d9de4e459e50e555bdfaf8b8df9e6082adfcc3fa9016d86088b229671c1b2eb8621764d666887e2f7b449f974984b89194e633585228f00567a6eb0ed9d63e35ed5940d3287f67d3c6fb272a311f9cb0e4c6a2e9b740c4b688dfb566b84010e8b26914485dac8b46b604429440f450a29a0bc5c2f9380baee6fddb8bf110275628ff68dc5c6e81a7d25a37a0750c1cde4e55b2db5810717500f469a810c1fb7a2b4aa9221182827bbb89bbc7e6742ed661fd97beb76997397a8a5a2a4f122f416c687d5ebb8ef4716c330a18fabda17f6c8d3b497708a66d44dc1d3b9e87ce3d42eff4cb5a9a81e0e78f550b107c842d36434d2c78596b20b1d96f312de5a8dfef6781b1b392c0794ee584b10dcbf610c1938a12cdea0ca545c67ef7f2bab28467cec0c617c56d003b1343c282c656f016a2b0997ceb477189b8619fe6d27a27031218bad76933f98e0b5d72610f7de75fcc3e87adb541538d1ddf9f20c3ae96439a1ddfb414029dbb5270265f4b0943751e09e3ba40e860683483731363af6898bed34fc144f98df883e95c1ea3bec892dc9ae1f8abe24272900694674c351d664ab30adcd9df10c8ca52693344f0fe00fd68c866b711bd9499040ccc5f051ffcff85d75d962ccd9e6af2daeedffd4493aad435254ca096a80a02193a3eb597f01211fd9aa39e558337b9a8992ae0ce9cc3fd764bf4a3437474c397bfd07f4764ac8f11950e66fbff1d817c785cc5d58f5965d5a15b4df28cbaf334e1c029d30468fd6f9745dcadcf979bb77cb5bd8fd2356006dad5a8dd0c931a9c0afff53940d7301c809dcce84438b00a03f477c0755059261ad8ee07cc0ce31e503eaa6500ffc51f26cf4cf38726ebba60df0df56059e4e9117d64be8a03b28efa75a30672d8d8a9a57525f16f997bee49bfe0bc3832a0ee5c03cc8847ad8c42f35ffa2dcece8f7b5992ca88e861629a4ce18571bb73e955a84c6566cc104f832bfbb757da42766bf007e41f8c5e90ebb416c35f91e65c13ed5f7e7a598a32d8870d1ad7d609a7095d1f66f05805554531339b6395092a9913e4938a3548a4edac9ae7d6dfebc6ae54043a782de21c2f75926a496b8f35cc80ab01f0d6d06b104970d55f5925cf7fb2477605071080cbeb901386d1df0b6a5f2543df497821771a9cfa16dbe8a7305a5c2761d3c3a0b2430d3b187c94a34af4e9c32673ecf4d3fff154a634d7928f251ba8da04bed9493fef94a46efbef27ef3140c7d0acc3e8d5885d01908d6523ff418a35feddbcf2bd9f401fbc9843d5745ab507648b7f17c23aadf76a1594668bed0e3cda8d61ab638a35944aa182109368e2e68231e528cf28b1c71d700b69a9232ff8084f03fa9da1bfe0b9812557e97f580c699a82c36e346fa3e813dce2a24c34d5ba39f03d06d90b70d4570b69956b1b9b82950d4d87855a590e66b4011bb4e02b1874c7bf4aacc44c01741c63dd19d28795470a303307389356462b7baa0b28fbd1bf071bd997be1907e1bc9ba41c875420a5c1bf3be8125d6e83daad9ee577cfaeeaedda7d9ab4c30fd60eab7329f9537ffd8734a71d41e6016349db803a901a555ca3640ebb14fe44440549bf9b7bd6ab6e537a66db77ae161da7c4e1e6eb7dba8ebc88fb83dcdc8d4d46eb24f066e2b26aa2cb4c1ef090215f5534652ab9c94d8e07565c7f851deec6dd4c8749195a533bb25200259b5f90c9423e302962b2277daa079ac001f1c7bcbf4950ee86b18d7c054b80f3660003701541ac6ca57e4c119228675bc858c9ec1ab8a0c85a95519c3a5d32d0923e3c5c25f2075f3e304f14304615eaf1689e497b29e2e6a625e05f322f26c713c2e60a47fefed11de974e389ccad0a65019a79bcbd01f824a6eb5c8662632609dfa6ea65093878328fcdef96e56bdb12d06659cc7196d706c6f77f4f7ba300412f96e2ee16f86bc1f09440ef75568343ae7a753d9458fb56e1ff893c69ceaecc2732c90aa501a64eeb95edc990c2abf2aa7690a9499b03e9ddf28bf8aced4aa51cfbeda8043589155737a54bfd77003c54d622e44aec31da85266fe1530f3260647d8e59b8ee5911b9502925a70ab3d71151d5fc4699eba1817e6f0e44bf8bf38d4260f8e32fbe95fde2cf8114bdfaa6a2180812939d3cb253a59ca69252bc8ada340d2717544477bd5701463be98d500fb04cf3116650a8f75f5887de3dee6a6d53b197fc76dac3cff7bc9d4f7e29eda36ee9937decfb0c07b7dc3ae91493e7e3315c27b8b3550b2ae012db659b11c4c2e25a4d7ce633a5856ab33ee89edc6647a293c8fd16ee3751daa8a401b08817a230ccf12b289252b7e73d9a48a041768b14d03d2b74c0f6dc233874ecd458014739a4ae0ce5d583a1c22dc5de97fdee09abfda3ee4c4bb0cf5e1065ed404e5f4fcef6be752d5f351a870cdebcb2902aafbffdcc43a2f410c59a92523cd6bbcf5c770eeefde1b781868fb43029a73b47c899246ad2d4822139a5b246cac6f5bd3256ebe9815905c2aa71d50c6ffc877ca560b906f7b1a3ef69957b38b936d47ed986bf65b221993e2e7c73ec8382bf7f82eb7bd2006a65c695d68a1a9d95357d58f1710c5495656fb4b165eaba6171f866eb193c6e73bdf697c9913960207a76d9e21a439b7e7eccada8d8880038f004f10fb95b324e03302675d6eae49e09c746ec8bbb4d9f9e2e42b9cbc7582ed5ce3b34722d4db1746830a2b18abef9c9c6b674c6d693c3a5bff6ec918b99ce7a2f5455d19b40ecaf55253012cb9bb5a835362681d7a3f7137bf13552539ba67e64ed0f585a2c2d39751d63f8513cbb17b8c3dba7e4b093903efc8d893f5a7344d447a7fa8f9aebf9a42e6cfba70b148c638effd6dbc714656aa9bf8768c1a373e27b23a15147efbc4b6a72c376bb6cff5ac958e1f3832400123cc6ef841a8077d49ae9a9ec6c49b21148f18e1777406d7ba6204f2fc5c474bc35e338e05b28ffc5574c62015f1eef287f57ae718a8858184ad6da9ed24ff6b4abc22ea1cee87dad2af8916d7e4ceb25906f092996ad46c8c9b1f27392e061ebc5497260c719a9701fcaef06d0d403688141971cab403e4188c638e3c1c1b36409f5f50e6bdcfe08c394a925c068f51190cbe834e7b34e4580dd03d756b68e3b50fe812cba8b3cb8e092defedca76892d7259b826de3079f50d0de717548b83091dc304e5ca6e44c01cc25cf916762bc3163e8acd3c0ff2d1bb60861a3cf9bcbd811f3f4e54abf76de7a04d52cd6d06fd1c717b05edc4e038983f2fe228ac60a16a60cb4921d582b3c9a7a1bba6901d259bc07eca8d8118e85d7c545a0f86aa49c1f94a7ad937d1ada1876147d522b16743aa8828b0eebd7828ed99199a6ddd67e44f63a222ec2326fd95d031398e5d5254e810665c87fd1585e3f342ead1bc92072723fef21fd35e18f8837881fabf969ad2b791785f7ae112d39d53c89407ba7e29b52764acb5d2ac1c316ea975e31ce55d39957a48054350dbca6fb500f4725cad994e1060a109fa7d0f71fb2c1fc1696bc8327b7ccd265caf56674f06ef0a5cfe8af19d15da38581e2cc1418fd432ce8bb9c96708ef35eb9c1328ed7e8457c08572d06f2ab3332dc229e7b4e1e80d085b9d320dc01d6aa0e33288f6f295173460a1d12b4a08618c22ed4b80b9373e4b0352f4710629b9d5712d93fc18617c53bb90b2fda2b00864e9552ba95b272393ebfab3b0d71236ad1588d1af072eaf8b16f49d0eefea6f50d5c62c867313c34107e6abad8f4d86142b45530920a480bd30b809833123930be7c6c99b8ae61c2d4ab2f6a31358eb1a909eead778a4b814ec299b3972050aa75618432782940648814315e657f692d92ed6f2a28d6ad49f69bf716202896d2f56cc25e0485884df69a3493f0a4e1fd142bd52937f2558d49f2f7219aee0942f0726ec7210a58deabb3fe81897aca3fa1414a7d948a79d145f5cc5846785300533cfaf6bee6e0f69be910212b5971e96de3506b286b4d0dc12aa3336692284e4405ccd0a5a7a2e7fc58b8ef7c9fc9861376b2c95e08469581e7173c3d4ac1a752ffd84787c23200c2346ce4b22ca99e2b954273bff6e7fd42d9fff222745cf181ce0f5ebc1095fe6f417c58a0e614d3fb9071c355702858d97e7d38b826d4ff4a0b93b6ae4c24e1f1590f4b42369d0e23e8ae0174d35d69aeaa6730303d42ef56c2c3441a960add81ea7195768aca50f7d59be65223c0c0e60600dde1d7b4f9bbf41be240f3497bb075b4eaeed199ebc2c00da5288579cc968cf9e904d7f2bfc516d9d4b7ca541e12109abcaf02094458c9e02096c34650920dcf6191655036df917691ae68367221e5d65f9495b36783429a3db4cba7df8aab6947b76b93a70840f8406d7d4b8973b19e0963087f09b931db6e9e30a03d645f174e4819e87f60f404d6509d8aa770468380f45b57b702d2a2f412a807c4df74d129bb61e5d1a9f3d0bab9c15cfe6209a39ad494fb5a9013616da48c6a34020ad331257ba1c76775d86139c305dbd27427e3893dda578717d9a7035b7a94e1947f4fa463d67119266a43cae59c09d695130164e1fdd79fb4d3de1b370ef8da5a9973385616a75da70112054b956e2e8e62b94992091ae1f4a1c81666b35a8af8c70bf95910e54a0d722f157cd618d21376a6806645d255986f24e1d2cdea40dd6e32e8b2e4651360e0aca5e5644ebdefd4fed1f5baf0e19065af738a486820cdd392626d89db211e8e5f1f569a55bd7f3905c1dd615e7b849cabf73fd6787460953b50d83e8337b573d45782eefc3835f0fbc03e5c83e74edf62d9c8c1135d8071d9c7071483b80cab2c40844f23da1686b5793f43a8c77e3d4ffe9e4e675fef5b14cb517bc33ffba92c3a550ac3613dc71c338783842ed56dd39f60a9d9fcbfe40820d0eeb6c7ce4c0879574341de560d4e71c4c98b31ca00adbe51680702d8ee1711e5a4c131c6b0b53acdfe03f223de1ba4287fcce808638abed59be1d975b68609b35433ba98ded0b560b990d6fbd9188ee6557118eeaf6e7cf76e4dd3a727a99a9f0a05f3ec445a4f9c90b54e46fa80b0bae5374f0e54cd1de657e7f1d1849072d60ccd33df02da0a70fb7ec802209c9a5e586e9dae7f87e974d8cb942a5d7832c7cf9a098102b22eb212fc8541f2737416264a284a6935b796ce87f83ed36be0a5faac1558e3a8c5996913c2a90cf77d25e2a9c5106065e4e654925b6d33dde4e67b33f6dcb4f7fd4176ea6cf27de3845617947c62aeba4a2433f2566bda2922c6ad8f48f88064652a8aa1496c9612857434053f584c1665b1def0cebe6b44b9c58ac49090a633a9b95a66ed760600c0d188de713b6233ad120bfdb94458ff7b25f208d6f503facfb6191f5e084da699c35008e00b9b613e73ca1edeaab4b1e26dfcad1072f199dacd1d30d52a760a7222d21886fa4647f5213e9f8ff55f3098e95fcb19c30bf5580d1b1e797a291184cc88123cef4dd5970fd7c56dfd79555427e563a999ce1cc66ceb0eb7ab08778b22630ba304f2d60b5226cd14ed2990ca7bebf31317ff0b6f40e76a43005e0695880ecfe40962c745a53d71bec5b436e77cfd9be458e6323ec7cd20afd51a64e5e853cec3fe1bd764e69fb9d4d8e3947385755925e75b6005a03d4eed17260e543084ed319d1f4b6497c1e08c4ebbf07d3532ff2244a0d1c650bd4e1bc6fa64d1cff40325cdf09fe55e197bbaa380ff8fef5ae0be6607730dbf53735b7a96da0f3c8c1ea8306a1ada85c03f2d261185d35b345fec34739b9bb8b0e498dcb7a0716f5ed738965fb03d7aa314167b8817c2e304d2cc0b9ecc966ce57199286d706d66595458881073a8504240221a3741e2370970f83b3542def0ac4dd8b1f24496a201bfd7be6ae5363d01e335cde87a61c97838e78ac35969ba44fc425de12353a73e47d0a91ce82c1a091af1367bb80f529a0519af6b1d6228d5f31725ad4c1d7f370367ea7725c2e6b76d7547c4815e4be83d90d8727b2ff969b1d4977369cc383f3e75d92327ba43a16d33c8c8d18a7545d56e259bf4c9d17a4457541a9b1161d108eeff9f7fc5f81e9ce2d4423606524190092a4ecb84ba03931592bd7ac3919e1b629c96b12c6d710b285c78e988a96cbb917197fdec9e2dd8929a6e6a06e1a85f5322ffbef032704edaa261e0f306bec889f6ee937ece861f0a4b42cfad6d70ad21b7108a6078ca9e43c01f074f37068595a9d30eb87ecbbe9a96af0e6cd62f953ab704721d96d75a3d1fc325bdd074d7daef35fd82463e1022003e6988c22842de30a9d5ac85f73c8200622734a82c3d1422b20500a290ef5323840cdb5b00cb3b65c365ff6583ee1ef77ebd255ae872aa0c9bec83735bbb912c76f6c0cc2b81df4c4271caf64dd87a6abf9909c5aefea670d460fa7d27dd755f048492c86c116e1041952a20b4520d16f2b7e78c978b15817d99f2e7051a088f09c5e8035e876f8fd97aca6b3d97758b657296979f4976696b0e51beb82d15a689efa6b60f867ddcc68cb387cc1556ab8e5a5d908dc337c473d500716b723223408c4e1fb44780bed7ce01c65f0f062fff0f1367e6dcca22876e0656fb968c977e369eff5b36c6303141ef9d6198e622ac8f99cff1e9c7889b080524d0a5be275b09dc1ac32faadf60790e278964ea6384b5d1bece13c8ef66899e7744de940d2f1476ba2cc62caf3f5b17a24afea92857eabbf1977a0ac4e9e115509e22cd176570d42d50105d37a41b5cefd74b30760a38816698c7b867c979429297fc9c2698d2514255daad40e5f6d716b18385aa213e8ddf8f21a3ac7abb3286767a03b101b150d0e0495c492c45ccc0c4f2e0f393c0b66607b5975d3c0bd358b666b33f38594c303147dd0698d60bbb203654d5f2cab1c4b5420eb5e1b28d973f9cb0f03d8f96be4a3ddfdd2ec1677a32cab4a7e0a1ab08f465bce66c8c1fb9307991f5de8f2b5b3403ce67a10a2c9397118316d7fcfd064285cb947975cc9536b2b3146090a7ee4300eff5dcd73d3f7e3590a03d425cd5da9ed55977d5b5e774089a257d15f2de7add1b096e0c38dd95812e1ad0bfba505963823fb4c054cffea31697b7bba49af255dad8b283d66f8f1dca2b551975966c509a4937820052df14dcecf44a8c1159f80fcfdd4d1b1b2e46e2cea467e68b9cbda9ea6a96f9d8b13c8d386d2fe43a7debd80bc89adcabe7677dd4fec1ba551e0dda8b9760a8accaa26aa6e9b1158eeb0719df933cd50d15bd5c60b12bbfdfb8727b0a2e259e7feff449f35289d5899ad836521fece4d5b25166690f20da59b902d636e2126ee69fb69af18f9f732ca754109e46b9e8b6b18ef63bb73624b6f7fa3c549564a3d7ed60d906b423127e2164a1b2f650770dd7ae0cf6289acd2ceb770b9d10e6f030e674f8aa7d434206e98104b10f03d8562dbf8f0dad4a9ab8ce0726bd8f6535308942f5ec24263653990c6e7117b2beb4040d3cc98a674497d5cdd8561bdc17fc526604ee79025175861883fdbb16b26d832323c48ef800ce6f276e7bb356cd1c543f8065536a5f81c9d4f4142601856cc6ba0a6ee1f1b8a49e05a6354aea11fbd9df091a4d252b105dd599a71b82f6be913a618c2d6c4522596c4a028e3c7d6aa73a1b6bd6346fc049d4565ff225601591b2f0b3164b239a00ca7951846b221dbd8e9fca90db69b2e2bb081452ab5448286af3d1ffcb9f1de518e407f45dda2cb253053dfec16b0a120c4a57c7df34d1d369afa521b77403dafc23fc9fc6ae949c28a3dd7f92cc73b5ec5de9258c0b4d19a04842f12c2867da4e917f51649bb489873757a4a69e980a7fc342bb9a740008840b90d64949a9bdc866ceb24842d0863fc16ec69f54ac2b40f40b51e1ee4f49570ccb321ad0eafbc2d89ff92f3f9239f7ec76fb044de39b8e98a4ff38bb43c1699902b7987c938236c79a61337d84083adadb5140e1f7e3a40d9fd0cd560dbf00a9990ab10dce987409dd76605196d3d108985f9526a43e9b704331d0b17cbdc31dc8c1808e0bd446ee7730ff239e3c6fd5c020eb082b5542820a35f27e88b3d07619a450c57d1c696fedda9021d37fe20af92583c8d30be99f23a85a5bcbf4d942ee4200059bc18fc3b7d2d1c352dc66b3fc12f82c635e5fbdf0f1f71903a2ef77f8dfdd3e9f9e6b6ec40e48029a8cc283176d1df1aa4cc8c489c75c3092a9d6a3c1a324380a4f5eaaf27a28a10f4f3df0abb99a04f8d60c0138ae901efe570fc324249b331e73d00b97229d647a7eaf39adec5b41a20a0240fb4d7eae7178ed6ecf3a0c3563045c8afb2ab6e587ba2b872927311c811e94290694e912390564fdc82b944122ba3cb0db9d8f654520056fbbc537a9739f88e13ea517414968661fe51bfca4ed7db88ce8037642aa12342814bfe605d9aca969bea0925bb74b018552d79d5115f0712a46cf13a20d935bfb7b52d8db18456c625632b3a73cfa8c100fe889e532fcd6b60d96f17aaa29f1704906ab3818a263b807f5d952b74f9b2c70fce9bca07d1d3ccc1cd366225e49286cf69368c8a5138588a5823faa3983ea9b9dd9befcf37fcb0131bb8ef8bf8a39e5727cda9856f4e9c4249b2dbbc7aba90d362f3faa47ac39a253a090157fc9824aeec455fd6bb8f45a4ac8d435ccf8291668ef64529e961b97331c764494cd46443c07f3f0ea28ac1c8782f2850cfb1558b464025f3f22863df89fb2b77945121220725a6fd2273d905734e1bd01c6434c7015b17f88522fe45bf7a6807367f2052b98c3fbd7abdf7286c40814298d25bc0c125126f2f5f352962457196843a602ebcb131934c773303f365c63e46a254aac55c00a24fd703f17dfd6dd48479a03696341d17e0b076df04823a9eaf2f1e80933bca819f053d7103f708c0ab82b96f77cd3329cdc6a7efe4182894872135eaf0764be5633423bd25fafcb2d21e85c511fefccb884c4f0454a8dc7f0fe7bc87bafc1cf2b0fbb00f2024da1d7fc3a8b07cfe334561b88006e0938cfdcb826157a7211a20aab24ae487e69fc7916426d40f3928367919f210b691d2ebdde4489076740c3ea6e4842bb7ea82a0c6a4fdfc5a35ed87d74977a91a9ee163a98e93b4a823d01be7cdfacd5698560d381f5d363ba85d1043b8b65173354dfc3979f98f7d046eef43374523568a737bb9459ce9641f4168f2b33f2e7cb2d80f3f5d5de6a92516313f1c98bc36213293ee7ec6a8a9a98cf3231e661e51e6b1a7be89ba20b3009f9547b3025c07cd918de309dd567f43e28f62e9aacbbbb286ea636b54b044ba69061d2a4e09bd442c82c080251f4eecdd44ba4edfbe2fa58616b8dab94485a0ccc114e65f1a295936064970bb27f8280879fb40d2d726f037f0a15230eec9231934342ab8077a42cee8f1b3de32287627bf2e3db56c1d010763fea629bc814d290be98902a5c7037e043f08b614e75e6ec871a0f3bdc85ac96015db4f47495d4b32813c47f4eb30d8be62992bea839e49ca1c12bd8c43c8058d416f6258b0394af0a279385f12a3ea78800e2203d36b2504c0b17da853771d4a78a820c3fdc767be4a5fc33489466d04d8dedbff9ca52503cb7b92615391249495053dd442ddad251a3f3f73f741a07659c246a7effe1ebb9e69e50063cb099634d1da0077d5bb33e4bb6310b77b5309195a0033b2888f19dd1bb250d5dbbca0fcefbb22f13fae12b9a20b64b70479241bdf4fedda037375e6e952150a35086f5ee2240795b5d6383292f4d0d46bf5a3a507fe612f664172a5fc9f98a90d49bfbfafbcfda5ccb05fd817a3590501918cd3be6d99018baed16b6971301a3e17d889e00b7fb7effd612a64f9de3f89c3fa174400779737e9b5c626b09403349bf5212a4a3fa171fa985c62e2b50a024a90c2ecb3605000f05a258872ab257889ec19f9b12847c7e94f152e576921a0212fc73f04186b04a9659c8eef900b8dd76dd20e2d9388cc67372d82c8ce54451986be9d294b2cc48ba2df056ac477a204ad05de49f64f44f665860b46ddd8371426fad88b2441908627d6371ae15b49340f6695e6004a3364eec40be8d1132ee75cba8adb0e9e40683e8d2251d410935237e6294eb1c24bd5444920856974955801dc6fbb77f54dd97eca9624d896270e09930bb6461e3146328b98aa44cd25a1294d62585a488041a9113044309e6b5093f3198c2298c85a906baae47f2de2ebe372548ec9376ee0e2438f13a7a9b2a5577e49852b9013b1af845118416231b7ec3fadf52568e737806c6f72246668f1e4106e632d5a9b6edd4b37f95cf6b542d0d9461303f8864e088171e1c6a3f85e1ffb23fd7aa03fe1d5957df2446856b0cfe4c3294bbf3bfd5d7871cff28d988c17c79c28806c525e958e8e5d40f57f03e1b02039e7061a467f8c86ed68d165b05777c0fe0d9f7c55405ec0eb85941a94b9eea4406aa4299abd44cf660be000f96c405b45012d238a5405206dae20438a11d6db99518d8313b5813778f1d24a182022d179abf4143e802b9d4b6c6bf240ec5b0eba7e0c95eb39c6f50093e7fcf7cd573a6578a67eb6cce0776bc17c90e471eedb8b0f842fc352696b3aaa46de459ba7974727a79ce44345527d14975326569baeab3d7a94be62f0642005b384a946629ffab0dc83cc66848a5ce6c0d8a6385e44ccc7350116f08206ece513608cbb8015d169edfbf0ee868c80037838fa1688296a890b5ff7c7e7a308993a6bd3f395ca3991800747c2a0e69a6dfab0b642954f4085e31f3405dc9a4de46ae49582ad3f1710365cb3269e13877c90b6f5396a90042662742f0f866e92a8124131f292931add417e79772234c19fd7ce7fc5e537bc0cc170f43cbd22c00e915cec35d543eb29846aed68e2861ab733ac54dcc60227edc291bf91fb72ca7282ab0153c8fecb5e858326074bc903c311ac91b09aca290e6091151d1478a9a3055400bd4900344313dbb664c60f6512f00a59efa76b59a7034a190140c40064a7e5140b24e21be48a80c5fc7940b6317d44ef3a89a2656b30812815665354ff906437250ea30d65541128841a2e55fcd83c599370bad12693c17f02765648bb05b550316acfa1406f4255ff7904124cadc8ef46db2352fec8add2e3ac4460552f8bb79e82d2b5414e390284a434e08464684cecfe27ea3a5b938906b0c47bc828a19ff4b1712441fb5bc6814e4705433a67bd145e5a878cb4bcbf0e347c3e1cc1b3ee2130d43eacf35c86c0e1bd4c308fbf80e5663ae4b6f7fd02a41c7c65d926d5214a3b6351d5085d7c342b96e075c745c79ecaf8dcddc6deaa0d3d00048cff016abbcfafb07115085c092cf52444c14f06ab3304a464869f7b7ea4aa673ac038063e4d527a9e1c84ff94a618293bc23cf1dfc69d30dcdf17a5831b3dcdfe15ec4184f6c0457555fb9cbc7243b815e03e133376f4d11bcdb97701af50444e9dce54e633958387a6c1ad32904a78d8c23082ffdb92c533a81f2705df1bc8b0005d8a9c97e00c7df4fce761a5023adf42c35faa6a915692f1913cd82c8b654fc03ab750d55d855edb67b5aa0d6dcc912a44560762d76fd838d0981803a9571eafc8c1fcdff87848808b5eb0350533f7b9174914e5b5e4cb06a258866add46984db06b97a670bcd0b2f13d7c3d3725ef5f8aaa1fcf432a89ac28d641bad68f67112957aacdaf8fb8c3a3a92994756eb65292d07101e73f7c51c669a28f61d875bef9f3cfd78d3ae7395ecd38dfa719f892ff92243c4f031d0cdf633975d01bfcc6ee2fd7ce9feda5fc56e151dded9a67ff5a9af737c89e54050003cdc2704f4e6b9815eb13e3c4560f202176c0f932124d9d9542bd6a3b5a778fa46d5a0d6b1e3b77227262af20c79ae305c8ca264a53ac3ce19b86773d50a9f81e6d4067a34675d4ec18de1e41e7ab7e2acd0e167ba6809b1ead4144c90a5179d36bf1a5bf1a2a360ba71576cbf25ad21913173ac5e00a5ad16e2511bc3f694db5336e7de0d4851914573a9a907a7f557dbc115a17f9a882bd3ad6574601f4d7bddd6902be349ffc0b71be6b661584a981d33e99584811eabb7cceb7aed90fcf47a84419f837003580b3d8c4e0cdaa6552d6a7199c5eb39fe4082195d020c204a52c680d72ebb2a105fe265f29d789458a823c8250e0605464e3987fdcfeeff6794338b63db926d7575d0a02b7be30b836ba8ae8f21ceb58ba48c80e293d366caf0ef7a3cb5cc073533964618623367211b9271ed30bd13d86adf1c7f267f1d4a1c3853e69b7c9e15232d761ce1401e1c9f9fd03767421865ae85a270701f86ac50fe40ad9f975d5ef4290138dc4a475ba0995cbb600d34e4de7cf658efd9f01ac996a2ca88663786f77c4e330aed15121047fd8cac2803db4fb41a9536aa83214974a85d50c8af3fa2c2a4907866d275a071919851e479c7bae5fc2c6890cf3695f4a00ba644dd5811243ef10430039948fada0c4790d413b9fd1700c10f6d16f63c41cc6cee897280c7c767e3e2c2c0c3fd285cfa06d4e14f14aa600dfd396ab9267dde3a169e44d2d02e041b6f7c8f100972c5cb07115c5df580052f9d1257af3bc022d9cc3e010df2dcbe09a287cdf25dd05d8f61708b2e399f789c132083aec2991fca354a6bdc8bc6cbddfc5f6d714792de0eed01a6ecec3befdd2016150ddc2dc6bda91b600c5eec471adb6fa6577e50108557d46b28cbdec51131fafc2caefda31aa9c1e70fc8322617e9a9a6b49dbc8725bd876d56049bb168ba4d90eaa1d88f7b9e0f5a7c99b03a80ea6a685ba7198d9213a9074e97aa15a9ebb5242daf0808307135ca8c72d745d5d05daf6398907364642075cd39ecd2adaa7add5eb90b68b9e7c6b59fb417ebe9215c0ca60dd359a9d73b9af2d00555e1e27651eafb6bd450da5ce7b502e29064ae840d45f8bd49618e2111c1792d97c8235408c286893b5d353a98f65128424298026d2262eef0014db28fa321db58778f2b0fdcca6612ffcb9e1f2b8ac0cb52a93e2664427ab8f1f526f6e4aee4c01819e60daf36ca848afab1e942b64a7ab8f974d6f7613fd60ed4f23434b9c63b6713f657bbe246a803192f03cdc47c0f6ce6e8b209507a0e28b5b4bf27d21b78380f446cff4dfee1a6bd3d4283d8f5bfb95731ac8e66974085d44072b55d8402ef096939812a2d1761cf1ff8be28fb4cbe57570bbdde6f865c950da4bafa802806ec8f44ca39d57056689f22fc71c097f0f8c0f292f564a15b0d8da5777b01788b579882673916735d8866475ff61d5e968c22b24a200bad225f3d0a0f6eaa679fc6544c69df07e97f97aa7e2d0ed62a4c29f0c9e9505793c6e479f10b351372f8f9fd57e6e626ae7cb8d5b55048cce5818109d0b74a808a4f2a57f7d7af7e345fb7350b762ca7ae46eb17ded61ad0daf9099a24be0606f93ab813964273d0ef33d832cab6da3c9084ff098e7223dd7f4b70678b4e289178f7ade7870292c020e5a7f021c8a62e551057cc98f9f7f2bd6361084b7a819c546c2c3d282ef58fc27a927bccd11cc3f379784b40e786e60102a0bd6899a71ace70909beac244bf350c23b5977afc5a4c827194f3d807cfe4396be7f4c59789a1517dcfbc1e608ab24952292870a5ca20a10963fd0f7cf0cdf23451215f6b26c94fb7199187662aa5f224cf6ae593c4af81c45322f2be458a67a8cd07891c33391ece6e5ca54f20505e9ace490ced665f80b463f18b260c78a900dd9caa5a80606897118c04140a97f4eaa5e1a01b3e72321da87409b4f28e1aaf5747ee6ead8b497912559365c4e2b41648055e7c4e1adce567033dd4ce3ff35157fbc430d0e5d1847d4727f8daa5afc30e59861af75dfadb00321eb0f8e0bffad7835e0a77b58660413ef95989268a6c99ad5e7cbf2ab9c5423f450db11edec4cbdb340d37a1df02191c245cced900dff38caf7f62a27d442aea71be32b103bc9a148116383bca3c02c5280b54c95d0a9e1d4646a8265d87254e05a4516cb712494dc50371cf26140b6b6a372e34031e4f987432e1e8a2cd4c3f853cc996d3a8bdaa41f785744aee7f94b18db1d8e9f78d8e8ff313ca4cb938a31dc59c590ae2e2167eac7aab7d8ac438ab3fe51b17e378296fa230298d71606e1aea2a025dcc9bc9c6dcaa6e7bcc61f0663c51912ba65659f1eddad44b9529416e07d7c3a496c743a9b3ba6cf656127cd7f82a3cd7e1caa778579db6a2fd131b30f969a00c57cd717a53715013f6d7d556c8224160bfc7ff677f97f56050ab3d1a7c8c2094216a20d069af62e9d9639620c553a621ef9647a881f93e88622824091efd8f8f6ebbcb06d4f38706a15bb8d448182d06f7931a2862de9ad06aec6781be638325d1bf15ba532097e93245aaf7f4c44711d17149588957b422044085279fe487d1fdc7de5153704b896a232f704b8cabd9d92509ae50bbc31e0000b74504d5fee420920f72bad39fcc900dc50cd70c05060fd2e1229f885a9709228b49653352018509a287d21f3611a74b28fbe34be4d69d4880b195712812173b65462dc5e09f89e45a3f3bc888a781c11051c81e0b9cc10286de4b5f714aad71df710bfc3a8ae99af30fef110a53b2b27686bc44e73bf2a4542c9c8054aef185dda5d3048c63516e29ac57f2ffce422983f743b327af626a9ba500b634e18cd930e0eea1541b467f4392720ce0453f89cf6225d70a84cf111e567fec8a3a5da1dfc45bb3ef7c5b282780057e2bd7101bbf6ef3cb395d9d25c6d0a6392b42f9aa7c173f8eb2a0ba19fffae26e4e1ba8968c2125ccc26f47b990a99aca8d38026080430486dd77f8eecec63e94d39777f91c68be5b0b031ef653f92ff8fc9046f13ed60d49fb463c390a6f121a504a3e31c89288ef60f75411a9de1912a26fb4d3ea03f6f2bf23b6376bc591a4c823a2650fd5da12253e628580f825b34a311cf90d205ff6f27a65b8d25baf5bf4879aeaa7c8f24d705baca807ed88b068e4c26e07265440718b2fdbef08b132afcfaa2559e7dc4e6dea88fb8fe63af63ecac44b66343937dfe945b1cb67d4dd20c7ecefea13ed169c188bc7191064e265db47196e0c4c7734fcdcf2195703289a31eb3ec90fc72ea32622eafc1dd9f1d1407e1eac95b46ee58032455d7b989aee404c1e1104f72253e987e4ebc0a7cf4fd9783a4857253b1104e4ca82ba33a91c1d4c4472fe19cb064dff8a3635b319f9b8c935a7020c6bc46c95f895c09ed36a6607cbaf6c961d99cd62edc2b6606c7da4f6b507e751841370e7e7927cc16fbcaa95d891a4e491bffd0253ac0754873b97bb3cfe7dac728a1bbea22aa0a60dc5eef33fc95c6753b601d563d9eb3b9d0e411ddd17de7d3f304cd720822490a7ed2bbf649d32d4c6d113f1d823acae2064824b90764745b52838b1f191c41b1033cdbeeb3b262c24b700614edd9716a0a6f45354ed9b9fd0cfe6c0ccd17d775001363f02291b4427b4ab3e10967dae824a5ea47efde1d72005b1f8814814a6e813393c469e59dd18ec8922fd0b348eb8d1425dec19c2077a3fca9e04ee8fd323af9f5b999d0e4eb2d624e2d71014c7afeb5074fabf0cc89aebb4738a8ab9b9f21aa5b7681cc8b99ddb999ea2087b90206ff1a66f493171a78ac628f9e2a214fe237c7933f3fcd994ab1923dd594984824bbd3cc2d5c8eb9cffad261c101d27e38bc8435a2c835660566b93c0ca65eb3cb8059a634c0b111d7de7a35c53414fccbd226d81e418ae3903696ad24f361ae4d74aa2fb44589b368f480bf698e9aad7d0960a102edbae519f7ec868412add15bec3eabd95b1a60acf79b2e01c34ccfddd25ca9550d17e7dcc2f12fa4632f5c646dcbc42633bc171e874e0ec54057e6af3449d214c61344cd88fde518844a41376b1e88dd0c38b02bc0a24c8578498797b5c33d3bfd8fe068ac93505ded849e52797672dd934ea1b925dfae6759be5c9c148443132e6de5d24991fc0cb6c0fffae94ce997222c4d48566c58c9e7915185ddaaa0e411fefc20dd381460800a543a3e29042cd4255f38870126c7813c3d3a8564f086e7c3cb630db4e42389b0d46877012f070ef0d4ea49b3099ca9e88a025f4e1e513d72e844b2c04394ac47b771d618a65fba70338625a17c9ef1624358c6265679072813815d2784293093e843d8ab56c7b8cf1daa2f59c1693bbab4a9a418949d571cbc753effb5a657cbbb1baf858b5bde4c8a07408fdc7e28fd28d25a3d48a625b98b1bd39c36a5930804f74689432649ad10eed02afcebad93cc4cc94a03b239d109dc77aa95cf0c0598df9ce04e04bba5ab468a78cfb05a4e497b38ee262c50732b24c0f3dde7fc9834842cfb61898f8fa0e0b8f4821ba418eba1102c7c1ec4c98b1566a1ea3986ce4a1de46e9e9b52a6186d1a4349f60c14c5302d61b800f87d50c2991ae4535cd586fa7c29f0bcdcab4e10ea8580e127b16e8ece28a0be3b15a81189c0d1f0a9611da690705695f7586d8aeadd80a298c69351572a4b3fe2cf0f7a63a69b03f74ffbb40899d624b6e50a1339bab53b55200a65bc7b9ccc03bbeaad12d9b77ba994f8e4ef44934001b879ff9ada1bae5f0955cfc9687639287e5d37dc91749d439f8fa52a6192977873993eff4ba9e34ceba012787b0cb5c9ca76676792c89140d55632733ed866fdf41ec9bd3cdea1f16b9c79db7079363691f957b3a8ede05d3d3ed85e1e85b7ef50523fa817dd29a3889562636aba3bcc489247b1f3838c1cbb0ec9e29b797bec0c738758a80c73466d6917b8aee9e4fe41dd226cb9940273cc3afe83c9b1a51da85c1064e37612619136b9b2b15bb9ce5754ac4fa15980aed5913467c53a467016c194c819230128a9d31c005ddad8a47877540f8d070beac275e18fecbcc4896d3a735a949ba4c3af41211f9d86d226f2b194628cf6596cb3f40110fa1709621d451cea36111ec6bfabc195b9bd46e253814567e63a7e59d2205a2ac713b23cb637e7b1f03ccb4a44c546575b06bad1528b4a505eed6f4fed94ab508023acfe2074e001fa14c3730a5302d0369ee9c4e53e7d55bea2b37c925d0f80a2e9e365815e8807c6f9915a05011e8b6744afdc6b74d6c304ebcc05fb82b5dccab1e794581ffbc61293c7745b2bbaab14c2944d3516a55cb3702a126837e991d9e9c036141f1bace27e425b7d835b70f6e4c20b304779d85ecf84d0813737100f7f8108b3c1e2716c8c4aa50220f4c5b6446a505139dfb4b276bbdf0fc1b342baa438a44cb62bd6122ea09b2f168c116a45ae04e2794c120b74c23515a836a89afae0934c8cd2c2b10fe653d72b14534358e2676ece93f996d398d9e55fdf4b9d5ee06a430f907c38237ec996c42189f2d33a3483674b55f5d73bcd3c68fe68c64f49e0355a67ecd296ee5332b56f4b3fb788df5b9af6eb068fab0ebdf00468a8f25fc62997fcfc1698caeb76e047bc080cbf292560dd0df1f975167e95e7c6eb8841ff7c5219b69a2d9a79b7239cf8cfb0a3395ed6fa4d0eff27dcd0e13a1a6816cae9ee7ce8367c5d6df9501d942cec2e6225ccb5c2f7da017a1273bd103d4b0cb7353c06ccfad3ca75b1f9a7fe8b4cfe447a69fa0307323f08b8005f74c4fe10a77b9c7b01302214064faa293195e18e0c817066b3d55b2a4f86bad2b4da30606e696bb9b4e84c0d72ca7af988460ba077db99e2291583dec987c27531d0cbfc39255c0a62f21754f7cf0d4f62344f5a8fa76b673bec629adfacc392680ff75d470821144c01ccb91c05d0da89106f54da69f7f5b777b6087df79a8018fa25683515242950c8ff71e18c0ad7d88966cfb8968da31f96bac21dd2372be9b4f0e4319180e79e7e39e416baae9ef075900972b69adf3871a69543d711ca5d9155f00ccd1b8526759eba5a3f367a97ba980c0b01ece4fca22818b1e8a10cecf3782441999ff2c4384f34c6e36e7407c50f4a75d687938c6b1bcf9c59d0781cfab5a518434991acacd7016b952f2d23a1173aae30b5cfbb3086077ee598765a99b77a1df8646f6c8eec55a4aeaa46d6d20d0bf032e2b22dcfd1926a0756e96a4e8e675961b73e45477554f66e67f809ea41403c0decc9d3a7a4234c62991ea4aa2d75b2aa065381b4d282f73f04dc2153ccadfb68a10feaffc685949b36504f6910cd45d67009f8926e461f2f8173f2d7715ae4988f7b71f1433e6eed4c0fa28af1e86c0e811b1db0e121bf2b12980c95aa0c7df8f8dbcf8e98a819d50a2acaaac8fa9b43a354fdde4b42b50112600d8df545fee3b51e24bb51dedf17211120569ac8e909e4269fbdd2f00c4d52b5d2b70e7a56c8d2ce3c1442a6b3f85091c867d3f7132f54f130f017d04abfa09fbc87031050368fdf078789f9f305c76f51eb313ff3745410a29a9b3e8ff458407c0b25b7c9315ae2210c78a063fcb40b7868a463c0e38e9098608df7fbabda712ee00d966b0c0dd3bedbbd659202b6be1d5b46aaf399cb996be9e2433132b2fada995303836f81891177159801ada3d2b68977aff89e4031d37c63a43caa1f7be27a398f68333a20ad91b33e0e7b9837c32cf9a6d67a5c987cf2a2f52a0f0848794cf607ebd48ca87b47e7c2e77acd621e3aaacd40b1a1db1d3497defa230967a45b02cd819f3d824277445165b1efc8d12aab01844a1114e38f87420cd3cca6a1d53fe2b7f548525186ce3502f7a513a8307f92f4a3c3c3842def01ec13354b438ba101b9570fe85d1e58f0992b34878ef2b2c306311c436d0f65cc80df9bf593b58828a05af8374d9f656a691bdf4452c34170930ea02a9a1110d7787b3c6442796cf28db5c8d350bc955509811a677787550d70ab6b5b41e51e33fb94f331d75521d38cc288534dc1c49d5ef2d97c8a7f5a9f85d06bdd958b046ce58fad667465b5367c7a80e43d0bf6bbcf112a9a479ee734c9d916d0d35776958f4a78ddfebf606c447d2df48be18a5a8d8c42fbdd34f8f496db070bff2c7df65c78f523aa75c350fcc8429e6aca20762f1cecebac83b50d48ee2346a8d138662c0ab64cc8339cefe4cfd8fcabc699f209bbb659e4b8830fe594aee90c8a4b737463c7bbb5d2f0e36b562b3c2cc8f90f21f9e0ca330415219ed2c274d1014d5653a440ab4b351a9fe2c3b48be41cb8557ef8b20b3a424d2c9b874e0cdbad31a58090a9752aba8c50c83f3bf50a3e56e6b2e1b60c29425eafebc2e426aa1a6c7ec579a1cb3c4b2c5d71a5b816e8b3b8f3ae2ec179f96e9e3fd9d0fdc297a22936b024380d815dee2519027b168be40dc18321f5f0cc54cdbe8b3eb75e4d4357464ae1716de8a119808b06f8a691ef7ab1661d96337a9dc506b5a3c705b219eb730266e35259424dcf7793047f3937cb3ec26c2c7d9bb5b8c7611a2b4eead7066101263ddf0df632c9aa4c99823f37b55f901890c9b4040cf37735d36cf2093fc1d68556921390f67ff7c7eb0bd5bb74029f55d10833e3757b29ed502d187436f921968550269dd75f40ff9d73c90855ee5e5759a8f209d30a77913e23ebd8f83131902135c0676c8853fc49971464e1160778af7be1905d9b4174587518adb7406d34eed3b70f59e66c7d0796b8211c3dbd158a621c0b5b1d8a73e512ca25eeb2096bcfd23cf6c24073af03db1a2dec3c43d2114c5722942bc84f39a814aa542b2377f3095db5f5963af5fc609e35c78b8db296989068f4a7867ff9b40490e205f740e59255546ced435367657c144d8d30b3b6534e64aa6b74720d9ee784e59492ba3569389102e7114f72b48dee33ce347224c534a70fe6327b7248f37ec2ade96bf488b079b98bf9505cadba99c7f4d4d31e2bd6d4c4c46e34c2f38bec3bec413a4d30c9d3dcdce60294f036a6468d474bc78ccabdc2b452508a8bc518402a7dbd974a50d3e25f65d0f7fdaef446c84ff9d0a934553fe2ac03aed062732cece56aae7f0805b5ecbc3c61a3e9edbbb6df1b068b32399dc1d10d34c0ac8a45ad14ca69911864535173044a9c03ad9a100cc5676984ac6593376e9d46bc00608c3491f2f13ad20d0d29fe0cf3f608531271bf6752cdfaa15caa838b4445b5874ad02ad17692305f977b0d63a9c503845765177655c8a491f935d9c2aa045eee14161ab32fb7480282ed4c7155651e0cc0fe1c86afac1572775c5980997fbeeed0124b983728f12609e09361410b57e6c10d85950d1fdc082b36dd2c42a00d59658ad38f7b769b0d477370c0a3b32a86aa2889f11fb2723fd025d94124202f2925db1d136d73d4269ef8214146c2d08ef0fee9377cca7517b76ae4d1c693beaf63cefef8db71725f9c3d780501f2cdb906e9134c5e73ed36d6d7f0e3f3787322c7d0840de5c97aa72915f6227e9ba7235bea9007448906213eec00e5c7cec98379dd538a4a22994c17cd5342358b0b43e95147f005a916d8b156027b99793bb4fc54c8d0ba3a69e89827a515909dc9a09b48db9c66b5596b8874456719a6f8ec3832cbc133c39f3b0f2ed7962b1dfb2bc193dbaee139c35f308d73e751732d930d02183c464afb4bae25451e31b269e66744c1569534bd38bab1da61bc37bb80acf0d657244d776f1a00ae0a463aa926c06b65efb8c86b11d3bfef641449e1a700f6529133e59c161728b143de587d9485be8af5ca1633fb1cfe2befcd8ad43523d5f5ba2619392a4256a3b47ae194f99652b2462c257a5aeb2cf30d8b0134aeb81d3ca95f556d97944e88a2c6bc6e87de0ec5f3bcf553da0fff4a1a81e4c9c840c2b08620a0dfc32ee379a7c157429470e3b04bf4b4016c5aae90ceb03fe778d7dc8ed0e4ab353eda485e5d5e404aa742ebe3ec744c17373d7088fb5172370012ea015dc7556a99c97a74e5e442d9a034572399eb3d24a4ba8ddeb37eb8aee1e8d825df5432cc1e532b796cbce683a0d0d3ca57a3242c638f32408cccd9cac6d0ec76a378f32cfc802e9e8fb92d261b530353a0c1443c64683af6f96f2de3b15629b22040b46fb1b2fae4e1e232bf66820352e1830b25b41d25aceb679737d83f1373027edf6e2d51c8a396b30657a6c23adc025f7064e28646978083f6e2b63da9f84ca3ffe1428fe0dfd6cb5a77cba7b67b13a9f0d97712ebfe27290a051e2e15fd17acd1a97695b1b52d8f0d22232b71ac6a77b6ee71bb5e927ca2d3acd481af50e3cd94862d1dee5d4f4b23ba615880b48e5d1b61f91c766853f3469d3de3421f6ad14bce300ed2b8495bf7ed7d8be28837fbd0fd7580750de61d7f46b23ba77884086bf7a5ed4c446a14604943f3f264a13f50fd89aa26c38ae09a9f152a2dc877851a3fc3f9df2612bb50955cc0a1d715a821da271ecad3db0764b953d0882fa43932c31e5c4dc021c61cea27eba1f5248bfa4e70cbd46bcb270bcd96df02fad5ec48f55426d38b968d1cd99e1010449362a020ea4c3e02600b4d8169f5e46afc653da9b9acb69f9dca4c86c6a155b3820e35cb13834ee12b321abf78333f7d2406bd4a5eadf599c7259bbe1260e3404f1e3d71f297bb9b916d47ffbdc8caa2fed0fd00d23bfd25e3a76c8d0bba4cc15df4570db92e09f7a972e74f7dea15d9feb108fe032fa735dd4d989a9b3ddc5dad825971b8545d75743cb3192e95511421076651ee2eb37a0782f33eb1c81cb4301fa154903653a77da679cc88dfb0afca760023b7cf7118c8fcc6dae7877de453c6a1486d742daa26f345d68e401bff34c90d5a14a026570da78dc1af9659b5acbfd262235b27ec8982560963486ba13cbfddb2cdfb1f0fb2be3c3ee0f24e8fef92f26252b1ed37a2f2c8a49ea03c68a143ebaac2e395bc0b0c46afa4ce46b33dabd2dcae6fdb76fa17429cedc9cc84c469f6f677bbeacb9c7f462a58c2a17fe103f8cfec59e1401d10fe343e5b3a890bc3199940fa4e8c16aef126776e9c9e7b25b9be5392e90ae85a72b1dc5d38350372f30e0c73d7019279085504b61d77d30317156792dcc976c20aba35c1c1dcd0e72ebed6dbd01e4a503bc80049ac0d052b81b5a03b91504a94b457031b04e0a78eeefcfe25ff5aac4317cadc192fff5473e9fb1f14d06ddf409e4f544dc9f4cd95f488d1925d2d93d22dca087802686bf42414c1bf73733518289f43af4dea02e9cb0a6e19c723fe11d99b84eb6e71f174dc1d4060c04b5464ea306d01cc3557e3f9d898192b9925c8e9f656110d4e2968a0122adeb3e3bb6bd1116a07e277d5da10c1b21a145e893de06ae0afdbef4bd4749c50b5d063f3994d8e43c9b667184469a3504fba93f8add2aac947cc0fe9e96bb7f877f035f12e2f88494beb94a7340822495ed71f6d9657a0c97b2bead4cb4d4c81e75f4ddadda85dca7c64569262dbe283fec9b52bd4b099195e2413256ffc04a6c30ed1fb2caa02991bbabefdac829f5182c48faa6d3f190eef116c2539128637910822fa08faa7adaf18845e343a9345f1a0e7c6a33187319c9ed1783cd9aa66034fa3b0433a33424b14f968bce9f03bf37cbc6f4dff037352eb2ed73761d5ac0b0ba16368b628c1b9946500e0da1717022c5ad94a980ede6f2d686c41c83f9fc1057b6a9030f10c13e4aa798652c0321d9a769d3e8eb3c888f2c27eef814b353ce16b4cfeef91fffbb21125f5a6d32ae804017dd3d90dda58525982182cce9bca64acf8503d36c902bd4ccc16170ebaf36d43679a4d21ece239ca83354d1b29efd7f6917e8f67f364b725481eef70dd3ba992b93de8160af8446a7993630594fb07b08ceec763340be34ed029a21ee03f92bbd5277eb9986e306eb7556c8dc6708e9d611585a3960aaa41fa5a257d768bec299c4e087d3dd9f2f4bb4053c6fe6b5d4221ae68394d3a8c13424309f832c239ecf126e70ab9a8aa3a736914af720fb5edd2d5e981cd845bdbc0e1030a4187358534d2ca8d35c56745e1100599087748b1e745f3dfb7288f10a4adc665e009fc17dc2db9e902c4542d6d7cd17083726b89f54c70932873c2db4a6bd8ecafa807e89e78b3b3c796d29f7f8f123615bb9103d68538b153cf94d16853cb4756d7de518d19b2ac567307ab02bc639526213467bf960d7cbb31d65d089d1aedee64a79ad3b21212d71bbd371eb9d10c7fdb0ed0015ec36cf113e52446228d3fbc8eaf13124f8450851af78b004213e5df66e2f142a30a072d1bad21999464cb5c31cfb70f0fcf6014446df6431bb90e7cdaad3273b8cda566c7c83bb7a08ee671fd7ae9a2733af5596938f8dc5b228ec31e5564b9e8c5bf4500d37d809a66f63d78d59c3badae85682b65baa6bb837263e5063b54d3c2617298c4fe40332616d84524562ddb574e95e1adf41f101b7048ff3f33fc81f385f70308196f544db3e171720d66d01e6081e1efb5a23429429245070e9817b59c05a5b7f695f46dc02639d10dcede160411bbdb804bb0fceeb12ae4254e4c778000b6f9b1cea0583da77ddb41a0b474f363a1390cf598db8d4087ec645df74133c19e64932ab96da5bcdec1398b7873e1b55d6975196642b259e78ef28095f90636965d773799eb70e3db00442d2386e3bfb1e88a21866aa4e7865b58b4f98dab951c25469518b3beecce2a9675f0067747f1acddfc660b2773cb4239e3766fd561137e6e4c960eeed493b6b3d516746b656801faa010234fb5151e7baae97fca5963f2f77980f046fb2ba425ae0eb4a87c6e439a8f0d0eee7746058d76a94a6e595d889f825894ecc706d4c3c74d69182e3424b02df96ce8018c748","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"]}} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockContentsELECTRA.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockContentsELECTRA.json new file mode 100644 index 00000000000..845045854af --- /dev/null +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockContentsELECTRA.json @@ -0,0 +1,421 @@ +{ + "version": "electra", + "execution_payload_blinded": false, + "execution_payload_value": "108477972351052331695947002912406997250600692969108946699443471459098753735725", + "consensus_block_value": "1339858616463813965601097196322078011440769170848634627274135136300100178872", + "data": { + "block": { + "slot": "1", + "proposer_index": "4666673844721362956", + "parent_root": "0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef", + "state_root": "0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e", + "body": { + "randao_reveal": "0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71", + "eth1_data": { + "deposit_root": "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f", + "deposit_count": "4658411424342975020", + "block_hash": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + }, + "graffiti": "0x0000000000000000000000000000000000000000000000000000000000000000", + "proposer_slashings": [ + { + "signed_header_1": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b", + "state_root": "0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb", + "body_root": "0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486" + }, + "signature": "0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483" + }, + "signed_header_2": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6", + "state_root": "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "body_root": "0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1" + }, + "signature": "0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1" + } + } + ], + "attester_slashings": [ + { + "attestation_1": { + "attesting_indices": [ + "4585702132744102314", + "4590659586689121994", + "4589007099177470570" + ], + "data": { + "slot": "1", + "index": "4580744678799082634", + "beacon_block_root": "0x17348c3f2ad0733f4b47b34442744b4a2e03a79b1f52c8e8922ee71060a05b1c", + "source": { + "epoch": "533653615", + "root": "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06" + }, + "target": { + "epoch": "538655350", + "root": "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0" + } + }, + "signature": "0xaffb36fe3e48b5c29794f85515b9a3adcd4206fec6dddac6926d0e985d96a9ade0e427f911d56dd90f2644af13e9740509147d149defa9b0763eecba616e0815e9a91c25178860be7d4196a9814781a4576ba7bc6398ef16b9bd5f88c4143bfb" + }, + "attestation_2": { + "attesting_indices": [ + "4585702132744102314", + "4590659586689121994", + "4589007099177470570" + ], + "data": { + "slot": "1", + "index": "4628666713557758827", + "beacon_block_root": "0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390", + "source": { + "epoch": "537693478", + "root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b" + }, + "target": { + "epoch": "538078227", + "root": "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb" + } + }, + "signature": "0xb7720f152c38d7172a82186892a68440bc4d285cc8aa92c1f017f93d5f61a29cf51670e4f944648bd8df82d4d6eae00615073d439389cdf35fbd7670a07ef8407c7c71a16be062fff16f351737ac99f006817ba43a295fe5286dfb4ba7116e07" + } + } + ], + "attestations": [ + { + "aggregation_bits": "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", + "data": { + "slot": "1", + "index": "4615446843529318507", + "beacon_block_root": "0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6", + "source": { + "epoch": "536154483", + "root": "0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0" + }, + "target": { + "epoch": "536539231", + "root": "0x82a81c3f096d065c7e3f5d7df79bd182a53c9471a737cfb9f7c4e9ed95d0f767" + } + }, + "signature": "0xa9aef1e37252740dedc5fc9886810459f7484555aa59fb3876803fc4924149cb471ffbbd9be5324d952efafc3de4c5f705dd02134916b2afa02194fe90a8d1e8f58ebcfe0d33d0b8a97e71a3f7591cb82c37ba531c059a684b581d3857f05e3c", + "committee_bits": "0x0a" + }, + { + "aggregation_bits": "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", + "data": { + "slot": "1", + "index": "4541085068713761673", + "beacon_block_root": "0xe24dff3e29e762b4488e615619483884c44b8f4b37239b5cdc4a3bd7d9b48c1d", + "source": { + "epoch": "529036628", + "root": "0xbb0b0b3fe94fa42a5e0893ff71360feab7459127ca9149e88148b44625f31d08" + }, + "target": { + "epoch": "527882381", + "root": "0x2ed2e73ea915e0c71d9afe03676b8ab8dd578b9311463e45934f49f843386a48" + } + }, + "signature": "0x958ab38cce5390fd750e87806f32ed8993a175bc3ccdab7ce2a40c23ac6117b603d5ae98d44a9780cca1f32d28bf5176058ef667b17fd95f13e047cd9cdebbf19f5270ec5a154e2ce2283da513c9ad05c26f10b0a65755eab4b1ed6f42175027", + "committee_bits": "0x04" + }, + { + "aggregation_bits": "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", + "data": { + "slot": "1", + "index": "4526212706878702633", + "beacon_block_root": "0x41f3e13e4961bf0c12dd652f3bf49e85e35a8a25c70e67ffc1d08cc01d9921d3", + "source": { + "epoch": "527305258", + "root": "0x51977a3f0ab3110e2a10e9c6bd0e89b1410ca45142ac42171bb2b169efc281bc" + }, + "target": { + "epoch": "532306994", + "root": "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7" + } + }, + "signature": "0x8ce27ee66d80548b04b029a68bf714f7918fe9b91c706050317b117786daa0dde1ea1ef9a8cc79bb41d6b7a4d661e30d0023df755b5f24daddfe6eda547945d49ab8796bdc3e63d75fcefabc8dda7f9b4d78292e8827948a5ebfa1f662db6ed9", + "committee_bits": "0x08" + } + ], + "deposits": [ + { + "proof": [ + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672" + ], + "data": { + "pubkey": "0xb94235fc2765496162b52009ab14fa6d0d0ed1debc25fbbd1fa6da8c64b58e5edaf39419489b556cb563cdd1d08c2eb0", + "withdrawal_credentials": "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", + "amount": "32000000000", + "signature": "0xa8d1b8a3f2e7d1f9cacf864d93be09c810406e24e9074c43a1a4323b16b045d428d23fa0762b8bbf203b452d9c8495340e065df1fabb6d1b56b3435d227afb2470f722aeba88fe4542eb8abc2329a6bbb965502fc5ee6ed7837ef9c938573fc3" + } + } + ], + "voluntary_exits": [ + { + "message": { + "epoch": "4559262388392254378", + "validator_index": "4560914871608938506" + }, + "signature": "0x8166b2ed13e982e6b9f05d30f42681b826099135a533d2614ef5f4f59811714245db0e1821a644859559f97ec1e614bf08b2edb294fa2edc1527f46596399534af23c98613e1b74c01871bf1dd2af9618bc0ba23ddfce8026b897cdbba8c1bce" + } + ], + "sync_aggregate": { + "sync_committee_bits": "0x01000000", + "sync_committee_signature": "0x8077d47ad0fe431af45ca6ed24efda0fa9c84364ee8af5f9e83f53b3e5934961197cb31b062dcc3d5dc793ec6de565960924b65d0535f3833ecc51567572959e2849e470be8b6a1f21e2c735552595e9765e66a599d645d33fa3746d409fa122" + }, + "execution_payload": { + "parent_hash": "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "fee_recipient": "0x23033a3fe9f2a903b4f058a4d4ef6a81852d9997", + "state_root": "0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be", + "receipts_root": "0xf8eb5a3ea82ccf3c1be1ac153e3f77f273a07343291711b9de6b9dbebc4c9b49", + "logs_bloom": "0xbf886c3ec849316e3b187793c3a4398b6097768d06bd968a54e8d2652d2a75a96ab3fe3195f647a70f258bba8e2e6afac13b68e2faa5061068306ca2a652ccf6becd6c58dcb63addb97feaaafc56cf440e920f1f1ee6ced53f0d6efd1209f3f0daf37dbc30149935d6dd2451da4f84d128262214a2e844c3079f5133690bbe15801b8e32f99a0c4144a1d705eabbeb18d2d32bd6c6f4f48b71b21578d4239b6197240a4ff3e0fe9aa69c35af5f59090c355feb7b601c1284334d2e5933fbca40a7792d1daddb890ce4e7124d627c763c5d9d79b5597a8580854a297498bb127e6040a3260c87ac53a8c4e69591597b0fb92cfdf430c136b9a5079a5dca820f58", + "prev_randao": "0xd2a9663e689510b3305bdebe972d4e58669a751fbc85bf448269162e078b2c34", + "block_number": "4488205580010065800", + "gas_limit": "4486553096793381672", + "gas_used": "4491510546443434056", + "timestamp": "4489858063226749928", + "extra_data": "0x7ed3313e083eea1ecfb57f4508fd068e9fb56c4125942ed01ef47538b5f29e14", + "base_fee_per_gas": "66016772192738304600348427229332912155053403334447944293225380805794998736543", + "block_hash": "0x58913d3ec8a62b95e52fb1ee60ebddf392af6e1db902dd5bc3f1eea7003130ff", + "transactions": [ + "0xde78143e27b846", + "0xb736203ee72088", + "0xc7dab83ea972da", + "0xa198c43e69db1b" + ], + "withdrawals": [ + { + "index": "4517950290795281992", + "validator_index": "766262", + "address": "0x4dc28f3e0884f5d07b860b8fce6fbebc3b857c21", + "amount": "4506382903983525800" + } + ], + "blob_gas_used": "4511340353633578184", + "excess_blob_gas": "4509687866121926760" + }, + "bls_to_execution_changes": [ + { + "message": { + "validator_index": "2227267", + "from_bls_pubkey": "0xaf8e9748b8dae2368d451ff7e57388b5a9de96c48d5421573713a104bd1d7d19a8fedc6c40cc0c63f030cd788d4b79c7", + "to_execution_address": "0x42fb7d43b1006df9874a521b12867f80fbfa5084" + }, + "signature": "0xa8709cb09f500debf2bbb6855e09542e63ef41d16f12fd72cffe162f228a3bd53079d54205623296544d6a4e803d7cbd03b452f30def23fd44a939ec651d16f8b2380c6c05ed8de42f6332456e214a3327bf9081373cd174c5fd88c73f7067be" + }, + { + "message": { + "validator_index": "1395399", + "from_bls_pubkey": "0x849eaedbe546193c419188b4aa3f2d222b377a136c5defe659dfa84b5ff83153490a330f25a7ca39243bcd11ebace030", + "to_execution_address": "0x683d7243f1972b8371d02072b997a81a08014fa8" + }, + "signature": "0x860ddd021623b0457093e3e33cec56fe571fbbe8a52a68ec6660579165513eeea8dc706ba31cdd09c5c7ab60765182cd084061dcb29dde1dd5d5956b404b389f599a34da02cd3a50385a148dd804110335507c0f05bdfdc495e4a4953dafac94" + }, + { + "message": { + "validator_index": "1010650", + "from_bls_pubkey": "0x8485b34d0bf20fc4d60d681351091329d0897bac95042cb32b979891d0d5f7f752df602f71f63b1d466017ad2a09b8a0", + "to_execution_address": "0x27883743308ce433056e2924fdef751d461f455c" + }, + "signature": "0x98536cd2647e9ae4add0f9ee0897f9c2bc423061a913bb3f1d5b79d2e3ac3090728c5023a892b7440c6cfc2fff73dd4210b61a2c7ad48282924dfe7c6c6f4884353d98d629b374df14b429a91ee58d18a80defab79fdf5cb71224fec86c022f9" + }, + { + "message": { + "validator_index": "2242888", + "from_bls_pubkey": "0xb62392bd8fa27ebbf0cf05be5bda4d08cc63c65e26ee59edc9a002682513972e9e5810163d19e720b078ad5e45dea8ad", + "to_execution_address": "0xeaa7e74372afb92149950f0e30e70d158bc46240" + }, + "signature": "0x895d52f7e0948110bfcd91fa281928e1c76841a86ae348b51e1c0bb9d10bce59917d950c415ac89c1099eecf840f62f0015790d194a97cabb85ba45d5ca678a2c7acfb4d86f22f430c7292bec30f1f0a24125aedf3132afd0a76b6ae0abef7a7" + }, + { + "message": { + "validator_index": "1858139", + "from_bls_pubkey": "0xae7908cd2718d6801bc1045d733f3c8367e3125c163784df4d34f356f899dad12024a9219f126e63dacb03ac068101ea", + "to_execution_address": "0xa9f2ac43b1a372d2dd3218c0743fdb17c9e258f4" + }, + "signature": "0x9846a460e26f9b19bc8a79f50838489e2764fcceed280b9f8729d38d13b6154bb69a8ab360a7cbe0c80a3bc7e92f5fee0212311895f198f7ca04e838530bd79c2814c2d0b4417c3f760727b92d279c91ccd6c94a08924d7402dbda81a2872ba2" + }, + { + "message": { + "validator_index": "2934395", + "from_bls_pubkey": "0xaa7ec4a37dae722143cee2fabacc1e11964fda925d7dc00efc1c3b3a537f414237ee98b5af27a6231ae5097e4a133529", + "to_execution_address": "0xcf34a143f13a315cc7b8e6161c5104b2d6e85618" + }, + "signature": "0x86c8e92840bfb3b3ab773a6c3f4bbdc36416746bc710630dec288404296db89f63eb25d648a0795e30e6870ea5a6f5b70bf684cbe96b72671398e89a8510991dca3110bff970cf1abec6c3bb3bfd7ba1b37ac1b973ac024bcbad0287d47aa65d" + }, + { + "message": { + "validator_index": "2393663", + "from_bls_pubkey": "0xb4de3568fdbb0af339856e6106dfd7808879d0564325ec1deab8e8932c4d173a8d7b04a546a9de867619730b512748b1", + "to_execution_address": "0xf2a1aa4230a3d3a803b5d735d4c36257dc672d0c" + }, + "signature": "0x8a5025a2a1543e6fa0fd574add3bcb06f96df170dbd82f51995a261559948009eefc0c8fc2c474c387cf52a8c5a698940eeb1fff88b70b5331be065192f46e47c765cbb3678d19a6a84f713e9c9464730649720a6182ea2964188a8dec26c2b4" + }, + { + "message": { + "validator_index": "469919", + "from_bls_pubkey": "0x8678ff3eff860e3ea75396d0bb0d548326928ecc62c8c9b30b58f8f3be02e3099ef80f47a13c7fd828412ba9f990c25d", + "to_execution_address": "0x18e49e426f3a9232ed3aa68c7bd58bf1e96d2b30" + }, + "signature": "0xb47bdd50d8e3ee31806068b3555ea1fc6771e2caf4b06d07394444468feec69e9d153e52ced5b5cbb5f8d44f2e981a060a691dd8cd0d86c4d7928bb908eabca9c2520e9033cfb4e5f13a80d30d4e8de24eb5a09a0e0b734a55811f13edd2fe6a" + }, + { + "message": { + "validator_index": "85170", + "from_bls_pubkey": "0x82b07707a61c37b860d0d290ec1c330ad73d0f5970b72c198aaa567ecbd2d2d08e884f2322519c2e17ab2cc3e9bb26de", + "to_execution_address": "0x740c2043b0ba6147da79c6d14c13c8515f2b41a4" + }, + "signature": "0x8008c559949fc9cab7b9b663aeecf3583273f07c7081afc5327ea39297f5adc1f1d8bb8d9485f1fb157a8bcc291625fd087e435b653ef0020f3fb8e4dc7ba04b6ebc64368aed53b868638cc39a536c0c077d6a08a4831f06e9145d328a52774e" + }, + { + "message": { + "validator_index": "1317408", + "from_bls_pubkey": "0x8a5997a79613125f1de5bd526981865c391f914492bf08bea98d89e0b212f554bab770783c094dc2ef1229e5cf6febc0", + "to_execution_address": "0x9a4e1443f05120d1c5ff9428f324f1eb6c313fc8" + }, + "signature": "0x877005ef02509214e9ede55f546c2b003c0209b7d885ea680d76369fc415180ef4fbbce332fce18608d3533b8d6d284603e52bc79193b0b2128c624332fe1bb1d1e1956361333e0ab171f1bdeee927a169d2ab78498189a9e8f4036cb47b77cf" + }, + { + "message": { + "validator_index": "932659", + "from_bls_pubkey": "0x8af5874a9623513bbb3200f80c2679f001ca294967e33f1e201f6720e30f3c8ab69492f3dab696b485436280bd5da4b3", + "to_execution_address": "0x5999d9423046d981599d9dda377dbeeeaa4f357c" + }, + "signature": "0xb21c09e06746c9cafbb504cf0aced08a807b87f62d57b526d28277802395a420321c8510b91b5e835a9fa47e6cc27d240d0991f1a05798ec502acd18dd8566ae675a05579e71bc8ba327ffb5f92c66c1f58ed89bf2804863cf50b958e79add78" + }, + { + "message": { + "validator_index": "1852932", + "from_bls_pubkey": "0x95e6bd6d5246d58b9d56e43c1490b8dfabe87ffc399721bd63de8a38a7a6bcab8399085f3ed777a668f857f591154b73", + "to_execution_address": "0xe2fd11426e5181a7eb81549e52a9782b7fb613e0" + }, + "signature": "0xb33229dc7bb509bee6290ece9d436db0477fc49ec3cc26e1e298eb72d62d0b4d28e72b271c0c3a9b9f86c44c883086680dc51747dd535a7b0b693302eadd8bf44f802fac281dc91025509a5c6df8bbe7455a3f30d32b2cc27c2322c7f00212d0" + }, + { + "message": { + "validator_index": "1468183", + "from_bls_pubkey": "0x98b245d4ae533c7648fd14a7858d17a792e7919a81c31f1db0dd1c0beedaf0fe7c7fc60be0b446238fd5e5c94220a538", + "to_execution_address": "0xa148d741ae453a587f1f5d509701462ebdd40994" + }, + "signature": "0xb6df5347cf18c72adf3ee1e2e5e942d8b3b7ab160b1f66d4991bab95e7050f302d723406d3410b9275700b3b998f2cd517c4da35e0294235f656d5c53cabc553f02b6a8f0e14a74571029f380c52a935c0230f4507ac486e4cf01ede4d04270f" + }, + { + "message": { + "validator_index": "2544439", + "from_bls_pubkey": "0x9866c028838d222cfed5b1ff8215618a8d6a81c3e96a34759e78172fd2d18521fdf686d1601a860a38d3c1fd8c9e22af", + "to_execution_address": "0xc78acb41eedcf8e16aa52ba73e136fc8cada07b8" + }, + "signature": "0x98ffde69b4d92a4510b5d42ae9bcc05315ed0a20fab2ff6fc8e416678f150d7bfb961da6774e86213ee711a2b065c3d300a13fcf630d7f303c59d848ec47905d2b439e7bb4f3348b6ddc448aa00f7c6eb6f64513182a3d335e2753f66cbec83e" + }, + { + "message": { + "validator_index": "2315672", + "from_bls_pubkey": "0x84768946243cfa8d15223bd7222c94a5ce4a610b7aea979ac29d5b6f30e721213ed5b3cef3b4d2e700251be6a3d4dbfa", + "to_execution_address": "0x23b34c422f5dc8f657e44bec0e51ab2840981d2c" + }, + "signature": "0xb9014738ce2ebfe44a8255a53e34b604f223702435a966b81276bd7967cc1e172a4dbace09be70a1f73b300d83a7a8ec161cdc911b167a8a6489def11edca95a3587eab704e98325ce29eb4f86a477755421b480ca39020c82f07e4977d9e859" + }, + { + "message": { + "validator_index": "391928", + "from_bls_pubkey": "0x8b37bcb9abb306bad986453fe618bd0161b29c9f5f1eee2aa91f44ad2ecf75604c38975532425ca87de0e7cdf3cbe44e", + "to_execution_address": "0x49f540426ff48680416a1a43b562d4c24d9e1b50" + }, + "signature": "0x954da68af7adf486693e9213a63a082fcf1b1ed99c320314b73e64c322470329df27c891348c17b92dc7972dbc7d9b4215c7746c756c1aa2194c7217ab902459290981a0905683fa8563a2a7241f2bc3a3d6e4fca48d9fce1c6c322c4835dc1b" + } + ], + "blob_kzg_commitments": [ + "0x83582f424fd7244f213350c530fd112a5fa71806352876480227941a471efbcb4c76127b24d689436e978f5ff3327e62", + "0x96792942ef2204941676b7f0048626f766aa1798ecf09e0230a8d7e2217fb256e395d8d91f376a31b5afd20bbafae148", + "0x594150410d114a888823a4369a4c1e9b4d1af3b146f383eace5399d4b17e3363cc267b8c513bd892003285f184da4d95", + "0x6c624a41ad5c29cd7d660b626ed53268531df243fdbbaca4fbd4dc9c8cdfeaed644641eb4c9cb880484ac89d4ba2b17b", + "0x32ff5b41cd798bfe9d9dd5dff33af5004014f58dda61327672511244fcbcc44d9de7eece5c7917b77201ff98f64a86c8" + ], + "execution_requests": { + "deposits": [ + { + "pubkey": "0xaacb0e7f3717c59e23c32cb07ce03be33c2bb8366da2d27a9954b77f2c9198a1b5f3aea585faffcdfa4800b592c4d5d8", + "withdrawal_credentials": "0x0100000000000000000000007f8344414da8081272a9728d415e47355920f1d5", + "amount": "4701376009451598829", + "signature": "0xa9bf2689fe47ca9ac1fb90da3b08259115adab480b4f387669f209ee7747f7451af8f61e4a9c057bc33ffc18f0b08c3407be0a59b8c61c741572f5d28e2a1f6af0fc17db7c3f48901c9267606c3d7831a3d3647b885946fc95fb5689d24f7b8d", + "index": "4691461101561559469" + }, + { + "pubkey": "0xb8fa03e47468016f15b89212a91f203194684e0cbbac07b6cd428fc7e10cb7d8a363985b46972eedd7bc434fc701c4b3", + "withdrawal_credentials": "0x0100000000000000000000003ece09418d9cc1c206477b3f86b61438983ee789", + "amount": "4684851168694822957", + "signature": "0xa529495633ab9ab138c0756646074fc7753fafbb44389490ddd46048f29267f6b85e46abbc1fe71c42fc98513ed0f6f800ebc9eaa04b484e29af7d7bb0c38b5e088435aee8583a812545b3057c184a4634957604ec0647d1fa81da2d15a5f198", + "index": "4688156139423158509" + } + ], + "withdrawals": [ + { + "source_address": "0x01eeb941cebf96b04a6e6129b9adac2fdce3046e", + "validator_pubkey": "0x97995c0a4cf28bb77bfea20753ecd1e3b3469492921c9542d99a1e81355f6d09ea4cbcb35e3b8f1240e8261d20da657b", + "amount": "4726163266291795342" + } + ], + "consolidations": [ + { + "source_address": "0x60939c41ee39f30814bd6502db591331fcf2ff47", + "source_pubkey": "0xa4a90125ab79fbbe706de307f1de84a6b0dc21adef413c6a5e91ab58e575164bd13c0517a318394a56adab9326607e82", + "target_pubkey": "0x83feea64397a7a9d3fbac0b9a16ccbfd63c4d4fa5d0fd8bbfa13739148e752ce1e9b1e01654b56cb56a196fd8d64db3f" + } + ] + } + } + }, + "kzg_proofs": [ + "0xf99b6d41ed96ed2fbed49f5d78a0b7992e0bf8d7b707b847e9cd47eb6d9a9eadd6889cb26d5676ed9cb83594a0f35a15", + "0xa250734616e5e744f48c493c6d932629d574d0f2b953d406c14b88999cbfbe0227821f9f2e60836eaef3cf363a0cfffd", + "0xb5716d46b630c789e9cfb067411c3bf6db77cf84701cfdc0efcccb617720768dbea1e5fd28c1635cf50b13e301d462e4", + "0x7c0e7f46d64d29bb09077be5c681fd8ec96ed2ce4dc2829266490109e8fd4fedf74293e1399ec2921fc349deac7c3731", + "0x8f2f794676990800ff49e2109a0a125ccf71d160038bab4c93ca44d1c25e07788f62594033ffa28067db8c8a73449b17" + ], + "blobs": [ + "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", + "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", + "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", + "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", + "0xe67a73414d4b0eebc8913832a417a3cc2708f945003f8f8dbb4c04239339e7223f69d65373f595ff55a0f2e7d92bf72eb9093585dec444ebaea74192770e068fc96e265ec54c5faa8d81ba37f7ecc2336c83fdfc4939e87f2ef3ca21e5232f7bcd02ae45bb67879545f34f877e2971e4eaa4cdf0714055cc42614fcda7ad3e6477f168e2dd59210dd76cffd92045b44b02dd9723dab81727b7715e7ef913203e5794dc59494209069f4b86b5442ba8f0251a1953dc31d180996612120b8e0c68e19a8eca31aa9aad7f0fa04984115058ea9a23a522b2665abec8e448838c12dfed625ca75b33645d5ca74e802f0a1a6f8a4e43d82cceb01f3bfcde55f8f32fc137e134089f9632579ecd2f8dc866528764c55d13cd0ea8f6ece4987678278972e019f7a36df20c1fb474714a85eab08c7bb12f42ada74758f19ab7f903e3869deb28771d4469fca18e433732d1cc6928f3f6c906c77da0752b2fde5d0de6e4d5c1daebcb3c10b9992122830bca8b6cd4974c706aec7dd680c37f42bf006efbddaed4462d7d2d96c6e7d5f271c38eba47566c7ba23f43026fa41c589eb880cd6c614d39bfc6c647aa5caee437c398ff38c1d32070b80d31adfc3b43260507a6da7055e711e77f5b678241d542050bd62f8f1442dca108fd8fbfbe057e2cb74d49d2af8b8547c97e4a5e3808ea76f760001ab5a5521ce177fa2445985b66cf23b4633a8e4a5e5eec4b782bce0f3b032698e0a03b6a9aac61d62653610460a0a3d363e6cee93c149b885f8ff925281951f602294ffa651fe67c0485bc22bae720e7f74027d101f8074c23b1540e49eccb84c894c87617135a1cc1d3835c88fac446a78b641e62bdb5c4d9c22a505d4ad38a1a42e0ef215db37ca4e9cc62d4bf1617de643c292b7dbbe61bf8356c563ef41c0956e57b45f5b441b9864c47197b97966e00fe1ab7c3fc5085b28430da029bc144fdf9431d6c09ef4ff51140ca663e4509f001397aefe44239be27cec5c49dfca33ce7e692b1c57f798e8ca6c91edd94c97b1a6578dfbfd15c9ebb1aa5356d17a0516a67652b0e588d4e0debf0dab6e8a88a86bdcbf1099697e91ed83ceed4c6d9a29d65a91bd8b4a779366a8c79d469091b2934205251fa96b6e71402a175c290405ff54657018327500b8edc59df9c2d4b076b3a98822e8c186ab8a11c63fd2bf5d6fd784c38b42fd3916897068db5bff14e226eb6ba83aeab6115771e90f2b4e57db04f596ebd2699380263b0e55a49c6670a2638f89db33190ee17f5f16259c249502d72cee737b272ea5f78efeebc19d1da5fd0457a5b3ee3b0c8f285f6ed86dd334b187282d39c3b359a8a8873ec1ece242a3838c1e5f3f2c604b0a26c66cbe1a733a04ed02b4a75f499087ad512c322772e5dd93e96cfebd1fb1d3f6b5da4e61847c814c3b7325268d5c30dbe4816630e24e05aa2398635440e691988911371b6399ffc30b17a3d963ac8b00a1044977b5ae329d99af0685254abe7d96408169391bab7389a26f3b1aab66cb1ce1b366131293e720a08676f186ffc3a5cf0c41f2bbd03f4b55fbac878ef41284929b8a49f82be77def2a2905801096aa3d7a3c2b62d976e87c8f36aee8cac5c2e5d4539ae8d5416f020f1474894e76088191f34369d62145de16da4c72ddee78d453ff6fbc3c93a1c786d58cd31978cfca00e3f821d606fc67c3170b58f76735ad6a9c238d9c707c4904acc037ed30c16b9127bc6076b1a1544b8f8dcf9c431edc1b4bcaa69d6a64d029cb9b849f2c4906d8a9a0313da43e04bbf615577dce38361e7eaabf8ef80a0bf6dd4eef4f0d2477bc5ef8abad5f784b8278dace10427bb2db172293f485caa83baa45da1dbf4bed053df85f4a4af9e72974863bb52aa19c7604625ca1d36dc4d13b7ee34f87f9c9e940f6e386a5093ebcb956dda6f7c868ec3ba36e9b0f0abee0967412c5fd029f8e64796d50ad909f2d04bb3e2ded8cecdef7a04edb91611a4b0f2283dec82d5031e1ca0993a7c6c968d23939043bb2070fbdecdb5f8060ac6c05e2ac9b05eb2bb1ab303c7e5c86a1f595e5bd37906924aa1c0e291b7d319833a530120528ef53dad318b5b73d0770e8a99d3b7853c9bf416872b6c5b03c0ac8f801c92fdac79ad1f95d8a699ef4a34310eb022a69b973095499f4a5b280b94ab4d1e53dc353ba20c13dd30bffb5ed57270225b14f447e45496cd1c39f806f669875d2c3118df29636662f0211c72de2fde47653ab14ea102a257da552242f84e8a64ff898d2958bacb83d13e830a29f1d0b52c6a60b5bdea6171f1baa8543592e77118afd2856756d1308c3392ebcf46d3f47e5f7667fc5f59660533e656d9ced6f7503a0f81698189abca14ada2930dce01d61634b6c51eb113fd4bbe65ceeadd1d02008b4d8719200ca0722cfe4e4c1ecdf2c252d4efae856b611cad21f906f93ec7b34b42d2764ec04e8565927b9b48bc47eb8d5b170638f10be68d30858a346810735858a40aab065fbcb734c6480b2733fd39c687ecf14125f0f8bb419b1bdd841f2cae905a5c7105aaeb81b3a8c4da09dad4f5b3e67d8773320aee0d95959435b35206e4384969d984f45654489f96f12be5ad3ea50806f9ab3b7d5552cdb89ff8c846b55c7aa9dbb952580af1b9908b8b8c16933d6092e27ebf1a9d5785287f5079f885bb03c2cc48eb6e5cb08df06ec0e73b0dadcb16c62b6f001f34ccf6706f1bca72467697d3e42441db55285473a6b78db268a3103186f66b77a95ce8653dd00ff4ec8cdf731381c315196e4acb81d4617afb6910873c5a1d616c15fae4400e3d2e0782a7d4c3b4a59d5979d9eecb9c6d26f5413c300d5bdb8190dcda1d40d66dd2893ccd561879df1bab5bf955c3e74fabab44cf170380ee46f1f26bcb01b3de8ea54e867b5cea2c759ff7160348030629916b967a53c3a3d1293443e657ba730fb491d91a61508bfe006791ddceeb777320747105b7f6cbf3edff2c27dea0308e940521eab898bfc16e653fdc753ce92aa264d84358f53c3cd691a65916f5c0f3d97b8e528fa0d0d18c83e8ff824c89644c1e535eb1a24e13f15c647eccc1f2876c81a59713a988af3a7bc91dd88ee7e27eb70129f3865ee7aa98cbbdec2a373281ebbc4db2f6f7bd81d9137a258f77de1d2f1282cf924e69df8c762a3513264a08677f2097a8f0c62d576932e5d7125e4d684d00c13503d92553b4536d7cf9f7f56b6ee9304b8a8f41a5667869a3721f0f448bf1297be661aab308a80d1f0d2506005c16b2859f7cb926159c8779b90f851c3aa9e4536487267ca8a780a966fcddc6f15fc78750474e0d77e6a9c2eb53dadbdb1e1f8b6ea1ca2f00e7673228fbacf729d0fe897fc12993014452e86fe1146783dc9b26fa682a372ce18eac1f91aff2d41899c853aabf971bbf57d292a6511b5e3db21b80947ec7819a75963851355b143abfddb8923cbaa2ca686f03432daa28fca7537d84cd9004139db206b20ccde1785645dcd13c28665c9c7e58505bb8b2113ef3f3ffcce2f188ff503e5e767e88a5ec21b389bdbbadd71bff883aae3f63e38abae7008f60368b5e953b15026228b2760f75bb79afaec72f8270a811dcb4c17b1be2904b8bf5db50317b1bf7a53499dbed1b6c2525176a391b4e7439d9b3b6975671b5d96406233a3c1f3b2ac1f4938512e5d838f5880963d04934070d81a4dd86a56ca92a7270962e6f54639703a1733dd6bb3dc41628113ee752e848d4b3d70694b950b2f98e4389547eb4a1d25a850336a0d025c9795e9694b7ae7276123e02d6c0fd408d26b25cddb66471241efb1c0f47c8a91eaf2c4522ffa523c401c35808f55fcfd5ae28b7bb2350569080642cb11b350c850f94484444e7022f35e22f4c53da8bab3182fcc4e2df6b0317771f2fb82a65e3e3bbbc11782deebe80cdb2c7af10159edd124d736afbd13b8c8740e079852112b16531874aac6a8bd7d0882212225771689c6c667a95614d079f6cde251ec25d42b51e06a3abc5419ac77b0a22222e9a417c0ddf9bb6be1fe266a78a9d1ddb0584ff35d1a8e9c2a5357da1b1a3a3f0c4947dff44322744eeaf647306a36291be2daa5a915b05b50a11131c4a0466cd4d1cf984a01b1be7ca9340eab9ad2be0323d66c6d1bb7362dbccc52e90f67777c9c32cfc1fe180db15e70f8ecfce76457d404f3b8383c12715d1abf5401f61f47d1af51d9577d6730830de31b7a5c90faf70b92d796e235ec92b47889ad12480e495524ef88fa5712e68ee24a364536c4d9cb87eed12972b9fbf04b0e4db2f632ea464dee27709bee7926e010be59a80d1e1a9b7f94916884ec202a5e7638346bc8ec4aa108ae04be7a3971c2acc2a4f253a4ab620289f71258bb87470d3ae0aa52c6a34e52e8bb7b4b5739b80bfede22cd32360c48512ff86b159cfd0d46a663565842de86c5a122b90c49c4ea92c413a3a5c43ad172b40657b0efa5d5fe7996982ef764109102afb7ec4bd1d0d61ee96562d0288170f9fcd9b5b8defd31e54735333b6403812872878bb7c376c4d66ff339305657c3ec65b4153786429c07f3c1f33ffd7dd344e8a92a2a12cba0dc4249df83a39c3dfe3c174697a1c29820ddd66f9871b5e3a2d4bcc4fe24fe111fb2b86ec8f5a47ad8144c705e77dbbf1f925784900c6fd6d7b6d21e46c3757346e2b472a76062b050f3f512c0f70440dbd17d0e0f1b8d2f9c142f275e03fc15e66b1a67ef9dccfdda89e00d81ee20f3f0a684d92817244daf1f2b9318105a96ee63fb453d860dfa0a16437e09444ce88470533a504991c91a7f8146b22ee404c9ec872ed9e7ce32ec925ba83bd0c21f26a8bfa21217927fafea5175856a138654b3653a1fcfa6e8d7b8ceef2c032378cfdcdf6f69a7f64e3a39cf470f088a1fda8e57e92690bd6010bd76973e8b4799cdb52c61e83bec64afe54f3adcc52e3082f25f2bcbac3769a3056cff6b51248c0e9d59532396b8563939ab61d1b74c07c42bb6659719a9168cceffe3e4bd2c41b5fc332129361fcc4f60cd38d24a36a5026600ee469ecb1ec649d93e966fdb1e574c0ed8b899e1c65f19eb53f9a5ba799f0411d500e7aa67783ecb1fceea05de243224d2efcc46c40d619dae3075b047a037d243256e70982417f26cf994c9e9f58748fad799999d156975155ec271cce0dab3cebae3c5b3c198bd465c797df830ff5fd867d8796ba8b0999cf5285ead06351001f5d65a6d9515974a006993e021a170fcc3e1d4e4150b1bf9883003125946e56fe07b2bc562ec8a1cf1270b685a600593fff8ce28181a8dd598869ebf679f10c31e657fdbf5bc83a8e4fbc5ce5840c542dc52a7e782c59da9fcd50d426b13f436873ecad37fae00df8e923ae734949edaa8df3b3443804833e208ff9b13db1a4e3acede23e02a8d897cfceeafae0f9e82350037048a43cf18fa2c060c76b137373923bf802b65096a69ceb8238401415639f1d7804046a41ca1ac2bb3d6a2761c1109999b144181e767c2993a9d9c34b7e4f277cd47c4799e528382d5be5203dea88305b15c4d61121b83f71ba4ce645504bacb6ec2b667ecc87091d21f4276bb2e00be2fc2a731cda586548ab518f3d6aaf581d3b85a87cd07ae11c8efeda2fdf659c9c2e056e8074d4d8c5bb3d8560a75380210eeec51c9dedafdc87dfc8ca7ed6350beb2f57f6ff335bd56f9bc212cc279800a390ca2a239a252f5f69f660298f90983f0c55db9185b16dff3af500db2abaa4fd27954c36bd3c1e20a05db784374802ac3aa1af95b3246d43cf01030a502615ac4d5be8d67fad0f207169bd94445d51dc2109e53e0d0186b1a37cce8057bc7657a5235b624078f97b6b7be7a24fb46279386efdf5e41a3b393831794b7c839c441c497f235461a678016859c68f95ff514846f9daaa42ec13989fcb2adc26282655fc82fdae6e0af726f9e056bb2b865ea71a16b7d2d4f2d91077632ca9723ae242bf0e2b1c6aa76eb569c0d435082261b109ddf7a52dce6e8721a63488dab32de7ecbb4b58660120daea480fb69e9424a344818ddb2d6096083883e4faf3041f242cdb396a322371f72045947fc68d9b56908ec670bb39455b0a078556f88e1a92008b620de832a6cea433b2e13d946245c7e782c73ef7fd4a19bde2944794ba553c1e9add6216687b825197ed227e66a55715587f24adcd189ce2423fe1b8940386d2a639bf27cbc6bb74573c7a79b169c1e380d85e64b901fe68dcceee12ffb9dbd6fb7ee2f9c79bc4b6e22caca4a06f1b52b2b0e2a6ae115ec87e2137cb36bb0ba25e56f32c58f305ef3639063704278fd02f53281c498a0ea2500caa4d8afc38997046dc52a9625cfd55e13639ec91daceb866ae35fffc1533d0a9da0969515b0657a6cce3179297e4ca31d1cd238fce9a293d74eb87d8ad967fbb7dc37a13bf5efb57b842e447fdb4c71acf099d00d08ee9a981888b91c5d8e65aec72206b84d99d66d5d1d35dc64626a40d5d4f855a90804d5c87f1be7fd8d540a6b500a61d56b4c3201730ed9ec4d589ca8a4a2c7adeedf5937e5d7ab3fa0f1dcdce815bd2924fe1d6f0d53826067ff32a3200bd51309a4c381dad156baccbd3a73753793fb380d6fcd9466173ba69c9b6e605ef9623ff8b5e3789be65b5aff91ec068b4d316790fd83eeeba8d62ec9fdad8d13111fb5d60a1e25bf9945a3892413f0945527f5e4875e10cb3f21bf151660e347320ad1f689ba23df59f50aee7c1d3d24654870db7244efc8b103b592a0e2b8ea93542b80170a5ab9a617e194f75b4d68fc46844d5f65fbcddceb549ebeac80bc555832736431019df678fd9cdd6902e546113f03142d5fcb3045eaa19f6605d119af87098be5bad577556cee18381ad754093950d25f41457feeb61b293c3b7ffb337a5e38fc0c13d02003a20bf888ef148c7114bfd3e9b49fdd818d604211ac75f8256fae5b3ef17b714c7faeea24278b467296bee388fc8b6098d07f2a11c47f5b492abf773c202f34b5cbd1c67c0dd955ca3de5d3a4728d148c04fe98fc91fe084bc4a7da45d244a2ea8c27537f7ba4e64e7f7775594bc6b918bfad90d43ff1b0fdeb835fbaa2e01888ef0ce01484b160a5b2aab4ace96942961a5956037bcb9b64ef75ffce0f394abe1c81b90254b79ecf6122c8db948d28c470957c765f25f53c6bc42c774f9318411bef7683e5fd853cefa705779079d2657403ae4b57cc8af37cfa5f2c8a53a78ba061f40d255e4188321b3cffffde0dc4446bfb4a35640580c1656792b1dc71b3edef7f6146627dbdf22753cae5a7e6ac31a491a02252ab99b71a7b6f42222b3cffb032dc16b7b871238f84817a8cb89c53ba1f255e47b8df765eb72d95b49859e0c6f603cff902e41eac359154d0fefea2472c04b013c9d6790feffc11e6ffe0729889eee346b2b730921f1a6a40713a220cee3096e0bcc2eb0bb65b8997ba2fb8f41c4afc0e1990860a32343fa64cdc8fea762611d9a7773c4839ebf7087cffa6eaf4e6c34201d3aa89a1c98db49bfd53357411fab2f266562bce3a52462505e208dbb631327f65abe9eb2e59cd18dd47a196b00df2385f9ef500a24800fbfcb14b979a27d496ad7e70a0c66a186ecbe538d2a0a2663b7dae02aefdb0144b70490b5699949af79294c7d5376f5eb77fc9e38324914f2f3606cbdf307baecd8797c27eef47bd2e53d6a5a7c710cf45f13260135397f6574b1747c8aed5aa59a4bdc598c15300488036a49176f0089e2d318b60e57c765b35c8063d3644b43eca2c9b91ccc2de8f71ea7b436588607968865857c9f7531fb15b96d4807634ba98b8b5a8b3b9bf681fcb64b6304e5be83f5598365fc6719445edb1b7ad79779dbbaff72280274f96dba7980a050a27412302a29b3e26504633ce4f4db734d3acdea7cda880cb19095a57a0c816245e0c099d1d1b9a21ceb875c13ffa0262633ecb65c91f6b356b04a4202684b898130b087413d312d315c0c31894aa8642eb87b218f3a710af1208e1bc1552e6f5984fe60f811bd4e4bf891ee6167798dfb55172df5993e7660fb95d2e754858c4e70f13deb5405a4bcf4707dafea50fede490534c3190bff3a32a428d62f2d0f7d7ef05123f35ec8ab9c76ba1dec3cca9e0659e7d6499aee70082dfd476ee8a798aa4faa8f3e04817accf3a05d8b49a93db3e51fc05a07a755944d7a0ce3d3ef1ae4e90b5369dde673751b38ad67bdf03baa00eb36a395d0a74292e9e01feb5798918bf9440cd9d0ad1eb15df32766a663fa137ddc1e1141b6520debfdfa9cd41c0b2d2d74a4d4006f6007c8eff2f400a2e600f46fe8be3e4958bd08430f70b7a51cfd0d381015d559694ed9f0f76ae7a863521313c4dd008aba43e0b13db7684a873bedc5144f80117a321e5ae59541139e3f64d699b68fbc35eb5c172756f3697fe3134ed93f0a0e69ca9107739c2b8f747e6387ef3c664259febb56b595943f2e26eb5b6bd59ad920d60043d99a5e21f9e5a6a6773f7706086e55c79108c29430b5c9933ae7d1ff1c4d2692554f60edf2e0247f80287825fbc7627bab7f57e315dd2ff09a7e2d8eef3c5b1da8d64b0e5ab00793824e935f3d7d3e13b60edf1ee26f7c4f43afc022bef7f3cf967845f4e17db6f597d4e3a2ae78d5f5a8202588907f647ad1ffbc2cc392a49c6a84eb6a683efeb5fd1a5dc8810545643e9c8a628ce8b7ca45629030ccb486816f3d56e58664842e95bfff6ebe05dfe37518c71e36ac3c4182bc9997bab49a0078d778ec0663eded672e7ebbc1780ee712210d93621bab28d100b6d10308dec25983f59467ff60eb1cc2b2a4b951d6721c8bc224dad0145b5dd62755310151056b8bb6b15b7456e78274895f2a9ee4bb5cd93e5cd97b40deb8d19b5761de85400c80de104864d22b0c1f3f6f6bfc735be4b04137917ac4d2543d4bf1c52793341d74e170ca9b805a504b18d9296275c9855d13b3a644eaa00b727fb9225e83248249d9032fa4539a8793f1fce232bc3e57668173b2a5a4e598bff7d153f99b95a60d6747f925944110934b9e6ba626ff35322920bfc722e11ce5f3c4c4b61558f465b3af601b8a0ced66b4bb6b7ffc503ebcc20dd00dca0f9a19e58ff73720f85f0c6024cdd2290c44beb0ecdd11fe1356585d0d58bea0257aa407b303f14af7db5b7c9660c16ebbdf7a86209299ddffa287c0c7c07d73db0a0667241067ad57e1ecce066c254e15ade18ac2ade01c0f10dd62dfe6983fdcf8af0e93dcbe6813ef41062cf5786b183f5bd67a25368980cdf1a82f991faca8d94d697d399b5c140684a28839b4f8e04bc47ffc46b4cf26cc695ee41ecf9b75a69d103c8c4b29212a4faa2824606c642d4ec19430d7e37246089bd0aecc21e23ad88f48504ad9fde68e7c6fda78f7e561efa878576332c334d48560f52f63e0d5a9dab5910bccafc56a51563120e56d0a643621019cda06d74ca8bd955d2f549cba7a06721bbc6dda423c3c34204ee96fbe0860cbc967b131aec341a13159b916c7b54aa78cfa4539bcc0f0a13dca1a7887fd382511c55089455a2022fa1a9bb0482eb7fbb639ee7bdd4cf26c5a0930356f63f7d19865d4ebd55e4396410fc53aaec0b2cc4581813e3b2af23a687ea3578da2676800dbb9a60cbcb36b6988dd69249fb08a96252aa334b88fe72a860cb5317c98d52654e0cc05a68a8914518853eeed093c67dcd6cf3f01e500cbb3a3c9444409d740beb9b5e0e754c5611f48f54d6270fad448236a46fdee4a382d8c3038b6b4833f82ed7c649f056ff64414b0fca58174aa988d23121314395c41662e8747fac186184680b41812c5d865ffc833817969fe0cec29c9aa0b7a1ca24a28c71902caf3ecefe514bc147d1a405be4440dff312288d6b37ae331692dec102748eed9b0334da511bf3f613f53ce7c91c2718f34e07a617abbbde29bb466af5c45bd33d6695b602fc68f4829eb4ea3bf38ee16710acb183a524dd056bb249596a5d26074263f91af0b1e674a35fa8b427532dff8588da235f4c3671471f21acd4b92de14ad0ea4c4438c3c275a71eb526047187098acd2af116741043eb88a9bf7458c188b2ad7e509e2773812305d0b658ae79228d84173b2c24789a53dc8beb5966b327e05004c05c1d76c308b58ee697d16abca53ab4c62abbab9f8755998e0939fe9aa92e17a1d493aa1fc05625f596d311ec0826e8d2de172dfd8c067afb069381b23d424b1be9e7c2d5e08ff253a3124e03848928aad65d3f989c8562d5d293c75bc43d9782e451658d63fe9ecd78329fb1197911d25d7a53a15e8b860cc4447fd3610a01bf0bef0df4a359ec6fbb92f0be4ca0922ad62b7893b43bc3bd49f1189b3684a293926d873a0e1aea634d7abc461a41cfa701f6c0138faa6d40a591f457a50c0f475af0538254b22e42f43326a0603f90cfbe4a66f52239ce426ace63111b57a14de47b146cb75d5bca1a1125714b6864091ee53d74174ae4af08fbea1a2c0b8e418c24b2c333002cebd8ea278e3fea282a1dd9cf05ec53888c0f1fbbbb3a2dd04f242ff688687fd9f3f42d9d07f9eb4453eed4ca3a6d88f4593b0bdfc2a4911d51de057f021eccd17035b5cf597889ffdaa68348f8c0e64c9a6b909b4a6c353000ea382ac105170022d55248ebb9549a4f8b66a889df29484ace80785234bb0f0d56165f955d0828fe36c6ddbe9cef236b28d2614f2c9cb87898d59e8f22722531f20ee27089e92d496efbf2d702c9d34991c84ed708ded09a7b9c6a801f00a9d2eea5cfc3a547a47d93d796918e2a0257244f982e1f957e3d2b6bc646ed7ce84f75bf730bae11446c8ff6489a7925311e12a6875ce9fe815b0496311700d4985414689ef93a50891044ea41bac045a0456bdb81e381d003fb7a160768c5f4f5edc23525a738195ca3ad156c09c32d59109f5a10617eb0e28c718beaf1e9d6992e4508306cbec1ffc3b1a38ae46d01c4c09eed36dae68bc3b4524c2ab2d7536e817363f7bcf52aa11a6b4a92f8c9f224f542304c6ae0e6405ce19feae92c8b4ec39da1db641458d5b1cb67020732eebb60762753528f477b975a940d06faacd6d888b97a7094e860c10ccc37383d8c1239b4575184d0f53ac982f987bf68808fd3f935ab4a069a4bd180a25ad7525ef3a2d4ff17b04dc28d83b4012f07d38487430257d344c74b0ebdcfae86831dfc126e0e9b5a24c520b5dfd0d70c3e9dacc6e61fdb0f527146f758ab53ad21b79ac1346ee21836d5673fc948e995b60dd7bc8c65d1ab700ea8020dff9e22db6a211b1dd761949fb0c539ae47e337351869c27055e30affe12b513c194164d8c1f1cb89e17cbd3a8bc7cc398a85e9ccccdcc7146bf18052045595b678f161d733ea75e96ca6a32ea271425590b51b9277aef511eb645568310726812eb7a1a178acee293235e2e6788d31089cb2b81f5ba39b77e5cb832820fcd8e54eb96d6da8c3405e59c75c23d9628fd97082b004cbc5356bcbd2e9f9b0f8e85ea30847605c2718c220fb79c14459104e2fc0e165becb425a3aeb0942e7d2fea23270835410e66c00ca6ed9efd202b64200968f652ed01df9ae3627f049cedbcdb85b5df695958ed77e4ab6028751bff698d41a99a6d3783dbf643c0ab563bdf00ea6156ab23e9e64889acab64a651dbc3b181895660dad4b1507b2ba2ae2e9caec64511f02fde7f816787ff746b28a2418036c63e503bd9d3232e8a4f17ca1fd530e3989f9db6125d837f0e31cd9523b6f2f2e4c5c6175ec5ef6219d045a7f871471e09ad0bc8fb7c06c83f7818edcff3d5503b8f018a724c3b58088f3fcf9b583ac896f59e5e1c25ddfd2cf42bb13c9da4a676357044e7f578d7fdb0b17ae08a313c05ef05fb5a880ebc24abcb98a685bb021561b48bd6a947798f4edb0c832197932fa6d3521d252221aa62e4b169a18987eb2e1e3f18508184cc7e94daa5c48565810dcc28d43124d4f3d1e88388869d56a0e6de84cd84c90db4313c3649b45dfb7e9bfb6b6f191b986ca4b22c297db2522f016c5cd95c8e41bbda96c8d860c2623a39b44de30700c5334c91b617201f23697fcc6e623aad4e4bebe7759e9382cbe180c927aa868c0d99a470513f8d470d7190caf154b12d3c401dd0ed4a272d2e2e4ca61d40296fd1a66441ac3326f56a3f884358dd7bc4106a8dba8b7250544ef492155ca749b9db95610d67aae0b5be1d2610d7f17e10170ea6e25c0d76c1c99999d8bce4d497d553a16179fe26a5a92c2b3f7bc7dec3b566d93cf8f7991b0c966f645c8027a9e5043df873ac484050e0409cab59232b471c2ccc537051c2acf8bd606107fa81ec7f13ccb7d87a280e802fbd74e86cc497d38f2eea9d4ddff2e2e5c1ce8c5d338fcd4b0018c668f4b2a7640fec77b8d8379e0d6a520674f0f9096f98ba23c8e3c8ada745df625473e4c6c99f4b4b34499887c044e316874c3736c6efac6631cd0c13a6a7dcb9c603ad9fea962571a402ff0aa0b11a9f5e64efc84b563bf13e321aa575ebee7ed0dfaecb6ba33338d7c8bb971a1c4953b0c27f2fb2e82ee6801c843db7ea8086da80ef36d1ccd3b2294caa13809c6f4c680c4172acfaa36abef5966a10948c4c067db09e946839381cbbfa573c5f578491832aaaecb69b26524eb6ee8d7b056e1e8055178c2bb6e3f6416eb0e1c8a75ecece4e85725069c796628541d624ff2d1742e989a09144147e2ab15d0321281c6107c0c4299f3d7e63312d0d2c717ef11e9d6d30d415aaecb68d4015e0cd6866c44f67bdd841d5809835dbb040dba8c33e25c51c99f41cd5bbc9557edc6ac7c9d374e2d95e9ff687bb1424bdd66aefd28ae3aeaf777256f7a02da6b7cd432035845b88174361fe4fa4d44d7b348ae6efe216ff2205e15fc3688d61cf13ff867f2c3d4b889241321a396aa5646627b710431cfaff29dc356c08b0be4b84800fdd5df44dd10e46f32d3bb3eba751cb78d0a3e078a8b87992697cc990a4244f076c4cdca7acacc23151232d96a796904fed6a7e48cf5365ccf5ec72d5c7b407ffaec704016762bdb6520efb177a4324dcc96be808fca422be8fe2d2e69309a6aa04c3bc6663468def83b90ca86b563a67eb77c4a80be3ef157a8ae7015e37afee386eb5f696fdcee9398f7801791020357b7fd77eaba802443e0b251d718c8667f6dd3fc5097a08174bc35a6bd6175699c941a5ebe01a197a25e9d99f875b77574e4467b15b099640997fcbed686a5cb5c68d2560815f99d4bf7a0b6752963d2f34b9e9af3db3bacd8220bef94b201a498912b1a0ba63b9d25f6dbca8f63717d400935174f4e7ed1e6c81dbf14cfe8a9ecbbf871d8cf268b89b59cfb28c7fa85def4eb145db7ec04a3f59a9f270d89c656bb69244481bf851cf67f736a1fa3c45a009c43ade04f3f9eaa690f06bc46648ecc843c218e8b3d69b0469d1b45f2fe79787740fff5a9779dd2d95c22a1c241bf28bb4c17664f35461a53cbcbb3882c6bdcd0c44d4a4575b8e02d0f84a509dcec9f6665eb3f34e27c89cb52d9e5df339de49903c07873c25f426ff6d9e8ae8b6de9349a471f7fb6f3cffdeb3bb3e1409298b02a5d5b58ca30f37bc5bac20ac4b4341e1ac29c6867c6b9730fc61ff3007b48a9c7590d39f685e252c5931d64c422f81baa2a7f16441c9ea2dda556010e9f68332901d9fbee767073a1499efb1c57c5a84b689dd19d20d4e310c507ad6694b5d4c1677726a6132f2aec58714899a28c9765bc3a5e7d7b209d5317e48945274a0b2452a11a688cee6b85853023432d4bee6721d55468e778eaca300034e1f140372dfd8c61962cbceb2fe870eca0948b32969b36b9bb9dfb93f606b4982cb347f97dbb8d52c5fbf883f706279d735edc42aa874b5eb61b22a7a0e471d7cc7bffb267212356e20c2040a6d5590c4a65169532ea57081d87aa5002a92acf93607850e50c49fe69bf170bc2388a00e85a7ada98a5bc4c0b407891eca3aecf1603e151825c0f22d9dee75000c56b9bcff440746f90487a401ec523d18a60283a7feec1b968bdb5db65e839a64cc3eba0a23b482dddf549dcaff3318772e825376c27bf504c0d63bc26a2cf2f72e4c01d662ab86617ff6cc93ddb41d909e73f0546ad8fc8d8b7e34093f94990173e6be39c31d0e954c17d80e636ab1f8b830f2b1bbc906112f2902f48eeaa50fc4fedaee2c8692ff014cc88a36ba3fe5ae0ef20add5e2d1a81d718f80cf8ea8201458e2e274a343c2f69b8323caf556cacd89accdb17e3046a733113f3ba6be13ccaef3e63ea07e0b929452c21de2e304c1a5ea5269e12c2685e8ebc801392863b73a48531c3a89d5625fc0bd3596be11f3a980c130d4d400d50d3ab7380ff5cfa3a1af5075d3353131743e307b8dff12b642d6f58ca48937f848a3692eb08362745f90b014d0972ce737160b225b1fa6844e9c993ee329ef73ab14e25862f03a5c0b4295ba500fabc501617908b2fcd42912b79c33d95324284e55d7bb528ae099a65aef8f5e013e399a40ba0c21fe21a66abaccdafd24b43610f52640f478c20fe5837dedc4f31a198ff0aa5d867dfc56d5b3df8887c4d6f319f31b666567267acfc4cb8268f7a23caa12ba7644f380bddb89a710202f14f71bb76c9e73c3e91191302537fae3cef05581370ebc580293d0f24c8827cdd01c9f741fa44f3430562595721b212fd5bf4ca41105461e850067b8971669abab86a6f2e2bf3a56b5e0c09b2b97a74d113d550ad5a6c0676240ab5bf4558eaed38c15c32417611f7e99bdf5655e5b89d9795c174647d6d093daef0a8fe3909185a6e8880a5bd6bd42af395a6523f45e3ba3747460bf0f4dba9f656d4be9c74d58e9929d0c4906c1d5786f1cbb397b0df248864606d0174366860e89c89c9033d548e11ca8f0b47e1db5dd9a69fcff4d2d124acbf6c87ff55ef8bcf7fc6594914c2aa3c9bfc2aa6a0d5e81803df3a816791d3e12032c5d205a6b76eb9c25f5fb8019e22d68369fef2969fba9461d0d060862880fca84fce486a0ab2172d1fe047d0f65fdda16bc6a4277624c7b7ea65e7a87cdc85fd013f890bae70779a550db10002930b58bc683ec11e602799984d03443463052502df29cfb9e691031368e5f6f885adad99004c521c39155e7d8c187955a69a57d542ffedec919644223b9a2c8000ad29d133eeffa41a7287411783ba6e38908e84242d1339fb8c9b01daabaf75da7b59acbb349c54d737359338c24fcd8df00ad13e1fe11c37a12f6b966fa20f2a684fed6e8336afc43caeb686fdd3035ef8cc78aad96cce264d866daefeba4aa7031edbdeca8a73d4eddca6ca0fb7c03f581d8befa8bc35c4c70c14b5cac1a89eb1615ed9ad8bbd9572cdc57aaebef478f407cd3c4e4eb70243939f379a143f0dc0b52d62c5dff84782341dabb67f493df7da2d772092ce0e48ce4ea1622515c0a93a0af51463a3692ce72e9522e7e7d496a94b133f6e78f6f0d4b69f52f9d29040160c2369a3df6cfa5f5519adb48e65e6cb07ebdfb96d04d6a3ab89c6aabf1988f2fedcca63d77b1b3bb4dbb2faf857655a2b81f5c12d58449bb88acee60f7bfa7bcefc6919ee76bebdb8de72a29493c6b71b65e7c6d884baff2895646e840bcae202e0616fc396594b2abd6ae6880a96049fa8da7cda40b778a05c6e98580e745d4d2583c6055c62efcae52cd70c50f8a8b099148d64709d9143db2dce80c8a1a324dfddae14b7e3d8877ab9d70d33bdcf65325615b914d03c7023d10d398fe67471cd1f6f739173d739b5141f269763e8e1f0aa2445ea2f4b06806867e3a9620f4b70fa840b2344e3f5f38f3ae3057a255b090a408bbfd3f83f25a8813621b4bac305ad1b3fbd7095edcefc885cb2fcfe2e2455e0ddce2b5d1af48016bcd5e73ec5c47e96cbf530addfd9cbbc19e9eeae061ab4f2e9a4bffd4d12ca729f774e68fde66d0c7c5b508b18f3ea5f492673b40b600955115e5d3ad758ebf7cb39328ada5398c8ab1e24b60242114b474c12542c163f609544e0dc0edbb69b5b5a6bf797feeac998573b594747093073b4b71470e9785a9119ac905208666855daba8a5a49754186d431c17ea073125714253f5c3ccbffc49299663d2afdfbbbfea3205dff5517af9960e070616fc91d7146656847f4012fd7575370412e06ec7436192db89765087da2cde5248f7f599bdbd98223b885770436adea8232cf4a34dcdbf6b57afad3870642063784361aed6132a5f0eca22a07dfb2f2f7f7ae4477c74fe2909ad80208151d4c7bf340544406ca788af8e6c24fd1018e026f939b650e627f4116b7677b3fdf02f0f9c59673ac420b7d7dd0832e431e8ac8b97d054adb86425c6181b9be2e3058f1004012a3c6fc922b395724e0b3f314c77d041b6d592e1190add4652ae659fc9da402ef5bcca0435ba1614995a04ae5109ed095ef2f55deb9eb8333871dc852ff98aef3379e983294a34dd0feb354f3f8321fdf3d6df8561f3c15b504c79032d7acbb7b6f08934b0a056ae9284e25c12baa43eef6be979ea245448b9b71e6363543f6bdbfe3055500467d02af7135337998227760b3b81b01548077851ba59f35dffd626309a604d7973f8192fae0f8d0ecb568c28a64546f4d6a3eb513cbc18ba7c46b176cef233a69dd4d3e82e78433e289bb43d0a8da2388595a78bcfa07ba191468662da0c41d48762d817bed9599444190228b1649a348d87dac5cf882197f07fdb3733d857d5da1ec88e0fb4e145b119e615a414fdf3926e632b02f0a13188ebbc21a8ce50f93e4592844fddfa70f45f1443644ce7a80b47d8b932dec2b5ceb46ae1518ab5f873e10f23643bea2bbb8f937e43c05c522abcec1f9252fc81f37cb937eb155fdd09e11f2b7016d73555de9f662c9cd3d5f64c515576d61c4eaddc362ddeaa3bab5693110d8cfd53e9bba6215b692e8b433ed420acefef9484d1d1290249a272267f84e65ce2931b93b68773c81be5956c78b7fc3b7f748798a8a63a53f5cea9c0917600d7bf07e03ed94f6b9d47bd535a2323ddf931af8df828ce8e6d40e22f847884b40bde78e8fd7810b3b667a3c2b9d0fca30074e1bbb62df5a890856f53cf97e93bb1037994cb9042ccc317128123dffd20a541bd1893a125432a518500c6b22d0c69deb669eab075778289888bebc150601a231737d520af4bc0a01c8f03612fa5c46750ae18406a321232d4e386118854b7ee156b0bb7cd77ca900915825dd84444227287b64951c6dc9f02810d402283639a21d445c765e799dc78129858849208bbbcec016d7f4db7da753df27828f45288e95c975d6425b324e28218b0c41c3b0ccdf28a408006ca99b7044db7b07fc5fe229946fd17e06b651ee72c0d50e51ad5a08978df58359f21976efa68339682b82e3da806e831a05cd4d5644445bf5f74a49bced7f56dc02f3aa8e2365afe76272f9c8b009bfd2a9871577a82ffe3b64e40fd0f51c4cfa85fcb2ae5c9f25c7c65ef1df84d173013b85bd797c5cf9535353de230256f6c8e990abdf35e5adaaad13504da049de1ee692cb05310943c75b298453d14ab2b8470958b11f9ca1e7a903da1589caaba6b4be4708d7676071d3d8e6133f2907c38c4b5e58fa60643a44c66338c200c13d2adc4020641ad0be96395ae241ba54969c39930e2c7ef6818d93322a6c69505a4e03616791bb447fff098916d1d6d118b43d5780e17a576b14cbec4ea7da4068110e92081e56afd43c67ed18c7ebdadcc0c402d9268bb836bf6f1a4e06f9e3a3421cb2563bec19092558d9bfc97a9060bcc06240081a7f0025a5356878c3fc24f91058552cf2515529440f15c19ac5325b2445db3047173845374b2d360816d46711a8e5aed162e24a76ea056b723e57896c15a18f64962ee7132b3765ea2844910c38099964e08fcf9f17c028c23e843e12899861772de77ecc28c9596293aa352d04ed307d0149fc53ddbc385b68132e1a5c4da1bc6b932f176c7797bb5e6fa26a73ae2a5f8af2498af4bc2ea2e9bfb7871d9143215165674fd137f415d60fc0f86b0ce345873b6121f136a111fc8b47e30bd9d9c930a19bf2597e8be36c4dd8d3777662dad6daa8573afab1b6b26704bb01cb2a8a6319df222d47816df5e2133bf92bf0c08403595093084eb31873462172cb116fca7d68252830ef4f273a9c316f5d8109f419d69533e8bebc9ff5ce29759e7e362129a1e6fe03b8f875dba2ffc9811cc1d9f38b926ff06d9cde64256ce46dbed220560071ec58682c37924dadcf515d62072da217f15288b09f14ce8887c64fea71e6c97af324bd83197fab8c901ba25d055ba9d87fe3886a3f6a489d505e63596f25c3d7ae69e3e8ea9264afeb5f0f987d29d0ed59e08acf5aade3d1a8b5d3acb8301302b259061aaf2bca6d23ec82eb75a946521c3daffacdcf82cecce5cda794f0cf9879994b2e06ce4ce181e1c3a25a5d35683b32cc9702c7583f392e9ec023ca2bdceb7def0be334206a0d5db9fed8cb14730b1315688e508056271313a26275d335696acdec9131042b4db135b489a3411959ac66c4213c1349191fb2acfca0ceab6cb042e20e16be8c1d64f06c6bb960e991ad6a13c6940ed076998970ee4d216ebc920450aca3cbb794629d432d6c85d27cded2536c43e2a939c4c234f80c7f4f2a4e346d09b83d1cf71cac49493614a882238396cb040415aa723874e0879c45e449b6c5583276edbb7c1d04ef780aa286929f828fcc3e582b0b3e5e86000fea54d193b8f6cab9a3a1e60becbdc9abde4e1a1acfd6efc03c18467354c4af34fc93f9f8fa4fd72377d2baf4ed4f4d94dc7c7e89cd01b11c8eaf3bf96e222e54dc6694321118348fea18058fe893e8d6ff15aac9dbd00688a010939df55850fc12d152eadbcfcf743d244fff31f8521d109c9a23f1d2b8a9c647e498e9a221b1c73479c1059c8f95fadcc684126553b7bab5658117242b2bd96a9f4d7ce0e51d4903c754946b888269c92a504707b2250f671b81ec7b7317b7c50a0d95894d578bfd73a6606ec6bb1b822e1181eaa8f401da860f208c91c9c0162a484f704534a20465e594db1c2b633649ebe363dda8eab60f92f9aee4cc5bdba0ba77530c67497afa8a3008b835d84020ef884c2c19050d3e8dd2e5389c6face10d114178cb5e311ad387cd6b7cd5cbffe9fb0bd3cef2caa2239827059deaaa3c2bd3c8955262ee56a4c13ff8a7f9851359bd72bfec36c726bf4cffb40d3efc9ef3a8fe0a0ffd7757185ab4be4ba8665192c26410aeb85802b5837a17dfdf56155c2e4de8287937dff6a118a1fe878248c1f45311c3467fdfbae9674d9ac69e63fe3918d1ea42691aa03a98054704f0452aaf8a3ab30e9ce891b9e5d085f19143054e2fa6ad6cdd0f159d9338dccbbb8142434600f225bac56247407035e0841cfc28101c232d485a0795e6a60c52ed459076a17a830467cae3762056921a2f467237f9e6625e228b1bc17eaacd4e9b41f2ff4e30e5051bd688420a7931a68728921ccc6629fe19d9d31642e3163c107ae10c248e6eea31a9aa382b0c8092b1cac42fc0fce9af12fcea5b4556b0d9fe8b7dbd72d5835773b0c9f978cbe670f8a23af9e474b237b65841ab52cd87aac62eb7a6348bc5532b89cebb1f3d86d4dcb9baba742d600195dde0f7bf30f775c82bb95105b2ddcbd2bf70c7404297d7307269e4f6e55299d633068295d522c6ca3bc4baec58ab0f488bbafc0091cc974488509d32609c347a25906304fabb6b6e7c0ed1f94854539786f64be7f14ab5221a5242f13ca725275bb0062dea00f9b26fdbfbacdb333053ab32398b5aefd5dccad8df90be72698dd33aab3587c9458bb7ed923244b5207d0eea60933fa321e85207b7665bcc1c56b67be6b02acceb81ffa7606dd5e605fe2155ee03b870c7890f62c2f1496302a4640d1d54200cca6dc6ae28d10efba2ae7c5624dd4be1765363ed2add702dff23e9c20dfe2f908536faa01e0d7afb20f06af8d80988f3e5aff983cdd264589fad295d460df21404a997896986a3a88bd4c9f5f39db19c4d7f3fb8be1d5eec8f737c6baa06e86bf15bc000a8a2b7e153d7eed6f464325deac3a2ecc41c505a22c4826af28b939d3ca4f88e6ae28ef5cc259ec16cc098e77d5e6b6eda848c69cd596bee29a205b298997fc9b4cb32eeae77513980d6443bcdda3e47ad739c5cab3bfe672f48a038fb2af3ca80a4253f957751b36a101ddd214ca129215239b0f92d14de375d04452243b21f38fdf63d82bb6310f8e8e309c7390555cd868f8a9bb25bc749d7659c0afdaef93f0bef73584d0fc40c0b09d7919b3c8e7af834cc96998d0ac149c03b78e8a28368d3da2660c3b9af1ac00f3853e65c51a7607db79421730dcebba534725ed7777d24436ec5e81e7eadaee4c766286832086e164e63a85fa5f4cea11bc4e5f3b2b96198c919f6e499e2e8bc0628364dfa03b715d876ebffad8a356be87da784574e1d1d73ce594fb0ea4a58767ae6106e317ce28262d8a0053d795d356ff32a3be182999abe10520f8d29c19f415f32d6e33aa5a962ed4fb08b11f540b2d4a9c20992214aa48e8714a250e396e5719c4c9b0f2724d42977ed49ca47f121b64006d32878f6a136cb5098519401d407b68f8ee84aecba8ed61d1e7ab35edb16061441ded8a3b8637afaf121e700009f639929888a853a2ffd7105093d18c34e346ac6ac321751019ec6c109e59c5dd60b81895721d51ed1a37bcfc6596901639a4fcb6c1dc3bab37e4733e2057c640af13f0109cf84551d8be69f111d667feaa2842e1f14ffa190657d04a401c1930172c7980a5c9d7060bfcf6c4c04686d02a3e3be07be9e9b678b5c0646d5e2eba8037988c849c126db636c8225dbf2be5263ebc097502ea19a78a99feb143471e0f577c1bf5853d0a267f3012d72aea92215db6d2854f08e8657b34763e597ad57557d6360cedfee11c6075dbb213f287d25fb71855538a27bfb210ef536942e7a7cce48c0a452a0c83433dc27534c7c65a0ea6e474ee502469e4313811b8a036c25b7781d0ee02d3d615b1b4f8af1a71b164d77fecd8d354696040eee515e43160f70b230f60780dc1f7e8a69a92bf0703401952c2e67a8198701c7e76045874387abea4f6bc8a5ba2e6beb316991632c861c46105b102bd3cef29ceddab76bcc6b19c56019e651d36da4d75b3fcb4f7f0a45f93efb2f73c33106ffb0a5cc10d474141e9b402d58daae07395a2dccc68996a5930f004596d1069af6c35e589d14da52851bd2b0349c7e67d07531c220ef32a6edd4e81f916366339a97373ab93ba5e4bb459c5885ee89c2b1335412787ae7c553e8423ac5d61d7798cae22f1357430238f7b0828c30805bc40b8c792dd3a66f0684308976886963b3c76c63db50272ea5896f17ae5b958d426ff19863414c68bb6d00774b6eb70640b419a7467c8ff462a5dc32f7a305dc3d1ffdc88082dd7f1b712067d13ef475a8aea2fc0d32c02401e4317194a83c6518d3ca0cafad828441aaf486f82925d3e95c6c96ee7c45b7c942cfff583482940b2f9a636028e6113fa05db5942150cb16cb90fa2ad60db53465f8ce388e4ea7a00a0884c6aaeebb992ff7f9ddb1f410d299d65005f26f5b71a707a4cf59a85d3907ba4157540540c7445a5cef6997fed97cef2d4a9c6d69e3000157db072ef78776767b50d059dcb866ebea4bd421bb7809985fc5a4c5fa9fb6ae39bed6ac701491e2742f8ad6a84a11006855ff18f010d57256c6dba695f2ddb181fd6267d0bbfc60ec37f2b6d1d3df6463d495ec5f97e3b8cba41e1618d9ae3092c5c76d312aa3ca12efd1f1df9b878e7d7487e0701666192a3874590288a60c2d614fa92867d8fbc7a3b0e9cf5fa2ff304741530f2cc962125e39fa33e479cae6c5b37d1048d16f24e2471593d048adc5407662208913cf0d785d309108d895b306ef21c2f9696465fe0792bd127d6c01b777301c74940d21eaaec82ec4fc0a07e09b12467a3c40c68facd28c3e65b2bfe81d4c4d46e2637c9f37d8921913b0cb2fe63f0f1f0735aff0e0db28e05531da7340fda0ed2880f682a9ce50be67486a760bd9660e6358e6c1f4c0fd79ac1cb3ddbe77ea6ac8d65806dbb9c79e6b6b345b6bd7c8c4caac1d63a0524ffe791d410e1937f95343a5c59f53cc11588609c92828ab1391f0d44d7fd931b557fd41b4d29704e9527df4a847e87844beb8c8744c57ab9717656bca7fb7b801e1ed71aa58056aa0a34934b7fa67b5f8560f6323d8c12b45cf8d38e214686b32ed953171b6f592889a494a753a5836b3dce4703203355a7284ebc02aae33e36c3ebdbd01629fde271b1b2ea78bc1b52cbef44859a76245f4d5b0e54b079265b78f63ca3bba43a46e20d76ccbf80b97aa9f3de0e4c151af90b7a8913d994e99100b4b6e627e27ec3337e02d7b8deb7990d4b3d3b9f45e8d20f16cac6e23bd0bc6d3520506501b1f960101931fda5c8e13eac305ea07cd57159feccd3928fe776d7ca113553b94eeb1b4da8dee76b1bb801ea5792e63e58a75b0426c616f5302b18e9f73452954f7679aa3848a7aacecd6e37b564196a8fbce68dc7d0a8484d93206c258266ca2e0b7903560f102af128f604c3ce7d20ee20fdeefc9d13653f028d424f1f23614fa8d886cdda0b0f4b14befbc54726ed8bab17f4261251700c1f55ef5af2c20e599be07d53bf729e008d2a0a8c9ac64ee6223893ff900ffde4ceffbac8a1ba7dfbd50a8aaa3e09557241fb4818b63d2520eea915e238989fbc9b9791bb311aad5b0279726ddd2233173a32284913d79a1fc82fed99ac695cdb017984198b7eea8b691161e33f283afaaaf15b8fd2641200daa8bb522f0c4fd1bd58dfb37749ae30040fbf09afb6a0e0ee66bc4ce5ab35f944bc914ae46ff39ac80807b0bbdbbe06db230c87b39121f6b13389109017d6b15129ae1cc84f11962f80e941878c184d42f3224af59b7f45d2b41ba846af28ac032b8c296478813206dc7d2f1a10086def993bb94741ba1ad4382d1bf2e8791d9d52c628ea4787fc663b16aaf183045b38979a953f60201d452a87170d357bf673ad7033755b8ad1b67c3ee2ac4ee35f5481ceca264b79802269820af30a031d17eec6b567e020af2916bdc075339d7d3684b33b32c8680367be601ee7744e343ca74151d1e57503ed509f6526bf53b342fe8fe13be3f612d6c5f59239f493d0e6dc9b8ae997ad10fe2726dc27c6b233250670dae38ba804d5f80ddd1f45a3749701b22c5b770c79ceb6ddee059c7a17bb0531a2ddd4dded283fcd9d8cc430876f7ee57679306bad4093919ad5c9958493bcaec7240575fd376392236897866f1c89a11efb64bf32ae106bd7822553ff54cfcb5edfbb90bec0ed3d323bd8f585e4cca7dd69c11048b5877a20fdad3fb7191afbfeb35585aa97418e93bccc1956a50fd5808497058a992261672b6cfca241cbe6a46e69d8dfc9d8b9b8b326d768ef30854ac8a44dc211420e3ab576af8e3ec957dfe2cf41f50fb6296c0959674aa1d93caa9bbaaaf16fc652d92e2a7e81b0cb7c2a36950400da508f9d9da603ca41297c95a8087eb4079691c720fefaf5ce639f7a103a65ea4a09b2907bf964c65c8e665291f0176a5319655faae8e3bd2954409cdfc6dc86ae46f779edd2727ddd4a362118503e75f27c846e903330a695696a6c6782455df99898d55a0a511e9fac62740f1be7c35c1cf404ad77474a177021b175dcc2228be24b52552c465439799084d8f2320e201f1614b5c488553bdeb7e130f6a62dba830e88570e171dc703ddac3fc697951a56550f6cf8b62e546cd35eb1d87346531ceb3e46179e93eba26dafbd38d1436cfd8c455407d45b6c2b5bc7658b0959c23d5ea8bebade5e1639be474dbcd95b032ece4d10d4303c0e9c3c8a167f65a59745028581cc5758a3937fb34662cfef81eb56dcd886525b1fdafb58a876e3e1d2ffe21eee4a9bf1ea76b1be0c6f2ff3ba93aaecd844e92014a4244b162b1fb2166d1ca57416ab08c6bf964847429631e40fa51b7d9d0c5c376d8a8ce635e7c5e866f4533abb73ca6f27a9054a5217a985164fbe9929d9934d2e5e9300c94145551b4a6dd8668311589dab5cab0eca51b505dae44fbcf9d4b946d8eb3fd78cfbc662e884361f793c81fd762ed7fe3ea3350be0a5dcc6001ce85899caf70b5cb57b8a06a411f02937dde8501b1af1f9517acd4567386b30aa662e9e77cbff7a7887a80e8bdb2cb064657cc8eafce00edd696df59ed5d0a2081c54db05e8a6fff782478b8e784b8812ec7e8a0b04caafb1d4d9306623a0d60f6680b90f5b752f6e2dae87f4188d3f06572e9bdbb47835fba9d99f57ffa49cab7108dba903f5ad6cf30627565d04acc88d43102af5fb73057d80fb0588faef78f7bcf8af83b43bbdd812dd3aaa0f0d7f10ff816941eb4f520cd04cada8811632e55e5618c3e4f4fde49c419171ebb7332c1cb782d51aea7436cfdcc845ca841043d73d5cd3bc397e0c554224534447c141e090e76e01cc774c073f29a0691ebb39d332eb3b368d1f7da41012cc84abbc711650d0d5a3980fb7353ae69a54bd4d43e73365be90b5d51b7a1b8ef062fe81cda6734c85a84dfe8cb7c095f553a130e319458fc16fdbb6be2bfba257a7938f083eb4de67b4016720944cc04e4277cc9f28c0d298c939c80799a3c378e52802587a0089c38f5ce9e6df47825e7be470172659bc38da7f673256358cb6209e3d7ac891df57eed91bdaf4716a6640f4ceaddbc233ba01538daef030063108f139f5c80c64344b8395093efc9de7e0ec57c114302ec9d3f81e77c92bf9009fb240c68ae849882a877626e10437c8813ad1dbe3f7bbd9c8af15958e14f76e107ebbf6d1537fc7956687cddc3f4337a5ba5ea630aba562fdf03b1f3f1f8718c90eabcf7068166ed1b38a3969520d503856e6a93921f85ff2afb43ac7ac4252319dad68aab80aa5898d7194905b1805915f1a3ead8e0ad18df5e09b06580424b49b261f77ed5d3c92fc0d3bb09e4116df4d5ddbd73f5647a708721e05291c0ac684e825dd0f6ad1d87c8cbe88ac5017beeae88620a5683b4d83a76e013957045e69cc28143da6fdc0b09b1a7e3794fb132af15a1dd8a565f1359015c2fd50d00d55fcb4050eac5d86cd09b966658373ed6f3bbe83d8ac33ba3988c2560893caf6a7d652bc34cb4001ba8bc53d7d5c243515c6e7e10e776a80d53fc4415ea1d7080e0249639790b85d06837c7ef3e7b04fff283064e4f7ce25a617731f112648314e95eb2a91f6999065f9c30da42c91ca1e5d476865ad7389708fe704ab50fdfca6c4e98d85eff937c7fb1e7b94dcbc3da0d4eb55aa8f7f355f64196ab9a411667478784e34a9c21b5ab7d4421b3acddb3093de5fe4e2233294dd11d52f7c9b7547b1bedb9c3ab977906c8ee9ba8c72017e4d6abbd992a6b2dc1e6fbb38c5fef22e2137d9f9b2d2b52587de922101cae584dbb82741714837dc470c4f39ba808006d1e77aa0ddaf81084ad0aa812e544a863768515f977c4bbc321376da87f6e47f5937a4884ee57450b1335918a57a8a10b430526c0c7f68c729ba1310a1ee4ef9c3728b8af5ce6caa25694353ed3e5bed88f943f3dc705192807fa8050160117bf51ae8dec551a38d7805162ea10e9df85082a90ded7848f4badcc5174486c817008d62ffa6cea70c14bb1d91c1733c9fd2571584eef399fd05d17d0da39ed139017c65901c84a14cb4652cddeff97a4f3865c6f61539cffc3bbf5d9277b2e57674a519cea1cd30b83fe4c672fd99e7b0b9394bd5575dce6e7bd9181e005f7fbda5851db0472de01829a4c444e2a7ebf922a6bc060869b9460f6238eddbbb3522b0a41cdfbdcdae45ea352f5d5e7b6c5c864930b8e9ff2c87073effa8d7265d244bf027f1eba4c68b3e2bc7da6e0fe43b79efac1ed96ca48464b0d7409346b94a0c682cff5153e84308f50d79fed82d79a5cc61e13dcce5dd6248cdef29f2bd7b41baff22a4370f3c236826e2c6e8880dbbfa8eee2f57654ca4fe0d02a96537ef57310eebdd6aab5c718eea39bdb1c2395937314b27bbbfe7b3de11452953b8d64bb2a218c84f08b50e2f84b4c7dd107b0311005b4a30c30026d99281c7708afb262adb82696377e78fedc2ea787785989c2c84ab9c009444d1cfebf717447b3ef206639f9f58058c8ecfc89e92f78a92b991d023e494a9753503c40639b180bcb0adbfabf08ce29ab4f2f8dbf7e8f6b17ae375dc84142094e06a945eb20764b64216ba74ecf82c4f2a4dddeaeebd7789b7a67229724ed8004a08a1e8138cab0abbad6c0a60a373f6cda3a14510b668abdb6052aa0a073652adde14c7b5bd09752651b185e5cd67784308b3d5eda2ac3b2bb79e2dec97125cbf31006422ab2014c2aa157559d3489fc1c7359876f9e27e88c1fcdf294dcb1c699bfb751516b15dd4dd179bee4e85aae1f87dd201e4c1d9bc945000eb8c6fe5d11a37d0d1cc39e3df2504d73f9561161bbe2319d538ff2010982a5334b6e86cf8ae1ac619f9589c83d44f89b274c97ad046132d7b9af5604632878c6c10dc6036da04936a6b969bce6306fa5b4791ef3782db02c6812dc8327c94d6717e4be4957ed90b1c98bf38b465100886b64975b0fc8f1682d657e34063688234ac97423ee996f4a5f0a82be566bca5dfb153af0b5432d7f3c80180529b6a3f37b6d7122c5d208ab267994603989404922fa02beac7a0f15c639e81703bfac89551242d4f7313363e1b64a042f43a9abded62e0a71303add488e154bd6bdc46f8427f8be43cef96a3ecaec511ca5a3ab20bcc2962a9dc2c1a24f2551313ca1766eb4a86db54f1a75c3ae6328011c9c0bb61c04f7ccaaafde2c048459e8ef0d7474e2ec8c3a6388119e15be4d034258506afffff35e407e4c6cbe04494a1564515e4c6117abfeea9f86a1aeafeed16e37955c03011a549fba217d588294c81a6acaf027921bc71a121f2009344d85cb7d914923c05321f8d9c112973ee7f1333abac664598a93a77e77664a1978222df6d588b59663cb6097a0aac0753cbdc95c96fcc1fc39765483a2c10fe7448aa8efaa72d651f6ea252659c1305723868ada43dbebab4aef9777835f9aee2f2725ecb5efe4da81ff87da3ccd2d52429538c8242013b364eb1b6f40af515b26badea6d56b02fcca823ad4d2e25faee10b27351e626f0786f93e0c027c3fd35123e46a083d9734af68e878b25851b400e0c169fdbeb7e344b39422eb6f90a7876f99b956f7cf9da429adbe42cdf565b7d90576d69fa87419ab622972c019953d253641fc8b18dfa112994628f81dc7e618041036dc85958054247e8600cd142686462349dfa732607932476c6003b679c864c240e5919c094207772b78493cd63c298bf5b5f17929a0ef46a667c253b84add6a19eb9637a1c56f4573ec492e17b89294e1773262a488bea6b219dafc6f58be0829206158ab7773a80376301bc5470a827b4be99850b17ffcbfd7b0d1f14268db21574331be695c6f8edf85d15de96b43467a5a10a5bd863dbd440bcf29c7d2d0d739914110d22acce70870dea094654c3ae40b5402551db972d0987650a6044448402572ebcc0f76a4f6413ee3c2fcbafa8447edea18ffe2cfdd6807f9869c0b6b60dc41b769f19b6989ea9cf8dd08ce18b39ed7336fdfed37c86d467e774cd8a62816026c99eca658538026d43db3abdfce63051f01df35d7fa00d70fc959e30298392381bccecc40a5bde7425eff77628b2cf4913c197b4be45e23e2e01eed6f902e91a87e9a7280b881be61003ebbc6d95651dad81aec28d026d5420b878bc230e31fe966065fc0cd4ddab0fd981805c47faeb25c61002697dcdd935297c838bdc707ea02fcbcf233c6cce6ac88549a310a4679e7e522f8a56a0f6fdae210a5fe507281dc1cee3f6e382ae5da5fabe2a59ecfca0b8c2c2b129a447445137298297816d878392dcb1a10ba7084c0771985a764f35db5ae7d539d19843a682926703ce5b378d80079cf61378faf22293752d474e774af0d8cbf8734693431821a5a1cc6bb91b47d21dd60a1acfd528a27a597cab6803f6bd414d01d32655404bfe09f63c6803d59d8cce81bead1ee57124ea89fab451e615d39d4a8bd9cccf28514cc07864513cc3476f75f3831ea26b03783c1873f798b89d054ec3bd0251a37c4b18823f09044c3c02fbc1fd40f9be51fe5c591ec70e3e172f3caa51602ef7736df449a093ce90a7e56a5573c77ed1e2b534f64c497e9e021bb0b6dac98fcc887ec2fe72756ebd04cd6d68f0213c325ac9361b12a77a008099502e7d630a352a8f0ee5c8f52a983213e030dfb25536b3730c66bc20e57cdbcd4c8334ea8261b460805afda55a1f7e2bf14fb41c6dd003efa8008e24b431fefab05a42af30c8029d70f8683bb33e085affd96ba6172b8f98454ca8d93ec9c00b246df3094cc0cab0014afcd9235ae340a19920e36062869a55649493f66b8ec65e84cbe27cb08f3add937071c53be5cec1a51c5d8da8877f794a8451c5a59cea58e8185d9ab56a40b590a48514201ed1891e89caf34ad315bc92beee9e2c5a1352db3c0ebed7e6dcb36d9db5bc587ad74f3f8e877618616731e1f99dc36dcf73ea0757e33dbffbba3506f49187d9c5a8b44cc5dbf0ef5262704432f1e22e705cbd441339ac63c77cb59b47a9b8b5519094257586bf0dd5521142ef04a5197dc4e8189c89f9aa6398187f8e0aa06c8ee4325006633b7bc5e50065716f26beb97196e59f8d2b7f7f7854d5991423a471eadf34c8922572fd669b5b8011aff1009e64dcce25a239d679d2a513d0fbb59b6615fdb7a179e337d613342bcbb3788b25026d0707005a7be1385c49bf5484e1f9f3744f0471a117df4ed841f416d14ee57480046e277da9832971d4f8a819a314769ccc4b950293722e3529f0e7c43bbe0d895b991a4bee6cc6b499599626d35618f05bac94328c1ace53ec1f5ef950433e9b08cf333bfccb7eaa716a09c1f309513c068a5494ffb9bf13095bffe91207b1f7cda910bbe414bf540f952b56b0fb3def0e4d332d46bba908017a9524bf34aefec0c8a5cae0de692d0f517fa97952d996c89a9c08eaf174f4741e4a4295c126222770f021382682d7c8c8742fc64987b9a5ad46b6e5d863fddaf1428f88aac6fa494e52f7ae7b7dd429ff3828d2c2faf8071d27a72af1e90b138d2c2876ed5e605d3e67050243cc87aa8dc2e59c2503eccea77681e21ba2ef1722a1a6eaeace5aa3980f5a4926589ed7b796b1aecfc94b6e76c9aa478797dad3c1e6cab8836e2b5393432b95321b26501361253b15b91ea48ab67415d3e177585213a417bdb425d6e18ce75b16754bf9f308392553624cbed056f80b230a490349cc303d9e6862b1c56e11e47af9fcd1fb947d4847b81bd6c9c3d666d3bbe55d56c50304808ffebcbab83e1bb778da7a6da8420cfbde0586b6945b87d8ee541d0624b92b0d5154674e8aa14d3bf9d2d07cc3dd84bb2cd9df7b723ddb21b85cf5bc22c414e45284943755947778da3da127e665720b3089785a6370f391b0737fcc434417535ee6a3fc91c762e6aa131c213c6d6b03ff7057fa988db6887f98d5d17f69011e472baa5f3db0117e4b55a0561a9b77578a4fca408fd2628a042f68f59b06d16769d492114f641260a18c1cd7265a3caa45187dd5fe033096765cf31a07ad8de74490fb6e2b0cbe2f323c46906aa2890ad96c7691dba61a925d61be0f43da6f84aefc37f27f7c83d3777cd9b10a4c023a21223eb0674a18ee55e8c59d27fa4f2c8dc7a334067f87f741d5eee35f0650534ac6710b2d0d7e7f593e31cabfc9c8da2fdf9a89fb13078cacce4a6505d277d3a62073e0b32a8216958a3ef6212421ff033128f4a47813a60326f61f17e60b62daccd06d3af6136987236a6d2fa4d0daf407ad459584ac8dd4e88cfd90f8211ac6ab0d41c7e08fd9d3008bb46d65e063d3cee3c7b22e6eaefe2d54c7f2494e0fa679eb3cea3b580d71c3cbeff855905e19e9510728fbd63c8eb46fc8e2ddc5d7b686dca2401c79669c2f76bb2565d3b41d9f1d19223e2559b2fe5e865ca506f3bcb49b02fa6997fbb817043077b92b3e97cd76c463c877624da9b35956bc5b467ba49775279c85af7742fcd1b565de3cbf4335f8c9ef4221d2985bf67c5f771d1eb05f7c42d299d8d643d5bff95c060bacda1f27455ccf3ca2891b65412e92070f1599c118a0184afcb28f2361ef8a7ed8e0dbca4e0bdc66e8097988a252ddcde19aec599fe2eb6d5ec17363bc296308322ed3cd7b20081d34e26ab6e4d195cd8e06c7d108c3ae13bf658abf9cfb011f9cdcbaf590030fec716a0881406fdf4c2ef8536fcf992255e362256516add1bb5ba2cc08ddd61b899bb7a95c97bcedf20ae20093b5d6792836074c997b3189f7f0e062c67ad93b7a08db13a8addf4191e62e0cf7aeedbc630e1500115c8d00902945613f3dfc53fb466bc928a7f1a5409e15b70be30930bb142b6f88788a72d50f39708cc006186b3d69dceb0cd30bbd4cfaa8bdf67c5dc94a114c89e34b33d5b7a0fcba515be70fe5fdaf8160e10e294732ace085f60ea2d312c3d7dd547897d753ff2c44cecfef9c36ae48bf35cb50412dc17397fe90813d087493f78938df117fbb782fb0d8f8e5ffb0512009e2e02e2fec0c5351c6ba1ac05596f38973757f4de7cccece696ab970aae61b7aa6e108cc750d4aa7ec176f91f9e8e1a471734053099a5ff75cabf55b89a63a1de02d43a5716e2c7668af5b1e7a590b6dad36f45638aa215b4e741945820b71cba5b983b54363e8e29f2c66ee3115fb29868d6d8cf936c51d28829fb1a382e01dbe6cb2ec6e98cbd6e20534a442a570ca79097c44d7742a5916f758c599c501277d17ec817dd44cae2b44cd52217c835aa4fc737c30074b18db5a66060bad841c233e72060d83024c182241bb6f378fd3cb4df63e2bde9f2942e4073c0a934c2ea48e194551cf2ccf04f91b6b69a1e4a8bc839e599619a4168134d7f7f8906e994626a368c297c3ead7910f65fffe8a4992497bbf900149f7bbcdbebb69ba5e1007a25cde1f996a1f5e55e10c122f69303bd9dd28e8dfa5492cd79c873389d2f449cd666390e5b543c9600695039dcc43a58521a77af816350b4bed9e9382b0141f2e877e814bcc01085bce4f2602407918ba32fb067f33f1bc5c3b54bccc15145d0ea8b7757fb82bd351e4ee95bca169740e09462b12de3e392a3f0d9bf88dc7b0c0d86989032e01482f4c95521be369a8a3d7a2baf2028b4570259fb23d9de98d6a8717445ca8ce5bfd25b4bb8669b4a035316a7cf537a1965834470e0c3aa6c6eb5e2b23f04c3d14c8f7a99be19a5d4fc9c8ebdba5fd4c69c51ecf2398909466251e6dc4f74a982ecc6b4c530a5eaf696fa6f74c7720e08e397d9d683216e4e713f83fd118009722a5665e584c913df2b30b74630cd7ce05508627938b5f749c966caa108e555c41de37749eebc83d7986769453a46deeed45834957b2644651a4f779a043301ed82533d2eaca4d30f9eabbc8209c79a700fc0f4ca998412fbe6a820217a4c24171c5150e199201d0af06cd089ebcd51fede7ee9f07097b57b88c3f84216e9748caecd890fd3bf14779cfef5e476e9b8db2e53b7fbcc5a56e09d171eb3a1158c94c079052d2387f48a131989f4fc42caf410032e92ad7a0654fbbe7b6600af7c86704e3629236f36157e595898711243e2ead8249e18dba2fcbdf6399be7edb9065b050be15ce41ee507bf9d6d1a25728fd620676c9613860ddaa0be2db6d44dab8b9f2201884817456d2e87a30d5d565b6baab02db4ed0a8e54c43d5db5c15f80e0de104af86ed89669ef4ea8c6300dcf254dbaeaf1e8de7d5d0bda61eae30a271ec9b268a120655a9c2de430dd2891438d62563d51b62441aa4355768bbe84882f2c93d4a899d429197a235d3962c81008459d6052bd667ec3df50371da99357b1155f665a0bed731e489ffaf510e31f08d7296a8d9959d874751e7a375155daf6586a98781b8eff5d71f82780f709fbdaff65be3d986e2d303e20fdf23455b62a0d44a34d60eb81d9b0c6da69f25cb4f124e711063c36470199b9930b27f3b80b0d5be896e796d19426110ad36d413ee6b5da89ebbd9223a288cfafd4d119d60a78b25c60b25b8046d6567f43ea000fdda182cd0685ba415b31d96a382d45d73c31a6e52934e8e5be2827904d80b72923dfc11ab2b20a9d9e5e80701b0cd974a760bfd93cd748e5f46a4a42585692e611e8b8af0b97a93fb7fed16caa91c7d3eeef9817ec7632f7864a7a9c7d2d5e145338721b7c3bf9967aa2fedf47b387a14d0ed46495e31c43065daa2580d4654d99d09e4790d8d9f3a300ab790bbe5b480fb01c079f622dd1909ce0d478b1a099c1b7624ddf5dbce06574d05d06d2e7f5780b3ec9582cf11e17e29df3043f31b81c743167e4ed8437c87a2df5c962186e2b1c47de9beee7a0286fd6b4698a33aa4f96ba91ad5e3d219d35462b01b758e48c21bf544147defa49687a8259b5db58d42ce6adffbb976932ecf43b466b1955b71dea0b0b4d18f9a6548e43c574e470a44de13519c340d067878a72c1eea619bd571d5d67094c9469a0d31c6a924dcd01923ad78c6702427e167f7c870550b0d2db23eb8bf66b8a1e1c016e9a6d6a0ba1970e84c54fb623c74ab2312046dcf211f7b249c0864156577d8b0d17754022b47e44cda556081956fa3bf4189c523518c0ee6e559dd78f28d9fd04acb03517746bda975c0a09f1faa0cc0908c90f07b68bfe20b314b5ff3a2ee24faa390f2ad209427ff92d90a214da9d90f0df2c904474b1d11837e7eee4db395f46bc3f12ea03cd7683376f8241e9f2f188c635c5f9da329a2b47dc7d2824866359fc8527a88c297c54d1731d8c3529f47fba2febc1e1ce482ff90d0c83b2609f014edb8fd7d8ee6c455b3a6077c658ce7ecaef25baeec6b2d4f67bfa3011a444241bb2cc75a03951c567d0f637cd84df505ac10a652f36bcdb59f652e831249ee1628441baa258ad4f3b270e7c195ceb4ba25c71171106c86334381e14e6f687a233b28db91f89acd55356e15da389fecd2c2dfde8c8f281a90bd27249684c788435b0d3ed5cc33696deadbc8003955c685ae818a9ca9f341d57e48606d4d79a8f21864736219743913c9960e3f7521919dd735ef654bc1d3104aa4ecba8c7c050449d9e113d18fc3a8651eea5e3e53fc73f1ca59be43772fbf3d271424b4e272701df3af000db7d530660c8dc4c4ea90f5b1b30c3bd8604cc79aea18083ba56d44d232b7cbf0051d0baf0108d5c8be452df6eb76566f6be21de259a57fc1f9ca231ef5a9e5354e394d6f4af1a624bd2ded1fe44982b126400df865759c88fdfc44c838bd99a769a4f3f150bc34e2cd600071420019a1747832d1e4b6fdae0d8684f3af04cf51a4f311075d93a398cbfc7ad1e41c9087beeadeca198d88a08e5527e378851c953435d1944bd28dbe9cb3ec3cc07d50a7cd2e7356ca6f91403fec036658f2efeeee5df5b218d0113d564f59d702decfcc9a94494858aa6184c97c061c3a0d283e2f4b28d4d77be636f7bb961b72dbe7d38f6b68a7f1e791be76019030664d8c7c8d0d59aad6800727ca3848caf9f5df183c38e0c1fc45205f8326db183e05e426d13c9219d6177880250be6e1f39e2fe25ca3202d72461a2eba3331574cf66ea68bbccf490a2cf157bd31fa92b765e0f3a68d6c91276dc21300bc66c7e8777bece7e189989daf92a9305b9b64d1f3bd471220bb2500c3d987df2c607985b473fe816e6cc55c15efe7bb0ce5f9a2758c0199f70800c47d57dae37cecd328704f201978dfba4c7716acb278e46589d078a2d4d72ee791f942e286169b8bb01a5df472024c8e9c6216eecaadb5de6a614ad7c29f6270fe4336bd3e62d5469d35415b284058b0cdbd9aa1f75d36cf2c58de7de531c4cdfea3fd7a471d1435ac5b32401ab71ceedcf1fe50b9def8fffdaf6bd7866b3f2c4442b7ab553fabb038714a1cac5eecfb8cc608ade2527b53ca3dcf60fc1d1a15cbb2941ebbac006f0a258a595af710106272826fce3c422abaa801c703a1856cfa39b7d3160a701cddc554e07fe658bcd87cfec401727ed94ec79fedee97e016d50a46041b5289dcad2ea3d1f9e8fc729ccb231d1dc1283539cb331a1fa3008172bf283fad2d36249fc0917840b68c4e94b15ef79dac82266d0288a8ebbe8c37ac2d6634baa5ae7d85f0b05e07409c5f36f3146a1c5925fd80919a5b65c71fe1b548cdfa939e15b869a86334d5ff2c077c25ef7c6a713a1f8d13662150d707a2f9dedbc1bc953ff7a12d054d29aece0f1e2d5e794023fa35ee87e62576a5a6b45fcf321cf6e88aaea6ef51cef992a04fd075da27f357df641bbfb8eae748cfbc32d071b435e764452afbec5387e3e3df5f812d6f6c62d7c2024b691b678c4c6312d891a00c4db4b067cca8b066ce6546aa9a1d325736aeeb4a2795969a1e75c50051072e02f4151118a55302ef7c94162e05c124422a8583d90df9a2324d6c306996edce8cf677b622c9e79d0ba2cb56b9534ab7528959811054a4bb93842f31baf04f2b0fdd5044c6c1eae356e4a9180ededdd3b715ee2896a14269a4ff157c1cacdb65be063b85143081eba08896db801c98a7578573e35f3442c06388b52ed9a4d0b2025607947d08899cac6ed12cbd994b8ef32db096073771f52281fb8850ac83a611023bebfa158f4f0214a006344361186481e70ea538f073cdad2515a3b2a6f5769ac0fca6f0889f00d66e93f77d164d34195f86e99fbae4f2dc459eff5a83a4802378a01df4ab4f20c053429a11922728b83f9b839fd245b0102031858600f4fdf8261eb263557c3ec037bb0d7c4e1cc70421e8b396d3bf33aa5f160cc2fc6b53df55aa5b511561d3ff50dc40ac6dd7e70d1e6b54cf50b08247fbe4a94a41bddfd934de42ae91c07df926d11e8b972448c4b267ef28a70899a8674546f042fb53150aa424457153f1513d137d8e6a37b76ef85534842871bbf2916d6287105c6d109f0de949a32b82df0a4ca7f4b9634bf82ffd60c3b35db15ee18ab16ad06c8da34374a220f682690f904246e7a16d262fa63318d7fa0324b55e1acd23f7ecc550ea7c6406d319bad954407e46c103a5c7dd5b9762ab3bd0ed150fdb8991cf60cdeffd54837093255f46b13dc0916961c084cecc60d9e3eb6ac3421f55b76c1eed70f1800baf2cc4191b405bfd9dfa30a3215b0536254a29a37d3ea271a83dd61ce3e79cfe4f0e0f2ce0ccc6d42c5956bd84eeea5bc0c1561276434f0c11f940b0d05b120088e5222a298678bb2458357bc6c7820a1c126a21d956ae0538ac2ca6171107d395862693e2c9f305683699b73b63ead96b2ffa07805e7aac0e961e98fa5a047b65fa9e674d481734ac3bbaa66c7d66a84e2a4041bcb1a8f8cc49fc62756912c1fb825f7fd4fb96cc8f18302f81052147c994cc5a2ed88515286867b034df79fcffd5654378faca46b1a13a05b53641dd0e1c2bf9bea90485e01363c77e9da05e6ca6a29f83a72128bf1416d1729dabc790adea09631094861e7ab779a9a965dca4179f1fc2c9316974b41c49f7d5f5f6026031bb1a7a975aa521cf8ec67858a2287d13015f39c1b92a3fa6c050f963c098dba97082646506e3dda85016901942c44565bad5184c6049700b634f37b08935b54d7c4f8d8736008d0cec54eb2766827ea7987bed7e041680f8bd70f22fba6ed9c30e4605de44cf8879475d72b615460ec6075e4c166697e1dab86a0b2a83568a162b7117ae96cb4c462455adc75bf25c589af21dc625de2fb5f98b5c7636b32842a07b5fbc4eac9a95057404b6ce02d82e1f308d181c6c3865985b311244577610f32671fce6627748e9a88a7abee38831ef0e0ce8759f2658e8ecf4d2b94a543162d39adbb57a3c2c1cc42a6b87585366f9b23ca11ca655d4409978ce20bf0275036afe226cf736e72f215b110fc59e5930b01904c3ab72da2786ac8a92acf127434422d9182b5f30942bb64ccdf7f90b501dba88b82a6046d66fbcb936b7d34f732dfb476f8e86927ab7f5fa37cc3dc8be3c80aea5e947dd3bed2684834791d552665b63760700c4adac55f2bc8760fa415139c5e6c0832684dcbfd865f06037a282baee2ea165314d783b26c92ed1adbb3ba85eee12adaaddb944d031aac1381a977522972869aa921c0f1258202bb5c75f155e71d4afdd65b33a59604b5db38a5075e0adad05ce8811c1359b591a1b9219df24a7259329b7c7f52ff33b1b91fca8c2afae0e8f9829148c6fba7fcb2e65cda5bd7166ef043fda26aa8b3f262caa22b1b9401261039688923e5a3a85237b8763e54ca42ef521b9de033a61178e63efad61ea0c764b3b739aa52867ebfa4e673561078b417647dc4ebc0fb67294b8d89536dfd6a5cc412468f9e186b80f4aa89a1b82947042d113ebe28fb95ebc99456afe64f93030f12b25b0193e0e08f96a161f3a89f11bc6c868bab88fc3bb1fd57dcbef22ba7568611db7821527d1ef85bef687708ff5865eddec729467533ea751aaad2fefcf8ee0e5a2e6cbbdf3569895c242fef1ea9b815423643dbb323f00b42951e3bdc54f9e634f635172cb042b2e675f06617f9d6773343f36dcaba226bde2ccaf8851fe4ebb5c21ce8dc7bdf9039c13da432ce17de6c01386d46567f59183d9fac7dea3f02442469b38ff6fd9281e188833f21e4ea790ec6938463bc8e703472b3f15bac25e130a381e124c05b4e0dc10102e5ab8f9ee31159d5e86d364a538dceb3dbdfe3f86c545f5b59c341456463bf33bace930ded9281b15eaf7245528da0c1b67ddb7e8ff7de6e1c88cfa390eb8514f3f9136fe1348bfeca06d76989b9325dfbfc445d3b98938267eb43922605bc8a48e0feb6134140635001ee20e2586fb58f286833080e980e85c21046ab89f2d3e299984bb9c62aaca31db2001ea4a91e458f2564740f0ac927c35df46d2a5ac5976df97b5eae194019f515663cbd12dbe9906b749a9289e28ac185949ca0499c803e8c4603329fa43c387bdf088344739b93c0b9c312bb52adf696723e61ba5e495b916f9a68951224003c671c2fba9edb52bf58325bc834fa70d291fe1dcbcbdbf69be7e4f0941af229276edb6b54bc29289493bc68df33f00930dfefce3edc47241282e38c7d5937eefab53af7d7da22a3826813cdb0079a3bdb33b59cf9d20bcab1fb58acf23c26aaebfb54f66b516ac55d80cebff100eaf8b227b7c586dd1da30951167adad7cadc22731bd51be8dcbc106d97b2daa54a3cc7b351849444590efd640bfde1c6b8ae3c0fabec5990d00419380ecfa85ef657e0a4230f742c311f44f75543f524e1f6ca9e103277ad626d0841413e1d32e833f9dde9079ce5ca1cebeac85aca8f8293d0b585de2eed16a6046cd27afe91778dc06a901028cde15ed0dca50f573c651a466870591bb0488f45a023389437f1fc186263c954bd1642280a8307571bd5579ad4afab3d0231c49b96249a2c10bffd9798892e030e8dbff98697d3c90d0cd02d7eff6a79238385e6f79b929739f175072333263b25f70da1c4e7027129fe7ad1777b5b16a0e16a9bcb053aaa0e3a42e8a82514a79774944d680c12550dba3e515e8ffc41f9ad07463661e3bf43af1bed86907214d9e36183718d534046cf40e922dad58addf4fd0288877b3313e2c47bc152c3f47c894d99b00b9142c36c03caa5d09f66f178d0039be67de67920cc2dc71ca8de062fe03b8db2322d5a296798202953ab271e230c82b869be83f158520318930c4b1b27e91cac2f1a5ca816eb6059c116aa37fff986122c24a81e6b6d40fe4cdb5e869c768991e7e2398c95d1d2b197c8517a1f377965648536dca9b4daca804e196b638ac7114aa63869284a5bdf95c5af953d474c49c2d2d2e26193c26f988c23d82e219d485f4836aa0fcb02de4f74a5b5d93f06aefc00028c99264f38795e99224f0af87f58ef7d991bbc6fa60a228d6efa48fecb0b89c64332c2e0c319b2399c89699455ce87acff73fa3020227ff2d5f1216b6d60ea4ce1e66c53c27e1a27af9136f37eb63fa50a8a56d822ee1edbc94a9a416bcc23a8b8966041dc664e388134bca0a5e809966e8f13e58f4bf99ea89f1a6377b13a9e77b58c1571d1a6d8808a1acb15bf1d0cf3796c7ecfc5ec50fb411a1c8ed4b8841fe812ee1497a0787dccc528397d7618de8e0cfe39dc36b7d448a8f2a8e52a2daecfca4ef87d608e2dbc042f18ab5384efad944a3806fbd3e6d1e5c48c64a1e147c2bda3a38f2b2644ea73985b82b815de17180225e8c4fd90ff8737cd0c3371f4bbab93b0f8eb027886813b88deeae38838a27438a2fc87688458745f5c784c412086226b66ae4e1ed0f2306fdff7bb4e11ae6e094275fbfd5ab53856190db25afef5a384a927db3ab05d4a0c922c953d3cacd36c26e2dee09e0f34a1f414eb6d69d27d42602cf22780aed84c819c150c258208be945a0f245a6eb6e988b297661facbad28d36b63782a6c27805a0260f01072edad5dca8e480e9aee6fd900b5928466cb04fe412f11b56eb378652999d43892b58f0c57e95422ffac1895bba2b5116de4155783dca73a8e86da810db93c84889c77c5b24114f010169e345b45164c7971a5958c582aed609668effb9e9b2f91a00204685b4abb5a6e2798132a8cbb72f8b9e8e347faaf1ad09e686398c09437accee110e043bb58704eeca33c9d67aed68614940c8c15bea1a7ecf76ed704551795dae649d27fe8721dddd286539553c37395a898fcd4d81ad80499dfcfb0e751365efb077f9a2b18b84fab07575c3ed1cacb8ec5b605228583e28eb77f324d05e370e75b43a4663032767665bcdf44b4f91fc633feeca1ed8aae4c5ca9efe1cd03126f68237a4ce6d66edba380a49fcdc6de675b86468142149b6dee98d8a7013bfb734d8920ac76cf559e41bdbd9b102aad6362186b55f134a1e67df9fa894e97d2675fd1fdadfb11dfcd8c9d1f0af735853d9cd368b84520e5f55f905ac3266533a5837af08db26992c5c3c0a8a1c404c88ce3ccc9a0af61001b9cbcfe0cdd805a08307429f674525c11a255adc224365c276fa58e6a30e7e4f1f7920ff8dea9c69daca693c30380998d7077ecce5424ef3611ae246a3395dd707f309bcd9ba0a8745b66991399f8014a8bd1974422c6332206865e7c2bc45ed68242f39c10491530c7413e490119e9840738aa362141939a2b199c83ae406274438ba903897ec0abde33b8d4ab6c10e5174785b1fea0ce629cd5c3c279d8ce24a6ee84e22aa904ba5be137bd08e3163f155cf543301d1baca3cd56b3f868dbc922f69f329da229ada22a6b0804cba081e5243783de1ac5d7a9167d0dbf03c185a5512736ed5f7e1d2463dc19bcb807344e6d2659302c618b1efc1bc4c8c509ddcd3f7b8fc0288ea8cd77357838d559cdf06c4eee36293599a576ad280b526b7373bc91d1aafb2e648c347b048ccec80247a749aa91b1133d5926e89fba4bf155fc073f45e862de9d072991e8b0157a2be2bf5246d64e4dbc4e90ead1bf5882921c06b02a169ad6b51b32087a6faf6859c8bd0f9d7aa832c71027fdfb13ab0ab3beeacfeade42cc8c1d206e331d4fb33cc498cbd96aa8124f78a2210e7a9ce1680a27415d6d133c1dcb003c2cd7616b967016fc60baf4d658991fd0a7301452a08f6f56946f42afaa8c611c3426fbba891a4d29fd16816b500ac6ae722368c687aa2cb8d3393957a91668b1ef03bc39681bbd4870d01007efc508b98af9814995ed5b70bd45f822d0eb7c91b8a69a49ba0c885f09154894e9304515fe46f0a48826956de2a30a465dc292c992819d4d5b563d100d180cf58933a705515417c436d38c2f8a1584a55c771c588a5c912e422de38139f2c5af2521008e5e540ec1ee675d2bd74aedf950039c96f4b7e8c6e30822237c5363e1511404c4f5fa64baf86478186ea7caea1081a3ce7d39cbc9c6abfefae63b4afe0e5ef082657dabb93600a412061f7665a279d551db61cf79b0dd6447024698f16433e6ad225bd36a8b1f8814a27f24c83743c7a54c5e1511d82d3eca63d231b9b04ae0b0fad7c6c91a8216e3a27ec004570b0b1611f5c6ad5e9f18c3044a5abfa10d4f56caeb4ba3639e5ed1961b38fab2b07042d6bc72cfebbacea20ce0756e289e8dacd71d31d4101665b82352ed3270148363767a353d5711ce03de5bc59a48c1d95eabbfc62a13ca3e7078013360bdda5f50fc83fcf1a436b3a81499f7fb782dda3ce14e5ad0bca2c98ac819b9b1116829edc6675a694f274a69b83b7f135025327585e5f9b743fa3f06a9b7383d4d5c172d7bfe62a8aaae37f6ec7a09e5b3edca3bdba96e6980e76cfadd87e8154113841cec0618c4ae95bcf90a6b7ee0d084ca904c32e7c77b991c1d7492dc876112636a2e73cf0a57d8904cc927c6c4f5e1a54880dc453d216f014bb2e74d3828b14cbc9b0c93271931f01a130d404cd8ee6807a04873db2a63c3e22f1b039a3498792cd55366206d01ddac0790faf54e6ec745d0ceb0ee2f6feb94aef00476b634deacadb78d3c27eec4c91afe59f56f151b088faa33e7017fd6d6116d84e4c067075f4711d6b85cd2146af1dcaa56b4c6599a8db6b0d301fc8b30e4de08e20ce019d0f2012553519020067ac47f0ca043eb23b0a4bce39c0a4a1e9ad6b15a1ad503df5c4c9ef3c4a0d2f3e434c4fd488521415955cbe65ec41dbfe91035df1663c131465502005412b6b68fb8dea8a28eeffdff54821d589ef2f4f6bde351494b373edc82a9e825249845122748c1226a6679317f1046b3747904f6f4625723f9955966b1b07a9d47ab9180c2edf3656308202ad03244f21797167113b9a560c95bc39b926b4f2baeed90fb6e165e4503d974ed776dc6be5ae88744dd73571ef8f21939d705adb424c2f3d391c8faf31386e701c2014ef8736e547c246ed5777df8b7662cd7b64b048b1dc0ceef84ce80d00b3ade432cd7767d4249c53fa00a561ac47de1f8c941a886adb185de216195e4f37fe3b0f3ea373a6444fd76649540b7280f2de79f2471b275c9816d18b8db7946fa9fec63b9c965f5322987e7134ab3d2f5a5cf90c9b2c7d37cc8aa5cd34c23ea3a9bb0304cd549df2885d9a9c50e31076c8a68bf30eae00767ddcb222b478a06fde0d179dbcbc7b364e458653289bd2095721bbbd431afbd74f4ef37587d38942e3abb04c63dc12278fa33c02586c09b3442a71029b9a504de4171dd2b18771e0352cad1d8fdc384285f7cd79d1cb3ad1036b99606424547fcbcc2eeefdba48e1acb7a15e587491f820bf156ca4f173d598ab80f8195f2c4848bf059ccecf8b2f3e245623a6a6972d74334bf356c15fc448437eeeac651335e208b4597faaa58c153254c3c2fb3ab9ec37940bce34b3b9978080ece1b42b0ac82297c15412450afbe40f5900a9ddea5e068012c60ba86097a2059fbdd8dc3e0238a317fd0fd6910934f2446d58fd00e061b64fdbc1b37b853de43901abaa7a759bf2c2a06beb5cb589bca7988294b0705a3768220da761ba2407eeb634421db50b6cca82ac067c22ce50e9668c4ea277eb3ee95067e87ae733ea77ce8407bba5ae3d5f313cd754cbf5e637f61afdf30bff3ec475638ac4a5913692c90dc899efeefd52468fbb1b774e1efd924f59b40fa069cc41d294515445567f785c553341a57e9ab775095d80042671bcddff681a65f438e0f6f5c7463a3884c639b4b76137c2d1b7f4647a6b9a6d08392dc38a335e95275f4e37de430ac76b96893c8713970db5264c3726cd4cebff3afae2055d0fb916a8ab3fe65329c6ffae787ebbc64ac5a791092ae7809c0bd3942575baed41986b08aa223edf4ce293b7cb019d1bea9e2fc44a649a2f79cac9fda64ffebbb6a3ee49b83bde1c28c37a4461fc2b35b8b376e8912aef25c64b6766d30f191803b34a5b3e99ced0d7d590f338ed98db452cca37cd6be87a3386f95c696fc896220391889f0aac5a9758af9891a1cb6e45901e3b74b85e86a5380d8215f4bbab8758b5431bfa2b1499e93b7af089dea8fa40879bdc1a7ca7a46ff70c612a1814b587107dce998eff1b7c979d236da030f047c082284a425b8f554e603c09f610aa3edd8b57d131c61820ae23917714fcdc6ea78b70bb03a388e56dae97cfe371ab28bca6dec70107207a6bb5655df082e388be420b27e7ba5c5ef3adbba95f6f336d32ec84dcfef44322400074c61fc194f0aa3614326a20d6ff435e54b05e55121a26fb7b5dc0452762a342d7823f096181b898940edbe83cb205dc5f5fcafd0940661b4854ef6f8bf38de8aa1724a760be536def0ede67fab4a3457377ff1a6e6820f6ee4bca39f871f937690b53529e6b8f4c735beb259b56cdaf07584e52939169de140ca197562b6b0dc3f988704d9aa2b23333cc26a905f529c1457a26170fbaa94ae25bda98dc66a802df3028960b65e08b63238018bfd4d2e1bb3db24a826d180e39f12dcab0f5874b3bf042e1d8d74bedebe23f40fce3fc5adcc4324a9e44ce3eeaf1671f8a235749a61ce0cd839aa0db15d0a299c7e3622e4e2f628b92e3da09f1fc25e33583e91f2c40f73aeb745038a30b9bbf8c566c115e13a2ecc551d28ddd483c57ada847ae549baa0e26d0b33f1781a6688d03828401f7f58e037b75b9b21e74e5eeaecb76069f69a5ef3abad98875f554a27672d070dacd045ab1ea26a55d9a394cb04dbe8e73e31225e72a20df01e16a147de69b68aba09fb42786f587f5dd1e434f60b4f871c99ecd2b753cd38eb17be7ace50ac8d056e6a57622e4926d7e3a18329db685a861274c0011ff945db56ae5da6a9a2ca0847ef118092e935fcafd73800101895ae953a2866fd27901a7b015a2082a61e9741223ef6aec86f66d6933675a5d217fc7c0217d7bebafe3637512e39de5f16a03fee6be68fe1876117c7799c1a34b418f8f82cca9d989bdf2b9d9411a01fb5a47cce8aeabb971b54766bfca291e917ed2041afe99d89820da4c4ea1527854e00dd0b2cb8de5569accdd8233fb20254ac41dd7c0468576eec68299b1e544919824616985d2c2a3a5132a5312c06a9d6aab47be65c6d8d0e082ed035d30bce41474884330ef21b86726c40228e11c91d924a3d8629b8a05013b8ba85b5207e559ea245284e3c99b05d3a3b439725f5247367deed2943c5c3016289ba142e74d5e35d37d1da2b139b92a94fd900e02a79530e8eff23e12b9a31becb7e9f3365b904d22a3fc08ce445150297378c5abdc5a629ea1a6e395735f694f573489dd0e51d0de5b046a760eae96311dc4166cd5619a98fff31a0dd8c0baee8e449a22ba742a7f537ea3a1d447efbb3f48ffbeb1297a02ca83eb9ebbf83efa7c2088966ec392fafb95c87dd4a3a80ddd5d15568d639876dc247bed7588bf385994e1008f7ad49417db5924bce27c212061b5385c7873ac42494f0585c816d9abaed70695c9e968d3c30d6dec35f08999353e0d5601340279871dc41a65f68b1742c27b445566bc1d2429215a62ffd0d9bd5d9d854d3f8cea192c19d5ddfd9f9967b48df1b7b1657abc6711c4411eaf7d636de702de9994895d42c1ec05211a00f8204033fb11cfd6ab74d0614186b33195de4e16ec19b45255296038845e049b158fe657238660c6f4f21325e4d4378c43b7bd03e069efa527bc197c55c66cdb9f5e9135a2705a1fff15fe253efab8dd621ec984dada81a49e880ca049d0cea7bf9c9e7ce2116b271acad1d87a77ef406bf82a092d07402da6ff4f928202e1aa5fe8e086bed2885ef36cd33955ed4045dc9322addd44bca4d33558cbfae700c7af660eba085fdb7d1f165832a1fa6487b6658e7528e89671db33e1a5fa56b725a2c769f80490bd6f976f4518c46a576dfdd5d0c9fa55a4f817d7c3fda3070f106e5ad746eb2622dd361e844f36b4f1033c1cd25377e6d2ef074256d3687ab7d91032d0c36a57e56b3cba26c306c7c5adfe2bb1667597fa11cbdc3903922e2eaec659e5462022d5f0ce574722562b14ec56b1f5ccff8e0099aae5b87cbb2868fc9219c584237f7aa7739fdd8ada6ff70b581d5567d36df8668f9115c353c9b592be4af45f7c58edf898760f935ee81eeb9dc25c55e5712d7287bc6cf01ff3da3953bcad22a6543d7a0e38be6f3dbcb258c3019379da683ddb442a0ee3b48195c3a0a799ba13713992877c524dea443bd0eb85e10a8e72af0f9d566cb800100c0eb9344fb3a76ca0a51c7308ce6bbca56d39915a8d8e93b07e0cd6053bc20edf72f50ed2983b0204c0cac93e07d83bc0025859abfc9f17e0b02e46ea720d2bd67570097e9f1bf3e86ef0258a45e109c727f373cd2a35c4550747cebc1ac904644c87d312eb89e1edebd22c8f554639ddf93d53c955fdda4b01bb2f565532357a045ebdd19238fb02c2191ce50d5c978afb6ad29bbf53ec16ab966668a257a567a65d8cdf8cd173fcd051f2825c8fea983434d290a3cc7955c405dac5ba9c34bbaaaf5f5cff71cf09f26a277928da80ea3f57e5a43cae68813edb1c2eaf39af6482c2a4e31129fddb8638f5f9ee500e246f140dc0b073444df00d3ec25eb8148ebcc91b663e7d4184ecf32ff22097db438db285db9c4a5177bd36a9821c7a2ee78a3dec8f4ce6f05522b8aeb4ec68448012f9a264ae966efcfd1497782533765d0258c92c9750fa54f405447a4d118607cdb5bc6e2e6dc9d4a2090e6d5b6a4c7a7b98263cf79c41fb9f4146b8f0f3dd7a1b392b86a31a5fa4719b724f92fa7ee1e2427ca7b41fca5e3932a88fbf03f83ed7d95336b79b4f09b4f4a7ada0941faa9fdd9bcc2821b1020e84a1d6a04dadfbf56ec5945c230072e262c0df4d3baa8bf2b3144e5360f8dce149e77e566c12e5bad66463cd990da525d83dc92ac67b195653a8db7d8a205b2a74745a2f14d6a70972a99b53180f65056ce2515c6198867511cfe42fc6936f5a5de280a489ef120ea7e974fd6d28da3dd710f8600cc2abc4854c671f2ce0f1e94051d7df259dd8f45db7374a9c6cab80f8bc1ee51bdf49a108d44b8048c2db01bde07c97d6b200e3834c70965c10f2d951ecf8cbb4b0c22a3abd02109bff2c9e59b81da09d38e6b28907528e966c708c88c634ad54d9c1aa7fc8527f1a118085fc9f6e161059da3ee4f75d35e9d0b67be735c8294a33907e7df38b68ad9d99ad72285306d89fc62a8d7a9e22292620a6dd1781a43b770bee9f5d90d4b1c47c83ea6370043488682f83e60969dc60d0c37bfd3a1d9c327c42953c656d7738ce147a2e2e45755b00e34449de43bcc31edbf87bdc273b0ec4bcd2e03de1c32890479806695a805f8ddc5833080737f2157e2e0d7e3ab7649ebf0dca32a54dfd8024a27556e74f55f1d7c694e603f2d2f36f1a805cd80329ed9fc0cb163b43e0a6b758085e48704795329da9fd0a4242d3a45ff97871e71c4c12ac411c5ac518d2315dd7e86284a869b16df66af3b194e9e8c48308297f57641a53543cde683520c5b99f698fc1c15b02cb542c197fe90100b2301517ba1bbab57d4d922eb406ca2d596b1fd671719ad4d10f8c131f4d20b9b7c8f203dcfeee38b4fc1cdfa669c6f78ec95485713944b49b1044fdb5ab7645050c690efc5eb27bc72b98ae2fe20b598a971d7eb39d580fcb1a2a889f93151df382b5278729da7c4b2360a5b2057be7e658d572bcd206eb051977bee9c702df7bdec6d2bbf15d1d153f91068ab5bb881f20e0b826bcb3d97479fbc3d7a29fe5bbe8531e2d572eeec192d5f8822997b91407703d1f3b51b3439ad2215f4889bb7405b06344bc22d22e9e92485bca98b18a3751a3e9cce06a25466727aca85c388e427feebb4c77620012696949dcfff6a883fe8d58793b1dce40dbb39c5208d092f8ab53235495991da438e976f94bae7b8e80a45711791e78e3234b4316968a2efb3fe85ee41f4531f419db7e5cee4f7384d9e463bd905c5fc96db26677962db559037b25cc7e252a80005df2fae975e463ff760edc0ce7458c996f01f0975b9caf022e84dd616ebca8f63ed56f6c2287d5a64c7e30ecccef90e36fc20254d1fe045f0f5984f690ddc525ff22b6a937f6946081eb600acba5e308ca8b1d7c73193f09dbd8acc9d54a4b1cc243b384d83369cb9c24c5a976b6247b08f44b5093cf204b2109fa8f5101fd03ab9b91ce1021addc8e0b85f8a8f28475a8c6b969ab26db3fe8484c4e2dc533bafbfeea26730a68817c1407abf12ed20483810563d9c92d9ec0c5979c0f9e31fcb034c3c65117f61939caae05c0c49354a5d762488484177630020bfdb1568619e37a52c0d6db4092974bebefc21037d3b52f8df9f2cb16c44858858152fc83de0f00a07d87c9871894c795eab9f44bff63238ae71034fafb34725d39bf65c3a8966bec87aeb9b8b4b504a0039255d1ef88023cd842f840ed95cf77212ea6b8d71b55ece1bd675842eddd1221339b91e98e4fc499f8760ba38344ad90f19b570b3dc8d27efbf4fa8ea5be5c3dd3358f936e3fb6cf9bb19b212478815a5e64c8e2fbc72ba0b0634c9fae2af06efe13819c103f194497cd6523df672922e6e22b2d89c68624a41da95c2c3632d5c32a5fe32a6d3b667595b03759e0e1977d3e70bea62df110df6e462db70bb9c4a0f4fe74c01a54e17ff8c5e48a07969ae363355aaad840df9905eb386b67daccd4edbff0434ef674dd88b3af7ad3d577437fc16648992e5bb878375cb91c8a70c2174826fc445379e6fa9a2b5b911cc4f986055ab1b5401869be7e0c6b9088ace17750feb2e94cb94ba89272105f6785f8afb112396385ca54b32eae703ce1a492958100e761588cb61216aa6ab21baa64f5598fb3511d0c4997c81fc02db913d0006008b083305abc580675b5d13d068c97aab5ee1e9659718f697bbf866d535ac848fb475858f25ac23a759657f7504098ac1b35e1144f0023e35076fc011e75027e91b09f6d61b639a13e97b56ddcf8401a0592a15070a2be63da0558df5bbb4843843f4c4b2e7ccbee5d21ade801da99c306a3da5c053332afedb6f9e19bdd360ab3f205fc28232ae05425d8487ce6f2020220fe43d6f231e7ab424fb80e59eeae114ea47c353a2e0aae1f21ce2a2c60416ae6f271cfefd5e331d961911f5695c4712db84ebc1b4e3a8ab1482ef6b2388b06418deed863191ccbcf481b04e7d4f1786403dbaaa62b67498c61fbd1519734a1591c686a905d1e69ceb2d1ddcf585d563ffda32d1106313102525a1453da8d573ee10da603e69861ca609c46db512a09f74f488e8445f2322858099efe26a87ba88f3a04435bf2b41aa8bd627ff7044af45a55dff4f25f331782b68cb5e1293abfd0eed98e49725f78f310d24001bf694caee95f923bba758535a6714836337664bf1b44d1a0f976cb40991ad22cfcb63b9327c145f38c0ca3a6a9469696528d366ebd41d2354b173ca05f6667baee3c818377b7e3100072de63659b4f3289f55562c5067a3ee45e1cb8a1ae17f023ed67ad9a81272bb8a9f8cbe7b4ee825fe72912d5d141d964fee64250ae6d966086f9748d4f0f03478e9a918f9992c10986d36bc8cef285881cbc8cdd357c7b8dca4fee39b3e8fa2b2c6f3d4243706e9c37bb4f10d079a6ae907cf75bbae2efb3d53866fa843696644ca1aaf271facc501fa811dde8e505f3b5e179ec3930470aa86bdbebe59c028d907c8977d8b562d9eb1dfa18329f4ed658b61c7dcffb5d10355a7f104a2b8a90c2dcddb19dec7dc66b51c8324482917681a37dd78fdb0ebc89463842b4af22ea39087e036c19a9fa99e02ab82fd4c2571cda4dff891bbab5dba022f58d39e074788c961589ef3c2f149f45c0fef139bcc340d4e004b8c6a493dc0acac4957ecc60b626efaf5acb882d3432260936338d2bb3694f54a71d8ca4daf5f01759d93da849825ba7aeb33b0ffc7d93a5cc4fd3f14efb53dff0ab36c2bf975bbf007447662dd1a0ce8391409999a75a011911bfd5bf8bcb3168e1b3488dddbfd6ccf6a9e3dd8e861a6bca18f5eaa62129da624197fbaf55332434e4e61b646a363ba7080b960aac3cb904a30c9f605c8c770e3401e41193ddf39e155e27ffe0a374f7191d4de72eef25abff567e339785bb4412e0d3eeb30b231cb0e8f234558491f8678ad79ea19ee16d85ad957091b1c91a41e73198563ddb2ef219aec0e67a56dfa014b4fa51ec10bec51ad6db271f4e07e8c6c2f4b5664d59bd482a0fb69cec877799509bdfc25255a1d5682d0fa2b96759f499fd27289ba872d7a0c4c62424ed1329dc7522f712ad6cdaea925ed2defb0ae7363fec062727dfea4237b2d103b5134a0e4e61aff08524d4ff2cea826a661ecc925c4a818c6738620bf22957c2a41a8da543d80a6d61b247308e6db881b179f2a08b001802fe2822d4344a8dca23f3d1c1438fc36b064133d341866b46c76f710a1402a75003ed04006ebc4716c33ee0a89280c4cc02a193d7427e9f23faf8cbbbd585a7dc967e0123c8a9fefeb3b635f6480fee8a21bd819e82e697887c7b9231c064357756d25bf29d7db39e4cfc2bb1d0cd8259f91edaba6501372ae723454f5bc8f1cde923f06efa77bbfe86f9d7466994f6ae6083a05744fdcef8b6cdf8f13e291d5a7852ebab23105a9d80d144efa8e71989f07e913aebfeefb7c97b805e999d82a0304d82cc0f275546fc60ec97f4aedbfb8a3294d41bfcfc8ce5601d21ab770e6dc28f7ad3e709edd5e04e8f07093b1bc9cf0ffe95096691e83278f7f24c342a76e3ae95a78b44e240b6acce91769c44d5a9addac8dda301e6bbade0bf64b9377dcdf431400c4473272c27295b1f4ab149c0aca987345d809bf29624f571e4c592bc0db24533c97b4c95c63de0bb17079b06ac44039f94b2dc29bb66d80569589e72c47d91f92a2085673f762d577c0f772c4ddf2e2292bca0196cd1c346ffdcaab4ceade10d69ae18bbd27af6d128c1d22a495315b59d11945f2e17cb6de227c2cba9b4c4510e9f13d1be11875dee75eebb942a8fc789905dfab1087b479f1153048796395de3dfc3893f4c5904f5862bde9419cdb60db7c5cf5ac11bb7321037304882c1fb70d26fea1e23f72042c9fb5763db2e57f0f53d2559ac1b3278656d258cdda7a952a85c9ed5e4afe28ea4082b23a22a7502703d2952e40f41e83c8b3bcb15161a590764743b1794cc6ebeec28658d9d4ae9ad876b98af0403a752b1cf83c820b57c1facdec7ae1c37c673805a9cd8b907b910b960f41aafa8e2fd90c376145c15a09c907062bddccf909ac697a2b3eb525f0d64defcf46ef781b8abfcf325ad87221e6e67c3fa9e11f845fcf54cf779c3dd7aa1a2ffabf6c9227e81e33650ff8f421ecd2064c85ad4b9862b4e10285c66547d35cd79d0dc8b689cd3e5d2453b6350735c9cff927ebdde61e6c3b578bb3cdcd75163203e51c09ace7af32f425f6eb0d44603a3b327c9c0777c361fbfd8b931af8dcb782dae7d93be90031736dfcfad0db21d4e3202c7611513ce1b8d9d472f07e25201b0a3ecfd44d68d4e4984d71cc8a1da230cb5db11aa84774cdff2c2178559a8e9584ac9e402510e4743db8fcd180bcc2adff1fd65dbd15f181414fbb040a9605b1480e8902e1488d7ace12fce37a1a89d1d79787eb13b7bb11c79352eae1775526f90adb7ad09000abd09a87d0ec7c9cb2aa66b9d95d300291a9fabeaeaedc005d24f92f9d659fff762dd1c6e851cad8903614b0d1d6bea93d8ea08f4f62e83df6e7fa5b074c112b7fe806017bc51763154a55f57da52783fda1ced64a577e105e885070fe3be4a559b168159944569331e2943caae44adf5e4526e8f4db96373ed466e8d6300bde5bb8a3ccf3bf872364f0f6650562bd151435f95f786f8749f552aa3a9ffe6039d0da484f09c859fc8ebfc8c962736ef242c52de1d7a58e6b6723105f59442b9fd9047ff04e22ea19faf594c8242cd55ea016eba1990826c64a64f0573e4a402150cc38ae673754e6945ff92f8a687164c5c630c048be91d297619a847bfca01c7d797b1931e6d212c781c1ff4ed398bb70d9eae31517ef844a24308b6aaa3602b5ab0389245b6b837009c04ec9e91cd0197a0ed3df52b5a2f015ad36e9571ccf9bf229521520455a5cdf02b8a5b763d1cbbe709e5c4d7899f218cca2e78537606c7a3723dc5af5e68f2c3ceb15b97fdd82494b7ae68b12d25f56b44adfb4e93ceab9430709796deee8da2fed5f32075bf50249f685e56d1500501a8da7d96dd148c275f75d07801525c741da01f93cef02cdddd7058ab676cf5a0f66e105a118ed06d47ac80129c16cb3564e64a177a1c211c84d04b55c1c352943fc84aeb6f9d6f44635a866fa27db52a5ef2d280aa8470b11626376b197df5ac2819095d3d211bfae1bdc858b0642a816b17fa58d612288e0d60ec508a0174996ce77211444fab3b23f0d24582b6dd253e9947f4397c0a85564767aa94f56aef57dae2d951a1584b4098f8f07b6b275e5fe28d9453762c9ad1d97afe9cc19b9c4bd98965b5d196c7836d6e87221ab295aa0a110865fb3261d274dfee69aa23ad3f7ae7bcc6e7a24eeb8900729f173bb0cfad870bf89e6536a3cfebe2a8794d1b3bc071715c54161caa8c50de4228061ad011f0f157f206b300c682a16ab6bfabdd2906fa551e1156a78cc583fdbfe6c3859d73ba10f9a49999f2ff9da16d09afd70ffe6d111fcd1ffcda979ae5d200321b9fd2c976ad539b93192daba68acfdf6e530072f64eacaf7895a29eb535a3c6916212f2229503c307638a5eb6bf1c7bfd5ceab2ed2114971d09e5424a8edd7c3a9867506e656608826573ad70fe951e706a6abce3f3a722a3e4dded28d4b3583d0b97cef9b713888400eb34588095eec92d25524985b439f43a2a32f36011ed18a846c226cfdf220107182c585f6e049fbb80b39587de6bae5512faf790dd7919d3f8399c6a96d2e3b9bc383abe5a2b9ac96e5bbf3966eca457ee87a1f3d34ee40eac04c7ab8bd68512333c2f81d680f83cd0dec51492125daf8c00040c0252f0f25866550ab5f639ddb7b64b9668a30b094c8527881297935904f056a10cc30972c8b8bb583c80c4a30e8e06ce1cb9b95db3196bc6702eb6f39c1c709f9e96cf707cedaed8be4add67c8dbbc4330bdfb254d389aa1da50679eb6065087a30f36aca402aa5faa09b12db7e62e56b2325ed6a212c177ddf7fdafdba79a6f2f8e05f059026f8b6a696256589200301c90858ba839722fe2da0337665e139536e6579d99107e0658fc83ca3f5e39e02076a4785a8040447c3bb84c6376257b76f21c81bb61a0dc9bc79ef4cd86c502380a07a6297246e3dda28d379e6b5f9c328299fa5bb060df7854ae8bbaf7f6f8a49b89ffd129a117030aab5dfdd3f2aaa632e471f4ee8c1aad86a52d3e88ffb1fc0f1eb3738ef10666c66b079bdc3461503f691e9c7eb758dd1ce7c9e46778036c7249df091edc3d4e3ddbf1436721e272d6681dab29bab73caccddb52badd914067a69198758b0c0dd040b14521d5a9750974d8397e2f4de21c2475871f0f4976336215acb82cf3b8ab8ee3b65f130e0103f5bbb6e9f5da7e28ab18654dd1644b7ebd9103d36e1e3a27f232a328c14efac6a73d0c24af93642198648bee4c091df18ff8805008f4b9224928c5936a36c1621933110e44ef1254148dcbb18b6b0e60c144b83032afc76ba6cdb798bb4a511e2f783d24608fb8a9baa6c1d4008a3c34cf08b8ac290dc481d020ca73068d28f1a1e5dc0bf2335dce1cc15c7bfd7480664d4de55eb0096636c155de05c2ca15387a973a8eacbfa5013ed15fd53c2702785fbf049e8aab6a8e28e9fef6087e506b99837e8a874c64e5196c256a58ee1d7c3f2fcb2501e1c1f6e88293ee183e7c5e336037043c5066111a5130e251635e75ba5e8f58626cca5a97a85fe7d2bf79664fdaca79cbd032f0a0c4524d0cf38cfdb31ff77e7fe06ee80040b5803e66279b481c461bf8a8aa6c81ba7633d1f61a6f9fc2b96b2bad3557a1e184310463734d4fa4484fc9dcbc4485d050b5cb5c658c08d5d1d2c13b96572efb356df46661b4e76a03310afea069ea1888a18ce094ef0b30b8749e1b25680cc2701d80e2e5c567598657c9a049b2dfb41caa86d31c64d95682f7a33e69aed7f5434f3dd6b82a7c10d643dadf0049093f17d593751aa93925fee8b4456c99dc7250956633823ea4fe834853f160a90006cbda6ddd160205ce24ee3bdd57049f94e46b59cc0118b3c6c29a11cb1ab8d31635633771ed69a8297f95a529b247576831df17d514a752f6308232d73c7a801742fbf2eed831a754559be4430b286daf03cfc8f3ba107b0cd44999b8eb357df1042a0905e954159ec3afebc52dd901b2aa6e35e17c93ffcffda96e1fbf52324c2845c67a62ce1cc60ef83567245d65e1f60a4d99d66800f615e09bad34247cd72483dae8cbcf7b8cd1953fa9a65e9f4a7ab3a01b874a7718828e50ebeae42c660651d901a9c9038fdd770a94be46ebd8741fe7bbe77caffc25cc7f4b968d86d8c920bb6a26d81978e9999a82b9b53768160a7a02ad81c82936806040e2dec3d69dbc5d23384b387d66a179ffb5b7a6a7004dd81cb3e035cf5644ef5fb0e98f5b90aafe7eecaf6c2d177734b160050ecc323323deb7c63efb408c6998679d8b0e7353c2acf5f6d78f4116dd56b2617a12c9d9a14f24947f2168bfd3744568cc6e006f32d0ab122f92964b87d4c0ada8123af73cd147d867f159467371e3c15acd8baebaa909ad3ec72887ce4ff59b8be1fb0c03caa69fba7cd24a5560628cb217c6be2acf656461750c364c5c3904ca03bbdaa7e83e6e10aebe0ec7dded94457261803674ea530af57a512538edba40308de5fff3e2b8530fa74bddd48920f7a29dc6f6c20d8b3f5f93f27c18b9747ae2c908842b103345e03c01ee135c5ea04b070267c48c7d188c12c3fb858bb13cbd7251d537dfd0f87c037714f1e3cc8ef4f3fce7d8aa6344619c1450c956e1fcbc55d835abf2ee541450fab0fed11b01e78436bdc0b7f885707041aa675ff5653a53ea081285ac94ae190fe5cf71d8aed73a788f341e042fe6a3ba40af2d59d6bc71915a93f825c983535f18cdd73e3d6164f9e90d7d9fadc73ad1ca5374dee19ca97c58218ae855a2cbb1761845decb4ef1c2bdff8c3afc81bad8061b7e7fcc769257d4390aaa72e5c7966e82735b69b6740ddeded4f32ec80fbb3499f4fb136d5cdec536bd09a93bdb45338ebb7f9be35f02837a6efbe9c1e1769bfd113ce43abf5dc52ec5e15b3dad5d3b8646f0d911c0a0cb045e5be689ac4a02ef8f16a116c9d99165b77a3c13aed3c2a0be5c11f70885330b3eaf72fc3c803778e58d6264b7c98d4c3fc5d2acf06648342fb1231eb6fa21ff410bf0d567e58c04a6d9703843323d13f197fa46a5560ffc06db6411cd0d5d4ed19054211600556c1399cba90bebcdc7add16442eef19e6c6efd1c558a49920b3df5a9f600f56b11355ca5f407078a073b2b124a09d4401864850832c370d226528d8d89b6e9ac0b0649e56c2bab673ff074ddc906458623516ad84fc6c30f36ca46b087c26378658c02a640a519797c9bf7f0b48944c1c9070cb21fc556a3cddc5659c713c83668eb1fb50a665b7bccffb14b9c493989f15d8bad161093c968734be045f9a6cdf8c2711635d5bc4b2e8f364115511d39d1d52e57b8af3c21e2c19a357650f22b046e0c7f2be0456b1242fffa6f324470a306613071243d307c45c358dfbe94c2fbf18ddb5dcd70816bae27f2bdac85916bb71a2d415703de796c8cdf0a11220662b15ec8127da6d74ec09f78287bac44cadd1635360580f64668fe73c31882f06633bc190a0272dc24b61330974886f3e1f202a7b62fa5a930ec3552a3a4887e94923556efbbf0a16942f892a601d74e4b50fad39b5bd60baeda4ecff26a66308b64e1379c5dbf5cfdf46368eefebec71987ff7c1ca9e69538233fced601c08dce2cfd2d2b8987e8044ea15498c1d817f0e2d25d870e19a1b452a149cf3e019ca1acd6d9d9eb5c445a1caf48463c70b7248b79a0cd3f16f169981ccd8597346bf3a1d793bb034c108d09370b49e2ba68f6f30468dd0cf3298c414efdeb5d3f8c5bc74ce43bf9d7137375dcbb26f7e4acd091ae49cc40315053edd60eaaf1e4932627090c7136a8b74803284671d81d4aa00028cad14b1c53a4fb734add405c997213577d3ea6518b617abeefec3b8acd371114ea1142028249f8db8d263294bc5b55c05d47c5fac068dc03cf069c2806c46ef99837f99011bb046bcb08d27c9d38651708b1ee94ad31d3c5529b4c418650cea33adf4e0e9977828a88975dcce0e6bdd38db58e884c18d80ab60cf2f0255cdad427d1e13994ec7f255e7584c0af279d432c0625fdbaf1b6ad8fa954b97e7d4c5a2d0cc865e4eea9697b227c4d380cc34ddefd4059ba8c4eff4663cac97017e71a0ca00bbb4cc3c38a209bbe052a72027ecda3e13133c2b04295d4b0dd9e1d4170f857f8adf5b6e73c23468ec63c90b4dfd77de3a3ae15047a0c98b124f0e8952f1b35845deb4712206e3399dea79261b90f3366fdd9e5c8a490eecaa5101c0b1810b95cf89eddb9657daa55f5a64730953cfe53b0062d6442d7b556f3ee971ef96a0063496211758fe408f272fddbee2159f074c2acd111a6edae89d33d802ec82bada03cef86f143c7f0f18970a7c6601303b852e586a06bb11425b6f34f4d084da1ff84e154bddd61c7d24c4709ed434efb9b56ef3c99265882546dcdfdd35b3d894e8a39fda4857d83516bd054e35aa11be265ab21b437ea29f2a4c93064d35a365c6edaf5a76000cc2b4cddcd1769d5a6f4452131bd8ec05aab00a9844c927bc933470dc1c5975d66763942b5f9cb6932abe9fa554a010c58bf9e77de80ac66adc3a3fd9525c61ff5e23e5865d26511c956c5051ae5c8517f52fafbd098b65a61790f3c995aa863068f2a7d7ef55a33dd3faab2e689ade7be8fcd4711865c86139c903da5c6bd5b7236da92231a4f680b00d89ad59e5b795c12a12cfbf4778f0b700cd7a25debcc09e39f7b46eff801ad6195f510c466860b522bc225898b0ee56c13c8714b1590947312a3043dd2803aaf6d22c41f85e3530b80e407683c109a10d730613e131620940f751325631a7e9c22239c07a13748de54b1acc35f945d19f212385859dd9d010ee43c54273c96337e1ed829797d8c9d4d0d7857761046303bd6cd072efcd13220e4eb365403c86f73dde997a986ac07581efb08fcedc74e11ca324d4b9d91c030eec882d7c22170674fa6542274c2e49bcfd81ec6060069709c682a587d5127138066a7bd80ed6b1005064842406dc26950babfc62dce26a4e1aa42bd6e04bcfc9bfdf7cf77f3d212b575ba073617c8df9353abf0a7bfb59d9247eaf5d649eeda433aa0a2978c4368bbb6b909748c5db1d1775fa2aac9fdc88a0729a52eec31c50318b67a008540a7934f09386ee19d9b043e1bf4e6d3c2bc0927716483af297a66cefa6c8cced075608c80b16da9d0956a357280f9127d4834de0c78f76fed707fcd1cd6420373cc690ff85a0b7d63ba08aa61c3f932f231927984534190858862ca8cd5e4b70e3296f12843b8d01d3a25f919f8ef51d96b90027f1e29b8f5c8a8db37c4629ecdc4f7721f4a391b8968caf5ed7156ca13aeff77df380de370faf0a5b8b8657806b73d3b23f5234cc715495d1ac9a0cd441f9196201360be90105898d10ac5d9a3e23f2a37d2649251f7b35b57d8b1ced12e5f31318e2558aa880839427013bbb03877b89250bb7259d66020667462bc95d5661a537c781d9ae3a78149bd10dcf41d83e7b67d3b2ec6976b820cfbff0bd132059bbeca0529a154e44b678b34f6ca38a4c200a9cc7808f734b53053ca9320e2807c0c528fe12d98eecd2e0928bf9acf426fdb89aa7f3efadc0c07bc7635857680a0a8496be8a9a6fc263cfe4cbba09a66cdf326e43f62bbccd283d5ac58c63d9129cfe00258a7a0c7fb9e9e32e0edd63ea80f67de2c7c1f2e2a83a08935b9cea333d68d535207e30b234c212107c97b9c766ae6cf26147a720459d11eef36ec8a1cc63a6edff3aa0a62682d932fdcae78abb96544c15ae8cb25bbb3ef7dcbf57e5c8294fa1bc71208397e1ab791d7f66a963aea9bd9c464b039370b756a67769cee0468afb7397ad0bff0aff080743730d46b70897d13315bf7a6cf9c579e6062496e27ddc3729d2d923d88531e02352e4f54e59521023a4d565461455d3c2f37e7eb66e4d1d2b772ccdf7c2ddbe538e9cf79f49a271585c8d2bfd4c5323c70e15eb75fba619410f317e6877bcbb9738b1de91a49b5428e54c23a42652968370c0cb04d68a09b388ac78d5871c8f2e463aef159a5da6fb83ab8c799e0f62f95ca4751ca8d760f1213047570f46238e362e876d68508fc980cfaf257e74f7d750e31071ed9e69573f00836ff1fa6d8db9ef1f8ab15d7d4f31b04959ca0529139300524df93bc4dda85707ddac2a90183d210b73c551cccb2ff1db19023c134f76c08f81b148adf26bd90ede0def4aa79dc9d8d5298522a0014ffe1bcfc0bc58662fecdbb4af73fd383e760ce2ab058613e827176074fb7f1f78206eeac2ce8709832ceb83660fd674a975d0891a822719f49abfe1c48b3de0c6e208a2850f15bf3100a536ec3323986f3cb31b221a9e247c23376272c7a90fb4197c3585140d0424e32639c007a9c311d42655f78e1f8a62dd429cd47cbfa2f2251ed9903260ab3a0b981fd6677da47af76cd1e95e4f5cd00ecd9833cef0d56c8534e3c4d17175c0866cde293d8174a7bacf3ab2e2910f334fec917473682e488df37051239abb3a792ba32a1e052be55298474dcd35af12768a928d688318f6736cdaced8ef3162ca47ae6a3db5baef209791cf906a0c70ce41aa97004b1d43b81e05fbe562845c671398c7a136025d20494f8545c5f15ecb8f262ecde6171e584843eff5acae3b2a4a4c6eb1f38b63ceecf95b8f27da234ba9d6ff4091ee9901977def24545f85250efc814ac2bf54f0ffb3037b9b8d9db7885bfdf50fa030c9654c79d3f2871d444cadc270b46fc1aa2fb3c51e294470e48b096d7ea544b2aa198f69060459f6ade97e17a36a8e7ca0458e0e6a85d1f70f74d0b4ebb8c90391bcd5c84c3cfb4165378c8e50e7e58e7757c76fad0b9b6ed645c8bc4ba4a648611ec5cc13fff4900c1a91671fb5df49e6be00e438e86071c481154e2413ca0f0ede5515d16d8db5d7f1d66543fe3e323d89de98ebaf02f29d940fbda307add8f547106441c7449ed7312e444a1445418ed44fef58538f25c358be7242d9efb6761c63c122b9258fc6efad2133e82f70a30b778dc0a273529a3b4d37f6fb49e2d38ab28c0e23f2f01d0ee079da0868103f29c35c56f0081ca172f504bdccdac1a1844f11b0629dbc2f47e6a0579402b1f7c9849f480a88778a085402d60f3d0d2656d3614fc76cc1135b17c498d4b343d83b279e1ebc29726910c5c08cba0fa575d0287d23f3256106da5cc1bbd385abbb49bc17a86d327d49af3b042a3badd0e5e57e7a5c9c6320b5866801333e665426e47ce364cc6526d2b991a5cab2770d3025b51bdbaa3fae13d1dd22a1da29da2f21385f7fad1563bb9c8ced413d46e1d784530b2d5edb0ffb409918d86034ec0ad2c7abc795b15e5db5fd46393e9d634c279e5e28de337e37a559cb72c7e4b9059137a25735b95ff54b0887ddf746b76e540449db7e0d937a51a6be369b76824164502c5cdca802e6ad71a2a3f8634a82253171923e7bf7dadb886c88e8bffc7c6c0c542ecc5a5d4322d0c2c3218fd5db9b79a42ac307c4219e30baa45846c2c46cc294edf697554bbe0b77666acd56de25ffd54899683e9c0aa2cb5d83991a543b6ca60f3e986e01fd0c6f4759c8e74f405e644e288ac04f720afaf75ba5376db7af65044ff14dc00aeb89e2691416ae445ecfafae8b33c121a6cf6c89b1b2d3c2130b4409f7bcbf28f62e12670c74694981d5e7a57b9c91b03d3cb89cc5510eb60ae1147d9bed4cb136b54805540b6a1d7782e986fc17ba4b463f6d194f49a799ddbe4c6d603d0f063cfc03adb90dda63374af3bf7345302ab34af5a75ec08be8fd56f8f3c15e803855d77e906dd2e1f13782255435ea978126ee0f8beb7f3e003f05d3697e1ca968139f71cb2134e62246011fceeeee80ca4d0b3f2ccd1fed1eb3136c00ff969c23a5ae4f22760056709ff681c8b7ad609662a7108c63c94f5a5d39df460144bc6de0d4e3effb84940689763bc1bf9687301e3ac4aa9fdb01dc0c66a08e98c681149704502ee524f86d76243250f4732ed8373c617359dc11faf2b8687bedea156d9f8c3387029ae1d120ddd78daa457d513eab6dae7a88e99ebd99ea8e22ebc8ea1ebe11fa17c960e1a38f27d8e351a9652682f65f33139b7a4dbab7406c0f20925e75c87934e155e76f75bad8682ef6fe7a307ff7c4d470cc2f03e6cdb8017f344596ed8cae6681b845405cacbf6293ef364fc84ed93c0d13d0aa794937b43e66007f2d133506513e7cab58de26331f8fb09be3066a35a1bf9cfe2160864177d2487dc3221dbe8db82cbab34867b4bf134054fe4a79cb5d50b1b63daf8108cf2f4c501cd5d9a6029093c07f23d58f418e75cb212dca3a89f3a7c9dc5fafa524074812bba5ae35ca016f40397d3f5c6bd2228ea9fb7639ed0acb56e8ef5c0c65719cf7fadddd235950b4004f770b2f594d21646526188013e353c4d4485a46b586f95379b58c7bf6b4a626bd290d45208bee901af5e43b99180bb4bfe2e0b00e62710a53041e40f89490d4852ff02e90c07f6335c8bc9b5434492eb561b011d00cf4f8ad653905009f3ebce5eddc9230436a70b62c8d48c881953bf9ff4b466fd98b6bf37abf6a5ab2017a55af9198869f4f95fe5a12026c70745ddf699f54c8c757d2a86fa8722a69ea3fa0cd7c7fc4e2dfd8d35a3ef7767e2e321a893ba5bdb4c2f03f80574cb53041475c46f09a3e9685aa7477286530c865a4284989e1b4b0e2c6c37aa34adeedde1e9fc0afd3eb1dec9f0f814ae418ab10eaf17ff60824b022758be600400c816f7e8118f2230d4e798b0b2f3336f2daf1546eba860f346a3a8c05834625cb04f3817c850dcf90132284d494668a92043bad538d125d0bc1b8a2c478692ff81d1f758b7b7f45bce506fbb3099a26a075cfc6ebd2bd998ed697e86bbd91920ff177dccdf0416fb2e12773d6002b9f61cd30c8893ebcb9cba138743aa18445276858894f3275299d548dd707f6e8a876a21d3ee3e9dec3a9b477cd9296aa2fcdeabc7721fd79cde689553ad36287789e64f698b543a53b2c9418a85dabf86dc5fbc5f325c0c4cb1dd151eb3bc5ce5e78e909ff26780b98209cfaf6210b5869a711a69e292a29f1e73c898a9fbe9bc69d0de76c82860fe5ca9d040d0b937ff6e0fc471e01d0c34d312deaf6de733eb1dcdbda6f2d94ca2a3a2b764283cb88ed6a73cf9b270038f23182e6430df17e2d753ab189b8c4f4c7bf80696c6c04a9856bfecf4b3f0a599a4bf7b4e65345617bc9a266c02c904476bb80f275eac39c35177744b8b48a01e54c143150131f382dc0e3a74228f16008e3e43b9a03a067bec6a435b79c0f24e51d756f707372220e5ca4fb720d95789519faac53478b96e0194e47571655b3c25339c466cd34673d886b8ef90096219c8584c16fc14b510262ad15d0409a3629b23f5e73cde7800dc12b58b87ef778a88ad8b4caac8e818bfad49cc1a64e11b2a6d61d42302c2d014af022e7c4a7dda1e4bd75bab436e012591a8ee7fe64b28eb16329b3445fcef93d2e22efcf704aa0c1e4f095ae6128ad831dee53bfd492c24ae4ede0a6dd2f1523357162d35d3c25975637386b84336c7134a44bed958305f424fd13858e4684021d3241f9eb48bb4d7d1884c5b25cd9f90f194d803c01f139c73bf05a77a6f5c86f3ccefd43593222cce8c3aef5ed9366d28d28840374bdc6f4e867c4d8622e51de733bcfa9a0d41189997c728442afb061cef939765e644905116cae8e12393b410b46364714e15b63e141a0d98537a0b564ff081908a1d6046f5ebf1eb17e683155f1a3539516d03bb421e11172af5eb374b008be9b2650724beae279a2781faf975cbc8ef34d0ac4bb6ec94544c047fa4af9ceea73ec42ca39dfcc91780978327ed4b18b7b9fe1549d780f53c964c82893ceffd82f38f3565d57b80d9d3681f36f35c8171c603c27a61bfaebaad43eebe271d5531f9674e833a7d06d3d5cdde1c637e9cece5d47c7de3cc479277044ebe98c12b485b5cbedfb73af623c0d493fc52910a21c582e87b41b40386a0338d082c384a358ba646a2ca654d22d16d4910864a6420b7f94f2c325d903717f4edac74b76d15dbf190de03068522c827546ff974b5853252e1c0c2d22d0b8eeb1848743b25d80434ee8189a756be6bfc0d355a042ea04fb1b139d2d90785fd5679fe25407179a315e84b94d988a4032d8f528bf7f21a4db92c5293d7bb361f2f5769f34bb018b7ea66c3f4fc5c2ddc2ef6c6240b39980e8ad1150f084558f35c612a3f4aa25b253b6ed088627808caa7103bef3b139199515f02a004c9943cfe99dddeb58cdb34dbb1e0c8b9625a9f7a77056a199fce966cd37f779afe6802bad66d9893c951119485433dcff388b6e36f6c48e878fcd516db6016f128ae0f254764aa3c4bd84c5ce9b7039b4ac76ba52393f094a127c7ab9a10d600e1917336b3a744f9ded95a20b4fd4d9f272ba14402e0fc7540780377ec0c6259274801cc63440c6b383d111b1f99e196c4b63a555dd2bcdeea17c314794e3a38783acf3ee7419ac70fed2ebe33de9873834ba2d6912db1815b0164624b4a32efdb53ba072440fae2dc1ed22adec7e0ac0eeb45a0501812a3c369eafec14af09a2d4fe0736b912d0af9a0013aa6143adec40515ded74e4a1b208f795b00f87129129a24697ecba7ad3108221551a1bcb589d6059d2fcf77293cfadd5b410a84b05974ad3ab655d2db15cc825eedff8f3256f59067bb76ed154cae0387ad4a4d14c570678dc34e8a8b8840d1e90bd87233225b32f2b2e0b1a449537ec79639c4fd6961804cb540a0b661e2a30427b33555010beed75375ff577c2303bc3beb34212f07ecad397e5844289cf04e7a763f218d75c766de01c582d747ed9774eebcd41a91e2464bb0eac32e7f9423cdf1098cf674467caf61252b185ab993eb5ad1f66d155e30bc0f04f79cecd090f198a1c35871fa7109b9f7bcccf68bedc276ba24c5b39d3b5102462c3051c7e0f9b3284e27d6f4195e82448cb0a4a879cabd1341bafca3365f57c569bc6502b266105478d18247cb2b37cc2705dafac2a6764b4ac090b8401c2c8867b85dec9fcf83ef13f5498e7ebfad817bd3938fbb8b6c258133a5e62e17940e5a5e8c577bc85e5686bae366fa6d5d0ac33ec61afd6cd63bdfd7437d00877ec78c2bd0f6120545fa2634f1ef0f169b414c53e87199c5ee76dd3fa6906364f596ccc883e18bfdbde2eddacf4fe7fd87b509fb000d7b5941978ad50376497fbf56a2a5ca144a9537287282052f5c5ddd29f501e68d55923eb2f17f86498b02a3515dd0ceef68862277385efe3c6a27f7134254d133265a36aed01edf6a9e1702caedd4ecb7c393469451f2afa7a9e4801e60e00b65449576c69e5620fb589c4f758facd9148ec36ad2480975a6dbb0efa8cdc6302d029eeb0ae3661b63c61ce6fa430886917c24f49c620920f186ad8445bac176badc634bdfda0478ce0b831f751d80e1207ddf2bef2a43d245a47beb3a79ee80dd3c10867b707425ab5c2f28f95871a793ff9773dd5313a0e45a8ea803c462738dc752f16a8159902cff69ec0849950e24ce5ccd0be4f16a13cd6873cdcc376b633eb7650c75fb3dc96061ab1d109b8bee75abc233b5c8a39bf41849fc20f5041ff0a64f1423f50abd3a262f222b4ed6713f48e4a3422bd94a8f817ba75b854f21b9f7870a0a8b5088c65765facb130812b7ecd2bdc7490e6f1b454217a81e65f0932aa2cad521a16b027218f803c9f998c50eff75aeb9d860e4635a4c14c9e6b7b9bb4004368fa1ef05f0d566be4bfeb0584214d64d6d2cf71edf1178b36cc2c35226eaba043fc25e66b4a1008b38b66b9bf7527df8748e1116f3b4819091fe06b77dcbc4bc664048ab69f37638a700bbbe97f11c5b63200e67bab283703bc2973ebecf4f40c1e400d3cc9eed3ef0fbf95142fcf92a6f97544e4cf74c658b7230a237755aef8c6a1de713b47ffac4a0622bad106c24acbbcc03a8e9df2f118bafebb2d4370ec656f9a0e219b6b524c195e0e8c16459f57c6327ff33f272f6c895f63560107cd74c351e7f9e1584f81b17cf0b66e3cf62048b3d31fd6fb56d5c8a8086f960b93b9b33a538828fec5fc5cfb4058e7d70646ab73b8a82f6340f17d7c9ce22763ec8cf9b7932090e64f85a8ad81d6edd44dce2e22416115a880df9eac50536f6219da0d7c00477ed97a95a78c2dd0b4106d24109b61b3620126c12d6dbfcc1570ff35b9676e5f27f88c079ad846a1cf9fb99b4ac22909e0343a168d0363566658d415e4d714b3786736309a1938e1ceb29896c51e1958572ac4e74b3a6dec8c09477c3b1763d9cbc8ea84cb02ef65112cf90c1018858c210e3f8d57d10a28c5c7640a53e60bfff4d92d9239b586013fb335b04cab8d77d3431e913d06e197e00128fbdb34f0f4c5b13ae970660c6eb46c9c3d03b1e73596719a38e7262178bc75ce93194f3a4df79ae869ef8f7bbea2b96c432ea774957e8a8975ccd522078a1372ea1a7db24e73102f3ec5de089baf2f63259f2b6bc252b9a00696f1eb7b2d395cf4a77ddb9cd7e790cc2871ec5e27aabe5e26d2aad8755470d058b5b5f1173f3ba4bd488864452e66f67a9c564f4b3351e0cffbb3d73c26ccb15772877cced1b6a7a51ac200612ecdf8b5b4f983a24884f234b3c332980bb752c2c8c4a7d8140d660c5e94867153adab61984e0f165049cb57bbf40f7d13b1222c966027bc25e4730cb5a50fa2896a9d2c4f32cf5a6c9a4d4bc09d38fad7f8a4211f2507f18f739504245de060cb7be311ffeff46275384b0bf0b2de23ea5a7aee8d1fd163f13d556cddf075cf7ee5983536bdbdabe660e823a6fe72561299c5fd9b4b304c69caace5326ec0e0fa6cfe26b9477895453af6a6533255d2c8a05229384b1669103bc2a80be450cf2a4f18bd91b8728687f84807e590fe962b98ff1672641225834fdae43eca4ff312f67c6ef3509558a4788b645a169ec015fa459cccb15d225dfcfe04e9643f7d0edfd4867816c9de12cebb180555220b5ebcfe2dcd2f336da0d3148995aa557c8a93daddc6f045fa653f4e678287f6f627bc61fd43644f4a90a93e7e0b2752686d6c88a4f3e93d8a75103897b2089249e8732a0989075349a969dd52029567069ec5379a27deaa9c54c8df2589419b8336ab7ea2ca74cab08704ed11e9c8e9147933d87202be43676692f2be6370a54a2afd1a23c90864e2429347ee093d175e99c11aaf358362a4389301b7d38caf09b397f2a95606e07714ebd3331a686778acf804dad66e3a24b590ccd7a699a8a8731d962a96c489246ddd5ef21eb4c635c80976cc0c9486dbfb0e1d6c080724cfeca09aa1019b5ba4f0a4d0a8381a74803fe3c9006660e07643fdea63263a1b651d647d8023b6d260d58bdbb6e23062d17cb45a539767813148c01f73a817ab70123c2c8dd08fae951fdf067bdca9b6aa7a8a2db7c04de533d43d11d4543a26445b2a4eea59a4a35c59bfce08f65b580b17076a7d0f2452e60d5d84a4586cb8389b9a1917ffa488063468a85c79a825fabc01c8ca0936c4a93650eff2e28f859ea74a89035c5d0c1fbd70e328d9e82c5fd736b9036d2b3d30008773a79a48e48bac9b3f4b55aa965b299e379cb16071984eeb81a43ebbf7c6450a4e9a3c0d69702b9da30929e65e87e397e82b00f7f441137717a5bb5c2779130e516af48af6efba10ca881484b3aab10412831007c80e8e143947679b734ec264444a0db8e5f945423f4dec4a34c59ba9dc983dea2a242cb34fd715b11ddefbcac1c00c82123f0f3347525a51877fbf98332a244fb7ccba119508b529e32a855d25b5df81611e5a84fe378a0fdb4d9f156a7cea44e1524414eb0e8b1a0ad384cb265c6efeda77d2409f82024aa148fa9e2fb098e890062dca93b124161745662cb8752d6d7fc78f28bc8047444158ce40bf89a0051fa8df8fea472e4bb0cca7e64479995fd3cc99b0c14335ba019944834098cd23de52237b04fdbd56876f2bb7c713905bd811599d09d616c13893fd48c64302470bc92f0230c006d04b340c63eda5227af19371531a561d260b177a5d04b96e46ca3c19e2004f977179fb98a11db0a758910bf7f43b1b0b01efffe0f221b1866772d87175c7dc323a2657735a0a70b3b2c306eef1131ea1337ace6030424d002d9293297c7d7bc74ebc529807383000670edbb548de45272669616c4a91e1dd1c8be039b62942b4f97d98e50f6ba1b1f84b3517ca39d4fbcd989ccec16282268e560ac8b9e40b60f4507fea6ff039218f0c88fe122ace9fc4dee16cac9d847b47241d8379dd9e9b33854e1dc3b931d6a8a9906515632508a536f57fee9fcb6dbcd21a31ed499b692d05535330fc57a1df688ff5a82b356c696eac97835dcdf32c9161e8ade2af0a4c9990cb1cbb1ea8a7991f395ae68f06e50a9f5bb25cdf440e2aacd7988e4ce5d947a0b525466b12540db10b1644bb87e3fac3c7407046ed483fa285d5c196f133cfbed8487c399585928bb564f516e9dce9b525efe2b8627c6d91d9e3d7050f7a274fef90a387072066a08dfe206722047c0bd7d2f5dbd145fcf8cfbd9f1d79e1494a1c152a185a2291444d279924c9b33405aa38b70545bb4b4cab3fbbfcc1b7169cbbafda12f05e8cb6c3b8f2c250054c5d943f486d5f341171f7f0664daa472098551e1a446c0d0deb3ca00454b50c5923c9eb4d68874c60b485a294113cecf966d8d5e95a82f1b8800c882e0b1dc3e095c328977ff85e7fff5200ffe69513c5b3570da0eb621ce696dd5af346c1687906487aff28b67403b4cf817a936678af723a47366d423e2c7c9815e2c37ef81df5442b8d1c4830c2d648965f1b5ae6e98907a4f7becdeb00317ab2649f0c97aa67f8c15440415e057cb0b440e86a6a88b693a18abeb83438e0db1404a19fb8bb10dca9f38ecd920a90120bad52eb59187b1be86a1434852089677281c58d945b37aa08af5dfd9304efb79491295c15475fd6411fb68f2068f5139aed7f75df709154d844e82397da5a15b2a5f865b5094f64b1adc5376d4440f2a5f0264553afc824bf915431fe3bd4fdf8bb13274655bdbe136af02a2f5fd58e96fd5b21fa51b394cb64bcea71cf35812a33cada63493fcc26a36f6d96498e7c4920b1701c4b6047b62d899ea279a7edf928d70108cc240e86ffcb3e55eef2acb63996c02bc8585158c5a590eda5c7cc97693d5b9872ca02566fc43ccc28ac3ad54bfb0613907ad5141a78b6d10d87d751ac79e8e264eaaf88307b4c0e0220974421785928b5546946f25edca314ca10528cd6fe655ffffa6a209951e8ad188fd1e9bb1ce10966bf782180196f1b37f43d7bc4f9db519d5acbfce7d7674517c5458259f3653870b210044913f87619e9a67ac2bbc96cd757bcd5484aa41fd5ad0e796dc81791c6969120f259ecb56fae2ee4353b1f69bbe876d06c81abf57480833a29a3fed869e5148748f62eee886fb46defb187942a0a86d74eae12dc7a095283530a75889164af896609cb5e4a434242fbc15a2c4a2c522458e21a6d571a642a097f85d710fc907cd704e7954ae8a9e7c1039d3235dd5fa19df5ee7b8fe5f59e3ef6caa9f1db10e495a134d3d71b0b739d9fbcc45ff2be01c08ef271c3d116ffcf8b64618a9071156fdd10925ade9a736dac6b6ffc91948c0bc73b5265835e0af9913472f6dfb4843fc8129f796b5fbaa3c8bef3991d906feae6778823046a1045dea3c08f93abbb33f00a7ea5649cc140beb28a741cf420a1abbacb5d55e749af1fd0b49329b8f0270f3535f88da9c47b7f18e97561621013b80617b0fae4013a82c0513cd0d68d27fc05645bfb9a60c945cfe066260058fd2a791e6d9b8f503f7c0680fd8e72fab1f8fc285fd3c9e655a738b238a237ff4a6cde703e06ca444f951b21e32781dbf465e7b0f3c7a3adaa570db2f08193e10fe147f5e0803b802eb3350040eeedf8cb128d89fe9d10938767a12d3aa0ba84a29153344e7b178abb178a83a748f331a5d19b51a63495dd3b02a589e51f6e957f6d550e6483042a050808df5c03f56ef0fd0e74981b554a79ca734ce73729ec63cdcba7baa0718a97219843b215616d1cdb5472809b555aa654c48149a76633a5446d259bfb68145e5317de81bc475746361bc703a7b774b9de11f84e364f9029af8b691eda3d84e1c17e55e068c1b0ce00b0406436aad54b76527948069c579efd9b0ffd0df71daac462aa68c870d9d161524ecc97dba5c8a65fd813629d1303a20d4e2b6b74dedd0ce1db82f7e6c7d1d98b5f86585378bd4e4a84fe0bfa187e2ac32032118375ee63ecfc8c18b2c3dd00f8013242f36b0b5d673fdea0e80ab55792c2549bf7c36f027c666e9d6037e4e0b14dd05e24a9830266c9ad65b0c628513b108983faefc142dbb6ba59709ed7bf257d57f680715ad4ecd43bb3e373e662a847b2cd206981da432d8c36dbfa57cda38a8f86a30697a84d431c1e0f908722ad71558f96fe6f7c59ade66077fc33f6af11a4eba37a7456dc17ea68a673825eac91023f345b2366fcf94871786cbf1ce9830526ac517a468056b3c83f2488066a446c7fb4770907025fd729c1ae785c0eb8049bc59ed8d68e37fe83dfead8a8fdbd433605e115e6f5f5a4576819a349681686ad95161de59021825d918d8ca2433088a60203f20562e0c744dc1c2f76adfad625dd9d5d61cb483ffec7580cfa18e33a2e2438df6541f8448c96b290f521b73d2b092bf9a0df33499a98402a83a43d286f460852772193d5b16e7ea7e9b01d0d03300e9b11c581da745bb0d6ce8fcdef51eb3f59eaacc011dbdf1408b28ee3c6238f81888778baef4bcf162b4858898e087c29668a2b43852c85a0042d0cb0a06cdad44f0c0f1bbdedee5a11cfb1406efe41eef37e5905e923b283ef2d3eb802d57183d9bd997d2d5acc264c57bbd6cfd3d9657e2b67452c8d9a51dad63a7ddbbfdc336a2389f7ae008c508d6d16e90987f9125e373d098b43b16becb32fd6289e354a202d4ac3b17b4578cf6ba790a82dd804cd78116456936009c671c9dcce431478b1a991c2c2a9d40dcd45464383305823a02d0ddcbcf91527fe0d713090bf3b5192e75fb48d87eb9c2a099cc455420aa4fc8e7a399220fd83c5abd08d4b4bc32e3e7ed09d379ce8d6c8fec6d9c45a79d12358d90ec71bfb5263b9abfdb872af86dd149497375fa97215ab69b959803603076efdc1920aaed04ae955070a22801a9dc48d5f7cbf8375fbf11c3a0930285685e69c01966c31fd423254857130ecf22dc6c0c108b259dfcff87c532b2172ec2e2d104efd0320356cd10a1426187e87709d2488d5c71fd615fdd3eba246f7dc99d5ca441bce951b422884a9604515bc98097ab53f7df1325a7ed078549d068204d0a134edf8920145f46ac9be8c1ca0abfd7bc54a956808ea69888fb3a50166154a9151dc09bdcfc02c7dafeef25d59e2d31e2a3d5bae2a4abbeaad641d42c2b386648d23a156be34e8a6d756be8d90790deedf27060cb5b0d4d80fd5c64c23823ecb6c1fe2f21ffca6929bba88e6a6a945f488b84c8da6da55aee87be4dd282631528e70f9091cbc2fcf0a46082f03d4bb17626adafaa3a4f54effb4f1565d0eb2bff4b44ba673fc50cade645ac51cfa816ffde9f6c5aba6d393e3b273ad486d1b9d4e2c9dacbcd251a1f4d7ade9d280371eed09e9ed83963e87cbf17c8d334cee928629edb08bd7af0cf981a0f0f88982880e7042c441c1c7b27b320ba2b1dc177d1b116cb6e3a1f4b8cdbb062e6cf07a5aac3be90fe4e84b3e62df92c4bf92c3105915a92abd8b4892136bd06f03fd655929dd07c49770b78135b8d611f47b5052735e4fb13d39a744c1836dcb758ea4a2581cdc2892128607d997b8fd8b8a7a7b2c3040a97857a110cb103f2b8ff125d614c5f968963d450c6b3958786c86ebcecb35e9d5506bf87ca1182cf11db7ce60664c51a54740b29e5286126b7041e9d38576a6b18b317150ea3018f87623e0bba29504184b54f7ea11c9b968066eda63501f3441ed2f511a4ed47c8e152ce91d4dce5f7208b24691af0b163a1e4b51b068b99acfc1a120678670c4be9078a4b6ab57ea760289561aab2455ca082739261374fbd8c19e8cc88e77ca993c0320d42b7a902ee28ae2bba93af44164ecbf7544fdd601ee236caada0b89225f86937c5f007248867ffd3543e79598b17811ed2295fd66b7b7f2e1e0754fd55ce37cf2798cefc170420bc8e8fe1a1923701e070b2c48807b88a4becd0da21bcef89264bbf481395f427b711695a120d5cd8cc03ee50353ef6e3f8e6554645128fb0141d25529153cd333660790b7fbe2c386de26d1a62a762590893ef895317c7debe7501dea295a6e584a1b34e5e9e9178110b1d8f24dee67eca2e9e074a192cacf0b58671247a26e21509d9325b8e8892327e54ed371ce32aa3f1231872726b9704a83aa5a1a2bf52df2ae6fab760c3a46275aec963b12ef9adf9fb8a6b83967e5c6536a8a32a2664c7ce6e9c8058ba6fcd57a2893291a0c872990e1d07f41d266a42d3bc4fcad5c82015f3438d8d7adb488e8debf7708e3caaf7c806f14491b6470349b5553e453337fe00ce54de3a71f5986f7d2730463b12334a6d2bfced3be0da477e2e4f0cdfeba6854e8f59addf6e084a22fb848270527cacef58f6a825a8f6a694aa11d30862cc098ca84916788c3cc793692741cbf0d70c1cd7a6a3c8e598d689d03a5a70bb68b580024c6db1b10a85db6cf42dff557ad8faa850eedd8903e3820ba14ddbe47adedb071e30a6aead22da98c30b03e2ef128031828ffe97b57bbaa944db94724b977e0e0a1a9230a1fbc401e920921083bc1cbe5d882d1fbda0fdaa793ae78cc028010a1ea65ac24a4b9f729db2aaad923c2ee178f44dc21f4e2edf0c68a5ec92a52d0e961d035d924fc8f3c607111acab78a9c5c73a8d09bbbc1547e5da3e775cb82a124f73888cce26fa1db40cb9f6d86fa5bf00067ee438d4117abf23a8d8437b2df0277c50a98ef16d2d88fa5d62c93babf59011d4db79fcb3d806ac9d2858b246cf2d21e2b9113168d8800ae182d47fa361b8c3d74f8f0914991642ed0d98172349b98d97ffcbf19518f0eb8063ecc606a7bf19f99248559d4ab8e510c2216eb02efb72f50cb29a12afcbbdc1c6ada83767f0cff898d0cfc8ec2fa9ad9f6d812e17c5e80849b64801a55b8f35655fa71f601337e21f87ee78fc96e76c23b3d1d4adec3cc2695165ecc596d1de51b222adeb07c1f5401d69df15d5dd505e52d772da8223a73474d379df6733ef0a2d62225fca84bc6eb8e32c15277af2340833ec1895c9478e71ddaf121097c6e8d87c3403f234ef557a2d23c7def7a7911ffc5248333c94892e56bdd9d97c30747b0e96eaf83d7efa82e38625a9bb6ee184f13d35d956bb97430e117d850410ad76464d0d8727c9e172837cd671462b1cf3563e5d0312fb4fa888944621cea6e6d557953b404349cb6ff35e649df83027161a225fb766f1768b28188bcdaf5eddbff616ea077db9ee858ab601967a412a0a9f4f01c1bab267d1c3e716c155c236dbac9a9c6c2b16f0b93a609724c51ee3c6430eabb8d038b08b0062b9abb60c3cb7f51fbb786db73592349e61c219b7a3a425f7c9a05bfe3886e7707ae7704dfebe70df049c2e1c4437949a26f2a978187ad412d2d64c8e63fc1fe53a87f8d38288607a7fe242ed9c66d6f4ebb2ddfce5cf1c8bf77d22c1159be61802d7f08a805f9ba9b81f794bc7b0c1a6f649b0f5c828e9a267cce9de7051d3695805fc48f4e549940035ac5d867dbba5a7ea6498d5dfd9346a55bf3c6b10b69fae53ed360783286697d07db4dcda456e803f8b27ddac74189d72ba644af9dba8d28de8e2f85a65b862ae4d1da7d2c076e07b6f25b8255663f11e2541f01103c093b280e58d37b65adb95c075672287b0f7488b8d650fc7ad3c40241bf20b7d8b92f3db4328dade3750903c2b5a84a735c3a1e34991ae927cc56c1d246e401c8850097a1d8aac38ba273e4a9a88a28453f02779bd7963acb9e699d1133e69f1c43e1733ef8b7cf069cf3cc49be5e525a3bbcdea7eb5d3af951e1ad2c8c1084385e16afb6b9cf1770bbb109921f86fbb1fbab1914016ff7f8efc88af6a52d2e54d0899677b3801ad964bd4459d7882a5b31c6b824d20ea642c983026570a060fb659818b5ee8a7ac6f1ffc2d4aa3286fdc17bef1c7411110787f4291258a6298d55d1dae7fba98db06bb2a42182427b51464c8dc533e118a80d84e2bcb6c4f1bd25a2674817ddbd8316e0c7bf606ea4a5d8b9eeec81d4b43c2f32a4c5d3431313e428a6575ddfa821cbbf9312eebd145a3378d2e2efa42b0e2e1a35b374d9586aaba63c570fc2eddd21ee42e38d7d62661ff100fc3b19401c0f15fbb1fde4a3737a4c53d0e7dae4016dd239de084c17d332789d146e34df9abc63bf0b22dfe4315a5c6a0c7f78124883b89513c504783ddfc7c906047c756df88a0fb524df827bd4d89b9bbf0e01645a6968768e886d58d0a1fd342e2771b11ecbe1c5a857497eba3caecf6acd5379714c035fefa6b5689aac15031c499f34b8ddc6f5116df5383bf5d241add24ea00b5c4c0b19aa69c8b8e8a55c584802f8dce2bd22758786fe4998c84ac36bc6653a7656195c475664dc568d2c363578b566a8b2cf180288f754115e8bad15634ab8d45d0d31f6963e8aa921e44cd10754f3b4c9a3851aa49e4b3e0166f52f6c4293b5d8d0d0ef64ec091c8bf9045af375b7c0e0e62681f243f5b618828193d736a77e832e5d591018a4c811653468c0ea208615087b2d9f8b97b8654b7a7f3084e8e52e57995aa8ff30182f24cb763c3a4914b81bd457b8ecec6f906f3e8e047a7ee89d5e3223edf3f6242fb88fe2251f380dc954a8ba2c326b1b4e6267a4e9dfad9af0bd9720c5d9d82a0fa6eb748908f679078e727d45fdd9bf45dbdd0bdc6b931af0cf63e694acd45e0ff7c7cb14986e1e9dc6226b31403969f555fe2ca84bae2f0f55548b87f8d1c71fb8793096252377aba01e5689c4f7315f8fcd974f9e3a611af2d27c0b5fc0f2e87abeafa23aadca56e1d1cb0fa3798a320c3d4fddfa5b8d61af0d0b8618069cb2d2c884e31511f96ff3ce7950cdee7a7b947f88e9e7174b9c779f2f866b3ea8d3da5c29dc29e0f288647fe62d8679d99eb16d50216220a1e99cc8508d364806a8aefc9c129d2b021367645fdee6a4ae8f33fac8825c6edb12503703db6ba45442f024b563cc464f2151e73e53582b42b7adb6f0a239ac89a82d600c878f246430459988f5c3594b8d1dbaeb871b0d8afef567263e5270f0a7ae66279b3de9f1b2d6c047aac7c3ea85e9c733c0c4f6f5c4a8aada8873477716b4954ecca1b032bad012142ecc4dd90577b5e44fbaf7d055a3a721325d8fdd6701688be9fe7409d2e492a8bafe2c1248adf1c31fb988b39a8bd816ce45214093c0208f14295b03eac85de5733cd58515155648c650e2bf5e46dc446a53cc3972fbf3955e0bf1728eb34590d0989bb7b15d57b7b463a3a273805b836225a0a86424bf567222bc44b9e57edcdad8287d3fd8c587aba9c7916e27fdfc284907e23a8d51018a001867da1d5c8b34f8bb49b2fc1d2c632eeec380f06a4f98c6b15f17ef448d0ecb64df18211bb8b2a63cafc3e268a618d3ef1924d065f792944f2f50e765dbe3bc85e6163ac1a015c51dffefcaac8777c9c5f4f183ea7a271f1baf5774ac6b93a0afa6b4b507fed8eb0f353094ed3c2d1ac071ff0866032dc833615b7bc4a93d5a8774666358bc59e283950247bdcb4b200c878722fa595064c8df96432612785f909db419da27962afda9568e5c60840c8bba80d9d177d5bb113c50f9beb10438eb2564318ddd9d7634851c356b4f2c60f86cf9f7851ce60a1d52122e29c29d03640f990878135f2b0a798ab1286df17560f3ba8c911c228266db00547564e6f3d003fc7ee309dfe448a8a79644dc1cf6e6f8c06bd6594ac6434a114482bcefccc07c8e79a7b713f0371e4d1e3fb64563dde287aa31984b711eb88abae5eea76879c26162870385d2fd559aa9592f5f902931122620a0a28e7e706ed764c3f634465cd6a69e1c94c0d25bcd3717182023fc14cafc72610f1ee5e2519ffced41b316cc6236ddc3c72503f289f04cdedb19d7b711111408d1967605c2797a4091fa6caf21079498c420c263de9cc26f0741e4ec698cda34315e75727fb2a44691329c9f909311baa803ccefbf2b63a0cebf9b4694576fccf8538ccac1faf20e411a576bfa574e505ad4d8f44b2ffdf5508bbacafaa1410e8545e92538e5d6212e838e830053a9cdf8cfde49d65d93fb56f088bef45e8be5977a279eab6b94e9bfd29fb5988db4fb08e2246cb0103d7e930d714535c565a6aa290a3b0068aa0c3a81d38c9d8e1125242f256da0c69655ce57e5cbcdd1eda87e0007cccf1dcb7ccb9d2bf5c0e35deeea8e3fca31a1c299a8159778b3c17874e39fa07801ad643c364982f9499d2fb0bc083c9865e6f86804e3fc1da499d86c2e1b911190a1b91c5a3bf8b687d121643c5d9dacca81a89e7c3029669c9fb033ac7cc46c286489f6323ab3df4c19f176fc7fc3aeb180271ec3bff032ceded92f683e235668c8481fa9a6ec661812a811c315de3a0494f3922e2a616c2ba6d7ec02d42cdf4d80ea1ce9f04f30c9dcdbabb8f9ae80419382c83a5a87b7260a5c44f4206217d6a437dad51da9dcdb9df8f87aba1c0846f8a2fb401086cf4060dc8382fd7f77e130b8dd8e47e30d3bfe9d827e1b9585cf616cc73760fc7a56c53500ecb6898933842b45f21c57bc9bac0b8261923fe82010c08fdc31bc57689761c9bc8ba397cae59087785d697738d89dcad2caff0bc66c598b42bed0f6c2f939700e33bd6bdbfbbf3fc66079ab7fb859d7772148b9397d6ecf6517d50203524e107c550c6a74519181d68f1f47f2048a4dcd2bbcdc1b73e0fe0aa19a6a6ecec70fe90e57902ad9967baee7bb5901796b86552da320b91ffc7ee6921fca80db5d47d56e0e243a656467217a5485325ae9f188a22a52e077ca53c076d58b56ae5a84ddfa3819342f680a4aedc35d34ea6964e4ba783c6517f1050cad377cd7bcaf96332c2d7ca852534905fb370fd5f3aaa121d68ee33bbb223436eab1c91e411a5d4dee1b683d4e1290e7f0ffe5fe42aeb61e0dfc48cac61fb2bbb5d6aaa3bc5781c6236b5449885510dd2eab91f728b6f438ab5f24eabf4657f8eae52413716ad6741fe0c256c7a918e3ab773d20fb519fe8acbb3917ceb4de7d38a3aca0e6ed8afb299a98eeb820060f7110d85d937a9f3a4597377243f67aada47c9bd0667ba1bd00ddaba56c8992651e9c2422cdbecd5d5cf146931047ff400301b364811e61ec53ab50b1d53881db611b6fc70b80a5d90b03b7a24a63c06a83a628208ad9af924831ee354c62ec368317fe91b33e732c21d26ed1ace78e3522e1f38d183a89eaf6fee6190e00b56edba09b33acf64f7fa0930e1613426dd8358958d185fd02feea125e66ba4bd793599dcf1ee48b7bd640deea060332e3c3e391e7cd72c59191a6b4a226d5c6a546fc66a550cc46e8a4ebac4bc420d91049a80f70a141dc7f991d1f4d4646d32c385cba1679da6009f23f319929b65be3dcd38e9a7f9a09c80839fb5525dadb403e21f5759306a136510f7660e733110d2407ba287ce676c69b56aab278c10cf90e89a471114d0837c2e2d159bba744a326be5013b6d7a3715dc46040950f9c98cee6638bb4328ec4327329dbb64b858344c16d00a3de6a0d0a481008723ca228391e0b1c1338ed1ac12f026067f786e2c5b11dccefb4158a1e9b222586a48244572a2d3f8f697fe30fba6411c0a992a62d82451d88d2810158ea03d92508e4da5b97e63f37d22a10f46a8f77d605876fc5fad840dcf85404a3547d95290c39e57e08fc60a0045e7785ca78bfdfd0686e353761c569aa41a9fe6fdf0779b7d85767b1481a4e951c432319223e5f74836e5c26d390e0ae5b90a3c4fc6e8bf5a6ccfcde7c25a19d1b854dc9b91b228019b2060db66afb8f7c4cd34ef4c50d184daa476a2cf49a39ee814d008e507725a58494029a34481db8e410ffcb8da65302ca5c482d69fb0c4285861acf5d0ebaa8a41b71de4aa9ebe05f273cdb3f3e3ee4dd2ffe45ef5fb92b51f125226c0a380fe71099c8c74ed01c8c4f5c05b34a55df198e252c47146a837ab46303ba22be1cb61110eaa243678974fa2cc4fd5a7927e170ead2a6364c514404ccf8831c0eef4df73bd7e66f8ef036426e029f886d407a4e900904aa114acc748994d0850e8ed8f7d72d771eea8c2bc755c6f7815a960b0dec69a4126c5b9ab17a47ca5b498ccb3b73eb20aa62de90cb0aac5f994ba662c2e8964cc29848e51db10391326c3729f8f313eff2a08e2db42b305ea3b2b6477900cba80ad2561e39f5aead87c95887d00fa8fda194659ab047cad275e11f60cbc8b6c8e5da0996c340659123d785fdfdd1eb440ff04d263263d715899224e13c64afc84577f04b87418bcad1af005d7a1bfd16d2ac69860478545c93605a95ed0e2d02a6f0803b59dbb0d942912854391fba49a28336c44ff268e8f54ca2f66093995da99305b85fa443d09d5d7a5f4be5f7463575c21b8732c1d07a38b15ed5d66e9faa3199a9ea671123231b21aaa0c8087d2f44f0bb4c0db968316f2890e04ca5ca24a033bd32a39a5a4573164004f992e917f7cb9a9e4c56932e1b3e1ace7f72f2c238c6d92409358bc735d333d2fbb6b87859efcf342a138b95cef5588a8c5715b857686cf701febec4d38f99dd258632fd7af626d6d978e894fae813bba47fdbb8dd935da7269dbbfee2147af523c9706a2d04dc8bfd89f1f2799ffd048e6e5292b071c1a2c5d6cd759d1b1f7a761697c58956b4092ffd7b5b0578956323ffffe1393695d763ee8416623e5b7eef3887d769ebe4537b47ece0c1202ee7d1b1e6e4e68d1b1534d9873d3279af0238e64b83ec3479a8e2761b09ae9f1a23194b55aca619aa2ea440eeec353a70f24bc5b311f5dd2bf6d9dc2d4e37eb431412c29b4870fbf996d254c7d134024cadf8c4d6a9ab9ee3b6c888a432a612a94ee37effa2bc724d3b106fb8a31e95d51164c27fabfa2046d88d9233e7acf68bce4ce988d10889fc3d6584ddfb83baf32f857fb48511f51279f6342708dd914ce01e4784a854ce3ad00b68557b1c8e5804a7e9d5f0e39538a64ab8612731d13430beeacf2ea62528d3f1dd23fd416062e0e9af1229a67dd5eec12c3caf85fcb639a6b1516388a17e18397d539a7126086cc12926e3564a979a07f5d32918afe0fbe4d22d7385706f13bb62817ace7bb381748d9d3a33f2298abd208f1f0e60040f9afd9819afd9808a81b33cc69e312a7e9f761dc63e08a94df896e18ef17adbf57cc75f631c497f6349efe393cb6fe900b1bc6153c01045c9c0109d762a08a3ca556b7d79646cd3f20613ea52646594836e99f189c4e58ed492e3550b8ce5f43682d75b67255fcf4f5f8bad0c1a8958a16d1fc2d8982b1b9ddf9ba6f7ca8e5ffb750c970a7fe7c40f2ff74acdc46969619b0041a050d56f398b675c76fc75fe2933cb5d7b99c2f67103ba15aadb0ef659b7a4817f43b96dc56f50d62c1fec949dd793c9451a01b7769f5ea026ffe8390bd38f86088c35a895d746216b9199ed240df4c7bdb07344947ac97e2c70528b64d918e1e48ae45c8b04fc9ade9986805097256f908d2739bc3d3b2c65959f89ff047021a16061fd56ab8c25d3ddb3a1ceccfcd776e4f29b2c4723bf8879bfcc3f63f5d0ea761c7d8374fb35d6e942bac81427d7977111e7172cc2541f496cb82f59dff009f63fd5787c7b47eeaf2e4ec26db92fb7efd09587319c5e46d7eb54a5203137c450a47040d38a7da00294d010e90e19ca9f4d0bfdd2bb3b461a604ff4410184a5b6d471baffdc7ead1a8a88212ef731eac73ee43c3dc4c727aca783341d1049dea123051f7715d3c5138b0869f4343be931d30561d4d3c9044aceb1ee67aedd854acf301b29524d756d6cfa058b4c33f9a89dfbc5af366d81580d41d3a8f3f8133136d594f5854d2c8de741d752a2adf57e9176a818e92db85a5c32f9ba44cc519a1bcf2530a3e29c3bb2b70341e97edc090fff4f0deae2e47c91a4054e2a78d80bfc6daa229617992227ffb760e118ed21002c74c15dd0460c128c866677d56fd071b0d3880ff53e547e382d4e662fb7a404f1211b80eb04fa1280bddbbfcc4577a9f889121f0286c39591e1bbcd801af3aed5c63567ba5a5e69bf11d81eb60354e62a11e69d4d31c949f749ee95dbda72d02730de9579f7f2eace625d4d7b3cfe16684b1c694ac0a15d692a3f64bbf40bd67a3c195e7144945e537fbd08768bd079d62b3f6c0838ebf3b2309e531750ac3406b69c13a53ac6fc081620c9440169512a67d27b94852c9789630b933bc8c4e5b44c520e468b2e80fa9002c80f292da9e0b3c9ff88c94cd254761b54c8c0caf3f7eed97c942116c6596db256f805c1295e780c6e1914165920187a0930a9b616aed005071870edfe9bccd484ace592fd6399f89422f8bbc07ae263f54ee18660b2475b405a8ec46ebb2ddf1659ca4fc58c37ddb509e34fc842a32a08f66abbf9e34597ea8ce7d1bdc077a0cc737b6b9cc38e816f74564b31a55ab20e83b5d9edb8a02608c61defd8f5c0b6f717029c2de7d69b7823f80928cd6cf730e099eb07ae86adbebbd01d6264881362ef725fd70af9592a7aeb4b3c093586c0844efcbe257b80092a2afbb081698184e16c71e00729dada7c0fb5e9665e005751b49e3288f12b3c4c6d50632aac1b0d03a157bc50f7b507508b4eb006249b4461de6737b628ed54144a867d4f75cfb57f0dd75f383b7150828a03bdaae1a04e2b2070732138381f0a602c1bf7c6e36a78527da51f4a0b41ab292422422beebd8b3ed58a1b583326fc2f73af72f06dc10fad17c23a4c73ec285be59f72f876bd9199375c2e4f3877ecb6b2d5ec89dabd1eb239c9e0230e5706fbdffc624fbd082a463d4d8f965634e30fe3b1b09868ea4bd7ba41974835b154608cee47405dea00180ea7ff37cff690c523e1cc03abbd7e3635ca4b2bb5618179ce9175f1848a358dd802ac9f9b01ebef35faf3120c51e9bc8acd6d354ee072e86873f7f1738db8664dc6dc9ce4432bd5009ebc4b456722245a47da38346076a28428f1060002707921b08994882bde880d18a3a3e6c209a98e98cb32914a484f2b77492e14a07aed8d7422799b47e8ee0a8f6ea7d4cc7071d06b3f980189c101d00e629f2e572cb2cf691e73e2baad9b49c5dbeac48ac1f610aa84fe14a0f3ebc6d0dd28df2c9e66a8442546587ec5454169afcdc4e51d99007fe3d6cf99bd5fc5a8b7684c6beb57dce4e266ad73e2e00cf69165b340b1b3996d91202bc023c469f52b02af1f767fb531d865c247dc04e8235726c45e2e28947463689527f426b3803623d6e8cc9c8106bbcb2e2502f7b7e892b4ff99b35cf242f0296d0982b98608a761a3150ca0102f37c4bc3621877e089e28c0698f14757c14aa87ee81d62b570e368a13d49a367422fcebf9e8f4e9356cea36399f61240e0bafaca95026cdeb0521162d2f574fb875e86c61973dc6c2d538e58d4229cb928b0e1a222f16fe3294d564980085b6239d43a8c7168585e03661257e1c5d78c7a0e600ee3c1e314faf99a6d5d6274c61f1ee38b1f7c8bf7086a6a0771d150010297a03bd3b413d71206ca15d3b90f8ea6b8e6b5ff0aeac6546d9d8558f2d780b3316bc9265c8e0c049652fa0d9b42166e824c332cc0babb2efab9fc81de9bc38a81938d1df7c3ad59036be521731361085af78ddf4b2beccbbe19c0a155cebaaf734761395874ebd6fa2d00ef887263bf43ef365ff390bbbed8fcde75013e8cdb23bedd77faf84986e457940668be8d9d05554f9e69e5cb7fccb0014967edb3a4e6e03fbafe52abf870ee4643bf1f51c4863ed8ddf2aa05e424b58d14f23ae9c78f6970195edee7ab853ce98a130c91eaa09c555ea7e68710eabcee6eb8191a4b96c78335777664fc0850977a8bb65a0b380170196726b244252aee64ee5770e4ba2eb85493188d25024fb46278ad0d5a2cbd0d094500201d51f16c51a0997b55d962956be2c321530ba1c7b46b4914269ab14791208ac55e5637abec1a0ebb83c72def3c871a39b0f577c7f4a8c37a68c2db9d3f31c8b3636f3238e9f4eb4af00a4acfbb5c400e619333ad87940d2f88878ca626a7ce60d3d7fabf49287f4edc4b3a681446fd08878e60e90388f7777c5fe05a385dea5bc20bf828ed134f2d8903bd50bea5680d554e5c0f6b280bfc06e915e2eac08d84a4c606cfaefa2ba4b677eb75cabc8e11215bfaeafb16a4801c8e47aae261831287727015058729a0b2e77ba0d542aa545d8f54a1071bc3330c5f7359f26f784fc44252ce6a8caa74c5fdcc6f91630e58872219ace9531a45b00791ce1f2414e08df63ad69b5073646b781b077e14c9ef66b77b7ff981446055cb3f41b242d2c1529fd9743247463d74fb5c864ebd22f20c4bf4e66452ac48ee4c431f11a715ff6731bd24fe26a8d3bdcb14cff4da1dc167c34221120b951b6c2e280fe19da4f99cf009ae3e665d8cef603f290ab4a4e0429c88849d6e0212351353db0addf05a65ed3fe230216aae2b2cc62e93158115311d6e9d10a1fee01a767fde34b91afaf4d9762acaf9c2ea2e41fbaa881ab1567964c43741c7074b1295e065b55391ff54f71fd842766d406d158085a44092ee6ecf8a9e0bff3f47ef7a7d2fce2524db1c3065c6927efcfdc3724d35d7b85949065b9bedb865eb5723d2790e908d2d1fbdf92dd5e2ef795d7e92a93a4d1e164a9c8013ebdaeca7e2cca1ca35c794969398e12359b243d63b65cbc34397aed1cef854b763ed0ab1ed06f3b215fb12b791cd1baebbaa9e9b778ef94989b659d2324bbc1c7984ac2e50107a8554a19418635dbc7da478337d4a2d0df12ebd7e23f2753b727f483ec28f324d33d1ac36fba133795b38fe5bf4192b8e0ebe0a93d1c9cbf3b9f25599dc07ed6e90c90b01c64f5a2d978ca900d4ae2e945e09abea6cc230f71cebd56908b55f232a924cbc1750882d30391fcbe7ee029ffa23578b64225621c6467950dea3ad40e2fcbf7ce033b052d7da30b8d2f11a39a553735dad6250048a89553b0425193776b83f08fc99b6d61e7ff0101f5c3e39411ca2003c4b18fb4f382a62c7b7605d061bccd9ba54a0a779448b7812bb86abd64c6df77acd43245337fdc0184b02188c88669461af9d3f3ad7a3fa570d173cdcf8de45914228a88698e6a60cda9939d899706a7ccfac70cacf4836128dcf69244b573fee14de0fe2b577fcbcb3d9247431ae50a06e66432e1cc86cbf9610a9eaf7fa372e25400c42361952777154b2dca53af1537c4ea46f0774a924e8e1c336a28e060453578d18da39ef8cf53755ea414e86470d240fd51bf9747d722b460c6fdbe1520374a24bd63a38b5452dde58bfbc446e8d1a219cf071cd6077cab7b894b2a91e9c44eaf9763eea88b6dfb35ed871ef878e8778f0ae8993995a517f16b153068fed3c829156020357ce1e7df6ffc5fe82011f5c1f50e26abfc7e4d5198a1fdba1fddee77c5dfc4d836b63dfd6611a1b5801c6d7f587aaaf8faefb6b331d3d1a9ef646aa14851425f49bcbe755c7753ee604170a94ffd29ac152d6a17cb54f08276141008d5793fff4a99cad191292e29283d1ddec9167efc110cb530ee92df5aa16152d7b333d82752e4fa9a789040af680446e10a18893e7b680e2897867bdfc1c73073c27c3bbf80527664357457c752034af6299b16b322981f2bb64fa7fd0890a503f3d48cf872f3cc7426bf1dad3beec7d59349e41a98efd754b19fa7600f2ad417cbec2208d07d6fb35710a3611e22896c86f28c6fb556bc5ddff36fe953147ac2e5a37d06c2ab13ec0c1e32ce1895481b97f14f7d14ede4b90ea06cfbb354647f6d578d4374a797b23be8a025ed5637c12ce5eede95be5a46fea893e3f480eba7a5802525998736320fbb840b82a1607503b51b0ad987c76be46ec6ad3d57b83a63a3b46ce5db1ffb6601f4cb61794f75a9e830b0c98aa9a8e827ce739be65241918c9b699249c47154e7bfd938de9779044e2eb410737dc9a72a7d907e473e2cace0bd2edc3769db9ecc4fdc5a8b2553caef335c9c4a90b1b108bf283ae4a21446fa255b858cd523408788d13c48726e075cf531217e6b7b0c79a12b8851c9f08518d66652782960e875692bf9c8059c9b3adf3a96f10ce4af12a04102b7e76ea1dd20ae8b5333c37862495ccf1ee147ba33e9cdb5245d6808d7bc22aac70358691d23a77f8ad32f8834ddf7a0b8b71b6a264e527f679538778c2f72644aeb12bffb38c6fe9941d6e173726a72f317e208afa49fb61e8829d0e8b58d7732851d175b8897dd1b4451039b074bef3ae562c3fd118d6218fd17dd8bceb50f48fd18fc9afa7c76e3ad88a0392c78e6b9c5db20fd907a4df093c6dac96893be608c538ca63f51252ab2361fe7d282c89a65a974c887448784de1af745d366f727df90f752b4e9cccbe14d1a057f652bd8b1b06d72251fe279a5c2da5cf31a92775d30030e46124f93e3a5e05178294b9d6c198a1b424c76d088b61a5f0f0f4b40d4b68bdcad2719973945f34aeee68436bdf59e58bb7b1f886ec3c59bb5a84302442ffba89ce596a5a5568b5f3580d9919d8451e986ebfa547140db3a8aa67dd5d5ccd6e1b257b7c1fe5812f38793714f47d79fbef509ec63415bd0e705bc620239b631685d1d71af8960a72ff561146202c45751e1711b2f29f10e4c6f353e2aebe835cef1593e9026519ba867d5b23ff73a9d48bd95726228bf71599942c0ff2cb1a0e5a3bb9a8fe5d0f6cced62dca1e6436870c75322d0d6cfc964300e7e8fa549459e2efd879fd452f329ae4149d6e8250500d0fa1b7501725b10a0f66f18f6d387344a270a4518027f7d3152539f967c923054fc978d33af6106dc146f74c001e2af49a0ab74a185be98ec1c77a43d488423e5a590b99d2d858395bcbe10e27363b179c9f97e128d86123482d9720259211915c145310da56ab1a7c88176e50b2b921a83040da5d7e3c90311bd0d12cf07f764e6b909e59223d1c4554063ec29efd10f71e12c23ee9138447d0f0f45cca31eeca434894ba5ba35ae04667194177bd59e432a6e451985957759dc57d6ddbb93b45dc08bfd69ab0e81fcc55098ae2af5d6987b0e083665c7f80ad7500f17e57205d7adf779296602e2ac0f8f2fa070db7c44f635c9e90b2736ebd5ba0b500db815190d42777bd09811bf5ef06ea0513393edc0434260061292ab510ff77df354e11a3903d50dc27533bcad572b1fe7a6daf9822aae2d184dd35ce97065a4aa971a234a9b7b4b896352ae5c3f2126df2de3b0e8dcae27b9364feedf2baa711be17186a0e6db0c642deb68b0c1626afcab885925cac30792c9379498c64d3280abad995f0201400a4a083550314e9d93dff4d56e6a6372046fb74720a2056ae9e04c43ed20668221563854c9418f8f0ea080eb7adb098e9fa1c47ea52acf0aba81ad95766e02fbc85ee92c0cc0ecc6696c0ef5098dceadab5fd74cf89710f52b9bf13f68053d5f0efcf2f9ebdae4bdb849b8375afd52b3a26dea580f3ee125c78d1c71f7f2baf1783b59869ffb59229ff1ea72b2851cb4b3687278866ddbbaeda322fe9a4b39767f5a92d5452ed20ed850488edc36ab1e41a9344a19e419bd52f8e4388c4fe5890f51d9975c1a0b68b155eb78a4c5df1362f527df2bcd42777dac53eb4c9fe48b0a2c57f1488be43e8b0ee7665b8782e96103c95a4252c2f44a6f30571d80ff45c3372d6ad288e3545c181b9b567efdd23dcc8c7788bb962a68532bf087309fd184faa9d4a7ffcfa72e5db7d46f769b7d28ae5a074c205034dbf553c3d44c92c908ff3296d4f92e379e2209498231de05085f38db7fa725027af41824944349b5016fad0650679b0c5e686bcbf1a3bd0bf9ae91f8385842cf72b44f4419da7cbe937d6f8973763feeb39674662141e2d3c81ac6a5307aabb9c178fed1fcc0702ed7a1049a777cf008f77cbb32fb572c547a2ee6a2478662dfbcc8e292963844e459a14e46fe6daf4d18a0cda86c7f1ac2c3b7cad6fda6a4768926ee3a88c502f29b6acd768be78f3417d93005e512e1b990c8efd3f9c86971a615336833f566d290bf17f507c647158b438a96dbbe445d7e89bddb863b855e6071fcc34132813521b0ce573e4fe94b1b7c44f7481d8ad960dc287211e109655d1309c61aa9b436ace495da60ea89ee072f4f4528620c9cbcced526acefd36813ca257c703cbcea80b8daaf8068d7eea0f6d163fd174d1d4fdc25f48e415aa14e9f9f05b489a9986224748918dddd20cc89ec334cec8e928501dc779135292eae6e48279efd0f9d0a7965ec830680c6833ade7a1e8c4d06019e4054b31fa97e26cc077aa9f8cdeaa7e94d63824664ed54c42edd809024501b27ef3b954912b57f3a323b9403265957e64ecab82a5823e16ab2ef037bf7245daab785ff82b086d3b120b3e2131a73b04673be2e856cc35e6883e03cc26c0005203ea95a42d87d1276c27b5be03a483a44e1b1d0144c6416ac4aa345ee0df9878d41b034552fec803d23ae89455dd3f3446145edbd8ebee6e871dd3bc59ea808f8b47bc0202b4e35a71f233cbae7e7c975034fbb520bb8c0f31808be877d32e42614b75372e65a9c01c28006d4a93a2335ee64d0eb691f2a72e85e743d1e1a28369e77e8dfb07df46001c3c0db6f07594d9fdaaad07809bcd81b3c8511f30b18f95fd09db8f900d205dd4b0372c40837ff29de29f005b0a6b95c7320bf53f3ab2c3817348578c49d130e4cb04392f37edc3bca0fe93e2827634916f50d36b80a7a3f329318b5f21197c98269ce976c6372f2d087a2d94417cec0ceba5ec9c715493e08443051ccbddc4ce81535df790fc4cbda9b74877e5edc4da4a747471bdd621a1af6a4b54985172ed46024acc61d953bd4bde074cb7ae74b93f9408bc82b64665efa2a05062057ab9538c791ac1e84afab3fdad7e4fe9e9ed572614348f8ff7cb3c7a276a09ace714151cba2d818f50bf1da9ece970d37171ed72acc85f311d29f76f97883d46a97ada275ed8f03cceb5e2b1f1165e3e6e0507166097dfe8063a3469942cbffb8c031e6c6b50a4bf72c9531f736e14db78e748d11cea2b1f17310196aaed7251dadc61cb01f1a51ca93f3d1f693fd2ba1a4b0fc59a594d648f93cf66188efa058a38d08573b50ea278fd2523aed9ff5fbb52f94aa0e95ebfd68e185a5ab3da160789db06aa52ede7c674fe2d288b5333c73a4acc77e29a33dcca49638945aaa842a30df872d746a8a62800fff593c04024102a4fbb7c765dc45299a3e468714e54af1a5ad347ebf00a62c4ef34b93987732b35b534be0cc18746728cbacb88a39af3ad4c1b5d680e9e2127732edc0b6ff8036b7ea54bc252e58ca7a42d2948ce7258285252a7448e213614676fd453734db9b2149c594f4b6ad48ed49948ded6826189259bce42227d83edc27a07f893425c106cec9016fdfdbab8548b5565602b89c19b37a9a0f6d35333d6835932c448491572d26610168ea4f66776d0fc1c9083dff1f7cd2848ccabdd0a81b5c38b9cfc50afc901ac97724eb5c82dd99fefc6ee16afb281de9fbbcb2e2d3dbd9d63ac1cf964c65b9183f535754b804c531a8cef046f219621b1aebc72305822bc24f7eaa7b5b3babf769bae9e1cb1c20529c9d33c2f73e56ea482d4927d2243bd03c5544b84b3a139e6240a2b8237d88acb5ffadd04940bf9cd7af18e622ddda6433c71653f3348afe636c5d34bb67c55e72b5fda8854b8b68bdaff73c9ab03af8cf394bd5b7e3d3395c2440d29261cfddd8d6e545ccbeb8fc2324936a8e304d9ae8e97bcb7acd89249f54c7b6b0f8b270ae9437e6f66345f8c11ef79391cfe66babf9b94696b17ccc68eb4025b11959b3fd79348fdb2de17105edda408a2f22210db4025ce98415ee2fd2f609e756e115ede7db86a1a9ec6f0e44afdd5bead986875fb7a5f4534f7dc8ceff700cc3a459e5c552d625965f6f790177391f97d6f6273afcbe069cfb1f56767d0d83416a1908a0b9cf6f5390e1f94a3a0aeb0da6e5ed781cc978ede2b10e9c09b6246ecf3ef6ad5284351c79abc41653672c2cef57796432ebfae8fbbfcce538e4a37e6b89e67bce4b703b04a4ca66e94c8f9b7b6609ed5bcdf0e9620c727063367cbfbb0e0c30f34101b01c1ac3c0b419775d1fc0ca4fb51cdeeff4101aae57ee728e7bb34ca697c465f0bc4d06ad7f13071d1c2776a72c0ae39870751ce83672a7f4a3b647dc18f77bc0f9f13746f9e2ba899cef3e8202ca483fc89adf0e7ecc3342f124ac670541574b13b0c12318118f3c6a8311d774171e8ce0107bc1282b5d4d7763dff0b7ce24f3eaa61d29b192b9e90ee021f4a2aee3104f1f2ab7ef6054377fa9f3ebfe0c2089d8e3f003ec37f2e02717ca4032cf48bacc428ef4de6286d8a382ee09bd3097dfbdedf562ee3a4b1ed1d0b8ec9cc0f72df8a7c176e3ca7c36e44e5f1ca3afffe7633bb72f6eb6996db3c26fe65c4a7265b4b0393e7b584ea52dc04565c1c51acfa0bb1955da2b6e626f3c12b3563afe17e87479e3656c9f76b160488db3f129c9824cb7dc70fe9c26d59f830101e1a1c5a23e941f0f8d3258340a3bba97773380bf45096de8f6566197e2d512c7953075b40d80f26fe608c4676df57fd6dc5656f4ec62724ac1d1b8ed0d08520d2e6777951338514ec41224488d79a5fe6e31eed700bc7c3a6d80b0e9be14b5108918c11337af851619708b6c426af89cba52ab59304b9c2eefdbe516a750c192096aae9b9392aa04fc40272fb7d1a80514c11cd0a2f0c60b9fbbed5d0d194de51120411af6dbecf72706c997eb37e779128e83c36d709030ba3d54074bd258728bfa2b6762347d1478912cfc3309bff1117be7951f7dbf37df3f812a4d36994d64213ddd8f265b4c7086db5bb64c6717afad6b46379289a3936783ca16f38cb60da1f94767216402b76ad097f0aa83ae4f74d5d1ac9e7f31bdba03613a9937b3fcf67b95884a503e96463bc830c40fb7981a773e647f75ce2ac8e39d64dadb1429aee7cbc52087537bd5091d19d7ee18f6cdf035be49ee000a6048b0d2174f49910b049aa5eef56f794615e825b7598a1892792b0966d72771dc1284d440c054b7cacf7ae20c5243c58c17aa1d13a5b07045a2710a7a9c1ad7f90afd50010c311eea1fccecf470d23a40ca3da20b1a30b6b5c44e7a23de8e983f3b5f4140f898d0879b686423a095d60dd186a819db7c66c490138682552775f841c233eef0f6dacda64da1ca26343bb8515cf5440fc43d9b69734d94ae3612bb98a3c92320c8cdee0e962e555b8a2fa85bc1a7aacd31bff084e2665d63107682146a3890fb453f32899a4ab8f62a1c0d81dfab53832db45cfe8957e4e1388e5620f3c937a1914811575966968f37908d43a2475bcde3a7bc50761ffc86e5a98474105a829ded0663a15eab31673fbe8736449065019a66a8e700adde3704fd674c33de99f4cb19995c47722ef2cefce1f898f565ded485f6ba196697a47121c25c60d8188997270cc8a0c925c77d436b6861b2b51f51db502602a33d7d1c91a30ceee4083a295958da56f507dd93b3cbb0815e7aec2902d96e3e30ff23932ee4b27c2f3152cadcc92c1cea4e43d20c0518835e5c5d4edbdca8ffcffaa5e0bb2bda0efab4227f62d93736d500be863583aa656f8d9294089bef0bb3ea04ad618acd251b02e3159eb8f2e09382efd4b8bc2868201f144e71172137059f1b4c2ba1ef4c7b0f301fccee270d373afa0a4463d81655a9763ec0ff8fd26348a7c58b5a9e8c99ebc486260511958801c4ea2a241ba4c6407e3ae49f5d165c923fe8d332a5d3059b46fc70430b238068450ce1f8ec477dbd398392e66d6bf58d4728bd108084e6463dbd6d7c77eecec78ee08307ac255c51d025bf7927a9276c2163e4adf0f975bb949a67ea162355236d684d13cc01956efb4527db71ce5e082f9e498fa80480363e45ab1b773fabdcd864237d57e330fe663eca9ca379fb426980cf8d091ae885cd060aef3ef79b3598a209d45f9788e671ef69a55267d32b9894beee3e2a23762b0c5aa06e2ea3a2bf05abf5bfeecee1086a0d85388caffc7559440c31daba90b751f3e4e47277edf924d6bed17885a4956181d99cf2cae346c4ef8d152ccc2a73113318bbf17c27c297fd4bf96f04543c75d3c2f75f569eaf2134319e778ac30f4dfa774a464e6cf995b5c92787f74ce16dd767beebf7e2d42fec2108f1b9b2faae2f71eca83a74822a39d5b749de39b103a48a8b1c469c0de4d1e28de43327c08639fcc7f3c4f6cc05e66c45c98d79259b152d16d54ff3b18d06c6fd3966755f1686093eac23dd7af0c0706367abd5beae4845a856132ad1ee8cf576cad3b56abf07fec6bfc04489f9ecb250a33389f047238207e30746d872ce0b8f9090b30be0b23f53ebbb51a7be34980ef6f596f5feca1f0214948a73e2163c62c1c72a4859ffd180d466d1a49886487bf116708a762acc11d395c334d3150b506b35571fc96c0238b4c7ac2209756f51098beac42d729bc6f7dc5fc8985f97664dabd25a7cf92481121a2bef81b68c2fa7a38784cf940cecf7ac5bc3acec71be3891c32cfdad60a57b4d04b881a5d4086d7a0a35dcc91d9ac040fb5359990649735e5bf5ec0f8cec468343fc0cbea0a1d3875edda70a71a4c343555ff2a594d34121a5c988ad198a7f92f967bd2470f9a40fceb42b9780198156add50f34b740f5fba395d199148bc085bf03fd1d78c42caf88b81774e3c3588e9e470bd07d3a95a3c1f3d1e62cd75c1a09e28593c4565bd679fbe5e7a1df3bf415067ae314df88e08c13e530d4967c444734ea95e8a281486faa6efc9975eb031d577c3dfe296c12c84933116a90f1aadaf1bbd43e2ebf9c8ffea001f40ecc2c74898194d91b97aac723d2ad784e6426d67ae626ba1cb5bf2098920aa7b2fb55fdf08fffbce2b9ae201817270121244891e0ef0746b6936f9efb0b6e0d5f4356f615377b1d855736a72eb529d84b54d10abe2213b70722c1202b16488971b17b03a1116647d1d6f1bc392f6112f468381bca148d4b81f19c1296d2f738ae26050ace2307679357a1ef7a01fe809ee628778d99dcbbb4893c38d9139ebbd9e3a9da6f72042154789ae7cca6373e511f0082e6f308db94fab00509c3a50517320faccee5e9ba21bf47a6ac46c449aa3852f0440441c7d8ed5b45801a36457b945465ebeaa8d32566a614bc6a63357d1e643ac74459aa6402760e6d24c0d6898d88b8f14c14ac09e3c7e1979354e1c925b2dea39f450adaf68d0b96b878498ae7310de36f65ff6a9e50b11ae6de481e0c6a74888f9fa9b1eafe10126ad373ea9ac73ac46cb76be3f6fc996773c85eb5afee8dd88427f880c77d03ec720e981ee23613d88e8a6a64d917f455cfe0f9e454566bf63d3d134db6930eedb0a698b1c65fbdb05843d9e9ee047818c278d1ac8deb7cff9b69560d5f1a2b0734e03c777796df2187aa11c59db7ac39e3e38978e0adb5a680d47bbf92c3f519b442851204259a5d7f6b9202e33ca647d5fdd0661bcead166dcc4cafea90d50b81181042aec851c6349537ac562e14c9aaa18aa7d9359505ed44e2d3d95a727125f08da4dd304a3fda1d03ea8340a055b6300dc320fcf56454517564a74c7b3d011e46e7e6801006a25c75431cb89ceba8106edc23f34657f9aebf06cc66bd329739ab9043d3b55e668d758373ef02dd6a2bde402b1b4e55df39ec3835fb8912259cffd88bb4d99c5450ca0020d2c1ed8c6c16d6562b53adbb7417d904336dc163e6094380a384539b2a224d91645c7d8846d439720d22c6560560ec7c8a34dcf97ad9e6b497d2b5ab03ac8ced3ad8d5462c66a45962ddcf90368707ea4f457740009ba0fc776d72d5a63ff88bfdfbf9901a48e07efaa0ccbb7521fb8826430277e27c9586a0d793e344164cf1ecdd8c1a0bd0e8f55ef41a90d556a59686068a68d0a3c0bc62862fe8f112254957c2acd380ea0111460decbb8c330bf33ce3d2d13d2f7a5683cced93269b8ef5254adb0effe65afc23e24ff173881b03e63e058ddf4d2abeba94b44d3dff42f44ff14cd192548ef9960cc161895bbdc67977e6a432629add35ecfebdf972608762dd395544ee90d3f77b5ac970e80b6bbc19d8f6f63696a0145daba8fb9594c501fc095fa897e1e3cff72087ee30e2facb6717f8ad43cf01eb184bbf4d8c00746171768752690c8a5e720ac36e1d1832942ff7871e01344244f33b8ddca657d2cc56fa055bcdd246162bad4d7d2d13e25df10d76d54d2dff1b2c17bef69bfacf1fc92cd8e1ab8ac41da1c0b84db88cc83c569288a0e27338600a3fc6d04f11774b47de5b84a786f6cf55da2235bdaf339ef65f5c13d76ffa78469564022de538d7601393eb6999213a5f10542e44f050c1705e6d0536544ebd44a48b080dfe2c5cb436523d000610a1ca6b14584e3e8e39cf44f311a26845f91fc5ffc3b0c342083e1c8aa9476febface5418735676076f3ff303160a3371ef830c5ff6c8a5db1cf6afb8de69983770cf627a676131941d18dd99b86d73ded2570857cb8e0c426ebf694c93690831e12d3a7dbc9e56acd32f3db2dcb123b5cc3898834bec93f7e8a5e06f00bfe26260ed613b2299100475830eb43085edf379c46ad1e93453e3076d17446304879fb4243bfeebf60772bb2c03b6a154c85969b3e945f86d33ff5c6e5c097db2c9a7d84084308cca056db0a8f306e24fb174a1c39ebd302796410fc8d61712edd7b47917124420735f30346e8091ec7daff81a735b892de3ce2657db1ad26d5f18c97bc9a86de40cce607ad4df5078e195f6418aadd1f00f316c031b60edd9289b2475751ecdbc7193dd8a49121287ad354676766a4f5c8fb444f429328429d9ea7930ba3173adc90e44c0d8f629db89f27b8d745b37bacf728da049b769317d50882b09beb961ab228e4b01fa9d7be7ea0d508b542e36747e4e9118e61c4abbdc901ac9378ea6cc0e1eafdc587a336526e1fa5540ba5f8dd722e4a0448cd2ffc7b363489aa1ef429f7c449532b611447c53bd9eeaebab617ef8cbb60a94aab9fba39f7f31ecd153d308b42ce212e9eb23fb3ec993ecf0c5e6f70ba7c1c1b6a6d6461fa4e99687d55dda81925ad9d27f21c1140d97b1ec054e487f35bb7161307ec6658a0e276f1fa1227c0a7f35a78200b04c80ad57bf5cb5d493ebf9cb16d84e55a6d8a4bc8b8a086a4fe3b134888b8ecce8f1978e6cfd822bc9b6647fc8b33d614f09c74e0182e121f57c131a560a88925b94390d5bab0b1138d75f5b6bfa3c3e7d3db0149c2316253c9f2bd03a1c693b0e786d3ddae28663081e251178a0f55e83df5eb548706bec4a20f7bc1e70d4c9dfd5202e97912f7df77b75776d04680b6815f96a990c256d15db9322323b42f09d297c61285f9357d7df7da44bab452566035d02459130d3eaf50484693de94d8d1c253c838552510d650913160d16f26dde8682a56b3a8ae778c93af9d51329e83fe3b18639d29d14d25ad1597178139dceb652394e4e5380343f87df2753c25a97314b70a3a314f86647699fdb14cecfa180e92131e576fdf70beb594e429885f386c66667a14cdcfb6ccafb070e800d4e2f6aa4e2827dfb17078a6aa1cb777c1c5f67efbd05ad746f9d00817706b016442619ad27453be7445da3590a220148cc4e7c791cfb648b65d9e9ca8c0a6edb912a3b496c066586b1e8f13268e05d6779acc4d26d69087f55747074b8f1d705d5bdc62a04f6577089f7e74304014148f19725afda01e7c0e83b07a0b508736cfdf44927fbc73690b7fa47a0169fedd0c26a8d2822cb1054a9bc4673d616b5a1df748aba75de01a6fcd690a15ab4edd878dbfb3a82b0615600fe939560108765977eb080a10edac555d2115fb34456aca45d644430d5db72844faab5f907c430ba3541bd35e32fd5b2573f3ae0a9f28db888878a61ae0e6b9801bb022431b7ab598ac7d5837e3b12fd0a0f5541f17430b28fefb5e3254796592397b3ca056436d670ced4177ebb8b6de7b618ac7dd53e9513f3514547cb5cde9f0081dee0f3638151bae7e881a3a4336228ae4f5f60d2b5da004e8e3972bcc454d12802a0fc7910da22e1193915946bcb0585a9138bfed2367e8088877fc610fc1fea461e74f2de9a89b74916b9e864679dd0899f91460124311f98f8c6215b03ec0bf9990cfd001aad04740d4efe38faaa0828350622656a8648247cc4864faa22567c5766fc2546438661fd118bb1bf3d6747d8f281bd4c03798fe981427b0201963813fb074b73999fa8a676167f09266b6bb2e841be8dd919c096dab86baaef1e9614e8683d4b73d53d52717abffdba591c095db83ad6e3ee3807ebdd1c5ef6420af4c31ded5b855294899568d42f9eb83b08002e20c647a5c13541bab7b6cedc33667d5a8f2d13644e8215e2890d60d268d24d60403a9a4d9f3ab0eea0b36ec8079ed804910a8cfe7d1fb5c18c5a8d36758976ffeb90a9dc5c50802ad7e69c670d18813659e37c3675aab6313134bb39e940de2f5df700a9237912b3a15ec120abe0cdc0dbf7d0c526a5ca3089579c70980ce208f209cff0a346f5e38ea6afdb82a746a3fb30268a16581612cba30737469d4319375119518d86d6a7c2799784de31b096bd53ed07dafd760008131d2d5a1d99e0c1650d5297d5b3029500a38e2cfee6844a7829e228ae417432a363b6a43f6353dbc4cfd8195b2a8980b30a6d8c2a170cc26ee5667d6ae2be74e9cf7833b2f75afa9f5fb2352fcce6603d901b6bf0f000ddfbe0ff44eee682d74920de356742520e31060e8d2df05601f762942f4751e65f178bc2a0243438380de198f1657c8b995d4f028c36872afbd56959f77f767a5d9619e2b5655fab8fcfb719c7155bcb9bb2b80441212049e4e8cff162ec402a49eb713c8edd667b88004b184635e7ca4c031b72c5df69adcdba796472e22f99d9e5a1cc88be4e9b6570370f52ef1eb4a634520c369831e21138bbbe71afc31cbb9cda365a217bd338230bbf56c0c2aac0ffcd753bb4108a73ee3e92f54bad4012eb3a3e9db4f83f69e429aa8c1d3141f9b485b52229bddb8bc29074e7e2bc42ce2b3a50f39d48ce8954d5984d100101f14940ba857a341f8974277ea27dd095cb1c2ff9b42eaec37f6b4f13793720e7543c41d28339c8333d8e19cc1f671c60c613426b324e6f38f9a833eae8e094e3781332328a0269087c94e300331807fd1cef14fd83bbf296336db0b2f52ca95bc28a8f72ac3b6b26ca95c6bed6be7a7c626c8ea9ea88291f12343f400b6e30a6e2aef80f8d1567245b704f3189b2fe1ec1ce818dc0723b6584acd7304d36cc92e1777de8d590c33160698885b86723da2cff5e6af9f3ffcf3ce65e624bc592dff7a971c2408af28ea6ef2f6a3fb4cbdb6590b228333a681bb70f4177c6c73cc2390758c42f0f621286a31098f176a6ffca500050565ba0d68e7eb958849b0c63111c31fbd57cada51ffe3f4538f4bb5afc536e90c66e58e625fc49b03489f55f8930d8d7ef2ba7c5eb319ab0be794ab14d9ec93b236c58019b90476d65a62546672820ac0bab6904991e4b9a2e1b4e0009dca8c797f13b33104630438751f91e165c113362c9bd873a7295c8fc99f7f480ced44dbc53f55c419eb228027a8bde60b400063ff4c889c651528345ca0672f358a90c069981b06ab4ecd959268af4fc923727f9a825d6e422d517b906750e3c57d5e5c74209357f456e5462eab2c0e4518b7a7bfd3d500d51f85798851c9556a8bae0c2058448af18f65c843f5f17826392465d81fe6ef6271917c1a01184b116b3a746d4d7183f82b8f911f1d4c0a85d1cb88af9bdb8531db2b1ca62338e5008aa06e2db552aadfa39f5aa0ea3fa6079315f7db8844ce423148132eb1019bf20ce71a3586ad328046e5fb11630f5815125b10495b45cd1e17869987ba1c1d23e997ee95f4ec158d8d70cce4ac2541cea37859ec170ae5ce4484e0b4075d43d801066c3048d737198df118560b7b1b44ad7975f060b1adf2afa986524f5d5f134e989e17737bc9bf96b4adaff54194e35d3086c1f2a1017a35cb6b94800fa51ec32e71505b644aba715d705c2978c44c4bbdbff415310c7708398cee6b5ae350642a764103e0725d8f69a38a2aa7ef7f83279070aff2fa41abb33acba820fbb71d994a47417d495c72eba70123d594485302e4852689894f6250138409971e983fd9aafe505cf381bae225e26c2f9d05916a918b9d1093e6fa97ee157d4d923106d4e23385defed60c6025786bf2e26c3fb80a9d31452e4fccfac5e24a4826b2c7964b1b081808027444d5c1cb73e9a1fc4aadd51ecda97eb249078330d5c724bd73600bdd7a33d69903a2eade2600b786d03b394901ab44858b3e743f2887d9614441bb870c9da4273c470cfec416a8582cb3a79ec1fae912aa1403ad9dd17b184ae739c143cac30972ae0f20e8314edc227225ae60c33feb86df0161c669450e1bc70c5a2972b4cd96f95698039ffbde39fca89f796967f442b49fffee26051535790222648ce43c8db5aa5ee6db178c19ff2c6928691cff6759eab74432834498d177e63152c077178101bcb9b0e2c7cf6ed6da83b50287ae771cc722fc52c521053b91a947561bd95207e9733f170bd596e68ed25d17f71a3af389882042d30b86720aeb13afc35470446fd1a954ed7e1db1d684b936000cefaf68eca379576fdb237652c8184eee3d7af6929d25182893de62cc694b99a110a7404ca9774567dbba40a182becbf86ffad1bad2661c0b1b1c12144a13f461914784af77683ac7cb114375ead01ba8ddb770de59117d19e76561786f03950174cadb3fe4341005f7f42353816d8e21d8dabe7883eb033f7827783e214d43b406ec9863c5ce0e6306a7e0db663b9ef9cca33383cfdcc6949aeb5afc1394f564e5cacf344aee9271d4259f13c2a9da036c4637b208fa18d8569bd3c22b2aceffdc905ce5d2cc214f92255f2028b5dcc5918fb2143c04dd57d07837115d7abaf8ff953f1020f7cbfbac4bda8937a24f939d803a32a5270cc6a957feb413635e049884d1a60e79d20f95b0a324e57cb914d9cbcd44eb63c64694380eb60108dcff34a08b2db81c9c6750a6bb8e8cf2666d0a8003c9c989df9f95ccaa8bd27e79d5c3a6f7f89986c5e90df6387e81979294122e0bdf3392e187ed195cabdde35e3d46fd973b555e53ad068978b2a78840fe3515a23a99a1410c24c206653a64e9bb131d4cf5ea6c40d60d222fe5d11f87d3efa6b2b0775066c6fdfdaa589bcbdafca0f72adb55c18248c972de6851631059cbbe37bc80703f49537748cfe3ae347ff0fb195a322e7d449c38e0d79398a788d88ae9d9eb08b302a69c11c637533c1afeac926403c4847aac0a9ff6673b30b632a8e55ad5665518646c78dfda7b4d240577af95d1ac1596cbbe4ab4a1bcccfb6d56b160ea52cf2e348661826f613e89a689ce3fbbcd23f6b905a4f7a4c39c8e2ceb8fe4e154776e3086b5accb8eb31acf99c6ed2e5e05d2a4eaa5b1c9d7214841e8fceecc9fa9c09470541f11c1542e629a3d8cb1add065045062bae243f5901568488de38b77d3e84e7ea29121f4cbee97a3f86785f0225a9e4737dd21ca9ff6360fb0da6d8534e2a91f81f89444b2b9794a4d554172d19c0f3982f14cca8ea782a47d46d70606944854f10027c602daaab513fb1bd183ea433243acc399270fb3d8c851fdcafa2c76f6b4e6b7ab44371e6c57e7df34bc99357f66a984105058d5957e46735c0736b7bf6be4fc30af3dd80bb01aab5a595d1d0f55f68024b601eda09aacbe4dc37125a885b5520fc456154066b0a51739f1525530c64bfcdfc1394710332e182afc1c119b10b1a8048d8ce03120800fb8b8d72ca3a22870c987afcff103f66487e2b60f0620a4c068c882a1581249c981e6d43a4032f1b3fb84b9494667e2b92adc58685a55faee1a72cf924f64b0d0dc20e139a57e2d13322c2c79a8e5d66d728731130c24e2e31b1105489e5f7604c05a4262d7a866cae61beb34f83f620553ebc4928975e30c2c73e43ac7321b3e91a769b7084ce1bb4453b836037aaafd82597c8d216b8d5a28bbb2dc4fb03533b56b6ccc1df9c2cbe60d256b60d8b4fb873c0981dc4d41e3ba2d2648e8dafcd74b4de726ccd1917c28b50e83060973728a6a31b213c7d45cd35731c6e6a6bc83f52a21ec2e019ea5a5f5a5c45fbc3a6d99ed37224aa17e82e719c628a89e8d4cff26df1be80d44c25bd20f4f2a0d6b8381d13709b5146e06507dae7851644a9087a78b5ef69ea908c4725914382100cad4eed4db205d6de94acd0aa33edd965117463b7ef2abc8edce40e3d9acaa881f83bdeb281b2fc264d9adad83b23e7d29a8f6b037fa6104669408e27661517a32e560bc113d3e702ec0db475fc7efcbf311c29e8e3970b7d024952cc6cf42d76c6f18b34f9fb9acb23c8379c11f840ef3191e0e0040674d7b6b30c33c26a05caf7c541d24b501e9e318e2b6ad9408436510963496ad44a201f75867bb272b546ec6f41a9a10afd178aa81ce9f73821c045c37e7d2135b1bf074ac4275477e0c94beecae8a2f913b5f8654c865778b095bd9fff454d301f9753313bd636da0dda5227d24caafdafa84695aceb62ca8adeb8a43fb50920eabd60ee145ea670d43af1611763168bfc4b7f0eec4b3dac1b7c5b7d47d52b361bd80c86847f4601d5eb65cacf2ab82fc27bd12893738ed103ee75f67ec94ff49501b4c72a9a5fca841c6df0ddd01904757fde40303110a00ba85884ed459ab38e872abe8a1b11fcc7de5b489a8a2e3e9353003894e66ab3e54300bb0a7e8c1e51eabe3e8e97c23b5ca274aa2bd15aa05371b2f51e55175ac1384cd51eed4bb556e1c6601abd981f13c356d26f7faa06a46dd1e01bf7eb16ad02bd32339ac94bad5b17fdb39867b6dcb3aae1739478dd7709d7662e78b41ec9e329d292b94689adb60c3634d79700a29013db7c9cc2a6668d9178ce1eb2dd49a9f9dddacdce6901a575ed8cfab872ef20fe27a002e0779a8a160cd5382c714a1ead1b9baa61bbfa7fc8499db206746f951c12eccc5b790e5bda9a18dd472e6f16f57d86fab1a339fd873616ccfbe3348a3d4c20853d6b1dfbe69f19943619583a2192332b8f19a382a1e36e67298fd517b469f64f241d6016261dbfb96b6ee3ff6f126de04b67a792dc42e969edbe54fdb561fa7435f6db61931923aaf01b4078ab571251b4afd80a288ba65a4fa8dd2cec10f3d8056f819df51c6f0b2042d0dd89df872f7263d12eafb9cb1d3ff84d45f1b7da2c5496fad66db3c8c608bbdb0b7cccb7ff0dcb6ab9250bb63fad5190c2a07967d39f8cc9c7c5f04d82798f124aef64a2fc1783436ea7853fc278c7c6eee8df23bf6607b768e7e621ae3d7edf158b917eef64f995e5dc6c139efa6245de485517cb1ad1901451308976657a8ad39e616a9ab5f35e8cd4ce126a0b9f5c0043aafe4fad4738d4aa6a162d8a2a2b91c687ab989108d41224f8c8dabbeef30ed49414f8e5da00aedab7e6fae0686b45c9d87fd698222ac373fdef0b9d35f4666d2a6a1398925e12173aeeed95c31934d6cf7d021102ac7a8a3605c6614b82130968cfee2f86e4bf7f9d54b359fe8b62920a859afebc203f4ebded31d67e0916adae4befff6593b8b68de190448fd145dacb3e76ab3682aaf2f0aaaca70e16b51a4126742bf07722cc3b796f3121b614b7792ef116ae03a7bbf41ead3aafffdb75c97ec10b7d992d91dca8087c129467ca1c52166e3168355030e1edd80b64d567d17575717638590f2a43899df6f60f5ee4526f5425a93796ce224dd63e71ea9f4be54933d85cb272e20c3b7b120e5259a2455978c0ec79753da314e75800b19b09a92411b5b4e52e4479075be2eee9974cfb00a88ecc73adb1b49bc6df7f12504577b810b2c23e889676e55993a786827ee1685eefeb7b1ea15075794aae55a31a49381f895ceef2a14a84f08921a553f4721a8a96de6784493c9cea8724b5a70853dff1887932ec327fc58adbd3f426123865210b5fd2a5263d4f5f75b04c2d748d4fd51151390a9bded776d245b0cc5c574df22ad581687c5d8f416b7f679125cd085a18c9d9002f8005796e61935dfeb58bfea22ca910d340720db01879a8c96b7a92a8347b42c9e48621e19559b744a8419e77fbfc2d7688bac100284b3f6e8071e55e62c6b54623ed9911caed5c2332429681f8d65ef34768100d182af709a8e54decfaf9b10625f5ff1a1fb6b0afd71249ebc1e11e9d8933b0fc7c1a30f25d663f982ffc146ff2d58bca82a522a3fd052cb4f3064c0de3229ce44e614b66e4aa4cbab883cf6a0f5cb02412fdb6dcd910b4318e99e99d19b0c253f4e8cf04bd061c4124f2b4e4e7631bde4be73ddef33e0089acf6eeecd62ca2c81c4de151b1c42b2f74b9b54f4c85fde21257af4d35e5a1388b169c5d6d59943a6b9709346baa66190d67ec1efe0148d080d461758af6048ddec7e397ac5f178ff0f68c7a9d268fa8f4ad0e4c4c49a07b88213ec4121c252b798ff806c6a3362676fc5d53bceb151a600ae5d6bfa2a06868e0a44ae1726e8c4266ee59411d524e982550d345f906c192d8643cd8d19d52eda576404d11e3797dcfb002012ae7ccb0c055729a5556830cf9e904d8c491a88421927ed2b5e0935e0142b9560daa5991736d8c65fafb58085cd637a1a0fb0d1f45270382412ccef21955f9278d33220eef62e295b5fcd04a0e8fe2a1bb7dd8e296717002e03af0559ada82225fc2475899ad18e600b48a40a16797d059c292ae16c78d20ff0a1739a203d50058145c28398735f51171be6c088ee9b83bb87a6b616cc3ef774130b9a595bbde8e27eab8ebcb26efa4bfb4274672f39752880430fc49a17a8ba980859725bf9de6c7ef90ef533ac543834bad8176d2882bbe5532f171580395a81f56c1f6af59af295a1e0e3fa7f60b62737b60ed26c1e3fcc98a28603fd493b078b2c4c61fed51769020ae1804e934dab300bd8d96ddb7426ec626034fa0ee3ecb077ec5e585371ceae2d8d2cdd0d8c3a49a148c493e802d86491be6a773127fac0fc4549e495fe73447bc55e329c2ee73e4467b6d73acea098268480934cf3a81863df1280a546430a073c809c03f02635580efb3b98f7d20ea0f8a5bb1935c0732c7d2260a74d3115c21c7684741c3492f6a9fd18610cfabdaab172846ebe9cd37246880d1bcfe017fa3710b853e6b0ebdf968ff250d8abd2de1eb1d08df06b7c3f2cee0118d989bed6c9d6407abc831e178307b6407201ab172cf8c881c457cfe1ece359b0e6671874d7cc56ef87742f4a109054ee971c06860bcec24043c29544ea634603a5c871133b9e84569a268f3e87b63f9f4805ba1bc2b56e700299d0afd40d28aa802d6f02c63686a3656dcfe4bfcde64313ccfd220a10af7cb210b2848e4cba09ee3cab43cfe4605c9b96c2845e8c362e6f6b252ec79e8987d347aa99d961eb80d8dc571bdb865130b12f991b766e495f954ced6b6e1f8bf8dab4809cdca8fbb72aa9aeb6b130d7e10d2f9dbf194147e3e82a4c7a0d0e22d268ea31532c224bfca0b129059416cc39ab0f6e31f4faf940b5ae4626b237723685f0f17f44fa9640d026a415424102f390e0cd3c5b40f79a6bcf7ad823026a18711e346934d2c50df55d3f08c116ea207cd6f7c1e43182d59b0753863b88737de1bcb953e1e81ac6e41f10887795fed4d19e30b7700ad614214afae05b3d46757a547c2ab13bfbfab425da89a259db681884204e2bc38d3329b263c3a476b94d8be2bbf6b64c08f4f4f23ac93fc4bf46c62fa8ddbdd26b6297d11be1d2c4e8186bb1d6af5a8a59662f0448a37276af47ade8c15b983693342cedcc512d0a2640acf1b92e0815087350f35fcbbfc65f56d9d0e3afe18f4f423b2a36be8e33387383cf24d0b1fe921fec95f797856864effadaa0bf18443c248b3bbf01854ef74ba88c8a2a3dc5a188a7a9d815cc97e282cf91d9a074cd02ca95d2a324a4d67bd9e5c927a4f10d302ba35c1b7f4cae1c5300939d308e29f4ca2dc2aeb79a45144f0ee9eeaec6d4664b66e0fcc08f7a75b74bc63b1fa52b38c26c4aac77fde0822b7220bcaa420ebbe1015bf361c82ad79e79b15ba373196878b5dcd46cf1d0a1405c24c9849d2beb842797fc25b643203973a5dcc4568d5f386c8686da370797def96aab33c60fc4f3d7ff0e6c1ef5ab7753a5d3f482d82a02c018848fe549bf7987cbfdf53eaaa1ffa2a25f37b53af499e50c95027c7b181ff63ea3f26cb5a72ace4fb1b793d0eb4405f2708da059b0a90e96ce3c651fbcc679982388bfac5e4ebb722cafe5834ef11bb73e3532dee1f28dca38de6f0fe2520eaf5863d408d8db4eacb24e2f26a7d6bde79796ce85e4d59f0e0f78420dada6bde1eb2607989c39a98e305766cc45955031f607ec3024de4dc288be0f1b53028b28d05447f32567ffc28fd2f9e99626bc43d09bbc2d7b792c5966f6f0d39c00a9803f40a16287ec024afb6913e04fe541e1fcde6253b7eb631d6da684311e29efef7490f02ab5d68d55fb1686d64cedc3506c59b7275f0efe8aaaeb94d6f2bd4091430679322117ba47445de19dc769a30a7751d612b577c2269677e2789fa2f3cb9fd38ba984fc6fefcfa118fd36f607aaa4907ffe91b8ff97b5a5c071713f4da77dbc6a13a9bd46d5d30387076ebdf252cdc5fbaa1817727de44549bd74accf097355ce3da01e629cd1077d231ca34b33d13db0e26ed949aa429e89d0a46d5f292fe869d6f6d10bdd9dafbef3a9f4b6b630a553eb0bd5b9f7380ae3df4430ef496c1461f9384e93edf76022506c553ab16cdcfd45bb5ecf603b4ac195ffb870308851b62031b5c7a935dc984d281afef42e17db7a7f10065a4f012c61887e2c9fc7c1e4123328b217eceab591b3c142ac8a1a325f9732cf5b54233e67162ecbabf8d8e367889e40d7a56dc5026bfccf2fc685961193ab9752e05cee9be7574384e9e7a6c2bbfc46c37a679e7798f4f71288b78adb3e69c6c17a00d65d832a1d3dcba73188d004fa3bab8f7eb604f9b6c08213dedd6f94a190e97cbcb9dc15e725007716d8d4a5aa6d949178c69330bd04da26679779965ecc6e7f8116d3cb67ec4814fea443a967dc09ce574e88695151a50e1adefe98e3c82b84354affc1f6e0795976e6a6d49ab6e927eff7440a6728a6f424a79f6dce59e5654354af722df1c7b724add724b3c39108b4268a607592854a1feb529b2ef07853b0d2c29d343b96ff971214b1c5646b6b52563038bd9753a97652856fc4abd1aec61c7130190c9b24817db783b3312e68f41c86a63ba65f26f3bba4e1c3958f1d9608f492caaeb5a003255a120a0ec18a16b3f8d649fe259d5d9360ff8f18023183b7d0a8b6ef0f71ce6febc773578869a4b329d977648a77fdecd74f9ad749b90568ff0b8eb6005524fe7d782be2d1be93b5143d877e783b46a9386fb4e84f12e4045acde20f62c50f14662c374d8be1f050ea36b6a85f69e98014e6881979a182c26d164ed2059a1f0f7104dfc17ebf3b8226fc38fd91dca9a713f0955a6664c9a39b2831280970443f64d6456df91c60e060edf8611bb4879a6324cfb3f4f43678c4e421f6dcb7339e6384a52f753f3287bcefcb74d8c538741ebfe8e03966c29b14db6df73303d218d37585e7b076097032c8d5c2177687b4c31c38728339f3d3c0c9770ceacda3c5516cdfd598e06c165239a031783348bb479bdc1f793da4d46b87568f3f37000cdb8ed91d7fc729b2d9714872ba4d20bc71e40d04fa9f06eed7d2ca008792051265a5b970b1070bc29c4b9c24d5529deba2875a82046f32ad2c3560467319281b75dc1f261f45b5fedc58201e302715e25a6488ff1cd7eef9977e4811f276ae97aaf3c6a1a5cdfec502bd00244452da58494159c5c333c606c6a1a9073db89408cb41ef3c7e500f1ed9ac3ac3deb22a7b858d70f8c4634ff79bd911259794c5ab1cbed0dd1d2ce30a38779fd90d4142984c7e136c553ce756f5e084efbd72678cd5dc504f50d19be15f51491719c518b12be6189dd11948a059414733a4d552e6c7e7782c081f57c2b4ccf1e07145c286b4a2845bbe01479749a0dd2265081c03b1c12a317bf088c8f3f7ea3f18c3861026482c9df5782f2f84fbb2387eb88ef8cc1a950b2f3cc6531c0418cbef328792a341f94da24e08652f19e725700d26cd6e48b799c30515ec4014c1873bae1119bee46dcd139e19749e6e6184658d38a33c93a6fb5002b563e8ff5540a938170f139e46ffe4bcc3f249e5ff73588bd4de1eed487304f94185c6f8f8bedf9d5b22d2822a42fa201c8317cf381bba26db2c213caed159eefdf1c59a5b47f90b6c332bfa0e14533fc6342d48b7ea3ba13dddbc3ff63c08c2ce941f8a1889347812c49118292b714e8e62bf7645b6c3537e4d879c7a660aec6d3d2410712f35901d99ee5d1fe0c392813454f27d2c8ed0218874f48fc79b058c99bd8ac39da164b82c0f009f2647e65f4ee8c57251d2603f9583e3e7963d1fd0caa81b6a17a7c56bc259db4daf00c016e07e3efa5074bbf8ce4ef3079c8a6fb9fd3a8344878a26291a3637073760504c974533457d485d961631e84cb2a346e1e2df5a0d66bf46b2df8b3d5eace7fe695a00b1477061f9e60348503215a51f0d393eda837603c3f5b446d01ee67d9c7a7f6d0a969d5b02c785961cc5702617a4d24adf808597df37b8ae6c5efc353f247697dad06ab29a553f881b65d1d57f15ac4a7f7c2c99dd4303387c484f602c401ed8be88fa69e0286dbe89e83790f2088997ea9fc1ae208278aeff1b22b0c5790fbb4ffa719ee8d06f1fa35463cf414928ee4240627377b5340b146a11f348388119b23790b32126bcb4033c35cf41d43d3925230c24cd474ea979e2aa4bd125330877adbb6023d0820b7104c25cadc6c5b4de67c2f808ce07e810875209844ec5d3555b30989d40349afafc9b7912d6d5cf7c31da7966077dac608d50bdef5a620b180ef2761ad6fc53f89ee86afd9c7d3b7421fd647b31c3d3490f274a30ce307424788e64c8ab7b6444c87d80651e4fd2d00d55e98a533cc91a95b7d14fe3f2468f29f51b64f0763f00a944b80e3ebdfb535255204f0730ebc1f6fdbe389558be8df6d270235d2b4eb59364ce0341ac0bcc19abb79c6df714c9ecf57090566d6e97bed59b2dd4eb90603eba0ede48eaa25573a172351c3c3d10e5e4fd0cdcea120b2628f58848f24792df8dfe7a5d4ecbd8473d501846db99834103536c3340d0ca8a5a458a1d8cab21d73f44d3bdf9ac1862ada585fc16b04c9d60f99d98b4142d2cf267bb7fb25bceec29ff41a370b7014c4ffe6e2d5d6769a2cf5b52622e4ccb654d74f30c7d526e70ff36caa665ab09b5090f13d9a59c96fd697f7fec7a595eec82e60720f1a8e4ba1d8ba5282e7c59c70ce1e06db3855b2d1b514fe07b4e2379ad7319b705ca7d0c58a5be4d1d31418506e207f141c8c206ea4fe142346e3abc32f1987aba4e20e85189c053787f63f23192e3d3591200b15d01ff72d144c6919c9db106c209b9902e63fa5e92d9ee0e2ea4facd387bede4e34ea803edc03461feb22b359a2d79b2d2b77ab88350d30a3f3784660d253fc2de3b5f110dfdf597e11bef58e229b1c127425634ad217f8c3b871828daae8216483ef12ee6170741569b550f738c54ce31f78554d7b794c65b292c57d2c08e6edcd96a6e42dddcf50562c6f9ea38280a0e1cc91a76af93e00cd4ee246d6b8076e0f0db7990ed292edee13fcaec44db60841e89bd7209f43bfea8ded010f059508aa33a20c577bf38d7cad62ba237fcd6a1a7c7aa7dff636365ed774ed9d132acc93daf9ac5c920d8bfedc2ce6e96dcec21dfe9f672f663866714c5f1f2dd0ca7dd67e9309f779bd41a74be9c66520e67e4ccea7a45a90ca8de07203e3ce2319ea0f596131046b12b05f5ac303888cf73880ad2120efcaeb215ccf3b2776bde9b4efbbee97e5b029993ee436596868e4abe583e5e142a218710950844f7c6a79febdc299f0fef5848d15d18934c08aef2d7977a9aceb6d6add00876a521cffc41bd24fe4fc3aa02d26e577f5ec6fdbda039052d4fd43f5434fcdb4da4ef7cec50d1c5b76bb843d377965d1a992f5d3a2f2533ac605ea233e7ef1a213a990b594599c90abbe4f00734e807a1467f98ff98f3cb511b344ce46f2614e4b4fcfaeb561e83ec6b20f4c66e3d5861555c56de3f39b015f00f785232b05624efd82ff0d67a9952145be51d61d36230c2bc83e179814bcf3316e7eca303a81a435d7ed46e61e34fdae58bc7ae42908e5eb130804641fd61895598143eb5162032ee4099f1c9807bc1f5f6da9f56abc9447dd529e1e87dcd8a02bf302050db91a1c20066c1dfc79b02357490dfc67a7a72eff0c57c1ec8dd00c9be7f0c629f10227e61fcf0744f0cfed4b14bad1c2f3d17f79f9dd7141c10b9023468e51d0b8d8c0f9175e9afe98e71b475e2fdad341a901ebb0913a4e9c287f84fee9d2235b4f53fbbac298cb8a2c26db7f1c1c242af2351d32bff32e1a3b6e404d58ddb7ea43f9f4f99235e132412c9ea6f74bf38f2b1777021332d2e12a501f101ecf143c9b76d292e3f88a130a3ba9f1b948b3c3417c89dedd787d6c854aab2a824f37b0f4bee348576aa3d2eb77189e52a48b7593b185fa0e61477cfe99b3faf64110cffb225cadac1b1e984cd78d43a3b1d577b2d1c0d205e09ae21871cbdc4d3405b262abd5770c8f80bc7225ad20173aa0518a8b358c9d5bb896b1afcbc026396e3ecf3fcb6e9ada63c71a32a077276d2fa1d64e01e513c3321c67af4cce0d54173045f71de00ad9f5bd5ee095fa5ed4784e134be8b4ad76723917262e19f918c1f3d65690a93e2d78c1c8b53c48ae16a68d5048cffd3a6233feec4c156618e5a051a7524bd1275dc0fdaa444a78231e98b19424408cdc50031ab90fe7fe2823dee7859c5bae78ceb8e71677f9b756c35fceb5abe927ad2ac8828e054f97bf611775b02a30a1df7dddcb0d5185f61d7ac42bd5921d54307f386bdd583e413a9edbf282e81f5cd1dfc1acc439b0a1599bbf87e69b51a0a8795f89869264714c0b30802032debb23788a71153d3e72eccf0129ed48a088b71e1dada070bb1357c60d1c5f130a30fb5b706477ff7a4830d16bc1d81148e6e87ca6a6ea8efdaffe62e02f8041a4b3ccff42011950b0187a2b95202cc32bf00b4c007d23ac299eb1f009ea7f6e90557669e213f55db0e77eef48b6d7864fcb7b5188f4c2c4024b10225d6805e41551b01cc426fd9552d7ab4704e5f11b5eabb9c16d65cc10908c698aa4b23d4b60b658de7341b319ec42c3b67b2437ed2783fac134e2b52f9d06bd791a852b2600a35bb90df7cc8eddeb505d14f47b091b458a1e32ae9d72389ff5dbf2ea35c66b0a3a86c2c4b9c10636c703699d7a7cd1b326451504484236034ea4cea8ff7a780e719458c026364c7457cfc9c6a62982c2b3945c2c9f13ac3a11ba4977d14be3e743fbaa96d9491845d777b7d5f0158d85eb1ddae3af3a764d29106d0d21cdcd5eaa8524da7cffd6fe448d6921a300f4b2eb0237125c31b4f72d8d3dfbfe8a39d3652349a137e0792cbddb4af5c246deb2c2bd6fd03d94476ee5ad2d54751090d57e472e752aa4f619f34478639f4f13405eb851bf742d58336958a42921cb1e4fada2fc8f2b7bc4707e7646e7772c83987dca00ae57e2d2fa602a81d590e9933a6d36716b5ce062e48fbcbbd764a8bf3d89647690443ee39e05a9931431da82ecc1d35f9f72dcd1eeded012aaebc07e457268fcc508a27f24de1d20f1d23fe5ebe9b62c10ce7b169de2ed3804e9621a3afbf3b4af9bd4ddcf68975f7d1408975a8517516db606ba6ba79e519fba52108b0caa0f9725cff8482279fe5d36cfd8edf032dbff593b4a33d4bb34fad259848df65a57e48c230fd09c429c2428e4cd76d78cedc86762d624b0c6eadb202fba0cc34526a5034a258299b9507ad50efefa3be03cf05e9876d63b5b33a6f4129e6af88eed624f7781ad556f201afeb1d75c7e819282ed0ec05fafc201784dc23d5070f36f49c55a30367ead8b9b220127941cc04b80f85a5486efc7fa1fb8384aee2330439d34487e0a7b33000d50caa376322ddb3b271d51facbcffade29b39acd0f12558239df81a704d1645ed4c26410fa8945080c74dca218df8ffa8089a82f91a36512b2368ead35d7909b255d658cce87a53744b0a0faf3a87b1f95bf12ffde7686c34ff0c1848a8dd1f685ed06ad7371a86929b4497cccf7369401a21a50809fa11e7f5d7a11815467a32e4a8cd4a34b0f2aee41081ff7c36a3b135e2571e286f0c51f0cdb78cae306800b239e9d26f930df3f3c12e3e81275668447408b706a83cbc6a64bf5401e58915104c903f2747408c886216e654aea77f06996d2cefbbe578511f5ba134a784c7a56fe1b1843dacc26c5f1b734fb10562917fb461b4ed99f6d114aecda1778b16db50f5d83cf73d940b0c4c6314761add85e640456f55f2c509a7b9e85c7dc35e5a73578c38fe48ffa1adf7bc4ee0d0317bf6d2353ffaf6f6b1300ee53e61d7f51178dc16c63e784ba080b7018c27597e2e8d229d8377eac078113234f9528edcce79628ccdcca4e4d6915e0a2aab018a026f60ac7fb532c398635e6f103dcf4e4b6b4c0f1d1eea304274ea9c9c109250fce5fb878b90ac6429fa984f2ce8f4a4417b1d953d449c92b350b56bdf17e9d5c2a3742a91e52b452caf444613f8adc879637a88cf3e5502b36263ad86d43c83c76cd8797de2fbc931164cb8cfa889dc879567ef47d5f28f6217b9f14e83d4337d112783aed78a3cc0e858e5e8f3b1fa46404941a4868f7990e6c026cc988c68e961de2ad065af7078ead5b2172c7fccd0d995f5e6248ce0cde5e5e31dbf2b66e1fa7d5385cd322fee971ebe363451574bb4f7e2b0a5624921d3a8ab8bf7d8848c590938f4a38d53b9a2e86e9f64296ff80c82c9a12812651d4eca4dc50e1f08aec580e330fafb83eb081b8dadd3dd6fc1e874f76f6ca55f657e791377b07ea1cfba6fa0f8db67802aecf17a8f72cff33f5750bef43c7757a7fa0851c758f844661c56fbf529a18b835be165196f8883cae5eee701822cb68b50fa2a7404b8af14622180b3f019aa18fbae90053fc83152b72a76cf118aa3e7c31a37440c2f06b02cff1965261f34be8717b33de8ab38cbcc44f0c2dfb54bef0889bce46ae1b1639049fd2778656a1765771d49e66787ee7ce421934b02a4fb799c06aef7eefa66d9846944c10c78d6e23408a9f498b38c8eb86946c3225c58a6d470044d5b3efca8c04ff42f20030c250509f3d5f8789a8dcc5c3c20da8295411514fa409c6492d81ea96c1f4aed0389d323b49c944478344d5b4cce49e5f4c16e768aaa41b18c83c90a44432f119508ee4ddca1c0356ff2ccf794aebebbc2911084a4ce794064829344ae59c3349b1e8244f6ee1637ae380ba9f0b6d26f3c41cc41bcc421ff1fdd56bec14745455c139d873a7133580238fc3a11047a9e1f15369aa20dda79c717364d0cdd31a43f84d7dbb01a40b806e8f045b156bf12a8258c0e55f13deabb658b311f423fd2139bab117aff8ad4d9516deb88f5f4ca788d0587c5df1c5790180b65124a6376b5955c6af57674e5937a2df2f94bbd60efee4e5e31fbc1ac4440685c2b7ee32bd63bb63c25fc0958de31340b5ffafca74d8c1aa600668814f14af6f6f57633a2de7ca3e6755c17df4412ce63ebd7a1e6e8018f7dd7a218befa36011e512c182a9d124dd22fca0fb2cea15010cfbf472fd4f9eb3a9d2c6879c7da4ef9a90978025e9b3697e78857afb41db3038aa05529e708dfe64916928817427abc098c88e8af41f9915720d267f1eef3e5bb12bbd09ff22d8bb99d0f1296e3dc050ed0ee5a60a5a9ecc9ec904d6e9a36637d1f80b8ed41ddfb5f7f77e40d65cd78a1c72de944a152f200ebde239beb02db858921a14b7441db2d88c937cf49da537bdd58f54764898c1b7e10be03eb3ccc36b32c82bfae0e35ff572feb4e73f5d584e6bae9185aee2f044a3d625f6ab27a1cea5c5b9cc3eb8462a3f4c3abc24ae23c63bc6cf4b460747c863fed3a77d56f4ddceb320882f50af3bbd49e5ee535672b6a0c076bad333e21bf6cd825570bd93992292ff56889effc96c5683b17442fdcecbba791c5d1f26ea241a69aab2b5b76e2a7ddf72a3efdb4bff868a70573e0f703e2c92e6ae6e82f92a0c2023d1c546bc05bd6a09dd159f7bdb973f6d6d358cf2525d495cd628f12f39bc258d426a40e2e323079316a6fb059bafb7ba4d037044b22d4a57a83b1fe7f59b2869dd6d880b8bbced053444d86f8ef15f8f31d4267bde2ab5f33b107196f6b065525ed294c7d6c819daa0ffb81937e0f4a776156107a9f670c1692f558c4a9fa3cce648c0f73110a943c6bf47ffcc8f136c20f64448bcfdb05f53f6966cf18394c1793a438a1f7e87629ac0cd51b8a8ce9f53771f56117e2c15db5aa36d609fa8857e6015fbb51080670e1fb0541a3af1b0db0cf7fe78ddbf0c28c0f1daffcf9b7342ed39991d170dd89d7541f3445cd919a5cda1191550725b26db0237abdc470d7544381d13c0812bc4887a5f3ca314e744344186e0ce19da03a7a773358f8517ab43c3336bf866f583036ca93e6128286d6f456d235e172ab369821be09e2656dc1ad13d899925b2e0437ba738b92ff77b425a9000a4e5f16ec8f3f3e76a5264e4b4a5ade7e757146437bcb74c8139ceeb75dfcae9ce737b2dece592f584cfa404b0911693615c629c47fada51f58f14e1d7ce3126cc866330b627a0ab0b046d5fe6673baedc030d9956426a53395429a2cc319d52ce9af67a044afe1dd5b65c7e86eb25eef5742970cbff2f0fac17b4186f88c7de23ff2c530631e35569db4bcdbbb8971ccf9ee1bbaefefd78095daf5141c4998d5d26f5c5a0cbfccfccf2561be769f3971dd53f17d7e4f1355d2b74006db8acf6c464a020e3a21afb1acb591e67fb12d0886ff3a425f47920c51c09fb932183062397d3778b3379bff0a797edf0af5ecc5886cd88d227d4c803931abb30a7817bd66b52219b43b8f2a61d678478f7dda57426be6cc9fe31f0e2fb4cdf8678346a3a485938fba5b9e25c297743a91aea09b1960bfd1585e30e664f0da9236704b95c04ff1d311e22cfd24faa6feeaca0b96e88566c606eeccdcc319f7feea017a604f744f22256fa6d14cd93b00b07320c894dbfef79532e8b6563eb6bc96bbc3e090c111eec17fa66f31e5a91454cae69946d293ef964e3db2f687c9cc18466e7f7de4acdc13d5cd6517421041abc01d06c342c16e7247d054f912ae3cf04fad70a14ba6ee709b6cd3ccb27db885267521414b8ba7af91a814cd2333729edd89a6f691133b3d830d1d6c76b50ecf8b694e1f3d96de6aab4802a0cdf311fbdea8fdd3ac794a25eb159128e0e7e61c99a51fec64ef9331ec56346b8559190b39f6c7c71f9cc7ee4eb533c28a0e5c026e5d53504cb2b31dfb9410b1d12b7e99dc3b61a1aa05b9133219f56442dea26abf78213d9f2546c4bac6674761b2ab556ce4ab41bbf82e8234491425234540c2f694f513201c94070f1ce5fbc4c15bc5542d748c81ccaabfe9373bb4c9fd1ee6adf4496f30464f3edddaeb0f00dc5b6f393610242407d80264c0021b77e6f89f55eff84f86c02df71b3ec411f3b2c8d4306c0abee1f2bfeb7e5eb119a89239da02a321ab95403b1990da2a8796f6127a3e41f7773f52733148c56d68855454976a9225baba4cdb5514c9fc6388e1ece65827d14f321083987d15b9af9d012f4d8b02a54bca24935006ae52c2e2e411b3a742f1888ea29d97c6587787ac929c387fe36677a0065df0f642c4e2f804b7a2d895cb1351a2841f5895a548d2e0fa489a448eacacd9048abdc5e81c463e4386f2380b0c8436ac72b4ac8843451abe440a7f71545f84076bbe419d4c5a0552735b3e9dd627396bfa100ba4e7a97ca5b2914eb438c286f7b7bed30adcfa70cc963403da0aa9c165fff8e8e2f7dfa9c210366627d43e01a2533b92a3fb9ce1c15dc21f2f2d8f799b17cc693f7ca2c35d86b21ae5974b4c1b6eac2c2ca76b9bac6903bd5ac1fcd949dc4e38eb414760d842833b52c8361eab629fd65b11183c13dc55e841622e3bcf883ad396c852880f4a1bf70850a3f9fcb12f8b757a0452fef17b2f4d079e28dac16b9bea645134fbc55c16cfc374beba66e770ed867d3a6653a59eb0b8285c6ea049540c9f57c1eba3d0a4c52849e60037841f58491ceecd178ee860ce358eb71421d52402900f43070fa45dee09994b07a77ab3b1ed06b2b73c2b5039826c2e161097d7a2c1bbe707a84a04cb48a9faf9719a28601fab2e0a940ba3469e2d61f2ed9bfb29f63cb0e38e63bad40d19e5f406f00908e23f217c049ae6b1414f8cb5ba0078bb01551ae28d309d24ccf34ba3aee21e4a0ca817f95cefcc39d48b8c444d6ba76fc25e75886ab8dfd2a0604a040e213042b175aae9979e4be8209f0bbdf3a31f5651409679ec163e176d438358c8718c8148a9c14fbbdf9a9c9353adb6516399c667d98f82e9db8ec2435fd4de38228929363077c9336a455275e7578589591f2a7ce57fdcaa2cdeabcba04ebf3a16c5066688218b4d89f1bb5f244dad8c66f1aed926fcd868377f1d9c203c61397c44f9f70972833217a35f1a58e0c84cffc4b9780eb516f5fa29f498732eeb4f342dee515f5255d0c19630366ffc44437d31f4fd53dbd8d93c9ab6443cf7421fdadbd59eaed85ab5b33e17fb28657cdd486a99c90b8d379c280c27a1d9a295017ff6582dcf6096366d5af22e2d5baabbd196278ce13c4bcc4ebb46be55967e469e717f4cf2aa07b74de283d21e59c29ce85e21edaec8f86d444f7c70255f0aa1348bf94fdc6d3736d80e6cf8e6f876ad0366eb19043047876586f121edcda25b9b8a5aa61aecdf176c5f98ae373147a068e4d6d52fb4183570a93fd29bd8df97a02f51e59e6e453f908712e7bb5323cdf60f883105cd62496cfd6bd72cfcc4c69a4099e921abf9262782e056e3b7a71ea7510defc946377b3316ccb426ad56d5952957fa3170117ea980e74a5d09041b40a2c530031d9e3b64d50ad7dec8a4e9b7191a0e3508f648ac25ed77b859efd0c50702063a83c70e554aaa74a35b3a96c9d0199ae5a5ebd5f9fa328852bd20c66ebfba702d201efcb0d7a678a2b43e32f2386f7cb70d31d9db0af2693d9f534597421c30669f390415296055c37bbf55c88be6c8befb43453c909fae46c13b123f771314890ab9b768efbfa66c793feda007c1015dbaa385790a38fb70229c8da7697ee80489c4619466ae0f8cab93bf1f7c32a89594fbdb103e023197eedd56364ff78eefca700198d551347371b8c468ca22ace33cfe91fefe9b7f708a5f7c52a555345f649a0968d219a4d8643c57611cdb456571ab35b795a6bdf8a05cf3fa5cc4ab4e74e401e05b2e1d53508709d8d14f4bc58a4fb11992ff4c2332b0da8a63c4c3d631dcb5dc6482e294445bed53aa895cbebb4baa79a12af75f89cb7037109d2d8628e762935b4d9d3b9a9cb1707281b706c488d319cee01340e6159e93edf34b0c155b2c5cdcdb8a71d947b0b16876c1d5780524b12d70ab47221923cbc3c693abffa4a1c9a4842ddfefe85613fbed358cfa3b5cf453ed5bd6160b50989cdf32d8060c3b8becf50cc6b7d85038c4ecc861ab0c7c9ce7b8f37e0bc6bcdbb941e0a8ede2626ef749a367b4718f4bb93509022790a5d20a37ae7354788405ae7b87053e9d58ef76e3787c6566608bfe68ea4f6598fcafca98eea6be583d4e336eca89f4a0f4d3328d2bbea929ebc3f90302e47750b2cfade0c04d3c75069c7abef6a28ea3771159d5ae5070e3d45168b9c0eeb8503f807b07a777eed7769e98fa48305262321a30a574f44512ca7d116e0545e3f71e4e1c0be13c3b8b265248965f633bbdd19f5ec2b6648b91311341a27f13c3e84479d515a73bf93727dc3a39202103ebd8bba4df565c1e264e8b555ee58c88860a822f5f83ad0a4085e072da4d9e322b6feb462cbb4e126fafc006659ab699ffccbac97d04c1a935f66a55dcee152563aeb377c8c8cdb27581e719656a8271d812c49d58b7c025b798945d47f18e965223aae4386416b6de4dd9d837ab832e8cb735fa0b84cb53223de04e044879a3863ec164a98044b11a3a1c98dbd565cf2f8432438f5a3a27e9166f39ad9c4385792c182e6a978bf7b4d4b711b85689a891253256f5535fcd5d57e95d4742bfbc47ad295648dd40a30d49fc3aba27386384ba1c041ba8c3917618d65cc95c4ff6744bb0b83aa93f6a89d4b21b9322de036635ba9bc154d958c03054ebcdee9c401f01e30420ae9514514d8a36b858f086a1bcd6933d53390201d843133c641afb7290467029e416a445527931b7b8086f5d7a1dac6ebe16ca2efe0633f290e882bb4c9a4f2db2398d21213efa3fe14835bd493ac3b3740b01a453f2c6908bafb23ee36f2ce0aa4b325fb9bea8487a94d2d8b94e4203992a72fdcdf487df93217c5347befeed67599a936af6bd6cd5ad74b336b58465eefe2994c366a2718e2d15824c54ba40a5dab3ccfe78c0a1ae536b874c034834ee8b2a855f6b55c7f0782a7f9784de983604d7c12da1c80da9325f4b69077ccfe92afd6c835419695d265e095f34e5fc1ab692141671ee568b682f2aa08779b7f15346e82749cdbb5d01a12e7353b9da07ced6c1d5048692902cf97f2e159a4c10ce03d2258469dff322633b7ca17ce27d448a42abd85c06d65b2ca07709adccad9165d762d335f57fb71ba23b7779f74e2f19dafbb73f5c5117514c5af89d115f57e00cacd4d33e257c6c73f4c04802a4fe05dcebee60ba9ef86d131d6ca4e15e5825e8a5af003865356dca23efc2dfa9013c2420c63739f40f8f1730dd454165ad2a3f35d6cae38893523e67eb2951c800b3f9a9ca64959f0014a0949745ffa3ee0f7b74387ed27b7dc4952ec0a00db304cacf65e1c6d5af87a72aa5c48fc83436591d2c8f81304e6a5e83f21fe907eece020ae00695f2645623979cb45b12f82dadaf8f5ed96f757537bec461b1641d0d5df5951e4f715bf5ba25c173233d36800a75b748668159a87e9c51404251933ba54261c16e640742b77acb22aec7cf85875aa90572248e24c9f6eddee897b74262076d73f0425643d688e181ed24dc6acc68a0ceaff0b5b8c35fcd123066c3f31342adcd179f5181ebda6fa518d47e48481f5f23ba97d1d98aa32727f5e779ef90021eef3adbb0d0095fee4daee48feb2662c003acd8761a42abe76f6b970761fb1bebfff09b4db3ab7413325b7b284c79539d24d8c39db4868ad600c500c1f477690c2048c904cc5f3b5b472ac6eb39b212b03cbb28f530085ae3f5b67b1d99ce55c0744298bbac1138ee6550153a1c9b47c8282c33a4aad89d02e11a41dd849643328b700729aee597a3e340b1c49304661ff31d22bd5136fcb7d6fa6b35d01a44c37875d17a734939899cd4876aa73dddef90f2ef20159b6107b4bf98e47782fce759289cfe81bb72586adb8d2b67a67ee1c42dc33b48b9126598f50b7f0e706c325ec6fe6be531893c8b97fffbaef9a11d869e2ca5b1b9c0fb8b7170df98c4cdb225a0f37242e25e12ea9dfbe5bc2ec10cb136151e45c23c1f15750c9ee2801c50dd7bc4ea321b8617f887dd608a694d37a467e26ef06ffe96693c0aa3b7fd02fbe1336c6d147f8431236f850ff91a183f2f91f36c0b5f98bafa6712a00dbedcd5fef83bab5ddc98b6fe6ceeb90401e706899760d456ac929c15c7e51b88a00e41602ad8f2bc7ce561da097eb6bb0455fba8857064508988bd297310a9f5b203a491738673d0af790a4c085d00ba6c7429999679318d81b5c03cd7406c625e27fb0ad7ef46050a17ab47540a550291d80889615f73c06402094888e95c14174752b75cf98bb674ba2374309e27702ed3e69ba64efb8215d4bc9e53003990bcb6bdbd860f1dfc2d2331f81321e5743806f263887208e9f01726a16d8596564dded7b6f1341f3f644bfa3dce509c6bd467b3ab2484862564add2ce078a2a933f1a40a890460cc3f40d9bcd23a6a9a886bd133c248842204cb003f1d7ffbf8dff7c9c5a8f01a69f8e3369b389d11767f79c111740535a2c90695983c1c21f0d7fab53f04662c0a26512703b5830eecc10f564fcab5471ea87858a9bce540e10a9863c606c73961eeba8c7f45768a2f32a621b637f4f01c0a2cb97eb4c332d26f8ef3a5ce1c7e7f1b07b787b6641394f7612f9f253922593ae5e87e4e2f71967f5a86ddaeb90c9f99fec1dc2e4d49a4fef9891c6f254448e9d91d6648c16adfb6e2fcb5adabd573fc0d5995a3322a7974ab0aa2e79cff4facf90149721007171534724a06ffd56cfa950289616376494c3e6228d1b01ff179c692fd32e078b9a34e807aa6d01d31edcb540e880fe7ddbf198e71665ad6032ebdf371039fb7ace701a2eeb13096af522ab6498c2f31b4c7682b0a5305eea00a4ef526f1343ac570d943cffdd4b04b4c718b9cb3ba0e20a24e5adf37eab17a3265523a1e22cd404d19568f959b6b0c2137f51e9a2dc8a6552b23c5283997372d83e62a41ed9d8195ca71b337dd5136bc087f70b160f82627f08f152f14f1d769655ec722e2d5bce1d7e2ced78f65642a1a6296baae841b2184eba4c759394fb43e25861f205ea1cd3929081a391a071d873d104e6b036e9538d9a3623fb840c37f90dbabf8a6347b33c356dcb0cb2b6c2366c658a90ada944d36ace4bb943eae2f8c01c99d8c440f9f5254aab35a9291db2ff7985121d87686f72126c2970172d4490a9520b3d6344a6feb4945d96129a5d2d221894c6456ce7445744b2ccf6eebb305bbbff3ee9562b8662de3704078ffcc07db6773b994ecd4d0103266aae6f1a777fe85b5df65f2f6620287ec2de203e61b02ff124851498bbeaddb19fc83fd385bb3384b18d86c63ef2779904373063110a5affcc3f6c119e3f4b34e15d1e47c754396b00ea74a60b72ef3296758c6b47828d11822ad8d88580277964ec0f7a5c8ade4407390b63b695e928012642e98e2c2a767c4e6314656e84b138e24486b8e01d04056d449caad319a938b8ca5f61d00abbadfd48661f42aaf36ad3582013fe6985548b8d8ececd6064d4d6befbdc2401ce05beecb4f85412d838e105526d0159343c8044f53cbb06f94ebbf9c371237ed3a0c6eccb0a519eddab2346b0086dbf38d81879c0ec6d5b9eb70ea0b20296bf60024d513c3dd930a25c505f3d5659bf0d1f891b1c3908f9aff0e72f96c50ba7d993665327ab404c153e24cb7db984a2df743778b91e3dfe9d5fe81a0251dd20cd6e9a5116960b465155bb5c79ed3f17a8f551251fc35f5c48398656beef9b697ffbce158f2d66132ba4b4fb1ca242fe6ff33407f6f7cb98095fd11342aa73ff3f1eca8e170d6b9df18ae10474e64b4154d2e6225295e466c922c9b14d338999bbf8a4c3c4aace30f7c784ffa20dac7f8a4c1dd31a081696346f7bcc76c1bc2ca974f65441de4f788e2f348c32a9ac1c5ff6b99ceb77d2631bb205399b2b30edfe8954fc57ec1813f1cb39c9910819048721985cd51b634c20bdbe2e6e23ea511f924a72ef66102318e7bce7ce7b335810b33102512eb7c277bf80f30cab3047d6f29d1582ca96f0ea7ffc60c100346925797b27c65879d68796625b7ef86787387ca75597ea5b0b64e8252b2bc966dffe1ed61c91cd36b2680f490b1855ea625e848fe6766ef2281da59a057e4d9e73b51d81cfa2ffb6c0df1fb6508fff406995a791ad26ca2165850d0c6b0a3ae0589f57c64b4798a5a186039d7a86ca363eed7ba3d0093f250a3020e3b144f95ae24e5c7be207e52a3a2f30ac364044f5cf8a93c1d8a6a0d8802cf925ae3b695dbc7ff8832c78ef4ec4ac452256373bfe7219886375b4aeaecd78941e68260681a757346cf7bdd338aa5666fa120deb5c9a45aba49e753e99ca2602881e3b5930d979c34255b50f907bf0818fbffaf761e10cef2d66e3aa52d293d00339a6defe86e5b45c9d6287aa36ecd6c9f6a9cdad71ea17aa553fe27277473d4ea88ad46f5d238aad4d1cf42d0784f371a81736537de7651427d0ec787984463f416aa9f133df47564cd58ffb581762a9e5bac535624b79b7ccd81473e52008f86f9c305332955431a258ebbadcf07ec82dac6099e568726e5a45a8faf6ecfa6398c6691dac359e89b5b98fcc5dd9cd5c006e7d25180a51e567706153507716587b928cfa3e81c461077928641bee9a576024c6600b91f7668708b729b8b74435273f295ba700d37a56d9dd8174d7dce6589843d15db213afb2716fea29cba215ebb28d261d150760da2446a723265a57501835f4b8a5347b366d90d7eb64660d23b22ca6f0a6b1cfc6f457d30b55f852f1bf3e6308a806076fa719959abab2cbb6f66e6cbe485f6acc80be7655d85d241027334aa6485a8ef9a403fcfed9c32895b7916f680f18e59df758dd66694ecfe1d926f6f60bae50ede6b5071ab6ee091d535817f35b836c5e5b0727f034853dc61b7b38bc756c2863c7c6a42b78e20895ef84d8cbd5fc1b5d840140e6e65a4f42d5108de7d86724e26c4513d4440c00e8a1cfa57b731ed715c859165cc68a685bff00d9be72bc621270634cc6f24bb21f78edcaf72a5a348a94d861ce2fb457131331ccb1f88b1fe1a0b37529c594aa6d8752f730fc5560a884dc6fc92a047be0c9a66c87e43c5a8721a3ba39b3be5e40d32361beca7c18c5e852e853539721669b5a0c27090e32688860587a90e5908cb3adc2f645c3b284cef9169b55822479d41843d9c62bd4403bf9b3b361fbca1d19577cddeda9c3a56035f0f868489c47f1a8e9158f447114e9b73ef8020482539ee2f272ddc73a4a4e4fb1165d25723372641697414685f19cf414802d4166bc78be90339addd4ace49ffbeec8b319d9a9940454cf68547f1ba9be0a643532fd9ac7939035aee9735725c98f6c11d9222389df8307e99a2e10a56c1d918b192da045839f2c9f9f774ba50d7cdf90d026971c32a1e4484902ad585ee5edae2974f61f78270a76d5bdba161e5315eba143a7e92d7c0c63bf5042b4edbfd1a57a76cb76d2cdb2c2cb8f85202e0281e519334df46cdcd885bf7764d30effbe2bb0e3f1c1a5fc03081873a01881ca2e3e26bfade0c32a812348238f8680967dea67c656985da6d0bdc4798adec9ee88b0931f1f941fd571251c4a77401f82f1a48845890d06dcf2f72f74f2480a2e58b0199924da678d013beb1cd669f02155a3c2043dea17f9d91cf9cb2450f1533aa51fd4c7101c5868b06807286ca5e5c516b2b6bb2a888db3223c100ec391bfef827ddf35a0855582d0b2b42b653ba5e485de529697d98a672c7f25600a88ab939c659c030a472c1c94bf3002bc5b5e1f89a73747dd9cf53f71e40aa908e6ea014b3b9e12a14b6632b32dbcf94476642ab795df422e2e3de4d60c0d4f87d8308cee8e69de6c692dcae3f28817c34d36fde2c0fb0da859da898530cb270c2be8463e5ee01cd31c9eb8ebce7fc46a27bb504165843c4bb5b85e756c04b91b8c5d73a5383226f5ff2e91ead67b59092cd551f12eda7adc9901b1337fe15a35772b6ccfc7decf967f98e6d5ebb2bd30faff442f4e78d23944092358ceb3bc7db545af5e0548523899e080ad139848673f8d14e7341440462858f1a522ffc4dea2de4d488a63b341df460e5a5fd2a3142f5d360905b31576b0c8740667915ccc2758e6933b7070d43e3348af667881787e861d0e27adb6a019858456ef942c10fd5af4d06ec9b4da3a8ba24af98c57d5d840eba4545817b1c7e3ed86ae4c8e1b1ae8d43364f05fc6050181596faa0ad617312661a494264a1280c8be4f410557190fe78050fdc4fee400a062ab5523218d09613b277d71cc093bc1c31e5567bd8c3dcac88fc038330b0d9c1e43a81fcf5adcff278a1db0562d05017c9f9640c9cc148a05f0ffdc9172ba33f3ebc4560988ee6572b00a445bd86feda067560a1dcb9bb7df0e0c3d59210eda200b2401fe8ecb470b5b1a8b7c86eae70f122a6fb3d0eea1f412e42818f148e271b57bef056b44e075d337d307ad6cabde6cdb69a48d675623c5b4f8c8cbee333272aeb3923c55c1b7cea58186f1f5ef311c73373ca5c71e60ced40861aea580b406e18e89176475c62a02f9edd3f81529c65ebd8f39fb1f4390f0b4a8c473cdba2ab109f5a0d31ceeaff590573401aa06f81f5edbdd1f0675e0df1ad01d9e61bca2b7cad1649c023f218cecf11bfeae132f7df28c0d8c0c8a4dcc548e97732805c7e55795fd9ba9621dee7c6386eee3ee329ebc3fad04d05af8fbc6e104e40ed54f76d566de26f4971acc1243a92091d0c7c56274486f06e33e3c8c75a5c8f343e2c02f9737df27a5cbb1c60508507d62ad9bca0f7ff90e763b48f2145f5628a3a795ef6ad36241801add95c0c35e99d3b2d81f93befd8682786e75e694279f2d37e9305058e8f734b0501038fa38374c6e94abeb843364f49fde8a653bd111d409d3af2887a122edeac5b7e7e666e3c04829249d998ad1205658f351bb7436ed77d4a7373e3589a9d6e9ba8ad264251ddf23de3ccc17c57c02be96f5bd3a429fc8afb574b242725a57b1360fa21273794354d874b448d805861d81d5c883ffc9372bcbcd58f748cf4e600cdfda9b33de8cd9625c7ddb62d243e63eb71a2d95e83a9363ae8e855ef512963d7c7a31a305d3f946c19fbd14fac9c9493e2c18a8a4fe66240dbe8b700b5a0644f0509aa6c1e943e71ee3e9abc2b78ec56e2d8a2f928a4ad0f50bbe9e60e09538a9e6999fda4d9fac524ff606c1776609f92afe0ae25a22b023a83f791690a28761265288de19f96d21bc88fcb4c5becf34362f8bc5f63de169fd3d49228aba16590310d4f2c7b547f71d7fac90691b29d9fe169c801af08f14f3457bdacd8ea1619183339a687088500a0039265a6aca0c76ea77d081093bdeba3001fbbe0d3b6bdf8c82508e044f408488b1128cdebe9ed218c35a55680b0e0119a14cff99ae269c19fb8152696c54c2bb5be315b69d55d672242bb14720cbee29d88eeb944ea83f9d8210bffcf84925679429a4b676d757fba9de6203de6186f72a4ae9e84d5143be51766936969700d07f34fbb600596fc50f6d7178e167984747ed68835ed17b3d2a25b11ea6d7a47f747c96d8a12a646454f97d69d0b40e2d18e743a62cb07a4eb9225296538ee2d4fb2dc47e363581860b36b02f66c3fbe33f54adcdd33bde2a4bc139107e6bf9f528299d3d41b0f032ab1bb8145c3c14039d92d7b6c373a58dc53f681b30b7bae26c5e7c0630ddbea919b37ff44961b05c26f4e887b630a8467000836ad7dc3234444c85ff05eca85e3c8036babb2779e086f74556a0077f6f185f77257b061f7b9104926879473de0d4a6677328a750f8dfbd69c62a0ecd52b1912faffc3aed93f44a631c1636cd639d4b01babdf5c50cf579df7c080955948bcd817bc8de4ab18e299bc34f325a1b0d6bc1222311ecfd9e00e680d805a52cc3c7c16552f4e05c50191aa75677a4612f7545b149213ed9b2121d383aa32a0acacd4c8441096b185ad5701a6df1120dc6d54b9b3e7797c1407627f2c9fe7b8bc706a02c249762dae1ed06c9643a75f3ffd19343bb9e6484c7f339a844f3b266d3e101eddd7e02cc74175b776851f88477c29965306938b200dedb2b6dba905daa25e79ac214d1581acbb57163958f150307cef87d52f76dd1abf3c638dd88829ed1af388aa3883766fdfe0b4a28c46cf6e0d12ca6c1dafa8152310f93221753a9634725afe10c3be6d508c629f32076441a61507664acdbb9b3aeb9d5d8fa5a27f8d5ff42aad595024babbf0083b074506c8d5cb11b4de6e47bfeba6431386fda332278258357b330b976d7277b3eff246db70f9d97de312e10b17a149a4998a1204bb0353d79484fa5aca4c82e1b83f3f75c98996d94e9c0157d5e9738bf41b500c10da16efc3463d839bd7e21135a5ce9b076406878a1d706e72d74214c05477f0a063b25a59063c46ce8d1a8087ebcd6c1641de847311c4219e71bb70bc37b2f3e8a80e895f4be92ff5cd7eeda61f037324a01faada751612edb99eb3b805e701e81871730ddc59b3c72accb8dfd92d4025cba94202b6cbcb578411621b6cb216a655c81954cf329d9e4ba38951d4e59850eb36762665c0e6b8df36445e03091fab10164a566fd75df85c91ed6fd1459ca02d3735f1c86268510e7fca8f1d1a2584f78773e8eb8055f710869681d29cd655f73ba3043483ca450ead93cfe44d2f42b0110617dda9a7e12fd944229e9f1b702ae57a7330e5d81db2d45dd4c978bcfbe59967a095779ea0b841c9c396d4593a7a82b3487adb0e4549d3f268429e3047650cd876450b52429160f527e13356bdcfdac4ffc9783d8cd8046fe8d7dcd6c348e3b53fece41a7ac7c0c3e5da356449becb41086f1f0aa8e23797c5855d569135f974d81bc2511d616f7aeae0c9bbf107b32649ba7944b0c021d106686099d6a7b641cd8aa202a7bc8c0df465ef030c32d4249938252aa08ad5b7c5b9c02e3b4fecbae176dc83b48179911859eb05b4292c6846bd9a6dd88fff33ae238a1f6d7bec648cd76a558721811e3cdc53424af864d1903c1d3d9d5fe775835a790b9e98b5787860df4786e723229d4a6c4ef087db612c76b99597617a2d9a0d822001bc3f7a0454a2adbb9962bc4b8f8b750d78e9a3c16fa0e551fee0e25d25b42a51403f91c1256a4455a9ad71a8cb8617cd01e52d6ebf6660bd576060c9511a8b4b72eef7f7ec149825f3592ced4d5aa29fec88fa43a6f26ead918ab4f0e86b5d2f4db0f321a74ddb2210bd42a6d78ad2b592b635c3fa22545baaff717715ac7543479eb36c4aa795e53553f93034f91a87f5c34868e37876e2e2407818551028502e53213da817122da790c2421f22b250e2c7651f614ebec2b758bf2147c8fe23148528a81ffc2b5db44050617b04c88f26968dc8a9631f60695956f4ca809a0d4b403af91f12f4f94b94646ad827d588d45d10b752cdb38314f402856ebcfb6472d5d82f7b0daa2d1b42330c4a7dc8c1971bd5364b8dc5d95aaab6df2c5b5c0093ccc97c88b6b2463e5a0d4b8e14178519524801a760c3709b5c5c9f7ceb91be4b6f23c716ba853681af04ff83df556475baaec8388c643dbb365777ae9eaa010ebccb2a2f95091430f82d53f1fd12b1bddebcb0fcb12e987d3d6aad9bfa172c6ad42673a746779a77082b469a4b190390d0c0d252f927be6cfea599a4a243296c38a3a784b0aaa555c8b02da72a26b4b96d5fbb0914bf4e5224682affd1dbe507618a7b2dd3b7b919c7ce2f5bc45e65ece4e2eb38ead9cd3ff26e6255617ed1958bfcda6c4cb87b758ed8c71a3a7f78826c5c56ebf68a2227e780d5b371aa635fc8466244c407341d17f346c280d395535d67e6999f241a030c2f2ec8160a933b9ed2e68e319155f800734f4ce08626992330f6751041e58faec6ab6f9a365e3bd5c6ed722062ede1706a59c851bcdae2b77dd88367dc97938a9d9c95331347663a1131a5647435f9b5ff31a1352f251b92e0518538cea8b6a381e7614abbd1866ef9227be1810582186875331cd1bf9b48d618b4b3c675ec513c87b7a3ca0607128d61cd51c15c5574ac1ab49af621524da55a4cf972bc6b42c609030e77f3dcdf2d45aa399edbe180afe666662a0bf47af039e7639324376f000d59698c2987894a59d86bd94abce847f62430ab0144648648a5d39db3354f84cbe424dd3e1966d3dc28cd0213c092a23a33faedc96597bc112944fd56dbc0638ba68b224a58464c3f9a3fe8c2bfbe8bf468e23bee4247bb8f61371f5c61717f2c827a996be7ff74ab4adf688bc5d7af3da69aa740ff0c7ab424bf46fb8ec2709e9d59e141848162793afb16c4e31d5f809a0924527db3d2e4992f8cca1171e2680f73c47253828ab7de7336669589e1fddacd7afbf23efb7874c48745667d9923dd009a273d1eb4aa8369f090ae8af247499d3ed68da2ec3dfec2e44d50195efc498ce38d59f1f7467f640804dd848ec7c9ba9ac127d6b7f2f1e281a5e39b6a367578a0566d84fab83361faa8b82bd6364afc0d620b3e8fcd2508d3761cbe04a648d29335761c54dde1692c0764206e27181bb59dc89656f70597efcb07a26b35b7bf6165473fa9c84ba8c9cebc726b7b8748c51f19d7df0bdfed17167c6653624b28fb23367f4f402719f04f1ce88feae8403dd7d4b9979bf8cc83aa6149bdbd0571472fd65f7a3f604b1501a8295381d056a077f6e148ab7fb7fa3e8b9a196d8b655d50c665d4742bd5e9fd313cf81eac30c4f7afcac83441970e701e0147aba4a8e5cd8ca318c2e8688e83a9e3b8f6a93257138ff5d5a3342dd0408cd530450b4672f48355b9bfd5b3a0731bd4e210efcecac8b1082b57d6187c911992841c893fb096d65ee036907081d542d29cc81d36badb0acfce265280eeabf79b34a6662f59898cb91ea568573852a925ec4d2c22bb52b64cf5d87da3a2bcece6446c295ab425a72bf0c084d685b857fe7c228bb5c3f85d595aaba3e3a2528c35ac8da2c947c84dd3d0ecd1bb057916b0a2a19ba8f5ddad72dacd1c0a15e2fff7ea3a4d4b13520a5c02c4c73ac12c3ee5fe73763facd4d8b832e5bbd7fd455f0b5738fd6b50a915ef4698faf7310b182b411902c21ff42c473d8b07276e3699db0161ddca3b37b430c8e97d048374ce797a675970ce18b85ab3cc442b8bd5eba98c23be5ddd67a2dc18ef16f3cf69ed999203822d205ffcf87aa75196ca26edf934ffb3801e2b91d3bf133f713d0f738987ea725a67acb408ca924faf4a932367e10b06ebbd79b2ab0375f60d0a32704241ec6a9b7627a90ef5f51da465662e65fd716ce3dac95516be67661821c03885ee2b978180ba930094ada49f7e507eac80ee9e4de29994acd6ef53c04c4a248811a00953db9414e0c38bee6e8ee59d559554336ba1e90ef5a44962e2df86deae9d96ff6a90aab60fb0d313bf241d0ae5ed08cc6923c0b7b4e163252a93cf47abc92d78ec533104943abef43d6ad59ac902849618c8a5b1dcff6004745ca3e5a983d81ac19e25abb28ef8c3272f4c7b0f1dd6195fb3263ba7bd16ec983a24e36bc7df6d1e2ac6b1a1a522610b39a6b2494a1f554f4e54abb57e90d10d4b98a17070de5c0bf916bb38495183cfd16d3cf413162eed13457e41888c040102e9d89084440fa0715c5bd6ec8db342110bb1d01a832f054d9171b288fd51df082648ad5dd50efac4a37cebc85317c079507eff84c497acafd6b02bec8af66a1a00f6528b29be1e0a3bd3de01140bb347f2afd7834bb744103512e25f0d61ce2e4e0177bf2b1f46fd37623a47b48c03430848bf141d9f1b73d2624d8e16c5546d8901ac9b9ae9474aee0f55440b76b5f88f278686541f04d757c3868e667db2a451f772be8bf124a67b4aea6f67874402e686053b9f157f02711466b9743e077ee6cc8902e5dde6c03dbc51440842876751fe0593bd0b507652733097eb18043aaf66597ce32e5046571049aea3922237791eaef0062697692ec6e9602a4cdf8ab743e563969416b931c7818ce04bd828e998fb42e261ca5cbe589b20c3e8ff082baedec36195a1f1f51a656edc703a7c93f8089b4f242862c08821d4fc428bd3dd7bbd787b84876e13f4bf5ca84f8d4d4aea21e25f187db37482521651353e29c45e00c570c84272bded485bc86be2494615e8e5b75d578e200d90baf0323c297ac5f681a171d91e6c6a327eb438b602a3830a96120701998e6716773b2abe76bc4bb6bebf20715d59b83ae35aa49a20e19a517dbce8db4389349a324a37cb2deeba1d71543d09650546ec999a71b85b65a4013618b7f8b3637707ca66266572959a07b73a7cd520b1e6ff8ac9623170f7e5d5d71b7503c572a0732b8fc6d2e6da500e0821b6f28be72613bb2f34ad3b434a1624ce32df998fa99473f70bf2800ed383a20e0e7055efb024d989669bd058998982cf1b8b0495424f538502bc8920e67e70d667e6c45ac188e587d9f3922b4146b8d0d52ac7e80d2e635390640d29ef1f9ca72e18e57cab47e24f36806115aea39f172f4c51ebecd3323108c0a5e1536f0c806b536fe96d18eaf829f8655133ce0efd1cc425895cbbd21f8cd853266b770eb42b90cfff5669bf10707a657f83bf886f0abd86ade1d44ed73fdd107cfd7b806c3785de5cb928e117ad2c5224b99d4a7076d05ec985d610404bd5d9885571ef21182d9c64b03f7702190c6e28efc2c595e2459f53634e69fcacc03c94e01439266f754abcf4f0f4b8f938865669ef9c8711d1744442ca8edbdc10d90f5f496f1c9c12c5d2c08d2398ed46addf4c68c9859569c59744a63a663ea3d80aa598eb7bb3b1d852c53264f2055c62d7e804a3dfae1563d0a254ab5563a721bbeafcbb10c502a9b22d7f5b89b12842b78e6c247c7ac2407278303c191e1be5feac53d4797255eaa7b477e618770236dafa06eb557083bf88a02df35364c638cf1d1cbaabd5c1d0aec8072cc97fab94004d6120f831d3db1da2f75c5b01e19ed12463b26db7171c84c0d2dabff190cfcd9009b106a9af9bc4ac51d0ba18ccb8caeffed3da150e95ae1f47278e1a8a164bd622f3b575ab9f10a5c9b9b07889e524137cc2e3fa6ca5f2ea25eabd6962d364da33254ead4e221d4110e1afbcda376e3a5e40cba22b72dc0cf0534b3bb8fd693ff2fbb0e86002063588b1dd3f3203d9689639a9f2bc033bcaeb052772fa0e8e550ccccba2f6ad6c6fde6f96dfdf39bcc95061e93e0496a146b405b7e28ecd6b7333bb26e75be5f665bdeee88d23fa11117c00cb61ac1ee61885ec528d6b3d7cdee8c95a503656cb71edc416b40ff3f56bac1ce321db75a5efb3e7c6a8acc3a243cf7595567800193c743f166565bd2c013cb197e87a52bd450a9cd37cf1f1a1bf822a18eeff2f923a854a1360d4df9a01cb4ea4c89478d126f1c1ad0c8a7da07739b5b975fa96ea3b5554ebe248f9cb4881179ad4740dc903a15c7e91bf9dabc1ae7562f567be5a0423bdb14c31776c8db3b85bc592024f97c7c2e1c4c16b34dd1a1590ac579320fa06c02c90e550cf21ceb4a0f078ed53da554b68fb02e68e3b3922d5f0b750fde15be057769a7c6b44a70a748f237088086855180f0de871589f0f565cd366b5abd2cfdfb08a355a009b09b754928ae4b4798ee81919bf7922e6b74d4cd54a934e8371a8bc3fb6da9d12ec9c5386cb24ee57ce4600f402a7f367b988afef49e2b58c16499424bdcda259a42b36a65b4573839c91cbf901de1995b1e824fc9475bd15518b32cc0c3863e221c0c3824b0cf8f4769fd4315e67ef209ee369b2ba203ec1c2ede4951cc7215c378ab735627f79753e39bed5706e8389700319ceaf3c2ae71b236e995948c03c340de794e76aa2fcc09b3fcda882d2bb2e65b8bd5527ba241993f804ab2c00a036a0b8338adc3fc736f5bee85f198fd6d13b18b529c2a815add6d8566809539e34f0e9ac8ea7c517abecbbe491097a4d724a013d67f17f48ac3d201d931a3b7dbe7ba6eeeae3e2d2b5190a8077114bef366d339a721ef5bf414aff24f1bd3b5b8516ee82cd6b266a9f89db2e474e2990ea10b4a5d0b755932a32f84397f45939c4684b0e565eb3c6043b9b3444c6b35a12b56cf04aac03803762e12490e52c84c36cda7ef19f052655a5972ed4e19909dd73194c20f2017edbf7b7c28d5a7e7ed1f39ea5e156c61a10307d598aeac38b497287134b0291a99e44427bff427b2f34202b34f56eb0237eb7a01bf7920bd5717023ccf75adb13255082e3792e74b6cbea95585a14858aba0c1a9e916e84ddfc3fd8fa3ffbb14c1955f8c718d52d26569dc171c33e107d4973ae7e4074541159443d461ee958b7b243b5026790c1498859f295ca223d9221258be4dd821cb386fa14405aaf63fcbf3a3d1163de0df57892b4e59dba3a2d04cfcf8192d7f0f2e76d1b70dbd8a12a16133a946ae2b6c22e8e13e58347b0703c10e94b0a98e1bbc2c0247a6c771b5905d8fd2232e0b6617aea1f55b4cb01b460febaf4544c137adea78b7978a01ddcfb48d51c72c37ed4a916c647578da4ac7ea29b6ebb61675beeedefebb5ec565fd1542a629c9aa6430bd4f467399983bd2e771d05f3a5b4cc46f044c503f903774ba5761fc2172e46a8bd13b0e93e741e67efa9d4ddcd8f35b3203087f6e82b7a4d130614cc0f4dc11cbcc908828ebacd8beeebaa77f1a3341f84b775b4ddecb7cd2f89fe4afcd3c1ee90138a51e19d7d244d0a9aa50e9bde2c344043c983d8591aba7719717e1cf1564faa58fc520df0d558b2c85d8396c1bfe0dccd8a856085302c43d138d58987fbdeb9596a405472b851f248049437affa47ecc78116538ee82e591e586999deb979e7360bcfde6ae9ebe3ffe8eb378f2cc107660a6a674c8220f62c634383043d31a86c8b650e2b42cf26e8891192bcaeb6416c0a3bdae5ac94c73c6c916af3c969e75c132d1e77721a2b399cf939afc525b4342b451aa17dd15ee281261e4e5c59fd9f8e97177659dd4b3de67665f42a1e5f897fc9848fe9517314a8f768c4e88bf50d47d6d6fb5b9cb9e0a2c064b70548576bde0e32233e43f5ae4b9ff2805c61253a54601f5fa3d034437ff40a5dbd5c442185dbd101c509f055bbdcaf42bb8d125bfd72c04da46598d64191a6f33fa72f27c4ff97a637bb3ce2e30fe3039096a9d8308ac950093c34d4d1fb89790c8ca2d993ca38a5e7a304c269c0ac50be5ac4faa1ebcef220aaf712a5fb233c8f0015f6ee91f59f88bf13f73b182cafa4870072f21c3eba3bf86b88913da8d1240dac4aba2db9425943fb9ce8662fbb6a20e6b48a69c269fae17efe9ed0476f664f482fd27c44d5001404214e9b74d747fe5d6b6961b93869161dc8bcaaf99d387ae4a18fdf6a36d74df195bfcd7996894c78623f56b7f5e8bd9c7e2e22d38f73d24320b8bb5e5275be92cd55b7dd3c230a83c2a2e01b4553eef7111a74f097e2b1f09854f80d665c682722f23850ff998c7081015ab66d7b35d7b5e041ed86c6048b0d5d858ea13a0290196bd012de33f88d4b40647a6529136c75d30cededfccf66c07fd29afbd377514c7626094069cb895ca05f4410f17d1b7863bd338a6ca57a078c541e48de66673a268459afbb55ca029cf4ade2d35bf84025224e5b5d309e1e3204d2e32fa1e6f73d599d593e3814c7e68df25a6f0a0e73dd69ca25f1af1893dae0e88678ae6fdb2fb6a1354fed8072a3dbe30197db7ae454a8806407737f225169cc105c49719857d2b7f0393fc56c2f4eeee59c925a0ae1566bea7561e426e024e95e2fe03a6fe3869505c0cdc72c98a02dc237e7800765cf0fb7a57354ea42198b80c716df5cebd2c59ecb8c87b5ec4b9143ea0804e80ed376bf5137a67b8657cad9c340e6746856a926e5445259220e111e0b1597d33b07b5ad5b4e98de896e87077cebd0ce19da06a75d0e4b3d316cf1e311a3b440bd7203d968ee3fb14ff3779642546ab1e7c62b5a82dc4057622c18d1983a9972300268f83f61c7a0bc0043dffdeeeae500aa9c0f98f1d4df85da70fc97d70dcc3805ee51ae847c47afb1ad9930e0ea5cc1b85546cf65f172ee4561a1ba6b02c134b06e6811492f4e97a8d7f86b84248f6c459b1edca28f589aff4d735359f870749ce9698035e0ead2898762cdea0644e94c5a855feaceafe9e02e2d61fc3c3410436de0f6e2be16237f87139a5218a8f7ea183bd9ce5a769d8433cf481ff4a53c878f67d07e781578b5114343b628ddcde376986cb821a6a0c8773c6783f2f4602c76685b4bd62731de4c971d3e546ea21c3e325c625be34950c82a605c688543596f1e471dac83abaed8fcdec9d5516f1f03bfc25ddf74590477961cd45b2d581b1a6637df16eba55f6a33866ba962239a55e0b98ccb80f48f3f2cbf87f3959ae31e19d70e0b7d8f2d79a1a7e9fe7b8be080b1d1a67ac743df3b5b7106918b660378f8573c339951dafa403b3f7ca07766dc3d76b7ca5629a8e800d054bb466f344a676d8e1ef1852b30b7ef1a50d70347ac40a29fb3efb5e139e1ea6cd9f74d124d78753fbf20536881e9b65f14a977c191d008912d18a445bf5c3eb9bc1f1f9ec30fb21b39685be06aa1b8a28066e2b68bd8b196671324d2d816cb9bfb7e4dbc041c2a0500614263791118b0eca2752c8780df084e3ab14efb7d73e91ba6f8b39326097146c84fc6564d0105a38ca2cd7fe7f417616e7ebd0468136a8d705cb0c8bf19eabbb89e63e6064456030d2a6830d10047dba044eca0345a5b74f43d420987458d9bed19967122590975daa26e532981f027a8e3eabd274cec43b1a9df90d1db8c0ae93e41e4f310b829e67376737eeebda9dd528910ee73c328073e5ec931beadc6174349193750b2afcfe4b94bd6a02ed13dd4e1a87d39774341d47c336178c9244cbf163715327a5448b196b87da91683043ace96c48716b3bc9957df4eb74d5f2a77171cc99d4657907f0f38b64f1dcfff536d9ed7e69f6ff691f5745489bc34602b3cdbb4de81eb77b54bfa62f83ef61247a3fc927489f48909beccd34f2ad6c1a67a48fa15490b8e6a128217634ac1a3a6963bdfb13bbb6ab9fe17bf50c325a65f4b95e86cf21967a154d529516427eca431170cef9185e2386599cd6442451c182bfdd0c781562585a23daadd84446a94a571f33d5e781ee486ed5e557a74d4e01c821459311ead23b3986207f49fe841e357d634e405558c5be34e1bd13fd6c323b97cdcf2fe2e00e1383f30d6c2d863221626795da8ce1dbfe43b56c0fe5d25c8a63173e599f1e4a955c39f9b1efa785f5cabfd766c5be7f3ee010254a27b9a9aabde10e155858e2f0c6b688d4387f5d872bd1bcf4bff551a1b6ca6b0d34c8ea980d82af1e1cb25b7ef1c6a4667638b907e7b337c57dfc6bcb65efb8962ec8f0a4456e2d4877d012d2a0d8e373b02afcfd5394b87b2b98847ecfb41a803718c57950f337c4e16d39e2cb4c2221304389f64953a6b5c724589fb84616c5f95892cc2d1c78fec5436bdefbab0a15bc0215021df499acb7ed33702fa2c4570e3aeab02def6e98ab5955fc4fe9b9d6038fdf490d1d2f9573ade6a54ba143a317d8cf9c5221018579279ffb30e66d7632c9be45bc25b5f756deb1d65a7ed649cdc97bf0ea297dfe5d3a23b71c43162034dd239f2c1da19be9103b03e8c6571f924c8a9df963eb3655bc555d8dab926f0c20a53405b4a69cd9ca9688bcb32227cdf14eab72b6e41a19051b3ffa3065ff486655673e57d02ea5bdeec2d960bcd323d5bb71fd4fee6d1bd7f5fd840d11d4a44eba8cd992f8e80aaa2ca692cf7db4438d7c7449b47354223bb875efc8cc241bf2b758bdf96286e0dcbf09beb994b812eefdaa6f90875c0ec9dfe59acc18738fa1b2bd77f71e21a7dfe33832ab32e3dcf892fd403d721e172eab9ae391cf6de92cefecdb34e41646869cb182622298276870c36048f66117251543db25c71cf11d765943e17bc573a05d5f8806df68c4f4139edd114a87921608b538613aa7426c69b7a054240bdec53d05a17f7e39bd82185be760cfdaf53a4c1acd3f1294009321f31d8e0af717116209a29bc510da283400ff684b03a0bf07c02e04aca307e2b340d5bb55c91fcd38f4e1fc036ce6204bff14691c0e22ca9e62c25473ca931d5625d45ca907279ffc7f464069c18bc63dc41d39c5ed6393d4ed3903383966910f3cd65a10970b427d926264e1f8246d674d10de1739b3b24a5acd94976e644d777dd1ee3768303e6b964e698735ac26ee7a4f1c117d24b5902500c49414e03ea40614da0fcaf772ebf6c3ae3dc5985e09a3f7cff1bc761d21e95b137e5600feae719cba3b43ce13b2724245db59f7f677800759a80d64f4cd98430b3b3f5c4dac557ff042abf3091920fd3ddea0072136d8e1303fe9d1ab3b3d94d42d5de2d457baf2f29e0f5fe70835bcb447da62f0dea5457a87eff138a5310eb3ac5ef2ee96bbe82a5c97245bbe374b5f804fc04ae64102247a0f363fa040867edd453dffb3cffe6ffce1592587e3158ba29ee9d6ad56a6768362ce999333342f2a534047059ae4f214c573f3984887f90297905a43aa80356c7869b8ff357e8a8afb0eaaa73bef96794627b7608dbd1a75687986a13630b6e0d4fda7579e0c130be211a55fbdcaaac6a00285284ccd59f951f0620e558a6247751503e9fbbee6772b398aba9861c3a8751dda954abaae4e1e3b6aebb46c734a8bd576665cd4cc5be49bcd3f82b05aa175999f036693563c6df35bea1d55278f6d807fe6cefab356ab7c138a76571d73c57e6e9d023c41be6a674e5289787a0ec80565f7981517e9244a4e739395f9a89f381302a3d6ad578c3045de611b98fc87df7f5f8892d092685ef32766dcdcc8737cf093004977ac474a01cf2ddaf65fea4e32376666369687f85a5e8eeb02d33599d2631eda875a8bd9ca06cd14068b3cbb121260c0859702293705f4482127e550db9635a7fba16c31ecdf33cedd142892bb55ed8376bab0c2d0e6e13557ccc5aa0b65cf44c08937a2e862d389e38bbc9c7bb17f1e52f58a24ec7ebb4ab117603b9349a922c55baa8009d43feccae5f30f5d1703507110a74352972d978b24860198dfdb33a43b72f12a4625aaaf9254a5ed32abefac229f5523be33d01d803d3275f488735f5cdadee143b2417373990918b2dee51bc70824e74e06f8fb6dcb80492a383e596d16bbcf383cc7f16773ab7b103135acb70b8d10150a22b23fbe4ba321c91d073ac9be7c574f9ec57f4e13e355895098a0c1a19f4df91c993fdea146921c1f984dce686424a33db9c76f3aef480b93223fb0683437b799e2c7339e1c40797aff4f34c539cc7a0abb6f7f1ff32f1ef1d964a029773d81691b16104afd487e0aa3517524da6b0d3bf8626892d83c4b5ed67d7483fccedbef55ec0ff4d4e3b1e00f1817d695d4ea59234e56fe76c38056e7cd7b72ebf75820821fce99a10257ca53cfe27de92ee2260f6cc1a8cc02f5631a25003ad147062d75d76e662ed295a8f42719aec8b618a2ee9a53ed76bb02e1d38a03c43e89f948e8903a867798e64a5be4f7c3f6d7d564a7dee22eea36343c834f4a802530bd858096b6bce17823c1280219238319a5b87cc5ac4b36418284cc2d2e75fde7ed9457debc1831593b0af6805ccc7b915f4d8c750c78e9840906c939069dc7f08a8e865b32b5ef03685913b2ea4a547d03c138a6a3a0bb7721f3611da35f8ea7c39a03e698209d543cdf0e960cd0a42b061e745f828024ce8c976823002267cf0febb91a53305f677d2f9f375313fc31efa6c357bfd30a4ffc4b1586598bbdc4189ee3f734b3f9df08d3ee1da3f9acf8775caa92ab46acfbb0771e0218d18c58c3dc030d44e16c1b5b0cfca128cce75dc97ced970ddcc43405b16ad60467defb619f4e53ce6cb742c3c3e6f32bc9a5813068d566b70a2b05afb8d3af2514c63e68810f81558b2c3a2aa074f63c7394ba4e24f1d6f6ddefaf6c68469f90bb0bd05487e563bd39e65c7a72ede64842cbb0c7a7016815058f0a70004ad6d95de01455aef417f896a422f5902ee0688369b4dffe870dd5334fa229f94fa9b1a76c8970d005c259a8ce9d2365610ae53a8646c58b1b2718221fac22d4cd0a269ab5a330f44d365cc16fa8c73acdbd6d3508df2fa38865f9a5789053d65eef5d84463149031a7ed199ff69ef514a68b2eb0816cd88f457fbf7e030c6345b4dc7d9b6479799c3b5d09e0272bdfc282f0e145cceb5a1004dafdea221fcc126bf2b21c1066b1b3f7c9d81900bca69a0cbb32149485719c5f309cd576275b3b2aa8ee05f1216fb2783b787ee8bdbf3aceb3eab205d2acbfb2733e7ea7335a8f6cc1e95499b59fb7f42f543281fdd240e638678b8b6f6b48594ad85d4ff3bad1ded41526a5725a75c616f0ab233287cddcbbf717f37f162a998f6fd52b40e7df6ace63fb756b65aabed3507ce673d9887d418c40be256eba69d1ae028b9221d3046d5aa57cf6c997c44137ca78bc05a9efe4b32ee90be69bc3d347a4278875bd49c57cc8453079e482aa2a0aeb6dffbd3352eb325ede11e75b0b2638176438e491bf0039427700a15a5153bde1cb7943a54c3b952acf2165ad2471bd098c199ab295d5a671ee4d5d9aea2441be7e803b1c28276b48136fedfa7c5fc4dd0bc31a4e58fa53abfc8482031dd9f90012a053d150ebcc7a64183886a7d8b5760d0a0a3a6a24cf3dcde262fc06ba6187769e5635c10b044b7faeb78eeae77cd666af783704b6ec03cfb2b169b83cc74f7fc3ec828d328daea4f04bccc1fefbb60cb090f1b10478da3753550eb5ebc31b66b1ecef595e073f1999df015907f84299254bfad1ef56977a49c57c7721b6a146cdbe09e0606a36a73943f416476319cab6d14618c71940d4666619eb92c7fc9f3795f66ead1e931b28d7890f11327902986d7f0c813143c4fc9669f1a94ab2d6547a0b6577d0e0c67ad6178d48234fc81b26518a4146e48e215defddaf78f2b2e57765bb201824fe1455ea90b326e244d370d1413068e1b804e91df9c7dab1e1af58fa7af851509bc342e44a1d4b06c63e95ee359f14948d535d8701bae7d771b6c6e340493f807b6905ada1485e113f0ea6d93e8149769dad8f40a58ca0065702c87dbdb74ae3fe3b7c41b1b2a847c7f13151863021013b29b39b0af0356eebfadb4f37f189f28a0f7ee648256f1a15fa0db60f85b04ffee71ec74a7800b76a4e3b9e08aad60908b4246b6919245d0a89dbdd2b3b21ce40bba291efa7554b736afcee1fec98f265617761cae9728926d22ba902aa4282a2d81b927cca03328b841ec57bb51c471234467455d58e4511eb627d0fca0a28869e3b34e49e7e399932bd51b4e68cd685b94849aad16fa3146cbce4a38bc1719368b2b811d2066b6a93eee17281ed5ab68cd16e9c2de7fa9da013c1617dd0383574300b5e49569c2e070e5ef336afe3a302a9acb003b6d3bf4751b0c0c270511bd5ee6c1d3d9b7df97775458946b650cce6e0afa17c0f10afe4a07b8d5ab100b779b2561323ccb04332e72f1aacee1ab747b371dee1306b489fcfac66b58fc9c13f7ba1f7689e4e694d2a049f9ec7706d53bee90a80f96a88b476af3f9c1c63b51851f9f6fea9bc29a49bc1a55e305efb432f947c59ac161177d335e166e72e503ee1d932b283df2a5db5f0cf54f050f35bae14bda84520a9df6ef3668229741777ddd83e57d8827203cf8c518074cbe8f21dc70c330eb1baadf621bf476cf9d06a4fcea4c4d248ee2e987f77356c81f5917e5fdd6a56b5d317eaae2e22a3530607527f5f9d5691edbc0f951c2ccf6a37208ad255628356250cfc62cc05f46689f3e2cb61ebd990a598f92433de26934e1fd8a0d08dd74d06014dce0436a822ec16be040e8ae73dad13158d4236358ce0f79c465c56a1dd7155de46165cff76062b75fabf6094d381ce95fde28d5274165656023b7cb9898541e1d095eddee07161358b416d71660231a10740fc1c721e96f65c65497b1b0257c35ae9e297ac0e18edf0539ec470f372d2d39ff45260a74061de0394a018cf911a51cebd3c3e7f9dc3d52c7e124a7d3407e5d434f32568974a21f590ab9776f8d230d4df4143ac051541f2ac4235aca6f6d1c903fcdf9931cc094e76c847a6cc3f68dd3062ae3f0e64c3432be90fef43556efabf639377a8403ad2ed5095b14bf289a11502c42813f4e3b0747eb49c188772fbbd2497c55338027f575b0f0bff778e2db68a4a1913fdb63d6a90d0699b22cff0767647461699eb01dcff95d19c62a45f9477270ac4abafe30c3647f415c67f13078edc443a3bba3c4f3d643f783bd86c72104fb6b75f350f0850373d9d01df31fc7f700c5e952ac6e2a7bb398244b05b8909f21d90d93f200c6064279a57332d741d59707049fc69a84bd3c3d928b2880f844100444b42ecf80010fae1956b7c8be6fb43bda4dda6e46cae89ecfeaa220f29f768737cf93bd84949e45e09c7a81b6c2be009659d2d3110ab58273e7cac8c580c20cc74454ba8a55673484e74cec9baeea4c154a0676f74eba3368a2280fda6b0367e5e134bf6e9251cecbe071f65a94c703290f8ec8ae838ffd675a5470e239d7ec09280e048b69db805c3086295245628d985a40d0ca7a1a7359fa182b91d570f6502cca25a664202a881bb70d9d13336be036c4b7aa1def8e0c72805ae6ed2c47d6c5fa02421e01ab5b7bab7d5a36c07e2e389dd8e6581f648cac576056f28bc101536d8b8ced204e7b4ebb8f239f48db929d12f378605c6cf8e8cd24a24c6dadced2ac0ecfe132a68c1d48a4b25d1bbbaa2445d673224326a6240e9d05589452e6344c0d30a6ed6fb6d6454ec6c540cf95b28bcbce33328d050c5dd5886c1e9c23ee8b509fb12b9b690c6d660ebecfdd17e6c52f04ef13b3d6443a7080ceff5be52fe70cdfc5c6747f0f9e1925f9a8fa966f1591900ca21c1ec9c92b1c0675bb1de6c35eb6fadd8cedf77daf84ae5c6b6018dc0bf4ca43320311bbe6604be54a8e0053d77d736e9484d653c14f7092ce0cee9aabe852bf0432b7f9e630ce4d955c4f0345837fdd984047313403cb64ea80a50ecf692da7a3b32f67a42b88a2b4422d8bba1a87fcdad28c981cfe3523e2add2993d1625a17ccb3ccee8267284b1a81a7e7be2e4d4c6326183c7cbf520f269b9b5c92d74cb1915f1b6960896982f04a71c06c173ec361a02f0e25d06a5d1d6cd93b7a1c4857af6515aff8e089dbb46829c3846f2a02bb184a54dc15e8c27fe7fbd5b98c99ba0fab1058c2b73aa49f353d619756bdbc9e58928046e39062e77af505349662b03515db4f537847f1b7bcb57e563b740bb3d8459748cea06065abf25b1042c5b59c4f7253776b1f1968727df2cf4af0ebfcab3db406987766de83df981d4d2165a9acbd799691c83722dc960b789c7fbb58af958332a6842277c2043304fad5032a047ca86bd284aa14d88d0a04e52abf82ff9fc7a9e7d1c31097afd7480798f666b1311b0bfd9f95ee7631a114baa3a0aff750d4643e5280d5049fe21e732e46c31285e338527260b499b07bb0b026eab43ad615b5c8c011d53882e80af75323ed2c22630f93a035a4c587b48ee0c38cc1881987d3a36f34b1672b2f55658e5f9e53f0d2f5cd07842ae04a5d3196875ca663863cbf01de295a043b304c5208efecf91ebce663907fe6c439facf3dac91aec387da6bac4e37db61ef1c57b3dc6d2b0c51820600599ebee7ba0312d15547085fd9194050e12537127555d85dcf995975f8d5897b471d05754b66995156febc45f649e427e2c154948cf0df8f20d424b2c53fece71279aca130035d1a221b3ad4a4c960e31c5dfb229a3aaeec04a37893e99a763947f78b1d3a2fd3116a66693ede918ce4004ddfb63c3006974e329f92c996154c981db4d93132ec06c98b593516a9cb2a4e6abe8d59055053ffcef158b138803c1737d39429c9dcc29099766935b01d88d3928cc821a08bdbce6a195dfe55ae4f82d3a9dfb2a4b8990a8652eb6f567cf97f25b0f2f71b13cf2b1bdfb73c1b9fe2f4458f8b32e9dc836ea8fdac7ee2893caa8a4e8443452de8e09c8c92ae896f1cb22406b5ecaf2a0a6b3defa5a9ac8ffcfaa8a8b13021706153cbdcd0c1f2c05ca2cb60dc1a84118f57e47d5b7ea4cc30d76d87191365f3b4422a7cd8097f6fa060d975be59e869be1122e8cf04ca1386814bb824a2fc521f0d5f19986da9985662b164df00d01f2e16dfec19c3b3baed6ab699288e858190bfb405305cc2f15fd9fb69f98124ad799be6f326e60bd8ab53a7b79efdd16af4a29765de046d6e326d21c4c1c24064625668c669740dd27eef1c78035a6866fd8b1bf110c122375bcdd3a7b57f778abe1479d777850d3dbab895d72d74057adaed7644be19acefd86c8444e12a8b42418c921cd717ef096f7f99353270166c839381c06813aa4d086bead8d265374765910e767e44ac04fb0a2f3122193da684ee3bfb6cb611ff1ccc82d72b2aa575046aada7ca3dd4a299d565953b35d1e7741d46c07d1ba8e060a8091b82f0f827661613e1e9bd0722d082cd5558335ec87e2769a16f9e8a84b3e6042b83a9c45fce3a4ad6ff467bf6ce32fb9ab112200aa86d0c17b63ba808046c39908b2991c0d7ca3c6884dd7989223e08df47b68cbcc0fdbf303487453dbf66343924bb5b5a22b73add9eb3e0474d36121a82edc82e2446b3d5421d781b6c82c3ee17e9154421a578a97f92a1002541bafed55b2eb2b5a43f950ee9ad8bf05c7ad81235210611288ec7faac41930d06a4468b11cd2cc36e5c07af1d247c388c3011fe5bd9d46009f8a0e4ec5aee6a6dfa0eec17e87bb75a2abd9949714739e0804b89fd0a9b18ee9786f3ba1a5ee463ea44746b75a6c6a769c1527efa6a8b52498694f874d4050e2fb927b7c22a53ac2322d2de9edffdfa01a97c207c8d14422fd16b924b38b9c0e701fcd52887768c5cb9c929445961ac7a33aa9687d57b2e1821078bb9339f5bccdae0dc35cfc6c9ce924df777e6012a847b93b7fd8f6224af34c0945934bd3b4d27c446681602fdb4585e1eff6d342a71b7908a97269b70e4883042bec2dddcc07ca72f52064cbcd2938351d62c55a1b6897ca76066d8fd695d2961ea6c358fdcfa8604180dfb7ceb77ef78acc8c0d26ee15f4538168ff537c9f7e5d780cab33db4125bf4db6c574ac09f9b6232ed5fd76a89d152dd03da07df66fef2962967e4a6fc82b4357c083a9c0db48f58ccebd28ff2bab679bf54dae131a09aec3029b444dd183a0d72a58eab3e0dfea9e2c3670814f8c046e3617289d8eaa68efc5ff68bf020faf38b781a0b49cd2e68bb033ffb8baf9f131856d6560701dc533d8bd6af2df67fd8716537719c22d1c9a4d228ae3756d749117ad2f805927ba7849ce3507ba8e6143506435aa2214dedddae95c6a287bf63de9b74c0dd27b2234f309345023b61cdb26a1f4587c03e9ba0341b1aeed704b3840391252a7326fcd752bdf2e091b59e7305afff3e87f2d8b072f60e90e024779bad3e5bc5397038ff121d34c1c4bc9c62da5e03167aeb4a5ca9828c90d3f443e48b57f4c2419dbecc64d3d412fae4a0f57497e1617d61671344c17b22f31bb819d1fb976a8eac2d5abce497ece4afe8a0844dc022f1be7806f9dcd7bc6594836efa0dc6248913882d59b8d0d57d3104b03f74e6a78b2070703d9a4e150130be765eb5ab8b3c3bae4e719a8bfa949514ded58558898ada8779a8ea709ed0128e7586dd07129cffa8a14a3b468c6a985a474dfe848829f3b5db715f736b4e311e497cb51ff2ee31c44fd8303851900c158e1de0002aefa5eeb2f4af7e9b7fd9e46e8430c356d9167949a16f2ba4f557af4cbe2f541ac7df3623023490ae672a3ada708561f02ae5282b8cd6e46625f13f2f2776d6af12c486beda6bea6590983e97d6ae2d688e4ba70eaca41ca96bea564ef1409b1bd02a7cd4d8771512b6691174f5ec526371e9941351fe0606cf611ca562a06e1bb91cdd15319e6f70023a572a0e41390801d589a86e6b6cfa870ebfbc2daae13ec259ea35b2cb4d7aa27b10c338f4d937e31510dfe05952b5e6b932e718f76611b4d28173170bacc7edeebf2e8a1124ed68276e543996332566c03ea311257fbbaf2f113455106e67c82ce14b7de67074527c417983d7c8430195dc036a55f5ec504b581a42b12f4f6220afd52088086de2f8e841df3461e2bd3ee6341fac2b22c7b4fb422268a5c4f9893af5804cb6c6e874bf89e8aaca78c6d4147711d27796b02ce790e5d28c62d07cd06e204e6d2da33c26b3a098cab85a044f2d07768f75b92a80335d332d9b14e1b0a51aedfc94cc925f4ef74226e8549147d52dc7041e025aa8d047ef67da1bf114f0b44dd5d6f92939d11d523b4300d06b058dfcd286171990fcd61259a9ebbe85f5bad3db936daa86a9895228ea822a22ca88cefa19d9fa58e93bc98775baab8211ffad4fcce1326c34e732851a2c9d58fc21f92e96ff438878dce7a6ddc2f077f4bc48bedf61d2786447c8abb78d3c636b1cbf90c9187049180d61e5a57e1705fd69d807e7330e9120814b906366aa2af493647c37b4af80168fd2ceb520829303b4d3739afc5fa9a516d829aa07a3aadfd2b365fb2c63ad539ef8bbc1efe33c920c76d535bdb15075eeee6a011274c0226d77c47af5a29c7f0c35d381f5c101c3233fc00c07e50a9bd6f1c99f167e4959bd0311b889b7eb49c30f999850fa4f3e2371ccc0c4507b5218aa596bedb79196e1abd05835a05a300ab0108b593bd9134f93eb4b453b5f5859c57183532812653f49b2b0aa90eed417666c6cb58ab967eff1cc50c9615870a751e726b5707f8f67b9ba63006fe405ca244e1f63bded2d0b195263af7487e9d144d5f8db3f288deb5d81710b5573e1da00984eca001a6e8960133b8097f62b24f5f4e598dca3ab57997cbb33125fbf8cb3cc7fd553a0c9c35bf40188e5d3982ba0862c67a0d04f0e585e58d1aa5aca911c00e12a0a073e7266c8305ee97b4772e6c948747922e831858046d9d13a73e7bd57b4a94baf5d1d2007acb9245469ff4a06c86e68416a2493614f2073f827793c1b7b6c93db78f1ed9012338b755efdb42344fc03f87564f6302ec32f83f8a0e45442b2320671e2738370230627c51cf2d209bdf47177b9a86b4b53d66313082102b33bca87308d1d1ec8a1f2270e2b32462b5277ca62b1a5889f3ff12e44fc08d4c7dad48d00299bb622bea0ca5fda8a7901f1e0eae26b6fb58e9139c7dd0acc7f4a2e1b61372860bd1b7dd4ded1e7710b5ead13b915908aa2cf7d1d70ba944a9f7ac43efcf8dc23d217c3466c4ca443a5efc90a962f130160af793fb03b1a7e21802a32f203945fe89952243d9363c0f39a0c532ca027df49447df70374310c4b8bc0bea4c41cd27b683d8f38487c8d2fca4a8f8e9245b70462dbcf5fe473b846c484feca28a301d574ac198dee52b135f51ff5a5e2be1d8a60a005837734ee456c69e147ed14b35db6ae4dab38611a30e406ccf0e1b92b4508b90c1aa5793b31d234ab50600972056cd327102b4a16ce6edcf49085bffd3e353b0bb1e68ad1e8fc5b74e3d1470db675b098dfddd2da0cba285eaad742355b030a5c76e85b07152dc3a68d2c9619d8b719044fe706ff8f366a8f11c6a877a495b70ecd1f43d78698d18282706e6be7babac3dfb8e6ff89e103224aa860eea8caf664afb1b45f2801d09c010b979f17f9f7a36979bdbc348a5e43d5168fc6e66f2754e1d22d617d091c5b0d445f95088c7964f525a3fad91d4334d0eda5b048c68709f30b18c2b368547a713c6eee8a2c853b6703bfe06b3c72cbe2940561b2695e62130b2f0e4460448a1936a89374b65950f9aa957cad9703f27de66c129dedff70b2eddef32115ff6eb720ab2f85a2123f863b0d3cebde25266a508e02c4c0ebfcf32b24c17cae4dddb9a4c8b05a28369ba379d97543396ef9a5079aefe0295cfef18fb1f10f5c4de3922631ca75faf4678ce8b0df7e9004919469eea1786f8d27cfe2839b03a6dc604e7c38744ece4e9bdb250316792ea0267ce46860b77cb058993996fe5ca84187784f3a687822c3a51612e81b196f7687540103785d95f529fc0b1dfcfe1b45615465a9a7d7f4f1e50790a6d2d988f396e56880bcbbea5b63c37e899b3a4fd848624742f3e45a942fe9e48082e2ad53c735fef300c023fb862d8c9985ef6f3e6c36062f54022e814d5e036c58af07f9a64868cb9e112a4c440ef4e4883cc99b519f102794df3d067b3f4bf6e3494fa94e2da5e1f23dce8e04c11daa17c0d6bf4f1c593bc3eebabae93388e9991104b4f25c80d2def414ca60eb5519c8684ff911a4430cb3e8ca133d1c3923511483605769066a47553f0da70f1200d4d589c517bb159c7c6179700e4d6ab5c8f680e958fb4f949649e0875cef23819b47dc3634dae2cdfa6c76066a99aca11c6da8b961213ea337f490c7b5bd067a1d20daff10252fe64a535515512df36653435f93f5ed01191d2c16ea1c22b05081f3902ba670c20f51553d0a3738622ad5f5f3cb296689673c0909dbb20a8f28922827adc79965fc35813eca8667587aeed9b5c826c02b3e0e8154c4c74ea2e83d297e1b962b8436e196bc2d19313d8a4ed6b97aaaf12e100f131ab16321d10f1423ba1f0b56ec9d85fca1d3c3eddd4c88ab4dac888e00784185cf02c153ef0fce57d157703427d714c34cd7c6c3630296cc5b9123f73bfca9b0a7c0ce6717cbc4fd84b0e663232ac5ba67a05c612ca653c74132f7d6d784d05d98f9ae7244da76b06584e1e92b6a939721f832870f28003ddbf611f3148042318f6938cf55770471c51fa86a6506bd2574cbe862db83c06ac3cd9248085012a8a75275a0e63fb636b9a3d6af4b4f468e6d8692b911991b420f2a2f7bda1a552474032524a389750f8ca4dc7ee95276abadc03ae22f1c7f110258b4931681a209acd339d505ac4fd0454a7cbfc46e576d89075b900b1ababc7e777c0ea20e99e9d0785a5ea676f755272c4ff2b8db394e86ee686e0e4d818537c1fb39387459c09c74615c840642553e9a41f739052ed71f3343885af3ed63de9935e582b807414b07ddf0f74fabbb728a1024b9728e3409adc68521ecf9eed75c445e2a994e321080902432fecf9fafe8d0aa266775da5cf83eb5b8a105d532b6d5c07645dada4cfef21977bcf2c1099c6950c91f40396c43eae533ad56e4e5d9ab945c75dc7d56b6ad0f7c98799c052d1773e6c81482216e8012912f93a396e41bbc0ea189e7df941f3393f06e045f9bea60f4d3577b25b5a9dbbe934a7a6a388fb26fc69b0958acdb428f4b005af49b44fe505835653b7780d207cc6969a4b6031bfcbacea7cf2f2801898bff48b7295dbcb68c1cee843f1893ac24c553114d8b9e0882641438df8076f0276419c50ec2dfe9344037a023f3aeb67496d6846ccb1a6d80a2fc0cb11304947ec78f08cdd216581418e9d1b08b674ecdf9b1e8a37d20f7af5145bb35424687d6e75d07184060a413df57ad17cc381dc76dc1a0c9efc13d263df756a924c713632623bde3944159cc14b8ec0198338734568445d382b1b05bb93b72e804811d700afda5e6aa4d3b9bfa626b824228c54e7e36f7b92cb0fca01a692785e030a5e4bea75a4f31fbf52e192b74db13a1296b8f78cb8ff74b1f1a371fa809ec7852738e2e60582ccb1cc6bbc0d56bc9ac1ae59a88173980eec367f073e30d0dd32f246f2c0d5775bfbaf470266fef13798a30930a9912793bc4e0a42f15265f53025e749ca6dc3521ead68a35266416bdf8f7d260bf2b27bfe5deb91950d8b03ae7385a3a16836e972e0ba2327a50ebf346c0939497a2e4ec2e2b175555b7025921affd72dc08718d8bac117224dd1e67e9cb77ce1c1d9e6d6d07adcc4a790d404034e1e41f7268e990c9780c792f31093fde015fef5156bec7abebaf2261ba450b56aa70fcfecd12d88238a379b617201a0f1a57b410a31e745047ffc599a956da4da4d973e9f148ab10fb34cca8b9bfc3158eb09f402ccfee04b8285432ac9846d43cf6a1077649d16c290208c6741404528d06ebd931a049a73eb409434add5c1c847016a1d546b74274810a8a997df9602ade3af503d06e475800a0623de4bb96b3167600da2e73154d644665ec77c83adf7e34aa883971238c0e38fcf46d4800a3bbc58c234158406cab3e3926586ead085bc69cb8d24333e35f2246121e614b52a70080a4f517944ccb9f4c74d540886308e5c6227b72eb69e11592ed2dbc256197dca22533a9d7ace0a826f563e4f296c8be42681ab677b1e8a76f0fef5838984fddcfc2d56f610ff5d6453f5fc339a9a1a797be0e7e2f504017a2b91d2fc260ba19626a855e523d530472da0450d1880640526febc86f5e44bc3a5b0386d94799541e62dc0cbac0eb6d7ec33e9b70820f987e5887e656f80eb0411d691d7380c54a97bfddfb0f68c950aceb3d0aebcd4251f16b5bfd17c0b47c365a5a924960005988efbb82fbc7951183b6e434e0ffec002b2e316dbd5b91e85a1fb7a9e2e253db2331ef1d59b62d20df7d013770960955073921693af2a32e2ab1966a3b2403e8dc189c1ac9ce45092d0c59fee172bbbd57bce1629db2fb3597047a3217e80a48c60c4ad8d8f01e684224815f9056559dfff664210e4c349aac444e2d891432cf3ac8e91a05be4aaa0afa8afb816af24026bfc79c03750297f1503fdb1232aa7525dd2b27691f80d749b67d40c7bc9e2399ff8ff9c667d028873a5a8e9df13fd5e92e27a3ebbf7fcf0bf6a00e19ba0f3e87343b3dea5f6af448c8ff09a8a21bec9f724f751f8c08b0f24897cc39b9ec6454f11c96d21dbbc75df626ae3cbb114710b6bb1bdc3adc547bb348f44972a7f761598d50d76798c58b726fd8a75883f59fd8bc35c6c0d3237b2f9d62987fe46150a867d3bf869f8e541f046571b5cee8250dc4399ed903978e2807f475e273316babd83d9cc621f955934d79cfb54fa1755b99913084f136ecffdd373b7fd9c2a7427d800dfb202aac987402a45ef04a4520e2962f85d6f613898844fe9e65c6dce5d00b13f75b211aaeb491195b49abf789f72915e2f5241f8e77f66d6add1f9f1cec6d5d156b0a8e887e801f795283bc1c0ddd66660061094bf023e774b3e27e069379f6b1ece42e8b6a86582aa3466c2fa7ed5c21894a27f0a68f1f30d06c35d393d0c8adc1558152fb2a8a05434a7e6e6186f9e589d9232329a4b176eae1b34a75eb31ee59b3592c30bd3e430acd7a59050313cbf792497c18426b037089e74475f852dd109f419ce7ba1644927b54c3f030b1ac670b9107352b81f6fdd0772fd72b46e799bdafd811d23908b6512754ccc562a9c269eac537d4af5369f5b78b825bb7fd7c60f04bb3e572b7a2fbf4089286dda40adc7b2b7da7e18357948470f1ff9f15a332e614b7c0c51a781819afe3d850c42e301ba17f022ad266a8cb076ff40fa7f239da859160b81f79005a6bb1b84ff5ef021d042278c3f0e6b10b0da690fd30fcbf6aa4b2011d58ccf0ac34304c1c66d536b024ca214771210e2d537ff510b3b6f348adc857e57cccbefe5720906c0931a560474b09824d32bfb64050a73f334c56dd8dd29b6ae5e87494f363d67416343b08a4a0f524607026864d59cfd639f6441b69025aa111167be17be510228813f569e977240aeb6573df8894be4354ea31c4157029e322ce2c0337ce22f39e3c69eeb68bbaf31159c9e212d48b8395565e1b9e9bb7535ea1fe6bc20cb2cd5c99d57d20cef4745b645d30a130e7a30f6e2793c1bfd169af5695aa8d2b338007e5e03f2f63642f351f0fccffc77c285d85384d71f455d0239c70a35b772960ad10821d5f6bbfac6ed63d1f88cb80791c3f345f552136a66d470b06c375d5989bb7bf3d239e10e5bc54dc4db0de3eb96cc8a6ad47c0f61f62269340b2abcb4be5a3395a5db44ff0363b05f27bc5c67f732553d7d66f53b07e5f9ab7e6b32d9ae162aeb4e8a2ac79d8e991b703631005da8d2d1bc555f3285d62649173a57f0aace9eeaa0fa5174a02f8753ff60731334ed9945b8a5157b74268b0f642ca5384a349f2621217d0a6f93ce12816117cf300fc9c61d0fe6b3d938423458da54648eb74fbcca820045065686a1cb7d5a8ca26937c4bf58769485a45b451654a05e0eb120346782fcba2d22ac43b44e6578178816fa18c48ebd3c6e3b9832c0258ffcd64d7789f4105c12feebe66ba9a9127b39ba0e4dd3f691aa80481431b436bb4003aa4b82d00e9a8511e995c2af1173b1965ec8b60537deff70888f1bdf6d012b8f4d4f3a7a94ad57101e0de3cbca519efdb8e4a46619e834ceec45d7210f4b96d9e828a87cce556aa2063a1a7217531fe550e2df0223bfc66bf9680ed73f834580ce0c7b7d133567c40fc00ba68a793136df59075df5efea8944409b72b4137f913567a1a5799944ce92d31d61868a580fb2d3c21ee492596242c30aaef162694cf412a045af4d2e17fdacef267e5ad98280fe1f008a8615ce4011d76fb2835aef286bbbc31d5fae9ed958c16f977e83685702c176f4e6947b8c41b1f35e298952e68da015aec8672da53fbe0ea9393373854137cd7abb2493447cd7da3ccf6d6a65770820d77ee7172744802365d2efb3afa75393354f2796c707aba347d49c575b18165b0b4c63ec17128c15bf9b7e8a56e561d4052b4915596b3d8d4c1e2f8409241c10aafe41699af0b7864f84ce70ce5d02aeb28766eb5936f29d40b14ccdd3bdd2353df08980b3029132e6ff0e5eb72bc1883ae9994a37bf0d59d504adf05ba7c0d097a8549722ee1950a9da75423fb5ad1ba2ba4a8990cce57beda17941bb93a729f6bdf1007e37792ae3650a7845cc7f37b6880f41345a8003ac5bb92fec0613cf74fa1ba0cf12eb56fb0c2d96e35e1518990e5e6c1bb2e73331b3445f04511c7a9ee76778741523cd321e3e77ace4d72f1199890469d5b27e2d5cc5c8841896323062f5b854ce3776c9c3c5138fec5115117f52a8971fbe9d8326b49b945bfd58d6f70def6122c4c0b10a49df917519be59f1b8c950add579c1c8ac4e43b8cd68ae5c65d174ba9b63a1629d4b0373db46f3713b50c3f4f65899ff9480042b693bef72a96658169410f3f4c03dc7c9db2e55f81472552e4dc0ba5f895c957562b2af54f302c30359045b90bbc8106d720f6bedb073c2bcdd6246f2d2c0bce9d3456d7d1319a0f92d8b06fd8923dc24d3d5a818762f4be8044418e56d6f0a9cb374d78d4866b20fa62f9f5eea15c60927bf8e501e3e84bce68604b4b1e6c6e362f669dc47e21336d0cabdee0030aff8a00d71a01beeb4ceb5b8ac007d2a8fdaa0edfa0b24fcbedd9c99354545b8b5ef028ded57749d742888896190e869184053947c42d905e92b91d7211214f8db021016b53897deeb7792f42b75b1064a2d507ba759ebd9f07a0a1f30bfb068054c1cdb1a4c679cd1e0de3962e8e0d563e1345e911ddb79ae66f850377ccae0313c584f07781ffe96eb30ca15e995b49bd65b5f7ec2941ab8e580969ecb9f864aaa44f71c49bf6a3a0456676169d9d9089438a23acba841582c203b6dc8c9a29be190e5d04ffe6e56ac9808c05febbc31e3ced403ac88c2e8dd45c859ee9ccac7b74d35de6d07f55e4463f5ff0e25fa40b137c04e167c8147a4a9309b747cccb85e06511a18e1214eaf15867639c78129ceec51d51818ef852ec38eb351c5aa2f915be4b5273160f6ea4d9605e4abb101dc1d021a3e294f4741372773e073c579eda8d2914f1a5e00e69a0e1b1481dd9ec3f92459bca7876f5507a1e181fbbf89167b5f2b18ffc3f9b9fe23f09885a01c92f7be8b9403a371c771e4260a425690540cccc2637fe016317a6c8dafe72af0c8ae9eee239bdc3f3fd3f543784495bd9459d3d50c7b2a977554846b8ca26ded002b2eca5d7499532f95345830efe5e2ee1a67d7ee1c1883e1ff6d6b96f7fb120c49f1f71070cbafe9be342a12f9cfd39e09b9accf3f96ff64b3613fde048dbb3c6eb393966940d4e950ec6204e80e6f24ce1696ae9ccef12d25e8472a28f0fe10cc8fc5f945601e56505f261a68d2b66d6144b425ed1288fff1b6b73612889ba28daa2e3142bf5352f8d42319fa68dc79381baa4d7422c9aceebd5d9d62a9e86e2ba1a216ace1fa360808aba1b35d98ed7adb3e34e7dec3e52a30795a26f6406897411b3615f07e5164c426d40a7523481cce3074e84bde948e92df41518663c7109cd3768e28997f77226ac79ee325ebc4aac09fa7c65edfcba67218f0866a56feed6074dc1752fd1082662d4fe33916446f537a931bd69bde61b871d643415a18b76271546b2da4d38a1d6e1502db65412d0b60f91e035648f9f19a41993a9adbefbfc5b22f80c96bff75a7161c006c2b5e93f9f2defaf8fae2cbf93562a85cc55d99547e919bbd56e67ab633415336269cd8e72bb5c94718e2850a50d8d4433978f844594dc8635ad3a1dbdcca6d2841df7220096d13e564fbae9af774d5f48bc66a19cfd5f5dfff346f4e4b31f7278f3b541db3c9bf65164b18cd58d21e7e370f9375f66174a544fbb79b17746d08bc3de61fdcfac28d415bc42c58f175726548f6b70f351800fe23eae7927fa1bbc974e6b6d952fb13afeed43bf81da64f17d47dc1e2b53dd30635fb1e6da3e45a92d3d749d79a396e18e96d65ca90606dbf312d74d7bfb646f994f38a8285ab3b9785fe682878fd8958967e3da138e1b87337f9a45b3007b62e5f5ad80affff16e1fda354073c233c487eb77cb0d2d75b0ae507a0a86b6da06b54ad6568f8d27cdfd0394321323fe36734cb19fabee1ece48edeb890e678f4212070f1cee58665f9ff84759e0107cb80c6ac97044c12a2eda96c503473b6f7113a3875f760a2bd3c9fa96577a545179674040ccf31a6893b0753ad590b3daf167a40a58d20a9a5df1a666c521a0efac6b9e5b0c17aebbdf0b735d322db0c21fd03c320734ff4d1dc3f5021e3ca02468532c77f3d32d09199fe3346ac709372aa23822dad255c9739b0eb25fd69b297030c2ded58f22e1221702a908eab9ffb5483d21d564e2dce10eeaff591ca5d652650e2d9b75ce64db8d39d7888593024ec057abe8a88a954a61c4ebbbe059dbd2298c6845f42112e6124094516e8b77381adbd787df0283a01060612e19341f6d08ca587941c069532c012765dc902d66fc8e2cf94d9a69e94918a82a616aab7e6200ceb8d113a18052588684ebf561d7212e3824bc17b1346ec3b1c77660c05cebf7d49ce172d2fe729ba3851b68ecffd5348ecffaa522999765736cb9a7f88229401163ee535d0d6cf58b43d178c16a7bfffd5b56d0c78e0eb3b130b28f9bd5fab5b78e3d92683795906aded5b50d1b07391f0b278ffc01d162ebb88a4681d80b5ae33254c2b8f03591b5f8d3516bef85998dc84564064d13514b858f892aa561773eb97f964ca209e00f3eda5cf49990f46d3e8e87c2ddbb71ccfeb3e5ed5cd4193a9d4c537173c1c4a9c7e08c3396db9716b762233dade392f9080e885cce8fd44da10f54414083502ae13b9635e4acf9f4ee28a143d75aeff281589e400792d8f9785f9fbe9a66986b4829143d365cb70a83c70544902391a3e57047d796305b85bf978bfb67f8bf93414901dbacd8e39b192d5e0b70f483503cd7132856914cb358567303a7b9d354c020c06d3323a6e8bbcc3b3588b8d7eb9735169ca6315ee705ff7975339e735d7696b3480dd2270c1918415e050d73d5a6d38336395f59750f3a6003e28f4d44ce7667062a8ed35a930abe6b2ac7b5f34d20e5109bbfc5145f71684629e96778b9f148c76596e3d90aa05c7a4d6beb4dcf2dd6fcf5c9dfb24d544b9ca5fc3b00bf1bef5ef03a40aa505bdd451eb58d92bd30576dae48df1cb4553cfe2a8da011e86df3b1b461ae8010bfe31be6125733e005ad09cadb8d3c832dfe03c45684ccfe425ac6bf044e85c6d6d2aba126250137a8d18b54772de145550785f18278a2125a8b4855b0683409aeb945cd48ab717fbc74cc4ae3ae4e738eb689ba310b355d59da869508901a08d64f5a7c01f5f8f8078c1eee3a380d675a977ea0faf1b471499f2557410c86a1e5014edd91b820a9f3735cc46dfbb22780b6db5764040c1814df0d1da59a87daf30df19a6a79470b0fa048f3bf5ca2e38c06b2396b065c540b8458df117cdcd51eb02ea5b37a31eb8ddb23184769f62f4cd4d0be02439ce2622638b476d39b9f075fc5cac681d524c1199b36719d17a3544b75f98bf65fddb16423445b54c14452181a36b2680f27a8d66edc7dfbb2597b0ab6ee60890f5e74ccc15a5941efb62abd784fb98022625e077621ff710d525cc81ce54e9a1ea48c525dd49eba01eeba7e53bfd3c4353ea79adebd5d92ed4ed607203a15d908b8bd5bda9d6b5c4d92b55a534b2adc33d16789cd0a549795208ddc6e14e9b01f8e2e55787b962da33bcea74b119cecb84e2a77c06374bb87c766bf4055f4c27264ecdcdcd009de73fa41b262333d3df8179de252099fdf0ee20f731b7fd2305d76667a2bb34155ac7149680161d2a8c36412e648588e81c53a74f8c0e413b78127f2e62b24cf902541a7165cc856e01eba018801e24c02951b4b933757bc973f7747e6c073dbd2c1e12235a6e4797d08c6819bb2b5b93ce73d8ade1db6c654eae401af316b9c20915d0143434d1ce562c3d33010f4086c04ceebf0bc399e3a4eec21e30714e110977f93b38622d6f9263cd89541994162d7fc6f918a0aa3ba4be98a1884a28bea0b30a7ead4f4729e4adb95e64543c00e9208d87b0dbeac95938085f1ea49101333b31449370b6f080503b62d2a9db454ec792db5559d7fd6cda23ec52c87facc206a3349b5be7ee25a070915b301a131f7903af07a2d5b9cb5de44d8a9bc664609865fab0438083f1c40ff255cdade33be810d02d34e6fb5f3fd0d2515d086f7f2d77cb2623da65abea02e9ace391841312e7a66d26b6009c2d770b4b7d91f51e6876e70a8e6a72ebb27d1bb3133cdac108098d4c89cc7d3a1db298696da0cbbf4079d22ecfd8dd3604246d6f679d29ed56242e3eb59b1aeae1558093dddb9e2b008779e418b90b33a358fb602e8cec9d0a298bd61511d6d585502252edba859f28deecd6b8a198d7eb4d2bb56a2bc71f9a37be73d3b82c58dae8fd03d3ff083fe83f63b91114845271bd9779bb66dc226f81412a21146cca1c44a3c55e3b9d6705e09b145406f8aa71a93df2e360476ad594d0075e7483e762de48963f6c1667c5ba3df7a2695465e50910b980578cb9b74567b61b4579bb4c2f2147d4ddac660ffc5202a73f5e136e98a8882d115cd0d3622570fd1b81020e66a4b6b4169362c3d7640c9227c551f5fd737a3dcfbe6530ee786c88aa4334a952a162f60e91f258b3d5adc954e0d3e67f7bf28a49ecde5afa241fc29c78b34a871d137e866e774d2a9c53670419b115b0d8d99aa44b45b5a91365203c3eda8bd64d550390309eec2c912bd616039e4c15d6141138ad3e7adb7d13fafaba552278a8e872574870795b416ba81691c3d23d275901ae03f0a595b9051508871e29e51268c5284aa67ad03081936509639f67b2a0ee2081079af89659ae4d74bc7ac87bb4eaa910d98e652ab16b8ba08f8540a47c1789bd3765e8f2efbfa09064670e12adb2f0bfebc7ec28f3b2883a77e1654cb2f8384591100813734c902b3f9e77767b56bf8296ac87a5bb1cb380bc814d34f586882c60244b7cff28b9be106f146633809739eeec62128457d9e93dfaf27f64673aafb2ec24aee4c4e21a78bf2ad87b92c2916b2cf66efa894299a371290e927ebe34cf74f9ae65cb2d3791692f0bd7280da977d237907c6868574a355766ff9bd6987dedeca2cef1867db2dddb90775f4de64c9338faf324a11479f6be2873ffc4b483780422a749285d3320b92a725b49d376af161ac1c1b5fa7cf96021e5b0eeda2d6262d22a8574b3a285a6bd907e216d23713adf43a92b60ee356a9c8663e87170525f925a324c7d228901a1bd54059dc86bcb46d9822901c3fe3cc1abbeba3d92732d91943b58035965ad604260f0d13904cbbb749fa1ca923b406847c7fa366dcf846c921ceee8a4a1bbcb12d01ebc51e698a0a60f2bda72d2515c1d403386c80cb7a0b89b1fd1557b34bb8497240a62088f021abb289d963ef5adcb911ecfe5f22f3f7169c8f8e1982e7b2689e6fe5f0543c3a1c6eca4f37145dbe64a39a2004f4f62a04e9f74bb21e595889f16da3784fc51cdca481be21d6474ed93bf0965bcd0a1a3eca7e3f25494d24d44143ad7eec643c6629de9ecb86672222bef411b8cc7978c714e1beaf2fd28f1117908bc04ff5e13a3ec921e445aec021417ca2d947d2ab107ed11e1d6cded97ef805e1ae71da68fa015df21447326f1b27b48082f26a503acb721d240cc85f4318e718e723778bfb8767c8bbd8af9455c29c224dd0d6cd73dfdc1c178fcc85089a9065c4f0b7bfaeebebca533001a977da88a2be1972fbe74a9d2d71028b2f7620ed0ea24386a36065a0c2b8f4abb585789e75cf81ddd4e9f736e9094e88c895430111a9a054792de76f1cae9953669b795b7264f67b3e53d8991cfa4facdc5d10610a43f498b43711f7bb53e343a9c88a0f27720bf2d94701b2427b9fc240e8b7b77a8c2b4b96735c0c9e7253eadfb15a5c80c4bdadeacd77dbce4badfcca14234051605869d99933344bcbd5599fd5ffbbbfa41f5c4aef0c6547627f6c9b9a354dcbd69c746f1352291ad0bbc7009accf7c1d7ce726d540c1630f9748cf4c929c6a251fbf04cf028594275fb0e82830caf95aec8a6778b2ca6c43d57b7a38094a28c6ff1e8453b3a69be00b02b763770d861234e72606d2441832b7aadf9124f7007817568fa3c53aefe030fc1052c40399c3c0f9727538508875ed813532bbbd179588700d37f4eb26be95e97bf27c8ee8f30c297190dfe8fb2e6e3f030e292fba08f06480da78eb5b8bfff15b9f2cfe63303a03a24cef661aa653d32e190bd384f9ce956d86ab329062d42cb3edb5f655198fd0a3b7d8a779f01a227b72070657a4e4249814b2235d4b39beb14f08182fa735dd6cb1e3ec5e9f62704d4d835739a91b5c2afcddc34c5b3c2ca47122baa50a3e33343487bae72d250627fec5cea578b2d66b251c63330d05f638c40f91b9b870af6a0cfbe8aef9e8fbb0f4ca8618a71965ddbd7eb7683a64dd330befe6aad7dd4bb1c29a127ec8ea0f1627a160787b167d6ec4398f376fed2de9cf763fe9d9b7b61da245a45a5ed76c8e668031dbf42948195f1ffd50edede6962464492ccfecd8caefe2519b3609567319ce97aae3e3e13fdab16fa6d2b11feddf6cbb73864fa22f3f1fdcb83c45bdc291b8d061a1833c6605ab37678c6454b6731484f28058ecf6bc36af8a52d3595c0ea683f9e0bc7d6bff37c0e46446ba311a98b141ef2c9813af3d330e3d897e73718ceb78da31f05988b3cbe64b6a97bfc31c50f206643ece38892792a14788afc9341931f695e17b2891834eb2741ee33a1a7214eccf70664ab3aca4a6a261a0e5f4c0eee1c6657fe5eed525bba123a21988c7dc8719a8c527703917d9b9098f7cc1ff4c4102611814970b0548c7a418b1d0e2ce61de77c17c5f02ec12c84e857dc2527c07c70164ff9081717d4fb0927266d88bb0a32992fd166750398e051fae7d31ebae9613b9a285707d5d7433cb86efdc1f0f742eb80f81b301c679e007f32dc610a0b49d9cd782932d6ad33a9c149b95be851c63cbffaf09b97c32f84930e290e94a1cf4fbb2643ff69eef3c1c54212ae35a7449be07414e650450653bba5e2572442de7bd667ae08aac1901b17b90d6563e69ddda185fab7dc09f944a89f1e02211956458282819c0cf33ff038d4beff091e7b171bce1da5c35edd14232cbfe8860545156df3ec3dc7f43d9fcf73395136b90625644033be8c88e3e18331757638a5a958fd31212301fd212a21fd2b0320728027496e7602987030b2baa1cf2f9c2c36fecde51ab8d5a6a4b82528680e3075effe0e4af8e5c843bcece737c0278b23c2ff3a9fac1a27c11711282ec544576e4ad3478b66d1004cb5de842004898f6144d1fd642d9d40353925f6fbefc8b47aea91b72996a2698e85371c4e6d1373e33ff4d9a80b46492f9e85a149f0918c38036648a0372890f8208a927c1f951d5487665975245086f2aee8cfb963ec8d6f27460fea7fa84e2671d1fe247276c3621c2f99e626ab6d030fa89b62b2f7690b9768606b3d5c870a8be712e44e2f6440b9d725407c78889158420462ca27ba6230c7f338c4eeae04da0d141592cd98de43ebe731258e254b45daee5f42c3360464a2196f5901272d936663a32973b2c9037c201ebdf9db04bab5b61f1d663d8477fcfe8a49a868e2927a96546cd628b8f49f75725c75dddeadbc4d83ca81a704b91d02f8a1edfee03db71f0d6abf5829f9ee0e6663f718d290ffeca16cd6f070020f17439a4c51701eeb86d1c38d92ad0105c2ae4e252dcfa83055d4d9feada810213ca615353e6ebdcb3186f0b078b176064fff97d92ad9d7249fd84ee55212c068fedd498d8543a670bcafb12faee65316ad604ca227c660569c6f4648495035390e7b842d030b9cd5e1b5e123d5a36ddd66b87242a08f8b64c715763e571256b1e3213c62b975c55af46ab33addd5490a070e9531ab5c7d90c4b981ac553dbb2d736a176bab35fc44e6d9f035a25ccfcd9461bf18fbaf3340729292cf36e372d2f15157ff87f97b3ae29cc56adaeccf5b20250f57b163557e89769fb75cc57d06aa701fc42343e4ca733e274255d1196e5fab7e81005d7778ce57dfc63f5bf1f5df656ad9c3a2dfe23f67fcbc892550c2591df0db9e218601d1c3903465970c0dc62b154d3821ca574ddab9e87463419925c99be008b9400e3d8cfb8ea5e45a82814550a5c6e25f61dd814a6dc85ed538b4dbedbf9383143bbbf85333c31536cb3ef9f15ae44cd41dd40ebe056907f568aed78fdb4ff134446124f1d65041952356089958c138b10ab1ec67fb3c8dfff6605bd24abb427d8cb2681affe7c31b0980974b81a2fc848c178cceb44abf7933b907ec5744bd859930f8898aafe2c8c0193942280c56b56de745092327c0a574519a8a019cfd58957b0aa52632c87dcf794bdb97bc7ec457e558f152b4699a938d8c0379d85161cf023c54d684d5cc83541d478976f6f45bf3c3d8e02ffa426cc7c909a86745793845035974bd812a68308a59b09bcb7f6dd9fe4f7e91e468618b4e2ea7d1c885e7a15df729b941a5d4ea001230976c80e59dd3e17139de8ad7e4c299444b9fa395b815cdf73232bf5c4c26d722184c50ff6dda9213ef83cdb7ba615d8418fcbc225a45ba2f2a7ee15dad8517121ce24b5c165a60522f30c3ee3bbf711bbf794f0e09f5d0fb98bb2674aa01fd82c9d3e17f0b8ff030cbdc21ed5b40faf608d545010afb5bd57ab8e606e9f624651a4c5c51029b2441d629bf295f55acb2d6150c43047c2f0e237283b9eb42dba456cf0b9e189f4230e5e3539c77c94922c20f704432af9f48e33074f9f6a02a9d5e135a968dc2fc3a9ca3994271b9f5cc9064731622c8acfc01027174050f319fc5a6d24d0a28b0b18d604e9d6e03cc6c7672efee05282df5000aee9ecc2c8b6fbc705e3a7a13d57a68118b32b5418b7127d8cea6943801d33369cb2ed1c655c5cb53c6bc73c2bf9076b3a30a8aa2517bbb78ab3e7a92a68aa6ac3b9f8bff38d05e7d109030b97f7f6b5378321e2f65e35f29d3575851d2e0530568b09cc82cae1d2c735c1686e1e982f1b73b8b53c033da7210b656b714f2abbf46e5119e2af517f76628cf3d5505ef5a17badfb9a3a9da1018c74382eaaf6ab56d03bab5cc2dbfdfd9e0f131c21b9752e7c93bcabeb91e19271845940a5cbeb367988914ef54b1b8a3d33aa41e0926a3c684fd61988863f430d917d2300ebe0f39700f3cc35853ab23375478f8c168f4658dfd93c1722893f763e158213330e34c21f9616ba03be65da22e26fac8fc7d7489db83048441888bae8f6d210aa1abf981a7631e846cbe0792e96eddb94ef1d5a15aae31023af3fcd9c9c7ad26c945292ad3e709d05ecdafe74b962bc0e8343302ce3066e3866479a5701ac8ef437f75fd4060a445dcd59664cc22a12011cbd05d95e1a5508925aefaaefbcf2096b8379c86dde418aa79dd312a6609adb8fd5668a94b6c29618e09629a8e7d4a84519feedee6e272030a625c9550ec53b929e15a38df677f8f53618963903e50b9d9df9e0ec8b4eee3fc08536750778d64c33a7352e9ea1b69f596c316abe8e9bc3fed9d5807ff1d22d1316b6b40a0ee61eea972a624bef658bb0e86ec2f6e223a78099c82f58b055a6bc95db7a69f9cddc2081d4ef5e8bff2e430eb299b04d995579c93e9896e9ea735c2c313c685cf069a37bdaaa1b358d5fab7319183f643d5976b3da6fca754318cb9a0f443dc57defb239f511aa0595d69423a62d72c66d4444e99c1d00388824039d50165fc145508b9940823568c27cf780deb8855a0cc08e46b7940e20fb63d53ad2f22007bba750f71d2ee876f63a91d52a80c701e2b13aeb8943df5b170974c526798fa187b7e1c900b81a4b5f54786d9f54a7266b793244ec87788abab8dac55bf9472062f58f04e9665c5c56a3350134fe7aace0904093a2b1bc92e4f4f4b2a443ff079f80d4e8b1792a53ab96ea1971fff7f0252b9424fbb38a6dd9c85eba95026cd3432d8072d43829761d43ee59f23c22b826d7808a6f10a4f536af2808f762c5c136e4b149d38e160be0e62c288588622214e06f7186788089b2bab85fbf61aed83c3f8c148ef519a874ce1fa567d39e087b0eef9c688f60fb6cdbaa6f1cada25056e59c81fb328b22706e5002d2352f5b022fb98925c6e84196134a0da3b96a9afbb1f3617b127f9bd1a384fd94da24d6b5a1452a35585dd2c940058020c450caa4b4766aa9390309a7262ff47a4add5dddb8724e5388c49ccfdef25192f659fb59c7e36552f1de9c77185aa0a3165d5fbefeb578611166ac937dcbeb312e2baa0ebc3b2183fb1a27c3a645dd7b26a9113eb1bd67b35b94969c9e167c8766cc3d2614f4bf930d704aabf414b097d3d0644c30625f9593c12e3e1fced34d6c455c493247381025ab873a77ef61ee8f2da00f7492afcb7a1fee5e2925d385fbaac844fe5363d2d8e62acfd20b937525cfb91c3d267c340c2400fbbb29cf77be08d33bbbff43ea31b0362b6aff29cafbca392abff4d51e26a16761016dafaea3cc787c391df99db5a7d52000ca436ab6f0a724dfc94eedb2d16223b2d3aad67708e4ada9b60e8ee96666f6732ed1457243ef589514ca5225ad0900fc04adfe21be0d9045dbcc8c3c64a5fc70db4e66c8d41b2fae374c4d5ca3c3079ed8c464b8454a53a7298594b8f79ff0dc6b6851ea9e795b8da865ec38012e8e493d4f9e5b6bcb6139321c1cda015dbcd346f697602765f72283accfc37128f7b6c53f436b04123c7059aa946c190b6a0697831488e9c21d3b045287b6b81732c63e5977947ad9b79240abed115f7085a689a1fb105e5c538448ed0d3788fd487f59a27a9e0fadfdbcda531277d6c7b098b3b9928e05585baeb6be9fcd5226669a28d4c19274c4519db3a38280d076ecd31baaa204fa7727f3f41da218b98d372b4c1929e52e43716f5a58b7b05c27275aa1c7e36dd12ee64c19dcc8762543756f137e846b9dab2fe62dce739c99ccff47998e9f2927832f575893182809ca2f0f75823a2afcbc824ac928faab11900a571ade11ac34ec9ad35653a77551f993457937c9af9ec1e2f27e9c60fcc3832583af40090e093139670005ff41baf96e4a75c0edd4d916e97d0d05683d4baca3b3f4b03c1ffc3c3255e22dbd25432831d33c559d2ad540679020c0ce3fff0dc8a22c04daae5a5627bd3c92e6cf38443b1ef74c22694e148afe7c739cd669eb410266f6566c69dcae239d499de2b0a2a51e03710e33b7d2844c4cc33ad2378517b3195734e1516abab5f91a56115fb7f881c37f114824fb12e6d2cd2d775a1e57d603cc7aa087909501d079daa921201870e9b730724a980618927f3b77b1957c3423e53f3b227bbea084d0f6132135fbbaf9a8b0b5c61472976bbf80a5670c0b037d22ca0d3d5eefdb1754ea3f9c7bf3dceea91d01ec24cdbe8eb472dc641f1f78f810c8ac1b3a1891ff0f39a4a8d380aa517c24c7b60e7d3a764c77699e3ecf95e26d3da10da27728a2958215923570b5192bd35dfac08c5f48066a7736e67f9258d018ed67ca8368e7c1c74df879ef4ec22070942fdae54821f9563cac74d1dc36c3e81ab869ff74928a2f904d900ed5dff87a47851710b0febcac0239c3c434eabd314d15d5dcd2b1f9115a9cf67091bfe0a6f3318f992ffe8fde1e94807a2cd512e5c19c0856e60fa550d84332f97793bc01069c9844492302ba4658d353cec2362de74d48e2621449dfccfc7a836480fbdbb2f41640786a6d65ab27a80221c8ca4e647cb441c5a98dbd96b9397c5c25f790447647f7f4e7a849cbc825886ce6fcf64e9a848e862d0c78aaa13b5192936514ad4bdcd8b2feb3c1f9eb65e9cab8ae15ded1f8b7bc38bdc0840dd2f8b82f803b01374de14da8c0ca5e83ce94ef4227cec1cb3d7553fedda95fe6a244f58d336a4ff27512b64dc85f8b1c884c0774466d13db1460ca1504200565e2ba270adf0f930125e76b6773df972626e9ec63209940bffc91f0013ddf7c641cac2d4761e9179f54df2c8b24cb80b2418438e6ef432040ea2237b443672bcf100bcabc30f8ffb4dfdfe4897cfa47ea1aba8457d5864ead0ea33a03f1b1f7d2cbcffb36af926bf795ebe829469c834987f2b969d8b661ff90cbcfdaf20ed266e63d1654e73f20876f7c2a746bd13dd26a51c2ab68960364a488d95861b9ee6294e80088ff9d9f232610ecdc5f5ba38405f24cb176e52635b31452cb8a96bdda5497244236c8d096dc95f3ade3ea26643a274fa1efd95a7b02f04af66a8bb663b16fefb3b8f8cf07272d2e46c4ada7fa49bcb6c5c1cefddaffe732944bbe4af81e81575e78bbf4e3b31cc2edccc2c9758274614af562c08982d1e0693c902d4f4e8c11d1f6c9f85b5ef3b4766ffb86d485902a2a55757804ba01293247edbedffb46a75caa1eef44d2b28c25320a06e65f891a9907475ef6f0fde041cc9d2d1ecdbf3e4488001cd34758d44e6efc1c31cfe3cd0e920d82b2185d071095cef612062a68fc3bf96b114f48c5d00328995cc1a14b21778fd6036e1937f2530efad3642eb66dffc3faf8ce1eae6e433c8c78f2fd36621b80023e35812bd13fe6b5106e7d50a67375a45ef0add86993da5c52cd393d097c49a4f50f1ace296c60fc24eb27e412b5396867e50292d9122972e34d14f1ed6a0b2dea208c2720f4cd97fd9782d0fa89811929b2994a544b8717664a7332cbef87d04c9cb837472967059220254b9f334fee6251f9f99485782ca3709c1ab4099314750c01e43a3708b362f8b583e1cb5db54954e979b415dbccd195cc13d54f6416a793d30abc0e8611a1c45300c5f903f8a2feaf314d0aaf5fd223b08e879a43351b9ef8cd002d2325004d4c9ff959e2d8418b704322f2433d45ff6059190defb3bd85457963c44d8f35dd147f7cb9a0060e38ff024cb3405f2990e2a6b8401f1feea406683f01b6c4891480b812aa4e251b7e0035a8448f4ed51bb157a5a114b18745cfb5c2e75fc8e913a8e7159c1d5c1122b4f77ae4ffd9018669e9b333334c514a2c9f11b35504f811c0e6af8584cd1b48695411b401e97be2fa0be2531697858e34bcf2083bb44f857069a11b651cb3b1b8bc0aa93f244e268a03135f969544f416bdb2949046155c67a45448b424195a7633cebc65f643a1740334b1e3a8bdeb5750c5fb75697a33a12daec6b15d672fcb0ee4cd9517a9e787e2ec256b1c5e78a64b9f2bf4961fcf9009dbf4f33fa947f91804ed287473479cb4c03fa5bf4aae0723c6799f32fff3bc33b2211e019e3aa2eb0d03b70e65a3dea47bc89eb2b102a04e2c4410e3be9aca7c90ff33200f78b8bb7709f1518e49aa3a56725376fd9b0da5dbff42b6015ed29f479199f70f744a34e62101b92ec9a48c73c14cc88160e9e40b7b7fb0330131d78e90a0c395c89d762c3a4c85f2cfe047720400e5697b3b127d9d09d273726a62197337e3e7c25afddccf327a8e8b601ddd9b8e82583635ba1594b082473a406e155644f469475e414959b306bc86a5706a32d0e0daeb639fff1767bbdf0fb36be6d50f77d4bebc3bd51bc0408aef4d0672776c951bf960a914f650681a91251b5f6126403998cda7d287d3d9e5fe47d06260c5e51bec5c1011c6f1b9e73c1cac559a3e2ef5373f472a685479c38fb1430388ef8802555efd0a2ae34ae065480be5d6597a7a54c6b4ce882cf0c57b026edb03f2f6c2d2e7622dd83881cdf0c8f908c9b866f0cd9c4cf55a63e75b7ae1f97248312d39b8b925eda11ce1f8e9eff32cdee2c8c9a71a1e2942447577a541b3ceb65cd49057d305c11bd117810b24061c5eaa76aa47cfa7301b880a71e3486badb14d6fb1967920f23b499621a6571bef57e6e961ef8b0de881c15cbd49490be9062ae74488047f7fc65da75e3c77b278a80997d82f76b9f40947cee2df0700bc4443490bb5472c116037b57e15eff3d8727bc452f1fc77771634ac7537676baaf5482f47a435fe3bb046a7e0ca20b76558f4c33e228d15819540913a588eb59f05260b73f016b1defa40173be7eaa30a9389c651062daae173228650b3ec815169f4311611439257b633c3ff5d63aad6e8760e9a12c93e8504ff6159fe13454eec0df3f175a3af03083f900ccfb9adbaf44cb63cc7e7a531701b0643671dc6f92e146fa34808358298b51d044382359611b33d891609ca710209b1e4d200f7a734f9a18628bf3151dc7fa6b14497022a31b4c4ab670a0dca08a335d4ad5b42eeefd4a51d453aa458bc5bd5dfcdffdc3483af03ed56128229ca0672d8aaa0f846d00ea2d7d03cff973d9f988641d91136cce775d9e767e15a3c6e431b96f4e80c5138999a69ba68be19a3955511e73bc6415a2b3260b948e15e673920024ef3e3b14abaa016efaa95863d7e6876d7b28beae0d5eaa0d509ef9ee65ca3883f14fa285c48a3da4ce5d8cd3b117ae8aea8fac1e4197107c2d988d4d1028da73d9da120c4c9d56b9687f604df021786c143a114d436f02f029417d7a590faa96812ffff35a48f0fca5555a79d72e82fada385506c4ad6a12047edb6d555134bcbdaedaa8dd003611a2591cc1ad3b4891f828417ad4a0c31eca1a1324f22af86ecd34173e547cf270ad586fd5af06cb811ac17fbe2fdaad67b885fa20b4bcd0649e6ff9eb222ac6e3936ea82715f6d490cb39a848131de9d3679717e5820d890fdfcaa7887256a80c3392f070242b7e752ed88476a7feee5b4cc2e97d85eabb10e1dbe214a19828dd60ae0f295833835e8825c907f8fa1c8d8343c2f60e3618bf4b770931426f381e2281e21393093e6b9b9d929f7c00920af32e4bdf9a77e2a59eda65a6af2b9fea30bb8fb064599530d1dddd4831b4a108b7705fcfd9be1402849344db298f9c32d319e6c75d360237359f91ec3ef005d0e01d3fdfcd2bce48f30e016088bba83801750ae474b9e07c3f05e0dc333fc54185ae7c2bf7addb9d23fa06667a59b216dcfbc1d57a369cef6e0b864ccc551b4c1bfb385490cc035d4edfc2445716b6357419322e9ffbebf5b31be0d44acd8e762a176500db89679641a89ff37edb0cd6dfbbe4c604cd41e8aa17e2f060a0c5594963ca597cb3ba8bc2f079934a61588da1f73c38668ebf92a65ec081a72c98226c708a8ae9314e32c05265e48cff87c05e414d63cacc85b68a9a7e4ba7ba5815838ea146e428e7b655163bcea2dd092ce6b72dea481af187765da87571ce43056920b84107fb25f59cef2cd913e4de61863886b5de6d682f3fda2e0cc8c293dc210f38b46282d00251b481b5c211f241b437fd6e52f9b24aba41c67fd670c01969f62cdd2810aba44033b5b4ad16c6850198a10529276868d88e24247ae6094d90e4ee7d6a05acd690976f4b3f56463863f9322daab2f08e8fcb32b21a6d8b9dadc7f858e3163e45cf012c952eb34a39c83a61dcf40bbcb5951899c51263ba431ae294b8d68df5d5d440f1d0efc627beff27b9cf237ac14aeb010d5ea8a9620d41e03aebfb17951d78d432ddb46677ccef8df90482ad20ad35ea706095a9e8dcbc6994c07af87ee60fa4cbc4fd971fc01b2ff93dcfb3b9b2e99622142030d727c7471e0ef8abb7afc512072eb95680c97a521b849480e0234627cea6c3a68575f67a452eb2516f2cb85bd8e9f4ce9a6b9ee68da2887be43b1e00baa56867f1e64cdab07cad6b9fc3ed5fb3681eecf6fd287331a604c7002c7476c7872d2fbbab961521d9f0c7aa0d1750f541d35f062c9452186488306e9ae3425323bff1978a1835f22cd2a4155b21dc6ead4182c67647eefff34efdbb1fdc07b835418f6a5b8ef0d2dc52625c2f99d26c0b19ae6cb0fef6032ef30449c5ab7474ddc62eaa8d7977b7588c52a7bedc598f5d0afafa8180d3103424ccb28f59cfdd205b3fafa2bf84668f2c7b9a751e2ddbc9d871b5e4a4bf47e9699154f04fefd6669961ffae98d74078025ac8713787b319fa3092aaab559c73f97d7c51d7f23afad5bbb6dccd6b0c8c9afe5e054aa5d63bc700e9f6e27b70bd996cd19060398a8dd67abbe9470b9e47eb0a7f38340b0ac33c5cd9bf9df0d8f797f87f7c9f6cefb41a817ea7ed1235aa116d4c44d2f3de644bfb17517aee8114ccc6295a75a2e165b486aa7cd2843ebc1de430181197da7bb84717ccf8a2e04aad3a3e63abe17f7eb02b49e0b4c1fd04efa1f8d7d02f59848e5dc8a361717b96760958437d93413e0fbf93e2cc834a11219c695797ebb5a21d79841ffc3b98355b5d779cf3abbeca4cbcdba4eaf42cf3075eb6a3122e9d1b8cf408da942d8d2ccb7a74810e9321aa7941b5dbe4f9a1bfbc6db57a6bd2f1daf636d24454bd45c2c719d3fbbf184c49e3ffd350570d3b0e3a9616cd675459ec21378c22e5e64a0048e53288b6fdd7784c69d961b1439e7e88a8e7455d0b5603b973c109ebd0c238add2f597f7dae2ebb51ba98094522430fb859abaf3e0d1f61f836be7c85b697b4743590d4a7204bab6cdb6b382b5f3487c8566bdb72d1f3fd39c8a7bb7527821ea212bc270b1e5e2643d2713dd490171e9854f0f7da5c07b58be73d82b39d345906e780535f2adc2cde38b4d32fc4f56803f5528917dbceebe4d17e68dee8f4711ea0e144141e39efe6e7724dd60a22a5ba64db1bd36dafdaf5b1ce13ea22248e5d36fa5cab569209d4427ecf2519221fd6fb50a1bb5edb10fe74ed8efd108b1f9ebdd600d2405d20f8f041182ecabf5ee0d52c5b28f3d3b2dc4892f484cccac952a856395b41fa43697cd8e2087ba626bafd829f2c1256a8309f71edc719ca94ee056bd592a9f6cb36cce76ca7befa91b1ceeb0ec28533609243c2f732e89db0c3019f3a6e14161c21eae6f10dfeb11e479bb896e76573912f5e8c49e64a0b91f15557dd9d153a0a207fc32967eff61c04f0416df83e031bf9b4b8ea0c5cb7d6267424ae81b8ba88eecd60de1c02068b057226ff32e9180fecb9c17a14f52a8708f8d38bfef82dd44f4bd6176403a76b4f18bde302a55ac1cd5523a36ec4d7ceadcd69d69d29a0820b6d9234a3c6ce0d94992613f6b0cdfe4b94ba539e93a81c9b017c10c8ff7d5bfe3d15f7d37c97f5783d42c0c21966751fc685eef450400c5edad61b25c0253414f92b16c62e631ba7a7d24bc5b9637ccfe293b7c0e958bc660aa2ee3020a78075038ca0ea7515721f1c1646ed0cc65ff1ccc68ac3f04736e13234c1107999b13c8bff1a272a0568b323dbcce6276aa35de79e509ede550a8bab6d3d22cabf8ed4bed7faf9653163289ba2d785efee54ae31c0643a3297e4fb32252ecd22b301e2f616250db3d86f70fb26e278a37982c7278f1e040339ae33ec9472bf70dc63377b59bd51c7416e2b53f6abd7e7069eac04c234ebf88084df249a810ebdda35ef706c0b10e0f3ba984a3c011ecf9a3566265ec2ca68470b188da5d4b03e4929716507ab8fd2fee517c6a4295b520b336769feefd22fa3d588ce2c302cccec558028a08ad2bcb2ddb953776c41031ab037f26a216ff9c1d9f87782af18b624ee64f9fbb209eb379fabec4186a0fd3c23aff60d2e7ed4c84feafc3584e20dba7264ed978a17a4557e8e01b96b13ff4d13d40482094ed18281e3df1058a7b842b0b8a9739384ad5cf3c443893094c7dd7c3e4307ed6b3ec86f9dd605dd6508d9a8847cf8c37bebbf0dbe33864d6c44577d9285cb438615f5c14fee78182b63e991ff106125ad06e4af2800c96f47d137571f103de99f4072dbfcc8f0625c9922ff5bf3f0131589a72018a08660b2af63d850df6eb043911c06b38fe7496999b4a7b1e86a3e26f9381fc262c47af1dfb5cc54a3d1fd72784a11150cec8bbef4a38a987afd53842d39674fce86054640804da3fc99136f9e49fa2bc78f220acf22ec4e42289ff1b5f4fd5772b0b1191a98d33ee7faed85c4c4c8f44115863d244c5b7ab6644b3da2454b1b6045830f5bbee6a9da6b418951b815b8b0a516c86b177fe3f96a07f125ccd1e5bc88794263348329219385e6ec7d7427f65ab7b86c0261a58cecb8d85ede623dfa892e9ffa15cd5825ca1d34cfb2eed262e2602ec6a969c691607a3c6bb523339dda1a784cf0f4aeb27aa6cca822a33c1ebf74b3d89eebf5d4b280f2169c5b8e32293e55262edd0a2b9e43c9ffdb1f268b646fb19213c8f101619eb1fe079b599ff7cfb8c98a42555d9311ece5e6ef3aef8b0520cbdee9e5c0657a74e75aa6c5a7e21f56415843fc1334aa74f9d51dbdb7fc54f49005955b58174ea0cf21a2086437ed4b30806a2df693b72b5c90d33cc618b95695735c3915296bf8f398edc25bc40a44658423d52f3e2b27ff1997a986bf92665fe1e0c2a4cf5146a824e56b0dc4c5acbfd77debfbd731d1fd6b04d7b407df15b93155f49a4608a3650a9d5dd5b368a877f8730fd44f61cdd825198a70c7727f514fe7e365bb98f3c726f335d96cbe74245784c25bac859243a3fdb00b4bc6a5f7a20dbf44774d32a4d75e57b5087990f8ef4d903b21690e3078180e7b013c73b0aa83760251c01419f151b135b1f5bdaf6c9bf72bd65b60484e33f8b6bbb7cfd3426e6e44acfcf82bfabe94bb9f96fecd46b648d400d7432f5749375aee39a88fe0d8ed691bd60ce1119890c45af65c9226d7edbd7b9e76511073c3e01316a19f23785a746acedef0a43a020f890a612610c75d59ce8bdf60eb2d59b1e3ca7be3260b882eb77c70ca994a16ef01fdc5a98a45064a56f972796517c426f128df079a6230a008aa4ffb57837ccfd9221139c383b3f2cf5bf68680480426fb3af0ebd10db3bf8683f8082e0c043085406fcc9ee9048ea7634cb3fac29d92793a6cec103a3bf0a2645300ac1dddce58360c4c491804c4bc1f95d7e728fe5731c87e520ce181f85ed93e799950b3a4773efbf130e3cc352fac26fc2417973992a2f7615206baae27bc9d922d8519d3a29cedf24f7b8783718e8ee5947550edf8d5f0eff8ca20bf9a2216f5e8cfe2565e0b556e903013cf768ac61dc783cce278aa63cab0c7aca2bc8a4eac7b672597a881093288c12f86508d530e80b07514d5b1a09537bc742be66a6373adefe48aa42db78b00f51d8856d8f3e1dfb7011e3aae3dab71a74cf098a9378b193cfe6b6e55805bdaf855a48dea703f4874ece4a1a9894f20c052c9454113149e5e95b217c94c64cb36f7032f60fadfdb2d0f385be64f156d9b34ec07c6b2511e9377168c6b3d09a04e512c026b5f36ec3d938fca0086d44ef163d1acb5249bc39a55da1b5191ba2b082e8cd30a7a894c661e2833c9f40dd1c5a9d0c9deb577e714b8bccef586f616aede1c1ad8e2ff60aeb5e54023b3e6315070625662cefa5b3ae252850f6539207a2eda588736177a2062c30d74f9569f35d4eea298c48a2240a836a66fb9ca8025625ea81d391c0e4e837ff94edc921b13d61ae0201e92c6dacba3ef4588c3bf9e7160eac08b090ec0d314786ca68c9af9c54b39e4ee2403a64fa956f19ac6c2de00a03efffbe621aee756bec1d42a53291c771bea47f62befc6c608463cc7b06816ab3873f1dfd90c296627d4a3506e1e9c8ccb88d777b2ecac308904ccf7a8d67a7bd833d5716b5599b9bdf58d78a4a56c885f62cfd384146b59d267b2cfff1bb461b48067e38b4fb7e2131427e305b1f545174cd4a6ab7bc02ed8d9956c203f2f11e0b333c71fe5e94a7820a7bcde96fa58346c07f57cf07d7f340986c5db919afee5a30232ac4acc30d57ab8c3d2c2d3d6a108beb69ce5c90f06cc0e0afaebfa26194d4eab97d95d41729ced5e0415f130e8c6620c87f2847127596ff0ba05dfdf26c469ddc66753687e556df0ca7291b48080d67b9aefba33a718c80f7f15af64d6a33e945fd88f8826abe71b6c2531dc8e5d86dbdac87d686ab848a29279df6d06a5614ee8631e43d0e3d4fea5c612bec19334d46ceaabf5c2224d6726da854481a4e488f8649eb161ac518a21f3b2d0dae513becee8ca08907f5d7671050440b80c333064a895c0449cde7211c674b33414689c3e8cbe09743591cf802f7db9773e039ee61fb8ff64deb665247d137fb835cc3361eb8bde1ee4c3f99596051c51d16aade1e81fd024a3e737af82397d3bcc80e68f5a0f40ed9f8294fd10fd0a57f33ba231767ef9459a990526bb00ca043a61ea65631ba9b051580a6463a8b3bedcb3caba909439507debaab41e7aa3d07465af22edc90bf2a1b67a93c46ed368eed4d227189e976d3365dcafd60ca5a09cd0eefee58d08a314911f257dc060edd2770eed48f1a5ab3617b2588768992df22c6cd0b30f059ba73b641e3879fdf2be2d3c178236b048fda5471ae6976c233301dff7f57e7cd97a8e46d4de789be1a02c307c98c3a40c5350dbc9f1d261f426db37646df32514fa15209a76c1d3423e26a4b754a2752a43a23ea6f5fb9a25ec00d4fe2ad55d19c059ee828aef70211987e08f0157e97f1cdc00f95be920e6dac867ad84ce3bced7d9f86aa466775848b6b0af1f7d40c65ac2dfb70f5bedf67cfa5f731c56786e5953e572b4622cd705c1a9cf36c44702cf5eec3bde1d143dbb078b0fa8bbee4da6eef4a4c322abc9b19764fb599f0ee67845d59220d3a526be0c6c5c47eaac957424420d596ff2822c73311ba8fd4d1ab1dbddaa7c54c8c4b643b8824f0c08f9ab43ca42f2687e2f4349492caa1016a80661efa38c68cecc677ddca34c4f93017f73cade869425255251ad06fc8c490e4b095ca246fed9bb999728b119d766ff3bad66f3303bead5dc36ea17916646cc5959021a18e14ba16eba3265b1753ba89f3cdc7657b57a27769eecb7b3d66ce8a5f542245b9dc8363dd006fb8169040e968033379a4bcf8e2b797064b22966c8b44efa18e329a893831390750226c14541a2f878d89c63733fb56bb8681346a947126d15c65e494c544285152d1ba79c17094de63ef91e0d1e2e71609a4092367e42a0172ece55349b28b1c6e470d7a5b411ad3e164f7777887c725792349ee36161f67f82a75de9c3e7f015ac1bda101a070e291e3c433b7c1f051bdbe799b2d76b779fc7477afa61718fc4e313059c5812ec122005bcc72d05c927e3ed3bfe6b37fe3ecc750bbe562b96f87ebd9a56e2f1176e5aa8fa5604f8202ae69c486f2d98e0b1d1362e2ec1bfc31c762e23ef687c7515080f83b8e7d4c65fe09939c5738b4e54810d81cde42449ed3f46ec90c13f33a7fa9fe85dad3444c660048f60d1f671207ac4c63f75a5dfcf4c6ebc092e34851ae4c5ec279ebe838a16959ae806803565dfefc850339b8b577b2e307204afc9dc08df3ff71b46613aed2c4e911d41c162bd395dae52124ee2d41395e7f57dd62bb1ef7841ffc38bf507d8bbd9530f3dabcc2d8e612391d16ecb9d201302fd59c4a600c1eb3435e6b8fb4c258d45651ca3ada9bf4133f0af60b3d0b8fe329aa793a12c347b0e623793531aa4b0bf460b036d4e5c907a00383eaf07ace00c835d4fd936e176d91bf79528e7aa06b243d7224e128961ed2fd86683ee87d217476452ab574c2960731d0b9cddd9e98dd4db5dcffdd831f0471c76b1d744a961527fcfa1576a5ab3a26fa81ec437f2a29b61d1be60244e31bd8de5c715322df72c657cd17f2b67fb0db5f848785072f2f5fc500793c57d704a16ea875a7bc36643837a35d4863ba3933d0e38f8606a7106a748fd59fce7e4e68a8403a47b603d66a06a4dc39ea58f87a7b800fcbe8079212b331e963bced1a9a6e1a308cea659ba8d9997c4b7828b69e5482fd2f2cb7954c04329afd924e5dd275adc573bfb01084507048ac604e8bbd3dd5223a4d9466a6774280683f5d6896e17913a8f4e98d838dbb2e810ec2d45d4aa70eade46ed23948f52c9ee1eecc41d07d9841254ca9f94a3152b87ecf7ab9aeec1a5c108b14b66d43047ea46588402bbf065494c749b3f82ceac5559487dca8db8067ee2290ccdb08a5a75c3c83f0d9c81f980c7c8965d92ab3ecee860d90cd707d57e6e15a8aab85e10944815fc42625a1c4934368054a4deff314ec5d4ba8e885c7b768976891dd47285e559781bfe7406872254e73b8dbf66c6e628fa58a478c93cacc9f1dd2993a59cf6eebb33a24ba5699e25d2452be58ea09575401bdd553b9081500795f25997eb79521b07574e9fabd6c97b31e048bcae08f216dff9cd55f9ec040d4e550f8faee2913c06f74f91f9f6aca840d602b7899a1a4f16eecb4b6583d81e259d06ae55a9b0b5280469f03c4b658e378a7cf414c798ac870d8c39f0072e2e805bcd9bd6bf07645e70f67c3afdfc846c455662b90d895353ab79754fa36c1a92c10ed23c042e0aebf781077f3a828a70606275b9fcf05fce8a32d7aa7d7c08c172c8452d33f40ad4e2efb89c1873f0b25fd1204f5484caae5fd9e548595a5cdcc55be6115a89b2a8163a325a52791ba5ca005f0607d143676e7e50cc524ffbbb9339391c9d4f1a12c4a2ebfc8e62fbdfff9540b2f7f99a2fcc8b13a282ea3555452fb1e8d2a7b44509e061ac7585f9311370294abb04cab5acc4b2440cff7c516a1a86577aa3718251c89515ac2064f852b7acefe49ccac58628b66ca170e943ef54e505a65cde94404c1bb5ca0f37819cce56115d52946bbbcdaf6c98c8c8968877c59c800b72b919c34b7771fec6b31b30abe0cb4806ce8524bb127a5699c7972029f2b36c21cccadc1b58ca3910f979fbb2c6599dcea995fbae4195076654436edc96753decf07048a165d43131dc3f3d8700d0d70882063058f4e6cb8ed01380dcd36b93aef27f2efa03548b0572533e11436e91a4f289f4e3bd85095dc033f0fbcae5fb554b4cda2b26ab20a63e98b11cbbce040acc39c51b42943cc50fdf9243d254d99d1236dbb7242b34921e0481681eaf3ef65c0a4c7fc000141eede743d57f321adbf97afe89b82310cc3885c4b0931fa569eee47dc3ffe3c96ea89a5cd9e728d9135baf6abaf37482bf3afde8c7b8f228c5f0fd8b1abc71998228de42803ebd66ff811a5a5a473c64cc8be8897af466aa36995eef56707af7682b66e69be0e57f884a8a6f161b2ae45669e37f9729125153d40e4851a458cd04a82e2e82910fcb0c94fe693994ab64c79086f915c267b749bde5823ac982f8dfc58c5487953c7936c2ed6f4d3d1c8fcf437d5a15f63e775f832af383f788f87f51bfe0a9e3c4ffdb57aec6dbea28427c130b36e8025ba45950990ad8a6f920808b85abad59f3ceb7a7520e60ec5bd773e40776f4c79972e400d65cb0a639711975409a3a4e9cc8aa0c76f7e8e4ef8e3cceb340ff882f58ff2ccdd31ba1ded76013d1f1b3f295217135e5c4e1df5f0f0bd3d1ffd4337a024c7b16ddb444c59ca65d1145ba3c6b1084ac16a30c1f114c45c44130d8cc03999025aca31e7b4941509a345e6e5d3e591b3aea39e11850706f6a10ea8a1b5b17228eb70326b6fcb64ea5f708372977a6fa16b149f926520950940b2cc539ad24456721ea3f51c1d214d583cc54323130691e24ec0d020e8071093c59fc67bb6385f57585695a3213b4438af22538be5d0e81ce72550009eff7d5fb18cfcdc4de3613ce47fc6bd5d258806b69fc39339208514f7a4a053b64aef9b04f63292dc6bd2604d195cc2d09e2199a005897ded27ae299cf0281955d7a3dff175f49b790233c463568165694db377a3ab8deef45d51c376d67adfd775b8c7ceae028d90a6f4d1b929c5d78d286c9256cf98d0d12898c02b8b42614a6bc5e094ab7988613d3a5526d9619495b3ec4b357d776820de356ce40623cef0d3cced62d0ce6f7ff877d045a232644d08a91321092ad50e110793ce7111ebc1d5a2d8fa5a8d6a520c291af56e099777b19135dd16189ddc30dc389ba00135e6a239334373f28b96b6154dd999563946550d9392328ded5f778927fea0f5f83f4c7bf4c5cbcafcda94e3afd8c25418e32f8db04cf9ffb68327963d3356c2e4de639b0630d233ba024bea349eb32abbec5d46e27ad1e5dec31b25f374251bec8a6f0a50d56f22acc67986981a54b513f0f6d96972331556b3a4f00485b2b67d3d2b751b2b5ad190310565f1feaeeb8df4f7f505ea81f80077b7739629ac9eeca79b79264cf378fc22ab80bb42060f51f1fd38cc80721305496c9a65aaa8fca1a8f0fb2975baf276cee9cb03a2f718fa53d0e22434069d3df6cc93db5512f623da374562894c2a933c36c15f1bb119d37cbb1b67e911304f61f39edffb23693e04df55788ff47db6c78253c97235788f3fbbdce3e756d410ff77ed5172f59ca2a806163130cc7028a015f94cadb046e16575c2245c2be2c65a30f5fd1298362376a44d723a6c50ed4aafcab497dc1cd02b0455c3d6b282fa8f3dcba43943054ad7758e801f2db0e01c01f10040752a96c2908e84caa6ce8ecf6a6279c790776563c279d476f7db7ec373da8a7bbd73eccebdaa5311afcd12e1dbc609a3c9cb536bee0b8979a4a4cebd3df3255f136a1be8e1884e664ad8359f0bb11934424d4270ddd72f86ee27e7dec9d96dc79452d91c122b55e9461eb2741a0a64e8c6304fa9245ccb9ff1759fcf6d49b7d2d32cfc6bfc1b759fca53f7e56c3b92b018e27c820ddccae93b36108a7035c6639b0b494a92c518efebc65d059a63f98279d4ad17686626316eaeb1e060ce80a2c311372283021a26da5fb0ffa9cad6d6482870bd2df424626ccc0af3bb6b5479168550ce8674b6f4954d6a8fa42fd62ab0b7387af3c8e9101e1618bce393e61744a9f8207869ebed39611b896fc9a57e5f5c4d882c7fa1f0bea0cb86659cf971e754c15c3f59ee0ad3590451fd143dd9598006d63c6a0a5dbf714971909c21bc9a7227ba8c464e25c9a22262cbca44c2d14b40875b381fd534ebcdf05bac03f41be081e8628cc980d74691c8b095bfc71502cc7045fedd7ada257e4b9ea95e59815d2a8771e20a3f95195ba5fc64acfa8c5f729ebf168192a15abc1e93fd09ed7d7e6ca93fa24fe98d5998afe473dc6ec30aa0cee97f0208d2bdfcd8b11c6cf7b5cf925a269770ebe94cf8b04360a0be866a25f460a06de8ba6d813dd4baa78223a27e141be3e515a79aa505a8ea408712738bb5319e56e6f256d6e5acede3df8a2e93484ac2251a6162ca20b23971ea4c3c5fec9ab1c9d8283060ba8db7a01fff0261dc81372d15aa54d707c3ba090b13737e28a01d283884efd37e7eb4fe9976ec6aa86beb18fff24d17d2faf9639495f7de2d6cb8b3a3955bf643a3e33d6a6fce91f897c8733a04360730870ba132c53a846f832dfd5cd79995f1f2c67cf0a31a310d581e4809062660e34160fd17cf2c559ac66304c9bddc48c33d53ee4ecfdab99c68540f151917c03f9f1f1677a9ce4d0c45b19df5579324ca836a52ec817ea64d6c7953ea7e9b63afec60ad0bb0b81759dfc6990d80bc3b699bda79f405dff53d3636357752647130dfdd0b9150286dc7b97d41e39b3f79d7271a04d6532bf87ce4ef0f92d095eed571f89749c766cacf7ef0f16eed6c16a0df3d52c416ae1c90ca222572302c9141142e9b7aeb9ad9a2718a08487307b62423e0df37c19f9bf12b408f330cf34b30295278eb0b58b5a250f6d92f597af517e3f4cf68b1764b8bc698bb5559d19deed429c66adb7b96e407172284f81b18ffd6c380d86567ad3f2d1e523df16b64de1b43db496d2dc2b5337436cf68a04ab9038367c9c1064161f204c1b3a96030f4502159db410f951273c44739a01ddff5914b49c261407b3ba2919963fd9bdf3bd4182efc62f6582e8a7f2a102443ccb5f462240e001351898d9a8a5c448b90512174568790b82af054a2714649a7acd25f12c23ee9c422fc63880c947c2dd7e62dbc5edd7ce39572890e22f3044c75778e86f6a38082f8b79edfc161a2447b41183e4a64196fb4834a30e8cf4cbd1ca4d97109d5d4986dd5ba9c26019929edbb25280a06f3bc90268ad384b9076b76ac9e6a9f2e44be5be143ed6713a3040d4111d822ae9e7640113c5319328e2098b7f53fc150311b545cae0f251c6b6cd6d6a93476cf351daf2f588c16e2babb3941b8be4b9bc704383a026469049cad000fc12c6bdce25b571fad3ed5128b85a199d7a027b7cf9bcf6555f76696093daa9569b5d3d17d6f3ab282c549314fced96303a1261194c11039161458036916b4a685e103a938353d700c52d8506baf1e17a0ec4755d514e50626a1756099098895a5ec85e55bb2b214ac110aa5a714ad7f0d6e73f9cee8a192c3591f237c38a3463653b80b1327440c04eac60c116f5e3d3da970b34b68119445282aaa5d4764b3ff516c2549fe96fad9b4c28169b3c6439924fbfdc956e03aa52dc8b4ed014b69f3664c3e952c0935c92500a72886dc583a985b98b02180a4d83fa5e5c7760d0b4bad6be936d09c49c5c3a6440cb78d9a6e5dda0593331166fde8a1478ccba4cef62ee0ba2224b4726ca0ecc3386e04f78fd8b40e86bbb50a53310ec4874bbafc5b85b3ca1e188f252ab77fb0e9accbb22ad7fc3b845ac18c05be64adec72ab716363c637ef1f9488291eae40b20374e5731cee5ee26896dcc70e4e369bf8b121d8e27ca1920b4ef5177387c64da0d3f90f96d308d4c5a55f3ee422f779189b9015af2aaf8efab07bb72d553f00157f2f29f38a110063f26f39193c6c5ea0df5806673f884cbca85d41c212c7867ba21ad697121425feadd6bf781d768581dca772d0245b852f2b9198bd012298d5f423d02653f0cdba0057e95af0d99be861be9eb699d7be7209414c451134f5cc19047a1b8348168ed1268912d2bc561ecd73398e15b3d7f7824e6aa593890935684d362e18047fae716aa875312c9cb267b09a386a27a4cc2dc821d6a7ce1bf0b5e30d7d37ced27961c2d00ad6983bb4d4f251806a719aaa1f773523d0550e1a7c7ca6b2fa961a8301bd26a5325636f7eaca0429d5528f9f63553e5f6a96af9a602489a5ad0fa2bae6605479541d98ab795f9dac258e8261b012be4c21a89a81f4bab8295d2f0ce2b4a543f51689dfc61aebc8ff34707b9f038f0127facca7cd4073980eadb377bed6f6a8e4439bf601653ac6f7c54375e13e63d37454e3ec818d572283f098b3ba27b65dacee36bb6d852e842b32da5bc92259fe8e0df34d2aa9bf6d5aeda383eba6b88aa6a8a317e0863d106a6d0918c70df09f84fca69d31d9de85ea87dbf4a797c6a2e9230eabbb53f154207f29ac91b3da4a4726ca4dab8534907fd209c227081b2d04790602d4cc672848629860f79a7df9485dd2af72a51c439da03fc8d992e95f778b015f7026d1aabaf53700d78f75d0f57a53c5c1e940ac88cb4e8b6453d58afaf7d612af1af4f4ff47ea24545f10b1b30488a0a1aa1f47d4ca4eca82747651d18e4165cb66aa16f6121c949824d09b51d9cf54d69f8e63e8201a242e70d9b5be9b620d08776265e9ac38abb424ede210772a77288434dcc160d1cbc91700f35e243e3a401b9b1af80d31dc70b8d12cb285bf2e2edb0c1d613f574d3fbe5e27f2d43d2b619c6c42dbc9fb39220b9a46309358d5f533e779a338d1613f6a5ccfe18aaa584e91fff96e070f15d4859bc6125de427346de7d480cc2dd418cbd80f8b4b362cf25f12fe9390eba75896db7e8293f406d8b10695e73e9875d7c6a1d017fd76497d6d7589440e90d3122294bf89be3fc7251f8decb01105229ddcfca670666066169f8e83f66502ec8a5cb5692ad11e12bc479d6f6725add46642229091d2d2b37cf2d8fea4f6cc9420ea61d1330110562411a9fad98a89ccaf99bf7bcb320bd65ea45f071b2579ad6b2f6e7002ae38c7d0bbfae8b494dac0a45275a6bcc2306d689045c159401c4e1e6ee768937bdaefa93f2a9b9ba5a225d95957c40900c92d483541d73348c9d379d88ad7954ae2d08d89a94d7c8c2880b0786efb213f4189300d1b39788919fda8144bf663615c9262903c3f18fe78cbede438ae974569e694b9312a4654aa1691c1cf0e0eedfdc39eaa7827fadfe1ec1ad82416d819f56925d7f69f644a9d37ec6ef23ce1fc992d69074bfd54a67538baab17ae4ba7fd4e4b2d6df0b6e4178ebe224201143eaa2fb2b0740d85fb8c0574e3ea6c29ed7ecfa752b2d028d8c0bb78f681a38208d0b3e80506612d454153b2c2e9cf862dd79c57ce71a3abf34742598e2665a5c04bad2c31e9732b60f37c5c8755b56ef94ce8fc336d171feadbffde2ddd832a2e832921b3593bdb19c6fea427e306090687fbd1b6fb153f3cb3bb5ef4030cde2981f0bfc3657c6582204a1b7d3c341d6e126146368401f11f88c20d5d2b7bc9f073b5d0f0717212312caa731b7b7d7962de9ce8d407448ad3169313769b32b57d2cd7e514b4c5daf85a38b7adb20d0953be749ec0942dea449f9a7462cfb97585a1b0007cbbd1b058dde0cd9865e5a249edc86df1d22281556701e8a2f5d0ae156d793fcde43b3c282c7794ce0c95db8684fc574a7a1b9f4d3987ea517053f6604eb6361be4d9019f81daf03096c7637005ee09b6d970a342e06fa0f756ea80f6a539d84e42e831d95d2a96a0e19cbd87d37f628f52fce74caf7f58daf28ec27efab309fbd990966a020b6bd743d4526fb7b011e4da85816bfa07c2b842ddac1976d44c895ac15c65f7f9c37a04c735fb5d44d2e57a822fdd9b0328ab793675a668f91a9ac851b17788b2e365e13217ead4fbff2cd12215876e4343817fb30c90c170d665fa7a6c6844a273098bd43a2a125e8c458fb115bbd4aa75526ce7b334974873e51c9d45487d6de6e026d2747d6e10945dfb41ee50347c801e107254a2a6af398c2e564922cb83f66acbf579e624bf16d36eae668e75b5074d6f628a2ccae5436684e88bd389c4b2c606b80c89d59593ccd6e633cc867c74923d69875486bc998144f151f75733cb12581ad18d04488cfe348f651ed79b084166db399680a70ba2eb6e298296bc0ff1b651d1299aa9303e1eee7888dd0e3555898461f1025d2f62c817adbbef09531c0841fd2062d7b4873e2b6b6e919e859c77497c707b06200e8000ecc3cd6623d3abc32efa8eef13add1dd6405f28db32eb99ab482fc00e4b68892afb6deb40bf6f0c77ca2305a41f828ebd87f7e56b11008b73bb9bc2d9a37aed219cc96704e1c9a39e76cc2a10aaa2ab53092bd74c141d3bdb95b95d2d02791f7558babc54c8e64bca5329fdb2b65d0985fb6b744eaa2bc91bd52840aa800245055419ab30b097936a3d787a05843a8bcf74578ee58211b8b561a2cc6a10c2f7ad2722142896afa2af09d1f953b88542f9a1b9362854c79fa41ca545c4114cee814eec3c5d3ea7ce435826e82aea40856dced9c662909177b56c464aadc1bf0ba2e7647341552876f745262feac820fabfcfeadb15c6265151745ecc440f1d9e1aebe398904b01865954f49a4c3e045cc000ee21868928b3198e51e380cbaa0970194683a6f751f859df158ddfdd99ed916afddcb213de35920194fd8e02db225f99966bccc74022187d5283994959f23545242a1e47d7ccd2ed47a22cfa94dfb38ff0b170e3b19560ff33356dd7fe0292b493c7374db99e2d1d5bd2c9dd406147de1f3891b662f1800f85c5a435c90e9320cf78b616c3039777fd926cb1d44aef7e3fb40b21a070cc10d64fb3ff6f07b19dc2322bd766cbd9fc2b66a77fbc2513fa6c818947fd531395d7617a135d704dc9978e5309e2c7a216fdd1c846d1126875f40733b30c15f4b5c9cdd97e02cf19d5b2c9bcb43813be117fc5ca0f613991bdf0e1c85ed688c774f478654647085b9d47eca141334012ed7660617ee81555d98223d026f5ae96a71cb9b309332bce3202f7939d83d412877900085c76789b42d2f63e41b9dcd88e1e0d2a96598747de304f863a34dfadee5951fd9afa37c36232c92b59e2870b6d12273af71dcf06bf546bf90ed45960c68b3943fa96977f7fed4694ebb6972f36a924f04facda4120d415b72ebbd9c9db0cceeda21c1f84222265abc8ac03a8987144fb72d4a5448e5c868367b7e356bdee6aa6cdb073d3414e5e70945021fdbb0ef84f46dcb816169afa13d22087bd364ab544fdc6b1469cb18011b0df75e21c650d9b036d82caa5550f918600d9d190fea36640c6f09c9c18b610fc7dbee9850c741f2948fe0e88c07c95d34f4d2b7a1149cd6126cd79a424d07dddde111f2d0c789b6eb2212c51cb60c2315571e0d18c09ed6030d31627030b71401abc407412aabba2657cf2a8c42af39bc85dd1020278aad6fd1d63ff54d910250d3f7299cacb6a46006bd059813e77121012ef640a8cacd6e8dfdcd2d7db59c1b669a847f6b4c52709f65edf398a27fb0011fe90c456ec058e804b3e3e0f7f16464746ddb6ea44dc7a1d79cfdc1045049efb34fd9253512eede7d645a5aa50a8241d1a23d1a27ab8924944f9383f1e1e1ecb638bc1032a2df3e81d48511586ddf67fac473be95d1cd50cd5d6658aaf3b0485be2f8f6faf3c72c5603c0f1dbb9a8b281942409c3ee80e4f4b134bc7a17a10bb08298686967dd9f68af3728230c3ff25bbf858edb1a83b09af14cb174016c70e2bba71deb77dee48f9d9faa4a19c86dcb4683473e6c2c1b9b73a23c3d2026645066746f6265fb19a5335baeae38cd5a1ac8840fe57d929d9d5d7fe5e8d2320b6b9a32dc96e8cab3695f822e0fcbd56625327c275d2a9446e382943be8cd913c6924a38535d5a9f9bd039c6bc4b12433b6b110b24f7de73665debf4e04813600cacbb0b261cb3f862766db6803c844d5adde87389a1d242343c263336b90a217a7187d4bd55a45cba756026a3290dc53ff738627f7b10ad681169284ccb24c72d78000619139128ae20bc77e4d87552c7a1ce14d360218ae1941a0dd858675bae12635a31e70ec5c94edc1f35ad03fcf641e7d6005d7c81b5591f160df2fecc8be94bee95d9d8b2c59c774dbef29ff21e7efaf7648dad1247f48e73258d2ec2b6c1c24ade8b3c5bac21df28fc45f3afb44fea38d02faf4e2e199eefc0237b3a54ec8fe8d01d3e41abf9f082859aabaaae8310804ce0f0c02153c966bf23194ae6405efcb141db8324fee9b07aaaee46e3df9b620e5ce56479c656eb0b59870f04871c9cdc8ad0b3f8d34014df40fb9fb59e41088ba3a1806d64e3700e5db1cc904762d9d9e11d650034acb638ac556fa7a1b7eca212816a939938b15be95e8ccb29da36922e113ca51596f74b8a64d894d3ae9d4078b9b2de60bc5abd09fc940f1c77404ac61fce2254590eeb8deabb7095a0d7bbb9234a380fd5304bb81ce9f24aba664af4df42680458c05b93a95095d5420f7c5d679b262b32165f64a64198a4bed229d2666f54a771d30ed835ff82489b9655316e61319e2e096b329ac0f1a52ecfd52b2710241587baab557a371f9b0d4442b4ce014326b5f66c75095983a6dd6571c8636d5236970f2d22f6d53878677f93819da165c5c0625a7feafff412554b642c157494270444baa8cbef4ba50d04ba4c7a00fd443b62975b7b642c9ce9e442e59390f4f16313d9a73db9dba979ae77968c509243417491d049b95ce84e7501699612a87d753125fb37409b18e36dde3cd4ea13111456581487bdda75475cb41b75b722883b55a87a09bea67fc2621f263be899c007adcb5824736c50561ccd7a1721138c30c68f83b9064b2ac980bf329cf066d17fa144e05036e4327780d40659d08996656d282f5e690a7b42dd75b4e3c72129f0cf5b87e81874e4d9c6b13ce00ab72673bf4867c37fbac138626412f4bbbb18b406eaddf353854a8e6699c287c21e7e7816ea9508224517be67b5fc1cae3c3fd92efa6f2296d0660f3aee73fd1e5199f73a29704bf01f647edbfb39fb87e04e94fee71b67dc32d5cfb8264fe194886703937dc64917b4bf47cbea345c237b03aae62c8cddd0d4c65ce55155268eca527a999c3f4f7ed9991e2a8b635674b13193a4bfe9538d20ec7523950369f4ae791e7765073e2a9dc0ec691dd0e970c68161928beb699cc91deea630f05ce2df4708e42405a0373ac58a1f04bd2445f0571157fd53c7c6a713e04add171993548ffbab41f89db04fa9b5224e0db8e3eddba26581192134fad521f170bd08756170187476f8ef3889835ddea1b4fc9374b82dfc22ae403d15aaed14225875856849bf3bad7407220981894e8acfaeeec32d6c04dc3ccc27a276da0f30fd6e852276c3a906e9ac46170b5b72685f4ba916ebff58f714c618bab52139661488a39e49ace910a08d7d4faab08908370f3718d0962a0dd6ad0748c910cb9077f194f11e01447a89e74743dd2ef75ac933c6ae2f4409ded0dca5d6f64448c872e96acedb8fe82dee8bc33055aa30bf245206ce2abc92802da67a1bbe2c268ce7477bb674442d5623e4575501f20e88c44d6fdd29570e6422d1a4d2dbb554592e879bb3382dd169ed766928969e58ae4f6bdb8c8e06500fb8721a637be4a4242042f4132eef0e2500f6f5891a920d107c869c9f5dce2a305f4e4a037622b2187ce27b426b2c2164884e38899fe5d80b50692734803b1804a3d806776abd0c753e22ed0bde7e857210dd055cf8be1bff48d438a59c1164c4a0daddafb21eac18538a824e4a42e8b1fb020e8d5e8849c3db824f9aa64ff41bb3bba0b31bffdba1555d7946cccc45e0f115ede10375385315fb93e36bfc49b35e69cc052fdf906d8b97ed706ddb4be3b07bfc8bea525cfe3e924e94a5f7a1df02047f5b372ae1bcdc005fa85385960724d66aae36e3133b2ab0721bd74fb898c525858d0a2e212024014db769dd339187ecf7c0397cf4bad15bb1e64bd452bf48cebcc2eef4d2a01995dae06cd17054ecde2acacf9c51a917c5eb0e812dd4f4475c0e613d26646d215277c399725c32433e39ad26c00814d75dcb7e3730cc6ca8c3b7304cdda6a8bb5ef9f70c77a36e2f76e1bf804f8cb1e0a4fa84ca2da6612edc2f017b5834171ca814841ab9a6655d416f729c4fd22364aef0f38b17187ffc8cc111b47da9aa70ba1f99a2dc61d3b18a46bc93d3d17f2f50a07e61b8a86fc448d3b822d39e671fc790b3ec0a46bb28802a826f9921ea74951c320402345367891092ce2bebc03cbf12a828dab23c1e8e652eb9c410ff8282609eb5574a9e8a8bdcaf3154056e108f8d36cac855be85db701552d28a7be2c91b27e3e8a1bbb15150114888711d0de05dd17519df0c822efc33fe75a058455cc2c9bc477082dde69e4587713f1569e08ed67332bffd73933980082e72d89646cf82328576112dc93de22179c1acfd20f0013a6de6d231292f50fe21c885f1d9b2c0f0f9d1c2080150e39b2f158043439e5f61746612650f4428486e56211f2e1f1a33566b1880326c66b652c98651c7fc0bff99cc5ad2c995c5c3ba36bdadb910609787a9da880f00c079cba6dc5644089de4189c8cc1b95139ada81377062eb3b230fb9e2c2c4771c15b8968caac7928bcf08a05ee1adadad2c2666beda13c8f7c31a8385cdecf6e37090cf50302eb3e5b0f73dbea8dc9962ab0475dcdceeacb327d3820f4e1fc786a8ae9a377788310c29835de36336a2dedfaaaed2ec81db7dc4fbde0d46f5cad9af765a62a513c8479d2c9a0d0c99d8c1207c40c3bcc02d76687183902f6420e962a25d19772f2832b8437d3d976fa3227cabff3853d24654a8eda8ae093b6273d8baa0455f25693c40e285bc4ca32408b2e7f59db359e9e19d592fff7484126a847985f537832f293e1c1b9429b318f0fe9b08c116fb117af649af20e05fdf752a3b47da82eb1590739ebc1555a3264ab68f8a5ab31fcb90517e6034c423546ea0eeeeca397d5a5d21355352a5b63dfcaceef67f163a8d2aef7d145ef1da30e46029ac402f3556511ef577a133248add73042c2c0c0d6562aeab8d48eb6e129aed4bc4dafeeacd7d3d01e61f013bbe3b62343bc117b707e45b6b6c9f55114e0602e0bbda8dcbbecb0426102aaba5e95670f84a837c8472725032c59470b6e2d3959af9a61b73e275b3c500e52fc0dce2e1f0161ad6c9b2625f9d335ca5b22b5fafabe549e208c98c98ce3fb7c2312289c04e51124149f81e15e6e7b122cd8f3d064673ef46fe1172b9b577ccb03ced672623885a13e422a34551bd508959c0b57588156c9a53fe60c8aff7935576f78c585d38c7249b9203eb70e179a82a3c3f3f335cb6698451e16aa2fe3e1fd92c7eb1816792a71f1fe35353f5724a70b20c1dd3d7675e7d3855d087ef45a36231b45b6374d69076c2fda1f9da0411d2917d244c703caf3db86f983e2de3c2af3f1cdc6ace139170b09f98af92fc615988a978ee0b982006f8b709006197df489c966c33eaae9cf84a2bbb1ea5ac63fcf8dccc7e40029537950998f65ba51f90dd762689196e047ba195bb36986709dc7312b7dccaa22d431115bbae9993c2839406fd11e4011ee7efe83845d60830870e80d230b5c8fa4d54dd145ca6ac85c67601882b1d757c0de0c1cdd63f6ccad4110cb2cc66663c6a3139e82c518018a0061a9ec73abfb85c26d26e3b5af31d27d3d0a22654913288d356df25a062a1e7d973bf516038ca3e716119c8ad030f2ab79b3e9ba8037e80fc332240f0e9510a0d2650e7271aef9888c6d12f70857d5e4c6fcede0e9c10da0922bdc3896f0ba023c0a26c73072530e9f0f18d0866b10424047d48b0ddad2dc54d57183695134094c0d248768331f41de1c7fb5317d737904459619e6bfb48202f398611bdd887811d6fd2b7753a73972d84cbd20e8c4cb6cd28611d9221731f17a3a1e88fc685aebdf4b605aaeef7c77f78c20f437bc474720a83b1bffb745ea9735aee752afa90ff18e72c523e14d915a6eca3b4096974bae85b6405d946cf5c1eea7c1e28208032e4d1d681a39a653f9ce332e1125f5c60bc9c7299cc858bfcf119e1febdf0621b9cf817affa4741e4a6a29c50b54589d19eea75568e12d429af9be4cdd911ed747e251439eb9f7dfc4c426b0a2fb2d7b1acb6293aeb7ba4d76e6ee9047de36d674bcf9bdedfbd89171f35341cca9a0a56b83f1de7c51692cdd889ed63f15c7117a073cd428f1c81d4d5df3d18d982164bcc270023a7e50826aa49bb6e0dacf61721f2946e14967b6bc0a63b91c37922cf7d47ba58deb15ad28b53e0eb88c8ccf074325a4e971ef72483ca5ba2223f60540fa92a1532f87e1639f1c165616db9a00e9f4f3185fb41de25ae3368ed1df50063d53c8b208bd408f6184bac4e2a6b16c83e984d5979228972605083b5500d2fbddcfe10b00cb014569e3d53477fdbb74c77ec39f561d7aca3825299f300dcef56c585a0cfa1047a524525311534b2dc53c27b7189b5f2e062e685d46333ba82c049b9574781fecdb0b148e1f95d6f52abdf88d60d687e52177dd65f7233cfe0131193f83840f975b96cb94163c59dd8114ea52b4a2551458472ddecb74fad32f7caf86930fed52e3e7bd1f7af9d13a4e11480996e5d778eb78c823186f915586fd91b35c4d25787f03d02e703c153df8a28f32c3c1c1b16482b57668499a86482723408c61ed7640896d5be2ce27524def35953bd6c635ce47f61c95bab971daa63813703a34e7d3a88676b9666980527d042648e4b5af030da871a74f29f7d16e1b036957e7fddfed76ba04fdac28616763c15b66906f9f6202d1fc0d96533c00a3a1fc276ab63275508551e304ca07db1d7040e428cb0a2d2d8219a500d224b11ba326d2a2f44c6d56946a43f4cbfd7e1f4313b4358e31127f66db0b658e0b8241b4f171318876416ff7093335c45a5111c7f36100a73b22ccfd501a9db38eb96267d6f75ac8788fab198f2d9ed0596aeed36651917d6f0fae92ceac1d6a8f6db266773a3bd758ce74cc47108cec8832cb1844110e195f653d7ce3e9e21e4445269da1f3287d4c43377bfce86facb3c1da6f792f74acfb84f53157bb9205187fcc249b104d0fbf6e358994931d03f1e87030437d2adb556ea51e5fcf2248b7997b649744ffc971f3103252945bac87e84808479326c0cc88f322151cebadf73b57d1526f4c1268990307a4f09f8ffe875d832fd2b4aaedbfede3390c05fd2cdc9010be5d93a7c3238cc73de44c2f02551fc2e346a1d09861d0b88ca1ccc98104ec52cb12223428559f62fec35169d17d7897d686d5f9e7f9824128571809df96ad8a07c602b725c8ce79147faaf7963bab0865430aa833368c2c445698d004dcf3730cc2b69dc5a242bc04c9c4aedec00e5964bb82de2fd948d1a30809d13789e5fcae7bd1aa5916a25a8c93510d61f2a9d5df251bb78bad4ad8eb12020dd03a16f019b7024c376f5bf78f2da40050be4e16f877c1917a3dbbd243ef91598d720f98b8545e9822b996323663f7bbe4a59a4c5bbc5f1247e7a2cdf1c9d66334b1b72c1fbd6610213aa1cdf4247be39c361a7391b18d0191de4b84944c2d7d009b3542277549fb6b88be3a84af62e252b20470d053e59042bb469ef46aeb647c40b25d0966c3ae606c688be176fea2066d69165349b14064b91f7e34fa404a2b3f9f211b046882ecd1ab12261f4af40affaf3c8d85ee3d6868425392f667f9feb2e70cfeeedd1fd9655a31e4f1efb8d93d730a33eb0853c0d60ea8a761a2f317dd05e1906d03417d2cf66badfb53a84bc4080c607985c9640cf9f74a5293bff689defa07031451445e3d6475be82c968a2671e5f3a7ed5615eaa41766e4a7e46111a23b41b905ded5c4dcd8d8c40da67f12a01839a38b81c0650399d904476d5f2d5c6383764937a081f6c4d235318f79d6675b6ca9ed31b6bcafa3f45c955e00d0bab72b0120315c188f26cbe8d59cbcf8710ffaa56c15f8e7ede3eb43782dbdc70e7a98987db314e9705d00d67a0ecea673772e0615ecb3833d88b094cd86ea081610a261ebfb2df5c88c315ac59a1e39733ccef7b80e3279f1c97c4f89c58bb143853b26ae17bca9c61b731412e88491a9ea3eb2b5e31388405e7030ac7ff5c45405a3387c6a292ee13413fa1e1588de71703f8c2c69e2482d053dcdb6f93fc90265225c8d2e2d7130478e52d9327a8dc1a430e006b2ec821dffe20b5daf89b0e0995fd589ec116e1586938d3ec2627551bded003a6376ef59907d0426cf09b8d13c3d04a0054c64a26a19256b40b984f8d734c1663736c4f8821fa054bbf226150b4b29d22d60fbd02c82fd6697ef7bb7729f4f1e7a249fe6a2bf86ed8b2417956ac63860ea198d994dd0f5faa8cc7e9cf42a69cc8f99adda42352eef89afb101dd2add0b1912106c0eeb99dfc89686f4225124856bbc2804b6441cd9b326894590520bd76a855c60f8f228e13e0eff37abb0d6ba17418128d7bbad6f3cc2fb0ad026cac7df7ac5b056a66129c93718bf9d45d72e3177d4ba839ef4410b52c75d90e00f2e513a40b7b6d5c6bb19f79691ee311f466ba8842e1a637fd73a0039efe5d8d6e2eb1294b26ce84d5552792e95f4150b490bc70e68033f1b9498e3a2268ae9cbf9ad714c0e0f71a94c8c6facf4edf8befb6a6c77b82583e34f286201f35d5d3869ea4767c5fad1a1c4551982d978c1ee6a7527e9406e08305aa063fa45e070093ecac1f9bcccf12d7e2d1f74781a3e0dbf2f1b5ef550ac341eeb53a03bb962170cc94c45a1e9ff3ddc083d7b01bbbd23662ded6eb63fdd63e8a7f5a23532140e6d36eef6e4f6486a37d0bc1f3a2638d4ea1804a1233437e65ba804d89bb939998ab5e98aff601bf873e1c0d9688c06485d2f16ced82d30b9ff73a84587611bb6e2beb70eedd6bbe6e88b5e40bf022c0d49c2077fc2aad446ebc4b6185860e54caf1b4cbb3ecb69f60a948811a0fe2d24d1b81954163294880208c6301a8f88739c6eac21c1f573dbfab3c95cf5de7cc0b10a68d445cc1d0762e30f2ca7ed2afcc2a9d6e3d9d15c0f0a16cf5a4a616c7d9546b83ef3864c4993ac231da81c28312f93f733441c0ff285ddc2bb832bbc09620d983589f22384e2ec6854f4e3a1e0954af193c05b222d9d9c7676e046b08bde95cb6097a4dc9db6e371e74daaa0193cbc318fa1542f8bffdd5d62649cb93f5c270c5e7fb500d61c031ee02701c43c802cd968dc9334b5ec9c5826ed7eae13d8a2169b4e4398a4d1738c3df5198342e5b330f869e60a88c2c94d46f920934062f609f3daef65a2f08dde307b49fd58fbbd702d51e2e9f3bfca9559981af22477aa1529595d338c1d60ca3fc48a5a3b0388d7f8a95bfc979df634b412e8c4e15a57789aadb72db3682efd369dfcbbe4b3a80f8e44ef048cd11be60c966bec7b772bcec1a82b526c69ef4d16f85fbc801c86e63d667d120ad0f8f4e99b6739843367af653a68ea5009cdbf602c9b80bb36dc52603aa644ea5ec4e8decd030588b5e19e8c6725196243a6547acf3858d35f3acb082b53a0221ea5fee4e24c59cc8e834890789b7661aa8eaffdcae7ed0d9985ec7e522ef4bcbb3a745850b1a91556ca0fea6506bdf0e14a87336af70773227370b59b27cdf4e512a264b0881b7ed148ee920327854a56d5e81553e0d8eebc107439f5f07a6ff233e6e86e885e9c6c22a210ccc512a666de4989c2bcdf3da33b0e542f8224c05d945e20a54d157d5e922c8a75273198e6496bb5eec9584413293658bb96eca9baa273960bd8cd301166a07dac9b1f0353aa0ba825e83db313e2f956872d26d264bf3232910c8af0127f40f168f38d6757cd69ab1921d71cfcbf04b49e0999d44ebe78627532d81a1753ee395403a9a8483197facf1ddbda27f275540d31d6eb8f69ecb4ba767b8b536ce8b09e2437950a879abdd1aa1f6826fe0662c0719c9fe9fbc8616667a40fd5e7d8f275b4c4c76d386277923bda0fae3b82dcc4d74c2b5aa77896487bb9f83bf633820594e0af73dd864f7a6670149054897351386f8ef40fff88f889af0fb05ee6e68ca868d60ec5dde1a564d8afefc8ab627ea94679a3cd339e464df26ac1fa53a59f5be6aee572db7d3894898f076ccd496b06768730edcc2ca6e7dce85936a6a61418fb87561cc6ff10f8fcaddbe7dc3bd86eb47ae57139a7f75cc250d9946aec83d2dc6c7b2cb8adccb6bdab4f34da7de4c4916761cc4b36ab14865cf42b81a9727de20935c272c24698090a3c242db0ba304b06c868b40e6b5ac42cf5235b1a779220e6533000902e8d01e946d94b5c6f9caf9945204c0b5cdf8ae9893a89b6ae8f1584cf7d2664e1266a2b774cb1203c38141efec62e568a38a19164429a95da75663b9be4a9987019fc21b3c923f58ef758b2e29ea52a475b613a8da049215749abdd10525f799fc244209e6e4b411a10fd6c94e1e1f9132620426ecffd6eed934b7819eb0eeaaf9d169d92af98bf2f7d430f703c877c36d8253750db96da2de16ac5348526f607cd89c0c8d57a66357f67481a4e067b3896367531e78cbc9c45e51d402b3cb415988c81137ae6d1f018e17a682dc75665e8aabba3a75e557bd35bfe659b60275ae903b5000e2ce7ba8fb9354ee2239ece39183ea0e64f4860255171efc941082fcd7bb092561ead6af0efd38be83235805a89f11002783f24d755f0c85a1da0aef667623ce78892eb8aedf336b161dd53ff4618246b2093e00a458e6c2a831f203bf40143aff69c006f0ab9d921df254340304e5d28730edfe5907c8bc6e71a6e1665b82a6dc839abf72109d211d60e2e1aa397bd51792b630f9f3d41f30617782408e65d349bab093d3738cecd77e9cbecf4344a96696026373516d325164f83a9b4e4d0ecfe4d46a029d4c096d63ee3fa7a3cb0b646583a8df58ffe08c71eaa0adc69fed17c295e447982692190c7f4ee223dc109ce30c546eb1ea2fb19baec502aea3af2ed911a8f1b229d1748be3c529b6b0bf7b517b51b273c1b90001d71acb6a007b321c996ac5fa3cb93f2164d170c1cde7f3ce119ca6b870d0ed05c93edc31bc04bd4df0f0be347dea7ee648a105f8aa1b105724c94eac166ef83c5a20b1171b747f54e8adf953c6dd7f0798478183387344a166dbd0fb45b62d06c8ba0b97b9c053e030e9ecfbf779cbd077b68bf3e3ec155200b105f50caca0425376aa6c5c63a18d5d68573453ee2b3ce5d62d6c185a65568f95860a5e53dbef923cb8dfedf6dd4a6dc12254b9a8a27233fc963d32c4377876ce89b7050056aa089498422387930a383888cce33e98bd37e660abc4e9056e88014a764d32398866a0e1db2f40f2e561a6eab9740476eb9eae5b1bf5f96bc0630b64074acc71d6818681a9e3532399a081041c90d61407fb155bf43edf1ad788daa7db40cd90797074aaec83cb99e9337fd3e6970e8f2644bacdd53ca55c99add5205a8ba745d5f47ca4a3e9fd0523448874dd35d00600d6c4156c7bf06f6f9b8125e05f765b23099a1028889770702a346604759c2859ea750f988bd5e62d4f8d5494ab2b08977ebae79b92a01931849955a0618ba90beb47a96c3f84bd24b9a8632aed90b8850f073651c6c97a6a29313c4aeb969b6371c4205f558ce3d231f98a6450262767fa3969d9b35b3d442bc248dcb36c4df4cb691bd29147dbf21347fe56801511454d662bc4fa1a5e7261e6ee3c633b323098d3200e36001d3748e357caf11adba6643444fcfaa1288bf9c5c16b33a9311149a578f69b299e3ab02b6f112fcfccd563f4e9724196f3356829e8b9b7ab5cbd45d12f78e0a962a27d184830a5df800f5d6b7d98a9c8a82fb75a7c34f8fdcf1ed7cdd651f8adddd130523f2b1850f67830e5840555b02c087dd2e6eda80c35b5c681315868f68ae4f8c9e5d4da9e656f500314aa173cacea71dae8e161e95a3c29374416661c596cd5f0032bcffd21c59d1e2cbb649aa6030afe6b014127380abe4a5b32a9995f955addc23ad455d7dd5bb328037d5be7c31ee592d4298f2f0ccd4add8cd3f0e10bc74c63ca58bc707e5168c288081f55584dcce7d847f9a3596387a6a5cd57aa8e273d8f72b958238b9c07d3ddd9f9371cdced1a1ba40689b92ba5aa8f449b6342a8e2e6eae21b56bef47372f75dcaf1d2d20319356494c166be3821f4445b42822156a93eb58bb9f011a12360aa1b637189680ca003facab90f58b03c6f7f9a897793182fb3ca1071d2505b3f5d2e642131396d377ede0acd9faef1644171f895bf5abd84374ab6d48a63120ffe3d4ce49940ef21dc4b4c19b2191235c96549a59af0725ebf5cf6504505791f0bfe72d3c3bc8d5e644e9c20cee32030c1dda49dbb4f5619d233850cf905cc40abbda7bfd51655f978ab364f4d3fd378646858f0fe42a83b3a3c42b3784ccc1ba473ef4bbcdce7489183cb1f883fc14d12e402c328ddf1110df87386304550d33e4f5988dd0aee5657a20530f97a076f2e88838ec2053d9425e466a3f654766ca62b828bb10f35f86d6f0afdd493d0baa0cef02c8bb45a3c561fdaab39d1b18426a926503d95174f179afd211a98b2bfca89a3ed2bf7a0464f95aed9006e9da55cd63ab908abfaa22915826fee6" + ] + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockPHASE0.json b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockPHASE0.json index d9e58d4c4d1..7be48f5675b 100644 --- a/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockPHASE0.json +++ b/data/beaconrestapi/src/integration-test/resources/tech/pegasys/teku/beaconrestapi/v3/newBlockPHASE0.json @@ -1,8 +1,8 @@ { "version": "phase0", "execution_payload_blinded": false, - "execution_payload_value": "33141069577231489142570280012906228567895582634247424250018499409257408942535", - "consensus_block_value": "7636749530225487814374999097680153891790598176358585351326080888526623976231", + "execution_payload_value": "105670341733713205478222391549927926503202765306297535497261713012493411499026", + "consensus_block_value": "114322550416336051447991521757964728159414731458556809485354459549587351467164", "data": { "slot": "1", "proposer_index": "4666673844721362956", @@ -49,19 +49,19 @@ "4589007099177470570" ], "data": { - "slot": "4580744678799082634", - "index": "4579092195582398506", - "beacon_block_root": "0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c", + "slot": "1", + "index": "4580744678799082634", + "beacon_block_root": "0x17348c3f2ad0733f4b47b34442744b4a2e03a79b1f52c8e8922ee71060a05b1c", "source": { - "epoch": "533461240", - "root": "0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565" + "epoch": "533653615", + "root": "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06" }, "target": { - "epoch": "538462976", - "root": "0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650" + "epoch": "538655350", + "root": "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0" } }, - "signature": "0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc" + "signature": "0xaffb36fe3e48b5c29794f85515b9a3adcd4206fec6dddac6926d0e985d96a9ade0e427f911d56dd90f2644af13e9740509147d149defa9b0763eecba616e0815e9a91c25178860be7d4196a9814781a4576ba7bc6398ef16b9bd5f88c4143bfb" }, "attestation_2": { "attesting_indices": [ @@ -70,127 +70,127 @@ "4589007099177470570" ], "data": { - "slot": "4620404293179370891", - "index": "4618751809962686763", - "beacon_block_root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b", + "slot": "1", + "index": "4628666713557758827", + "beacon_block_root": "0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390", "source": { - "epoch": "538078227", - "root": "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb" + "epoch": "537693478", + "root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b" }, "target": { - "epoch": "536923980", - "root": "0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5" + "epoch": "538078227", + "root": "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb" } }, - "signature": "0xa32991816eb9f297553b4732309a4cdba7b33287264611715b0ab3319bca19e581da6e2659912a4e0e94aafc01c488e30ffc96ed14e2a726b9d3c618405ee0bf54bf6ae7f2097465cb27ab8132ec24eb93d3c9159475304082f7f0e452b93b65" + "signature": "0xb7720f152c38d7172a82186892a68440bc4d285cc8aa92c1f017f93d5f61a29cf51670e4f944648bd8df82d4d6eae00615073d439389cdf35fbd7670a07ef8407c7c71a16be062fff16f351737ac99f006817ba43a295fe5286dfb4ba7116e07" } } ], "attestations": [ { - "aggregation_bits": "0xfa79cdb89d0d51c5cdd001b7425c6d726750a9d5f89ade6ed9890ce3a706140c399a5e10c90a819094b65322dac7501f7c75471e69d4567358d8ca75f7c1b3133ebecf006b369a1f36efc5f2b706d5922ff98c58a1825a53a864376658f816600cf021cea843d4396502bb9c74d1510afe26036f89f783b4f5c7bacb6649c46f217a6af835f312d6fa253d2bbc83c07993f4f10de2ed2d952689379dbe4f794c1a1055a6b364d68e038deec9667f576b3b9eca5fcadd6298f181e1edb876efc3d0975ae14ae9a0ad2f1836d4c3f1080a96d8ab7c43b34bb2eda895ff66be698b363cfa4be33da3ec94a1a7a90672fd12c4a59916bb937e78476e4f08e4f4031001", + "aggregation_bits": "0x88e3aeac2cb7509e753b73880be4e95da67b35193a1a8d916d3a5f3b61c59b6d90d866ae7ee81a10a9ea025ade39ad5b978bd20bd2d2031d61e8aa7b5090b08248dbcac0698c25ea7b858ae37e5347010aa764962e4f70513d9e2488a9808d0510dcb3dc9385cc9c28ba4a1eae314e5c3372b3d2387836dc0750553f84b1b490b7fffcb2824b614596050fa2ffed45b30b7db4e67cd782cf0446b5448ed43cb01991cde29c15b0a29dcafdbf29840045c4a3d7e58b93ff391e3ae281185e49aeeed12188548d0dc8e904edc1c8a9831577d08b0c708dbb1784cef981e8363efb46d26f039c2561792d1a2e81218eec593aefaa25bb280fbdd25f8103381a51c601", "data": { - "slot": "4605531939934246443", - "index": "4610489389584298827", - "beacon_block_root": "0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b", + "slot": "1", + "index": "4615446843529318507", + "beacon_block_root": "0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6", "source": { - "epoch": "529421377", - "root": "0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2" + "epoch": "536154483", + "root": "0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0" }, "target": { - "epoch": "529806126", - "root": "0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd" + "epoch": "536539231", + "root": "0x82a81c3f096d065c7e3f5d7df79bd182a53c9471a737cfb9f7c4e9ed95d0f767" } }, - "signature": "0x8f8d16b39e14569aab1b712e5c19ed51afe3600a6b017e8ab432f43a02ee720a733c33ef087d2f3653a9701e8d8a836301655b9195c0373b775c88ba1368e5d55354a70a3096bd26dee29dddbe7a4820e2b1653e84122beacbc01af7d93e6bdc" + "signature": "0xa9aef1e37252740dedc5fc9886810459f7484555aa59fb3876803fc4924149cb471ffbbd9be5324d952efafc3de4c5f705dd02134916b2afa02194fe90a8d1e8f58ebcfe0d33d0b8a97e71a3f7591cb82c37ba531c059a684b581d3857f05e3c" }, { - "aggregation_bits": "0x4ac567b296efbf7cf3209e87096a7a1a50fd523400113f917f6584a5a306f06b2d8da9ae858d47ff2594010089838efe41f19a78d9aae27c2ffde26f278b8681db9d091eb72e7cab3e449dfccd46a270693e1f88f197324e57bfd45573315cf9fb60d770937b32f7c0c6ce1581ec51e6b60f71acfde304dc917f2e0aa7872038b7d9140d15f7927c23a0490a74c2b0aca2773fed9217067e4444f9ca93874e4ff8407111c3efdb138b97c6d4957b6a70ec1debb283e3d0eb1cfef068adcffbf057d20fdc339eae03f0fa2613abdde8158a7fc40c3cfd1117eb6f8c4ae21d6b2ab4b57ae9a8653a34451aee6418c0c3609dc937293f5f5b346a7ab1a0d144185101", + "aggregation_bits": "0x0aa2e4365aad4ec5115dbc42fc6bcda2a0739e4b8c6c07334b99338ec990c7dc93162171b1ed0afe8b1f151348438523b428076a646db8375993d417cd79f1854f796992a8aea702eb3180373e7ff4b4c53ef3b306a5af7f82ba3a4a362af88084e7d166dd0ed5026019cd4f2c4fad16566f927d0dceb14203e8abc293267466c487eb2b108ae043792ff8e8c56e9fbb26d98381ad35e70558cc74f74d1d5a7de764645e15298f90a9a4292e58188deba564756775d54bad38de697be7659cde395c60f403933083c4e71881c26d15c83a61359fbecd1c12d8f31c0d440c128c416e09ee2d3fe64b8a4c737c2f604756d08d8c1f77d4623404e031805797412b01", "data": { - "slot": "4544390030852162633", - "index": "4542737547635478505", - "beacon_block_root": "0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd", + "slot": "1", + "index": "4549347484797182313", + "beacon_block_root": "0xcf2c053f899b836f534bfa2a45bf23b7be4890b9815a72a2aec9f70eff53d592", "source": { - "epoch": "527690007", - "root": "0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8" + "epoch": "528459505", + "root": "0xa8ea103f4904c5e568c52bd49eadfa1cb142929514c9202e53c7707e4a92667d" }, "target": { - "epoch": "528074756", - "root": "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8" + "epoch": "528844253", + "root": "0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd" } }, - "signature": "0x90309dd491ae6ed51917dc305a3d4ae68d0a0d4792c7eb59c193bd03605bd94e61cab37502de0ad3e6162bc02427bba80a798b3670d5de82a854094016cc298b265371345c0e3ac49fd44bbb9ba0d4fcea0c1a80cecb60e93921d907e8c48120" + "signature": "0x8f5c34de9e22ceaa7e8d165fc0553b32f02188539e89e2cc91e2eb9077645986550d872ee3403204ae5d554eae3cac12124e18d2324bccc814775316aaef352abc0450812b3ca9fde96ecafa911b3b8bfddca8db4027f08e29c22a9c370ad933" }, { - "aggregation_bits": "0xe8c9759f0840f980ae956b15fc383d992e7d4420d12ba5bf32f669f446ac6fa388e20e5ce96e9266dd98840179d2cde3cabd9a8bafab5dec9c2e89f7f78c989e690548603984803b80c82d7b76443194576a1ce49da5cfe56f56e83b745fb01b5f18ccc86d88f5a22d927e64ff0b8e880893abcddec45b268531c4a0697537dae643a24b1a36432f37d42962553bd39af71f37e0429b81470c11316aa39db074aa3f1df4124e7cb203debed60b885ffb9b27e46a1434e81bbd56566632d0729c0822ac415cbb67f25973667d88e58df9c2f058a0ae7f118c98cc448453b6fbe590363bd17ed62c2f808df61f2a9e593235eeb56db74b9dd15980189a5271468301", + "aggregation_bits": "0xd664cfc4f928592f21ca9fae84cd2a15d4acf76e0d2cbb493324ae9cb25757559fc4b060414cbfd84de047d4f04da4aa6669e83b9b8418d348bfc46b3fef684ffbf0162da3c6258f690b14c94cf448280b646c140b24928defd2d12434dbbbd0afbea5e5661fcac8116699ec8a059acf084ab956ab0eaf508ab7d3e4bd352a80f6b8ff73b4b24753a865991c45c9d9f0e1675e7327ccaaeb146bc3d0a4db2d7e607930579fc38a41d5019f222166cea9ebebfe0dd7b875fa612ecb7bb80f83718702da59fd2687d445048ac99f25b5f088fe931ec4bbf9ecdfc169844c00bc69fe38c0110fc59105233b29f6ddecb7968065fd7ef787e41d3545fefe30314fa401", "data": { - "slot": "4529517677607038185", - "index": "4574134745932346122", - "beacon_block_root": "0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947", + "slot": "1", + "index": "4536127614768741993", + "beacon_block_root": "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8", "source": { - "epoch": "532884117", - "root": "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31" + "epoch": "526920509", + "root": "0x41f3e13e4961bf0c12dd652f3bf49e85e35a8a25c70e67ffc1d08cc01d9921d3" }, "target": { - "epoch": "531729870", - "root": "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672" + "epoch": "527305258", + "root": "0x51977a3f0ab3110e2a10e9c6bd0e89b1410ca45142ac42171bb2b169efc281bc" } }, - "signature": "0x8c40f51a99fce6ebb9a4db5e80d715fff319e7ae523e46afb5d03c000d427e23c7a39e77e2af53851706283c8ca91d680997cb459386fbdff52c4d0ecf498e173717a838a792b210bdffaf476538628584a133899bf30dd5ce7056463b8cd683" + "signature": "0xa17225b5e5319618e77f5b93350430acfadd8ae12a279f1a4176cc7ad1de7ecfc8670988519713fbac8f702cca29bddb14ff1463dae3abb53ddb0c025cd69c8cfb0f5298ab241c06ddb840c7a260f3dbd37120826b13b17e22d086148ebdbab1" } ], "deposits": [ { "proof": [ - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", - "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c" + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7" ], "data": { - "pubkey": "0xb1f8f6e731dbf6b4e3265fb857c7190adbfc7e6cc95ce2e8bda72be8b6ea3459f862310a2484c3b0ee33b30920f18c1d", - "withdrawal_credentials": "0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c", + "pubkey": "0x90b2ffa8992560bca2080afa9b3adc904ce9085a8c2cc897282f20378bdf3cdc0a74100f226ea698e07d4afe50d8ff54", + "withdrawal_credentials": "0x9d1b633f8ae18e21ff1b86740b32dbe55a18a0991bcfe5ffd2b6bf8a59465fe7", "amount": "32000000000", - "signature": "0xb594382214f5bdd375de66c45e1c61a526c7b73fb166c72433bbd9c2a7ad6881244e61cc6427e0206a50b762a129d8830e8708c55761d61ce9e3b19c1bee13bc55daa13bdb07118efdbf57a588b8a64e6392d14f935e53b68933e3355b35acdb" + "signature": "0x978f1439422f6e539e93927a7754e7f9866fbe5832da066bb8fec5041a6818bbfe7e79747a963eec57f76924aeb591d0133ffae96de0793f02d13a13e1f7286a7940e48093ceb832b58e9d6bff9adfc1e8f59367d905633d743cd62ccbd2b27c" } } ], "voluntary_exits": [ { "message": { - "epoch": "4562567354825622634", - "validator_index": "4564219838042306762" + "epoch": "4570829775204010570", + "validator_index": "4565872325553958186" }, - "signature": "0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e" + "signature": "0x8c2c3b368bc00b3853e6df352e816dd910016db953ac77cc1565e3c22f1c0b24c59f24ea9e8ca406aa95b23368d163e80baa6de3f8f7ac19ee78c976d2ae5a21c86fa1762cc959bc734379055cb7aa1de36eae00541936b8c2ee908c770d41ff" } ] } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/BeaconRestApiTypes.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/BeaconRestApiTypes.java index a51e6dbd9e3..9cdb37286ec 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/BeaconRestApiTypes.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/BeaconRestApiTypes.java @@ -69,6 +69,7 @@ import tech.pegasys.teku.infrastructure.http.RestApiConstants; import tech.pegasys.teku.infrastructure.json.types.CoreTypes; import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.json.types.EnumTypeDefinition; import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition; import tech.pegasys.teku.infrastructure.json.types.StringValueTypeDefinition; import tech.pegasys.teku.infrastructure.restapi.endpoints.ParameterMetadata; @@ -76,7 +77,9 @@ import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockHeader; import tech.pegasys.teku.spec.datastructures.metadata.BlockAndMetaData; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; public class BeaconRestApiTypes { private static final StringValueTypeDefinition STATUS_VALUE = @@ -141,10 +144,10 @@ public class BeaconRestApiTypes { SIGNATURE_TYPE.withDescription( "`BLSSignature Hex` BLS12-381 signature for the current epoch.")); - public static final ParameterMetadata SKIP_RANDAO_VERIFICATION_PARAMETER = + public static final ParameterMetadata SKIP_RANDAO_VERIFICATION_PARAMETER = new ParameterMetadata<>( RestApiConstants.SKIP_RANDAO_VERIFICATION, - BOOLEAN_TYPE.withDescription(SKIP_RANDAO_VERIFICATION_PARAM_DESCRIPTION)); + CoreTypes.flag(SKIP_RANDAO_VERIFICATION_PARAM_DESCRIPTION)); public static final ParameterMetadata BUILDER_BOOST_FACTOR_PARAMETER = new ParameterMetadata<>( @@ -236,15 +239,12 @@ public class BeaconRestApiTypes { CoreTypes.UINT64_TYPE.withDescription( "Array of indices for data column sidecars to request for in the specified block. Returns all data column sidecars in the block if not specified.")); - private static final StringValueTypeDefinition - BROADCAST_VALIDATION_VALUE = - DeserializableTypeDefinition.string(BroadcastValidationParameter.class) - .formatter(BroadcastValidationParameter::toString) - .parser(BroadcastValidationParameter::valueOf) - .example("consensus_and_equivocation") - .description(PARAM_BROADCAST_VALIDATION_DESCRIPTION) - .format("string") - .build(); + private static final EnumTypeDefinition BROADCAST_VALIDATION_VALUE = + new EnumTypeDefinition.EnumTypeBuilder<>(BroadcastValidationParameter.class) + .example("consensus_and_equivocation") + .description(PARAM_BROADCAST_VALIDATION_DESCRIPTION) + .format("string") + .build(); public static final ParameterMetadata PARAMETER_BROADCAST_VALIDATION = @@ -253,6 +253,22 @@ public class BeaconRestApiTypes { public static final ParameterMetadata ETH_CONSENSUS_VERSION_TYPE = new ParameterMetadata<>(HEADER_CONSENSUS_VERSION, MILESTONE_TYPE); + public static DeserializableTypeDefinition electraAttestationTypeDef( + final SchemaDefinitionCache schemaDefinitionCache) { + return schemaDefinitionCache + .getSchemaDefinition(SpecMilestone.ELECTRA) + .getAttestationSchema() + .getJsonTypeDefinition(); + } + + public static DeserializableTypeDefinition phase0AttestationTypeDef( + final SchemaDefinitionCache schemaDefinitionCache) { + return schemaDefinitionCache + .getSchemaDefinition(SpecMilestone.PHASE0) + .getAttestationSchema() + .getJsonTypeDefinition(); + } + @SuppressWarnings("JavaCase") public enum BroadcastValidationParameter { gossip, diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/JsonTypeDefinitionBeaconRestApi.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/JsonTypeDefinitionBeaconRestApi.java index 6d4175ddfb9..130821a48de 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/JsonTypeDefinitionBeaconRestApi.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/JsonTypeDefinitionBeaconRestApi.java @@ -34,6 +34,7 @@ import tech.pegasys.teku.beaconrestapi.handlers.tekuv1.beacon.GetEth1Data; import tech.pegasys.teku.beaconrestapi.handlers.tekuv1.beacon.GetEth1DataCache; import tech.pegasys.teku.beaconrestapi.handlers.tekuv1.beacon.GetEth1VotingSummary; +import tech.pegasys.teku.beaconrestapi.handlers.tekuv1.beacon.GetFinalizedStateSlotBefore; import tech.pegasys.teku.beaconrestapi.handlers.tekuv1.beacon.GetProposersData; import tech.pegasys.teku.beaconrestapi.handlers.tekuv1.beacon.GetStateByBlockRoot; import tech.pegasys.teku.beaconrestapi.handlers.tekuv1.node.GetPeersScore; @@ -87,7 +88,6 @@ import tech.pegasys.teku.beaconrestapi.handlers.v1.rewards.GetSyncCommitteeRewards; import tech.pegasys.teku.beaconrestapi.handlers.v1.validator.GetAggregateAttestation; import tech.pegasys.teku.beaconrestapi.handlers.v1.validator.GetAttestationData; -import tech.pegasys.teku.beaconrestapi.handlers.v1.validator.GetNewBlindedBlock; import tech.pegasys.teku.beaconrestapi.handlers.v1.validator.GetProposerDuties; import tech.pegasys.teku.beaconrestapi.handlers.v1.validator.GetSyncCommitteeContribution; import tech.pegasys.teku.beaconrestapi.handlers.v1.validator.PostAggregateAndProofs; @@ -101,12 +101,18 @@ import tech.pegasys.teku.beaconrestapi.handlers.v1.validator.PostSyncCommitteeSubscriptions; import tech.pegasys.teku.beaconrestapi.handlers.v1.validator.PostSyncDuties; import tech.pegasys.teku.beaconrestapi.handlers.v1.validator.PostValidatorLiveness; +import tech.pegasys.teku.beaconrestapi.handlers.v2.beacon.GetAttestationsV2; +import tech.pegasys.teku.beaconrestapi.handlers.v2.beacon.GetAttesterSlashingsV2; import tech.pegasys.teku.beaconrestapi.handlers.v2.beacon.GetBlock; +import tech.pegasys.teku.beaconrestapi.handlers.v2.beacon.GetBlockAttestationsV2; +import tech.pegasys.teku.beaconrestapi.handlers.v2.beacon.PostAttestationsV2; +import tech.pegasys.teku.beaconrestapi.handlers.v2.beacon.PostAttesterSlashingV2; import tech.pegasys.teku.beaconrestapi.handlers.v2.beacon.PostBlindedBlockV2; import tech.pegasys.teku.beaconrestapi.handlers.v2.beacon.PostBlockV2; import tech.pegasys.teku.beaconrestapi.handlers.v2.debug.GetChainHeadsV2; import tech.pegasys.teku.beaconrestapi.handlers.v2.debug.GetState; -import tech.pegasys.teku.beaconrestapi.handlers.v2.validator.GetNewBlock; +import tech.pegasys.teku.beaconrestapi.handlers.v2.validator.GetAggregateAttestationV2; +import tech.pegasys.teku.beaconrestapi.handlers.v2.validator.PostAggregateAndProofsV2; import tech.pegasys.teku.beaconrestapi.handlers.v3.validator.GetNewBlockV3; import tech.pegasys.teku.infrastructure.async.AsyncRunner; import tech.pegasys.teku.infrastructure.async.SafeFuture; @@ -231,10 +237,15 @@ private static RestApi create( .endpoint(new GetBlockRoot(dataProvider)) .endpoint(new GetFinalizedBlockRoot(dataProvider)) .endpoint(new GetBlockAttestations(dataProvider, spec)) + .endpoint(new GetBlockAttestationsV2(dataProvider, schemaCache)) .endpoint(new GetAttestations(dataProvider, spec)) + .endpoint(new GetAttestationsV2(dataProvider, schemaCache)) .endpoint(new PostAttestation(dataProvider, schemaCache)) - .endpoint(new GetAttesterSlashings(dataProvider, spec)) - .endpoint(new PostAttesterSlashing(dataProvider, spec)) + .endpoint(new PostAttestationsV2(dataProvider, schemaCache)) + .endpoint(new GetAttesterSlashings(dataProvider, schemaCache)) + .endpoint(new GetAttesterSlashingsV2(dataProvider, schemaCache)) + .endpoint(new PostAttesterSlashing(dataProvider, schemaCache)) + .endpoint(new PostAttesterSlashingV2(dataProvider, schemaCache)) .endpoint(new GetProposerSlashings(dataProvider)) .endpoint(new PostProposerSlashing(dataProvider)) .endpoint(new GetVoluntaryExits(dataProvider)) @@ -266,12 +277,12 @@ private static RestApi create( // Validator Handlers .endpoint(new PostAttesterDuties(dataProvider)) .endpoint(new GetProposerDuties(dataProvider)) - .endpoint(new GetNewBlock(dataProvider, spec, schemaCache)) - .endpoint(new GetNewBlindedBlock(dataProvider, spec, schemaCache)) .endpoint(new GetNewBlockV3(dataProvider, schemaCache)) .endpoint(new GetAttestationData(dataProvider)) .endpoint(new GetAggregateAttestation(dataProvider, spec)) - .endpoint(new PostAggregateAndProofs(dataProvider, spec.getGenesisSchemaDefinitions())) + .endpoint(new GetAggregateAttestationV2(dataProvider, schemaCache)) + .endpoint(new PostAggregateAndProofs(dataProvider, schemaCache)) + .endpoint(new PostAggregateAndProofsV2(dataProvider, schemaCache)) .endpoint(new PostSubscribeToBeaconCommitteeSubnet(dataProvider)) .endpoint(new PostSyncDuties(dataProvider)) .endpoint(new GetSyncCommitteeContribution(dataProvider, schemaCache)) @@ -305,6 +316,7 @@ private static RestApi create( .endpoint(new GetEth1DataCache(eth1DataProvider)) .endpoint(new GetEth1VotingSummary(dataProvider, eth1DataProvider)) .endpoint(new GetGlobalValidatorInclusion(dataProvider)) + .endpoint(new GetFinalizedStateSlotBefore(dataProvider)) .endpoint(new GetValidatorInclusion(dataProvider)); builder = applyAddons(builder, config, spec, dataProvider, schemaCache); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/addon/Eip7594RestApiBuilderAddon.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/addon/Eip7594RestApiBuilderAddon.java index 390a4376582..4a01c03635e 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/addon/Eip7594RestApiBuilderAddon.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/addon/Eip7594RestApiBuilderAddon.java @@ -36,7 +36,7 @@ public Eip7594RestApiBuilderAddon( @Override public boolean isEnabled() { - return spec.isMilestoneSupported(SpecMilestone.EIP7594); + return spec.isMilestoneSupported(SpecMilestone.ELECTRA); } @Override diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/admin/PutLogLevel.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/admin/PutLogLevel.java index 84f9f095112..e1dbc75f25c 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/admin/PutLogLevel.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/admin/PutLogLevel.java @@ -46,7 +46,7 @@ public PutLogLevel() { } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final LogLevel requestBody = request.getRequestBody(); final List logFilters = requestBody.getLogFilter().orElse(List.of("")); @@ -85,7 +85,7 @@ public Level getLevel() { return level; } - public void setLevel(Level level) { + public void setLevel(final Level level) { this.level = level; } @@ -93,7 +93,7 @@ public Optional> getLogFilter() { return logFilter; } - public void setLogFilter(Optional> logFilter) { + public void setLogFilter(final Optional> logFilter) { this.logFilter = logFilter; } @@ -111,7 +111,7 @@ static DeserializableTypeDefinition getJsonTypeDefinition() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/admin/Readiness.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/admin/Readiness.java index 304ebb4f47c..1f55129a999 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/admin/Readiness.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/admin/Readiness.java @@ -16,6 +16,7 @@ import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.REQUIRE_PREPARED_PROPOSERS_PARAMETER; import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.REQUIRE_VALIDATOR_REGISTRATIONS_PARAMETER; import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.TARGET_PEER_COUNT_PARAMETER; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.CACHE_NONE; @@ -68,6 +69,8 @@ public Readiness(final DataProvider provider) { .queryParam(REQUIRE_VALIDATOR_REGISTRATIONS_PARAMETER) .response(SC_OK, "Node is ready") .response(SC_SERVICE_UNAVAILABLE, "Node not initialized or having issues") + .response( + SC_NO_CONTENT, "Data is unavailable because the chain has not yet reached genesis") .build()); this.syncProvider = syncProvider; this.chainDataProvider = chainDataProvider; @@ -77,7 +80,7 @@ public Readiness(final DataProvider provider) { } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { request.header(Header.CACHE_CONTROL, CACHE_NONE); if (!chainDataProvider.isStoreAvailable() @@ -94,7 +97,7 @@ public void handleRequest(RestApiRequest request) throws JsonProcessingException private boolean belowTargetPeerCount(final RestApiRequest request) { return request .getOptionalQueryParameter(TARGET_PEER_COUNT_PARAMETER) - .map(targetPeerCount -> networkDataProvider.getPeerCount() < targetPeerCount) + .map(targetPeerCount -> networkDataProvider.countPeers() < targetPeerCount) .orElse(false); } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetAllBlobSidecarsAtSlot.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetAllBlobSidecarsAtSlot.java index 5b49c78eb21..3df8ad059e3 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetAllBlobSidecarsAtSlot.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetAllBlobSidecarsAtSlot.java @@ -68,11 +68,12 @@ private static EndpointMetadata createEndpointMetadata(final SchemaDefinitionCac .queryListParam(BLOB_INDICES_PARAMETER) .response(SC_OK, "Request successful", getResponseType(schemaCache), getSszResponseType()) .withNotFoundResponse() + .withChainDataResponses() .build(); } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final List indices = request.getQueryParameterList(BLOB_INDICES_PARAMETER); final SafeFuture>> future = chainDataProvider.getAllBlobSidecarsAtSlot( diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetAllBlocksAtSlot.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetAllBlocksAtSlot.java index 36746425589..bd166eadf17 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetAllBlocksAtSlot.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetAllBlocksAtSlot.java @@ -18,6 +18,7 @@ import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.MILESTONE_TYPE; import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.SIGNATURE_TYPE; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.CACHE_NONE; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_TEKU; @@ -64,6 +65,8 @@ public GetAllBlocksAtSlot( .tags(TAG_TEKU) .pathParam(SLOT_PARAMETER.withDescription("slot of the blocks to retrieve.")) .response(SC_OK, "Request successful", getResponseType(schemaDefinitionCache)) + .response( + SC_NO_CONTENT, "Data is unavailable because the chain has not yet reached genesis") .withServiceUnavailableResponse() .withNotFoundResponse() .build()); @@ -71,7 +74,7 @@ public GetAllBlocksAtSlot( } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { request.header(Header.CACHE_CONTROL, CACHE_NONE); final UInt64 slot = request.getPathParameter(SLOT_PARAMETER); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetDeposits.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetDeposits.java index 788e1544eeb..25aa4fb3e5e 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetDeposits.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetDeposits.java @@ -35,9 +35,11 @@ public class GetDeposits extends RestApiEndpoint { private static final SerializableTypeDefinition DEPOSIT_WITH_INDEX_TYPE = SerializableTypeDefinition.object(DepositWithIndex.class) - .withField("index", CoreTypes.UINT64_TYPE, DepositWithIndex::getIndex) + .withField("index", CoreTypes.UINT64_TYPE, DepositWithIndex::index) .withField( - "data", DepositData.SSZ_SCHEMA.getJsonTypeDefinition(), DepositWithIndex::getData) + "data", + DepositData.SSZ_SCHEMA.getJsonTypeDefinition(), + depositWithIndex -> depositWithIndex.deposit().getData()) .build(); public static final SerializableTypeDefinition> DEPOSITS_RESPONSE_TYPE = diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetEth1Data.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetEth1Data.java index 46131c57410..fb81f703b67 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetEth1Data.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetEth1Data.java @@ -51,6 +51,7 @@ public GetEth1Data(final DataProvider dataProvider, final Eth1DataProvider eth1D .tags(TAG_TEKU) .response(SC_OK, "Request successful", ETH1DATA_RESPONSE_TYPE) .withNotFoundResponse() + .withChainDataResponses() .build()); this.chainDataProvider = dataProvider.getChainDataProvider(); this.eth1DataProvider = eth1DataProvider; diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetEth1DataCache.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetEth1DataCache.java index ec8f7500791..cfc51a9c202 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetEth1DataCache.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetEth1DataCache.java @@ -45,7 +45,7 @@ public class GetEth1DataCache extends RestApiEndpoint { private final Eth1DataProvider eth1DataProvider; - public GetEth1DataCache(Eth1DataProvider eth1DataProvider) { + public GetEth1DataCache(final Eth1DataProvider eth1DataProvider) { super( EndpointMetadata.get(ROUTE) .operationId("getTekuV1BeaconPoolEth1cache") @@ -60,7 +60,7 @@ public GetEth1DataCache(Eth1DataProvider eth1DataProvider) { } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { request.header(Header.CACHE_CONTROL, CACHE_NONE); Collection eth1CachedBlocks = this.eth1DataProvider.getEth1CachedBlocks(); if (eth1CachedBlocks.isEmpty()) { diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetEth1VotingSummary.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetEth1VotingSummary.java index 14dd49860f5..a28f4fe0f1e 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetEth1VotingSummary.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetEth1VotingSummary.java @@ -89,6 +89,7 @@ public GetEth1VotingSummary( .tags(TAG_TEKU) .response(SC_OK, "Request successful", ETH1VOTING_SUMMARY_RESPONSE_TYPE) .withNotFoundResponse() + .withChainDataResponses() .build()); this.chainDataProvider = dataProvider.getChainDataProvider(); this.eth1DataProvider = eth1DataProvider; diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetFinalizedStateSlotBefore.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetFinalizedStateSlotBefore.java new file mode 100644 index 00000000000..0c9606df6aa --- /dev/null +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetFinalizedStateSlotBefore.java @@ -0,0 +1,77 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.beaconrestapi.handlers.tekuv1.beacon; + +import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.SLOT_PARAMETER; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_TEKU; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; + +import com.fasterxml.jackson.core.JsonProcessingException; +import java.util.Optional; +import java.util.function.Function; +import tech.pegasys.teku.api.ChainDataProvider; +import tech.pegasys.teku.api.DataProvider; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition; +import tech.pegasys.teku.infrastructure.restapi.endpoints.AsyncApiResponse; +import tech.pegasys.teku.infrastructure.restapi.endpoints.EndpointMetadata; +import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; +import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiRequest; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; + +public class GetFinalizedStateSlotBefore extends RestApiEndpoint { + public static final String ROUTE = "/teku/v1/beacon/state/finalized/slot/before/{slot}"; + private final ChainDataProvider chainDataProvider; + private static final SerializableTypeDefinition UINT64_RESPONSE = + SerializableTypeDefinition.object() + .name("Slot") + .withField("data", UINT64_TYPE, Function.identity()) + .build(); + + public GetFinalizedStateSlotBefore(final DataProvider dataProvider) { + this(dataProvider.getChainDataProvider()); + } + + public GetFinalizedStateSlotBefore(final ChainDataProvider chainDataProvider) { + super( + EndpointMetadata.get(ROUTE) + .operationId("GetFinalizedStateSlotBefore") + .summary("Get the closest stored state index") + .description("Get the State slot closest to the specified slot.") + .tags(TAG_TEKU) + .pathParam(SLOT_PARAMETER.withDescription("At or before the specified slot")) + .response(SC_OK, "Request successful", UINT64_RESPONSE) + .response( + SC_NO_CONTENT, "Data is unavailable because the chain has not yet reached genesis") + .withServiceUnavailableResponse() + .withNotFoundResponse() + .build()); + this.chainDataProvider = chainDataProvider; + } + + @Override + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { + final UInt64 beforeSlot = request.getPathParameter(SLOT_PARAMETER); + final SafeFuture> future = chainDataProvider.getFinalizedStateSlot(beforeSlot); + + request.respondAsync( + future.thenApply( + maybeSlot -> + maybeSlot + .map(AsyncApiResponse::respondOk) + .orElseGet(AsyncApiResponse::respondNotFound))); + } +} diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetProposersData.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetProposersData.java index 5d2a54bc4ad..11fda354c11 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetProposersData.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetProposersData.java @@ -52,7 +52,7 @@ public GetProposersData(final DataProvider provider) { } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { request.header(CACHE_CONTROL, CACHE_NONE); request.respondOk( new ProposersData( diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetStateByBlockRoot.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetStateByBlockRoot.java index 1303ad2454d..34c5dc98b28 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetStateByBlockRoot.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetStateByBlockRoot.java @@ -60,12 +60,13 @@ public GetStateByBlockRoot(final ChainDataProvider chainDataProvider, final Spec spec.getForkSchedule() .getSpecMilestoneAtSlot(((BeaconState) beaconState).getSlot()))) .withNotFoundResponse() + .withChainDataResponses() .build()); this.chainDataProvider = chainDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { request.header(Header.CACHE_CONTROL, CACHE_NONE); final String blockId = request.getPathParameter(PARAMETER_BLOCK_ID); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/node/GetPeersScore.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/node/GetPeersScore.java index 11c642d373e..c0a7c015bbf 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/node/GetPeersScore.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/node/GetPeersScore.java @@ -66,7 +66,7 @@ public GetPeersScore(final DataProvider provider) { } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { request.header(Header.CACHE_CONTROL, CACHE_NONE); request.respondOk(network.getPeerScores()); } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/validatorInclusion/GetGlobalValidatorInclusion.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/validatorInclusion/GetGlobalValidatorInclusion.java index dba3f57bcf5..f3217d9db1c 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/validatorInclusion/GetGlobalValidatorInclusion.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/validatorInclusion/GetGlobalValidatorInclusion.java @@ -14,6 +14,7 @@ package tech.pegasys.teku.beaconrestapi.handlers.tekuv1.validatorInclusion; import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.EPOCH_PARAMETER; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_EXPERIMENTAL; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_TEKU; @@ -60,6 +61,8 @@ public GetGlobalValidatorInclusion(final ChainDataProvider chainDataProvider) { .withField( "data", GetGlobalValidatorResponseData.RESPONSE_DATA, Function.identity()) .build()) + .response( + SC_NO_CONTENT, "Data is unavailable because the chain has not yet reached genesis") .withNotFoundResponse() .withServiceUnavailableResponse() .build()); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/validatorInclusion/GetValidatorInclusion.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/validatorInclusion/GetValidatorInclusion.java index aef36a8b8db..40e9ec5d72f 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/validatorInclusion/GetValidatorInclusion.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/validatorInclusion/GetValidatorInclusion.java @@ -15,6 +15,7 @@ import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.EPOCH_PARAMETER; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_EXPERIMENTAL; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_TEKU; @@ -69,6 +70,8 @@ public GetValidatorInclusion(final DataProvider dataProvider) { GetValidatorInclusionResponseData.RESPONSE_DATA, Function.identity()) .build()) + .response( + SC_NO_CONTENT, "Data is unavailable because the chain has not yet reached genesis") .withNotFoundResponse() .withServiceUnavailableResponse() .build()); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/AbstractGetSimpleDataFromState.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/AbstractGetSimpleDataFromState.java index f3195043aaf..3c34337628d 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/AbstractGetSimpleDataFromState.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/AbstractGetSimpleDataFromState.java @@ -36,7 +36,7 @@ public AbstractGetSimpleDataFromState( } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final SafeFuture> future = chainDataProvider.getBeaconStateAndMetadata(request.getPathParameter(PARAMETER_STATE_ID)); request.respondAsync( diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetAttestations.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetAttestations.java index bb5bfd2c2e4..6441582538e 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetAttestations.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetAttestations.java @@ -34,14 +34,13 @@ import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiRequest; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.datastructures.operations.Attestation; public class GetAttestations extends RestApiEndpoint { public static final String ROUTE = "/eth/v1/beacon/pool/attestations"; private final NodeDataProvider nodeDataProvider; - public GetAttestations(final DataProvider dataProvider, Spec spec) { + public GetAttestations(final DataProvider dataProvider, final Spec spec) { this(dataProvider.getNodeDataProvider(), spec); } @@ -53,15 +52,16 @@ public GetAttestations(final NodeDataProvider nodeDataProvider, final Spec spec) .description( "Retrieves attestations known by the node but not necessarily incorporated into any block.") .tags(TAG_BEACON) + .deprecated(true) .queryParam(SLOT_PARAMETER.withDescription(SLOT_QUERY_DESCRIPTION)) .queryParam(COMMITTEE_INDEX_PARAMETER) - .response(SC_OK, "Request successful", getResponseType(spec.getGenesisSpecConfig())) + .response(SC_OK, "Request successful", getResponseType(spec)) .build()); this.nodeDataProvider = nodeDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { request.header(Header.CACHE_CONTROL, CACHE_NONE); final Optional slot = request.getOptionalQueryParameter(SLOT_PARAMETER.withDescription(SLOT_QUERY_DESCRIPTION)); @@ -71,13 +71,13 @@ public void handleRequest(RestApiRequest request) throws JsonProcessingException request.respondOk(nodeDataProvider.getAttestations(slot, committeeIndex)); } - private static SerializableTypeDefinition> getResponseType( - SpecConfig specConfig) { + private static SerializableTypeDefinition> getResponseType(final Spec spec) { return SerializableTypeDefinition.>object() .name("GetPoolAttestationsResponse") .withField( "data", - listOf(new Attestation.AttestationSchema(specConfig).getJsonTypeDefinition()), + listOf( + spec.getGenesisSchemaDefinitions().getAttestationSchema().getJsonTypeDefinition()), Function.identity()) .build(); } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetAttesterSlashings.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetAttesterSlashings.java index cc40eff277e..a14ffa446b5 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetAttesterSlashings.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetAttesterSlashings.java @@ -28,19 +28,21 @@ import tech.pegasys.teku.infrastructure.restapi.endpoints.EndpointMetadata; import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiRequest; -import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; -import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestation; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; public class GetAttesterSlashings extends RestApiEndpoint { public static final String ROUTE = "/eth/v1/beacon/pool/attester_slashings"; private final NodeDataProvider nodeDataProvider; - public GetAttesterSlashings(final DataProvider dataProvider, Spec spec) { - this(dataProvider.getNodeDataProvider(), spec); + public GetAttesterSlashings( + final DataProvider dataProvider, final SchemaDefinitionCache schemaDefinitionCache) { + this(dataProvider.getNodeDataProvider(), schemaDefinitionCache); } - GetAttesterSlashings(final NodeDataProvider provider, Spec spec) { + GetAttesterSlashings( + final NodeDataProvider provider, final SchemaDefinitionCache schemaDefinitionCache) { super( EndpointMetadata.get(ROUTE) .operationId("getPoolAttesterSlashings") @@ -48,28 +50,31 @@ public GetAttesterSlashings(final DataProvider dataProvider, Spec spec) { .description( "Retrieves attester slashings known by the node but not necessarily incorporated into any block.") .tags(TAG_BEACON) - .response(SC_OK, "Request successful", getResponseType(spec)) + .deprecated(true) + .response(SC_OK, "Request successful", getResponseType(schemaDefinitionCache)) .build()); this.nodeDataProvider = provider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { request.header(Header.CACHE_CONTROL, CACHE_NONE); List attesterSlashings = nodeDataProvider.getAttesterSlashings(); request.respondOk(attesterSlashings); } - private static SerializableTypeDefinition> getResponseType(Spec spec) { - final IndexedAttestation.IndexedAttestationSchema indexedAttestationSchema = - new IndexedAttestation.IndexedAttestationSchema(spec.getGenesisSpecConfig()); - final AttesterSlashing.AttesterSlashingSchema attesterSlashingSchema = - new AttesterSlashing.AttesterSlashingSchema(indexedAttestationSchema); - + private static SerializableTypeDefinition> getResponseType( + final SchemaDefinitionCache schemaDefinitionCache) { return SerializableTypeDefinition.>object() .name("GetPoolAttesterSlashingsResponse") .withField( - "data", listOf(attesterSlashingSchema.getJsonTypeDefinition()), Function.identity()) + "data", + listOf( + schemaDefinitionCache + .getSchemaDefinition(SpecMilestone.PHASE0) + .getAttesterSlashingSchema() + .getJsonTypeDefinition()), + Function.identity()) .build(); } } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlindedBlock.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlindedBlock.java index eb742c74975..1d565886b13 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlindedBlock.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlindedBlock.java @@ -15,6 +15,7 @@ import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.PARAMETER_BLOCK_ID; import static tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil.getSchemaDefinitionForAllSupportedMilestones; +import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.ETH_CONSENSUS_HEADER_TYPE; import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.MILESTONE_TYPE; import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.sszResponseType; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; @@ -65,14 +66,16 @@ public GetBlindedBlock( SC_OK, "Request successful", getResponseType(schemaDefinitionCache), - sszResponseType()) + sszResponseType(), + ETH_CONSENSUS_HEADER_TYPE) .withNotFoundResponse() + .withChainDataResponses() .build()); this.chainDataProvider = chainDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final SafeFuture>> future = chainDataProvider.getBlindedBlock(request.getPathParameter(PARAMETER_BLOCK_ID)); @@ -91,7 +94,7 @@ public void handleRequest(RestApiRequest request) throws JsonProcessingException } private static SerializableTypeDefinition> getResponseType( - SchemaDefinitionCache schemaDefinitionCache) { + final SchemaDefinitionCache schemaDefinitionCache) { final SerializableTypeDefinition signedBeaconBlockType = getSchemaDefinitionForAllSupportedMilestones( schemaDefinitionCache, diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlobSidecars.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlobSidecars.java index 64754841d55..c76ff445124 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlobSidecars.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlobSidecars.java @@ -15,17 +15,23 @@ import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.BLOB_INDICES_PARAMETER; import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.PARAMETER_BLOCK_ID; +import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.ETH_CONSENSUS_HEADER_TYPE; +import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.MILESTONE_TYPE; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.EXECUTION_OPTIMISTIC; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.FINALIZED; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_BEACON; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.BOOLEAN_TYPE; import static tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition.listOf; import com.fasterxml.jackson.core.JsonProcessingException; import java.util.Collections; import java.util.List; import java.util.Optional; -import java.util.function.Function; import tech.pegasys.teku.api.ChainDataProvider; import tech.pegasys.teku.api.DataProvider; +import tech.pegasys.teku.api.schema.Version; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition; @@ -38,6 +44,7 @@ import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; +import tech.pegasys.teku.spec.datastructures.metadata.BlobSidecarsAndMetaData; import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsDeneb; @@ -67,40 +74,56 @@ private static EndpointMetadata createEndpointMetadata(final SchemaDefinitionCac .tags(TAG_BEACON) .pathParam(PARAMETER_BLOCK_ID) .queryListParam(BLOB_INDICES_PARAMETER) - .response(SC_OK, "Request successful", getResponseType(schemaCache), getSszResponseType()) + .response( + SC_OK, + "Request successful", + getResponseType(schemaCache), + getSszResponseType(), + ETH_CONSENSUS_HEADER_TYPE) .withNotFoundResponse() + .withChainDataResponses() .build(); } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final List indices = request.getQueryParameterList(BLOB_INDICES_PARAMETER); - final SafeFuture>> future = + final SafeFuture> future = chainDataProvider.getBlobSidecars(request.getPathParameter(PARAMETER_BLOCK_ID), indices); - request.respondAsync( future.thenApply( - blobSidecars -> - blobSidecars - .map(AsyncApiResponse::respondOk) + maybeBlobSidecars -> + maybeBlobSidecars + .map( + blobSidecarsAndMetaData -> { + request.header( + HEADER_CONSENSUS_VERSION, + Version.fromMilestone(blobSidecarsAndMetaData.getMilestone()).name()); + return AsyncApiResponse.respondOk(blobSidecarsAndMetaData); + }) .orElse(AsyncApiResponse.respondNotFound()))); } - private static SerializableTypeDefinition> getResponseType( + private static SerializableTypeDefinition getResponseType( final SchemaDefinitionCache schemaCache) { final DeserializableTypeDefinition blobSidecarType = SchemaDefinitionsDeneb.required(schemaCache.getSchemaDefinition(SpecMilestone.DENEB)) .getBlobSidecarSchema() .getJsonTypeDefinition(); - return SerializableTypeDefinition.>object() + return SerializableTypeDefinition.object() .name("GetBlobSidecarsResponse") - .withField("data", listOf(blobSidecarType), Function.identity()) + .withOptionalField("version", MILESTONE_TYPE, (b) -> Optional.of(b.getMilestone())) + .withOptionalField( + EXECUTION_OPTIMISTIC, BOOLEAN_TYPE, (b) -> Optional.of(b.isExecutionOptimistic())) + .withOptionalField(FINALIZED, BOOLEAN_TYPE, (b) -> Optional.of(b.isFinalized())) + .withField("data", listOf(blobSidecarType), BlobSidecarsAndMetaData::getData) .build(); } - private static ResponseContentTypeDefinition> getSszResponseType() { - final OctetStreamResponseContentTypeDefinition.OctetStreamSerializer> - serializer = (data, out) -> data.forEach(blobSidecar -> blobSidecar.sszSerialize(out)); + private static ResponseContentTypeDefinition getSszResponseType() { + final OctetStreamResponseContentTypeDefinition.OctetStreamSerializer + serializer = + (data, out) -> data.getData().forEach(blobSidecar -> blobSidecar.sszSerialize(out)); return new OctetStreamResponseContentTypeDefinition<>(serializer, __ -> Collections.emptyMap()); } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockAttestations.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockAttestations.java index 07757393f7f..a647995b0a1 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockAttestations.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockAttestations.java @@ -35,16 +35,17 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; public class GetBlockAttestations extends RestApiEndpoint { public static final String ROUTE = "/eth/v1/beacon/blocks/{block_id}/attestations"; private final ChainDataProvider chainDataProvider; - public GetBlockAttestations(final DataProvider dataProvider, Spec spec) { + public GetBlockAttestations(final DataProvider dataProvider, final Spec spec) { this(dataProvider.getChainDataProvider(), spec); } - public GetBlockAttestations(final ChainDataProvider chainDataProvider, Spec spec) { + public GetBlockAttestations(final ChainDataProvider chainDataProvider, final Spec spec) { super( EndpointMetadata.get(ROUTE) .operationId("getBlockAttestations") @@ -54,12 +55,14 @@ public GetBlockAttestations(final ChainDataProvider chainDataProvider, Spec spec .pathParam(PARAMETER_BLOCK_ID) .response(SC_OK, "Request successful", getResponseType(spec)) .withNotFoundResponse() + .withChainDataResponses() + .deprecated(true) .build()); this.chainDataProvider = chainDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final SafeFuture>>> future = chainDataProvider.getBlockAttestations(request.getPathParameter(PARAMETER_BLOCK_ID)); @@ -72,15 +75,18 @@ public void handleRequest(RestApiRequest request) throws JsonProcessingException } private static SerializableTypeDefinition>> getResponseType( - Spec spec) { - Attestation.AttestationSchema dataSchema = - new Attestation.AttestationSchema(spec.getGenesisSpecConfig()); + final Spec spec) { + final AttestationSchema dataSchema = + spec.getGenesisSchemaDefinitions().getAttestationSchema(); return SerializableTypeDefinition.>>object() .name("GetBlockAttestationsResponse") .withField(EXECUTION_OPTIMISTIC, BOOLEAN_TYPE, ObjectAndMetaData::isExecutionOptimistic) .withField(FINALIZED, BOOLEAN_TYPE, ObjectAndMetaData::isFinalized) - .withField("data", listOf(dataSchema.getJsonTypeDefinition()), ObjectAndMetaData::getData) + .withField( + "data", + listOf(dataSchema.castTypeToAttestationSchema().getJsonTypeDefinition()), + ObjectAndMetaData::getData) .build(); } } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockHeader.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockHeader.java index 92245969e8d..8726b892767 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockHeader.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockHeader.java @@ -61,12 +61,13 @@ public GetBlockHeader(final ChainDataProvider chainDataProvider) { .pathParam(PARAMETER_BLOCK_ID) .response(SC_OK, "Request successful", RESPONSE_TYPE) .withNotFoundResponse() + .withChainDataResponses() .build()); this.chainDataProvider = chainDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final SafeFuture> future = chainDataProvider.getBlockAndMetaData(request.getPathParameter(PARAMETER_BLOCK_ID)); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockHeaders.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockHeaders.java index e383df95140..80cba132698 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockHeaders.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockHeaders.java @@ -68,12 +68,13 @@ public GetBlockHeaders(final ChainDataProvider chainDataProvider) { .queryParam(SLOT_PARAMETER.withDescription(SLOT_QUERY_DESCRIPTION)) .queryParam(PARENT_ROOT_PARAMETER) .response(SC_OK, "Request successful", RESPONSE_TYPE) + .withChainDataResponses() .build()); this.chainDataProvider = chainDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final Optional parentRoot = request.getOptionalQueryParameter(PARENT_ROOT_PARAMETER); final Optional slot = request.getOptionalQueryParameter(SLOT_PARAMETER.withDescription(SLOT_QUERY_DESCRIPTION)); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockRoot.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockRoot.java index 60ebc8673f2..1eda82b9563 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockRoot.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockRoot.java @@ -60,12 +60,13 @@ public GetBlockRoot(final ChainDataProvider chainDataProvider) { .pathParam(PARAMETER_BLOCK_ID) .response(SC_OK, "Request successful", RESPONSE_TYPE) .withNotFoundResponse() + .withChainDataResponses() .build()); this.chainDataProvider = chainDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final SafeFuture>> future = chainDataProvider.getBlockRoot(request.getPathParameter(PARAMETER_BLOCK_ID)); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlsToExecutionChanges.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlsToExecutionChanges.java index dd862a6dfca..037e6d620e4 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlsToExecutionChanges.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlsToExecutionChanges.java @@ -86,7 +86,7 @@ private static EndpointMetadata createEndpointMetadata(final SchemaDefinitionCac } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { request.header(Header.CACHE_CONTROL, CACHE_NONE); final Optional locallySubmitted = request.getOptionalQueryParameter(LOCALLY_SUBMITTED_QUERY_PARAMETER); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetDataColumnSidecars.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetDataColumnSidecars.java index bfeb993598d..74333f0d79f 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetDataColumnSidecars.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetDataColumnSidecars.java @@ -74,7 +74,7 @@ private static EndpointMetadata createEndpointMetadata(final SchemaDefinitionCac } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final List indices = request.getQueryParameterList(DATA_COLUMN_INDICES_PARAMETER); final SafeFuture>> future = chainDataProvider.getDataColumnSidecars( @@ -91,7 +91,7 @@ public void handleRequest(RestApiRequest request) throws JsonProcessingException private static SerializableTypeDefinition> getResponseType( final SchemaDefinitionCache schemaCache) { final DeserializableTypeDefinition dataColumnSidecarType = - SchemaDefinitionsEip7594.required(schemaCache.getSchemaDefinition(SpecMilestone.EIP7594)) + SchemaDefinitionsEip7594.required(schemaCache.getSchemaDefinition(SpecMilestone.ELECTRA)) .getDataColumnSidecarSchema() .getJsonTypeDefinition(); return SerializableTypeDefinition.>object() diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetFinalizedBlockRoot.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetFinalizedBlockRoot.java index fb0dcdc69f2..ffa0409bd07 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetFinalizedBlockRoot.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetFinalizedBlockRoot.java @@ -43,11 +43,11 @@ public class GetFinalizedBlockRoot extends RestApiEndpoint { .withField("data", ROOT_TYPE, Function.identity()) .build(); - public GetFinalizedBlockRoot(DataProvider dataProvider) { + public GetFinalizedBlockRoot(final DataProvider dataProvider) { this(dataProvider.getChainDataProvider()); } - public GetFinalizedBlockRoot(ChainDataProvider chainDataProvider) { + public GetFinalizedBlockRoot(final ChainDataProvider chainDataProvider) { super( EndpointMetadata.get(ROUTE) .operationId("getFinalizedBlockRoot") @@ -59,12 +59,13 @@ public GetFinalizedBlockRoot(ChainDataProvider chainDataProvider) { .pathParam(SLOT_PARAMETER) .response(SC_OK, "Request successful", RESPONSE_TYPE) .withNotFoundResponse() + .withChainDataResponses() .build()); this.chainDataProvider = chainDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final UInt64 slot = request.getPathParameter(SLOT_PARAMETER); final SafeFuture> futureFinalizedBlockRoot = chainDataProvider.getFinalizedBlockRoot(slot); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetFinalizedCheckpointState.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetFinalizedCheckpointState.java index b8e6b6284c5..e22caf5bf13 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetFinalizedCheckpointState.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetFinalizedCheckpointState.java @@ -38,11 +38,11 @@ public class GetFinalizedCheckpointState extends RestApiEndpoint { public static final String ROUTE = "/eth/v1/checkpoint/finalized_state"; private final ChainDataProvider chainDataProvider; - public GetFinalizedCheckpointState(final DataProvider dataProvider, Spec spec) { + public GetFinalizedCheckpointState(final DataProvider dataProvider, final Spec spec) { this(dataProvider.getChainDataProvider(), spec); } - public GetFinalizedCheckpointState(final ChainDataProvider chainDataProvider, Spec spec) { + public GetFinalizedCheckpointState(final ChainDataProvider chainDataProvider, final Spec spec) { super( EndpointMetadata.get(ROUTE) .operationId("getFinalizedCheckpointState") @@ -59,12 +59,13 @@ public GetFinalizedCheckpointState(final ChainDataProvider chainDataProvider, Sp spec.getForkSchedule() .getSpecMilestoneAtSlot(((BeaconState) beaconState).getSlot()))) .withNotFoundResponse() + .withChainDataResponses() .build()); this.chainDataProvider = chainDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final SafeFuture> future = chainDataProvider.getBeaconStateAndMetadata("finalized"); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetGenesis.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetGenesis.java index 06e155f08de..6220a635ecf 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetGenesis.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetGenesis.java @@ -47,6 +47,7 @@ public GetGenesis(final DataProvider dataProvider) { .tags(TAG_BEACON, TAG_VALIDATOR_REQUIRED) .response(SC_OK, "Request successful", GET_GENESIS_API_DATA_TYPE) .response(SC_NOT_FOUND, "Chain genesis info is not yet known") + .withChainDataResponses() .build()); this.chainDataProvider = chainDataProvider; } @@ -59,7 +60,7 @@ private Optional getGenesisData() { } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final Optional maybeData = getGenesisData(); if (maybeData.isEmpty()) { request.respondWithCode(SC_NOT_FOUND); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetProposerSlashings.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetProposerSlashings.java index 6bd9d8ec722..342b6dd1a92 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetProposerSlashings.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetProposerSlashings.java @@ -61,7 +61,7 @@ public GetProposerSlashings(final DataProvider dataProvider) { } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { request.header(Header.CACHE_CONTROL, CACHE_NONE); List proposerSlashings = nodeDataProvider.getProposerSlashings(); request.respondOk(proposerSlashings); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateCommittees.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateCommittees.java index adcbac11a95..2774daed3d9 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateCommittees.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateCommittees.java @@ -47,12 +47,12 @@ public class GetStateCommittees extends RestApiEndpoint { private static final SerializableTypeDefinition EPOCH_COMMITTEE_TYPE = SerializableTypeDefinition.object(CommitteeAssignment.class) - .withField("index", UINT64_TYPE, CommitteeAssignment::getCommitteeIndex) - .withField("slot", UINT64_TYPE, CommitteeAssignment::getSlot) + .withField("index", UINT64_TYPE, CommitteeAssignment::committeeIndex) + .withField("slot", UINT64_TYPE, CommitteeAssignment::slot) .withField( "validators", listOf(UINT64_TYPE), - committeeAssignment -> UInt64Util.intToUInt64List(committeeAssignment.getCommittee())) + committeeAssignment -> UInt64Util.intToUInt64List(committeeAssignment.committee())) .build(); private static final SerializableTypeDefinition>> @@ -84,12 +84,13 @@ public GetStateCommittees(final DataProvider dataProvider) { .tags(TAG_BEACON) .response(SC_OK, "Request successful", RESPONSE_TYPE) .withNotFoundResponse() + .withChainDataResponses() .build()); this.chainDataProvider = chainDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final Optional epoch = request.getOptionalQueryParameter(EPOCH_PARAMETER); final Optional committeeIndex = request.getOptionalQueryParameter(INDEX_PARAMETER); final Optional slot = diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateFinalityCheckpoints.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateFinalityCheckpoints.java index c139a3b8672..d98449ff9b5 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateFinalityCheckpoints.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateFinalityCheckpoints.java @@ -70,6 +70,7 @@ public GetStateFinalityCheckpoints(final DataProvider dataProvider) { .pathParam(PARAMETER_STATE_ID) .response(SC_OK, "Request successful", RESPONSE_TYPE) .withNotFoundResponse() + .withChainDataResponses() .build(), chainDataProvider); } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateFork.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateFork.java index 3ff9bbfb0ac..7d6c9c66754 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateFork.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateFork.java @@ -59,6 +59,7 @@ public GetStateFork(final DataProvider dataProvider) { .pathParam(PARAMETER_STATE_ID) .response(SC_OK, "Request successful", RESPONSE_TYPE) .withNotFoundResponse() + .withChainDataResponses() .build(), chainDataProvider); } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateRandao.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateRandao.java index 08f65303b32..29411997810 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateRandao.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateRandao.java @@ -80,6 +80,7 @@ private static EndpointMetadata createMetadata() { .queryParam(EPOCH_PARAMETER) .withNotFoundResponse() .response(SC_OK, "Request successful", responseType) + .withChainDataResponses() .build(); } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateRoot.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateRoot.java index 9a225284082..4843d7320e6 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateRoot.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateRoot.java @@ -55,6 +55,7 @@ public GetStateRoot(final DataProvider dataProvider) { .pathParam(PARAMETER_STATE_ID) .response(SC_OK, "Request successful", RESPONSE_TYPE) .withNotFoundResponse() + .withChainDataResponses() .build(), chainDataProvider); } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateSyncCommittees.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateSyncCommittees.java index cec44e00070..61dda4244a9 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateSyncCommittees.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateSyncCommittees.java @@ -78,12 +78,13 @@ public GetStateSyncCommittees(final ChainDataProvider chainDataProvider) { .queryParam(EPOCH_PARAMETER) .response(HttpStatusCodes.SC_OK, "Request successful", RESPONSE_TYPE) .withNotFoundResponse() + .withChainDataResponses() .build()); this.chainDataProvider = chainDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final Optional epoch = request.getOptionalQueryParameter(EPOCH_PARAMETER); final SafeFuture>> future = chainDataProvider.getStateSyncCommittees( diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateValidator.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateValidator.java index 1f5307c6686..cf77fae9400 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateValidator.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateValidator.java @@ -67,12 +67,13 @@ public GetStateValidator(final DataProvider dataProvider) { .tags(TAG_BEACON, TAG_VALIDATOR_REQUIRED) .response(SC_OK, "Request successful", RESPONSE_TYPE) .withNotFoundResponse() + .withChainDataResponses() .build()); this.chainDataProvider = provider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final SafeFuture> future = chainDataProvider.getBeaconStateAndMetadata(request.getPathParameter(PARAMETER_STATE_ID)); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateValidatorBalances.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateValidatorBalances.java index 020e0ab6f71..95a478d8902 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateValidatorBalances.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateValidatorBalances.java @@ -69,12 +69,13 @@ public GetStateValidatorBalances(final DataProvider dataProvider) { .queryListParam(ID_PARAMETER) .response(SC_OK, "Request successful", RESPONSE_TYPE) .withNotFoundResponse() + .withChainDataResponses() .build()); this.chainDataProvider = chainDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final List validators = request.getQueryParameterList(ID_PARAMETER); final SafeFuture>>> future = diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateValidators.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateValidators.java index 9a876e2ace4..e6069ca1f8e 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateValidators.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateValidators.java @@ -59,12 +59,13 @@ public GetStateValidators(final DataProvider dataProvider) { .tags(TAG_BEACON) .response(SC_OK, "Request successful", STATE_VALIDATORS_RESPONSE_TYPE) .withNotFoundResponse() + .withChainDataResponses() .build()); this.chainDataProvider = provider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final List validators = request.getQueryParameterList(ID_PARAMETER); final List statusParameters = request.getQueryParameterList(STATUS_PARAMETER); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetVoluntaryExits.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetVoluntaryExits.java index 69008e2eabc..9f534b33c6a 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetVoluntaryExits.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetVoluntaryExits.java @@ -62,7 +62,7 @@ public GetVoluntaryExits(final DataProvider dataProvider) { } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { request.header(Header.CACHE_CONTROL, CACHE_NONE); request.respondOk(nodeDataProvider.getVoluntaryExits()); } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/MilestoneDependentTypesUtil.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/MilestoneDependentTypesUtil.java index ebf54a3613f..c6d4efea5ea 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/MilestoneDependentTypesUtil.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/MilestoneDependentTypesUtil.java @@ -13,8 +13,11 @@ package tech.pegasys.teku.beaconrestapi.handlers.v1.beacon; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; + import com.fasterxml.jackson.core.JsonProcessingException; import java.util.List; +import java.util.Map; import java.util.Optional; import java.util.function.BiPredicate; import java.util.function.Function; @@ -76,7 +79,40 @@ SerializableOneOfTypeDefinition getMultipleSchemaDefinitionFromMilestone( return builder.build(); } - public static DeserializableTypeDefinition slotBasedSelector( + public static + DeserializableTypeDefinition headerBasedSelectorWithSlotFallback( + final Map headers, + final String json, + final SchemaDefinitionCache schemaDefinitionCache, + final Function> getSchema) { + if (headers.containsKey(HEADER_CONSENSUS_VERSION)) { + return headerBasedSelector(headers, schemaDefinitionCache, getSchema); + } + return slotBasedSelector(json, schemaDefinitionCache, getSchema); + } + + public static DeserializableTypeDefinition headerBasedSelector( + final Map headers, + final SchemaDefinitionCache schemaDefinitionCache, + final Function> getSchema) { + if (!headers.containsKey(HEADER_CONSENSUS_VERSION)) { + throw new BadRequestException( + String.format("Missing required header value for (%s)", HEADER_CONSENSUS_VERSION)); + } + try { + final SpecMilestone milestone = SpecMilestone.forName(headers.get(HEADER_CONSENSUS_VERSION)); + return getSchema + .apply(schemaDefinitionCache.getSchemaDefinition(milestone)) + .getJsonTypeDefinition(); + } catch (Exception e) { + throw new BadRequestException( + String.format( + "Invalid value for (%s) header: %s", + HEADER_CONSENSUS_VERSION, headers.get(HEADER_CONSENSUS_VERSION))); + } + } + + private static DeserializableTypeDefinition slotBasedSelector( final String json, final SchemaDefinitionCache schemaDefinitionCache, final Function> getSchema) { diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostAttestation.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostAttestation.java index 1aef8da8d4e..4c8da178a70 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostAttestation.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostAttestation.java @@ -65,12 +65,13 @@ public PostAttestation( SC_BAD_REQUEST, "Errors with one or more attestations", ErrorListBadRequest.getJsonTypeDefinition()) + .withChainDataResponses() .build()); this.provider = provider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final List attestations = request.getRequestBody(); final SafeFuture> future = provider.submitAttestations(attestations); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostAttesterSlashing.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostAttesterSlashing.java index d66aff7b692..a2dad44e879 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostAttesterSlashing.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostAttesterSlashing.java @@ -26,10 +26,9 @@ import tech.pegasys.teku.infrastructure.restapi.endpoints.EndpointMetadata; import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiRequest; -import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; -import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestation; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; import tech.pegasys.teku.statetransition.validation.InternalValidationResult; import tech.pegasys.teku.statetransition.validation.ValidationResultCode; @@ -37,11 +36,13 @@ public class PostAttesterSlashing extends RestApiEndpoint { public static final String ROUTE = "/eth/v1/beacon/pool/attester_slashings"; private final NodeDataProvider nodeDataProvider; - public PostAttesterSlashing(final DataProvider dataProvider, final Spec spec) { - this(dataProvider.getNodeDataProvider(), spec); + public PostAttesterSlashing( + final DataProvider dataProvider, final SchemaDefinitionCache schemaDefinitionCache) { + this(dataProvider.getNodeDataProvider(), schemaDefinitionCache); } - public PostAttesterSlashing(final NodeDataProvider provider, final Spec spec) { + public PostAttesterSlashing( + final NodeDataProvider provider, final SchemaDefinitionCache schemaDefinitionCache) { super( EndpointMetadata.post(ROUTE) .operationId("submitPoolAttesterSlashings") @@ -49,14 +50,14 @@ public PostAttesterSlashing(final NodeDataProvider provider, final Spec spec) { .description( "Submits attester slashing object to node's pool and if passes validation node MUST broadcast it to network.") .tags(TAG_BEACON) - .requestBodyType(getRequestType(spec.getGenesisSpecConfig())) + .requestBodyType(getRequestType(schemaDefinitionCache)) .response(SC_OK, "Success") .build()); this.nodeDataProvider = provider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final AttesterSlashing attesterSlashing = request.getRequestBody(); final SafeFuture future = nodeDataProvider.postAttesterSlashing(attesterSlashing); @@ -79,12 +80,10 @@ public void handleRequest(RestApiRequest request) throws JsonProcessingException } private static DeserializableTypeDefinition getRequestType( - SpecConfig specConfig) { - final IndexedAttestation.IndexedAttestationSchema indexedAttestationSchema = - new IndexedAttestation.IndexedAttestationSchema(specConfig); - final AttesterSlashing.AttesterSlashingSchema attesterSlashingSchema = - new AttesterSlashing.AttesterSlashingSchema(indexedAttestationSchema); - - return attesterSlashingSchema.getJsonTypeDefinition(); + final SchemaDefinitionCache schemaDefinitionCache) { + return schemaDefinitionCache + .getSchemaDefinition(SpecMilestone.PHASE0) + .getAttesterSlashingSchema() + .getJsonTypeDefinition(); } } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostBlindedBlock.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostBlindedBlock.java index 54b5636d1bb..79c937784a4 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostBlindedBlock.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostBlindedBlock.java @@ -15,8 +15,9 @@ import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.ETH_CONSENSUS_VERSION_TYPE; import static tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil.getSchemaDefinitionForAllSupportedMilestones; -import static tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil.slotBasedSelector; +import static tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil.headerBasedSelectorWithSlotFallback; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_ACCEPTED; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_BEACON; @@ -79,8 +80,18 @@ private static EndpointMetadata createMetadata( .operationId("publishBlindedBlock") .summary("Publish a signed blinded block") .description( - "Submit a signed blinded beacon block to the beacon node to be broadcast and imported. The beacon node performs the required validation.") + """ + Instructs the beacon node to use the components of the `SignedBlindedBeaconBlock` to construct and publish a \ + `SignedBeaconBlock` by swapping out the `transactions_root` for the corresponding full list of `transactions`. \ + The beacon node should broadcast a newly constructed `SignedBeaconBlock` to the beacon network, \ + to be included in the beacon chain. The beacon node is not required to validate the signed \ + `BeaconBlock`, and a successful response (20X) only indicates that the broadcast has been \ + successful. The beacon node is expected to integrate the new block into its state, and \ + therefore validate the block internally, however blocks which fail the validation are still \ + broadcast but a different status code is returned (202). Pre-Bellatrix, this endpoint will accept \ + a `SignedBeaconBlock`.""") .tags(TAG_BEACON, TAG_VALIDATOR_REQUIRED) + .deprecated(true) .requestBodyType( getSchemaDefinitionForAllSupportedMilestones( schemaDefinitionCache, @@ -91,7 +102,8 @@ private static EndpointMetadata createMetadata( .milestoneAtSlot(blockContainer.getSlot()) .equals(milestone)), context -> - slotBasedSelector( + headerBasedSelectorWithSlotFallback( + context.getHeaders(), context.getBody(), schemaDefinitionCache, SchemaDefinitions::getSignedBlindedBlockContainerSchema), @@ -106,6 +118,8 @@ private static EndpointMetadata createMetadata( .withBadRequestResponse(Optional.of("Unable to parse request body.")) .response( SC_SERVICE_UNAVAILABLE, "Beacon node is currently syncing.", HTTP_ERROR_RESPONSE_TYPE) + .response( + SC_NO_CONTENT, "Data is unavailable because the chain has not yet reached genesis") .build(); } } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostBlock.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostBlock.java index d59b01f4590..d713b9a3ec2 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostBlock.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostBlock.java @@ -15,8 +15,9 @@ import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.ETH_CONSENSUS_VERSION_TYPE; import static tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil.getSchemaDefinitionForAllSupportedMilestones; -import static tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil.slotBasedSelector; +import static tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil.headerBasedSelectorWithSlotFallback; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_ACCEPTED; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.SERVICE_UNAVAILABLE; @@ -70,7 +71,7 @@ public void handleRequest(final RestApiRequest request) throws JsonProcessingExc request.respondAsync( validatorDataProvider - .submitSignedBlock(requestBody, BroadcastValidationLevel.NOT_REQUIRED) + .submitSignedBlock(requestBody, BroadcastValidationLevel.GOSSIP) .thenApply(this::processSendSignedBlockResult)); } @@ -80,10 +81,17 @@ private static EndpointMetadata createMetadata( .operationId("publishBlock") .summary("Publish a signed block") .description( - "Submit a signed beacon block to the beacon node to be broadcast and imported." - + " After Deneb, this additionally instructs the beacon node to broadcast and import all given blobs." - + " The beacon node performs the required validation.") + """ + Instructs the beacon node to broadcast a newly signed beacon block to the beacon network, \ + to be included in the beacon chain. A success response (20x) indicates that the block \ + passed gossip validation and was successfully broadcast onto the network. \ + The beacon node is also expected to integrate the block into the state, but may broadcast it \ + before doing so, so as to aid timely delivery of the block. Should the block fail full \ + validation, a separate success response code (202) is used to indicate that the block was \ + successfully broadcast but failed integration. After Deneb, this additionally instructs \ + the beacon node to broadcast all given signed blobs.""") .tags(TAG_BEACON, TAG_VALIDATOR_REQUIRED) + .deprecated(true) .requestBodyType( getSchemaDefinitionForAllSupportedMilestones( schemaDefinitionCache, @@ -94,7 +102,8 @@ private static EndpointMetadata createMetadata( .milestoneAtSlot(blockContainer.getSlot()) .equals(milestone)), context -> - slotBasedSelector( + headerBasedSelectorWithSlotFallback( + context.getHeaders(), context.getBody(), schemaDefinitionCache, SchemaDefinitions::getSignedBlockContainerSchema), @@ -109,6 +118,8 @@ private static EndpointMetadata createMetadata( .withBadRequestResponse(Optional.of("Unable to parse request body.")) .response( SC_SERVICE_UNAVAILABLE, "Beacon node is currently syncing.", HTTP_ERROR_RESPONSE_TYPE) + .response( + SC_NO_CONTENT, "Data is unavailable because the chain has not yet reached genesis") .build(); } } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostBlsToExecutionChanges.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostBlsToExecutionChanges.java index e4c7cacd153..89e1c5b3cca 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostBlsToExecutionChanges.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostBlsToExecutionChanges.java @@ -75,7 +75,7 @@ private static EndpointMetadata createEndpointMetadata(final SchemaDefinitionCac } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final List blsToExecutionChanges = request.getRequestBody(); if (blsToExecutionChanges.size() > MAX_BLS_MESSAGES_PER_REQUEST) { final String errorMessage = diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostProposerSlashing.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostProposerSlashing.java index 6df0827edee..3b2e3942731 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostProposerSlashing.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostProposerSlashing.java @@ -59,7 +59,7 @@ public PostProposerSlashing(final NodeDataProvider provider) { } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final ProposerSlashing proposerSlashing = request.getRequestBody(); final SafeFuture future = nodeDataProvider.postProposerSlashing(proposerSlashing); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostStateValidatorBalances.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostStateValidatorBalances.java index 1cbbc78650f..dc081b53afb 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostStateValidatorBalances.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostStateValidatorBalances.java @@ -51,12 +51,13 @@ public PostStateValidatorBalances(final DataProvider dataProvider) { .requestBodyType(DeserializableTypeDefinition.listOf(STRING_TYPE)) .response(SC_OK, "Request successful", GetStateValidatorBalances.RESPONSE_TYPE) .withNotFoundResponse() + .withChainDataResponses() .build()); this.chainDataProvider = chainDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final Optional> validators = request.getOptionalRequestBody(); final SafeFuture>>> future = diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostStateValidators.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostStateValidators.java index 6474651f4ef..8ac822bd9b1 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostStateValidators.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostStateValidators.java @@ -59,12 +59,13 @@ public PostStateValidators(final DataProvider dataProvider) { .tags(TAG_BEACON) .response(SC_OK, "Request successful", STATE_VALIDATORS_RESPONSE_TYPE) .withNotFoundResponse() + .withChainDataResponses() .build()); this.chainDataProvider = provider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final Optional requestBody; try { diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostSyncCommittees.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostSyncCommittees.java index f82c3bf23c2..80a04e2671d 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostSyncCommittees.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostSyncCommittees.java @@ -67,12 +67,13 @@ public PostSyncCommittees(final ValidatorDataProvider provider) { SC_BAD_REQUEST, "Errors with one or more sync committee signatures", getBadRequestResponseTypes()) + .withChainDataResponses() .build()); this.provider = provider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final List messages = request.getRequestBody(); final SafeFuture> future = provider.submitCommitteeSignatures(messages); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostVoluntaryExit.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostVoluntaryExit.java index 3016aab587a..1cf7567af0e 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostVoluntaryExit.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostVoluntaryExit.java @@ -57,7 +57,7 @@ public PostVoluntaryExit(final NodeDataProvider provider) { } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final SignedVoluntaryExit exit = request.getRequestBody(); final SafeFuture future = nodeDataProvider.postVoluntaryExit(exit); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/lightclient/GetLightClientBootstrap.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/lightclient/GetLightClientBootstrap.java index 7ee0fb67c6f..03c61594361 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/lightclient/GetLightClientBootstrap.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/lightclient/GetLightClientBootstrap.java @@ -67,12 +67,13 @@ public GetLightClientBootstrap( .withNotFoundResponse() .withNotAcceptedResponse() .withNotImplementedResponse() + .withChainDataResponses() .build()); this.chainDataProvider = chainDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final Bytes32 blockRoot = request.getPathParameter(BLOCK_ROOT_PARAMETER); final SafeFuture>> future = chainDataProvider.getLightClientBoostrap(blockRoot); @@ -92,7 +93,7 @@ public void handleRequest(RestApiRequest request) throws JsonProcessingException } private static SerializableTypeDefinition> - getResponseType(SchemaDefinitionCache schemaDefinitionCache) { + getResponseType(final SchemaDefinitionCache schemaDefinitionCache) { final SerializableTypeDefinition lightClientBootstrapType = SchemaDefinitionsAltair.required( schemaDefinitionCache.getSchemaDefinition(SpecMilestone.ALTAIR)) diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/lightclient/GetLightClientUpdatesByRange.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/lightclient/GetLightClientUpdatesByRange.java index 944fc7517e4..e64ee211da7 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/lightclient/GetLightClientUpdatesByRange.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/lightclient/GetLightClientUpdatesByRange.java @@ -60,12 +60,12 @@ public GetLightClientUpdatesByRange(final SchemaDefinitionCache schemaDefinition } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { request.respondError(501, "Not implemented"); } private static ResponseContentTypeDefinition>> - getJsonResponseType(SchemaDefinitionCache schemaDefinitionCache) { + getJsonResponseType(final SchemaDefinitionCache schemaDefinitionCache) { final SerializableTypeDefinition lightClientUpdateType = SchemaDefinitionsAltair.required( schemaDefinitionCache.getSchemaDefinition(SpecMilestone.ALTAIR)) diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/builder/GetExpectedWithdrawals.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/builder/GetExpectedWithdrawals.java index 11f5833c7e4..e6a6c2d3638 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/builder/GetExpectedWithdrawals.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/builder/GetExpectedWithdrawals.java @@ -74,12 +74,13 @@ protected GetExpectedWithdrawals( .response(SC_OK, "Request successful", getResponseType(schemaDefinitionCache)) .withNotFoundResponse() .withNotImplementedResponse() + .withChainDataResponses() .build()); this.chainDataProvider = chainDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final SafeFuture>>> future = chainDataProvider.getExpectedWithdrawals( request.getPathParameter(PARAMETER_STATE_ID), diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/config/GetDepositContract.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/config/GetDepositContract.java index 60c3a358399..96846052978 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/config/GetDepositContract.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/config/GetDepositContract.java @@ -13,7 +13,7 @@ package tech.pegasys.teku.beaconrestapi.handlers.v1.config; -import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.ETH1ADDRESS_TYPE; +import static tech.pegasys.teku.ethereum.execution.types.Eth1Address.ETH1ADDRESS_TYPE; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_CONFIG; import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; @@ -64,7 +64,7 @@ public GetDepositContract( } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final long depositChainId = configProvider.getGenesisSpecConfig().getDepositChainId(); request.respondOk(new DepositContractData(depositChainId, depositContractAddress)); } @@ -73,7 +73,7 @@ static class DepositContractData { final UInt64 chainId; final Eth1Address address; - DepositContractData(long chainId, Eth1Address address) { + DepositContractData(final long chainId, final Eth1Address address) { this.chainId = UInt64.valueOf(chainId); this.address = address; } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/config/GetForkSchedule.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/config/GetForkSchedule.java index c10498c4474..d6343ff88ab 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/config/GetForkSchedule.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/config/GetForkSchedule.java @@ -56,7 +56,7 @@ public GetForkSchedule(final DataProvider dataProvider) { } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { request.respondOk(configProvider.getStateForkSchedule()); } } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/config/GetSpec.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/config/GetSpec.java index 1694f283da0..4dbc4ce083c 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/config/GetSpec.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/config/GetSpec.java @@ -51,7 +51,7 @@ public GetSpec(final DataProvider dataProvider) { } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { try { final SpecConfigData responseContext = new SpecConfigData(configProvider.getGenesisSpec()); request.respondOk(responseContext.getConfigMap()); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/debug/GetForkChoice.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/debug/GetForkChoice.java index 09c6b96af9b..439af4e1f37 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/debug/GetForkChoice.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/debug/GetForkChoice.java @@ -13,6 +13,7 @@ package tech.pegasys.teku.beaconrestapi.handlers.v1.debug; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.CACHE_NONE; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_DEBUG; @@ -71,7 +72,7 @@ public class GetForkChoice extends RestApiEndpoint { .withField("weight", UINT64_TYPE, ProtoNodeData::getWeight) .withField( "validity", - DeserializableTypeDefinition.enumOf(ProtoNodeValidationStatus.class), + DeserializableTypeDefinition.enumOf(ProtoNodeValidationStatus.class, true), ProtoNodeData::getValidationStatus) .withField( "execution_block_hash", @@ -148,13 +149,15 @@ public GetForkChoice(final ChainDataProvider chainDataProvider) { .description("Retrieves all current fork choice context.") .tags(TAG_DEBUG) .response(SC_OK, "Request successful", RESPONSE_TYPE) + .response( + SC_NO_CONTENT, "Data is unavailable because the chain has not yet reached genesis") .withServiceUnavailableResponse() .build()); this.chainDataProvider = chainDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { request.header(Header.CACHE_CONTROL, CACHE_NONE); request.respondOk(chainDataProvider.getForkChoiceData()); } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/debug/GetState.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/debug/GetState.java index 2170c1ece37..64cf1df4b59 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/debug/GetState.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/debug/GetState.java @@ -80,12 +80,13 @@ public GetState( beaconState -> spec.getForkSchedule().getSpecMilestoneAtSlot(beaconState.getSlot()))) .withNotFoundResponse() + .withChainDataResponses() .build()); this.chainDataProvider = chainDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final SafeFuture> future = chainDataProvider.getBeaconStateAndMetadata(request.getPathParameter(PARAMETER_STATE_ID)); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/AttestationEvent.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/AttestationEvent.java index b58be4856bb..3fe35205748 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/AttestationEvent.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/AttestationEvent.java @@ -17,7 +17,8 @@ public class AttestationEvent extends Event { - AttestationEvent(Attestation attestation) { - super(attestation.getSchema().getJsonTypeDefinition(), attestation); + AttestationEvent(final Attestation attestation) { + super( + attestation.getSchema().castTypeToAttestationSchema().getJsonTypeDefinition(), attestation); } } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/ContributionAndProofEvent.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/ContributionAndProofEvent.java index 03ec197a23f..9dfc8e99570 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/ContributionAndProofEvent.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/ContributionAndProofEvent.java @@ -17,7 +17,7 @@ public class ContributionAndProofEvent extends Event { - ContributionAndProofEvent(SignedContributionAndProof signedContributionAndProof) { + ContributionAndProofEvent(final SignedContributionAndProof signedContributionAndProof) { super( signedContributionAndProof.getSchema().getJsonTypeDefinition(), signedContributionAndProof); } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/Event.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/Event.java index 20a1b6589db..efe1920c831 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/Event.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/Event.java @@ -20,7 +20,7 @@ public abstract class Event { final SerializableTypeDefinition type; final T data; - Event(SerializableTypeDefinition type, T data) { + Event(final SerializableTypeDefinition type, final T data) { this.type = type; this.data = data; } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/GetEvents.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/GetEvents.java index eab07771370..44f13b3044a 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/GetEvents.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/GetEvents.java @@ -79,6 +79,7 @@ public GetEvents( .tags(TAG_EVENTS, TAG_VALIDATOR_REQUIRED) .queryParam(TOPICS_PARAMETER) .response(SC_OK, "Request successful", new EventStreamResponseContentTypeDefinition()) + .withChainDataResponses() .build()); eventSubscriptionManager = new EventSubscriptionManager( @@ -94,7 +95,7 @@ public GetEvents( } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { request.startEventStream(eventSubscriptionManager::registerClient); } } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/PayloadAttributesEvent.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/PayloadAttributesEvent.java index 967a0c5fa9c..f613e5233f5 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/PayloadAttributesEvent.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/PayloadAttributesEvent.java @@ -13,7 +13,7 @@ package tech.pegasys.teku.beaconrestapi.handlers.v1.events; -import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.ETH1ADDRESS_TYPE; +import static tech.pegasys.teku.ethereum.execution.types.Eth1Address.ETH1ADDRESS_TYPE; import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.MILESTONE_TYPE; import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.BYTES32_TYPE; import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/SyncStateChangeEvent.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/SyncStateChangeEvent.java index 2865ef2cfdc..9545b6abdfd 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/SyncStateChangeEvent.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/SyncStateChangeEvent.java @@ -26,7 +26,7 @@ public class SyncStateChangeEvent extends Event { .withField("sync_state", STRING_TYPE, Function.identity()) .build(); - SyncStateChangeEvent(String syncState) { + SyncStateChangeEvent(final String syncState) { super(SYNC_STATE_CHANGE_EVENT_TYPE, syncState); } } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetHealth.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetHealth.java index 8a0540a0ca2..e7627f7ddfa 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetHealth.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetHealth.java @@ -14,6 +14,7 @@ package tech.pegasys.teku.beaconrestapi.handlers.v1.node; import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.SYNCING_PARAMETER; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_PARTIAL_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; @@ -55,6 +56,8 @@ public GetHealth(final DataProvider provider) { .response(SC_OK, "Node is ready") .response(SC_PARTIAL_CONTENT, "Node is syncing but can serve incomplete data") .response(SC_SERVICE_UNAVAILABLE, "Node not initialized or having issues") + .response( + SC_NO_CONTENT, "Data is unavailable because the chain has not yet reached genesis") .withBadRequestResponse(Optional.of("Invalid syncing status code")) .build()); this.syncProvider = syncProvider; @@ -62,7 +65,7 @@ public GetHealth(final DataProvider provider) { } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { request.header(Header.CACHE_CONTROL, CACHE_NONE); if (!chainDataProvider.isStoreAvailable() || syncProvider.getRejectedExecutionCount() > 0) { request.respondWithCode(SC_SERVICE_UNAVAILABLE); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetPeerById.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetPeerById.java index ec8560478ae..d140b00a96a 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetPeerById.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetPeerById.java @@ -62,7 +62,7 @@ public GetPeerById(final DataProvider provider) { } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { request.header(Header.CACHE_CONTROL, CACHE_NONE); final Optional peer = network.getEth2PeerById(request.getPathParameter(PEER_ID_PARAMETER)); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetPeerCount.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetPeerCount.java index 21225652539..71c5faf78c6 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetPeerCount.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetPeerCount.java @@ -16,39 +16,19 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.CACHE_NONE; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_NODE; -import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; import com.fasterxml.jackson.core.JsonProcessingException; import io.javalin.http.Header; -import java.util.List; -import java.util.Objects; -import java.util.function.Function; import tech.pegasys.teku.api.DataProvider; import tech.pegasys.teku.api.NetworkDataProvider; -import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition; +import tech.pegasys.teku.ethereum.json.types.node.PeerCountBuilder; import tech.pegasys.teku.infrastructure.restapi.endpoints.EndpointMetadata; import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiRequest; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.networking.eth2.peers.Eth2Peer; public class GetPeerCount extends RestApiEndpoint { public static final String ROUTE = "/eth/v1/node/peer_count"; - private static final SerializableTypeDefinition PEER_COUNT_TYPE = - SerializableTypeDefinition.object(ResponseData.class) - .withField("disconnected", UINT64_TYPE, ResponseData::getDisconnected) - .withField("connecting", UINT64_TYPE, responseData -> UInt64.valueOf(0)) - .withField("connected", UINT64_TYPE, ResponseData::getConnected) - .withField("disconnecting", UINT64_TYPE, responseData -> UInt64.valueOf(0)) - .build(); - - private static final SerializableTypeDefinition RESPONSE_TYPE = - SerializableTypeDefinition.object(ResponseData.class) - .name("GetPeerCountResponse") - .withField("data", PEER_COUNT_TYPE, Function.identity()) - .build(); - private final NetworkDataProvider network; public GetPeerCount(final DataProvider provider) { @@ -62,61 +42,14 @@ public GetPeerCount(final DataProvider provider) { .summary("Get peer count") .description("Retrieves number of known peers.") .tags(TAG_NODE) - .response(SC_OK, "Request successful", RESPONSE_TYPE) + .response(SC_OK, "Request successful", PeerCountBuilder.PEER_COUNT_TYPE) .build()); this.network = network; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { request.header(Header.CACHE_CONTROL, CACHE_NONE); - request.respondOk(new ResponseData(network.getEth2Peers())); - } - - static class ResponseData { - final UInt64 disconnected; - final UInt64 connected; - - ResponseData(List peers) { - long disconnected = 0; - long connected = 0; - - for (Eth2Peer peer : peers) { - if (peer.isConnected()) { - connected++; - } else { - disconnected++; - } - } - - this.disconnected = UInt64.valueOf(disconnected); - this.connected = UInt64.valueOf(connected); - } - - UInt64 getDisconnected() { - return disconnected; - } - - UInt64 getConnected() { - return connected; - } - - @Override - public boolean equals(final Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - final ResponseData that = (ResponseData) o; - return Objects.equals(disconnected, that.disconnected) - && Objects.equals(connected, that.connected); - } - - @Override - public int hashCode() { - return Objects.hash(disconnected, connected); - } + request.respondOk(network.getPeerCount()); } } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetSyncing.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetSyncing.java index 6792868a46f..749346dd4de 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetSyncing.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetSyncing.java @@ -80,7 +80,7 @@ public GetSyncing(final DataProvider provider) { } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { request.header(Header.CACHE_CONTROL, CACHE_NONE); request.respondOk(new SyncStatusData(syncProvider, executionClientDataProvider)); } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetVersion.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetVersion.java index 5aa2c65ca20..256f57f655d 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetVersion.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetVersion.java @@ -54,7 +54,7 @@ public GetVersion() { } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { request.header(Header.CACHE_CONTROL, CACHE_NONE); request.respondOk(VersionProvider.VERSION); } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/rewards/GetAttestationRewards.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/rewards/GetAttestationRewards.java index b809f0d9128..7642123391e 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/rewards/GetAttestationRewards.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/rewards/GetAttestationRewards.java @@ -104,16 +104,16 @@ public GetAttestationRewards(final ChainDataProvider chainDataProvider) { .optionalRequestBody() .requestBodyType(DeserializableTypeDefinition.listOf(STRING_TYPE)) .response(SC_OK, "Request successful", RESPONSE_TYPE) - .withNotImplementedResponse() .withNotFoundResponse() .withInternalErrorResponse() + .withChainDataResponses() .build()); this.chainDataProvider = chainDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final UInt64 epoch = request.getPathParameter(EPOCH_PARAMETER); // Validator identifier might be the validator's public key or index. If empty we query all // validators. diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/rewards/GetBlockRewards.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/rewards/GetBlockRewards.java index 415a13c8223..39f84030f76 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/rewards/GetBlockRewards.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/rewards/GetBlockRewards.java @@ -73,12 +73,13 @@ public GetBlockRewards(final ChainDataProvider chainDataProvider) { .response(SC_OK, "Request successful", RESPONSE_TYPE) .withNotFoundResponse() .withInternalErrorResponse() + .withChainDataResponses() .build()); this.chainDataProvider = chainDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { request.respondAsync( chainDataProvider .getBlockRewardsFromBlockId(request.getPathParameter(PARAMETER_BLOCK_ID)) diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/rewards/GetSyncCommitteeRewards.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/rewards/GetSyncCommitteeRewards.java index c6a5ac27577..6696e737374 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/rewards/GetSyncCommitteeRewards.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/rewards/GetSyncCommitteeRewards.java @@ -86,12 +86,13 @@ public GetSyncCommitteeRewards(final ChainDataProvider chainDataProvider) { .response(SC_OK, "Request successful", RESPONSE_TYPE) .withNotFoundResponse() .withInternalErrorResponse() + .withChainDataResponses() .build()); this.chainDataProvider = chainDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { // Validator identifier might be the validator's public key or index. If empty we query all // validators. final Optional> maybeList = request.getOptionalRequestBody(); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetAggregateAttestation.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetAggregateAttestation.java index 4c7c850f41e..1dd8577a737 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetAggregateAttestation.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetAggregateAttestation.java @@ -34,8 +34,8 @@ import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiRequest; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; public class GetAggregateAttestation extends RestApiEndpoint { public static final String ROUTE = "/eth/v1/validator/aggregate_attestation"; @@ -57,24 +57,23 @@ public GetAggregateAttestation(final ValidatorDataProvider provider, final Spec .description( "Aggregates all attestations matching given attestation data root and slot.") .tags(TAG_VALIDATOR, TAG_VALIDATOR_REQUIRED) + .deprecated(true) .queryParamRequired(ATTESTATION_DATA_ROOT_PARAMETER) .queryParamRequired(SLOT_PARAM) - .response( - HttpStatusCodes.SC_OK, - "Request successful", - getResponseType(spec.getGenesisSpecConfig())) + .response(HttpStatusCodes.SC_OK, "Request successful", getResponseType(spec)) .withNotFoundResponse() + .withChainDataResponses() .build()); this.provider = provider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final Bytes32 beaconBlockRoot = request.getQueryParameter(ATTESTATION_DATA_ROOT_PARAMETER); final UInt64 slot = request.getQueryParameter(SLOT_PARAM); final SafeFuture> future = - provider.createAggregate(slot, beaconBlockRoot); + provider.createAggregate(slot, beaconBlockRoot, Optional.empty()); request.respondAsync( future.thenApply( @@ -84,12 +83,16 @@ public void handleRequest(RestApiRequest request) throws JsonProcessingException .orElseGet(AsyncApiResponse::respondNotFound))); } - private static SerializableTypeDefinition getResponseType(SpecConfig specConfig) { - Attestation.AttestationSchema dataSchema = new Attestation.AttestationSchema(specConfig); + private static SerializableTypeDefinition getResponseType(final Spec spec) { + final AttestationSchema dataSchema = + spec.getGenesisSchemaDefinitions().getAttestationSchema(); return SerializableTypeDefinition.object(Attestation.class) .name("GetAggregatedAttestationResponse") - .withField("data", dataSchema.getJsonTypeDefinition(), Function.identity()) + .withField( + "data", + dataSchema.castTypeToAttestationSchema().getJsonTypeDefinition(), + Function.identity()) .build(); } } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetAttestationData.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetAttestationData.java index 9ea02ad9c3e..0923b70a1ff 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetAttestationData.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetAttestationData.java @@ -74,7 +74,7 @@ public GetAttestationData(final ValidatorDataProvider provider) { } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final UInt64 slot = request.getQueryParameter(SLOT_PARAM); final UInt64 committeeIndex = request.getQueryParameter(COMMITTEE_INDEX_PARAMETER); if (committeeIndex.isLessThan(0)) { diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetNewBlindedBlock.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetNewBlindedBlock.java deleted file mode 100644 index cda922692ec..00000000000 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetNewBlindedBlock.java +++ /dev/null @@ -1,128 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.beaconrestapi.handlers.v1.validator; - -import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.GRAFFITI_PARAMETER; -import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.RANDAO_PARAMETER; -import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.SLOT_PARAMETER; -import static tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil.getSchemaDefinitionForAllSupportedMilestones; -import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.MILESTONE_TYPE; -import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.sszResponseType; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; -import static tech.pegasys.teku.infrastructure.http.RestApiConstants.SLOT_PATH_DESCRIPTION; -import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_VALIDATOR; -import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_VALIDATOR_REQUIRED; - -import com.fasterxml.jackson.core.JsonProcessingException; -import java.util.Optional; -import java.util.function.Function; -import org.apache.tuweni.bytes.Bytes32; -import tech.pegasys.teku.api.DataProvider; -import tech.pegasys.teku.api.ValidatorDataProvider; -import tech.pegasys.teku.bls.BLSSignature; -import tech.pegasys.teku.infrastructure.async.SafeFuture; -import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition; -import tech.pegasys.teku.infrastructure.restapi.endpoints.AsyncApiResponse; -import tech.pegasys.teku.infrastructure.restapi.endpoints.EndpointMetadata; -import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; -import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiRequest; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.datastructures.blocks.BlockContainer; -import tech.pegasys.teku.spec.datastructures.metadata.BlockContainerAndMetaData; -import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; -import tech.pegasys.teku.spec.schemas.SchemaDefinitions; -import tech.pegasys.teku.storage.client.ChainDataUnavailableException; - -@SuppressWarnings("unused") -public class GetNewBlindedBlock extends RestApiEndpoint { - public static final String ROUTE = "/eth/v1/validator/blinded_blocks/{slot}"; - private final ValidatorDataProvider provider; - - public GetNewBlindedBlock( - final DataProvider dataProvider, - final Spec spec, - final SchemaDefinitionCache schemaDefinitionCache) { - this(dataProvider.getValidatorDataProvider(), spec, schemaDefinitionCache); - } - - public GetNewBlindedBlock( - final ValidatorDataProvider provider, - final Spec spec, - final SchemaDefinitionCache schemaDefinitionCache) { - super(getEndpointMetaData(spec, schemaDefinitionCache)); - this.provider = provider; - } - - private static EndpointMetadata getEndpointMetaData( - final Spec spec, final SchemaDefinitionCache schemaDefinitionCache) { - return EndpointMetadata.get(ROUTE) - .operationId("produceBlindedBlock") - .summary("Produce unsigned blinded block") - .description( - "Requests a beacon node to produce a valid blinded block, which can then be signed by a validator. " - + "A blinded block is a block with only a transactions root, rather than a full transactions list.\n\n" - + "Metadata in the response indicates the type of block produced, and the supported types of block " - + "will be added to as forks progress.\n\n" - + "Pre-Bellatrix, this endpoint will return a `BeaconBlock`.") - .tags(TAG_VALIDATOR, TAG_VALIDATOR_REQUIRED) - .pathParam(SLOT_PARAMETER.withDescription(SLOT_PATH_DESCRIPTION)) - .queryParamRequired(RANDAO_PARAMETER) - .queryParam(GRAFFITI_PARAMETER) - .response( - SC_OK, - "Request successful", - SerializableTypeDefinition.object() - .name("GetNewBlindedBlockResponse") - .withField( - "data", - getSchemaDefinitionForAllSupportedMilestones( - schemaDefinitionCache, - "BlindedBlock", - SchemaDefinitions::getBlindedBlockContainerSchema, - (blockContainer, milestone) -> - schemaDefinitionCache - .milestoneAtSlot(blockContainer.getSlot()) - .equals(milestone)), - Function.identity()) - .withField( - "version", - MILESTONE_TYPE, - blockContainer -> - schemaDefinitionCache.milestoneAtSlot(blockContainer.getSlot())) - .build(), - sszResponseType( - blockContainer -> - spec.getForkSchedule().getSpecMilestoneAtSlot(blockContainer.getSlot()))) - .build(); - } - - @Override - @SuppressWarnings("deprecation") - public void handleRequest(final RestApiRequest request) throws JsonProcessingException { - final UInt64 slot = - request.getPathParameter(SLOT_PARAMETER.withDescription(SLOT_PATH_DESCRIPTION)); - final BLSSignature randao = request.getQueryParameter(RANDAO_PARAMETER); - final Optional graffiti = request.getOptionalQueryParameter(GRAFFITI_PARAMETER); - final SafeFuture> result = - provider.getUnsignedBeaconBlockAtSlot(slot, randao, graffiti, true, Optional.empty()); - request.respondAsync( - result.thenApplyChecked( - maybeBlock -> - maybeBlock - .map(BlockContainerAndMetaData::blockContainer) - .map(AsyncApiResponse::respondOk) - .orElseThrow(ChainDataUnavailableException::new))); - } -} diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetProposerDuties.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetProposerDuties.java index 4f2ffd2c7eb..cfe43d483a3 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetProposerDuties.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetProposerDuties.java @@ -20,7 +20,6 @@ import static tech.pegasys.teku.infrastructure.http.RestApiConstants.SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_VALIDATOR; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_VALIDATOR_REQUIRED; -import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.HTTP_ERROR_RESPONSE_TYPE; import com.fasterxml.jackson.core.JsonProcessingException; import java.util.Optional; @@ -64,14 +63,14 @@ public GetProposerDuties(final DataProvider dataProvider) { .tags(TAG_VALIDATOR, TAG_VALIDATOR_REQUIRED) .pathParam(EPOCH_PARAMETER) .response(SC_OK, "Request successful", PROPOSER_DUTIES_TYPE) - .response(SC_SERVICE_UNAVAILABLE, "Service unavailable", HTTP_ERROR_RESPONSE_TYPE) + .withChainDataResponses() .build()); this.validatorDataProvider = validatorDataProvider; this.syncDataProvider = syncDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { if (!validatorDataProvider.isStoreAvailable() || syncDataProvider.isSyncing()) { request.respondError(SC_SERVICE_UNAVAILABLE, SERVICE_UNAVAILABLE); return; diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetSyncCommitteeContribution.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetSyncCommitteeContribution.java index 86caf66cf8e..c52b54b29ba 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetSyncCommitteeContribution.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetSyncCommitteeContribution.java @@ -72,7 +72,7 @@ public GetSyncCommitteeContribution( } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final UInt64 slot = request.getQueryParameter(SLOT_PARAMETER.withDescription(SLOT_QUERY_DESCRIPTION)); final Bytes32 blockRoot = request.getQueryParameter(BEACON_BLOCK_ROOT_PARAMETER); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostAggregateAndProofs.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostAggregateAndProofs.java index fa020b9c1bd..7136f411895 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostAggregateAndProofs.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostAggregateAndProofs.java @@ -29,8 +29,9 @@ import tech.pegasys.teku.infrastructure.restapi.endpoints.EndpointMetadata; import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiRequest; +import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof; -import tech.pegasys.teku.spec.schemas.SchemaDefinitions; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; import tech.pegasys.teku.validator.api.SubmitDataError; public class PostAggregateAndProofs extends RestApiEndpoint { @@ -38,12 +39,12 @@ public class PostAggregateAndProofs extends RestApiEndpoint { private final ValidatorDataProvider provider; public PostAggregateAndProofs( - final DataProvider provider, final SchemaDefinitions schemaDefinitions) { - this(provider.getValidatorDataProvider(), schemaDefinitions); + final DataProvider provider, final SchemaDefinitionCache schemaDefinitionCache) { + this(provider.getValidatorDataProvider(), schemaDefinitionCache); } public PostAggregateAndProofs( - final ValidatorDataProvider provider, final SchemaDefinitions schemaDefinitions) { + final ValidatorDataProvider provider, final SchemaDefinitionCache schemaDefinitionCache) { super( EndpointMetadata.post(ROUTE) .operationId("publishAggregateAndProofs") @@ -51,16 +52,21 @@ public PostAggregateAndProofs( .description( "Verifies given aggregate and proofs and publishes it on appropriate gossipsub topic.") .tags(TAG_VALIDATOR, TAG_VALIDATOR_REQUIRED) + .deprecated(true) .requestBodyType( DeserializableTypeDefinition.listOf( - schemaDefinitions.getSignedAggregateAndProofSchema().getJsonTypeDefinition())) + schemaDefinitionCache + .getSchemaDefinition(SpecMilestone.PHASE0) + .getSignedAggregateAndProofSchema() + .getJsonTypeDefinition())) .response(SC_OK, "Successfully published aggregate.") + .withChainDataResponses() .build()); this.provider = provider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final List signedAggregateAndProofs = request.getRequestBody(); final SafeFuture> future = provider.sendAggregateAndProofs(signedAggregateAndProofs); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostAttesterDuties.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostAttesterDuties.java index 57e0a084ed4..e8d4096a59e 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostAttesterDuties.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostAttesterDuties.java @@ -15,6 +15,7 @@ import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.EPOCH_PARAMETER; import static tech.pegasys.teku.ethereum.json.types.validator.AttesterDutiesBuilder.ATTESTER_DUTIES_RESPONSE_TYPE; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_VALIDATOR; @@ -71,6 +72,8 @@ public PostAttesterDuties(final DataProvider dataProvider) { .requestBodyType(DeserializableTypeDefinition.listOf(INTEGER_TYPE, 1)) .pathParam(EPOCH_PARAMETER) .response(SC_OK, "Success response", ATTESTER_DUTIES_RESPONSE_TYPE) + .response( + SC_NO_CONTENT, "Data is unavailable because the chain has not yet reached genesis") .withServiceUnavailableResponse() .build()); this.validatorDataProvider = validatorDataProvider; @@ -78,7 +81,7 @@ public PostAttesterDuties(final DataProvider dataProvider) { } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { if (!validatorDataProvider.isStoreAvailable() || syncDataProvider.isSyncing()) { request.respondError( SC_SERVICE_UNAVAILABLE, "Beacon node is currently syncing and not serving requests."); diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostContributionAndProofs.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostContributionAndProofs.java index a818f3ac1ab..727f4e04df7 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostContributionAndProofs.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostContributionAndProofs.java @@ -53,12 +53,13 @@ public PostContributionAndProofs( .requestBodyType( DeserializableTypeDefinition.listOf(getRequestType(schemaDefinitionCache))) .response(SC_OK, "Successful response") + .withChainDataResponses() .build()); this.provider = provider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final SafeFuture future = provider.sendContributionAndProofs(request.getRequestBody()); request.respondAsync(future.thenApply(v -> AsyncApiResponse.respondWithCode(SC_OK))); } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostPrepareBeaconProposer.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostPrepareBeaconProposer.java index e20e2adfbf7..7d05b839a1f 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostPrepareBeaconProposer.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostPrepareBeaconProposer.java @@ -13,15 +13,12 @@ package tech.pegasys.teku.beaconrestapi.handlers.v1.validator; -import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.ETH1ADDRESS_TYPE; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_VALIDATOR; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_VALIDATOR_REQUIRED; -import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; import static tech.pegasys.teku.infrastructure.logging.StatusLogger.STATUS_LOG; import com.fasterxml.jackson.core.JsonProcessingException; -import com.google.common.annotations.VisibleForTesting; import java.util.List; import java.util.Optional; import tech.pegasys.teku.api.DataProvider; @@ -32,33 +29,11 @@ import tech.pegasys.teku.infrastructure.restapi.endpoints.EndpointMetadata; import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiRequest; -import tech.pegasys.teku.spec.datastructures.operations.versions.bellatrix.BeaconPreparableProposer; +import tech.pegasys.teku.spec.datastructures.validator.BeaconPreparableProposer; public class PostPrepareBeaconProposer extends RestApiEndpoint { public static final String ROUTE = "/eth/v1/validator/prepare_beacon_proposer"; - @VisibleForTesting - public static final DeserializableTypeDefinition - BEACON_PREPARABLE_PROPOSER_TYPE = - DeserializableTypeDefinition.object( - BeaconPreparableProposer.class, BeaconPreparableProposer.Builder.class) - .name("BeaconPreparableProposer") - .finisher(BeaconPreparableProposer.Builder::build) - .initializer(BeaconPreparableProposer::builder) - .description( - "The fee recipient that should be used by an associated validator index.") - .withField( - "validator_index", - UINT64_TYPE, - BeaconPreparableProposer::getValidatorIndex, - BeaconPreparableProposer.Builder::validatorIndex) - .withField( - "fee_recipient", - ETH1ADDRESS_TYPE, - BeaconPreparableProposer::getFeeRecipient, - BeaconPreparableProposer.Builder::feeRecipient) - .build(); - private final ValidatorDataProvider validatorDataProvider; private final boolean isProposerDefaultFeeRecipientDefined; @@ -97,12 +72,13 @@ private static EndpointMetadata createMetadata() { + "Note that because the information is not persistent across beacon node restarts it is recommended that either the beacon node is monitored for restarts or this information is refreshed by resending this request periodically (for example, each epoch).\n\n" + "Also note that requests containing currently inactive or unknown validator indices will be accepted, as they may become active at a later epoch.") .tags(TAG_VALIDATOR, TAG_VALIDATOR_REQUIRED) - .requestBodyType(DeserializableTypeDefinition.listOf(BEACON_PREPARABLE_PROPOSER_TYPE)) + .requestBodyType(DeserializableTypeDefinition.listOf(BeaconPreparableProposer.SSZ_DATA)) .response(SC_OK, "Preparation information has been received.") .response( HttpStatusCodes.SC_ACCEPTED, "Block has been successfully broadcast, but failed validation and has not been imported.") .withBadRequestResponse(Optional.of("Invalid parameter supplied.")) + .withChainDataResponses() .build(); } } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostRegisterValidator.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostRegisterValidator.java index 5072add41dc..c4b21bdb865 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostRegisterValidator.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostRegisterValidator.java @@ -57,6 +57,7 @@ public PostRegisterValidator(final ValidatorDataProvider validatorDataProvider) .withBadRequestResponse( Optional.of( "The request could not be processed, check the response for more information.")) + .withChainDataResponses() .build()); this.validatorDataProvider = validatorDataProvider; diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostSubscribeToBeaconCommitteeSubnet.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostSubscribeToBeaconCommitteeSubnet.java index 73e43a2bc7e..f9f3d0cd909 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostSubscribeToBeaconCommitteeSubnet.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostSubscribeToBeaconCommitteeSubnet.java @@ -13,15 +13,12 @@ package tech.pegasys.teku.beaconrestapi.handlers.v1.validator; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_VALIDATOR; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_VALIDATOR_REQUIRED; -import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.BOOLEAN_TYPE; -import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.INTEGER_TYPE; -import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; import com.fasterxml.jackson.core.JsonProcessingException; import java.util.List; -import java.util.Objects; import tech.pegasys.teku.api.DataProvider; import tech.pegasys.teku.api.ValidatorDataProvider; import tech.pegasys.teku.infrastructure.http.HttpStatusCodes; @@ -30,45 +27,13 @@ import tech.pegasys.teku.infrastructure.restapi.endpoints.EndpointMetadata; import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiRequest; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.validator.api.CommitteeSubscriptionData; import tech.pegasys.teku.validator.api.CommitteeSubscriptionRequest; public class PostSubscribeToBeaconCommitteeSubnet extends RestApiEndpoint { public static final String ROUTE = "/eth/v1/validator/beacon_committee_subscriptions"; private final ValidatorDataProvider provider; - private static final DeserializableTypeDefinition - COMMITTEE_SUBSCRIPTION_REQUEST_TYPE = - DeserializableTypeDefinition.object(CommitteeSubscriptionData.class) - .name("CommitteeSubscriptionData") - .initializer(CommitteeSubscriptionData::new) - .withField( - "validator_index", - INTEGER_TYPE, - CommitteeSubscriptionData::getValidatorIndex, - CommitteeSubscriptionData::setValidatorIndex) - .withField( - "committee_index", - INTEGER_TYPE, - CommitteeSubscriptionData::getCommitteeIndex, - CommitteeSubscriptionData::setCommitteeIndex) - .withField( - "committees_at_slot", - UINT64_TYPE, - CommitteeSubscriptionData::getCommitteesAtSlot, - CommitteeSubscriptionData::setCommitteesAtSlot) - .withField( - "slot", - UINT64_TYPE, - CommitteeSubscriptionData::getSlot, - CommitteeSubscriptionData::setSlot) - .withField( - "is_aggregator", - BOOLEAN_TYPE, - CommitteeSubscriptionData::isAggregator, - CommitteeSubscriptionData::setAggregator) - .build(); - public PostSubscribeToBeaconCommitteeSubnet(final DataProvider dataProvider) { this(dataProvider.getValidatorDataProvider()); } @@ -84,17 +49,19 @@ public PostSubscribeToBeaconCommitteeSubnet(final ValidatorDataProvider provider + "- aggregate attestations received on that subnet\n") .tags(TAG_VALIDATOR, TAG_VALIDATOR_REQUIRED) .requestBodyType( - DeserializableTypeDefinition.listOf(COMMITTEE_SUBSCRIPTION_REQUEST_TYPE)) + DeserializableTypeDefinition.listOf(CommitteeSubscriptionData.SSZ_DATA)) .response( HttpStatusCodes.SC_OK, "Slot signature is valid and beacon node has prepared the attestation subnet. Note that, there is no guarantee the node will find peers for the subnet") + .response( + SC_NO_CONTENT, "Data is unavailable because the chain has not yet reached genesis") .withServiceUnavailableResponse() .build()); this.provider = provider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final List requestBody = request.getRequestBody(); final List subscriptionRequests = requestBody.stream() @@ -105,109 +72,4 @@ public void handleRequest(RestApiRequest request) throws JsonProcessingException .subscribeToBeaconCommittee(subscriptionRequests) .thenApply(AsyncApiResponse::respondOk)); } - - static class CommitteeSubscriptionData { - private int validatorIndex; - private int committeeIndex; - private UInt64 committeesAtSlot; - private UInt64 slot; - private boolean isAggregator; - - CommitteeSubscriptionData() {} - - CommitteeSubscriptionData( - int validatorIndex, - int committeeIndex, - UInt64 committeesAtSlot, - UInt64 slot, - boolean isAggregator) { - this.validatorIndex = validatorIndex; - this.committeeIndex = committeeIndex; - this.committeesAtSlot = committeesAtSlot; - this.slot = slot; - this.isAggregator = isAggregator; - } - - public CommitteeSubscriptionRequest toCommitteeSubscriptionRequest() { - return new CommitteeSubscriptionRequest( - validatorIndex, committeeIndex, committeesAtSlot, slot, isAggregator); - } - - public int getValidatorIndex() { - return validatorIndex; - } - - public void setValidatorIndex(int validatorIndex) { - this.validatorIndex = validatorIndex; - } - - public int getCommitteeIndex() { - return committeeIndex; - } - - public void setCommitteeIndex(int committeeIndex) { - this.committeeIndex = committeeIndex; - } - - public UInt64 getCommitteesAtSlot() { - return committeesAtSlot; - } - - public void setCommitteesAtSlot(UInt64 committeesAtSlot) { - this.committeesAtSlot = committeesAtSlot; - } - - public UInt64 getSlot() { - return slot; - } - - public void setSlot(UInt64 slot) { - this.slot = slot; - } - - public boolean isAggregator() { - return isAggregator; - } - - public void setAggregator(boolean aggregator) { - isAggregator = aggregator; - } - - @Override - public boolean equals(Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - CommitteeSubscriptionData that = (CommitteeSubscriptionData) o; - return validatorIndex == that.validatorIndex - && committeeIndex == that.committeeIndex - && isAggregator == that.isAggregator - && Objects.equals(committeesAtSlot, that.committeesAtSlot) - && Objects.equals(slot, that.slot); - } - - @Override - public int hashCode() { - return Objects.hash(validatorIndex, committeeIndex, committeesAtSlot, slot, isAggregator); - } - - @Override - public String toString() { - return "CommitteeSubscriptionData{" - + "validatorIndex=" - + validatorIndex - + ", committeeIndex=" - + committeeIndex - + ", committeesAtSlot=" - + committeesAtSlot - + ", slot=" - + slot - + ", isAggregator=" - + isAggregator - + '}'; - } - } } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostSyncCommitteeSubscriptions.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostSyncCommitteeSubscriptions.java index b5444f99504..574063023d4 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostSyncCommitteeSubscriptions.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostSyncCommitteeSubscriptions.java @@ -13,53 +13,27 @@ package tech.pegasys.teku.beaconrestapi.handlers.v1.validator; +import static tech.pegasys.teku.ethereum.json.types.validator.PostSyncCommitteeData.SYNC_COMMITTEE_SUBSCRIPTION; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_VALIDATOR; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_VALIDATOR_REQUIRED; -import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.INTEGER_TYPE; -import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; import com.fasterxml.jackson.core.JsonProcessingException; -import it.unimi.dsi.fastutil.ints.IntArrayList; -import it.unimi.dsi.fastutil.ints.IntOpenHashSet; -import it.unimi.dsi.fastutil.ints.IntSet; import java.util.List; -import java.util.Objects; import tech.pegasys.teku.api.DataProvider; import tech.pegasys.teku.api.ValidatorDataProvider; +import tech.pegasys.teku.ethereum.json.types.validator.PostSyncCommitteeData; +import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; import tech.pegasys.teku.infrastructure.restapi.endpoints.AsyncApiResponse; import tech.pegasys.teku.infrastructure.restapi.endpoints.EndpointMetadata; import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiRequest; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.validator.api.SyncCommitteeSubnetSubscription; public class PostSyncCommitteeSubscriptions extends RestApiEndpoint { public static final String ROUTE = "/eth/v1/validator/sync_committee_subscriptions"; private final ValidatorDataProvider provider; - static final DeserializableTypeDefinition REQUEST_TYPE = - DeserializableTypeDefinition.object(PostSyncCommitteeData.class) - .name("PostSyncCommitteeData") - .initializer(PostSyncCommitteeData::new) - .withField( - "validator_index", - INTEGER_TYPE, - PostSyncCommitteeData::getValidatorIndex, - PostSyncCommitteeData::setValidatorIndex) - .withField( - "sync_committee_indices", - DeserializableTypeDefinition.listOf(INTEGER_TYPE), - PostSyncCommitteeData::getSyncCommitteeIndices, - PostSyncCommitteeData::setSyncCommitteeIndices) - .withField( - "until_epoch", - UINT64_TYPE, - PostSyncCommitteeData::getUntilEpoch, - PostSyncCommitteeData::setUntilEpoch) - .build(); - public PostSyncCommitteeSubscriptions(final DataProvider dataProvider) { this(dataProvider.getValidatorDataProvider()); } @@ -74,14 +48,15 @@ public PostSyncCommitteeSubscriptions(final ValidatorDataProvider validatorDataP + "Sync committees are not present in phase0, but are required for Altair networks.\n\n" + "Subscribing to sync committee subnets is an action performed by VC to enable network participation in Altair networks, and only required if the VC has an active validator in an active sync committee.") .tags(TAG_VALIDATOR, TAG_VALIDATOR_REQUIRED) - .requestBodyType(DeserializableTypeDefinition.listOf(REQUEST_TYPE)) + .requestBodyType(DeserializableTypeDefinition.listOf(SYNC_COMMITTEE_SUBSCRIPTION)) .response(SC_OK, "Successful response") + .withChainDataResponses() .build()); this.provider = validatorDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final List requestData = request.getRequestBody(); final List subscriptions = requestData.stream().map(PostSyncCommitteeData::toSyncCommitteeSubnetSubscription).toList(); @@ -90,78 +65,4 @@ public void handleRequest(RestApiRequest request) throws JsonProcessingException .subscribeToSyncCommitteeSubnets(subscriptions) .thenApply(AsyncApiResponse::respondOk)); } - - public static class PostSyncCommitteeData { - private int validatorIndex; - private IntSet syncCommitteeIndices; - private UInt64 untilEpoch; - - public PostSyncCommitteeData() {} - - public PostSyncCommitteeData( - final int validatorIndex, final IntSet syncCommitteeIndices, final UInt64 untilEpoch) { - this.validatorIndex = validatorIndex; - this.syncCommitteeIndices = syncCommitteeIndices; - this.untilEpoch = untilEpoch; - } - - public SyncCommitteeSubnetSubscription toSyncCommitteeSubnetSubscription() { - return new SyncCommitteeSubnetSubscription(validatorIndex, syncCommitteeIndices, untilEpoch); - } - - public int getValidatorIndex() { - return validatorIndex; - } - - public void setValidatorIndex(int validatorIndex) { - this.validatorIndex = validatorIndex; - } - - public List getSyncCommitteeIndices() { - return new IntArrayList(syncCommitteeIndices); - } - - public void setSyncCommitteeIndices(List syncCommitteeIndices) { - this.syncCommitteeIndices = new IntOpenHashSet(syncCommitteeIndices); - } - - public UInt64 getUntilEpoch() { - return untilEpoch; - } - - public void setUntilEpoch(UInt64 untilEpoch) { - this.untilEpoch = untilEpoch; - } - - @Override - public boolean equals(Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - PostSyncCommitteeData that = (PostSyncCommitteeData) o; - return validatorIndex == that.validatorIndex - && Objects.equals(syncCommitteeIndices, that.syncCommitteeIndices) - && Objects.equals(untilEpoch, that.untilEpoch); - } - - @Override - public int hashCode() { - return Objects.hash(validatorIndex, syncCommitteeIndices, untilEpoch); - } - - @Override - public String toString() { - return "PostSyncCommitteeData{" - + "validatorIndex=" - + validatorIndex - + ", syncCommitteeIndices=" - + syncCommitteeIndices - + ", untilEpoch=" - + untilEpoch - + '}'; - } - } } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostSyncDuties.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostSyncDuties.java index f4359020ca9..7f6e79c8438 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostSyncDuties.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostSyncDuties.java @@ -15,6 +15,7 @@ import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.EPOCH_PARAMETER; import static tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeDutiesBuilder.SYNC_COMMITTEE_DUTIES_TYPE; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.SERVICE_UNAVAILABLE; @@ -60,13 +61,15 @@ public PostSyncDuties(final DataProvider dataProvider) { .requestBodyType(DeserializableTypeDefinition.listOf(INTEGER_TYPE, 1)) .response(SC_OK, "Request successful", SYNC_COMMITTEE_DUTIES_TYPE) .withServiceUnavailableResponse() + .response( + SC_NO_CONTENT, "Data is unavailable because the chain has not yet reached genesis") .build()); this.validatorDataProvider = validatorDataProvider; this.syncDataProvider = syncDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { if (!validatorDataProvider.isStoreAvailable() || syncDataProvider.isSyncing()) { request.respondError(SC_SERVICE_UNAVAILABLE, SERVICE_UNAVAILABLE); return; diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostValidatorLiveness.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostValidatorLiveness.java index d23b315d1c8..f1ac9ab69bc 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostValidatorLiveness.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostValidatorLiveness.java @@ -14,6 +14,7 @@ package tech.pegasys.teku.beaconrestapi.handlers.v1.validator; import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.EPOCH_PARAMETER; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_VALIDATOR; import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; @@ -78,6 +79,8 @@ public PostValidatorLiveness( .pathParam(EPOCH_PARAMETER) .requestBodyType(DeserializableTypeDefinition.listOf(UINT64_TYPE, 1)) .response(SC_OK, "Successful Response", RESPONSE_TYPE) + .response( + SC_NO_CONTENT, "Data is unavailable because the chain has not yet reached genesis") .withServiceUnavailableResponse() .build()); this.chainDataProvider = chainDataProvider; @@ -86,7 +89,7 @@ public PostValidatorLiveness( } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { if (!chainDataProvider.isStoreAvailable() || syncDataProvider.isSyncing()) { throw new ServiceUnavailableException(); } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetAttestationsV2.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetAttestationsV2.java new file mode 100644 index 00000000000..4ae861f7949 --- /dev/null +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetAttestationsV2.java @@ -0,0 +1,128 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.beaconrestapi.handlers.v2.beacon; + +import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.COMMITTEE_INDEX_PARAMETER; +import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.SLOT_PARAMETER; +import static tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil.getMultipleSchemaDefinitionFromMilestone; +import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.ETH_CONSENSUS_HEADER_TYPE; +import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.MILESTONE_TYPE; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.CACHE_NONE; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.SLOT_QUERY_DESCRIPTION; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_BEACON; +import static tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition.listOf; + +import com.fasterxml.jackson.core.JsonProcessingException; +import io.javalin.http.Header; +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import tech.pegasys.teku.api.DataProvider; +import tech.pegasys.teku.api.NodeDataProvider; +import tech.pegasys.teku.api.schema.Version; +import tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil; +import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition; +import tech.pegasys.teku.infrastructure.restapi.endpoints.EndpointMetadata; +import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; +import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiRequest; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; +import tech.pegasys.teku.spec.schemas.SchemaDefinitions; + +public class GetAttestationsV2 extends RestApiEndpoint { + + public static final String ROUTE = "/eth/v2/beacon/pool/attestations"; + + private final NodeDataProvider nodeDataProvider; + + public GetAttestationsV2( + final DataProvider dataProvider, final SchemaDefinitionCache schemaDefinitionCache) { + + this(dataProvider.getNodeDataProvider(), schemaDefinitionCache); + } + + public GetAttestationsV2( + final NodeDataProvider nodeDataProvider, final SchemaDefinitionCache schemaDefinitionCache) { + super( + EndpointMetadata.get(ROUTE) + .operationId("getPoolAttestationsV2") + .summary("Get Attestations from operations pool") + .description( + "Retrieves attestations known by the node but not necessarily incorporated into any block.") + .tags(TAG_BEACON) + .queryParam(SLOT_PARAMETER.withDescription(SLOT_QUERY_DESCRIPTION)) + .queryParam(COMMITTEE_INDEX_PARAMETER) + .response( + SC_OK, + "Request successful", + getResponseType(schemaDefinitionCache), + ETH_CONSENSUS_HEADER_TYPE) + .build()); + this.nodeDataProvider = nodeDataProvider; + } + + @Override + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { + request.header(Header.CACHE_CONTROL, CACHE_NONE); + final Optional slot = + request.getOptionalQueryParameter(SLOT_PARAMETER.withDescription(SLOT_QUERY_DESCRIPTION)); + final Optional committeeIndex = + request.getOptionalQueryParameter(COMMITTEE_INDEX_PARAMETER); + final ObjectAndMetaData> attestationsAndMetaData = + nodeDataProvider.getAttestationsAndMetaData(slot, committeeIndex); + + request.header( + HEADER_CONSENSUS_VERSION, + Version.fromMilestone(attestationsAndMetaData.getMilestone()).name()); + request.respondOk(attestationsAndMetaData); + } + + private static SerializableTypeDefinition>> getResponseType( + final SchemaDefinitionCache schemaDefinitionCache) { + + final List> schemaGetters = + generateAttestationSchemaGetters(schemaDefinitionCache); + + final SerializableTypeDefinition attestationType = + getMultipleSchemaDefinitionFromMilestone( + schemaDefinitionCache, "Attestation", schemaGetters); + + return SerializableTypeDefinition.>>object() + .name("GetPoolAttestationsV2Response") + .withField("version", MILESTONE_TYPE, ObjectAndMetaData::getMilestone) + .withField("data", listOf(attestationType), ObjectAndMetaData::getData) + .build(); + } + + private static List> + generateAttestationSchemaGetters(final SchemaDefinitionCache schemaDefinitionCache) { + final List> schemaGetterList = + new ArrayList<>(); + + schemaGetterList.add( + new MilestoneDependentTypesUtil.ConditionalSchemaGetter<>( + (attestation, milestone) -> + schemaDefinitionCache + .milestoneAtSlot(attestation.getData().getSlot()) + .equals(milestone), + SpecMilestone.PHASE0, + SchemaDefinitions::getAttestationSchema)); + return schemaGetterList; + } +} diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetAttesterSlashingsV2.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetAttesterSlashingsV2.java new file mode 100644 index 00000000000..80ee43369b7 --- /dev/null +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetAttesterSlashingsV2.java @@ -0,0 +1,127 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.beaconrestapi.handlers.v2.beacon; + +import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.ETH_CONSENSUS_HEADER_TYPE; +import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.MILESTONE_TYPE; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.CACHE_NONE; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_BEACON; +import static tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition.listOf; + +import com.fasterxml.jackson.core.JsonProcessingException; +import io.javalin.http.Header; +import java.util.List; +import java.util.function.Predicate; +import tech.pegasys.teku.api.DataProvider; +import tech.pegasys.teku.api.NodeDataProvider; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.json.types.SerializableOneOfTypeDefinition; +import tech.pegasys.teku.infrastructure.json.types.SerializableOneOfTypeDefinitionBuilder; +import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition; +import tech.pegasys.teku.infrastructure.restapi.endpoints.EndpointMetadata; +import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; +import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiRequest; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; +import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; + +public class GetAttesterSlashingsV2 extends RestApiEndpoint { + public static final String ROUTE = "/eth/v2/beacon/pool/attester_slashings"; + private final NodeDataProvider nodeDataProvider; + + public GetAttesterSlashingsV2( + final DataProvider dataProvider, final SchemaDefinitionCache schemaDefinitionCache) { + this(dataProvider.getNodeDataProvider(), schemaDefinitionCache); + } + + GetAttesterSlashingsV2( + final NodeDataProvider provider, final SchemaDefinitionCache schemaDefinitionCache) { + super( + EndpointMetadata.get(ROUTE) + .operationId("getPoolAttesterSlashingsV2") + .summary("Get AttesterSlashings from operations pool") + .description( + "Retrieves attester slashings known by the node but not necessarily incorporated into any block.") + .tags(TAG_BEACON) + .response( + SC_OK, + "Request successful", + getResponseType(schemaDefinitionCache), + ETH_CONSENSUS_HEADER_TYPE) + .build()); + this.nodeDataProvider = provider; + } + + @Override + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { + request.header(Header.CACHE_CONTROL, CACHE_NONE); + ObjectAndMetaData> attesterSlashingsWithMetadaData = + nodeDataProvider.getAttesterSlashingsAndMetaData(); + request.header(HEADER_CONSENSUS_VERSION, attesterSlashingsWithMetadaData.getMilestone().name()); + request.respondOk(attesterSlashingsWithMetadaData); + } + + private static SerializableTypeDefinition>> + getResponseType(final SchemaDefinitionCache schemaDefinitionCache) { + + final DeserializableTypeDefinition attesterSlashingPhase0Schema = + schemaDefinitionCache + .getSchemaDefinition(SpecMilestone.PHASE0) + .getAttesterSlashingSchema() + .getJsonTypeDefinition(); + + final DeserializableTypeDefinition attesterSlashingElectraSchema = + schemaDefinitionCache + .getSchemaDefinition(SpecMilestone.ELECTRA) + .getAttesterSlashingSchema() + .getJsonTypeDefinition(); + + final SerializableOneOfTypeDefinition> oneOfTypeDefinition = + new SerializableOneOfTypeDefinitionBuilder>() + .withType( + electraAttesterSlashingsPredicate(schemaDefinitionCache), + listOf(attesterSlashingElectraSchema)) + .withType( + phase0AttesterSlashingsPredicate(schemaDefinitionCache), + listOf(attesterSlashingPhase0Schema)) + .build(); + + return SerializableTypeDefinition.>>object() + .name("GetPoolAttesterSlashingsV2Response") + .withField("version", MILESTONE_TYPE, ObjectAndMetaData::getMilestone) + .withField("data", oneOfTypeDefinition, ObjectAndMetaData::getData) + .build(); + } + + private static Predicate> electraAttesterSlashingsPredicate( + final SchemaDefinitionCache schemaDefinitionCache) { + return attesterSlashings -> + !attesterSlashings.isEmpty() + && schemaDefinitionCache + .milestoneAtSlot(attesterSlashings.get(0).getAttestation1().getData().getSlot()) + .isGreaterThanOrEqualTo(SpecMilestone.ELECTRA); + } + + private static Predicate> phase0AttesterSlashingsPredicate( + final SchemaDefinitionCache schemaDefinitionCache) { + return attesterSlashings -> + attesterSlashings.isEmpty() + || !schemaDefinitionCache + .milestoneAtSlot(attesterSlashings.get(0).getAttestation1().getData().getSlot()) + .isGreaterThanOrEqualTo(SpecMilestone.ELECTRA); + } +} diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetBlock.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetBlock.java index 793b2084b94..cac0ebdc4dc 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetBlock.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetBlock.java @@ -65,12 +65,13 @@ public GetBlock( getResponseType(schemaDefinitionCache), sszResponseType()) .withNotFoundResponse() + .withChainDataResponses() .build()); this.chainDataProvider = chainDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final SafeFuture>> future = chainDataProvider.getBlock(request.getPathParameter(PARAMETER_BLOCK_ID)); @@ -89,7 +90,7 @@ public void handleRequest(RestApiRequest request) throws JsonProcessingException } private static SerializableTypeDefinition> getResponseType( - SchemaDefinitionCache schemaDefinitionCache) { + final SchemaDefinitionCache schemaDefinitionCache) { final SerializableTypeDefinition signedBeaconBlockType = getSchemaDefinitionForAllSupportedMilestones( schemaDefinitionCache, diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetBlockAttestationsV2.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetBlockAttestationsV2.java new file mode 100644 index 00000000000..9bf0391d2d0 --- /dev/null +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetBlockAttestationsV2.java @@ -0,0 +1,129 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.beaconrestapi.handlers.v2.beacon; + +import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.PARAMETER_BLOCK_ID; +import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.ETH_CONSENSUS_HEADER_TYPE; +import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.MILESTONE_TYPE; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.EXECUTION_OPTIMISTIC; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.FINALIZED; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_BEACON; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.BOOLEAN_TYPE; +import static tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition.listOf; + +import com.fasterxml.jackson.core.JsonProcessingException; +import java.util.List; +import java.util.Optional; +import java.util.function.Predicate; +import tech.pegasys.teku.api.ChainDataProvider; +import tech.pegasys.teku.api.DataProvider; +import tech.pegasys.teku.api.schema.Version; +import tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.json.types.SerializableOneOfTypeDefinition; +import tech.pegasys.teku.infrastructure.json.types.SerializableOneOfTypeDefinitionBuilder; +import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition; +import tech.pegasys.teku.infrastructure.restapi.endpoints.AsyncApiResponse; +import tech.pegasys.teku.infrastructure.restapi.endpoints.EndpointMetadata; +import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; +import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiRequest; +import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; + +public class GetBlockAttestationsV2 extends RestApiEndpoint { + + public static final String ROUTE = "/eth/v2/beacon/blocks/{block_id}/attestations"; + private final ChainDataProvider chainDataProvider; + + public GetBlockAttestationsV2( + final DataProvider dataProvider, final SchemaDefinitionCache schemaDefinitionCache) { + this(dataProvider.getChainDataProvider(), schemaDefinitionCache); + } + + public GetBlockAttestationsV2( + final ChainDataProvider chainDataProvider, + final SchemaDefinitionCache schemaDefinitionCache) { + super( + EndpointMetadata.get(ROUTE) + .operationId("getBlockAttestationsV2") + .summary("Get block attestations") + .description("Retrieves attestations included in requested block.") + .tags(TAG_BEACON) + .pathParam(PARAMETER_BLOCK_ID) + .response( + SC_OK, + "Request successful", + getResponseType(schemaDefinitionCache), + ETH_CONSENSUS_HEADER_TYPE) + .withNotFoundResponse() + .withChainDataResponses() + .build()); + this.chainDataProvider = chainDataProvider; + } + + @Override + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { + final SafeFuture>>> future = + chainDataProvider.getBlockAttestations(request.getPathParameter(PARAMETER_BLOCK_ID)); + + request.respondAsync( + future.thenApply( + maybeAttestationsAndMetadata -> + maybeAttestationsAndMetadata + .map( + attestationsAndMetadata -> { + request.header( + HEADER_CONSENSUS_VERSION, + Version.fromMilestone(attestationsAndMetadata.getMilestone()).name()); + return AsyncApiResponse.respondOk(attestationsAndMetadata); + }) + .orElseGet(AsyncApiResponse::respondNotFound))); + } + + @SuppressWarnings("unchecked") + private static SerializableTypeDefinition>> getResponseType( + final SchemaDefinitionCache schemaDefinitionCache) { + + final SerializableOneOfTypeDefinition> oneOfTypeDefinition = + new SerializableOneOfTypeDefinitionBuilder>() + .withType( + electraAttestationsPredicate(), + listOf(BeaconRestApiTypes.electraAttestationTypeDef(schemaDefinitionCache))) + .withType( + phase0AttestationsPredicate(), + listOf(BeaconRestApiTypes.phase0AttestationTypeDef(schemaDefinitionCache))) + .build(); + + return SerializableTypeDefinition.>>object() + .name("GetBlockAttestationsResponseV2") + .withField(EXECUTION_OPTIMISTIC, BOOLEAN_TYPE, ObjectAndMetaData::isExecutionOptimistic) + .withField(FINALIZED, BOOLEAN_TYPE, ObjectAndMetaData::isFinalized) + .withField("version", MILESTONE_TYPE, ObjectAndMetaData::getMilestone) + .withField("data", oneOfTypeDefinition, ObjectAndMetaData::getData) + .build(); + } + + private static Predicate> phase0AttestationsPredicate() { + // Before Electra attestations do not require committee bits + return attestations -> attestations.isEmpty() || !attestations.get(0).requiresCommitteeBits(); + } + + private static Predicate> electraAttestationsPredicate() { + // Only once we are in Electra attestations will have committee bits + return attestations -> !attestations.isEmpty() && attestations.get(0).requiresCommitteeBits(); + } +} diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/PostAttestationsV2.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/PostAttestationsV2.java new file mode 100644 index 00000000000..2ddd488a0f0 --- /dev/null +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/PostAttestationsV2.java @@ -0,0 +1,126 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.beaconrestapi.handlers.v2.beacon; + +import static tech.pegasys.teku.api.ValidatorDataProvider.PARTIAL_PUBLISH_FAILURE_MESSAGE; +import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.ETH_CONSENSUS_VERSION_TYPE; +import static tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil.getSchemaDefinitionForAllSupportedMilestones; +import static tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil.headerBasedSelector; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_BEACON; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_EXPERIMENTAL; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_VALIDATOR_REQUIRED; + +import com.fasterxml.jackson.core.JsonProcessingException; +import java.util.List; +import java.util.function.BiPredicate; +import tech.pegasys.teku.api.DataProvider; +import tech.pegasys.teku.api.ValidatorDataProvider; +import tech.pegasys.teku.beaconrestapi.schema.ErrorListBadRequest; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.json.types.SerializableOneOfTypeDefinition; +import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition; +import tech.pegasys.teku.infrastructure.restapi.endpoints.AsyncApiResponse; +import tech.pegasys.teku.infrastructure.restapi.endpoints.EndpointMetadata; +import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; +import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiRequest; +import tech.pegasys.teku.infrastructure.restapi.openapi.request.OneOfArrayJsonRequestContentTypeDefinition; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; +import tech.pegasys.teku.spec.schemas.SchemaDefinitions; +import tech.pegasys.teku.validator.api.SubmitDataError; + +public class PostAttestationsV2 extends RestApiEndpoint { + + public static final String ROUTE = "/eth/v2/beacon/pool/attestations"; + private final ValidatorDataProvider validatorDataProvider; + + public PostAttestationsV2( + final DataProvider validatorDataProvider, final SchemaDefinitionCache schemaDefinitionCache) { + this(validatorDataProvider.getValidatorDataProvider(), schemaDefinitionCache); + } + + public PostAttestationsV2( + final ValidatorDataProvider validatorDataProvider, + final SchemaDefinitionCache schemaDefinitionCache) { + super(createMetadata(schemaDefinitionCache)); + this.validatorDataProvider = validatorDataProvider; + } + + @Override + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { + final List attestations = request.getRequestBody(); + final SafeFuture> future = + validatorDataProvider.submitAttestations(attestations); + + request.respondAsync( + future.thenApply( + errors -> { + if (errors.isEmpty()) { + return AsyncApiResponse.respondWithCode(SC_OK); + } + final ErrorListBadRequest data = + ErrorListBadRequest.convert(PARTIAL_PUBLISH_FAILURE_MESSAGE, errors); + return AsyncApiResponse.respondWithObject(SC_BAD_REQUEST, data); + })); + } + + private static EndpointMetadata createMetadata( + final SchemaDefinitionCache schemaDefinitionCache) { + + final BiPredicate attestationSchemaPredicate = + (attestation, milestone) -> + schemaDefinitionCache + .milestoneAtSlot(attestation.getData().getSlot()) + .equals(milestone); + + final SerializableOneOfTypeDefinition attestationSchemaDefinition = + getSchemaDefinitionForAllSupportedMilestones( + schemaDefinitionCache, + "SignedAttestation", + SchemaDefinitions::getAttestationSchema, + attestationSchemaPredicate); + + final OneOfArrayJsonRequestContentTypeDefinition.BodyTypeSelector + attestationBodySelector = + context -> + headerBasedSelector( + context.getHeaders(), + schemaDefinitionCache, + SchemaDefinitions::getAttestationSchema); + + return EndpointMetadata.post(ROUTE) + .operationId("submitPoolAttestationsV2") + .summary("Submit Attestation objects to node") + .description( + "Submits Attestation objects to the node. Each attestation in the request body is processed individually.\n" + + "If an attestation is validated successfully, the node MUST publish that attestation on the appropriate subnet.\n" + + "If one or more attestations fail validation, the node MUST return a 400 error with details of which attestations have failed, and why.") + .tags(TAG_BEACON, TAG_VALIDATOR_REQUIRED, TAG_EXPERIMENTAL) + .requestBodyType( + SerializableTypeDefinition.listOf(attestationSchemaDefinition), attestationBodySelector) + .headerRequired( + ETH_CONSENSUS_VERSION_TYPE.withDescription( + "Version of the attestations being submitted.")) + .response(SC_OK, "Attestations are stored in pool and broadcast on appropriate subnet") + .response( + SC_BAD_REQUEST, + "Errors with one or more attestations", + ErrorListBadRequest.getJsonTypeDefinition()) + .withChainDataResponses() + .build(); + } +} diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/PostAttesterSlashingV2.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/PostAttesterSlashingV2.java new file mode 100644 index 00000000000..4217eb91480 --- /dev/null +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/PostAttesterSlashingV2.java @@ -0,0 +1,149 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.beaconrestapi.handlers.v2.beacon; + +import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.ETH_CONSENSUS_VERSION_TYPE; +import static tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil.headerBasedSelector; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_BEACON; + +import com.fasterxml.jackson.core.JsonProcessingException; +import java.util.function.Predicate; +import tech.pegasys.teku.api.DataProvider; +import tech.pegasys.teku.api.NodeDataProvider; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.json.types.SerializableOneOfTypeDefinition; +import tech.pegasys.teku.infrastructure.json.types.SerializableOneOfTypeDefinitionBuilder; +import tech.pegasys.teku.infrastructure.restapi.endpoints.AsyncApiResponse; +import tech.pegasys.teku.infrastructure.restapi.endpoints.EndpointMetadata; +import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; +import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiRequest; +import tech.pegasys.teku.infrastructure.restapi.openapi.request.OneOfJsonRequestContentTypeDefinition; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; +import tech.pegasys.teku.spec.schemas.SchemaDefinitions; +import tech.pegasys.teku.statetransition.validation.InternalValidationResult; +import tech.pegasys.teku.statetransition.validation.ValidationResultCode; + +public class PostAttesterSlashingV2 extends RestApiEndpoint { + public static final String ROUTE = "/eth/v2/beacon/pool/attester_slashings"; + private final NodeDataProvider nodeDataProvider; + + public PostAttesterSlashingV2( + final DataProvider dataProvider, final SchemaDefinitionCache schemaDefinitionCache) { + this(dataProvider.getNodeDataProvider(), schemaDefinitionCache); + } + + public PostAttesterSlashingV2( + final NodeDataProvider provider, final SchemaDefinitionCache schemaDefinitionCache) { + super(createMetadata(schemaDefinitionCache)); + this.nodeDataProvider = provider; + } + + private static EndpointMetadata createMetadata( + final SchemaDefinitionCache schemaDefinitionCache) { + + final DeserializableTypeDefinition attesterSlashingPhase0Schema = + schemaDefinitionCache + .getSchemaDefinition(SpecMilestone.PHASE0) + .getAttesterSlashingSchema() + .getJsonTypeDefinition(); + + final DeserializableTypeDefinition attesterSlashingElectraSchema = + schemaDefinitionCache + .getSchemaDefinition(SpecMilestone.ELECTRA) + .getAttesterSlashingSchema() + .getJsonTypeDefinition(); + + final SerializableOneOfTypeDefinition attesterSlashingSchemaDefinition = + new SerializableOneOfTypeDefinitionBuilder() + .withType( + electraAttesterSlashingsPredicate(schemaDefinitionCache), + attesterSlashingElectraSchema) + .withType( + phase0AttesterSlashingsPredicate(schemaDefinitionCache), + attesterSlashingPhase0Schema) + .build(); + + final OneOfJsonRequestContentTypeDefinition.BodyTypeSelector + attesterSlashingBodySelector = + context -> + headerBasedSelector( + context.getHeaders(), + schemaDefinitionCache, + SchemaDefinitions::getAttesterSlashingSchema); + + return EndpointMetadata.post(ROUTE) + .operationId("submitPoolAttesterSlashingsV2") + .summary("Submit AttesterSlashing object to node's pool") + .description( + "Submits AttesterSlashing object to node's pool. Upon successful validation the node MUST broadcast it to network.") + .tags(TAG_BEACON) + .requestBodyType(attesterSlashingSchemaDefinition, attesterSlashingBodySelector) + .headerRequired( + ETH_CONSENSUS_VERSION_TYPE.withDescription( + "Version of the attester slashing being submitted.")) + .response(SC_OK, "Success") + .build(); + } + + @Override + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { + handleAttesterSlashingRequest(request, nodeDataProvider); + } + + public static void handleAttesterSlashingRequest( + final RestApiRequest request, final NodeDataProvider nodeDataProvider) + throws JsonProcessingException { + final AttesterSlashing attesterSlashing = request.getRequestBody(); + final SafeFuture future = + nodeDataProvider.postAttesterSlashing(attesterSlashing); + + request.respondAsync( + future.thenApply( + internalValidationResult -> { + if (internalValidationResult.code().equals(ValidationResultCode.IGNORE) + || internalValidationResult.code().equals(ValidationResultCode.REJECT)) { + return AsyncApiResponse.respondWithError( + SC_BAD_REQUEST, + internalValidationResult + .getDescription() + .orElse( + "Invalid attester slashing, it will never pass validation so it's rejected.")); + } else { + + return AsyncApiResponse.respondWithCode(SC_OK); + } + })); + } + + private static Predicate electraAttesterSlashingsPredicate( + final SchemaDefinitionCache schemaDefinitionCache) { + return attesterSlashings -> + schemaDefinitionCache + .milestoneAtSlot(attesterSlashings.getAttestation1().getData().getSlot()) + .isGreaterThanOrEqualTo(SpecMilestone.ELECTRA); + } + + private static Predicate phase0AttesterSlashingsPredicate( + final SchemaDefinitionCache schemaDefinitionCache) { + return attesterSlashings -> + !schemaDefinitionCache + .milestoneAtSlot(attesterSlashings.getAttestation1().getData().getSlot()) + .isGreaterThanOrEqualTo(SpecMilestone.ELECTRA); + } +} diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/PostBlindedBlockV2.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/PostBlindedBlockV2.java index 5fe6da80e54..78759d28646 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/PostBlindedBlockV2.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/PostBlindedBlockV2.java @@ -16,10 +16,12 @@ import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.ETH_CONSENSUS_VERSION_TYPE; import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.PARAMETER_BROADCAST_VALIDATION; import static tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil.getSchemaDefinitionForAllSupportedMilestones; -import static tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil.slotBasedSelector; +import static tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil.headerBasedSelectorWithSlotFallback; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_ACCEPTED; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_BEACON; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_VALIDATOR_REQUIRED; import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.HTTP_ERROR_RESPONSE_TYPE; @@ -63,7 +65,7 @@ public PostBlindedBlockV2( @Override public void handleRequest(final RestApiRequest request) throws JsonProcessingException { if (syncDataProvider.isSyncing()) { - request.respondError(SC_SERVICE_UNAVAILABLE, "Beacon node is currently syncing."); + request.respondError(SC_SERVICE_UNAVAILABLE, SERVICE_UNAVAILABLE); return; } @@ -113,7 +115,8 @@ broadcast but a different status code is returned (202). Pre-Bellatrix, this end .milestoneAtSlot(blockContainer.getSlot()) .equals(milestone)), context -> - slotBasedSelector( + headerBasedSelectorWithSlotFallback( + context.getHeaders(), context.getBody(), schemaDefinitionCache, SchemaDefinitions::getSignedBlindedBlockContainerSchema), @@ -125,8 +128,9 @@ broadcast but a different status code is returned (202). Pre-Bellatrix, this end SC_ACCEPTED, "Block has been successfully broadcast, but failed validation and has not been imported.") .withBadRequestResponse(Optional.of("Unable to parse request body.")) + .response(SC_SERVICE_UNAVAILABLE, SERVICE_UNAVAILABLE, HTTP_ERROR_RESPONSE_TYPE) .response( - SC_SERVICE_UNAVAILABLE, "Beacon node is currently syncing.", HTTP_ERROR_RESPONSE_TYPE) + SC_NO_CONTENT, "Data is unavailable because the chain has not yet reached genesis") .build(); } } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/PostBlockV2.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/PostBlockV2.java index 78200d40670..4b9369bda15 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/PostBlockV2.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/PostBlockV2.java @@ -16,8 +16,9 @@ import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.ETH_CONSENSUS_VERSION_TYPE; import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.PARAMETER_BROADCAST_VALIDATION; import static tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil.getSchemaDefinitionForAllSupportedMilestones; -import static tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil.slotBasedSelector; +import static tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil.headerBasedSelectorWithSlotFallback; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_ACCEPTED; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.SERVICE_UNAVAILABLE; @@ -113,7 +114,8 @@ validation, a separate success response code (202) is used to indicate that the .milestoneAtSlot(blockContainer.getSlot()) .equals(milestone)), context -> - slotBasedSelector( + headerBasedSelectorWithSlotFallback( + context.getHeaders(), context.getBody(), schemaDefinitionCache, SchemaDefinitions::getSignedBlockContainerSchema), @@ -125,8 +127,9 @@ validation, a separate success response code (202) is used to indicate that the SC_ACCEPTED, "Block has been successfully broadcast, but failed validation and has not been imported.") .withBadRequestResponse(Optional.of("Unable to parse request body.")) + .response(SC_SERVICE_UNAVAILABLE, SERVICE_UNAVAILABLE, HTTP_ERROR_RESPONSE_TYPE) .response( - SC_SERVICE_UNAVAILABLE, "Beacon node is currently syncing.", HTTP_ERROR_RESPONSE_TYPE) + SC_NO_CONTENT, "Data is unavailable because the chain has not yet reached genesis") .build(); } } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/debug/GetChainHeadsV2.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/debug/GetChainHeadsV2.java index 45304776547..cdefcf45dc2 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/debug/GetChainHeadsV2.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/debug/GetChainHeadsV2.java @@ -49,6 +49,7 @@ public GetChainHeadsV2(final ChainDataProvider chainDataProvider) { .description("Retrieves all possible chain heads (leaves of fork choice tree).") .tags(TAG_DEBUG) .response(SC_OK, "Success", responseType(CHAIN_HEAD_TYPE_V2)) + .withChainDataResponses() .build()); } } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/debug/GetState.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/debug/GetState.java index 3f12a5b6a67..032dc7abc6a 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/debug/GetState.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/debug/GetState.java @@ -15,6 +15,7 @@ import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.PARAMETER_STATE_ID; import static tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil.getSchemaDefinitionForAllSupportedMilestones; +import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.ETH_CONSENSUS_HEADER_TYPE; import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.MILESTONE_TYPE; import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.sszResponseType; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; @@ -65,14 +66,16 @@ public GetState( SC_OK, "Request successful", getResponseType(schemaDefinitionCache), - sszResponseType()) + sszResponseType(), + ETH_CONSENSUS_HEADER_TYPE) .withNotFoundResponse() + .withChainDataResponses() .build()); this.chainDataProvider = chainDataProvider; } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final SafeFuture> future = chainDataProvider.getBeaconStateAndMetadata(request.getPathParameter(PARAMETER_STATE_ID)); @@ -91,7 +94,7 @@ public void handleRequest(RestApiRequest request) throws JsonProcessingException } private static SerializableTypeDefinition getResponseType( - SchemaDefinitionCache schemaDefinitionCache) { + final SchemaDefinitionCache schemaDefinitionCache) { return SerializableTypeDefinition.object() .name("GetStateV2Response") .withField("version", MILESTONE_TYPE, ObjectAndMetaData::getMilestone) diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/validator/GetAggregateAttestationV2.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/validator/GetAggregateAttestationV2.java new file mode 100644 index 00000000000..06d2596b1ce --- /dev/null +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/validator/GetAggregateAttestationV2.java @@ -0,0 +1,138 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.beaconrestapi.handlers.v2.validator; + +import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.ATTESTATION_DATA_ROOT_PARAMETER; +import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.COMMITTEE_INDEX_PARAMETER; +import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.SLOT_PARAMETER; +import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.ETH_CONSENSUS_HEADER_TYPE; +import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.MILESTONE_TYPE; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_VALIDATOR; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_VALIDATOR_REQUIRED; + +import com.fasterxml.jackson.core.JsonProcessingException; +import java.util.Optional; +import java.util.function.Predicate; +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.api.DataProvider; +import tech.pegasys.teku.api.ValidatorDataProvider; +import tech.pegasys.teku.api.schema.Version; +import tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.http.HttpStatusCodes; +import tech.pegasys.teku.infrastructure.json.types.SerializableOneOfTypeDefinition; +import tech.pegasys.teku.infrastructure.json.types.SerializableOneOfTypeDefinitionBuilder; +import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition; +import tech.pegasys.teku.infrastructure.restapi.endpoints.AsyncApiResponse; +import tech.pegasys.teku.infrastructure.restapi.endpoints.EndpointMetadata; +import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; +import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiRequest; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; + +public class GetAggregateAttestationV2 extends RestApiEndpoint { + + public static final String ROUTE = "/eth/v2/validator/aggregate_attestation"; + private final ValidatorDataProvider provider; + + public GetAggregateAttestationV2( + final DataProvider dataProvider, final SchemaDefinitionCache schemaDefinitionCache) { + this(dataProvider.getValidatorDataProvider(), schemaDefinitionCache); + } + + public GetAggregateAttestationV2( + final ValidatorDataProvider provider, final SchemaDefinitionCache schemaDefinitionCache) { + super( + EndpointMetadata.get(ROUTE) + .operationId("getAggregatedAttestationV2") + .summary("Get aggregated attestation") + .description( + "Aggregates all attestations matching given attestation data root, slot and committee index.\n" + + "A 503 error must be returned if the block identified by the response\n" + + "`beacon_block_root` is optimistic (i.e. the aggregated attestation attests\n" + + "to a block that has not been fully verified by an execution engine).\n" + + "A 404 error must be returned if no attestation is available for the requested\n" + + "`attestation_data_root`.") + .tags(TAG_VALIDATOR, TAG_VALIDATOR_REQUIRED) + .queryParamRequired(ATTESTATION_DATA_ROOT_PARAMETER) + .queryParamRequired(SLOT_PARAMETER) + .queryParamRequired(COMMITTEE_INDEX_PARAMETER) + .response( + HttpStatusCodes.SC_OK, + "Request successful", + getResponseType(schemaDefinitionCache), + ETH_CONSENSUS_HEADER_TYPE) + .withNotFoundResponse() + .withChainDataResponses() + .build()); + this.provider = provider; + } + + @Override + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { + final Bytes32 beaconBlockRoot = request.getQueryParameter(ATTESTATION_DATA_ROOT_PARAMETER); + final UInt64 slot = request.getQueryParameter(SLOT_PARAMETER); + final UInt64 committeeIndex = request.getQueryParameter(COMMITTEE_INDEX_PARAMETER); + + final SafeFuture>> future = + provider.createAggregateAndMetaData(slot, beaconBlockRoot, committeeIndex); + + request.respondAsync( + future.thenApply( + maybeAttestation -> + maybeAttestation + .map( + attestationAndMetaData -> { + request.header( + HEADER_CONSENSUS_VERSION, + Version.fromMilestone(attestationAndMetaData.getMilestone()).name()); + return AsyncApiResponse.respondOk(attestationAndMetaData); + }) + .orElseGet(AsyncApiResponse::respondNotFound))); + } + + @SuppressWarnings("unchecked") + private static SerializableTypeDefinition> getResponseType( + final SchemaDefinitionCache schemaDefinitionCache) { + + final SerializableOneOfTypeDefinition oneOfTypeDefinition = + new SerializableOneOfTypeDefinitionBuilder() + .withType( + electraAttestationPredicate(), + BeaconRestApiTypes.electraAttestationTypeDef(schemaDefinitionCache)) + .withType( + phase0AttestationPredicate(), + BeaconRestApiTypes.phase0AttestationTypeDef(schemaDefinitionCache)) + .build(); + + return SerializableTypeDefinition.>object() + .name("GetAggregatedAttestationResponseV2") + .withField("version", MILESTONE_TYPE, ObjectAndMetaData::getMilestone) + .withField("data", oneOfTypeDefinition, ObjectAndMetaData::getData) + .build(); + } + + private static Predicate phase0AttestationPredicate() { + // Before Electra attestations do not require committee bits + return attestation -> !attestation.requiresCommitteeBits(); + } + + private static Predicate electraAttestationPredicate() { + // Only once we are in Electra attestations will have committee bits + return Attestation::requiresCommitteeBits; + } +} diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/validator/GetNewBlock.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/validator/GetNewBlock.java deleted file mode 100644 index c737a93eca2..00000000000 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/validator/GetNewBlock.java +++ /dev/null @@ -1,126 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.beaconrestapi.handlers.v2.validator; - -import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.GRAFFITI_PARAMETER; -import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.RANDAO_PARAMETER; -import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.SLOT_PARAMETER; -import static tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil.getSchemaDefinitionForAllSupportedMilestones; -import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.MILESTONE_TYPE; -import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.sszResponseType; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; -import static tech.pegasys.teku.infrastructure.http.RestApiConstants.SLOT_PATH_DESCRIPTION; -import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_VALIDATOR; -import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_VALIDATOR_REQUIRED; - -import com.fasterxml.jackson.core.JsonProcessingException; -import java.util.Optional; -import java.util.function.Function; -import org.apache.tuweni.bytes.Bytes32; -import tech.pegasys.teku.api.DataProvider; -import tech.pegasys.teku.api.ValidatorDataProvider; -import tech.pegasys.teku.bls.BLSSignature; -import tech.pegasys.teku.infrastructure.async.SafeFuture; -import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition; -import tech.pegasys.teku.infrastructure.restapi.endpoints.AsyncApiResponse; -import tech.pegasys.teku.infrastructure.restapi.endpoints.EndpointMetadata; -import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; -import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiRequest; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.datastructures.blocks.BlockContainer; -import tech.pegasys.teku.spec.datastructures.metadata.BlockContainerAndMetaData; -import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; -import tech.pegasys.teku.spec.schemas.SchemaDefinitions; -import tech.pegasys.teku.storage.client.ChainDataUnavailableException; - -public class GetNewBlock extends RestApiEndpoint { - public static final String ROUTE = "/eth/v2/validator/blocks/{slot}"; - - protected final ValidatorDataProvider provider; - - public GetNewBlock( - final DataProvider dataProvider, - final Spec spec, - final SchemaDefinitionCache schemaDefinitionCache) { - this(dataProvider.getValidatorDataProvider(), spec, schemaDefinitionCache); - } - - public GetNewBlock( - final ValidatorDataProvider provider, - final Spec spec, - final SchemaDefinitionCache schemaDefinitionCache) { - super(getEndpointMetaData(spec, schemaDefinitionCache)); - this.provider = provider; - } - - private static EndpointMetadata getEndpointMetaData( - final Spec spec, final SchemaDefinitionCache schemaDefinitionCache) { - return EndpointMetadata.get(ROUTE) - .operationId("produceBlockV2") - .summary("Produce a new block, without signature.") - .description( - "Requests a beacon node to produce a valid block, which can then be signed by a validator.\n" - + "Metadata in the response indicates the type of block produced, and the supported types of block " - + "will be added to as forks progress.") - .tags(TAG_VALIDATOR, TAG_VALIDATOR_REQUIRED) - .pathParam(SLOT_PARAMETER.withDescription(SLOT_PATH_DESCRIPTION)) - .queryParamRequired(RANDAO_PARAMETER) - .queryParam(GRAFFITI_PARAMETER) - .response( - SC_OK, - "Request successful", - SerializableTypeDefinition.object() - .name("ProduceBlockV2Response") - .withField( - "data", - getSchemaDefinitionForAllSupportedMilestones( - schemaDefinitionCache, - "Block", - SchemaDefinitions::getBlockContainerSchema, - (blockContainer, milestone) -> - schemaDefinitionCache - .milestoneAtSlot(blockContainer.getSlot()) - .equals(milestone)), - Function.identity()) - .withField( - "version", - MILESTONE_TYPE, - blockContainer -> - schemaDefinitionCache.milestoneAtSlot(blockContainer.getSlot())) - .build(), - sszResponseType( - blockContainer -> - spec.getForkSchedule().getSpecMilestoneAtSlot(blockContainer.getSlot()))) - .build(); - } - - @Override - @SuppressWarnings("deprecation") - public void handleRequest(RestApiRequest request) throws JsonProcessingException { - final UInt64 slot = - request.getPathParameter(SLOT_PARAMETER.withDescription(SLOT_PATH_DESCRIPTION)); - final BLSSignature randao = request.getQueryParameter(RANDAO_PARAMETER); - final Optional graffiti = request.getOptionalQueryParameter(GRAFFITI_PARAMETER); - final SafeFuture> result = - provider.getUnsignedBeaconBlockAtSlot(slot, randao, graffiti, false, Optional.empty()); - request.respondAsync( - result.thenApply( - maybeBlock -> - maybeBlock - .map(BlockContainerAndMetaData::blockContainer) - .map(AsyncApiResponse::respondOk) - .orElseThrow(ChainDataUnavailableException::new))); - } -} diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/validator/PostAggregateAndProofsV2.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/validator/PostAggregateAndProofsV2.java new file mode 100644 index 00000000000..ae5755bcf96 --- /dev/null +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v2/validator/PostAggregateAndProofsV2.java @@ -0,0 +1,121 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.beaconrestapi.handlers.v2.validator; + +import static tech.pegasys.teku.api.ValidatorDataProvider.PARTIAL_PUBLISH_FAILURE_MESSAGE; +import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.ETH_CONSENSUS_VERSION_TYPE; +import static tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil.getSchemaDefinitionForAllSupportedMilestones; +import static tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil.headerBasedSelector; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_VALIDATOR; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.TAG_VALIDATOR_REQUIRED; + +import com.fasterxml.jackson.core.JsonProcessingException; +import java.util.List; +import java.util.Optional; +import java.util.function.BiPredicate; +import tech.pegasys.teku.api.DataProvider; +import tech.pegasys.teku.api.ValidatorDataProvider; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.json.types.SerializableOneOfTypeDefinition; +import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition; +import tech.pegasys.teku.infrastructure.restapi.endpoints.AsyncApiResponse; +import tech.pegasys.teku.infrastructure.restapi.endpoints.EndpointMetadata; +import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; +import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiRequest; +import tech.pegasys.teku.infrastructure.restapi.openapi.request.OneOfArrayJsonRequestContentTypeDefinition; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; +import tech.pegasys.teku.spec.schemas.SchemaDefinitions; +import tech.pegasys.teku.validator.api.SubmitDataError; + +public class PostAggregateAndProofsV2 extends RestApiEndpoint { + public static final String ROUTE = "/eth/v2/validator/aggregate_and_proofs"; + private final ValidatorDataProvider provider; + + public PostAggregateAndProofsV2( + final DataProvider provider, final SchemaDefinitionCache schemaDefinitionCache) { + this(provider.getValidatorDataProvider(), schemaDefinitionCache); + } + + public PostAggregateAndProofsV2( + final ValidatorDataProvider provider, final SchemaDefinitionCache schemaDefinitionCache) { + super(createMetadata(schemaDefinitionCache)); + this.provider = provider; + } + + @Override + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { + final List signedAggregateAndProofs = request.getRequestBody(); + final SafeFuture> future = + provider.sendAggregateAndProofs(signedAggregateAndProofs); + + request.respondAsync( + future.thenApply( + errors -> { + if (errors.isEmpty()) { + return AsyncApiResponse.respondWithCode(SC_OK); + } + return AsyncApiResponse.respondWithError( + SC_BAD_REQUEST, PARTIAL_PUBLISH_FAILURE_MESSAGE); + })); + } + + private static EndpointMetadata createMetadata( + final SchemaDefinitionCache schemaDefinitionCache) { + + final BiPredicate + signedAggregateAndProofSchemaPredicate = + (signedAggregateAndProof, milestone) -> + schemaDefinitionCache + .milestoneAtSlot( + signedAggregateAndProof.getMessage().getAggregate().getData().getSlot()) + .equals(milestone); + + final SerializableOneOfTypeDefinition + signedAggregateAndProofSchemaDefinition = + getSchemaDefinitionForAllSupportedMilestones( + schemaDefinitionCache, + "SignedAggregateAndProof", + SchemaDefinitions::getSignedAggregateAndProofSchema, + signedAggregateAndProofSchemaPredicate); + + final OneOfArrayJsonRequestContentTypeDefinition.BodyTypeSelector + aggregateAndProofBodySelector = + context -> + headerBasedSelector( + context.getHeaders(), + schemaDefinitionCache, + SchemaDefinitions::getSignedAggregateAndProofSchema); + + return EndpointMetadata.post(ROUTE) + .operationId("publishAggregateAndProofsV2") + .summary("Publish multiple aggregate and proofs") + .description( + "Verifies given aggregate and proofs and publishes it on appropriate gossipsub topic.") + .tags(TAG_VALIDATOR, TAG_VALIDATOR_REQUIRED) + .requestBodyType( + SerializableTypeDefinition.listOf(signedAggregateAndProofSchemaDefinition), + aggregateAndProofBodySelector) + .headerRequired( + ETH_CONSENSUS_VERSION_TYPE.withDescription( + "Version of the aggregate and proofs being submitted.")) + .response(SC_OK, "Attestations are stored in pool and broadcast on appropriate subnet") + .withBadRequestResponse(Optional.of("Invalid request syntax.")) + .withChainDataResponses() + .build(); + } +} diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v3/validator/GetNewBlockV3.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v3/validator/GetNewBlockV3.java index 9c4ffb2f690..fc499f4e629 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v3/validator/GetNewBlockV3.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v3/validator/GetNewBlockV3.java @@ -19,6 +19,10 @@ import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.SKIP_RANDAO_VERIFICATION_PARAMETER; import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.SLOT_PARAMETER; import static tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil.getMultipleSchemaDefinitionFromMilestone; +import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.ETH_CONSENSUS_HEADER_TYPE; +import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.ETH_HEADER_CONSENSUS_BLOCK_VALUE_TYPE; +import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.ETH_HEADER_EXECUTION_PAYLOAD_BLINDED_TYPE; +import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.ETH_HEADER_EXECUTION_PAYLOAD_VALUE_TYPE; import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.MILESTONE_TYPE; import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.blockContainerAndMetaDataSszResponseType; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; @@ -95,13 +99,15 @@ private static EndpointMetadata getEndpointMetaData( .pathParam(SLOT_PARAMETER.withDescription(SLOT_PATH_DESCRIPTION)) .queryParamRequired(RANDAO_PARAMETER) .queryParam(GRAFFITI_PARAMETER) - .queryParam(SKIP_RANDAO_VERIFICATION_PARAMETER) + .queryParamAllowsEmpty(SKIP_RANDAO_VERIFICATION_PARAMETER) .queryParam(BUILDER_BOOST_FACTOR_PARAMETER) .response( SC_OK, "Request successful", getResponseType(schemaDefinitionCache), - blockContainerAndMetaDataSszResponseType()) + blockContainerAndMetaDataSszResponseType(), + getHeaders()) + .withChainDataResponses() .build(); } @@ -193,4 +199,13 @@ private static SerializableTypeDefinition getResponse SchemaDefinitions::getBlindedBlockContainerSchema)); return schemaGetterList; } + + private static List> getHeaders() { + List> headers = new ArrayList<>(); + headers.add(ETH_CONSENSUS_HEADER_TYPE); + headers.add(ETH_HEADER_EXECUTION_PAYLOAD_BLINDED_TYPE); + headers.add(ETH_HEADER_EXECUTION_PAYLOAD_VALUE_TYPE); + headers.add(ETH_HEADER_CONSENSUS_BLOCK_VALUE_TYPE); + return headers; + } } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/schema/ErrorListBadRequest.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/schema/ErrorListBadRequest.java index 5866b8a809b..47519c93555 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/schema/ErrorListBadRequest.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/schema/ErrorListBadRequest.java @@ -51,7 +51,7 @@ public static ErrorListBadRequest convert( } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/schema/ErrorResponse.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/schema/ErrorResponse.java index 8b911fb5488..9884f739f65 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/schema/ErrorResponse.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/schema/ErrorResponse.java @@ -22,7 +22,7 @@ public class ErrorResponse { @JsonCreator public ErrorResponse( - @JsonProperty("status") Integer status, @JsonProperty("message") String message) { + final @JsonProperty("status") Integer status, final @JsonProperty("message") String message) { this.status = status; this.message = message; } diff --git a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/schema/ProposersData.java b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/schema/ProposersData.java index f1de7428e9d..ba85dd5fc99 100644 --- a/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/schema/ProposersData.java +++ b/data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/schema/ProposersData.java @@ -13,7 +13,7 @@ package tech.pegasys.teku.beaconrestapi.schema; -import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.ETH1ADDRESS_TYPE; +import static tech.pegasys.teku.ethereum.execution.types.Eth1Address.ETH1ADDRESS_TYPE; import static tech.pegasys.teku.ethereum.json.types.SharedApiTypes.PUBKEY_API_TYPE; import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; import static tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition.listOf; @@ -96,7 +96,7 @@ public static SerializableTypeDefinition getJsonTypeDefinition() } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/AbstractGetNewBlockTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/AbstractGetNewBlockTest.java deleted file mode 100644 index 954db214654..00000000000 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/AbstractGetNewBlockTest.java +++ /dev/null @@ -1,121 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.beaconrestapi; - -import static java.nio.charset.StandardCharsets.UTF_8; -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.when; -import static tech.pegasys.teku.infrastructure.http.RestApiConstants.RANDAO_REVEAL; -import static tech.pegasys.teku.infrastructure.http.RestApiConstants.SLOT; -import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ONE; - -import com.google.common.io.Resources; -import java.util.Optional; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Disabled; -import org.junit.jupiter.api.Test; -import tech.pegasys.teku.bls.BLSSignature; -import tech.pegasys.teku.bls.BLSTestUtil; -import tech.pegasys.teku.infrastructure.async.SafeFuture; -import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.SpecMilestone; -import tech.pegasys.teku.spec.TestSpecFactory; -import tech.pegasys.teku.spec.datastructures.blocks.versions.deneb.BlockContents; -import tech.pegasys.teku.spec.datastructures.metadata.BlockContainerAndMetaData; -import tech.pegasys.teku.spec.util.DataStructureUtil; -import tech.pegasys.teku.storage.client.ChainDataUnavailableException; - -public abstract class AbstractGetNewBlockTest extends AbstractMigratedBeaconHandlerTest { - protected final BLSSignature signature = BLSTestUtil.randomSignature(1234); - - @BeforeEach - public void setup() { - setHandler(getHandler()); - request.setPathParameter(SLOT, "1"); - request.setQueryParameter(RANDAO_REVEAL, signature.toBytesCompressed().toHexString()); - when(validatorDataProvider.getMilestoneAtSlot(UInt64.ONE)).thenReturn(SpecMilestone.ALTAIR); - } - - @SuppressWarnings("unchecked") - @Test - @Disabled("TODO: Fix fixtures, random was changed") - void shouldReturnBlockWithoutGraffiti() throws Exception { - final BlockContainerAndMetaData blockContainerAndMetaData = - dataStructureUtil.randomBlockContainerAndMetaData(ONE); - doReturn(SafeFuture.completedFuture(Optional.of(blockContainerAndMetaData))) - .when(validatorDataProvider) - .getUnsignedBeaconBlockAtSlot( - ONE, signature, Optional.empty(), isBlindedBlocks(), Optional.empty()); - - handler.handleRequest(request); - - assertThat(request.getResponseBody()).isEqualTo(blockContainerAndMetaData.blockContainer()); - // Check block serializes correctly - assertThat(request.getResponseBodyAsJson(handler)) - .isEqualTo( - Resources.toString( - Resources.getResource(AbstractGetNewBlockTest.class, "beaconBlock.json"), UTF_8)); - } - - @Test - void shouldReturnBlindedBeaconBlockPostDeneb() throws Exception { - spec = TestSpecFactory.createMinimalDeneb(); - dataStructureUtil = new DataStructureUtil(spec); - final BlockContainerAndMetaData blockContainerAndMetaData = - dataStructureUtil.randomBlindedBlockContainerAndMetaData(ONE); - doReturn(SafeFuture.completedFuture(Optional.of(blockContainerAndMetaData))) - .when(validatorDataProvider) - .getUnsignedBeaconBlockAtSlot( - ONE, signature, Optional.empty(), isBlindedBlocks(), Optional.empty()); - - handler.handleRequest(request); - - assertThat(request.getResponseBody()).isEqualTo(blockContainerAndMetaData.blockContainer()); - } - - @Test - void shouldReturnBlockContentsPostDeneb() throws Exception { - spec = TestSpecFactory.createMinimalDeneb(); - dataStructureUtil = new DataStructureUtil(spec); - final BlockContents blockContents = dataStructureUtil.randomBlockContents(ONE); - final BlockContainerAndMetaData blockContainerAndMetaData = - dataStructureUtil.randomBlockContainerAndMetaData(blockContents, ONE); - doReturn(SafeFuture.completedFuture(Optional.of(blockContainerAndMetaData))) - .when(validatorDataProvider) - .getUnsignedBeaconBlockAtSlot( - ONE, signature, Optional.empty(), isBlindedBlocks(), Optional.empty()); - - handler.handleRequest(request); - - assertThat(request.getResponseBody()).isEqualTo(blockContents); - } - - @Test - void shouldThrowExceptionWithEmptyBlock() throws Exception { - - doReturn(SafeFuture.completedFuture(Optional.empty())) - .when(validatorDataProvider) - .getUnsignedBeaconBlockAtSlot( - ONE, signature, Optional.empty(), isBlindedBlocks(), Optional.empty()); - - handler.handleRequest(request); - assertThat(request.getResponseError()).containsInstanceOf(ChainDataUnavailableException.class); - } - - public abstract RestApiEndpoint getHandler(); - - public abstract boolean isBlindedBlocks(); -} diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/AbstractMigratedBeaconHandlerTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/AbstractMigratedBeaconHandlerTest.java index 8850e4a6ee0..dcb3e1ad1d4 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/AbstractMigratedBeaconHandlerTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/AbstractMigratedBeaconHandlerTest.java @@ -28,7 +28,6 @@ import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.networking.eth2.Eth2P2PNetwork; -import tech.pegasys.teku.provider.JsonProvider; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; @@ -39,7 +38,6 @@ public abstract class AbstractMigratedBeaconHandlerTest { protected final Eth2P2PNetwork eth2P2PNetwork = mock(Eth2P2PNetwork.class); protected Spec spec = TestSpecFactory.createMinimalPhase0(); - protected final JsonProvider jsonProvider = new JsonProvider(); protected final NetworkDataProvider network = new NetworkDataProvider(eth2P2PNetwork); protected final SyncService syncService = mock(SyncService.class); diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/AbstractPostBlockTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/AbstractPostBlockTest.java index 16c8ca95ffe..caba3cf8376 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/AbstractPostBlockTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/AbstractPostBlockTest.java @@ -28,11 +28,12 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import tech.pegasys.teku.api.exceptions.BadRequestException; -import tech.pegasys.teku.api.schema.phase0.BeaconBlockPhase0; import tech.pegasys.teku.beacon.sync.events.SyncState; import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.json.JsonUtil; import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; import tech.pegasys.teku.spec.util.DataStructureUtil; @@ -79,8 +80,9 @@ void shouldReturnBadRequestIfArgumentNotJSON() { @Test void shouldReturnBadRequestIfArgumentNotSignedBeaconBlock() throws Exception { + final BeaconBlock block = dataStructureUtil.randomBeaconBlock(3); final String notASignedBlock = - jsonProvider.objectToJSON(new BeaconBlockPhase0(dataStructureUtil.randomBeaconBlock(3))); + JsonUtil.serialize(block, block.getSchema().getJsonTypeDefinition()); assertThatThrownBy( () -> diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/admin/ReadinessTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/admin/ReadinessTest.java index ccc2b1d5079..3939cfd62a4 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/admin/ReadinessTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/admin/ReadinessTest.java @@ -19,6 +19,7 @@ import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.REQUIRE_PREPARED_PROPOSERS; @@ -164,6 +165,11 @@ void metadata_shouldHandle200() { verifyMetadataEmptyResponse(handler, SC_OK); } + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + @Test void metadata_shouldHandle400() throws JsonProcessingException { verifyMetadataErrorResponse(handler, SC_BAD_REQUEST); @@ -175,7 +181,7 @@ void metadata_shouldHandle500() throws JsonProcessingException { } @Test - void metadata_shouldHandle503() { + void metadata_shouldHandle503() throws JsonProcessingException { verifyMetadataEmptyResponse(handler, SC_SERVICE_UNAVAILABLE); } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetAllBlobSidecarsAtSlotTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetAllBlobSidecarsAtSlotTest.java index 937357352ca..1a0de27491c 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetAllBlobSidecarsAtSlotTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetAllBlobSidecarsAtSlotTest.java @@ -20,14 +20,17 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.SLOT; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; import com.google.common.io.Resources; -import java.io.IOException; import java.util.List; import java.util.Optional; import java.util.stream.Collectors; @@ -35,6 +38,7 @@ import org.junit.jupiter.api.Test; import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerTest; import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.json.JsonTestUtil; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; @@ -83,15 +87,28 @@ void metadata_shouldHandle500() throws JsonProcessingException { } @Test - void metadata_shouldHandle200() throws IOException { + void metadata_shouldHandle200() throws Exception { final List nonCanonicalBlobSidecars = dataStructureUtil.randomBlobSidecars(4); - final String data = getResponseStringFromMetadata(handler, SC_OK, nonCanonicalBlobSidecars); - final String expected = - Resources.toString( - Resources.getResource( - GetAllBlobSidecarsAtSlotTest.class, "getAllBlobSidecarsAtSlot.json"), - UTF_8); + final JsonNode data = + JsonTestUtil.parseAsJsonNode( + getResponseStringFromMetadata(handler, SC_OK, nonCanonicalBlobSidecars)); + final JsonNode expected = + JsonTestUtil.parseAsJsonNode( + Resources.toString( + Resources.getResource( + GetAllBlobSidecarsAtSlotTest.class, "getAllBlobSidecarsAtSlot.json"), + UTF_8)); assertThat(data).isEqualTo(expected); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetAllBlocksAtSlotTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetAllBlocksAtSlotTest.java index a440cc35ac2..fe2fba4fd9d 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetAllBlocksAtSlotTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetAllBlocksAtSlotTest.java @@ -20,22 +20,24 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.SLOT; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; import com.google.common.io.Resources; -import java.io.IOException; import java.util.List; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import tech.pegasys.teku.api.migrated.AllBlocksAtSlotData; import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerTest; import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.json.JsonTestUtil; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; @@ -87,12 +89,18 @@ void metadata_shouldHandle503() throws JsonProcessingException { } @Test - @Disabled("TODO: Fix fixtures, random was changed") - void metadata_shouldHandle200() throws IOException { + void metadata_shouldHandle200() throws Exception { final String data = getResponseStringFromMetadata(handler, SC_OK, responseData); + final JsonNode responseDataAsJsonNode = JsonTestUtil.parseAsJsonNode(data); final String expected = Resources.toString( Resources.getResource(GetAllBlocksAtSlotTest.class, "getAllBlocksAtSlot.json"), UTF_8); - assertThat(data).isEqualTo(expected); + final JsonNode expectedAsJsonNode = JsonTestUtil.parseAsJsonNode(expected); + assertThat(responseDataAsJsonNode).isEqualTo(expectedAsJsonNode); + } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetEth1DataTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetEth1DataTest.java index 5b3d06a1162..597a0d071a2 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetEth1DataTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetEth1DataTest.java @@ -20,8 +20,11 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -98,4 +101,14 @@ void metadata_shouldHandle200() throws JsonProcessingException { .isEqualTo( "{\"data\":{\"deposit_root\":\"0xd543a5c171f43007ec7a6871885a3faeb3fd8c4f5a810097508ffd301459aa22\",\"deposit_count\":\"20\",\"block_hash\":\"0xaf01b1c1315d727d01f5991ae1481614a7f78e2beeefae22f48c76a05f973b0d\"}}"); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetEth1VotingSummaryTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetEth1VotingSummaryTest.java index d5e94d948f1..d4433f06a6a 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetEth1VotingSummaryTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetEth1VotingSummaryTest.java @@ -20,8 +20,11 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -116,4 +119,14 @@ void metadata_shouldHandle200() throws JsonProcessingException { .isEqualTo( "{\"data\":{\"state_eth1_data\":{\"deposit_root\":\"0xd543a5c171f43007ec7a6871885a3faeb3fd8c4f5a810097508ffd301459aa22\",\"deposit_count\":\"20\",\"block_hash\":\"0xaf01b1c1315d727d01f5991ae1481614a7f78e2beeefae22f48c76a05f973b0d\"},\"eth1_data_votes\":[{\"eth1_data\":{\"deposit_root\":\"0xd543a5c171f43007ec7a6871885a3faeb3fd8c4f5a810097508ffd301459aa22\",\"deposit_count\":\"20\",\"block_hash\":\"0xaf01b1c1315d727d01f5991ae1481614a7f78e2beeefae22f48c76a05f973b0d\"},\"votes\":\"20\"}],\"votes_required\":\"50\",\"voting_period_slots\":\"100\",\"voting_period_slots_left\":\"30\"}}"); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetFinalizedStateSlotBeforeTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetFinalizedStateSlotBeforeTest.java new file mode 100644 index 00000000000..e79b00dfded --- /dev/null +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetFinalizedStateSlotBeforeTest.java @@ -0,0 +1,75 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.beaconrestapi.handlers.tekuv1.beacon; + +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.SLOT; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; + +import com.fasterxml.jackson.core.JsonProcessingException; +import java.io.IOException; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerTest; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; + +class GetFinalizedStateSlotBeforeTest extends AbstractMigratedBeaconHandlerTest { + final UInt64 responseData = UInt64.ONE; + + @BeforeEach + void setup() { + setHandler(new GetFinalizedStateSlotBefore(chainDataProvider)); + request.setPathParameter(SLOT, "1"); + } + + @Test + void metadata_shouldHandle400() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_BAD_REQUEST); + } + + @Test + void metadata_shouldHandle404() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_NOT_FOUND); + } + + @Test + void metadata_shouldHandle500() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_INTERNAL_SERVER_ERROR); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } + + @Test + void metadata_shouldHandle200() throws IOException { + final String data = getResponseStringFromMetadata(handler, SC_OK, responseData); + final String expected = "{\"data\":\"1\"}"; + assertThat(data).isEqualTo(expected); + } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } +} diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetStateByBlockRootTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetStateByBlockRootTest.java index 83ad9d2c576..4e5faa2ee0c 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetStateByBlockRootTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/GetStateByBlockRootTest.java @@ -19,9 +19,12 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.PARAM_BLOCK_ID; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseSszFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -77,4 +80,14 @@ void metadata_shouldHandle200() throws IOException { final BeaconState expected = spec.deserializeBeaconState(Bytes.wrap(response)); assertThat(data).isEqualTo(expected); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/validatorInclusion/GetGlobalValidatorInclusionTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/validatorInclusion/GetGlobalValidatorInclusionTest.java index 4aeb71d86f3..2c929f18fe9 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/validatorInclusion/GetGlobalValidatorInclusionTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/validatorInclusion/GetGlobalValidatorInclusionTest.java @@ -18,9 +18,11 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -87,4 +89,9 @@ void metadata_shouldHandle200() throws IOException { UTF_8); assertThat(data).isEqualTo(expected); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/validatorInclusion/GetValidatorInclusionTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/validatorInclusion/GetValidatorInclusionTest.java index a54d3334510..e9a625acffa 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/validatorInclusion/GetValidatorInclusionTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/validatorInclusion/GetValidatorInclusionTest.java @@ -18,9 +18,11 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -84,4 +86,9 @@ void metadata_shouldHandle200() throws IOException { UTF_8); assertThat(data).isEqualTo(expected); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetAttestationsTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetAttestationsTest.java index b76aee76611..33fda857071 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetAttestationsTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetAttestationsTest.java @@ -24,13 +24,14 @@ import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; import com.google.common.io.Resources; -import java.io.IOException; import java.util.Collections; import java.util.List; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerTest; +import tech.pegasys.teku.infrastructure.json.JsonTestUtil; import tech.pegasys.teku.spec.datastructures.operations.Attestation; class GetAttestationsTest extends AbstractMigratedBeaconHandlerTest { @@ -74,14 +75,16 @@ void metadata_shouldHandle500() throws JsonProcessingException { } @Test - void metadata_shouldHandle200() throws IOException { + void metadata_shouldHandle200() throws Exception { List responseData = List.of(dataStructureUtil.randomAttestation(), dataStructureUtil.randomAttestation()); final String data = getResponseStringFromMetadata(handler, SC_OK, responseData); + final JsonNode responseDataAsJsonNode = JsonTestUtil.parseAsJsonNode(data); final String expected = Resources.toString( Resources.getResource(GetAttestationsTest.class, "getAttestations.json"), UTF_8); - assertThat(data).isEqualTo(expected); + final JsonNode expectedAsJsonNode = JsonTestUtil.parseAsJsonNode(expected); + assertThat(responseDataAsJsonNode).isEqualTo(expectedAsJsonNode); } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetAttesterSlashingsTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetAttesterSlashingsTest.java index fad7d951560..08eb42fea25 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetAttesterSlashingsTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetAttesterSlashingsTest.java @@ -23,20 +23,21 @@ import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; import com.google.common.io.Resources; -import java.io.IOException; import java.util.Collections; import java.util.List; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerTest; +import tech.pegasys.teku.infrastructure.json.JsonTestUtil; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; class GetAttesterSlashingsTest extends AbstractMigratedBeaconHandlerTest { @BeforeEach void setup() { - setHandler(new GetAttesterSlashings(nodeDataProvider, spec)); + setHandler(new GetAttesterSlashings(nodeDataProvider, schemaDefinitionCache)); } @Test @@ -74,16 +75,18 @@ void metadata_shouldHandle500() throws JsonProcessingException { } @Test - void metadata_shouldHandle200() throws IOException { + void metadata_shouldHandle200() throws Exception { List responseData = List.of( dataStructureUtil.randomAttesterSlashing(), dataStructureUtil.randomAttesterSlashing()); final String data = getResponseStringFromMetadata(handler, SC_OK, responseData); + final JsonNode responseDataAsJsonNode = JsonTestUtil.parseAsJsonNode(data); final String expected = Resources.toString( Resources.getResource(GetAttesterSlashingsTest.class, "getAttesterSlashings.json"), UTF_8); - assertThat(data).isEqualTo(expected); + final JsonNode expectedAsJsonNode = JsonTestUtil.parseAsJsonNode(expected); + assertThat(responseDataAsJsonNode).isEqualTo(expectedAsJsonNode); } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlindedBlockTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlindedBlockTest.java index 98daf89144f..82eec64d036 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlindedBlockTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlindedBlockTest.java @@ -18,17 +18,21 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; import com.google.common.io.Resources; -import java.io.IOException; import java.util.concurrent.ExecutionException; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerWithChainDataProviderTest; +import tech.pegasys.teku.infrastructure.json.JsonTestUtil; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; @@ -72,14 +76,26 @@ void metadata_shouldHandle500() throws JsonProcessingException { } @Test - void metadata_shouldHandle200() throws IOException { + void metadata_shouldHandle200() throws Exception { final SignedBeaconBlock beaconBlock = dataStructureUtil.randomSignedBlindedBeaconBlock(1); final ObjectAndMetaData responseData = withMetaData(beaconBlock); final String data = getResponseStringFromMetadata(handler, SC_OK, responseData); + final JsonNode responseDataAsJsonNode = JsonTestUtil.parseAsJsonNode(data); final String expected = Resources.toString( Resources.getResource(GetBlindedBlockTest.class, "getBlindedBlock.json"), UTF_8); - assertThat(data).isEqualTo(expected); + final JsonNode expectedAsJsonNode = JsonTestUtil.parseAsJsonNode(expected); + assertThat(responseDataAsJsonNode).isEqualTo(expectedAsJsonNode); + } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlobSidecarsTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlobSidecarsTest.java index 96a63535f92..24f2a86f414 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlobSidecarsTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlobSidecarsTest.java @@ -15,25 +15,32 @@ import static java.nio.charset.StandardCharsets.UTF_8; import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static tech.pegasys.teku.beaconrestapi.BeaconRestApiTypes.ETH_CONSENSUS_VERSION_TYPE; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; import com.google.common.io.Resources; -import java.io.IOException; import java.util.Collections; import java.util.List; import java.util.concurrent.ExecutionException; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import tech.pegasys.teku.api.schema.Version; import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerWithChainDataProviderTest; +import tech.pegasys.teku.infrastructure.json.JsonTestUtil; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; +import tech.pegasys.teku.spec.datastructures.metadata.BlobSidecarsAndMetaData; import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; class GetBlobSidecarsTest extends AbstractMigratedBeaconHandlerWithChainDataProviderTest { @@ -61,7 +68,10 @@ void shouldReturnBlobSidecars() handler.handleRequest(request); assertThat(request.getResponseCode()).isEqualTo(SC_OK); - assertThat(request.getResponseBody()).isEqualTo(blobSidecars); + assertThat(((BlobSidecarsAndMetaData) request.getResponseBody()).getData()) + .isEqualTo(blobSidecars); + assertThat(request.getResponseHeaders(ETH_CONSENSUS_VERSION_TYPE.getName())) + .isEqualTo(Version.fromMilestone(SpecMilestone.DENEB).name()); } @Test @@ -80,13 +90,27 @@ void metadata_shouldHandle500() throws JsonProcessingException { } @Test - void metadata_shouldHandle200() throws IOException { + void metadata_shouldHandle200() throws Exception { final List blobSidecars = dataStructureUtil.randomBlobSidecars(3); - - final String data = getResponseStringFromMetadata(handler, SC_OK, blobSidecars); - final String expected = - Resources.toString( - Resources.getResource(GetBlobSidecarsTest.class, "getBlobSidecars.json"), UTF_8); + final BlobSidecarsAndMetaData blobSidecarsAndMetaData = + new BlobSidecarsAndMetaData(blobSidecars, SpecMilestone.DENEB, true, false, false); + final JsonNode data = + JsonTestUtil.parseAsJsonNode( + getResponseStringFromMetadata(handler, SC_OK, blobSidecarsAndMetaData)); + final JsonNode expected = + JsonTestUtil.parseAsJsonNode( + Resources.toString( + Resources.getResource(GetBlobSidecarsTest.class, "getBlobSidecars.json"), UTF_8)); assertThat(data).isEqualTo(expected); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockAttestationsTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockAttestationsTest.java index 83ddf51ecda..58d83f24123 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockAttestationsTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockAttestationsTest.java @@ -18,19 +18,23 @@ import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; import com.google.common.io.Resources; -import java.io.IOException; import java.util.List; import java.util.Optional; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerTest; import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.json.JsonTestUtil; import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; import tech.pegasys.teku.spec.datastructures.operations.Attestation; @@ -71,12 +75,24 @@ void metadata_shouldHandle500() throws JsonProcessingException { } @Test - void metadata_shouldHandle200() throws IOException { + void metadata_shouldHandle200() throws Exception { final String data = getResponseStringFromMetadata(handler, SC_OK, responseData); + final JsonNode responseDataAsJsonNode = JsonTestUtil.parseAsJsonNode(data); final String expected = Resources.toString( Resources.getResource(GetBlockAttestationsTest.class, "getBlockAttestations.json"), UTF_8); - assertThat(data).isEqualTo(expected); + final JsonNode expectedAsJsonNode = JsonTestUtil.parseAsJsonNode(expected); + assertThat(responseDataAsJsonNode).isEqualTo(expectedAsJsonNode); + } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockHeaderTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockHeaderTest.java index 6256eb1734f..e8f42fc5312 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockHeaderTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockHeaderTest.java @@ -17,20 +17,23 @@ import static org.assertj.core.api.AssertionsForClassTypes.assertThat; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; import com.google.common.io.Resources; -import java.io.IOException; import java.util.Optional; import java.util.concurrent.ExecutionException; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerWithChainDataProviderTest; import tech.pegasys.teku.bls.BLSSignature; +import tech.pegasys.teku.infrastructure.json.JsonTestUtil; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; @@ -77,12 +80,23 @@ void metadata_shouldHandle500() throws JsonProcessingException { } @Test - @Disabled("TODO: Fix fixtures, random was changed") - void metadata_shouldHandle200() throws IOException { + void metadata_shouldHandle200() throws Exception { final String data = getResponseStringFromMetadata(handler, SC_OK, responseData); + final JsonNode responseDataAsJsonNode = JsonTestUtil.parseAsJsonNode(data); final String expected = Resources.toString( Resources.getResource(GetBlockHeaderTest.class, "getBlockHeader.json"), UTF_8); - assertThat(data).isEqualTo(expected); + final JsonNode expectedAsJsonNode = JsonTestUtil.parseAsJsonNode(expected); + assertThat(responseDataAsJsonNode).isEqualTo(expectedAsJsonNode); + } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockHeadersTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockHeadersTest.java index c2bfd1e8b67..6af34049f96 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockHeadersTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockHeadersTest.java @@ -17,21 +17,24 @@ import static org.assertj.core.api.AssertionsForClassTypes.assertThat; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; import com.google.common.io.Resources; -import java.io.IOException; import java.util.List; import java.util.Optional; import java.util.concurrent.ExecutionException; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import tech.pegasys.teku.api.migrated.BlockHeadersResponse; import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerWithChainDataProviderTest; +import tech.pegasys.teku.infrastructure.json.JsonTestUtil; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.datastructures.metadata.BlockAndMetaData; @@ -67,21 +70,32 @@ void metadata_shouldHandle500() throws JsonProcessingException { } @Test - @Disabled("TODO: Fix fixtures, random was changed") - void metadata_shouldHandle200() throws IOException { + void metadata_shouldHandle200() throws Exception { final List headers = List.of(generateBlockHeaderData(), generateBlockHeaderData()); final BlockHeadersResponse responseData = new BlockHeadersResponse(true, false, headers); final String data = getResponseStringFromMetadata(handler, SC_OK, responseData); + final JsonNode responseDataAsJsonNode = JsonTestUtil.parseAsJsonNode(data); final String expected = Resources.toString( Resources.getResource(GetBlockHeadersTest.class, "getBlockHeaders.json"), UTF_8); - assertThat(data).isEqualTo(expected); + final JsonNode expectedAsJsonNode = JsonTestUtil.parseAsJsonNode(expected); + assertThat(responseDataAsJsonNode).isEqualTo(expectedAsJsonNode); } private BlockAndMetaData generateBlockHeaderData() { return new BlockAndMetaData( dataStructureUtil.randomSignedBeaconBlock(1), SpecMilestone.PHASE0, true, true, false); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockRootTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockRootTest.java index 577407957a3..d998c1a6532 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockRootTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetBlockRootTest.java @@ -17,8 +17,11 @@ import static org.assertj.core.api.AssertionsForClassTypes.assertThat; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -83,4 +86,14 @@ void metadata_shouldHandle200() throws IOException { Resources.getResource(GetBlockRootTest.class, "getBlockRoot.json"), UTF_8); assertThat(data).isEqualTo(expected); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetFinalizedBlockRootTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetFinalizedBlockRootTest.java index 5a6df110be1..3a2d6e12a1b 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetFinalizedBlockRootTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetFinalizedBlockRootTest.java @@ -19,8 +19,11 @@ import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -73,4 +76,14 @@ void metadata_shouldHandle200() throws IOException { UTF_8); assertThat(data).isEqualTo(expected); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetFinalizedCheckpointStateTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetFinalizedCheckpointStateTest.java index ac4c0c5ce2f..b5077f4ae61 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetFinalizedCheckpointStateTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetFinalizedCheckpointStateTest.java @@ -17,8 +17,11 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseSszFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -58,4 +61,14 @@ void metadata_shouldHandle200() throws IOException { final BeaconState expected = spec.deserializeBeaconState(Bytes.wrap(response)); assertThat(data).isEqualTo(expected); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetGenesisTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetGenesisTest.java index 119753f8009..f0467aae3d0 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetGenesisTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetGenesisTest.java @@ -17,7 +17,9 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; @@ -96,4 +98,14 @@ void metadata_shouldHandle200() throws JsonProcessingException { "{\"data\":{\"genesis_time\":\"%s\",\"genesis_validators_root\":\"%s\",\"genesis_fork_version\":\"%s\"}}", genesisTime, genesisValidatorsRoot, fork)); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateCommitteesTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateCommitteesTest.java index 63f23b0a3af..57d020557f7 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateCommitteesTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateCommitteesTest.java @@ -80,7 +80,7 @@ public void shouldGetCommitteesFromState() throws Exception { @ParameterizedTest @ValueSource(strings = {"index", "slot", "epoch"}) - public void shouldFailIfEpochInvalid(String queryParam) { + public void shouldFailIfEpochInvalid(final String queryParam) { final StubRestApiRequest request = StubRestApiRequest.builder() .metadata(handler.getMetadata()) diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateFinalityCheckpointsTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateFinalityCheckpointsTest.java index 912150f44a3..7eb3f3c42d4 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateFinalityCheckpointsTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateFinalityCheckpointsTest.java @@ -17,8 +17,11 @@ import static org.assertj.core.api.AssertionsForClassTypes.assertThat; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -96,4 +99,14 @@ void metadata_shouldHandle200() throws IOException { assertThat(data).isEqualTo(expected); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateForkTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateForkTest.java index 7fe8dd34623..fe702ffc7f8 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateForkTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateForkTest.java @@ -17,8 +17,11 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -101,4 +104,14 @@ void metadata_shouldHandle200() throws JsonProcessingException { .isEqualTo( "{\"execution_optimistic\":false,\"finalized\":false,\"data\":{\"previous_version\":\"0x103ac940\",\"current_version\":\"0x6fdfab40\",\"epoch\":\"4658411424342975020\"}}"); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateRandaoTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateRandaoTest.java index 742879833d8..daf0ea36c4c 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateRandaoTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateRandaoTest.java @@ -17,8 +17,11 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -70,4 +73,14 @@ void metadata_shouldHandle200() throws IOException { randao); assertThat(data).isEqualTo(expected); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateRootTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateRootTest.java index 332fe838cd5..a5f6bc758a0 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateRootTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateRootTest.java @@ -16,8 +16,11 @@ import static org.assertj.core.api.AssertionsForClassTypes.assertThat; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -77,4 +80,14 @@ void metadata_shouldHandle200() throws IOException { responseData.getData().hashTreeRoot()); assertThat(data).isEqualTo(expected); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateSyncCommitteesTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateSyncCommitteesTest.java index 1b1ca22d2e6..7ca0bed5632 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateSyncCommitteesTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateSyncCommitteesTest.java @@ -16,8 +16,11 @@ import static org.assertj.core.api.AssertionsForClassTypes.assertThat; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -96,4 +99,14 @@ void metadata_shouldHandle200() throws IOException { "{\"execution_optimistic\":false,\"finalized\":false,\"data\":{\"validators\":[\"2\",\"92\",\"37\"],\"validator_aggregates\":[[\"9\",\"89\"],[\"1\"]]}}"; assertThat(data).isEqualTo(expected); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateValidatorBalancesTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateValidatorBalancesTest.java index e735156d11c..4a0d54097e4 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateValidatorBalancesTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateValidatorBalancesTest.java @@ -18,8 +18,11 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -117,4 +120,14 @@ void metadata_shouldHandle200() throws IOException { UTF_8); assertThat(data).isEqualTo(expected); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateValidatorTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateValidatorTest.java index 0e3106901a8..401307bec14 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateValidatorTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateValidatorTest.java @@ -17,8 +17,11 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -114,4 +117,14 @@ void metadata_shouldHandle200() throws IOException { AssertionsForClassTypes.assertThat(data).isEqualTo(expected); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateValidatorsTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateValidatorsTest.java index 9d48b140a3d..e54c0740c27 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateValidatorsTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/GetStateValidatorsTest.java @@ -29,7 +29,9 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; @@ -208,4 +210,14 @@ private static Stream provideStatusParameters() { Arguments.of(List.of("exited"), Set.of(exited_slashed, exited_unslashed)), Arguments.of(List.of("withdrawal"), Set.of(withdrawal_done, withdrawal_possible))); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostAttestationTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostAttestationTest.java index 58a0d5c1a9d..6eec8e8ae92 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostAttestationTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostAttestationTest.java @@ -19,7 +19,9 @@ import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getRequestBodyFromMetadata; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; @@ -111,4 +113,14 @@ void metadata_shouldHandle500() throws JsonProcessingException { void metadata_shouldHandle200() throws IOException { verifyMetadataEmptyResponse(handler, SC_OK); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostAttesterSlashingTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostAttesterSlashingTest.java index ab7302db2a6..bb7e27defee 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostAttesterSlashingTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostAttesterSlashingTest.java @@ -38,7 +38,7 @@ public class PostAttesterSlashingTest extends AbstractMigratedBeaconHandlerTest @BeforeEach void setup() { - setHandler(new PostAttesterSlashing(nodeDataProvider, spec)); + setHandler(new PostAttesterSlashing(nodeDataProvider, schemaDefinitionCache)); } @Test diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostBlindedBlockTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostBlindedBlockTest.java index 46ac20c2faf..6eb94fc48cd 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostBlindedBlockTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostBlindedBlockTest.java @@ -14,7 +14,12 @@ package tech.pegasys.teku.beaconrestapi.handlers.v1.beacon; import static org.assertj.core.api.Assertions.assertThat; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; +import com.fasterxml.jackson.core.JsonProcessingException; import java.io.ByteArrayInputStream; import java.util.Optional; import org.junit.jupiter.api.Test; @@ -47,4 +52,14 @@ void shouldAcceptBlindedBlockAsSsz() throws Exception { Optional.of(ContentTypes.OCTET_STREAM)); assertThat(result).isEqualTo(data); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostBlockTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostBlockTest.java index 7478104c127..8210fdbf4c2 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostBlockTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostBlockTest.java @@ -14,7 +14,12 @@ package tech.pegasys.teku.beaconrestapi.handlers.v1.beacon; import static org.assertj.core.api.Assertions.assertThat; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; +import com.fasterxml.jackson.core.JsonProcessingException; import java.io.ByteArrayInputStream; import java.util.Optional; import org.junit.jupiter.api.Test; @@ -61,4 +66,14 @@ void shouldAcceptBlockContentsAsSsz() throws Exception { Optional.of(ContentTypes.OCTET_STREAM)); assertThat(result).isEqualTo(data); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostStateValidatorBalancesTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostStateValidatorBalancesTest.java index ab78211cbda..a2e78f7e0fd 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostStateValidatorBalancesTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostStateValidatorBalancesTest.java @@ -18,8 +18,11 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -116,4 +119,14 @@ void metadata_shouldHandle200() throws IOException { UTF_8); assertThat(data).isEqualTo(expected); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostStateValidatorsTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostStateValidatorsTest.java index 065f237797f..69366db9f69 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostStateValidatorsTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostStateValidatorsTest.java @@ -29,7 +29,9 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; @@ -238,4 +240,14 @@ private static Stream provideStatusParameters() { Arguments.of(List.of("exited"), Set.of(exited_slashed, exited_unslashed)), Arguments.of(List.of("withdrawal"), Set.of(withdrawal_done, withdrawal_possible))); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostSyncCommitteesTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostSyncCommitteesTest.java index b1ed54567ce..deca2e1bd42 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostSyncCommitteesTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/PostSyncCommitteesTest.java @@ -19,7 +19,9 @@ import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; @@ -107,4 +109,14 @@ void metadata_shouldHandle500() throws JsonProcessingException { void metadata_shouldHandle200() throws IOException { verifyMetadataEmptyResponse(handler, SC_OK); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/builder/GetExpectedWithdrawalsTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/builder/GetExpectedWithdrawalsTest.java index 451fe9d462c..ffc76d8bf6a 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/builder/GetExpectedWithdrawalsTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/builder/GetExpectedWithdrawalsTest.java @@ -19,17 +19,20 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_IMPLEMENTED; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; import com.google.common.io.Resources; -import java.io.IOException; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerWithChainDataProviderTest; +import tech.pegasys.teku.infrastructure.json.JsonTestUtil; import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.capella.BeaconBlockBodyCapella; @@ -68,18 +71,28 @@ void metadata_shouldHandle501() throws JsonProcessingException { } @Test - @Disabled("TODO: Fix fixtures, random was changed") - void metadata_shouldHandle200() throws IOException { + void metadata_shouldHandle200() throws Exception { final BeaconBlockBodyCapella beaconBlock = BeaconBlockBodyCapella.required(dataStructureUtil.randomBeaconBlock(1).getBody()); final ObjectAndMetaData> responseData = withMetaData(beaconBlock.getExecutionPayload().getWithdrawals()); - final String data = getResponseStringFromMetadata(handler, SC_OK, responseData); + final JsonNode responseDataAsJsonNode = JsonTestUtil.parseAsJsonNode(data); final String expected = Resources.toString( Resources.getResource(GetExpectedWithdrawalsTest.class, "getExpectedWithdrawals.json"), UTF_8); - assertThat(data).isEqualTo(expected); + final JsonNode expectedAsJsonNode = JsonTestUtil.parseAsJsonNode(expected); + assertThat(responseDataAsJsonNode).isEqualTo(expectedAsJsonNode); + } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/debug/GetForkChoiceTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/debug/GetForkChoiceTest.java index 62bc2d418d9..86611a29580 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/debug/GetForkChoiceTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/debug/GetForkChoiceTest.java @@ -18,9 +18,11 @@ import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -97,4 +99,9 @@ void metadata_shouldHandle200() throws IOException { Resources.toString(Resources.getResource(GetForkChoice.class, "getForkChoice.json"), UTF_8); assertThat(data).isEqualTo(expected); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/debug/GetStateTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/debug/GetStateTest.java index 957bdf1c0c1..10cb2064409 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/debug/GetStateTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/debug/GetStateTest.java @@ -20,18 +20,22 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; import com.google.common.io.Resources; -import java.io.IOException; import java.util.Optional; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerTest; import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.json.JsonTestUtil; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.datastructures.metadata.StateAndMetaData; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; @@ -75,12 +79,23 @@ void metadata_shouldHandle500() throws JsonProcessingException { } @Test - void metadata_shouldHandle200() throws IOException { - BeaconState responseData = dataStructureUtil.randomBeaconState(); - + void metadata_shouldHandle200() throws Exception { + final BeaconState responseData = dataStructureUtil.randomBeaconState(); final String data = getResponseStringFromMetadata(handler, SC_OK, responseData); + final JsonNode responseDataAsJsonNode = JsonTestUtil.parseAsJsonNode(data); final String expected = Resources.toString(Resources.getResource(GetStateTest.class, "getState.json"), UTF_8); - assertThat(data).isEqualTo(String.format(expected, responseData.getGenesisTime())); + final JsonNode expectedAsJsonNode = JsonTestUtil.parseAsJsonNode(expected); + assertThat(responseDataAsJsonNode).isEqualTo(expectedAsJsonNode); + } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/EventSubscriberTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/EventSubscriberTest.java index 88950827561..e0f6a09837c 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/EventSubscriberTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/EventSubscriberTest.java @@ -32,7 +32,6 @@ import java.io.IOException; import java.util.Arrays; import java.util.List; -import java.util.stream.Collectors; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; @@ -53,8 +52,7 @@ public class EventSubscriberTest { private final Context context = new StubContext(req, res); private final StubAsyncRunner asyncRunner = new StubAsyncRunner(); - private final List allEventTypes = - Arrays.stream(EventType.values()).collect(Collectors.toList()); + private final List allEventTypes = Arrays.stream(EventType.values()).toList(); private SseClient sseClient; diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/EventSubscriptionManagerTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/EventSubscriptionManagerTest.java index 324656e3219..5b251fe5b74 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/EventSubscriptionManagerTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/EventSubscriptionManagerTest.java @@ -519,7 +519,7 @@ private void triggerContributionEvent() { asyncRunner.executeQueuedActions(); } - private > void checkEvent(String eventType, E event) + private > void checkEvent(final String eventType, final E event) throws JsonProcessingException { final String eventString = outputStream.getString(); assertThat(eventString).contains(String.format("event: %s\n", eventType)); diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/EventTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/EventTest.java index b23a24a2249..d1dc3d602ee 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/EventTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/EventTest.java @@ -38,10 +38,16 @@ public static Stream getEventTypes() { final Spec spec = TestSpecFactory.createMinimalPhase0(); final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); + final Spec specElectra = TestSpecFactory.createMinimalElectra(); + final DataStructureUtil dataStructureUtilElectra = new DataStructureUtil(specElectra); return Stream.of( Arguments.of( - "AttestationEvent", + "AttestationEvent Phase0", new AttestationEvent(dataStructureUtil.randomAttestation()).getJsonTypeDefinition()), + Arguments.of( + "AttestationEvent Electra", + new AttestationEvent(dataStructureUtilElectra.randomAttestation()) + .getJsonTypeDefinition()), Arguments.of( "BlockEvent", new BlockEvent(dataStructureUtil.randomSignedBeaconBlock(1), false) diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/StubContext.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/StubContext.java index 7d2306edc59..060a0ee2fab 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/StubContext.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/StubContext.java @@ -109,7 +109,7 @@ public InputStream resultInputStream() { } @Override - public T appData(@NotNull Key key) { + public T appData(@NotNull final Key key) { return null; } @@ -121,7 +121,7 @@ public JsonMapper jsonMapper() { @NotNull @Override - public Context minSizeForCompression(int i) { + public Context minSizeForCompression(final int i) { return null; } @@ -138,10 +138,15 @@ public Context skipRemainingHandlers() { } @Override - public T with(@NotNull Class> aClass) { + public T with(@NotNull final Class> aClass) { return null; } @Override - public void writeJsonStream(@NotNull Stream stream) {} + public void writeJsonStream(@NotNull final Stream stream) {} + + @Override + public boolean strictContentTypes() { + return false; + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/TestEvent.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/TestEvent.java index bbe1282eb63..e2ff03ee58c 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/TestEvent.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/TestEvent.java @@ -19,7 +19,7 @@ public class TestEvent extends Event { private static final SerializableTypeDefinition EVENT_TYPE = SerializableTypeDefinition.object(String.class).build(); - TestEvent(String data) { + TestEvent(final String data) { super(EVENT_TYPE, data); } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/TestServletOutputStream.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/TestServletOutputStream.java index 8a838515408..a26b59dd3fa 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/TestServletOutputStream.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/TestServletOutputStream.java @@ -21,7 +21,7 @@ import org.apache.commons.lang3.StringUtils; public class TestServletOutputStream extends ServletOutputStream { - private StringBuilder builder = new StringBuilder(); + private final StringBuilder builder = new StringBuilder(); private int writeCounter = 0; @Override diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetHealthTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetHealthTest.java index fbc17089965..91974d2cbca 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetHealthTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetHealthTest.java @@ -19,6 +19,7 @@ import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_PARTIAL_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; @@ -141,4 +142,14 @@ void metadata_shouldHandle500() throws JsonProcessingException { void metadata_shouldHandle200() { verifyMetadataEmptyResponse(handler, SC_OK); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataEmptyResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetIdentityTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetIdentityTest.java index dc268bd1ecd..fa868eb609c 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetIdentityTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetIdentityTest.java @@ -53,7 +53,7 @@ public void shouldReturnExpectedObjectType() throws Exception { when(eth2P2PNetwork.getMetadata()).thenReturn(defaultMetadata); when(eth2P2PNetwork.getNodeId()).thenReturn(nodeid); when(nodeid.toBase58()).thenReturn("aeiou"); - when(eth2P2PNetwork.getNodeAddress()).thenReturn("address"); + when(eth2P2PNetwork.getNodeAddresses()).thenReturn(List.of("address")); handler.handleRequest(request); diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetPeerCountTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetPeerCountTest.java index 87df3a9f2e0..c239d34f3f7 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetPeerCountTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/node/GetPeerCountTest.java @@ -23,19 +23,18 @@ import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; -import java.util.List; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import tech.pegasys.teku.api.NetworkDataProvider; import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerTest; -import tech.pegasys.teku.networking.eth2.peers.Eth2Peer; +import tech.pegasys.teku.ethereum.json.types.node.PeerCount; +import tech.pegasys.teku.ethereum.json.types.node.PeerCountBuilder; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; class GetPeerCountTest extends AbstractMigratedBeaconHandlerTest { - private final Eth2Peer peer1 = mock(Eth2Peer.class); - private final Eth2Peer peer2 = mock(Eth2Peer.class); private final NetworkDataProvider networkDataProvider = mock(NetworkDataProvider.class); - private final List data = List.of(peer1, peer2); - private final GetPeerCount.ResponseData peerCountData = new GetPeerCount.ResponseData(data); + private final PeerCount peerCount = + new PeerCountBuilder().disconnected(UInt64.valueOf(2)).connected(UInt64.valueOf(4)).build(); @BeforeEach void setUp() { @@ -45,11 +44,11 @@ void setUp() { @Test public void shouldReturnListOfPeers() throws Exception { - when(networkDataProvider.getEth2Peers()).thenReturn(data); + when(networkDataProvider.getPeerCount()).thenReturn(peerCount); handler.handleRequest(request); assertThat(request.getResponseCode()).isEqualTo(SC_OK); - assertThat(request.getResponseBody()).isEqualTo(peerCountData); + assertThat(request.getResponseBody()).isEqualTo(peerCount); } @Test @@ -64,9 +63,9 @@ void metadata_shouldHandle500() throws JsonProcessingException { @Test void metadata_shouldHandle200() throws JsonProcessingException { - final String data = getResponseStringFromMetadata(handler, SC_OK, peerCountData); + final String data = getResponseStringFromMetadata(handler, SC_OK, peerCount); assertThat(data) .isEqualTo( - "{\"data\":{\"disconnected\":\"2\",\"connecting\":\"0\",\"connected\":\"0\",\"disconnecting\":\"0\"}}"); + "{\"data\":{\"disconnected\":\"2\",\"connecting\":\"0\",\"connected\":\"4\",\"disconnecting\":\"0\"}}"); } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/rewards/GetAttestationRewardsTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/rewards/GetAttestationRewardsTest.java index 9b87af01002..02af105cc5f 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/rewards/GetAttestationRewardsTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/rewards/GetAttestationRewardsTest.java @@ -18,9 +18,11 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_IMPLEMENTED; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -80,11 +82,6 @@ void metadata_shouldHandle500() throws JsonProcessingException { verifyMetadataErrorResponse(handler, SC_INTERNAL_SERVER_ERROR); } - @Test - void metadata_shouldHandle501() throws JsonProcessingException { - verifyMetadataErrorResponse(handler, SC_NOT_IMPLEMENTED); - } - @Test void metadata_shouldHandle200() throws IOException { final String data = getResponseStringFromMetadata(handler, SC_OK, responseData); @@ -94,4 +91,14 @@ void metadata_shouldHandle200() throws IOException { UTF_8); assertThat(data).isEqualTo(String.format(expected, responseData)); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/rewards/GetBlockRewardsTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/rewards/GetBlockRewardsTest.java index 790a2c35121..df35f4f41ad 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/rewards/GetBlockRewardsTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/rewards/GetBlockRewardsTest.java @@ -18,8 +18,11 @@ import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -88,4 +91,14 @@ void metadata_shouldHandle200() throws IOException { Resources.getResource(GetBlockRewardsTest.class, "blockRewardsData.json"), UTF_8); AssertionsForClassTypes.assertThat(data).isEqualTo(expected); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/rewards/GetSyncCommitteeRewardsTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/rewards/GetSyncCommitteeRewardsTest.java index 8c471d09808..dff45e47ceb 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/rewards/GetSyncCommitteeRewardsTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/rewards/GetSyncCommitteeRewardsTest.java @@ -18,8 +18,11 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -113,4 +116,14 @@ void metadata_shouldHandle200() throws IOException { UTF_8); assertThat(data).isEqualTo(expected); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetAggregateAttestationTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetAggregateAttestationTest.java index 2d36214531f..15c78b50488 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetAggregateAttestationTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetAggregateAttestationTest.java @@ -25,14 +25,15 @@ import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; import com.google.common.io.Resources; -import java.io.IOException; import java.util.Optional; import org.apache.tuweni.bytes.Bytes32; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerTest; import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.json.JsonTestUtil; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.datastructures.operations.Attestation; @@ -50,7 +51,8 @@ public void shouldReturnAttestationInformation() throws JsonProcessingException request.setQueryParameter("attestation_data_root", attestationDataRoot.toHexString()); Attestation attestation = dataStructureUtil.randomAttestation(); - when(validatorDataProvider.createAggregate(eq(UInt64.valueOf(1)), eq(attestationDataRoot))) + when(validatorDataProvider.createAggregate( + eq(UInt64.valueOf(1)), eq(attestationDataRoot), eq(Optional.empty()))) .thenReturn(SafeFuture.completedFuture(Optional.of(attestation))); handler.handleRequest(request); @@ -75,15 +77,16 @@ void metadata_shouldHandle500() throws JsonProcessingException { } @Test - void metadata_shouldHandle200() throws IOException { - Attestation responseData = dataStructureUtil.randomAttestation(); - + void metadata_shouldHandle200() throws Exception { + final Attestation responseData = dataStructureUtil.randomAttestation(); final String data = getResponseStringFromMetadata(handler, SC_OK, responseData); + final JsonNode responseDataAsJsonNode = JsonTestUtil.parseAsJsonNode(data); final String expected = Resources.toString( Resources.getResource( GetAggregateAttestationTest.class, "getAggregateAttestation.json"), UTF_8); - assertThat(data).isEqualTo(expected); + final JsonNode expectedAsJsonNode = JsonTestUtil.parseAsJsonNode(expected); + assertThat(responseDataAsJsonNode).isEqualTo(expectedAsJsonNode); } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetAttestationDataTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetAttestationDataTest.java index ccef7493054..94a30ae039e 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetAttestationDataTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetAttestationDataTest.java @@ -17,11 +17,13 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.COMMITTEE_INDEX; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.SLOT; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -74,6 +76,11 @@ void metadata_shouldHandle500() throws JsonProcessingException { verifyMetadataErrorResponse(handler, SC_INTERNAL_SERVER_ERROR); } + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + @Test void metadata_shouldHandle503() throws JsonProcessingException { verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetProposerDutiesTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetProposerDutiesTest.java index 07ccea7eb37..a1449040e69 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetProposerDutiesTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetProposerDutiesTest.java @@ -19,9 +19,12 @@ import static org.mockito.Mockito.when; import static tech.pegasys.teku.beacon.sync.events.SyncState.SYNCING; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.EPOCH; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -105,4 +108,14 @@ void metadata_shouldHandle200() throws IOException { Resources.getResource(GetProposerDutiesTest.class, "getProposerDuties.json"), UTF_8); AssertionsForClassTypes.assertThat(data).isEqualTo(expected); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostAggregateAndProofsTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostAggregateAndProofsTest.java index c48d3538ad9..88abbb5e088 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostAggregateAndProofsTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostAggregateAndProofsTest.java @@ -18,7 +18,9 @@ import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; @@ -32,14 +34,14 @@ import tech.pegasys.teku.infrastructure.http.HttpErrorResponse; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; import tech.pegasys.teku.validator.api.SubmitDataError; public class PostAggregateAndProofsTest extends AbstractMigratedBeaconHandlerTest { @BeforeEach public void beforeEach() { - setHandler( - new PostAggregateAndProofs(validatorDataProvider, spec.getGenesisSchemaDefinitions())); + setHandler(new PostAggregateAndProofs(validatorDataProvider, new SchemaDefinitionCache(spec))); } @Test @@ -90,4 +92,14 @@ void metadata_shouldHandle500() throws JsonProcessingException { void metadata_shouldHandle200() { verifyMetadataEmptyResponse(handler, SC_OK); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostAttesterDutiesTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostAttesterDutiesTest.java index c5d7b8763a1..688157060d9 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostAttesterDutiesTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostAttesterDutiesTest.java @@ -19,10 +19,12 @@ import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getRequestBodyFromMetadata; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -100,6 +102,11 @@ void metadata_shouldHandle500() throws JsonProcessingException { verifyMetadataErrorResponse(handler, SC_INTERNAL_SERVER_ERROR); } + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + @Test void metadata_shouldHandle503() throws JsonProcessingException { verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostContributionAndProofsTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostContributionAndProofsTest.java index 9abb4b3545e..c6790e3a6ba 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostContributionAndProofsTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostContributionAndProofsTest.java @@ -17,7 +17,9 @@ import static org.assertj.core.api.Assertions.assertThat; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getRequestBodyFromMetadata; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; @@ -65,4 +67,14 @@ void metadata_shouldHandle500() throws JsonProcessingException { void metadata_shouldHandle200() { verifyMetadataEmptyResponse(handler, SC_OK); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostPrepareBeaconProposerTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostPrepareBeaconProposerTest.java index eef2c8b6f65..26b34d21e61 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostPrepareBeaconProposerTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostPrepareBeaconProposerTest.java @@ -17,6 +17,9 @@ import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -26,7 +29,7 @@ import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerTest; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.http.HttpStatusCodes; -import tech.pegasys.teku.spec.datastructures.operations.versions.bellatrix.BeaconPreparableProposer; +import tech.pegasys.teku.spec.datastructures.validator.BeaconPreparableProposer; class PostPrepareBeaconProposerTest extends AbstractMigratedBeaconHandlerTest { @@ -57,4 +60,14 @@ void metadata_shouldHandle400() throws JsonProcessingException { void metadata_shouldHandle500() throws JsonProcessingException { verifyMetadataErrorResponse(handler, SC_INTERNAL_SERVER_ERROR); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostRegisterValidatorTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostRegisterValidatorTest.java index 97eb819e540..fbffe91f6eb 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostRegisterValidatorTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostRegisterValidatorTest.java @@ -17,7 +17,10 @@ import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -56,4 +59,14 @@ void metadata_shouldHandle400() throws JsonProcessingException { void metadata_shouldHandle500() throws JsonProcessingException { verifyMetadataErrorResponse(handler, SC_INTERNAL_SERVER_ERROR); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostSubscribeToBeaconCommitteeSubnetTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostSubscribeToBeaconCommitteeSubnetTest.java index 13cb3de9b23..e7ed25b337c 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostSubscribeToBeaconCommitteeSubnetTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostSubscribeToBeaconCommitteeSubnetTest.java @@ -18,7 +18,9 @@ import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getRequestBodyFromMetadata; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; @@ -31,6 +33,7 @@ import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerTest; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.validator.api.CommitteeSubscriptionData; class PostSubscribeToBeaconCommitteeSubnetTest extends AbstractMigratedBeaconHandlerTest { @@ -43,9 +46,8 @@ void setup() { @Test public void shouldReturnSuccessWhenSubscriptionToBeaconCommitteeIsSuccessful() throws JsonProcessingException { - final PostSubscribeToBeaconCommitteeSubnet.CommitteeSubscriptionData data = - new PostSubscribeToBeaconCommitteeSubnet.CommitteeSubscriptionData( - 1, 1, UInt64.ONE, UInt64.ONE, false); + final CommitteeSubscriptionData data = + new CommitteeSubscriptionData(1, 1, UInt64.ONE, UInt64.ONE, false); request.setRequestBody(List.of(data)); @@ -61,10 +63,7 @@ void shouldReadRequestBody() throws IOException { "[{\"validator_index\":\"1\",\"committee_index\":\"1\",\"committees_at_slot\":\"1\"," + "\"slot\":\"1\",\"is_aggregator\":true}]"; assertThat(getRequestBodyFromMetadata(handler, data)) - .isEqualTo( - List.of( - new PostSubscribeToBeaconCommitteeSubnet.CommitteeSubscriptionData( - 1, 1, UInt64.ONE, UInt64.ONE, true))); + .isEqualTo(List.of(new CommitteeSubscriptionData(1, 1, UInt64.ONE, UInt64.ONE, true))); } @Test @@ -81,4 +80,14 @@ void metadata_shouldHandle500() throws JsonProcessingException { void metadata_shouldHandle200() { verifyMetadataEmptyResponse(handler, SC_OK); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostSyncCommitteeSubscriptionsTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostSyncCommitteeSubscriptionsTest.java index b6fad5f29cc..7147f11c502 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostSyncCommitteeSubscriptionsTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostSyncCommitteeSubscriptionsTest.java @@ -18,7 +18,9 @@ import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getRequestBodyFromMetadata; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; @@ -30,14 +32,13 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerTest; +import tech.pegasys.teku.ethereum.json.types.validator.PostSyncCommitteeData; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.unsigned.UInt64; class PostSyncCommitteeSubscriptionsTest extends AbstractMigratedBeaconHandlerTest { - private final List requestBody = - List.of( - new PostSyncCommitteeSubscriptions.PostSyncCommitteeData( - 1, new IntOpenHashSet(List.of(0, 1)), UInt64.ONE)); + private final List requestBody = + List.of(new PostSyncCommitteeData(1, new IntOpenHashSet(List.of(0, 1)), UInt64.ONE)); @BeforeEach void setup() { @@ -77,4 +78,14 @@ void metadata_shouldHandle500() throws JsonProcessingException { void metadata_shouldHandle200() { verifyMetadataEmptyResponse(handler, SC_OK); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostSyncDutiesTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostSyncDutiesTest.java index ba2c1a547cf..28c24dc3cef 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostSyncDutiesTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostSyncDutiesTest.java @@ -21,10 +21,12 @@ import static tech.pegasys.teku.beacon.sync.events.SyncState.SYNCING; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getRequestBodyFromMetadata; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -103,4 +105,14 @@ void metadata_shouldHandle200() throws IOException { Resources.getResource(PostSyncDutiesTest.class, "postSyncDuties.json"), UTF_8); assertThat(data).isEqualTo(expected); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostValidatorLivenessTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostValidatorLivenessTest.java index 83e218a063f..d670b6db96a 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostValidatorLivenessTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/PostValidatorLivenessTest.java @@ -17,10 +17,12 @@ import static org.assertj.core.api.AssertionsForClassTypes.assertThat; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getRequestBodyFromMetadata; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -73,4 +75,9 @@ void metadata_shouldHandle200() throws IOException { UTF_8); assertThat(data).isEqualTo(expected); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetAttestationsV2Test.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetAttestationsV2Test.java new file mode 100644 index 00000000000..3425a5667cc --- /dev/null +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetAttestationsV2Test.java @@ -0,0 +1,119 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.beaconrestapi.handlers.v2.beacon; + +import static java.nio.charset.StandardCharsets.UTF_8; +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.when; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; +import static tech.pegasys.teku.spec.SpecMilestone.ELECTRA; +import static tech.pegasys.teku.spec.SpecMilestone.PHASE0; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; +import com.google.common.io.Resources; +import java.io.IOException; +import java.util.Collections; +import java.util.List; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.schema.Version; +import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerTest; +import tech.pegasys.teku.infrastructure.json.JsonTestUtil; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider; +import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +@TestSpecContext(milestone = {PHASE0, ELECTRA}) +public class GetAttestationsV2Test extends AbstractMigratedBeaconHandlerTest { + + private SpecMilestone specMilestone; + + @BeforeEach + void setup(final TestSpecInvocationContextProvider.SpecContext specContext) { + spec = specContext.getSpec(); + dataStructureUtil = new DataStructureUtil(spec); + specMilestone = specContext.getSpecMilestone(); + setHandler(new GetAttestationsV2(nodeDataProvider, new SchemaDefinitionCache(spec))); + } + + @TestTemplate + public void shouldReturnAttestationsWhenFound() throws JsonProcessingException { + final List attestations = + List.of(dataStructureUtil.randomAttestation(), dataStructureUtil.randomAttestation()); + final ObjectAndMetaData> attestationsAndMetaData = + new ObjectAndMetaData<>( + attestations, spec.getGenesisSpec().getMilestone(), false, false, false); + when(nodeDataProvider.getAttestationsAndMetaData(any(), any())) + .thenReturn(attestationsAndMetaData); + + handler.handleRequest(request); + assertThat(request.getResponseCode()).isEqualTo(SC_OK); + assertThat(request.getResponseBody()).isEqualTo(attestationsAndMetaData); + assertThat(request.getResponseHeaders(HEADER_CONSENSUS_VERSION)) + .isEqualTo(Version.fromMilestone(specMilestone).name()); + } + + @TestTemplate + public void shouldReturnEmptyListWhenNoAttestations() throws JsonProcessingException { + final ObjectAndMetaData> attestationsAndMetaData = + new ObjectAndMetaData<>( + Collections.emptyList(), spec.getGenesisSpec().getMilestone(), false, false, false); + when(nodeDataProvider.getAttestationsAndMetaData(any(), any())) + .thenReturn(attestationsAndMetaData); + + handler.handleRequest(request); + assertThat(request.getResponseCode()).isEqualTo(SC_OK); + assertThat(request.getResponseBody()).isEqualTo(attestationsAndMetaData); + assertThat(request.getResponseHeaders(HEADER_CONSENSUS_VERSION)) + .isEqualTo(Version.fromMilestone(specMilestone).name()); + } + + @TestTemplate + void metadata_shouldHandle400() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_BAD_REQUEST); + } + + @TestTemplate + void metadata_shouldHandle500() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_INTERNAL_SERVER_ERROR); + } + + @TestTemplate + void metadata_shouldHandle200() throws Exception { + final List attestations = + List.of(dataStructureUtil.randomAttestation(), dataStructureUtil.randomAttestation()); + final ObjectAndMetaData> responseData = withMetaData(attestations); + final String responseDataAsString = getResponseStringFromMetadata(handler, SC_OK, responseData); + final JsonNode responseDataAsJsonNode = JsonTestUtil.parseAsJsonNode(responseDataAsString); + final String expected = getExpectedResponseAsJson(specMilestone); + final JsonNode expectedAsJsonNode = JsonTestUtil.parseAsJsonNode(expected); + assertThat(responseDataAsJsonNode).isEqualTo(expectedAsJsonNode); + } + + private String getExpectedResponseAsJson(final SpecMilestone specMilestone) throws IOException { + final String fileName = String.format("getAttestations%s.json", specMilestone.name()); + return Resources.toString(Resources.getResource(GetAttestationsV2Test.class, fileName), UTF_8); + } +} diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetAttesterSlashingsV2Test.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetAttesterSlashingsV2Test.java new file mode 100644 index 00000000000..22591cf9cab --- /dev/null +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetAttesterSlashingsV2Test.java @@ -0,0 +1,120 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.beaconrestapi.handlers.v2.beacon; + +import static java.nio.charset.StandardCharsets.UTF_8; +import static java.util.Collections.emptyList; +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.mockito.Mockito.when; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; +import static tech.pegasys.teku.spec.SpecMilestone.ELECTRA; +import static tech.pegasys.teku.spec.SpecMilestone.PHASE0; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; +import com.google.common.io.Resources; +import java.io.IOException; +import java.util.List; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerTest; +import tech.pegasys.teku.infrastructure.json.JsonTestUtil; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider; +import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; +import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +@TestSpecContext(milestone = {PHASE0, ELECTRA}) +class GetAttesterSlashingsV2Test extends AbstractMigratedBeaconHandlerTest { + + private SpecMilestone specMilestone; + + @BeforeEach + void setup(final TestSpecInvocationContextProvider.SpecContext specContext) { + spec = specContext.getSpec(); + dataStructureUtil = new DataStructureUtil(spec); + specMilestone = specContext.getSpecMilestone(); + setHandler(new GetAttesterSlashingsV2(nodeDataProvider, new SchemaDefinitionCache(spec))); + } + + @TestTemplate + void should_returnAttesterSlashings() throws Exception { + final List attesterSlashing = + List.of(dataStructureUtil.randomAttesterSlashing()); + final ObjectAndMetaData> attesterSlashingWithMetaData = + new ObjectAndMetaData<>(attesterSlashing, specMilestone, false, false, false); + when(nodeDataProvider.getAttesterSlashingsAndMetaData()) + .thenReturn(attesterSlashingWithMetaData); + + handler.handleRequest(request); + assertThat(request.getResponseCode()).isEqualTo(SC_OK); + assertThat(request.getResponseBody()).isEqualTo(attesterSlashingWithMetaData); + assertThat(request.getResponseHeaders(HEADER_CONSENSUS_VERSION)) + .isEqualTo(specMilestone.name()); + } + + @TestTemplate + void should_returnEmptyListWhenNoAttesterSlashings() throws Exception { + + final ObjectAndMetaData> attesterSlashingWithMetaData = + new ObjectAndMetaData<>(emptyList(), specMilestone, false, false, false); + when(nodeDataProvider.getAttesterSlashingsAndMetaData()) + .thenReturn(attesterSlashingWithMetaData); + + handler.handleRequest(request); + assertThat(request.getResponseCode()).isEqualTo(SC_OK); + assertThat(request.getResponseBody()).isEqualTo(attesterSlashingWithMetaData); + assertThat(request.getResponseHeaders(HEADER_CONSENSUS_VERSION)) + .isEqualTo(specMilestone.name()); + } + + @TestTemplate + void metadata_shouldHandle200() throws Exception { + final ObjectAndMetaData> responseData = + withMetaData( + List.of( + dataStructureUtil.randomAttesterSlashing(), + dataStructureUtil.randomAttesterSlashing())); + + final JsonNode data = + JsonTestUtil.parseAsJsonNode(getResponseStringFromMetadata(handler, SC_OK, responseData)); + final JsonNode expected = + JsonTestUtil.parseAsJsonNode(getExpectedResponseAsJson(specMilestone)); + assertThat(data).isEqualTo(expected); + } + + @TestTemplate + void metadata_shouldHandle400() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_BAD_REQUEST); + } + + @TestTemplate + void metadata_shouldHandle500() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_INTERNAL_SERVER_ERROR); + } + + private String getExpectedResponseAsJson(final SpecMilestone specMilestone) throws IOException { + final String fileName = String.format("getAttesterSlashings%s.json", specMilestone.name()); + return Resources.toString( + Resources.getResource(GetAttesterSlashingsV2Test.class, fileName), UTF_8); + } +} diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetBlockAttestationsV2Test.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetBlockAttestationsV2Test.java new file mode 100644 index 00000000000..de47b89c423 --- /dev/null +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetBlockAttestationsV2Test.java @@ -0,0 +1,180 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.beaconrestapi.handlers.v2.beacon; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.AssertionsForClassTypes.fail; +import static org.mockito.Mockito.when; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; +import static tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition.listOf; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; + +import com.fasterxml.jackson.core.JsonProcessingException; +import java.io.IOException; +import java.util.List; +import java.util.Optional; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.api.schema.Version; +import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerTest; +import tech.pegasys.teku.ethereum.json.types.SharedApiTypes; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.json.JsonUtil; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +class GetBlockAttestationsV2Test extends AbstractMigratedBeaconHandlerTest { + + final Spec specMinimalPhase0 = TestSpecFactory.createMinimalPhase0(); + final DataStructureUtil phase0DataStructureUtil = new DataStructureUtil(specMinimalPhase0); + private final List phase0Attestations = + List.of( + phase0DataStructureUtil.randomAttestation(), phase0DataStructureUtil.randomAttestation()); + private final ObjectAndMetaData> phase0responseData = + new ObjectAndMetaData<>( + phase0Attestations, + specMinimalPhase0.getGenesisSpec().getMilestone(), + false, + true, + false); + + final Spec specMinimalElectra = TestSpecFactory.createMinimalElectra(); + final DataStructureUtil electraDataStructureUtil = new DataStructureUtil(specMinimalElectra); + final List electraAttestations = + List.of( + electraDataStructureUtil.randomAttestation(), + electraDataStructureUtil.randomAttestation()); + private final ObjectAndMetaData> electraResponseData = + new ObjectAndMetaData<>( + electraAttestations, + specMinimalElectra.getGenesisSpec().getMilestone(), + false, + true, + false); + + @BeforeEach + void setUp() { + setHandler(new GetBlockAttestationsV2(chainDataProvider, schemaDefinitionCache)); + request.setPathParameter("block_id", "head"); + } + + @Test + public void shouldReturnBlockAttestationsInformationForPhase0() throws JsonProcessingException { + final Optional>> optionalData = + Optional.of(phase0responseData); + when(chainDataProvider.getBlockAttestations("head")) + .thenReturn(SafeFuture.completedFuture(optionalData)); + + handler.handleRequest(request); + + assertThat(request.getResponseCode()).isEqualTo(SC_OK); + assertThat(phase0responseData.getData().size()).isGreaterThan(0); + assertThat(request.getResponseBody()).isEqualTo(optionalData.get()); + assertThat(request.getResponseHeaders(HEADER_CONSENSUS_VERSION)) + .isEqualTo(Version.fromMilestone(phase0responseData.getMilestone()).name()); + } + + @Test + public void shouldReturnBlockAttestationsInformationForElectra() throws JsonProcessingException { + final Optional>> optionalData = + Optional.of(electraResponseData); + when(chainDataProvider.getBlockAttestations("head")) + .thenReturn(SafeFuture.completedFuture(optionalData)); + + handler.handleRequest(request); + + assertThat(request.getResponseCode()).isEqualTo(SC_OK); + assertThat(electraResponseData.getData().size()).isGreaterThan(0); + assertThat(request.getResponseBody()).isEqualTo(optionalData.get()); + assertThat(request.getResponseHeaders(HEADER_CONSENSUS_VERSION)) + .isEqualTo(Version.fromMilestone(electraResponseData.getMilestone()).name()); + } + + @Test + void metadata_shouldHandle400() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_BAD_REQUEST); + } + + @Test + void metadata_shouldHandle500() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_INTERNAL_SERVER_ERROR); + } + + @Test + void metadata_shouldHandle200_phase0Attestations() throws IOException { + setHandler( + new GetBlockAttestationsV2( + chainDataProvider, new SchemaDefinitionCache(specMinimalPhase0))); + final String data = getResponseStringFromMetadata(handler, SC_OK, phase0responseData); + + final AttestationSchema phase0AttestationSchema = + schemaDefinitionCache.getSchemaDefinition(SpecMilestone.PHASE0).getAttestationSchema(); + final List attestations = + parseAttestationsFromResponse(data, phase0AttestationSchema); + + assertThat(attestations).isNotEmpty(); + assertThat(attestations).allMatch(att -> !att.requiresCommitteeBits()); + } + + @Test + void metadata_shouldHandle200_electraAttestations() throws IOException { + setHandler( + new GetBlockAttestationsV2( + chainDataProvider, new SchemaDefinitionCache(specMinimalElectra))); + final String data = getResponseStringFromMetadata(handler, SC_OK, electraResponseData); + + final AttestationSchema electraAttestationSchema = + schemaDefinitionCache.getSchemaDefinition(SpecMilestone.ELECTRA).getAttestationSchema(); + final List attestations = + parseAttestationsFromResponse(data, electraAttestationSchema); + + assertThat(attestations).isNotEmpty(); + assertThat(attestations).allMatch(Attestation::requiresCommitteeBits); + } + + private List parseAttestationsFromResponse( + final String data, final AttestationSchema schema) { + try { + return JsonUtil.parse( + data, + SharedApiTypes.withDataWrapper("Attestations", listOf(schema.getJsonTypeDefinition()))); + } catch (JsonProcessingException e) { + fail("Error parsing response", e); + return List.of(); + } + } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } +} diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetBlockTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetBlockTest.java index a2db7b636d1..b4462825fa8 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetBlockTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/GetBlockTest.java @@ -18,18 +18,21 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; import com.google.common.io.Resources; -import java.io.IOException; import java.util.concurrent.ExecutionException; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerWithChainDataProviderTest; +import tech.pegasys.teku.infrastructure.json.JsonTestUtil; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; @@ -73,14 +76,24 @@ void metadata_shouldHandle500() throws JsonProcessingException { } @Test - @Disabled("TODO: Fix fixtures, random was changed") - void metadata_shouldHandle200() throws IOException { + void metadata_shouldHandle200() throws Exception { final SignedBeaconBlock beaconBlock = dataStructureUtil.randomSignedBeaconBlock(1); final ObjectAndMetaData responseData = withMetaData(beaconBlock); - final String data = getResponseStringFromMetadata(handler, SC_OK, responseData); + final JsonNode responseDataAsJsonNode = JsonTestUtil.parseAsJsonNode(data); final String expected = Resources.toString(Resources.getResource(GetBlockTest.class, "getBlock.json"), UTF_8); - assertThat(data).isEqualTo(expected); + final JsonNode expectedAsJsonNode = JsonTestUtil.parseAsJsonNode(expected); + assertThat(responseDataAsJsonNode).isEqualTo(expectedAsJsonNode); + } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/PostAttestationsV2Test.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/PostAttestationsV2Test.java new file mode 100644 index 00000000000..41e91a3df23 --- /dev/null +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/PostAttestationsV2Test.java @@ -0,0 +1,160 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.beaconrestapi.handlers.v2.beacon; + +import static java.nio.charset.StandardCharsets.UTF_8; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.when; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getRequestBodyFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; +import static tech.pegasys.teku.spec.SpecMilestone.ELECTRA; +import static tech.pegasys.teku.spec.SpecMilestone.PHASE0; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; +import com.google.common.io.Resources; +import java.io.IOException; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import org.assertj.core.api.AssertionsForClassTypes; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerTest; +import tech.pegasys.teku.beaconrestapi.schema.ErrorListBadRequest; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.json.JsonTestUtil; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; +import tech.pegasys.teku.validator.api.SubmitDataError; + +@TestSpecContext(milestone = {PHASE0, ELECTRA}) +public class PostAttestationsV2Test extends AbstractMigratedBeaconHandlerTest { + + private SpecMilestone specMilestone; + + @BeforeEach + void setUp(final TestSpecInvocationContextProvider.SpecContext specContext) { + spec = specContext.getSpec(); + specMilestone = specContext.getSpecMilestone(); + schemaDefinitionCache = new SchemaDefinitionCache(spec); + setHandler(new PostAttestationsV2(validatorDataProvider, schemaDefinitionCache)); + } + + @TestTemplate + void shouldBeAbleToSubmitAttestation() throws Exception { + final List attestations = + List.of(dataStructureUtil.randomAttestation(), dataStructureUtil.randomAttestation()); + request.setRequestBody(attestations); + request.setRequestHeader( + HEADER_CONSENSUS_VERSION, specMilestone.name().toLowerCase(Locale.ROOT)); + when(validatorDataProvider.submitAttestations(attestations)) + .thenReturn(SafeFuture.completedFuture(List.of())); + + handler.handleRequest(request); + + assertThat(request.getResponseCode()).isEqualTo(SC_OK); + assertThat(request.getResponseBody()).isNull(); + } + + @TestTemplate + void shouldReportInvalidAttestations() throws Exception { + final List attestations = + List.of(dataStructureUtil.randomAttestation(), dataStructureUtil.randomAttestation()); + final List errors = + List.of(new SubmitDataError(UInt64.ZERO, "Bad Attestation")); + final ErrorListBadRequest response = + new ErrorListBadRequest( + "Some items failed to publish, refer to errors for details", errors); + + request.setRequestHeader( + HEADER_CONSENSUS_VERSION, specMilestone.name().toLowerCase(Locale.ROOT)); + request.setRequestBody(attestations); + + when(validatorDataProvider.submitAttestations(attestations)) + .thenReturn(SafeFuture.completedFuture(errors)); + + handler.handleRequest(request); + assertThat(request.getResponseCode()).isEqualTo(SC_BAD_REQUEST); + assertThat(request.getResponseBody()).isEqualTo(response); + } + + @TestTemplate + void shouldReadRequestBody() throws IOException { + final String data = getExpectedResponseAsJson(specMilestone); + final Object requestBody = + getRequestBodyFromMetadata( + handler, Map.of(HEADER_CONSENSUS_VERSION, specMilestone.name()), data); + assertThat(requestBody).isInstanceOf(List.class); + assertThat(((List) requestBody).get(0)).isInstanceOf(Attestation.class); + } + + @TestTemplate + void metadata_shouldHandle400() throws Exception { + final List errors = + List.of( + new SubmitDataError(UInt64.ZERO, "Darn"), new SubmitDataError(UInt64.ONE, "Incorrect")); + final ErrorListBadRequest responseData = + new ErrorListBadRequest( + "Some items failed to publish, refer to errors for details", errors); + + final JsonNode data = + JsonTestUtil.parseAsJsonNode( + getResponseStringFromMetadata(handler, SC_BAD_REQUEST, responseData)); + final JsonNode expected = + JsonTestUtil.parseAsJsonNode( + Resources.toString( + Resources.getResource(PostAttestationsV2Test.class, "errorListBadRequest.json"), + UTF_8)); + AssertionsForClassTypes.assertThat(data).isEqualTo(expected); + } + + @TestTemplate + void metadata_shouldHandle500() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_INTERNAL_SERVER_ERROR); + } + + @TestTemplate + void metadata_shouldHandle200() { + verifyMetadataEmptyResponse(handler, SC_OK); + } + + private String getExpectedResponseAsJson(final SpecMilestone specMilestone) throws IOException { + final String fileName = + String.format("postAttestationRequestBody%s.json", specMilestone.name()); + return Resources.toString(Resources.getResource(PostAttestationsV2Test.class, fileName), UTF_8); + } + + @TestTemplate + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @TestTemplate + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } +} diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/PostAttesterSlashingV2Test.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/PostAttesterSlashingV2Test.java new file mode 100644 index 00000000000..026dc84ab40 --- /dev/null +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/PostAttesterSlashingV2Test.java @@ -0,0 +1,115 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.beaconrestapi.handlers.v2.beacon; + +import static java.nio.charset.StandardCharsets.UTF_8; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.when; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getRequestBodyFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; +import static tech.pegasys.teku.spec.SpecMilestone.ELECTRA; +import static tech.pegasys.teku.spec.SpecMilestone.PHASE0; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.google.common.io.Resources; +import java.io.IOException; +import java.util.Map; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerTest; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.http.HttpErrorResponse; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider; +import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; +import tech.pegasys.teku.spec.util.DataStructureUtil; +import tech.pegasys.teku.statetransition.validation.InternalValidationResult; + +@TestSpecContext(milestone = {PHASE0, ELECTRA}) +class PostAttesterSlashingV2Test extends AbstractMigratedBeaconHandlerTest { + + private SpecMilestone specMilestone; + + @BeforeEach + void setup(final TestSpecInvocationContextProvider.SpecContext specContext) { + spec = specContext.getSpec(); + dataStructureUtil = new DataStructureUtil(spec); + specMilestone = specContext.getSpecMilestone(); + setHandler(new PostAttesterSlashingV2(nodeDataProvider, new SchemaDefinitionCache(spec))); + } + + @TestTemplate + void shouldBeAbleToSubmitSlashing() throws Exception { + final AttesterSlashing slashing = dataStructureUtil.randomAttesterSlashing(); + request.setRequestBody(slashing); + + when(nodeDataProvider.postAttesterSlashing(slashing)) + .thenReturn(SafeFuture.completedFuture(InternalValidationResult.ACCEPT)); + + handler.handleRequest(request); + + assertThat(request.getResponseCode()).isEqualTo(SC_OK); + assertThat(request.getResponseBody()).isNull(); + } + + @TestTemplate + void shouldReturnBadRequestIfAttesterSlashingIsInvalid() throws Exception { + final AttesterSlashing slashing = dataStructureUtil.randomAttesterSlashing(); + request.setRequestBody(slashing); + + when(nodeDataProvider.postAttesterSlashing(slashing)) + .thenReturn(SafeFuture.completedFuture(InternalValidationResult.reject("Nope"))); + + handler.handleRequest(request); + + final HttpErrorResponse expectedBody = new HttpErrorResponse(SC_BAD_REQUEST, "Nope"); + assertThat(request.getResponseCode()).isEqualTo(SC_BAD_REQUEST); + assertThat(request.getResponseBody()).isEqualTo(expectedBody); + } + + @TestTemplate + void shouldReadRequestBody() throws IOException { + final String data = + Resources.toString( + Resources.getResource( + PostAttesterSlashingV2Test.class, "postAttesterSlashingRequestBody.json"), + UTF_8); + assertThat( + getRequestBodyFromMetadata( + handler, Map.of(HEADER_CONSENSUS_VERSION, specMilestone.name()), data)) + .isInstanceOf(AttesterSlashing.class); + } + + @TestTemplate + void metadata_shouldHandle400() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_BAD_REQUEST); + } + + @TestTemplate + void metadata_shouldHandle500() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_INTERNAL_SERVER_ERROR); + } + + @TestTemplate + void metadata_shouldHandle200() throws IOException { + verifyMetadataEmptyResponse(handler, SC_OK); + } +} diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/debug/GetChainHeadsV2Test.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/debug/GetChainHeadsV2Test.java index cfddcf2dda2..e0162f148b3 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/debug/GetChainHeadsV2Test.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/debug/GetChainHeadsV2Test.java @@ -16,8 +16,11 @@ import static org.assertj.core.api.Assertions.assertThat; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import com.fasterxml.jackson.core.JsonProcessingException; @@ -66,4 +69,14 @@ void shouldGetSuccessfulResponse() throws JsonProcessingException { assertThat(request.getResponseCode()).isEqualTo(SC_OK); assertThat(request.getResponseBody()).isEqualTo(protoNodeDataList); } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/debug/GetStateTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/debug/GetStateTest.java index d4c0af892b8..d6a425bb3d7 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/debug/GetStateTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/debug/GetStateTest.java @@ -18,18 +18,22 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import static tech.pegasys.teku.spec.SpecMilestone.PHASE0; import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; import com.google.common.io.Resources; -import java.io.IOException; import java.util.concurrent.ExecutionException; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerWithChainDataProviderTest; +import tech.pegasys.teku.infrastructure.json.JsonTestUtil; import tech.pegasys.teku.spec.datastructures.metadata.StateAndMetaData; class GetStateTest extends AbstractMigratedBeaconHandlerWithChainDataProviderTest { @@ -71,7 +75,7 @@ void metadata_shouldHandle500() throws JsonProcessingException { } @Test - void metadata_shouldHandle200() throws IOException { + void metadata_shouldHandle200() throws Exception { final StateAndMetaData responseData = new StateAndMetaData( dataStructureUtil.randomBeaconState(), @@ -81,8 +85,20 @@ void metadata_shouldHandle200() throws IOException { false); final String data = getResponseStringFromMetadata(handler, SC_OK, responseData); + final JsonNode responseDataAsJsonNode = JsonTestUtil.parseAsJsonNode(data); final String expected = Resources.toString(Resources.getResource(GetStateTest.class, "getState.json"), UTF_8); - assertThat(data).isEqualTo(String.format(expected, responseData.getData().getGenesisTime())); + final JsonNode expectedAsJsonNode = JsonTestUtil.parseAsJsonNode(expected); + assertThat(responseDataAsJsonNode).isEqualTo(expectedAsJsonNode); + } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/validator/GetAggregateAttestationV2Test.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/validator/GetAggregateAttestationV2Test.java new file mode 100644 index 00000000000..910c9363470 --- /dev/null +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/validator/GetAggregateAttestationV2Test.java @@ -0,0 +1,168 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.beaconrestapi.handlers.v2.validator; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.when; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; + +import com.fasterxml.jackson.core.JsonProcessingException; +import java.io.IOException; +import java.util.Optional; +import org.apache.tuweni.bytes.Bytes32; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.api.schema.Version; +import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerTest; +import tech.pegasys.teku.ethereum.json.types.SharedApiTypes; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.http.RestApiConstants; +import tech.pegasys.teku.infrastructure.json.JsonUtil; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +public class GetAggregateAttestationV2Test extends AbstractMigratedBeaconHandlerTest { + + final Spec specMinimalPhase0 = TestSpecFactory.createMinimalPhase0(); + final DataStructureUtil phase0DataStructureUtil = new DataStructureUtil(specMinimalPhase0); + private final Attestation phase0Attestation = phase0DataStructureUtil.randomAttestation(); + private final ObjectAndMetaData phase0responseData = + new ObjectAndMetaData<>( + phase0Attestation, + specMinimalPhase0.getGenesisSpec().getMilestone(), + false, + false, + false); + + final Spec specMinimalElectra = TestSpecFactory.createMinimalElectra(); + final DataStructureUtil electraDataStructureUtil = new DataStructureUtil(specMinimalElectra); + final Attestation electraAttestation = electraDataStructureUtil.randomAttestation(); + private final ObjectAndMetaData electraResponseData = + new ObjectAndMetaData<>( + electraAttestation, + specMinimalElectra.getGenesisSpec().getMilestone(), + false, + true, + false); + private final Bytes32 blockRoot = phase0DataStructureUtil.randomBytes32(); + private final UInt64 slot = phase0DataStructureUtil.randomSlot(); + private final UInt64 committeeIndex = phase0DataStructureUtil.randomUInt64(); + + @BeforeEach + void setUp() { + setHandler(new GetAggregateAttestationV2(validatorDataProvider, schemaDefinitionCache)); + request.setQueryParameter(RestApiConstants.ATTESTATION_DATA_ROOT, blockRoot.toHexString()); + request.setQueryParameter(RestApiConstants.SLOT, slot.toString()); + request.setQueryParameter(RestApiConstants.COMMITTEE_INDEX, committeeIndex.toString()); + } + + @Test + public void shouldReturnAggregateAttestationForPhase0() throws JsonProcessingException { + final Optional> optionalData = Optional.of(phase0responseData); + when(validatorDataProvider.createAggregateAndMetaData(slot, blockRoot, committeeIndex)) + .thenReturn(SafeFuture.completedFuture(optionalData)); + + handler.handleRequest(request); + + assertThat(request.getResponseCode()).isEqualTo(SC_OK); + assertThat(phase0responseData.getData().size()).isGreaterThan(0); + assertThat(request.getResponseBody()).isEqualTo(optionalData.get()); + assertThat(request.getResponseHeaders(HEADER_CONSENSUS_VERSION)) + .isEqualTo(Version.fromMilestone(phase0responseData.getMilestone()).name()); + } + + @Test + public void shouldReturnAggregateAttestationForElectra() throws JsonProcessingException { + final Optional> optionalData = Optional.of(electraResponseData); + when(validatorDataProvider.createAggregateAndMetaData(slot, blockRoot, committeeIndex)) + .thenReturn(SafeFuture.completedFuture(optionalData)); + + handler.handleRequest(request); + + assertThat(request.getResponseCode()).isEqualTo(SC_OK); + assertThat(electraResponseData.getData().size()).isGreaterThan(0); + assertThat(request.getResponseBody()).isEqualTo(optionalData.get()); + assertThat(request.getResponseHeaders(HEADER_CONSENSUS_VERSION)) + .isEqualTo(Version.fromMilestone(electraResponseData.getMilestone()).name()); + } + + @Test + void metadata_shouldHandle400() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_BAD_REQUEST); + } + + @Test + void metadata_shouldHandle500() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_INTERNAL_SERVER_ERROR); + } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } + + @Test + void metadata_shouldHandle200_phase0Attestation() throws IOException { + setHandler( + new GetAggregateAttestationV2( + validatorDataProvider, new SchemaDefinitionCache(specMinimalPhase0))); + final String data = getResponseStringFromMetadata(handler, SC_OK, phase0responseData); + + final AttestationSchema phase0AttestationSchema = + schemaDefinitionCache.getSchemaDefinition(SpecMilestone.PHASE0).getAttestationSchema(); + final Attestation attestation = parseAttestationFromResponse(data, phase0AttestationSchema); + + assertThat(attestation.requiresCommitteeBits()).isFalse(); + } + + @Test + void metadata_shouldHandle200_electraAttestation() throws IOException { + setHandler( + new GetAggregateAttestationV2( + validatorDataProvider, new SchemaDefinitionCache(specMinimalElectra))); + final String data = getResponseStringFromMetadata(handler, SC_OK, electraResponseData); + + final AttestationSchema electraAttestationSchema = + schemaDefinitionCache.getSchemaDefinition(SpecMilestone.ELECTRA).getAttestationSchema(); + final Attestation attestation = parseAttestationFromResponse(data, electraAttestationSchema); + + assertThat(attestation.requiresCommitteeBits()).isTrue(); + } + + private T parseAttestationFromResponse( + final String data, final AttestationSchema schema) throws JsonProcessingException { + return JsonUtil.parse( + data, SharedApiTypes.withDataWrapper("Attestation", schema.getJsonTypeDefinition())); + } +} diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/validator/PostAggregateAndProofsV2Test.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/validator/PostAggregateAndProofsV2Test.java new file mode 100644 index 00000000000..f2274bf4c1b --- /dev/null +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/validator/PostAggregateAndProofsV2Test.java @@ -0,0 +1,155 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.beaconrestapi.handlers.v2.validator; + +import static java.nio.charset.StandardCharsets.UTF_8; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.anyList; +import static org.mockito.Mockito.when; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getRequestBodyFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; +import static tech.pegasys.teku.spec.SpecMilestone.ELECTRA; +import static tech.pegasys.teku.spec.SpecMilestone.PHASE0; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.google.common.io.Resources; +import java.io.IOException; +import java.util.List; +import java.util.Map; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.beaconrestapi.AbstractMigratedBeaconHandlerTest; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.http.HttpErrorResponse; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider; +import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof; +import tech.pegasys.teku.spec.datastructures.operations.versions.electra.AttestationElectra; +import tech.pegasys.teku.spec.datastructures.operations.versions.phase0.AttestationPhase0; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; +import tech.pegasys.teku.spec.util.DataStructureUtil; +import tech.pegasys.teku.validator.api.SubmitDataError; + +@TestSpecContext(milestone = {PHASE0, ELECTRA}) +public class PostAggregateAndProofsV2Test extends AbstractMigratedBeaconHandlerTest { + + private SpecMilestone specMilestone; + + @BeforeEach + public void beforeEach(final TestSpecInvocationContextProvider.SpecContext specContext) { + spec = specContext.getSpec(); + dataStructureUtil = new DataStructureUtil(spec); + specMilestone = specContext.getSpecMilestone(); + setHandler( + new PostAggregateAndProofsV2(validatorDataProvider, new SchemaDefinitionCache(spec))); + } + + @TestTemplate + public void shouldReturnSuccessWhenSendAggregateAndProofSucceeds() throws Exception { + final SignedAggregateAndProof signedAggregateAndProof = + dataStructureUtil.randomSignedAggregateAndProof(); + request.setRequestBody(List.of(signedAggregateAndProof)); + + when(validatorDataProvider.sendAggregateAndProofs(anyList())) + .thenReturn(SafeFuture.completedFuture(List.of())); + + handler.handleRequest(request); + + assertThat(request.getResponseCode()).isEqualTo(SC_OK); + assertThat(request.getResponseBody()).isNull(); + } + + @TestTemplate + public void shouldReturnBadRequestWhenErrorsReturned() throws Exception { + final SignedAggregateAndProof signedAggregateAndProof = + dataStructureUtil.randomSignedAggregateAndProof(); + request.setRequestBody(List.of(signedAggregateAndProof)); + + final List errors = List.of(new SubmitDataError(UInt64.ZERO, "Failed")); + when(validatorDataProvider.sendAggregateAndProofs(anyList())) + .thenReturn(SafeFuture.completedFuture(errors)); + + handler.handleRequest(request); + + final HttpErrorResponse expected = + new HttpErrorResponse( + SC_BAD_REQUEST, "Some items failed to publish, refer to errors for details"); + assertThat(request.getResponseCode()).isEqualTo(SC_BAD_REQUEST); + assertThat(request.getResponseBody()).isEqualTo(expected); + } + + @TestTemplate + void shouldReadRequestBody() throws IOException { + final String data = getExpectedResponseAsJson(specMilestone); + final Object requestBody = + getRequestBodyFromMetadata( + handler, Map.of(HEADER_CONSENSUS_VERSION, specMilestone.name()), data); + assertThat(requestBody).isInstanceOf(List.class); + assertThat(((List) requestBody).get(0)).isInstanceOf(SignedAggregateAndProof.class); + if (specMilestone.isGreaterThanOrEqualTo(ELECTRA)) { + assertThat( + ((SignedAggregateAndProof) ((List) requestBody).get(0)) + .getMessage() + .getAggregate()) + .isInstanceOf(AttestationElectra.class); + } else { + assertThat( + ((SignedAggregateAndProof) ((List) requestBody).get(0)) + .getMessage() + .getAggregate()) + .isInstanceOf(AttestationPhase0.class); + } + } + + @TestTemplate + void metadata_shouldHandle400() throws IOException { + verifyMetadataErrorResponse(handler, SC_BAD_REQUEST); + } + + @TestTemplate + void metadata_shouldHandle500() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_INTERNAL_SERVER_ERROR); + } + + @TestTemplate + void metadata_shouldHandle200() { + verifyMetadataEmptyResponse(handler, SC_OK); + } + + private String getExpectedResponseAsJson(final SpecMilestone specMilestone) throws IOException { + final String fileName = + String.format("postAggregateAndProofsRequestBody%s.json", specMilestone.name()); + return Resources.toString( + Resources.getResource(PostAggregateAndProofsV2Test.class, fileName), UTF_8); + } + + @TestTemplate + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @TestTemplate + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } +} diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v3/validator/GetNewBlockV3Test.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v3/validator/GetNewBlockV3Test.java index 1e422952048..250ce9b96d9 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v3/validator/GetNewBlockV3Test.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v3/validator/GetNewBlockV3Test.java @@ -18,16 +18,21 @@ import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_BLOCK_VALUE; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_EXECUTION_PAYLOAD_BLINDED; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_EXECUTION_PAYLOAD_VALUE; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.RANDAO_REVEAL; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.SLOT; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ONE; import static tech.pegasys.teku.spec.SpecMilestone.BELLATRIX; import static tech.pegasys.teku.spec.SpecMilestone.DENEB; +import com.fasterxml.jackson.core.JsonProcessingException; import java.util.Optional; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.TestTemplate; @@ -142,4 +147,14 @@ void shouldThrowExceptionWhenEmptyBlock() throws Exception { assertThat(request.getResponseCode()).isEqualTo(SC_INTERNAL_SERVER_ERROR); assertThat(request.getResponseBody().toString()).contains("Unable to produce a block"); } + + @TestTemplate + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @TestTemplate + void metadata_shouldHandle503() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_SERVICE_UNAVAILABLE); + } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/schema/MilestoneDependentTypesUtilTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/schema/MilestoneDependentTypesUtilTest.java new file mode 100644 index 00000000000..3441c7894bf --- /dev/null +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/schema/MilestoneDependentTypesUtilTest.java @@ -0,0 +1,84 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.beaconrestapi.schema; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; + +import java.util.Collections; +import java.util.Map; +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import tech.pegasys.teku.api.exceptions.BadRequestException; +import tech.pegasys.teku.beaconrestapi.handlers.v1.beacon.MilestoneDependentTypesUtil; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; +import tech.pegasys.teku.spec.schemas.SchemaDefinitions; + +public class MilestoneDependentTypesUtilTest { + private final Spec spec = TestSpecFactory.createMinimalElectra(); + private final SchemaDefinitionCache cache = new SchemaDefinitionCache(spec); + + @ParameterizedTest(name = "{0}") + @MethodSource("milestones") + void headerSelector_UsesConsensusVersionPhase0(final SpecMilestone targetMilestone) { + final DeserializableTypeDefinition typeDefinition = + MilestoneDependentTypesUtil.headerBasedSelector( + Map.of(HEADER_CONSENSUS_VERSION, targetMilestone.toString()), + cache, + SchemaDefinitions::getAttestationSchema); + assertThat(typeDefinition.getTypeName()) + .contains( + spec.forMilestone(targetMilestone) + .getSchemaDefinitions() + .getAttestationSchema() + .getContainerName()); + } + + @Test + void headerSelector_errorsWhenInvalid() { + assertThatThrownBy( + () -> + MilestoneDependentTypesUtil.headerBasedSelector( + Map.of(HEADER_CONSENSUS_VERSION, "invalid"), + cache, + SchemaDefinitions::getAttestationSchema)) + .isInstanceOf(BadRequestException.class) + .hasMessageContaining("Invalid value for (Eth-Consensus-Version) header: invalid"); + } + + @Test + void headerSelector_errorsWhenMissing() { + assertThatThrownBy( + () -> + MilestoneDependentTypesUtil.headerBasedSelector( + Collections.emptyMap(), cache, SchemaDefinitions::getAttestationSchema)) + .isInstanceOf(BadRequestException.class) + .hasMessageContaining("Missing required header value for (Eth-Consensus-Version)"); + } + + private static Stream milestones() { + return Stream.of( + Arguments.of(SpecMilestone.PHASE0), + Arguments.of(SpecMilestone.DENEB), + Arguments.of(SpecMilestone.ELECTRA)); + } +} diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/schema/OneOfTest.java b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/schema/OneOfTest.java index af048bfc4d9..efa1d5ae1b6 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/schema/OneOfTest.java +++ b/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/schema/OneOfTest.java @@ -24,6 +24,7 @@ import tech.pegasys.teku.infrastructure.json.JsonUtil; import tech.pegasys.teku.infrastructure.json.types.SerializableOneOfTypeDefinition; import tech.pegasys.teku.infrastructure.json.types.SerializableOneOfTypeDefinitionBuilder; +import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.TestSpecFactory; @@ -41,6 +42,11 @@ public class OneOfTest { private final Predicate isBellatrix = block -> spec.atSlot(block.getSlot()).getMilestone().equals(SpecMilestone.BELLATRIX); + private final SerializableTypeDefinition type1 = + SerializableTypeDefinition.object(String.class).name("Type1").build(); + private final SerializableTypeDefinition type2 = + SerializableTypeDefinition.object(String.class).name("Type2").build(); + @SuppressWarnings("unchecked") @Test void shouldCreateOneOfBlockDefinition() throws Exception { @@ -68,7 +74,7 @@ void shouldCreateOneOfBlockDefinition() throws Exception { .build(); final String openApiType = JsonUtil.serialize(schema::serializeOpenApiType); - Map parsed = JsonTestUtil.parse(openApiType); + final Map parsed = JsonTestUtil.parse(openApiType); List> oneOfList = (List>) parsed.get("oneOf"); assertThat(oneOfList.stream().flatMap(z -> z.values().stream()).collect(Collectors.toList())) @@ -78,6 +84,25 @@ void shouldCreateOneOfBlockDefinition() throws Exception { "#/components/schemas/BeaconBlockBellatrix"); } + @SuppressWarnings("unchecked") + @Test + void shouldDeDuplicateList() throws Exception { + + final SerializableOneOfTypeDefinition schema = + new SerializableOneOfTypeDefinitionBuilder() + .title("TYPES") + .withType(String::isEmpty, type1) + .withType(String::isEmpty, type1) + .withType(String::isEmpty, type2) + .build(); + + final String openApiType = JsonUtil.serialize(schema::serializeOpenApiType); + final Map parsed = JsonTestUtil.parse(openApiType); + final List> oneOfList = (List>) parsed.get("oneOf"); + assertThat(oneOfList.stream().flatMap(z -> z.values().stream()).collect(Collectors.toList())) + .containsExactly("#/components/schemas/Type1", "#/components/schemas/Type2"); + } + @SuppressWarnings("unchecked") @Test void shouldCreateOneOfBlindedBlockDefinition() throws Exception { @@ -112,6 +137,6 @@ void shouldCreateOneOfBlindedBlockDefinition() throws Exception { .containsOnly( "#/components/schemas/BeaconBlockPhase0", "#/components/schemas/BeaconBlockAltair", - "#/components/schemas/BlindedBlockBellatrix"); + "#/components/schemas/BlindedBeaconBlockBellatrix"); } } diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/getAllBlobSidecarsAtSlot.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/getAllBlobSidecarsAtSlot.json index 7f7f63bcbc0..45197ecd990 100644 --- a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/getAllBlobSidecarsAtSlot.json +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/getAllBlobSidecarsAtSlot.json @@ -1 +1,67 @@ -{"data":[{"index":"2","blob":"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","kzg_commitment":"0x103ac9406cdc59b89027eb1c9e97f607dd5fdccfa8fb2da4eaeea9d25032add96bfd4710d1f100f267608c6b69cd4448","kzg_proof":"0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f619b26eab6d66297cbd9dbc84db437c8","signed_block_header":{"message":{"slot":"4658411424342975020","proposer_index":"4663368873993027404","parent_root":"0x5cbeb140ec0ad7cb653388caecba483cf66bd817821ed18ca1f3b7f3b9b58a04","state_root":"0x1f86d83f0bf91cc0d7e07410828140e0dddbb331dc20b6743f9f79e549b50b11","body_root":"0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b"},"signature":"0x992e2695a49aaedcb373280f375a08adaafafff0bab131d48674136f5e452c8bb0797618eeb99bc3a4835bca2bd6aec6067807e927604548997a795d7ba982a5274f0d1d55624a8c7b66973c6e717f3c46bd2d92bc1696d3173751a6b0bf6a63"},"kzg_commitment_inclusion_proof":["0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486","0x6b0ac13f8a279ad3abec11bed1a49214f6e7af79b643595df6a38706b338e93b","0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6","0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26","0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1","0xb88ea93f0a5617e780f8ae6b1fc8e4480ff4abc18f66fc45ada895271cbcc666","0xcbafa33faaa1f62b763b1697f350f91515f7aa53462f2500db29d9eff71c7ef1","0x924cb53fcabe585d9672e01478b6bbae02eead9d22d5aad151a60e9768fa5751","0xa56daf3f6a0a38a28bb547404c3fd07b08f1ac2fd99dd38b7f27525f425b0fdc"]},{"index":"5","blob":"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","kzg_commitment":"0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec0636688650b0a49443de4e2d69df618914","kzg_proof":"0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a795653913a151466aea2c5bbf193edd4f03c8","signed_block_header":{"message":{"slot":"4625361742829423275","proposer_index":"4630319196774442955","parent_root":"0xda533c406bf3482d8e6e992e756be34172a8c47fc1cc0018350bfe98c946deda","state_root":"0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390","body_root":"0x4d1a19402bb984ca4d0005336ba05e1098babeeb0781f5744712934ae78b2a1b"},"signature":"0xadd071eb32731713b9040770807acb7033344aafc6df54ebf8a790187ddc947e2bb06a9547eb7c3876533720f36e54761018488a3857bb1d87175f7905620088fd81593465b7139e794f75bba0daaef713a9b7bec99656073c1396866d35f9b0"},"kzg_commitment_inclusion_proof":["0x27d82440eb21c640637a36dcc38e35768bb4c0c79aefa300ec0f0cba32cabb05","0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb","0x999e0140abe701de220ca2e0b9c3b044b1c6ba33e0a3985dfe16a16b510f0846","0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5","0x735c0d406b5043543786d38912b287aaa4c0bc0f731247e9a3141adb9c4d9930","0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6","0xe622ea3f2b167ff1f7173f8e08e70279cad2b67bb9c63b46b51baf8cba92e570","0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0","0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b"]},{"index":"4","blob":"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","kzg_commitment":"0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd0ee000b841381cd96f346bde6ffd5414","kzg_proof":"0xcf2c053f899b836f534bfa2a45bf23b7be4890b9815a72a2aec9f70eff53d592047edf91261d7e7ed3adba3b53e44794","signed_block_header":{"message":{"slot":"4539432581202110249","proposer_index":"4544390030852162633","parent_root":"0xbb0b0b3fe94fa42a5e0893ff71360feab7459127ca9149e88148b44625f31d08","state_root":"0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd","body_root":"0x2ed2e73ea915e0c71d9afe03676b8ab8dd578b9311463e45934f49f843386a48"},"signature":"0x958ab38cce5390fd750e87806f32ed8993a175bc3ccdab7ce2a40c23ac6117b603d5ae98d44a9780cca1f32d28bf5176058ef667b17fd95f13e047cd9cdebbf19f5270ec5a154e2ce2283da513c9ad05c26f10b0a65755eab4b1ed6f42175027"},"kzg_commitment_inclusion_proof":["0x0890f33e697e213e331430adc059611ed0518d6fa4b4ecd0384dc2678e76fb32","0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8","0x7a56d03e29445ddbf2a59bb1b68edcecf66387dbea68e12d4a545719acbb4773","0x41f3e13e4961bf0c12dd652f3bf49e85e35a8a25c70e67ffc1d08cc01d9921d3","0x5414dc3ee9ac9e510720cd5a0e7db352e95d89b77dd78fb9ef51d088f8f9d85d","0x51977a3f0ab3110e2a10e9c6bd0e89b1410ca45142ac42171bb2b169efc281bc","0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947","0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7","0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31"]},{"index":"5","blob":"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","kzg_commitment":"0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75cf364b74684ac97b2181146cb19a0a747","kzg_proof":"0xe99f4b3f0a100c35d42723225a552d1a73249ce1f5f188e889bbcdabc2c93c12e90296206891f9577c8a9528fd869ac7","signed_block_header":{"message":{"slot":"4559262388392254378","proposer_index":"4564219838042306762","parent_root":"0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587","state_root":"0x3624343f893e8948a933c0cfa8787f4e8c309829ce142cd140c0dbcc2c4d1a3d","body_root":"0x49452e3f298a688d9e7627fb7c01941b923397bb84dd548b6e411f9506aed1c7"},"signature":"0x9365d2047fca642d170e3d136ee04996d1252624a0b48001798084ef880eb9da787a612ad95c049b05589b14f107a3590a0cc299017da35a5219bc59c88fd015896e2a096f60e6a42da7b8437706064ea9faff9171b11dbb10c860beadc3521a"},"kzg_commitment_inclusion_proof":["0x23033a3fe9f2a903b4f058a4d4ef6a81852d9997184c0317133f980452ec62b2","0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be","0xf8eb5a3ea82ccf3c1be1ac153e3f77f273a07343291711b9de6b9dbebc4c9b49","0xbf886c3ec849316e3b187793c3a4398b6097768d06bd968a54e8d2652d2a75a9","0xd2a9663e689510b3305bdebe972d4e58669a751fbc85bf448269162e078b2c34","0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9","0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874","0x0c0d553e4878ae811024144112c88bbf79a372d5dfdf39730cede08696ad52d4","0x1f2e4f3ee8c38dc605677b6ce650a08c7fa6716795a8622d396e244f710e0a5f"]}]} \ No newline at end of file +{ + "data" : [ { + "index" : "2", + "blob" : "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", + "kzg_commitment" : "0x103ac9406cdc59b89027eb1c9e97f607dd5fdccfa8fb2da4eaeea9d25032add96bfd4710d1f100f267608c6b69cd4448", + "kzg_proof" : "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f619b26eab6d66297cbd9dbc84db437c8", + "signed_block_header" : { + "message" : { + "slot" : "4658411424342975020", + "proposer_index" : "4663368873993027404", + "parent_root" : "0x5cbeb140ec0ad7cb653388caecba483cf66bd817821ed18ca1f3b7f3b9b58a04", + "state_root" : "0x1f86d83f0bf91cc0d7e07410828140e0dddbb331dc20b6743f9f79e549b50b11", + "body_root" : "0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b" + }, + "signature" : "0x992e2695a49aaedcb373280f375a08adaafafff0bab131d48674136f5e452c8bb0797618eeb99bc3a4835bca2bd6aec6067807e927604548997a795d7ba982a5274f0d1d55624a8c7b66973c6e717f3c46bd2d92bc1696d3173751a6b0bf6a63" + }, + "kzg_commitment_inclusion_proof" : [ "0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486", "0x6b0ac13f8a279ad3abec11bed1a49214f6e7af79b643595df6a38706b338e93b", "0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6", "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", "0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1", "0xb88ea93f0a5617e780f8ae6b1fc8e4480ff4abc18f66fc45ada895271cbcc666", "0xcbafa33faaa1f62b763b1697f350f91515f7aa53462f2500db29d9eff71c7ef1", "0x924cb53fcabe585d9672e01478b6bbae02eead9d22d5aad151a60e9768fa5751", "0xa56daf3f6a0a38a28bb547404c3fd07b08f1ac2fd99dd38b7f27525f425b0fdc" ] + }, { + "index" : "5", + "blob" : "0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c9f48c0f1b643b4559736eabc189a252e040935cd157474a4552125f936ea47427d430bcf3009ecb1a03a63e202544e17f53610c4e925f094bc0a269f008850ca78e2901186e7b8b0d3142e301bb53ef0d240947a7f2272333db5314991431f06751a0b5199985a3402202d612ecb785b9f91108833fc57e09c43d591bcb8a872bccc64b0df5477fb00940f26b956fae90863fd0634993635df01ed444a2d59ad786f1dede191ed0d29a2c68970edb45eda6d210c055a7952d2c9fee6785bdcf13a46491bbe10af11d7a1d13fb8ecf77a882a8d6dff8f4fca8377cc52770c242c772a30afa73c7fe1ee4c33fa2c3c36b2a7a18d48ce436206c66d1056eb82b73905e4ccd361d9ae60510c220d1ce0d1c672ccf8b7f04b0c7bb12a96a26db5958ca211aff3c6012f106a54c596095cd71c468575363ab30ed821ec201d095934a16da101c84476955aa61192192be5d2822708a13a526ffbab3464d28fc1bb65a06bd9b7375c3bece5f72418f8eb64294c3a0334b53567d09ccd7d030a086f2f1503f022cf2488667b50f05289694b9fdb4937893bb3c97c6d1431c1c347c2dbd58234729ec604553e2df3ce8cf731f72742a827d3eeb34a85f3675f2f5b0dd01e98c7dfdbff58f3fc0877369e9b4dd257b85d3285df2767939af2d3ff15cbf164dae38bbca00ae95ee54b17e891b13c4d60b3df1ad1520236fb8bcb4eb983a4943eb6489511ac9796c794f3bdc7618fdc96395aa6e423c2414eeeaab97f87aa49a1c6d87ac95a900338a4eff560359275d625adc58b3281638ff7ed401679720b44f06147d78dcae5c5e8aed23289073943539edf0ef5935bfbdd96f11ca89bc04bea16215c3476da80e9310e47c20bd023d397f409470eff97749fe4a73bbb5b3d60595c0f24835c7d52c71e60a0f2dd600d0300eb3fc380a97f9eecbf2cac3a879ad6d9b7d737ec5511621f6d608c900971b7507859f9403d19135ee110f4d0f9b660cfb57d71d2a681e6dc16affca5cfb45eb148e60c88a12508bb7eb406fd47718640775667ad90a9406a356b8d3a88a7f0b346d87a1de9d701af798572d7897b2b4a06630b16398655455a3827d4b090a8f531d70da26c4667b4adcd3fe2bb66a3ca796362b64a68218746e1596ce32016bb1ea727f1440fdaf065bd0c3e3e1b11de7f256d1a716095d1708a1ead64f22bd6f4de6092d20c2e52e245b0f155e10c1dda227d5eddbb05ae83b4bd2f9a996d62eeeef871391af3b9d9c36d60a9f9d289de6f0e9fc5903bd7de0e83508d459f851d77d0abdee7c211f27903c2c6c57c9ef6f980b7e15a7b7a121a29156df0980de4ede731eedfc4764adb1dcf9c8006fd20164b6eefa712d3689a26b70c201f767a969c7cd81a1a47f2a5f9dbfe8623d86c5f7fa630d43ea459da479e5f36e39b6bc71d40cf6323c06dcd3e4a2630234a80e5bf8fe8d67efd14bd3dfb00520d241781d457494dd30836355e922f36687517abf816e11ea265fba00cbdafbef1693254b7b582557ef7383bfc239aae34787d747b0be87e26012612854fccf5d3964398c428fa1adb9e54123204ca92ccf315e656854f2ab788de4c306cdf2ed96125f21c3bf3a024b2dfecaf5f87d83025d4f2021b6ac1deec23905a4a11808cd8882a783df4a3901c21f7093e7f1af553c39abc5d126e3e54274025a6b08e967a7054eed249fe8bbcd721ba22c0d0f1a980f92ae52510dcb9d1d8ca69afcf8ae5b5434ff5801c6f0fb1bca0af4019d55cbda427ec037a59d13bb07e3f2358ec4782538277ed819cbed5e00d4c5510d470c05ac42113bd26ff358992f5c73dccd4d77ca880275d3b6b5aab9d6a3db9fe41e200e8da3c860123bff5cb697987a37b07bdfa57892c00cace4771479876f86f10f21c426c8a53ab928913a4bbad4a3a3acc9e1eb272b51cb1ca8edfe91217be4d9d6a7c150342e898dce7e333ab3079ec23ecc1057b765bf7db717118592af82e7454fbab3a80dd705d3ea72b9d33046c55db852a2eceeb8a31170ef23c6ef25c29585d272937e2ebf3bb1c11f4bc5c5eb099048bf62b98c6d90ca1a8936949163f854f8720943692736f06f83303543a397b65d8b46096fc55515d4c5cbb9cace507dc4b89d0561dde77cd16459316cbefc4da83c415d0ef840bac5798189e052ac172faaec43bfd75406a44548314b065092b4510704c595d659126b4fc731a7446c29b9c57e9d3a03cd08143f17bdea411289736518e677813fb787fce9d7955e2283c095ea3f6994dbf6faaae4d1c668c7a3abee8f6396c5393f2b57bbdc2a7701e6f54bae1f2f43b38d4663c6e8597fd16b05a87c063f66a829b17cd682dfb2f79c892cfa404f0ee541bbd77770a33a805c040e6f16ff6f1ff6011f56a0355e2d860aa991b9f964bf0d1089b79ee646ce4f68a54be593871b491f51aad213ed7d4557ffca4e9b3e55c28fd734c4802d4ae20ae7c23110f20b362c4e4527821b9c248301c163e95ec647775f18b844fc7e5d2fdb339fdbeca426b8441768ffa370ddd62d0d7ac9cfdf0b7d56adde216a425e340069874b82bc4292bf653ff53eb1a3ea084dd76a3c6fe08fb42a5f60eb196ee556f6144a241c37b15afa8f69505b799c117b0922ca2032abcc8e626912769d2e7f40c2c346ca825109874b5a4b2c69d6c8cc72b67977204fa76a22fa04dbb323292be63e1598d50f0bc5912cf3bd701a09c361f0168e02140f6a8a13e5addf6d527131053107108bcb44ff70c4bbafe4f823b81c9952b2ef581835e151ee4c8bde195cfb29965bd625975e18de7f6d01287a118238a217e1b93c41f6aaae09812c5b132c52059c2058e5f6197054f38dd2cffdf46495586a1f2cdef6570e0194058d63ed485cbd1d055629fb3c3fafdce01c583565b3f614295dbaeab920e410997b2ea69b6188662bdf7d22faf83660f71c1e83ed5494cf6e2ec8f3e63eccdaca4dda3da51ffdfc45896c9eaa95bc1b92236a46aab1e2bf34bf89ab8479cbb19ee00cb9f64b2c2f557ff65734b64e0d9bcdb8344b869033d4daf2bd17da7cd33ae9b3582441477ff734a1c77d79c97781739018a20437ec646fb71337a7c0d2806c4ab94d7af2aa136bc788023163fb83583d36dffa16a21c545f0a4db2044d11bde69fecfa46b875ec19605061d360196d35e8a848a3abf2091ff7b2c37812cf01d9f95a602ad146240a8c628455d3eabe23ea4ed2583c194604b66ec8598dddfccf2495efdcab952d0737c589f9829919cc13c0696805a2f71527f9ca2a0c3ffb7fb5e5afe7ddea24ad2d6abef52a84dd66af416218fbd3d4fe9b6c740749dc7e0c676d1d2e659909b31cb1b29f63731226ebd6e46b29f15e6b78741ea33bebc85556ca7200a7b35ab123367cd776a28423adeef660f485e42b7fd1493c1d10edd1bfeb7d951a182b78cba5b11c97210ffebc34af071303be1ba0cde9044b158678248dc9c0665a27dc71edece65c1603cd4a4d064c435fa10e33687faa747f794651035d3db4f8a1f81bc4b5fc9b0bbf7fcf2072d9c58271a2983a55a1a86a89496dd83df6225bac88c6e0f72f64138849d9e6cdbaf0d2822d8c3eceb9068648659e59ce495bb6bb34dbc83d4f0e876b9a628066e561ec0fa102d764c3f0aa2f9e7c43b7f4e63b5553f587ce94269d3fe3a85bd241119225c453bd3b124ca7a92ed0bc54ed0e0602c6eee104077c245132fce9cb600526d59bde9262d7c7f5ded0a97be4f3cf478cffd428352a22cc43290c5620b6a73bb391539bf7b4cbe435d54ba08da1d72cfbaa0a05af7d72438c21c2814223a9e1f42bd05e935db2b9becd43b228cddebfd7a22970e78b08958fbc4cf74787d1a3967772ef8ea33e3541d051e018c4de8a2bde109db91c9c7fa2931a6921ae5973b4fdc0abedea3e9cc40593a4a4d21acdd194d8e97de4316adec3b67cc7c49fe8e87d731e8a93fb37be4b4abf17b72924a446c1aac4445c3ab927333fe6523ce6853279001f45eb7a3bcef088ec13af501c859037d16769083219af2bd7a10110103e1ce0fdb1b156daa566fe8dadba55b4cc14be87a851ff3c42886d16d54da4455ed090762d64721f72b5d93da99f578e56442ae91a26edd6bc6cb48755357280084d68d6cb0eb78a2215c92841b4ed7eb9a70df8702655f1dd46fe5661970fa1db899cb6312922daee17b5c66ee596d5dcbd8a9795e6f5a21e48fbac9d3f75be8ec2e3b9d26a641a5889cc3ad02bd14d9f6841f90742c06703d2d2e3e546dbcdb58debb015c61b03927898ac82b5d42db2b65d04285295bfc596fc6d8914b7e1886a35a40e7cf77b742e2b385a13a4f01117e5106d5ae685567b66c6f25ea2499d8c38d0d3ee52e3852d8d3c880d8d3be61670bfa2f9ce7cac97d1064ceed2d9fffb4dc8c9ba099f643b6eede4935d81e681aea585e559cb9970ed42aee48788a85532e087f41edddf63bae2b5f53dae08910c889b5be59e41b022da50bcc5a29456937852c8cb674c0c8f7348b51ed7fb9b1aead8849b7c65394a26e4f46cc71ed83c39e2a1e948fe9552d0a7913737802134673b110cc9e73c6136308363f7e831bd244c3d236cc2f41a3a3397a326f00050ec80c0581836051aff92909139bdd08c2ab86375ab140e7141ebe2cccb267723ab9fb294c3d3568078bc8edbc2b274c05c0c710a774430e22a562f0cfee7b0e4d77e2e166bfc24aeb3b9e320a31612317e91deeb1d350201f776091f4cd9653c6f8ac4ad10f08a8f0118a371e44df70aec3e4ce8721f335c2ab595b34b7a5d1872944aab424bed0d6a90eee0decc77166c0b9d67aa6adf0764ed021d0c7abccc1ed1debf6bdcfb92d23d0e93a4e96c45741011221b4732563ecaed87aaa3d2b8680ab28118adaceea171b01d05b9cbf5be6614ab75b2d5766edbebc2ff205b55adfe84b7bf5b194d5e15b7d01c97b17f43447eb598938019eee320c752d40a16405d0b73edcda1bf602a5dbf24cacd510ae60f6c562e5b138dc1c4f0dfd3f7507b2e50582f511436f412c1d64e3fa9e2eb12008942cf8f4a1b7f62f5917ea321158abd21f39c4c96eeacda7880b044a87413d6c1fa5290e51ce1be4eb4738d7cd9b2d9a9aaf95321dbb84b6a949bfc54edf34428bb8a683c4a44b241429b8289c7776a4ff14dc75b721f5597683f24f362cc3b197ad8f7874002bb55b8b0bd6ddb719028b7723843ce4e4082329b9fbafff6d2f396f79d7c54ac37f3f3d67e45c00aa981e83a89858bdbdc0ba7f0388ace4fad02363ec4c48fefe39a22b166e80f6433fde7ade5b782b0db643cb1486cdb7f3b1bc51e511c9ee2d9fbba1f5b0ea7c00eb82faecd52d810695998904d045422a68234055860404853886c5f66c5a2683eb36792c315141ff511f693d4fe23a308845c19f9b006e9cb5ed4b9e92e92671370d30ad4c87f4f289aa280013f50bde392e2f1e0f5a71f0d43fc687410314f2c86576b21e18f1fd724a18e1b61c1acddc03729d740ea960dca1d8df16abb4350ad1de31e73e01e15ccc844719220dddbc6576dd108d02b0a18c1fe8cbeffcea51445f55325e6f86c11ff2ed6166c9b2d61b39128418c80a2391887624a310c66fb197fdaac1c275e5fbaa64589b5d32ac4a5a6644c3c478afe768742db1d2024953da3bbdd7625c0869d68f0ac02508299d7e75e890ec6b9f8baa5fcbb017dd8441f1d5080d6a8e250ff625c39bc924971661d04186fa379de5fec998870b15491dbdc7a3b32c80446c6a3250318a39a37e5c7a47b225947d4624d7143bbb7206e9b0be2ca05b4e59545c9699e4863e71995f6ed079651fa8b4f1c42149fd3c555ddf9fad663534b55c3584874c40eec09db3161eb0bcd70fce0a5cd32124bfe14cc6fe4d61ec140715a30539eba348229bb8d53646aaa0bbc0d3818d9cffce68e944a7d5ea42f6eb2ffb738a46590f3ac2bf7f109b2dc3de9b7baa7282b33ec4fb3119ff7662840ffdb8feeb1ade4a16c177dc8ab6c36c817bb95f2288d2660761d7069a721d8adcd6b62a88a23cc592a5f3293af9612bb95027bec750fea5ab5e30d57d151f7cbd65b84fba2acc8fcdf73096010bba747148fbf9775406dccc9f28204c9007f0ecdad418d571797babfe25c87d12021fc4123fd6e0c320f075ed41360340161fd68452043987899f6c60cd593f7f13e8e18c8a2e47c3614afdf3f69a60d1ce69055f8fe9ba27a7d750915853d5f0f1f08a8fb56ed596065671a7e982137ef9cea87fa46c5ad04f434cc2aeb9a704b33a17e4ea193a9a830715196c59bfcd7975a0848c89480163c4cb41a2ffa1144f2f0fa20443961d8551eccf3a3dce84ba291f62b7113e6bab838980d28cad301a1a54772017bc813cae58f64f8113abd8d6da3420272201b76b712c053ffcdc83add89ce853bd2d649ac5ee8e2d3ed44a11cdf92bc3002838aa9513dde7225f437be97924c7c9375e176521a8791b147d8e834dd22f517f773433c139ca03a4457b0538c2da5ddbb22afc14fd56a948bda70095d38c8cfb1240c606371f8908898b46c9b005c116fd5cbf247de5f8a3dedc2b320a4e144d64c92ee3b7942f8f92eb59239055d40905393f656bfde09f2e4dd2a536bc68cd6d0ee579a4c8604c4fbe08b173ed30f060d4648abea980c5b04237c10071af6c1a123e0c87d29d13048d503cb18296d076427ee053a891f219a434494ade8959f21cc02600b879af64c30bd3fcdda93b221a5baa7eec8a06af81ebac59c53b5d233887749ef9632e0b312a68e05d03b492fc7876951b9321fe8b04b2d5bf2126e1b5b9ea0204430e4f8c7933f4728d993007403dff1143df649a803805b877faaea60c3edebfde50ebeafd111b2333b277604f5aea5c383779261978486e6f8d196158d440011bc3f949da686c89dea9bfb2d9b247bf77edb5cd30594bf596f0c4023da4ea1702018908c94c6352c723dca9119bdcaf9fbc3ed353cb02358fdb77e9d6b4c4439f007a6c24f0603f11375776a64c3ed9eaa32b9d483b216a12c4fa38832f7238a92d611d7f998ea6ba70ca4e5000529a02038e35b08a50a44a803656b435f3a0fc5fdea6cca4b1f0dab483eb6cfc7c85a16d4dc9362b2a45786dfb6ed6eca796e6363ef81951921c31993409ac2a08e105610d2c543f9885e8543ff143729e2c3fa33ee7d55c2c3a0213e4eacb065b29344588549ce204f13b896d104aa9fae653aa7faca9b2fef24792bbd365f8998a09642fda9ffb7ee8fcf599423d15733ea2ab8061e1a875fb2ee4918dca69e4681ec06a7d5c39c61d861b05c49d31521e62b30988649599a3e57647e5ee2de7d978f5869f3d1e0218393164144cfa2768e0a387853eb8e14ebad8202c6807b8280f8e3ac6ac3ac2b504e8cd76cd955b72a93f311fb7be49ef898c4db77862f7531a74af1d32f9c7a33b87016fa0531982835ec203fb608e907e8db2602c94058e386c28f0249e04e5ba5dfb4ca170ad5739d7394154dcc3d01d1ce1038530b1be5fc1ad33ec5c285560c16e9c7e5338a034e84dcdf24b4f60a7aedb02b74924ff9f8ca7fccea4191cd116cbb23d33cd82e8283aff4422aa85c31eecc275aafe1fb642ef055507ae3c909be624cf5978160c4e2113e0443d99816e572c505d7b206e71ad2b375a080665ec464fb3745ee8a44a7caaf88c0f8aa6be2c2c1d1338bad5d64bf1dff611a4118244d0aea52279e197f7486baef95a4b50c635783ab5d63e3cdffe7b399f90599ef30c8f4505bec3adaed454c78f9dcbabd4bc4ddaed1412bfaf9a9aa1f11b5863d2a9fe8ab9a09bf6ec1a3b1af7fe0347f5b9778176467171f1355e3674e7260fb9136a87c47a51c77a4cc5b46cbae044e7296add6af3a97c52e13c10c16dd4956ef8f32b549e8026047d040558233c286a8eefc911d5772fbfd3502a3979aa1391cc7948e1d0616c56254c9f621e0d94b36df5eb875b17a29fe638ddb9a8c4d13646a8b69bc9850509a09ab634a6e57232cf6829f12828dadd1789a545f1f6d6c9e11f2394b55fe2a4af91092447c11f07c12290a9925f98360acb17c819043f255ca926d3b69f5d85f5fe4559a3236a31d4e47dae240b3ab2840e24773d24d2e83b7aa1115f5da37c7af424aef1868ff69d651b011c6358a6ef090bb64cdb964c43898a923912e3bc2c71c1cc791a846a366d7c13edac0f4cd9caa6c88b1f587b01f3a4b24164d6a65999ebe619d12459bb01f769bf2d18ca75f6e8170fd059a0446ecd1e68c066e5377f7ab2c3bf2c05cea3837aeaec1a8d189ab042467bb5619fd0d14512c57bad5d7bde35fccb0754149b387c7f46ecebbd8b59b86f751976e8a20487987c3c10471576565faadc06b6523249bf4d9660825aa7241d3fe461bcc5fed2c6674d0dd57b6708182d6892e1c57aada1ff5c1229cfed86b83bd62cf82541f05d58d579cc8d00766ae2830046fcc17d5045260898fc9868fbb7d30e4181a859921b53e05472df72290372079a96f998abc6ef1d59e07649774071a77e3ae5b88df48d3478c1651541b1482c176b2588c48c3cc31a9364020f484451583e6953ebe62a96a93c385f2d861657fa31f3c76274a49b2f0941917a1e3287c1f77d5c3dd1b0633b17cd7380719ab80342ebe77e70ef550b63477bc536371f6a5474038757058fe7ce4afa60e7a842f85c4c93c99c6671cacd32b5cebd60534bd92041c19dac7b489439ee065f983d228ce44725204534abf3cdcaca80f22e1fc715dc5ad255ae5e43c9503f214fb6ce0c79f728df72c98efccfd1bf23f3fae54e4dd7b0887e3c0eecade2ee66cc99cd4c8f109cfef2567a1e298e0ba898b260d6358398e3363a9fead44c88c74654f4f6a8730236b0e11abe2010db424f5d984c52b5dd8f505b3e9074e496f739b39d0f45aa0af290fe3a1fe7feb5835469578ee03eb98e829c7b5b388536d7fd9a2421384d1c47fda34fa57cb4efca20c7adda37975dd04b10cac08bd29bd0c0d96c782de8d2b340eaeda3104a351019936d57d1d26f9e9eda0383458f8986ff02587163d07bb3712c4ebf39b607f94290aea52c6c87d69efde39b35a1d9d2d3c751d3f4549a20c9c6d2dca928383ff5934a860218b1f4fcd889b457c4fb14b5b1c63d4167666793a279a33fe17067be47628e77daeeedb724f92dace76fd0837ea8a4465a488825db6b8c97daabc7fb53d8eb40d7b2da4fbf9cb9f9ab4b9bfa9deadcfd9f5fea7f0a70837ec2b8ddda1ad339ede26771b3debe81f982b85cde7907390c7cfffd88377917e8e4bcf5bea83f65c3afe95072120fe2af7b75db87437b355c7b2daf09f3153b4ae0ac2045644aa1e98c091bfe0c23b0f3de539ca0fa49356f2025a8d5ebfc948034d67a6055e86bc6120a5f0459f213665db6102d42744e7a9cd563c925886099ff59c2489050a2cdc327542bf758f05cb61b153e628626a09d5f10880a37de2d86a83d356e7ea52b9d0b64bb5f96db816d8cbfe3850cdfd9329b4123be2b5428770bf21dc3af8e00cf5785ff8acfa7275b2d7e3bde171261869273167da99e19351d2afd2ce7731d581f6666728c7b98a1b385b3d4bcdeacb7045d404c9e5080d14f4c4bee6ebc750d6d66aef3397aded7e88fdddf9505546ee311c4ee1564a3d06401af824e85b6a9bd62a61ea6fcc80829ea6adf3f1566d7d6f5fbe8c27ae23ef3aa1b42d715b6dd804e4dbd8659307be8d32b1ddaa60d9fb77ee8527aae9d1ae929d8f31c64adfe999e5a55f33dba162a2d2c328caa8d2015c7c45fb8f1169804f5272874a96ddbe28379f9e895a09e09754718fec3eb76b3f0aacb1a00ef4e587f908cf9060476a8f5c0ffc6043dea3318cea1ddb6d950075772d3e2de1ff3ceeef4330c3a7ddb2b8c321ad0ed5ab9690f166a5ae3af6abc9131f677ed96d5a02202f9cf60bb17202b4a5dae0c92c001ce1013abd28a5930470e83e185d00adf09a5b6a9ce8f4f2e7ce877ee9d2b106580404d88d3dde2f7ce44e1502d17c0ed49850fc6f08a5f743922bf7e175406929aa6b8aea60c7456a49193955448fa0335bee2954234fa0248beb734719b939ab685265f3bde6dc8a86633a6a840b3ac10505948529c245ba26c7646fd05b722c31025e17bdadf7d3696031ff3510d48ac03ad57d57a1cf9120087d2d02fbde4816107fb29e5ffd6025e45bc8a641e8a47ba66fdcc4a27c9be340a57bc44fc2f5650cd7bcba722ebd0fb2de153a6a6fbc863d7baba1686ab7fcd603ad4ce7c62630768b2a69c3905f435361251e9e0754415fccfe4e6cdf30e120a43899d3d74fb6ad9f5cecce324a281807ac3137da8d1f9d2c5aa0331ebfff7521d5147876f5db1951e4193ee7916b13d68db43bf98b21764e6e97dd94f8a8012d9de0712f0c3c35f0a10f7bbed83534bcef888b01dca2366c271af51cf2415f76bebfc96a9c3429219a16e6499d730c2c17b54486162dd74ac88a51b90efecd72c8e03c4e0f94768b1f81d924c4b8bcefc2404786643ac433b80a704abeec4145625b86fed0a3f62bb16e20309c810f75c06280c7e197b14ca594b76ad14754d8bce5a59c0f06f542463bb5e8518a6ea65036669d12b0800f77aca02161d2ca24f6f9ab6589914065e2a6974adeb7508bbe11c45da62264a277288aeda365c3c894d884f4dd51389dc29486e1ea7ed18aae9289cea9ea81101cbfd04e37ea217063836ef4796bb9b992cc65bac099219a0166c54a45ef128eff278db8c4a33e1f63ec17d847d147792b7fc7bdc9dd590add7fb277fb560c9a02d67c02742954b6dfcca2e56baa86547c6443a69fc5a9a0a6016b348921a218999177a794bb563e36ca3cda338d85f3e97d53dc2de4cbf8f8741c09d55df6f5f442aa439449d4bb557a556631f14b48088c01c8a01b6b93a3b353872b8f0849e4f1d6f948c573ea24787bb269f9b721b04dc3a17d70275af7d736d90023df50525aac1ac61c9e74e13a3e68c1094ed9e7c6f1df50917f9b3f7afd511914a4e18bbe47f14088eeac2f575cfca62961fa079b20460cfa070b01869a5e6ac9ddf9de94e8856c61ce5ea36dbb82bda0b3439b470eccd09942635c7542c51b192711fce510b6dafc3661664c37f8d1ef4bd8643652d613bf72973a182436b82e6656e40cf3d4b3d410c7a186a37e099ee622ad91ed978486c42c1cd55989f53674b1d57bd0b54bb066bad554c2eab26a1e1c80d7f92200a1f03185bb8212dbe87e303fcfd5be1806d892e6c61dd870ed6638abd26159bb0031597312a97a827cef5bb90e4aabffb6861da735831a158ebfd9d7461d6e1f58e4400938d5378785a1224a31b3dad8a7f527754dc133c686d16b2eb612a1b20527a392bd3a75922fc91e1b1dcf0e12714772d5e20192debf6317f94e12029d42489cdb0e743da7692b7d900acbf84e34a88087237bc5d18b0483c3675dc1db8c6a769158506df4db1d3b87d0a57312e125b77baf7a24b3e075c279a2880bee5227f5f46c93620fcc3b06db4cfca7af31a08d0f36cf888a17c7c004833ef062d9ff1267db4e4a899285baad31d486384c97fca441b0b38ab9bd08d52d882a5262123d71ff1ef5698fd8d68c121dce55169a201a7940297677b771734c38a7b16b3d4b23187fe5faa9baa603f11d66d772df475df22ae72546052ecba73e4219ef2d997535d7fcaf8f525921f19085a15c8ab0b078824aa7f59dadb058b36613fb3498e54a9aef3a95ac4c2882d2f827ba2290ba3172bb5f5f227bb900b65baae7e0e3f52b27408b84dd1f64aee15ad2300dda04daa201d80573ce450dea3ddf5dca67b6986e18f1778bef943119b197c963b5bee2d77feb37b6cb4e12e2532668e38b1f685fade2de539dcd304a0f48163b7b182d49c8c502c880bc170c1545b21957966e688a29708d96f61bc08e52bcd8d787623948bed19f8cf9b1f1f91cd8d710d968e9a593f46ebcceed86184a453e26e8c6560d5f93b9769aa8cd06bb4c0ddcbc3ee70d7c3f6e3cdbd9f76de5460d6b25641dad809257d461d4b96193941fcb40fb6abc52e22119104711cf2befb36493f76761576224858990d7507b95915f08b87971dfb6a01fbb1b0bd362874e89a200207a24941b793c4069651986e6448dd10abb06be310334253ba12143f6ff26d3185a980928d70e21ef94ce46c69ab6b2467a031c71123a38088638e9fd401ec5b81e79648c96d8090d8fec57a1ba922b900e66253ebfa28ff9bfa45dbac5cf94feb2e6688328a32be3da1c45315fbc1f175cdc03656ad92587f1b770834f966ae84e3540727cd5f53af24d8fab6f9bd8df1754e5493711eeb35ffa5be4db5e0b87480d4d050bf1e0211a94bac4322b065aa5137d21643ae58f2522934b3d1e554231330cda7ee2170c5087039369857d5bea905afa660fc0569b58492c2715145b7beaae3b669b424e34b1e3861a12935e619295759cddf9b8a3d938b311c73dc5135eed19e47c689d5300ab0f32772c53410cdf435d0a0bc3ef281795c3fb7a86843c912ba20095213abe42f263904ad9852ff73f5745d5fcb519a930aaadfdd6b453e6e16921cd6ab614e7427887aed28772675880a7e83f1cbdc014711cc7c3eade10c32bdca3a4d2d9a0adbeb076fd96ac8a793a3392e6c446bd95d8cd27be38088288bc854720d9e5f991fdbd785a9eaa04709962ae46a94c34b2317a87129d946b49a5acf6ab077ddb89df8fe92ec0c08b66300f310d509ca926a13d9840c64be95c3218ffb5d2f2c859382fba2deb7a869ca3ff10ea0e3a363f9c3d1a1fce3bc49994ea563ba6f4054ace0c52b512687ae977604c145d761f253d0763934ad2a0ea2176c6b1c96bd39b71d714cde6a57f04a0d61f0758d7ad074c64d0ad22a49eb6134237b2c389842fa665b30bbe62389f02e75e070221530e39535b6765841360d639c38909b8892f38dee77f4d1434e6d49ddca15a72356a110af26bd490267bae5f77d66384dcd9489f0c899b7a155e990683594a04d451c71b50103a36f5b4cfe70bb3f40bd7568f463e81ff851adca7c2d54db85aaeb9cd326b19c1ee06197783a16ef15ab2c9c8bf8ff0a4879ff4d46aee956444c5dbab7bcbebe0aeca474216bd608cc96f99db20bf1c42d835cd06f0d5745bd99e5f38094861cc68bd29048faf522b23007d6ee38d75d85a8a54a3952cef64579f9e8f747827a4a8618c444cce2f4c4ab7d09687a1cd7fdc551542bbdd891244b549cc795ae389e2fd0aaedcec54335e0641e71d9c0839a828640902ca38d17b4c9ce019acd27617773072126e120ec3db84bf8aeb7fa34c6bf8df990c2eece3796c59a9687d24347b52f4168d75f038f163c16747c12f67f7fedb77162776fa338bfe94bacc18a31d767b1eaed52498ab74c8322415fe0bcbf9e62810f6811481ef129e11629916f96985b1e9ccbc13591dd1d2558b7450e21b3544290224205ac27fd5cf6d845304a3d2dfcf9152119d79a68d8bb534d400f1c2fbb7dfc82236e09e7ad7c45a6360dc19681df2554403dc3099bd53c7460560a533b8ed3c6fe788dcf4236f54cc80cc30d3dc774f80da9b14a6ee6d50914e23f692fc481f580446c82338cace0eb56e38aeac51fe1dd395c9a26b383b03ea170db05f3236e6c8c3131f9323b9ef7c1ca0b2029ad9477d30d0a2c569de1f8c7b459234c418176ff1ceeb687e6da6fc719110a8f81cd50945ad0ca581067d6e95b55e7e546f131c72e32121e0a77356ccb20388974f99fe132c8137663e17ca62588c06e7679c932945a9b00ae7104906242791c25bd3ef303ee4ca90d448ae2016b517e5b438a0e2825c6658055423ee985c8afa66d5c0908e5f1696957cbc6ffbfa43617723e72e13872dbd6c41cda6278493cdf9500b643734437e635c2ffff057227569a5710db9a032b19f4f73fd3b254d077745de430026dd57ccf7cf7130772a59042e94f14380b783e2e2d36664b94b7907cf287c3212bded468bb03314dc3074a6973bb2c627f5bd35119c7936130da82d47e1d47011687fc1767c203a95e7d5ffe7c8e214c84fd554e7b5e57950b25d8d6c3678ff96cbf0d48581e3dac9b6c1b67fe6b848ec46f93aa22c4b08b0f0d4d9117121a0378079e3b6db6a72ec58eaefb9b87b9a559ca17ffed4daf6e897f1d48c7220a3c78a36084f0a0b1cabd39e488b0cb8a7044cdb07a19e3386996d117f049675968280cf5894fc5db5fb48963ce27c6c4b37508795fddaa972fa080f0b64244376bcdbe75072146ad90e85c93012966a19766ccdf815c809a74e9d5197753934fd1d6cefd8e7bb55e457f53434b91d47b284165a8cae285bd712abff247bf789f470fdb05009c0d6e28674590473ef1a7d69862e9b9737161643d6e78ebdc5a911f5d482b16dca7b1294de01687283f4ff4b2edaadfa86c910ddb91c65e596554d012e4aedbf8ab4dfba05f6b104e49e43c5f70e161e0a1383367399a504a42c774cf4fba2fa9b12494a990f9d96cca144a600e2879bbd0f11dcdb5bba210f3d849efd84545848ef9b1a994e4508d21221c64b3ccf5ec83cc1a6c09aceb0af3f5318c9d4a25388a7d4f14133ad45cdd2e998cb775b657c27cf913b932f6170ef3310e21c72b1073f333d1cdd03c58685f06885ce7337d556b9111107142e994eaf54bb2fe86cb4ce56491c9764ec61fa39239a535f43bff053b4b29f08125d9ab4b3b4546bac393a7ab337ca749825f9accf149fd17de3880536d4fb7195b1bb0a331a2a31e634e0a1a39b3de5c964c552737cb14cd7755eeba2686d8a6c2540396b40c7e5feb66a5824924c12ca668967d1ee584de95214657754e0976d186325cdac3a1fb8b07a3fbc7d9bf522938db8933e57d213c5a599102f8cd0b9c7a1c543afee1c7c8f2c76077ed8fdb7585ac6bf1a46d0534954fd78f11769d081a75806d43b76a3012bfd02e43ccc69a0a9f28cb2a500cab747e1873caa895d1cce6061f4552df62b55a2f9e355b890a8cfc28c433d34a2140c04b23578813588300b0ac99bdf7673b93a22267be8d15ae44b69827ebeaa73c92e9d4aa836a46598a6d57fad2d555208817ab2847ad340f9484763906a96f5e556e2618c69f02fa6dce03e7fa7047a9adbbac2846bb2371872445b72059a72d05dbdcaad4edf0301b8a8ad1e714a3a89e81275cb1fbcbfa5f907ec99b60aaf89937b04c5143864f34fa9832c0e1b014bfa2ba5367a6fedc04a29725de367fad140928070cc42a53599d212a754b816af917c96e2b69ffe3fd9df87474eaa5f4e3e087f48246ecf41b955c8d559823176621ae9eb2e3debfa9a285729d9e3667ebcbcbb1b1d4000d8229588447652c6199c201ac9c2aa50dc23cb700ec0750faf6e1b463992c19f4fe41191975218c8ca941ed2f02474c6bb6d542baefeed5f9cdbbe5a03a4283cc77ed4b5aa291b532bcaa8fb353b58a20873e53bfa2b17f2c6af50ed3d2bb1cddb9df83f3d54b14090f4c72a7a2e66d268f2b51c1b1c236fb10b12be10e731568c5eb0c5d773ad38ffd390d2511bec4971cb53b8f9127c5b52d13ce348df881a7728e4b058820f3627ac95bac11165ad4cdd690a4bbf9d34ed5c67b6c790cbed94165ad15270fb127d017814f543affe068f0c57c59e53929cd751a4d44269f879ab129b521ef3c5043827cfeba6c66ce494750ad1cae99d0c7536cc47af2766e59da51eaebfcbf2f5b2eeee4725fcd3094823d0800a850b74b949c0e87cde5b74fe9f17e0045b3182e81eb0b5dbc77f20a2e5c49343fb55361f1db50b74a7d69410c4187502e867f09a6e3b144a0f90ad13bf40f896ea536b7280d3b3daf32360415a26e1def945b340d940afe1c52e55c7d0f27394965f5637a8182fa78a11b9bfcf3ab52126f4057e90c596cb4d57e972c525e1f73cd00cf2cc547d6d31d758e59727f36f96de94ab1c5959ae1e88877646375ffa8c9c392067cb90723976e4bea255c13559b31ab9fc112868f8a1768a6e5dbbc3527a35bd74d863a7e4a010913e5de4db0e7b19134c4cff69faea67155ff470f7bb3b8e0eee2efb12f45e48b59e47435e5b07f48b29570c56668806b3a73658370aa6314a3f0909734b71a26e6d613c0a298c59aa057073b2de5cd7201491f5c1d750894cc552873c0150a7a099fa54bedaa30a64ae924cbaf36dd83ba05463721b8992f4847fb60ba0d42dcb38e09729cd46bb53f5ce1449ded65595874942e2cb2c41a788ca0fc3d4660aafa37cdf6dba923b9d178cebb1d84d6a435fe548c85eadafac0cb461e16f3b99099cdfed7aa7c4c6a985206d64798f4498c932911852fd38d0be7c7784937b5836e13bb955dc3a4fdefecc7e0a7f65987fe23b8361ae5fb1745681bdf8d57fc24fcde58d61acfad9576ef5309be7498dc0ea73dd145a3381fdefdf977cbbcf467e72754a75ed2944d8e6afb5b819b0e0ea5b449f09c24e53b4d07c46ea3c6238c7aa85abd7937c6cce0ab92b7d821b7dd8ead24e5c884b7f08b31fdc0e66d6bef240e1c400d4725d0d722bab720377deffb73a2e308cf3b8c9423ef9f1db748cdf6b9bfe0931e22fb2155afb4aa9ddfd6feb363c8addcc20fea3a457e01f57dbb27112234d5f6279032e3975b3a95ec7a11bcc72d9c83def81258b34901dbd297905d3b8c75ba1d65c09c780e8895e0d48fe5101fcf14c59314bbf980bf5fd4a5313e52d665ecf28548a54a2fc2d8f18c388d7d67d42a362effefd7ce936fbeceaaa7db556dde727c88a8e0b508b61220b19b57b14cc8ba1b63cbc092066ff950c3742a6ea937d821031f8ef4efcbb408029e3c676dc65afdd5766148588dd5afe486500f08cbda3380a2c23bfffad6db166e2090819321286e8d4d0ffce66d5f9d76d3c4cebd31a48b520b213530e86a3e6bccac65410c574c4862ac1778dd7b20d416d712fec3bef3482c8a82ff48c2af42ddf30be43a0e10bbb23e04df2fd6c2f79d6a410901d04a1e4441490e764bff478127f83f7f365f200f8ad2eeb7c47e62870a99021cea687e2bc3e54d2571ac5d79a6c7c8a28161367929c411b66f71aee395af1923c5e9cc822d2106e0e2956d1e48a4effd1845ab1734d07b78c65f0fca19ea402d7baad91faebeafe3fc7e716d09d1c13af1bb997adf212d5fe42d634cbc0534180f50a5cd99f09e53e8910b5c8f24d75cdf7815437296c46d7065d2ac7e91ce9041c135905ce17d05bfd8aef70887906834b6c77f6a4022556db500774770b25f35a87adec92d97725dc457110a77a64336b19b5013e8d91e0370cd5e575c3e34c9f54184ef65f09794a9d4778d8607a9452b7ba3e58675e4060ba406065ed4675a5b3c1e728c34cf1c3f9e026cda064ae2e81a1cf8cb873c68a15c0f66577073d9d11162a69d6eea012340ef3babda760733d77872988e473770ac133a7a8e11b61286a40e03941c40545153bac86ae88c58a0067185a586a95a267176d061462e1dad4fa01fdf78f0b6fca496136f855028f7f5045b08e65e65cb0066b35ac8f8b52f3b39c5f912b392199cb600de3cef78f9a2069a65a52b3b2b216a53fd8218e19f18f9bff709fc14d4edce1aab4fbca17e223ff40008d7ab14b43834082ee46ddd65c749210888cce5a47b7fd5a3770244a606d0a5f69126d6f16caeea32f2688a972a938d01842e5e18d95fc6fafc7a298ad5c869fd63420e343a6c8b5aa6a48f6db9438d3be312fbc2fc80ff24c7ee7d1c6e2b3f4f703b0c1a12ed5efd933ab1a3dbf0e4e6f534117d93bd198dabc95b73357c57b9bf6dc0a81906ceafc403337043a8d7d691b504db588213b4a37715e109f155b02fdb3c485b5eeca4381f8d82856a011f069851b21152ef78d3e9b1d965f451e141acc5c0bdf17e41a372307479ad01a2a14624073242a2453c14795be6a6a9f0caa87199ea8e52997b225bdd98d8f5dacb0a82e45c7b527bb671902c5c57a450eabf5a7a7859e2d0f51bfd7f67c7c36b8e9601e17abbe5b7db7fa77f670fe55948825e74e0494e9d5f8bac3a0b4d343af57d13523ad5dfce853db4d13d09ad0f53a86e50ffaba15ca766aab59eacdd25dab6da6f6a2c918f67b0bf12a232ee39158b7148269d69808ae3f6fb751edea0881f95ebc83c95b20d63c26b47ae2dbf4ea8b2cb08949b4405fc7572805066b524f893ba8712a18847e29033cf543668a823e33027d7cbec22f223df2fe21342e864c41707cea144903ed8e4522d9b773840aa77b001b4013bc85972d0e81b7718ecc7fdfd282bfb928c2a27f3f909bf10ebc57b37830949fdc321040a6c45de0cfb9c9b91e935b14c661b3d35a96d1c3a31bb3b021fa4716bf09bf756e9b377c062d785aa6d2e14a1686c6910e6e08854c516152c6ef4ad049e727699d181b52cd668a62c2853b56fb4491d6d8970230e7c3d184e5bcab6f4df5ef69b092b601d6df92c951d63e2586f96018021aee1c6d1ccd5e2a66bf00c0cbd3a3668c7ad4325d001e8689c756a41492ddb7012d001628b472563faabab3e3144043b15160e5d4b7dc4b60a37ded9d81a48ee2f0cb871e9b6bc782bbf7ad65be018c453ad315ae965efc825a9ec67b82e7d45b5e23c6311c321224dec1bf59dcbd9b6ed0fe1c4e0769ef4bf5a7820e4e089d33fbb254588e84a709dd46e04ee963fbbf328642649f157a44418ffbe7ddb642bfebb93425e2cd9c7f06e192ebcc307ee665d2371d3f946d44696cffd78a05f94224f502eefccaf5ca83c61e1e6c7036153e63f7912c57b985f6ffb1f5888638825f468fe321a9cbdf8b63051bfeb9399ba63827753d4ac945c8fde69f82bc436d8065a4e9ed7744980ae59f51d34890d4ef2bf8506c5b482be655ea46e8b2301476663da92c9e2b32d97c20887ca1daaf94dd525b77436b08779349df3835c006c2555056050d68376fa31095f956f523ecbfebb947b877f5a38b1a5e066a87cb1affd55d3328895dd89d83b2ff2ec585c31a30e8b3f3fe5e71a6511bcc33c74440b66f458fac598c98b8f26fac36f054ebf9ecbea218fecad7807bb55b76e1c37233431ac82348fab9cfe14a047571792e5ba02a289d63106a5c37ff35101597343defd179f255475fe80955360cd3dc67e46a704ccbb65842fcebf8de6a4477d30d66f47f7971060f0affc1d4e889c1191b112253671d0a461c5e01b55d5b405857540a67dfac402c9ecdf7300c64d5fe2a67fbcb8b3c9ca53e9cbf0a135a24c3f4050512157c4b8cc229ad976f2dc68e95c8fa3f87e3f8f33a96d276c3fc853a8051f979d9a3758fa3dcd97e166cb90e5bec6dac568335f955c371f159d12e1fe82540889c998384881da7f74f30d8d279e0b233b143b6aeb409e08abcd1d51906e3a18061538890bfc68c01d728be1d4522a26083301e17bfc9c81e8c1bc39293d3e4db7ebb9f783dbe3c99274a22ab012552fa819c28370f92d42dbf976dc07877201d95594a6c53af942653ca337b0cb9f738701d080d9e4d3d8034b0569baac0db3a22594737b601e0d129052f56f7f80ea58b211a3bd7e137700dfd80f933fe9e451c7598e3b0f09593cac6828c1f354b61e727dd091b1f6cd142b92e49bbc048f80c6d75e68aa35cb868411f8eb0bdc1ca7c9a3d8b19889fa20998890345cff1ea970d4bbd77661b0bcc36f486545bb0f80e12593b4b65d82d95a47d5c313a208fa566d71ba2b10423d7f15e505a2f944a3f9374eb51d076052680ddf266a56e6dad391177e5d0afbda5d8c7b0cc184df5cc4248decb4a11f2ffb4b67c86aa929c5228438a309d9fba006d1657407aba72e3bc9163218470b0af029a789d6ce5b520b5ec7c1af4d7f3008d5446b7fa1d3b1da185442c79c67e457021ae7ac1aeea19a8ae635f1f95ea80dfc6aef850060b91097fee07b42c0b12be30f034b899a78e848fe2ea6b3a748229f16e17443f8360ede1e338765445084101080a93654bb6f2b231bb4183e44f98a7c10374a6fa41c1d5bea07313380f1800b55b5e6c727149bcca8b6059372ab7ea2121bdac7f30c93951ba45758ac8a5c5f055b7e6c6c8953dbd8b91f68d320b009e7481bcd475418dbda328d98951c84a7e69e88230272e4efdad84ca416684829b8f5183bf7f094a1f66a0b8e33670a615e08b36969363111ae9238389a92e3b840d042779c4085566c3d0e355cb7b45c41b95017ad47f1a2bf0ad112904712cb9f27edd833867e3d70fb58a804487e01bfc5d6b04c3a31ac0239cc253e25d9b7a5fdd2818afda29e22c9aeed2cbf165f82c45e47f0e8cf6d39421e7a8a3331d7e38c8cc67fff2d454c2759d2c8ca5f10f31927e9879800496bce8354451f860b09ca1b27dbe8eb4dbc8fa6d7375aeeedbf3413a2b8e9caf5c038fa69e3b1391c550f64d7b82bbf452139662f1e3190901dcd290cb93d8b0941e146249afd1fe02c70aed7ce311e9877186ec8b098c2a3623b1170ff1670cd26be6ff60f020038192a269d0c7c914d671f186bc6c43708ec259b7563e8ff64cd873fc1122219d9ba475c4a57ba371a2b88c1e53f1a56c67219386495b78e44697fc647069f9ae77cd1c477646c40bcdab8494999e4bad03d1a7ff30cf2c9f709ded7b3fc72296110d7368cf5fa73aa32e99635b630b096d9dfaaabd1d530389e6e882aab4e5e57fa336fa5f51ea912333f11363b73bc663f3816d6bed99653f4b2b670ac3445fabe308e103cda4f283088272e065914a19602c7fd2493a3e2f0387f9fc327df7273099752f53be8c22d0dc9d597a023baf94ce1ffeab053cf7572c5e810a6a08dc0f1f3c0f4a8894ca042ec458023080de96330ac90c675abb377b26b6a37f234a065eea970665c00ed3c0a952047147e550da1f5b4cb2e57df982f194b29b1bb5f75380debb31d7943e4a08353e450ed6cbcc7b2016773f785896ba809afaef7b04265e448d7a08faadbae38cf55f578924657ee9e55923cf93c5a9b49012d2cd4136dfb591c49895af03a0e52c5f18f2c85acc78f82aaf88d403353d8c366c424392c5953ef9296beafcd6decff69d4325b43e39aab2d06a77df13468ed07de9280e337fee789a1b773f4bcf91131cea5c8406ba0c3657ec6d2d4dddba8b0a3d319b58d9dd14f6cfacdc0599aab566d5a11e89f7f9ced3f1fe0dd67132c7577529d2b25cc799affa2bc47a7c0d6955cc37f25f8edc434c560b955be6d4c60ed2c5fb145d5563369577b202a23d8e123a2f705d2e1f0fe4ab7eb460270aded95c35617ec49e479ca9315ebb4a52ce11aca5f3bb372b5e2463a6c00ff44c28d98a9aa1093d4eaddb6f917c7a40b756f2b5fe59d1951dbcc2d439096ae067f231efd5fb68b8dc664e2bcdfda2d05ca1a643a3ea4db370d7d8a66265ece03838a8b72c304e6512528208710cdb7e962a55a5e5bef18f93106640924758373b90c8c9ce15be9dea4d7b06daa4d4ab1b1865ea56fc0ba085451f4cc20390f49eaeceb3acbfe1cb42e32e1d1128b09ff16687b13ca7d84a69298ae4a06cd931979de429a7195e0fded90f84624bdc24e19a94b76c630b4093bec95daef98e8459c8a6e4e9eae940a425877d7029b88979adc9a3c02083330d2afe35d33c67edaaa0cddd1e837530c1e8aa54303e35ff5df49d8af16d655338a1afe47f1c655d7bb77a7d393063829dd3771136dd5fb2b5f6859f954912d4458b8be5f57caffd1b54d7c3eeb51391cb0059d9540b78a142e6a6c9d63d267b1a2e908f3f64ab6231a085a42133690e86fac3e2673529248a0b03a562859bf984860b0762c817e154b9519eb3734b161cf7b8d564573dc9b17517b781c86fc2597a6afcc9bee5dbcc8d4c80db4b0d4899bd300d06f6b73374c99f54b05e085819a95aeaa31d59e77e419d59615720f09f9abbe0ce590ae675984d3010d9280d01addd8daefbc2443b7ae0583dc25fb3e530b5a3fcfba4e6fac47c43264e980e87f82045107eed04fbb4f460d71daeeb0ff91e10343c6aaf18ac8ee0ee7d7ca98c85b284e68fbf69345ac41db1485c7d66eef3db4d817ecc54621b4a9bc7322abbc95220cfe36e14540eacb32827f4088216ae079ff105b455d21420b8a772cfe822fcfab40366572f3231d828302dc8c805dc176669bbb66b0caf5f19dc15e5bcf7c6e5fa55588215de1dbc40cb15b1022b4ae9f49a5b938c0d48d6d6dd280eaeda45b0bba3434bb96a7f78f470dc9fdfe72ea21c99f658d4b292dbed452bc640c2213d76635fb9d096853ce91000e83982b196eb3ffc0e806672d21d38a3d6943478968e500ed19c10e4078a6561d3f148a804253bd5a042961c175e3e863950cb6d0c37aff7a41fcf4c6cf063fabdce3cc954ee4d6fb79649e67e3a67f824204e61009e6e16c423e6dc4eb41cf751ba344dc494acd636786d92cec5184300b10a3cc8ac31ae538803bd29be77f1d8a75d513988725151d5a7fbe942fd2297a458e78f6d86275aed31802efcaa98d72537bb7d439e8312aa2344d8c9967bf84369861895c324337b93068e7b70ff5ba63c2cbdf13236857ef4e3f7ef7e5d7b29b8be38bce4a3cdfaaa57524e7544ebdb64dfd45e667ee62de58b3f7b2128016ae81ef8ce92e5b59de0a238e4981785774510f1e484a908fcd91d28a90580b75e56be21783a4fb220fe9ea4a3d82dfb5d5179ab55be4ca586b6af3198a46c443398babdef3373f0d353d948a5ca7b49a117d19a77b53f9dd970c8c74190c2d5a75fa4292c3b781de67f8ccefdd24b723b8764b33d63791d6f2d0f4afdd03d07bad2370e3e1b7ddfdd47f94a26d908c50d985def71d366f2118c4fae5a823a01b5d46e065ab0ec15a982976557d6aa9cbb746705d80793341fd2d42434f8ce9fa4af68c4f565791027ec393c7c88fc9b7b7e6db56032dae571aff788f03fed185da9b724e287060162e0e808d33c5f883afa6d84b45045c7209675999a860690f0ff196ee03ffb0120940e92a34342b08bf5be8485bb1f2390f427c30423c4a4f27875f4a71e84a9b067f13c7b7e8656c57f195ce326ffd5690a3fb969b41cac2614138ff42d81f3d3d692306c950779c2ce303da6d7b891dcf51e5944cc0bad32cd789a05dbe3fd8558f38d14bc23f4a5fc5ca002995e2516d467d978130b9e6bf540023f54cdda311f55717cff589c04cbb27ba7c845f18163150864eab0fb3dc9721fac87a62fe359426d1cc85730818ff7a2fd48f3e6264f51538df6e258642d533e28404957ba5d973d1af7265232e5f162e65049269922864b18b5d7f542f15749071e7cae22923942c9ea19c5bbdbc5b142eb43c0ebf953097b17c50ba24b39cc30de82e0f77488b40565a42ed558c2bd4df75fe259eba237f37779a4d09ddbb6efd0d15e43a1107a863c8148ab058a364039f9011394bbb07ca1bdee3a8195af8f9215fc7a2b929a2907c9f79e53f2c3d7b90d228fdad3ce235db5bad88bdf0c71334f1539b7224b9bfeb03583571d9b33a2806d0b57c7738bd4ce447fe76b09ba219363633e0a1b148eb51b5e2b61659ae4d1c4838055818eaa9382b7bc29760b7e7b364f69b000d8b3a701782e5a6aad969118c77cc49cf2a4ffb100875d986bf79b026cbb25da8a7f79420946df2b79fe759cd6e086a5f7842303afe38930c4feee59ad6236f423a274edc33cfa59105b95e61d1228a7862a74db42605d4b8b32947b032642ef27a311a752121a09e7ed50932b73a029f1f48dcff89adf2400951d4c2cbdd52d8666290d4778d31307cb362038da2536aab13a8ba6452345203537f4e906b9c956e6b19f0e9d0a9ef8ad13a2068619b05909b802fe8edc2b9875b206a39dfed4fb0de37c47abb36ff412fea3f7db1d45bb39589eda7c9f324805f7afc567d3750f2b4604041b512e828d31bb7e281eb99635d1bc9d706de3300944fddf67e31836ac963a5ef3803b08247aa45f6f39ef0e96f33e8c71741d8f9f68554328ee666de5e6418845027b09d168c13b7df33c01dee74bc5e44bb3a3fc55ba9294e0e2fce97616cbe1f1607e152d0ae244ff797cd20b90cab2950a07e02acb379d3372a2dfb4e64b55b4dc05111ab1c3c0191b356ef2f700a353f0a3af742a10325c4b1a0f7bcef2bceef0ab3eb914f7ce825e06e6a10ddca2c2a8a79ac4261f3c1b02e5e5b112415d5d319b67e6894f3ab4af3f742d92ca0a68b841c7297674d1832fd87db4ff40be2e186e7ebbcc8b725c63daf4d21b8c08d7d5b3b5c7cbaf00e1e39588f72e961fbc2532956146c53e323a4ae07f86bfea3cf3b00c10f7ce67b26bd7f73525dce38dfe1916947de21a91647000cd6fabbfa6d06bbbcf7610cade3dedee81ffab548ac7b79d1ee5ccdedaae5f89f1d0b307a1790b9ac16cda3e5aeb124316b8078ed4b4959c0df91215a4963a8272b85025e64b19ab44f7313d54cdaf0f7bc15317b7acadf6ab8c42d4f891b73acf562f2b71ce1673c5bcd3528683dcbc6be9ddb5dcd2f48887c01425ed3edd15e3fa3dce8de52be6eabbae2fadb12a48ef3dfdf91412d93d841c6aacdd32a4a0f56422f2816d4b5ba600dff5cce279622007c99271a20b99aec092f18bdcde9b4635a8d0341e100524ef040d29a5954bc83ee91c50ea24e14fcad3c6d5aabf7e74ecd2bd987adf6af0e5904d48c9302778028c826cae35d1067ad5f2ef28012682b1a385ea316d50a28f8fe506ad939d4537b8f96b8686859889a1873f80cad973a406d1813bf8de440595f26ce289e363fdb457826fe9d411b3e6785919bb0fc7bd1d4e5a3c8de7e6425e7ab523bbc6680ba5fc0ae07571e48696664e4b012c0cd96947246e94c6157b9dc278c73dc0ffafe0d7af97ac9c9c04c26433dbb55319d6793c435d4d1d8fb814457d37e17426cd41041ca24c11dede68a0600f73f422717b2b36d31b771c6d0aeebdf7540f43c5d20c85e11dd7e275b54cb6aee8e0849994f6a719d2380421a0b093386277cd083b2551d32754f09449f5e283f113ee0c0d1e9616b549ca6d05dc8516e4f15726ecb41939ad47ac7521bc3b28f5bc2bb39f68364235c20794ceab6cf566f62cc57f479c3eee5ed9ecdeeb085de40161ca0c16059f782ab44755e5329d201e5f1cd6a00c5dcc81751bfbd10219551e0c3d7fcfce1a713a15c1cd2946e0db186f599186bb1bb086fb0e99381db08e86a980453a6b79374a7b13bf861bd7ba71213d2ea63e3a955ed3ccd80d78453b422d2c64c0252ebe92ab68ab4168c86abba67d8ac2785c4b28fd0578d97d8ad4c1bbd9c9788dd4243d9521b6406c40c74903a48a2076f5205d65b0c537cc0b5028b098c420282fc0327ebf08bf3abbad20dd513b9ea55fcd146b2b5e4f6664a214bac74db12f9444bca71c34c98a284288eeb5453c9496cbeea66f6e8a619e8c15a4fafa2aa749cdd3f8d60ef1fa9ce17d29591563184ee1ecdb847bfe4fbad9b5a52d95c92d5253743cc5c19abbd0a8f7ed77764c586ed70828f394839897789115bf0a4e531367b5bea06bed005d81599b851dfba8963249c870572e5e7b307ea751f0394abde6a4d24cfab16c9ecbd10eeb3a25a3a9b7f370fc7fa5a0be59572c6df76e1966a49a59c94aa793b55383312292781c9d9b96e92eaf1bfa6f0badbc74e95e6f00bbb31d08a7bec17d156366ddb1d234acca2e2b7a5626eefac667c1ddcd60c263037861aa9afd10a5ab0b14d7f6fc45fd24d3aad8a39762f538e4ef3b0319428379d794ad63582ec1c3721f1ffeffe3c80419d8388e71928c22c71ee72a811d786d7a64642b6cccb6f4d65fcb006fff1f19c399cea7c4f44ba42a5ad4407ecb2343eecc19f4c6fc88e4e41840601080bca7dc02429f7429b7d0ed2d925a3dfe6bf97eeff2ff79fbd298fdea515c4ef7ef5b2e6a39c44d0c27d7580c614927b9d952b94a9d21c86bc0c9148af5f179eed8e71e49566110c7201865fa2937ca2a7595788b18be0bf566d84efd7a9d1922e7b52f81821c9bef3eb09c13773db0d732d7dba483195ddb8a6382689e3c65c2f9958e3a92759de68105f1b3d052fc7506feedce23388e2946e4da7365d7423229f2069f08a271cdbba2c8835187faf0bacabe74ab286c8dccccc0ec7d10e21fcfea4d59b01635b1f591945e15e3dfbcebc6f95c74bf4fc4c6055598c04c422446c31724f684832886d56363e2576b05c4b81e44f6207ddc6b9a36fccf5b70831dd3a139fa23a6a6835b4601875152b94363399cfbec2427bd89895d9ef83491821d28c1bef918365adf16d2a0ce99b4891d1ba7bc990f1e410d3fabaeec36f2c6650366f00d82e9add282bcec5f1846735f61337c8f82993e88d2d65248d978b48ae6f8a6dbed488978a0d3d5a893d6f25e5b306d5c219c4b0c4a1829b7ef39d44af18e04a7d0ede0f18a86095db7335369e6c967e0366cfe98230cc3a7b48c4a6ac15b2fe6f2a03feab37336734a4fdbac656cd44f4a960b9e495f1aa0271565254d06da2b6ad802b7018b06faea5df2d6b4c726332ef81fd88f011e18cdaf1f920b718835acc309dcf4d54e8df1d7e0ede6de09cf93776c61d46c44f420518a3aabacc92f4f141c010fc2e0d3e070d71a69ccbf634f863413fffaf00e9081d8f2fcd44dd1c3c094506f081671134a8f78501159bcb98cf5d1866b518e50d66e3de6c7951faffa491b015f29bffc6f92f1b86af4e64f5e5b7132da688b9d2f7aa7f124d7222416ff63cff479e61b7308f8a5b9430f6e0969172e68dec8b27550b08c148c0983c400e8b64c06cd7504786e573c7b2e19e7fe4ce8b8adbcc72adc6997d68ee25e080f4439decb4ccb29968bc056cfff866a5d664f6342a4c2e5b6522d0f7336f4e0d3b9a2a2304ec50cc1e650be93bd3e5ff1b7f6a99e1ae67b2a08e487e4d2e5de7c9fc2b8065d07302e005c61d5c02bcd30e8908c0ec723f1fe919f5bbfeaa18b91262e7758f9fb5646b6038a6774701dd88185bc5be6a6d9421c4ecb5271f3d27425449ed029986f77bafa82fd3adba49c7b8cd8273e1b949ea60c6d2befec0f358925ef6bd10abc170a522dd0f896584e35e2fc72c6681ca14052107423546f056edd80864beb94263c0f5bb32af73ceaa37351fae9338541bd01e12714aabc0e1038ed4fdc39e3926b5334876ebc8aadeedf82d7907e184b530e1c962087c6d11a2faa1b25119bbe6a7340118933d18289f7295ec219859e4cc157847ad7dc64cd6b9421d563d986946130e94591f9c4775056f2717097d0f2765466aeb25955f3f0f921e3df2141f9d2ff200fead1c4c40f553b34ef7e50df304bb43fa1d9f34b360854f5974ee86adac517d2f9d8bda7de9f5360eb7c533cf2645afc3c578dd20b8cc7436d2b19e61f0c5e1129760d0f06e47b3f1b2c6bfbe85d995c8af27d27b440396bd7062547526c22828b8e3ca4b74340dc2e79a4154dd9e9fb022959291d76f9ac586703754be873eea11485d78cfeae5d066dad3f36faabe9898d013e666558d659effe1b6eb2a2b682696ffb3b7b2031fd63143f682cca41c4022a3168cd3eb1f1a7dd40023a7c842706600134857cd38f0e07cbfdd6c76c77ded28ce07579ec8ab86bdfca30377eedb6b03f9031f9ae20189de0b4f774c106563f508399a7fd9db20689ae98780d449ced6bd4b54d8646c4b41d12858574742058141a83593c3843dcabe380020f40c55a904e95d4c862638da11bd08b5e015f7ca227ec04dad5792ed0b17125bef7061eb428967ea08380c4ae8e72b4c5a0e223f88098190f857bfacc3d2a022042fb964933b9a0ccc414076e5843a3e9215274ee63cad3add5bc57e8df8416b4efb204939f2e4078df1660592f5bfc2c3452121b22d3b725f8fcccaf4dbc12fd4f7c655260855619d8fdb98869fa67d886b381302954106ebf33a7eea13b88f483e7d416eb8fe25cc74c01d176a94a22c8b03db6b53e88ce7db1adf71fb2b7c275bc409d1a375272e8e4dcffe4557775c5bbb8d18e9e81eab6dd1d4e53349a4c7cfa5e66c4cd51e67de6ec4d3a06107b2c73ce621fd9ed24b262521f11c2494448f5eef379c59f893fab2224af0561af26bdb798fdaa858f2559443695f8e37af83d9b9185e87c9fc8c8950782ea8bfd71c04c5b5ec175c7a9ffb00b966fb32c708fa7e54c4e43343d1d1c05e5840012660af394c4831885f798cc96ce274c49b6fb68d90e04136d81ab931efef408f57f0a3b94a21be5530b11377c0439f1ed77c0217d42c91ae224ee978b078ce76ac3d89268254ec0102e68f1dc343ce6f23e7899cce03500ee6670737e5fbec3586e9c9f1eeddbe50ab0b18e8c25c29070ddf3a8c26257f0327f0810ccd876cbefa4946d6f7600efddde8113c384de0490182a0d2ba372b18028eaf2931ace53947ead62526a119f89099b89c54996f6a8e650d6e9141858aa6743d54eeffc5a053099f54680ca6da8f0df308af07f513d412964ca42e8bdfedededbb979a6c76c8192fac9a2eb0296e887acd4423947b2985dbfedc4f40f2d6d6a6389f99563c50417750e539ac508f2151052bbcea8959afa50957d975818120d0cba89e5b6e7edc89007a8456736e458842da64950e7af44de06f62237e2553027fd04dfa197ef72d3d5f091479d3325719f3f3c32f4facf9d142684f9ce70605fab2d1b4621ad641bf41e6e2f32c7d8187b704de8760a5a473eeca87e85a681d6afa557d85eb6fed67b8dcdac4d88d0d723a7737a3619ffb50684dea63f5baac940a8c322d73eda41402d33da0bf1d4bb373edd4cf53cf06eeb218bde8bbd31e2f282a2c2abb2efb00085418d349be2973fc4f4071d35da463013897d9ef9b28d62069d7de994644a05a0d72ec5d52dfc334486d4a57e5d220b31d195d9790563e0a8563f317fa0719f2510e2ccc92debcf8c6ad6fc4facb9a191b35284f44eb7728407e22934644ccb696bcd8438a1d8ed87db6d29d9feef5a8ea0719f3dc0d606c5f203122d87f9239f538e0b118ac45fc64b39a42cc79f18b27412451934899442a6a636e92ac988ead9c62b2709a4179356cba22ef16a092d11b57483557a5acf08f00af0bda06f19f5e0b919a2f88e4f178768d6834b71acce6ef6ba445fa7e81d6b7b30fb8dab0d3e3592ef26f805a5a86cdc10b307fdf611dcf8057de2c10b29ff8f21be99feff39f3b02a8f3c40978aaf434a251ae96bc0fc3f1d6688a02dd868f61e224f0dbcbc5995e3e0d0b8c15c959976995b8de6d1b70a53fb8bb125e8d1a71ca2ae56ecf87bc060d4058fd4108defc90465e4ae873d776c4894b57175726f37084e62995e8a52ac00600cfce543ab1bd698344057bbeef2b332a0eed7606c720187df6561bc6d7d6e923c9d4f6bfad87f7991e80a978ca4ca1889c48cbba285d8b16157274abfa24e6af8a2f36e759fce628db7a07d62e97a6a4d697ea732f5f75e2fae9e98f1f51230d1dfc0e5e3c1c083a2df63438948b9960feca9f888a9061331ae223e63959fa04de20f688865baeb8b45d0210b14043c028d676eed30ea20dd4281d48dd0b4c8e17c1ada7f0232b0bb7fa9845e6de1da5e3355987df2df2cd3ca753697c8b277f1aca291031501871727f334d2324e36306633ad646f2e811f1f488ee74d0c05c966c843175b272f0b17f66ea55e26a0d9162d4ec10983b4cf3c3124de927b7c335980251a78e84db76f1f8e3167fd9845f3774a4be0fd0ae6d6ebb13acaeab223c852833f81da03964b34c2a6b731ebd3e6ad67333789f543f75323fcada27c1fe30de22180caa9c170557321fcec2b7a38a1374ebaa68d56ef80c7c94f2d34c98d7a308c7fb732dc20a298778b0071fdda79c66afb132adf73f56786191fd66237dd683e7fee6f8234b08d4b7cf549519d647ce7f499f21eb33b0a6a5286eec1d6a04380d1ffec7823317e92bf4f61306b16c6dc0670d8f88e20315677991f153a851c092d9900c55938d7c647e2ef318d410bbc5b18b47c4fec138861decacd687ecfa9f9fedac202081aa69dd8d75d7612421c6009b6daf5fb3d2ceffe1c91019929e2d5344b87cf03d75bb18a8f0847dce15d9e5c074567d594c46dfccddfeb7224cffcfe04d3c012fc842480fedb3d1c9611e22ea31f7f6de30b7d162f9ef7a468ec160354188b256bf4b1ba3d72209d125602d9da5e20e98a30bbb6c90f7c22179f545b5441448573517522f1e27581b7182b0fce9f92a13f6a2dacc3167b319dc17347fa5ab6b0bda8f425ad1aaf3e87adb0b9aee7854b9bf703dd5c93bb3a8377ed6d7e108a6ae533557e3256a911fd11fd117ecacbafe185e49ee6867ee42e9b74774a44aea952c5e8d316faff2f60de6479cb9472f23dc17338dc845d24a3fde9794ee5f0b788f87f5316d4555b5e6e5e8136e3ca9820d2f897a0857931567224bee7a7442461488368607b9007ca5fee343f774c175cd32aa685e91a8ff6614dc66a3bda9941f210903d04cbb2360c19bac903b36c2753549dab1374c919692369e5307c2929698bc7ee63155297eb3263c44e66a9bc400ee585e28feb2460d3b49d207f193e9bab0ef17b31eaa5fbecfd0de2de332371774fb950401f28bce3e5c6bd0fd27b7e3dcda52006b703749958b029dccd8f5828c3c1e66ddd45c42880545a893c389714712cb3116106a4aa9f240af71acf35c39216196dc3f76cfd777e93dc3f8715791c366ebfb120436f4e3668bc7dc23e953af0cdf8ee9b7adda844f63813f7f556bd64ec27c35190f8e5764bfe178e61e04b4ba9945dfea4ab6076c77254e59bf1a9bbc27feb21e0a48f279077cd00e774dda5a999a19243b841f9637eb017c9ef8c85e256aa2921e236896f5746425e382115965e6203566d03948f274d7d76bf3ccefa8ad62829ed7ae0d414c67c7e3ca43ba03cac1dc1f1ced07fc44f3d8920d68d7753817c26a4d0014a2abcd45cea05ca9bca8d1a91c5ba37ed642ba166eda9df1148034e7a225ada65fdaeee573559f2e572703c2c176140db13afa2d7405f3d4437f1c58c031bfcc2147b565878b4d0bccb2cafe21cb9063c95ea287d9cbfb317631cb02e4f86b592d045fa54fbb9df350fa521217a81be9b9c10b0e027e3a26f519938cbe34579ae948ce9870b001a1eb7081a649d455fbf2dbd112bc034e9c09b9e90ce354a59b73ed69e2d50abd7671cc0aa8a707385173083be763547013681d44a584fbddeb0df08db914bdcbb2f589972fbc6e9d0a530931e9bd004568c5510388977f9e096ff58bfeec8f18652d66f8ba98289e36dc81c9068ba6f77815e670400e6b1ce54bc13b9eeb9d03a73de66aa883cbb9daba785efa997daabe7572cb4d74fd771fffbe1ba792d638cdbdd1ed256cdfd1c445dc36c15dcf34362f0c636377a9def1d87a01b2d57ed68d74b1a5063861f4b100fcbe0ee07a31328cd4c5df08947de676285a802bade3547c5651305c42f6933f0b51be3c6e5df07769fc4ca11944cd7d1dfbf1efce16410852ce92d4e6ddff41a38d85b131460cff71d6fbd7487696335482b45320ec82f87eaddb7ca61d0f353f4469b35e4829d115470cf1620ffdc1eb464ea1380c18ca73d757ff4e9e3d49bfebb66921de6dd581d1743c5ef42a5ea4d966317d021d331241b50b9f990e71e8aa8464bd3daabc6905db2068f6c02c65156f02ab432feafdaf964bce44826ce2f0f9620648443d7f0b4f755ca5ec7cb8bf0a8a518499ac1b8f2b97034ba67cb89de283e7c6424efe413c5d4ff275e04cb9dd00535f449418d33d40dc17cb79dbba4e49defb114822e9203207a2eeb972be9e1b684ca533e2ee67e6e7f1270ea0c3406e7b7edb4aaddfde267e8f6d15a0b791de9de625bb2dd8642b2be5f785bd7dacabe56a8bab646fb73863be7f03f299cbfad082bda0f01baccaa07d59fdd061483054e0dc71902944b2983d3939a4d7e1ee3516b7dfe602cc0bb2517bb3d893f3bc98cf07237ed3fefcb5d98f6b9960e7f6d56cddeb0fc63343c25cdff1ba6bb20d9119ea2dff622abe849f69b7d732d9b10ab087e02cd35f19a529bf45bd8d8375b4fdc54ee90a2f44832e096b097bdc44053d404946219a9c23cddac00e938f598dd8ef299457bb1965dbc1b0fb44f0ae48cbff1e2795c0b579b03c963d4275863732052e5d5b3c2c91a21dee22bcf4f12ce3363adf75c374d82bbcaebe57b430e61c878726eb7e53a1eade2512fc29b05da41f8741f1cdcde3f048c069de78cf5de3f190d4ea8b30e516884e057188df59dc11bf63b04acc3545490afb1749e77807acb3d0a9114adee9525a5bc8943ef46cd346227c36f5d90c951893f55748a490661f874fec04c3b7c1a014719148d6021f179bf1728ed0a4d7d535207e3a62aac816ea579f97ff68347558ac2f81fb1bdb41b3460bc58f8d62c54b911b8fc89280d1ef1fd25fb04c2bf9ef2d2212325ebbbb911e9d387ee5ba731ebb6397ffd8131d0e8221112abb21a4ca4c33df9f3d468f1e6e57467ab36b0c6141d68bc6eb08f7c482d80c73882a8e78c3c0673af378838c70418a5301e78aa741e607edf74354130d62d2c446b845b100bf064ec3838dccabbb714fc67f2be82b12dbdb16b12a00bf85e00e593bdccf07a664fa93581a16056d66a5a1c698002bee9609cd959b14c6c18f72d57fe050e1e938b3d3055a65e50d0d0365d3d0301de3ef85d823cedccb5366c837f530569be0cac0af173cf86dc34f096f45e59b1ca43c704f27a369f2c22619e449eb27da37fcbd9a79b9d3bcfc6fccd50488ca979c1e800eeaebd1e0fc6125790442adf85b091923925d3c41042854610ece29fad8a37f77a637acdf57a6def204acf6b87296981993bd3e20b7f81d56d4b088e42b01ca7f239c97050c7deb9c17b5b584cb11d10738b229a9141c9a0ffe9d9af59159d20e5417b473f54726d503b2bf3de7eeb0f66cb510da9739ad6a90d4792216e69eac134929a2b1b91f9ec0bd8f9e79bff68497ba49f48ce53100c965209fb83748805a4d9cbc69129601b9b0c42a06bab44d7c35f120d528712f366ff0561a3b7c9e8270be0edc8304434a369eaffacfd49efac86625cacaadf8d58a2cf5ee1bfca77850bd80761f13e2e5bf8454690f907f1844cb2734db9ca745817c7d77241eb8f1becf239479226d81d8803bc4aef906192987838306e54d4c016e74873b4ca30062aece2fbdc2233e46c1b13ccb710297f7c6adc092a50d4a7ff097d6b18385a4a117ca9d433b69727b18f0a79431ecddd7f629e47fec335666d827a1a5d5a02aea4a8d1ee408077f137c6b0b5cc431fb124c8e882a3f2316745cbed861e78b7dac8d8a5c17563f1a7b86b532bc8aca41f83d9828fc180e976f9ab867c473b0bbcea90b27bb89affa6ef5ecf0dd361e3a6e05515b286181b46a122f49e5c719af706b1efcbab8020caf2cbeefab513b38722342c032fdbed564267e77ee45930001249133222c74971faff32da4b45d1237dbb98dfd40e80b75a15ef352e11640a12affdc24e5210a95aa968fd712c5b168b31ff36c71f8da982d8e6559a68b1cc055eda27c152f43b26a9f21926cdb7757f658c13f4f8f37e4db071d3d31d464a283f6440fa2b69394e135f3189aabb173343d0b9a898b83169fcc6bfe342dac4c14087b34a88dda832682a6e4c9a7938ec01ab0e245759387d23ba459f5dbabe06eae5319f5d56580f30c1bc2f8bf77cb304b02019ab806f7aefb3842cc2cbc0a7a715faf8c60845325b0d34c7ac85709e1d7fbbb15b07c07d671c1ada8c1fe8c25413b4e23e0f0ba4017fa487630bed1712eb3f8387f7016cbcbe4708b30144fe0f14baea4eb8062e9cf217d6a08a78743e501daf6bcc5b077976d6e09f2769a21c9bc2bb0d0c1a269ea2ccea4580ba6fe8f8f4f39ee4f1ba6eb075fce9fd554e019135117366d66312af489c8c7105b0ea4b2765dd0de4588206c061583061b1bf1e880618edf2b50c694ff4d9117b2226dd94bb27399063118f8c031736e1852d2a036485afad2ffb985beffcb20ccac116d8ffd25b2aa1a17f9f20804f5570b8424be3c3b1ccb16a5d6177f00475b64a7606df72cbdc09d2c28099204e0144fec0073ded51840943c3ac7be0f43b3c657de6acd5034807c2b1b685f4d30432bfd708f85845a181a4bbefb866937468f94c4599e36f1585a32acde0edf592030b12954bcd997f170415352f1923b52445ce595008ba80440c499edd750711ef417f9d9c1f2c6cc005785b6effc61d9aa8e399c7cfcafeb1a71e17c028f28e58f728a2e089a38c5563a0988c52a32bb4f517a200d0699cd380e97656ee934751f60e175b7390502a651fed58928d1eb0084d221a5896a65ce7e3a8d0b72f8b3441a5eaa279e350c468b08fba751525251459a23a93a8330740cce2d60ab88c6a4c15c3d698851d72fbea3675f67eacc19874e9b70d86e96a64f2f4c06876cac68bac14abf103e15809a52f244f7fe36f2b236d9c738386f44a8744c2ab4ab7bbe18054a1ed995e1fb298b97be114c12bd5e6a2d7022024d1446510a0f3e0979551d8f27b30fe56b86e0822d89509aa11c1129cf9ef7f0fc3bc1c1d98a7a8308e4c177795b41730bac3c3c32342dbfd8f715b6187a30af6ac842835a8448731ba355fb1229fc84121af87784a3a7e182f8622afea2a51671293d17177c9ee452cf293692e4413fca22c86b8a8e3c3d650e8cee41a5aac829b4b4557e026902862b4ef9a386ca963b3bae6003002cddf1eec7cecd88f8befc2018d0e43db9afbd7a5dcaa1be16f5cc7ed89a83d80f0a538d04dbc344681f0809a986e16643a8ff065a60de6f527d472b122d644bc26335a70b854e457ddc776f74b2874b2dc2741c9a2f6d2f071b8a22c499c26094e1bb3cb7aef3ecbfec0b37dba5b5cd2c2b8f8ec4d671c99ec40b6b85630672d432760d369a320ee8225ba9aa05ef62f6bad62fdd7e0cbbb59b51ae3bef44b2a439072360ee8074d7f057f0c4dcfe93fbb4ea5a6180c8b83dd5a8bccb59c6a3219a66491b414f59649f3b9d594cec7f7993196c74df0a287093c7045a23e09cd8974d8dcfd999eff3c44325aedaa257d7b5a8451c715ea3901b731e1bd2544a8ebb6cc3eb9daedae4049d5e76a20de0540c87cc8dbba37a7f11ed44b4ee692b55fb7c027a593db3c9616d06bde44af4081baf6889e31a2e1ca3b4d42bfcef13f45e1c25c4d57b8673ac2f3c5cbf0b0130eeed87c738f6f777cd1bd0694d8aab9c5aab4b08702354ccd97805060a2a88cad91d1a7533a43ed8254c5d48da9eedf1590d573d2252928149cfc8dc9bfc9f8b1e2517c0f4472389d09947347678aa5e354470e72fe5a87e4773d29b7bf87017ce31f6739ce7f87f8f6e7c5d0a5004bc8b5b82fce8b7743752d7d44fbcbbb89188bd35a605b0c3cd12aa8d77b523f4473afebcd8344dc4c2ef0d609f08b5497ceddcd572bc4dc0e1f40f300af37cc5eb6c5d1043d7cedfc41ba26fa31e3988e5d93fdac83ec3dd9b0c3fc0512c8997d200c6b781a1f9fd299826dd4fbefdefe6cd10ce46da543d2fffb8bbaf5432dd4f335eaa7e0182cab0aa47eb6bcc9f8c7313933e27b91ab6d43bb443ab7337df15d70a2afca0b8e7441152bd1aac10817680f83c3df089524dcbcd9e813e9f39bc896838d906bb692937f1daf310858241ee68db00a0cdd2349d33b64623415a96a31a1d666c4858f3f45dafabcbc55a4bc09eb7ab7a1926243d8b9a95678b06dadb6ee4c83867315465560c4c5391663e14cd6a654137f6a319acfbd03c1fd515db79db71d46365b498fea5fc0c13185775bd18800a711cefc63fb0f3eb55b1f7355e16a0c655d89d3139925b945375122d34e4c462a22885e77d32f17a445c638a64ecf54e4463f6331ecf6586eb982c8bb378d09baadb8ca48421a66d5de8d8b8e8781ded37520a91f5bdef90302defbea7827fd9b2ac06e041bd5884623d2b74e5197d8802e6663a829fadc88af6cf1bde316bb0ba46cf8a7c6dc999f29686a114f2fb294cd484c5791ecc879e4a5fe3ebbc7567a60872c8503cd302a204c742306bd6797ec442eabbc618577d9186eed1db662e9a83cbca5c579c1136ea1ee5dcae82737dd32f663c87baa31ec916d0bb4c98dbc5007c8fef90569e4e7f0dce2b2ba501b811a60e99347a43f704a74a324fb202e5f829e9c5de8fb7824fa56070141574ff04b51b05079b09a5e8c2337a2b78769f99947e45db12dcb7ba227559e1f001c123dcf5891b43ee492d691e22a7a487a64876a9b04457604574d29cdccec2c9b05c95109df1738a6022da66f291d692e31a375f817d82e14703488c8658b501b28faf9bb1ec92ea8929b6798c3b8daf4c596f8df40bf8e76244e42531c4d749cc117915bcd581f912376c7007f93492fc053a94d2177a1b11e7abdef49872524a2aba0795574706b655f85cc1a443f3fa5057c8acf2d9aa8dee6d7768206c48b2977f79c78447266b21f2de6d1a650dbb211f271b8b38c953323a44e7eabcb92408b5df9e4e0c76f04eebdb23bbb704b69243a600fbd6622bde277ca34af4e3d2a38f96370f9e7a111f1e75cded1849af7263c97ffa766bbcf26b4bbfd7cc9ea980c82dec016c259bf06b94e69a814521c46c6714664b68acc1bfa184ecd054022aa711b9c7c43c58adabaae7ad72ee083ecfc93ac378175c7317f718280fbc2724dc5a17e3de2a6859487913997101c7cb7e8f27b625577584a880b7eede40c0622bcf5e3d7175c0892f01a0d19407160ac6fd56891bae9b43409091e6b454bccce65cf6a2db5fafe60ff15b51206d24cce8a825abf617bc54ea17f27a07133bbf389b7943df79c4afe72c03143240ba9a969e372de7f6aa2fe78b265a43eef38b3e198132e71c9a34e3486e9b7e68f22c2d7c2e45014df99ef29cfcf9cf5618f6f285eae8e019995c8b11aa6d1d6a77f3ca1a12cf1d9f2c43da84590d248e4cb7e8fa54c2a419f620447bcd916505649031bbdac74a23cf1064df8c13ea174bfcd4f3047fee71d60e1b931515da45e05a78dbbed0cb1c20cc844986c8347b02e4e9bc8ac4e570c0c7e54a688b26d253dd8e2042b0aa878695e64002b1c34581060162559836613981b03ae0872b8f8e568ffd85d1d7754a59bffd17945783d0e99568d3e8b9c8b9857cb16c221be89838e10208c2dabf835bf7404ffd161bf18990dee104aea3eeb24eafe27aa54df5a92bffccb412eb9eb59f508aba02c58cd9df8711207f9e94f88da2142f35befc05185cf3fe866753d0b89c9d5f7a898f3be434b9d41f9018deb102a8e83b69a85ae460ca9a478768ed48c663c3d0fcca09aa8be39df1b68efd402269cc8ebf8aebc544d7a55dd1309fc2027a81f0a8f810f4cde55a3d7a80831fd2ce0ad382f2ae1b3ba4e34b92354fbb1596781057ed101666d4cf3bb286b12db03851faa532ce70e3d0381fcc26b7f15a944c782b933d9f441925aeb8a45d363b3458cf10d2294fc79e300fe8c567a49af1e354c54cc1d458276806c4de712d06be579298f6d2e1cf1f78aecb2b4438a261e89cd4b738fcada508204f946abea4058ca5bfb69067dd3f62ab337d042fdb984b05d8613276f77359888fbdda2a2bb4b8490e1e5e75ea1d652076dab36d5a2cbe05f5e5b4a8959912573c49e6785b169f6a1698e908658c9b740e1a30d321a13aed1b17b7b95d87d296277ec8f1d9d48c7b7426156ba71b42cc94a7b01e8e607806ea4da819ae13963d6c724ef00216ca635f3e78e2bac43c0903b33b262b4d79ccfbade7dd993f45b5326059ff3bfe2c7b996ade35ce258e5b69b62a5d6820ff2ea13a48eb342324f44dde6048da848696d4d6c3fe0945e461743aafaae78e11e725df94f04a56622533c9ea51f87c3124dbb9dccbacf90cda66ac4d90606e7bdb1f2309310bca8ee10df7170ed5828b58102c8e13996e77e1680a5ca051bd4b95751fd61e734f1bf7f2a718399637756a195875f6beacbbc54e258744fa7955c40e6da0c581f5e3c27301b30788d6d3dfc11bdfd10bbf136539394dd456abb0d3603200057e01a11814cbc02534b810ea6c1f4fa2c9ccdd1eb2a883fb18dc388e4929039bd98275bb640fae04eac897d2a522fa35987a1b5424b8d070d68c0ad3e972a8fe7a6b6466c43bfe7992515b77a1bc4d2f6afdf377d6412ffce7cf0a5a7253660a78a4d66409d7c7ade8b250d7c21765d72f8e2fb0c47c71cdb2566088147ca3768bce16bb95ed315972dcefae743f95c01958be05ff1ab82256b5f654895d3e24cf3cd6de97dffa54d159b624ea6fe4389d8e31256d36fe3ef786fc3ce0190637853fa8ff7954f47748caa68598778c8ca4133faf19bd8cb0256a654888104000fa0386dfc1b484c58d77c3117ca27c1895f94119675083e71182671ec5ab25b9c8254a3be3b125ec438a98d879d7d72c1538b61dd0d4561c9046ff29020b610d0d8d37c3c611e313b50bb0a5708873bfbb1dc0bc15424e8621f26bceb56196754b5c6ea3072ae1fca87d1efdcad55bee1364a6ccfc9d05e27dcaaeabc666d7611a807a9c2935d36d7052f627a4ce4e529e4e501afd6deb4757d50ff3a4fc2d34d6e9c5ab49f285f27ff8d150d2063d21bae8ce198456c55252489acb894e150bea9d20440bce52ea337e4db067d4d120a049d226ad1028966c289dc68efb005c77853f16c429ade6970b8bc97c66e268d9c03155915902654b1a2d648f8cd25d66623b6928349c594b91b0b6558f01f6dbf065d1900012e82c5a9fa7065e6443295c0e03fa2c3794dd146485348cef0bb7280ed137c46b84752f0fbc5a5b0346bc5a1aa17bdb2e153bf456a36a4d2468f9c06c13a13ff59113f5dca84865ee7faccca300ab7541270653b55a7bc149443bdbe7f177c4ec6133fd29166201db962f8450778334c5cff4a5b85e616ebe28f6a68800fc9f5f95fd2b5e21cffc7236960eae1bcb57260d8ef918684934158f94397d3ea8f3b2c35922a641c600d15aa348ad7d2c6a5f65e02291e1536d9554e31a99d65ffc1c71ef366f3c6cb3066b92f921ef9e2c83c40b8265a42fbeb8fc4ee2d16f425d2a55df48ec290ee49823d6ed425c5fae38abb85fd8c49fd3adc396a4c00d8ac53af1eeac9689e76dff50da612cb4fbbc37add637b56e3ef9d680df7c2481141301772013a766e6f0275a528c60e13206ce3f3c75c7d10eee4b59502f5e687ae506fff0479e8c1f3cf29adebe4152abfb5dd8013b611eb09b5642a3bef6bfd56f240fb721becbe449b38e12e39811c2c6dc5ab2d9d791435df55353d115039a390c71dbbf8e4daff9b3ca2511116ff46054d8aa77039357535ceb52ee0adc1f69c158e67e5af94f48afc8d99cbc37a633619d4345c1de69da709d73ecc664c6241adb9aa9b0e817a358815e3c8c7e4678b7909c4e72c4d2994cf9e96a5ff7cb9143b49afce5ebea16d2d63fdcdbf414f09ae1269e7d722bc9c01a97cc908e40fa3c5e4c878e1e6e8835cfa54ae4d20971640646ecca52813acd0c02fb38b6b3ad5977fd51078cc4d60f9f71234850a233030ba2894577e86f2afc2a29d70b8042c0787b76efe38bc6e183014e8aac93c3782f058b61163f83c239a2e9144fd6f7eebc9c05aa3e0bd79d6ea5ec93c7a6f359d6de7e921734ef340d8d2e3902ea1a32d67329def1c5af2f7e0ed52e4a3e3b4fc3c51dd2afe25852578235b59ae17b31352771f674e4a8f14943888d5e497299a993781d0e9551a20469f499416c31601fa718a255250d34fce227c2f8a4f6880af41ff41780a8e04fc2571c241f248df5bb6b553c4818be3cc11547af2de4016480a2de358a4c7ad409861754fc1c57ca2619c600256147eb24c27723042ffeaec387e32f6fee127115678a38c55cb148ce676fcee052fba933ac12fac51d0d2ebf9f0f1ad38b00fa9ee1158efa1363ea31c51159f394fb3754bfbd63bdd7cf8bca17f55016cccebb619c80f7ab6d897e9d112e21eec5db9b9107803549797a49e9462986fc9fbacd7593331e79411200d7638ec837b9261e492e4691ff66587def8cc5dc78e53734d37dbe6266eb42bc40bbbb762d7cd613ad4f601e4d6646e10ff1e51531e96cd326d2531d673a30c9a93c844d5cc3dc78e68003d292583631ad652bcd897fb3316335476ebfe049cc46237eedc4049e5adfcdc5470454add988b83bc54d171b0ab740959e9f53cb108d847e0a5b707312008d24aac83b45f6a83f40444298e7aed3d75a109b914beee9622010332c295069a6ff2a20e72ca08f4466803a180d3cadbb5abfdcd9307f905044d60fb680f474d31b0c905da48c9d085e1c7c71b8991ea17a513bf835a7d7108b654210adbb87ea9f3757ac81fbb9feddb3868dc74e1bd644b78e6ceb69e23bdecb0d6cd8b77d029868ad5faef5997f1c7890c74c23596b665ce95d34918ce5e80001589e9b3b9876e38eb8a8db40cf59dc49220d939beb33e896fcc9a3d5ad97daf8148fd42ee88dbe164e014494c35552ba2c06100be5208e02b0b62b446e9f11bc98b175c65c95baa9e7de291dbdd516485ae41442ec48eee62fd94cfbecf65563f1fbf12e4a2bab73037a6b50ec220e3d428c07fa4be985697266ab7c9b5973ff30dba6da2e4e6ff9aaa198f80e88b05ab392eb8147e5af032b65a2506cc6852fc5b136a157e279c1ed36119beada064fc8c2e468b142355b7032ca0e38003e992251b37f1530ea5498ad73f2c9ecb61c329b89069baa6d6c01fdce80ff0f3675f8859843aa64341b84915bd82c1820c8bdcf05cb0cecefa78c4897d995bd55a1b48996aab00e5ad22aff6f38abba87dbb2c50c810a79d2e54d6cba3ae31947ebfc8d2cc10ba2b2a5fe2ac2e6c4b4559408179ceba1e87b5052144702fdf8fa84e637138a58f8432566d57b73f9eb60cb97148e69657203a9b3bfd99ac66f3dd5201e773874ccaa9f21dcdd550cc74bea5f3ffc887f762187264203c8aa5a5a16fd500387e83f93a04dab8e08cbb7f07fadce71b47ff6af764944ffa842d9d17438cdbbf5f654c1952cc538f103abde45712cee631b19bb143dc1baeb6cce1ca0b209a8f88a74a9dc5f3e792d9e98e5a85e77b77b62a7218e2f882aea6c6081ffc66e4d6192ea98ba3e421e9febf8b2267902fdc25090c521b0bdf1ab267af7fcd2d8f98c1a686e01888cb5d15f477e1290d5499c39654c88d1575806724c1d189017de211881e262c1ef6a93cf87c592c828c76946dd6f635ca39154ccc93bb34c70f864ee2c60b435d1365b3ebd19eabdec4e472352de1695bf528265285bccba1dcf72a2476da5a9ab5cd60772fb5cf0424e040141abac6220b962a264671400c8fae42512a3aa8c8a3937e532c7463301788746ce4fa7f60d818db3bc6416ef1481ae4bb0361fa291621fe710b22f8b344706a73d3be36f218c3ccd33b460d514ff38c9aa11dfdc75133ffe21d6f5749a51bad57af3e954cdb7e3e11168e216d2a30c1d6b7adb6dffec0316fc4e5bdf256afeba92c5582cd3037d7e60a8eee2cafa8c53c44c6cd48e03f11540668b387b93fde138063deccc08c38c702798ab6c8694696ac25f15923d7a570ed068d178c25dd141e28773a3bed34c53a656ac9d2af97b73cb0a1c12027d3f8bf7b680aa70902428bffbc21893f5cc618928b93667430addf6dbae2737b0b3605b70e0d4feb2868b2b35353fd07883b67ca2c38462225208eb324f7f90a5153afadbb76be72823ac5fb187fe52ef73af289fffc6c36630366e7ed2db2d36464acf33251cc159bbf14df4209291347671f68055b35d8e0312ffe280918974f5c55eeee144113d54644330a20af2ffca62e437dcf1a82ac326fdeb0b0ab77d2c6552fd8c76ee9d593318117dca70fb26ae6a7d699f0eacde636109be45f1c38fe625933ef972402831f08cf80a9798c2c36ff8e2cc025c7d9d06dcd95379ac518ae341c947ff522b538bdcc955c11dcad54c3bdffdee8f680d82923ed9c49a2e96f084f4904cd51c3526fd280bb6a5be5be2cd51abec5e40cd8bd80c91fcc214d3e907ad354fdf8393ea5d12df8b0bf690bcb571c24f649a5ff71a36c9ca5d4b0d903c9f4de9f13ed0ef9a3959e0fc6cf3472ec624015951273c2296e279170697c411f1236dbbc372cb670b545eac8bc715834924a98d9bec8d4575d262d452c695ddd7b5eff9c0a3b10bff8194de5294303ede0caa8f755b85b817a3ab2439715bcc97376b65fab2251162e31b4ba4a4801ce797ea828d8458b54cf25501b478e366128eb1cb89903a0bbb520e8cfe87407aae7770fa225ba385c6709dace73aae016ad62ec82b546392daf8cc15128f81296ed0ca593e38c0ab6264a6cf961d3b2768dd7bc1e1b7d3dab3d616f10955c0e434bb4c093a58b0ae6f287c2f6309654f45a5c016fe99708620406f31403289cf9ac41707d759944a6ca85f93d7edce7528e6e6a6a27a5094c55dd4615bc62cb7326df69efdc2b407b2e665b69139606135899c1bd501cc8f69a8c5617f758405eaa90653da791a7afb78665e2463d1ae482e26a28f791e612e729a6c51e5c6971561343f3e4ab7abbc083af2726248f090a701fc9f4f96614b5d28450c826cebbdf3838109671e73d2d34829593605740c7b5811ba96559516e2b9bfc6fa2353d9ae2c71ede3ccb8232b69ae6a5e1e849364426fde83a22c66cc54245cc2d625875783ae033602ed6df50dd077604d317fd1d75b18f0c7ae95bb50231b8ebd190ba6b4558ebc28309c2cc5974d44cbfa2c65146aa2dd8570c4a33d567ddc843d3cca4fdeb436ceefb65c06e3d8193de5977689b7b3eb1138354a1a87ae6b814157e1a07138472cfaaf2751576d6fb0d2ff8fe03d93dfa73011cdda3798bcf402a881dbc1e9f8404a0dc49b4b72dca72d20ee2de21125aa8f321b3f247b98618b4a3215ac2134770ebb7b110121783739c706132c374a528d0578f9b7dd89f0f557f20f2f9d4ddfab1b2a21c550603198b7ffb0cebf81f19200fc24b3bb5fe4ec2fafd480e475f7bfc2c3dbd6863662dd9d316b6d0820c1c0ae120c7770ac1eb133d01d4dd446046326cca229a19fdd368cad79462220432dcaf93eb5ca49b4dd33ad9166f73bf92cf8dd265f7cc45a86deb44bad1a9f32806d46fa7a15cf91590612cd741e34f1bec525b692e6d2a078a13dba7ef16104cbf660ddd2a71f302936c03d690af636d3f6e6dacf097a036e97730af9554bf7c0cf03f176b9db581283ecccc40da9dd153df5494e3a71ef45be35c0a104e8b4b0f1befd4cd0eafa43f3bf59f83f58e947103b21cdbdf1865fc99540238ce481e1a57532a717f80e748dd4036a3d74076fdf3676a7b2374e615b5a444c5293fe35b5df1a8357f38b256ebc45e97552d7133678347cb603e899eb7d1a9bed6b7736f409e6400f8f6b08cf7ddf9bbaa8c2d032274c834d1be20b2bafbafe4a85c5e4dad1fc8c6cc3bea5c30f91ad131466b3527c30ea54c791766dd2a7b7a220bffba16be875744ad2c9e2dea44ce5958932c344a6d1fb5600ee127ca282f21e387c31e088e8b923635ed04b4abd1210a9ba2262e2c6d799e7d32e772b778e8692a9068a9b0c6a12e3a69f2bc08d1dcc0c13d64bf8d1aa63be43b143d6435d00dfd7199a913b4c1ccd1052464f3536f6711ddf8898735a0fd54328936bb27f5c8dadb692b68b900f0a0a4bd914a8d21e43b26f381f2c68f9814dc6ccdb9d760badba2bcba629edf8648f6d159da9a6b8609b498bf265f5035efebb8901c455a4bd8730f115fa97aa0f65bc9d4de8c89c79ef5a4831ddfd1291041b19341d35610f7ee381e53d1f3e372bc20ca02b6787f34fec48b1defc8f2e9868ffa9a3dd9fb34b4b528b32018da8c0ba6d2c1fab9863cb24f84df8a2e7a113be72abb4a162fda45909c8e827b884a573c1838458d396669ddb86f49a0b2b7dd6db94756cce918587a3adcb1ba105501d7ddad53ca22a8e3c066e3b9ef16a13b059a9e656af085345eff591d46f52a5d30983a3bf4eb5f297a3e6f24111002f7940b58d7cf21c83a311a9938d0e640878423836c28a7e91a96e3378f7e8320b589580e25c2a6da7ca0114bee7adf9b093f8374084e9c7ebba3bd50cb478b2473d9411e7d10ccc00140a0fa0f03e9d3c5d712da77263a5ae076eb9d094c66035592bbf9587f320fcd54b94485bf9b7aba8e4ebb09cd5654dbf81b8639d5b2f40fc7c130feb5dd83a4239a6f154d9b63c7dfff81c0b7d8b50bb8164c860c40b08a35f7eb1bb6be408051b86b1e41d3fd74862e7f45b81545b76922762fd13dcfaaeddd784c3654d62b08d3aacb2c972f92c22811dd569d3298e67b228565b8b81d4b6b2a3bf3452ea5efe657f68224559ad47c2f296a1970961caba6adc37261298dc7e8c2ce7187665326de29936dfab1c4ea378b7f9e58e251a0aba8e4407b94bf67b847d2eef0c5cc0edb44952144580a7b3ead524818831c8dbda0aa213ebdede7b7641e21a80419484f5ac89e680473884b4253c027403d98bd0b17707b37a2375f7da7b3afcfe6ee45ac2341b2920d8e11c073cc1f407679561e66cd28b5488e55abc9835361b623c89b26ddf4865d5df2d03854d0f0320e1ac5f2e047a5a8304018c7bbd15ff57ee1db2927c20226fb2a3675a762b7bc563aa62ee48365bbfc548308a5dffc788950b4cc81c2b675a59ecce63e31e82ac0cb176e2f57a159aabcf85cf1b2046065d0090769f68bb401a82972e3dc2be3f045cd2c2a5c629a869e96d79a95c6f33a6d09dc67d5dc83dcb2aada9e5d2a77b3a694f4be525422e5779f65923c64148ff1f6c27bf7afb61ede50daa40237772456b2dbfefd5e3a7b197976662b6cad069c275cdfddfbb31979323678c5b7ac98f684c637bd24643aface639dcf5c92bf18f2e307ba9ff272f9e62fe49cd0c3bd7c1d10096a03f6361eba992138d320c91a4bd89443c802df6309def351bb414fbf95a6391e8bf1f6756ead198239dfb6b4680586742892662c5219cd0b78fb61a39fbdeffb0b2c06fb87d7d9a0e9ad451ec45e03549626648110bd0767c891804a541c4c04c01468d3a85c10571b347961e0ba99b339f34d89f1e350adb7b41f2e86ff01c4e5ee2568288ea360fda56372c36fe81f2374f659f36dc296cd0d29b86d93ff3100c7ddb8128ea39b8e9d953eefd6d4435246602ae7ab9fadbef7a91ca1d11f5ad34306463e0d89a66ecfdf113b04a35045c9febae9a2580773a7fec7d8fccf26891ca063bee6ec67ac5c115b0012b32778a11c1f2d55b84dc263c4dafa65938ec0f4e0868488afab0f8772704726d48fa7349913cd8fb108e929d292dcaa5f9e2db710fd077adc6b45249aac00cae69d20dc9b36d5d89776f46a46b8b1722cfc4b320275e4a7f1c7453b24236865130d4888573e21beee9672fe85fce114342e4b7f8906f9449f0935c010d31c1fdb37e1d6489c9acf6a2b0d111f41448036a12f3cc6718a37969a8d0da43784b1e6eec3bc5660009d19e8f0b5d45dc165f9769b424126a9422a31282b4362c43632e4cdef74f3eb893e380521e7fb69fd7111172b884258679fca50a5b907c643e1fd420bf4698ffb55910343a098ff4f1e30b55f854836e59f976e76fed70b467da60eed6c4a7339134e609aa06d63cb6b764be879bfb7dc0b2757ee4c2bd5a598d32856946ded1e9eac77efb232d4c33c3480ebba6371c50d7b5858194dfc1d42d7ad397a4cf2b60bf8fb8d0b56fbbfac4e3b5207d97edcf3b869e617bf60159bea82ff73f7d3effd85cb95d2730169e100f25f22ff5d1a7fbb95874fc1bf0b1a2b2bc0ffbebc6b2eb7dd0eeb804183aab2575a6fd8f786729c53cff2e2de96704b9dede048fc4c970d8c15e8e3d46eb778fca614449f8400f8fed183343944947cb8053735161786fcea0a00dde6b5174d5467f449dd688ff1bed2bf85366eb8db290d3ad48a657d5e4393a8df39e1305510d0eb3010b3ab570117853b5a5234ef901b7a7597be25eac4cc552a37f5852c84c501c94d77544514192667c098ef5a0ddcbea5a2ff90fafc56fe189524eb489783d1642c3f99abda2e155f3d50a9e3760d1717d2d623c649e78984571a62fd8dbfe42d59cad904dff214f9f843ad23fecfc52069442206d07b8a1464d1602bb7a73238d311b88cec4e1df909b06621ca3753aa317a8089c0718303eead63e82c3aeb9304df29ec4b2059cf8541847f2cadab4e3fd020c88c8140ec746247b92ec76fbc1ac836eb1f745143a1d5f9932c4ba49a100a652af5f407c21a3c08a49fac5143dc8455c423bac1cf7ba9093be351a66609b4bef6901c05f1cf7704c0e514b7a0dbb527ac8d41963cd29a0a7d742f316f49a8d472f31cec085317d86dd67e8cb221ee7f79b37c155c0cd4ba34d12b193eec66c0cf0b03799bc0c34d3e5a73587cf59e8214d71ab5989aa91e49caab598a823cdc286a7def23d5d679d04c6fc89dbd059f3c46f325148b7339eee2ad491e99af8db80b4385647c0ea2c36ebbc647449e635b7a787724e3c3a2c2db5d7947ad0185ec26dcf88e87916c34ad1267de5235c32089e2d6efd6571789ef1f92b2e87be1cc611c09b1e2348c77291a20042422ef107c97be5f4dce66eb6f06cf026425f817c0f3c4ad28163037442cba66afff10aa5381d3108416d821354d4f466bdd1e30a630aa8d3854af099acef431937e008f9769477b6d91d41d713cafff16fd272edac03202def6712b349902bdc2b5855d01cb1131facd0f8cce95a960c8981ac3d5795c267932766ad7fe5622b0b5dbc0fa81e4bac6ba76b106885d661c1e3661f1342e49a907cdca3845aa301eb147c193cd554ee6784942605c0211ae85f6896761e0c61fe59e76ea30b2da35f47e59316a6af60af8f7bbaf374972c4b4290468953320cd63a160aa84d697c33e48b33adb6c8131cb21a70707c5f75f93d8fe09ca04eb3dc99c26013265d425e7e076b9bfbf174e41d527f4ca9c45a64e22f3de4d636f3527acc5356d0ebbe13cb4322c1c1a8ae97c2ec08e0411f0b162a2f69da5acd7c0fe0660abc3ae9f2a52461d735282c5b22dab4573b7c8f9d08f2a423b1a77fca7255f4dfdb86fc77010825cbfda36383955e987f6206889fa978fc90acc914975366f380638c524cbe99fa1ac17a1524ef8edd0c9b8028d9bce37c2488e2cbef9c25fb08ca5620721a1d83ea1e496db3106e67b557ff675220b96102bfa8cafbd7a6c73305a2f50cb77eb6fe987fd26065440a3e1a8c0fe3ea67835cd8e5dbd2448256f3a964dfe69bcb936c7ee00e09771cf005b8a284d77dbd8f8ba6f67dfd765713fdf9415a87d8b5613dae04c518d6440deac9b26374e96fd2e6bd4d4178a34514204014154615127f2a85d536d745d0a472b4a2ea6273958d9c46ef7654ef726676856c83038a5ec3d2cb155cd31317dd7ca14a3350252be20cb3f72e5017886ac3190c40711b356f0b05d6486dde3464d2f8f63d4909924869d21187ffb9324191a16b3f14d3daac2e0effe3b5d386246161e7cb9d200d999a2d00496167a247df5c32d26a81b4a0899dceed1e9f30090519d209543145a4af9a18d9f8590ea47321c077e01ccb094ccd5156b5d199d2157d5f0a773dc65b5679c474c7662ee22114a980795b4f729b8bebe3df8deefa2af2ab10cad6808a211901c1be42c09f98843381601812f0ab7ad629dca49baac7f5c6aaaa88461d9d60e1a886b50549886fd793bf51097500869bce7321d6bce008369c2b4152fb72ea0a8cb0b241e53413c66b8feeceaf34349b22a47014d46e4e7398b2f9bf6e227435bdb19b3ef3c4b262374607217cf2868a0632f6927e7e2d69cda2de0e1d0ca8af503f1ec955df1cc052901f62e3f40cee2164e0cd6a7002f93ddedca28fd402db3ae53b34506aca2dca7c9a19ad3aa4a4695d7b0aac5bef77ec27cb444c5fd2adbef208d3927d72a6acc7b56f7fca4c5cf6d119cf0ec4272dd5b05c9f7de412302c169a7f57d9c05e2e2c84b28faa56182b10e6687d16a8d7b859a9c52be33c02ef4169168e74743c9be8b1d5e2ed27b12b989363749d2526b7735fa804f2ecd3ecb433f818f48b5a19de59ed1df9d152a3bbf61487df273db909a2a2b4b0acea3340f48c191d4e873bf6d4b5e660affbdafffc12f499a837acfc2deece5b0a9ff92326b94c94ecc663b8380bd4034eff1f3c5eb849c94b9f8b7c9f2c46c59ae2e81dee6d777c37cdf5382d71ee41fb867aaea3a51a723df53ba898e174b377b3c082201ae3c5588759ccdd8dc073620cb480cf3cc21b0730355e19f4b5e84aa7427d5c34ea40d692cd270ba9f702d0e0ad770425392f3b37fd878f328d55fc6a71cc9db494c529c209dab03394c6d5a607c70acaf9aba867726a06cc5f37a8371f9bb7984402179cb145433eaa843fd6154374dbf4e4e510e6c462d4bc259862cc4a246072c386dc96874600b2bb803a286b6fca953765f806c9c8c3355098cfd54b779379c617efcbf2e1526815077420060e50d7eef2d69b3520f6c66e2878f35c87387569c57a860c1f333f252775584be1e667c46fd80d1e2a2cd026b6ea06cc185e2ccafcd1d131b6455e54ab07d9d1524ddeb1d71ec328c30a9de644c8399268940e2639801151a64f331d6745e0bf0e07fe03293c494ebc977d79a5476c657a71408dc8c6536158b992f8921eb8f428db0be28bbc4f632bc06ed6a5b1f318750db83aaa157481ba13689e1fd5dc26645532bb2e9a72f733d552eb6fe2a8e7a986692390940de9918ef67ba18373302743f64ba8c6d452100aba66a4ce46811c7d838eed9d3d153e81a981ef9410043a39bb2d54a58a9c91f73ac29cf918f58296bbc8a43f36db4ae574aa1246ce03590e58220b91d47365195b0fa6fdf9d3bdfbaa4456bda04a7adac5dead2db3b40a5dbb8dcc5429862e4f0749f408a223bada3aba8b0cd0896220031598b26808e905a0cf6ab110ece45d9c2b845b45fd87e22017fa59c315579f9dd1fc8f41b7bcaa516f10dbcd56026c7fd51fcc82f131ca6b52dd81f80f18dfb068f95490645e31814b80fcd958b58846b24045a28b8acb1f7501980e84ad9033a357e64d874e48294047b02e53b62171729742238eb621e369646338cfe704b8a9b8fb0f515adb82f4b18760d15f8bb01199579bc2b38dba657cdd7e9339b0bc563d9e4f0d71a009c33d86895e5b7ec02d8ea8e4767dd6d5fb16b6d3e002af8c527bb1ffb2028d90ed67a6031d8b96cf2f486f9c01b9436c2e75cff37df03fb09a586673a2dd5c668f3254f3aad7d3770ace7af1e70523a90ec1bf197bc541ed5639c694c9860e8aff72f0a11d311b478e08abc27e2645a8bd39518078c0bdd71dc62a6ba87465ef94014ea81d61b3d796b4760d21378082e07a04b54ad15cf20a73c4f1ef6a68d3fe2e38e96d43ca7892a766ac55132c6ad9148abae6feec5e48da173eb571e320a377e95b6799ef6626c198657ed9a7d7574349fbbfb0e01eeeee7bf67288e4e4b44993a633f49594f1ba3e49ea36d2c511f0dd0b020acde358079a1853423fd3f4d6da88d0209602b0651d6065c792feb757943d5028ef6f5ac0f60f7bee0bdb4d5758162618ada840c90faa9f5c4f777797f000f5e2a286e5c4611c54cc23cbbfd517c1b9b4faed4f0b826c057377bd99212918ab9ae86c179882080a11a6064a9d1a34c85682b1a8f6f8d0e272fc721698a8996ac5eaf9c0995730ba307849c89fd4fdcf2eade26d7b85d3ec9dd2da27d48dc2e3246f37d19faed70cf3bf7cf3bcae0ad71dc6a9be86548189b2727534f22b999101669243a9aad03258669bf8a386eff4f97f20871e2287715f5aad9f11875f8e57629b7361447281389da657262b04ec8c6a9a7fc4c10f859b8b935318dcd5939d1957f864c8de26d657aafc36e24ddbd1817d9cc197f2edd60aac1532194dd1b1e51e697b549ab04dcad1c47ce43953ce9faa70211c32e9c35fcaf8f3618981834311ae435c715eeff38be153dd2757e2047644d360cad12619fe7d048a746a435612be2229af7b1010c0cb556fc41592d42fe39c82cf46b6478f36e99fa0b040645cec9e55a438d12312b903ad33629b993c61493adc8695000bf9225e9aa81a58a027b4507dbea87637c5fba00b38a0bdbd5cc450d05a5cdd5ffb11bb0b909b3fb6cc17de687746125b4135c61ed4ce11ca7aa022df29f17a0a64335bae5863cbddeed4970ec57c4692db1c8e162cb7493623de22ee10b3f851242a1a0eef84d38e372466559f762661900dddddceec7eedbca5564317937e942dad861ba75bd1d9bfe40b7ad56e094f988f8cdb772baad9ec0ed783dac4b3a353e5618eb829625885a59975eb7c0b8bc3fae7fcde732f5c99fc52024ca046316efd2218f583caad5cc1f8b3cdd089a0f5952f908ffd5156b48b8a5d5927674b8ba77566222a6d9783a9641ad5e3a73bb31119efcfe9b7c10d91d46e9a634be94422b7f5a1ae578d341dec5dd5bacdfdf3474ef9e35aeed8b02899885e79ab878bd97ab3503bb5f2ddb6f4a92f522662aa7fe95e34f2e6cf8d67d704b3de45d577160771c8d45ad6dee9b39623b220b2b30efcba24bf731c72d6a1233d9e5a6ff551d7256db83b43eb45b66fd8f6ee0922190b7ea257cd4e917b9b3901ef2eae58a61902f0d4f3207a975bcad8cc096d12598ea8b62a107a20de7e2e71b38c81318c305132e840a4de46576cfa7fabea804e7455a41cbd2cc69d9a4b5ca3405ded86322cb280844fef293182ecbf52d2ccf29b145e2337f9e0ed4f5a9afd9a351aa66afceafb45835cd6c425e6aa43f8de0f59155ce9478ee68293128c9ff18b5cc8d6cd539ead9e1865c1342f84050a24a7f6201d74995f5d466fd9ca491e8b6a5da971e50c0ab073812b777db9e2f2cc682f65dc6a3dde327482cfa1aafd339efcca7052c34fb5cc90d915607f69500718b50e46e12741709a7c2f2a80f099f08554ce5a9d926cfab9f760335aeef61fddacb33479aedd8f52a4fc24c55b2f70ab149ae52c8cb4cd9585e6565e0986c1f22c8ec1451110f5715301ec64292284b10e53ca611c7d4f5cd6d89fcf130dc1cfc4863119edb348dd771d146445c88eecf91974fbc4479c7413c5410dacbf2aebf20e89cec82cbc2011e59ac4221cc102beb3c8572a387f67b699a76438ba807caccbd0ae8afe746db78eb9ad34493141fd5bfd7599b42e570ffdf67a5dd65d26da0f5549fef5a2a21332b788754886638767436f7d96cc48c3f3377a868fee4dd9266af556e10297615654d5e18cca05e5b6763aebea8bbe47d75a1463f7f1fdf96e7fbba4d8cfedf5d0a971fabf3798d0f8374b16439e5b699c96bb67ba349800448b9262166560b3f394f2448e0d15b7bc1c80db944a8dc869d9244934b844a6b919b6eb5f128c950b0b73ca83c5e83c55dfde36abcf7e577e45468394f70117268858fffde401292feef198f83575b78ab8d0cb26f4efde67f488d612fd75747c371c4345678c105d3def3e0d7658b11d4dec5e0e66e079897ad2c43339245277bf8dbfae985d81eab97a54b794286a19d9dd5bef4b6417f2e45f151d4e7839936c505e80a01dc3415c4ff0dd74a555f682a94f8ea960fc822b2953fa402a26d992cd7105fda0b6f031e83186607a978c00576c277a603f6651a94d71c3dc09797ffe2d5731634b077fb4b80f25898bd6f710093fa22d4dd5ad749826877a4834135828b533c107c63cb22a81ca604083c5e520021b5b642f17fc0952cdc33a984ff6e06d1e55859c4fbfafe437f2f95893a2cf36f9771960ea383c63a4b1ad0861e53457e5c2f1770ee376b456cdac67e8b4d8bc3135d39528c310b685d0619aefcce9d611bc8d61f5aa2f578731840b1d9a209e3d624d482500295745788bbdc051267bc7fe2f6d9d768fac780460bf5c2733afff46188f7ead6dd885d353b8f338f822939ac1f75338d0a9b45251bf1fe0bebf8d8b16c85909873522fd56f162b7cfb6c6d3c035ebc02e067455207b46a4145bbf90008e1e3e68c83f16240af45eff706394be119e266bf78a19c5d8403aab18a4d6e1fe2985c04dfa1bc3c9e0ca40b6d477e15a21384bfe80cbf146eb9c9c7c43d0995234a989f9db6f2ad742832f7efd2461433c3619c3255d859f0b802668484e5cc1622e7d9b937ac7436c8fcb4b5ad80e2f823f210235b119da97312b1a7a7c30ba3f6b9bd39a8cfae5d6d5f8b539b6c7d107f33388dbb9768e30d9b1bf24487269134ba656be249883b4b7ff7f4dbb049e2dd0273f2fff1c47791a6294d3e7528f5647a642ba1068cc694d0c4216e84d83d9c2534aecd2bda3384a0c93fe2652a6396365835c70a9247e48afa1eb91c0fcb91c1733090fc04b6ab922b68d0acb597a99f246df7f8b3fcac65c1aa39a8f6f6cf55125f49cbfb0ac143ac8535d674c013a22826d32b189ef51eb5517ae80d9a08ce93b8b2b09a1b4798dc4e2b5a82e022a0a850312b56362dd1815128b6bcf94d247dd216a21aab0af7bc75b91602598d6869f1d8ea42c91d404a85acbc0cb7facd72725d73d4bc6e2048f1c31378018efb6d5e6de7e1cf231b2f6ea94fecccae38c6e31b1c7f7125e4f8b6c0329c095a97ba4d9e6b7ee01278b198d1c3d442df05bc5aae1e0e9da02277f8b8105ee4c69fed50409b95c7d14da8163e8a55309f6bb9d2ac8d8c4cfa679b0c397ef40f71b2a6666be60685f7151b21d4ff55ca1632c7354a6b7079916d7a861dede143a882d770ed17c766ec68387dbc6fddf0091ac87e30bb84f0835f885b3241f31af14fb55fc87523962136710013523a9b2a743b0030bc86aa39235da7111d05e3f44cb8ee7ba1c6becc9dcf67c96e24f9ee07931472d0b3a6ee40e1d34e6664fc941981167b984582e0a1f7843064705a7d7dbabcb1958641ef4a3abd2c527d34e5aa166282d2d3b65f356edff5d73b2e54d7a18609db8d822ff3c59d837b15f2232e9f228a32a64d7aa09e43e6b1b6798346bd5bd4deb2029fdc28f650571e6ced6b74c233485364c32a3c692f90b18214448c22651e2830af2430027f62dfbb38c18a0a2d8baf19846f51475c09eadadb3ad6cfaeb46f84a4272e341667b4a905c58236e51394c0c46b42ce699486263dfbc4c1456f0e693fc24ca5728476074f28d9b3e31e7ddc28df6a10d450d7127cc991105026fbdd42dd4fd03a951bed7540cf1ef809d5a2ed4b9275d5e07145f81effd78f08550f3a01f7174d3ad42ca57f1d3a0aba89c59c65d08f824e3d240226a545de2aa0e36de494000c941de7b759c7072dc477fb394242e611b642191893bd4963c8802d2d9b7c1dd174a9b94e22f34dabb31896a2bb9bbb18fdf4de4eb97455b387da5468473265abfd7f3164a11a1b7860c67a389a634da9dbebfbfad3816808b1c82715aacaa34fa4c78c6996d33a0cdf735140adc35b04cfe85342cda05500caca683263256ff79e1c54cadb45513c7019ece762fbecafcb035cdafbfe2b9f4a7e7425efe4ca77821cd967317658803afbc4271d8066f7e7b18e9222c56ea503cf240eea8af86c76c68245f0ec6887e7adfc40ef1eb0fca18abde6deac0a2d5ce2ef2ccef0ba2cd7542448fd308487c4f0e2089fce42185d56b7f8cc627dfd27473ce63355df338c40c7625e81d6c5f0d66ff895d8d453313f9d68911309d377786e5b7009de40034066da78d9af7a60a4338e7dbbc0a32c87f3f90202cd6a3d670913e7be35b3a76d16c234a0d88908f3b3f9d2330ce63fe792525cd37fe55c5a03076f217fb278d9bfa096c625a6f57ea517445c173bc52bd1479f4649a5929dc11ae5a3175e350921c557f58c7a414891f043530ffb876d9e86df7f7bfbc1e03fce3c6061bf7ecaaa1a2d9042a4bea5afab84b7b4d29afc63a963bb48eba71a2fb40f3af01415fb82b5c0f686210f2e6db14c4c7709957e465faa938f8b82756608abd756483fed1f5e47e126671b902c6a53eda70165c47bee02e6c66b0f4fb13cfa8522418f009910ac3d89084beac4a12401f7200bf58d22f3bfa1214c5b5b5b458038757b07311a34398a7c4f7b6442cb043851a17c4d14245df219a37bc220b19a797648f7a6558a40bbfda4d410b315b5da10e0cb673314605d1521d0157b858f0ca3b2f88d11d52af78391b04aa3d70a38a2adc6af69d3af04e56fea1cfa127e5c81209fbc9b1fbb54778b36ae88405b7a730d80c1215a37a0af1942ad9f3bd2f7e52e86ca5db130db0c1d97d2904917b07b6e8e2f8ec06a28d9e4ea7730af4fed6b66c49e1c95171b153469e6e4b707f19ad03cfbe596c633553ce87b64ac976c56988b4f2123093d005260f076c63f4da6ab81cc21ee2a7588d6c51de6ee0b0754105c1dd5f6f4b70049a50b6480d387aaaa99fefddf940b066b2216e22fe4cd1a3fdf60cb592df6c75374a5b5177ecb2d10a22fc8646f51167df000f4f8d91b4f3602a23a35e562b868545622b8ca064fe2623edd1e39cd029640417261b1c77d672a1c16661dc8e7782b88be79e082634dae58a01ec4d53ff6941e2c5db21aa124b8b7c23673886981ce0d12cdfc6d65618cf95630399b594498f675522402e4356c677f3065023c4ba2a772fe9c3717d6614d925cdd58253111ab393ebdc021cd2f6657a13bc6ee4b47287623717a28e5dba7420737fde9b05c530245417718854ede3072b6d692fd6085691a97fdc062ae3f82622a1ab331c5df0531f48747c435d6a1a2c60ee4fe28ec275046cff3d0f6d2c4b8b5285457f9b4daf321282ed5be34f41b86266700ba24eef7093bb80e3e0983d64449a120ef8a582170314092b5c95f1b9e77f297a554eb6f81d47d88eb035a1e45cbd0adb4b064c7dc39469978a76ded7eb5cabcc7cbdc50d5d1d698fc5ccb84b643d56ac43fa36b5d792bc560ef9cb04eae81392c683bd0414cde7765ff24d58c155fd7da2e7f635f05a0774aaf39ef1df48c9cfa6312e935017c16942aa12d1454ac1fc539fb719ca5b79d2db47a3966297db7e11801658d3e038a3351408ff0a806b0c4f0e679d9ff585a1bf479eaec25ee50a051dda5208b8f1f1d1b9a52f5e25cf4248384ea42897d1eb4982483841839ed4e48ea0668ff10433a0579632bd3afa6b34e6ca342b4a580acc6f37f7538f59b1a3385adb549d11e1873be0dde20e1b049bb2fef89b11162fcbb814f3f993ef69bec8a0de39d66e838d92388ae37f6fc0b85d73bd4ebb63dc26113ef71f0f3339069d47ff4c2efc38e13f129659932b06729307f536072d6a8fe18d10158ade523be5b7b29239e1303d17b2e1a137a571158df23738461f844c391a140fe21758778e23d05d79eb329494335128403b4eee3850bc86d2f1aa53c22c19bf6c0de367413113382a2017106bf24fc4ee5d21a7d172e49703f4b0aeb193f9f56ae60159fd029d5ab6854d60853e48259cd7207c0f2aafa27f1e3c32eeb0d5587b3cb20f1a6071b6ce1e555851992d4f51f4b63d5d4b45b00c004b84e7598f25ff976b74ba5af98c6c8f44de70fcf326646f0223bb096f3c4300ac72d7af4e07a3f5940dfaff7f983dea46292ad3140f691e556c39171b66c49c83996795fefa7d2f0a4a5f81b3c43cb3175031610d940b29b8d5341ddbafd577c859f54bcd4378409d9b5ccd2b77793a8827a54ade28a03d64d9bed366508449c61fee0fb06fecbc9361eabbde674f10007159d28df3809a47c2dbe31613b2069cf9fd40dc6bb48723a383cba909917af858c82ca3a987f4868e80cb69c8addbbf7d0ac04da914bffb990feaca8266807e4545f7ad7c363bf5a17a2d814639ea760134b242513719bb0c82ec6835e358b3f44a7cbc1662fba148ab52a4f91e155d1f57c5be89296c78793c2708d893c64debfeeee5a66ea947094125bc04b985e38dc86709ca8ce93a107a10191e873016334431c2fd716cdac7d899d7f10b02cb4545222e3f6eaa7e7d50f56af092176b69f708f0b9cc1b01b8b04da8f2569caff850687b40f683b4840f91ae35d8dcbd1d2ee28f840c01961f571c04b13bbf78d77cc003d4e1c1c26a09c6ff2ac7ac1380935dc55d299828e97e9267afdf1be7a8501b1f43f84f7f300ece584c26c8875f3cf33bf96ff87a06e46e6d39a9891030d08ce8beee0f399d23f81acddd52c4788ce39e2aabc802a369d559e47979dae2d661bf146c953019447088a089468f1407891f625ea16a26dc73919f883880f0c3b7c6721e4618582e9d4b1214253bf624dff43823881307019b1f553de112983052653c15e89bd38f57eeeeda8d339a89bbd50d7cbf8d6cde39321ab082f5ceaa67c5eed0fcd515149d623c21e674c431c87fb1ad7e21a264bc9befadb95f37ae835815bbe3d6d322697c82cfdb0f5f75c6352372454759e309511265b0dc6655694f4ef8a224d8560c72a3c4a7aca8f6033a5d966730bcf442eddb1a3ccc7c7d17225fc66136bdf7b26244399b02b3d8335831d51c3d50c8692e338d9ae20856ac0c59d813fa7700caccc5f7b16031d70f5c3581d985a8f7d2778ce122a64197eb8dcd62914fb27c9912cc6a992897193e97bfcff453e84e184c7a4318f48ad897e612ca5b8cf546baff57c4da4e86dbf95ff3d6a9a615334ad9cd94ae7b4cc1a4a098249bf8a471043d6fbf9cdd8d44e68cdd9050b03b90476b47d13b40180e85064c03754fc8e432dd54bebf72380944fba07544585d7977f4d607831821a47ca60c32b943a6fabfd45147edbf6aaf7b0eb37e4eb837e49a8b6c0b0031012decd3306205f92e256e780d22920912908f2a28a5909fd42a10ea583d1d89d0f400261af1ec8836e686077697a0ab22f09138102de10fed3cadee3d1347758b0411f9d93c667e7fa4192039966691e6caac26e34f3cc01bab481b8f3ae31cc9b230eae538bb5a95276b47ccbdb9be9b27a263fd17739cdff52416a27b4bfac1243c5fdc347f1377c45565059239c66214ed652c7f86416ecab4284fbe0e5ea679a4fc5807988f1185914743596e547da0d4274b222e8256179ac221d2e4eb449acd2ed90e3d2d8ad4ba1a266719a6dc6fd3a3ee1be2e6f22255f318dcf31b01e7aea3b0baea3c597a75f5d7d5210c00c2af5c22d85f28ac0dd4f4f78b40b7193eb6d00d8ead8134ee3850e5ef266c230681d834f309b50b6af69d267b64603f14a26a0ecfd3b5c94e2a85a5cce7c1bd56a91e9475b3319ed423ed2157f00a7b9924ede35309054985e75633e15d974f767a3cbafe5ef2a5b547857cb9317c6424a71808201d90bf5f4e66f5879e918127d7c329b13a839d96df2d6fcf6ed1a85d726f81c334ed41ac19beb6c055e492faa2497af1a9238ab54c4ff9320cf9e0e5d4b837aefda2e69ea54a4fabf2d917ea3be6744a7e431ec0447791977b39b86f9f7f58e980ae900c4c5adc7e6c4f08618ab74008990cace010d9652c44a762887292cbe899008a44902289ffdc361e846d5f9f5c0fd7e78645cb2cd6efaf6388e784b766b5fded92c13ae7b40b1584d86a81391e93b27a96c04685a22a90a466932e167b69fee3b5d21ed7626b84d3a19147fb7452e264e50669e716ece0da673f2a5961accfa9cfe3ae0087f9b3639173de8005b95b30348df6243d14043fe478571e9eeb326e9f63b0dbdce5e2e7a0edf7926d7d4af30914d3798f80b9929dc658f476095afb0abc49482ae6e75d323d48b3232e8c221e018b2c263f8e775f67142fee527131433588b7d6a0ab4ccf8609b90b0134343a8ccbbec8306715e47a37ccb4d412510d1adce30ea7ad522185787d52010912bda8e5adc41cfc1037dbb067c411cf15fb2e9819770d7d04fe8f559862d7055c2ad050c3abf357d210ba31409302aca09b3d760faed0421ba08c662c044fd77a6f3525f55bc05a1be44ab34b1470a232efcb114f22d935f367a1f5c3f96f6282c873a4d6f29037ee975fef5bf5311db7a717692dfc9f245abdb84d3dac753ce46e7fad988e73f6c327e3e552cd937f1e001463531e2df0adecf740c7b73230f27b79489afe7cf212a48a59672c299b88347847d67e640f4b1950a4ed6b75bc30a90b1e89c5b15c254dea5179c0a43a3fe5e340e05a5f0a4b9f38d1b590d29479d81bfd110f94b73fc2599876ffda9980eebddfe806dc00937e7325cb02d41dee8dfa57217b0b5a177fb73fcf09f5e9197fb9997d5da52232a97580bbf8e8f3b9c5aac3b3e055f198212917fab6fcced177dc449a0e3135104faec843039e63a5cf847b366ab2fdfe316b3709fe56e1a25d799e91519a13ec807166ac1a93f1771a41dd77ad824f3867207c4e2c762ec668cec685bb8c2aaac4bbc8354b5ed42a196beb27a1af919ea1d504109c09b68d7ae2c1703ca9fbf2745ddd94d20975ebab57cae8913abdfc151db24cdd34ee0e04c8f6bc846d9c21065e9c7fc024f4edb6fd46ef7804a3e56238ae9082e43f9d27a5b36d55ac37828a907d496c6da30fd17a4d335600685a8a46e2d9032b84149fbfa6d77c3389e00f64fe8f51f5894934a17030703702c109d07e8c69ac8ff3305264e981526366b0f31ff7253ee0f259a765369b40bd2a8ad87477b183a446be20e50340932dca703be6f5393896d3ecf48749ea0db8eae252fce81fb9fb6133970663f51b5ecd4520ddb2763ad006fb1354936b3e697c68f112d3ee54426ce5be061686e0050bdbaa8ff08a0463ad9100ee62d27315bac1d1f3ff0c561ab9267d0988f5fe4316f56d0e0a199c5a702c6c9bbd30865963bd70a456df5895f31b5d98985861cfe8889270fff75d73d3a20d467f22d2a4f3e1a76b2f3686bf181c9e1f44c20571a1e26c4d92d9eca1577dc1fb0a0c48bac8b13353b8e8761242255f6edcec1a879275cf4372e7be8b6ddc116e8b4e553299dd66ad69c814ff3f308739d1a17683a02f89727929ec0c385bb875c3933af93adf3b8a8ade256c046d79980822c96af0699e01f9c687b11e98cf896e93e4ceb9b6eb42c5251b31ddb1bb87c7105756e6d0d49715753e3e304db54a31f4e6c3bdc38defcb31f09a7ea774672aa3f1f673dd1be233a42c29552211f8192acbc241f509f20c7765e8dd7b0e7b2d165b09b7b93414753edf1d52a30ffab0747f069ac9d36e7724a3d0db255a6c45ad43e6e7aabd6043093a799a03a45b995e549ecad879c84fc15efabe8346c687bb91f8975a6e82eefb8ecff2998e48c160a1ed2de3122d1401f2837ede9d796379b53a4099e334581d8a65e33df993228bdb2d6b9ef60c717f6d7bdc9b4358e9a85fbf1f74d2bab0bab5b7faf0b5331355a3e7bcbafd984556966850291b9da44a102c6ab8db57430943f3df7d8fc225f7107c87dab947b8bfe9c2c169186303e5983cc63d82d55285737b35f7a6fd99f050a03f76b3555b3636751230f92b4f20dc3b1c92f70206a077674b408c485d9a74d9a0e6c04261c515627990ce5835b9ca8cb4e08b2d648ed700a2099b289be93404340ff750e17a99ddac12ccb3df0bdc24a62e8fad614b83463ceb28c6ddc347d1256389062c2ec230dd0ecae79cb9060c95465b5afc1e776cc2863c73be86d2426d3e2caf2f0cf7177fbf8706192b8ce2c0ed0e12683c7a5674dbd81e26a5763042cd31dcec9b8643e6d1000226f1bf58633c3c364b49dd22ec3563e01d7c6fc6e3fba6defa2c63d7af7f1935144652b45e336d2a0be0469cb0654d712fc13a04af282b4d1ce2b7eefc7a7bda9a318b4f3ce9ead8285f8cc89722f9af552c4f3d85921a84e3c9a7137d37bd91501152167be8a42ead974d5cf9cbbc1e7d3f779982bde82267b784c7485ad4dfb387d30c2e996f9ba52c8a43b1eb0c63944d80940448358a06cd0ffe8b5a63abc31316c6eacf1196b0b5af1bf22611c82c23107d00ea3a643eebe1a2009da9c327d3d3ed07dcc2179af6afb8e78656bcaaf29df8a998b51a8d75ee0f3994bc55e9307ec02bafcb1c08be869f2943e4500666bd7c6908425c671f2f95baaf3776bb82668f2af8f626373d378bfd77b3ba1bf824d62207869c3cb3ebfae723c09ed3d6a441354b5db9c6eab0ec69726dd68bf71aa5cb6826938b05bdf5bbd4902a52747ccf57b1e3df95423c63187c5fa02cd53edb5180acba06865eb453edc1d93ad0abc7473974a6aff407480851c6bb09a0f642d25e02d2c8209e5749ee2650fdf84bca8263919d47552f2411a9eeedf4d022f51e531a5d99613e72de3c6d968dbaa10dbd83665bc61f1b37357f2ba0a6c71ce29563ab22410b6b8ff67c9c980cfd88dc9f71e0f9e5de6df3c3004e636e9b6e4f47bca9acee9474aae13f39a60020f113d822ab92de8bc57f4c4e1e67732125526c4b47ccaa3fe3b3f6d111f41d5437a374082acaa2367c3560784f03854a17582d06d613ddb59610fe302c1a9f350a139549a2442cc9392425628c317b3a009fb88fda59e06693186c7563952d29e8fc6735d72bd837998eb873860e27bbd3bba83cfb39a71053986b3802445a3d388c79864aaad3b05b6b6146625ed3ec4615bbac3c927029ea52b8c00eeba592730452512b74989ca4e592b4790555562167d6742a078c1b187a49000db3198cd33a64b8bf3d798181dabef72d8fabb68c4161931f802e856437ccacb1a86f4a7f184cbfbe3e3e1c915df8bd6fa9313a4488e8a8dfa756eebf28eefc603acb33411b5dd7a0b5d13ff5356661b6a55df535f1152f176cc1a6badc77d45abd018a63d480ff6663fc4ddb5d85ab5afb11c7e38af6272682eebd4858376925e97251716b6591b90c325bcf823bceacc27d04933291ffcddf34473696baaa1e5a710a3f17fc1589fa6d4fbe88b97ca83b8d90241ccd99f840e75be300daf61b103bffcca747bb8c7b1f9603062e4edd47ea404150a8c6d3a2888d9bf912e5a6f181284bfc7a45135e262f1fc547d4fceb8cb2602abe96e9ca10bae054b232b54384eac48c67959c7adf32b944880f83d3dbef12d91d4ab3bf40744ddbce19b132b52cc1e13b1e9b28411b6837662b19cd5c8adfe170d3614a077247c9139d4650f58d711892e48dc40764470440aca54af509ff9a71293c7df5b296505b92b10f5bb7e163cee05c2ff253cc451e7978e0bad32daeb1e00029c3501a15197637498b0ff687cdde82500e016f48466ba4ca53ead99fb0c72d66e32b40af94510fb9a150ef5fe334198e15e2ad929c4d6366e729f73f427fed0f29e6982bf43d397fa9c2965729ec4a58d97eaa58d77554b69ee1d7354549b0437bdddd8b164eaea0a51c2df11c340e9dbf111e04816181e0b4ec817fa98722e6991803423ee9e084294eb4448e3b44544f2cadb6ca0057ae17ad1aebc6a5481df2577bb98be0bc7781b33278dec888f6ccb0b1c02e992d0f98892e9c036605d682bca8ce47c935286b761c4b8e2b0cffe6b26a29e3698c94aad1ca8bcacd343ed1b69050fe65f92c5e1d268f1c61cb707211222b1c7c11f4b7289b04d229d348ed2f4e8468280b7c648b61a934875b5037db3fb61e49c988fdda7d25b2e45c2d861e69a32716e5f382f2ac142df54626cdd073eb2220cdcffdbd4c62cb29b1e70efa2e594f9a39d1b17a29dcd596ab81879515a1067632ec807eea047d8e46b4f2bd6348c00d993b659fa5249762637172619ce3cf88b023257efea5ab3b6e99d96e278352000db8a585a5a0df04810b5f46976fff00e55f7fa22bb59751b7ddfc53b813d08c32b5b8ccf91be31a54e8ff59df39b37acbafcbb7f8f8038041898b56ce76bf417c02599ba3f3a89679a61557d5e69820cfc52d491306ac0cf3ef1e39a81bfe680b537feb1a986a26b666ab875c52b0c2d876811010ca0ac213203f9987e72ab8ffc1ba56ea1142b9794c630aed0ade12df3cbb5f4e047180c374f7ec44b3e0b3334619e5f976287bf403d3c487d24df1c9b7d8252ec76b6b20067beed8cbc04f1b44a0a0d07744e29636f0948e21a5f2ec2761715afb7aedb536d92735704d95e1ff54ef8ad388a7af188d9383a0058af8f4759284dc170cfb25c2908957945bf11ed5f541e2a2c49bdde4797aafdf800427733e8e790bc63b3c5b702129a959cc2e7f84260c39d1a53e387c97e094a641ee1f57cb36157646a523f55501f01d731f2b51a050795943f9792b4f7aeae1f31c6f37b64ae1739bd0e834b1f137b4a7c5727f58bef707d84f0b303bf74b0e91a6cfa72b424f6daaf0ca86407da50404588ab934fddcbc878588ef3f86dd4e44270ddc057c0832de7c5169411e6d3534f4a85beec664ece963a56f6f8a5ec1a05dc01cb8ad66ebd4ae8f66c8c05d99a41a01741f66acdea1b819088e19dcba01a94ffe5e5caafa270759a8bd443bf5992d49995540d1aaf8d49db55d7d33f8f1937f47936481f793c9852e8fffe825faf6d3d9f8495f07970cf71fddb7646cf64493e92f76dd88267c47d944396471022139459b8b0f4a663914a577f7b496440bfdab25951a1255698db936af8e0cc8be8dd293a2d63071393afbbb25a18a3fd99e6d6998756e842279598212c99fa6c12ca59d42434e566d403c8f5ca01312c49a1d04abd23497f8e2ee7f865dd4af810ff292af2c337f3add6bfa69b69e5f88b3cd4dced33d8d83eea9e424ba34c63db6074143b1afd88802cba050d6d3d0013d8067543f661c1faf91f3787be94c92a03ac1eb84c539464a8aa5c7140934b29c931966b6c76f69dca01a03471d3d0656b8b8aa8f2500e472ad47baaaf904415aed567ebbe1e7c596149eba75110181fe825f15dc52aad7eb31c3c5c76a72f8bf46c7ec086dcbdb3b1f80858e2daccf8a1735d6d5c4601872ca16bd34a863460b3de55437d355164b71a7c19093061f6d80d72ad8a270a5bcc12527c602933c2d076f2eb48475245a4a63bf0e036a86e1d687630cf3b3ff38d64dbf9eba8d111bf3224508a7d9791904d04218159d7dc67485669856c4abd720f1f341ff4c9fae0c03396ed5a3cb68494b05f51ab15f05598f2d1dad9eb1e858a46676ef26e31690a5fdb8ed2f977b6b1b33af2966ec8a80894685390f200807aa6df8c20980d8096a598a23e99b0d87a9ed6d1cc0c9cf357a522322d7881a792395fc874e3d5e46c569d9d3105aa76b32c89f9746fef098d1872066fd7e5989e81b821ef4821973381cc9d2b09bf2769e4cf556e17658e2332f3ba2261b708a4772755bbedf3213f2b6ce2db0ea1ed644762b506182f521cd27d53e207ea7ea06c1a27d8886caa9894e289c261656dfba36a6748e57057d8b6152e104452360e262785e15ccc83bc151a31798b1407574f2da1b018b6b2c7b62c73a81182eb065659908cbac3e0bbafdb257b7949aa6e6028b60259c9abde5c4f78dc91f9663770b409e1243562e94e7d628ab58d7fb1131cefa85690c58c4b5a486c18619fa1d4b70b98855d3e3027551da97ddd624d642ed60e3b74a098b772b3cb100e36e0a50faafc5c723c7f9652e3c5bc7a9f834690c39abad875951de7379a34116203bf84c6548230046394499e7fefc65f9b6cea5651b58c6aae2d52ea432836c6b9a571894f9179cf92af883cb61270bce770ed436bb2893244fd964dd1a02e191d432c0b9d0f666c530379d37ff387764fdb96c8adc714c2e2c7c543561806db4c0859e0d5f355cdd430d97df86e26aade0d5eae485ebfab9d1e3a00c41c2d6fba0fe152e68efe315835abd902e1c9e247b5929cd7d33bae18749d0fc5910893d2e7f746d3b62431f1a52dc9343a1e49640b3edf42e48b199c67a1ae2c9b984afdb9fa5e833709d8ebdfb76f5867062d8284342f8c30e9b785f5887e0f78d5a7dff2ab5d1a01f83d6d1b24d2e4d4cd05c91dea0bd28ceded8a75a5d7ed6613850959d21985a19149135a734e62e3cd0e34a4cedc096b438d47f08e02d4c8f051c20abfed8742dafbd915c3acb550c52ab1bc93fd3f050f2db60805ee042738fc3c8bae740d0cc32d404291eb715cb07dada887f197a16abef74f4917c98efc5653766c2c9ca8dcdcff7bb169d8f4bea136e2bcd5363deb0b4152a4c52cbe70766cdfe50feefa95e93ee91e8f990a5cd6a5e4dbdb74064e8eff8fb75e5c6c67f81d602952d567f66492f7e4cc0bfb2051d6ef862e7b9c94524bed45daaa6f88f83ffab01b8481187a12e2aa6fb67921ad4942f2acfac10d5578738568d9d6e4f6be1637ee0fa86940dc9910aa3ed298d550c6682748ba25241c53ba45f721d1614b84839cb41a6356073829656fa9dabd7a30459fff3cb53606508be832a7f19b36bae4994bf61146fb7211501fcda756c64e86388613affc11e5dd9728d1019bcec9a22a87c489e9a8365f6976e0e9234ade13b765b855574b00acaf524d21aff8147d5c7a712555d0e9b9573b82d514c52354773b8a309ea8276302b3fc9371111a523631819af4451e1cff9156ec3a4f51b74466170e9d0431af8b44080785299d562323ada87f568acea942eccdc3ac541c3187f2cd61cc20326a74683c12212ae2d3a3c79201e7a42ca307285a95e0646a2f127fc4c498654f711b1e3cf179d3be7a2b83ab077154178b84b9f92fc594116746b687f1361c24f41b0b54546853b0d0e8e0985397716fa4d8a5eb21a7238b62619dbfb2e7116780b5893c6efd4a05a534ef3b39f6887773620cf38fc04aa75d0b827e6b6eeaf2cc90d1924286311bacf79ab5967fc2ab1b47b41e09c26063fb4f4febf5d61fdfbd05e699a431b6708b0b9066b62d9ebc64b4bc77176d5315eb52479c19dc407f58f6ea81c20e833a7e16e7f1585488a4e2474b759c27304bbaec095c16b83e6a599347eb19b1d37df9236b4af0ec61aba8d5e2d4ca91acce3863fb2ae2e23486a49b49adfc972e9126d78e739b067840ed68189f91231c9e7ca4f1297fdebee09cf302c2aba9ff3c0f2ad7e6ed20302eaf145ecd20774af01da65604166da2ea7c0216a9de179b556abd583625da8a4daaee6c0ded6aa2712ec5226553ead71fd8b550b6b79fac2d2067024b6a399ce046a012d9d71954fea7cf7551341f0b6ef6040cf9664f25e372377345553c4b81985dba4fcaf3f3666e62ac19e7b7a0e676feff5b26e4f07cdddfda8c78d47ed9d133d585e6ec8615733a1a3d4c9f51e819279c2acf5bee934da851c128a7ecc7f7af0c0aab7d7493f75ef15b5e5aaa00ec30f01a9502a684b69a74c2662bb0afefb9417766d73dbd926ce995bcbfbe161eb007ef085019ada79599be3edb62fde6977dc34209ef6776560938773ac456df61d8aec2189ca1cfd028fa7cd9314f3779153800930f0290b96cab42658bf3134ec7a334168f70e6982526e06356bf368a5016b5aa612baf3b5ebc3ea37597d6dfd28a51f84529342833383d19237a00fa933e54f391777f6bc0633cdacb2f940967097becec463d9cc23c181aa4f3b5e587831bf65b1ce5e850fe60bd77b8aa384b412740e65d49fb03963a0a0e04dfed423690c3b04b8ed995e7f5ee1f9fb9da9591e75cc0666c8612e65a3aee8beaaadca10bd2a29eead2e3048e28d8701a242481dad88a82813cbe273df7fbc394685cabc18cbadfa24f923a96a00108410706e3a740903eef46ad56d97b382e4e7d6c0c589fa0f10ab88be3238b89940cbcf3ce5f61d004c82d9ae734b54b8665801110db01545b4f34ee7355829b5b6eb43275e60723f6fc8deb888a936ab3fb9d963d1577e383b11c06bec2e6c0f67f92629531a2592bd7d6b60c3c15c016d50822293c68543117dd07931ee07e46139403e8cb3a480483459b90d60ac3061b227fc0810e9b8d5ee9e27cafaf28625f1c3e8a73ffec30f7892f875ad81044ac493652465725b450c47ec3d8282daccb68cace7412cca138326f70e7be91da7503b14268ffee5f43bb1243fc328db8d2884930c7526383871d7b660d8986e30288884c2081a82db24b390a3ca8f1588a5e2aa43026b63f61de5d668d709c00c09a7745667a553ada4fbd3eca6d42ae3e1868222f979d6df15321c2ba07f2d58c60d672b0675ed054714f6605465513d7027b0b31a44cff04563f4d13516a5fa694325cc25acd9628739e4b2e349d2699a894e9349dec2b25246eb5e8f6c6cce4a313869f1a712ee67eaef3a9d6f8b7f233a791b31e3d42ec19d34ebe5e99a165169704d1cab8a1827d749bf22e36e37cd7dd1a0f5cc60b05b6d25785a199a45e35a6062091fa5041e468cccd1c4009bba50fcbeff3876577c04b74f5519ab133565dec4ae2bbbc0111d339ee828dc020a5522b53478577b274f09f540a662e5f2128769a79b9b51817c1e972f032e65408272d22d06fadc1f6adca482da2682839038d1247e038dba41124a29b439f45f409cf240828ba95e111866d257b31a5a9b96cdb2bc29c4bfd337120bccd10cc45a560a6c8de64c994347aa5430989f12be8755ffe6353e4856983b001ee2741ce0d8c375802014bf60157e1790b96752aab76918cbc48265bda6bb794ce7e921965f2bd545ff9f981cd649d5d9cd26a7e61509d20c67749743b6798c8d73ffdd20ad6b32c37d27f3d900221fa4e033ded3533546d3223b59737e27a084ac4da05e879a9226498a0166aca750c6d31f8e426907a1cfedfe704c9ca9f0b4cbeffac23695801b4533dd961979ef6ed79bcc6e12d4aa5436728c0c0f10a43e9d5260ac07edc46409cb50032932580ff6af4a3d4d60c2f25d2cf4c9bc1e774e05533cc9cbe37e975fba56e5e3fcdac28a415102dd25391037d45f5eea6542e678aca2a25878b0bcc57cf53befb1a9b9c4e957f0caa743428c1a3517c6ead96a7fb7ec4b05838f6eeec2636c1d89391a261c3089ded6efbe9984bb3fe05f09b23878e00732e22d9f41659ef5de59fabd099dfe112986d31c8f060fe1acedae21d6fc3a6dbeb64a965826da44c96b852818487d177eef64b9126edb02038b36cf1d0cb8358fb05edc83457b5c18d7a51ad3263f85f3472f8bba9c2a4f9fe5f774e623f16b0e6b35b943e17cca2875dc2c0ed7f0af656455d99592cf3aa2da3881a1c7ad1da8d9a5a4cf29725efd6041ef6f41cff7f26d144ea34838bb0f7fd678ce1e7f114ec43b8892638b2abb07e526f39fce557da6381e595bb02150b8d66583e3c03ff553e4f8aab9489e2ec912e369d42b3b2d3db68b1f855eebaf646410e9a059f817afef9f6be0c4f44328174ff50e62a8ee32d8ddd2e88634dc13f84ebf41d4af31a6f9e2da87c1c38d8b6b578fc4be45ee4eb705432cdc046d4fafd0d6eeac6743708b7a339edf33c18d697382f50d952123eb89b562e9d959731463933deb865377880f6462ad4d3adee726edc31809be20a70063c7deab7d16d9da70ae63c1ea34b8278f4674d276b16219455af0ecc0bcb553f8474b28170345757a7b3a5d951effa18ca2f04a96c191f2d1213f8a67a4034614df8c054ebf5bbed4b681bf65a218c364365d51e2de8d862d491aebb401ad36cebe0121a7a5fac533b90caa7033e45bd77c7c9f4310e83dc89a0de9f0cfbee92d4b4491918d71b461e0d2fd4e6697e2d7cd8914c843541065a35bf825401e33aee4fbf4db03589dbb9d7b269c1d67700b513cba218fc9da9e28ac43a32d48bcc1820c0e3813a1c5b3d4ed8c7cc679754dc045cb27003a545cefa2397da2dac14c1e2f28c29c2f704e89fc8f13a5349d2dfaf6e052fd436660d218a30a6c1a9226ec3ce174406daaa6de8a8b0a3136cd6b64f4b841367f39be28f1b564bfe6c99d67b7a8afd5a5806965c1670e828f61801e2477362447d75d7cc55decedccc9f12c57b3b673297858ba2e0351cc0ec9160440e3971a25dd7890e120c4292ea1d6a3ab2e320a772bc974ed8b06edac6c8b7fb5e46fe73b601fb8499d535aa9b9f6791538ae89f16a26652985e806705d732cbd6aea0357c9b77cc596c5003be16deda5791b9ce1526c239ec7b42e559c134ad401dc547f24769428f4892cc5ed4be7ac564eedc55dadede844aa2713f0e7fd01933b7b3719e82854d7d17ff11816e6ff407d0334988ed6c7b61030c8241c66922ca1b4c1826d6daa3015449f5f45b84327c6a7cbc1ca43a0acafdde441167c313fcb4b116ab885eecb908e4fa4c606c3eba9defe54adbce69a540ae6baecc68f6d1c9949f551bccad9c174411079af9b7a8870b025990842a950d0afdfe7ddfae71b93ecba14097766ec503033b2ef4c652e02eb84849d83fdf9969bd907bb9350f0ee1ac9b0e739039716e6adbb5ef0e045bd329e785ecf2a272f8b527edd0c50ebd0879b297ebd250db713c84fb8a7a3de88331112aa8c3db7ff927b323c1a56fe0c022d57137365de95212e21770965eed1cda004b9fa950c420d893f08fd7b3ef7b44b65d57ecc5d0dea37533f96b4cbe3c32e944c8264894e28e2733fd52265c4825952f0e5e621039085ff188170b3d089211aad1e2418f94132d10ea3b2537a1aac73f4f817848ce373b27a546645eaf9bf86f877e0a6fda1420f0522d28870abd2ef8c340327a306e6eb233e8e05caef04d7c0886ea47c65031715e88aac605821428612836ce94326a1c70be1dce90beba5fae8ff8887ad728a6872100807cc04bb2485bdfb7e492cba86220097cc2137983b18a24abd622138020a4c0a5391cafdca16633ee5396b953afbc563b61256ee48614ce7f61feda930aae2c52711bd82f0e70ae4f34466818fed5c57f516f9f9f53018e203162797d052256eac57ac136805eb62ddbaae43ef53a9ebb9b7b99f52fa20be76fac7725f703fe02c033f51f6d0e16d43cb9a953b52ab797ffb34d829025285815381dbdd4302198afeb0303876e2815b62f8a158c9fbc30487bb34d0ab1944e2b274298274dfbb3ae9f776d9a55b5d23d63b8a8741af6cd4b4ea534221938cdfb119e73a35008cdb4e9f411b111d85a5552ee390d5b87d5de5406a937038f354c0635301a8e9f64f10117eaa5f95bf4d4cec35bf685ee29b8905c5ab789891cf1889e1fb68ca8872a06873c699ff964d2b187ea9b16eeb50aaab3f573fdd84ba6be4b7706b607355f66135b7403cda104b82adcde3b0cccbed2bcba38a286c9b134b2e8892610d13576f33948f9f1ec2d62a27fb01751d425eb1ef8fd7edef5ee4d957dfaf74522e5983a95a9ef339dff36e458d23435ab8725a4409087a36b5e7aa73ead1135e83c3a62e54614ac6dd9766d4753667637a1cbef73a62ca6e7e981e7a270c24f4c7290427cdbe00a4dfbdf49317087efe23db5a4b2cbbad49476f63962023aafa9b68ad511b35817677eecfb8f09e375039191415afe6eb7ad5d1aea53ec6c6fa2963013bf4cae9237d4bd56c152f3a684f53683e9ec6d83cc4b72aba6b4110a357a442c91344b657f2914c4a7a3370b5c4cb18456c9349cc3096f39b85d0724786c5a1b332d4f401f7c35fe40e76138a09cd91bb01385ceb7664a245a0fefb5ae3bcb8034dca58d3cd6ced3ea81076a178bc80c4ebdae15dfdcbc66418bb58f94875369b38eeb3c5f0b00851bbb0e195bf7fab9cdaee866c12d565dc750e5960ae5144ad8b8afc93359cee89e7a7e466d7f64a1070640465d8a209431e997f73287e0141d35c0b3a0260f44851930bf98c8ce0015ed7be1942102f64d7457e367a304ab219e6a97f9173f661cca35596991fbde5d4d0395e1f40e6bd19da8455353ae331bdd55e6847c81c9dd6d0a8684bc635464279ae8c39724b01334e719d6a8e0c419688a3c015845c3962802a00be2ed1405f53e60180af159838174581ea9c6f396ed6d297f0f3fb66706da8d3a29d8e078fda339d441fd91acaccbd9615a558c5c5a72ec052a881c87bd72cb799cdc55f8d1e04478817c3d8a3d492173d622c65eb0dcf52d2ede3f8b244706a193105226db60d66573a865301fea46193b315ed61d72a28c513820203611a0be858c2bee6a492683632e5c3cf366078ac21f90497da2e61f5326de8f1c3aa9f2381a6b4f607843e9edfca91b0c4aa818e63d6a5e97086e06566ca1d49a7718dda86bf1accad97de880927ddcbab00465245e2a000dccccd26a8a40a90d8372334c8e31a07e988c00de3d6f9722dc5b55392cd1a718fdc123ac4588c566f140f29b12571473ecf620ef8b8eb92886761f2e4df09b59856de8713e2744f1276e6cbf649f10ac50ec4f252aceff665b300e27dc7b9719fc926e3f0b2063bd594a021c3d1ffdb5567ed75eda2f35a9a88eb0a8541490e38951f1e1a707aa1f9581a8a535015d0df906482be1f1a4e2841a1fa55082f9a82c3c52e6fda7f5d1c4293b8cb7141567f64b71ef7703ae5ab3f44e4b9c7b00350985863c16eb3f699012f3c3f4fa555300bf76940b75d3d9a7b1a313131699e4782daa6a4c72ccc334a7798336af59b358c3aa80c5344cefe630da1aeacc9f9c66f92d57499f20e40ced7ed1cf0fc9b8fde185f4da1df8ca01c2cfb658c940776468b210135828cee841f3297b4177c1cf22f822009d6ddb8ec284e901c6192c96115878fd94d496c1603f95da7b8743b5ea0af463c0358a6b1d8c047621d04ee8943512ac336ebefbd9bcc4469e47e0d858f7c7434f656454bb5f2dcde877cd4c96cae69ce18f4f807e315b209b652ad03a6d1d0e7705dd8425eec4737b1375ce8ab542bbf3ecc4b923c955ee4dab5f838925732e7e847aa6015a096318544d20d5f36eab3e99c745ae96a5b0d121ac58585f3ed18094fd47f41fa7a143e8b414cab46a813cefada3693afa0b7b58b99aab353488b32dad1b2ea815a17eb234d56f74d9c509560b0cdc69ca6882bf04750d58bdce9f421ccb64089813beffc8ead6dce152e5b7943bc7245cbd97294ff59a9c1897998a2c7c615ee5b9983d1b4f67df848d4313b82a86ade867e9c0bb3186fe9b99e975e1d1b5e6ad5e63370d5ee59aff4e09ad1b4a5e896b0c44f5debd86d9213da1ff1e9c4b57443be5d51b8b27a9d14d01158bbac0701560a4384628d6dc3e8d795705c20dab07af7b57d09a61959118c816458e7480ae772c83cff893ae7f4a60e210fcc2ef0f136c4c4b34db79820b1cb6152350e84b8fb3d230c5c27c93b6bd4f6d3ee36c214b16443dbdd9577c71344ba75a1223c1f6e9a22c4cd87a11beae7e89e981e952702463a32113dcab06634d2c1732fa5a573e7328e0c3632e41c7913783633665fe56c34a21cf782497057d24a2d470f1e5fc36782ba0ef3848f71aa9f6468020f88af7d83375526d51c60429a015c709313de4e126d734e24b1e9bb4de5d2d60b303ae9dc3da84fecdd72739850c8bc5ad07e9eeebbc8edb164b0c2b7252c51acee0de8656787459734a5ba483bc6cfc68ffe33848cf815c60fc908468654d001247bef44eb4f9e76f7877be2acf6e340144b62aab7ee13601eead9228ecc2430a8ac2fc4ad9ef4abe298021119dd9bc7b566905c801cb95572fe858d4d3aa1048b1c9a76c2d8ab7443cc2f64bf629a1680e4279993f8e7857da4339b75e8ba2e7c1a3887a2a2c4a81d0df13b7b53abf83771d3bf727b3020d6ad824f17443abc184ad12c746ac18ffdb78cb806de7b866c480d093ba07c93eca1fe368f61fbba8c23e27ba5dc9abdc41abc791e18e353cfbdfdf0b5ebccf52a3b61eddd753e223272e2106a6ec4e924fc95362379bacdacb3a9af7fdf04f72de9a4399159886518d5db4c60d540f227144978ad5e464a84267118da87c7b0f74de7a96c0c1353aa41501ec08ec67c1890a60107862e8e6da3dd7a73ee63e5f4be1bd93330ce1ffa7d7090fa56f4e75a907cada49606c82fcbc05e02a7d17f6dc88dc8538cefc295a5a29a9eb2957e4aa8c0cd8a956644acd4a2351846bd6681a833f7ab88130328a758eaac69f71efb628a55fd70935c8507815bf6e4a4f422d1d02063b4edd694c936a141044cc8d3badd57fc77b761b843dc00829f04a79869e8ce864189fbb1218a41a05520c052a045a5d4deaa86377917d8ac1793d6efcc7f25308619e2361c0f433beddf41f07a3e927b3d4c0a6f2e26a0c9f38d8a7208b1950b7c5a5701f8070a46a469ea009f70308411692407fc8ae64c5a16b9a2600d606c4381865649a33abd15b451adddba843b3936772210a69a6b7a9d8675cacf10889bbc395a78b2a2961f828490f30c84e0795807cfae534ce20561568971df5f116c457a903fb033f7652750531812e1fbfa7cfc5da9da2ff1aff7bdd933a21e2d3efff1df2e17c7e2cf5c92a672abf492c881acdceb2a4142b1edad04239f1da7c1a8b0352908a7d60725ff52a03a4b50532eb3f7f36b20004971618c08f13360479c369de8401525fdc00eb131bca0c3ef7b182752db81dd380fe7a1dd88d2294520e75976624ab564b405c02bb2558a546ec7202dfb4a2e427f54ec4f40cda6d6474451b387a70032da483f85dea6881e7cd734be10b77cb280f77042bc4354386396dfd22b14c324896fa1accd315b4d876a65d3f21c36d3c615394c1fd4904c00e102db60c2d937c8c56c023190cfc76521c24e28302478f50d92388c81531a7b47a22a56d338309330a15a091482d2f968cda356d76875adebcc8578f8464b1e439aee2e96b5152fa6077ea1eeb59ada21785d00f29b23a9c032e5ce1a29add34c20ab285ba0b28eace3a9584c1cb18c648e9993a77be0e8547bbee1fda1b364dc02b91115ce16c78f5b0e3d2f86894a644688c819598defff73ac2dc440f24adf44c20f43bf139442104f76126cfc5cb200f24f940c0e0fbdacfdebfcefa610099648b6dc06c1ec1aca0680a0cdc503642faed193c5cdc4ccf1337573fe2b419f331c6d3af1fba7dcd33f34062b05eedcc72b3b3e7c38267510867398cc84e9a2cfe82634b0e030c499fca5ac40be424099eb5d26233f5db3e560e5ee49d7a87936a767f0fe534b8366b0cb63bd5b39ca5f02de74f9d734f0fddfef26b1ee50788d279b1d457ce861a4c5f94762274294739b70d08679b5091d5681d05cb716f12e8ebb8fbe460bf5dc162decdad1be857f736a9fdba3d143deccc3cf21c652a75ad2477c11dfbc1dce75259323ee4a73c35c9e7ca95622f23b7b5ffd57ced1ca2b408ace0a3a11424f265081827794ae02bc8bf9a896b3ec36528d9c9c2cb5dc87f62e4eed903bf26d6282b1f047c488660bdd078beee0210674f990655ce31f04682a92dddab26b1dd683764d9e76894a5936a465e941d72eb7757eaf81087711dfeff9795966ac102169d3dfa1435c1ec5539c249aa66ba6267c3c6ce126d218f5f7269b0f0208db59be9477d7d7b64707788a081524aca6808147da67b78d941a97b08e4343713f878174f7ad9cb934e72a60a7f3300e2eb6171a99205a659d12240cdb015de9aa26edd230f3f08c9dc3471a33d2d1603d71e09721be16dcd3756ee3c0986cc732a812cec05df13c4a0d5c7804d3d5c6c4894ff444182d3c092e85533b1afec913f144c20d04d11590cb55d1881a230cda8f3dbf77a875908dfdcccd35dfa0249bda527d9be2c1022016825fbb5213a842444a01fa0b523992f566950b028cfb96af91aeab596db1ad9bdb9d4326e0fe93200f9260852dffa2fee6122ae252ffe7b1b75d87adfc7b6d1da9902bc91fb42ccc21129f7a8dc4d1545a78dca3a91a92968672dd85b15b65f06b13e26f512012a8e63275f6b139d3069e6fdcab3964b6044697596e0e6613801e86e6d2793b4d4633360d26c633f57805cd402586c634190e00f6588f96fac8c2730caecf8ebaecc0cfacdda08989e15080c881e00f50e6e1e09117f2e63cdc400cbf4578ff60176fd2941015981acef33d4df26c5c93ef999c05e30ef8875f958b0ddb53844bf355538f5ad2cf809dab9a5eee360c64ad9ef644d840cd3f0d50e8923bda1892e3a82c3779d5eeba036693a3b255b71f0c73d11e775e5c013362637c30077fb6ff680ab7cf68c73c8777bba5bc20d261ed0e44d12342f44c323dd30b0d57a2b991e76a99e2b4b64204228b164f74f310a50910f8a5e2bb660041c4f326d3ad5697183d46dce02c9a2b6b8874f205ef1f7c94c252a9fbcb41a67ac8d4542e27a145b506f60bc3e839fe424433f1c835832f450a7f3f46a598c3b290f476f1a0db802ebc356221c9f657fa652edb622eb76fb00b0b5b41052c07cca800eab7d5bc636fb491f781559c5f093f3d02b0775860d4be32548a5b7fb971f14f187c3e81be6f62a1838b60b21726a131fe5747bb1b539f3269c561503216319fe7f375179296be78e5f56543d2aaf0692a7256232c7d395937169875604156b646fdfa6d96ec89779f0a8609b94cad63263a0e3a142c5ee84428a8c5442f45bda51a2469b51ed58957b540824622eb6853d4e6a4c86c076678c7f02774be4a4879ff55508e5075305824528bc9f975885a222a2a30fa37349f08bcf499ae8e4dbb2ccf91f3be50130ff95255e6ff9885a6a78ca6a9875f26e801e259f22e1f466a9d9a946a32ad728e08feaa15b6c451e57d4e3284db0d526913da8ed0bc6fb604837bf0af41ea870cac3dc621398def8a59d63885b9fe8798bf7c411852653b1112e4cb306451c962a1622eaad7ba534e9ef8f1649dc8b9d313f8cac4e34902995e49508fd4e50f8f7b2665a3f866f6ab835ca04f45b80fd9a0b86a62304143a848661d24435ed136a35b7ad4515f4b6049b134660ca3994f0349fb93de18efd1783f647958b2fb1be76cf8596e4946f07ba5793e15ba543dfc69538deb8d42a86cfadacc07e682aa9c0efe218540642249d2b85f44a8b78e19e5cb9a69615a4793d90a90b1fc5c7050c3c3709fe77182e40cddc60a851593eedb30978ed634ca79ef91ec153e7b9f06163e5d0f2a6adffbcf72640066ef81dc95bb761274c6d3075bd23a17374b8e0bac0755362457cb3baf8b9c4e99bbee6a0e90bcdd22e906cc1e31894c206d37549040969bee131ee40676c9ead2c05830c69f040804f68e58e5761c649498b86e5a9ab552452b746c596eb6a0d6629e4a98c17a2698cb97af441de955c01bd302135b18b245d4aa380dec24ed68a58567964460ea11dbd1bf52531b6677fc6de2f7ba7d59bc3b655d7cef47a890b9345d2d428c0fee98f4f09c4c91f7d48512aa81a37188bddd8b7488c349807320b852147ae89a2a5636c0d4fd5c2e56f870f14c80dac481b0c78124f9c643574e8178c890f168b718d66cc3c245629525d70bc9846ed1c04609e786ff4ffc91bfe350971f390cfa8295b45689456111fcc058ce8339f404dd0469f59fe7d8722096887923e6fb7e3b38a0d8050a82aa6a43247e381b8db07aaf435dd089e86d80375f40fe3012328f0760a4247886bf8e9f170eaa48fcafecc54e29c49fa41488c59fd76be65ab8395138ea65264e14d3b6396126c6d81165443208df8c4ba55024299e83ea31c558e67d5410dd58ec808e7f9029f276fff7f2aa9431240b3bcb9d06171cb0b184909ba29f2f1d190348d1ecc46afbbecf03d3de11742ffbe89c5c1875adc3717550ca51772498164c6d4d44053166532ecfb4c1ad07e9e749f4f14bc31d41954bf9cf9c2a23b5e0a4a37548d9048807914da489fb6285ec4e24d064abb75a29b75d8c37095f0ed1e20cdf8be4cd0fa6750775339872a5dd56bfd1541debd4d327b9e6c47bc8f29de684c5d1da6d7a07229940172be3e483d884b024595d8ad1e7c045332934e4bc9f2384fe6ff49c78e017de8c34fe4ca629b38e6c1d3ce84428e51829bb791a9529d61f98259a1d71f2f26fa05cbfe0e42c366e5cfcbd71d4d8304f811399ff816c0abcd617caf999b392d7d6330c1463f0bab95419383a996478dfd7043db1a5ecab26452ca5ff23a70d3c0298844f4287e7bb0ed1376c5daeb04226e002838bb01b4af14393536e69c88a262f3670eca7d523550e9dc52ae658f46f69c67c9a6960ba2c53a9ecfcbfbaef6daa99462ed975874c4dc8182912dbf77e05d2d75748872ddd80e517bf41615f2dc3a4172238b0de4b8f8dc8cc64a850b0323b81792611fc5caf84f2a5511810f923681aea20ef0445c1c35155ba9f87d09ee39fc8f052a7eb10fff28a65baffc8afa4fd3a443f39bd56f6c09bd7fd2b086c8f05d47ae34eaea98b5d66d3e06a2dd9ff5fb6f357a2551bf5353144b04cd87641bf72268c3940e164d1d59e135493fb025715afadc7e37cbc68cdd964ff26af968c1609b551d3856abbf2008a0599e8ddeb223c28131ad076220d6319de5bd6295eee78f0a4e0e227e178a4da87721bf99a86d33458c05125bf80e33f858c3421dbd82b1de568cdb6d93cd01f2a5e44c0d35e2cb4487ce6d5b30a63c516b916e8df265291e9c4c7728ff2f9a000291eb27bab70b3fd29db28028e566ab61828bef82d57e42b069ff1c3437b0862c3bfae6c8864f671c42750c5ecffe40e76f836e9aa313849e723418836638969e5dbb1f0374a1807def69fac565f37cb9b41fc27f46d56844ce1fbc7e39d1e76c3a0a24afd4c7000a9733e77e78f7b1ed1bd255ffc5b904454f260ba7dec39aad229a72dc77cf50790207f7c95a92a3c66a141ee240b1592f7593d71a667ce6e9db57543aaa415a65e38fc2570828bdf5009b967e0fd5a9d3a7e1f5016869feda71172a72b86d1cef9db8e6e2ee987c3d8f0931125bf4e36eda8ff8f92e1229564ee016b5b437853a80edd6b0d33a02a5480c066afc33253fbaf42b93334109a380d6713bf010b6eebc252c0fe361659f4c6e9961441808f4d27be2dfc47f073907a9a180c10a939e77901272710b218a2319a02a5e4a3a839be2fa0bed2985b04461867b21864365b3710eeac41b436ea50dec11e94240083aa6b99547888d18c6a47df362b83c92acc1b76d615a203fabfdc1e30a29d1deb4260f4246d8318c7d82dd75da68ab975b925b578529ad5ab3ee017ca20f92a522bef60fa72a6b849d56c95254d56b3402e76b5b59cc983a35021e0423b827367b486e1292a63fb081d16d8901032c7ade123130b2667ed7af3345e48c2baede950584e09f17d71cb81c64e415825e9c4cbca80b07c5b72fe3d66ada2535aab784203d4b5cb326caef0961fe2d39371ccfe58444699547779fa689bc6c7806af3df8c712a0e1c85ba14e161621fee9c3123bfb6d38393e7128ec32a38cff0066b178a7aa6c25215880789a1ffc36b080158c0c5152a31ae39bf0612bde91a03a20d7015640686bdf3c179602060af3cef7913721d41f13d212d6a3c5f21dc051dfd1bc09ed673dfe23e4693feffc41ef11286533e4cfb094e8aac483f331758c3b6c4c8e907432218826d2322f1217b6474d7124d23fb0c32ec26083710ba690f66b2d3d661bbf217f5936bab9a2c82c8bd90ec2d923b43d9c1da034cdf544acf7a4b57ec183efd1ccc20bd6d245a4906d23433b3eb462ea643e2f3f1eb223275da3f20ec20aeb71c6512ddd9f61e47497dc1cdcba97a531e6e13471d2a49fbf7baddce69112dd7dbd28884b85dc6d8674da1b20175c4bac6d9d5a2253a19a343c9e554b196aed812067adeb4d7c4bddbdedb71482d70721002245a78165bcb397d867bfda8e979a2463f0db7dc3f994aa088ac1bce870b55cd70fa1ad5fa3b42bd805dfe031c3dd8ee2fa40e2555759e4e4697ed47c71be367b2c0fd26fb5c6b33daeaaf9869ecc29a492c6dbb223caeabbf7de5a88fb91ac4231f1e7f38bc1af6eb6680f35e10973dfaa2b063b0407631143bee2e96059a51663f790b5c8e4d660ee9c6d0427923cf7cf77d20a2b3e0c351c3141d459e79bd8d78cee9582769659ddd895970ba5583dd8fabe10a2f1ea30a9b366ee52a99cd47db3142f1829b44928495c2e8a9cebda6c37ba5cd2f8e20795b00bfb1d2fba8c2a96e310cbdcb0f7b70e247a8e386336c5fa796ba9337d890333c09e4c3341f2cd939ad189a1a1629094cbe0f4583ece52438f1fc20d170d362700aa9aee3c0a49634cc54fff2d10a0b9735e1749917114733b87dfe5924bdc0cd6fa54841db49bfbe1b9476aa92c705c864e35644e2d8f013869638429323356e2162cbbba8896699ed0aaeb1895ddac9da3c9788c61dbc1502cf3f23a4ef3fe3468673a3484d5159c7b7f8541db544642dfd25e9008e3c4fc466680872317114df3e02e74fa47ca95d3fca0ca3564c82a017b46b20a6749cb21c69478babee6d05953de00486955dc572405ee3b1d3c8ff473cade25c5c5920fce0e80299f25e3ebd6d3098ec7f54c442964b09310d7da4f77606ce7162ec3af7cca016a04928659bdfacec06d02a6c96af54df2201bbe13d62c03b12e7208dbd12576b99d6fa14d0645bc07d52bd685691077c620afc5084c358c48cbd51a38cf93f22120e66a7a5d27e48d1857bac01e720c08459edb82ca1d63f17af631ab0ae8448357a16221c81b392a41c8a644b7e3c483e709688d3c62ecc3ffa8fa305c17b631739e4ad24ce1b3d647cb55e95c815b4a6a8cf206f42b88b7dccfec620a6711b357b3171d69b9c571640344b955c5865f8ac086699e8b00d7acc316f99360147540799e707cd298049b73984167300186efc5e54c6ced19218913e87a72bfcd8dcb6ec1041cd228c09645845956d4bf6e96b049007d1f39ff429d9356da7e3722df583116c08bf50787eb47c634a380a24a2f52b420ec4900d942e7f38aef09d6547da1d036f8a5c296e06a02232982e389b0021696a881c99478f5794a7acec9dc17dcbbbf8f1b3a7536d2fa1eeaee18d261b2f640cf4fe82aae97038df19878c8d4d21d91be0e29c8111d0956c639b3e670923c8dd0b37f49a144dc6056ce3226708015f5569f5e8fd9628453e0089515654ba6a0f1b8e58e8e95ec9af50adc7232bc45aa888299b0360e9da1b84d05d3d909f2993b758bdd730449fd4c71d6e251f265619ec6b23819faa215d82bd663ef338f1a1d6a310a25862c4518c45f2e7b8d5d231d1f144993b8a508293790fcb3b432d34f13fbcf4027080640c0cd07706485e7df1814a2380b3d8ac5532962ce772528b385c546e5eb51534f2e480f66da6660e7f3ebd28a13a7821fdce60fdb7951daadaa39524510d65463c7e8a1a1cf27afa300267680df65acb749747ac8cee79d7560fbb2073f16f09e6e88eacc2b609d95fa2b9d5903fbdb80e6f34ff85c5bd1de2db47ded81a414c20fe7c0ba7e6024832a8cc1647c7579bc4841f8d7d6611ccdb5abecead818bc2190356a800bafa6ad95203055ee2d649089bec40cc0762f7518b60d69ec5be8557cddb88a7ab8c62ddf41431a8ffc23e24492ed9605337f495af03cd144967909de9e0c512edc6da79fea15dff2b8b162cd85e6c268c1fe0e05034013f896f446787e20da7eb577f0a47b8ff76d0d5147d9db0dfba892b19086364b2ed7c3fe4ef2a0a2155c110828767a9c25e14d79ecef43170750421c2417aa1953c04c619cb67b35888aa101812385e04158d2fbed23ba32cbdeb9e42f9445d510db32f6e0d26181965db96fb90c2e259a925c1a366710779afc06cc5b3bb260552806dd40434d464574e09e85c3c3e064f68fb1e535aaa8d162f93b904b9cec02724b5208126874af165381ffdd8ca869f935b269d4d11f4af5ea95392eb5608c12ed488acc9f971197c48e6f3872909ad254054660a0e0ec3b6f7082a5436542022862a74a4d29189b8f3069bef9df0e4c6ba675d39f58e070eae14e5c1f292a218fd86805013f99cc8074c10371753c2bebec2be7bccfcdb8070f65cfecaa259c273febda84e0a6f521c0a32716a7b505ce5e9e4291e34cc67ebf2ef9b31d836c3ee5d7510c6bb493d8093abba4b687dfc0408692303e56728f48e1598247e05bc4a4df4546214642945c2115d634b3c98026cd352dd1369daf915c3430250358853dfc5ebcab3f0b021740f89740d78049907dcc62f962afb2d17e02358fe747ae8087b8fb44a7c4c9c09a279ebc7d54d4cf03a83fb996ea9dae7cabb4cad1ca2201e037dde1e9cf491e76512514847da62e1086b0a1b7523d11ced73b1766863f95f94d31b8aecdab4f7f24a12936d3a89b7afe69b716281b810600e7ee682ec586a24d9347a5fd4102649f9c15dcbd4b8f66a27f9c2f5e54964a15b737d5f5115c3702562f1da4efce54ccd7b93c7d41443582a918a8f9f347a5721e72f6558405497f5a18327ec1daa538f57d27f07b4e817dd5e1888f379fa256547e6e8412fe73e2a2edb2e1c586dc0f3ebed6a90b953fd05860fd68d8d4d928db7fd771495ad4fb2e7368a507d2cb095b86bcb9fb196cfd145e904cf6c25f80a46c6f2378dba3b64a2e760a3a867b6eaee07f294e2e919299a6f7b722cf38d7a9d067769a386d787dad1960bf8a4a9417a2e503626240c2f2742124731707975c0741a52bd6dc29283f04a782eec7f1e57845ae9e946eb8b5456faf36515f47d533d754a49305fd94dd0a56d754c3b85425f3b1428f11165d071f30345a27fbc3483fc143d725c36f714f8fc0e56e6058a4b551388ea80240cb1d2b07b9b2a7fa5d92c993e3ccdeaf8f128324a9da09b4d84956c559eff71a70359293fc6e4ac15c984e9c77ad1382bb07450753cbbb0d47f962aaa98ccff27ac594b2baee39eb54e4f1e377cce7ac52f7b78da50e5d9af619289fb0cde0ccfc4300ca72317124f5a3ecf817637b977619e910c79681a418625603350b2bed7b6890958b8ad228a51d535b300e60039c9b090eb5d75c3ecfce0eda35db0b4ebc275fc2344a983af8ca342739602fccb03f475d0268040a505adf96e521877257cd2089c6183642dd84e2f94187d8fe93c679c42ffac62bc99fb696cf183a38a4a002373f0e1b6a0f46d570b4c157f77b56534719a4cfde4e1cac03721f7f881e9e805ce935bc6e8163362c957f3592f4395036dad68e517bd7725cf6a80a56be85573d0324c54d767e6069d48d031a0d224c4c77060a69f3f60e6197c69772c2b97b8c877b9a9638230f6aa8eaede83de5abdcf20957de62e569cbfa8f7d32e6979b1bf524751e3f934b20c7c22d1f6f8736f1780266fc284e159f465bc9516af8cc300753c6bafd07c5fd7cc2ab53f47d16c5a53bf85e3f1529041cd753427dcba8b62d896cdc900b1d8221999677a0477ba19e3718fb855a694de1d7fd825232e38b636306289f5248fa8630a00a8fdda517b7da4e9964935eede38d13b538c87c8c88ff27411113102398f6ff15b13039e11f30d2e329739d95725937af37265aecea51ce45b275dd795e525837cbcf30d3118c2d278be1fa7a18d3a35bc063a88e77f9664ea005bdd35909f2453816e1663484e0fbb6fa9e6043e3ca66bcb71f0a4e8554cc7dad08317219c5d7781003d57dde5989912e07d76aa4c8dbd18ea9a24f0d2945ae3f3910d0df15cf5ec60066cbb9e079a42d71f81683012ed99b73a5b6a8c07bcc2f225e12ae2676f8a1fe28ac5bdf6664d3fc81db21c01f5ce3ceaa26d9cc6970f30473b360aacdf32a36d9b651332b2b5c72608e6a702ca8b900f7dd45ca36ed64c958750d3350e5378a84308688267b151240f064ab1dc7634f7bcbe1bf5f71903dee87d7f0dc56eeff303a0f8ea5eacf2ebfc376dae4b8d1b9ffd0ee0e1ae4bd0a3e724c1bc4a990bf8fe20036a05c5c621f5450e19509d006c5aeb3d4b21d56fdfb993e3beb1fec0c7e603638e834e9331931eed0799cc0cc3df413bd16a942586e278839d195a83de99c63d74c14e39dfa5534de97c0fcec10d3f449d6259d89e6e68d7bb147e24d1f36abffa47fff782209a46ea21b47d8e14d82fe76668fcef445b881204d202cc36f3e64467507f9bbd4ea5c700da96fa264254665dfa4d90d42e1a5e60cd87383ceb62d73a63d29fd9ed5aaa6ff4bc715d79ab2074bb5be4ed20e481967ef6234cdf7de51b10fa3a40997ef1344bf26e28bd074a6a4ce1d2b855992153068a4114e11a9fd261875b0198dd0b7c791ef23e0f5825adc2f1398a5661b3d71be4a1b805c2915f14e6c0e6d51bc3e8eee4af4ab8fc196125f2eed18f808c3987cb7961e4bc6e861c7ff0cd5c649aef6ecbf550c32b6f83f263d379d090aa39a73a92fa1b43c85b21abbcfde1a9220c90b07cfc7e655fad9a7fc8d5cd493bbaedbd3b12cdb697f7fb74c7893a7766e84192a379fdf875a5019f8bb39ed924b55f22dfe61df19e163a2cabf9e04fcf0a3fa4cc8b979868d8ff77c5303fcd10fd157485bbb59ef6e4a1c7b2b473a0262a9fb6d6df67fede06e226d6bc1189bb00be4cf17c43ac5b64a7174c26333f94d948ecec64cca0daf1ea08281357518a3e1c72239af6c20de1f5c89d2a877cbcd876c126a2e976b093cc66130abae2a91483c464b405d550b0ea36eb157ac35ff63762b29426cdc67f30ef9cc9c69a37205e7d2f7428bae3031a0eb09439ca1d1ef150839fad2989573301995c6b30376cabbd91611ddcfdf5cabe9db596523edcda5cbf7aee4044dfe6c6fd957cfc56477a6ce31724f3a51176bfe4a9887aa15c7fe863de1bfadb21cd1f6ef333d2c4b57165e98d84d273834c9f732ba99c39ac3e80ddd8ad838d3e605b477dab67951a4bf7bf7404450fcfafe81504b7c0b0cecbc08b5fdd772ff08dc3bba3654e80e254b226e172f9fd5db4d39ce3139c1b0caf8d6bac2b11a29934f7c3bfc47bf2afef86078c207f927ca8c87b8e4522dcb4c4976169db6e61a7aa14f12d9161b9c6103453f862520e6288b2827176a5157cba33df7e73e96b6237b469f07796c83bc3058db511f948b18721a0d2f48654739680db983f77eee498b29b64880edcbba3e39fc70b2f6e778c3dd529b1774ba42ede5a1acd2069bd7dcb6ce0b6e3f89163afd6f5b022a50eb188c5a8c548c83faeb3fe4471853df10c04f4f95bae0ef549f3116467c1b272c5718c9ae84b425b158657cfc26fd97b5ce505d4b26d3b8aaee094621714e985cbb6c210f943a440b95ef3011b7aef1bfb861d095b0074777f9e03d2aeabf57c7997dd4579e53366bf8162b81bc36f3c69696cb5db2c9358bfe76cd29e1d6128bad7513810e7b83ea474ac5026b2320b9b201bb0193a11e703fa78b55b90d11a2c92244507a24534b754efa8e1cb875b78ce043be317e62af4d31755de5762bba3dad3f3cd42434a9c7d23c8b9961ac75f6d774f67175899d1c3480125a2a22ba430c1b87389a315ca7f3db45d8fdf9ba0eac235ba33b99cea45d530b0330d89ebc1872e2f1a5af40e672845402dfb89fe10a14454ea549e2633190206340b7ae57ce829dd5d7faf0651527918f7d4b03343c07c92a310d27e3f32622e0ad42637f3351779f2befda753c5ed62a7c89e6c06fb3333ab80b17fc830623649bcb6350c6a43a6abf3adb8b306a1db602713c95c062bdcb8734accf323dbb0acc52a6b874f0e2a23139c556b361508f37ad6dfefa037940837439a1d1b03302582f6184f698670d9caf46c00293baf2e3dc9350b8d24480315bd339776fecff49b08ae9a819a04e670b643ab754d5c4a755dca66df874877d00b73b521caabdb940c54e10ae01b382ad0f0ccb2e7dd56ed0b8dc16c17c8601e8f4e2f901465548e8f649cbce8086768badfb55a33c6c3f1f9e44b6072604260d948cc98bca1e02c5aedd91545c81221e651bc12f9eef3ccf026e2446e8d0d21b5fb6287b68965e8c1329faf9c77d460ead7a24ec2f0e170fc21170bb52e9b1689952700094b985bec281b89b8d9be1beadb4e8afcacd40083940ed6e807b4a910574a8e6c967a64fffca8b7f6d26e5d4617cf933cc3232d6bb627999141a9465d17e6f7d921e727018ba22462eeab3a531bb29f551e0c93f3ae77d0cfe87cf89abf3eb1fc252e4abbe9024394da982670cbac21f5679492311814de2e6c9a1021cc4f0910dec1ee4cdbd8e699e8738d96df90a3d98e814cca862dd6f8211fddedcfaae9260df350375c89a84f90e7d62b62931488455bba5cfdf9c31cbfb2afcaefa5433f79bd07991ce27d0de9ea31a634e34a9885801240746fb10fe2efb6fb66da84cb69a446fcfcfb72043432cc5d888fb14e074ceaad59cefb0f8b5c6c8d00f3ac8d2b9fad9493edac64522f57b666be5c3ecc48c82b0bfcbed99df298079fcadeb891157a09ac4d203d49a2fca62a33fe1b9676180c60ad612a6138328cb9da864f6fec2af1c685a509c3b92489032574bf6c9eb42a21618c6802e9912ed8f9709d1ea2e9f393f4540f8ec3af007565ec8e1ab7729d8a2a1565122dca9d196a677efc7a4a2279e054fa1d6d85c2d8d6d533ae596bedcb4baa7003631813ae3735dbeabd356e143a83ab05949bf8d6321a87fd45ea9189a045f1af77b8d35ce72568cc000c5cb22ea5c781a6d604f1205a171cf73ad25dd8b239d1ce9a7bfe745c390d8557f2d58a0665ef93656efa9c2589e747c3e75481b2a48abbbeb400a29b3218a49ca6b5ecb227514d7bd79bad6a567d271e366de283dcdd8833f5e49359b1e04b1b86bbc6b237cdd587f3cf6a941fc15d28b31ea6dfc63212025cc0c23811598b93210732f6bf2de35298645414d6db5f3125d054adc4d7eb80cbbe3740d4fc2e5fd3ec90d70f600e9a2e80f84f85b534c2b15e9ffdd37a1bd5ed9c1b6d49476d72cf6e01600cf79314f919ea2c647f69ac539a7913aab060a1e62a9577853ba3150dcb9fb759a9a4fee27b07b5262c165333c804860a720d2613cef7e462dc206a82ef986b88cf458ec9c6108d3cf3f15f88214ac5779b6e53600342c107b5050c5afe0c749de8c1f37d6e8e37c6ce7756a052c58bd86bc4906cd5eb9920512d63c3cec1237f17a9c70fb9075e90fe1ab7e1fabe06d507cb39e167059499c32b75be6aa56b2ca061084a45899a51858ba4272f77bf7df6d2142e6da5b71f1f5a4acc90201c276e4809af7f7b7bbcaa0a3d9efa1f8f45a5694317b2a7ca1dfff237bd34390e259061f5a92cc9bbb479cf195cd6a72777e4916f5494bb5439ff3ea1eefb845eefb898c71ee455e91b407ba6513554fb15678c37d683c2a68d40d1012ac1eb2352bb91dafb92c4f336149e42cbfb2b8d8947301a25857eff03e9d352ff133a4c22130972f2f68d5da34a4b5faf013274897ed365b3b5902731a1641de5b68388aa60c4df0523670930febd0ad6936f9b7f6ec3ebe9bfc71e121701cca01e567343e212263301f8ddb28f0d9c53f3ce88fd5b4d7a2d66beb4da7a030d7af8ba5a7601de390dcce1b92121f27054d4c5b4f0ec565f19ffc926ca022f5884a00a58cdc64946cc931572ca1999ef33dfcf3cf9ae8675b1f3381da3654ce9d9ab8e9f5e5fe593f8ba7ad482a5893ecd31b97aa591fc7d5c41e1a1f562d6c1fb5ff431349f6bf58b78e5e80e329964a0dbb84a5c699ac80df9fee9e23ab683aa368f59ec7b13dc1e5a5deac8f4efc24a615b0a6f6edc6c23c2620d64311037745f6b9d528e707578beb3b2cb611d1bfe3c3d9a23bc41952455f0046612204de33d30143c96e374a3596a927db63c93155895ec85d4449fb9ff6c8a3ea82572b3e6d240a5f49a6a7bb2e9ce5e71296aa4968fea7719e411ee239eb316466100b1a518e3ea3023ca80a407416cd5c34dde4b77bac554baac0ab6b762e9402026f078e965fa738702a4e0ddcd3b69458585bfb1b0fb31a7111cc11ae69c70d910d99272d5810c024aa268f0b33579a5611fb088755ac007cb88e3636190b259af1eda18877aec3cff8015a4e6f2940da68bccc4298df57eb0efcdc9d9ae6800dd156b3bdde42922c2ae1305f2d50c5edabf3a1894b4274eece5c3cbffbaf60b080b12c6d02e7f3ca65360dd206979c2b9d31259a1f1953d23122130101047f6a424d3932a8acaa72064501bdfe936562f40e08bc1d8dc148190d452668546e1001965a1966a8d91931c0c8892aee2d8922e25beeb1e82a3ab81ddc3997b6613457eb10ffb7e6e4999a50ece63c1e17217fad6b052606f59de24d235415b1b84bdc357f6bcbcb7e170c3a6cfb11fd9899e91db5214186f6fb0e35dbcb4f65f78b4f32806dd7ed75f2e9d784d298b35a5603c910b6ebfb19f4744bb5a69512e2f7535adfb154edf7c90dafcdcbabea5621e6049d53f924b6ef9cc3de2bf480a9e47a79fe166a206f69d91fd2ee9269c7acb4bc727e8a5b3019d82ca20617b773d77906d23b3d1266d6cbf1ba629f2d1d4e5b5c3b2c2d6478b0fd15c5f819580e5b61bb96f626a3cd9b251493d516bbfacea916be8d38fc63fad5b7e30a5d930ba73c2db6a2a6ceb8609194fbe471524c69b1cdf576b97d5dfc069d58ec1561a28e9515c316c2cfaa8f95549487bec86b10683b4d7c6da7cd02b61944bd1bdd2f007fb7caacf36d1783ef52626ce87a9208054728000aaa6c3c80706cd39327247822eaeaa062600e7d9f929f5f88f1a4b05041677d1f4a4f04a12081d99c116fd8e1e17e6e143b9dbde056c1b9b29a862b5199187f3dfabdc9bdd8b47d76860bd35a012b321bb5107136d588e737be5175559468f2b7a51b3f90d170995adf55a36ceae9cac48c342cabe2fe97b6fa92e0e0f90b7466f142f583543cd51dcfd2bdd3f2ec515a52c809d3e82d3df2a8f22dde73a809456d311c6903efde2eca77656de88189d52504bdf55bbb70a7e77db5e37059aa7a1532dd962499e16e8a3ed5263e74e131714daefa195c945bb0272f0502591673fbbfb626f3b409b6aa63c0f542abf4b2c02add2e59e5ca0f7190453a6c447bdbe18c8efa2fc3b878ae9a410dc6201061dc8bfa7cfbc8a1cb7679945b27e40641bda66d2fe0a4219f6aba9284357617957b949ea34a52a5a6ada17c751e4b8aa66557ebe78f7388c9baacc91da0421ecb94a0e972265163af12648f212f9932a2d415f339be86b188bae5a3725178b00c1963d9ce0dcc1338b42eaa52cb814c5d13b6d395a18097c0dff477aaf72d5a18adbe434d23e21573be8d96a468c686b15421734be53f0a41ae91c0583add3ba93fbee11ef91df34ab19434af4d5017eaa3a60cabc7bd155753ff28063917920f2fcb4726b32e5260597e685ce6ac2cc016cf727d6079be0b1d67d3d099e2d5acf881e8f07502eb3136a6e645912f6817604e118d37f385057052f1e5f86eb31146e52f56870f102315cd283850a1d829d92aec14e01a19b1b2b5b5e61b03636881ff7bcd2e715a8367dcc636d82860ac48a47f68cbf35bcf4297afe9ab6dc97233203b28b63fa2aab9f5d1a1920bb9898c441717c7f70c159e472ec67e7870df5e01dd943638b1ae0da61647d7bb76490fcc96daa19e23b98c5f73812c621a7c8888fefd4baa998900a35849fa1f6f7da531c665bfd80999338f3eb988905bbaf2cc2c8cb10e19cd54c67a0c3914cab9ccc8cf8f2aa474d9d30044a6f9a0257a5f351ab42616e67f2858194cfc29015b8d01f35533823dc55a10a9dcb1a2fdfcda5ad0fb77c96de90dbd965989b18b5a5abb2d5e1cf3129b005c4d12c598ac43b324762af844cd0823978cea4f8015eb80cb422702e519b41d8777c965f6f7db62b54ab3773285202d00a900bac4d37b4896c865825fdf5021cb416a367d729bc471e3e7692adb9b890ea8078f9c950cd19d710c31b7eff86d61988f45e6c8dd9e0e3d1db03e1e688b32f850f19cd1bfa98096e2889674e758f394cbb686b497f7448a6bc3730db3633d6e5d8b9bf5005462d11d97c66d8c8d37fc7045c5780ae2455957278a7d68b4ff2b79e79770bf24807968417601cebb5319d41437b4d3238093582617875830af545a76d61281426119b7b0fe001464a7918fddc3cba9e987a6a9f60d08763ac00ad849f7c2cb64b2196ac2dd7c74f2982fa0e1b3f1bf9548610d83bff9d5d3f4d20468a24424589a3652ad0a99c65f2a53fa9a654ffc01e11949d88ed827e139d84b3a0ab14c39261a061688eb902c4a8ad8357421a0ccbd7a7e033e31e3d3ac155e0c6c594ac80dbe5fffc3b1b03c4053d0fbd51d58ad6cf71f4fc9d7cef0c2e084fd3c2ef9b4d30b1f6a5e831aa9d4baf0b9ab36f96dd17d478f6b7eac9a59f5812149943ab5c9670f111982217fb88e41166b2d8dc2278b31d0a5e73d162ce3bd6cbbfd904ee63e30c01ba73a90fc9c1a5cbb4add90b735dab725624586833607eabd9f21caea7009cca183f9a0ea0ba2a2710060fa2e56f5e3e57e12e1ddd73145e2f6dc82651e84cd81743b7b2c74fa60dabf6db1538e44fd2acbab5ad53a014fff9cfc247e9a00e27426dbeb7cb1494c46ff7e1371e205466300259868deec2a07d853de5daa3aec828b8515fc60e2fc68e9425fee72d76858e98d6dcf38418c6f34dc1394b7a43629176dcef2c7e7c4291157a03627ef68edd2cdc2677f103e84535025d82ec1faef4650c30ac65149b3b04530546d67e3684682c9fb3f12bf3979545d3e38538fa4c22b2ee14601ce83fbdc9663b490f0470417ec6256b20c9a2f0a0ff766f9ba734d5f57c58972972c07480ac676402d49becb6de6e85e9bddea9a7a8ffe2d8ac543ace2f95eec638a2580f018fea6855e62af46fa91831187eeb147ba6b80010235391df32b12c6eafbad3b4c4c3e78b38ea19c3cde1d69837409e8831d12773f16347690f594ff9896c4cb6ab02354dfc743b6a262f9cece0ab62c3cc5e3e864b14222fbb3dcbf56db7a91e47214bc8e2a945b6d4f6b739d94c5984624e5e8ea5cc1a96c53e5b2fc499daa55ad76bfafaf5c4406589909843d0b90884539fe55aab448719bb78ac84342c2b5b2c1638180b7f6174528c95114398ede158ec79fcaacfee69677b2069928330efa625a8888cddba6259e7b1dd09d5ba54574c4cefd3133eaed50f78ef32555cffbb6ac81b2cd4ac1974bfe29509115575d58ef25a933cecaebf23512c03c1f756df2ee578f101e1df5d150ef64a8d8bc5915216689155f0a166777e6daea471d4d740a5c5a54ac13d245593d2a2bc8b6819ebf5cea08b47d799db85ac7009dc2939587e9c9d0afef19b14c23229d56b6b4dc0e1b5a16d737536c423d1d40d6d2d25d93c535b5409f6cf1a5f3b89dea29d1861bfdf71daf945323fc4c3084ffeb9b6437f91c35c9a929c6f23e973918cf9d7a8892a4412e29183900b50b1e08f1fb8e43a37de572c84e8263a9bbfdbea9c3705ce5df9123a0e78ab50d76715c12387af36935d8d7e2f2ed7c66dfe035f5186202d49540095d84c821dd34bb5599248838ce9655913e6462f5a649536f4a4c1f2dd3223da858319adb12752c3c35dcd7f2f4a4f23b33aaaeb7f649ebd9492dc812896b82b253360397d463c9d8d4fcb7860b75b11e865937f32001f4491ba0268ec314db191c9d48ba9206115e7484b08389c9b6582babe2264105e4c1d2bda8c196725296b232d1e90e9b1202a136f3b21937afd132ab198791f6270d2b8055d35e793a758640c8b3fa9a4d64ec0f0565d7cae6274d9bbf2caa3e21a2be76931dbb233ce81535bcafa9eeecb729bfdba7ee482393ec52dc2230a36260861f6853768f33713c89fb8b873384457a94e80ecbaba9d527665ac459006362e01f6158ce1cb44bf252504a23c3652e5b8a0026358822c52c6b41665efd7afc56a27f2ae233c313ae90763984dcdc0a603ee2e72d52b0f25b448acabd6a7edd831202b889ce40ebe447685acdb318b465e0b16fcb0af57774887d4b43533a5d893bcb898b1dbc488ccb78fa46f26bd19f98af6bbc62b65368a95cc1157aa851ac09ddd6e9e95b75833ce077c28c7cf95b006abb895dad31683f7fac6caddbc54b0f86331a37919f416c10ae2cd8afad3ed332cd4d63cb10e547c40cc202e6c249137b719837e2ea5dce64db9b2637b121763a043636f4ad959e87d8f73c81489ba2f0cf65268feb89dbce896672a8c35904c440c6be7ef76610f4270c2f9a96838ee7fa897810afe231f24463dbc96404b4d538afb0e77a9ec5098441ca34708e35c53a4b4e99c4cf6f6934697773cdee874f7eed57b177886a83bd39918829607423076aad230fc74a990490e00f1de680734ba95ba7eae27c4065a28f5e3a2a05cb2392548446a06e1bdb662743bb16a54af4727e89a5babd2550924ad75a01e9f4521db599d79537eac283f802ceefd053b408e93a95153fc3286c2e91969c0cac8f13ac3ad0c94c4cdeccaf33acf0249fc25fca18da95cb792694df720b77bed49856a6a498ceb12de860ccb83b11a711fc9362f4c3da46a99be2cd0b4ac7584a04a95505568d5bca52c1ccf5d9828fa14d54ea4d52b5b10e086c18ea64c0b459fc18acd6d91a1d36e49263b4ca861097043a67eed58cbcaf1351050b5fe69ce1500ad30c4fa00f3d6fc3d0f9fadedcfa0e3468118ea2b9dc8353bd19d0fb8c5e0302f219d1ea262b496fffa7a941771efd9884af6cd85bae362cd51212ecd1ed510a457ea79dd1e9e20030a96f00d4e4e1d09885030a81cae8dd484b9f17a936970dc8a730e729a46d31e7cb17633d9d4f9ef4277052d5550f9cb9ade4f658b9fb715aae3e0514b419d7973bc81ff52f68f87fe36848dcab4e156ae9b256bf6d25e78bed8797e54fba36d62968f6e12d25122a3d2a846d379f0ca1dadb19edbc673e60dc666f5dea7b93a639bc1023b4d87516ff0b00d61c9c78a9b8b1ace9e7a171a5911b8acf3a0ec88e37f5f540200cc6b6956a0142e927a30ff95e69b3e1200144f55849fe845f9ba4d845232e76291630ba8be5e9e6a1388210381270d62f8d98f1c64eab2b0d3109ab4a9527c1299ed22141525c7790e5a4d64bd45a57c5c85d8b9f5f7afb3219af1ba1493a8727bf71f07f54a4e1fdc050f484c491ef89da1321b57bdb771bdf8ccc76cc97e74246e4b8371e213b760ec6cfc485bc07dc3da4097b0068a8a36f3383529240fc45254a0b5dfc0d7c175aad286ac63bb9de5fb02bda9d3e8454fd72ad6ea1ad42d1a2941bb5c234df0652339a7d981a2ceb23dab1fefc3f15f7eac0e56f1ee9c9d629ec35046634e0a735b55231215aef6ebe45ef1b39388196d36f9a7a4bb17b3689fcc51c0ba22705322d8a5005506dbe630fc002ba8e4f77dc727480e175d8a39a7b68431190800ad8d08352e7a98570d9a3f580fac932e3ee3b7fd5b421f013b673c2bc507737e9d4343a38d7638505d60e2481c3c8307f8b0c0dd5fea5e73a4bd6136ea9db63b36952863f23d11e2e8698c3094a3e3bc263e388c1078c7a400fc14c9d5850696fa6883d8949ea57a5371b39cbca8f520f6904e1a08f1144eaf7d42eafb10052363f532968ea9e31f5884c1c05d691520ca8a286d04682590648e54e4985c4fc05e4ba1f863ab0c6345d21c62454794a1b99a24cb67fd9760a7a059d52b86b986cbb0903374b4732e7ccaea76c3e4338c0e401309b86f1bde54d44a60f8ef2ca0feca49398cb154dcf18aa8b52d3154bbc85c0dd41f3cce5c1acd2c4584955a4c419974d8551446cbaf9ef23c5d8526821958d2bfec4e52e5fdd804e31d70b3f4503f260de00b07f3530c164c30d077f2e810d814114476d3d566dc4b50eb580cdb9fedc8224dacd28fb444be06d3e37c4fa076d4a337963bcdcc4ca07169f79c07c7e864716b6d6fa900879b456e83a81decd90c5c2616c0e45e4ddd16d8bccdee242d880bc19401f9e0c49bd6fd67905409a3611cde978a6fd53d249c54dd651a980c8c8fe7535b6e1b80e9a6c5758dac6e63a1647ece2e950367caa1e057480e48014f81c07e0b0aea19cb276e6ff30ff75b5bd9881157d2dd6b2a8826ed2abd4f4af6cb0d6fbc61e9bd1acc9044101bb429acc781113d74d06447f84d7a5611388355379a92551f574c9e9054f5aca3904ae39b20501b21669fce5de029136542c092f6f165f47fa0dd61701a9d272ec3a33668103ef64f3e3cea66bd2c7f0b83f9241cabdde7d440b930ec3976de7710747463402056cb5325a4851fedf2c8cbce79213e807704f0d9298acde80bebdd5b8767c41ecd3393164e72b0edc15366ee66616eb26507215936538ff6632e1465ab72451f6f7cc1b280a9adc61bd99ea80a9d42f8ca6dd05bd955c595bb96d1346626024db36cb2dec8e71cf30c7c1e7ae6788d2c1ed5a25a6a1f3ecdc2aeecd0af495f709120cfdc07b0106023cf1597cdfb05f1fb7753df4b485da362b546a33c4508780f88ece2dfccfcef065c37c1b812f0d8859b72111ae83732a01ceea484a99fd5dde6712444c61a646a1e82f2af0d5510002074ac1d1cc172fe0c11dbf6a6ff8f1353cf8a686cde5d1507dca6c120cc81aaf60d398987069138debf8fc3920a2d953a4496da527a6a6c7b7cce6ee3d2bcb0a4e6a327cc7cdbd6a07ff0ca690bd533dbf520824f744ac8d326b309d2b51e72c3938b2c155c9f9097acfc8847a6511cc955fea5fd49e721dc345a45ce08005280e8dfc78f0c84a5b7aced4aef58cabf6dd8b0d53d25a91455712d9a9aafe8b51e94acf7eba237592df28295478b60fa81fbafc6b1a01efd75c2f4335e760cd6721029d4df6c7e84d6cddb66da2f0dde959cf8c8419c280662a46ad4283a928a65e0673ba38df7bec511c9e954f461328d9fe17397211c4bba73f57467a1674e761e3f5375aa28fdc183c0430a02106c20e56e91a2588cd10e884f796e64a346355b44d115a7a29ec41fdc616f4e56995b919c1b178cae01621e28f4f725b83bc9cbf559497251d07d2a8f0ca07bb9821da25c54eb3d8a70af1307d69ddbf9176bc86a915ae248d7cf13fb14da48a70999d5409eda4b6743626ffddd60c637ade99a25a996a1a05050290e22fe92e7a0d6e00ac1e4232c30dabdecca25fb6c39249de04fcc2a31b3cb18d67e13e5fc9432f69cb2ca089e22ed3a6f9b347bc96092a770e9d3d54368be42b04ec498d6bcdb9b04d29566b5da63ccaaa1b8dc9519bdcf16de03f487a0dddc41b7de86761555d299bf1037786c7acc98cf4383b354c176dba1b9fcdea28de461e3d4476cbdf78a6ca249760c6661a48ce74768bb03d2a7cccdd8c9d1b26ae15e3d3b0448bf6d6e7ab814a7f484bd36032c9d73fd7bb4c6394643e4c0d4c1774ae24ed5661c37f366848867a84f261a05c10264e21b418e46f264e021a616cb341b6bb5ba9329c4afc87f15fb9caba3a53095477286e75e6ffaa8ca5b38a0b0819c930070b2e97697c51a83020f4ac1686b5b8401bf27ddd8dc01a4145dc8b1c166ee8492d6759240dc3cbb6fcb79a4992cbb7046ed17e084e763ee011baedeb867452314ee9ae5b2ce0ad68b47a03cdce1037c5998e1afc6d147498e12a4707d6586ffd6e67d2dc55171dd4ad29c818314e1e661b54294903f2a1ee671b03cd85044419df6160c258ba0c126a33e8e76daea0bf1fc0cb374f20f5d3db80ef650d73564001cb04ef762895db498ca8aae0316384e98a43e734df94860f0ac4090f0b218d27b6b84ca45658b247e796797904213355e84f4ef997254e13aad93012e3ab48888bae4d5102d4923a3f766dd7cad98c884baeb682d080e7678e7ebdec6ef319933e685be6721edc6cde57871117b9fbce468b3c828ca1c55a5654e10b617c3e0c288e35ca0456a81125864cebf35f3f7a742c16d0bcf4ca7fee51a89c29cef7f4613b53cc6dfa445ea58c2c8ff47fc3084133041bdafab5d5b5a2e0df68d46c9154814d1f4fbd652f362c873c881f8467038ce760408b5fe396bd587d99b9e252cbff3966ce7045825e7e2e40397c35919237cd094fa8e3ce5f38e5ec99de60fb965e59f54b781e1e5cb1fe0cca12fe23ad9da7e07ab5666b97f9e69d70c868ab8f8303f0fc2834256e668b75c9bed4c63754af913c57c0605d36e7cfb874db0f38d3ad36523c96c68868ee64ee605da9ca3386753f331403765c4a7c651f7425b0b39e594394c68c4ec213647c5e0c2e825bf74b167e3bd0ee0bf9f68ce375948ae3c196f27085d4cca1f6f16e1dee8785292ac6e57c74244a3b0ef99095e8ed18485a86255cd6019cb6ae930c6818e1a923fb1417b7931bc40b7e5e83184550df329602aed257b1f0b167fa96424dd52e3bbefb591a799a2fd3760fa185052cc310d5e585e4a91439b7faeea8e4339445742a55fdacd9ef5561de78ab343d910cb2506b6dd252c92ff3af5167e56a791948252de9a034aea79eaba5f9d9df94a1f14eaa9df6a4a72afcbad504f37c31b521ff6ef9bd71848c89dc3e293c9b22ae1089d71a1b7b023992ffa28821b0ca1e17ca808ab3cdb4f5b6389d7f96037ac9afbad02a0ca69949d39851c7a1c8701a0df72fb1986b2027b17a17253bb5fdc243142d321c7689d10bc24540050fa2387da7b423c7443a628993620cd0eaeb52f120aa0aa897f023a83a6d6bf7042419e0de35dec506d3394ec9e71b4208660c0518a82870c1b26d81f52f8c91685a88334e691071c18f5a62d1cfdfb857a13ad63f34f46dc773d9a81e91b108041e5e9842906eec7ebfc79523d76b773d1ca224301463b9c40f6a66132c8eee8818e135d3de90586023cdabd83e8a31fa3101e899d80fd9ac8ea137d52ac9e74afec5d42bbc43623e8fdcda138c99db03319f7d23d90e77654f66f9f886cc0a5ca11b42f949f6e74783c08329c8827bf6a89d27838ce98d222773a7d0cf8d9660af618346ae51fd36ec376a6d865e7658a572c9489b9731927d0695e1fb8d0a223a921610f4bbda9b862b50d638c27e287585456c2bb2054a808e498971f736dbbae770984114110dd7e99efb3ec55c4a736eeae1c33090d363c07db7001f0bbc52a594f0e1aa9780b27a7bf81d584b03fc07142ed83de44a5a925462b9c5cadd29817034537766ba3789a1fe70deaaebfb7aab0ed4012770794005903772f638c6798d127082c544780e2f11e14600c6590372b192f5baecdd453aa4c05c669e7f7d5c29e73d55dccf8203cc02fe5ca38cd0d5c150735a989f248737983e0b0c72d5c08fb8b7f5f9940acd9a3391ba23b0af39b615b600effcb02ea98a822141cf6ce1b533bb9d8469e0ffedd56c98fe1110479c6f75eb1766b156c56969373b2e4612dd49a1afe91758987756757f83ec3318dbf63f6e685620979c3e8205c46525ee26240bad5f45d8c21c394555789f7bda4d9eeb4e9bb22da7c76e619408c31a463251fb76375243f37a23ef47fcd07bf343fd3664ee7237b6ac898b23f3b2823bcd0d0b2e67da2fcb5dd818b6dfd0da321ed87a088e54c4e263b03838157576287d33e4f24d0fbd29f82b513a4b77ea9d54951397f2e00adc052c8091b3fa4fbefb7abb9c5e545036e0288ac206a4365a7187ccc308e6165806b4923893b4219fe560e1bc44fd387434fd816dab20e3d9003743868bee636bd56b695b899b20036b78928e5e65d88ef5b0239d11f3fef3235142181d208548ac890889e8a6f8586b08d9447df12e4bfa9199db1b0460832bd256c3ca7f8e930e0de08614efc9287afd598ff1014ae23ce77f201bc376dd6b8fcc7a4c88c907a55a7850f6c23a408320c72c3075aad1d1a188ae419cad6057a8a1f03803bdccb145953ebf7c14defd652e2a7ab02dc86cd74da67b6e54e89260827e3fbd7cf0e546f2a402a9db2651b50afec9400e82080fdfd66ed81b5a38992d827c4f5636d6afaa6ccc8650d591fad20d95ccfb578aac931fa51733ef811adeb2fec4905dcf4b4c8ba243b2c480b1f84a87d49da9878dd5777c393f1c035a7610ab51d147411f47328afb5f061f130aa8693fc208c50327702f28a2a55b74cfcba91ea679ebb10f03f66bfd0f34304699c106106b0b6b73aaeb45f1800841ec38ebf83c40d93df6ae09c4653283b271a2cb62a40d779ac6e2cd3e43f27278f8280e4c56a89976b73d6de259915c47119be647f343c5103860e2506f6c00b6347ad65a18887a36f7da4f371d31bd392475d15427c435601189628f5ea1a0662e6d86778c397aff962db41bdc79333998be30dc8660e04e85d15733699f0dffc7602ac35b49d283add0215c64dcd2e4c4c56a23e77dda647b4df9c9bd8d1e066d208ba3568dbe2c00f128873d45da499f95215c0e342658a1fca8a474ed98ce81a5f0b18decb7350fb7716fbddbe6db8818b699617254d63c43b37f5f7b213de2fd127d28ccdfcff09b415877f3c27dfdb52367330910e106dce5cdba1f229e93a58e6eadb9cb09a877e99bce233b8988039d173815d4ec7097fa4b172ba465b25ff4398a69e9d0b2381840dc4a134d1ecb95ea1119cba40296e398e60b17fc220d78296bffa862b729fc7d9f700f2ae20f59b3c1add4aff8330e48cb7497dd01efc82f36b86d6756dcf1101e178e92c237f738d8c4156e973af0f739757418855a987b5e17ef100ef8172acfa5bc1347c3baf1e875d69c5759959ce74f7b9bcc25dda38ce137a95389bb0c551f617a8ba495946e5ea0566ac62905d94c45a6fa310fe5bd3c147e76dfb57c808ace961ec019e9bae4bb6a95ed540ee945f368bfb756416067d20c21597bf56d3672cba29014183a1dc1ef87632353be44452ce1153d7e16dab7c739d1f8a437e59fa7e0a46f74bb217f78f01e287c246f32e70f1e2077386efdfd9d53b638e6404e6a72b5d386c868614cdb1b32bfc5362be39e94af699c2c290497150fb28f89d5141ae9d5853f984f1885daf0bd4f6c842500d1f23c705e0b8e58ad8833740bce32eb775fee798d359db7f7524cdefb3cfe9b5f6bc9e287e38241a4e2ee65454736df1c6443e27fa26ccb42f39bd516c677ffa103c37775ab6f183a26fdbe408056e07531c481d7a36fa401106a304aeeed53c091e1d3493b65209470ac5b0c8b3fc2c38be4223d103d7886712b344ae70649e9bb3f91252c26d53c5207c0dbd9ee7947d416c994b90d9953a845920726d33887932c7ba46eaa1eee7d2c267883643f8afa51c11a782f6987d9799fc742c4e252e7dd049f12dacca7227acb9d483ba168ee4b5d284a8be60cf9ae50f9f4d44e3125357d0bc91e5bb6b4455163241d32fc5dcfe56ac43c0e5ca9344e68b1207f553da9fd3e9ed52f9f237b52445e26e88bd2765cc1dcd2ac1e7ec5cdf201aa3d404b64ccb48c096a0abd3ee9c45e21ae9762c5297f41740b2eacec5af7388f4ba441a6ba4c48ad431b45cbeccccf3f321750138cc19fed01ae607d3dd00d5782573904a3fbd883c102f125315f4ebf87fbcef3ab8c600df7fcaa1e94432b9ce5a745d40f131c545035bcc226cc382ab5bdea86459d7867f0b878a4d9535f949e005bcc203bcdb93b93b360cddef42c68b15821ee0eca2480cbaef42d222013e01235ddc3059ee2441d2636a03ea42a0ee72464835608be275f12f50d47290474c79e0d42a069aab8fe5c692923c8190e51972a172042ed45c7b8367c7c5edea16ed360f1429f4e7fa5ac494ce3afe43d48ce86267b989447ac6bec1a9f95c51f42d218b09ccda69c11e6cf811ffec82a60978d715ceb735ae52d03dce90d1cd425b3c2b94a72166819c15a849b9955247f6bb793333cfb17a31dc2a5e6817169fb84edd36fd652fc0c7e226774dc3ba275d309ead7d0b7d8416177dd6beebca6f72c606e441937266b46bb43142d6b6bd7988f81fb9e12317f8c28f838ac0fe58729c238698628e3fbf140420ffd60302559a5b5e0aeda6a03fefc00a2024e8c5430d5a791c5f3c7a46d1bc835b218ef27171ebef21dd99318ade65e32807d26608dae10efc38492df2540cab7c833a0f8a5a998e7ed04501f933d1d9e95aa9ae7c038209637149ce8cf5367d04eaa7de59fa29a97fc442e9114a668cd9c13c540c31142235a90ebb6bbf33f38ff34f677dc135e3470507e82f55ffef864c60d2f635f187981c21b3677e129b85051eb95c4f8c916fc71ea183333ecacf7cace9836666595015a85b65bd1f1634bc2d6428962340875519d8a30cba3867097d1b48afd72ae75dfbbb6dfe789a40d0e2fde5d1432d6a7bbcf9ad225e2aac1b293079a0fe85a9ff8ebe56ad097165cbf59d8ca4f1cb6019ba91f676b8e3cf012cb252dfca6670d509b5fb8eb7788026626231e9af411309f7d24924697b4c8f1a708aafc4be3bbd1ed505afdba1f1aa5bed431093e94bbe6d14bc905d5caba5ceffd48676f19c722fb4440e0371493192e3da1648d3894dda4e0ad904c89b9f27347adc4e57f15bd7d0969358824717146c106b214063c2a8a18a17355059981babf9a69fbe6cd43b0862010802290711b76e4f7427b8ef11ceac680b5e62c99a44bf39dde6f3bc66219cf15f3347ea97746c8f91b3b423eeba0acfaaad7e78f3a0e7740204c75dff42631a77e905212c58f9966cc2a36988f1085960cb1530faa814790c40fce26c78265d9f0f125ab79d1a3f94689143a821072a5d9ed53b37075251d436cafdcc335e62ff22f0a2ee7f97e1786abd051b9a2049e9dca8a3bfab09452979a27430c7d4c341b4da8bbac0b5851bc4dd3d41d57c57ac91fd1e2d4808c4f20b1cac3eec7e0767eaf078932406382a2431d087ea2f906b9d5bba5dd4911e4de7ad72b83fe4ec6dffb47a0cf640df3d6c61b43f18abb366334b29410c867b0878399951bf17cfb3bfda47f88232206633367cfa41bdc04f5c8bfefeee94bead1f65220050401da50d6632ad99b7227045170e6d6b239db37298442e3d835031b0c6122f3bb12b945d1932ee10ca495d1f5f3ddd40a90f8ca58230ac017ffbc7f5dd2b3aac92df523a345ee8409d304f747d2a4a8ed9ad9d7914e9dc04844de62adf1b37331af779c281708588ca7ec6aae994d2c93e9f3646499cc655d0324f7f4dec574453f01e25b72b0dc78d65725de58857843358ddb7135d84c968ba3a9a65b921b777d0172922bfb0e211d8f6dc0e13fdfc42ae804c74830375ad360a1258fc4948d84dd2a9a7812444cdd0ffa7c3e3f58d19e8c4d8df88db35fe2bb3f553f24b18551e3211129edd59ee35b0f7520cfa3a05ab1b03f69a55296fbf064361eaae2a666ce0e4af8ae212d82efb360040e42906e86ec9875e66328d973f700b8485e7b3b4f43642665e64aefcbe82d54234256f2a49f9ed9c717a3261cce6db28e59b3f8ee5333b9450c8f2a7882f4670a01b16ea8fb6afd52ce96a6a2180a44af4f51b1f3e964c32c3bd3015c042a183739d14c316fa78eedab0680578119a30b58bb53fab324641ec42ba529cf6530c2f6218b58c0e617b68c288a5c6db3e5de254ab8e916d449b7e5c7431a83bfc37cec443cc86148159a55667e8e8181dd7082c37f783c02e113996b37acf324bdc0f409ed5b57dda95f56704fde27551de8b53266ca0388649737c2855e5b2b7ea61fa1401a7938dda5834f81a6892e5d864ee61d90ef8833a011fdcaa54c600b863360b93c9f05fdc94c0b7fb4f83fa7f4185078e9cb5875947943ca2332d80c177e07a07d6059382a453e9877352c397198311a1b438d6d9c275397c43d94cda8805a5481d950ac34af7c82a7d7a4fbc74ba8f12c4e0a7949a5e70697e712deaf95852dbb837c36ccdfb9c7d956d250d60dc6fab6e1d877406716928b5ce5aa8b2aea3220fd7985a69743a3d7910adc18203d6ddd7f6fe7d7cd3e37e668112fc5e82721da1355dc806b799bb713a6af0d7290528a98499cf9b2c32e06a4cf9ec4172413fa1643ec411e17a3fdd38071353b1d7bb6d752e33bf2ba7d246a54d4d70bfbc46654d7df61f4f1a04714c2f111cdcc76c518a811afa0012e6f636ea87e2d1ca335f2a74393a26f5ca222939dc1e5588264f19312104e04a4dd05f183c90b12cbfeb0bedbb35cc9d31b479a1e561a62c6e618bf46d4085cf6ca1b33291b38eaef5ee54c8a7856da03d2e5755faf5c0e1af55df2a8d9fab6ff09576176c6539e8d8e93df386537777d037d6cc4c5977365b7926b99e9394093a82266bf0fea88d27ee51aee0791e90f51578f5b7d604f40f760539f1af85563b22efaaf70f764faf97ef23c931d95e3c51b7ec84c181865d58367764d647c70c88350f6845614bcafccc4e5de1e383906f7f8a3d6d70f5d6ea07422d06a770d36e0e3e954dcb0cea596f30657ebbff41eeb2bb5568356c7d45d987d4f8f607c866c5cd14a43b1d5216b4579665a4772faca3acb5cf9752c3afa2c58bbb89ef70d75997b031d92464a24ab7305c268a44409bc36e8843f5a9b96cc5305c3a5361a5fbd860d8f59a1f9a35ccefae8b33be4c586b25cc49bebbbed4ac9a92e5540fe1942878568006b7884c148a066242e7bb89adf9bb9dfde4db8b5b0a08ec4893443c366b6791ce5ca4bcd4389700dc3ef7539df89c97416dbfd819d87fb402626ec45edeabe19aa9db833002c6fa103b96cf9160f8743f93a01597b8ad263154b72d0ee3ad4f443e98f68ebf3bad8119b689304219d24b8d1a2e3833f72fcb8c3a2ff28e495e5583ac3b521aa3b6127028034848483863f09c25b623b7408c1026b3fc56ddb21aa8fcd0ddf8fb7ab16fea307ab0b58cc2bfa1900c61dbce8020b35936d8e89743439502ed15849f280be3f9b6be389b0fa7df19b8e3ddd3a2a935f360f82b7a12370c7739bcb1910474babb8635eb9411213dfd44052c4b865b8a086a88eb6d1dbb3aa571e0a2fe879fb9c7249d2e8df98c5f8e2db307b81538cb52add2bba79ead99587f13b05ab0c504e16963d8fd3a744fb108afcf9f5eae9a4007bf1402558ecb301e07885c4a0c30c2861e1940f482d161083665096e928575b776fe7cf4c42920c29e557f16d021968e7c3217e7f4c12ac8a916033d84f44713b258b626157df0cdc6f782fd3d727fd1a936250179f6ae6b14101ead97e541081a9a781b6263bc198c3fe9542efc100738db7374cde8240da2d3ef944f2fa16e67682ba9234774c92d7e7933741fd248d0e0ec5f96b2d47b69a590dc3d5edb2b2a155dfd2e375a73236ac0d51249c2dc39b0e20731b19c4a1e271daada56142562de41ddb45f869651878b120bb2d1cf7f94879e857e6e2e8699399e64c5a70154cd2c76975f6561e6cb6ddfb2e963603f69759c19cad0accb5a8620dc0da4bd433119be793736c898303fe5c8acd13869ab27a9e4035a1a084230bc6bde4c0cfffe26642a1a8ceb43389a24b6bee779ff997d13aab83be99e69638ccfbe968a61d115514cf8cfce18405faaaff666959a7b3cdad8f5b54744d3d0b88df7aec13ce2ccb75e3bbb5ee0963054aa7683f8be2c8c4434099d0ec9112d0212f470f94d16d5b586c6dec707eff4a4520e66864dd2780ac776dcff05ceb25efed2f1da2b22df83bcfd1e1d71bc57a97a20ace298ea710de30df054808d9ca64230f7e255e13b363e46324e427447ecaffde68be9fecca02f9c6b9da19aad50cd547ca4cf335f0d6a2d246e2c72787beb8a18c67ae63f6208dc73ed9c4faa3ee7df2fdbf11967566225d549e57be1fb8d373b553ae368a2aee1415c5b4edc998caef24d5b518fdb1c91794ecd783dce19babb07d5df465d0f79a2d2096190bf543d5d812b69bae4bfab17c0fbf88b435dc7f910dabdbec21f9c792922d8973dbb013a3af11eeec76eb10a402b948fe1fefbca33fff1174f12683b98093cc6dedb3f07d0f6d8d609e89182a340fe4eb79d7cf6bccfa37e73e6bd71739e1177c7f3b1774fd63d3f0e975f041a66ec96c1f764ba4d502583ce14093a3b4f4207a239eff16c7f3c9b58fb9fe6a3f48a745fc8fa467661de9af4597dc6f9947156dbdedf0f471953815c879cd4d8a551bbd650bd4020ebb69cc8e17adcf1ea2a4aef4bb421f969862ade58d54efec77884e8bcd640c91aa2436455ae559d9d5c4cc5e9c5a8fdad46f6e26cc1276e6e2fa875d528528d3e2cb1908df09efb0a05c91c0a80db600972e531311a084dd8f74833b32a770107d4eaceebdf3a302e51b209c1ef25c3fcbf1f64950aeb90873c466f631124de398755f09bab3e7190acfc80c1e1a42b88246d85fdbba057c245c9e4b049c1791fd23f3f408fd445f96b21f58e85acaae524bd44b8e54b8d7834bda0821d2a1335305737ca0bb81478cd9e02966542cc05aba1b4da35e4e2c78c50f6827b32eced7333ce8100be02a101732cfe23a2da37a0d19ba3a4b51498277783003c1c348d6aca4b7d654a2117d3a6a846d4baf0a77aa455c805e080091867453bea20c262b8f9b20b8fd6ecbd4ac03c00faacdc9cf49b424d75d70db02e1cbd8f0dec9ff468feb9d38f701b2c604e2a362d50d29f57d7c8cb8fe260d449d523322a2064dfd50053a98539bb395f612b5825afedf7209ee447c09c64358f95af6b35d15c775685c45b5be7a0c32c0f7fb77389852348da48f74f761f0401a4e78b05078a74a1f951fecf4326fefdef05e986d04d391b990f9c4e33da139d0d09005a3e6833e92e746d62ac38f166a16e9ea82b4a5b788efa54dc6a96785a1e7b4274e98a5482d7a1121693b7f7dd4472c8877490a5268e4305d808d50de7ea5394deea06c5530ba828e4fd225cf3fe2014893adb423415fdb577cbac9ffbcaecb2e91cad7966c8920213049a6c85783e158840ec908abf0293dac830b07ad886fb9eca1467aa6e25179b5629a02a5faeafebfcbe7e5ccf796536e526135372ffae603476806d40e3d237b469a7e4e4f091f0198b8eaeabe1addc600eda4cbd9447361155c710e7a772c0746e82f03dafd2d4f59625fb5db4bff546764a7c20ba12cf08fbb53eeecf68eb0004f6302258032024da13e11497807afca3d813c5fc809935c28e4547f10ead553efa4150cc499beb6f7ddda11aada7ba8960b31bf8dde9ab2f5a3fc423a6f88557fcbc0a1b53adc6d98f4dfb0bc5df0c0d1720565a620fecdd9d609fd9e7c835de0d97934e31b6e211ad57bb5401b34f9ded85edf8d1627337161ef247a9fb20345bcbb54876b7a36df6e6a06bf58e3a1a62001cf517ce2a01fdd8405f53ba925c83b53daf1d0d205061970d55be69520af52d60f09208f4b4a668eb5331dfed1aab987ce8173ca2acbf4b8633e1967421c0fefd5003c824ac8027bbb6d705286165d1c82788e32959662a37683bd64f17e7c37b964d72041aba205d1d26bb4b0ecb19f98907aee7305be86d43a697e7cddcc225be827050d6219be15aa58ff4fc5b18ec417fb8c206359e1a45306014c8b63489b7e01fb8f702853c4844a5d561832b04d56b44d66717dd55ed0d3801f008a7fae8bc81613e0a34c41cb5af337ad904a4679bb3f12d745dd81ca40aadad032911c48a37654e7e83b756ed44698a7c30b619b9bb16e27c6c80054eec6d4dce8c286a700c4eba549ab4338ac9632c1b1627733778fbee6d30d1aac04b68b6574ade601b4a9fdded893fb91b3b23ee895a68e06b818aa31df770f22d2f1a71173e9656c75a4b878185424d98984040fec9ef3eed7763057905a74489bfd1fd7893f7f6a8c63c7486a987de7aaf62b4481cb47987835973d8c9e4bc8f8e337beba76dcf2e6fcd999e293f9d4da2c78ba8f5b435561df11756e63aea7536b69ccf98a743ca065140d2427e43a393c1951280728ed81ce62b9043de1f5d2c27f1bd7b179232288aed237fbcedc07e365e05da71e20f68a808813fab55f2e02479dff575e8531c321fc7ae55837a6d1fac4461bbaffbd6d80a57179f98d894a28d52043c885c5276d5837a0aaf03e9095016915d8004d3cd4476de5c0bc1986716d64c2cfb99c975ed109a7e67b7b99742dac4e8e627fb12010eb0a876520b9010353bc6571831c54b6f88ba0718c8fd1218b1f28af79de514ec4bed6942890d652c85d395354defd68f07aaf7893787a55bce9345bd2aba0278fab9eb41ae200fc56bdef29a47ee41cee39ee48aa110427b42e94d56d3b7ecff663fba9fb7e2925c36b5664eeab4a60a2fca8967ae8bf2200e947597783557c11ad51bc213bec3d5f0ec27ce6aa6f06b9ac608b2267e31b1653a754ca345bb5766743fda2bf4daab6b594068561b1715ad0ed2fafe82e8e825044924bc28e97ad23b2d733f17dee1d999314065e0275755831d8ecdc5becc451f9d1cedd63a37a4ec46bebb9055082e8aa9b475b7212ab9e8f2379087b7c3003d4a3e177996099c6e58bf121953d384cf4617b6d39ef63966c250a6a020f73411e2bc0fef4089da4938bab842c8fa80506de80e5d4ffa56088d9469f9d0511bd64bcbe74b8089c02df88398ef2c5f79b72a0934f343d178409d86de0eb7b80fc970b75a530eddb36ba59901d775acbff32a955f2308eeb760cf638b73b75699aaf81e9e045b25ed7a991ecd075bf512b9bc569df58c0a5f226ae5a24cdb154440164fb80a9f57d6745a24395eee0087fee506ba5ee3db4121875656d3ce9f25d263213149bee10c960bdec30e8244c67e88cb5dcec692ff5d0bbe50d5af7f19aecfe76957fa98cdc36da12221dfc3993896a595a3f7f2efbb2f1f13352c3fd9a5983929ff74dc6b0270d74af2cb510ff055c113b3650bc98399122868f098168d5ab3efbf829578fc4f3e65b0e2ea6bacb7dabac72ad902e0023aebf8651aa7be2afc7a4acdff687f4a1f6edeb7245538b9279d1a555f9d647350ef02c2cea196c4a174084663e0fddb5937d650eb41a2da7a73de81fd348108d9e3b763cd08f5c59daa91e8293b0d91667b41ea0650bea28fb5b7470f40104eae39de82c539c1fb9557364dfb9ce966b3b2a00e2411a233b3e83e711ee8ce26f4ab512ee1e964be29f1780bc88eefbbfb66c7fc57bf2bef3a6e7f073230da442e417b9a99e2495edeaa8eecee2c21d07dd25c5e5b8e772b7b177b2c040139327d4ee1bf560e62a07c5ce4ede500a5d52fb35c4ef57b69f72f09a7c5284352e943859649f4a4a54af1c2971311e54591565c97af501729ef89046bf66e6673fdb719c4d385718ac00223f90ab1bcef8a1f3b2fd33534a1205100a56a07954a531e9f2a7af43b8faf6d2d139d135d36ce20351d6f62640100d018237139586c69b64c99b64f5ab4cb3aa41ef16fc0cf3ae081ace4795e3b6c78412ce6b0a3d13096fc768feb4eff9b5fa9099f187e1565c4e2fcd6472f87c374cff8edae135675f85b3c16a621fa56fccef791ed8e8606116780114f2fe10797e8337fa7a93ad6bf72f735eed330cfc8f9beba379844fed03b81bede3b8613581e7ebd157aa14e30dec9d165e8b36f82e66892585295e1cf6198ed27a07bddd800ee23918d144e21d96833397899486dabb56cf723641c0586386a0d7006ce17428b7f6daeff602a729ec985b97a2b3adf989a96b5bda112a322e2a7d33323cc15d2b96ffb32698c1ec8366a2bf4d7e326b65cba14542cb984ee5bb8e7506599d6347361df6166d92e58af99d5273855cceaa50bf9ff0e64c089fd826471eb8c9d956d8d7ca4ce9c8854a88c2a3aadeaa7c4ad20e138952e38b122cc31ed6f1765cec66eb2f776866ed4d5a824d46b20170553d5079cf304c87bc3f16bdfb4f4842b031da3bb0bda0e8779fa27a3e8fff2244e5da66ec8c24ece2a5b23a538b3d0ede73e05331925062f01590bd9541e79cc337a92142c71dfe5fcb84c65facd66c8258e9e08a47d0220f5106daa2a3ee25c477f0b99510689d18dcfed834e8a4a67d335fac651cb39c5366d20cfc9e5f1651d0d742ab748cdf587c58f2cc30b37e4b795cd5d21dd731b8fb91206247d22300eafc999e6b79188e23065cf1450b650653485a0b34dff348d987f8f79c4313678c4e6ddc59c0f17285c5f9f32056b3123ea22c9237806b6b4c6adb025b6b9a5d25ffe9077a30a000d7ea312536ba8fea88eedf36fff5f5afca4b6337b2532e28f054d70cba05ff755dd6d6518b5e7a5a8b3719f71aa246d9c240ce3b0ac2f01d074acde3e65cf850e1b7615c59766062936fa3066960a522dee8912debbf44fe3e393628dbfc3840f1d556780fd3e76b0b0f66f0702c4fd15dedf1607db71c99c5a1125d110afa4d55242e1aa0b943d3f18bd07343366794a300dc73971a2a274147475331491eaa74ebbcf42ef04181a0eb30a28392b645af57403baa2cbc17a14b3452dbc1d2c0eed4dbf582172b764b0326a458db76ecfaacd2b3e188340195516aa5747fd969784ca05941546408cf36d816cd46adedb10cfa33bc18beea63d4c5fccee9e27f1d79838c784deca81ce2a8ae442290c59970a5543e386cec947e04216d021344cc4c7b394c567e3c4c37125d46479e815fccb2f6e083096a9fefad4b1f4e9e514e6b41523e5770b3e912fd7494dc87275f438a0d99e5a31f2c16ebd1d9991b3f8add6c1e171fb37e9105a87d46d243f5dfc271f345b303ea6f657467b1509f13ca0485f5d2a924f50945f03ac98c5fb73a44fa459b03f8ec18f02debe09e24065b8365924024eb0d544877969ef46e1aff9802d00eec1a9ab185a9670aff4182a2b2a5fbb2ee3aace5270fe4fc08d4535e0983b74d8204a7aabe4a4fc72c846bf0087e3a12ebc026efd0c0a2594f60b857bb55265cb2bdf037d2ce493366b686a413f9e66fc10727ebd4dfa98ee872dfbfd057dc2b99c0ac2e886529ce0ac7369aedd09ccdf1425ed1c308d3f8398389d793cc7a69c852284265b91b117072e29418fe5fc8e8a3b24050c6818e18ccf388c42c25523ffb3f1136667354ed3b4cbeabfb4d091924b358ec992a7d60e27d200530448b6f9fadcbbfb3f707fd3f6fe4d343d201954dcd39820f89d10678a62c003a6471f62696585f2a541407c37236d470c2abc34ea1fbd22ea11b56fd4e6ab1cc49c68e329ea34b7ce6005e18ec18618ef06ceaf684058179c47fdecf9bd3951ff49c56f93cc28040d2dc19d67529a027a2e3d82b8cdc220a60910f77d57f013fe589462b6027cd95f0e3b9b02544fac840b2fcc340cfa3885919e86fa3118c4e836d17dd579f89ee065c215f3b0385ca8a0c9fda9f645d3180006249e293f67eb20833de64803cc540e1fe0a076ae02c53cdde0d718a6d72366f72eaa1667f9b9a0fdfb13b3ec0c9f6ce176c6dbb7977e3f60d5f2390fbccf5ce832f4bbf91f0619042a3dfa4da04d10741af596bf00bbedee6224d7c336282ece426605dcb40b62226e74015f920be490d00f850caf2656c195096e51649e8de5647c963a300676ccd680bf6d8f2ceefbdfcd9f388daf45c9393197fc4285e088adcaa8e970b82d176b5c81e14125a1a5133a44209f094ceaeaa1f0a514951657c6743a72c4e50c1c4eb5fc739310bc96d436c903ed2ad07d1d52d8718f6a122d45b58c2659d71e5a596f328ab42dbb47f4f465d5efcf3495b6b1f6bcc405a2b36458f2d775dce2a58a2021d77f5dd845d37c68edb9f60cac871d99274d4907846642ee07ecc4487ae29347b2aba69b476a2abc9e846260bc056ddcc1977f102525e6a1ae3a64bdbc5747f7cb3db2fb129e2dc065201a00e7df67a7a231d2c06222cf8bf0c015474656ee7629e14f0ed730096eab02eaea21ae4a75737ad488c2ac1a965d3135b2c3d5eef49211f048db9515d05651e0c19ecc45f0ba81f70e168df974932fa4cdbe76e349dd8a2a51a6e6fec7a659d04cdb9cfd5bf0b715886e0b31555da349b7e23b1b8bb90d385dfe3a42250e55d10e8ed10bd0a1b5e99ff2009cdaaad58b38cd65186df456782465afb60b0c3cbeeae01e7c42379a94f1581aa86ef8dcd932ffaf12764f19ec5ff17701aa3aacb6d7aba44f621c6b19100965d7de0238221cbead73005ee5badaa7771e400e949da5a1acfb415b6be01e25bf3d4be0b65d8bf84d590d102eac12b6f6de75fe6b99d1a0e2e6d1f19a37fafdc80565d8fb03d57f9d17e7d403b168303c64011442956a9a01ef2a6c6cccefb384ecfc95ee90b728b7b4937fb35ae13502a79d14c2c105c10be5a88d46340706e7c4e18b750618a5716a1757315e759bf5f350c7b110c3f1880dd5129768da913af30ea7aa69ce28c32887fc1b16f280b468030b0eb86189f2a020d61243fe055df12aa88943822b0311eb102e016a71097a65b912b66417684a6fe13e05fb088cce55bec72297d92afbf0c4284235f1726f2690fc4747a104ad713685d3d4d6ada9473d1d162906f5f16ebc9c1d829b61e47a9a4170c167b0dccf57e73424d7bf3abf88cb3419b046b2b5ef797e7531f949f3d451781c6017e023ddd795bead5b49408f92152a6c992fb374fa71db3c8b60a205af6997d38036c49be3c6ee871134226e9a572c463910e5594fab672874c293025092dbd6a04f5e2e9a7c3da8ac6eee180f1b3beb07301bfd710086ef7d5a92e0d007818b200f61e594cdc97255fa0e1e4d85082f1f1d0a889feabac76de73ec4e61fa35d864f376a92b6317ceaf4cce287403a3e1d99ad7c4f099465ec7f764febf584af5b5c529f5c980a5dd8089ff0c2f7d50f1d1c7b7be99d28bf8a0709e518e945a5e975048795b7e94b2ef9c72dd1ddbde75d4f64ad190e2a6e3fbbbf3c3e1ca602ab502b3b97bafcbfab1c451bce263dfc6492a97b666584135badb30145f7da4c9d95aa3f4a2e329e09da0c722e8ca490f4777c7f95d08e5e9c3df474e4a473a2ef62b6b93403f2b2cf319db916cbf6168c4472d38022cc99bea67d4e3e934dfb29c5ed550c0d667a9d34dab11f24a52a4576c63039503bdf97717f56f1f798c2cb4545e7c3845279eb873caa11de5b76c9396d82b4f537569e00f3706247edfc8c5ac10865847ea8f0e34f2069c0ded6cdf0f5d7d3cfea1c760582159abd6d6ce1f0004c058eacb48598813fa899f54cf7b33de23e404abffb07bd6d19dafd6419e997becd06231596063f1c92b968904eccf1636ecdaa5d19e4a19377e08542809839d05ab3c43aed2364c46d750d566f39e23f42a3dfe4964a72aa6c5747b32446b3e3b141b959f4f8f97e58a6e29a702e240fab0debf9ff3cdacb2d8941488bb0b614a9c2a58f432445d57f2a3d861b90046942ff3e7bac936603a205a6fd678774fce4297568bf57243fd56204b5667aca46288e8db9f27a4bd2051f5dad9fef067f7fceb0035ad8be8c6eb3feff53bc492d1f7629ca8cf27af5076f9a9d3e00aceb01ed685c750083674f052e0f3f574506ac93f694444c0b68474e819dc548d0f99b26ad7552bd7484c9473c4c6302a2d3f168ea7f0cb1eddb5f5cd9612b48e96c68fe946def10cc61fae9f705e0a868a61c9b1cdac49df4225ffdd21334f21f691f5dd8b8348fe3a92e60e0d6c9e898837276676810602a4293d6db434d32cbc2cd0ff80858e476951ca5c2a0e894cb208c6898b5c49c77291e5583b2f062bad20743f69ee94b31e7f7b665af9932a5a2ca823008b5ca9949a1276fa1acd34f99950f9f0c17188c5a5b1447d4ed7e18c7dafbb41fd1b56982a0c05f9e544b6b3ac5e960a64c2ffd9fe444678d83e67825f9ad8f1bd3fc7123f1d644fa8982241c682fb527858a7540294e2689cd0c5d6eb6957f2d0294d5f8a6e6615ebfa45532fea1184c45b72f025c4130196e4851d52d5699f9e145869e76ae823117d2f540bae1935e7757cea893ad796610245a0efbb7d7c50028cb9371b13fbf00a0431fd9fad30119a1ca2a25274c78b0de4689c0203cdb782f17c955b752534498bf453dd6d2b2f3dc32b6ecc9626093e9d3d4b9217fba239d2fa2674afbba42b6f6305fc70fc866e8b81eb2af161e496c9d53a9ec5006f08aa2a6f23973de88eb1c636aff57ef9fb6108f0e7a9b0af2c1e1ac6bd6294545608d5a1a1873647c9b770ece171f6c7dcb9e975ad14be0a9f713a39edaaadce261b3f999bfc691d21e98b29f8c6798bbc276f434dc05af6a513e3a14168ee8311ee40e6fc7f1d6b6426636ed3d3b6afdc7a9a423c7974ff2c534583e4b27cf9301b2213010e4bd02c7fa4883efb3ffb51ce52caa453c28357e97485a6174b5d1c478f4fd3ebe29ade24913bcc99373f797601ff10a2754b15ba5cee6e1bd3473f8b30c9337a61aa3bb9d84a1d86d7cb1221d43c4502180856ddeaeda79c7f36c80a57ff2a6ab6790efe0c30d8c5e98f83b73f43d53360e877d76da247c90054a134c3d9c7cbc20bb0eb98f7b3954c78471f198efd56f52b38397a63a5fa42fadbda953fa69a98af81e7197e797e715b5ed8a40b89ba2fa3f3074b9db3dfb79c95e5ae4ef673ae7ee16b4167b43c47a0be615cec3ed4af33e652a97be546aaa3b297ac60f30537b4b64173eb73ca1c8422c1a415e1a795b42ba75f88b86a48d8027dc0e06c32785506875328066c9b6d69eeffa5ff2cd59adf831556ad9ca2f1eb290f82ce3801423f617adb50a344214b42c19f94a87e4669fad4c5ef78c6678fabbe71a9710f78cd8b286fe542de98ef6643f8b7c9cce7361ccd5efafd94e3383bc8034acd62a7b4a2eb70bd48e832582376a12e4eaab95a5f960d7721fa0f8a5a10df32e95885d7c4194defe87b9978aada55664725e6c05eb55f1d71cf76e0bf2ab9cf35498b014dd588daaf65a0bd4e8c0c1e1a15ec0d032975917417a3435c2fca010fac166a9653f98944f19c73822593dc3b3108c89a2f55b919c79b8f61a51aa61e84b9a49beb820dd1666d626f8d5ee791ab912667dbdd94861ece1f6af8cb806b8d9edf4228a3b88e877401d0d3100f3fce1d3d27ac7df60f3ed8a30e63848e0f95c451ed3db25fe10b8fa35f6a2e526c34372eb98b76ba4899cfb752a829d180caa0d318c825c8bb51ac596798fb98cb282b504bf53ca035efbb8e89719c899fe221d09d40d74de8c23adff1c4b59a19a53a624301c8c0e6eba2e81ee34da91872a54761365178d27990a400494e66791d96486cd8fc87ccb05f58ad9261af4075188bd80fdc18fc82867c01fd832e3bf4ec11729c64ba77cbeb5258649abf99f6df117daf2a1c0cd7ce8f7aaa2629d3e4acffc6749550dedbefec38935489b53154431f08c8d60a88782f5facac8240235a409f559c2cfed0ca1ae187f2d193f22e1ab00fc1e9465056eda9c3e9288d7bf314a0306d935461b97808c734176db3c0699e055d8e4c6751d5bc4805cde706cb57ee0be6c27d47cceaa3a91daf95299b705f71da9bbea1031440a393ac0817b86971756c0b63cab9bee9ab343aee55a2f6a07e24deb8478b8f07a6bfacaebd1233b638c5c912cc310e6bd2d42e45d4ffb3bccb5c926a72767d3f433c01efba64346709c0d902858ea7b134d6fae94f4955a6197a88619e33ef1d61e1ae1b20d4f46706b5d2deec1476e81fe2b6206fa33a17e06d10543ac9964ff78d1bc29ab23fd7b492b066485eed2c98f521c77b0b35d82586a06a2f86ad919319b5bf62b2ee3c56b755d1abb6a8f41c78f3ca71918cd4b93c4cad42f06133e24adf1ab4af0a29c8a03985b95f8e1d6cb79e4178abda8e5d83dfc31b2b667deeffbb36679cd983d4d65c1cc67c5d86797107bdf0e829400aed826f1e9fb3f06a38e5868808958776da2069ed2c0d668ed502c8e0970b03da59539e3284a98e8e8e6a0c4a33c291cbd0d3a4bf3e814db0fe86822b4150b4939aa09bb54c783be86f5ca1d22a1854477e753ecbcb61c93ace3600d7f982ac4df5dcfe5a398a7f546741b711e869c6187deea15da1150cfbc6e8c477bbf86009fada5f3ecfcbdaeabc75ef346e4cf1fb00bbe49bafd621e5149267542a40b8ab0d50d904a9d138c02bc5ffdca883519bcb431f7ac03da9583aeaf1a0f769b81fa876b0a16340ad0b38a6f08728b19582201c90b2c3894580ac96ae1f6be89c769e5866e7ae898cbe695e3bae5cc79a9c8ccb013b89b3f6d24acdceb78e71ff676470b2d2283c79cd5319504818a89bfcdf035eae781dfe4da03523ad248182c60860a54c1ee343d6aa4614b36ad2e2485ad49fa8d9b4b51d0545b1fcafa26a7e1af77577e4d91e0fe3ca9a75ed984fb0e5c030f153baf8b18b14ac4e8ad6d2e7711aa697b4a23a35b07d230846d599635311db4766c0ccbd23cb5bd494f064d7010e063023544884b26c559798eafd47aa674266d84b30a80baf9af7ce77d5c6189b83e15e1e2c862536f5d4f173e587f118bd4c2dccec04f9cb3032622545fbb57b61a653ffe71d05a41bbfdc3ef862d0d096fe18dd7e4dcc448aa51307eab9435c3d8f11c2f5355abb0c3cc35625d529b368902181f4615375ef2a943e464ec5aab42d4801d3dba3bb634d58069118e5082c9a31849324572616c04b5e4c7f2229dc3f4ac06905f184fe626ca8b84c66fffa9205bcc6b811cffdef604cc432085afb0b0dc3b1ac0e4fe86681e82868595e2c893cd7470e9eaac4b66496465255f5821b07aa446017e45680211bde7ec7606c96125e10f7c6c1f0342476191fd63f4576ead389beab4305b26e4df5b2a4368c20f4906527879d3c9dc6bf38eae0344ba36c88687dec6cb9c46f23e2c9569ac4247e7abad848e870c961538e27ec6eb5998643083aed6a7d2cdd165badfe196dd29fdec8e1648bf24c51fc6f6ac65f20c92a66a7c642759172a3492d20697924d5670b92dd48740ad1872251af1624416f9737f965b44fb167dd138cee8402e24414b54b4ea8a97e6db67524654ff335edc354c384293aa3b83ca7e86aecb9a0ac39cd5b5925d932bd43f3ebc2539f13ae610c46adf0506ea83cabf1670672f92fe75a9f43ca5c775a8694d6e19e818c9fe5f6a87b5c2b5cd5cdb096fbf7de594ff030f7921b009f20472d83ad92523d4b0a2da36dca4e035fa4d9eb60216db25b64c9af72a16f6a4ec82abf692f0f24e13ff40bfab64b381ce51757ec8a4d3112fa9b28778fc6b1febe987474d5c4a5c39eddfa21314e29c1ad6b9c37fddb3ef2bb112aaef390d4318daa14e0db753e76aa08b8eb65a1f8c191849c23de105c17cee4b9f9830c31620ac212317bb18cca7482f982587a50961d137977b107722bd58400ebf2c36abc032a51cd3490a90375549cdd41bb031095249b3f5d85c0c574ca8fa1080580f7056bbed21317eaa47776911a3f7023f6df27b1d17142a23ed69900b365cda541c0f6a8e292c2a5dda41b54c0f9b605797307b859aedfa978e8dd62199a5b4a437ffaaf6e4a7ac1c88ea68ea74541368a97d2c264bd50b9956d7af3e5e94a1638267e7a800d30389d5dc4fa7e94e6812d53724780fb24052599122babefea06645e7820cce2714f61f884ab0969830a8b48d2db4a7679d7d00998ac945957437ee80509857ee2684620ed110a73641381710c725cac3cd8339d41756a72e25693fa719cddf2b66c855406c712546f3aa9187a54d87129f2c17254e232b7e7dfc86ab1a0055146405aca13a2663faa3ee663b2cd41fed84dfc8408545e6348cd48cc184f5835994f36b066b8dc20233349937f74bb651137409c968e83c9b253b2bf2fa4a13a3cf19acb8c6bdfe82883b364855c486b586926709776566255f75c3c117b29111cfb530fc24854a520bb03050c92b8e8e3aa409c485aaed6214680004e6fa20eeb634ae33f3b6e0a62995585a8982cbc43354cf8b3af067ee654c995268ee878f883bb2e1b4cadfacd3c2444301dd8496959ff24392c0dbaf347406e112f9b40cac3f753d7cca8ac8ff713f234d363abe2c768a7f5d4d92d9a81e5af34ca5fb8b6faf161a7791496d25d987afc2123014e5ea90a5bd164d84ad5caf12f3e596dd80aa056d615a0284c2d87aa265f2bb7853f44ef0aae119b57105e135d7303a97754a98d60b9ea654d8b774da7293bc8f2bbd4f9971fe3ee4e8ba7a793e69bb15457b132edc410dc86cf07d47d704e8b8c8843dc531dff9d14afe15ae5f9a1fa1cd63a5384d1674a0070c15f0b688d9bba80f4a0d5dfe0993905495f8e881946e4b5e14616ca542f83690a74de74609d2eca704d63d154244fa7aeffb79ea2063e680247c5a51e8ef0afb8b0173cf1714dcadbffd6ca299c18bab7c8827d6154924b6f563cdc2eff499cf8e6b1a6d17d361b8e7ce5bc078128bf1f798fa788aa17165dc7a8fa7a1757bb264fbce47bd118a45ee8ccd4b38fa048ea6796f036d5a9fab76f4fdc0d0254d96932e3657a42408fba964595a1041466c5752f63cf2786123001a8842a93231f8a40c2c250c7cb1764e03ec00efd664a62cf074ee6d37ce3d269d37809de44c2cb39b3f60bdbc00af5d99446af1e6b5196198c31cde2ce42adf7224edc93747baa337323efe9893e33499763d794f530b7ce12e13b3d30352059efa696ae4cfc9a0ee7baec04dac1d1713685418b89fdca40cf63d9e2c6e5ab9c77ee33a2a169fa305c55c7443b140d72a57c2ccabbbcf081dcfd47149cec3cc810341dd724f2722906e832615adaa83c5532a47b30edc84f763555b43ae0eb795f4a29e88359531960a8ed92bcc64b537be653568c4920529cecd027f0075d7d04ef135b0850db09cde8b3e2fe2e3646fd17acbdf4c134f8e20f758289632055522ba556d7f63478365723ac8e55866ce17e30498d80f1ffcde1f1e7faa5db09218602b1b69e55a94cf2fe1946f91efacf0215848e0e1da3282e66be4564f15b8e79825cb0c3932537d8dd0b83d68c94510abd6939fae3bddf6c3cb981d9c448fde3b9c0d3548f30c86e21428b2c50ea0fd18f39f959baa151d66a4c1619c017b5f603361353d3d71369601a655309be494b3670003133ff24bda079cea84b9805ecc1307628f767f8a72a7744eed8a6f8446f73d721891e3c7872cba650f1514e6b252e3941f20e6b4c6d2dcedb06ed8d147027b2cadd14650fa1ac8e2b2e6a694c222e2a964bf899d59bb0924df141e534e2a5ec144db67957c5a9b566c77d61a84a81301a831495e2cd02e085c0a1d34d87d7884492c54bc82a6401717746dbd088c5102527a3dc60c499153ec347a7661e6d10cb1fd4bdce4f6516355fd57d8e8a1ca95465ea3d8f767dae52529356bcad223b4a0e75282e9641ed9089c1557924542a7515e55494c940a3ff01d283b0e588f1a22c65d3020b714fd5a1c2b3de73e2aa9a3e23c06cdb98006959fd561494249a3e7cfdfd90b9e70b95591941e2c4dff115ea969ac7395cc866064062e10d0cbf6201105679deb61d70b033ea546b179d72fca8e0e13da6d2cd2e4e34515129b7d5fbcbc367e4fc488518917104c5134f901e17cb3c956350b5d996e1d20298ee78a03d2962a6205e004d56faf5f4f66f7b331d1564489b858b8ff688353dcdca9e56ab64cdc080657e669de68e12d2c57e8d67964d0452beebfc91215c441e67821c84c11457c9b49010b2d36ecdaa622e14ddf813e5ffecbe4d759c75e73c2d0835ff812197cd377a41b5ea5243de8656cf17b039578d5912de178621f8a36701ad16f6e69794684eaf62358d71b3eb1e0356a75926ac106c7ea550097598fdcffc757bccec19179d27fdb84677ced9c29b8fa1600e72f9424f15492c2a53cdaaf9d758263f58a42e86b62720dcfd93ee471b358d443accab064bd5a31cdc3f56b635ebf8e51dd2f7d0af001e584e4b58ba43161259860d90d5c43717b21c6feaf03e3629e9a8874708a6d214ce90aa1b54d488deb944117e69dbf4208686485b66d1ed031ae28a98700a959915869a85e365dea93c3f2804ce4a30d253d3e640dfdf6627408044a57b02441f22d54f346ef76ba6214bc30adfb42656b53a9353a8f18e427c69e38bb593209ea02a8b05e4ca6f5a5e65cea4d9f96b377c981d76ef9e8187fedf636df8c80f1cf194c8e423176c4b7f423945e35c7b0ef0f22ed4dd0bc31c8079e6dd7463ecfc50da344c8c0d407d1cd76b999cc5befd819a65ebfb39e58e7559be8c8587f8cf6214f0a9b4179d0abc7de0575fda2513fd19ad6d4904f2ba1296119a25b9aa724ca401de84922e6f591c4cde190978e2b0aa044be8bc239b52d27526332cfb088467f401b04284393d53e859d0e3eb3e96d505ace833b87c8a6aa4df75ca3ceff6c7c36ab9ec696b089bb4712953a9e9f18f8118f63630e20f7aca59b9d073a8af90d49f63835c2a5e8d653c79c288433e33f22e6ae193a2bef875ad9b288c2190058c62edf155da82e66896189106c8293f88d4901876cdeb4d6510d288347b0590d7f57670b324e8c97f0332a31b2e66c9e16046ef879dd4b81d2807e903fce266c4750414ac0dff60b33608c35850edb02c389f4572a7608700812312a3331c14579f28bc9b87ac0fa1f87c0d9682231c75fdc7aaaba6a77cb856c54cd42e2b632723d0152820422c2270976f3b53bb7f8fbffffd75b8c84f4bbd1d5bf9d94a8cc12938b08b9ec20c3e0d68dcd152b802b677ff826b125ea4f83719af6095425694004963aabbf7a0a85d106c8098fc1e6bd000740553533979a5201826083dd5963ad6922da88801374bbe537653aa812d7e982435378daa01fcb8954102bc727e9222a127d050ce5aeb8fa94cfeae25cd4147f76ac4450781789a02d9a970d98c3ed42f4ffa6f8e35b5fa61d444f5d3697944251d533f12de92ad5f01448e68ae71758587f65caf94458003b945ee52148896545369d37fee367fab7a82ca5edcdc80b544f626c19578f011ae1fdb488d1040466ade0b14eb3c8f27c1335aa0af3f12a57765a31bf27f4932024f7192f61ffb83808818786eeef2b4e272f027b590b13b32ee97fc46acaa91fa83fb6b0ed5b535a8e0e97f78c720a9f49f5d4de06e062fd669ad4c2798abe658d8e1221aafc764e77e176e46a40c86bf3ecfa4a816a48a640cd034dd351631f46437d0a95e79bc56fa4e22ec79c879633d5530b58c1fd129466e5789ae3b8c51b9c6f8aeb7a1de117af5f61c7a69c192ae5b8f29d13474d6c53d48e1439f9b4a83cf337b1b14b8184302296f3714f698f3aa4f263b503e186dbab372ba272675c04c2d52d78b075be297d34b7ae98a52a98e71d463c24d1d5c32c2dee75963bfb341a8f6a10fb7b4338679de3e29a0a59740c8be0ab97a50041f4430e53fd1d1de980a3b98643568130dea62b32da648e5737c455b20174e2b96ea162f082eaaddaecf22b3698e55f883335a7b6742cce8aa893c8f44b6d085a7013637ddbd96a7913d1175d0722b5918b585369dd5033163405e36b64ea36745dcab09244db6951d2e39ac196fdcf841914909adbac6c0f4b6654d0ba2ae3b40c2a8cb2334c91c1ee951266dbbbee5ae25ba1fad090383870e74a174ff7b824cd005b59241a1d02a6d4a34d230cc77810e52f3288cfeeec3143fcfe622514fb3937299ee7fc1e7bc763b25063400229221cc60a0e40f962037822ab20848b40c6f622631722f76a53116c015b4fbce67cf3562757b554378f337a51c81862412a581b168f54dfdcd77640a0a0ec05782f44b24cb402124d5d0744f636ad15d01ce608010c6562ef05c4612087e563d8ec29143a57c2d8fbe5dfc738d89cd25702a4842a575be16a3943453c101e4ef3891a97116a39618e6c80ca2f557cfbbe7bd34cc69ac10da8ece5289a5cfdb12e8878bc507be3f9103bf71b5692b0a819ff66c435c52d70c6522c8a004cd56fc57607e65840e5037019170c87ce49232ce4ea70981b07e4329228ad9a3fd5dcf134f8de87f0e474e61904f00af57f6abd8eb17cec5d68197e5933184d306440e85e3a4fe0ba8c55bc14cba3b374fdb0b9a03a35bf1ee91483c824161a8b5258a16f5f4b42184a44556dcc00092ebedc245e208e6d300baadde78938968530d57461a3c433fcb2f38efa7b68854aa808ddac519cf4490309b1285ccf6cdc39da83d79d14392658a86f2c9941e20e2d032d5a021a52459630bea63573f42db482f319b676bd15b2bc24c98b7574fa2fd02e9086e67499ce72ca26da7fd3625157f76eb38a8b62441c51db02ef98c52a25fea44182bdf15ff8550b3292b4d623dcab9aaad5d57b09cbabab4c22311105edbaadeb940e05a93ba2b9810f0b33f605c18f183ecf0fb75eeedf1f812fd95ec65b7fb4666d0e668d0829bd9ee72d65baf49a3193d39d717e1319b70834fc1c845007366632895091a09654a9dc9eed585d934b0220f5136ae5aa31b2386adfacf425bba7c9121bbf3697bce0f29b3d2f84d9d0a01ba24572dc4625004ecca8fad1741b5f039472e2920141b5ad907b05502f59e62f8c397d4db42d7967b767dbb2a24f67f413f0990e6b67e11f81e291bfb25c2e31461484e8ef102438bc41f4844fedbe66d630d97b3043dd0feb06017485743a57d3a715874cbf0f1fe678990b92ec07daa79c695b45a26a2cf753750beb43aec5e268d14a6f10cc237b8456629174061479bc646343e70951ecd4814be8f391a4c33fed0b419fef020f7e6a4fdcef2641ac65bb5574ba84da162baf1bada2d0c8931db5172f90914a3b5447666854f6a4b568b126d078630b96a4fb4f5347bbec6a0c053f555ed0868e4c14fa625ea7daf1e35d73296d7880c1c45543bc51867884c7ce346b054c7e843e2be03d7890a5d3d52b48026d54b51833224297bdc9daa9c6973c8fffac7e99999b02a22dab51cb0b5b37c367cf98eef1bcc4da6601715f0ef928489717b9cab8a7c2315215a4891581bf4ed4843143f2ed793a2d0d00960422aa58ffbcae153e442b4578915b807603022bae52527d96782164dbb1bce2ff53ec3d7b4aadc8309ff309ef0641c2e99ec9bbe0dc5ef67990360dd616e47f45628673a4785bb6619551b142fcc7a42ee2e046940a208adf5f6a1b4e48e497b039b8d6817e559e283a9c9524243fc57eb1b8bccd86a89c7d81ee7110b7149d4b55f9c2b79ad95ce653be81b4cd905380c45e7f37404948fa868f2d15b7feafba48d7c1908d84b3d7db78845f6f93c44126c4a1b6eb95a54e739f599f003656743724e8ff1b1ebdac8275f9eb24ea4d8eb75359a57d795f7441b067152ec1036c5c753a078f755e092929b2d52a75cdb4aad89b28b35a05355d1ef4b94212390085f1b21d344e468b678668d06252feac07b5231c8a50cdae276ba1131f8f37b4936fc249dd5b4e320780e521d46d1d612a68547dc766b826736714220eaa8e7bfce466a65e4f4f10885b858829a25fc44265b91271f24a0c0b2e5b753a8a03244a2431f210f3b9f59cd3038e2f69db48d339194b51f64aa72aee48dc354495b89aebd39851578768a90aba79591cc839340457f4799736c4028690a571a29f8e1e431661020f52934b4db8903dc53479123a9c77baa164d837eda75ec87d5e0c9b2b438a077caa02d0a465f5147e9822ebbe84bd2c1c0183636fbe92f5a5531eec9c70adcb2bf8f6ba398f433d62de9d944a47baaaed570490b64f4b195a51bf7dd43728b9437ac9418611f9ba0ecfc0b41f14e753911f41c1a51dfb37512bedd0f3b82fc4fd3863ce5885d6b1b2f9b64612249b0bdbb52b69039b0bb75250e2fcee03ece034fa0c81a69aa6ecaf7e8a1bde314cf7cb80f9f1f3107ce75ece7229cb402586018befad2d0b465acb5d5256cd573b0577e55e374409e1756783f9152d311d3466f07356e84e598ced293deeae8bf862f586280a84c799f6977c589237e528eb0b5153ba4e7cd8387344e92f1d3374016bbfecaff0da40632ec62d05babd7faf0eaa8ec569fe7cba0d02be39148a0b1b1b853c5f2f133497e32d84e9ae157e0bdaa0b69bb50a288e335b4380d8d519a98c2dafc6d7618fd2e3b9f54a0a2d4b8a1504e412d4008cd7200ac84a2d9e1decbec06086ce721d3957d66b4bd82e6b3fa1cd81350f1ebedc67380034db666ee66dcefeb26f0590537a7b67a0ab6c473ea2b791c2ab2ed985111ea9ae86a3d4de66f74b538950c98d46ce01145c2920209fb664ad0b2785e24d34a87ad6df12e0ec9c16e725fb1eb7aafda305158d2c83acead89ba0ce0aa4b4dd8e31ea55943b2d68fbdc26744686535ecbe3b39ce688a9d90e68aee695a215a6e5be206d0201c49bf01aafb2091004070db5764ea2548c0430a1dd766b56d97b24e02edb778a506183765da9fa527e6ff293fa15988fbe29510b9e29255df184c7ac856165f11985e44057f61aadfbd3362d8a817ce889c6b21a59e275fb5871820a09610195c3515eb6229ad465355f6342bcc2978e94a9a27b74f79695256d2e3316be489a117e918e51bfaf21fd5cc62a623c11b86da8098a24ba40342714b139dace2c66bd5ee370fbdce86e65f7474dc66fcc1f2aca40dc0e36fc091909c57ff84d87245acedb7a08be693c7a40adaa3ae3c57f107921b7bc52afe361123f3d818bd244497dcdbb4b37af5f898a7051f7db571a568d6495ddc07fba64de24fd375671f9be9b07b86d96d40ffb5074e948053034eb424ca5595d8c2861d1ac212a5787bad60ffce9a6135568ba337c2b0f5f0898576c454a34f487ebe37e085b95d9ffc1b7a9393d4ad012eb2dc785648b0d6711a774a49a3e8df365c7b0ad321e39668fc907d6921f2cdafcbf3ad1f77ee4c1f26502e3e099ac911cc41dac845670a066f81ce73e8e7be762f717a8d999c7638fad4dcb1a0a31af3a913180fe938171cd098bf8899768ecc91f9cb614393a5bc2407bce7b18ba090d9588bda616b4e6100143fd30a188b143826e1a4475b88a67b88e5bea05c06e882501de527fdf77be931d1ae40ff1b7c32db51f1d81b3acdfbfc56c828dc7a9c158847c2e963fb029ae5dcac9b1d42da14fca03e3574bbe91616ea910775bfb7165e8443a618aaae9074f4bf7f87320191c14fbf0bb1fcd65638a6a98f9b51d77938eecca8a428859c872f0fd05ea14cb46c1253185d29547b3d1a8d1ed43cf55bc9e9904188051193becfd5982a0183c0b6c15a93f15baaae3e55aa4d06bf6b25b0239656fa9578a941feb014b74e954c5e503ee195c9602b8c812b09542b5d62f81653dafd64a55c6b47bddead40cdf19ade1a72390e849c1e7b9c949182f316aa1ac2e54d9aee56370f14ae5688c0cafd0f014dc5a8a7b0a4f2375850655d46f2d30b12f2242e89694b598d00096f17440b78610e57a19d5d4cb6eafeac9f62981dd91aeff35d223bc3c8d40e36b047ecfb1e20a2355aa655088230f76d170e600b66d6feecc597e6194e180bbe9a36768572210081936e02d1236af3d4942c85bee3a29f610faed83fdc01fb5618e5236aad42e3bdfc934f15aff0ff4dd0cc87bfcbfe14cd973c21c344b488ebc676bc4ca995d27a8f61b7a4f07aa360a954445061874ba434798568717edaa96390356bfa7e980f851231b3c8e4099ef482388853467761b3dadb8b2acc2728bee37f9e748359a5ef4c9d5520704d9c5b280c45f57147a64e144b87c070a84ffd82c166659c6214dfbac4ded9684616f06f1a422991d8167021d627b182b858129d37c14cca423f108c4440499748dbd995050906434322832f20d04451f9f487a42338b260968cabfadb2fe1c3b4d126524f528f92f2a2449144e37e5abea6e48a18610015b89d64b0cc96a63561d588a8a30e9ec73e396e30a8d4ec66c5a45729d20478b7f5b10d8f1766b648e76bcc9ba3207a4a6b343dd490bcda8aeeb85bd7423df06787ede165d3da54af721340717c312dcb759f4dcf52efac0192838508d8e8e465036cdbdc5663df4c31a94d0cb857e2537d66fc6b85717362c42d3389e6d1b365de29803b9f30e73e8e7f4d200254362fa87aa46a6a817a7845688e567945053cbad1f2786ce908f8c97295d993fff4a14c7554c307a3ca3fc9ba6abfce84b2f7d534aeafa1709434ec64eea843fb1e91a78c28b2b66dd30938cba42997eb3ef390f5d11309f913d545cd9919f79ea1fbe513ffae31fcf45275160470d0305ce2b166be565d6215f30ea17912239251faeceb854418a505002fac0b9b3406198ae30d8b2f0d64a4192cfcccca498b9f2d1056698fbbd21b1324e597cfbb6eb2f6e4fed4b354692acc9956248ab4ac7f2cde2ba89dff16c3cb63bf8d97f8b140ad5358684b52d612019283fafc9b34c4fda78ad2e237775bb7432dafcb055e9b1ca93c7b72c184c4fd8d3e5d052f88d8de9699953ca3b956a0af465750c87d742c2289e40bc0512a0663aeb1c99dfe0041f9cb1071b85ed7962a256b8e57121ef18ca8001280910aded9e3929bfaeec5f95b7fd1c22d4538e21170e9dbe30a57ec46690df22a00fc5f339c733185d6f1e752656ab47267040e0cd61e02ff07ac85162ba42ab18466bbe7cab9618c4a3145b91ae8df303b69d35eb73a2615d5e3a33e1f299779513d4846e7355d6ac76e90e1244e2410fdea5912a11e6133bcd575fe0f5d47283906d728db09619ddd2988996f18ec704cacce7bc9b15375f43333f323fe84892405479dd0024fd856ef24b2e02b76660497c2962c27b149b02faecba124f038252daf40e3aec1eb6ae1a053c564933180991904722c706506367c2857f85b557ac071ce7f48060b1670889c59572671f15dbb974798fc2b2c04d378e418c39cba3164454719737507b06175c772668a3b69f8fd13eca2effb11210564769fcffaaf4f2d7ae8b8ec89835f056d89cd9342617040f4c54cd1e682fdca269a5dada69c5c130a0d93482ab093e5a80cec34e7ded9bfcc46db383b5b1c4fc94cc0c87b4600f6e94a5dfd8d8c94864effdc6ed8ec4c8148f3a123a7cbbaac83df123fc8fce82d74a33baed4610feda822c6029d3af134a7b434f72fc02961779281697fdce5d52aa6f86ea484fc75393a03d015eb8175fbbf3ac05c44f73857d0b5b1897549f2ec0664d58f748b00fea66a3d0ed5b4c535b1c83b7cd0123c1a03618991c06f6857dcb9f6bad94dd6512cddf197a08a0ae3e700735b588d7971fcb5d49f6be8296a57366685e1f539698e7cf9b4fa4e2b59009a615c3ebc39d1fef7209540b6bc382d9427f38a70abf3c0d74e3b20800d2ade1e95dfa431ace624b323005af3b25439b7fc694405aed7d5894cb36810ab44b5bf5463f3e5abc168c76105b221bd450fa9030c6d2aa85a629759c704e15000db98a4c259def3002e3960f690ecc55955e25a2f3997e7bb0a19bbd7726df88bca3a4c3f0b6204b1585f35ebdd17fd95ad0c589cba5c713ed2aa22babaf4c6623a69e7bdef24c82092c92aa3dfe782b697f069b89588e2b59ec1c248b08b370ccb2ed2bd2507b205094ca4e2bdc7d8a0f3c478f79ebe73cec588eb91140f2ea0e9c68b022e1381007ff02e772e51ac907fd030edce83c9cfda16b41d9dc5f65699a2056594ac7170db27c475348b564825db51ed5b1dfa7103e31ce8b5581238dc9c9ba5f459bdb9776303418686d7c361a41c6d5f8f2e3f56a87278b98968e79abb300c6202b42df17bb661d5bd1d10396fab1c445a03c34a476f27c84f47eaea15159813c0d138be859b58e6c5f3d9058331204749ee81a2facfb6a6f2f66cb755328c18f66eb903ef76c629ad8404d885b06553408a6b193ced573a215a4e8d34d413f22a9e119f04630db1763a17d76b23c8389824bfa1ae23d9cd8799097cbf201be94a272d8def2ed76c97c33261387a7b54ab3e79b54bdf72dc3cd03bd51da4a3d96da91f067d7bf90ccbd425076086a3ba307e91c948d1435878c6869bdda98cd6d41f734f14fc523ed6a3fa758a65eae95ca0747706bd5183d759f684cf1c0ce742e040664934a0d31d89b469801d94e718bec2c44ff9b01729540839dba10d697aed98faf20cfe44c9b0380b96c858e61d4cc8eb0359bb9a5230352347bd56dd8227a7e423bbd002b8e567d5ffc87dadf30780816043afacc295613fab78b5ecd2e10809377e4866ba111e5d6273dd73c848f881d3d5aa4cfff732abb5e393820f7b41699570978df7e0f138bf93d6a1ab0e00d3175f5350c967acea67eb4600eb04f4c54f71b7e0dfcca0a90cf8921f28a208d00f7c1ebd28f52f7d190d801e97b68d443c9e7e4b25c8d031cacf7c090267d2efec7d161e62d6fc5b350ecd096990809ec624e8d3a653252091651019266c2c7e2bc5d320109b178a824bace10e301f957595fdb483d6c7f5589b8d6ece60a95279e2e064f9cf58971161dcee39b376f932ddf973422b18ca1773de6663237b78c5c56c6f19f1da2b15b04c5b18fc27330490f7e88e93cc5b5d8bf2c1c49a5ec94552b237c3394f8716e2faab1800a49c40ac9b68353d0fbfa4a853bfd76e24d07a8b77078d8a01a9cb524e82be62e5067e23dd2962d18c1fec321d94e7a51956f980eede33c0e3c84bd243cfdfa5891367eeee9e944e6f1f4d0954724fafe9d9c053ae1abd5eff85b001c2e191cd1ddd306ab74d728a6f73167c4eaed4c1e5321edb1b1374990dfbb3ed52c0477f1a2e36baefe6dbdb738b044a28ce88ee83ed4ff8fdfdfa9d2301f68eebf5908508e8fc02668ef9d99818fe0c006a808d8445246f12f6f8090046713522f44eab91404a8bc84544f0da390eb16ab95e579d878d537aba9a6be665887377608f3d9c6f3d1ebf6c5429f1c996028606a3a502feb921eeabff162111a53eb557aa3a41f11873eea22a83c6e3425f006b85b7e819109d132ddaca41eb876e2e28365e3219845bedf7d10c196103a2d6b6284396a164e793c9de3816da31bdaf4a11a79abc56d2b189ce0a5587e7bf5b01fcc37de68f3f50b907cf37a30dd057966fa39de58fecd477b933d19f4f1afecfc6d97fb3c0faa40bc238a2015a18ec3f8c0705f1761f127c8cc24928eb2d854d75ef82b874e99541905ce00f0ffe3a3902d6b784a475d2a663bd317884f3047e533c2ae051a42c71357eb68c03da22dfbd0a75340965d0bea4b76ebc5d8382d2c59d0a6b5cae7e60bb575166ad20ede1c2c7fabc9632b3f21ab7fe94b6c22260a98fe335aee3ef0d6494c9f35826d04681e6240bb02c93f889891e9c556893eaced4ff6fc9bad883ccae8304e06b01968a407566e1fa390d208b34f00c4a7e898b1a99565d8912b7a3fa3fb454542023ae623483fec88e56698f5a16effdc59240c5d8ea50a40ffc1a1b4e58e1bf50a11968200105ecd3adf4df770a644ac6cfcbcf88f8f80abaab542021102b449d0b19e9eb9c678a3d48a2cea84e21f95a8a0311d313903eb30ee07fc555b709f25f3211102caab070ceb960b0c7f5e671be3eb4c98807b0b8c7a751715bb61068047c77166893ec8873881b57a808ff4c16d38f3fe82a6e2bc5988b1a72651b85e2d5a8280f4cc7e00dc7373e80c1441583a351ba121dad3490061614803587aa9bbb8bf6b01d48cf6f65dc5f8ecbf968b1a2891c187d9b8b2d7bd05829f0869031a12b2c8284e6dd1d7377ac90e0a1bb32f2568e79db96034bb451714aa26f19e09759689e65fedb78875ccf304cdca6571051e5f92d556527ca209c2b7eff63559ae3bbc3d141e114249aa688697fd7e2dadd7565ad3e301606bc5b2c0f36d676f772c6632291106f3b5d3d3eb8cd26482a26fa22cb87afd9edf84dca17de3e1c5f480514eecb28cc071b83cb4d528aee3f35051030d04bce4709d78988bbd706884f1591e27537c7d983fcf02a00598986e58c51f13b9c3d21d00a2cc5730387bdc0463b41bafec372ee3111bb089143c2536e7810881947d9c7a10c3702c2ab37973a123918ea8ab71c951e980d89f4046096a727c0232ed54035ae961c704da5d1a4b06f045cdccfec5b87af49271674230cdfcb3da699f2b9a4210ece0f84d1e1712fa6eafc840c16c548194c713484387f06f1ead4e031c886aebcd066e7e42e7081f4f6dc7e4b6a050d4627ae2d0f18e9cded9fc04ffa2071a911cd93672f2a4ae9b28874d448248cbec392679bd8c3555a04702eb6af99f00002c71ef43f5baeb1747b42324cd12f268bdd99d234f3c2bcfb0ee58921ebd7d98078d2d9fffa9b84016e5fbfa7a748e8adad1cbeb267305ccfa4fb3b7b24e6f9c7a81a04752b901479edd2f70ab4abfb8d8b3194fbb4408b96b864d8da17792b5a8343d91a8ac1b6210f3c4e78cca62fcf9c8d960c34c57fd7e7ea6be9c98396e36a318e776d9c648633e70effea89e85abddfc80acf269c4c920de66663f7ab901b2a14679354fb9ffd5aed004a4072446a6f2e89042917def29de95ebc4fc686a4e81c09138d1f47ce0250508d824d05ecb7c237e7e1a5aa65c95d12ea446b52a1f86faf6ab0c3f6d9266bcea8a6e22a7ffab910b22afd3cb3fd09102d4afbabf47a7afb2c077633a69e257ea5673da5dc108e54052302389daaec393ad32fa6100582b7007762d123554ed51df81584fa9bba8ccf350c987207346c429edd78d041cd09a23b0efe2c322c9fc781023666963b48ae19e0936006871557f79191c1a8b94cc538afc673f4aeaa8701f66cbdc28b95afd80691b45ed8be26b3b6dea32b8818c29a12f4690298219d9fd6e97cb8bbb4615ed343dc04850abb15ee313eb3e345d0a056538582978090b2c2d12445592f9d63dfa9268b9722e948a70b965105f1b54a6fe4b5592e6ed4092ba83ab1668854b9e0e8b656d16945d3d6a5aca7648ac3e05602d40119b88f8e4cf94e89e3f7a95f5079f356853e8365a0fbde4ac47fcd4c174847756994a04dc4a3f49d9694ceb1a3ff8621ab725ddb2fe66a9d54c4d9f1927610af8988676d4ac4e069c0e0b085f57247868c10ffd3dbba5a01556d5d8b9ebb7f33c8273d0909d708606a9668c25b1d9262368dd3f3a30277a0efdac4a8e33ee98c0f5fe1e0e66d5c2318b070a5ef5cbd27e92b352b527224b03e90d265efa76ddedc46fefcf75606f1f5734b3298d90f2ec9eef72cdd10e397a58e177193d7f5d2976d84598dd68c80684c8e8df2893f8d5db41498b42ef92469c9e0fb37caaa122c559ff3bd3092858df7a20f13a1ab6160e981d61f2279b849b79f3433ddf5d2c21354a273203c5120674dddc7b5b6ad0f0d7ad333de883364ee1bbfe89230dac2baf1d31f8293d52ed34b58c64a0ef0eae693150e42260e0424e702a6d897ca93ac2db8fc768cd4b5dcd9aebb57ab804679253da8a160bb71a61bff57b2b1747d9a0861c6550594d7062ea7df2088f20b29e2e0c386648b40a51ac7446390574470834953c38a4b21705ef13e14a480d15dd9119dac19e285eaa0b84e9137079f562a83adaee5d2f94d8dc6d0d86ddbf8f681ca7c01eaf31f15c699f817a7d1c0cbb43f872fae43e008979cd46ba9d140fc3f68c1e800ad2b61a32efaec6d3eee57caa405a69e004c611edfe1f266920fa3f350c8c4fc84533063af61739b90f8e09d4ec8b32136c26d474576fdb2847a93e2db586455f9501b1fa4ee35520104c1969b624260bdbb3fdf285d163f45ce83447fcede182564d6a22da405133e413ee9b59e76d8d68d53e94d623759793798917e2847407015add4e99df8b30cd1056e405bb9de21348d105b80bb669ba8f3ec82274b50e3cfdff0c32761faaee207e4988285464279bcef5e56d92aa62536c1d18c8edfe0d205178be3d7b7ad256942385de6aee95b3d6d799f61fd3ce638b9ed8f2af06e83f67132272100077793a7f2a2eb715d6450628889512902f4e8fae2544202f1ceeceb392d50e72a383c88cff8f5a46785f3da63dfcc0559519d19c6978cd3e6b50399b662c316026235fc5d81ba32b77dfb543a52339c029bdc9f85d2919effda1fa1782c099af523ccaaf830f7c030cfae9bc1cc66431b8a69cb2f15730364baed846f0debea68764336f704f6ebfa2b7ca1983e23d5f493572d2ade793a7235829d04b5867dad066a4857adf30156472468e193c13c49940a2d02621312d581541ba9d01b70db3c05974f56bc9e0ad5a1f75e4dadc227f8daed8ff300a9b386f31ab41354b570b26e5234dc03c7abcf2115f7787a091e55a0d81a4a66edf7483d733304e671d7efd1f3edd50cfe0b9934b70bc53e6bbe8d8c3c124f5c3d1c1823afec83031bb53e1ede31db3d5dd61e9308654113d4fb2abd0338ef6dde100333af9d7befde0c81fcf68e72015816c7274dfa2d8cec3326c66e3b466e729906f8ddb1962ad01c93b43fe59f8b398fa037d40748305f37d27f63e9d64daa4d6a41098f589185fc16cfb78e93cba0652421cce76313f2e91dd09ed9ff5888b1653649d79258c87bb1bdd9928122216522c951865c592c78c03ef92ef81351a0e93dbfaec2956563668d484324478312a91f210dc66a43ef70231d65f53bb40f58bbac46d1162c944a5764ffcc00c9d0793ade250018a8374b5e3222c1c47fff4fbc4512757e53d52d874d16b19b316a12ba4eb80c2bf0178eebd0004709f714bb41c2ca4ff1be68b3dde20cc04137dc1a45f4c039f2c65dcf00301d247fdcaed1b70cfa00c158a57c232641bdc88e0341eabca58cd364bf8f6418f897e74c49faa788e8d088fe56f8a45e4b81f969fc50c7a00f448e851bbabd62ec754ec3f266fc9399f80e434376bef872defe17049b61e11395023379bb14def35eda721718ced61e78608c3907091232492c97c18b8d05e61e6e6f99c1a8a217cd25ea256b5d64e6e2e938a1a5767462af380e8aa8183fa8454a32f92f2c097e86fe59bc0b59b06b211de3bf013aa6f7d1ec37483d50cc8c8a29effb6b343fa38946592fae986fd3ecd303a394b82d5fbc71212004c9b90d521697639ce1afb98f5267c25c374495082fd61a3daca274bc48a8c23d17c7d49e46123d729707269aae789b448827286562daa944da3f86a8f3eb1ed2335b5ca424b32aa9cc9ad75afc4713c930b3bcdf37cf24d68d2b433c52a8f6157e414bf56ef727373137cfc65b2fecc50faf87904e99071a1f855b6a9b5b5eb54fd3f727fd4002bef7ac0591085e68241645a85bb2a7060a392380ca2bf9274554c80a0e0017d65c518962c568928febd79af844e44d1a8cdcbbfe9b843520d6b4d30f2e1d30b289d6b4e8dc6ac76ef2cc413b0751d0252b120b1311b88e1cff9d2a9f0ace0881994a2d4454f366bfd8cb410d4ee2f9b2895d171da9cdef73c36fcf262b1eca29bbab73f06c50e8dd8ef819386fa43164ff52490b132f5461dae7ba3cd22efd13a955a9d3e5f996473fb575058dd3cd03eff7942ed77b634adc12dbc06782659109daa3f9e3b1c23fa68d5ec0461f5c715152bc60629bac0a423ff6a6bec3cc725bec11738d9b89e5386da8bd5532cac854f40c80ba945777f5a23f54aff7ca6a5d90ee7f29cf4a4abb4a7948205810af9f6f141707fdc9342449b4187f2154fa94280513b4dd1e5c4ea4bcfe2cb7fb18b0afb726dd460b5e18e0bbe404f700dc0437e1ae59775f9963063309f7ebe9743bdbbe325f6c3c54c3de397a05e920ee098b516c88c65420b2525eef3fc08da8ff62b9919d846f72329d28379b094c44df2b19cec1e4bae8179c3b840a59da273d09de4f08f4af9087d8f8d849826b52a74487e0aa74e9724721830cbe0790beb18507947d6b0c68639f0a974ad22e4c839d2d4b462ff47f96ba5f09f94b64d08d2d0b1ec8bccaf93b04d05f94a334c94cc362accefcbe30851e1d1efaff4cfffb42f2f012fe281c30a3c480b0e871760aec6c8b7d30ab6f325d72fa0a3d9e5d9a9003c756a38ee59c3904c945d958a29d3e53b76f59229bf7c145a06e49b52c94f2e9dae86b8928f2ab9fc86dcf2d2ee25864bcc23e4eab402e881ef6b9fe0357a9cba87ef1e4686e360570ef9352c0c0072fcb88bdff6b7f2efc1273622a062af9a496db9bb899b6668d15060eb0caeb4665fdc4210988aa0f818acc5f89e37a926e31a1ac342027e2b9098879a4d4b07ff38aec183941eef2a72949f5a2b1fd8fe2f5aeb2d1dcfca17366523da7bc6b06dcc3862320e2fdb8a148ccbbef316dd8494332b2a3aed3f933b09b174cbc9dd07538be7f7d711f1c5136057c8950d107086327c1b0cc3a4320efaee9c572dae9fea3ef41b41e4d2519cc4d5426e65fa4ff6baa42b82a9144070e75f32a6bbb7ae0438906a99f5b4da34f3d92ebcfddbde76f00e6be5b98091d203ca159f748250a045a8dcef97e0014f2d7cde687325240c5b468109e12bafa2a4bb8d69830b0dd95e8cd0cd4d356cc17fdc210763fe66cc4881edb2982c4ac78600bbe1774273940670d2f0a1a420055d9a83db55c3f0bce612d75422ef02c5902e1d98f88c8358ccedf444d4b23650c55a95ffab809f942ef66d88a0b47f45e11a278d0e43ea94f87db9a1edf9d4e7bc464cf24578484e1249dbdff60fd3fa5560e31a60310ae93102890bbaa77f43c28c6d27e8a3eab4c1cfc1f6e96632197cdfa8be2c19d730503fbc7b9ffdb6dbcedb0a68532bb153816c4ee29376fce0083adfb49f2f8062a15d347145d1e5bd2eea0e16d5eec5734dacd862e3cf0ff38d59d3981b9aea869b6883cb870ca03f24f2d9a4a2fff3116f3c1379865371691ae69b7a75f9fb5656d0a4b23d2d316bde2feed8ab251af63b6fcc4053bb42eeded10d1db2dbb4472ee9458df3c57affc162aca0af5b6d5676ba3e33fc12094bb8cdc04dbc451b0fa26b9e47d5f9221d66522098474e8bb02338f1329f38432ab9d02389b731f5ebd2f2d86cac0313fbee46dd894ee25cc23d262803896050056997a15c0609533a0f7f0bd503b1453ca28cea7e7eaec8cc5368e50c5992a678731fd538d830ea1e76f5bfe938e5e5c0a9f6bf2f637b358a0d0379938b2a5978f02dcea516793f53129d0cc38013bd0cfb5852e8c5c8dc8284a1a1ba5257ef1e43c7650bd6aea15cc1a23c9fadc6f19c420b30318849eda893103d00919d8a10cab9a27f020af4b7db960877cf1b16c7836dadcf7a647d6690c3880bba535dac41122e4dddbf48c4d9eb5eb0a04386fbd65f21ef1eb24d875b4ff2f358267186c5a4d72304724b76207bbc310e06178551c6318567845ba85bef7761fd94bde3d3872a2527ba7b1eb8011558103b1420ab0a3043815c4317be0199285b728e329396113f47a437ccee9e4b9178518f02a79985a65f6f734b4e87d6437a673ab9def08b8652329617cf553b9d4dcafd2f9f6530fa4d2a2e634fa7c34cef6e29f54c78718438d7115ce38e4fb7ceba2732d2624f5b0baa5c4e062ba6d636582b64775647a61cfc02aef497ac2a3c4c66913c09bf12094231910e02a74c78481eb248742445217fea14541ee812123d32a6d8d8c5d53af999c826bd92352735e584fb02a6f4612f8cd4c3b8514b785f029e18d0d0bf8809835add132aff336bae60c1f3f30b1851d9ce455ecbce48187acd4ff63f175b62e9fb685d02b3bf0a8a5ebe7ed59a901eab48ebeb310a34e0e7a989d2422fe824bdf6031bf636908650af239dd53c8f424d9b419f55e338c71304fef3c4f8e4299459546d25fbd425d924b891777cf55fd89c1e9f8276dcec5d5eeb686a14f9792c7bc69a86372684803b0b5c7bb80a885cc95e7299cc4b072d7821489c77dfd3be7b428d061b0b13ff5de44532bd8cc6db769e85b70bd8e0ac68ef2ca5f66c2b21ae5052398ebd948f5d3d58e383c597149e16a86fe40bd5dce279b0dd45ce26b912949e9a6b54a065583ce43fca3e6a1c028d90923def58ee7cb7f5e8432f9f3e4e7d455e4ff72274882efbe7735024cac0b6538760ec6ff3147222019fa5264ec63bc1d06041d983b47af5fee7b29ef09583ee33283033ddacb5de5327a97ccbcd3db247b782da993ddfedcfdc7224695b87c275f44c51ca5706d86e609c19140b0459a23c220dae021542824320f7ed8f1e132a645e8ca5129040bc23e8a60182a71b5a2ffcabb1941d18de45d6ccc4eef988c617ea3914a2444b0f66f583bceb340423a63bc6e57418d52088c64c396274ae81fe3fc1b4cf84b24072e0425e46eb411cb7d7c1815778a4e1204692e7da75750bf02a22ada08333db2a192a64c67ea590248fd4a9a4d6f505f9f6b0d6d5acb1d594586f895f0b0fd82444b5f193bc2547b1f789b5b170fbc5858c2a639b979aecdefd4b6a93ad8a6bad9812e3fd4e5c637ef842c66c8f2cc10ed778f9802d4c5f95e372833eb06fe10ca8a4af0ced08d614d1b0ad74b7c522f23489a0b7f74838b43431eafd3b8a8998f2801c9ff38b5dfca05d24d78444d698453b547110f205a31ee9b3e4672bb465eff3be7a416a16023e2450ef82eccb0cbee42f67ce11f3839190642cc1a9beaf33fa4efa32d29b9009b39a1e26444d638bcc680ada516f1d352fad14d6dd2f4337c9c943c50eb8bb5f10d8594a98616d03b018ea08c46720f5657a8c1ca3e47fcb4564303c12a5e12c11bdc43e774260c041d817a35d0fcd5de2527e465d4cc4ba894d5021f3dc0331e2a5d57333e067e8a32995a574373860ed05dab66fb5532e6541b4156d7a397a83acbb566476550eefb2132c4538b3fbdfa9b553c4a90969daea66bb5c29dda9480f01c26530dc8cb148926b706918b8a6ea1f63475b6c1d9f16c0ee43a758aa57e7a3b0d6dd0d3a6ac8a08e7a2afed243a87d796b20f0259fb5fba2c8d3af952d2f1f8e18b709950fc354534b7b12804ce58cc1a4007eae79afbef835512daf1a191e93d4310f1c88f73882af2421a36b05670fec508feeff847390f9b4d27cc0b5d31b74e5664d329dc134d57086f8dc5b1c413f60706bb7c2a8ad25486e3f98ea30caa97fd3f15e7e0f69d37310b7f309c3681f347c5a5d43db7bf05778426db87293e3c87cb3cfe20b901fe49054942d131d105563235f4256a834161abfded1c28ddcb886b0404a279a1783a13cb95fea161dabcf32603e1390ee090058e081e46f0e9bc6acdcf644867b155df7f08250f3526af745b5abc373c10fda853ae2273a384348c2c4479d9dedeb0e74dae1d78a3f0ff117eb766e7f74eaaaa608621d6ddd5195f48de3a05678fb1aeaad9d72d07b6bdae13f574bf6706349c4399cc387c488f0d6bfb226500686a008b36c17931fc2246f24f1c57e43fbb490117e2944792ff78957aa6ef5e95299fbc9a8cfce47f4979fc1c8d25d1f2a2089a7bdbe2ecb875ab14566c32253777723e1ad087395bdde107004006c5b30d2aa68a0ccc14c52a3a6ef93c491ddae833a808842a5ae00ae5141ffebb1f17642a79211d123d462311aac2ca4eb04447e0941f47590ba23d97075ab0be5ff7f0f0fba08b604fe44e9874a80e01ea78844bb50aacbc2e87ce5f203c5ea704667b37d47401fdbaaf04161890f45fd8bde7c55efff7ef4e8ceee3816d44f54aef2176af43b48f0798ea4929e363c36d74f8bdaf4d405d46fd5ee2b8cffeddcc0326ce2529f2c3e544c5016b1a7bb7898b7501f49d2d71cb7e1b98f79af8e372ab3dd2343d4f420e641349b5fb555e73e7a766d6bf86ecffc8642b9a2ffdcdd3f3b17b18101e1411d6571e2386d39101dce48a1ec7d5bda0057f68303023d26741ea74415512cefad8e765a42822b4aed936190f2fd84e587ae454a49d1589de41cafbee086a2498d8ee8aa7407c2ae4bbfa52cb5f6f239dc91a85559734d5ccdd37ff715e7e14d7750c8583cfa6ce9364f57050498b6f14b99b2b2c78ba14111be0133bd6c83c46c108966fa9c15ba92d63d7ec1e1cfb4a4ed079660de6fceb6c40dcb3250a3912f9f08d883a15e59a894275360122849bf544587a1a16f6c675f1789a4dd83b1c5b69b4e9e23cfe3a41d45c46c65fb24f24d2d573da1c40cf044ca11979b446dfb5ea0858a7372901693211603224c049c3eac7e9a30c162c5ab7db763c1e7f7e061485477b0b6be726c39e655f9383b9eae85e454ed03797c1a9f02b3fd1fb146d08dfd083394d690cf713328b55020dd94bc2fb9519b024ec87641068da0c045968303d7c7478d2c79f2df57363d73c2b308bd4c1719959a8de77a31a0e999b91f7467f1b92960673524e04ec35f15b905eb054369bfeb63640c32dc12cb3dbf0c803c56ad6bfe44e8d54090a638c3b53933c809e7316fcd78d582007217bc3cf6aeb67a49c7e92c26caac321db4beab3f0885bc765480a3c906426f52418d5642a46cc7b367cd6b5c2f205d95b68312e5c5feb0e74170d4583af54cf7dcd8f8086a5619da97e9b089c406cf3c82b169814135ea6484a2f2ebc7a98f4840a353080430408dff799186ac175bdfcf4cb1b24700a5b7f911b15cb4eb8219bb2958a9bc4a826b792b05de31e06415b55fef2965d0d1590d546e790a6046bf216a3e145e84169bcb8de835fd1466c2b1c5ac874c4e8f583241a6753fd04ff7a3ef0255c90fa954cdec7a47806f6ee37ea375486b89b606c79c7aea84c6e41d2a84e28f9df6dd3dc323e06797139cad78a35bc17f26517fcc7132672a35a0b4b252e145e1bfc693fccca2a0a337a8fcbd90732c42871ff81b5db6917005f4386a5c47a9df736b25fba62b589f0f5b115f5456c5723412e403a917d76fd4a24a77df1e02ac494b1eb0274d8aefc911a035a9a3f5deebd0e576f104acf4964322b573b622fda6d5a097fdba90f3c23e2f401479912f9435923603555d7357c357d62e21ec52bfee30bdad8c7b95f2e6c59ad0fd239200cf02a4cb847075c3e0f8a916b8e2970b6feef294bdf95cfd22ea6e67da4b8fde6138207a2f9422c8aeef7c8594d2b007a59fc551b0d1c640a2ef749dbc27a060614d26679820c70f15b9d1e91584ac1fd08bf703a7e9e2a82696e038d4d25438797889f025287acc516be8775f80857aa4258cdd4ae07a1b04f8d2e357f11d3b09df803de01745de720cd1f8d8e5a75cca85ae38263543cba6c8ab18ff4c0b9da3376bc8f7e76e0dda3802e0ac4cad3060b5fcc42b01d9d308e3d396888111058e3c749f3ddcccc3c119ae3549bb00e175c801662e3f8e153e28db5734b9a8de45ee8588a8d43a6ab4ab4fb1e3aa5c118ec8e80b65a44666ecad035e4879d634f5a52f98d12d9d5112552a95f11b55f3246fb226ee08e7d2cc3c94fe8d7ef41202f86c5677310ed98eccb578aeba5fe524b07753486019db2c1f8c7bd0a9c6df8266763ffc161955b04f303599130cc86d14838ad74167476d3f92d962fcb167c0e3054ae69324165429d194f5d75df955e44a646401ed77859639e098a42653bb24b91f5ffc6ece2988553a4a327b32252296029b5727d07eeaf41b4c1a8f96a4c37bdfb6f33d8232a5e173e22a2118985456ca8c9a9d32f5dc538a5a4b560164322395dcac231f493a70514d1c902a602100622b866a559c49635224d8d671137da60ce8ba7bd197484a64dd37e2e5a1b76c57d094e516b8f44a8c0f60455c82dc9b4a947181311e2f41022b1afe4f740a8e67b8e7eedfa38982a404dee742b218e6bebdd5a16b2f11a5c4906f97e566db7fa182bf9f8f4be93758ef142c765bbbbb39e61deb99f48c3140ada8efd3f694bf85b2846162b1c8c0a1440c6ff3661272c6b6c2bb9ee7c16aa0e4be48b11af594d13160adc46c9f312d759c87817302b6d2751f13f359a724e6dc083c72bb87f5ddcb63f60723e673167d0b663a54a91c7493a22505ecb22e06001f672e34f16c58af42807e16a575c358b95a8990d03531228e16f619cf5d0a01d02063d708d4a3f399249996524ca688dcd545e12f8a6e5748f9bfaca16ea4502528c768c3e05d0ec9484089016594924eb2fab67f2f830d3c7c0f42227a57a5777f6ea0edd85d5c5a86c7e7df1b297f685d9ab25bdc834149df66d280f6797b93e5f1abb6f1ff9efbc7893f05555b5cef6dd82bf5a50697c51772215c7ed791ed9e89aa0a26b87706dd713391f006ba107c21ac95d17cd40c44ce4c48d8a66ae7808f32bd8db6f098c571f71934ac2e6f4cb273f1634361a1d0e842a5f8ddce2371a8cc837fdef43d3931d66a8310d23ea09ff4495836cfdcf00448c5f7aa47ebcae973c00771d5252a0aad9202bdc2713cb85460a9654d304de8736336fea5a05cab191c7e92c5ee46c06e42fb90a0f4f90aee37968634f5082a316a2a9f7a45ef5a22f143425efdbc3e9f7b1fbf11fbf082d2a8ccde7ccd81a1c1098e3a9f0e8a92e685f5721b65bd0dd88e03963e5c117c41c263b244946afcb61eeb35ad08e4e6331798b0dc60861f496a696554ffb96a32fdcfb04ede231678e8bcd985ccb55fcab28e29665bf30a313837ab045821b1d13e3b78800a7444c20fa290c943dd4fdee15ffee187d5c7684d337404f3a085faaaea0964e2007025fd588f607d854f98239673580a9787d667df858b12365dc2469cf5a8ca2c79847f8036f691c46e953745003cb0ea52f93c0d78d95ac9a5ef6a06159f83391c96c256e4799861536638fe3ae2388aab6458065ead8e0fbc7b06e3ebbf79d2416895f0b99daab4d80e863c56002e458f3a4a6100cd5b15f115b1302421a6606bd800a30c59f9d2f488809534344ce2dfb725def18237c8239f8d932904ffc9b41b2e99d968f1781a3f12351c7d7b9561a74fe4fa194b0eebb1fcff994b787eb7379dd096ca6f640b940a71b8c0570c38ed9c7b7063703f8d151f191dfa93f4748aabf529400611135c487d6744495308fec0da0c353e110a4928ed36bc82f750416adaa2d34f08ee5fb48ac9362d15ac630ce5c8e924484c0081f9d560d4680ee2c481944d553836da0bdb25268ef7b03b7b3107dc9abf30a1b9a0af58b857b3c3f7f88cbe010209fe7a9381886c15b5b613751aee589b70c64c7cf938ce8f3390567939f9a6f1bf6f0758333597da0f9b946ad205a7b3a4bf3134b13d8601c3c9628c3914925301c5caf955e793c11cc37391438ab88e880d3fc66fc411a6bb41322c81ecaf16220efdc1bbc017b6eb9b2c5e6fea18795be75c67b8cee3c014a0251a6f9e41afce4acf23ebc40f1e11a6deb5cb16288fbeb88768ce82c1a083e2eee5690fa1eb34ee15df3c5a39cbcdf93bcfe903a7c9b69ea2c960ab624280d6e75eeb6615ed7462c3dd6acf4a57cdbec7d2a52b545f8aed1964c536a27692a1b8695f8cb7b6f3833256bed3abac47b164d4590b980d09aa55d710b63e6e7e384e7420b36604462141fc92f9bdbd68a6330088a3411a6f11fca013e02acd21e9200229cccc5bce823a4b143bb5ac7f01c21451f952207b10040b280f6ea714d3ca0ac70f7389d5de9132f17500e69c3c8884d596ddf97ec997d9c7c194096c69ee24bb77e6fbd8e06caf41e541eff465b8d85007ef582c14c7e21317b1ee4df26cb7b243ecae062bfe1c01b2d7ec939d5c2f585d8de19dfa09fad259ebc5600cedaaf977c69862d3af454f62f41fac9ac5ee25adc3d6a53b93d9f070a2e98225b155955988cbdde01d7f216147df0f2649084691beacbbc972f3306b1caaa001be9bb7f47abcbbcfe05a2c8135cc359d506447a6f811fa4b88549cfbc6cdf137517d9e989163fe1028b69575a1467c73b751500c77417f9b45032df607a961b4a78d8158ee24368924326e5444613fac791295e915b0294841845cd79d2f6736140c248a76b6fe11435f081d96d8ba62b2dfb8e6e4661b15996e863c90a11cd16599ff4b7773a6f63625032d46ce9f43eafe12b0939ca678243a8367b0b5f86e9ec3c0f959d0f978d43144ca434bbc11b6c2aa78ee5f461c77b17abea9632547f9e1fbb768e0f04bbb782e9c56ca1020a5907e746a650e5fb3b1b04ca2af126d41fb95eca21f0919d10d182e474d36da7f46535cc2498dd52c22fa3d6b198e4278b05ac4a1f269fe8be4617297be053ed698daeda2db74c3da4d9b66419159ffcb659dad8c8e8e0a0d3e9b3acba1075dde44786a673e7ca59a088cba1d14f72fde2391dc1d3b14c30ad0c9c0405451dda22f4f16e6f7d7a8424a81d6955120325aeb37c6b62078a08bee461f99601b7681cc88bb4c3b54308429a7764cfd2bbbdb7467a78414048f7042a1d7b0a68a77f964fa260d0396549e60a9fdf1ad7453259766feb414e670cfd6994d285adc41ca1b65a8d9cb475de0c583f2d46bafd4a6cd130fba6672971d87a2487c1963cb61c58e96b102ff4bfc61977d025102ee53995a609f89dc4e2a183b75ae9f891d9bef5acafd777750290eaceef6dc95a5cab5fa3c6e6e4750e98529e57dd25dd5ccb2dc21bd695a5216c4d937dedd4dd1c95c4933a2a8e9500d50d18a2f2ffda5272613fbc0f6266dac09d06d6411519cf711a298ad88267072cfdcbde6d799d26491a3bef90cfa6fa122954a16df0808f8b0b1018e52e9ca58de02bb8dc3b5b7c4b56d53d324e45bdaf1a1ae51ce4c67d3b7a3cb700244eb6e5df2234ed29f405dc847a8a15b33e79db4321ac6997fe1ac077f9467514f52ac5f547999c83470b8f7882c1dbf98fd9601c03385027ef1c895acbf2cec8df6fb0665a7c17264dbc2964a55efdb573da7b5d645a3c461e8e3c6b7f3f70da1bdb65bda772173012c0a47711d4fe1bf7a89b8f0bd674f4569d86ed59c62f1f006eea8af1ad57cf0a14bbca081adeb053944c383ae0d2367eb95aea3695cc907208627f3a402fde18a52f33501724838356c92364d14f6453b672ae2cc2f34c2d02002e38db2745fcd26f64424c7c46ade362e10751f0491f78852977d965a24cfd7fb7d3138051c658b8760f176596cd45c3280246828121310b834f8dd2c974ac7432b512af125decc4fa376d7c54e71cc3f52fcbca5095820a8d1fa1b708d61683f4490eb13cddbdf640b44c7ebc83d2c02fac312becde072878008738d14a8bb551af8c291d091cf47baf1b9fe04772d7328e3a47be29c2ca818e86655a1a843058a728442ac497cb11495d4d7bb93ae4546eba54d28ce04948b2541297d5fcfce4b51c998ace1a9c80e4d1a0197b6ada2420c805a328fbb04028f853c94bc14bffac8b807c64c5e9b2abca849b33c0ba2209ca5a94f4ae0048ab976e009241ba1376f60290b0d90f5cf8504f5c5331c29d197f186543fe8f2147aaa0be4f0752367c29c2703c024efadd275d7d6dd0c19321998c1bb019560e16cae8f53ed4e7a48a2912910923fcbc7d074f1b93213f77ee5a6a849f8aa083270bcae9ada404809d2b2c78bc4df02a830265c735c71781ae115e7f4e0f75460287f0358ed01d88a7b5cc83d2ccf94f5a8e7987839489c5b9867a17b48a92eee7ce6ec074fdef043a8fba657b3e0f45070ec9552dc393df4b6d976b514f31238160cf0e29b02d089cbc6a72dd87e34efc6e9f97b0bdc449a90254865fc05a6cde527c2db6396101236067a7c2b8a3ee36ad38877c3faead79ad0e5070b563e449e94ec63aba68c2ea3ecaa28d387406622a8b302b0aaaa4aee0c08df2031228c36e43cca6ce0809badff6a0b09209bb9384ea5f8b62bd723cc29324270a5716e6904737a121b7db75410688e9becf36df77f5ef26b9bfa701494631102b8f6de3773df21ffb2eba37dc3bd8e6a9742f431c8b2f09a77688dce66b8ff32eb553a6183e3c006b4391c70aa3e3dec48f35ebc8e3865c1f0ad21a28b5b4e2e15595ef0b085fdf0d3e9c858eb9778aa667822f0347ebf930cca40606b6c7a7c864ec7af058c9ffa3c1c73c779116cc3a1e5752b42163c789857867a2eba527280b682ac8dcefa552855c42fdfec1368556ead4da04c1308ec1294858d76e4bdfbb8d4bbdbb330a5488c2d6993a4a65e35e1893ce8964d947b65f0bc3142b0dbbe1de3f39d099e8304cf2732e58dc87f4c7b0161be11749d3ae1127da534a3a0c4c0952f42ab7efb80ff3fa9729fdd394bac772a3f9d0b5aced55ec9d4c161b5f2bc218eaaa8cc0f7c7a46d3315ec30d26a6b2867b6a49379069e7c81d9f8c1420c761f3f1dea432f7ad8a180933bb1104d21e6c050cb85160e01b43f109ca8e6b733385403507cdb1ea41c3f7aa536f7d8419548c5b94fa47fae52803128845e25e8e30b0ef9cbd73fa1785ce63ade4298b0dbc89c6813bec93570a0bc99e327677ef2341ca4bd327456ff277a78e417f6d25a4fdd3d54dd0f2bf9f147a33a044dcff50decdc053c68e0502d1f756eeff7a38123bf5221f6867e440604a80af2c1014f07111ca750f988992110d0a62b900618fc4f3dad4fa2e236cd3e56dd2b5783dfc09d94ae8152c2de1c40858ac12405ba9388ed94255bf7a45f9183f5146632db50cc5d14a9964661352dfbeedea00666f4e1668734ce6ca11937ae8c8a90a161c7d035db1302fe2b1143a9fdb07d9def8e121d327106728bab88610a6e7560b7a4fb5a425455d212705546540d4823ddc10a1fb514dffc64f89cd1eaf695122dacdf95723dcc85845f192b4796edd62b966eb649620fed0816b17337b7287b38a0c52151c3258f4bf44dfdaf8067069af199621d1d8d67e27dea057f4e3d4b19e6e4e8bf324ea8bad61fcaec38e8a46e55625a9928959e4bad8cfc3dc5551fc6d3ab81a836e75300c896363f2b55d94029fea109a6d7b34d9bb048f457c59ef123ea98717afe4b63a5363c5343aa4ceb432a25a6019d9afc7d168c517deee3dec8343c3f047790d7eb885d64b85b7242d8fa18b8f7d5c0de85edc6a8ddbe7491e17fb9bc305bfb77ea97eac8b9b29c5a0faa80786b9b0ef4842669ab804aac610d8a32e389b5a44c637250a5f5a3e30c920aa3ad6bd6de51426c79afbbf686fec60b5466ceb3cef484e3932c506deaf62bf15f5c8be25851e4012738d4022ff22fa7678702405aad7f9f70acd2bdb8caf6282fed576be715da26d44faccd465e49e05a4c7a99b73aa41c0c71dc9a5faf331be4a2b39c0766b1b5c70a255a66baa1166bcecce4f3fe08f4af470d1c5fbf8cb9ded2fd4847705a7325d395bf88fb0001522ca6102abf6a934eb12f9b6b28c331a62f543709f8f6e9b7c4525a2f7733ac79c4205276b5239e47766d4ffabfecb8ff9ca349d1c8d594812a448cbaa38f24b04a85ba6a2bce301a260469eafa5653050ab55a7b12b2e371b037e20388514c3f44601eb53dff30e670c3f2391595afa73cb7a7d96b64129a067c85c10a6ab997ed856a3b7cd91d77405ca1747f8b9c6031190657321b930b0a8eb60922954fe9e0f1c028d788bc3cdfe6c854be38640ec975b9cbc8159753af13253cd62c1bf710eda87663aad479e3dd6bbe87e02d7902c103b5891e8920042878173e851c779f01d9f8d4eaaf9701bdbad9eb309fd1ed3af4c432f1d33e5eed5ff5516b4a111408395565495085d85c67f3e70814782423e3ddedd1fc5ec1dc73c068b9ac7117f8ebba5d1e81bc17ef720b324d33cf064c30ca4419b74604bc406e8aa8098fea157b5f5ac1fdb9a9bcf0aaf4679e74ad81df052a55cc2a5c74ebb131b7f399c90044666b3dd9f9185f17ea0ce9b7da96fa549f87884608735a69ae54830ca9aa813203a14a814597bcfde5ebabcaf2eb19d23e5cb4634de0dbf79fce1a4a129397684b1e42dc226cd89f6fc8b7470f45978964bd43b9fc319894cb7596885a4097bba5e9c20cd93621d550dc53e473dd5e7c4286e4072b8fb8542f666950c3acf88aae8969c666a33e20b6f7256804bc7c1572a97e62b76a5af6f0185faa05eb9a825af9421b18ccd596f6aa0a2cb3686b1a371f2756472dfae3bfc734ed01be7e0a3eb3a1b1c59d34db37edeb21cd99ebae271437c8976c461113ab574dfcfed5e83b88ff977ae7a3e7cc2c3cbdd734c8b2baaf5ed4a1045b2081e11d2d1bd557212e080d944f80c21c0226803c8fe029f10a797d65b09a4bc84ec13b156e21b57ee735dbdfd79666e901ce86df229e930118b5a996887fb45001b89b64ede2fd080f45a5562667981a7c7e759eafc5afe455895c164efb38282370766db6bf791a63f1058012ecc45d328089de6a464d9f358426392290d2d767664b62abfca7cc894f96a85d6f83597cc76f067744a0bee4f7e0be56d9debdc523bb6706876a7f1bbf79a861a2baa9f9b5c5dd84e0287f28c0c41a252c90719726b40c1c8ba39acc4cd64e287a676e0b36db9fbbab6eb699cd39461714e74c72998c0bbefcd16afe0a44ddcd03fda78d25d33439f4757350d5c42ce98bc23649ba8073bc4d557a695880b890ae0bcb68365ef553bc50874b25560cc2bf5aeb25646307bae7196a0e0e93d46a1063ed3dfc3b3604af8d26ada10a1e300b24b25d9629367963007ebec1bb640624293421438a5fe59db5ef72e04a311cffe12bc0daecc02ed186466afd64f4b17bb36b15a8813cd491b3e39574bd165f7b897162623cf1aa420a79e0eb65988d8ab650848fd55fc979ccd5afd23d4084516cdb1c27a09bb6bb5942f3fbc8da765deee138fe5b76f97f4e7a38e6d91910f1d3d8c65b49a0e49391640a3cb99ba8e3651a36b0f753eecee6740e731bdc9052a8faa979396a49e7f641ecb2c38e2f2292a40ec52c6a7b3097b641e18fa43c96c5e36ff1e5a480a5102472c0ad8552141f4d33907fecb8cf7c3b8d2f089656d676031e121f0df10ea8660c3f7d587779b15d7cd8ab4bc4f1e4d38aa2c8ec5de72dbf62eaa85026d7c38f61c654468ed693ee340bc04b6a01a4bea3362d803323a6d054d8dee38f9ac76fb2f2e44085f7017c3fc84d892b539af21fdcb4a79db3d21cb35e2391a9b11f5610c0ded1fc98b4059a64945ce93fd892c77c6c863db50d76d788256b648b8c54c9f23c6385c269ff8847af8a3c59e3d9d3d55b76ffc1afac9d88dc7003ea333aab573ce7e40c3fc078606b42105868097689e0dc15c96852103e6682dbc456d3ef565157a6279f50abde4da3ba4d32fcbd96bf5dd9b955d35dbb543313908ff68bb47e332a76f366a698d0d3789d8f106deabfb1c323af4c26be472d9b9c71d2fb0c7718274660c959c7dd6f86e9ca88c10efd078a87c40a060a3172a2d54c154637a3492902d425694b56611b959b49128ed99eba1a704f042e55df703f38e8e7859b1cbf92a4f76be3c629093fe05953c01d0b3e9db642864e090eaebdd9316bf3fe9ba7ed8d5042499bcf646ae017512a7b124048bcde581913f6589bfcf2d106c50a58b4372e3ab5ba5d7a03f316f460243e411002ac4b13671f447388f54f70557d7d98ed86b3d9184fa11bcc6736e59deb82fd46ab811d2e945dd5e9643f69181ea6a6d434b4d520710abe4ee76e2945448df775ca40eac7ed1e63a1bf0ad7d118680ab32edc7373c4c71a8f3a97dc39d6a6faecd1ed0d07aa81e47902455993d5c0fa6790f9edcbf779cb02ec67f9719f2cc0f06aa7d8c131d00f73e78ac9afa6582ce9d597163f94930d7cbd3b0e75f0b9f858cd29ef5ec33592eb2af0e96539f8129851100f0661e0bab5b160d2da19614d23df0cc60ae1132c5f0cf538b52c6d5d27447f82efa56f4ee35098a07971c5208b3834ae9a6d6a708886efcd878de70755f13ccc884fd6c18ac95f8b60441020ff869d9ef819ad438660882c1c77a19d583bdf9f1347605d20beda3a2c7d42423926056960b7aa20a8569b8ef581035475becfbdd2155c37c71b00fd377e9da53d693354305e97327646fe3ee86d3b334d831bf45e8a8b2a86a50237a988898039031f9240abadfaa53b083aea5e12e9bf4910be7564c169c68ce236658f0d66bf73920a6838e5ba58ed1e3034bb9df8c90dcc9042b11cbd4024a1890e2771c15f808d9fdada0939c25961f25274336aea0f46de1dcd5597f090499903e7df163c751f89fac195b08b9f0b4316ded78baac5e18467cd8e4fd67c19324c1fe2306cb8652c9ae6594d503a2aea5cb9b08fd9db032029dd89467d7b743b00cc28d88cfe79af923382de4352e1fe8f46d98daddbc636553da6a07616e76b9a12a6bc48eb0587200324e8a1e33f2c0b79ee746c492b9c4409c63dbb03b3a69ff213368862158bb115c2a0f276911d9a7fd514a56aed0f8af12aa17384c3e0f54b3ca7a1e5d3a2063e76e301dd9794556c5d98554f190dfc1792ea01f5a7f9bbd3ce1d01f536c2fb2e52f9ecd1025f719d023a8993fd2daa9d057910a8157261a583c967a34da3df3eb527d6e609947686d3df7c8d8db4efacfadbaa8d7aa6868ddbccc5c292adfe5d0e4e6d96a8b71bd59e9cf4cc93a2301ad491c19b9b540b8a0f0c698432671b9f97b6598923a15159b9f1aa50cdd48343c946e1ce8f430abcd16aa5be74292c1e6c47bbb0d19b8f24362dc053bb82cae44589b17f6badf840297f53324dca63af29a1d88aadf42fa5e07aa45dc8347ba167842e6974995cb8c0df767b8d9531e739b33f18e647f18859e2e1cba388f71b7a5357dd2b0c2786939529cb8e60408b6f51ae27c6b9e3be026a5b0cb1703673355fa5c294977b9ea4a7fca154f69297e562359652db59b9ce0607894f42464eac04dd43859eb3e254c48877be2f54e0032115254843a930a23466510607735e63f9c12665af71e879e4f9940f15ff4895b9f80ff7f8b07f3c65164871a04878e5e890a8f5b9b443ad386df6395226946cef8da81a66861e0e20d2ce2e3dad04b226c24e43377703476b587cffefc04d4c63df40d4c74155ecd1c5b5a5b8953eba0cfc0559352c916bef8945c67726c9bd10327a13bb7bc7017b4e69f20a624d69cf08a3f8197fc3e753eb650a84be51a3ed28f01621ebdc8771fd9cdd14a4b6d27429b3b85d3eeabdacb6c502811bb977ba7d7904bfa81716d3a60c8d293ec1c63ec69478939fc97abb682fffd93b3e73f72cebd0c7d44ffb6f62bde032288f85e4891a47f1ec9ea006cd1c9b0669344fd99d51e9c40647d99db1cc7ae9c44f2ad65601ffa7ca2e42d2b588ef65fb25b18741a7fbcc04f9f5880425afa2a4cffcb863da52b736ea55788a2262a1aa00b84cfa06854dcfcf52f142a9526f838bb9ba1d85440c42c710fea7e04fc77d881e46b1df57759f12b93d87cceabb9915c47e12d72935407d4d30c05600b1788aa1f7ca0ef785edb8979a3ee2d1921560c982558e80daff207ff7fecafabe360244d2c109108f8b945ff5d7cc3376a9bf2667e3343e383de3d5325336617867e2a4c177361d597955eb584fad788d0388a23b5cf4af62076ac07b7132bb6ee5a26e2cd0a08178fc8068faaf350af15840d8bc2b2aa69ff7086f3414c10eacfd2db28543e142999d7de79f4d641b5fe1d0e9556eb4e4438733a36a1b4760c203a613fa45409ad4fda82549d760468d3ce894952f3609c0a7e9e860b25a0e09b8055a528ff36abb3732c2571d67236e3720ead4e620e6f57f0e82487ac27c74166066443b428d1a85a6b28524a1c16fef6be2f13708326251799457217da6ad4bf782dc9d9b53b7772368eb7e48ff5f9644b142147c3d21e4eb1adf9c5a8745ccb84e582bffc314c73d7812835162b2e002e142a27484511b0e422a1d2b011a394789daa69d2d5b7227367c3567420f971bf1e955795926f579a44c28890bbb969f2e6742b71152c1c3010ba4e92353c06f470fce924f8ce2ee85c072b85c0705fe5868211701983293e04d3ba1e75dbf7d36bae4c5bc86a51e7baef090b7ee0e5f9fd6f1c4d01782b40e8e6cf893f41cd00802ead6ac99ffb03324feaf91de56cbc0f454b14002c92da7163a8f181dac4d93cb22a5067700b2b6ccebb57eb9c184c6e0776edd1a2656855c9e2d96797511112a5d854340311f7d6689f5b01ea857bf429f89a1243de18153090c8b76da7c59a2591bc7623ef3e16ec3d5b2cf59e9564122b33345b8df79fc0722234d6576e5985978cedbd0ba8107e6e9c51a87f3876a1b09eb49915a13d388ce06a4efe30a4cc0a948963101edd152d4598336af819a58da5b79373a65968fcf857d7fc6e2135282093cc3a5212fee0e3da89cbbc3d6414955a40d6e05fb72f951f75489e9cad5d0698523da43b57f3499ee14f0909159fc8ed7c0738019e5d6feeb345bf2b592cee8872af168195b5b2e73607a57c661a9fbf87649de62a57f1bf1db501960ddb04a0500e31e2ff9770d1c799519df65fa74b86663d0e7ea5ee62c4af6aacd5f88406304df1bd30b09aaa978c84d5dc600d7001bb29cd4ff81397bdb38dcd70afbbb1fef52ec4998f74c3ee9554061e2092c263ecfdb566e46586a2c0aa1dd0e5759bc7d911d7fc698ac5d6010dd43b7d983d7e9a407322f2682f0f84c3149b32ff4c3e517ed5f28bbb9b9f261917a2ce1045044383faf3fbcc8d269679e4ad9e1caf380d99c16621ad7b5be939fe384c4d720f9a825be0dcb5700cc6c7df9437ad343077c438184c5f976252375bd74909ad9a72c9d4026ffbf66976e87e1272dac0c4a1b9bc1c8ade5ad03180c7c9412dd7053798c507dafa9aec09fbd19f5c021d35c99edf586c4bdf02d469ca51af19b895f1128bb031d390c55f3a35e5a1c56deb633dff099db2691dc601ef22b982e3f1e4f754536427fb2a60d6e1425be3d9efc2b9dd3e366f6187aaa3c3e6ab260fa6b460845979bf23d298c28649b3cc8070426e105c6811276c1dc511b844e9a9a41d5035c11fa3767de90b6d41581af23f0accef9870039a3aa9a938aacb1d8ec03e0e2a9b8c87776a4087cba4be4d92525e636d80df66e825cbf07940fe09583071956d8ea9aa4ade66ebd5a23388bc447f75f7732fe479a4073033f3c9eb4012b191a8549375b3a4dda7c39cbf21fcd31ab25b24ab6663f20e0b74b0d60b5ee595b4523868809c88c90a83a9d8496c614c026d1ba4fed68ef17b1c56e1a6ca0ddb5fa09e66d155dbef870d14e51b27752d830a34f96370bb643db33ce6b7925378e84a7c5b71b7f2c2325adb8dd1b037f611081dedd21301178970a81bed2b634af417d960af3fa77ebdbb32e1fc76f7ad0b63dc4c3d52aa149c8d58bc51e94d4bb45255ecad15d6548f0ffe44f4cea66b222048e609eb463cb3c5fda1761d055bfd3fa12d1392e1a9c3835b39da595b266a298b4edc1027c37119bcaf238ee39781f402bdf6902d6124e217ebea57cf15ff85a6f81e8ce6c9e351ab0cdc732447acdad2996659a339713e3496f93fe1a2e74eed9b49b3dc008f745a2ebf7e674de2a3ff781d58303a869e6ab847e314e813d787ea1d76aa5c435647b39041303729578b634444452e33b3a21320810cc29c96ef975466b1da9dbe680df1f268d176ad0aa559865732d6007c80df701570a48b76af74bd9b556f1aa6fc10acdb512bf2270a97e260500be7ca9055749cc47aedbe3acfdcd069798f5cd9692bb80f782c1f6f71795c2c03cf1302a757b3e5e6404038d9a9026a3360dcae44a915ccb46c449e0b2acdc0526811001c3f919db816c7e15d76a26389f2ea251a7b698ae5b67b7eb643382b4e44333784e6103b0300f34243d96833c7783f3f151a10f9f229be91d83ca68840501cb71a212e02a48db81fdbf9cea9213007de42a0cb6957b19cc3d6d624e212a722a5131c8c2cf682dc2afa5496bf8f64632238f73d5a42c5b487d8af432934f3d0be3d41f279d6bd7c8c4ff040dae5ede89339c26f8c747b3d4881c49844d42164ac611ac95058b887b8b645952065a61f1c2d854caf56718124f9cc3d2cc478512349419f6ecef241957ded1fdf306f03d1e0a826970ce65effdeb14f168d38bed8973ba7280907c2f1d833aefc5bb3868f70c42f0687b1c4ddfd8e6eb390d40644e01c363cec9f754c0153d47e80fe0c66d4020105d6a33995dfda407b447337319eec472fbe129ae9b1006a1e1328edcee19217cb3d3e58ca9653ed08dad893230119f840d3e1c439045b09ece4c8f8ba49cf5137d0a54d3f5a42a487e6161188b0b20bea75025b90e1059204852ceb6b5d3374d88c255b72cb80152fdb5bdcb7f3c866ed2e5a1a2a8577a75574b4fc1ea440a8854994568c026cf6cf6005d3cae70093f8ce899283c8072f725daf53878b30f886e578299fb99a7f70e8a8083aad6d41d4dbc6a6ff3353d676c2fa8d18bdacd64d89d5523431bdedf8021e4152b7c2c12443360dde0de88afed2613b21e2cf94bdf418612ba88602f051b67a76a73489ba74f5d481e100ff265c9061b5e05feb031ed37de880e1834723b761325ec0b57246c1d90739452ca5049df768db897801a370ded26df8b9380ad9d91c2c1b81a743f4512d8326cce946a26bda7d673a42cf6e54233fd0f130070a788a4c42d0304a6842865f74de55db991e0d603c16863830bf022c47fccd10ef0810147ba8f496a10a04cb30267f84b2e2938aa953d933d894f8b04fafea0faa09d57c98b407a48bd6cbe681aa846fa4828b650c1e3da5595fa95d2664bba0392eb6fa85c15d7afa2c5d53dc35739a1c3a659cdd07e0eb333be52b1378fa2a60dc37c16a410a591562085a26d7b9f2333b81c02b83e6ec2e5c063a00cb242360ae48e533cb10d4c924b55ea162ae1d0b2999b43c68c37ec5859f02d143c68603f3d304f799c5cc68f2f853dcef211d109cfa2af87320b7d3927a6bee49d6e5542e245e6a08bee5989f7d2bcf57054227a291c0fcc556dd8cf0e645ed4a248b28951581a21b5154dcd3b77c84bb1d1fed3bc37e28627703b320581a8e37d4951494180461f9a731028aeddb63fdc86d8bdc17ceecb1e387883854599605eb15bf4704e7826b5eadfd938c9b4444d21627edb523fdff7501fa61b24b2c2eeb7d7903b98d885fb3c3c712d1f1ed7c56d1c14bacf3c6fc39580d5a295c702f81fbf8cd927cc467495922ffbbbc8ed4b80986c70cb2a83bb50cb9f32d94070840899be1ab40793b77de4da5595e043ea702d8a4d6ec0cb6bfefe49321662cbf6dcb112def2d123328dc0423586b7df22e62331db1c86549eccc7bb3d01ea4dddf0976d3fadcadcd4c0c5beeed2522ebe09cd0dd756a843381c923614198a8efe7d8d0abd292642ddbdf6f4d10fff16806f149858b17ef98007a69bed1076f065043ccbe62fc0f985f943edcf997f26de5e3fb291017a80141f0e780a60176386787deccd1e7dcf81c3b380a01fe213f1573a9d3d39d4ed915443e71690b2e1d1eb985c7a3e59a5bbd53be9bbe1a5bece26b00ff224fa2f2875871ee5758e15233db4556acfb907492dc0626849280c1c59af61d611c39ff9ddfae68a188f8f96f41fb53d1d3991966fa6c97228bcfd1e3c49c13738da617b5de44e71586db37f44dbb4d9d106dc3da99b3af00153175a69df0b8f9bb6a396935078224d8b6b593dbed07a2b146115cac497f8130bec75e2a6b5a5c8bbec20de94ae829095f2042e781f7aab190459fe231f1baa96f25fa458539a3e7b9f8b53615da0ef764aa8f4a20c8bf48cec5b306ca3f7c4420b4c636300a22156083cdad1aae36292f86359907d8f67bcb9ba357507aa4f29cdb47884c74f25ad5ee40d5b0cebd85956fb273ccbb17e5fef6a388af04c90e7cc41a9b7d963e92602b361de33708000e22f7e091b60ddc1ea7d545cc162cd5d9deea9c547f5b64e20c551f72fb9f1af2df22816d442a6c26a59560493b0395e55d76dab1b5b3411bcb9f6fa2bf6356c6ec4fab939537bf69895d057ad30d5460b9a29d67af815b7083db7f663d05e9b51270c8970a5be8e413349d03917bdeca2ba1099e5b5a2adfb488579dc3d754a61e397d85bac738a3a3ad3c83fe227d063323a73399874b76c36b22d6b3eebb5f612175d7f14088f8c07cc264f407cc98149f925abd32bff977a5d746018c0848316ce058ab6c1b49959207fc23326b9856a47efe115fd14f7d5b7b6ab8de44186646f7ce1df611486fcfc2da8fd383854440fc1350b437f3e6f0bc097511bcc4ddf213e02d8086e7404302500fbf5bf66c72bbcd2d192eeea4cef346eaa8be89f906360ef567cab01ffe5bf8d02e710d22b1b5d8ca1d9cd110bcbca45d3224b01db700c3445767dec6703848d1dad823fc7d742c41368db267c7b9e42642e4253333865b1ca7d05c135dd803655fd8ef570ae6b01fc5857748be360a34c26078281372da3592eec98756f8aab4f3f6b4d1eb71f7e4f57ea63736b4c289903b176dd364677937eda6cad233f83970feb7cde03f89846793731e259bf4ba6dd1077861920a866cf93225ca89b645a5a646f2a4e2d8e9a6a607c7099b3a703bb45a41b8f5232f60d5d006e8a4597b01e51facd5d8b96e7991d563a474a0e98abec5c58cabf5fb0c6f6c804bc9f752881aefaae6955c65f79c5b063f330c777b9abe870a4639a57be210c8d7897e96189ad95e260532937656de2886165d00e9d5520aa02b209ad591c2b914a73de80241d380d2b8c5af44068125f1ae6f7ceaddc358db524f7e473dbc519fb92d39f01b8c8b3c3792e631539fbebaeee47ba07b9e7e56ed5ea7b34461322a8aaa5318524e3ffe170f5aebdc72976931c09c53ac9e0db4d326a0347d92220e39b350c8d0101d3ee3bc9e25d7deb7e87bae17e3ee319babc4a8a86f44968b6a972421397158ee03e5be3c97efb20a30770f348360d34026c9b931b7bb6ffbd553cc08b6923e3d9d66a72fc308d6e27ce7a6d2cb42ce1a6b4fa461fd5454a59edca51e136319d811007769939390721aa233e116c52cc95bcfdc94961beadf9a190cce734fcf53a8f3734ec3919d52ba4307e82e2bbaf3c0098bd8cb621ca2895f2d586157d4847ac56a371a8bc0fe5c2920804dab08c1a6341a6f3dc49f0d033f994f313c2d081a811df175ff5d57ca6d35d6699d5c60c9a63a511598b1e3f810521bbcc699bd445f233ba51ffb209aed9a2dd7d5378211d4bfa709513a08c7626678639d3446a9bd3e4b12d79882cc93e15a334501da20ad8d512f663d07d4a3b8f568646c8bbb9a3b4a3d709588f2709e46a537eea3eeb358619cb46c8fc1b64576942237369907bdd3065e1fa4e65ed1706bcde31a7457549eda82c8f12c48edb32a24c636fe41fc78caf34a281533fa68ba8680ff68680b022a9070a4ff0c79b733d6cd404968603d49168cce54c10955ebfcde1910b9863c93d92dc24f4a62611154aa4990f9011b642fac314f310270fa22ecaf133a962fcafec788d0489fe665a1460dc593a17ea6ee53517968488755a75c0f72268971e070ecdad295944d4acab18ce9a155c8a0a0e7139c8a5e7bfa50660a7a10e2cdc7d448bcd53320f1d463ba8754ec36cc1227c4bfecd2fdc2e5716376d7e19bc2a4437ddaa61c9703f026be07063da053e6dbe180b5474ce6d0c86fabaf206501f152b60113b77706809f18d70b8a299bf9e881e88d0a3903416cdf07ce0bcff26d0e12a326228651da294105f65763d2b9ded1692347e04de598296ae05fce30e74d6e58fe7701918bb8b5655b467b9f8d9360dd91023688457d82bac3d71308c510e257276aa3446e1c450e6ef85e9a0f96d6fe4b4d1d8ec05ce861e0b9b2ff6ec9ee0190d9253e11c928da9fcba6cf18bca3ee93997fcddaa3d9ca960444497ec26957084c1c286e4fa3ea560e8e409b983ab18338eec6dcc742e7bb0b3552c007397f526109fcef088620b2a882604ce201afa53fd68fc10b74ae25993839097d4243c3a9ba8bc9ac15a45d6962981f155b331d5955527584189747e2e150d60c579172801ff79bc94260776850c590d8fcee5e404ccc63f63820dfe4489ec01877fcfbca01396d5d1084833229b8bef4667479ed61cf56664e49b0fc375dbf958839cfc0419cee05500271ad00b555e064bdedb048c0a477491952c4ca7c3a7e7aa3101c784013839013aee9c0f549316ba617c2bc19aff13c170b93961ded83dcb809562c98f68538b04c51f524627a1b6e260262e8b0060bd1bd296d18982b259a29d11eec12064d1937e709e3915f6139a5f5dc4fdd350e58e5608a7784bc3b8f951281d8c7964f527488ca4724eb6a9093364102cee237c2a1e985f8d5ad5e82496d58cb3077f6a17c61ba58b66d35df0de135cc41fc87a7d473b28ead7b2a7fc8c0b1894b563d129e09f093017387f685bcfe0a2b4c12a54dcbabe01b0e583b5d2dbfaa6e0573f370f67e697695f7898b23ef2e0e4bffdd06beb5c9e31bc589eadf7218109375585c391bbea63a0fb024eca93db090177371dd35d60c337ce64b57ac95db8743982ab9906a8082af68b6d2f752153c7211d26c02cb4551bdee45c59733194066cead59dbbb57f39d0f7d29ec19cfeccf64ad0e791f17367be4066d71da639b7e5974c329f1c1ac85ec94ce85549b27059e4403507be5d85c2f372179c5af7c6a5c8dbdd8c13f2bc9a592aaf85a524098f3210add3ec4ac15d799438405a1d40e3e5d4b81d3b7e637c6ab3952932523601cb5381dfc179cd20c3de846fd3130cf2c82008844c1551a416fe139fd2d9782d7ff5721fa08e68c9f3afe1ee4a9052192c83c3825be1f0ee90d1524aa4ad4a964529ba2b4c5474f8708a0e646e33976a62f425af9c587dbf5328a6d404f86aa0918c26b58951bdd5e59ed1483e297efddfd565f3b605ac4846c007a7782971c90b3f6f248ba57b6e28c103f4fbc34e574e565b3d60ee8cb13245d209f6c5c9ac46bfcf89c24972674b051dd30ccf957e838ce7faba8d61e08271e6417f6fa72f8677e429ef495e89c0f5912033bcfcc7e2f562f0f84d3102bbf64bad7d5269e7fbc91884ccdcbea8354031578d520e7bc39714f4a71701d275b1bdfe74f8da83587bc8dd9f60ded773869c79132b755ee654cff1985b5f80ec7f78ce5438a21f41b14dd2c5163026bc4fcf7272a1f4aa2d452f92cb33103d2f45b41848b00cc204144195f16747d7421dec3659b19c02c3d1c68a9389464cd54579307a96f751c7c91e9416d3f714df9c9934b83cd4f2382f723a7d618a73abe4a8bcac5a0dfd36d2883d5cb00bbd46643372c63b622e25583aab4dc50edb9e7f0d6ba00859a303f4c85d1296f7d8b76dbb330f788e808ef061e500313c3cf6fcdabd70c1f05a51d365f2003c0101737b878d33c8856f8cc7cde6f169c19637544a8b91f92eda8c7b7be602a18aec559bdc864c904d15a8c81dafb6f2a3643c0dc090830b0713229f396656b54880063f8578770005c98cb988a50429e399d796e1d0384a1d23e08b926b4fd5397dc6a324bb43a30d5621f7aa5bfb2e86e867440e4fa8f7fe750c1600609c72e168f6dc902b5abd6c62a1758000bc453bd77065687d424fdbbeb132badd16d0198f22b335c2c5930d8a95153baee10ed72ca6f6f588aee75b11aff810eb13b39a2049ccb5f0bd16cfd58a18bc695569d1a41d47eceaa42ff29e8ada7e7fdcf89ee67e9d0a219d06d0ef840812420cfb63880c39321d53e545ee873a61641a2f6d1e105afff74c8c6580b18b89a245c04988e517fe84137b780add993dbbc549ac9ddc9fca80ab8b616580fcf932881a34858bfb260377522b853b97835e0d615d9e7a4cc051e4f16726b757dd22b2e33912eb31ad7964562d0f56a70a4d457d13934de3238ca6674df1273280d1c5a21da4401f9fe4e57f2b43401d17af20879d5186523a977c7da2ae18f0226616d210a3304ffe1e669b8edb7956e8f49b05f298d310977663ff584af46e7a0517c15e275852a7bf84bf65da5a54b931b0bb17bb334b92e2a09953c17aa642cba51f4a5ec3527fcaf290d772c7e488560009ebe4ad9a2c82c82ca95f818a58f5b4976c75bb636334f2bece9feb8a3be42a3ec183914607e26310f5df6022b136bfa9256eb2fe185ae6344a3cfc85ddb9f0596ce0b0507afa91c3a6af6bc908611b219b3a87cf07ab30edc87d895d1518bda5b2f6d26dfb297713844a665be59e9bdee5902e077dcde1f9bf7572a14e5cbe87f44b20e5c31a979c47bf2d947dc8586b7af4d4fea10c0202b970d6fed3d5a4d07324fc07f46eae1942090b9e499ea79ff59414a81687e5f4441bef77bdee88d33a35f8a06873951bee9767b34f70fc61f0f7a4376c2526d024ab5dfd554567b1b251f79febccc4e41475e9240a661e373c4f998d01b0aedd96f3db638093be48d057356ac08a878fe9749a16e4642efa4c9a11cca4f87b109ef297b9a446217a827603ae0eb290a8b2cf9bfd48785d615afbb2c0c90402ca12d4dabad144a36ca4290ab1ba881b29f9475cf2176f44fbacc725c47e1bc2b765f025daa82a457d32bd14f2b4231bb1bf289de8b23cba6e2dd58ace7361beaa352a66c6e2ad979cf1b962c1670917ed6b1439e76c83a55c66de052e79e8e6b6d4e1ab9c69f82458162747784b04e2eb91777e6c390e66ed7bfe114024ddb2c9d8f4270f337ee9f7196a6f6ffcce6e9da803c4a00bc68db2876192ecb3ada21bc76886bb9bd9f0d6f1f8af1af122e25991b6dbcdd69cc607177a8c96780fa03baed5a9c924ecde4a6eb22b1729fcd5ee61a2a44ae68147e757d910af07fbdf0e0e3a888cf1fe14fc23a9490763bbe26491754c1d09fb315e2433ca4b87b37582e0067d7bb32fb1fb1adab9db459d274456514c1413c13e8e186f7020736933b6bd310ed170f6e6f0c3553c9ee032b4f2aa65462c2990fdef7df7004f2c68ebb9de4219879733e143b0b20a813a9c3c07dbd444a47ff7923e8163c4071ebfaf6adeb9bcd658ba9e2c1a2c8c229ffe31f81a2d7a8a1a99511baab54e0dcae3d39586f827535a39bbf6954a476246caca4873a434d944b9ce91c3693096076cf78c6c461471782388325a4346644b3914f198685cac61e3b5fb9b539d41f24bf256b20c3b6c08a56abe1269879e5f6db1f1cf0dbab48dd11f339166bd4183e2f48f700bbef9f8300dea76e176fdc78249a7d7b47b9967f341d14f9b032f5c2d3ee85be5de3a06ff43bc0e59cfbc5e5dc9e16e1134c5467ad475c4e75545d9d77ed56714264d7302683ba2c347be961c890c36c48b32ab3f7982e658b14857476ebb2b40853a0c63b018962913191007dcbea8d35a880d4848e76e3a48bf7ee43c2d203d0da0bd90f5617b98a1afac8e969eb9ceed2fb2338671f84d968e35ae42be48fbebda2eb2f0607dc994a3deecb5c2e4cca5efe1dec5df79127da691571c185777db1d80160dd7bfa5bdfd46936d1d398e59e9224ecb3cfd4ed04b2f89a495439b8cbbdb7162122b814809eba12e736d49cc276207a8ba30d6f0ec38e1f576314a2fec0d1fe92d8e4286e7d249bb7c18c139a3a1f4992cf2d56b466c55537bbca6fa5950e7443a89da325fe6ee0abcbb1b26aa118027ca42c2e759665a83036e3d9208e960d34f464b28d9dcb45237c4ba4d3b959c24cdebde748359f131157199c83fdbb0fca0ad328b9953e026aeb8457c25db09a73ca3255e91790a90cf322f94e72e0f41083bbfa36529fa1fffb93fe760c560eb5267fb0aa9dcb10ecc854373fdc3aebcc0f07c3f2ed07832da63f129950c597e502b215e45b8e018b5ff81e28efea575db20c41a55c555cedaf62cd5b241921742f3202e89d77caa6c5567ae1543e4e6f77e8d6d4212cb31f0bceadb205528dc402b5de8cbb58ccfc0c959e43804c1b8027290866b7cf6312545bf795ace0305a7f356f4588e8fcb89a80de333316bc2f953101bc05fd1d572ad53257952252d2242961c95cef6634a75213c10926646373d50f698fe2e4e95d98a805d110b1aef5cec64d7dcea50387431b509c47fa37dd0c256f32438fa72a76e8e2cd3dfbef7bbc914dde1b6d55977f57d80a4b99c4f9145910a1ca4a14fc6c46e709635780d6bb1ae2896902a1e7b02c3003f30ead65f7642ff49c157273425a56e12bdd6d19a59dab2736bea4fad98269941b5d844c3d2540f9344427aae67d63eb9e19f58a1cba4969728fb438af483e61e03dff5b861ec81db7fd74eacd4fe696838c5b8706f6635dfd7658edf5ee8c030997f6fad6f56e1af9bd7d581b341ff9652b9a15113942ebf7093beab0e9e4b24a0a3a6eb4f49ebfa0d39b458cd28b0067ded776ea4ff5f8d5f167290c322380fe6a32d5908ab585e6e407289194cb7ddb02b43a9b670ffea16dda080ac81eb8c33d54289cc8c3c2ba65cf70e62a94b4d8e860a20197ec04fece5bf9ed29653f263d62a3cae5dea746241bba4c07b66631548e5c9b558b5c0bf9b1ba41dd06f9c8d87f45c4bb006804c0c507b5e2308b12fe23e4a1fff47c88e81d7f1beb738ac4b313517c47782af42c4214533558236314cc0bfd5536e022292a90fc62680ee3237af5622ceaaac530d2e38cc107e046b64d80b6fae7d1305dc94e39d2e88821b2878c7e31e1a828e80c18ac08e888a779b74b68f64677c5bac4a85cd04e2e68a0db153dbfee88d843b5bd8ad2c25775e559a39736dd91578a7a5d627665cfba6002da79645bc96185e08e32a9e7b962f7918a0c0bbabe01aaecabf4e095fc3a16685f0652672c12c56ce38a5ca0293ca06314fea73a34b90c1f4413b023b235201b1b01e01abafe70c7c9be80b511a143e44d5aa36240b635c695aa8a799f1e8a5e876708a7fb8cc40302faea02edce3b751b887cc409b0bf45d6ab99855bcb980c8a9ce85512775641d578361c146453ce92c011fa547bd8fe57270826187940c9540f410b8cd48d6203ac4301eb7b4cd89b8427ad5012c2ee0cc48aa5a627ad0429cafb54174c2413415fb5e2604a5a57e2c2e52faa09519d4eb0d347df9cbdcda9739f0b7934ac1e006672f6f368a76562f958a56cfd705b45d11de6bdf38474a538db82651507177c4f265cab5bcfbd19fdf0b96c8e9cd18887a49bc5f2c7fc8027024a1fabee4a4508bf11b97063d5a71901ec421f67ded3d82a827d858260afc1897cfd496d0cc41cf1f7b50166c7e6e94464169ef7c4e52f747e189d63a2deea8ba23b4162476e85b2e6a949d30ec7a1535eba4e84abea2cca1c9a6c4cb0c4e84621b5a60168a982bfd151771411f8803021e0b6dd6905327b7d0a6dd515b6d99c3b6ec75291921316fd555f8c7827cdbe875f84e4a7d47057518bd6c77e70e393a20c53b12327007a4162360f5fe1014719d8830d4c0d3f33e65f43a209c35ed695a13a4e938744f360520765485bdbf4b12c84e339846169433a02186afe6f31946725ab8e4ee84b6be42dcbecb38058bb9b51846041ce55565f3590db56cf189c5550217536f29132a3fa71d37159e6f475c92019761fd92e743ca4e3a1ff21fca9a75b1d87359acffac8fcbc4a0976ccb5657dd57092da4b060fa3e419d585b3ceebd8eb052c7b36a93c06de7da4c446f985761ee8f6c0f7201e108011f9a36239bd6d3962ec10dbfc0f99e94a6ef177a02977e23664fab4810b20c9c00a7ecb287dc1095892796593d8b8eb4f5a008c12c5031464e378ba3d05404796183ae2610bd011031b97768a6cd7f3d7185a5f6b5a2f980f7e2f80eadc8ec8b570a26d4e8b690e1ccd937c541e5e8f64ad4ba7130424859e4b995b9b015b048f32a5371f85b06a1ac25897a3d92914fc6d82aa05aea0b04027322c465caf0db69ed5cdd3e99c36740a148d1c480abb06d19589c0d0758ea9b2fc1761aec59567dde7d149bb7a6d7634bbcec388468ac49e7b172c9f095f962afc57cb7a8afe62d735dab55b688c6fb2848c56b11410a6f21042ef3ed5ad7b5bba1453b1223d04c83fe227d2db7826ba6ada014522ed11f8940afb50e61ff4b5c5526a4d648cc762254bfda31ab7d7bcace429080f2f61752c0e4c465f92ca1b2defdcd859efa0c12f6c623dc0f032844d34331df27a1c07609e24bbf588b97f07ac994bc083d1d446b345453ecb125695038022d207c4649b69415971ec39dbed4ce0118da424b878555ea3560ee93d8ea2131e2b69ac27afb3ca8f3219fb4e7bc3661a66dcbe24778f2871a11a19c087eb8d5f6f29ba534e1e04c6a83dde7bd36b47ae25a8e8311b76f9880ab0bac895c77025833406519201fd8bda088f431a59ca7c59097fbadb568ce851047f9c0dc3e1be3e12b51c7654c3b2e1a81329f9b15bb5c4e8f30758a8aba68a29b2ef0cb25917edf08a365a25db236b19ee7a1d1d4142de4808d7d38ad7cd9bc4920cef64f415d27f063883a2fcc539c2a849b63de0365048aa65b2d80b08c1137a1fdb6c52fea0990c1198b25abba165e8eefc3fa84c7bf4a0fcffc607aa0b458e5436f03e0d01bf6e9d261df4cb0c5f5d92a675f0d9efebef52e815b956de1cf96f2b8f8bdf1061d6a51d43b1dc79312eab71025e06f4d01c3c40d1ac256fecdcee2b58d4cddffbde65526750eaf965b5f59f98a220048cc04dfda0a7f14cd8818c67cc1d4cf3006960fb86621d31baacb67545a6e14e5e0e8cb8a9c736d46e753c57f47e88c3916fa236c2da32db9e1f6ebb4d6e1935c43ab830fdd1b1ba8e9647368449f83c0aeb938254f2a24506bf4d401a53bacf27ec8ec79a8dc4869d473f8310623f405b8a1d431d63a6d08270df5434577767631f2003004e7d130e41e78152bae122354d3942b83a7872b5324a4c52b132fc132a6d0f490f021237be0bb77c1f7b2b0249fb2b26c8f8350cb18c0274db49c0bbc4a437e1c5098679fe76729fcecd19b122bf0e056624b6d020d6530fb96499b446a86fc3c30047b754de3e1d81d49b4f076edf5823a7a68641df9f4ca6cda3f27d00cd4a556f7f193fac712fe328d6742dc0f6e38c344d9a9ac64b538280ab96cc0b0b93f73b2f274102a07aa67be37b29f4900f1931025f507c42a6060fb65076fa0669ca6cab2b7a2a28b3a28f4e8e9eb54c64f8a8b45d2a3b7090fd307892472141cb1f1e1aed31f6a651b625987e16d4ae924c8664f3a4e546a12957de91004663fa4a7ef7b2d5337f57598bb7720afa9f0b0877a83f285f3939f0df851b2eccb41911c1939c1f7c5923140a915e66cbeb28f8f82a63be224326199d40355a14a45f5d2790476213a0554c4a844e11b2c1e5bb90270ee369615035329590bef245d61a6a67c6328102c519d8e18144263727a946f15e462f13767e7341cde2ddccab5511e3e6eacdf382155d6c55bb6fc494e2226d109d3adef84155b08bd05814130683a4c8bd0a2af054cedefd05b4c400208896f8d72bcdb9282c854fc7271ab426df9ec358e622e102c2631289a5f860ebfaf8d65c2dec05eef618329a1182acf810979e4a959ad2485c1de7f34d0357541935731a8ecc92572af364214b112097d7ac15ab42162e7ac79fb7373eee485c45840b9205038b80005584692d30593ceaccb0bc925b9eb3f772a149e5a4099dca2d1330cda8aac99cafb98a827079dac63bea827ef773608e936e39ee7711ec150e418e0bdb6b006e29ae518800bae92b11a586f4b619580ef32f674d9946fceb19ee78473b438f181e4d24c3393c8eb8b9f342382e998535f6a7e113a455406ad4c3d1b96eecc8da9b56ccde136a77b0722ef4ee352f4b3df5843737139a8f03d7baa95e9dc6a0cde4c11126ade61a6bd159c32565f013f7bc6b453bc6964f9852692c97f540629cf0ef4e8dc90e2d883ddd87629f7dc5360cd2ca1282fe234084a136072757394ee8ad68e74d09799d728999fd84c803c11aa9cf9a6f4c67594560b21ae81d9e84ac07d49fc3677ab4ffee6c98fee778ff0ed824cc98ecedf87d0b1248725ff5214dea933fd9565a98c804f481b5fc92118586891d6ff4d5e2aa0085b60148f8a394965816e25e32a7841efd3e9b256a6c10373f98466b65cb5e73bf675722b59d7ae32a9c54b4b69340330a3a6184c020b3b116d0d62239bdbf9b6f6639243ba5ae504d834818aa46da735ad3ff514e0a66be3f47bc1f46280635bac3f04a43b912e93cfdfe48bdd9863120a73003cc9f98af65c5f7916f4b004c585fc947689b3ef5fb685602bc774d141de5f37c6cd7a7bce2d06c5db360905d308f957cbfdbfc7d107c578e29c889a11e020c59b997682c14c862322f322bc584bc2a08e55aca9ee0faabe5ae6e6b1215e1803a0379a64f1910063680845a7b11f6e0e2ccd75ba856402160fc10757abece1d32d82f9b4b876de83a3f113c24b347140bebb61613f7272bf50048003e2050ef3232d578b4dbe27d899ba2016e7161a8c184909641d2685d0c99dbb8d848d1cc964f65e3f7b75f9b38563f70bf06b981d63c3c2813fc12f4dd16aa1af413b7cab2673a74972f23ff15a03c62363fda08052d00504673ac4d6346a7fdcdea33c37badfc3733b3f2ca1e9c7944f6c80baa601e4244aba25d69d7ce7006efba84d83a527d2d64622e008888fe99c64fc758d1b2996f26e6b870c7131032319de8eb517a36ca66ce5a0857d0b77601fec408a0916af082bdeb2ab3f7a35016e7ba231056b6789577ef2f8a870b05d2bc833213e93d18159793873d22d7846ea0946c96d00f13b38f1825d1139602c3cd48531bd7eaf02c5c0319edab39c64e973ff4cb86876c05cba17dd50371419d978a6d0f8b3db0582982957c51cf61578c92b062f817c63f4a6f321357052696c09b857932354977dcee56bb9065744a3103d5eb24145c3de7c01d41b8902bceef3424f30221dd9a623fdafd508f74f2f3d75ffc0624d98b6efb80496c335e1fd02cd711f3dc41bbef85431ef975a858cf688d619f12dec58fda7ed2f792e03b2e47af63f42e82388a81d60c150aac4b9dcb626582697fbd8ebda056bddb671c4c85c27bc0cd5d2d94427ff0ec7fef35a29d262319a2c676ff3751cd1532bcbec3caa80e8beac5913c174cd7af6e35444d59e4eb08c92ff2162f63e3a5713e3493fbfe1e2b2f602d02c7eef6135b15dc66cceaba72cc2bc75a9389c3f16f5e002cf1e7398d020b5ab21f3b7d8ef07b6227d04bbafc519d8eb935da6e71d521c79fc586c3808d52968df9aef084ae2852f05960d7d7dd5f1d564e55a5a706a14b44fd8553326af9e77b23e5201a592da2a15842673348be8e8f0a575efd848cbe68089121e520760e7b1b22a7780f747cc59752dbd0fafa1e10df26d163a5a35cf66fdb81bd947385b012cbf6bc8337440c0fb285a934c8d5ec696a0dff783d5d16c19871ae4b5157c97febfde07287ecd299ca6dd89dd0002068ae235b4ac13037f58233dc0ca0bf916dae554b25c69ead0fc3343aca2e7ee8a0e4dded1f2f0f0ba556fc05a9a89deec6e902e4722db1301c0f0a75e5f5d6d7b0de07e74a98d659ce54afc8e0e4b6a21c8fc6d07f47ed7101dfaf5aa7a729994dd6479127a139c055c2aacc4482c989c43dfe3a297426fca5ab8fd6dbbee4baf2e786c5da053eb6b669a4309ce46e33bdaf14c1e367202fecaeded93d275105e791e93206100b77851696c3d521ce07744882759fa8c5455668d2f720c2ec273139587d232408a47f1abadfc8841e60678f5d8d1f13ae7c671ae5a369e394c761a6977474384bbde9cb97f8120cfa3ca1ac7b201658f512084d2a44a0d480371085f1e53c5457c9e001202e2feb7f8432ef209d3e79611f6f4cb3897f510c6786e76cca48162bc6189ad9767d0847f2294a41d1a34ed973baa503c13a0a52ce5fbe96d397309fbd39f61d334f7d2023fdd250ab38042b096aab950cdd249663ce63da9865e71497ae7b653b3719aa66fd42a414ed9a22ad69f76ebb8eb880e3cf136ae7ab9674004212a4bbcbdeb0403d7761877263f0ec30e3c42d425328f6dc6db7f6aa297c0857a8b56dc08463c43ef5ff41f686df75c60eb1f94575ecfa82f57b83f9a25d44e4aeda04c0f55433de60593a31815c6621dbf5417e122085e89551131d98ad9a999a44dcb3cf4e8a2f044a3250a24b4978f1d270931484d37317dbe2b0b3a10dc264b23a39e5f3e5704ee18f608dafb58abce9c838d691cca9ac7c40b0319f1e840a1dbddbbe32e9c65122db20b99fccd7ea317ec9aa9549e368a4558f6419a51c0c74ba4c14888f334354034ef28e0f01f0fd48df5599baa5c3a2a06b32c03291f069b2375711151bfde2cdc8d8e1484e830fa5318e1e6d431913a1c394fe5e20bf501984286fdeb57dcf10395fd580641fbc2e0182a9ffe62bd478d317c99367860613cdde778a0167b09a264eb538c78421d08e531bcc549d9083ea5ebc35cfd7f1ee9704ba971e8042ead9c06266a8336ab0a294dc527c76d726cc9d8b414f450e775ad9ce478b328917b9a52aeae0f52117f3cfd7f06aa2c45c7420bfb807eb0864b2ce7caa570c7f903f42ec78a8559ab54fff436a507339bb66c2c27779e66c88470caafa413f568b21ad8f34c9215f08d2163f140d1ca5f90477444f65d6df84b2ec1eb7a5214950a652cc6c98ecbac2f77838a730355d3748c2e27a78616e176a7c18214baefabcc6713f42f38f4b76787e2b04683a86849e3f2bcff6b0e8572901ab0a700267a3279dd225dba4a6e8dbf5a976170c8c6f9c1be93884f14e73796ff41ed6e063e6993e726e130a0ec9529cb63d466e2a99a896c36708d34db809f31e0e3e2eb1756410147f4e6434b817a96f650f890591c5882cbe680dcb06496a33477a77998b3ea20d370e9911d4aa45893b8368d27c24da9ee07dd781f443e7bb292f6822ce8ad8baa65855c7398e0b98e8437d0f4c39082d7e3b6eaf38233136d96953cd35166a7442c787952fc68d2bf82e1a4d7a9fa65f2c7a95cf30c642561c72afe7db5763d60d44e1dee843cfb8d914f905a23cd86370340f6990ddc918f29e956b12f1a25679fd5c3d168eca54a4d6b50762b4d8894f5126ea8d9aa9a5c680457067f75c2becb6b1a6b36eeb3ea7414e6b576f7313014827951e7f780272679f2a7664988134a1e0a0c629913b91a7a91d2e2d8c529b01e47c131c01956a25ab7da7e1b1035853ad86fec492be38810ef809589817d65e30912992c275d5f4111b4408d8af7e511edc6834b6e54e61a868ca1521703cb166bb5e7b6f925e8ea1337a1890fef1ccffb2abd43b43871b09abea6144b56748e30a1e7a6da002d5cdb7381c30596aed5e1f78775078fe4ba390005132ea1ded88f1140c58df34f52a28026565e024010fbc266b9a9fe95950d91bfdb26a6dc53990c3667dab0a79f3f51856ad827b66283fb052b187d8a7ca1b88809ee91fa660131a1460e0569e8673a776dc62f9de861e7457a4bd14e3343eb3d261bf1e476a1fb5bd380bdf2ee454c5d99b8e254147447f3a7167e74a8f7e3a518088a229494d8b156e6d143635c07c04e4047e2b4ed3440f8eeecf57460b603d0e144840f0b61d1322cffa3242ee309c880c5d70c3fbfaf5637af561a32b6b7c35a26492da937dcca62127d0fa5a0852a9dac26f90df0d00cd3a5dc557f8b477b472332584e5b80a00f2ffbeed853cb240893d79e5865a859d82af89f6a3630f5ca3b66eef3380596caba90ed44271b8985d699db4e4239517b295c278531631925e65771f5a17bad8a9483a079a754cd15ec30b35ebf3d974f1fab4ba8603cad15901999e62e351671c8335053910155e3cc83664b0da3b60bbb94cfb104c7a25a42d7af9732765efb76cf1f072b9608784997d7ea2bdc87c3780955fa184a5b0c4a07f42cdc2ae7b39462f0ed1643ee82aa30788cca8eedd64f5b86fdbb73a28290c6d8cd201aec9b8baf94933bc42f05efbd3c82a54e08b14697b97ff62d457e412597329d4d3ccca84c8b0806ee063b276bb4a0f4f1003b4984fa7232f9f9abce96891e5f9902b74a525f4e773acd98faa495c96830bb6e752e153fb68cc638a7a010ac5f926c1eb96a6ecaf69613c0158de122b04a088f50366b3307933b8e6243d017df2c51b2d252f119867f74ec6f87dc31b552951ff7419c44cdf2bb129767e201699f1fd5ad6be02c9f0af21bb6815893ea40f5f0d480ce42f7197fdb872e91559f65fddf10c7d0255e2879d8ee5b9c5a5a003f2e8fad05a1ae18a5ea64a660f4bb58466ca4d537548811bfdc8de9b9a64e444bfc67aa3cc44cc00289e939145ba14c4f7eb5328674a0aab522250f86d63224d6ec1925ec608d489c62562a76fdacdd8222fdcb905cd6498fe28a0516b448a8e1c24bff13a9983fa352adc074bf181502db0522621cedb683b383d9e03581490da842f11fb4a04ae87de1e6d191381229411cc72b227fe0f92be72e868a1a7962caf0189406de21262ea914b20effb4c858ef4bc5270080b64d4301010eb4b368a5efff328b264dd7fe8011f27acf21462ddde53be6b7a9e6522c0fc37ebd99ae2c86895302738692b351c98fcd472fd43e2dca55a0bba591b189c915d78db1314f995bcbebd728ac90c26b7f154f6ca7131ccccaafee5de6372ed26c4cd8d7375f978689a632e4c4dfa08e25a84f5efec618085dad339cfed115f1bf3df371d4dce4ad86fab3ee1c2950eed1045fe8fe62f358a37a8a5a6bb21475235c146335940ed554f05c359c692e5def12ee2de466f329bb4687b43a68d5e161b16e2314977cbcd2c879786091fcaf15dcccd0127ce0bfc66a253d1d9c880e6f699ea66436443b76045e6d1d290ebf4bbe65ac0566726cf08e38bd054e42d275eb394245efce167263b5bba796569baf2e2ef43d7246e8478a900fe6af5c890ae1811402843fc2a1ec3bc0cee8f81aff02dfedb60f2648338e6e4f043cccc778584f56921256f5ecd9feaed3117ca1527b9f13ddcbff553ee0bd95e5bfa70b9467a57323e2290641b948545d80490950b87e3ffe953b5cce4afa3180129792c991acb1666c89872d38bc11f8ca3b50a9547611d5aee7a3889ba2dfcd9bf28f3e807b8ccf8fd16222654242b8b0daa7ec304dc2db7ba7af8ee27a44a5bdb94f0e35ab616441c2c3328e4328d280b543b15df8f94b8124ce34958e10b5193cef0fca6e5d70ddaa41c52354fe747410ac412daf659ce90858475f07f6a5d919fc8ec0e70c40e0634defeab488be2aff24ac1b8188f9af2d86b714a393e71f7d2ce2c69ab0271115a08ee0f618d868063ea30ea491374cbd8eddd75714c549644967d748a4c596ac314c614c897d6241f83f1852b55e506d21380c81221247430bd611c50a55aa627f98d72cf2107c585a19858fe2f2d3b63fbc4fe1ac4cfa27cfb9fcdb683fb7cf355308e59f363fe15353e009b56becbbb9138ec7bfa9866f756c2dafd643b9247c1ffb144abc6f1d6360119a1d5bedbac690dbc313398acc3899bf08e19091116762ed6d45524a285948279af168910f6669ac1b0bb3bd16d34bb9a2dc0cb15691e56f95dfe01a39fd7657fb7762e24781cd9d80c59bfb6626afad7e250d8e81b87f108b18df716a508d46bbdf1ed473706e7567cedb82bc384f3be16cdfe0891cae1590d3534fe2b40fdcf979ebf56573b878a18648fa1cdec85328aa6fd052fe7e9b0981bf9d49e308f0980b5ced77bcfa0ccfdb6fe3258bc53a622b3092baec532db9f021c82c0b441cf85a4f8d035debb202d8695fa14a845f3b90f4cf9806ac8d6211b87954f184ccd3745506969268665d15f39b99aa4053c64a86172e16c1b8b6755b6d66261eb51139f9d5bd52e5315ca8ca0cc6b1c83e1ddb8db324dd57f11aa093d23595ae2098dc2da38262899969deed675755a7287137cbc5c7a34ac8d09f7409d767df5ccc430b47a3f24721c353eba6fc101c828f66dfe510f1b3e96563cfa29892c6c7a36f40f66a4c51c1704c581d55308423c0df70e3fa719362d701c36402ed095e5f90682bd2a3d78347d7c33596fb0dee878154b75ed1777483816d906949342d263e3d64361478ef0f65929cab9685e4a569b8c95d9204aea601656c3cf7247011a248a0e54de07b6616f95ebfa50ccc5b7e6978a56b9dac9934f3898233bfd4cece852a8987fb28e7173fa9a6f5ef06da38bab53de75b98bb6939c93cdedc2d5044e9403cc39ff631d36b046ebbfdc77c944f79ed4ca5a8a4ddfb40d3aaf773e41a3e93cec2f87cf958062b4412f61bfe4a32034aa02942e3f264557b30d00f9c639a22d38e4827b15e28f17b352975bf766bf2e13dc25d8795729b8e8f3c8a2248e41ce7e674f132df50c78542e5943d50be108da912d563efbcfbde60c3a71924dfb68087df0c36cbb8068aeeac601af37857519f5afef10c6b6d95ab849ae23353d9c83de8b4c8dc7e60c0ce3c27a8ecc210be7d113fc92f8f54f3cefe944fb11242da00eea9e7a100f71340373bff7121ebeb80da70bc76ab67534a2935dd53903aa4194fc0fe2711d2f88f9c4f21f32572b0fce19a081afb63f602cc50a78abe1dc730b521826110966bda7e53d6c4d9eb22e7dfe7408d3c720456e8005dda6f80d8b34a2a4d9171f00b489c8d42a023861f1b14f5822d64f381306c87926f538161a0d48f624777d491c7fa60ab8ac5bacfbd6e792192dc7d08ee328e3b048c141a809c013b6b197d6e981797681d0b7fbddec06e172383c2e3b272bf9d3156d0251ba2dc91efcb6bacc587f27993aea03ede9d1fa5ae3d0aca0d5e4ab24054372b77fd638c25d740e2b42bde9cafa0af1da09cfac0c523a2fc86867304aa805a6f778a3fbb3de41c654e97a9a651b20615bd66d80b1d042dd45b34d1db86aa3cf7f7ea4d12a39e2d8ebb4bf8c2a14a72e5cd17cf47e0146326dd93597dfcfc630fbd08ae268f7ecb5baa2defd1451110b9d70ae45129fb95b885e3d8da9f046ddb81e2c8e3b614d0c7372e899ebc942e9af891cc74c069ee72c658d054cd2b44d38a504cd741ec4e00ed63510ce931338ac64c3ca322111c3074bcc79cca0d1c1c57fb02000fe64f4cdbbe0b7308ad0ec1e6b021a8f3abe88bab9a943c10f157350a7711475e3157b098b4944f8a8bb5d01d01dfe5cb8681fa41f531924242997e4c2af4d49771322585a9189a77587ecc09cbdd83ab964a8ae44019a47726d3273ab732c04d86d66bcba2151d1e1dd80a1466e4c67171bbe7c586cea416b73bad170ebfb1535873bd7b0233e4065dad2044f20f50a628c02906850615ead82881bc1e9b234ee980159da07c286aa8f856078a7b0d0f3c7fd42a6ef43686b141cdfce6544608c2dcc2a8b0021e90c8011edc83b770e6c734cb0458d92e0e6582dc135f77ff0aba4f809e38586d352267f57ebf9c30076481ee107f5e470a9b18f7fe85d824eb9b2149079d0294e846df1ff7c5f8ddaf79604ddb3f2562da234e47de6fbb53b34de14e1436282217936008f80d4cdab79bd1075dbd784778b2e1c46525663c80703db79c47d8c9cbed6e2eb7a1e9c60d2b342e449f89794069ccba68598d15b67d20cd96aa91d2fc1966addb7e9d35aef81479f632f6348aab24b59eb10f76f8b4e3afc452f494aba31cddfd2474e68d9c687ed8f588f07da55ad59b9afb9e29a4e54ebd1a1d438bf583ff9e72baa17f03286257ed5d7929ba07b5a228bbffe07fe72ccb550bce171315f97bfeda4adb20c8ea6b90a570dc9634efe375fcf9daa5eec39bdd4c7a640d46ebfdfc9023d54adb1e988e2e2dfed9f2cc18209c106ebc1bad434892ed1d6cd5e1bac5f07a3c6031944854879fbd40bbfbb470bfe686350334d170c4c3e5b9da8ada5357e6ade0fa034b2afbc4c4f9252aa8f0c921778850c5c25c1643e5f39f9356a3053d7af67c5561c8b807201d3aae14554cbe588b0b46518507ad7eb89ab904a1fbb9c4bb5e85431d6650918a0a41b31536b478876f8c19c2430deefea129b2e30ecff8f36d973138c871e9a7fa8451b1a6716f74cf9e1a5ebbf966dad956604796669d93bb491242f379bb12cedba38e037207e0074cefb19fecf2a9697c42770cca6fbab13b2e543c9bba9158a94c27ebbdca03157b896646eaa525d347506734b5f137f8c7111d371e393dd59f9c2f4a4f04ed2a9957a49687d6c30ca82c442947c6d457dfa88ea305f7bd9ac9745e27c5d6cabc1044a864b8c472f5494cb80638af89f2c55441bcfe9d096cbb2790f3281c2d8c9efb49ec47dffef9440ff359a4e72c1372df8fae9023f51496ed6e639472e4899aa3c5821c709f810acc74ee61bcaf550668ca1106b687d2641fdf4402d4a3fd9848440b57d5047d9fb421cfba0fe1a4e1ad02cf0562a41c3bae96c6bfd44d47b0a8b254e40bbcd2567b5d15936142187da103d902bdcf7a103f9a325601074826cb599b82a2bedbff1be06aaec9e8f844e5c799fd5aeaff9c3769484a7945d14cc8b755405db023d19f538a2ddc1fffd893c08d00dbeaa185aa85c36762124e5616252b92249d708ff3d468081739d28b4b019441c9edf968ac2bf0224e530ebbbf0106b9d4c2d40d9b1f5110b4dab55dafc5c0aed30795814d1a2db01cf3c668b05539ee7bb395bb4d66c4d0c2900e107ad86aa87555660d25a8e7ddfe2d935bd1a010ddf1622a8cfc1b879e55b836ffdd0d0c13b958a72557834a074aee97fd68ac5dad6fa87951e0949e7c05eb57d210779af144ada861f26e4b68f4325a7cf8d8f8949c3f8ccb87673381d5c253e84663f5166da420bebd614412cd49991e7f012fe249e781d431fef39282bf9c710b9eacf848d6ff6a7addfaad2cf233f29b24594e28602369bd3574b6ced6b9545c0c27bf92d46aa185283bde32bf7af9d45e343dd0f013050e5ad5792b04a520e7013b9c6255ba63806e29fb1521d1b644febd4979dd6e9b1dcd45d3a2c75fa9824b0fc8c017b0ad77d0267880ff1742a0b2024e5bb5531810e16892cf2644840d96dd8a24f23e90efd8d3608b0a345c06e8977248148be8af69cd9642d9f73e54fa41772a0066a876d52f1727db5cfbd52f2e20388ebfcb6dbf95cbb5a443f53e9b1ebab058abca56dc279cfa2808679916abc7ae46ea85889a0f62a3c855884a8762826ce4bda1ad87382048fafd4c519c320ee9c7735c4d869b8f8a52805e77bd8907364971977e5a1ee4ce4c13231681688b19c9d0c7a5d10cb3dab0522f87040338926f18fadd4a8c2a7108b8dc2b63c6a55c9ee946dc5b6e6951d8c71cfe71ad602c58f44b1fa8ba425bdb4fc6b7855f375e0690e33665e5bf4493c3a77355974d838dc32963470ec355c38c9ad6245c8fb07853c1eff71a9e15a2d352965f1c996a6f61ce0fa22455541e6c3235d32db0087a9e09bef3baaa3ce87cccaf15cf06c96312ee9bf8edcbfd6e2ebf62b0850cbf1b10450006b4812fe09aa4262160ba1c0926d8ad6462409b823656d8ff570902f7015c36497c81ac7839581ac21043e4e540070d90122bbb2f6be12e0edb2f12428cda7cab6a1330c5ca3582482580cd6673cc36e19505ff0798a32e427ca657a13ee0323a4e542e00cb37684c2f4278eec8a144f0b0e93d721419fb89eceffe9deccc550a139b9e4a33d27516d21c522ba1aafa9fba00984347bff2b917046bc29ab900fd25ee3954174ac6d967ff662dc62c05b2dc49d0f50761bd9033d0da008e2c934bf4ab4ff9cae4e3e5215867c1175fdf28dc9d448e2ebe4a13bf281d585dc30e4d3cf899b7d297b1a386a33d04b20b01f284a75ddb03733ea45e4dfb81be28b70e0d5ade542158c23e8b3e87f30e3550db166137250ce6d1670717b153cb133689822968f5ef413ce8112b9b89cae3a14fd97b499ae039f5fcf86174ecde987bc15b22412d549c68c28ddb9621d78b959870fed228a21a903b834b753a547960a529f6ac9c197571588fe0851769c0c40eda718baf8cd973547535d9811ad7ecaaf9cafb1cfadeea84d6192441d12d8f971659172dec147f7dc366ca753fd5d9271fcbf53c24701a3a86c6614bc6bd7307886056379cfde32997497d11ec7c9a83f49c36ceffbb552ce90b316b3aa59720e244f23d838ceffe5b699661cbf26daa66e1d64c07925cc79e3b47594e174ff61626fa45f5659fceba1204b680a64e396711cb0321815f065cc2774a6a61bb242318f8d468dda091cc8a0551459e5cbe4b874e056b40462d4c11ac564567ee3a79c270318964087a9ae03c1a5d0a537c6e5cd23d3dfa9850b152703fb2562a32badb37f35137e5a09e2613092c6dd115a3ce2c3625f32e6d3ce6703cf05581b8dd88d2f5077e5b6791a3b33c84ab5ef1f9cf24151f9e79af89bbf38f653fdab2d02db13f13bab937770def52982cd317908917301940f56cdc93f9cbb5eb02d920ba50af367083347a1f4cd08d1aa3a31c1033e68a41dcca752c2971db762c1e6f486bc0766b7ef6e635e9faed54907f3eac25490ec990a5efa08404d5373c9788d8c5a302bc5c339cbd8a9d9326916cfc7d2ad168a4c27cf7af3c33481baf539b4270945adf0a037bf192c382a52d2b97ffc34ac548e695cc09e56eaa831c940285dcf73a912c0bb7c566df0062aa0097927a5978cd6b06a367f0240dfe0a246e98ae3b8ba47825b2c662a1a58164ffc40555531d9df64e123c8c33748fc1e2b286a3969c0d65b7486f21742fbbde0310402356897feacb017b20087495b986fc72e47ad940d86a3876827eaf6f08b2c97eb293d788205476572f6198db3adb96be611ff128ee24d359b8005258169d60e817f476f3d8b1cb1f5f98dd341f1541c79b3b06ec58f18724aae7cad9572fbe87c1e2ef1897e278daf7bb596ca54ad73edb662d9872b70e2ff4fac500357cbc46bd130826a9065251196187c1c77d65fd2d98e790aa603e1f3bfe681733959ab21f19f949c8558fc788e70977eb30673f0fbffb0b5d44583ec7fee51648e1fe85f7260b7b89c85b7ad182c7db4b617c4a44855b389a9edad48ec7d294b3278712d746d14baedf5fb355def248268075f87ef846c0f117639a9a8bf53644a25e1a31c543f87aab45a1fbb0f9cd92b77453f1452b70ffe9f26ea75d658f9aac9fc32c8b75356c1564d06fe17881cd32fffa5f7dce38a17ebe25da55528284d6dce9c4dca6306e36d42714945791b2998ba9cbe118eaad2229d7c29c51375d5fc4c2c5fd836c85814bad04a0d0dbd9a40fd34a535c4a77fcea979582399b14bc894e8dfbf57b0656772b65b94e076605ae40edf607ddff5bff770d160fd01ec03b0c6596f730c2a08a4151e355302823bf50ee0fd5f8f1888941e99e0b60b6847ef1ba06e07961f9c4e9ec40019f731de7dcd4a4bd8f462ff40526ffca796060fd2d20f5760dc4e4c9585a9369d354a6185614cdf7ec807c115919280292bcf3b7f24cd56e87f4f452b4d0ece344b25864c69bf20cf4ff5ab3797a32de5765690cdd8d4aec518fe38d05bdff4203aac335e720aca2d7f3c629cab1e388082cf36dc4eb533c9e293dadc781e84614f33f22f23506c3fe6eeccdef7ecc91502bd383bd049d0ac887565df7c279357f0ab7252c831ea8e6084952356e47d814afd08a4f0e003a2a89f1648c95ae7378ac404322717fb83c43eac0d47a8e579b5f2f841fccc5c30ec10ad2559d97a4d0dcb1f67b8a8aba90acfc3c20143057b7e39c18ab67b0264cdf2f0f17ce6fb0b9e89dc96abebdb44a7b4d2ffcff9d68062b300a7ebd82d4c638b286e93334cf265e07ae35639bc3a106d943d2854c4918cb0b46a96edadc9cf33a18f51d2053dae92dbecf31d5847a98e08e53709301999a4c2dd9c6361ad28a82f7c6bcaf068ae980661cc0409849057f193cf8bef11ba25715465d4c126f606a496b0578b85b84aa31c387a003e050e5771e338c90046ebee17c68e5682a0bf5b9beca58957ade582db0eb6bf1c63cd049211c1fbbe3b20c99e11cf3c386780b0cc1f78514be23b14796f139f98ebff086de041b51485a57755413aa64abbed862fe0887d37e3e0f0c0fe144bc1d7d23660a7a79d2302cfcef680cb5af4168ebfd7f5995defb9c150cfff9643546c67a444535d4ba1a7bd8b749c4931a7acdec744841972a5a5e69101e8da5b230a612f137903cbe139b8cf6f12c8995a87f60ace52fbf31d6c0eb776502a39cb74b5f59868e41eb26ecb9e41cdad132af6767a1f06e54bb1aeeee61f67e9dab9c951d93b311fb80280895f93c439b5435dc90ac65c14981eed27ea6041130d85e13b02cfca0f036279f85f870984a826c6d335ccc0762e2e2067b040b244f69015555c77d44edb46ca9d4e71ff87ab31c95e7766c041122416c2cb2986ac8d06a4c815a09bbf112be71cc01ec3da8e81aa60d3af3ffc8002fb16f03a46721d1a2c7d21ff5c87e975030eadaf024fb81fc4424c767550669cb61a7a27e566c5a1fc95b7a9f1749b362e89f1fec7eda28097ff6b17052fe6770acde6a7f71cfafb2e2ed3385a54d5ae5b61cd9af7595a5220a9bf6cc7c3d880993c587a5ad80346c8fcb2fdd9e537ad2532644d86ea019b428059c8147d458b43e015f3671f7ce25a7e584694b4d6b74c323f35a7854d276e474c01a2eeeda57e4e071d1f1ad44fe2950db2ddd4b9064434c96d748d0849d1e3339042a9c23c98c63c6ade55ce4ed353db95b3a65f4e525dd447d4fc8fe5b4b1abbb21396b0b08d367f493f604599ab712710b15385a11e313129d2953d4db29d4d4445cc2df3e475e4d85d85f6702cdc571ec6e2777568e9e71397f5b8dff96d483682b562c9bfe9adf10a8a0083e7c4b0985e307aecdd9714a4febc127c4a354248b5fea6a6d0dbade0a7fdbc78cc0be90aede22ced141ec372ba430a8bd7a0132b616f44e368800c89729f7e2b6be7ffd90ffbb474bc25495f2666d9f600b0cc5d87a1fc888a0d272a6ce2f51d961b0a5582786d69f8e5116de49cb18f8c7ab1ec575c9d4399a3ab16b5a93193cbab814302a2bfcfcc66eeffec4b5d8fad99645a32d8624c806678081b388f92c57c3efef00c64a874d9d8e50a228eb595b8ab26a5d9b8a25c82ac98b75445b183a40ea36f66a7f38e5b0e3181c3682a29cc90c35bd84404c977ab084a6539c5ace61cadb2d996c7673e138d98e84240de198f67b966ef8492ef077129e15a483869e7deb11ceb4ac944b9b51cacc2bd442c0e99350bdbfaac04cee88203dca065d323da5a4f35473b36ed3583b5c936ba30f24f63988b16d20ee6f7881530d917b9dc22673ebfe0b79afed8ade961674a4d4a32b131879edc85d77ec7b33997fb9208cbae8094440bdd552102a6e9f83a765346be86da4660cc4bdbb508d9d30774431fa0e978fea128d70ffe2ef041dbc9c8a3c97b9c605cc70eb8ba56374289953c7365b51f1b3ade8f11a21b61971345671b2f5e26aa77553d86a918d18450bdd55d905e7b7d0a4d887ee99750ac352f3050ef104d6b37d845c1f3e38ec7941355bad8c7edbc585b6418caa720c8a22d904dd21ed99c02ebdb0938763cfcda0f260476d303881c1bf756c7d055caa19f125e543a0f7e173dc5efb0c608695986ea0f9d887984ebd923932181d8b5f8f28896eb8d311d63562c29639597024794ab7082006907338b46a5613bc1fb26ff032bfb970ef73fef71836e5c98d6dc2e86b12d6a0257c460c47fb3b768292d3bc98d92e174e08d9e422de4effd64ebaf081d83d3f4e825567956a66f63cf34e873dd01e9b448ad19753305e9fe28097cc9ee15e3e37fa96f55d00467a887cd74e5e409b81b5d1072392784a20dc64732b3ea243f060cda8ca328435522cb31f91aec59984913907bd8982004eca2a8282b61f431789ce8b5e08337964acac23d624799c13ea57f6408a98e2c9250ac6864d3fe56d65d0cb0d9efba9abc7aa6d26d7cc39d1d3b53daaf84dc885bf868fb35c33e51e2ee93c9876afa7b446384a8fe7568c1519b1779d4ff77549f7fba1c885b8114cf8acd8a3602aa61f1aa1bca0805d5368bcf1d6dfaff11d3042e8c049f7144f8ae06815358fb2a724c9df85efe13515094b1db4da001ce02a01b3bffcc00bcb6205a9883a4213fd0b305af9977cc8e46cffb19e1ca123a67ca7e6ea6c383687cf5193c504ff3332b38e07acb21fcc83b6b33320d8a6862d3c3119c7696d75bac317e12ec6582e240ce7d943e4348a7b43a4145c64b06d8ad6e9fcae86ae6d2ea37a81e3184924dc9dab84ced00c3e6e210204dab944bff08a8253cf9a1d3eaac6a92e0476185930febdfa0fa03b615392558c13f6c30e1beb78bd5c4054e6aff9ea7f4fc1d64e1b5fbd3d2a810577898eb02bd1dee7483961cd9fa457180c4efd744279bc63ea2e00a558d924db28a83fb14ffe55d43feba8099ac78220138c081a23b19007e087b7ba9f3f3fe6c5c58254df5ee6b7786d4f974681a8e8b80240c2f283489bea2b6dcd8fe70aa677736d983c7c40fcdcc83a663f5e7596a68743b60fa256418fcba1c3e631c39bbd0bc3eee732b406318821e3a026d8edaa6ea2b9bd1c0cae6f76e379cfdf2a07020f827f2f85b98872300e3e851083558ec761f5765b24006def5af13aca05b35932563b94ba6960807be30032836eebb22b79b27f6139291df43fcec0209dd1c07423bece5e0109ae1ed2f5f1d055a9f22257e446fb4ce654f96026a1bb40e966077f019e66659b24b9e35dd55235996de35a835d123f48c8949e9fc125bdd0db1534dfc99b995e33607177d2bed3193a3458b70eb65dcc030a6fdebf04ebbb2f83c363037549e8f121ad540066353329871ad2e25dd00440375c44736e22585881dcf08ca942cdd5c01a02e64526fb10f2db19978a2ad1d16c84fe778cbff86c80e82fd423f6e11ddd0ffd177db6094f8ccd635431dd26399018649da7a5d38b537fd46771fd0a35bb38fa9dc0b8fd74d9947e2e4cc369104adda45156b74d7a91f22ef3718f9d6ed816fcdae443115156c86c368296545ee4adc764125f575227c28e29d20a50be897ab9f16932bec4f1786fa91879710cedf6f8bceb0ad9cecb2675cbd272ba4df20e54df40a4721b37a2e006466d2284a63929d666aa2f09828a972ff7ec6611bacc5ec6ab7c55d333bcdd168fdd39b4ce8cfb26d733b9b9a20bb2f9794272bf0e84342431e21a0aaf2ec22b0d1323014b1904c5ae1e714df3fb29e9d162bcc9a35b9eea16c0e8ff1cd571285cc09ae1d59d56e24de89c622a6380e923dfa83d9847cab7bf454b62d58273157678f729e1ea64fed594887ee17c94ce3a6e6fab639491a6916639517779db4ef13302487e652de46525530e5c35b666806bfc762d620f71c358295012f30595edce5ef14388b9cfec25cb04bcb188cc7e5261343c2487df891735959f9c218a7b888406d761ec5474225ba734c6b422a445d5f17c229bbda4e34e6893158a66718546acf211a1e1592b065c8c7e6b235e8d45917cf8d2cf37be8584d273f2ed6e4fecdd894f19f57157748ac699b82d261176938f15728331ef59ad23be5fef494fdaf9e2e3bb66783e0fe21e0aa5bac1e0b1f64e3d9e523e8121ea4973f3d93b58ca0a5c2b2356827e2e9797762964ceae0b0b0308d6166dc57c1950038630f01d94cfdc997b9e5f3754693cb8f0e7ab4e2e5e0f60b7c335cbdace325211e602b685c3d93232e7fa8f7984e460eacff93dbd20f507164489ed0dac0138ebec94204ca93110f3abd0306b8fad2fadaa291745a70b0f6273ee45f0a8c503d0825cb96b5a1de2f7d586c53579a29ca9fd191fbce8a05f5e6d753218fbf5f4bc03fec848dddf67a6c08780a2d700522c5b49bc921cce3527ae77d79c8f09bd9a4d89f3bf03e3f77ec34497c3e857b03046f4f653daee9f88bcb09cea48bf09b8feaec64e1473fa5a9b6dc290894c4703ce5bfdd55c5300a55838aba7720bf41319a033cc3f5a6efb4cfbbf93b32560b40b86a3faca7892eb684c74a81d358f78d4910db1e53265e75a66cfa45365745aeb04ddffa7ccde5e1fa629f455925e65a98e8bf0e865849a68c136b78b99b124ebb24560cdc2452b114b43d9647ed9c9de94cc6097708603a5babeb5b1427c3dbae09b4390cf7b8d3a68fb119199ee8f24024db3e53bb75296b7356f9d22e97ce1213f7ff4a9060929cad2f80e1e7df604f374fd01057a182158ea92178a45ebdfc1b9260f14c3eec5f209cd121adbbb368c09d17e95c4b3e4ae34bd7b418d1365ee32acfa4962337ba22a0737ab50181a1bb7e4984f9e104766eb93df79f42593cef890fe21e595ace77dbda8eb9988ea99904c59e1a6b6c9daedf250cc61ea7212fea5ccda2516bf6c9418cc1d66686f6b864296478e2782ec9b28fdacee82030159dcf58e4dbb28cac0d74ac7dd5c3511f37e14289c8dcfea594253e06afe8faec4a5f8465daa421799e5bed8158f9a3612214b7029baa78611697370d8ba34d01de58aada88cd7d179fc6ab39cb637aa83278c9422741529b04d7d59ee97be94e66e017c5646a879015bb3daf2f36fc6cb7893c18a16c264a8a58fa397f94d06c519f7cee3fc60ea948848630c7b3159d27bbed0f67ea47a6db78ae9729a67bb045f95b59e6db893d72936bed20d315263406ed50f4c2f13f8f6e75b502e5d09118b20782b94b32c38e54752a0462a5eaf3756a8146c985e47b23827b9d4377dff7da94402a1476463577672c9b2ee1cca7cb9eb55fb13c8dbcd1dc6685b8e1b04fc062bed3fd45ece174ea40fbd4dcf2dadd8a1b9721c493891ca2ecb50f1caf98d78938e2e30852ecd82d52d681f313251129539262233688364fc84e6d657ddf194a5d6224247005220144ed9fbb29bd4777f63133cf77957d2aceaa330b4521b66678f0160f902e90b9992b2696e0c0fd915d8ffb30cfae8cbcb89e814701ec4d4b6d464eee0b681c778903d8dfe8c5c88d8cee7879882483d6c9d3e26ecac8cc5a19472fad9e60ca91acf65a2de084659d28ebc3ae129d84ea19b7da27189ac890b1203c8bc1ae1f7aa4b83cb0ed0b99b3cf7728eeb0d78a4c0a9bc432fe732850067178ecf242fa218f7f4fe8618d41555f96101d6cfc2a51721155d151dd72c93ff9fdb1d95867cd3358b1d6f79373e911bf128aa135ae1651235ddae2459bd9f18935e84456a3d6c5fc27b2a6df538c0f69643640443dddebfc120601c724e5e4653079dcff4a66b42cd6704d606599bb8279ce2cd52e6ad1e8abee7c554233df265c27c128d90329e6f76b2775428bba273984721abb0f65989b79806be5a17d6794261b1aac278a7a8a0f0794f38e58a358d1ab346db1551b9b4886a95607e82bd940294aad60c872d7c32e8193d2d5a51b11cbf95a87416b53cd89e1dc376db85793965b38ccbd9b318c4343f35728f62ca58802a7e9b702b0b4ef5b44dbb9644bb1014aa4961300c4cbcb1fc9f56bb9a6c6db775fd4e5a21f4b9e4258b53c1cefd245436af4c8e0c77d1171a04f103f0e7722b93c76b8104fdf68687110d3bf3bf6b1bd77fc5ed4a0d7902524918a19b3c2723263ee5c98d95ef18ae3931376189172607419fbaa769b9734aa65d63e8b03bee45d3c3c8731aba7e2b24a3bdde7e5472714dfb54a8b9bc4d1d257c2a51e2b85b7aba3f49ed0bbfbddf2d6c29cfd605c43549a292a10983d97000446cef6b6f41c80c1dcb03a2dd7f19369faa09e881223d2a293ab2bb0842205bceb3397c54f9cdb13e00b6a8ae92465865c4ffcc87589e469a8b8df3d51a7414141c12f47adfef9ffd4eeacd586934fbf8cf33d54e75121b37b415c132d4eabad8d924e912d49445325131cbe499e0574e75ff3e9d4b79bb0b5ac6132b4791df38af96a57abf722d06575815a35dd9d92a38aaf348f26d1f7916efc02431eb4b1179037ff507eb2f94e2cbfbff132efb76eacf3f6245ebbc8ff5bd2609b26bdce2a3cc1e0e1a77c3152aca6116bdef7da83217c28d63002310f61936ebcd7d01cdafb71503ea243edc99657b6c8141253d0e380ac03095862b904deda1ea1c29b7b4dcd4dd6b231a9d4d5738892af94f604c52a2a2d13e73aa29818d0657fd92c7dae465fd175f8fa899a1467ca4cf16000f947c67342412f49f051565c24451d4df987cef6a2e147a8402d7058321d0c85030ffb486f2b88cc36ec834c1d2779195bfbb6b650e97b248368dc67d3f1bb85ba528a2bae1b206da7dd45d4a19bcdd614c47260f6f83f4d40946c3eb4ed53a4e53866f09c9750c1bdc52283b8507b5beddfdf7ef8fe3494b3d9d934dba99139d62f7c66c43b51f33a53b70d376befeb88bf38b946c31b583365dc5c331b09991fa75d124e405e5c3c10de137cabda37206085b0db9a84d8783425a943b8a3ac4c7605f337b0258e11138cbeeef5016a004b23f71ee2bd0162dbdc8ab54328aa6d2feb4e069251093678d9c6595a2bc0d025a5559670ede21d9999315a14e99fba5374a3707c8d257514d246ddd697c174ede27618c553b50bdbc5f842c99b95bc5b9f18714fa0a9eb48b92b828d6fc2e6a1a71aa10433e7e61586acfbaef53b1730969e24123644c3801925f6efb1159b88bc35b3e3a4a39324a6570285df5bdc93148a0c2a0b03a7f8ef25f24412bb0796d8a1b5352a043e3860a045bbe42921c12a5dcf1d079b532fc1917b8958ce31ce6b899ec270814a2c02acfc1e41418b48183f5063f13fcdcc1d7cb966890b1dc1f5b0585bfd35518b196356658998bd1c3580fdae0cec593dd4724c6ac2e72ae66fd94ff8a89663eb105428c1bf6fa05067e90b898fcb8720628ae0c668b8e80a586ff44e40fd9fd880723e31199c9d8e26aa3496db3f3e5c36159aa825d04c9dcb404f08e8df4a3a022ab45ed0d2fbe22f6b88229ff84c43393f9a00395e4636ce3e40913533324fe7acf0ac2efb95d35a802ac56f1f23a890fc68cb5c5d5c14a24e4d60209c52ab8c12ae6a44dc5281d60f774c240b5858e27dd0cfc81906683feccb27d0f0affc8b77a58f4a30841c728d4180397b97bb389bcbb71ff62b796556bfd81731b366b4221b02f5e09af09221793ab67e0e87230cab75e15ae1995161017e01e42356aeaa5997dafa3e8c1cd03e421317cb818a5cdbb47e369610f49126de0ef7d8410a33040447287a7cde61f654953d9ef325471c717349d8f360b4a96ee35fff09de010fe74a9b80fd824b72d733cb1783750c857a600e6e0c4d1947fdba8b07f6f59389d6d300d2635f55a874689b6bb2826c52f9c4af82b8afd52a88850a82f4348be279120b296453e5a7293d80b0b4357c0b0f8e61790b579e86e0efbb88c41a95b48fa75a7cb1cb84f3a4180cbdcfca1f5c2b9b59d73369f416dafcfe111b7b6ee3ae9863f536342941acb0481d5e383044e683277d2ce0a49e52a45da5ba7ddf94ccff3a396afe4c9f2fc30aea2204573418b3fa9dcb06c703d40428e2ba47d22ee19d04de0ced34f0be2ef47a5ab6d272d438dc6e4c1992d8d75779c38920ab4501fe68db2b8ebcfe91797346c7cbbef699001789edc4f79397311d6d345921b9ace22076e268bb435f723d3fe3d90f9d10517feacac2f50a186bbc259213b6ba30568334809a3acac440a72f751545b09ea3ca981fd6734da1d8a1c751f0cda49ae3edc9158192a275c97d86d2c7c8b5609e25e8a966fa97c4ecd5231f331424f0524a24df253e7ac0799bdb152b4e70abaf917b0fef3ba80b9fb06dd2700a0caac77781688dd5d9974eb4dd586372f7bd5786225c1d4732a5ede90bc6a2098286c622656d29b4bd0f8cda907ea790688a77ee0840d9c64062ee67a8c68bdeebbbf67c8cb83fb34029a6265bf1f2374b6169cc73fcd6625f6731c02d4e8f90ede99b64d62b7cbdf0089880bb5bbc866d886f1615c8897cc4c606f9b0711b0859ff7b7f956d23fd823035697ad84f92d4538aa8b84b30078fb4b346c7bf94785082bcce3af14b4eebc4bd2fa1456f1fba125b23764416ccacd8499cf25fe6f65e9fca17802525eb39caf349868aabc693aa261ea57918767b6b469d33175a41f3b0815f6898c09ffa6c4d9c97118aaf4e83a403e6b1544772b36f3bb61b5bfd10ff10af28d6c586e7757545b504da77b8f9bee61a749ae2993e71d7d41963e3c135959d218cecfdd15b97b0e554d8ec31f7bbd95b1d6152dc04fba4429d480489bb35854fede17f1ba5e1d17ac0577f333d075aeb9f922387e25ddef0f02107e485b6a0632877790a405049ed778d81837d05c97b88b1e842e8caa8f2df3e28c368b62cb6d158b65facc5a40fa0fa4a21d7b8ccdfe41434d74974ced6dc6a6c5bc1d795c286a9c60c2f70e8df1da8ce5adb54fe212026855f1e7f001b3fd519ebe321ec4db1ad034e548b78b40c95b9a58344ffbdf62b4601273917ce74aa9338c1fd2e39b4790d8422bb431ca25895ba1b8025334b559b9ebc7fc3fe1fce8bf524aeaedfc1c3b07d717b0ed5bdf522a176308b68f2d7cac25630ae2133679271dd3fee8493c20bfedeb631f08682eeadc1bba074209910af9e3272e13576e70642c97310b8445c66721879b5035c4e5c15397bad9c877a83b3474a3e5469a4530058ef8dcf240200f1b202b212b9a44ea9fdf5ae2d97ddf7cf56df326831e72c7268fbf959eb29afbf6fc0b9a7b319a07f20804f3494d0e32c5d285fa21c26bf02704dfbcf98e430799f96baac5a35a216f92ea0c5d8013f329adf3cd2fcac6c117bf0251e176ed52dfdbf17a7cba5ced2613d2492135d6c63bb78ceb12b6bc0282b4aade2cd0b1da32fb34a8e1125cb82d4a95da5985bf7f5928d3dcde0cad1b6f20a9e6ba2e681ae69c424d1c207bdeda63a0555b383b287dbcfe9cc15b99964184a79433e332c213eb1bde36c4bcd32d9e7655b35d3a7f0144789bf4a0a72f9305a0c5fb31f37aefaf33d20dc888bc9bf42b67b5c0b484ea525f8edba1a17573d8635e12cad1baba8bf41e79b12b96c781eb48474e1f1603b706153b1676faa98914f2d190b8a9cf2f3a823a5654efe6d371788697fb9a6134742ab125b813de2faab8d0bcd6157445d59c7a119930d5869011219547c125a8e467d96f1c2bc6c472d558871f78660b0adddeb0f1741715aefc7bb0084a81194317c7bafc9ec0298aed3271ca0857611239820538f252f7446d00e1c9e55d71b515bf6ed83278a5670ebd34d1e3beec9ab95a84aef1f7d75fb02a5d1621328911865b39d00f76fa4fe48704753dc73e42d4d588785823d7224b34f80061d7016053838d2c55c390e040f4a2b9a632671e96b59b1ec0f898426973c69cef72db6283df38d538fc8e87f18a34e2617a2c389e78970b1ff71e889bc90b8418c4170959b8f2d9b776290ae6086cfdc691350be8d6a211010a3b53e6bbc8545569c8fb46649bead65ee0ffa659d459b801ce0a661dc1e24f59c113200e742e8aeeca14b2b2dee072eadf521cfa8908274e91176c722798ab197ccf9ffb8f3752b61ce283fc0e33a10638c3a37daa63a7d7360cea4c9d2e53df4aa03b67d3175c1021278dc45981a0202b65772f1e8315abeb3676a8ed049d35c534979c907dd60e6c5bb811ea0e59ec6521640a25c949f123d427c0d55fff7c2e4cc27cdc99ececa4280ced273f6d4a8c31d0803d56ddf0919c415aede6a851873e2730baa05218dbec7dad071edaaf29a511cf9093fed3fc37aceebb26a9fc0e73c9b7384ce22f393a94fb46d927b1bde114d20dab55a405c140328d0fa9b195ead3f7005947895959d9b688432a934f1d539cc00cf92e854ae3d09e76339b96b477154c09bc0fa0c31d277c525103aee41843c2ea71c211576d60f0918df72e761a429ba1d58de5a88a239f9f895942961c9e51bcd0f8676168d6557e1fc8adead44dd3ea60b470698419b6e9ac0529e664f342bdd1ffe554980a6cbc6cd5a55e419b8fb14e70b11d5d1dc892820a135c7fc9f96c111105125610b6af9c0922339a4e9947b061730fd76e482050a84ed3065a8d0c510cc1eeb97079209363da5f28d27001c485443d771b1abef99837fc795e8d25cb652a32968fe6bb98040eec010ac1b911669ddba7a845b8b27f39da61311a0198daf29941c5b990931af57618d1644b975ef0ceaaef8b023e6e8144c87da830229da1d531f7c893cfa893b19799601905cd25325c957cb2bea17567fef6d504abeb3f0a66b9e01c577114e1934ad3880a3b33d5c4c7598218d90c41b3d22916df42bb51a142eb68db80b96108b56a81b2d56bb97c2bde4fe0e628275aff78bf7a9eee3675bd9a162d1fde1d263a59f1cfc3e096dd22ed9cdc602a40e150eba0fe79403b1cc0b7aa44267c17f27c23497a2da85505d95010168f0d07b81d4c1b7483075324f5c30ddb0125e53339defe99062a96a8baecf377fc82cc250666d741327467e93ed80b92d96431b4999d0a85eea12bb54636b5004ba034f0dfa64010b491d5dfdf84d4aca71438cba7e869abb6dd9bc4605968822df8b551002e04bee10cebae71017b583e364c3faefc9d5362e0a05e8f2841f3a8221b405eb497642ed4701bb5297a847d935273a98d2b67b179a90bd0dc1b4eff0006034773b06cc24f1cc2849b2c4b3b8045e51e7a1c4f88125937ebb3f302e652691a9f4bcab234e51ca274c952eaa0ccb1fcf5997de0c6e606e371af6df7e9840d75e9f4a4bb93b68f77e8fc8f4bfe2b38292c69df5860a53b28cf114e1723fa0cf78ee8c1f8b0100be6aa11ec1c561211517ed0d76ac6f7368b17ba0075997556502013e91ce0c818734f2c54792451848f61b77f5af9c16a1d802a11fafdb12f238c12a6809cdeb350e9cb1921228a6f43e55bf329cf04fe6fa7d8b4a798a8af7a83edc896c611cdf7e05e6d4206e5c46d58a6d5d5432c4d561a623e678e82419186bde2706bc2ca92f2f1ead188530860cccfcaa1e43b6478be62aa6ae0b124e753baca53485b03389fa70b732715d6bacebbfb74a8bb88b50cf6161dc739eda8b3721d5c7cbc44f49a65b1f06e1a5abcf4569546c77fad56455f44a34ac00366d9c3b8321a984ea5018d9e45cb5dd7de1125499a6266ff1008f01aec3a9d2217d64d40d18b7656a45ca1fd34204622c733ebcd0c11ee5dd8f9072251e9bcd974d4b89b56fa248440c379d872acad2483bd0a58f09e18d98162f30ac745d70c9e191c75eb2ba47609a0f6a15cf9355b183cb42af995653936ec81259e412e720e043dbcb6894abae9e43daa41d9275962ce9102fa5dd079b4ee69e9d299c017e5822925e23fb05711b82eac3bb63c44413aeaa6b008a64764f0ef6fee6aa0dc7abfe6a5aea92845b0e3144497b354551809875fa21ab7863847d5f77630e7f248f389f8987b00f08092a371cc634b599c45d97a08e3e1cc61034461f01193631fa4161d8e5d74b92223e6180715d333f2b4f1c8cc3432e3d08d49b46c9f7389abc0ead72fe75775441c25803ff67c581da5e21e9692db4b89a4749bac5f2e954e57562e2930b1ec9e8bb4d6e296da51beaa0ad6e41f23b7c39e56e2cfd14d0944e139ec9266215bbf5940ab0b83f33c21e8984d3fe9e68ce022fbfe95c43f3e185c2b21681dcff3a15c72714afe1f4c9cb754636e55d0652ab8e4832e2522df6eabafa00a45ab571c33bd01fe1eb8453ed353fec9d1679168debfab99a73f6c19fd8a7fd7ff55221833ae173cccec01cd53d387950b30934195c9d698ea27b97d29089bcbc49c5f9df467d449608eed1321d96b6c48a7a16d7dd9042ff9606c4c4a5c113882870fad43ce3ca4f17a8c82ad9c9bbeaf8d26b9fd1a5db14bca828701f9c686b22ea7eb827bb69884ecf31a17f70c5d971741d715c4a967aaebcad82ab5e10e95208f1bc9ce8f6da7e54bb00744381625c34404c983d8bc93946838f1304cf9fcefa4674341771a3b895375ee2d9c62d76035784af57cff076354e382bf363568a3b67da6b802916a40dcda6cd93821c77e50a955204ab2dc02d9a1dd6d937c501f0b79b8bb289512304bbe10c51264b4ce835e5cf29d6cf938165e6d739a68e852da9c3d45c5251ca51ae8b57bb34c304ff09174a7f34a2018800a77764696b6e2d1ded1701a758bcd56da28e9a8f875f86f23304d6eef230f5ed88993d6dac048904179644a71454a22efe4b9027ec46d095bc8e45312adda4cbe70044e8839e62cfff0a8dedccde334c707b0d6f74bbc7e3b472d8ea2f1c6b94e5e98f4c1e04ead830b9a41f77ff25308d440bea2ff80c0a498c92d76ff1768de4cecd3e08b2a8f37a1b745b503d9df6b5d1f5709dfe67646ad49e18a7ce1f3facc773be88465451ae0669d890146491d3892c14088cf7a62199980d6fe104331bc0f3f0ab40cb12c042361bd56d096684593223525205b5fd97885a75df019249e75353cc51eaeabc2338d584ce7e0b8f7c12306069ddc2a26f58e959eef89f291e73adbbbcf871af2be819a92fed5e6a72171737af6736c833bdd0160187aee1d6aac60a6387c1d39728202035436d7d5763d59bca9cb8771d0d927e32627a34bb2ae2664314424ce1038e86aab59696ed7bd3cfd20426f6de78abd17e7a02bce2ba73caf1e86e491e82ea4e0e2a8b570aba9e8e80d6c46288b20244b1e4ad92c94c34bdcd25fa40e9156486550209c8cecbe192f528ed420576c285dfc5b2a2c09708b023cdf54265e82e8d46fd3a294ec3f3be6e923c708bf64539cc95f10ef35e3c57d7e8b7c799fec7267866624dd4b6f33d9335bc49f43a4caab48b6868a7f916cfc46ddf1d01caf18448794cee211184012a4974dee7fe8c0140e137905afb6bc8b93bf65143f4b46e9b2a970d20b07e33465ee710aad937665e1fef9fe9bd1f353ef14be97fc252c6b21071accad8dde78adac50d0152ccaff1553c974c82694f6203040c9ee04d7caa5a488fbb400425894cd6b38f7db58f9abc12a64b33bb9c0975a8b8aee95d8e73e8ae7dfb13886420686ca3575f02eaff34d0c3fe55b7c23785163be33e97fce9857dd5c7312bae60bbdeb459f5d08ef60cc7c6f5e16692404c44ad53bf2a164f7baea6e04f0bee6fa8c881cfb3721d8346c72631dbf01b840d9ed62aa09f2b641fc189d8f3895054ec22615af3996d5a72be1dae6ed533825a75c06ee6bea68cb74f88104d1b822d3617b5431405554475e217258fa9c6956bb152fb3b74409e812ef05cda98d9495219dc353d09d164d2ca6a29287febe6a97e0881572024d4ad5d6243931dcb36bec064fa08d1147d01104b474f642d1f92e781810830573af55ec5889df5daa56606a133cc354add25c47577aefb139456a0553e3b738525d3a0d05a9ab59d6f3505262f3e03ea656b09ae6c7dbf4421da769ba073e48d487c24678bb925055174395c8a3f49ac1dc873d83d76c0b22c03559c8ca2ceadec83fb4649717ba8747f49780f4387827e2aaca8b861350a9d6d94532e3f9b6ed7397ade32dbdd09f39d05ffa30840a273bbace24f8898ca75d4c19d0200192deb4c34561a38e6e8d9f7b756324d61a916fabaecdde471e653fbbbfafdb05a2b2175019099297f9d88f4b975808d207c09043de3b440d2bf19c45821feda9d9454de16c8e8669603f90cb3b2bf43d566f5ba066f6d35fe5304b8031b9ccf40f3fbfaa9b69499a2621d43ae464bd81d1c4d9afbc6b0203e1e2d3f51fb8e2d2a8bacbf7d5e4ef428116900a3f72e52d3c2d24b6e77b278477085f9fec234095cd714fa32f92017e833a5c611aa0037290ee51cbf7b0c8b23c6745701d9ab47035607ba1fe0438f15aff7e9b26d415a7d091245acc9fdc208314b1cd89c0a8fb7d2ad17789e87f3e9c9da2c688ab45c567867ba22a2bc6a5f03c9d0d95aa3bb213c787be05ceeb8f9f70e7243de9faeb19a1273924a323dc229abafd38bbe076aa2b88a3e64b3a11edd17dad495e87db84584884cdfa52a363483a5fe0cd220a4601a8697b486a76b945f28ac0b5537b30e1f640448eb99f6dee446611b04097d2a0c6e5dd899971720a1f9b92ce37562f8ba5fc053373b74069f03be8350e284ddaf60131e5123d5b5d46f2318d94194f03449c968c0995066eda7c6173e42f7c48ee392fa7021739063156044fd816d959ebd876df392907d42ab874e472", + "kzg_commitment" : "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec0636688650b0a49443de4e2d69df618914", + "kzg_proof" : "0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a795653913a151466aea2c5bbf193edd4f03c8", + "signed_block_header" : { + "message" : { + "slot" : "4625361742829423275", + "proposer_index" : "4630319196774442955", + "parent_root" : "0xda533c406bf3482d8e6e992e756be34172a8c47fc1cc0018350bfe98c946deda", + "state_root" : "0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390", + "body_root" : "0x4d1a19402bb984ca4d0005336ba05e1098babeeb0781f5744712934ae78b2a1b" + }, + "signature" : "0xadd071eb32731713b9040770807acb7033344aafc6df54ebf8a790187ddc947e2bb06a9547eb7c3876533720f36e54761018488a3857bb1d87175f7905620088fd81593465b7139e794f75bba0daaef713a9b7bec99656073c1396866d35f9b0" + }, + "kzg_commitment_inclusion_proof" : [ "0x27d82440eb21c640637a36dcc38e35768bb4c0c79aefa300ec0f0cba32cabb05", "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb", "0x999e0140abe701de220ca2e0b9c3b044b1c6ba33e0a3985dfe16a16b510f0846", "0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5", "0x735c0d406b5043543786d38912b287aaa4c0bc0f731247e9a3141adb9c4d9930", "0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6", "0xe622ea3f2b167ff1f7173f8e08e70279cad2b67bb9c63b46b51baf8cba92e570", "0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0", "0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b" ] + }, { + "index" : "4", + "blob" : "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", + "kzg_commitment" : "0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd0ee000b841381cd96f346bde6ffd5414", + "kzg_proof" : "0xcf2c053f899b836f534bfa2a45bf23b7be4890b9815a72a2aec9f70eff53d592047edf91261d7e7ed3adba3b53e44794", + "signed_block_header" : { + "message" : { + "slot" : "4539432581202110249", + "proposer_index" : "4544390030852162633", + "parent_root" : "0xbb0b0b3fe94fa42a5e0893ff71360feab7459127ca9149e88148b44625f31d08", + "state_root" : "0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd", + "body_root" : "0x2ed2e73ea915e0c71d9afe03676b8ab8dd578b9311463e45934f49f843386a48" + }, + "signature" : "0x958ab38cce5390fd750e87806f32ed8993a175bc3ccdab7ce2a40c23ac6117b603d5ae98d44a9780cca1f32d28bf5176058ef667b17fd95f13e047cd9cdebbf19f5270ec5a154e2ce2283da513c9ad05c26f10b0a65755eab4b1ed6f42175027" + }, + "kzg_commitment_inclusion_proof" : [ "0x0890f33e697e213e331430adc059611ed0518d6fa4b4ecd0384dc2678e76fb32", "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8", "0x7a56d03e29445ddbf2a59bb1b68edcecf66387dbea68e12d4a545719acbb4773", "0x41f3e13e4961bf0c12dd652f3bf49e85e35a8a25c70e67ffc1d08cc01d9921d3", "0x5414dc3ee9ac9e510720cd5a0e7db352e95d89b77dd78fb9ef51d088f8f9d85d", "0x51977a3f0ab3110e2a10e9c6bd0e89b1410ca45142ac42171bb2b169efc281bc", "0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947", "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31" ] + }, { + "index" : "5", + "blob" : "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", + "kzg_commitment" : "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75cf364b74684ac97b2181146cb19a0a747", + "kzg_proof" : "0xe99f4b3f0a100c35d42723225a552d1a73249ce1f5f188e889bbcdabc2c93c12e90296206891f9577c8a9528fd869ac7", + "signed_block_header" : { + "message" : { + "slot" : "4559262388392254378", + "proposer_index" : "4564219838042306762", + "parent_root" : "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "state_root" : "0x3624343f893e8948a933c0cfa8787f4e8c309829ce142cd140c0dbcc2c4d1a3d", + "body_root" : "0x49452e3f298a688d9e7627fb7c01941b923397bb84dd548b6e411f9506aed1c7" + }, + "signature" : "0x9365d2047fca642d170e3d136ee04996d1252624a0b48001798084ef880eb9da787a612ad95c049b05589b14f107a3590a0cc299017da35a5219bc59c88fd015896e2a096f60e6a42da7b8437706064ea9faff9171b11dbb10c860beadc3521a" + }, + "kzg_commitment_inclusion_proof" : [ "0x23033a3fe9f2a903b4f058a4d4ef6a81852d9997184c0317133f980452ec62b2", "0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be", "0xf8eb5a3ea82ccf3c1be1ac153e3f77f273a07343291711b9de6b9dbebc4c9b49", "0xbf886c3ec849316e3b187793c3a4398b6097768d06bd968a54e8d2652d2a75a9", "0xd2a9663e689510b3305bdebe972d4e58669a751fbc85bf448269162e078b2c34", "0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9", "0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874", "0x0c0d553e4878ae811024144112c88bbf79a372d5dfdf39730cede08696ad52d4", "0x1f2e4f3ee8c38dc605677b6ce650a08c7fa6716795a8622d396e244f710e0a5f" ] + } ] +} \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/getAllBlocksAtSlot.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/getAllBlocksAtSlot.json index 813ad8d6bab..135cff0560e 100644 --- a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/getAllBlocksAtSlot.json +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/tekuv1/beacon/getAllBlocksAtSlot.json @@ -1 +1,201 @@ -{"version":"altair","data":[{"message":{"slot":"1","proposer_index":"4666673844721362956","parent_root":"0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef","state_root":"0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e","body":{"randao_reveal":"0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71","eth1_data":{"deposit_root":"0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f","deposit_count":"4658411424342975020","block_hash":"0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379"},"graffiti":"0x0000000000000000000000000000000000000000000000000000000000000000","proposer_slashings":[{"signed_header_1":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b","state_root":"0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb","body_root":"0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486"},"signature":"0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483"},"signed_header_2":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6","state_root":"0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26","body_root":"0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1"},"signature":"0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1"}}],"attester_slashings":[{"attestation_1":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4580744678799082634","index":"4579092195582398506","beacon_block_root":"0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c","source":{"epoch":"533461240","root":"0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565"},"target":{"epoch":"538462976","root":"0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650"}},"signature":"0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc"},"attestation_2":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4620404293179370891","index":"4618751809962686763","beacon_block_root":"0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b","source":{"epoch":"538078227","root":"0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb"},"target":{"epoch":"536923980","root":"0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5"}},"signature":"0xa32991816eb9f297553b4732309a4cdba7b33287264611715b0ab3319bca19e581da6e2659912a4e0e94aafc01c488e30ffc96ed14e2a726b9d3c618405ee0bf54bf6ae7f2097465cb27ab8132ec24eb93d3c9159475304082f7f0e452b93b65"}}],"attestations":[{"aggregation_bits":"0xfa79cdb89d0d51c5cdd001b7425c6d726750a9d5f89ade6ed9890ce3a706140c399a5e10c90a819094b65322dac7501f7c75471e69d4567358d8ca75f7c1b3133ebecf006b369a1f36efc5f2b706d5922ff98c58a1825a53a864376658f816600cf021cea843d4396502bb9c74d1510afe26036f89f783b4f5c7bacb6649c46f217a6af835f312d6fa253d2bbc83c07993f4f10de2ed2d952689379dbe4f794c1a1055a6b364d68e038deec9667f576b3b9eca5fcadd6298f181e1edb876efc3d0975ae14ae9a0ad2f1836d4c3f1080a96d8ab7c43b34bb2eda895ff66be698b363cfa4be33da3ec94a1a7a90672fd12c4a59916bb937e78476e4f08e4f4031001","data":{"slot":"4605531939934246443","index":"4610489389584298827","beacon_block_root":"0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b","source":{"epoch":"529421377","root":"0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2"},"target":{"epoch":"529806126","root":"0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd"}},"signature":"0x8f8d16b39e14569aab1b712e5c19ed51afe3600a6b017e8ab432f43a02ee720a733c33ef087d2f3653a9701e8d8a836301655b9195c0373b775c88ba1368e5d55354a70a3096bd26dee29dddbe7a4820e2b1653e84122beacbc01af7d93e6bdc"},{"aggregation_bits":"0x4ac567b296efbf7cf3209e87096a7a1a50fd523400113f917f6584a5a306f06b2d8da9ae858d47ff2594010089838efe41f19a78d9aae27c2ffde26f278b8681db9d091eb72e7cab3e449dfccd46a270693e1f88f197324e57bfd45573315cf9fb60d770937b32f7c0c6ce1581ec51e6b60f71acfde304dc917f2e0aa7872038b7d9140d15f7927c23a0490a74c2b0aca2773fed9217067e4444f9ca93874e4ff8407111c3efdb138b97c6d4957b6a70ec1debb283e3d0eb1cfef068adcffbf057d20fdc339eae03f0fa2613abdde8158a7fc40c3cfd1117eb6f8c4ae21d6b2ab4b57ae9a8653a34451aee6418c0c3609dc937293f5f5b346a7ab1a0d144185101","data":{"slot":"4544390030852162633","index":"4542737547635478505","beacon_block_root":"0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd","source":{"epoch":"527690007","root":"0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8"},"target":{"epoch":"528074756","root":"0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8"}},"signature":"0x90309dd491ae6ed51917dc305a3d4ae68d0a0d4792c7eb59c193bd03605bd94e61cab37502de0ad3e6162bc02427bba80a798b3670d5de82a854094016cc298b265371345c0e3ac49fd44bbb9ba0d4fcea0c1a80cecb60e93921d907e8c48120"},{"aggregation_bits":"0xe8c9759f0840f980ae956b15fc383d992e7d4420d12ba5bf32f669f446ac6fa388e20e5ce96e9266dd98840179d2cde3cabd9a8bafab5dec9c2e89f7f78c989e690548603984803b80c82d7b76443194576a1ce49da5cfe56f56e83b745fb01b5f18ccc86d88f5a22d927e64ff0b8e880893abcddec45b268531c4a0697537dae643a24b1a36432f37d42962553bd39af71f37e0429b81470c11316aa39db074aa3f1df4124e7cb203debed60b885ffb9b27e46a1434e81bbd56566632d0729c0822ac415cbb67f25973667d88e58df9c2f058a0ae7f118c98cc448453b6fbe590363bd17ed62c2f808df61f2a9e593235eeb56db74b9dd15980189a5271468301","data":{"slot":"4529517677607038185","index":"4574134745932346122","beacon_block_root":"0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947","source":{"epoch":"532884117","root":"0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31"},"target":{"epoch":"531729870","root":"0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672"}},"signature":"0x8c40f51a99fce6ebb9a4db5e80d715fff319e7ae523e46afb5d03c000d427e23c7a39e77e2af53851706283c8ca91d680997cb459386fbdff52c4d0ecf498e173717a838a792b210bdffaf476538628584a133899bf30dd5ce7056463b8cd683"}],"deposits":[{"proof":["0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c"],"data":{"pubkey":"0xb1f8f6e731dbf6b4e3265fb857c7190adbfc7e6cc95ce2e8bda72be8b6ea3459f862310a2484c3b0ee33b30920f18c1d","withdrawal_credentials":"0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c","amount":"32000000000","signature":"0xb594382214f5bdd375de66c45e1c61a526c7b73fb166c72433bbd9c2a7ad6881244e61cc6427e0206a50b762a129d8830e8708c55761d61ce9e3b19c1bee13bc55daa13bdb07118efdbf57a588b8a64e6392d14f935e53b68933e3355b35acdb"}}],"voluntary_exits":[{"message":{"epoch":"4562567354825622634","validator_index":"4564219838042306762"},"signature":"0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e"}]}},"signature":"0x8077d47ad0fe431af45ca6ed24efda0fa9c84364ee8af5f9e83f53b3e5934961197cb31b062dcc3d5dc793ec6de565960924b65d0535f3833ecc51567572959e2849e470be8b6a1f21e2c735552595e9765e66a599d645d33fa3746d409fa122","root":"0x28d7cd9c71934d91c6e7836a62759c39a672c439de48f06ab0a985334e77b837"}]} \ No newline at end of file +{ + "version": "altair", + "data": [ + { + "message": { + "slot": "1", + "proposer_index": "4666673844721362956", + "parent_root": "0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef", + "state_root": "0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e", + "body": { + "randao_reveal": "0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71", + "eth1_data": { + "deposit_root": "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f", + "deposit_count": "4658411424342975020", + "block_hash": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + }, + "graffiti": "0x0000000000000000000000000000000000000000000000000000000000000000", + "proposer_slashings": [ + { + "signed_header_1": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b", + "state_root": "0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb", + "body_root": "0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486" + }, + "signature": "0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483" + }, + "signed_header_2": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6", + "state_root": "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "body_root": "0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1" + }, + "signature": "0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1" + } + } + ], + "attester_slashings": [ + { + "attestation_1": { + "attesting_indices": [ + "4585702132744102314", + "4590659586689121994", + "4589007099177470570" + ], + "data": { + "slot": "1", + "index": "4580744678799082634", + "beacon_block_root": "0x17348c3f2ad0733f4b47b34442744b4a2e03a79b1f52c8e8922ee71060a05b1c", + "source": { + "epoch": "533653615", + "root": "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06" + }, + "target": { + "epoch": "538655350", + "root": "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0" + } + }, + "signature": "0xaffb36fe3e48b5c29794f85515b9a3adcd4206fec6dddac6926d0e985d96a9ade0e427f911d56dd90f2644af13e9740509147d149defa9b0763eecba616e0815e9a91c25178860be7d4196a9814781a4576ba7bc6398ef16b9bd5f88c4143bfb" + }, + "attestation_2": { + "attesting_indices": [ + "4585702132744102314", + "4590659586689121994", + "4589007099177470570" + ], + "data": { + "slot": "1", + "index": "4628666713557758827", + "beacon_block_root": "0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390", + "source": { + "epoch": "537693478", + "root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b" + }, + "target": { + "epoch": "538078227", + "root": "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb" + } + }, + "signature": "0xb7720f152c38d7172a82186892a68440bc4d285cc8aa92c1f017f93d5f61a29cf51670e4f944648bd8df82d4d6eae00615073d439389cdf35fbd7670a07ef8407c7c71a16be062fff16f351737ac99f006817ba43a295fe5286dfb4ba7116e07" + } + } + ], + "attestations": [ + { + "aggregation_bits": "0x88e3aeac2cb7509e753b73880be4e95da67b35193a1a8d916d3a5f3b61c59b6d90d866ae7ee81a10a9ea025ade39ad5b978bd20bd2d2031d61e8aa7b5090b08248dbcac0698c25ea7b858ae37e5347010aa764962e4f70513d9e2488a9808d0510dcb3dc9385cc9c28ba4a1eae314e5c3372b3d2387836dc0750553f84b1b490b7fffcb2824b614596050fa2ffed45b30b7db4e67cd782cf0446b5448ed43cb01991cde29c15b0a29dcafdbf29840045c4a3d7e58b93ff391e3ae281185e49aeeed12188548d0dc8e904edc1c8a9831577d08b0c708dbb1784cef981e8363efb46d26f039c2561792d1a2e81218eec593aefaa25bb280fbdd25f8103381a51c601", + "data": { + "slot": "1", + "index": "4615446843529318507", + "beacon_block_root": "0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6", + "source": { + "epoch": "536154483", + "root": "0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0" + }, + "target": { + "epoch": "536539231", + "root": "0x82a81c3f096d065c7e3f5d7df79bd182a53c9471a737cfb9f7c4e9ed95d0f767" + } + }, + "signature": "0xa9aef1e37252740dedc5fc9886810459f7484555aa59fb3876803fc4924149cb471ffbbd9be5324d952efafc3de4c5f705dd02134916b2afa02194fe90a8d1e8f58ebcfe0d33d0b8a97e71a3f7591cb82c37ba531c059a684b581d3857f05e3c" + }, + { + "aggregation_bits": "0x0aa2e4365aad4ec5115dbc42fc6bcda2a0739e4b8c6c07334b99338ec990c7dc93162171b1ed0afe8b1f151348438523b428076a646db8375993d417cd79f1854f796992a8aea702eb3180373e7ff4b4c53ef3b306a5af7f82ba3a4a362af88084e7d166dd0ed5026019cd4f2c4fad16566f927d0dceb14203e8abc293267466c487eb2b108ae043792ff8e8c56e9fbb26d98381ad35e70558cc74f74d1d5a7de764645e15298f90a9a4292e58188deba564756775d54bad38de697be7659cde395c60f403933083c4e71881c26d15c83a61359fbecd1c12d8f31c0d440c128c416e09ee2d3fe64b8a4c737c2f604756d08d8c1f77d4623404e031805797412b01", + "data": { + "slot": "1", + "index": "4549347484797182313", + "beacon_block_root": "0xcf2c053f899b836f534bfa2a45bf23b7be4890b9815a72a2aec9f70eff53d592", + "source": { + "epoch": "528459505", + "root": "0xa8ea103f4904c5e568c52bd49eadfa1cb142929514c9202e53c7707e4a92667d" + }, + "target": { + "epoch": "528844253", + "root": "0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd" + } + }, + "signature": "0x8f5c34de9e22ceaa7e8d165fc0553b32f02188539e89e2cc91e2eb9077645986550d872ee3403204ae5d554eae3cac12124e18d2324bccc814775316aaef352abc0450812b3ca9fde96ecafa911b3b8bfddca8db4027f08e29c22a9c370ad933" + }, + { + "aggregation_bits": "0xd664cfc4f928592f21ca9fae84cd2a15d4acf76e0d2cbb493324ae9cb25757559fc4b060414cbfd84de047d4f04da4aa6669e83b9b8418d348bfc46b3fef684ffbf0162da3c6258f690b14c94cf448280b646c140b24928defd2d12434dbbbd0afbea5e5661fcac8116699ec8a059acf084ab956ab0eaf508ab7d3e4bd352a80f6b8ff73b4b24753a865991c45c9d9f0e1675e7327ccaaeb146bc3d0a4db2d7e607930579fc38a41d5019f222166cea9ebebfe0dd7b875fa612ecb7bb80f83718702da59fd2687d445048ac99f25b5f088fe931ec4bbf9ecdfc169844c00bc69fe38c0110fc59105233b29f6ddecb7968065fd7ef787e41d3545fefe30314fa401", + "data": { + "slot": "1", + "index": "4536127614768741993", + "beacon_block_root": "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8", + "source": { + "epoch": "526920509", + "root": "0x41f3e13e4961bf0c12dd652f3bf49e85e35a8a25c70e67ffc1d08cc01d9921d3" + }, + "target": { + "epoch": "527305258", + "root": "0x51977a3f0ab3110e2a10e9c6bd0e89b1410ca45142ac42171bb2b169efc281bc" + } + }, + "signature": "0xa17225b5e5319618e77f5b93350430acfadd8ae12a279f1a4176cc7ad1de7ecfc8670988519713fbac8f702cca29bddb14ff1463dae3abb53ddb0c025cd69c8cfb0f5298ab241c06ddb840c7a260f3dbd37120826b13b17e22d086148ebdbab1" + } + ], + "deposits": [ + { + "proof": [ + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7" + ], + "data": { + "pubkey": "0x90b2ffa8992560bca2080afa9b3adc904ce9085a8c2cc897282f20378bdf3cdc0a74100f226ea698e07d4afe50d8ff54", + "withdrawal_credentials": "0x9d1b633f8ae18e21ff1b86740b32dbe55a18a0991bcfe5ffd2b6bf8a59465fe7", + "amount": "32000000000", + "signature": "0x978f1439422f6e539e93927a7754e7f9866fbe5832da066bb8fec5041a6818bbfe7e79747a963eec57f76924aeb591d0133ffae96de0793f02d13a13e1f7286a7940e48093ceb832b58e9d6bff9adfc1e8f59367d905633d743cd62ccbd2b27c" + } + } + ], + "voluntary_exits": [ + { + "message": { + "epoch": "4570829775204010570", + "validator_index": "4565872325553958186" + }, + "signature": "0x8c2c3b368bc00b3853e6df352e816dd910016db953ac77cc1565e3c22f1c0b24c59f24ea9e8ca406aa95b23368d163e80baa6de3f8f7ac19ee78c976d2ae5a21c86fa1762cc959bc734379055cb7aa1de36eae00541936b8c2ee908c770d41ff" + } + ] + } + }, + "signature": "0x8ab48d0165e8cc8bfc6804760141896946c3be751af5f16d1a03ead456ebceab88a8168e1da194df56c512edc15ca6350c413cb819d31a7ef69b329d8cb9fa8e5d93ae66289a445f1465d57d97e72d4c0866e48a806df7f58ebcd060e2d03a72", + "root": "0x127698f65207baf45ec6497931e82df707176d84588b76f6f1e4c4c577de3b94" + } + ] +} \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getAttestations.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getAttestations.json index 727e0d52693..1303431d694 100644 --- a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getAttestations.json +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getAttestations.json @@ -1 +1,38 @@ -{"data":[{"aggregation_bits":"0x4a9278690f62e1a353f1abf2b9701e13e8cdf4d9ac6b032ba43b05b25f713540ce24f3192819e752fb091217ff34b68e934a06d316b6060696f8f24749574c4b3ac2e4ccb6914c434b09a81fff523e12acbe299fcdad715593298d72ca70e1ffc743ad7ce89587fbb4b4c57db7856b7082db70ebddcbebe264f886236df2dd51539e10d4dcd5950e6cea7c993d3e999a5589a4c71669ffb1390987e43a8c4790a70275364f96cbee34b0b5a9d1b3da4322ad12e07c81c6e6430d2528f19bb1727c3f63f414885bd97505283b0bb6773712096d5feb67c43d67f2fbf17bf796ed5080aece6b968d532d985ad2553daf31ad4022aa49d7a92ada719c9f93ab4b6f01","data":{"slot":"4665021361504678828","index":"4669978815449698508","beacon_block_root":"0x103ac9406cdc59b89027eb1c9e97f607dd5fdccfa8fb2da4eaeea9d25032add9","source":{"epoch":"542502839","root":"0x8200a6402ca295554fb9562193cc71d60272d63beeaf2201fdf53e846e77f919"},"target":{"epoch":"542887588","root":"0x5cbeb140ec0ad7cb653388caecba483cf66bd817821ed18ca1f3b7f3b9b58a04"}},"signature":"0xae401f767ab1917f925fe299ad51a57d52f7cc80deb1cc20fa2b3aa983e4e4d23056d79f01f3c97e29c8905da17e70e30c2a3f6bdd83dbc4ddf530e02e8f4d7ba22260e12e5f5fe7875b48e79660615b275597e87b2d33e076664b3da1737852"},{"aggregation_bits":"0xd837d68714980f385c05b1c4e60e08695d100bd93ba04e50555a513c03bd99ce5c71e4a2a5a91419669bc583aab06a4e8f5d03f406f837e1a1d5bbec09cef1d8d9e33e9b65986cb7c3a274160d8245732ae9bf069db0adc8c4b9550069bfba37b8831ae257e4435f9910b4f4833226fa4830001eab94dc4fb0c094ac3876f98df571f6287b2093a52d404dc4bc3ae98f220a5127f647a3ba73545715870cc3e15051d024ea5de67f28429fd3139d978cc4aec10f360ef8e1f2207665a62887850b6ab8094cde4d7683e37ba631c8dc6e8ea826e6d12d1bf0962970755d49f8451035b8e305c6352b7de6753e459f404b760689dd4f53dd9ff6b0d221849b10aa01","data":{"slot":"4603879456717562315","index":"4602226973500878187","beacon_block_root":"0x6b0ac13f8a279ad3abec11bed1a49214f6e7af79b643595df6a38706b338e93b","source":{"epoch":"534615487","root":"0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26"},"target":{"epoch":"535000236","root":"0xb88ea93f0a5617e780f8ae6b1fc8e4480ff4abc18f66fc45ada895271cbcc666"}},"signature":"0xb8f4f7eb7f1ff3eb3923e6bf36b3a0865c80f47fb8e5dbe8830751f66bd8a06a3a1e06b7b2dec66556b532721018ce940c982953c8c6176125c7dd2ba1e8cb944e10e4a14905f7135a477810872518cbac085dfc69c1759d64dab5e225a5f16c"}]} \ No newline at end of file +{ + "data": [ + { + "aggregation_bits": "0x9827585d426605f0a23b9e5655df2c9b501c6282a5f6fae2fd7d5e0bdb68956e5b396afdfa9429f71e6e46ce94b24c59a4ca399550d1eccd9132ddc8c623328fd26ffad9a0d317fa12c74fe24eaaed6af7c42ab575d7d1d67fc4c3f1a42ebfba009b6ffc09671e81630d44851d5881782c1e25b9bb224b6f3e326221dfe891a480eb8fb6b93496a3836eb84d14bdd14706b06561622086cc5b5599be5c85252c2fb381141967c86c0aac570904117a3ae74d23572cdacff735639f1be45bcb7361cfbaf2970c5a0ec22004c4bfcfa8f75398984d07612c95523f1f39d17ed2b606cdd95e2ce4f41553918ac38030fbd280fc33c4c12a96052807f2e0cbbe1dcb01", + "data": { + "slot": "4669978815449698508", + "index": "4668326327938047084", + "beacon_block_root": "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f", + "source": { + "epoch": "542310465", + "root": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + }, + "target": { + "epoch": "542695214", + "root": "0x1f86d83f0bf91cc0d7e07410828140e0dddbb331dc20b6743f9f79e549b50b11" + } + }, + "signature": "0xb3a22ab9ec46aec35a9dacfb9036375ea1528041a926cb9d2d315ab964e82be5d6990e7fef2343f2dbb4c2b7dd74687f11144beaeb5758ebe349762b4dbde5e67bbc8d89a95a803c6610631d178249917cbf0d8b11bd8740f3cb767c843aa88c" + }, + { + "aggregation_bits": "0xb4a12e84d6e7598e246347c9df0778036a543cf20a90811be8c174b87cc98e0e0ba76fd9c7076eb7a9e484775545f6d5f2250b82098ec29be0e58139a4f463a2114f5321f6eec21a7b42baed386ceef459fbd893203af7ba9fcd9a66026acd536f0dc4e94bf34d909acd179b6aa21b824682d768d2d1d60682db4c0416dc9580432f4646a680f5f28857fabf55aa4c3fb5e97c2607fdf744013208f3db52ba768bd7ad4949a4a5ddd7d268ed35f6a3724f49761f9c4ff623695bec713896100742b7e0e96b3f174595d21b82a5acff69f98885460e338639bd25b48adfdcfb1d07b040bacf552a17e369197d0711717a54944a551f8c56a1335d6a443d61786f01", + "data": { + "slot": "4593964548827522954", + "index": "4592312065610838826", + "beacon_block_root": "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "source": { + "epoch": "535000236", + "root": "0xb88ea93f0a5617e780f8ae6b1fc8e4480ff4abc18f66fc45ada895271cbcc666" + }, + "target": { + "epoch": "533845989", + "root": "0x924cb53fcabe585d9672e01478b6bbae02eead9d22d5aad151a60e9768fa5751" + } + }, + "signature": "0x93bcd24f4a430255688b4a9a548da6f88a03bcf775104980edb7e818a3eb26f40ed8981681e4c92e4f02360fcc91bfdf062466e46c2a11058d2200e378fec149f13445aa520ea8e87bd94d3b260478c4ac0a92c27a3af35dae1e843e4112e05c" + } + ] +} \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getAttesterSlashings.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getAttesterSlashings.json index 5cd4ac55a4f..585d64ecd1d 100644 --- a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getAttesterSlashings.json +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getAttesterSlashings.json @@ -1 +1,92 @@ -{"data":[{"attestation_1":{"attesting_indices":["4666673844721362956","4665021361504678828","4669978815449698508"],"data":{"slot":"4668326327938047084","index":"4660063907559659148","beacon_block_root":"0x8200a6402ca295554fb9562193cc71d60272d63beeaf2201fdf53e846e77f919","source":{"epoch":"542887588","root":"0x5cbeb140ec0ad7cb653388caecba483cf66bd817821ed18ca1f3b7f3b9b58a04"},"target":{"epoch":"535577359","root":"0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b"}},"signature":"0x992e2695a49aaedcb373280f375a08adaafafff0bab131d48674136f5e452c8bb0797618eeb99bc3a4835bca2bd6aec6067807e927604548997a795d7ba982a5274f0d1d55624a8c7b66973c6e717f3c46bd2d92bc1696d3173751a6b0bf6a63"},"attestation_2":{"attesting_indices":["4666673844721362956","4665021361504678828","4669978815449698508"],"data":{"slot":"4602226973500878187","index":"4593964548827522954","beacon_block_root":"0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6","source":{"epoch":"535192610","root":"0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1"},"target":{"epoch":"534038364","root":"0xcbafa33faaa1f62b763b1697f350f91515f7aa53462f2500db29d9eff71c7ef1"}},"signature":"0x9776d892cbc6c914554d0153158c9a7c72164e9f60d3fe5816bdaf08a9bf3ca67d77a9c1d6431ba3294ec9032424322b0ab9e9a58fb0b9d8de93946ff414d2bef1f58da9f4a9b1e585c57571a6c8c8c2c0aa1c574939b7acd228d3f35d7b6e6e"}},{"attestation_1":{"attesting_indices":["4589007099177470570","4580744678799082634","4579092195582398506"],"data":{"slot":"4584049649527418186","index":"4582397162015766762","beacon_block_root":"0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565","source":{"epoch":"538462976","root":"0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650"},"target":{"epoch":"538847725","root":"0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390"}},"signature":"0x88a276eb43fd6674df0c66f4a2d988eb33b7d1dd992b71ccc4a6a8202cd12533828bc067f6b424fc554ed97bf16202bd0e4a9e9ba9bcde870fe7a51ae3351e2f63999138f8bc8ef315b0e168beda213ce3cbb7776026257c65b88fe28f00318f"},"attestation_2":{"attesting_indices":["4589007099177470570","4580744678799082634","4579092195582398506"],"data":{"slot":"4623709263907706443","index":"4622056780691022315","beacon_block_root":"0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb","source":{"epoch":"536923980","root":"0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5"},"target":{"epoch":"537308729","root":"0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6"}},"signature":"0xaa6e7c4619474f9b282e9f9bacf70496bee8b8fc79bb139ce047ffe273b1198bd34d35a9e42aab7ea1650b777218eaa706d3b1f017fff3be70a00851ad131c8877550e53ab01fd4850f5546664d1696c122a92ba49e68da2656ebcf43a82078b"}}]} \ No newline at end of file +{ + "data": [ + { + "attestation_1": { + "attesting_indices": [ + "4665021361504678828", + "4669978815449698508", + "4668326327938047084" + ], + "data": { + "slot": "4660063907559659148", + "index": "4658411424342975020", + "beacon_block_root": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379", + "source": { + "epoch": "542695214", + "root": "0x1f86d83f0bf91cc0d7e07410828140e0dddbb331dc20b6743f9f79e549b50b11" + }, + "target": { + "epoch": "535384985", + "root": "0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb" + } + }, + "signature": "0xae757bc04a0f7ee8e8d1668c8de3fd4ca45ca7e8f7ad7d3323350213956386cfc97094f156a7d6ab2d3ebe6a7eb7ce2c10d0d32091ee4867224ef5856bff529e9f0c2cb9c0085a28f6a47d75aae926913f681a6b21e25b093b78e3cf188bb6be" + }, + "attestation_2": { + "attesting_indices": [ + "4665021361504678828", + "4669978815449698508", + "4668326327938047084" + ], + "data": { + "slot": "4593964548827522954", + "index": "4592312065610838826", + "beacon_block_root": "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "source": { + "epoch": "535000236", + "root": "0xb88ea93f0a5617e780f8ae6b1fc8e4480ff4abc18f66fc45ada895271cbcc666" + }, + "target": { + "epoch": "533845989", + "root": "0x924cb53fcabe585d9672e01478b6bbae02eead9d22d5aad151a60e9768fa5751" + } + }, + "signature": "0x93bcd24f4a430255688b4a9a548da6f88a03bcf775104980edb7e818a3eb26f40ed8981681e4c92e4f02360fcc91bfdf062466e46c2a11058d2200e378fec149f13445aa520ea8e87bd94d3b260478c4ac0a92c27a3af35dae1e843e4112e05c" + } + }, + { + "attestation_1": { + "attesting_indices": [ + "4579092195582398506", + "4584049649527418186", + "4582397162015766762" + ], + "data": { + "slot": "4627014230341074699", + "index": "4625361742829423275", + "beacon_block_root": "0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650", + "source": { + "epoch": "538847725", + "root": "0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390" + }, + "target": { + "epoch": "537693478", + "root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b" + } + }, + "signature": "0x89253547c4da2415ab254923840e8988872bb213d72482da53998afaf78d3d4be75b3d45dafa853e297c274286792098167a69856d813f5b38d1eecbca1a63d67e6f38acd72149931b5b9bf53d45b94c3b2b81d7183c1f18836bf1dbbd7e019a" + }, + "attestation_2": { + "attesting_indices": [ + "4579092195582398506", + "4584049649527418186", + "4582397162015766762" + ], + "data": { + "slot": "4613794356017667083", + "index": "4612141872800982955", + "beacon_block_root": "0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5", + "source": { + "epoch": "537308729", + "root": "0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6" + }, + "target": { + "epoch": "536154483", + "root": "0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0" + } + }, + "signature": "0x987deb6cea81585136778dd3825ee4bc58bbbf1f007b9d2c819c4441de0c6c4f727aef2aa8e373231d451f3f2ee72a7e0e4e6d8e3f24c0c0371fe0bf37fed52eab8615b90cb16cfd74d7d47f9de296c35481ece0c3f2b23a25e9085515e6d0e4" + } + } + ] +} \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getBlindedBlock.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getBlindedBlock.json index 8abf8236476..05949560c1d 100644 --- a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getBlindedBlock.json +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getBlindedBlock.json @@ -1 +1,200 @@ -{"version":"altair","execution_optimistic":false,"finalized":false,"data":{"message":{"slot":"1","proposer_index":"4666673844721362956","parent_root":"0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef","state_root":"0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e","body":{"randao_reveal":"0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71","eth1_data":{"deposit_root":"0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f","deposit_count":"4658411424342975020","block_hash":"0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379"},"graffiti":"0x0000000000000000000000000000000000000000000000000000000000000000","proposer_slashings":[{"signed_header_1":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b","state_root":"0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb","body_root":"0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486"},"signature":"0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483"},"signed_header_2":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6","state_root":"0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26","body_root":"0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1"},"signature":"0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1"}}],"attester_slashings":[{"attestation_1":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4580744678799082634","index":"4579092195582398506","beacon_block_root":"0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c","source":{"epoch":"533461240","root":"0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565"},"target":{"epoch":"538462976","root":"0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650"}},"signature":"0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc"},"attestation_2":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4620404293179370891","index":"4618751809962686763","beacon_block_root":"0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b","source":{"epoch":"538078227","root":"0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb"},"target":{"epoch":"536923980","root":"0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5"}},"signature":"0xa32991816eb9f297553b4732309a4cdba7b33287264611715b0ab3319bca19e581da6e2659912a4e0e94aafc01c488e30ffc96ed14e2a726b9d3c618405ee0bf54bf6ae7f2097465cb27ab8132ec24eb93d3c9159475304082f7f0e452b93b65"}}],"attestations":[{"aggregation_bits":"0xfa79cdb89d0d51c5cdd001b7425c6d726750a9d5f89ade6ed9890ce3a706140c399a5e10c90a819094b65322dac7501f7c75471e69d4567358d8ca75f7c1b3133ebecf006b369a1f36efc5f2b706d5922ff98c58a1825a53a864376658f816600cf021cea843d4396502bb9c74d1510afe26036f89f783b4f5c7bacb6649c46f217a6af835f312d6fa253d2bbc83c07993f4f10de2ed2d952689379dbe4f794c1a1055a6b364d68e038deec9667f576b3b9eca5fcadd6298f181e1edb876efc3d0975ae14ae9a0ad2f1836d4c3f1080a96d8ab7c43b34bb2eda895ff66be698b363cfa4be33da3ec94a1a7a90672fd12c4a59916bb937e78476e4f08e4f4031001","data":{"slot":"4605531939934246443","index":"4610489389584298827","beacon_block_root":"0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b","source":{"epoch":"529421377","root":"0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2"},"target":{"epoch":"529806126","root":"0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd"}},"signature":"0x8f8d16b39e14569aab1b712e5c19ed51afe3600a6b017e8ab432f43a02ee720a733c33ef087d2f3653a9701e8d8a836301655b9195c0373b775c88ba1368e5d55354a70a3096bd26dee29dddbe7a4820e2b1653e84122beacbc01af7d93e6bdc"},{"aggregation_bits":"0x4ac567b296efbf7cf3209e87096a7a1a50fd523400113f917f6584a5a306f06b2d8da9ae858d47ff2594010089838efe41f19a78d9aae27c2ffde26f278b8681db9d091eb72e7cab3e449dfccd46a270693e1f88f197324e57bfd45573315cf9fb60d770937b32f7c0c6ce1581ec51e6b60f71acfde304dc917f2e0aa7872038b7d9140d15f7927c23a0490a74c2b0aca2773fed9217067e4444f9ca93874e4ff8407111c3efdb138b97c6d4957b6a70ec1debb283e3d0eb1cfef068adcffbf057d20fdc339eae03f0fa2613abdde8158a7fc40c3cfd1117eb6f8c4ae21d6b2ab4b57ae9a8653a34451aee6418c0c3609dc937293f5f5b346a7ab1a0d144185101","data":{"slot":"4544390030852162633","index":"4542737547635478505","beacon_block_root":"0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd","source":{"epoch":"527690007","root":"0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8"},"target":{"epoch":"528074756","root":"0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8"}},"signature":"0x90309dd491ae6ed51917dc305a3d4ae68d0a0d4792c7eb59c193bd03605bd94e61cab37502de0ad3e6162bc02427bba80a798b3670d5de82a854094016cc298b265371345c0e3ac49fd44bbb9ba0d4fcea0c1a80cecb60e93921d907e8c48120"},{"aggregation_bits":"0xe8c9759f0840f980ae956b15fc383d992e7d4420d12ba5bf32f669f446ac6fa388e20e5ce96e9266dd98840179d2cde3cabd9a8bafab5dec9c2e89f7f78c989e690548603984803b80c82d7b76443194576a1ce49da5cfe56f56e83b745fb01b5f18ccc86d88f5a22d927e64ff0b8e880893abcddec45b268531c4a0697537dae643a24b1a36432f37d42962553bd39af71f37e0429b81470c11316aa39db074aa3f1df4124e7cb203debed60b885ffb9b27e46a1434e81bbd56566632d0729c0822ac415cbb67f25973667d88e58df9c2f058a0ae7f118c98cc448453b6fbe590363bd17ed62c2f808df61f2a9e593235eeb56db74b9dd15980189a5271468301","data":{"slot":"4529517677607038185","index":"4574134745932346122","beacon_block_root":"0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947","source":{"epoch":"532884117","root":"0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31"},"target":{"epoch":"531729870","root":"0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672"}},"signature":"0x8c40f51a99fce6ebb9a4db5e80d715fff319e7ae523e46afb5d03c000d427e23c7a39e77e2af53851706283c8ca91d680997cb459386fbdff52c4d0ecf498e173717a838a792b210bdffaf476538628584a133899bf30dd5ce7056463b8cd683"}],"deposits":[{"proof":["0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c"],"data":{"pubkey":"0xb1f8f6e731dbf6b4e3265fb857c7190adbfc7e6cc95ce2e8bda72be8b6ea3459f862310a2484c3b0ee33b30920f18c1d","withdrawal_credentials":"0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c","amount":"32000000000","signature":"0xb594382214f5bdd375de66c45e1c61a526c7b73fb166c72433bbd9c2a7ad6881244e61cc6427e0206a50b762a129d8830e8708c55761d61ce9e3b19c1bee13bc55daa13bdb07118efdbf57a588b8a64e6392d14f935e53b68933e3355b35acdb"}}],"voluntary_exits":[{"message":{"epoch":"4562567354825622634","validator_index":"4564219838042306762"},"signature":"0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e"}]}},"signature":"0xaacffaf60c8253477ecad70de8589f2ef7670d0b0dc446d4baac3b465a901d3e64bb6d2c3d8bdb58aed45ac30466261416d152d5ae242204201bf6decfddde697ae0c5d44cf31ca3d43aa18f2799461fc1ee14dbf905b1e31f242fd31c083c5a"}} \ No newline at end of file +{ + "version": "altair", + "execution_optimistic": false, + "finalized": false, + "data": { + "message": { + "slot": "1", + "proposer_index": "4666673844721362956", + "parent_root": "0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef", + "state_root": "0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e", + "body": { + "randao_reveal": "0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71", + "eth1_data": { + "deposit_root": "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f", + "deposit_count": "4658411424342975020", + "block_hash": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + }, + "graffiti": "0x0000000000000000000000000000000000000000000000000000000000000000", + "proposer_slashings": [ + { + "signed_header_1": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b", + "state_root": "0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb", + "body_root": "0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486" + }, + "signature": "0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483" + }, + "signed_header_2": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6", + "state_root": "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "body_root": "0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1" + }, + "signature": "0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1" + } + } + ], + "attester_slashings": [ + { + "attestation_1": { + "attesting_indices": [ + "4590659586689121994", + "4589007099177470570", + "4580744678799082634" + ], + "data": { + "slot": "4579092195582398506", + "index": "4584049649527418186", + "beacon_block_root": "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06", + "source": { + "epoch": "538655350", + "root": "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0" + }, + "target": { + "epoch": "539040099", + "root": "0xda533c406bf3482d8e6e992e756be34172a8c47fc1cc0018350bfe98c946deda" + } + }, + "signature": "0x8bfc6e1a1c76bdafb4d491ce02a35effde6d7362eb32c03f119c47c12fb2b49e7656bbd4702ba02560fd7fe117f2c74e02142ce46176ebf269d5b34a48a65525e35db6cc446965e86e22e9d8adf5abe92315690b6de5f4591769487539fed52a" + }, + "attestation_2": { + "attesting_indices": [ + "4590659586689121994", + "4589007099177470570", + "4580744678799082634" + ], + "data": { + "slot": "4618751809962686763", + "index": "4623709263907706443", + "beacon_block_root": "0x27d82440eb21c640637a36dcc38e35768bb4c0c79aefa300ec0f0cba32cabb05", + "source": { + "epoch": "537116355", + "root": "0x999e0140abe701de220ca2e0b9c3b044b1c6ba33e0a3985dfe16a16b510f0846" + }, + "target": { + "epoch": "537501104", + "root": "0x735c0d406b5043543786d38912b287aaa4c0bc0f731247e9a3141adb9c4d9930" + } + }, + "signature": "0xb2213ef588828a7c18cdc781d0ed2516fd3e11de625f191aae7ae4be8b1ad2cc217728c65a500aedea276d345f09fd3212b009568a6549f5f40ead6d7ec4d0f3f329c00a1b4bca59068ee0555c94aec91bebc18365ca0b2d6692557b4b0c4267" + } + } + ], + "attestations": [ + { + "aggregation_bits": "0x907c35a14e5afee2fffc1703230dbe923ea49766c5af5277f432d84b3c2323d8a5a8dc131a8cbb3c69aad1172537e0826b0f4ee1639f650b91bbeab0eaf337f9472742d6f8443c1eb7c62f5f876f5f154689fb6548800c39b12a8d1f2585230fc372dfe5bc46a4c4358fb1ebb547796df094800159f2c9d982d61666d8a188e3b665900ce8f564188f269b5265d345893085d41f43a030337dedcafbef1245fb43c6c44b9891c2ff5f157069435c52c7fc457d5ec218f5d2ca50e69cae88c863b56e53213d92d7f6357a56344a4c2b80b58249b494d992f3c78d7440fe6b69d32ff3c1c29dbea8d0aebc1347743dac65bb66529f27dcf476baa3774d1e5c69dd01", + "data": { + "slot": "4608836906367614699", + "index": "4547695001580498185", + "beacon_block_root": "0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2", + "source": { + "epoch": "529806126", + "root": "0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd" + }, + "target": { + "epoch": "528651879", + "root": "0xe24dff3e29e762b4488e615619483884c44b8f4b37239b5cdc4a3bd7d9b48c1d" + } + }, + "signature": "0x913ce44a60f20df0261b53d8031d13f3a8d51cf53ba5eb65735ae960623c48acd56286b31ecd74cdaf51f66b2b2331fa0e907e8cb9d4dde513ca29cc34ee9925301bb541055a8daef33bb3e1fb8442a4a033f93f86933bc35fd2ce34a569a6ef" + }, + { + "aggregation_bits": "0xae44a59e9b57b7141da75dba9d385b795ba84317f41948621bf98a34f92168838b72a9678bc58de000cf466104613975fb1490c591f0ee9055cce4aaa2ff0eb5a26c8b9e20b6a386d9e9f7964a3ebb957e3c6b0124271c279496235101a29fbf18ac7be6749a8b1f230bb5131e97b28c06683ca9a6cb6129b2a25b4f539f7f5e41cc1997c5b4a57d51dbce5ad4ab746a403e5270c785b76d47475c0ee6c309e33dad08193c3f8e40e9414096276bfb5708c84359dd51eb54ca67dd7a6eb5645801fb83811b4c11eb5b240e9d0bc0847ae7abfa235c7d6cc5f7eca53bce62b1b987b7c11ef54592399882d7983eb3c6a58ff636f52b4007afbc0d66bfe9d9276a01", + "data": { + "slot": "4532822644040406441", + "index": "4537780097985426121", + "beacon_block_root": "0x0890f33e697e213e331430adc059611ed0518d6fa4b4ecd0384dc2678e76fb32", + "source": { + "epoch": "527112883", + "root": "0x7a56d03e29445ddbf2a59bb1b68edcecf66387dbea68e12d4a545719acbb4773" + }, + "target": { + "epoch": "527497632", + "root": "0x5414dc3ee9ac9e510720cd5a0e7db352e95d89b77dd78fb9ef51d088f8f9d85d" + } + }, + "signature": "0xa3f0d1902ab93bc710c2af70da7699b79480ee062fc8add2cc1c6ddce56d54706ef91f581ec0f94cee95fc4be146005f174e2e77733d71ef59e53a12eb852e09e4334af2c27120e506ebab9c04e2b2f99045d40bd1372618173cf6df4ad21f86" + }, + { + "aggregation_bits": "0xe2e8a45105213f0f211443b26e3a23df7f899eb9b3ddd40b5f51905f90441f98eaa0d2b9ed7dddf5b4089188c41388cb5702236640399f914245bc085459f40d628a99fd663a4429e9b46e61dc8beb6ae3757aaeffc6db49c374cc93d1e663989d84fa7b4aa499a8b5d34ec5fea94bcdb33af829c6260d2a88a6be97e89baa6215949a4ef124436f685d4ee683c0c27f0ac7aefd77f4b305842d1cf2d08d9b7f4e501a38b81014fcbcec2156d5abbd1010afe4a596164e4659c6dd794639199119b4a3f2ec4f3b4d6a084bdedf66dfdcc1be1c522d9bf72663b7cc1a8746c3737e20ef7ee1b7863f89ab600a35772b4eede0424b8b69bcd27a6b354252a0147701", + "data": { + "slot": "4575787224854062954", + "index": "4567524808770642314", + "beacon_block_root": "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "source": { + "epoch": "532114619", + "root": "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c" + }, + "target": { + "epoch": "530960372", + "root": "0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c" + } + }, + "signature": "0x8166b2ed13e982e6b9f05d30f42681b826099135a533d2614ef5f4f59811714245db0e1821a644859559f97ec1e614bf08b2edb294fa2edc1527f46596399534af23c98613e1b74c01871bf1dd2af9618bc0ba23ddfce8026b897cdbba8c1bce" + } + ], + "deposits": [ + { + "proof": [ + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587" + ], + "data": { + "pubkey": "0x83b9036200e9e907c86ede7f98b23297389e8af19d403466e00f1946867db735d8620019e28aa42739f49c65b78a2806", + "withdrawal_credentials": "0x49452e3f298a688d9e7627fb7c01941b923397bb84dd548b6e411f9506aed1c7", + "amount": "32000000000", + "signature": "0x86e6ad7c26352727d310e10f7c745a0725636f63013f70c5a442489946dcd1c85665cd3539fe9d8fe6f6b49b5b7f13a50af2a2b98a7d385417c98e5d74273e67cc3bd8f8544dc3697124c8176835745659182eab37f3ebe0a881ff4e7f62bc31" + } + } + ], + "voluntary_exits": [ + { + "message": { + "epoch": "4555957421958886121", + "validator_index": "4557609905175570249" + }, + "signature": "0xaacffaf60c8253477ecad70de8589f2ef7670d0b0dc446d4baac3b465a901d3e64bb6d2c3d8bdb58aed45ac30466261416d152d5ae242204201bf6decfddde697ae0c5d44cf31ca3d43aa18f2799461fc1ee14dbf905b1e31f242fd31c083c5a" + } + ] + } + }, + "signature": "0xb4619694384c8eb2975580bcf872825989dbe1a3cb79f1683c64ce3ab62431f6d80b10ae018bb0d4d4c9519e086a731413ef29fe7d0586ced2220a9cab11b70a8cd2dbaaa8e28e2ce6d913f4437e28752d4cbfe17a1fbd433dd22d33ee148ff1" + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getBlobSidecars.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getBlobSidecars.json index 63b0505e93b..ab15088324d 100644 --- a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getBlobSidecars.json +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getBlobSidecars.json @@ -1 +1,54 @@ -{"data":[{"index":"2","blob":"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","kzg_commitment":"0x103ac9406cdc59b89027eb1c9e97f607dd5fdccfa8fb2da4eaeea9d25032add96bfd4710d1f100f267608c6b69cd4448","kzg_proof":"0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f619b26eab6d66297cbd9dbc84db437c8","signed_block_header":{"message":{"slot":"4658411424342975020","proposer_index":"4663368873993027404","parent_root":"0x5cbeb140ec0ad7cb653388caecba483cf66bd817821ed18ca1f3b7f3b9b58a04","state_root":"0x1f86d83f0bf91cc0d7e07410828140e0dddbb331dc20b6743f9f79e549b50b11","body_root":"0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b"},"signature":"0x992e2695a49aaedcb373280f375a08adaafafff0bab131d48674136f5e452c8bb0797618eeb99bc3a4835bca2bd6aec6067807e927604548997a795d7ba982a5274f0d1d55624a8c7b66973c6e717f3c46bd2d92bc1696d3173751a6b0bf6a63"},"kzg_commitment_inclusion_proof":["0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486","0x6b0ac13f8a279ad3abec11bed1a49214f6e7af79b643595df6a38706b338e93b","0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6","0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26","0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1","0xb88ea93f0a5617e780f8ae6b1fc8e4480ff4abc18f66fc45ada895271cbcc666","0xcbafa33faaa1f62b763b1697f350f91515f7aa53462f2500db29d9eff71c7ef1","0x924cb53fcabe585d9672e01478b6bbae02eead9d22d5aad151a60e9768fa5751","0xa56daf3f6a0a38a28bb547404c3fd07b08f1ac2fd99dd38b7f27525f425b0fdc"]},{"index":"5","blob":"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","kzg_commitment":"0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec0636688650b0a49443de4e2d69df618914","kzg_proof":"0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a795653913a151466aea2c5bbf193edd4f03c8","signed_block_header":{"message":{"slot":"4625361742829423275","proposer_index":"4630319196774442955","parent_root":"0xda533c406bf3482d8e6e992e756be34172a8c47fc1cc0018350bfe98c946deda","state_root":"0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390","body_root":"0x4d1a19402bb984ca4d0005336ba05e1098babeeb0781f5744712934ae78b2a1b"},"signature":"0xadd071eb32731713b9040770807acb7033344aafc6df54ebf8a790187ddc947e2bb06a9547eb7c3876533720f36e54761018488a3857bb1d87175f7905620088fd81593465b7139e794f75bba0daaef713a9b7bec99656073c1396866d35f9b0"},"kzg_commitment_inclusion_proof":["0x27d82440eb21c640637a36dcc38e35768bb4c0c79aefa300ec0f0cba32cabb05","0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb","0x999e0140abe701de220ca2e0b9c3b044b1c6ba33e0a3985dfe16a16b510f0846","0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5","0x735c0d406b5043543786d38912b287aaa4c0bc0f731247e9a3141adb9c4d9930","0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6","0xe622ea3f2b167ff1f7173f8e08e70279cad2b67bb9c63b46b51baf8cba92e570","0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0","0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b"]},{"index":"4","blob":"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","kzg_commitment":"0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd0ee000b841381cd96f346bde6ffd5414","kzg_proof":"0xcf2c053f899b836f534bfa2a45bf23b7be4890b9815a72a2aec9f70eff53d592047edf91261d7e7ed3adba3b53e44794","signed_block_header":{"message":{"slot":"4539432581202110249","proposer_index":"4544390030852162633","parent_root":"0xbb0b0b3fe94fa42a5e0893ff71360feab7459127ca9149e88148b44625f31d08","state_root":"0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd","body_root":"0x2ed2e73ea915e0c71d9afe03676b8ab8dd578b9311463e45934f49f843386a48"},"signature":"0x958ab38cce5390fd750e87806f32ed8993a175bc3ccdab7ce2a40c23ac6117b603d5ae98d44a9780cca1f32d28bf5176058ef667b17fd95f13e047cd9cdebbf19f5270ec5a154e2ce2283da513c9ad05c26f10b0a65755eab4b1ed6f42175027"},"kzg_commitment_inclusion_proof":["0x0890f33e697e213e331430adc059611ed0518d6fa4b4ecd0384dc2678e76fb32","0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8","0x7a56d03e29445ddbf2a59bb1b68edcecf66387dbea68e12d4a545719acbb4773","0x41f3e13e4961bf0c12dd652f3bf49e85e35a8a25c70e67ffc1d08cc01d9921d3","0x5414dc3ee9ac9e510720cd5a0e7db352e95d89b77dd78fb9ef51d088f8f9d85d","0x51977a3f0ab3110e2a10e9c6bd0e89b1410ca45142ac42171bb2b169efc281bc","0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947","0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7","0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31"]}]} \ No newline at end of file +{ + "version" : "deneb", + "execution_optimistic" : true, + "finalized" : false, + "data" : [ { + "index" : "2", + "blob" : "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", + "kzg_commitment" : "0x103ac9406cdc59b89027eb1c9e97f607dd5fdccfa8fb2da4eaeea9d25032add96bfd4710d1f100f267608c6b69cd4448", + "kzg_proof" : "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f619b26eab6d66297cbd9dbc84db437c8", + "signed_block_header" : { + "message" : { + "slot" : "4658411424342975020", + "proposer_index" : "4663368873993027404", + "parent_root" : "0x5cbeb140ec0ad7cb653388caecba483cf66bd817821ed18ca1f3b7f3b9b58a04", + "state_root" : "0x1f86d83f0bf91cc0d7e07410828140e0dddbb331dc20b6743f9f79e549b50b11", + "body_root" : "0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b" + }, + "signature" : "0x992e2695a49aaedcb373280f375a08adaafafff0bab131d48674136f5e452c8bb0797618eeb99bc3a4835bca2bd6aec6067807e927604548997a795d7ba982a5274f0d1d55624a8c7b66973c6e717f3c46bd2d92bc1696d3173751a6b0bf6a63" + }, + "kzg_commitment_inclusion_proof" : [ "0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486", "0x6b0ac13f8a279ad3abec11bed1a49214f6e7af79b643595df6a38706b338e93b", "0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6", "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", "0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1", "0xb88ea93f0a5617e780f8ae6b1fc8e4480ff4abc18f66fc45ada895271cbcc666", "0xcbafa33faaa1f62b763b1697f350f91515f7aa53462f2500db29d9eff71c7ef1", "0x924cb53fcabe585d9672e01478b6bbae02eead9d22d5aad151a60e9768fa5751", "0xa56daf3f6a0a38a28bb547404c3fd07b08f1ac2fd99dd38b7f27525f425b0fdc" ] + }, { + "index" : "5", + "blob" : "0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c9f48c0f1b643b4559736eabc189a252e040935cd157474a4552125f936ea47427d430bcf3009ecb1a03a63e202544e17f53610c4e925f094bc0a269f008850ca78e2901186e7b8b0d3142e301bb53ef0d240947a7f2272333db5314991431f06751a0b5199985a3402202d612ecb785b9f91108833fc57e09c43d591bcb8a872bccc64b0df5477fb00940f26b956fae90863fd0634993635df01ed444a2d59ad786f1dede191ed0d29a2c68970edb45eda6d210c055a7952d2c9fee6785bdcf13a46491bbe10af11d7a1d13fb8ecf77a882a8d6dff8f4fca8377cc52770c242c772a30afa73c7fe1ee4c33fa2c3c36b2a7a18d48ce436206c66d1056eb82b73905e4ccd361d9ae60510c220d1ce0d1c672ccf8b7f04b0c7bb12a96a26db5958ca211aff3c6012f106a54c596095cd71c468575363ab30ed821ec201d095934a16da101c84476955aa61192192be5d2822708a13a526ffbab3464d28fc1bb65a06bd9b7375c3bece5f72418f8eb64294c3a0334b53567d09ccd7d030a086f2f1503f022cf2488667b50f05289694b9fdb4937893bb3c97c6d1431c1c347c2dbd58234729ec604553e2df3ce8cf731f72742a827d3eeb34a85f3675f2f5b0dd01e98c7dfdbff58f3fc0877369e9b4dd257b85d3285df2767939af2d3ff15cbf164dae38bbca00ae95ee54b17e891b13c4d60b3df1ad1520236fb8bcb4eb983a4943eb6489511ac9796c794f3bdc7618fdc96395aa6e423c2414eeeaab97f87aa49a1c6d87ac95a900338a4eff560359275d625adc58b3281638ff7ed401679720b44f06147d78dcae5c5e8aed23289073943539edf0ef5935bfbdd96f11ca89bc04bea16215c3476da80e9310e47c20bd023d397f409470eff97749fe4a73bbb5b3d60595c0f24835c7d52c71e60a0f2dd600d0300eb3fc380a97f9eecbf2cac3a879ad6d9b7d737ec5511621f6d608c900971b7507859f9403d19135ee110f4d0f9b660cfb57d71d2a681e6dc16affca5cfb45eb148e60c88a12508bb7eb406fd47718640775667ad90a9406a356b8d3a88a7f0b346d87a1de9d701af798572d7897b2b4a06630b16398655455a3827d4b090a8f531d70da26c4667b4adcd3fe2bb66a3ca796362b64a68218746e1596ce32016bb1ea727f1440fdaf065bd0c3e3e1b11de7f256d1a716095d1708a1ead64f22bd6f4de6092d20c2e52e245b0f155e10c1dda227d5eddbb05ae83b4bd2f9a996d62eeeef871391af3b9d9c36d60a9f9d289de6f0e9fc5903bd7de0e83508d459f851d77d0abdee7c211f27903c2c6c57c9ef6f980b7e15a7b7a121a29156df0980de4ede731eedfc4764adb1dcf9c8006fd20164b6eefa712d3689a26b70c201f767a969c7cd81a1a47f2a5f9dbfe8623d86c5f7fa630d43ea459da479e5f36e39b6bc71d40cf6323c06dcd3e4a2630234a80e5bf8fe8d67efd14bd3dfb00520d241781d457494dd30836355e922f36687517abf816e11ea265fba00cbdafbef1693254b7b582557ef7383bfc239aae34787d747b0be87e26012612854fccf5d3964398c428fa1adb9e54123204ca92ccf315e656854f2ab788de4c306cdf2ed96125f21c3bf3a024b2dfecaf5f87d83025d4f2021b6ac1deec23905a4a11808cd8882a783df4a3901c21f7093e7f1af553c39abc5d126e3e54274025a6b08e967a7054eed249fe8bbcd721ba22c0d0f1a980f92ae52510dcb9d1d8ca69afcf8ae5b5434ff5801c6f0fb1bca0af4019d55cbda427ec037a59d13bb07e3f2358ec4782538277ed819cbed5e00d4c5510d470c05ac42113bd26ff358992f5c73dccd4d77ca880275d3b6b5aab9d6a3db9fe41e200e8da3c860123bff5cb697987a37b07bdfa57892c00cace4771479876f86f10f21c426c8a53ab928913a4bbad4a3a3acc9e1eb272b51cb1ca8edfe91217be4d9d6a7c150342e898dce7e333ab3079ec23ecc1057b765bf7db717118592af82e7454fbab3a80dd705d3ea72b9d33046c55db852a2eceeb8a31170ef23c6ef25c29585d272937e2ebf3bb1c11f4bc5c5eb099048bf62b98c6d90ca1a8936949163f854f8720943692736f06f83303543a397b65d8b46096fc55515d4c5cbb9cace507dc4b89d0561dde77cd16459316cbefc4da83c415d0ef840bac5798189e052ac172faaec43bfd75406a44548314b065092b4510704c595d659126b4fc731a7446c29b9c57e9d3a03cd08143f17bdea411289736518e677813fb787fce9d7955e2283c095ea3f6994dbf6faaae4d1c668c7a3abee8f6396c5393f2b57bbdc2a7701e6f54bae1f2f43b38d4663c6e8597fd16b05a87c063f66a829b17cd682dfb2f79c892cfa404f0ee541bbd77770a33a805c040e6f16ff6f1ff6011f56a0355e2d860aa991b9f964bf0d1089b79ee646ce4f68a54be593871b491f51aad213ed7d4557ffca4e9b3e55c28fd734c4802d4ae20ae7c23110f20b362c4e4527821b9c248301c163e95ec647775f18b844fc7e5d2fdb339fdbeca426b8441768ffa370ddd62d0d7ac9cfdf0b7d56adde216a425e340069874b82bc4292bf653ff53eb1a3ea084dd76a3c6fe08fb42a5f60eb196ee556f6144a241c37b15afa8f69505b799c117b0922ca2032abcc8e626912769d2e7f40c2c346ca825109874b5a4b2c69d6c8cc72b67977204fa76a22fa04dbb323292be63e1598d50f0bc5912cf3bd701a09c361f0168e02140f6a8a13e5addf6d527131053107108bcb44ff70c4bbafe4f823b81c9952b2ef581835e151ee4c8bde195cfb29965bd625975e18de7f6d01287a118238a217e1b93c41f6aaae09812c5b132c52059c2058e5f6197054f38dd2cffdf46495586a1f2cdef6570e0194058d63ed485cbd1d055629fb3c3fafdce01c583565b3f614295dbaeab920e410997b2ea69b6188662bdf7d22faf83660f71c1e83ed5494cf6e2ec8f3e63eccdaca4dda3da51ffdfc45896c9eaa95bc1b92236a46aab1e2bf34bf89ab8479cbb19ee00cb9f64b2c2f557ff65734b64e0d9bcdb8344b869033d4daf2bd17da7cd33ae9b3582441477ff734a1c77d79c97781739018a20437ec646fb71337a7c0d2806c4ab94d7af2aa136bc788023163fb83583d36dffa16a21c545f0a4db2044d11bde69fecfa46b875ec19605061d360196d35e8a848a3abf2091ff7b2c37812cf01d9f95a602ad146240a8c628455d3eabe23ea4ed2583c194604b66ec8598dddfccf2495efdcab952d0737c589f9829919cc13c0696805a2f71527f9ca2a0c3ffb7fb5e5afe7ddea24ad2d6abef52a84dd66af416218fbd3d4fe9b6c740749dc7e0c676d1d2e659909b31cb1b29f63731226ebd6e46b29f15e6b78741ea33bebc85556ca7200a7b35ab123367cd776a28423adeef660f485e42b7fd1493c1d10edd1bfeb7d951a182b78cba5b11c97210ffebc34af071303be1ba0cde9044b158678248dc9c0665a27dc71edece65c1603cd4a4d064c435fa10e33687faa747f794651035d3db4f8a1f81bc4b5fc9b0bbf7fcf2072d9c58271a2983a55a1a86a89496dd83df6225bac88c6e0f72f64138849d9e6cdbaf0d2822d8c3eceb9068648659e59ce495bb6bb34dbc83d4f0e876b9a628066e561ec0fa102d764c3f0aa2f9e7c43b7f4e63b5553f587ce94269d3fe3a85bd241119225c453bd3b124ca7a92ed0bc54ed0e0602c6eee104077c245132fce9cb600526d59bde9262d7c7f5ded0a97be4f3cf478cffd428352a22cc43290c5620b6a73bb391539bf7b4cbe435d54ba08da1d72cfbaa0a05af7d72438c21c2814223a9e1f42bd05e935db2b9becd43b228cddebfd7a22970e78b08958fbc4cf74787d1a3967772ef8ea33e3541d051e018c4de8a2bde109db91c9c7fa2931a6921ae5973b4fdc0abedea3e9cc40593a4a4d21acdd194d8e97de4316adec3b67cc7c49fe8e87d731e8a93fb37be4b4abf17b72924a446c1aac4445c3ab927333fe6523ce6853279001f45eb7a3bcef088ec13af501c859037d16769083219af2bd7a10110103e1ce0fdb1b156daa566fe8dadba55b4cc14be87a851ff3c42886d16d54da4455ed090762d64721f72b5d93da99f578e56442ae91a26edd6bc6cb48755357280084d68d6cb0eb78a2215c92841b4ed7eb9a70df8702655f1dd46fe5661970fa1db899cb6312922daee17b5c66ee596d5dcbd8a9795e6f5a21e48fbac9d3f75be8ec2e3b9d26a641a5889cc3ad02bd14d9f6841f90742c06703d2d2e3e546dbcdb58debb015c61b03927898ac82b5d42db2b65d04285295bfc596fc6d8914b7e1886a35a40e7cf77b742e2b385a13a4f01117e5106d5ae685567b66c6f25ea2499d8c38d0d3ee52e3852d8d3c880d8d3be61670bfa2f9ce7cac97d1064ceed2d9fffb4dc8c9ba099f643b6eede4935d81e681aea585e559cb9970ed42aee48788a85532e087f41edddf63bae2b5f53dae08910c889b5be59e41b022da50bcc5a29456937852c8cb674c0c8f7348b51ed7fb9b1aead8849b7c65394a26e4f46cc71ed83c39e2a1e948fe9552d0a7913737802134673b110cc9e73c6136308363f7e831bd244c3d236cc2f41a3a3397a326f00050ec80c0581836051aff92909139bdd08c2ab86375ab140e7141ebe2cccb267723ab9fb294c3d3568078bc8edbc2b274c05c0c710a774430e22a562f0cfee7b0e4d77e2e166bfc24aeb3b9e320a31612317e91deeb1d350201f776091f4cd9653c6f8ac4ad10f08a8f0118a371e44df70aec3e4ce8721f335c2ab595b34b7a5d1872944aab424bed0d6a90eee0decc77166c0b9d67aa6adf0764ed021d0c7abccc1ed1debf6bdcfb92d23d0e93a4e96c45741011221b4732563ecaed87aaa3d2b8680ab28118adaceea171b01d05b9cbf5be6614ab75b2d5766edbebc2ff205b55adfe84b7bf5b194d5e15b7d01c97b17f43447eb598938019eee320c752d40a16405d0b73edcda1bf602a5dbf24cacd510ae60f6c562e5b138dc1c4f0dfd3f7507b2e50582f511436f412c1d64e3fa9e2eb12008942cf8f4a1b7f62f5917ea321158abd21f39c4c96eeacda7880b044a87413d6c1fa5290e51ce1be4eb4738d7cd9b2d9a9aaf95321dbb84b6a949bfc54edf34428bb8a683c4a44b241429b8289c7776a4ff14dc75b721f5597683f24f362cc3b197ad8f7874002bb55b8b0bd6ddb719028b7723843ce4e4082329b9fbafff6d2f396f79d7c54ac37f3f3d67e45c00aa981e83a89858bdbdc0ba7f0388ace4fad02363ec4c48fefe39a22b166e80f6433fde7ade5b782b0db643cb1486cdb7f3b1bc51e511c9ee2d9fbba1f5b0ea7c00eb82faecd52d810695998904d045422a68234055860404853886c5f66c5a2683eb36792c315141ff511f693d4fe23a308845c19f9b006e9cb5ed4b9e92e92671370d30ad4c87f4f289aa280013f50bde392e2f1e0f5a71f0d43fc687410314f2c86576b21e18f1fd724a18e1b61c1acddc03729d740ea960dca1d8df16abb4350ad1de31e73e01e15ccc844719220dddbc6576dd108d02b0a18c1fe8cbeffcea51445f55325e6f86c11ff2ed6166c9b2d61b39128418c80a2391887624a310c66fb197fdaac1c275e5fbaa64589b5d32ac4a5a6644c3c478afe768742db1d2024953da3bbdd7625c0869d68f0ac02508299d7e75e890ec6b9f8baa5fcbb017dd8441f1d5080d6a8e250ff625c39bc924971661d04186fa379de5fec998870b15491dbdc7a3b32c80446c6a3250318a39a37e5c7a47b225947d4624d7143bbb7206e9b0be2ca05b4e59545c9699e4863e71995f6ed079651fa8b4f1c42149fd3c555ddf9fad663534b55c3584874c40eec09db3161eb0bcd70fce0a5cd32124bfe14cc6fe4d61ec140715a30539eba348229bb8d53646aaa0bbc0d3818d9cffce68e944a7d5ea42f6eb2ffb738a46590f3ac2bf7f109b2dc3de9b7baa7282b33ec4fb3119ff7662840ffdb8feeb1ade4a16c177dc8ab6c36c817bb95f2288d2660761d7069a721d8adcd6b62a88a23cc592a5f3293af9612bb95027bec750fea5ab5e30d57d151f7cbd65b84fba2acc8fcdf73096010bba747148fbf9775406dccc9f28204c9007f0ecdad418d571797babfe25c87d12021fc4123fd6e0c320f075ed41360340161fd68452043987899f6c60cd593f7f13e8e18c8a2e47c3614afdf3f69a60d1ce69055f8fe9ba27a7d750915853d5f0f1f08a8fb56ed596065671a7e982137ef9cea87fa46c5ad04f434cc2aeb9a704b33a17e4ea193a9a830715196c59bfcd7975a0848c89480163c4cb41a2ffa1144f2f0fa20443961d8551eccf3a3dce84ba291f62b7113e6bab838980d28cad301a1a54772017bc813cae58f64f8113abd8d6da3420272201b76b712c053ffcdc83add89ce853bd2d649ac5ee8e2d3ed44a11cdf92bc3002838aa9513dde7225f437be97924c7c9375e176521a8791b147d8e834dd22f517f773433c139ca03a4457b0538c2da5ddbb22afc14fd56a948bda70095d38c8cfb1240c606371f8908898b46c9b005c116fd5cbf247de5f8a3dedc2b320a4e144d64c92ee3b7942f8f92eb59239055d40905393f656bfde09f2e4dd2a536bc68cd6d0ee579a4c8604c4fbe08b173ed30f060d4648abea980c5b04237c10071af6c1a123e0c87d29d13048d503cb18296d076427ee053a891f219a434494ade8959f21cc02600b879af64c30bd3fcdda93b221a5baa7eec8a06af81ebac59c53b5d233887749ef9632e0b312a68e05d03b492fc7876951b9321fe8b04b2d5bf2126e1b5b9ea0204430e4f8c7933f4728d993007403dff1143df649a803805b877faaea60c3edebfde50ebeafd111b2333b277604f5aea5c383779261978486e6f8d196158d440011bc3f949da686c89dea9bfb2d9b247bf77edb5cd30594bf596f0c4023da4ea1702018908c94c6352c723dca9119bdcaf9fbc3ed353cb02358fdb77e9d6b4c4439f007a6c24f0603f11375776a64c3ed9eaa32b9d483b216a12c4fa38832f7238a92d611d7f998ea6ba70ca4e5000529a02038e35b08a50a44a803656b435f3a0fc5fdea6cca4b1f0dab483eb6cfc7c85a16d4dc9362b2a45786dfb6ed6eca796e6363ef81951921c31993409ac2a08e105610d2c543f9885e8543ff143729e2c3fa33ee7d55c2c3a0213e4eacb065b29344588549ce204f13b896d104aa9fae653aa7faca9b2fef24792bbd365f8998a09642fda9ffb7ee8fcf599423d15733ea2ab8061e1a875fb2ee4918dca69e4681ec06a7d5c39c61d861b05c49d31521e62b30988649599a3e57647e5ee2de7d978f5869f3d1e0218393164144cfa2768e0a387853eb8e14ebad8202c6807b8280f8e3ac6ac3ac2b504e8cd76cd955b72a93f311fb7be49ef898c4db77862f7531a74af1d32f9c7a33b87016fa0531982835ec203fb608e907e8db2602c94058e386c28f0249e04e5ba5dfb4ca170ad5739d7394154dcc3d01d1ce1038530b1be5fc1ad33ec5c285560c16e9c7e5338a034e84dcdf24b4f60a7aedb02b74924ff9f8ca7fccea4191cd116cbb23d33cd82e8283aff4422aa85c31eecc275aafe1fb642ef055507ae3c909be624cf5978160c4e2113e0443d99816e572c505d7b206e71ad2b375a080665ec464fb3745ee8a44a7caaf88c0f8aa6be2c2c1d1338bad5d64bf1dff611a4118244d0aea52279e197f7486baef95a4b50c635783ab5d63e3cdffe7b399f90599ef30c8f4505bec3adaed454c78f9dcbabd4bc4ddaed1412bfaf9a9aa1f11b5863d2a9fe8ab9a09bf6ec1a3b1af7fe0347f5b9778176467171f1355e3674e7260fb9136a87c47a51c77a4cc5b46cbae044e7296add6af3a97c52e13c10c16dd4956ef8f32b549e8026047d040558233c286a8eefc911d5772fbfd3502a3979aa1391cc7948e1d0616c56254c9f621e0d94b36df5eb875b17a29fe638ddb9a8c4d13646a8b69bc9850509a09ab634a6e57232cf6829f12828dadd1789a545f1f6d6c9e11f2394b55fe2a4af91092447c11f07c12290a9925f98360acb17c819043f255ca926d3b69f5d85f5fe4559a3236a31d4e47dae240b3ab2840e24773d24d2e83b7aa1115f5da37c7af424aef1868ff69d651b011c6358a6ef090bb64cdb964c43898a923912e3bc2c71c1cc791a846a366d7c13edac0f4cd9caa6c88b1f587b01f3a4b24164d6a65999ebe619d12459bb01f769bf2d18ca75f6e8170fd059a0446ecd1e68c066e5377f7ab2c3bf2c05cea3837aeaec1a8d189ab042467bb5619fd0d14512c57bad5d7bde35fccb0754149b387c7f46ecebbd8b59b86f751976e8a20487987c3c10471576565faadc06b6523249bf4d9660825aa7241d3fe461bcc5fed2c6674d0dd57b6708182d6892e1c57aada1ff5c1229cfed86b83bd62cf82541f05d58d579cc8d00766ae2830046fcc17d5045260898fc9868fbb7d30e4181a859921b53e05472df72290372079a96f998abc6ef1d59e07649774071a77e3ae5b88df48d3478c1651541b1482c176b2588c48c3cc31a9364020f484451583e6953ebe62a96a93c385f2d861657fa31f3c76274a49b2f0941917a1e3287c1f77d5c3dd1b0633b17cd7380719ab80342ebe77e70ef550b63477bc536371f6a5474038757058fe7ce4afa60e7a842f85c4c93c99c6671cacd32b5cebd60534bd92041c19dac7b489439ee065f983d228ce44725204534abf3cdcaca80f22e1fc715dc5ad255ae5e43c9503f214fb6ce0c79f728df72c98efccfd1bf23f3fae54e4dd7b0887e3c0eecade2ee66cc99cd4c8f109cfef2567a1e298e0ba898b260d6358398e3363a9fead44c88c74654f4f6a8730236b0e11abe2010db424f5d984c52b5dd8f505b3e9074e496f739b39d0f45aa0af290fe3a1fe7feb5835469578ee03eb98e829c7b5b388536d7fd9a2421384d1c47fda34fa57cb4efca20c7adda37975dd04b10cac08bd29bd0c0d96c782de8d2b340eaeda3104a351019936d57d1d26f9e9eda0383458f8986ff02587163d07bb3712c4ebf39b607f94290aea52c6c87d69efde39b35a1d9d2d3c751d3f4549a20c9c6d2dca928383ff5934a860218b1f4fcd889b457c4fb14b5b1c63d4167666793a279a33fe17067be47628e77daeeedb724f92dace76fd0837ea8a4465a488825db6b8c97daabc7fb53d8eb40d7b2da4fbf9cb9f9ab4b9bfa9deadcfd9f5fea7f0a70837ec2b8ddda1ad339ede26771b3debe81f982b85cde7907390c7cfffd88377917e8e4bcf5bea83f65c3afe95072120fe2af7b75db87437b355c7b2daf09f3153b4ae0ac2045644aa1e98c091bfe0c23b0f3de539ca0fa49356f2025a8d5ebfc948034d67a6055e86bc6120a5f0459f213665db6102d42744e7a9cd563c925886099ff59c2489050a2cdc327542bf758f05cb61b153e628626a09d5f10880a37de2d86a83d356e7ea52b9d0b64bb5f96db816d8cbfe3850cdfd9329b4123be2b5428770bf21dc3af8e00cf5785ff8acfa7275b2d7e3bde171261869273167da99e19351d2afd2ce7731d581f6666728c7b98a1b385b3d4bcdeacb7045d404c9e5080d14f4c4bee6ebc750d6d66aef3397aded7e88fdddf9505546ee311c4ee1564a3d06401af824e85b6a9bd62a61ea6fcc80829ea6adf3f1566d7d6f5fbe8c27ae23ef3aa1b42d715b6dd804e4dbd8659307be8d32b1ddaa60d9fb77ee8527aae9d1ae929d8f31c64adfe999e5a55f33dba162a2d2c328caa8d2015c7c45fb8f1169804f5272874a96ddbe28379f9e895a09e09754718fec3eb76b3f0aacb1a00ef4e587f908cf9060476a8f5c0ffc6043dea3318cea1ddb6d950075772d3e2de1ff3ceeef4330c3a7ddb2b8c321ad0ed5ab9690f166a5ae3af6abc9131f677ed96d5a02202f9cf60bb17202b4a5dae0c92c001ce1013abd28a5930470e83e185d00adf09a5b6a9ce8f4f2e7ce877ee9d2b106580404d88d3dde2f7ce44e1502d17c0ed49850fc6f08a5f743922bf7e175406929aa6b8aea60c7456a49193955448fa0335bee2954234fa0248beb734719b939ab685265f3bde6dc8a86633a6a840b3ac10505948529c245ba26c7646fd05b722c31025e17bdadf7d3696031ff3510d48ac03ad57d57a1cf9120087d2d02fbde4816107fb29e5ffd6025e45bc8a641e8a47ba66fdcc4a27c9be340a57bc44fc2f5650cd7bcba722ebd0fb2de153a6a6fbc863d7baba1686ab7fcd603ad4ce7c62630768b2a69c3905f435361251e9e0754415fccfe4e6cdf30e120a43899d3d74fb6ad9f5cecce324a281807ac3137da8d1f9d2c5aa0331ebfff7521d5147876f5db1951e4193ee7916b13d68db43bf98b21764e6e97dd94f8a8012d9de0712f0c3c35f0a10f7bbed83534bcef888b01dca2366c271af51cf2415f76bebfc96a9c3429219a16e6499d730c2c17b54486162dd74ac88a51b90efecd72c8e03c4e0f94768b1f81d924c4b8bcefc2404786643ac433b80a704abeec4145625b86fed0a3f62bb16e20309c810f75c06280c7e197b14ca594b76ad14754d8bce5a59c0f06f542463bb5e8518a6ea65036669d12b0800f77aca02161d2ca24f6f9ab6589914065e2a6974adeb7508bbe11c45da62264a277288aeda365c3c894d884f4dd51389dc29486e1ea7ed18aae9289cea9ea81101cbfd04e37ea217063836ef4796bb9b992cc65bac099219a0166c54a45ef128eff278db8c4a33e1f63ec17d847d147792b7fc7bdc9dd590add7fb277fb560c9a02d67c02742954b6dfcca2e56baa86547c6443a69fc5a9a0a6016b348921a218999177a794bb563e36ca3cda338d85f3e97d53dc2de4cbf8f8741c09d55df6f5f442aa439449d4bb557a556631f14b48088c01c8a01b6b93a3b353872b8f0849e4f1d6f948c573ea24787bb269f9b721b04dc3a17d70275af7d736d90023df50525aac1ac61c9e74e13a3e68c1094ed9e7c6f1df50917f9b3f7afd511914a4e18bbe47f14088eeac2f575cfca62961fa079b20460cfa070b01869a5e6ac9ddf9de94e8856c61ce5ea36dbb82bda0b3439b470eccd09942635c7542c51b192711fce510b6dafc3661664c37f8d1ef4bd8643652d613bf72973a182436b82e6656e40cf3d4b3d410c7a186a37e099ee622ad91ed978486c42c1cd55989f53674b1d57bd0b54bb066bad554c2eab26a1e1c80d7f92200a1f03185bb8212dbe87e303fcfd5be1806d892e6c61dd870ed6638abd26159bb0031597312a97a827cef5bb90e4aabffb6861da735831a158ebfd9d7461d6e1f58e4400938d5378785a1224a31b3dad8a7f527754dc133c686d16b2eb612a1b20527a392bd3a75922fc91e1b1dcf0e12714772d5e20192debf6317f94e12029d42489cdb0e743da7692b7d900acbf84e34a88087237bc5d18b0483c3675dc1db8c6a769158506df4db1d3b87d0a57312e125b77baf7a24b3e075c279a2880bee5227f5f46c93620fcc3b06db4cfca7af31a08d0f36cf888a17c7c004833ef062d9ff1267db4e4a899285baad31d486384c97fca441b0b38ab9bd08d52d882a5262123d71ff1ef5698fd8d68c121dce55169a201a7940297677b771734c38a7b16b3d4b23187fe5faa9baa603f11d66d772df475df22ae72546052ecba73e4219ef2d997535d7fcaf8f525921f19085a15c8ab0b078824aa7f59dadb058b36613fb3498e54a9aef3a95ac4c2882d2f827ba2290ba3172bb5f5f227bb900b65baae7e0e3f52b27408b84dd1f64aee15ad2300dda04daa201d80573ce450dea3ddf5dca67b6986e18f1778bef943119b197c963b5bee2d77feb37b6cb4e12e2532668e38b1f685fade2de539dcd304a0f48163b7b182d49c8c502c880bc170c1545b21957966e688a29708d96f61bc08e52bcd8d787623948bed19f8cf9b1f1f91cd8d710d968e9a593f46ebcceed86184a453e26e8c6560d5f93b9769aa8cd06bb4c0ddcbc3ee70d7c3f6e3cdbd9f76de5460d6b25641dad809257d461d4b96193941fcb40fb6abc52e22119104711cf2befb36493f76761576224858990d7507b95915f08b87971dfb6a01fbb1b0bd362874e89a200207a24941b793c4069651986e6448dd10abb06be310334253ba12143f6ff26d3185a980928d70e21ef94ce46c69ab6b2467a031c71123a38088638e9fd401ec5b81e79648c96d8090d8fec57a1ba922b900e66253ebfa28ff9bfa45dbac5cf94feb2e6688328a32be3da1c45315fbc1f175cdc03656ad92587f1b770834f966ae84e3540727cd5f53af24d8fab6f9bd8df1754e5493711eeb35ffa5be4db5e0b87480d4d050bf1e0211a94bac4322b065aa5137d21643ae58f2522934b3d1e554231330cda7ee2170c5087039369857d5bea905afa660fc0569b58492c2715145b7beaae3b669b424e34b1e3861a12935e619295759cddf9b8a3d938b311c73dc5135eed19e47c689d5300ab0f32772c53410cdf435d0a0bc3ef281795c3fb7a86843c912ba20095213abe42f263904ad9852ff73f5745d5fcb519a930aaadfdd6b453e6e16921cd6ab614e7427887aed28772675880a7e83f1cbdc014711cc7c3eade10c32bdca3a4d2d9a0adbeb076fd96ac8a793a3392e6c446bd95d8cd27be38088288bc854720d9e5f991fdbd785a9eaa04709962ae46a94c34b2317a87129d946b49a5acf6ab077ddb89df8fe92ec0c08b66300f310d509ca926a13d9840c64be95c3218ffb5d2f2c859382fba2deb7a869ca3ff10ea0e3a363f9c3d1a1fce3bc49994ea563ba6f4054ace0c52b512687ae977604c145d761f253d0763934ad2a0ea2176c6b1c96bd39b71d714cde6a57f04a0d61f0758d7ad074c64d0ad22a49eb6134237b2c389842fa665b30bbe62389f02e75e070221530e39535b6765841360d639c38909b8892f38dee77f4d1434e6d49ddca15a72356a110af26bd490267bae5f77d66384dcd9489f0c899b7a155e990683594a04d451c71b50103a36f5b4cfe70bb3f40bd7568f463e81ff851adca7c2d54db85aaeb9cd326b19c1ee06197783a16ef15ab2c9c8bf8ff0a4879ff4d46aee956444c5dbab7bcbebe0aeca474216bd608cc96f99db20bf1c42d835cd06f0d5745bd99e5f38094861cc68bd29048faf522b23007d6ee38d75d85a8a54a3952cef64579f9e8f747827a4a8618c444cce2f4c4ab7d09687a1cd7fdc551542bbdd891244b549cc795ae389e2fd0aaedcec54335e0641e71d9c0839a828640902ca38d17b4c9ce019acd27617773072126e120ec3db84bf8aeb7fa34c6bf8df990c2eece3796c59a9687d24347b52f4168d75f038f163c16747c12f67f7fedb77162776fa338bfe94bacc18a31d767b1eaed52498ab74c8322415fe0bcbf9e62810f6811481ef129e11629916f96985b1e9ccbc13591dd1d2558b7450e21b3544290224205ac27fd5cf6d845304a3d2dfcf9152119d79a68d8bb534d400f1c2fbb7dfc82236e09e7ad7c45a6360dc19681df2554403dc3099bd53c7460560a533b8ed3c6fe788dcf4236f54cc80cc30d3dc774f80da9b14a6ee6d50914e23f692fc481f580446c82338cace0eb56e38aeac51fe1dd395c9a26b383b03ea170db05f3236e6c8c3131f9323b9ef7c1ca0b2029ad9477d30d0a2c569de1f8c7b459234c418176ff1ceeb687e6da6fc719110a8f81cd50945ad0ca581067d6e95b55e7e546f131c72e32121e0a77356ccb20388974f99fe132c8137663e17ca62588c06e7679c932945a9b00ae7104906242791c25bd3ef303ee4ca90d448ae2016b517e5b438a0e2825c6658055423ee985c8afa66d5c0908e5f1696957cbc6ffbfa43617723e72e13872dbd6c41cda6278493cdf9500b643734437e635c2ffff057227569a5710db9a032b19f4f73fd3b254d077745de430026dd57ccf7cf7130772a59042e94f14380b783e2e2d36664b94b7907cf287c3212bded468bb03314dc3074a6973bb2c627f5bd35119c7936130da82d47e1d47011687fc1767c203a95e7d5ffe7c8e214c84fd554e7b5e57950b25d8d6c3678ff96cbf0d48581e3dac9b6c1b67fe6b848ec46f93aa22c4b08b0f0d4d9117121a0378079e3b6db6a72ec58eaefb9b87b9a559ca17ffed4daf6e897f1d48c7220a3c78a36084f0a0b1cabd39e488b0cb8a7044cdb07a19e3386996d117f049675968280cf5894fc5db5fb48963ce27c6c4b37508795fddaa972fa080f0b64244376bcdbe75072146ad90e85c93012966a19766ccdf815c809a74e9d5197753934fd1d6cefd8e7bb55e457f53434b91d47b284165a8cae285bd712abff247bf789f470fdb05009c0d6e28674590473ef1a7d69862e9b9737161643d6e78ebdc5a911f5d482b16dca7b1294de01687283f4ff4b2edaadfa86c910ddb91c65e596554d012e4aedbf8ab4dfba05f6b104e49e43c5f70e161e0a1383367399a504a42c774cf4fba2fa9b12494a990f9d96cca144a600e2879bbd0f11dcdb5bba210f3d849efd84545848ef9b1a994e4508d21221c64b3ccf5ec83cc1a6c09aceb0af3f5318c9d4a25388a7d4f14133ad45cdd2e998cb775b657c27cf913b932f6170ef3310e21c72b1073f333d1cdd03c58685f06885ce7337d556b9111107142e994eaf54bb2fe86cb4ce56491c9764ec61fa39239a535f43bff053b4b29f08125d9ab4b3b4546bac393a7ab337ca749825f9accf149fd17de3880536d4fb7195b1bb0a331a2a31e634e0a1a39b3de5c964c552737cb14cd7755eeba2686d8a6c2540396b40c7e5feb66a5824924c12ca668967d1ee584de95214657754e0976d186325cdac3a1fb8b07a3fbc7d9bf522938db8933e57d213c5a599102f8cd0b9c7a1c543afee1c7c8f2c76077ed8fdb7585ac6bf1a46d0534954fd78f11769d081a75806d43b76a3012bfd02e43ccc69a0a9f28cb2a500cab747e1873caa895d1cce6061f4552df62b55a2f9e355b890a8cfc28c433d34a2140c04b23578813588300b0ac99bdf7673b93a22267be8d15ae44b69827ebeaa73c92e9d4aa836a46598a6d57fad2d555208817ab2847ad340f9484763906a96f5e556e2618c69f02fa6dce03e7fa7047a9adbbac2846bb2371872445b72059a72d05dbdcaad4edf0301b8a8ad1e714a3a89e81275cb1fbcbfa5f907ec99b60aaf89937b04c5143864f34fa9832c0e1b014bfa2ba5367a6fedc04a29725de367fad140928070cc42a53599d212a754b816af917c96e2b69ffe3fd9df87474eaa5f4e3e087f48246ecf41b955c8d559823176621ae9eb2e3debfa9a285729d9e3667ebcbcbb1b1d4000d8229588447652c6199c201ac9c2aa50dc23cb700ec0750faf6e1b463992c19f4fe41191975218c8ca941ed2f02474c6bb6d542baefeed5f9cdbbe5a03a4283cc77ed4b5aa291b532bcaa8fb353b58a20873e53bfa2b17f2c6af50ed3d2bb1cddb9df83f3d54b14090f4c72a7a2e66d268f2b51c1b1c236fb10b12be10e731568c5eb0c5d773ad38ffd390d2511bec4971cb53b8f9127c5b52d13ce348df881a7728e4b058820f3627ac95bac11165ad4cdd690a4bbf9d34ed5c67b6c790cbed94165ad15270fb127d017814f543affe068f0c57c59e53929cd751a4d44269f879ab129b521ef3c5043827cfeba6c66ce494750ad1cae99d0c7536cc47af2766e59da51eaebfcbf2f5b2eeee4725fcd3094823d0800a850b74b949c0e87cde5b74fe9f17e0045b3182e81eb0b5dbc77f20a2e5c49343fb55361f1db50b74a7d69410c4187502e867f09a6e3b144a0f90ad13bf40f896ea536b7280d3b3daf32360415a26e1def945b340d940afe1c52e55c7d0f27394965f5637a8182fa78a11b9bfcf3ab52126f4057e90c596cb4d57e972c525e1f73cd00cf2cc547d6d31d758e59727f36f96de94ab1c5959ae1e88877646375ffa8c9c392067cb90723976e4bea255c13559b31ab9fc112868f8a1768a6e5dbbc3527a35bd74d863a7e4a010913e5de4db0e7b19134c4cff69faea67155ff470f7bb3b8e0eee2efb12f45e48b59e47435e5b07f48b29570c56668806b3a73658370aa6314a3f0909734b71a26e6d613c0a298c59aa057073b2de5cd7201491f5c1d750894cc552873c0150a7a099fa54bedaa30a64ae924cbaf36dd83ba05463721b8992f4847fb60ba0d42dcb38e09729cd46bb53f5ce1449ded65595874942e2cb2c41a788ca0fc3d4660aafa37cdf6dba923b9d178cebb1d84d6a435fe548c85eadafac0cb461e16f3b99099cdfed7aa7c4c6a985206d64798f4498c932911852fd38d0be7c7784937b5836e13bb955dc3a4fdefecc7e0a7f65987fe23b8361ae5fb1745681bdf8d57fc24fcde58d61acfad9576ef5309be7498dc0ea73dd145a3381fdefdf977cbbcf467e72754a75ed2944d8e6afb5b819b0e0ea5b449f09c24e53b4d07c46ea3c6238c7aa85abd7937c6cce0ab92b7d821b7dd8ead24e5c884b7f08b31fdc0e66d6bef240e1c400d4725d0d722bab720377deffb73a2e308cf3b8c9423ef9f1db748cdf6b9bfe0931e22fb2155afb4aa9ddfd6feb363c8addcc20fea3a457e01f57dbb27112234d5f6279032e3975b3a95ec7a11bcc72d9c83def81258b34901dbd297905d3b8c75ba1d65c09c780e8895e0d48fe5101fcf14c59314bbf980bf5fd4a5313e52d665ecf28548a54a2fc2d8f18c388d7d67d42a362effefd7ce936fbeceaaa7db556dde727c88a8e0b508b61220b19b57b14cc8ba1b63cbc092066ff950c3742a6ea937d821031f8ef4efcbb408029e3c676dc65afdd5766148588dd5afe486500f08cbda3380a2c23bfffad6db166e2090819321286e8d4d0ffce66d5f9d76d3c4cebd31a48b520b213530e86a3e6bccac65410c574c4862ac1778dd7b20d416d712fec3bef3482c8a82ff48c2af42ddf30be43a0e10bbb23e04df2fd6c2f79d6a410901d04a1e4441490e764bff478127f83f7f365f200f8ad2eeb7c47e62870a99021cea687e2bc3e54d2571ac5d79a6c7c8a28161367929c411b66f71aee395af1923c5e9cc822d2106e0e2956d1e48a4effd1845ab1734d07b78c65f0fca19ea402d7baad91faebeafe3fc7e716d09d1c13af1bb997adf212d5fe42d634cbc0534180f50a5cd99f09e53e8910b5c8f24d75cdf7815437296c46d7065d2ac7e91ce9041c135905ce17d05bfd8aef70887906834b6c77f6a4022556db500774770b25f35a87adec92d97725dc457110a77a64336b19b5013e8d91e0370cd5e575c3e34c9f54184ef65f09794a9d4778d8607a9452b7ba3e58675e4060ba406065ed4675a5b3c1e728c34cf1c3f9e026cda064ae2e81a1cf8cb873c68a15c0f66577073d9d11162a69d6eea012340ef3babda760733d77872988e473770ac133a7a8e11b61286a40e03941c40545153bac86ae88c58a0067185a586a95a267176d061462e1dad4fa01fdf78f0b6fca496136f855028f7f5045b08e65e65cb0066b35ac8f8b52f3b39c5f912b392199cb600de3cef78f9a2069a65a52b3b2b216a53fd8218e19f18f9bff709fc14d4edce1aab4fbca17e223ff40008d7ab14b43834082ee46ddd65c749210888cce5a47b7fd5a3770244a606d0a5f69126d6f16caeea32f2688a972a938d01842e5e18d95fc6fafc7a298ad5c869fd63420e343a6c8b5aa6a48f6db9438d3be312fbc2fc80ff24c7ee7d1c6e2b3f4f703b0c1a12ed5efd933ab1a3dbf0e4e6f534117d93bd198dabc95b73357c57b9bf6dc0a81906ceafc403337043a8d7d691b504db588213b4a37715e109f155b02fdb3c485b5eeca4381f8d82856a011f069851b21152ef78d3e9b1d965f451e141acc5c0bdf17e41a372307479ad01a2a14624073242a2453c14795be6a6a9f0caa87199ea8e52997b225bdd98d8f5dacb0a82e45c7b527bb671902c5c57a450eabf5a7a7859e2d0f51bfd7f67c7c36b8e9601e17abbe5b7db7fa77f670fe55948825e74e0494e9d5f8bac3a0b4d343af57d13523ad5dfce853db4d13d09ad0f53a86e50ffaba15ca766aab59eacdd25dab6da6f6a2c918f67b0bf12a232ee39158b7148269d69808ae3f6fb751edea0881f95ebc83c95b20d63c26b47ae2dbf4ea8b2cb08949b4405fc7572805066b524f893ba8712a18847e29033cf543668a823e33027d7cbec22f223df2fe21342e864c41707cea144903ed8e4522d9b773840aa77b001b4013bc85972d0e81b7718ecc7fdfd282bfb928c2a27f3f909bf10ebc57b37830949fdc321040a6c45de0cfb9c9b91e935b14c661b3d35a96d1c3a31bb3b021fa4716bf09bf756e9b377c062d785aa6d2e14a1686c6910e6e08854c516152c6ef4ad049e727699d181b52cd668a62c2853b56fb4491d6d8970230e7c3d184e5bcab6f4df5ef69b092b601d6df92c951d63e2586f96018021aee1c6d1ccd5e2a66bf00c0cbd3a3668c7ad4325d001e8689c756a41492ddb7012d001628b472563faabab3e3144043b15160e5d4b7dc4b60a37ded9d81a48ee2f0cb871e9b6bc782bbf7ad65be018c453ad315ae965efc825a9ec67b82e7d45b5e23c6311c321224dec1bf59dcbd9b6ed0fe1c4e0769ef4bf5a7820e4e089d33fbb254588e84a709dd46e04ee963fbbf328642649f157a44418ffbe7ddb642bfebb93425e2cd9c7f06e192ebcc307ee665d2371d3f946d44696cffd78a05f94224f502eefccaf5ca83c61e1e6c7036153e63f7912c57b985f6ffb1f5888638825f468fe321a9cbdf8b63051bfeb9399ba63827753d4ac945c8fde69f82bc436d8065a4e9ed7744980ae59f51d34890d4ef2bf8506c5b482be655ea46e8b2301476663da92c9e2b32d97c20887ca1daaf94dd525b77436b08779349df3835c006c2555056050d68376fa31095f956f523ecbfebb947b877f5a38b1a5e066a87cb1affd55d3328895dd89d83b2ff2ec585c31a30e8b3f3fe5e71a6511bcc33c74440b66f458fac598c98b8f26fac36f054ebf9ecbea218fecad7807bb55b76e1c37233431ac82348fab9cfe14a047571792e5ba02a289d63106a5c37ff35101597343defd179f255475fe80955360cd3dc67e46a704ccbb65842fcebf8de6a4477d30d66f47f7971060f0affc1d4e889c1191b112253671d0a461c5e01b55d5b405857540a67dfac402c9ecdf7300c64d5fe2a67fbcb8b3c9ca53e9cbf0a135a24c3f4050512157c4b8cc229ad976f2dc68e95c8fa3f87e3f8f33a96d276c3fc853a8051f979d9a3758fa3dcd97e166cb90e5bec6dac568335f955c371f159d12e1fe82540889c998384881da7f74f30d8d279e0b233b143b6aeb409e08abcd1d51906e3a18061538890bfc68c01d728be1d4522a26083301e17bfc9c81e8c1bc39293d3e4db7ebb9f783dbe3c99274a22ab012552fa819c28370f92d42dbf976dc07877201d95594a6c53af942653ca337b0cb9f738701d080d9e4d3d8034b0569baac0db3a22594737b601e0d129052f56f7f80ea58b211a3bd7e137700dfd80f933fe9e451c7598e3b0f09593cac6828c1f354b61e727dd091b1f6cd142b92e49bbc048f80c6d75e68aa35cb868411f8eb0bdc1ca7c9a3d8b19889fa20998890345cff1ea970d4bbd77661b0bcc36f486545bb0f80e12593b4b65d82d95a47d5c313a208fa566d71ba2b10423d7f15e505a2f944a3f9374eb51d076052680ddf266a56e6dad391177e5d0afbda5d8c7b0cc184df5cc4248decb4a11f2ffb4b67c86aa929c5228438a309d9fba006d1657407aba72e3bc9163218470b0af029a789d6ce5b520b5ec7c1af4d7f3008d5446b7fa1d3b1da185442c79c67e457021ae7ac1aeea19a8ae635f1f95ea80dfc6aef850060b91097fee07b42c0b12be30f034b899a78e848fe2ea6b3a748229f16e17443f8360ede1e338765445084101080a93654bb6f2b231bb4183e44f98a7c10374a6fa41c1d5bea07313380f1800b55b5e6c727149bcca8b6059372ab7ea2121bdac7f30c93951ba45758ac8a5c5f055b7e6c6c8953dbd8b91f68d320b009e7481bcd475418dbda328d98951c84a7e69e88230272e4efdad84ca416684829b8f5183bf7f094a1f66a0b8e33670a615e08b36969363111ae9238389a92e3b840d042779c4085566c3d0e355cb7b45c41b95017ad47f1a2bf0ad112904712cb9f27edd833867e3d70fb58a804487e01bfc5d6b04c3a31ac0239cc253e25d9b7a5fdd2818afda29e22c9aeed2cbf165f82c45e47f0e8cf6d39421e7a8a3331d7e38c8cc67fff2d454c2759d2c8ca5f10f31927e9879800496bce8354451f860b09ca1b27dbe8eb4dbc8fa6d7375aeeedbf3413a2b8e9caf5c038fa69e3b1391c550f64d7b82bbf452139662f1e3190901dcd290cb93d8b0941e146249afd1fe02c70aed7ce311e9877186ec8b098c2a3623b1170ff1670cd26be6ff60f020038192a269d0c7c914d671f186bc6c43708ec259b7563e8ff64cd873fc1122219d9ba475c4a57ba371a2b88c1e53f1a56c67219386495b78e44697fc647069f9ae77cd1c477646c40bcdab8494999e4bad03d1a7ff30cf2c9f709ded7b3fc72296110d7368cf5fa73aa32e99635b630b096d9dfaaabd1d530389e6e882aab4e5e57fa336fa5f51ea912333f11363b73bc663f3816d6bed99653f4b2b670ac3445fabe308e103cda4f283088272e065914a19602c7fd2493a3e2f0387f9fc327df7273099752f53be8c22d0dc9d597a023baf94ce1ffeab053cf7572c5e810a6a08dc0f1f3c0f4a8894ca042ec458023080de96330ac90c675abb377b26b6a37f234a065eea970665c00ed3c0a952047147e550da1f5b4cb2e57df982f194b29b1bb5f75380debb31d7943e4a08353e450ed6cbcc7b2016773f785896ba809afaef7b04265e448d7a08faadbae38cf55f578924657ee9e55923cf93c5a9b49012d2cd4136dfb591c49895af03a0e52c5f18f2c85acc78f82aaf88d403353d8c366c424392c5953ef9296beafcd6decff69d4325b43e39aab2d06a77df13468ed07de9280e337fee789a1b773f4bcf91131cea5c8406ba0c3657ec6d2d4dddba8b0a3d319b58d9dd14f6cfacdc0599aab566d5a11e89f7f9ced3f1fe0dd67132c7577529d2b25cc799affa2bc47a7c0d6955cc37f25f8edc434c560b955be6d4c60ed2c5fb145d5563369577b202a23d8e123a2f705d2e1f0fe4ab7eb460270aded95c35617ec49e479ca9315ebb4a52ce11aca5f3bb372b5e2463a6c00ff44c28d98a9aa1093d4eaddb6f917c7a40b756f2b5fe59d1951dbcc2d439096ae067f231efd5fb68b8dc664e2bcdfda2d05ca1a643a3ea4db370d7d8a66265ece03838a8b72c304e6512528208710cdb7e962a55a5e5bef18f93106640924758373b90c8c9ce15be9dea4d7b06daa4d4ab1b1865ea56fc0ba085451f4cc20390f49eaeceb3acbfe1cb42e32e1d1128b09ff16687b13ca7d84a69298ae4a06cd931979de429a7195e0fded90f84624bdc24e19a94b76c630b4093bec95daef98e8459c8a6e4e9eae940a425877d7029b88979adc9a3c02083330d2afe35d33c67edaaa0cddd1e837530c1e8aa54303e35ff5df49d8af16d655338a1afe47f1c655d7bb77a7d393063829dd3771136dd5fb2b5f6859f954912d4458b8be5f57caffd1b54d7c3eeb51391cb0059d9540b78a142e6a6c9d63d267b1a2e908f3f64ab6231a085a42133690e86fac3e2673529248a0b03a562859bf984860b0762c817e154b9519eb3734b161cf7b8d564573dc9b17517b781c86fc2597a6afcc9bee5dbcc8d4c80db4b0d4899bd300d06f6b73374c99f54b05e085819a95aeaa31d59e77e419d59615720f09f9abbe0ce590ae675984d3010d9280d01addd8daefbc2443b7ae0583dc25fb3e530b5a3fcfba4e6fac47c43264e980e87f82045107eed04fbb4f460d71daeeb0ff91e10343c6aaf18ac8ee0ee7d7ca98c85b284e68fbf69345ac41db1485c7d66eef3db4d817ecc54621b4a9bc7322abbc95220cfe36e14540eacb32827f4088216ae079ff105b455d21420b8a772cfe822fcfab40366572f3231d828302dc8c805dc176669bbb66b0caf5f19dc15e5bcf7c6e5fa55588215de1dbc40cb15b1022b4ae9f49a5b938c0d48d6d6dd280eaeda45b0bba3434bb96a7f78f470dc9fdfe72ea21c99f658d4b292dbed452bc640c2213d76635fb9d096853ce91000e83982b196eb3ffc0e806672d21d38a3d6943478968e500ed19c10e4078a6561d3f148a804253bd5a042961c175e3e863950cb6d0c37aff7a41fcf4c6cf063fabdce3cc954ee4d6fb79649e67e3a67f824204e61009e6e16c423e6dc4eb41cf751ba344dc494acd636786d92cec5184300b10a3cc8ac31ae538803bd29be77f1d8a75d513988725151d5a7fbe942fd2297a458e78f6d86275aed31802efcaa98d72537bb7d439e8312aa2344d8c9967bf84369861895c324337b93068e7b70ff5ba63c2cbdf13236857ef4e3f7ef7e5d7b29b8be38bce4a3cdfaaa57524e7544ebdb64dfd45e667ee62de58b3f7b2128016ae81ef8ce92e5b59de0a238e4981785774510f1e484a908fcd91d28a90580b75e56be21783a4fb220fe9ea4a3d82dfb5d5179ab55be4ca586b6af3198a46c443398babdef3373f0d353d948a5ca7b49a117d19a77b53f9dd970c8c74190c2d5a75fa4292c3b781de67f8ccefdd24b723b8764b33d63791d6f2d0f4afdd03d07bad2370e3e1b7ddfdd47f94a26d908c50d985def71d366f2118c4fae5a823a01b5d46e065ab0ec15a982976557d6aa9cbb746705d80793341fd2d42434f8ce9fa4af68c4f565791027ec393c7c88fc9b7b7e6db56032dae571aff788f03fed185da9b724e287060162e0e808d33c5f883afa6d84b45045c7209675999a860690f0ff196ee03ffb0120940e92a34342b08bf5be8485bb1f2390f427c30423c4a4f27875f4a71e84a9b067f13c7b7e8656c57f195ce326ffd5690a3fb969b41cac2614138ff42d81f3d3d692306c950779c2ce303da6d7b891dcf51e5944cc0bad32cd789a05dbe3fd8558f38d14bc23f4a5fc5ca002995e2516d467d978130b9e6bf540023f54cdda311f55717cff589c04cbb27ba7c845f18163150864eab0fb3dc9721fac87a62fe359426d1cc85730818ff7a2fd48f3e6264f51538df6e258642d533e28404957ba5d973d1af7265232e5f162e65049269922864b18b5d7f542f15749071e7cae22923942c9ea19c5bbdbc5b142eb43c0ebf953097b17c50ba24b39cc30de82e0f77488b40565a42ed558c2bd4df75fe259eba237f37779a4d09ddbb6efd0d15e43a1107a863c8148ab058a364039f9011394bbb07ca1bdee3a8195af8f9215fc7a2b929a2907c9f79e53f2c3d7b90d228fdad3ce235db5bad88bdf0c71334f1539b7224b9bfeb03583571d9b33a2806d0b57c7738bd4ce447fe76b09ba219363633e0a1b148eb51b5e2b61659ae4d1c4838055818eaa9382b7bc29760b7e7b364f69b000d8b3a701782e5a6aad969118c77cc49cf2a4ffb100875d986bf79b026cbb25da8a7f79420946df2b79fe759cd6e086a5f7842303afe38930c4feee59ad6236f423a274edc33cfa59105b95e61d1228a7862a74db42605d4b8b32947b032642ef27a311a752121a09e7ed50932b73a029f1f48dcff89adf2400951d4c2cbdd52d8666290d4778d31307cb362038da2536aab13a8ba6452345203537f4e906b9c956e6b19f0e9d0a9ef8ad13a2068619b05909b802fe8edc2b9875b206a39dfed4fb0de37c47abb36ff412fea3f7db1d45bb39589eda7c9f324805f7afc567d3750f2b4604041b512e828d31bb7e281eb99635d1bc9d706de3300944fddf67e31836ac963a5ef3803b08247aa45f6f39ef0e96f33e8c71741d8f9f68554328ee666de5e6418845027b09d168c13b7df33c01dee74bc5e44bb3a3fc55ba9294e0e2fce97616cbe1f1607e152d0ae244ff797cd20b90cab2950a07e02acb379d3372a2dfb4e64b55b4dc05111ab1c3c0191b356ef2f700a353f0a3af742a10325c4b1a0f7bcef2bceef0ab3eb914f7ce825e06e6a10ddca2c2a8a79ac4261f3c1b02e5e5b112415d5d319b67e6894f3ab4af3f742d92ca0a68b841c7297674d1832fd87db4ff40be2e186e7ebbcc8b725c63daf4d21b8c08d7d5b3b5c7cbaf00e1e39588f72e961fbc2532956146c53e323a4ae07f86bfea3cf3b00c10f7ce67b26bd7f73525dce38dfe1916947de21a91647000cd6fabbfa6d06bbbcf7610cade3dedee81ffab548ac7b79d1ee5ccdedaae5f89f1d0b307a1790b9ac16cda3e5aeb124316b8078ed4b4959c0df91215a4963a8272b85025e64b19ab44f7313d54cdaf0f7bc15317b7acadf6ab8c42d4f891b73acf562f2b71ce1673c5bcd3528683dcbc6be9ddb5dcd2f48887c01425ed3edd15e3fa3dce8de52be6eabbae2fadb12a48ef3dfdf91412d93d841c6aacdd32a4a0f56422f2816d4b5ba600dff5cce279622007c99271a20b99aec092f18bdcde9b4635a8d0341e100524ef040d29a5954bc83ee91c50ea24e14fcad3c6d5aabf7e74ecd2bd987adf6af0e5904d48c9302778028c826cae35d1067ad5f2ef28012682b1a385ea316d50a28f8fe506ad939d4537b8f96b8686859889a1873f80cad973a406d1813bf8de440595f26ce289e363fdb457826fe9d411b3e6785919bb0fc7bd1d4e5a3c8de7e6425e7ab523bbc6680ba5fc0ae07571e48696664e4b012c0cd96947246e94c6157b9dc278c73dc0ffafe0d7af97ac9c9c04c26433dbb55319d6793c435d4d1d8fb814457d37e17426cd41041ca24c11dede68a0600f73f422717b2b36d31b771c6d0aeebdf7540f43c5d20c85e11dd7e275b54cb6aee8e0849994f6a719d2380421a0b093386277cd083b2551d32754f09449f5e283f113ee0c0d1e9616b549ca6d05dc8516e4f15726ecb41939ad47ac7521bc3b28f5bc2bb39f68364235c20794ceab6cf566f62cc57f479c3eee5ed9ecdeeb085de40161ca0c16059f782ab44755e5329d201e5f1cd6a00c5dcc81751bfbd10219551e0c3d7fcfce1a713a15c1cd2946e0db186f599186bb1bb086fb0e99381db08e86a980453a6b79374a7b13bf861bd7ba71213d2ea63e3a955ed3ccd80d78453b422d2c64c0252ebe92ab68ab4168c86abba67d8ac2785c4b28fd0578d97d8ad4c1bbd9c9788dd4243d9521b6406c40c74903a48a2076f5205d65b0c537cc0b5028b098c420282fc0327ebf08bf3abbad20dd513b9ea55fcd146b2b5e4f6664a214bac74db12f9444bca71c34c98a284288eeb5453c9496cbeea66f6e8a619e8c15a4fafa2aa749cdd3f8d60ef1fa9ce17d29591563184ee1ecdb847bfe4fbad9b5a52d95c92d5253743cc5c19abbd0a8f7ed77764c586ed70828f394839897789115bf0a4e531367b5bea06bed005d81599b851dfba8963249c870572e5e7b307ea751f0394abde6a4d24cfab16c9ecbd10eeb3a25a3a9b7f370fc7fa5a0be59572c6df76e1966a49a59c94aa793b55383312292781c9d9b96e92eaf1bfa6f0badbc74e95e6f00bbb31d08a7bec17d156366ddb1d234acca2e2b7a5626eefac667c1ddcd60c263037861aa9afd10a5ab0b14d7f6fc45fd24d3aad8a39762f538e4ef3b0319428379d794ad63582ec1c3721f1ffeffe3c80419d8388e71928c22c71ee72a811d786d7a64642b6cccb6f4d65fcb006fff1f19c399cea7c4f44ba42a5ad4407ecb2343eecc19f4c6fc88e4e41840601080bca7dc02429f7429b7d0ed2d925a3dfe6bf97eeff2ff79fbd298fdea515c4ef7ef5b2e6a39c44d0c27d7580c614927b9d952b94a9d21c86bc0c9148af5f179eed8e71e49566110c7201865fa2937ca2a7595788b18be0bf566d84efd7a9d1922e7b52f81821c9bef3eb09c13773db0d732d7dba483195ddb8a6382689e3c65c2f9958e3a92759de68105f1b3d052fc7506feedce23388e2946e4da7365d7423229f2069f08a271cdbba2c8835187faf0bacabe74ab286c8dccccc0ec7d10e21fcfea4d59b01635b1f591945e15e3dfbcebc6f95c74bf4fc4c6055598c04c422446c31724f684832886d56363e2576b05c4b81e44f6207ddc6b9a36fccf5b70831dd3a139fa23a6a6835b4601875152b94363399cfbec2427bd89895d9ef83491821d28c1bef918365adf16d2a0ce99b4891d1ba7bc990f1e410d3fabaeec36f2c6650366f00d82e9add282bcec5f1846735f61337c8f82993e88d2d65248d978b48ae6f8a6dbed488978a0d3d5a893d6f25e5b306d5c219c4b0c4a1829b7ef39d44af18e04a7d0ede0f18a86095db7335369e6c967e0366cfe98230cc3a7b48c4a6ac15b2fe6f2a03feab37336734a4fdbac656cd44f4a960b9e495f1aa0271565254d06da2b6ad802b7018b06faea5df2d6b4c726332ef81fd88f011e18cdaf1f920b718835acc309dcf4d54e8df1d7e0ede6de09cf93776c61d46c44f420518a3aabacc92f4f141c010fc2e0d3e070d71a69ccbf634f863413fffaf00e9081d8f2fcd44dd1c3c094506f081671134a8f78501159bcb98cf5d1866b518e50d66e3de6c7951faffa491b015f29bffc6f92f1b86af4e64f5e5b7132da688b9d2f7aa7f124d7222416ff63cff479e61b7308f8a5b9430f6e0969172e68dec8b27550b08c148c0983c400e8b64c06cd7504786e573c7b2e19e7fe4ce8b8adbcc72adc6997d68ee25e080f4439decb4ccb29968bc056cfff866a5d664f6342a4c2e5b6522d0f7336f4e0d3b9a2a2304ec50cc1e650be93bd3e5ff1b7f6a99e1ae67b2a08e487e4d2e5de7c9fc2b8065d07302e005c61d5c02bcd30e8908c0ec723f1fe919f5bbfeaa18b91262e7758f9fb5646b6038a6774701dd88185bc5be6a6d9421c4ecb5271f3d27425449ed029986f77bafa82fd3adba49c7b8cd8273e1b949ea60c6d2befec0f358925ef6bd10abc170a522dd0f896584e35e2fc72c6681ca14052107423546f056edd80864beb94263c0f5bb32af73ceaa37351fae9338541bd01e12714aabc0e1038ed4fdc39e3926b5334876ebc8aadeedf82d7907e184b530e1c962087c6d11a2faa1b25119bbe6a7340118933d18289f7295ec219859e4cc157847ad7dc64cd6b9421d563d986946130e94591f9c4775056f2717097d0f2765466aeb25955f3f0f921e3df2141f9d2ff200fead1c4c40f553b34ef7e50df304bb43fa1d9f34b360854f5974ee86adac517d2f9d8bda7de9f5360eb7c533cf2645afc3c578dd20b8cc7436d2b19e61f0c5e1129760d0f06e47b3f1b2c6bfbe85d995c8af27d27b440396bd7062547526c22828b8e3ca4b74340dc2e79a4154dd9e9fb022959291d76f9ac586703754be873eea11485d78cfeae5d066dad3f36faabe9898d013e666558d659effe1b6eb2a2b682696ffb3b7b2031fd63143f682cca41c4022a3168cd3eb1f1a7dd40023a7c842706600134857cd38f0e07cbfdd6c76c77ded28ce07579ec8ab86bdfca30377eedb6b03f9031f9ae20189de0b4f774c106563f508399a7fd9db20689ae98780d449ced6bd4b54d8646c4b41d12858574742058141a83593c3843dcabe380020f40c55a904e95d4c862638da11bd08b5e015f7ca227ec04dad5792ed0b17125bef7061eb428967ea08380c4ae8e72b4c5a0e223f88098190f857bfacc3d2a022042fb964933b9a0ccc414076e5843a3e9215274ee63cad3add5bc57e8df8416b4efb204939f2e4078df1660592f5bfc2c3452121b22d3b725f8fcccaf4dbc12fd4f7c655260855619d8fdb98869fa67d886b381302954106ebf33a7eea13b88f483e7d416eb8fe25cc74c01d176a94a22c8b03db6b53e88ce7db1adf71fb2b7c275bc409d1a375272e8e4dcffe4557775c5bbb8d18e9e81eab6dd1d4e53349a4c7cfa5e66c4cd51e67de6ec4d3a06107b2c73ce621fd9ed24b262521f11c2494448f5eef379c59f893fab2224af0561af26bdb798fdaa858f2559443695f8e37af83d9b9185e87c9fc8c8950782ea8bfd71c04c5b5ec175c7a9ffb00b966fb32c708fa7e54c4e43343d1d1c05e5840012660af394c4831885f798cc96ce274c49b6fb68d90e04136d81ab931efef408f57f0a3b94a21be5530b11377c0439f1ed77c0217d42c91ae224ee978b078ce76ac3d89268254ec0102e68f1dc343ce6f23e7899cce03500ee6670737e5fbec3586e9c9f1eeddbe50ab0b18e8c25c29070ddf3a8c26257f0327f0810ccd876cbefa4946d6f7600efddde8113c384de0490182a0d2ba372b18028eaf2931ace53947ead62526a119f89099b89c54996f6a8e650d6e9141858aa6743d54eeffc5a053099f54680ca6da8f0df308af07f513d412964ca42e8bdfedededbb979a6c76c8192fac9a2eb0296e887acd4423947b2985dbfedc4f40f2d6d6a6389f99563c50417750e539ac508f2151052bbcea8959afa50957d975818120d0cba89e5b6e7edc89007a8456736e458842da64950e7af44de06f62237e2553027fd04dfa197ef72d3d5f091479d3325719f3f3c32f4facf9d142684f9ce70605fab2d1b4621ad641bf41e6e2f32c7d8187b704de8760a5a473eeca87e85a681d6afa557d85eb6fed67b8dcdac4d88d0d723a7737a3619ffb50684dea63f5baac940a8c322d73eda41402d33da0bf1d4bb373edd4cf53cf06eeb218bde8bbd31e2f282a2c2abb2efb00085418d349be2973fc4f4071d35da463013897d9ef9b28d62069d7de994644a05a0d72ec5d52dfc334486d4a57e5d220b31d195d9790563e0a8563f317fa0719f2510e2ccc92debcf8c6ad6fc4facb9a191b35284f44eb7728407e22934644ccb696bcd8438a1d8ed87db6d29d9feef5a8ea0719f3dc0d606c5f203122d87f9239f538e0b118ac45fc64b39a42cc79f18b27412451934899442a6a636e92ac988ead9c62b2709a4179356cba22ef16a092d11b57483557a5acf08f00af0bda06f19f5e0b919a2f88e4f178768d6834b71acce6ef6ba445fa7e81d6b7b30fb8dab0d3e3592ef26f805a5a86cdc10b307fdf611dcf8057de2c10b29ff8f21be99feff39f3b02a8f3c40978aaf434a251ae96bc0fc3f1d6688a02dd868f61e224f0dbcbc5995e3e0d0b8c15c959976995b8de6d1b70a53fb8bb125e8d1a71ca2ae56ecf87bc060d4058fd4108defc90465e4ae873d776c4894b57175726f37084e62995e8a52ac00600cfce543ab1bd698344057bbeef2b332a0eed7606c720187df6561bc6d7d6e923c9d4f6bfad87f7991e80a978ca4ca1889c48cbba285d8b16157274abfa24e6af8a2f36e759fce628db7a07d62e97a6a4d697ea732f5f75e2fae9e98f1f51230d1dfc0e5e3c1c083a2df63438948b9960feca9f888a9061331ae223e63959fa04de20f688865baeb8b45d0210b14043c028d676eed30ea20dd4281d48dd0b4c8e17c1ada7f0232b0bb7fa9845e6de1da5e3355987df2df2cd3ca753697c8b277f1aca291031501871727f334d2324e36306633ad646f2e811f1f488ee74d0c05c966c843175b272f0b17f66ea55e26a0d9162d4ec10983b4cf3c3124de927b7c335980251a78e84db76f1f8e3167fd9845f3774a4be0fd0ae6d6ebb13acaeab223c852833f81da03964b34c2a6b731ebd3e6ad67333789f543f75323fcada27c1fe30de22180caa9c170557321fcec2b7a38a1374ebaa68d56ef80c7c94f2d34c98d7a308c7fb732dc20a298778b0071fdda79c66afb132adf73f56786191fd66237dd683e7fee6f8234b08d4b7cf549519d647ce7f499f21eb33b0a6a5286eec1d6a04380d1ffec7823317e92bf4f61306b16c6dc0670d8f88e20315677991f153a851c092d9900c55938d7c647e2ef318d410bbc5b18b47c4fec138861decacd687ecfa9f9fedac202081aa69dd8d75d7612421c6009b6daf5fb3d2ceffe1c91019929e2d5344b87cf03d75bb18a8f0847dce15d9e5c074567d594c46dfccddfeb7224cffcfe04d3c012fc842480fedb3d1c9611e22ea31f7f6de30b7d162f9ef7a468ec160354188b256bf4b1ba3d72209d125602d9da5e20e98a30bbb6c90f7c22179f545b5441448573517522f1e27581b7182b0fce9f92a13f6a2dacc3167b319dc17347fa5ab6b0bda8f425ad1aaf3e87adb0b9aee7854b9bf703dd5c93bb3a8377ed6d7e108a6ae533557e3256a911fd11fd117ecacbafe185e49ee6867ee42e9b74774a44aea952c5e8d316faff2f60de6479cb9472f23dc17338dc845d24a3fde9794ee5f0b788f87f5316d4555b5e6e5e8136e3ca9820d2f897a0857931567224bee7a7442461488368607b9007ca5fee343f774c175cd32aa685e91a8ff6614dc66a3bda9941f210903d04cbb2360c19bac903b36c2753549dab1374c919692369e5307c2929698bc7ee63155297eb3263c44e66a9bc400ee585e28feb2460d3b49d207f193e9bab0ef17b31eaa5fbecfd0de2de332371774fb950401f28bce3e5c6bd0fd27b7e3dcda52006b703749958b029dccd8f5828c3c1e66ddd45c42880545a893c389714712cb3116106a4aa9f240af71acf35c39216196dc3f76cfd777e93dc3f8715791c366ebfb120436f4e3668bc7dc23e953af0cdf8ee9b7adda844f63813f7f556bd64ec27c35190f8e5764bfe178e61e04b4ba9945dfea4ab6076c77254e59bf1a9bbc27feb21e0a48f279077cd00e774dda5a999a19243b841f9637eb017c9ef8c85e256aa2921e236896f5746425e382115965e6203566d03948f274d7d76bf3ccefa8ad62829ed7ae0d414c67c7e3ca43ba03cac1dc1f1ced07fc44f3d8920d68d7753817c26a4d0014a2abcd45cea05ca9bca8d1a91c5ba37ed642ba166eda9df1148034e7a225ada65fdaeee573559f2e572703c2c176140db13afa2d7405f3d4437f1c58c031bfcc2147b565878b4d0bccb2cafe21cb9063c95ea287d9cbfb317631cb02e4f86b592d045fa54fbb9df350fa521217a81be9b9c10b0e027e3a26f519938cbe34579ae948ce9870b001a1eb7081a649d455fbf2dbd112bc034e9c09b9e90ce354a59b73ed69e2d50abd7671cc0aa8a707385173083be763547013681d44a584fbddeb0df08db914bdcbb2f589972fbc6e9d0a530931e9bd004568c5510388977f9e096ff58bfeec8f18652d66f8ba98289e36dc81c9068ba6f77815e670400e6b1ce54bc13b9eeb9d03a73de66aa883cbb9daba785efa997daabe7572cb4d74fd771fffbe1ba792d638cdbdd1ed256cdfd1c445dc36c15dcf34362f0c636377a9def1d87a01b2d57ed68d74b1a5063861f4b100fcbe0ee07a31328cd4c5df08947de676285a802bade3547c5651305c42f6933f0b51be3c6e5df07769fc4ca11944cd7d1dfbf1efce16410852ce92d4e6ddff41a38d85b131460cff71d6fbd7487696335482b45320ec82f87eaddb7ca61d0f353f4469b35e4829d115470cf1620ffdc1eb464ea1380c18ca73d757ff4e9e3d49bfebb66921de6dd581d1743c5ef42a5ea4d966317d021d331241b50b9f990e71e8aa8464bd3daabc6905db2068f6c02c65156f02ab432feafdaf964bce44826ce2f0f9620648443d7f0b4f755ca5ec7cb8bf0a8a518499ac1b8f2b97034ba67cb89de283e7c6424efe413c5d4ff275e04cb9dd00535f449418d33d40dc17cb79dbba4e49defb114822e9203207a2eeb972be9e1b684ca533e2ee67e6e7f1270ea0c3406e7b7edb4aaddfde267e8f6d15a0b791de9de625bb2dd8642b2be5f785bd7dacabe56a8bab646fb73863be7f03f299cbfad082bda0f01baccaa07d59fdd061483054e0dc71902944b2983d3939a4d7e1ee3516b7dfe602cc0bb2517bb3d893f3bc98cf07237ed3fefcb5d98f6b9960e7f6d56cddeb0fc63343c25cdff1ba6bb20d9119ea2dff622abe849f69b7d732d9b10ab087e02cd35f19a529bf45bd8d8375b4fdc54ee90a2f44832e096b097bdc44053d404946219a9c23cddac00e938f598dd8ef299457bb1965dbc1b0fb44f0ae48cbff1e2795c0b579b03c963d4275863732052e5d5b3c2c91a21dee22bcf4f12ce3363adf75c374d82bbcaebe57b430e61c878726eb7e53a1eade2512fc29b05da41f8741f1cdcde3f048c069de78cf5de3f190d4ea8b30e516884e057188df59dc11bf63b04acc3545490afb1749e77807acb3d0a9114adee9525a5bc8943ef46cd346227c36f5d90c951893f55748a490661f874fec04c3b7c1a014719148d6021f179bf1728ed0a4d7d535207e3a62aac816ea579f97ff68347558ac2f81fb1bdb41b3460bc58f8d62c54b911b8fc89280d1ef1fd25fb04c2bf9ef2d2212325ebbbb911e9d387ee5ba731ebb6397ffd8131d0e8221112abb21a4ca4c33df9f3d468f1e6e57467ab36b0c6141d68bc6eb08f7c482d80c73882a8e78c3c0673af378838c70418a5301e78aa741e607edf74354130d62d2c446b845b100bf064ec3838dccabbb714fc67f2be82b12dbdb16b12a00bf85e00e593bdccf07a664fa93581a16056d66a5a1c698002bee9609cd959b14c6c18f72d57fe050e1e938b3d3055a65e50d0d0365d3d0301de3ef85d823cedccb5366c837f530569be0cac0af173cf86dc34f096f45e59b1ca43c704f27a369f2c22619e449eb27da37fcbd9a79b9d3bcfc6fccd50488ca979c1e800eeaebd1e0fc6125790442adf85b091923925d3c41042854610ece29fad8a37f77a637acdf57a6def204acf6b87296981993bd3e20b7f81d56d4b088e42b01ca7f239c97050c7deb9c17b5b584cb11d10738b229a9141c9a0ffe9d9af59159d20e5417b473f54726d503b2bf3de7eeb0f66cb510da9739ad6a90d4792216e69eac134929a2b1b91f9ec0bd8f9e79bff68497ba49f48ce53100c965209fb83748805a4d9cbc69129601b9b0c42a06bab44d7c35f120d528712f366ff0561a3b7c9e8270be0edc8304434a369eaffacfd49efac86625cacaadf8d58a2cf5ee1bfca77850bd80761f13e2e5bf8454690f907f1844cb2734db9ca745817c7d77241eb8f1becf239479226d81d8803bc4aef906192987838306e54d4c016e74873b4ca30062aece2fbdc2233e46c1b13ccb710297f7c6adc092a50d4a7ff097d6b18385a4a117ca9d433b69727b18f0a79431ecddd7f629e47fec335666d827a1a5d5a02aea4a8d1ee408077f137c6b0b5cc431fb124c8e882a3f2316745cbed861e78b7dac8d8a5c17563f1a7b86b532bc8aca41f83d9828fc180e976f9ab867c473b0bbcea90b27bb89affa6ef5ecf0dd361e3a6e05515b286181b46a122f49e5c719af706b1efcbab8020caf2cbeefab513b38722342c032fdbed564267e77ee45930001249133222c74971faff32da4b45d1237dbb98dfd40e80b75a15ef352e11640a12affdc24e5210a95aa968fd712c5b168b31ff36c71f8da982d8e6559a68b1cc055eda27c152f43b26a9f21926cdb7757f658c13f4f8f37e4db071d3d31d464a283f6440fa2b69394e135f3189aabb173343d0b9a898b83169fcc6bfe342dac4c14087b34a88dda832682a6e4c9a7938ec01ab0e245759387d23ba459f5dbabe06eae5319f5d56580f30c1bc2f8bf77cb304b02019ab806f7aefb3842cc2cbc0a7a715faf8c60845325b0d34c7ac85709e1d7fbbb15b07c07d671c1ada8c1fe8c25413b4e23e0f0ba4017fa487630bed1712eb3f8387f7016cbcbe4708b30144fe0f14baea4eb8062e9cf217d6a08a78743e501daf6bcc5b077976d6e09f2769a21c9bc2bb0d0c1a269ea2ccea4580ba6fe8f8f4f39ee4f1ba6eb075fce9fd554e019135117366d66312af489c8c7105b0ea4b2765dd0de4588206c061583061b1bf1e880618edf2b50c694ff4d9117b2226dd94bb27399063118f8c031736e1852d2a036485afad2ffb985beffcb20ccac116d8ffd25b2aa1a17f9f20804f5570b8424be3c3b1ccb16a5d6177f00475b64a7606df72cbdc09d2c28099204e0144fec0073ded51840943c3ac7be0f43b3c657de6acd5034807c2b1b685f4d30432bfd708f85845a181a4bbefb866937468f94c4599e36f1585a32acde0edf592030b12954bcd997f170415352f1923b52445ce595008ba80440c499edd750711ef417f9d9c1f2c6cc005785b6effc61d9aa8e399c7cfcafeb1a71e17c028f28e58f728a2e089a38c5563a0988c52a32bb4f517a200d0699cd380e97656ee934751f60e175b7390502a651fed58928d1eb0084d221a5896a65ce7e3a8d0b72f8b3441a5eaa279e350c468b08fba751525251459a23a93a8330740cce2d60ab88c6a4c15c3d698851d72fbea3675f67eacc19874e9b70d86e96a64f2f4c06876cac68bac14abf103e15809a52f244f7fe36f2b236d9c738386f44a8744c2ab4ab7bbe18054a1ed995e1fb298b97be114c12bd5e6a2d7022024d1446510a0f3e0979551d8f27b30fe56b86e0822d89509aa11c1129cf9ef7f0fc3bc1c1d98a7a8308e4c177795b41730bac3c3c32342dbfd8f715b6187a30af6ac842835a8448731ba355fb1229fc84121af87784a3a7e182f8622afea2a51671293d17177c9ee452cf293692e4413fca22c86b8a8e3c3d650e8cee41a5aac829b4b4557e026902862b4ef9a386ca963b3bae6003002cddf1eec7cecd88f8befc2018d0e43db9afbd7a5dcaa1be16f5cc7ed89a83d80f0a538d04dbc344681f0809a986e16643a8ff065a60de6f527d472b122d644bc26335a70b854e457ddc776f74b2874b2dc2741c9a2f6d2f071b8a22c499c26094e1bb3cb7aef3ecbfec0b37dba5b5cd2c2b8f8ec4d671c99ec40b6b85630672d432760d369a320ee8225ba9aa05ef62f6bad62fdd7e0cbbb59b51ae3bef44b2a439072360ee8074d7f057f0c4dcfe93fbb4ea5a6180c8b83dd5a8bccb59c6a3219a66491b414f59649f3b9d594cec7f7993196c74df0a287093c7045a23e09cd8974d8dcfd999eff3c44325aedaa257d7b5a8451c715ea3901b731e1bd2544a8ebb6cc3eb9daedae4049d5e76a20de0540c87cc8dbba37a7f11ed44b4ee692b55fb7c027a593db3c9616d06bde44af4081baf6889e31a2e1ca3b4d42bfcef13f45e1c25c4d57b8673ac2f3c5cbf0b0130eeed87c738f6f777cd1bd0694d8aab9c5aab4b08702354ccd97805060a2a88cad91d1a7533a43ed8254c5d48da9eedf1590d573d2252928149cfc8dc9bfc9f8b1e2517c0f4472389d09947347678aa5e354470e72fe5a87e4773d29b7bf87017ce31f6739ce7f87f8f6e7c5d0a5004bc8b5b82fce8b7743752d7d44fbcbbb89188bd35a605b0c3cd12aa8d77b523f4473afebcd8344dc4c2ef0d609f08b5497ceddcd572bc4dc0e1f40f300af37cc5eb6c5d1043d7cedfc41ba26fa31e3988e5d93fdac83ec3dd9b0c3fc0512c8997d200c6b781a1f9fd299826dd4fbefdefe6cd10ce46da543d2fffb8bbaf5432dd4f335eaa7e0182cab0aa47eb6bcc9f8c7313933e27b91ab6d43bb443ab7337df15d70a2afca0b8e7441152bd1aac10817680f83c3df089524dcbcd9e813e9f39bc896838d906bb692937f1daf310858241ee68db00a0cdd2349d33b64623415a96a31a1d666c4858f3f45dafabcbc55a4bc09eb7ab7a1926243d8b9a95678b06dadb6ee4c83867315465560c4c5391663e14cd6a654137f6a319acfbd03c1fd515db79db71d46365b498fea5fc0c13185775bd18800a711cefc63fb0f3eb55b1f7355e16a0c655d89d3139925b945375122d34e4c462a22885e77d32f17a445c638a64ecf54e4463f6331ecf6586eb982c8bb378d09baadb8ca48421a66d5de8d8b8e8781ded37520a91f5bdef90302defbea7827fd9b2ac06e041bd5884623d2b74e5197d8802e6663a829fadc88af6cf1bde316bb0ba46cf8a7c6dc999f29686a114f2fb294cd484c5791ecc879e4a5fe3ebbc7567a60872c8503cd302a204c742306bd6797ec442eabbc618577d9186eed1db662e9a83cbca5c579c1136ea1ee5dcae82737dd32f663c87baa31ec916d0bb4c98dbc5007c8fef90569e4e7f0dce2b2ba501b811a60e99347a43f704a74a324fb202e5f829e9c5de8fb7824fa56070141574ff04b51b05079b09a5e8c2337a2b78769f99947e45db12dcb7ba227559e1f001c123dcf5891b43ee492d691e22a7a487a64876a9b04457604574d29cdccec2c9b05c95109df1738a6022da66f291d692e31a375f817d82e14703488c8658b501b28faf9bb1ec92ea8929b6798c3b8daf4c596f8df40bf8e76244e42531c4d749cc117915bcd581f912376c7007f93492fc053a94d2177a1b11e7abdef49872524a2aba0795574706b655f85cc1a443f3fa5057c8acf2d9aa8dee6d7768206c48b2977f79c78447266b21f2de6d1a650dbb211f271b8b38c953323a44e7eabcb92408b5df9e4e0c76f04eebdb23bbb704b69243a600fbd6622bde277ca34af4e3d2a38f96370f9e7a111f1e75cded1849af7263c97ffa766bbcf26b4bbfd7cc9ea980c82dec016c259bf06b94e69a814521c46c6714664b68acc1bfa184ecd054022aa711b9c7c43c58adabaae7ad72ee083ecfc93ac378175c7317f718280fbc2724dc5a17e3de2a6859487913997101c7cb7e8f27b625577584a880b7eede40c0622bcf5e3d7175c0892f01a0d19407160ac6fd56891bae9b43409091e6b454bccce65cf6a2db5fafe60ff15b51206d24cce8a825abf617bc54ea17f27a07133bbf389b7943df79c4afe72c03143240ba9a969e372de7f6aa2fe78b265a43eef38b3e198132e71c9a34e3486e9b7e68f22c2d7c2e45014df99ef29cfcf9cf5618f6f285eae8e019995c8b11aa6d1d6a77f3ca1a12cf1d9f2c43da84590d248e4cb7e8fa54c2a419f620447bcd916505649031bbdac74a23cf1064df8c13ea174bfcd4f3047fee71d60e1b931515da45e05a78dbbed0cb1c20cc844986c8347b02e4e9bc8ac4e570c0c7e54a688b26d253dd8e2042b0aa878695e64002b1c34581060162559836613981b03ae0872b8f8e568ffd85d1d7754a59bffd17945783d0e99568d3e8b9c8b9857cb16c221be89838e10208c2dabf835bf7404ffd161bf18990dee104aea3eeb24eafe27aa54df5a92bffccb412eb9eb59f508aba02c58cd9df8711207f9e94f88da2142f35befc05185cf3fe866753d0b89c9d5f7a898f3be434b9d41f9018deb102a8e83b69a85ae460ca9a478768ed48c663c3d0fcca09aa8be39df1b68efd402269cc8ebf8aebc544d7a55dd1309fc2027a81f0a8f810f4cde55a3d7a80831fd2ce0ad382f2ae1b3ba4e34b92354fbb1596781057ed101666d4cf3bb286b12db03851faa532ce70e3d0381fcc26b7f15a944c782b933d9f441925aeb8a45d363b3458cf10d2294fc79e300fe8c567a49af1e354c54cc1d458276806c4de712d06be579298f6d2e1cf1f78aecb2b4438a261e89cd4b738fcada508204f946abea4058ca5bfb69067dd3f62ab337d042fdb984b05d8613276f77359888fbdda2a2bb4b8490e1e5e75ea1d652076dab36d5a2cbe05f5e5b4a8959912573c49e6785b169f6a1698e908658c9b740e1a30d321a13aed1b17b7b95d87d296277ec8f1d9d48c7b7426156ba71b42cc94a7b01e8e607806ea4da819ae13963d6c724ef00216ca635f3e78e2bac43c0903b33b262b4d79ccfbade7dd993f45b5326059ff3bfe2c7b996ade35ce258e5b69b62a5d6820ff2ea13a48eb342324f44dde6048da848696d4d6c3fe0945e461743aafaae78e11e725df94f04a56622533c9ea51f87c3124dbb9dccbacf90cda66ac4d90606e7bdb1f2309310bca8ee10df7170ed5828b58102c8e13996e77e1680a5ca051bd4b95751fd61e734f1bf7f2a718399637756a195875f6beacbbc54e258744fa7955c40e6da0c581f5e3c27301b30788d6d3dfc11bdfd10bbf136539394dd456abb0d3603200057e01a11814cbc02534b810ea6c1f4fa2c9ccdd1eb2a883fb18dc388e4929039bd98275bb640fae04eac897d2a522fa35987a1b5424b8d070d68c0ad3e972a8fe7a6b6466c43bfe7992515b77a1bc4d2f6afdf377d6412ffce7cf0a5a7253660a78a4d66409d7c7ade8b250d7c21765d72f8e2fb0c47c71cdb2566088147ca3768bce16bb95ed315972dcefae743f95c01958be05ff1ab82256b5f654895d3e24cf3cd6de97dffa54d159b624ea6fe4389d8e31256d36fe3ef786fc3ce0190637853fa8ff7954f47748caa68598778c8ca4133faf19bd8cb0256a654888104000fa0386dfc1b484c58d77c3117ca27c1895f94119675083e71182671ec5ab25b9c8254a3be3b125ec438a98d879d7d72c1538b61dd0d4561c9046ff29020b610d0d8d37c3c611e313b50bb0a5708873bfbb1dc0bc15424e8621f26bceb56196754b5c6ea3072ae1fca87d1efdcad55bee1364a6ccfc9d05e27dcaaeabc666d7611a807a9c2935d36d7052f627a4ce4e529e4e501afd6deb4757d50ff3a4fc2d34d6e9c5ab49f285f27ff8d150d2063d21bae8ce198456c55252489acb894e150bea9d20440bce52ea337e4db067d4d120a049d226ad1028966c289dc68efb005c77853f16c429ade6970b8bc97c66e268d9c03155915902654b1a2d648f8cd25d66623b6928349c594b91b0b6558f01f6dbf065d1900012e82c5a9fa7065e6443295c0e03fa2c3794dd146485348cef0bb7280ed137c46b84752f0fbc5a5b0346bc5a1aa17bdb2e153bf456a36a4d2468f9c06c13a13ff59113f5dca84865ee7faccca300ab7541270653b55a7bc149443bdbe7f177c4ec6133fd29166201db962f8450778334c5cff4a5b85e616ebe28f6a68800fc9f5f95fd2b5e21cffc7236960eae1bcb57260d8ef918684934158f94397d3ea8f3b2c35922a641c600d15aa348ad7d2c6a5f65e02291e1536d9554e31a99d65ffc1c71ef366f3c6cb3066b92f921ef9e2c83c40b8265a42fbeb8fc4ee2d16f425d2a55df48ec290ee49823d6ed425c5fae38abb85fd8c49fd3adc396a4c00d8ac53af1eeac9689e76dff50da612cb4fbbc37add637b56e3ef9d680df7c2481141301772013a766e6f0275a528c60e13206ce3f3c75c7d10eee4b59502f5e687ae506fff0479e8c1f3cf29adebe4152abfb5dd8013b611eb09b5642a3bef6bfd56f240fb721becbe449b38e12e39811c2c6dc5ab2d9d791435df55353d115039a390c71dbbf8e4daff9b3ca2511116ff46054d8aa77039357535ceb52ee0adc1f69c158e67e5af94f48afc8d99cbc37a633619d4345c1de69da709d73ecc664c6241adb9aa9b0e817a358815e3c8c7e4678b7909c4e72c4d2994cf9e96a5ff7cb9143b49afce5ebea16d2d63fdcdbf414f09ae1269e7d722bc9c01a97cc908e40fa3c5e4c878e1e6e8835cfa54ae4d20971640646ecca52813acd0c02fb38b6b3ad5977fd51078cc4d60f9f71234850a233030ba2894577e86f2afc2a29d70b8042c0787b76efe38bc6e183014e8aac93c3782f058b61163f83c239a2e9144fd6f7eebc9c05aa3e0bd79d6ea5ec93c7a6f359d6de7e921734ef340d8d2e3902ea1a32d67329def1c5af2f7e0ed52e4a3e3b4fc3c51dd2afe25852578235b59ae17b31352771f674e4a8f14943888d5e497299a993781d0e9551a20469f499416c31601fa718a255250d34fce227c2f8a4f6880af41ff41780a8e04fc2571c241f248df5bb6b553c4818be3cc11547af2de4016480a2de358a4c7ad409861754fc1c57ca2619c600256147eb24c27723042ffeaec387e32f6fee127115678a38c55cb148ce676fcee052fba933ac12fac51d0d2ebf9f0f1ad38b00fa9ee1158efa1363ea31c51159f394fb3754bfbd63bdd7cf8bca17f55016cccebb619c80f7ab6d897e9d112e21eec5db9b9107803549797a49e9462986fc9fbacd7593331e79411200d7638ec837b9261e492e4691ff66587def8cc5dc78e53734d37dbe6266eb42bc40bbbb762d7cd613ad4f601e4d6646e10ff1e51531e96cd326d2531d673a30c9a93c844d5cc3dc78e68003d292583631ad652bcd897fb3316335476ebfe049cc46237eedc4049e5adfcdc5470454add988b83bc54d171b0ab740959e9f53cb108d847e0a5b707312008d24aac83b45f6a83f40444298e7aed3d75a109b914beee9622010332c295069a6ff2a20e72ca08f4466803a180d3cadbb5abfdcd9307f905044d60fb680f474d31b0c905da48c9d085e1c7c71b8991ea17a513bf835a7d7108b654210adbb87ea9f3757ac81fbb9feddb3868dc74e1bd644b78e6ceb69e23bdecb0d6cd8b77d029868ad5faef5997f1c7890c74c23596b665ce95d34918ce5e80001589e9b3b9876e38eb8a8db40cf59dc49220d939beb33e896fcc9a3d5ad97daf8148fd42ee88dbe164e014494c35552ba2c06100be5208e02b0b62b446e9f11bc98b175c65c95baa9e7de291dbdd516485ae41442ec48eee62fd94cfbecf65563f1fbf12e4a2bab73037a6b50ec220e3d428c07fa4be985697266ab7c9b5973ff30dba6da2e4e6ff9aaa198f80e88b05ab392eb8147e5af032b65a2506cc6852fc5b136a157e279c1ed36119beada064fc8c2e468b142355b7032ca0e38003e992251b37f1530ea5498ad73f2c9ecb61c329b89069baa6d6c01fdce80ff0f3675f8859843aa64341b84915bd82c1820c8bdcf05cb0cecefa78c4897d995bd55a1b48996aab00e5ad22aff6f38abba87dbb2c50c810a79d2e54d6cba3ae31947ebfc8d2cc10ba2b2a5fe2ac2e6c4b4559408179ceba1e87b5052144702fdf8fa84e637138a58f8432566d57b73f9eb60cb97148e69657203a9b3bfd99ac66f3dd5201e773874ccaa9f21dcdd550cc74bea5f3ffc887f762187264203c8aa5a5a16fd500387e83f93a04dab8e08cbb7f07fadce71b47ff6af764944ffa842d9d17438cdbbf5f654c1952cc538f103abde45712cee631b19bb143dc1baeb6cce1ca0b209a8f88a74a9dc5f3e792d9e98e5a85e77b77b62a7218e2f882aea6c6081ffc66e4d6192ea98ba3e421e9febf8b2267902fdc25090c521b0bdf1ab267af7fcd2d8f98c1a686e01888cb5d15f477e1290d5499c39654c88d1575806724c1d189017de211881e262c1ef6a93cf87c592c828c76946dd6f635ca39154ccc93bb34c70f864ee2c60b435d1365b3ebd19eabdec4e472352de1695bf528265285bccba1dcf72a2476da5a9ab5cd60772fb5cf0424e040141abac6220b962a264671400c8fae42512a3aa8c8a3937e532c7463301788746ce4fa7f60d818db3bc6416ef1481ae4bb0361fa291621fe710b22f8b344706a73d3be36f218c3ccd33b460d514ff38c9aa11dfdc75133ffe21d6f5749a51bad57af3e954cdb7e3e11168e216d2a30c1d6b7adb6dffec0316fc4e5bdf256afeba92c5582cd3037d7e60a8eee2cafa8c53c44c6cd48e03f11540668b387b93fde138063deccc08c38c702798ab6c8694696ac25f15923d7a570ed068d178c25dd141e28773a3bed34c53a656ac9d2af97b73cb0a1c12027d3f8bf7b680aa70902428bffbc21893f5cc618928b93667430addf6dbae2737b0b3605b70e0d4feb2868b2b35353fd07883b67ca2c38462225208eb324f7f90a5153afadbb76be72823ac5fb187fe52ef73af289fffc6c36630366e7ed2db2d36464acf33251cc159bbf14df4209291347671f68055b35d8e0312ffe280918974f5c55eeee144113d54644330a20af2ffca62e437dcf1a82ac326fdeb0b0ab77d2c6552fd8c76ee9d593318117dca70fb26ae6a7d699f0eacde636109be45f1c38fe625933ef972402831f08cf80a9798c2c36ff8e2cc025c7d9d06dcd95379ac518ae341c947ff522b538bdcc955c11dcad54c3bdffdee8f680d82923ed9c49a2e96f084f4904cd51c3526fd280bb6a5be5be2cd51abec5e40cd8bd80c91fcc214d3e907ad354fdf8393ea5d12df8b0bf690bcb571c24f649a5ff71a36c9ca5d4b0d903c9f4de9f13ed0ef9a3959e0fc6cf3472ec624015951273c2296e279170697c411f1236dbbc372cb670b545eac8bc715834924a98d9bec8d4575d262d452c695ddd7b5eff9c0a3b10bff8194de5294303ede0caa8f755b85b817a3ab2439715bcc97376b65fab2251162e31b4ba4a4801ce797ea828d8458b54cf25501b478e366128eb1cb89903a0bbb520e8cfe87407aae7770fa225ba385c6709dace73aae016ad62ec82b546392daf8cc15128f81296ed0ca593e38c0ab6264a6cf961d3b2768dd7bc1e1b7d3dab3d616f10955c0e434bb4c093a58b0ae6f287c2f6309654f45a5c016fe99708620406f31403289cf9ac41707d759944a6ca85f93d7edce7528e6e6a6a27a5094c55dd4615bc62cb7326df69efdc2b407b2e665b69139606135899c1bd501cc8f69a8c5617f758405eaa90653da791a7afb78665e2463d1ae482e26a28f791e612e729a6c51e5c6971561343f3e4ab7abbc083af2726248f090a701fc9f4f96614b5d28450c826cebbdf3838109671e73d2d34829593605740c7b5811ba96559516e2b9bfc6fa2353d9ae2c71ede3ccb8232b69ae6a5e1e849364426fde83a22c66cc54245cc2d625875783ae033602ed6df50dd077604d317fd1d75b18f0c7ae95bb50231b8ebd190ba6b4558ebc28309c2cc5974d44cbfa2c65146aa2dd8570c4a33d567ddc843d3cca4fdeb436ceefb65c06e3d8193de5977689b7b3eb1138354a1a87ae6b814157e1a07138472cfaaf2751576d6fb0d2ff8fe03d93dfa73011cdda3798bcf402a881dbc1e9f8404a0dc49b4b72dca72d20ee2de21125aa8f321b3f247b98618b4a3215ac2134770ebb7b110121783739c706132c374a528d0578f9b7dd89f0f557f20f2f9d4ddfab1b2a21c550603198b7ffb0cebf81f19200fc24b3bb5fe4ec2fafd480e475f7bfc2c3dbd6863662dd9d316b6d0820c1c0ae120c7770ac1eb133d01d4dd446046326cca229a19fdd368cad79462220432dcaf93eb5ca49b4dd33ad9166f73bf92cf8dd265f7cc45a86deb44bad1a9f32806d46fa7a15cf91590612cd741e34f1bec525b692e6d2a078a13dba7ef16104cbf660ddd2a71f302936c03d690af636d3f6e6dacf097a036e97730af9554bf7c0cf03f176b9db581283ecccc40da9dd153df5494e3a71ef45be35c0a104e8b4b0f1befd4cd0eafa43f3bf59f83f58e947103b21cdbdf1865fc99540238ce481e1a57532a717f80e748dd4036a3d74076fdf3676a7b2374e615b5a444c5293fe35b5df1a8357f38b256ebc45e97552d7133678347cb603e899eb7d1a9bed6b7736f409e6400f8f6b08cf7ddf9bbaa8c2d032274c834d1be20b2bafbafe4a85c5e4dad1fc8c6cc3bea5c30f91ad131466b3527c30ea54c791766dd2a7b7a220bffba16be875744ad2c9e2dea44ce5958932c344a6d1fb5600ee127ca282f21e387c31e088e8b923635ed04b4abd1210a9ba2262e2c6d799e7d32e772b778e8692a9068a9b0c6a12e3a69f2bc08d1dcc0c13d64bf8d1aa63be43b143d6435d00dfd7199a913b4c1ccd1052464f3536f6711ddf8898735a0fd54328936bb27f5c8dadb692b68b900f0a0a4bd914a8d21e43b26f381f2c68f9814dc6ccdb9d760badba2bcba629edf8648f6d159da9a6b8609b498bf265f5035efebb8901c455a4bd8730f115fa97aa0f65bc9d4de8c89c79ef5a4831ddfd1291041b19341d35610f7ee381e53d1f3e372bc20ca02b6787f34fec48b1defc8f2e9868ffa9a3dd9fb34b4b528b32018da8c0ba6d2c1fab9863cb24f84df8a2e7a113be72abb4a162fda45909c8e827b884a573c1838458d396669ddb86f49a0b2b7dd6db94756cce918587a3adcb1ba105501d7ddad53ca22a8e3c066e3b9ef16a13b059a9e656af085345eff591d46f52a5d30983a3bf4eb5f297a3e6f24111002f7940b58d7cf21c83a311a9938d0e640878423836c28a7e91a96e3378f7e8320b589580e25c2a6da7ca0114bee7adf9b093f8374084e9c7ebba3bd50cb478b2473d9411e7d10ccc00140a0fa0f03e9d3c5d712da77263a5ae076eb9d094c66035592bbf9587f320fcd54b94485bf9b7aba8e4ebb09cd5654dbf81b8639d5b2f40fc7c130feb5dd83a4239a6f154d9b63c7dfff81c0b7d8b50bb8164c860c40b08a35f7eb1bb6be408051b86b1e41d3fd74862e7f45b81545b76922762fd13dcfaaeddd784c3654d62b08d3aacb2c972f92c22811dd569d3298e67b228565b8b81d4b6b2a3bf3452ea5efe657f68224559ad47c2f296a1970961caba6adc37261298dc7e8c2ce7187665326de29936dfab1c4ea378b7f9e58e251a0aba8e4407b94bf67b847d2eef0c5cc0edb44952144580a7b3ead524818831c8dbda0aa213ebdede7b7641e21a80419484f5ac89e680473884b4253c027403d98bd0b17707b37a2375f7da7b3afcfe6ee45ac2341b2920d8e11c073cc1f407679561e66cd28b5488e55abc9835361b623c89b26ddf4865d5df2d03854d0f0320e1ac5f2e047a5a8304018c7bbd15ff57ee1db2927c20226fb2a3675a762b7bc563aa62ee48365bbfc548308a5dffc788950b4cc81c2b675a59ecce63e31e82ac0cb176e2f57a159aabcf85cf1b2046065d0090769f68bb401a82972e3dc2be3f045cd2c2a5c629a869e96d79a95c6f33a6d09dc67d5dc83dcb2aada9e5d2a77b3a694f4be525422e5779f65923c64148ff1f6c27bf7afb61ede50daa40237772456b2dbfefd5e3a7b197976662b6cad069c275cdfddfbb31979323678c5b7ac98f684c637bd24643aface639dcf5c92bf18f2e307ba9ff272f9e62fe49cd0c3bd7c1d10096a03f6361eba992138d320c91a4bd89443c802df6309def351bb414fbf95a6391e8bf1f6756ead198239dfb6b4680586742892662c5219cd0b78fb61a39fbdeffb0b2c06fb87d7d9a0e9ad451ec45e03549626648110bd0767c891804a541c4c04c01468d3a85c10571b347961e0ba99b339f34d89f1e350adb7b41f2e86ff01c4e5ee2568288ea360fda56372c36fe81f2374f659f36dc296cd0d29b86d93ff3100c7ddb8128ea39b8e9d953eefd6d4435246602ae7ab9fadbef7a91ca1d11f5ad34306463e0d89a66ecfdf113b04a35045c9febae9a2580773a7fec7d8fccf26891ca063bee6ec67ac5c115b0012b32778a11c1f2d55b84dc263c4dafa65938ec0f4e0868488afab0f8772704726d48fa7349913cd8fb108e929d292dcaa5f9e2db710fd077adc6b45249aac00cae69d20dc9b36d5d89776f46a46b8b1722cfc4b320275e4a7f1c7453b24236865130d4888573e21beee9672fe85fce114342e4b7f8906f9449f0935c010d31c1fdb37e1d6489c9acf6a2b0d111f41448036a12f3cc6718a37969a8d0da43784b1e6eec3bc5660009d19e8f0b5d45dc165f9769b424126a9422a31282b4362c43632e4cdef74f3eb893e380521e7fb69fd7111172b884258679fca50a5b907c643e1fd420bf4698ffb55910343a098ff4f1e30b55f854836e59f976e76fed70b467da60eed6c4a7339134e609aa06d63cb6b764be879bfb7dc0b2757ee4c2bd5a598d32856946ded1e9eac77efb232d4c33c3480ebba6371c50d7b5858194dfc1d42d7ad397a4cf2b60bf8fb8d0b56fbbfac4e3b5207d97edcf3b869e617bf60159bea82ff73f7d3effd85cb95d2730169e100f25f22ff5d1a7fbb95874fc1bf0b1a2b2bc0ffbebc6b2eb7dd0eeb804183aab2575a6fd8f786729c53cff2e2de96704b9dede048fc4c970d8c15e8e3d46eb778fca614449f8400f8fed183343944947cb8053735161786fcea0a00dde6b5174d5467f449dd688ff1bed2bf85366eb8db290d3ad48a657d5e4393a8df39e1305510d0eb3010b3ab570117853b5a5234ef901b7a7597be25eac4cc552a37f5852c84c501c94d77544514192667c098ef5a0ddcbea5a2ff90fafc56fe189524eb489783d1642c3f99abda2e155f3d50a9e3760d1717d2d623c649e78984571a62fd8dbfe42d59cad904dff214f9f843ad23fecfc52069442206d07b8a1464d1602bb7a73238d311b88cec4e1df909b06621ca3753aa317a8089c0718303eead63e82c3aeb9304df29ec4b2059cf8541847f2cadab4e3fd020c88c8140ec746247b92ec76fbc1ac836eb1f745143a1d5f9932c4ba49a100a652af5f407c21a3c08a49fac5143dc8455c423bac1cf7ba9093be351a66609b4bef6901c05f1cf7704c0e514b7a0dbb527ac8d41963cd29a0a7d742f316f49a8d472f31cec085317d86dd67e8cb221ee7f79b37c155c0cd4ba34d12b193eec66c0cf0b03799bc0c34d3e5a73587cf59e8214d71ab5989aa91e49caab598a823cdc286a7def23d5d679d04c6fc89dbd059f3c46f325148b7339eee2ad491e99af8db80b4385647c0ea2c36ebbc647449e635b7a787724e3c3a2c2db5d7947ad0185ec26dcf88e87916c34ad1267de5235c32089e2d6efd6571789ef1f92b2e87be1cc611c09b1e2348c77291a20042422ef107c97be5f4dce66eb6f06cf026425f817c0f3c4ad28163037442cba66afff10aa5381d3108416d821354d4f466bdd1e30a630aa8d3854af099acef431937e008f9769477b6d91d41d713cafff16fd272edac03202def6712b349902bdc2b5855d01cb1131facd0f8cce95a960c8981ac3d5795c267932766ad7fe5622b0b5dbc0fa81e4bac6ba76b106885d661c1e3661f1342e49a907cdca3845aa301eb147c193cd554ee6784942605c0211ae85f6896761e0c61fe59e76ea30b2da35f47e59316a6af60af8f7bbaf374972c4b4290468953320cd63a160aa84d697c33e48b33adb6c8131cb21a70707c5f75f93d8fe09ca04eb3dc99c26013265d425e7e076b9bfbf174e41d527f4ca9c45a64e22f3de4d636f3527acc5356d0ebbe13cb4322c1c1a8ae97c2ec08e0411f0b162a2f69da5acd7c0fe0660abc3ae9f2a52461d735282c5b22dab4573b7c8f9d08f2a423b1a77fca7255f4dfdb86fc77010825cbfda36383955e987f6206889fa978fc90acc914975366f380638c524cbe99fa1ac17a1524ef8edd0c9b8028d9bce37c2488e2cbef9c25fb08ca5620721a1d83ea1e496db3106e67b557ff675220b96102bfa8cafbd7a6c73305a2f50cb77eb6fe987fd26065440a3e1a8c0fe3ea67835cd8e5dbd2448256f3a964dfe69bcb936c7ee00e09771cf005b8a284d77dbd8f8ba6f67dfd765713fdf9415a87d8b5613dae04c518d6440deac9b26374e96fd2e6bd4d4178a34514204014154615127f2a85d536d745d0a472b4a2ea6273958d9c46ef7654ef726676856c83038a5ec3d2cb155cd31317dd7ca14a3350252be20cb3f72e5017886ac3190c40711b356f0b05d6486dde3464d2f8f63d4909924869d21187ffb9324191a16b3f14d3daac2e0effe3b5d386246161e7cb9d200d999a2d00496167a247df5c32d26a81b4a0899dceed1e9f30090519d209543145a4af9a18d9f8590ea47321c077e01ccb094ccd5156b5d199d2157d5f0a773dc65b5679c474c7662ee22114a980795b4f729b8bebe3df8deefa2af2ab10cad6808a211901c1be42c09f98843381601812f0ab7ad629dca49baac7f5c6aaaa88461d9d60e1a886b50549886fd793bf51097500869bce7321d6bce008369c2b4152fb72ea0a8cb0b241e53413c66b8feeceaf34349b22a47014d46e4e7398b2f9bf6e227435bdb19b3ef3c4b262374607217cf2868a0632f6927e7e2d69cda2de0e1d0ca8af503f1ec955df1cc052901f62e3f40cee2164e0cd6a7002f93ddedca28fd402db3ae53b34506aca2dca7c9a19ad3aa4a4695d7b0aac5bef77ec27cb444c5fd2adbef208d3927d72a6acc7b56f7fca4c5cf6d119cf0ec4272dd5b05c9f7de412302c169a7f57d9c05e2e2c84b28faa56182b10e6687d16a8d7b859a9c52be33c02ef4169168e74743c9be8b1d5e2ed27b12b989363749d2526b7735fa804f2ecd3ecb433f818f48b5a19de59ed1df9d152a3bbf61487df273db909a2a2b4b0acea3340f48c191d4e873bf6d4b5e660affbdafffc12f499a837acfc2deece5b0a9ff92326b94c94ecc663b8380bd4034eff1f3c5eb849c94b9f8b7c9f2c46c59ae2e81dee6d777c37cdf5382d71ee41fb867aaea3a51a723df53ba898e174b377b3c082201ae3c5588759ccdd8dc073620cb480cf3cc21b0730355e19f4b5e84aa7427d5c34ea40d692cd270ba9f702d0e0ad770425392f3b37fd878f328d55fc6a71cc9db494c529c209dab03394c6d5a607c70acaf9aba867726a06cc5f37a8371f9bb7984402179cb145433eaa843fd6154374dbf4e4e510e6c462d4bc259862cc4a246072c386dc96874600b2bb803a286b6fca953765f806c9c8c3355098cfd54b779379c617efcbf2e1526815077420060e50d7eef2d69b3520f6c66e2878f35c87387569c57a860c1f333f252775584be1e667c46fd80d1e2a2cd026b6ea06cc185e2ccafcd1d131b6455e54ab07d9d1524ddeb1d71ec328c30a9de644c8399268940e2639801151a64f331d6745e0bf0e07fe03293c494ebc977d79a5476c657a71408dc8c6536158b992f8921eb8f428db0be28bbc4f632bc06ed6a5b1f318750db83aaa157481ba13689e1fd5dc26645532bb2e9a72f733d552eb6fe2a8e7a986692390940de9918ef67ba18373302743f64ba8c6d452100aba66a4ce46811c7d838eed9d3d153e81a981ef9410043a39bb2d54a58a9c91f73ac29cf918f58296bbc8a43f36db4ae574aa1246ce03590e58220b91d47365195b0fa6fdf9d3bdfbaa4456bda04a7adac5dead2db3b40a5dbb8dcc5429862e4f0749f408a223bada3aba8b0cd0896220031598b26808e905a0cf6ab110ece45d9c2b845b45fd87e22017fa59c315579f9dd1fc8f41b7bcaa516f10dbcd56026c7fd51fcc82f131ca6b52dd81f80f18dfb068f95490645e31814b80fcd958b58846b24045a28b8acb1f7501980e84ad9033a357e64d874e48294047b02e53b62171729742238eb621e369646338cfe704b8a9b8fb0f515adb82f4b18760d15f8bb01199579bc2b38dba657cdd7e9339b0bc563d9e4f0d71a009c33d86895e5b7ec02d8ea8e4767dd6d5fb16b6d3e002af8c527bb1ffb2028d90ed67a6031d8b96cf2f486f9c01b9436c2e75cff37df03fb09a586673a2dd5c668f3254f3aad7d3770ace7af1e70523a90ec1bf197bc541ed5639c694c9860e8aff72f0a11d311b478e08abc27e2645a8bd39518078c0bdd71dc62a6ba87465ef94014ea81d61b3d796b4760d21378082e07a04b54ad15cf20a73c4f1ef6a68d3fe2e38e96d43ca7892a766ac55132c6ad9148abae6feec5e48da173eb571e320a377e95b6799ef6626c198657ed9a7d7574349fbbfb0e01eeeee7bf67288e4e4b44993a633f49594f1ba3e49ea36d2c511f0dd0b020acde358079a1853423fd3f4d6da88d0209602b0651d6065c792feb757943d5028ef6f5ac0f60f7bee0bdb4d5758162618ada840c90faa9f5c4f777797f000f5e2a286e5c4611c54cc23cbbfd517c1b9b4faed4f0b826c057377bd99212918ab9ae86c179882080a11a6064a9d1a34c85682b1a8f6f8d0e272fc721698a8996ac5eaf9c0995730ba307849c89fd4fdcf2eade26d7b85d3ec9dd2da27d48dc2e3246f37d19faed70cf3bf7cf3bcae0ad71dc6a9be86548189b2727534f22b999101669243a9aad03258669bf8a386eff4f97f20871e2287715f5aad9f11875f8e57629b7361447281389da657262b04ec8c6a9a7fc4c10f859b8b935318dcd5939d1957f864c8de26d657aafc36e24ddbd1817d9cc197f2edd60aac1532194dd1b1e51e697b549ab04dcad1c47ce43953ce9faa70211c32e9c35fcaf8f3618981834311ae435c715eeff38be153dd2757e2047644d360cad12619fe7d048a746a435612be2229af7b1010c0cb556fc41592d42fe39c82cf46b6478f36e99fa0b040645cec9e55a438d12312b903ad33629b993c61493adc8695000bf9225e9aa81a58a027b4507dbea87637c5fba00b38a0bdbd5cc450d05a5cdd5ffb11bb0b909b3fb6cc17de687746125b4135c61ed4ce11ca7aa022df29f17a0a64335bae5863cbddeed4970ec57c4692db1c8e162cb7493623de22ee10b3f851242a1a0eef84d38e372466559f762661900dddddceec7eedbca5564317937e942dad861ba75bd1d9bfe40b7ad56e094f988f8cdb772baad9ec0ed783dac4b3a353e5618eb829625885a59975eb7c0b8bc3fae7fcde732f5c99fc52024ca046316efd2218f583caad5cc1f8b3cdd089a0f5952f908ffd5156b48b8a5d5927674b8ba77566222a6d9783a9641ad5e3a73bb31119efcfe9b7c10d91d46e9a634be94422b7f5a1ae578d341dec5dd5bacdfdf3474ef9e35aeed8b02899885e79ab878bd97ab3503bb5f2ddb6f4a92f522662aa7fe95e34f2e6cf8d67d704b3de45d577160771c8d45ad6dee9b39623b220b2b30efcba24bf731c72d6a1233d9e5a6ff551d7256db83b43eb45b66fd8f6ee0922190b7ea257cd4e917b9b3901ef2eae58a61902f0d4f3207a975bcad8cc096d12598ea8b62a107a20de7e2e71b38c81318c305132e840a4de46576cfa7fabea804e7455a41cbd2cc69d9a4b5ca3405ded86322cb280844fef293182ecbf52d2ccf29b145e2337f9e0ed4f5a9afd9a351aa66afceafb45835cd6c425e6aa43f8de0f59155ce9478ee68293128c9ff18b5cc8d6cd539ead9e1865c1342f84050a24a7f6201d74995f5d466fd9ca491e8b6a5da971e50c0ab073812b777db9e2f2cc682f65dc6a3dde327482cfa1aafd339efcca7052c34fb5cc90d915607f69500718b50e46e12741709a7c2f2a80f099f08554ce5a9d926cfab9f760335aeef61fddacb33479aedd8f52a4fc24c55b2f70ab149ae52c8cb4cd9585e6565e0986c1f22c8ec1451110f5715301ec64292284b10e53ca611c7d4f5cd6d89fcf130dc1cfc4863119edb348dd771d146445c88eecf91974fbc4479c7413c5410dacbf2aebf20e89cec82cbc2011e59ac4221cc102beb3c8572a387f67b699a76438ba807caccbd0ae8afe746db78eb9ad34493141fd5bfd7599b42e570ffdf67a5dd65d26da0f5549fef5a2a21332b788754886638767436f7d96cc48c3f3377a868fee4dd9266af556e10297615654d5e18cca05e5b6763aebea8bbe47d75a1463f7f1fdf96e7fbba4d8cfedf5d0a971fabf3798d0f8374b16439e5b699c96bb67ba349800448b9262166560b3f394f2448e0d15b7bc1c80db944a8dc869d9244934b844a6b919b6eb5f128c950b0b73ca83c5e83c55dfde36abcf7e577e45468394f70117268858fffde401292feef198f83575b78ab8d0cb26f4efde67f488d612fd75747c371c4345678c105d3def3e0d7658b11d4dec5e0e66e079897ad2c43339245277bf8dbfae985d81eab97a54b794286a19d9dd5bef4b6417f2e45f151d4e7839936c505e80a01dc3415c4ff0dd74a555f682a94f8ea960fc822b2953fa402a26d992cd7105fda0b6f031e83186607a978c00576c277a603f6651a94d71c3dc09797ffe2d5731634b077fb4b80f25898bd6f710093fa22d4dd5ad749826877a4834135828b533c107c63cb22a81ca604083c5e520021b5b642f17fc0952cdc33a984ff6e06d1e55859c4fbfafe437f2f95893a2cf36f9771960ea383c63a4b1ad0861e53457e5c2f1770ee376b456cdac67e8b4d8bc3135d39528c310b685d0619aefcce9d611bc8d61f5aa2f578731840b1d9a209e3d624d482500295745788bbdc051267bc7fe2f6d9d768fac780460bf5c2733afff46188f7ead6dd885d353b8f338f822939ac1f75338d0a9b45251bf1fe0bebf8d8b16c85909873522fd56f162b7cfb6c6d3c035ebc02e067455207b46a4145bbf90008e1e3e68c83f16240af45eff706394be119e266bf78a19c5d8403aab18a4d6e1fe2985c04dfa1bc3c9e0ca40b6d477e15a21384bfe80cbf146eb9c9c7c43d0995234a989f9db6f2ad742832f7efd2461433c3619c3255d859f0b802668484e5cc1622e7d9b937ac7436c8fcb4b5ad80e2f823f210235b119da97312b1a7a7c30ba3f6b9bd39a8cfae5d6d5f8b539b6c7d107f33388dbb9768e30d9b1bf24487269134ba656be249883b4b7ff7f4dbb049e2dd0273f2fff1c47791a6294d3e7528f5647a642ba1068cc694d0c4216e84d83d9c2534aecd2bda3384a0c93fe2652a6396365835c70a9247e48afa1eb91c0fcb91c1733090fc04b6ab922b68d0acb597a99f246df7f8b3fcac65c1aa39a8f6f6cf55125f49cbfb0ac143ac8535d674c013a22826d32b189ef51eb5517ae80d9a08ce93b8b2b09a1b4798dc4e2b5a82e022a0a850312b56362dd1815128b6bcf94d247dd216a21aab0af7bc75b91602598d6869f1d8ea42c91d404a85acbc0cb7facd72725d73d4bc6e2048f1c31378018efb6d5e6de7e1cf231b2f6ea94fecccae38c6e31b1c7f7125e4f8b6c0329c095a97ba4d9e6b7ee01278b198d1c3d442df05bc5aae1e0e9da02277f8b8105ee4c69fed50409b95c7d14da8163e8a55309f6bb9d2ac8d8c4cfa679b0c397ef40f71b2a6666be60685f7151b21d4ff55ca1632c7354a6b7079916d7a861dede143a882d770ed17c766ec68387dbc6fddf0091ac87e30bb84f0835f885b3241f31af14fb55fc87523962136710013523a9b2a743b0030bc86aa39235da7111d05e3f44cb8ee7ba1c6becc9dcf67c96e24f9ee07931472d0b3a6ee40e1d34e6664fc941981167b984582e0a1f7843064705a7d7dbabcb1958641ef4a3abd2c527d34e5aa166282d2d3b65f356edff5d73b2e54d7a18609db8d822ff3c59d837b15f2232e9f228a32a64d7aa09e43e6b1b6798346bd5bd4deb2029fdc28f650571e6ced6b74c233485364c32a3c692f90b18214448c22651e2830af2430027f62dfbb38c18a0a2d8baf19846f51475c09eadadb3ad6cfaeb46f84a4272e341667b4a905c58236e51394c0c46b42ce699486263dfbc4c1456f0e693fc24ca5728476074f28d9b3e31e7ddc28df6a10d450d7127cc991105026fbdd42dd4fd03a951bed7540cf1ef809d5a2ed4b9275d5e07145f81effd78f08550f3a01f7174d3ad42ca57f1d3a0aba89c59c65d08f824e3d240226a545de2aa0e36de494000c941de7b759c7072dc477fb394242e611b642191893bd4963c8802d2d9b7c1dd174a9b94e22f34dabb31896a2bb9bbb18fdf4de4eb97455b387da5468473265abfd7f3164a11a1b7860c67a389a634da9dbebfbfad3816808b1c82715aacaa34fa4c78c6996d33a0cdf735140adc35b04cfe85342cda05500caca683263256ff79e1c54cadb45513c7019ece762fbecafcb035cdafbfe2b9f4a7e7425efe4ca77821cd967317658803afbc4271d8066f7e7b18e9222c56ea503cf240eea8af86c76c68245f0ec6887e7adfc40ef1eb0fca18abde6deac0a2d5ce2ef2ccef0ba2cd7542448fd308487c4f0e2089fce42185d56b7f8cc627dfd27473ce63355df338c40c7625e81d6c5f0d66ff895d8d453313f9d68911309d377786e5b7009de40034066da78d9af7a60a4338e7dbbc0a32c87f3f90202cd6a3d670913e7be35b3a76d16c234a0d88908f3b3f9d2330ce63fe792525cd37fe55c5a03076f217fb278d9bfa096c625a6f57ea517445c173bc52bd1479f4649a5929dc11ae5a3175e350921c557f58c7a414891f043530ffb876d9e86df7f7bfbc1e03fce3c6061bf7ecaaa1a2d9042a4bea5afab84b7b4d29afc63a963bb48eba71a2fb40f3af01415fb82b5c0f686210f2e6db14c4c7709957e465faa938f8b82756608abd756483fed1f5e47e126671b902c6a53eda70165c47bee02e6c66b0f4fb13cfa8522418f009910ac3d89084beac4a12401f7200bf58d22f3bfa1214c5b5b5b458038757b07311a34398a7c4f7b6442cb043851a17c4d14245df219a37bc220b19a797648f7a6558a40bbfda4d410b315b5da10e0cb673314605d1521d0157b858f0ca3b2f88d11d52af78391b04aa3d70a38a2adc6af69d3af04e56fea1cfa127e5c81209fbc9b1fbb54778b36ae88405b7a730d80c1215a37a0af1942ad9f3bd2f7e52e86ca5db130db0c1d97d2904917b07b6e8e2f8ec06a28d9e4ea7730af4fed6b66c49e1c95171b153469e6e4b707f19ad03cfbe596c633553ce87b64ac976c56988b4f2123093d005260f076c63f4da6ab81cc21ee2a7588d6c51de6ee0b0754105c1dd5f6f4b70049a50b6480d387aaaa99fefddf940b066b2216e22fe4cd1a3fdf60cb592df6c75374a5b5177ecb2d10a22fc8646f51167df000f4f8d91b4f3602a23a35e562b868545622b8ca064fe2623edd1e39cd029640417261b1c77d672a1c16661dc8e7782b88be79e082634dae58a01ec4d53ff6941e2c5db21aa124b8b7c23673886981ce0d12cdfc6d65618cf95630399b594498f675522402e4356c677f3065023c4ba2a772fe9c3717d6614d925cdd58253111ab393ebdc021cd2f6657a13bc6ee4b47287623717a28e5dba7420737fde9b05c530245417718854ede3072b6d692fd6085691a97fdc062ae3f82622a1ab331c5df0531f48747c435d6a1a2c60ee4fe28ec275046cff3d0f6d2c4b8b5285457f9b4daf321282ed5be34f41b86266700ba24eef7093bb80e3e0983d64449a120ef8a582170314092b5c95f1b9e77f297a554eb6f81d47d88eb035a1e45cbd0adb4b064c7dc39469978a76ded7eb5cabcc7cbdc50d5d1d698fc5ccb84b643d56ac43fa36b5d792bc560ef9cb04eae81392c683bd0414cde7765ff24d58c155fd7da2e7f635f05a0774aaf39ef1df48c9cfa6312e935017c16942aa12d1454ac1fc539fb719ca5b79d2db47a3966297db7e11801658d3e038a3351408ff0a806b0c4f0e679d9ff585a1bf479eaec25ee50a051dda5208b8f1f1d1b9a52f5e25cf4248384ea42897d1eb4982483841839ed4e48ea0668ff10433a0579632bd3afa6b34e6ca342b4a580acc6f37f7538f59b1a3385adb549d11e1873be0dde20e1b049bb2fef89b11162fcbb814f3f993ef69bec8a0de39d66e838d92388ae37f6fc0b85d73bd4ebb63dc26113ef71f0f3339069d47ff4c2efc38e13f129659932b06729307f536072d6a8fe18d10158ade523be5b7b29239e1303d17b2e1a137a571158df23738461f844c391a140fe21758778e23d05d79eb329494335128403b4eee3850bc86d2f1aa53c22c19bf6c0de367413113382a2017106bf24fc4ee5d21a7d172e49703f4b0aeb193f9f56ae60159fd029d5ab6854d60853e48259cd7207c0f2aafa27f1e3c32eeb0d5587b3cb20f1a6071b6ce1e555851992d4f51f4b63d5d4b45b00c004b84e7598f25ff976b74ba5af98c6c8f44de70fcf326646f0223bb096f3c4300ac72d7af4e07a3f5940dfaff7f983dea46292ad3140f691e556c39171b66c49c83996795fefa7d2f0a4a5f81b3c43cb3175031610d940b29b8d5341ddbafd577c859f54bcd4378409d9b5ccd2b77793a8827a54ade28a03d64d9bed366508449c61fee0fb06fecbc9361eabbde674f10007159d28df3809a47c2dbe31613b2069cf9fd40dc6bb48723a383cba909917af858c82ca3a987f4868e80cb69c8addbbf7d0ac04da914bffb990feaca8266807e4545f7ad7c363bf5a17a2d814639ea760134b242513719bb0c82ec6835e358b3f44a7cbc1662fba148ab52a4f91e155d1f57c5be89296c78793c2708d893c64debfeeee5a66ea947094125bc04b985e38dc86709ca8ce93a107a10191e873016334431c2fd716cdac7d899d7f10b02cb4545222e3f6eaa7e7d50f56af092176b69f708f0b9cc1b01b8b04da8f2569caff850687b40f683b4840f91ae35d8dcbd1d2ee28f840c01961f571c04b13bbf78d77cc003d4e1c1c26a09c6ff2ac7ac1380935dc55d299828e97e9267afdf1be7a8501b1f43f84f7f300ece584c26c8875f3cf33bf96ff87a06e46e6d39a9891030d08ce8beee0f399d23f81acddd52c4788ce39e2aabc802a369d559e47979dae2d661bf146c953019447088a089468f1407891f625ea16a26dc73919f883880f0c3b7c6721e4618582e9d4b1214253bf624dff43823881307019b1f553de112983052653c15e89bd38f57eeeeda8d339a89bbd50d7cbf8d6cde39321ab082f5ceaa67c5eed0fcd515149d623c21e674c431c87fb1ad7e21a264bc9befadb95f37ae835815bbe3d6d322697c82cfdb0f5f75c6352372454759e309511265b0dc6655694f4ef8a224d8560c72a3c4a7aca8f6033a5d966730bcf442eddb1a3ccc7c7d17225fc66136bdf7b26244399b02b3d8335831d51c3d50c8692e338d9ae20856ac0c59d813fa7700caccc5f7b16031d70f5c3581d985a8f7d2778ce122a64197eb8dcd62914fb27c9912cc6a992897193e97bfcff453e84e184c7a4318f48ad897e612ca5b8cf546baff57c4da4e86dbf95ff3d6a9a615334ad9cd94ae7b4cc1a4a098249bf8a471043d6fbf9cdd8d44e68cdd9050b03b90476b47d13b40180e85064c03754fc8e432dd54bebf72380944fba07544585d7977f4d607831821a47ca60c32b943a6fabfd45147edbf6aaf7b0eb37e4eb837e49a8b6c0b0031012decd3306205f92e256e780d22920912908f2a28a5909fd42a10ea583d1d89d0f400261af1ec8836e686077697a0ab22f09138102de10fed3cadee3d1347758b0411f9d93c667e7fa4192039966691e6caac26e34f3cc01bab481b8f3ae31cc9b230eae538bb5a95276b47ccbdb9be9b27a263fd17739cdff52416a27b4bfac1243c5fdc347f1377c45565059239c66214ed652c7f86416ecab4284fbe0e5ea679a4fc5807988f1185914743596e547da0d4274b222e8256179ac221d2e4eb449acd2ed90e3d2d8ad4ba1a266719a6dc6fd3a3ee1be2e6f22255f318dcf31b01e7aea3b0baea3c597a75f5d7d5210c00c2af5c22d85f28ac0dd4f4f78b40b7193eb6d00d8ead8134ee3850e5ef266c230681d834f309b50b6af69d267b64603f14a26a0ecfd3b5c94e2a85a5cce7c1bd56a91e9475b3319ed423ed2157f00a7b9924ede35309054985e75633e15d974f767a3cbafe5ef2a5b547857cb9317c6424a71808201d90bf5f4e66f5879e918127d7c329b13a839d96df2d6fcf6ed1a85d726f81c334ed41ac19beb6c055e492faa2497af1a9238ab54c4ff9320cf9e0e5d4b837aefda2e69ea54a4fabf2d917ea3be6744a7e431ec0447791977b39b86f9f7f58e980ae900c4c5adc7e6c4f08618ab74008990cace010d9652c44a762887292cbe899008a44902289ffdc361e846d5f9f5c0fd7e78645cb2cd6efaf6388e784b766b5fded92c13ae7b40b1584d86a81391e93b27a96c04685a22a90a466932e167b69fee3b5d21ed7626b84d3a19147fb7452e264e50669e716ece0da673f2a5961accfa9cfe3ae0087f9b3639173de8005b95b30348df6243d14043fe478571e9eeb326e9f63b0dbdce5e2e7a0edf7926d7d4af30914d3798f80b9929dc658f476095afb0abc49482ae6e75d323d48b3232e8c221e018b2c263f8e775f67142fee527131433588b7d6a0ab4ccf8609b90b0134343a8ccbbec8306715e47a37ccb4d412510d1adce30ea7ad522185787d52010912bda8e5adc41cfc1037dbb067c411cf15fb2e9819770d7d04fe8f559862d7055c2ad050c3abf357d210ba31409302aca09b3d760faed0421ba08c662c044fd77a6f3525f55bc05a1be44ab34b1470a232efcb114f22d935f367a1f5c3f96f6282c873a4d6f29037ee975fef5bf5311db7a717692dfc9f245abdb84d3dac753ce46e7fad988e73f6c327e3e552cd937f1e001463531e2df0adecf740c7b73230f27b79489afe7cf212a48a59672c299b88347847d67e640f4b1950a4ed6b75bc30a90b1e89c5b15c254dea5179c0a43a3fe5e340e05a5f0a4b9f38d1b590d29479d81bfd110f94b73fc2599876ffda9980eebddfe806dc00937e7325cb02d41dee8dfa57217b0b5a177fb73fcf09f5e9197fb9997d5da52232a97580bbf8e8f3b9c5aac3b3e055f198212917fab6fcced177dc449a0e3135104faec843039e63a5cf847b366ab2fdfe316b3709fe56e1a25d799e91519a13ec807166ac1a93f1771a41dd77ad824f3867207c4e2c762ec668cec685bb8c2aaac4bbc8354b5ed42a196beb27a1af919ea1d504109c09b68d7ae2c1703ca9fbf2745ddd94d20975ebab57cae8913abdfc151db24cdd34ee0e04c8f6bc846d9c21065e9c7fc024f4edb6fd46ef7804a3e56238ae9082e43f9d27a5b36d55ac37828a907d496c6da30fd17a4d335600685a8a46e2d9032b84149fbfa6d77c3389e00f64fe8f51f5894934a17030703702c109d07e8c69ac8ff3305264e981526366b0f31ff7253ee0f259a765369b40bd2a8ad87477b183a446be20e50340932dca703be6f5393896d3ecf48749ea0db8eae252fce81fb9fb6133970663f51b5ecd4520ddb2763ad006fb1354936b3e697c68f112d3ee54426ce5be061686e0050bdbaa8ff08a0463ad9100ee62d27315bac1d1f3ff0c561ab9267d0988f5fe4316f56d0e0a199c5a702c6c9bbd30865963bd70a456df5895f31b5d98985861cfe8889270fff75d73d3a20d467f22d2a4f3e1a76b2f3686bf181c9e1f44c20571a1e26c4d92d9eca1577dc1fb0a0c48bac8b13353b8e8761242255f6edcec1a879275cf4372e7be8b6ddc116e8b4e553299dd66ad69c814ff3f308739d1a17683a02f89727929ec0c385bb875c3933af93adf3b8a8ade256c046d79980822c96af0699e01f9c687b11e98cf896e93e4ceb9b6eb42c5251b31ddb1bb87c7105756e6d0d49715753e3e304db54a31f4e6c3bdc38defcb31f09a7ea774672aa3f1f673dd1be233a42c29552211f8192acbc241f509f20c7765e8dd7b0e7b2d165b09b7b93414753edf1d52a30ffab0747f069ac9d36e7724a3d0db255a6c45ad43e6e7aabd6043093a799a03a45b995e549ecad879c84fc15efabe8346c687bb91f8975a6e82eefb8ecff2998e48c160a1ed2de3122d1401f2837ede9d796379b53a4099e334581d8a65e33df993228bdb2d6b9ef60c717f6d7bdc9b4358e9a85fbf1f74d2bab0bab5b7faf0b5331355a3e7bcbafd984556966850291b9da44a102c6ab8db57430943f3df7d8fc225f7107c87dab947b8bfe9c2c169186303e5983cc63d82d55285737b35f7a6fd99f050a03f76b3555b3636751230f92b4f20dc3b1c92f70206a077674b408c485d9a74d9a0e6c04261c515627990ce5835b9ca8cb4e08b2d648ed700a2099b289be93404340ff750e17a99ddac12ccb3df0bdc24a62e8fad614b83463ceb28c6ddc347d1256389062c2ec230dd0ecae79cb9060c95465b5afc1e776cc2863c73be86d2426d3e2caf2f0cf7177fbf8706192b8ce2c0ed0e12683c7a5674dbd81e26a5763042cd31dcec9b8643e6d1000226f1bf58633c3c364b49dd22ec3563e01d7c6fc6e3fba6defa2c63d7af7f1935144652b45e336d2a0be0469cb0654d712fc13a04af282b4d1ce2b7eefc7a7bda9a318b4f3ce9ead8285f8cc89722f9af552c4f3d85921a84e3c9a7137d37bd91501152167be8a42ead974d5cf9cbbc1e7d3f779982bde82267b784c7485ad4dfb387d30c2e996f9ba52c8a43b1eb0c63944d80940448358a06cd0ffe8b5a63abc31316c6eacf1196b0b5af1bf22611c82c23107d00ea3a643eebe1a2009da9c327d3d3ed07dcc2179af6afb8e78656bcaaf29df8a998b51a8d75ee0f3994bc55e9307ec02bafcb1c08be869f2943e4500666bd7c6908425c671f2f95baaf3776bb82668f2af8f626373d378bfd77b3ba1bf824d62207869c3cb3ebfae723c09ed3d6a441354b5db9c6eab0ec69726dd68bf71aa5cb6826938b05bdf5bbd4902a52747ccf57b1e3df95423c63187c5fa02cd53edb5180acba06865eb453edc1d93ad0abc7473974a6aff407480851c6bb09a0f642d25e02d2c8209e5749ee2650fdf84bca8263919d47552f2411a9eeedf4d022f51e531a5d99613e72de3c6d968dbaa10dbd83665bc61f1b37357f2ba0a6c71ce29563ab22410b6b8ff67c9c980cfd88dc9f71e0f9e5de6df3c3004e636e9b6e4f47bca9acee9474aae13f39a60020f113d822ab92de8bc57f4c4e1e67732125526c4b47ccaa3fe3b3f6d111f41d5437a374082acaa2367c3560784f03854a17582d06d613ddb59610fe302c1a9f350a139549a2442cc9392425628c317b3a009fb88fda59e06693186c7563952d29e8fc6735d72bd837998eb873860e27bbd3bba83cfb39a71053986b3802445a3d388c79864aaad3b05b6b6146625ed3ec4615bbac3c927029ea52b8c00eeba592730452512b74989ca4e592b4790555562167d6742a078c1b187a49000db3198cd33a64b8bf3d798181dabef72d8fabb68c4161931f802e856437ccacb1a86f4a7f184cbfbe3e3e1c915df8bd6fa9313a4488e8a8dfa756eebf28eefc603acb33411b5dd7a0b5d13ff5356661b6a55df535f1152f176cc1a6badc77d45abd018a63d480ff6663fc4ddb5d85ab5afb11c7e38af6272682eebd4858376925e97251716b6591b90c325bcf823bceacc27d04933291ffcddf34473696baaa1e5a710a3f17fc1589fa6d4fbe88b97ca83b8d90241ccd99f840e75be300daf61b103bffcca747bb8c7b1f9603062e4edd47ea404150a8c6d3a2888d9bf912e5a6f181284bfc7a45135e262f1fc547d4fceb8cb2602abe96e9ca10bae054b232b54384eac48c67959c7adf32b944880f83d3dbef12d91d4ab3bf40744ddbce19b132b52cc1e13b1e9b28411b6837662b19cd5c8adfe170d3614a077247c9139d4650f58d711892e48dc40764470440aca54af509ff9a71293c7df5b296505b92b10f5bb7e163cee05c2ff253cc451e7978e0bad32daeb1e00029c3501a15197637498b0ff687cdde82500e016f48466ba4ca53ead99fb0c72d66e32b40af94510fb9a150ef5fe334198e15e2ad929c4d6366e729f73f427fed0f29e6982bf43d397fa9c2965729ec4a58d97eaa58d77554b69ee1d7354549b0437bdddd8b164eaea0a51c2df11c340e9dbf111e04816181e0b4ec817fa98722e6991803423ee9e084294eb4448e3b44544f2cadb6ca0057ae17ad1aebc6a5481df2577bb98be0bc7781b33278dec888f6ccb0b1c02e992d0f98892e9c036605d682bca8ce47c935286b761c4b8e2b0cffe6b26a29e3698c94aad1ca8bcacd343ed1b69050fe65f92c5e1d268f1c61cb707211222b1c7c11f4b7289b04d229d348ed2f4e8468280b7c648b61a934875b5037db3fb61e49c988fdda7d25b2e45c2d861e69a32716e5f382f2ac142df54626cdd073eb2220cdcffdbd4c62cb29b1e70efa2e594f9a39d1b17a29dcd596ab81879515a1067632ec807eea047d8e46b4f2bd6348c00d993b659fa5249762637172619ce3cf88b023257efea5ab3b6e99d96e278352000db8a585a5a0df04810b5f46976fff00e55f7fa22bb59751b7ddfc53b813d08c32b5b8ccf91be31a54e8ff59df39b37acbafcbb7f8f8038041898b56ce76bf417c02599ba3f3a89679a61557d5e69820cfc52d491306ac0cf3ef1e39a81bfe680b537feb1a986a26b666ab875c52b0c2d876811010ca0ac213203f9987e72ab8ffc1ba56ea1142b9794c630aed0ade12df3cbb5f4e047180c374f7ec44b3e0b3334619e5f976287bf403d3c487d24df1c9b7d8252ec76b6b20067beed8cbc04f1b44a0a0d07744e29636f0948e21a5f2ec2761715afb7aedb536d92735704d95e1ff54ef8ad388a7af188d9383a0058af8f4759284dc170cfb25c2908957945bf11ed5f541e2a2c49bdde4797aafdf800427733e8e790bc63b3c5b702129a959cc2e7f84260c39d1a53e387c97e094a641ee1f57cb36157646a523f55501f01d731f2b51a050795943f9792b4f7aeae1f31c6f37b64ae1739bd0e834b1f137b4a7c5727f58bef707d84f0b303bf74b0e91a6cfa72b424f6daaf0ca86407da50404588ab934fddcbc878588ef3f86dd4e44270ddc057c0832de7c5169411e6d3534f4a85beec664ece963a56f6f8a5ec1a05dc01cb8ad66ebd4ae8f66c8c05d99a41a01741f66acdea1b819088e19dcba01a94ffe5e5caafa270759a8bd443bf5992d49995540d1aaf8d49db55d7d33f8f1937f47936481f793c9852e8fffe825faf6d3d9f8495f07970cf71fddb7646cf64493e92f76dd88267c47d944396471022139459b8b0f4a663914a577f7b496440bfdab25951a1255698db936af8e0cc8be8dd293a2d63071393afbbb25a18a3fd99e6d6998756e842279598212c99fa6c12ca59d42434e566d403c8f5ca01312c49a1d04abd23497f8e2ee7f865dd4af810ff292af2c337f3add6bfa69b69e5f88b3cd4dced33d8d83eea9e424ba34c63db6074143b1afd88802cba050d6d3d0013d8067543f661c1faf91f3787be94c92a03ac1eb84c539464a8aa5c7140934b29c931966b6c76f69dca01a03471d3d0656b8b8aa8f2500e472ad47baaaf904415aed567ebbe1e7c596149eba75110181fe825f15dc52aad7eb31c3c5c76a72f8bf46c7ec086dcbdb3b1f80858e2daccf8a1735d6d5c4601872ca16bd34a863460b3de55437d355164b71a7c19093061f6d80d72ad8a270a5bcc12527c602933c2d076f2eb48475245a4a63bf0e036a86e1d687630cf3b3ff38d64dbf9eba8d111bf3224508a7d9791904d04218159d7dc67485669856c4abd720f1f341ff4c9fae0c03396ed5a3cb68494b05f51ab15f05598f2d1dad9eb1e858a46676ef26e31690a5fdb8ed2f977b6b1b33af2966ec8a80894685390f200807aa6df8c20980d8096a598a23e99b0d87a9ed6d1cc0c9cf357a522322d7881a792395fc874e3d5e46c569d9d3105aa76b32c89f9746fef098d1872066fd7e5989e81b821ef4821973381cc9d2b09bf2769e4cf556e17658e2332f3ba2261b708a4772755bbedf3213f2b6ce2db0ea1ed644762b506182f521cd27d53e207ea7ea06c1a27d8886caa9894e289c261656dfba36a6748e57057d8b6152e104452360e262785e15ccc83bc151a31798b1407574f2da1b018b6b2c7b62c73a81182eb065659908cbac3e0bbafdb257b7949aa6e6028b60259c9abde5c4f78dc91f9663770b409e1243562e94e7d628ab58d7fb1131cefa85690c58c4b5a486c18619fa1d4b70b98855d3e3027551da97ddd624d642ed60e3b74a098b772b3cb100e36e0a50faafc5c723c7f9652e3c5bc7a9f834690c39abad875951de7379a34116203bf84c6548230046394499e7fefc65f9b6cea5651b58c6aae2d52ea432836c6b9a571894f9179cf92af883cb61270bce770ed436bb2893244fd964dd1a02e191d432c0b9d0f666c530379d37ff387764fdb96c8adc714c2e2c7c543561806db4c0859e0d5f355cdd430d97df86e26aade0d5eae485ebfab9d1e3a00c41c2d6fba0fe152e68efe315835abd902e1c9e247b5929cd7d33bae18749d0fc5910893d2e7f746d3b62431f1a52dc9343a1e49640b3edf42e48b199c67a1ae2c9b984afdb9fa5e833709d8ebdfb76f5867062d8284342f8c30e9b785f5887e0f78d5a7dff2ab5d1a01f83d6d1b24d2e4d4cd05c91dea0bd28ceded8a75a5d7ed6613850959d21985a19149135a734e62e3cd0e34a4cedc096b438d47f08e02d4c8f051c20abfed8742dafbd915c3acb550c52ab1bc93fd3f050f2db60805ee042738fc3c8bae740d0cc32d404291eb715cb07dada887f197a16abef74f4917c98efc5653766c2c9ca8dcdcff7bb169d8f4bea136e2bcd5363deb0b4152a4c52cbe70766cdfe50feefa95e93ee91e8f990a5cd6a5e4dbdb74064e8eff8fb75e5c6c67f81d602952d567f66492f7e4cc0bfb2051d6ef862e7b9c94524bed45daaa6f88f83ffab01b8481187a12e2aa6fb67921ad4942f2acfac10d5578738568d9d6e4f6be1637ee0fa86940dc9910aa3ed298d550c6682748ba25241c53ba45f721d1614b84839cb41a6356073829656fa9dabd7a30459fff3cb53606508be832a7f19b36bae4994bf61146fb7211501fcda756c64e86388613affc11e5dd9728d1019bcec9a22a87c489e9a8365f6976e0e9234ade13b765b855574b00acaf524d21aff8147d5c7a712555d0e9b9573b82d514c52354773b8a309ea8276302b3fc9371111a523631819af4451e1cff9156ec3a4f51b74466170e9d0431af8b44080785299d562323ada87f568acea942eccdc3ac541c3187f2cd61cc20326a74683c12212ae2d3a3c79201e7a42ca307285a95e0646a2f127fc4c498654f711b1e3cf179d3be7a2b83ab077154178b84b9f92fc594116746b687f1361c24f41b0b54546853b0d0e8e0985397716fa4d8a5eb21a7238b62619dbfb2e7116780b5893c6efd4a05a534ef3b39f6887773620cf38fc04aa75d0b827e6b6eeaf2cc90d1924286311bacf79ab5967fc2ab1b47b41e09c26063fb4f4febf5d61fdfbd05e699a431b6708b0b9066b62d9ebc64b4bc77176d5315eb52479c19dc407f58f6ea81c20e833a7e16e7f1585488a4e2474b759c27304bbaec095c16b83e6a599347eb19b1d37df9236b4af0ec61aba8d5e2d4ca91acce3863fb2ae2e23486a49b49adfc972e9126d78e739b067840ed68189f91231c9e7ca4f1297fdebee09cf302c2aba9ff3c0f2ad7e6ed20302eaf145ecd20774af01da65604166da2ea7c0216a9de179b556abd583625da8a4daaee6c0ded6aa2712ec5226553ead71fd8b550b6b79fac2d2067024b6a399ce046a012d9d71954fea7cf7551341f0b6ef6040cf9664f25e372377345553c4b81985dba4fcaf3f3666e62ac19e7b7a0e676feff5b26e4f07cdddfda8c78d47ed9d133d585e6ec8615733a1a3d4c9f51e819279c2acf5bee934da851c128a7ecc7f7af0c0aab7d7493f75ef15b5e5aaa00ec30f01a9502a684b69a74c2662bb0afefb9417766d73dbd926ce995bcbfbe161eb007ef085019ada79599be3edb62fde6977dc34209ef6776560938773ac456df61d8aec2189ca1cfd028fa7cd9314f3779153800930f0290b96cab42658bf3134ec7a334168f70e6982526e06356bf368a5016b5aa612baf3b5ebc3ea37597d6dfd28a51f84529342833383d19237a00fa933e54f391777f6bc0633cdacb2f940967097becec463d9cc23c181aa4f3b5e587831bf65b1ce5e850fe60bd77b8aa384b412740e65d49fb03963a0a0e04dfed423690c3b04b8ed995e7f5ee1f9fb9da9591e75cc0666c8612e65a3aee8beaaadca10bd2a29eead2e3048e28d8701a242481dad88a82813cbe273df7fbc394685cabc18cbadfa24f923a96a00108410706e3a740903eef46ad56d97b382e4e7d6c0c589fa0f10ab88be3238b89940cbcf3ce5f61d004c82d9ae734b54b8665801110db01545b4f34ee7355829b5b6eb43275e60723f6fc8deb888a936ab3fb9d963d1577e383b11c06bec2e6c0f67f92629531a2592bd7d6b60c3c15c016d50822293c68543117dd07931ee07e46139403e8cb3a480483459b90d60ac3061b227fc0810e9b8d5ee9e27cafaf28625f1c3e8a73ffec30f7892f875ad81044ac493652465725b450c47ec3d8282daccb68cace7412cca138326f70e7be91da7503b14268ffee5f43bb1243fc328db8d2884930c7526383871d7b660d8986e30288884c2081a82db24b390a3ca8f1588a5e2aa43026b63f61de5d668d709c00c09a7745667a553ada4fbd3eca6d42ae3e1868222f979d6df15321c2ba07f2d58c60d672b0675ed054714f6605465513d7027b0b31a44cff04563f4d13516a5fa694325cc25acd9628739e4b2e349d2699a894e9349dec2b25246eb5e8f6c6cce4a313869f1a712ee67eaef3a9d6f8b7f233a791b31e3d42ec19d34ebe5e99a165169704d1cab8a1827d749bf22e36e37cd7dd1a0f5cc60b05b6d25785a199a45e35a6062091fa5041e468cccd1c4009bba50fcbeff3876577c04b74f5519ab133565dec4ae2bbbc0111d339ee828dc020a5522b53478577b274f09f540a662e5f2128769a79b9b51817c1e972f032e65408272d22d06fadc1f6adca482da2682839038d1247e038dba41124a29b439f45f409cf240828ba95e111866d257b31a5a9b96cdb2bc29c4bfd337120bccd10cc45a560a6c8de64c994347aa5430989f12be8755ffe6353e4856983b001ee2741ce0d8c375802014bf60157e1790b96752aab76918cbc48265bda6bb794ce7e921965f2bd545ff9f981cd649d5d9cd26a7e61509d20c67749743b6798c8d73ffdd20ad6b32c37d27f3d900221fa4e033ded3533546d3223b59737e27a084ac4da05e879a9226498a0166aca750c6d31f8e426907a1cfedfe704c9ca9f0b4cbeffac23695801b4533dd961979ef6ed79bcc6e12d4aa5436728c0c0f10a43e9d5260ac07edc46409cb50032932580ff6af4a3d4d60c2f25d2cf4c9bc1e774e05533cc9cbe37e975fba56e5e3fcdac28a415102dd25391037d45f5eea6542e678aca2a25878b0bcc57cf53befb1a9b9c4e957f0caa743428c1a3517c6ead96a7fb7ec4b05838f6eeec2636c1d89391a261c3089ded6efbe9984bb3fe05f09b23878e00732e22d9f41659ef5de59fabd099dfe112986d31c8f060fe1acedae21d6fc3a6dbeb64a965826da44c96b852818487d177eef64b9126edb02038b36cf1d0cb8358fb05edc83457b5c18d7a51ad3263f85f3472f8bba9c2a4f9fe5f774e623f16b0e6b35b943e17cca2875dc2c0ed7f0af656455d99592cf3aa2da3881a1c7ad1da8d9a5a4cf29725efd6041ef6f41cff7f26d144ea34838bb0f7fd678ce1e7f114ec43b8892638b2abb07e526f39fce557da6381e595bb02150b8d66583e3c03ff553e4f8aab9489e2ec912e369d42b3b2d3db68b1f855eebaf646410e9a059f817afef9f6be0c4f44328174ff50e62a8ee32d8ddd2e88634dc13f84ebf41d4af31a6f9e2da87c1c38d8b6b578fc4be45ee4eb705432cdc046d4fafd0d6eeac6743708b7a339edf33c18d697382f50d952123eb89b562e9d959731463933deb865377880f6462ad4d3adee726edc31809be20a70063c7deab7d16d9da70ae63c1ea34b8278f4674d276b16219455af0ecc0bcb553f8474b28170345757a7b3a5d951effa18ca2f04a96c191f2d1213f8a67a4034614df8c054ebf5bbed4b681bf65a218c364365d51e2de8d862d491aebb401ad36cebe0121a7a5fac533b90caa7033e45bd77c7c9f4310e83dc89a0de9f0cfbee92d4b4491918d71b461e0d2fd4e6697e2d7cd8914c843541065a35bf825401e33aee4fbf4db03589dbb9d7b269c1d67700b513cba218fc9da9e28ac43a32d48bcc1820c0e3813a1c5b3d4ed8c7cc679754dc045cb27003a545cefa2397da2dac14c1e2f28c29c2f704e89fc8f13a5349d2dfaf6e052fd436660d218a30a6c1a9226ec3ce174406daaa6de8a8b0a3136cd6b64f4b841367f39be28f1b564bfe6c99d67b7a8afd5a5806965c1670e828f61801e2477362447d75d7cc55decedccc9f12c57b3b673297858ba2e0351cc0ec9160440e3971a25dd7890e120c4292ea1d6a3ab2e320a772bc974ed8b06edac6c8b7fb5e46fe73b601fb8499d535aa9b9f6791538ae89f16a26652985e806705d732cbd6aea0357c9b77cc596c5003be16deda5791b9ce1526c239ec7b42e559c134ad401dc547f24769428f4892cc5ed4be7ac564eedc55dadede844aa2713f0e7fd01933b7b3719e82854d7d17ff11816e6ff407d0334988ed6c7b61030c8241c66922ca1b4c1826d6daa3015449f5f45b84327c6a7cbc1ca43a0acafdde441167c313fcb4b116ab885eecb908e4fa4c606c3eba9defe54adbce69a540ae6baecc68f6d1c9949f551bccad9c174411079af9b7a8870b025990842a950d0afdfe7ddfae71b93ecba14097766ec503033b2ef4c652e02eb84849d83fdf9969bd907bb9350f0ee1ac9b0e739039716e6adbb5ef0e045bd329e785ecf2a272f8b527edd0c50ebd0879b297ebd250db713c84fb8a7a3de88331112aa8c3db7ff927b323c1a56fe0c022d57137365de95212e21770965eed1cda004b9fa950c420d893f08fd7b3ef7b44b65d57ecc5d0dea37533f96b4cbe3c32e944c8264894e28e2733fd52265c4825952f0e5e621039085ff188170b3d089211aad1e2418f94132d10ea3b2537a1aac73f4f817848ce373b27a546645eaf9bf86f877e0a6fda1420f0522d28870abd2ef8c340327a306e6eb233e8e05caef04d7c0886ea47c65031715e88aac605821428612836ce94326a1c70be1dce90beba5fae8ff8887ad728a6872100807cc04bb2485bdfb7e492cba86220097cc2137983b18a24abd622138020a4c0a5391cafdca16633ee5396b953afbc563b61256ee48614ce7f61feda930aae2c52711bd82f0e70ae4f34466818fed5c57f516f9f9f53018e203162797d052256eac57ac136805eb62ddbaae43ef53a9ebb9b7b99f52fa20be76fac7725f703fe02c033f51f6d0e16d43cb9a953b52ab797ffb34d829025285815381dbdd4302198afeb0303876e2815b62f8a158c9fbc30487bb34d0ab1944e2b274298274dfbb3ae9f776d9a55b5d23d63b8a8741af6cd4b4ea534221938cdfb119e73a35008cdb4e9f411b111d85a5552ee390d5b87d5de5406a937038f354c0635301a8e9f64f10117eaa5f95bf4d4cec35bf685ee29b8905c5ab789891cf1889e1fb68ca8872a06873c699ff964d2b187ea9b16eeb50aaab3f573fdd84ba6be4b7706b607355f66135b7403cda104b82adcde3b0cccbed2bcba38a286c9b134b2e8892610d13576f33948f9f1ec2d62a27fb01751d425eb1ef8fd7edef5ee4d957dfaf74522e5983a95a9ef339dff36e458d23435ab8725a4409087a36b5e7aa73ead1135e83c3a62e54614ac6dd9766d4753667637a1cbef73a62ca6e7e981e7a270c24f4c7290427cdbe00a4dfbdf49317087efe23db5a4b2cbbad49476f63962023aafa9b68ad511b35817677eecfb8f09e375039191415afe6eb7ad5d1aea53ec6c6fa2963013bf4cae9237d4bd56c152f3a684f53683e9ec6d83cc4b72aba6b4110a357a442c91344b657f2914c4a7a3370b5c4cb18456c9349cc3096f39b85d0724786c5a1b332d4f401f7c35fe40e76138a09cd91bb01385ceb7664a245a0fefb5ae3bcb8034dca58d3cd6ced3ea81076a178bc80c4ebdae15dfdcbc66418bb58f94875369b38eeb3c5f0b00851bbb0e195bf7fab9cdaee866c12d565dc750e5960ae5144ad8b8afc93359cee89e7a7e466d7f64a1070640465d8a209431e997f73287e0141d35c0b3a0260f44851930bf98c8ce0015ed7be1942102f64d7457e367a304ab219e6a97f9173f661cca35596991fbde5d4d0395e1f40e6bd19da8455353ae331bdd55e6847c81c9dd6d0a8684bc635464279ae8c39724b01334e719d6a8e0c419688a3c015845c3962802a00be2ed1405f53e60180af159838174581ea9c6f396ed6d297f0f3fb66706da8d3a29d8e078fda339d441fd91acaccbd9615a558c5c5a72ec052a881c87bd72cb799cdc55f8d1e04478817c3d8a3d492173d622c65eb0dcf52d2ede3f8b244706a193105226db60d66573a865301fea46193b315ed61d72a28c513820203611a0be858c2bee6a492683632e5c3cf366078ac21f90497da2e61f5326de8f1c3aa9f2381a6b4f607843e9edfca91b0c4aa818e63d6a5e97086e06566ca1d49a7718dda86bf1accad97de880927ddcbab00465245e2a000dccccd26a8a40a90d8372334c8e31a07e988c00de3d6f9722dc5b55392cd1a718fdc123ac4588c566f140f29b12571473ecf620ef8b8eb92886761f2e4df09b59856de8713e2744f1276e6cbf649f10ac50ec4f252aceff665b300e27dc7b9719fc926e3f0b2063bd594a021c3d1ffdb5567ed75eda2f35a9a88eb0a8541490e38951f1e1a707aa1f9581a8a535015d0df906482be1f1a4e2841a1fa55082f9a82c3c52e6fda7f5d1c4293b8cb7141567f64b71ef7703ae5ab3f44e4b9c7b00350985863c16eb3f699012f3c3f4fa555300bf76940b75d3d9a7b1a313131699e4782daa6a4c72ccc334a7798336af59b358c3aa80c5344cefe630da1aeacc9f9c66f92d57499f20e40ced7ed1cf0fc9b8fde185f4da1df8ca01c2cfb658c940776468b210135828cee841f3297b4177c1cf22f822009d6ddb8ec284e901c6192c96115878fd94d496c1603f95da7b8743b5ea0af463c0358a6b1d8c047621d04ee8943512ac336ebefbd9bcc4469e47e0d858f7c7434f656454bb5f2dcde877cd4c96cae69ce18f4f807e315b209b652ad03a6d1d0e7705dd8425eec4737b1375ce8ab542bbf3ecc4b923c955ee4dab5f838925732e7e847aa6015a096318544d20d5f36eab3e99c745ae96a5b0d121ac58585f3ed18094fd47f41fa7a143e8b414cab46a813cefada3693afa0b7b58b99aab353488b32dad1b2ea815a17eb234d56f74d9c509560b0cdc69ca6882bf04750d58bdce9f421ccb64089813beffc8ead6dce152e5b7943bc7245cbd97294ff59a9c1897998a2c7c615ee5b9983d1b4f67df848d4313b82a86ade867e9c0bb3186fe9b99e975e1d1b5e6ad5e63370d5ee59aff4e09ad1b4a5e896b0c44f5debd86d9213da1ff1e9c4b57443be5d51b8b27a9d14d01158bbac0701560a4384628d6dc3e8d795705c20dab07af7b57d09a61959118c816458e7480ae772c83cff893ae7f4a60e210fcc2ef0f136c4c4b34db79820b1cb6152350e84b8fb3d230c5c27c93b6bd4f6d3ee36c214b16443dbdd9577c71344ba75a1223c1f6e9a22c4cd87a11beae7e89e981e952702463a32113dcab06634d2c1732fa5a573e7328e0c3632e41c7913783633665fe56c34a21cf782497057d24a2d470f1e5fc36782ba0ef3848f71aa9f6468020f88af7d83375526d51c60429a015c709313de4e126d734e24b1e9bb4de5d2d60b303ae9dc3da84fecdd72739850c8bc5ad07e9eeebbc8edb164b0c2b7252c51acee0de8656787459734a5ba483bc6cfc68ffe33848cf815c60fc908468654d001247bef44eb4f9e76f7877be2acf6e340144b62aab7ee13601eead9228ecc2430a8ac2fc4ad9ef4abe298021119dd9bc7b566905c801cb95572fe858d4d3aa1048b1c9a76c2d8ab7443cc2f64bf629a1680e4279993f8e7857da4339b75e8ba2e7c1a3887a2a2c4a81d0df13b7b53abf83771d3bf727b3020d6ad824f17443abc184ad12c746ac18ffdb78cb806de7b866c480d093ba07c93eca1fe368f61fbba8c23e27ba5dc9abdc41abc791e18e353cfbdfdf0b5ebccf52a3b61eddd753e223272e2106a6ec4e924fc95362379bacdacb3a9af7fdf04f72de9a4399159886518d5db4c60d540f227144978ad5e464a84267118da87c7b0f74de7a96c0c1353aa41501ec08ec67c1890a60107862e8e6da3dd7a73ee63e5f4be1bd93330ce1ffa7d7090fa56f4e75a907cada49606c82fcbc05e02a7d17f6dc88dc8538cefc295a5a29a9eb2957e4aa8c0cd8a956644acd4a2351846bd6681a833f7ab88130328a758eaac69f71efb628a55fd70935c8507815bf6e4a4f422d1d02063b4edd694c936a141044cc8d3badd57fc77b761b843dc00829f04a79869e8ce864189fbb1218a41a05520c052a045a5d4deaa86377917d8ac1793d6efcc7f25308619e2361c0f433beddf41f07a3e927b3d4c0a6f2e26a0c9f38d8a7208b1950b7c5a5701f8070a46a469ea009f70308411692407fc8ae64c5a16b9a2600d606c4381865649a33abd15b451adddba843b3936772210a69a6b7a9d8675cacf10889bbc395a78b2a2961f828490f30c84e0795807cfae534ce20561568971df5f116c457a903fb033f7652750531812e1fbfa7cfc5da9da2ff1aff7bdd933a21e2d3efff1df2e17c7e2cf5c92a672abf492c881acdceb2a4142b1edad04239f1da7c1a8b0352908a7d60725ff52a03a4b50532eb3f7f36b20004971618c08f13360479c369de8401525fdc00eb131bca0c3ef7b182752db81dd380fe7a1dd88d2294520e75976624ab564b405c02bb2558a546ec7202dfb4a2e427f54ec4f40cda6d6474451b387a70032da483f85dea6881e7cd734be10b77cb280f77042bc4354386396dfd22b14c324896fa1accd315b4d876a65d3f21c36d3c615394c1fd4904c00e102db60c2d937c8c56c023190cfc76521c24e28302478f50d92388c81531a7b47a22a56d338309330a15a091482d2f968cda356d76875adebcc8578f8464b1e439aee2e96b5152fa6077ea1eeb59ada21785d00f29b23a9c032e5ce1a29add34c20ab285ba0b28eace3a9584c1cb18c648e9993a77be0e8547bbee1fda1b364dc02b91115ce16c78f5b0e3d2f86894a644688c819598defff73ac2dc440f24adf44c20f43bf139442104f76126cfc5cb200f24f940c0e0fbdacfdebfcefa610099648b6dc06c1ec1aca0680a0cdc503642faed193c5cdc4ccf1337573fe2b419f331c6d3af1fba7dcd33f34062b05eedcc72b3b3e7c38267510867398cc84e9a2cfe82634b0e030c499fca5ac40be424099eb5d26233f5db3e560e5ee49d7a87936a767f0fe534b8366b0cb63bd5b39ca5f02de74f9d734f0fddfef26b1ee50788d279b1d457ce861a4c5f94762274294739b70d08679b5091d5681d05cb716f12e8ebb8fbe460bf5dc162decdad1be857f736a9fdba3d143deccc3cf21c652a75ad2477c11dfbc1dce75259323ee4a73c35c9e7ca95622f23b7b5ffd57ced1ca2b408ace0a3a11424f265081827794ae02bc8bf9a896b3ec36528d9c9c2cb5dc87f62e4eed903bf26d6282b1f047c488660bdd078beee0210674f990655ce31f04682a92dddab26b1dd683764d9e76894a5936a465e941d72eb7757eaf81087711dfeff9795966ac102169d3dfa1435c1ec5539c249aa66ba6267c3c6ce126d218f5f7269b0f0208db59be9477d7d7b64707788a081524aca6808147da67b78d941a97b08e4343713f878174f7ad9cb934e72a60a7f3300e2eb6171a99205a659d12240cdb015de9aa26edd230f3f08c9dc3471a33d2d1603d71e09721be16dcd3756ee3c0986cc732a812cec05df13c4a0d5c7804d3d5c6c4894ff444182d3c092e85533b1afec913f144c20d04d11590cb55d1881a230cda8f3dbf77a875908dfdcccd35dfa0249bda527d9be2c1022016825fbb5213a842444a01fa0b523992f566950b028cfb96af91aeab596db1ad9bdb9d4326e0fe93200f9260852dffa2fee6122ae252ffe7b1b75d87adfc7b6d1da9902bc91fb42ccc21129f7a8dc4d1545a78dca3a91a92968672dd85b15b65f06b13e26f512012a8e63275f6b139d3069e6fdcab3964b6044697596e0e6613801e86e6d2793b4d4633360d26c633f57805cd402586c634190e00f6588f96fac8c2730caecf8ebaecc0cfacdda08989e15080c881e00f50e6e1e09117f2e63cdc400cbf4578ff60176fd2941015981acef33d4df26c5c93ef999c05e30ef8875f958b0ddb53844bf355538f5ad2cf809dab9a5eee360c64ad9ef644d840cd3f0d50e8923bda1892e3a82c3779d5eeba036693a3b255b71f0c73d11e775e5c013362637c30077fb6ff680ab7cf68c73c8777bba5bc20d261ed0e44d12342f44c323dd30b0d57a2b991e76a99e2b4b64204228b164f74f310a50910f8a5e2bb660041c4f326d3ad5697183d46dce02c9a2b6b8874f205ef1f7c94c252a9fbcb41a67ac8d4542e27a145b506f60bc3e839fe424433f1c835832f450a7f3f46a598c3b290f476f1a0db802ebc356221c9f657fa652edb622eb76fb00b0b5b41052c07cca800eab7d5bc636fb491f781559c5f093f3d02b0775860d4be32548a5b7fb971f14f187c3e81be6f62a1838b60b21726a131fe5747bb1b539f3269c561503216319fe7f375179296be78e5f56543d2aaf0692a7256232c7d395937169875604156b646fdfa6d96ec89779f0a8609b94cad63263a0e3a142c5ee84428a8c5442f45bda51a2469b51ed58957b540824622eb6853d4e6a4c86c076678c7f02774be4a4879ff55508e5075305824528bc9f975885a222a2a30fa37349f08bcf499ae8e4dbb2ccf91f3be50130ff95255e6ff9885a6a78ca6a9875f26e801e259f22e1f466a9d9a946a32ad728e08feaa15b6c451e57d4e3284db0d526913da8ed0bc6fb604837bf0af41ea870cac3dc621398def8a59d63885b9fe8798bf7c411852653b1112e4cb306451c962a1622eaad7ba534e9ef8f1649dc8b9d313f8cac4e34902995e49508fd4e50f8f7b2665a3f866f6ab835ca04f45b80fd9a0b86a62304143a848661d24435ed136a35b7ad4515f4b6049b134660ca3994f0349fb93de18efd1783f647958b2fb1be76cf8596e4946f07ba5793e15ba543dfc69538deb8d42a86cfadacc07e682aa9c0efe218540642249d2b85f44a8b78e19e5cb9a69615a4793d90a90b1fc5c7050c3c3709fe77182e40cddc60a851593eedb30978ed634ca79ef91ec153e7b9f06163e5d0f2a6adffbcf72640066ef81dc95bb761274c6d3075bd23a17374b8e0bac0755362457cb3baf8b9c4e99bbee6a0e90bcdd22e906cc1e31894c206d37549040969bee131ee40676c9ead2c05830c69f040804f68e58e5761c649498b86e5a9ab552452b746c596eb6a0d6629e4a98c17a2698cb97af441de955c01bd302135b18b245d4aa380dec24ed68a58567964460ea11dbd1bf52531b6677fc6de2f7ba7d59bc3b655d7cef47a890b9345d2d428c0fee98f4f09c4c91f7d48512aa81a37188bddd8b7488c349807320b852147ae89a2a5636c0d4fd5c2e56f870f14c80dac481b0c78124f9c643574e8178c890f168b718d66cc3c245629525d70bc9846ed1c04609e786ff4ffc91bfe350971f390cfa8295b45689456111fcc058ce8339f404dd0469f59fe7d8722096887923e6fb7e3b38a0d8050a82aa6a43247e381b8db07aaf435dd089e86d80375f40fe3012328f0760a4247886bf8e9f170eaa48fcafecc54e29c49fa41488c59fd76be65ab8395138ea65264e14d3b6396126c6d81165443208df8c4ba55024299e83ea31c558e67d5410dd58ec808e7f9029f276fff7f2aa9431240b3bcb9d06171cb0b184909ba29f2f1d190348d1ecc46afbbecf03d3de11742ffbe89c5c1875adc3717550ca51772498164c6d4d44053166532ecfb4c1ad07e9e749f4f14bc31d41954bf9cf9c2a23b5e0a4a37548d9048807914da489fb6285ec4e24d064abb75a29b75d8c37095f0ed1e20cdf8be4cd0fa6750775339872a5dd56bfd1541debd4d327b9e6c47bc8f29de684c5d1da6d7a07229940172be3e483d884b024595d8ad1e7c045332934e4bc9f2384fe6ff49c78e017de8c34fe4ca629b38e6c1d3ce84428e51829bb791a9529d61f98259a1d71f2f26fa05cbfe0e42c366e5cfcbd71d4d8304f811399ff816c0abcd617caf999b392d7d6330c1463f0bab95419383a996478dfd7043db1a5ecab26452ca5ff23a70d3c0298844f4287e7bb0ed1376c5daeb04226e002838bb01b4af14393536e69c88a262f3670eca7d523550e9dc52ae658f46f69c67c9a6960ba2c53a9ecfcbfbaef6daa99462ed975874c4dc8182912dbf77e05d2d75748872ddd80e517bf41615f2dc3a4172238b0de4b8f8dc8cc64a850b0323b81792611fc5caf84f2a5511810f923681aea20ef0445c1c35155ba9f87d09ee39fc8f052a7eb10fff28a65baffc8afa4fd3a443f39bd56f6c09bd7fd2b086c8f05d47ae34eaea98b5d66d3e06a2dd9ff5fb6f357a2551bf5353144b04cd87641bf72268c3940e164d1d59e135493fb025715afadc7e37cbc68cdd964ff26af968c1609b551d3856abbf2008a0599e8ddeb223c28131ad076220d6319de5bd6295eee78f0a4e0e227e178a4da87721bf99a86d33458c05125bf80e33f858c3421dbd82b1de568cdb6d93cd01f2a5e44c0d35e2cb4487ce6d5b30a63c516b916e8df265291e9c4c7728ff2f9a000291eb27bab70b3fd29db28028e566ab61828bef82d57e42b069ff1c3437b0862c3bfae6c8864f671c42750c5ecffe40e76f836e9aa313849e723418836638969e5dbb1f0374a1807def69fac565f37cb9b41fc27f46d56844ce1fbc7e39d1e76c3a0a24afd4c7000a9733e77e78f7b1ed1bd255ffc5b904454f260ba7dec39aad229a72dc77cf50790207f7c95a92a3c66a141ee240b1592f7593d71a667ce6e9db57543aaa415a65e38fc2570828bdf5009b967e0fd5a9d3a7e1f5016869feda71172a72b86d1cef9db8e6e2ee987c3d8f0931125bf4e36eda8ff8f92e1229564ee016b5b437853a80edd6b0d33a02a5480c066afc33253fbaf42b93334109a380d6713bf010b6eebc252c0fe361659f4c6e9961441808f4d27be2dfc47f073907a9a180c10a939e77901272710b218a2319a02a5e4a3a839be2fa0bed2985b04461867b21864365b3710eeac41b436ea50dec11e94240083aa6b99547888d18c6a47df362b83c92acc1b76d615a203fabfdc1e30a29d1deb4260f4246d8318c7d82dd75da68ab975b925b578529ad5ab3ee017ca20f92a522bef60fa72a6b849d56c95254d56b3402e76b5b59cc983a35021e0423b827367b486e1292a63fb081d16d8901032c7ade123130b2667ed7af3345e48c2baede950584e09f17d71cb81c64e415825e9c4cbca80b07c5b72fe3d66ada2535aab784203d4b5cb326caef0961fe2d39371ccfe58444699547779fa689bc6c7806af3df8c712a0e1c85ba14e161621fee9c3123bfb6d38393e7128ec32a38cff0066b178a7aa6c25215880789a1ffc36b080158c0c5152a31ae39bf0612bde91a03a20d7015640686bdf3c179602060af3cef7913721d41f13d212d6a3c5f21dc051dfd1bc09ed673dfe23e4693feffc41ef11286533e4cfb094e8aac483f331758c3b6c4c8e907432218826d2322f1217b6474d7124d23fb0c32ec26083710ba690f66b2d3d661bbf217f5936bab9a2c82c8bd90ec2d923b43d9c1da034cdf544acf7a4b57ec183efd1ccc20bd6d245a4906d23433b3eb462ea643e2f3f1eb223275da3f20ec20aeb71c6512ddd9f61e47497dc1cdcba97a531e6e13471d2a49fbf7baddce69112dd7dbd28884b85dc6d8674da1b20175c4bac6d9d5a2253a19a343c9e554b196aed812067adeb4d7c4bddbdedb71482d70721002245a78165bcb397d867bfda8e979a2463f0db7dc3f994aa088ac1bce870b55cd70fa1ad5fa3b42bd805dfe031c3dd8ee2fa40e2555759e4e4697ed47c71be367b2c0fd26fb5c6b33daeaaf9869ecc29a492c6dbb223caeabbf7de5a88fb91ac4231f1e7f38bc1af6eb6680f35e10973dfaa2b063b0407631143bee2e96059a51663f790b5c8e4d660ee9c6d0427923cf7cf77d20a2b3e0c351c3141d459e79bd8d78cee9582769659ddd895970ba5583dd8fabe10a2f1ea30a9b366ee52a99cd47db3142f1829b44928495c2e8a9cebda6c37ba5cd2f8e20795b00bfb1d2fba8c2a96e310cbdcb0f7b70e247a8e386336c5fa796ba9337d890333c09e4c3341f2cd939ad189a1a1629094cbe0f4583ece52438f1fc20d170d362700aa9aee3c0a49634cc54fff2d10a0b9735e1749917114733b87dfe5924bdc0cd6fa54841db49bfbe1b9476aa92c705c864e35644e2d8f013869638429323356e2162cbbba8896699ed0aaeb1895ddac9da3c9788c61dbc1502cf3f23a4ef3fe3468673a3484d5159c7b7f8541db544642dfd25e9008e3c4fc466680872317114df3e02e74fa47ca95d3fca0ca3564c82a017b46b20a6749cb21c69478babee6d05953de00486955dc572405ee3b1d3c8ff473cade25c5c5920fce0e80299f25e3ebd6d3098ec7f54c442964b09310d7da4f77606ce7162ec3af7cca016a04928659bdfacec06d02a6c96af54df2201bbe13d62c03b12e7208dbd12576b99d6fa14d0645bc07d52bd685691077c620afc5084c358c48cbd51a38cf93f22120e66a7a5d27e48d1857bac01e720c08459edb82ca1d63f17af631ab0ae8448357a16221c81b392a41c8a644b7e3c483e709688d3c62ecc3ffa8fa305c17b631739e4ad24ce1b3d647cb55e95c815b4a6a8cf206f42b88b7dccfec620a6711b357b3171d69b9c571640344b955c5865f8ac086699e8b00d7acc316f99360147540799e707cd298049b73984167300186efc5e54c6ced19218913e87a72bfcd8dcb6ec1041cd228c09645845956d4bf6e96b049007d1f39ff429d9356da7e3722df583116c08bf50787eb47c634a380a24a2f52b420ec4900d942e7f38aef09d6547da1d036f8a5c296e06a02232982e389b0021696a881c99478f5794a7acec9dc17dcbbbf8f1b3a7536d2fa1eeaee18d261b2f640cf4fe82aae97038df19878c8d4d21d91be0e29c8111d0956c639b3e670923c8dd0b37f49a144dc6056ce3226708015f5569f5e8fd9628453e0089515654ba6a0f1b8e58e8e95ec9af50adc7232bc45aa888299b0360e9da1b84d05d3d909f2993b758bdd730449fd4c71d6e251f265619ec6b23819faa215d82bd663ef338f1a1d6a310a25862c4518c45f2e7b8d5d231d1f144993b8a508293790fcb3b432d34f13fbcf4027080640c0cd07706485e7df1814a2380b3d8ac5532962ce772528b385c546e5eb51534f2e480f66da6660e7f3ebd28a13a7821fdce60fdb7951daadaa39524510d65463c7e8a1a1cf27afa300267680df65acb749747ac8cee79d7560fbb2073f16f09e6e88eacc2b609d95fa2b9d5903fbdb80e6f34ff85c5bd1de2db47ded81a414c20fe7c0ba7e6024832a8cc1647c7579bc4841f8d7d6611ccdb5abecead818bc2190356a800bafa6ad95203055ee2d649089bec40cc0762f7518b60d69ec5be8557cddb88a7ab8c62ddf41431a8ffc23e24492ed9605337f495af03cd144967909de9e0c512edc6da79fea15dff2b8b162cd85e6c268c1fe0e05034013f896f446787e20da7eb577f0a47b8ff76d0d5147d9db0dfba892b19086364b2ed7c3fe4ef2a0a2155c110828767a9c25e14d79ecef43170750421c2417aa1953c04c619cb67b35888aa101812385e04158d2fbed23ba32cbdeb9e42f9445d510db32f6e0d26181965db96fb90c2e259a925c1a366710779afc06cc5b3bb260552806dd40434d464574e09e85c3c3e064f68fb1e535aaa8d162f93b904b9cec02724b5208126874af165381ffdd8ca869f935b269d4d11f4af5ea95392eb5608c12ed488acc9f971197c48e6f3872909ad254054660a0e0ec3b6f7082a5436542022862a74a4d29189b8f3069bef9df0e4c6ba675d39f58e070eae14e5c1f292a218fd86805013f99cc8074c10371753c2bebec2be7bccfcdb8070f65cfecaa259c273febda84e0a6f521c0a32716a7b505ce5e9e4291e34cc67ebf2ef9b31d836c3ee5d7510c6bb493d8093abba4b687dfc0408692303e56728f48e1598247e05bc4a4df4546214642945c2115d634b3c98026cd352dd1369daf915c3430250358853dfc5ebcab3f0b021740f89740d78049907dcc62f962afb2d17e02358fe747ae8087b8fb44a7c4c9c09a279ebc7d54d4cf03a83fb996ea9dae7cabb4cad1ca2201e037dde1e9cf491e76512514847da62e1086b0a1b7523d11ced73b1766863f95f94d31b8aecdab4f7f24a12936d3a89b7afe69b716281b810600e7ee682ec586a24d9347a5fd4102649f9c15dcbd4b8f66a27f9c2f5e54964a15b737d5f5115c3702562f1da4efce54ccd7b93c7d41443582a918a8f9f347a5721e72f6558405497f5a18327ec1daa538f57d27f07b4e817dd5e1888f379fa256547e6e8412fe73e2a2edb2e1c586dc0f3ebed6a90b953fd05860fd68d8d4d928db7fd771495ad4fb2e7368a507d2cb095b86bcb9fb196cfd145e904cf6c25f80a46c6f2378dba3b64a2e760a3a867b6eaee07f294e2e919299a6f7b722cf38d7a9d067769a386d787dad1960bf8a4a9417a2e503626240c2f2742124731707975c0741a52bd6dc29283f04a782eec7f1e57845ae9e946eb8b5456faf36515f47d533d754a49305fd94dd0a56d754c3b85425f3b1428f11165d071f30345a27fbc3483fc143d725c36f714f8fc0e56e6058a4b551388ea80240cb1d2b07b9b2a7fa5d92c993e3ccdeaf8f128324a9da09b4d84956c559eff71a70359293fc6e4ac15c984e9c77ad1382bb07450753cbbb0d47f962aaa98ccff27ac594b2baee39eb54e4f1e377cce7ac52f7b78da50e5d9af619289fb0cde0ccfc4300ca72317124f5a3ecf817637b977619e910c79681a418625603350b2bed7b6890958b8ad228a51d535b300e60039c9b090eb5d75c3ecfce0eda35db0b4ebc275fc2344a983af8ca342739602fccb03f475d0268040a505adf96e521877257cd2089c6183642dd84e2f94187d8fe93c679c42ffac62bc99fb696cf183a38a4a002373f0e1b6a0f46d570b4c157f77b56534719a4cfde4e1cac03721f7f881e9e805ce935bc6e8163362c957f3592f4395036dad68e517bd7725cf6a80a56be85573d0324c54d767e6069d48d031a0d224c4c77060a69f3f60e6197c69772c2b97b8c877b9a9638230f6aa8eaede83de5abdcf20957de62e569cbfa8f7d32e6979b1bf524751e3f934b20c7c22d1f6f8736f1780266fc284e159f465bc9516af8cc300753c6bafd07c5fd7cc2ab53f47d16c5a53bf85e3f1529041cd753427dcba8b62d896cdc900b1d8221999677a0477ba19e3718fb855a694de1d7fd825232e38b636306289f5248fa8630a00a8fdda517b7da4e9964935eede38d13b538c87c8c88ff27411113102398f6ff15b13039e11f30d2e329739d95725937af37265aecea51ce45b275dd795e525837cbcf30d3118c2d278be1fa7a18d3a35bc063a88e77f9664ea005bdd35909f2453816e1663484e0fbb6fa9e6043e3ca66bcb71f0a4e8554cc7dad08317219c5d7781003d57dde5989912e07d76aa4c8dbd18ea9a24f0d2945ae3f3910d0df15cf5ec60066cbb9e079a42d71f81683012ed99b73a5b6a8c07bcc2f225e12ae2676f8a1fe28ac5bdf6664d3fc81db21c01f5ce3ceaa26d9cc6970f30473b360aacdf32a36d9b651332b2b5c72608e6a702ca8b900f7dd45ca36ed64c958750d3350e5378a84308688267b151240f064ab1dc7634f7bcbe1bf5f71903dee87d7f0dc56eeff303a0f8ea5eacf2ebfc376dae4b8d1b9ffd0ee0e1ae4bd0a3e724c1bc4a990bf8fe20036a05c5c621f5450e19509d006c5aeb3d4b21d56fdfb993e3beb1fec0c7e603638e834e9331931eed0799cc0cc3df413bd16a942586e278839d195a83de99c63d74c14e39dfa5534de97c0fcec10d3f449d6259d89e6e68d7bb147e24d1f36abffa47fff782209a46ea21b47d8e14d82fe76668fcef445b881204d202cc36f3e64467507f9bbd4ea5c700da96fa264254665dfa4d90d42e1a5e60cd87383ceb62d73a63d29fd9ed5aaa6ff4bc715d79ab2074bb5be4ed20e481967ef6234cdf7de51b10fa3a40997ef1344bf26e28bd074a6a4ce1d2b855992153068a4114e11a9fd261875b0198dd0b7c791ef23e0f5825adc2f1398a5661b3d71be4a1b805c2915f14e6c0e6d51bc3e8eee4af4ab8fc196125f2eed18f808c3987cb7961e4bc6e861c7ff0cd5c649aef6ecbf550c32b6f83f263d379d090aa39a73a92fa1b43c85b21abbcfde1a9220c90b07cfc7e655fad9a7fc8d5cd493bbaedbd3b12cdb697f7fb74c7893a7766e84192a379fdf875a5019f8bb39ed924b55f22dfe61df19e163a2cabf9e04fcf0a3fa4cc8b979868d8ff77c5303fcd10fd157485bbb59ef6e4a1c7b2b473a0262a9fb6d6df67fede06e226d6bc1189bb00be4cf17c43ac5b64a7174c26333f94d948ecec64cca0daf1ea08281357518a3e1c72239af6c20de1f5c89d2a877cbcd876c126a2e976b093cc66130abae2a91483c464b405d550b0ea36eb157ac35ff63762b29426cdc67f30ef9cc9c69a37205e7d2f7428bae3031a0eb09439ca1d1ef150839fad2989573301995c6b30376cabbd91611ddcfdf5cabe9db596523edcda5cbf7aee4044dfe6c6fd957cfc56477a6ce31724f3a51176bfe4a9887aa15c7fe863de1bfadb21cd1f6ef333d2c4b57165e98d84d273834c9f732ba99c39ac3e80ddd8ad838d3e605b477dab67951a4bf7bf7404450fcfafe81504b7c0b0cecbc08b5fdd772ff08dc3bba3654e80e254b226e172f9fd5db4d39ce3139c1b0caf8d6bac2b11a29934f7c3bfc47bf2afef86078c207f927ca8c87b8e4522dcb4c4976169db6e61a7aa14f12d9161b9c6103453f862520e6288b2827176a5157cba33df7e73e96b6237b469f07796c83bc3058db511f948b18721a0d2f48654739680db983f77eee498b29b64880edcbba3e39fc70b2f6e778c3dd529b1774ba42ede5a1acd2069bd7dcb6ce0b6e3f89163afd6f5b022a50eb188c5a8c548c83faeb3fe4471853df10c04f4f95bae0ef549f3116467c1b272c5718c9ae84b425b158657cfc26fd97b5ce505d4b26d3b8aaee094621714e985cbb6c210f943a440b95ef3011b7aef1bfb861d095b0074777f9e03d2aeabf57c7997dd4579e53366bf8162b81bc36f3c69696cb5db2c9358bfe76cd29e1d6128bad7513810e7b83ea474ac5026b2320b9b201bb0193a11e703fa78b55b90d11a2c92244507a24534b754efa8e1cb875b78ce043be317e62af4d31755de5762bba3dad3f3cd42434a9c7d23c8b9961ac75f6d774f67175899d1c3480125a2a22ba430c1b87389a315ca7f3db45d8fdf9ba0eac235ba33b99cea45d530b0330d89ebc1872e2f1a5af40e672845402dfb89fe10a14454ea549e2633190206340b7ae57ce829dd5d7faf0651527918f7d4b03343c07c92a310d27e3f32622e0ad42637f3351779f2befda753c5ed62a7c89e6c06fb3333ab80b17fc830623649bcb6350c6a43a6abf3adb8b306a1db602713c95c062bdcb8734accf323dbb0acc52a6b874f0e2a23139c556b361508f37ad6dfefa037940837439a1d1b03302582f6184f698670d9caf46c00293baf2e3dc9350b8d24480315bd339776fecff49b08ae9a819a04e670b643ab754d5c4a755dca66df874877d00b73b521caabdb940c54e10ae01b382ad0f0ccb2e7dd56ed0b8dc16c17c8601e8f4e2f901465548e8f649cbce8086768badfb55a33c6c3f1f9e44b6072604260d948cc98bca1e02c5aedd91545c81221e651bc12f9eef3ccf026e2446e8d0d21b5fb6287b68965e8c1329faf9c77d460ead7a24ec2f0e170fc21170bb52e9b1689952700094b985bec281b89b8d9be1beadb4e8afcacd40083940ed6e807b4a910574a8e6c967a64fffca8b7f6d26e5d4617cf933cc3232d6bb627999141a9465d17e6f7d921e727018ba22462eeab3a531bb29f551e0c93f3ae77d0cfe87cf89abf3eb1fc252e4abbe9024394da982670cbac21f5679492311814de2e6c9a1021cc4f0910dec1ee4cdbd8e699e8738d96df90a3d98e814cca862dd6f8211fddedcfaae9260df350375c89a84f90e7d62b62931488455bba5cfdf9c31cbfb2afcaefa5433f79bd07991ce27d0de9ea31a634e34a9885801240746fb10fe2efb6fb66da84cb69a446fcfcfb72043432cc5d888fb14e074ceaad59cefb0f8b5c6c8d00f3ac8d2b9fad9493edac64522f57b666be5c3ecc48c82b0bfcbed99df298079fcadeb891157a09ac4d203d49a2fca62a33fe1b9676180c60ad612a6138328cb9da864f6fec2af1c685a509c3b92489032574bf6c9eb42a21618c6802e9912ed8f9709d1ea2e9f393f4540f8ec3af007565ec8e1ab7729d8a2a1565122dca9d196a677efc7a4a2279e054fa1d6d85c2d8d6d533ae596bedcb4baa7003631813ae3735dbeabd356e143a83ab05949bf8d6321a87fd45ea9189a045f1af77b8d35ce72568cc000c5cb22ea5c781a6d604f1205a171cf73ad25dd8b239d1ce9a7bfe745c390d8557f2d58a0665ef93656efa9c2589e747c3e75481b2a48abbbeb400a29b3218a49ca6b5ecb227514d7bd79bad6a567d271e366de283dcdd8833f5e49359b1e04b1b86bbc6b237cdd587f3cf6a941fc15d28b31ea6dfc63212025cc0c23811598b93210732f6bf2de35298645414d6db5f3125d054adc4d7eb80cbbe3740d4fc2e5fd3ec90d70f600e9a2e80f84f85b534c2b15e9ffdd37a1bd5ed9c1b6d49476d72cf6e01600cf79314f919ea2c647f69ac539a7913aab060a1e62a9577853ba3150dcb9fb759a9a4fee27b07b5262c165333c804860a720d2613cef7e462dc206a82ef986b88cf458ec9c6108d3cf3f15f88214ac5779b6e53600342c107b5050c5afe0c749de8c1f37d6e8e37c6ce7756a052c58bd86bc4906cd5eb9920512d63c3cec1237f17a9c70fb9075e90fe1ab7e1fabe06d507cb39e167059499c32b75be6aa56b2ca061084a45899a51858ba4272f77bf7df6d2142e6da5b71f1f5a4acc90201c276e4809af7f7b7bbcaa0a3d9efa1f8f45a5694317b2a7ca1dfff237bd34390e259061f5a92cc9bbb479cf195cd6a72777e4916f5494bb5439ff3ea1eefb845eefb898c71ee455e91b407ba6513554fb15678c37d683c2a68d40d1012ac1eb2352bb91dafb92c4f336149e42cbfb2b8d8947301a25857eff03e9d352ff133a4c22130972f2f68d5da34a4b5faf013274897ed365b3b5902731a1641de5b68388aa60c4df0523670930febd0ad6936f9b7f6ec3ebe9bfc71e121701cca01e567343e212263301f8ddb28f0d9c53f3ce88fd5b4d7a2d66beb4da7a030d7af8ba5a7601de390dcce1b92121f27054d4c5b4f0ec565f19ffc926ca022f5884a00a58cdc64946cc931572ca1999ef33dfcf3cf9ae8675b1f3381da3654ce9d9ab8e9f5e5fe593f8ba7ad482a5893ecd31b97aa591fc7d5c41e1a1f562d6c1fb5ff431349f6bf58b78e5e80e329964a0dbb84a5c699ac80df9fee9e23ab683aa368f59ec7b13dc1e5a5deac8f4efc24a615b0a6f6edc6c23c2620d64311037745f6b9d528e707578beb3b2cb611d1bfe3c3d9a23bc41952455f0046612204de33d30143c96e374a3596a927db63c93155895ec85d4449fb9ff6c8a3ea82572b3e6d240a5f49a6a7bb2e9ce5e71296aa4968fea7719e411ee239eb316466100b1a518e3ea3023ca80a407416cd5c34dde4b77bac554baac0ab6b762e9402026f078e965fa738702a4e0ddcd3b69458585bfb1b0fb31a7111cc11ae69c70d910d99272d5810c024aa268f0b33579a5611fb088755ac007cb88e3636190b259af1eda18877aec3cff8015a4e6f2940da68bccc4298df57eb0efcdc9d9ae6800dd156b3bdde42922c2ae1305f2d50c5edabf3a1894b4274eece5c3cbffbaf60b080b12c6d02e7f3ca65360dd206979c2b9d31259a1f1953d23122130101047f6a424d3932a8acaa72064501bdfe936562f40e08bc1d8dc148190d452668546e1001965a1966a8d91931c0c8892aee2d8922e25beeb1e82a3ab81ddc3997b6613457eb10ffb7e6e4999a50ece63c1e17217fad6b052606f59de24d235415b1b84bdc357f6bcbcb7e170c3a6cfb11fd9899e91db5214186f6fb0e35dbcb4f65f78b4f32806dd7ed75f2e9d784d298b35a5603c910b6ebfb19f4744bb5a69512e2f7535adfb154edf7c90dafcdcbabea5621e6049d53f924b6ef9cc3de2bf480a9e47a79fe166a206f69d91fd2ee9269c7acb4bc727e8a5b3019d82ca20617b773d77906d23b3d1266d6cbf1ba629f2d1d4e5b5c3b2c2d6478b0fd15c5f819580e5b61bb96f626a3cd9b251493d516bbfacea916be8d38fc63fad5b7e30a5d930ba73c2db6a2a6ceb8609194fbe471524c69b1cdf576b97d5dfc069d58ec1561a28e9515c316c2cfaa8f95549487bec86b10683b4d7c6da7cd02b61944bd1bdd2f007fb7caacf36d1783ef52626ce87a9208054728000aaa6c3c80706cd39327247822eaeaa062600e7d9f929f5f88f1a4b05041677d1f4a4f04a12081d99c116fd8e1e17e6e143b9dbde056c1b9b29a862b5199187f3dfabdc9bdd8b47d76860bd35a012b321bb5107136d588e737be5175559468f2b7a51b3f90d170995adf55a36ceae9cac48c342cabe2fe97b6fa92e0e0f90b7466f142f583543cd51dcfd2bdd3f2ec515a52c809d3e82d3df2a8f22dde73a809456d311c6903efde2eca77656de88189d52504bdf55bbb70a7e77db5e37059aa7a1532dd962499e16e8a3ed5263e74e131714daefa195c945bb0272f0502591673fbbfb626f3b409b6aa63c0f542abf4b2c02add2e59e5ca0f7190453a6c447bdbe18c8efa2fc3b878ae9a410dc6201061dc8bfa7cfbc8a1cb7679945b27e40641bda66d2fe0a4219f6aba9284357617957b949ea34a52a5a6ada17c751e4b8aa66557ebe78f7388c9baacc91da0421ecb94a0e972265163af12648f212f9932a2d415f339be86b188bae5a3725178b00c1963d9ce0dcc1338b42eaa52cb814c5d13b6d395a18097c0dff477aaf72d5a18adbe434d23e21573be8d96a468c686b15421734be53f0a41ae91c0583add3ba93fbee11ef91df34ab19434af4d5017eaa3a60cabc7bd155753ff28063917920f2fcb4726b32e5260597e685ce6ac2cc016cf727d6079be0b1d67d3d099e2d5acf881e8f07502eb3136a6e645912f6817604e118d37f385057052f1e5f86eb31146e52f56870f102315cd283850a1d829d92aec14e01a19b1b2b5b5e61b03636881ff7bcd2e715a8367dcc636d82860ac48a47f68cbf35bcf4297afe9ab6dc97233203b28b63fa2aab9f5d1a1920bb9898c441717c7f70c159e472ec67e7870df5e01dd943638b1ae0da61647d7bb76490fcc96daa19e23b98c5f73812c621a7c8888fefd4baa998900a35849fa1f6f7da531c665bfd80999338f3eb988905bbaf2cc2c8cb10e19cd54c67a0c3914cab9ccc8cf8f2aa474d9d30044a6f9a0257a5f351ab42616e67f2858194cfc29015b8d01f35533823dc55a10a9dcb1a2fdfcda5ad0fb77c96de90dbd965989b18b5a5abb2d5e1cf3129b005c4d12c598ac43b324762af844cd0823978cea4f8015eb80cb422702e519b41d8777c965f6f7db62b54ab3773285202d00a900bac4d37b4896c865825fdf5021cb416a367d729bc471e3e7692adb9b890ea8078f9c950cd19d710c31b7eff86d61988f45e6c8dd9e0e3d1db03e1e688b32f850f19cd1bfa98096e2889674e758f394cbb686b497f7448a6bc3730db3633d6e5d8b9bf5005462d11d97c66d8c8d37fc7045c5780ae2455957278a7d68b4ff2b79e79770bf24807968417601cebb5319d41437b4d3238093582617875830af545a76d61281426119b7b0fe001464a7918fddc3cba9e987a6a9f60d08763ac00ad849f7c2cb64b2196ac2dd7c74f2982fa0e1b3f1bf9548610d83bff9d5d3f4d20468a24424589a3652ad0a99c65f2a53fa9a654ffc01e11949d88ed827e139d84b3a0ab14c39261a061688eb902c4a8ad8357421a0ccbd7a7e033e31e3d3ac155e0c6c594ac80dbe5fffc3b1b03c4053d0fbd51d58ad6cf71f4fc9d7cef0c2e084fd3c2ef9b4d30b1f6a5e831aa9d4baf0b9ab36f96dd17d478f6b7eac9a59f5812149943ab5c9670f111982217fb88e41166b2d8dc2278b31d0a5e73d162ce3bd6cbbfd904ee63e30c01ba73a90fc9c1a5cbb4add90b735dab725624586833607eabd9f21caea7009cca183f9a0ea0ba2a2710060fa2e56f5e3e57e12e1ddd73145e2f6dc82651e84cd81743b7b2c74fa60dabf6db1538e44fd2acbab5ad53a014fff9cfc247e9a00e27426dbeb7cb1494c46ff7e1371e205466300259868deec2a07d853de5daa3aec828b8515fc60e2fc68e9425fee72d76858e98d6dcf38418c6f34dc1394b7a43629176dcef2c7e7c4291157a03627ef68edd2cdc2677f103e84535025d82ec1faef4650c30ac65149b3b04530546d67e3684682c9fb3f12bf3979545d3e38538fa4c22b2ee14601ce83fbdc9663b490f0470417ec6256b20c9a2f0a0ff766f9ba734d5f57c58972972c07480ac676402d49becb6de6e85e9bddea9a7a8ffe2d8ac543ace2f95eec638a2580f018fea6855e62af46fa91831187eeb147ba6b80010235391df32b12c6eafbad3b4c4c3e78b38ea19c3cde1d69837409e8831d12773f16347690f594ff9896c4cb6ab02354dfc743b6a262f9cece0ab62c3cc5e3e864b14222fbb3dcbf56db7a91e47214bc8e2a945b6d4f6b739d94c5984624e5e8ea5cc1a96c53e5b2fc499daa55ad76bfafaf5c4406589909843d0b90884539fe55aab448719bb78ac84342c2b5b2c1638180b7f6174528c95114398ede158ec79fcaacfee69677b2069928330efa625a8888cddba6259e7b1dd09d5ba54574c4cefd3133eaed50f78ef32555cffbb6ac81b2cd4ac1974bfe29509115575d58ef25a933cecaebf23512c03c1f756df2ee578f101e1df5d150ef64a8d8bc5915216689155f0a166777e6daea471d4d740a5c5a54ac13d245593d2a2bc8b6819ebf5cea08b47d799db85ac7009dc2939587e9c9d0afef19b14c23229d56b6b4dc0e1b5a16d737536c423d1d40d6d2d25d93c535b5409f6cf1a5f3b89dea29d1861bfdf71daf945323fc4c3084ffeb9b6437f91c35c9a929c6f23e973918cf9d7a8892a4412e29183900b50b1e08f1fb8e43a37de572c84e8263a9bbfdbea9c3705ce5df9123a0e78ab50d76715c12387af36935d8d7e2f2ed7c66dfe035f5186202d49540095d84c821dd34bb5599248838ce9655913e6462f5a649536f4a4c1f2dd3223da858319adb12752c3c35dcd7f2f4a4f23b33aaaeb7f649ebd9492dc812896b82b253360397d463c9d8d4fcb7860b75b11e865937f32001f4491ba0268ec314db191c9d48ba9206115e7484b08389c9b6582babe2264105e4c1d2bda8c196725296b232d1e90e9b1202a136f3b21937afd132ab198791f6270d2b8055d35e793a758640c8b3fa9a4d64ec0f0565d7cae6274d9bbf2caa3e21a2be76931dbb233ce81535bcafa9eeecb729bfdba7ee482393ec52dc2230a36260861f6853768f33713c89fb8b873384457a94e80ecbaba9d527665ac459006362e01f6158ce1cb44bf252504a23c3652e5b8a0026358822c52c6b41665efd7afc56a27f2ae233c313ae90763984dcdc0a603ee2e72d52b0f25b448acabd6a7edd831202b889ce40ebe447685acdb318b465e0b16fcb0af57774887d4b43533a5d893bcb898b1dbc488ccb78fa46f26bd19f98af6bbc62b65368a95cc1157aa851ac09ddd6e9e95b75833ce077c28c7cf95b006abb895dad31683f7fac6caddbc54b0f86331a37919f416c10ae2cd8afad3ed332cd4d63cb10e547c40cc202e6c249137b719837e2ea5dce64db9b2637b121763a043636f4ad959e87d8f73c81489ba2f0cf65268feb89dbce896672a8c35904c440c6be7ef76610f4270c2f9a96838ee7fa897810afe231f24463dbc96404b4d538afb0e77a9ec5098441ca34708e35c53a4b4e99c4cf6f6934697773cdee874f7eed57b177886a83bd39918829607423076aad230fc74a990490e00f1de680734ba95ba7eae27c4065a28f5e3a2a05cb2392548446a06e1bdb662743bb16a54af4727e89a5babd2550924ad75a01e9f4521db599d79537eac283f802ceefd053b408e93a95153fc3286c2e91969c0cac8f13ac3ad0c94c4cdeccaf33acf0249fc25fca18da95cb792694df720b77bed49856a6a498ceb12de860ccb83b11a711fc9362f4c3da46a99be2cd0b4ac7584a04a95505568d5bca52c1ccf5d9828fa14d54ea4d52b5b10e086c18ea64c0b459fc18acd6d91a1d36e49263b4ca861097043a67eed58cbcaf1351050b5fe69ce1500ad30c4fa00f3d6fc3d0f9fadedcfa0e3468118ea2b9dc8353bd19d0fb8c5e0302f219d1ea262b496fffa7a941771efd9884af6cd85bae362cd51212ecd1ed510a457ea79dd1e9e20030a96f00d4e4e1d09885030a81cae8dd484b9f17a936970dc8a730e729a46d31e7cb17633d9d4f9ef4277052d5550f9cb9ade4f658b9fb715aae3e0514b419d7973bc81ff52f68f87fe36848dcab4e156ae9b256bf6d25e78bed8797e54fba36d62968f6e12d25122a3d2a846d379f0ca1dadb19edbc673e60dc666f5dea7b93a639bc1023b4d87516ff0b00d61c9c78a9b8b1ace9e7a171a5911b8acf3a0ec88e37f5f540200cc6b6956a0142e927a30ff95e69b3e1200144f55849fe845f9ba4d845232e76291630ba8be5e9e6a1388210381270d62f8d98f1c64eab2b0d3109ab4a9527c1299ed22141525c7790e5a4d64bd45a57c5c85d8b9f5f7afb3219af1ba1493a8727bf71f07f54a4e1fdc050f484c491ef89da1321b57bdb771bdf8ccc76cc97e74246e4b8371e213b760ec6cfc485bc07dc3da4097b0068a8a36f3383529240fc45254a0b5dfc0d7c175aad286ac63bb9de5fb02bda9d3e8454fd72ad6ea1ad42d1a2941bb5c234df0652339a7d981a2ceb23dab1fefc3f15f7eac0e56f1ee9c9d629ec35046634e0a735b55231215aef6ebe45ef1b39388196d36f9a7a4bb17b3689fcc51c0ba22705322d8a5005506dbe630fc002ba8e4f77dc727480e175d8a39a7b68431190800ad8d08352e7a98570d9a3f580fac932e3ee3b7fd5b421f013b673c2bc507737e9d4343a38d7638505d60e2481c3c8307f8b0c0dd5fea5e73a4bd6136ea9db63b36952863f23d11e2e8698c3094a3e3bc263e388c1078c7a400fc14c9d5850696fa6883d8949ea57a5371b39cbca8f520f6904e1a08f1144eaf7d42eafb10052363f532968ea9e31f5884c1c05d691520ca8a286d04682590648e54e4985c4fc05e4ba1f863ab0c6345d21c62454794a1b99a24cb67fd9760a7a059d52b86b986cbb0903374b4732e7ccaea76c3e4338c0e401309b86f1bde54d44a60f8ef2ca0feca49398cb154dcf18aa8b52d3154bbc85c0dd41f3cce5c1acd2c4584955a4c419974d8551446cbaf9ef23c5d8526821958d2bfec4e52e5fdd804e31d70b3f4503f260de00b07f3530c164c30d077f2e810d814114476d3d566dc4b50eb580cdb9fedc8224dacd28fb444be06d3e37c4fa076d4a337963bcdcc4ca07169f79c07c7e864716b6d6fa900879b456e83a81decd90c5c2616c0e45e4ddd16d8bccdee242d880bc19401f9e0c49bd6fd67905409a3611cde978a6fd53d249c54dd651a980c8c8fe7535b6e1b80e9a6c5758dac6e63a1647ece2e950367caa1e057480e48014f81c07e0b0aea19cb276e6ff30ff75b5bd9881157d2dd6b2a8826ed2abd4f4af6cb0d6fbc61e9bd1acc9044101bb429acc781113d74d06447f84d7a5611388355379a92551f574c9e9054f5aca3904ae39b20501b21669fce5de029136542c092f6f165f47fa0dd61701a9d272ec3a33668103ef64f3e3cea66bd2c7f0b83f9241cabdde7d440b930ec3976de7710747463402056cb5325a4851fedf2c8cbce79213e807704f0d9298acde80bebdd5b8767c41ecd3393164e72b0edc15366ee66616eb26507215936538ff6632e1465ab72451f6f7cc1b280a9adc61bd99ea80a9d42f8ca6dd05bd955c595bb96d1346626024db36cb2dec8e71cf30c7c1e7ae6788d2c1ed5a25a6a1f3ecdc2aeecd0af495f709120cfdc07b0106023cf1597cdfb05f1fb7753df4b485da362b546a33c4508780f88ece2dfccfcef065c37c1b812f0d8859b72111ae83732a01ceea484a99fd5dde6712444c61a646a1e82f2af0d5510002074ac1d1cc172fe0c11dbf6a6ff8f1353cf8a686cde5d1507dca6c120cc81aaf60d398987069138debf8fc3920a2d953a4496da527a6a6c7b7cce6ee3d2bcb0a4e6a327cc7cdbd6a07ff0ca690bd533dbf520824f744ac8d326b309d2b51e72c3938b2c155c9f9097acfc8847a6511cc955fea5fd49e721dc345a45ce08005280e8dfc78f0c84a5b7aced4aef58cabf6dd8b0d53d25a91455712d9a9aafe8b51e94acf7eba237592df28295478b60fa81fbafc6b1a01efd75c2f4335e760cd6721029d4df6c7e84d6cddb66da2f0dde959cf8c8419c280662a46ad4283a928a65e0673ba38df7bec511c9e954f461328d9fe17397211c4bba73f57467a1674e761e3f5375aa28fdc183c0430a02106c20e56e91a2588cd10e884f796e64a346355b44d115a7a29ec41fdc616f4e56995b919c1b178cae01621e28f4f725b83bc9cbf559497251d07d2a8f0ca07bb9821da25c54eb3d8a70af1307d69ddbf9176bc86a915ae248d7cf13fb14da48a70999d5409eda4b6743626ffddd60c637ade99a25a996a1a05050290e22fe92e7a0d6e00ac1e4232c30dabdecca25fb6c39249de04fcc2a31b3cb18d67e13e5fc9432f69cb2ca089e22ed3a6f9b347bc96092a770e9d3d54368be42b04ec498d6bcdb9b04d29566b5da63ccaaa1b8dc9519bdcf16de03f487a0dddc41b7de86761555d299bf1037786c7acc98cf4383b354c176dba1b9fcdea28de461e3d4476cbdf78a6ca249760c6661a48ce74768bb03d2a7cccdd8c9d1b26ae15e3d3b0448bf6d6e7ab814a7f484bd36032c9d73fd7bb4c6394643e4c0d4c1774ae24ed5661c37f366848867a84f261a05c10264e21b418e46f264e021a616cb341b6bb5ba9329c4afc87f15fb9caba3a53095477286e75e6ffaa8ca5b38a0b0819c930070b2e97697c51a83020f4ac1686b5b8401bf27ddd8dc01a4145dc8b1c166ee8492d6759240dc3cbb6fcb79a4992cbb7046ed17e084e763ee011baedeb867452314ee9ae5b2ce0ad68b47a03cdce1037c5998e1afc6d147498e12a4707d6586ffd6e67d2dc55171dd4ad29c818314e1e661b54294903f2a1ee671b03cd85044419df6160c258ba0c126a33e8e76daea0bf1fc0cb374f20f5d3db80ef650d73564001cb04ef762895db498ca8aae0316384e98a43e734df94860f0ac4090f0b218d27b6b84ca45658b247e796797904213355e84f4ef997254e13aad93012e3ab48888bae4d5102d4923a3f766dd7cad98c884baeb682d080e7678e7ebdec6ef319933e685be6721edc6cde57871117b9fbce468b3c828ca1c55a5654e10b617c3e0c288e35ca0456a81125864cebf35f3f7a742c16d0bcf4ca7fee51a89c29cef7f4613b53cc6dfa445ea58c2c8ff47fc3084133041bdafab5d5b5a2e0df68d46c9154814d1f4fbd652f362c873c881f8467038ce760408b5fe396bd587d99b9e252cbff3966ce7045825e7e2e40397c35919237cd094fa8e3ce5f38e5ec99de60fb965e59f54b781e1e5cb1fe0cca12fe23ad9da7e07ab5666b97f9e69d70c868ab8f8303f0fc2834256e668b75c9bed4c63754af913c57c0605d36e7cfb874db0f38d3ad36523c96c68868ee64ee605da9ca3386753f331403765c4a7c651f7425b0b39e594394c68c4ec213647c5e0c2e825bf74b167e3bd0ee0bf9f68ce375948ae3c196f27085d4cca1f6f16e1dee8785292ac6e57c74244a3b0ef99095e8ed18485a86255cd6019cb6ae930c6818e1a923fb1417b7931bc40b7e5e83184550df329602aed257b1f0b167fa96424dd52e3bbefb591a799a2fd3760fa185052cc310d5e585e4a91439b7faeea8e4339445742a55fdacd9ef5561de78ab343d910cb2506b6dd252c92ff3af5167e56a791948252de9a034aea79eaba5f9d9df94a1f14eaa9df6a4a72afcbad504f37c31b521ff6ef9bd71848c89dc3e293c9b22ae1089d71a1b7b023992ffa28821b0ca1e17ca808ab3cdb4f5b6389d7f96037ac9afbad02a0ca69949d39851c7a1c8701a0df72fb1986b2027b17a17253bb5fdc243142d321c7689d10bc24540050fa2387da7b423c7443a628993620cd0eaeb52f120aa0aa897f023a83a6d6bf7042419e0de35dec506d3394ec9e71b4208660c0518a82870c1b26d81f52f8c91685a88334e691071c18f5a62d1cfdfb857a13ad63f34f46dc773d9a81e91b108041e5e9842906eec7ebfc79523d76b773d1ca224301463b9c40f6a66132c8eee8818e135d3de90586023cdabd83e8a31fa3101e899d80fd9ac8ea137d52ac9e74afec5d42bbc43623e8fdcda138c99db03319f7d23d90e77654f66f9f886cc0a5ca11b42f949f6e74783c08329c8827bf6a89d27838ce98d222773a7d0cf8d9660af618346ae51fd36ec376a6d865e7658a572c9489b9731927d0695e1fb8d0a223a921610f4bbda9b862b50d638c27e287585456c2bb2054a808e498971f736dbbae770984114110dd7e99efb3ec55c4a736eeae1c33090d363c07db7001f0bbc52a594f0e1aa9780b27a7bf81d584b03fc07142ed83de44a5a925462b9c5cadd29817034537766ba3789a1fe70deaaebfb7aab0ed4012770794005903772f638c6798d127082c544780e2f11e14600c6590372b192f5baecdd453aa4c05c669e7f7d5c29e73d55dccf8203cc02fe5ca38cd0d5c150735a989f248737983e0b0c72d5c08fb8b7f5f9940acd9a3391ba23b0af39b615b600effcb02ea98a822141cf6ce1b533bb9d8469e0ffedd56c98fe1110479c6f75eb1766b156c56969373b2e4612dd49a1afe91758987756757f83ec3318dbf63f6e685620979c3e8205c46525ee26240bad5f45d8c21c394555789f7bda4d9eeb4e9bb22da7c76e619408c31a463251fb76375243f37a23ef47fcd07bf343fd3664ee7237b6ac898b23f3b2823bcd0d0b2e67da2fcb5dd818b6dfd0da321ed87a088e54c4e263b03838157576287d33e4f24d0fbd29f82b513a4b77ea9d54951397f2e00adc052c8091b3fa4fbefb7abb9c5e545036e0288ac206a4365a7187ccc308e6165806b4923893b4219fe560e1bc44fd387434fd816dab20e3d9003743868bee636bd56b695b899b20036b78928e5e65d88ef5b0239d11f3fef3235142181d208548ac890889e8a6f8586b08d9447df12e4bfa9199db1b0460832bd256c3ca7f8e930e0de08614efc9287afd598ff1014ae23ce77f201bc376dd6b8fcc7a4c88c907a55a7850f6c23a408320c72c3075aad1d1a188ae419cad6057a8a1f03803bdccb145953ebf7c14defd652e2a7ab02dc86cd74da67b6e54e89260827e3fbd7cf0e546f2a402a9db2651b50afec9400e82080fdfd66ed81b5a38992d827c4f5636d6afaa6ccc8650d591fad20d95ccfb578aac931fa51733ef811adeb2fec4905dcf4b4c8ba243b2c480b1f84a87d49da9878dd5777c393f1c035a7610ab51d147411f47328afb5f061f130aa8693fc208c50327702f28a2a55b74cfcba91ea679ebb10f03f66bfd0f34304699c106106b0b6b73aaeb45f1800841ec38ebf83c40d93df6ae09c4653283b271a2cb62a40d779ac6e2cd3e43f27278f8280e4c56a89976b73d6de259915c47119be647f343c5103860e2506f6c00b6347ad65a18887a36f7da4f371d31bd392475d15427c435601189628f5ea1a0662e6d86778c397aff962db41bdc79333998be30dc8660e04e85d15733699f0dffc7602ac35b49d283add0215c64dcd2e4c4c56a23e77dda647b4df9c9bd8d1e066d208ba3568dbe2c00f128873d45da499f95215c0e342658a1fca8a474ed98ce81a5f0b18decb7350fb7716fbddbe6db8818b699617254d63c43b37f5f7b213de2fd127d28ccdfcff09b415877f3c27dfdb52367330910e106dce5cdba1f229e93a58e6eadb9cb09a877e99bce233b8988039d173815d4ec7097fa4b172ba465b25ff4398a69e9d0b2381840dc4a134d1ecb95ea1119cba40296e398e60b17fc220d78296bffa862b729fc7d9f700f2ae20f59b3c1add4aff8330e48cb7497dd01efc82f36b86d6756dcf1101e178e92c237f738d8c4156e973af0f739757418855a987b5e17ef100ef8172acfa5bc1347c3baf1e875d69c5759959ce74f7b9bcc25dda38ce137a95389bb0c551f617a8ba495946e5ea0566ac62905d94c45a6fa310fe5bd3c147e76dfb57c808ace961ec019e9bae4bb6a95ed540ee945f368bfb756416067d20c21597bf56d3672cba29014183a1dc1ef87632353be44452ce1153d7e16dab7c739d1f8a437e59fa7e0a46f74bb217f78f01e287c246f32e70f1e2077386efdfd9d53b638e6404e6a72b5d386c868614cdb1b32bfc5362be39e94af699c2c290497150fb28f89d5141ae9d5853f984f1885daf0bd4f6c842500d1f23c705e0b8e58ad8833740bce32eb775fee798d359db7f7524cdefb3cfe9b5f6bc9e287e38241a4e2ee65454736df1c6443e27fa26ccb42f39bd516c677ffa103c37775ab6f183a26fdbe408056e07531c481d7a36fa401106a304aeeed53c091e1d3493b65209470ac5b0c8b3fc2c38be4223d103d7886712b344ae70649e9bb3f91252c26d53c5207c0dbd9ee7947d416c994b90d9953a845920726d33887932c7ba46eaa1eee7d2c267883643f8afa51c11a782f6987d9799fc742c4e252e7dd049f12dacca7227acb9d483ba168ee4b5d284a8be60cf9ae50f9f4d44e3125357d0bc91e5bb6b4455163241d32fc5dcfe56ac43c0e5ca9344e68b1207f553da9fd3e9ed52f9f237b52445e26e88bd2765cc1dcd2ac1e7ec5cdf201aa3d404b64ccb48c096a0abd3ee9c45e21ae9762c5297f41740b2eacec5af7388f4ba441a6ba4c48ad431b45cbeccccf3f321750138cc19fed01ae607d3dd00d5782573904a3fbd883c102f125315f4ebf87fbcef3ab8c600df7fcaa1e94432b9ce5a745d40f131c545035bcc226cc382ab5bdea86459d7867f0b878a4d9535f949e005bcc203bcdb93b93b360cddef42c68b15821ee0eca2480cbaef42d222013e01235ddc3059ee2441d2636a03ea42a0ee72464835608be275f12f50d47290474c79e0d42a069aab8fe5c692923c8190e51972a172042ed45c7b8367c7c5edea16ed360f1429f4e7fa5ac494ce3afe43d48ce86267b989447ac6bec1a9f95c51f42d218b09ccda69c11e6cf811ffec82a60978d715ceb735ae52d03dce90d1cd425b3c2b94a72166819c15a849b9955247f6bb793333cfb17a31dc2a5e6817169fb84edd36fd652fc0c7e226774dc3ba275d309ead7d0b7d8416177dd6beebca6f72c606e441937266b46bb43142d6b6bd7988f81fb9e12317f8c28f838ac0fe58729c238698628e3fbf140420ffd60302559a5b5e0aeda6a03fefc00a2024e8c5430d5a791c5f3c7a46d1bc835b218ef27171ebef21dd99318ade65e32807d26608dae10efc38492df2540cab7c833a0f8a5a998e7ed04501f933d1d9e95aa9ae7c038209637149ce8cf5367d04eaa7de59fa29a97fc442e9114a668cd9c13c540c31142235a90ebb6bbf33f38ff34f677dc135e3470507e82f55ffef864c60d2f635f187981c21b3677e129b85051eb95c4f8c916fc71ea183333ecacf7cace9836666595015a85b65bd1f1634bc2d6428962340875519d8a30cba3867097d1b48afd72ae75dfbbb6dfe789a40d0e2fde5d1432d6a7bbcf9ad225e2aac1b293079a0fe85a9ff8ebe56ad097165cbf59d8ca4f1cb6019ba91f676b8e3cf012cb252dfca6670d509b5fb8eb7788026626231e9af411309f7d24924697b4c8f1a708aafc4be3bbd1ed505afdba1f1aa5bed431093e94bbe6d14bc905d5caba5ceffd48676f19c722fb4440e0371493192e3da1648d3894dda4e0ad904c89b9f27347adc4e57f15bd7d0969358824717146c106b214063c2a8a18a17355059981babf9a69fbe6cd43b0862010802290711b76e4f7427b8ef11ceac680b5e62c99a44bf39dde6f3bc66219cf15f3347ea97746c8f91b3b423eeba0acfaaad7e78f3a0e7740204c75dff42631a77e905212c58f9966cc2a36988f1085960cb1530faa814790c40fce26c78265d9f0f125ab79d1a3f94689143a821072a5d9ed53b37075251d436cafdcc335e62ff22f0a2ee7f97e1786abd051b9a2049e9dca8a3bfab09452979a27430c7d4c341b4da8bbac0b5851bc4dd3d41d57c57ac91fd1e2d4808c4f20b1cac3eec7e0767eaf078932406382a2431d087ea2f906b9d5bba5dd4911e4de7ad72b83fe4ec6dffb47a0cf640df3d6c61b43f18abb366334b29410c867b0878399951bf17cfb3bfda47f88232206633367cfa41bdc04f5c8bfefeee94bead1f65220050401da50d6632ad99b7227045170e6d6b239db37298442e3d835031b0c6122f3bb12b945d1932ee10ca495d1f5f3ddd40a90f8ca58230ac017ffbc7f5dd2b3aac92df523a345ee8409d304f747d2a4a8ed9ad9d7914e9dc04844de62adf1b37331af779c281708588ca7ec6aae994d2c93e9f3646499cc655d0324f7f4dec574453f01e25b72b0dc78d65725de58857843358ddb7135d84c968ba3a9a65b921b777d0172922bfb0e211d8f6dc0e13fdfc42ae804c74830375ad360a1258fc4948d84dd2a9a7812444cdd0ffa7c3e3f58d19e8c4d8df88db35fe2bb3f553f24b18551e3211129edd59ee35b0f7520cfa3a05ab1b03f69a55296fbf064361eaae2a666ce0e4af8ae212d82efb360040e42906e86ec9875e66328d973f700b8485e7b3b4f43642665e64aefcbe82d54234256f2a49f9ed9c717a3261cce6db28e59b3f8ee5333b9450c8f2a7882f4670a01b16ea8fb6afd52ce96a6a2180a44af4f51b1f3e964c32c3bd3015c042a183739d14c316fa78eedab0680578119a30b58bb53fab324641ec42ba529cf6530c2f6218b58c0e617b68c288a5c6db3e5de254ab8e916d449b7e5c7431a83bfc37cec443cc86148159a55667e8e8181dd7082c37f783c02e113996b37acf324bdc0f409ed5b57dda95f56704fde27551de8b53266ca0388649737c2855e5b2b7ea61fa1401a7938dda5834f81a6892e5d864ee61d90ef8833a011fdcaa54c600b863360b93c9f05fdc94c0b7fb4f83fa7f4185078e9cb5875947943ca2332d80c177e07a07d6059382a453e9877352c397198311a1b438d6d9c275397c43d94cda8805a5481d950ac34af7c82a7d7a4fbc74ba8f12c4e0a7949a5e70697e712deaf95852dbb837c36ccdfb9c7d956d250d60dc6fab6e1d877406716928b5ce5aa8b2aea3220fd7985a69743a3d7910adc18203d6ddd7f6fe7d7cd3e37e668112fc5e82721da1355dc806b799bb713a6af0d7290528a98499cf9b2c32e06a4cf9ec4172413fa1643ec411e17a3fdd38071353b1d7bb6d752e33bf2ba7d246a54d4d70bfbc46654d7df61f4f1a04714c2f111cdcc76c518a811afa0012e6f636ea87e2d1ca335f2a74393a26f5ca222939dc1e5588264f19312104e04a4dd05f183c90b12cbfeb0bedbb35cc9d31b479a1e561a62c6e618bf46d4085cf6ca1b33291b38eaef5ee54c8a7856da03d2e5755faf5c0e1af55df2a8d9fab6ff09576176c6539e8d8e93df386537777d037d6cc4c5977365b7926b99e9394093a82266bf0fea88d27ee51aee0791e90f51578f5b7d604f40f760539f1af85563b22efaaf70f764faf97ef23c931d95e3c51b7ec84c181865d58367764d647c70c88350f6845614bcafccc4e5de1e383906f7f8a3d6d70f5d6ea07422d06a770d36e0e3e954dcb0cea596f30657ebbff41eeb2bb5568356c7d45d987d4f8f607c866c5cd14a43b1d5216b4579665a4772faca3acb5cf9752c3afa2c58bbb89ef70d75997b031d92464a24ab7305c268a44409bc36e8843f5a9b96cc5305c3a5361a5fbd860d8f59a1f9a35ccefae8b33be4c586b25cc49bebbbed4ac9a92e5540fe1942878568006b7884c148a066242e7bb89adf9bb9dfde4db8b5b0a08ec4893443c366b6791ce5ca4bcd4389700dc3ef7539df89c97416dbfd819d87fb402626ec45edeabe19aa9db833002c6fa103b96cf9160f8743f93a01597b8ad263154b72d0ee3ad4f443e98f68ebf3bad8119b689304219d24b8d1a2e3833f72fcb8c3a2ff28e495e5583ac3b521aa3b6127028034848483863f09c25b623b7408c1026b3fc56ddb21aa8fcd0ddf8fb7ab16fea307ab0b58cc2bfa1900c61dbce8020b35936d8e89743439502ed15849f280be3f9b6be389b0fa7df19b8e3ddd3a2a935f360f82b7a12370c7739bcb1910474babb8635eb9411213dfd44052c4b865b8a086a88eb6d1dbb3aa571e0a2fe879fb9c7249d2e8df98c5f8e2db307b81538cb52add2bba79ead99587f13b05ab0c504e16963d8fd3a744fb108afcf9f5eae9a4007bf1402558ecb301e07885c4a0c30c2861e1940f482d161083665096e928575b776fe7cf4c42920c29e557f16d021968e7c3217e7f4c12ac8a916033d84f44713b258b626157df0cdc6f782fd3d727fd1a936250179f6ae6b14101ead97e541081a9a781b6263bc198c3fe9542efc100738db7374cde8240da2d3ef944f2fa16e67682ba9234774c92d7e7933741fd248d0e0ec5f96b2d47b69a590dc3d5edb2b2a155dfd2e375a73236ac0d51249c2dc39b0e20731b19c4a1e271daada56142562de41ddb45f869651878b120bb2d1cf7f94879e857e6e2e8699399e64c5a70154cd2c76975f6561e6cb6ddfb2e963603f69759c19cad0accb5a8620dc0da4bd433119be793736c898303fe5c8acd13869ab27a9e4035a1a084230bc6bde4c0cfffe26642a1a8ceb43389a24b6bee779ff997d13aab83be99e69638ccfbe968a61d115514cf8cfce18405faaaff666959a7b3cdad8f5b54744d3d0b88df7aec13ce2ccb75e3bbb5ee0963054aa7683f8be2c8c4434099d0ec9112d0212f470f94d16d5b586c6dec707eff4a4520e66864dd2780ac776dcff05ceb25efed2f1da2b22df83bcfd1e1d71bc57a97a20ace298ea710de30df054808d9ca64230f7e255e13b363e46324e427447ecaffde68be9fecca02f9c6b9da19aad50cd547ca4cf335f0d6a2d246e2c72787beb8a18c67ae63f6208dc73ed9c4faa3ee7df2fdbf11967566225d549e57be1fb8d373b553ae368a2aee1415c5b4edc998caef24d5b518fdb1c91794ecd783dce19babb07d5df465d0f79a2d2096190bf543d5d812b69bae4bfab17c0fbf88b435dc7f910dabdbec21f9c792922d8973dbb013a3af11eeec76eb10a402b948fe1fefbca33fff1174f12683b98093cc6dedb3f07d0f6d8d609e89182a340fe4eb79d7cf6bccfa37e73e6bd71739e1177c7f3b1774fd63d3f0e975f041a66ec96c1f764ba4d502583ce14093a3b4f4207a239eff16c7f3c9b58fb9fe6a3f48a745fc8fa467661de9af4597dc6f9947156dbdedf0f471953815c879cd4d8a551bbd650bd4020ebb69cc8e17adcf1ea2a4aef4bb421f969862ade58d54efec77884e8bcd640c91aa2436455ae559d9d5c4cc5e9c5a8fdad46f6e26cc1276e6e2fa875d528528d3e2cb1908df09efb0a05c91c0a80db600972e531311a084dd8f74833b32a770107d4eaceebdf3a302e51b209c1ef25c3fcbf1f64950aeb90873c466f631124de398755f09bab3e7190acfc80c1e1a42b88246d85fdbba057c245c9e4b049c1791fd23f3f408fd445f96b21f58e85acaae524bd44b8e54b8d7834bda0821d2a1335305737ca0bb81478cd9e02966542cc05aba1b4da35e4e2c78c50f6827b32eced7333ce8100be02a101732cfe23a2da37a0d19ba3a4b51498277783003c1c348d6aca4b7d654a2117d3a6a846d4baf0a77aa455c805e080091867453bea20c262b8f9b20b8fd6ecbd4ac03c00faacdc9cf49b424d75d70db02e1cbd8f0dec9ff468feb9d38f701b2c604e2a362d50d29f57d7c8cb8fe260d449d523322a2064dfd50053a98539bb395f612b5825afedf7209ee447c09c64358f95af6b35d15c775685c45b5be7a0c32c0f7fb77389852348da48f74f761f0401a4e78b05078a74a1f951fecf4326fefdef05e986d04d391b990f9c4e33da139d0d09005a3e6833e92e746d62ac38f166a16e9ea82b4a5b788efa54dc6a96785a1e7b4274e98a5482d7a1121693b7f7dd4472c8877490a5268e4305d808d50de7ea5394deea06c5530ba828e4fd225cf3fe2014893adb423415fdb577cbac9ffbcaecb2e91cad7966c8920213049a6c85783e158840ec908abf0293dac830b07ad886fb9eca1467aa6e25179b5629a02a5faeafebfcbe7e5ccf796536e526135372ffae603476806d40e3d237b469a7e4e4f091f0198b8eaeabe1addc600eda4cbd9447361155c710e7a772c0746e82f03dafd2d4f59625fb5db4bff546764a7c20ba12cf08fbb53eeecf68eb0004f6302258032024da13e11497807afca3d813c5fc809935c28e4547f10ead553efa4150cc499beb6f7ddda11aada7ba8960b31bf8dde9ab2f5a3fc423a6f88557fcbc0a1b53adc6d98f4dfb0bc5df0c0d1720565a620fecdd9d609fd9e7c835de0d97934e31b6e211ad57bb5401b34f9ded85edf8d1627337161ef247a9fb20345bcbb54876b7a36df6e6a06bf58e3a1a62001cf517ce2a01fdd8405f53ba925c83b53daf1d0d205061970d55be69520af52d60f09208f4b4a668eb5331dfed1aab987ce8173ca2acbf4b8633e1967421c0fefd5003c824ac8027bbb6d705286165d1c82788e32959662a37683bd64f17e7c37b964d72041aba205d1d26bb4b0ecb19f98907aee7305be86d43a697e7cddcc225be827050d6219be15aa58ff4fc5b18ec417fb8c206359e1a45306014c8b63489b7e01fb8f702853c4844a5d561832b04d56b44d66717dd55ed0d3801f008a7fae8bc81613e0a34c41cb5af337ad904a4679bb3f12d745dd81ca40aadad032911c48a37654e7e83b756ed44698a7c30b619b9bb16e27c6c80054eec6d4dce8c286a700c4eba549ab4338ac9632c1b1627733778fbee6d30d1aac04b68b6574ade601b4a9fdded893fb91b3b23ee895a68e06b818aa31df770f22d2f1a71173e9656c75a4b878185424d98984040fec9ef3eed7763057905a74489bfd1fd7893f7f6a8c63c7486a987de7aaf62b4481cb47987835973d8c9e4bc8f8e337beba76dcf2e6fcd999e293f9d4da2c78ba8f5b435561df11756e63aea7536b69ccf98a743ca065140d2427e43a393c1951280728ed81ce62b9043de1f5d2c27f1bd7b179232288aed237fbcedc07e365e05da71e20f68a808813fab55f2e02479dff575e8531c321fc7ae55837a6d1fac4461bbaffbd6d80a57179f98d894a28d52043c885c5276d5837a0aaf03e9095016915d8004d3cd4476de5c0bc1986716d64c2cfb99c975ed109a7e67b7b99742dac4e8e627fb12010eb0a876520b9010353bc6571831c54b6f88ba0718c8fd1218b1f28af79de514ec4bed6942890d652c85d395354defd68f07aaf7893787a55bce9345bd2aba0278fab9eb41ae200fc56bdef29a47ee41cee39ee48aa110427b42e94d56d3b7ecff663fba9fb7e2925c36b5664eeab4a60a2fca8967ae8bf2200e947597783557c11ad51bc213bec3d5f0ec27ce6aa6f06b9ac608b2267e31b1653a754ca345bb5766743fda2bf4daab6b594068561b1715ad0ed2fafe82e8e825044924bc28e97ad23b2d733f17dee1d999314065e0275755831d8ecdc5becc451f9d1cedd63a37a4ec46bebb9055082e8aa9b475b7212ab9e8f2379087b7c3003d4a3e177996099c6e58bf121953d384cf4617b6d39ef63966c250a6a020f73411e2bc0fef4089da4938bab842c8fa80506de80e5d4ffa56088d9469f9d0511bd64bcbe74b8089c02df88398ef2c5f79b72a0934f343d178409d86de0eb7b80fc970b75a530eddb36ba59901d775acbff32a955f2308eeb760cf638b73b75699aaf81e9e045b25ed7a991ecd075bf512b9bc569df58c0a5f226ae5a24cdb154440164fb80a9f57d6745a24395eee0087fee506ba5ee3db4121875656d3ce9f25d263213149bee10c960bdec30e8244c67e88cb5dcec692ff5d0bbe50d5af7f19aecfe76957fa98cdc36da12221dfc3993896a595a3f7f2efbb2f1f13352c3fd9a5983929ff74dc6b0270d74af2cb510ff055c113b3650bc98399122868f098168d5ab3efbf829578fc4f3e65b0e2ea6bacb7dabac72ad902e0023aebf8651aa7be2afc7a4acdff687f4a1f6edeb7245538b9279d1a555f9d647350ef02c2cea196c4a174084663e0fddb5937d650eb41a2da7a73de81fd348108d9e3b763cd08f5c59daa91e8293b0d91667b41ea0650bea28fb5b7470f40104eae39de82c539c1fb9557364dfb9ce966b3b2a00e2411a233b3e83e711ee8ce26f4ab512ee1e964be29f1780bc88eefbbfb66c7fc57bf2bef3a6e7f073230da442e417b9a99e2495edeaa8eecee2c21d07dd25c5e5b8e772b7b177b2c040139327d4ee1bf560e62a07c5ce4ede500a5d52fb35c4ef57b69f72f09a7c5284352e943859649f4a4a54af1c2971311e54591565c97af501729ef89046bf66e6673fdb719c4d385718ac00223f90ab1bcef8a1f3b2fd33534a1205100a56a07954a531e9f2a7af43b8faf6d2d139d135d36ce20351d6f62640100d018237139586c69b64c99b64f5ab4cb3aa41ef16fc0cf3ae081ace4795e3b6c78412ce6b0a3d13096fc768feb4eff9b5fa9099f187e1565c4e2fcd6472f87c374cff8edae135675f85b3c16a621fa56fccef791ed8e8606116780114f2fe10797e8337fa7a93ad6bf72f735eed330cfc8f9beba379844fed03b81bede3b8613581e7ebd157aa14e30dec9d165e8b36f82e66892585295e1cf6198ed27a07bddd800ee23918d144e21d96833397899486dabb56cf723641c0586386a0d7006ce17428b7f6daeff602a729ec985b97a2b3adf989a96b5bda112a322e2a7d33323cc15d2b96ffb32698c1ec8366a2bf4d7e326b65cba14542cb984ee5bb8e7506599d6347361df6166d92e58af99d5273855cceaa50bf9ff0e64c089fd826471eb8c9d956d8d7ca4ce9c8854a88c2a3aadeaa7c4ad20e138952e38b122cc31ed6f1765cec66eb2f776866ed4d5a824d46b20170553d5079cf304c87bc3f16bdfb4f4842b031da3bb0bda0e8779fa27a3e8fff2244e5da66ec8c24ece2a5b23a538b3d0ede73e05331925062f01590bd9541e79cc337a92142c71dfe5fcb84c65facd66c8258e9e08a47d0220f5106daa2a3ee25c477f0b99510689d18dcfed834e8a4a67d335fac651cb39c5366d20cfc9e5f1651d0d742ab748cdf587c58f2cc30b37e4b795cd5d21dd731b8fb91206247d22300eafc999e6b79188e23065cf1450b650653485a0b34dff348d987f8f79c4313678c4e6ddc59c0f17285c5f9f32056b3123ea22c9237806b6b4c6adb025b6b9a5d25ffe9077a30a000d7ea312536ba8fea88eedf36fff5f5afca4b6337b2532e28f054d70cba05ff755dd6d6518b5e7a5a8b3719f71aa246d9c240ce3b0ac2f01d074acde3e65cf850e1b7615c59766062936fa3066960a522dee8912debbf44fe3e393628dbfc3840f1d556780fd3e76b0b0f66f0702c4fd15dedf1607db71c99c5a1125d110afa4d55242e1aa0b943d3f18bd07343366794a300dc73971a2a274147475331491eaa74ebbcf42ef04181a0eb30a28392b645af57403baa2cbc17a14b3452dbc1d2c0eed4dbf582172b764b0326a458db76ecfaacd2b3e188340195516aa5747fd969784ca05941546408cf36d816cd46adedb10cfa33bc18beea63d4c5fccee9e27f1d79838c784deca81ce2a8ae442290c59970a5543e386cec947e04216d021344cc4c7b394c567e3c4c37125d46479e815fccb2f6e083096a9fefad4b1f4e9e514e6b41523e5770b3e912fd7494dc87275f438a0d99e5a31f2c16ebd1d9991b3f8add6c1e171fb37e9105a87d46d243f5dfc271f345b303ea6f657467b1509f13ca0485f5d2a924f50945f03ac98c5fb73a44fa459b03f8ec18f02debe09e24065b8365924024eb0d544877969ef46e1aff9802d00eec1a9ab185a9670aff4182a2b2a5fbb2ee3aace5270fe4fc08d4535e0983b74d8204a7aabe4a4fc72c846bf0087e3a12ebc026efd0c0a2594f60b857bb55265cb2bdf037d2ce493366b686a413f9e66fc10727ebd4dfa98ee872dfbfd057dc2b99c0ac2e886529ce0ac7369aedd09ccdf1425ed1c308d3f8398389d793cc7a69c852284265b91b117072e29418fe5fc8e8a3b24050c6818e18ccf388c42c25523ffb3f1136667354ed3b4cbeabfb4d091924b358ec992a7d60e27d200530448b6f9fadcbbfb3f707fd3f6fe4d343d201954dcd39820f89d10678a62c003a6471f62696585f2a541407c37236d470c2abc34ea1fbd22ea11b56fd4e6ab1cc49c68e329ea34b7ce6005e18ec18618ef06ceaf684058179c47fdecf9bd3951ff49c56f93cc28040d2dc19d67529a027a2e3d82b8cdc220a60910f77d57f013fe589462b6027cd95f0e3b9b02544fac840b2fcc340cfa3885919e86fa3118c4e836d17dd579f89ee065c215f3b0385ca8a0c9fda9f645d3180006249e293f67eb20833de64803cc540e1fe0a076ae02c53cdde0d718a6d72366f72eaa1667f9b9a0fdfb13b3ec0c9f6ce176c6dbb7977e3f60d5f2390fbccf5ce832f4bbf91f0619042a3dfa4da04d10741af596bf00bbedee6224d7c336282ece426605dcb40b62226e74015f920be490d00f850caf2656c195096e51649e8de5647c963a300676ccd680bf6d8f2ceefbdfcd9f388daf45c9393197fc4285e088adcaa8e970b82d176b5c81e14125a1a5133a44209f094ceaeaa1f0a514951657c6743a72c4e50c1c4eb5fc739310bc96d436c903ed2ad07d1d52d8718f6a122d45b58c2659d71e5a596f328ab42dbb47f4f465d5efcf3495b6b1f6bcc405a2b36458f2d775dce2a58a2021d77f5dd845d37c68edb9f60cac871d99274d4907846642ee07ecc4487ae29347b2aba69b476a2abc9e846260bc056ddcc1977f102525e6a1ae3a64bdbc5747f7cb3db2fb129e2dc065201a00e7df67a7a231d2c06222cf8bf0c015474656ee7629e14f0ed730096eab02eaea21ae4a75737ad488c2ac1a965d3135b2c3d5eef49211f048db9515d05651e0c19ecc45f0ba81f70e168df974932fa4cdbe76e349dd8a2a51a6e6fec7a659d04cdb9cfd5bf0b715886e0b31555da349b7e23b1b8bb90d385dfe3a42250e55d10e8ed10bd0a1b5e99ff2009cdaaad58b38cd65186df456782465afb60b0c3cbeeae01e7c42379a94f1581aa86ef8dcd932ffaf12764f19ec5ff17701aa3aacb6d7aba44f621c6b19100965d7de0238221cbead73005ee5badaa7771e400e949da5a1acfb415b6be01e25bf3d4be0b65d8bf84d590d102eac12b6f6de75fe6b99d1a0e2e6d1f19a37fafdc80565d8fb03d57f9d17e7d403b168303c64011442956a9a01ef2a6c6cccefb384ecfc95ee90b728b7b4937fb35ae13502a79d14c2c105c10be5a88d46340706e7c4e18b750618a5716a1757315e759bf5f350c7b110c3f1880dd5129768da913af30ea7aa69ce28c32887fc1b16f280b468030b0eb86189f2a020d61243fe055df12aa88943822b0311eb102e016a71097a65b912b66417684a6fe13e05fb088cce55bec72297d92afbf0c4284235f1726f2690fc4747a104ad713685d3d4d6ada9473d1d162906f5f16ebc9c1d829b61e47a9a4170c167b0dccf57e73424d7bf3abf88cb3419b046b2b5ef797e7531f949f3d451781c6017e023ddd795bead5b49408f92152a6c992fb374fa71db3c8b60a205af6997d38036c49be3c6ee871134226e9a572c463910e5594fab672874c293025092dbd6a04f5e2e9a7c3da8ac6eee180f1b3beb07301bfd710086ef7d5a92e0d007818b200f61e594cdc97255fa0e1e4d85082f1f1d0a889feabac76de73ec4e61fa35d864f376a92b6317ceaf4cce287403a3e1d99ad7c4f099465ec7f764febf584af5b5c529f5c980a5dd8089ff0c2f7d50f1d1c7b7be99d28bf8a0709e518e945a5e975048795b7e94b2ef9c72dd1ddbde75d4f64ad190e2a6e3fbbbf3c3e1ca602ab502b3b97bafcbfab1c451bce263dfc6492a97b666584135badb30145f7da4c9d95aa3f4a2e329e09da0c722e8ca490f4777c7f95d08e5e9c3df474e4a473a2ef62b6b93403f2b2cf319db916cbf6168c4472d38022cc99bea67d4e3e934dfb29c5ed550c0d667a9d34dab11f24a52a4576c63039503bdf97717f56f1f798c2cb4545e7c3845279eb873caa11de5b76c9396d82b4f537569e00f3706247edfc8c5ac10865847ea8f0e34f2069c0ded6cdf0f5d7d3cfea1c760582159abd6d6ce1f0004c058eacb48598813fa899f54cf7b33de23e404abffb07bd6d19dafd6419e997becd06231596063f1c92b968904eccf1636ecdaa5d19e4a19377e08542809839d05ab3c43aed2364c46d750d566f39e23f42a3dfe4964a72aa6c5747b32446b3e3b141b959f4f8f97e58a6e29a702e240fab0debf9ff3cdacb2d8941488bb0b614a9c2a58f432445d57f2a3d861b90046942ff3e7bac936603a205a6fd678774fce4297568bf57243fd56204b5667aca46288e8db9f27a4bd2051f5dad9fef067f7fceb0035ad8be8c6eb3feff53bc492d1f7629ca8cf27af5076f9a9d3e00aceb01ed685c750083674f052e0f3f574506ac93f694444c0b68474e819dc548d0f99b26ad7552bd7484c9473c4c6302a2d3f168ea7f0cb1eddb5f5cd9612b48e96c68fe946def10cc61fae9f705e0a868a61c9b1cdac49df4225ffdd21334f21f691f5dd8b8348fe3a92e60e0d6c9e898837276676810602a4293d6db434d32cbc2cd0ff80858e476951ca5c2a0e894cb208c6898b5c49c77291e5583b2f062bad20743f69ee94b31e7f7b665af9932a5a2ca823008b5ca9949a1276fa1acd34f99950f9f0c17188c5a5b1447d4ed7e18c7dafbb41fd1b56982a0c05f9e544b6b3ac5e960a64c2ffd9fe444678d83e67825f9ad8f1bd3fc7123f1d644fa8982241c682fb527858a7540294e2689cd0c5d6eb6957f2d0294d5f8a6e6615ebfa45532fea1184c45b72f025c4130196e4851d52d5699f9e145869e76ae823117d2f540bae1935e7757cea893ad796610245a0efbb7d7c50028cb9371b13fbf00a0431fd9fad30119a1ca2a25274c78b0de4689c0203cdb782f17c955b752534498bf453dd6d2b2f3dc32b6ecc9626093e9d3d4b9217fba239d2fa2674afbba42b6f6305fc70fc866e8b81eb2af161e496c9d53a9ec5006f08aa2a6f23973de88eb1c636aff57ef9fb6108f0e7a9b0af2c1e1ac6bd6294545608d5a1a1873647c9b770ece171f6c7dcb9e975ad14be0a9f713a39edaaadce261b3f999bfc691d21e98b29f8c6798bbc276f434dc05af6a513e3a14168ee8311ee40e6fc7f1d6b6426636ed3d3b6afdc7a9a423c7974ff2c534583e4b27cf9301b2213010e4bd02c7fa4883efb3ffb51ce52caa453c28357e97485a6174b5d1c478f4fd3ebe29ade24913bcc99373f797601ff10a2754b15ba5cee6e1bd3473f8b30c9337a61aa3bb9d84a1d86d7cb1221d43c4502180856ddeaeda79c7f36c80a57ff2a6ab6790efe0c30d8c5e98f83b73f43d53360e877d76da247c90054a134c3d9c7cbc20bb0eb98f7b3954c78471f198efd56f52b38397a63a5fa42fadbda953fa69a98af81e7197e797e715b5ed8a40b89ba2fa3f3074b9db3dfb79c95e5ae4ef673ae7ee16b4167b43c47a0be615cec3ed4af33e652a97be546aaa3b297ac60f30537b4b64173eb73ca1c8422c1a415e1a795b42ba75f88b86a48d8027dc0e06c32785506875328066c9b6d69eeffa5ff2cd59adf831556ad9ca2f1eb290f82ce3801423f617adb50a344214b42c19f94a87e4669fad4c5ef78c6678fabbe71a9710f78cd8b286fe542de98ef6643f8b7c9cce7361ccd5efafd94e3383bc8034acd62a7b4a2eb70bd48e832582376a12e4eaab95a5f960d7721fa0f8a5a10df32e95885d7c4194defe87b9978aada55664725e6c05eb55f1d71cf76e0bf2ab9cf35498b014dd588daaf65a0bd4e8c0c1e1a15ec0d032975917417a3435c2fca010fac166a9653f98944f19c73822593dc3b3108c89a2f55b919c79b8f61a51aa61e84b9a49beb820dd1666d626f8d5ee791ab912667dbdd94861ece1f6af8cb806b8d9edf4228a3b88e877401d0d3100f3fce1d3d27ac7df60f3ed8a30e63848e0f95c451ed3db25fe10b8fa35f6a2e526c34372eb98b76ba4899cfb752a829d180caa0d318c825c8bb51ac596798fb98cb282b504bf53ca035efbb8e89719c899fe221d09d40d74de8c23adff1c4b59a19a53a624301c8c0e6eba2e81ee34da91872a54761365178d27990a400494e66791d96486cd8fc87ccb05f58ad9261af4075188bd80fdc18fc82867c01fd832e3bf4ec11729c64ba77cbeb5258649abf99f6df117daf2a1c0cd7ce8f7aaa2629d3e4acffc6749550dedbefec38935489b53154431f08c8d60a88782f5facac8240235a409f559c2cfed0ca1ae187f2d193f22e1ab00fc1e9465056eda9c3e9288d7bf314a0306d935461b97808c734176db3c0699e055d8e4c6751d5bc4805cde706cb57ee0be6c27d47cceaa3a91daf95299b705f71da9bbea1031440a393ac0817b86971756c0b63cab9bee9ab343aee55a2f6a07e24deb8478b8f07a6bfacaebd1233b638c5c912cc310e6bd2d42e45d4ffb3bccb5c926a72767d3f433c01efba64346709c0d902858ea7b134d6fae94f4955a6197a88619e33ef1d61e1ae1b20d4f46706b5d2deec1476e81fe2b6206fa33a17e06d10543ac9964ff78d1bc29ab23fd7b492b066485eed2c98f521c77b0b35d82586a06a2f86ad919319b5bf62b2ee3c56b755d1abb6a8f41c78f3ca71918cd4b93c4cad42f06133e24adf1ab4af0a29c8a03985b95f8e1d6cb79e4178abda8e5d83dfc31b2b667deeffbb36679cd983d4d65c1cc67c5d86797107bdf0e829400aed826f1e9fb3f06a38e5868808958776da2069ed2c0d668ed502c8e0970b03da59539e3284a98e8e8e6a0c4a33c291cbd0d3a4bf3e814db0fe86822b4150b4939aa09bb54c783be86f5ca1d22a1854477e753ecbcb61c93ace3600d7f982ac4df5dcfe5a398a7f546741b711e869c6187deea15da1150cfbc6e8c477bbf86009fada5f3ecfcbdaeabc75ef346e4cf1fb00bbe49bafd621e5149267542a40b8ab0d50d904a9d138c02bc5ffdca883519bcb431f7ac03da9583aeaf1a0f769b81fa876b0a16340ad0b38a6f08728b19582201c90b2c3894580ac96ae1f6be89c769e5866e7ae898cbe695e3bae5cc79a9c8ccb013b89b3f6d24acdceb78e71ff676470b2d2283c79cd5319504818a89bfcdf035eae781dfe4da03523ad248182c60860a54c1ee343d6aa4614b36ad2e2485ad49fa8d9b4b51d0545b1fcafa26a7e1af77577e4d91e0fe3ca9a75ed984fb0e5c030f153baf8b18b14ac4e8ad6d2e7711aa697b4a23a35b07d230846d599635311db4766c0ccbd23cb5bd494f064d7010e063023544884b26c559798eafd47aa674266d84b30a80baf9af7ce77d5c6189b83e15e1e2c862536f5d4f173e587f118bd4c2dccec04f9cb3032622545fbb57b61a653ffe71d05a41bbfdc3ef862d0d096fe18dd7e4dcc448aa51307eab9435c3d8f11c2f5355abb0c3cc35625d529b368902181f4615375ef2a943e464ec5aab42d4801d3dba3bb634d58069118e5082c9a31849324572616c04b5e4c7f2229dc3f4ac06905f184fe626ca8b84c66fffa9205bcc6b811cffdef604cc432085afb0b0dc3b1ac0e4fe86681e82868595e2c893cd7470e9eaac4b66496465255f5821b07aa446017e45680211bde7ec7606c96125e10f7c6c1f0342476191fd63f4576ead389beab4305b26e4df5b2a4368c20f4906527879d3c9dc6bf38eae0344ba36c88687dec6cb9c46f23e2c9569ac4247e7abad848e870c961538e27ec6eb5998643083aed6a7d2cdd165badfe196dd29fdec8e1648bf24c51fc6f6ac65f20c92a66a7c642759172a3492d20697924d5670b92dd48740ad1872251af1624416f9737f965b44fb167dd138cee8402e24414b54b4ea8a97e6db67524654ff335edc354c384293aa3b83ca7e86aecb9a0ac39cd5b5925d932bd43f3ebc2539f13ae610c46adf0506ea83cabf1670672f92fe75a9f43ca5c775a8694d6e19e818c9fe5f6a87b5c2b5cd5cdb096fbf7de594ff030f7921b009f20472d83ad92523d4b0a2da36dca4e035fa4d9eb60216db25b64c9af72a16f6a4ec82abf692f0f24e13ff40bfab64b381ce51757ec8a4d3112fa9b28778fc6b1febe987474d5c4a5c39eddfa21314e29c1ad6b9c37fddb3ef2bb112aaef390d4318daa14e0db753e76aa08b8eb65a1f8c191849c23de105c17cee4b9f9830c31620ac212317bb18cca7482f982587a50961d137977b107722bd58400ebf2c36abc032a51cd3490a90375549cdd41bb031095249b3f5d85c0c574ca8fa1080580f7056bbed21317eaa47776911a3f7023f6df27b1d17142a23ed69900b365cda541c0f6a8e292c2a5dda41b54c0f9b605797307b859aedfa978e8dd62199a5b4a437ffaaf6e4a7ac1c88ea68ea74541368a97d2c264bd50b9956d7af3e5e94a1638267e7a800d30389d5dc4fa7e94e6812d53724780fb24052599122babefea06645e7820cce2714f61f884ab0969830a8b48d2db4a7679d7d00998ac945957437ee80509857ee2684620ed110a73641381710c725cac3cd8339d41756a72e25693fa719cddf2b66c855406c712546f3aa9187a54d87129f2c17254e232b7e7dfc86ab1a0055146405aca13a2663faa3ee663b2cd41fed84dfc8408545e6348cd48cc184f5835994f36b066b8dc20233349937f74bb651137409c968e83c9b253b2bf2fa4a13a3cf19acb8c6bdfe82883b364855c486b586926709776566255f75c3c117b29111cfb530fc24854a520bb03050c92b8e8e3aa409c485aaed6214680004e6fa20eeb634ae33f3b6e0a62995585a8982cbc43354cf8b3af067ee654c995268ee878f883bb2e1b4cadfacd3c2444301dd8496959ff24392c0dbaf347406e112f9b40cac3f753d7cca8ac8ff713f234d363abe2c768a7f5d4d92d9a81e5af34ca5fb8b6faf161a7791496d25d987afc2123014e5ea90a5bd164d84ad5caf12f3e596dd80aa056d615a0284c2d87aa265f2bb7853f44ef0aae119b57105e135d7303a97754a98d60b9ea654d8b774da7293bc8f2bbd4f9971fe3ee4e8ba7a793e69bb15457b132edc410dc86cf07d47d704e8b8c8843dc531dff9d14afe15ae5f9a1fa1cd63a5384d1674a0070c15f0b688d9bba80f4a0d5dfe0993905495f8e881946e4b5e14616ca542f83690a74de74609d2eca704d63d154244fa7aeffb79ea2063e680247c5a51e8ef0afb8b0173cf1714dcadbffd6ca299c18bab7c8827d6154924b6f563cdc2eff499cf8e6b1a6d17d361b8e7ce5bc078128bf1f798fa788aa17165dc7a8fa7a1757bb264fbce47bd118a45ee8ccd4b38fa048ea6796f036d5a9fab76f4fdc0d0254d96932e3657a42408fba964595a1041466c5752f63cf2786123001a8842a93231f8a40c2c250c7cb1764e03ec00efd664a62cf074ee6d37ce3d269d37809de44c2cb39b3f60bdbc00af5d99446af1e6b5196198c31cde2ce42adf7224edc93747baa337323efe9893e33499763d794f530b7ce12e13b3d30352059efa696ae4cfc9a0ee7baec04dac1d1713685418b89fdca40cf63d9e2c6e5ab9c77ee33a2a169fa305c55c7443b140d72a57c2ccabbbcf081dcfd47149cec3cc810341dd724f2722906e832615adaa83c5532a47b30edc84f763555b43ae0eb795f4a29e88359531960a8ed92bcc64b537be653568c4920529cecd027f0075d7d04ef135b0850db09cde8b3e2fe2e3646fd17acbdf4c134f8e20f758289632055522ba556d7f63478365723ac8e55866ce17e30498d80f1ffcde1f1e7faa5db09218602b1b69e55a94cf2fe1946f91efacf0215848e0e1da3282e66be4564f15b8e79825cb0c3932537d8dd0b83d68c94510abd6939fae3bddf6c3cb981d9c448fde3b9c0d3548f30c86e21428b2c50ea0fd18f39f959baa151d66a4c1619c017b5f603361353d3d71369601a655309be494b3670003133ff24bda079cea84b9805ecc1307628f767f8a72a7744eed8a6f8446f73d721891e3c7872cba650f1514e6b252e3941f20e6b4c6d2dcedb06ed8d147027b2cadd14650fa1ac8e2b2e6a694c222e2a964bf899d59bb0924df141e534e2a5ec144db67957c5a9b566c77d61a84a81301a831495e2cd02e085c0a1d34d87d7884492c54bc82a6401717746dbd088c5102527a3dc60c499153ec347a7661e6d10cb1fd4bdce4f6516355fd57d8e8a1ca95465ea3d8f767dae52529356bcad223b4a0e75282e9641ed9089c1557924542a7515e55494c940a3ff01d283b0e588f1a22c65d3020b714fd5a1c2b3de73e2aa9a3e23c06cdb98006959fd561494249a3e7cfdfd90b9e70b95591941e2c4dff115ea969ac7395cc866064062e10d0cbf6201105679deb61d70b033ea546b179d72fca8e0e13da6d2cd2e4e34515129b7d5fbcbc367e4fc488518917104c5134f901e17cb3c956350b5d996e1d20298ee78a03d2962a6205e004d56faf5f4f66f7b331d1564489b858b8ff688353dcdca9e56ab64cdc080657e669de68e12d2c57e8d67964d0452beebfc91215c441e67821c84c11457c9b49010b2d36ecdaa622e14ddf813e5ffecbe4d759c75e73c2d0835ff812197cd377a41b5ea5243de8656cf17b039578d5912de178621f8a36701ad16f6e69794684eaf62358d71b3eb1e0356a75926ac106c7ea550097598fdcffc757bccec19179d27fdb84677ced9c29b8fa1600e72f9424f15492c2a53cdaaf9d758263f58a42e86b62720dcfd93ee471b358d443accab064bd5a31cdc3f56b635ebf8e51dd2f7d0af001e584e4b58ba43161259860d90d5c43717b21c6feaf03e3629e9a8874708a6d214ce90aa1b54d488deb944117e69dbf4208686485b66d1ed031ae28a98700a959915869a85e365dea93c3f2804ce4a30d253d3e640dfdf6627408044a57b02441f22d54f346ef76ba6214bc30adfb42656b53a9353a8f18e427c69e38bb593209ea02a8b05e4ca6f5a5e65cea4d9f96b377c981d76ef9e8187fedf636df8c80f1cf194c8e423176c4b7f423945e35c7b0ef0f22ed4dd0bc31c8079e6dd7463ecfc50da344c8c0d407d1cd76b999cc5befd819a65ebfb39e58e7559be8c8587f8cf6214f0a9b4179d0abc7de0575fda2513fd19ad6d4904f2ba1296119a25b9aa724ca401de84922e6f591c4cde190978e2b0aa044be8bc239b52d27526332cfb088467f401b04284393d53e859d0e3eb3e96d505ace833b87c8a6aa4df75ca3ceff6c7c36ab9ec696b089bb4712953a9e9f18f8118f63630e20f7aca59b9d073a8af90d49f63835c2a5e8d653c79c288433e33f22e6ae193a2bef875ad9b288c2190058c62edf155da82e66896189106c8293f88d4901876cdeb4d6510d288347b0590d7f57670b324e8c97f0332a31b2e66c9e16046ef879dd4b81d2807e903fce266c4750414ac0dff60b33608c35850edb02c389f4572a7608700812312a3331c14579f28bc9b87ac0fa1f87c0d9682231c75fdc7aaaba6a77cb856c54cd42e2b632723d0152820422c2270976f3b53bb7f8fbffffd75b8c84f4bbd1d5bf9d94a8cc12938b08b9ec20c3e0d68dcd152b802b677ff826b125ea4f83719af6095425694004963aabbf7a0a85d106c8098fc1e6bd000740553533979a5201826083dd5963ad6922da88801374bbe537653aa812d7e982435378daa01fcb8954102bc727e9222a127d050ce5aeb8fa94cfeae25cd4147f76ac4450781789a02d9a970d98c3ed42f4ffa6f8e35b5fa61d444f5d3697944251d533f12de92ad5f01448e68ae71758587f65caf94458003b945ee52148896545369d37fee367fab7a82ca5edcdc80b544f626c19578f011ae1fdb488d1040466ade0b14eb3c8f27c1335aa0af3f12a57765a31bf27f4932024f7192f61ffb83808818786eeef2b4e272f027b590b13b32ee97fc46acaa91fa83fb6b0ed5b535a8e0e97f78c720a9f49f5d4de06e062fd669ad4c2798abe658d8e1221aafc764e77e176e46a40c86bf3ecfa4a816a48a640cd034dd351631f46437d0a95e79bc56fa4e22ec79c879633d5530b58c1fd129466e5789ae3b8c51b9c6f8aeb7a1de117af5f61c7a69c192ae5b8f29d13474d6c53d48e1439f9b4a83cf337b1b14b8184302296f3714f698f3aa4f263b503e186dbab372ba272675c04c2d52d78b075be297d34b7ae98a52a98e71d463c24d1d5c32c2dee75963bfb341a8f6a10fb7b4338679de3e29a0a59740c8be0ab97a50041f4430e53fd1d1de980a3b98643568130dea62b32da648e5737c455b20174e2b96ea162f082eaaddaecf22b3698e55f883335a7b6742cce8aa893c8f44b6d085a7013637ddbd96a7913d1175d0722b5918b585369dd5033163405e36b64ea36745dcab09244db6951d2e39ac196fdcf841914909adbac6c0f4b6654d0ba2ae3b40c2a8cb2334c91c1ee951266dbbbee5ae25ba1fad090383870e74a174ff7b824cd005b59241a1d02a6d4a34d230cc77810e52f3288cfeeec3143fcfe622514fb3937299ee7fc1e7bc763b25063400229221cc60a0e40f962037822ab20848b40c6f622631722f76a53116c015b4fbce67cf3562757b554378f337a51c81862412a581b168f54dfdcd77640a0a0ec05782f44b24cb402124d5d0744f636ad15d01ce608010c6562ef05c4612087e563d8ec29143a57c2d8fbe5dfc738d89cd25702a4842a575be16a3943453c101e4ef3891a97116a39618e6c80ca2f557cfbbe7bd34cc69ac10da8ece5289a5cfdb12e8878bc507be3f9103bf71b5692b0a819ff66c435c52d70c6522c8a004cd56fc57607e65840e5037019170c87ce49232ce4ea70981b07e4329228ad9a3fd5dcf134f8de87f0e474e61904f00af57f6abd8eb17cec5d68197e5933184d306440e85e3a4fe0ba8c55bc14cba3b374fdb0b9a03a35bf1ee91483c824161a8b5258a16f5f4b42184a44556dcc00092ebedc245e208e6d300baadde78938968530d57461a3c433fcb2f38efa7b68854aa808ddac519cf4490309b1285ccf6cdc39da83d79d14392658a86f2c9941e20e2d032d5a021a52459630bea63573f42db482f319b676bd15b2bc24c98b7574fa2fd02e9086e67499ce72ca26da7fd3625157f76eb38a8b62441c51db02ef98c52a25fea44182bdf15ff8550b3292b4d623dcab9aaad5d57b09cbabab4c22311105edbaadeb940e05a93ba2b9810f0b33f605c18f183ecf0fb75eeedf1f812fd95ec65b7fb4666d0e668d0829bd9ee72d65baf49a3193d39d717e1319b70834fc1c845007366632895091a09654a9dc9eed585d934b0220f5136ae5aa31b2386adfacf425bba7c9121bbf3697bce0f29b3d2f84d9d0a01ba24572dc4625004ecca8fad1741b5f039472e2920141b5ad907b05502f59e62f8c397d4db42d7967b767dbb2a24f67f413f0990e6b67e11f81e291bfb25c2e31461484e8ef102438bc41f4844fedbe66d630d97b3043dd0feb06017485743a57d3a715874cbf0f1fe678990b92ec07daa79c695b45a26a2cf753750beb43aec5e268d14a6f10cc237b8456629174061479bc646343e70951ecd4814be8f391a4c33fed0b419fef020f7e6a4fdcef2641ac65bb5574ba84da162baf1bada2d0c8931db5172f90914a3b5447666854f6a4b568b126d078630b96a4fb4f5347bbec6a0c053f555ed0868e4c14fa625ea7daf1e35d73296d7880c1c45543bc51867884c7ce346b054c7e843e2be03d7890a5d3d52b48026d54b51833224297bdc9daa9c6973c8fffac7e99999b02a22dab51cb0b5b37c367cf98eef1bcc4da6601715f0ef928489717b9cab8a7c2315215a4891581bf4ed4843143f2ed793a2d0d00960422aa58ffbcae153e442b4578915b807603022bae52527d96782164dbb1bce2ff53ec3d7b4aadc8309ff309ef0641c2e99ec9bbe0dc5ef67990360dd616e47f45628673a4785bb6619551b142fcc7a42ee2e046940a208adf5f6a1b4e48e497b039b8d6817e559e283a9c9524243fc57eb1b8bccd86a89c7d81ee7110b7149d4b55f9c2b79ad95ce653be81b4cd905380c45e7f37404948fa868f2d15b7feafba48d7c1908d84b3d7db78845f6f93c44126c4a1b6eb95a54e739f599f003656743724e8ff1b1ebdac8275f9eb24ea4d8eb75359a57d795f7441b067152ec1036c5c753a078f755e092929b2d52a75cdb4aad89b28b35a05355d1ef4b94212390085f1b21d344e468b678668d06252feac07b5231c8a50cdae276ba1131f8f37b4936fc249dd5b4e320780e521d46d1d612a68547dc766b826736714220eaa8e7bfce466a65e4f4f10885b858829a25fc44265b91271f24a0c0b2e5b753a8a03244a2431f210f3b9f59cd3038e2f69db48d339194b51f64aa72aee48dc354495b89aebd39851578768a90aba79591cc839340457f4799736c4028690a571a29f8e1e431661020f52934b4db8903dc53479123a9c77baa164d837eda75ec87d5e0c9b2b438a077caa02d0a465f5147e9822ebbe84bd2c1c0183636fbe92f5a5531eec9c70adcb2bf8f6ba398f433d62de9d944a47baaaed570490b64f4b195a51bf7dd43728b9437ac9418611f9ba0ecfc0b41f14e753911f41c1a51dfb37512bedd0f3b82fc4fd3863ce5885d6b1b2f9b64612249b0bdbb52b69039b0bb75250e2fcee03ece034fa0c81a69aa6ecaf7e8a1bde314cf7cb80f9f1f3107ce75ece7229cb402586018befad2d0b465acb5d5256cd573b0577e55e374409e1756783f9152d311d3466f07356e84e598ced293deeae8bf862f586280a84c799f6977c589237e528eb0b5153ba4e7cd8387344e92f1d3374016bbfecaff0da40632ec62d05babd7faf0eaa8ec569fe7cba0d02be39148a0b1b1b853c5f2f133497e32d84e9ae157e0bdaa0b69bb50a288e335b4380d8d519a98c2dafc6d7618fd2e3b9f54a0a2d4b8a1504e412d4008cd7200ac84a2d9e1decbec06086ce721d3957d66b4bd82e6b3fa1cd81350f1ebedc67380034db666ee66dcefeb26f0590537a7b67a0ab6c473ea2b791c2ab2ed985111ea9ae86a3d4de66f74b538950c98d46ce01145c2920209fb664ad0b2785e24d34a87ad6df12e0ec9c16e725fb1eb7aafda305158d2c83acead89ba0ce0aa4b4dd8e31ea55943b2d68fbdc26744686535ecbe3b39ce688a9d90e68aee695a215a6e5be206d0201c49bf01aafb2091004070db5764ea2548c0430a1dd766b56d97b24e02edb778a506183765da9fa527e6ff293fa15988fbe29510b9e29255df184c7ac856165f11985e44057f61aadfbd3362d8a817ce889c6b21a59e275fb5871820a09610195c3515eb6229ad465355f6342bcc2978e94a9a27b74f79695256d2e3316be489a117e918e51bfaf21fd5cc62a623c11b86da8098a24ba40342714b139dace2c66bd5ee370fbdce86e65f7474dc66fcc1f2aca40dc0e36fc091909c57ff84d87245acedb7a08be693c7a40adaa3ae3c57f107921b7bc52afe361123f3d818bd244497dcdbb4b37af5f898a7051f7db571a568d6495ddc07fba64de24fd375671f9be9b07b86d96d40ffb5074e948053034eb424ca5595d8c2861d1ac212a5787bad60ffce9a6135568ba337c2b0f5f0898576c454a34f487ebe37e085b95d9ffc1b7a9393d4ad012eb2dc785648b0d6711a774a49a3e8df365c7b0ad321e39668fc907d6921f2cdafcbf3ad1f77ee4c1f26502e3e099ac911cc41dac845670a066f81ce73e8e7be762f717a8d999c7638fad4dcb1a0a31af3a913180fe938171cd098bf8899768ecc91f9cb614393a5bc2407bce7b18ba090d9588bda616b4e6100143fd30a188b143826e1a4475b88a67b88e5bea05c06e882501de527fdf77be931d1ae40ff1b7c32db51f1d81b3acdfbfc56c828dc7a9c158847c2e963fb029ae5dcac9b1d42da14fca03e3574bbe91616ea910775bfb7165e8443a618aaae9074f4bf7f87320191c14fbf0bb1fcd65638a6a98f9b51d77938eecca8a428859c872f0fd05ea14cb46c1253185d29547b3d1a8d1ed43cf55bc9e9904188051193becfd5982a0183c0b6c15a93f15baaae3e55aa4d06bf6b25b0239656fa9578a941feb014b74e954c5e503ee195c9602b8c812b09542b5d62f81653dafd64a55c6b47bddead40cdf19ade1a72390e849c1e7b9c949182f316aa1ac2e54d9aee56370f14ae5688c0cafd0f014dc5a8a7b0a4f2375850655d46f2d30b12f2242e89694b598d00096f17440b78610e57a19d5d4cb6eafeac9f62981dd91aeff35d223bc3c8d40e36b047ecfb1e20a2355aa655088230f76d170e600b66d6feecc597e6194e180bbe9a36768572210081936e02d1236af3d4942c85bee3a29f610faed83fdc01fb5618e5236aad42e3bdfc934f15aff0ff4dd0cc87bfcbfe14cd973c21c344b488ebc676bc4ca995d27a8f61b7a4f07aa360a954445061874ba434798568717edaa96390356bfa7e980f851231b3c8e4099ef482388853467761b3dadb8b2acc2728bee37f9e748359a5ef4c9d5520704d9c5b280c45f57147a64e144b87c070a84ffd82c166659c6214dfbac4ded9684616f06f1a422991d8167021d627b182b858129d37c14cca423f108c4440499748dbd995050906434322832f20d04451f9f487a42338b260968cabfadb2fe1c3b4d126524f528f92f2a2449144e37e5abea6e48a18610015b89d64b0cc96a63561d588a8a30e9ec73e396e30a8d4ec66c5a45729d20478b7f5b10d8f1766b648e76bcc9ba3207a4a6b343dd490bcda8aeeb85bd7423df06787ede165d3da54af721340717c312dcb759f4dcf52efac0192838508d8e8e465036cdbdc5663df4c31a94d0cb857e2537d66fc6b85717362c42d3389e6d1b365de29803b9f30e73e8e7f4d200254362fa87aa46a6a817a7845688e567945053cbad1f2786ce908f8c97295d993fff4a14c7554c307a3ca3fc9ba6abfce84b2f7d534aeafa1709434ec64eea843fb1e91a78c28b2b66dd30938cba42997eb3ef390f5d11309f913d545cd9919f79ea1fbe513ffae31fcf45275160470d0305ce2b166be565d6215f30ea17912239251faeceb854418a505002fac0b9b3406198ae30d8b2f0d64a4192cfcccca498b9f2d1056698fbbd21b1324e597cfbb6eb2f6e4fed4b354692acc9956248ab4ac7f2cde2ba89dff16c3cb63bf8d97f8b140ad5358684b52d612019283fafc9b34c4fda78ad2e237775bb7432dafcb055e9b1ca93c7b72c184c4fd8d3e5d052f88d8de9699953ca3b956a0af465750c87d742c2289e40bc0512a0663aeb1c99dfe0041f9cb1071b85ed7962a256b8e57121ef18ca8001280910aded9e3929bfaeec5f95b7fd1c22d4538e21170e9dbe30a57ec46690df22a00fc5f339c733185d6f1e752656ab47267040e0cd61e02ff07ac85162ba42ab18466bbe7cab9618c4a3145b91ae8df303b69d35eb73a2615d5e3a33e1f299779513d4846e7355d6ac76e90e1244e2410fdea5912a11e6133bcd575fe0f5d47283906d728db09619ddd2988996f18ec704cacce7bc9b15375f43333f323fe84892405479dd0024fd856ef24b2e02b76660497c2962c27b149b02faecba124f038252daf40e3aec1eb6ae1a053c564933180991904722c706506367c2857f85b557ac071ce7f48060b1670889c59572671f15dbb974798fc2b2c04d378e418c39cba3164454719737507b06175c772668a3b69f8fd13eca2effb11210564769fcffaaf4f2d7ae8b8ec89835f056d89cd9342617040f4c54cd1e682fdca269a5dada69c5c130a0d93482ab093e5a80cec34e7ded9bfcc46db383b5b1c4fc94cc0c87b4600f6e94a5dfd8d8c94864effdc6ed8ec4c8148f3a123a7cbbaac83df123fc8fce82d74a33baed4610feda822c6029d3af134a7b434f72fc02961779281697fdce5d52aa6f86ea484fc75393a03d015eb8175fbbf3ac05c44f73857d0b5b1897549f2ec0664d58f748b00fea66a3d0ed5b4c535b1c83b7cd0123c1a03618991c06f6857dcb9f6bad94dd6512cddf197a08a0ae3e700735b588d7971fcb5d49f6be8296a57366685e1f539698e7cf9b4fa4e2b59009a615c3ebc39d1fef7209540b6bc382d9427f38a70abf3c0d74e3b20800d2ade1e95dfa431ace624b323005af3b25439b7fc694405aed7d5894cb36810ab44b5bf5463f3e5abc168c76105b221bd450fa9030c6d2aa85a629759c704e15000db98a4c259def3002e3960f690ecc55955e25a2f3997e7bb0a19bbd7726df88bca3a4c3f0b6204b1585f35ebdd17fd95ad0c589cba5c713ed2aa22babaf4c6623a69e7bdef24c82092c92aa3dfe782b697f069b89588e2b59ec1c248b08b370ccb2ed2bd2507b205094ca4e2bdc7d8a0f3c478f79ebe73cec588eb91140f2ea0e9c68b022e1381007ff02e772e51ac907fd030edce83c9cfda16b41d9dc5f65699a2056594ac7170db27c475348b564825db51ed5b1dfa7103e31ce8b5581238dc9c9ba5f459bdb9776303418686d7c361a41c6d5f8f2e3f56a87278b98968e79abb300c6202b42df17bb661d5bd1d10396fab1c445a03c34a476f27c84f47eaea15159813c0d138be859b58e6c5f3d9058331204749ee81a2facfb6a6f2f66cb755328c18f66eb903ef76c629ad8404d885b06553408a6b193ced573a215a4e8d34d413f22a9e119f04630db1763a17d76b23c8389824bfa1ae23d9cd8799097cbf201be94a272d8def2ed76c97c33261387a7b54ab3e79b54bdf72dc3cd03bd51da4a3d96da91f067d7bf90ccbd425076086a3ba307e91c948d1435878c6869bdda98cd6d41f734f14fc523ed6a3fa758a65eae95ca0747706bd5183d759f684cf1c0ce742e040664934a0d31d89b469801d94e718bec2c44ff9b01729540839dba10d697aed98faf20cfe44c9b0380b96c858e61d4cc8eb0359bb9a5230352347bd56dd8227a7e423bbd002b8e567d5ffc87dadf30780816043afacc295613fab78b5ecd2e10809377e4866ba111e5d6273dd73c848f881d3d5aa4cfff732abb5e393820f7b41699570978df7e0f138bf93d6a1ab0e00d3175f5350c967acea67eb4600eb04f4c54f71b7e0dfcca0a90cf8921f28a208d00f7c1ebd28f52f7d190d801e97b68d443c9e7e4b25c8d031cacf7c090267d2efec7d161e62d6fc5b350ecd096990809ec624e8d3a653252091651019266c2c7e2bc5d320109b178a824bace10e301f957595fdb483d6c7f5589b8d6ece60a95279e2e064f9cf58971161dcee39b376f932ddf973422b18ca1773de6663237b78c5c56c6f19f1da2b15b04c5b18fc27330490f7e88e93cc5b5d8bf2c1c49a5ec94552b237c3394f8716e2faab1800a49c40ac9b68353d0fbfa4a853bfd76e24d07a8b77078d8a01a9cb524e82be62e5067e23dd2962d18c1fec321d94e7a51956f980eede33c0e3c84bd243cfdfa5891367eeee9e944e6f1f4d0954724fafe9d9c053ae1abd5eff85b001c2e191cd1ddd306ab74d728a6f73167c4eaed4c1e5321edb1b1374990dfbb3ed52c0477f1a2e36baefe6dbdb738b044a28ce88ee83ed4ff8fdfdfa9d2301f68eebf5908508e8fc02668ef9d99818fe0c006a808d8445246f12f6f8090046713522f44eab91404a8bc84544f0da390eb16ab95e579d878d537aba9a6be665887377608f3d9c6f3d1ebf6c5429f1c996028606a3a502feb921eeabff162111a53eb557aa3a41f11873eea22a83c6e3425f006b85b7e819109d132ddaca41eb876e2e28365e3219845bedf7d10c196103a2d6b6284396a164e793c9de3816da31bdaf4a11a79abc56d2b189ce0a5587e7bf5b01fcc37de68f3f50b907cf37a30dd057966fa39de58fecd477b933d19f4f1afecfc6d97fb3c0faa40bc238a2015a18ec3f8c0705f1761f127c8cc24928eb2d854d75ef82b874e99541905ce00f0ffe3a3902d6b784a475d2a663bd317884f3047e533c2ae051a42c71357eb68c03da22dfbd0a75340965d0bea4b76ebc5d8382d2c59d0a6b5cae7e60bb575166ad20ede1c2c7fabc9632b3f21ab7fe94b6c22260a98fe335aee3ef0d6494c9f35826d04681e6240bb02c93f889891e9c556893eaced4ff6fc9bad883ccae8304e06b01968a407566e1fa390d208b34f00c4a7e898b1a99565d8912b7a3fa3fb454542023ae623483fec88e56698f5a16effdc59240c5d8ea50a40ffc1a1b4e58e1bf50a11968200105ecd3adf4df770a644ac6cfcbcf88f8f80abaab542021102b449d0b19e9eb9c678a3d48a2cea84e21f95a8a0311d313903eb30ee07fc555b709f25f3211102caab070ceb960b0c7f5e671be3eb4c98807b0b8c7a751715bb61068047c77166893ec8873881b57a808ff4c16d38f3fe82a6e2bc5988b1a72651b85e2d5a8280f4cc7e00dc7373e80c1441583a351ba121dad3490061614803587aa9bbb8bf6b01d48cf6f65dc5f8ecbf968b1a2891c187d9b8b2d7bd05829f0869031a12b2c8284e6dd1d7377ac90e0a1bb32f2568e79db96034bb451714aa26f19e09759689e65fedb78875ccf304cdca6571051e5f92d556527ca209c2b7eff63559ae3bbc3d141e114249aa688697fd7e2dadd7565ad3e301606bc5b2c0f36d676f772c6632291106f3b5d3d3eb8cd26482a26fa22cb87afd9edf84dca17de3e1c5f480514eecb28cc071b83cb4d528aee3f35051030d04bce4709d78988bbd706884f1591e27537c7d983fcf02a00598986e58c51f13b9c3d21d00a2cc5730387bdc0463b41bafec372ee3111bb089143c2536e7810881947d9c7a10c3702c2ab37973a123918ea8ab71c951e980d89f4046096a727c0232ed54035ae961c704da5d1a4b06f045cdccfec5b87af49271674230cdfcb3da699f2b9a4210ece0f84d1e1712fa6eafc840c16c548194c713484387f06f1ead4e031c886aebcd066e7e42e7081f4f6dc7e4b6a050d4627ae2d0f18e9cded9fc04ffa2071a911cd93672f2a4ae9b28874d448248cbec392679bd8c3555a04702eb6af99f00002c71ef43f5baeb1747b42324cd12f268bdd99d234f3c2bcfb0ee58921ebd7d98078d2d9fffa9b84016e5fbfa7a748e8adad1cbeb267305ccfa4fb3b7b24e6f9c7a81a04752b901479edd2f70ab4abfb8d8b3194fbb4408b96b864d8da17792b5a8343d91a8ac1b6210f3c4e78cca62fcf9c8d960c34c57fd7e7ea6be9c98396e36a318e776d9c648633e70effea89e85abddfc80acf269c4c920de66663f7ab901b2a14679354fb9ffd5aed004a4072446a6f2e89042917def29de95ebc4fc686a4e81c09138d1f47ce0250508d824d05ecb7c237e7e1a5aa65c95d12ea446b52a1f86faf6ab0c3f6d9266bcea8a6e22a7ffab910b22afd3cb3fd09102d4afbabf47a7afb2c077633a69e257ea5673da5dc108e54052302389daaec393ad32fa6100582b7007762d123554ed51df81584fa9bba8ccf350c987207346c429edd78d041cd09a23b0efe2c322c9fc781023666963b48ae19e0936006871557f79191c1a8b94cc538afc673f4aeaa8701f66cbdc28b95afd80691b45ed8be26b3b6dea32b8818c29a12f4690298219d9fd6e97cb8bbb4615ed343dc04850abb15ee313eb3e345d0a056538582978090b2c2d12445592f9d63dfa9268b9722e948a70b965105f1b54a6fe4b5592e6ed4092ba83ab1668854b9e0e8b656d16945d3d6a5aca7648ac3e05602d40119b88f8e4cf94e89e3f7a95f5079f356853e8365a0fbde4ac47fcd4c174847756994a04dc4a3f49d9694ceb1a3ff8621ab725ddb2fe66a9d54c4d9f1927610af8988676d4ac4e069c0e0b085f57247868c10ffd3dbba5a01556d5d8b9ebb7f33c8273d0909d708606a9668c25b1d9262368dd3f3a30277a0efdac4a8e33ee98c0f5fe1e0e66d5c2318b070a5ef5cbd27e92b352b527224b03e90d265efa76ddedc46fefcf75606f1f5734b3298d90f2ec9eef72cdd10e397a58e177193d7f5d2976d84598dd68c80684c8e8df2893f8d5db41498b42ef92469c9e0fb37caaa122c559ff3bd3092858df7a20f13a1ab6160e981d61f2279b849b79f3433ddf5d2c21354a273203c5120674dddc7b5b6ad0f0d7ad333de883364ee1bbfe89230dac2baf1d31f8293d52ed34b58c64a0ef0eae693150e42260e0424e702a6d897ca93ac2db8fc768cd4b5dcd9aebb57ab804679253da8a160bb71a61bff57b2b1747d9a0861c6550594d7062ea7df2088f20b29e2e0c386648b40a51ac7446390574470834953c38a4b21705ef13e14a480d15dd9119dac19e285eaa0b84e9137079f562a83adaee5d2f94d8dc6d0d86ddbf8f681ca7c01eaf31f15c699f817a7d1c0cbb43f872fae43e008979cd46ba9d140fc3f68c1e800ad2b61a32efaec6d3eee57caa405a69e004c611edfe1f266920fa3f350c8c4fc84533063af61739b90f8e09d4ec8b32136c26d474576fdb2847a93e2db586455f9501b1fa4ee35520104c1969b624260bdbb3fdf285d163f45ce83447fcede182564d6a22da405133e413ee9b59e76d8d68d53e94d623759793798917e2847407015add4e99df8b30cd1056e405bb9de21348d105b80bb669ba8f3ec82274b50e3cfdff0c32761faaee207e4988285464279bcef5e56d92aa62536c1d18c8edfe0d205178be3d7b7ad256942385de6aee95b3d6d799f61fd3ce638b9ed8f2af06e83f67132272100077793a7f2a2eb715d6450628889512902f4e8fae2544202f1ceeceb392d50e72a383c88cff8f5a46785f3da63dfcc0559519d19c6978cd3e6b50399b662c316026235fc5d81ba32b77dfb543a52339c029bdc9f85d2919effda1fa1782c099af523ccaaf830f7c030cfae9bc1cc66431b8a69cb2f15730364baed846f0debea68764336f704f6ebfa2b7ca1983e23d5f493572d2ade793a7235829d04b5867dad066a4857adf30156472468e193c13c49940a2d02621312d581541ba9d01b70db3c05974f56bc9e0ad5a1f75e4dadc227f8daed8ff300a9b386f31ab41354b570b26e5234dc03c7abcf2115f7787a091e55a0d81a4a66edf7483d733304e671d7efd1f3edd50cfe0b9934b70bc53e6bbe8d8c3c124f5c3d1c1823afec83031bb53e1ede31db3d5dd61e9308654113d4fb2abd0338ef6dde100333af9d7befde0c81fcf68e72015816c7274dfa2d8cec3326c66e3b466e729906f8ddb1962ad01c93b43fe59f8b398fa037d40748305f37d27f63e9d64daa4d6a41098f589185fc16cfb78e93cba0652421cce76313f2e91dd09ed9ff5888b1653649d79258c87bb1bdd9928122216522c951865c592c78c03ef92ef81351a0e93dbfaec2956563668d484324478312a91f210dc66a43ef70231d65f53bb40f58bbac46d1162c944a5764ffcc00c9d0793ade250018a8374b5e3222c1c47fff4fbc4512757e53d52d874d16b19b316a12ba4eb80c2bf0178eebd0004709f714bb41c2ca4ff1be68b3dde20cc04137dc1a45f4c039f2c65dcf00301d247fdcaed1b70cfa00c158a57c232641bdc88e0341eabca58cd364bf8f6418f897e74c49faa788e8d088fe56f8a45e4b81f969fc50c7a00f448e851bbabd62ec754ec3f266fc9399f80e434376bef872defe17049b61e11395023379bb14def35eda721718ced61e78608c3907091232492c97c18b8d05e61e6e6f99c1a8a217cd25ea256b5d64e6e2e938a1a5767462af380e8aa8183fa8454a32f92f2c097e86fe59bc0b59b06b211de3bf013aa6f7d1ec37483d50cc8c8a29effb6b343fa38946592fae986fd3ecd303a394b82d5fbc71212004c9b90d521697639ce1afb98f5267c25c374495082fd61a3daca274bc48a8c23d17c7d49e46123d729707269aae789b448827286562daa944da3f86a8f3eb1ed2335b5ca424b32aa9cc9ad75afc4713c930b3bcdf37cf24d68d2b433c52a8f6157e414bf56ef727373137cfc65b2fecc50faf87904e99071a1f855b6a9b5b5eb54fd3f727fd4002bef7ac0591085e68241645a85bb2a7060a392380ca2bf9274554c80a0e0017d65c518962c568928febd79af844e44d1a8cdcbbfe9b843520d6b4d30f2e1d30b289d6b4e8dc6ac76ef2cc413b0751d0252b120b1311b88e1cff9d2a9f0ace0881994a2d4454f366bfd8cb410d4ee2f9b2895d171da9cdef73c36fcf262b1eca29bbab73f06c50e8dd8ef819386fa43164ff52490b132f5461dae7ba3cd22efd13a955a9d3e5f996473fb575058dd3cd03eff7942ed77b634adc12dbc06782659109daa3f9e3b1c23fa68d5ec0461f5c715152bc60629bac0a423ff6a6bec3cc725bec11738d9b89e5386da8bd5532cac854f40c80ba945777f5a23f54aff7ca6a5d90ee7f29cf4a4abb4a7948205810af9f6f141707fdc9342449b4187f2154fa94280513b4dd1e5c4ea4bcfe2cb7fb18b0afb726dd460b5e18e0bbe404f700dc0437e1ae59775f9963063309f7ebe9743bdbbe325f6c3c54c3de397a05e920ee098b516c88c65420b2525eef3fc08da8ff62b9919d846f72329d28379b094c44df2b19cec1e4bae8179c3b840a59da273d09de4f08f4af9087d8f8d849826b52a74487e0aa74e9724721830cbe0790beb18507947d6b0c68639f0a974ad22e4c839d2d4b462ff47f96ba5f09f94b64d08d2d0b1ec8bccaf93b04d05f94a334c94cc362accefcbe30851e1d1efaff4cfffb42f2f012fe281c30a3c480b0e871760aec6c8b7d30ab6f325d72fa0a3d9e5d9a9003c756a38ee59c3904c945d958a29d3e53b76f59229bf7c145a06e49b52c94f2e9dae86b8928f2ab9fc86dcf2d2ee25864bcc23e4eab402e881ef6b9fe0357a9cba87ef1e4686e360570ef9352c0c0072fcb88bdff6b7f2efc1273622a062af9a496db9bb899b6668d15060eb0caeb4665fdc4210988aa0f818acc5f89e37a926e31a1ac342027e2b9098879a4d4b07ff38aec183941eef2a72949f5a2b1fd8fe2f5aeb2d1dcfca17366523da7bc6b06dcc3862320e2fdb8a148ccbbef316dd8494332b2a3aed3f933b09b174cbc9dd07538be7f7d711f1c5136057c8950d107086327c1b0cc3a4320efaee9c572dae9fea3ef41b41e4d2519cc4d5426e65fa4ff6baa42b82a9144070e75f32a6bbb7ae0438906a99f5b4da34f3d92ebcfddbde76f00e6be5b98091d203ca159f748250a045a8dcef97e0014f2d7cde687325240c5b468109e12bafa2a4bb8d69830b0dd95e8cd0cd4d356cc17fdc210763fe66cc4881edb2982c4ac78600bbe1774273940670d2f0a1a420055d9a83db55c3f0bce612d75422ef02c5902e1d98f88c8358ccedf444d4b23650c55a95ffab809f942ef66d88a0b47f45e11a278d0e43ea94f87db9a1edf9d4e7bc464cf24578484e1249dbdff60fd3fa5560e31a60310ae93102890bbaa77f43c28c6d27e8a3eab4c1cfc1f6e96632197cdfa8be2c19d730503fbc7b9ffdb6dbcedb0a68532bb153816c4ee29376fce0083adfb49f2f8062a15d347145d1e5bd2eea0e16d5eec5734dacd862e3cf0ff38d59d3981b9aea869b6883cb870ca03f24f2d9a4a2fff3116f3c1379865371691ae69b7a75f9fb5656d0a4b23d2d316bde2feed8ab251af63b6fcc4053bb42eeded10d1db2dbb4472ee9458df3c57affc162aca0af5b6d5676ba3e33fc12094bb8cdc04dbc451b0fa26b9e47d5f9221d66522098474e8bb02338f1329f38432ab9d02389b731f5ebd2f2d86cac0313fbee46dd894ee25cc23d262803896050056997a15c0609533a0f7f0bd503b1453ca28cea7e7eaec8cc5368e50c5992a678731fd538d830ea1e76f5bfe938e5e5c0a9f6bf2f637b358a0d0379938b2a5978f02dcea516793f53129d0cc38013bd0cfb5852e8c5c8dc8284a1a1ba5257ef1e43c7650bd6aea15cc1a23c9fadc6f19c420b30318849eda893103d00919d8a10cab9a27f020af4b7db960877cf1b16c7836dadcf7a647d6690c3880bba535dac41122e4dddbf48c4d9eb5eb0a04386fbd65f21ef1eb24d875b4ff2f358267186c5a4d72304724b76207bbc310e06178551c6318567845ba85bef7761fd94bde3d3872a2527ba7b1eb8011558103b1420ab0a3043815c4317be0199285b728e329396113f47a437ccee9e4b9178518f02a79985a65f6f734b4e87d6437a673ab9def08b8652329617cf553b9d4dcafd2f9f6530fa4d2a2e634fa7c34cef6e29f54c78718438d7115ce38e4fb7ceba2732d2624f5b0baa5c4e062ba6d636582b64775647a61cfc02aef497ac2a3c4c66913c09bf12094231910e02a74c78481eb248742445217fea14541ee812123d32a6d8d8c5d53af999c826bd92352735e584fb02a6f4612f8cd4c3b8514b785f029e18d0d0bf8809835add132aff336bae60c1f3f30b1851d9ce455ecbce48187acd4ff63f175b62e9fb685d02b3bf0a8a5ebe7ed59a901eab48ebeb310a34e0e7a989d2422fe824bdf6031bf636908650af239dd53c8f424d9b419f55e338c71304fef3c4f8e4299459546d25fbd425d924b891777cf55fd89c1e9f8276dcec5d5eeb686a14f9792c7bc69a86372684803b0b5c7bb80a885cc95e7299cc4b072d7821489c77dfd3be7b428d061b0b13ff5de44532bd8cc6db769e85b70bd8e0ac68ef2ca5f66c2b21ae5052398ebd948f5d3d58e383c597149e16a86fe40bd5dce279b0dd45ce26b912949e9a6b54a065583ce43fca3e6a1c028d90923def58ee7cb7f5e8432f9f3e4e7d455e4ff72274882efbe7735024cac0b6538760ec6ff3147222019fa5264ec63bc1d06041d983b47af5fee7b29ef09583ee33283033ddacb5de5327a97ccbcd3db247b782da993ddfedcfdc7224695b87c275f44c51ca5706d86e609c19140b0459a23c220dae021542824320f7ed8f1e132a645e8ca5129040bc23e8a60182a71b5a2ffcabb1941d18de45d6ccc4eef988c617ea3914a2444b0f66f583bceb340423a63bc6e57418d52088c64c396274ae81fe3fc1b4cf84b24072e0425e46eb411cb7d7c1815778a4e1204692e7da75750bf02a22ada08333db2a192a64c67ea590248fd4a9a4d6f505f9f6b0d6d5acb1d594586f895f0b0fd82444b5f193bc2547b1f789b5b170fbc5858c2a639b979aecdefd4b6a93ad8a6bad9812e3fd4e5c637ef842c66c8f2cc10ed778f9802d4c5f95e372833eb06fe10ca8a4af0ced08d614d1b0ad74b7c522f23489a0b7f74838b43431eafd3b8a8998f2801c9ff38b5dfca05d24d78444d698453b547110f205a31ee9b3e4672bb465eff3be7a416a16023e2450ef82eccb0cbee42f67ce11f3839190642cc1a9beaf33fa4efa32d29b9009b39a1e26444d638bcc680ada516f1d352fad14d6dd2f4337c9c943c50eb8bb5f10d8594a98616d03b018ea08c46720f5657a8c1ca3e47fcb4564303c12a5e12c11bdc43e774260c041d817a35d0fcd5de2527e465d4cc4ba894d5021f3dc0331e2a5d57333e067e8a32995a574373860ed05dab66fb5532e6541b4156d7a397a83acbb566476550eefb2132c4538b3fbdfa9b553c4a90969daea66bb5c29dda9480f01c26530dc8cb148926b706918b8a6ea1f63475b6c1d9f16c0ee43a758aa57e7a3b0d6dd0d3a6ac8a08e7a2afed243a87d796b20f0259fb5fba2c8d3af952d2f1f8e18b709950fc354534b7b12804ce58cc1a4007eae79afbef835512daf1a191e93d4310f1c88f73882af2421a36b05670fec508feeff847390f9b4d27cc0b5d31b74e5664d329dc134d57086f8dc5b1c413f60706bb7c2a8ad25486e3f98ea30caa97fd3f15e7e0f69d37310b7f309c3681f347c5a5d43db7bf05778426db87293e3c87cb3cfe20b901fe49054942d131d105563235f4256a834161abfded1c28ddcb886b0404a279a1783a13cb95fea161dabcf32603e1390ee090058e081e46f0e9bc6acdcf644867b155df7f08250f3526af745b5abc373c10fda853ae2273a384348c2c4479d9dedeb0e74dae1d78a3f0ff117eb766e7f74eaaaa608621d6ddd5195f48de3a05678fb1aeaad9d72d07b6bdae13f574bf6706349c4399cc387c488f0d6bfb226500686a008b36c17931fc2246f24f1c57e43fbb490117e2944792ff78957aa6ef5e95299fbc9a8cfce47f4979fc1c8d25d1f2a2089a7bdbe2ecb875ab14566c32253777723e1ad087395bdde107004006c5b30d2aa68a0ccc14c52a3a6ef93c491ddae833a808842a5ae00ae5141ffebb1f17642a79211d123d462311aac2ca4eb04447e0941f47590ba23d97075ab0be5ff7f0f0fba08b604fe44e9874a80e01ea78844bb50aacbc2e87ce5f203c5ea704667b37d47401fdbaaf04161890f45fd8bde7c55efff7ef4e8ceee3816d44f54aef2176af43b48f0798ea4929e363c36d74f8bdaf4d405d46fd5ee2b8cffeddcc0326ce2529f2c3e544c5016b1a7bb7898b7501f49d2d71cb7e1b98f79af8e372ab3dd2343d4f420e641349b5fb555e73e7a766d6bf86ecffc8642b9a2ffdcdd3f3b17b18101e1411d6571e2386d39101dce48a1ec7d5bda0057f68303023d26741ea74415512cefad8e765a42822b4aed936190f2fd84e587ae454a49d1589de41cafbee086a2498d8ee8aa7407c2ae4bbfa52cb5f6f239dc91a85559734d5ccdd37ff715e7e14d7750c8583cfa6ce9364f57050498b6f14b99b2b2c78ba14111be0133bd6c83c46c108966fa9c15ba92d63d7ec1e1cfb4a4ed079660de6fceb6c40dcb3250a3912f9f08d883a15e59a894275360122849bf544587a1a16f6c675f1789a4dd83b1c5b69b4e9e23cfe3a41d45c46c65fb24f24d2d573da1c40cf044ca11979b446dfb5ea0858a7372901693211603224c049c3eac7e9a30c162c5ab7db763c1e7f7e061485477b0b6be726c39e655f9383b9eae85e454ed03797c1a9f02b3fd1fb146d08dfd083394d690cf713328b55020dd94bc2fb9519b024ec87641068da0c045968303d7c7478d2c79f2df57363d73c2b308bd4c1719959a8de77a31a0e999b91f7467f1b92960673524e04ec35f15b905eb054369bfeb63640c32dc12cb3dbf0c803c56ad6bfe44e8d54090a638c3b53933c809e7316fcd78d582007217bc3cf6aeb67a49c7e92c26caac321db4beab3f0885bc765480a3c906426f52418d5642a46cc7b367cd6b5c2f205d95b68312e5c5feb0e74170d4583af54cf7dcd8f8086a5619da97e9b089c406cf3c82b169814135ea6484a2f2ebc7a98f4840a353080430408dff799186ac175bdfcf4cb1b24700a5b7f911b15cb4eb8219bb2958a9bc4a826b792b05de31e06415b55fef2965d0d1590d546e790a6046bf216a3e145e84169bcb8de835fd1466c2b1c5ac874c4e8f583241a6753fd04ff7a3ef0255c90fa954cdec7a47806f6ee37ea375486b89b606c79c7aea84c6e41d2a84e28f9df6dd3dc323e06797139cad78a35bc17f26517fcc7132672a35a0b4b252e145e1bfc693fccca2a0a337a8fcbd90732c42871ff81b5db6917005f4386a5c47a9df736b25fba62b589f0f5b115f5456c5723412e403a917d76fd4a24a77df1e02ac494b1eb0274d8aefc911a035a9a3f5deebd0e576f104acf4964322b573b622fda6d5a097fdba90f3c23e2f401479912f9435923603555d7357c357d62e21ec52bfee30bdad8c7b95f2e6c59ad0fd239200cf02a4cb847075c3e0f8a916b8e2970b6feef294bdf95cfd22ea6e67da4b8fde6138207a2f9422c8aeef7c8594d2b007a59fc551b0d1c640a2ef749dbc27a060614d26679820c70f15b9d1e91584ac1fd08bf703a7e9e2a82696e038d4d25438797889f025287acc516be8775f80857aa4258cdd4ae07a1b04f8d2e357f11d3b09df803de01745de720cd1f8d8e5a75cca85ae38263543cba6c8ab18ff4c0b9da3376bc8f7e76e0dda3802e0ac4cad3060b5fcc42b01d9d308e3d396888111058e3c749f3ddcccc3c119ae3549bb00e175c801662e3f8e153e28db5734b9a8de45ee8588a8d43a6ab4ab4fb1e3aa5c118ec8e80b65a44666ecad035e4879d634f5a52f98d12d9d5112552a95f11b55f3246fb226ee08e7d2cc3c94fe8d7ef41202f86c5677310ed98eccb578aeba5fe524b07753486019db2c1f8c7bd0a9c6df8266763ffc161955b04f303599130cc86d14838ad74167476d3f92d962fcb167c0e3054ae69324165429d194f5d75df955e44a646401ed77859639e098a42653bb24b91f5ffc6ece2988553a4a327b32252296029b5727d07eeaf41b4c1a8f96a4c37bdfb6f33d8232a5e173e22a2118985456ca8c9a9d32f5dc538a5a4b560164322395dcac231f493a70514d1c902a602100622b866a559c49635224d8d671137da60ce8ba7bd197484a64dd37e2e5a1b76c57d094e516b8f44a8c0f60455c82dc9b4a947181311e2f41022b1afe4f740a8e67b8e7eedfa38982a404dee742b218e6bebdd5a16b2f11a5c4906f97e566db7fa182bf9f8f4be93758ef142c765bbbbb39e61deb99f48c3140ada8efd3f694bf85b2846162b1c8c0a1440c6ff3661272c6b6c2bb9ee7c16aa0e4be48b11af594d13160adc46c9f312d759c87817302b6d2751f13f359a724e6dc083c72bb87f5ddcb63f60723e673167d0b663a54a91c7493a22505ecb22e06001f672e34f16c58af42807e16a575c358b95a8990d03531228e16f619cf5d0a01d02063d708d4a3f399249996524ca688dcd545e12f8a6e5748f9bfaca16ea4502528c768c3e05d0ec9484089016594924eb2fab67f2f830d3c7c0f42227a57a5777f6ea0edd85d5c5a86c7e7df1b297f685d9ab25bdc834149df66d280f6797b93e5f1abb6f1ff9efbc7893f05555b5cef6dd82bf5a50697c51772215c7ed791ed9e89aa0a26b87706dd713391f006ba107c21ac95d17cd40c44ce4c48d8a66ae7808f32bd8db6f098c571f71934ac2e6f4cb273f1634361a1d0e842a5f8ddce2371a8cc837fdef43d3931d66a8310d23ea09ff4495836cfdcf00448c5f7aa47ebcae973c00771d5252a0aad9202bdc2713cb85460a9654d304de8736336fea5a05cab191c7e92c5ee46c06e42fb90a0f4f90aee37968634f5082a316a2a9f7a45ef5a22f143425efdbc3e9f7b1fbf11fbf082d2a8ccde7ccd81a1c1098e3a9f0e8a92e685f5721b65bd0dd88e03963e5c117c41c263b244946afcb61eeb35ad08e4e6331798b0dc60861f496a696554ffb96a32fdcfb04ede231678e8bcd985ccb55fcab28e29665bf30a313837ab045821b1d13e3b78800a7444c20fa290c943dd4fdee15ffee187d5c7684d337404f3a085faaaea0964e2007025fd588f607d854f98239673580a9787d667df858b12365dc2469cf5a8ca2c79847f8036f691c46e953745003cb0ea52f93c0d78d95ac9a5ef6a06159f83391c96c256e4799861536638fe3ae2388aab6458065ead8e0fbc7b06e3ebbf79d2416895f0b99daab4d80e863c56002e458f3a4a6100cd5b15f115b1302421a6606bd800a30c59f9d2f488809534344ce2dfb725def18237c8239f8d932904ffc9b41b2e99d968f1781a3f12351c7d7b9561a74fe4fa194b0eebb1fcff994b787eb7379dd096ca6f640b940a71b8c0570c38ed9c7b7063703f8d151f191dfa93f4748aabf529400611135c487d6744495308fec0da0c353e110a4928ed36bc82f750416adaa2d34f08ee5fb48ac9362d15ac630ce5c8e924484c0081f9d560d4680ee2c481944d553836da0bdb25268ef7b03b7b3107dc9abf30a1b9a0af58b857b3c3f7f88cbe010209fe7a9381886c15b5b613751aee589b70c64c7cf938ce8f3390567939f9a6f1bf6f0758333597da0f9b946ad205a7b3a4bf3134b13d8601c3c9628c3914925301c5caf955e793c11cc37391438ab88e880d3fc66fc411a6bb41322c81ecaf16220efdc1bbc017b6eb9b2c5e6fea18795be75c67b8cee3c014a0251a6f9e41afce4acf23ebc40f1e11a6deb5cb16288fbeb88768ce82c1a083e2eee5690fa1eb34ee15df3c5a39cbcdf93bcfe903a7c9b69ea2c960ab624280d6e75eeb6615ed7462c3dd6acf4a57cdbec7d2a52b545f8aed1964c536a27692a1b8695f8cb7b6f3833256bed3abac47b164d4590b980d09aa55d710b63e6e7e384e7420b36604462141fc92f9bdbd68a6330088a3411a6f11fca013e02acd21e9200229cccc5bce823a4b143bb5ac7f01c21451f952207b10040b280f6ea714d3ca0ac70f7389d5de9132f17500e69c3c8884d596ddf97ec997d9c7c194096c69ee24bb77e6fbd8e06caf41e541eff465b8d85007ef582c14c7e21317b1ee4df26cb7b243ecae062bfe1c01b2d7ec939d5c2f585d8de19dfa09fad259ebc5600cedaaf977c69862d3af454f62f41fac9ac5ee25adc3d6a53b93d9f070a2e98225b155955988cbdde01d7f216147df0f2649084691beacbbc972f3306b1caaa001be9bb7f47abcbbcfe05a2c8135cc359d506447a6f811fa4b88549cfbc6cdf137517d9e989163fe1028b69575a1467c73b751500c77417f9b45032df607a961b4a78d8158ee24368924326e5444613fac791295e915b0294841845cd79d2f6736140c248a76b6fe11435f081d96d8ba62b2dfb8e6e4661b15996e863c90a11cd16599ff4b7773a6f63625032d46ce9f43eafe12b0939ca678243a8367b0b5f86e9ec3c0f959d0f978d43144ca434bbc11b6c2aa78ee5f461c77b17abea9632547f9e1fbb768e0f04bbb782e9c56ca1020a5907e746a650e5fb3b1b04ca2af126d41fb95eca21f0919d10d182e474d36da7f46535cc2498dd52c22fa3d6b198e4278b05ac4a1f269fe8be4617297be053ed698daeda2db74c3da4d9b66419159ffcb659dad8c8e8e0a0d3e9b3acba1075dde44786a673e7ca59a088cba1d14f72fde2391dc1d3b14c30ad0c9c0405451dda22f4f16e6f7d7a8424a81d6955120325aeb37c6b62078a08bee461f99601b7681cc88bb4c3b54308429a7764cfd2bbbdb7467a78414048f7042a1d7b0a68a77f964fa260d0396549e60a9fdf1ad7453259766feb414e670cfd6994d285adc41ca1b65a8d9cb475de0c583f2d46bafd4a6cd130fba6672971d87a2487c1963cb61c58e96b102ff4bfc61977d025102ee53995a609f89dc4e2a183b75ae9f891d9bef5acafd777750290eaceef6dc95a5cab5fa3c6e6e4750e98529e57dd25dd5ccb2dc21bd695a5216c4d937dedd4dd1c95c4933a2a8e9500d50d18a2f2ffda5272613fbc0f6266dac09d06d6411519cf711a298ad88267072cfdcbde6d799d26491a3bef90cfa6fa122954a16df0808f8b0b1018e52e9ca58de02bb8dc3b5b7c4b56d53d324e45bdaf1a1ae51ce4c67d3b7a3cb700244eb6e5df2234ed29f405dc847a8a15b33e79db4321ac6997fe1ac077f9467514f52ac5f547999c83470b8f7882c1dbf98fd9601c03385027ef1c895acbf2cec8df6fb0665a7c17264dbc2964a55efdb573da7b5d645a3c461e8e3c6b7f3f70da1bdb65bda772173012c0a47711d4fe1bf7a89b8f0bd674f4569d86ed59c62f1f006eea8af1ad57cf0a14bbca081adeb053944c383ae0d2367eb95aea3695cc907208627f3a402fde18a52f33501724838356c92364d14f6453b672ae2cc2f34c2d02002e38db2745fcd26f64424c7c46ade362e10751f0491f78852977d965a24cfd7fb7d3138051c658b8760f176596cd45c3280246828121310b834f8dd2c974ac7432b512af125decc4fa376d7c54e71cc3f52fcbca5095820a8d1fa1b708d61683f4490eb13cddbdf640b44c7ebc83d2c02fac312becde072878008738d14a8bb551af8c291d091cf47baf1b9fe04772d7328e3a47be29c2ca818e86655a1a843058a728442ac497cb11495d4d7bb93ae4546eba54d28ce04948b2541297d5fcfce4b51c998ace1a9c80e4d1a0197b6ada2420c805a328fbb04028f853c94bc14bffac8b807c64c5e9b2abca849b33c0ba2209ca5a94f4ae0048ab976e009241ba1376f60290b0d90f5cf8504f5c5331c29d197f186543fe8f2147aaa0be4f0752367c29c2703c024efadd275d7d6dd0c19321998c1bb019560e16cae8f53ed4e7a48a2912910923fcbc7d074f1b93213f77ee5a6a849f8aa083270bcae9ada404809d2b2c78bc4df02a830265c735c71781ae115e7f4e0f75460287f0358ed01d88a7b5cc83d2ccf94f5a8e7987839489c5b9867a17b48a92eee7ce6ec074fdef043a8fba657b3e0f45070ec9552dc393df4b6d976b514f31238160cf0e29b02d089cbc6a72dd87e34efc6e9f97b0bdc449a90254865fc05a6cde527c2db6396101236067a7c2b8a3ee36ad38877c3faead79ad0e5070b563e449e94ec63aba68c2ea3ecaa28d387406622a8b302b0aaaa4aee0c08df2031228c36e43cca6ce0809badff6a0b09209bb9384ea5f8b62bd723cc29324270a5716e6904737a121b7db75410688e9becf36df77f5ef26b9bfa701494631102b8f6de3773df21ffb2eba37dc3bd8e6a9742f431c8b2f09a77688dce66b8ff32eb553a6183e3c006b4391c70aa3e3dec48f35ebc8e3865c1f0ad21a28b5b4e2e15595ef0b085fdf0d3e9c858eb9778aa667822f0347ebf930cca40606b6c7a7c864ec7af058c9ffa3c1c73c779116cc3a1e5752b42163c789857867a2eba527280b682ac8dcefa552855c42fdfec1368556ead4da04c1308ec1294858d76e4bdfbb8d4bbdbb330a5488c2d6993a4a65e35e1893ce8964d947b65f0bc3142b0dbbe1de3f39d099e8304cf2732e58dc87f4c7b0161be11749d3ae1127da534a3a0c4c0952f42ab7efb80ff3fa9729fdd394bac772a3f9d0b5aced55ec9d4c161b5f2bc218eaaa8cc0f7c7a46d3315ec30d26a6b2867b6a49379069e7c81d9f8c1420c761f3f1dea432f7ad8a180933bb1104d21e6c050cb85160e01b43f109ca8e6b733385403507cdb1ea41c3f7aa536f7d8419548c5b94fa47fae52803128845e25e8e30b0ef9cbd73fa1785ce63ade4298b0dbc89c6813bec93570a0bc99e327677ef2341ca4bd327456ff277a78e417f6d25a4fdd3d54dd0f2bf9f147a33a044dcff50decdc053c68e0502d1f756eeff7a38123bf5221f6867e440604a80af2c1014f07111ca750f988992110d0a62b900618fc4f3dad4fa2e236cd3e56dd2b5783dfc09d94ae8152c2de1c40858ac12405ba9388ed94255bf7a45f9183f5146632db50cc5d14a9964661352dfbeedea00666f4e1668734ce6ca11937ae8c8a90a161c7d035db1302fe2b1143a9fdb07d9def8e121d327106728bab88610a6e7560b7a4fb5a425455d212705546540d4823ddc10a1fb514dffc64f89cd1eaf695122dacdf95723dcc85845f192b4796edd62b966eb649620fed0816b17337b7287b38a0c52151c3258f4bf44dfdaf8067069af199621d1d8d67e27dea057f4e3d4b19e6e4e8bf324ea8bad61fcaec38e8a46e55625a9928959e4bad8cfc3dc5551fc6d3ab81a836e75300c896363f2b55d94029fea109a6d7b34d9bb048f457c59ef123ea98717afe4b63a5363c5343aa4ceb432a25a6019d9afc7d168c517deee3dec8343c3f047790d7eb885d64b85b7242d8fa18b8f7d5c0de85edc6a8ddbe7491e17fb9bc305bfb77ea97eac8b9b29c5a0faa80786b9b0ef4842669ab804aac610d8a32e389b5a44c637250a5f5a3e30c920aa3ad6bd6de51426c79afbbf686fec60b5466ceb3cef484e3932c506deaf62bf15f5c8be25851e4012738d4022ff22fa7678702405aad7f9f70acd2bdb8caf6282fed576be715da26d44faccd465e49e05a4c7a99b73aa41c0c71dc9a5faf331be4a2b39c0766b1b5c70a255a66baa1166bcecce4f3fe08f4af470d1c5fbf8cb9ded2fd4847705a7325d395bf88fb0001522ca6102abf6a934eb12f9b6b28c331a62f543709f8f6e9b7c4525a2f7733ac79c4205276b5239e47766d4ffabfecb8ff9ca349d1c8d594812a448cbaa38f24b04a85ba6a2bce301a260469eafa5653050ab55a7b12b2e371b037e20388514c3f44601eb53dff30e670c3f2391595afa73cb7a7d96b64129a067c85c10a6ab997ed856a3b7cd91d77405ca1747f8b9c6031190657321b930b0a8eb60922954fe9e0f1c028d788bc3cdfe6c854be38640ec975b9cbc8159753af13253cd62c1bf710eda87663aad479e3dd6bbe87e02d7902c103b5891e8920042878173e851c779f01d9f8d4eaaf9701bdbad9eb309fd1ed3af4c432f1d33e5eed5ff5516b4a111408395565495085d85c67f3e70814782423e3ddedd1fc5ec1dc73c068b9ac7117f8ebba5d1e81bc17ef720b324d33cf064c30ca4419b74604bc406e8aa8098fea157b5f5ac1fdb9a9bcf0aaf4679e74ad81df052a55cc2a5c74ebb131b7f399c90044666b3dd9f9185f17ea0ce9b7da96fa549f87884608735a69ae54830ca9aa813203a14a814597bcfde5ebabcaf2eb19d23e5cb4634de0dbf79fce1a4a129397684b1e42dc226cd89f6fc8b7470f45978964bd43b9fc319894cb7596885a4097bba5e9c20cd93621d550dc53e473dd5e7c4286e4072b8fb8542f666950c3acf88aae8969c666a33e20b6f7256804bc7c1572a97e62b76a5af6f0185faa05eb9a825af9421b18ccd596f6aa0a2cb3686b1a371f2756472dfae3bfc734ed01be7e0a3eb3a1b1c59d34db37edeb21cd99ebae271437c8976c461113ab574dfcfed5e83b88ff977ae7a3e7cc2c3cbdd734c8b2baaf5ed4a1045b2081e11d2d1bd557212e080d944f80c21c0226803c8fe029f10a797d65b09a4bc84ec13b156e21b57ee735dbdfd79666e901ce86df229e930118b5a996887fb45001b89b64ede2fd080f45a5562667981a7c7e759eafc5afe455895c164efb38282370766db6bf791a63f1058012ecc45d328089de6a464d9f358426392290d2d767664b62abfca7cc894f96a85d6f83597cc76f067744a0bee4f7e0be56d9debdc523bb6706876a7f1bbf79a861a2baa9f9b5c5dd84e0287f28c0c41a252c90719726b40c1c8ba39acc4cd64e287a676e0b36db9fbbab6eb699cd39461714e74c72998c0bbefcd16afe0a44ddcd03fda78d25d33439f4757350d5c42ce98bc23649ba8073bc4d557a695880b890ae0bcb68365ef553bc50874b25560cc2bf5aeb25646307bae7196a0e0e93d46a1063ed3dfc3b3604af8d26ada10a1e300b24b25d9629367963007ebec1bb640624293421438a5fe59db5ef72e04a311cffe12bc0daecc02ed186466afd64f4b17bb36b15a8813cd491b3e39574bd165f7b897162623cf1aa420a79e0eb65988d8ab650848fd55fc979ccd5afd23d4084516cdb1c27a09bb6bb5942f3fbc8da765deee138fe5b76f97f4e7a38e6d91910f1d3d8c65b49a0e49391640a3cb99ba8e3651a36b0f753eecee6740e731bdc9052a8faa979396a49e7f641ecb2c38e2f2292a40ec52c6a7b3097b641e18fa43c96c5e36ff1e5a480a5102472c0ad8552141f4d33907fecb8cf7c3b8d2f089656d676031e121f0df10ea8660c3f7d587779b15d7cd8ab4bc4f1e4d38aa2c8ec5de72dbf62eaa85026d7c38f61c654468ed693ee340bc04b6a01a4bea3362d803323a6d054d8dee38f9ac76fb2f2e44085f7017c3fc84d892b539af21fdcb4a79db3d21cb35e2391a9b11f5610c0ded1fc98b4059a64945ce93fd892c77c6c863db50d76d788256b648b8c54c9f23c6385c269ff8847af8a3c59e3d9d3d55b76ffc1afac9d88dc7003ea333aab573ce7e40c3fc078606b42105868097689e0dc15c96852103e6682dbc456d3ef565157a6279f50abde4da3ba4d32fcbd96bf5dd9b955d35dbb543313908ff68bb47e332a76f366a698d0d3789d8f106deabfb1c323af4c26be472d9b9c71d2fb0c7718274660c959c7dd6f86e9ca88c10efd078a87c40a060a3172a2d54c154637a3492902d425694b56611b959b49128ed99eba1a704f042e55df703f38e8e7859b1cbf92a4f76be3c629093fe05953c01d0b3e9db642864e090eaebdd9316bf3fe9ba7ed8d5042499bcf646ae017512a7b124048bcde581913f6589bfcf2d106c50a58b4372e3ab5ba5d7a03f316f460243e411002ac4b13671f447388f54f70557d7d98ed86b3d9184fa11bcc6736e59deb82fd46ab811d2e945dd5e9643f69181ea6a6d434b4d520710abe4ee76e2945448df775ca40eac7ed1e63a1bf0ad7d118680ab32edc7373c4c71a8f3a97dc39d6a6faecd1ed0d07aa81e47902455993d5c0fa6790f9edcbf779cb02ec67f9719f2cc0f06aa7d8c131d00f73e78ac9afa6582ce9d597163f94930d7cbd3b0e75f0b9f858cd29ef5ec33592eb2af0e96539f8129851100f0661e0bab5b160d2da19614d23df0cc60ae1132c5f0cf538b52c6d5d27447f82efa56f4ee35098a07971c5208b3834ae9a6d6a708886efcd878de70755f13ccc884fd6c18ac95f8b60441020ff869d9ef819ad438660882c1c77a19d583bdf9f1347605d20beda3a2c7d42423926056960b7aa20a8569b8ef581035475becfbdd2155c37c71b00fd377e9da53d693354305e97327646fe3ee86d3b334d831bf45e8a8b2a86a50237a988898039031f9240abadfaa53b083aea5e12e9bf4910be7564c169c68ce236658f0d66bf73920a6838e5ba58ed1e3034bb9df8c90dcc9042b11cbd4024a1890e2771c15f808d9fdada0939c25961f25274336aea0f46de1dcd5597f090499903e7df163c751f89fac195b08b9f0b4316ded78baac5e18467cd8e4fd67c19324c1fe2306cb8652c9ae6594d503a2aea5cb9b08fd9db032029dd89467d7b743b00cc28d88cfe79af923382de4352e1fe8f46d98daddbc636553da6a07616e76b9a12a6bc48eb0587200324e8a1e33f2c0b79ee746c492b9c4409c63dbb03b3a69ff213368862158bb115c2a0f276911d9a7fd514a56aed0f8af12aa17384c3e0f54b3ca7a1e5d3a2063e76e301dd9794556c5d98554f190dfc1792ea01f5a7f9bbd3ce1d01f536c2fb2e52f9ecd1025f719d023a8993fd2daa9d057910a8157261a583c967a34da3df3eb527d6e609947686d3df7c8d8db4efacfadbaa8d7aa6868ddbccc5c292adfe5d0e4e6d96a8b71bd59e9cf4cc93a2301ad491c19b9b540b8a0f0c698432671b9f97b6598923a15159b9f1aa50cdd48343c946e1ce8f430abcd16aa5be74292c1e6c47bbb0d19b8f24362dc053bb82cae44589b17f6badf840297f53324dca63af29a1d88aadf42fa5e07aa45dc8347ba167842e6974995cb8c0df767b8d9531e739b33f18e647f18859e2e1cba388f71b7a5357dd2b0c2786939529cb8e60408b6f51ae27c6b9e3be026a5b0cb1703673355fa5c294977b9ea4a7fca154f69297e562359652db59b9ce0607894f42464eac04dd43859eb3e254c48877be2f54e0032115254843a930a23466510607735e63f9c12665af71e879e4f9940f15ff4895b9f80ff7f8b07f3c65164871a04878e5e890a8f5b9b443ad386df6395226946cef8da81a66861e0e20d2ce2e3dad04b226c24e43377703476b587cffefc04d4c63df40d4c74155ecd1c5b5a5b8953eba0cfc0559352c916bef8945c67726c9bd10327a13bb7bc7017b4e69f20a624d69cf08a3f8197fc3e753eb650a84be51a3ed28f01621ebdc8771fd9cdd14a4b6d27429b3b85d3eeabdacb6c502811bb977ba7d7904bfa81716d3a60c8d293ec1c63ec69478939fc97abb682fffd93b3e73f72cebd0c7d44ffb6f62bde032288f85e4891a47f1ec9ea006cd1c9b0669344fd99d51e9c40647d99db1cc7ae9c44f2ad65601ffa7ca2e42d2b588ef65fb25b18741a7fbcc04f9f5880425afa2a4cffcb863da52b736ea55788a2262a1aa00b84cfa06854dcfcf52f142a9526f838bb9ba1d85440c42c710fea7e04fc77d881e46b1df57759f12b93d87cceabb9915c47e12d72935407d4d30c05600b1788aa1f7ca0ef785edb8979a3ee2d1921560c982558e80daff207ff7fecafabe360244d2c109108f8b945ff5d7cc3376a9bf2667e3343e383de3d5325336617867e2a4c177361d597955eb584fad788d0388a23b5cf4af62076ac07b7132bb6ee5a26e2cd0a08178fc8068faaf350af15840d8bc2b2aa69ff7086f3414c10eacfd2db28543e142999d7de79f4d641b5fe1d0e9556eb4e4438733a36a1b4760c203a613fa45409ad4fda82549d760468d3ce894952f3609c0a7e9e860b25a0e09b8055a528ff36abb3732c2571d67236e3720ead4e620e6f57f0e82487ac27c74166066443b428d1a85a6b28524a1c16fef6be2f13708326251799457217da6ad4bf782dc9d9b53b7772368eb7e48ff5f9644b142147c3d21e4eb1adf9c5a8745ccb84e582bffc314c73d7812835162b2e002e142a27484511b0e422a1d2b011a394789daa69d2d5b7227367c3567420f971bf1e955795926f579a44c28890bbb969f2e6742b71152c1c3010ba4e92353c06f470fce924f8ce2ee85c072b85c0705fe5868211701983293e04d3ba1e75dbf7d36bae4c5bc86a51e7baef090b7ee0e5f9fd6f1c4d01782b40e8e6cf893f41cd00802ead6ac99ffb03324feaf91de56cbc0f454b14002c92da7163a8f181dac4d93cb22a5067700b2b6ccebb57eb9c184c6e0776edd1a2656855c9e2d96797511112a5d854340311f7d6689f5b01ea857bf429f89a1243de18153090c8b76da7c59a2591bc7623ef3e16ec3d5b2cf59e9564122b33345b8df79fc0722234d6576e5985978cedbd0ba8107e6e9c51a87f3876a1b09eb49915a13d388ce06a4efe30a4cc0a948963101edd152d4598336af819a58da5b79373a65968fcf857d7fc6e2135282093cc3a5212fee0e3da89cbbc3d6414955a40d6e05fb72f951f75489e9cad5d0698523da43b57f3499ee14f0909159fc8ed7c0738019e5d6feeb345bf2b592cee8872af168195b5b2e73607a57c661a9fbf87649de62a57f1bf1db501960ddb04a0500e31e2ff9770d1c799519df65fa74b86663d0e7ea5ee62c4af6aacd5f88406304df1bd30b09aaa978c84d5dc600d7001bb29cd4ff81397bdb38dcd70afbbb1fef52ec4998f74c3ee9554061e2092c263ecfdb566e46586a2c0aa1dd0e5759bc7d911d7fc698ac5d6010dd43b7d983d7e9a407322f2682f0f84c3149b32ff4c3e517ed5f28bbb9b9f261917a2ce1045044383faf3fbcc8d269679e4ad9e1caf380d99c16621ad7b5be939fe384c4d720f9a825be0dcb5700cc6c7df9437ad343077c438184c5f976252375bd74909ad9a72c9d4026ffbf66976e87e1272dac0c4a1b9bc1c8ade5ad03180c7c9412dd7053798c507dafa9aec09fbd19f5c021d35c99edf586c4bdf02d469ca51af19b895f1128bb031d390c55f3a35e5a1c56deb633dff099db2691dc601ef22b982e3f1e4f754536427fb2a60d6e1425be3d9efc2b9dd3e366f6187aaa3c3e6ab260fa6b460845979bf23d298c28649b3cc8070426e105c6811276c1dc511b844e9a9a41d5035c11fa3767de90b6d41581af23f0accef9870039a3aa9a938aacb1d8ec03e0e2a9b8c87776a4087cba4be4d92525e636d80df66e825cbf07940fe09583071956d8ea9aa4ade66ebd5a23388bc447f75f7732fe479a4073033f3c9eb4012b191a8549375b3a4dda7c39cbf21fcd31ab25b24ab6663f20e0b74b0d60b5ee595b4523868809c88c90a83a9d8496c614c026d1ba4fed68ef17b1c56e1a6ca0ddb5fa09e66d155dbef870d14e51b27752d830a34f96370bb643db33ce6b7925378e84a7c5b71b7f2c2325adb8dd1b037f611081dedd21301178970a81bed2b634af417d960af3fa77ebdbb32e1fc76f7ad0b63dc4c3d52aa149c8d58bc51e94d4bb45255ecad15d6548f0ffe44f4cea66b222048e609eb463cb3c5fda1761d055bfd3fa12d1392e1a9c3835b39da595b266a298b4edc1027c37119bcaf238ee39781f402bdf6902d6124e217ebea57cf15ff85a6f81e8ce6c9e351ab0cdc732447acdad2996659a339713e3496f93fe1a2e74eed9b49b3dc008f745a2ebf7e674de2a3ff781d58303a869e6ab847e314e813d787ea1d76aa5c435647b39041303729578b634444452e33b3a21320810cc29c96ef975466b1da9dbe680df1f268d176ad0aa559865732d6007c80df701570a48b76af74bd9b556f1aa6fc10acdb512bf2270a97e260500be7ca9055749cc47aedbe3acfdcd069798f5cd9692bb80f782c1f6f71795c2c03cf1302a757b3e5e6404038d9a9026a3360dcae44a915ccb46c449e0b2acdc0526811001c3f919db816c7e15d76a26389f2ea251a7b698ae5b67b7eb643382b4e44333784e6103b0300f34243d96833c7783f3f151a10f9f229be91d83ca68840501cb71a212e02a48db81fdbf9cea9213007de42a0cb6957b19cc3d6d624e212a722a5131c8c2cf682dc2afa5496bf8f64632238f73d5a42c5b487d8af432934f3d0be3d41f279d6bd7c8c4ff040dae5ede89339c26f8c747b3d4881c49844d42164ac611ac95058b887b8b645952065a61f1c2d854caf56718124f9cc3d2cc478512349419f6ecef241957ded1fdf306f03d1e0a826970ce65effdeb14f168d38bed8973ba7280907c2f1d833aefc5bb3868f70c42f0687b1c4ddfd8e6eb390d40644e01c363cec9f754c0153d47e80fe0c66d4020105d6a33995dfda407b447337319eec472fbe129ae9b1006a1e1328edcee19217cb3d3e58ca9653ed08dad893230119f840d3e1c439045b09ece4c8f8ba49cf5137d0a54d3f5a42a487e6161188b0b20bea75025b90e1059204852ceb6b5d3374d88c255b72cb80152fdb5bdcb7f3c866ed2e5a1a2a8577a75574b4fc1ea440a8854994568c026cf6cf6005d3cae70093f8ce899283c8072f725daf53878b30f886e578299fb99a7f70e8a8083aad6d41d4dbc6a6ff3353d676c2fa8d18bdacd64d89d5523431bdedf8021e4152b7c2c12443360dde0de88afed2613b21e2cf94bdf418612ba88602f051b67a76a73489ba74f5d481e100ff265c9061b5e05feb031ed37de880e1834723b761325ec0b57246c1d90739452ca5049df768db897801a370ded26df8b9380ad9d91c2c1b81a743f4512d8326cce946a26bda7d673a42cf6e54233fd0f130070a788a4c42d0304a6842865f74de55db991e0d603c16863830bf022c47fccd10ef0810147ba8f496a10a04cb30267f84b2e2938aa953d933d894f8b04fafea0faa09d57c98b407a48bd6cbe681aa846fa4828b650c1e3da5595fa95d2664bba0392eb6fa85c15d7afa2c5d53dc35739a1c3a659cdd07e0eb333be52b1378fa2a60dc37c16a410a591562085a26d7b9f2333b81c02b83e6ec2e5c063a00cb242360ae48e533cb10d4c924b55ea162ae1d0b2999b43c68c37ec5859f02d143c68603f3d304f799c5cc68f2f853dcef211d109cfa2af87320b7d3927a6bee49d6e5542e245e6a08bee5989f7d2bcf57054227a291c0fcc556dd8cf0e645ed4a248b28951581a21b5154dcd3b77c84bb1d1fed3bc37e28627703b320581a8e37d4951494180461f9a731028aeddb63fdc86d8bdc17ceecb1e387883854599605eb15bf4704e7826b5eadfd938c9b4444d21627edb523fdff7501fa61b24b2c2eeb7d7903b98d885fb3c3c712d1f1ed7c56d1c14bacf3c6fc39580d5a295c702f81fbf8cd927cc467495922ffbbbc8ed4b80986c70cb2a83bb50cb9f32d94070840899be1ab40793b77de4da5595e043ea702d8a4d6ec0cb6bfefe49321662cbf6dcb112def2d123328dc0423586b7df22e62331db1c86549eccc7bb3d01ea4dddf0976d3fadcadcd4c0c5beeed2522ebe09cd0dd756a843381c923614198a8efe7d8d0abd292642ddbdf6f4d10fff16806f149858b17ef98007a69bed1076f065043ccbe62fc0f985f943edcf997f26de5e3fb291017a80141f0e780a60176386787deccd1e7dcf81c3b380a01fe213f1573a9d3d39d4ed915443e71690b2e1d1eb985c7a3e59a5bbd53be9bbe1a5bece26b00ff224fa2f2875871ee5758e15233db4556acfb907492dc0626849280c1c59af61d611c39ff9ddfae68a188f8f96f41fb53d1d3991966fa6c97228bcfd1e3c49c13738da617b5de44e71586db37f44dbb4d9d106dc3da99b3af00153175a69df0b8f9bb6a396935078224d8b6b593dbed07a2b146115cac497f8130bec75e2a6b5a5c8bbec20de94ae829095f2042e781f7aab190459fe231f1baa96f25fa458539a3e7b9f8b53615da0ef764aa8f4a20c8bf48cec5b306ca3f7c4420b4c636300a22156083cdad1aae36292f86359907d8f67bcb9ba357507aa4f29cdb47884c74f25ad5ee40d5b0cebd85956fb273ccbb17e5fef6a388af04c90e7cc41a9b7d963e92602b361de33708000e22f7e091b60ddc1ea7d545cc162cd5d9deea9c547f5b64e20c551f72fb9f1af2df22816d442a6c26a59560493b0395e55d76dab1b5b3411bcb9f6fa2bf6356c6ec4fab939537bf69895d057ad30d5460b9a29d67af815b7083db7f663d05e9b51270c8970a5be8e413349d03917bdeca2ba1099e5b5a2adfb488579dc3d754a61e397d85bac738a3a3ad3c83fe227d063323a73399874b76c36b22d6b3eebb5f612175d7f14088f8c07cc264f407cc98149f925abd32bff977a5d746018c0848316ce058ab6c1b49959207fc23326b9856a47efe115fd14f7d5b7b6ab8de44186646f7ce1df611486fcfc2da8fd383854440fc1350b437f3e6f0bc097511bcc4ddf213e02d8086e7404302500fbf5bf66c72bbcd2d192eeea4cef346eaa8be89f906360ef567cab01ffe5bf8d02e710d22b1b5d8ca1d9cd110bcbca45d3224b01db700c3445767dec6703848d1dad823fc7d742c41368db267c7b9e42642e4253333865b1ca7d05c135dd803655fd8ef570ae6b01fc5857748be360a34c26078281372da3592eec98756f8aab4f3f6b4d1eb71f7e4f57ea63736b4c289903b176dd364677937eda6cad233f83970feb7cde03f89846793731e259bf4ba6dd1077861920a866cf93225ca89b645a5a646f2a4e2d8e9a6a607c7099b3a703bb45a41b8f5232f60d5d006e8a4597b01e51facd5d8b96e7991d563a474a0e98abec5c58cabf5fb0c6f6c804bc9f752881aefaae6955c65f79c5b063f330c777b9abe870a4639a57be210c8d7897e96189ad95e260532937656de2886165d00e9d5520aa02b209ad591c2b914a73de80241d380d2b8c5af44068125f1ae6f7ceaddc358db524f7e473dbc519fb92d39f01b8c8b3c3792e631539fbebaeee47ba07b9e7e56ed5ea7b34461322a8aaa5318524e3ffe170f5aebdc72976931c09c53ac9e0db4d326a0347d92220e39b350c8d0101d3ee3bc9e25d7deb7e87bae17e3ee319babc4a8a86f44968b6a972421397158ee03e5be3c97efb20a30770f348360d34026c9b931b7bb6ffbd553cc08b6923e3d9d66a72fc308d6e27ce7a6d2cb42ce1a6b4fa461fd5454a59edca51e136319d811007769939390721aa233e116c52cc95bcfdc94961beadf9a190cce734fcf53a8f3734ec3919d52ba4307e82e2bbaf3c0098bd8cb621ca2895f2d586157d4847ac56a371a8bc0fe5c2920804dab08c1a6341a6f3dc49f0d033f994f313c2d081a811df175ff5d57ca6d35d6699d5c60c9a63a511598b1e3f810521bbcc699bd445f233ba51ffb209aed9a2dd7d5378211d4bfa709513a08c7626678639d3446a9bd3e4b12d79882cc93e15a334501da20ad8d512f663d07d4a3b8f568646c8bbb9a3b4a3d709588f2709e46a537eea3eeb358619cb46c8fc1b64576942237369907bdd3065e1fa4e65ed1706bcde31a7457549eda82c8f12c48edb32a24c636fe41fc78caf34a281533fa68ba8680ff68680b022a9070a4ff0c79b733d6cd404968603d49168cce54c10955ebfcde1910b9863c93d92dc24f4a62611154aa4990f9011b642fac314f310270fa22ecaf133a962fcafec788d0489fe665a1460dc593a17ea6ee53517968488755a75c0f72268971e070ecdad295944d4acab18ce9a155c8a0a0e7139c8a5e7bfa50660a7a10e2cdc7d448bcd53320f1d463ba8754ec36cc1227c4bfecd2fdc2e5716376d7e19bc2a4437ddaa61c9703f026be07063da053e6dbe180b5474ce6d0c86fabaf206501f152b60113b77706809f18d70b8a299bf9e881e88d0a3903416cdf07ce0bcff26d0e12a326228651da294105f65763d2b9ded1692347e04de598296ae05fce30e74d6e58fe7701918bb8b5655b467b9f8d9360dd91023688457d82bac3d71308c510e257276aa3446e1c450e6ef85e9a0f96d6fe4b4d1d8ec05ce861e0b9b2ff6ec9ee0190d9253e11c928da9fcba6cf18bca3ee93997fcddaa3d9ca960444497ec26957084c1c286e4fa3ea560e8e409b983ab18338eec6dcc742e7bb0b3552c007397f526109fcef088620b2a882604ce201afa53fd68fc10b74ae25993839097d4243c3a9ba8bc9ac15a45d6962981f155b331d5955527584189747e2e150d60c579172801ff79bc94260776850c590d8fcee5e404ccc63f63820dfe4489ec01877fcfbca01396d5d1084833229b8bef4667479ed61cf56664e49b0fc375dbf958839cfc0419cee05500271ad00b555e064bdedb048c0a477491952c4ca7c3a7e7aa3101c784013839013aee9c0f549316ba617c2bc19aff13c170b93961ded83dcb809562c98f68538b04c51f524627a1b6e260262e8b0060bd1bd296d18982b259a29d11eec12064d1937e709e3915f6139a5f5dc4fdd350e58e5608a7784bc3b8f951281d8c7964f527488ca4724eb6a9093364102cee237c2a1e985f8d5ad5e82496d58cb3077f6a17c61ba58b66d35df0de135cc41fc87a7d473b28ead7b2a7fc8c0b1894b563d129e09f093017387f685bcfe0a2b4c12a54dcbabe01b0e583b5d2dbfaa6e0573f370f67e697695f7898b23ef2e0e4bffdd06beb5c9e31bc589eadf7218109375585c391bbea63a0fb024eca93db090177371dd35d60c337ce64b57ac95db8743982ab9906a8082af68b6d2f752153c7211d26c02cb4551bdee45c59733194066cead59dbbb57f39d0f7d29ec19cfeccf64ad0e791f17367be4066d71da639b7e5974c329f1c1ac85ec94ce85549b27059e4403507be5d85c2f372179c5af7c6a5c8dbdd8c13f2bc9a592aaf85a524098f3210add3ec4ac15d799438405a1d40e3e5d4b81d3b7e637c6ab3952932523601cb5381dfc179cd20c3de846fd3130cf2c82008844c1551a416fe139fd2d9782d7ff5721fa08e68c9f3afe1ee4a9052192c83c3825be1f0ee90d1524aa4ad4a964529ba2b4c5474f8708a0e646e33976a62f425af9c587dbf5328a6d404f86aa0918c26b58951bdd5e59ed1483e297efddfd565f3b605ac4846c007a7782971c90b3f6f248ba57b6e28c103f4fbc34e574e565b3d60ee8cb13245d209f6c5c9ac46bfcf89c24972674b051dd30ccf957e838ce7faba8d61e08271e6417f6fa72f8677e429ef495e89c0f5912033bcfcc7e2f562f0f84d3102bbf64bad7d5269e7fbc91884ccdcbea8354031578d520e7bc39714f4a71701d275b1bdfe74f8da83587bc8dd9f60ded773869c79132b755ee654cff1985b5f80ec7f78ce5438a21f41b14dd2c5163026bc4fcf7272a1f4aa2d452f92cb33103d2f45b41848b00cc204144195f16747d7421dec3659b19c02c3d1c68a9389464cd54579307a96f751c7c91e9416d3f714df9c9934b83cd4f2382f723a7d618a73abe4a8bcac5a0dfd36d2883d5cb00bbd46643372c63b622e25583aab4dc50edb9e7f0d6ba00859a303f4c85d1296f7d8b76dbb330f788e808ef061e500313c3cf6fcdabd70c1f05a51d365f2003c0101737b878d33c8856f8cc7cde6f169c19637544a8b91f92eda8c7b7be602a18aec559bdc864c904d15a8c81dafb6f2a3643c0dc090830b0713229f396656b54880063f8578770005c98cb988a50429e399d796e1d0384a1d23e08b926b4fd5397dc6a324bb43a30d5621f7aa5bfb2e86e867440e4fa8f7fe750c1600609c72e168f6dc902b5abd6c62a1758000bc453bd77065687d424fdbbeb132badd16d0198f22b335c2c5930d8a95153baee10ed72ca6f6f588aee75b11aff810eb13b39a2049ccb5f0bd16cfd58a18bc695569d1a41d47eceaa42ff29e8ada7e7fdcf89ee67e9d0a219d06d0ef840812420cfb63880c39321d53e545ee873a61641a2f6d1e105afff74c8c6580b18b89a245c04988e517fe84137b780add993dbbc549ac9ddc9fca80ab8b616580fcf932881a34858bfb260377522b853b97835e0d615d9e7a4cc051e4f16726b757dd22b2e33912eb31ad7964562d0f56a70a4d457d13934de3238ca6674df1273280d1c5a21da4401f9fe4e57f2b43401d17af20879d5186523a977c7da2ae18f0226616d210a3304ffe1e669b8edb7956e8f49b05f298d310977663ff584af46e7a0517c15e275852a7bf84bf65da5a54b931b0bb17bb334b92e2a09953c17aa642cba51f4a5ec3527fcaf290d772c7e488560009ebe4ad9a2c82c82ca95f818a58f5b4976c75bb636334f2bece9feb8a3be42a3ec183914607e26310f5df6022b136bfa9256eb2fe185ae6344a3cfc85ddb9f0596ce0b0507afa91c3a6af6bc908611b219b3a87cf07ab30edc87d895d1518bda5b2f6d26dfb297713844a665be59e9bdee5902e077dcde1f9bf7572a14e5cbe87f44b20e5c31a979c47bf2d947dc8586b7af4d4fea10c0202b970d6fed3d5a4d07324fc07f46eae1942090b9e499ea79ff59414a81687e5f4441bef77bdee88d33a35f8a06873951bee9767b34f70fc61f0f7a4376c2526d024ab5dfd554567b1b251f79febccc4e41475e9240a661e373c4f998d01b0aedd96f3db638093be48d057356ac08a878fe9749a16e4642efa4c9a11cca4f87b109ef297b9a446217a827603ae0eb290a8b2cf9bfd48785d615afbb2c0c90402ca12d4dabad144a36ca4290ab1ba881b29f9475cf2176f44fbacc725c47e1bc2b765f025daa82a457d32bd14f2b4231bb1bf289de8b23cba6e2dd58ace7361beaa352a66c6e2ad979cf1b962c1670917ed6b1439e76c83a55c66de052e79e8e6b6d4e1ab9c69f82458162747784b04e2eb91777e6c390e66ed7bfe114024ddb2c9d8f4270f337ee9f7196a6f6ffcce6e9da803c4a00bc68db2876192ecb3ada21bc76886bb9bd9f0d6f1f8af1af122e25991b6dbcdd69cc607177a8c96780fa03baed5a9c924ecde4a6eb22b1729fcd5ee61a2a44ae68147e757d910af07fbdf0e0e3a888cf1fe14fc23a9490763bbe26491754c1d09fb315e2433ca4b87b37582e0067d7bb32fb1fb1adab9db459d274456514c1413c13e8e186f7020736933b6bd310ed170f6e6f0c3553c9ee032b4f2aa65462c2990fdef7df7004f2c68ebb9de4219879733e143b0b20a813a9c3c07dbd444a47ff7923e8163c4071ebfaf6adeb9bcd658ba9e2c1a2c8c229ffe31f81a2d7a8a1a99511baab54e0dcae3d39586f827535a39bbf6954a476246caca4873a434d944b9ce91c3693096076cf78c6c461471782388325a4346644b3914f198685cac61e3b5fb9b539d41f24bf256b20c3b6c08a56abe1269879e5f6db1f1cf0dbab48dd11f339166bd4183e2f48f700bbef9f8300dea76e176fdc78249a7d7b47b9967f341d14f9b032f5c2d3ee85be5de3a06ff43bc0e59cfbc5e5dc9e16e1134c5467ad475c4e75545d9d77ed56714264d7302683ba2c347be961c890c36c48b32ab3f7982e658b14857476ebb2b40853a0c63b018962913191007dcbea8d35a880d4848e76e3a48bf7ee43c2d203d0da0bd90f5617b98a1afac8e969eb9ceed2fb2338671f84d968e35ae42be48fbebda2eb2f0607dc994a3deecb5c2e4cca5efe1dec5df79127da691571c185777db1d80160dd7bfa5bdfd46936d1d398e59e9224ecb3cfd4ed04b2f89a495439b8cbbdb7162122b814809eba12e736d49cc276207a8ba30d6f0ec38e1f576314a2fec0d1fe92d8e4286e7d249bb7c18c139a3a1f4992cf2d56b466c55537bbca6fa5950e7443a89da325fe6ee0abcbb1b26aa118027ca42c2e759665a83036e3d9208e960d34f464b28d9dcb45237c4ba4d3b959c24cdebde748359f131157199c83fdbb0fca0ad328b9953e026aeb8457c25db09a73ca3255e91790a90cf322f94e72e0f41083bbfa36529fa1fffb93fe760c560eb5267fb0aa9dcb10ecc854373fdc3aebcc0f07c3f2ed07832da63f129950c597e502b215e45b8e018b5ff81e28efea575db20c41a55c555cedaf62cd5b241921742f3202e89d77caa6c5567ae1543e4e6f77e8d6d4212cb31f0bceadb205528dc402b5de8cbb58ccfc0c959e43804c1b8027290866b7cf6312545bf795ace0305a7f356f4588e8fcb89a80de333316bc2f953101bc05fd1d572ad53257952252d2242961c95cef6634a75213c10926646373d50f698fe2e4e95d98a805d110b1aef5cec64d7dcea50387431b509c47fa37dd0c256f32438fa72a76e8e2cd3dfbef7bbc914dde1b6d55977f57d80a4b99c4f9145910a1ca4a14fc6c46e709635780d6bb1ae2896902a1e7b02c3003f30ead65f7642ff49c157273425a56e12bdd6d19a59dab2736bea4fad98269941b5d844c3d2540f9344427aae67d63eb9e19f58a1cba4969728fb438af483e61e03dff5b861ec81db7fd74eacd4fe696838c5b8706f6635dfd7658edf5ee8c030997f6fad6f56e1af9bd7d581b341ff9652b9a15113942ebf7093beab0e9e4b24a0a3a6eb4f49ebfa0d39b458cd28b0067ded776ea4ff5f8d5f167290c322380fe6a32d5908ab585e6e407289194cb7ddb02b43a9b670ffea16dda080ac81eb8c33d54289cc8c3c2ba65cf70e62a94b4d8e860a20197ec04fece5bf9ed29653f263d62a3cae5dea746241bba4c07b66631548e5c9b558b5c0bf9b1ba41dd06f9c8d87f45c4bb006804c0c507b5e2308b12fe23e4a1fff47c88e81d7f1beb738ac4b313517c47782af42c4214533558236314cc0bfd5536e022292a90fc62680ee3237af5622ceaaac530d2e38cc107e046b64d80b6fae7d1305dc94e39d2e88821b2878c7e31e1a828e80c18ac08e888a779b74b68f64677c5bac4a85cd04e2e68a0db153dbfee88d843b5bd8ad2c25775e559a39736dd91578a7a5d627665cfba6002da79645bc96185e08e32a9e7b962f7918a0c0bbabe01aaecabf4e095fc3a16685f0652672c12c56ce38a5ca0293ca06314fea73a34b90c1f4413b023b235201b1b01e01abafe70c7c9be80b511a143e44d5aa36240b635c695aa8a799f1e8a5e876708a7fb8cc40302faea02edce3b751b887cc409b0bf45d6ab99855bcb980c8a9ce85512775641d578361c146453ce92c011fa547bd8fe57270826187940c9540f410b8cd48d6203ac4301eb7b4cd89b8427ad5012c2ee0cc48aa5a627ad0429cafb54174c2413415fb5e2604a5a57e2c2e52faa09519d4eb0d347df9cbdcda9739f0b7934ac1e006672f6f368a76562f958a56cfd705b45d11de6bdf38474a538db82651507177c4f265cab5bcfbd19fdf0b96c8e9cd18887a49bc5f2c7fc8027024a1fabee4a4508bf11b97063d5a71901ec421f67ded3d82a827d858260afc1897cfd496d0cc41cf1f7b50166c7e6e94464169ef7c4e52f747e189d63a2deea8ba23b4162476e85b2e6a949d30ec7a1535eba4e84abea2cca1c9a6c4cb0c4e84621b5a60168a982bfd151771411f8803021e0b6dd6905327b7d0a6dd515b6d99c3b6ec75291921316fd555f8c7827cdbe875f84e4a7d47057518bd6c77e70e393a20c53b12327007a4162360f5fe1014719d8830d4c0d3f33e65f43a209c35ed695a13a4e938744f360520765485bdbf4b12c84e339846169433a02186afe6f31946725ab8e4ee84b6be42dcbecb38058bb9b51846041ce55565f3590db56cf189c5550217536f29132a3fa71d37159e6f475c92019761fd92e743ca4e3a1ff21fca9a75b1d87359acffac8fcbc4a0976ccb5657dd57092da4b060fa3e419d585b3ceebd8eb052c7b36a93c06de7da4c446f985761ee8f6c0f7201e108011f9a36239bd6d3962ec10dbfc0f99e94a6ef177a02977e23664fab4810b20c9c00a7ecb287dc1095892796593d8b8eb4f5a008c12c5031464e378ba3d05404796183ae2610bd011031b97768a6cd7f3d7185a5f6b5a2f980f7e2f80eadc8ec8b570a26d4e8b690e1ccd937c541e5e8f64ad4ba7130424859e4b995b9b015b048f32a5371f85b06a1ac25897a3d92914fc6d82aa05aea0b04027322c465caf0db69ed5cdd3e99c36740a148d1c480abb06d19589c0d0758ea9b2fc1761aec59567dde7d149bb7a6d7634bbcec388468ac49e7b172c9f095f962afc57cb7a8afe62d735dab55b688c6fb2848c56b11410a6f21042ef3ed5ad7b5bba1453b1223d04c83fe227d2db7826ba6ada014522ed11f8940afb50e61ff4b5c5526a4d648cc762254bfda31ab7d7bcace429080f2f61752c0e4c465f92ca1b2defdcd859efa0c12f6c623dc0f032844d34331df27a1c07609e24bbf588b97f07ac994bc083d1d446b345453ecb125695038022d207c4649b69415971ec39dbed4ce0118da424b878555ea3560ee93d8ea2131e2b69ac27afb3ca8f3219fb4e7bc3661a66dcbe24778f2871a11a19c087eb8d5f6f29ba534e1e04c6a83dde7bd36b47ae25a8e8311b76f9880ab0bac895c77025833406519201fd8bda088f431a59ca7c59097fbadb568ce851047f9c0dc3e1be3e12b51c7654c3b2e1a81329f9b15bb5c4e8f30758a8aba68a29b2ef0cb25917edf08a365a25db236b19ee7a1d1d4142de4808d7d38ad7cd9bc4920cef64f415d27f063883a2fcc539c2a849b63de0365048aa65b2d80b08c1137a1fdb6c52fea0990c1198b25abba165e8eefc3fa84c7bf4a0fcffc607aa0b458e5436f03e0d01bf6e9d261df4cb0c5f5d92a675f0d9efebef52e815b956de1cf96f2b8f8bdf1061d6a51d43b1dc79312eab71025e06f4d01c3c40d1ac256fecdcee2b58d4cddffbde65526750eaf965b5f59f98a220048cc04dfda0a7f14cd8818c67cc1d4cf3006960fb86621d31baacb67545a6e14e5e0e8cb8a9c736d46e753c57f47e88c3916fa236c2da32db9e1f6ebb4d6e1935c43ab830fdd1b1ba8e9647368449f83c0aeb938254f2a24506bf4d401a53bacf27ec8ec79a8dc4869d473f8310623f405b8a1d431d63a6d08270df5434577767631f2003004e7d130e41e78152bae122354d3942b83a7872b5324a4c52b132fc132a6d0f490f021237be0bb77c1f7b2b0249fb2b26c8f8350cb18c0274db49c0bbc4a437e1c5098679fe76729fcecd19b122bf0e056624b6d020d6530fb96499b446a86fc3c30047b754de3e1d81d49b4f076edf5823a7a68641df9f4ca6cda3f27d00cd4a556f7f193fac712fe328d6742dc0f6e38c344d9a9ac64b538280ab96cc0b0b93f73b2f274102a07aa67be37b29f4900f1931025f507c42a6060fb65076fa0669ca6cab2b7a2a28b3a28f4e8e9eb54c64f8a8b45d2a3b7090fd307892472141cb1f1e1aed31f6a651b625987e16d4ae924c8664f3a4e546a12957de91004663fa4a7ef7b2d5337f57598bb7720afa9f0b0877a83f285f3939f0df851b2eccb41911c1939c1f7c5923140a915e66cbeb28f8f82a63be224326199d40355a14a45f5d2790476213a0554c4a844e11b2c1e5bb90270ee369615035329590bef245d61a6a67c6328102c519d8e18144263727a946f15e462f13767e7341cde2ddccab5511e3e6eacdf382155d6c55bb6fc494e2226d109d3adef84155b08bd05814130683a4c8bd0a2af054cedefd05b4c400208896f8d72bcdb9282c854fc7271ab426df9ec358e622e102c2631289a5f860ebfaf8d65c2dec05eef618329a1182acf810979e4a959ad2485c1de7f34d0357541935731a8ecc92572af364214b112097d7ac15ab42162e7ac79fb7373eee485c45840b9205038b80005584692d30593ceaccb0bc925b9eb3f772a149e5a4099dca2d1330cda8aac99cafb98a827079dac63bea827ef773608e936e39ee7711ec150e418e0bdb6b006e29ae518800bae92b11a586f4b619580ef32f674d9946fceb19ee78473b438f181e4d24c3393c8eb8b9f342382e998535f6a7e113a455406ad4c3d1b96eecc8da9b56ccde136a77b0722ef4ee352f4b3df5843737139a8f03d7baa95e9dc6a0cde4c11126ade61a6bd159c32565f013f7bc6b453bc6964f9852692c97f540629cf0ef4e8dc90e2d883ddd87629f7dc5360cd2ca1282fe234084a136072757394ee8ad68e74d09799d728999fd84c803c11aa9cf9a6f4c67594560b21ae81d9e84ac07d49fc3677ab4ffee6c98fee778ff0ed824cc98ecedf87d0b1248725ff5214dea933fd9565a98c804f481b5fc92118586891d6ff4d5e2aa0085b60148f8a394965816e25e32a7841efd3e9b256a6c10373f98466b65cb5e73bf675722b59d7ae32a9c54b4b69340330a3a6184c020b3b116d0d62239bdbf9b6f6639243ba5ae504d834818aa46da735ad3ff514e0a66be3f47bc1f46280635bac3f04a43b912e93cfdfe48bdd9863120a73003cc9f98af65c5f7916f4b004c585fc947689b3ef5fb685602bc774d141de5f37c6cd7a7bce2d06c5db360905d308f957cbfdbfc7d107c578e29c889a11e020c59b997682c14c862322f322bc584bc2a08e55aca9ee0faabe5ae6e6b1215e1803a0379a64f1910063680845a7b11f6e0e2ccd75ba856402160fc10757abece1d32d82f9b4b876de83a3f113c24b347140bebb61613f7272bf50048003e2050ef3232d578b4dbe27d899ba2016e7161a8c184909641d2685d0c99dbb8d848d1cc964f65e3f7b75f9b38563f70bf06b981d63c3c2813fc12f4dd16aa1af413b7cab2673a74972f23ff15a03c62363fda08052d00504673ac4d6346a7fdcdea33c37badfc3733b3f2ca1e9c7944f6c80baa601e4244aba25d69d7ce7006efba84d83a527d2d64622e008888fe99c64fc758d1b2996f26e6b870c7131032319de8eb517a36ca66ce5a0857d0b77601fec408a0916af082bdeb2ab3f7a35016e7ba231056b6789577ef2f8a870b05d2bc833213e93d18159793873d22d7846ea0946c96d00f13b38f1825d1139602c3cd48531bd7eaf02c5c0319edab39c64e973ff4cb86876c05cba17dd50371419d978a6d0f8b3db0582982957c51cf61578c92b062f817c63f4a6f321357052696c09b857932354977dcee56bb9065744a3103d5eb24145c3de7c01d41b8902bceef3424f30221dd9a623fdafd508f74f2f3d75ffc0624d98b6efb80496c335e1fd02cd711f3dc41bbef85431ef975a858cf688d619f12dec58fda7ed2f792e03b2e47af63f42e82388a81d60c150aac4b9dcb626582697fbd8ebda056bddb671c4c85c27bc0cd5d2d94427ff0ec7fef35a29d262319a2c676ff3751cd1532bcbec3caa80e8beac5913c174cd7af6e35444d59e4eb08c92ff2162f63e3a5713e3493fbfe1e2b2f602d02c7eef6135b15dc66cceaba72cc2bc75a9389c3f16f5e002cf1e7398d020b5ab21f3b7d8ef07b6227d04bbafc519d8eb935da6e71d521c79fc586c3808d52968df9aef084ae2852f05960d7d7dd5f1d564e55a5a706a14b44fd8553326af9e77b23e5201a592da2a15842673348be8e8f0a575efd848cbe68089121e520760e7b1b22a7780f747cc59752dbd0fafa1e10df26d163a5a35cf66fdb81bd947385b012cbf6bc8337440c0fb285a934c8d5ec696a0dff783d5d16c19871ae4b5157c97febfde07287ecd299ca6dd89dd0002068ae235b4ac13037f58233dc0ca0bf916dae554b25c69ead0fc3343aca2e7ee8a0e4dded1f2f0f0ba556fc05a9a89deec6e902e4722db1301c0f0a75e5f5d6d7b0de07e74a98d659ce54afc8e0e4b6a21c8fc6d07f47ed7101dfaf5aa7a729994dd6479127a139c055c2aacc4482c989c43dfe3a297426fca5ab8fd6dbbee4baf2e786c5da053eb6b669a4309ce46e33bdaf14c1e367202fecaeded93d275105e791e93206100b77851696c3d521ce07744882759fa8c5455668d2f720c2ec273139587d232408a47f1abadfc8841e60678f5d8d1f13ae7c671ae5a369e394c761a6977474384bbde9cb97f8120cfa3ca1ac7b201658f512084d2a44a0d480371085f1e53c5457c9e001202e2feb7f8432ef209d3e79611f6f4cb3897f510c6786e76cca48162bc6189ad9767d0847f2294a41d1a34ed973baa503c13a0a52ce5fbe96d397309fbd39f61d334f7d2023fdd250ab38042b096aab950cdd249663ce63da9865e71497ae7b653b3719aa66fd42a414ed9a22ad69f76ebb8eb880e3cf136ae7ab9674004212a4bbcbdeb0403d7761877263f0ec30e3c42d425328f6dc6db7f6aa297c0857a8b56dc08463c43ef5ff41f686df75c60eb1f94575ecfa82f57b83f9a25d44e4aeda04c0f55433de60593a31815c6621dbf5417e122085e89551131d98ad9a999a44dcb3cf4e8a2f044a3250a24b4978f1d270931484d37317dbe2b0b3a10dc264b23a39e5f3e5704ee18f608dafb58abce9c838d691cca9ac7c40b0319f1e840a1dbddbbe32e9c65122db20b99fccd7ea317ec9aa9549e368a4558f6419a51c0c74ba4c14888f334354034ef28e0f01f0fd48df5599baa5c3a2a06b32c03291f069b2375711151bfde2cdc8d8e1484e830fa5318e1e6d431913a1c394fe5e20bf501984286fdeb57dcf10395fd580641fbc2e0182a9ffe62bd478d317c99367860613cdde778a0167b09a264eb538c78421d08e531bcc549d9083ea5ebc35cfd7f1ee9704ba971e8042ead9c06266a8336ab0a294dc527c76d726cc9d8b414f450e775ad9ce478b328917b9a52aeae0f52117f3cfd7f06aa2c45c7420bfb807eb0864b2ce7caa570c7f903f42ec78a8559ab54fff436a507339bb66c2c27779e66c88470caafa413f568b21ad8f34c9215f08d2163f140d1ca5f90477444f65d6df84b2ec1eb7a5214950a652cc6c98ecbac2f77838a730355d3748c2e27a78616e176a7c18214baefabcc6713f42f38f4b76787e2b04683a86849e3f2bcff6b0e8572901ab0a700267a3279dd225dba4a6e8dbf5a976170c8c6f9c1be93884f14e73796ff41ed6e063e6993e726e130a0ec9529cb63d466e2a99a896c36708d34db809f31e0e3e2eb1756410147f4e6434b817a96f650f890591c5882cbe680dcb06496a33477a77998b3ea20d370e9911d4aa45893b8368d27c24da9ee07dd781f443e7bb292f6822ce8ad8baa65855c7398e0b98e8437d0f4c39082d7e3b6eaf38233136d96953cd35166a7442c787952fc68d2bf82e1a4d7a9fa65f2c7a95cf30c642561c72afe7db5763d60d44e1dee843cfb8d914f905a23cd86370340f6990ddc918f29e956b12f1a25679fd5c3d168eca54a4d6b50762b4d8894f5126ea8d9aa9a5c680457067f75c2becb6b1a6b36eeb3ea7414e6b576f7313014827951e7f780272679f2a7664988134a1e0a0c629913b91a7a91d2e2d8c529b01e47c131c01956a25ab7da7e1b1035853ad86fec492be38810ef809589817d65e30912992c275d5f4111b4408d8af7e511edc6834b6e54e61a868ca1521703cb166bb5e7b6f925e8ea1337a1890fef1ccffb2abd43b43871b09abea6144b56748e30a1e7a6da002d5cdb7381c30596aed5e1f78775078fe4ba390005132ea1ded88f1140c58df34f52a28026565e024010fbc266b9a9fe95950d91bfdb26a6dc53990c3667dab0a79f3f51856ad827b66283fb052b187d8a7ca1b88809ee91fa660131a1460e0569e8673a776dc62f9de861e7457a4bd14e3343eb3d261bf1e476a1fb5bd380bdf2ee454c5d99b8e254147447f3a7167e74a8f7e3a518088a229494d8b156e6d143635c07c04e4047e2b4ed3440f8eeecf57460b603d0e144840f0b61d1322cffa3242ee309c880c5d70c3fbfaf5637af561a32b6b7c35a26492da937dcca62127d0fa5a0852a9dac26f90df0d00cd3a5dc557f8b477b472332584e5b80a00f2ffbeed853cb240893d79e5865a859d82af89f6a3630f5ca3b66eef3380596caba90ed44271b8985d699db4e4239517b295c278531631925e65771f5a17bad8a9483a079a754cd15ec30b35ebf3d974f1fab4ba8603cad15901999e62e351671c8335053910155e3cc83664b0da3b60bbb94cfb104c7a25a42d7af9732765efb76cf1f072b9608784997d7ea2bdc87c3780955fa184a5b0c4a07f42cdc2ae7b39462f0ed1643ee82aa30788cca8eedd64f5b86fdbb73a28290c6d8cd201aec9b8baf94933bc42f05efbd3c82a54e08b14697b97ff62d457e412597329d4d3ccca84c8b0806ee063b276bb4a0f4f1003b4984fa7232f9f9abce96891e5f9902b74a525f4e773acd98faa495c96830bb6e752e153fb68cc638a7a010ac5f926c1eb96a6ecaf69613c0158de122b04a088f50366b3307933b8e6243d017df2c51b2d252f119867f74ec6f87dc31b552951ff7419c44cdf2bb129767e201699f1fd5ad6be02c9f0af21bb6815893ea40f5f0d480ce42f7197fdb872e91559f65fddf10c7d0255e2879d8ee5b9c5a5a003f2e8fad05a1ae18a5ea64a660f4bb58466ca4d537548811bfdc8de9b9a64e444bfc67aa3cc44cc00289e939145ba14c4f7eb5328674a0aab522250f86d63224d6ec1925ec608d489c62562a76fdacdd8222fdcb905cd6498fe28a0516b448a8e1c24bff13a9983fa352adc074bf181502db0522621cedb683b383d9e03581490da842f11fb4a04ae87de1e6d191381229411cc72b227fe0f92be72e868a1a7962caf0189406de21262ea914b20effb4c858ef4bc5270080b64d4301010eb4b368a5efff328b264dd7fe8011f27acf21462ddde53be6b7a9e6522c0fc37ebd99ae2c86895302738692b351c98fcd472fd43e2dca55a0bba591b189c915d78db1314f995bcbebd728ac90c26b7f154f6ca7131ccccaafee5de6372ed26c4cd8d7375f978689a632e4c4dfa08e25a84f5efec618085dad339cfed115f1bf3df371d4dce4ad86fab3ee1c2950eed1045fe8fe62f358a37a8a5a6bb21475235c146335940ed554f05c359c692e5def12ee2de466f329bb4687b43a68d5e161b16e2314977cbcd2c879786091fcaf15dcccd0127ce0bfc66a253d1d9c880e6f699ea66436443b76045e6d1d290ebf4bbe65ac0566726cf08e38bd054e42d275eb394245efce167263b5bba796569baf2e2ef43d7246e8478a900fe6af5c890ae1811402843fc2a1ec3bc0cee8f81aff02dfedb60f2648338e6e4f043cccc778584f56921256f5ecd9feaed3117ca1527b9f13ddcbff553ee0bd95e5bfa70b9467a57323e2290641b948545d80490950b87e3ffe953b5cce4afa3180129792c991acb1666c89872d38bc11f8ca3b50a9547611d5aee7a3889ba2dfcd9bf28f3e807b8ccf8fd16222654242b8b0daa7ec304dc2db7ba7af8ee27a44a5bdb94f0e35ab616441c2c3328e4328d280b543b15df8f94b8124ce34958e10b5193cef0fca6e5d70ddaa41c52354fe747410ac412daf659ce90858475f07f6a5d919fc8ec0e70c40e0634defeab488be2aff24ac1b8188f9af2d86b714a393e71f7d2ce2c69ab0271115a08ee0f618d868063ea30ea491374cbd8eddd75714c549644967d748a4c596ac314c614c897d6241f83f1852b55e506d21380c81221247430bd611c50a55aa627f98d72cf2107c585a19858fe2f2d3b63fbc4fe1ac4cfa27cfb9fcdb683fb7cf355308e59f363fe15353e009b56becbbb9138ec7bfa9866f756c2dafd643b9247c1ffb144abc6f1d6360119a1d5bedbac690dbc313398acc3899bf08e19091116762ed6d45524a285948279af168910f6669ac1b0bb3bd16d34bb9a2dc0cb15691e56f95dfe01a39fd7657fb7762e24781cd9d80c59bfb6626afad7e250d8e81b87f108b18df716a508d46bbdf1ed473706e7567cedb82bc384f3be16cdfe0891cae1590d3534fe2b40fdcf979ebf56573b878a18648fa1cdec85328aa6fd052fe7e9b0981bf9d49e308f0980b5ced77bcfa0ccfdb6fe3258bc53a622b3092baec532db9f021c82c0b441cf85a4f8d035debb202d8695fa14a845f3b90f4cf9806ac8d6211b87954f184ccd3745506969268665d15f39b99aa4053c64a86172e16c1b8b6755b6d66261eb51139f9d5bd52e5315ca8ca0cc6b1c83e1ddb8db324dd57f11aa093d23595ae2098dc2da38262899969deed675755a7287137cbc5c7a34ac8d09f7409d767df5ccc430b47a3f24721c353eba6fc101c828f66dfe510f1b3e96563cfa29892c6c7a36f40f66a4c51c1704c581d55308423c0df70e3fa719362d701c36402ed095e5f90682bd2a3d78347d7c33596fb0dee878154b75ed1777483816d906949342d263e3d64361478ef0f65929cab9685e4a569b8c95d9204aea601656c3cf7247011a248a0e54de07b6616f95ebfa50ccc5b7e6978a56b9dac9934f3898233bfd4cece852a8987fb28e7173fa9a6f5ef06da38bab53de75b98bb6939c93cdedc2d5044e9403cc39ff631d36b046ebbfdc77c944f79ed4ca5a8a4ddfb40d3aaf773e41a3e93cec2f87cf958062b4412f61bfe4a32034aa02942e3f264557b30d00f9c639a22d38e4827b15e28f17b352975bf766bf2e13dc25d8795729b8e8f3c8a2248e41ce7e674f132df50c78542e5943d50be108da912d563efbcfbde60c3a71924dfb68087df0c36cbb8068aeeac601af37857519f5afef10c6b6d95ab849ae23353d9c83de8b4c8dc7e60c0ce3c27a8ecc210be7d113fc92f8f54f3cefe944fb11242da00eea9e7a100f71340373bff7121ebeb80da70bc76ab67534a2935dd53903aa4194fc0fe2711d2f88f9c4f21f32572b0fce19a081afb63f602cc50a78abe1dc730b521826110966bda7e53d6c4d9eb22e7dfe7408d3c720456e8005dda6f80d8b34a2a4d9171f00b489c8d42a023861f1b14f5822d64f381306c87926f538161a0d48f624777d491c7fa60ab8ac5bacfbd6e792192dc7d08ee328e3b048c141a809c013b6b197d6e981797681d0b7fbddec06e172383c2e3b272bf9d3156d0251ba2dc91efcb6bacc587f27993aea03ede9d1fa5ae3d0aca0d5e4ab24054372b77fd638c25d740e2b42bde9cafa0af1da09cfac0c523a2fc86867304aa805a6f778a3fbb3de41c654e97a9a651b20615bd66d80b1d042dd45b34d1db86aa3cf7f7ea4d12a39e2d8ebb4bf8c2a14a72e5cd17cf47e0146326dd93597dfcfc630fbd08ae268f7ecb5baa2defd1451110b9d70ae45129fb95b885e3d8da9f046ddb81e2c8e3b614d0c7372e899ebc942e9af891cc74c069ee72c658d054cd2b44d38a504cd741ec4e00ed63510ce931338ac64c3ca322111c3074bcc79cca0d1c1c57fb02000fe64f4cdbbe0b7308ad0ec1e6b021a8f3abe88bab9a943c10f157350a7711475e3157b098b4944f8a8bb5d01d01dfe5cb8681fa41f531924242997e4c2af4d49771322585a9189a77587ecc09cbdd83ab964a8ae44019a47726d3273ab732c04d86d66bcba2151d1e1dd80a1466e4c67171bbe7c586cea416b73bad170ebfb1535873bd7b0233e4065dad2044f20f50a628c02906850615ead82881bc1e9b234ee980159da07c286aa8f856078a7b0d0f3c7fd42a6ef43686b141cdfce6544608c2dcc2a8b0021e90c8011edc83b770e6c734cb0458d92e0e6582dc135f77ff0aba4f809e38586d352267f57ebf9c30076481ee107f5e470a9b18f7fe85d824eb9b2149079d0294e846df1ff7c5f8ddaf79604ddb3f2562da234e47de6fbb53b34de14e1436282217936008f80d4cdab79bd1075dbd784778b2e1c46525663c80703db79c47d8c9cbed6e2eb7a1e9c60d2b342e449f89794069ccba68598d15b67d20cd96aa91d2fc1966addb7e9d35aef81479f632f6348aab24b59eb10f76f8b4e3afc452f494aba31cddfd2474e68d9c687ed8f588f07da55ad59b9afb9e29a4e54ebd1a1d438bf583ff9e72baa17f03286257ed5d7929ba07b5a228bbffe07fe72ccb550bce171315f97bfeda4adb20c8ea6b90a570dc9634efe375fcf9daa5eec39bdd4c7a640d46ebfdfc9023d54adb1e988e2e2dfed9f2cc18209c106ebc1bad434892ed1d6cd5e1bac5f07a3c6031944854879fbd40bbfbb470bfe686350334d170c4c3e5b9da8ada5357e6ade0fa034b2afbc4c4f9252aa8f0c921778850c5c25c1643e5f39f9356a3053d7af67c5561c8b807201d3aae14554cbe588b0b46518507ad7eb89ab904a1fbb9c4bb5e85431d6650918a0a41b31536b478876f8c19c2430deefea129b2e30ecff8f36d973138c871e9a7fa8451b1a6716f74cf9e1a5ebbf966dad956604796669d93bb491242f379bb12cedba38e037207e0074cefb19fecf2a9697c42770cca6fbab13b2e543c9bba9158a94c27ebbdca03157b896646eaa525d347506734b5f137f8c7111d371e393dd59f9c2f4a4f04ed2a9957a49687d6c30ca82c442947c6d457dfa88ea305f7bd9ac9745e27c5d6cabc1044a864b8c472f5494cb80638af89f2c55441bcfe9d096cbb2790f3281c2d8c9efb49ec47dffef9440ff359a4e72c1372df8fae9023f51496ed6e639472e4899aa3c5821c709f810acc74ee61bcaf550668ca1106b687d2641fdf4402d4a3fd9848440b57d5047d9fb421cfba0fe1a4e1ad02cf0562a41c3bae96c6bfd44d47b0a8b254e40bbcd2567b5d15936142187da103d902bdcf7a103f9a325601074826cb599b82a2bedbff1be06aaec9e8f844e5c799fd5aeaff9c3769484a7945d14cc8b755405db023d19f538a2ddc1fffd893c08d00dbeaa185aa85c36762124e5616252b92249d708ff3d468081739d28b4b019441c9edf968ac2bf0224e530ebbbf0106b9d4c2d40d9b1f5110b4dab55dafc5c0aed30795814d1a2db01cf3c668b05539ee7bb395bb4d66c4d0c2900e107ad86aa87555660d25a8e7ddfe2d935bd1a010ddf1622a8cfc1b879e55b836ffdd0d0c13b958a72557834a074aee97fd68ac5dad6fa87951e0949e7c05eb57d210779af144ada861f26e4b68f4325a7cf8d8f8949c3f8ccb87673381d5c253e84663f5166da420bebd614412cd49991e7f012fe249e781d431fef39282bf9c710b9eacf848d6ff6a7addfaad2cf233f29b24594e28602369bd3574b6ced6b9545c0c27bf92d46aa185283bde32bf7af9d45e343dd0f013050e5ad5792b04a520e7013b9c6255ba63806e29fb1521d1b644febd4979dd6e9b1dcd45d3a2c75fa9824b0fc8c017b0ad77d0267880ff1742a0b2024e5bb5531810e16892cf2644840d96dd8a24f23e90efd8d3608b0a345c06e8977248148be8af69cd9642d9f73e54fa41772a0066a876d52f1727db5cfbd52f2e20388ebfcb6dbf95cbb5a443f53e9b1ebab058abca56dc279cfa2808679916abc7ae46ea85889a0f62a3c855884a8762826ce4bda1ad87382048fafd4c519c320ee9c7735c4d869b8f8a52805e77bd8907364971977e5a1ee4ce4c13231681688b19c9d0c7a5d10cb3dab0522f87040338926f18fadd4a8c2a7108b8dc2b63c6a55c9ee946dc5b6e6951d8c71cfe71ad602c58f44b1fa8ba425bdb4fc6b7855f375e0690e33665e5bf4493c3a77355974d838dc32963470ec355c38c9ad6245c8fb07853c1eff71a9e15a2d352965f1c996a6f61ce0fa22455541e6c3235d32db0087a9e09bef3baaa3ce87cccaf15cf06c96312ee9bf8edcbfd6e2ebf62b0850cbf1b10450006b4812fe09aa4262160ba1c0926d8ad6462409b823656d8ff570902f7015c36497c81ac7839581ac21043e4e540070d90122bbb2f6be12e0edb2f12428cda7cab6a1330c5ca3582482580cd6673cc36e19505ff0798a32e427ca657a13ee0323a4e542e00cb37684c2f4278eec8a144f0b0e93d721419fb89eceffe9deccc550a139b9e4a33d27516d21c522ba1aafa9fba00984347bff2b917046bc29ab900fd25ee3954174ac6d967ff662dc62c05b2dc49d0f50761bd9033d0da008e2c934bf4ab4ff9cae4e3e5215867c1175fdf28dc9d448e2ebe4a13bf281d585dc30e4d3cf899b7d297b1a386a33d04b20b01f284a75ddb03733ea45e4dfb81be28b70e0d5ade542158c23e8b3e87f30e3550db166137250ce6d1670717b153cb133689822968f5ef413ce8112b9b89cae3a14fd97b499ae039f5fcf86174ecde987bc15b22412d549c68c28ddb9621d78b959870fed228a21a903b834b753a547960a529f6ac9c197571588fe0851769c0c40eda718baf8cd973547535d9811ad7ecaaf9cafb1cfadeea84d6192441d12d8f971659172dec147f7dc366ca753fd5d9271fcbf53c24701a3a86c6614bc6bd7307886056379cfde32997497d11ec7c9a83f49c36ceffbb552ce90b316b3aa59720e244f23d838ceffe5b699661cbf26daa66e1d64c07925cc79e3b47594e174ff61626fa45f5659fceba1204b680a64e396711cb0321815f065cc2774a6a61bb242318f8d468dda091cc8a0551459e5cbe4b874e056b40462d4c11ac564567ee3a79c270318964087a9ae03c1a5d0a537c6e5cd23d3dfa9850b152703fb2562a32badb37f35137e5a09e2613092c6dd115a3ce2c3625f32e6d3ce6703cf05581b8dd88d2f5077e5b6791a3b33c84ab5ef1f9cf24151f9e79af89bbf38f653fdab2d02db13f13bab937770def52982cd317908917301940f56cdc93f9cbb5eb02d920ba50af367083347a1f4cd08d1aa3a31c1033e68a41dcca752c2971db762c1e6f486bc0766b7ef6e635e9faed54907f3eac25490ec990a5efa08404d5373c9788d8c5a302bc5c339cbd8a9d9326916cfc7d2ad168a4c27cf7af3c33481baf539b4270945adf0a037bf192c382a52d2b97ffc34ac548e695cc09e56eaa831c940285dcf73a912c0bb7c566df0062aa0097927a5978cd6b06a367f0240dfe0a246e98ae3b8ba47825b2c662a1a58164ffc40555531d9df64e123c8c33748fc1e2b286a3969c0d65b7486f21742fbbde0310402356897feacb017b20087495b986fc72e47ad940d86a3876827eaf6f08b2c97eb293d788205476572f6198db3adb96be611ff128ee24d359b8005258169d60e817f476f3d8b1cb1f5f98dd341f1541c79b3b06ec58f18724aae7cad9572fbe87c1e2ef1897e278daf7bb596ca54ad73edb662d9872b70e2ff4fac500357cbc46bd130826a9065251196187c1c77d65fd2d98e790aa603e1f3bfe681733959ab21f19f949c8558fc788e70977eb30673f0fbffb0b5d44583ec7fee51648e1fe85f7260b7b89c85b7ad182c7db4b617c4a44855b389a9edad48ec7d294b3278712d746d14baedf5fb355def248268075f87ef846c0f117639a9a8bf53644a25e1a31c543f87aab45a1fbb0f9cd92b77453f1452b70ffe9f26ea75d658f9aac9fc32c8b75356c1564d06fe17881cd32fffa5f7dce38a17ebe25da55528284d6dce9c4dca6306e36d42714945791b2998ba9cbe118eaad2229d7c29c51375d5fc4c2c5fd836c85814bad04a0d0dbd9a40fd34a535c4a77fcea979582399b14bc894e8dfbf57b0656772b65b94e076605ae40edf607ddff5bff770d160fd01ec03b0c6596f730c2a08a4151e355302823bf50ee0fd5f8f1888941e99e0b60b6847ef1ba06e07961f9c4e9ec40019f731de7dcd4a4bd8f462ff40526ffca796060fd2d20f5760dc4e4c9585a9369d354a6185614cdf7ec807c115919280292bcf3b7f24cd56e87f4f452b4d0ece344b25864c69bf20cf4ff5ab3797a32de5765690cdd8d4aec518fe38d05bdff4203aac335e720aca2d7f3c629cab1e388082cf36dc4eb533c9e293dadc781e84614f33f22f23506c3fe6eeccdef7ecc91502bd383bd049d0ac887565df7c279357f0ab7252c831ea8e6084952356e47d814afd08a4f0e003a2a89f1648c95ae7378ac404322717fb83c43eac0d47a8e579b5f2f841fccc5c30ec10ad2559d97a4d0dcb1f67b8a8aba90acfc3c20143057b7e39c18ab67b0264cdf2f0f17ce6fb0b9e89dc96abebdb44a7b4d2ffcff9d68062b300a7ebd82d4c638b286e93334cf265e07ae35639bc3a106d943d2854c4918cb0b46a96edadc9cf33a18f51d2053dae92dbecf31d5847a98e08e53709301999a4c2dd9c6361ad28a82f7c6bcaf068ae980661cc0409849057f193cf8bef11ba25715465d4c126f606a496b0578b85b84aa31c387a003e050e5771e338c90046ebee17c68e5682a0bf5b9beca58957ade582db0eb6bf1c63cd049211c1fbbe3b20c99e11cf3c386780b0cc1f78514be23b14796f139f98ebff086de041b51485a57755413aa64abbed862fe0887d37e3e0f0c0fe144bc1d7d23660a7a79d2302cfcef680cb5af4168ebfd7f5995defb9c150cfff9643546c67a444535d4ba1a7bd8b749c4931a7acdec744841972a5a5e69101e8da5b230a612f137903cbe139b8cf6f12c8995a87f60ace52fbf31d6c0eb776502a39cb74b5f59868e41eb26ecb9e41cdad132af6767a1f06e54bb1aeeee61f67e9dab9c951d93b311fb80280895f93c439b5435dc90ac65c14981eed27ea6041130d85e13b02cfca0f036279f85f870984a826c6d335ccc0762e2e2067b040b244f69015555c77d44edb46ca9d4e71ff87ab31c95e7766c041122416c2cb2986ac8d06a4c815a09bbf112be71cc01ec3da8e81aa60d3af3ffc8002fb16f03a46721d1a2c7d21ff5c87e975030eadaf024fb81fc4424c767550669cb61a7a27e566c5a1fc95b7a9f1749b362e89f1fec7eda28097ff6b17052fe6770acde6a7f71cfafb2e2ed3385a54d5ae5b61cd9af7595a5220a9bf6cc7c3d880993c587a5ad80346c8fcb2fdd9e537ad2532644d86ea019b428059c8147d458b43e015f3671f7ce25a7e584694b4d6b74c323f35a7854d276e474c01a2eeeda57e4e071d1f1ad44fe2950db2ddd4b9064434c96d748d0849d1e3339042a9c23c98c63c6ade55ce4ed353db95b3a65f4e525dd447d4fc8fe5b4b1abbb21396b0b08d367f493f604599ab712710b15385a11e313129d2953d4db29d4d4445cc2df3e475e4d85d85f6702cdc571ec6e2777568e9e71397f5b8dff96d483682b562c9bfe9adf10a8a0083e7c4b0985e307aecdd9714a4febc127c4a354248b5fea6a6d0dbade0a7fdbc78cc0be90aede22ced141ec372ba430a8bd7a0132b616f44e368800c89729f7e2b6be7ffd90ffbb474bc25495f2666d9f600b0cc5d87a1fc888a0d272a6ce2f51d961b0a5582786d69f8e5116de49cb18f8c7ab1ec575c9d4399a3ab16b5a93193cbab814302a2bfcfcc66eeffec4b5d8fad99645a32d8624c806678081b388f92c57c3efef00c64a874d9d8e50a228eb595b8ab26a5d9b8a25c82ac98b75445b183a40ea36f66a7f38e5b0e3181c3682a29cc90c35bd84404c977ab084a6539c5ace61cadb2d996c7673e138d98e84240de198f67b966ef8492ef077129e15a483869e7deb11ceb4ac944b9b51cacc2bd442c0e99350bdbfaac04cee88203dca065d323da5a4f35473b36ed3583b5c936ba30f24f63988b16d20ee6f7881530d917b9dc22673ebfe0b79afed8ade961674a4d4a32b131879edc85d77ec7b33997fb9208cbae8094440bdd552102a6e9f83a765346be86da4660cc4bdbb508d9d30774431fa0e978fea128d70ffe2ef041dbc9c8a3c97b9c605cc70eb8ba56374289953c7365b51f1b3ade8f11a21b61971345671b2f5e26aa77553d86a918d18450bdd55d905e7b7d0a4d887ee99750ac352f3050ef104d6b37d845c1f3e38ec7941355bad8c7edbc585b6418caa720c8a22d904dd21ed99c02ebdb0938763cfcda0f260476d303881c1bf756c7d055caa19f125e543a0f7e173dc5efb0c608695986ea0f9d887984ebd923932181d8b5f8f28896eb8d311d63562c29639597024794ab7082006907338b46a5613bc1fb26ff032bfb970ef73fef71836e5c98d6dc2e86b12d6a0257c460c47fb3b768292d3bc98d92e174e08d9e422de4effd64ebaf081d83d3f4e825567956a66f63cf34e873dd01e9b448ad19753305e9fe28097cc9ee15e3e37fa96f55d00467a887cd74e5e409b81b5d1072392784a20dc64732b3ea243f060cda8ca328435522cb31f91aec59984913907bd8982004eca2a8282b61f431789ce8b5e08337964acac23d624799c13ea57f6408a98e2c9250ac6864d3fe56d65d0cb0d9efba9abc7aa6d26d7cc39d1d3b53daaf84dc885bf868fb35c33e51e2ee93c9876afa7b446384a8fe7568c1519b1779d4ff77549f7fba1c885b8114cf8acd8a3602aa61f1aa1bca0805d5368bcf1d6dfaff11d3042e8c049f7144f8ae06815358fb2a724c9df85efe13515094b1db4da001ce02a01b3bffcc00bcb6205a9883a4213fd0b305af9977cc8e46cffb19e1ca123a67ca7e6ea6c383687cf5193c504ff3332b38e07acb21fcc83b6b33320d8a6862d3c3119c7696d75bac317e12ec6582e240ce7d943e4348a7b43a4145c64b06d8ad6e9fcae86ae6d2ea37a81e3184924dc9dab84ced00c3e6e210204dab944bff08a8253cf9a1d3eaac6a92e0476185930febdfa0fa03b615392558c13f6c30e1beb78bd5c4054e6aff9ea7f4fc1d64e1b5fbd3d2a810577898eb02bd1dee7483961cd9fa457180c4efd744279bc63ea2e00a558d924db28a83fb14ffe55d43feba8099ac78220138c081a23b19007e087b7ba9f3f3fe6c5c58254df5ee6b7786d4f974681a8e8b80240c2f283489bea2b6dcd8fe70aa677736d983c7c40fcdcc83a663f5e7596a68743b60fa256418fcba1c3e631c39bbd0bc3eee732b406318821e3a026d8edaa6ea2b9bd1c0cae6f76e379cfdf2a07020f827f2f85b98872300e3e851083558ec761f5765b24006def5af13aca05b35932563b94ba6960807be30032836eebb22b79b27f6139291df43fcec0209dd1c07423bece5e0109ae1ed2f5f1d055a9f22257e446fb4ce654f96026a1bb40e966077f019e66659b24b9e35dd55235996de35a835d123f48c8949e9fc125bdd0db1534dfc99b995e33607177d2bed3193a3458b70eb65dcc030a6fdebf04ebbb2f83c363037549e8f121ad540066353329871ad2e25dd00440375c44736e22585881dcf08ca942cdd5c01a02e64526fb10f2db19978a2ad1d16c84fe778cbff86c80e82fd423f6e11ddd0ffd177db6094f8ccd635431dd26399018649da7a5d38b537fd46771fd0a35bb38fa9dc0b8fd74d9947e2e4cc369104adda45156b74d7a91f22ef3718f9d6ed816fcdae443115156c86c368296545ee4adc764125f575227c28e29d20a50be897ab9f16932bec4f1786fa91879710cedf6f8bceb0ad9cecb2675cbd272ba4df20e54df40a4721b37a2e006466d2284a63929d666aa2f09828a972ff7ec6611bacc5ec6ab7c55d333bcdd168fdd39b4ce8cfb26d733b9b9a20bb2f9794272bf0e84342431e21a0aaf2ec22b0d1323014b1904c5ae1e714df3fb29e9d162bcc9a35b9eea16c0e8ff1cd571285cc09ae1d59d56e24de89c622a6380e923dfa83d9847cab7bf454b62d58273157678f729e1ea64fed594887ee17c94ce3a6e6fab639491a6916639517779db4ef13302487e652de46525530e5c35b666806bfc762d620f71c358295012f30595edce5ef14388b9cfec25cb04bcb188cc7e5261343c2487df891735959f9c218a7b888406d761ec5474225ba734c6b422a445d5f17c229bbda4e34e6893158a66718546acf211a1e1592b065c8c7e6b235e8d45917cf8d2cf37be8584d273f2ed6e4fecdd894f19f57157748ac699b82d261176938f15728331ef59ad23be5fef494fdaf9e2e3bb66783e0fe21e0aa5bac1e0b1f64e3d9e523e8121ea4973f3d93b58ca0a5c2b2356827e2e9797762964ceae0b0b0308d6166dc57c1950038630f01d94cfdc997b9e5f3754693cb8f0e7ab4e2e5e0f60b7c335cbdace325211e602b685c3d93232e7fa8f7984e460eacff93dbd20f507164489ed0dac0138ebec94204ca93110f3abd0306b8fad2fadaa291745a70b0f6273ee45f0a8c503d0825cb96b5a1de2f7d586c53579a29ca9fd191fbce8a05f5e6d753218fbf5f4bc03fec848dddf67a6c08780a2d700522c5b49bc921cce3527ae77d79c8f09bd9a4d89f3bf03e3f77ec34497c3e857b03046f4f653daee9f88bcb09cea48bf09b8feaec64e1473fa5a9b6dc290894c4703ce5bfdd55c5300a55838aba7720bf41319a033cc3f5a6efb4cfbbf93b32560b40b86a3faca7892eb684c74a81d358f78d4910db1e53265e75a66cfa45365745aeb04ddffa7ccde5e1fa629f455925e65a98e8bf0e865849a68c136b78b99b124ebb24560cdc2452b114b43d9647ed9c9de94cc6097708603a5babeb5b1427c3dbae09b4390cf7b8d3a68fb119199ee8f24024db3e53bb75296b7356f9d22e97ce1213f7ff4a9060929cad2f80e1e7df604f374fd01057a182158ea92178a45ebdfc1b9260f14c3eec5f209cd121adbbb368c09d17e95c4b3e4ae34bd7b418d1365ee32acfa4962337ba22a0737ab50181a1bb7e4984f9e104766eb93df79f42593cef890fe21e595ace77dbda8eb9988ea99904c59e1a6b6c9daedf250cc61ea7212fea5ccda2516bf6c9418cc1d66686f6b864296478e2782ec9b28fdacee82030159dcf58e4dbb28cac0d74ac7dd5c3511f37e14289c8dcfea594253e06afe8faec4a5f8465daa421799e5bed8158f9a3612214b7029baa78611697370d8ba34d01de58aada88cd7d179fc6ab39cb637aa83278c9422741529b04d7d59ee97be94e66e017c5646a879015bb3daf2f36fc6cb7893c18a16c264a8a58fa397f94d06c519f7cee3fc60ea948848630c7b3159d27bbed0f67ea47a6db78ae9729a67bb045f95b59e6db893d72936bed20d315263406ed50f4c2f13f8f6e75b502e5d09118b20782b94b32c38e54752a0462a5eaf3756a8146c985e47b23827b9d4377dff7da94402a1476463577672c9b2ee1cca7cb9eb55fb13c8dbcd1dc6685b8e1b04fc062bed3fd45ece174ea40fbd4dcf2dadd8a1b9721c493891ca2ecb50f1caf98d78938e2e30852ecd82d52d681f313251129539262233688364fc84e6d657ddf194a5d6224247005220144ed9fbb29bd4777f63133cf77957d2aceaa330b4521b66678f0160f902e90b9992b2696e0c0fd915d8ffb30cfae8cbcb89e814701ec4d4b6d464eee0b681c778903d8dfe8c5c88d8cee7879882483d6c9d3e26ecac8cc5a19472fad9e60ca91acf65a2de084659d28ebc3ae129d84ea19b7da27189ac890b1203c8bc1ae1f7aa4b83cb0ed0b99b3cf7728eeb0d78a4c0a9bc432fe732850067178ecf242fa218f7f4fe8618d41555f96101d6cfc2a51721155d151dd72c93ff9fdb1d95867cd3358b1d6f79373e911bf128aa135ae1651235ddae2459bd9f18935e84456a3d6c5fc27b2a6df538c0f69643640443dddebfc120601c724e5e4653079dcff4a66b42cd6704d606599bb8279ce2cd52e6ad1e8abee7c554233df265c27c128d90329e6f76b2775428bba273984721abb0f65989b79806be5a17d6794261b1aac278a7a8a0f0794f38e58a358d1ab346db1551b9b4886a95607e82bd940294aad60c872d7c32e8193d2d5a51b11cbf95a87416b53cd89e1dc376db85793965b38ccbd9b318c4343f35728f62ca58802a7e9b702b0b4ef5b44dbb9644bb1014aa4961300c4cbcb1fc9f56bb9a6c6db775fd4e5a21f4b9e4258b53c1cefd245436af4c8e0c77d1171a04f103f0e7722b93c76b8104fdf68687110d3bf3bf6b1bd77fc5ed4a0d7902524918a19b3c2723263ee5c98d95ef18ae3931376189172607419fbaa769b9734aa65d63e8b03bee45d3c3c8731aba7e2b24a3bdde7e5472714dfb54a8b9bc4d1d257c2a51e2b85b7aba3f49ed0bbfbddf2d6c29cfd605c43549a292a10983d97000446cef6b6f41c80c1dcb03a2dd7f19369faa09e881223d2a293ab2bb0842205bceb3397c54f9cdb13e00b6a8ae92465865c4ffcc87589e469a8b8df3d51a7414141c12f47adfef9ffd4eeacd586934fbf8cf33d54e75121b37b415c132d4eabad8d924e912d49445325131cbe499e0574e75ff3e9d4b79bb0b5ac6132b4791df38af96a57abf722d06575815a35dd9d92a38aaf348f26d1f7916efc02431eb4b1179037ff507eb2f94e2cbfbff132efb76eacf3f6245ebbc8ff5bd2609b26bdce2a3cc1e0e1a77c3152aca6116bdef7da83217c28d63002310f61936ebcd7d01cdafb71503ea243edc99657b6c8141253d0e380ac03095862b904deda1ea1c29b7b4dcd4dd6b231a9d4d5738892af94f604c52a2a2d13e73aa29818d0657fd92c7dae465fd175f8fa899a1467ca4cf16000f947c67342412f49f051565c24451d4df987cef6a2e147a8402d7058321d0c85030ffb486f2b88cc36ec834c1d2779195bfbb6b650e97b248368dc67d3f1bb85ba528a2bae1b206da7dd45d4a19bcdd614c47260f6f83f4d40946c3eb4ed53a4e53866f09c9750c1bdc52283b8507b5beddfdf7ef8fe3494b3d9d934dba99139d62f7c66c43b51f33a53b70d376befeb88bf38b946c31b583365dc5c331b09991fa75d124e405e5c3c10de137cabda37206085b0db9a84d8783425a943b8a3ac4c7605f337b0258e11138cbeeef5016a004b23f71ee2bd0162dbdc8ab54328aa6d2feb4e069251093678d9c6595a2bc0d025a5559670ede21d9999315a14e99fba5374a3707c8d257514d246ddd697c174ede27618c553b50bdbc5f842c99b95bc5b9f18714fa0a9eb48b92b828d6fc2e6a1a71aa10433e7e61586acfbaef53b1730969e24123644c3801925f6efb1159b88bc35b3e3a4a39324a6570285df5bdc93148a0c2a0b03a7f8ef25f24412bb0796d8a1b5352a043e3860a045bbe42921c12a5dcf1d079b532fc1917b8958ce31ce6b899ec270814a2c02acfc1e41418b48183f5063f13fcdcc1d7cb966890b1dc1f5b0585bfd35518b196356658998bd1c3580fdae0cec593dd4724c6ac2e72ae66fd94ff8a89663eb105428c1bf6fa05067e90b898fcb8720628ae0c668b8e80a586ff44e40fd9fd880723e31199c9d8e26aa3496db3f3e5c36159aa825d04c9dcb404f08e8df4a3a022ab45ed0d2fbe22f6b88229ff84c43393f9a00395e4636ce3e40913533324fe7acf0ac2efb95d35a802ac56f1f23a890fc68cb5c5d5c14a24e4d60209c52ab8c12ae6a44dc5281d60f774c240b5858e27dd0cfc81906683feccb27d0f0affc8b77a58f4a30841c728d4180397b97bb389bcbb71ff62b796556bfd81731b366b4221b02f5e09af09221793ab67e0e87230cab75e15ae1995161017e01e42356aeaa5997dafa3e8c1cd03e421317cb818a5cdbb47e369610f49126de0ef7d8410a33040447287a7cde61f654953d9ef325471c717349d8f360b4a96ee35fff09de010fe74a9b80fd824b72d733cb1783750c857a600e6e0c4d1947fdba8b07f6f59389d6d300d2635f55a874689b6bb2826c52f9c4af82b8afd52a88850a82f4348be279120b296453e5a7293d80b0b4357c0b0f8e61790b579e86e0efbb88c41a95b48fa75a7cb1cb84f3a4180cbdcfca1f5c2b9b59d73369f416dafcfe111b7b6ee3ae9863f536342941acb0481d5e383044e683277d2ce0a49e52a45da5ba7ddf94ccff3a396afe4c9f2fc30aea2204573418b3fa9dcb06c703d40428e2ba47d22ee19d04de0ced34f0be2ef47a5ab6d272d438dc6e4c1992d8d75779c38920ab4501fe68db2b8ebcfe91797346c7cbbef699001789edc4f79397311d6d345921b9ace22076e268bb435f723d3fe3d90f9d10517feacac2f50a186bbc259213b6ba30568334809a3acac440a72f751545b09ea3ca981fd6734da1d8a1c751f0cda49ae3edc9158192a275c97d86d2c7c8b5609e25e8a966fa97c4ecd5231f331424f0524a24df253e7ac0799bdb152b4e70abaf917b0fef3ba80b9fb06dd2700a0caac77781688dd5d9974eb4dd586372f7bd5786225c1d4732a5ede90bc6a2098286c622656d29b4bd0f8cda907ea790688a77ee0840d9c64062ee67a8c68bdeebbbf67c8cb83fb34029a6265bf1f2374b6169cc73fcd6625f6731c02d4e8f90ede99b64d62b7cbdf0089880bb5bbc866d886f1615c8897cc4c606f9b0711b0859ff7b7f956d23fd823035697ad84f92d4538aa8b84b30078fb4b346c7bf94785082bcce3af14b4eebc4bd2fa1456f1fba125b23764416ccacd8499cf25fe6f65e9fca17802525eb39caf349868aabc693aa261ea57918767b6b469d33175a41f3b0815f6898c09ffa6c4d9c97118aaf4e83a403e6b1544772b36f3bb61b5bfd10ff10af28d6c586e7757545b504da77b8f9bee61a749ae2993e71d7d41963e3c135959d218cecfdd15b97b0e554d8ec31f7bbd95b1d6152dc04fba4429d480489bb35854fede17f1ba5e1d17ac0577f333d075aeb9f922387e25ddef0f02107e485b6a0632877790a405049ed778d81837d05c97b88b1e842e8caa8f2df3e28c368b62cb6d158b65facc5a40fa0fa4a21d7b8ccdfe41434d74974ced6dc6a6c5bc1d795c286a9c60c2f70e8df1da8ce5adb54fe212026855f1e7f001b3fd519ebe321ec4db1ad034e548b78b40c95b9a58344ffbdf62b4601273917ce74aa9338c1fd2e39b4790d8422bb431ca25895ba1b8025334b559b9ebc7fc3fe1fce8bf524aeaedfc1c3b07d717b0ed5bdf522a176308b68f2d7cac25630ae2133679271dd3fee8493c20bfedeb631f08682eeadc1bba074209910af9e3272e13576e70642c97310b8445c66721879b5035c4e5c15397bad9c877a83b3474a3e5469a4530058ef8dcf240200f1b202b212b9a44ea9fdf5ae2d97ddf7cf56df326831e72c7268fbf959eb29afbf6fc0b9a7b319a07f20804f3494d0e32c5d285fa21c26bf02704dfbcf98e430799f96baac5a35a216f92ea0c5d8013f329adf3cd2fcac6c117bf0251e176ed52dfdbf17a7cba5ced2613d2492135d6c63bb78ceb12b6bc0282b4aade2cd0b1da32fb34a8e1125cb82d4a95da5985bf7f5928d3dcde0cad1b6f20a9e6ba2e681ae69c424d1c207bdeda63a0555b383b287dbcfe9cc15b99964184a79433e332c213eb1bde36c4bcd32d9e7655b35d3a7f0144789bf4a0a72f9305a0c5fb31f37aefaf33d20dc888bc9bf42b67b5c0b484ea525f8edba1a17573d8635e12cad1baba8bf41e79b12b96c781eb48474e1f1603b706153b1676faa98914f2d190b8a9cf2f3a823a5654efe6d371788697fb9a6134742ab125b813de2faab8d0bcd6157445d59c7a119930d5869011219547c125a8e467d96f1c2bc6c472d558871f78660b0adddeb0f1741715aefc7bb0084a81194317c7bafc9ec0298aed3271ca0857611239820538f252f7446d00e1c9e55d71b515bf6ed83278a5670ebd34d1e3beec9ab95a84aef1f7d75fb02a5d1621328911865b39d00f76fa4fe48704753dc73e42d4d588785823d7224b34f80061d7016053838d2c55c390e040f4a2b9a632671e96b59b1ec0f898426973c69cef72db6283df38d538fc8e87f18a34e2617a2c389e78970b1ff71e889bc90b8418c4170959b8f2d9b776290ae6086cfdc691350be8d6a211010a3b53e6bbc8545569c8fb46649bead65ee0ffa659d459b801ce0a661dc1e24f59c113200e742e8aeeca14b2b2dee072eadf521cfa8908274e91176c722798ab197ccf9ffb8f3752b61ce283fc0e33a10638c3a37daa63a7d7360cea4c9d2e53df4aa03b67d3175c1021278dc45981a0202b65772f1e8315abeb3676a8ed049d35c534979c907dd60e6c5bb811ea0e59ec6521640a25c949f123d427c0d55fff7c2e4cc27cdc99ececa4280ced273f6d4a8c31d0803d56ddf0919c415aede6a851873e2730baa05218dbec7dad071edaaf29a511cf9093fed3fc37aceebb26a9fc0e73c9b7384ce22f393a94fb46d927b1bde114d20dab55a405c140328d0fa9b195ead3f7005947895959d9b688432a934f1d539cc00cf92e854ae3d09e76339b96b477154c09bc0fa0c31d277c525103aee41843c2ea71c211576d60f0918df72e761a429ba1d58de5a88a239f9f895942961c9e51bcd0f8676168d6557e1fc8adead44dd3ea60b470698419b6e9ac0529e664f342bdd1ffe554980a6cbc6cd5a55e419b8fb14e70b11d5d1dc892820a135c7fc9f96c111105125610b6af9c0922339a4e9947b061730fd76e482050a84ed3065a8d0c510cc1eeb97079209363da5f28d27001c485443d771b1abef99837fc795e8d25cb652a32968fe6bb98040eec010ac1b911669ddba7a845b8b27f39da61311a0198daf29941c5b990931af57618d1644b975ef0ceaaef8b023e6e8144c87da830229da1d531f7c893cfa893b19799601905cd25325c957cb2bea17567fef6d504abeb3f0a66b9e01c577114e1934ad3880a3b33d5c4c7598218d90c41b3d22916df42bb51a142eb68db80b96108b56a81b2d56bb97c2bde4fe0e628275aff78bf7a9eee3675bd9a162d1fde1d263a59f1cfc3e096dd22ed9cdc602a40e150eba0fe79403b1cc0b7aa44267c17f27c23497a2da85505d95010168f0d07b81d4c1b7483075324f5c30ddb0125e53339defe99062a96a8baecf377fc82cc250666d741327467e93ed80b92d96431b4999d0a85eea12bb54636b5004ba034f0dfa64010b491d5dfdf84d4aca71438cba7e869abb6dd9bc4605968822df8b551002e04bee10cebae71017b583e364c3faefc9d5362e0a05e8f2841f3a8221b405eb497642ed4701bb5297a847d935273a98d2b67b179a90bd0dc1b4eff0006034773b06cc24f1cc2849b2c4b3b8045e51e7a1c4f88125937ebb3f302e652691a9f4bcab234e51ca274c952eaa0ccb1fcf5997de0c6e606e371af6df7e9840d75e9f4a4bb93b68f77e8fc8f4bfe2b38292c69df5860a53b28cf114e1723fa0cf78ee8c1f8b0100be6aa11ec1c561211517ed0d76ac6f7368b17ba0075997556502013e91ce0c818734f2c54792451848f61b77f5af9c16a1d802a11fafdb12f238c12a6809cdeb350e9cb1921228a6f43e55bf329cf04fe6fa7d8b4a798a8af7a83edc896c611cdf7e05e6d4206e5c46d58a6d5d5432c4d561a623e678e82419186bde2706bc2ca92f2f1ead188530860cccfcaa1e43b6478be62aa6ae0b124e753baca53485b03389fa70b732715d6bacebbfb74a8bb88b50cf6161dc739eda8b3721d5c7cbc44f49a65b1f06e1a5abcf4569546c77fad56455f44a34ac00366d9c3b8321a984ea5018d9e45cb5dd7de1125499a6266ff1008f01aec3a9d2217d64d40d18b7656a45ca1fd34204622c733ebcd0c11ee5dd8f9072251e9bcd974d4b89b56fa248440c379d872acad2483bd0a58f09e18d98162f30ac745d70c9e191c75eb2ba47609a0f6a15cf9355b183cb42af995653936ec81259e412e720e043dbcb6894abae9e43daa41d9275962ce9102fa5dd079b4ee69e9d299c017e5822925e23fb05711b82eac3bb63c44413aeaa6b008a64764f0ef6fee6aa0dc7abfe6a5aea92845b0e3144497b354551809875fa21ab7863847d5f77630e7f248f389f8987b00f08092a371cc634b599c45d97a08e3e1cc61034461f01193631fa4161d8e5d74b92223e6180715d333f2b4f1c8cc3432e3d08d49b46c9f7389abc0ead72fe75775441c25803ff67c581da5e21e9692db4b89a4749bac5f2e954e57562e2930b1ec9e8bb4d6e296da51beaa0ad6e41f23b7c39e56e2cfd14d0944e139ec9266215bbf5940ab0b83f33c21e8984d3fe9e68ce022fbfe95c43f3e185c2b21681dcff3a15c72714afe1f4c9cb754636e55d0652ab8e4832e2522df6eabafa00a45ab571c33bd01fe1eb8453ed353fec9d1679168debfab99a73f6c19fd8a7fd7ff55221833ae173cccec01cd53d387950b30934195c9d698ea27b97d29089bcbc49c5f9df467d449608eed1321d96b6c48a7a16d7dd9042ff9606c4c4a5c113882870fad43ce3ca4f17a8c82ad9c9bbeaf8d26b9fd1a5db14bca828701f9c686b22ea7eb827bb69884ecf31a17f70c5d971741d715c4a967aaebcad82ab5e10e95208f1bc9ce8f6da7e54bb00744381625c34404c983d8bc93946838f1304cf9fcefa4674341771a3b895375ee2d9c62d76035784af57cff076354e382bf363568a3b67da6b802916a40dcda6cd93821c77e50a955204ab2dc02d9a1dd6d937c501f0b79b8bb289512304bbe10c51264b4ce835e5cf29d6cf938165e6d739a68e852da9c3d45c5251ca51ae8b57bb34c304ff09174a7f34a2018800a77764696b6e2d1ded1701a758bcd56da28e9a8f875f86f23304d6eef230f5ed88993d6dac048904179644a71454a22efe4b9027ec46d095bc8e45312adda4cbe70044e8839e62cfff0a8dedccde334c707b0d6f74bbc7e3b472d8ea2f1c6b94e5e98f4c1e04ead830b9a41f77ff25308d440bea2ff80c0a498c92d76ff1768de4cecd3e08b2a8f37a1b745b503d9df6b5d1f5709dfe67646ad49e18a7ce1f3facc773be88465451ae0669d890146491d3892c14088cf7a62199980d6fe104331bc0f3f0ab40cb12c042361bd56d096684593223525205b5fd97885a75df019249e75353cc51eaeabc2338d584ce7e0b8f7c12306069ddc2a26f58e959eef89f291e73adbbbcf871af2be819a92fed5e6a72171737af6736c833bdd0160187aee1d6aac60a6387c1d39728202035436d7d5763d59bca9cb8771d0d927e32627a34bb2ae2664314424ce1038e86aab59696ed7bd3cfd20426f6de78abd17e7a02bce2ba73caf1e86e491e82ea4e0e2a8b570aba9e8e80d6c46288b20244b1e4ad92c94c34bdcd25fa40e9156486550209c8cecbe192f528ed420576c285dfc5b2a2c09708b023cdf54265e82e8d46fd3a294ec3f3be6e923c708bf64539cc95f10ef35e3c57d7e8b7c799fec7267866624dd4b6f33d9335bc49f43a4caab48b6868a7f916cfc46ddf1d01caf18448794cee211184012a4974dee7fe8c0140e137905afb6bc8b93bf65143f4b46e9b2a970d20b07e33465ee710aad937665e1fef9fe9bd1f353ef14be97fc252c6b21071accad8dde78adac50d0152ccaff1553c974c82694f6203040c9ee04d7caa5a488fbb400425894cd6b38f7db58f9abc12a64b33bb9c0975a8b8aee95d8e73e8ae7dfb13886420686ca3575f02eaff34d0c3fe55b7c23785163be33e97fce9857dd5c7312bae60bbdeb459f5d08ef60cc7c6f5e16692404c44ad53bf2a164f7baea6e04f0bee6fa8c881cfb3721d8346c72631dbf01b840d9ed62aa09f2b641fc189d8f3895054ec22615af3996d5a72be1dae6ed533825a75c06ee6bea68cb74f88104d1b822d3617b5431405554475e217258fa9c6956bb152fb3b74409e812ef05cda98d9495219dc353d09d164d2ca6a29287febe6a97e0881572024d4ad5d6243931dcb36bec064fa08d1147d01104b474f642d1f92e781810830573af55ec5889df5daa56606a133cc354add25c47577aefb139456a0553e3b738525d3a0d05a9ab59d6f3505262f3e03ea656b09ae6c7dbf4421da769ba073e48d487c24678bb925055174395c8a3f49ac1dc873d83d76c0b22c03559c8ca2ceadec83fb4649717ba8747f49780f4387827e2aaca8b861350a9d6d94532e3f9b6ed7397ade32dbdd09f39d05ffa30840a273bbace24f8898ca75d4c19d0200192deb4c34561a38e6e8d9f7b756324d61a916fabaecdde471e653fbbbfafdb05a2b2175019099297f9d88f4b975808d207c09043de3b440d2bf19c45821feda9d9454de16c8e8669603f90cb3b2bf43d566f5ba066f6d35fe5304b8031b9ccf40f3fbfaa9b69499a2621d43ae464bd81d1c4d9afbc6b0203e1e2d3f51fb8e2d2a8bacbf7d5e4ef428116900a3f72e52d3c2d24b6e77b278477085f9fec234095cd714fa32f92017e833a5c611aa0037290ee51cbf7b0c8b23c6745701d9ab47035607ba1fe0438f15aff7e9b26d415a7d091245acc9fdc208314b1cd89c0a8fb7d2ad17789e87f3e9c9da2c688ab45c567867ba22a2bc6a5f03c9d0d95aa3bb213c787be05ceeb8f9f70e7243de9faeb19a1273924a323dc229abafd38bbe076aa2b88a3e64b3a11edd17dad495e87db84584884cdfa52a363483a5fe0cd220a4601a8697b486a76b945f28ac0b5537b30e1f640448eb99f6dee446611b04097d2a0c6e5dd899971720a1f9b92ce37562f8ba5fc053373b74069f03be8350e284ddaf60131e5123d5b5d46f2318d94194f03449c968c0995066eda7c6173e42f7c48ee392fa7021739063156044fd816d959ebd876df392907d42ab874e472", + "kzg_commitment" : "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec0636688650b0a49443de4e2d69df618914", + "kzg_proof" : "0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a795653913a151466aea2c5bbf193edd4f03c8", + "signed_block_header" : { + "message" : { + "slot" : "4625361742829423275", + "proposer_index" : "4630319196774442955", + "parent_root" : "0xda533c406bf3482d8e6e992e756be34172a8c47fc1cc0018350bfe98c946deda", + "state_root" : "0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390", + "body_root" : "0x4d1a19402bb984ca4d0005336ba05e1098babeeb0781f5744712934ae78b2a1b" + }, + "signature" : "0xadd071eb32731713b9040770807acb7033344aafc6df54ebf8a790187ddc947e2bb06a9547eb7c3876533720f36e54761018488a3857bb1d87175f7905620088fd81593465b7139e794f75bba0daaef713a9b7bec99656073c1396866d35f9b0" + }, + "kzg_commitment_inclusion_proof" : [ "0x27d82440eb21c640637a36dcc38e35768bb4c0c79aefa300ec0f0cba32cabb05", "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb", "0x999e0140abe701de220ca2e0b9c3b044b1c6ba33e0a3985dfe16a16b510f0846", "0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5", "0x735c0d406b5043543786d38912b287aaa4c0bc0f731247e9a3141adb9c4d9930", "0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6", "0xe622ea3f2b167ff1f7173f8e08e70279cad2b67bb9c63b46b51baf8cba92e570", "0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0", "0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b" ] + }, { + "index" : "4", + "blob" : "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", + "kzg_commitment" : "0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd0ee000b841381cd96f346bde6ffd5414", + "kzg_proof" : "0xcf2c053f899b836f534bfa2a45bf23b7be4890b9815a72a2aec9f70eff53d592047edf91261d7e7ed3adba3b53e44794", + "signed_block_header" : { + "message" : { + "slot" : "4539432581202110249", + "proposer_index" : "4544390030852162633", + "parent_root" : "0xbb0b0b3fe94fa42a5e0893ff71360feab7459127ca9149e88148b44625f31d08", + "state_root" : "0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd", + "body_root" : "0x2ed2e73ea915e0c71d9afe03676b8ab8dd578b9311463e45934f49f843386a48" + }, + "signature" : "0x958ab38cce5390fd750e87806f32ed8993a175bc3ccdab7ce2a40c23ac6117b603d5ae98d44a9780cca1f32d28bf5176058ef667b17fd95f13e047cd9cdebbf19f5270ec5a154e2ce2283da513c9ad05c26f10b0a65755eab4b1ed6f42175027" + }, + "kzg_commitment_inclusion_proof" : [ "0x0890f33e697e213e331430adc059611ed0518d6fa4b4ecd0384dc2678e76fb32", "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8", "0x7a56d03e29445ddbf2a59bb1b68edcecf66387dbea68e12d4a545719acbb4773", "0x41f3e13e4961bf0c12dd652f3bf49e85e35a8a25c70e67ffc1d08cc01d9921d3", "0x5414dc3ee9ac9e510720cd5a0e7db352e95d89b77dd78fb9ef51d088f8f9d85d", "0x51977a3f0ab3110e2a10e9c6bd0e89b1410ca45142ac42171bb2b169efc281bc", "0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947", "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31" ] + } ] +} \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getBlockAttestations.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getBlockAttestations.json index 26adce6e3fc..fbca66ee92c 100644 --- a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getBlockAttestations.json +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getBlockAttestations.json @@ -1 +1,40 @@ -{"execution_optimistic":false,"finalized":false,"data":[{"aggregation_bits":"0x4a9278690f62e1a353f1abf2b9701e13e8cdf4d9ac6b032ba43b05b25f713540ce24f3192819e752fb091217ff34b68e934a06d316b6060696f8f24749574c4b3ac2e4ccb6914c434b09a81fff523e12acbe299fcdad715593298d72ca70e1ffc743ad7ce89587fbb4b4c57db7856b7082db70ebddcbebe264f886236df2dd51539e10d4dcd5950e6cea7c993d3e999a5589a4c71669ffb1390987e43a8c4790a70275364f96cbee34b0b5a9d1b3da4322ad12e07c81c6e6430d2528f19bb1727c3f63f414885bd97505283b0bb6773712096d5feb67c43d67f2fbf17bf796ed5080aece6b968d532d985ad2553daf31ad4022aa49d7a92ada719c9f93ab4b6f01","data":{"slot":"4665021361504678828","index":"4669978815449698508","beacon_block_root":"0x103ac9406cdc59b89027eb1c9e97f607dd5fdccfa8fb2da4eaeea9d25032add9","source":{"epoch":"542502839","root":"0x8200a6402ca295554fb9562193cc71d60272d63beeaf2201fdf53e846e77f919"},"target":{"epoch":"542887588","root":"0x5cbeb140ec0ad7cb653388caecba483cf66bd817821ed18ca1f3b7f3b9b58a04"}},"signature":"0xae401f767ab1917f925fe299ad51a57d52f7cc80deb1cc20fa2b3aa983e4e4d23056d79f01f3c97e29c8905da17e70e30c2a3f6bdd83dbc4ddf530e02e8f4d7ba22260e12e5f5fe7875b48e79660615b275597e87b2d33e076664b3da1737852"},{"aggregation_bits":"0xd837d68714980f385c05b1c4e60e08695d100bd93ba04e50555a513c03bd99ce5c71e4a2a5a91419669bc583aab06a4e8f5d03f406f837e1a1d5bbec09cef1d8d9e33e9b65986cb7c3a274160d8245732ae9bf069db0adc8c4b9550069bfba37b8831ae257e4435f9910b4f4833226fa4830001eab94dc4fb0c094ac3876f98df571f6287b2093a52d404dc4bc3ae98f220a5127f647a3ba73545715870cc3e15051d024ea5de67f28429fd3139d978cc4aec10f360ef8e1f2207665a62887850b6ab8094cde4d7683e37ba631c8dc6e8ea826e6d12d1bf0962970755d49f8451035b8e305c6352b7de6753e459f404b760689dd4f53dd9ff6b0d221849b10aa01","data":{"slot":"4603879456717562315","index":"4602226973500878187","beacon_block_root":"0x6b0ac13f8a279ad3abec11bed1a49214f6e7af79b643595df6a38706b338e93b","source":{"epoch":"534615487","root":"0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26"},"target":{"epoch":"535000236","root":"0xb88ea93f0a5617e780f8ae6b1fc8e4480ff4abc18f66fc45ada895271cbcc666"}},"signature":"0xb8f4f7eb7f1ff3eb3923e6bf36b3a0865c80f47fb8e5dbe8830751f66bd8a06a3a1e06b7b2dec66556b532721018ce940c982953c8c6176125c7dd2ba1e8cb944e10e4a14905f7135a477810872518cbac085dfc69c1759d64dab5e225a5f16c"}]} \ No newline at end of file +{ + "execution_optimistic": false, + "finalized": false, + "data": [ + { + "aggregation_bits": "0x9827585d426605f0a23b9e5655df2c9b501c6282a5f6fae2fd7d5e0bdb68956e5b396afdfa9429f71e6e46ce94b24c59a4ca399550d1eccd9132ddc8c623328fd26ffad9a0d317fa12c74fe24eaaed6af7c42ab575d7d1d67fc4c3f1a42ebfba009b6ffc09671e81630d44851d5881782c1e25b9bb224b6f3e326221dfe891a480eb8fb6b93496a3836eb84d14bdd14706b06561622086cc5b5599be5c85252c2fb381141967c86c0aac570904117a3ae74d23572cdacff735639f1be45bcb7361cfbaf2970c5a0ec22004c4bfcfa8f75398984d07612c95523f1f39d17ed2b606cdd95e2ce4f41553918ac38030fbd280fc33c4c12a96052807f2e0cbbe1dcb01", + "data": { + "slot": "4669978815449698508", + "index": "4668326327938047084", + "beacon_block_root": "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f", + "source": { + "epoch": "542310465", + "root": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + }, + "target": { + "epoch": "542695214", + "root": "0x1f86d83f0bf91cc0d7e07410828140e0dddbb331dc20b6743f9f79e549b50b11" + } + }, + "signature": "0xb3a22ab9ec46aec35a9dacfb9036375ea1528041a926cb9d2d315ab964e82be5d6990e7fef2343f2dbb4c2b7dd74687f11144beaeb5758ebe349762b4dbde5e67bbc8d89a95a803c6610631d178249917cbf0d8b11bd8740f3cb767c843aa88c" + }, + { + "aggregation_bits": "0xb4a12e84d6e7598e246347c9df0778036a543cf20a90811be8c174b87cc98e0e0ba76fd9c7076eb7a9e484775545f6d5f2250b82098ec29be0e58139a4f463a2114f5321f6eec21a7b42baed386ceef459fbd893203af7ba9fcd9a66026acd536f0dc4e94bf34d909acd179b6aa21b824682d768d2d1d60682db4c0416dc9580432f4646a680f5f28857fabf55aa4c3fb5e97c2607fdf744013208f3db52ba768bd7ad4949a4a5ddd7d268ed35f6a3724f49761f9c4ff623695bec713896100742b7e0e96b3f174595d21b82a5acff69f98885460e338639bd25b48adfdcfb1d07b040bacf552a17e369197d0711717a54944a551f8c56a1335d6a443d61786f01", + "data": { + "slot": "4593964548827522954", + "index": "4592312065610838826", + "beacon_block_root": "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "source": { + "epoch": "535000236", + "root": "0xb88ea93f0a5617e780f8ae6b1fc8e4480ff4abc18f66fc45ada895271cbcc666" + }, + "target": { + "epoch": "533845989", + "root": "0x924cb53fcabe585d9672e01478b6bbae02eead9d22d5aad151a60e9768fa5751" + } + }, + "signature": "0x93bcd24f4a430255688b4a9a548da6f88a03bcf775104980edb7e818a3eb26f40ed8981681e4c92e4f02360fcc91bfdf062466e46c2a11058d2200e378fec149f13445aa520ea8e87bd94d3b260478c4ac0a92c27a3af35dae1e843e4112e05c" + } + ] +} \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getBlockHeader.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getBlockHeader.json index 04e2ee358a9..4e387b976cc 100644 --- a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getBlockHeader.json +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getBlockHeader.json @@ -1 +1,18 @@ -{"data":{"root":"0x28d7cd9c71934d91c6e7836a62759c39a672c439de48f06ab0a985334e77b837","canonical":true,"header":{"message":{"slot":"1","proposer_index":"4666673844721362956","parent_root":"0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef","state_root":"0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e","body_root":"0xff295368e542c3b9d0edd8ac2c13dbcead031030de32edd7e5f12249e8cf51ae"},"signature":"0x8077d47ad0fe431af45ca6ed24efda0fa9c84364ee8af5f9e83f53b3e5934961197cb31b062dcc3d5dc793ec6de565960924b65d0535f3833ecc51567572959e2849e470be8b6a1f21e2c735552595e9765e66a599d645d33fa3746d409fa122"}},"execution_optimistic":false,"finalized":false} \ No newline at end of file +{ + "data": { + "root": "0x127698f65207baf45ec6497931e82df707176d84588b76f6f1e4c4c577de3b94", + "canonical": true, + "header": { + "message": { + "slot": "1", + "proposer_index": "4666673844721362956", + "parent_root": "0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef", + "state_root": "0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e", + "body_root": "0x5a75dcd745c46d94e1b52a2d5834087ae5fae810fa4d69ee800f3753fc05a4b2" + }, + "signature": "0x8ab48d0165e8cc8bfc6804760141896946c3be751af5f16d1a03ead456ebceab88a8168e1da194df56c512edc15ca6350c413cb819d31a7ef69b329d8cb9fa8e5d93ae66289a445f1465d57d97e72d4c0866e48a806df7f58ebcd060e2d03a72" + } + }, + "execution_optimistic": false, + "finalized": false +} \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getBlockHeaders.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getBlockHeaders.json index f60bc9934dc..02346817229 100644 --- a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getBlockHeaders.json +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/beacon/getBlockHeaders.json @@ -1 +1,34 @@ -{"execution_optimistic":true,"finalized":false,"data":[{"root":"0x28d7cd9c71934d91c6e7836a62759c39a672c439de48f06ab0a985334e77b837","canonical":true,"header":{"message":{"slot":"1","proposer_index":"4666673844721362956","parent_root":"0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef","state_root":"0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e","body_root":"0xff295368e542c3b9d0edd8ac2c13dbcead031030de32edd7e5f12249e8cf51ae"},"signature":"0x8077d47ad0fe431af45ca6ed24efda0fa9c84364ee8af5f9e83f53b3e5934961197cb31b062dcc3d5dc793ec6de565960924b65d0535f3833ecc51567572959e2849e470be8b6a1f21e2c735552595e9765e66a599d645d33fa3746d409fa122"}},{"root":"0xaf82c4432d24203f4947c962e71eff26e1465a3e6065e9c264ffee9d45381357","canonical":true,"header":{"message":{"slot":"1","proposer_index":"4557609905175570249","parent_root":"0x23033a3fe9f2a903b4f058a4d4ef6a81852d9997184c0317133f980452ec62b2","state_root":"0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be","body_root":"0x08fa7f155ec243caca2b47cc976e8088f5eb7c35f66f41ba1a867eab1eebb8ce"},"signature":"0xabd643eedb5dfcc8f2db27bcfd59f6359517cec81ab4d5ff08bd5fd246ba120883c047e0cffc1d215104169a335628180df5779f128772f899546fd260328d4a4368a044c3e2037f4284624728dc94e05467b1559aad3077cf9557bf62fc56e2"}}]} \ No newline at end of file +{ + "execution_optimistic": true, + "finalized": false, + "data": [ + { + "root": "0x127698f65207baf45ec6497931e82df707176d84588b76f6f1e4c4c577de3b94", + "canonical": true, + "header": { + "message": { + "slot": "1", + "proposer_index": "4666673844721362956", + "parent_root": "0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef", + "state_root": "0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e", + "body_root": "0x5a75dcd745c46d94e1b52a2d5834087ae5fae810fa4d69ee800f3753fc05a4b2" + }, + "signature": "0x8ab48d0165e8cc8bfc6804760141896946c3be751af5f16d1a03ead456ebceab88a8168e1da194df56c512edc15ca6350c413cb819d31a7ef69b329d8cb9fa8e5d93ae66289a445f1465d57d97e72d4c0866e48a806df7f58ebcd060e2d03a72" + } + }, + { + "root": "0xdcaa6769bd88a5fc1302760cc1f20fe57d04f6164335cdf2149e54d58402d473", + "canonical": true, + "header": { + "message": { + "slot": "1", + "proposer_index": "4559262388392254378", + "parent_root": "0xc35d573fca784dabeaa154cbb2430480661e9ebd886037742eb9461b0e08cefc", + "state_root": "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "body_root": "0x6f8f410666c7a0d861b9984c17d50ddb50f7ec7bef63b48c43ad6695a12b55df" + }, + "signature": "0xa2695a1a43803793a6a1e80b15798147d8a63da5c8a6ee3e18dabd190255f48cbe36c33e3ffa372e11b19605cd2282a3136a2662cd3c8f9d3d0345ec1593b4241a0ee66c0d626da3db5cc6bd7d1119063922633c1c2987d69839af6ac37eb675" + } + } + ] +} \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/builder/getExpectedWithdrawals.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/builder/getExpectedWithdrawals.json index 7a6ca06da17..c68aa837b6b 100644 --- a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/builder/getExpectedWithdrawals.json +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/builder/getExpectedWithdrawals.json @@ -1 +1,12 @@ -{"execution_optimistic":false,"finalized":false,"data":[{"index":"4864971916622804241","validator_index":"2164897","address":"0x09988f43d11dcf2aa7811c9997eb4119e8f153ce","amount":"4866624404134455665"}]} \ No newline at end of file +{ + "execution_optimistic": false, + "finalized": false, + "data": [ + { + "index": "4503077933255190248", + "validator_index": "2357271", + "address": "0x42fb7d43b1006df9874a521b12867f80fbfa5084", + "amount": "4868276887351139793" + } + ] +} \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/debug/getForkChoice.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/debug/getForkChoice.json index c6f0ec4ceb7..a1e65ee71b2 100644 --- a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/debug/getForkChoice.json +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/debug/getForkChoice.json @@ -1 +1 @@ -{"justified_checkpoint":{"epoch":"1","root":"0x0000000000000000000000000000000000000000000000000000000000001111"},"finalized_checkpoint":{"epoch":"0","root":"0x0000000000000000000000000000000000000000000000000000000000002222"},"fork_choice_nodes":[{"slot":"32","block_root":"0x0000000000000000000000000000000000000000000000000000000000003333","parent_root":"0x0000000000000000000000000000000000000000000000000000000000004444","justified_epoch":"10","finalized_epoch":"11","weight":"409600000000","validity":"OPTIMISTIC","execution_block_hash":"0x0000000000000000000000000000000000000000000000000000000000006666","extra_data":{"state_root":"0x0000000000000000000000000000000000000000000000000000000000005555","justified_root":"0x0000000000000000000000000000000000000000000000000000000000007777","unrealised_justified_epoch":"12","unrealized_justified_root":"0x0000000000000000000000000000000000000000000000000000000000009999","unrealised_finalized_epoch":"13","unrealized_finalized_root":"0x0000000000000000000000000000000000000000000000000000000000000000"}}],"extra_data":{}} \ No newline at end of file +{"justified_checkpoint":{"epoch":"1","root":"0x0000000000000000000000000000000000000000000000000000000000001111"},"finalized_checkpoint":{"epoch":"0","root":"0x0000000000000000000000000000000000000000000000000000000000002222"},"fork_choice_nodes":[{"slot":"32","block_root":"0x0000000000000000000000000000000000000000000000000000000000003333","parent_root":"0x0000000000000000000000000000000000000000000000000000000000004444","justified_epoch":"10","finalized_epoch":"11","weight":"409600000000","validity":"optimistic","execution_block_hash":"0x0000000000000000000000000000000000000000000000000000000000006666","extra_data":{"state_root":"0x0000000000000000000000000000000000000000000000000000000000005555","justified_root":"0x0000000000000000000000000000000000000000000000000000000000007777","unrealised_justified_epoch":"12","unrealized_justified_root":"0x0000000000000000000000000000000000000000000000000000000000009999","unrealised_finalized_epoch":"13","unrealized_finalized_root":"0x0000000000000000000000000000000000000000000000000000000000000000"}}],"extra_data":{}} \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/debug/getState.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/debug/getState.json index 21ff360799c..1a9b4976635 100644 --- a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/debug/getState.json +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/debug/getState.json @@ -1 +1,5274 @@ -{"data":{"genesis_time":"%s","genesis_validators_root":"0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef","slot":"4669978815449698508","fork":{"previous_version":"0x103ac940","current_version":"0x6fdfab40","epoch":"4658411424342975020"},"latest_block_header":{"slot":"4669978815449698508","proposer_index":"4663368873993027404","parent_root":"0x5cbeb140ec0ad7cb653388caecba483cf66bd817821ed18ca1f3b7f3b9b58a04","state_root":"0x0000000000000000000000000000000000000000000000000000000000000000","body_root":"0x1f86d83f0bf91cc0d7e07410828140e0dddbb331dc20b6743f9f79e549b50b11"},"block_roots":["0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b","0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb","0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486","0x6b0ac13f8a279ad3abec11bed1a49214f6e7af79b643595df6a38706b338e93b","0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6","0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000"],"state_roots":["0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1","0xb88ea93f0a5617e780f8ae6b1fc8e4480ff4abc18f66fc45ada895271cbcc666","0xcbafa33faaa1f62b763b1697f350f91515f7aa53462f2500db29d9eff71c7ef1","0x924cb53fcabe585d9672e01478b6bbae02eead9d22d5aad151a60e9768fa5751","0xa56daf3f6a0a38a28bb547404c3fd07b08f1ac2fd99dd38b7f27525f425b0fdc","0x0413923f8a8494fa55044c196eeb367d2800a80969899f2e64ada348863fa491","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000"],"historical_roots":["0x17348c3f2ad0733f4b47b34442744b4a2e03a79b1f52c8e8922ee71060a05b1c","0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c","0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06","0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565","0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0","0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650","0xda533c406bf3482d8e6e992e756be34172a8c47fc1cc0018350bfe98c946deda","0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390","0x4d1a19402bb984ca4d0005336ba05e1098babeeb0781f5744712934ae78b2a1b","0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b","0x27d82440eb21c640637a36dcc38e35768bb4c0c79aefa300ec0f0cba32cabb05","0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb","0x999e0140abe701de220ca2e0b9c3b044b1c6ba33e0a3985dfe16a16b510f0846","0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5","0x735c0d406b5043543786d38912b287aaa4c0bc0f731247e9a3141adb9c4d9930","0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6","0xe622ea3f2b167ff1f7173f8e08e70279cad2b67bb9c63b46b51baf8cba92e570","0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0","0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b","0x82a81c3f096d065c7e3f5d7df79bd182a53c9471a737cfb9f7c4e9ed95d0f767","0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2","0x5c66283fc9d547d293b98e264f8aa8e89836964d3ba67d459cc2625de10e8952","0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd","0xcf2c053f899b836f534bfa2a45bf23b7be4890b9815a72a2aec9f70eff53d592","0xe24dff3e29e762b4488e615619483884c44b8f4b37239b5cdc4a3bd7d9b48c1d","0xa8ea103f4904c5e568c52bd49eadfa1cb142929514c9202e53c7707e4a92667d","0xbb0b0b3fe94fa42a5e0893ff71360feab7459127ca9149e88148b44625f31d08","0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd","0x2ed2e73ea915e0c71d9afe03676b8ab8dd578b9311463e45934f49f843386a48","0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8","0x0890f33e697e213e331430adc059611ed0518d6fa4b4ecd0384dc2678e76fb32","0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8","0x7a56d03e29445ddbf2a59bb1b68edcecf66387dbea68e12d4a545719acbb4773","0x41f3e13e4961bf0c12dd652f3bf49e85e35a8a25c70e67ffc1d08cc01d9921d3","0x5414dc3ee9ac9e510720cd5a0e7db352e95d89b77dd78fb9ef51d088f8f9d85d","0x51977a3f0ab3110e2a10e9c6bd0e89b1410ca45142ac42171bb2b169efc281bc","0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947","0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7","0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31","0x9d1b633f8ae18e21ff1b86740b32dbe55a18a0991bcfe5ffd2b6bf8a59465fe7","0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672","0x77d96e3f4a4ad0971596b71d6420b24b4d12a275af3d948b77b438faa484f0d1","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0xe99f4b3f0a100c35d42723225a552d1a73249ce1f5f188e889bbcdabc2c93c12","0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c","0xc35d573fca784dabeaa154cbb2430480661e9ebd886037742eb9461b0e08cefc","0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587","0x3624343f893e8948a933c0cfa8787f4e8c309829ce142cd140c0dbcc2c4d1a3d","0x49452e3f298a688d9e7627fb7c01941b923397bb84dd548b6e411f9506aed1c7","0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27","0x23033a3fe9f2a903b4f058a4d4ef6a81852d9997184c0317133f980452ec62b2","0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be","0xf8eb5a3ea82ccf3c1be1ac153e3f77f273a07343291711b9de6b9dbebc4c9b49","0xbf886c3ec849316e3b187793c3a4398b6097768d06bd968a54e8d2652d2a75a9","0xd2a9663e689510b3305bdebe972d4e58669a751fbc85bf448269162e078b2c34","0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9","0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874","0x0c0d553e4878ae811024144112c88bbf79a372d5dfdf39730cede08696ad52d4","0x1f2e4f3ee8c38dc605677b6ce650a08c7fa6716795a8622d396e244f710e0a5f","0x7ed3313e083eea1ecfb57f4508fd068e9fb56c4125942ed01ef47538b5f29e14","0x91f42b3ea889c963c4f8e670db851b5ba5b86bd3dc5c578a4c75b9008f53569f","0x58913d3ec8a62b95e52fb1ee60ebddf392af6e1db902dd5bc3f1eea7003130ff","0x6bb2373e68f20adada72181a3474f2c098b26daf6fcb0516f0723270da91e789","0xcb571a3e876c6732a4c11cf3562059c2b8c16889ffb6d1b8d5f883591e767c3f","0xde78143e27b846779904841e2aa96d8fbec4671bb57ffa72037ac721f8d633ca","0xa415263e48d5a8a8ba3b4e9caf0e3028abbb6a65922580447af6fcc869b40d2a","0xb736203ee72088edaf7eb5c7839744f5b1be69f748eea8fea77740914415c5b4","0xb4b9be3e0927fba9d26ed13331291a54096d84910dc35b5cd4d721723cde6d13","0xc7dab83ea972daeec7b1385f04b22e210f708323c38b84160159653a163f259e","0x8e77ca3ec98f3c20e7e802dd8917f1b9fc66866da0310ae878d59ae1871cfffd","0xa198c43e69db1b65dc2b6a085da00587026a85ff57fa32a2a656dea9617db688","0x003ea73e885578bda77a6ee17f4c6c88227980d9e6e5fe448bdc2f93a5614b3e","0x135fa13e28a157029cbdd50c53d58055287c7f6b9dae27ffb95d735b7fc202c9","0xdafbb23e48beb933bcf49f8ad83a43ee157382b57a54add02fdaa802f09fdc28","0xed1cad3ee8099978b13707b6acc357bb1b768147301dd68a5d5beccacb0094b3","0x4dc28f3e0884f5d07b860b8fce6fbebc3b857c21c008a22d42e13db40fe52869","0x60e3893ea8cfd41571c972baa1f8d28941887bb376d1cae77062817ce945e0f3","0x26809b3ec8ec364791003d38265e95222e7f7efd537750b9e6deb6235a23ba53","0x39a1953e6838168c8643a463fae6a9ef34827d8f094079731460faeb348471de","0x9946783e88b272e45092a83c1c9310f154917869992b4516f9e54bd578680694","0xac67723e28fe512946d50f68f01b25be5a9477fb4ff46dd027678f9d52c9bd1e","0x7304843e481bb45a660cdae57581e756478b7a452c9af3a19de3c444c3a6977e","0x86257e3ee866939f5b4f4111490afc234d8e79d7e3621c5ccb64080d9e074f09","0x2fda834311b58db49107ebef3efd6ab3f5f751f2e5ae381ba4e248bbcd2c6f5e","0x42fb7d43b1006df9874a521b12867f80fbfa50849c7761d5d1638c83a78d26e9","0x09988f43d11dcf2aa7811c9997eb4119e8f153ce791de7a648e0c12a186b0049","0x1cb989437169ae6f9cc483c46a7456e6eff452602fe60f61766105f3f2cbb7d3","0x7b5e6c4391e30ac86613889d8c20bde70e044e3abfd1db035be756dc36b04c89","0x8e7f6643312fea0c5c56efc860a9d1b414074dcc759a04be89689aa411110414","0x551c7843514c4c3e7c8db946e50e944d01fe4f1652408a8fffe4cf4b82eedd73","0x683d7243f1972b8371d02072b997a81a08014fa80809b3492d6613145c4f95fe","0xc8e25443111288db3b1f254bdb430f1c27104a8298f47eec12ec64fda0332ab4","0xdb034f43b15d672031628c76afcc23e92d1349144fbda7a6406da8c57a94e13e","0xa2a06043d17ac951519956f43432e6811a0a4c5e2b632d78b6e9dd6ceb71bb9e","0xb5c15a4371c6a89646dcbd1f07bbfa4e210d4bf0e22b5632e46a2135c5d27229","0x14673d43914005ef102bc2f829676150401c46ca721722d5c9f0721e09b707df","0x27883743308ce433056e2924fdef751d461f455c28e04a8ff771b6e6e417bf69","0xee24494351a9466526a5f3a1825538b6331648a60586d0606deeeb8d55f598c9","0x01464343f1f425aa1be85acd56de4c833a194738bb4ef91a9b6f2f562f565054","0xfdc8e14312fb98663ed87639047022e291c761d28023ac78c7cf1037271ff9b2"],"eth1_data":{"deposit_root":"0x10eadb43b24678ab331bde64d7f836af97ca606436ecd432f55054ff0180b03d","deposit_count":"4894716627408020434","block_hash":"0xeaa7e74372afb92149950f0e30e70d158bc46240ca5a83be9a4ecd6e4cbe4128"},"eth1_data_votes":[{"deposit_root":"0x4a4dca439229167a13e413e752937416aad35d1a59464f617ed41e5890a2d6dd","deposit_count":"4883149240596264241","block_hash":"0x240bd643529257f0285e4590ab814b7c9dcd5ff6edb4fdec23d297c7dce067c8"},{"deposit_root":"0x372cd043f2dd36351da1acbb7f0a6049a4d05e88a37d26a75153db8fb6411f53","deposit_count":"4878191786651244561","block_hash":"0xa9f2ac43b1a372d2dd3218c0743fdb17c9e258f4e9311b04635a7041d4866b93"},{"deposit_root":"0x708fbe43d1c0d403fd69e23dfaa49db0b6d95b3ec6d7a0d5dad6a5e8456445f3","deposit_count":"4879844274162895985","block_hash":"0xe3559b43918610a1bdfb4d42efd9187fdceb55aa0c8c9532eddd3a9a63a99133"},{"deposit_root":"0xf676954331d2efe5b23eb56dc3622d4ce2ee543cc254beec1a5f7e623e0a49be","deposit_count":"4874886820217876305","block_hash":"0xcf34a143f13a315cc7b8e6161c5104b2d6e8561856c36c78bf5cf7d18948daa8"},{"deposit_root":"0x92fcc742102977503966d35cb217fc55bd583232b0c551605c08b9c319485bb5","deposit_count":"4810439944702424240","block_hash":"0x6cbad342d091b8c64ee004060b06d3bbb052340e443400ec010632336486ec9f"},{"deposit_root":"0x7fdbcd4270dd970b44236c31de8ee788b75533a0fafc28a62f8775fb3fe7a32a","deposit_count":"4805482499347339152","block_hash":"0xf2a1aa4230a3d3a803b5d735d4c36257dc672d0c40b11d03418e0aad5d2cf06a"},{"deposit_root":"0xb83ebc4250c035da23eca1b3592925f0c95e30561d57a3d4b80a4054ce09caca","deposit_count":"4807134978269055984","block_hash":"0x2b0599420f867177e37d0db84f5ea0beef702ac2630b9831ca11d505ec4e160b"},{"deposit_root":"0x3e269342afd150bcd8c074e323e7b48bf57329541ad4c0ebf89218cec6afcd95","deposit_count":"4802177528619003599","block_hash":"0x18e49e426f3a9232ed3aa68c7bd58bf1e96d2b30ad426f779d90913d12ee5e80"},{"deposit_root":"0x778981428fb4ee8ab889aa659e81f2f2087d260a3d2e3b1a8216e32655d2f335","deposit_count":"4790610137512280111","block_hash":"0x51478d424f1d3001cd03dc0ef66fc958fb7628e6d09ce9a526145c96a1108520"},{"deposit_root":"0x64688742ef680f46c246433acaf8dd25027a27788665126054959f5e7b713cab","deposit_count":"4838532176565923600","block_hash":"0x740c2043b0ba6147da79c6d14c13c8515f2b41a40103ee77ae76c4074d9b9c94"},{"deposit_root":"0x3aa93143d0d7c378fbb0904fd1788aea4c2244eedea8734924f3f9aebe7876f4","deposit_count":"4840184655487640432","block_hash":"0xad6f0e43909dff15ba42fc53c6ad05b972343e5a245d68a637fa8e60dcbdc234"},{"deposit_root":"0xc090084330e9de5aaf85637f9a361a8678373decdb259160657bd228b71e7abf","deposit_count":"4835227205837588048","block_hash":"0x9a4e1443f05120d1c5ff9428f324f1eb6c313fc86e943fec09794b98025d0baa"},{"deposit_root":"0xf9f3f64210cc7c298f4e990115d157ed8b403aa2fe7f0b8feefe9c814641a05f","deposit_count":"4823659819025831856","block_hash":"0xd3b10243d034be9fa5c8caaa6ebf2e537e3a3c7e91eeb91a93fc15f1917f314a"},{"deposit_root":"0xe6d2fc4270809de49a0b32d641484320853d3b1047b7e2d4c07d59b96ce0e8d4","deposit_count":"4818702369375779472","block_hash":"0x5999d9423046d981599d9dda377dbeeeaa4f357c8d6bd731d384ee6a8a253515"},{"deposit_root":"0x2036eb4250633bb379d46758bce28087974638c66a115d034a012412fb020f75","deposit_count":"4820354852592463600","block_hash":"0xf51e0c420e9d60ece0c4bbc926328df885b912727bdc6aa5152e29cc6563470c"},{"deposit_root":"0x08400642aee83f31d60723f5fabaa1c58bbc110432a5935f43af6c943fc4fe96","deposit_count":"4762517914238715343","block_hash":"0xe2fd11426e5181a7eb81549e52a9782b7fb613e0c51342ebe7ace5038b029081"},{"deposit_root":"0x42a3f4418ecbddffb5d058777555df2c9ec50eba55ff0d8ecc3237edcfe62437","deposit_count":"4750950527426959150","block_hash":"0x1c6100424e341f76cb4a8a20cd43b69291bf1096e86dbc197030b05c1a25b621"},{"deposit_root":"0x2f82fa41ee7ffebac08df14ba1ccca5f98c20f289e36e5d39eb1f324f4856dac","deposit_count":"4745993073481939470","block_hash":"0xa148d741ae453a587f1f5d509701462ebdd40994e5ead930b1b888d612cbb9ec"},{"deposit_root":"0x68e5e841ce629c89a05627ce1c6708c7aacb0cdec1905f022835be7d83a8934c","deposit_count":"4747645556698623598","block_hash":"0xdbabc5418e28d8265fe892d2129c8395d0dd064a0845545f3a3c532fa2eddf8c"},{"deposit_root":"0xeeccbf412e74b76b542bfafde5249862d6e005dcbe0d7d1968bd96f77c4e9717","deposit_count":"4742688102753603918","block_hash":"0xc78acb41eedcf8e16aa52ba73e136fc8cada07b8517c2ba50cbb0f67c78c2802"},{"deposit_root":"0xc40d6a420fe36b9e8d954713eca44427218922521651de02391bf147bf55d160","deposit_count":"4784000204645543599","block_hash":"0x9ecb7542cf4bad14a20f79bc45931b8d1483242ea9bf8c8edd186ab70a94624b"},{"deposit_root":"0xb1ec6f426f978c599752e0e7181c305a1b8623c06088b5480b9aad7fe5f419d6","deposit_count":"4779042750700523919","block_hash":"0x23b34c422f5dc8f657e44bec0e51ab2840981d2ca63caaa51da14231033a6616"},{"deposit_root":"0xea4f5e424f7a2a28771b166a93b66dc12d8f207683e22f77941d78d874174076","deposit_count":"4780695238212175343","block_hash":"0x5d163b420f4066c536ad816e89ebe88f53a11ae2c99624d4a7240d8a925c8cb6"},{"deposit_root":"0x70373542af8b450a2cf0e8995d74fd5c59a419747f5f4d8ed5a550526cbd4341","deposit_count":"4775737784267155663","block_hash":"0x49f540426ff48680416a1a43b562d4c24d9e1b5012cefb1979a3c9c1b8fbd42b"},{"deposit_root":"0xa99a23428f6ee3d80bb91e1cd80e3bc46cad162aa2b9c7bc5e291babfcdf69e1","deposit_count":"4764170397455399471","block_hash":"0x83582f424fd7244f213350c530fd112a5fa71806352876480227941a471efbcb"},{"deposit_root":"0x96792942ef2204941676b7f0048626f766aa1798ecf09e0230a8d7e2217fb256","deposit_count":"4706333459101651213","block_hash":"0x6c624a41ad5c29cd7d660b626ed53268531df243fdbbaca4fbd4dc9c8cdfeaed"},{"deposit_root":"0x32ff5b41cd798bfe9d9dd5dff33af5004014f58dda61327672511244fcbcc44d","deposit_count":"4707985942318335341","block_hash":"0xa5c538418d3fc79b5d2f41e4e96f70cf6626eff9201627d38558a7f51b02118e"},{"deposit_root":"0xb8e632412d8ba6e05272a80fbcf8849c6c29ee8bd6de4f8db2d9eabdf562c818","deposit_count":"4703028492668282957","block_hash":"0x92a43e41edf3e75667ecd9b815e75b026023f067694dfe1857d7632d40a15903"},{"deposit_root":"0xf14921410d6e44af323bde913793c2037f32eb41f938cabb3c5db5168485eeb8","deposit_count":"4691461101561559469","block_hash":"0xcb072d41cdd6852547b50f3b90819969722ced1d8ca77847e05a2e86cfc37fa3"},{"deposit_root":"0xde2827416d22656a3cf87666640aae36792fecaf4370a1010edc714eaa24372e","deposit_count":"4686503651911507085","block_hash":"0x51ef03412de8a007fc89e26a593f29059e41e61b8924965e21e30600c869836e"},{"deposit_root":"0x188c15414d0503391cc1ace8dfa4eb9d8b38e96566ca1b30975f3ca739475dce","deposit_count":"4688156139423158509","block_hash":"0x2730ae410e57553a34f42f8060bfd5c9e9e90292e167f747f14061500b71bdb7"},{"deposit_root":"0x3a51a841aea2347f293797ab3448ea96efec0124973020021fc2a418e5d17442","deposit_count":"4736078169886867406","block_hash":"0x140fb4416e0b76f53fb1c8548d36c1fce3e603002b9fce8dc3bf1d883110062d"}],"eth1_deposit_index":"4726163266291795342","validators":[{"pubkey":"0x8238eb67219c0c314c0b387a1300ebe7ee0b3bfde764c14e90d42e82197100fedb6950f6db432cee0e766cfd35ff22c7","withdrawal_credentials":"0x4d72a2414eee13c41e7afed607d1fe63f5ef00b64ef948bc4d43e8e0c0322ccd","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xaf72cddf5e9e8f9e3213202be4447e2eb5a5a61632935ce5695105b936cccae9fc9c504f2bcf511d91531a2738e1d71b","withdrawal_credentials":"0xc0387f410db44f61de0b6adbfd057a321b02fb2194ad3d195f4a7d92de77780d","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x83feea64397a7a9d3fbac0b9a16ccbfd63c4d4fa5d0fd8bbfa13739148e752ce1e9b1e01654b56cb56a196fd8d64db3f","withdrawal_credentials":"0x9af68a41ce1c91d7f3859b8456f450980efcfcfd271ceca40448f60129b609f8","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xaafd198509805b36458bfa1c0202ea15976ab05f75100f8ed811fb700b4d657531e364c12a87d345f4799c43e2bb5ae6","withdrawal_credentials":"0x0cbd67418de2cc74b31707894c29cc66340ef7696dd0e001164f8bb348fb5538","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb9f6a699d12e3b22af90798367dbf0631ebaaaf8f61655d320f1459b2ed90c922371211fd49c3b93e3c5a550730cf272","withdrawal_credentials":"0xe67a73414d4b0eebc8913832a417a3cc2708f945003f8f8dbb4c04239339e722","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x85808a97e324987cd03bfc33e49aaa6cbc8a5cb66fb44111b0d8bc8c6b7c810638e6a6ac88d640b3492a684c19053f61","withdrawal_credentials":"0xa250734616e5e744f48c493c6d932629d574d0f2b953d406c14b88999cbfbe02","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x99b20a6a3e75af8e62e7f3f5143a149ab8e4ff041b0bf44e70174c19184e0ad2d612a3cd648ac30b428469bde0d1cea2","withdrawal_credentials":"0x7c0e7f46d64d29bb09077be5c681fd8ec96ed2ce4dc2829266490109e8fd4fed","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x962f9f117cb8bfe6d6bcc374161f8e605cdff99bee8161ed5b527987f0e5116f94821f23f28773da660a420525bd4201","withdrawal_credentials":"0xefd45b4696136558c998e6e9bcb6785dee80cc3a937677ef785096ba06439c2d","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8b585aa726039b4472f9552d0c79479cb6adc817b80667143271f83ddea3228455397c6ac7e29e6fa703eb31e8674828","withdrawal_credentials":"0xc8926746567ca6cede12189315a54fc3e17ace1626e5257b1d4e0f2a51812d18","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xaec6dab7580191dde7d836f49c0e9639ec9f7306f25cf1c37b212a28244f1b8144c1a05919239caec52ba139fede301b","withdrawal_credentials":"0x3b5944461642e26b9ea483970adaca91078dc8826c991ad82f55a4db6fc67958","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xaa7d67cf12895fe67b0023fb9c2fb0b7a60bd3b9c90c01dd758002a19265cc9c2fa5338b6a59a5a0b648140752ddf8a0","withdrawal_credentials":"0x15175046d6aa23e2b31eb54063c8a1f7fa86ca5eff07c963d4521d4bbb040b43","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa0e27864d6b654c4d9b58d1248ca6a494b47d5764847ce585f31df6aa5cf24d17113207ac820b0a5f6da0df2b182931b","withdrawal_credentials":"0x87dd2c4696705f7f73b0204559fd1cc62099c4ca46bcbdc0e659b2fcd9495783","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb18269548d92185838a418050a4c9523838a4704849986ca7d0e2c1b360c8319011a2df056268abf89350de67d1b1b78","withdrawal_credentials":"0x619b384656d9a0f5882a52eeb2ebf32b1393c6a6d92a6c4c8b572b6c2488e86d","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa211797aa69f18ce249575da91eca37736093b7339a10fa1272692ddd82239fd8f6b75b36a796721b81d6d9a23fabf84","withdrawal_credentials":"0x713fd146172bf3f6a05dd5853306de577144e0d254c84764e5385015f6b14857","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb2463b15365ee966c742aab78e5a694f1f4eee7ba5e633930b0c5f587ff65fa8d7d4ad918a8120fdfc1c69c2ef175b70","withdrawal_credentials":"0x4afddc46d793346db6d7062f8cf4b4bd653ee2aee736f6ef8936c98442f0d941","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xab4bbb1caad2be96ce362592fcc04c8c71734b59fef25d4cdd59bf6aa351ddcb63f5361e5d9dce661efcd56b4218f929","withdrawal_credentials":"0xbdc3b9469759700a756972338229308c8a50dc1a2debea4c9c3d5e3660352682","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x955246320f9112d6559264b15d335ec4e9bb68ab2b73dc08b242944b4aa4741d391a89f3cd3382a858b5e6ec9bf33b6e","withdrawal_credentials":"0x9781c54657c2b1808be3a3dcdb1707f27e4adef6c15999d8403bd7a5ab73b76c","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xad37627de08eb0d0bedbc4f9b6a4aa2e002627ff5cfbb6959490b144fbfc6a331e9dc0c4c712ffb05a9f0d42754dab30","withdrawal_credentials":"0x0948a2461788ed1d4a750fe1d04c82c0a35cd862070e8e3553426c57c9b803ad","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x975152efef95e4e4af3a6a0f79b1f3aeefb81320c04467fb624ec2adffb3af5062b55b8c5783552a7c5a190ef20b36d7","withdrawal_credentials":"0xe305ae46d7f02e9460ef408a293b59269756da3e9a7c3cc1f73fe5c615f79497","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa6e40ebe55ee13712a34981540bdd953448f1352d13742cfd7ae8abe89b0745a679a86aee7b5b416e5a3a87170ddae87","withdrawal_credentials":"0x56cc8a4696b66a311f81ac8e1f70d4f4bc68d4aae030311e0a477a78333ce1d7","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x91866281e564f2166e4763df3b138fd387f17ffcc7b347fdbc1fb50a31655dd39ec1d682f5044ce69eab524aa4007a87","withdrawal_credentials":"0x308a9646561faca734fbdd37785eab5ab062d686739fdfa9af44f3e77e7a72c2","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x933ff51b3543f3a53e0408f9553e242db71f4da386e07a2c50116023f5b6a897dc2ebe40df4f89381081fc5b651b81b4","withdrawal_credentials":"0x0573b7451559d1e09beb31a9e2adb7cb9dd5b032846aed4b7a71f8a1e8daaa59","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb6a7219422fa8dcf311dce6f2daad64d8e7add1905e755ea43e40df9399d45fa201292eac717cdd6bb09e438706b186b","withdrawal_credentials":"0xdf30c345d5c11257b16563523a9c8e3190cfb20e18d99bd71e6f711134193c44","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8348da0d73db2e9e07fdf61060b5fe240a884c2e8edd48077f6ba522ce0a23fec3f5b5277795bb959c76b44dabcdb37b","withdrawal_credentials":"0x52f79f4595874ef470f7ce5630d10900b6e1ac7a5e8d9034317606c3525e8884","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xac026719d44d1e8eae15ec4df24eed0d77a2f463792f5ba9253d23d50f8f19d3e82eb735d2acfdf7105f5bda84530487","withdrawal_credentials":"0x2cb5ab4555f08f6a8671000089bfe065a9dbae56f1fb3ec0d5737f329d9c196f","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8040a9aa1a7c18f8db862015ea6ba5b260a3790640302913eafef678d40c66805f05cf1a0f46a2254ebc8dafe79e2bca","withdrawal_credentials":"0x9e7b884515b6cb0745036c047ff45b34cfeda8c237b0331de87a14e4bce165af","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa8a8f5fd201bc673bada188e1ad794d70c44272af3dcc856e38055f602e26747fbb3506f172aa018d083b3690f2e644c","withdrawal_credentials":"0x78399445d51e0d7e5b7d9dadd7e2329ac2e7aa9eca1ee2a88c788d530720f799","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb932d4eee66120398141d5d9a50d71dc9e7c6950a9a65e917d3a86b33d887189c85a728c4bb6c1ae82e63e46454a28d6","withdrawal_credentials":"0xebff704594e4481b1a0f09b2cd17ae68e8f9a40a11d3d6059f7f2205256543da","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa421315146222618b1c57f9e304785c4de36458dade253a459e577566b4d806ff1691c5ebc8a974cb4ed8b1704ba3c42","withdrawal_credentials":"0xc4bd7c45554d8a9130893a5b260685cedbf3a6e6a4418591437d9b7470a3d4c4","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8d33433c914c5ca722b0683f97f4d05e012cdc85633a3d2581b2b1c7a57248c60b9446d89e224655c04be566c60127fa","withdrawal_credentials":"0xd4611546169fdc9248bcbdf2a7206ffa39a5c0121fdf60a99d5ec01d42cd34ae","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8cc3ed86d17823dc4f2e7b26afd5cc158a9aa0eae455d3036a12b58ba820ef469bc6c96b924993a742bee6a6935b28d4","withdrawal_credentials":"0xae1f2146d6071e095d36ef9b000f46602c9fc2eeb24d0f35425c398d8e0bc698","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa022cd8d35607db7b3261c18d36951b7b9cfefb4a5154e5c04588a4272f31edd43e722febde2bdc2a4a87c996bf00451","withdrawal_credentials":"0x20e6fd4595cd59a61cc85aa0f643c12e52b1bc5af80104925563ce3eac5012d9","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa8a931213b70226a83587756c4600a2ff88d2cd4eb61fc671e9da331c3a3bc0bbc8ce4a39db7d52998c678514b2eea1b","withdrawal_credentials":"0xfaa3094655369b1c32428c494f32989445abbe368c70b21df96047aef78ea3c3","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x944871d0c9f5ed3f398b2affdc4c9bc535a38c093e20ada27d8fe171fec1a1b990243883afed5eabe561c6ec39864b30","withdrawal_credentials":"0x6d6ae64515fcd6b9f1d3f74d446713636bbdb8a2d224a77a0c68dc5f15d4ef03","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa4d9a7333cbbfe1b43c81d96c2c75624494864a7759e7831003e4604f678699fda282c3ea510c99c98c75bba3cc4604b","withdrawal_credentials":"0x4628f245d5641830074e29f79d55eac85eb7ba7e65935506b06555cf611281ee","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x85ecf16940353cf72aee4b4aa8fec6c881b79dfdb7b6204dc13793b9ce153a6cb43870db19659f5a222433f938206fe9","withdrawal_credentials":"0xb9eece45952a54cdc6df94fb938a659784c9b4eaab474a63c36cea807f57cd2e","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x872247e7012206c1e5435f7743d5a555239339733524372121b95ca339504d44094c6f908f08ebd2b53cb1ed085a245a","withdrawal_credentials":"0x93acda4555939543dc59c6a4ec783cfd77c3b6c63eb6f8ee676a63f0ca955e19","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa5a7604c7f72ebb0fb5471a96b8d49762c6b75aec9ff44cfa2e312f9cd296a3e9375b891d785438dd48aedfadbc426e2","withdrawal_credentials":"0x6995fb4414cdba7c434a1a1656c8486e653691724f810691329768aa35f696b0","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x93818d1d96a9323ef0447a95838d42dd1a09a4b9037c00beaadd6080835ccc5d99ac25688d65530811641e17dc3180b3","withdrawal_credentials":"0x42530745d435fcf258c44bbfaeb61fd45830934ee3efb41cd794e1198034289b","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb6347454b98399213bb55322bae7cefb903ed09c594c87259f31ed3232db2aace12fa70185509888bfa245ad225f769c","withdrawal_credentials":"0xb519e44493fb37901856b7c3a4eb9aa27e428dba29a4a979ea9b76cb9e7974db","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xac572911123c11d2009e1c385f22fe42d16a679775646eab6fbc8be798be02f77a9b57cfb06550539c024e059e30bb34","withdrawal_credentials":"0x8fd7ef44546479062dd0e86cfdd97108713c8f96bc1258058e99ef3ae9b705c6","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa061bb193abe9246eaaaac35b76cb8d70f8239298069c7396da3411f63e7911a392161acd162c21fdf833d60f806d169","withdrawal_credentials":"0x019ecc44132ab5a3ec615471f30eedd6974e890202c74c62a1a084ec08fd5106","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xaa5d57db0f3b58f238b9be564a977b953a1de9d6b4d8a2be7dbcf0f0cb0200a73ab14bd5c069d53db8d46fb226672562","withdrawal_credentials":"0xdb5bd844d392f61902dc851a4bfdc33c8a488bde9535fbed459efd5b533be3f0","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa81cbb669ab9ae9951ebf7a143b4a3a83c8884fb2f0420e95e61904de24a3b27e9426687419c48645f9a7a1720ebe50b","withdrawal_credentials":"0x4e22b544935832b7c16df11e41323f0bb05a854adce9ef4a58a5920d71802f31","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa1ddf7f024df4dc53d70a695ddefc6741afb9b002e686ea528975765b1d8b61e8d60cf4984178799c67df3ba3156c9d3","withdrawal_credentials":"0x28e0c04453c1732dd7e722c89a201671a35487266f589ed6fca20b7dbcbec01b","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb4f2ab7d49b6f55517d4eeb28c540fdb9dffbab0c13bc76e07a434fee9b383521a0fd9f6639a8546fa3671a00a211009","withdrawal_credentials":"0x378459451413c62eef1aa65f1c3b009d0106a152eaf579ee568430268fe82005","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb1efeeb48386e83b4966e55d834fe07b63ab3cdb59c1c4aaccfd587a819445c50237894bef43d235d7deebbce23a77af","withdrawal_credentials":"0x11426545d47b07a50495d7087429d702f4ffa22e7d64287afb81a995da26b2ef","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x92e12d76878e0de0473c4c6782c1792e4e70baa2852acf055bc3c88737dc845d3660e0f91a57be075718545a4e45f1a6","withdrawal_credentials":"0x8308424594414342c426430d6a5e52d11a129d9ac3181dd70d893e47f86bfe2f","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8534c9f9cb0ad52f9d80709583a57518b5479ce39f2027503bfdf5c15f2c6bf277ed0fa8ded816d106bfa94ae5884d56","withdrawal_credentials":"0x5dc64d4554aa84b8d9a074b6c34c29370d0c9f765787cb62b286b7b643aa8f1a","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x95a323d2a4bf702d248584876975f60cca9ec15ff0888d928f8f3798e1ebb55d9b1704a2369db37a4874cf20c1fa18ae","withdrawal_credentials":"0xd08c2a451470c0559932e0bab981a405331e99e29d3bc0bfc48d4c6862efdb5a","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb0b0c8a0b5cc2eb6b35db821eb29d759fb33284bd5ccb325b1f8a96e07ca96d12037edc86443b642ec6db22e0c6487e3","withdrawal_credentials":"0xaa4a3645d4d801ccaeac116411707b6b26189bbe30aa6e4b698bc5d7ad2d6d45","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x875a76a3e345afee45e7181cea2f8e1f85160eb87b48f1fe8813872d412b08b2f4ff9515eacdab1157f02eec3396e2f0","withdrawal_credentials":"0x1c111345949e3d696e3e7d6807a5f6394c2a952a765e63a87b925a89cb72b985","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x92859a8dd8bc58c9c35ba7b5a03f68937dcd6a168c1986f2367dd115d07b596dcdc305ef4aefc5c20d0e15b2dec71458","withdrawal_credentials":"0xf6ce1e4554077fdf83b8ae116093cd9f3f24970609cd11342090d3f816b14a70","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x94c1b49cfe20e8babbf7fa80d5989fbe24118149ac9adfabb587eb6ee462b2f6f812b32fd29c1abbf52ad0801ea1c28b","withdrawal_credentials":"0xccb73f441241a418eaa80283cae2d9102d9771b21a981fd6ebbcd8b281118307","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8244460fdae46ef761855909e46c678b8386f473d146da67b2b0899c88053b12fbf6d2b540587e413a6bd5485d330d2d","withdrawal_credentials":"0xa6754b44d2a9e58e0023342c23d1b0762091738eae06ce6190ba5122cc4f14f2","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x89c7d432a62ab14608090ffa3b53ea83ab1bcc3b450ec2e93d8bc60779b88f1cec594b0ec28148af581cdf069511d950","withdrawal_credentials":"0x183c2844926f212cbfb49f3018062c4546a36dfaf4bac2bea2c1e6d3ea946032","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x86f0ee71fb95022911b594c7db22b94cd37bd1a70b1a36ebb452e7bdf02cb25d3805ad622fa28a623ad20ecb625302f4","withdrawal_credentials":"0xf2f9334452d862a2d52ed1d971f402ab399d6fd68729714a47bf5f4335d3f11c","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb9546c91cbd47bcfa488a983fd877aca4c8291f35064c6df05213232a4e5794f32a0dd52deb6d3c060fbcd823872340f","withdrawal_credentials":"0x65c01044129e9e3f94c03cde67297e795faf6942cddd65a759c6f4f454183e5d","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8cc8d50ab70030baadfc940c13e40a0f1e94a78cdc96c7e1006a596e69f9a4180649763c3c1c232b4b84d81c1beb01f9","withdrawal_credentials":"0x3e7e1c44d206e0b5a93a6e87c01755df52a96b1e604c1433fec36d649f56cf47","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x80419c71149761ff351d665bea6c7d874588e8c8a3462cc38d4059b700b65280591e10bf9f1b386c32a9f20ebfe7ae85","withdrawal_credentials":"0xb144f94392cc1b5369ccd98bb54cd0ad78bb658aa700099010cb0216bd9b1b88","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa9fc3471260f9b26aaec3c23ad10ce7b1397e412c3b2244fd28350d4a3600e9eb15bacfd9d96b27a0d3f6dd32f3249aa","withdrawal_credentials":"0x8b02054452355dc97e460b350e3ba7136bb567663a6fb71bb5c87b8508daac72","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa9208ba9a2194fe136236f55ba1386e75220d78b87f13c5c271840ffa732d1ba5ed1d61791eeab0b79b6a50ee0bd9640","withdrawal_credentials":"0x9aa69d441387afca96798ecc9055913fc9668192b50c93330faaa02edb030d5c","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x80c96133fbd52e79a7942109776cbb23bdac979244528e097f1e916a4d0b7463b4af2d7f4c6b06a820596d7c7688775b","withdrawal_credentials":"0x7464a944d3eff040acf3bf75e84368a5bc60836e487b41bfb3a7199e26429e46","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb65586852e5e24552200524b31eb54f3bf83782fc3afd6c1b45b30061ed98eb36dfb2414622cb3fecf0aa32680885f22","withdrawal_credentials":"0xe72a864493b52cde6b852b7ade78e373e2727dda8e2f361cc6aeae4f4487ea86","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x9923628ca9e4bf029de23f10ea12be7c68fcf0babb9b2e94b6d854bfc26488222271bb11d870f79e7fbc8d572e465096","withdrawal_credentials":"0xc0e89144531e6e5481ff5c233767bad9d56c7fb6229ee4a76aac27bf8fc57b71","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8d87ba1c7738f7b14b45562d993016c3aaff28d66c06006edd27e779404adf72ea01d5cf02752f07fba516a4020c6e02","withdrawal_credentials":"0x33af6e4413e4a9f14091c8272d9c35a8fb7e79226852d9047db3bc70ae0ac8b1","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x99cee98eb05f310aa7c0cf69a7adca06b50e927abd98f66a46db9aecd28bb159f81d18ef22b5512abe7ff7e6592dd416","withdrawal_credentials":"0x0d6d7a44d34ceb67560bfad0858a0c0eee787bfefbc0879021b135e0f948599c","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8a56d6d4a228b9a437aafbe1cd67630270694e0bc258ad06eeacebc2bb9f91896c77347f7b0fb9ee018c75ce48069df6","withdrawal_credentials":"0x7f33574492122705159d65d57bbf87dc148b756a41757ced34b8ca91178ea5dc","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x89b56335a0f6072a50c7f4c2a7f6c13375c0539ec6e96e589ce6f092101ca469d5c68dbc609deb6c6720cfc3ca1c1211","withdrawal_credentials":"0x59f16244537b687b2b17977ed4ad5e4207857746d4e32a79d8b5430162cc36c7","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x82e63946d7ecd5b029e583d716980121ac053036c8e2539c54590fd093b8a199125ca81e05437e2f32d9ba615e782e14","withdrawal_credentials":"0xe2e1d58f9895b65d8f9384b1123e78a8b8a62aff6d6c0709a38fb94de115840e","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb85ace936ff7c586f535dd9d099a9912156fa573e68c15cb4e59119735c4f2e217ad50be7432d0ad07d9ef0ce922748f","withdrawal_credentials":"0xbc9fe18f58fef7d3a40db65a6a2c4f0eaba02cdb00dbb594478d32bd2d5415f9","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa85181d81a61491234a89ce78b38a32a65a30883676c02327d51f37eccac79b09b159d77e3a8c357c613a42c34c476d8","withdrawal_credentials":"0x2f66be8f18c43371649f215f6061cadcd1b22647468faaf15a94c76e4b996139","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x954c039820868bcf0462ce5f03f7b1b580f6a1d3a6b11e563a111b99e1b6054cd85c0a2a8bee9aefd2662ce57389c26e","withdrawal_credentials":"0x0924ca8fd82c75e779195308b94fa142c4ac2823dafd587dfe9140de96d7f223","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x92fa07603f121755a03f501e681c7925c4d7ac722677a7afc30ac3ca17edc591a3556a07c3389454b6395655410b0851","withdrawal_credentials":"0x7beaa68f98f2b08439abbe0caf841c11eabe228f20b24dda1199d58fb51c3f64","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x924bcf588ccd2cc807ebc2a13be45d1d823189083c7ceba599dec6c4efc2fe584f2feb773acc6ea29023986b0c878c3c","withdrawal_credentials":"0x55a8b28f585bf2fa4e25f0b50873f376ddb8246bb320fc65b6964eff005bd04e","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x87bbe1851c1c76dff5724ff9ea4991eb18cd973368e2fffc0a8f96a989dba8b3ba2364f472ee3ae5efa88cffdf0dcff3","withdrawal_credentials":"0xc86e8f8f18212e980db75bbafda76e4503cb1ed7f9d4f0c2c89de3b01ea01c8f","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8fd60c26c770f756f5755e24dd842815bec4d2a4d5972bed81f619d65f5c438b55d0815a51fb7ac29103ca30d56d3f12","withdrawal_credentials":"0xa12c9b8fd8896f0e23318d63569645abf6c420b38d439f4e6d9b5c2069dead79","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb9d761f4aae30c40a134536e82fe10a005776769a9aafa8828d84a2f6e2108324d3fc4b9dba8ff9389ee58fe7a891de1","withdrawal_credentials":"0xb1d0339099dbc10f3b6410fbd8b02fd754763adf08e17a66c77c81c93b080e63","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8f8a44d7b8bf1a9c4b0da59fd1c5b81fcd7f4bb65f74f5c15070896d801adade1afa3057e4446fc4485c95d8bba45322","withdrawal_credentials":"0x8b8e3f905944038650de41a4309f063d47703cbb9b4f29f26b7afa3887469f4d","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xaea0272cf434061757f99e10bf69a3d360582f9e017bccd33004f4171480da267ccbe05e2bab415fc721cbe05331ac70","withdrawal_credentials":"0xfd541c90190a3f231070ada826d4810b6d823627e1031e4f7e818feaa58beb8d","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x9352921ea86b4fcafb31353d6f6ec851f016bfd040261c0d25ed31513dd96f90db5aec8b62b4f01de27c844e5f938fd3","withdrawal_credentials":"0xd7122890d972809925eade517fc25871607c38037472ccda227f085af0c97c78","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa90d76c381296c7771550ec8802afdcd871323230b5fa6293372c211f13ecf26bea3529c6f3961efa6bd9f14f71ea78f","withdrawal_credentials":"0x4ad904909938bc36e57b4a5675f7d33f868e326fba26c13735869d0b0e0fc9b8","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x90426a54b52002ce7dedc53271685fac6fd34fc9f2ada48b0e973cfb70c1bfc669f8edb600fdc09a829dbb64754f70ee","withdrawal_credentials":"0x2397109059a1fdacfaf57bffcde5aaa57988344b4e956fc3d983167b5a4d5aa3","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb04eaf02e2c89a51c4a85719508e42e156e4b007be028a32c4b82f07a2caf480c200d239925858a9b1b06fe2ffe194c0","withdrawal_credentials":"0x965ded8f1967394aba87e703c31a26749f9a2eb794496420ec8aab2c7892a6e3","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x92d58fc2e15dabb9856d510362e29e3005eaf5afdaa6d73167910088cde285df049e183e7a073948228a32a7bcef4157","withdrawal_credentials":"0x701bf98fd9cf7ac0cf0119ad1c09fdd99294309327b812ac9088249cc3d037ce","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb2504cc3cfc396fd5d1c8bd0fb28abdb664cefce90c0e215fed809e0e003db8a213316794641974d8b41fb2e4e8a8e71","withdrawal_credentials":"0x46041a8f9709a0f936f26c1e8658094b80070b3f3883204e5cb529562e317065","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8fd5bfb6f3fc8289b2b96f61e85314fff9451620ff76e02ecd1f1e18f85a1d28d7d372757c5f62651e5ccc8747e88e9a","withdrawal_credentials":"0x1fc2258f5772e16f4c6c9ec7df46e0b073010d1bcbf1ced900b3a2c5796f0150","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa6257c4d665a74781c6474bbbd9e3654816800d9e620d6599a9d07d90ecc25b30bc2162406a110b04fb0287170b22bbc","withdrawal_credentials":"0x9288028f17381d0d0bfe09ccd47b5b7f9913078711a6c33613ba377797b44d90","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x9816d5dfe480e7407fa48799e97613b36b7e3f4ea40409d459afe79289f0865b489047923236c33de8d6fa5064e21012","withdrawal_credentials":"0x6c460e8fd7a05e8321783b752d6a32e58c0d0963a51472c2b7b7b0e6e2f2de7a","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x85af0debd8150ab283be02193d85ec6cc5bf83d5150dffa39a373e143166f556d84d80bb1639d3e9eae8f77d32607f3e","withdrawal_credentials":"0xde0ceb8e97669a20e009a779239fadb3b21f03cfebc8661fcabe459801382bbb","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa582b36ff4fdd89b42b41257e74f4ebef541d58eb26ec16690cea2186ad86b636fcf7b152cff1cb937ebb5dec4c0b41f","withdrawal_credentials":"0xb8caf68e57cfdb96f583d8227c8d8419a51905ab7e3715ab6ebcbe074c76bca5","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa9eace0075c4fd875cd34d1d33b70388239c8d2fb261d7f7de5410290ade122beb97e55eff954d6dcb34810dd689f309","withdrawal_credentials":"0x2b91d38e17951734b515442771c2ffe7cb2bff16c4eb090881c353b96abb08e6","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb8402ce87952bdd62fe35a001d5e6eeec1589ce7b17b533a549bc8ea0c623bc90b307a517c55b0b378d9a477c8bfaea3","withdrawal_credentials":"0x054fdf8ed7fd58aaca8f75d0cab0d64dbe2501f3585ab89325c1cc28b5f999d0","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb118ece6890d73c69e078778e485a36ec4c46c13835cbb0851e91203d23e92796a6d3db24576f30416ab1e821faf404f","withdrawal_credentials":"0x14f3778f984fababe2c2f8674ccbc0791cd71a1fd3f793ab7fa2f1d18823fab9","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb5e5eea094bd1d47e8af58b0cf0923cec826c0273af1d70bd13c61bf1018314c962786640e23b4b99a4ca97c1e3b2fc5","withdrawal_credentials":"0xeeb0838f58b8ec21f83c2a11a5b997df0fd11cfb6666423724a06a41d3618ba4","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x98e1a9f686747193e5c4c2ef173376d7fa6eba245a6be60e1f03a4b8602ca44fa9c1854dfb74168650bef2ea472a71cc","withdrawal_credentials":"0x6077608f187e28bfb7ce95159aee12ae35e31667ac1a379436a7fff2f1a6d7e4","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa670ca0acad87fd703652fd6b5637ea08f0574ea796624bd53506ebc2987e74aad2ce81ad8944a00ea65e2c012a8ddcf","withdrawal_credentials":"0x3a356c8fd8e66935cd48c7bef3dce91328dd18433f89e51fdba478623ce568cf","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x967b31c6012734f4e06ec9c0213237fdf20c6f7a78d9cbbec2f7dbcfa02494f0176fad563f70226fdfa1c7e093fcc2b2","withdrawal_credentials":"0xadfb488f97aca5d28cda32c3e91165e24eef12af853dda7cedab0d145b2ab50f","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8c8669dd614a7d7e1be27c78d93f74445cd05ebffc97d6140770f324aac71e7600f24c07eff9671f844b33f03c57afc3","withdrawal_credentials":"0x87b9548f5715e748a254646c42003c4841e9148b19ac880892a98683a66846fa","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa7eea08884d0e81c6c4d044b6a5c624432fcbff44af67d95c889140a51b033e14adc747f85773b375d9d93f864728d59","withdrawal_credentials":"0xf97f318f17db22e661e6cf703735b71667fb0ef75f607d65a4b01b35c4ad923a","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"}],"balances":["10316516445055493815","10321473899000513495","10319821411488862071","10258679506701745558","10257027023485061430","10261984477430081110","10260331994213396982","10252069569540041750","10250417086323357622","10255374540268377302","10253722057051693174","10245459636673305237","10243807153456621109","10248764603106673494","10247112124184956661","10238849699511601429","10237197216294917301","10242154670239936981","10240502182728285557","10285119251053593494","10283466763541942070","10288424217486961750","10286771734270277622","10278509318186856982","10276856830675205558","10281814280325257942","10280161801403541110","10271899381025153174","10270246893513501750","10275204347458521430","10273551864241837302","10265289439568482070","10263636960646765238","10268594410296817622","10266941927080133494","10205800022293016980","10204147539076332852","10209104988726385237","10207452505509701108","10199190085131313172","10197537601914629044","10202495051564681428","10200842568347997300","10192580152264576660","10190927664752925236","10195885118697944916","10194232635481260788","10185970215102872852","10184317727591221428","10189275181536241108","10187622698319556980","10232239762349897621","10230587283428180789","10235544733078233173","10233892245566581749","10225629829483161109","10223977346266476981","10228934800211496661","10227282312699845237","10219019892321457301","10217367409104773173","10222324858754825557","10220672375538141429","10212409959454720789","10210757476238036661","10215714921593121749","10214062442671404917","10575956426039018910","10574303942822334782","10579261392472387166","10577608909255703038","10569346488877315101","10567694005660630973","10572651459605650653","10570998972093999229","10562736551715611293","10561084072793894461","10566041518148979549","10564389034932295421","10556126618848874781","10554474135632190653","10559431585282243037","10557779102065558909","10602396166095899550","10600743682879215422","10605701136824235102","10604048653607550974","10595786228934195742","10594133750012478910","10599091199662531294","10597438716445847166","10589176296067459230","10587523812850775102","10592481266795794782","10590828779284143358","10582566358905755422","10580913875689071294","10585871329634090974","10584218842122439550","10523076937335323036"],"randao_mixes":["0xcc9b03923c85d9ce8eba32968977d98d668788d1c2f0e4f3a79facfcd8247794","0x933815925ca23b00aef1fc130edd9b26547e8b1b9f966ac51e1ce2a3480251f4","0xa6590f92fced1a45a334643fe265b0f35a818aad565f937f4b9d256c2363087f","0x05fff1911c68779d6d836818041217f579908587e54a5f223023775567479d34","0x1820ec91bcb356e263c6cf43d89a2bc27f9384199c1388dc5ea4ba1d41a854bf","0xdfbcfd91dcd0b81383fd99c15d00ee5a6d8a876379b90daed520f0c4b2852e1f","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000"],"slashings":["10518119487685270652","10509857067306882716","10508204584090198588","10513162033740250972","10511509554818534140","10503247130145178908","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0"],"previous_epoch_attestations":[{"aggregation_bits":"0xc13b057eebd0a20e77f0053ea01fb1035e29af5216f98ff11b7f25cf8046cb34ed31c1f6761b16d7afe0029f71a90db7afde04463f6d20229d7903c6e6552eaf91586219e79c006152c6cf537d5937a0fa86f4ce31b9204428b56ebf687be3c696964bcb53ac3724029e0c429ce7beb83445c1e4193aceb7a4ea95f8ec0c0560f26c46e10de9274bbeb11ff74e57d7a4bc836e04bae7f3d2263b46cd5d411629ef6c3b1739722b7b853d5acd9ac82c762a572be5c33887f34b0c15c5c85e6658b064b653507e8a0ef2dae6b6d670e493ebd1314844334bb3481ec4e1d6b1554c56fc1240daa19fbefd61072f78697e32ff5e0c5854017157c7057a7e13c4547a01","data":{"slot":"10541254261308783037","index":"10546211710958835421","beacon_block_root":"0xc1cc55927d62a30a24118d36f6fbb9560f5d96d5caf6a9c5268ffb08e6d86ffe","source":{"epoch":"226586384","root":"0x339332923d28dfa7e4a2f83aec303525346f904110ab9e22399690ba051ebc3e"},"target":{"epoch":"226971133","root":"0x0d513e92fd90201ef91c2ae4451f0c8b2869921da3194daedd93092a505c4d29"}},"inclusion_delay":"10529686874497026844","proposer_index":"10528034391280342716"},{"aggregation_bits":"0xfbc0f5ce1d02b16516ceb65c28a28d3f85a033dcb5791d1efedc4b0f0381c4a42e75e98800df99f790b9c2b76f9df472256e936684eeb05ce0f36ad995b4677aef38cfc9fce2a960cff495667e06a9190c9e1fe8e4b04a487e0e2f53916e44f02a3198fbdcc92ae15fa71cc9c45fa7e4e8925070cab533cede7b7c70fce4f6b5e789bab7f051d1dc0a422d56047959026c581b6a8177588c94ecec2c4dcad39048aebe7316774f4eb92640abf0176178856d1e5be75508d1217b16684b300237472d2b9f4a5a44aba75b1d679720e7bc6a5b5134eb2db358a51d141fce8980b4663230507371f9014293afb7debde3af1135fe419c3e6d9d1c6e0fe4cbae068801","data":{"slot":"10531339357713710972","index":"10470197452926594459","beacon_block_root":"0x2fbe47913bf9c26a35191b03fd916a302ee868118d07fe385fc51c05244063eb","source":{"epoch":"219276155","root":"0x097c5391fb6104e14b934cac5680419622e26aed2176acc404c395746f7ef4d5"},"target":{"epoch":"218121908","root":"0x7c423091bb27407e0a25b8b04cb5bc6447f46459672aa12117ca2a268dc34016"}},"inclusion_delay":"10466892482198258907","proposer_index":"10465239998981574779"},{"aggregation_bits":"0x895a64ccc2677a9055191cb998f76d84e62f6e2bb76e02ce1b8d1310e62f567c090dfd47d0851ffad9d504a4de88e7aff4ed4c8044912acb082070dbe57086f3b289c0f1371e2f92f9c96beebd5e4db7b48fccd0b8b1dcd4733ce40cb5590dd8d0c5a5fc75004b2e049e58b1054e6a770f26d8da3d8cfb946e9da02b77c8e60e43f033059cd511bdf67f3857a581eb8300e927af13a270fab524c871771913097cc07431875b3d7b2b341554b1e77be872c272e8399fa25e416fa1c2e2985c68f7dcdf5d5c4488b659c4258ed72ccaea3c70b8b403b17d68957d6190d80170424058a42a3a12e2e404efeb05363ac9dbe03d718fb8eee6414ed85716693269bf01","data":{"slot":"10455325095386502715","index":"10460282549331522395","beacon_block_root":"0xa2842491fbbefe07f4aa8607f3c6e5fe54fa627dd3bbf29572ccb1b64285af2b","source":{"epoch":"216582912","root":"0x144b0191ba843aa5b43cf20be9fb60cd790c5de91a70e7f285d3466860cafb6b"},"target":{"epoch":"216967661","root":"0xee080d917bed7b1bc9b623b541ea37336d065fc5adde957e29d1bfd7ab088d56"}},"inclusion_delay":"10496637192983475100","proposer_index":"10494984714061758268"},{"aggregation_bits":"0x8d57e4f001bd2a836a064b3f73dd152eb2083292d10d92d947bd2b28a8eaf86560e7ecedb63fef3e3f0e90623dfb142959cec7219ef449450bec0c7133dae48b513450bae190ea3ec196d194a3e83d4161ce9d216ad8dd3a3656eccf652f74e7657d5a6d2a2b5f93b462f74e39f9d777831d0dfcc9d7a699908a55e1cd48b4440730847db571f77dd121ab69526c55f45632128ca1c3d7ba6f28522d625580b90f112ca0a6f6b5c772987115606ea6a92024a771b8d922e592ecb5d7421343b5ea61d839abc5e208c1aa26c5068e957c5b6c95d31453f480490325c11fa5239425c93ee00e70cffad3441899baed5c1497a158a1f02240308b27cde3e0757b2301","data":{"slot":"10498289676200159228","index":"10490027260116738587","beacon_block_root":"0x4a318e91bb6d4b30b6f543fa12287493e3c37439019f147f3ab7f2a1e7b5ca6a","source":{"epoch":"221584648","root":"0x24ef99917bd68ca6cc6f75a36a164bf9d7bd7615950dc30adfb46b1132f45b55"},"target":{"epoch":"220430401","root":"0x96b576913b9cc8438b01e1a7604bc6c7fccf7081dbc1b767f1bb00c35139a895"}},"inclusion_delay":"10486722293683370331","proposer_index":"10485069806171718907"},{"aggregation_bits":"0x213b9e54dd8aaee5a2bacbec930cd5ff31458541408fe4422cd8a5664903ff344ffdc6ab3822055bce1185b6d787836ece3bff24c056bb08e5b87c2ab3382de812fc2b5b66d6fb0c13a69207d73d81b7e7996165029c364a14d4784fff1d8e122200ec558ca23ffe6894cbbb868adcf918e9a0430e8c11b36851607589b7a39682363b7dd559b2d93acceabdffd4a52c5b1f2be0be8cbf7020390ce69fc9b08da5ea6fc6806e4460b19a925d6bece0d8738581255df831f56caf9efd1d213a6e2ce7538a4264d1538f5439765ba2fa4bc6f11bc71b33fc161072b98d0f97efaf0040537d5593a882020e43aef7cf45ab0151aa44f0613ac959a4f2bf6cc9751b01","data":{"slot":"10475154906871614139","index":"10480112352226699227","beacon_block_root":"0xbdf76a917b3387cd7687affe075def6109d66ea5475309dc4dbe875305fb16ab","source":{"epoch":"212735423","root":"0x92e08b903a6dac06dc77037071acfbd2f6484951581e177e18eb8c0d705b4f42"},"target":{"epoch":"213120172","root":"0x6c9e9790fad5ed7cf2f13419ca9ad238ea424b2dec8cc509bde8057dbb99e02c"}},"inclusion_delay":"10410708031356162073","proposer_index":"10409055548139477945"},{"aggregation_bits":"0xddd595431d0af31b61ea10b20de18776036aeba5ffa89ea53f751ff1cee785757cd3425f05b16691595a874d1e507fc75cf5cfa3d10d9dfe8eab23f990e7488f506dd260338a4dad5aa077212ffb4b3b494cb07fd331729ee4ce737402dcfbf9ee2b67c24426608db34a9027e3440c87fc741090677d8f0f50f8422a24d9b73a56e271cf640dd597b0bd8e6afeaa4dd6ea443aa20b426e9a6e5fccd3551469d50f1d629648ade6cfecc934acfb6f399ac49156c8222e066f38aec1d2a97ddcdb0f821d5ea9d7d89288db57f547cbed8c6d6d5f4d3ae9663a14a888be217546c8736fea1cae83bbe8b6d2d497d5aeff71c039d3395853bd6448ba081b9e0254b701","data":{"slot":"10412360514572846202","index":"10404098094194458265","beacon_block_root":"0x2be95c9039caa62d868f3dcb0ef39f3b286141e10b645d4f86f4a84f43620a98","source":{"epoch":"211581177","root":"0x05a76890f932e8a39c096f7467e176a11c5b43bd9ed20bdb2bf221bf8ea09b82"},"target":{"epoch":"210426930","root":"0x786d4590b9f823415b9bda785d16f26f416d3d29e58600383df9b670ace5e7c2"}},"inclusion_delay":"10400793127761090009","proposer_index":"10399140640249438585"},{"aggregation_bits":"0x55ac8db6c3e77f41740ad6dfe9eb29fb1061d50ca4fff68497b8dec6ecaceef5837bcaf6c1da6f5439a6456326b3c237b402a7d3fbe109273c26708613e2af9da43196bd3e82831b0ddbdc104ed7756381c142db8ffae1165fd005c383ec8e89f95ea8f7fe401e9ce3d905de6976ce695943d9e609ec94c626b1c4c4380f812762cf20fd90e1852c36a5fda321c7cad2615f72558e5a550a81c957f6bbdea72af3fdb41d23f1b8f97339f372fc092a29bece580e07e10ad118b96c4215902a8d42a3e0cca233762288477e884a582a563e683021f10591ca905a995376a94dae5b997d05d8589e7fa518a13fb7bf2751a9b508605c816d7cdbfd12382814519001","data":{"slot":"10442105225358062394","index":"10447062675008114778","beacon_block_root":"0x3b8df590fa1bf92e9ec2c062900d8a6786125b0d86013967e0d5cdf8158c6a81","source":{"epoch":"215043917","root":"0xad53d290bae134cc5e542c6786420536ab245579ccb52dc4f3dc62aa33d1b6c1"},"target":{"epoch":"215428666","root":"0x8711de907a4a764273ce5d10de30dc9b9f1e57556024dc4f97dadb197e0f48ac"}},"inclusion_delay":"10430537834251338906","proposer_index":"10428885355329622074"},{"aggregation_bits":"0x05366eea76f3627e9ead05ed4064b5c515604bc9074a446b787ca94ec04fe9ed263ddbb35f9ef4786eff150b11d13252722b340740f3d86b22171218c4972794d2403b38205a3a9210f1ee4945c88fd0f2d82988d8b7220409a8702c28b9f12b95e47be3f1a5474dda686455328aedb9a6d368d1fa6141bade74ad7cbab6f524d76abca76f9576fb3e165ca26af9037edb8217f334e43818b2209c6aa9d5625dd2773db049cc9ede4636b30cb0f76f8721f245f5c6cd95f8fd3ee6ed9cea2ae130dc13a1b7d7bf66de4ba9850f08a1b9a7ec36380e0f65659dad74adb7938d352b7759172350358c1c335034565af60d67dfc2fa9cfc59a819d86d0af5fe570601","data":{"slot":"10432190321762990330","index":"10423927901384602394","beacon_block_root":"0x465ca390ba3e2ff3086c66c22389a99edd3c4d097ffb739561e67eec06d87117","source":{"epoch":"213889670","root":"0x201aaf907aa770691de6976b7b778004d1364fe5126a222105e4f75b51160302"},"target":{"epoch":"255827300","root":"0xdcefae9543414ac349e1a87544f303617ea32692cb7e679a0ce37bd25b9cdae1"}},"inclusion_delay":"10790779338697236067","proposer_index":"10789126855480551939"},{"aggregation_bits":"0xaf4365f0f77f9dc05312c66c10b5d8bb38f21c4f412dbf2df45aef7cb76d4303d65003cd8f6e0b06cbb9a12f02c198e2dd6c7b0c902e28dc5e26f55d6cfbb7c4b45660676be47b2fe3ccd4ce9a0d11c5e674b2a8a1d59f5b9214067ba24f02110840eef06002456e162eb207e1d0033153e46a58aa1c7133bce88905268fe089ae20101497bab8d84f415eb4467cfaa36b97bab11a1b7d3f070b7e77aa7396f66149afc2d5083a1e188fd5e71419b009bc96592f29ea74ab56aab53304d7999a605157d0e491db97daf6167f629567b1c39bfc520a71e79f06745e110d12698dbf07165a0c2eacd0c82911e89c689b90f57f2ca5ffaff474b9c918f240ffa0dc01","data":{"slot":"10779211947590512579","index":"10784169401535532259","beacon_block_root":"0x0232a39583d8084d336777ccec042dfb8ba924b63810b90e67e50263105e49f7","source":{"epoch":"254288305","root":"0x75f87f95429e44eaf2f8e2d0e139a8c9b0bb1e227ec4ad6b7aec97142ea39537"},"target":{"epoch":"254673054","root":"0x4fb68b95020786600873147a3a287f2fa4b520fe11335cf71eea108479e12622"}},"inclusion_delay":"10767644560778756386","proposer_index":"10765992077562072258"},{"aggregation_bits":"0xdd1982ad734484ab7934d17899984cbc74fd0045e7cc2b4a42a09da72092e46a55d29ef179af00eee680b147083d49a70c90cd3d28d6b9f16593ad538b4adf5dce3bc7a5215af3395a7b8b9ed13a8354a16cd23f649c955b0a645d978b12bf35642e70c8bfe758ab2bae41c639681f4959bd73ccfb930c0bcefd68b36e1488c23909a41e260a4a1f7768efbb6d067730bbeadb13240f51ad2492f4cf22f8d98a70c0750cde1fbe36fe4eb1a1ee66c7270f8f57d099e0f9083d2d1b9a023109f1322fe4cd6ed443f287fbdbfe6dc96c0e841fd03461691e7e0a33307f813b751117c1367cfce74f03f95258e228c40068aa11ebb77791003fb9a0a2f59e8de0ba01","data":{"slot":"10769297048290407810","index":"10813914112320748451","beacon_block_root":"0xaade0c9643875575f5b134bf0a66bb8f1a73367266f3daf72fd0434eb58e6436","source":{"epoch":"259290040","root":"0x849c189603f096eb0a2c6668635492f50e6d384ef9618983d4cdbcbd00cdf520"},"target":{"epoch":"258135794","root":"0xf762f595c3b5d288cabdd16c59890dc4337f32ba3f167ee0e6d4516f1e124261"}},"inclusion_delay":"10810609145887380195","proposer_index":"10808956662670696067"},{"aggregation_bits":"0x452abf40a90c43f5acf411357174e8406ec937f4ac094533c0cd17903241edfe8ff81a38c3dcd5aaad34336d014cd573b3fb298d107b6907f73efc98339a9cdbbcf288b9fcdc0dc789860b00603667adbd5131471e539fc10350f128d22698cffaffefdddd992c9e7a75843e321ce59fbc831bbcb532bb163a346c4bf8daa6f51de5d5449ac61bb781721e6eda2db52416d1cef6f5973b118b36ffea0c323a7f00223337d479456db3675e3f5f7ab91c5ff1f132cc0bd50c9f96e64ce5545ff03b0e1a0f6bb196538f66eae1a81407c87b5215530ad3e409021827bab8fdcb62cf1f6103dbed46c0daf89d535b85976c1b1f756a176342b5e6a5bde3459abdb401","data":{"slot":"10799041754780656707","index":"10803999208725676387","beacon_block_root":"0x1da5e995034d9112b443a0c3009b365e408530deaca7cf5442d7d8ffd3d3b076","source":{"epoch":"256596798","root":"0x906bc695c312cdaf74d50bc8f6cfb12c65972a4af25bc4b155de6db1f118fdb6"},"target":{"epoch":"256981547","root":"0x6929d295837b0e26894f3d714fbe889259912c2685ca723df9dbe6203d578ea1"}},"inclusion_delay":"10734594883560171937","proposer_index":"10732942400343487809"},{"aggregation_bits":"0xeb8e995f3d04154367e5c8fbe3bbb4f574f1511a07eaaf34f561f711ada4e41a9b869e55cf4672e70bf4f1dc42133b7c701db8ae61e36bd31fafabff3d455dbc70e250c0bd649b26c091ee088cb027201d34c36d43de0b25c67a8c3b727bef260a5074441d0165d3e6f34da054d62ef95d1f2f6cdce1884c809c6c0f5f0fb2d1cb9082ceaf32786a8957cc89fb1348d6040a81b5a07bda1fd7506edf0e4fa42652b4bf634d3f68a26d33b03fee9564d6f3f5ecd3d82ef19cce2bb127a8199c071a6d55b31313bf13cbaad524f4771115b5a618591a137ea7a6069d2844367b116e3a587038fcd5ce7e002aee5c9c3d56962349579fc44301ffea6253b3dc991001","data":{"slot":"10736247366776856066","index":"10727984950693435425","beacon_block_root":"0x8c96db94c1e3b072c54b2e900731e7375f10031a70b823c87b0dfafb113ba463","source":{"epoch":"249286569","root":"0x6554e794814cf2e8dac55f39601fbe9d530a05f60327d253200b736b5c79354e"},"target":{"epoch":"248132322","root":"0xd81ac49441122e869a57cb3d5654396c781cff6149dbc6b03212081d7abe818e"}},"inclusion_delay":"10724679979965099873","proposer_index":"10723027496748415745"},{"aggregation_bits":"0x2df2ea7a81b89729a55869bc2328fce686cf64d8d32aeb96dab9204f5fa472b275dc249a41525c80b90e6643b4efae8bf6db216d6d43d17777d98bdca4f6b447a73e2231ae86822632a98c9b580183666b5305e583bbe25538ea389bed6553d57d2d936eba0455906855754463a02156b1ca83779b2a2e00f0d369dc435b01ab5c4a25ce0032390de0fe097d36fba1ebfea6a9c95f9c9029581b1304f1dbbe139e88e6f34b92216f31e314757505dea79545f90e376cc02cb078920bcd2261c0ddfdd61c7ec3d4c9cf1461bbe84138262ebad6dbd433e2b24e7a999f01258f3e09b7f5e93ade1a86666cc05f1144201dbbd59a289bc6bd6b6c6a487b0ff8a1a901","data":{"slot":"10713112588858376385","index":"10718070042803396065","beacon_block_root":"0xfe5cb89481a9ec0f84dd9994fd6562068522fd85b66c18258e148fad2f80f0a3","source":{"epoch":"252749309","root":"0x0e01519542fb3e119c101d2c7e804c32e2d316b2310af43ce8f5b35601aa508d"},"target":{"epoch":"253134058","root":"0xe7be5c9502648087b28a4ed5d76e2398d6cd188ec478a2c88cf32cc64ce8e177"}},"inclusion_delay":"10754424690750316066","proposer_index":"10752772207533631938"},{"aggregation_bits":"0x292f4bf64ae18b6298276fbee03604ceeaeee974f2cffdb89e1d082b128d44e3ea0225a00760a4633df3b188709e5ebd5ecba24ef5aeba507013a43e655956b74492b2baa852e0392ad89746f696e782a6125828ccd2622b2780b27b39726de44d953ccb84b74523ca891ee2971288970a9857f767d34219069788d1e35af7cf0833f796a2bafd1f87a48e51a94213fe346cb5d94df43d4980276be2d6bfacabe3ffe4c059debbd3e64b37ad859a16e5cf967dae56cc611f4c7196186fad7a0da7d3d86e9c32fcef1e3aa9ca38b758a24e0772240fb17be9c70540bf4881bdb83c2aeb634f2d0b8c5841bbcddb50a0f27bc198d6ffcb8f04aa8867eedcab8ea501","data":{"slot":"10756077173967000194","index":"10747814753588612258","beacon_block_root":"0xa609229542583938462857871cc7f09a14ec0e42e44f3a0e56ffcf98d4b00be3","source":{"epoch":"251595062","root":"0x80c72d9502c17aae5ca2883074b5c70008e6101e77bee899fbfc48081fef9ccd"},"target":{"epoch":"250440816","root":"0xf38d0a95c286b64b1b34f4346aea42cf2df80a8abd72ddf60d04deb93e34e90d"}},"inclusion_delay":"10744509791450211298","proposer_index":"10742857303938559874"},{"aggregation_bits":"0x0b67f1c19d8c1e87dbf0351fdc962141a70b2c05f31cee6873fc486cfb876ecabc5a715e94eb1e8d555d36dc11cb6ec38a50f8c814d320c73c64b33c155436aa112394d2f2f1fa113cd7e5c9d5cb130a9c2384949cb7770ce9b0ed571d8d1f46966117cc41f464baa38c9aba14c073747d64fb5e8ad8ab5316b3dd89ea646772efeb160c8bba9afc6b991b510afa3295e06c752a6fa2199b81ddcd15dccc0531bfb02e10cb53fde4f61b255a627afdf47c1d02ad2926fb88066631b6f71bb41633a42dce1e1d037a80e7b903f9bfccf6162e97baf745216fb66d11895c28251f1940ff5c56d7244d4f75f463559cce32c213189cf92bd65dbc3c2a1c7b2ff92301","data":{"slot":"10680062911639791936","index":"10685020365584811616","beacon_block_root":"0x7cf2429400925e71ad18abf88516fd0b025fe9edf51a48b0212cd5523e11447a","source":{"epoch":"242745838","root":"0xefb81f94c0579a0e6caa16fd7b4b78da2771e3593bcf3c0d34336a045d5690ba"},"target":{"epoch":"243130586","root":"0xc9762b9480c0db84822448a6d4394f401b6be535ce3deb98d830e373a89421a5"}},"inclusion_delay":"10668495524828035744","proposer_index":"10666843041611351616"},{"aggregation_bits":"0x79dc1ae55e5e5ea992cb3129d46a954472e8b84115dc379386403eecf76081ab1c18d908a6af0549598576b63635974753fceeccbedbb0fae554d3f2d2613e7b61403050f80b410981f432d4c6b58191da1b744e58fa5d1a7d083aedf691a2ea9ac2c1d0d3037c0d97add89bcdbc4e0435b24a094b5f5e6eecf6198e389d50a1b9caa3427986e9a34b7abbc24794b79e083f14c2b0bca6c9835083f4c4c760812c55fe77e4272cd7400c74242e8d89f893221c9aa82b642269b9621fc5eb4473c0e8b2f281598e3fda67224070e727c879a6f3aae04f5952fa2bfcfcec01f1e479867d19ac9e47eaf04fff63f390169fd859e30e31391c1a2915d017a6cdb03301","data":{"slot":"10670148008044719872","index":"10661885587666331936","beacon_block_root":"0x88c1f093c0b4943516c2505818921c435989dbe9ee1483dea23c8646305d4b10","source":{"epoch":"241591591","root":"0x617ffc93801dd6ab2c3c82017180f3a84d83ddc58183316a473affb57b9bdcfa"},"target":{"epoch":"246593327","root":"0x71239594416f28ad446f0599f39addd4aa34f7f1fc200d82a11b245f4dc53ce4"}},"inclusion_delay":"10711460105641692257","proposer_index":"10709807626719975425"},{"aggregation_bits":"0xf10c2208026592e3342af24e5f0013b86801cfed961b4ce400047ed375abc63fc38a5083fdddaa0d7b72b49a1a158f13348e8a3cd837f512d5919a9c02f5198111777408abae8c2dd78b58273fa8be684717036263f65f874456bb177785919445b6de657174403a4fb229a6c78894cafaf3c35d7dea6164989f1dd7341966aded463354a50a3d883522ca9bd0ae6cb8910851674124dfdb04e68c8a204c8bb05cb334fdcad386ed6de4b2bb1df9bf65d97e42d2cdc9482ac1261c8938ae122d685be8f1953c6a93d67707fb373cc04ea6e57cceae6724207a58ed0c89c7c3b243f828468b0c6e29ce9c3090d2e2cad66bf5a95303a0dad0ca728f254ecaaf1e01","data":{"slot":"10699892718829936065","index":"10704850172774955745","beacon_block_root":"0x976589948106e7362ef5d3ef9aac066fb73af51569b25ef6fc1dabef0287abf9","source":{"epoch":"245054331","root":"0x0a2c669440cc22d4ee863ff490e1813ddc4cef81af6653530f2540a120ccf739"},"target":{"epoch":"245439080","root":"0xe3e971940135644a0301719de8cf58a3d046f15d42d501dfb322b9106b0a8924"}},"inclusion_delay":"10688325332018179872","proposer_index":"10686672848801495744"},{"aggregation_bits":"0x81bfc090bfbf83ac6957e66c55bb25f7a502b2ab50b9dc8b959e3a137a4c695266dc626dca1db5a5462066e41ff47ec67d225d7d6781a16f08c0fb12e39417204f1619f0e9195314e9fd9f9a3e9cc4b9a91fed93e5be3d05ba48ecbbb6d0a821780c8d754eb159ff3a32eb311870e898e2257ad81c459c2b6c2e366986e417fa7a4f8a0a742a6c2b45932998d9c0e93671d130855d1270c9362f474d4c574e0dbc3ba598e54291cdd2d4e77c3084da4be6459f04496ec5096ae13e28b270325a01fb1e878e78ebd707fbdcbaba654f71b32d9c8fd9ddd884933a85f751fe110b212ecb4e27078ffe770e7938f47c5b6b2d3bbae89b96e29e5e59752f93a5afcc01","data":{"slot":"10689977819529831296","index":"10628835910447747487","beacon_block_root":"0x06577b933f9d06973ffd61bca142b748d6c5c7512cc3b2693654cceb3fee9ee6","source":{"epoch":"237744102","root":"0xdf148793ff05480d54779365fa308eaecabfc92dc03161f5da51455b8b2c30d1"},"target":{"epoch":"236589855","root":"0x52db6393bfcb83aa1409ff69ef65097defd1c39906e65552ed58da0ca9717c11"}},"inclusion_delay":"10625530944014379231","proposer_index":"10623878460797695103"},{"aggregation_bits":"0xad277bbb7ae243fb2f86dccf2f5fc51ce00356d2713a46cbdc5d49189f62163b7f9476015ed202330f2cb794beb5651fe9bd83b8c3eed3f8c4976d1821d9f5cd80ad96c03fbb29fc6da2ff9172efe0bf118e5327ab5ca41217c773a410756e8806d132728f78792040962ecdb6b1593add99da239b666c734ad878008dda255390a123924d6e1b7adca6ec193a79689d2d6a34e8fb257d0a5ff5033e17cda7d4c8516f8a3269f3fdc7a5f5827df2505a0dcaa1a717be0f8e60e6688a12e82f41a92bce37888b1a00b504d653524978c3f305fd1311d124aaf652402d65178ffe07579eb45adca663f0003d9ed0b275b3ac3db6939c46014658bf6add3428700901","data":{"slot":"10613963552907655742","index":"10618921006852675423","beacon_block_root":"0x781d5893ff624234fe8ecdc097773217fcd7c1bd7277a7c6485b619d5e33eb26","source":{"epoch":"235050860","root":"0xebe33493be287ed1be2039c58cacade521eabb29b92b9c235b62f64e7c783767"},"target":{"epoch":"235435608","root":"0xc5a140937e91bf47d39a6a6ee59a844b15e4bd054c9a4aafff5f6fbec7b6c851"}},"inclusion_delay":"10655275654799595424","proposer_index":"10653623171582911295"},{"aggregation_bits":"0xa52ac334c11b0a68135db44dbc07fd360426136632dcd8e95cfd57b21f2f2122ba404b9b3aecf3ecabe7277b5ee6be99019f019f08b3967f521ad5bef47ad7f1f2d986037d236b03f6ffe758a45ee00998566ac8b095ba785035b9f782b191b3b13ae1d7ee57408ffd6a867b43b7f95a618306718d171c7c26faf8d9b61875299db4a10c75b2df1abbf45ea5c792dec8cb93496271455b3bceed975e20401d60bb4e674f8ddd28513809d652e773513a4bbd26720c6cec1d3827589f9a6122d87536ae51772970a6672b1528a79b87e583b85978b8b7bdd8ff05052d68f3b12876cf94c4df1c7b2552b90e001036d2590da18a2d654baa231e9415a8e7fb8f0601","data":{"slot":"10656928138016279552","index":"10648665717637891615","beacon_block_root":"0x20cac193bf118f5cc0d98ab3b5d8c0ab8ba1d379a05ac9af1046a28803640666","source":{"epoch":"240052595","root":"0xfa87cd937f7ad0d2d653bc5c0ec797117f9bd55534c9773bb5431bf84ea29750"},"target":{"epoch":"238898349","root":"0x6d4eaa933f400c7095e5276104fc12e0a4adcfc17a7d6c98c74ab0a96ce7e390"}},"inclusion_delay":"10645360746909556063","proposer_index":"10643708267987839231"},{"aggregation_bits":"0x254ea956740f9888d4721b9cce953727763896bfa04ddc5e9723b5ec395fbe8744104d7cb6f0d9cac88127d5a83f2bce166b594d2319c62b2f4ae4d8fd89789080f1eccf6e453e43042f14fb7a268cd74a38c24870d045c8ca870d97db156e51f40f1bfd2a7a48e0298d9adf71f5f6958a7ea2da587cb656c705b72e73cf7acf912c0eca63ba981ed01dfe51082b37b014bc402e548bbb4948e04283bb4c2f5c01fb04652b4d885a4d6b723abef3524b98a520faf34e5d3de6b6f6bde17acb5baa30266887e25fe9e79488bb9e8d7ed25ee4936c345321c53675182431e04c11775728fb891fee5c58d1f53dc566e90f195faf794449f5ca0dd72fe473d6277f01","data":{"slot":"10633793360097799871","index":"10638750814042819551","beacon_block_root":"0x93909e937fd7caf97f6bf6b7ab0d3c7ab1b3cde5e60ebe0c234d373a21a952a6","source":{"epoch":"280451230","root":"0x4f669e984871a453ab6607c27489bfd65f20a5929f230386294cbbb02b2f2a86"},"target":{"epoch":"280835979","root":"0x2924aa9808dae5c9c0e0386bcd77963c521aa76e3392b111ce493420766dbb70"}},"inclusion_delay":"10992382381327012904","proposer_index":"10990729898110328776"},{"aggregation_bits":"0x0f853bf134b8389b7dc5689b511018e285b34eec630787e46a11c60815224bc5d1c7a6887e51853a49a8ebffcaf6e3486e79cd454ab5b5e7219242e13ae7e918253cb6d4743382b29e958bbf71aeedeb8ba0c66e4ea7bc353da8d1aa2202b527623882f2a255ff2d8e9cabc96a2d771ab17df5e780e6fdcc3e931518499855e6ca13316736b97bcef3f6edb140698e8ae159a9a6e99c3a8d305f775919adad36b1b8a595b03426bb7af1b0c71b73c1da17552645334dc046502683eea7b6e1af57c57cbd089469b25a96e552865bda4ba669a43ec1b1e94d6801626f135bd70dd659cf3638abb8a83fb903967afbe030c86fa830866470278e64bf6fce92783c01","data":{"slot":"10994034860248729736","index":"10985772444165309096","beacon_block_root":"0xe86e6f9848ce9e7a557e411d11d0633f91389d22526949579755d7f2fe35e5db","source":{"epoch":"279296983","root":"0xc22c7b980837e0f06af872c66abe3aa584329ffee5d7f7e23c535062497476c6"},"target":{"epoch":"278142736","root":"0x34f35798c7fc1b8e2a8adeca60f3b573aa44996a2b8cec3f4e5ae51367b9c206"}},"inclusion_delay":"10982467473436973544","proposer_index":"10980814990220289416"},{"aggregation_bits":"0x17952318786767a33407a0d13152a63f1b8f7890685777d5e5d7dc3e67cb655138cb8e410222fa3d2938291dd666dbbdca2ea935687a2509933736be957e38925368e78a29345c802fca802298063a1217f178c33001962f1efc48417a32845b97584de54471a19c5b0946814310f5ecce112e29c671a24142f831c7f4ee22cf7c1ed055e225aa7dd1a01c78773644ac7c5258514914561b93e9708eb7274c4343580b2a9a60a1a1c671661909e746a1756228975588ec985785ef2c15df97c97ff4f26b2b99bd735616d668838329d57d8bab72efa91cdc6b30138a78957e7d96a7da7236319c6984eacf2d59e098bfd9c171b5e4b6f02d7161c7e5738e67fd01","data":{"slot":"11023779575328913225","index":"11028737024978965609","beacon_block_root":"0xf71208990920f17b6db1c4b493ea4d6beee9b64ecd06256ff136fc9bd05f45c5","source":{"epoch":"282759723","root":"0x6ad9e498c8e52c192c4330b9881fc93914fcb0ba13bb19cc043e914deea49105"},"target":{"epoch":"283144472","root":"0x4497f098894e6e8f42bd6162e10da09f07f6b296a729c857a83b0abd39e322f0"}},"inclusion_delay":"11012212184222189736","proposer_index":"11010559701005505608"},{"aggregation_bits":"0xa58ec0888b55e6f8e63dffe638ed22d8da8ec494ae23657a39299af4890e62399ac9bf7734f6f5912a25e9fdc839abb970668f90d27cf5748f065b306697ca030d189eb221c2f58ff2e812f399d3a88bf18d1891f588dcaf9c640fe8516eb3bca1f59adc0bb6d9896eab1692fdecc2b4e44acd2f13e49739b879da46f34b1250eb9f7c733f15d98afd25ff3b3839c1269c8fbdfb563afc092509b6c787bc01f710f2fd68b150d580f0ae375f0638838aaa3a2749d52653f4bd42eeb1022717a414bed54236bc20d6040ab9bb4cdbaaea4a82ca4bc833e4330916bee4a6fc69e0a651e8204b78f3de3f9882357d0c0946330bf3c24c8bbcabd908bfe6ab74620b01","data":{"slot":"11013864667438873864","index":"11005602251355453224","beacon_block_root":"0x03e2b598c8422740d65a6a1425666da24614a94ac600609d7247ad8fc1ab4c5b","source":{"epoch":"281605477","root":"0xdd9fc19888ab68b6ecd49bbd7e544408390eab26596f0e29174526ff0ceadd45"},"target":{"epoch":"274295247","root":"0xb288e29747e58def52c5ef2ee8a35079278185d26a3a1ccbe2712bb9774a16dd"}},"inclusion_delay":"10949417796218389095","proposer_index":"10947765313001704967"},{"aggregation_bits":"0x3f7e5eaf5cd0af1f29e8945ec72c32331389397586fd6f18ba18fbf14020d857bc8b8aa385ac57544f013ee679ef3245853cc5b53701d7e346d15d2a165b828e60f33742f333f737d6c742bad085cc8d6bbd00a5b189c8995476c0d645d163457a09715ec258fa125f2f5beb122f295751f271c568dddfb588bd041cfcef00f40f60a4a712519a9e213c2a7a998072ddc434db5ec20cf14b6cd29072cc36282f45d89538263bf7a0645c6131cb894b5a0bf458f88f5df973d570096bd8adabbfbc0f04e203bafdc9f27bd512c7d707180aeb21cda0273e07487eafbe9255b93bd00b2c9bd486d92f38f6cf4377a02354da13b8bd6a414f63ffbe22bd19f1a9ab01","data":{"slot":"10937850409406632902","index":"10942807863351652583","beacon_block_root":"0xd9cad697877c4c793d4bbe858fb57913338783f6d7cb6d3f3d74b2492b0c85f2","source":{"epoch":"272756252","root":"0x4b91b39746428816fcdc298a85eaf4e159997d621d80629c507b47fb4a51d132"},"target":{"epoch":"273141001","root":"0x254fbf9706abc98c12575b33ded8cb474c937f3eb0ee1028f478c06a958f621d"}},"inclusion_delay":"10926283022594876710","proposer_index":"10924630539378192582"},{"aggregation_bits":"0xdde4a5bfd3c236608efd8529c4817e2f128a17bb0558cd7b49faadbf7d673777567d91d5b3689c3c3a592ede6c90c31144c082309f8146cf9ae1fca4652a8a473cc6189069cb783e49f4b563b1c05b5c1c8569d7f4c0e31b06afc57bacc8dce2b622e7467d1be3b76b877ce24e571521de02d040ad70aaee7628ba99140f710faa493ca9e761eb581dfedef3d8fff5207469bb70fc3e1c194e5f7aaa10654593c25a3e2f2d2a108052f77157af7f2cf4748ec44f2f9176d0a42712d6a8512dd0d0dcb380929e164c25773a330c8fcc17ff6b0b97b79dcea8342c1bc70f6d6deee0e59ddaadcf3a94818c4e69564dbe2d34188a0c2238e7ae29935f8ec116ff5d01","data":{"slot":"10927935501516593542","index":"10972552574136868775","beacon_block_root":"0x81774098472b99a1ff957b78ae1608a8c35095b205af8f28065ff334d13ca031","source":{"epoch":"277757988","root":"0x5b354c980794da171410ad210705df0db64a978e981d3eb4aa5c6ca41c7b311c"},"target":{"epoch":"276603741","root":"0xcdfb2898c75916b5d4a11826fd395adcdc5c91faded13211bd6301563ac07d5c"}},"inclusion_delay":"10969247603408533223","proposer_index":"10967595120191849095"},{"aggregation_bits":"0xd715ac460bf97b7ac2794a03c6cf82800d63300b7e5dc40ffb356d8ccf0d70e9bb47995e4c0fc1f979adaa7450705f852b8bff54b76d9636aa4c61da4033f9b540fe4e08e27fe4883e2f1df6d82ecaa418c89f68eaade043a436fe803f9a59de28f65873dfe1cc822bb4e1dac5638fab26350b04d3cbb5f10f51824203184faa0ee4ed8b3ad53bf8ef97abf04ff03ef4795adf1149b33789e9e9558d64a6a2a6b43a5c952f5e8af6fb06f689884f0a2f3ef38a356a3e788c741c2e44d5356f957d5579973d9aa9b827e70de801111781a02ec0f834a5bbd9a75f52064ca276de880b9a858f57105e8e270bc8645c2330277dc355a2caa9e7aa46472c1e85ea9801","data":{"slot":"10957680216596777031","index":"10962637666246829415","beacon_block_root":"0xf33d1d9807f1d43ebe27e77ca44b8376e8628f1e4b638485186688e6ef81ec71","source":{"epoch":"275064745","root":"0x6604fa97c7b610dc7db952819a80fe440e75898a911779e22b6d1d980dc738b2"},"target":{"epoch":"275449494","root":"0x40c20598871f52529333842af26ed5aa016f8b662486276ecf6a96075805ca9c"}},"inclusion_delay":"10893233345376292261","proposer_index":"10891580857864640837"},{"aggregation_bits":"0xab73bc0b8fe9b784143b93c80da7821c37ce7eede13afb35eeb8c50900ccaf4e99679d206394aebddf5e6c0b99beadc9390d4e96e69cbee1d15cb484e3cc481683cb8773b4ff104847b8f8f56e22ce28b0f5784e7280646362053017dc819874df65c1ee87fbf28582fbb254be990557dfaca5c5b83023b924f8e404043bd19e1bb037fbaac95c8047a698c56eedd48e4a8f86d7dc6dc70bb78a84b6ee703abb8725a4c867b7e45c256148783980c7259937ddfc329a5d4034b1797f5060ac6264324282f31fb5ff23071ae91f70608eebfa85b217f727749003aad75241cfe9b93eb66b404680792addbc55f63db19afa848ec183eced02bb519d88c4c283b601","data":{"slot":"10894885824298009093","index":"10886623408214588453","beacon_block_root":"0x622f0f97c587f49ecf2f7549abe1335008ee615a0f74d8f8529ca9e22ce9df5e","source":{"epoch":"267754516","root":"0x3ced1a9785f03515e4a9a6f203d00ab6fbe76336a2e28684f699225278277149"},"target":{"epoch":"266600269","root":"0xaeb3f79645b671b2a43b12f7f904868421fa5da2e8967be109a1b703966cbd89"}},"inclusion_delay":"10883318437486252901","proposer_index":"10881665954269568773"},{"aggregation_bits":"0x0b3fd5353a4eaf60d891189cf5b4576f9461652650aaec2261bb7a572664bde7bf54afdccb8541d22df46dee96d11c1b2e8ba6d6ea3c0c4dbf2ac2466336c17961236c82b27d455a95203b669d3928a6f692960e53c79bb7fca1e437c03836809a3136d4085cf7886c9c8eb10c4bcb3d1e59006aff4b9893f107abd1d9ccc8c46f28987af4c01b4e86209931a11628d7c10d9b8bd2efb5a978dad879d77e62f02f9ecd28f965ddff5953b532bc00e7706a777a3199997ce53e60da497f5256a97a26c33f1ba482b1ef98866061259bd966ce0f745a13b9621851b6733ef332c89ea44ef64f847511b7b19660334d885d247c9e85effe32fb6919b25448f7dccf01","data":{"slot":"10871751050674496709","index":"10876708504619516389","beacon_block_root":"0xd5f5eb96854d303c8ec1e04da016af1e2d005cc65528cd5564a33e944b2e2c9f","source":{"epoch":"271217256","root":"0xe4998497469f823da6f463e52231994a8bb175f2d0c5a86dbe84633d1d588c88"},"target":{"epoch":"271602005","root":"0xbe5790970608c4b3bc6e958e7b1f70b07eab77ce633457f96382dcac68961d73"}},"inclusion_delay":"10913063148271469094","proposer_index":"10911410665054784966"},{"aggregation_bits":"0x131a4ccac00427fbefe6048d35bdfa24f946fcae142d7829b5cf75a726a007fad29bb0440b31b832fd323e199623e609879b7d7527e1f7323cc5bdf497b8234da39f7e83a4f3a6f72d7301b90699aa420bc3ee85998c15a9ebc174769eec86f79d1a8bc5735bde3d9b484f0e295da2f98827dd6e2332c9fcad204bca3a581a821b343aa34059fff8c9540b8f76b998a133c1e292ebc711e922f3c5a972a230324d475e2320d316420efad7584281ed7538146ea1437ddcd7edf12e50f7fe5a7063089755cc37e31f7e934413d1f36c2f5333e98b6f452222b102f34687c64404ffb780059bc54d13289c3476a5d83fbf47e1fb7b4b6310826d3d99a185b4d79001","data":{"slot":"10914715631488153222","index":"10906453215404732582","beacon_block_root":"0x7da2559746fc7c64500c9e40bf773db3bdc96d82830bef3e2c8e7f7ff05e47de","source":{"epoch":"270063010","root":"0x576061970665beda6586cfe918661419b0c36f5e167a9dcad18bf8ee3b9dd8c8"},"target":{"epoch":"268908763","root":"0xc9263e97c52afa7725183bee0e9b8fe7d6d569ca5c2e9227e3928da059e22409"}},"inclusion_delay":"10903148244676397030","proposer_index":"10901495761459712902"},{"aggregation_bits":"0x3f18c4c555082cc4b83f6d2dcb898bcb976d0d7b14ce6e6df8fc7af003d2a517f2c0a429536922c610d4ad3b63b7fc6112006240e38cfff5c416aaead37442809eae53e3eb6268458b7efbb482d98e46516216f5cdbb0c9d0fdbab3bba43769643e6a24222b8feaec7c8e2d6e79d794a3fdb59c6f92901e4b3d605a1b564b83dfecbb23abfd839b305686f0e9700a2217febf64df6b6039b0b0ac348386899781b691677f0786b72baea8c84ab674ea587dd43029d977670ade4f1ee0f73c77bedfb6255faf12080a86a48faf85b59dd0f584a10e721f83ab06a2225b3cdb4eadfcf447ea6b7d1db3c8a60e9c7175aeeeed09e456fa3f35ecfdb52532221a80501","data":{"slot":"10838701373455912260","index":"10843658827400931940","beacon_block_root":"0x538b76960436a29db7fcf1b129c74924aa3c482e94d6fce0f8ba84395abf7f75","source":{"epoch":"261213785","root":"0xc5515396c4fbdd3a768e5db61ffcc4f2cf4e429ada8af13d0ac219eb7804ccb5"},"target":{"epoch":"261598534","root":"0x9f0f5f9684641fb18c088f5f78ea9b58c34844766df99fc9afbf925ac4425da0"}},"inclusion_delay":"10827133986644156068","proposer_index":"10825481503427471940"},{"aggregation_bits":"0x6de337bdfdb3eeef6413761eea7227c55440a198f74c7c867d1b46f408ad8aee52ee92e62dafb94b8d0df9477f8c0df5dbac25f558956fcab9a38ae434050b01c0c7fe61f6f8816496dda421898e5895675bcfe108763e5d394beec7513ec1bb6ccb747a5dfe032bde603567b8606615a300c0a08faee4884f434a15c2cd91fc6bca0a764c6ccb44a1aa6f0fc86f2e868fb6a7a1408ca283a9804895ec71dc4cdcc391dddf08c3510cf798e2ec882a8bf081ffcd8c18c976d383da5f9999611686bbc11aec95a8857ee6c709b586c65322d02a1950fb0099dc6c5e53fa57605aaf91d65ef974321dc580e9f8f9998a53007234370790c7dc25c26d48fbceaad701","data":{"slot":"10828786465565872900","index":"10820524049482452260","beacon_block_root":"0x5e5a2496c458d86120a69711bc42695b01673a2a8dd0370f78cb352d4b0b870b","source":{"epoch":"260059538","root":"0x3818309684c119d83620c9ba153140c1f5603c06203fe69a1dc9ae9c974918f6"},"target":{"epoch":"265061274","root":"0x47bcc89645136cd94d534c52964b2aed531256329bdcc1b277aad345697378df"}},"inclusion_delay":"10870098567457812581","proposer_index":"10868446084241128453"},{"aggregation_bits":"0x77f136dca1ea90b94b93b8788e18bb784136ce11f4cbc8f0bfd64ace4ef70d6af1069f053b8ef65e6f8b7fa96e3235a17cde59857b588e282b06ab19dd04599b76dbbab4bb375752e12046f8eaa2c26c62de990956ae2c87821b317ad0197441b12bebc7b30ccd760ff3d8d43091dee6687c6a402b4beb813b0bd2cf4f1bbfe15f07bb7270709cef5bcafc442770e48886add2081904d43f1cb745f782f91571a8b35f56f5cc19c71456077cc86e04f4b6fed11f79f5edba20acf4c124f521418f88af88c59175617ef6b416301931c5f491a165b2833cec5f770fb6379aba0dacefdb29efc618df1642e40a80ca549b51b1efeea72c15d61a9377680dd1b7e201","data":{"slot":"10858531180646056389","index":"10863488630296108773","beacon_block_root":"0x6dfebc9685aa2a6338d91aa93e5d53875f185456086e1327d2ac5ad61e35e7f4","source":{"epoch":"263522278","root":"0xe0c4999644706600f76a86ad3392ce55852a4ec24e220884e5b3ef873c7a3335"},"target":{"epoch":"263907027","root":"0xba82a59604d9a7760de5b7568c80a5bb7824509ee190b60f89b168f787b8c41f"}},"inclusion_delay":"10846963789539332900","proposer_index":"10845311306322648772"},{"aggregation_bits":"0x854ac7d5865a39839b0cf94fc6249f7e427ed075926ada930f6e2c08c615225350068d1f45c8ade65e937d5160494c64e572f70140ce6e19d726c3642a55601ae8da1657e198de5a7c1809ede1fd1cf514e67a9e13f34687d4a3f0d75b44cb30af48705bac49e7eb325b82553f2dc0ba64abd84138843cfcc9dfbc635d9ace26696e0f7c84c84e6c6f495c85de3e632b1e7293e7af20fd493df7892a38e254c429288e32dfe93c73ae05d78ae79929db39e64eb57d9bebd1ca2bf3600e09870ebd845ce553f5f86429763bf77b03daeada11c320d51b45577938aa4a2fa4eeb7dd09e1681eafba688ff16d0362e6c526b09b4dd6ef9e4919daba8972dc3bfaf301","data":{"slot":"10848616272756017028","index":"9518366703504708996","beacon_block_root":"0x2929128423212d61fac071ab276e9e9e3eb62f8fd3a1c1145b6cff9c7e2bfd07","source":{"epoch":"108468471","root":"0x03e71d84e4896ed7103ba354805c750431b0316b671070a0ff69780cc9698ef2"},"target":{"epoch":"107314225","root":"0x75adfa83a34faa74cfcc0e597691f0d257c22bd7adc464fd12710dbee7aeda32"}},"inclusion_delay":"9515061732776373443","proposer_index":"9513409249559689315"},{"aggregation_bits":"0x95547a6b98c39e823657818d059bfa21c610aba5b59b7a12ce5c194bc6faee2b9eea395c64d9021b43ff5fee36e6d3001674e696189822b4a45ec720620fb53fb5f2cb8baddef6f5eec8df4a3c0b8db8583c853a7400ecdbd86f5605186523c1493ef5b6bcf1d3711d863f633ded03aff18bc843a0d7394df20d11a7729b40dab732ad79d074a1b01b2a0c9ec882be2811dfb28dd405947d26285671cf0337fd4f2799d5c295aedce8e5967efc45e79f2da8ace629dddddd4857d80015280abcfbbacb5cd4deae70dfc8ffbc4e39f81e557e5bb9ebb264da3aca1bc16e9288a64d9c705af23a1dc4195890aa50c7e75f5c1c618082b0daa28e679d7a14a391b901","data":{"slot":"9503494345964617251","index":"9508451795614669635","beacon_block_root":"0x9befee83e3e668feba52ddaf1da3196d63c829fb1a56b6716d73944e9c704948","source":{"epoch":"105775229","root":"0x0eb6cb83a3aca49b79e448b413d8943b89da2367600aabce807a2900bab59588"},"target":{"epoch":"106159978","root":"0xe873d7836315e6118f5e7a5d6cc66ba17cd42543f378595a2478a26f05f42673"}},"inclusion_delay":"9544806443561589636","proposer_index":"9543153960344905508"},{"aggregation_bits":"0xd139daf643bec6090b22658d56d416073a57ff8f737cee110be421bac6169130f70d026432629afee3100d2576bcaa5abb7424b58810f1b16ed3981af5805b875c1e110bab5a9d9add9ac4d5aebfaf18497fccd9ae094815df4f14f4dd1571eaf5de9ab2c4f69bfca95a96d790a968fee2d117271eaa50508c68d1ade8db20f6e3ce6f2068e8558e3cf8b860756b3c3dff428e875169f21df772d721d5576d093e720b82892970603949f7fd0cdd6caf3e7e2972201c6dae98b44c569df046712735a97c214dc4c4cf063ec796cfb7e4610b7fc310d25dabd39df2e1afb6fa383caefff8a6eb008a9775a730ba12715079d01d7eef9d2ed3cb0b7787b7bbe4b001","data":{"slot":"9546458926778273764","index":"9538196506399885828","beacon_block_root":"0x449c5884a495b5267c9d9aa23c04a801f3913bb74739d85a355ed53941a16487","source":{"epoch":"110776965","root":"0x1d5a648464fef69c9117cc4b94f27e67e68b3d93dba786e6da5b4ea98cdff571"},"target":{"epoch":"109622718","root":"0x9020418424c4323a51a937508a27fa350c9e37ff215c7b43ec62e35aab2442b2"}},"inclusion_delay":"9534891544261484868","proposer_index":"9533239056749833444"},{"aggregation_bits":"0x5d04ea02ff2a78f6cd8b425826574b42d8094acdb8ac9a86a9313fe443c606d3915f28a3b84ff09b193a0c920dc33e4538ebde138000676d43d1eeb3347b9245bdf722c93a9ac48a26a2c764d43241f30b19a27dee0c954155ef88d46228f91ab2ab7c9d4111b7d13dac8c70aaf9e751af0cb2884985f33a78f5def9ac4e17945597c82019e002c8d5b15c34bef3f4016919b6c13b8bd2f530db8fe86bd11f74b60d6c3887f1dd9d631b1597934c70dedd8f37afcd3e7e0ac467e77de2caf6b7f0e62e639a9ef71509d98244c079dc97fc97b157df30659c9aede65dba052e471534d74cb1e1d5a088195c09df38ed3fef789c65eabd302ad92b18cb2367ca8d01","data":{"slot":"9523324153154761380","index":"9528281607099781060","beacon_block_root":"0xb6623584645bf1c33b2f06a7313923d018a435238dedccb748656aeb5fe6b0c7","source":{"epoch":"101927740","root":"0x8c4b5683229516fda21f5a189b882f41061710cf9eb8da5913926fa5ca46e95e"},"target":{"epoch":"102312489","root":"0x66096283e2fd5773b7998bc1f47606a7f91012ab322789e5b88fe81415857a49"}},"inclusion_delay":"9458877277639309314","proposer_index":"9457224794422625186"},{"aggregation_bits":"0x81c09ae57b0b16050b809f02e41902dac231203597cfe6bc90ad1765bc3b5c327374acc685fdf3c39360ca0bd6154486ab676d36d145431a3310ba86b6a6e76b77cedbd8eb52304b26b50100e2bc594f956cf59727e135a19c84de4782e9cef06e8567011b53e3c62778cdbcd95327a15d100059603645425e19f03a471b13acb0721e93a8f62530d424dea19fad087943046d84ee64a01df9250e94e80ea16dfcde81604512b560bf4cb2a626c9a9587fcb6a46dafb58ca91d6f891b7873d61e3cf853a2eeeee5e4eb7b5c2de9b8b981663ae5cef78f734aef3deeca6ee3e6c24094a0a46d855c82ef3cb9ed473d6a53e81c138222ff1efc0d8827ecdd0aaad01","data":{"slot":"9460529760855993442","index":"9452267344772572802","beacon_block_root":"0x2554278322f210244c37947338cfd3a9382f085f51fe202b819b8be79d4da4b4","source":{"epoch":"100773493","root":"0xff113383e25a529a61b1c51c91bdaa0f2b290a3be56ccfb626990457e88b359f"},"target":{"epoch":"99619247","root":"0x71d80f83a2208e372143312187f225de513b04a72b21c41339a0990806d181df"}},"inclusion_delay":"9448962378339204546","proposer_index":"9447309890827553122"},{"aggregation_bits":"0x29d2333c870ef90be345d869ed7197579d2d1610968a9ec813f15d53aea15ea2dc502c0dd0deb604b7894c21eee5fe52443501c7eda816f1799d865b84bd30b101fa95a82c86ecddb9d88bb20bb0e536ab60032019211531b585c1f912c1b988faedd835b1f1aef3fee16005d307b47302aacb2d7ed3324d2a46e0c05da43515861cafb15c48b4b9da666fcc08e682f7da7ffe7b1ff831878b1391fb0686485c813ebbdf4f642b36a0e8243884bab72f70b2860e8e10549a11e1d4924a613d514efe73b9e8c350ae0e2b84b6da450a064da259388144024126f03f03e728803645c7fd5540ca712eb94d6f24b66003842d8408f302db338f8fc5584c738c97a201","data":{"slot":"9490274471641209635","index":"9495231925586229315","beacon_block_root":"0x34f8bf83e3436325646a170bbae9bdd595e0218bcc9bfc42db7cb0906f77049e","source":{"epoch":"104236234","root":"0xa7be9c83a3099fc223fc820fb01e39a4bbf21bf71250f19fee8345428dbc50de"},"target":{"epoch":"104620982","root":"0x817ca8836372e0383976b4b8090d100aaeec1dd3a6be9f2b9381beb1d8fae1c8"}},"inclusion_delay":"9478707084829453443","proposer_index":"9477054601612769315"},{"aggregation_bits":"0x1129588c24f48861f8480c5fe50933611c2a827e772b2ea2e5010319a743f0da789207bbee7fa92ab9e55e49c99b054795db2d9256ba0609c638e70762ec18715f9ab00a761c27f64cfcd8c86a9779078e586bf21c651729c35d801591fc0c2f0442272c1ab6d766cb5223860ebf880708ff72c8375c8f67d4531e74bd4e449091b61afba57ce40efae7cc2b05e846557be289c101eade9dadd00b28569f0de445b4fa9f4417463114b777764945e1015fe8cbb91e9ada387ea6d3266c1bfb2e2db848e5658f9dab98274937119f8129ccaac12de6defaee0bb2076d33a55c8b6401dd45e71198bc28326abf17acdad98ae6b3c38aa0054b1f848766a836cdc101","data":{"slot":"9480359572341104867","index":"9472097147667749634","beacon_block_root":"0x40c76d83a26699e9cd13bd6a4d65dd0ced0a1487c59537715c8d618460c30b34","source":{"epoch":"103081987","root":"0x1985798362cfda5fe28dee13a653b472e00416635804e6fc018bdaf3ab019d1e"},"target":{"epoch":"95771758","root":"0xef6d9a8221090099497e42850fa3c0e3ce77f00e69cff39eccb7dfad1662d5b5"}},"inclusion_delay":"9415912696825652801","proposer_index":"9414260213608968673"},{"aggregation_bits":"0x3133e223b3bb8d95ffadf2f61b2d03db51c957ad67b926c14abcea188b28cb62d07813cd77583e2cd5c9093a298c9da00100654694d1080886dba14da72280fd12a13f6e3d87695f32f32c012ac70d217769034e88cb04b5e70add6be5923696f292b4aedf5cf7fdf1c11e7ec32e79bfbd4bd072d24f7fbfe876611fb270b20a77599b699dbcd64327fa196ee75254d42e081d9c85be23df8968878f390d043c119e30ced2177c3534e56790bcb6e0d0ab22f53a647350ff1a912015e4870771894dbd7767d46237a6584516fa3116d399e32ab60ef6a2fa0a9a527e0fa8c472037b093fa25e95657d75356af561b0e12a57d1398c78e4a3a512b5b41df38a3601","data":{"slot":"9404345310013896609","index":"9409302759663948993","beacon_block_root":"0x15b08e8261a0be22340411dcb7b4e97dda7dee32d660451327ba663ecb2344cb","source":{"epoch":"94232762","root":"0x88766b822166fabff3957ce0ace9644c0090e89e1c153a703ac1fbefe968900b"},"target":{"epoch":"94617511","root":"0x62347782e1ce3b360910ae8905d83bb2f389ea7ab083e8fbdfbe745f34a721f6"}},"inclusion_delay":"9392777918907173120","proposer_index":"9391125435690488992"},{"aggregation_bits":"0xc1c151bf09610cfbfba456c491c0e74f94085b5a59a926aebf0e14da86e64c9270bea1194db8a305e99559422e1f6cb5cac925562fe298b55bf7cc8340cba0655cc4328024198046e7907ed422943fda225062fc9d8e6ebdb1d248c66c8ba331de9656868599fef8cc7f5ee5df8254ef239d29751b8002c2343b0baf288bc1c7d0384f0f640ea0b41b38e9a1ae2ad67bd7914c727aa2cfadbfb1c9d7a3c6498896348d58fea2ba35826a3e3fe248c47e357c4ad4a42ddddef64221a1c77dc51569428ee671b0ff0223454aaf75ebbdc4fe4249e1396cd815e6ddb30c0b95908f33e52b3dcac6f7f6c0ae846151d925f8c07fe302cc45be25761b6abf82dc8ac401","data":{"slot":"9394430406418824544","index":"9439047470449165186","beacon_block_root":"0xbe5cf882224f0b4bf64ececed51578126a4700ef044467fcf0a4a72970545f0a","source":{"epoch":"99234498","root":"0x971a0483e2b74cc10bc9ff772e044f785d4102cb97b2158894a22099bb92f0f4"},"target":{"epoch":"98080251","root":"0x0ae1e082a17d885ecb5a6b7c2439ca468353fc36dd660ae5a7a9b54ad9d73c35"}},"inclusion_delay":"9435742504015796930","proposer_index":"9434090020799112801"},{"aggregation_bits":"0xdd523952c55833e1046531ab5aa633aa8ec17cc3029d8f5f01d39ce4e44463129b9c2bb09feaaf80a77c9b68128fd461ef965da6028d455bc17ab9ffd15073e21adc537c6d0d5ff0f8afdd6f423c4201744f949b874f6d67aa42e321ef3bf4450055f5816ff7922d0c4bb5f8546a9e18c284e24b6141addf63fe0f71280df7f2f4d49e39b2ccf51f69499ae4f423b86fdec6395a2a3b751d3f15ced28589aebbe0546b63d27209af9c5ff0a4f3b6788161896467d196e98cb6f119b23310f14bc073706460d5abd653c87ff450715e722128c28b1b44a7a460cdaaed4b1b0b947b73b428e15ddd3a572cb1c122cc3895dab6a2dfe6377807795e72ad1c838fd301","data":{"slot":"9424175117204040737","index":"9429132566854093121","beacon_block_root":"0x3023d582e11447e8b5e039d3cb4af3e08f59fa5a4af85b5902ac3cdb8e99ab4a","source":{"epoch":"96541256","root":"0xa3e9b182a1da82857472a5d7c17f6eafb56bf4c690ac50b615b3d18cacdef78a"},"target":{"epoch":"96926004","root":"0x7da7bd826143c4fb8aecd6801a6e4515a865f6a2231bff41b9b04afcf81c8975"}},"inclusion_delay":"9359728241688588672","proposer_index":"9358075758471904544"},{"aggregation_bits":"0x3114060f3454c51e816ee875c86f3b32b4ec5a072fdfb6f9166cd45c6b8538723fb6aee4b36ac6cc05a4199dc9582ca6b402eec549584b2d10424e2ff7892205f1cdab653901a931f9aa3256b87a0b8dcea243a55a82e9ebeb689d1a186ea2af22f8761cb77fef48679bb5842d0cc46c2319119a0cf237b7fa52a1578971c3562199585125322645407c8f51343dc2d5ecd1209d5fd7049e6e731fef0e5132b0e243063fdb316691411b4f51647fa3a1d9c571aeed23f74ee354200c6f5c14fab502ff3590670093373600756e93c95dcbde8fc5391a390816c7135ed698b2ae642c05cd36ad8929f3daa6d83fb5a2444acbdf8720c1d4826151ba09e680eb6f01","data":{"slot":"9361380724905272800","index":"9353118308821852159","beacon_block_root":"0x9f14c7819fab6648c6e8c79fd2e0a3baafe4cc960e09b0cc3ce25dd7cb009f37","source":{"epoch":"89231026","root":"0x79d2d2816014a8bedb62f9482bcf7a20a2dece72a1775e58e0dfd646173f3022"},"target":{"epoch":"88076780","root":"0xeb98af811fdae35b9bf4644d2104f6eec8f0c8dee72b53b5f3e66bf835847c62"}},"inclusion_delay":"9349813338093516607","proposer_index":"9348160854876832479"},{"aggregation_bits":"0x35302c21c1e7c3ff4fc1eba42afc670356e32fe4eddf8372b91baa2acfe58e0253e20c123d652f6ab70c0c723e843abba2a504244bfabdb17c3c7e65726fc37e912151bc3fcdf03323d239d5ce6f3ca2a8c7a5e53aa716d3d9da699a237b4f5347850026115aefa7896ce981ff144ba2dbe6fd354ff9209dc215daa2d78ed40c1503ffdf722cc323c8f6ae65dfc52a2c62a43cd98519063ce1424bbc77e92a8b62f82dff7dad27af1ccbb70d397e0dfeab1455aa1b21a4eb7f172937186eae2566c0febb786e6f6cfbbab4f67875a00a54c0451774baa57f7ea60ffaa78b6e806d9420d222ec1450e23278fd584d9f7ed43d7f852081ab79239107755ad5835701","data":{"slot":"9338245955576727711","index":"9343203400931812799","beacon_block_root":"0x11dba3815f71a2e5857a33a4c8151f89d4f6c60254bda4294ee9f288ea45eb77","source":{"epoch":"92693767","root":"0x217f3c8220c3f4e69dadb63b4a3009b532a8e02ecf5a8041a8ca1732bc6f4b61"},"target":{"epoch":"93078515","root":"0xfb3c4882e02b365db327e8e4a21ee01a25a2e20a62c92ecd4dc890a107aedc4b"}},"inclusion_delay":"9379558048878732800","proposer_index":"9377905565662048672"},{"aggregation_bits":"0xf95fdcef0e3d1b7a3ab27724e9becb89f2e6f06f4239137465e3b4c6eea9d01b36683008f95d568b27a3199ddad54d670a84ce059a038ed4d7f705cfa7c9190ef1fc41bf2b41960c93fb83b850984ae6b506cd7ee0c6d3b98ca86b4b7a2fb864f76f72943ad9ff903fb50a1ff948f35064bc2b4d97205dd07d1a2ee8768c8548e0151ce54ab40325ceb61cdb28ec9c79b43f05d0bd59237d6a0cda50a2853c3b912179dcfe869713cbe796fd6b3686b4f9e2e0b28a414599665019239ad7f2fadc5f345a8f464142e2a63c8fa097dfec011de6e041783c87f3bbcedf02bf394a0ce4be82b51c401c601b4f7bb8598f32b0a3837988089a6837388de081e6b44b01","data":{"slot":"9381210536390384224","index":"9372948111717028992","beacon_block_root":"0xba870d822020ef0d47c5f096e776ad1d64c0d8be82a0c61216d433748f7606b7","source":{"epoch":"91539520","root":"0x93451982e08830845c3f22403f65848357bada9a150f759ebbd1ace3dab497a1"},"target":{"epoch":"90385273","root":"0x060cf681a04e6c211cd18d44359aff517dccd4065bc369fbcdd84195f8f9e3e1"}},"inclusion_delay":"9369643149578628032","proposer_index":"9367990662066976608"},{"aggregation_bits":"0x572a6633cfadeed4eaa53a6d717f3eedab5ce189916f9cb4efadc2fa997a5765333def7439a62bcd86778fd9c9cdc9877cc7df5e419d6c23d0df2087120280dc347e9ce9f13f87d028d7916a8c8cc3573292d5fe5c26c42e81a22934a0f92b4f0682f3868a13dcbb8af8d57c2e9048de9989f9d64af00c981a006c01cb25d0e45c083150c2833b238ec48dc965c94d90434ea02a9aa6ab1f32670c13e8d649c23c576b2a868c1e51b45aa3328ac87122a75b5961f0646dc38d5ec12412e2e2a79ec8f42acc95a1b606ab431561afea4a25ec7ca28f06906518f60de9f8fafdbb8c243b49be40ea6d9703ebf6546be2861c2329176b77bebe3823f07030a5439501","data":{"slot":"9728232162217906473","index":"9733189616162926153","beacon_block_root":"0x765d0d87e9b9c86772c001a1b0f2307a112db06b3bb50b8c1dd3b7ea98fcdd96","source":{"epoch":"131938154","root":"0xe823ea86a97f040532526da5a527ac48373faad7816900e92fda4c9cb7412ad7"},"target":{"epoch":"132322903","root":"0xc2e1f58669e8457b47cc9e4efe1583ae2a39acb314d8ae74d4d7c50b0280bbc1"}},"inclusion_delay":"9716664775406150280","proposer_index":"9715012292189466152"},{"aggregation_bits":"0x25f034a37a9ffb8f5d8a2f1f58f23ae8f3537de7a7a94e5f531da43ea5b478fc8bb3fd1b9642a039d5aeddb1fe733922a36940dbfa9f2daecd734088e56083566a1bb161eac11fedddb5c7f785ca11c476ba31fd886b8e34f7706ad55aa495fa0a690117bcdff56adf5135c573a87580c65252d09059a1e3e45727ab5f88e4a74ba98c0e373569c0a6beafc22c9fca73bb57c0402292424d940ea7d3388d8c7f1b94f30aa8f8bf788997f35cb73f1c1c9862b493b4686b216251d244ba0843e9fcad852299d138f7302b98f7a276455400a41cb3a89e68ca60f5a9977881b262ecf29969408909d28c786accf38f3b5ff669a32c2b474279f54a0263ab0f476301","data":{"slot":"9718317258622834408","index":"9710054838244446472","beacon_block_root":"0x812cbb86a8dcfe2bdc69a700426e50b16957a26734af46ba9de368de8a48e52c","source":{"epoch":"130783908","root":"0x5beac686684540a2f1e3d8a99b5c27175c51a443c71df54542e1e14dd5867617"},"target":{"epoch":"135785643","root":"0x6a8e5f87299792a309175c411d771143ba02be6f42bbd05d9cc206f7a7b0d600"}},"inclusion_delay":"9759629356219806793","proposer_index":"9757976873003122665"},{"aggregation_bits":"0xadcbbc4e04405491106ae932f4f48415ed470366fc6a3668ecd07c4c17047f6c5489f4da7115ff6cb5701ffbc640a042421a6cabda622d7417de2945c4d6a7c51c62f7b8e747914bc2ee6466e427267e28b7ef39b7262ae8cc631e66cab8e188d40dfea21fa592515ac2e87df9fcef504d7ec934baf0e3fdb1192b5571f2d2b8398c7d18e9abba6b10635e07939882373238f46d370af95d241808ac524661486df43595c7686522360724c605490727879eda6c05974f6d087ee41b274704ebd59e68f5d3f5cc57d0bbbeedaf69f0fade67951f1aa49d1bf3e7d0582c4d395bcc2c86164eb1271897da6e3f831fee62a5c478f119f842728e4f90493552523001","data":{"slot":"9748061969408050601","index":"9753019419058102985","beacon_block_root":"0x91d05387692e512df49c2a98c4883addc608bc93af4c22d2f7c48d875c724516","source":{"epoch":"134246648","root":"0x0397308729f48ccab32e969cbabdb5abec1ab6fff500172f0acc22397ab79156"},"target":{"epoch":"134631397","root":"0xdd543c87e95cce40c9a8c74512ac8c11df14b8db886fc5baaec99ba8c5f52241"}},"inclusion_delay":"9736494578301327113","proposer_index":"9734842099379610281"},{"aggregation_bits":"0xb591c7026c7b65faa259f85e7dc280536c4c3d8e5acea48b187738801c8dd005b06fce664f6374e59a294fa3c3be50c3bd7e584afae8fc1dadef4949f1e3a84d4a1f594aff9d2cd295ec1a3bef59b4e44d8eae6b116fac2e521b5c9823e4de28f8a621be8546c39c275a86fea064d22e819d68130b7f5bc0ca9c86f5a35fa37bee2dc1561893c8bca847ed02d8a7811dc3b3f58284b4144d00efc24cf05d24feaedeba7fa99d487302417374ccb7440c384545ce51abf2eae2b9c3a901b9a686ad8243df46d145b2c1b785942ef761e5d1677d9a3cbc658635b0f10664c32987bce20e02a74840ff2eb9e337f4e777bfda8ddae5f1489e790a020f4aec79104701","data":{"slot":"9738147065812978537","index":"9677005161025862023","beacon_block_root":"0xffc1458627c5708d04a5b864cb1eebb6e6938ecf725d764531fbae8399d93803","source":{"epoch":"126936419","root":"0xd97f5186e72db2031a1fea0d240dc21cd98d90ab06cc24d1d5f827f3e517caed"},"target":{"epoch":"125782172","root":"0x4c462e86a7f3eda0d9b0551219423debff9f8a174c80192ee8ffbca4035d162e"}},"inclusion_delay":"9673700190297526471","proposer_index":"9672047707080842343"},{"aggregation_bits":"0xd52b4d3dbaf7a40d418ef27fc28e52b82561d85b5359be03d50e4bc7b1276beca03fda09e69b7f51d706d89165eb4db41e24002dbf87efaee838de4387e8c34137fed53aa45d36ba79e3c8b66c2070f0f5bd565727c893509eea93f1b55b4a9a067a40a84048e8475dee420609c0229c7625d0fbd46782ba5378928caee39187265608ce21178ad771fe78067c7e32388e7ab2ee8e0188bd4667d838ea97a974fe10722e3db62022843463aa2d44dc9ccf0a3bed8f604845ea0e10d4c9193ad93567b477d253bccc736cb475ef5cdc93896a16035546bf004c88247d50cd795d9a8812fca68268523a45a611d24f5907e215b32bc7887524849048b167a86ef401","data":{"slot":"9662132803485770279","index":"9667090257430789959","beacon_block_root":"0x72882286e78aac2ac4362469c15366850ba6883bb9116ba243024435b81e8543","source":{"epoch":"124243176","root":"0xe44eff85a750e8c783c88f6db688e15331b882a7ffc55fff5609d9e6d663d183"},"target":{"epoch":"124627925","root":"0xbe0c0b8667b9293e9942c1160f77b8b924b2848392340e8bfa06525621a2626e"}},"inclusion_delay":"9703444901082742664","proposer_index":"9701792422161025832"},{"aggregation_bits":"0xd106ddd3711bec162cb9adfd21ec7c9e096456d2b2bcaa24a93454a61febd875fd67cd8230a306bc75c98e3406901cb8e324ab882f7f0c83943101e31361693df792c739a3cbd6c5dbb352f97293261ce4f63ff2fc673f169b089d143acc96bb21f4271c67aecaf0ec1ee9a97dd24254e07614fb0c1b9eb1af5d5bd593f2c1ab7bc49ed0990b6e4d7720ec38aab1b469f8e18d66b4629fbdfd27585cdd4ab3dc9cad2000a810be9ee198475edfc0cf7dd5fd1e7d1c25e87e31af604e6d903304494afa9525c6866be107ff9e3fab873da872b26440c6047ac192115cf1e90b85abbd0cf6f24376148ce99183018bfd8d80d9984d7b15e447ca70d7acfc296d2c01","data":{"slot":"9705097384299426792","index":"9696834968216006152","beacon_block_root":"0x1a358c86a839f9528581e15bdfb4f4199b6f9af7e6f48c8b0ced84205d4fa082","source":{"epoch":"129244912","root":"0xf4f2978668a23ac99bfb120538a3cb7f8e699cd37a633b17b0eafd8fa88d316d"},"target":{"epoch":"128090665","root":"0x66b97486286876665a8d7e092ed8464eb47b963fc0173074c3f19241c6d27dad"}},"inclusion_delay":"9693529997487670600","proposer_index":"9691877514270986472"},{"aggregation_bits":"0x7d5af774448e5a7be614052ac37da18bfaa35b317e38bcd782730ff97f8b4fddd377f36dbe9ce89acda39a93706e8cf5c0bb71d8a75fbe5f2e2dd5a1d352c75f1fdafd7c340941e7132b59ba3662989ba699d9b2be41f2c6318c48b44716b8cc64b5c117c1ebca9730f975cc4a848d322112a8118f466cdfddb016f0540cded947d641962d1b2bab97cda9cc200a7c1d369e972aa3addddd521a4587004283fd121a62812cd2533f0ba8b4545441cb89a66d3ab07b0bdbdb6fee4b795eabc4d3871869084d7bf91da9786b89251d0c2e37e378704de2784eafcb4df6a57fd7b8ca10e0ef614ba17c38856aa6c5b1c5fb467ecae85f058b295bd8ea82607c735501","data":{"slot":"9681962614970881704","index":"9686920060325966792","beacon_block_root":"0x8dfb688668ff34f045134d60d5e96fe8c08194632ca981e81ef419d27b94ecc2","source":{"epoch":"120395687","root":"0x62e4898526395a29ac03a1d13f397c59aef46e0f3d748f8ae9201f8ce5f4245a"},"target":{"epoch":"120780436","root":"0x3ca29585e6a19b9fc17dd27a982753bfa1ee70ebd1e23d168e1e98fb3133b644"}},"inclusion_delay":"9617515739455429638","proposer_index":"9615863256238745510"},{"aggregation_bits":"0x9525ada1708c2c84f555dc645180a212c10e05f7559f26089fff677fc92215b5cde9b7310025af9243f84b6aa1b9f632b615c30e76029c296ff7a761f04e0331d44a45d1f0d1d50702bef7e5d384500708fc43b8f5a946ebd8de01a3e417b9a59890d2ae197bd1fa4b30bcd8aebe0dcccf9f0ad1a096f3056c1d36069d2742c582320a9618ac4ef51eeecaba0157804d04878eeb3e21acd78b7cc4e08e933fa40d4dfa9d363b689e57d50a71f5cc12cb0869ab71e686fc0633cf10c143f60f40ac78d11803d8d4da6e3a540f1ffe3bf15c1733fb6f38aee2c8c5ef0519bd2fd36b55d80c32da315e9a7c9d041ad94fe18283a79527a24f3040ff322590dfd2eb01","data":{"slot":"9619168222672113766","index":"9610905802293725830","beacon_block_root":"0xfbec5a8526965450561bdb2cdc7f20c2e00c679ff0b9d55b582a3bceb8fbdfaf","source":{"epoch":"119241441","root":"0xd5aa6685e6fe95c66b950cd6356ef727d306697b842884e7fc27b43d043a719a"},"target":{"epoch":"118087194","root":"0x48714385a6c4d1632a2778da2ba372f6f91863e7cadc78440f2f49ef227fbdda"}},"inclusion_delay":"9607600831565390278","proposer_index":"9605948348348706150"},{"aggregation_bits":"0x0fed244d2ab3dbd6909c1049bac27ddfdb8f336e565a0b792931674f52ec5ba51cebe3d80e548ad72264c94cdd086ce69d75ef7e0ae749cff57ad70d71fd46aba257020f2d77aab91d71157ceaa80cfe06f1d9492b4d46b2f3c61d38752f585b2de145b97b0ddfefbb251de1254eb70b203df0d18a27bc8899723ad902b1fcc8943f9b00a4231c5eb4b63be3d6195beb8df4ef1c97b9106f2bca59962214dc95712db0f43c5fa720e811c5ea40ae04dc0b1385832025d04afafaa8deb61b0935a0f91aca2cbc0316aaaa63519b63f83f03e6b497af901a9643ff9cec5877758ba5cacf531c40179989b6ddbf20c991c9b2adc8483750db1b9b3aaa252682879f01","data":{"slot":"9648912933457329959","index":"9653870383107382343","beacon_block_root":"0x0b91f385e7e7a6516d4e5ec45e9a0aee3dbe80cb6b57b173b20b60778b254099","source":{"epoch":"122704181","root":"0x7d57d085a7ade2ee2de0c9c853cf85bc63d07a37b10ba6d0c412f528a96a8cd9"},"target":{"epoch":"123088930","root":"0x5715dc8567162465425afb71acbd5c2256ca7c13457a545c69106e98f4a81dc4"}},"inclusion_delay":"9637345542350606470","proposer_index":"9635693063428889638"},{"aggregation_bits":"0x7d5657d98f41f6e80ba3532f321799ab9684878990dbb8969e931591572ffcc5fe2dc8df68a6197b2d3c897ed2b2bde3088bfafb75d5dd78ac62be8384cc2d3bfc36efbf228137b8ca5b432da19d962d73d9b85d6c086c29257e17d5ae76e3ffd34f9682ace8e22a83998e627fb2a873bc48715453aca990e3e5f779661c8bdf029e074e559fef81901719f29337ce605c41aaa2918fea9d8d02957f16079529f0e72134330e9983dc069584aed402f3bc0a386c00637f68b60d3beef662cb52ff672d69bcd89373b8a628fa94fb33a0b4de1c879abae3f72db83890455ba17697046e4ff749bd2a328d5d3685254654aee3325ef7e8ab5c1633753df32dd44d01","data":{"slot":"9638998029862257895","index":"9630735609483869958","beacon_block_root":"0x1660a185a60add15d7f70324f0152a2595e872c76451eca1321c116b7c71472f","source":{"epoch":"121549934","root":"0xf01dad8566731e8cec7135cd4904018b88e274a3f7bf9a2dd7198adac7afd819"},"target":{"epoch":"114239705","root":"0xc606ce8425ad43c55362893eb3530dfc76554f4f088ba8cfa2468f94321011b1"}},"inclusion_delay":"9574551154346805829","proposer_index":"9572898671130121701"},{"aggregation_bits":"0x67cec3ff12043fc699700044ee3da94073ad6240a16927d4f1c6d086b205062de8f59c3ab89a22fc40509e4373a53714c950a75e13baf7ab683cb883dec3e457b18fe0d77734a528a67eb3e4e6fa6239ca69b4611a877b17e945d48f0ac1574502b321166c24e0f18c094b8afc7177d13ff4f9fba4afd15a7333230068705976e7dd8edc285e24a04d2a0d7270aeff8e21a3ae5f3bb86b5fa1b9c1ca5c8c3831a0897d64b034f3305a748e7b6fab9b435083046dda90d5e7ba9a98511ce576494792eac92a56412c0ed5205bd7768656f4c577199026296c3c946bc771f371cd342c7a21deb342fb24a811d10fa93ca4b6f7b710dbf84a6130c56afd4de893da01","data":{"slot":"9562983767535049637","index":"9567941221480069317","beacon_block_root":"0xec48c2846544024f3ee857955a653696825b4d73751cfa43fe481625e6d17fc6","source":{"epoch":"112700709","root":"0x5e0f9f84240a3eecfd79c399509ab164a86d47dfbbd0eea01050abd60517cc06"},"target":{"epoch":"113085458","root":"0x38cdaa84e5727f6212f4f442a98888ca9b6749bb4f3f9d2cb54d244650555df1"}},"inclusion_delay":"9551416380723293444","proposer_index":"9549763897506609316"},{"aggregation_bits":"0xc5b422efb39626fc202f0136e61985efe6a27c64abe9b4bf045ca7c6392209454a77a848ce7cbf56390dce2877f3c61117b8b26b28ad37879304d9dda7e2c1d7cfea6515399a1e2e5159e4b9f58cf6aa8751d813cdc0119d77bf9d62e195e8e12c88fb08436599a4a5bb290921cd7f8d60232bbe3d20ac2701aec2a690d828a9537a759ad57ed373f1c12d7129d17e05e032ebbc2a02c8059774029a8c57d5017229a6038f050683fe9bda6d26557f6d4abe09cb9a9478025558cdeb1f2df2707d95d1a594daa9e149d9bb7694a61d79a1169c7ab51cd9cd90fa97a1b9cb213055ead833977ae9681513d0dbef61b134fdf135ac7b4d7422b66890c49552df9a01","data":{"slot":"9553068868234944868","index":"9597685932265285509","beacon_block_root":"0x94f52b8525f34e77ff32158879c6c42a12255f2fa3ff1b2dc63357108b029b05","source":{"epoch":"117702445","root":"0x6eb33785e65b90ed15ad4631d2b49b90051f610b366ecab86a31d07fd7402cf0"},"target":{"epoch":"116548198","root":"0xe0791485a521cc8ad43eb235c8e9165f2b315b777c22bf157d386531f5857830"}},"inclusion_delay":"9594380961536949957","proposer_index":"9592728478320265829"},{"aggregation_bits":"0xcdaf38176dfd89ac60eecf19cd3b197335f66b19e42dcdca8a92a8f81f392a159f65a4965039f211739508436a334af5f7c6969d55c0b2608da9a1008bf04f0c31db0dcd651cd295ce044a980c848a51d95e2ff6932318854ea123d9e8871d9fda5c603fe18ee615443adcd43bb5d47f4d13c1763391b92dd5cfc654d7670eaae755a78e629685c02399de286ede24337945da39d71e2d1935c225f5e09c223a06cb418931418475d0ae75f324a3c97200e02710ff63545c3f4ab16e3161804254ac7536b5760448f3499cb999b5eeeb7a441b3cc1a4ac3b17c38240c445db6864648fea1172a92d26e1856a8c659640d49766d15bbfb60067adcb644b8cc0fe01","data":{"slot":"9582813574725193765","index":"9587771024375246149","beacon_block_root":"0x07bc0885e5b88a14bfc4808c6ffb3ff93737599be9b3108ad83aecc1aa47e745","source":{"epoch":"115009203","root":"0x7982e584a57ec6b17e56ec906530bbc75d4953072f6805e7eb418173c88c3386"},"target":{"epoch":"115393952","root":"0x5340f18465e7072894d01d3abd1e922d504355e3c2d6b3728f3ffae213cbc470"}},"inclusion_delay":"9941402591659439502","proposer_index":"9939750104147788078"},{"aggregation_bits":"0xb76fa8b5cdfc539ed13b96fdb0d6b5b5be1fb74aa35597b97248cf963a70d0b306846b33c9dabfed0070cd4921f2916cdbde6503927f42363d73077f558df6108794c4423ebbef8e5bbb4ce465ef7c5d5854383cae41c160abeefac460b0af6c4fcf91274c28f2badc0bd79e106ddef1a7403747ee2fa1743d7b560c6434658aaf62a5a747b2e91123740edc02c6b94de99912d53588248d245325ff1358b25ab0c4a16d62682ff7f7a0ce1ac1324b22663d47767ec1db27bd494078ff913bb6b9550f8731859333ed0b045a8d6c477e803866e74ee6945f1bed9986eefa077db44a6223acc5cf7862ea66fcb7e29d0e1ceda9fbd0baf1e5f71f7fedbd1a1b3e01","data":{"slot":"9943055074876123630","index":"9934792654497735694","beacon_block_root":"0x5c9ad989aeaf5e9594d7cbf1d5bd67be17bc28d8550e9cd44d438c7a86d4797b","source":{"epoch":"156946833","root":"0x3558e5896e18a00baa51fd9a2eac3e240ab62ab4e87c4a60f14005ead1120b66"},"target":{"epoch":"155792586","root":"0xa81ec2892ededba869e3689f23e1b9f230c824202e313fbd04489a9bf05757a6"}},"inclusion_delay":"9931487688064367438","proposer_index":"9929835204847683310"},{"aggregation_bits":"0x71009253786a41ff13fe072e5245fc469d23a8b82097922b2c76d9c048a047b2e8f661d44fec1483f3dad8e7cfee213070b92dc0586d90abdb6d765dc4ed77756e58f4b3edfc3a1ca2274745997ebaba9a22d64487442cd8047c4c64790411890a92663ce489f8e721eccb6f270b743fdaf58ae838e0521acdb60f998ca77f4489f71f273259ae374b3d6dbccda56070722d1e994253442deb7a51766e5482469c79ea56c4b88e728ada227ecaa23dc630bd603f81db6a823b586a1b84b34b71765f861ac9dca4fd29f4bc42d36cba4d1da5fe618ba06868828d8d26bfedfb0583e3c4b9efc792004a809ddd6693a0edc85dca0cf0ea0e18e51d4039214737d201","data":{"slot":"9919920296957643949","index":"9924877750902663630","beacon_block_root":"0xce60b6896d759a32536937f6cbf2e28c3cce22449bc290315f4a212ca519c6bb","source":{"epoch":"160409573","root":"0xde044f8a2fc7ec336b9cba8d4c0dcdb89a7f3c7016606c49b92b46d5774326a5"},"target":{"epoch":"160794322","root":"0xb7c25a8aef2f2eaa8116ec36a5fba31e8e793e4ca9ce1ad55e29bf44c281b78f"}},"inclusion_delay":"9961232398849583630","proposer_index":"9959579915632899502"},{"aggregation_bits":"0x4d0f72cdb307a5fc3ea909b0b107048c790075266ed000257096f7b8254f7cab0538540e8b5c6d5037155d1b0e75d86cd48bcee380a9b327fbe60ead11c79d098fb86438aa39f95331735f0a0fccfa1d2722abeb754d01b6028ea0878a70cf729d18918eb9aac05a903020d5932ce97573a64fa7e8296b1733d2fa509fe32a34dde7cc5f0ab86a7d2da5cd00749ef66d3af32794d815736d322d41e2cddc1cd27524e9c2671c94cf5d7b01b61a22f833325ec42b9a2acb9422b95acf00364ebcee2866b836edc8d2389bff7941c64df32fb10a134b44d3811d90e406340d9d8be05a4c31fb14837a60bbaa5da627107ab8c9fa78103f7f61a9661fd6da7608ca01","data":{"slot":"9962884882066267758","index":"9954622461687879822","beacon_block_root":"0x760d208a2e24e75a15b4f4e8e9537121cc973400c9a5b21a283562174a4ae1fa","source":{"epoch":"159255326","root":"0x50cb2b8aee8c28d12b2e269242424887bf9136dc5c1461a6cc32db86958872e5"},"target":{"epoch":"158101080","root":"0xc391088aae52646eeabf91963877c355e5a33048a2c85503df397038b3cdbe25"}},"inclusion_delay":"9951317490959544270","proposer_index":"9949665012037827438"},{"aggregation_bits":"0x4797c2e76408c81b9d7e539d8a6604673867807756a716e59d1570e245c70e6325ea40707765f3865efd8a78aee14372e4930075e6c62130383031b57421f506d3510251f9aef3a33f7e0b9745940e6bbf534717096ab3aac5601f981f47419ad2cc6698186be585dab0240958ed469f1f1fd34f0e10935dab56072890f71dbd0a0e25e573719904e0f8d901d337cf8e4cc960697281cf1f12b6c764c346f54b0d482191f5a772adf9290bc85ad5d2b3d4c5fa0ec4d1f1122d1c88aca8925287509f3708301b064d2e46a2d860c27a856d9af10d81d09db12eb8345406c45d42c331c90e0aceaefb64deef6886e27e4a80a9fe3614ff0cb9b3d4023d75bb7b3901","data":{"slot":"9886870619739059501","index":"9891828073684079181","beacon_block_root":"0x4cf64089ed5d0c947ca4485a53a37d92b90a0facda70c0bcf36167d1b4aa1992","source":{"epoch":"150406102","root":"0xbfbc1d89ac2348313c36b45e49d8f860df1c09182025b5190569fc82d2ef65d2"},"target":{"epoch":"150790850","root":"0x997a29896d8c89a751b0e507a2c6cfc6d2160bf4b39363a5aa6675f21e2ef7bc"}},"inclusion_delay":"9875303232927303308","proposer_index":"9873650749710619180"},{"aggregation_bits":"0x35ad23ff9b32c974264159af834b9061b166ee1965338e4268cbd4225264a12985087eee1992ad6a53074a00a99cb3b69bb9a6e0ddd0f09c0400597bb260b5dd8d34e6d3e3f0dca38a5cd99047cb98d85f6bae98cca7f836131a4e34fc1af6a9fc70b4a9962fdb60a71850a880555feb44ed52c8c6912645d1c3ef91e1272d6adc2a99bb83474883cc6bff82ba4846258cd4218ba123620524528d96591910b6cf81f8f1dbb630cec7264a8e302ea78c6ecae584209dceb1fadbaa082e6876c82ad2c87a3a5fce69988a7f38239af1ab5898d91cb4fa615a43d208234ec989dff2b77a4f3887cf0cdda5a663604aa787eec307a21cc2a85d21fadf2ca814365d01","data":{"slot":"9876955716143987436","index":"9868693295765599500","beacon_block_root":"0x58c5ee88ac804258e54deeb9e61e9dc9113501a8d36afbea747218c5a5f62028","source":{"epoch":"149251855","root":"0x3183fa886ce983cefbc71f633f0d742f042f038466d9a97618709134f134b212"},"target":{"epoch":"154253591","root":"0x412793892d3bd6cf13fba2fac0275e5b62e01cb0e176858e7251b6ddc35e12fc"}},"inclusion_delay":"9918267813740959821","proposer_index":"9916615334819242989"},{"aggregation_bits":"0xabfc1b0377ef367ee6a5b4c02b693edcca6d01bd3e26b079e203485c6a69e71f6e207b05bbc3e32e30b088aab76c06e29a6ed091ed3db043dead3e07227ff61ff350b00fe9f4801cd525d29baff7ce22873fd872826e59a02800c18a6d2603500189632ffcb9c55517cb97918b21f168c9d8ea94bc00494805bceb5e2aa00bc7b8c8488f3dc9182a9e130acb0d630023378f552fdc2fb99986c586f937d7fdc19a601a5e71528bb8ded7a45091dcb4b76ca64b572336e2a52ae4c01bdb24b48e83c13bfc1f3bd7bdf05a5f208e0e1275872b58b0f0d285cecdeb69e73503e2a5bb393d941f1d665fe2177d8381157a2facc9ab7facb0e835ccbc87047245295501","data":{"slot":"9906700426929203629","index":"9911657880874223309","beacon_block_root":"0x676987896dd29459fd807151683987f56ee61ad44e08d702ce533d6e78208111","source":{"epoch":"152714595","root":"0xda2f64892d98d0f6bd12dd555d6e02c494f8144094bccb5fe05ad21f9665cd51"},"target":{"epoch":"153099344","root":"0xb3ed6f89ed00126dd28c0effb65cd92987f2161c272b7aeb85584b8fe1a35e3c"}},"inclusion_delay":"9895133040117447437","proposer_index":"9893480556900763309"},{"aggregation_bits":"0xdd6cf833c4d9ff31ddc1a6fa02dc28536f6c1cf3b006a48e03b7269ced08090aceec5306c52178264de0d850b817f277754e97145c87304dc3195489850ede878d308febe3562b3e604714cecce2dcb1e80735444723d3a81ef89866c63bfebf2fa7b00463acfc80676be70a1559fb91938a628a7d9fee317d6908ec5a5a6a16bdadf0a1c859ebd3c2986808165d0824be1204c54cb700cd202d0c2987dcb87f1aeb895cda02d7986cd8d1369f22b19d43bc46f9c7de7d324103cbb5d9e890eab0890425a57f8f88675a01c9ebd2d15aa22330118648740cc1bfd18a993e3d38abff691cf38445485b6476a8231febf346a3584cf4c950fa56b5fd37adf329ab01","data":{"slot":"9896785523334131565","index":"9835643618547015051","beacon_block_root":"0xd65a79882b69b4b90e89ff1d6fcf37cf8e71ed0f11192b76078a5e6ab58774fe","source":{"epoch":"145404366","root":"0xaf188588ebd1f52f240331c7c7bd0e35816befeba587d901ab87d7d900c605e9"},"target":{"epoch":"144250119","root":"0x22df6188ab9731cde3949ccbbdf28903a77de957eb3bce5ebe8e6c8b1e0b5229"}},"inclusion_delay":"9832338652113646795","proposer_index":"9830686168896962667"},{"aggregation_bits":"0xe35648291310d664aa54ac4f7df5b1bc03cfd8809085be1e6af672db096222d1e20547af294de300048e0b3099c3ef00c7748a10b8e8b29e13cb07994148d66380511207b8e4a99e7e0a564383b4b831b474e0703387e0947b914b1992de0c4ef453d704c224dc5b30ebe2f2d28b2cf6b432f26a10ac04f9e7ed7e95756468c97954187bb5fd08107fe52c48e3a5b104cbf911085672a3834cb6125f888e11854ac0418c5ebb5da0dc8febd9a2593b0db0325aba9115e7852384b89e716a0eb004b0f0952311591551e54528ea426c88e00edfac4f64be14f29585908e97e7e1fdc7a9e3dfea1e0dca89381f6954d5c3fe335636f001b711406032f43837764e01","data":{"slot":"9820771261006923307","index":"9825728714951942987","beacon_block_root":"0x48215688eb2ef056cd1a6b226404b39db383e77b58cd1fd31a91f31bd3ccc03e","source":{"epoch":"142711124","root":"0xbbe73288abf42bf48dacd6265a392e6cd995e1e79e8114302c9888cdf1110d7f"},"target":{"epoch":"143095872","root":"0x95a53e886b5d6d6aa22608d0b32705d2cc8fe3c331f0c2bbd195013d3d509e69"}},"inclusion_delay":"9862083362898862988","proposer_index":"9860430879682178860"},{"aggregation_bits":"0xeffbe88dd8bffeffdb53facbec77d4766fc84524d4632270367666bd60a711c003fa4ebffd791aefa0739bcf5d3f960c6b6c4bb26c30d3f998266025b4c01c4733bd0084ae684aa1ee5e4c041100fad45977819f486e4dde7de3cb7836f2ff69d7a990b29d06e5ee84171c4d6ebd08305ae83ee248f930571b890ad44be01ae76c049ae70571cc2219f19874384c2672856068056c4287f99dff1239b9caa71529bd5abb5337130c8b7bc08959d5f44ea655dfe3bad242b6f205a08a53e901619fddb49fc0a2b9b3418b14537eec5396f6167bdfce320fb465e020b64433903bccb827140bed4b037c3647196bc147c59e6dde811cbd5b4404d72d71e1265c4001","data":{"slot":"9863735846115547116","index":"9855473425737159180","beacon_block_root":"0xf0cdbf88acdd3c7f8f65281583654132434df93785b041bce27b340778fddb7d","source":{"epoch":"147712859","root":"0xca8bcb886c467ef5a5df59bedc5318983647fb13191ff0478679ad76c43b6d68"},"target":{"epoch":"146558613","root":"0x3d52a8882c0cba926471c5c2d28893665c59f57f5fd3e4a499804228e280b9a8"}},"inclusion_delay":"9852168455008823628","proposer_index":"9850515976087106796"},{"aggregation_bits":"0x69bfd02d24716c1511cd7b1a1ce40b05cdd77aefd56165d379a20861863f8a9ceda17c5e73dcf5c853411be0e2568651d94bb3e03010434df65a404a9db2b930e854fb4d2c9e1ba91402df8fe9d9d59b0b006b9da829a68676735d58a8de06ddb2b0c6a133b3e98b707010a8354f8bdee3f583edcfb6cc7ceb411d438f1d2934d8d03543dd798944791ebdc2e5f4fe2b9b377449e16ce549d8cb6ae2645e0f00e783196bdfcf8c2366597481845078194555e9e775f25703cc5403211efbf1fa594b7c20ac718ae1857599c225482ca16a87b7fb03c6b3c38dc07c0b11286486ad071aa91527d66b6c78bc3c2e3959b652d74dc108ed04be0e3717ed7d62203001","data":{"slot":"9840601068197067435","index":"9845558522142087116","beacon_block_root":"0x63949c886ca3781c4ff79319799abc00685ff3a3cb643619f482c9b8974228be","source":{"epoch":"138863635","root":"0x397dbd872add9d55b5e7e78ae3e9c87156d2cd4fdc2f44bbc0afce7201a36055"},"target":{"epoch":"139248383","root":"0x133bc987ea45dfcbcb6119343bd89fd749cccf2b709ef24664ad47e24ce1f13f"}},"inclusion_delay":"9776154196976582666","proposer_index":"9774501713759898538"},{"aggregation_bits":"0x971abdb6c8690aeba68fa0d49f9c0999e7ee340ab71f0a196e0e787215ce9dc8ef0b78714b76b2c1c641dcd5fa907e966c450457c14d799b85411f3b174f741b626592667c62cdf11557ea9b1d0fb807a5bd98d3e1c4216a3c7985eb4b89527449dc6d34fb839ee482f34b24528045b6016c236ce647dcb0c1e8bf0de664bd981d21ad2add4dee92703baf76848a01912922a58ad49284c383ac0bafae028339991dd53ecd0ce61c3b248b1930d9a179e1c1fe2e40354197884d5c89dba63a1e7827b275d41053a3c2bb87d33ab03b6e8513fa71518c236ffbcac5b96fd3c50d9852b34b6a32074980818fa7a85cf36c9fae3518190a8432150ced6983444b1601","data":{"slot":"9777806680193266794","index":"9769544259814878858","beacon_block_root":"0xd2858e872a3a987c5fff21e680306dda88eac5df8f758a8c2eb9eab4d4a91bab","source":{"epoch":"137709388","root":"0xab439a87eaa2d9f27579538fd81e44407be4c7bb23e43818d2b663241fe8ac95"},"target":{"epoch":"136555141","root":"0x1e0a7787aa681590340bbf93ce53bf0ea1f6c12769982d75e5bdf8d53e2df9d5"}},"inclusion_delay":"9766239293381510602","proposer_index":"9764586810164826474"},{"aggregation_bits":"0x1f9801db9817e13def4f47bb17dad724fab273b3a111e96cf243f35523b5925c227370bec504c685e6f75e7fa334c653852173672980b0fd9dec4ec6bb5c7b911659c4be31ec13960a188b80bc3b85febb706e77ff0131f217adaa14d0373f8bdfaaf2135955e1d1c32c3e9e5eb1992ca283da42cdc60babaca39ad3fa238f85096b0e1511c13f31be4b5fb763e3db95a15508ff419f4e7b010bb6d1cac95084c5ad9b04d77058aa84c045a59327fe4efab970d434de7d837a52211e2ceaf858f106cd62d9382c488a26e21c3606ccb05290713c33f4531e75bbac5544376e24b2d8747869a86a86ea6bca001a413d019e21ef45a07044185169f7aa7c915cfb01","data":{"slot":"9807551390978482987","index":"9812508844923502667","beacon_block_root":"0xe1292788eb8bea7d7732a57d014b5706e59bdf0b0a1366a4889a0f5ea6d37b94","source":{"epoch":"141172128","root":"0x54f00388aa51261b37c41082f77fd2d40baed97750c75a019aa1a40fc518c8d4"},"target":{"epoch":"141556877","root":"0x2dae0f886bba67914c3e422b506ea93afea7db53e435098d3f9f1d7f105759bf"}},"inclusion_delay":"9795984004166726794","proposer_index":"9794331520950042666"},{"aggregation_bits":"0x6d6b6293ee8cf4ae6f3a33991fe6f3aba1b0aeb35215f9972551258daaf2b501847561c4a3600521f1a40e87a34d3e5762db14c390cb204260d537f8483f5f00683169062b02f8c4fd5345d1776c5f65d64906347bc01bea4115dfb809c882eeb31b211c4711f834c68cfe1ec14da258ffc75bcd574734d757a039511c19fa061ccea67be1e54df6dec82dbc1cdb503841ce0954790de32927ff7c16720219b0467e0acfd869159fb1dc1c13fdd9b96065827d73e457f2b015d533b61a10fc3741347e1a5b74e2c51c2bd933f556575f3f921008006caa2138df993ad80c1848ca1e047ba3e3cd65d241432cafe9e81870cb64f5e14148fb02408db0a423182901","data":{"slot":"9797636487383410922","index":"9789374067005022986","beacon_block_root":"0xecf8d487aaae2042e0db4add94c6763d3dc6d107030da1d208abc051981f832a","source":{"epoch":"140017881","root":"0xc6b6e0876a1762b8f6557c86edb44da330c0d3e3967b4f5eada839c1e35d1415"},"target":{"epoch":"181955511","root":"0x828ce08c33b13b1222518d90b630d1ffde2cab904f9094d7b3a7bd37ece3ebf4"}},"inclusion_delay":"10156225504317656659","proposer_index":"10154573016806005235"},{"aggregation_bits":"0xc33f6d0d299421808d4ff6c4968d3615f8076b156cc3968d04b7c2fe7f208abf0580b9adc2b2b2d74482c29380049a96cb1c2dd84104dea5c74fb9bb74c1c33ac7deb1e030ecfb1dc46acf4629fbd463fa8d9274277085bf5820a00ff31e1b962ea4c04697777f5326da095457174ddc28fdc91468b6679535ba7630a021fe2ae88cde6e2ed287f48e7fec8b645c8bd4a29fc41f5fe2254cff99de5351c5f97a670899f91aa978fccef40f38d72763fa966521f90bf1937ee653f86f062c0b0e53f5ba6e0bb498a4d0d680eb1cfe90597f618d3a5e92004be0bfdb0f7bb98008da5a9b8f009f608d245be6f3619e93acc26bca10071fee05f351f8211764afe501","data":{"slot":"10144658117505900467","index":"10149615567155952851","beacon_block_root":"0xa9ced48c7348fa9b0cd75be75d42fa99eb32a9b4bc21e64b0faa44c8a1a55a0a","source":{"epoch":"180416516","root":"0x1b95b18c330e3639cb68c7eb537775681045a32002d6daa821b1d979bfeaa64a"},"target":{"epoch":"180801265","root":"0xf552bd8cf37677afe1e2f894ac654cce043fa5fc95448934c6ae52e90b293835"}},"inclusion_delay":"10133090726399176979","proposer_index":"10131438247477460147"},{"aggregation_bits":"0x91948c518a76e0fcd86363ae1ff0030ba864fff922e1b4f2b3bbf434eaef81c6ffcea4bfbc54f07771db93eb8ffb4b821dbc9a9df2820b98365fd13505e247e8bdb318922a24530451481c17229f46d0ddb5ea83653fe7b72ad8f3a23843ae7a5098127f101206c6137adbc56aaf7008a42d48733a39d2ec4bcd3514e9bd8ee17fad2b5097e87403b6ce9eca3bba447f7a66c5b0e9dd8a94cd4d1093edcebcc6648a101134bc1ed579e55f4e81d806c4897e3f52ab7e8c6b0fc4cac703c3cf6041c3c96615901350c7da23491527176eca594d0968087ca8add17f78a1a554f3fa042f897d57bf3abf20277bc5360e7174004ca08f2e91eb32704727efcaef5701","data":{"slot":"10134743209615861107","index":"10179360282236136340","beacon_block_root":"0x517b3e8d34f746c4ce2119da7ca3882e7afcba70ea040835d79485b346d67549","source":{"epoch":"185418251","root":"0x2b394a8df45f883ae39b4a83d5915f946ef6bc4c7d73b6c07b92fe2291140734"},"target":{"epoch":"184264005","root":"0x9dff268db425c4d7a32db687cac6da629308b7b8c327ab1d8e9993d4b0595374"}},"inclusion_delay":"10176055311507800788","proposer_index":"10174402828291116660"},{"aggregation_bits":"0x0bd49435f67d9fec3587a18193b286b6be09c85929e61c821dfefb03f10ee2d226f4a0508a32a472737f54d1b709d376a5cbb56dc04f9776a0d8c0582030f023ce8a58cba0248d222e03b6aa43f291c941aa1d233f74e62d11c68e1fb9f91b104d69856862f54bf77be87ebfc0d9aae24702b30d50048de2ba22b04f7ea2a9744340df620246209840966fa1b40dc66ff2c9f87b38447b08ebea9fec8b0540f3b27ac69e89dc85ef4424e0b0166ee9fbbb0a1184ed9180356bf7f390b7aee5264cfe37b11694cd8c07465e57b07ec0a891a8e2476230033c37e80699e66a5eed825a28dd5b4caa69a48a46c0862b8b4a648193f9cf901283ed375f09109ee8d301","data":{"slot":"10164487924696044595","index":"10169445374346096980","beacon_block_root":"0xc3411b8df4bc82618db384de72d803fda00eb5dc30b9fc91e99b1a65651bc289","source":{"epoch":"182725009","root":"0x3608f88cb382befe4d45f0e2670d7fcbc520af48766df1eefca2af1683600eca"},"target":{"epoch":"183109758","root":"0x10c6038d73ebff7462bf218cc0fb5531b91ab12409dc9f7aa1a02886ce9e9fb4"}},"inclusion_delay":"10100041049180592530","proposer_index":"10098388565963908402"},{"aggregation_bits":"0xe3129da3e65b6913b2b0784f55cfdeae8c20b6b500a502a8085bff96478c99b6385ea4970408a33cd4e9523866df2bd8638e867b1510bb004445961d836d810e263a00e33638192a4f325398be5dd615f5cdcbd9f89992e5cf9522ec558a6eb9994e24d9aa7516e69022a6a3b33270b8a48f1ddc38d7179b0b8f92319fa1ac74ee240e12966043f2c9ad5db595331991c414bbbecd8a0926248d8e8244d80fca04d98ace991fe2419a596ee906a7a0b165868461d03436ed3fd2a87823e35ed36f8a78acfc05b0cbc18bc1938c0de7f73a5cac444066b98049e22e2ed889fec2a70f013dd47c38af5377d147896a2143a4acee64ef035a46b63c87a0fa1586f901","data":{"slot":"10101693532397276658","index":"10093431116313856018","beacon_block_root":"0x32330d8cb253a2c19ebb12ab786eb4d6bf998718f4c9500523d23b61a282b576","source":{"epoch":"175414780","root":"0x0cf1188c72bce337b3354454d15c8b3cb39389f48738ff90c7cfb4d0edc04661"},"target":{"epoch":"174260533","root":"0x7eb7f58b31821fd573c7af58c791060bd8a58360cdecf3eddad649820b0693a1"}},"inclusion_delay":"10090126145585520466","proposer_index":"10088473662368836338"},{"aggregation_bits":"0x477fa707daca7bfc7c2fde5ae55e16bf7e0f8366c29514af8796c9c8b1ed8e17864e8ef68e8d8819277352df9542bb84eaf9f8eb9f324d9a751ce7dd030e20dfcd56fa23f1a7a273950fd1336ae173da37a22549b61cdf994017968efeb27218dc9ff3d24d7142e954c5aa8740647e576c72a8717e00b1f579c2959055f68e0b9af6abb0c2220e74244059004a5bf04c0eaa33f8c3444940cbb9db199a440d9f297ec1ec33b313abe26baba113af8e44d79693a81766a75ac19303535cd8bf18a808f9b310b68fbe8d755d8f942baec027c362e20dc621e6a882b2dacabb0affc4f6fe249b3dee77d91fab6acc36382526537c25ea6385bf65eebae06e698a8401","data":{"slot":"10078558758773764273","index":"10083516208423816657","beacon_block_root":"0xa5f9e98b7119de5e5d4d7eaf6ea32fa5e5ab81843a7e456235d9d012c0c701b7","source":{"epoch":"178877520","root":"0xb49d828c326b306075800147f0bd19d1425d9bb0b51b217a8fbaf5bb92f161a0"},"target":{"epoch":"179262269","root":"0x8e5b8e8cf3d371d68bfa32f049acf03636579d8c488acf0534b86e2bde2ff38a"}},"inclusion_delay":"10119870856370736658","proposer_index":"10118218373154052530"},{"aggregation_bits":"0x4b7b67ab19b293674970da12769cee145a2a54deac0080a4cb46c520d9a0314a6b9a976a4cbf5191b7a0c23c77186a884dfb76c805e63e5da3119b7ef7a72a332e3eea80a7a86a0da75accf4d446b33e8eeb748465357a67063514ef6eafa4236b81266c3b527356e03d15316476c317f118642b8ef9c5fe85c7514765f6ff684f84497abadac0926356c93fbb665438bc50c57362244f2830b08f9cac499a47c3a3d0099c3e1b131182c170c8264324c1ed153c34d306471a12d3c77c67b8d994f737d3e325e50a1c3b1c2c40c8bf46e2ddc73c11f4b81c2ab7c7b92b4f3c37f743b6160f9db76557377cd404beaeaf04cd3dd3274ea0f6a15180dd8be8d1de01","data":{"slot":"10121523339587420786","index":"10113260923504000146","beacon_block_root":"0x4da6538c32c82a871f983ba28d04be39747593406861674bfec311fe65f81cf6","source":{"epoch":"177723273","root":"0x27645f8cf2306cfd35126d4be6f2949f686f951cfbcf15d7a2c18a6db136aee0"},"target":{"epoch":"176569027","root":"0x992a3c8cb2f6a79af4a3d84fdb27106e8d818f8841840a34b5c81f1fcf7bfa20"}},"inclusion_delay":"10109955952775664594","proposer_index":"10108303469558980466"},{"aggregation_bits":"0x61e8fdbd84e7fa526aa505ab8ef8aeef550b9329b4d3d2d00657217f3c8aae365e528387bc75eed4da041909d65cf1d6bce0ae294189be0267c6cd78a1e9e33c71dd4544f91978cd9b5514791327c7aa14dab4301bb4cfe9ab05d3e03a4a264b915dd37affd213d997b140f5a38624a544a4f8f378ea35a606a3873c68d8edd0a94f8aeb879aa8e3aa2b887f4cde479a71684b06e231c2d2706b8929a7db7a93f9891a5b1f12fd2f11f0da9fb5c469313b25aa1f6a281cc8368520ecf5e166c204402071757f05f188c65d8581e74a9cbad6aca6b9b4477a189f96aa1f8780fdb56ff2885266d8ac50031973ac7ade179480fea90057c70ae7e6ca662e22fe4f01","data":{"slot":"10045509081555179825","index":"10050466531205232209","beacon_block_root":"0x238f748bf10150c086888f13f753caaa62e86dec792c75edc9f016b8d058558d","source":{"epoch":"168874049","root":"0x9555518bb0c78b5d451afb17ed88457987fa6758bfe0694adcf7ab69ee9da1cd"},"target":{"epoch":"169258798","root":"0x6f135d8b7030cdd35b942cc145771cdf7bf46934524f18d680f524d939dc32b8"}},"inclusion_delay":"10033941690448456336","proposer_index":"10032289211526739504"},{"aggregation_bits":"0x1312068880a56379409c80dd26461af992088fae92f38c63d3b8633faf69ac06bf94a3acda31f1f8c79ccd33d0b5010242c97b186abf2faefea6a47554c9c2af2ff828e6f533c1ce8c574f4c3c517538e2e25ce2dcfd87f355fd985c93d60b3d2d74496674770a5ce619235ebd7a1adfcae378718265889a73a62498ba77dc178e6ebf8972aeda64029bea3e15b0c61940350ae9dd256c80468342f11710bf2f7a13975e3087cc05b7f78e79e13b041f157126f98ea0036919522742d61986a534049f50ef1bcd90bc479ef10efdd12215de04838e2ebe8515dd33ca90bf5861b5a140c46d6ffa3bed3894f80ee20bca43ce549b88ea370e238d3565f51aad9801","data":{"slot":"10035594173665140464","index":"10027331757581719824","beacon_block_root":"0x2e5e228bb0248684ef3135738acfe9e1b91260e87226b01b4a01c8abc1a45c23","source":{"epoch":"167719802","root":"0x081c2e8b708dc7fa05ac661ce2bdc047ad0c62c405955ea7eefe401b0ce3ed0d"},"target":{"epoch":"172721538","root":"0x17c0c68b31df19fc1ddfe9b364d8aa730abe7bf080323abf48e065c4de0c4ef7"}},"inclusion_delay":"10076906275557080145","proposer_index":"10075253792340396017"},{"aggregation_bits":"0xbb810e75de0a0c279d7dc6f2cc21d65c8ad0b843d9f67155597b724099b68e9a6896aa6776525f5fe4290315ed519f57b23e17a808527f59a25ba7b8fd1f993573ff6c36e87d4e70f38ccdf5597cc3426fee2adfc2132e636e6b0583005a6ec1f786d6d1c651764b770ee6a7344edb0b0b47c209e980df8722e920c2b0a1e20aaaebcdba8c1a0b85f4ca1eddc29f9d3b490667c80cbd84a8ec356d967f5b791c2ee361e41a7316be922601a756c1cf041f062802df4b0777934d1953227490f01d3b4506ea1f70215cd6a26d0b66a2ac4c1fc18fe412cc708ff84a0b8350d218e1bf75bb6bf792c07aeaf1083f9cd4e770e90d42ca18a7a650cb7fe70b4eb0fd01","data":{"slot":"10065338888745323953","index":"10070296338395376337","beacon_block_root":"0x3d02bb8b7176d8850765b80a0bead30d17c47914edc38b33a4e2ec5493cebc0c","source":{"epoch":"171182542","root":"0xb0c8978b313c1423c7f6230f011f4fdc3cd6738033788090b6e98106b113094d"},"target":{"epoch":"171567291","root":"0x8a86a38bf1a45599dc7055b85a0d264230d0755cc6e62e1c5be7fa75fd519a37"}},"inclusion_delay":"10053771497638600465","proposer_index":"10052119014421916337"},{"aggregation_bits":"0xc95bfd656f5cdd1cbe0a5788854dcac8ddc22c457257423eece557973175015bec14b81182b7647dd5514971cb2a6ed36d1e31adfbd16f771bfaa5f64abeebbd2d9cc8d4e2c7f37166af8220106a15b951c6c30fd65a2469f8b7820ee10799eedffb0568e1946a8e2aa390667ab6b1f91d3541ceb92fc0dffc7ecac6000891493cee34b57c2a5916c4483cf483a08a30b9d10ea432832be8cab00748a7c034a0bb6282b535233b8e252fd9e1183b0a2aa43eb7b4eb6590fad942237d778ae08f765e732f617bb8644fdae204c2be8193af57c8b6c2ae3dd9e6fbee750f68c644c1f9d2baaabf335fc9f9701b9994453e7aa38df24261fbed57cf807cf2ecf0bd01","data":{"slot":"10055423980855284593","index":"9994282076068168079","beacon_block_root":"0xacf3ac8a2f0df8e5186d46d7128084e7364f4c50b0d4dfa6dd180e51d135b0f9","source":{"epoch":"163872313","root":"0x86b1b88aef75395c2de777806b6e5b4d2a494e2c44438e32821687c01c7441e4"},"target":{"epoch":"162718066","root":"0xf877958aaf3b75f9ed78e38461a3d61b4f5b48988af7828f941d1c723ab98d24"}},"inclusion_delay":"9990977109634799823","proposer_index":"9989324626418115695"},{"aggregation_bits":"0xebeb7346f2bdd4bb9cd9ec69b96d8f7732f6f93c72854d3e017444c3f45feb96dcccccc7c08cff9290359c2bca7e75a5df045f4a17a64dacd72d127c3e21a1396235cc94b277e9c14a82482d502f311b0975131b4bebb7d63ff2dd307d20efcf20472aae20dc03457022958eb5f606d22288d9f6471cea1dc499a59d0f3423b4eb153f235d8e29771d150df4645939d2e5706a43b6f7a7037c6ae12aec1b9c488ecf4ee7a588d3be347f481e744c809b59b3890535ac6a5c9116edd68d12af94dacfa78de6bd52bbf560a2e50b278e45fa7e032bebb0e3cbd2b2fd2abb61067eead286e1cb4c579adf764ea633d0698e53ba409c44ab18d2514782af6d292f2a01","data":{"slot":"9979409722823043631","index":"9984367172473096015","beacon_block_root":"0x1fba898aefd23383d7feb1db08b5ffb55c6146bcf688d403f01fa302ef7afc39","source":{"epoch":"161179071","root":"0x9180668aaf986f2097901de0fee97a84817340283d3dc960022738b40dc0487a"},"target":{"epoch":"161563820","root":"0x6b3e728a6f01b196ac0a4f8956d851ea756d4204d0ab77eca724b12358fed964"}},"inclusion_delay":"10020721820420016016","proposer_index":"10019069332908364592"},{"aggregation_bits":"0xaf8ccfd931624c38a08aa27b5f6b77fceef7649b1633f5710d847e21dc725c8b2100b1fd322a06b620e21cee28072499323c946bdb0b2ece50d6f95e6a926b4d80915e35f6fb8bcf69d5d6f2cfc813fcf4a752701932223d399147c0817c98fc84ac0574597e53f6c1de5c3010602b4b9d9f1c49bf798308beecc4dfb435f32aff07af63f592ef65d3168ccbb5b68f8e0b8f5342a695a162377cfd7249570a8cdd3e5150a1eccd02e7c228f78c4445dd49758c94ac6baf6e48c589c28bdbb40dc202a1ec192c3a87650ae19edbc0f18baf42a650f4d07b2012ef0a0b4a5564c49ba7dc135f258fd44ccb5296fd48d24112272dac2414b8e31424f03ab23d803701","data":{"slot":"10022374303636700144","index":"10014111887553279504","beacon_block_root":"0xc766f38ab08180ab99496fce27168e4aeb2a5878246cf6ecb80ae4ed94ab1779","source":{"epoch":"166180806","root":"0xa124ff8a70eac121afc3a0777f0465b0df245a54b8daa4785c085d5ddfe9a863"},"target":{"epoch":"165026560","root":"0x13ebdb8a30b0fdbe6e550c7c7539e07e043754c0fe8e99d56f0ff20efe2ef5a3"}},"inclusion_delay":"10010806916824943952","proposer_index":"10009154433608259824"},{"aggregation_bits":"0x0f84c53b8f5444dc6717ab282bf8b79d2cf851d017a1e3e662f8787f7b72c32bc718973ab82e291317d80c599b3b34e5111b4dfbd76d0c7718b8199c6b3198226a792ce4257f9e5da6e9c161b8547d53b241bee47167dd45d230b3688e40670c43f873cf944f77b50d1861542230a1e4e56aa364f91682234a55db4bf563e068d89120675092aa0313f2cb1e7a0966738cb4760e195ae108f815a2b570db1191558630d8a56d2088be804d37cb4583aa38d42848c14db2c3341eebe9a088418e1d942bd278950d5aa5f45c0f86a49c3800bb6a543b30eb15d38611a76f66f97bba1a31964cbf0adc55a7aa879894ef6a2edf997e2ce4e6b98605cd262e49b88e01","data":{"slot":"9999239530013187759","index":"10004196979663240143","beacon_block_root":"0x392dd08a6f47bc4858dbdad21c4b0919113d52e46a20eb49ca11799fb2f063b9","source":{"epoch":"9588004","root":"0x5c4f54780f61c41f71abf7796915b0c7bdc2358d840e5366e5c701243fe0be76"},"target":{"epoch":"9972753","root":"0x360d6078cfc9059687252923c203872db1bc3769177d01f289c57a938b1e5061"}},"inclusion_delay":"8665684985738576879","proposer_index":"8664032502521892751"},{"aggregation_bits":"0x4c31b3e70289c29bfd1ef1dcb56916ba48dfcc6577f25c017a066db2cbf7ef8a8ac61128204993f01872d22f39ef4a196282a31ba04a4b5dab98151e963da4eedab94f6ae09c3b61369f8a4413cb5002645ceec7bb3872857153a5ba582ace240e3b9a5556886e3516895b8b9dd85662243f9058f7fc71447bbe569f9821f4d376d229425015b802733f5cb1e668e96086a75aefff87cc59ba2649f577ed93131e2ef7f333e4bb370554acb5a96f8cecd267317d79447240bab32543ec079ad00034b7188160f2566c06ec358f621be12fe5dceba9eb673877d29af52c64465ffe997c68d0c57cec505886960b08e2457dbba31c3ddc439ac4b39a41c347ace601","data":{"slot":"8667337468955261007","index":"8659075052871840366","beacon_block_root":"0xf55725780ebebe461bc331d5065c5430efda2d1d3654993753d11d6612e779cc","source":{"epoch":"8433757","root":"0xce153178ce2600bd303d637e5f4a2b96e3d42ff9cac247c3f7ce96d55e250bb7"},"target":{"epoch":"7279511","root":"0x41dc0d788eec3b5af0cece82557fa66408e7296510773c200ad62b877c6a57f7"}},"inclusion_delay":"8655770082143504814","proposer_index":"8654117598926820686"},{"aggregation_bits":"0x56e2020f5eb22c95f7fc3efbb71bba775ee1ba403cb56375f5d865dc7922405a42481d439e2b5fb7fa4b1005054cd2cd4ea5ce6b8ba713b3992d22d2e2a4f11cac4c0bbe6ffdf59f2174205fb2aff6f8ea5098a3efdc719d59c5bf09d80adb56b54a81f2f0fe4b80861d7e3e17bc00b843116a20d6394e4d07e3f2c50542cbdc42f8cc5d689aedb151e7af78d11b7b649de46a4a229fe7c93890da949b2d642c02ce3559b9842c4d2bd022439819de5b9c5a3f8f383e7e0c528219d5116ac4f2ad054b1ef644b5f26c86492f22fadc6778e55786dfd38bedfde3cb9c4fe0ad2ddaf36b07f45b5919cfe362340016f75d6e0cf85f2ca685d887b550095d50916901","data":{"slot":"8697082179740477199","index":"8702039633685496879","beacon_block_root":"0x04fcbd78cf0f114833f6b46c88763e5c4d8c4749b1f1744fadb2420fe510dab5","source":{"epoch":"11896498","root":"0x77c29a788fd54ce5f28720717eabb92a729e41b5f7a569acbfb9d7c0035626f6"},"target":{"epoch":"12281246","root":"0x5080a6784f3e8e5b0802521ad6999090669843918b14183864b750304e94b7e0"}},"inclusion_delay":"8685514792928721007","proposer_index":"8683862309712036879"},{"aggregation_bits":"0xcc5861374d6036fe1ec66e99b4a426839fc0440c1ab4d71f1b42178e71c94713c10a269de8eb443ba317407d0ab603c85d9d51ef30b3c38e440d0c9c03cd93d7fa2da64cf547481c5e577746f9e814639f686924b09c130fde39f2ba325ec4e7defc126ae73a6a85d3afe9bd0a84f1ec7b90eb9be4b63b31ff36d1f947f4bb5ff455701399bc3f6679c48f7bfa30b6ce757b6fa110090a191e130148ab372999c304f6549791482c9f9d31add666abf5a20022249c276083bd47017e1980fc9e134230252e0035b73f1ad2cc21a25758b56435dab94b625495c763f6d343edbeaa11e8570b06328a7299631da4fe6aa180dad3eee596f51fd3f8bf1a84aadbdf01","data":{"slot":"8687167280440372431","index":"8678904855767017199","beacon_block_root":"0x0fcb6b788f32470c9c9f5acc1bf25d93a4b63945aaebaf7d2ec3f302d65ce14b","source":{"epoch":"10742251","root":"0xe98877784f9b8882b2198c7573e034f998b03b213d5a5e09d2c06c72219b7236"},"target":{"epoch":"3432022","root":"0xbf7198770dd5adbb180ae0e6dd2f416a852316cd4f256cab9ded712c8bfbaacd"}},"inclusion_delay":"8622720404924920365","proposer_index":"8621067921708236237"},{"aggregation_bits":"0x7ac259399225fd095d930c79cb442268dea729fd1210df5cec1353939441fd5a6e4a3b631874f79fce7b970f2ac718152d878febe4fe495d8cdb0bdec390cf5895dca9ec3ff45a6cfa5885c7bbb4346da659f13d4e348a29131cacb637f9204c82087ddc8653629a813a2c45c4044c5fcc78787b3a85d391dd939792cfcaede213acb98065bdc12191399b7b1f898d4f21832854885e67d92ecb8faaa0e6e040b36e3e0e37baa04d89cd6953321103755edf0ea3c2cd5a74b1e7ed90fb04f3c18bf7c78dc8fea76884b9d26d43bee48ace4d9e4850251c76a6ad7785e568b961a95abded36e41d4b75fd4e7a0a1e1031698fb795e11416c6a47de89132264e7401","data":{"slot":"8611153013818196877","index":"8616110467763216557","beacon_block_root":"0xe5b38c774d6c6c450390ae3d84416a04922914f1bbb6bd1ff9eff8bc40bd19e3","source":{"epoch":"1893026","root":"0x587a69770d32a8e2c2211a427a76e5d2b73b0e5d016bb27c0bf78d6e5e026623"},"target":{"epoch":"2277775","root":"0x32387577cd9ae958d89b4bebd364bc38ab35103995d96008b0f406deaa40f70d"}},"inclusion_delay":"8599585627006440685","proposer_index":"8597933143789756557"},{"aggregation_bits":"0x9893704c7516c2664f261a06c2f9b64f47a6b57af19cdfbb41a5255503a2d212dd1c04534a25ae166303c5670dbde04440a1397f5d64d8f1b06b6b1220b1e7dbcbf564ac2556c1ece5189398d0eb66f5e37199680915a8bb8da43f094c808ff99c23afcd8886598ff483ccd69bb875254092b175ca2a6ee8214e7922e5239c3905ac06de888511deb119a9f846ff02e8db18693afe2998818c3085d4bc6dadfd41eca6e618fabd6c3d5a3c25fca3e04ad1a4930162c067659d20f53934d6e7acf0b950e00ab29f2d07a513750de72fa5c244776646f960cd0becc7f92d53a8b8a9b418854bbfbe90ee87cb73adbe95c083c105a621210ac3587472a2ace80d8301","data":{"slot":"8601238114518092109","index":"8645855178548432750","beacon_block_root":"0x8d60f6770e1bb96dc5da6b30a3a2f89821f325ade999df08c1da39a8e5ed3422","source":{"epoch":"6894762","root":"0x671e0278ce83fae3da549dd9fc90cffe15ed27897c088e9465d8b217312cc60c"},"target":{"epoch":"5740515","root":"0xdae4de778e4936819ae608def2c54acd3aff21f5c2bc82f178df47c94f71124d"}},"inclusion_delay":"8642550212115064494","proposer_index":"8640897728898380366"},{"aggregation_bits":"0x90a388312de8257ea2c2d32826971bd279ade293ee427fcecf5a60621bee55e24086089e50564353a0be074d336c7e942f72950b758b888c23c63c7ebdc9f041bef807fc2ed26d52b6013c03e1c3584d757f2ec857b02aa3a6bcb3fa5db8228300df70f83bf1571a7510198f11c4ebf3abff4b8de48f1bf45919717cf2b5aabc3120f5c08c2f4875cf4858b5a1dd417e50670f193ff0839d2896a6b350a44cc8760c64691a9c57f2063fe69b4d115371fed89d5e272343b33412c8afca929dea79880af267dee29c75252ecf8938ca3a10c6f8390c9515b8b188be1077d7230cfd420bfaf505c70f7884acc98dfa18c490ee427b09dbca433332e280165c18c801","data":{"slot":"8630982821008341006","index":"8635940274953360686","beacon_block_root":"0x0027d377cee0f40a846cd73499d77367470520192f4ed465d4e1ce5904338162","source":{"epoch":"4201520","root":"0x73edaf778ea630a844fe42398f0cef356c171a857502c9c2e6e8630b2278cda2"},"target":{"epoch":"4586268","root":"0x4cabbb774e0f721e597874e2e7fac59b60111c610871774e8be6dc7a6db65e8d"}},"inclusion_delay":"8566535949787856236","proposer_index":"8564883466571172108"},{"aggregation_bits":"0xee053db66970518065e00af7984e4e424282bc7595ec413478e75ef38c058a43938c0dfbfec4ce470e2445fc6eb1843d9da604e82c530a7adb1662be9716a52874f83bc77b6ab9d3eb06990a250552914b0a98b2875d3fc646feaec5bea9d26bf573cb697b6548a937cec3b36066a5074970a95dce7e8fbd43b57752f58bbe88565d2d9a0d99372dc56b6a85cbea3f5e615a14dcca3c7293b4f01f8f91f312d04097783960f76961da40498ae8dcca31540c08b27b8cff676826df8659cdf6485ae0e1e73b6d2dd61097910f9769dd24fa52ad336ecf8514af9257e7685c8aabdc7b361d82b4104fced4bb5accce33fc49538f2e297c41f7288db2e4e917796801","data":{"slot":"8568188433004540364","index":"8559926016921119724","beacon_block_root":"0x6f18c5768c77146b95746501a06d24416690f254f35e28d90d18f055419a744f","source":{"epoch":"996891290","root":"0x48d6d0764ce055e1aaee96aaf95bfba65a8af43086cdd664b11569c58cd8053a"},"target":{"epoch":"995737044","root":"0xbb9cad760ca6917e6a8002afee9076757f9cee9ccc81cbc1c41cfe76ab1d527a"}},"inclusion_delay":"8556621046192784172","proposer_index":"8554968562976100044"},{"aggregation_bits":"0x68501702146ff562ab6aa7a378dd0717f50fc3ee046a5fe753b0d0ad78a58deaecd63d38f2d8e269fc8e504395ed146a2e60dda828f1b8f7b52057fe0e3d88cd9f34843e6c9a28c13f5e9a9b7d90265e29f666a2ce1ad636bd6a1a6d22500d89b0321d62dc554e84f138eff6533d2ea8a01d5456c8134d97f72060a70874a9c360d6841ebe4d508b66866e34161bff37a4378db294fa5a7572d160ce6a6f00cce428371ac62782f236f2a9c026dc6edb074c3c3bdcce4e501477bca862d4a5969d726c3d53b89814d55a2d07c94cf65767c26185232f3f03ee834b614d473792b7e49b8097f68b35da98516786beaba497b515eb0d7e1d9f3bee0a787d0b051d01","data":{"slot":"8545053655086060684","index":"8550011109031080364","beacon_block_root":"0xe1dea1764c3d50085406d10596a29f0f8ca2ecc039131d36201f85075fdfc08f","source":{"epoch":"354031","root":"0xf1823a770d8fa2096c39549d17bd893be95306edb4b0f84d7a00aab032092179"},"target":{"epoch":"738779","root":"0xca404677cdf7e37f82b3854670ab60a1dd4d08c9471fa7d91efe22207d47b263"}},"inclusion_delay":"8586365756978000365","proposer_index":"8584713273761316237"},{"aggregation_bits":"0x04efff9ff693eded9e3d9daabbd5f7791d281e1fc08cebe913cacc0d712922fb8948050696621ba83c7187a855becddc82705628a856cba1268b6b5cdae252315c9497bd281e8b6c05500444f76656bbf03e1f670c5bf75ca19c319eace4d8b8a7588bc607d66e3d47cc3021f7f283b915a793d5346a65fae95d80654bb4fbb075b6268a26b594574190fa0bd4b075635abc301824982d3da9ce70735d6a9a5c97d575fc0132984e415fc011959da9a02c2f38afafefef01cdf6ecb9e85f904345774e12b00de832440e6e7419aa9d9d50df44f61fcd84616cd62b70b673555c847391586325da236eb536594f2a3d0af73b77d5e172693a77cdd5dd8e6b320401","data":{"slot":"8588018240194684493","index":"8579755819816296556","beacon_block_root":"0x898b0b770cec9c3016518ef8b4032ea41b6cfe7c67f63e1fe809c6f20510dcce","source":{"epoch":"999199784","root":"0x63491777cc54dea62ccbbfa10df2040a0f660059fa64edaa8c073f62504e6db9"},"target":{"epoch":"998045537","root":"0xd60ff4768c1a1a44eb5c2ba6032780d83478fac44019e2079f0ed4136e93b9f9"}},"inclusion_delay":"8576450857677895596","proposer_index":"8574798370166244172"},{"aggregation_bits":"0x9ee7c4f82bdefec2f5ecf70283d09b82d267dbeae00ab749f8f3f83ed5839993b08071c10e01902c589c08fd34ab542132eb0c5e486b4966cedc7557beafcb5d213f5b5d7cefc1a62355deccf03a32af888fc7db327242686c71cfe1da5b0c9b68e42ec0ae344f36f4dd15c112b1bc1aa01b29ffca428de0f598c65e44c85b1283272d181971473face98d4b3009c0c99657a415a42db1478815bed446787507adffb9ede3b8727ed5cd98fe70bb01a0cae5070ec01cc4c6a5611f370ad69d78fb1299a232773baddaa8659dd8b2826f13f6a7c097515bdf1eb9ba33907ae5b0e21bd52066ff15ce798963fb85ea01985b433fafe5aa0eab390fda3f29f058d301","data":{"slot":"8512003977867476235","index":"8516961431812495915","beacon_block_root":"0x5f742c76cb25c2697d41e2691e533a1509dfd82878c14cc1b336cbac6f701466","source":{"epoch":"990350559","root":"0xd23a09768bebfd063cd34d6e1488b5e32ef1d294be75411ec63d605e8db560a6"},"target":{"epoch":"990735308","root":"0xacf814764b543f7d524d7f176d768c4922ebd47051e4efa96a3bd9cdd8f3f190"}},"inclusion_delay":"8500436591055720042","proposer_index":"8498784107839035914"},{"aggregation_bits":"0x2c55b6ac9b0e1df984c8e3358bab2f97112ecd624fabc7a60f40fa464440bfd3112642e231e51f815e55ca9752f7a5e4f7575b8bf329d95033ec0c48599ec2f57f4a14953a056ababe27a1dfe325a4bc9cb72f49b5b348f8fa019225730733ae048afcf5a17b103340e4454a6e09416c2a4e8872daef188c0b0589be30607ccd3407d046c341b6a90041fd082b6e4946e6caddbb2e9f7e15aad971acce2396363f75a3a9cdc96e5ee35ec990fc6666dd55bfe8b34518ea63cfb61db4c33cab79814ea25fa53372c85d34ce5d19af29e106f746f8a0eba2f973bc86498c6fa10842d175220316b779f0b36ef1006b9861f7a93d1f2d91b6ecfd000024b4185c0301","data":{"slot":"8502089074272404171","index":"8493826658188983530","beacon_block_root":"0x6b43da758a48f82de6ea87c9b1ce594c6009cb2471bb87ef34477ca060bc1bfc","source":{"epoch":"989196312","root":"0x4401e6754ab139a4fc64b9720abd30b25403cd00042a367bd844f50fabfaace6"},"target":{"epoch":"994198048","root":"0x54a57e760b038ca514983c0a8bd71adeb1b4e62c7fc7119332261ab97e240dd0"}},"inclusion_delay":"8543401176164343852","proposer_index":"8541748692947659724"},{"aggregation_bits":"0x34861e41473372a94a28205b08e1e33a8e50788b047eba95ab9de261122a3963cb046a2de69302c63ef940992d373df05c3536fa9d868cb321495d9fe8ee3007017b734aef86f608699c07019a195bc41bbbd9bcab776376c512d8b6e23916589b6b796057d57fc690e7a092c55d9ba6e7fc537edd5145857e720140ae773ec6d0eba35013e7e613e2080dc9bc5d9b60ef99c0420b83e7ad2feef649aefa7d8f6a95c512c61f85287ffe070e7ff235085a8686d332ebce3545ab202a3f5c717a287d5edd8d576c4c0c34f2711432927fdd77cb54cad3d28949a5f7a207ed2fdba2a3627f852cd9a87bc98b00523c4f7ee60466c20d21f4660647ca06280c493601","data":{"slot":"8531833785057620363","index":"8536791239002640043","beacon_block_root":"0x7ae772764b9a4a2ffe1d0b6133e94378bebae450ec5863078e28a14932e67be5","source":{"epoch":"992659053","root":"0xedad4f760b6086ccbdaf7665281ebf46e3ccdebc320d5864a02f36fb512bc825"},"target":{"epoch":"993043801","root":"0xc66b5b76cbc8c742d329a80e810c96acd7c6e098c57b06f0452daf6a9c695910"}},"inclusion_delay":"8520266398245864171","proposer_index":"8518613915029180043"},{"aggregation_bits":"0xc43c2561a0c9e7a56b572430084cd7241760478d06ba29621c4984fadb65166a0ac25bdf78570b2c45a058c533d0e535a903b35f7271188fdc7c15190fcf399e5f1efeeae515798dd47609189b6ce11c6f93a0aefe3f29663bc98d4d3966a33cd54da8d8589046e3ad5ff71289e9a0c2fda8baf90dddf0d90ced2df0cc250b5145ce9b16ea4715ec8e8a2fc0fd7306eb3e84a1ee9513085d9d4c3c1116e338bb681c7c40e8ae935f61b05ec837456486e5dc1aecb2c353b40a26148b1ca65d15cb70ee8aaa13b7280ba4b0b4d36a0940fc7eeb45eccb2b6424eb5edc1850f92f926df43d9df57e3dc0f2ea027304d6c3894dc5f8051e4225b16e353cf1ce1b6401","data":{"slot":"8521918885757515595","index":"8883812869125129588","beacon_block_root":"0xcfc5437b14911eb0d33056c699ab6b3d9d3fb48d58b3ee51023141020f730e1b","source":{"epoch":"34596683","root":"0xa9834f7bd4f95f26e9aa876ff19942a39139b669eb219ddda72eba715ab19f05"},"target":{"epoch":"33442436","root":"0x1b4a2c7b94bf9bc3a83cf373e7cebd71b64bb0d531d6913ab9354f2378f6eb45"}},"inclusion_delay":"8880507898396794036","proposer_index":"8878855415180109908"},{"aggregation_bits":"0x9e6bf617419110d3a780f5e993af121a8ec7140af0e4c6963f6760483ee7d9843ca7832ea927f642dc84c47100a241011640ea0489aceee8e384fbc0a71769ecdcfa03bce6a27e58234e03b2cefb782c7085358ed757b5bfb2daf92a4b803a466ce1594b09d7653065138530eeeb57de05da682354a1a6b8675f4c8171714f69ff86a32f5956dbe7dbbcbed382a2df2bc1d18ca69beccf18c1ec965835b4cc32d9a0eeeeda74af1f1f0e6db393ebb65e2b7ac6744dd632e7a1accd5d9692806888cfe6f1fbd9f9d9d749ec0b76d30ef0d80c353522d7039cfeab90ca38054d7d80b929ae72bbf125162ae79229a5f91721cf4787ea7d4de284ff408941edfcda01","data":{"slot":"8868940511585037844","index":"8873897965530057524","beacon_block_root":"0x428c207bd4565a4d93c2c1ca8ee0e60bc351aef99e67e3ae1538d6b32db85a5b","source":{"epoch":"31903440","root":"0xb452fd7a931c96ea52542dcf841562dae863a865e41bd80b273f6b654bfda69b"},"target":{"epoch":"32288189","root":"0x8e10097b5385d76068ce5e78dd033940dc5daa41778a8697cc3ce4d4973b3886"}},"inclusion_delay":"8910252609182010229","proposer_index":"8908600125965326101"},{"aggregation_bits":"0xb6e77da99ecb18cc9837d77b548f68dacaa688a01e9352b97b9bec290069ce95455df8a46d9d4f8f7e595281c171bb4faf50692558710d9a740de77a73a8a3103e82333fa0a41dc7da19b965d94c7ae8b4c464651cbe78d1e7b8ebc99ac6c47dd34ac25072d06d85d5ef5d9659e8239fb9c9ac3b86c0e6b61338ad183a70be71a848e18b6b8a2da7fc322c6c974f6d7b376ab9279c8969780ec5127c88a05ba63a7caf0f5588b8a34aa2406bc1636c40691143e0968694f57a5d99089e099487929004d30e589377c777ee61ee307106897192da1e339efefeff55e741217bb7f3aca324665bfc212803dc026270e971c251baf906e15787c09c9714f2beebc701","data":{"slot":"8911905092398694357","index":"8903642676315273716","beacon_block_root":"0xea388a7b9405a775550d7fbdad4175a0521bc0b5cb4a0598dd22179fd2e8759a","source":{"epoch":"36905176","root":"0xc4f6957b546ee8eb6a87b06606304c064615c2915fb9b3238120900e1e270785"},"target":{"epoch":"35750929","root":"0x36bd727b143424892a191c6bfc64c7d46b27bcfda56da880942725c03c6c53c5"}},"inclusion_delay":"8900337705586938164","proposer_index":"8898685222370254036"}],"current_epoch_attestations":[{"aggregation_bits":"0x348a47ef2b708dae548a63ac901da0a948c9bd639d01051a74787277a0c9717d6a479247e18120a9876346a72b48281028de38f55659bf391271d331b2c302f5feae6bfeb75244cd4901eae6a6941dc662a0aaf578fa85a35d1a3f6901f370dc363f146abe6465e0090875734f3fa050523d111048afcedde0e7a2cfcaa618373e02e20f11c0788115de6d8dc8c38386b815a06b344a01dcc589cfe5d92461b818c8c405d3115ceeb4d0a28bd8e3e63d1b316729e9a52140c40cba22a53a6442c59281ac66f9bc2d0bd972f8bc700e7502cd5c2e135782e03f9e494b25b3af02f0b1deb9e5583959346b27b43ac2f523dca63a0c32b3297d52bfe7806ea2f53e01","data":{"slot":"8888770318775181972","index":"8893727768425234356","beacon_block_root":"0x5cff667b54cbe212149feac1a376f06e782dba2111fff9f4f029ac50f12dc2da","source":{"epoch":"28055951","root":"0x32e8877a1305084c7b8f3e330dc6fcdf65a094cd23ca0797bb56b10a5b8efa71"},"target":{"epoch":"28440700","root":"0x0ca6937ad36d49c2900970dc65b4d345599a96a9b638b6225f542a7aa6cc8b5c"}},"inclusion_delay":"8824323447554697202","proposer_index":"8822670964338013074"},{"aggregation_bits":"0xca04969aaa6cf81092d7aaee02f5be3062e0fb97b520ff9561565eaa7702369d7168963fef1b0fa108eb55d6e29670b9ba5229e70705d44fe16b8ce2d01cd3943d349157f02bb07500161c98505a084ac99ddd2a2d5601459d28715ae6b4af77d81f2ffff474143b53cd26efea957a24a6a0b3e0a05c5b37d94a8c87c1b51d0febd63b7790ee1bddbdef0bef689559568b0c338d2386f05098fec68013789ec2abbffc59c9d225a348a70c73697a7fbfbbbd42e458719798c121ed4d3457aff19463eb9004eab5ed4e878dfca2053dfafe991164b18d38e441d4f3d8bb301fa5e584575e8468e97b8095900ca9035e98498b6739cad4e8d94b006b6c9ccc95a401","data":{"slot":"8825975926476414034","index":"8817713510392993394","beacon_block_root":"0xcbf0587a1262027325a7788eaa0ca14897b88c5dd50f4e682960cd4c2e95b5c7","source":{"epoch":"26901705","root":"0xa5ae647ad2ca43e93a21aa3703fb77ae8bb28e39697efcf3cd5d46bc79d346b2"},"target":{"epoch":"25747458","root":"0x1775417a92907f86fab2153cf82ff37cb0c488a5af32f150e064db6d981893f2"}},"inclusion_delay":"8814408539664657842","proposer_index":"8812756056447973714"},{"aggregation_bits":"0x429d1f657615054a24326acf6ab3508d7bc1bfbffb64b364479a53c045ea190da45196a7116843c428f09738fb60607955d505532cc8449873cefb9d1d05c5044762c48f632c2cd302dcbe2039761f9057d12b8cbf9002dd9f326ee5f52438874f5974c81687788ec25cfb9220e15282d9b6481896e9c12aa81738dedf0b33a3ddbbe1495c68cf361fb6fbba0ec6937002674dfc501acefc38c971d77db3f8f5f77c1ef2d284a3754303c3ad5f84e5ccf6eb7c98ac9bbbc0f11a51cdca1bf5863d521c0607e20e1d4c0aba62a39eec6c22d89e21fb25c634db88fa15e0bf1590adfed0018879a5a6b73e14addb9e5915f200aee4fa2e2adb9556b7c6015d80d501","data":{"slot":"8855720641556597523","index":"8860678091206649907","beacon_block_root":"0xda94f17ad3b354743ddafb252b278b74f569a68950ad29808341f2f500bf15b1","source":{"epoch":"30364445","root":"0x4d5bce7a93799011fc6b672a215c06431a7ca0f596611edd964887a71e0462f1"},"target":{"epoch":"30749194","root":"0x2719da7a53e2d18712e698d37a4adda80e76a2d12ad0cc683a4600176a42f3db"}},"inclusion_delay":"8844153250449874035","proposer_index":"8842500767233189907"},{"aggregation_bits":"0x30276671fe8500356d1d3da9633ecc0beceaa1b3f8e49113b0386f16e82d9e64539faddd2728586127acd5c6ff1b917c84ef325687dc94b44dfe9b13e444e08d3d12797de1ce8742cb5ed13138628d2332e9d35eb35368cd18682f0a94bd85f12bf0afdcadd265dbbbf698c17d19d998d167c91e925696125e0251d03fe24e12ca125407ad7e9ca1331cdb235ec817f3f2fe15ca8c2aa7ac0cc1cb1fc928b748779d8db7fcb4d652e33d8bdb007b08e65992e379a8d4a5531dedc87265e179fb5d1d674f9bcec4099a9671036cc767c34550f951ed3f3b9bb6c30e4b6997d9c0cd10c61973f9245d0e441ca7fe56c6ecbc6b54f2da1b1e18165e6dd5ddb1c22301","data":{"slot":"8845805733666558163","index":"8837543317583137523","beacon_block_root":"0xe6639f7a93d68a38a683a185bea2aaab4c94988549a764ae0452a3e9f20a1d47","source":{"epoch":"29210198","root":"0xc021ab7a533fccaebbfdd22e17918111408e9a61dc15133aa84f1c593d49ae31"},"target":{"epoch":"21899969","root":"0x950acc791179f1e722ee26a081e08d822d01750deee020dc737c2113a7a9e6c8"}},"inclusion_delay":"8781358862446073393","proposer_index":"8779706379229389265"},{"aggregation_bits":"0x1aff6a4e6b80c1502eca460a985f88e0a2c34802d0f69f4937c163096d05b44f70e4b81097e6cbdf4ac202c65aef9ca530c769b363b1b66ba0299c09be38a96030f97765373fcd02f9d11bb9553579c50bd807e2ba787d69e5f7a05688404791d40cc85a603b0584c470ddf9b0db063b66df71e678657c586e661d8934d83cad0a6db7b784def9caef61ce23b5700717ae0403372a7f39d6469ae1ebc1fa5dc9477145e50c977c6de10c8884f108b0a7ad5fdddc667cbfec597c65c8e75dc5a4fc2892ef0dd02114ac7831a2e6db4037153b1ecfc493c5a6c6ab5f78dd1f419eeb7c46f26a2a689c02025851b0d3acfc758377bcf4d9fd853c8a726e433f951301","data":{"slot":"8769791475634317201","index":"8774748929579336881","beacon_block_root":"0xbc4cc0795110b0710d74f5f628f2b61c3a0773315a727250cf7ea8a35c6b55de","source":{"epoch":"20360973","root":"0x2e139d7911d6eb0ecc0561fb1e2732eb5f196d9da02667ade2853d557ab0a11e"},"target":{"epoch":"20745722","root":"0x08d1a879d13e2d85e27f92a47715095153136f79349515398683b6c4c5ee3209"}},"inclusion_delay":"8758224088822561009","proposer_index":"8756571605605876881"},{"aggregation_bits":"0x88645946dab2f06b74f1c73431609ece64ccb40417564d3aea755959feef1b3ef3e69b3f812252dd769a53fc5c906ae0d9f17e76da2b37f458187247c77190d16ed8f3972b450117417317641470ef7446a16a4d3c39f77983c7e7ba6b5c2afa6a225a633a7f2c89bcd2c53a6ce71acf4a8c9261beeadf05944b342b3e634d649f8c03e97d6e8a195bd0e820d006833c0eb976dd376194c465f60aabd1f13a74d4b9a94523c312567589cce22994d799b60ec0664633a0ae26b92c7dcda717c19a6ea3499ef4acb12b64f6282c83cb2892323ecdeb893d4109b9720643031d86dfba72e39363411f3f58d5e9963f3585bbe9d50d24a985449c8389edb3e7ddd501","data":{"slot":"8759876567744277841","index":"8804493640364553074","beacon_block_root":"0x64f9297a12bffc99cfbeb2e9475345b1c9d084ed885594399769e98e019c701d","source":{"epoch":"25362709","root":"0x3eb7357ad2273e10e438e492a0411c17bdca86c91bc442c53c6762fe4cda0108"},"target":{"epoch":"24208462","root":"0xb07d127a92ed79ada3ca4f97957697e5e2dc8035617837224e6ef7af6b1f4e48"}},"inclusion_delay":"8801188669636217522","proposer_index":"8799536186419533394"},{"aggregation_bits":"0x909e912f946f1f31d558815f990a71537e18c3290512314f7039d177a92b1dbe2b4491fc9d055f1a782794745552d42477a21a06f2c4f7b642b48599ebe8863b1cf4894f2663df3f13a892f5bd5cb50dd8f6bc25047c55e322f75636fa644f13b7c3cd76d88961743ccf6eeb3f8fc0953d486937917f940be82c9053aab57351abe190d78ad45eb3a18a1cf92703c92817c26f72c4f16f5c42822ed43f33d06580195f6a29b38b6c6b04033c9a04a86285384c9199dcae63d4b840e732ea2bd2b7d75f9a9af0716553e9cf42285e78b1cf5275a29431457187a687f96089b6f3ba50bdfc85e921d8085b9872b736a2988c6f04743652014463c4970f44d280b401","data":{"slot":"8789621282824461330","index":"8794578732474513714","beacon_block_root":"0xd6bf067ad28438378e501eee3d88c07fefe27e59ce098996aa707e401fe1bc5d","source":{"epoch":"22669467","root":"0x4986e379914a74d44de289f232bd3b4e14f578c514be7df3bc7713f23e26099e"},"target":{"epoch":"23054216","root":"0x2344ef7952b3b54a635cbb9b8bab12b408ef7aa1a72c2c7f61758c6189649a88"}},"inclusion_delay":"8725174411603976560","proposer_index":"8723521924092325136"},{"aggregation_bits":"0x7ef20af280fe51cf1a395a975f5665ca46208dcb37318b4463b579eb33c843d6bd78948af83e0216dadd922b1c9c2ea985f6aa929b68d74003a063af69b75394d34565e6727b2bbdda2d07f64a92eba1f65b6e1dd1117007e28d3aa55b373aba23ac5ec71a9b35b1678eaf471d48ab7fcac3a3e4888801537201fc5b0bdc6df54e3d156fbc623d4883bf5e1f0615b54214db3f3c171f1ff79ea4f5fbf5e68f9df50e53a28b50e6d3b671eddc2beb71603b2c19654db91abf90bd37dae7a6c325c4b6918ffe614922341370d2262d2fbda22672a854fbfedd79bc96589e2a33349b651c1afe5a71d0fc296fcd7247bc305f457982dc54c5f07ae449aba20c841e01","data":{"slot":"8726826890525693392","index":"8718564474442272752","beacon_block_root":"0x45b1f878901b58979f58acba441e71590e6e5195921add09e3a69f3c5d48b04a","source":{"epoch":"15359238","root":"0x1f6f04795084990db4d2dd639c0c48bf0268537125898b9588a418aca8864135"},"target":{"epoch":"14204991","root":"0x9135e178104ad5aa746449689241c38d277a4ddd6b3d80f29aabad5dc6cb8d75"}},"inclusion_delay":"8715259503713937200","proposer_index":"8713607020497253072"},{"aggregation_bits":"0x5cbf30543c9acfabdcb4db40afc6adddd63e9019e2a19de36860e6b485c8c8afd36ab66f3a9bfe33283793cefe91bede321412909f9e75e459d22205e8c5eae7393903a3747570aba8b4146dbc4bcf12947e95c19d56ac57f90d8e8504aec61c6435a8dcfe2c19dab9e912802eb204d103f374cb7fd3f9784245a18cd320d48f7275822b4a2e784d68563bfa89e57d0fabb406705af85d45519aaba00a7a9d0731b918f0b5895e7cfd0308b6ba635d0de8ae3f3872bb8bcabfecb4e898a414f213a51312975a33def1fbcee2640b56ea38bebc2e1bdf628a9ac4eafcd11deb8db0f9208ee758f49ae4451ffcb57717f18bbdc1d4f836ba18ec5d72a73a10bcf701","data":{"slot":"8703692116902181007","index":"8708649570847200688","beacon_block_root":"0xb877d57850e193345eea17bf3953ec2734804b01d8ced166f6ad34ee7b8dfc8a","source":{"epoch":"18821978","root":"0xc71b6e791133e635761d9b56bb6dd6539131652d536cad7e508f59974db75c74"},"target":{"epoch":"19206727","root":"0xa1d97979d19b27ac8b97ccff145cadb9852b6709e6da5b0af48cd20698f5ed5e"}},"inclusion_delay":"8745004214499153393","proposer_index":"8743351731282469264"},{"aggregation_bits":"0x9492f0aad776c73ae1e7c7da5ecc55f31a1f1f8102d4a9c834d8df158de4aba7deb48ae659b9a6fbb8f802393c034f789ba091334b111693cc7d7a273f434c8bdb11918020ed1c1012f90aba22ec8fe34d3fe5ea5e358099ef4f54f621fab92151791ee0852e41610a15d15c8a8dad919d28b95d638ac977fc09505df021026baeb11217f2d4be2d8f4c8dc75ac8ef7f651f3b7bf8994935899bbf243976079563440e45aa2715c03cac6aec60880251df4fbb80a95e0ed14f3d84ff982f352f2baa197060491bebe0878d39f8ed2d0418a79059091bfb930edb4bd809a99461c964aa6e3389bc949e68a7e675a3b156eb21644ad4dba33d23aa4db2d7e193a801","data":{"slot":"8746656697715837521","index":"8738394281632416880","beacon_block_root":"0x60243f791090e05c2035d5b158b47abcc3495dbd06b2f34fbe9875d920be17ca","source":{"epoch":"17667731","root":"0x3ae24a79d0f821d335af065bb1a25122b7435f999920a2db6296ee486bfca8b4"},"target":{"epoch":"16513484","root":"0xaca8277990be5d70f540725fa6d7ccf0dc555905dfd49638759d83fa8a41f5f4"}},"inclusion_delay":"8735089310904081328","proposer_index":"8733436827687397200"},{"aggregation_bits":"0x3ee66a4d18f23c8429500d0bdb091d47d9895e272ca2e6183a968b61424513c199f145166838db95192bd44dcc00c9a76cf7cb9c93cce476e3ad1c2714badc207676c6f7bb550789afd0a0bafe6a15f77a4b7f4acf15dce6e1562f21a324435800f6cbb3352f42e6c2492f1e5dd7a71f66106a04a7dfff6fbe1131244d8d504edfbc7eb64bf148264e6a1cf0a6e91e17c35ade015776a356c1310d660aa1fe2e0ada9d3718ed7d9243311de7c576f9c341292593d67f0a1bffbd5c780a197034e965c900b384e30d6e2af2a2196128acd8904d33d5675e19b581c06faa4c70714c21749e9ef5169c5870a2f83995bed34ba1ae121b88bfeab3bb180373e46cf601","data":{"slot":"9093678327838327065","index":"9098635781783346745","beacon_block_root":"0x1cfa3e7ed929bab64b30e6bb2130fe1871b6346abfc638c9c497f94f2a44efa9","source":{"epoch":"58066366","root":"0x8fc01b7e99eff5530bc251c0176579e797c82ed6057b2d26d79e8e0148893bea"},"target":{"epoch":"58451114","root":"0x697e277e595837ca203c83696f53504d8ac230b298e9dbb17b9c077193c7ccd4"}},"inclusion_delay":"9082110941026570873","proposer_index":"9080458457809886745"},{"aggregation_bits":"0x6e3c195ce2a4b5e9c0f79f29933ab1531b82422be206f6cf8e64e9bdcdad145139b34fe45e5c40b84a979635c8d73c23b5595c0d6ad7f54b9ebc7de8d3da77e088137113a1bf9d88da525e6fb71ec3260e431d59203cbef0bfce1ccd2ad93c35a4ff19ad0b680e93ffe3ee96847f3ae13f46faa9547a0a074e04dd94dd25fa850897a0b4b6451bf9664a3cf777bf8b3c63579fbb6c42180477f1dfb7863ab7c249f054f037581fba7c5648d18e89ccfdda139835d672940a913b5d9059f096598959eadc35c06b54ba1ae5e39a3de3f26d5ced5beb6fa7ae9fd70c92b62721cd28e7c09cc53ff539e30aab711e3da75fa5eb450bf3b61b296b82e7098e82301601","data":{"slot":"9083763424243255001","index":"9075501003864867065","beacon_block_root":"0x27c9ec7d994cf07ab5d98b1bb4ab1d50c9e02666b8c073f745a8aa431b90f63f","source":{"epoch":"56912119","root":"0x0187f87d59b531f1ca53bdc40c9af4b5bcda28424b2f2283e9a523b366ce872a"},"target":{"epoch":"61913855","root":"0x112b917e1a0784f2e286405c8eb4dee11a8c426ec6ccfd9a4387485c38f8e713"}},"inclusion_delay":"9125075521840227386","proposer_index":"9123423042918510554"},{"aggregation_bits":"0xe695b031fe0be9e9c233da4670586c7c058775cfe99109dc9caaf19bdd69b7c5d6114e2b747f0e3d3a26141ff507a0765a20343d0f9ab1ad04311587426ab7387eaa268feabb31f6c58c7bd61e1a535f004eefb51691bd7c8496b170a96f41cb6339921aa98ae0262e3683ec0e1b8023b02ed28138cb354a3849d74bf31a55185c3873e643ebc34210108e52f0bcd138fa34ea4cc8cb643cf587c8d0ca7954a7b980569a3f888d61c1ff824d8e765282a14eb64ea398981c11053147a5b58e3e207a055e3c2596ec92baca5997e3861876192206a1475bda158e1d7a37cb9a9c250d87c8cf24dff8f8b96e8b3c6ef233be415fd2d1465961c4d1dfdb7c966d5301","data":{"slot":"9113508135028471194","index":"9118465588973490874","beacon_block_root":"0x376d857e5a9e427ccd0c0fb335c6077c26924092335e4f0f9f89cfecedb95629","source":{"epoch":"60374859","root":"0xaa33627e19647e198c9e7ab72bfb824a4ca43afe7912446cb190649e0bffa269"},"target":{"epoch":"60759608","root":"0x83f16d7ed9ccbf8fa118ac6084e959b03f9e3cda0c81f2f7568edd0d573d3454"}},"inclusion_delay":"9101940748216715001","proposer_index":"9100288265000030873"},{"aggregation_bits":"0x941c89493d5969a73b0e4830dae40861dc8ae0e10a201973e918df035282b8a87377740802bf911d07728437c37e50e28bcf9bb9288a30187b0d7429e58bd4b920478b6db085aad432eaf7835d3dc56c7d778696dad8d66e52aee28d4033feef4f18490a2aea796397dd55bd53e39e7f78f1cb07fe504236408cdac325e0259dc819c7e8b8d1b2b168d9ae79ef86559f12898baed3ccce4ee36c06081aaa9b12881b8e5731bd4881f7eacfab818994edbe742b78633197bc965a52ff006b6853da26766babe11ea8c9a6195252bba703db990326f2fda67378c0f4152bf02ca855cf56ce77fcfc2f61cb2fa299c96baa448bbce01979a7a635d2a058a16e2fa101","data":{"slot":"9103593231433399129","index":"9042451322351315320","beacon_block_root":"0xa55e777d183562dcdd149d7f3c5cb855451d13cef66ea382d8bff0e82b214a16","source":{"epoch":"53064630","root":"0x7f1c837dd89da352f38ece28954a8fbb391715aa8add510e7dbd6958765fdb00"},"target":{"epoch":"51910383","root":"0xf2e25f7d9863dfefb2203a2d8b7f0a8a5e290f16d091466b8fc4fe0994a42741"}},"inclusion_delay":"9039146360212914360","proposer_index":"9037493876996230232"},{"aggregation_bits":"0xbed67102ea1c20f8d85b02d92c94b8ca99a136b432f427b3843d5254fe0210c11a2f60cd6471aa834a5e5705724acbb00f10545d4ee3bbcf9bfea20361561fd46d768425fa3fb4243ea59d6e1e62a14ce544eae3873ac2f8de093dc3e41c5ad5b8ecee1cef2f1b3e2852d885de204dbd8f0d4bab1441b8dfd028849828de96262dc4247e9115f9eaf1c4eb390e5e451f4672ad4343d1f784e3b4182d512150fb7c30c407e117127177fecd540cfe15ed4efb877b69eb9d3f186e55008ae3f40c46c18ac93c16f43773cc09d293b7bef98130faba0ab1585469aca1233e7bdec2f7a512b12b3392ba86b7610d162f451ab5cb149a5ff146750f0c3ac216e1611501","data":{"slot":"9027578969106190871","index":"9032536423051210552","beacon_block_root":"0x1825547dd8fa9d799da60884329133246b2f0d3a3d2398dfebc6859a49669656","source":{"epoch":"50371388","root":"0x8beb307d97c0d9165c38748828c6aef2904107a683d78c3cfdcd1a4c67abe296"},"target":{"epoch":"50756136","root":"0x64a93c7d57291b8d71b2a53181b48558843b098216463bc8a2cb93bbb2e97381"}},"inclusion_delay":"9068891070998130552","proposer_index":"9067238583486479128"},{"aggregation_bits":"0xb29a50af2560a862efec1c49b39ad050e986e97cbc5293bdd0597c37f7a484d8bfeb7ff5a247f376aad1c4eab25c19faf700975edf3ed2aa19f9eca594c955cc9c8a3606acb756897cd0a39180fff3b81805934acdf2031281f6bb813d59bfec05061da8d0085a999cae327a2a1624f93b779683e8324145266c6413815ec70c3968f03ea9f31d40b68279047991e76b08e9d74df3b9c1fc2c9c5878f63dc263cfedd4bcae3496dd2453ae9d56769f9a130932df387f392dc1ed7510212ae1f33e674639cba4dc8be3f64ba84351d1dfc70d47451883c22a9cf1545bfeffac0404b819039ff5c3f6109e5899fcbb7795df5f3c6433d8e500802a205eefb0520f01","data":{"slot":"9070543554214814681","index":"9062281133836426744","beacon_block_root":"0xc0d1bd7d98a9eaa15ef1c57651f2c1b8faf81ef66a06bac8b3b1c685ee96b195","source":{"epoch":"55373123","root":"0x9a8fc97d58122c18746bf71fa9e0981eeef220d2fe74685457af3ff539d54280"},"target":{"epoch":"54218877","root":"0x0d56a67d18d867b533fd62249f1514ed13051b3e44295db16ab6d4a6581a8fc0"}},"inclusion_delay":"9058976163108091192","proposer_index":"9057323679891407064"},{"aggregation_bits":"0x76b7f289ddf5f2812743b59c43010a310eeb9cde7fd69d2ecf0862ea11a4987c50bb59213c421c6358d3c51651758aa0f18f7fcd553e3a027cc7afc3dd2ab68f6d622ddfaff1d39bd2a874025402e56e9f60791e0df6ea623b612b81265d100b423ba380768d7dfe4008869f1860ea72d0823b2c2f7d60ea56e26bc696a1d5fa2d604fba9c3b5ae6df0f7993162a0fb2bd94e909ec6f018ce78d25b3c9b5f8716d439faae0b2837ffc414ad01bf61f6ce0981446df1cac881f16fa275f70126bf0e546b6a27fabd6a359d5351d77bac87b998dc55f135a1f499168b6ffe850bfa3b4bdbb91b25d8f06d6b1ae994b49ee50afad6527ba92fa52481f5a33bd263201","data":{"slot":"9047408776296335000","index":"9052366230241354680","beacon_block_root":"0x33989a7d586f263f1e83317b47273d87200b1962b0baae25c6b85b370cdcfdd5","source":{"epoch":"46523899","root":"0x0981bb7c16a94b78857385ecb07649f80d7ef30dc185bcc791e560f1773c366d"},"target":{"epoch":"46908647","root":"0xe23ec77cd7118dee9aedb6950965205e0178f5e955f46a5335e3d960c27ac757"}},"inclusion_delay":"8982961905075850230","proposer_index":"8981309417564198806"},{"aggregation_bits":"0xfa7b85cc09d1bc7de0086edacfee48a93582fa085210b394ca854afc8a4f735865f15d5721c9532bdc0341c596bbf206a236dffea27a39752c17d9a13af4f7a8af1296e6ffb8651a87fe07658cd4a1ae24052b0d5c1b7e86d94bb732c3ca60e20f44b813860c230f1ba447117daa701c101f9b7d44acf4f2ec0f69881bcfc042f89486c0258c39bad71a6b07ff6fd10aa489b0cad9f1f3e431ef0ccd406422491fc1dbb262dbc8c9a016ada4be51c22c4c98c3a3c68a390843ab851dc82cdd9dca9cacabdc8f9691e60b4a911310ed17b0eddcc30f79f1b767bbe026c35ba8188207acd9fd028fa6b50a86b7d3bbd0d4d106d1b4f734365c4be7d5b785dacd9801","data":{"slot":"8984614388292534358","index":"8976351967914146422","beacon_block_root":"0xa1898c7c1606469f2e8bbf474dbded603f96eb9d74cb0299ffee7c334a43f1c2","source":{"epoch":"45369652","root":"0x7b47987cd66e87154405f1f0a6abc4c63390ed79083ab124a3ecf5a2958182ad"},"target":{"epoch":"44215405","root":"0xee0d757c9634c3b203975cf59ce03f9558a2e7e54eeea581b6f38a54b3c6ceed"}},"inclusion_delay":"8973047001480778166","proposer_index":"8971394518264094038"},{"aggregation_bits":"0x42603831d7d137a309e921bd4daaf684097e8d81198413e15c480aca9cb7900c9ee35194d09a6f8ead7186ebaa5deef28d45bb0ada87b9aa3eb8f26fdbe5b63ed04fd23c73a72aac1c9720d46d4cd296fa38dde52a5a777ef379facd52bc559e9b95cf06846d6c969bd58ae45a8a78e6d9284281000963ac1862e5f62419f26fde9b75f6bd036c5035489ee6883c120c2fc6f5b7d8780a7cd259bfa23ca2e7f863316509693b1ff33ffb7b7e8d81563f0761ad658267131a49b0fd827669cbebd38d7768c2aa4a25e88b73af86cb5ed5abae51ab65459de2ed8ed9ea36d1d66feac9d3aeddb1f37026c08302f1bfcdd1cd2b2de9cf86e15cd0e0ef9d72c65ab801","data":{"slot":"9014359099077750551","index":"9019316553022770231","beacon_block_root":"0xb12d257dd75798a046be42dfcfd7d78c9d4705caef68deb059d0a1dc1c6d51ac","source":{"epoch":"48832392","root":"0x23f4017d971dd43d0650aee3c50c535bc259ff35351dd30d6cd7368e3ab29dec"},"target":{"epoch":"49217141","root":"0xfdb10d7d578615b41bcadf8c1efb29c1b6530112c98b819910d5affd85f02ed7"}},"inclusion_delay":"9002791712265994359","proposer_index":"9001139229049310231"},{"aggregation_bits":"0x329a5b20563aa2389bd4e18bc407f09b4a4e90e7b7200102ebf85c0a1d6293693d75522a6c7cc5a2ba24538394263be61cbbfc6ea0c369a6ab0a926138a4bca78e1ebfd4697d37a4e9f5cecdc6b3458f172020f3e71f3f0c6c8ba961f9a1e220fdb998360a8e57dff6fee421a476c73256d8f384d78c1cf56ad78b4ee4a0857c59128bb06d079cce5d89ee8dc1179d279d5d940f665ea5e464946472ecb92ac5949a852d47af9bc2096c2a18c17e3330b87b30fe26e90c9be6b7fc32f599098688c2005453eec3c0b217946ecd91c5c60a2630fe47dd640fc0dcbd9756cc2077d20f35ab27f145c3bdfb0e2450df5c08316184591fb1b81b14ad909e8aae5f6c01","data":{"slot":"9004444195482678487","index":"8996181775104290551","beacon_block_root":"0xbcfcd27c977ace64b067e83e6253f7c3f471f7c5e86219dfdae052d00db95842","source":{"epoch":"47678145","root":"0x96bade7c57e30fdbc5e119e8bb41ce29e86bf9a17bd1c76a7edecb3f58f7e92c"},"target":{"epoch":"40367916","root":"0x6ca3ff7b151d35142cd26d592591da9ad5ded34d8d9cd50c4a0bd1f9c35722c4"}},"inclusion_delay":"8939997324262193717","proposer_index":"8938344836750542293"},{"aggregation_bits":"0x0682ef02c167e3bf500533a276c36120817844b632e61bc584993d15dbd87c801a3d67567315c7c4df0b80f525722610d8b6f388c7fe7b317bdcc5e358699cb3d3f730d0382c054eefb8864404cfa18d8eb09cc7bb300eaba1d0527ead9ebe8003417be0c3c13690bcf5f09d4fb62c00e0645b4e2495e6afda63d425ee9cd5d09d6f022338245aace594becd228e8600f1a5d05077683136454e2a84b77bc3bce2f14b7ff784d3f3a93f3cf72c3f5bb0c2f5ecdb7882123ccaf48d891f3ff49d247fd466d7150abd08d4d06f9fbf70bc5cafd374cec78f79d1e4ecd54245d203fc6565f45f029e2abadf4aceb2db32b0812180231a714b103a390a6d0c31a4af01","data":{"slot":"8928429933155470229","index":"8933387387100489909","beacon_block_root":"0x92e5f37b55b4f39d16583cb0cca20335e2e4d171f92d2781a50d588a781991d9","source":{"epoch":"38828921","root":"0x05acd07b157a2f3bd6e9a7b4c2d77e0307f7cbdd3fe21bdeb814ed3b965edd19"},"target":{"epoch":"39213669","root":"0xde69dc7bd5e270b1eb63d95d1ac65569fbf0cdb9d350ca695c1266abe19c6e04"}},"inclusion_delay":"8916862546343714037","proposer_index":"8915210063127029909"},{"aggregation_bits":"0xae794e126bbfe2b4936ab5803c7f1c14426ac1dad4878d2ff0266b41e60b5269e37b52884df24e8cae72c08d32add6548189948d7d34eace04dcafed9fd8942badd23d2633f49e7352da491147f0033cfba8fc866e7584b9670833d284e3492eaaeee75ddc032ad5a99fb24e460e12aab93bbad8f91a71d3b4bebe115670a62b8aceb319ed3ca87a3507dc0c2ff94b02213a95bfedd2ba4467efe0ced7e4a68d643ad2aad9e5ced09d716511eb012c8a4def617bf80e0d1ea4bb84355b5730604c31ee3f5b5de1d90bc807e1b8e4fb93596ed362f96f7696bdb750aedf7c043b9cafc1e4f7c8118803e543461097ab4da7e8d31112886f578d787576f0fce27901","data":{"slot":"8918515029560398165","index":"8963132093590738806","beacon_block_root":"0x3a925d7c166340c6d8a2f9a2ea0392c971aee32d2711496a6df898751d4aac18","source":{"epoch":"43830656","root":"0x1450697cd6cb813cee1c2b4c43f2682f65a8e509ba7ff7f512f611e568883d03"},"target":{"epoch":"42676410","root":"0x8716467c9691bdd9adae96503927e4fd8abadf750034ec5224fda69686cd8943"}},"inclusion_delay":"8959827127157370550","proposer_index":"8958174643940686422"},{"aggregation_bits":"0xe665367ab78a3dd8bfa9dcef5e11d3d9df76e6d6c7c2b07bcbebe3ebd470d4bd1d79fe611b8313c8ec8402a70e3f46c0eee2ec7c85ba2a059e53cc020c08f3b1dbd35f732ee4525105a18d082e4c2ee5f5a70b2a301426604495cc0f96522cd2718e7ad85e315c6870cf1797ccf28a2fb68763aed7f73e8a55f81a4b51cb800cfce30b6b73b6fdd8e357296fb8fa5134aa49e49058d66670d059e1893fab4d3431da3490d0a104a643d58bee5f1d1b9166924f829de521ae6fe02cb6ae9b1ab7a10018b9587457fbfb48ac9f457b380da73eb80dba47c867b1a101469eda4c48cc55d697d9d314460896c6ed658d3654274193dc227eaed766772f5419cdffd401","data":{"slot":"8948259740345614358","index":"8953217194290634038","beacon_block_root":"0xad583a7cd6287c63983465a7e0380d9897c0dd996dc53dc780ff2d273b8ff858","source":{"epoch":"41137414","root":"0x1f1f177c95eeb70057c6d0abd66d8866bcd2d705b37932249206c3d859d44499"},"target":{"epoch":"41522163","root":"0xf9dc227c5557f9766d4002552f5c5fccb0ccd9e146e8e0af37043c48a512d683"}},"inclusion_delay":"9306848752984892798","proposer_index":"9305196274063175966"},{"aggregation_bits":"0xbd6224c819dfdd8f4206268946fefb8e4cce18e5ae9a9a4d26d4a211f08f891684ec85ddcb364a2f9f2bce5c85f4a72fcff268567217fb46aeb17b1fe377c6a92d1c346075436c915d9fdb4c0f83cdd974cf5a9f2c66970dfb4b557123616e2bdbf9b991f72ca1d2e85f0c98d72a9172ddd0341bfd0c7f94be6a68784219e2a9a1cc7dd5feb3925a6aacdfe058f6e80a6bd70d7cd0817de40746c4c3992fe5f41219876562c9ed35206b78978a0c0ac1e0ca79f05eca8cf7d53255a4ed6bfc63cf71a42e5f82c190e73ad92e75a6519c09438a5b1e92518eff975a11a44d86f17d5b3fef286533907d98184f58989013e7740c9800776b31fcc69fd7fc8b143b01","data":{"slot":"9308501240496544222","index":"9300238820118156286","beacon_block_root":"0x02370b819e1f50e46d47b00c46fb345d7745add6d91fc911f407cedf181c8b8e","source":{"epoch":"83075044","root":"0xdcf416815e88915a83c1e1b59fe90bc36a3fafb26c8e779d9905474f635a1c79"},"target":{"epoch":"81920797","root":"0x4ebbf3801e4ecdf742534dba951e87919051a91eb2426cfaab0cdc00819f68b9"}},"inclusion_delay":"9296933853684788030","proposer_index":"9295281370468103902"},{"aggregation_bits":"0x1b4e9eaca358cd2b8829b6d8b76f2399fdc3ff542e18adf2591df54756af021e2afebb18453be50a2c81c6eb7a293354401931022d3549fef481494d62d52be24c642ea563e0bb9187a768dffb0e6f83369bfed92c017c7c2dcbe3513c5180dedc044baf503f8793043930fcc5ce1bdc05af9030fac3cfff44f5570f0e4df1e3c752d2c90aa3d51c8b419e50b7851177a82124305ea31f440aab911805a3bdeb922cce6f4c590e3065298dfe8d0ca9013a4e4da5a3c88dd3cbf1f7cda649a9a501f3abb516b9eace29d54495af9a7caf92d5645d5152d7ba37af4604e0176a4e7c47d9702f6666c9e5f6e27a3f71a8bdfbdbbc890011375b6f87a7cb604e08ab01","data":{"slot":"9285366466873031838","index":"9290323916523084222","beacon_block_root":"0x75fde7805ee58b812cd91b113c30b02b9c57a7421fd4bd6e070f63913661d7ce","source":{"epoch":"86537784","root":"0x84a180811f37de82440c9fa8be4a9a57fa08c16e9a71998661f0873a088b37b8"},"target":{"epoch":"86922533","root":"0x5e5f8c81df9f1ff95a86d051163971bded02c34a2de0471205ee00aa53c9c8a2"}},"inclusion_delay":"9326678564470004223","proposer_index":"9325026076958352799"},{"aggregation_bits":"0x07a3de316cbe44babdfeb9d62275c33491c4b2c8cfff39152dedecef4e222103f720a620038294caa826de081878cefee13cbaa170ec389f6b0c32ef954fe1b24d401c0665775b2fb6f4768865b889716fdbd752f7eabc932a236e36e925f6fd292edb3a5e9dd622b0c59b0260ecb65c82b34c9a0c56b7f0b882a7469d4ca0b7a24272d1a2b811b0ec070c6e42aaa523f2bb793b3787ab24c3b381fe31e7ef3f6173fcdc53bc9c0ea295eeefd7842ad0542dc81dbaac2a681150479b0ee4986a1fcc6913f8aa806830a205fffb2d2b15d3c8612a46205cd032f2a30029a310bc0d5305c49ba43bc15f4951c4dfc58e7387155d77a8b8073ea1aef84ea37b97a501","data":{"slot":"9328331047686688351","index":"9320068631603267711","beacon_block_root":"0x1daa51811f94d8a9ee23d9035b913ec02c21b9fe4db7df57cff9a37cdb91f20d","source":{"epoch":"85383537","root":"0xf7675d81dffc1920049e0aadb37f15261f1bbbdae0258ee373f71cec26d083f8"},"target":{"epoch":"84229291","root":"0x692e3a819ec255bdc32f76b1a9b490f4452db54626da824086feb19d4515d038"}},"inclusion_delay":"9316763660874932159","proposer_index":"9315111177658248031"},{"aggregation_bits":"0x6d994f1eb97346cf4eabc3395c91fe9ffee7ff18ce6cab15e47c9df9bb881acee562faa4a9eb8757c18245549d2d530775b764853683bb4caffa45f1cd5ba99af0f99356bad6d1a798d99e4da6ecfcf7d7cacd63ab4dab268715a00d4c88a049f5da6e3db6d796f8ae645eeaaf29816e650fe0b9e3654d880844f93b965a131244bb6907ab1bf3c9003a882621139e099ed37f46bf509466e36987086ab446c7ff59b49ca196f2feaac0fc141a630250f6a0d68ee8c6a4c35d67dd70b6689451a7ba9abb7e2c5dfd0ea7157f38a08ce583e084b0eb0597c6438cf393bd1be8ce2b38d7d8c27f401a4aad147313092413d72d180dac68346daf08e78d21bf780001","data":{"slot":"9252316789654447389","index":"9257274235009532477","beacon_block_root":"0xf3927280ddcdfde255142d75c5e04a31199493aa5e82edf99a26a93645f22aa5","source":{"epoch":"76534313","root":"0x65594f809d93398014a69879ba15c6ff3fa68d16a436e256ad2d3ee8643777e5"},"target":{"epoch":"76919062","root":"0x3f175b805dfc7af62a20ca2213049d6532a08ff237a590e2512bb757af7508d0"}},"inclusion_delay":"9240749398547723901","proposer_index":"9239096915331039773"},{"aggregation_bits":"0x5f432e22484195a4b732ea5b552d5b3b29e663fe60cc31fe15f4d9a03049dd870714c482950d5cf3cc5e153ebb5faa92ac09f3058db82af1565a05ff345a051eae9cbea4b66c5cbc4cfad010e5ab6f6ea3d2a6347d00c13659ade9a1a7d15de5f3ecac152930adadbfe7df69f3513b9eb9dd517462ba323072d1929d278d23c9d39695093227031e8c992aefe86153004efc1af8e4c23834d4e0118002af2b7bf8f10f5a8cd7c39c14cda8365fb6676fa939c970480f29e23a30f7d0a512a41459aeadd6c108c0d89abb06ae6f70074be4e0c4f4c89f664bafb8057d287f5c121bf2fb92b9d763ced3d79d7ab5b43b1a99c682b7e51fa46a2a693d16d9853bd201","data":{"slot":"9242401881764408029","index":"9234139465680987389","beacon_block_root":"0xfe6120809df033a7bebdd2d4575c6a6871be85a6577c28281b375a2a373e323b","source":{"epoch":"75380066","root":"0xd81f2c805d59751dd437047eb04a41ce64b88782eaead6b3bf34d399827cc325"},"target":{"epoch":"80381802","root":"0xe7c3c4801eabc71eec6a871532652bfac269a1ae6588b2cb1916f84254a6230f"}},"inclusion_delay":"9283713983656347710","proposer_index":"9282061496144696286"},{"aggregation_bits":"0xe770b76f869cdb3ab1eb04749d41c6e639be54733b4809c8a7b8898727a0b2b3d6ac0949f17d13f4aeff973482fa12c68242de753cd57e9f4ccf4021b9c38282c88df8b4e2ae029af62577218c039a97bdee709a21c8c1ec42bd77502ef10a1f253d2fb04b5ed338677e6c907964a24132c8d8187c6bb5ad8fac3e67281f9ce4e73b6613a68952a55ec9dbac3f435024c79769a711de6aa0f75626b5e460ca4e0c336d6184b101e2291c7f8e4862e150eac777810da519ccd807cd4f59fefa5bf4a55146e12c1414fa3b6b94f2e794953965ee99bbb6521a22892e906bbd6ba37b0064e91fec8a664c64b810cee7643733634deae4edf262d164679425d8263601","data":{"slot":"9272146596844591517","index":"9277104046494643902","beacon_block_root":"0x0d06b9805e4286a8d6f0556cd9765494ce6f9fd2d219044075187fd309689224","source":{"epoch":"78842806","root":"0x80cc95801d08c2459682c170cfabcf62f481993e18cef89c881f148527adde64"},"target":{"epoch":"79227555","root":"0x5a8aa180dd7003bcabfcf219289aa6c8e77b9b1aab3ca7282c1d8df472eb6f4f"}},"inclusion_delay":"9260579205737868029","proposer_index":"9258926722521183901"},{"aggregation_bits":"0x9723944e1ea44bc04c94110ed5fce2883facea1fcde8bbe3524eef1d266715bb65aeb97fcf2f8c5cd2e3574c9c42e24243bfc9808f95af2290ef296f2aa2aa1386a85d54e83caa8327a7695c8f340804f0f610d16604a16c944db6f5e5dcbf3a9951bc249c928f7dd2dc2c19769c9c116e5e69bf3de0e8d5f11954cbd8f26495d01add4d5829807e6229fb25787d9fab370e3e6c036c67b6c1bb6d5df86b87f33c92e5a58a82b7db9f9baff2149ca77e59de6a2bcdc83a6c37e0deebd892523ec4f5290bee68dd396d2bf81ff3bc17da0e6dee899c3eebed6ece5aecb1a0be5b5bee64e92626a1b1f5161519e663f5ee7d2bff7f2c5148a375259887fc7076d201","data":{"slot":"9262231688954552157","index":"9201089784167435644","beacon_block_root":"0x7cf7aa7f1cd9a508e7f8e338e00c056eeefa710e952a58b3ae4ea0cf46cf8511","source":{"epoch":"71532577","root":"0x56b5b67fdc41e77efc7215e239fbdbd3e1f473ea2999063f534c193f920d17fc"},"target":{"epoch":"70378330","root":"0xc87b937f9c07231cbc0481e62e3057a207076e566f4dfb9b6553aef0b052633c"}},"inclusion_delay":"9197784817734067388","proposer_index":"9196132330222415964"},{"aggregation_bits":"0xa2ab4074cba90a242bc75eabef189a63f99a074ed432b5a7bfff3f4cc35f6f5662dced8966b212999ae7c01e29776914d74493e5e9a804b555193bfd1bee6a8eeb595a14b1bc29cb1da893d1e1506c4448e5c8cc9060b1783a66acedc123b5016fe95bb25d51aa22485a29f9b15d63b149a2c156c2f3110f75fc03b2d3ce737b3ee114d825ef720dbf15ef259185c4426bf57a21a993f9c4ae61f36af1b9ae288cbdefa41a8adce30b6f7e86cdcdeefeb543140cf31210f73a673d407291c5257116dd2bec3202a653c4f83ea29a9a604f642f15940510810fe3889f81a927bd3482b0375f5dee6cf57a51be84a6dbd6a9a2b23009d1a9365bb3d72d4afe396101","data":{"slot":"9186217430922311195","index":"9191174880572363579","beacon_block_root":"0xefbd877fdb9ee1a5a68a4f3dd641803c130d6c7adcde4c10c15535816514d251","source":{"epoch":"68839335","root":"0x6184647f9b641d43661cbb41cb76fb0a391f66e62293416dd45cca3283591e92"},"target":{"epoch":"69224084","root":"0x3b42707f5bcd5eb97b96ecea2465d2702c1968c2b501f0f8785a43a2ce97af7c"}},"inclusion_delay":"9227529528519283580","proposer_index":"9225877041007632156"},{"aggregation_bits":"0xe3a545f845c4d2af06344a6d2c033acc1db9cacb5fee1daceb0903ae0bc84deaab62d4532486eb753e2041fbca24834a7e501c56b80127b8c3c255c74c6968f629b5e897b420c2f56ff96dde57b40a70d5ac2133db0974126587772953b55e2cd097a8063270929fd082820e955b4e81a7f81512bc9a6d229bd9f6aac90e044123a9d6821c51b60f585749926e6c76150d6c562a23bedcc0245df607d63c5cfa7fe67f5289174b5e7ce01e5e13eb242de4a0b3180ec0b5fe03a6fd52f95bd39cec381b041fa77ea04b7b28e76234e1f23e794ae6a4c58bf082d4edb68099157902b76a49cb1db76273416f0446335bd8c1ffe9ccad580a171749d801bdab033901","data":{"slot":"9229182011735967708","index":"9220919591357579772","beacon_block_root":"0x976af17f9c4d2ece68d50c30f4a20ed1a3d67d3609c26ef98940766c0a45ed90","source":{"epoch":"73841070","root":"0x7128fd7f5cb66f447e4f3ed94d91e53696d07f129d301d852e3eefdb55837e7b"},"target":{"epoch":"72686824","root":"0xe3eed97f1c7cabe13de1a9dd43c66005bce2797ee3e411e24045848d73c8cabb"}},"inclusion_delay":"9217614624924211516","proposer_index":"9215962141707527388"},{"aggregation_bits":"0x42c4fdd07452d040c098cdfe6ed2e2d9af160d80b91e5b3b04d350f06c70c2235d304634be900010cc4a505c24d81214e9fb8116e260c520f5a4360c0f0ac185ca4cba62a3201bf6b7416e7d0b2b6c2e32f1c73b9d2a99e0ff07f3b18a0b77da95665e9cd5d59ad214e59aeb6609c00fbe15b9b57bdddb0cf716a1ce4db12d87b761598c6c59f368b1f62ce783d48f6c53334e66043dae201b56aad62f2824e8db5634710faf2ef195324b36c4eb2cfe812c855153f21858bfbf167f8301232f2a3e11dce732415a87d484dc7c134a41a1ffc06269a1559f6aa7f11cd38ec14064ae06449c1e62b87b0bf7258343c7ba4d41ebfac11655ff04fbe75728763fd401","data":{"slot":"9206047238112455324","index":"9211004687762507708","beacon_block_root":"0x0931ce7f5c136a6b28677834ead7899fc8e877a24f7663569c470b1e288a39d1","source":{"epoch":"64991846","root":"0xdf19ef7e1a4d8fa48e57cca554279610b65b524e604171f8677410d892ea7168"},"target":{"epoch":"65376595","root":"0xb9d7fa7edab5d01aa4d1fd4ead156d76a955542af4af1f840b728947de280353"}},"inclusion_delay":"9141600362597003258","proposer_index":"9139947879380319130"},{"aggregation_bits":"0xfe86a0ca205206b71fd01428789ec2e1153f13f6b0d121a9317730e1fb93f8450f0fc2b18008437a5a98d2e1ed0558b27b6610c4357561461495605bad75a0aa08ff4a5df7396f5496f589037fe56ca79d24b04148533da63e04aa8e28570132fd48050d06d7ad113ea4307505671a7fd3b90975122e60554dbae3b1e0cc233f6a158350dd6790f998c17f1b02b2521ef12a83219953dfa4533063aa6cb5b8b4ef40a02115ec465fca4f55d73d4461bfa730909c60b7b0c0eab60955525ce8680d4bdfc93b010819c2aabb4c52785d8ea959a4680ffba82b9ebd409f5c0d502755139ab7698efa204ff760284c72ec308c2c928fe1bd9d4b1fd405f8d3c57a7d01","data":{"slot":"9143252845813687386","index":"9134990425435299450","beacon_block_root":"0x7822c07e1aaa89cb386f0601f16d3a79e8734ade1387b7c9d57d2c1a65f12cbe","source":{"epoch":"63837599","root":"0x52e0cb7eda12cb414ee937aa4a5c11dfdb6d4cbaa7f565557a7ba589b12fbea8"},"target":{"epoch":"62683352","root":"0xc4a6a87e9ad806df0d7ba3ae40918cad01804626eda95ab28c823a3bcf740ae9"}},"inclusion_delay":"9131685459001931194","proposer_index":"9130032975785247066"},{"aggregation_bits":"0x745029266c6c11ec7a30f70f92b41f0c8e5aac5bfb565cdda71038d6615adffbd02f6a5a9e49325f718810cad1f4444695157cb4ddd864b8c60823243ce4426574d10c017a14b3e8b93e063b86cd525e57a946ea583608ba1518162dbd42364c4cb0daa8e63193a0f391f50d8d1550bc5f97e13d64a14f5d3df6efe77cdd0d260ed8524229d145197a998a5815c1881a684936d6246f1432f09c74cd003e4b0892a26eab9a1ad049374aba081090efad6840be62345436ca2afb34c2ae503a8f84f263db162df9d9822696666eedba18fdea8d047f93943f8a8961460a81eb5315c529ac2d1fd267561d95914723719cc52bd956e12f5f4b50931dd82dc8630e01","data":{"slot":"9172997560893870875","index":"9177955006248955963","beacon_block_root":"0x87c6587fdbfbdbcc50a28998738824a54525640a8e2493e12f5f51c3381b8da7","source":{"epoch":"67300339","root":"0xfa8c357f9bc1176a1034f59c69bd9f736b375e76d4d8873e4266e6745660d9e7"},"target":{"epoch":"67685088","root":"0xd44a417f5b2a59e025ae2646c1ab76d95e316052684736cae6635fe4a19e6ad2"}},"inclusion_delay":"9161430169787147387","proposer_index":"9159777686570463259"},{"aggregation_bits":"0x26e37a76bfbf98c3e44fa37d999b5a504b35901c55f0c33650aa481267bf50380ceddb4ce8aef9f36cd5c0b2c60a3d4254fb4a3567acb415f32d4baadb858bfd28b9e8c1756e78cdfe1c5023959d28cf8a20b69cdb73452e6be059c15e1f0bf12a9d0d98f876aac5a63f051c8329ed56044e783d852cba20c1b244471eb17ca158f1ab5cd0e537a8d66baed15eef0d1f81ccf76db7dd9960c64cae238835be3c000beec63409354d409f6ecf164fe883c75111c11450a9436534366a090a3ee2b61055bc046169fc163a67a7c8f4753f53eac54558a9ecd5d69a9c3880bab3ca151b0cac4e5733d4ed36b89bc317e0550f44436429b1718cc8d8e0c3d6a1275801","data":{"slot":"9163082653003831515","index":"9154820236920410875","beacon_block_root":"0x9395067f9b1e1291b94b2ff8060444dc9d4f5606871ece0fb06f02b72967943d","source":{"epoch":"66146092","root":"0x6d53127f5b875307cfc560a15ef21a42904958e21a8d7c9b546d7b2674a52528"},"target":{"epoch":"911092286","root":"0x8f75966cfaa05bdee8957d48abbcc1f03dcf3b8b347be4b76f2304ab019580e5"}},"inclusion_delay":"7829528113024187930","proposer_index":"7827875629807503802"},{"aggregation_bits":"0xa6a269164f856a9609146afb94353e4c2d498d0cb007f58d92986b5533c3ac9ac7c20e0d1beb5e9d05b9ebabc4a8f2c6eff74ea643f9483f4f068f16a11906e67dea5d9e6c3bd2c6ecd46eba5a6aa99aa75b68b9faa9ce4e3fc8d6551136628804a7c8916baecd63d9ceb03280eb3d942737693f3f6caa9370f4bd855559911dce78807b487758791a385eaac25fc87c8d0096351d7999507cc044e87fc6d315b5baaa200968a7d0b3df5f4a0d992e25f3176396446aa1cfde461e4a188dd9506048c50b83698378e2058bdd7fcf70e17f5df5de25b0de0e7de403b949b0995eb78e8edbc2f585bc4a0243f8b16c80287323473cae87a1a4cc85f84b3cbd493b01","data":{"slot":"7817960721917464442","index":"7822918175862484122","beacon_block_root":"0xb5b78a6c3a381a68d21b4c9f52ceea8a49d539afa00c362cca258b3bb656effa","source":{"epoch":"909553290","root":"0x287e676cfafd550591adb7a3480366596fe7331be6c02a89dd2c20edd49b3b3b"},"target":{"epoch":"909938039","root":"0x023c736cba66977ba727e94ca1f13cbf62e135f77a2fd914812a995c1fdacc25"}},"inclusion_delay":"7806393335105708249","proposer_index":"7804740851889024121"},{"aggregation_bits":"0xd4724a668c9236f8a9b8f8809699927bec4a3b2017232776e7284b8bbc32a27f65047577a52b47bd0aa1bad7d4c443d33847d3c36869d9023817e79940282e7f839bf02ee78d7cee71b619a749347f2926418babbce9845ee8320ff0da63ddefe8881ab9f4ca94c6acbaa2e01f93206c3d6198bc6ce175ec0ceca62719196bda785d3c35b0670aee360b6ca999314bf33c9bf3c8c7cf70425e528fad67df96a3e35e2a67275192f1a6604a8c40264b0b4c4c6e08c07e2f6d0ec10c2f4a461d1f16133a000c2d4a7db5888c0ebc1cf9def35fd5d81208aecb9183c3c6d59bc52bc74cbed7ff2d262ff329ca7296c0511041c9e54a0e7fb9a758880bd1a0370bc901","data":{"slot":"7808045818322392377","index":"7852662886647700315","beacon_block_root":"0x5d64f46cfbe6669094660992712f791fd99e4b6bceef57159210cc265b870a3a","source":{"epoch":"914555026","root":"0x3722006dbb4fa806a9e03a3bca1d5085cc984d47615e06a1370e4596a6c59b24"},"target":{"epoch":"913400779","root":"0xaae8dc6c7a15e4a36972a63fbf52cb53f2aa47b3a712fbfd4915da47c50ae864"}},"inclusion_delay":"7849357920214332058","proposer_index":"7847705436997647930"},{"aggregation_bits":"0x4ce3f38b50aef8aaf65cbdee75fb4ef6f3630ea15d674743e5f55be98ceec4ebfc363dfc174802782a2f7b79cd443b078130fb3307808be0aa9216e6cdbb39ef798e947f3c89a05986a8a7d6b01949f0bc47fd5fc0ad98c4caa880075371681b76680dbeb638faf3f5fd033015ef8abbd0d353bc644472e67c9cb3d1af0ec4534c98cf0344efdb5e64db9c604e029085b7fca275b2d7cfd8e9f5a0d7cf5f799c15d848cc2d1d58832901e45242b23d14033040daa08d29215f70347db50b3f59db92d2d6cc08d689b595b730b08f1809a5cc9cbe5020d81219b8daabd5171b3be71639a871344ec9484bc7dbfe89895c534614d724a87fa7b3cdfd771b6a1e2601","data":{"slot":"7837790529107608570","index":"7842747983052628250","beacon_block_root":"0xd02ad16cbaaca22d53f874966764f4edfeb045d714a44c72a51761d879cc567a","source":{"epoch":"911861784","root":"0x43f1ad6c7a72deca138ae09a5c996fbc24c33f435a5841cfb71ef6899811a3ba"},"target":{"epoch":"912246532","root":"0x1cafb96c3adb1f4128041244b587462217bd411feec6ef5a5c1c6ff9e34f34a5"}},"inclusion_delay":"7773343657887123801","proposer_index":"7771691174670439673"},{"aggregation_bits":"0xa2e594d490aeb715744b64217bb74ee6c96e4065f041b98bde48637c1b05be8f2a1f789159d2277685f2f96805f2038847efc805dfd58ab44b8bc134e7aecc8aff9e6d5d78b594f9efad50e594de497c1a1a397401c05e002a8ade1ce7221cb1b74e062b5e28ad9e4e364bac647d90c538cfa56c4f95e39e5eb459df2c1d41639bee963371dbbc0f6f6ae8942736ee45afe9a93ea719be70a79211ac4888c1a5c66ff490aedc6c7c74727fb2f759e056a1b4973b957a05f91fc50e921046d4e9e8ff89eb74fae9ccf27fc9d6ad640f459b68912530725fb73db3f2b8a8b46b98861bb04a1624bcf2e43ef44273b813a6123f6f8ac60abb13aaea2bdeefc87f2301","data":{"slot":"7774996141103807929","index":"7766733725020387288","beacon_block_root":"0x3f1cc36b7843c28d640003636efaa4c71e3c1813d8b4a0e5de4d82d4b7334a67","source":{"epoch":"904551554","root":"0x18dace6b38ac03047a7a340cc6e87b2d11361aef6b234f71834bfb430272db51"},"target":{"epoch":"903397308","root":"0x8ba0ab6bf8713fa1390ca010bc1df7fb3748145bb1d743ce955290f520b72792"}},"inclusion_delay":"7763428754292051736","proposer_index":"7761776271075367608"},{"aggregation_bits":"0x2481a6b82c1921fe3d74457123a61af53b61d59e7251ee2aa5b96d22ffa5b96b444d5b76d6c60b527e18e1cf62cfd0dfc60093851cd5f0003fd5b17e6eb44de33a5612996d5101e93df51146f84e0f03e84edd7043c5b170803c4ab49c92370df0bbf819b1ad81f9a8d1554916875f43e91a4c9208da7fb1cac7160870ca6779b43239f784dbe9f8c507a961e8dc16a4099e8172891fbcd0c0d228e3b546f1b0465a9b98b0568d83afc0afdb88c1c28bd2a4a1b67a7e3459979444b8d955052fbef912564db3d413f7e7745df0f2647612ec5f33ff9ecb8b35da6ec475879f2dadb68cf253cf2b8bf4740467b7c03b75158df54fe24aecfb380a10ca639c015a01","data":{"slot":"7751861363185328248","index":"7756818817130347928","beacon_block_root":"0xb1e29f6b3809fe2a23926e67632f2096434e127f1e699542f1541786d57896a7","source":{"epoch":"908014295","root":"0xc186386cf95a502c3bc5f1fee5490ac2a1ff2bab9906715a4b363c2fa7a2f690"},"target":{"epoch":"908399043","root":"0x9a44446cb9c391a2513f23a83e38e12794f92d872c751fe6ef33b59ef2e0877b"}},"inclusion_delay":"7793173465077267929","proposer_index":"7791520981860583801"},{"aggregation_bits":"0x488e4734b7576071c98bcb6ce6f5f65f9f44d01d38b75204f9097502876b02f211fb446c91f6f3bbfed7eb3e2617620968101884dd59cae7291ececcba3cf397d9a2023e6ac5c3c617f4ad192ebb0ff5610fa4b198a4359a854e40450cc6de2e41d23eaace8bcb4e5729bcc6b3b9267b6e089d94f8b50bf8c0a8d641974e367f18621d5b3c771d7ee3d13b5e3d6fa2f05727bf7919b7f9b013c93823804ae32c6505cb2baff8163ffe2dce0218188a5680d745067119907a86b5342d37d022f2a78c54b4ba13bc2d26eb776b60690bf4e1f17b4868504279b4851fa91cb36df5de032748c7ff72c5526e39c974559dd237d815798e875fde7da6cfd7a039212601","data":{"slot":"7794825948293952057","index":"7786563527915564121","beacon_block_root":"0x598f096cf9b74a53e5dc2b5a8290ae2ad317243b4c4cb72bb93f58717aa9b1e6","source":{"epoch":"906860048","root":"0x334d156cb9208cc9fb565d03db7e8590c6112617dfba65b75e3dd1e0c5e742d1"},"target":{"epoch":"905705801","root":"0xa613f26b79e6c766bae8c807d1b3005fec232083256f5a1470446692e42c8f11"}},"inclusion_delay":"7783258561482195865","proposer_index":"7781606078265511737"},{"aggregation_bits":"0x6616ff0e625ea85583de9980d9b1e6b4590535500034c8d416580c3442070939059150ca602f791f137e34589fe3b8c7b80acc73bb64c0306cc8f9d6dc328bd886dbad7a3f2451de33fb55d060e42b53d91fde88c6cb264c404dbf3888f3fe533b5fd3bd8b43a8d50d8539be7b3bc5d908b0117e0facf1e6c09f1859997204c8769316e345f2de1da8e00f525fdf185213dc9954a9c277623b12b6b59b93427c2b2f056b3ad375036e5dde7d6c3a68d67f1c38072bf22ecd8692c627ef44948d023da3243d645ab0b81467e321cc9626b2f896d7c1e4895b85cc4e1a28aa95aff86ae3f7f6041d7855227e7a5298b5c027497b87aa47bc4f7d30d20ca7ed5e9101","data":{"slot":"7718811685966743799","index":"7723769139911763479","beacon_block_root":"0x2f782a6bb7f16f8c4ccd7fcbecdfba9bc08afee65d17c5cd846c5d2be509ea7d","source":{"epoch":"898010823","root":"0xa23e076b77b7ab290b5febcfe214366ae69cf852a3cbb92a9773f2dc034f36be"},"target":{"epoch":"898395572","root":"0x7cfc126b3720ed9f21d91c793a030dd0d996fa2e363a68b63b716b4c4e8dc7a8"}},"inclusion_delay":"7707244299154987607","proposer_index":"7705591815938303479"},{"aggregation_bits":"0x7425d61ee6e4a96f206719f3d80e6a93c7420936c6367e21e1ca42c17bc88e34ad07774c22787212dc877420829c29f36f0250668022111df4f8a95839038d5bdc7e809231deed50a6aa0a9143f0ffe09d97bddf19264c0e17d5ccd671e46174563501a59826b050181ddbfd62857a8751608069d42326be36c2f78e4bda3101e1b6abad3c4a29c28a531d5dd69194dbeb45ecf2b37e9a90899a7ccf83802740b1a7adac3143132b50748f0b62c50df8e84325a4cbbfb0ce7c55c0aad9be5cfb62f44037a420d6b4ef9414a63014379837e0ee86e6fe70f2a98fe0f4a0a3c9fbc8eed4f20f0e3e8fee5937f37714283d7401d9b302f204aa7c792b1f1ac75a4501","data":{"slot":"7708896782371671735","index":"7700634366288251095","beacon_block_root":"0x3b47d86a7714a650b576252b7f5bdad218b5f0e2561100fc057d0e1fd655f113","source":{"epoch":"896856576","root":"0x1405e46a377de7c6cbf056d4d749b1380baff2bee97fae87aa7a878e219482fe"},"target":{"epoch":"901858312","root":"0x24a97c6bf8ce39c8e323da6b59649b6469600ceb641d8a9f045cac37f3bde2e7"}},"inclusion_delay":"7750208884263611416","proposer_index":"7748556401046927288"},{"aggregation_bits":"0xfe772f62b89f77356da656dd5808d70e7fbe7e8bc55142506d14c8fecd68a1a0723f7b272a0d6fd5357bb68a9e4cf50706557cd6a8ad81e32855f0068884b8818cced5ca2cf8b3e3d8b3fc9c2a57663b82185b7b4dcf4cd2a984e179e23234ccd9c1dc021ad4de61c09e0aa0e8676a77de076abffc9a39a34787e34d660d473c9519199b2be67c69400bcc9864925e7b603add840666303c6d2cfd687541d6f3c9454b9639b78b31ff8719f5c37f13d99e3f1b5a8611b4068be2f6b864d552cb0b472cf133452940ee043b08af07d64e4873fde295464e2761e89319fd2513c8887251ed219507c45563f218454fffa6652c046e220842822b28b711249a4f7d01","data":{"slot":"7738641493156887928","index":"7743598947101907608","beacon_block_root":"0x4aeb706b3866f851cda9a8c20076c4fe75660a0fd1aedb135f5e33c8a87f51fd","source":{"epoch":"900319317","root":"0xbdb14d6bf82b34ef8d3b14c7f6aa3fcd9b78047b1763d0707265c879c6c49d3d"},"target":{"epoch":"900704065","root":"0x966f596bb8947565a2b545704f9916338e720657aad17efc166341e912032f28"}},"inclusion_delay":"7727074106345131735","proposer_index":"7725421623128447607"},{"aggregation_bits":"0x8ccc0c5ad10d393afbd9c8a6513dd3a0bcacabdca295d0bfa2eebe3ccde42650865369b91ccbe2f72e22643098314482c9a56bd2107751cc11e191986f57b200d0ba28682746d8efcfd983cd2913f980ae22332a03826ec8bebcfe9403afcbebb5ea09960596d394f426692ba5c3d5a986e790b98f234cdbb81a0bf9f1b5741f203aaed5d2c68c9e24ebec9125a9ddf8d003983e14d0d8324de77c300bca8fc92ae4d21b14a24c02da824c9309c146f0c004a7f92e7cb96ce105e515ee2fb2a4712b9648ab01a2453d08e84bea9f5d218d7195e3b25cf7bce8aa3a67349d4116c8ac43ef49cde673ec18ff10f0e2265bcb43a31dea789244ab012d16ff130c4b01","data":{"slot":"7728726593856783159","index":"7667584689069666646","beacon_block_root":"0xb9dc626af6fc17b2deb1368f070c75d895f1dc4a95bf2f87989454c4e5e644ea","source":{"epoch":"893009087","root":"0x929a6e6ab6655928f32b683860fa4b3e88ebde26282ede123d92cd333125d6d4"},"target":{"epoch":"891854841","root":"0x05614b6a762b95c5b3bdd33c562fc70caefdd8926ee2d26f509962e54f6a2215"}},"inclusion_delay":"7664279718341331094","proposer_index":"7662627235124646966"},{"aggregation_bits":"0xa6d234500400b2af7c8a34522a30030f77b86fafa2c2de7fe57bde012a4e5ca9060f5d45980347e9430fb71039c51df9196f3516c558735fdd33d792abbbc8ed9c1b6720fefa963762dc4944aa488dc056906b37fe2671627b0929ca15009b9642167201c451a14fed36eceb425a271aa10e3453501e8553c1eee684fe8944a384d93f6f3b024ad3f9d7fa918f504e198c699c2bbc659b546f7f7895411ac2f35ccb1c51f74d5e325bd25e6de032c470748b9a5e7cb6b3ebe103421f0eaf6dfbcd3c40e82f7a4bdacff3a8a39b5a2bb3df5b6c7c1bb80cbecdc22d34809d17ecc696c79f6306cf8eba7dabb7ee267a496067c936eeaad1f689b762c5cad0dbfa01","data":{"slot":"7652712327234607606","index":"7657669781179627286","beacon_block_root":"0x2ba33f6ab6c2534f9d43a293fd40f0a6ba03d7b6db7324e4ab9be975042c912a","source":{"epoch":"890315845","root":"0x9e691c6a75888fec5dd50d98f3756b75e015d12221281941bea27e272271dd6a"},"target":{"epoch":"890700594","root":"0x7827286a36f1d062724f3f414c6442dbd30fd3feb496c7cc62a0f7966daf6e55"}},"inclusion_delay":"7694024429126547287","proposer_index":"7692371945909863159"},{"aggregation_bits":"0xea7edfec57e1ba3e41713855b9222fa59b9ba20382a7de7339a7d2cb80873eb84bc1661dee3b963ca1f025ef781f0ce9bf4dbf3519c4b2584a9eafb45f1932957fb3e78bba74709cc1e3c643b4f14e5d0bd932d8a6eff99cfeeb2b98f344e3e77dae0db66576caf27b6aa55f644d4f5e0355bc1188e35d0cfde3070dc58d160fd189b947937abaeb5f897ea6123ff82eeef3a108a4041f54b427e968661540633b9c4ba5b41b948d287b393d3bbaccab8c5c1eca45f215f852c3c628861e6e16d56a2a8bc4d9616e7e7afad37be11931bc6e48918c04d54544bdd0353d816116f3e74d7fb5c45a80424ad589acb2c86501b9a9c08e05e3b74dd0ed103be960e001","data":{"slot":"7695676912343231415","index":"7687414491964843478","beacon_block_root":"0xd34fa96a7671a0775f8e5f861ca27e3b4acde872085746cd73862a61a95cac69","source":{"epoch":"895317581","root":"0xad0db56a37dae1ed7508912f759055a13dc7ea4e9cc5f4581884a3d0f49a3d54"},"target":{"epoch":"894163334","root":"0x20d4916af69f1d8b349afc336ac5d06f63d9e4bae279e9b52a8b388212e08994"}},"inclusion_delay":"7684109525531475222","proposer_index":"7682457042314791094"},{"aggregation_bits":"0x6c33e5cceba12efa87ccbd074bb1f1f62a928f404367b8e3f2b7c19da5f7f48075db44b864743e495c8a25404632dd3827f207a655e632cc12a28e215febd9f69c5edc5aa892a18a0b1384c8c069e0aa4dbdfcd0a4a210ecd66bffb86c480d0978d9fb0c40d3c6bdb51d9dfad79e80b47eaa479acf0c6f264f3402d805de015de5513607e632edefb7353b43dd0401b3f507a86412c95db47b2e9d2bff89787f9f2002a692af8d6c912bc91793bbde75d6ec29c29ad1801868596d80b92d9bf11b6aac1da01b163e97e754580757630221d28201430a49722dd5cc955d52be29975ea0c0a9c787f8fa242face963f43fdb07b2900e650d18dadbd7dae7b44e5c01","data":{"slot":"7672542134424751734","index":"7677499588369771414","beacon_block_root":"0x4616866a3637dc141e20cb8a12d7f9096fdfe2de4f0b3b2a868dbf12c7a1f8a9","source":{"epoch":"935716215","root":"0x02ec856fffd0b56e4a1bdc94db527d661d4cba8b082080a38c8c4389d127d089"},"target":{"epoch":"936100964","root":"0xdca9916fbf39f7e460950d3e334154cc1046bc679b8e2e2f318abcf81c666174"}},"inclusion_delay":"8031131155653964767","proposer_index":"8029478668142313343"},{"aggregation_bits":"0x0655371adb725ecd26494168425cdf84b80e7b89627dc3100f7de021a018222fea52a15fe887626a8729a8830dd75c4c52e2fdea300fd110285c287ab485587e38310755ab74b9dd13bbb384e1a111b4cc85fc7f88cbe181317e030153ff47fb8fae02c1e974b3442bb400dccebf9b67ddabbf2c29932639e4aaca881a0d73e03e6601bceb358a2f37cdcd9eb448bce705bb25ccba5f16602ab58cc1dc7ae8bf282ed07a67543276f28f1a2856f3553f46549bed5bdf3d23cac33c1fffd94d4477d999b64e65b1fd2ca790a38308cd8383af3dd2e710c05cf3a197f347da87941ff0678d5071c08dacabcd1ed666fe406b77059de56858bfcf6c67dbb202938f01","data":{"slot":"8032783634575681599","index":"8024521218492260959","beacon_block_root":"0x9bf4566fff2db095f43216f0789921cf4f64b21bba65c674fa955fcba42e8bdf","source":{"epoch":"934561969","root":"0x75b2626fbf96f10b09ad4799d087f834425eb4f74ed474009f93d83aef6c1cca"},"target":{"epoch":"933407722","root":"0xe7783f6f7f5c2da9c93eb39dc6bc73036870ae639488695db19a6dec0db2680a"}},"inclusion_delay":"8021216247763925407","proposer_index":"8019563764547241279"},{"aggregation_bits":"0x1e6c2f7387c190dd62ad2e0439525029a02544ed19fb6be1a011281fba6a2def09402785d6f6afef67122a89020383c97b95d99e5fc085febad35c167d9e89b0de00510ce0f3756800d635fd8809064dd6c9a2df7eab40598b201a3edbc1220513de99c44fdafdf1d2ade52f44fb4368bac154485702632195f0c63383b0457f2847d2aa70c8da9db1953c6ba32b6e631dec70e74d57aef8c9232be6c0ba0b82d5ce12616da4ac0cfc3eddb6f523ca287a2b372d5a3445fd0a68040109905727dee066a408616e696ea7a9995e9c3a05d39dbbfe84bc74685281ce1a04572c2777af72db5deaadc09a9119a5e564e905311a5e40d5db9cbf8429bff90d40869a01","data":{"slot":"8062528349655865088","index":"8067485799305917472","beacon_block_root":"0xaa98ef6fc07f02970c669987f9b30bfbac15cc473503a28c547784747658ebc8","source":{"epoch":"938024709","root":"0x1d5fcc6f80453e34cbf7048cefe886c9d227c6b37bb796e9677e1926949d3709"},"target":{"epoch":"938409458","root":"0xf71cd86f40ae7faae171363548d75d2fc521c88f0f2645750b7c9295dfdbc8f3"}},"inclusion_delay":"8050960958549141599","proposer_index":"8049308475332457471"},{"aggregation_bits":"0xecb5cd42319bc5aadd93db3f314ee43f6f2459e35f59698c44335e993fa40a3eeb069cb3e835b0c2ac2e6ae10c701b8d442c7d7be08b94c3c7e7319a8ef783231065f7efeb3cce40ddf43acc8b3cd5def691418813ce0b5bf49c5dc2509fd7206d7b4afd4097d5f4e30e21be9843fc98a29ced0f1495fe5c6b672dd4815831fcbfe26efc81fd096b994d5e06a014e7c83d7d11081dc95162fec2e17c50a14636c54d8a9b4271496f68ff8d709dfaaf16e6731af23e388fdc6faf04a01a78334ae4b65d810145e10cfd3b6e595d08f5ba7c1cd3efb382cd077a86eaf6d3ddf8db47f0f18bc7a08a632dea10ad530876bcff11f45b1567a47c182046e2d326c4e801","data":{"slot":"8052613441765825727","index":"8044351025682405087","beacon_block_root":"0xb6679d6f7fa2385b750f3fe78c2f2b320440be432efddcbad587356867a4f25e","source":{"epoch":"936870462","root":"0x9025a96f3f0b7ad18b897090e51d0298f739c01fc16b8b467985aed7b2e28349"},"target":{"epoch":"929560233","root":"0x650eca6efe449f0af179c4014f6d0e09e5ac9acbd33699e845b2b3911d43bce0"}},"inclusion_delay":"7988166570545340958","proposer_index":"7986514083033689534"},{"aggregation_bits":"0xd69f5064a36645cdeac4bc99c96adc8008278c1276c3668c89683fccca06a5f7cd5e891e5378024451007db2ad06587336a7b11f14b6b7440f977798de382becffd4f3a630e050a8f9f9d045894a60da2e829fb56fe399cd59a992ad342a811b96bf756b0d77b46fbd8f954635c0037015e04ba7fbae04665381ebac8d66e24359a9846ef49dfabb50510a424ca55a08e18f177797dcf590d458ef8b0e71cf8c55224283f35f7b1e7a2e9e9dd58cd59618bf60d1e0c3051e469cf6cea0de2d353a53882307cb2c53ce986af01ee05268243138709b461eb35bca3a41f7d62821618bf5b0b65bf1aa7a8f5543e3241c647f0b119019af4ff3bea60a0067a3035d01","data":{"slot":"7976599183733584766","index":"7981556637678604446","beacon_block_root":"0x8c50be6e3edc5d94dcff9258f67e37a3f1b298ef3fc8ea5ca0b43a22d2042bf6","source":{"epoch":"928021237","root":"0xfe169b6efda199319b91fe5cecb3b27117c5925b857cdfb9b3bbcfd3f0497736"},"target":{"epoch":"928405986","root":"0xd8d4a66ebe0adba7b10b300644a289d70abf943719eb8d4557b948433b880821"}},"inclusion_delay":"7965031796921828573","proposer_index":"7963379313705144445"},{"aggregation_bits":"0xd4056934ad2c04b7d277a9b24187babc8f260a56f472f7e31cfa68d6c8ef2ebe6dd4be1165ba5becdc582fcbaaf9e1777117349bef767238d2ab16d6a9c93b67a9bd3416e83ee9b546de9e5082afb301938879ceaaa6f2dfaf519351bddf3a3eba9da77737b2abfae427d7c5687c2b24bbd3ba413a01f30ea8182e05639992966e0c3864018d2b20f8d328d50ddb03a7011a529722d852c2669565c846fa0a7056c915cedc4a1d2fceb0cafbb733b89937c7fff7c4898ab5adc3f065b4a42d72814c7f5b15e7c5971d046fc10578d9432b3c3a7bbc1ce719368c46bfebed3db7010d45f107535b3941f49c61504885d9f041a3c1099033145df79712bd285aef01","data":{"slot":"7966684275843545405","index":"8011301348463820638","beacon_block_root":"0x34fd276ffe8aaabc9e4a504b15e0c537817caaab6dab0c46689f7b0d77354635","source":{"epoch":"933022973","root":"0x0ebb336fbef3eb32b3c481f46dce9c9d7476ac87001abbd10d9df47cc273d71f"},"target":{"epoch":"931868726","root":"0x8081106f7eb927d07356edf86303186c9a88a6f346ceaf2e1fa4892ee0b82360"}},"inclusion_delay":"8007996377735485086","proposer_index":"8006343894518800958"},{"aggregation_bits":"0x5a5ee0ccf18bdaad139767dccae36471df4d2d7fbfa5c8d29e3669f1f6270d0e82de32fa9b8abe8936a7a9e09669b9b3197051eb85fb76d7d2240b1a8b63c8b5dd8053c824b8e75711233da96303a4f819c60760b4c5734786420cef3e6f2bc02568b84095d4c4afa4b572dcf280a1d652ed712540bcec01dd4938da741fad9e5a0deb36bc1d7bd90e8bd9e0dafd10b198597132785093f4c0216eb682f3ff0522995374d63c8631d1701d25048f868678d0d18d04b0a6e9e7f89d71496a4b790c6da5dc18ef75771d045659d1620cd8deb855155664d3cd1eff6356284186c4200312ae25d039ee54f6d9f0605812c0cb65e4585920f13469a28f3a426507fb01","data":{"slot":"7996428990923728894","index":"8001386440573781278","beacon_block_root":"0xa6c3046fbe50e6595ddcbb4f0a154106a68ea417b35f01a37ba610bf957a9275","source":{"epoch":"930329731","root":"0x198ae16e7e1622f71c6e2754004abcd4cca09e83f913f6ff8eada570b3bfdeb5"},"target":{"epoch":"930714480","root":"0xf347ed6e3e7f636d32e858fd5938933abf9aa05f8c82a48b32ab1ee0fefd6fa0"}},"inclusion_delay":"7931982119703244124","proposer_index":"7930329632191592700"},{"aggregation_bits":"0xa692b1c8310b8d58ec97ba11082c666cec46439a1242f28b819a1160e58847ee2080b76497026be5916f6e194fbf813d0d9f723ef8eada0280fc4e3e09aeb9b01e30e3e17024398748a4ca9a9beda17db7dbae1f356827834e59407cc93c7b2c4303a39dcd50bed00f73395213e2fbf6b3708fed29477059cfe49a445766b02e8fed27a604a10c61059d987ef9ca6c59bb402a7507ecf1f08d47ffdb284d717c32ffdf23ddf7e1a22d0bf35d24405bc4d6dce444bb07a421be5dc2da0c37349c2c0cce09f06e6c3552f6280bbc02bbce572c9c9e20060661cab7d24536e21eaf91760bc86248e9a4f0a36add69b0a9e21e9db926e1a274b6721d5595a8d2064501","data":{"slot":"7933634598624960957","index":"7925372182541540316","beacon_block_root":"0x15b5f66d7ce705ba6ee4491c11abf1dfc619775377705516b4dc31bbd2e18562","source":{"epoch":"923019502","root":"0xef72026e3c504730835e7bc56a99c845b913792f0adf03a259daaa2a1e20174d"},"target":{"epoch":"921865255","root":"0x6139df6dfc1583cd43f0e6c960ce4314df25739b5093f8fe6be13fdc3c65638d"}},"inclusion_delay":"7922067211813204764","proposer_index":"7920414728596520636"},{"aggregation_bits":"0x02fe9beec59c1b372aab15c7bebfbc6d0f4af4419084e41e06cb5f3e92c8f86e4ed884081d05169062d16efeb160506f1e501c69fa8a3c7aa7e4289c88556859fc5ad52077a2c880ba1c9f314f04d67f710f6e17150dcaf3c4dfb65c7309c4dc263e45b74371bdf5c19425b728b879397b8c6e4a6e38d1527f309f018adaa3242bf3b8a434296a27ef55fd0a74238491643fb219533b91448252a3a091d97b61b24994735b470021c3195e1d25c07938313ec089fe05b181649e69f4632d7743ea0e419e1cdd53ebd75b9190a536c4b9c99897986d4ad05603d5ce6f63f1c290feed865d23473dbcc5eb10fe0c48b7ad8825b354f5d30e48283d6ac1340f3a7c01","data":{"slot":"7910499825001448572","index":"7915457278946468252","beacon_block_root":"0x887bd36d3cad41572d76b52007e06caeeb2b71bfbd244a73c7e3c66cf126d2a2","source":{"epoch":"926482242","root":"0x971f6c6efdfe935845a938b889fa56da49dd8aeb38c2258b21c5eb15c350328c"},"target":{"epoch":"926866991","root":"0x71dd776ebd67d5ce5b236a61e1e82d403cd78cc7cb30d416c5c264850e8fc376"}},"inclusion_delay":"7951811922598420957","proposer_index":"7950159439381736829"},{"aggregation_bits":"0x4ef340600ee252ac2770294c29f91cd7eb68e1f1f7437059c253619aba262e576304afc0dfb5ef61a22a7c1d523ac9adb340dbca781617d565e957be5fde82a93e24450b63260bba225da3f6d1b6861dcccf77f9efec469d8339260dab3bb3ff91c6abe0f8f39c5053688b22c6b64c58ec97b428bc45bc0c630cde58cd1bff104f212aee0cb5af1d291d4fb6839622e4c2a40e19e972b7341918b246b6dd6df1d1c401c05d939a9d96bd7cd5de0de9456bff541d0fe504fabc1d7d65eba0529e545303beef4e3bc5846ed4a24184fb7fbda5f0e657a24ab58aaa2e47e345f44a011498beb71124f2e2c3ee6e86dc2107a9f982e219efb0596c55340ceb361de601","data":{"slot":"7953464405815105085","index":"7945201989731684445","beacon_block_root":"0x30283d6efd5b8e7fefc072132641fb427bf5827beb076c5c8fce07589657ede1","source":{"epoch":"925327995","root":"0x0ae6486ebdc4cff5053ba4bc7e2fd2a86eef84577e761ae834cc80c7e1957ecc"},"target":{"epoch":"924173748","root":"0x7cac256e7d8a0b93c4cc0fc174644d7794017fc3c42a0f4546d31579ffdaca0c"}},"inclusion_delay":"7941897019003348893","proposer_index":"7940244535786664765"},{"aggregation_bits":"0x7e6fc80cd9a29a9ae033c7f6d689457c22f6b400e6f46ad1ad8ab5bd1feac03ec15c8b2d8dff655fc7c7af21f25e163721db106e9c3b9f42853e10110f17eba273d743532b95419a2472c33792d6e21b5456696592055188260779108fdc95064f104433299bbccf48ccced24176cba95b2b3ac74b7c568471ca9a61c225cdb5a882a27e2111dd72e601debe222d910f1e5dcabf63f55a765b827cf0fc0fc6d98d2b4f9489dafabc04ee772ab73fd3458c347b3a950f8a15b6084a6b53242fa54ce6f61cf900e11c9699940ab0c844adf98c5b7c0f20948fe3ca7fb5d6ec64b19f2e88e5ee6ea827e6ffa8c168120b8c084989a81d6f63ee3ad32a457cf347f701","data":{"slot":"7877450147782864123","index":"7882407601727883803","beacon_block_root":"0x06115e6dbb95b3b856b1c684909007b468685d27fcd279fe5afb0c1200b82579","source":{"epoch":"916478770","root":"0x78d73a6d7b5bef551543328985c582828e7a579342876e5b6d02a2c31efd71b9"},"target":{"epoch":"916863519","root":"0x5295466d3bc430cc2bbd6332deb359e88174596fd5f51ce711001b336a3b03a4"}},"inclusion_delay":"7865882760971107931","proposer_index":"7864230277754423803"},{"aggregation_bits":"0x4691bb510e5587b057bd53c17db5c04a63ff38cc4670fa305a3b53d58a0d437f333eb81b6b3bfe5bc21efd1bf1b1a373e672974e274d4e1fb03f703afcf2fa250df2c7a3316faaaf99c1854f99e1d088384e03f0d64c3b8cf0bdfcb850c420e1811d960b165e874a75449e499dce5069d7d6ab4012d92dfb81573f89b2d8f24e7ea31e38da218ea5c0836d35414e12812ec68f14534b246c694333b08a9489e94038961682e9cf9d10a537ccf548b66a1748e631e5021537fd4f09e2416e696af6ab0d54eb64395d4715d3eb35d087875e8d33017818612486c88b498ed5304c8ff82ef557a643905fd42168cd9e9661e02b5b1a555aaf2de49af57487dc033001","data":{"slot":"7867535239892824763","index":"7859272823809404123","beacon_block_root":"0x11e00b6d7bb8e97cbf5a6ce4220c27ebc0924f23f5ccb42cdb0bbe05f2032d0f","source":{"epoch":"915324524","root":"0xeb9d176d3b212bf3d5d49d8d7bfafd50b38c51ff883b63b8800937753d42bef9"},"target":{"epoch":"920326259","root":"0xfa41b06dfc727df4ed072125fd14e87c113e6b2b03d93ed0daea5b1e0f6c1ee3"}},"inclusion_delay":"7908847341784764444","proposer_index":"7907194858568080316"},{"aggregation_bits":"0xbe0c323c9e5869fc1b7d14ad97d37d8f7d9e5f6c07b19045d6f69ee2f19568cfc88c10d1e558b39ea1a23f35c9f177b64e05f33e0da23ed862a261db7666ecbb7bf3a379f46b7481ce1e6ef378edae332730f11098c23b12ede76741c5ec579d1dc5493cf829813fa0537bd586bafce73ca8402a38789e60f5323f573cc8be618b4eaf2eb29d5c0e2a9b9854f66ddc072799fee3cc633cf44f75160f74ce4e523c48703dd28e05ebc634f813446ea049fd7fea6730e83dce314877f4bca6e3ae5f987b43e6602cfd4681eaf5684a6415410f304db33095f126e7a2a4495b8a34cf667b82559d615344be64b2afce5367f989d263d5a0ed056d9fafd47185145101","data":{"slot":"7897279954973008252","index":"7902237404623060636","beacon_block_root":"0x2084a46d3c0a3c7ed78def7ba42611171d44694f706a904435ede2aec42d8df8","source":{"epoch":"918787264","root":"0x934a816dfbcf771b961f5b809a5b8ce5435663bbb61e85a148f47760e272d938"},"target":{"epoch":"919172013","root":"0x6d088d6dbc38b991ac998c29f349634b36506597498d332decf1f0cf2db16a23"}},"inclusion_delay":"7885712563866284763","proposer_index":"7884060080649600635"},{"aggregation_bits":"0x8cf72b0c79a81bd5c8029496de2c797abfd5c9626115902e6874e86136786fc760daa0fb9319fab6f89b7f59e609e63298e585aba7388efedd8229df8977c52a2596aed1204dd99273109c22319a3080036a80075d891182795f22fd6eb12a3b63fb962ca6fcb9babde21c525ecef69700799125b9f7e3bc8f5ff0d54a8dadf23d6b1720d2252fd90e30fabfab535dacef80bb45f8d1f3266d38d42d6c5503679ea3fdd9bd8fb18ef27b2c65dad0a5676327f68c104512fc5acf59d518de87c02fdcc0236404689911850d80fb90efa2d4067b6ca8aa6c60ca85d7cb43467eadffa0b8c1bc578ad4dd84a98b4e6a8a9656c32291d5915103bbfed4cfa819148501","data":{"slot":"7887365047082968891","index":"8249259030450582884","beacon_block_root":"0x75627572040110ffaca03ae10ae938dcfdc8388cdcc41b8faaf58267a0ba1f2e","source":{"epoch":"960724894","root":"0x4f208172c4695175c21a6c8a63d70f42f1c23a686f33ca1a4ef3fbd6ebf8b018"},"target":{"epoch":"959570647","root":"0xc2e65d72842f8d1281acd78e590c8b1016d534d4b5e7be7761fa90880a3efd58"}},"inclusion_delay":"8245954068312181924","proposer_index":"8244301580800530500"},{"aggregation_bits":"0xf2a79beabfaaed6f7cf54c5e52e19dc27c4fcaf66e4bdf2e601aaddbf1889520b59f51c3e2ff47d841dceb15a521047723b2bef06fe47f4170628c920dff5c506e4253a7f968df0f202d3632ed1fba0024541b2742e0877fb27f4d3e6457d201fa571379b662becd51a44e379b2e5817fe4653bc950ad3d4ed4fb23df7cccbcfd82877856b16e4ca5ad76b29f59a8ca58dc13e075e3a1d413157760c4ea3f29ebef8caa31f55074cc8c0db26127f76f9ef03aec66e4457b2f34f84818c6852bffd6b084b1648b06a1528100b3288a89034f6800c5c04c1e891d9d57eb2b3e6796bf03461bf0b08dcb95d6e058458f582f743f03236cd74958f2fa309197ce7db01","data":{"slot":"8234386677205458436","index":"8239344131150478116","beacon_block_root":"0xe8285272c4c64b9c6c32a6e5001eb4aa23db32f8227910ecbcfc1719beff6b6e","source":{"epoch":"958031652","root":"0x5bef2e72848c87392bc411eaf6522f7948ed2c64682d0549cf03adcadd44b8ae"},"target":{"epoch":"958416400","root":"0x34ad3a7244f5c8af413e43934e4106df3ce72e40fb9bb3d47301263a28834999"}},"inclusion_delay":"8275698779097398117","proposer_index":"8274046291585746693"},{"aggregation_bits":"0xfeea61544ce035fe096a42d7e3aba160106a074e0bcd6f282ef085f249e4b639245152dba5dbbe55e102f8fccb74bd6b9c817de3a84b9ece67edcb3cf852f6e89ceae2acafec9f6338792afd73a88a679c1d22c819892334a504c55efb838d3648bce8cdddc55ef2e47ae7c52f2e751f405c8f8b65fbefcbb36b503e9cccb9d2d4f8c1dfd3ba16681483fd15846f3af4a76ec30ce2583971ae1f62486b36600a4c0df8360ce898e1bf61b856ea7bb0a3cfe06b56d681f3050aae84c40eb35352e57c0b29c57fd8cc8456d2f4f23ac7e616aba1f2465758221986d8645217c4d71e49aaf16fea58d02e71118b078cf76d95d7dcc8de225674cb44786ec13fd46501","data":{"slot":"8277351262314082245","index":"8269088841935694309","beacon_block_root":"0x90d5bb72857598c42e7d63d81e7f423fb2a444b44f5c32d584e75804643087ad","source":{"epoch":"963033387","root":"0x6a93c77245ded93a43f79481776d19a5a69e4690e3cae06029e5d173af6e1898"},"target":{"epoch":"961879141","root":"0xdd59a47205a415d8038900866da29473cbb040fc297fd5bd3bec6625cdb364d8"}},"inclusion_delay":"8265783871207358757","proposer_index":"8264131387990674629"},{"aggregation_bits":"0x3ac64b92f047175ac3f5d307533866f3a20d809c9bef68a301c3daa46ea439d4ca4be82faa5ed5701a70f913bc8c48b73dee2525a6393852bdbb8f50a96d7e49c026b9d8ed2accb1ca05fb7e846cfc60de51824099edfce617b55378063652c30d8c1ed61bc0da1d189ffab45c6affb9b9a92364a68219a16b97b5cb481b8a9171a67ef124ba438f546eb8e34be7d2e1700fda60f1925b87250e2793963ada174a97b30c2a307c2e47b3dc5eb55db6cc1d600f5b0ba3c63134e72dfe25e0a6d036368c962968e79e43b84eeee48e68818a35293209b64c35d0fe8c4d472438b839e0836f6688c5b83b1de8ae43b4ea7e83218f09da42211d58a507321daab25d01","data":{"slot":"8254216484395602564","index":"8259173938340622245","beacon_block_root":"0x039c9872453bd461ed0ecfdc14b4bd0dd8b63e209510273297eeedb58275d3ed","source":{"epoch":"954184163","root":"0xd984b9710375f99a54ff224e7e03ca7ec52919cca7db34d4621bf36fecd50b85"},"target":{"epoch":"954568911","root":"0xb242c571c3dd3a11697954f7d7f1a0e4b9231ba83a4ae35f07196cdf38149d6f"}},"inclusion_delay":"8189769613175117795","proposer_index":"8188117125663466371"},{"aggregation_bits":"0x22aa3e6e7057e8e051961a5894c7754d9828de78a0ad4321342eb23bfd4d6331d8e16c7926c5fe38d7933fe2657afeb98ab21753f7303c26f2abf0204a241e048f3c4164bdf7383083508d6832aafcfa710472ce8c819883f59dceefb563262a7feb954b4b4ca67a635df5aa3911b5577bb097b4cd7782d8513e53a1c31d97adad62b50d134e20c17d5d899622b02c9143180c234c5f3b216a68e6acd9ef645e9da1cf419073cff099dcf3ffc1f6efccb1741ab27d26f2c360ca7013212d6d242146ceadebc9eadc4426516aea6f7f1ec1e3457d79e85999b4a4241ff99798a358a51c8329db15929f66fb1564ed4084d25d8314fa41c3884b9b9d94aa4ddad301","data":{"slot":"8191422096391801923","index":"8183159676013413987","beacon_block_root":"0x718d8a7103d2f3c1fe165da91b4a6ee7f741115c59217ba5d0240fb2bfdcc6da","source":{"epoch":"953029916","root":"0x4b4b9671c33a353813918e527438454deb3b1338ed8f2931752288210b1b58c5"},"target":{"epoch":"951875669","root":"0xbe117371820071d5d322fa566a6dc01b104e0da433441e8e87291dd32960a405"}},"inclusion_delay":"8179854709580045731","proposer_index":"8178202226363361603"},{"aggregation_bits":"0x08111202ae6d823e9d77de3e388dfab08210e1d1fbab2a54bae13a450bc724a007c9ecd21ea6a33db7a3b9cc59aa206d63e57da3fc9ff8cc6626d5fdbbeffd9a7d2d04b9e050ae0e853fb3b8db92ca097f0815309ce71a99cf47c816b47f4350c11f1e7ca922cbefb2a910d337240f87a8777f842382ddd62547453b59a3b8a0bb074d2fe5a2f17a9f0998d775e6e637ca6b7385cdc3d4b5c0dae1c3b72587b961c169cb96b581aeb4cf7d615010313b931914680489f9a583f30c11d5e12352483731acc8a54f35442b2ed4fff09a8c9ea12651b2d02dec34ef75f7ba19bad968bbc9fc89c15f57084c9e1e06ec5d488193894da2a353289c8e47b45c5acdf601","data":{"slot":"8221166807177018116","index":"8226124261122037796","beacon_block_root":"0x81312372c42346c3164ae0409d64581355f32a88d4be56bd2a06345b920627c4","source":{"epoch":"956492656","root":"0xf3f7ff7183e98160d5db4b459399d3e17a0525f41a734b1a3d0dc90cb04b7304"},"target":{"epoch":"956877405","root":"0xcdb50b724452c3d6eb557deeeb87aa476eff26d0aee1f9a5e10a427cfb8904ef"}},"inclusion_delay":"8209599420365261923","proposer_index":"8207946937148577795"},{"aggregation_bits":"0xfacbea0e0f3e7f25bc4a8d4d9076c4f5ce0a5f15dd8bf8af4f73628502208bc983cff70568e2acb1b8f7ebf25e5c9139944ce2a257c469f11e0ebcf05cdcb41d07682973eaa7060fea5d24211ac8dcd20310fba343a6781910ffd9beff222cf4bf26dd6232c7b2aaaf434252a85c96f92c33ee37526560fddf12edcb795ad8b1aca2f8011d1e83adf3be0a5c3ce864bc32d6226fe3fb7de7f6172f13313fc0873248a128b1d49694124638074fff5c059d2389cf80476601ed0e0dac868b83262a790af0f4e987b091b60d95742c11a32b682e581948dddf51a9c90ca6200866087d8adcb348fcb4b1375736e120ccf0e3bdf2f532de0f6c1cdf98878c38dd4601","data":{"slot":"8211251903581946051","index":"8202989483203558115","beacon_block_root":"0x8c00d17183467c877ff385a030e0774aac1d1d84cdb891ebab16e54e83522e5a","source":{"epoch":"955338409","root":"0x66bedc7143afbdfd946db74988ce4eb0a0171f606027407750145ebece90bf44"},"target":{"epoch":"948028180","root":"0x3ca7fd7002e9e236fb5d0bbbf21d5b218d8af90b72f24d191b41637838f1f7db"}},"inclusion_delay":"8146805032361461282","proposer_index":"8145152544849809858"},{"aggregation_bits":"0x5873573092fb7720941bf52d2e72643a4a16baec9559a2f8667a0cd2b44cf8e0b3ac02709c282a47d59b7cc2fe7bcac33cf73d25b3e97e66f3e1626b38905d965a71a4133a570dbf7f124629d791a8d293032d563f8fe72d9dc30681db95ce5a63f8e2c7960fb271e4c6c7ba4b9d495a93cf639e8d5e80a1e71402a0f6663b0e498bb9df24dec3d6fe87ff14db58d611762c749e6f8ff6b4f68d21f6aaec6bc5e0616d781c76d4ae1616327b121d74446f8cb54ede3ec896a19e7a967fa61f3c8f8cfe44e8877fa76e390d3d8fa5a6d56941f5c79c72037569cd98feb089f69d26545f26eb93d615a67003c44dadb2a0c209d28f3507ecd43b51935d22acb2e101","data":{"slot":"8135237641254737794","index":"8140195095199757474","beacon_block_root":"0x62e9f1704280a1c0e6e3d9119a2f84bb9990f72fde839f8d7643ea08edb266f1","source":{"epoch":"946489185","root":"0xd5afce700146dd5da57545168f64ff89bfa2f19b243894ea894a7fba0bf8b231"},"target":{"epoch":"946873933","root":"0xae6dda70c1ae1ed4bbef76bfe852d6efb29cf377b8a642762d48f8295736441c"}},"inclusion_delay":"8123670254442981601","proposer_index":"8122017771226297473"},{"aggregation_bits":"0xe228752907c9ee3ba5eef742671e50349a0c27eb32bad0d2970970ce318267995b7a21c2ea6ca7aee4c0bca8d9557bc7e945eaa0081baf0acb480f64ffd95c110cb0abb1b0bfa399425380bcf6871ac17e98c6c1fa4e85bdcb7a402d388953ee6d75325d954a8ba48967263923215706905cb2d97ec15df91d59e81cbcce5bcbdd2a0dd0c5feb15392661c5dc226929b8eb529f4f8b9ceecc44cea8f0a6784f9e2e07e3c3f6fc185a243736774aa036ad0b7a8e06ab067654659792d6cdd9dd2ff9a0c71f0c3e5823925861c407969ca1c48bff4a6fafe446cca75137db59c40161b7e3613fbb9ee312b2adeebe52b95ac66333dfd38dc1297166d5fff62e2b201","data":{"slot":"8125322737659665729","index":"8169939801690006370","beacon_block_root":"0x0a965b71022feee8a72e9704b8901250295a09ec0c67c1763f2e2bf492e38130","source":{"epoch":"951490920","root":"0xe4536771c2972f5fbda8c8ad117fe9b51c540bc89fd56f02e32ba463de21131b"},"target":{"epoch":"950336674","root":"0x571a4471825d6bfc7c3a34b207b4648442660534e589645ff6323915fc665f5b"}},"inclusion_delay":"8166634835256638114","proposer_index":"8164982352039953986"},{"aggregation_bits":"0xba05d5d84916ca45680f30680f58de090cb8388679fd08f625463c7c637250198041890f541bbadbe7563ec3e3d48336420086d022b42be51dc5eb996cc0fe8f7e6d4d612d3b7f23140a2b459fb2e5b9a027b429a48b04a76021f8c6b9d5ce94f125afea67ac97958cb495a88949afe4c4785aa1161c4ae4683de4c68c197cf2c94d78e3097660ba6036ed9f452598af87da54d18920b065e27a6de864a463c8960a38d73d03abbfd9e33df3d198b0059bcb36b23a5f4f316443c53bd018ea0442bbe233d7e73ade39a9f1965406ae55c68c08baecd40a11e8f244ff363e35795604e901144a9d312639cb6fdad2be85f569e370ceca1a306c117755155efdd701","data":{"slot":"8155067448444881922","index":"8160024902389901602","beacon_block_root":"0x7d5c3871c2f4298667c00209aec58d1e4e6c0358521bb6d35135c0a5b128ce70","source":{"epoch":"948797678","root":"0xef22157182ba652326526e0da4fa08ed747efdc398cfaa30643c5557cf6d1ab1"},"target":{"epoch":"949182427","root":"0xc9e020714223a7993ccc9fb6fce8df526778ff9f2b3e59bc083acec61aacab9b"}},"inclusion_delay":"8090620572929429856","proposer_index":"8088968089712745728"},{"aggregation_bits":"0x94ef868f59af3fb38b4ceb239d30acb5b6316264d29e369e32ca2078dce54ffbd6683e627e80f3af41c6e9363a033b9d95c7b6266f2d0511683e17c9cf1f9f2aa81d34d06cc3ebc25f4dde6e6965bc351ac254b2642640c78a3aa5f16ac01b7d85121673adac82cc573a4c16ee8bfd9a35f6ac7079afdcac7111c26d8d7669525ca92b988c420fa64b054d226431e56594d70112d8ee41ec6d8434962ef1fc71a17ce4cb67e2c61245ba124ae055a8973d5f39d32dbb69e1b45fba82f475017173d39c22010453993e33cf465b6799930c585430ce8498bdccd8ffed88ad9453576171e6fffa8d13915f5c568b39352fa0949f29d529dea577aead58b39d9b7d01","data":{"slot":"8092273060441081280","index":"8084010635767726048","beacon_block_root":"0xeb4d2a70808b49e678c890d5b55b3ef86ef7d593162c0a478b6be1a1ee8fc15d","source":{"epoch":"941487449","root":"0xc50b367040f48a5c8d42c27e0e4a155e61f1d76fa99ab8d22f695a1139ce5248"},"target":{"epoch":"940333202","root":"0x38d2127000bac6f94cd42d83037f902c8703d2dbef4ead2f4270efc258139f88"}},"inclusion_delay":"8080705673629325088","proposer_index":"8079053190412640960"},{"aggregation_bits":"0x1ac71ced66313f7849616af57da366e42cfed577434e248f1d110f276e15b11330720ca9d2d91ac1b768f989c95deaca1730ee506dc5c149ca0215c7cf7d3e434bf58b117f39ded6ae350dfd96b91affdcafb8382461bd33a2b831615765a18ed062d0f949098aab895c40d359f773587a3346fbba88ef06cb34fd1951895a2d38f18c00d34a4a40a8a8cb96bbd50cc96bb8195e7728090cb00d4dd5f16d87280784adc8e168debf6ae8f4e2f7d59aea4e5f17cec0b84c91ce06b1bcbfded6a634011cacf95960ff71da725d0c43908891c4fa16432cb89835b1f39298ba736f11e83d5bf7f9486b1b37e761ca8309e1bc2266f9817b814ee4cc9b9c6f11b78001","data":{"slot":"8069138282522601600","index":"8074095736467621280","beacon_block_root":"0x5e14077040518583375afcd9ab90b9c69309d0ff5ce0fea39d7276530cd50d9e","source":{"epoch":"944950189","root":"0x6db89f7001a3d7844f8d7f712caba3f2f1bae92bd77ddabbf7539bfcdefe6d87"},"target":{"epoch":"945334938","root":"0x4776ab70c10b19fb6407b11a85997a58e4b4eb076aec88479c51146c2a3dff71"}},"inclusion_delay":"8110450384414541281","proposer_index":"8108797896902889857"},{"aggregation_bits":"0x5e0a7d56a54ce3e754b0747e9e62be0fc8db0d0f159bb4c869b0138443dee708dd9cb0971627c32027a1ed6429065b5cab1005f3bf7980ea8d8f4673b9fbf473ac19d98279b79c59a556150201047e5969e6c9c67fa0385d67d2b2a3c4a111af46cd165e182ab63c3a407a5f7d4b4e9442219eb1cae5368b57590553329908ccfd050ed8e1ce8cfa47ee5fa01468aa98ad016dd66740974479405d29d66071d864d92a6e628605038f44dd320d1452f29c3c930a89dceb221dc7d1ad1391e7fb480c76c70e6c1279e8a6b1af94a0cbe6f6d13d65db161362a9ad84dad71a01b52719e3b9e339556d911ef8f50846bd4fd4f5424f2d66232fa8f2a841be69cc8901","data":{"slot":"8112102867631225409","index":"8103840447252837473","beacon_block_root":"0x06c170700100d2abf9a4b9ccc9f1475b23d3e1bb8ac3208d655db73eb20529dd","source":{"epoch":"943795942","root":"0xe07e7c70c16813220e1feb7522e01ec116cde3971d32cf180a5b30aefd43bac7"},"target":{"epoch":"942641696","root":"0x53455970812e4fbfceb0567a18159a8f3cdfdd0363e6c3751c62c55f1b890608"}},"inclusion_delay":"8100535476524501921","proposer_index":"8098882993307817793"},{"aggregation_bits":"0x3818662050519158b815bdfe0e21d3393d4918d82b5d53884af5e6e60c0c68ce78e9dffae7d76e66ca10dbf07a06dfb8535790a847a4327920676360ad126cb18cae06d4348d8f0484723f00749ae48947f25ee56ed2ad82ebe3c4d6ce23c295bf61a34d8a48318ef61cac9dea0bf0049f30483826ac600235414ff28fe14eed911352ce73d172ab87194f37dcc5fb111850e0be20bf786541aaf568d537a5b25da8b88c504dfde2b4e6ea4986eaa92443d84f01667d4f7cde5509a7c9ebbae0d901e69f5c2238ea6c0a8e2495191eced2eba20fbc9139c8d3e1e56e85dbd1f431486d4a5647ea776686dd61e2f714cb5437d8a1c1088689a871ff910f697b4701","data":{"slot":"8459124493458747657","index":"8464081943108800042","beacon_block_root":"0xc2967075ca99ab0524a0cad6926dcbb7d13fb96843d865066c5c3bb5bb8b00bd","source":{"epoch":"984194577","root":"0x355d4d75895fe7a2e43136db88a24686f651b3d4898c5a637e63d066d9d04cfd"},"target":{"epoch":"984579326","root":"0x0f1b597549c82819f9ab6784e1901decea4bb5b01cfb08ef236149d6250fdee7"}},"inclusion_delay":"8447557106646991465","proposer_index":"8445904619135340041"},{"aggregation_bits":"0x82a3952033cb003033a02cc9051c6f1fe80aad84c879c963ff5f802e0642cff5ba2ff5ac11929560c7cc09882d1e2e6da46f3cac9cb663139d4e8b6e56630e38eaaf22243eb775145b5279dd55f4363322d237e5a39ba700ac1b937a691a7d32914b3159c40d18e3cf96d5d7f7bb6e74c496c92fe7115738cf30c830e9997d222672eef08e45a4b427d0ecbe919fba9ba34ba512f181d375e7633fa3cd2d4806cf2920f97b7915e18bbcb6874114482a7ce1d0e7f6f1d35af1d0088c4f8a5c0cea7dd7f6ca86b2efbb1a531dd6439510cd22eb42b70bc4733aa3c114acb1248f4186cc402d8e47e0dd7dd06342c38b22da7ee2130b390a2e2816079bd7833f7501","data":{"slot":"8449209589863675593","index":"8440947169485287657","beacon_block_root":"0xce651e7589bce1c98d49703625e9eaee286aab643cd2a034ec6ceca8acd70753","source":{"epoch":"983040330","root":"0xa8232a7549252340a3c3a1df7ed7c1541c64ad40cf404fc0916a6518f815993d"},"target":{"epoch":"988042066","root":"0xb7c7c2750a777541bbf6247700f2ab807915c76c4ade2ad8eb4b8ac1ca3ff926"}},"inclusion_delay":"8490521691755615274","proposer_index":"8488869204243963850"},{"aggregation_bits":"0x8c3194cc67b02fac47446aa3cf2ae382f363da318e3fb1054193991830208073771d7407bfe1faa7a57fcb22718bb6794c8110d8d7d933c80df368f3d9604bae8ca26ef3a1d1b9b86c2bb64e2cdc81ebfcd7c101b574851806a10e8dac32584f21b2aaee069e175e1e8358af7ddfc6a269b171d9dda408a7ba5bc86e75b55bbb129e7fc25ac9f1cec98899fde69ca0bf681cdce784193e2545552ce539afae3b9ac9e26369198eb3121c7958e7e6807167bfdefda312f3c673e53498b86f5cea57ce2be05722dd1e989b72474b9940f60a62ce2eed23ba86badc98edd1754fb56150db3d8b94231165cf9592f190f42fe95ba95e29834804df013ab82805207801","data":{"slot":"8478954300648891786","index":"8483911750298944170","beacon_block_root":"0xdd09b7754a0e34cba57cf3cda703d51a861bc590b76f7c4c464e11527e01683c","source":{"epoch":"986503070","root":"0x50d093750ad46f68650e5fd29d3850e9ab2dbffcfd2371a95955a6039d46b47c"},"target":{"epoch":"986887819","root":"0x2a8e9f75ca3cb1de7a88907bf526274f9f27c1d890921f35fd521f73e8844567"}},"inclusion_delay":"8467386913837135594","proposer_index":"8465734430620451466"},{"aggregation_bits":"0x5ec2a53cc0229657c83bf984869df7bc3642067f8dfd0166bc03d2d2b9efa702d9af4ed9d92161ce98218bd874f94fbd8afb876dfc9ea2e470d300ed4a314121d2cf8b76ab7322a93109e0113fcd3258b1ceba36eabbc78a391bc521077e67b0cfce79559ddb2c1b8b25aa2eb2a7c9da0761f1bf362b957b4ddc26de27482a3e87beeb80a1e9815de93b3b74ada266bad88d810d1e0d95377319663c61b4e38fdc02794a565cf8c200a1b93eaa1dcd0af883d31a023664e514a21f238a11ba8d2dcf99c1c566d10b6b872de70841c5e937e3821fca0941259faf3d13594e8f68118e5b1bf21d0986dfb45c88453d65163f3d1bd301b6fcc23d68c0a2f2c7608801","data":{"slot":"8469039397053819722","index":"8407897492266703208","beacon_block_root":"0x4cfba87408a5532bb684819aae9985f4a5a697cc7b80d0bf8084324ebc685b29","source":{"epoch":"979192841","root":"0x26b9b474c80d95a1ccfeb24306885c5a99a099a80eef7e4b2482abbd07a7ec13"},"target":{"epoch":"978038594","root":"0x987f917488d3d03e8b901e48fcbcd728beb2931454a373a83789406f25ec3854"}},"inclusion_delay":"8404592525833334952","proposer_index":"8402940038321683528"},{"aggregation_bits":"0xfcdab9fe176f9fb04f6c102cbef0f7417b61431aad1b083adb52bfc70c495c6dfb67daa729265b8ad1454cb8540c8ec15be059d99883005398849f657b7e6b228f6e4c93f1c30469950430dc348f56e8c9dde84e34bdfcbcd614da1e03c9b3501f58c6d1101a2d5a18a527c6fc67127974dd691571ba3521593b79b72a761c8163696a319b6de7241006aa7d68421459847ed768ac183de51b02f8090eb64b570a6df118f473dab780d132d1c3e2c50a080bef9959fdfa6a7885c05910996614a3bcc761c328278631ad7146bbcd481b7eca6da242959c3d87ce6c846de55b813ef50f67ebc7664bc9c118be6fd15f46ae48729d26649f725fdcdf5044677e6f01","data":{"slot":"8393025139021578760","index":"8397982584376663848","beacon_block_root":"0xbec18574c86a8fc87616ed9ea3ce00c3cbb89138c134c51c928bc7ffdaada769","source":{"epoch":"976499599","root":"0x318862748830cb6535a858a399037c91f0ca8ba407e9b979a5925cb1f8f2f3a9"},"target":{"epoch":"976884348","root":"0x0b466e7448990cdc4a228a4cf2f152f7e4c48d809a5768054990d52044318594"}},"inclusion_delay":"8434337232323583849","proposer_index":"8432684749106899721"},{"aggregation_bits":"0xb8557c42bc14173372bb2ca77c320b28974616b1e9d9040905a2b1383c8dfb6016f3453de9d9034735b2df4f95dd0feff4b0d3fb0f0462f50b0bf2452cf381526e467c10b74fd2963f52ac03b26b830f119cb9e76fd450f6c16310fc77be2e62ba105d536f3d3de9a87b9079d9517baac6e7ad1721515528863e382747f649af465dedc822f1272cf65c094313b1b28cc2e7e8e83e791a85ce5bb8250caafd8ff910f39d76d5140fd7b918011d6a0b7332586a0958765ed5a00424ccb2d063271f836902b4b14fb0a8d7313d0b3f37b94f7f6859fa7101fc3b81e98da4412d4b586441df1f043f4f7fec2704b1456ba089d79b61c36afd711bb3c0a59b34056201","data":{"slot":"8435989719835235273","index":"8427727299456847337","beacon_block_root":"0x676eef748919dcf03761aa91c22f8f575a82a3f4ee17e7055a7608eb7fdec2a8","source":{"epoch":"981501334","root":"0x402cfb7449821d674ddbdb3a1b1e66bd4e7ca5d082869591ff73815acb1c5493"},"target":{"epoch":"980347088","root":"0xb3f2d774084859040c6d473f1153e18b738e9f3cc83a8aee127b160ce961a0d3"}},"inclusion_delay":"8424422333023479081","proposer_index":"8422769849806794953"},{"aggregation_bits":"0x1e354ee209aa27d5b40e87719ca3c27ac47aa3e2780922befa302f2fda7df4d1f0a363da6184ed23c7884e684fb0da0065beab3f8166c061771092876f850a33072a6fe1e0fb539efdceed92caf4316473f975af0f91bba653d5845c698a91d2d7cd8b70e9b82fa26c9e9cd8eba7b5c58f9e10bce61aff04d2f337d1920b535d62c46248947960481ab5ecb7dc1a1af5fd88fba411965aa70d5fe8feb226cedef9069af7d001a1ac2b0b7d09786a0d9f64687cc4bd1663c1d4f5e5e25d1a90bc80c5eb1ccc78e667e3398da3652b5c2ad64185bd37579debf6f0b5b1f142e1674effbc561a06fc27cba0d03d7c2d56a20f290b16ee6ba38e0992fa6907a0291b01","data":{"slot":"8412854941916755592","index":"8417812395861775272","beacon_block_root":"0xd934cc7448df178ef7f21596b8640a2680949d6034ccdb626d7d9d9c9e230fe9","source":{"epoch":"972652110","root":"0xaf1ded7307193dc75ee3690722b416976d07780c4697e90438aaa25608844780"},"target":{"epoch":"973036859","root":"0x89dbf873c7817e3d735d9bb07ba2edfc61017ae8d9059890dda71bc653c2d86a"}},"inclusion_delay":"8348408066401303527","proposer_index":"8346755583184619399"},{"aggregation_bits":"0x30f709b1d9a2d22b3b5fdeae0ffbd6e7bf51ed86526e9834afbc832744c2ea74b6bde7bfef16a279511aee511656720993c29a38507fe1141fc9edc38f5cef1e6d9a96d0b546e666845d0a9fac3874da5c948181de7cef4293feda4792dd417d29e3206521201c762751cc16006cbf3de906b42dcfc7086e755f99bcb972cef1b7b1b829b7ac038213803c4afd4fe20d7e91ab61847823adc03869db3972d1c759b0a7abab6ac90b556d531903e704dd5aece305e3195a5b9140d84b98565fc9b9318341348a4d22e08ab2b56b4b4bd5189588fe510f174702fa05a2ecc9291d4f82a7a5fdb76345237967aaee05dcc8ce94762b0ed92e0b103c2cddfd52603f01","data":{"slot":"8350060553912954951","index":"8341798133534567015","beacon_block_root":"0x4826be73077637ee07fba362bffabaff9f1f709cf8dc2fd6a7b3be98db8a02d6","source":{"epoch":"971497863","root":"0x22e4c973c7de78641d75d50b18e99165931972788c4bde614bb1370826c993c0"},"target":{"epoch":"970343616","root":"0x94aaa67386a4b401dc0641100d1e0d34b82b6ce4d2ffd2be5eb8ccb9450ee000"}},"inclusion_delay":"8338493167101198759","proposer_index":"8336840683884514630"},{"aggregation_bits":"0x28a0114c04eaac73fabe918ac79d1a7a21beea2f1c2bac5005730659779aecb03d3f6b769964bf2c333a0cff2ed6aad9bbb5b7896bd027b70c448c2f4c4fcac4bba3da02f8cb2a40b396ad441f14a321d289f77d88f96dde29ac65d21169f480b603abd20b5a32c2abc071a7884c25f726b86d3de56a767390139920a6a571cde337691b15515639d5c8cd89ea1c650be7ca8a4635e0d915f29f6faedfb5197485504100f19a5f308c1c8ca38f1d86f880b0c577a2fa7e652153e4597dd1103e342859d7bdab519ee08acf39ee91a833e6d5e7b23a2760b708e8544fa44fc3640fa4bafad92d4a9868b3e8119c55d184dfb78be62e2fe8295a7d1a6f034575d001","data":{"slot":"8379805264698171144","index":"8384762714348223528","beacon_block_root":"0x57ca5674c8c789ef1f2e27fa4015a52bfdd089c8737a0bee0095e341adb462bf","source":{"epoch":"974960603","root":"0xca903374878dc58cdfbf92fe364a20fa22e38334b92e004b139c78f3cbf9aeff"},"target":{"epoch":"975345352","root":"0xa44e3f7447f60603f439c4a78f38f75f16dd85104d9daed6b899f162173840ea"}},"inclusion_delay":"8368237877886414951","proposer_index":"8366585390374763527"},{"aggregation_bits":"0xdab2d35ceedb0f5c82d151ffcfe92e54b83b7e0c3fcf3cbbb4813199f879c2c8957d7846a7b0347867475c0723e33b989d9d209cd0abb0cff2f8ec21bb1cc047ed867fc2e63695776eb4b357744331928fb10c4e54b807d85eb4043ed8fc4be75a2170c8b53b2db7de423724c7b099936fa9c4ba26e7c20aec8756c2620b09cf3735dd15ec25a2ca5d6b6e88b333aca40757cf242afe77c7d44fe446c72a594a82dbfa82daaf3b10feb758d988e2e7d57a89d8c826f3c3d146d4e1667f8bb3537d2e4ffe3beb08c2b316e458a1c9032ce25ce3d60d3d161b67aff8a1387297f93f6a20feae66a9239189e389bfe9402964fd21c80656c0eb8d7ce04cd8bb201301","data":{"slot":"8369890361103099079","index":"8361627945019678439","beacon_block_root":"0x6399047487eabfb389d7cc59d390c46254fb7bc46c74461c81a594359e006a55","source":{"epoch":"973806356","root":"0x3c5710744753012a9e51fe022c7f9bc848f57da0ffe2f4a726a30da5ea3efb3f"},"target":{"epoch":"966496127","root":"0x12403173068d26630542527496cea7393568584c11ae024af1cf125f549f33d7"}},"inclusion_delay":"8305443485587647014","proposer_index":"8303791002370962886"},{"aggregation_bits":"0x4c486277395f456fc592835fb1e1eebb7db89b1b3788a8695db034da01b13924b125dd841feb37150f62eb6980576047e487fa78148689543a0afb25ee51a828e87f78222bd68757489b09de34035522b603fe7b0943966eb934ff63fc09af8fb5d457c974f70de9a4e23adc08726a2119596012c9fe7b404a7088bb2c35d273d2ca1ca981246091b456eb8904a255675badcbf9a8abca2db4d4cab1ece8f414d6fc76d72f6548203ec5c16a8500cf55c404fe7b5809794c081512ded7c72ec8d17bb95eb921db1f48b4ccf8a2c116deb3552e4ce4914aad2783a9120c7f472251506c089bb82ec295ada57ef72526adde246626228e735773aae7977937eb8401","data":{"slot":"8293876103070858117","index":"8298833548425943206","beacon_block_root":"0x388225734524e5ecefc720cb3de0d0d3426e56707d3f54be4dd299ef0961a2ec","source":{"epoch":"964957132","root":"0xab48027305ea208aaf598ccf33154ca2678050dcc3f3481b5fd92ea127a6ee2c"},"target":{"epoch":"965341881","root":"0x85060e73c5526200c4d3bd788c0323085b7a52b85762f7a604d7a71072e47f17"}},"inclusion_delay":"8282308711964134629","proposer_index":"8280656224452483205"},{"aggregation_bits":"0xa6d3526fbe4cde4042351564b856f23c30b9a735d02810d6a95d06528c56bec431e3e8e6212eba35317b3b318028d96291254c18af545839273e92ab193028bbbe1efd88342c36ded53816833d54c3d9d339342acf02fe7c2d2cec8d973690f9997885f36b3254a8d96e495d940a557b44eb994088794e7c3eed231544ccac88c56b8de7751c923694bc49025cd818c5fb34aa17801fe73d863820f27af339201777f5970454ee10289a1380a8afa86b2b1d418ddc04eeedd6f01169d0ade2a73b054a90244c727a91a87155e19d8d735434665f028bb3c25ac55dac04e2c3ff710694086a31cd712c962957d1edb741106ef414eab0771587a19c14a27ded5601","data":{"slot":"8283961195180818757","index":"8328578263506126694","beacon_block_root":"0xe12e8f7306d33115b112debd5c415f68d137682cab2276a715bddadaae91bd2b","source":{"epoch":"969958867","root":"0xbaec9a73c63b738bc78c0f67b52f36cec5316a083e912433b9ba534af9cf4e16"},"target":{"epoch":"968804621","root":"0x2db377738601af28861e7b6baa64b19cea43647484451990ccc1e8fb18159b56"}},"inclusion_delay":"8325273297072758438","proposer_index":"8323620809561107014"},{"aggregation_bits":"0xa670da8262b1f08a1ed46c2ab0443c802a9211b09a3d2ae73e940e649edf9150fef1446d9d4de69271cfb9bf99f80186da5068e895bbd48ff593f0e790a0a335a86b8e503180b06822e3b4b0dc3879210d3e6286b3c637e0247af9329709a5050730526cc1542b19497984459f36c78c47d6709856dca177caa8276dd3e094ad934f4455c996c3dd2ae5b953c2da1ad26263ffbe0527bc2102af838d043dffd96797133c0e82750eb41a9c181a894b56e4636775bdeeeae30e8929ebac41d86392e0370b32210dca9929104b6d011eee0bd8c431f02343d2ccd47401916ced871118db534827e2a797e43df4b8fb2a4d38c135cdfac3b7b7ece6c08e1c40f02101","data":{"slot":"8313705905966034950","index":"8318663359911054630","beacon_block_root":"0x53f56b73c6986db271a449c25276da36f7496298f1d66a0427c46f8cccd6096c","source":{"epoch":"967265625","root":"0xc6bb4873865ea94f3036b5c647ab55051c5c5c04378b5f613acb043eeb1b56ac"},"target":{"epoch":"967650374","root":"0xa079547346c7eac546b0e66fa0992c6b10565ee0caf90deddec87dad365ae796"}},"inclusion_delay":"13748725597936915948","proposer_index":"13747073110425264524"},{"aggregation_bits":"0x53c052ab2b0d3708b881faa64cad1ebd457dbdfc23d3ab6050fde450072635ee978f12f9677c93de5e6b510380931cd03a1e882213cf8d2f8a8af61d5dd94e20f503540211e9a51d1bd86e3c8c3f492e0f44a3c38172a67f7a7f75fe48c64862d0365d9b2df43806efb57f9a8b8b4a42e3a105def1641d1e8e5d3b3df133f2becffcfc97e73a5b0c87ae587eead70ac523be0264dee6fbb4032ececdfc3d20c31f58cd78080bccd1f3f7fde79c85509623c1f4a5405ad3ee7a994f3c7ad927517903bc795684d6cb65bb3ae3aa3a3ee6c004242e1e4216073286157c704eafa96cb17d38ddff9cd329df1668c6ac163fd72df9ffdc52a201b9a1ffd56527113d01","data":{"slot":"13750378081153600076","index":"13742115660775212139","beacon_block_root":"0x75eeafbe0b10b6bb7e3871502c4d9805d9830de13da58d6560a7011b1e271209","source":{"epoch":"600177566","root":"0x4facbbbecc78f73194b2a2f9853b6f6bcd7d0fbdd0133cf104a57a8a6a65a3f3"},"target":{"epoch":"599023319","root":"0xc27298be8b3e33cf53440efe7b70ea39f28f092916c8304e17ac0f3c88aaef33"}},"inclusion_delay":"13738810690046876587","proposer_index":"13737158211125159755"},{"aggregation_bits":"0xdfcc446c97d939c7732a61f3a4beddce36c2ea17a1458fe31fcfaa0e6b46aa0e79df381aedf1fab8ace5d0e6f2998d2db9e372e0196f8f8ab4def6bb183aefcb1fdf26fb073df679f8e07daffc8f2e2cdf006b43c37559add5cce0fa5370b2869767ca80a05134c1390041fff959c9e4224dbc70b42b0f30f69236cafaede5fccb6e5bb79d220c216a4e8c6a353ff0947d011420d2203b54ca3e9e1c24b939f6f9efa4233ecf35b908e4ccaed195eec3d541d2b9be194a5b06fc6e16418ade8c26973fc63f4fe515a1458778f41ec7d53f92eabc9388aa2113b689507955715a692cd2a89ebc89fb3191ec4d39587f6971d159bb9c12dbf323e1c6c9f9212d8901","data":{"slot":"13727243303235120395","index":"13732200757180140075","beacon_block_root":"0xe8b48cbecbd5f1583ecadc54228213d4ff95074d835982c273ae96cc3d6c5e49","source":{"epoch":"603640306","root":"0xf75825bf8c27445a56fd5feca49cfdff5c472179fef65ddacd8fbb750f96be32"},"target":{"epoch":"604025055","root":"0xd11631bf4c9085d06b779195fd8ad4655041235591650c66718d34e55ad44f1d"}},"inclusion_delay":"13768555405127060076","proposer_index":"13766902921910375948"},{"aggregation_bits":"0xab23a1d274e0814c47752dfb63e9e5059ae73695ca131bc413b1966f2a8e9d179ca724163bcb09517c6c41119992565145e0b0c3c85fccfc2516ed9dcf89053afd3fb4b801b11206d3b9c770662c004c1dc03a9c991e8ce5f97762ab2286e0f112a8193488537df68bfac4184c4fedbcb4167c5806ce77690ab7764b6b2cb5f68e18d9f7adb8f8a1cd0d18d40406c6e013df2f2b21420c7c07770e7000fc2b4e8a32b6930d6abdd55d69e0570344428787225628a5bfee48ef3d5e01e045d1d33a587124c8eca73bb02f440224bdd8977a8d4d5212e0175397ebd863a0d143c41c99482a0a2cd4978bbedbd3d0d839cb134d681534bb2e8667c698cc2052168101","data":{"slot":"13770207888343744204","index":"13761945467965356268","beacon_block_root":"0x9061f6be8c843e8100159a4741e3a1688e5f1909b03ca4ab3b99d7b7e29c7988","source":{"epoch":"602486059","root":"0x6a1f02bf4ced7ff7158fcbf09ad178ce82591be544ab5237df9650272ddb0a73"},"target":{"epoch":"601331812","root":"0xdde5debe0cb3bb94d52037f58f06f49ca76b15518a5f4794f29de5d84b2057b3"}},"inclusion_delay":"13758640497237020716","proposer_index":"13756988014020336588"},{"aggregation_bits":"0x8f5b3ffde9ada84b0ca4c7329f8901eed5cfdbc0c325cb1dbce8c2a84e25b6feb4d734b2dda18f351042923139b749bee57bee160e72ec3fcfc16ad66e556c76a2c4b3905e418c66f7ff25bd30452c50e553a42966799edb14f435f02631a208c1312e2248b12d3dab6e29888a9f3a5c83abc1f8f15dafc3b8722a326632870d6a875867d2dbbbd815308d94b33ed5c246e3684ab3f6302527ec08078b2e83dadb1cfcc19ec6c707eb1b7d0006e6c9167bed6b9bfb57f0dff3cc0cab28d90f6892c984bc5f9a50a6a67740a3e7306f472fa6aaccfbf04bf9b7c1e89cb058d1bf30f2bc5573d7bf509eda9e749ebcd15bc379ed7e3073dd5dd92b860eb7de512201","data":{"slot":"13694193626016535946","index":"13699151079961555626","beacon_block_root":"0x664a17be4abe63ba6605eeb8ab32aed97cd2f3b4c207b24d06c6dc714cfdb11f","source":{"epoch":"593636834","root":"0xd910f4bd0a849f57269759bda16729a8a1e4ed2008bca6aa19cd71236b42fe5f"},"target":{"epoch":"594021583","root":"0xb2ceffbdcaece0cd3b118b66f955000e95deeffc9b2a5536bdcaea92b6808f4a"}},"inclusion_delay":"13682626239204779754","proposer_index":"13680973755988095626"},{"aggregation_bits":"0xd7c194e1481735505cbb576417143d6052c567aae5a533ee4b7ea4ac47cb115f14110780ab45a2380e1ac64b36c9b0ab12d3d943e5a26c0133d90009ca342df7fce1365052ab15e448bd63e00b3b7e8b424956ea10b4f553c2ae7d1cc96c0dafad4dfc3e7ff604589ed4fb631567a0048f7f6033e0d252bfc8efc7d484edb6d89f268a0925efce1b2d902f75ea7050cdaf9861a0ea409f35112482dc373586264a9e7404b193eb04df48ad7e293bbd3871b7572d5bdceff89c1b2e82cb23cb25fba37ba5ccde89a3205bcc8324e8a0680cafcfc58d4a31cafa886470f875078a503c1c50cadc94ed27a013fdbb8ccca60d1715c7713ff1ba4d1e7d7d2e001cd401","data":{"slot":"13684278722421463882","index":"13676016302043075946","beacon_block_root":"0x7119c5bd0ae1997ed0ae93183eaecd10d3fce5b0ba01ed7b87d68d653e49b9b5","source":{"epoch":"592482588","root":"0x4bd7d0bdca49dbf4e528c5c1969ca476c7f6e78c4e709b072bd406d589874aa0"},"target":{"epoch":"597484323","root":"0x5b7b69be8b9b2df6fd5b485918b78ea224a801b9c90d771f85b52b7e5bb1aa89"}},"inclusion_delay":"13725590820018436267","proposer_index":"13723938336801752139"},{"aggregation_bits":"0x47d2cd1c965c122cf379106fdc12b1dd48854102aee16a99c3a0699651191ecbff2b094f05365fbd6e8700210a18287fbbacbcbb8c0fadee2154777472294b299854508c4e25ca521feec8737a964072de6f24c4287cf4cdd9b863b7445428173abc6f839f1048ed4a55169b1dd1bae3746dfa5bc2a355a2bc9eca4c9ef798f0eb62513f99111ab0bbc35f16fd7b9acb36bb5da71f59e7a8b3922d9a51fd0e573efe266f9367301e10c872e09dab8f0319caf9d71e37e61c6660d6943f4ae9e3d292012389b8134378eafc51295167fdd50f40e9ef76479ff6903599a3ff29fa626a0307ec663534908a1e17d9dad3bb2519389a507d33da16482717b013071601","data":{"slot":"13714023433206680075","index":"13718980887151699755","beacon_block_root":"0x81bd5dbecb32ec7fe8e116b0bfc8b73c31aeffdc359fc893e1b7b20e1073199f","source":{"epoch":"595945328","root":"0xf3833abe8bf8271da77382b4b5fd320b56c0f9487b53bdf0f3be47c02eb865df"},"target":{"epoch":"596330077","root":"0xcd4146be4b616993bdedb35d0eec09714abafb240fc26b7c98bcc02f79f6f6c9"}},"inclusion_delay":"13702456046394923882","proposer_index":"13700803563178239754"},{"aggregation_bits":"0x7da06e4c26fe8925b717c009942585db848e5f062805d9f631123c50c8e6b9871eed2ae463e6549d1d9fc0592d64f97b2c457bba37593d52d4f502da996846afeeb51e2e44df237b02dcfe2c3302b2c39167cd37eb3194dd4748765bcf689d34f69abcba425430e857e64109c62f072a393851ff32dabada4207c19a3e9ae4067ce2e4396b6969471103ad9fbc041968d66e1d4c05ef59fb8553e3439bb5cfea7d75afabb856b63e641622c6c21dea2984d0e670bb1b7d7f0927c50d3eb0ad8ee0d5b75817fcdac7f5ea9370ac69ec58b22ee0f8dce8ba76dbc795e72ce2d56702a42e17821e5ea325e1973e7c7042c2ef734a68b842051cd263f8056d7c13e001","data":{"slot":"13704108529611608011","index":"13642966620529524201","beacon_block_root":"0xefae4fbd89c90be0f8e9a47cc65e68165039d218f9af1c071aeed30a4dda0c8c","source":{"epoch":"588635099","root":"0xc96c5bbd49324d560e64d6251f4d3f7c4433d4f48d1ecb92bfeb4c7a98189e76"},"target":{"epoch":"587480852","root":"0x3c3338bd09f888f3cdf5412a1582ba4a6945ce60d3d2bfefd1f2e12bb75deab6"}},"inclusion_delay":"13639661654096155945","proposer_index":"13638009175174439113"},{"aggregation_bits":"0x4f2af777bae3e290f8d68ae0ac682534f083b6175153c2b6da4b5b4d26f0c74f3b1d3ba993b8ff135ab3175aac9161a9ee9ef515d1562705341214f2c11c6f45b184d2469d2e65cba6e92ee472450ee5a0763182bf94897daa208930ae9da7cd316e19bc83bd11674d77ccf52dcca8196f84e495eceb70e356c9c7d731a6ffaa1acd0fca146f3e0cda1e789f12bdaa888add113ba7915491ede86766c0ae2331a55ea5f97ddce41e96c538bab34ca0387f4ec971e5d0c7d95454a613d42092155460636085021dd8dbd4bad16d5079b2e2278165048c6404ebffc0f0186b6d8c26ccbeecaed1616e619dc9859a9a7ef2359345029ddae4f61cd4a6bfd2f1fc4701","data":{"slot":"13628094267284399753","index":"13633051721229419433","beacon_block_root":"0x62752cbd498f477db87b1081bc93e3e4764bcc843f6411642df568bc6b1f59cc","source":{"epoch":"585941856","root":"0xd53b09bd0955831a770d7c85b2c85eb39b5dc6f0851806c13ffcfd6d8a64a50c"},"target":{"epoch":"586326605","root":"0xaef914bdc9bdc4908d87ad2e0ab735198f57c8cc1987b44ce4f976ddd5a236f7"}},"inclusion_delay":"13669406369176339434","proposer_index":"13667753881664688010"},{"aggregation_bits":"0x0b373d925d100a83cfaf5ce27f1a5dff04a2cc8b5035debc975355f63d54b1d652e70651550e26d6ea6887864e4a997152ac361a5cd2c4cba79f085236a6813d5228c04dd9a38b6c0db7f62fece0428637275869645d44a3ae5281d4bd815c6e8e54fa2ce4ba315aff893d2d99df95dbda562c5b36122dad00fc27c72ba7acd6af11dfe7a8d1fe36fd58c8a048d60cdec824603ab539f2d134997d5af6a2b88545a3b5def8416ea2c36d1b6a45666e7a09a97dc3841163ef9fa5a6821683fcbe4edd470376a17b7ce9babbaabdb71a50a63a641ef616ddef6fe934f1f1cf5f44175f018f7a16683087b66491580ecd7445876cac315186a752bbb8022b822e1b01","data":{"slot":"13671058852393023562","index":"13662796432014635626","beacon_block_root":"0x0a2296bd093e94a57ac6cd73dbf471790515de406d47334df5dfa9a71150740b","source":{"epoch":"590943592","root":"0xe4dfa1bdcaa6d51b8f40ff1c33e348dff90ee01c00b6e1d899dd22175c8e05f6"},"target":{"epoch":"589789345","root":"0x57a67ebd896c11b94fd26a212918c4ad1e21da88466ad635ace4b7c87ad35136"}},"inclusion_delay":"13659491461286300073","proposer_index":"13657838978069615945"},{"aggregation_bits":"0x874b0712e0061ee503137df52f8b948c26a53d1db8f7f82a59022ba999d46f737cb52486db5b4af31c168760b537086d58014bc852203652d1bf1938b5c4205d99d06e0c83ef527ede0fffae9ab8e4ed5362b2ed201aa9f32fc2577680bc61d2eb895817010f31f721ddb1ecae091f359141977471bd9886f5257011eb59b894990874e37fd19a5416f56a54c5ede4a3331b7d760a3f9a79db9063d94a3eb8b94015763e7ef93f093cbfa362d86762ad5a095b4c4833560a41708fac6db04497891fcf8f1a664c092d402735a393712338beee1a313e611a2eba085585fcaa695ec465b26c1c2d8a6ffc4da61d7630a6db531ee91515585280b987d6f71f3af201","data":{"slot":"13647924074474543881","index":"13652881528419563561","beacon_block_root":"0x7de872bdc903d04239583978d029ed472b27d8acb3fb27aa07e73e592f95c04b","source":{"epoch":"582094367","root":"0x53d193bc883df57ba0488de93a79f9b8189ab258c4c6354cd313441399f5f8e2"},"target":{"epoch":"582479116","root":"0x2c8f9fbc48a636f2b5c2be929367d01e0c94b4345835e4d77711bd82e4338acd"}},"inclusion_delay":"13583477203254059112","proposer_index":"13581824715742407688"},{"aggregation_bits":"0x5b0456e9208eea1bc551a4276962c598148433ff379452d14ebf63ad0e3d74574ec240b3f4c0ceba987c44b96dc3f28f6d8e7af601af362232eb6fc8979b6db951e006e583b2a6b4978831b360f7ac51f93f60ceedb79c17fdc10a6172fb33f8d680c70adb1e08c0fb836342c8f2415de1dc31b5188600deee847618502627204ecdac926c77e88c1dc2fe81e53098f920472d311ff078f196f6f3a4cd6b35a9d603eb6e673073a661d85cc369c8baedf41d04e97e2666c20cddd2077cfd87c8a86fa19a729707c65a8b58b18de226acd11aae90016cf73642b089c4d94f0b52ddb9745c9a093c62dba0fe3f56427a5e1e4e27fc7db755d799f64d7a14e0d35f01","data":{"slot":"13585129686470743240","index":"13576867266092355303","beacon_block_root":"0xebd964bc879aefa24a60c744d7bf9d214ab2aae8770c7c1d411d60556cfcb338","source":{"epoch":"580940121","root":"0xc59770bc470331195fdaf8ed30ae74873eacacc40a7b2aa9e51ad9c4b73a4523"},"target":{"epoch":"579785874","root":"0x385e4dbc07c96cb61f6c64f226e3ef5563bea630502f1f06f8216e76d67f9163"}},"inclusion_delay":"13573562295364019751","proposer_index":"13571909816442302919"},{"aggregation_bits":"0xf3dc5e047c3695231d91e804c104682784593d1234d37ee48166629f14f373c3b3682b7866b30a3cb0c0c6975453467b0cc91e4e2072a6c1a2541694270ae22b27cd717f9eb2ea40c171b358417a62a9f4309684957a3c87c61c00b8f0f7940c0a551cbfb8ed2c7dfab29a13c386efc738a9ca79626b0fd09fd5fee0dff499256ae15724b0d9bd250f921f62927ac3cdad7940d4bae8116134d4f8c125a1c714226325f5ed04e1dccfca9a59cf10a5fab707a23f0bb5689e14e22c11c81085bfa1567f9c7fb3ea020ad361afb07d1d3a00a823f54b508183ce80b8239083806b080f6b6398133d35c0eabb9e6d0ea63055e33c217d0d13ff367545d9b2e5c67801","data":{"slot":"13614874397255959432","index":"13619831851200979112","beacon_block_root":"0xfb7dfdbc48ec41a462934adc59da874da863c414f2a957359bfe84fe3e261422","source":{"epoch":"584402861","root":"0x6d44dabc08b27d412125b6e04f0f031ccd75be80385e4c92ad051ab05d6b6062"},"target":{"epoch":"584787610","root":"0x4702e6bcc81abfb7379fe789a7fdd981c16fc05ccbccfa1d5203931fa8a9f14c"}},"inclusion_delay":"13603307010444203240","proposer_index":"13601654527227519112"},{"aggregation_bits":"0x8b67e68d0f6f127c3ec82772c8a1fc230206b11cd213e40735f015139110dc66154e194e1ce71332aa9916ad722cb3fff311c86b9bf477e5d774761ac06bc2a159ecec8794ea30c15c51e4ff080cf01aea2afb02d3b3368d30a11d1431aa39eb347fcfa62eb81140930170101bbe77f3367b493e23c4e88d6b08900eec5968fccc49a06a466d6aaa39f3bc6bdd4056d459a00175b95e3e710289b3393d2a0a2123e8a4cae35424b5fb03cbb3a2cea2d40c7e9ff49bc3f679f8950f28cf7b61ca9370e5efedf766278c1b264e336026857fa1cbd11948786a2387d5544cf890b72cd14960789ad48679d132bcd5a637a9bb0dd617bdb89b3dee34c8e3562c867a01","data":{"slot":"13604959493660887368","index":"13596697073282499432","beacon_block_root":"0x064dabbc080f7868cb3cf03bec55a784ff8db610eba392631c0f36f230721bb8","source":{"epoch":"583248614","root":"0xe00ab7bcc877b9dee0b621e544447eeaf387b8ec7e1241efc00caf617bb0aca2"},"target":{"epoch":"625186244","root":"0x9ce0b6c1911193380cb232ef0dc00147a0f48f9937278668c60b33d884368482"}},"inclusion_delay":"13963548510595133105","proposer_index":"13961896023083481681"}],"justification_bits":"0x05","previous_justified_checkpoint":{"epoch":"223123644","root":"0x8be6c8917c79927f22583b48cdcfa690a5a57e85e2c77c3971ab4fcf5feda0ff"},"current_justified_checkpoint":{"epoch":"228125379","root":"0x9a8a61923dcbe4803a8bbedf4fea90bc025798b15d655851cb8c7478311701e9"},"finalized_checkpoint":{"epoch":"228510128","root":"0x74486d92fd3326f74f05f088a8d86722f6509a8df0d306dd6f8aede77d5592d3"}}} \ No newline at end of file +{ + "data": { + "genesis_time": "87914232", + "genesis_validators_root": "0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef", + "slot": "4669978815449698508", + "fork": { + "previous_version": "0x103ac940", + "current_version": "0x6fdfab40", + "epoch": "4658411424342975020" + }, + "latest_block_header": { + "slot": "4669978815449698508", + "proposer_index": "4663368873993027404", + "parent_root": "0x5cbeb140ec0ad7cb653388caecba483cf66bd817821ed18ca1f3b7f3b9b58a04", + "state_root": "0x0000000000000000000000000000000000000000000000000000000000000000", + "body_root": "0x1f86d83f0bf91cc0d7e07410828140e0dddbb331dc20b6743f9f79e549b50b11" + }, + "block_roots": [ + "0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b", + "0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb", + "0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486", + "0x6b0ac13f8a279ad3abec11bed1a49214f6e7af79b643595df6a38706b338e93b", + "0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6", + "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000" + ], + "state_roots": [ + "0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1", + "0xb88ea93f0a5617e780f8ae6b1fc8e4480ff4abc18f66fc45ada895271cbcc666", + "0xcbafa33faaa1f62b763b1697f350f91515f7aa53462f2500db29d9eff71c7ef1", + "0x924cb53fcabe585d9672e01478b6bbae02eead9d22d5aad151a60e9768fa5751", + "0xa56daf3f6a0a38a28bb547404c3fd07b08f1ac2fd99dd38b7f27525f425b0fdc", + "0x0413923f8a8494fa55044c196eeb367d2800a80969899f2e64ada348863fa491", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000" + ], + "historical_roots": [ + "0x17348c3f2ad0733f4b47b34442744b4a2e03a79b1f52c8e8922ee71060a05b1c", + "0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c", + "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06", + "0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565", + "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0", + "0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650", + "0xda533c406bf3482d8e6e992e756be34172a8c47fc1cc0018350bfe98c946deda", + "0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390", + "0x4d1a19402bb984ca4d0005336ba05e1098babeeb0781f5744712934ae78b2a1b", + "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b", + "0x27d82440eb21c640637a36dcc38e35768bb4c0c79aefa300ec0f0cba32cabb05", + "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb", + "0x999e0140abe701de220ca2e0b9c3b044b1c6ba33e0a3985dfe16a16b510f0846", + "0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5", + "0x735c0d406b5043543786d38912b287aaa4c0bc0f731247e9a3141adb9c4d9930", + "0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6", + "0xe622ea3f2b167ff1f7173f8e08e70279cad2b67bb9c63b46b51baf8cba92e570", + "0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0", + "0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b", + "0x82a81c3f096d065c7e3f5d7df79bd182a53c9471a737cfb9f7c4e9ed95d0f767", + "0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2", + "0x5c66283fc9d547d293b98e264f8aa8e89836964d3ba67d459cc2625de10e8952", + "0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd", + "0xcf2c053f899b836f534bfa2a45bf23b7be4890b9815a72a2aec9f70eff53d592", + "0xe24dff3e29e762b4488e615619483884c44b8f4b37239b5cdc4a3bd7d9b48c1d", + "0xa8ea103f4904c5e568c52bd49eadfa1cb142929514c9202e53c7707e4a92667d", + "0xbb0b0b3fe94fa42a5e0893ff71360feab7459127ca9149e88148b44625f31d08", + "0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd", + "0x2ed2e73ea915e0c71d9afe03676b8ab8dd578b9311463e45934f49f843386a48", + "0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8", + "0x0890f33e697e213e331430adc059611ed0518d6fa4b4ecd0384dc2678e76fb32", + "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8", + "0x7a56d03e29445ddbf2a59bb1b68edcecf66387dbea68e12d4a545719acbb4773", + "0x41f3e13e4961bf0c12dd652f3bf49e85e35a8a25c70e67ffc1d08cc01d9921d3", + "0x5414dc3ee9ac9e510720cd5a0e7db352e95d89b77dd78fb9ef51d088f8f9d85d", + "0x51977a3f0ab3110e2a10e9c6bd0e89b1410ca45142ac42171bb2b169efc281bc", + "0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", + "0x9d1b633f8ae18e21ff1b86740b32dbe55a18a0991bcfe5ffd2b6bf8a59465fe7", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0x77d96e3f4a4ad0971596b71d6420b24b4d12a275af3d948b77b438faa484f0d1", + "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", + "0xe99f4b3f0a100c35d42723225a552d1a73249ce1f5f188e889bbcdabc2c93c12", + "0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c", + "0xc35d573fca784dabeaa154cbb2430480661e9ebd886037742eb9461b0e08cefc", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0x3624343f893e8948a933c0cfa8787f4e8c309829ce142cd140c0dbcc2c4d1a3d", + "0x49452e3f298a688d9e7627fb7c01941b923397bb84dd548b6e411f9506aed1c7", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x23033a3fe9f2a903b4f058a4d4ef6a81852d9997184c0317133f980452ec62b2", + "0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be", + "0xf8eb5a3ea82ccf3c1be1ac153e3f77f273a07343291711b9de6b9dbebc4c9b49", + "0xbf886c3ec849316e3b187793c3a4398b6097768d06bd968a54e8d2652d2a75a9", + "0xd2a9663e689510b3305bdebe972d4e58669a751fbc85bf448269162e078b2c34", + "0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9", + "0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874", + "0x0c0d553e4878ae811024144112c88bbf79a372d5dfdf39730cede08696ad52d4", + "0x1f2e4f3ee8c38dc605677b6ce650a08c7fa6716795a8622d396e244f710e0a5f", + "0x7ed3313e083eea1ecfb57f4508fd068e9fb56c4125942ed01ef47538b5f29e14", + "0x91f42b3ea889c963c4f8e670db851b5ba5b86bd3dc5c578a4c75b9008f53569f", + "0x58913d3ec8a62b95e52fb1ee60ebddf392af6e1db902dd5bc3f1eea7003130ff", + "0x6bb2373e68f20adada72181a3474f2c098b26daf6fcb0516f0723270da91e789", + "0xcb571a3e876c6732a4c11cf3562059c2b8c16889ffb6d1b8d5f883591e767c3f", + "0xde78143e27b846779904841e2aa96d8fbec4671bb57ffa72037ac721f8d633ca", + "0xa415263e48d5a8a8ba3b4e9caf0e3028abbb6a65922580447af6fcc869b40d2a", + "0xb736203ee72088edaf7eb5c7839744f5b1be69f748eea8fea77740914415c5b4", + "0xb4b9be3e0927fba9d26ed13331291a54096d84910dc35b5cd4d721723cde6d13", + "0xc7dab83ea972daeec7b1385f04b22e210f708323c38b84160159653a163f259e", + "0x8e77ca3ec98f3c20e7e802dd8917f1b9fc66866da0310ae878d59ae1871cfffd", + "0xa198c43e69db1b65dc2b6a085da00587026a85ff57fa32a2a656dea9617db688", + "0x003ea73e885578bda77a6ee17f4c6c88227980d9e6e5fe448bdc2f93a5614b3e", + "0x135fa13e28a157029cbdd50c53d58055287c7f6b9dae27ffb95d735b7fc202c9", + "0xdafbb23e48beb933bcf49f8ad83a43ee157382b57a54add02fdaa802f09fdc28", + "0xed1cad3ee8099978b13707b6acc357bb1b768147301dd68a5d5beccacb0094b3", + "0x4dc28f3e0884f5d07b860b8fce6fbebc3b857c21c008a22d42e13db40fe52869", + "0x60e3893ea8cfd41571c972baa1f8d28941887bb376d1cae77062817ce945e0f3", + "0x26809b3ec8ec364791003d38265e95222e7f7efd537750b9e6deb6235a23ba53", + "0x39a1953e6838168c8643a463fae6a9ef34827d8f094079731460faeb348471de", + "0x9946783e88b272e45092a83c1c9310f154917869992b4516f9e54bd578680694", + "0xac67723e28fe512946d50f68f01b25be5a9477fb4ff46dd027678f9d52c9bd1e", + "0x7304843e481bb45a660cdae57581e756478b7a452c9af3a19de3c444c3a6977e", + "0x86257e3ee866939f5b4f4111490afc234d8e79d7e3621c5ccb64080d9e074f09", + "0x2fda834311b58db49107ebef3efd6ab3f5f751f2e5ae381ba4e248bbcd2c6f5e", + "0x42fb7d43b1006df9874a521b12867f80fbfa50849c7761d5d1638c83a78d26e9", + "0x09988f43d11dcf2aa7811c9997eb4119e8f153ce791de7a648e0c12a186b0049", + "0x1cb989437169ae6f9cc483c46a7456e6eff452602fe60f61766105f3f2cbb7d3", + "0x7b5e6c4391e30ac86613889d8c20bde70e044e3abfd1db035be756dc36b04c89", + "0x8e7f6643312fea0c5c56efc860a9d1b414074dcc759a04be89689aa411110414", + "0x551c7843514c4c3e7c8db946e50e944d01fe4f1652408a8fffe4cf4b82eedd73", + "0x683d7243f1972b8371d02072b997a81a08014fa80809b3492d6613145c4f95fe", + "0xc8e25443111288db3b1f254bdb430f1c27104a8298f47eec12ec64fda0332ab4", + "0xdb034f43b15d672031628c76afcc23e92d1349144fbda7a6406da8c57a94e13e", + "0xa2a06043d17ac951519956f43432e6811a0a4c5e2b632d78b6e9dd6ceb71bb9e", + "0xb5c15a4371c6a89646dcbd1f07bbfa4e210d4bf0e22b5632e46a2135c5d27229", + "0x14673d43914005ef102bc2f829676150401c46ca721722d5c9f0721e09b707df", + "0x27883743308ce433056e2924fdef751d461f455c28e04a8ff771b6e6e417bf69", + "0xee24494351a9466526a5f3a1825538b6331648a60586d0606deeeb8d55f598c9", + "0x01464343f1f425aa1be85acd56de4c833a194738bb4ef91a9b6f2f562f565054", + "0xfdc8e14312fb98663ed87639047022e291c761d28023ac78c7cf1037271ff9b2" + ], + "eth1_data": { + "deposit_root": "0x10eadb43b24678ab331bde64d7f836af97ca606436ecd432f55054ff0180b03d", + "deposit_count": "4894716627408020434", + "block_hash": "0xeaa7e74372afb92149950f0e30e70d158bc46240ca5a83be9a4ecd6e4cbe4128" + }, + "eth1_data_votes": [ + { + "deposit_root": "0x4a4dca439229167a13e413e752937416aad35d1a59464f617ed41e5890a2d6dd", + "deposit_count": "4883149240596264241", + "block_hash": "0x240bd643529257f0285e4590ab814b7c9dcd5ff6edb4fdec23d297c7dce067c8" + }, + { + "deposit_root": "0x372cd043f2dd36351da1acbb7f0a6049a4d05e88a37d26a75153db8fb6411f53", + "deposit_count": "4878191786651244561", + "block_hash": "0xa9f2ac43b1a372d2dd3218c0743fdb17c9e258f4e9311b04635a7041d4866b93" + }, + { + "deposit_root": "0x708fbe43d1c0d403fd69e23dfaa49db0b6d95b3ec6d7a0d5dad6a5e8456445f3", + "deposit_count": "4879844274162895985", + "block_hash": "0xe3559b43918610a1bdfb4d42efd9187fdceb55aa0c8c9532eddd3a9a63a99133" + }, + { + "deposit_root": "0xf676954331d2efe5b23eb56dc3622d4ce2ee543cc254beec1a5f7e623e0a49be", + "deposit_count": "4874886820217876305", + "block_hash": "0xcf34a143f13a315cc7b8e6161c5104b2d6e8561856c36c78bf5cf7d18948daa8" + }, + { + "deposit_root": "0x92fcc742102977503966d35cb217fc55bd583232b0c551605c08b9c319485bb5", + "deposit_count": "4810439944702424240", + "block_hash": "0x6cbad342d091b8c64ee004060b06d3bbb052340e443400ec010632336486ec9f" + }, + { + "deposit_root": "0x7fdbcd4270dd970b44236c31de8ee788b75533a0fafc28a62f8775fb3fe7a32a", + "deposit_count": "4805482499347339152", + "block_hash": "0xf2a1aa4230a3d3a803b5d735d4c36257dc672d0c40b11d03418e0aad5d2cf06a" + }, + { + "deposit_root": "0xb83ebc4250c035da23eca1b3592925f0c95e30561d57a3d4b80a4054ce09caca", + "deposit_count": "4807134978269055984", + "block_hash": "0x2b0599420f867177e37d0db84f5ea0beef702ac2630b9831ca11d505ec4e160b" + }, + { + "deposit_root": "0x3e269342afd150bcd8c074e323e7b48bf57329541ad4c0ebf89218cec6afcd95", + "deposit_count": "4802177528619003599", + "block_hash": "0x18e49e426f3a9232ed3aa68c7bd58bf1e96d2b30ad426f779d90913d12ee5e80" + }, + { + "deposit_root": "0x778981428fb4ee8ab889aa659e81f2f2087d260a3d2e3b1a8216e32655d2f335", + "deposit_count": "4790610137512280111", + "block_hash": "0x51478d424f1d3001cd03dc0ef66fc958fb7628e6d09ce9a526145c96a1108520" + }, + { + "deposit_root": "0x64688742ef680f46c246433acaf8dd25027a27788665126054959f5e7b713cab", + "deposit_count": "4838532176565923600", + "block_hash": "0x740c2043b0ba6147da79c6d14c13c8515f2b41a40103ee77ae76c4074d9b9c94" + }, + { + "deposit_root": "0x3aa93143d0d7c378fbb0904fd1788aea4c2244eedea8734924f3f9aebe7876f4", + "deposit_count": "4840184655487640432", + "block_hash": "0xad6f0e43909dff15ba42fc53c6ad05b972343e5a245d68a637fa8e60dcbdc234" + }, + { + "deposit_root": "0xc090084330e9de5aaf85637f9a361a8678373decdb259160657bd228b71e7abf", + "deposit_count": "4835227205837588048", + "block_hash": "0x9a4e1443f05120d1c5ff9428f324f1eb6c313fc86e943fec09794b98025d0baa" + }, + { + "deposit_root": "0xf9f3f64210cc7c298f4e990115d157ed8b403aa2fe7f0b8feefe9c814641a05f", + "deposit_count": "4823659819025831856", + "block_hash": "0xd3b10243d034be9fa5c8caaa6ebf2e537e3a3c7e91eeb91a93fc15f1917f314a" + }, + { + "deposit_root": "0xe6d2fc4270809de49a0b32d641484320853d3b1047b7e2d4c07d59b96ce0e8d4", + "deposit_count": "4818702369375779472", + "block_hash": "0x5999d9423046d981599d9dda377dbeeeaa4f357c8d6bd731d384ee6a8a253515" + }, + { + "deposit_root": "0x2036eb4250633bb379d46758bce28087974638c66a115d034a012412fb020f75", + "deposit_count": "4820354852592463600", + "block_hash": "0xf51e0c420e9d60ece0c4bbc926328df885b912727bdc6aa5152e29cc6563470c" + }, + { + "deposit_root": "0x08400642aee83f31d60723f5fabaa1c58bbc110432a5935f43af6c943fc4fe96", + "deposit_count": "4762517914238715343", + "block_hash": "0xe2fd11426e5181a7eb81549e52a9782b7fb613e0c51342ebe7ace5038b029081" + }, + { + "deposit_root": "0x42a3f4418ecbddffb5d058777555df2c9ec50eba55ff0d8ecc3237edcfe62437", + "deposit_count": "4750950527426959150", + "block_hash": "0x1c6100424e341f76cb4a8a20cd43b69291bf1096e86dbc197030b05c1a25b621" + }, + { + "deposit_root": "0x2f82fa41ee7ffebac08df14ba1ccca5f98c20f289e36e5d39eb1f324f4856dac", + "deposit_count": "4745993073481939470", + "block_hash": "0xa148d741ae453a587f1f5d509701462ebdd40994e5ead930b1b888d612cbb9ec" + }, + { + "deposit_root": "0x68e5e841ce629c89a05627ce1c6708c7aacb0cdec1905f022835be7d83a8934c", + "deposit_count": "4747645556698623598", + "block_hash": "0xdbabc5418e28d8265fe892d2129c8395d0dd064a0845545f3a3c532fa2eddf8c" + }, + { + "deposit_root": "0xeeccbf412e74b76b542bfafde5249862d6e005dcbe0d7d1968bd96f77c4e9717", + "deposit_count": "4742688102753603918", + "block_hash": "0xc78acb41eedcf8e16aa52ba73e136fc8cada07b8517c2ba50cbb0f67c78c2802" + }, + { + "deposit_root": "0xc40d6a420fe36b9e8d954713eca44427218922521651de02391bf147bf55d160", + "deposit_count": "4784000204645543599", + "block_hash": "0x9ecb7542cf4bad14a20f79bc45931b8d1483242ea9bf8c8edd186ab70a94624b" + }, + { + "deposit_root": "0xb1ec6f426f978c599752e0e7181c305a1b8623c06088b5480b9aad7fe5f419d6", + "deposit_count": "4779042750700523919", + "block_hash": "0x23b34c422f5dc8f657e44bec0e51ab2840981d2ca63caaa51da14231033a6616" + }, + { + "deposit_root": "0xea4f5e424f7a2a28771b166a93b66dc12d8f207683e22f77941d78d874174076", + "deposit_count": "4780695238212175343", + "block_hash": "0x5d163b420f4066c536ad816e89ebe88f53a11ae2c99624d4a7240d8a925c8cb6" + }, + { + "deposit_root": "0x70373542af8b450a2cf0e8995d74fd5c59a419747f5f4d8ed5a550526cbd4341", + "deposit_count": "4775737784267155663", + "block_hash": "0x49f540426ff48680416a1a43b562d4c24d9e1b5012cefb1979a3c9c1b8fbd42b" + }, + { + "deposit_root": "0xa99a23428f6ee3d80bb91e1cd80e3bc46cad162aa2b9c7bc5e291babfcdf69e1", + "deposit_count": "4764170397455399471", + "block_hash": "0x83582f424fd7244f213350c530fd112a5fa71806352876480227941a471efbcb" + }, + { + "deposit_root": "0x96792942ef2204941676b7f0048626f766aa1798ecf09e0230a8d7e2217fb256", + "deposit_count": "4706333459101651213", + "block_hash": "0x6c624a41ad5c29cd7d660b626ed53268531df243fdbbaca4fbd4dc9c8cdfeaed" + }, + { + "deposit_root": "0x32ff5b41cd798bfe9d9dd5dff33af5004014f58dda61327672511244fcbcc44d", + "deposit_count": "4707985942318335341", + "block_hash": "0xa5c538418d3fc79b5d2f41e4e96f70cf6626eff9201627d38558a7f51b02118e" + }, + { + "deposit_root": "0xb8e632412d8ba6e05272a80fbcf8849c6c29ee8bd6de4f8db2d9eabdf562c818", + "deposit_count": "4703028492668282957", + "block_hash": "0x92a43e41edf3e75667ecd9b815e75b026023f067694dfe1857d7632d40a15903" + }, + { + "deposit_root": "0xf14921410d6e44af323bde913793c2037f32eb41f938cabb3c5db5168485eeb8", + "deposit_count": "4691461101561559469", + "block_hash": "0xcb072d41cdd6852547b50f3b90819969722ced1d8ca77847e05a2e86cfc37fa3" + }, + { + "deposit_root": "0xde2827416d22656a3cf87666640aae36792fecaf4370a1010edc714eaa24372e", + "deposit_count": "4686503651911507085", + "block_hash": "0x51ef03412de8a007fc89e26a593f29059e41e61b8924965e21e30600c869836e" + }, + { + "deposit_root": "0x188c15414d0503391cc1ace8dfa4eb9d8b38e96566ca1b30975f3ca739475dce", + "deposit_count": "4688156139423158509", + "block_hash": "0x2730ae410e57553a34f42f8060bfd5c9e9e90292e167f747f14061500b71bdb7" + }, + { + "deposit_root": "0x3a51a841aea2347f293797ab3448ea96efec0124973020021fc2a418e5d17442", + "deposit_count": "4736078169886867406", + "block_hash": "0x140fb4416e0b76f53fb1c8548d36c1fce3e603002b9fce8dc3bf1d883110062d" + } + ], + "eth1_deposit_index": "4726163266291795342", + "validators": [ + { + "pubkey": "0x8238eb67219c0c314c0b387a1300ebe7ee0b3bfde764c14e90d42e82197100fedb6950f6db432cee0e766cfd35ff22c7", + "withdrawal_credentials": "0x4d72a2414eee13c41e7afed607d1fe63f5ef00b64ef948bc4d43e8e0c0322ccd", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xaf72cddf5e9e8f9e3213202be4447e2eb5a5a61632935ce5695105b936cccae9fc9c504f2bcf511d91531a2738e1d71b", + "withdrawal_credentials": "0xc0387f410db44f61de0b6adbfd057a321b02fb2194ad3d195f4a7d92de77780d", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x83feea64397a7a9d3fbac0b9a16ccbfd63c4d4fa5d0fd8bbfa13739148e752ce1e9b1e01654b56cb56a196fd8d64db3f", + "withdrawal_credentials": "0x9af68a41ce1c91d7f3859b8456f450980efcfcfd271ceca40448f60129b609f8", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xaafd198509805b36458bfa1c0202ea15976ab05f75100f8ed811fb700b4d657531e364c12a87d345f4799c43e2bb5ae6", + "withdrawal_credentials": "0x0cbd67418de2cc74b31707894c29cc66340ef7696dd0e001164f8bb348fb5538", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb9f6a699d12e3b22af90798367dbf0631ebaaaf8f61655d320f1459b2ed90c922371211fd49c3b93e3c5a550730cf272", + "withdrawal_credentials": "0xe67a73414d4b0eebc8913832a417a3cc2708f945003f8f8dbb4c04239339e722", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x85808a97e324987cd03bfc33e49aaa6cbc8a5cb66fb44111b0d8bc8c6b7c810638e6a6ac88d640b3492a684c19053f61", + "withdrawal_credentials": "0xa250734616e5e744f48c493c6d932629d574d0f2b953d406c14b88999cbfbe02", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x99b20a6a3e75af8e62e7f3f5143a149ab8e4ff041b0bf44e70174c19184e0ad2d612a3cd648ac30b428469bde0d1cea2", + "withdrawal_credentials": "0x7c0e7f46d64d29bb09077be5c681fd8ec96ed2ce4dc2829266490109e8fd4fed", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x962f9f117cb8bfe6d6bcc374161f8e605cdff99bee8161ed5b527987f0e5116f94821f23f28773da660a420525bd4201", + "withdrawal_credentials": "0xefd45b4696136558c998e6e9bcb6785dee80cc3a937677ef785096ba06439c2d", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8b585aa726039b4472f9552d0c79479cb6adc817b80667143271f83ddea3228455397c6ac7e29e6fa703eb31e8674828", + "withdrawal_credentials": "0xc8926746567ca6cede12189315a54fc3e17ace1626e5257b1d4e0f2a51812d18", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xaec6dab7580191dde7d836f49c0e9639ec9f7306f25cf1c37b212a28244f1b8144c1a05919239caec52ba139fede301b", + "withdrawal_credentials": "0x3b5944461642e26b9ea483970adaca91078dc8826c991ad82f55a4db6fc67958", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xaa7d67cf12895fe67b0023fb9c2fb0b7a60bd3b9c90c01dd758002a19265cc9c2fa5338b6a59a5a0b648140752ddf8a0", + "withdrawal_credentials": "0x15175046d6aa23e2b31eb54063c8a1f7fa86ca5eff07c963d4521d4bbb040b43", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa0e27864d6b654c4d9b58d1248ca6a494b47d5764847ce585f31df6aa5cf24d17113207ac820b0a5f6da0df2b182931b", + "withdrawal_credentials": "0x87dd2c4696705f7f73b0204559fd1cc62099c4ca46bcbdc0e659b2fcd9495783", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb18269548d92185838a418050a4c9523838a4704849986ca7d0e2c1b360c8319011a2df056268abf89350de67d1b1b78", + "withdrawal_credentials": "0x619b384656d9a0f5882a52eeb2ebf32b1393c6a6d92a6c4c8b572b6c2488e86d", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa211797aa69f18ce249575da91eca37736093b7339a10fa1272692ddd82239fd8f6b75b36a796721b81d6d9a23fabf84", + "withdrawal_credentials": "0x713fd146172bf3f6a05dd5853306de577144e0d254c84764e5385015f6b14857", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb2463b15365ee966c742aab78e5a694f1f4eee7ba5e633930b0c5f587ff65fa8d7d4ad918a8120fdfc1c69c2ef175b70", + "withdrawal_credentials": "0x4afddc46d793346db6d7062f8cf4b4bd653ee2aee736f6ef8936c98442f0d941", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xab4bbb1caad2be96ce362592fcc04c8c71734b59fef25d4cdd59bf6aa351ddcb63f5361e5d9dce661efcd56b4218f929", + "withdrawal_credentials": "0xbdc3b9469759700a756972338229308c8a50dc1a2debea4c9c3d5e3660352682", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x955246320f9112d6559264b15d335ec4e9bb68ab2b73dc08b242944b4aa4741d391a89f3cd3382a858b5e6ec9bf33b6e", + "withdrawal_credentials": "0x9781c54657c2b1808be3a3dcdb1707f27e4adef6c15999d8403bd7a5ab73b76c", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xad37627de08eb0d0bedbc4f9b6a4aa2e002627ff5cfbb6959490b144fbfc6a331e9dc0c4c712ffb05a9f0d42754dab30", + "withdrawal_credentials": "0x0948a2461788ed1d4a750fe1d04c82c0a35cd862070e8e3553426c57c9b803ad", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x975152efef95e4e4af3a6a0f79b1f3aeefb81320c04467fb624ec2adffb3af5062b55b8c5783552a7c5a190ef20b36d7", + "withdrawal_credentials": "0xe305ae46d7f02e9460ef408a293b59269756da3e9a7c3cc1f73fe5c615f79497", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa6e40ebe55ee13712a34981540bdd953448f1352d13742cfd7ae8abe89b0745a679a86aee7b5b416e5a3a87170ddae87", + "withdrawal_credentials": "0x56cc8a4696b66a311f81ac8e1f70d4f4bc68d4aae030311e0a477a78333ce1d7", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x91866281e564f2166e4763df3b138fd387f17ffcc7b347fdbc1fb50a31655dd39ec1d682f5044ce69eab524aa4007a87", + "withdrawal_credentials": "0x308a9646561faca734fbdd37785eab5ab062d686739fdfa9af44f3e77e7a72c2", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x933ff51b3543f3a53e0408f9553e242db71f4da386e07a2c50116023f5b6a897dc2ebe40df4f89381081fc5b651b81b4", + "withdrawal_credentials": "0x0573b7451559d1e09beb31a9e2adb7cb9dd5b032846aed4b7a71f8a1e8daaa59", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb6a7219422fa8dcf311dce6f2daad64d8e7add1905e755ea43e40df9399d45fa201292eac717cdd6bb09e438706b186b", + "withdrawal_credentials": "0xdf30c345d5c11257b16563523a9c8e3190cfb20e18d99bd71e6f711134193c44", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8348da0d73db2e9e07fdf61060b5fe240a884c2e8edd48077f6ba522ce0a23fec3f5b5277795bb959c76b44dabcdb37b", + "withdrawal_credentials": "0x52f79f4595874ef470f7ce5630d10900b6e1ac7a5e8d9034317606c3525e8884", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xac026719d44d1e8eae15ec4df24eed0d77a2f463792f5ba9253d23d50f8f19d3e82eb735d2acfdf7105f5bda84530487", + "withdrawal_credentials": "0x2cb5ab4555f08f6a8671000089bfe065a9dbae56f1fb3ec0d5737f329d9c196f", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8040a9aa1a7c18f8db862015ea6ba5b260a3790640302913eafef678d40c66805f05cf1a0f46a2254ebc8dafe79e2bca", + "withdrawal_credentials": "0x9e7b884515b6cb0745036c047ff45b34cfeda8c237b0331de87a14e4bce165af", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa8a8f5fd201bc673bada188e1ad794d70c44272af3dcc856e38055f602e26747fbb3506f172aa018d083b3690f2e644c", + "withdrawal_credentials": "0x78399445d51e0d7e5b7d9dadd7e2329ac2e7aa9eca1ee2a88c788d530720f799", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb932d4eee66120398141d5d9a50d71dc9e7c6950a9a65e917d3a86b33d887189c85a728c4bb6c1ae82e63e46454a28d6", + "withdrawal_credentials": "0xebff704594e4481b1a0f09b2cd17ae68e8f9a40a11d3d6059f7f2205256543da", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa421315146222618b1c57f9e304785c4de36458dade253a459e577566b4d806ff1691c5ebc8a974cb4ed8b1704ba3c42", + "withdrawal_credentials": "0xc4bd7c45554d8a9130893a5b260685cedbf3a6e6a4418591437d9b7470a3d4c4", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8d33433c914c5ca722b0683f97f4d05e012cdc85633a3d2581b2b1c7a57248c60b9446d89e224655c04be566c60127fa", + "withdrawal_credentials": "0xd4611546169fdc9248bcbdf2a7206ffa39a5c0121fdf60a99d5ec01d42cd34ae", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8cc3ed86d17823dc4f2e7b26afd5cc158a9aa0eae455d3036a12b58ba820ef469bc6c96b924993a742bee6a6935b28d4", + "withdrawal_credentials": "0xae1f2146d6071e095d36ef9b000f46602c9fc2eeb24d0f35425c398d8e0bc698", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa022cd8d35607db7b3261c18d36951b7b9cfefb4a5154e5c04588a4272f31edd43e722febde2bdc2a4a87c996bf00451", + "withdrawal_credentials": "0x20e6fd4595cd59a61cc85aa0f643c12e52b1bc5af80104925563ce3eac5012d9", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa8a931213b70226a83587756c4600a2ff88d2cd4eb61fc671e9da331c3a3bc0bbc8ce4a39db7d52998c678514b2eea1b", + "withdrawal_credentials": "0xfaa3094655369b1c32428c494f32989445abbe368c70b21df96047aef78ea3c3", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x944871d0c9f5ed3f398b2affdc4c9bc535a38c093e20ada27d8fe171fec1a1b990243883afed5eabe561c6ec39864b30", + "withdrawal_credentials": "0x6d6ae64515fcd6b9f1d3f74d446713636bbdb8a2d224a77a0c68dc5f15d4ef03", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa4d9a7333cbbfe1b43c81d96c2c75624494864a7759e7831003e4604f678699fda282c3ea510c99c98c75bba3cc4604b", + "withdrawal_credentials": "0x4628f245d5641830074e29f79d55eac85eb7ba7e65935506b06555cf611281ee", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x85ecf16940353cf72aee4b4aa8fec6c881b79dfdb7b6204dc13793b9ce153a6cb43870db19659f5a222433f938206fe9", + "withdrawal_credentials": "0xb9eece45952a54cdc6df94fb938a659784c9b4eaab474a63c36cea807f57cd2e", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x872247e7012206c1e5435f7743d5a555239339733524372121b95ca339504d44094c6f908f08ebd2b53cb1ed085a245a", + "withdrawal_credentials": "0x93acda4555939543dc59c6a4ec783cfd77c3b6c63eb6f8ee676a63f0ca955e19", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa5a7604c7f72ebb0fb5471a96b8d49762c6b75aec9ff44cfa2e312f9cd296a3e9375b891d785438dd48aedfadbc426e2", + "withdrawal_credentials": "0x6995fb4414cdba7c434a1a1656c8486e653691724f810691329768aa35f696b0", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x93818d1d96a9323ef0447a95838d42dd1a09a4b9037c00beaadd6080835ccc5d99ac25688d65530811641e17dc3180b3", + "withdrawal_credentials": "0x42530745d435fcf258c44bbfaeb61fd45830934ee3efb41cd794e1198034289b", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb6347454b98399213bb55322bae7cefb903ed09c594c87259f31ed3232db2aace12fa70185509888bfa245ad225f769c", + "withdrawal_credentials": "0xb519e44493fb37901856b7c3a4eb9aa27e428dba29a4a979ea9b76cb9e7974db", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xac572911123c11d2009e1c385f22fe42d16a679775646eab6fbc8be798be02f77a9b57cfb06550539c024e059e30bb34", + "withdrawal_credentials": "0x8fd7ef44546479062dd0e86cfdd97108713c8f96bc1258058e99ef3ae9b705c6", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa061bb193abe9246eaaaac35b76cb8d70f8239298069c7396da3411f63e7911a392161acd162c21fdf833d60f806d169", + "withdrawal_credentials": "0x019ecc44132ab5a3ec615471f30eedd6974e890202c74c62a1a084ec08fd5106", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xaa5d57db0f3b58f238b9be564a977b953a1de9d6b4d8a2be7dbcf0f0cb0200a73ab14bd5c069d53db8d46fb226672562", + "withdrawal_credentials": "0xdb5bd844d392f61902dc851a4bfdc33c8a488bde9535fbed459efd5b533be3f0", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa81cbb669ab9ae9951ebf7a143b4a3a83c8884fb2f0420e95e61904de24a3b27e9426687419c48645f9a7a1720ebe50b", + "withdrawal_credentials": "0x4e22b544935832b7c16df11e41323f0bb05a854adce9ef4a58a5920d71802f31", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa1ddf7f024df4dc53d70a695ddefc6741afb9b002e686ea528975765b1d8b61e8d60cf4984178799c67df3ba3156c9d3", + "withdrawal_credentials": "0x28e0c04453c1732dd7e722c89a201671a35487266f589ed6fca20b7dbcbec01b", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb4f2ab7d49b6f55517d4eeb28c540fdb9dffbab0c13bc76e07a434fee9b383521a0fd9f6639a8546fa3671a00a211009", + "withdrawal_credentials": "0x378459451413c62eef1aa65f1c3b009d0106a152eaf579ee568430268fe82005", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb1efeeb48386e83b4966e55d834fe07b63ab3cdb59c1c4aaccfd587a819445c50237894bef43d235d7deebbce23a77af", + "withdrawal_credentials": "0x11426545d47b07a50495d7087429d702f4ffa22e7d64287afb81a995da26b2ef", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x92e12d76878e0de0473c4c6782c1792e4e70baa2852acf055bc3c88737dc845d3660e0f91a57be075718545a4e45f1a6", + "withdrawal_credentials": "0x8308424594414342c426430d6a5e52d11a129d9ac3181dd70d893e47f86bfe2f", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8534c9f9cb0ad52f9d80709583a57518b5479ce39f2027503bfdf5c15f2c6bf277ed0fa8ded816d106bfa94ae5884d56", + "withdrawal_credentials": "0x5dc64d4554aa84b8d9a074b6c34c29370d0c9f765787cb62b286b7b643aa8f1a", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x95a323d2a4bf702d248584876975f60cca9ec15ff0888d928f8f3798e1ebb55d9b1704a2369db37a4874cf20c1fa18ae", + "withdrawal_credentials": "0xd08c2a451470c0559932e0bab981a405331e99e29d3bc0bfc48d4c6862efdb5a", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb0b0c8a0b5cc2eb6b35db821eb29d759fb33284bd5ccb325b1f8a96e07ca96d12037edc86443b642ec6db22e0c6487e3", + "withdrawal_credentials": "0xaa4a3645d4d801ccaeac116411707b6b26189bbe30aa6e4b698bc5d7ad2d6d45", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x875a76a3e345afee45e7181cea2f8e1f85160eb87b48f1fe8813872d412b08b2f4ff9515eacdab1157f02eec3396e2f0", + "withdrawal_credentials": "0x1c111345949e3d696e3e7d6807a5f6394c2a952a765e63a87b925a89cb72b985", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x92859a8dd8bc58c9c35ba7b5a03f68937dcd6a168c1986f2367dd115d07b596dcdc305ef4aefc5c20d0e15b2dec71458", + "withdrawal_credentials": "0xf6ce1e4554077fdf83b8ae116093cd9f3f24970609cd11342090d3f816b14a70", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x94c1b49cfe20e8babbf7fa80d5989fbe24118149ac9adfabb587eb6ee462b2f6f812b32fd29c1abbf52ad0801ea1c28b", + "withdrawal_credentials": "0xccb73f441241a418eaa80283cae2d9102d9771b21a981fd6ebbcd8b281118307", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8244460fdae46ef761855909e46c678b8386f473d146da67b2b0899c88053b12fbf6d2b540587e413a6bd5485d330d2d", + "withdrawal_credentials": "0xa6754b44d2a9e58e0023342c23d1b0762091738eae06ce6190ba5122cc4f14f2", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x89c7d432a62ab14608090ffa3b53ea83ab1bcc3b450ec2e93d8bc60779b88f1cec594b0ec28148af581cdf069511d950", + "withdrawal_credentials": "0x183c2844926f212cbfb49f3018062c4546a36dfaf4bac2bea2c1e6d3ea946032", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x86f0ee71fb95022911b594c7db22b94cd37bd1a70b1a36ebb452e7bdf02cb25d3805ad622fa28a623ad20ecb625302f4", + "withdrawal_credentials": "0xf2f9334452d862a2d52ed1d971f402ab399d6fd68729714a47bf5f4335d3f11c", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb9546c91cbd47bcfa488a983fd877aca4c8291f35064c6df05213232a4e5794f32a0dd52deb6d3c060fbcd823872340f", + "withdrawal_credentials": "0x65c01044129e9e3f94c03cde67297e795faf6942cddd65a759c6f4f454183e5d", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8cc8d50ab70030baadfc940c13e40a0f1e94a78cdc96c7e1006a596e69f9a4180649763c3c1c232b4b84d81c1beb01f9", + "withdrawal_credentials": "0x3e7e1c44d206e0b5a93a6e87c01755df52a96b1e604c1433fec36d649f56cf47", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x80419c71149761ff351d665bea6c7d874588e8c8a3462cc38d4059b700b65280591e10bf9f1b386c32a9f20ebfe7ae85", + "withdrawal_credentials": "0xb144f94392cc1b5369ccd98bb54cd0ad78bb658aa700099010cb0216bd9b1b88", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa9fc3471260f9b26aaec3c23ad10ce7b1397e412c3b2244fd28350d4a3600e9eb15bacfd9d96b27a0d3f6dd32f3249aa", + "withdrawal_credentials": "0x8b02054452355dc97e460b350e3ba7136bb567663a6fb71bb5c87b8508daac72", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa9208ba9a2194fe136236f55ba1386e75220d78b87f13c5c271840ffa732d1ba5ed1d61791eeab0b79b6a50ee0bd9640", + "withdrawal_credentials": "0x9aa69d441387afca96798ecc9055913fc9668192b50c93330faaa02edb030d5c", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x80c96133fbd52e79a7942109776cbb23bdac979244528e097f1e916a4d0b7463b4af2d7f4c6b06a820596d7c7688775b", + "withdrawal_credentials": "0x7464a944d3eff040acf3bf75e84368a5bc60836e487b41bfb3a7199e26429e46", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb65586852e5e24552200524b31eb54f3bf83782fc3afd6c1b45b30061ed98eb36dfb2414622cb3fecf0aa32680885f22", + "withdrawal_credentials": "0xe72a864493b52cde6b852b7ade78e373e2727dda8e2f361cc6aeae4f4487ea86", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x9923628ca9e4bf029de23f10ea12be7c68fcf0babb9b2e94b6d854bfc26488222271bb11d870f79e7fbc8d572e465096", + "withdrawal_credentials": "0xc0e89144531e6e5481ff5c233767bad9d56c7fb6229ee4a76aac27bf8fc57b71", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8d87ba1c7738f7b14b45562d993016c3aaff28d66c06006edd27e779404adf72ea01d5cf02752f07fba516a4020c6e02", + "withdrawal_credentials": "0x33af6e4413e4a9f14091c8272d9c35a8fb7e79226852d9047db3bc70ae0ac8b1", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x99cee98eb05f310aa7c0cf69a7adca06b50e927abd98f66a46db9aecd28bb159f81d18ef22b5512abe7ff7e6592dd416", + "withdrawal_credentials": "0x0d6d7a44d34ceb67560bfad0858a0c0eee787bfefbc0879021b135e0f948599c", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8a56d6d4a228b9a437aafbe1cd67630270694e0bc258ad06eeacebc2bb9f91896c77347f7b0fb9ee018c75ce48069df6", + "withdrawal_credentials": "0x7f33574492122705159d65d57bbf87dc148b756a41757ced34b8ca91178ea5dc", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x89b56335a0f6072a50c7f4c2a7f6c13375c0539ec6e96e589ce6f092101ca469d5c68dbc609deb6c6720cfc3ca1c1211", + "withdrawal_credentials": "0x59f16244537b687b2b17977ed4ad5e4207857746d4e32a79d8b5430162cc36c7", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x82e63946d7ecd5b029e583d716980121ac053036c8e2539c54590fd093b8a199125ca81e05437e2f32d9ba615e782e14", + "withdrawal_credentials": "0xe2e1d58f9895b65d8f9384b1123e78a8b8a62aff6d6c0709a38fb94de115840e", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb85ace936ff7c586f535dd9d099a9912156fa573e68c15cb4e59119735c4f2e217ad50be7432d0ad07d9ef0ce922748f", + "withdrawal_credentials": "0xbc9fe18f58fef7d3a40db65a6a2c4f0eaba02cdb00dbb594478d32bd2d5415f9", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa85181d81a61491234a89ce78b38a32a65a30883676c02327d51f37eccac79b09b159d77e3a8c357c613a42c34c476d8", + "withdrawal_credentials": "0x2f66be8f18c43371649f215f6061cadcd1b22647468faaf15a94c76e4b996139", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x954c039820868bcf0462ce5f03f7b1b580f6a1d3a6b11e563a111b99e1b6054cd85c0a2a8bee9aefd2662ce57389c26e", + "withdrawal_credentials": "0x0924ca8fd82c75e779195308b94fa142c4ac2823dafd587dfe9140de96d7f223", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x92fa07603f121755a03f501e681c7925c4d7ac722677a7afc30ac3ca17edc591a3556a07c3389454b6395655410b0851", + "withdrawal_credentials": "0x7beaa68f98f2b08439abbe0caf841c11eabe228f20b24dda1199d58fb51c3f64", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x924bcf588ccd2cc807ebc2a13be45d1d823189083c7ceba599dec6c4efc2fe584f2feb773acc6ea29023986b0c878c3c", + "withdrawal_credentials": "0x55a8b28f585bf2fa4e25f0b50873f376ddb8246bb320fc65b6964eff005bd04e", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x87bbe1851c1c76dff5724ff9ea4991eb18cd973368e2fffc0a8f96a989dba8b3ba2364f472ee3ae5efa88cffdf0dcff3", + "withdrawal_credentials": "0xc86e8f8f18212e980db75bbafda76e4503cb1ed7f9d4f0c2c89de3b01ea01c8f", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8fd60c26c770f756f5755e24dd842815bec4d2a4d5972bed81f619d65f5c438b55d0815a51fb7ac29103ca30d56d3f12", + "withdrawal_credentials": "0xa12c9b8fd8896f0e23318d63569645abf6c420b38d439f4e6d9b5c2069dead79", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb9d761f4aae30c40a134536e82fe10a005776769a9aafa8828d84a2f6e2108324d3fc4b9dba8ff9389ee58fe7a891de1", + "withdrawal_credentials": "0xb1d0339099dbc10f3b6410fbd8b02fd754763adf08e17a66c77c81c93b080e63", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8f8a44d7b8bf1a9c4b0da59fd1c5b81fcd7f4bb65f74f5c15070896d801adade1afa3057e4446fc4485c95d8bba45322", + "withdrawal_credentials": "0x8b8e3f905944038650de41a4309f063d47703cbb9b4f29f26b7afa3887469f4d", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xaea0272cf434061757f99e10bf69a3d360582f9e017bccd33004f4171480da267ccbe05e2bab415fc721cbe05331ac70", + "withdrawal_credentials": "0xfd541c90190a3f231070ada826d4810b6d823627e1031e4f7e818feaa58beb8d", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x9352921ea86b4fcafb31353d6f6ec851f016bfd040261c0d25ed31513dd96f90db5aec8b62b4f01de27c844e5f938fd3", + "withdrawal_credentials": "0xd7122890d972809925eade517fc25871607c38037472ccda227f085af0c97c78", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa90d76c381296c7771550ec8802afdcd871323230b5fa6293372c211f13ecf26bea3529c6f3961efa6bd9f14f71ea78f", + "withdrawal_credentials": "0x4ad904909938bc36e57b4a5675f7d33f868e326fba26c13735869d0b0e0fc9b8", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x90426a54b52002ce7dedc53271685fac6fd34fc9f2ada48b0e973cfb70c1bfc669f8edb600fdc09a829dbb64754f70ee", + "withdrawal_credentials": "0x2397109059a1fdacfaf57bffcde5aaa57988344b4e956fc3d983167b5a4d5aa3", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb04eaf02e2c89a51c4a85719508e42e156e4b007be028a32c4b82f07a2caf480c200d239925858a9b1b06fe2ffe194c0", + "withdrawal_credentials": "0x965ded8f1967394aba87e703c31a26749f9a2eb794496420ec8aab2c7892a6e3", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x92d58fc2e15dabb9856d510362e29e3005eaf5afdaa6d73167910088cde285df049e183e7a073948228a32a7bcef4157", + "withdrawal_credentials": "0x701bf98fd9cf7ac0cf0119ad1c09fdd99294309327b812ac9088249cc3d037ce", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb2504cc3cfc396fd5d1c8bd0fb28abdb664cefce90c0e215fed809e0e003db8a213316794641974d8b41fb2e4e8a8e71", + "withdrawal_credentials": "0x46041a8f9709a0f936f26c1e8658094b80070b3f3883204e5cb529562e317065", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8fd5bfb6f3fc8289b2b96f61e85314fff9451620ff76e02ecd1f1e18f85a1d28d7d372757c5f62651e5ccc8747e88e9a", + "withdrawal_credentials": "0x1fc2258f5772e16f4c6c9ec7df46e0b073010d1bcbf1ced900b3a2c5796f0150", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa6257c4d665a74781c6474bbbd9e3654816800d9e620d6599a9d07d90ecc25b30bc2162406a110b04fb0287170b22bbc", + "withdrawal_credentials": "0x9288028f17381d0d0bfe09ccd47b5b7f9913078711a6c33613ba377797b44d90", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x9816d5dfe480e7407fa48799e97613b36b7e3f4ea40409d459afe79289f0865b489047923236c33de8d6fa5064e21012", + "withdrawal_credentials": "0x6c460e8fd7a05e8321783b752d6a32e58c0d0963a51472c2b7b7b0e6e2f2de7a", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x85af0debd8150ab283be02193d85ec6cc5bf83d5150dffa39a373e143166f556d84d80bb1639d3e9eae8f77d32607f3e", + "withdrawal_credentials": "0xde0ceb8e97669a20e009a779239fadb3b21f03cfebc8661fcabe459801382bbb", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa582b36ff4fdd89b42b41257e74f4ebef541d58eb26ec16690cea2186ad86b636fcf7b152cff1cb937ebb5dec4c0b41f", + "withdrawal_credentials": "0xb8caf68e57cfdb96f583d8227c8d8419a51905ab7e3715ab6ebcbe074c76bca5", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa9eace0075c4fd875cd34d1d33b70388239c8d2fb261d7f7de5410290ade122beb97e55eff954d6dcb34810dd689f309", + "withdrawal_credentials": "0x2b91d38e17951734b515442771c2ffe7cb2bff16c4eb090881c353b96abb08e6", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb8402ce87952bdd62fe35a001d5e6eeec1589ce7b17b533a549bc8ea0c623bc90b307a517c55b0b378d9a477c8bfaea3", + "withdrawal_credentials": "0x054fdf8ed7fd58aaca8f75d0cab0d64dbe2501f3585ab89325c1cc28b5f999d0", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb118ece6890d73c69e078778e485a36ec4c46c13835cbb0851e91203d23e92796a6d3db24576f30416ab1e821faf404f", + "withdrawal_credentials": "0x14f3778f984fababe2c2f8674ccbc0791cd71a1fd3f793ab7fa2f1d18823fab9", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb5e5eea094bd1d47e8af58b0cf0923cec826c0273af1d70bd13c61bf1018314c962786640e23b4b99a4ca97c1e3b2fc5", + "withdrawal_credentials": "0xeeb0838f58b8ec21f83c2a11a5b997df0fd11cfb6666423724a06a41d3618ba4", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x98e1a9f686747193e5c4c2ef173376d7fa6eba245a6be60e1f03a4b8602ca44fa9c1854dfb74168650bef2ea472a71cc", + "withdrawal_credentials": "0x6077608f187e28bfb7ce95159aee12ae35e31667ac1a379436a7fff2f1a6d7e4", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa670ca0acad87fd703652fd6b5637ea08f0574ea796624bd53506ebc2987e74aad2ce81ad8944a00ea65e2c012a8ddcf", + "withdrawal_credentials": "0x3a356c8fd8e66935cd48c7bef3dce91328dd18433f89e51fdba478623ce568cf", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x967b31c6012734f4e06ec9c0213237fdf20c6f7a78d9cbbec2f7dbcfa02494f0176fad563f70226fdfa1c7e093fcc2b2", + "withdrawal_credentials": "0xadfb488f97aca5d28cda32c3e91165e24eef12af853dda7cedab0d145b2ab50f", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8c8669dd614a7d7e1be27c78d93f74445cd05ebffc97d6140770f324aac71e7600f24c07eff9671f844b33f03c57afc3", + "withdrawal_credentials": "0x87b9548f5715e748a254646c42003c4841e9148b19ac880892a98683a66846fa", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa7eea08884d0e81c6c4d044b6a5c624432fcbff44af67d95c889140a51b033e14adc747f85773b375d9d93f864728d59", + "withdrawal_credentials": "0xf97f318f17db22e661e6cf703735b71667fb0ef75f607d65a4b01b35c4ad923a", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + } + ], + "balances": [ + "10316516445055493815", + "10321473899000513495", + "10319821411488862071", + "10258679506701745558", + "10257027023485061430", + "10261984477430081110", + "10260331994213396982", + "10252069569540041750", + "10250417086323357622", + "10255374540268377302", + "10253722057051693174", + "10245459636673305237", + "10243807153456621109", + "10248764603106673494", + "10247112124184956661", + "10238849699511601429", + "10237197216294917301", + "10242154670239936981", + "10240502182728285557", + "10285119251053593494", + "10283466763541942070", + "10288424217486961750", + "10286771734270277622", + "10278509318186856982", + "10276856830675205558", + "10281814280325257942", + "10280161801403541110", + "10271899381025153174", + "10270246893513501750", + "10275204347458521430", + "10273551864241837302", + "10265289439568482070", + "10263636960646765238", + "10268594410296817622", + "10266941927080133494", + "10205800022293016980", + "10204147539076332852", + "10209104988726385237", + "10207452505509701108", + "10199190085131313172", + "10197537601914629044", + "10202495051564681428", + "10200842568347997300", + "10192580152264576660", + "10190927664752925236", + "10195885118697944916", + "10194232635481260788", + "10185970215102872852", + "10184317727591221428", + "10189275181536241108", + "10187622698319556980", + "10232239762349897621", + "10230587283428180789", + "10235544733078233173", + "10233892245566581749", + "10225629829483161109", + "10223977346266476981", + "10228934800211496661", + "10227282312699845237", + "10219019892321457301", + "10217367409104773173", + "10222324858754825557", + "10220672375538141429", + "10212409959454720789", + "10210757476238036661", + "10215714921593121749", + "10214062442671404917", + "10575956426039018910", + "10574303942822334782", + "10579261392472387166", + "10577608909255703038", + "10569346488877315101", + "10567694005660630973", + "10572651459605650653", + "10570998972093999229", + "10562736551715611293", + "10561084072793894461", + "10566041518148979549", + "10564389034932295421", + "10556126618848874781", + "10554474135632190653", + "10559431585282243037", + "10557779102065558909", + "10602396166095899550", + "10600743682879215422", + "10605701136824235102", + "10604048653607550974", + "10595786228934195742", + "10594133750012478910", + "10599091199662531294", + "10597438716445847166", + "10589176296067459230", + "10587523812850775102", + "10592481266795794782", + "10590828779284143358", + "10582566358905755422", + "10580913875689071294", + "10585871329634090974", + "10584218842122439550", + "10523076937335323036" + ], + "randao_mixes": [ + "0xcc9b03923c85d9ce8eba32968977d98d668788d1c2f0e4f3a79facfcd8247794", + "0x933815925ca23b00aef1fc130edd9b26547e8b1b9f966ac51e1ce2a3480251f4", + "0xa6590f92fced1a45a334643fe265b0f35a818aad565f937f4b9d256c2363087f", + "0x05fff1911c68779d6d836818041217f579908587e54a5f223023775567479d34", + "0x1820ec91bcb356e263c6cf43d89a2bc27f9384199c1388dc5ea4ba1d41a854bf", + "0xdfbcfd91dcd0b81383fd99c15d00ee5a6d8a876379b90daed520f0c4b2852e1f", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000" + ], + "slashings": [ + "10518119487685270652", + "10509857067306882716", + "10508204584090198588", + "10513162033740250972", + "10511509554818534140", + "10503247130145178908", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + "previous_epoch_attestations": [ + { + "aggregation_bits": "0x5f8eaf0a8405eedd8d1b23877cb087aafbbc0d4c5470c638620ffe76a69b4c6eca3a5a12f67cc47e0295165f7eefd7658e46d60c5b5cebc413aa2d502933802131711eb6726c777403c900e2c481f77893cc8526890a11e754d8210cb319a9bb827f8953a368ec97d2af59ad172a5cb09e80077f57976c3de036b896a6dc495732a1054baf0e526d9cf7493fa7c430f14db3a3938dbe8f8d152206f53a05758f6247fffd465e2afb73a945390f9c8c077e350b129f0600a002fb25f6d51e8a19a0dce9179ffd8dc84753484965a8ba53af03c41ad97793125cb4f48ff89d9a5f0af0f3d9b5120fd28348e329ad632b64f2a2c60f987acf781d9a4605c09902da01", + "data": { + "slot": "10546211710958835421", + "index": "10544559232037118589", + "beacon_block_root": "0x207238929ddcff62ef5f910f18a820582e6c91af59e275680b154df22abd04b4", + "source": { + "epoch": "226394009", + "root": "0xfa2f44925d4541d904dac2b87196f7bd2266938bed5024f4af12c66175fb959e" + }, + "target": { + "epoch": "226778758", + "root": "0x6cf620921c0b7d76c36b2ebd67cb728c47788df733051951c2195b139440e2de" + } + }, + "inclusion_delay": "10528034391280342716", + "proposer_index": "10532991840930395101" + }, + { + "aggregation_bits": "0x052eed1ddda2449b89c72d11f2df83a2b598453a9a5a27fce96023189460d7c5dfdd6c163c4ca2ff1e335468664bcefd22bca3d5f53b9dba95693dbfff6b3a1927083762bc1635909e63f2658ac02899aad3cbc6341d6e209e44724865391719faac816b8c5170a675730651a3847d8a0c1fb692e306ed96e7df532ed99efb41b3dd750f71eda68523735bac256787d44f414a6994dba90c5c9a6d5e869e7e88fad9c22b0ca23a916f41978b6198b83a1b7989b6dfb2241b50f30b42ee7defc2624837aba0e9dfecc2a603f7895378c286ef5afeff7b18f45153140d50eab8c7450729b104c0aeeba0ee186ac0ac4105904d81bde49c80382d40d5c92ea1662201", + "data": { + "slot": "10468544969709910331", + "index": "10473502419359962715", + "beacon_block_root": "0x097c5391fb6104e14b934cac5680419622e26aed2176acc404c395746f7ef4d5", + "source": { + "epoch": "218121908", + "root": "0x7c423091bb27407e0a25b8b04cb5bc6447f46459672aa12117ca2a268dc34016" + }, + "target": { + "epoch": "218506657", + "root": "0x55003c917b9081f4209fe959a4a393ca3bee6635fa984fadbbc7a395d801d200" + } + }, + "inclusion_delay": "10456977582898154139", + "proposer_index": "10455325095386502715" + }, + { + "aggregation_bits": "0x696d247befe49563ad922a94754c3d09c63eed1794770f4f06cdac61b976fe930b14c6838265dbfb3ba0426ca1864579d6cd3ec208fc8565a7bb7f45dd1e7c1dda841fefb3cef40b2a07689710ec8fc5d6f78bbd834be7f5fd512af73a225fd0841f676184629294d17e3d5ba7a5ab7fada39564d76478042740dde775e2a2b78419b06f3030949b98ffa8cbdc06093e46e9ce11b6f81823943fec63501940bee5bb9c16fe723e730d20ea3070fbff11721213ae6d8427cd948a12f1a5d4332dcbc44a3998ad116fe491ab65a6d1b52a3ff4ef2dbea705e58b97447dfa49b5595ad554b68db0f58073fa1813b13cbd39cd8bead8a815b16a50fb6939306e361b01", + "data": { + "slot": "10450367645736450330", + "index": "10448715158224798906", + "beacon_block_root": "0xdbe71291dba19cd6d473bc896e61236667036033f6156dc4fb4f7c0fd1a7d5cb", + "source": { + "epoch": "216775287", + "root": "0xea8bab919cf3eed7eca63f21ef7b0d92c4b4795f72b348dc5531a1b8a3d135b5" + }, + "target": { + "epoch": "221777023", + "root": "0xc449b7915c5c304e022171ca486ae4f7b8ae7b3b0522f767fa2e1a28ee0fc79f" + } + }, + "inclusion_delay": "10498289676200159228", + "proposer_index": "10490027260116738587" + }, + { + "aggregation_bits": "0x9148df7be014de7c40c8ae64024cc6f55ed7189d0a9c014ddefbb44634104059518556d1b2cacf99ed5155e710a65822b557798b1b512d12eb7e4dbbfb98d36ac7680cb7fbdc68886947f5e6de5c4cf26cae09d6941a804092c2c648f88dadadf749575101f87cc1ab961ab4b057f344c1ea1b1fa4df11bcd74a16d8194ce8130787da8b96eff3a3c01efc18ca145acd0dfe6335d05de92e17b230175b166c93567783012272c336e043fa472699b4755849bfea72b0332c4e8221689d0f92502448b236d87bf8320457bf7095479ff11b2bd65aba9f2cc14b2210b101f8643a4e8bd12c0de37b93f0c2e36f090c3c7a4eb9106ea4fc5fd0e7c22fc592255ffb01", + "data": { + "slot": "10491679743333422715", + "index": "10483417322955034779", + "beacon_block_root": "0x96b576913b9cc8438b01e1a7604bc6c7fccf7081dbc1b767f1bb00c35139a895", + "source": { + "epoch": "220815150", + "root": "0x70738291fb040abaa17b1251b9399d2df0c9725d6e3066f396b979329c773980" + }, + "target": { + "epoch": "219660904", + "root": "0xe3395f91bbca4557600d7e55af6e18fc15dc6cc9b4e45a50a8c00ee4babc85c0" + } + }, + "inclusion_delay": "10480112352226699227", + "proposer_index": "10478459873304982395" + }, + { + "aggregation_bits": "0x09602575709e7df892147500a107d58baa3b79ff321117cd423fa648fa3b81ca62dadbf9c5d7b23aa9cfd399eddc35872bddd5e19539c466206004ef8d91366932ec0f6ca4c832141b5eb2d88e4b8b200736f252594a031ff8a33486e07e8cfc3bf73052b151822962a2d2be099bc2ae5091506e1195218819313d7d0c63f21b9021123380e854bbbf213af4072f8f1b1874f6143f1d0c2b4f26bcab730dd67e97a60774b5f4e0cefab781780a76994720f1d73f34508afa176162e1240f24ca9743de5a6b3c7bc03dede90e7633bac148a38a5f8fed9e160040a57c1bfdcb8b2e686a479933804cd0d3238732a09a9eef16cb6e409f03091e455668cd7f024401", + "data": { + "slot": "10420622934951234138", + "index": "10418970451734550010", + "beacon_block_root": "0xcc437a9019504ad5bc4039f2ec46393a095246077b7891aca16e5766ff7d75e2", + "source": { + "epoch": "211773551", + "root": "0xa5018690dab88b4bd2ba6a9b453510a0fd4b48e30fe73f38466cd0d54abc06cd" + }, + "target": { + "epoch": "212158300", + "root": "0x18c86290997ec7e8914cd69f3b6a8b6e225e424f559b3495587365876801530d" + } + }, + "inclusion_delay": "10402445610977774137", + "proposer_index": "10407403064922793817" + }, + { + "aggregation_bits": "0x5bb1dd7848b08b4ef93af2d85feb3ebd419037b7f7b9d78a6a1606cd1a5412486a33da454f80ac0bf63a44219b7f869b33d99c0c9f03fbd6c04d03619b27f7bfbaf5f3bdb3945d09246b4800f51a8616277a488ff0bdd2d6e2f747432545dd96fb62f9469d903aa25908205c8cd20308e1fb8b46c95a0b03ef22bea7e020bd3a5111903177bbb7bc004f7893457cbb039480c355f53337d43394762af5562dc7dd5094a4e3ad7017c5496c10202b86060dee43d48daaac04eb01f74f3879a0d95364efcb214d7afa03587b3b0c6afcb2b9a356f7ab2137e95bb3098cea02657c34ac2c0c969bdd6eac2e624b206502ac8bfaef9728e7f0ebb23e95e420ed435d01", + "data": { + "slot": "10395835678111037625", + "index": "10400793127761090009", + "beacon_block_root": "0x512b5190796165b771150c22b604c9d535673f0578f5aec3e2f62fe0f82379ad", + "source": { + "epoch": "215813415", + "root": "0x61cfe9903ab3b7b889488fb9371fb30192185931f3928adb3cd85489ca4dd996" + }, + "target": { + "epoch": "216198163", + "root": "0x3b8df590fa1bf92e9ec2c062900d8a6786125b0d86013967e0d5cdf8158c6a81" + } + }, + "inclusion_delay": "10437147771413042714", + "proposer_index": "10435495288196358586" + }, + { + "aggregation_bits": "0x890c9f93cd096717568f95f1759e0cba1824cc6df2d6235801e090971a4a56ff05c0f93a4bd21c5f16a5c23ebb0304d9e85b0d6f19ab04f6480f7655c5e2d721f3b0b5b9a54a631ec056915bc29f5cafc5c31c43194ecf6f083180a47862350a3e80c64815d1f6243c15cedb32490dc1eb64add4864a9023a9ac32b1ca9fc14904b8b5373be2329e4c1d7b31cad6479fb797fa58595c4ec98002e978ce81e876371044ffbb11cfaf96f175304bf6bf985371e03398779d4e2926416e5e5cd54150cb5ee416a5488a330155932c15d592d539040b8205848bc822b8a44eee57340addc3d20d793f44c99ba8e076f8a3cd79e0d93f40df7da32da76b3451a32cad01", + "data": { + "slot": "10430537834251338906", + "index": "10428885355329622074", + "beacon_block_root": "0xc074cc905a2d14115397939259cb1903b227540b837e567e215ea6720e326e4c", + "source": { + "epoch": "214466793", + "root": "0x333ba9901af34fae1229ff964f0095d1d7394e77c9324bdb33653b242c77ba8c" + }, + "target": { + "epoch": "213312547", + "root": "0x0df9b490da5b912428a33040a8ee6b37cb3350535ca1f966d862b49377b54b77" + } + }, + "inclusion_delay": "10425580388896253818", + "proposer_index": "10787474372263867811" + }, + { + "aggregation_bits": "0x1ff81e4014af9cff228d16075808fc0de9c288b88aadbdd435fde9183bae4c3b661e215fb9b8d626d065711505ba20e642c5fe88ab3cf8e0830e9cd3969b9f46eab72dd9f51680c634e4c4511950e75692495bd15d98f5c9d5a843d459122db294d13de8665d5c4b6bc5f2bceeac38e78f728a5b6493c66e4065a7a58467971e8bc1ec5a69d2cb6fe3c37c751f523f088a0eff5c49a1926931e335b2b8297342a2aaaea3fb69411f0dd0068911c5dc3661ccc48d6d864a8ff85de48707ae7fbf591628b070f51e125d6a6512a34dacb67e92bd433dcb1e306b1eea6535ae1dfcefd9a51333248577730294787ba00e0559759e52975edeb36ee047e89955f20e01", + "data": { + "slot": "10789126855480551939", + "index": "10780864430807196707", + "beacon_block_root": "0x28749795c36fc7d61eed45239316569597af22daa5a10a83c3e789f3c51fb80c", + "source": { + "epoch": "255442551", + "root": "0x0232a39583d8084d336777ccec042dfb8ba924b63810b90e67e50263105e49f7" + }, + "target": { + "epoch": "254288305", + "root": "0x75f87f95429e44eaf2f8e2d0e139a8c9b0bb1e227ec4ad6b7aec97142ea39537" + } + }, + "inclusion_delay": "10777559468668795747", + "proposer_index": "10775906985452111618" + }, + { + "aggregation_bits": "0x0b1150d0cdfc0eca01aa9a65047441d5feb8476071e06e9642ec85feda355160572d8e7a738363e8c99d262eb1ec4de8f6e3e6c4439fa5d207aacbb68b1e2468fbdac985a682063d869642c17c36b803b346bbe6a360b8b82955bd17199de731e5e81f647a12c15264d9abc1266f7421e48a27ce64b19de6487894368de0e83d58fbb0c2b7796dec0591e8a8883ff95b5f2077b6713dc22e11f9478305b40332b32f0de2087fa8762e8467a71909523075327af6c71779bfc9f43596d097f261c8067ba1db86b40a3e3176e08bbe8c434fc3a4160def6f35b6ac9015297c2c825669acbb59decd7b0dc2e15fa9bf04b9b0848a586b8b2c600bde1b9bd694991601", + "data": { + "slot": "10770949531507091938", + "index": "10769297048290407810", + "beacon_block_root": "0x97bd1296a33b7630006fcd9337dda6c2147037e0b02ab23d024f0086db2dadab", + "source": { + "epoch": "258712917", + "root": "0x717b1e9663a4b7a615e9fe3c8fcb7d28086a39bc439960c9a64c79f5266c3e96" + }, + "target": { + "epoch": "259097666", + "root": "0xe441fb95236af343d57a6a418500f9f62d7c3328894d5526b9530ea744b18ad6" + } + }, + "inclusion_delay": "10805651691942360515", + "proposer_index": "10810609145887380195" + }, + { + "aggregation_bits": "0x452abf40a90c43f5acf411357174e8406ec937f4ac094533c0cd17903241edfe8ff81a38c3dcd5aaad34336d014cd573b3fb298d107b6907f73efc98339a9cdbbcf288b9fcdc0dc789860b00603667adbd5131471e539fc10350f128d22698cffaffefdddd992c9e7a75843e321ce59fbc831bbcb532bb163a346c4bf8daa6f51de5d5449ac61bb781721e6eda2db52416d1cef6f5973b118b36ffea0c323a7f00223337d479456db3675e3f5f7ab91c5ff1f132cc0bd50c9f96e64ce5545ff03b0e1a0f6bb196538f66eae1a81407c87b5215530ad3e409021827bab8fdcb62cf1f6103dbed46c0daf89d535b85976c1b1f756a176342b5e6a5bde3459abdb401", + "data": { + "slot": "10799041754780656707", + "index": "10803999208725676387", + "beacon_block_root": "0x1da5e995034d9112b443a0c3009b365e408530deaca7cf5442d7d8ffd3d3b076", + "source": { + "epoch": "256596798", + "root": "0x906bc695c312cdaf74d50bc8f6cfb12c65972a4af25bc4b155de6db1f118fdb6" + }, + "target": { + "epoch": "256981547", + "root": "0x6929d295837b0e26894f3d714fbe889259912c2685ca723df9dbe6203d578ea1" + } + }, + "inclusion_delay": "10734594883560171937", + "proposer_index": "10732942400343487809" + }, + { + "aggregation_bits": "0x173ff9281191e7dc9d6add4a2e10fe50e07078693bf647e1c8a3cdacddfc7ab4081b86b14da28cceab81a485b83dd53c579488fcabf331271907ade82843b3328edf85dda924ca9299ff8074110a457b2f0ec040f1ed38262b4721289834844b5ab88cd1f4f5bfe7754646596ebbcc70f3faeda60e4806f8b895a3ec13b6ae24ac574bf082d73957e7c11d691f9c225bd67b4403c4253eb4b76f7ce3295ae785c3df6b4812134b60b12dab791b9cf44b7345dc04c6d455ebd7c60d052df9f50685378067b6aac2ee2fb15bfa063f6fd590b06df3ed579f44b8cdb1f07a3ab69016beade47e5ce1983a28adfc89b859b1e8ab51015f78fca06699041948c1867001", + "data": { + "slot": "10727984950693435425", + "index": "10726332467476751297", + "beacon_block_root": "0x5233ed94e10013a4e582f80d8c96a9d04d0706644d5ea999f2892fa381187ec3", + "source": { + "epoch": "249094194", + "root": "0xc5f9c994a1c64e41a514641282cb249f721900d093129ef60591c454a05dca03" + }, + "target": { + "epoch": "247939948", + "root": "0x9fb7d594612f90b7ba8e95bbdbb9fb04661302ac26814c82a98e3dc4eb9b5bee" + } + }, + "inclusion_delay": "10723027496748415745", + "proposer_index": "10714765076370027809" + }, + { + "aggregation_bits": "0x53ed223313edfa3e9c781f8e43698c0603db52b36e0e05a3f3c6c7ef21984d32d47a85b9a7f5420e7511677e5b14720ccfa0595343190a8a9b2aa20d4bb526a57ae6b9842fbcbd9fae4862c466cb01494e414c923839ebbfeb1e5ae4501df7bdf8ef6565b880134f2eecf0bb819a0b45ab7c1589cfefe06b0f44631fa5f1ed2deb5c8bee1d84da0255dc5f07676b066b5fcfa5f08fc58c97436d2e40e0851aaf851fd29eec6b11b987eccb173014680b52d24ece390dc273038b881a918a722d4138b9c4a833c2d21d360bdf7e7531ad4b2bb55a6aa373bf617a74a093a0c0661e328ebee31fbc3afe61e67943693132264631b95709bfc8e086d25bb610c17601", + "data": { + "slot": "10716417559586711937", + "index": "10761034627912019874", + "beacon_block_root": "0x0e01519542fb3e119c101d2c7e804c32e2d316b2310af43ce8f5b35601aa508d", + "source": { + "epoch": "253134058", + "root": "0xe7be5c9502648087b28a4ed5d76e2398d6cd188ec478a2c88cf32cc64ce8e177" + }, + "target": { + "epoch": "251979811", + "root": "0x5a853995c229bc24711cbad9cda39e66fbdf12fa0a2d97259ffac1776b2d2eb8" + } + }, + "inclusion_delay": "10757729661478651618", + "proposer_index": "10756077173967000194" + }, + { + "aggregation_bits": "0xcd708af8a003faa7fe724d2027a573662971e64efcf2f50a3cd19b425c1b7dd838d9b5d73b45c76693d8b4bcb26324a8a83e6f6900c9e0cb8227c266df4a1973fbbea0b7b3ca35800c9c4fad325ff7c0083230133ba470ae7cb7aec5537d31ec36665ec8eb90a2f22cf614d8a063538fbaad5c21d7a753a5c4c00a2811118ea31b7bbcba7967e884cd823c62d8eae57026e401f9de9395669586861eb901aabbf044f0671d22df538448f81f16699165545dc3aba2b96b694c0006ab3d073563dd59b75620ae13eb6821885a4726c47af5784d27094d6eebd4a9cc8ffeeb686f66609bfcc2570b0f8f1364d4ae7048dd16e5f3b33340c0e574b0fe8ad27ccaa201", + "data": { + "slot": "10751119724316947810", + "index": "10749467236805296386", + "beacon_block_root": "0xe06c1095223bd70626f18c0996612e0227f50bf807aab43cdf829af163d33183", + "source": { + "epoch": "250248441", + "root": "0xba2a1c95e2a3187d3b6bbeb2ef4f05681bef0dd49a1863c884801361ae11c36d" + }, + "target": { + "epoch": "250633190", + "root": "0x8f133d94a0dd3db6a25b1224599f11d90862e87fabe3706a4fad181b1972fb04" + } + }, + "inclusion_delay": "10680062911639791936", + "proposer_index": "10685020365584811616" + }, + { + "aggregation_bits": "0x17c8c08ffca1f2b9e1af5184c443b66dcffc0f7e2a8891ccaedecf0c2e7cb67f292cfb63f0c53be7c5e7f4819ac503da26809a30b4ac47f55cf5f3af9f362811ab04a9cf693963a49414f83bfa7f2bbca3099173c23b0f502428d48485688f8c457556f1c7271ae09d307e2c256c76453b86c9adb7121c24db71ca0416753c297e464ab624041e202204ed31d246326db516581217a5aac7d826afa7cd88881f67c2c33b4fd68f1570ccaec6481cadd640618b5ea2ea66408a08e88b1b4553f21d957fa257a2e05ccc18c3a4ee8606db5ef251133941ed0fd00d3c814a95329c7d074496774cd96ec8d49de581fda68c46da3007ed068785e479a8565d67f86e01", + "data": { + "slot": "10673452978773055424", + "index": "10678410428423107808", + "beacon_block_root": "0xc9762b9480c0db84822448a6d4394f401b6be535ce3deb98d830e373a89421a5", + "source": { + "epoch": "241976340", + "root": "0x3b3d08944086172241b6b3aaca6eca0e407ddfa114f2dff5eb377825c6d96de5" + }, + "target": { + "epoch": "242361089", + "root": "0x15fb139400ef58985730e553225da1743477e17da7608e819035f1941118ffcf" + } + }, + "inclusion_delay": "10661885587666331936", + "proposer_index": "10660233108744615104" + }, + { + "aggregation_bits": "0xdba309c98ff30105c35c55133150cac74e60024126f5adfe48b14b3b46cb9b6da8bf7b5246e410cb8ae9f006e6429856d0f42f2741e90b6a140792f3756e63441508e083f6abb71f2678b3726a921b74cd6c5f403520b69115bc9c9bd1766e943ab6c6780da0f97739ab6c5611cda65283e6d270403c01d471a24f58762b6457edc23c9664d12cbdc9cf5936662d16af2d93c46ea4c521a8ccc56f94f396fe18fc6097c4750d0b32cac94534547fe025080a1547d2fefc02ec3870184bf53d1db71b101f46ff67ceda6d6b3e8386d3a5ed646612f6b5f818a380ac18dcb4633b474d3c11e235d04f0708bbdd317d42801bfc79e2b1de9cffbae309be67acac2901", + "data": { + "slot": "10708155143503291297", + "index": "10706502655991639873", + "beacon_block_root": "0x37c0a694618c8ade64a6cf167800a06d982bfa3bd9c6925317985906bea21644", + "source": { + "epoch": "246785701", + "root": "0xaa8683942152c67b23383b1b6d351b3cbd3df4a71f7b87b02a9feeb7dce76284" + }, + "target": { + "epoch": "245631454", + "root": "0x84448f94e1ba07f239b26cc4c623f2a1b137f683b2e9353cce9c67272826f46e" + } + }, + "inclusion_delay": "10703197689558271617", + "proposer_index": "10694935264884916384" + }, + { + "aggregation_bits": "0x9980facac0166e58230ac0570e48763ecd11f8ddab2fa67fa09e9973aeb4e1c7e73ee9c03b7b9483761df52c74e8138d91f66be2d24c465d7813b38ddfd689fb5abb97be7addeaa0462893a806e24c6375657d77a33dc1253e9c40a4ba5c31fb0020284a416216af435742c9171efcebe4e3640b31af2e0e2ba8857152a02a6b6ad8c5b2528c7b46592d8de5093ecb4c26a1517e2145caf55716b3fc7810b227456d8831e90ee6be11064ceb1b1c8b0b32b19f13cde85be1b6db87b5740684fccb437439e743c7a240a6773fa0f06ddcc3f0df2775a1f169117f20b30f4306aa567a3989628e7416f4b84692c00f5bcfd9262242cf06d96e16989762d162c6c301", + "data": { + "slot": "10696587752396567809", + "index": "10688325332018179872", + "beacon_block_root": "0x56b04e94c0fa9fe7c292dca1de04d471f558ebc98889f63bc6294ec28a4fd564", + "source": { + "epoch": "244669582", + "root": "0x306e5a948063e15dd80c0e4b37f3aad7e952eda51bf8a4c76a27c731d58d664f" + }, + "target": { + "epoch": "237359353", + "root": "0x06577b933f9d06973ffd61bca142b748d6c5c7512cc3b2693654cceb3fee9ee6" + } + }, + "inclusion_delay": "10632140876881115743", + "proposer_index": "10630488393664431615" + }, + { + "aggregation_bits": "0x130fc866501c49aae7694bb1b2106479ab47dff9828231f51481475d48658070dd6d44c8005ee9343a1760f12312661077e4ac249124cf18f62e4bd9b3ecad7cf77d50e0b22f5171350f8cc7fcad99d11bae0fe77e61427b40d69e6960eb96ab091e2ccc730ec9cd8b7b86ca3d728b5125be0f7494c15c8a67c5ae45fd2e377f73d6ae4e9dcddc1bae14db09934036fa232bd8679e2506c84e967e70708ae8c80dbd0466e6a8818e0f7221e60663a46a524d11e3498818315dfd440ce11610e28b47121fb17d21e8cb52294c73048ca29859816b69d1516b079d557c0d8011f336190462d6f48dab9ca0846bd1e1702f5c20f756d0752dde7e8183c3dcbd0f3401", + "data": { + "slot": "10625530944014379231", + "index": "10623878460797695103", + "beacon_block_root": "0x8b3e52939fae2179f3d134ec6a0047e402dbc04f2940d08076dca4653894a2b1", + "source": { + "epoch": "235627983", + "root": "0x65fc5d935f1763ef094c6695c3ee1d4af6d4c22bbcae7e0c1ada1dd583d2339c" + }, + "target": { + "epoch": "236012732", + "root": "0xd8c23a931edd9e8cc8ddd199b92399181be7bc97026373692de1b286a11780dc" + } + }, + "inclusion_delay": "10607353620040919230", + "proposer_index": "10612311069690971614" + }, + { + "aggregation_bits": "0xdd2d136e03cc26cd0a39c4c1cd008e9619f22c55cfe93e50e4e2a7d2a2531ed602e44098f847ed46f2c6e4c3933a4a0f38f6e8e43641076eabfaec3b8968430bab5505bd7e55403eee5f0db7901c4ed4f13c4dbc69946d5a2b65d2d7e348e4d607825ed472d12e10f5a38925a629d12b6cf1b15de55a560155ed4172a8b079953a8843ea2a10bd4c5eff2ddb46577d194c5a6c77fa29fd85dc1ba71c611c80d7b6985a862ea07d02d2932d32c3d931cef8469b2746a9fcfb4f16d784d4c7b551714fe39d18c2ab9d3a043c4c700e066aa46dba586ce3e811d520e592ae63f070254fb3c894cf04185a907186429bab6af3ba49c42d863b0bd3b10def5e93afdb01", + "data": { + "slot": "10653623171582911295", + "index": "10658580625527930976", + "beacon_block_root": "0xae03e593004c53bf01481fafbfa345dd668fd90d5aa6d452fe3e0dd7e51eba25", + "source": { + "epoch": "239667846", + "root": "0x20cac193bf118f5cc0d98ab3b5d8c0ab8ba1d379a05ac9af1046a28803640666" + }, + "target": { + "epoch": "240052595", + "root": "0xfa87cd937f7ad0d2d653bc5c0ec797117f9bd55534c9773bb5431bf84ea29750" + } + }, + "inclusion_delay": "10642055784771155103", + "proposer_index": "10640403301554470975" + }, + { + "aggregation_bits": "0x1342f260e90ad7722dc5e2464883387c4869a8294354077259d678a3c8e53741f33f6e2eca438643c9ede054dd4bf197ce6395e6d9265fb9d9128b71a30e050f9f350bb160edc0e3cb23de5c02215e16df68e187bee41e0bf8760ac83b73a85f4879da57dc23cda2c79d9eaea70804fcfc49e28bd31eebb5f77ac13c8c74032d4d4e11ce6dc58bf545fc9abc3cd05b067555e0230a637e2a49be2aab0d06d4d5290a4d63706c78234530428c5b3ba214012d27bba69be585673c663fbe6443355d4194a0491e16380efd95c74d82eb9507e50f6fa637655646dc41820953fdce5795ab530ff418d385c83f5e34ab4c7cba9a2591411d723fec818e8740c133c501", + "data": { + "slot": "10635445847609451295", + "index": "10633793360097799871", + "beacon_block_root": "0x806fa493df8bebb48a288f8cd78427adabb0ce5330469552f5cbf37147489b1b", + "source": { + "epoch": "238321225", + "root": "0x3c45a498a825c50eb623a096a000ab09581da600e95adacbfbca77e850ce72fb" + }, + "target": { + "epoch": "280258855", + "root": "0x1603b098688e0685cb9dd13ff9ee816f4c17a8dc7cc98857a0c8f0579b0c04e6" + } + }, + "inclusion_delay": "11000644797410433544", + "proposer_index": "10992382381327012904" + }, + { + "aggregation_bits": "0x0f853bf134b8389b7dc5689b511018e285b34eec630787e46a11c60815224bc5d1c7a6887e51853a49a8ebffcaf6e3486e79cd454ab5b5e7219242e13ae7e918253cb6d4743382b29e958bbf71aeedeb8ba0c66e4ea7bc353da8d1aa2202b527623882f2a255ff2d8e9cabc96a2d771ab17df5e780e6fdcc3e931518499855e6ca13316736b97bcef3f6edb140698e8ae159a9a6e99c3a8d305f775919adad36b1b8a595b03426bb7af1b0c71b73c1da17552645334dc046502683eea7b6e1af57c57cbd089469b25a96e552865bda4ba669a43ec1b1e94d6801626f135bd70dd659cf3638abb8a83fb903967afbe030c86fa830866470278e64bf6fce92783c01", + "data": { + "slot": "10994034860248729736", + "index": "10985772444165309096", + "beacon_block_root": "0xe86e6f9848ce9e7a557e411d11d0633f91389d22526949579755d7f2fe35e5db", + "source": { + "epoch": "279296983", + "root": "0xc22c7b980837e0f06af872c66abe3aa584329ffee5d7f7e23c535062497476c6" + }, + "target": { + "epoch": "278142736", + "root": "0x34f35798c7fc1b8e2a8adeca60f3b573aa44996a2b8cec3f4e5ae51367b9c206" + } + }, + "inclusion_delay": "10982467473436973544", + "proposer_index": "10980814990220289416" + }, + { + "aggregation_bits": "0xa120cbae17f6ab52f7caa7749cfdf096871efe82416bf71db59a268f60b2e9ef3de614afd2440810d9497d1db90815fafde69f792c455eef2c5d34a8bb18d65cf3456b85b7442b996e44a5163d78726accd14bff093a272cb291218045c07e7680813b76f4074fe888bd6afc089d3fc462f41d4788974887d1367c21ac7426fa3bf5233b21c259584b24add21f81a931ad669dc61c032a6cded45edeb16e3fe0d9e785a8e179a661b86523cdfcfaf2343392202209f36b4d0eeac51f1c39eec8e32c63afc801e125e520b8d5b7fa7e955b085ee15ab9f0755dbff742d619fb2edfea6b681983371842474a7b9ee0eddfdacc6b2aecfb5f5a2a5ab3beba5b51d801", + "data": { + "slot": "11028737024978965609", + "index": "11027084541762281481", + "beacon_block_root": "0x57b8ea98289a4dd43700c98db596b46c0df9b1285df2f011d6bc4d851444da7a", + "source": { + "epoch": "282567349", + "root": "0x3176f698e9028f4a4c7afa360e858bd201f3b304f0609f9d7bbac6f45f826b65" + }, + "target": { + "epoch": "282952098", + "root": "0xa33cd398a8c8cae70c0c663b03ba06a12605ae70361594fa8dc15ba67dc7b7a5" + } + }, + "inclusion_delay": "11010559701005505608", + "proposer_index": "11015517154950525288" + }, + { + "aggregation_bits": "0xff7cb1c00e8af5d5cdaa7f8470c516c45c84d2e20c83b78b9ebba8cc88e5ccc47b0785a34a150e925674b987cd841a4ca5d158c4e9ee64c87e22332ec1f6c28b737d1b543e192e9e47d35dee72a87f58a494f72aa9eef6a5cb145e0499770a894cd658c294d2c2689336d05aa4d54a42b9be54e8526b483444c4fcb01b3161937d3acd3dcca52b19d787dfb2694708852c82fc19f6aa11db07d47c190bb6ccca9231746d9f05d0b144a2e1a956cda6b40801baeef36bcc7792a58453005c63ca668b6616b4f0e097838a2ada4f8371c5a302860ef62919b204444e1a1b461510c69f4d20a1b0524d86a30a9ed88470c9bd2108520e9804680f0d407c56d820c801", + "data": { + "slot": "11003949768138769096", + "index": "11008907222083788776", + "beacon_block_root": "0xdd9fc19888ab68b6ecd49bbd7e544408390eab26596f0e29174526ff0ceadd45", + "source": { + "epoch": "274295247", + "root": "0xb288e29747e58def52c5ef2ee8a35079278185d26a3a1ccbe2712bb9774a16dd" + }, + "target": { + "epoch": "274679996", + "root": "0x8c46ee97074ecf65683f21d8419227df1a7b87aefea8ca56866fa428c288a7c7" + } + }, + "inclusion_delay": "10939502892623317031", + "proposer_index": "10937850409406632902" + }, + { + "aggregation_bits": "0x95c3549b318741f8ea03a3ef23024096e31c1a2f8b65a7c9c25d62d873795b48afa61966844b97f5367c2bae47619813b3bdbf317a46ae4888796a7c0e3ded6290c23edd6623a8871f88ef0b61f58fc6308507bc03d2715a9f3b9d44ffe32c0cacc121cf37140425d99a56387872c21ffff3b23b0b74177ac07779d1b05f2c904d8f660997b499edffb4ec9421879bc2fc243e48465b8da617cfb608ea7d5b80ddf1605ad166b4207cc496e5361ceb672dfd5eded9ae7ea69857ab48c9c9e3bea856d426e3c0bc1e51409ba9710a59d84a6474d6356173bf3eb08b563c4d74689e87cdc53135ed7f46de581182ed77806fd4e36966b3f2540409d4ae5b049f8a01", + "data": { + "slot": "10932892955461613222", + "index": "10931240472244929094", + "beacon_block_root": "0x122ec597665fea471d14f4070a50b77a469080acfa25e86dc7f77ca2bb2eab92", + "source": { + "epoch": "272948626", + "root": "0x85f4a197262526e5dca55f0c008532496ba27a1840dadccad9fe1154d973f7d2" + }, + "target": { + "epoch": "271794380", + "root": "0x5eb2ad97e68d675bf11f91b5597309af5f9c7cf4d3488b567efc8ac324b288bd" + } + }, + "inclusion_delay": "10927935501516593542", + "proposer_index": "10972552574136868775" + }, + { + "aggregation_bits": "0xf7e5e91d52e392cf024bbbcad683c9594339ad03160eac68087474b69a1fe7fce6270d64963213f777cd3badf563828840af74fc68c3303fe4ed4b43edb3c45105625f84767db42944dc72d30f8541c1b896458b95a3d43ff088c77b0843eef1d487c3d736d58fddd20619e7ab41d0e47eba8c507bce35abb01bf2eeb7e546ba59d71c2f382b7ab21f5f2a47de34c281b1b58c60075364c7a4627774e16f27bd6ed33e3685435bafad0b8f3ff1f7d84b15779498d6b8c041c2bcb8c1fc380795cf9ab88087549c63ab061ba4489cd673dce04d01b511eec3886c9bfacfc4576a8fd1587da30e70849468ed3df897fed56c0659bb1e6bc6a0d009da56c9efbdf001", + "data": { + "slot": "10974205057353552903", + "index": "10965942636975164967", + "beacon_block_root": "0xcdfb2898c75916b5d4a11826fd395adcdc5c91faded13211bd6301563ac07d5c", + "source": { + "epoch": "276988490", + "root": "0xa7b9349887c2572be91b4acf55283142cf5693d67240e19c61617ac585fe0e47" + }, + "target": { + "epoch": "275834243", + "root": "0x1a801198478893c8a9adb5d34b5dac10f5688d42b8f4d5f974680f77a4435b87" + } + }, + "inclusion_delay": "10962637666246829415", + "proposer_index": "10960985183030145287" + }, + { + "aggregation_bits": "0xf739b76b82944ec783bc37d92abd449970370e0a8d41572a77e46058eeb6f9600f02224cba8c3c7028802bd664296996e08d2aa0c0442f2475710a52fd1e4ffaf6b73f7e6ced3288e2a39c526ae97c750599ec9e16df39ca8de31ce91dee9178018e73d720d219e0c5b044b134caf847812263155afbaa07ba2e90e5dce248c95a2cd2876584e9225b97dddd6889d4c35cb35f2a7fef74b4b13e65c5fae41c3dfe5ab117fe67fe87531dce8b32ebce59828da0651d69e226f710a9d8ca1fa3d39201eb5b7aa6604bc4dc4812b2d1f2e7256454da267b8b5657f223aa74566614ee41759dc9fcc48cffe4511a0621e668c5ff4199228a2e13a524831d873ed58801", + "data": { + "slot": "10956027733380092903", + "index": "10954375250163408775", + "beacon_block_root": "0x038a2c97a50d984605e170708935cd4ee8de66807f880c566d1658f9e8044ba9", + "source": { + "epoch": "267946891", + "root": "0xdc4738976576d9bc1a5ba219e123a4b4dcd8685c12f7bae11114d1683443dc93" + }, + "target": { + "epoch": "268331639", + "root": "0x4f0e1597253c155ad9ec0d1ed7581f8301eb62c858abaf3e241b661a528828d4" + } + }, + "inclusion_delay": "10884970920702937029", + "proposer_index": "10889928374647956709" + }, + { + "aggregation_bits": "0x8d94ef3ade27465fd2c93f210d6241435e3ce478cb3f32fea4bbb437f09b24d38a9204f073bc60f15dae7feb5c9d50804229db7d7f214afbcfbb8299a9c476c646df52ce2c9d80ed3b618f940081210d98aa04e8ed02471df53d4724cad8aeca739c7bec0eafa9d262e92b09b14558481fab12b9104d27e69d833899618cf88f5f83d68278661f8fff112cc4793c29af9549a6c0ae88927d98c12c4c4e29b7e97dd88089c4a9aa8d878d1050568db6f2129970c29c10cd0da318cff6f14cd54a1095a3f70a9a169ca3660aedff9931740e30cc4c8c3331a27f10d7a36c2c4cecf0e77c333c15d6b194032a3802aec83ba1f5263bff65c9110dfd70f14aa7e1d601", + "data": { + "slot": "10878360983541233221", + "index": "10883318437486252901", + "beacon_block_root": "0x88710397051fb328b9b543a052f35cea14f45f7e7b052a6dad9e3073e1aa4e74", + "source": { + "epoch": "265830772", + "root": "0xfb37e096c5e4eec57947afa44828d8b83a065aeac1b91ecac0a5c524ffef9ab4" + }, + "target": { + "epoch": "266215521", + "root": "0xd5f5eb96854d303c8ec1e04da016af1e2d005cc65528cd5564a33e944b2e2c9f" + } + }, + "inclusion_delay": "10919673085433172902", + "proposer_index": "10918020602216488774" + }, + { + "aggregation_bits": "0x7faaafa75effb09d1558549aa0dbda64640239a7c605075dd1297166fc4db3f0f022aa8f67fb41358035b9fc4ce05152dd6a02d8eeabebdf67ecf3bd732dc278908a5f833b63fefae1de36628bc5c3ac0bf19a7a087a19d03c7a83048dee76869e5e70ea82fc65d10585e58abf3668d120348a693816fd1fce6f948f4a1c6eec6c036b31fd2a3889934f2e1cdfd2d6e7c5c05a1daaf7ca6823d8f2b3056d730c1aaa37ecd4036531da3d015cb19ddd4f0cbace0139cbce69153f0377265ba5b41b2811597de17df785dd6549bfae1178f2e79db525d7ffe04d8752472bd2fe25cebf3ac3ef642459441684a2052bab66d7be9a44167c2c51da61d3bf3863e8af01", + "data": { + "slot": "10913063148271469094", + "index": "10911410665054784966", + "beacon_block_root": "0xf7ba7e97e6ea61829b37cb10f6b9ad1791b47484868ed127ec05a705f7b84313", + "source": { + "epoch": "270640133", + "root": "0x6a815b97a6b09d1f5bc93615ecee28e6b6c66ef0cc42c684ff0c3cb715fe8f53" + }, + "target": { + "epoch": "269485886", + "root": "0x443f67976619df95704368be44ddff4baac070cc60b17410a30ab526613c213e" + } + }, + "inclusion_delay": "10908105698621416710", + "proposer_index": "10899843278243028774" + }, + { + "aggregation_bits": "0x2bfcc5d86481483a1e74b6f35df293d2ad5157931bad94d3ef60726184bbb77354cba2157ff20f97cf44ef44aa60c4cac7ced22eb291d032ad8ff43b39af97a715372b5fadfb99fdca79dc977414d6defbdfe0a20d87b869c7b9f38c504d013e24c1a9d3ea2ac9ffbc0f13688737b7a6df46bb46d1b2d78c217e274fb65b6fcd2b0b69490c6f5aed0cd96c30b655faf35c77af8c216bf81fdfac5307bbb58591db6ecf23aa13936967bf61ac1ba886a7208954cbd832488af849a6d08a3e2c8ed79729f834013d41ef98f74dc4bf4a0311ac461a013b07949620cb974c3e8cc1de7a51aa710741d9886bd399415ed17437659758df05b6bbdebc58fdc6a289af01", + "data": { + "slot": "10901495761459712902", + "index": "10840353856672596388", + "beacon_block_root": "0x79cd6a9644cd6027a182c008d0d872beb642465200684e5553bd0bca0f81ee8a", + "source": { + "epoch": "262368032", + "root": "0x538b76960436a29db7fcf1b129c74924aa3c482e94d6fce0f8ba84395abf7f75" + }, + "target": { + "epoch": "261213785", + "root": "0xc5515396c4fbdd3a768e5db61ffcc4f2cf4e429ada8af13d0ac219eb7804ccb5" + } + }, + "inclusion_delay": "10837048890239228132", + "proposer_index": "10835396402727576708" + }, + { + "aggregation_bits": "0x91d3e5d4775bff88aec3b564ef0812b4590734bd2b4493d37dff1867c6c8b0e42897a11f89b7722cb35a6c3af51aab7f11ddbb4958d9321f4792bd6db794f334fb37eac97b08d369ff70cf2b84d21161084199bac9cf1a36ae9a0b490ab9277faf77cbd5ba8eb296752fdf6ba333a45d033374301081e53073231cf8b2ddf1941a9d81f6d72fecb4fb20aab66842336bc97d4b2c8d893502ae6afd9bb3bf1b7d19af20522dcdb412d0331e821785bf9a08154a4976c25768ea9cf75d1b7e8ef2e4944b36c407d64cc4aca91790dbb23f42061c1431fba5d48da25acac63fdf1cbe996c83f55d9264a13a7124d8d29fda926f656cdba7aa428798e9548b5b95e801", + "data": { + "slot": "10830438953077524324", + "index": "10828786465565872900", + "beacon_block_root": "0x4b392a96240df91c2b6330e6e8b9548efb633b98d6070f554b4af26471aacf80", + "source": { + "epoch": "259482415", + "root": "0x25f73596e4753a9340dd618f41a82bf4ef5d3d746976bde0ef476bd4bce8606b" + }, + "target": { + "epoch": "259867164", + "root": "0x349bce96a5c78c945810e526c3c215204c0f57a0e51399f84929907d8e12c154" + } + }, + "inclusion_delay": "10865141113512792901", + "proposer_index": "10870098567457812581" + }, + { + "aggregation_bits": "0x77f136dca1ea90b94b93b8788e18bb784136ce11f4cbc8f0bfd64ace4ef70d6af1069f053b8ef65e6f8b7fa96e3235a17cde59857b588e282b06ab19dd04599b76dbbab4bb375752e12046f8eaa2c26c62de990956ae2c87821b317ad0197441b12bebc7b30ccd760ff3d8d43091dee6687c6a402b4beb813b0bd2cf4f1bbfe15f07bb7270709cef5bcafc442770e48886add2081904d43f1cb745f782f91571a8b35f56f5cc19c71456077cc86e04f4b6fed11f79f5edba20acf4c124f521418f88af88c59175617ef6b416301931c5f491a165b2833cec5f770fb6379aba0dacefdb29efc618df1642e40a80ca549b51b1efeea72c15d61a9377680dd1b7e201", + "data": { + "slot": "10858531180646056389", + "index": "10863488630296108773", + "beacon_block_root": "0x6dfebc9685aa2a6338d91aa93e5d53875f185456086e1327d2ac5ad61e35e7f4", + "source": { + "epoch": "263522278", + "root": "0xe0c4999644706600f76a86ad3392ce55852a4ec24e220884e5b3ef873c7a3335" + }, + "target": { + "epoch": "263907027", + "root": "0xba82a59604d9a7760de5b7568c80a5bb7824509ee190b60f89b168f787b8c41f" + } + }, + "inclusion_delay": "10846963789539332900", + "proposer_index": "10845311306322648772" + }, + { + "aggregation_bits": "0x3bb6cff0eb9d734869e69cff0b8bcfc3cbab636fbbe6b442562fc7b1e2e9a37d468f15fb87aadd4962b868bd53873a20820ae40a82bf50770b8c8d6737731ad610ff927875e882eb2550cca074df54a34eb63d3281c97746400e9f4191879859ea9839ce5d2b22d1a3cac38f15602ab3c1cc9d9f566a5e1f89985b067f8ac6df2c934ef2b12fa95292c92f42b7b9aab61e025670aa6755a04d0ea8500e232363b3114a5101511d833201fc8a568dad72fb956d462bc0e6c81ecdce72116d6e2f2104c0a9bc56e9b90443158c4adf8d28df9296b2751bb9ff45d3c2a3832823a4ff040336701d151cd9729a13b5ea80c10c8d168bfbe7f4ac0409d6081706efd501", + "data": { + "slot": "9518366703504708996", + "index": "9516714220288024867", + "beacon_block_root": "0xefc52384443e8f921bf83b29acd360372bad32d9b04747e6d1e83444ee08d767", + "source": { + "epoch": "108276097", + "root": "0x628c00840304cb2fda89a72da208dc0550bf2c45f6fb3b43e4efc9f50d4e23a8" + }, + "target": { + "epoch": "107121850", + "root": "0x3c4a0c84c36c0ca6f003d9d6fbf6b26b44b92e218a6aeace88ed4265588cb492" + } + }, + "inclusion_delay": "9513409249559689315", + "proposer_index": "9505146829181301379" + }, + { + "aggregation_bits": "0xefb1ba29bab480520fbd35b1741b9c8cb3d396dcc49fd78b6153eecfffd3c1ff8b3eb073c2e77c111ef8df734ae6030f275d4da81fafb1ff6d7eae6a6f7b8fc5646a2265bca4dc7d5e09b0114ed12ed3216edbcfad832319a383fde365389fa70ea447b928e7e5ce1dbad90cf46d2accf3ab7ddcf5827226851caa0d5c333c1402a40e1d4d7657b3ee20faa00b263b9095fede94516bc2cb75182b008f4ecb425cc18d99e568ec4d40fd6d8cf8d0c3f3fe6e1b9361b8fed373c852a4cbe65c3d6a418e942304f545c08a9cd8928c5b3c316df8aa75b4511735ebd677e06f07b20a5e1b9518b983f82395cbcc66abb6c8a4ffa21b561d553d750b8536cd09f94901", + "data": { + "slot": "9506799312397985507", + "index": "9498536896314564867", + "beacon_block_root": "0x0eb6cb83a3aca49b79e448b413d8943b89da2367600aabce807a2900bab59588", + "source": { + "epoch": "106159978", + "root": "0xe873d7836315e6118f5e7a5d6cc66ba17cd42543f378595a2478a26f05f42673" + }, + "target": { + "epoch": "111161714", + "root": "0xf717708424673813a791fdf4ede055cdda853f6f6e1635727e59c718d81d875c" + } + }, + "inclusion_delay": "9548111414289925188", + "proposer_index": "9546458926778273764" + }, + { + "aggregation_bits": "0x95720bf421e83b5b2f7fe34a93d664bcd99176b2f6c1d6352e5daac1cd5026474696a855046fb1ffd63909912058f58cce8f598675571bfa7539dae3df1c9d01aad21904a4c24523e8ce9c2d3e5ffd92271d60c6593b98040c7ac4eb242e15b2c819b8352ff4546a9d319ded9ccc3b0a167dd550edca458ceebf52354c9f6faa16033c00283d653776f6cf07070a5a0f6d950afde02e73baabf2025f85cf296621da1f45f57d788b4348d8050e2eb11d64a49f22702876d8b4075ce5f568785fdb3ac45eea1179177f6d3bdcefcf420a4e0c084416cc40a980016ed81da537ad627f8fff3b919c49546f81288bb28507a01c751ba3362f0895b1a3a7b9e0ba9e01", + "data": { + "slot": "9541501477128221380", + "index": "9539848989616569956", + "beacon_block_root": "0x7dff4684847853f55b66d024b79ee568069b386d6a935289bfe19f92d0c38a27", + "source": { + "epoch": "109430344", + "root": "0x57bd528444e1946b71e001ce0f8dbccef9943a49fe01011563df18021b021c12" + }, + "target": { + "epoch": "109815093", + "root": "0xc9832f8404a7d00830726dd205c2379d1fa734b544b6f57176e6adb33a476852" + } + }, + "inclusion_delay": "9523324153154761380", + "proposer_index": "9528281607099781060" + }, + { + "aggregation_bits": "0xe7dc5396795cf8d012aa79b7f54930aa57f41660a97e63813523f2adf7ff63e7e6e68fe9875c4d6f9e9749be2cbcf811d65fa6cbdb32f315cbf3db1e1be465319e8a1066ea201f527e55abeffc76a2f2b02e8220a6e2a663e6e03f3270046b98f90fb80e03c48459a863f29328e71fac51f3a1348d7b0b2de948789935b34f30173eea45f5cac791c9305996162fada2bf6561066b0bc5d3b65b33d2b95219faba1ccc3be607a1f195c24ed400189db6f08ddf86f05a5ae16aa966b0ef2f5b8634578af6e49d9d6154c4dda34276a09b317044d53620ea7d84b4ae5321eb753c7dc911058e4adafeb5a8fc52a67f6b4c85bb0ba9da74624821685a1b7638c24201", + "data": { + "slot": "9463834731584328994", + "index": "9468792185529348674", + "beacon_block_root": "0x66096283e2fd5773b7998bc1f47606a7f91012ab322789e5b88fe81415857a49", + "source": { + "epoch": "101158242", + "root": "0xd8cf3e83a2c39310772bf7c5eaab81751f230c1778db7d42ca967dc633cac689" + }, + "target": { + "epoch": "101542991", + "root": "0xb28d4a83622cd5868ca5286f439a58db121d0ef30b4a2cce6f94f6357e085874" + } + }, + "inclusion_delay": "9452267344772572802", + "proposer_index": "9450614861555888674" + }, + { + "aggregation_bits": "0xa3ff90d1978819683267dff00249ce90b4e3023d14c77f027e1eea8ad9c1d578153f179c336e2e4a6b1c4caae36562d132452bdc3467e81ad93ddd3ee3a32335c1840a2ff4fbc6efda29f0a61a1895ae8a2b4e1b51d3ec362471f30da41f0692c2fd7cad0de667a38a7061ed6c42c6dba3275a607d151ab17bdef64499a0274e413a2825b417b4896237ae413a466beca2eded3afa6c647c63fae6755e4c1ff4258fd8e6943bc4d19783c22eb57bca6fc9e7611e892e70b3306adf07819cd569145b66f7ad9235a5ae5de8322dfe1f771f6b3972f93cf77ad7483e42a6792cb70302212a0033c70d63fea128d3b7837a9c0561d8b2ff5f2ad9e2de3f6cff8e1501", + "data": { + "slot": "9445657407610868994", + "index": "9444004924394184866", + "beacon_block_root": "0x38752183c23df068417afb9e0c58e8763e3207f108c749e5af1ccfaf77ae5b3f", + "source": { + "epoch": "99811621", + "root": "0x4719ba83838f426a59ad7e368e72d2a29be3201d836425fd09fef35849d8bb28" + }, + "target": { + "epoch": "104813357", + "root": "0x21d7c58343f883e06e27b0dfe660a9088fdd22f916d3d388aefb6cc895164d13" + } + }, + "inclusion_delay": "9493579442369545187", + "proposer_index": "9485317026286124547" + }, + { + "aggregation_bits": "0x47b46b44c5597f17d225e8e494d865ffacea2231a9be35053e7fa8f313ef6966c996ad068251a88828fc4d8142c16ace79597d18d7d365aca0ebe7995b8f8eca4c660a072df4ce408079e96c27aa46b9d25a6c10c6a64b934e41ab924f3c052cfc774e108d64803ef484ce7633b19c620808461b4a96380219d76d6be74e79ca3120454503dad2dfa2df7832dd56653f6d1afa5abfe41521e1636f9d57de71cb95a2b73660991144ca647efc831991c3e30dbbca8459cf34faf84e9b94dd2a06e3171a790c04a699141a64b21e4009aca8ac9a81780656084df602ed65f8cb271a46afda8b484f162bc44666e14c32bf171edbeade30b9bb62416007ea74fefb01", + "data": { + "slot": "9486969509502808675", + "index": "9478707084829453443", + "beacon_block_root": "0xf342858323381cd6f80720bdfe418bd8d4fe173fec729488a5885363f73f2e09", + "source": { + "epoch": "103851485", + "root": "0xcd009183e3a05d4c0e8251665730623ec7f8191b7fe142144a86ccd2427ebff3" + }, + "target": { + "epoch": "102697238", + "root": "0x40c76d83a26699e9cd13bd6a4d65dd0ced0a1487c59537715c8d618460c30b34" + } + }, + "inclusion_delay": "9475402118396085186", + "proposer_index": "9473749635179401058" + }, + { + "aggregation_bits": "0xef91307e7d4180f3443ce1eb866326b95886468c311543842e6cf665d1ac7761f0c328077754d7abe94b5e4f8132336f8b5ff8dff99f00dfcaf2e78c373661492360984eb077a652d378ee53a4a7e4cf31630f97817a69cc29037b4fd5c9f0f135d50b173ded5fd43e8c4c7d9ab5a9881d7d87c5af68ca0ec5ba165ca2e0f646148aaefb1edf71a355603cfc4f61fdb1e850d13b408cf01cb8e372054a40292cd472cb412fc73f7dc077e1f64f62b5dffbb4450e1a69c482a98b1f122359dcbce83402154e035d1b1f1eab499d7462b8ff369c8d46d67f9b5315f7622ffd5e7172b383f896369e0d01d5859e7442b5bdb68040765043e019974cd1aaa5acb70d01", + "data": { + "slot": "9415912696825652801", + "index": "9414260213608968673", + "beacon_block_root": "0x28d1888201ec9d67294778078a3dfe4ae080edc48d296ecd553baa06a584fb55", + "source": { + "epoch": "94809886", + "root": "0x028f9482c154dfdd3fc1a9b0e32bd5b0d47aefa020981c59fa382376f0c28c40" + }, + "target": { + "epoch": "95194634", + "root": "0x75557182811a1b7bfe5215b5d960507ff98ce90c664c11b60c40b8270e08d980" + } + }, + "inclusion_delay": "9397735372852192801", + "proposer_index": "9402692826797212481" + }, + { + "aggregation_bits": "0xabc5abe7e83eba454a8e201aa001cfafa3cdec0a649d83931051d472e9eb7be2d40a2a1eaf1bd98b22bedaf7d5afb03293318a2121350ffa82d5ed5b5d9a389723d9e51db43bafdff67190a919eef4f5512e15492007f837ca3022af19728553d908e1a9941cc255cb0ef89c07b46cae682fba4a678768ad0328910c1c27b5435737a9e3b18c72f6e6367e9063b659d161a640fa0acfda2fccd53081f29ef11f97a7b095d1d7b8237ce2c18be549b3d2e6b15fd4aec8d3b8415f1a3799b9519d3c3b83a6164a1d27753a3b4e234f3ceb181d20e06262c57c9cfc3ab3871089972c2698901c14ebe3f921c6610ef41c2b5a6c200a003b02aaba1372ea595cf21901", + "data": { + "slot": "9391125435690488992", + "index": "9396082889635508673", + "beacon_block_root": "0xaeb85f8260fdb849de1b4b3754fb8de60c96e6c289a68be496c382809e2aff20", + "source": { + "epoch": "98849749", + "root": "0xbe5cf882224f0b4bf64ececed51578126a4700ef044467fcf0a4a72970545f0a" + }, + "target": { + "epoch": "99234498", + "root": "0x971a0483e2b74cc10bc9ff772e044f785d4102cb97b2158894a22099bb92f0f4" + } + }, + "inclusion_delay": "9432437537582428673", + "proposer_index": "9430785054365744545" + }, + { + "aggregation_bits": "0x4bfc6a7c48e7849c8d8241b9a6f0feaafa49d3d7e1e5175455234132f5ac7dc8bfd39ae87b49baca15005df9aafa22302cba1b0cf73dac5b3e94d6e62751982dc998a20be7e5b15420600dc8727bd2c4711fe7c7cb5d96bc01b7ef4fce551c01302a7d0d9844576be24b5a9fa9c76767749028f2e847f224f5f3192b26dfe194229e295dbc9715c4aeac7d0cd0183549372bd97716e0b23e77c226cab2cc1578f0c5a2eb815fbfde3551c18e42589b3e398563436d4bf1f49758be301c0a212737a693a0a6f36a45f3c13642e3700b8fe0a25229899ee72c1a65e3516aeeb25e533aff70c7f68b5d5abd6dfb106ac90e386612337a739bc220aceea6299a89e101", + "data": { + "slot": "9425827600420724865", + "index": "9424175117204040737", + "beacon_block_root": "0x1d02db8241c967a3c09dd2a7f8c1de138956fbc8942f339fd42af912b438f4bf", + "source": { + "epoch": "97503128", + "root": "0x90c8b782018fa3407f2f3eacedf659e2ae68f534dae327fce7318ec4d27d4000" + }, + "target": { + "epoch": "96348881", + "root": "0x6986c382c1f7e4b695a96f5546e53048a262f7106d52d6878c2f07341dbcd1ea" + } + }, + "inclusion_delay": "9420870150770672481", + "proposer_index": "9359728241688588672" + }, + { + "aggregation_bits": "0x3114060f3454c51e816ee875c86f3b32b4ec5a072fdfb6f9166cd45c6b8538723fb6aee4b36ac6cc05a4199dc9582ca6b402eec549584b2d10424e2ff7892205f1cdab653901a931f9aa3256b87a0b8dcea243a55a82e9ebeb689d1a186ea2af22f8761cb77fef48679bb5842d0cc46c2319119a0cf237b7fa52a1578971c3562199585125322645407c8f51343dc2d5ecd1209d5fd7049e6e731fef0e5132b0e243063fdb316691411b4f51647fa3a1d9c571aeed23f74ee354200c6f5c14fab502ff3590670093373600756e93c95dcbde8fc5391a390816c7135ed698b2ae642c05cd36ad8929f3daa6d83fb5a2444acbdf8720c1d4826151ba09e680eb6f01", + "data": { + "slot": "9361380724905272800", + "index": "9353118308821852159", + "beacon_block_root": "0x9f14c7819fab6648c6e8c79fd2e0a3baafe4cc960e09b0cc3ce25dd7cb009f37", + "source": { + "epoch": "89231026", + "root": "0x79d2d2816014a8bedb62f9482bcf7a20a2dece72a1775e58e0dfd646173f3022" + }, + "target": { + "epoch": "88076780", + "root": "0xeb98af811fdae35b9bf4644d2104f6eec8f0c8dee72b53b5f3e66bf835847c62" + } + }, + "inclusion_delay": "9349813338093516607", + "proposer_index": "9348160854876832479" + }, + { + "aggregation_bits": "0xa58d441fec134306d449cc06d61314baa6649c8dacf6abbae95e50b38f982bec406f95f07f81cb435e4a58ae2c0a40b906347e0401ef1617977659776308bdebb605cd11abc58f8b7f5cf4055f1f5650f2af849d8cda651814f36651c8d13cbe855342b4e03c11405cc56e7eb58381bb7523bcb32554e81bd1ced1c4c7769475766bce89f8c9c08962727c87674044851191f956214f6e45cb6d69b601ec51a8e3d6b55e228566fd2a5fcee9ecb2b9a3ee2de7dd467b3cddd2f9131591fef12458186aff9f9548bb5ae85a8dd85dfec8d302728454be1d964849eb8e890382d32358880ccd4fad148c1a8a7f9d83ab98e5b3cf91a87c94543872f10f08c0957f01", + "data": { + "slot": "9343203400931812799", + "index": "9341550917715128671", + "beacon_block_root": "0x0e5e4282807715a2a86a4f1076a7f4e72ba5e19c199257877a49d469e20e94d6", + "source": { + "epoch": "92501392", + "root": "0xe71b4e8240e05618bde480b9cf95cb4d1f9fe378ac0006131f474dd92d4d25c1" + }, + "target": { + "epoch": "92886141", + "root": "0x5ae22a8200a692b57d76ecbdc4ca461c44b1dde4f2b4fa6f324ee28a4b927101" + } + }, + "inclusion_delay": "9377905565662048672", + "proposer_index": "9382863019607068352" + }, + { + "aggregation_bits": "0x43a4379fbdc70831b10dff57e113bf1675e7666189db201ea159c28c664e97129ee603fac7bc4d6138fb49e5dca2fce25d2e59c0a042de216fc22ec140e8038eafac8c5d21fb11202c886d47f30d9955c29aa6b4bdcb93e93d509ce6d1321fc09fd1a40c2dbaf69d02194485a4f0db003c4880dbd43fe2c886c746cae3ccf49db6b0a02ffe04f5d2629dad5071d3137a1c42453ea56dad4c58a8958e1a5a7987508aea38f020c2b2f71c86372bc1c28f46de6c19492fca6f8893038a88279697a7000d790b23c8d7a1aad72c6bcf42d3e4d4c7d13ec0c4229a8de3205aa766723c620f8ecfd5238fd9604f5219113fdb668175d1c035e405e55957331e08ffbd01", + "data": { + "slot": "9371295632795312160", + "index": "9376253082445364544", + "beacon_block_root": "0x93451982e08830845c3f22403f65848357bada9a150f759ebbd1ace3dab497a1", + "source": { + "epoch": "90385273", + "root": "0x060cf681a04e6c211cd18d44359aff517dccd4065bc369fbcdd84195f8f9e3e1" + }, + "target": { + "epoch": "90770022", + "root": "0xe0c9018260b7ad97314bbfed8e88d6b770c6d6e2ee31188772d6ba04443875cc" + } + }, + "inclusion_delay": "9729884645434590601", + "proposer_index": "9728232162217906473" + }, + { + "aggregation_bits": "0xe59fcf07a01c0a977bce29ee91b0444216cc439aa9d277ecd6a55d4bed62c1cb1020f7b6abc8f96e6a05d903b2cbe396531e9dce07d85789579526d887e4f6528c5f836df55fda4679d99c9f05f623105afa95c67fddf3e576c762ca0a83584250da97167b711e996b483e9ff5fdaad63f6e380a201d017666c8a847edb59cd928f5f62a46e0185d25601871dd5e222d365f450cbafdcb6649ba2a6dc6139a612c288f7d58243bd38ac61ae67f5cd13780014a86a47ce05761b060979fa20ec20231e92e0a358c63a3dc8ceedd72b788213b69302a0675ec2e18298cd6323bf8da29815ad9f3f019eb2e0de5c34fe670292dd84963841891ab90860b31d8173401", + "data": { + "slot": "9723274708272886793", + "index": "9721622225056202665", + "beacon_block_root": "0xafc0fb86c99c6636528937232a8d6ee12436ad215e0f86baa6568243281f0437", + "source": { + "epoch": "132130529", + "root": "0x2287d8868862a2d3111ba32720c2e9af4a48a78da4c37a17b95d17f546645077" + }, + "target": { + "epoch": "130976282", + "root": "0xfb44e48648cbe3492795d4d079b0c0153d42a969373229a35d5b906491a2e161" + } + }, + "inclusion_delay": "9718317258622834408", + "proposer_index": "9710054838244446472" + }, + { + "aggregation_bits": "0xf14927b89a33142157d54b0668072d66e1977d986d3875a31ead9356c91bc0402cc1772e00cea71fa5b45db90dce54a10fe85c619fb26ab1bca2007efb02bf8c69e7ab2439099f515472e24fde2f2b22ba942f16eaa8725e13dc230bc6280df0fac14e2a310da7aaf1a28c7d42f467e1c2a00203e1d30984a9db10844beaf9f46b7bc0a4139d7b18bf155b3df60ff619ada9a0dfd0757041f5ace8e96ccb74d4c7faccab241cc98d37485a8af5454cdfa9069c6e1ee0f78aaff155f33146c241a60ad49d445e0edded785c33a542adb0e830d1ddafda80ba27f4245de7947cac82fff3b063508c3f2fce4e46a5e8196175d093b53ff7dbaba88d6589dc49643701", + "data": { + "slot": "9711707321461130600", + "index": "9756324389786438537", + "beacon_block_root": "0x6a8e5f87299792a309175c411d771143ba02be6f42bbd05d9cc206f7a7b0d600", + "source": { + "epoch": "136170392", + "root": "0x444c6b87e9ffd3191f918dea7565e8a8adfcbf4bd5297fe940c07f66f2ee67eb" + }, + "target": { + "epoch": "135016146", + "root": "0xb7124887a9c50fb7de22f9ee6b9a6377d30ebab71bde734653c714181134b42b" + } + }, + "inclusion_delay": "9753019419058102985", + "proposer_index": "9751366940136386153" + }, + { + "aggregation_bits": "0x1f25a77781ef0bac41fbbde8d0edd056c9cfacf40f52e50341234199e78c66bba2e657008d8ea0ef577d0b7bf610321388362a4bbcde86f4e025465479d1c6dbe21a86e5e9edf76b0ea3cb824ee1f58b3ee6fdd5eb14d16ff4b67327edde2d673c70452de234172df6c2ce042a0d312e6b68aa013992bc0e9855e99baf64afdaffd4627035546d9ae7c33afab020eb8297d23424216360b06f46e0b4c6085fd137e17e1576504b533e496cc01babb6993f30d5b8055077b5a967599758d1cc07b6429b1b9559066670d0fb9f1c2824a79ef3030949be8d46035a95f04a8aad84faefa7de207ad38e581544e561e363fa67034033a1fc20d47db97910ae2767e201", + "data": { + "slot": "9746409486191366473", + "index": "9744757002974682345", + "beacon_block_root": "0x3cfa1e8709d72a9993f7cb1e3558f312ff23b3b5185b915d934fed9109dab7f6", + "source": { + "epoch": "133284776", + "root": "0x16b82a87c93f6c0fa871fdc78d46ca78f21db591abc93fe9384d6601551849e1" + }, + "target": { + "epoch": "133669524", + "root": "0xeca04b86877991480f625139f795d6e9e0908f3dbc944d8b037a6bbbbf788178" + } + }, + "inclusion_delay": "9675352673514210599", + "proposer_index": "9680310127459230280" + }, + { + "aggregation_bits": "0xd584f624594a49b26b429704bb5345ee8db0f02489ecc1a59a5e9df75dd2f7511507623442f55a7f054b4b5cccb42537a2f89f83123b899a3aef9edc2d897fb09a43bf6f3f85f5467420fc00008968d7bdd54eb51049e7b01e2cab6a3f56d2894f2f4d15ca8bbf1f435ea3babe8c18e577f2c8281d24748f17bee587f86a89d476fb567cab23bf3a6845e821a4041440d722dbd0781754313fb7b009fad7665ca407c78fbd3a563542ef325a0fae888cea74181c45c053dc367ac5e91b07bf343ad6d7ffb3dd66e3f83a1de171e1d616e96dd7a8b3921fe08be965758ed49e74f5c6792095c3dd7399f339dc073c1929174cbb83d37a6dd46c702fdc217e49ea01", + "data": { + "slot": "9668742740647474087", + "index": "9673700190297526471", + "beacon_block_root": "0x25043a86675c2f17ef2a87bb72301451f2998cf3dfeec7b98cfd35144e9ba718", + "source": { + "epoch": "125012674", + "root": "0x98ca168627226bb4aebcf2bf68658f1f18ac865f25a3bc169f04cbc56ce0f358" + }, + "target": { + "epoch": "125397423", + "root": "0x72882286e78aac2ac4362469c15366850ba6883bb9116ba243024435b81e8543" + } + }, + "inclusion_delay": "9657175349540750599", + "proposer_index": "9655522866324066471" + }, + { + "aggregation_bits": "0x3982ad40970eac0a4133b1535ed07b55ec2d897be551dd9235e21396e744d4462284c8c1fab7375eda4c4fc0ec79abfe567d2a15effce3554e11b808c7d838e40c0fd7322add75b5f57da6f9424e9d1f13b7b286e57dbf71c93b737566c996153590ff37a52c5cab77213890daabcdf49e0a25fcaa41e33325ad64ebd80be0aa4127855cfaf48da723065f17b565fa5fd9b65fe0db31d53e631425be9d596a44bb9ddbf4cd66c35160fef5e894cdc58bb39f82c4f5d248fa5a523f402885c159584c38f6f281d245caa228ebe8c129d84ebe202d3f4e1a897055fd646884e7428b82202b4abac1d856a516c57384cdc75a0ad2e6939079de32e8a6ac3fbd116d01", + "data": { + "slot": "9703444901082742664", + "index": "9701792422161025832", + "beacon_block_root": "0x944db5864828de70d1ac0e2c16f7647e6f5aa1f9ea776f74cb64aca664a99cb7", + "source": { + "epoch": "129822035", + "root": "0x0714928608ee190e903e7a300c2ce04c956c9b65302c64d1de6b415882eee8f7" + }, + "target": { + "epoch": "128667789", + "root": "0xe1d19d86c8565b84a6b8abd9641ab7b288669d41c39a125d8269bac7ce2c7ae2" + } + }, + "inclusion_delay": "9698487451432690280", + "proposer_index": "9690225031054302344" + }, + { + "aggregation_bits": "0x5fa8d5c4e4decb71ad6f9c51cbc0959d3facff77191c96367dc94ba95f6268f87b05dcd348f87392b6b15afb3e1b3560317764d59e1a2b623295b9af2572c4d741bb90ae28f3e846ae282f03541c4e08e9b4a0f1710c1acca6bc1d5aa4690d6a080e0b0f6eaea75a0dd9bf5f81f8974f37073917cacbc1a02731bad2adb5beb2d8fbf9f8dcbbda7cb3ed89d56b74b5bc974dd6887f99360fe0d3cf528459465902f0a40403e6329cbdade53292beaee719752512fb82547908396cce34d424dafc545860da3e51383ae4a0ca6bc5af0172fb39ec3e7a81f5c6a079ccb343414192f6c5b9a881429f279fc3a5e21c5406d1b06972d77a372e9fd11090bdb3738301", + "data": { + "slot": "9691877514270986472", + "index": "9683615098187565832", + "beacon_block_root": "0xb33d5d86a896f3792f991bb77cfb9882cd879287993ad35c7af6a06230565bd8", + "source": { + "epoch": "127705916", + "root": "0x8dfb688668ff34f045134d60d5e96fe8c08194632ca981e81ef419d27b94ecc2" + }, + "target": { + "epoch": "120395687", + "root": "0x62e4898526395a29ac03a1d13f397c59aef46e0f3d748f8ae9201f8ce5f4245a" + } + }, + "inclusion_delay": "9627430643050501702", + "proposer_index": "9625778155538850278" + }, + { + "aggregation_bits": "0xc9cf5dcc5c4634813cd4bf58cd4b8777c94a84d889b761fc61023b76bb8227df675215daba8d0cb57a83dc8525aa50fcef6da9b63d42817c19cee1ba114b6254edfb07637d11b11add219cb75479fbfb0afe5b60be54289adcd7f587fedd6b2613763508fa8a7c3285dd145caebde4f42978fec07a3cf7bce95885e7051b30a6556537440aff79056454cd21a00a4c2883076248d191fb56b857b1fea9c6b0b8c8608e51ccba59ed3552dc3946c1a6f0e1fc0f553833e98982d339578940f284c4517e54392ae26353ec6b583c2354372d4205c02e8883e2d14a4e40a9c095987a937bd99c5bb9a24d8e20d3bf104e883596365a7b994faf76c92939b4ccaff501", + "data": { + "slot": "9620820705888797894", + "index": "9619168222672113766", + "beacon_block_root": "0xe8cb6085864a750b60d8730108f70bf5da09680d3af1aca12aa9f705de9a2825", + "source": { + "epoch": "118664317", + "root": "0xc2896c8546b3b6817652a5aa61e5e25acd036ae9cd5f5b2dcea6707529d9b90f" + }, + "target": { + "epoch": "119049066", + "root": "0x345049850679f21e35e410af571a5e29f31564551314508ae1ad0527481e0650" + } + }, + "inclusion_delay": "9602643386210305190", + "proposer_index": "9607600831565390278" + }, + { + "aggregation_bits": "0x0fed244d2ab3dbd6909c1049bac27ddfdb8f336e565a0b792931674f52ec5ba51cebe3d80e548ad72264c94cdd086ce69d75ef7e0ae749cff57ad70d71fd46aba257020f2d77aab91d71157ceaa80cfe06f1d9492b4d46b2f3c61d38752f585b2de145b97b0ddfefbb251de1254eb70b203df0d18a27bc8899723ad902b1fcc8943f9b00a4231c5eb4b63be3d6195beb8df4ef1c97b9106f2bca59962214dc95712db0f43c5fa720e811c5ea40ae04dc0b1385832025d04afafaa8deb61b0935a0f91aca2cbc0316aaaa63519b63f83f03e6b497af901a9643ff9cec5877758ba5cacf531c40179989b6ddbf20c991c9b2adc8483750db1b9b3aaa252682879f01", + "data": { + "slot": "9648912933457329959", + "index": "9653870383107382343", + "beacon_block_root": "0x0b91f385e7e7a6516d4e5ec45e9a0aee3dbe80cb6b57b173b20b60778b254099", + "source": { + "epoch": "122704181", + "root": "0x7d57d085a7ade2ee2de0c9c853cf85bc63d07a37b10ba6d0c412f528a96a8cd9" + }, + "target": { + "epoch": "123088930", + "root": "0x5715dc8567162465425afb71acbd5c2256ca7c13457a545c69106e98f4a81dc4" + } + }, + "inclusion_delay": "9637345542350606470", + "proposer_index": "9635693063428889638" + }, + { + "aggregation_bits": "0xc1e257ece8e03266fa69360cbfd2cb663a153b930877254b679e6c28797a3c3a4920733db060e1d28c49dd12d7b4e73fe883a0e1bfa0b384ab88815393a8c1af045339c37ee1e0002b150f3408c55c7d6891b962fc73d7e280536127252484d61647d332518f3c5f53bb083a39ef6a5a519d37af794b19969945a2134064a7f4c16fca24f9fe2ce73f9d88d16b10a47585706b24749e93f4f76aec21314ae28f6a9ec553c8039a03e2106a115fcd860a137839991431fa39da8a194dff22a7530a77f5e95da194841cbfe641a6876de0b45bcb146bac1f97113210fdf9536025fb0a97559079ceda56c6dae6706943f3eb6ca3297bd9955f65800301385887ed01", + "data": { + "slot": "9630735609483869958", + "index": "9629083126267185830", + "beacon_block_root": "0xddfcb285c6273f47f72ecea1767becbd82df751141f77173a9984612ed4e218f", + "source": { + "epoch": "121357560", + "root": "0xb2e5d384856164805e1f2213dfcaf82e705250bd52c27f1574c54bcc57af5926" + }, + "target": { + "epoch": "114047331", + "root": "0x8ca3df8445caa5f6739953bc38b9cf94634c5299e5302ea119c3c43ba2edea10" + } + }, + "inclusion_delay": "9572898671130121701", + "proposer_index": "9564636250751733765" + }, + { + "aggregation_bits": "0x395a2b3e3053707db11c1ad29777eebc7c2cd5419e5802cd5df131444b29b9c8cc011d197af30d52dd679f776f10ef8bd4e9552018cd0462c14e90d9c1f0709d7c433360fc060a25b7ff7d3b46c58134f359d71421ada88f1a8d1ab6fb3c73280711fb037c32ac6c8c5425ed1dc54bd115166e8689e0aa358aa43fa9578a07aa60476e207148d6ea311bfa88eb1e72148786a2cebdfbb5f5eacf9f1c4dd5e084fd50758d9a4c8121b6b67cc749eebebf877cb327507bde050da70769c045a0c8cecba4016e2d1731189ac03f58caaf501b8a16b0c960dcf514d0aa7ad32178dd6ca969ae2528cdeebf2123933de66db58db46c990317d21f9d4956def440f31501", + "data": { + "slot": "9566288738263385189", + "index": "9558026313590029957", + "beacon_block_root": "0x5e0f9f84240a3eecfd79c399509ab164a86d47dfbbd0eea01050abd60517cc06", + "source": { + "epoch": "113085458", + "root": "0x38cdaa84e5727f6212f4f442a98888ca9b6749bb4f3f9d2cb54d244650555df1" + }, + "target": { + "epoch": "111931212", + "root": "0xab938784a438bbffd28560479fbd0399c179432795f39189c754b9f76e9aa931" + } + }, + "inclusion_delay": "9554721347156661700", + "proposer_index": "9553068868234944868" + }, + { + "aggregation_bits": "0x05ace765a3afe2b4c73a680d4cb837ccd634a73fe892b368226e638b34bf8f2320ee0c37e61e981a4c960c9534ef153d00b10b0a2e25c823bd03e6796123494fc79f2f007a64822eb16851dbbe621c93b598c18d26106b1c9d307ac6949845fce9bbf4a66f2c0de2ec67e38e3f50070efc87a72c81b23ddb67004699f36275d294c95c2c4143fe7d28970dafbe7b02adfbe956217e3dac942c62b4c317063431194377a4cd0f89afb5ad4b4925400cc1198bbd08cd575e2a036b09d8fcc8868e7622d28ba6229a028df077ba66213e06c5c76caf4f188b2d844f16d5367716ff1ab39dc58c0ad1d6e1bfa172f8fd467f8bf38f971356b16a29e70c04d40ff0e101", + "data": { + "slot": "9600990898698653766", + "index": "9599338415481969638", + "beacon_block_root": "0xcd581a8505d6ec45dffb4a0af4600292252e5ce5c659965b4fb721691b25c1a5", + "source": { + "epoch": "116355824", + "root": "0xa7162685c53e2ebcf5757cb34d4fd9f718285ec159c844e7f3b49ad866635290" + }, + "target": { + "epoch": "116740573", + "root": "0x1add028585046a59b407e8b7428454c63e3a582d9f7c394406bc2f8a84a89ed0" + } + }, + "inclusion_delay": "9582813574725193765", + "proposer_index": "9587771024375246149" + }, + { + "aggregation_bits": "0xc9f84a0e8fd13813e8a388e09d8acbba252fc96739b892260b2f6998c8cab2a42c070eab4415167b83b7cf0f496e16ce1917480de2dfd55ffd7ef9d72691591d262657d0765cdb2882d52f2a01b392e5d53c3a33bca1ea85e53d0b425823969429a82d17e65c95e9f9cd156c12bbf00949c1df85785b1f48d801d553472736fbd7e2da36e4648435bb284885b2a0a619661df3e0b4418aa75844544595df8d304290ed68b1cdf736027968212f15dab1388e2fc175c759b2e3a8a4d1603f00afba955338fc699e74ff16177c8b10646e3e0ad08cfafa25db51b28b00d8188521146766afc4792c50845bea9a9800fc6ce11e4f6bcb2faad90448adc009eeb1e301", + "data": { + "slot": "9576203637563489957", + "index": "9581161091508509637", + "beacon_block_root": "0x5340f18465e7072894d01d3abd1e922d504355e3c2d6b3728f3ffae213cbc470", + "source": { + "epoch": "157331582", + "root": "0x0f16f1892e81e181bfcb2e44869a158afeaf2c907bebf8eb963e7e591d519c50" + }, + "target": { + "epoch": "157716331", + "root": "0xe9d3fc89eee922f8d54560eddf88eceff1a92e6c0f5aa7773a3cf7c8688f2d3b" + } + }, + "inclusion_delay": "9934792654497735694", + "proposer_index": "9933140171281051566" + }, + { + "aggregation_bits": "0x55d3f396045bbcf740a6574fc488d1acc30195de0858c1d4ad1933731fca5275a39b48230751e26cf3d85b687483be7a5774bce9c6555c06c6e848cea088a54f21c41948701b080cf7a0ffd35f4935bd43544a7b51f3babb873df0a340d64185c3b3988bbab975de934963b2eb9ca1bb0257460ce449fed51c7e126a1a4e58e969287ed31ac238fbb56568a422eff1b84e9893ef29c1e1bcc80ee9b6c517edd7b87fe86f31590a425dc3b6387fd0ced9b6514b4e8a92439e2c6944ba20bb22da5f29386bf62e5bc045224ca4be6dd325f9eaf24dfe2a80103947d0a8d84db1a3c26ae97bba3fddee97f1a82a420c29c4be2a2975407f16044c087b9c261d0a8e01", + "data": { + "slot": "9928182721630999182", + "index": "9926530234119347758", + "beacon_block_root": "0x6fbbd3894efb3dda891a331da8467c8b1dbf276a0bd7c48e7bc4cf4261353106", + "source": { + "epoch": "155984961", + "root": "0xe181b0890dc1797749ac9e219e7bf75943d121d6518bb9eb8dcb64f47f7a7d46" + }, + "target": { + "epoch": "154830714", + "root": "0xbb3fbc89ce29bbed5e26d0caf769cebf36cb23b2e5f9677732c9dd63cab80e31" + } + }, + "inclusion_delay": "9923225267685979501", + "proposer_index": "9967842331716320143" + }, + { + "aggregation_bits": "0x11f0c8d653eb3980a5f66f0fb1903b4091c4777894e5cd51e5962049e17ccc9f7c08fef3b678ec56b76bce53e5abb425282c700db4a4d4918e3d6a70c9248bb13c644b3cb85d52e79d3026b85279e3aa2d4aaa0c4782dddcea2a8c9d9e7552f8d6adf8b8be39b2008d81c40d280a3b462a54585495d3dd203e14c9556fcc1e67fc348355ac1e7ba8b5963c776c76fc53058b0fe969c758915aa317dedc11f1f82d66d643cb99e79e83a09ae070b3e9b1dea2c49a91c2d67f7ee1d7721f68dbf9a0b5d4c177d9dafeb7e461a492fb45eafd7f433af4081f6259f1404629b8d2029a1466f1688d760d464f4e0dd2d4f0173d90f2a30c972491d5025d8498b62df901", + "data": { + "slot": "9969494814933004271", + "index": "9961232398849583630", + "beacon_block_root": "0x2a89378aaef5694740a8573b9b301fedb38b38b8ef820f32703054f6e0c603d0", + "source": { + "epoch": "160024824", + "root": "0x0447438a6e5eabbd562289e4f41ef652a7853a9483f1bdbd152ecd652b0595ba" + }, + "target": { + "epoch": "158870577", + "root": "0x760d208a2e24e75a15b4f4e8e9537121cc973400c9a5b21a283562174a4ae1fa" + } + }, + "inclusion_delay": "9957927428121248078", + "proposer_index": "9956274944904563950" + }, + { + "aggregation_bits": "0x05d98ac3a268bfce3091cb7d4c7da79a820b0330aff8433b1ba774af1d29550d111d54d559175bc0e80499147afc4f3e8c0f3b8df4c3cdbb3bc9216055a90cde7d952cec3a49b45e02d681c6bc1fef2e176c3930dcbe902b58c3f7070bcbfc211f8142b6a94e6cdf0ada9631b8241ee1cde4779d30c681ace6a33b8220aa6934de0dcfcde3f34d289df7cb277b497630be85d643305f4c4e6eaf63c7658da0673cff75273f0c2e77e9bc53d6302febf5294a56c12a9b5cbe4bfef24ab8d342b72907c712de2af0e4462e3be439b41abac4ebb27cc98078ff056739d64076c27ef2846b794177f6092c8ae1aa60a0f8e99560da8c1846cc428c2d0497ffa74de001", + "data": { + "slot": "9951317490959544270", + "index": "9949665012037827438", + "beacon_block_root": "0x5f173b898da9ebd871e7af85272c925fc00d0e3e9039e97621e3aa998e0bd11c", + "source": { + "epoch": "150983225", + "root": "0x39d546894d122d4f8761e12e801a69c5b307101a23a89702c5e02309da496207" + }, + "target": { + "epoch": "151367974", + "root": "0xac9b23890cd868ec46f34c33754fe493d9190a86695c8c5fd8e7b8baf88eae47" + } + }, + "inclusion_delay": "9880260686872322988", + "proposer_index": "9885218136522375373" + }, + { + "aggregation_bits": "0x5f69ca9579cdefd01c6de9a9e24ff310eceb7b627a46f29fc8e020c34f489eeda0bc75e14b3c91419c02c935527a66a8a6c0cf0653a702d5ad3310ea0f7036ce45d9252ef082f23adb7e975d321f6b672e59d90c25278edcea5a0cc6dda7424f69d6428b8653dc6fbd1ffbee668d31fa427fb735ba54cd1f611c673a9f0d49b47b216fc9fe41be953174a8fdbb62e1dd257d2dabf1787aeb2f0550e21940d229ba55c09d7cc777bdb52e956e162b9360894c52642abc4c171de2a0aef2d0212ce78b8fbaefa67952c38f9ddab5b6f0297f9f7b9f49acf01b29d7c9ddcc24c087ec761101f21ce0b0c52c0e814f6dd698f043cd1bc0812b028cf6d74b31be559a01", + "data": { + "slot": "9873650749710619180", + "index": "9878608203655638860", + "beacon_block_root": "0xe5fe1189ecba06bb26bc82b5f0e921fbeb22073c8db6068e616b831387b1d4e7", + "source": { + "epoch": "148867106", + "root": "0x58c5ee88ac804258e54deeb9e61e9dc9113501a8d36afbea747218c5a5f62028" + }, + "target": { + "epoch": "149251855", + "root": "0x3183fa886ce983cefbc71f633f0d742f042f038466d9a97618709134f134b212" + } + }, + "inclusion_delay": "9914962847307591565", + "proposer_index": "9913310364090907437" + }, + { + "aggregation_bits": "0x9db2023ed6d44192fb718412e72b6917946f26bdf53f675cc892a5894f62f099ca4d505d4f6036a4c09d1faa441c77ea69481679802e8d712174711ed57a8e5009887b33634c6eb119e9620d1523d1d69c21e79ecaf4003344ddcff01b92cb5f887459a10b38502edb8b51e8385006316ec07fe5366706b382f2bf3ca4193f35faa017fb771a999379a62a2e3c8aac1535e6f632c64737fecc396e290981475e511f1398326afd01f21dbd42357fe8cd563a58137f617818abc1469d451f54e064363914f90e1e3c11b2135c34a9c7181b798952a4a8856f9a42083b0bba714eb2637e4449ee90c81710250943f9a5e10e4a39b1acb04ec0536b5e35097258ef01", + "data": { + "slot": "9908352910145887757", + "index": "9906700426929203629", + "beacon_block_root": "0x54488d89cd86b514083e0a2694b0722868e31b42973fae48a0d2f9a59dbfc986", + "source": { + "epoch": "153676467", + "root": "0xc60e6a898d4cf1b1c8cf752a8ae5edf68ef515aeddf3a2a5b2d98e57bb0416c7" + }, + "target": { + "epoch": "152522221", + "root": "0xa0cc75894db53228dd49a7d3e3d3c45c81ef178a7162513157d707c70743a7b1" + } + }, + "inclusion_delay": "9903395460495835373", + "proposer_index": "9895133040117447437" + }, + { + "aggregation_bits": "0xdd6cf833c4d9ff31ddc1a6fa02dc28536f6c1cf3b006a48e03b7269ced08090aceec5306c52178264de0d850b817f277754e97145c87304dc3195489850ede878d308febe3562b3e604714cecce2dcb1e80735444723d3a81ef89866c63bfebf2fa7b00463acfc80676be70a1559fb91938a628a7d9fee317d6908ec5a5a6a16bdadf0a1c859ebd3c2986808165d0824be1204c54cb700cd202d0c2987dcb87f1aeb895cda02d7986cd8d1369f22b19d43bc46f9c7de7d324103cbb5d9e890eab0890425a57f8f88675a01c9ebd2d15aa22330118648740cc1bfd18a993e3d38abff691cf38445485b6476a8231febf346a3584cf4c950fa56b5fd37adf329ab01", + "data": { + "slot": "9896785523334131565", + "index": "9835643618547015051", + "beacon_block_root": "0xd65a79882b69b4b90e89ff1d6fcf37cf8e71ed0f11192b76078a5e6ab58774fe", + "source": { + "epoch": "145404366", + "root": "0xaf188588ebd1f52f240331c7c7bd0e35816befeba587d901ab87d7d900c605e9" + }, + "target": { + "epoch": "144250119", + "root": "0x22df6188ab9731cde3949ccbbdf28903a77de957eb3bce5ebe8e6c8b1e0b5229" + } + }, + "inclusion_delay": "9832338652113646795", + "proposer_index": "9830686168896962667" + }, + { + "aggregation_bits": "0x53e3e07d7ed114a3098ac9ec90d8b19d8b0a6f9eb82cd7ce27bfc8222903a2c394b8de4fbbac05ade1de5fecebe58dd2f1949d7256c7ca338d00289e112eb8956035dc2b2fb4d32f1e4453e82e467b0a971c86dc087751f744b846ab1c8c5b62a49ff09233520261eb1765012cd4ceff1ef7a19cfa44043cbf26337b5ff470eb3cb1593d571c49aebd61acd09a22fd9b39c88c97f2fdcfd41cbf3135ae83469eda3a846381a67c206293aa1f534d9ad4b342cccdc5ea62d45e6298ad7802663c1b9a2269e078bce2f4d0eb124ba6324af1998abff9a8567f4e570065a2377be2c70a50fef3d237753435850dbe518011c1bd8760e0fb01728e934c96f24a20ec01", + "data": { + "slot": "9825728714951942987", + "index": "9824076231735258859", + "beacon_block_root": "0xa8c638880ba94caf98696ffb86b0199fd392e255e7b8eb75fe16450517b155f4", + "source": { + "epoch": "142518749", + "root": "0x81844488cb118e25ade3a0a4df9ef004c68ce4317b279a01a314be7462efe6de" + }, + "target": { + "epoch": "142903498", + "root": "0x9128dd888c63e026c516243c61b9da30243efe5df6c47519fdf5e21d351947c8" + } + }, + "inclusion_delay": "9860430879682178860", + "proposer_index": "9865388329332231244" + }, + { + "aggregation_bits": "0x958119dd1f345fbee1de7efca5d848622343d12ab6e198c987d51a7de4653a11eb394c8f939d81cfab2d4ba75ac52749981e5cb3c772420061960939738314b76ddc9d26a5d2cba031000a111a563c071d0e648e9ce237c63b9b9a94e7be4c8c9b0942a23ac2e5ab51bd4eccb3059c443798afc70176072ae184e074e14a3a38fbad26b9f0493fe5bd82fa376532aa78f49b39cf56c424adab769d5da5996aa169369b675d2280243f74fae7652e11f81d6b43099edfdf05948a8b235913c707ecd642c750c6b5be1417e3327b3c8e98d11e15eaf91aff4dcaa294ca5b9a4fe29c6e875627e50846c5cdca108aba5b7c062f74f29c8277a7539af2fa7cc00aa101", + "data": { + "slot": "9853820942520475052", + "index": "9858778392170527436", + "beacon_block_root": "0xca8bcb886c467ef5a5df59bedc5318983647fb13191ff0478679ad76c43b6d68", + "source": { + "epoch": "146558613", + "root": "0x3d52a8882c0cba926471c5c2d28893665c59f57f5fd3e4a499804228e280b9a8" + }, + "target": { + "epoch": "146943361", + "root": "0x1710b488ec74fb087aebf66b2a776acc4f53f75bf24193303d7ebb972dbf4a93" + } + }, + "inclusion_delay": "9842253555708718860", + "proposer_index": "9840601068197067435" + }, + { + "aggregation_bits": "0xd1affa5bc8e6a643c30748bff0cb7e886157cc9538dc806b28e8835c8b530c86faa8e4ac25b92ae932044f58111c1c8dee2be1a27e3538cb71146f4199d45bf699d8a7eab9ce420dc54c507b583b5ec951686cf549509e87780ed28b23b064d4e1ee0639d6e7063cb9f059631f0645970f804c33bd1f2496878b20ac858d63088871f699271c0c4a5e88a964547394e6ef2795dbe5b3ad24b3df4df8520f7cbb76acc6010b76eda318855655744ddce24002fa402be9d352a0b3338213b99dfbc55aa8ec49a90f34306c663914985b696c0dc069b6c2ca6a910e1cffbd28afdde380fbf0fb9de01d0a553f2cfb39bc404d599514d08b528d8c0071926e1f7e9501", + "data": { + "slot": "9782764134138286474", + "index": "9781111650921602346", + "beacon_block_root": "0xff19cf874afaff86d61eb208684f8b0a43c9d099b9d5c98c362c041a72803ab5", + "source": { + "epoch": "139056009", + "root": "0x72e0ab870ac03b2495b01d0d5e8406d969dbca05ff89bee9493399cb90c586f5" + }, + "target": { + "epoch": "137901762", + "root": "0x4c9eb787ca287d9aab2a4fb6b672dd3e5cd5cce193f86c75ed30123bdb0318e0" + } + }, + "inclusion_delay": "9777806680193266794", + "proposer_index": "9769544259814878858" + }, + { + "aggregation_bits": "0x038696ac1044e65dd8d2446796655e424e793d456cea20ffa317da12f1bc8df47afbc20cff9a124a463a1f1c219c3295c0d514edd050bfad67d257edc5ac6ac8e6988c68e6a0444d18860fed163bc0a1e9db09199647e150b6c3a9c6d58d5b7e91f8008af130d62e1c247c9883ae419f009b31933c8dc19704662c009465c1ca0d9ce2987febff4fa90e1b775e766fab3dd4dc01a4c4976ff33d5cb7cec25f12ef0a78994188b4edc5f782eb5a48a1dbd52cfcfd2a95c87a54bfc13438ed7e60839ef048371ce9009665006ebd5d99eb45d119fd86ca019f99adc0f839de8367e513618b4a63d2218bb6d64edcb793005a366ca109fc9dcb7ccd2f4da1866ccd01", + "data": { + "slot": "9771196743031562986", + "index": "9762934326948142346", + "beacon_block_root": "0x1e0a7787aa681590340bbf93ce53bf0ea1f6c12769982d75e5bdf8d53e2df9d5", + "source": { + "epoch": "136939890", + "root": "0xf8c782876ad156064a85f03c2742967494f0c303fc06dc0089bb7145896b8ac0" + }, + "target": { + "epoch": "141941626", + "root": "0x076c1b882b23a90762b873d4a95c80a0f2a1dd2f77a4b718e39c96ee5b95eaa9" + } + }, + "inclusion_delay": "9812508844923502667", + "proposer_index": "9810856361706818539" + }, + { + "aggregation_bits": "0x8dc21ae70108e6d4b6d016a9b3a083264570a5b95a1830407c989fb48e3b0e9e9758db64438ed30cd4db89fed163c4134f0a2283f7b81bec6e1d316f4f5b338e6800b509bf428570f6156a24c6b51e2aac217d1803f93a697d74986a76c8d5e95fd2d9bfbee066890f2cbaabab1068515916993b67e44c1919eed4353489b276dd3051555f20eeda31423f5a605eb23581bee8525d43891e29d65428540bca1306515a8484c0061fc94875852cc519b507615f94f00d7163d97a879093b080367af4ae8ebf196502a14cb5eac46e089b1f10e592a92a57810d10fdf7748cdc4b9252f7e48f53fc11bce484be39a488ef6cd5ffab71b4f5fec8fbab8fcd3e6f8b01", + "data": { + "slot": "9805898907761798859", + "index": "9804246420250147435", + "beacon_block_root": "0x8d53f2878a34c4e9168d4604721a103c1eb7d62d7321d52f24256f68543bee74", + "source": { + "epoch": "140210256", + "root": "0x6711fe874a9d05602c0778adcb08e7a111b1d809079083bbc822e8d79f797f5f" + }, + "target": { + "epoch": "140595005", + "root": "0xd9d7da870a6341fdeb98e3b1c13d627037c3d2754d447818db297d89bdbecb9f" + } + }, + "inclusion_delay": "9787721583788338858", + "proposer_index": "9792679037733358538" + }, + { + "aggregation_bits": "0x1362df66c7bcdd2d86919277ea1e4098c296637ebed6f8f1419b450fbbd8124aa0a23281f2dd1675961b44174fdaf6ede7985e307529bd93319cc1244ea278e95023aedcab2ce3a369a37b64757eadc576a282a171f953e73cec0b18ef9881ddf4d1a97bd9e41c67182fa0cc6e331df5542edf27c53cd0f0f03e41197861c5707b3f986c0c761729871e385e3c688f3cb567a5c5a72c96f89716886240827572bd43b452967c88ad082306eefc91703be7923bee41fc06926a697f50ca6eaa8ef9401842f8013a984cab3d6f6f1a3ad43fbf48d31a8c4eaba2dee65e6cc4d744b51de1502906d5a204dcb95e74fd73803561f28a17fcf4fcba949a575134acfc01", + "data": { + "slot": "10151268050372636979", + "index": "10156225504317656659", + "beacon_block_root": "0x5c4aec8cf3197d8837cbbe390f1fa865d226ad6ce3fe426358a536a738227ddf", + "source": { + "epoch": "181186014", + "root": "0xcf10c98cb3dfb825f65c2a3e04542334f738a7d829b337c06aaccb585667c91f" + }, + "target": { + "epoch": "181570762", + "root": "0xa9ced48c7348fa9b0cd75be75d42fa99eb32a9b4bc21e64b0faa44c8a1a55a0a" + } + }, + "inclusion_delay": "10139700663560880787", + "proposer_index": "10138048180344196659" + }, + { + "aggregation_bits": "0x5f2d1e6024fca88120c034b20b9e2662e1017e98b0ebe1f2e36fce6531c732ed477b9a74c6f81b706d9044860b1f7d5d15cd232588ccc76831769778f4f5bb4dee479640a7b42b189ce7200cad97bf0dfea7fe5ae4caebde7f595527a3c4f1d1af522dd176e2dfaefc97a3d36d748e2004da9d517511c74512b482d5d0a59e0408fa43ea4da90292f4548b1881a140122ce728b128ce7597ecf6ed5d26907362a265e9d7e2686d8e2d22891c6663f7f9ece981f655c808d55ed9e7e9c091b4e801cc7662a962a5186a9c8df73abae13e09b43b10101051abb15a7a291bf04e13ebda955ea5be4a61cb825f27405d8f3d6c341f4f5b35fbd8842f133f5f7f90ea01", + "data": { + "slot": "10133090726399176979", + "index": "10131438247477460147", + "beacon_block_root": "0x2eb6ab8cd359157ec1ab2e1726008a351648a2b2b99e03634f321d429a4b5ed5", + "source": { + "epoch": "179839392", + "root": "0x3e5a448d94ab677fd9deb1aea81a746174f9bbde343cdf7aa91342eb6c75bebe" + }, + "target": { + "epoch": "184841128", + "root": "0x1718508d5414a9f5ee58e35701094bc767f3bdbac7aa8d064e11bb5ab7b34fa9" + } + }, + "inclusion_delay": "10181012765452820468", + "proposer_index": "10172750340779465236" + }, + { + "aggregation_bits": "0xa90ee5e473698ee6cc8c11a6b88f8aa86100443c2f06eef9ab489b59d9a8cd2b8fb210667cc1bf502c2144b9b9a4633244c701e86f29075e5de0a046c759d1a8b2ebd53ded9a34a7d3f768ff81c76b1a34866cb971bd8ca3527e1fb170a4ea27b1c45f717d1150e2e64b8c2c9c61961a0dd3230816c3f09a40fb5cedbe17520794e16f6cf276524f64b75deaf31745e03fd4b993a8fed2da5d0fd535bf0e0d4f33f8d753a2cdb28b70e1b0e67511ecd554520f220cbeb7161438d437f1445749bfe480ec8dd0054dc05ba176312c6b87a423c2571528f29f72ae9ae66ad70879b2940cd4200549da1fb04b6333871ee2ab8fe1dd27cc2a042856a5038d71b28001", + "data": { + "slot": "10174402828291116660", + "index": "10166140403617761427", + "beacon_block_root": "0xea830f8d335441eb7839533519ea2c97ac14b3009d4a4e06459ea1f519dd309f", + "source": { + "epoch": "183879256", + "root": "0xc3411b8df4bc82618db384de72d803fda00eb5dc30b9fc91e99b1a65651bc289" + }, + "target": { + "epoch": "182725009", + "root": "0x3608f88cb382befe4d45f0e2670d7fcbc520af48766df1eefca2af1683600eca" + } + }, + "inclusion_delay": "10162835441479360467", + "proposer_index": "10161182958262676339" + }, + { + "aggregation_bits": "0x1fa33fdccba5651e4c173e32888013c80d643394b32d55f8bdd7c1cf1d8b04bc96a3bf6e06c4c2b9e9ef9747e25f8d93fadda8c667597677177dd852226875292def86f1b138edb6acbc3bc33322ffa897ef9f913f699e801a3ec7642e110bfa3a8812664dc5af0b4f6f5e65f469a3f006a8595fa7fc1a5a8ed267d0afb1cd2add7787826573f4129b161b262d08d478a25c16b90cbe73f725aff9b9b794c1a6503873286d8b90327e9ea9cd9cea5984fc0a2543ae9aa8f22e0c83ffe21db1171fe3f40856d3cf06fbd14f8ca218b8b9db999e7b397acc89756d3f2be0d42cc9dee1bbfe304e136535b7e0b18e89b4170d993dd93b1e769d404191a6c6e8fbc601", + "data": { + "slot": "10103346015613960786", + "index": "10101693532397276658", + "beacon_block_root": "0x1f12138c1208c37ca978ab7fa5e59f09b99688863d01284bf550f898c821feeb", + "source": { + "epoch": "174837657", + "root": "0xf9cf1e8cd27004f3bef2dc28fed3766fac908a62d16fd6d69a4e710813608fd6" + }, + "target": { + "epoch": "175222406", + "root": "0x6b96fb8b923640907e84482df308f23dd2a284ce1724cb33ac5506ba31a5db16" + } + }, + "inclusion_delay": "10085168691640500785", + "proposer_index": "10090126145585520466" + }, + { + "aggregation_bits": "0x477fa707daca7bfc7c2fde5ae55e16bf7e0f8366c29514af8796c9c8b1ed8e17864e8ef68e8d8819277352df9542bb84eaf9f8eb9f324d9a751ce7dd030e20dfcd56fa23f1a7a273950fd1336ae173da37a22549b61cdf994017968efeb27218dc9ff3d24d7142e954c5aa8740647e576c72a8717e00b1f579c2959055f68e0b9af6abb0c2220e74244059004a5bf04c0eaa33f8c3444940cbb9db199a440d9f297ec1ec33b313abe26baba113af8e44d79693a81766a75ac19303535cd8bf18a808f9b310b68fbe8d755d8f942baec027c362e20dc621e6a882b2dacabb0affc4f6fe249b3dee77d91fab6acc36382526537c25ea6385bf65eebae06e698a8401", + "data": { + "slot": "10078558758773764273", + "index": "10083516208423816657", + "beacon_block_root": "0xa5f9e98b7119de5e5d4d7eaf6ea32fa5e5ab81843a7e456235d9d012c0c701b7", + "source": { + "epoch": "178877520", + "root": "0xb49d828c326b306075800147f0bd19d1425d9bb0b51b217a8fbaf5bb92f161a0" + }, + "target": { + "epoch": "179262269", + "root": "0x8e5b8e8cf3d371d68bfa32f049acf03636579d8c488acf0534b86e2bde2ff38a" + } + }, + "inclusion_delay": "10119870856370736658", + "proposer_index": "10118218373154052530" + }, + { + "aggregation_bits": "0xb7c6ad9df61775f49bbabbe7aa13dc994f3bfceb55ad406cb2279e99bffb9a2578b385888cd9ad9c1bdd96c00056388c3b7a639c49bb86bff56a9caaf183d4d4c603e530b2683ca476942840459cd967858b730d5d4e414ca098434c9185f74e3fdd64ecca70a96e218812c0ae39291e57cda4f1e0113d31be0d04a36b64fb58ab7f0884773ba17468d31bd6d3f11df55da10ef5a77b33157a8d8c62ca0cf9f8568c168ae3071c91a7d80e841dfae7f94c8e128b60a9a957d29de8f4bb0752d8c9b7e917264fe4fdbf0cd39ff434a18ec205122ff4b250f41c1da31f8543b974bbca16472a2fd40d2b8b1ac4c3a9cb50c951ce992f7a0977b263aea25ab4c7f701", + "data": { + "slot": "10113260923504000146", + "index": "10111608435992348722", + "beacon_block_root": "0x1343658c52e58cb83fcf0520126a80d2616c968a4507ed1c744047a5d6d5f655", + "source": { + "epoch": "177530899", + "root": "0x8609428c12abc855ff607124089ffba0877e90f68bbbe1798747dc56f51a4396" + }, + "target": { + "epoch": "176376652", + "root": "0x60c74d8cd2130acc14dba2cd618dd2067a7892d21e2a90052b4555c64059d480" + } + }, + "inclusion_delay": "10108303469558980466", + "proposer_index": "10047161564771863953" + }, + { + "aggregation_bits": "0x4de68fee8eb074e271cf1331c538d803e102241f81c228892b59c3f7858609c759f6223d0edad55d076998f5a8762150819e9257ffdf096befa1a521a2db6544be6186da782f56c48a77ba820bdd0c0329a8d3e5e4957c037847281067b3006c0fcf6d75ef073d54945437be5b10ac801ac6515d54a5d6f8b9b6998f5468891b2c513885de9c5eddc711ab01df58e04a8691661f42dcd1744b1ec47ff685d8aaf40c0f16b967c9ddfbfa083fbbd5190ad8ca9d4f61cd893e01f4bec0ab1171ca85b927a111d3304a93e520e141b323169d518f8f64bedb13b0bb5335991dd18da4f8b9db9ba4c6304a3c67d5ee77a518bb1ab578dc99c0352aafe25f948cd79f01", + "data": { + "slot": "10048814047988548081", + "index": "10040551627610160144", + "beacon_block_root": "0x9555518bb0c78b5d451afb17ed88457987fa6758bfe0694adcf7ab69ee9da1cd", + "source": { + "epoch": "169258798", + "root": "0x6f135d8b7030cdd35b942cc145771cdf7bf46934524f18d680f524d939dc32b8" + }, + "target": { + "epoch": "168104551", + "root": "0xe2d9398b30f608711a2698c53bac97ada00664a098030d3393fcb98a58217ff8" + } + }, + "inclusion_delay": "10037246656881824592", + "proposer_index": "10035594173665140464" + }, + { + "aggregation_bits": "0x5b3dcfee5ef782e76260b74bd3c44459f2f6c3921ecef4e21cc9e418973fd831220f091c6621fe9b5897d9021c2d4adfb5bd0e9f9fd8557d0e1cd6087ff68689e9bc622aeabbd067301b04054eb871878e8730d92bc910b6ace8d2635f5eebf512f64bcfaa18e98d1a4278e09a3fc14236de4e88dd101d8ec0e0a9549a25b7199f6ae4ad0573e89ba9101d4d4d35e01b539ebed562c0ed3f5d03d20e6f16f9294509813152d389b0959605837bd885a8cd3a9e31fa94283f3572bff096bbd848568e74689e654f42ca2f2f656f7986c921c593c24d16bb846e00abf764ace9f7cf6a3c1ff21722f83066d2e23e40afb606eabd7ae06106e66fb7b601eb8cfb9601", + "data": { + "slot": "10030636724015088080", + "index": "10028984240798403952", + "beacon_block_root": "0x049fcc8b91933ab7279c8288904f96a604bb7c5eca6911051a5f22fc04ac966c", + "source": { + "epoch": "172529163", + "root": "0xde5cd88b51fc7b2d3d16b431e93d6d0cf7b47e3a5dd8bf90bf5c9b6b4fea2757" + }, + "target": { + "epoch": "172913912", + "root": "0x5023b58b11c2b7cafca71f36df72e8da1dc778a6a38cb4edd163301d6e2f7497" + } + }, + "inclusion_delay": "10065338888745323953", + "proposer_index": "10070296338395376337" + }, + { + "aggregation_bits": "0xb71e342e1d23e5988f32054fe4d4ce8c60051a3c0363bae3dceaf5660e492eafd984911e703c5ad93477c0cdae8fd244fca7457adcff990bd288e62f55fe6fd6e000126272b5ddc47f4f48df60c8b2b22486b23eb898768bc3ff69bc8cfeb58a2a60bf7df1d2261920fe1f3d872c99f91b95d0da842a6bb0efeb736deea3f9549a7088c12bacaf4868f3cb8aca022fc01ecc07b567ca2e66ed861ea6669c1516f6a4dc59965361ed4df50e717cab3e4467f100f5e18596dd47130c6ca96a733ff1961dc60797fa4f59e903e84caba8108c488ab7512420b0ccbd6f4a95ad8c1c943eabf560ac25e3f1566eddcbfa34c1c53047ca8ea86873b08e18fd6906906001", + "data": { + "slot": "10058728951583620145", + "index": "10063686405528639825", + "beacon_block_root": "0x8a86a38bf1a45599dc7055b85a0d264230d0755cc6e62e1c5be7fa75fd519a37", + "source": { + "epoch": "170413044", + "root": "0xfc4c808bb16a91369b02c1bc5042a11055e26fc80c9b23796dee8f271b97e677" + }, + "target": { + "epoch": "170797793", + "root": "0xd60a8c8b71d3d2acb17cf265a830787649dc71a49f09d20412ec089766d57762" + } + }, + "inclusion_delay": "9994282076068168079", + "proposer_index": "9992629592851483951" + }, + { + "aggregation_bits": "0xc52d460682bc4cb1a681f964b78e8a9ce6bcd4f301899091920e262ea3d5fbe1cd2385d3fe42d3bcb2875b2c01f9d22b98ea6263ac37808f4c911f55ec45701f0ba927f6a69d5ed52f46fa3e1714ce3fd04b4231199e912c96b15ec8c4ea9a09c696dc28fa3ee6788257895bf143fb84544cf4e0a5351682b500b9ce858b80042bc71dfff1f9bde04b4ce82c9a1a2a1fdafcd7204b58b692fd9d55bd03961a189969c34a70ad47eaeec69f5de88c77b3cb42a8ee8bdb2741ce45c7636156f26bfbbb8ffed823b2f6993e5219ea23e15d71275c6fd63a4fd4e649b804170be2e8eb94ab509e8c02e53b2d1e721553faaa14c4fae1f0dbc2c6b0122922455682e101", + "data": { + "slot": "9987672138906464271", + "index": "9986019655689780143", + "beacon_block_root": "0xbf14a78acf58d72a0db0ad02e60899b43c524be2679d08610b9a5119ab966784", + "source": { + "epoch": "162910441", + "root": "0x32db838a8f1e13c8cc411907dc3d14836264454ead51fdbd1da1e6cac9dbb3c4" + }, + "target": { + "epoch": "161756194", + "root": "0x0b998f8a4f87543ee2bb4ab0342cebe8555e472a40c0ab49c29e5f3a151a45af" + } + }, + "inclusion_delay": "9982714689256411887", + "proposer_index": "9974452268878023951" + }, + { + "aggregation_bits": "0x81f9bb1f32c2d23fafbb2afcc968698b1f97de03c521d7d7ec6ba7291f92c462c96a45dd3613c17ced728dd6f4c6e13284fc258415ddfca3feae2bfbeb5135e22b9157212385575954e102e26cc5da1070257cecb04090346eb6354a14ddcbfb2681959532ca7bd873ff3db175462e222a9e4acb7ed970057a9a9e1c31dc47386c89dfe50e8adf64f83baa6ab5419e2b57cb6e7205988bad7311f6ecad4729f3f3107bab03f5b16d1076b73c52cda577eed63e453f4f41b3be0fe2cfd7b27a505d94be4dc0563688e35bc0049c12a7679d2da08236fef722bbf645d43ff1050efd130cae40def5a6c7cd51e057b630b9f8299b1b18e63148b5c7ffe2bac067e101", + "data": { + "slot": "9976104752094708079", + "index": "10020721820420016016", + "beacon_block_root": "0x7ae20a8b30530398c43dd220d8f23b16d21e5c304b4953040106d6cc2b283a4e", + "source": { + "epoch": "166950304", + "root": "0x54a0168bf0bb440edab703ca31e1127cc6185e0cdeb70190a5034f3c7666cb38" + }, + "target": { + "epoch": "165796058", + "root": "0xc766f38ab08180ab99496fce27168e4aeb2a5878246cf6ecb80ae4ed94ab1779" + } + }, + "inclusion_delay": "10017416849691680464", + "proposer_index": "10015764370769963632" + }, + { + "aggregation_bits": "0xb3d63756201e56b28db46812b69194e925b54afde3ab067637a474a62812780027a137f1882748144f9b9b141f290bae6b2a7746172110a2e3a1ffd96b266b9665a80a64b8e7e750da64ac6b340b148e9543b92df4d77b24c18805625d5f2d2f783b4e7475fbdf5df77dcad23d7b63fc6b197667e6b8e7bb451d070a6572f007bce6ede90ac14df36571ce85db74ab302ae8ba89cc6e1bdbcb7ed7f3f78cdfa596cb499657bc72935a4940b33071129d64791c5c1ff5a8bca082a4cf333c3e0605bdf05741453ab31ebef101a1f96ef2ce6c7c7f7130b65a8f0c45fad2b937108f428b41e1d6eb96a03713d1bbb76312fe8a4890686eca2130fbd3389af8e73301", + "data": { + "slot": "10010806916824943952", + "index": "10009154433608259824", + "beacon_block_root": "0x4c4eca8a0f939b8d4e1e42fef0d31de61740517621e91304f892bc678d511b44", + "source": { + "epoch": "164064688", + "root": "0x260cd68acffbdc03639873a749c2f44b0a3a5352b457c28f9d9035d7d88fac2e" + }, + "target": { + "epoch": "164449436", + "root": "0x492e5a786f15e5da7c68904e958c9bfab7bf36fbcd452aacb746be5b657f07ec" + } + }, + "inclusion_delay": "8670642439683596559", + "proposer_index": "8675599893628616239" + }, + { + "aggregation_bits": "0x26355b856096a4b9dc6ac348ccb5e6d67d8dfb0ed8d7f1b8541909dab40148328f12106f66ae2d5e55dd549ac46a128f537f9bed4e31f93672783c76836e32b411659cdd73ae9d4caf0f60cd2e056a3d490c8b3258fceccf038f6696a9d36a5059086450421f4ee20d48f55978627b432a1f1724e3f9df9a49a3de2d048a880dd0d9cf162f337a009a8c6e8a67ca6e92230676fd0bc36cffc156548376b3338443babfbe91199843e90fd3a58f6eb92011a004ac712471afc1042a5060fb0c58c5c8bab08693066b72f74e5512c4386b08f23f6a76abfe615db67f4aa2f80b0fa81905eb194ee7f24af158dc69a6176ad638789fe1b3ca75617b800e58afe5a201", + "data": { + "slot": "8664032502521892751", + "index": "8668989956466912431", + "beacon_block_root": "0x829148784ff882a95c31c6d01027d961cac833b1f09fa4da40ca88b4f4a12d8c", + "source": { + "epoch": "8049009", + "root": "0xf55725780ebebe461bc331d5065c5430efda2d1d3654993753d11d6612e779cc" + }, + "target": { + "epoch": "8433757", + "root": "0xce153178ce2600bd303d637e5f4a2b96e3d42ff9cac247c3f7ce96d55e250bb7" + } + }, + "inclusion_delay": "8652465115710136558", + "proposer_index": "8650812632493452430" + }, + { + "aggregation_bits": "0xea7a9ae73ad454c9ba8665d9c9ac996c9f11f6a2566ad99bd921862598b7f9ed1c9bba9f5894c25f12e051aaba9e8d13269d3eb833568379a0987a2e615d7dd8a70dc2103d7045f71543ba279c78fe742562e349afcff4fae01b2a09f0f8fa1867fae4d32c30ad5ced3dc2065857a3d452de75fa01745a0c8b3e5fc4305af1f3c40d1b963ec62cbfc927d9a99d23e0ac3808dacd9421ad409cd6f930b83115965808f9c1c755b771427d7977918d709908cb3ce087385748e7a453a22843a33f2846d4abbed6bc8a84d05cee67e0c4893b09c7afb453e9666612e67a00cc0aacf74351fd85343d5185a3b6f01d86f344038c01fc89789b8e3be12166c6a4010d01", + "data": { + "slot": "8698734662957161327", + "index": "8697082179740477199", + "beacon_block_root": "0xf1dac3782fc431033eb34d41b4ed298f478948b7fb284c957f31ff460ab0222b", + "source": { + "epoch": "12858370", + "root": "0x64a1a078ef896da0fd44b945aa22a55d6c9b422341dd40f2923894f828f56e6b" + }, + "target": { + "epoch": "11704123", + "root": "0x3d5fac78aff2ae1613bfeaee03117cc3609544ffd44bef7d36360d6874330056" + } + }, + "inclusion_delay": "8693777213307108943", + "proposer_index": "8685514792928721007" + }, + { + "aggregation_bits": "0xcc5861374d6036fe1ec66e99b4a426839fc0440c1ab4d71f1b42178e71c94713c10a269de8eb443ba317407d0ab603c85d9d51ef30b3c38e440d0c9c03cd93d7fa2da64cf547481c5e577746f9e814639f686924b09c130fde39f2ba325ec4e7defc126ae73a6a85d3afe9bd0a84f1ec7b90eb9be4b63b31ff36d1f947f4bb5ff455701399bc3f6679c48f7bfa30b6ce757b6fa110090a191e130148ab372999c304f6549791482c9f9d31add666abf5a20022249c276083bd47017e1980fc9e134230252e0035b73f1ad2cc21a25758b56435dab94b625495c763f6d343edbeaa11e8570b06328a7299631da4fe6aa180dad3eee596f51fd3f8bf1a84aadbdf01", + "data": { + "slot": "8687167280440372431", + "index": "8678904855767017199", + "beacon_block_root": "0x0fcb6b788f32470c9c9f5acc1bf25d93a4b63945aaebaf7d2ec3f302d65ce14b", + "source": { + "epoch": "10742251", + "root": "0xe98877784f9b8882b2198c7573e034f998b03b213d5a5e09d2c06c72219b7236" + }, + "target": { + "epoch": "3432022", + "root": "0xbf7198770dd5adbb180ae0e6dd2f416a852316cd4f256cab9ded712c8bfbaacd" + } + }, + "inclusion_delay": "8622720404924920365", + "proposer_index": "8621067921708236237" + }, + { + "aggregation_bits": "0xae7f7a6ffda8dd4a9ef96b5c26eb75647bb60ba60a9d45951d54a98a92195eb4f953a3859eb63bb4b62fc3437dcd76558a2fbd99bbdb61d74b50048ab5f6379474b930932b74a7cc2f17007c2acdf490fc2382a4640c6120a5712a6d68ae632f10511667773784ef5ac361b06c598e56e285a1cc512d3311b55bea44ab59a053d1c5c8ac84dac03f0eb54997660262da72b3e1c3ac410b0047aeadd4876587762bd5ea654853e2dd95d17c87430d93cc0a3a9815961fd7553e2553b3aac80fc0336b52094d07d6bf25ac1c97e756fb6a8edce3daf73370d7de47963fcde83862ca565f7d115428371ac809e89f5244cd6300adc26145a9afff42bebf495512d101", + "data": { + "slot": "8616110467763216557", + "index": "8614457984546532429", + "beacon_block_root": "0x45596f776de6c89dcddeb216a7edd005b1380fcb4ba289c2de754aa684a1ae98", + "source": { + "epoch": "1700652", + "root": "0x1f177b772d4f0a14e358e4bfffdba76ba43211a7de10384e8273c315cfdf3f83" + }, + "target": { + "epoch": "2085401", + "root": "0x91dd5777ed1446b1a2ea4fc4f510233aca440b1324c52cab957a58c7ee248cc3" + } + }, + "inclusion_delay": "8597933143789756557", + "proposer_index": "8602890597734776237" + }, + { + "aggregation_bits": "0xc8558181be3d7a7d3331500965eadeedabc379a4f5724b3455733be4392fe10aa4d43b4fac9ff7d663c8d698cfe55a4efdb9da5ccc6aa9e117c035b6d75a0da73951348f23caaa73e5434985665e2695122920cff37d8f51cac671fac31630d22bcf7c7fb2a16a32407f476bafae5ca5edc865f7324717efc77b312bdef7ce11905da24a2015ff445e563fc429db20b93fe152a3ec49ae79d50b11b88e71bb09b019b461957547d04a3058f5046e2020b1c337919d47c1f444a0652d9349ea53cfb63607f9b3551baeeb90a6d54460d2b259520de60bf92f9ebb86d07c779a62d900d2e5dfc72b84d8b0fca76e6adc0ee15f23500dbc3cfa1613241757db329f01", + "data": { + "slot": "8644202695331748622", + "index": "8649160144981801006", + "beacon_block_root": "0x671e0278ce83fae3da549dd9fc90cffe15ed27897c088e9465d8b217312cc60c", + "source": { + "epoch": "5740515", + "root": "0xdae4de778e4936819ae608def2c54acd3aff21f5c2bc82f178df47c94f71124d" + }, + "target": { + "epoch": "6125264", + "root": "0xb4a2ea774eb277f7af603a874ab421332ef923d1562b317d1cddc0389aafa337" + } + }, + "inclusion_delay": "8632635308519992430", + "proposer_index": "8630982821008341006" + }, + { + "aggregation_bits": "0x00134a4f403d8dad5040e28cc2782857d83876e9ba4f7106b20dbedb1799d11c170b817210ba96f24ccdd2ac8365c04208caa75931bfc32b651c33ac3d9d9ec50f552e422ad23acaf92f03eff61912173e056ca4244bdc2017d3bc45d29bfcca1525a86fd39289e08c275d54ba9901d805790e628766327b0590bdb0fea7b20df7c956ee76c88d59f5d40c63897aaa8ba144ce8f9b0e6f6408abd08d7ee3bf4eaf73a926e7c1427288b39e4fdc0da780f8a8bf897351cea070d4729dd1d2772fe138d9b6a0def14bd440a014bde0947993c26d9aa9d7ec38c7670aebdf57e45fa7cbe3ea5237f75f07a27ad9daf27d32bbe118344135774e4989a47bd5490ea901", + "data": { + "slot": "8626025375653255918", + "index": "8624372888141604494", + "beacon_block_root": "0x398ac177aec392d964350db71472b1ce5a0e1dcf52a84e945d6599b29355a702", + "source": { + "epoch": "4393894", + "root": "0x0f73e2766cfdb712cb2561287ec1bd3f4781f77a63735c3628929e6cfdb5df99" + }, + "target": { + "epoch": "997083665", + "root": "0xe930ee762c66f988e09f92d1d6af94a53a7bf956f6e10ac2cd8f17dc48f47084" + } + }, + "inclusion_delay": "8568188433004540364", + "proposer_index": "8559926016921119724" + }, + { + "aggregation_bits": "0xfab20ebd09d98cf74bc86e3860175cae9ed13e2f1e7910e035526b3328f712f7b4bea6c6dad06c631c6986b101e6c924316a520284da4c4dbbc63b636b773799f7a427d2e2aa286f47c5f5383a314b7f03208ed0fb94e36ee70a455a20094320257fe256f5a701d31976322bcf2021765cf2fb8667745e9a063b141aa98980d3e6e473eaaf3b33f05b52fc909bda116672a23165f60b99ab1d0ad83642349efa1ef50398ec3b1b331cb7c0dcca089b332cd0a0057344e499a0d84a9bc291451c2d9c8d4a9a7389b808a993eb19a177a9aa14601b89fb2f5ccd95f267572194a6b82d7d40a3a5f9666c0687aa7b3d5252dc42af8b19d7302e9942d7048a51565501", + "data": { + "slot": "8561578495842836556", + "index": "8553316079759415916", + "beacon_block_root": "0xbb9cad760ca6917e6a8002afee9076757f9cee9ccc81cbc1c41cfe76ab1d527a", + "source": { + "epoch": "996121793", + "root": "0x955ab976cc0ed3f47ffa3358477f4ddb7396f07860f0794d681a77e6f65be364" + }, + "target": { + "epoch": "994967546", + "root": "0x072196768cd40e923f8c9f5c3db4c8a998a8eae4a6a46eaa7b210c9814a12fa5" + } + }, + "inclusion_delay": "8550011109031080364", + "proposer_index": "8548358625814396236" + }, + { + "aggregation_bits": "0x549c8feaba41213e65d7bc01077a84d42439b84cfd21e309ee2db6340f74b60dba95bce07404ef039c20d14362502394a4d82c78e203a00ca5810d4acb8408fdfcbd1ca13c4c90f14154997062aeb6f8af463d5bfe22507b0031353602afa9f1e3cc5f4666a0b05d9efdd388bddde1b8b542d32a6b0fcb543b97fd2a1d26e70ff268c5f48f504367c2169b7f3c373cff0bddd50601cd4c4ed3a150697b67a9fe5f6eb1907c3699ce5f0bf797244029d9aa5f290972f46f92a311448e391f684a1935bbde536611edf13ca26f2916fb5f745d90e5868171c851384fa89a679287927e680ac685e7533099856b9e2649fddae57c8261ca170b2cbeeb86261e45a101", + "data": { + "slot": "8596280660573072429", + "index": "8594628177356388301", + "beacon_block_root": "0x2ae62877ed7140d84c028a1f9257c7a2fc5c03a3d70a737c03847409c12b4719", + "source": { + "epoch": "999392158", + "root": "0x04a43477adda814e617cbbc8eb459e08ef56057f6a792108a781ed780c6ad803" + }, + "target": { + "epoch": "999776907", + "root": "0x766a11776ca0bdeb210e27cde17a19d71569ffeab02d1665ba88822a2aaf2444" + } + }, + "inclusion_delay": "8578103336599612428", + "proposer_index": "8583060790544632109" + }, + { + "aggregation_bits": "0x024875a4ab2f9d184dc77c61e8bf68e257d2825ebad9a20fd5683d332539bd87163c9cb8ac03b1e3431146d9119d30a0fcde4c8636691d3b82e60bec82260511ad852070e85893ce7ae773e53967b98eee28e7877edd8124fdb664a5cf94fc052351347a6a602cb625d2616c91cc9e2e4504380190fb61e37426fef8eb4da220f1c5c7fc7401c12f7161dc3bd1e098eec22b70cfcabd7633af850aabd4b753470d0ec15cc32e2f1220d8b1facffffe1d83cbbda31369e9484f5f5ba2c17be1c9dd9abe77189651f98fb5707a107dfc279d154c0ab741d47e07d7d21eac1954db88fb5f104abe9ad1d57dc692dea5c2eb3a08ddbff1f34c898d6108a650bf10a701", + "data": { + "slot": "8571493403732875916", + "index": "8576450857677895596", + "beacon_block_root": "0xb0cdff764c835bba00d75c4f5c15573e2872fca0d3879093430c4d83b9d14ae4", + "source": { + "epoch": "991120057", + "root": "0x85b620760bbd80f367c7b0c0c56463af15e5d64ce5529e350e39523d2432837b" + }, + "target": { + "epoch": "991504806", + "root": "0x5f742c76cb25c2697d41e2691e533a1509dfd82878c14cc1b336cbac6f701466" + } + }, + "inclusion_delay": "8507046528217423851", + "proposer_index": "8505394045000739723" + }, + { + "aggregation_bits": "0xe0fd04d194a474a57d4fb41916cd1ef2d96a4e43bd23b0fd1c0de6670ea52499b2bb512922a9798365179fe0d86d12ebec922636a121d58b51f51a9a7dab3ac852ba17d5f97710bbe2e8d1856c735f42baad5380f4cb2e81a9983ba58184da88eb0e516b418aa7de9fb9efce6d72df60806c5c7bc5e49d2d84dd305b647029e1c7706dcc5a3291c956dafa9883310d25001718187bbd6cc49bba81823127fc2f6a9a50633d19050d03884ebe0f6fb28b277877ad9ba27afc7528323849e250bcc32f25bf96a54544677a4103fef2f42a6423b0c3fa59971a46370b123c373fb3d313cff7ee1f3d811409d727048985c0efbc6ed0b1881a314b7f9639dded232e01", + "data": { + "slot": "8500436591055720042", + "index": "8498784107839035914", + "beacon_block_root": "0xe55b03762b37dd4b3116b599e810cab034f4d126743e6ad8f3bea32668161831", + "source": { + "epoch": "989773436", + "root": "0x5822e075eafc18e9f1a7209edd45457f5a06cc92baf25e3506c638d8865b6471" + }, + "target": { + "epoch": "988619189", + "root": "0x31e0eb75aa655a5f0622524736341ce54d00ce6e4e610dc1aac3b147d199f55b" + } + }, + "inclusion_delay": "8495479137110700362", + "proposer_index": "8540096209730975595" + }, + { + "aggregation_bits": "0x06dbfd51f73073d2900db36d21dce51fc85be4c7e35e9a7c7e3fb505b7d9ba03e902313b9070ddef33a582f3284d8cf41f9c20f626860ddc1c413eb11b3f1a8757181688f56c4f502cbcd07450538d5754a411376418c1fc46aad31a4b6ca9e7b790a37dcc126203e54c80311ae506d8aa2fc209b4d6b2fe80f3faa656dec50fc76a366ae5ff9694d2393c4ae7835acf0f6085203bb54fff09333dafba70b072f9bf4f77e95ae000ce695764490d1937ccbb197996a6c11e2f4823b47d32b31f76a341b51533e459de384d42dde853f942958124fd692e2a84c6a3dfcf967fc3e265ca4f6c643013c2f30229f4f05eb7682ed672d5518ca1c6269005d7a245d001", + "data": { + "slot": "8541748692947659724", + "index": "8533486272569271787", + "beacon_block_root": "0xa02967768b3109b9e9a3d9b7dafa6c12cac0e27458eab47be92a28dae7a7eafa", + "source": { + "epoch": "993813299", + "root": "0x7ae772764b9a4a2ffe1d0b6133e94378bebae450ec5863078e28a14932e67be5" + }, + "target": { + "epoch": "992659053", + "root": "0xedad4f760b6086ccbdaf7665281ebf46e3ccdebc320d5864a02f36fb512bc825" + } + }, + "inclusion_delay": "8530181301840936235", + "proposer_index": "8528528818624252107" + }, + { + "aggregation_bits": "0x0206b70d2f33e6ab95f0353c9c22fa65db25528d7622421e882f98e30302ab100a7943165c59732b7ccfcf98bc1ae2febbbaa3e20a3155f6a86533949e9a216b04cff87f62ed99889dda35d23d36c8d34e85b602b3864c0b7f402a494af167bef78a87677f61fe0f6212dd4703ca663a59beecfc1161e851fba498b93c991b7eb099b282ab12629efc508851d02ec8aed80c49eb613dc394ac2e4bda61b5b3936833c50a126c012cb5471ec8c190d5b19943a34aee6fc7691aff3a8dcb18a2d1a93b12ae92c1844120e21e8afd2f7f0d1bab917ebd416e877064dbef200d672d83954fead2d6dc16ad125b0e36e7105b9156de62b9b56ef28f10a923016364e801", + "data": { + "slot": "8523571368974199723", + "index": "8521918885757515595", + "beacon_block_root": "0xbca4497b74453f6bdeedee9ac5225770973cb5fba1eac597d4affd3935125790", + "source": { + "epoch": "34019559", + "root": "0x9662557b34ae80e1f46720441e112ed68b36b7d73459742379ad76a98050e87a" + }, + "target": { + "epoch": "34404308", + "root": "0x0829327bf473bc7eb3f98b481446a9a4b048b1437b0d69808bb40b5b9e9534bb" + } + }, + "inclusion_delay": "8875550444451774356", + "proposer_index": "8880507898396794036" + }, + { + "aggregation_bits": "0x9e6bf617419110d3a780f5e993af121a8ec7140af0e4c6963f6760483ee7d9843ca7832ea927f642dc84c47100a241011640ea0489aceee8e384fbc0a71769ecdcfa03bce6a27e58234e03b2cefb782c7085358ed757b5bfb2daf92a4b803a466ce1594b09d7653065138530eeeb57de05da682354a1a6b8675f4c8171714f69ff86a32f5956dbe7dbbcbed382a2df2bc1d18ca69beccf18c1ec965835b4cc32d9a0eeeeda74af1f1f0e6db393ebb65e2b7ac6744dd632e7a1accd5d9692806888cfe6f1fbd9f9d9d749ec0b76d30ef0d80c353522d7039cfeab90ca38054d7d80b929ae72bbf125162ae79229a5f91721cf4787ea7d4de284ff408941edfcda01", + "data": { + "slot": "8868940511585037844", + "index": "8873897965530057524", + "beacon_block_root": "0x428c207bd4565a4d93c2c1ca8ee0e60bc351aef99e67e3ae1538d6b32db85a5b", + "source": { + "epoch": "31903440", + "root": "0xb452fd7a931c96ea52542dcf841562dae863a865e41bd80b273f6b654bfda69b" + }, + "target": { + "epoch": "32288189", + "root": "0x8e10097b5385d76068ce5e78dd033940dc5daa41778a8697cc3ce4d4973b3886" + } + }, + "inclusion_delay": "8910252609182010229", + "proposer_index": "8908600125965326101" + }, + { + "aggregation_bits": "0x4e52159df308bd184895d0d2986b0a1f76732eda779e13612ed4b71023b84d2b56546158f9519106533a066d02ff410f888153671c04554cdbe7c0656bdfc9f4128e4c80b4746053aa97fa947dbfb7bde6fc265812c5cb7259d5249a34a5a350839242d58284b1b3055f077ff2bded973f2e6ee1dd2a2e3c1ce148f718db92c8de078c31a36d38cd97a7fca32e408226465275b9bd9b03013ef800072ee23816b700dfa80bdcb96154be7c9f547eccd1ff677233c859158606bb292bc5cdf886e360d5d78d718aa97350c09b5acc2ec5acf647c8eb3376de48151104efa8b4b4bfa042bc8169c34bc6260d116a3a08224fdce1bd9208e8a01e62f967f0ebf5e301", + "data": { + "slot": "8903642676315273716", + "index": "8901990193098589588", + "beacon_block_root": "0xb1d59b7bb42209a77544493b32a737394012c3ffa8f08a69549f4c4643c64ffa", + "source": { + "epoch": "36712802", + "root": "0x239c787b74e8444434d6b43f28dcb2076524bd6beea47fc666a6e1f7620b9c3a" + }, + "target": { + "epoch": "35558555", + "root": "0xfd59847b345186ba4a50e6e881ca896d591ebf4782132e520ba45a67ad492d25" + } + }, + "inclusion_delay": "8898685222370254036", + "proposer_index": "8890422806286833396" + }, + { + "aggregation_bits": "0x5e068cb5dd66a6da63ad503ef13cdb691d9982482334f02757f6f6979fd7662d7af19140232a1f27881ec497f6ecd09f11278281d92e4c419990faaa27b1900f36b69841b5606b589162000983763ecb16b2dd82973a5a4b225e5d1af08ed6b2298d8f61ae7049773174b9949cad90314eae968d17ea0c9393f06b46a40c79af998c0ceb465e8ecb20f1fea64913265e0e2494eab307aff29afcc283c838f42fdd56a5ec74ec6fbc4858dcfbde629011f87ae0b9a3ed030ee7b5a427f98872a64eca686cd138ca1711e7529420f521e76798ffe74f919fa915fa88f43f76b352a32405323c88374d0ec244b16ca9e5111715c345ee2db383b7bf7b85d54ab4c301", + "data": { + "slot": "8892075285208550228", + "index": "8830933380421433715", + "beacon_block_root": "0x32e8877a1305084c7b8f3e330dc6fcdf65a094cd23ca0797bb56b10a5b8efa71", + "source": { + "epoch": "28440700", + "root": "0x0ca6937ad36d49c2900970dc65b4d345599a96a9b638b6225f542a7aa6cc8b5c" + }, + "target": { + "epoch": "27286454", + "root": "0x7f6c707a9233855f509bdbe05be94e147eac9015fcecaa7f725bbf2bc511d89c" + } + }, + "inclusion_delay": "8827628409693098163", + "proposer_index": "8825975926476414034" + }, + { + "aggregation_bits": "0x842357fecfaea928f3371dede7f6408f6b7760e0b81fe7a74228d49958b40f2a4fa33cc0593fe094217a412da915bb3ace148c70fa42ae0cf18dcabcfba96d957b30cb9afc93708cc46a475152b2f901e1c87719522078565d3dadc5aa3ba3eba6b9e97ebe56b78dbb5131d5feb0a1db5600ec9894794e83cbb930c8a5b26432981264d7d033688657c0b868916cdf6819ecb7b19c6d336bc35e4b2fc4e238c2bcc6ea37db26094100b4c2807299be60a8c2dafda3459ecee11975de4cd082587ced0e081502286d78339cc2c381cd435602eee57251b5fe5a183b7b0f13a649d3c731581a9105f86703ac155d03ae3490130c5c821fe713069ac30c121389ad01", + "data": { + "slot": "8821018476826361650", + "index": "8819365993609677522", + "beacon_block_root": "0x0454477af244a0410470ae1025a7deafaac18913f869c896b2e397a5bdb7db67", + "source": { + "epoch": "25555083", + "root": "0xde11537ab2ade1b71aeadfb97d95b5159ebb8bef8cd8762257e1101508f66c52" + }, + "target": { + "epoch": "25939832", + "root": "0xeeb5eb7a73ff33b9321d6351ffaf9f41fb6ca51b0776523ab1c235bedb1fcd3b" + } + }, + "inclusion_delay": "8855720641556597523", + "proposer_index": "8860678091206649907" + }, + { + "aggregation_bits": "0x46002c321e5aeed75e7d0eb472e66a63d1be96e405d0e8804a0fccb6939ab1b4177bbcda612666ce7a80d470103f01e1b915499009e722af049cba0ad13752f7f4deaa82f0ec2967db1e9a1a34803e2c0bf3346a4c53de3577b8c57a7980a1959d6659e7105710d48da91e2a39eff1e1db555aebe7337c5ded918bd70f480ad5dd08bc73767e5efbd7237c3b97fa900a14bf38e13d74987256b39243cdf4c6ff2f0bb35bdf41d6049df57e3b24c8354ace1d5429ac3baa3d3f70c4725b457e73d3e56a8e24b98a38805911e7f05346c96285dbd07e6506d298e5cff5ffc2c198d091bbc2896aae4194eb6b29ee79f7f3172997662ef697a6db9355b00019aadd01", + "data": { + "slot": "8849110704394893715", + "index": "8854068158339913395", + "beacon_block_root": "0x2719da7a53e2d18712e698d37a4adda80e76a2d12ad0cc683a4600176a42f3db", + "source": { + "epoch": "29594947", + "root": "0x99dfb67a13a80d25d17704d8707f587733889c3d7084c1c54d4d95c888873f1c" + }, + "target": { + "epoch": "29979696", + "root": "0x739dc27ad3104f9be7f13581c86d2fdd27829e1903f36f51f14a0e38d3c5d006" + } + }, + "inclusion_delay": "8837543317583137523", + "proposer_index": "8835890834366453395" + }, + { + "aggregation_bits": "0x024b6d5c643a1fc930aa8c3b97679c98913ad7bb3bfdd236ecab53c7398c10aae0b0162fd1330decf7c050c20f6b0b654ee3f4b4f862dca4b622ee3a3b4394d28b58b14aef7671de357a44f082a71ca6a5bdb151bb659564e4bd3965358b4d1de3c43f745a53f36377f62d708cf22f35027451351734c9a95b040f1f694c71f18e5aeb53232b2d60bce1addc4c3337101b93bed59a0379df4c171336fd6e88d9b429a036ad8f71a3efe6a3c9b1a9f89ce2f6ec715c0f9dea1d4055e472ef719fbe6d85b75da50fbb32ac287fdff5b234c99a24c7fff909c3d27847c159604a3ebf4bcfc91512f0825bddd73499b113871cef4e14425fb8f9859bfcd0968ec3d301", + "data": { + "slot": "8778053891717737841", + "index": "8776401408501053713", + "beacon_block_root": "0x5ca7dd79319653194325f11d0646501b1bf87757ca86a6adeaf856ba1887c028", + "source": { + "epoch": "22092343", + "root": "0xcf6dba79f15b8fb602b75c22fc7acbe9400a72c3113b9b0afdffeb6b36cc0c69" + }, + "target": { + "epoch": "20938097", + "root": "0xa92bc679b1c4d02c17318ecb5469a24f3404749fa4a94996a1fd64db820a9e53" + } + }, + "inclusion_delay": "8773096446362652753", + "proposer_index": "8764834021689297521" + }, + { + "aggregation_bits": "0x58e7230f289f19561ef6008ff99bad40dd1db66befd224da7fc486290a9b830bc45433131509f57b87b590fb67ce0639757f016e4ec7434228c9f7d76b1a2dc0ff38bb9b3185aa2be8b0f37648cfc3ca1e8a7ab746baaa130e67c2b6e3b8f3f59296334d3cec67d1e23b720e49c90e3f687fc09a5720232058f587235e624133af315b53fbdc9a5543e71d4d68b8a1d4196147365f342ff81dec7a9d81b3a25e0aff54a8af466c87ab566732df8c840b46fa6add4cbdbd42ea49a9c039f9d30470d1dd076f295e1b371751833a6a41a4726afd661999f121cfce93475d9e4a8eb1fc1525a068f6a118292055f27c9deb0ac095a530107fb9f546a88fd097ddcd01", + "data": { + "slot": "8766486504905981649", + "index": "8758224088822561009", + "beacon_block_root": "0x7b97857991046922a111fea86c4a841f782569e57a490a96998a4b76e4337f49", + "source": { + "epoch": "19976224", + "root": "0x54559179516daa98b78b2f52c5385b856c1f6bc10db8b8213d88c4e52f721034" + }, + "target": { + "epoch": "24977960", + "root": "0x64f9297a12bffc99cfbeb2e9475345b1c9d084ed885594399769e98e019c701d" + } + }, + "inclusion_delay": "8807798606797921330", + "proposer_index": "8806146123581237202" + }, + { + "aggregation_bits": "0x4e66a65a9b47175c1cbdc22004607034f55d4208d9ba44390053cd277588a7b509678335b18db41d077c4329edb8f2bba0e137bc299eeb41348d831ceffd7e867124a3c9a9eb03301e27debf38113c50bafce8dec104319aa056bb86e8ffb924403de8c8377cd15dc32a86e529f402f581cb9c33cd51b4f6c771ef165add23af5996690fdb37c9c0db233b62971c8547610ac3fdb2f375afd5079392586716494774f690ff03fc0faa4ac01829f73c75dca56ba0472d345d6cc16df1d1767472a5b2c3d7ae26478caba3621c0f0385e2ac8f03986eb3b431db0de7e890d478948bde816b8150e8946de220a61e65a6403c7257ba6a50119c41f2061535efff8b01", + "data": { + "slot": "8801188669636217522", + "index": "8799536186419533394", + "beacon_block_root": "0xeae0007a72d0177c839385191011d54cf5e57deb84d2b150d7f1c108fa4174e8", + "source": { + "epoch": "23246590", + "root": "0xc39e0c7a323959f2990db7c269ffabb2e9df7fc7184160dc7cef3a78458005d3" + }, + "target": { + "epoch": "23631339", + "root": "0x3665e979f1fe948f589f22c75f3427810ef279335ef554398ff6cf2963c55113" + } + }, + "inclusion_delay": "8783011345662757521", + "proposer_index": "8787968799607777202" + }, + { + "aggregation_bits": "0x94cac2b1e27155df214b4c0d2e5f95a6d938baf28304bcfd4a1e904babf46816b98eac09d2bd0e9c43d2139e833cdf2f9c4bca65857b241fba530bf53c85c7fc1f7caa58e7090714c2edc929f67821388f4b0b2a14134fcd58c9c0d63ece06d63428e8eb03cf5d6e54e2a9b8bddea37fd4444452a5c1331dc49c67ba65761131d0bbad9b43d47a1564a18972978137a2f3fa3a37f5560b89c4a6ea3da4fe348aeb9a475fa4a9a4235efa0fea0f88444c8c89ae05c758197533e8add7bb1052e9e9fe9f67883a6c3f226b1012aae9065387775a194eff6bc05bb117670cba384484e99fd5348bfbedc604dfc730888d0145ddb20bd0bb5ccef129779a5bf4efd101", + "data": { + "slot": "8723521924092325136", + "index": "8728479373742377520", + "beacon_block_root": "0xd2ea1b79d0551cfadfc640b64ee9f58ae95b57294c66e8acd09f0a8b3e03640a", + "source": { + "epoch": "14974489", + "root": "0x45b1f878901b58979f58acba441e71590e6e5195921add09e3a69f3c5d48b04a" + }, + "target": { + "epoch": "15359238", + "root": "0x1f6f04795084990db4d2dd639c0c48bf0268537125898b9588a418aca8864135" + } + }, + "inclusion_delay": "8711954537280568944", + "proposer_index": "8710302049768917520" + }, + { + "aggregation_bits": "0x58a12b77b4a3a0c501a1ca9a8bddeb1d88aea6850db986cf66930b6864e2552120051cbce49022b9f85f170a8ee1e5c3e838577a78bc5ae480a84dad17c020b89af08a94fa9396af6da991c80c8c51f6b36fe725e36077fc41dc88c962d16a5e4c4fa870c8ed9ebcf4fba6e3db9bf52f3461072654b0a28ba603e3628fb3e84da6ef7cbb14d929ee8fef5b272c5e30ac2a4ca65b78b1c2641f46634932e02a98e288517366256099e4e9701006eb897f55e23454b76e13228dd81767a5aadc0c8cf271fec1f6dbaf50518118cf68928db4fa2d8e894162c3c86d9636fa88f1c2daa367d6a1b33266085a52aa46d8223d087bdb7e98321dec8fe3e2aec16ba9c601", + "data": { + "slot": "8705344604413832432", + "index": "8703692116902181007", + "beacon_block_root": "0xa556db78b095b4ef69a7b09366cad75a2e7d4c6f2206a9acc82cf125a12c4500", + "source": { + "epoch": "13627868", + "root": "0xb4fa737971e706f181da332be7e4c1868b2e669b9da384c4220e16cf7356a5e9" + }, + "target": { + "epoch": "18629603", + "root": "0x8eb87f7931504867965465d440d398ec7f28687730123350c60b8f3ebe9436d4" + } + }, + "inclusion_delay": "8753266634877541329", + "proposer_index": "8745004214499153393" + }, + { + "aggregation_bits": "0x9492f0aad776c73ae1e7c7da5ecc55f31a1f1f8102d4a9c834d8df158de4aba7deb48ae659b9a6fbb8f802393c034f789ba091334b111693cc7d7a273f434c8bdb11918020ed1c1012f90aba22ec8fe34d3fe5ea5e358099ef4f54f621fab92151791ee0852e41610a15d15c8a8dad919d28b95d638ac977fc09505df021026baeb11217f2d4be2d8f4c8dc75ac8ef7f651f3b7bf8994935899bbf243976079563440e45aa2715c03cac6aec60880251df4fbb80a95e0ed14f3d84ff982f352f2baa197060491bebe0878d39f8ed2d0418a79059091bfb930edb4bd809a99461c964aa6e3389bc949e68a7e675a3b156eb21644ad4dba33d23aa4db2d7e193a801", + "data": { + "slot": "8746656697715837521", + "index": "8738394281632416880", + "beacon_block_root": "0x60243f791090e05c2035d5b158b47abcc3495dbd06b2f34fbe9875d920be17ca", + "source": { + "epoch": "17667731", + "root": "0x3ae24a79d0f821d335af065bb1a25122b7435f999920a2db6296ee486bfca8b4" + }, + "target": { + "epoch": "16513484", + "root": "0xaca8277990be5d70f540725fa6d7ccf0dc555905dfd49638759d83fa8a41f5f4" + } + }, + "inclusion_delay": "8735089310904081328", + "proposer_index": "8733436827687397200" + } + ], + "current_epoch_attestations": [ + { + "aggregation_bits": "0xd84302696f1b99d5dbfaeeb37fe46aca6f18f86d110f25e0cad5147c7c948b9f8ebcfcf8ba9f3730387b8085f8a68b7f7b5fbcacd9cf18db75e773718edd32bd16cb81e0af157b3d469eefe84bd475a211134e6564ae754b833b2a12182fb473108f8121c44992d623716ae77782cd46c855acd0cd3951a1d24b4c6b03b74cf7995d1f48e106cd0871ff1c0a5646d298127a1f9672684fe1daee973f3cf88d5993a5d930e7797c42d5393051186a793e675f976580248cea9232ea4e43781bf170ac194032ada2ce9313b959392df7ecf81618a178252754e36c643484c4b1320a2cc7c5fbc521ec2ed141aaec938b344d3fd5c553f29ccc48087e3c3bb953c601", + "data": { + "slot": "9098635781783346745", + "index": "9096983294271695321", + "beacon_block_root": "0x7c9f217ef9a3160f157fea9443dc641a90c52f444fb2046ca91d4b396e28845f", + "source": { + "epoch": "57873991", + "root": "0x555d2d7eb90c58852bf91b3e9cca3b8084bf3120e220b3f74d1bc4a8b966154a" + }, + "target": { + "epoch": "58258740", + "root": "0xc8230a7e79d29322ea8a874292ffb64ea9d12b8c28d5a7546022595ad7ab618a" + } + }, + "inclusion_delay": "9080458457809886745", + "proposer_index": "9085415907459939129" + }, + { + "aggregation_bits": "0x9c87b1a4433786f3d6ce8e5e9a86a5f4cec2dc4c416664a663d39f7d88fabb38887d7cf2208e6d5867ce461fcfad8c6662b9fb41d12525e72498d5e4e5db637bd672fdb12d05783065311d30b4057195697f70afe471f4707a3e5d22c0808b93da40cb95c48d37169ad2dc05da821cf131d731ffd4f51d3a15fdfebabff48bd0be5714da5475eb4acac95f2c389142bf9b8eba55b8f4f5d2544815bff6217af7c67bc1dc0949029fc8cb5a3f9255abf67d4a85ce369ebbe87a7cee25ff8a3650d71f95fdece02370b9162d4a476468dd005fac48c8d5d267f2f5a9e47ebbf7941831418d7536dcea0a31025baad126a6e5c4f7adfb8f632e6cc73d3e160812c001", + "data": { + "slot": "9073848520648182937", + "index": "9078805970298235321", + "beacon_block_root": "0x0187f87d59b531f1ca53bdc40c9af4b5bcda28424b2f2283e9a523b366ce872a", + "source": { + "epoch": "61913855", + "root": "0x112b917e1a0784f2e286405c8eb4dee11a8c426ec6ccfd9a4387485c38f8e713" + }, + "target": { + "epoch": "62298603", + "root": "0xebe89c7eda6fc568f8007205e7a2b5470d86444a593bac26e884c1cb843679fe" + } + }, + "inclusion_delay": "9115160618245155322", + "proposer_index": "9113508135028471194" + }, + { + "aggregation_bits": "0x541e780fd30f083b11d7ff6f85773fdbbf16c79ec61d40416ca04a229d141c1fe0acde8f34d8da18cb7380220ee11a206db862ae578dca030adb32590f3edbddde03f3a8fcfb666f94a2ac4b8f40b30c5156aaad0deb8a3fb8bbbeb207b40bc735f35f8b40ec1811ff864606645442aa1a29117f5a65d78e62135b0cc5205da1bfdf30ccf90c806c02971d7e993b3ba5ad0527ca6c870fc1bd5ccbeced24af20371b923940e0cca3c7fbc21b5bead35da51f81b9f7071bcf6c6b076468c1e63ebeaa91dafb1a95303fad00c22f1b58db748af6253649b3674344780099535f1f27012ed9ee86e4949e9dbadda969f79f98cf558511b2e636fb6a11e0a78d7bbb01", + "data": { + "slot": "9108550681083451513", + "index": "9106898202161734681", + "beacon_block_root": "0x70d0737e3a81e04aacd54435b06045e3399b3d4856b8c93d280d9a457cdc7cc9", + "source": { + "epoch": "60567233", + "root": "0xe396507ef9461ce86c67b039a695c0b15ead37b49c6cbe9a3b142ff79b21c909" + }, + "target": { + "epoch": "59412987", + "root": "0xbd545c7eb9af5d5e81e1e1e2ff83971752a739902fdb6c26df11a866e65f5af4" + } + }, + "inclusion_delay": "9103593231433399129", + "proposer_index": "9042451322351315320" + }, + { + "aggregation_bits": "0x4cb430d99baec9e99e29e71320c83b19937fabec0ae36cd5f61793ecbe7197ac414df03bfee922cd87dd8471b60d16b664f29732fb68ed4db4358292585020e5a46eb8692e03f6024a48ba4d45696e6df672024b36b575e84061457ad3842c6904a554b166db40a34a4229dcd0fee2229622b8db3ae03ea565b3f264a80ffde6aa7ee4ccc8bbbfe1a7102fef0f1a88b886f5cd102d60294af4febad5d8eb05c4b3912363430f95ad545b94e031e76940633f8316d7ed3766b847c21283c781a47eaecb7ec58ef5c5b91f46f4cad69b4b7c5eaba4aa6d2b9666af88093d355de7f877d4f05b2bd2311d3b47e8cae498ddfeec2e34ef75a166afa0273de81547d701", + "data": { + "slot": "9044103809862966744", + "index": "9035841389484578808", + "beacon_block_root": "0xf2e25f7d9863dfefb2203a2d8b7f0a8a5e290f16d091466b8fc4fe0994a42741", + "source": { + "epoch": "52295132", + "root": "0xcca06b7d58cc2066c89a6bd6e46de1ef522311f26300f5f634c27779dfe2b82b" + }, + "target": { + "epoch": "51140885", + "root": "0x3e67487d17925c03872cd7dad9a25cbe77350b5ea9b4e95346c90c2bfe27056c" + } + }, + "inclusion_delay": "9032536423051210552", + "proposer_index": "9030883939834526424" + }, + { + "aggregation_bits": "0x9c49fa0c6a293dc8814c7382f8e4d761803988a40dacd49f488e3aa162b0af96bc18db1df0d29b08983251c4261b68bcd134193733dfb5436081cd8e5951ce89e3ba54baf49772b1c83b5d8ee00463a9da16e95ee94a191ff4c83f8d406b12bc149078a0518cdc5a451860e848d1aae4791b97063725e721ce6f92f36649a2c6b9cd78668d5049e147d19b743c77cee9a19b097a1d7010f9e3e2c8a463664c74a61c8587b2ba1c80ff75fd5e7b3aa502f6d61d27dcbc058399c8f683f5fd3c2c2184d8256278bfcdd6c554b8201e6bbe847a65b0086f4801d905f1d912ae4c99dbc758796098123d63783bde54409111561c3e349bbde187e6be339b06d567ce01", + "data": { + "slot": "9025926485889506743", + "index": "9024273998377855319", + "beacon_block_root": "0x612cdb7d782f8e4994a2c19d2f465bb7dbe9231cdb1aee25ce2b759caab21ce0", + "source": { + "epoch": "55565498", + "root": "0x3beae67d3998cfbfaa1cf3468734321dcfe325f86e899cb17329ee0bf5f0adca" + }, + "target": { + "epoch": "55950247", + "root": "0xadb0c37df85d0b5d69ae5e4b7d69adebf4f51f64b43d910e853083bd1436fa0a" + } + }, + "inclusion_delay": "9060628646324775320", + "proposer_index": "9065586100269795000" + }, + { + "aggregation_bits": "0x746e01a43cdc5a972d1e71013b743f8f80783522a443deba20f9e58aafd612c5e389e70dc02f3df8e0c1561bf433c4f39d2e40e3403a65308c11ee1cf14b687efa1715cb34894e2f9d6bd47cdc36bc9c925bebfb7afdb76a9ff942d61ad18941388f86a8591e11863ff06b4f0946fa5ec65001fe6b77c19d937758ce40a3ccad3cd3118a3a9d4e1a8632cda64044099aee688c1e9d5a9398525750806af050793510b24b2c2ef18c6294c70f39590e7edc659ef193f1a866d348e31ae83ed0cb1c48308a53ea7cb06f87d1bc87ac7065bbdec6f58857d3790bf075f5e1bd09f3c8b9d7e3e2a3b1eea040cef02d2c0a4294a684cfe3448923388dbd27105f052501", + "data": { + "slot": "9054018713458038808", + "index": "9058976163108091192", + "beacon_block_root": "0xe613b27dd840a92b497794cdf803eb5207ff1c1ad7970b3d0fb44d16a35820ab", + "source": { + "epoch": "53449379", + "root": "0x59da8e7d9806e5c8080900d2ee3866212c1117861d4c009a21bbe2c7c19d6ceb" + }, + "target": { + "epoch": "53834128", + "root": "0x33989a7d586f263f1e83317b47273d87200b1962b0baae25c6b85b370cdcfdd5" + } + }, + "inclusion_delay": "8989571842237554039", + "proposer_index": "8987919359020869910" + }, + { + "aggregation_bits": "0x16d976e12693b23a08acbde650c069dcb680ff0882b8c4b8ea5936add86a811a77087b940ff0b40df209d4aa1f0ac4c839636547d230e4a03e16bf664e802d13b08210667c368c168f70fe7a09a8dc50471f1ffdd1e23aef8fd209165253b78498fcc7a4f27a92e71cc3ddb5e2a11224a8386e6c188cf83b9b17962d6bdec45d8d60a37c75ef1cdaa9816e953a549c6dbac87c4da6e18e652644db810b7ba541daec633c9a0e9f9b54c43ac24d0c422d3807fbddb83e09b779b7a8910914423d88bd26b76d5d203ddf51201725041860d2b84afc5b43bd75f114a0b87b2266839349170e722326fc4802be617718c52d455221e5eb07220739b9abb8bdc7b2a101", + "data": { + "slot": "8982961905075850230", + "index": "8981309417564198806", + "beacon_block_root": "0x1ca2b57cb6f42abd7ab6ec1784ff5dc51481f29f784ee581bf66a4b9519dedf7", + "source": { + "epoch": "45946775", + "root": "0x8e68927c76ba665a3948581c7a34d9933993ec0bbe02daded16d396b6fe23938" + }, + "target": { + "epoch": "44792528", + "root": "0x68269e7c3623a8d04fc289c5d322b0f92d8deee75171886a766bb2dabb20cb22" + } + }, + "inclusion_delay": "8978004451130830550", + "proposer_index": "8969742035047409910" + }, + { + "aggregation_bits": "0x420dce9e0a1cab3c74167f3abe890baa6d5bd12d574087ee503835b9b010e39173e15c8e95a0be6d3df61218e801d7de601530ab135b9a9dbc35bcc50dee7c4330bb00b77422cd13a6ed9a8bda79d16a2771a52a7013fb54b61358ae8bea82b734ff9c90bf6e1e2528290b73ffa8458077329f45d07c9aa0240715bf9d9d8747c8ab852e84beaa3e12d22cf87783b059a13fc9fc4e0836568954bb6202275528912c57fa66124d4fe8135b26d61d9d6d1402694541e7b60f11318d9595e0cd346e8292063538600bb9e7b1945f5d071a2ab2f659f7a7149b6cd11de98fe5a0f589dc7906cb50e33c10fafdd8330fbe1ea9bf209f237ad1251cce5018c571c3a701", + "data": { + "slot": "8971394518264094038", + "index": "9016011582294434679", + "beacon_block_root": "0xd76f197d17ef562a3144113676e90027a94d03ee5cfa2f25b5d2286dd12ec0c1", + "source": { + "epoch": "49986639", + "root": "0xb12d257dd75798a046be42dfcfd7d78c9d4705caef68deb059d0a1dc1c6d51ac" + }, + "target": { + "epoch": "48832392", + "root": "0x23f4017d971dd43d0650aee3c50c535bc259ff35351dd30d6cd7368e3ab29dec" + } + }, + "inclusion_delay": "9012706615861066423", + "proposer_index": "9011054128349414999" + }, + { + "aggregation_bits": "0x6c2a0059b9c0a3357a11b4d5596d65dac781814e6008761b5ba6205bc985076bbf8c50e238342f85ce37c4c619f42d0cceca42d7619b74dea733d4288d916592e7ef3dc466c5452e3072b0c34aef2ec1213274ab36af78e5792a48abeb2a002276543591fc3faea22933df24bf1d0d5aa6eee72788250d26c9877cadbc72e5da1845363285d6e82d0b00ca9e603e10c41a5d3daeb2de677555bf11398be2e0fd5177f7a3b55ecbb37cef682c32732703c6fda47a785f16041ee8cb343e6cd242faeb9c9afd19fc2c8e5daa546a9c332f7ef10ec538cb45ccdc539cccf2b9aaf8a3c78f4caa59cc0b7139b7e9d7345cf1ab7cc3944b32ae40b8f0749263a9627301", + "data": { + "slot": "9006096678699362615", + "index": "9004444195482678487", + "beacon_block_root": "0xa9dbd87cf72eef1fba2481138ecae2f6ee6ef833329af024ac5f0f083358a1b7", + "source": { + "epoch": "47101022", + "root": "0x8399e47cb7973096d09eb2bce7b8b95ce268fa0fc5089fb0505d88777e9632a2" + }, + "target": { + "epoch": "47485771", + "root": "0x5982057c75d155cf378f062e5108c6cdcfdbd4bbd6d3ac521c8a8d31e8f66a39" + } + }, + "inclusion_delay": "8935039870317174037", + "proposer_index": "8939997324262193717" + }, + { + "aggregation_bits": "0x0682ef02c167e3bf500533a276c36120817844b632e61bc584993d15dbd87c801a3d67567315c7c4df0b80f525722610d8b6f388c7fe7b317bdcc5e358699cb3d3f730d0382c054eefb8864404cfa18d8eb09cc7bb300eaba1d0527ead9ebe8003417be0c3c13690bcf5f09d4fb62c00e0645b4e2495e6afda63d425ee9cd5d09d6f022338245aace594becd228e8600f1a5d05077683136454e2a84b77bc3bce2f14b7ff784d3f3a93f3cf72c3f5bb0c2f5ecdb7882123ccaf48d891f3ff49d247fd466d7150abd08d4d06f9fbf70bc5cafd374cec78f79d1e4ecd54245d203fc6565f45f029e2abadf4aceb2db32b0812180231a714b103a390a6d0c31a4af01", + "data": { + "slot": "8928429933155470229", + "index": "8933387387100489909", + "beacon_block_root": "0x92e5f37b55b4f39d16583cb0cca20335e2e4d171f92d2781a50d588a781991d9", + "source": { + "epoch": "38828921", + "root": "0x05acd07b157a2f3bd6e9a7b4c2d77e0307f7cbdd3fe21bdeb814ed3b965edd19" + }, + "target": { + "epoch": "39213669", + "root": "0xde69dc7bd5e270b1eb63d95d1ac65569fbf0cdb9d350ca695c1266abe19c6e04" + } + }, + "inclusion_delay": "8916862546343714037", + "proposer_index": "8915210063127029909" + }, + { + "aggregation_bits": "0x4acd06a4062100e772c8b46fc8d05dd942eb6581aa1b24ef29677278d64ed597c7e4eb616d1580254302956541bb2c84a501429d3139137a3b3481b933bc5aa5057b749d27b4c5e70394ce3ed602d24fa4d6babe5c4636baf0f11e414a413a4b78a62fe9ad65d5292e2af7924d93f8b61bfc783892f8db3bd9655bdd4ac8ae1ccebfd01301fb28118e9a0bfe567ea11ff10a5420c98cd0af1fe2e4b2f5e5959efd5336018fd8cfd1bf6cd5453e5c9c518b9e72ceac95886bc2d5b4165eb74b2490d13fd3bccaa49f3ead497e883d2450feaca4f1453b9e3ecb70f454e1f5a338c2a229f3c27a16e965e1e5d4c7dbec8c9e65e94642f8535876831b0992ab94d901", + "data": { + "slot": "8963132093590738806", + "index": "8961479610374054678", + "beacon_block_root": "0x012f6f7c3680a2f7f9d9c320706954625fa5e67704b7ce3be474ce1c8e278678", + "source": { + "epoch": "43638282", + "root": "0x74f54b7cf645de94b86b2f25659ecf3084b7e0e34a6bc398f67b63ceac6cd2b8" + }, + "target": { + "epoch": "42484035", + "root": "0x4db3577cb6ae1f0bcee560cebe8ca69678b1e2bfddd971249b79dc3df7aa63a3" + } + }, + "inclusion_delay": "8958174643940686422", + "proposer_index": "8949912223562298486" + }, + { + "aggregation_bits": "0x88ee5d2a77d173589f88b8731650b01973e6d385b2e72fe263e422632f684b192c6d54b3fd002dc123b18052f39b925fff0b8a5a8b8c9bcc57a1a50d191a775a12dfaac5a7cafe4c5c804fe75212954ad4d578dffb17d1c69b51e6fef3ab00346630cdfb6ee53af570d29d7d3c64a28eb8b1e7516bfaf085aacfc0f12f4ac4934b67ad87ae340f4b1e797f38a96efefc1e58ed28e9a479d68e2f7edffef3f9a1645e085d735a325c6b8ddc9a7d2e0f7da165f8c8b580278810bda78a72652917e6fd5d79ba1825626c7b4c7b883a198bc0791da44307114e1b84f0f80a520638d1dcc7491ac9ab73921b34ab76e36f6b1dd251547a3125e8c9ba35318025981201", + "data": { + "slot": "8951564711073949910", + "index": "8943302286400594677", + "beacon_block_root": "0x1f1f177c95eeb70057c6d0abd66d8866bcd2d705b37932249206c3d859d44499", + "source": { + "epoch": "41522163", + "root": "0xf9dc227c5557f9766d4002552f5c5fccb0ccd9e146e8e0af37043c48a512d683" + }, + "target": { + "epoch": "83459793", + "root": "0xb6b222811ef1d2d0983b135ff8d7e2285e39b18efffc25293d03c0beae98ad63" + } + }, + "inclusion_delay": "9310153723713228350", + "proposer_index": "9308501240496544222" + }, + { + "aggregation_bits": "0xd30d67ca5d1d2c37a0d4901e237c5d202e55152ba0a596c1d8e93f60de39ab293b35336d7d16082eb3a2ca6f0fe06cf93f2d854198722395fc7b0f45088209ec9a501ee8683a6e28e9c3a0b4b967ff131affb2a2db150e1c3e5e8f4e767ec467a7661f181d196620e8202b86e16bc6abe550f7c5496afa01feb9e6f4a2588a979402a2e17f66e4a580ca2cd7ed2d47403839814c6366deeb520a14f47bbdfbec8d9eda003c0509924378960510ef6c123121d5ed27fc87a1e980cd57efc1e78d2f7d441d4ed7560ed5e1791e581a8041a04a35dcd98ed28dec33d610426f5f5a0384e962b01d2e2b22aec4774e916c01ba3d45ec48b83a19a05c3eaf6a595cac01", + "data": { + "slot": "9303543790846491838", + "index": "9301891307629807710", + "beacon_block_root": "0x3b9af9807e02eeb24d10e68ec19572c4894eaa8cfc7943407e8b9838a73eb12e", + "source": { + "epoch": "81728423", + "root": "0x155805813e6b2f29628a17381a84492a7d48ac688fe8f1cb228911a8f27c4219" + }, + "target": { + "epoch": "82113172", + "root": "0x881ee280fe306bc6221c833c10b9c4f8a25aa6d4d59ce6283590a65910c28e59" + } + }, + "inclusion_delay": "9285366466873031838", + "proposer_index": "9290323916523084222" + }, + { + "aggregation_bits": "0x392f1e720cc96b40858b8f5f422db5dfae102dae7c5adccc88a20c4f515d16f6e294a72f1509aa4c65119fb3b7c856f25c6582bd7af7dbc30aef1ff2e21c65cf87f4cbb166057587aed799475553393626a9b0074c6a6bf1517ac111985dd399aeb86d1b4789a1fdb6e81079a078de95dc15c9b43a53d0ba8e932de987eec47b15dcc257d9baf7fe10095a14873f084377fa1530e64e3d82f9479a8862bbd78136b3c410f445fc8fde1998cf53af1cbc93b85f7938e9b942a36b1c8ad2100eea182124b3ff43f65326a6757b7b008a83949e00ab5bb64dbd18d742bfb15e18c812d216c23037a4f86090332b1da8ff4051869f5e347794c80e64a0133897be4201", + "data": { + "slot": "9331636014120056607", + "index": "9336593468065076287", + "beacon_block_root": "0x5e5f8c81df9f1ff95a86d051163971bded02c34a2de0471205ee00aa53c9c8a2", + "source": { + "epoch": "85768286", + "root": "0xd02569819f655b9619183c560c6eec8b1315bdb673943c6f18f5955b720e15e3" + }, + "target": { + "epoch": "86153035", + "root": "0xaae374815fce9c0c2f926dff655cc3f1060fbf920703ebfabcf20ecbbd4ca6cd" + } + }, + "inclusion_delay": "9320068631603267711", + "proposer_index": "9318416144091616287" + }, + { + "aggregation_bits": "0xf56dc5b4f3893a5d647b89ccc76f8b75cdda01d820a7e27f031ea13eff99bcc1554f0d9ae521610848189b80c80ddd2e3b13f7ca8fd0818d98457dca0961838d5198e9ed6bdfb52a1af3c32fd7beb99448895cb4bb50c34800ee192eef423a81c01ae912a92e424716c71763d21d4c252ca41e6a8f31e8060cf4a92063cf9d4572083df7ad6fa1435ba26c03f0178e1ce75299004fa8bc0b8de6493d0e31d3962929910b829de92f226af775434fcb2f8b81c361eaffb2009153e419909b400ef0bfcb1a264e6bd29013ccb10a04ff72afddfd78d46e4c88c35bc2a2137c89676b1146f8ad1ff953b2c63f562838736e3cc077bb58fce1cab2dc0d77f64c625501", + "data": { + "slot": "9313458694441563902", + "index": "9311806206929912478", + "beacon_block_root": "0x30cb4b81bfdfb7eee466402f2e1a538d3224b89003800812fd7ae744b5f2a998", + "source": { + "epoch": "84421665", + "root": "0x06b46c807d19dd274a5794a098695ffe1f97923c144b16b4c8a7ecfe2053e22f" + }, + "target": { + "epoch": "77111436", + "root": "0xdf7178803d821e9e60d1c549f157366413919418a7b9c43f6ca5656e6b91731a" + } + }, + "inclusion_delay": "9255621756087815645", + "proposer_index": "9247359335709427709" + }, + { + "aggregation_bits": "0x4f489d1dbb2949dbfd6781246dd08affc33341a8ba494f58c8637fd144b02532f2f67bae7f2039d91c8587b9e081c39a00ce22d338f56e43068b64245c393be92d600ae9a5a4f50a8539f4b0cd9e66d8e7b8bed646893c8cf82de170315584efa248f12ba7d3f27fb11970754297294fab2f67a78ba087473b51619c74e13f9fe324d9f314991542b4a49f58b03939383daa72e79c1c0a48b0077a3e3aecf270aa8b26f10a63b05dd61e29f61d6266bc19cf41cdeaa7bc29665e626966cc2794326397fb10832be494e6d60facf1ade6a4e22499f647ce2febf9322d3f0ab79e51bf99d708ecffae5120c23501c75f3c2c9f9b0ce49fae9a42055d8ab95718cf01", + "data": { + "slot": "9249011818926111837", + "index": "9240749398547723901", + "beacon_block_root": "0xb2dd37801dc2b693e9b135270939183458b2895e7d59853f64324c09cdba5410", + "source": { + "epoch": "76149564", + "root": "0x8b9b4380dd2af809ff2b67d06227ef994bac8b3a11c833cb0830c57818f9e5fa" + }, + "target": { + "epoch": "74995317", + "root": "0xfe6120809df033a7bebdd2d4575c6a6871be85a6577c28281b375a2a373e323b" + } + }, + "inclusion_delay": "9237444432114355645", + "proposer_index": "9235791948897671517" + }, + { + "aggregation_bits": "0x3960d50a28f5d2525b6c474b003d6793e9fbd550ed217e5dd7ec099e731703d85cd51080a590f8c39aed106b087f2508c11174c95e05e2461b4e26e45cd26abdb33cf7967d525d1703aad97a410bb173a9c8ac574031a697371cd17e5c364ab8ecf15e27a08842c0e13bc594362361a5b2bf8f0dd3c0120470f149a0501fcd411688efad14fa45c10c72fe3d977c1c6301cda48c4dca996b46fdd1e8932d45664ad415ed5c717293cdaebdec9acc1442814247f4571f173268dae44898534197ec82c968d1d623fc01fd07ab94f288d01a81d9a3c1acd77357060f82d3c8f9b1428c5c3879cce01f30ef0844edec68e31a5c1c0f98d5d6bff631ab8a4f0f5b1801", + "data": { + "slot": "9283713983656347710", + "index": "9282061496144696286", + "beacon_block_root": "0x2027b380fe8d65edcc33bd97adff6861d4729e6488e22cfaa399c29be3c849af", + "source": { + "epoch": "79419930", + "root": "0xfae4be80bef6a663e1adee4005ee3fc7c86ca0401b51db8547973b0b2e07db99" + }, + "target": { + "epoch": "79804678", + "root": "0x6dab9b807dbce200a03f5a45fb22bb95ed7e9aac6105d0e25a9ed0bc4d4c27da" + } + }, + "inclusion_delay": "9265536659682887709", + "proposer_index": "9270494113627907389" + }, + { + "aggregation_bits": "0x7db27c151ddbecf155f40702e46d84404238fd6618f97dbb6fd50a994d7b027b507850d80dc4b6f147dcc7d5f2713b9edb27352e80affe7b5b0f012a1f903a6953058e4ba9065c1a3014a3a1aec8b64b89a45784c9c6f70e6f959c9ed0011b4e0ee627338004eea2d4b13bf69f2e941364fdfe60c82fb2bfc782ca60e6580848550565bda1bd67b59e07bc5bf9273c33843b164d8e27a75892ebf13b3b77af4c2b02b939255384497113f180309d929286d5dd5fee83312b899940cf043645be410944c31d866340737a11fa27a91670e9aa4d88c06c368404ab96532316f7474179bdc6e5269729e81b4b9f246fc4f542b13cd5f08eccddd04de0ac67fb1c1801", + "data": { + "slot": "9258926722521183901", + "index": "9263884172171236285", + "beacon_block_root": "0xa60e8a805d9f80cf800890c776bdf8fc00889762845f4a11e3219b15dc6e4d7a", + "source": { + "epoch": "71147828", + "root": "0x7cf7aa7f1cd9a508e7f8e338e00c056eeefa710e952a58b3ae4ea0cf46cf8511" + }, + "target": { + "epoch": "71532577", + "root": "0x56b5b67fdc41e77efc7215e239fbdbd3e1f473ea2999063f534c193f920d17fc" + } + }, + "inclusion_delay": "9194479847005731836", + "proposer_index": "9192827363789047708" + }, + { + "aggregation_bits": "0x06c71f73161431d86b644b791b4ad670ccc1314e372b7689a12edb91e2e7f1a4c5f3ce4182396f1363db144c59063f451d4a56871b85afafa7da7054e0e917807808abef3f3adf4b202d3615dd7654e55cb5e3006ad843a102978f8ef4442dc2ee91481ebbf23941ee5aad9156a89cfba3b5116bc9f34fb9c5e105d1adb546c9eeb92eac2b8c85fd38b49f40b17da9fe4a9fca1eb79e2faf86f63b2acdbe12a6cce260164b33aad2a361068454894f010a55394487cd000e99cfafc6ecabacc1c6a07fe2921dbfdcb3ada4c21193eeaf02e8f7b1a65f6088784b5919f19fb4f31be9fbeb09fe387b24759b38f74b0a9db64512df999d8cc2d861563faaa16ddb01", + "data": { + "slot": "9187869914138995323", + "index": "9186217430922311195", + "beacon_block_root": "0xdb9c8d7f3b530261b147e81102b96b6f0d0a6de82516245693d4f1b88ab31ac7", + "source": { + "epoch": "69801207", + "root": "0x4e636a7ffb183efe70d95316f8ede63d321c67546bca18b3a6db866aa8f86607" + }, + "target": { + "epoch": "68646960", + "root": "0x2821767fbb817f74865385bf51dcbda326166930ff38c73e4ad9ffd9f436f8f1" + } + }, + "inclusion_delay": "9182912460193975643", + "proposer_index": "9227529528519283580" + }, + { + "aggregation_bits": "0xe3a545f845c4d2af06344a6d2c033acc1db9cacb5fee1daceb0903ae0bc84deaab62d4532486eb753e2041fbca24834a7e501c56b80127b8c3c255c74c6968f629b5e897b420c2f56ff96dde57b40a70d5ac2133db0974126587772953b55e2cd097a8063270929fd082820e955b4e81a7f81512bc9a6d229bd9f6aac90e044123a9d6821c51b60f585749926e6c76150d6c562a23bedcc0245df607d63c5cfa7fe67f5289174b5e7ce01e5e13eb242de4a0b3180ec0b5fe03a6fd52f95bd39cec381b041fa77ea04b7b28e76234e1f23e794ae6a4c58bf082d4edb68099157902b76a49cb1db76273416f0446335bd8c1ffe9ccad580a171749d801bdab033901", + "data": { + "slot": "9229182011735967708", + "index": "9220919591357579772", + "beacon_block_root": "0x976af17f9c4d2ece68d50c30f4a20ed1a3d67d3609c26ef98940766c0a45ed90", + "source": { + "epoch": "73841070", + "root": "0x7128fd7f5cb66f447e4f3ed94d91e53696d07f129d301d852e3eefdb55837e7b" + }, + "target": { + "epoch": "72686824", + "root": "0xe3eed97f1c7cabe13de1a9dd43c66005bce2797ee3e411e24045848d73c8cabb" + } + }, + "inclusion_delay": "9217614624924211516", + "proposer_index": "9215962141707527388" + }, + { + "aggregation_bits": "0xf67c3defd9c717932353de66927dd3140ac32dcad082d42754988f496b2156dd4c39fff3fcfdc4b3742e46a4577eec40ce72531ab0067f90536e389a01cc3f5b2e61a64737d0644ebf0fe10cfe1166742889a316349128a1c16ece63153880f7c0bc960e352504e4d2f19f110d5426071ae1f8fb087c3084bb4cc421658b203271999ac2d0bcd00e1675af43fa43607192068f6021a240f7345bf0ea09e55f9b4b69e87374222a731fa657e252f6382f954d86e607819f4f533ab84fce654a8eb7af481a805982b820a16b03dbcb1500a72c97f890e59876564a15e66d0604037b27e7cde1b793ce1d2a1231d4635b44614ff1cc51e9e6c45a44a82d726b682301", + "data": { + "slot": "9211004687762507708", + "index": "9209352204545823580", + "beacon_block_root": "0xccf8f47e7a01b05f9914657a809e8143af5853bcaa78483e39f3cc0fb889badd", + "source": { + "epoch": "64799471", + "root": "0xa6b6007f3b6af1d5af8e9623d98c58a9a35255983de7f6c9def0457f03c84bc8" + }, + "target": { + "epoch": "65184220", + "root": "0x187ddd7efa2f2d736e200228cfc1d377c8644f04849beb26f0f7da30220d9808" + } + }, + "inclusion_delay": "9139947879380319130", + "proposer_index": "9144905329030371514" + }, + { + "aggregation_bits": "0x0e5c4393e160579d3caf851371cad6cd52adc7f01475a942c7e544257141df3ce4c5dbc3beccdc700442021dfbdae1b6f49c27c10e67f0fee9a008555e1688235eaecfbdfdab666b29c5f69a3411ba35b33860708d9e57f649b4e732cb0bfe05f1ec963f1810c4d4672cb0e4d95f268dc7eba073c9c1dd2db4c54e1d286712a4fcb43e4e2c4f62029ca15f18f9ec9f9989f3c68b664532fc61faa96f747e7d0f7ceb686d3ef9f67f7a2e807134bb1292b00d171245fbb9f784452a78f4276a357b0188aba745d54c052234bd5d22c6918c984a4b38c1588450fbc5f1417404fb755509f1504711b5f6a8ef20fb9af50d1626613d294b2584da95faf20d733aaf01", + "data": { + "slot": "9133337942218615322", + "index": "9138295396163635002", + "beacon_block_root": "0x52e0cb7eda12cb414ee937aa4a5c11dfdb6d4cbaa7f565557a7ba589b12fbea8", + "source": { + "epoch": "62683352", + "root": "0xc4a6a87e9ad806df0d7ba3ae40918cad01804626eda95ab28c823a3bcf740ae9" + }, + "target": { + "epoch": "63068101", + "root": "0x9e64b47e5a41485523f5d457987f6313f47948028018093e3180b3aa1ab39bd3" + } + }, + "inclusion_delay": "9174650039815587707", + "proposer_index": "9172997560893870875" + }, + { + "aggregation_bits": "0xeee4891241f9e91d8ab2b42c7a1b6cc99a8b9a33db4fbd15f253c36f6dc95949d73753bddc8ef9d455dcc40a6bdf7294a31d2e629aebde7e41c36de530d32c99dc7dc099ee74e872e8500979177d180d66c172e76445a939eb7170da96084109144e093b175149d106003ae38728b284fd5622a336410f9c4329c21a76cc07174d3553f8953005b5d40d1cc66d0463159979f615003a786f9acd7f95672fb82e1799baa96a56d1c9219e817cdfae2f3cee38a89962269395474784f93320128f1e9ab28f9d7dfe3c653d5a2ddf14e492f8699a9692dd69c6d466040f27883e744b49e8b2c227fb9f222c5683f027046a7024cb11611a60f4070973a5cc75757f01", + "data": { + "slot": "9168040106948851195", + "index": "9166387623732167067", + "beacon_block_root": "0xc129477fbbde799b306bbf1aee22620c582e61c0b17e0d10b8e21b1cc73db347", + "source": { + "epoch": "67492714", + "root": "0x33f0237f7ba4b538effc2a1fe357ddda7d405b2cf732026dcbe9b0cde582ff87" + }, + "target": { + "epoch": "66338467", + "root": "0x0dae2f7f3b0df7ae05775cc83c46b440713a5d088ba1b0f870e7293d30c19072" + } + }, + "inclusion_delay": "9163082653003831515", + "proposer_index": "9154820236920410875" + }, + { + "aggregation_bits": "0xa220299d55d6717efe0296c4815206dfe1a0384387651dd24912ef7a918858c49bdff1303481fedd9aec02b015d77140bb3bfb8dc2c5c00282bc4b3917653d409d4434ccee2cfb79d7d56589c8ac1d3fd74abe7accb8b8a61334211252bb90f3d09140a6efa5d49799caec01aa2ded23069c0acccea60e0784bc134eec9b04364a6ca1fe7a5727e44f4c1eec06574745b68ed7c74aea425c0ed7dc24ddf44f17785d016f104c479c964ae3157dbbb0c1e3bd3252c2d83c87ba4401578f549a87b815037cc732fe420bc48c260f057fa2112406f9f72de4b1919bf87e14efe842595cef68594486bcee801135b6f4c8fadacce3ed296b7a76a0b4c0a691e7244e01", + "data": { + "slot": "9156472720137095003", + "index": "7826223142295852378", + "beacon_block_root": "0x8f75966cfaa05bdee8957d48abbcc1f03dcf3b8b347be4b76f2304ab019580e5", + "source": { + "epoch": "911477035", + "root": "0x6933a26cba099d54fd0faff104ab985630c93d67c7e9924313217d1a4cd311d0" + }, + "target": { + "epoch": "910322788", + "root": "0xdbf97e6c7acfd8f1bda11af6f9df132556db37d30d9e87a0262812cc6b185e10" + } + }, + "inclusion_delay": "7822918175862484122", + "proposer_index": "7821265692645799994" + }, + { + "aggregation_bits": "0x64df6310c132f4237053db213837e388510bbf5b0b3fb7aefe6b1732f26b3011739dec93c12d831474c5ecb3b5fa8d932eef89cd244046a5b29fe0cf5d5c62b9d236ec08f28f244224798f1ee04cbe7bb031bb97921133b5051fd02334048aeea8d2d23916eb4ad275cee5537d4ec37591a45b163c0cf5284532cbe30ba327ef1cb1fd9f5c04c9d8bd89be436124a13aeada367e43911f39351f8cc1418eed9877e3ea827a59d371a835575eb73a8b7a4b1f48ff9e25b93e59ef3a4c0796711e87f3e74505c5cbb00a3dc6f58ce6059eb38d6042374ace438d4d630679530b109f050fc3901e117b96840b2e33c214f3d1c5f7dc9ae305c207f364f669821de301", + "data": { + "slot": "7816308242995747610", + "index": "7814655759779063482", + "beacon_block_root": "0x61e1556cd9e0f3d37176ed25c39da3c082f030d1091ba5b766b0ea4563be61db", + "source": { + "epoch": "908591418", + "root": "0x3b9f616c9949354a87f01ecf1c8c7a2675ea32ad9d8953430bae63b5affcf2c5" + }, + "target": { + "epoch": "908976167", + "root": "0x4a43fa6c5b9b874b9f23a2669da66452d39b4cd918272f5b648f885e812653af" + } + }, + "inclusion_delay": "7851010399136048891", + "proposer_index": "7855967853081068571" + }, + { + "aggregation_bits": "0x88f899b1b3c3135c9c91da150d26991113b20dde86f2bca53448c48b7a1dccde8d4492c1e72603763a24e9b40658760c7df54f8827adced3de0356f17fd80b56cebabc70aec93bad2b6987ecef3c7466fc24e9ac0462d4dc6e3c289ceff5b1108644601199fba12b2b12e2e8aa999b4b92a1476f4d869ed1330a20d8770ddf0c5d2b9139ea59db832d6e68819cbcb7f9a11aa74a43a06446ac424ce152189197ccded56fa0792e30a7d74784a0581c9666c8e22b8301b685830ea9c03a559e3f34ab064a88074ab5b8eb46f02356b234c59add13b7fe75735ff9f7ab8ac2cc73cc54c2690ae59ec843bcda1d88f6cd32f6df0d6d703a7156f688ca4a1b083f9d01", + "data": { + "slot": "7844400466269312378", + "index": "7849357920214332058", + "beacon_block_root": "0x84a6e86c3a7e251a7eecd7e81841a2b9e5a4498f3b81a989ee1253b71049794f", + "source": { + "epoch": "912631281", + "root": "0xf66cc56cfa4361b73e7e43ed0e761d880bb743fb81359ee6001ae8682e8ec58f" + }, + "target": { + "epoch": "913016030", + "root": "0xd02ad16cbaaca22d53f874966764f4edfeb045d714a44c72a51761d879cc567a" + } + }, + "inclusion_delay": "7832833079457556186", + "proposer_index": "7831180596240872058" + }, + { + "aggregation_bits": "0xc0bb40f67d94f0c6beef7cf3e8b42f9bf32799e2886fb217903845e4542bfbc95e8f0e515b006a77276fec844b932dcc8962f39fd4ca8618ccbbd089ddefc95a105e96fdb151fb54df45dc85bc5122adf2655197b255d8a59f997483abfe311ebda22411d3df42df2ba8e9b64ebc40937af5a7b9f9614346b559a4b4d776b4a83aef529ded0c8c7e5660bbf2aa5d49b2bbb53e32f753d549fb02dd1c9802b784f3dca802d4ed2bd0c5472b16b0bbcd1439af6c37fa37ac9fab6e387d5cad80d9c92769faa9daf8618ed35b6e54c22cc9ba01aa94782af8544c357fb26d40d5e4969ea27f951dc6038ceaf60dfde21d2c4f39e54838b17bb809935b6eddd761d201", + "data": { + "slot": "7773343657887123801", + "index": "7771691174670439673", + "beacon_block_root": "0xb934ec6b1932a7abaf2b3033a43c152cf2261f15dc3783ce9ec5a95abe8d469c", + "source": { + "epoch": "905128678", + "root": "0x2cfbc86bd8f7e2486fbd9b379a7190fa1839198122ec772bb1cc3e0cdcd292dc" + }, + "target": { + "epoch": "903974431", + "root": "0x05b9d46b996024bf8437cde0f35f67600b331b5db55a26b755cab77b281124c7" + } + }, + "inclusion_delay": "7768386203942104120", + "proposer_index": "7760123787858683480" + }, + { + "aggregation_bits": "0xfe5b5d808d2bb1d6a509d60f0a9b0e59bd60e99044f156d1022d16806a403e22dc4f6144a01380f2c301a2a77d31205b153a275466ed297f4245906089b57160643fbf1b7b3bbaf1008fe99ff351adb04456a7630d88a3a247043f597dc68e788cb42a28be79daec3c790660da376419af6ac514fb5588acb6dabc88a03254eea3d3849955ef3a0fada6896cbbf89e06e945e4d830a75282e22da623a5ddb48441f200dc8f67eab73955ffad9ef6a5a56dff3cc97a5683fe571316ba4f8f23420fc3254ecad61e9623fba791f123ef79f5e5732cd026326018918f39e19ee77589796d5422f644bc4d0f896c900da36c43c717bd22789cf8b94b0d91b8ce718801", + "data": { + "slot": "7761776271075367608", + "index": "7753513850696979672", + "beacon_block_root": "0xd724946b78a0bcb40e183dbe0b414930505410a38bfae6b64c579e168a3a05bd", + "source": { + "epoch": "903012559", + "root": "0xb1e29f6b3809fe2a23926e67632f2096434e127f1e699542f1541786d57896a7" + }, + "target": { + "epoch": "908014295", + "root": "0xc186386cf95a502c3bc5f1fee5490ac2a1ff2bab9906715a4b363c2fa7a2f690" + } + }, + "inclusion_delay": "7803088368672339993", + "proposer_index": "7801435881160688569" + }, + { + "aggregation_bits": "0x9c36b559beff685f831610647b5ef33917015d72c29b0430cd0759db5c4688c823e0756b1d3e019c87e87c6dafcfc4462061313c0501873e5202e81f096a3da2f222847ee5dd33fbce03c3522ae5761b4325b07a591459f398f766755e40083d420fd3042c786866bc545401aa82655bceaf6196a71c1f4fcb7c44b4a4f626d27f3db6c75d046898b1723ccd9d56efbd912e42f2ec23c96122628d3da70e6110a0a99ab15929206c32e948a6ea371f4b6f50f8a26bc208e5d08f100bf002bf14d0a8eb984a4c8ac5dfa13811c46477b709340f6327c847bc886abe9604d4b57eef09989d43dfdb0d3ec5811d743799836524c43652acfb8d4cf980d348e45acf01", + "data": { + "slot": "7796478435805603481", + "index": "7794825948293952057", + "beacon_block_root": "0x466e0f6c596c6b0ef099c42eae079a5dcd1425a995838e718bbe14a9a048fa5b", + "source": { + "epoch": "906282924", + "root": "0x202c1b6c19d5ac840614f6d707f670c3c00e278529f23cfd30bc8d18eb868b46" + }, + "target": { + "epoch": "906667673", + "root": "0x93f2f76bd99ae821c5a561dcfd2aec91e62021f16fa6315a42c322ca09ccd786" + } + }, + "inclusion_delay": "7778301111832143481", + "proposer_index": "7783258561482195865" + }, + { + "aggregation_bits": "0x6616ff0e625ea85583de9980d9b1e6b4590535500034c8d416580c3442070939059150ca602f791f137e34589fe3b8c7b80acc73bb64c0306cc8f9d6dc328bd886dbad7a3f2451de33fb55d060e42b53d91fde88c6cb264c404dbf3888f3fe533b5fd3bd8b43a8d50d8539be7b3bc5d908b0117e0facf1e6c09f1859997204c8769316e345f2de1da8e00f525fdf185213dc9954a9c277623b12b6b59b93427c2b2f056b3ad375036e5dde7d6c3a68d67f1c38072bf22ecd8692c627ef44948d023da3243d645ab0b81467e321cc9626b2f896d7c1e4895b85cc4e1a28aa95aff86ae3f7f6041d7855227e7a5298b5c027497b87aa47bc4f7d30d20ca7ed5e9101", + "data": { + "slot": "7718811685966743799", + "index": "7723769139911763479", + "beacon_block_root": "0x2f782a6bb7f16f8c4ccd7fcbecdfba9bc08afee65d17c5cd846c5d2be509ea7d", + "source": { + "epoch": "898010823", + "root": "0xa23e076b77b7ab290b5febcfe214366ae69cf852a3cbb92a9773f2dc034f36be" + }, + "target": { + "epoch": "898395572", + "root": "0x7cfc126b3720ed9f21d91c793a030dd0d996fa2e363a68b63b716b4c4e8dc7a8" + } + }, + "inclusion_delay": "7707244299154987607", + "proposer_index": "7705591815938303479" + }, + { + "aggregation_bits": "0xa2111e28883d498ce38d3e525c21591efa13bd7c0c8af6e6b8245bd04c110a0eba0afeaa501bd2393cfd20d8d492f7234cfa43624623f89b7e32af8eb765659599f79f0624ecb065e7878daae6081f9de5bdbee331dd3c0db9fa63a7fc6b165f46cd813561506b61ebfd3a05486c980ef9c4f3a8ba8544327a1c80c171486db4804d40e3d0afa8a425c6cd91aa16de58ba702d741721feffe9976147f48f5473249c5d064e0f702d4e6cd1cfe7598d596737a6d695c40d9b32b27e9c84fc22723bb6ccb3050dde624ca1db7904406cd811e3bb144a3890429f61c4088e8a6cb886283f682bbc016b9954f223621a2dde58bd10e4c28cb78d23ca6d64b93a2cc601", + "data": { + "slot": "7700634366288251095", + "index": "7698981883071566967", + "beacon_block_root": "0x01e4e96a97310882d6adefa804c19c6b05acf32c33b785cd7cf943c64733cb73", + "source": { + "epoch": "896664202", + "root": "0x1188826b58835a83eee0724086db8697635d0d59ae5461e5d6da686f195d2b5d" + }, + "target": { + "epoch": "901665938", + "root": "0xeb458e6b18ec9bf9035ba4e9dec95dfd56570f3541c30f717ad8e1de649bbc47" + } + }, + "inclusion_delay": "7748556401046927288", + "proposer_index": "7740293976373572056" + }, + { + "aggregation_bits": "0x4472c528dec82eb14ec711522120b6e2e26a40fb9074fdc5580b0b6af66f96d5e28b7a28d820515b695435b764ba699a1bec84a1a79670ac84e4d9d49dc50e2b40139e7724ca8ceee8d316731b18dd98bb623c0c860cdb78d2cc091817cb10a2de1327072ec2ac3cc14335da09fb4237d0c7fdc1585762c930107bae5ea713b2021789ed7ef39b33e1258be2a1a6d12b91a3901097293582765ae2be651f3a4c8591665b9ec2cda0938feeb5e52a26a50d9c9c10deb03b69e8d36b05b067c54bc4bf31b915b77d57f4efdb7c2feaff512f741e634c003b2e4d9c52a67dbd49b8ddb09ee2fb0788104d6e855f1368ae9bbaa7cf77aa17c01dae21eb589b3002aa01", + "data": { + "slot": "7741946463885223480", + "index": "7733684043506835544", + "beacon_block_root": "0xbdb14d6bf82b34ef8d3b14c7f6aa3fcd9b78047b1763d0707265c879c6c49d3d", + "source": { + "epoch": "900704065", + "root": "0x966f596bb8947565a2b545704f9916338e720657aad17efc166341e912032f28" + }, + "target": { + "epoch": "899549819", + "root": "0x0936366b775ab1026247b17445ce9101b48400c3f0857359296ad69a30487b68" + } + }, + "inclusion_delay": "7730379077073467288", + "proposer_index": "7728726593856783159" + }, + { + "aggregation_bits": "0xeeddffb64642d117de5910d5bfe3a1b4163621d0ac7fe2cdfd0665703459fd97d3d4f720a0a52bc8aca6b3093645062de5fa8043a8df89d4efe9e1a8c0ee8fe9eb970d6de33057ba97d0112d78af3b7e58f8c71ccb14e967ae9ee9d54d1ee57e7d8542803e6242dc5b0de7d1e56f77cd403e37a7e47c30ed6a79609b5e893c9f3709e34be8c76c2e30544f277dbd480744e9187f2441589f3dfafd236880c6e947414124c1826a9519c1f19f6d510ba96d40228ec48090adeb335a8c273713d1e6b22dd5f6b4be4cfddf9932f4de977f64dc5f6f51600938167ea52f67ae2e62f555a308ff7c5b21656f45bb8a8ea03539b1b052a6219efc472ddba9500babed01", + "data": { + "slot": "7670889651208067606", + "index": "7669237167991383478", + "beacon_block_root": "0xf23f516ad6dfb580be7a6c1182a6b23fa7fad900b819aab522181f1d75096b8a", + "source": { + "epoch": "891662466", + "root": "0xccfd5c6a9648f7f6d3f49dbadb9489a59bf4dbdc4b885841c615988cc047fc74" + }, + "target": { + "epoch": "892047215", + "root": "0x3ec4396a560e3394938609bfd1c90474c006d648913c4d9ed91c2d3ede8c48b5" + } + }, + "inclusion_delay": "7652712327234607606", + "proposer_index": "7657669781179627286" + }, + { + "aggregation_bits": "0xba0b876b776c4f90e701c03d5ac1582bcd6d4fc07cd5018bf4676873dc61d4949b3df33828ea654a731724d34a4a51f8b54c63ac5175b768adc0d70893d8ce3e1fae792564261921ae7fedb0257e354c39967dc147ab28fa56b5804b8184109cbb1a1a3452a2ee17f38f1331457c327bb1fc2688bd90d2660c6ad589a4ce7ff9344361751db44e02a1620d49b7eeec23d915f0b8ce8268a806fcbda2c05dbb590690f1f07b882c81840151bb834854f04c47b845f472a6002d799fa21cf19fd213112864acd17ff29b6a09270ce709569d94afc6d4ace04e8f8158f79e404914a9d1cc52601f3ea48989045afa558a27f57ab1ee7a50cd1e6553c0aba888fae801", + "data": { + "slot": "7646102394367871093", + "index": "7651059848312890774", + "beacon_block_root": "0x7827286a36f1d062724f3f414c6442dbd30fd3feb496c7cc62a0f7966daf6e55", + "source": { + "epoch": "895702330", + "root": "0x87cbc06af74223648a82c2d8cd7e2c0731c1ec2a2f34a3e4bc811c403fd9ce3e" + }, + "target": { + "epoch": "896087079", + "root": "0x6189cc6ab7ab64daa0fcf381266d036d24bbee06c2a25170617f95af8b176029" + } + }, + "inclusion_delay": "7687414491964843478", + "proposer_index": "7685762008748159350" + }, + { + "aggregation_bits": "0x4ab0ccd1d7d4d5da1894a9075770e8a5e59994136dafd478f754af2ed039e273fd8ec5c728b8c3ab1e98a28ec96f92e2526df2d786fffb4899a7e02c851d628a95fb377c34f8c6b82dcc54860e5a5bfd1e8b295eaa511617543a5df5d6aa09c85c58941a98c34a9197eac3369b28bd22ae43aa38238186e7dea41daf8b362aec018204c39dcf2988ed3c0ed3b047817bcb9e2123b8ed003dfceaa3f8d00c7efee5f622a74f2aa33cc1b25897ac512f5c1e10148a31a78508776253a33960c65a32b4b86e9b2988973f31a587eac82c68e92ed52b1e88950c1d1fb99b5b3cf2ddd6cc0c37fb3dccdb3d053ed2efec7d3a8f790324824143467c8c6c5ddcde779001", + "data": { + "slot": "7680804559098106966", + "index": "7679152071586455542", + "beacon_block_root": "0xe770a36a16bd7fbc54d1c6b1ef2a930850d0e704bf1f6f87a1076e2983bd63f4", + "source": { + "epoch": "894355709", + "root": "0x5937806ad682bb59146332b6e55f0ed775e2e17005d463e4b40e03dba202b034" + }, + "target": { + "epoch": "893201462", + "root": "0x33f58b6a96ebfccf29dd635f3e4ee53c69dce34c98421270580c7c4aed40411f" + } + }, + "inclusion_delay": "7675847105153087286", + "proposer_index": "8037741088520701279" + }, + { + "aggregation_bits": "0x9a100513325ea2322c8425d35b83883a334af0d619d85cfe9a8457415debba97ff700d625ce24744d6503b07f4bb301fec739228556a9522d2af28a8fce56ec53dece94922b4a468b97a2764fcb56c0690876e8f7e06be2999a08e9ec5fbdcf156834ffeefe7e5be944b7d5252198986d33dadf7905dd00ea36dc9c7460f7cbf0edd5d2645cb9dfb69d039df6cf096df72d349bb42b0cc9c022b7efb0d26619573645bd3c3184d8d2458317c74274cfeaa233134945602da06398d2242936ce01120e73bf579d51bac5a150200094516cbe5757ac954c82eb7e092325965f01e52b24844516a64a88c9de2c0a085966eafe2cd24f1894347a78880a79144eaf701", + "data": { + "slot": "8039393571737385407", + "index": "8031131155653964767", + "beacon_block_root": "0x4f706e6f7fff32821f2779422976cf9a3658b6d3e142238c439151aa3aabadb4", + "source": { + "epoch": "935331466", + "root": "0x282e7a6f3f6874f834a1aaeb8264a6002952b8af74b1d117e88eca1985e93e9f" + }, + "target": { + "epoch": "934177220", + "root": "0x9bf4566fff2db095f43216f0789921cf4f64b21bba65c674fa955fcba42e8bdf" + } + }, + "inclusion_delay": "8027826184925629215", + "proposer_index": "8026173701708945087" + }, + { + "aggregation_bits": "0x46885f83e3b4c40b0ff5a1802f3e35f24245155fee958096a4156a66184621ad8633b34213c82808c89e6e5960e05e1042d410046d45e9aa62032ffde92719695c39630d212ce2522a0ccb509af229c22dcabeaa313e72d8e94b752ff6543a390fbb7174dd003da79f1eb43ecb87cc40a4ad400ad85b8e8232783958c84862bf5d2743ac4a66e87badb89feefa1f1c9b01ad800170aca84336b30e2002ab12bc63f9e9bab904e4e14dd47940bcbe90d65dc34347ab4f33712796997ff18dc56adaf2b46d5686b143468102bceb53d3e367f5a93fc3f439ba8352aa26b2aec062271465e4ef921cacb05f9ee70293de52079ae521a11983156eb5dc597ec4c2cb01", + "data": { + "slot": "8021216247763925407", + "index": "8019563764547241279", + "beacon_block_root": "0xbeb9e96f60cbe1db01a900b3cd3c20c8b318cbd9eccbca4682f8c73c50b9a253", + "source": { + "epoch": "938601832", + "root": "0x9777f56f203423521723325c262bf72da612cdb57f3a79d226f640ac9bf7333e" + }, + "target": { + "epoch": "938986581", + "root": "0x0a3ed26fe0f95eefd6b49d601b6072fccc24c721c5ee6d2f39fdd55dba3c807e" + } + }, + "inclusion_delay": "8055918412494161280", + "proposer_index": "8060875866439180960" + }, + { + "aggregation_bits": "0x80a6e6039044a73ce6bbada0503e9c9ff2746fda3e688e937e3e3bb9d0219d627fb635d82ab78a68a16d7b5df8d0a11b39cc34c5ee34059d0e9f08671b84255a4bb926f96b4e28f9e454c031ffc27ed7c78b145daa459da98758af3025e66144b2ad9dc95083e87be1c6bbc1c8b3d4f6acac3c71a1d2a5735df8a775bdf20870187dc540fcfbeb244c5bc91c359e43689a583d19d0ae6f0ca4b6a40a11bd2ea1d28db63fe14d09bc90327392b8ddabf825388cc3b45b8dda6dfe8a91d65c20ad6b7ed8d3f63d193faf468ebdc0d1de395b45506ecf8cb1ce54a326c94999e2831070ea4c2d28807f37676f6303e50787444a3f73d9b02fc2b1843aa548cea42501", + "data": { + "slot": "8049308475332457471", + "index": "8054265929277477152", + "beacon_block_root": "0x43a1c06fbfdcfcbdb67dd3e296faaf63de2dc4d7e848e85dc280a0b6495fa61e", + "source": { + "epoch": "936485713", + "root": "0xb6679d6f7fa2385b750f3fe78c2f2b320440be432efddcbad587356867a4f25e" + }, + "target": { + "epoch": "936870462", + "root": "0x9025a96f3f0b7ad18b897090e51d0298f739c01fc16b8b467985aed7b2e28349" + } + }, + "inclusion_delay": "7984861599817005406", + "proposer_index": "7983209116600321278" + }, + { + "aggregation_bits": "0x96510b6a3f411b11f33341ca2d70d2cf5c6d2202b19af4e137dbf2903ab9ae393b15ba8ca5bb558d23acac735d74e3646da3747c578c2cccf08e1801e03f2ab3a88415543a22aefc757f62d1fb6eba3b31c2e15b03d37306f356e470557445cd9acafec37be623125a8d612660477483e3f59b5ef2c8599d4f8fbd86d25cd5a00941ba96eac839c0e5e06ab36d1c96bf08e6f76ae93570f39081a74bfc71f1031d1b2f01a2606bbb7265869f1d4c660522fb6f1d7e941caf459925e01ec0a1d9e7e34ae8392245a3678177c2fe6a16213567ac5298dc4eea2473fbc7df623b7b5fc872b8e9a8377d9d84cfdc7088c9cd94bc8f7c91ebc17775b00652c09e1fed01", + "data": { + "slot": "7978251666950268894", + "index": "7976599183733584766", + "beacon_block_root": "0x792fc46e9e907e4fe7bc2b2d22f622d6ebaf995d89ffc1a27233f759f7a3736b", + "source": { + "epoch": "928983110", + "root": "0xebf5a06e5d56baeca64e9731182b9ea411c293c9cfb3b6ff853a8c0b15e9bfab" + }, + "target": { + "epoch": "927828863", + "root": "0xc5b3ac6e1ebffb62bcc8c8da7119750a04bc95a56222658b2a38057b61275196" + } + }, + "inclusion_delay": "7973294213005249214", + "proposer_index": "7965031796921828573" + }, + { + "aggregation_bits": "0xd4056934ad2c04b7d277a9b24187babc8f260a56f472f7e31cfa68d6c8ef2ebe6dd4be1165ba5becdc582fcbaaf9e1777117349bef767238d2ab16d6a9c93b67a9bd3416e83ee9b546de9e5082afb301938879ceaaa6f2dfaf519351bddf3a3eba9da77737b2abfae427d7c5687c2b24bbd3ba413a01f30ea8182e05639992966e0c3864018d2b20f8d328d50ddb03a7011a529722d852c2669565c846fa0a7056c915cedc4a1d2fceb0cafbb733b89937c7fff7c4898ab5adc3f065b4a42d72814c7f5b15e7c5971d046fc10578d9432b3c3a7bbc1ce719368c46bfebed3db7010d45f107535b3941f49c61504885d9f041a3c1099033145df79712bd285aef01", + "data": { + "slot": "7966684275843545405", + "index": "8011301348463820638", + "beacon_block_root": "0x34fd276ffe8aaabc9e4a504b15e0c537817caaab6dab0c46689f7b0d77354635", + "source": { + "epoch": "933022973", + "root": "0x0ebb336fbef3eb32b3c481f46dce9c9d7476ac87001abbd10d9df47cc273d71f" + }, + "target": { + "epoch": "931868726", + "root": "0x8081106f7eb927d07356edf86303186c9a88a6f346ceaf2e1fa4892ee0b82360" + } + }, + "inclusion_delay": "8007996377735485086", + "proposer_index": "8006343894518800958" + }, + { + "aggregation_bits": "0x8eca88eb9c785e7ff07d76fd26cc46d0d54cbf24e238260ac761b4d8b66a894481b78a36dbff58a41eb1fe09414713e124c142f1ed9cbc71cdae741fa7162033fe6d1bf630f815ef404c309cf21b6caa5eee256d6e3e108620abe34df41178ab74362cde74a21a577705052438f36ee2f22a3a8b224566c5b592df3e5225e1231ee10ef811ee4917c1414832207a5e36d979b404dd0fcaa3a28e6d9fa4ab9c373af2b751884595a1c7a4fcf1f7b302ef3da0f27a5a2923beab1eb6421c3a233c9dec31d89926dca7b015d8467593d112d96e8006bfc6be650a13d7b006894b87770ef3fe0071948a22be16c495575676e2f6348c51de4d31b9f9f9401930521b01", + "data": { + "slot": "8001386440573781278", + "index": "7999733957357097150", + "beacon_block_root": "0x0669e76edeca42b2272bc0282cc1a707c69d9ff1434bcd45602c62a8d95e272b", + "source": { + "epoch": "930137356", + "root": "0xe026f36e9e3384283da5f1d185af7e6db997a1cdd6b97bd1042adb17249db815" + }, + "target": { + "epoch": "930522105", + "root": "0xb60f146e5c6da961a4954543effe8adea70a7c79e7848973d056e0d18efdf0ac" + } + }, + "inclusion_delay": "7930329632191592700", + "proposer_index": "7935287081841645085" + }, + { + "aggregation_bits": "0xd460d09940d91c34efb8ef234793d21a73455fd4b3044bec58266534e80348e3b832971b9186a2254a97be334bab51f99c17b73a6af90b1f177424e0fecf9133481336177ea287881d8603cf3c1bb3e7d0c7600971654701983319943e21c7050d2f64a44a15824572df7853ccd24624afb96e62caf08f04b67de206458fc3ad1bccbad8f819ffb63755baebb4e4a0d24b8bef9f18dceca8bfaf352a581e9cc8a534477bd3a704831b1ca06b69bf3eba69a478ef5f2a2f067402c0761e6d00695d60fd39c22aad311cfaa7b8f5dba2e9eba41d8a078e7ee004b377baae495f7ff0b80fd2b1870ab76959ebd5d8d93c35d0564b1f299da0f1b3102dbf742800a301", + "data": { + "slot": "7923719695029888892", + "index": "7928677148974908572", + "beacon_block_root": "0xef72026e3c504730835e7bc56a99c845b913792f0adf03a259daaa2a1e20174d", + "source": { + "epoch": "921865255", + "root": "0x6139df6dfc1583cd43f0e6c960ce4314df25739b5093f8fe6be13fdc3c65638d" + }, + "target": { + "epoch": "922250004", + "root": "0x3bf7ea6dbc7ec443586a1873b9bc1a7ad21f7577e401a78a10dfb84b87a3f477" + } + }, + "inclusion_delay": "7912152308218132700", + "proposer_index": "7910499825001448572" + }, + { + "aggregation_bits": "0x984f2389aa3bfde4894540e70210acf0a2df523a383944ded7a4e4c7a69d7ab809f11dffade6c33d83a6ba12435e8a2c68c052afafbef3d4e9ae26da353116153473440f718a9731ebe25aa7def615047e076a3a06763d704db6d1ab7c3ea3db72e4b42ea293619612346329ca259311c748acbcb8d739b017ea306ea68aabc16b984df88ecc880964e20ccc0d3ccfed910f7387a75d6d6de827a09cf788a8c63eae5094053b17a19d0d6dd9f8dcb8e930cfe57eaa3e34d67e6259c76cef8e4277ee93b2d9764091625f1b2a827ada61cd1be22b8c9e7fff1d3fef0b4dfd46d38e61554f26fd06fcb2c755ec8948d26b8fbb229b6136b158ff8a9cfbeef86c9c01", + "data": { + "slot": "7958421859760124765", + "index": "7956769376543440637", + "beacon_block_root": "0x5ebc7d6e1d1cf68965e002360e60197336d48d351568ab5c984121bd342e0cec", + "source": { + "epoch": "926674616", + "root": "0xd0825a6edde1312725726e3a049594415ce687a15b1ca0b9aa48b66e5273582c" + }, + "target": { + "epoch": "925520369", + "root": "0xaa40666e9d4a739d3aec9fe35c836ba74fe0897dee8a4e454f462fde9db1e916" + } + }, + "inclusion_delay": "7953464405815105085", + "proposer_index": "7945201989731684445" + }, + { + "aggregation_bits": "0x5e7cfa19fbcfbad32d053ef731000209112ae8bf31d64ffd17f7f2684cd3c7631660a5fd5f094a43f3153fdda174a4a61fc08d67ed5b73e315ba1f66b7ad307229f88d77f96e9e8eaea6174ce986d721808de81931239a1562b18d94279f78a5687ae6dee7108a5a2cb864b6bf92cdaaec44a2dfc50f1b6b26e0ef53915cd54a6f84355c2813aad1f430fb1f7bae0c8ef9fc66c39654840878aa4075e69a04fb8dc24c69dd3fec6c404e5501fcbe38c51bc046aaa1280036e0c3c858553ff3f19bf275b46ae783efcb1413238b7d91f27de7934ec8bee6c7cdc3ab86be12a3c21111f2c7b0c295df413510a29b3d412a4ca4d85da9ddcf9945b192a3c9741c5a01", + "data": { + "slot": "7946854472948368573", + "index": "7938592052569980637", + "beacon_block_root": "0x7cac256e7d8a0b93c4cc0fc174644d7794017fc3c42a0f4546d31579ffdaca0c", + "source": { + "epoch": "924558497", + "root": "0x566a316e3df34c09d946416acd5224dd87fb809f5899bdd0ebd08ee84b195cf7" + }, + "target": { + "epoch": "917248268", + "root": "0x2c53526dfb2c7242403795db37a2304e756e5b4b6964cb72b6fd93a2b579948e" + } + }, + "inclusion_delay": "7882407601727883803", + "proposer_index": "7880755114216232379" + }, + { + "aggregation_bits": "0xdc21d32141c5e577bd367666b37b906b56fe8f1615fdf0f90379c8648e105ce5243328f5695cb0f4276ba8e7d20fd122c9d3c50c6f0292db3fa51f38f29594f9e58f920c251dd59ed88f40fa285131fa63461a99fe7f982f02d45369af2a5fe8cb6cc699ef383132a5c8abb4f787ba20753b688a603a097fe89fd2679c4afaf73e589db2b7744c896307bef1a081f99e7fb66a00373c4815391e3cd8cd8dfa5edd53421552cdcf1d4ea80e1860d5129773386856a1d894e4b781b9f1843a87e9abf355d02ef528adf3205d501389f1c23d4ec6428d5ec4c593630f1ba459f41fe9f4cfadb0955ee42174f2720a95e684eb2e016c8dab8229bba1a30e55cd558501", + "data": { + "slot": "7875797660271212699", + "index": "7874145177054528571", + "beacon_block_root": "0xb23a296d5b3e8d24f50b680b0060c0e9a183544965e1e889f6856c1cae1f9859", + "source": { + "epoch": "915516898", + "root": "0x8bf8346d1ba7ce9a0a8699b4594e974f947d5625f84f97159b83e58bf95d2944" + }, + "target": { + "epoch": "915901647", + "root": "0xfebe116ddb6c0a38ca1705b94f83121eba8f50913e048c72ad8a7a3d17a37584" + } + }, + "inclusion_delay": "7857620340592719995", + "proposer_index": "7862577790242772379" + }, + { + "aggregation_bits": "0x1e1328252534a24010727074e66aeaa1f50f743a5b00dbf80b56581a4636e07afbba3aed192136b471daac30622f1b7ca2c106c67aa75acc527169428236fe0aea269f3cef63f13557dfaa037671ffc56b4178f46b4227db6553cec65d084d96d7f32c8aeda2f2ed9f6494491b96695a785e76d111f26647b2b40c18e8d896323bc0f39c901b5ad3f3e668212e95ee7d3147d30ab774ab68abf3c0b5c49f975b641e3d9ad60b73d011e675c3263e71ba0983e212fecda425f962e849b3fae64a843b314e954ae9d1ca7658543b9bce18095b77718e6e7db74196afa57524d51cb0a05c116446c0ffe7080f36dbad77c13c389afbc17236bc455a09b252c7174e01", + "data": { + "slot": "7903889887839744764", + "index": "7908847341784764444", + "beacon_block_root": "0xd4ffbb6dbcdbbe6a028252ce5603bfe204386d079647ed5b7ee8d48d5aaaafcd", + "source": { + "epoch": "919556762", + "root": "0x47c6986d7ca1fa07c113bed24b383ab12a4a6773dcfbe1b891ef693f78effb0d" + }, + "target": { + "epoch": "919941510", + "root": "0x2084a46d3c0a3c7ed78def7ba42611171d44694f706a904435ede2aec42d8df8" + } + }, + "inclusion_delay": "7892322501027988572", + "proposer_index": "7890670017811304443" + }, + { + "aggregation_bits": "0x522cf961f5f24390728ad7b203685c0af4d05845d53de75aaeaad638ea90d2cd4a319212a7101891ddc1a80044e3417d46f4891767623207049b2f1ae9733d0e1c26ad71a3fba48c03b773e9f4c5d74c0160f4c9dc7a577bac56c6f9b63af11cac313c83431911577b3f93530df134afacce9525a7ddf3d590628f925c9ded1d681c22b081e6096e7809ff265b6090c3a9c9536c19d32ae77e5661031309804af9ad0937245fe6f836b57a71bfd5307800a85e434edb8741895270daff4878686db15c6fc6961315facfe5cb4c1d9af133d24e76c8ba70b11a0a339ff3072036ee68e014b93e8b1c301e595f6e8dde9f6dde138c89bbfdda89c099c2c88c6b2801", + "data": { + "slot": "7885712563866284763", + "index": "7884060080649600635", + "beacon_block_root": "0xa66b7b6d9b1b57608c62c2ab6de4a0b24959624d6ce7ad5b7675bb28bcd390c3", + "source": { + "epoch": "918210140", + "root": "0x62417b7264b530bab75dd3b53660240ff7c539fa25fcf2d47c743f9fc65968a3" + }, + "target": { + "epoch": "960147770", + "root": "0x3cff8672241e7230cdd7045f8f4efb74eabf3bd6b96aa1602072b80e1198f98d" + } + }, + "inclusion_delay": "8250911517962234308", + "proposer_index": "8242649097583846372" + }, + { + "aggregation_bits": "0x887d38a213d8b45053ca536c5a1439f5a14e5e9269eb6f449430a933ec47ba0948d95ab5943bcc584c01b969ba52f532e04e2365d4ffac7d4c13e79c7a9c74c932673444f792771c7707602b8f4a6cb3bb68e3329ca0e76d65c71c928f4aeda4206ac8e70d2783882c0f8c37c1d2c469e5bbd22b6405ecbc91ca5a3f88f4ba426f03c39bd2a2b45c7ee59862baf90f4a889cdbc9c38cf65707d7fc404ea99fa26d7e62c32045604dfdbd89285d8053d62019327dcb8bd891d8a8af53ae9ad2f08735bb32a52c6c4f96a4974ee7d663bf173ee8177f3c3d82bdbf6912cb0a6e644926a4614e436a2f802665af63d471db7d695e28daf34cdacf8cf828c0c6a18f01", + "data": { + "slot": "8244301580800530500", + "index": "8236039160422142564", + "beacon_block_root": "0x0e6b4672045e0a2656b8743ca72fdd442fe1301c8e0a626018ff9ea973c1da83", + "source": { + "epoch": "959185898", + "root": "0xe8285272c4c64b9c6c32a6e5001eb4aa23db32f8227910ecbcfc1719beff6b6e" + }, + "target": { + "epoch": "958031652", + "root": "0x5bef2e72848c87392bc411eaf6522f7948ed2c64682d0549cf03adcadd44b8ae" + } + }, + "inclusion_delay": "8232734193988774308", + "proposer_index": "8231081706477122884" + }, + { + "aggregation_bits": "0xe298912968282dd9e8c111a33fd584855b278e68df452a740ba6d93182c00773846a6a921113df52dd403fab48a503a065d851cbd213022a55d484f7f2672f9da11ec5046074af7ff3904de3ffbdf308bf1f7a9138344d5deabd6092ca0d2731e2d345622b34bf1faf354e53e1498a8fec7bda1b7c5d7a22ac76a28bbcdcd1bc36af7047d3c9e4cbe63bfa806530769771fb2f23335a64b0b9bc955614692b2e0861a1daf408eab3fba93c34395c21b83277dbd0e933598bda32a9d21f17acd3931da5254589e7207b107ccf9cbf3be96f3e97d80c57a4d24941d57df7c05e4e2f45b026eb43109a63e8a55fa5cd736c4fca8d37823972af7f3a3470303ee35901", + "data": { + "slot": "8279003745530766373", + "index": "8277351262314082245", + "beacon_block_root": "0x7db4c172e529b97f383afcac4bf62d72aca145229993091b5766153c89cfcf22", + "source": { + "epoch": "962456264", + "root": "0x5772cd72a592faf54eb42d56a4e404d89f9b47fe2c02b8a6fb638eabd50d610d" + }, + "target": { + "epoch": "962841013", + "root": "0xca38aa72655836930d46995a991980a6c5ad416a72b6ac030e6b235df352ad4d" + } + }, + "inclusion_delay": "8260826421557306373", + "proposer_index": "8265783871207358757" + }, + { + "aggregation_bits": "0x3ac64b92f047175ac3f5d307533866f3a20d809c9bef68a301c3daa46ea439d4ca4be82faa5ed5701a70f913bc8c48b73dee2525a6393852bdbb8f50a96d7e49c026b9d8ed2accb1ca05fb7e846cfc60de51824099edfce617b55378063652c30d8c1ed61bc0da1d189ffab45c6affb9b9a92364a68219a16b97b5cb481b8a9171a67ef124ba438f546eb8e34be7d2e1700fda60f1925b87250e2793963ada174a97b30c2a307c2e47b3dc5eb55db6cc1d600f5b0ba3c63134e72dfe25e0a6d036368c962968e79e43b84eeee48e68818a35293209b64c35d0fe8c4d472438b839e0836f6688c5b83b1de8ae43b4ea7e83218f09da42211d58a507321daab25d01", + "data": { + "slot": "8254216484395602564", + "index": "8259173938340622245", + "beacon_block_root": "0x039c9872453bd461ed0ecfdc14b4bd0dd8b63e209510273297eeedb58275d3ed", + "source": { + "epoch": "954184163", + "root": "0xd984b9710375f99a54ff224e7e03ca7ec52919cca7db34d4621bf36fecd50b85" + }, + "target": { + "epoch": "954568911", + "root": "0xb242c571c3dd3a11697954f7d7f1a0e4b9231ba83a4ae35f07196cdf38149d6f" + } + }, + "inclusion_delay": "8189769613175117795", + "proposer_index": "8188117125663466371" + }, + { + "aggregation_bits": "0x943f3c5a1fc68f13804c3f39386826202cb56a00150042c14d6d89828a1cec8fcfc8f59f64221c93aa652b9853f428e83d0a41119511e79261d2de26444251e06f8d8c5da9856d88da0e229e83d0beaf2a4c36c630f82a420b30407d4a30754beda373dab22e58dcb24c3857d3c6ff5edf51d4c2679e241f097c26ef63a7925048179667bfab23e7f2d59b6e9a36074c2239c9b5c80a535a70776484fffe0f550d0c2613e9067eb30100a61b11fb7abb78802de4217c76f03e2bd634e4c115a5792716a96e59bb13e176ff955a9620d6e77b316f6faea331aa2e9147d59f55e846680e9bc7790eeaf15b3a01b188257052939952b2416ea39528f1edd378d5d701", + "data": { + "slot": "8183159676013413987", + "index": "8181507188501762563", + "beacon_block_root": "0x382a9c7123ef55f31e4e2727a0af3080e43814a636c7007747a1445930baa03a", + "source": { + "epoch": "952837541", + "root": "0xabf07871e3b49190dddf922b96e4ab4e0a4b0e127c7bf5d35aa8d90a4effec7a" + }, + "target": { + "epoch": "951683295", + "root": "0x85ae8471a31dd306f359c4d4efd282b4fd4410ee10eaa35ffea5527a9a3d7e65" + } + }, + "inclusion_delay": "8178202226363361603", + "proposer_index": "8222819290393702244" + }, + { + "aggregation_bits": "0x501ce35a6c3b6924ac109c2b7b7889cebf44d5a8848fcdc9978edb8b706a1b40173967d5dc2d98b57a843b3da05eb4e35e9909d5c6f46f94a946ecaca6ee7dd33031df07e3aa90079ddef9e7e440789a405c74e503ad4df3b4870fc3c502673dd6fd8161b9e6af48c8841fa856b62127b217ea18868706af17569990770df41c0d89abcb9826173536764facbc2441a77d6877a56c02b01383a8b8bcfe782326bc515b2631e4137c5e4382c1168105975478a3296e68e847b4cc93acdb0134da8f2f76470acc192e42346bb0f9513b0fb9f7843c639e38655c8bb5892c89b0811b3a12334112a16b20e7871c20b3643b988903c4feb8e8361b425f93c1b2a73901", + "data": { + "slot": "8224471773610386372", + "index": "8216209353231998435", + "beacon_block_root": "0xf3f7ff7183e98160d5db4b459399d3e17a0525f41a734b1a3d0dc90cb04b7304", + "source": { + "epoch": "956877405", + "root": "0xcdb50b724452c3d6eb557deeeb87aa476eff26d0aee1f9a5e10a427cfb8904ef" + }, + "target": { + "epoch": "955723158", + "root": "0x407ce8710318ff73aae7e8f2e1bc25169311213cf495ee02f411d72d19cf502f" + } + }, + "inclusion_delay": "8212904386798630179", + "proposer_index": "8211251903581946051" + }, + { + "aggregation_bits": "0x3685216afd7ace1c94b7284a71f5300ee8ae746013a4902aa89fdfe488f7ebfe7e0e5fc1d2c6e3b2a5bcfae2550bdaec6abad730ac03b3be1df2bf29b76b727b35ecb1dff77fc6a04f393dcb80ad6c1f7f54d9d0f4916148dd4a1181a325c8fec3d7a9c3bde971194f5e69cc8e3a40a4d52545d5e601d967fd636b839d4aa3cf7f7a23294f8bf130d834b9ff0b09c3e62232ac5f5e12fc48c6b6eee447adcaa32dccf447c350f2913405c37d560c1d95079831527431e873e144d71dbd33b5c8427765d5e53e3336acee1c0e118cafd90433597b593658d8430d45b1413281e97ebe9bdb6f3021474a25b32b160034cf30f90bd07a3502e4524509c70e72cd2301", + "data": { + "slot": "8206294449636926371", + "index": "8204641966420242243", + "beacon_block_root": "0x29860371629d03f2061ba48f1f9546548787fa79bb29255fedbf1fb05e904051", + "source": { + "epoch": "947835806", + "root": "0x03440f71220645681b95d53877831dba7a81fc554f98d3ea92bd981fa9ced13b" + }, + "target": { + "epoch": "948220555", + "root": "0x750aec70e2cb8005db26413d6db89888a093f6c1954cc847a4c42dd1c8131e7c" + } + }, + "inclusion_delay": "8135237641254737794", + "proposer_index": "8140195095199757474" + }, + { + "aggregation_bits": "0xcc2ca579e4de9a969ec2c1960e8f75d4a201b8920f8e795f23b2828a1aee78550aec28c51ccf3b61c5c7bdddad25865ad83e22dc02641e50823826e4e0b3cb27458cb81fab8f8480d3d34a01cee5b17e4b6835b44f0c1e7735d782dc57307780bbc6adfa819cf12b981a24165ab3692b972c3565e0943694ea9a71bfe664035d5a1fe724ba78471076304b2403ac156b69c445e519b5c828bf1bd7c95b3aab6ebf6646d9909aa25fc489158f703b270613f8373774d0f14b296a6729f2758e5340632579d73b139123466ef9d60d4c483b1714fd7bbaa33d0aae9dace574a01069982571ca6a077421c64c1839cfda8c57e0f82531f74724529c553840eabb6b01", + "data": { + "slot": "8128627708388001281", + "index": "8133585153743086369", + "beacon_block_root": "0xae6dda70c1ae1ed4bbef76bfe852d6efb29cf377b8a642762d48f8295736441c", + "source": { + "epoch": "945719687", + "root": "0x2134b77081745a717a81e2c3de8751bed8aeede3fe5a37d3404f8ddb757b905c" + }, + "target": { + "epoch": "946104436", + "root": "0xfbf1c27041dd9be78ffb136d37762824cba8efbf91c9e55ee54c064bc0b92147" + } + }, + "inclusion_delay": "8169939801690006370", + "proposer_index": "8168287318473322242" + }, + { + "aggregation_bits": "0x1c54ec93e12710565957a42c19fbffd3dab7034958f5ed1c2ec157de1e324e7ee93c963a2cb58e75856879cc6c79443803fd3bc1c0ecb651867dd7d4923663b145d9e60bb851181530469d52e9a15a67f919af21ae7c02d8f2505f3e0027ff845e24127c1f8c7c2cfe5ec85544cad830b08befa7fc94ee38ad34f9d988f05d4e4993db379103a48f3e6409c6ac4219632b5dfcf0678605f44508f91b236a06d0502c52fce83229eb8bf42ca3576a0faa45663f98851b4627fb7deb0b4174f3eb6bd49ad6e051fcf235ef2111b413200f5ff05e94934ea24fd33958704398b38d3780c88c69a8d68e718afe92fe553bcd21f2481d5ace82248b0394f7b426d01601", + "data": { + "slot": "8163329868823269858", + "index": "8161677385606585730", + "beacon_block_root": "0x1db75571a27acd2d9d71fe2f8c19271d2f5d087ec22fea306caf6ebc6d4439bb", + "source": { + "epoch": "950529048", + "root": "0x907d3271624009cb5c036a34824ea2eb556f02ea08e4de8d7fb6036e8b8985fb" + }, + "target": { + "epoch": "949374801", + "root": "0x6a3b3e7122a94a41727d9bddda3c7951486904c69c528d1923b47cddd6c716e6" + } + }, + "inclusion_delay": "8158372414878250178", + "proposer_index": "8150109994499862242" + }, + { + "aggregation_bits": "0x4c00179bd9498ef1506d44447e1cbfc501dc27f98d4c2ddb00d9fd54685e67fda5d5922096f094555a59ad321b2077a95bfbfeae2cc6b8ecf426c25273d06266a56012de3a095d9207eb6982907057138957d7fc0e09d3459b7536fcec4ce873de9359c16739f148c6fd3cb769c18785cb48ddce245b84fb5a2e7c6906b3000f4e495825747082fc8d140ac2cc9d3d1e22ab5d89257aaacbf8068b0ea5bed35b1bd809381662cb7eb66b4b4ffd3b85eb6078217238f240df1732ee23ed827fc19763af25bb886ccce7aad371cc68a7ffa09bfa3b36d4173a42d681c0b2e77d2928859bc69f4bd22e3da6b52dd87e67de895a686902a79947a1bc6e24dcd6910201", + "data": { + "slot": "8151762477716546370", + "index": "8090620572929429856", + "beacon_block_root": "0x9fc94170005dccd2a3bcf3276638ecc355ebd94b3d09675ed366d380850ce432", + "source": { + "epoch": "942256947", + "root": "0x79874d70c0c50d49b83625d1bf26c32948e5db27d07715ea78644cf0d04a751d" + }, + "target": { + "epoch": "941102700", + "root": "0xeb4d2a70808b49e678c890d5b55b3ef86ef7d593162c0a478b6be1a1ee8fc15d" + } + }, + "inclusion_delay": "8087315606496061600", + "proposer_index": "8085663123279377472" + }, + { + "aggregation_bits": "0xd62ffe9061836115c1dc28cb68526683e1bb4c52b54657d30a8f277fb4bc0c7992891f2ae4d5e9eebe332e8c449218048d6374c826875db5bc3b1a4ed669ce7638444001f89ba4c376aa2eb7d2b72203fa8cac6469d9d158f231c621a6fbcebf6f8d3dc725fc3e274ed1fad5408c903ed31413dca103fe95976407fe73b53a035fc731886315eda1fa33df0c02e2c02d1561fcd396307fc791a2b6138e280da8c209050f19b8a8c9bb3d322c09402dd210c0ab389e025f2f5c989faa782289db366c89b959cfd7271c9c9d0b231ec7e9e710cc3d0b24317b113d569ba262f33d40e427cc839160735ca7379cd9d40d396c7c37759d50cd9750b13e99070ecc3d01", + "data": { + "slot": "8080705673629325088", + "index": "8079053190412640960", + "beacon_block_root": "0x71350170e09c64c82c9d63057e19ce939a0ccf9112a9275ecbf3b91be735c528", + "source": { + "epoch": "939371330", + "root": "0x4bf30c70a005a63e421795aed707a5f98d06d16da617d6e96ff1328b32745613" + }, + "target": { + "epoch": "939756079", + "root": "0x5a97a5706157f83f5a4a184659228f25ebb7ea9921b5b101c9d25734049eb6fc" + } + }, + "inclusion_delay": "8115407829769626369", + "proposer_index": "8120365283714646049" + }, + { + "aggregation_bits": "0x344d37144637066a659e0ecbbf58cf6ff5cbba766aaf39d140a8f1742c92f0e4480ab3b850cc6dacea823fd9fe32c69bf6e93d0d9532d38144af3f74b45fe03265a8007dfc85b37d2daef74d26c6f534749cbe43c4e876bf9c16781e3f583dc27158a977243ed9db702dd5280d7fe28568530f8dd6a2dce5e4429cf11d335043da9bc82c94fcea7cead189ded5f04b4a581061e1b6189ea22a0f027687b821ef78051a2ec5ff56d063df6ad60f1976be3b9b24ee8134e3acc6f24e344df9705acb7c6d0648197660f6d2d00a18866861d186fc4c2e18aa4bc3c944a553d317e51998b2760babcf70ab978a3b7aaaccf8ef078dd7e9b8b9200dda70210581ec5b01", + "data": { + "slot": "8108797896902889857", + "index": "8113755350847909537", + "beacon_block_root": "0x94fa9370413a960e39134ec8d4bccc8cfdc0e74f440f2c305356228d93c0dc9c", + "source": { + "epoch": "943411193", + "root": "0x06c170700100d2abf9a4b9ccc9f1475b23d3e1bb8ac3208d655db73eb20529dd" + }, + "target": { + "epoch": "943795942", + "root": "0xe07e7c70c16813220e1feb7522e01ec116cde3971d32cf180a5b30aefd43bac7" + } + }, + "inclusion_delay": "8097230514386100961", + "proposer_index": "8095578026874449537" + }, + { + "aggregation_bits": "0xd84bd4f2d575f7f303eba91908cbadd406f4730124924162c89639010204d379f5d13d8f66c98b8d65892a6ba2ab0c53089f9c5a2e65090bd607792c5f0a6717d3ac12f0e2dd73c788c2ad34863bc55838d8586873de2eae65830001796f715b0bc86bdcc2193a248877c6523bd81bd293c2fa7326884a5fa6d8142cbd62297129dfbe0cd52598c7117e7ab9ed0a2900939fed9d8afe1fed7ea6c2d8d1ac37fd679b4c41b7235171215cc56c9270218452f09cfb5300ee1ec081f78d1651f8b061f8022239d6ecf4c47141983932a49e6e8d030ba404ad589075cabcf5f04e4666ebcb7196d3a7db6cedeca10eda306eba81e5f2a931fb7b43e051459b4ae44401", + "data": { + "slot": "8460776980970399082", + "index": "8459124493458747657", + "beacon_block_root": "0xaf7576752a4eccc02f5d63abbfe4b6eaca3cbad68c0f3d4c3edbf7ece12a4932", + "source": { + "epoch": "985156449", + "root": "0x223c5375e913085eeeeeceafb41932b9f04eb442d3c331a950e28c9eff6f9572" + }, + "target": { + "epoch": "984002202", + "root": "0xfcf95e75a97c49d4046900590d08091fe348b61e6632e034f5df050e4aae265d" + } + }, + "inclusion_delay": "8455819527025379401", + "proposer_index": "8447557106646991465" + }, + { + "aggregation_bits": "0x82a3952033cb003033a02cc9051c6f1fe80aad84c879c963ff5f802e0642cff5ba2ff5ac11929560c7cc09882d1e2e6da46f3cac9cb663139d4e8b6e56630e38eaaf22243eb775145b5279dd55f4363322d237e5a39ba700ac1b937a691a7d32914b3159c40d18e3cf96d5d7f7bb6e74c496c92fe7115738cf30c830e9997d222672eef08e45a4b427d0ecbe919fba9ba34ba512f181d375e7633fa3cd2d4806cf2920f97b7915e18bbcb6874114482a7ce1d0e7f6f1d35af1d0088c4f8a5c0cea7dd7f6ca86b2efbb1a531dd6439510cd22eb42b70bc4733aa3c114acb1248f4186cc402d8e47e0dd7dd06342c38b22da7ee2130b390a2e2816079bd7833f7501", + "data": { + "slot": "8449209589863675593", + "index": "8440947169485287657", + "beacon_block_root": "0xce651e7589bce1c98d49703625e9eaee286aab643cd2a034ec6ceca8acd70753", + "source": { + "epoch": "983040330", + "root": "0xa8232a7549252340a3c3a1df7ed7c1541c64ad40cf404fc0916a6518f815993d" + }, + "target": { + "epoch": "988042066", + "root": "0xb7c7c2750a777541bbf6247700f2ab807915c76c4ade2ad8eb4b8ac1ca3ff926" + } + }, + "inclusion_delay": "8490521691755615274", + "proposer_index": "8488869204243963850" + }, + { + "aggregation_bits": "0x78ccbfb94a2f8bfb95ae5f167ac1b06f42e2686afee598cc30d066213c652fcd7d00fdc33f8e3446010d1d43c4a9c8ab43f1408e9b8e8d54834847e5d434354a2c977b45b4d1dc09adc557b4874ae9b8a6b5a53886072c1b03e4825e03989f7757f2ca7de37ca86bce77127ee70227a3cd76a586bf09c230c0903d2079261f9cd375dcfebeae44603e0a4b1d9c1bcf229b241171200442523d0c36bd57ee191816f282c83f7d8f338808802c3cd970c4604fd94adf697055af0b8cadb50f336bde1efb2c12c9b8d82fee7c99eb6015b43fe31bb51865622fce167cdb61fd94b337551aa3eca617550bb38282a69c90c9dcdd3119a9705c1b8c3e44d36bf83e1001", + "data": { + "slot": "8483911750298944170", + "index": "8482259267082260042", + "beacon_block_root": "0x3daf99756a88902370cbf7a6c9af3b1ca52ac06a465b48ef2bd4623bc2e5fcf1", + "source": { + "epoch": "986310696", + "root": "0x176da5752af1d19985452950229e12829824c246dac9f67ad0d1dbaa0e248edc" + }, + "target": { + "epoch": "986695445", + "root": "0x89338275eab60d3745d7945417d38d50be36bcb2207eebd7e2d8705c2c69da1c" + } + }, + "inclusion_delay": "8465734430620451466", + "proposer_index": "8470691880270503850" + }, + { + "aggregation_bits": "0xc22cf4aff082c9293f7b62cad45697850c6b0839a29e7d68a3efbacf2e44fce4dff1c8f6d5a9ec8715b71d61ecafb71b4967b68625eba2121887d60889ec840818d732cd7a7b9a29700f051ac14334d49fd36e487952536efb791b1af52ca11925e1c2c6cd0b5058716a7b2052898720496d452f17b82a33d37d04f844092f8252563cfbb65d7094c08e7b8284a6388ac9d49f9aeb61e4396c7f2f45636136f6ad70355e7c97d65ddcd4d6df1a9c144d54075cffff90726f581748db4e5955f116b2b3903d94d848ae47122626a1c627941fc715b849f98bb3b58c206785b60b30fb56e8198d10c46846ebf7895bbe8cfaf843acf218395b64f61a0e04e0002c01", + "data": { + "slot": "8406245009050019080", + "index": "8411202462995038760", + "beacon_block_root": "0x26b9b474c80d95a1ccfeb24306885c5a99a099a80eef7e4b2482abbd07a7ec13", + "source": { + "epoch": "978038594", + "root": "0x987f917488d3d03e8b901e48fcbcd728beb2931454a373a83789406f25ec3854" + }, + "target": { + "epoch": "978423343", + "root": "0x723d9d74483c12b5a10a50f155abae8eb2ac95f0e7112234db86b9de712aca3e" + } + }, + "inclusion_delay": "8394677622238262888", + "proposer_index": "8393025139021578760" + }, + { + "aggregation_bits": "0x4e6b11c93cc4b873d5a6458c7356b12ceff1c9442ca361fa021124fe2012dd53ec6a4242e98ba783383c09d0b4badd97393a5ad8d88cfadd877db130223b03ece6132338e4a34dd4dc6b1d739127341e93b7aa7386c66a3fabddd785a8a3e4165b12c044a16cf3eec916683a47acd071d8182bd723d29daf35b094512c4c547c258c495f2188820fab80ea81a05d7ec4d07e1afe5a46659071dbe27f18fb38e4925661332a7bdb74d4811925127f419f6f78e62e0da37db93476f27f45f91b95247e5ea4821966539ccc3fbc1b0116db3b0838923795749cb911086143a48f826e38857e84f40927af78bdae3ad91ab1ebc429caaa9b303d686fa96a863a480b01", + "data": { + "slot": "8388067685076559080", + "index": "8386415201859874952", + "beacon_block_root": "0xf8247474a84d2d9755df22211e693e2addc18eeee48e3f4b1c0f925869d0cd09", + "source": { + "epoch": "976691973", + "root": "0x07c90c75699f7f986d12a6b8a08328563b73a81a5f2c1b6376f0b6013bfa2df3" + }, + "target": { + "epoch": "981693709", + "root": "0xe18618752908c10e838cd761f971ffbb2e6daaf6f29ac9ee1aee2f718738bfdd" + } + }, + "inclusion_delay": "8435989719835235273", + "proposer_index": "8427727299456847337" + }, + { + "aggregation_bits": "0x68404ec90c3cdf44f8f4fa98244f5d24bf843fe822486bfd88323491ca6463dca1c3fe0059b403e965c91cdf0693676c7a306c100f6926ca7ac8b29e0082376beaba400c2485432b971396b19c97fab359b6a80018170c9ec5fbad2b4a53bfe96094347871ae5c3737cc67c5407f68ca9311b38458d3bf1d41b84b6c11f630dc67d6a3b8874727902b63be524b4ff536972f81d64f2f24d9d31e581e19fd5481204a5e367a19667c0966319717141ab306a669f013924318645c71f1742ea026d1202b0b15a7e70e6c8aafbd18869d102bab0971a7a9cdbc59d0988d32346ae233667a144e4f8ebc7d1850c0e0a783c66c1ab3f8d77e46a9f77e2794b8746e5101", + "data": { + "slot": "8429379782673531465", + "index": "8421117362295143529", + "beacon_block_root": "0xb3f2d774084859040c6d473f1153e18b738e9f3cc83a8aee127b160ce961a0d3", + "source": { + "epoch": "980731837", + "root": "0x8db0e374c9b09a7a22e778e86941b8f16788a1185ba9387ab6788f7b34a031be" + }, + "target": { + "epoch": "979577590", + "root": "0xff76c0748876d617e178e4ec5f7633c08c9a9b84a15d2dd7c97f242d52e57dfe" + } + }, + "inclusion_delay": "8417812395861775272", + "proposer_index": "8416159908350123848" + }, + { + "aggregation_bits": "0x8a66f145f6b630fae8b55f97b260c54643d45cdc2a67ddfd9ee07a9e081fca4a91947f582d357e5aa87bfa3555680cc18c2ac0730c098bf230c3ea80d53881a0053f03d3e0348a7ad51387adcf8234a93efcf69cdf47ce41b49755f654c71a35f8b873f5d8428255fee881c5e2b37d354f63f196fd2be1910b9570d197c8865072c8cb07116940bedc1c2cffd5c828989ee146f5e067c1f0aad566931677aa70c10b7245f5d7cdca832038fdf2bb34865c9f43e29562dc4b2f966068c75e364868015e4d74084cd45d1c7ccedbb21d041a151f7d28c1efef3450e550c005ed5e618f0f3c580554215d5da234796ca83bc9404cf44e3d9a088e4353af370e751701", + "data": { + "slot": "8358322974291342887", + "index": "8356670491074658759", + "beacon_block_root": "0xe880db73e7fbda953dac9f899d4e54fe801075c269f16333c22d6daf97a66d20", + "source": { + "epoch": "971690237", + "root": "0xc23ee773a7641c0c5326d132f53c2b64730a779efc5f12bf662be61ee2e4fe0a" + }, + "target": { + "epoch": "972074986", + "root": "0x3505c473672a58a912b83c37eb71a632991c710a4214071c79327bd0012a4b4b" + } + }, + "inclusion_delay": "8340145650317882887", + "proposer_index": "8345103104262902567" + }, + { + "aggregation_bits": "0x46b108cad5182afce52fbf6759968538f48f70d2ee7dd77364dcfe9a307231e9ed5d7fd0d57e787b778a2dacb26dcd56940c1315cd71d58e10a6f956c4d2947e810767162468e6f5f8a26d7cb6d3bac95e3ae941faa25f3ac59a247095c467d65caf9b4118d61ed9414357276cfa2012b0030ab965c44d32c404e111299fc57131a34115e61a663d66072ad9fc8f44fa9316b3b6ea89fac31eb35632b8bd5751a07d49890bc7875f37e03b90798c38224108d528698dda30c3f9444459383a63af9e5274ac414ce26fb9eca3b3025e77f14ba100b98146d8a9f11c88d78baaea41104954c5e629d93535d9c73a9ea53985abcc41126d4938ab8e81af138c361701", + "data": { + "slot": "8333535713156179078", + "index": "8338493167101198759", + "beacon_block_root": "0x6e68b273460df677f28072b9660ce499ac256ec0656e814a02b64529904c71eb", + "source": { + "epoch": "975730101", + "root": "0x7d0c4b74085f48790ab4f550e826cec509d787ece00b5d625c976ad26276d1d4" + }, + "target": { + "epoch": "976114850", + "root": "0x57ca5674c8c789ef1f2e27fa4015a52bfdd089c8737a0bee0095e341adb462bf" + } + }, + "inclusion_delay": "8374847815048118759", + "proposer_index": "8373195327536467335" + }, + { + "aggregation_bits": "0xa40ac12101202436223bd2c552f30b15a07aeb0fe943db24516f3dc02c3f75ca9fc658af812c556b1e31cb82a3019d1607c48a2418f9bf2e4ae18ae21a5838f3ce56d80277d77b6e2a3bd41f995f58dee89338941d4063b52e15a1d6caf2a6c0b9cd8d6d548f867e200d9920d06357df8e9f10397bc447babfca6b27d23711a2044264836e42a53baf51691b4a2120e5810a66abe6fa8356e5a41bc8a0ef9264433f3bce0b4e48637e719eb579ba12cf0f1f7573f840fd7a95cfc872be6d6f972703c2d29d7927224bd0e147c78c5e638589d5e9672573f25f61f1f0902319673e20202d560503494531595d3d16d454c7a07a275a1dc4f07d036c50abc21b2f01", + "data": { + "slot": "8368237877886414951", + "index": "8366585390374763527", + "beacon_block_root": "0xddb12d7427d9a4d1d402fa290ad334c728e682c670f72805411dbcbba65a668a", + "source": { + "epoch": "974383480", + "root": "0x50780a74e79ee06e9394652e0008b0954ef87c32b6ab1d625424516dc49fb2ca" + }, + "target": { + "epoch": "973229233", + "root": "0x29361674a70722e5a90e97d758f686fb41f27e0e491accedf821cadc0fde43b5" + } + }, + "inclusion_delay": "8363280423941395271", + "proposer_index": "8302138519154278758" + }, + { + "aggregation_bits": "0x1eb29137998b64a4b5effb0db9784a95eeb3075e35b9ba00ca226a2e9230967916e77f1b690f2dbe5e96eb419f81b1822f6b7fedaf9c1d60c8239b29459183a4b61a17c229382c5abfb1e38f176f87b348369b79d48e5de2f6c8bace1454102ac9df84546ab0104cb5d1fcd745caf2d40104e19d13719c2bb075c74bad99e370056fa00f3a9433460ad5db880ba4d7ec8a709e53bf9d3173b0474149d466b3acf53d8f5221b315258a48c44e5ffe2e7b7b7afbd4b823f4c663c22a56af3b0e85a23f8c67ab65910bceb18fb82e9995e1bedd8c2cd329b30e2382016d9045119a21966e03e3ea01152ed7b4f65293bb34368a859c22bf8b9075cf1a8d859aa97701", + "data": { + "slot": "8303791002370962886", + "index": "8295528586287542245", + "beacon_block_root": "0x5fc4197385bba376da4def21e4f1f96d4e745494ead0a532a8d42080be221102", + "source": { + "epoch": "966111378", + "root": "0x388225734524e5ecefc720cb3de0d0d3426e56707d3f54be4dd299ef0961a2ec" + }, + "target": { + "epoch": "964957132", + "root": "0xab48027305ea208aaf598ccf33154ca2678050dcc3f3481b5fd92ea127a6ee2c" + } + }, + "inclusion_delay": "8292223615559206693", + "proposer_index": "8290571132342522565" + }, + { + "aggregation_bits": "0x4a5bc3224104d327f28a577e2f44d34db97fa414068465c27c935e4b563927c72358d03f25644aba017eac640bda4fb98b486f21e71e446a2907d46898349806b5cbff083bbce2c33cf73dc9f208aab6e377617506f390150b65608d54e9fe7b18b4285c0ce7c4451683a3c8d4e59f33ee99ccc00757c785eba29550a65efc63361d2c757d7bf506aa064f91bdc854a96d2f4689c50d5f2c951255600daf93a4d43a1c79d8849d40297c85e21fe230fa4a90f9a182fa747244683eef93433f53792cdfad049e8d92286a1c4a4643b93437e955607b03eca20e08fdbd6a9f09e458440bcbcc5865bc40dc98c9d0a2f388ba738f9f961a6b4331ff5632524ac26701", + "data": { + "slot": "8285613678397502885", + "index": "8283961195180818757", + "beacon_block_root": "0xce0d9573668752d0bccf769288b84a9bcb34699af5594dede73b9712d43006a1", + "source": { + "epoch": "969381744", + "root": "0xa7cba07326f09346d249a83be1a62101be2e6b7688c8fb788b3910821f6f978b" + }, + "target": { + "epoch": "969766493", + "root": "0x1a927d73e6b5cfe391db1340d7db9ccfe44065e2ce7cf0d59e40a5333db4e3cb" + } + }, + "inclusion_delay": "8320315843127738758", + "proposer_index": "8325273297072758438" + }, + { + "aggregation_bits": "0xa670da8262b1f08a1ed46c2ab0443c802a9211b09a3d2ae73e940e649edf9150fef1446d9d4de69271cfb9bf99f80186da5068e895bbd48ff593f0e790a0a335a86b8e503180b06822e3b4b0dc3879210d3e6286b3c637e0247af9329709a5050730526cc1542b19497984459f36c78c47d6709856dca177caa8276dd3e094ad934f4455c996c3dd2ae5b953c2da1ad26263ffbe0527bc2102af838d043dffd96797133c0e82750eb41a9c181a894b56e4636775bdeeeae30e8929ebac41d86392e0370b32210dca9929104b6d011eee0bd8c431f02343d2ccd47401916ced871118db534827e2a797e43df4b8fb2a4d38c135cdfac3b7b7ece6c08e1c40f02101", + "data": { + "slot": "8313705905966034950", + "index": "8318663359911054630", + "beacon_block_root": "0x53f56b73c6986db271a449c25276da36f7496298f1d66a0427c46f8cccd6096c", + "source": { + "epoch": "967265625", + "root": "0xc6bb4873865ea94f3036b5c647ab55051c5c5c04378b5f613acb043eeb1b56ac" + }, + "target": { + "epoch": "967650374", + "root": "0xa079547346c7eac546b0e66fa0992c6b10565ee0caf90deddec87dad365ae796" + } + }, + "inclusion_delay": "13748725597936915948", + "proposer_index": "13747073110425264524" + }, + { + "aggregation_bits": "0x81b07794e590d1795b2b9f0fe9804f31f87caba4425e21bc01b55fc9a877824000b28b1d253b79dd6e3604db9038b6c464be9a72dfaa65f9cd80d06f508f22bf97fe839406939ab55af6c1013d84ae75545ca6edbb09d7f4fe8a7b48e7543b4a056a9f3bdc90cf3034adbd60a1c6805b4927c601a38d6f9986945c73ab01be1b2a3f35993fdf7c6b092189c493e8c100738ee3f19af116e1251f41b7da7972688773391b77a7cd52cdab7a234d89c42f3173771214215ebf144bc508031b4a4064da69bdb1e69116c0ac75580a43e824e181713cea4edeaf6078b12d5a4e6afa373c9cad7a5d33afc7f6d17661a002c8e2a3b3ac1c249b1aeb3289afa65a275c01", + "data": { + "slot": "13742115660775212139", + "index": "13740463173263560715", + "beacon_block_root": "0x3c8bc1be2c2d18ed9f6f3bceb2b25a9ec67a102b1a4b1337d72337c28f04ec68", + "source": { + "epoch": "599985191", + "root": "0xaf519ebeebf2538a5e01a7d2a7e7d56cec8c0a9760ff0794e92acc73ae4938a9" + }, + "target": { + "epoch": "598830945", + "root": "0x880faabeab5b9500747bd87b00d6acd2df860c73f36db61f8e2845e3f987c993" + } + }, + "inclusion_delay": "13737158211125159755", + "proposer_index": "13728895786451804523" + }, + { + "aggregation_bits": "0x91e48c6fd1eee97f538a75e38d562e0e0357dd3656f401fe3fc0d98e800a9dc7e45b9b05af7e67762187c353af3d7531b48b7b9617a058d46dbfd7e501a976795346ff41860dd3b06541b3d0a655ad07f4701c260af6c6ed079c0f9c2ea50ea8e9f154afb4641ad626064b821cc7e5ed2c6f3d2f6866c57b01c59d611c46b3606d70b2cbc8a6fe7e0355cbb4fcaf556cda7054b0717dbdf69519cb52742d8c49e41350cf19fe37ca703c1a0ef7aa52cf52ee6df8f0b94165f4c9e18b9f6ac949e27d608659a4112abb2ae71d757a664e08c1c91d4fc6136879934cfdeda9204e3ee9cb67543e76ff2b4e96cb01430edaee4a8238445d546decedfaad46c9445c01", + "data": { + "slot": "13730548273963455947", + "index": "13775165337993796588", + "beacon_block_root": "0xf75825bf8c27445a56fd5feca49cfdff5c472179fef65ddacd8fbb750f96be32", + "source": { + "epoch": "604025055", + "root": "0xd11631bf4c9085d06b779195fd8ad4655041235591650c66718d34e55ad44f1d" + }, + "target": { + "epoch": "602870808", + "root": "0x44dd0dbf0c56c16d2b09fd99f2bf4f3475531dc1d71901c38494c99678199c5d" + } + }, + "inclusion_delay": "13771860367265461036", + "proposer_index": "13770207888343744204" + }, + { + "aggregation_bits": "0xe36840b4b222707629040a6ce6fb53fe3b750fe0c4fe7147fe4e1984f6b82d2ca164a80b83ef6654a26744a1b4c30b81b1144dce75f8b49771b0b980a7de43bfc9df86341f6943bfe7d49f9876d150ee11c450af6e6e5df6c1f22eb46e2184bd294b4d276355b6f50125fbe37e7ab92f45b277a7f02642f1f841f5d38dc9cd5c3d5f80d7e06d8ffc0d03aec3f2a640678253a21b826bed951bf386176ee61f5c0500e2fe59b6a8307b28ad659237a1019e49fafdd189c31efb14efbae4e7ae3f16d61e85b9a21e3306b07099491b6f5b5480b001dcf42654cd2754d242f33e6347fa38b99315184c5c8cdcdfc4489771d88941317c122f54181732a47a8166ae01", + "data": { + "slot": "13765250434398724524", + "index": "13763597951182040396", + "beacon_block_root": "0xc9c4e4be6c67dc4fdfddcfc9bc7ddfcfa16816bfd3961edac41ca21071bf9f28", + "source": { + "epoch": "601139438", + "root": "0xa382f0be2cd01dc6f5570173146cb6359462189b6705cd65681a1b80bcfd3013" + }, + "target": { + "epoch": "601524187", + "root": "0x796b11beea0943ff5c4855e47ebbc2a682d5f24678d0da073447203a275e69aa" + } + }, + "inclusion_delay": "13694193626016535946", + "proposer_index": "13699151079961555626" + }, + { + "aggregation_bits": "0xbdc02ee74a8471f627f521e9cf545e04ef54d39a101091b16570c46888c72eca05859e8f4dc68c97c11c54b2c865243d096ab895cadc8a58bb72284b77263a8db3a8edc2c091b3dd7e1f890f3ce14da63f7135ddd1ffe2b3916e1dedb8913a8b1a5f070e6d6262e594f99414e8d118648139d70f981729f4fff45d3bbe43e716382034cff85f3a1c8c8d7918eb40f73f18a94cb9cb1c8bbf4a50dfba5a691eb1874e51681a4ab176258072de2c2a99968b0d694c5b9de1362f0831969f85dca4587ac6658e267b8422498566e4dc0dea6bf46de47c18aea1d4ccaccf2e8d5ed25df4e6d7024e0ef19d6921ffcdc9bdb70654f6c6a5d0e21ca8c7657897bc701201", + "data": { + "slot": "13687583693149799434", + "index": "13692541138504884522", + "beacon_block_root": "0xb2ceffbdcaece0cd3b118b66f955000e95deeffc9b2a5536bdcaea92b6808f4a", + "source": { + "epoch": "592867337", + "root": "0x2595dcbd8ab21c6bfba2f66aef8a7bdcbaf0e968e1de4993d0d17f44d4c5db8a" + }, + "target": { + "epoch": "593252086", + "root": "0xff52e8bd4a1b5ee1101d281448795242aeeaeb44744df81e74cff8b31f046d75" + } + }, + "inclusion_delay": "13676016302043075946", + "proposer_index": "13674363818826391818" + }, + { + "aggregation_bits": "0xd78fc7c7d5d292ac051c06feeac478bf0ee6e9fe0ebda983e68d497fe6518bd9b04e36ea77c6c5f1df77508bc69aeefbfddf1d823598d813cdb26f9115b3798907a8c74f5c19c260c49bd367e21c3d6a55151df666ac0bc2e87b6752ef0a97c52420c79e0347817a30c4972e8eb447f970e0f9d768f50d4c6da1b9a2dbf78a2a69ee56676f8a59c18f23cfbaebc941b08e50c99df8390a1a13f84a8601ff3abd904e450628143df437a3956cbcd9d8434076d1411b8bff550fa9890d943d83d93cf4a94fda73c090d0f090f59ffa7414ccef1225ff04b18e6e2025c8c8ae9345269793598d3642325237dfc7d869596ded908de3ed5b7e7f74cdfd1c9117102401", + "data": { + "slot": "13722285849290100715", + "index": "13720633370368383883", + "beacon_block_root": "0x21187bbeabb88f271e9312d79d1c513b119f0403a6b3fcf0fc316125cc8e84e9", + "source": { + "epoch": "597676698", + "root": "0x94de57be6b7ecbc4dd247edb9351cc0937b1fe6eec67f14d0e39f6d6ead3d029" + }, + "target": { + "epoch": "596522451", + "root": "0x6e9c63be2be70c3bf29eaf84ec3fa36f2aab004b7fd69fd9b3366f4635126214" + } + }, + "inclusion_delay": "13717328403935015627", + "proposer_index": "13709065979261660395" + }, + { + "aggregation_bits": "0x39ad7c47f417411aec5ea2fa8dd596359d1956599b10c632eeaa1b361e5731336bbfa0c8c7d961b3378201557eb8b4e082d56d4f8674188580264e67371bd1765a50973fd617e6cf8f0f1a9c6e2ce36def17dfd3f1f32fe7c2f889cf25a994333f2e9186c9876e324a1cb8f1df0317c37a8e6f245f680fff0789528f6e99ec5c6c74bbcbc985fd121de4196824fa1f53820670fdfc93eb5aa167a2fd80f106c023221a023cdac0ffeac00516b9aabb6ff08d4e8515dfe0929561d8b0a0ee2f228e78c5f3e6c5414f6ab619f4bff166fff248a3407374dab69894b0663b3ed2ae7fe1584103adfb8805073a98883782ac0aaac3918c92bcecbb855b300bbd5aea01", + "data": { + "slot": "13710718462478344523", + "index": "13702456046394923882", + "beacon_block_root": "0x400823be0a27a5307c7f1f620421853f6fccf590557660d9aac355e1973b430a", + "source": { + "epoch": "595560579", + "root": "0x1ac62ebecb8fe6a692f9500b5c0f5ca563c6f76ce8e40e654fc1ce50e379d4f4" + }, + "target": { + "epoch": "588250350", + "root": "0xefae4fbd89c90be0f8e9a47cc65e68165039d218f9af1c071aeed30a4dda0c8c" + } + }, + "inclusion_delay": "13646271591257859753", + "proposer_index": "13644619108041175625" + }, + { + "aggregation_bits": "0xa380265a4e5b8ab538cb48fd394a0053eae32576e07b35b2fa37411cfe967864bde00970b5f69c5c7ff0806f234a576714cfce61a13cbbb4c23b12374130fff19654d5e61aa4a5defe464dba7d2a6f9a845c6d4b342fad98bf916d10395e21fec2c4b423796aa8dbc23824f1628b6661efa321d4bacd2d534184797261b6de006dfe9334578e9b6f84855f04baace7cd049ef59670192e50d8e2da6aa77aec25633314b7a31ca74970367e3c4455902a929074d5ba6f5f46ee0a891d15f69f9c2449ebed27f0fa34710ed38e4b050f4bedf2bf4c6ea438f4977565fba09ae59f17820d2b33f049360c06f8591bfd6e038d0e359d81a7c04c3aaa2eb90264873c01", + "data": { + "slot": "13639661654096155945", + "index": "13638009175174439113", + "beacon_block_root": "0x759626bde9da26c2adbe77ac901cf8b17c4ecb16f62c3a1e5a76ac8446801057", + "source": { + "epoch": "586518980", + "root": "0x4f5432bda9436838c338a955e80acf176f48cdf2899be8a9ff7325f491bea141" + }, + "target": { + "epoch": "586903729", + "root": "0xc11a0fbd6909a4d582ca145ade3f4ae6955ac75ecf4fdd06127bbaa5af03ee81" + } + }, + "inclusion_delay": "13621484334417663241", + "proposer_index": "13626441784067715625" + }, + { + "aggregation_bits": "0x65a3ddda1fef8d81dc89aebc4edaaebf397edbf2fd977a35227c359616f986a246619d7203e5187ea75b14b2b3ea4dfc27d5ca6c42ad73833eee2199e3b413969bf407fed2932461345640c2d09aa18f4845ae188b1ac229d48a41afc2fc7800d8564532fcec4707f8c6031e7945bf9bd6f6afee4b1552e37badbf4d050cbc4839a479b3715119300066bbd6dd30a916687d48b6a4b0cd7b5f6f3247b6fc1030d27f0c975b3d4851af7165ce43234b84ba6afa11ac5c40a5aca03ca10a272abf93050ad211461b61fed9d9cf6f1331d3d175861b6d9ee1c40599f54e731a00340ddcd285b38fc6849d388505ca03b4436a34af2fed1e9c99f7b32045b06a27f601", + "data": { + "slot": "13667753881664688010", + "index": "13672711331314740394", + "beacon_block_root": "0x985bb9bd4a785808ba34626fe5bff6aae002e4d427933ef0e2d814f6f20a28cb", + "source": { + "epoch": "590558843", + "root": "0x0a2296bd093e94a57ac6cd73dbf471790515de406d47334df5dfa9a71150740b" + }, + "target": { + "epoch": "590943592", + "root": "0xe4dfa1bdcaa6d51b8f40ff1c33e348dff90ee01c00b6e1d899dd22175c8e05f6" + } + }, + "inclusion_delay": "13656186494852931817", + "proposer_index": "13654534011636247689" + }, + { + "aggregation_bits": "0x25e41cbe7b2b38d9fad489afcbd9c80478ed82c573eb220784d03762386767b5dbba2f8737d03679c85a8089c567863bd3018729b78a89442e15763149c3549327982f37cd4db4d8282a4e292abff148663081237c286248051b993084ca8d18e7f5c3b994eea4f20cdf2c907d58e0c72656c899fc93c779e96b3ee6a54ac5664b603d972084fe8981c81c1065940f10f2b3f5ca57974c7087cfcbb9d96616324d4557f925d06ef0d4748a74cfc08656e111520c7e684ef3d2d1a8326baded53ea8b6d720c1b85e185e86d0750b3247c74667318a3a424d05e1579dff52b39a2769f28322bf70f5f5266117c7f87551d33f0960985d59a93a92893a5be781f8101", + "data": { + "slot": "13649576557691228009", + "index": "13647924074474543881", + "beacon_block_root": "0x6ac778bd29b8f0fd4415d24cfda0d87a2424d91afd32ffefda65fb90543409c1", + "source": { + "epoch": "589212222", + "root": "0x3fb099bce8f11537ab0526be67f0e4eb1297b3c60efe0c92a592004bbf944158" + }, + "target": { + "epoch": "581901993", + "root": "0x196ea5bca85a57adc07f5767bfdebb510591b5a2a16cbb1d499079ba0ad3d242" + } + }, + "inclusion_delay": "13591739619337479752", + "proposer_index": "13583477203254059112" + }, + { + "aggregation_bits": "0x5b0456e9208eea1bc551a4276962c598148433ff379452d14ebf63ad0e3d74574ec240b3f4c0ceba987c44b96dc3f28f6d8e7af601af362232eb6fc8979b6db951e006e583b2a6b4978831b360f7ac51f93f60ceedb79c17fdc10a6172fb33f8d680c70adb1e08c0fb836342c8f2415de1dc31b5188600deee847618502627204ecdac926c77e88c1dc2fe81e53098f920472d311ff078f196f6f3a4cd6b35a9d603eb6e673073a661d85cc369c8baedf41d04e97e2666c20cddd2077cfd87c8a86fa19a729707c65a8b58b18de226acd11aae90016cf73642b089c4d94f0b52ddb9745c9a093c62dba0fe3f56427a5e1e4e27fc7db755d799f64d7a14e0d35f01", + "data": { + "slot": "13585129686470743240", + "index": "13576867266092355303", + "beacon_block_root": "0xebd964bc879aefa24a60c744d7bf9d214ab2aae8770c7c1d411d60556cfcb338", + "source": { + "epoch": "580940121", + "root": "0xc59770bc470331195fdaf8ed30ae74873eacacc40a7b2aa9e51ad9c4b73a4523" + }, + "target": { + "epoch": "579785874", + "root": "0x385e4dbc07c96cb61f6c64f226e3ef5563bea630502f1f06f8216e76d67f9163" + } + }, + "inclusion_delay": "13573562295364019751", + "proposer_index": "13571909816442302919" + }, + { + "aggregation_bits": "0x6969fcb290b275d2e74fdfa83c8b3c223ccc8f18315e9328d921398670aad0bca261b29ce274ceb958b5926a067c94b73b110c886647fa672daf19871f6c9cef86383fb48b4056c1915f547ee54a23f2ff68f08caf090f060a710f41175df32dd01ffc0ed9cdbc4b3f039475e15f058f986c190700c7f734c709df2cb4cfd41e9e121e0c583c3a0b84169ca6fafda9403c48c94aafb769104c9fdbf143aac4a6bf18495ab27df24cabdcebad1f1c0143b0f384985f0eeecb4b109c224060e9be7507a710f8928fd5a592af34910163fa277b566fbb46782ada2a9cfa340f0b7807828238ff231251ac4668ca9e09e3f578ede47f29ec3eea6dc20da86198d08801", + "data": { + "slot": "13619831851200979112", + "index": "13618179363689327688", + "beacon_block_root": "0x5a23e0bc68669efc2ce24eb57b86ee4ec772bfee829523d88084d6e7820aa9d7", + "source": { + "epoch": "584210486", + "root": "0x34e1ebbc28cfdf72415c805ed474c5b4ba6cc1ca1504d26324824f57ce483ac2" + }, + "target": { + "epoch": "584595235", + "root": "0xa7a7c8bce8941b1001eeeb62caa94083e07ebb365bb8c6c03789e408ec8d8602" + } + }, + "inclusion_delay": "13601654527227519112", + "proposer_index": "13606611972582604200" + }, + { + "aggregation_bits": "0x29bda59d8add6b54ac7e3741c0dec814c787affb7034d22af20871c189dfdb3ff48c72812a24949a878544c16b9f03ca32b56df7b8efe7186f4e0e56377aed300781432589181ddc28f23ea62b0b36808f0700513afed61d6b595eec9be68edf78881d9a215d0885aea92091564a5809eeaeb8b9d909f5b7101979be20805d7bdb6c1c549d57187b1160dee8ac2e1d7eb11f6c9b874cd723300139f4ed31629dc5497b0e48650097551d99852433cfebab641042fbca6979a75210acfd8563a5ca2c92a3e0938f63df07bf4b7e3aada2fe238f803ef204dd0fe565aac5604d0efc57dd7063d0d791c08b733572caaac5f50545c63583e552489fb6f88f86818c01", + "data": { + "slot": "13595044590065815304", + "index": "13600002039715867688", + "beacon_block_root": "0xe00ab7bcc877b9dee0b621e544447eeaf387b8ec7e1241efc00caf617bb0aca2", + "source": { + "epoch": "625186244", + "root": "0x9ce0b6c1911193380cb232ef0dc00147a0f48f9937278668c60b33d884368482" + }, + "target": { + "epoch": "625570993", + "root": "0x769ec2c1517ad4ae212c649866aed8ac94ee9175ca9534f46b09ac47d074156d" + } + }, + "inclusion_delay": "13953633602705093745", + "proposer_index": "13951981123783376913" + }, + { + "aggregation_bits": "0xbb8ede052586631b3cb1e1a0b09dfadca0acb0e0b9dc839c4e52689cd2db83def30014882aa202c5f7ef9f3357717ffee896893a07376ef6755c9f1d74e13cee18671cddc3b65cd877832e5e657ba0cccdf4730e982a9691227dcc94c506895db28708201dd8ed30c4fcec08270bab366da9991d35f9102af0578ecb7c6a7a6f4fa308e04bb5fc45191578192cc3489151d145a38aefb40ba0bb020439bd8d6f9b3c7a0904fbe8d73bae573c562eed075fe935cb20db17747c31c6d18e014c703a1d3df4ea544bdefd50f52b6a14defb39ff68e114343f10676d1b13c13180043e1cf48c55346420d3ed743be8f1ec6f20b4063a3e6e1dc22216f128b09d234401", + "data": { + "slot": "13947023669838357233", + "index": "13945371186621673104", + "beacon_block_root": "0xfc8599c1b18bef90d60037c8306c6848bf038b73c712520bab9184c1c81a1938", + "source": { + "epoch": "623839623", + "root": "0x6e4c76c170512b2e9592a2cc25a1e316e51585df0dc74668be981973e75f6578" + }, + "target": { + "epoch": "622685376", + "root": "0x480a82c130ba6ca4ab0cd4757e8fba7cd80f87bba035f5f3629692e2329ef662" + } + }, + "inclusion_delay": "13942066215893337552", + "proposer_index": "13986683279923678193" + }, + { + "aggregation_bits": "0x75fd2785476200e555ebd0a6958d116433755ee47519889466e07af33afdbd00ae8840c21a09a6a723589bbce75ba125038c4e6b3cf2e6c102c8b5af176fd6cd078b59c1cf99dc56bed772a6630b67cb276e212f83fd78640c4e141b16be53a28f19f03919100e49d264e3f7763cf3ce848f2766044032db9e5b24f40af194c74dfb6064f5680c9ed9f6aa5e63d117f62222d8934fce571432565a2c302fa1590235608de0ff3dddf6cd7acd124de4a9f540a70f3fdf2ab6e61a434cb3d0b9c18015517b4a4acb9b6597eb2a45d79d020c4a7136100084209790ebe63ad481042700d936d365ef9905970537218bf7bceeaab90973b7e3129d6f56243616859001", + "data": { + "slot": "13988335767435329618", + "index": "13980073347056941681", + "beacon_block_root": "0xb753fdc111861bfe8d8e5be622560baa55d09bc1abbe9caea1fd087548aceb01", + "source": { + "epoch": "627879487", + "root": "0x911109c2d1ee5c74a3088d8f7b44e20f49ca9d9d3e2d4b3a46fb81e493ea7cec" + }, + "target": { + "epoch": "626725240", + "root": "0x03d8e5c191b49811629af89370795dde6edc970984e13f9758021796b12fc92c" + } + }, + "inclusion_delay": "13976768380623573425", + "proposer_index": "13975115893111922001" + }, + { + "aggregation_bits": "0x41347d1592f5e4d454ec75dfa961e67068bbeda6723c137590f0769c5a34289613823bd64466cd687c37cf4b504fce2ab5aa1c2fbc6dffd9a06cf79207811c6746163b3dc84df2ed2883bc6f8667525f98c88e3a5c43149b7087a738a653bc78ce22da396eaff035ed7cbe8aee33b66073ff58bab576ef5784cf667f64140ab4da02bcaebe8daed625364b4a75edd59f790c5068b157d95b134300de69f3c8da9fb2e3c40acbddf48ed913729293be39c0b0a95184c6ac5196e6c7f50cfb08075b6f46886fb0e1930a4cb0daed8c5555045f28b42a8edbad433a1f74440e84784ed2549cecdc0791605f79400f08fc4046bfb10976da2181e05f4e3369e77d8301", + "data": { + "slot": "13970158443461869617", + "index": "13968505960245185489", + "beacon_block_root": "0xece100c1f0399d8fbecdb330ae517e1c625271474c7576f351b05f18f6f0b84e", + "source": { + "epoch": "618837887", + "root": "0xc69f0cc1b0a2de05d447e5d907405582554c7323dfe3247ff6add887412f4a39" + }, + "target": { + "epoch": "619222636", + "root": "0x3966e9c06f681aa393d950defc74d0507b5e6d8f259819dc08b56d3960749679" + } + }, + "inclusion_delay": "13899101635079681039", + "proposer_index": "13904059084729733423" + }, + { + "aggregation_bits": "0xbf8c41266a46e5960d385f5a8a5ee2ec2e3019deb98236920a8f6a724079ff24b2370d5a864795a95811cf5c65a9633a0d62c9f00ac931872eaeef7f5259a70a3a7672cf8776f5c8f248cfe1481fcf1220ebe85ca75cabc4081a9d657840439ebc72d602027a48066faad1756a3893caa434a813394312748321cbc379b820625bbfa8bb677e1ab399b838d475784ab832fc9af27a70af5c4fb03d419d6e20041114563a113d8cfe72cf458a14be86a0d0b82bf544e5b8fa41b917e36eac6a94b7bb2824531c650d85fb65224281b6c5b7aae03b88a25f5c6799cfeee07294a851648bf65907093681ba84336cce531ae1dbc7b82e3b6c814097dcc7862e7ddb01", + "data": { + "slot": "13892491697917977231", + "index": "13897449151862996911", + "beacon_block_root": "0x72c9d7c04f4bb87173a28660770f0eb88e676a4548f2930a92383892ef96bc19", + "source": { + "epoch": "616721768", + "root": "0xe58fb4c00f11f40e3234f2646d448986b37964b18ea68867a43fcd430ddc085a" + }, + "target": { + "epoch": "617106517", + "root": "0xbe4dc0c0cf79358548ae230ec63260eca773668d221537f3493d46b3581a9a44" + } + }, + "inclusion_delay": "13933803799809916912", + "proposer_index": "13932151312298265488" + }, + { + "aggregation_bits": "0x73b709eddadefb56d32d32f3b30d4aed76878a0afcfb33011dbffa225cf62b06d8a8af6de211b04dddaa0d614efd167fd6d830df9c02bf27b269c6df03b19bb5306375cd97c8ea453bdf37162f5b65a796c3f8df46a6b14bc3bd1ae7b747c9825940610d8c5b9dc48ce75712646f0cd8ba0ba0ce86d3d84cf0af4aa5e2262db16e6f459c6221ffb5d5e6ba3372d606b960376bed644be243b4f50399913d81eb7b46a5fe059f13e2a179d4ac2d23ed0f8fce9f96d13884d7a6bffbe6f9933af27646b80b65740e2b22e089c2a09f9e89d27680d260b6be7cc523429205c22a612e54439aca672a4c5398fcb1ef17e00fd7d07dc45620e149574a5c11f7f860a201", + "data": { + "slot": "13927193862648213104", + "index": "13925541375136561680", + "beacon_block_root": "0xe11253c1301767cb55240ed11bd65ee50a287f4b537b3bc5d09fae2405a5b1b8", + "source": { + "epoch": "621531130", + "root": "0x53d92fc1f0dca26814b679d5110bdab3303a79b7992f3022e3a643d623eafdf8" + }, + "target": { + "epoch": "620376883", + "root": "0x2d973bc1b045e4de2a30ab7e6af9b01923347b932c9edead88a4bc456e288fe3" + } + }, + "inclusion_delay": "13922236408703193424", + "proposer_index": "13913973992619772784" + }, + { + "aggregation_bits": "0x33e169e4f680e170c914d80ff6cd23fb8dccbc5d29d3708624de7424a89944859c65bf950a50ba8f0adb4fbbbae4e16f8eecf0a0dced130b5218cf7053730e6b989b0d3e013ae4cb00704dc2bc9ae9d4e6af820cc659663432bc494367fc9c61db57a839c44f6469b14de1f0594a594c6d8114f07e3cb2de316fc8343f642ab42d274712956e5d3750d1f8f51e99a2c179d082ae6fbec9f840d9631c61e650f63da01d32ffa6253b1db5b3929d3eb2c7a0d10d7d6bc78bdd4fb83fc945f6b35a7079b09eb98d1e5d454dd9af9ca749f228372a3d5542070b9ec97b42b405689d76eb74e3440cd64d1a74bf068946cc59f93d75f88e48137a521727931a7b21e201", + "data": { + "slot": "13915626475836456912", + "index": "13854484566754373102", + "beacon_block_root": "0x63253fc08ef965705b6f03c9f6f4238c30b65019cd54b8f2385713e91d6d5c30", + "source": { + "epoch": "613259028", + "root": "0x3ce34ac04e62a7e670e934724ee3faf124b052f560c3667edc548c5868abed1a" + }, + "target": { + "epoch": "612104782", + "root": "0xafa927c00e28e383307ba076441876c049c24c61a7775bdbef5b210a86f0395b" + } + }, + "inclusion_delay": "13851179600321004846", + "proposer_index": "13849527117104320718" + }, + { + "aggregation_bits": "0xbbde0bce6f581dd569a7774aecdeb0fd698acd7015d8868eb0d18a226612e9928c36baf5775de74cc7ed8207cc168cc050f6bdc45ca5f46b1927de056fc189a84fdecac7dfa8b79e55b30e560d7c7d2f9db6f90e8903e4eb53fcd398bd49fb39f529c83eb43bdb8b38716498706b64fcf8bc4e8bfbd0c0c37f47e38a8e4b19792c2bab070a6f9a0a15f03cb9559656746ec84bedd17408f1585a5891647d9a937c601341706482c145f3cabb4fd19fdec820735cafb7561f0f1a0e40d4ff21a4697da0e9d983a5972eb11799bf9279c631ae383338b2e53f902ecedfa6663c641e0ae988507dccf970f5ddb690eec6bb5a2184e5803fcef2ea86567675a2188401", + "data": { + "slot": "13844569663159301038", + "index": "13842917179942616910", + "beacon_block_root": "0x3591febf6e39fe65e44f73a60ed6055c75d7455fa3f478f22fe4f9837f963d26", + "source": { + "epoch": "610373412", + "root": "0x0e4f0ac02ea23fdcfac9a44f66c4dcc168d1473b3663277ed4e172f3cad4ce10" + }, + "target": { + "epoch": "610758161", + "root": "0x1ef3a2c0eff391dd12fd27e7e8dec6edc6826167b10003962ec3979c9cfe2efa" + } + }, + "inclusion_delay": "13879271827889536911", + "proposer_index": "13884229281834556591" + }, + { + "aggregation_bits": "0x57edf04a3de938e385e3c81f51cf5b5569fb72b45d25cc8c78c2588eac54579cf18f92afcee44364b61c97787c3682cb23fc7b210b6070dcc1b3fede05482017167b9fb757b687751a07568d222ca93273eefba91c70834e3ddfce032a68c944eebddaad3fe83cf606916b67ed6cb4c4f2f3d0e28643ea510d4b2d75e7e57dbcf873c58b2db2b9d397136a6a6b041097033af7e1d5defdb0dbcba3fc757ba704cb7d0d8530407f84c810da624fb234b0f0b2b8c9a0822becd4791fdce53b8c07ce4556fb4c1c24ebd46719940c04d67400238d46f5a21e5b0492066055a55e65057c38a090ccc323814700986b125ff699331f17e4f4fa4d16fdf9cee24a3aee01", + "data": { + "slot": "13872661890727833103", + "index": "13877619344672852783", + "beacon_block_root": "0x575691c0cfd62facf1c55d6963790455d98b5e1dd45a7dc4b74662f52b21559a", + "source": { + "epoch": "614413275", + "root": "0xca1c6ec08f9c6b49b157c96d59ae7f23fe9d58891a0f7221c94df7a64a66a1da" + }, + "target": { + "epoch": "614798024", + "root": "0xa4da79c04f05adbfc6d1fa16b19c5689f2975a65ae7d20ad6e4b701695a432c5" + } + }, + "inclusion_delay": "13861094503916076910", + "proposer_index": "13859442020699392782" + }, + { + "aggregation_bits": "0xbfea210cdbfc59bba712e61a84dd7dee8aa7e881d358903ffb8fdd75c6c2762b6a04183efb498549331792ea33eb5917d335d6c4f60702ebbb49f8856fbf0a5bad179432ce6ac68ea47b0df47041fbb95fce1f9ecb061b1ffc4e063ce65b15cc905c1a2451eedb44e60f78fdcb19ef1b035a930974ef7eef8f99ac79c2b103c228bb34ab3c67cf2cdc79b9cd1aff3ec9c8e5638144bb389fcf7b2c42dae1a1065c5f58ea76c43b240b3135f0d6519122bb6817d081b425bbb94b876b8f81f163a65b397775509a61621ead06e1b40299aeb8f24577ded129df4e925fb714dbda5fb76437043619806e5da6815dd2bbe8c4e3f623ac3f950e48266eb2e9bf56fc01", + "data": { + "slot": "13801605082345644525", + "index": "13799952599128960397", + "beacon_block_root": "0x8ce494bfad8ab13d2205b6b3ef7477c7e50d34a37511570967f9b898da6522e7", + "source": { + "epoch": "606910672", + "root": "0xffaa71bf6d50eddae29621b8e5a9f2950b202e0fbbc54b667a004e4af8aa6e27" + }, + "target": { + "epoch": "605756425", + "root": "0xd9687dbf2db92e51f71053613d98c9fbfe1930eb4f34faf11efec6b943e9ff11" + } + }, + "inclusion_delay": "13796647628400624845", + "proposer_index": "13788385208022236909" + }, + { + "aggregation_bits": "0x614a397e03095839bc2efa8ce27add768ce894fb8f2675db20428a99b4a3b5a3e8613d26b369dda8032982d7ab4d33816b77635f48228d7de587a05eba65ba23dd7fdccc169504bab9e31ab61e4164c466f5b5795698ed791497bce9306be22ee04d101576d14b7653c01363df1bcb10c3d14eb19c9abf6c947b944595dbeb482d9390afa2947be141f78b1e1c428d4c6a191b6b8fcc4a7a9348336faa6e83ce4859e87e250c722ed699630f605ca783ef45c77540cc7c9b4265714e95c697f8076771d307cefa5666b798f8e83dd12285462b7563d21889e7ec20c317f6d1214411df5de1ad19e587fb5bf07715f5abac2811c674b5d24e50ae2dfd07864c2401", + "data": { + "slot": "13790037691238921037", + "index": "13781775275155500396", + "beacon_block_root": "0xabd43cbf0cf9c64681f1c23e5579abcb433b253124d4baf1158bad54a512e107", + "source": { + "epoch": "604794553", + "root": "0x859248bfcc6108bd966bf4e7ae6782313735270db842697dba8826c4f15072f2" + }, + "target": { + "epoch": "609796288", + "root": "0x9436e1bf8eb35abeae9e777f30826c5d94e6403933e04495146a4b6dc37ad2db" + } + }, + "inclusion_delay": "13831349793130860718", + "proposer_index": "13829697309914176590" + }, + { + "aggregation_bits": "0x5b85d1a33095c1b09225a013259508c66680641c98dc241bf39dd4deca06c12387da25412ffd55a5d1e80005d3b3e1117ea91d450eda2128fd82c6b71b32a6e34ba3a2b9c8e681a19f22b33a6ff5bb4fe283667980274e60ba3c8cccff0dd2ab22e6c91419c1ff7b50dbd501ff37cad0aa49561ba4960af6f3ff6974303414e6fdefa2f3865f0be4db232d736bd618d0163f5fa97ecadeff4d63382ae0ad3392af0248ea7900f598de0d55030cb91cede54bc2404a54c58444ea377fad48db9e3a4eff1486e3f067fb28af7c51565577fe055f1a652468d3523b145c7ab0ad002e02ea9fa08e05d4f8745d95970a0c44ba6fd3c50836a03f94c0f12f73de6ee001", + "data": { + "slot": "13824739855969156910", + "index": "13823087372752472781", + "beacon_block_root": "0x1a1eb8bfedc475a063734aaff93ffcf8c0fb39372f5d62ac54f223e7bb20d6a6", + "source": { + "epoch": "608064918", + "root": "0xf4dbc3bfad2db71679ed7b58522ed35eb3f53b13c2cb1038f9ef9c56075f6791" + }, + "target": { + "epoch": "608449667", + "root": "0x66a2a0bf6df3f2b3387fe75c48634e2dd907367f088005950bf7310825a4b3d1" + } + }, + "inclusion_delay": "13806562531995696909", + "proposer_index": "13811519985940716589" + }, + { + "aggregation_bits": "0xebed10f1d9733661e6242cc6380e41b9807ec0d9040abcb592c515b37ec0cb97f034ed235def52dd43a819fc6d2bf35ed83b7de8bd458b72b4881fbb004968f46384bc995de8ef714b9426da553800b0d80b31a0d1d2f6de52a41ea34e5c5f072901b1f45ecd757447caae6732167765f8654014455f0c1f9876b90c3dcd40f07030b25c5703f34f3fcfaa7732c32753b26a23280425075ef7a24719942625ff1b902036b95a7bac67c4264a7e4d3fe1dc7ac27cefa5b2592395d83f7492fd00bbcaac49f5d32eed8ceb94f83a2f4428d9aaf65b5bd2c5eafcef46a461b987c3880edcae8acb342e416468ddde52750aacfadd65ff56732e9e5491f7ff0ca49101", + "data": { + "slot": "14170108998579995030", + "index": "14175066452525014710", + "beacon_block_root": "0xe914b2c456aa2e3f84b1c2e496449422746b10769e3ad0df8872eb259f076511", + "source": { + "epoch": "649040676", + "root": "0x5cdb8ec416706adc43432ee98b790ff1997d0ae2e5eec43c9b7980d7be4cb151" + }, + "target": { + "epoch": "649425425", + "root": "0x36999ac4d6d8ab5259bd5f92e467e6568d770cbe785d73c83f77f946098b423c" + } + }, + "inclusion_delay": "14158541611768238838", + "proposer_index": "14156889128551554710" + }, + { + "aggregation_bits": "0x29cbe1b70729d7b144dd8b11ff8d3f1663c15ca619679087780c85966056572a45fd6755ebcb99db6ca31d5801ff2851ac6f28f7c4e2f139a26029a9a2186ef1d4e8a6d45a900fc8bdd03c3297ed3a78b40bdf1b6684ffdf8b3142bc3e53d09f14e6357d904b92c62bb1b57d356226b956a0a241f4a5a9aa98a13f04d19a3c8e0474c05410d6d5f454201935dfa9f925ab07bdd829c28283a00380ef3a383bdb802e7759cf8ebf4d7c47e9b877aef2f30d91fe751b93b83a43a063857c28d2c8574443f0951d34ef3b8f3561cf8bb8d2ea25c9ded40ac0e9ef33521387881a7d76dc0aa916b169e58f1a55852bf38b96d5ae3413b7dd1255c18e049fe1dfb8aa01", + "data": { + "slot": "14151931678901502326", + "index": "14150279195684818198", + "beacon_block_root": "0xbb8071c436eac6340d9232c2ae2576f2b98c05bc74da90df80ffd1c001314607", + "source": { + "epoch": "647694055", + "root": "0xcb240ac5f73b193625c5b5592f40601e163e1fe8ef776cf7dae0f669d45aa6f0" + }, + "target": { + "epoch": "652695791", + "root": "0xa5e215c5b7a45aac3b3fe702882e37840a3821c483e61a837ede6fd91f9937db" + } + }, + "inclusion_delay": "14199853713660178519", + "proposer_index": "14191591293281790583" + }, + { + "aggregation_bits": "0x4fe11a3666f5b4852889a711cc9d89ea23b1a422c48abaa0b807d38d98b888b61f68dff5d3b03db9b81218539b57626ae7bd662ef5673d8eded43f9b303ac10f9948c70c1a3e7a63b0883575bbfde57f3ae4dde0b0d7192de432cb07d569c3e328f047e2fad85d1b113db392c0f4bc83319bec2b8336eb71a8a9b459e83852e3c42abd9f2709b621c0e3cde3f9bba64fe8550a4c0df247fe32a2fb8621a8d6ee9922693d138b5c182388e1223fc9d99daf0ee4f302a703f93d46701949c83ddb7c9821769d2a359bca4d2b60640b231bd433786bd633599d3dcf5acc74ab7bfeafa0b1138d88e3765b2c92fa89c668493e048e21db3425c46465aaa363d19ae801", + "data": { + "slot": "14193243776498474711", + "index": "14184981360415054070", + "beacon_block_root": "0x774ed5c496e4f2a1c41f57e0a00f19544e59160a5886db82766b567481c218d1", + "source": { + "epoch": "651733918", + "root": "0x500ce1c4564d3418da998889f9fdefb9425318e6ecf4890e1a69cfe3cc00aabb" + }, + "target": { + "epoch": "650579672", + "root": "0xc3d2bdc4161370b5992bf48dee326b886765125232a97e6b2d706495eb45f6fb" + } + }, + "inclusion_delay": "14181676389686718518", + "proposer_index": "14180023906470034390" + }, + { + "aggregation_bits": "0x75a61618dc6c4f33706ac1977e87123cc7c5d008d8e104a0399a99e6589afd330c3952cdadf5609aac7c0aadc4ac18c5417f8bdc7f2b429db5cd278f7693ec8d76cc9495ce1cef27c78b62690858c28d594ea2f23d8d3b319d5a4b4b8febe6a26b1802edfae4b67199493f92a0408971e0f3267924ccd5a562d4df4de81ee9ae71a454a0f84a117c73de8f0b228c7f55d5df80c3aba2a6e1791294090d362c0b73f7e5ce083b77e339ee886827267498cff67ac500c71c3b7a1531907ec1fb016f9b6590782cde51e3b1f5124f7cc3311b3a0623c3727f9a6b4daf194eac2cef5fc1840183e0f8eb312d3a1f286623b9bf215d3c5310317c8c6d9b427caec3a701", + "data": { + "slot": "14122186963821318837", + "index": "14120534480604634709", + "beacon_block_root": "0xacdcd8c375987433f55eaf2a2c0b8cc65bdbeb8ff93cb5c7261ead172f07e61d", + "source": { + "epoch": "642692319", + "root": "0x869ae4c33501b6a90bd9e0d385f9622c4fd5ed6b8dab6353ca1b26877b457708" + }, + "target": { + "epoch": "643077068", + "root": "0xf860c1c3f4c6f146ca6a4cd87a2edefa74e7e7d7d35f58b0dd22bb38998ac348" + } + }, + "inclusion_delay": "14104009639847858836", + "proposer_index": "14108967093792878517" + }, + { + "aggregation_bits": "0x25f26c946a51d0b4585221ff914a552338f7aa58092904ae14f39326f2f0df9044c852c502be66b1a358cd15b3a59a045959db3953007fc8bdb231697425d552f6f5c8c4125bf6a4f4f154bcfa89c7ab39009e693072ea8864570a0a0370d350899bf9998a103b3023a389789c71fcd712f9d742bf37fb9efdc758dc545be483127ddb0233157312c889c96d465f5b21c9aaa505e14d9cd4cf0cb88adeead52a0e075f0ac241e91a8d0eef0c193b8b4ceee0282fbb3f1bb19a6b96b8c0b4f638eaa5742924459e6ba917e5392306d058e477fb4e429292edefa25668d3c37b7959c5a3533c9205abcdc573fc2e9e5cab73cd7d8017a30a550532a040d069a7ef01", + "data": { + "slot": "14097399706981122324", + "index": "14102357160926142004", + "beacon_block_root": "0x32c4afc3d4a98f15aa33825af5c81b6287f0e48df6b9d2de66a6859128ade9e8", + "source": { + "epoch": "646732183", + "root": "0x416848c495fbe116c26605f277e3058ee4a1feb97157aef6c087aa3afad649d2" + }, + "target": { + "epoch": "647116932", + "root": "0x1b2654c45564238dd7e0369bd0d1dcf3d89b009604c65c82658523aa4515dbbc" + } + }, + "inclusion_delay": "14138711804578094709", + "proposer_index": "14137059321361410581" + }, + { + "aggregation_bits": "0xd3aa3c5ee8c86d56bf474c449e06cf2d24cb554e4851122153419618feeafa9a2f19783a03e84b7556e60b0b22c04990f2d8421ad08ab46927f50349bbe855ec34ac8e0040ec683755a2c1987da475928f2d4476fd81d40522d89deb50565a146e29f4d747d9b626472f07f7f2b603169907dad2238763ce9e69d89a2dc9ead887f4eb242e40769840938befddf5b608da60999f8474e0813418e252d6ba105df55daeee8eebe626963cee003caef0e1bcf66d58fef599dcce441c9b15bf0ec2a81aed2f1b7de98b6d1e49999308a86200aca9a784bc4bb7ca3eabb4163fc09216dca8bbc56225832e4bd97e6c061ff211cfcdfa7752ce959eec2786e03aee9e01", + "data": { + "slot": "14132101871711358197", + "index": "14130449388494674069", + "beacon_block_root": "0xa10d2bc4b5753e6f8cb509cb998f6c8f04b1f99300437a99a50dfc233ebbde87", + "source": { + "epoch": "645385562", + "root": "0x13d407c4753b7a0c4c4775cf8fc4e75d29c3f3ff46f76ef6b81491d55c002bc8" + }, + "target": { + "epoch": "644231315", + "root": "0xed9113c435a4bb8261c1a678e8b2bec31dbdf5dbda651d825c120a45a73ebcb2" + } + }, + "inclusion_delay": "14127144417766338517", + "proposer_index": "14066002512979222003" + }, + { + "aggregation_bits": "0x2d0364e9b67c2f8e3592c5901928dbef22a28cb8022e7fdd803ecb54c0b3f134cb7c5e0660a903f403184f7b8a8727c4fa2ef7c177af3b0f6d3f12a4f4306d8080e087960fcf78128a1af70f33a5b972a70cec856496a850db012d27866666a4767e74ac68666425d2f86800173d261d9f8c2c3ac796a08799acf02652c6ca8f069f6b3083a3a2a9e39538bcd9d041a5d19ad040c1d0f6402b3aabef6a2534975ec79930cc153f2ca88438db2aab08d6b9922edfff94bfff10cc3abe3ff8325a638ea7ba2b69219fe997816716916bd237123c2ba0b0a21dee9f4baf9463c22219fba40430292f734fafb65d478910b36080ba4d27118df56e3df0632f22dec601", + "data": { + "slot": "14067655000490873427", + "index": "14059392575817518195", + "beacon_block_root": "0x222017c313583d149200ffc274ae3136293fcb617b1cf7c60cc560e8568389ff", + "source": { + "epoch": "637113460", + "root": "0xfcdd22c3d3c07e8aa87a306ccc9c089c1d39cd3d0e8ba552b1c2d957a1c11aea" + }, + "target": { + "epoch": "635959214", + "root": "0x6fa4ffc29386ba27670c9c70c2d1836a424bc7a9543f9aafc3c96e09bf06672a" + } + }, + "inclusion_delay": "14056087609384149939", + "proposer_index": "14054435121872498515" + } + ], + "justification_bits": "0x05", + "previous_justified_checkpoint": { + "epoch": "223123644", + "root": "0x8be6c8917c79927f22583b48cdcfa690a5a57e85e2c77c3971ab4fcf5feda0ff" + }, + "current_justified_checkpoint": { + "epoch": "228125379", + "root": "0x9a8a61923dcbe4803a8bbedf4fea90bc025798b15d655851cb8c7478311701e9" + }, + "finalized_checkpoint": { + "epoch": "228510128", + "root": "0x74486d92fd3326f74f05f088a8d86722f6509a8df0d306dd6f8aede77d5592d3" + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/events/schema/AttestationElectra.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/events/schema/AttestationElectra.json new file mode 100644 index 00000000000..59d61a7c416 --- /dev/null +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/events/schema/AttestationElectra.json @@ -0,0 +1,28 @@ +{ + "title" : "AttestationElectra", + "type" : "object", + "required" : [ "aggregation_bits", "data", "signature", "committee_bits" ], + "properties" : { + "aggregation_bits" : { + "type" : "string", + "pattern" : "^0x[a-fA-F0-9]{2,}$", + "description" : "SSZ hexadecimal", + "format" : "bytes" + }, + "data" : { + "$ref" : "#/components/schemas/AttestationData" + }, + "signature" : { + "type" : "string", + "pattern" : "^0x[a-fA-F0-9]{2,}$", + "description" : "SSZ hexadecimal", + "format" : "bytes" + }, + "committee_bits" : { + "type" : "string", + "pattern" : "^0x[a-fA-F0-9]{2,}$", + "description" : "SSZ hexadecimal", + "format" : "bytes" + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/events/schema/Attestation.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/events/schema/AttestationPhase0.json similarity index 93% rename from data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/events/schema/Attestation.json rename to data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/events/schema/AttestationPhase0.json index b66acc1e1b8..980a5264304 100644 --- a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/events/schema/Attestation.json +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/events/schema/AttestationPhase0.json @@ -1,5 +1,5 @@ { - "title" : "Attestation", + "title" : "AttestationPhase0", "type" : "object", "required" : [ "aggregation_bits", "data", "signature" ], "properties" : { diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/getAggregateAttestation.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/getAggregateAttestation.json index 023cfc3fa98..dff86239547 100644 --- a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/getAggregateAttestation.json +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/getAggregateAttestation.json @@ -1 +1,19 @@ -{"data":{"aggregation_bits":"0x4a9278690f62e1a353f1abf2b9701e13e8cdf4d9ac6b032ba43b05b25f713540ce24f3192819e752fb091217ff34b68e934a06d316b6060696f8f24749574c4b3ac2e4ccb6914c434b09a81fff523e12acbe299fcdad715593298d72ca70e1ffc743ad7ce89587fbb4b4c57db7856b7082db70ebddcbebe264f886236df2dd51539e10d4dcd5950e6cea7c993d3e999a5589a4c71669ffb1390987e43a8c4790a70275364f96cbee34b0b5a9d1b3da4322ad12e07c81c6e6430d2528f19bb1727c3f63f414885bd97505283b0bb6773712096d5feb67c43d67f2fbf17bf796ed5080aece6b968d532d985ad2553daf31ad4022aa49d7a92ada719c9f93ab4b6f01","data":{"slot":"4665021361504678828","index":"4669978815449698508","beacon_block_root":"0x103ac9406cdc59b89027eb1c9e97f607dd5fdccfa8fb2da4eaeea9d25032add9","source":{"epoch":"542502839","root":"0x8200a6402ca295554fb9562193cc71d60272d63beeaf2201fdf53e846e77f919"},"target":{"epoch":"542887588","root":"0x5cbeb140ec0ad7cb653388caecba483cf66bd817821ed18ca1f3b7f3b9b58a04"}},"signature":"0xae401f767ab1917f925fe299ad51a57d52f7cc80deb1cc20fa2b3aa983e4e4d23056d79f01f3c97e29c8905da17e70e30c2a3f6bdd83dbc4ddf530e02e8f4d7ba22260e12e5f5fe7875b48e79660615b275597e87b2d33e076664b3da1737852"}} \ No newline at end of file +{ + "data": { + "aggregation_bits": "0x9827585d426605f0a23b9e5655df2c9b501c6282a5f6fae2fd7d5e0bdb68956e5b396afdfa9429f71e6e46ce94b24c59a4ca399550d1eccd9132ddc8c623328fd26ffad9a0d317fa12c74fe24eaaed6af7c42ab575d7d1d67fc4c3f1a42ebfba009b6ffc09671e81630d44851d5881782c1e25b9bb224b6f3e326221dfe891a480eb8fb6b93496a3836eb84d14bdd14706b06561622086cc5b5599be5c85252c2fb381141967c86c0aac570904117a3ae74d23572cdacff735639f1be45bcb7361cfbaf2970c5a0ec22004c4bfcfa8f75398984d07612c95523f1f39d17ed2b606cdd95e2ce4f41553918ac38030fbd280fc33c4c12a96052807f2e0cbbe1dcb01", + "data": { + "slot": "4669978815449698508", + "index": "4668326327938047084", + "beacon_block_root": "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f", + "source": { + "epoch": "542310465", + "root": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + }, + "target": { + "epoch": "542695214", + "root": "0x1f86d83f0bf91cc0d7e07410828140e0dddbb331dc20b6743f9f79e549b50b11" + } + }, + "signature": "0xb3a22ab9ec46aec35a9dacfb9036375ea1528041a926cb9d2d315ab964e82be5d6990e7fef2343f2dbb4c2b7dd74687f11144beaeb5758ebe349762b4dbde5e67bbc8d89a95a803c6610631d178249917cbf0d8b11bd8740f3cb767c843aa88c" + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/errorListBadRequest.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/errorListBadRequest.json new file mode 100644 index 00000000000..3c6e1f892f1 --- /dev/null +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/errorListBadRequest.json @@ -0,0 +1 @@ +{"code":400,"message":"Some items failed to publish, refer to errors for details","failures":[{"index":"0","message":"Darn"},{"index":"1","message":"Incorrect"}]} \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/getAttestationsELECTRA.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/getAttestationsELECTRA.json new file mode 100644 index 00000000000..784409b894b --- /dev/null +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/getAttestationsELECTRA.json @@ -0,0 +1,41 @@ +{ + "version": "electra", + "data": [ + { + "aggregation_bits": "0x9827585d426605f0a23b9e5655df2c9b501c6282a5f6fae2fd7d5e0bdb68956e5b396afdfa9429f71e6e46ce94b24c59a4ca399550d1eccd9132ddc8c623328fd26ffad9a0d317fa12c74fe24eaaed6af7c42ab575d7d1d67fc4c3f1a42ebfba009b6ffc09671e81630d44851d5881782c1e25b9bb224b6f3e326221dfe891a480eb8fb6b93496a3836eb84d14bdd14706b06561622086cc5b5599be5c85252c2fb381141967c86c0aac570904117a3ae74d23572cdacff735639f1be45bcb7361cfbaf2970c5a0ec22004c4bfcfa8f75398984d07612c95523f1f39d17ed2b606cdd95e2ce4f41553918ac38030fbd280fc33c4c12a96052807f2e0cbbe1dcbac4a17e4c8a6041077468bb47e4c556e28153f8eff2c061036fb2dee285a45df386ac52ff9f4338aa06e169d04880eac988fca2453ae6f4fd72ee2e298aa82319001e10d82a03c58fbf9015fa2cb58f20f29c18c92fe321e9b9bcb061767b1054cbf99d3f34a82a63c4b43e00f928632ea40e7846ce450781b307841950923059e7d45b4b142c0e3dbcf5c6ae6733a2131ac6b9d66294b9823ea4e321c3e30c4b2f4f1660816aa665d8bdebe4a7ff38c772b1f9d2ebca10af70e90314668d75881b704d819dd7c4073599477d281bcb9e45842cb1f4b5942854ca83e2318285b24420bf0e53ce2d713ad1ec83f5336e1a4cf8d08b5bde5314e2566093d2793a8430d666e8995f5e71991e930fc45abfc67a7de0e7fcd27adb94334377ea703e3c7f39e0a92f5fb0c28e0e4ca92218e6fae157a74f97bf49ed75921a55d87fb97e04d879d4928c348fa2e79db213918f98f1089854dfac64845051f78e647101eb5c5dd339d7bd3f156fd22bb544e59adc6074d583814284a40c7608b5d6429ae02fdfc9cd873554b9f7c0a81f6b69f856ed66075c94877e2a6d7a298a688d2329ca50d6b4585f005e62ab163ef5603f26f998ff1cd48ee6cc509a2d8b497c8a533344fde12a300e4319bf5b54aaacff6bc222f2fcf3d20ed2cdcc54e6a3040f3fec9abd95dfafe5aa0383cbd3f7b5c71dba07422b717c5e65db1a95b2691b8ebafcdebbfb8febe622f49c1b48affd7a7c24693592ebe69834d65c74fa2cf025e36115dc345f7c16da37659fb58646f8f98819ff70c38c825b75ae3ef61f9b3f127c4b294dc04340c11e5f03fb370f445028488354017392d09e17fc2bbe60d76b99acdda94a846d431ece3b6311e55e95836c768aa39e6485d0b4cd6ae5f5e9c8fc4ec8359505edb76e622ae2ea4f42e6b9424cdd5953109eeba188718f4b17eda005f3c87c52070f0e97972e0ba48adbae11045262e27ee3f1f17ea1bca8888f58cc4a1a830bc00935cbe8982563daeb1e60ad9e373bc2a980b7032bf3013369d5d23d3763e499cb3950610aff05a4df9a8752c1b4b0eb3e94a97f34ae7896201", + "data": { + "slot": "4669978815449698508", + "index": "4668326327938047084", + "beacon_block_root": "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f", + "source": { + "epoch": "542310465", + "root": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + }, + "target": { + "epoch": "542695214", + "root": "0x1f86d83f0bf91cc0d7e07410828140e0dddbb331dc20b6743f9f79e549b50b11" + } + }, + "signature": "0xb3a22ab9ec46aec35a9dacfb9036375ea1528041a926cb9d2d315ab964e82be5d6990e7fef2343f2dbb4c2b7dd74687f11144beaeb5758ebe349762b4dbde5e67bbc8d89a95a803c6610631d178249917cbf0d8b11bd8740f3cb767c843aa88c", + "committee_bits": "0x04" + }, + { + "aggregation_bits": "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", + "data": { + "slot": "4592312065610838826", + "index": "4597269519555858506", + "beacon_block_root": "0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1", + "source": { + "epoch": "534038364", + "root": "0xcbafa33faaa1f62b763b1697f350f91515f7aa53462f2500db29d9eff71c7ef1" + }, + "target": { + "epoch": "534423113", + "root": "0xa56daf3f6a0a38a28bb547404c3fd07b08f1ac2fd99dd38b7f27525f425b0fdc" + } + }, + "signature": "0x8f2f048d2061f5e290f2fcbe3ba5ab2d85fb62db534e5e49d985475e3ac39e317db50af5dbc2fd94c81284c10c3ff5930b21b375837f13de2cb209aa8804af037f75dde5900da65d98d717bdee5549f3de2f544b576e860a001fb69b5ac82e5f", + "committee_bits": "0x00" + } + ] +} \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/getAttestationsPHASE0.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/getAttestationsPHASE0.json new file mode 100644 index 00000000000..dddcacddde2 --- /dev/null +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/getAttestationsPHASE0.json @@ -0,0 +1,39 @@ +{ + "version": "phase0", + "data": [ + { + "aggregation_bits": "0x9827585d426605f0a23b9e5655df2c9b501c6282a5f6fae2fd7d5e0bdb68956e5b396afdfa9429f71e6e46ce94b24c59a4ca399550d1eccd9132ddc8c623328fd26ffad9a0d317fa12c74fe24eaaed6af7c42ab575d7d1d67fc4c3f1a42ebfba009b6ffc09671e81630d44851d5881782c1e25b9bb224b6f3e326221dfe891a480eb8fb6b93496a3836eb84d14bdd14706b06561622086cc5b5599be5c85252c2fb381141967c86c0aac570904117a3ae74d23572cdacff735639f1be45bcb7361cfbaf2970c5a0ec22004c4bfcfa8f75398984d07612c95523f1f39d17ed2b606cdd95e2ce4f41553918ac38030fbd280fc33c4c12a96052807f2e0cbbe1dcb01", + "data": { + "slot": "4669978815449698508", + "index": "4668326327938047084", + "beacon_block_root": "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f", + "source": { + "epoch": "542310465", + "root": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + }, + "target": { + "epoch": "542695214", + "root": "0x1f86d83f0bf91cc0d7e07410828140e0dddbb331dc20b6743f9f79e549b50b11" + } + }, + "signature": "0xb3a22ab9ec46aec35a9dacfb9036375ea1528041a926cb9d2d315ab964e82be5d6990e7fef2343f2dbb4c2b7dd74687f11144beaeb5758ebe349762b4dbde5e67bbc8d89a95a803c6610631d178249917cbf0d8b11bd8740f3cb767c843aa88c" + }, + { + "aggregation_bits": "0xb4a12e84d6e7598e246347c9df0778036a543cf20a90811be8c174b87cc98e0e0ba76fd9c7076eb7a9e484775545f6d5f2250b82098ec29be0e58139a4f463a2114f5321f6eec21a7b42baed386ceef459fbd893203af7ba9fcd9a66026acd536f0dc4e94bf34d909acd179b6aa21b824682d768d2d1d60682db4c0416dc9580432f4646a680f5f28857fabf55aa4c3fb5e97c2607fdf744013208f3db52ba768bd7ad4949a4a5ddd7d268ed35f6a3724f49761f9c4ff623695bec713896100742b7e0e96b3f174595d21b82a5acff69f98885460e338639bd25b48adfdcfb1d07b040bacf552a17e369197d0711717a54944a551f8c56a1335d6a443d61786f01", + "data": { + "slot": "4593964548827522954", + "index": "4592312065610838826", + "beacon_block_root": "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "source": { + "epoch": "535000236", + "root": "0xb88ea93f0a5617e780f8ae6b1fc8e4480ff4abc18f66fc45ada895271cbcc666" + }, + "target": { + "epoch": "533845989", + "root": "0x924cb53fcabe585d9672e01478b6bbae02eead9d22d5aad151a60e9768fa5751" + } + }, + "signature": "0x93bcd24f4a430255688b4a9a548da6f88a03bcf775104980edb7e818a3eb26f40ed8981681e4c92e4f02360fcc91bfdf062466e46c2a11058d2200e378fec149f13445aa520ea8e87bd94d3b260478c4ac0a92c27a3af35dae1e843e4112e05c" + } + ] +} \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/getAttesterSlashingsELECTRA.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/getAttesterSlashingsELECTRA.json new file mode 100644 index 00000000000..0c5795d97f4 --- /dev/null +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/getAttesterSlashingsELECTRA.json @@ -0,0 +1,93 @@ +{ + "version": "electra", + "data": [ + { + "attestation_1": { + "attesting_indices": [ + "4665021361504678828", + "4669978815449698508", + "4668326327938047084" + ], + "data": { + "slot": "4660063907559659148", + "index": "4658411424342975020", + "beacon_block_root": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379", + "source": { + "epoch": "542695214", + "root": "0x1f86d83f0bf91cc0d7e07410828140e0dddbb331dc20b6743f9f79e549b50b11" + }, + "target": { + "epoch": "535384985", + "root": "0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb" + } + }, + "signature": "0xae757bc04a0f7ee8e8d1668c8de3fd4ca45ca7e8f7ad7d3323350213956386cfc97094f156a7d6ab2d3ebe6a7eb7ce2c10d0d32091ee4867224ef5856bff529e9f0c2cb9c0085a28f6a47d75aae926913f681a6b21e25b093b78e3cf188bb6be" + }, + "attestation_2": { + "attesting_indices": [ + "4665021361504678828", + "4669978815449698508", + "4668326327938047084" + ], + "data": { + "slot": "4593964548827522954", + "index": "4592312065610838826", + "beacon_block_root": "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "source": { + "epoch": "535000236", + "root": "0xb88ea93f0a5617e780f8ae6b1fc8e4480ff4abc18f66fc45ada895271cbcc666" + }, + "target": { + "epoch": "533845989", + "root": "0x924cb53fcabe585d9672e01478b6bbae02eead9d22d5aad151a60e9768fa5751" + } + }, + "signature": "0x93bcd24f4a430255688b4a9a548da6f88a03bcf775104980edb7e818a3eb26f40ed8981681e4c92e4f02360fcc91bfdf062466e46c2a11058d2200e378fec149f13445aa520ea8e87bd94d3b260478c4ac0a92c27a3af35dae1e843e4112e05c" + } + }, + { + "attestation_1": { + "attesting_indices": [ + "4579092195582398506", + "4584049649527418186", + "4582397162015766762" + ], + "data": { + "slot": "4627014230341074699", + "index": "4625361742829423275", + "beacon_block_root": "0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650", + "source": { + "epoch": "538847725", + "root": "0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390" + }, + "target": { + "epoch": "537693478", + "root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b" + } + }, + "signature": "0x89253547c4da2415ab254923840e8988872bb213d72482da53998afaf78d3d4be75b3d45dafa853e297c274286792098167a69856d813f5b38d1eecbca1a63d67e6f38acd72149931b5b9bf53d45b94c3b2b81d7183c1f18836bf1dbbd7e019a" + }, + "attestation_2": { + "attesting_indices": [ + "4579092195582398506", + "4584049649527418186", + "4582397162015766762" + ], + "data": { + "slot": "4613794356017667083", + "index": "4612141872800982955", + "beacon_block_root": "0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5", + "source": { + "epoch": "537308729", + "root": "0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6" + }, + "target": { + "epoch": "536154483", + "root": "0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0" + } + }, + "signature": "0x987deb6cea81585136778dd3825ee4bc58bbbf1f007b9d2c819c4441de0c6c4f727aef2aa8e373231d451f3f2ee72a7e0e4e6d8e3f24c0c0371fe0bf37fed52eab8615b90cb16cfd74d7d47f9de296c35481ece0c3f2b23a25e9085515e6d0e4" + } + } + ] +} \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/getAttesterSlashingsPHASE0.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/getAttesterSlashingsPHASE0.json new file mode 100644 index 00000000000..3d69e02389b --- /dev/null +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/getAttesterSlashingsPHASE0.json @@ -0,0 +1,93 @@ +{ + "version": "phase0", + "data": [ + { + "attestation_1": { + "attesting_indices": [ + "4665021361504678828", + "4669978815449698508", + "4668326327938047084" + ], + "data": { + "slot": "4660063907559659148", + "index": "4658411424342975020", + "beacon_block_root": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379", + "source": { + "epoch": "542695214", + "root": "0x1f86d83f0bf91cc0d7e07410828140e0dddbb331dc20b6743f9f79e549b50b11" + }, + "target": { + "epoch": "535384985", + "root": "0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb" + } + }, + "signature": "0xae757bc04a0f7ee8e8d1668c8de3fd4ca45ca7e8f7ad7d3323350213956386cfc97094f156a7d6ab2d3ebe6a7eb7ce2c10d0d32091ee4867224ef5856bff529e9f0c2cb9c0085a28f6a47d75aae926913f681a6b21e25b093b78e3cf188bb6be" + }, + "attestation_2": { + "attesting_indices": [ + "4665021361504678828", + "4669978815449698508", + "4668326327938047084" + ], + "data": { + "slot": "4593964548827522954", + "index": "4592312065610838826", + "beacon_block_root": "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "source": { + "epoch": "535000236", + "root": "0xb88ea93f0a5617e780f8ae6b1fc8e4480ff4abc18f66fc45ada895271cbcc666" + }, + "target": { + "epoch": "533845989", + "root": "0x924cb53fcabe585d9672e01478b6bbae02eead9d22d5aad151a60e9768fa5751" + } + }, + "signature": "0x93bcd24f4a430255688b4a9a548da6f88a03bcf775104980edb7e818a3eb26f40ed8981681e4c92e4f02360fcc91bfdf062466e46c2a11058d2200e378fec149f13445aa520ea8e87bd94d3b260478c4ac0a92c27a3af35dae1e843e4112e05c" + } + }, + { + "attestation_1": { + "attesting_indices": [ + "4579092195582398506", + "4584049649527418186", + "4582397162015766762" + ], + "data": { + "slot": "4627014230341074699", + "index": "4625361742829423275", + "beacon_block_root": "0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650", + "source": { + "epoch": "538847725", + "root": "0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390" + }, + "target": { + "epoch": "537693478", + "root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b" + } + }, + "signature": "0x89253547c4da2415ab254923840e8988872bb213d72482da53998afaf78d3d4be75b3d45dafa853e297c274286792098167a69856d813f5b38d1eecbca1a63d67e6f38acd72149931b5b9bf53d45b94c3b2b81d7183c1f18836bf1dbbd7e019a" + }, + "attestation_2": { + "attesting_indices": [ + "4579092195582398506", + "4584049649527418186", + "4582397162015766762" + ], + "data": { + "slot": "4613794356017667083", + "index": "4612141872800982955", + "beacon_block_root": "0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5", + "source": { + "epoch": "537308729", + "root": "0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6" + }, + "target": { + "epoch": "536154483", + "root": "0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0" + } + }, + "signature": "0x987deb6cea81585136778dd3825ee4bc58bbbf1f007b9d2c819c4441de0c6c4f727aef2aa8e373231d451f3f2ee72a7e0e4e6d8e3f24c0c0371fe0bf37fed52eab8615b90cb16cfd74d7d47f9de296c35481ece0c3f2b23a25e9085515e6d0e4" + } + } + ] +} \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/getBlock.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/getBlock.json index 8abf8236476..4cfce383415 100644 --- a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/getBlock.json +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/getBlock.json @@ -1 +1,200 @@ -{"version":"altair","execution_optimistic":false,"finalized":false,"data":{"message":{"slot":"1","proposer_index":"4666673844721362956","parent_root":"0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef","state_root":"0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e","body":{"randao_reveal":"0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71","eth1_data":{"deposit_root":"0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f","deposit_count":"4658411424342975020","block_hash":"0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379"},"graffiti":"0x0000000000000000000000000000000000000000000000000000000000000000","proposer_slashings":[{"signed_header_1":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b","state_root":"0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb","body_root":"0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486"},"signature":"0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483"},"signed_header_2":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6","state_root":"0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26","body_root":"0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1"},"signature":"0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1"}}],"attester_slashings":[{"attestation_1":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4580744678799082634","index":"4579092195582398506","beacon_block_root":"0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c","source":{"epoch":"533461240","root":"0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565"},"target":{"epoch":"538462976","root":"0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650"}},"signature":"0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc"},"attestation_2":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4620404293179370891","index":"4618751809962686763","beacon_block_root":"0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b","source":{"epoch":"538078227","root":"0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb"},"target":{"epoch":"536923980","root":"0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5"}},"signature":"0xa32991816eb9f297553b4732309a4cdba7b33287264611715b0ab3319bca19e581da6e2659912a4e0e94aafc01c488e30ffc96ed14e2a726b9d3c618405ee0bf54bf6ae7f2097465cb27ab8132ec24eb93d3c9159475304082f7f0e452b93b65"}}],"attestations":[{"aggregation_bits":"0xfa79cdb89d0d51c5cdd001b7425c6d726750a9d5f89ade6ed9890ce3a706140c399a5e10c90a819094b65322dac7501f7c75471e69d4567358d8ca75f7c1b3133ebecf006b369a1f36efc5f2b706d5922ff98c58a1825a53a864376658f816600cf021cea843d4396502bb9c74d1510afe26036f89f783b4f5c7bacb6649c46f217a6af835f312d6fa253d2bbc83c07993f4f10de2ed2d952689379dbe4f794c1a1055a6b364d68e038deec9667f576b3b9eca5fcadd6298f181e1edb876efc3d0975ae14ae9a0ad2f1836d4c3f1080a96d8ab7c43b34bb2eda895ff66be698b363cfa4be33da3ec94a1a7a90672fd12c4a59916bb937e78476e4f08e4f4031001","data":{"slot":"4605531939934246443","index":"4610489389584298827","beacon_block_root":"0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b","source":{"epoch":"529421377","root":"0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2"},"target":{"epoch":"529806126","root":"0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd"}},"signature":"0x8f8d16b39e14569aab1b712e5c19ed51afe3600a6b017e8ab432f43a02ee720a733c33ef087d2f3653a9701e8d8a836301655b9195c0373b775c88ba1368e5d55354a70a3096bd26dee29dddbe7a4820e2b1653e84122beacbc01af7d93e6bdc"},{"aggregation_bits":"0x4ac567b296efbf7cf3209e87096a7a1a50fd523400113f917f6584a5a306f06b2d8da9ae858d47ff2594010089838efe41f19a78d9aae27c2ffde26f278b8681db9d091eb72e7cab3e449dfccd46a270693e1f88f197324e57bfd45573315cf9fb60d770937b32f7c0c6ce1581ec51e6b60f71acfde304dc917f2e0aa7872038b7d9140d15f7927c23a0490a74c2b0aca2773fed9217067e4444f9ca93874e4ff8407111c3efdb138b97c6d4957b6a70ec1debb283e3d0eb1cfef068adcffbf057d20fdc339eae03f0fa2613abdde8158a7fc40c3cfd1117eb6f8c4ae21d6b2ab4b57ae9a8653a34451aee6418c0c3609dc937293f5f5b346a7ab1a0d144185101","data":{"slot":"4544390030852162633","index":"4542737547635478505","beacon_block_root":"0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd","source":{"epoch":"527690007","root":"0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8"},"target":{"epoch":"528074756","root":"0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8"}},"signature":"0x90309dd491ae6ed51917dc305a3d4ae68d0a0d4792c7eb59c193bd03605bd94e61cab37502de0ad3e6162bc02427bba80a798b3670d5de82a854094016cc298b265371345c0e3ac49fd44bbb9ba0d4fcea0c1a80cecb60e93921d907e8c48120"},{"aggregation_bits":"0xe8c9759f0840f980ae956b15fc383d992e7d4420d12ba5bf32f669f446ac6fa388e20e5ce96e9266dd98840179d2cde3cabd9a8bafab5dec9c2e89f7f78c989e690548603984803b80c82d7b76443194576a1ce49da5cfe56f56e83b745fb01b5f18ccc86d88f5a22d927e64ff0b8e880893abcddec45b268531c4a0697537dae643a24b1a36432f37d42962553bd39af71f37e0429b81470c11316aa39db074aa3f1df4124e7cb203debed60b885ffb9b27e46a1434e81bbd56566632d0729c0822ac415cbb67f25973667d88e58df9c2f058a0ae7f118c98cc448453b6fbe590363bd17ed62c2f808df61f2a9e593235eeb56db74b9dd15980189a5271468301","data":{"slot":"4529517677607038185","index":"4574134745932346122","beacon_block_root":"0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947","source":{"epoch":"532884117","root":"0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31"},"target":{"epoch":"531729870","root":"0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672"}},"signature":"0x8c40f51a99fce6ebb9a4db5e80d715fff319e7ae523e46afb5d03c000d427e23c7a39e77e2af53851706283c8ca91d680997cb459386fbdff52c4d0ecf498e173717a838a792b210bdffaf476538628584a133899bf30dd5ce7056463b8cd683"}],"deposits":[{"proof":["0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c"],"data":{"pubkey":"0xb1f8f6e731dbf6b4e3265fb857c7190adbfc7e6cc95ce2e8bda72be8b6ea3459f862310a2484c3b0ee33b30920f18c1d","withdrawal_credentials":"0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c","amount":"32000000000","signature":"0xb594382214f5bdd375de66c45e1c61a526c7b73fb166c72433bbd9c2a7ad6881244e61cc6427e0206a50b762a129d8830e8708c55761d61ce9e3b19c1bee13bc55daa13bdb07118efdbf57a588b8a64e6392d14f935e53b68933e3355b35acdb"}}],"voluntary_exits":[{"message":{"epoch":"4562567354825622634","validator_index":"4564219838042306762"},"signature":"0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e"}]}},"signature":"0xaacffaf60c8253477ecad70de8589f2ef7670d0b0dc446d4baac3b465a901d3e64bb6d2c3d8bdb58aed45ac30466261416d152d5ae242204201bf6decfddde697ae0c5d44cf31ca3d43aa18f2799461fc1ee14dbf905b1e31f242fd31c083c5a"}} \ No newline at end of file +{ + "version": "altair", + "execution_optimistic": false, + "finalized": false, + "data": { + "message": { + "slot": "1", + "proposer_index": "4666673844721362956", + "parent_root": "0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef", + "state_root": "0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e", + "body": { + "randao_reveal": "0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71", + "eth1_data": { + "deposit_root": "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f", + "deposit_count": "4658411424342975020", + "block_hash": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + }, + "graffiti": "0x0000000000000000000000000000000000000000000000000000000000000000", + "proposer_slashings": [ + { + "signed_header_1": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b", + "state_root": "0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb", + "body_root": "0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486" + }, + "signature": "0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483" + }, + "signed_header_2": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6", + "state_root": "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "body_root": "0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1" + }, + "signature": "0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1" + } + } + ], + "attester_slashings": [ + { + "attestation_1": { + "attesting_indices": [ + "4585702132744102314", + "4590659586689121994", + "4589007099177470570" + ], + "data": { + "slot": "1", + "index": "4580744678799082634", + "beacon_block_root": "0x17348c3f2ad0733f4b47b34442744b4a2e03a79b1f52c8e8922ee71060a05b1c", + "source": { + "epoch": "533653615", + "root": "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06" + }, + "target": { + "epoch": "538655350", + "root": "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0" + } + }, + "signature": "0xaffb36fe3e48b5c29794f85515b9a3adcd4206fec6dddac6926d0e985d96a9ade0e427f911d56dd90f2644af13e9740509147d149defa9b0763eecba616e0815e9a91c25178860be7d4196a9814781a4576ba7bc6398ef16b9bd5f88c4143bfb" + }, + "attestation_2": { + "attesting_indices": [ + "4585702132744102314", + "4590659586689121994", + "4589007099177470570" + ], + "data": { + "slot": "1", + "index": "4628666713557758827", + "beacon_block_root": "0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390", + "source": { + "epoch": "537693478", + "root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b" + }, + "target": { + "epoch": "538078227", + "root": "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb" + } + }, + "signature": "0xb7720f152c38d7172a82186892a68440bc4d285cc8aa92c1f017f93d5f61a29cf51670e4f944648bd8df82d4d6eae00615073d439389cdf35fbd7670a07ef8407c7c71a16be062fff16f351737ac99f006817ba43a295fe5286dfb4ba7116e07" + } + } + ], + "attestations": [ + { + "aggregation_bits": "0x88e3aeac2cb7509e753b73880be4e95da67b35193a1a8d916d3a5f3b61c59b6d90d866ae7ee81a10a9ea025ade39ad5b978bd20bd2d2031d61e8aa7b5090b08248dbcac0698c25ea7b858ae37e5347010aa764962e4f70513d9e2488a9808d0510dcb3dc9385cc9c28ba4a1eae314e5c3372b3d2387836dc0750553f84b1b490b7fffcb2824b614596050fa2ffed45b30b7db4e67cd782cf0446b5448ed43cb01991cde29c15b0a29dcafdbf29840045c4a3d7e58b93ff391e3ae281185e49aeeed12188548d0dc8e904edc1c8a9831577d08b0c708dbb1784cef981e8363efb46d26f039c2561792d1a2e81218eec593aefaa25bb280fbdd25f8103381a51c601", + "data": { + "slot": "1", + "index": "4615446843529318507", + "beacon_block_root": "0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6", + "source": { + "epoch": "536154483", + "root": "0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0" + }, + "target": { + "epoch": "536539231", + "root": "0x82a81c3f096d065c7e3f5d7df79bd182a53c9471a737cfb9f7c4e9ed95d0f767" + } + }, + "signature": "0xa9aef1e37252740dedc5fc9886810459f7484555aa59fb3876803fc4924149cb471ffbbd9be5324d952efafc3de4c5f705dd02134916b2afa02194fe90a8d1e8f58ebcfe0d33d0b8a97e71a3f7591cb82c37ba531c059a684b581d3857f05e3c" + }, + { + "aggregation_bits": "0x0aa2e4365aad4ec5115dbc42fc6bcda2a0739e4b8c6c07334b99338ec990c7dc93162171b1ed0afe8b1f151348438523b428076a646db8375993d417cd79f1854f796992a8aea702eb3180373e7ff4b4c53ef3b306a5af7f82ba3a4a362af88084e7d166dd0ed5026019cd4f2c4fad16566f927d0dceb14203e8abc293267466c487eb2b108ae043792ff8e8c56e9fbb26d98381ad35e70558cc74f74d1d5a7de764645e15298f90a9a4292e58188deba564756775d54bad38de697be7659cde395c60f403933083c4e71881c26d15c83a61359fbecd1c12d8f31c0d440c128c416e09ee2d3fe64b8a4c737c2f604756d08d8c1f77d4623404e031805797412b01", + "data": { + "slot": "1", + "index": "4549347484797182313", + "beacon_block_root": "0xcf2c053f899b836f534bfa2a45bf23b7be4890b9815a72a2aec9f70eff53d592", + "source": { + "epoch": "528459505", + "root": "0xa8ea103f4904c5e568c52bd49eadfa1cb142929514c9202e53c7707e4a92667d" + }, + "target": { + "epoch": "528844253", + "root": "0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd" + } + }, + "signature": "0x8f5c34de9e22ceaa7e8d165fc0553b32f02188539e89e2cc91e2eb9077645986550d872ee3403204ae5d554eae3cac12124e18d2324bccc814775316aaef352abc0450812b3ca9fde96ecafa911b3b8bfddca8db4027f08e29c22a9c370ad933" + }, + { + "aggregation_bits": "0xd664cfc4f928592f21ca9fae84cd2a15d4acf76e0d2cbb493324ae9cb25757559fc4b060414cbfd84de047d4f04da4aa6669e83b9b8418d348bfc46b3fef684ffbf0162da3c6258f690b14c94cf448280b646c140b24928defd2d12434dbbbd0afbea5e5661fcac8116699ec8a059acf084ab956ab0eaf508ab7d3e4bd352a80f6b8ff73b4b24753a865991c45c9d9f0e1675e7327ccaaeb146bc3d0a4db2d7e607930579fc38a41d5019f222166cea9ebebfe0dd7b875fa612ecb7bb80f83718702da59fd2687d445048ac99f25b5f088fe931ec4bbf9ecdfc169844c00bc69fe38c0110fc59105233b29f6ddecb7968065fd7ef787e41d3545fefe30314fa401", + "data": { + "slot": "1", + "index": "4536127614768741993", + "beacon_block_root": "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8", + "source": { + "epoch": "526920509", + "root": "0x41f3e13e4961bf0c12dd652f3bf49e85e35a8a25c70e67ffc1d08cc01d9921d3" + }, + "target": { + "epoch": "527305258", + "root": "0x51977a3f0ab3110e2a10e9c6bd0e89b1410ca45142ac42171bb2b169efc281bc" + } + }, + "signature": "0xa17225b5e5319618e77f5b93350430acfadd8ae12a279f1a4176cc7ad1de7ecfc8670988519713fbac8f702cca29bddb14ff1463dae3abb53ddb0c025cd69c8cfb0f5298ab241c06ddb840c7a260f3dbd37120826b13b17e22d086148ebdbab1" + } + ], + "deposits": [ + { + "proof": [ + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7" + ], + "data": { + "pubkey": "0x90b2ffa8992560bca2080afa9b3adc904ce9085a8c2cc897282f20378bdf3cdc0a74100f226ea698e07d4afe50d8ff54", + "withdrawal_credentials": "0x9d1b633f8ae18e21ff1b86740b32dbe55a18a0991bcfe5ffd2b6bf8a59465fe7", + "amount": "32000000000", + "signature": "0x978f1439422f6e539e93927a7754e7f9866fbe5832da066bb8fec5041a6818bbfe7e79747a963eec57f76924aeb591d0133ffae96de0793f02d13a13e1f7286a7940e48093ceb832b58e9d6bff9adfc1e8f59367d905633d743cd62ccbd2b27c" + } + } + ], + "voluntary_exits": [ + { + "message": { + "epoch": "4570829775204010570", + "validator_index": "4565872325553958186" + }, + "signature": "0x8c2c3b368bc00b3853e6df352e816dd910016db953ac77cc1565e3c22f1c0b24c59f24ea9e8ca406aa95b23368d163e80baa6de3f8f7ac19ee78c976d2ae5a21c86fa1762cc959bc734379055cb7aa1de36eae00541936b8c2ee908c770d41ff" + } + ] + } + }, + "signature": "0xaa0f4b876c4fc52ca19c4905d49e329a88f907c3a07bb22f61c50e8e4f577ef468f0d4a1c3b0ec0123646b5f040d2c910380e5955c2e42fdfdc087ac66ef6097e607575c0db6529df1b1a0dc786e63f5268463672fcf0dd4aac7c9cf3cc98a43" + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/postAttestationRequestBodyELECTRA.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/postAttestationRequestBodyELECTRA.json new file mode 100644 index 00000000000..1ec340afbd9 --- /dev/null +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/postAttestationRequestBodyELECTRA.json @@ -0,0 +1,20 @@ +[ + { + "aggregation_bits": "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", + "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505", + "committee_bits": "0x08", + "data": { + "slot": "1", + "index": "1", + "beacon_block_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", + "source": { + "epoch": "1", + "root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2" + }, + "target": { + "epoch": "1", + "root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2" + } + } + } +] \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/postAttestationRequestBodyPHASE0.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/postAttestationRequestBodyPHASE0.json new file mode 100644 index 00000000000..3fb3970bc4a --- /dev/null +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/postAttestationRequestBodyPHASE0.json @@ -0,0 +1,19 @@ +[ + { + "aggregation_bits": "0x01", + "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505", + "data": { + "slot": "1", + "index": "1", + "beacon_block_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", + "source": { + "epoch": "1", + "root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2" + }, + "target": { + "epoch": "1", + "root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2" + } + } + } +] \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/postAttesterSlashingRequestBody.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/postAttesterSlashingRequestBody.json new file mode 100644 index 00000000000..5ee301b7555 --- /dev/null +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/beacon/postAttesterSlashingRequestBody.json @@ -0,0 +1 @@ +{"attestation_1":{"attesting_indices":["1"],"signature":"0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505","data":{"slot":"1","index":"1","beacon_block_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","source":{"epoch":"1","root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"},"target":{"epoch":"1","root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"}}},"attestation_2":{"attesting_indices":["1"],"signature":"0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505","data":{"slot":"1","index":"1","beacon_block_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","source":{"epoch":"1","root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"},"target":{"epoch":"1","root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"}}}} \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/debug/getState.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/debug/getState.json index f559f11d5de..94590e9aa18 100644 --- a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/debug/getState.json +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/debug/getState.json @@ -1 +1,5277 @@ -{"version":"phase0","execution_optimistic":false,"finalized":false,"data":{"genesis_time":"87914232","genesis_validators_root":"0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef","slot":"4669978815449698508","fork":{"previous_version":"0x103ac940","current_version":"0x6fdfab40","epoch":"4658411424342975020"},"latest_block_header":{"slot":"4669978815449698508","proposer_index":"4663368873993027404","parent_root":"0x5cbeb140ec0ad7cb653388caecba483cf66bd817821ed18ca1f3b7f3b9b58a04","state_root":"0x0000000000000000000000000000000000000000000000000000000000000000","body_root":"0x1f86d83f0bf91cc0d7e07410828140e0dddbb331dc20b6743f9f79e549b50b11"},"block_roots":["0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b","0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb","0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486","0x6b0ac13f8a279ad3abec11bed1a49214f6e7af79b643595df6a38706b338e93b","0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6","0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000"],"state_roots":["0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1","0xb88ea93f0a5617e780f8ae6b1fc8e4480ff4abc18f66fc45ada895271cbcc666","0xcbafa33faaa1f62b763b1697f350f91515f7aa53462f2500db29d9eff71c7ef1","0x924cb53fcabe585d9672e01478b6bbae02eead9d22d5aad151a60e9768fa5751","0xa56daf3f6a0a38a28bb547404c3fd07b08f1ac2fd99dd38b7f27525f425b0fdc","0x0413923f8a8494fa55044c196eeb367d2800a80969899f2e64ada348863fa491","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000"],"historical_roots":["0x17348c3f2ad0733f4b47b34442744b4a2e03a79b1f52c8e8922ee71060a05b1c","0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c","0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06","0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565","0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0","0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650","0xda533c406bf3482d8e6e992e756be34172a8c47fc1cc0018350bfe98c946deda","0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390","0x4d1a19402bb984ca4d0005336ba05e1098babeeb0781f5744712934ae78b2a1b","0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b","0x27d82440eb21c640637a36dcc38e35768bb4c0c79aefa300ec0f0cba32cabb05","0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb","0x999e0140abe701de220ca2e0b9c3b044b1c6ba33e0a3985dfe16a16b510f0846","0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5","0x735c0d406b5043543786d38912b287aaa4c0bc0f731247e9a3141adb9c4d9930","0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6","0xe622ea3f2b167ff1f7173f8e08e70279cad2b67bb9c63b46b51baf8cba92e570","0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0","0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b","0x82a81c3f096d065c7e3f5d7df79bd182a53c9471a737cfb9f7c4e9ed95d0f767","0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2","0x5c66283fc9d547d293b98e264f8aa8e89836964d3ba67d459cc2625de10e8952","0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd","0xcf2c053f899b836f534bfa2a45bf23b7be4890b9815a72a2aec9f70eff53d592","0xe24dff3e29e762b4488e615619483884c44b8f4b37239b5cdc4a3bd7d9b48c1d","0xa8ea103f4904c5e568c52bd49eadfa1cb142929514c9202e53c7707e4a92667d","0xbb0b0b3fe94fa42a5e0893ff71360feab7459127ca9149e88148b44625f31d08","0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd","0x2ed2e73ea915e0c71d9afe03676b8ab8dd578b9311463e45934f49f843386a48","0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8","0x0890f33e697e213e331430adc059611ed0518d6fa4b4ecd0384dc2678e76fb32","0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8","0x7a56d03e29445ddbf2a59bb1b68edcecf66387dbea68e12d4a545719acbb4773","0x41f3e13e4961bf0c12dd652f3bf49e85e35a8a25c70e67ffc1d08cc01d9921d3","0x5414dc3ee9ac9e510720cd5a0e7db352e95d89b77dd78fb9ef51d088f8f9d85d","0x51977a3f0ab3110e2a10e9c6bd0e89b1410ca45142ac42171bb2b169efc281bc","0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947","0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7","0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31","0x9d1b633f8ae18e21ff1b86740b32dbe55a18a0991bcfe5ffd2b6bf8a59465fe7","0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672","0x77d96e3f4a4ad0971596b71d6420b24b4d12a275af3d948b77b438faa484f0d1","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0xe99f4b3f0a100c35d42723225a552d1a73249ce1f5f188e889bbcdabc2c93c12","0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c","0xc35d573fca784dabeaa154cbb2430480661e9ebd886037742eb9461b0e08cefc","0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587","0x3624343f893e8948a933c0cfa8787f4e8c309829ce142cd140c0dbcc2c4d1a3d","0x49452e3f298a688d9e7627fb7c01941b923397bb84dd548b6e411f9506aed1c7","0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27","0x23033a3fe9f2a903b4f058a4d4ef6a81852d9997184c0317133f980452ec62b2","0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be","0xf8eb5a3ea82ccf3c1be1ac153e3f77f273a07343291711b9de6b9dbebc4c9b49","0xbf886c3ec849316e3b187793c3a4398b6097768d06bd968a54e8d2652d2a75a9","0xd2a9663e689510b3305bdebe972d4e58669a751fbc85bf448269162e078b2c34","0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9","0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874","0x0c0d553e4878ae811024144112c88bbf79a372d5dfdf39730cede08696ad52d4","0x1f2e4f3ee8c38dc605677b6ce650a08c7fa6716795a8622d396e244f710e0a5f","0x7ed3313e083eea1ecfb57f4508fd068e9fb56c4125942ed01ef47538b5f29e14","0x91f42b3ea889c963c4f8e670db851b5ba5b86bd3dc5c578a4c75b9008f53569f","0x58913d3ec8a62b95e52fb1ee60ebddf392af6e1db902dd5bc3f1eea7003130ff","0x6bb2373e68f20adada72181a3474f2c098b26daf6fcb0516f0723270da91e789","0xcb571a3e876c6732a4c11cf3562059c2b8c16889ffb6d1b8d5f883591e767c3f","0xde78143e27b846779904841e2aa96d8fbec4671bb57ffa72037ac721f8d633ca","0xa415263e48d5a8a8ba3b4e9caf0e3028abbb6a65922580447af6fcc869b40d2a","0xb736203ee72088edaf7eb5c7839744f5b1be69f748eea8fea77740914415c5b4","0xb4b9be3e0927fba9d26ed13331291a54096d84910dc35b5cd4d721723cde6d13","0xc7dab83ea972daeec7b1385f04b22e210f708323c38b84160159653a163f259e","0x8e77ca3ec98f3c20e7e802dd8917f1b9fc66866da0310ae878d59ae1871cfffd","0xa198c43e69db1b65dc2b6a085da00587026a85ff57fa32a2a656dea9617db688","0x003ea73e885578bda77a6ee17f4c6c88227980d9e6e5fe448bdc2f93a5614b3e","0x135fa13e28a157029cbdd50c53d58055287c7f6b9dae27ffb95d735b7fc202c9","0xdafbb23e48beb933bcf49f8ad83a43ee157382b57a54add02fdaa802f09fdc28","0xed1cad3ee8099978b13707b6acc357bb1b768147301dd68a5d5beccacb0094b3","0x4dc28f3e0884f5d07b860b8fce6fbebc3b857c21c008a22d42e13db40fe52869","0x60e3893ea8cfd41571c972baa1f8d28941887bb376d1cae77062817ce945e0f3","0x26809b3ec8ec364791003d38265e95222e7f7efd537750b9e6deb6235a23ba53","0x39a1953e6838168c8643a463fae6a9ef34827d8f094079731460faeb348471de","0x9946783e88b272e45092a83c1c9310f154917869992b4516f9e54bd578680694","0xac67723e28fe512946d50f68f01b25be5a9477fb4ff46dd027678f9d52c9bd1e","0x7304843e481bb45a660cdae57581e756478b7a452c9af3a19de3c444c3a6977e","0x86257e3ee866939f5b4f4111490afc234d8e79d7e3621c5ccb64080d9e074f09","0x2fda834311b58db49107ebef3efd6ab3f5f751f2e5ae381ba4e248bbcd2c6f5e","0x42fb7d43b1006df9874a521b12867f80fbfa50849c7761d5d1638c83a78d26e9","0x09988f43d11dcf2aa7811c9997eb4119e8f153ce791de7a648e0c12a186b0049","0x1cb989437169ae6f9cc483c46a7456e6eff452602fe60f61766105f3f2cbb7d3","0x7b5e6c4391e30ac86613889d8c20bde70e044e3abfd1db035be756dc36b04c89","0x8e7f6643312fea0c5c56efc860a9d1b414074dcc759a04be89689aa411110414","0x551c7843514c4c3e7c8db946e50e944d01fe4f1652408a8fffe4cf4b82eedd73","0x683d7243f1972b8371d02072b997a81a08014fa80809b3492d6613145c4f95fe","0xc8e25443111288db3b1f254bdb430f1c27104a8298f47eec12ec64fda0332ab4","0xdb034f43b15d672031628c76afcc23e92d1349144fbda7a6406da8c57a94e13e","0xa2a06043d17ac951519956f43432e6811a0a4c5e2b632d78b6e9dd6ceb71bb9e","0xb5c15a4371c6a89646dcbd1f07bbfa4e210d4bf0e22b5632e46a2135c5d27229","0x14673d43914005ef102bc2f829676150401c46ca721722d5c9f0721e09b707df","0x27883743308ce433056e2924fdef751d461f455c28e04a8ff771b6e6e417bf69","0xee24494351a9466526a5f3a1825538b6331648a60586d0606deeeb8d55f598c9","0x01464343f1f425aa1be85acd56de4c833a194738bb4ef91a9b6f2f562f565054","0xfdc8e14312fb98663ed87639047022e291c761d28023ac78c7cf1037271ff9b2"],"eth1_data":{"deposit_root":"0x10eadb43b24678ab331bde64d7f836af97ca606436ecd432f55054ff0180b03d","deposit_count":"4894716627408020434","block_hash":"0xeaa7e74372afb92149950f0e30e70d158bc46240ca5a83be9a4ecd6e4cbe4128"},"eth1_data_votes":[{"deposit_root":"0x4a4dca439229167a13e413e752937416aad35d1a59464f617ed41e5890a2d6dd","deposit_count":"4883149240596264241","block_hash":"0x240bd643529257f0285e4590ab814b7c9dcd5ff6edb4fdec23d297c7dce067c8"},{"deposit_root":"0x372cd043f2dd36351da1acbb7f0a6049a4d05e88a37d26a75153db8fb6411f53","deposit_count":"4878191786651244561","block_hash":"0xa9f2ac43b1a372d2dd3218c0743fdb17c9e258f4e9311b04635a7041d4866b93"},{"deposit_root":"0x708fbe43d1c0d403fd69e23dfaa49db0b6d95b3ec6d7a0d5dad6a5e8456445f3","deposit_count":"4879844274162895985","block_hash":"0xe3559b43918610a1bdfb4d42efd9187fdceb55aa0c8c9532eddd3a9a63a99133"},{"deposit_root":"0xf676954331d2efe5b23eb56dc3622d4ce2ee543cc254beec1a5f7e623e0a49be","deposit_count":"4874886820217876305","block_hash":"0xcf34a143f13a315cc7b8e6161c5104b2d6e8561856c36c78bf5cf7d18948daa8"},{"deposit_root":"0x92fcc742102977503966d35cb217fc55bd583232b0c551605c08b9c319485bb5","deposit_count":"4810439944702424240","block_hash":"0x6cbad342d091b8c64ee004060b06d3bbb052340e443400ec010632336486ec9f"},{"deposit_root":"0x7fdbcd4270dd970b44236c31de8ee788b75533a0fafc28a62f8775fb3fe7a32a","deposit_count":"4805482499347339152","block_hash":"0xf2a1aa4230a3d3a803b5d735d4c36257dc672d0c40b11d03418e0aad5d2cf06a"},{"deposit_root":"0xb83ebc4250c035da23eca1b3592925f0c95e30561d57a3d4b80a4054ce09caca","deposit_count":"4807134978269055984","block_hash":"0x2b0599420f867177e37d0db84f5ea0beef702ac2630b9831ca11d505ec4e160b"},{"deposit_root":"0x3e269342afd150bcd8c074e323e7b48bf57329541ad4c0ebf89218cec6afcd95","deposit_count":"4802177528619003599","block_hash":"0x18e49e426f3a9232ed3aa68c7bd58bf1e96d2b30ad426f779d90913d12ee5e80"},{"deposit_root":"0x778981428fb4ee8ab889aa659e81f2f2087d260a3d2e3b1a8216e32655d2f335","deposit_count":"4790610137512280111","block_hash":"0x51478d424f1d3001cd03dc0ef66fc958fb7628e6d09ce9a526145c96a1108520"},{"deposit_root":"0x64688742ef680f46c246433acaf8dd25027a27788665126054959f5e7b713cab","deposit_count":"4838532176565923600","block_hash":"0x740c2043b0ba6147da79c6d14c13c8515f2b41a40103ee77ae76c4074d9b9c94"},{"deposit_root":"0x3aa93143d0d7c378fbb0904fd1788aea4c2244eedea8734924f3f9aebe7876f4","deposit_count":"4840184655487640432","block_hash":"0xad6f0e43909dff15ba42fc53c6ad05b972343e5a245d68a637fa8e60dcbdc234"},{"deposit_root":"0xc090084330e9de5aaf85637f9a361a8678373decdb259160657bd228b71e7abf","deposit_count":"4835227205837588048","block_hash":"0x9a4e1443f05120d1c5ff9428f324f1eb6c313fc86e943fec09794b98025d0baa"},{"deposit_root":"0xf9f3f64210cc7c298f4e990115d157ed8b403aa2fe7f0b8feefe9c814641a05f","deposit_count":"4823659819025831856","block_hash":"0xd3b10243d034be9fa5c8caaa6ebf2e537e3a3c7e91eeb91a93fc15f1917f314a"},{"deposit_root":"0xe6d2fc4270809de49a0b32d641484320853d3b1047b7e2d4c07d59b96ce0e8d4","deposit_count":"4818702369375779472","block_hash":"0x5999d9423046d981599d9dda377dbeeeaa4f357c8d6bd731d384ee6a8a253515"},{"deposit_root":"0x2036eb4250633bb379d46758bce28087974638c66a115d034a012412fb020f75","deposit_count":"4820354852592463600","block_hash":"0xf51e0c420e9d60ece0c4bbc926328df885b912727bdc6aa5152e29cc6563470c"},{"deposit_root":"0x08400642aee83f31d60723f5fabaa1c58bbc110432a5935f43af6c943fc4fe96","deposit_count":"4762517914238715343","block_hash":"0xe2fd11426e5181a7eb81549e52a9782b7fb613e0c51342ebe7ace5038b029081"},{"deposit_root":"0x42a3f4418ecbddffb5d058777555df2c9ec50eba55ff0d8ecc3237edcfe62437","deposit_count":"4750950527426959150","block_hash":"0x1c6100424e341f76cb4a8a20cd43b69291bf1096e86dbc197030b05c1a25b621"},{"deposit_root":"0x2f82fa41ee7ffebac08df14ba1ccca5f98c20f289e36e5d39eb1f324f4856dac","deposit_count":"4745993073481939470","block_hash":"0xa148d741ae453a587f1f5d509701462ebdd40994e5ead930b1b888d612cbb9ec"},{"deposit_root":"0x68e5e841ce629c89a05627ce1c6708c7aacb0cdec1905f022835be7d83a8934c","deposit_count":"4747645556698623598","block_hash":"0xdbabc5418e28d8265fe892d2129c8395d0dd064a0845545f3a3c532fa2eddf8c"},{"deposit_root":"0xeeccbf412e74b76b542bfafde5249862d6e005dcbe0d7d1968bd96f77c4e9717","deposit_count":"4742688102753603918","block_hash":"0xc78acb41eedcf8e16aa52ba73e136fc8cada07b8517c2ba50cbb0f67c78c2802"},{"deposit_root":"0xc40d6a420fe36b9e8d954713eca44427218922521651de02391bf147bf55d160","deposit_count":"4784000204645543599","block_hash":"0x9ecb7542cf4bad14a20f79bc45931b8d1483242ea9bf8c8edd186ab70a94624b"},{"deposit_root":"0xb1ec6f426f978c599752e0e7181c305a1b8623c06088b5480b9aad7fe5f419d6","deposit_count":"4779042750700523919","block_hash":"0x23b34c422f5dc8f657e44bec0e51ab2840981d2ca63caaa51da14231033a6616"},{"deposit_root":"0xea4f5e424f7a2a28771b166a93b66dc12d8f207683e22f77941d78d874174076","deposit_count":"4780695238212175343","block_hash":"0x5d163b420f4066c536ad816e89ebe88f53a11ae2c99624d4a7240d8a925c8cb6"},{"deposit_root":"0x70373542af8b450a2cf0e8995d74fd5c59a419747f5f4d8ed5a550526cbd4341","deposit_count":"4775737784267155663","block_hash":"0x49f540426ff48680416a1a43b562d4c24d9e1b5012cefb1979a3c9c1b8fbd42b"},{"deposit_root":"0xa99a23428f6ee3d80bb91e1cd80e3bc46cad162aa2b9c7bc5e291babfcdf69e1","deposit_count":"4764170397455399471","block_hash":"0x83582f424fd7244f213350c530fd112a5fa71806352876480227941a471efbcb"},{"deposit_root":"0x96792942ef2204941676b7f0048626f766aa1798ecf09e0230a8d7e2217fb256","deposit_count":"4706333459101651213","block_hash":"0x6c624a41ad5c29cd7d660b626ed53268531df243fdbbaca4fbd4dc9c8cdfeaed"},{"deposit_root":"0x32ff5b41cd798bfe9d9dd5dff33af5004014f58dda61327672511244fcbcc44d","deposit_count":"4707985942318335341","block_hash":"0xa5c538418d3fc79b5d2f41e4e96f70cf6626eff9201627d38558a7f51b02118e"},{"deposit_root":"0xb8e632412d8ba6e05272a80fbcf8849c6c29ee8bd6de4f8db2d9eabdf562c818","deposit_count":"4703028492668282957","block_hash":"0x92a43e41edf3e75667ecd9b815e75b026023f067694dfe1857d7632d40a15903"},{"deposit_root":"0xf14921410d6e44af323bde913793c2037f32eb41f938cabb3c5db5168485eeb8","deposit_count":"4691461101561559469","block_hash":"0xcb072d41cdd6852547b50f3b90819969722ced1d8ca77847e05a2e86cfc37fa3"},{"deposit_root":"0xde2827416d22656a3cf87666640aae36792fecaf4370a1010edc714eaa24372e","deposit_count":"4686503651911507085","block_hash":"0x51ef03412de8a007fc89e26a593f29059e41e61b8924965e21e30600c869836e"},{"deposit_root":"0x188c15414d0503391cc1ace8dfa4eb9d8b38e96566ca1b30975f3ca739475dce","deposit_count":"4688156139423158509","block_hash":"0x2730ae410e57553a34f42f8060bfd5c9e9e90292e167f747f14061500b71bdb7"},{"deposit_root":"0x3a51a841aea2347f293797ab3448ea96efec0124973020021fc2a418e5d17442","deposit_count":"4736078169886867406","block_hash":"0x140fb4416e0b76f53fb1c8548d36c1fce3e603002b9fce8dc3bf1d883110062d"}],"eth1_deposit_index":"4726163266291795342","validators":[{"pubkey":"0x8238eb67219c0c314c0b387a1300ebe7ee0b3bfde764c14e90d42e82197100fedb6950f6db432cee0e766cfd35ff22c7","withdrawal_credentials":"0x4d72a2414eee13c41e7afed607d1fe63f5ef00b64ef948bc4d43e8e0c0322ccd","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xaf72cddf5e9e8f9e3213202be4447e2eb5a5a61632935ce5695105b936cccae9fc9c504f2bcf511d91531a2738e1d71b","withdrawal_credentials":"0xc0387f410db44f61de0b6adbfd057a321b02fb2194ad3d195f4a7d92de77780d","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x83feea64397a7a9d3fbac0b9a16ccbfd63c4d4fa5d0fd8bbfa13739148e752ce1e9b1e01654b56cb56a196fd8d64db3f","withdrawal_credentials":"0x9af68a41ce1c91d7f3859b8456f450980efcfcfd271ceca40448f60129b609f8","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xaafd198509805b36458bfa1c0202ea15976ab05f75100f8ed811fb700b4d657531e364c12a87d345f4799c43e2bb5ae6","withdrawal_credentials":"0x0cbd67418de2cc74b31707894c29cc66340ef7696dd0e001164f8bb348fb5538","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb9f6a699d12e3b22af90798367dbf0631ebaaaf8f61655d320f1459b2ed90c922371211fd49c3b93e3c5a550730cf272","withdrawal_credentials":"0xe67a73414d4b0eebc8913832a417a3cc2708f945003f8f8dbb4c04239339e722","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x85808a97e324987cd03bfc33e49aaa6cbc8a5cb66fb44111b0d8bc8c6b7c810638e6a6ac88d640b3492a684c19053f61","withdrawal_credentials":"0xa250734616e5e744f48c493c6d932629d574d0f2b953d406c14b88999cbfbe02","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x99b20a6a3e75af8e62e7f3f5143a149ab8e4ff041b0bf44e70174c19184e0ad2d612a3cd648ac30b428469bde0d1cea2","withdrawal_credentials":"0x7c0e7f46d64d29bb09077be5c681fd8ec96ed2ce4dc2829266490109e8fd4fed","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x962f9f117cb8bfe6d6bcc374161f8e605cdff99bee8161ed5b527987f0e5116f94821f23f28773da660a420525bd4201","withdrawal_credentials":"0xefd45b4696136558c998e6e9bcb6785dee80cc3a937677ef785096ba06439c2d","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8b585aa726039b4472f9552d0c79479cb6adc817b80667143271f83ddea3228455397c6ac7e29e6fa703eb31e8674828","withdrawal_credentials":"0xc8926746567ca6cede12189315a54fc3e17ace1626e5257b1d4e0f2a51812d18","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xaec6dab7580191dde7d836f49c0e9639ec9f7306f25cf1c37b212a28244f1b8144c1a05919239caec52ba139fede301b","withdrawal_credentials":"0x3b5944461642e26b9ea483970adaca91078dc8826c991ad82f55a4db6fc67958","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xaa7d67cf12895fe67b0023fb9c2fb0b7a60bd3b9c90c01dd758002a19265cc9c2fa5338b6a59a5a0b648140752ddf8a0","withdrawal_credentials":"0x15175046d6aa23e2b31eb54063c8a1f7fa86ca5eff07c963d4521d4bbb040b43","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa0e27864d6b654c4d9b58d1248ca6a494b47d5764847ce585f31df6aa5cf24d17113207ac820b0a5f6da0df2b182931b","withdrawal_credentials":"0x87dd2c4696705f7f73b0204559fd1cc62099c4ca46bcbdc0e659b2fcd9495783","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb18269548d92185838a418050a4c9523838a4704849986ca7d0e2c1b360c8319011a2df056268abf89350de67d1b1b78","withdrawal_credentials":"0x619b384656d9a0f5882a52eeb2ebf32b1393c6a6d92a6c4c8b572b6c2488e86d","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa211797aa69f18ce249575da91eca37736093b7339a10fa1272692ddd82239fd8f6b75b36a796721b81d6d9a23fabf84","withdrawal_credentials":"0x713fd146172bf3f6a05dd5853306de577144e0d254c84764e5385015f6b14857","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb2463b15365ee966c742aab78e5a694f1f4eee7ba5e633930b0c5f587ff65fa8d7d4ad918a8120fdfc1c69c2ef175b70","withdrawal_credentials":"0x4afddc46d793346db6d7062f8cf4b4bd653ee2aee736f6ef8936c98442f0d941","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xab4bbb1caad2be96ce362592fcc04c8c71734b59fef25d4cdd59bf6aa351ddcb63f5361e5d9dce661efcd56b4218f929","withdrawal_credentials":"0xbdc3b9469759700a756972338229308c8a50dc1a2debea4c9c3d5e3660352682","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x955246320f9112d6559264b15d335ec4e9bb68ab2b73dc08b242944b4aa4741d391a89f3cd3382a858b5e6ec9bf33b6e","withdrawal_credentials":"0x9781c54657c2b1808be3a3dcdb1707f27e4adef6c15999d8403bd7a5ab73b76c","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xad37627de08eb0d0bedbc4f9b6a4aa2e002627ff5cfbb6959490b144fbfc6a331e9dc0c4c712ffb05a9f0d42754dab30","withdrawal_credentials":"0x0948a2461788ed1d4a750fe1d04c82c0a35cd862070e8e3553426c57c9b803ad","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x975152efef95e4e4af3a6a0f79b1f3aeefb81320c04467fb624ec2adffb3af5062b55b8c5783552a7c5a190ef20b36d7","withdrawal_credentials":"0xe305ae46d7f02e9460ef408a293b59269756da3e9a7c3cc1f73fe5c615f79497","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa6e40ebe55ee13712a34981540bdd953448f1352d13742cfd7ae8abe89b0745a679a86aee7b5b416e5a3a87170ddae87","withdrawal_credentials":"0x56cc8a4696b66a311f81ac8e1f70d4f4bc68d4aae030311e0a477a78333ce1d7","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x91866281e564f2166e4763df3b138fd387f17ffcc7b347fdbc1fb50a31655dd39ec1d682f5044ce69eab524aa4007a87","withdrawal_credentials":"0x308a9646561faca734fbdd37785eab5ab062d686739fdfa9af44f3e77e7a72c2","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x933ff51b3543f3a53e0408f9553e242db71f4da386e07a2c50116023f5b6a897dc2ebe40df4f89381081fc5b651b81b4","withdrawal_credentials":"0x0573b7451559d1e09beb31a9e2adb7cb9dd5b032846aed4b7a71f8a1e8daaa59","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb6a7219422fa8dcf311dce6f2daad64d8e7add1905e755ea43e40df9399d45fa201292eac717cdd6bb09e438706b186b","withdrawal_credentials":"0xdf30c345d5c11257b16563523a9c8e3190cfb20e18d99bd71e6f711134193c44","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8348da0d73db2e9e07fdf61060b5fe240a884c2e8edd48077f6ba522ce0a23fec3f5b5277795bb959c76b44dabcdb37b","withdrawal_credentials":"0x52f79f4595874ef470f7ce5630d10900b6e1ac7a5e8d9034317606c3525e8884","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xac026719d44d1e8eae15ec4df24eed0d77a2f463792f5ba9253d23d50f8f19d3e82eb735d2acfdf7105f5bda84530487","withdrawal_credentials":"0x2cb5ab4555f08f6a8671000089bfe065a9dbae56f1fb3ec0d5737f329d9c196f","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8040a9aa1a7c18f8db862015ea6ba5b260a3790640302913eafef678d40c66805f05cf1a0f46a2254ebc8dafe79e2bca","withdrawal_credentials":"0x9e7b884515b6cb0745036c047ff45b34cfeda8c237b0331de87a14e4bce165af","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa8a8f5fd201bc673bada188e1ad794d70c44272af3dcc856e38055f602e26747fbb3506f172aa018d083b3690f2e644c","withdrawal_credentials":"0x78399445d51e0d7e5b7d9dadd7e2329ac2e7aa9eca1ee2a88c788d530720f799","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb932d4eee66120398141d5d9a50d71dc9e7c6950a9a65e917d3a86b33d887189c85a728c4bb6c1ae82e63e46454a28d6","withdrawal_credentials":"0xebff704594e4481b1a0f09b2cd17ae68e8f9a40a11d3d6059f7f2205256543da","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa421315146222618b1c57f9e304785c4de36458dade253a459e577566b4d806ff1691c5ebc8a974cb4ed8b1704ba3c42","withdrawal_credentials":"0xc4bd7c45554d8a9130893a5b260685cedbf3a6e6a4418591437d9b7470a3d4c4","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8d33433c914c5ca722b0683f97f4d05e012cdc85633a3d2581b2b1c7a57248c60b9446d89e224655c04be566c60127fa","withdrawal_credentials":"0xd4611546169fdc9248bcbdf2a7206ffa39a5c0121fdf60a99d5ec01d42cd34ae","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8cc3ed86d17823dc4f2e7b26afd5cc158a9aa0eae455d3036a12b58ba820ef469bc6c96b924993a742bee6a6935b28d4","withdrawal_credentials":"0xae1f2146d6071e095d36ef9b000f46602c9fc2eeb24d0f35425c398d8e0bc698","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa022cd8d35607db7b3261c18d36951b7b9cfefb4a5154e5c04588a4272f31edd43e722febde2bdc2a4a87c996bf00451","withdrawal_credentials":"0x20e6fd4595cd59a61cc85aa0f643c12e52b1bc5af80104925563ce3eac5012d9","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa8a931213b70226a83587756c4600a2ff88d2cd4eb61fc671e9da331c3a3bc0bbc8ce4a39db7d52998c678514b2eea1b","withdrawal_credentials":"0xfaa3094655369b1c32428c494f32989445abbe368c70b21df96047aef78ea3c3","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x944871d0c9f5ed3f398b2affdc4c9bc535a38c093e20ada27d8fe171fec1a1b990243883afed5eabe561c6ec39864b30","withdrawal_credentials":"0x6d6ae64515fcd6b9f1d3f74d446713636bbdb8a2d224a77a0c68dc5f15d4ef03","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa4d9a7333cbbfe1b43c81d96c2c75624494864a7759e7831003e4604f678699fda282c3ea510c99c98c75bba3cc4604b","withdrawal_credentials":"0x4628f245d5641830074e29f79d55eac85eb7ba7e65935506b06555cf611281ee","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x85ecf16940353cf72aee4b4aa8fec6c881b79dfdb7b6204dc13793b9ce153a6cb43870db19659f5a222433f938206fe9","withdrawal_credentials":"0xb9eece45952a54cdc6df94fb938a659784c9b4eaab474a63c36cea807f57cd2e","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x872247e7012206c1e5435f7743d5a555239339733524372121b95ca339504d44094c6f908f08ebd2b53cb1ed085a245a","withdrawal_credentials":"0x93acda4555939543dc59c6a4ec783cfd77c3b6c63eb6f8ee676a63f0ca955e19","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa5a7604c7f72ebb0fb5471a96b8d49762c6b75aec9ff44cfa2e312f9cd296a3e9375b891d785438dd48aedfadbc426e2","withdrawal_credentials":"0x6995fb4414cdba7c434a1a1656c8486e653691724f810691329768aa35f696b0","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x93818d1d96a9323ef0447a95838d42dd1a09a4b9037c00beaadd6080835ccc5d99ac25688d65530811641e17dc3180b3","withdrawal_credentials":"0x42530745d435fcf258c44bbfaeb61fd45830934ee3efb41cd794e1198034289b","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb6347454b98399213bb55322bae7cefb903ed09c594c87259f31ed3232db2aace12fa70185509888bfa245ad225f769c","withdrawal_credentials":"0xb519e44493fb37901856b7c3a4eb9aa27e428dba29a4a979ea9b76cb9e7974db","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xac572911123c11d2009e1c385f22fe42d16a679775646eab6fbc8be798be02f77a9b57cfb06550539c024e059e30bb34","withdrawal_credentials":"0x8fd7ef44546479062dd0e86cfdd97108713c8f96bc1258058e99ef3ae9b705c6","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa061bb193abe9246eaaaac35b76cb8d70f8239298069c7396da3411f63e7911a392161acd162c21fdf833d60f806d169","withdrawal_credentials":"0x019ecc44132ab5a3ec615471f30eedd6974e890202c74c62a1a084ec08fd5106","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xaa5d57db0f3b58f238b9be564a977b953a1de9d6b4d8a2be7dbcf0f0cb0200a73ab14bd5c069d53db8d46fb226672562","withdrawal_credentials":"0xdb5bd844d392f61902dc851a4bfdc33c8a488bde9535fbed459efd5b533be3f0","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa81cbb669ab9ae9951ebf7a143b4a3a83c8884fb2f0420e95e61904de24a3b27e9426687419c48645f9a7a1720ebe50b","withdrawal_credentials":"0x4e22b544935832b7c16df11e41323f0bb05a854adce9ef4a58a5920d71802f31","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa1ddf7f024df4dc53d70a695ddefc6741afb9b002e686ea528975765b1d8b61e8d60cf4984178799c67df3ba3156c9d3","withdrawal_credentials":"0x28e0c04453c1732dd7e722c89a201671a35487266f589ed6fca20b7dbcbec01b","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb4f2ab7d49b6f55517d4eeb28c540fdb9dffbab0c13bc76e07a434fee9b383521a0fd9f6639a8546fa3671a00a211009","withdrawal_credentials":"0x378459451413c62eef1aa65f1c3b009d0106a152eaf579ee568430268fe82005","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb1efeeb48386e83b4966e55d834fe07b63ab3cdb59c1c4aaccfd587a819445c50237894bef43d235d7deebbce23a77af","withdrawal_credentials":"0x11426545d47b07a50495d7087429d702f4ffa22e7d64287afb81a995da26b2ef","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x92e12d76878e0de0473c4c6782c1792e4e70baa2852acf055bc3c88737dc845d3660e0f91a57be075718545a4e45f1a6","withdrawal_credentials":"0x8308424594414342c426430d6a5e52d11a129d9ac3181dd70d893e47f86bfe2f","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8534c9f9cb0ad52f9d80709583a57518b5479ce39f2027503bfdf5c15f2c6bf277ed0fa8ded816d106bfa94ae5884d56","withdrawal_credentials":"0x5dc64d4554aa84b8d9a074b6c34c29370d0c9f765787cb62b286b7b643aa8f1a","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x95a323d2a4bf702d248584876975f60cca9ec15ff0888d928f8f3798e1ebb55d9b1704a2369db37a4874cf20c1fa18ae","withdrawal_credentials":"0xd08c2a451470c0559932e0bab981a405331e99e29d3bc0bfc48d4c6862efdb5a","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb0b0c8a0b5cc2eb6b35db821eb29d759fb33284bd5ccb325b1f8a96e07ca96d12037edc86443b642ec6db22e0c6487e3","withdrawal_credentials":"0xaa4a3645d4d801ccaeac116411707b6b26189bbe30aa6e4b698bc5d7ad2d6d45","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x875a76a3e345afee45e7181cea2f8e1f85160eb87b48f1fe8813872d412b08b2f4ff9515eacdab1157f02eec3396e2f0","withdrawal_credentials":"0x1c111345949e3d696e3e7d6807a5f6394c2a952a765e63a87b925a89cb72b985","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x92859a8dd8bc58c9c35ba7b5a03f68937dcd6a168c1986f2367dd115d07b596dcdc305ef4aefc5c20d0e15b2dec71458","withdrawal_credentials":"0xf6ce1e4554077fdf83b8ae116093cd9f3f24970609cd11342090d3f816b14a70","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x94c1b49cfe20e8babbf7fa80d5989fbe24118149ac9adfabb587eb6ee462b2f6f812b32fd29c1abbf52ad0801ea1c28b","withdrawal_credentials":"0xccb73f441241a418eaa80283cae2d9102d9771b21a981fd6ebbcd8b281118307","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8244460fdae46ef761855909e46c678b8386f473d146da67b2b0899c88053b12fbf6d2b540587e413a6bd5485d330d2d","withdrawal_credentials":"0xa6754b44d2a9e58e0023342c23d1b0762091738eae06ce6190ba5122cc4f14f2","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x89c7d432a62ab14608090ffa3b53ea83ab1bcc3b450ec2e93d8bc60779b88f1cec594b0ec28148af581cdf069511d950","withdrawal_credentials":"0x183c2844926f212cbfb49f3018062c4546a36dfaf4bac2bea2c1e6d3ea946032","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x86f0ee71fb95022911b594c7db22b94cd37bd1a70b1a36ebb452e7bdf02cb25d3805ad622fa28a623ad20ecb625302f4","withdrawal_credentials":"0xf2f9334452d862a2d52ed1d971f402ab399d6fd68729714a47bf5f4335d3f11c","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb9546c91cbd47bcfa488a983fd877aca4c8291f35064c6df05213232a4e5794f32a0dd52deb6d3c060fbcd823872340f","withdrawal_credentials":"0x65c01044129e9e3f94c03cde67297e795faf6942cddd65a759c6f4f454183e5d","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8cc8d50ab70030baadfc940c13e40a0f1e94a78cdc96c7e1006a596e69f9a4180649763c3c1c232b4b84d81c1beb01f9","withdrawal_credentials":"0x3e7e1c44d206e0b5a93a6e87c01755df52a96b1e604c1433fec36d649f56cf47","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x80419c71149761ff351d665bea6c7d874588e8c8a3462cc38d4059b700b65280591e10bf9f1b386c32a9f20ebfe7ae85","withdrawal_credentials":"0xb144f94392cc1b5369ccd98bb54cd0ad78bb658aa700099010cb0216bd9b1b88","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa9fc3471260f9b26aaec3c23ad10ce7b1397e412c3b2244fd28350d4a3600e9eb15bacfd9d96b27a0d3f6dd32f3249aa","withdrawal_credentials":"0x8b02054452355dc97e460b350e3ba7136bb567663a6fb71bb5c87b8508daac72","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa9208ba9a2194fe136236f55ba1386e75220d78b87f13c5c271840ffa732d1ba5ed1d61791eeab0b79b6a50ee0bd9640","withdrawal_credentials":"0x9aa69d441387afca96798ecc9055913fc9668192b50c93330faaa02edb030d5c","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x80c96133fbd52e79a7942109776cbb23bdac979244528e097f1e916a4d0b7463b4af2d7f4c6b06a820596d7c7688775b","withdrawal_credentials":"0x7464a944d3eff040acf3bf75e84368a5bc60836e487b41bfb3a7199e26429e46","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb65586852e5e24552200524b31eb54f3bf83782fc3afd6c1b45b30061ed98eb36dfb2414622cb3fecf0aa32680885f22","withdrawal_credentials":"0xe72a864493b52cde6b852b7ade78e373e2727dda8e2f361cc6aeae4f4487ea86","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x9923628ca9e4bf029de23f10ea12be7c68fcf0babb9b2e94b6d854bfc26488222271bb11d870f79e7fbc8d572e465096","withdrawal_credentials":"0xc0e89144531e6e5481ff5c233767bad9d56c7fb6229ee4a76aac27bf8fc57b71","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8d87ba1c7738f7b14b45562d993016c3aaff28d66c06006edd27e779404adf72ea01d5cf02752f07fba516a4020c6e02","withdrawal_credentials":"0x33af6e4413e4a9f14091c8272d9c35a8fb7e79226852d9047db3bc70ae0ac8b1","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x99cee98eb05f310aa7c0cf69a7adca06b50e927abd98f66a46db9aecd28bb159f81d18ef22b5512abe7ff7e6592dd416","withdrawal_credentials":"0x0d6d7a44d34ceb67560bfad0858a0c0eee787bfefbc0879021b135e0f948599c","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8a56d6d4a228b9a437aafbe1cd67630270694e0bc258ad06eeacebc2bb9f91896c77347f7b0fb9ee018c75ce48069df6","withdrawal_credentials":"0x7f33574492122705159d65d57bbf87dc148b756a41757ced34b8ca91178ea5dc","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x89b56335a0f6072a50c7f4c2a7f6c13375c0539ec6e96e589ce6f092101ca469d5c68dbc609deb6c6720cfc3ca1c1211","withdrawal_credentials":"0x59f16244537b687b2b17977ed4ad5e4207857746d4e32a79d8b5430162cc36c7","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x82e63946d7ecd5b029e583d716980121ac053036c8e2539c54590fd093b8a199125ca81e05437e2f32d9ba615e782e14","withdrawal_credentials":"0xe2e1d58f9895b65d8f9384b1123e78a8b8a62aff6d6c0709a38fb94de115840e","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb85ace936ff7c586f535dd9d099a9912156fa573e68c15cb4e59119735c4f2e217ad50be7432d0ad07d9ef0ce922748f","withdrawal_credentials":"0xbc9fe18f58fef7d3a40db65a6a2c4f0eaba02cdb00dbb594478d32bd2d5415f9","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa85181d81a61491234a89ce78b38a32a65a30883676c02327d51f37eccac79b09b159d77e3a8c357c613a42c34c476d8","withdrawal_credentials":"0x2f66be8f18c43371649f215f6061cadcd1b22647468faaf15a94c76e4b996139","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x954c039820868bcf0462ce5f03f7b1b580f6a1d3a6b11e563a111b99e1b6054cd85c0a2a8bee9aefd2662ce57389c26e","withdrawal_credentials":"0x0924ca8fd82c75e779195308b94fa142c4ac2823dafd587dfe9140de96d7f223","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x92fa07603f121755a03f501e681c7925c4d7ac722677a7afc30ac3ca17edc591a3556a07c3389454b6395655410b0851","withdrawal_credentials":"0x7beaa68f98f2b08439abbe0caf841c11eabe228f20b24dda1199d58fb51c3f64","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x924bcf588ccd2cc807ebc2a13be45d1d823189083c7ceba599dec6c4efc2fe584f2feb773acc6ea29023986b0c878c3c","withdrawal_credentials":"0x55a8b28f585bf2fa4e25f0b50873f376ddb8246bb320fc65b6964eff005bd04e","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x87bbe1851c1c76dff5724ff9ea4991eb18cd973368e2fffc0a8f96a989dba8b3ba2364f472ee3ae5efa88cffdf0dcff3","withdrawal_credentials":"0xc86e8f8f18212e980db75bbafda76e4503cb1ed7f9d4f0c2c89de3b01ea01c8f","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8fd60c26c770f756f5755e24dd842815bec4d2a4d5972bed81f619d65f5c438b55d0815a51fb7ac29103ca30d56d3f12","withdrawal_credentials":"0xa12c9b8fd8896f0e23318d63569645abf6c420b38d439f4e6d9b5c2069dead79","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb9d761f4aae30c40a134536e82fe10a005776769a9aafa8828d84a2f6e2108324d3fc4b9dba8ff9389ee58fe7a891de1","withdrawal_credentials":"0xb1d0339099dbc10f3b6410fbd8b02fd754763adf08e17a66c77c81c93b080e63","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8f8a44d7b8bf1a9c4b0da59fd1c5b81fcd7f4bb65f74f5c15070896d801adade1afa3057e4446fc4485c95d8bba45322","withdrawal_credentials":"0x8b8e3f905944038650de41a4309f063d47703cbb9b4f29f26b7afa3887469f4d","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xaea0272cf434061757f99e10bf69a3d360582f9e017bccd33004f4171480da267ccbe05e2bab415fc721cbe05331ac70","withdrawal_credentials":"0xfd541c90190a3f231070ada826d4810b6d823627e1031e4f7e818feaa58beb8d","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x9352921ea86b4fcafb31353d6f6ec851f016bfd040261c0d25ed31513dd96f90db5aec8b62b4f01de27c844e5f938fd3","withdrawal_credentials":"0xd7122890d972809925eade517fc25871607c38037472ccda227f085af0c97c78","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa90d76c381296c7771550ec8802afdcd871323230b5fa6293372c211f13ecf26bea3529c6f3961efa6bd9f14f71ea78f","withdrawal_credentials":"0x4ad904909938bc36e57b4a5675f7d33f868e326fba26c13735869d0b0e0fc9b8","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x90426a54b52002ce7dedc53271685fac6fd34fc9f2ada48b0e973cfb70c1bfc669f8edb600fdc09a829dbb64754f70ee","withdrawal_credentials":"0x2397109059a1fdacfaf57bffcde5aaa57988344b4e956fc3d983167b5a4d5aa3","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb04eaf02e2c89a51c4a85719508e42e156e4b007be028a32c4b82f07a2caf480c200d239925858a9b1b06fe2ffe194c0","withdrawal_credentials":"0x965ded8f1967394aba87e703c31a26749f9a2eb794496420ec8aab2c7892a6e3","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x92d58fc2e15dabb9856d510362e29e3005eaf5afdaa6d73167910088cde285df049e183e7a073948228a32a7bcef4157","withdrawal_credentials":"0x701bf98fd9cf7ac0cf0119ad1c09fdd99294309327b812ac9088249cc3d037ce","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb2504cc3cfc396fd5d1c8bd0fb28abdb664cefce90c0e215fed809e0e003db8a213316794641974d8b41fb2e4e8a8e71","withdrawal_credentials":"0x46041a8f9709a0f936f26c1e8658094b80070b3f3883204e5cb529562e317065","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8fd5bfb6f3fc8289b2b96f61e85314fff9451620ff76e02ecd1f1e18f85a1d28d7d372757c5f62651e5ccc8747e88e9a","withdrawal_credentials":"0x1fc2258f5772e16f4c6c9ec7df46e0b073010d1bcbf1ced900b3a2c5796f0150","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa6257c4d665a74781c6474bbbd9e3654816800d9e620d6599a9d07d90ecc25b30bc2162406a110b04fb0287170b22bbc","withdrawal_credentials":"0x9288028f17381d0d0bfe09ccd47b5b7f9913078711a6c33613ba377797b44d90","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x9816d5dfe480e7407fa48799e97613b36b7e3f4ea40409d459afe79289f0865b489047923236c33de8d6fa5064e21012","withdrawal_credentials":"0x6c460e8fd7a05e8321783b752d6a32e58c0d0963a51472c2b7b7b0e6e2f2de7a","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x85af0debd8150ab283be02193d85ec6cc5bf83d5150dffa39a373e143166f556d84d80bb1639d3e9eae8f77d32607f3e","withdrawal_credentials":"0xde0ceb8e97669a20e009a779239fadb3b21f03cfebc8661fcabe459801382bbb","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa582b36ff4fdd89b42b41257e74f4ebef541d58eb26ec16690cea2186ad86b636fcf7b152cff1cb937ebb5dec4c0b41f","withdrawal_credentials":"0xb8caf68e57cfdb96f583d8227c8d8419a51905ab7e3715ab6ebcbe074c76bca5","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa9eace0075c4fd875cd34d1d33b70388239c8d2fb261d7f7de5410290ade122beb97e55eff954d6dcb34810dd689f309","withdrawal_credentials":"0x2b91d38e17951734b515442771c2ffe7cb2bff16c4eb090881c353b96abb08e6","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb8402ce87952bdd62fe35a001d5e6eeec1589ce7b17b533a549bc8ea0c623bc90b307a517c55b0b378d9a477c8bfaea3","withdrawal_credentials":"0x054fdf8ed7fd58aaca8f75d0cab0d64dbe2501f3585ab89325c1cc28b5f999d0","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb118ece6890d73c69e078778e485a36ec4c46c13835cbb0851e91203d23e92796a6d3db24576f30416ab1e821faf404f","withdrawal_credentials":"0x14f3778f984fababe2c2f8674ccbc0791cd71a1fd3f793ab7fa2f1d18823fab9","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xb5e5eea094bd1d47e8af58b0cf0923cec826c0273af1d70bd13c61bf1018314c962786640e23b4b99a4ca97c1e3b2fc5","withdrawal_credentials":"0xeeb0838f58b8ec21f83c2a11a5b997df0fd11cfb6666423724a06a41d3618ba4","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x98e1a9f686747193e5c4c2ef173376d7fa6eba245a6be60e1f03a4b8602ca44fa9c1854dfb74168650bef2ea472a71cc","withdrawal_credentials":"0x6077608f187e28bfb7ce95159aee12ae35e31667ac1a379436a7fff2f1a6d7e4","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa670ca0acad87fd703652fd6b5637ea08f0574ea796624bd53506ebc2987e74aad2ce81ad8944a00ea65e2c012a8ddcf","withdrawal_credentials":"0x3a356c8fd8e66935cd48c7bef3dce91328dd18433f89e51fdba478623ce568cf","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x967b31c6012734f4e06ec9c0213237fdf20c6f7a78d9cbbec2f7dbcfa02494f0176fad563f70226fdfa1c7e093fcc2b2","withdrawal_credentials":"0xadfb488f97aca5d28cda32c3e91165e24eef12af853dda7cedab0d145b2ab50f","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0x8c8669dd614a7d7e1be27c78d93f74445cd05ebffc97d6140770f324aac71e7600f24c07eff9671f844b33f03c57afc3","withdrawal_credentials":"0x87b9548f5715e748a254646c42003c4841e9148b19ac880892a98683a66846fa","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"},{"pubkey":"0xa7eea08884d0e81c6c4d044b6a5c624432fcbff44af67d95c889140a51b033e14adc747f85773b375d9d93f864728d59","withdrawal_credentials":"0xf97f318f17db22e661e6cf703735b71667fb0ef75f607d65a4b01b35c4ad923a","effective_balance":"32000000000","slashed":false,"activation_eligibility_epoch":"18446744073709551615","activation_epoch":"18446744073709551615","exit_epoch":"18446744073709551615","withdrawable_epoch":"18446744073709551615"}],"balances":["10316516445055493815","10321473899000513495","10319821411488862071","10258679506701745558","10257027023485061430","10261984477430081110","10260331994213396982","10252069569540041750","10250417086323357622","10255374540268377302","10253722057051693174","10245459636673305237","10243807153456621109","10248764603106673494","10247112124184956661","10238849699511601429","10237197216294917301","10242154670239936981","10240502182728285557","10285119251053593494","10283466763541942070","10288424217486961750","10286771734270277622","10278509318186856982","10276856830675205558","10281814280325257942","10280161801403541110","10271899381025153174","10270246893513501750","10275204347458521430","10273551864241837302","10265289439568482070","10263636960646765238","10268594410296817622","10266941927080133494","10205800022293016980","10204147539076332852","10209104988726385237","10207452505509701108","10199190085131313172","10197537601914629044","10202495051564681428","10200842568347997300","10192580152264576660","10190927664752925236","10195885118697944916","10194232635481260788","10185970215102872852","10184317727591221428","10189275181536241108","10187622698319556980","10232239762349897621","10230587283428180789","10235544733078233173","10233892245566581749","10225629829483161109","10223977346266476981","10228934800211496661","10227282312699845237","10219019892321457301","10217367409104773173","10222324858754825557","10220672375538141429","10212409959454720789","10210757476238036661","10215714921593121749","10214062442671404917","10575956426039018910","10574303942822334782","10579261392472387166","10577608909255703038","10569346488877315101","10567694005660630973","10572651459605650653","10570998972093999229","10562736551715611293","10561084072793894461","10566041518148979549","10564389034932295421","10556126618848874781","10554474135632190653","10559431585282243037","10557779102065558909","10602396166095899550","10600743682879215422","10605701136824235102","10604048653607550974","10595786228934195742","10594133750012478910","10599091199662531294","10597438716445847166","10589176296067459230","10587523812850775102","10592481266795794782","10590828779284143358","10582566358905755422","10580913875689071294","10585871329634090974","10584218842122439550","10523076937335323036"],"randao_mixes":["0xcc9b03923c85d9ce8eba32968977d98d668788d1c2f0e4f3a79facfcd8247794","0x933815925ca23b00aef1fc130edd9b26547e8b1b9f966ac51e1ce2a3480251f4","0xa6590f92fced1a45a334643fe265b0f35a818aad565f937f4b9d256c2363087f","0x05fff1911c68779d6d836818041217f579908587e54a5f223023775567479d34","0x1820ec91bcb356e263c6cf43d89a2bc27f9384199c1388dc5ea4ba1d41a854bf","0xdfbcfd91dcd0b81383fd99c15d00ee5a6d8a876379b90daed520f0c4b2852e1f","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000"],"slashings":["10518119487685270652","10509857067306882716","10508204584090198588","10513162033740250972","10511509554818534140","10503247130145178908","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0"],"previous_epoch_attestations":[{"aggregation_bits":"0xc13b057eebd0a20e77f0053ea01fb1035e29af5216f98ff11b7f25cf8046cb34ed31c1f6761b16d7afe0029f71a90db7afde04463f6d20229d7903c6e6552eaf91586219e79c006152c6cf537d5937a0fa86f4ce31b9204428b56ebf687be3c696964bcb53ac3724029e0c429ce7beb83445c1e4193aceb7a4ea95f8ec0c0560f26c46e10de9274bbeb11ff74e57d7a4bc836e04bae7f3d2263b46cd5d411629ef6c3b1739722b7b853d5acd9ac82c762a572be5c33887f34b0c15c5c85e6658b064b653507e8a0ef2dae6b6d670e493ebd1314844334bb3481ec4e1d6b1554c56fc1240daa19fbefd61072f78697e32ff5e0c5854017157c7057a7e13c4547a01","data":{"slot":"10541254261308783037","index":"10546211710958835421","beacon_block_root":"0xc1cc55927d62a30a24118d36f6fbb9560f5d96d5caf6a9c5268ffb08e6d86ffe","source":{"epoch":"226586384","root":"0x339332923d28dfa7e4a2f83aec303525346f904110ab9e22399690ba051ebc3e"},"target":{"epoch":"226971133","root":"0x0d513e92fd90201ef91c2ae4451f0c8b2869921da3194daedd93092a505c4d29"}},"inclusion_delay":"10529686874497026844","proposer_index":"10528034391280342716"},{"aggregation_bits":"0xfbc0f5ce1d02b16516ceb65c28a28d3f85a033dcb5791d1efedc4b0f0381c4a42e75e98800df99f790b9c2b76f9df472256e936684eeb05ce0f36ad995b4677aef38cfc9fce2a960cff495667e06a9190c9e1fe8e4b04a487e0e2f53916e44f02a3198fbdcc92ae15fa71cc9c45fa7e4e8925070cab533cede7b7c70fce4f6b5e789bab7f051d1dc0a422d56047959026c581b6a8177588c94ecec2c4dcad39048aebe7316774f4eb92640abf0176178856d1e5be75508d1217b16684b300237472d2b9f4a5a44aba75b1d679720e7bc6a5b5134eb2db358a51d141fce8980b4663230507371f9014293afb7debde3af1135fe419c3e6d9d1c6e0fe4cbae068801","data":{"slot":"10531339357713710972","index":"10470197452926594459","beacon_block_root":"0x2fbe47913bf9c26a35191b03fd916a302ee868118d07fe385fc51c05244063eb","source":{"epoch":"219276155","root":"0x097c5391fb6104e14b934cac5680419622e26aed2176acc404c395746f7ef4d5"},"target":{"epoch":"218121908","root":"0x7c423091bb27407e0a25b8b04cb5bc6447f46459672aa12117ca2a268dc34016"}},"inclusion_delay":"10466892482198258907","proposer_index":"10465239998981574779"},{"aggregation_bits":"0x895a64ccc2677a9055191cb998f76d84e62f6e2bb76e02ce1b8d1310e62f567c090dfd47d0851ffad9d504a4de88e7aff4ed4c8044912acb082070dbe57086f3b289c0f1371e2f92f9c96beebd5e4db7b48fccd0b8b1dcd4733ce40cb5590dd8d0c5a5fc75004b2e049e58b1054e6a770f26d8da3d8cfb946e9da02b77c8e60e43f033059cd511bdf67f3857a581eb8300e927af13a270fab524c871771913097cc07431875b3d7b2b341554b1e77be872c272e8399fa25e416fa1c2e2985c68f7dcdf5d5c4488b659c4258ed72ccaea3c70b8b403b17d68957d6190d80170424058a42a3a12e2e404efeb05363ac9dbe03d718fb8eee6414ed85716693269bf01","data":{"slot":"10455325095386502715","index":"10460282549331522395","beacon_block_root":"0xa2842491fbbefe07f4aa8607f3c6e5fe54fa627dd3bbf29572ccb1b64285af2b","source":{"epoch":"216582912","root":"0x144b0191ba843aa5b43cf20be9fb60cd790c5de91a70e7f285d3466860cafb6b"},"target":{"epoch":"216967661","root":"0xee080d917bed7b1bc9b623b541ea37336d065fc5adde957e29d1bfd7ab088d56"}},"inclusion_delay":"10496637192983475100","proposer_index":"10494984714061758268"},{"aggregation_bits":"0x8d57e4f001bd2a836a064b3f73dd152eb2083292d10d92d947bd2b28a8eaf86560e7ecedb63fef3e3f0e90623dfb142959cec7219ef449450bec0c7133dae48b513450bae190ea3ec196d194a3e83d4161ce9d216ad8dd3a3656eccf652f74e7657d5a6d2a2b5f93b462f74e39f9d777831d0dfcc9d7a699908a55e1cd48b4440730847db571f77dd121ab69526c55f45632128ca1c3d7ba6f28522d625580b90f112ca0a6f6b5c772987115606ea6a92024a771b8d922e592ecb5d7421343b5ea61d839abc5e208c1aa26c5068e957c5b6c95d31453f480490325c11fa5239425c93ee00e70cffad3441899baed5c1497a158a1f02240308b27cde3e0757b2301","data":{"slot":"10498289676200159228","index":"10490027260116738587","beacon_block_root":"0x4a318e91bb6d4b30b6f543fa12287493e3c37439019f147f3ab7f2a1e7b5ca6a","source":{"epoch":"221584648","root":"0x24ef99917bd68ca6cc6f75a36a164bf9d7bd7615950dc30adfb46b1132f45b55"},"target":{"epoch":"220430401","root":"0x96b576913b9cc8438b01e1a7604bc6c7fccf7081dbc1b767f1bb00c35139a895"}},"inclusion_delay":"10486722293683370331","proposer_index":"10485069806171718907"},{"aggregation_bits":"0x213b9e54dd8aaee5a2bacbec930cd5ff31458541408fe4422cd8a5664903ff344ffdc6ab3822055bce1185b6d787836ece3bff24c056bb08e5b87c2ab3382de812fc2b5b66d6fb0c13a69207d73d81b7e7996165029c364a14d4784fff1d8e122200ec558ca23ffe6894cbbb868adcf918e9a0430e8c11b36851607589b7a39682363b7dd559b2d93acceabdffd4a52c5b1f2be0be8cbf7020390ce69fc9b08da5ea6fc6806e4460b19a925d6bece0d8738581255df831f56caf9efd1d213a6e2ce7538a4264d1538f5439765ba2fa4bc6f11bc71b33fc161072b98d0f97efaf0040537d5593a882020e43aef7cf45ab0151aa44f0613ac959a4f2bf6cc9751b01","data":{"slot":"10475154906871614139","index":"10480112352226699227","beacon_block_root":"0xbdf76a917b3387cd7687affe075def6109d66ea5475309dc4dbe875305fb16ab","source":{"epoch":"212735423","root":"0x92e08b903a6dac06dc77037071acfbd2f6484951581e177e18eb8c0d705b4f42"},"target":{"epoch":"213120172","root":"0x6c9e9790fad5ed7cf2f13419ca9ad238ea424b2dec8cc509bde8057dbb99e02c"}},"inclusion_delay":"10410708031356162073","proposer_index":"10409055548139477945"},{"aggregation_bits":"0xddd595431d0af31b61ea10b20de18776036aeba5ffa89ea53f751ff1cee785757cd3425f05b16691595a874d1e507fc75cf5cfa3d10d9dfe8eab23f990e7488f506dd260338a4dad5aa077212ffb4b3b494cb07fd331729ee4ce737402dcfbf9ee2b67c24426608db34a9027e3440c87fc741090677d8f0f50f8422a24d9b73a56e271cf640dd597b0bd8e6afeaa4dd6ea443aa20b426e9a6e5fccd3551469d50f1d629648ade6cfecc934acfb6f399ac49156c8222e066f38aec1d2a97ddcdb0f821d5ea9d7d89288db57f547cbed8c6d6d5f4d3ae9663a14a888be217546c8736fea1cae83bbe8b6d2d497d5aeff71c039d3395853bd6448ba081b9e0254b701","data":{"slot":"10412360514572846202","index":"10404098094194458265","beacon_block_root":"0x2be95c9039caa62d868f3dcb0ef39f3b286141e10b645d4f86f4a84f43620a98","source":{"epoch":"211581177","root":"0x05a76890f932e8a39c096f7467e176a11c5b43bd9ed20bdb2bf221bf8ea09b82"},"target":{"epoch":"210426930","root":"0x786d4590b9f823415b9bda785d16f26f416d3d29e58600383df9b670ace5e7c2"}},"inclusion_delay":"10400793127761090009","proposer_index":"10399140640249438585"},{"aggregation_bits":"0x55ac8db6c3e77f41740ad6dfe9eb29fb1061d50ca4fff68497b8dec6ecaceef5837bcaf6c1da6f5439a6456326b3c237b402a7d3fbe109273c26708613e2af9da43196bd3e82831b0ddbdc104ed7756381c142db8ffae1165fd005c383ec8e89f95ea8f7fe401e9ce3d905de6976ce695943d9e609ec94c626b1c4c4380f812762cf20fd90e1852c36a5fda321c7cad2615f72558e5a550a81c957f6bbdea72af3fdb41d23f1b8f97339f372fc092a29bece580e07e10ad118b96c4215902a8d42a3e0cca233762288477e884a582a563e683021f10591ca905a995376a94dae5b997d05d8589e7fa518a13fb7bf2751a9b508605c816d7cdbfd12382814519001","data":{"slot":"10442105225358062394","index":"10447062675008114778","beacon_block_root":"0x3b8df590fa1bf92e9ec2c062900d8a6786125b0d86013967e0d5cdf8158c6a81","source":{"epoch":"215043917","root":"0xad53d290bae134cc5e542c6786420536ab245579ccb52dc4f3dc62aa33d1b6c1"},"target":{"epoch":"215428666","root":"0x8711de907a4a764273ce5d10de30dc9b9f1e57556024dc4f97dadb197e0f48ac"}},"inclusion_delay":"10430537834251338906","proposer_index":"10428885355329622074"},{"aggregation_bits":"0x05366eea76f3627e9ead05ed4064b5c515604bc9074a446b787ca94ec04fe9ed263ddbb35f9ef4786eff150b11d13252722b340740f3d86b22171218c4972794d2403b38205a3a9210f1ee4945c88fd0f2d82988d8b7220409a8702c28b9f12b95e47be3f1a5474dda686455328aedb9a6d368d1fa6141bade74ad7cbab6f524d76abca76f9576fb3e165ca26af9037edb8217f334e43818b2209c6aa9d5625dd2773db049cc9ede4636b30cb0f76f8721f245f5c6cd95f8fd3ee6ed9cea2ae130dc13a1b7d7bf66de4ba9850f08a1b9a7ec36380e0f65659dad74adb7938d352b7759172350358c1c335034565af60d67dfc2fa9cfc59a819d86d0af5fe570601","data":{"slot":"10432190321762990330","index":"10423927901384602394","beacon_block_root":"0x465ca390ba3e2ff3086c66c22389a99edd3c4d097ffb739561e67eec06d87117","source":{"epoch":"213889670","root":"0x201aaf907aa770691de6976b7b778004d1364fe5126a222105e4f75b51160302"},"target":{"epoch":"255827300","root":"0xdcefae9543414ac349e1a87544f303617ea32692cb7e679a0ce37bd25b9cdae1"}},"inclusion_delay":"10790779338697236067","proposer_index":"10789126855480551939"},{"aggregation_bits":"0xaf4365f0f77f9dc05312c66c10b5d8bb38f21c4f412dbf2df45aef7cb76d4303d65003cd8f6e0b06cbb9a12f02c198e2dd6c7b0c902e28dc5e26f55d6cfbb7c4b45660676be47b2fe3ccd4ce9a0d11c5e674b2a8a1d59f5b9214067ba24f02110840eef06002456e162eb207e1d0033153e46a58aa1c7133bce88905268fe089ae20101497bab8d84f415eb4467cfaa36b97bab11a1b7d3f070b7e77aa7396f66149afc2d5083a1e188fd5e71419b009bc96592f29ea74ab56aab53304d7999a605157d0e491db97daf6167f629567b1c39bfc520a71e79f06745e110d12698dbf07165a0c2eacd0c82911e89c689b90f57f2ca5ffaff474b9c918f240ffa0dc01","data":{"slot":"10779211947590512579","index":"10784169401535532259","beacon_block_root":"0x0232a39583d8084d336777ccec042dfb8ba924b63810b90e67e50263105e49f7","source":{"epoch":"254288305","root":"0x75f87f95429e44eaf2f8e2d0e139a8c9b0bb1e227ec4ad6b7aec97142ea39537"},"target":{"epoch":"254673054","root":"0x4fb68b95020786600873147a3a287f2fa4b520fe11335cf71eea108479e12622"}},"inclusion_delay":"10767644560778756386","proposer_index":"10765992077562072258"},{"aggregation_bits":"0xdd1982ad734484ab7934d17899984cbc74fd0045e7cc2b4a42a09da72092e46a55d29ef179af00eee680b147083d49a70c90cd3d28d6b9f16593ad538b4adf5dce3bc7a5215af3395a7b8b9ed13a8354a16cd23f649c955b0a645d978b12bf35642e70c8bfe758ab2bae41c639681f4959bd73ccfb930c0bcefd68b36e1488c23909a41e260a4a1f7768efbb6d067730bbeadb13240f51ad2492f4cf22f8d98a70c0750cde1fbe36fe4eb1a1ee66c7270f8f57d099e0f9083d2d1b9a023109f1322fe4cd6ed443f287fbdbfe6dc96c0e841fd03461691e7e0a33307f813b751117c1367cfce74f03f95258e228c40068aa11ebb77791003fb9a0a2f59e8de0ba01","data":{"slot":"10769297048290407810","index":"10813914112320748451","beacon_block_root":"0xaade0c9643875575f5b134bf0a66bb8f1a73367266f3daf72fd0434eb58e6436","source":{"epoch":"259290040","root":"0x849c189603f096eb0a2c6668635492f50e6d384ef9618983d4cdbcbd00cdf520"},"target":{"epoch":"258135794","root":"0xf762f595c3b5d288cabdd16c59890dc4337f32ba3f167ee0e6d4516f1e124261"}},"inclusion_delay":"10810609145887380195","proposer_index":"10808956662670696067"},{"aggregation_bits":"0x452abf40a90c43f5acf411357174e8406ec937f4ac094533c0cd17903241edfe8ff81a38c3dcd5aaad34336d014cd573b3fb298d107b6907f73efc98339a9cdbbcf288b9fcdc0dc789860b00603667adbd5131471e539fc10350f128d22698cffaffefdddd992c9e7a75843e321ce59fbc831bbcb532bb163a346c4bf8daa6f51de5d5449ac61bb781721e6eda2db52416d1cef6f5973b118b36ffea0c323a7f00223337d479456db3675e3f5f7ab91c5ff1f132cc0bd50c9f96e64ce5545ff03b0e1a0f6bb196538f66eae1a81407c87b5215530ad3e409021827bab8fdcb62cf1f6103dbed46c0daf89d535b85976c1b1f756a176342b5e6a5bde3459abdb401","data":{"slot":"10799041754780656707","index":"10803999208725676387","beacon_block_root":"0x1da5e995034d9112b443a0c3009b365e408530deaca7cf5442d7d8ffd3d3b076","source":{"epoch":"256596798","root":"0x906bc695c312cdaf74d50bc8f6cfb12c65972a4af25bc4b155de6db1f118fdb6"},"target":{"epoch":"256981547","root":"0x6929d295837b0e26894f3d714fbe889259912c2685ca723df9dbe6203d578ea1"}},"inclusion_delay":"10734594883560171937","proposer_index":"10732942400343487809"},{"aggregation_bits":"0xeb8e995f3d04154367e5c8fbe3bbb4f574f1511a07eaaf34f561f711ada4e41a9b869e55cf4672e70bf4f1dc42133b7c701db8ae61e36bd31fafabff3d455dbc70e250c0bd649b26c091ee088cb027201d34c36d43de0b25c67a8c3b727bef260a5074441d0165d3e6f34da054d62ef95d1f2f6cdce1884c809c6c0f5f0fb2d1cb9082ceaf32786a8957cc89fb1348d6040a81b5a07bda1fd7506edf0e4fa42652b4bf634d3f68a26d33b03fee9564d6f3f5ecd3d82ef19cce2bb127a8199c071a6d55b31313bf13cbaad524f4771115b5a618591a137ea7a6069d2844367b116e3a587038fcd5ce7e002aee5c9c3d56962349579fc44301ffea6253b3dc991001","data":{"slot":"10736247366776856066","index":"10727984950693435425","beacon_block_root":"0x8c96db94c1e3b072c54b2e900731e7375f10031a70b823c87b0dfafb113ba463","source":{"epoch":"249286569","root":"0x6554e794814cf2e8dac55f39601fbe9d530a05f60327d253200b736b5c79354e"},"target":{"epoch":"248132322","root":"0xd81ac49441122e869a57cb3d5654396c781cff6149dbc6b03212081d7abe818e"}},"inclusion_delay":"10724679979965099873","proposer_index":"10723027496748415745"},{"aggregation_bits":"0x2df2ea7a81b89729a55869bc2328fce686cf64d8d32aeb96dab9204f5fa472b275dc249a41525c80b90e6643b4efae8bf6db216d6d43d17777d98bdca4f6b447a73e2231ae86822632a98c9b580183666b5305e583bbe25538ea389bed6553d57d2d936eba0455906855754463a02156b1ca83779b2a2e00f0d369dc435b01ab5c4a25ce0032390de0fe097d36fba1ebfea6a9c95f9c9029581b1304f1dbbe139e88e6f34b92216f31e314757505dea79545f90e376cc02cb078920bcd2261c0ddfdd61c7ec3d4c9cf1461bbe84138262ebad6dbd433e2b24e7a999f01258f3e09b7f5e93ade1a86666cc05f1144201dbbd59a289bc6bd6b6c6a487b0ff8a1a901","data":{"slot":"10713112588858376385","index":"10718070042803396065","beacon_block_root":"0xfe5cb89481a9ec0f84dd9994fd6562068522fd85b66c18258e148fad2f80f0a3","source":{"epoch":"252749309","root":"0x0e01519542fb3e119c101d2c7e804c32e2d316b2310af43ce8f5b35601aa508d"},"target":{"epoch":"253134058","root":"0xe7be5c9502648087b28a4ed5d76e2398d6cd188ec478a2c88cf32cc64ce8e177"}},"inclusion_delay":"10754424690750316066","proposer_index":"10752772207533631938"},{"aggregation_bits":"0x292f4bf64ae18b6298276fbee03604ceeaeee974f2cffdb89e1d082b128d44e3ea0225a00760a4633df3b188709e5ebd5ecba24ef5aeba507013a43e655956b74492b2baa852e0392ad89746f696e782a6125828ccd2622b2780b27b39726de44d953ccb84b74523ca891ee2971288970a9857f767d34219069788d1e35af7cf0833f796a2bafd1f87a48e51a94213fe346cb5d94df43d4980276be2d6bfacabe3ffe4c059debbd3e64b37ad859a16e5cf967dae56cc611f4c7196186fad7a0da7d3d86e9c32fcef1e3aa9ca38b758a24e0772240fb17be9c70540bf4881bdb83c2aeb634f2d0b8c5841bbcddb50a0f27bc198d6ffcb8f04aa8867eedcab8ea501","data":{"slot":"10756077173967000194","index":"10747814753588612258","beacon_block_root":"0xa609229542583938462857871cc7f09a14ec0e42e44f3a0e56ffcf98d4b00be3","source":{"epoch":"251595062","root":"0x80c72d9502c17aae5ca2883074b5c70008e6101e77bee899fbfc48081fef9ccd"},"target":{"epoch":"250440816","root":"0xf38d0a95c286b64b1b34f4346aea42cf2df80a8abd72ddf60d04deb93e34e90d"}},"inclusion_delay":"10744509791450211298","proposer_index":"10742857303938559874"},{"aggregation_bits":"0x0b67f1c19d8c1e87dbf0351fdc962141a70b2c05f31cee6873fc486cfb876ecabc5a715e94eb1e8d555d36dc11cb6ec38a50f8c814d320c73c64b33c155436aa112394d2f2f1fa113cd7e5c9d5cb130a9c2384949cb7770ce9b0ed571d8d1f46966117cc41f464baa38c9aba14c073747d64fb5e8ad8ab5316b3dd89ea646772efeb160c8bba9afc6b991b510afa3295e06c752a6fa2199b81ddcd15dccc0531bfb02e10cb53fde4f61b255a627afdf47c1d02ad2926fb88066631b6f71bb41633a42dce1e1d037a80e7b903f9bfccf6162e97baf745216fb66d11895c28251f1940ff5c56d7244d4f75f463559cce32c213189cf92bd65dbc3c2a1c7b2ff92301","data":{"slot":"10680062911639791936","index":"10685020365584811616","beacon_block_root":"0x7cf2429400925e71ad18abf88516fd0b025fe9edf51a48b0212cd5523e11447a","source":{"epoch":"242745838","root":"0xefb81f94c0579a0e6caa16fd7b4b78da2771e3593bcf3c0d34336a045d5690ba"},"target":{"epoch":"243130586","root":"0xc9762b9480c0db84822448a6d4394f401b6be535ce3deb98d830e373a89421a5"}},"inclusion_delay":"10668495524828035744","proposer_index":"10666843041611351616"},{"aggregation_bits":"0x79dc1ae55e5e5ea992cb3129d46a954472e8b84115dc379386403eecf76081ab1c18d908a6af0549598576b63635974753fceeccbedbb0fae554d3f2d2613e7b61403050f80b410981f432d4c6b58191da1b744e58fa5d1a7d083aedf691a2ea9ac2c1d0d3037c0d97add89bcdbc4e0435b24a094b5f5e6eecf6198e389d50a1b9caa3427986e9a34b7abbc24794b79e083f14c2b0bca6c9835083f4c4c760812c55fe77e4272cd7400c74242e8d89f893221c9aa82b642269b9621fc5eb4473c0e8b2f281598e3fda67224070e727c879a6f3aae04f5952fa2bfcfcec01f1e479867d19ac9e47eaf04fff63f390169fd859e30e31391c1a2915d017a6cdb03301","data":{"slot":"10670148008044719872","index":"10661885587666331936","beacon_block_root":"0x88c1f093c0b4943516c2505818921c435989dbe9ee1483dea23c8646305d4b10","source":{"epoch":"241591591","root":"0x617ffc93801dd6ab2c3c82017180f3a84d83ddc58183316a473affb57b9bdcfa"},"target":{"epoch":"246593327","root":"0x71239594416f28ad446f0599f39addd4aa34f7f1fc200d82a11b245f4dc53ce4"}},"inclusion_delay":"10711460105641692257","proposer_index":"10709807626719975425"},{"aggregation_bits":"0xf10c2208026592e3342af24e5f0013b86801cfed961b4ce400047ed375abc63fc38a5083fdddaa0d7b72b49a1a158f13348e8a3cd837f512d5919a9c02f5198111777408abae8c2dd78b58273fa8be684717036263f65f874456bb177785919445b6de657174403a4fb229a6c78894cafaf3c35d7dea6164989f1dd7341966aded463354a50a3d883522ca9bd0ae6cb8910851674124dfdb04e68c8a204c8bb05cb334fdcad386ed6de4b2bb1df9bf65d97e42d2cdc9482ac1261c8938ae122d685be8f1953c6a93d67707fb373cc04ea6e57cceae6724207a58ed0c89c7c3b243f828468b0c6e29ce9c3090d2e2cad66bf5a95303a0dad0ca728f254ecaaf1e01","data":{"slot":"10699892718829936065","index":"10704850172774955745","beacon_block_root":"0x976589948106e7362ef5d3ef9aac066fb73af51569b25ef6fc1dabef0287abf9","source":{"epoch":"245054331","root":"0x0a2c669440cc22d4ee863ff490e1813ddc4cef81af6653530f2540a120ccf739"},"target":{"epoch":"245439080","root":"0xe3e971940135644a0301719de8cf58a3d046f15d42d501dfb322b9106b0a8924"}},"inclusion_delay":"10688325332018179872","proposer_index":"10686672848801495744"},{"aggregation_bits":"0x81bfc090bfbf83ac6957e66c55bb25f7a502b2ab50b9dc8b959e3a137a4c695266dc626dca1db5a5462066e41ff47ec67d225d7d6781a16f08c0fb12e39417204f1619f0e9195314e9fd9f9a3e9cc4b9a91fed93e5be3d05ba48ecbbb6d0a821780c8d754eb159ff3a32eb311870e898e2257ad81c459c2b6c2e366986e417fa7a4f8a0a742a6c2b45932998d9c0e93671d130855d1270c9362f474d4c574e0dbc3ba598e54291cdd2d4e77c3084da4be6459f04496ec5096ae13e28b270325a01fb1e878e78ebd707fbdcbaba654f71b32d9c8fd9ddd884933a85f751fe110b212ecb4e27078ffe770e7938f47c5b6b2d3bbae89b96e29e5e59752f93a5afcc01","data":{"slot":"10689977819529831296","index":"10628835910447747487","beacon_block_root":"0x06577b933f9d06973ffd61bca142b748d6c5c7512cc3b2693654cceb3fee9ee6","source":{"epoch":"237744102","root":"0xdf148793ff05480d54779365fa308eaecabfc92dc03161f5da51455b8b2c30d1"},"target":{"epoch":"236589855","root":"0x52db6393bfcb83aa1409ff69ef65097defd1c39906e65552ed58da0ca9717c11"}},"inclusion_delay":"10625530944014379231","proposer_index":"10623878460797695103"},{"aggregation_bits":"0xad277bbb7ae243fb2f86dccf2f5fc51ce00356d2713a46cbdc5d49189f62163b7f9476015ed202330f2cb794beb5651fe9bd83b8c3eed3f8c4976d1821d9f5cd80ad96c03fbb29fc6da2ff9172efe0bf118e5327ab5ca41217c773a410756e8806d132728f78792040962ecdb6b1593add99da239b666c734ad878008dda255390a123924d6e1b7adca6ec193a79689d2d6a34e8fb257d0a5ff5033e17cda7d4c8516f8a3269f3fdc7a5f5827df2505a0dcaa1a717be0f8e60e6688a12e82f41a92bce37888b1a00b504d653524978c3f305fd1311d124aaf652402d65178ffe07579eb45adca663f0003d9ed0b275b3ac3db6939c46014658bf6add3428700901","data":{"slot":"10613963552907655742","index":"10618921006852675423","beacon_block_root":"0x781d5893ff624234fe8ecdc097773217fcd7c1bd7277a7c6485b619d5e33eb26","source":{"epoch":"235050860","root":"0xebe33493be287ed1be2039c58cacade521eabb29b92b9c235b62f64e7c783767"},"target":{"epoch":"235435608","root":"0xc5a140937e91bf47d39a6a6ee59a844b15e4bd054c9a4aafff5f6fbec7b6c851"}},"inclusion_delay":"10655275654799595424","proposer_index":"10653623171582911295"},{"aggregation_bits":"0xa52ac334c11b0a68135db44dbc07fd360426136632dcd8e95cfd57b21f2f2122ba404b9b3aecf3ecabe7277b5ee6be99019f019f08b3967f521ad5bef47ad7f1f2d986037d236b03f6ffe758a45ee00998566ac8b095ba785035b9f782b191b3b13ae1d7ee57408ffd6a867b43b7f95a618306718d171c7c26faf8d9b61875299db4a10c75b2df1abbf45ea5c792dec8cb93496271455b3bceed975e20401d60bb4e674f8ddd28513809d652e773513a4bbd26720c6cec1d3827589f9a6122d87536ae51772970a6672b1528a79b87e583b85978b8b7bdd8ff05052d68f3b12876cf94c4df1c7b2552b90e001036d2590da18a2d654baa231e9415a8e7fb8f0601","data":{"slot":"10656928138016279552","index":"10648665717637891615","beacon_block_root":"0x20cac193bf118f5cc0d98ab3b5d8c0ab8ba1d379a05ac9af1046a28803640666","source":{"epoch":"240052595","root":"0xfa87cd937f7ad0d2d653bc5c0ec797117f9bd55534c9773bb5431bf84ea29750"},"target":{"epoch":"238898349","root":"0x6d4eaa933f400c7095e5276104fc12e0a4adcfc17a7d6c98c74ab0a96ce7e390"}},"inclusion_delay":"10645360746909556063","proposer_index":"10643708267987839231"},{"aggregation_bits":"0x254ea956740f9888d4721b9cce953727763896bfa04ddc5e9723b5ec395fbe8744104d7cb6f0d9cac88127d5a83f2bce166b594d2319c62b2f4ae4d8fd89789080f1eccf6e453e43042f14fb7a268cd74a38c24870d045c8ca870d97db156e51f40f1bfd2a7a48e0298d9adf71f5f6958a7ea2da587cb656c705b72e73cf7acf912c0eca63ba981ed01dfe51082b37b014bc402e548bbb4948e04283bb4c2f5c01fb04652b4d885a4d6b723abef3524b98a520faf34e5d3de6b6f6bde17acb5baa30266887e25fe9e79488bb9e8d7ed25ee4936c345321c53675182431e04c11775728fb891fee5c58d1f53dc566e90f195faf794449f5ca0dd72fe473d6277f01","data":{"slot":"10633793360097799871","index":"10638750814042819551","beacon_block_root":"0x93909e937fd7caf97f6bf6b7ab0d3c7ab1b3cde5e60ebe0c234d373a21a952a6","source":{"epoch":"280451230","root":"0x4f669e984871a453ab6607c27489bfd65f20a5929f230386294cbbb02b2f2a86"},"target":{"epoch":"280835979","root":"0x2924aa9808dae5c9c0e0386bcd77963c521aa76e3392b111ce493420766dbb70"}},"inclusion_delay":"10992382381327012904","proposer_index":"10990729898110328776"},{"aggregation_bits":"0x0f853bf134b8389b7dc5689b511018e285b34eec630787e46a11c60815224bc5d1c7a6887e51853a49a8ebffcaf6e3486e79cd454ab5b5e7219242e13ae7e918253cb6d4743382b29e958bbf71aeedeb8ba0c66e4ea7bc353da8d1aa2202b527623882f2a255ff2d8e9cabc96a2d771ab17df5e780e6fdcc3e931518499855e6ca13316736b97bcef3f6edb140698e8ae159a9a6e99c3a8d305f775919adad36b1b8a595b03426bb7af1b0c71b73c1da17552645334dc046502683eea7b6e1af57c57cbd089469b25a96e552865bda4ba669a43ec1b1e94d6801626f135bd70dd659cf3638abb8a83fb903967afbe030c86fa830866470278e64bf6fce92783c01","data":{"slot":"10994034860248729736","index":"10985772444165309096","beacon_block_root":"0xe86e6f9848ce9e7a557e411d11d0633f91389d22526949579755d7f2fe35e5db","source":{"epoch":"279296983","root":"0xc22c7b980837e0f06af872c66abe3aa584329ffee5d7f7e23c535062497476c6"},"target":{"epoch":"278142736","root":"0x34f35798c7fc1b8e2a8adeca60f3b573aa44996a2b8cec3f4e5ae51367b9c206"}},"inclusion_delay":"10982467473436973544","proposer_index":"10980814990220289416"},{"aggregation_bits":"0x17952318786767a33407a0d13152a63f1b8f7890685777d5e5d7dc3e67cb655138cb8e410222fa3d2938291dd666dbbdca2ea935687a2509933736be957e38925368e78a29345c802fca802298063a1217f178c33001962f1efc48417a32845b97584de54471a19c5b0946814310f5ecce112e29c671a24142f831c7f4ee22cf7c1ed055e225aa7dd1a01c78773644ac7c5258514914561b93e9708eb7274c4343580b2a9a60a1a1c671661909e746a1756228975588ec985785ef2c15df97c97ff4f26b2b99bd735616d668838329d57d8bab72efa91cdc6b30138a78957e7d96a7da7236319c6984eacf2d59e098bfd9c171b5e4b6f02d7161c7e5738e67fd01","data":{"slot":"11023779575328913225","index":"11028737024978965609","beacon_block_root":"0xf71208990920f17b6db1c4b493ea4d6beee9b64ecd06256ff136fc9bd05f45c5","source":{"epoch":"282759723","root":"0x6ad9e498c8e52c192c4330b9881fc93914fcb0ba13bb19cc043e914deea49105"},"target":{"epoch":"283144472","root":"0x4497f098894e6e8f42bd6162e10da09f07f6b296a729c857a83b0abd39e322f0"}},"inclusion_delay":"11012212184222189736","proposer_index":"11010559701005505608"},{"aggregation_bits":"0xa58ec0888b55e6f8e63dffe638ed22d8da8ec494ae23657a39299af4890e62399ac9bf7734f6f5912a25e9fdc839abb970668f90d27cf5748f065b306697ca030d189eb221c2f58ff2e812f399d3a88bf18d1891f588dcaf9c640fe8516eb3bca1f59adc0bb6d9896eab1692fdecc2b4e44acd2f13e49739b879da46f34b1250eb9f7c733f15d98afd25ff3b3839c1269c8fbdfb563afc092509b6c787bc01f710f2fd68b150d580f0ae375f0638838aaa3a2749d52653f4bd42eeb1022717a414bed54236bc20d6040ab9bb4cdbaaea4a82ca4bc833e4330916bee4a6fc69e0a651e8204b78f3de3f9882357d0c0946330bf3c24c8bbcabd908bfe6ab74620b01","data":{"slot":"11013864667438873864","index":"11005602251355453224","beacon_block_root":"0x03e2b598c8422740d65a6a1425666da24614a94ac600609d7247ad8fc1ab4c5b","source":{"epoch":"281605477","root":"0xdd9fc19888ab68b6ecd49bbd7e544408390eab26596f0e29174526ff0ceadd45"},"target":{"epoch":"274295247","root":"0xb288e29747e58def52c5ef2ee8a35079278185d26a3a1ccbe2712bb9774a16dd"}},"inclusion_delay":"10949417796218389095","proposer_index":"10947765313001704967"},{"aggregation_bits":"0x3f7e5eaf5cd0af1f29e8945ec72c32331389397586fd6f18ba18fbf14020d857bc8b8aa385ac57544f013ee679ef3245853cc5b53701d7e346d15d2a165b828e60f33742f333f737d6c742bad085cc8d6bbd00a5b189c8995476c0d645d163457a09715ec258fa125f2f5beb122f295751f271c568dddfb588bd041cfcef00f40f60a4a712519a9e213c2a7a998072ddc434db5ec20cf14b6cd29072cc36282f45d89538263bf7a0645c6131cb894b5a0bf458f88f5df973d570096bd8adabbfbc0f04e203bafdc9f27bd512c7d707180aeb21cda0273e07487eafbe9255b93bd00b2c9bd486d92f38f6cf4377a02354da13b8bd6a414f63ffbe22bd19f1a9ab01","data":{"slot":"10937850409406632902","index":"10942807863351652583","beacon_block_root":"0xd9cad697877c4c793d4bbe858fb57913338783f6d7cb6d3f3d74b2492b0c85f2","source":{"epoch":"272756252","root":"0x4b91b39746428816fcdc298a85eaf4e159997d621d80629c507b47fb4a51d132"},"target":{"epoch":"273141001","root":"0x254fbf9706abc98c12575b33ded8cb474c937f3eb0ee1028f478c06a958f621d"}},"inclusion_delay":"10926283022594876710","proposer_index":"10924630539378192582"},{"aggregation_bits":"0xdde4a5bfd3c236608efd8529c4817e2f128a17bb0558cd7b49faadbf7d673777567d91d5b3689c3c3a592ede6c90c31144c082309f8146cf9ae1fca4652a8a473cc6189069cb783e49f4b563b1c05b5c1c8569d7f4c0e31b06afc57bacc8dce2b622e7467d1be3b76b877ce24e571521de02d040ad70aaee7628ba99140f710faa493ca9e761eb581dfedef3d8fff5207469bb70fc3e1c194e5f7aaa10654593c25a3e2f2d2a108052f77157af7f2cf4748ec44f2f9176d0a42712d6a8512dd0d0dcb380929e164c25773a330c8fcc17ff6b0b97b79dcea8342c1bc70f6d6deee0e59ddaadcf3a94818c4e69564dbe2d34188a0c2238e7ae29935f8ec116ff5d01","data":{"slot":"10927935501516593542","index":"10972552574136868775","beacon_block_root":"0x81774098472b99a1ff957b78ae1608a8c35095b205af8f28065ff334d13ca031","source":{"epoch":"277757988","root":"0x5b354c980794da171410ad210705df0db64a978e981d3eb4aa5c6ca41c7b311c"},"target":{"epoch":"276603741","root":"0xcdfb2898c75916b5d4a11826fd395adcdc5c91faded13211bd6301563ac07d5c"}},"inclusion_delay":"10969247603408533223","proposer_index":"10967595120191849095"},{"aggregation_bits":"0xd715ac460bf97b7ac2794a03c6cf82800d63300b7e5dc40ffb356d8ccf0d70e9bb47995e4c0fc1f979adaa7450705f852b8bff54b76d9636aa4c61da4033f9b540fe4e08e27fe4883e2f1df6d82ecaa418c89f68eaade043a436fe803f9a59de28f65873dfe1cc822bb4e1dac5638fab26350b04d3cbb5f10f51824203184faa0ee4ed8b3ad53bf8ef97abf04ff03ef4795adf1149b33789e9e9558d64a6a2a6b43a5c952f5e8af6fb06f689884f0a2f3ef38a356a3e788c741c2e44d5356f957d5579973d9aa9b827e70de801111781a02ec0f834a5bbd9a75f52064ca276de880b9a858f57105e8e270bc8645c2330277dc355a2caa9e7aa46472c1e85ea9801","data":{"slot":"10957680216596777031","index":"10962637666246829415","beacon_block_root":"0xf33d1d9807f1d43ebe27e77ca44b8376e8628f1e4b638485186688e6ef81ec71","source":{"epoch":"275064745","root":"0x6604fa97c7b610dc7db952819a80fe440e75898a911779e22b6d1d980dc738b2"},"target":{"epoch":"275449494","root":"0x40c20598871f52529333842af26ed5aa016f8b662486276ecf6a96075805ca9c"}},"inclusion_delay":"10893233345376292261","proposer_index":"10891580857864640837"},{"aggregation_bits":"0xab73bc0b8fe9b784143b93c80da7821c37ce7eede13afb35eeb8c50900ccaf4e99679d206394aebddf5e6c0b99beadc9390d4e96e69cbee1d15cb484e3cc481683cb8773b4ff104847b8f8f56e22ce28b0f5784e7280646362053017dc819874df65c1ee87fbf28582fbb254be990557dfaca5c5b83023b924f8e404043bd19e1bb037fbaac95c8047a698c56eedd48e4a8f86d7dc6dc70bb78a84b6ee703abb8725a4c867b7e45c256148783980c7259937ddfc329a5d4034b1797f5060ac6264324282f31fb5ff23071ae91f70608eebfa85b217f727749003aad75241cfe9b93eb66b404680792addbc55f63db19afa848ec183eced02bb519d88c4c283b601","data":{"slot":"10894885824298009093","index":"10886623408214588453","beacon_block_root":"0x622f0f97c587f49ecf2f7549abe1335008ee615a0f74d8f8529ca9e22ce9df5e","source":{"epoch":"267754516","root":"0x3ced1a9785f03515e4a9a6f203d00ab6fbe76336a2e28684f699225278277149"},"target":{"epoch":"266600269","root":"0xaeb3f79645b671b2a43b12f7f904868421fa5da2e8967be109a1b703966cbd89"}},"inclusion_delay":"10883318437486252901","proposer_index":"10881665954269568773"},{"aggregation_bits":"0x0b3fd5353a4eaf60d891189cf5b4576f9461652650aaec2261bb7a572664bde7bf54afdccb8541d22df46dee96d11c1b2e8ba6d6ea3c0c4dbf2ac2466336c17961236c82b27d455a95203b669d3928a6f692960e53c79bb7fca1e437c03836809a3136d4085cf7886c9c8eb10c4bcb3d1e59006aff4b9893f107abd1d9ccc8c46f28987af4c01b4e86209931a11628d7c10d9b8bd2efb5a978dad879d77e62f02f9ecd28f965ddff5953b532bc00e7706a777a3199997ce53e60da497f5256a97a26c33f1ba482b1ef98866061259bd966ce0f745a13b9621851b6733ef332c89ea44ef64f847511b7b19660334d885d247c9e85effe32fb6919b25448f7dccf01","data":{"slot":"10871751050674496709","index":"10876708504619516389","beacon_block_root":"0xd5f5eb96854d303c8ec1e04da016af1e2d005cc65528cd5564a33e944b2e2c9f","source":{"epoch":"271217256","root":"0xe4998497469f823da6f463e52231994a8bb175f2d0c5a86dbe84633d1d588c88"},"target":{"epoch":"271602005","root":"0xbe5790970608c4b3bc6e958e7b1f70b07eab77ce633457f96382dcac68961d73"}},"inclusion_delay":"10913063148271469094","proposer_index":"10911410665054784966"},{"aggregation_bits":"0x131a4ccac00427fbefe6048d35bdfa24f946fcae142d7829b5cf75a726a007fad29bb0440b31b832fd323e199623e609879b7d7527e1f7323cc5bdf497b8234da39f7e83a4f3a6f72d7301b90699aa420bc3ee85998c15a9ebc174769eec86f79d1a8bc5735bde3d9b484f0e295da2f98827dd6e2332c9fcad204bca3a581a821b343aa34059fff8c9540b8f76b998a133c1e292ebc711e922f3c5a972a230324d475e2320d316420efad7584281ed7538146ea1437ddcd7edf12e50f7fe5a7063089755cc37e31f7e934413d1f36c2f5333e98b6f452222b102f34687c64404ffb780059bc54d13289c3476a5d83fbf47e1fb7b4b6310826d3d99a185b4d79001","data":{"slot":"10914715631488153222","index":"10906453215404732582","beacon_block_root":"0x7da2559746fc7c64500c9e40bf773db3bdc96d82830bef3e2c8e7f7ff05e47de","source":{"epoch":"270063010","root":"0x576061970665beda6586cfe918661419b0c36f5e167a9dcad18bf8ee3b9dd8c8"},"target":{"epoch":"268908763","root":"0xc9263e97c52afa7725183bee0e9b8fe7d6d569ca5c2e9227e3928da059e22409"}},"inclusion_delay":"10903148244676397030","proposer_index":"10901495761459712902"},{"aggregation_bits":"0x3f18c4c555082cc4b83f6d2dcb898bcb976d0d7b14ce6e6df8fc7af003d2a517f2c0a429536922c610d4ad3b63b7fc6112006240e38cfff5c416aaead37442809eae53e3eb6268458b7efbb482d98e46516216f5cdbb0c9d0fdbab3bba43769643e6a24222b8feaec7c8e2d6e79d794a3fdb59c6f92901e4b3d605a1b564b83dfecbb23abfd839b305686f0e9700a2217febf64df6b6039b0b0ac348386899781b691677f0786b72baea8c84ab674ea587dd43029d977670ade4f1ee0f73c77bedfb6255faf12080a86a48faf85b59dd0f584a10e721f83ab06a2225b3cdb4eadfcf447ea6b7d1db3c8a60e9c7175aeeeed09e456fa3f35ecfdb52532221a80501","data":{"slot":"10838701373455912260","index":"10843658827400931940","beacon_block_root":"0x538b76960436a29db7fcf1b129c74924aa3c482e94d6fce0f8ba84395abf7f75","source":{"epoch":"261213785","root":"0xc5515396c4fbdd3a768e5db61ffcc4f2cf4e429ada8af13d0ac219eb7804ccb5"},"target":{"epoch":"261598534","root":"0x9f0f5f9684641fb18c088f5f78ea9b58c34844766df99fc9afbf925ac4425da0"}},"inclusion_delay":"10827133986644156068","proposer_index":"10825481503427471940"},{"aggregation_bits":"0x6de337bdfdb3eeef6413761eea7227c55440a198f74c7c867d1b46f408ad8aee52ee92e62dafb94b8d0df9477f8c0df5dbac25f558956fcab9a38ae434050b01c0c7fe61f6f8816496dda421898e5895675bcfe108763e5d394beec7513ec1bb6ccb747a5dfe032bde603567b8606615a300c0a08faee4884f434a15c2cd91fc6bca0a764c6ccb44a1aa6f0fc86f2e868fb6a7a1408ca283a9804895ec71dc4cdcc391dddf08c3510cf798e2ec882a8bf081ffcd8c18c976d383da5f9999611686bbc11aec95a8857ee6c709b586c65322d02a1950fb0099dc6c5e53fa57605aaf91d65ef974321dc580e9f8f9998a53007234370790c7dc25c26d48fbceaad701","data":{"slot":"10828786465565872900","index":"10820524049482452260","beacon_block_root":"0x5e5a2496c458d86120a69711bc42695b01673a2a8dd0370f78cb352d4b0b870b","source":{"epoch":"260059538","root":"0x3818309684c119d83620c9ba153140c1f5603c06203fe69a1dc9ae9c974918f6"},"target":{"epoch":"265061274","root":"0x47bcc89645136cd94d534c52964b2aed531256329bdcc1b277aad345697378df"}},"inclusion_delay":"10870098567457812581","proposer_index":"10868446084241128453"},{"aggregation_bits":"0x77f136dca1ea90b94b93b8788e18bb784136ce11f4cbc8f0bfd64ace4ef70d6af1069f053b8ef65e6f8b7fa96e3235a17cde59857b588e282b06ab19dd04599b76dbbab4bb375752e12046f8eaa2c26c62de990956ae2c87821b317ad0197441b12bebc7b30ccd760ff3d8d43091dee6687c6a402b4beb813b0bd2cf4f1bbfe15f07bb7270709cef5bcafc442770e48886add2081904d43f1cb745f782f91571a8b35f56f5cc19c71456077cc86e04f4b6fed11f79f5edba20acf4c124f521418f88af88c59175617ef6b416301931c5f491a165b2833cec5f770fb6379aba0dacefdb29efc618df1642e40a80ca549b51b1efeea72c15d61a9377680dd1b7e201","data":{"slot":"10858531180646056389","index":"10863488630296108773","beacon_block_root":"0x6dfebc9685aa2a6338d91aa93e5d53875f185456086e1327d2ac5ad61e35e7f4","source":{"epoch":"263522278","root":"0xe0c4999644706600f76a86ad3392ce55852a4ec24e220884e5b3ef873c7a3335"},"target":{"epoch":"263907027","root":"0xba82a59604d9a7760de5b7568c80a5bb7824509ee190b60f89b168f787b8c41f"}},"inclusion_delay":"10846963789539332900","proposer_index":"10845311306322648772"},{"aggregation_bits":"0x854ac7d5865a39839b0cf94fc6249f7e427ed075926ada930f6e2c08c615225350068d1f45c8ade65e937d5160494c64e572f70140ce6e19d726c3642a55601ae8da1657e198de5a7c1809ede1fd1cf514e67a9e13f34687d4a3f0d75b44cb30af48705bac49e7eb325b82553f2dc0ba64abd84138843cfcc9dfbc635d9ace26696e0f7c84c84e6c6f495c85de3e632b1e7293e7af20fd493df7892a38e254c429288e32dfe93c73ae05d78ae79929db39e64eb57d9bebd1ca2bf3600e09870ebd845ce553f5f86429763bf77b03daeada11c320d51b45577938aa4a2fa4eeb7dd09e1681eafba688ff16d0362e6c526b09b4dd6ef9e4919daba8972dc3bfaf301","data":{"slot":"10848616272756017028","index":"9518366703504708996","beacon_block_root":"0x2929128423212d61fac071ab276e9e9e3eb62f8fd3a1c1145b6cff9c7e2bfd07","source":{"epoch":"108468471","root":"0x03e71d84e4896ed7103ba354805c750431b0316b671070a0ff69780cc9698ef2"},"target":{"epoch":"107314225","root":"0x75adfa83a34faa74cfcc0e597691f0d257c22bd7adc464fd12710dbee7aeda32"}},"inclusion_delay":"9515061732776373443","proposer_index":"9513409249559689315"},{"aggregation_bits":"0x95547a6b98c39e823657818d059bfa21c610aba5b59b7a12ce5c194bc6faee2b9eea395c64d9021b43ff5fee36e6d3001674e696189822b4a45ec720620fb53fb5f2cb8baddef6f5eec8df4a3c0b8db8583c853a7400ecdbd86f5605186523c1493ef5b6bcf1d3711d863f633ded03aff18bc843a0d7394df20d11a7729b40dab732ad79d074a1b01b2a0c9ec882be2811dfb28dd405947d26285671cf0337fd4f2799d5c295aedce8e5967efc45e79f2da8ace629dddddd4857d80015280abcfbbacb5cd4deae70dfc8ffbc4e39f81e557e5bb9ebb264da3aca1bc16e9288a64d9c705af23a1dc4195890aa50c7e75f5c1c618082b0daa28e679d7a14a391b901","data":{"slot":"9503494345964617251","index":"9508451795614669635","beacon_block_root":"0x9befee83e3e668feba52ddaf1da3196d63c829fb1a56b6716d73944e9c704948","source":{"epoch":"105775229","root":"0x0eb6cb83a3aca49b79e448b413d8943b89da2367600aabce807a2900bab59588"},"target":{"epoch":"106159978","root":"0xe873d7836315e6118f5e7a5d6cc66ba17cd42543f378595a2478a26f05f42673"}},"inclusion_delay":"9544806443561589636","proposer_index":"9543153960344905508"},{"aggregation_bits":"0xd139daf643bec6090b22658d56d416073a57ff8f737cee110be421bac6169130f70d026432629afee3100d2576bcaa5abb7424b58810f1b16ed3981af5805b875c1e110bab5a9d9add9ac4d5aebfaf18497fccd9ae094815df4f14f4dd1571eaf5de9ab2c4f69bfca95a96d790a968fee2d117271eaa50508c68d1ade8db20f6e3ce6f2068e8558e3cf8b860756b3c3dff428e875169f21df772d721d5576d093e720b82892970603949f7fd0cdd6caf3e7e2972201c6dae98b44c569df046712735a97c214dc4c4cf063ec796cfb7e4610b7fc310d25dabd39df2e1afb6fa383caefff8a6eb008a9775a730ba12715079d01d7eef9d2ed3cb0b7787b7bbe4b001","data":{"slot":"9546458926778273764","index":"9538196506399885828","beacon_block_root":"0x449c5884a495b5267c9d9aa23c04a801f3913bb74739d85a355ed53941a16487","source":{"epoch":"110776965","root":"0x1d5a648464fef69c9117cc4b94f27e67e68b3d93dba786e6da5b4ea98cdff571"},"target":{"epoch":"109622718","root":"0x9020418424c4323a51a937508a27fa350c9e37ff215c7b43ec62e35aab2442b2"}},"inclusion_delay":"9534891544261484868","proposer_index":"9533239056749833444"},{"aggregation_bits":"0x5d04ea02ff2a78f6cd8b425826574b42d8094acdb8ac9a86a9313fe443c606d3915f28a3b84ff09b193a0c920dc33e4538ebde138000676d43d1eeb3347b9245bdf722c93a9ac48a26a2c764d43241f30b19a27dee0c954155ef88d46228f91ab2ab7c9d4111b7d13dac8c70aaf9e751af0cb2884985f33a78f5def9ac4e17945597c82019e002c8d5b15c34bef3f4016919b6c13b8bd2f530db8fe86bd11f74b60d6c3887f1dd9d631b1597934c70dedd8f37afcd3e7e0ac467e77de2caf6b7f0e62e639a9ef71509d98244c079dc97fc97b157df30659c9aede65dba052e471534d74cb1e1d5a088195c09df38ed3fef789c65eabd302ad92b18cb2367ca8d01","data":{"slot":"9523324153154761380","index":"9528281607099781060","beacon_block_root":"0xb6623584645bf1c33b2f06a7313923d018a435238dedccb748656aeb5fe6b0c7","source":{"epoch":"101927740","root":"0x8c4b5683229516fda21f5a189b882f41061710cf9eb8da5913926fa5ca46e95e"},"target":{"epoch":"102312489","root":"0x66096283e2fd5773b7998bc1f47606a7f91012ab322789e5b88fe81415857a49"}},"inclusion_delay":"9458877277639309314","proposer_index":"9457224794422625186"},{"aggregation_bits":"0x81c09ae57b0b16050b809f02e41902dac231203597cfe6bc90ad1765bc3b5c327374acc685fdf3c39360ca0bd6154486ab676d36d145431a3310ba86b6a6e76b77cedbd8eb52304b26b50100e2bc594f956cf59727e135a19c84de4782e9cef06e8567011b53e3c62778cdbcd95327a15d100059603645425e19f03a471b13acb0721e93a8f62530d424dea19fad087943046d84ee64a01df9250e94e80ea16dfcde81604512b560bf4cb2a626c9a9587fcb6a46dafb58ca91d6f891b7873d61e3cf853a2eeeee5e4eb7b5c2de9b8b981663ae5cef78f734aef3deeca6ee3e6c24094a0a46d855c82ef3cb9ed473d6a53e81c138222ff1efc0d8827ecdd0aaad01","data":{"slot":"9460529760855993442","index":"9452267344772572802","beacon_block_root":"0x2554278322f210244c37947338cfd3a9382f085f51fe202b819b8be79d4da4b4","source":{"epoch":"100773493","root":"0xff113383e25a529a61b1c51c91bdaa0f2b290a3be56ccfb626990457e88b359f"},"target":{"epoch":"99619247","root":"0x71d80f83a2208e372143312187f225de513b04a72b21c41339a0990806d181df"}},"inclusion_delay":"9448962378339204546","proposer_index":"9447309890827553122"},{"aggregation_bits":"0x29d2333c870ef90be345d869ed7197579d2d1610968a9ec813f15d53aea15ea2dc502c0dd0deb604b7894c21eee5fe52443501c7eda816f1799d865b84bd30b101fa95a82c86ecddb9d88bb20bb0e536ab60032019211531b585c1f912c1b988faedd835b1f1aef3fee16005d307b47302aacb2d7ed3324d2a46e0c05da43515861cafb15c48b4b9da666fcc08e682f7da7ffe7b1ff831878b1391fb0686485c813ebbdf4f642b36a0e8243884bab72f70b2860e8e10549a11e1d4924a613d514efe73b9e8c350ae0e2b84b6da450a064da259388144024126f03f03e728803645c7fd5540ca712eb94d6f24b66003842d8408f302db338f8fc5584c738c97a201","data":{"slot":"9490274471641209635","index":"9495231925586229315","beacon_block_root":"0x34f8bf83e3436325646a170bbae9bdd595e0218bcc9bfc42db7cb0906f77049e","source":{"epoch":"104236234","root":"0xa7be9c83a3099fc223fc820fb01e39a4bbf21bf71250f19fee8345428dbc50de"},"target":{"epoch":"104620982","root":"0x817ca8836372e0383976b4b8090d100aaeec1dd3a6be9f2b9381beb1d8fae1c8"}},"inclusion_delay":"9478707084829453443","proposer_index":"9477054601612769315"},{"aggregation_bits":"0x1129588c24f48861f8480c5fe50933611c2a827e772b2ea2e5010319a743f0da789207bbee7fa92ab9e55e49c99b054795db2d9256ba0609c638e70762ec18715f9ab00a761c27f64cfcd8c86a9779078e586bf21c651729c35d801591fc0c2f0442272c1ab6d766cb5223860ebf880708ff72c8375c8f67d4531e74bd4e449091b61afba57ce40efae7cc2b05e846557be289c101eade9dadd00b28569f0de445b4fa9f4417463114b777764945e1015fe8cbb91e9ada387ea6d3266c1bfb2e2db848e5658f9dab98274937119f8129ccaac12de6defaee0bb2076d33a55c8b6401dd45e71198bc28326abf17acdad98ae6b3c38aa0054b1f848766a836cdc101","data":{"slot":"9480359572341104867","index":"9472097147667749634","beacon_block_root":"0x40c76d83a26699e9cd13bd6a4d65dd0ced0a1487c59537715c8d618460c30b34","source":{"epoch":"103081987","root":"0x1985798362cfda5fe28dee13a653b472e00416635804e6fc018bdaf3ab019d1e"},"target":{"epoch":"95771758","root":"0xef6d9a8221090099497e42850fa3c0e3ce77f00e69cff39eccb7dfad1662d5b5"}},"inclusion_delay":"9415912696825652801","proposer_index":"9414260213608968673"},{"aggregation_bits":"0x3133e223b3bb8d95ffadf2f61b2d03db51c957ad67b926c14abcea188b28cb62d07813cd77583e2cd5c9093a298c9da00100654694d1080886dba14da72280fd12a13f6e3d87695f32f32c012ac70d217769034e88cb04b5e70add6be5923696f292b4aedf5cf7fdf1c11e7ec32e79bfbd4bd072d24f7fbfe876611fb270b20a77599b699dbcd64327fa196ee75254d42e081d9c85be23df8968878f390d043c119e30ced2177c3534e56790bcb6e0d0ab22f53a647350ff1a912015e4870771894dbd7767d46237a6584516fa3116d399e32ab60ef6a2fa0a9a527e0fa8c472037b093fa25e95657d75356af561b0e12a57d1398c78e4a3a512b5b41df38a3601","data":{"slot":"9404345310013896609","index":"9409302759663948993","beacon_block_root":"0x15b08e8261a0be22340411dcb7b4e97dda7dee32d660451327ba663ecb2344cb","source":{"epoch":"94232762","root":"0x88766b822166fabff3957ce0ace9644c0090e89e1c153a703ac1fbefe968900b"},"target":{"epoch":"94617511","root":"0x62347782e1ce3b360910ae8905d83bb2f389ea7ab083e8fbdfbe745f34a721f6"}},"inclusion_delay":"9392777918907173120","proposer_index":"9391125435690488992"},{"aggregation_bits":"0xc1c151bf09610cfbfba456c491c0e74f94085b5a59a926aebf0e14da86e64c9270bea1194db8a305e99559422e1f6cb5cac925562fe298b55bf7cc8340cba0655cc4328024198046e7907ed422943fda225062fc9d8e6ebdb1d248c66c8ba331de9656868599fef8cc7f5ee5df8254ef239d29751b8002c2343b0baf288bc1c7d0384f0f640ea0b41b38e9a1ae2ad67bd7914c727aa2cfadbfb1c9d7a3c6498896348d58fea2ba35826a3e3fe248c47e357c4ad4a42ddddef64221a1c77dc51569428ee671b0ff0223454aaf75ebbdc4fe4249e1396cd815e6ddb30c0b95908f33e52b3dcac6f7f6c0ae846151d925f8c07fe302cc45be25761b6abf82dc8ac401","data":{"slot":"9394430406418824544","index":"9439047470449165186","beacon_block_root":"0xbe5cf882224f0b4bf64ececed51578126a4700ef044467fcf0a4a72970545f0a","source":{"epoch":"99234498","root":"0x971a0483e2b74cc10bc9ff772e044f785d4102cb97b2158894a22099bb92f0f4"},"target":{"epoch":"98080251","root":"0x0ae1e082a17d885ecb5a6b7c2439ca468353fc36dd660ae5a7a9b54ad9d73c35"}},"inclusion_delay":"9435742504015796930","proposer_index":"9434090020799112801"},{"aggregation_bits":"0xdd523952c55833e1046531ab5aa633aa8ec17cc3029d8f5f01d39ce4e44463129b9c2bb09feaaf80a77c9b68128fd461ef965da6028d455bc17ab9ffd15073e21adc537c6d0d5ff0f8afdd6f423c4201744f949b874f6d67aa42e321ef3bf4450055f5816ff7922d0c4bb5f8546a9e18c284e24b6141addf63fe0f71280df7f2f4d49e39b2ccf51f69499ae4f423b86fdec6395a2a3b751d3f15ced28589aebbe0546b63d27209af9c5ff0a4f3b6788161896467d196e98cb6f119b23310f14bc073706460d5abd653c87ff450715e722128c28b1b44a7a460cdaaed4b1b0b947b73b428e15ddd3a572cb1c122cc3895dab6a2dfe6377807795e72ad1c838fd301","data":{"slot":"9424175117204040737","index":"9429132566854093121","beacon_block_root":"0x3023d582e11447e8b5e039d3cb4af3e08f59fa5a4af85b5902ac3cdb8e99ab4a","source":{"epoch":"96541256","root":"0xa3e9b182a1da82857472a5d7c17f6eafb56bf4c690ac50b615b3d18cacdef78a"},"target":{"epoch":"96926004","root":"0x7da7bd826143c4fb8aecd6801a6e4515a865f6a2231bff41b9b04afcf81c8975"}},"inclusion_delay":"9359728241688588672","proposer_index":"9358075758471904544"},{"aggregation_bits":"0x3114060f3454c51e816ee875c86f3b32b4ec5a072fdfb6f9166cd45c6b8538723fb6aee4b36ac6cc05a4199dc9582ca6b402eec549584b2d10424e2ff7892205f1cdab653901a931f9aa3256b87a0b8dcea243a55a82e9ebeb689d1a186ea2af22f8761cb77fef48679bb5842d0cc46c2319119a0cf237b7fa52a1578971c3562199585125322645407c8f51343dc2d5ecd1209d5fd7049e6e731fef0e5132b0e243063fdb316691411b4f51647fa3a1d9c571aeed23f74ee354200c6f5c14fab502ff3590670093373600756e93c95dcbde8fc5391a390816c7135ed698b2ae642c05cd36ad8929f3daa6d83fb5a2444acbdf8720c1d4826151ba09e680eb6f01","data":{"slot":"9361380724905272800","index":"9353118308821852159","beacon_block_root":"0x9f14c7819fab6648c6e8c79fd2e0a3baafe4cc960e09b0cc3ce25dd7cb009f37","source":{"epoch":"89231026","root":"0x79d2d2816014a8bedb62f9482bcf7a20a2dece72a1775e58e0dfd646173f3022"},"target":{"epoch":"88076780","root":"0xeb98af811fdae35b9bf4644d2104f6eec8f0c8dee72b53b5f3e66bf835847c62"}},"inclusion_delay":"9349813338093516607","proposer_index":"9348160854876832479"},{"aggregation_bits":"0x35302c21c1e7c3ff4fc1eba42afc670356e32fe4eddf8372b91baa2acfe58e0253e20c123d652f6ab70c0c723e843abba2a504244bfabdb17c3c7e65726fc37e912151bc3fcdf03323d239d5ce6f3ca2a8c7a5e53aa716d3d9da699a237b4f5347850026115aefa7896ce981ff144ba2dbe6fd354ff9209dc215daa2d78ed40c1503ffdf722cc323c8f6ae65dfc52a2c62a43cd98519063ce1424bbc77e92a8b62f82dff7dad27af1ccbb70d397e0dfeab1455aa1b21a4eb7f172937186eae2566c0febb786e6f6cfbbab4f67875a00a54c0451774baa57f7ea60ffaa78b6e806d9420d222ec1450e23278fd584d9f7ed43d7f852081ab79239107755ad5835701","data":{"slot":"9338245955576727711","index":"9343203400931812799","beacon_block_root":"0x11dba3815f71a2e5857a33a4c8151f89d4f6c60254bda4294ee9f288ea45eb77","source":{"epoch":"92693767","root":"0x217f3c8220c3f4e69dadb63b4a3009b532a8e02ecf5a8041a8ca1732bc6f4b61"},"target":{"epoch":"93078515","root":"0xfb3c4882e02b365db327e8e4a21ee01a25a2e20a62c92ecd4dc890a107aedc4b"}},"inclusion_delay":"9379558048878732800","proposer_index":"9377905565662048672"},{"aggregation_bits":"0xf95fdcef0e3d1b7a3ab27724e9becb89f2e6f06f4239137465e3b4c6eea9d01b36683008f95d568b27a3199ddad54d670a84ce059a038ed4d7f705cfa7c9190ef1fc41bf2b41960c93fb83b850984ae6b506cd7ee0c6d3b98ca86b4b7a2fb864f76f72943ad9ff903fb50a1ff948f35064bc2b4d97205dd07d1a2ee8768c8548e0151ce54ab40325ceb61cdb28ec9c79b43f05d0bd59237d6a0cda50a2853c3b912179dcfe869713cbe796fd6b3686b4f9e2e0b28a414599665019239ad7f2fadc5f345a8f464142e2a63c8fa097dfec011de6e041783c87f3bbcedf02bf394a0ce4be82b51c401c601b4f7bb8598f32b0a3837988089a6837388de081e6b44b01","data":{"slot":"9381210536390384224","index":"9372948111717028992","beacon_block_root":"0xba870d822020ef0d47c5f096e776ad1d64c0d8be82a0c61216d433748f7606b7","source":{"epoch":"91539520","root":"0x93451982e08830845c3f22403f65848357bada9a150f759ebbd1ace3dab497a1"},"target":{"epoch":"90385273","root":"0x060cf681a04e6c211cd18d44359aff517dccd4065bc369fbcdd84195f8f9e3e1"}},"inclusion_delay":"9369643149578628032","proposer_index":"9367990662066976608"},{"aggregation_bits":"0x572a6633cfadeed4eaa53a6d717f3eedab5ce189916f9cb4efadc2fa997a5765333def7439a62bcd86778fd9c9cdc9877cc7df5e419d6c23d0df2087120280dc347e9ce9f13f87d028d7916a8c8cc3573292d5fe5c26c42e81a22934a0f92b4f0682f3868a13dcbb8af8d57c2e9048de9989f9d64af00c981a006c01cb25d0e45c083150c2833b238ec48dc965c94d90434ea02a9aa6ab1f32670c13e8d649c23c576b2a868c1e51b45aa3328ac87122a75b5961f0646dc38d5ec12412e2e2a79ec8f42acc95a1b606ab431561afea4a25ec7ca28f06906518f60de9f8fafdbb8c243b49be40ea6d9703ebf6546be2861c2329176b77bebe3823f07030a5439501","data":{"slot":"9728232162217906473","index":"9733189616162926153","beacon_block_root":"0x765d0d87e9b9c86772c001a1b0f2307a112db06b3bb50b8c1dd3b7ea98fcdd96","source":{"epoch":"131938154","root":"0xe823ea86a97f040532526da5a527ac48373faad7816900e92fda4c9cb7412ad7"},"target":{"epoch":"132322903","root":"0xc2e1f58669e8457b47cc9e4efe1583ae2a39acb314d8ae74d4d7c50b0280bbc1"}},"inclusion_delay":"9716664775406150280","proposer_index":"9715012292189466152"},{"aggregation_bits":"0x25f034a37a9ffb8f5d8a2f1f58f23ae8f3537de7a7a94e5f531da43ea5b478fc8bb3fd1b9642a039d5aeddb1fe733922a36940dbfa9f2daecd734088e56083566a1bb161eac11fedddb5c7f785ca11c476ba31fd886b8e34f7706ad55aa495fa0a690117bcdff56adf5135c573a87580c65252d09059a1e3e45727ab5f88e4a74ba98c0e373569c0a6beafc22c9fca73bb57c0402292424d940ea7d3388d8c7f1b94f30aa8f8bf788997f35cb73f1c1c9862b493b4686b216251d244ba0843e9fcad852299d138f7302b98f7a276455400a41cb3a89e68ca60f5a9977881b262ecf29969408909d28c786accf38f3b5ff669a32c2b474279f54a0263ab0f476301","data":{"slot":"9718317258622834408","index":"9710054838244446472","beacon_block_root":"0x812cbb86a8dcfe2bdc69a700426e50b16957a26734af46ba9de368de8a48e52c","source":{"epoch":"130783908","root":"0x5beac686684540a2f1e3d8a99b5c27175c51a443c71df54542e1e14dd5867617"},"target":{"epoch":"135785643","root":"0x6a8e5f87299792a309175c411d771143ba02be6f42bbd05d9cc206f7a7b0d600"}},"inclusion_delay":"9759629356219806793","proposer_index":"9757976873003122665"},{"aggregation_bits":"0xadcbbc4e04405491106ae932f4f48415ed470366fc6a3668ecd07c4c17047f6c5489f4da7115ff6cb5701ffbc640a042421a6cabda622d7417de2945c4d6a7c51c62f7b8e747914bc2ee6466e427267e28b7ef39b7262ae8cc631e66cab8e188d40dfea21fa592515ac2e87df9fcef504d7ec934baf0e3fdb1192b5571f2d2b8398c7d18e9abba6b10635e07939882373238f46d370af95d241808ac524661486df43595c7686522360724c605490727879eda6c05974f6d087ee41b274704ebd59e68f5d3f5cc57d0bbbeedaf69f0fade67951f1aa49d1bf3e7d0582c4d395bcc2c86164eb1271897da6e3f831fee62a5c478f119f842728e4f90493552523001","data":{"slot":"9748061969408050601","index":"9753019419058102985","beacon_block_root":"0x91d05387692e512df49c2a98c4883addc608bc93af4c22d2f7c48d875c724516","source":{"epoch":"134246648","root":"0x0397308729f48ccab32e969cbabdb5abec1ab6fff500172f0acc22397ab79156"},"target":{"epoch":"134631397","root":"0xdd543c87e95cce40c9a8c74512ac8c11df14b8db886fc5baaec99ba8c5f52241"}},"inclusion_delay":"9736494578301327113","proposer_index":"9734842099379610281"},{"aggregation_bits":"0xb591c7026c7b65faa259f85e7dc280536c4c3d8e5acea48b187738801c8dd005b06fce664f6374e59a294fa3c3be50c3bd7e584afae8fc1dadef4949f1e3a84d4a1f594aff9d2cd295ec1a3bef59b4e44d8eae6b116fac2e521b5c9823e4de28f8a621be8546c39c275a86fea064d22e819d68130b7f5bc0ca9c86f5a35fa37bee2dc1561893c8bca847ed02d8a7811dc3b3f58284b4144d00efc24cf05d24feaedeba7fa99d487302417374ccb7440c384545ce51abf2eae2b9c3a901b9a686ad8243df46d145b2c1b785942ef761e5d1677d9a3cbc658635b0f10664c32987bce20e02a74840ff2eb9e337f4e777bfda8ddae5f1489e790a020f4aec79104701","data":{"slot":"9738147065812978537","index":"9677005161025862023","beacon_block_root":"0xffc1458627c5708d04a5b864cb1eebb6e6938ecf725d764531fbae8399d93803","source":{"epoch":"126936419","root":"0xd97f5186e72db2031a1fea0d240dc21cd98d90ab06cc24d1d5f827f3e517caed"},"target":{"epoch":"125782172","root":"0x4c462e86a7f3eda0d9b0551219423debff9f8a174c80192ee8ffbca4035d162e"}},"inclusion_delay":"9673700190297526471","proposer_index":"9672047707080842343"},{"aggregation_bits":"0xd52b4d3dbaf7a40d418ef27fc28e52b82561d85b5359be03d50e4bc7b1276beca03fda09e69b7f51d706d89165eb4db41e24002dbf87efaee838de4387e8c34137fed53aa45d36ba79e3c8b66c2070f0f5bd565727c893509eea93f1b55b4a9a067a40a84048e8475dee420609c0229c7625d0fbd46782ba5378928caee39187265608ce21178ad771fe78067c7e32388e7ab2ee8e0188bd4667d838ea97a974fe10722e3db62022843463aa2d44dc9ccf0a3bed8f604845ea0e10d4c9193ad93567b477d253bccc736cb475ef5cdc93896a16035546bf004c88247d50cd795d9a8812fca68268523a45a611d24f5907e215b32bc7887524849048b167a86ef401","data":{"slot":"9662132803485770279","index":"9667090257430789959","beacon_block_root":"0x72882286e78aac2ac4362469c15366850ba6883bb9116ba243024435b81e8543","source":{"epoch":"124243176","root":"0xe44eff85a750e8c783c88f6db688e15331b882a7ffc55fff5609d9e6d663d183"},"target":{"epoch":"124627925","root":"0xbe0c0b8667b9293e9942c1160f77b8b924b2848392340e8bfa06525621a2626e"}},"inclusion_delay":"9703444901082742664","proposer_index":"9701792422161025832"},{"aggregation_bits":"0xd106ddd3711bec162cb9adfd21ec7c9e096456d2b2bcaa24a93454a61febd875fd67cd8230a306bc75c98e3406901cb8e324ab882f7f0c83943101e31361693df792c739a3cbd6c5dbb352f97293261ce4f63ff2fc673f169b089d143acc96bb21f4271c67aecaf0ec1ee9a97dd24254e07614fb0c1b9eb1af5d5bd593f2c1ab7bc49ed0990b6e4d7720ec38aab1b469f8e18d66b4629fbdfd27585cdd4ab3dc9cad2000a810be9ee198475edfc0cf7dd5fd1e7d1c25e87e31af604e6d903304494afa9525c6866be107ff9e3fab873da872b26440c6047ac192115cf1e90b85abbd0cf6f24376148ce99183018bfd8d80d9984d7b15e447ca70d7acfc296d2c01","data":{"slot":"9705097384299426792","index":"9696834968216006152","beacon_block_root":"0x1a358c86a839f9528581e15bdfb4f4199b6f9af7e6f48c8b0ced84205d4fa082","source":{"epoch":"129244912","root":"0xf4f2978668a23ac99bfb120538a3cb7f8e699cd37a633b17b0eafd8fa88d316d"},"target":{"epoch":"128090665","root":"0x66b97486286876665a8d7e092ed8464eb47b963fc0173074c3f19241c6d27dad"}},"inclusion_delay":"9693529997487670600","proposer_index":"9691877514270986472"},{"aggregation_bits":"0x7d5af774448e5a7be614052ac37da18bfaa35b317e38bcd782730ff97f8b4fddd377f36dbe9ce89acda39a93706e8cf5c0bb71d8a75fbe5f2e2dd5a1d352c75f1fdafd7c340941e7132b59ba3662989ba699d9b2be41f2c6318c48b44716b8cc64b5c117c1ebca9730f975cc4a848d322112a8118f466cdfddb016f0540cded947d641962d1b2bab97cda9cc200a7c1d369e972aa3addddd521a4587004283fd121a62812cd2533f0ba8b4545441cb89a66d3ab07b0bdbdb6fee4b795eabc4d3871869084d7bf91da9786b89251d0c2e37e378704de2784eafcb4df6a57fd7b8ca10e0ef614ba17c38856aa6c5b1c5fb467ecae85f058b295bd8ea82607c735501","data":{"slot":"9681962614970881704","index":"9686920060325966792","beacon_block_root":"0x8dfb688668ff34f045134d60d5e96fe8c08194632ca981e81ef419d27b94ecc2","source":{"epoch":"120395687","root":"0x62e4898526395a29ac03a1d13f397c59aef46e0f3d748f8ae9201f8ce5f4245a"},"target":{"epoch":"120780436","root":"0x3ca29585e6a19b9fc17dd27a982753bfa1ee70ebd1e23d168e1e98fb3133b644"}},"inclusion_delay":"9617515739455429638","proposer_index":"9615863256238745510"},{"aggregation_bits":"0x9525ada1708c2c84f555dc645180a212c10e05f7559f26089fff677fc92215b5cde9b7310025af9243f84b6aa1b9f632b615c30e76029c296ff7a761f04e0331d44a45d1f0d1d50702bef7e5d384500708fc43b8f5a946ebd8de01a3e417b9a59890d2ae197bd1fa4b30bcd8aebe0dcccf9f0ad1a096f3056c1d36069d2742c582320a9618ac4ef51eeecaba0157804d04878eeb3e21acd78b7cc4e08e933fa40d4dfa9d363b689e57d50a71f5cc12cb0869ab71e686fc0633cf10c143f60f40ac78d11803d8d4da6e3a540f1ffe3bf15c1733fb6f38aee2c8c5ef0519bd2fd36b55d80c32da315e9a7c9d041ad94fe18283a79527a24f3040ff322590dfd2eb01","data":{"slot":"9619168222672113766","index":"9610905802293725830","beacon_block_root":"0xfbec5a8526965450561bdb2cdc7f20c2e00c679ff0b9d55b582a3bceb8fbdfaf","source":{"epoch":"119241441","root":"0xd5aa6685e6fe95c66b950cd6356ef727d306697b842884e7fc27b43d043a719a"},"target":{"epoch":"118087194","root":"0x48714385a6c4d1632a2778da2ba372f6f91863e7cadc78440f2f49ef227fbdda"}},"inclusion_delay":"9607600831565390278","proposer_index":"9605948348348706150"},{"aggregation_bits":"0x0fed244d2ab3dbd6909c1049bac27ddfdb8f336e565a0b792931674f52ec5ba51cebe3d80e548ad72264c94cdd086ce69d75ef7e0ae749cff57ad70d71fd46aba257020f2d77aab91d71157ceaa80cfe06f1d9492b4d46b2f3c61d38752f585b2de145b97b0ddfefbb251de1254eb70b203df0d18a27bc8899723ad902b1fcc8943f9b00a4231c5eb4b63be3d6195beb8df4ef1c97b9106f2bca59962214dc95712db0f43c5fa720e811c5ea40ae04dc0b1385832025d04afafaa8deb61b0935a0f91aca2cbc0316aaaa63519b63f83f03e6b497af901a9643ff9cec5877758ba5cacf531c40179989b6ddbf20c991c9b2adc8483750db1b9b3aaa252682879f01","data":{"slot":"9648912933457329959","index":"9653870383107382343","beacon_block_root":"0x0b91f385e7e7a6516d4e5ec45e9a0aee3dbe80cb6b57b173b20b60778b254099","source":{"epoch":"122704181","root":"0x7d57d085a7ade2ee2de0c9c853cf85bc63d07a37b10ba6d0c412f528a96a8cd9"},"target":{"epoch":"123088930","root":"0x5715dc8567162465425afb71acbd5c2256ca7c13457a545c69106e98f4a81dc4"}},"inclusion_delay":"9637345542350606470","proposer_index":"9635693063428889638"},{"aggregation_bits":"0x7d5657d98f41f6e80ba3532f321799ab9684878990dbb8969e931591572ffcc5fe2dc8df68a6197b2d3c897ed2b2bde3088bfafb75d5dd78ac62be8384cc2d3bfc36efbf228137b8ca5b432da19d962d73d9b85d6c086c29257e17d5ae76e3ffd34f9682ace8e22a83998e627fb2a873bc48715453aca990e3e5f779661c8bdf029e074e559fef81901719f29337ce605c41aaa2918fea9d8d02957f16079529f0e72134330e9983dc069584aed402f3bc0a386c00637f68b60d3beef662cb52ff672d69bcd89373b8a628fa94fb33a0b4de1c879abae3f72db83890455ba17697046e4ff749bd2a328d5d3685254654aee3325ef7e8ab5c1633753df32dd44d01","data":{"slot":"9638998029862257895","index":"9630735609483869958","beacon_block_root":"0x1660a185a60add15d7f70324f0152a2595e872c76451eca1321c116b7c71472f","source":{"epoch":"121549934","root":"0xf01dad8566731e8cec7135cd4904018b88e274a3f7bf9a2dd7198adac7afd819"},"target":{"epoch":"114239705","root":"0xc606ce8425ad43c55362893eb3530dfc76554f4f088ba8cfa2468f94321011b1"}},"inclusion_delay":"9574551154346805829","proposer_index":"9572898671130121701"},{"aggregation_bits":"0x67cec3ff12043fc699700044ee3da94073ad6240a16927d4f1c6d086b205062de8f59c3ab89a22fc40509e4373a53714c950a75e13baf7ab683cb883dec3e457b18fe0d77734a528a67eb3e4e6fa6239ca69b4611a877b17e945d48f0ac1574502b321166c24e0f18c094b8afc7177d13ff4f9fba4afd15a7333230068705976e7dd8edc285e24a04d2a0d7270aeff8e21a3ae5f3bb86b5fa1b9c1ca5c8c3831a0897d64b034f3305a748e7b6fab9b435083046dda90d5e7ba9a98511ce576494792eac92a56412c0ed5205bd7768656f4c577199026296c3c946bc771f371cd342c7a21deb342fb24a811d10fa93ca4b6f7b710dbf84a6130c56afd4de893da01","data":{"slot":"9562983767535049637","index":"9567941221480069317","beacon_block_root":"0xec48c2846544024f3ee857955a653696825b4d73751cfa43fe481625e6d17fc6","source":{"epoch":"112700709","root":"0x5e0f9f84240a3eecfd79c399509ab164a86d47dfbbd0eea01050abd60517cc06"},"target":{"epoch":"113085458","root":"0x38cdaa84e5727f6212f4f442a98888ca9b6749bb4f3f9d2cb54d244650555df1"}},"inclusion_delay":"9551416380723293444","proposer_index":"9549763897506609316"},{"aggregation_bits":"0xc5b422efb39626fc202f0136e61985efe6a27c64abe9b4bf045ca7c6392209454a77a848ce7cbf56390dce2877f3c61117b8b26b28ad37879304d9dda7e2c1d7cfea6515399a1e2e5159e4b9f58cf6aa8751d813cdc0119d77bf9d62e195e8e12c88fb08436599a4a5bb290921cd7f8d60232bbe3d20ac2701aec2a690d828a9537a759ad57ed373f1c12d7129d17e05e032ebbc2a02c8059774029a8c57d5017229a6038f050683fe9bda6d26557f6d4abe09cb9a9478025558cdeb1f2df2707d95d1a594daa9e149d9bb7694a61d79a1169c7ab51cd9cd90fa97a1b9cb213055ead833977ae9681513d0dbef61b134fdf135ac7b4d7422b66890c49552df9a01","data":{"slot":"9553068868234944868","index":"9597685932265285509","beacon_block_root":"0x94f52b8525f34e77ff32158879c6c42a12255f2fa3ff1b2dc63357108b029b05","source":{"epoch":"117702445","root":"0x6eb33785e65b90ed15ad4631d2b49b90051f610b366ecab86a31d07fd7402cf0"},"target":{"epoch":"116548198","root":"0xe0791485a521cc8ad43eb235c8e9165f2b315b777c22bf157d386531f5857830"}},"inclusion_delay":"9594380961536949957","proposer_index":"9592728478320265829"},{"aggregation_bits":"0xcdaf38176dfd89ac60eecf19cd3b197335f66b19e42dcdca8a92a8f81f392a159f65a4965039f211739508436a334af5f7c6969d55c0b2608da9a1008bf04f0c31db0dcd651cd295ce044a980c848a51d95e2ff6932318854ea123d9e8871d9fda5c603fe18ee615443adcd43bb5d47f4d13c1763391b92dd5cfc654d7670eaae755a78e629685c02399de286ede24337945da39d71e2d1935c225f5e09c223a06cb418931418475d0ae75f324a3c97200e02710ff63545c3f4ab16e3161804254ac7536b5760448f3499cb999b5eeeb7a441b3cc1a4ac3b17c38240c445db6864648fea1172a92d26e1856a8c659640d49766d15bbfb60067adcb644b8cc0fe01","data":{"slot":"9582813574725193765","index":"9587771024375246149","beacon_block_root":"0x07bc0885e5b88a14bfc4808c6ffb3ff93737599be9b3108ad83aecc1aa47e745","source":{"epoch":"115009203","root":"0x7982e584a57ec6b17e56ec906530bbc75d4953072f6805e7eb418173c88c3386"},"target":{"epoch":"115393952","root":"0x5340f18465e7072894d01d3abd1e922d504355e3c2d6b3728f3ffae213cbc470"}},"inclusion_delay":"9941402591659439502","proposer_index":"9939750104147788078"},{"aggregation_bits":"0xb76fa8b5cdfc539ed13b96fdb0d6b5b5be1fb74aa35597b97248cf963a70d0b306846b33c9dabfed0070cd4921f2916cdbde6503927f42363d73077f558df6108794c4423ebbef8e5bbb4ce465ef7c5d5854383cae41c160abeefac460b0af6c4fcf91274c28f2badc0bd79e106ddef1a7403747ee2fa1743d7b560c6434658aaf62a5a747b2e91123740edc02c6b94de99912d53588248d245325ff1358b25ab0c4a16d62682ff7f7a0ce1ac1324b22663d47767ec1db27bd494078ff913bb6b9550f8731859333ed0b045a8d6c477e803866e74ee6945f1bed9986eefa077db44a6223acc5cf7862ea66fcb7e29d0e1ceda9fbd0baf1e5f71f7fedbd1a1b3e01","data":{"slot":"9943055074876123630","index":"9934792654497735694","beacon_block_root":"0x5c9ad989aeaf5e9594d7cbf1d5bd67be17bc28d8550e9cd44d438c7a86d4797b","source":{"epoch":"156946833","root":"0x3558e5896e18a00baa51fd9a2eac3e240ab62ab4e87c4a60f14005ead1120b66"},"target":{"epoch":"155792586","root":"0xa81ec2892ededba869e3689f23e1b9f230c824202e313fbd04489a9bf05757a6"}},"inclusion_delay":"9931487688064367438","proposer_index":"9929835204847683310"},{"aggregation_bits":"0x71009253786a41ff13fe072e5245fc469d23a8b82097922b2c76d9c048a047b2e8f661d44fec1483f3dad8e7cfee213070b92dc0586d90abdb6d765dc4ed77756e58f4b3edfc3a1ca2274745997ebaba9a22d64487442cd8047c4c64790411890a92663ce489f8e721eccb6f270b743fdaf58ae838e0521acdb60f998ca77f4489f71f273259ae374b3d6dbccda56070722d1e994253442deb7a51766e5482469c79ea56c4b88e728ada227ecaa23dc630bd603f81db6a823b586a1b84b34b71765f861ac9dca4fd29f4bc42d36cba4d1da5fe618ba06868828d8d26bfedfb0583e3c4b9efc792004a809ddd6693a0edc85dca0cf0ea0e18e51d4039214737d201","data":{"slot":"9919920296957643949","index":"9924877750902663630","beacon_block_root":"0xce60b6896d759a32536937f6cbf2e28c3cce22449bc290315f4a212ca519c6bb","source":{"epoch":"160409573","root":"0xde044f8a2fc7ec336b9cba8d4c0dcdb89a7f3c7016606c49b92b46d5774326a5"},"target":{"epoch":"160794322","root":"0xb7c25a8aef2f2eaa8116ec36a5fba31e8e793e4ca9ce1ad55e29bf44c281b78f"}},"inclusion_delay":"9961232398849583630","proposer_index":"9959579915632899502"},{"aggregation_bits":"0x4d0f72cdb307a5fc3ea909b0b107048c790075266ed000257096f7b8254f7cab0538540e8b5c6d5037155d1b0e75d86cd48bcee380a9b327fbe60ead11c79d098fb86438aa39f95331735f0a0fccfa1d2722abeb754d01b6028ea0878a70cf729d18918eb9aac05a903020d5932ce97573a64fa7e8296b1733d2fa509fe32a34dde7cc5f0ab86a7d2da5cd00749ef66d3af32794d815736d322d41e2cddc1cd27524e9c2671c94cf5d7b01b61a22f833325ec42b9a2acb9422b95acf00364ebcee2866b836edc8d2389bff7941c64df32fb10a134b44d3811d90e406340d9d8be05a4c31fb14837a60bbaa5da627107ab8c9fa78103f7f61a9661fd6da7608ca01","data":{"slot":"9962884882066267758","index":"9954622461687879822","beacon_block_root":"0x760d208a2e24e75a15b4f4e8e9537121cc973400c9a5b21a283562174a4ae1fa","source":{"epoch":"159255326","root":"0x50cb2b8aee8c28d12b2e269242424887bf9136dc5c1461a6cc32db86958872e5"},"target":{"epoch":"158101080","root":"0xc391088aae52646eeabf91963877c355e5a33048a2c85503df397038b3cdbe25"}},"inclusion_delay":"9951317490959544270","proposer_index":"9949665012037827438"},{"aggregation_bits":"0x4797c2e76408c81b9d7e539d8a6604673867807756a716e59d1570e245c70e6325ea40707765f3865efd8a78aee14372e4930075e6c62130383031b57421f506d3510251f9aef3a33f7e0b9745940e6bbf534717096ab3aac5601f981f47419ad2cc6698186be585dab0240958ed469f1f1fd34f0e10935dab56072890f71dbd0a0e25e573719904e0f8d901d337cf8e4cc960697281cf1f12b6c764c346f54b0d482191f5a772adf9290bc85ad5d2b3d4c5fa0ec4d1f1122d1c88aca8925287509f3708301b064d2e46a2d860c27a856d9af10d81d09db12eb8345406c45d42c331c90e0aceaefb64deef6886e27e4a80a9fe3614ff0cb9b3d4023d75bb7b3901","data":{"slot":"9886870619739059501","index":"9891828073684079181","beacon_block_root":"0x4cf64089ed5d0c947ca4485a53a37d92b90a0facda70c0bcf36167d1b4aa1992","source":{"epoch":"150406102","root":"0xbfbc1d89ac2348313c36b45e49d8f860df1c09182025b5190569fc82d2ef65d2"},"target":{"epoch":"150790850","root":"0x997a29896d8c89a751b0e507a2c6cfc6d2160bf4b39363a5aa6675f21e2ef7bc"}},"inclusion_delay":"9875303232927303308","proposer_index":"9873650749710619180"},{"aggregation_bits":"0x35ad23ff9b32c974264159af834b9061b166ee1965338e4268cbd4225264a12985087eee1992ad6a53074a00a99cb3b69bb9a6e0ddd0f09c0400597bb260b5dd8d34e6d3e3f0dca38a5cd99047cb98d85f6bae98cca7f836131a4e34fc1af6a9fc70b4a9962fdb60a71850a880555feb44ed52c8c6912645d1c3ef91e1272d6adc2a99bb83474883cc6bff82ba4846258cd4218ba123620524528d96591910b6cf81f8f1dbb630cec7264a8e302ea78c6ecae584209dceb1fadbaa082e6876c82ad2c87a3a5fce69988a7f38239af1ab5898d91cb4fa615a43d208234ec989dff2b77a4f3887cf0cdda5a663604aa787eec307a21cc2a85d21fadf2ca814365d01","data":{"slot":"9876955716143987436","index":"9868693295765599500","beacon_block_root":"0x58c5ee88ac804258e54deeb9e61e9dc9113501a8d36afbea747218c5a5f62028","source":{"epoch":"149251855","root":"0x3183fa886ce983cefbc71f633f0d742f042f038466d9a97618709134f134b212"},"target":{"epoch":"154253591","root":"0x412793892d3bd6cf13fba2fac0275e5b62e01cb0e176858e7251b6ddc35e12fc"}},"inclusion_delay":"9918267813740959821","proposer_index":"9916615334819242989"},{"aggregation_bits":"0xabfc1b0377ef367ee6a5b4c02b693edcca6d01bd3e26b079e203485c6a69e71f6e207b05bbc3e32e30b088aab76c06e29a6ed091ed3db043dead3e07227ff61ff350b00fe9f4801cd525d29baff7ce22873fd872826e59a02800c18a6d2603500189632ffcb9c55517cb97918b21f168c9d8ea94bc00494805bceb5e2aa00bc7b8c8488f3dc9182a9e130acb0d630023378f552fdc2fb99986c586f937d7fdc19a601a5e71528bb8ded7a45091dcb4b76ca64b572336e2a52ae4c01bdb24b48e83c13bfc1f3bd7bdf05a5f208e0e1275872b58b0f0d285cecdeb69e73503e2a5bb393d941f1d665fe2177d8381157a2facc9ab7facb0e835ccbc87047245295501","data":{"slot":"9906700426929203629","index":"9911657880874223309","beacon_block_root":"0x676987896dd29459fd807151683987f56ee61ad44e08d702ce533d6e78208111","source":{"epoch":"152714595","root":"0xda2f64892d98d0f6bd12dd555d6e02c494f8144094bccb5fe05ad21f9665cd51"},"target":{"epoch":"153099344","root":"0xb3ed6f89ed00126dd28c0effb65cd92987f2161c272b7aeb85584b8fe1a35e3c"}},"inclusion_delay":"9895133040117447437","proposer_index":"9893480556900763309"},{"aggregation_bits":"0xdd6cf833c4d9ff31ddc1a6fa02dc28536f6c1cf3b006a48e03b7269ced08090aceec5306c52178264de0d850b817f277754e97145c87304dc3195489850ede878d308febe3562b3e604714cecce2dcb1e80735444723d3a81ef89866c63bfebf2fa7b00463acfc80676be70a1559fb91938a628a7d9fee317d6908ec5a5a6a16bdadf0a1c859ebd3c2986808165d0824be1204c54cb700cd202d0c2987dcb87f1aeb895cda02d7986cd8d1369f22b19d43bc46f9c7de7d324103cbb5d9e890eab0890425a57f8f88675a01c9ebd2d15aa22330118648740cc1bfd18a993e3d38abff691cf38445485b6476a8231febf346a3584cf4c950fa56b5fd37adf329ab01","data":{"slot":"9896785523334131565","index":"9835643618547015051","beacon_block_root":"0xd65a79882b69b4b90e89ff1d6fcf37cf8e71ed0f11192b76078a5e6ab58774fe","source":{"epoch":"145404366","root":"0xaf188588ebd1f52f240331c7c7bd0e35816befeba587d901ab87d7d900c605e9"},"target":{"epoch":"144250119","root":"0x22df6188ab9731cde3949ccbbdf28903a77de957eb3bce5ebe8e6c8b1e0b5229"}},"inclusion_delay":"9832338652113646795","proposer_index":"9830686168896962667"},{"aggregation_bits":"0xe35648291310d664aa54ac4f7df5b1bc03cfd8809085be1e6af672db096222d1e20547af294de300048e0b3099c3ef00c7748a10b8e8b29e13cb07994148d66380511207b8e4a99e7e0a564383b4b831b474e0703387e0947b914b1992de0c4ef453d704c224dc5b30ebe2f2d28b2cf6b432f26a10ac04f9e7ed7e95756468c97954187bb5fd08107fe52c48e3a5b104cbf911085672a3834cb6125f888e11854ac0418c5ebb5da0dc8febd9a2593b0db0325aba9115e7852384b89e716a0eb004b0f0952311591551e54528ea426c88e00edfac4f64be14f29585908e97e7e1fdc7a9e3dfea1e0dca89381f6954d5c3fe335636f001b711406032f43837764e01","data":{"slot":"9820771261006923307","index":"9825728714951942987","beacon_block_root":"0x48215688eb2ef056cd1a6b226404b39db383e77b58cd1fd31a91f31bd3ccc03e","source":{"epoch":"142711124","root":"0xbbe73288abf42bf48dacd6265a392e6cd995e1e79e8114302c9888cdf1110d7f"},"target":{"epoch":"143095872","root":"0x95a53e886b5d6d6aa22608d0b32705d2cc8fe3c331f0c2bbd195013d3d509e69"}},"inclusion_delay":"9862083362898862988","proposer_index":"9860430879682178860"},{"aggregation_bits":"0xeffbe88dd8bffeffdb53facbec77d4766fc84524d4632270367666bd60a711c003fa4ebffd791aefa0739bcf5d3f960c6b6c4bb26c30d3f998266025b4c01c4733bd0084ae684aa1ee5e4c041100fad45977819f486e4dde7de3cb7836f2ff69d7a990b29d06e5ee84171c4d6ebd08305ae83ee248f930571b890ad44be01ae76c049ae70571cc2219f19874384c2672856068056c4287f99dff1239b9caa71529bd5abb5337130c8b7bc08959d5f44ea655dfe3bad242b6f205a08a53e901619fddb49fc0a2b9b3418b14537eec5396f6167bdfce320fb465e020b64433903bccb827140bed4b037c3647196bc147c59e6dde811cbd5b4404d72d71e1265c4001","data":{"slot":"9863735846115547116","index":"9855473425737159180","beacon_block_root":"0xf0cdbf88acdd3c7f8f65281583654132434df93785b041bce27b340778fddb7d","source":{"epoch":"147712859","root":"0xca8bcb886c467ef5a5df59bedc5318983647fb13191ff0478679ad76c43b6d68"},"target":{"epoch":"146558613","root":"0x3d52a8882c0cba926471c5c2d28893665c59f57f5fd3e4a499804228e280b9a8"}},"inclusion_delay":"9852168455008823628","proposer_index":"9850515976087106796"},{"aggregation_bits":"0x69bfd02d24716c1511cd7b1a1ce40b05cdd77aefd56165d379a20861863f8a9ceda17c5e73dcf5c853411be0e2568651d94bb3e03010434df65a404a9db2b930e854fb4d2c9e1ba91402df8fe9d9d59b0b006b9da829a68676735d58a8de06ddb2b0c6a133b3e98b707010a8354f8bdee3f583edcfb6cc7ceb411d438f1d2934d8d03543dd798944791ebdc2e5f4fe2b9b377449e16ce549d8cb6ae2645e0f00e783196bdfcf8c2366597481845078194555e9e775f25703cc5403211efbf1fa594b7c20ac718ae1857599c225482ca16a87b7fb03c6b3c38dc07c0b11286486ad071aa91527d66b6c78bc3c2e3959b652d74dc108ed04be0e3717ed7d62203001","data":{"slot":"9840601068197067435","index":"9845558522142087116","beacon_block_root":"0x63949c886ca3781c4ff79319799abc00685ff3a3cb643619f482c9b8974228be","source":{"epoch":"138863635","root":"0x397dbd872add9d55b5e7e78ae3e9c87156d2cd4fdc2f44bbc0afce7201a36055"},"target":{"epoch":"139248383","root":"0x133bc987ea45dfcbcb6119343bd89fd749cccf2b709ef24664ad47e24ce1f13f"}},"inclusion_delay":"9776154196976582666","proposer_index":"9774501713759898538"},{"aggregation_bits":"0x971abdb6c8690aeba68fa0d49f9c0999e7ee340ab71f0a196e0e787215ce9dc8ef0b78714b76b2c1c641dcd5fa907e966c450457c14d799b85411f3b174f741b626592667c62cdf11557ea9b1d0fb807a5bd98d3e1c4216a3c7985eb4b89527449dc6d34fb839ee482f34b24528045b6016c236ce647dcb0c1e8bf0de664bd981d21ad2add4dee92703baf76848a01912922a58ad49284c383ac0bafae028339991dd53ecd0ce61c3b248b1930d9a179e1c1fe2e40354197884d5c89dba63a1e7827b275d41053a3c2bb87d33ab03b6e8513fa71518c236ffbcac5b96fd3c50d9852b34b6a32074980818fa7a85cf36c9fae3518190a8432150ced6983444b1601","data":{"slot":"9777806680193266794","index":"9769544259814878858","beacon_block_root":"0xd2858e872a3a987c5fff21e680306dda88eac5df8f758a8c2eb9eab4d4a91bab","source":{"epoch":"137709388","root":"0xab439a87eaa2d9f27579538fd81e44407be4c7bb23e43818d2b663241fe8ac95"},"target":{"epoch":"136555141","root":"0x1e0a7787aa681590340bbf93ce53bf0ea1f6c12769982d75e5bdf8d53e2df9d5"}},"inclusion_delay":"9766239293381510602","proposer_index":"9764586810164826474"},{"aggregation_bits":"0x1f9801db9817e13def4f47bb17dad724fab273b3a111e96cf243f35523b5925c227370bec504c685e6f75e7fa334c653852173672980b0fd9dec4ec6bb5c7b911659c4be31ec13960a188b80bc3b85febb706e77ff0131f217adaa14d0373f8bdfaaf2135955e1d1c32c3e9e5eb1992ca283da42cdc60babaca39ad3fa238f85096b0e1511c13f31be4b5fb763e3db95a15508ff419f4e7b010bb6d1cac95084c5ad9b04d77058aa84c045a59327fe4efab970d434de7d837a52211e2ceaf858f106cd62d9382c488a26e21c3606ccb05290713c33f4531e75bbac5544376e24b2d8747869a86a86ea6bca001a413d019e21ef45a07044185169f7aa7c915cfb01","data":{"slot":"9807551390978482987","index":"9812508844923502667","beacon_block_root":"0xe1292788eb8bea7d7732a57d014b5706e59bdf0b0a1366a4889a0f5ea6d37b94","source":{"epoch":"141172128","root":"0x54f00388aa51261b37c41082f77fd2d40baed97750c75a019aa1a40fc518c8d4"},"target":{"epoch":"141556877","root":"0x2dae0f886bba67914c3e422b506ea93afea7db53e435098d3f9f1d7f105759bf"}},"inclusion_delay":"9795984004166726794","proposer_index":"9794331520950042666"},{"aggregation_bits":"0x6d6b6293ee8cf4ae6f3a33991fe6f3aba1b0aeb35215f9972551258daaf2b501847561c4a3600521f1a40e87a34d3e5762db14c390cb204260d537f8483f5f00683169062b02f8c4fd5345d1776c5f65d64906347bc01bea4115dfb809c882eeb31b211c4711f834c68cfe1ec14da258ffc75bcd574734d757a039511c19fa061ccea67be1e54df6dec82dbc1cdb503841ce0954790de32927ff7c16720219b0467e0acfd869159fb1dc1c13fdd9b96065827d73e457f2b015d533b61a10fc3741347e1a5b74e2c51c2bd933f556575f3f921008006caa2138df993ad80c1848ca1e047ba3e3cd65d241432cafe9e81870cb64f5e14148fb02408db0a423182901","data":{"slot":"9797636487383410922","index":"9789374067005022986","beacon_block_root":"0xecf8d487aaae2042e0db4add94c6763d3dc6d107030da1d208abc051981f832a","source":{"epoch":"140017881","root":"0xc6b6e0876a1762b8f6557c86edb44da330c0d3e3967b4f5eada839c1e35d1415"},"target":{"epoch":"181955511","root":"0x828ce08c33b13b1222518d90b630d1ffde2cab904f9094d7b3a7bd37ece3ebf4"}},"inclusion_delay":"10156225504317656659","proposer_index":"10154573016806005235"},{"aggregation_bits":"0xc33f6d0d299421808d4ff6c4968d3615f8076b156cc3968d04b7c2fe7f208abf0580b9adc2b2b2d74482c29380049a96cb1c2dd84104dea5c74fb9bb74c1c33ac7deb1e030ecfb1dc46acf4629fbd463fa8d9274277085bf5820a00ff31e1b962ea4c04697777f5326da095457174ddc28fdc91468b6679535ba7630a021fe2ae88cde6e2ed287f48e7fec8b645c8bd4a29fc41f5fe2254cff99de5351c5f97a670899f91aa978fccef40f38d72763fa966521f90bf1937ee653f86f062c0b0e53f5ba6e0bb498a4d0d680eb1cfe90597f618d3a5e92004be0bfdb0f7bb98008da5a9b8f009f608d245be6f3619e93acc26bca10071fee05f351f8211764afe501","data":{"slot":"10144658117505900467","index":"10149615567155952851","beacon_block_root":"0xa9ced48c7348fa9b0cd75be75d42fa99eb32a9b4bc21e64b0faa44c8a1a55a0a","source":{"epoch":"180416516","root":"0x1b95b18c330e3639cb68c7eb537775681045a32002d6daa821b1d979bfeaa64a"},"target":{"epoch":"180801265","root":"0xf552bd8cf37677afe1e2f894ac654cce043fa5fc95448934c6ae52e90b293835"}},"inclusion_delay":"10133090726399176979","proposer_index":"10131438247477460147"},{"aggregation_bits":"0x91948c518a76e0fcd86363ae1ff0030ba864fff922e1b4f2b3bbf434eaef81c6ffcea4bfbc54f07771db93eb8ffb4b821dbc9a9df2820b98365fd13505e247e8bdb318922a24530451481c17229f46d0ddb5ea83653fe7b72ad8f3a23843ae7a5098127f101206c6137adbc56aaf7008a42d48733a39d2ec4bcd3514e9bd8ee17fad2b5097e87403b6ce9eca3bba447f7a66c5b0e9dd8a94cd4d1093edcebcc6648a101134bc1ed579e55f4e81d806c4897e3f52ab7e8c6b0fc4cac703c3cf6041c3c96615901350c7da23491527176eca594d0968087ca8add17f78a1a554f3fa042f897d57bf3abf20277bc5360e7174004ca08f2e91eb32704727efcaef5701","data":{"slot":"10134743209615861107","index":"10179360282236136340","beacon_block_root":"0x517b3e8d34f746c4ce2119da7ca3882e7afcba70ea040835d79485b346d67549","source":{"epoch":"185418251","root":"0x2b394a8df45f883ae39b4a83d5915f946ef6bc4c7d73b6c07b92fe2291140734"},"target":{"epoch":"184264005","root":"0x9dff268db425c4d7a32db687cac6da629308b7b8c327ab1d8e9993d4b0595374"}},"inclusion_delay":"10176055311507800788","proposer_index":"10174402828291116660"},{"aggregation_bits":"0x0bd49435f67d9fec3587a18193b286b6be09c85929e61c821dfefb03f10ee2d226f4a0508a32a472737f54d1b709d376a5cbb56dc04f9776a0d8c0582030f023ce8a58cba0248d222e03b6aa43f291c941aa1d233f74e62d11c68e1fb9f91b104d69856862f54bf77be87ebfc0d9aae24702b30d50048de2ba22b04f7ea2a9744340df620246209840966fa1b40dc66ff2c9f87b38447b08ebea9fec8b0540f3b27ac69e89dc85ef4424e0b0166ee9fbbb0a1184ed9180356bf7f390b7aee5264cfe37b11694cd8c07465e57b07ec0a891a8e2476230033c37e80699e66a5eed825a28dd5b4caa69a48a46c0862b8b4a648193f9cf901283ed375f09109ee8d301","data":{"slot":"10164487924696044595","index":"10169445374346096980","beacon_block_root":"0xc3411b8df4bc82618db384de72d803fda00eb5dc30b9fc91e99b1a65651bc289","source":{"epoch":"182725009","root":"0x3608f88cb382befe4d45f0e2670d7fcbc520af48766df1eefca2af1683600eca"},"target":{"epoch":"183109758","root":"0x10c6038d73ebff7462bf218cc0fb5531b91ab12409dc9f7aa1a02886ce9e9fb4"}},"inclusion_delay":"10100041049180592530","proposer_index":"10098388565963908402"},{"aggregation_bits":"0xe3129da3e65b6913b2b0784f55cfdeae8c20b6b500a502a8085bff96478c99b6385ea4970408a33cd4e9523866df2bd8638e867b1510bb004445961d836d810e263a00e33638192a4f325398be5dd615f5cdcbd9f89992e5cf9522ec558a6eb9994e24d9aa7516e69022a6a3b33270b8a48f1ddc38d7179b0b8f92319fa1ac74ee240e12966043f2c9ad5db595331991c414bbbecd8a0926248d8e8244d80fca04d98ace991fe2419a596ee906a7a0b165868461d03436ed3fd2a87823e35ed36f8a78acfc05b0cbc18bc1938c0de7f73a5cac444066b98049e22e2ed889fec2a70f013dd47c38af5377d147896a2143a4acee64ef035a46b63c87a0fa1586f901","data":{"slot":"10101693532397276658","index":"10093431116313856018","beacon_block_root":"0x32330d8cb253a2c19ebb12ab786eb4d6bf998718f4c9500523d23b61a282b576","source":{"epoch":"175414780","root":"0x0cf1188c72bce337b3354454d15c8b3cb39389f48738ff90c7cfb4d0edc04661"},"target":{"epoch":"174260533","root":"0x7eb7f58b31821fd573c7af58c791060bd8a58360cdecf3eddad649820b0693a1"}},"inclusion_delay":"10090126145585520466","proposer_index":"10088473662368836338"},{"aggregation_bits":"0x477fa707daca7bfc7c2fde5ae55e16bf7e0f8366c29514af8796c9c8b1ed8e17864e8ef68e8d8819277352df9542bb84eaf9f8eb9f324d9a751ce7dd030e20dfcd56fa23f1a7a273950fd1336ae173da37a22549b61cdf994017968efeb27218dc9ff3d24d7142e954c5aa8740647e576c72a8717e00b1f579c2959055f68e0b9af6abb0c2220e74244059004a5bf04c0eaa33f8c3444940cbb9db199a440d9f297ec1ec33b313abe26baba113af8e44d79693a81766a75ac19303535cd8bf18a808f9b310b68fbe8d755d8f942baec027c362e20dc621e6a882b2dacabb0affc4f6fe249b3dee77d91fab6acc36382526537c25ea6385bf65eebae06e698a8401","data":{"slot":"10078558758773764273","index":"10083516208423816657","beacon_block_root":"0xa5f9e98b7119de5e5d4d7eaf6ea32fa5e5ab81843a7e456235d9d012c0c701b7","source":{"epoch":"178877520","root":"0xb49d828c326b306075800147f0bd19d1425d9bb0b51b217a8fbaf5bb92f161a0"},"target":{"epoch":"179262269","root":"0x8e5b8e8cf3d371d68bfa32f049acf03636579d8c488acf0534b86e2bde2ff38a"}},"inclusion_delay":"10119870856370736658","proposer_index":"10118218373154052530"},{"aggregation_bits":"0x4b7b67ab19b293674970da12769cee145a2a54deac0080a4cb46c520d9a0314a6b9a976a4cbf5191b7a0c23c77186a884dfb76c805e63e5da3119b7ef7a72a332e3eea80a7a86a0da75accf4d446b33e8eeb748465357a67063514ef6eafa4236b81266c3b527356e03d15316476c317f118642b8ef9c5fe85c7514765f6ff684f84497abadac0926356c93fbb665438bc50c57362244f2830b08f9cac499a47c3a3d0099c3e1b131182c170c8264324c1ed153c34d306471a12d3c77c67b8d994f737d3e325e50a1c3b1c2c40c8bf46e2ddc73c11f4b81c2ab7c7b92b4f3c37f743b6160f9db76557377cd404beaeaf04cd3dd3274ea0f6a15180dd8be8d1de01","data":{"slot":"10121523339587420786","index":"10113260923504000146","beacon_block_root":"0x4da6538c32c82a871f983ba28d04be39747593406861674bfec311fe65f81cf6","source":{"epoch":"177723273","root":"0x27645f8cf2306cfd35126d4be6f2949f686f951cfbcf15d7a2c18a6db136aee0"},"target":{"epoch":"176569027","root":"0x992a3c8cb2f6a79af4a3d84fdb27106e8d818f8841840a34b5c81f1fcf7bfa20"}},"inclusion_delay":"10109955952775664594","proposer_index":"10108303469558980466"},{"aggregation_bits":"0x61e8fdbd84e7fa526aa505ab8ef8aeef550b9329b4d3d2d00657217f3c8aae365e528387bc75eed4da041909d65cf1d6bce0ae294189be0267c6cd78a1e9e33c71dd4544f91978cd9b5514791327c7aa14dab4301bb4cfe9ab05d3e03a4a264b915dd37affd213d997b140f5a38624a544a4f8f378ea35a606a3873c68d8edd0a94f8aeb879aa8e3aa2b887f4cde479a71684b06e231c2d2706b8929a7db7a93f9891a5b1f12fd2f11f0da9fb5c469313b25aa1f6a281cc8368520ecf5e166c204402071757f05f188c65d8581e74a9cbad6aca6b9b4477a189f96aa1f8780fdb56ff2885266d8ac50031973ac7ade179480fea90057c70ae7e6ca662e22fe4f01","data":{"slot":"10045509081555179825","index":"10050466531205232209","beacon_block_root":"0x238f748bf10150c086888f13f753caaa62e86dec792c75edc9f016b8d058558d","source":{"epoch":"168874049","root":"0x9555518bb0c78b5d451afb17ed88457987fa6758bfe0694adcf7ab69ee9da1cd"},"target":{"epoch":"169258798","root":"0x6f135d8b7030cdd35b942cc145771cdf7bf46934524f18d680f524d939dc32b8"}},"inclusion_delay":"10033941690448456336","proposer_index":"10032289211526739504"},{"aggregation_bits":"0x1312068880a56379409c80dd26461af992088fae92f38c63d3b8633faf69ac06bf94a3acda31f1f8c79ccd33d0b5010242c97b186abf2faefea6a47554c9c2af2ff828e6f533c1ce8c574f4c3c517538e2e25ce2dcfd87f355fd985c93d60b3d2d74496674770a5ce619235ebd7a1adfcae378718265889a73a62498ba77dc178e6ebf8972aeda64029bea3e15b0c61940350ae9dd256c80468342f11710bf2f7a13975e3087cc05b7f78e79e13b041f157126f98ea0036919522742d61986a534049f50ef1bcd90bc479ef10efdd12215de04838e2ebe8515dd33ca90bf5861b5a140c46d6ffa3bed3894f80ee20bca43ce549b88ea370e238d3565f51aad9801","data":{"slot":"10035594173665140464","index":"10027331757581719824","beacon_block_root":"0x2e5e228bb0248684ef3135738acfe9e1b91260e87226b01b4a01c8abc1a45c23","source":{"epoch":"167719802","root":"0x081c2e8b708dc7fa05ac661ce2bdc047ad0c62c405955ea7eefe401b0ce3ed0d"},"target":{"epoch":"172721538","root":"0x17c0c68b31df19fc1ddfe9b364d8aa730abe7bf080323abf48e065c4de0c4ef7"}},"inclusion_delay":"10076906275557080145","proposer_index":"10075253792340396017"},{"aggregation_bits":"0xbb810e75de0a0c279d7dc6f2cc21d65c8ad0b843d9f67155597b724099b68e9a6896aa6776525f5fe4290315ed519f57b23e17a808527f59a25ba7b8fd1f993573ff6c36e87d4e70f38ccdf5597cc3426fee2adfc2132e636e6b0583005a6ec1f786d6d1c651764b770ee6a7344edb0b0b47c209e980df8722e920c2b0a1e20aaaebcdba8c1a0b85f4ca1eddc29f9d3b490667c80cbd84a8ec356d967f5b791c2ee361e41a7316be922601a756c1cf041f062802df4b0777934d1953227490f01d3b4506ea1f70215cd6a26d0b66a2ac4c1fc18fe412cc708ff84a0b8350d218e1bf75bb6bf792c07aeaf1083f9cd4e770e90d42ca18a7a650cb7fe70b4eb0fd01","data":{"slot":"10065338888745323953","index":"10070296338395376337","beacon_block_root":"0x3d02bb8b7176d8850765b80a0bead30d17c47914edc38b33a4e2ec5493cebc0c","source":{"epoch":"171182542","root":"0xb0c8978b313c1423c7f6230f011f4fdc3cd6738033788090b6e98106b113094d"},"target":{"epoch":"171567291","root":"0x8a86a38bf1a45599dc7055b85a0d264230d0755cc6e62e1c5be7fa75fd519a37"}},"inclusion_delay":"10053771497638600465","proposer_index":"10052119014421916337"},{"aggregation_bits":"0xc95bfd656f5cdd1cbe0a5788854dcac8ddc22c457257423eece557973175015bec14b81182b7647dd5514971cb2a6ed36d1e31adfbd16f771bfaa5f64abeebbd2d9cc8d4e2c7f37166af8220106a15b951c6c30fd65a2469f8b7820ee10799eedffb0568e1946a8e2aa390667ab6b1f91d3541ceb92fc0dffc7ecac6000891493cee34b57c2a5916c4483cf483a08a30b9d10ea432832be8cab00748a7c034a0bb6282b535233b8e252fd9e1183b0a2aa43eb7b4eb6590fad942237d778ae08f765e732f617bb8644fdae204c2be8193af57c8b6c2ae3dd9e6fbee750f68c644c1f9d2baaabf335fc9f9701b9994453e7aa38df24261fbed57cf807cf2ecf0bd01","data":{"slot":"10055423980855284593","index":"9994282076068168079","beacon_block_root":"0xacf3ac8a2f0df8e5186d46d7128084e7364f4c50b0d4dfa6dd180e51d135b0f9","source":{"epoch":"163872313","root":"0x86b1b88aef75395c2de777806b6e5b4d2a494e2c44438e32821687c01c7441e4"},"target":{"epoch":"162718066","root":"0xf877958aaf3b75f9ed78e38461a3d61b4f5b48988af7828f941d1c723ab98d24"}},"inclusion_delay":"9990977109634799823","proposer_index":"9989324626418115695"},{"aggregation_bits":"0xebeb7346f2bdd4bb9cd9ec69b96d8f7732f6f93c72854d3e017444c3f45feb96dcccccc7c08cff9290359c2bca7e75a5df045f4a17a64dacd72d127c3e21a1396235cc94b277e9c14a82482d502f311b0975131b4bebb7d63ff2dd307d20efcf20472aae20dc03457022958eb5f606d22288d9f6471cea1dc499a59d0f3423b4eb153f235d8e29771d150df4645939d2e5706a43b6f7a7037c6ae12aec1b9c488ecf4ee7a588d3be347f481e744c809b59b3890535ac6a5c9116edd68d12af94dacfa78de6bd52bbf560a2e50b278e45fa7e032bebb0e3cbd2b2fd2abb61067eead286e1cb4c579adf764ea633d0698e53ba409c44ab18d2514782af6d292f2a01","data":{"slot":"9979409722823043631","index":"9984367172473096015","beacon_block_root":"0x1fba898aefd23383d7feb1db08b5ffb55c6146bcf688d403f01fa302ef7afc39","source":{"epoch":"161179071","root":"0x9180668aaf986f2097901de0fee97a84817340283d3dc960022738b40dc0487a"},"target":{"epoch":"161563820","root":"0x6b3e728a6f01b196ac0a4f8956d851ea756d4204d0ab77eca724b12358fed964"}},"inclusion_delay":"10020721820420016016","proposer_index":"10019069332908364592"},{"aggregation_bits":"0xaf8ccfd931624c38a08aa27b5f6b77fceef7649b1633f5710d847e21dc725c8b2100b1fd322a06b620e21cee28072499323c946bdb0b2ece50d6f95e6a926b4d80915e35f6fb8bcf69d5d6f2cfc813fcf4a752701932223d399147c0817c98fc84ac0574597e53f6c1de5c3010602b4b9d9f1c49bf798308beecc4dfb435f32aff07af63f592ef65d3168ccbb5b68f8e0b8f5342a695a162377cfd7249570a8cdd3e5150a1eccd02e7c228f78c4445dd49758c94ac6baf6e48c589c28bdbb40dc202a1ec192c3a87650ae19edbc0f18baf42a650f4d07b2012ef0a0b4a5564c49ba7dc135f258fd44ccb5296fd48d24112272dac2414b8e31424f03ab23d803701","data":{"slot":"10022374303636700144","index":"10014111887553279504","beacon_block_root":"0xc766f38ab08180ab99496fce27168e4aeb2a5878246cf6ecb80ae4ed94ab1779","source":{"epoch":"166180806","root":"0xa124ff8a70eac121afc3a0777f0465b0df245a54b8daa4785c085d5ddfe9a863"},"target":{"epoch":"165026560","root":"0x13ebdb8a30b0fdbe6e550c7c7539e07e043754c0fe8e99d56f0ff20efe2ef5a3"}},"inclusion_delay":"10010806916824943952","proposer_index":"10009154433608259824"},{"aggregation_bits":"0x0f84c53b8f5444dc6717ab282bf8b79d2cf851d017a1e3e662f8787f7b72c32bc718973ab82e291317d80c599b3b34e5111b4dfbd76d0c7718b8199c6b3198226a792ce4257f9e5da6e9c161b8547d53b241bee47167dd45d230b3688e40670c43f873cf944f77b50d1861542230a1e4e56aa364f91682234a55db4bf563e068d89120675092aa0313f2cb1e7a0966738cb4760e195ae108f815a2b570db1191558630d8a56d2088be804d37cb4583aa38d42848c14db2c3341eebe9a088418e1d942bd278950d5aa5f45c0f86a49c3800bb6a543b30eb15d38611a76f66f97bba1a31964cbf0adc55a7aa879894ef6a2edf997e2ce4e6b98605cd262e49b88e01","data":{"slot":"9999239530013187759","index":"10004196979663240143","beacon_block_root":"0x392dd08a6f47bc4858dbdad21c4b0919113d52e46a20eb49ca11799fb2f063b9","source":{"epoch":"9588004","root":"0x5c4f54780f61c41f71abf7796915b0c7bdc2358d840e5366e5c701243fe0be76"},"target":{"epoch":"9972753","root":"0x360d6078cfc9059687252923c203872db1bc3769177d01f289c57a938b1e5061"}},"inclusion_delay":"8665684985738576879","proposer_index":"8664032502521892751"},{"aggregation_bits":"0x4c31b3e70289c29bfd1ef1dcb56916ba48dfcc6577f25c017a066db2cbf7ef8a8ac61128204993f01872d22f39ef4a196282a31ba04a4b5dab98151e963da4eedab94f6ae09c3b61369f8a4413cb5002645ceec7bb3872857153a5ba582ace240e3b9a5556886e3516895b8b9dd85662243f9058f7fc71447bbe569f9821f4d376d229425015b802733f5cb1e668e96086a75aefff87cc59ba2649f577ed93131e2ef7f333e4bb370554acb5a96f8cecd267317d79447240bab32543ec079ad00034b7188160f2566c06ec358f621be12fe5dceba9eb673877d29af52c64465ffe997c68d0c57cec505886960b08e2457dbba31c3ddc439ac4b39a41c347ace601","data":{"slot":"8667337468955261007","index":"8659075052871840366","beacon_block_root":"0xf55725780ebebe461bc331d5065c5430efda2d1d3654993753d11d6612e779cc","source":{"epoch":"8433757","root":"0xce153178ce2600bd303d637e5f4a2b96e3d42ff9cac247c3f7ce96d55e250bb7"},"target":{"epoch":"7279511","root":"0x41dc0d788eec3b5af0cece82557fa66408e7296510773c200ad62b877c6a57f7"}},"inclusion_delay":"8655770082143504814","proposer_index":"8654117598926820686"},{"aggregation_bits":"0x56e2020f5eb22c95f7fc3efbb71bba775ee1ba403cb56375f5d865dc7922405a42481d439e2b5fb7fa4b1005054cd2cd4ea5ce6b8ba713b3992d22d2e2a4f11cac4c0bbe6ffdf59f2174205fb2aff6f8ea5098a3efdc719d59c5bf09d80adb56b54a81f2f0fe4b80861d7e3e17bc00b843116a20d6394e4d07e3f2c50542cbdc42f8cc5d689aedb151e7af78d11b7b649de46a4a229fe7c93890da949b2d642c02ce3559b9842c4d2bd022439819de5b9c5a3f8f383e7e0c528219d5116ac4f2ad054b1ef644b5f26c86492f22fadc6778e55786dfd38bedfde3cb9c4fe0ad2ddaf36b07f45b5919cfe362340016f75d6e0cf85f2ca685d887b550095d50916901","data":{"slot":"8697082179740477199","index":"8702039633685496879","beacon_block_root":"0x04fcbd78cf0f114833f6b46c88763e5c4d8c4749b1f1744fadb2420fe510dab5","source":{"epoch":"11896498","root":"0x77c29a788fd54ce5f28720717eabb92a729e41b5f7a569acbfb9d7c0035626f6"},"target":{"epoch":"12281246","root":"0x5080a6784f3e8e5b0802521ad6999090669843918b14183864b750304e94b7e0"}},"inclusion_delay":"8685514792928721007","proposer_index":"8683862309712036879"},{"aggregation_bits":"0xcc5861374d6036fe1ec66e99b4a426839fc0440c1ab4d71f1b42178e71c94713c10a269de8eb443ba317407d0ab603c85d9d51ef30b3c38e440d0c9c03cd93d7fa2da64cf547481c5e577746f9e814639f686924b09c130fde39f2ba325ec4e7defc126ae73a6a85d3afe9bd0a84f1ec7b90eb9be4b63b31ff36d1f947f4bb5ff455701399bc3f6679c48f7bfa30b6ce757b6fa110090a191e130148ab372999c304f6549791482c9f9d31add666abf5a20022249c276083bd47017e1980fc9e134230252e0035b73f1ad2cc21a25758b56435dab94b625495c763f6d343edbeaa11e8570b06328a7299631da4fe6aa180dad3eee596f51fd3f8bf1a84aadbdf01","data":{"slot":"8687167280440372431","index":"8678904855767017199","beacon_block_root":"0x0fcb6b788f32470c9c9f5acc1bf25d93a4b63945aaebaf7d2ec3f302d65ce14b","source":{"epoch":"10742251","root":"0xe98877784f9b8882b2198c7573e034f998b03b213d5a5e09d2c06c72219b7236"},"target":{"epoch":"3432022","root":"0xbf7198770dd5adbb180ae0e6dd2f416a852316cd4f256cab9ded712c8bfbaacd"}},"inclusion_delay":"8622720404924920365","proposer_index":"8621067921708236237"},{"aggregation_bits":"0x7ac259399225fd095d930c79cb442268dea729fd1210df5cec1353939441fd5a6e4a3b631874f79fce7b970f2ac718152d878febe4fe495d8cdb0bdec390cf5895dca9ec3ff45a6cfa5885c7bbb4346da659f13d4e348a29131cacb637f9204c82087ddc8653629a813a2c45c4044c5fcc78787b3a85d391dd939792cfcaede213acb98065bdc12191399b7b1f898d4f21832854885e67d92ecb8faaa0e6e040b36e3e0e37baa04d89cd6953321103755edf0ea3c2cd5a74b1e7ed90fb04f3c18bf7c78dc8fea76884b9d26d43bee48ace4d9e4850251c76a6ad7785e568b961a95abded36e41d4b75fd4e7a0a1e1031698fb795e11416c6a47de89132264e7401","data":{"slot":"8611153013818196877","index":"8616110467763216557","beacon_block_root":"0xe5b38c774d6c6c450390ae3d84416a04922914f1bbb6bd1ff9eff8bc40bd19e3","source":{"epoch":"1893026","root":"0x587a69770d32a8e2c2211a427a76e5d2b73b0e5d016bb27c0bf78d6e5e026623"},"target":{"epoch":"2277775","root":"0x32387577cd9ae958d89b4bebd364bc38ab35103995d96008b0f406deaa40f70d"}},"inclusion_delay":"8599585627006440685","proposer_index":"8597933143789756557"},{"aggregation_bits":"0x9893704c7516c2664f261a06c2f9b64f47a6b57af19cdfbb41a5255503a2d212dd1c04534a25ae166303c5670dbde04440a1397f5d64d8f1b06b6b1220b1e7dbcbf564ac2556c1ece5189398d0eb66f5e37199680915a8bb8da43f094c808ff99c23afcd8886598ff483ccd69bb875254092b175ca2a6ee8214e7922e5239c3905ac06de888511deb119a9f846ff02e8db18693afe2998818c3085d4bc6dadfd41eca6e618fabd6c3d5a3c25fca3e04ad1a4930162c067659d20f53934d6e7acf0b950e00ab29f2d07a513750de72fa5c244776646f960cd0becc7f92d53a8b8a9b418854bbfbe90ee87cb73adbe95c083c105a621210ac3587472a2ace80d8301","data":{"slot":"8601238114518092109","index":"8645855178548432750","beacon_block_root":"0x8d60f6770e1bb96dc5da6b30a3a2f89821f325ade999df08c1da39a8e5ed3422","source":{"epoch":"6894762","root":"0x671e0278ce83fae3da549dd9fc90cffe15ed27897c088e9465d8b217312cc60c"},"target":{"epoch":"5740515","root":"0xdae4de778e4936819ae608def2c54acd3aff21f5c2bc82f178df47c94f71124d"}},"inclusion_delay":"8642550212115064494","proposer_index":"8640897728898380366"},{"aggregation_bits":"0x90a388312de8257ea2c2d32826971bd279ade293ee427fcecf5a60621bee55e24086089e50564353a0be074d336c7e942f72950b758b888c23c63c7ebdc9f041bef807fc2ed26d52b6013c03e1c3584d757f2ec857b02aa3a6bcb3fa5db8228300df70f83bf1571a7510198f11c4ebf3abff4b8de48f1bf45919717cf2b5aabc3120f5c08c2f4875cf4858b5a1dd417e50670f193ff0839d2896a6b350a44cc8760c64691a9c57f2063fe69b4d115371fed89d5e272343b33412c8afca929dea79880af267dee29c75252ecf8938ca3a10c6f8390c9515b8b188be1077d7230cfd420bfaf505c70f7884acc98dfa18c490ee427b09dbca433332e280165c18c801","data":{"slot":"8630982821008341006","index":"8635940274953360686","beacon_block_root":"0x0027d377cee0f40a846cd73499d77367470520192f4ed465d4e1ce5904338162","source":{"epoch":"4201520","root":"0x73edaf778ea630a844fe42398f0cef356c171a857502c9c2e6e8630b2278cda2"},"target":{"epoch":"4586268","root":"0x4cabbb774e0f721e597874e2e7fac59b60111c610871774e8be6dc7a6db65e8d"}},"inclusion_delay":"8566535949787856236","proposer_index":"8564883466571172108"},{"aggregation_bits":"0xee053db66970518065e00af7984e4e424282bc7595ec413478e75ef38c058a43938c0dfbfec4ce470e2445fc6eb1843d9da604e82c530a7adb1662be9716a52874f83bc77b6ab9d3eb06990a250552914b0a98b2875d3fc646feaec5bea9d26bf573cb697b6548a937cec3b36066a5074970a95dce7e8fbd43b57752f58bbe88565d2d9a0d99372dc56b6a85cbea3f5e615a14dcca3c7293b4f01f8f91f312d04097783960f76961da40498ae8dcca31540c08b27b8cff676826df8659cdf6485ae0e1e73b6d2dd61097910f9769dd24fa52ad336ecf8514af9257e7685c8aabdc7b361d82b4104fced4bb5accce33fc49538f2e297c41f7288db2e4e917796801","data":{"slot":"8568188433004540364","index":"8559926016921119724","beacon_block_root":"0x6f18c5768c77146b95746501a06d24416690f254f35e28d90d18f055419a744f","source":{"epoch":"996891290","root":"0x48d6d0764ce055e1aaee96aaf95bfba65a8af43086cdd664b11569c58cd8053a"},"target":{"epoch":"995737044","root":"0xbb9cad760ca6917e6a8002afee9076757f9cee9ccc81cbc1c41cfe76ab1d527a"}},"inclusion_delay":"8556621046192784172","proposer_index":"8554968562976100044"},{"aggregation_bits":"0x68501702146ff562ab6aa7a378dd0717f50fc3ee046a5fe753b0d0ad78a58deaecd63d38f2d8e269fc8e504395ed146a2e60dda828f1b8f7b52057fe0e3d88cd9f34843e6c9a28c13f5e9a9b7d90265e29f666a2ce1ad636bd6a1a6d22500d89b0321d62dc554e84f138eff6533d2ea8a01d5456c8134d97f72060a70874a9c360d6841ebe4d508b66866e34161bff37a4378db294fa5a7572d160ce6a6f00cce428371ac62782f236f2a9c026dc6edb074c3c3bdcce4e501477bca862d4a5969d726c3d53b89814d55a2d07c94cf65767c26185232f3f03ee834b614d473792b7e49b8097f68b35da98516786beaba497b515eb0d7e1d9f3bee0a787d0b051d01","data":{"slot":"8545053655086060684","index":"8550011109031080364","beacon_block_root":"0xe1dea1764c3d50085406d10596a29f0f8ca2ecc039131d36201f85075fdfc08f","source":{"epoch":"354031","root":"0xf1823a770d8fa2096c39549d17bd893be95306edb4b0f84d7a00aab032092179"},"target":{"epoch":"738779","root":"0xca404677cdf7e37f82b3854670ab60a1dd4d08c9471fa7d91efe22207d47b263"}},"inclusion_delay":"8586365756978000365","proposer_index":"8584713273761316237"},{"aggregation_bits":"0x04efff9ff693eded9e3d9daabbd5f7791d281e1fc08cebe913cacc0d712922fb8948050696621ba83c7187a855becddc82705628a856cba1268b6b5cdae252315c9497bd281e8b6c05500444f76656bbf03e1f670c5bf75ca19c319eace4d8b8a7588bc607d66e3d47cc3021f7f283b915a793d5346a65fae95d80654bb4fbb075b6268a26b594574190fa0bd4b075635abc301824982d3da9ce70735d6a9a5c97d575fc0132984e415fc011959da9a02c2f38afafefef01cdf6ecb9e85f904345774e12b00de832440e6e7419aa9d9d50df44f61fcd84616cd62b70b673555c847391586325da236eb536594f2a3d0af73b77d5e172693a77cdd5dd8e6b320401","data":{"slot":"8588018240194684493","index":"8579755819816296556","beacon_block_root":"0x898b0b770cec9c3016518ef8b4032ea41b6cfe7c67f63e1fe809c6f20510dcce","source":{"epoch":"999199784","root":"0x63491777cc54dea62ccbbfa10df2040a0f660059fa64edaa8c073f62504e6db9"},"target":{"epoch":"998045537","root":"0xd60ff4768c1a1a44eb5c2ba6032780d83478fac44019e2079f0ed4136e93b9f9"}},"inclusion_delay":"8576450857677895596","proposer_index":"8574798370166244172"},{"aggregation_bits":"0x9ee7c4f82bdefec2f5ecf70283d09b82d267dbeae00ab749f8f3f83ed5839993b08071c10e01902c589c08fd34ab542132eb0c5e486b4966cedc7557beafcb5d213f5b5d7cefc1a62355deccf03a32af888fc7db327242686c71cfe1da5b0c9b68e42ec0ae344f36f4dd15c112b1bc1aa01b29ffca428de0f598c65e44c85b1283272d181971473face98d4b3009c0c99657a415a42db1478815bed446787507adffb9ede3b8727ed5cd98fe70bb01a0cae5070ec01cc4c6a5611f370ad69d78fb1299a232773baddaa8659dd8b2826f13f6a7c097515bdf1eb9ba33907ae5b0e21bd52066ff15ce798963fb85ea01985b433fafe5aa0eab390fda3f29f058d301","data":{"slot":"8512003977867476235","index":"8516961431812495915","beacon_block_root":"0x5f742c76cb25c2697d41e2691e533a1509dfd82878c14cc1b336cbac6f701466","source":{"epoch":"990350559","root":"0xd23a09768bebfd063cd34d6e1488b5e32ef1d294be75411ec63d605e8db560a6"},"target":{"epoch":"990735308","root":"0xacf814764b543f7d524d7f176d768c4922ebd47051e4efa96a3bd9cdd8f3f190"}},"inclusion_delay":"8500436591055720042","proposer_index":"8498784107839035914"},{"aggregation_bits":"0x2c55b6ac9b0e1df984c8e3358bab2f97112ecd624fabc7a60f40fa464440bfd3112642e231e51f815e55ca9752f7a5e4f7575b8bf329d95033ec0c48599ec2f57f4a14953a056ababe27a1dfe325a4bc9cb72f49b5b348f8fa019225730733ae048afcf5a17b103340e4454a6e09416c2a4e8872daef188c0b0589be30607ccd3407d046c341b6a90041fd082b6e4946e6caddbb2e9f7e15aad971acce2396363f75a3a9cdc96e5ee35ec990fc6666dd55bfe8b34518ea63cfb61db4c33cab79814ea25fa53372c85d34ce5d19af29e106f746f8a0eba2f973bc86498c6fa10842d175220316b779f0b36ef1006b9861f7a93d1f2d91b6ecfd000024b4185c0301","data":{"slot":"8502089074272404171","index":"8493826658188983530","beacon_block_root":"0x6b43da758a48f82de6ea87c9b1ce594c6009cb2471bb87ef34477ca060bc1bfc","source":{"epoch":"989196312","root":"0x4401e6754ab139a4fc64b9720abd30b25403cd00042a367bd844f50fabfaace6"},"target":{"epoch":"994198048","root":"0x54a57e760b038ca514983c0a8bd71adeb1b4e62c7fc7119332261ab97e240dd0"}},"inclusion_delay":"8543401176164343852","proposer_index":"8541748692947659724"},{"aggregation_bits":"0x34861e41473372a94a28205b08e1e33a8e50788b047eba95ab9de261122a3963cb046a2de69302c63ef940992d373df05c3536fa9d868cb321495d9fe8ee3007017b734aef86f608699c07019a195bc41bbbd9bcab776376c512d8b6e23916589b6b796057d57fc690e7a092c55d9ba6e7fc537edd5145857e720140ae773ec6d0eba35013e7e613e2080dc9bc5d9b60ef99c0420b83e7ad2feef649aefa7d8f6a95c512c61f85287ffe070e7ff235085a8686d332ebce3545ab202a3f5c717a287d5edd8d576c4c0c34f2711432927fdd77cb54cad3d28949a5f7a207ed2fdba2a3627f852cd9a87bc98b00523c4f7ee60466c20d21f4660647ca06280c493601","data":{"slot":"8531833785057620363","index":"8536791239002640043","beacon_block_root":"0x7ae772764b9a4a2ffe1d0b6133e94378bebae450ec5863078e28a14932e67be5","source":{"epoch":"992659053","root":"0xedad4f760b6086ccbdaf7665281ebf46e3ccdebc320d5864a02f36fb512bc825"},"target":{"epoch":"993043801","root":"0xc66b5b76cbc8c742d329a80e810c96acd7c6e098c57b06f0452daf6a9c695910"}},"inclusion_delay":"8520266398245864171","proposer_index":"8518613915029180043"},{"aggregation_bits":"0xc43c2561a0c9e7a56b572430084cd7241760478d06ba29621c4984fadb65166a0ac25bdf78570b2c45a058c533d0e535a903b35f7271188fdc7c15190fcf399e5f1efeeae515798dd47609189b6ce11c6f93a0aefe3f29663bc98d4d3966a33cd54da8d8589046e3ad5ff71289e9a0c2fda8baf90dddf0d90ced2df0cc250b5145ce9b16ea4715ec8e8a2fc0fd7306eb3e84a1ee9513085d9d4c3c1116e338bb681c7c40e8ae935f61b05ec837456486e5dc1aecb2c353b40a26148b1ca65d15cb70ee8aaa13b7280ba4b0b4d36a0940fc7eeb45eccb2b6424eb5edc1850f92f926df43d9df57e3dc0f2ea027304d6c3894dc5f8051e4225b16e353cf1ce1b6401","data":{"slot":"8521918885757515595","index":"8883812869125129588","beacon_block_root":"0xcfc5437b14911eb0d33056c699ab6b3d9d3fb48d58b3ee51023141020f730e1b","source":{"epoch":"34596683","root":"0xa9834f7bd4f95f26e9aa876ff19942a39139b669eb219ddda72eba715ab19f05"},"target":{"epoch":"33442436","root":"0x1b4a2c7b94bf9bc3a83cf373e7cebd71b64bb0d531d6913ab9354f2378f6eb45"}},"inclusion_delay":"8880507898396794036","proposer_index":"8878855415180109908"},{"aggregation_bits":"0x9e6bf617419110d3a780f5e993af121a8ec7140af0e4c6963f6760483ee7d9843ca7832ea927f642dc84c47100a241011640ea0489aceee8e384fbc0a71769ecdcfa03bce6a27e58234e03b2cefb782c7085358ed757b5bfb2daf92a4b803a466ce1594b09d7653065138530eeeb57de05da682354a1a6b8675f4c8171714f69ff86a32f5956dbe7dbbcbed382a2df2bc1d18ca69beccf18c1ec965835b4cc32d9a0eeeeda74af1f1f0e6db393ebb65e2b7ac6744dd632e7a1accd5d9692806888cfe6f1fbd9f9d9d749ec0b76d30ef0d80c353522d7039cfeab90ca38054d7d80b929ae72bbf125162ae79229a5f91721cf4787ea7d4de284ff408941edfcda01","data":{"slot":"8868940511585037844","index":"8873897965530057524","beacon_block_root":"0x428c207bd4565a4d93c2c1ca8ee0e60bc351aef99e67e3ae1538d6b32db85a5b","source":{"epoch":"31903440","root":"0xb452fd7a931c96ea52542dcf841562dae863a865e41bd80b273f6b654bfda69b"},"target":{"epoch":"32288189","root":"0x8e10097b5385d76068ce5e78dd033940dc5daa41778a8697cc3ce4d4973b3886"}},"inclusion_delay":"8910252609182010229","proposer_index":"8908600125965326101"},{"aggregation_bits":"0xb6e77da99ecb18cc9837d77b548f68dacaa688a01e9352b97b9bec290069ce95455df8a46d9d4f8f7e595281c171bb4faf50692558710d9a740de77a73a8a3103e82333fa0a41dc7da19b965d94c7ae8b4c464651cbe78d1e7b8ebc99ac6c47dd34ac25072d06d85d5ef5d9659e8239fb9c9ac3b86c0e6b61338ad183a70be71a848e18b6b8a2da7fc322c6c974f6d7b376ab9279c8969780ec5127c88a05ba63a7caf0f5588b8a34aa2406bc1636c40691143e0968694f57a5d99089e099487929004d30e589377c777ee61ee307106897192da1e339efefeff55e741217bb7f3aca324665bfc212803dc026270e971c251baf906e15787c09c9714f2beebc701","data":{"slot":"8911905092398694357","index":"8903642676315273716","beacon_block_root":"0xea388a7b9405a775550d7fbdad4175a0521bc0b5cb4a0598dd22179fd2e8759a","source":{"epoch":"36905176","root":"0xc4f6957b546ee8eb6a87b06606304c064615c2915fb9b3238120900e1e270785"},"target":{"epoch":"35750929","root":"0x36bd727b143424892a191c6bfc64c7d46b27bcfda56da880942725c03c6c53c5"}},"inclusion_delay":"8900337705586938164","proposer_index":"8898685222370254036"}],"current_epoch_attestations":[{"aggregation_bits":"0x348a47ef2b708dae548a63ac901da0a948c9bd639d01051a74787277a0c9717d6a479247e18120a9876346a72b48281028de38f55659bf391271d331b2c302f5feae6bfeb75244cd4901eae6a6941dc662a0aaf578fa85a35d1a3f6901f370dc363f146abe6465e0090875734f3fa050523d111048afcedde0e7a2cfcaa618373e02e20f11c0788115de6d8dc8c38386b815a06b344a01dcc589cfe5d92461b818c8c405d3115ceeb4d0a28bd8e3e63d1b316729e9a52140c40cba22a53a6442c59281ac66f9bc2d0bd972f8bc700e7502cd5c2e135782e03f9e494b25b3af02f0b1deb9e5583959346b27b43ac2f523dca63a0c32b3297d52bfe7806ea2f53e01","data":{"slot":"8888770318775181972","index":"8893727768425234356","beacon_block_root":"0x5cff667b54cbe212149feac1a376f06e782dba2111fff9f4f029ac50f12dc2da","source":{"epoch":"28055951","root":"0x32e8877a1305084c7b8f3e330dc6fcdf65a094cd23ca0797bb56b10a5b8efa71"},"target":{"epoch":"28440700","root":"0x0ca6937ad36d49c2900970dc65b4d345599a96a9b638b6225f542a7aa6cc8b5c"}},"inclusion_delay":"8824323447554697202","proposer_index":"8822670964338013074"},{"aggregation_bits":"0xca04969aaa6cf81092d7aaee02f5be3062e0fb97b520ff9561565eaa7702369d7168963fef1b0fa108eb55d6e29670b9ba5229e70705d44fe16b8ce2d01cd3943d349157f02bb07500161c98505a084ac99ddd2a2d5601459d28715ae6b4af77d81f2ffff474143b53cd26efea957a24a6a0b3e0a05c5b37d94a8c87c1b51d0febd63b7790ee1bddbdef0bef689559568b0c338d2386f05098fec68013789ec2abbffc59c9d225a348a70c73697a7fbfbbbd42e458719798c121ed4d3457aff19463eb9004eab5ed4e878dfca2053dfafe991164b18d38e441d4f3d8bb301fa5e584575e8468e97b8095900ca9035e98498b6739cad4e8d94b006b6c9ccc95a401","data":{"slot":"8825975926476414034","index":"8817713510392993394","beacon_block_root":"0xcbf0587a1262027325a7788eaa0ca14897b88c5dd50f4e682960cd4c2e95b5c7","source":{"epoch":"26901705","root":"0xa5ae647ad2ca43e93a21aa3703fb77ae8bb28e39697efcf3cd5d46bc79d346b2"},"target":{"epoch":"25747458","root":"0x1775417a92907f86fab2153cf82ff37cb0c488a5af32f150e064db6d981893f2"}},"inclusion_delay":"8814408539664657842","proposer_index":"8812756056447973714"},{"aggregation_bits":"0x429d1f657615054a24326acf6ab3508d7bc1bfbffb64b364479a53c045ea190da45196a7116843c428f09738fb60607955d505532cc8449873cefb9d1d05c5044762c48f632c2cd302dcbe2039761f9057d12b8cbf9002dd9f326ee5f52438874f5974c81687788ec25cfb9220e15282d9b6481896e9c12aa81738dedf0b33a3ddbbe1495c68cf361fb6fbba0ec6937002674dfc501acefc38c971d77db3f8f5f77c1ef2d284a3754303c3ad5f84e5ccf6eb7c98ac9bbbc0f11a51cdca1bf5863d521c0607e20e1d4c0aba62a39eec6c22d89e21fb25c634db88fa15e0bf1590adfed0018879a5a6b73e14addb9e5915f200aee4fa2e2adb9556b7c6015d80d501","data":{"slot":"8855720641556597523","index":"8860678091206649907","beacon_block_root":"0xda94f17ad3b354743ddafb252b278b74f569a68950ad29808341f2f500bf15b1","source":{"epoch":"30364445","root":"0x4d5bce7a93799011fc6b672a215c06431a7ca0f596611edd964887a71e0462f1"},"target":{"epoch":"30749194","root":"0x2719da7a53e2d18712e698d37a4adda80e76a2d12ad0cc683a4600176a42f3db"}},"inclusion_delay":"8844153250449874035","proposer_index":"8842500767233189907"},{"aggregation_bits":"0x30276671fe8500356d1d3da9633ecc0beceaa1b3f8e49113b0386f16e82d9e64539faddd2728586127acd5c6ff1b917c84ef325687dc94b44dfe9b13e444e08d3d12797de1ce8742cb5ed13138628d2332e9d35eb35368cd18682f0a94bd85f12bf0afdcadd265dbbbf698c17d19d998d167c91e925696125e0251d03fe24e12ca125407ad7e9ca1331cdb235ec817f3f2fe15ca8c2aa7ac0cc1cb1fc928b748779d8db7fcb4d652e33d8bdb007b08e65992e379a8d4a5531dedc87265e179fb5d1d674f9bcec4099a9671036cc767c34550f951ed3f3b9bb6c30e4b6997d9c0cd10c61973f9245d0e441ca7fe56c6ecbc6b54f2da1b1e18165e6dd5ddb1c22301","data":{"slot":"8845805733666558163","index":"8837543317583137523","beacon_block_root":"0xe6639f7a93d68a38a683a185bea2aaab4c94988549a764ae0452a3e9f20a1d47","source":{"epoch":"29210198","root":"0xc021ab7a533fccaebbfdd22e17918111408e9a61dc15133aa84f1c593d49ae31"},"target":{"epoch":"21899969","root":"0x950acc791179f1e722ee26a081e08d822d01750deee020dc737c2113a7a9e6c8"}},"inclusion_delay":"8781358862446073393","proposer_index":"8779706379229389265"},{"aggregation_bits":"0x1aff6a4e6b80c1502eca460a985f88e0a2c34802d0f69f4937c163096d05b44f70e4b81097e6cbdf4ac202c65aef9ca530c769b363b1b66ba0299c09be38a96030f97765373fcd02f9d11bb9553579c50bd807e2ba787d69e5f7a05688404791d40cc85a603b0584c470ddf9b0db063b66df71e678657c586e661d8934d83cad0a6db7b784def9caef61ce23b5700717ae0403372a7f39d6469ae1ebc1fa5dc9477145e50c977c6de10c8884f108b0a7ad5fdddc667cbfec597c65c8e75dc5a4fc2892ef0dd02114ac7831a2e6db4037153b1ecfc493c5a6c6ab5f78dd1f419eeb7c46f26a2a689c02025851b0d3acfc758377bcf4d9fd853c8a726e433f951301","data":{"slot":"8769791475634317201","index":"8774748929579336881","beacon_block_root":"0xbc4cc0795110b0710d74f5f628f2b61c3a0773315a727250cf7ea8a35c6b55de","source":{"epoch":"20360973","root":"0x2e139d7911d6eb0ecc0561fb1e2732eb5f196d9da02667ade2853d557ab0a11e"},"target":{"epoch":"20745722","root":"0x08d1a879d13e2d85e27f92a47715095153136f79349515398683b6c4c5ee3209"}},"inclusion_delay":"8758224088822561009","proposer_index":"8756571605605876881"},{"aggregation_bits":"0x88645946dab2f06b74f1c73431609ece64ccb40417564d3aea755959feef1b3ef3e69b3f812252dd769a53fc5c906ae0d9f17e76da2b37f458187247c77190d16ed8f3972b450117417317641470ef7446a16a4d3c39f77983c7e7ba6b5c2afa6a225a633a7f2c89bcd2c53a6ce71acf4a8c9261beeadf05944b342b3e634d649f8c03e97d6e8a195bd0e820d006833c0eb976dd376194c465f60aabd1f13a74d4b9a94523c312567589cce22994d799b60ec0664633a0ae26b92c7dcda717c19a6ea3499ef4acb12b64f6282c83cb2892323ecdeb893d4109b9720643031d86dfba72e39363411f3f58d5e9963f3585bbe9d50d24a985449c8389edb3e7ddd501","data":{"slot":"8759876567744277841","index":"8804493640364553074","beacon_block_root":"0x64f9297a12bffc99cfbeb2e9475345b1c9d084ed885594399769e98e019c701d","source":{"epoch":"25362709","root":"0x3eb7357ad2273e10e438e492a0411c17bdca86c91bc442c53c6762fe4cda0108"},"target":{"epoch":"24208462","root":"0xb07d127a92ed79ada3ca4f97957697e5e2dc8035617837224e6ef7af6b1f4e48"}},"inclusion_delay":"8801188669636217522","proposer_index":"8799536186419533394"},{"aggregation_bits":"0x909e912f946f1f31d558815f990a71537e18c3290512314f7039d177a92b1dbe2b4491fc9d055f1a782794745552d42477a21a06f2c4f7b642b48599ebe8863b1cf4894f2663df3f13a892f5bd5cb50dd8f6bc25047c55e322f75636fa644f13b7c3cd76d88961743ccf6eeb3f8fc0953d486937917f940be82c9053aab57351abe190d78ad45eb3a18a1cf92703c92817c26f72c4f16f5c42822ed43f33d06580195f6a29b38b6c6b04033c9a04a86285384c9199dcae63d4b840e732ea2bd2b7d75f9a9af0716553e9cf42285e78b1cf5275a29431457187a687f96089b6f3ba50bdfc85e921d8085b9872b736a2988c6f04743652014463c4970f44d280b401","data":{"slot":"8789621282824461330","index":"8794578732474513714","beacon_block_root":"0xd6bf067ad28438378e501eee3d88c07fefe27e59ce098996aa707e401fe1bc5d","source":{"epoch":"22669467","root":"0x4986e379914a74d44de289f232bd3b4e14f578c514be7df3bc7713f23e26099e"},"target":{"epoch":"23054216","root":"0x2344ef7952b3b54a635cbb9b8bab12b408ef7aa1a72c2c7f61758c6189649a88"}},"inclusion_delay":"8725174411603976560","proposer_index":"8723521924092325136"},{"aggregation_bits":"0x7ef20af280fe51cf1a395a975f5665ca46208dcb37318b4463b579eb33c843d6bd78948af83e0216dadd922b1c9c2ea985f6aa929b68d74003a063af69b75394d34565e6727b2bbdda2d07f64a92eba1f65b6e1dd1117007e28d3aa55b373aba23ac5ec71a9b35b1678eaf471d48ab7fcac3a3e4888801537201fc5b0bdc6df54e3d156fbc623d4883bf5e1f0615b54214db3f3c171f1ff79ea4f5fbf5e68f9df50e53a28b50e6d3b671eddc2beb71603b2c19654db91abf90bd37dae7a6c325c4b6918ffe614922341370d2262d2fbda22672a854fbfedd79bc96589e2a33349b651c1afe5a71d0fc296fcd7247bc305f457982dc54c5f07ae449aba20c841e01","data":{"slot":"8726826890525693392","index":"8718564474442272752","beacon_block_root":"0x45b1f878901b58979f58acba441e71590e6e5195921add09e3a69f3c5d48b04a","source":{"epoch":"15359238","root":"0x1f6f04795084990db4d2dd639c0c48bf0268537125898b9588a418aca8864135"},"target":{"epoch":"14204991","root":"0x9135e178104ad5aa746449689241c38d277a4ddd6b3d80f29aabad5dc6cb8d75"}},"inclusion_delay":"8715259503713937200","proposer_index":"8713607020497253072"},{"aggregation_bits":"0x5cbf30543c9acfabdcb4db40afc6adddd63e9019e2a19de36860e6b485c8c8afd36ab66f3a9bfe33283793cefe91bede321412909f9e75e459d22205e8c5eae7393903a3747570aba8b4146dbc4bcf12947e95c19d56ac57f90d8e8504aec61c6435a8dcfe2c19dab9e912802eb204d103f374cb7fd3f9784245a18cd320d48f7275822b4a2e784d68563bfa89e57d0fabb406705af85d45519aaba00a7a9d0731b918f0b5895e7cfd0308b6ba635d0de8ae3f3872bb8bcabfecb4e898a414f213a51312975a33def1fbcee2640b56ea38bebc2e1bdf628a9ac4eafcd11deb8db0f9208ee758f49ae4451ffcb57717f18bbdc1d4f836ba18ec5d72a73a10bcf701","data":{"slot":"8703692116902181007","index":"8708649570847200688","beacon_block_root":"0xb877d57850e193345eea17bf3953ec2734804b01d8ced166f6ad34ee7b8dfc8a","source":{"epoch":"18821978","root":"0xc71b6e791133e635761d9b56bb6dd6539131652d536cad7e508f59974db75c74"},"target":{"epoch":"19206727","root":"0xa1d97979d19b27ac8b97ccff145cadb9852b6709e6da5b0af48cd20698f5ed5e"}},"inclusion_delay":"8745004214499153393","proposer_index":"8743351731282469264"},{"aggregation_bits":"0x9492f0aad776c73ae1e7c7da5ecc55f31a1f1f8102d4a9c834d8df158de4aba7deb48ae659b9a6fbb8f802393c034f789ba091334b111693cc7d7a273f434c8bdb11918020ed1c1012f90aba22ec8fe34d3fe5ea5e358099ef4f54f621fab92151791ee0852e41610a15d15c8a8dad919d28b95d638ac977fc09505df021026baeb11217f2d4be2d8f4c8dc75ac8ef7f651f3b7bf8994935899bbf243976079563440e45aa2715c03cac6aec60880251df4fbb80a95e0ed14f3d84ff982f352f2baa197060491bebe0878d39f8ed2d0418a79059091bfb930edb4bd809a99461c964aa6e3389bc949e68a7e675a3b156eb21644ad4dba33d23aa4db2d7e193a801","data":{"slot":"8746656697715837521","index":"8738394281632416880","beacon_block_root":"0x60243f791090e05c2035d5b158b47abcc3495dbd06b2f34fbe9875d920be17ca","source":{"epoch":"17667731","root":"0x3ae24a79d0f821d335af065bb1a25122b7435f999920a2db6296ee486bfca8b4"},"target":{"epoch":"16513484","root":"0xaca8277990be5d70f540725fa6d7ccf0dc555905dfd49638759d83fa8a41f5f4"}},"inclusion_delay":"8735089310904081328","proposer_index":"8733436827687397200"},{"aggregation_bits":"0x3ee66a4d18f23c8429500d0bdb091d47d9895e272ca2e6183a968b61424513c199f145166838db95192bd44dcc00c9a76cf7cb9c93cce476e3ad1c2714badc207676c6f7bb550789afd0a0bafe6a15f77a4b7f4acf15dce6e1562f21a324435800f6cbb3352f42e6c2492f1e5dd7a71f66106a04a7dfff6fbe1131244d8d504edfbc7eb64bf148264e6a1cf0a6e91e17c35ade015776a356c1310d660aa1fe2e0ada9d3718ed7d9243311de7c576f9c341292593d67f0a1bffbd5c780a197034e965c900b384e30d6e2af2a2196128acd8904d33d5675e19b581c06faa4c70714c21749e9ef5169c5870a2f83995bed34ba1ae121b88bfeab3bb180373e46cf601","data":{"slot":"9093678327838327065","index":"9098635781783346745","beacon_block_root":"0x1cfa3e7ed929bab64b30e6bb2130fe1871b6346abfc638c9c497f94f2a44efa9","source":{"epoch":"58066366","root":"0x8fc01b7e99eff5530bc251c0176579e797c82ed6057b2d26d79e8e0148893bea"},"target":{"epoch":"58451114","root":"0x697e277e595837ca203c83696f53504d8ac230b298e9dbb17b9c077193c7ccd4"}},"inclusion_delay":"9082110941026570873","proposer_index":"9080458457809886745"},{"aggregation_bits":"0x6e3c195ce2a4b5e9c0f79f29933ab1531b82422be206f6cf8e64e9bdcdad145139b34fe45e5c40b84a979635c8d73c23b5595c0d6ad7f54b9ebc7de8d3da77e088137113a1bf9d88da525e6fb71ec3260e431d59203cbef0bfce1ccd2ad93c35a4ff19ad0b680e93ffe3ee96847f3ae13f46faa9547a0a074e04dd94dd25fa850897a0b4b6451bf9664a3cf777bf8b3c63579fbb6c42180477f1dfb7863ab7c249f054f037581fba7c5648d18e89ccfdda139835d672940a913b5d9059f096598959eadc35c06b54ba1ae5e39a3de3f26d5ced5beb6fa7ae9fd70c92b62721cd28e7c09cc53ff539e30aab711e3da75fa5eb450bf3b61b296b82e7098e82301601","data":{"slot":"9083763424243255001","index":"9075501003864867065","beacon_block_root":"0x27c9ec7d994cf07ab5d98b1bb4ab1d50c9e02666b8c073f745a8aa431b90f63f","source":{"epoch":"56912119","root":"0x0187f87d59b531f1ca53bdc40c9af4b5bcda28424b2f2283e9a523b366ce872a"},"target":{"epoch":"61913855","root":"0x112b917e1a0784f2e286405c8eb4dee11a8c426ec6ccfd9a4387485c38f8e713"}},"inclusion_delay":"9125075521840227386","proposer_index":"9123423042918510554"},{"aggregation_bits":"0xe695b031fe0be9e9c233da4670586c7c058775cfe99109dc9caaf19bdd69b7c5d6114e2b747f0e3d3a26141ff507a0765a20343d0f9ab1ad04311587426ab7387eaa268feabb31f6c58c7bd61e1a535f004eefb51691bd7c8496b170a96f41cb6339921aa98ae0262e3683ec0e1b8023b02ed28138cb354a3849d74bf31a55185c3873e643ebc34210108e52f0bcd138fa34ea4cc8cb643cf587c8d0ca7954a7b980569a3f888d61c1ff824d8e765282a14eb64ea398981c11053147a5b58e3e207a055e3c2596ec92baca5997e3861876192206a1475bda158e1d7a37cb9a9c250d87c8cf24dff8f8b96e8b3c6ef233be415fd2d1465961c4d1dfdb7c966d5301","data":{"slot":"9113508135028471194","index":"9118465588973490874","beacon_block_root":"0x376d857e5a9e427ccd0c0fb335c6077c26924092335e4f0f9f89cfecedb95629","source":{"epoch":"60374859","root":"0xaa33627e19647e198c9e7ab72bfb824a4ca43afe7912446cb190649e0bffa269"},"target":{"epoch":"60759608","root":"0x83f16d7ed9ccbf8fa118ac6084e959b03f9e3cda0c81f2f7568edd0d573d3454"}},"inclusion_delay":"9101940748216715001","proposer_index":"9100288265000030873"},{"aggregation_bits":"0x941c89493d5969a73b0e4830dae40861dc8ae0e10a201973e918df035282b8a87377740802bf911d07728437c37e50e28bcf9bb9288a30187b0d7429e58bd4b920478b6db085aad432eaf7835d3dc56c7d778696dad8d66e52aee28d4033feef4f18490a2aea796397dd55bd53e39e7f78f1cb07fe504236408cdac325e0259dc819c7e8b8d1b2b168d9ae79ef86559f12898baed3ccce4ee36c06081aaa9b12881b8e5731bd4881f7eacfab818994edbe742b78633197bc965a52ff006b6853da26766babe11ea8c9a6195252bba703db990326f2fda67378c0f4152bf02ca855cf56ce77fcfc2f61cb2fa299c96baa448bbce01979a7a635d2a058a16e2fa101","data":{"slot":"9103593231433399129","index":"9042451322351315320","beacon_block_root":"0xa55e777d183562dcdd149d7f3c5cb855451d13cef66ea382d8bff0e82b214a16","source":{"epoch":"53064630","root":"0x7f1c837dd89da352f38ece28954a8fbb391715aa8add510e7dbd6958765fdb00"},"target":{"epoch":"51910383","root":"0xf2e25f7d9863dfefb2203a2d8b7f0a8a5e290f16d091466b8fc4fe0994a42741"}},"inclusion_delay":"9039146360212914360","proposer_index":"9037493876996230232"},{"aggregation_bits":"0xbed67102ea1c20f8d85b02d92c94b8ca99a136b432f427b3843d5254fe0210c11a2f60cd6471aa834a5e5705724acbb00f10545d4ee3bbcf9bfea20361561fd46d768425fa3fb4243ea59d6e1e62a14ce544eae3873ac2f8de093dc3e41c5ad5b8ecee1cef2f1b3e2852d885de204dbd8f0d4bab1441b8dfd028849828de96262dc4247e9115f9eaf1c4eb390e5e451f4672ad4343d1f784e3b4182d512150fb7c30c407e117127177fecd540cfe15ed4efb877b69eb9d3f186e55008ae3f40c46c18ac93c16f43773cc09d293b7bef98130faba0ab1585469aca1233e7bdec2f7a512b12b3392ba86b7610d162f451ab5cb149a5ff146750f0c3ac216e1611501","data":{"slot":"9027578969106190871","index":"9032536423051210552","beacon_block_root":"0x1825547dd8fa9d799da60884329133246b2f0d3a3d2398dfebc6859a49669656","source":{"epoch":"50371388","root":"0x8beb307d97c0d9165c38748828c6aef2904107a683d78c3cfdcd1a4c67abe296"},"target":{"epoch":"50756136","root":"0x64a93c7d57291b8d71b2a53181b48558843b098216463bc8a2cb93bbb2e97381"}},"inclusion_delay":"9068891070998130552","proposer_index":"9067238583486479128"},{"aggregation_bits":"0xb29a50af2560a862efec1c49b39ad050e986e97cbc5293bdd0597c37f7a484d8bfeb7ff5a247f376aad1c4eab25c19faf700975edf3ed2aa19f9eca594c955cc9c8a3606acb756897cd0a39180fff3b81805934acdf2031281f6bb813d59bfec05061da8d0085a999cae327a2a1624f93b779683e8324145266c6413815ec70c3968f03ea9f31d40b68279047991e76b08e9d74df3b9c1fc2c9c5878f63dc263cfedd4bcae3496dd2453ae9d56769f9a130932df387f392dc1ed7510212ae1f33e674639cba4dc8be3f64ba84351d1dfc70d47451883c22a9cf1545bfeffac0404b819039ff5c3f6109e5899fcbb7795df5f3c6433d8e500802a205eefb0520f01","data":{"slot":"9070543554214814681","index":"9062281133836426744","beacon_block_root":"0xc0d1bd7d98a9eaa15ef1c57651f2c1b8faf81ef66a06bac8b3b1c685ee96b195","source":{"epoch":"55373123","root":"0x9a8fc97d58122c18746bf71fa9e0981eeef220d2fe74685457af3ff539d54280"},"target":{"epoch":"54218877","root":"0x0d56a67d18d867b533fd62249f1514ed13051b3e44295db16ab6d4a6581a8fc0"}},"inclusion_delay":"9058976163108091192","proposer_index":"9057323679891407064"},{"aggregation_bits":"0x76b7f289ddf5f2812743b59c43010a310eeb9cde7fd69d2ecf0862ea11a4987c50bb59213c421c6358d3c51651758aa0f18f7fcd553e3a027cc7afc3dd2ab68f6d622ddfaff1d39bd2a874025402e56e9f60791e0df6ea623b612b81265d100b423ba380768d7dfe4008869f1860ea72d0823b2c2f7d60ea56e26bc696a1d5fa2d604fba9c3b5ae6df0f7993162a0fb2bd94e909ec6f018ce78d25b3c9b5f8716d439faae0b2837ffc414ad01bf61f6ce0981446df1cac881f16fa275f70126bf0e546b6a27fabd6a359d5351d77bac87b998dc55f135a1f499168b6ffe850bfa3b4bdbb91b25d8f06d6b1ae994b49ee50afad6527ba92fa52481f5a33bd263201","data":{"slot":"9047408776296335000","index":"9052366230241354680","beacon_block_root":"0x33989a7d586f263f1e83317b47273d87200b1962b0baae25c6b85b370cdcfdd5","source":{"epoch":"46523899","root":"0x0981bb7c16a94b78857385ecb07649f80d7ef30dc185bcc791e560f1773c366d"},"target":{"epoch":"46908647","root":"0xe23ec77cd7118dee9aedb6950965205e0178f5e955f46a5335e3d960c27ac757"}},"inclusion_delay":"8982961905075850230","proposer_index":"8981309417564198806"},{"aggregation_bits":"0xfa7b85cc09d1bc7de0086edacfee48a93582fa085210b394ca854afc8a4f735865f15d5721c9532bdc0341c596bbf206a236dffea27a39752c17d9a13af4f7a8af1296e6ffb8651a87fe07658cd4a1ae24052b0d5c1b7e86d94bb732c3ca60e20f44b813860c230f1ba447117daa701c101f9b7d44acf4f2ec0f69881bcfc042f89486c0258c39bad71a6b07ff6fd10aa489b0cad9f1f3e431ef0ccd406422491fc1dbb262dbc8c9a016ada4be51c22c4c98c3a3c68a390843ab851dc82cdd9dca9cacabdc8f9691e60b4a911310ed17b0eddcc30f79f1b767bbe026c35ba8188207acd9fd028fa6b50a86b7d3bbd0d4d106d1b4f734365c4be7d5b785dacd9801","data":{"slot":"8984614388292534358","index":"8976351967914146422","beacon_block_root":"0xa1898c7c1606469f2e8bbf474dbded603f96eb9d74cb0299ffee7c334a43f1c2","source":{"epoch":"45369652","root":"0x7b47987cd66e87154405f1f0a6abc4c63390ed79083ab124a3ecf5a2958182ad"},"target":{"epoch":"44215405","root":"0xee0d757c9634c3b203975cf59ce03f9558a2e7e54eeea581b6f38a54b3c6ceed"}},"inclusion_delay":"8973047001480778166","proposer_index":"8971394518264094038"},{"aggregation_bits":"0x42603831d7d137a309e921bd4daaf684097e8d81198413e15c480aca9cb7900c9ee35194d09a6f8ead7186ebaa5deef28d45bb0ada87b9aa3eb8f26fdbe5b63ed04fd23c73a72aac1c9720d46d4cd296fa38dde52a5a777ef379facd52bc559e9b95cf06846d6c969bd58ae45a8a78e6d9284281000963ac1862e5f62419f26fde9b75f6bd036c5035489ee6883c120c2fc6f5b7d8780a7cd259bfa23ca2e7f863316509693b1ff33ffb7b7e8d81563f0761ad658267131a49b0fd827669cbebd38d7768c2aa4a25e88b73af86cb5ed5abae51ab65459de2ed8ed9ea36d1d66feac9d3aeddb1f37026c08302f1bfcdd1cd2b2de9cf86e15cd0e0ef9d72c65ab801","data":{"slot":"9014359099077750551","index":"9019316553022770231","beacon_block_root":"0xb12d257dd75798a046be42dfcfd7d78c9d4705caef68deb059d0a1dc1c6d51ac","source":{"epoch":"48832392","root":"0x23f4017d971dd43d0650aee3c50c535bc259ff35351dd30d6cd7368e3ab29dec"},"target":{"epoch":"49217141","root":"0xfdb10d7d578615b41bcadf8c1efb29c1b6530112c98b819910d5affd85f02ed7"}},"inclusion_delay":"9002791712265994359","proposer_index":"9001139229049310231"},{"aggregation_bits":"0x329a5b20563aa2389bd4e18bc407f09b4a4e90e7b7200102ebf85c0a1d6293693d75522a6c7cc5a2ba24538394263be61cbbfc6ea0c369a6ab0a926138a4bca78e1ebfd4697d37a4e9f5cecdc6b3458f172020f3e71f3f0c6c8ba961f9a1e220fdb998360a8e57dff6fee421a476c73256d8f384d78c1cf56ad78b4ee4a0857c59128bb06d079cce5d89ee8dc1179d279d5d940f665ea5e464946472ecb92ac5949a852d47af9bc2096c2a18c17e3330b87b30fe26e90c9be6b7fc32f599098688c2005453eec3c0b217946ecd91c5c60a2630fe47dd640fc0dcbd9756cc2077d20f35ab27f145c3bdfb0e2450df5c08316184591fb1b81b14ad909e8aae5f6c01","data":{"slot":"9004444195482678487","index":"8996181775104290551","beacon_block_root":"0xbcfcd27c977ace64b067e83e6253f7c3f471f7c5e86219dfdae052d00db95842","source":{"epoch":"47678145","root":"0x96bade7c57e30fdbc5e119e8bb41ce29e86bf9a17bd1c76a7edecb3f58f7e92c"},"target":{"epoch":"40367916","root":"0x6ca3ff7b151d35142cd26d592591da9ad5ded34d8d9cd50c4a0bd1f9c35722c4"}},"inclusion_delay":"8939997324262193717","proposer_index":"8938344836750542293"},{"aggregation_bits":"0x0682ef02c167e3bf500533a276c36120817844b632e61bc584993d15dbd87c801a3d67567315c7c4df0b80f525722610d8b6f388c7fe7b317bdcc5e358699cb3d3f730d0382c054eefb8864404cfa18d8eb09cc7bb300eaba1d0527ead9ebe8003417be0c3c13690bcf5f09d4fb62c00e0645b4e2495e6afda63d425ee9cd5d09d6f022338245aace594becd228e8600f1a5d05077683136454e2a84b77bc3bce2f14b7ff784d3f3a93f3cf72c3f5bb0c2f5ecdb7882123ccaf48d891f3ff49d247fd466d7150abd08d4d06f9fbf70bc5cafd374cec78f79d1e4ecd54245d203fc6565f45f029e2abadf4aceb2db32b0812180231a714b103a390a6d0c31a4af01","data":{"slot":"8928429933155470229","index":"8933387387100489909","beacon_block_root":"0x92e5f37b55b4f39d16583cb0cca20335e2e4d171f92d2781a50d588a781991d9","source":{"epoch":"38828921","root":"0x05acd07b157a2f3bd6e9a7b4c2d77e0307f7cbdd3fe21bdeb814ed3b965edd19"},"target":{"epoch":"39213669","root":"0xde69dc7bd5e270b1eb63d95d1ac65569fbf0cdb9d350ca695c1266abe19c6e04"}},"inclusion_delay":"8916862546343714037","proposer_index":"8915210063127029909"},{"aggregation_bits":"0xae794e126bbfe2b4936ab5803c7f1c14426ac1dad4878d2ff0266b41e60b5269e37b52884df24e8cae72c08d32add6548189948d7d34eace04dcafed9fd8942badd23d2633f49e7352da491147f0033cfba8fc866e7584b9670833d284e3492eaaeee75ddc032ad5a99fb24e460e12aab93bbad8f91a71d3b4bebe115670a62b8aceb319ed3ca87a3507dc0c2ff94b02213a95bfedd2ba4467efe0ced7e4a68d643ad2aad9e5ced09d716511eb012c8a4def617bf80e0d1ea4bb84355b5730604c31ee3f5b5de1d90bc807e1b8e4fb93596ed362f96f7696bdb750aedf7c043b9cafc1e4f7c8118803e543461097ab4da7e8d31112886f578d787576f0fce27901","data":{"slot":"8918515029560398165","index":"8963132093590738806","beacon_block_root":"0x3a925d7c166340c6d8a2f9a2ea0392c971aee32d2711496a6df898751d4aac18","source":{"epoch":"43830656","root":"0x1450697cd6cb813cee1c2b4c43f2682f65a8e509ba7ff7f512f611e568883d03"},"target":{"epoch":"42676410","root":"0x8716467c9691bdd9adae96503927e4fd8abadf750034ec5224fda69686cd8943"}},"inclusion_delay":"8959827127157370550","proposer_index":"8958174643940686422"},{"aggregation_bits":"0xe665367ab78a3dd8bfa9dcef5e11d3d9df76e6d6c7c2b07bcbebe3ebd470d4bd1d79fe611b8313c8ec8402a70e3f46c0eee2ec7c85ba2a059e53cc020c08f3b1dbd35f732ee4525105a18d082e4c2ee5f5a70b2a301426604495cc0f96522cd2718e7ad85e315c6870cf1797ccf28a2fb68763aed7f73e8a55f81a4b51cb800cfce30b6b73b6fdd8e357296fb8fa5134aa49e49058d66670d059e1893fab4d3431da3490d0a104a643d58bee5f1d1b9166924f829de521ae6fe02cb6ae9b1ab7a10018b9587457fbfb48ac9f457b380da73eb80dba47c867b1a101469eda4c48cc55d697d9d314460896c6ed658d3654274193dc227eaed766772f5419cdffd401","data":{"slot":"8948259740345614358","index":"8953217194290634038","beacon_block_root":"0xad583a7cd6287c63983465a7e0380d9897c0dd996dc53dc780ff2d273b8ff858","source":{"epoch":"41137414","root":"0x1f1f177c95eeb70057c6d0abd66d8866bcd2d705b37932249206c3d859d44499"},"target":{"epoch":"41522163","root":"0xf9dc227c5557f9766d4002552f5c5fccb0ccd9e146e8e0af37043c48a512d683"}},"inclusion_delay":"9306848752984892798","proposer_index":"9305196274063175966"},{"aggregation_bits":"0xbd6224c819dfdd8f4206268946fefb8e4cce18e5ae9a9a4d26d4a211f08f891684ec85ddcb364a2f9f2bce5c85f4a72fcff268567217fb46aeb17b1fe377c6a92d1c346075436c915d9fdb4c0f83cdd974cf5a9f2c66970dfb4b557123616e2bdbf9b991f72ca1d2e85f0c98d72a9172ddd0341bfd0c7f94be6a68784219e2a9a1cc7dd5feb3925a6aacdfe058f6e80a6bd70d7cd0817de40746c4c3992fe5f41219876562c9ed35206b78978a0c0ac1e0ca79f05eca8cf7d53255a4ed6bfc63cf71a42e5f82c190e73ad92e75a6519c09438a5b1e92518eff975a11a44d86f17d5b3fef286533907d98184f58989013e7740c9800776b31fcc69fd7fc8b143b01","data":{"slot":"9308501240496544222","index":"9300238820118156286","beacon_block_root":"0x02370b819e1f50e46d47b00c46fb345d7745add6d91fc911f407cedf181c8b8e","source":{"epoch":"83075044","root":"0xdcf416815e88915a83c1e1b59fe90bc36a3fafb26c8e779d9905474f635a1c79"},"target":{"epoch":"81920797","root":"0x4ebbf3801e4ecdf742534dba951e87919051a91eb2426cfaab0cdc00819f68b9"}},"inclusion_delay":"9296933853684788030","proposer_index":"9295281370468103902"},{"aggregation_bits":"0x1b4e9eaca358cd2b8829b6d8b76f2399fdc3ff542e18adf2591df54756af021e2afebb18453be50a2c81c6eb7a293354401931022d3549fef481494d62d52be24c642ea563e0bb9187a768dffb0e6f83369bfed92c017c7c2dcbe3513c5180dedc044baf503f8793043930fcc5ce1bdc05af9030fac3cfff44f5570f0e4df1e3c752d2c90aa3d51c8b419e50b7851177a82124305ea31f440aab911805a3bdeb922cce6f4c590e3065298dfe8d0ca9013a4e4da5a3c88dd3cbf1f7cda649a9a501f3abb516b9eace29d54495af9a7caf92d5645d5152d7ba37af4604e0176a4e7c47d9702f6666c9e5f6e27a3f71a8bdfbdbbc890011375b6f87a7cb604e08ab01","data":{"slot":"9285366466873031838","index":"9290323916523084222","beacon_block_root":"0x75fde7805ee58b812cd91b113c30b02b9c57a7421fd4bd6e070f63913661d7ce","source":{"epoch":"86537784","root":"0x84a180811f37de82440c9fa8be4a9a57fa08c16e9a71998661f0873a088b37b8"},"target":{"epoch":"86922533","root":"0x5e5f8c81df9f1ff95a86d051163971bded02c34a2de0471205ee00aa53c9c8a2"}},"inclusion_delay":"9326678564470004223","proposer_index":"9325026076958352799"},{"aggregation_bits":"0x07a3de316cbe44babdfeb9d62275c33491c4b2c8cfff39152dedecef4e222103f720a620038294caa826de081878cefee13cbaa170ec389f6b0c32ef954fe1b24d401c0665775b2fb6f4768865b889716fdbd752f7eabc932a236e36e925f6fd292edb3a5e9dd622b0c59b0260ecb65c82b34c9a0c56b7f0b882a7469d4ca0b7a24272d1a2b811b0ec070c6e42aaa523f2bb793b3787ab24c3b381fe31e7ef3f6173fcdc53bc9c0ea295eeefd7842ad0542dc81dbaac2a681150479b0ee4986a1fcc6913f8aa806830a205fffb2d2b15d3c8612a46205cd032f2a30029a310bc0d5305c49ba43bc15f4951c4dfc58e7387155d77a8b8073ea1aef84ea37b97a501","data":{"slot":"9328331047686688351","index":"9320068631603267711","beacon_block_root":"0x1daa51811f94d8a9ee23d9035b913ec02c21b9fe4db7df57cff9a37cdb91f20d","source":{"epoch":"85383537","root":"0xf7675d81dffc1920049e0aadb37f15261f1bbbdae0258ee373f71cec26d083f8"},"target":{"epoch":"84229291","root":"0x692e3a819ec255bdc32f76b1a9b490f4452db54626da824086feb19d4515d038"}},"inclusion_delay":"9316763660874932159","proposer_index":"9315111177658248031"},{"aggregation_bits":"0x6d994f1eb97346cf4eabc3395c91fe9ffee7ff18ce6cab15e47c9df9bb881acee562faa4a9eb8757c18245549d2d530775b764853683bb4caffa45f1cd5ba99af0f99356bad6d1a798d99e4da6ecfcf7d7cacd63ab4dab268715a00d4c88a049f5da6e3db6d796f8ae645eeaaf29816e650fe0b9e3654d880844f93b965a131244bb6907ab1bf3c9003a882621139e099ed37f46bf509466e36987086ab446c7ff59b49ca196f2feaac0fc141a630250f6a0d68ee8c6a4c35d67dd70b6689451a7ba9abb7e2c5dfd0ea7157f38a08ce583e084b0eb0597c6438cf393bd1be8ce2b38d7d8c27f401a4aad147313092413d72d180dac68346daf08e78d21bf780001","data":{"slot":"9252316789654447389","index":"9257274235009532477","beacon_block_root":"0xf3927280ddcdfde255142d75c5e04a31199493aa5e82edf99a26a93645f22aa5","source":{"epoch":"76534313","root":"0x65594f809d93398014a69879ba15c6ff3fa68d16a436e256ad2d3ee8643777e5"},"target":{"epoch":"76919062","root":"0x3f175b805dfc7af62a20ca2213049d6532a08ff237a590e2512bb757af7508d0"}},"inclusion_delay":"9240749398547723901","proposer_index":"9239096915331039773"},{"aggregation_bits":"0x5f432e22484195a4b732ea5b552d5b3b29e663fe60cc31fe15f4d9a03049dd870714c482950d5cf3cc5e153ebb5faa92ac09f3058db82af1565a05ff345a051eae9cbea4b66c5cbc4cfad010e5ab6f6ea3d2a6347d00c13659ade9a1a7d15de5f3ecac152930adadbfe7df69f3513b9eb9dd517462ba323072d1929d278d23c9d39695093227031e8c992aefe86153004efc1af8e4c23834d4e0118002af2b7bf8f10f5a8cd7c39c14cda8365fb6676fa939c970480f29e23a30f7d0a512a41459aeadd6c108c0d89abb06ae6f70074be4e0c4f4c89f664bafb8057d287f5c121bf2fb92b9d763ced3d79d7ab5b43b1a99c682b7e51fa46a2a693d16d9853bd201","data":{"slot":"9242401881764408029","index":"9234139465680987389","beacon_block_root":"0xfe6120809df033a7bebdd2d4575c6a6871be85a6577c28281b375a2a373e323b","source":{"epoch":"75380066","root":"0xd81f2c805d59751dd437047eb04a41ce64b88782eaead6b3bf34d399827cc325"},"target":{"epoch":"80381802","root":"0xe7c3c4801eabc71eec6a871532652bfac269a1ae6588b2cb1916f84254a6230f"}},"inclusion_delay":"9283713983656347710","proposer_index":"9282061496144696286"},{"aggregation_bits":"0xe770b76f869cdb3ab1eb04749d41c6e639be54733b4809c8a7b8898727a0b2b3d6ac0949f17d13f4aeff973482fa12c68242de753cd57e9f4ccf4021b9c38282c88df8b4e2ae029af62577218c039a97bdee709a21c8c1ec42bd77502ef10a1f253d2fb04b5ed338677e6c907964a24132c8d8187c6bb5ad8fac3e67281f9ce4e73b6613a68952a55ec9dbac3f435024c79769a711de6aa0f75626b5e460ca4e0c336d6184b101e2291c7f8e4862e150eac777810da519ccd807cd4f59fefa5bf4a55146e12c1414fa3b6b94f2e794953965ee99bbb6521a22892e906bbd6ba37b0064e91fec8a664c64b810cee7643733634deae4edf262d164679425d8263601","data":{"slot":"9272146596844591517","index":"9277104046494643902","beacon_block_root":"0x0d06b9805e4286a8d6f0556cd9765494ce6f9fd2d219044075187fd309689224","source":{"epoch":"78842806","root":"0x80cc95801d08c2459682c170cfabcf62f481993e18cef89c881f148527adde64"},"target":{"epoch":"79227555","root":"0x5a8aa180dd7003bcabfcf219289aa6c8e77b9b1aab3ca7282c1d8df472eb6f4f"}},"inclusion_delay":"9260579205737868029","proposer_index":"9258926722521183901"},{"aggregation_bits":"0x9723944e1ea44bc04c94110ed5fce2883facea1fcde8bbe3524eef1d266715bb65aeb97fcf2f8c5cd2e3574c9c42e24243bfc9808f95af2290ef296f2aa2aa1386a85d54e83caa8327a7695c8f340804f0f610d16604a16c944db6f5e5dcbf3a9951bc249c928f7dd2dc2c19769c9c116e5e69bf3de0e8d5f11954cbd8f26495d01add4d5829807e6229fb25787d9fab370e3e6c036c67b6c1bb6d5df86b87f33c92e5a58a82b7db9f9baff2149ca77e59de6a2bcdc83a6c37e0deebd892523ec4f5290bee68dd396d2bf81ff3bc17da0e6dee899c3eebed6ece5aecb1a0be5b5bee64e92626a1b1f5161519e663f5ee7d2bff7f2c5148a375259887fc7076d201","data":{"slot":"9262231688954552157","index":"9201089784167435644","beacon_block_root":"0x7cf7aa7f1cd9a508e7f8e338e00c056eeefa710e952a58b3ae4ea0cf46cf8511","source":{"epoch":"71532577","root":"0x56b5b67fdc41e77efc7215e239fbdbd3e1f473ea2999063f534c193f920d17fc"},"target":{"epoch":"70378330","root":"0xc87b937f9c07231cbc0481e62e3057a207076e566f4dfb9b6553aef0b052633c"}},"inclusion_delay":"9197784817734067388","proposer_index":"9196132330222415964"},{"aggregation_bits":"0xa2ab4074cba90a242bc75eabef189a63f99a074ed432b5a7bfff3f4cc35f6f5662dced8966b212999ae7c01e29776914d74493e5e9a804b555193bfd1bee6a8eeb595a14b1bc29cb1da893d1e1506c4448e5c8cc9060b1783a66acedc123b5016fe95bb25d51aa22485a29f9b15d63b149a2c156c2f3110f75fc03b2d3ce737b3ee114d825ef720dbf15ef259185c4426bf57a21a993f9c4ae61f36af1b9ae288cbdefa41a8adce30b6f7e86cdcdeefeb543140cf31210f73a673d407291c5257116dd2bec3202a653c4f83ea29a9a604f642f15940510810fe3889f81a927bd3482b0375f5dee6cf57a51be84a6dbd6a9a2b23009d1a9365bb3d72d4afe396101","data":{"slot":"9186217430922311195","index":"9191174880572363579","beacon_block_root":"0xefbd877fdb9ee1a5a68a4f3dd641803c130d6c7adcde4c10c15535816514d251","source":{"epoch":"68839335","root":"0x6184647f9b641d43661cbb41cb76fb0a391f66e62293416dd45cca3283591e92"},"target":{"epoch":"69224084","root":"0x3b42707f5bcd5eb97b96ecea2465d2702c1968c2b501f0f8785a43a2ce97af7c"}},"inclusion_delay":"9227529528519283580","proposer_index":"9225877041007632156"},{"aggregation_bits":"0xe3a545f845c4d2af06344a6d2c033acc1db9cacb5fee1daceb0903ae0bc84deaab62d4532486eb753e2041fbca24834a7e501c56b80127b8c3c255c74c6968f629b5e897b420c2f56ff96dde57b40a70d5ac2133db0974126587772953b55e2cd097a8063270929fd082820e955b4e81a7f81512bc9a6d229bd9f6aac90e044123a9d6821c51b60f585749926e6c76150d6c562a23bedcc0245df607d63c5cfa7fe67f5289174b5e7ce01e5e13eb242de4a0b3180ec0b5fe03a6fd52f95bd39cec381b041fa77ea04b7b28e76234e1f23e794ae6a4c58bf082d4edb68099157902b76a49cb1db76273416f0446335bd8c1ffe9ccad580a171749d801bdab033901","data":{"slot":"9229182011735967708","index":"9220919591357579772","beacon_block_root":"0x976af17f9c4d2ece68d50c30f4a20ed1a3d67d3609c26ef98940766c0a45ed90","source":{"epoch":"73841070","root":"0x7128fd7f5cb66f447e4f3ed94d91e53696d07f129d301d852e3eefdb55837e7b"},"target":{"epoch":"72686824","root":"0xe3eed97f1c7cabe13de1a9dd43c66005bce2797ee3e411e24045848d73c8cabb"}},"inclusion_delay":"9217614624924211516","proposer_index":"9215962141707527388"},{"aggregation_bits":"0x42c4fdd07452d040c098cdfe6ed2e2d9af160d80b91e5b3b04d350f06c70c2235d304634be900010cc4a505c24d81214e9fb8116e260c520f5a4360c0f0ac185ca4cba62a3201bf6b7416e7d0b2b6c2e32f1c73b9d2a99e0ff07f3b18a0b77da95665e9cd5d59ad214e59aeb6609c00fbe15b9b57bdddb0cf716a1ce4db12d87b761598c6c59f368b1f62ce783d48f6c53334e66043dae201b56aad62f2824e8db5634710faf2ef195324b36c4eb2cfe812c855153f21858bfbf167f8301232f2a3e11dce732415a87d484dc7c134a41a1ffc06269a1559f6aa7f11cd38ec14064ae06449c1e62b87b0bf7258343c7ba4d41ebfac11655ff04fbe75728763fd401","data":{"slot":"9206047238112455324","index":"9211004687762507708","beacon_block_root":"0x0931ce7f5c136a6b28677834ead7899fc8e877a24f7663569c470b1e288a39d1","source":{"epoch":"64991846","root":"0xdf19ef7e1a4d8fa48e57cca554279610b65b524e604171f8677410d892ea7168"},"target":{"epoch":"65376595","root":"0xb9d7fa7edab5d01aa4d1fd4ead156d76a955542af4af1f840b728947de280353"}},"inclusion_delay":"9141600362597003258","proposer_index":"9139947879380319130"},{"aggregation_bits":"0xfe86a0ca205206b71fd01428789ec2e1153f13f6b0d121a9317730e1fb93f8450f0fc2b18008437a5a98d2e1ed0558b27b6610c4357561461495605bad75a0aa08ff4a5df7396f5496f589037fe56ca79d24b04148533da63e04aa8e28570132fd48050d06d7ad113ea4307505671a7fd3b90975122e60554dbae3b1e0cc233f6a158350dd6790f998c17f1b02b2521ef12a83219953dfa4533063aa6cb5b8b4ef40a02115ec465fca4f55d73d4461bfa730909c60b7b0c0eab60955525ce8680d4bdfc93b010819c2aabb4c52785d8ea959a4680ffba82b9ebd409f5c0d502755139ab7698efa204ff760284c72ec308c2c928fe1bd9d4b1fd405f8d3c57a7d01","data":{"slot":"9143252845813687386","index":"9134990425435299450","beacon_block_root":"0x7822c07e1aaa89cb386f0601f16d3a79e8734ade1387b7c9d57d2c1a65f12cbe","source":{"epoch":"63837599","root":"0x52e0cb7eda12cb414ee937aa4a5c11dfdb6d4cbaa7f565557a7ba589b12fbea8"},"target":{"epoch":"62683352","root":"0xc4a6a87e9ad806df0d7ba3ae40918cad01804626eda95ab28c823a3bcf740ae9"}},"inclusion_delay":"9131685459001931194","proposer_index":"9130032975785247066"},{"aggregation_bits":"0x745029266c6c11ec7a30f70f92b41f0c8e5aac5bfb565cdda71038d6615adffbd02f6a5a9e49325f718810cad1f4444695157cb4ddd864b8c60823243ce4426574d10c017a14b3e8b93e063b86cd525e57a946ea583608ba1518162dbd42364c4cb0daa8e63193a0f391f50d8d1550bc5f97e13d64a14f5d3df6efe77cdd0d260ed8524229d145197a998a5815c1881a684936d6246f1432f09c74cd003e4b0892a26eab9a1ad049374aba081090efad6840be62345436ca2afb34c2ae503a8f84f263db162df9d9822696666eedba18fdea8d047f93943f8a8961460a81eb5315c529ac2d1fd267561d95914723719cc52bd956e12f5f4b50931dd82dc8630e01","data":{"slot":"9172997560893870875","index":"9177955006248955963","beacon_block_root":"0x87c6587fdbfbdbcc50a28998738824a54525640a8e2493e12f5f51c3381b8da7","source":{"epoch":"67300339","root":"0xfa8c357f9bc1176a1034f59c69bd9f736b375e76d4d8873e4266e6745660d9e7"},"target":{"epoch":"67685088","root":"0xd44a417f5b2a59e025ae2646c1ab76d95e316052684736cae6635fe4a19e6ad2"}},"inclusion_delay":"9161430169787147387","proposer_index":"9159777686570463259"},{"aggregation_bits":"0x26e37a76bfbf98c3e44fa37d999b5a504b35901c55f0c33650aa481267bf50380ceddb4ce8aef9f36cd5c0b2c60a3d4254fb4a3567acb415f32d4baadb858bfd28b9e8c1756e78cdfe1c5023959d28cf8a20b69cdb73452e6be059c15e1f0bf12a9d0d98f876aac5a63f051c8329ed56044e783d852cba20c1b244471eb17ca158f1ab5cd0e537a8d66baed15eef0d1f81ccf76db7dd9960c64cae238835be3c000beec63409354d409f6ecf164fe883c75111c11450a9436534366a090a3ee2b61055bc046169fc163a67a7c8f4753f53eac54558a9ecd5d69a9c3880bab3ca151b0cac4e5733d4ed36b89bc317e0550f44436429b1718cc8d8e0c3d6a1275801","data":{"slot":"9163082653003831515","index":"9154820236920410875","beacon_block_root":"0x9395067f9b1e1291b94b2ff8060444dc9d4f5606871ece0fb06f02b72967943d","source":{"epoch":"66146092","root":"0x6d53127f5b875307cfc560a15ef21a42904958e21a8d7c9b546d7b2674a52528"},"target":{"epoch":"911092286","root":"0x8f75966cfaa05bdee8957d48abbcc1f03dcf3b8b347be4b76f2304ab019580e5"}},"inclusion_delay":"7829528113024187930","proposer_index":"7827875629807503802"},{"aggregation_bits":"0xa6a269164f856a9609146afb94353e4c2d498d0cb007f58d92986b5533c3ac9ac7c20e0d1beb5e9d05b9ebabc4a8f2c6eff74ea643f9483f4f068f16a11906e67dea5d9e6c3bd2c6ecd46eba5a6aa99aa75b68b9faa9ce4e3fc8d6551136628804a7c8916baecd63d9ceb03280eb3d942737693f3f6caa9370f4bd855559911dce78807b487758791a385eaac25fc87c8d0096351d7999507cc044e87fc6d315b5baaa200968a7d0b3df5f4a0d992e25f3176396446aa1cfde461e4a188dd9506048c50b83698378e2058bdd7fcf70e17f5df5de25b0de0e7de403b949b0995eb78e8edbc2f585bc4a0243f8b16c80287323473cae87a1a4cc85f84b3cbd493b01","data":{"slot":"7817960721917464442","index":"7822918175862484122","beacon_block_root":"0xb5b78a6c3a381a68d21b4c9f52ceea8a49d539afa00c362cca258b3bb656effa","source":{"epoch":"909553290","root":"0x287e676cfafd550591adb7a3480366596fe7331be6c02a89dd2c20edd49b3b3b"},"target":{"epoch":"909938039","root":"0x023c736cba66977ba727e94ca1f13cbf62e135f77a2fd914812a995c1fdacc25"}},"inclusion_delay":"7806393335105708249","proposer_index":"7804740851889024121"},{"aggregation_bits":"0xd4724a668c9236f8a9b8f8809699927bec4a3b2017232776e7284b8bbc32a27f65047577a52b47bd0aa1bad7d4c443d33847d3c36869d9023817e79940282e7f839bf02ee78d7cee71b619a749347f2926418babbce9845ee8320ff0da63ddefe8881ab9f4ca94c6acbaa2e01f93206c3d6198bc6ce175ec0ceca62719196bda785d3c35b0670aee360b6ca999314bf33c9bf3c8c7cf70425e528fad67df96a3e35e2a67275192f1a6604a8c40264b0b4c4c6e08c07e2f6d0ec10c2f4a461d1f16133a000c2d4a7db5888c0ebc1cf9def35fd5d81208aecb9183c3c6d59bc52bc74cbed7ff2d262ff329ca7296c0511041c9e54a0e7fb9a758880bd1a0370bc901","data":{"slot":"7808045818322392377","index":"7852662886647700315","beacon_block_root":"0x5d64f46cfbe6669094660992712f791fd99e4b6bceef57159210cc265b870a3a","source":{"epoch":"914555026","root":"0x3722006dbb4fa806a9e03a3bca1d5085cc984d47615e06a1370e4596a6c59b24"},"target":{"epoch":"913400779","root":"0xaae8dc6c7a15e4a36972a63fbf52cb53f2aa47b3a712fbfd4915da47c50ae864"}},"inclusion_delay":"7849357920214332058","proposer_index":"7847705436997647930"},{"aggregation_bits":"0x4ce3f38b50aef8aaf65cbdee75fb4ef6f3630ea15d674743e5f55be98ceec4ebfc363dfc174802782a2f7b79cd443b078130fb3307808be0aa9216e6cdbb39ef798e947f3c89a05986a8a7d6b01949f0bc47fd5fc0ad98c4caa880075371681b76680dbeb638faf3f5fd033015ef8abbd0d353bc644472e67c9cb3d1af0ec4534c98cf0344efdb5e64db9c604e029085b7fca275b2d7cfd8e9f5a0d7cf5f799c15d848cc2d1d58832901e45242b23d14033040daa08d29215f70347db50b3f59db92d2d6cc08d689b595b730b08f1809a5cc9cbe5020d81219b8daabd5171b3be71639a871344ec9484bc7dbfe89895c534614d724a87fa7b3cdfd771b6a1e2601","data":{"slot":"7837790529107608570","index":"7842747983052628250","beacon_block_root":"0xd02ad16cbaaca22d53f874966764f4edfeb045d714a44c72a51761d879cc567a","source":{"epoch":"911861784","root":"0x43f1ad6c7a72deca138ae09a5c996fbc24c33f435a5841cfb71ef6899811a3ba"},"target":{"epoch":"912246532","root":"0x1cafb96c3adb1f4128041244b587462217bd411feec6ef5a5c1c6ff9e34f34a5"}},"inclusion_delay":"7773343657887123801","proposer_index":"7771691174670439673"},{"aggregation_bits":"0xa2e594d490aeb715744b64217bb74ee6c96e4065f041b98bde48637c1b05be8f2a1f789159d2277685f2f96805f2038847efc805dfd58ab44b8bc134e7aecc8aff9e6d5d78b594f9efad50e594de497c1a1a397401c05e002a8ade1ce7221cb1b74e062b5e28ad9e4e364bac647d90c538cfa56c4f95e39e5eb459df2c1d41639bee963371dbbc0f6f6ae8942736ee45afe9a93ea719be70a79211ac4888c1a5c66ff490aedc6c7c74727fb2f759e056a1b4973b957a05f91fc50e921046d4e9e8ff89eb74fae9ccf27fc9d6ad640f459b68912530725fb73db3f2b8a8b46b98861bb04a1624bcf2e43ef44273b813a6123f6f8ac60abb13aaea2bdeefc87f2301","data":{"slot":"7774996141103807929","index":"7766733725020387288","beacon_block_root":"0x3f1cc36b7843c28d640003636efaa4c71e3c1813d8b4a0e5de4d82d4b7334a67","source":{"epoch":"904551554","root":"0x18dace6b38ac03047a7a340cc6e87b2d11361aef6b234f71834bfb430272db51"},"target":{"epoch":"903397308","root":"0x8ba0ab6bf8713fa1390ca010bc1df7fb3748145bb1d743ce955290f520b72792"}},"inclusion_delay":"7763428754292051736","proposer_index":"7761776271075367608"},{"aggregation_bits":"0x2481a6b82c1921fe3d74457123a61af53b61d59e7251ee2aa5b96d22ffa5b96b444d5b76d6c60b527e18e1cf62cfd0dfc60093851cd5f0003fd5b17e6eb44de33a5612996d5101e93df51146f84e0f03e84edd7043c5b170803c4ab49c92370df0bbf819b1ad81f9a8d1554916875f43e91a4c9208da7fb1cac7160870ca6779b43239f784dbe9f8c507a961e8dc16a4099e8172891fbcd0c0d228e3b546f1b0465a9b98b0568d83afc0afdb88c1c28bd2a4a1b67a7e3459979444b8d955052fbef912564db3d413f7e7745df0f2647612ec5f33ff9ecb8b35da6ec475879f2dadb68cf253cf2b8bf4740467b7c03b75158df54fe24aecfb380a10ca639c015a01","data":{"slot":"7751861363185328248","index":"7756818817130347928","beacon_block_root":"0xb1e29f6b3809fe2a23926e67632f2096434e127f1e699542f1541786d57896a7","source":{"epoch":"908014295","root":"0xc186386cf95a502c3bc5f1fee5490ac2a1ff2bab9906715a4b363c2fa7a2f690"},"target":{"epoch":"908399043","root":"0x9a44446cb9c391a2513f23a83e38e12794f92d872c751fe6ef33b59ef2e0877b"}},"inclusion_delay":"7793173465077267929","proposer_index":"7791520981860583801"},{"aggregation_bits":"0x488e4734b7576071c98bcb6ce6f5f65f9f44d01d38b75204f9097502876b02f211fb446c91f6f3bbfed7eb3e2617620968101884dd59cae7291ececcba3cf397d9a2023e6ac5c3c617f4ad192ebb0ff5610fa4b198a4359a854e40450cc6de2e41d23eaace8bcb4e5729bcc6b3b9267b6e089d94f8b50bf8c0a8d641974e367f18621d5b3c771d7ee3d13b5e3d6fa2f05727bf7919b7f9b013c93823804ae32c6505cb2baff8163ffe2dce0218188a5680d745067119907a86b5342d37d022f2a78c54b4ba13bc2d26eb776b60690bf4e1f17b4868504279b4851fa91cb36df5de032748c7ff72c5526e39c974559dd237d815798e875fde7da6cfd7a039212601","data":{"slot":"7794825948293952057","index":"7786563527915564121","beacon_block_root":"0x598f096cf9b74a53e5dc2b5a8290ae2ad317243b4c4cb72bb93f58717aa9b1e6","source":{"epoch":"906860048","root":"0x334d156cb9208cc9fb565d03db7e8590c6112617dfba65b75e3dd1e0c5e742d1"},"target":{"epoch":"905705801","root":"0xa613f26b79e6c766bae8c807d1b3005fec232083256f5a1470446692e42c8f11"}},"inclusion_delay":"7783258561482195865","proposer_index":"7781606078265511737"},{"aggregation_bits":"0x6616ff0e625ea85583de9980d9b1e6b4590535500034c8d416580c3442070939059150ca602f791f137e34589fe3b8c7b80acc73bb64c0306cc8f9d6dc328bd886dbad7a3f2451de33fb55d060e42b53d91fde88c6cb264c404dbf3888f3fe533b5fd3bd8b43a8d50d8539be7b3bc5d908b0117e0facf1e6c09f1859997204c8769316e345f2de1da8e00f525fdf185213dc9954a9c277623b12b6b59b93427c2b2f056b3ad375036e5dde7d6c3a68d67f1c38072bf22ecd8692c627ef44948d023da3243d645ab0b81467e321cc9626b2f896d7c1e4895b85cc4e1a28aa95aff86ae3f7f6041d7855227e7a5298b5c027497b87aa47bc4f7d30d20ca7ed5e9101","data":{"slot":"7718811685966743799","index":"7723769139911763479","beacon_block_root":"0x2f782a6bb7f16f8c4ccd7fcbecdfba9bc08afee65d17c5cd846c5d2be509ea7d","source":{"epoch":"898010823","root":"0xa23e076b77b7ab290b5febcfe214366ae69cf852a3cbb92a9773f2dc034f36be"},"target":{"epoch":"898395572","root":"0x7cfc126b3720ed9f21d91c793a030dd0d996fa2e363a68b63b716b4c4e8dc7a8"}},"inclusion_delay":"7707244299154987607","proposer_index":"7705591815938303479"},{"aggregation_bits":"0x7425d61ee6e4a96f206719f3d80e6a93c7420936c6367e21e1ca42c17bc88e34ad07774c22787212dc877420829c29f36f0250668022111df4f8a95839038d5bdc7e809231deed50a6aa0a9143f0ffe09d97bddf19264c0e17d5ccd671e46174563501a59826b050181ddbfd62857a8751608069d42326be36c2f78e4bda3101e1b6abad3c4a29c28a531d5dd69194dbeb45ecf2b37e9a90899a7ccf83802740b1a7adac3143132b50748f0b62c50df8e84325a4cbbfb0ce7c55c0aad9be5cfb62f44037a420d6b4ef9414a63014379837e0ee86e6fe70f2a98fe0f4a0a3c9fbc8eed4f20f0e3e8fee5937f37714283d7401d9b302f204aa7c792b1f1ac75a4501","data":{"slot":"7708896782371671735","index":"7700634366288251095","beacon_block_root":"0x3b47d86a7714a650b576252b7f5bdad218b5f0e2561100fc057d0e1fd655f113","source":{"epoch":"896856576","root":"0x1405e46a377de7c6cbf056d4d749b1380baff2bee97fae87aa7a878e219482fe"},"target":{"epoch":"901858312","root":"0x24a97c6bf8ce39c8e323da6b59649b6469600ceb641d8a9f045cac37f3bde2e7"}},"inclusion_delay":"7750208884263611416","proposer_index":"7748556401046927288"},{"aggregation_bits":"0xfe772f62b89f77356da656dd5808d70e7fbe7e8bc55142506d14c8fecd68a1a0723f7b272a0d6fd5357bb68a9e4cf50706557cd6a8ad81e32855f0068884b8818cced5ca2cf8b3e3d8b3fc9c2a57663b82185b7b4dcf4cd2a984e179e23234ccd9c1dc021ad4de61c09e0aa0e8676a77de076abffc9a39a34787e34d660d473c9519199b2be67c69400bcc9864925e7b603add840666303c6d2cfd687541d6f3c9454b9639b78b31ff8719f5c37f13d99e3f1b5a8611b4068be2f6b864d552cb0b472cf133452940ee043b08af07d64e4873fde295464e2761e89319fd2513c8887251ed219507c45563f218454fffa6652c046e220842822b28b711249a4f7d01","data":{"slot":"7738641493156887928","index":"7743598947101907608","beacon_block_root":"0x4aeb706b3866f851cda9a8c20076c4fe75660a0fd1aedb135f5e33c8a87f51fd","source":{"epoch":"900319317","root":"0xbdb14d6bf82b34ef8d3b14c7f6aa3fcd9b78047b1763d0707265c879c6c49d3d"},"target":{"epoch":"900704065","root":"0x966f596bb8947565a2b545704f9916338e720657aad17efc166341e912032f28"}},"inclusion_delay":"7727074106345131735","proposer_index":"7725421623128447607"},{"aggregation_bits":"0x8ccc0c5ad10d393afbd9c8a6513dd3a0bcacabdca295d0bfa2eebe3ccde42650865369b91ccbe2f72e22643098314482c9a56bd2107751cc11e191986f57b200d0ba28682746d8efcfd983cd2913f980ae22332a03826ec8bebcfe9403afcbebb5ea09960596d394f426692ba5c3d5a986e790b98f234cdbb81a0bf9f1b5741f203aaed5d2c68c9e24ebec9125a9ddf8d003983e14d0d8324de77c300bca8fc92ae4d21b14a24c02da824c9309c146f0c004a7f92e7cb96ce105e515ee2fb2a4712b9648ab01a2453d08e84bea9f5d218d7195e3b25cf7bce8aa3a67349d4116c8ac43ef49cde673ec18ff10f0e2265bcb43a31dea789244ab012d16ff130c4b01","data":{"slot":"7728726593856783159","index":"7667584689069666646","beacon_block_root":"0xb9dc626af6fc17b2deb1368f070c75d895f1dc4a95bf2f87989454c4e5e644ea","source":{"epoch":"893009087","root":"0x929a6e6ab6655928f32b683860fa4b3e88ebde26282ede123d92cd333125d6d4"},"target":{"epoch":"891854841","root":"0x05614b6a762b95c5b3bdd33c562fc70caefdd8926ee2d26f509962e54f6a2215"}},"inclusion_delay":"7664279718341331094","proposer_index":"7662627235124646966"},{"aggregation_bits":"0xa6d234500400b2af7c8a34522a30030f77b86fafa2c2de7fe57bde012a4e5ca9060f5d45980347e9430fb71039c51df9196f3516c558735fdd33d792abbbc8ed9c1b6720fefa963762dc4944aa488dc056906b37fe2671627b0929ca15009b9642167201c451a14fed36eceb425a271aa10e3453501e8553c1eee684fe8944a384d93f6f3b024ad3f9d7fa918f504e198c699c2bbc659b546f7f7895411ac2f35ccb1c51f74d5e325bd25e6de032c470748b9a5e7cb6b3ebe103421f0eaf6dfbcd3c40e82f7a4bdacff3a8a39b5a2bb3df5b6c7c1bb80cbecdc22d34809d17ecc696c79f6306cf8eba7dabb7ee267a496067c936eeaad1f689b762c5cad0dbfa01","data":{"slot":"7652712327234607606","index":"7657669781179627286","beacon_block_root":"0x2ba33f6ab6c2534f9d43a293fd40f0a6ba03d7b6db7324e4ab9be975042c912a","source":{"epoch":"890315845","root":"0x9e691c6a75888fec5dd50d98f3756b75e015d12221281941bea27e272271dd6a"},"target":{"epoch":"890700594","root":"0x7827286a36f1d062724f3f414c6442dbd30fd3feb496c7cc62a0f7966daf6e55"}},"inclusion_delay":"7694024429126547287","proposer_index":"7692371945909863159"},{"aggregation_bits":"0xea7edfec57e1ba3e41713855b9222fa59b9ba20382a7de7339a7d2cb80873eb84bc1661dee3b963ca1f025ef781f0ce9bf4dbf3519c4b2584a9eafb45f1932957fb3e78bba74709cc1e3c643b4f14e5d0bd932d8a6eff99cfeeb2b98f344e3e77dae0db66576caf27b6aa55f644d4f5e0355bc1188e35d0cfde3070dc58d160fd189b947937abaeb5f897ea6123ff82eeef3a108a4041f54b427e968661540633b9c4ba5b41b948d287b393d3bbaccab8c5c1eca45f215f852c3c628861e6e16d56a2a8bc4d9616e7e7afad37be11931bc6e48918c04d54544bdd0353d816116f3e74d7fb5c45a80424ad589acb2c86501b9a9c08e05e3b74dd0ed103be960e001","data":{"slot":"7695676912343231415","index":"7687414491964843478","beacon_block_root":"0xd34fa96a7671a0775f8e5f861ca27e3b4acde872085746cd73862a61a95cac69","source":{"epoch":"895317581","root":"0xad0db56a37dae1ed7508912f759055a13dc7ea4e9cc5f4581884a3d0f49a3d54"},"target":{"epoch":"894163334","root":"0x20d4916af69f1d8b349afc336ac5d06f63d9e4bae279e9b52a8b388212e08994"}},"inclusion_delay":"7684109525531475222","proposer_index":"7682457042314791094"},{"aggregation_bits":"0x6c33e5cceba12efa87ccbd074bb1f1f62a928f404367b8e3f2b7c19da5f7f48075db44b864743e495c8a25404632dd3827f207a655e632cc12a28e215febd9f69c5edc5aa892a18a0b1384c8c069e0aa4dbdfcd0a4a210ecd66bffb86c480d0978d9fb0c40d3c6bdb51d9dfad79e80b47eaa479acf0c6f264f3402d805de015de5513607e632edefb7353b43dd0401b3f507a86412c95db47b2e9d2bff89787f9f2002a692af8d6c912bc91793bbde75d6ec29c29ad1801868596d80b92d9bf11b6aac1da01b163e97e754580757630221d28201430a49722dd5cc955d52be29975ea0c0a9c787f8fa242face963f43fdb07b2900e650d18dadbd7dae7b44e5c01","data":{"slot":"7672542134424751734","index":"7677499588369771414","beacon_block_root":"0x4616866a3637dc141e20cb8a12d7f9096fdfe2de4f0b3b2a868dbf12c7a1f8a9","source":{"epoch":"935716215","root":"0x02ec856fffd0b56e4a1bdc94db527d661d4cba8b082080a38c8c4389d127d089"},"target":{"epoch":"936100964","root":"0xdca9916fbf39f7e460950d3e334154cc1046bc679b8e2e2f318abcf81c666174"}},"inclusion_delay":"8031131155653964767","proposer_index":"8029478668142313343"},{"aggregation_bits":"0x0655371adb725ecd26494168425cdf84b80e7b89627dc3100f7de021a018222fea52a15fe887626a8729a8830dd75c4c52e2fdea300fd110285c287ab485587e38310755ab74b9dd13bbb384e1a111b4cc85fc7f88cbe181317e030153ff47fb8fae02c1e974b3442bb400dccebf9b67ddabbf2c29932639e4aaca881a0d73e03e6601bceb358a2f37cdcd9eb448bce705bb25ccba5f16602ab58cc1dc7ae8bf282ed07a67543276f28f1a2856f3553f46549bed5bdf3d23cac33c1fffd94d4477d999b64e65b1fd2ca790a38308cd8383af3dd2e710c05cf3a197f347da87941ff0678d5071c08dacabcd1ed666fe406b77059de56858bfcf6c67dbb202938f01","data":{"slot":"8032783634575681599","index":"8024521218492260959","beacon_block_root":"0x9bf4566fff2db095f43216f0789921cf4f64b21bba65c674fa955fcba42e8bdf","source":{"epoch":"934561969","root":"0x75b2626fbf96f10b09ad4799d087f834425eb4f74ed474009f93d83aef6c1cca"},"target":{"epoch":"933407722","root":"0xe7783f6f7f5c2da9c93eb39dc6bc73036870ae639488695db19a6dec0db2680a"}},"inclusion_delay":"8021216247763925407","proposer_index":"8019563764547241279"},{"aggregation_bits":"0x1e6c2f7387c190dd62ad2e0439525029a02544ed19fb6be1a011281fba6a2def09402785d6f6afef67122a89020383c97b95d99e5fc085febad35c167d9e89b0de00510ce0f3756800d635fd8809064dd6c9a2df7eab40598b201a3edbc1220513de99c44fdafdf1d2ade52f44fb4368bac154485702632195f0c63383b0457f2847d2aa70c8da9db1953c6ba32b6e631dec70e74d57aef8c9232be6c0ba0b82d5ce12616da4ac0cfc3eddb6f523ca287a2b372d5a3445fd0a68040109905727dee066a408616e696ea7a9995e9c3a05d39dbbfe84bc74685281ce1a04572c2777af72db5deaadc09a9119a5e564e905311a5e40d5db9cbf8429bff90d40869a01","data":{"slot":"8062528349655865088","index":"8067485799305917472","beacon_block_root":"0xaa98ef6fc07f02970c669987f9b30bfbac15cc473503a28c547784747658ebc8","source":{"epoch":"938024709","root":"0x1d5fcc6f80453e34cbf7048cefe886c9d227c6b37bb796e9677e1926949d3709"},"target":{"epoch":"938409458","root":"0xf71cd86f40ae7faae171363548d75d2fc521c88f0f2645750b7c9295dfdbc8f3"}},"inclusion_delay":"8050960958549141599","proposer_index":"8049308475332457471"},{"aggregation_bits":"0xecb5cd42319bc5aadd93db3f314ee43f6f2459e35f59698c44335e993fa40a3eeb069cb3e835b0c2ac2e6ae10c701b8d442c7d7be08b94c3c7e7319a8ef783231065f7efeb3cce40ddf43acc8b3cd5def691418813ce0b5bf49c5dc2509fd7206d7b4afd4097d5f4e30e21be9843fc98a29ced0f1495fe5c6b672dd4815831fcbfe26efc81fd096b994d5e06a014e7c83d7d11081dc95162fec2e17c50a14636c54d8a9b4271496f68ff8d709dfaaf16e6731af23e388fdc6faf04a01a78334ae4b65d810145e10cfd3b6e595d08f5ba7c1cd3efb382cd077a86eaf6d3ddf8db47f0f18bc7a08a632dea10ad530876bcff11f45b1567a47c182046e2d326c4e801","data":{"slot":"8052613441765825727","index":"8044351025682405087","beacon_block_root":"0xb6679d6f7fa2385b750f3fe78c2f2b320440be432efddcbad587356867a4f25e","source":{"epoch":"936870462","root":"0x9025a96f3f0b7ad18b897090e51d0298f739c01fc16b8b467985aed7b2e28349"},"target":{"epoch":"929560233","root":"0x650eca6efe449f0af179c4014f6d0e09e5ac9acbd33699e845b2b3911d43bce0"}},"inclusion_delay":"7988166570545340958","proposer_index":"7986514083033689534"},{"aggregation_bits":"0xd69f5064a36645cdeac4bc99c96adc8008278c1276c3668c89683fccca06a5f7cd5e891e5378024451007db2ad06587336a7b11f14b6b7440f977798de382becffd4f3a630e050a8f9f9d045894a60da2e829fb56fe399cd59a992ad342a811b96bf756b0d77b46fbd8f954635c0037015e04ba7fbae04665381ebac8d66e24359a9846ef49dfabb50510a424ca55a08e18f177797dcf590d458ef8b0e71cf8c55224283f35f7b1e7a2e9e9dd58cd59618bf60d1e0c3051e469cf6cea0de2d353a53882307cb2c53ce986af01ee05268243138709b461eb35bca3a41f7d62821618bf5b0b65bf1aa7a8f5543e3241c647f0b119019af4ff3bea60a0067a3035d01","data":{"slot":"7976599183733584766","index":"7981556637678604446","beacon_block_root":"0x8c50be6e3edc5d94dcff9258f67e37a3f1b298ef3fc8ea5ca0b43a22d2042bf6","source":{"epoch":"928021237","root":"0xfe169b6efda199319b91fe5cecb3b27117c5925b857cdfb9b3bbcfd3f0497736"},"target":{"epoch":"928405986","root":"0xd8d4a66ebe0adba7b10b300644a289d70abf943719eb8d4557b948433b880821"}},"inclusion_delay":"7965031796921828573","proposer_index":"7963379313705144445"},{"aggregation_bits":"0xd4056934ad2c04b7d277a9b24187babc8f260a56f472f7e31cfa68d6c8ef2ebe6dd4be1165ba5becdc582fcbaaf9e1777117349bef767238d2ab16d6a9c93b67a9bd3416e83ee9b546de9e5082afb301938879ceaaa6f2dfaf519351bddf3a3eba9da77737b2abfae427d7c5687c2b24bbd3ba413a01f30ea8182e05639992966e0c3864018d2b20f8d328d50ddb03a7011a529722d852c2669565c846fa0a7056c915cedc4a1d2fceb0cafbb733b89937c7fff7c4898ab5adc3f065b4a42d72814c7f5b15e7c5971d046fc10578d9432b3c3a7bbc1ce719368c46bfebed3db7010d45f107535b3941f49c61504885d9f041a3c1099033145df79712bd285aef01","data":{"slot":"7966684275843545405","index":"8011301348463820638","beacon_block_root":"0x34fd276ffe8aaabc9e4a504b15e0c537817caaab6dab0c46689f7b0d77354635","source":{"epoch":"933022973","root":"0x0ebb336fbef3eb32b3c481f46dce9c9d7476ac87001abbd10d9df47cc273d71f"},"target":{"epoch":"931868726","root":"0x8081106f7eb927d07356edf86303186c9a88a6f346ceaf2e1fa4892ee0b82360"}},"inclusion_delay":"8007996377735485086","proposer_index":"8006343894518800958"},{"aggregation_bits":"0x5a5ee0ccf18bdaad139767dccae36471df4d2d7fbfa5c8d29e3669f1f6270d0e82de32fa9b8abe8936a7a9e09669b9b3197051eb85fb76d7d2240b1a8b63c8b5dd8053c824b8e75711233da96303a4f819c60760b4c5734786420cef3e6f2bc02568b84095d4c4afa4b572dcf280a1d652ed712540bcec01dd4938da741fad9e5a0deb36bc1d7bd90e8bd9e0dafd10b198597132785093f4c0216eb682f3ff0522995374d63c8631d1701d25048f868678d0d18d04b0a6e9e7f89d71496a4b790c6da5dc18ef75771d045659d1620cd8deb855155664d3cd1eff6356284186c4200312ae25d039ee54f6d9f0605812c0cb65e4585920f13469a28f3a426507fb01","data":{"slot":"7996428990923728894","index":"8001386440573781278","beacon_block_root":"0xa6c3046fbe50e6595ddcbb4f0a154106a68ea417b35f01a37ba610bf957a9275","source":{"epoch":"930329731","root":"0x198ae16e7e1622f71c6e2754004abcd4cca09e83f913f6ff8eada570b3bfdeb5"},"target":{"epoch":"930714480","root":"0xf347ed6e3e7f636d32e858fd5938933abf9aa05f8c82a48b32ab1ee0fefd6fa0"}},"inclusion_delay":"7931982119703244124","proposer_index":"7930329632191592700"},{"aggregation_bits":"0xa692b1c8310b8d58ec97ba11082c666cec46439a1242f28b819a1160e58847ee2080b76497026be5916f6e194fbf813d0d9f723ef8eada0280fc4e3e09aeb9b01e30e3e17024398748a4ca9a9beda17db7dbae1f356827834e59407cc93c7b2c4303a39dcd50bed00f73395213e2fbf6b3708fed29477059cfe49a445766b02e8fed27a604a10c61059d987ef9ca6c59bb402a7507ecf1f08d47ffdb284d717c32ffdf23ddf7e1a22d0bf35d24405bc4d6dce444bb07a421be5dc2da0c37349c2c0cce09f06e6c3552f6280bbc02bbce572c9c9e20060661cab7d24536e21eaf91760bc86248e9a4f0a36add69b0a9e21e9db926e1a274b6721d5595a8d2064501","data":{"slot":"7933634598624960957","index":"7925372182541540316","beacon_block_root":"0x15b5f66d7ce705ba6ee4491c11abf1dfc619775377705516b4dc31bbd2e18562","source":{"epoch":"923019502","root":"0xef72026e3c504730835e7bc56a99c845b913792f0adf03a259daaa2a1e20174d"},"target":{"epoch":"921865255","root":"0x6139df6dfc1583cd43f0e6c960ce4314df25739b5093f8fe6be13fdc3c65638d"}},"inclusion_delay":"7922067211813204764","proposer_index":"7920414728596520636"},{"aggregation_bits":"0x02fe9beec59c1b372aab15c7bebfbc6d0f4af4419084e41e06cb5f3e92c8f86e4ed884081d05169062d16efeb160506f1e501c69fa8a3c7aa7e4289c88556859fc5ad52077a2c880ba1c9f314f04d67f710f6e17150dcaf3c4dfb65c7309c4dc263e45b74371bdf5c19425b728b879397b8c6e4a6e38d1527f309f018adaa3242bf3b8a434296a27ef55fd0a74238491643fb219533b91448252a3a091d97b61b24994735b470021c3195e1d25c07938313ec089fe05b181649e69f4632d7743ea0e419e1cdd53ebd75b9190a536c4b9c99897986d4ad05603d5ce6f63f1c290feed865d23473dbcc5eb10fe0c48b7ad8825b354f5d30e48283d6ac1340f3a7c01","data":{"slot":"7910499825001448572","index":"7915457278946468252","beacon_block_root":"0x887bd36d3cad41572d76b52007e06caeeb2b71bfbd244a73c7e3c66cf126d2a2","source":{"epoch":"926482242","root":"0x971f6c6efdfe935845a938b889fa56da49dd8aeb38c2258b21c5eb15c350328c"},"target":{"epoch":"926866991","root":"0x71dd776ebd67d5ce5b236a61e1e82d403cd78cc7cb30d416c5c264850e8fc376"}},"inclusion_delay":"7951811922598420957","proposer_index":"7950159439381736829"},{"aggregation_bits":"0x4ef340600ee252ac2770294c29f91cd7eb68e1f1f7437059c253619aba262e576304afc0dfb5ef61a22a7c1d523ac9adb340dbca781617d565e957be5fde82a93e24450b63260bba225da3f6d1b6861dcccf77f9efec469d8339260dab3bb3ff91c6abe0f8f39c5053688b22c6b64c58ec97b428bc45bc0c630cde58cd1bff104f212aee0cb5af1d291d4fb6839622e4c2a40e19e972b7341918b246b6dd6df1d1c401c05d939a9d96bd7cd5de0de9456bff541d0fe504fabc1d7d65eba0529e545303beef4e3bc5846ed4a24184fb7fbda5f0e657a24ab58aaa2e47e345f44a011498beb71124f2e2c3ee6e86dc2107a9f982e219efb0596c55340ceb361de601","data":{"slot":"7953464405815105085","index":"7945201989731684445","beacon_block_root":"0x30283d6efd5b8e7fefc072132641fb427bf5827beb076c5c8fce07589657ede1","source":{"epoch":"925327995","root":"0x0ae6486ebdc4cff5053ba4bc7e2fd2a86eef84577e761ae834cc80c7e1957ecc"},"target":{"epoch":"924173748","root":"0x7cac256e7d8a0b93c4cc0fc174644d7794017fc3c42a0f4546d31579ffdaca0c"}},"inclusion_delay":"7941897019003348893","proposer_index":"7940244535786664765"},{"aggregation_bits":"0x7e6fc80cd9a29a9ae033c7f6d689457c22f6b400e6f46ad1ad8ab5bd1feac03ec15c8b2d8dff655fc7c7af21f25e163721db106e9c3b9f42853e10110f17eba273d743532b95419a2472c33792d6e21b5456696592055188260779108fdc95064f104433299bbccf48ccced24176cba95b2b3ac74b7c568471ca9a61c225cdb5a882a27e2111dd72e601debe222d910f1e5dcabf63f55a765b827cf0fc0fc6d98d2b4f9489dafabc04ee772ab73fd3458c347b3a950f8a15b6084a6b53242fa54ce6f61cf900e11c9699940ab0c844adf98c5b7c0f20948fe3ca7fb5d6ec64b19f2e88e5ee6ea827e6ffa8c168120b8c084989a81d6f63ee3ad32a457cf347f701","data":{"slot":"7877450147782864123","index":"7882407601727883803","beacon_block_root":"0x06115e6dbb95b3b856b1c684909007b468685d27fcd279fe5afb0c1200b82579","source":{"epoch":"916478770","root":"0x78d73a6d7b5bef551543328985c582828e7a579342876e5b6d02a2c31efd71b9"},"target":{"epoch":"916863519","root":"0x5295466d3bc430cc2bbd6332deb359e88174596fd5f51ce711001b336a3b03a4"}},"inclusion_delay":"7865882760971107931","proposer_index":"7864230277754423803"},{"aggregation_bits":"0x4691bb510e5587b057bd53c17db5c04a63ff38cc4670fa305a3b53d58a0d437f333eb81b6b3bfe5bc21efd1bf1b1a373e672974e274d4e1fb03f703afcf2fa250df2c7a3316faaaf99c1854f99e1d088384e03f0d64c3b8cf0bdfcb850c420e1811d960b165e874a75449e499dce5069d7d6ab4012d92dfb81573f89b2d8f24e7ea31e38da218ea5c0836d35414e12812ec68f14534b246c694333b08a9489e94038961682e9cf9d10a537ccf548b66a1748e631e5021537fd4f09e2416e696af6ab0d54eb64395d4715d3eb35d087875e8d33017818612486c88b498ed5304c8ff82ef557a643905fd42168cd9e9661e02b5b1a555aaf2de49af57487dc033001","data":{"slot":"7867535239892824763","index":"7859272823809404123","beacon_block_root":"0x11e00b6d7bb8e97cbf5a6ce4220c27ebc0924f23f5ccb42cdb0bbe05f2032d0f","source":{"epoch":"915324524","root":"0xeb9d176d3b212bf3d5d49d8d7bfafd50b38c51ff883b63b8800937753d42bef9"},"target":{"epoch":"920326259","root":"0xfa41b06dfc727df4ed072125fd14e87c113e6b2b03d93ed0daea5b1e0f6c1ee3"}},"inclusion_delay":"7908847341784764444","proposer_index":"7907194858568080316"},{"aggregation_bits":"0xbe0c323c9e5869fc1b7d14ad97d37d8f7d9e5f6c07b19045d6f69ee2f19568cfc88c10d1e558b39ea1a23f35c9f177b64e05f33e0da23ed862a261db7666ecbb7bf3a379f46b7481ce1e6ef378edae332730f11098c23b12ede76741c5ec579d1dc5493cf829813fa0537bd586bafce73ca8402a38789e60f5323f573cc8be618b4eaf2eb29d5c0e2a9b9854f66ddc072799fee3cc633cf44f75160f74ce4e523c48703dd28e05ebc634f813446ea049fd7fea6730e83dce314877f4bca6e3ae5f987b43e6602cfd4681eaf5684a6415410f304db33095f126e7a2a4495b8a34cf667b82559d615344be64b2afce5367f989d263d5a0ed056d9fafd47185145101","data":{"slot":"7897279954973008252","index":"7902237404623060636","beacon_block_root":"0x2084a46d3c0a3c7ed78def7ba42611171d44694f706a904435ede2aec42d8df8","source":{"epoch":"918787264","root":"0x934a816dfbcf771b961f5b809a5b8ce5435663bbb61e85a148f47760e272d938"},"target":{"epoch":"919172013","root":"0x6d088d6dbc38b991ac998c29f349634b36506597498d332decf1f0cf2db16a23"}},"inclusion_delay":"7885712563866284763","proposer_index":"7884060080649600635"},{"aggregation_bits":"0x8cf72b0c79a81bd5c8029496de2c797abfd5c9626115902e6874e86136786fc760daa0fb9319fab6f89b7f59e609e63298e585aba7388efedd8229df8977c52a2596aed1204dd99273109c22319a3080036a80075d891182795f22fd6eb12a3b63fb962ca6fcb9babde21c525ecef69700799125b9f7e3bc8f5ff0d54a8dadf23d6b1720d2252fd90e30fabfab535dacef80bb45f8d1f3266d38d42d6c5503679ea3fdd9bd8fb18ef27b2c65dad0a5676327f68c104512fc5acf59d518de87c02fdcc0236404689911850d80fb90efa2d4067b6ca8aa6c60ca85d7cb43467eadffa0b8c1bc578ad4dd84a98b4e6a8a9656c32291d5915103bbfed4cfa819148501","data":{"slot":"7887365047082968891","index":"8249259030450582884","beacon_block_root":"0x75627572040110ffaca03ae10ae938dcfdc8388cdcc41b8faaf58267a0ba1f2e","source":{"epoch":"960724894","root":"0x4f208172c4695175c21a6c8a63d70f42f1c23a686f33ca1a4ef3fbd6ebf8b018"},"target":{"epoch":"959570647","root":"0xc2e65d72842f8d1281acd78e590c8b1016d534d4b5e7be7761fa90880a3efd58"}},"inclusion_delay":"8245954068312181924","proposer_index":"8244301580800530500"},{"aggregation_bits":"0xf2a79beabfaaed6f7cf54c5e52e19dc27c4fcaf66e4bdf2e601aaddbf1889520b59f51c3e2ff47d841dceb15a521047723b2bef06fe47f4170628c920dff5c506e4253a7f968df0f202d3632ed1fba0024541b2742e0877fb27f4d3e6457d201fa571379b662becd51a44e379b2e5817fe4653bc950ad3d4ed4fb23df7cccbcfd82877856b16e4ca5ad76b29f59a8ca58dc13e075e3a1d413157760c4ea3f29ebef8caa31f55074cc8c0db26127f76f9ef03aec66e4457b2f34f84818c6852bffd6b084b1648b06a1528100b3288a89034f6800c5c04c1e891d9d57eb2b3e6796bf03461bf0b08dcb95d6e058458f582f743f03236cd74958f2fa309197ce7db01","data":{"slot":"8234386677205458436","index":"8239344131150478116","beacon_block_root":"0xe8285272c4c64b9c6c32a6e5001eb4aa23db32f8227910ecbcfc1719beff6b6e","source":{"epoch":"958031652","root":"0x5bef2e72848c87392bc411eaf6522f7948ed2c64682d0549cf03adcadd44b8ae"},"target":{"epoch":"958416400","root":"0x34ad3a7244f5c8af413e43934e4106df3ce72e40fb9bb3d47301263a28834999"}},"inclusion_delay":"8275698779097398117","proposer_index":"8274046291585746693"},{"aggregation_bits":"0xfeea61544ce035fe096a42d7e3aba160106a074e0bcd6f282ef085f249e4b639245152dba5dbbe55e102f8fccb74bd6b9c817de3a84b9ece67edcb3cf852f6e89ceae2acafec9f6338792afd73a88a679c1d22c819892334a504c55efb838d3648bce8cdddc55ef2e47ae7c52f2e751f405c8f8b65fbefcbb36b503e9cccb9d2d4f8c1dfd3ba16681483fd15846f3af4a76ec30ce2583971ae1f62486b36600a4c0df8360ce898e1bf61b856ea7bb0a3cfe06b56d681f3050aae84c40eb35352e57c0b29c57fd8cc8456d2f4f23ac7e616aba1f2465758221986d8645217c4d71e49aaf16fea58d02e71118b078cf76d95d7dcc8de225674cb44786ec13fd46501","data":{"slot":"8277351262314082245","index":"8269088841935694309","beacon_block_root":"0x90d5bb72857598c42e7d63d81e7f423fb2a444b44f5c32d584e75804643087ad","source":{"epoch":"963033387","root":"0x6a93c77245ded93a43f79481776d19a5a69e4690e3cae06029e5d173af6e1898"},"target":{"epoch":"961879141","root":"0xdd59a47205a415d8038900866da29473cbb040fc297fd5bd3bec6625cdb364d8"}},"inclusion_delay":"8265783871207358757","proposer_index":"8264131387990674629"},{"aggregation_bits":"0x3ac64b92f047175ac3f5d307533866f3a20d809c9bef68a301c3daa46ea439d4ca4be82faa5ed5701a70f913bc8c48b73dee2525a6393852bdbb8f50a96d7e49c026b9d8ed2accb1ca05fb7e846cfc60de51824099edfce617b55378063652c30d8c1ed61bc0da1d189ffab45c6affb9b9a92364a68219a16b97b5cb481b8a9171a67ef124ba438f546eb8e34be7d2e1700fda60f1925b87250e2793963ada174a97b30c2a307c2e47b3dc5eb55db6cc1d600f5b0ba3c63134e72dfe25e0a6d036368c962968e79e43b84eeee48e68818a35293209b64c35d0fe8c4d472438b839e0836f6688c5b83b1de8ae43b4ea7e83218f09da42211d58a507321daab25d01","data":{"slot":"8254216484395602564","index":"8259173938340622245","beacon_block_root":"0x039c9872453bd461ed0ecfdc14b4bd0dd8b63e209510273297eeedb58275d3ed","source":{"epoch":"954184163","root":"0xd984b9710375f99a54ff224e7e03ca7ec52919cca7db34d4621bf36fecd50b85"},"target":{"epoch":"954568911","root":"0xb242c571c3dd3a11697954f7d7f1a0e4b9231ba83a4ae35f07196cdf38149d6f"}},"inclusion_delay":"8189769613175117795","proposer_index":"8188117125663466371"},{"aggregation_bits":"0x22aa3e6e7057e8e051961a5894c7754d9828de78a0ad4321342eb23bfd4d6331d8e16c7926c5fe38d7933fe2657afeb98ab21753f7303c26f2abf0204a241e048f3c4164bdf7383083508d6832aafcfa710472ce8c819883f59dceefb563262a7feb954b4b4ca67a635df5aa3911b5577bb097b4cd7782d8513e53a1c31d97adad62b50d134e20c17d5d899622b02c9143180c234c5f3b216a68e6acd9ef645e9da1cf419073cff099dcf3ffc1f6efccb1741ab27d26f2c360ca7013212d6d242146ceadebc9eadc4426516aea6f7f1ec1e3457d79e85999b4a4241ff99798a358a51c8329db15929f66fb1564ed4084d25d8314fa41c3884b9b9d94aa4ddad301","data":{"slot":"8191422096391801923","index":"8183159676013413987","beacon_block_root":"0x718d8a7103d2f3c1fe165da91b4a6ee7f741115c59217ba5d0240fb2bfdcc6da","source":{"epoch":"953029916","root":"0x4b4b9671c33a353813918e527438454deb3b1338ed8f2931752288210b1b58c5"},"target":{"epoch":"951875669","root":"0xbe117371820071d5d322fa566a6dc01b104e0da433441e8e87291dd32960a405"}},"inclusion_delay":"8179854709580045731","proposer_index":"8178202226363361603"},{"aggregation_bits":"0x08111202ae6d823e9d77de3e388dfab08210e1d1fbab2a54bae13a450bc724a007c9ecd21ea6a33db7a3b9cc59aa206d63e57da3fc9ff8cc6626d5fdbbeffd9a7d2d04b9e050ae0e853fb3b8db92ca097f0815309ce71a99cf47c816b47f4350c11f1e7ca922cbefb2a910d337240f87a8777f842382ddd62547453b59a3b8a0bb074d2fe5a2f17a9f0998d775e6e637ca6b7385cdc3d4b5c0dae1c3b72587b961c169cb96b581aeb4cf7d615010313b931914680489f9a583f30c11d5e12352483731acc8a54f35442b2ed4fff09a8c9ea12651b2d02dec34ef75f7ba19bad968bbc9fc89c15f57084c9e1e06ec5d488193894da2a353289c8e47b45c5acdf601","data":{"slot":"8221166807177018116","index":"8226124261122037796","beacon_block_root":"0x81312372c42346c3164ae0409d64581355f32a88d4be56bd2a06345b920627c4","source":{"epoch":"956492656","root":"0xf3f7ff7183e98160d5db4b459399d3e17a0525f41a734b1a3d0dc90cb04b7304"},"target":{"epoch":"956877405","root":"0xcdb50b724452c3d6eb557deeeb87aa476eff26d0aee1f9a5e10a427cfb8904ef"}},"inclusion_delay":"8209599420365261923","proposer_index":"8207946937148577795"},{"aggregation_bits":"0xfacbea0e0f3e7f25bc4a8d4d9076c4f5ce0a5f15dd8bf8af4f73628502208bc983cff70568e2acb1b8f7ebf25e5c9139944ce2a257c469f11e0ebcf05cdcb41d07682973eaa7060fea5d24211ac8dcd20310fba343a6781910ffd9beff222cf4bf26dd6232c7b2aaaf434252a85c96f92c33ee37526560fddf12edcb795ad8b1aca2f8011d1e83adf3be0a5c3ce864bc32d6226fe3fb7de7f6172f13313fc0873248a128b1d49694124638074fff5c059d2389cf80476601ed0e0dac868b83262a790af0f4e987b091b60d95742c11a32b682e581948dddf51a9c90ca6200866087d8adcb348fcb4b1375736e120ccf0e3bdf2f532de0f6c1cdf98878c38dd4601","data":{"slot":"8211251903581946051","index":"8202989483203558115","beacon_block_root":"0x8c00d17183467c877ff385a030e0774aac1d1d84cdb891ebab16e54e83522e5a","source":{"epoch":"955338409","root":"0x66bedc7143afbdfd946db74988ce4eb0a0171f606027407750145ebece90bf44"},"target":{"epoch":"948028180","root":"0x3ca7fd7002e9e236fb5d0bbbf21d5b218d8af90b72f24d191b41637838f1f7db"}},"inclusion_delay":"8146805032361461282","proposer_index":"8145152544849809858"},{"aggregation_bits":"0x5873573092fb7720941bf52d2e72643a4a16baec9559a2f8667a0cd2b44cf8e0b3ac02709c282a47d59b7cc2fe7bcac33cf73d25b3e97e66f3e1626b38905d965a71a4133a570dbf7f124629d791a8d293032d563f8fe72d9dc30681db95ce5a63f8e2c7960fb271e4c6c7ba4b9d495a93cf639e8d5e80a1e71402a0f6663b0e498bb9df24dec3d6fe87ff14db58d611762c749e6f8ff6b4f68d21f6aaec6bc5e0616d781c76d4ae1616327b121d74446f8cb54ede3ec896a19e7a967fa61f3c8f8cfe44e8877fa76e390d3d8fa5a6d56941f5c79c72037569cd98feb089f69d26545f26eb93d615a67003c44dadb2a0c209d28f3507ecd43b51935d22acb2e101","data":{"slot":"8135237641254737794","index":"8140195095199757474","beacon_block_root":"0x62e9f1704280a1c0e6e3d9119a2f84bb9990f72fde839f8d7643ea08edb266f1","source":{"epoch":"946489185","root":"0xd5afce700146dd5da57545168f64ff89bfa2f19b243894ea894a7fba0bf8b231"},"target":{"epoch":"946873933","root":"0xae6dda70c1ae1ed4bbef76bfe852d6efb29cf377b8a642762d48f8295736441c"}},"inclusion_delay":"8123670254442981601","proposer_index":"8122017771226297473"},{"aggregation_bits":"0xe228752907c9ee3ba5eef742671e50349a0c27eb32bad0d2970970ce318267995b7a21c2ea6ca7aee4c0bca8d9557bc7e945eaa0081baf0acb480f64ffd95c110cb0abb1b0bfa399425380bcf6871ac17e98c6c1fa4e85bdcb7a402d388953ee6d75325d954a8ba48967263923215706905cb2d97ec15df91d59e81cbcce5bcbdd2a0dd0c5feb15392661c5dc226929b8eb529f4f8b9ceecc44cea8f0a6784f9e2e07e3c3f6fc185a243736774aa036ad0b7a8e06ab067654659792d6cdd9dd2ff9a0c71f0c3e5823925861c407969ca1c48bff4a6fafe446cca75137db59c40161b7e3613fbb9ee312b2adeebe52b95ac66333dfd38dc1297166d5fff62e2b201","data":{"slot":"8125322737659665729","index":"8169939801690006370","beacon_block_root":"0x0a965b71022feee8a72e9704b8901250295a09ec0c67c1763f2e2bf492e38130","source":{"epoch":"951490920","root":"0xe4536771c2972f5fbda8c8ad117fe9b51c540bc89fd56f02e32ba463de21131b"},"target":{"epoch":"950336674","root":"0x571a4471825d6bfc7c3a34b207b4648442660534e589645ff6323915fc665f5b"}},"inclusion_delay":"8166634835256638114","proposer_index":"8164982352039953986"},{"aggregation_bits":"0xba05d5d84916ca45680f30680f58de090cb8388679fd08f625463c7c637250198041890f541bbadbe7563ec3e3d48336420086d022b42be51dc5eb996cc0fe8f7e6d4d612d3b7f23140a2b459fb2e5b9a027b429a48b04a76021f8c6b9d5ce94f125afea67ac97958cb495a88949afe4c4785aa1161c4ae4683de4c68c197cf2c94d78e3097660ba6036ed9f452598af87da54d18920b065e27a6de864a463c8960a38d73d03abbfd9e33df3d198b0059bcb36b23a5f4f316443c53bd018ea0442bbe233d7e73ade39a9f1965406ae55c68c08baecd40a11e8f244ff363e35795604e901144a9d312639cb6fdad2be85f569e370ceca1a306c117755155efdd701","data":{"slot":"8155067448444881922","index":"8160024902389901602","beacon_block_root":"0x7d5c3871c2f4298667c00209aec58d1e4e6c0358521bb6d35135c0a5b128ce70","source":{"epoch":"948797678","root":"0xef22157182ba652326526e0da4fa08ed747efdc398cfaa30643c5557cf6d1ab1"},"target":{"epoch":"949182427","root":"0xc9e020714223a7993ccc9fb6fce8df526778ff9f2b3e59bc083acec61aacab9b"}},"inclusion_delay":"8090620572929429856","proposer_index":"8088968089712745728"},{"aggregation_bits":"0x94ef868f59af3fb38b4ceb239d30acb5b6316264d29e369e32ca2078dce54ffbd6683e627e80f3af41c6e9363a033b9d95c7b6266f2d0511683e17c9cf1f9f2aa81d34d06cc3ebc25f4dde6e6965bc351ac254b2642640c78a3aa5f16ac01b7d85121673adac82cc573a4c16ee8bfd9a35f6ac7079afdcac7111c26d8d7669525ca92b988c420fa64b054d226431e56594d70112d8ee41ec6d8434962ef1fc71a17ce4cb67e2c61245ba124ae055a8973d5f39d32dbb69e1b45fba82f475017173d39c22010453993e33cf465b6799930c585430ce8498bdccd8ffed88ad9453576171e6fffa8d13915f5c568b39352fa0949f29d529dea577aead58b39d9b7d01","data":{"slot":"8092273060441081280","index":"8084010635767726048","beacon_block_root":"0xeb4d2a70808b49e678c890d5b55b3ef86ef7d593162c0a478b6be1a1ee8fc15d","source":{"epoch":"941487449","root":"0xc50b367040f48a5c8d42c27e0e4a155e61f1d76fa99ab8d22f695a1139ce5248"},"target":{"epoch":"940333202","root":"0x38d2127000bac6f94cd42d83037f902c8703d2dbef4ead2f4270efc258139f88"}},"inclusion_delay":"8080705673629325088","proposer_index":"8079053190412640960"},{"aggregation_bits":"0x1ac71ced66313f7849616af57da366e42cfed577434e248f1d110f276e15b11330720ca9d2d91ac1b768f989c95deaca1730ee506dc5c149ca0215c7cf7d3e434bf58b117f39ded6ae350dfd96b91affdcafb8382461bd33a2b831615765a18ed062d0f949098aab895c40d359f773587a3346fbba88ef06cb34fd1951895a2d38f18c00d34a4a40a8a8cb96bbd50cc96bb8195e7728090cb00d4dd5f16d87280784adc8e168debf6ae8f4e2f7d59aea4e5f17cec0b84c91ce06b1bcbfded6a634011cacf95960ff71da725d0c43908891c4fa16432cb89835b1f39298ba736f11e83d5bf7f9486b1b37e761ca8309e1bc2266f9817b814ee4cc9b9c6f11b78001","data":{"slot":"8069138282522601600","index":"8074095736467621280","beacon_block_root":"0x5e14077040518583375afcd9ab90b9c69309d0ff5ce0fea39d7276530cd50d9e","source":{"epoch":"944950189","root":"0x6db89f7001a3d7844f8d7f712caba3f2f1bae92bd77ddabbf7539bfcdefe6d87"},"target":{"epoch":"945334938","root":"0x4776ab70c10b19fb6407b11a85997a58e4b4eb076aec88479c51146c2a3dff71"}},"inclusion_delay":"8110450384414541281","proposer_index":"8108797896902889857"},{"aggregation_bits":"0x5e0a7d56a54ce3e754b0747e9e62be0fc8db0d0f159bb4c869b0138443dee708dd9cb0971627c32027a1ed6429065b5cab1005f3bf7980ea8d8f4673b9fbf473ac19d98279b79c59a556150201047e5969e6c9c67fa0385d67d2b2a3c4a111af46cd165e182ab63c3a407a5f7d4b4e9442219eb1cae5368b57590553329908ccfd050ed8e1ce8cfa47ee5fa01468aa98ad016dd66740974479405d29d66071d864d92a6e628605038f44dd320d1452f29c3c930a89dceb221dc7d1ad1391e7fb480c76c70e6c1279e8a6b1af94a0cbe6f6d13d65db161362a9ad84dad71a01b52719e3b9e339556d911ef8f50846bd4fd4f5424f2d66232fa8f2a841be69cc8901","data":{"slot":"8112102867631225409","index":"8103840447252837473","beacon_block_root":"0x06c170700100d2abf9a4b9ccc9f1475b23d3e1bb8ac3208d655db73eb20529dd","source":{"epoch":"943795942","root":"0xe07e7c70c16813220e1feb7522e01ec116cde3971d32cf180a5b30aefd43bac7"},"target":{"epoch":"942641696","root":"0x53455970812e4fbfceb0567a18159a8f3cdfdd0363e6c3751c62c55f1b890608"}},"inclusion_delay":"8100535476524501921","proposer_index":"8098882993307817793"},{"aggregation_bits":"0x3818662050519158b815bdfe0e21d3393d4918d82b5d53884af5e6e60c0c68ce78e9dffae7d76e66ca10dbf07a06dfb8535790a847a4327920676360ad126cb18cae06d4348d8f0484723f00749ae48947f25ee56ed2ad82ebe3c4d6ce23c295bf61a34d8a48318ef61cac9dea0bf0049f30483826ac600235414ff28fe14eed911352ce73d172ab87194f37dcc5fb111850e0be20bf786541aaf568d537a5b25da8b88c504dfde2b4e6ea4986eaa92443d84f01667d4f7cde5509a7c9ebbae0d901e69f5c2238ea6c0a8e2495191eced2eba20fbc9139c8d3e1e56e85dbd1f431486d4a5647ea776686dd61e2f714cb5437d8a1c1088689a871ff910f697b4701","data":{"slot":"8459124493458747657","index":"8464081943108800042","beacon_block_root":"0xc2967075ca99ab0524a0cad6926dcbb7d13fb96843d865066c5c3bb5bb8b00bd","source":{"epoch":"984194577","root":"0x355d4d75895fe7a2e43136db88a24686f651b3d4898c5a637e63d066d9d04cfd"},"target":{"epoch":"984579326","root":"0x0f1b597549c82819f9ab6784e1901decea4bb5b01cfb08ef236149d6250fdee7"}},"inclusion_delay":"8447557106646991465","proposer_index":"8445904619135340041"},{"aggregation_bits":"0x82a3952033cb003033a02cc9051c6f1fe80aad84c879c963ff5f802e0642cff5ba2ff5ac11929560c7cc09882d1e2e6da46f3cac9cb663139d4e8b6e56630e38eaaf22243eb775145b5279dd55f4363322d237e5a39ba700ac1b937a691a7d32914b3159c40d18e3cf96d5d7f7bb6e74c496c92fe7115738cf30c830e9997d222672eef08e45a4b427d0ecbe919fba9ba34ba512f181d375e7633fa3cd2d4806cf2920f97b7915e18bbcb6874114482a7ce1d0e7f6f1d35af1d0088c4f8a5c0cea7dd7f6ca86b2efbb1a531dd6439510cd22eb42b70bc4733aa3c114acb1248f4186cc402d8e47e0dd7dd06342c38b22da7ee2130b390a2e2816079bd7833f7501","data":{"slot":"8449209589863675593","index":"8440947169485287657","beacon_block_root":"0xce651e7589bce1c98d49703625e9eaee286aab643cd2a034ec6ceca8acd70753","source":{"epoch":"983040330","root":"0xa8232a7549252340a3c3a1df7ed7c1541c64ad40cf404fc0916a6518f815993d"},"target":{"epoch":"988042066","root":"0xb7c7c2750a777541bbf6247700f2ab807915c76c4ade2ad8eb4b8ac1ca3ff926"}},"inclusion_delay":"8490521691755615274","proposer_index":"8488869204243963850"},{"aggregation_bits":"0x8c3194cc67b02fac47446aa3cf2ae382f363da318e3fb1054193991830208073771d7407bfe1faa7a57fcb22718bb6794c8110d8d7d933c80df368f3d9604bae8ca26ef3a1d1b9b86c2bb64e2cdc81ebfcd7c101b574851806a10e8dac32584f21b2aaee069e175e1e8358af7ddfc6a269b171d9dda408a7ba5bc86e75b55bbb129e7fc25ac9f1cec98899fde69ca0bf681cdce784193e2545552ce539afae3b9ac9e26369198eb3121c7958e7e6807167bfdefda312f3c673e53498b86f5cea57ce2be05722dd1e989b72474b9940f60a62ce2eed23ba86badc98edd1754fb56150db3d8b94231165cf9592f190f42fe95ba95e29834804df013ab82805207801","data":{"slot":"8478954300648891786","index":"8483911750298944170","beacon_block_root":"0xdd09b7754a0e34cba57cf3cda703d51a861bc590b76f7c4c464e11527e01683c","source":{"epoch":"986503070","root":"0x50d093750ad46f68650e5fd29d3850e9ab2dbffcfd2371a95955a6039d46b47c"},"target":{"epoch":"986887819","root":"0x2a8e9f75ca3cb1de7a88907bf526274f9f27c1d890921f35fd521f73e8844567"}},"inclusion_delay":"8467386913837135594","proposer_index":"8465734430620451466"},{"aggregation_bits":"0x5ec2a53cc0229657c83bf984869df7bc3642067f8dfd0166bc03d2d2b9efa702d9af4ed9d92161ce98218bd874f94fbd8afb876dfc9ea2e470d300ed4a314121d2cf8b76ab7322a93109e0113fcd3258b1ceba36eabbc78a391bc521077e67b0cfce79559ddb2c1b8b25aa2eb2a7c9da0761f1bf362b957b4ddc26de27482a3e87beeb80a1e9815de93b3b74ada266bad88d810d1e0d95377319663c61b4e38fdc02794a565cf8c200a1b93eaa1dcd0af883d31a023664e514a21f238a11ba8d2dcf99c1c566d10b6b872de70841c5e937e3821fca0941259faf3d13594e8f68118e5b1bf21d0986dfb45c88453d65163f3d1bd301b6fcc23d68c0a2f2c7608801","data":{"slot":"8469039397053819722","index":"8407897492266703208","beacon_block_root":"0x4cfba87408a5532bb684819aae9985f4a5a697cc7b80d0bf8084324ebc685b29","source":{"epoch":"979192841","root":"0x26b9b474c80d95a1ccfeb24306885c5a99a099a80eef7e4b2482abbd07a7ec13"},"target":{"epoch":"978038594","root":"0x987f917488d3d03e8b901e48fcbcd728beb2931454a373a83789406f25ec3854"}},"inclusion_delay":"8404592525833334952","proposer_index":"8402940038321683528"},{"aggregation_bits":"0xfcdab9fe176f9fb04f6c102cbef0f7417b61431aad1b083adb52bfc70c495c6dfb67daa729265b8ad1454cb8540c8ec15be059d99883005398849f657b7e6b228f6e4c93f1c30469950430dc348f56e8c9dde84e34bdfcbcd614da1e03c9b3501f58c6d1101a2d5a18a527c6fc67127974dd691571ba3521593b79b72a761c8163696a319b6de7241006aa7d68421459847ed768ac183de51b02f8090eb64b570a6df118f473dab780d132d1c3e2c50a080bef9959fdfa6a7885c05910996614a3bcc761c328278631ad7146bbcd481b7eca6da242959c3d87ce6c846de55b813ef50f67ebc7664bc9c118be6fd15f46ae48729d26649f725fdcdf5044677e6f01","data":{"slot":"8393025139021578760","index":"8397982584376663848","beacon_block_root":"0xbec18574c86a8fc87616ed9ea3ce00c3cbb89138c134c51c928bc7ffdaada769","source":{"epoch":"976499599","root":"0x318862748830cb6535a858a399037c91f0ca8ba407e9b979a5925cb1f8f2f3a9"},"target":{"epoch":"976884348","root":"0x0b466e7448990cdc4a228a4cf2f152f7e4c48d809a5768054990d52044318594"}},"inclusion_delay":"8434337232323583849","proposer_index":"8432684749106899721"},{"aggregation_bits":"0xb8557c42bc14173372bb2ca77c320b28974616b1e9d9040905a2b1383c8dfb6016f3453de9d9034735b2df4f95dd0feff4b0d3fb0f0462f50b0bf2452cf381526e467c10b74fd2963f52ac03b26b830f119cb9e76fd450f6c16310fc77be2e62ba105d536f3d3de9a87b9079d9517baac6e7ad1721515528863e382747f649af465dedc822f1272cf65c094313b1b28cc2e7e8e83e791a85ce5bb8250caafd8ff910f39d76d5140fd7b918011d6a0b7332586a0958765ed5a00424ccb2d063271f836902b4b14fb0a8d7313d0b3f37b94f7f6859fa7101fc3b81e98da4412d4b586441df1f043f4f7fec2704b1456ba089d79b61c36afd711bb3c0a59b34056201","data":{"slot":"8435989719835235273","index":"8427727299456847337","beacon_block_root":"0x676eef748919dcf03761aa91c22f8f575a82a3f4ee17e7055a7608eb7fdec2a8","source":{"epoch":"981501334","root":"0x402cfb7449821d674ddbdb3a1b1e66bd4e7ca5d082869591ff73815acb1c5493"},"target":{"epoch":"980347088","root":"0xb3f2d774084859040c6d473f1153e18b738e9f3cc83a8aee127b160ce961a0d3"}},"inclusion_delay":"8424422333023479081","proposer_index":"8422769849806794953"},{"aggregation_bits":"0x1e354ee209aa27d5b40e87719ca3c27ac47aa3e2780922befa302f2fda7df4d1f0a363da6184ed23c7884e684fb0da0065beab3f8166c061771092876f850a33072a6fe1e0fb539efdceed92caf4316473f975af0f91bba653d5845c698a91d2d7cd8b70e9b82fa26c9e9cd8eba7b5c58f9e10bce61aff04d2f337d1920b535d62c46248947960481ab5ecb7dc1a1af5fd88fba411965aa70d5fe8feb226cedef9069af7d001a1ac2b0b7d09786a0d9f64687cc4bd1663c1d4f5e5e25d1a90bc80c5eb1ccc78e667e3398da3652b5c2ad64185bd37579debf6f0b5b1f142e1674effbc561a06fc27cba0d03d7c2d56a20f290b16ee6ba38e0992fa6907a0291b01","data":{"slot":"8412854941916755592","index":"8417812395861775272","beacon_block_root":"0xd934cc7448df178ef7f21596b8640a2680949d6034ccdb626d7d9d9c9e230fe9","source":{"epoch":"972652110","root":"0xaf1ded7307193dc75ee3690722b416976d07780c4697e90438aaa25608844780"},"target":{"epoch":"973036859","root":"0x89dbf873c7817e3d735d9bb07ba2edfc61017ae8d9059890dda71bc653c2d86a"}},"inclusion_delay":"8348408066401303527","proposer_index":"8346755583184619399"},{"aggregation_bits":"0x30f709b1d9a2d22b3b5fdeae0ffbd6e7bf51ed86526e9834afbc832744c2ea74b6bde7bfef16a279511aee511656720993c29a38507fe1141fc9edc38f5cef1e6d9a96d0b546e666845d0a9fac3874da5c948181de7cef4293feda4792dd417d29e3206521201c762751cc16006cbf3de906b42dcfc7086e755f99bcb972cef1b7b1b829b7ac038213803c4afd4fe20d7e91ab61847823adc03869db3972d1c759b0a7abab6ac90b556d531903e704dd5aece305e3195a5b9140d84b98565fc9b9318341348a4d22e08ab2b56b4b4bd5189588fe510f174702fa05a2ecc9291d4f82a7a5fdb76345237967aaee05dcc8ce94762b0ed92e0b103c2cddfd52603f01","data":{"slot":"8350060553912954951","index":"8341798133534567015","beacon_block_root":"0x4826be73077637ee07fba362bffabaff9f1f709cf8dc2fd6a7b3be98db8a02d6","source":{"epoch":"971497863","root":"0x22e4c973c7de78641d75d50b18e99165931972788c4bde614bb1370826c993c0"},"target":{"epoch":"970343616","root":"0x94aaa67386a4b401dc0641100d1e0d34b82b6ce4d2ffd2be5eb8ccb9450ee000"}},"inclusion_delay":"8338493167101198759","proposer_index":"8336840683884514630"},{"aggregation_bits":"0x28a0114c04eaac73fabe918ac79d1a7a21beea2f1c2bac5005730659779aecb03d3f6b769964bf2c333a0cff2ed6aad9bbb5b7896bd027b70c448c2f4c4fcac4bba3da02f8cb2a40b396ad441f14a321d289f77d88f96dde29ac65d21169f480b603abd20b5a32c2abc071a7884c25f726b86d3de56a767390139920a6a571cde337691b15515639d5c8cd89ea1c650be7ca8a4635e0d915f29f6faedfb5197485504100f19a5f308c1c8ca38f1d86f880b0c577a2fa7e652153e4597dd1103e342859d7bdab519ee08acf39ee91a833e6d5e7b23a2760b708e8544fa44fc3640fa4bafad92d4a9868b3e8119c55d184dfb78be62e2fe8295a7d1a6f034575d001","data":{"slot":"8379805264698171144","index":"8384762714348223528","beacon_block_root":"0x57ca5674c8c789ef1f2e27fa4015a52bfdd089c8737a0bee0095e341adb462bf","source":{"epoch":"974960603","root":"0xca903374878dc58cdfbf92fe364a20fa22e38334b92e004b139c78f3cbf9aeff"},"target":{"epoch":"975345352","root":"0xa44e3f7447f60603f439c4a78f38f75f16dd85104d9daed6b899f162173840ea"}},"inclusion_delay":"8368237877886414951","proposer_index":"8366585390374763527"},{"aggregation_bits":"0xdab2d35ceedb0f5c82d151ffcfe92e54b83b7e0c3fcf3cbbb4813199f879c2c8957d7846a7b0347867475c0723e33b989d9d209cd0abb0cff2f8ec21bb1cc047ed867fc2e63695776eb4b357744331928fb10c4e54b807d85eb4043ed8fc4be75a2170c8b53b2db7de423724c7b099936fa9c4ba26e7c20aec8756c2620b09cf3735dd15ec25a2ca5d6b6e88b333aca40757cf242afe77c7d44fe446c72a594a82dbfa82daaf3b10feb758d988e2e7d57a89d8c826f3c3d146d4e1667f8bb3537d2e4ffe3beb08c2b316e458a1c9032ce25ce3d60d3d161b67aff8a1387297f93f6a20feae66a9239189e389bfe9402964fd21c80656c0eb8d7ce04cd8bb201301","data":{"slot":"8369890361103099079","index":"8361627945019678439","beacon_block_root":"0x6399047487eabfb389d7cc59d390c46254fb7bc46c74461c81a594359e006a55","source":{"epoch":"973806356","root":"0x3c5710744753012a9e51fe022c7f9bc848f57da0ffe2f4a726a30da5ea3efb3f"},"target":{"epoch":"966496127","root":"0x12403173068d26630542527496cea7393568584c11ae024af1cf125f549f33d7"}},"inclusion_delay":"8305443485587647014","proposer_index":"8303791002370962886"},{"aggregation_bits":"0x4c486277395f456fc592835fb1e1eebb7db89b1b3788a8695db034da01b13924b125dd841feb37150f62eb6980576047e487fa78148689543a0afb25ee51a828e87f78222bd68757489b09de34035522b603fe7b0943966eb934ff63fc09af8fb5d457c974f70de9a4e23adc08726a2119596012c9fe7b404a7088bb2c35d273d2ca1ca981246091b456eb8904a255675badcbf9a8abca2db4d4cab1ece8f414d6fc76d72f6548203ec5c16a8500cf55c404fe7b5809794c081512ded7c72ec8d17bb95eb921db1f48b4ccf8a2c116deb3552e4ce4914aad2783a9120c7f472251506c089bb82ec295ada57ef72526adde246626228e735773aae7977937eb8401","data":{"slot":"8293876103070858117","index":"8298833548425943206","beacon_block_root":"0x388225734524e5ecefc720cb3de0d0d3426e56707d3f54be4dd299ef0961a2ec","source":{"epoch":"964957132","root":"0xab48027305ea208aaf598ccf33154ca2678050dcc3f3481b5fd92ea127a6ee2c"},"target":{"epoch":"965341881","root":"0x85060e73c5526200c4d3bd788c0323085b7a52b85762f7a604d7a71072e47f17"}},"inclusion_delay":"8282308711964134629","proposer_index":"8280656224452483205"},{"aggregation_bits":"0xa6d3526fbe4cde4042351564b856f23c30b9a735d02810d6a95d06528c56bec431e3e8e6212eba35317b3b318028d96291254c18af545839273e92ab193028bbbe1efd88342c36ded53816833d54c3d9d339342acf02fe7c2d2cec8d973690f9997885f36b3254a8d96e495d940a557b44eb994088794e7c3eed231544ccac88c56b8de7751c923694bc49025cd818c5fb34aa17801fe73d863820f27af339201777f5970454ee10289a1380a8afa86b2b1d418ddc04eeedd6f01169d0ade2a73b054a90244c727a91a87155e19d8d735434665f028bb3c25ac55dac04e2c3ff710694086a31cd712c962957d1edb741106ef414eab0771587a19c14a27ded5601","data":{"slot":"8283961195180818757","index":"8328578263506126694","beacon_block_root":"0xe12e8f7306d33115b112debd5c415f68d137682cab2276a715bddadaae91bd2b","source":{"epoch":"969958867","root":"0xbaec9a73c63b738bc78c0f67b52f36cec5316a083e912433b9ba534af9cf4e16"},"target":{"epoch":"968804621","root":"0x2db377738601af28861e7b6baa64b19cea43647484451990ccc1e8fb18159b56"}},"inclusion_delay":"8325273297072758438","proposer_index":"8323620809561107014"},{"aggregation_bits":"0xa670da8262b1f08a1ed46c2ab0443c802a9211b09a3d2ae73e940e649edf9150fef1446d9d4de69271cfb9bf99f80186da5068e895bbd48ff593f0e790a0a335a86b8e503180b06822e3b4b0dc3879210d3e6286b3c637e0247af9329709a5050730526cc1542b19497984459f36c78c47d6709856dca177caa8276dd3e094ad934f4455c996c3dd2ae5b953c2da1ad26263ffbe0527bc2102af838d043dffd96797133c0e82750eb41a9c181a894b56e4636775bdeeeae30e8929ebac41d86392e0370b32210dca9929104b6d011eee0bd8c431f02343d2ccd47401916ced871118db534827e2a797e43df4b8fb2a4d38c135cdfac3b7b7ece6c08e1c40f02101","data":{"slot":"8313705905966034950","index":"8318663359911054630","beacon_block_root":"0x53f56b73c6986db271a449c25276da36f7496298f1d66a0427c46f8cccd6096c","source":{"epoch":"967265625","root":"0xc6bb4873865ea94f3036b5c647ab55051c5c5c04378b5f613acb043eeb1b56ac"},"target":{"epoch":"967650374","root":"0xa079547346c7eac546b0e66fa0992c6b10565ee0caf90deddec87dad365ae796"}},"inclusion_delay":"13748725597936915948","proposer_index":"13747073110425264524"},{"aggregation_bits":"0x53c052ab2b0d3708b881faa64cad1ebd457dbdfc23d3ab6050fde450072635ee978f12f9677c93de5e6b510380931cd03a1e882213cf8d2f8a8af61d5dd94e20f503540211e9a51d1bd86e3c8c3f492e0f44a3c38172a67f7a7f75fe48c64862d0365d9b2df43806efb57f9a8b8b4a42e3a105def1641d1e8e5d3b3df133f2becffcfc97e73a5b0c87ae587eead70ac523be0264dee6fbb4032ececdfc3d20c31f58cd78080bccd1f3f7fde79c85509623c1f4a5405ad3ee7a994f3c7ad927517903bc795684d6cb65bb3ae3aa3a3ee6c004242e1e4216073286157c704eafa96cb17d38ddff9cd329df1668c6ac163fd72df9ffdc52a201b9a1ffd56527113d01","data":{"slot":"13750378081153600076","index":"13742115660775212139","beacon_block_root":"0x75eeafbe0b10b6bb7e3871502c4d9805d9830de13da58d6560a7011b1e271209","source":{"epoch":"600177566","root":"0x4facbbbecc78f73194b2a2f9853b6f6bcd7d0fbdd0133cf104a57a8a6a65a3f3"},"target":{"epoch":"599023319","root":"0xc27298be8b3e33cf53440efe7b70ea39f28f092916c8304e17ac0f3c88aaef33"}},"inclusion_delay":"13738810690046876587","proposer_index":"13737158211125159755"},{"aggregation_bits":"0xdfcc446c97d939c7732a61f3a4beddce36c2ea17a1458fe31fcfaa0e6b46aa0e79df381aedf1fab8ace5d0e6f2998d2db9e372e0196f8f8ab4def6bb183aefcb1fdf26fb073df679f8e07daffc8f2e2cdf006b43c37559add5cce0fa5370b2869767ca80a05134c1390041fff959c9e4224dbc70b42b0f30f69236cafaede5fccb6e5bb79d220c216a4e8c6a353ff0947d011420d2203b54ca3e9e1c24b939f6f9efa4233ecf35b908e4ccaed195eec3d541d2b9be194a5b06fc6e16418ade8c26973fc63f4fe515a1458778f41ec7d53f92eabc9388aa2113b689507955715a692cd2a89ebc89fb3191ec4d39587f6971d159bb9c12dbf323e1c6c9f9212d8901","data":{"slot":"13727243303235120395","index":"13732200757180140075","beacon_block_root":"0xe8b48cbecbd5f1583ecadc54228213d4ff95074d835982c273ae96cc3d6c5e49","source":{"epoch":"603640306","root":"0xf75825bf8c27445a56fd5feca49cfdff5c472179fef65ddacd8fbb750f96be32"},"target":{"epoch":"604025055","root":"0xd11631bf4c9085d06b779195fd8ad4655041235591650c66718d34e55ad44f1d"}},"inclusion_delay":"13768555405127060076","proposer_index":"13766902921910375948"},{"aggregation_bits":"0xab23a1d274e0814c47752dfb63e9e5059ae73695ca131bc413b1966f2a8e9d179ca724163bcb09517c6c41119992565145e0b0c3c85fccfc2516ed9dcf89053afd3fb4b801b11206d3b9c770662c004c1dc03a9c991e8ce5f97762ab2286e0f112a8193488537df68bfac4184c4fedbcb4167c5806ce77690ab7764b6b2cb5f68e18d9f7adb8f8a1cd0d18d40406c6e013df2f2b21420c7c07770e7000fc2b4e8a32b6930d6abdd55d69e0570344428787225628a5bfee48ef3d5e01e045d1d33a587124c8eca73bb02f440224bdd8977a8d4d5212e0175397ebd863a0d143c41c99482a0a2cd4978bbedbd3d0d839cb134d681534bb2e8667c698cc2052168101","data":{"slot":"13770207888343744204","index":"13761945467965356268","beacon_block_root":"0x9061f6be8c843e8100159a4741e3a1688e5f1909b03ca4ab3b99d7b7e29c7988","source":{"epoch":"602486059","root":"0x6a1f02bf4ced7ff7158fcbf09ad178ce82591be544ab5237df9650272ddb0a73"},"target":{"epoch":"601331812","root":"0xdde5debe0cb3bb94d52037f58f06f49ca76b15518a5f4794f29de5d84b2057b3"}},"inclusion_delay":"13758640497237020716","proposer_index":"13756988014020336588"},{"aggregation_bits":"0x8f5b3ffde9ada84b0ca4c7329f8901eed5cfdbc0c325cb1dbce8c2a84e25b6feb4d734b2dda18f351042923139b749bee57bee160e72ec3fcfc16ad66e556c76a2c4b3905e418c66f7ff25bd30452c50e553a42966799edb14f435f02631a208c1312e2248b12d3dab6e29888a9f3a5c83abc1f8f15dafc3b8722a326632870d6a875867d2dbbbd815308d94b33ed5c246e3684ab3f6302527ec08078b2e83dadb1cfcc19ec6c707eb1b7d0006e6c9167bed6b9bfb57f0dff3cc0cab28d90f6892c984bc5f9a50a6a67740a3e7306f472fa6aaccfbf04bf9b7c1e89cb058d1bf30f2bc5573d7bf509eda9e749ebcd15bc379ed7e3073dd5dd92b860eb7de512201","data":{"slot":"13694193626016535946","index":"13699151079961555626","beacon_block_root":"0x664a17be4abe63ba6605eeb8ab32aed97cd2f3b4c207b24d06c6dc714cfdb11f","source":{"epoch":"593636834","root":"0xd910f4bd0a849f57269759bda16729a8a1e4ed2008bca6aa19cd71236b42fe5f"},"target":{"epoch":"594021583","root":"0xb2ceffbdcaece0cd3b118b66f955000e95deeffc9b2a5536bdcaea92b6808f4a"}},"inclusion_delay":"13682626239204779754","proposer_index":"13680973755988095626"},{"aggregation_bits":"0xd7c194e1481735505cbb576417143d6052c567aae5a533ee4b7ea4ac47cb115f14110780ab45a2380e1ac64b36c9b0ab12d3d943e5a26c0133d90009ca342df7fce1365052ab15e448bd63e00b3b7e8b424956ea10b4f553c2ae7d1cc96c0dafad4dfc3e7ff604589ed4fb631567a0048f7f6033e0d252bfc8efc7d484edb6d89f268a0925efce1b2d902f75ea7050cdaf9861a0ea409f35112482dc373586264a9e7404b193eb04df48ad7e293bbd3871b7572d5bdceff89c1b2e82cb23cb25fba37ba5ccde89a3205bcc8324e8a0680cafcfc58d4a31cafa886470f875078a503c1c50cadc94ed27a013fdbb8ccca60d1715c7713ff1ba4d1e7d7d2e001cd401","data":{"slot":"13684278722421463882","index":"13676016302043075946","beacon_block_root":"0x7119c5bd0ae1997ed0ae93183eaecd10d3fce5b0ba01ed7b87d68d653e49b9b5","source":{"epoch":"592482588","root":"0x4bd7d0bdca49dbf4e528c5c1969ca476c7f6e78c4e709b072bd406d589874aa0"},"target":{"epoch":"597484323","root":"0x5b7b69be8b9b2df6fd5b485918b78ea224a801b9c90d771f85b52b7e5bb1aa89"}},"inclusion_delay":"13725590820018436267","proposer_index":"13723938336801752139"},{"aggregation_bits":"0x47d2cd1c965c122cf379106fdc12b1dd48854102aee16a99c3a0699651191ecbff2b094f05365fbd6e8700210a18287fbbacbcbb8c0fadee2154777472294b299854508c4e25ca521feec8737a964072de6f24c4287cf4cdd9b863b7445428173abc6f839f1048ed4a55169b1dd1bae3746dfa5bc2a355a2bc9eca4c9ef798f0eb62513f99111ab0bbc35f16fd7b9acb36bb5da71f59e7a8b3922d9a51fd0e573efe266f9367301e10c872e09dab8f0319caf9d71e37e61c6660d6943f4ae9e3d292012389b8134378eafc51295167fdd50f40e9ef76479ff6903599a3ff29fa626a0307ec663534908a1e17d9dad3bb2519389a507d33da16482717b013071601","data":{"slot":"13714023433206680075","index":"13718980887151699755","beacon_block_root":"0x81bd5dbecb32ec7fe8e116b0bfc8b73c31aeffdc359fc893e1b7b20e1073199f","source":{"epoch":"595945328","root":"0xf3833abe8bf8271da77382b4b5fd320b56c0f9487b53bdf0f3be47c02eb865df"},"target":{"epoch":"596330077","root":"0xcd4146be4b616993bdedb35d0eec09714abafb240fc26b7c98bcc02f79f6f6c9"}},"inclusion_delay":"13702456046394923882","proposer_index":"13700803563178239754"},{"aggregation_bits":"0x7da06e4c26fe8925b717c009942585db848e5f062805d9f631123c50c8e6b9871eed2ae463e6549d1d9fc0592d64f97b2c457bba37593d52d4f502da996846afeeb51e2e44df237b02dcfe2c3302b2c39167cd37eb3194dd4748765bcf689d34f69abcba425430e857e64109c62f072a393851ff32dabada4207c19a3e9ae4067ce2e4396b6969471103ad9fbc041968d66e1d4c05ef59fb8553e3439bb5cfea7d75afabb856b63e641622c6c21dea2984d0e670bb1b7d7f0927c50d3eb0ad8ee0d5b75817fcdac7f5ea9370ac69ec58b22ee0f8dce8ba76dbc795e72ce2d56702a42e17821e5ea325e1973e7c7042c2ef734a68b842051cd263f8056d7c13e001","data":{"slot":"13704108529611608011","index":"13642966620529524201","beacon_block_root":"0xefae4fbd89c90be0f8e9a47cc65e68165039d218f9af1c071aeed30a4dda0c8c","source":{"epoch":"588635099","root":"0xc96c5bbd49324d560e64d6251f4d3f7c4433d4f48d1ecb92bfeb4c7a98189e76"},"target":{"epoch":"587480852","root":"0x3c3338bd09f888f3cdf5412a1582ba4a6945ce60d3d2bfefd1f2e12bb75deab6"}},"inclusion_delay":"13639661654096155945","proposer_index":"13638009175174439113"},{"aggregation_bits":"0x4f2af777bae3e290f8d68ae0ac682534f083b6175153c2b6da4b5b4d26f0c74f3b1d3ba993b8ff135ab3175aac9161a9ee9ef515d1562705341214f2c11c6f45b184d2469d2e65cba6e92ee472450ee5a0763182bf94897daa208930ae9da7cd316e19bc83bd11674d77ccf52dcca8196f84e495eceb70e356c9c7d731a6ffaa1acd0fca146f3e0cda1e789f12bdaa888add113ba7915491ede86766c0ae2331a55ea5f97ddce41e96c538bab34ca0387f4ec971e5d0c7d95454a613d42092155460636085021dd8dbd4bad16d5079b2e2278165048c6404ebffc0f0186b6d8c26ccbeecaed1616e619dc9859a9a7ef2359345029ddae4f61cd4a6bfd2f1fc4701","data":{"slot":"13628094267284399753","index":"13633051721229419433","beacon_block_root":"0x62752cbd498f477db87b1081bc93e3e4764bcc843f6411642df568bc6b1f59cc","source":{"epoch":"585941856","root":"0xd53b09bd0955831a770d7c85b2c85eb39b5dc6f0851806c13ffcfd6d8a64a50c"},"target":{"epoch":"586326605","root":"0xaef914bdc9bdc4908d87ad2e0ab735198f57c8cc1987b44ce4f976ddd5a236f7"}},"inclusion_delay":"13669406369176339434","proposer_index":"13667753881664688010"},{"aggregation_bits":"0x0b373d925d100a83cfaf5ce27f1a5dff04a2cc8b5035debc975355f63d54b1d652e70651550e26d6ea6887864e4a997152ac361a5cd2c4cba79f085236a6813d5228c04dd9a38b6c0db7f62fece0428637275869645d44a3ae5281d4bd815c6e8e54fa2ce4ba315aff893d2d99df95dbda562c5b36122dad00fc27c72ba7acd6af11dfe7a8d1fe36fd58c8a048d60cdec824603ab539f2d134997d5af6a2b88545a3b5def8416ea2c36d1b6a45666e7a09a97dc3841163ef9fa5a6821683fcbe4edd470376a17b7ce9babbaabdb71a50a63a641ef616ddef6fe934f1f1cf5f44175f018f7a16683087b66491580ecd7445876cac315186a752bbb8022b822e1b01","data":{"slot":"13671058852393023562","index":"13662796432014635626","beacon_block_root":"0x0a2296bd093e94a57ac6cd73dbf471790515de406d47334df5dfa9a71150740b","source":{"epoch":"590943592","root":"0xe4dfa1bdcaa6d51b8f40ff1c33e348dff90ee01c00b6e1d899dd22175c8e05f6"},"target":{"epoch":"589789345","root":"0x57a67ebd896c11b94fd26a212918c4ad1e21da88466ad635ace4b7c87ad35136"}},"inclusion_delay":"13659491461286300073","proposer_index":"13657838978069615945"},{"aggregation_bits":"0x874b0712e0061ee503137df52f8b948c26a53d1db8f7f82a59022ba999d46f737cb52486db5b4af31c168760b537086d58014bc852203652d1bf1938b5c4205d99d06e0c83ef527ede0fffae9ab8e4ed5362b2ed201aa9f32fc2577680bc61d2eb895817010f31f721ddb1ecae091f359141977471bd9886f5257011eb59b894990874e37fd19a5416f56a54c5ede4a3331b7d760a3f9a79db9063d94a3eb8b94015763e7ef93f093cbfa362d86762ad5a095b4c4833560a41708fac6db04497891fcf8f1a664c092d402735a393712338beee1a313e611a2eba085585fcaa695ec465b26c1c2d8a6ffc4da61d7630a6db531ee91515585280b987d6f71f3af201","data":{"slot":"13647924074474543881","index":"13652881528419563561","beacon_block_root":"0x7de872bdc903d04239583978d029ed472b27d8acb3fb27aa07e73e592f95c04b","source":{"epoch":"582094367","root":"0x53d193bc883df57ba0488de93a79f9b8189ab258c4c6354cd313441399f5f8e2"},"target":{"epoch":"582479116","root":"0x2c8f9fbc48a636f2b5c2be929367d01e0c94b4345835e4d77711bd82e4338acd"}},"inclusion_delay":"13583477203254059112","proposer_index":"13581824715742407688"},{"aggregation_bits":"0x5b0456e9208eea1bc551a4276962c598148433ff379452d14ebf63ad0e3d74574ec240b3f4c0ceba987c44b96dc3f28f6d8e7af601af362232eb6fc8979b6db951e006e583b2a6b4978831b360f7ac51f93f60ceedb79c17fdc10a6172fb33f8d680c70adb1e08c0fb836342c8f2415de1dc31b5188600deee847618502627204ecdac926c77e88c1dc2fe81e53098f920472d311ff078f196f6f3a4cd6b35a9d603eb6e673073a661d85cc369c8baedf41d04e97e2666c20cddd2077cfd87c8a86fa19a729707c65a8b58b18de226acd11aae90016cf73642b089c4d94f0b52ddb9745c9a093c62dba0fe3f56427a5e1e4e27fc7db755d799f64d7a14e0d35f01","data":{"slot":"13585129686470743240","index":"13576867266092355303","beacon_block_root":"0xebd964bc879aefa24a60c744d7bf9d214ab2aae8770c7c1d411d60556cfcb338","source":{"epoch":"580940121","root":"0xc59770bc470331195fdaf8ed30ae74873eacacc40a7b2aa9e51ad9c4b73a4523"},"target":{"epoch":"579785874","root":"0x385e4dbc07c96cb61f6c64f226e3ef5563bea630502f1f06f8216e76d67f9163"}},"inclusion_delay":"13573562295364019751","proposer_index":"13571909816442302919"},{"aggregation_bits":"0xf3dc5e047c3695231d91e804c104682784593d1234d37ee48166629f14f373c3b3682b7866b30a3cb0c0c6975453467b0cc91e4e2072a6c1a2541694270ae22b27cd717f9eb2ea40c171b358417a62a9f4309684957a3c87c61c00b8f0f7940c0a551cbfb8ed2c7dfab29a13c386efc738a9ca79626b0fd09fd5fee0dff499256ae15724b0d9bd250f921f62927ac3cdad7940d4bae8116134d4f8c125a1c714226325f5ed04e1dccfca9a59cf10a5fab707a23f0bb5689e14e22c11c81085bfa1567f9c7fb3ea020ad361afb07d1d3a00a823f54b508183ce80b8239083806b080f6b6398133d35c0eabb9e6d0ea63055e33c217d0d13ff367545d9b2e5c67801","data":{"slot":"13614874397255959432","index":"13619831851200979112","beacon_block_root":"0xfb7dfdbc48ec41a462934adc59da874da863c414f2a957359bfe84fe3e261422","source":{"epoch":"584402861","root":"0x6d44dabc08b27d412125b6e04f0f031ccd75be80385e4c92ad051ab05d6b6062"},"target":{"epoch":"584787610","root":"0x4702e6bcc81abfb7379fe789a7fdd981c16fc05ccbccfa1d5203931fa8a9f14c"}},"inclusion_delay":"13603307010444203240","proposer_index":"13601654527227519112"},{"aggregation_bits":"0x8b67e68d0f6f127c3ec82772c8a1fc230206b11cd213e40735f015139110dc66154e194e1ce71332aa9916ad722cb3fff311c86b9bf477e5d774761ac06bc2a159ecec8794ea30c15c51e4ff080cf01aea2afb02d3b3368d30a11d1431aa39eb347fcfa62eb81140930170101bbe77f3367b493e23c4e88d6b08900eec5968fccc49a06a466d6aaa39f3bc6bdd4056d459a00175b95e3e710289b3393d2a0a2123e8a4cae35424b5fb03cbb3a2cea2d40c7e9ff49bc3f679f8950f28cf7b61ca9370e5efedf766278c1b264e336026857fa1cbd11948786a2387d5544cf890b72cd14960789ad48679d132bcd5a637a9bb0dd617bdb89b3dee34c8e3562c867a01","data":{"slot":"13604959493660887368","index":"13596697073282499432","beacon_block_root":"0x064dabbc080f7868cb3cf03bec55a784ff8db610eba392631c0f36f230721bb8","source":{"epoch":"583248614","root":"0xe00ab7bcc877b9dee0b621e544447eeaf387b8ec7e1241efc00caf617bb0aca2"},"target":{"epoch":"625186244","root":"0x9ce0b6c1911193380cb232ef0dc00147a0f48f9937278668c60b33d884368482"}},"inclusion_delay":"13963548510595133105","proposer_index":"13961896023083481681"}],"justification_bits":"0x05","previous_justified_checkpoint":{"epoch":"223123644","root":"0x8be6c8917c79927f22583b48cdcfa690a5a57e85e2c77c3971ab4fcf5feda0ff"},"current_justified_checkpoint":{"epoch":"228125379","root":"0x9a8a61923dcbe4803a8bbedf4fea90bc025798b15d655851cb8c7478311701e9"},"finalized_checkpoint":{"epoch":"228510128","root":"0x74486d92fd3326f74f05f088a8d86722f6509a8df0d306dd6f8aede77d5592d3"}}} \ No newline at end of file +{ + "version": "phase0", + "execution_optimistic": false, + "finalized": false, + "data": { + "genesis_time": "87914232", + "genesis_validators_root": "0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef", + "slot": "4669978815449698508", + "fork": { + "previous_version": "0x103ac940", + "current_version": "0x6fdfab40", + "epoch": "4658411424342975020" + }, + "latest_block_header": { + "slot": "4669978815449698508", + "proposer_index": "4663368873993027404", + "parent_root": "0x5cbeb140ec0ad7cb653388caecba483cf66bd817821ed18ca1f3b7f3b9b58a04", + "state_root": "0x0000000000000000000000000000000000000000000000000000000000000000", + "body_root": "0x1f86d83f0bf91cc0d7e07410828140e0dddbb331dc20b6743f9f79e549b50b11" + }, + "block_roots": [ + "0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b", + "0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb", + "0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486", + "0x6b0ac13f8a279ad3abec11bed1a49214f6e7af79b643595df6a38706b338e93b", + "0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6", + "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000" + ], + "state_roots": [ + "0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1", + "0xb88ea93f0a5617e780f8ae6b1fc8e4480ff4abc18f66fc45ada895271cbcc666", + "0xcbafa33faaa1f62b763b1697f350f91515f7aa53462f2500db29d9eff71c7ef1", + "0x924cb53fcabe585d9672e01478b6bbae02eead9d22d5aad151a60e9768fa5751", + "0xa56daf3f6a0a38a28bb547404c3fd07b08f1ac2fd99dd38b7f27525f425b0fdc", + "0x0413923f8a8494fa55044c196eeb367d2800a80969899f2e64ada348863fa491", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000" + ], + "historical_roots": [ + "0x17348c3f2ad0733f4b47b34442744b4a2e03a79b1f52c8e8922ee71060a05b1c", + "0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c", + "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06", + "0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565", + "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0", + "0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650", + "0xda533c406bf3482d8e6e992e756be34172a8c47fc1cc0018350bfe98c946deda", + "0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390", + "0x4d1a19402bb984ca4d0005336ba05e1098babeeb0781f5744712934ae78b2a1b", + "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b", + "0x27d82440eb21c640637a36dcc38e35768bb4c0c79aefa300ec0f0cba32cabb05", + "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb", + "0x999e0140abe701de220ca2e0b9c3b044b1c6ba33e0a3985dfe16a16b510f0846", + "0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5", + "0x735c0d406b5043543786d38912b287aaa4c0bc0f731247e9a3141adb9c4d9930", + "0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6", + "0xe622ea3f2b167ff1f7173f8e08e70279cad2b67bb9c63b46b51baf8cba92e570", + "0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0", + "0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b", + "0x82a81c3f096d065c7e3f5d7df79bd182a53c9471a737cfb9f7c4e9ed95d0f767", + "0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2", + "0x5c66283fc9d547d293b98e264f8aa8e89836964d3ba67d459cc2625de10e8952", + "0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd", + "0xcf2c053f899b836f534bfa2a45bf23b7be4890b9815a72a2aec9f70eff53d592", + "0xe24dff3e29e762b4488e615619483884c44b8f4b37239b5cdc4a3bd7d9b48c1d", + "0xa8ea103f4904c5e568c52bd49eadfa1cb142929514c9202e53c7707e4a92667d", + "0xbb0b0b3fe94fa42a5e0893ff71360feab7459127ca9149e88148b44625f31d08", + "0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd", + "0x2ed2e73ea915e0c71d9afe03676b8ab8dd578b9311463e45934f49f843386a48", + "0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8", + "0x0890f33e697e213e331430adc059611ed0518d6fa4b4ecd0384dc2678e76fb32", + "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8", + "0x7a56d03e29445ddbf2a59bb1b68edcecf66387dbea68e12d4a545719acbb4773", + "0x41f3e13e4961bf0c12dd652f3bf49e85e35a8a25c70e67ffc1d08cc01d9921d3", + "0x5414dc3ee9ac9e510720cd5a0e7db352e95d89b77dd78fb9ef51d088f8f9d85d", + "0x51977a3f0ab3110e2a10e9c6bd0e89b1410ca45142ac42171bb2b169efc281bc", + "0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", + "0x9d1b633f8ae18e21ff1b86740b32dbe55a18a0991bcfe5ffd2b6bf8a59465fe7", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0x77d96e3f4a4ad0971596b71d6420b24b4d12a275af3d948b77b438faa484f0d1", + "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", + "0xe99f4b3f0a100c35d42723225a552d1a73249ce1f5f188e889bbcdabc2c93c12", + "0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c", + "0xc35d573fca784dabeaa154cbb2430480661e9ebd886037742eb9461b0e08cefc", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0x3624343f893e8948a933c0cfa8787f4e8c309829ce142cd140c0dbcc2c4d1a3d", + "0x49452e3f298a688d9e7627fb7c01941b923397bb84dd548b6e411f9506aed1c7", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x23033a3fe9f2a903b4f058a4d4ef6a81852d9997184c0317133f980452ec62b2", + "0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be", + "0xf8eb5a3ea82ccf3c1be1ac153e3f77f273a07343291711b9de6b9dbebc4c9b49", + "0xbf886c3ec849316e3b187793c3a4398b6097768d06bd968a54e8d2652d2a75a9", + "0xd2a9663e689510b3305bdebe972d4e58669a751fbc85bf448269162e078b2c34", + "0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9", + "0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874", + "0x0c0d553e4878ae811024144112c88bbf79a372d5dfdf39730cede08696ad52d4", + "0x1f2e4f3ee8c38dc605677b6ce650a08c7fa6716795a8622d396e244f710e0a5f", + "0x7ed3313e083eea1ecfb57f4508fd068e9fb56c4125942ed01ef47538b5f29e14", + "0x91f42b3ea889c963c4f8e670db851b5ba5b86bd3dc5c578a4c75b9008f53569f", + "0x58913d3ec8a62b95e52fb1ee60ebddf392af6e1db902dd5bc3f1eea7003130ff", + "0x6bb2373e68f20adada72181a3474f2c098b26daf6fcb0516f0723270da91e789", + "0xcb571a3e876c6732a4c11cf3562059c2b8c16889ffb6d1b8d5f883591e767c3f", + "0xde78143e27b846779904841e2aa96d8fbec4671bb57ffa72037ac721f8d633ca", + "0xa415263e48d5a8a8ba3b4e9caf0e3028abbb6a65922580447af6fcc869b40d2a", + "0xb736203ee72088edaf7eb5c7839744f5b1be69f748eea8fea77740914415c5b4", + "0xb4b9be3e0927fba9d26ed13331291a54096d84910dc35b5cd4d721723cde6d13", + "0xc7dab83ea972daeec7b1385f04b22e210f708323c38b84160159653a163f259e", + "0x8e77ca3ec98f3c20e7e802dd8917f1b9fc66866da0310ae878d59ae1871cfffd", + "0xa198c43e69db1b65dc2b6a085da00587026a85ff57fa32a2a656dea9617db688", + "0x003ea73e885578bda77a6ee17f4c6c88227980d9e6e5fe448bdc2f93a5614b3e", + "0x135fa13e28a157029cbdd50c53d58055287c7f6b9dae27ffb95d735b7fc202c9", + "0xdafbb23e48beb933bcf49f8ad83a43ee157382b57a54add02fdaa802f09fdc28", + "0xed1cad3ee8099978b13707b6acc357bb1b768147301dd68a5d5beccacb0094b3", + "0x4dc28f3e0884f5d07b860b8fce6fbebc3b857c21c008a22d42e13db40fe52869", + "0x60e3893ea8cfd41571c972baa1f8d28941887bb376d1cae77062817ce945e0f3", + "0x26809b3ec8ec364791003d38265e95222e7f7efd537750b9e6deb6235a23ba53", + "0x39a1953e6838168c8643a463fae6a9ef34827d8f094079731460faeb348471de", + "0x9946783e88b272e45092a83c1c9310f154917869992b4516f9e54bd578680694", + "0xac67723e28fe512946d50f68f01b25be5a9477fb4ff46dd027678f9d52c9bd1e", + "0x7304843e481bb45a660cdae57581e756478b7a452c9af3a19de3c444c3a6977e", + "0x86257e3ee866939f5b4f4111490afc234d8e79d7e3621c5ccb64080d9e074f09", + "0x2fda834311b58db49107ebef3efd6ab3f5f751f2e5ae381ba4e248bbcd2c6f5e", + "0x42fb7d43b1006df9874a521b12867f80fbfa50849c7761d5d1638c83a78d26e9", + "0x09988f43d11dcf2aa7811c9997eb4119e8f153ce791de7a648e0c12a186b0049", + "0x1cb989437169ae6f9cc483c46a7456e6eff452602fe60f61766105f3f2cbb7d3", + "0x7b5e6c4391e30ac86613889d8c20bde70e044e3abfd1db035be756dc36b04c89", + "0x8e7f6643312fea0c5c56efc860a9d1b414074dcc759a04be89689aa411110414", + "0x551c7843514c4c3e7c8db946e50e944d01fe4f1652408a8fffe4cf4b82eedd73", + "0x683d7243f1972b8371d02072b997a81a08014fa80809b3492d6613145c4f95fe", + "0xc8e25443111288db3b1f254bdb430f1c27104a8298f47eec12ec64fda0332ab4", + "0xdb034f43b15d672031628c76afcc23e92d1349144fbda7a6406da8c57a94e13e", + "0xa2a06043d17ac951519956f43432e6811a0a4c5e2b632d78b6e9dd6ceb71bb9e", + "0xb5c15a4371c6a89646dcbd1f07bbfa4e210d4bf0e22b5632e46a2135c5d27229", + "0x14673d43914005ef102bc2f829676150401c46ca721722d5c9f0721e09b707df", + "0x27883743308ce433056e2924fdef751d461f455c28e04a8ff771b6e6e417bf69", + "0xee24494351a9466526a5f3a1825538b6331648a60586d0606deeeb8d55f598c9", + "0x01464343f1f425aa1be85acd56de4c833a194738bb4ef91a9b6f2f562f565054", + "0xfdc8e14312fb98663ed87639047022e291c761d28023ac78c7cf1037271ff9b2" + ], + "eth1_data": { + "deposit_root": "0x10eadb43b24678ab331bde64d7f836af97ca606436ecd432f55054ff0180b03d", + "deposit_count": "4894716627408020434", + "block_hash": "0xeaa7e74372afb92149950f0e30e70d158bc46240ca5a83be9a4ecd6e4cbe4128" + }, + "eth1_data_votes": [ + { + "deposit_root": "0x4a4dca439229167a13e413e752937416aad35d1a59464f617ed41e5890a2d6dd", + "deposit_count": "4883149240596264241", + "block_hash": "0x240bd643529257f0285e4590ab814b7c9dcd5ff6edb4fdec23d297c7dce067c8" + }, + { + "deposit_root": "0x372cd043f2dd36351da1acbb7f0a6049a4d05e88a37d26a75153db8fb6411f53", + "deposit_count": "4878191786651244561", + "block_hash": "0xa9f2ac43b1a372d2dd3218c0743fdb17c9e258f4e9311b04635a7041d4866b93" + }, + { + "deposit_root": "0x708fbe43d1c0d403fd69e23dfaa49db0b6d95b3ec6d7a0d5dad6a5e8456445f3", + "deposit_count": "4879844274162895985", + "block_hash": "0xe3559b43918610a1bdfb4d42efd9187fdceb55aa0c8c9532eddd3a9a63a99133" + }, + { + "deposit_root": "0xf676954331d2efe5b23eb56dc3622d4ce2ee543cc254beec1a5f7e623e0a49be", + "deposit_count": "4874886820217876305", + "block_hash": "0xcf34a143f13a315cc7b8e6161c5104b2d6e8561856c36c78bf5cf7d18948daa8" + }, + { + "deposit_root": "0x92fcc742102977503966d35cb217fc55bd583232b0c551605c08b9c319485bb5", + "deposit_count": "4810439944702424240", + "block_hash": "0x6cbad342d091b8c64ee004060b06d3bbb052340e443400ec010632336486ec9f" + }, + { + "deposit_root": "0x7fdbcd4270dd970b44236c31de8ee788b75533a0fafc28a62f8775fb3fe7a32a", + "deposit_count": "4805482499347339152", + "block_hash": "0xf2a1aa4230a3d3a803b5d735d4c36257dc672d0c40b11d03418e0aad5d2cf06a" + }, + { + "deposit_root": "0xb83ebc4250c035da23eca1b3592925f0c95e30561d57a3d4b80a4054ce09caca", + "deposit_count": "4807134978269055984", + "block_hash": "0x2b0599420f867177e37d0db84f5ea0beef702ac2630b9831ca11d505ec4e160b" + }, + { + "deposit_root": "0x3e269342afd150bcd8c074e323e7b48bf57329541ad4c0ebf89218cec6afcd95", + "deposit_count": "4802177528619003599", + "block_hash": "0x18e49e426f3a9232ed3aa68c7bd58bf1e96d2b30ad426f779d90913d12ee5e80" + }, + { + "deposit_root": "0x778981428fb4ee8ab889aa659e81f2f2087d260a3d2e3b1a8216e32655d2f335", + "deposit_count": "4790610137512280111", + "block_hash": "0x51478d424f1d3001cd03dc0ef66fc958fb7628e6d09ce9a526145c96a1108520" + }, + { + "deposit_root": "0x64688742ef680f46c246433acaf8dd25027a27788665126054959f5e7b713cab", + "deposit_count": "4838532176565923600", + "block_hash": "0x740c2043b0ba6147da79c6d14c13c8515f2b41a40103ee77ae76c4074d9b9c94" + }, + { + "deposit_root": "0x3aa93143d0d7c378fbb0904fd1788aea4c2244eedea8734924f3f9aebe7876f4", + "deposit_count": "4840184655487640432", + "block_hash": "0xad6f0e43909dff15ba42fc53c6ad05b972343e5a245d68a637fa8e60dcbdc234" + }, + { + "deposit_root": "0xc090084330e9de5aaf85637f9a361a8678373decdb259160657bd228b71e7abf", + "deposit_count": "4835227205837588048", + "block_hash": "0x9a4e1443f05120d1c5ff9428f324f1eb6c313fc86e943fec09794b98025d0baa" + }, + { + "deposit_root": "0xf9f3f64210cc7c298f4e990115d157ed8b403aa2fe7f0b8feefe9c814641a05f", + "deposit_count": "4823659819025831856", + "block_hash": "0xd3b10243d034be9fa5c8caaa6ebf2e537e3a3c7e91eeb91a93fc15f1917f314a" + }, + { + "deposit_root": "0xe6d2fc4270809de49a0b32d641484320853d3b1047b7e2d4c07d59b96ce0e8d4", + "deposit_count": "4818702369375779472", + "block_hash": "0x5999d9423046d981599d9dda377dbeeeaa4f357c8d6bd731d384ee6a8a253515" + }, + { + "deposit_root": "0x2036eb4250633bb379d46758bce28087974638c66a115d034a012412fb020f75", + "deposit_count": "4820354852592463600", + "block_hash": "0xf51e0c420e9d60ece0c4bbc926328df885b912727bdc6aa5152e29cc6563470c" + }, + { + "deposit_root": "0x08400642aee83f31d60723f5fabaa1c58bbc110432a5935f43af6c943fc4fe96", + "deposit_count": "4762517914238715343", + "block_hash": "0xe2fd11426e5181a7eb81549e52a9782b7fb613e0c51342ebe7ace5038b029081" + }, + { + "deposit_root": "0x42a3f4418ecbddffb5d058777555df2c9ec50eba55ff0d8ecc3237edcfe62437", + "deposit_count": "4750950527426959150", + "block_hash": "0x1c6100424e341f76cb4a8a20cd43b69291bf1096e86dbc197030b05c1a25b621" + }, + { + "deposit_root": "0x2f82fa41ee7ffebac08df14ba1ccca5f98c20f289e36e5d39eb1f324f4856dac", + "deposit_count": "4745993073481939470", + "block_hash": "0xa148d741ae453a587f1f5d509701462ebdd40994e5ead930b1b888d612cbb9ec" + }, + { + "deposit_root": "0x68e5e841ce629c89a05627ce1c6708c7aacb0cdec1905f022835be7d83a8934c", + "deposit_count": "4747645556698623598", + "block_hash": "0xdbabc5418e28d8265fe892d2129c8395d0dd064a0845545f3a3c532fa2eddf8c" + }, + { + "deposit_root": "0xeeccbf412e74b76b542bfafde5249862d6e005dcbe0d7d1968bd96f77c4e9717", + "deposit_count": "4742688102753603918", + "block_hash": "0xc78acb41eedcf8e16aa52ba73e136fc8cada07b8517c2ba50cbb0f67c78c2802" + }, + { + "deposit_root": "0xc40d6a420fe36b9e8d954713eca44427218922521651de02391bf147bf55d160", + "deposit_count": "4784000204645543599", + "block_hash": "0x9ecb7542cf4bad14a20f79bc45931b8d1483242ea9bf8c8edd186ab70a94624b" + }, + { + "deposit_root": "0xb1ec6f426f978c599752e0e7181c305a1b8623c06088b5480b9aad7fe5f419d6", + "deposit_count": "4779042750700523919", + "block_hash": "0x23b34c422f5dc8f657e44bec0e51ab2840981d2ca63caaa51da14231033a6616" + }, + { + "deposit_root": "0xea4f5e424f7a2a28771b166a93b66dc12d8f207683e22f77941d78d874174076", + "deposit_count": "4780695238212175343", + "block_hash": "0x5d163b420f4066c536ad816e89ebe88f53a11ae2c99624d4a7240d8a925c8cb6" + }, + { + "deposit_root": "0x70373542af8b450a2cf0e8995d74fd5c59a419747f5f4d8ed5a550526cbd4341", + "deposit_count": "4775737784267155663", + "block_hash": "0x49f540426ff48680416a1a43b562d4c24d9e1b5012cefb1979a3c9c1b8fbd42b" + }, + { + "deposit_root": "0xa99a23428f6ee3d80bb91e1cd80e3bc46cad162aa2b9c7bc5e291babfcdf69e1", + "deposit_count": "4764170397455399471", + "block_hash": "0x83582f424fd7244f213350c530fd112a5fa71806352876480227941a471efbcb" + }, + { + "deposit_root": "0x96792942ef2204941676b7f0048626f766aa1798ecf09e0230a8d7e2217fb256", + "deposit_count": "4706333459101651213", + "block_hash": "0x6c624a41ad5c29cd7d660b626ed53268531df243fdbbaca4fbd4dc9c8cdfeaed" + }, + { + "deposit_root": "0x32ff5b41cd798bfe9d9dd5dff33af5004014f58dda61327672511244fcbcc44d", + "deposit_count": "4707985942318335341", + "block_hash": "0xa5c538418d3fc79b5d2f41e4e96f70cf6626eff9201627d38558a7f51b02118e" + }, + { + "deposit_root": "0xb8e632412d8ba6e05272a80fbcf8849c6c29ee8bd6de4f8db2d9eabdf562c818", + "deposit_count": "4703028492668282957", + "block_hash": "0x92a43e41edf3e75667ecd9b815e75b026023f067694dfe1857d7632d40a15903" + }, + { + "deposit_root": "0xf14921410d6e44af323bde913793c2037f32eb41f938cabb3c5db5168485eeb8", + "deposit_count": "4691461101561559469", + "block_hash": "0xcb072d41cdd6852547b50f3b90819969722ced1d8ca77847e05a2e86cfc37fa3" + }, + { + "deposit_root": "0xde2827416d22656a3cf87666640aae36792fecaf4370a1010edc714eaa24372e", + "deposit_count": "4686503651911507085", + "block_hash": "0x51ef03412de8a007fc89e26a593f29059e41e61b8924965e21e30600c869836e" + }, + { + "deposit_root": "0x188c15414d0503391cc1ace8dfa4eb9d8b38e96566ca1b30975f3ca739475dce", + "deposit_count": "4688156139423158509", + "block_hash": "0x2730ae410e57553a34f42f8060bfd5c9e9e90292e167f747f14061500b71bdb7" + }, + { + "deposit_root": "0x3a51a841aea2347f293797ab3448ea96efec0124973020021fc2a418e5d17442", + "deposit_count": "4736078169886867406", + "block_hash": "0x140fb4416e0b76f53fb1c8548d36c1fce3e603002b9fce8dc3bf1d883110062d" + } + ], + "eth1_deposit_index": "4726163266291795342", + "validators": [ + { + "pubkey": "0x8238eb67219c0c314c0b387a1300ebe7ee0b3bfde764c14e90d42e82197100fedb6950f6db432cee0e766cfd35ff22c7", + "withdrawal_credentials": "0x4d72a2414eee13c41e7afed607d1fe63f5ef00b64ef948bc4d43e8e0c0322ccd", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xaf72cddf5e9e8f9e3213202be4447e2eb5a5a61632935ce5695105b936cccae9fc9c504f2bcf511d91531a2738e1d71b", + "withdrawal_credentials": "0xc0387f410db44f61de0b6adbfd057a321b02fb2194ad3d195f4a7d92de77780d", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x83feea64397a7a9d3fbac0b9a16ccbfd63c4d4fa5d0fd8bbfa13739148e752ce1e9b1e01654b56cb56a196fd8d64db3f", + "withdrawal_credentials": "0x9af68a41ce1c91d7f3859b8456f450980efcfcfd271ceca40448f60129b609f8", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xaafd198509805b36458bfa1c0202ea15976ab05f75100f8ed811fb700b4d657531e364c12a87d345f4799c43e2bb5ae6", + "withdrawal_credentials": "0x0cbd67418de2cc74b31707894c29cc66340ef7696dd0e001164f8bb348fb5538", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb9f6a699d12e3b22af90798367dbf0631ebaaaf8f61655d320f1459b2ed90c922371211fd49c3b93e3c5a550730cf272", + "withdrawal_credentials": "0xe67a73414d4b0eebc8913832a417a3cc2708f945003f8f8dbb4c04239339e722", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x85808a97e324987cd03bfc33e49aaa6cbc8a5cb66fb44111b0d8bc8c6b7c810638e6a6ac88d640b3492a684c19053f61", + "withdrawal_credentials": "0xa250734616e5e744f48c493c6d932629d574d0f2b953d406c14b88999cbfbe02", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x99b20a6a3e75af8e62e7f3f5143a149ab8e4ff041b0bf44e70174c19184e0ad2d612a3cd648ac30b428469bde0d1cea2", + "withdrawal_credentials": "0x7c0e7f46d64d29bb09077be5c681fd8ec96ed2ce4dc2829266490109e8fd4fed", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x962f9f117cb8bfe6d6bcc374161f8e605cdff99bee8161ed5b527987f0e5116f94821f23f28773da660a420525bd4201", + "withdrawal_credentials": "0xefd45b4696136558c998e6e9bcb6785dee80cc3a937677ef785096ba06439c2d", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8b585aa726039b4472f9552d0c79479cb6adc817b80667143271f83ddea3228455397c6ac7e29e6fa703eb31e8674828", + "withdrawal_credentials": "0xc8926746567ca6cede12189315a54fc3e17ace1626e5257b1d4e0f2a51812d18", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xaec6dab7580191dde7d836f49c0e9639ec9f7306f25cf1c37b212a28244f1b8144c1a05919239caec52ba139fede301b", + "withdrawal_credentials": "0x3b5944461642e26b9ea483970adaca91078dc8826c991ad82f55a4db6fc67958", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xaa7d67cf12895fe67b0023fb9c2fb0b7a60bd3b9c90c01dd758002a19265cc9c2fa5338b6a59a5a0b648140752ddf8a0", + "withdrawal_credentials": "0x15175046d6aa23e2b31eb54063c8a1f7fa86ca5eff07c963d4521d4bbb040b43", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa0e27864d6b654c4d9b58d1248ca6a494b47d5764847ce585f31df6aa5cf24d17113207ac820b0a5f6da0df2b182931b", + "withdrawal_credentials": "0x87dd2c4696705f7f73b0204559fd1cc62099c4ca46bcbdc0e659b2fcd9495783", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb18269548d92185838a418050a4c9523838a4704849986ca7d0e2c1b360c8319011a2df056268abf89350de67d1b1b78", + "withdrawal_credentials": "0x619b384656d9a0f5882a52eeb2ebf32b1393c6a6d92a6c4c8b572b6c2488e86d", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa211797aa69f18ce249575da91eca37736093b7339a10fa1272692ddd82239fd8f6b75b36a796721b81d6d9a23fabf84", + "withdrawal_credentials": "0x713fd146172bf3f6a05dd5853306de577144e0d254c84764e5385015f6b14857", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb2463b15365ee966c742aab78e5a694f1f4eee7ba5e633930b0c5f587ff65fa8d7d4ad918a8120fdfc1c69c2ef175b70", + "withdrawal_credentials": "0x4afddc46d793346db6d7062f8cf4b4bd653ee2aee736f6ef8936c98442f0d941", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xab4bbb1caad2be96ce362592fcc04c8c71734b59fef25d4cdd59bf6aa351ddcb63f5361e5d9dce661efcd56b4218f929", + "withdrawal_credentials": "0xbdc3b9469759700a756972338229308c8a50dc1a2debea4c9c3d5e3660352682", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x955246320f9112d6559264b15d335ec4e9bb68ab2b73dc08b242944b4aa4741d391a89f3cd3382a858b5e6ec9bf33b6e", + "withdrawal_credentials": "0x9781c54657c2b1808be3a3dcdb1707f27e4adef6c15999d8403bd7a5ab73b76c", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xad37627de08eb0d0bedbc4f9b6a4aa2e002627ff5cfbb6959490b144fbfc6a331e9dc0c4c712ffb05a9f0d42754dab30", + "withdrawal_credentials": "0x0948a2461788ed1d4a750fe1d04c82c0a35cd862070e8e3553426c57c9b803ad", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x975152efef95e4e4af3a6a0f79b1f3aeefb81320c04467fb624ec2adffb3af5062b55b8c5783552a7c5a190ef20b36d7", + "withdrawal_credentials": "0xe305ae46d7f02e9460ef408a293b59269756da3e9a7c3cc1f73fe5c615f79497", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa6e40ebe55ee13712a34981540bdd953448f1352d13742cfd7ae8abe89b0745a679a86aee7b5b416e5a3a87170ddae87", + "withdrawal_credentials": "0x56cc8a4696b66a311f81ac8e1f70d4f4bc68d4aae030311e0a477a78333ce1d7", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x91866281e564f2166e4763df3b138fd387f17ffcc7b347fdbc1fb50a31655dd39ec1d682f5044ce69eab524aa4007a87", + "withdrawal_credentials": "0x308a9646561faca734fbdd37785eab5ab062d686739fdfa9af44f3e77e7a72c2", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x933ff51b3543f3a53e0408f9553e242db71f4da386e07a2c50116023f5b6a897dc2ebe40df4f89381081fc5b651b81b4", + "withdrawal_credentials": "0x0573b7451559d1e09beb31a9e2adb7cb9dd5b032846aed4b7a71f8a1e8daaa59", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb6a7219422fa8dcf311dce6f2daad64d8e7add1905e755ea43e40df9399d45fa201292eac717cdd6bb09e438706b186b", + "withdrawal_credentials": "0xdf30c345d5c11257b16563523a9c8e3190cfb20e18d99bd71e6f711134193c44", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8348da0d73db2e9e07fdf61060b5fe240a884c2e8edd48077f6ba522ce0a23fec3f5b5277795bb959c76b44dabcdb37b", + "withdrawal_credentials": "0x52f79f4595874ef470f7ce5630d10900b6e1ac7a5e8d9034317606c3525e8884", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xac026719d44d1e8eae15ec4df24eed0d77a2f463792f5ba9253d23d50f8f19d3e82eb735d2acfdf7105f5bda84530487", + "withdrawal_credentials": "0x2cb5ab4555f08f6a8671000089bfe065a9dbae56f1fb3ec0d5737f329d9c196f", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8040a9aa1a7c18f8db862015ea6ba5b260a3790640302913eafef678d40c66805f05cf1a0f46a2254ebc8dafe79e2bca", + "withdrawal_credentials": "0x9e7b884515b6cb0745036c047ff45b34cfeda8c237b0331de87a14e4bce165af", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa8a8f5fd201bc673bada188e1ad794d70c44272af3dcc856e38055f602e26747fbb3506f172aa018d083b3690f2e644c", + "withdrawal_credentials": "0x78399445d51e0d7e5b7d9dadd7e2329ac2e7aa9eca1ee2a88c788d530720f799", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb932d4eee66120398141d5d9a50d71dc9e7c6950a9a65e917d3a86b33d887189c85a728c4bb6c1ae82e63e46454a28d6", + "withdrawal_credentials": "0xebff704594e4481b1a0f09b2cd17ae68e8f9a40a11d3d6059f7f2205256543da", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa421315146222618b1c57f9e304785c4de36458dade253a459e577566b4d806ff1691c5ebc8a974cb4ed8b1704ba3c42", + "withdrawal_credentials": "0xc4bd7c45554d8a9130893a5b260685cedbf3a6e6a4418591437d9b7470a3d4c4", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8d33433c914c5ca722b0683f97f4d05e012cdc85633a3d2581b2b1c7a57248c60b9446d89e224655c04be566c60127fa", + "withdrawal_credentials": "0xd4611546169fdc9248bcbdf2a7206ffa39a5c0121fdf60a99d5ec01d42cd34ae", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8cc3ed86d17823dc4f2e7b26afd5cc158a9aa0eae455d3036a12b58ba820ef469bc6c96b924993a742bee6a6935b28d4", + "withdrawal_credentials": "0xae1f2146d6071e095d36ef9b000f46602c9fc2eeb24d0f35425c398d8e0bc698", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa022cd8d35607db7b3261c18d36951b7b9cfefb4a5154e5c04588a4272f31edd43e722febde2bdc2a4a87c996bf00451", + "withdrawal_credentials": "0x20e6fd4595cd59a61cc85aa0f643c12e52b1bc5af80104925563ce3eac5012d9", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa8a931213b70226a83587756c4600a2ff88d2cd4eb61fc671e9da331c3a3bc0bbc8ce4a39db7d52998c678514b2eea1b", + "withdrawal_credentials": "0xfaa3094655369b1c32428c494f32989445abbe368c70b21df96047aef78ea3c3", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x944871d0c9f5ed3f398b2affdc4c9bc535a38c093e20ada27d8fe171fec1a1b990243883afed5eabe561c6ec39864b30", + "withdrawal_credentials": "0x6d6ae64515fcd6b9f1d3f74d446713636bbdb8a2d224a77a0c68dc5f15d4ef03", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa4d9a7333cbbfe1b43c81d96c2c75624494864a7759e7831003e4604f678699fda282c3ea510c99c98c75bba3cc4604b", + "withdrawal_credentials": "0x4628f245d5641830074e29f79d55eac85eb7ba7e65935506b06555cf611281ee", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x85ecf16940353cf72aee4b4aa8fec6c881b79dfdb7b6204dc13793b9ce153a6cb43870db19659f5a222433f938206fe9", + "withdrawal_credentials": "0xb9eece45952a54cdc6df94fb938a659784c9b4eaab474a63c36cea807f57cd2e", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x872247e7012206c1e5435f7743d5a555239339733524372121b95ca339504d44094c6f908f08ebd2b53cb1ed085a245a", + "withdrawal_credentials": "0x93acda4555939543dc59c6a4ec783cfd77c3b6c63eb6f8ee676a63f0ca955e19", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa5a7604c7f72ebb0fb5471a96b8d49762c6b75aec9ff44cfa2e312f9cd296a3e9375b891d785438dd48aedfadbc426e2", + "withdrawal_credentials": "0x6995fb4414cdba7c434a1a1656c8486e653691724f810691329768aa35f696b0", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x93818d1d96a9323ef0447a95838d42dd1a09a4b9037c00beaadd6080835ccc5d99ac25688d65530811641e17dc3180b3", + "withdrawal_credentials": "0x42530745d435fcf258c44bbfaeb61fd45830934ee3efb41cd794e1198034289b", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb6347454b98399213bb55322bae7cefb903ed09c594c87259f31ed3232db2aace12fa70185509888bfa245ad225f769c", + "withdrawal_credentials": "0xb519e44493fb37901856b7c3a4eb9aa27e428dba29a4a979ea9b76cb9e7974db", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xac572911123c11d2009e1c385f22fe42d16a679775646eab6fbc8be798be02f77a9b57cfb06550539c024e059e30bb34", + "withdrawal_credentials": "0x8fd7ef44546479062dd0e86cfdd97108713c8f96bc1258058e99ef3ae9b705c6", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa061bb193abe9246eaaaac35b76cb8d70f8239298069c7396da3411f63e7911a392161acd162c21fdf833d60f806d169", + "withdrawal_credentials": "0x019ecc44132ab5a3ec615471f30eedd6974e890202c74c62a1a084ec08fd5106", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xaa5d57db0f3b58f238b9be564a977b953a1de9d6b4d8a2be7dbcf0f0cb0200a73ab14bd5c069d53db8d46fb226672562", + "withdrawal_credentials": "0xdb5bd844d392f61902dc851a4bfdc33c8a488bde9535fbed459efd5b533be3f0", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa81cbb669ab9ae9951ebf7a143b4a3a83c8884fb2f0420e95e61904de24a3b27e9426687419c48645f9a7a1720ebe50b", + "withdrawal_credentials": "0x4e22b544935832b7c16df11e41323f0bb05a854adce9ef4a58a5920d71802f31", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa1ddf7f024df4dc53d70a695ddefc6741afb9b002e686ea528975765b1d8b61e8d60cf4984178799c67df3ba3156c9d3", + "withdrawal_credentials": "0x28e0c04453c1732dd7e722c89a201671a35487266f589ed6fca20b7dbcbec01b", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb4f2ab7d49b6f55517d4eeb28c540fdb9dffbab0c13bc76e07a434fee9b383521a0fd9f6639a8546fa3671a00a211009", + "withdrawal_credentials": "0x378459451413c62eef1aa65f1c3b009d0106a152eaf579ee568430268fe82005", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb1efeeb48386e83b4966e55d834fe07b63ab3cdb59c1c4aaccfd587a819445c50237894bef43d235d7deebbce23a77af", + "withdrawal_credentials": "0x11426545d47b07a50495d7087429d702f4ffa22e7d64287afb81a995da26b2ef", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x92e12d76878e0de0473c4c6782c1792e4e70baa2852acf055bc3c88737dc845d3660e0f91a57be075718545a4e45f1a6", + "withdrawal_credentials": "0x8308424594414342c426430d6a5e52d11a129d9ac3181dd70d893e47f86bfe2f", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8534c9f9cb0ad52f9d80709583a57518b5479ce39f2027503bfdf5c15f2c6bf277ed0fa8ded816d106bfa94ae5884d56", + "withdrawal_credentials": "0x5dc64d4554aa84b8d9a074b6c34c29370d0c9f765787cb62b286b7b643aa8f1a", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x95a323d2a4bf702d248584876975f60cca9ec15ff0888d928f8f3798e1ebb55d9b1704a2369db37a4874cf20c1fa18ae", + "withdrawal_credentials": "0xd08c2a451470c0559932e0bab981a405331e99e29d3bc0bfc48d4c6862efdb5a", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb0b0c8a0b5cc2eb6b35db821eb29d759fb33284bd5ccb325b1f8a96e07ca96d12037edc86443b642ec6db22e0c6487e3", + "withdrawal_credentials": "0xaa4a3645d4d801ccaeac116411707b6b26189bbe30aa6e4b698bc5d7ad2d6d45", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x875a76a3e345afee45e7181cea2f8e1f85160eb87b48f1fe8813872d412b08b2f4ff9515eacdab1157f02eec3396e2f0", + "withdrawal_credentials": "0x1c111345949e3d696e3e7d6807a5f6394c2a952a765e63a87b925a89cb72b985", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x92859a8dd8bc58c9c35ba7b5a03f68937dcd6a168c1986f2367dd115d07b596dcdc305ef4aefc5c20d0e15b2dec71458", + "withdrawal_credentials": "0xf6ce1e4554077fdf83b8ae116093cd9f3f24970609cd11342090d3f816b14a70", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x94c1b49cfe20e8babbf7fa80d5989fbe24118149ac9adfabb587eb6ee462b2f6f812b32fd29c1abbf52ad0801ea1c28b", + "withdrawal_credentials": "0xccb73f441241a418eaa80283cae2d9102d9771b21a981fd6ebbcd8b281118307", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8244460fdae46ef761855909e46c678b8386f473d146da67b2b0899c88053b12fbf6d2b540587e413a6bd5485d330d2d", + "withdrawal_credentials": "0xa6754b44d2a9e58e0023342c23d1b0762091738eae06ce6190ba5122cc4f14f2", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x89c7d432a62ab14608090ffa3b53ea83ab1bcc3b450ec2e93d8bc60779b88f1cec594b0ec28148af581cdf069511d950", + "withdrawal_credentials": "0x183c2844926f212cbfb49f3018062c4546a36dfaf4bac2bea2c1e6d3ea946032", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x86f0ee71fb95022911b594c7db22b94cd37bd1a70b1a36ebb452e7bdf02cb25d3805ad622fa28a623ad20ecb625302f4", + "withdrawal_credentials": "0xf2f9334452d862a2d52ed1d971f402ab399d6fd68729714a47bf5f4335d3f11c", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb9546c91cbd47bcfa488a983fd877aca4c8291f35064c6df05213232a4e5794f32a0dd52deb6d3c060fbcd823872340f", + "withdrawal_credentials": "0x65c01044129e9e3f94c03cde67297e795faf6942cddd65a759c6f4f454183e5d", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8cc8d50ab70030baadfc940c13e40a0f1e94a78cdc96c7e1006a596e69f9a4180649763c3c1c232b4b84d81c1beb01f9", + "withdrawal_credentials": "0x3e7e1c44d206e0b5a93a6e87c01755df52a96b1e604c1433fec36d649f56cf47", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x80419c71149761ff351d665bea6c7d874588e8c8a3462cc38d4059b700b65280591e10bf9f1b386c32a9f20ebfe7ae85", + "withdrawal_credentials": "0xb144f94392cc1b5369ccd98bb54cd0ad78bb658aa700099010cb0216bd9b1b88", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa9fc3471260f9b26aaec3c23ad10ce7b1397e412c3b2244fd28350d4a3600e9eb15bacfd9d96b27a0d3f6dd32f3249aa", + "withdrawal_credentials": "0x8b02054452355dc97e460b350e3ba7136bb567663a6fb71bb5c87b8508daac72", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa9208ba9a2194fe136236f55ba1386e75220d78b87f13c5c271840ffa732d1ba5ed1d61791eeab0b79b6a50ee0bd9640", + "withdrawal_credentials": "0x9aa69d441387afca96798ecc9055913fc9668192b50c93330faaa02edb030d5c", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x80c96133fbd52e79a7942109776cbb23bdac979244528e097f1e916a4d0b7463b4af2d7f4c6b06a820596d7c7688775b", + "withdrawal_credentials": "0x7464a944d3eff040acf3bf75e84368a5bc60836e487b41bfb3a7199e26429e46", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb65586852e5e24552200524b31eb54f3bf83782fc3afd6c1b45b30061ed98eb36dfb2414622cb3fecf0aa32680885f22", + "withdrawal_credentials": "0xe72a864493b52cde6b852b7ade78e373e2727dda8e2f361cc6aeae4f4487ea86", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x9923628ca9e4bf029de23f10ea12be7c68fcf0babb9b2e94b6d854bfc26488222271bb11d870f79e7fbc8d572e465096", + "withdrawal_credentials": "0xc0e89144531e6e5481ff5c233767bad9d56c7fb6229ee4a76aac27bf8fc57b71", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8d87ba1c7738f7b14b45562d993016c3aaff28d66c06006edd27e779404adf72ea01d5cf02752f07fba516a4020c6e02", + "withdrawal_credentials": "0x33af6e4413e4a9f14091c8272d9c35a8fb7e79226852d9047db3bc70ae0ac8b1", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x99cee98eb05f310aa7c0cf69a7adca06b50e927abd98f66a46db9aecd28bb159f81d18ef22b5512abe7ff7e6592dd416", + "withdrawal_credentials": "0x0d6d7a44d34ceb67560bfad0858a0c0eee787bfefbc0879021b135e0f948599c", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8a56d6d4a228b9a437aafbe1cd67630270694e0bc258ad06eeacebc2bb9f91896c77347f7b0fb9ee018c75ce48069df6", + "withdrawal_credentials": "0x7f33574492122705159d65d57bbf87dc148b756a41757ced34b8ca91178ea5dc", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x89b56335a0f6072a50c7f4c2a7f6c13375c0539ec6e96e589ce6f092101ca469d5c68dbc609deb6c6720cfc3ca1c1211", + "withdrawal_credentials": "0x59f16244537b687b2b17977ed4ad5e4207857746d4e32a79d8b5430162cc36c7", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x82e63946d7ecd5b029e583d716980121ac053036c8e2539c54590fd093b8a199125ca81e05437e2f32d9ba615e782e14", + "withdrawal_credentials": "0xe2e1d58f9895b65d8f9384b1123e78a8b8a62aff6d6c0709a38fb94de115840e", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb85ace936ff7c586f535dd9d099a9912156fa573e68c15cb4e59119735c4f2e217ad50be7432d0ad07d9ef0ce922748f", + "withdrawal_credentials": "0xbc9fe18f58fef7d3a40db65a6a2c4f0eaba02cdb00dbb594478d32bd2d5415f9", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa85181d81a61491234a89ce78b38a32a65a30883676c02327d51f37eccac79b09b159d77e3a8c357c613a42c34c476d8", + "withdrawal_credentials": "0x2f66be8f18c43371649f215f6061cadcd1b22647468faaf15a94c76e4b996139", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x954c039820868bcf0462ce5f03f7b1b580f6a1d3a6b11e563a111b99e1b6054cd85c0a2a8bee9aefd2662ce57389c26e", + "withdrawal_credentials": "0x0924ca8fd82c75e779195308b94fa142c4ac2823dafd587dfe9140de96d7f223", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x92fa07603f121755a03f501e681c7925c4d7ac722677a7afc30ac3ca17edc591a3556a07c3389454b6395655410b0851", + "withdrawal_credentials": "0x7beaa68f98f2b08439abbe0caf841c11eabe228f20b24dda1199d58fb51c3f64", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x924bcf588ccd2cc807ebc2a13be45d1d823189083c7ceba599dec6c4efc2fe584f2feb773acc6ea29023986b0c878c3c", + "withdrawal_credentials": "0x55a8b28f585bf2fa4e25f0b50873f376ddb8246bb320fc65b6964eff005bd04e", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x87bbe1851c1c76dff5724ff9ea4991eb18cd973368e2fffc0a8f96a989dba8b3ba2364f472ee3ae5efa88cffdf0dcff3", + "withdrawal_credentials": "0xc86e8f8f18212e980db75bbafda76e4503cb1ed7f9d4f0c2c89de3b01ea01c8f", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8fd60c26c770f756f5755e24dd842815bec4d2a4d5972bed81f619d65f5c438b55d0815a51fb7ac29103ca30d56d3f12", + "withdrawal_credentials": "0xa12c9b8fd8896f0e23318d63569645abf6c420b38d439f4e6d9b5c2069dead79", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb9d761f4aae30c40a134536e82fe10a005776769a9aafa8828d84a2f6e2108324d3fc4b9dba8ff9389ee58fe7a891de1", + "withdrawal_credentials": "0xb1d0339099dbc10f3b6410fbd8b02fd754763adf08e17a66c77c81c93b080e63", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8f8a44d7b8bf1a9c4b0da59fd1c5b81fcd7f4bb65f74f5c15070896d801adade1afa3057e4446fc4485c95d8bba45322", + "withdrawal_credentials": "0x8b8e3f905944038650de41a4309f063d47703cbb9b4f29f26b7afa3887469f4d", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xaea0272cf434061757f99e10bf69a3d360582f9e017bccd33004f4171480da267ccbe05e2bab415fc721cbe05331ac70", + "withdrawal_credentials": "0xfd541c90190a3f231070ada826d4810b6d823627e1031e4f7e818feaa58beb8d", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x9352921ea86b4fcafb31353d6f6ec851f016bfd040261c0d25ed31513dd96f90db5aec8b62b4f01de27c844e5f938fd3", + "withdrawal_credentials": "0xd7122890d972809925eade517fc25871607c38037472ccda227f085af0c97c78", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa90d76c381296c7771550ec8802afdcd871323230b5fa6293372c211f13ecf26bea3529c6f3961efa6bd9f14f71ea78f", + "withdrawal_credentials": "0x4ad904909938bc36e57b4a5675f7d33f868e326fba26c13735869d0b0e0fc9b8", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x90426a54b52002ce7dedc53271685fac6fd34fc9f2ada48b0e973cfb70c1bfc669f8edb600fdc09a829dbb64754f70ee", + "withdrawal_credentials": "0x2397109059a1fdacfaf57bffcde5aaa57988344b4e956fc3d983167b5a4d5aa3", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb04eaf02e2c89a51c4a85719508e42e156e4b007be028a32c4b82f07a2caf480c200d239925858a9b1b06fe2ffe194c0", + "withdrawal_credentials": "0x965ded8f1967394aba87e703c31a26749f9a2eb794496420ec8aab2c7892a6e3", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x92d58fc2e15dabb9856d510362e29e3005eaf5afdaa6d73167910088cde285df049e183e7a073948228a32a7bcef4157", + "withdrawal_credentials": "0x701bf98fd9cf7ac0cf0119ad1c09fdd99294309327b812ac9088249cc3d037ce", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb2504cc3cfc396fd5d1c8bd0fb28abdb664cefce90c0e215fed809e0e003db8a213316794641974d8b41fb2e4e8a8e71", + "withdrawal_credentials": "0x46041a8f9709a0f936f26c1e8658094b80070b3f3883204e5cb529562e317065", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8fd5bfb6f3fc8289b2b96f61e85314fff9451620ff76e02ecd1f1e18f85a1d28d7d372757c5f62651e5ccc8747e88e9a", + "withdrawal_credentials": "0x1fc2258f5772e16f4c6c9ec7df46e0b073010d1bcbf1ced900b3a2c5796f0150", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa6257c4d665a74781c6474bbbd9e3654816800d9e620d6599a9d07d90ecc25b30bc2162406a110b04fb0287170b22bbc", + "withdrawal_credentials": "0x9288028f17381d0d0bfe09ccd47b5b7f9913078711a6c33613ba377797b44d90", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x9816d5dfe480e7407fa48799e97613b36b7e3f4ea40409d459afe79289f0865b489047923236c33de8d6fa5064e21012", + "withdrawal_credentials": "0x6c460e8fd7a05e8321783b752d6a32e58c0d0963a51472c2b7b7b0e6e2f2de7a", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x85af0debd8150ab283be02193d85ec6cc5bf83d5150dffa39a373e143166f556d84d80bb1639d3e9eae8f77d32607f3e", + "withdrawal_credentials": "0xde0ceb8e97669a20e009a779239fadb3b21f03cfebc8661fcabe459801382bbb", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa582b36ff4fdd89b42b41257e74f4ebef541d58eb26ec16690cea2186ad86b636fcf7b152cff1cb937ebb5dec4c0b41f", + "withdrawal_credentials": "0xb8caf68e57cfdb96f583d8227c8d8419a51905ab7e3715ab6ebcbe074c76bca5", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa9eace0075c4fd875cd34d1d33b70388239c8d2fb261d7f7de5410290ade122beb97e55eff954d6dcb34810dd689f309", + "withdrawal_credentials": "0x2b91d38e17951734b515442771c2ffe7cb2bff16c4eb090881c353b96abb08e6", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb8402ce87952bdd62fe35a001d5e6eeec1589ce7b17b533a549bc8ea0c623bc90b307a517c55b0b378d9a477c8bfaea3", + "withdrawal_credentials": "0x054fdf8ed7fd58aaca8f75d0cab0d64dbe2501f3585ab89325c1cc28b5f999d0", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb118ece6890d73c69e078778e485a36ec4c46c13835cbb0851e91203d23e92796a6d3db24576f30416ab1e821faf404f", + "withdrawal_credentials": "0x14f3778f984fababe2c2f8674ccbc0791cd71a1fd3f793ab7fa2f1d18823fab9", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xb5e5eea094bd1d47e8af58b0cf0923cec826c0273af1d70bd13c61bf1018314c962786640e23b4b99a4ca97c1e3b2fc5", + "withdrawal_credentials": "0xeeb0838f58b8ec21f83c2a11a5b997df0fd11cfb6666423724a06a41d3618ba4", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x98e1a9f686747193e5c4c2ef173376d7fa6eba245a6be60e1f03a4b8602ca44fa9c1854dfb74168650bef2ea472a71cc", + "withdrawal_credentials": "0x6077608f187e28bfb7ce95159aee12ae35e31667ac1a379436a7fff2f1a6d7e4", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa670ca0acad87fd703652fd6b5637ea08f0574ea796624bd53506ebc2987e74aad2ce81ad8944a00ea65e2c012a8ddcf", + "withdrawal_credentials": "0x3a356c8fd8e66935cd48c7bef3dce91328dd18433f89e51fdba478623ce568cf", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x967b31c6012734f4e06ec9c0213237fdf20c6f7a78d9cbbec2f7dbcfa02494f0176fad563f70226fdfa1c7e093fcc2b2", + "withdrawal_credentials": "0xadfb488f97aca5d28cda32c3e91165e24eef12af853dda7cedab0d145b2ab50f", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0x8c8669dd614a7d7e1be27c78d93f74445cd05ebffc97d6140770f324aac71e7600f24c07eff9671f844b33f03c57afc3", + "withdrawal_credentials": "0x87b9548f5715e748a254646c42003c4841e9148b19ac880892a98683a66846fa", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + }, + { + "pubkey": "0xa7eea08884d0e81c6c4d044b6a5c624432fcbff44af67d95c889140a51b033e14adc747f85773b375d9d93f864728d59", + "withdrawal_credentials": "0xf97f318f17db22e661e6cf703735b71667fb0ef75f607d65a4b01b35c4ad923a", + "effective_balance": "32000000000", + "slashed": false, + "activation_eligibility_epoch": "18446744073709551615", + "activation_epoch": "18446744073709551615", + "exit_epoch": "18446744073709551615", + "withdrawable_epoch": "18446744073709551615" + } + ], + "balances": [ + "10316516445055493815", + "10321473899000513495", + "10319821411488862071", + "10258679506701745558", + "10257027023485061430", + "10261984477430081110", + "10260331994213396982", + "10252069569540041750", + "10250417086323357622", + "10255374540268377302", + "10253722057051693174", + "10245459636673305237", + "10243807153456621109", + "10248764603106673494", + "10247112124184956661", + "10238849699511601429", + "10237197216294917301", + "10242154670239936981", + "10240502182728285557", + "10285119251053593494", + "10283466763541942070", + "10288424217486961750", + "10286771734270277622", + "10278509318186856982", + "10276856830675205558", + "10281814280325257942", + "10280161801403541110", + "10271899381025153174", + "10270246893513501750", + "10275204347458521430", + "10273551864241837302", + "10265289439568482070", + "10263636960646765238", + "10268594410296817622", + "10266941927080133494", + "10205800022293016980", + "10204147539076332852", + "10209104988726385237", + "10207452505509701108", + "10199190085131313172", + "10197537601914629044", + "10202495051564681428", + "10200842568347997300", + "10192580152264576660", + "10190927664752925236", + "10195885118697944916", + "10194232635481260788", + "10185970215102872852", + "10184317727591221428", + "10189275181536241108", + "10187622698319556980", + "10232239762349897621", + "10230587283428180789", + "10235544733078233173", + "10233892245566581749", + "10225629829483161109", + "10223977346266476981", + "10228934800211496661", + "10227282312699845237", + "10219019892321457301", + "10217367409104773173", + "10222324858754825557", + "10220672375538141429", + "10212409959454720789", + "10210757476238036661", + "10215714921593121749", + "10214062442671404917", + "10575956426039018910", + "10574303942822334782", + "10579261392472387166", + "10577608909255703038", + "10569346488877315101", + "10567694005660630973", + "10572651459605650653", + "10570998972093999229", + "10562736551715611293", + "10561084072793894461", + "10566041518148979549", + "10564389034932295421", + "10556126618848874781", + "10554474135632190653", + "10559431585282243037", + "10557779102065558909", + "10602396166095899550", + "10600743682879215422", + "10605701136824235102", + "10604048653607550974", + "10595786228934195742", + "10594133750012478910", + "10599091199662531294", + "10597438716445847166", + "10589176296067459230", + "10587523812850775102", + "10592481266795794782", + "10590828779284143358", + "10582566358905755422", + "10580913875689071294", + "10585871329634090974", + "10584218842122439550", + "10523076937335323036" + ], + "randao_mixes": [ + "0xcc9b03923c85d9ce8eba32968977d98d668788d1c2f0e4f3a79facfcd8247794", + "0x933815925ca23b00aef1fc130edd9b26547e8b1b9f966ac51e1ce2a3480251f4", + "0xa6590f92fced1a45a334643fe265b0f35a818aad565f937f4b9d256c2363087f", + "0x05fff1911c68779d6d836818041217f579908587e54a5f223023775567479d34", + "0x1820ec91bcb356e263c6cf43d89a2bc27f9384199c1388dc5ea4ba1d41a854bf", + "0xdfbcfd91dcd0b81383fd99c15d00ee5a6d8a876379b90daed520f0c4b2852e1f", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000" + ], + "slashings": [ + "10518119487685270652", + "10509857067306882716", + "10508204584090198588", + "10513162033740250972", + "10511509554818534140", + "10503247130145178908", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + "previous_epoch_attestations": [ + { + "aggregation_bits": "0x5f8eaf0a8405eedd8d1b23877cb087aafbbc0d4c5470c638620ffe76a69b4c6eca3a5a12f67cc47e0295165f7eefd7658e46d60c5b5cebc413aa2d502933802131711eb6726c777403c900e2c481f77893cc8526890a11e754d8210cb319a9bb827f8953a368ec97d2af59ad172a5cb09e80077f57976c3de036b896a6dc495732a1054baf0e526d9cf7493fa7c430f14db3a3938dbe8f8d152206f53a05758f6247fffd465e2afb73a945390f9c8c077e350b129f0600a002fb25f6d51e8a19a0dce9179ffd8dc84753484965a8ba53af03c41ad97793125cb4f48ff89d9a5f0af0f3d9b5120fd28348e329ad632b64f2a2c60f987acf781d9a4605c09902da01", + "data": { + "slot": "10546211710958835421", + "index": "10544559232037118589", + "beacon_block_root": "0x207238929ddcff62ef5f910f18a820582e6c91af59e275680b154df22abd04b4", + "source": { + "epoch": "226394009", + "root": "0xfa2f44925d4541d904dac2b87196f7bd2266938bed5024f4af12c66175fb959e" + }, + "target": { + "epoch": "226778758", + "root": "0x6cf620921c0b7d76c36b2ebd67cb728c47788df733051951c2195b139440e2de" + } + }, + "inclusion_delay": "10528034391280342716", + "proposer_index": "10532991840930395101" + }, + { + "aggregation_bits": "0x052eed1ddda2449b89c72d11f2df83a2b598453a9a5a27fce96023189460d7c5dfdd6c163c4ca2ff1e335468664bcefd22bca3d5f53b9dba95693dbfff6b3a1927083762bc1635909e63f2658ac02899aad3cbc6341d6e209e44724865391719faac816b8c5170a675730651a3847d8a0c1fb692e306ed96e7df532ed99efb41b3dd750f71eda68523735bac256787d44f414a6994dba90c5c9a6d5e869e7e88fad9c22b0ca23a916f41978b6198b83a1b7989b6dfb2241b50f30b42ee7defc2624837aba0e9dfecc2a603f7895378c286ef5afeff7b18f45153140d50eab8c7450729b104c0aeeba0ee186ac0ac4105904d81bde49c80382d40d5c92ea1662201", + "data": { + "slot": "10468544969709910331", + "index": "10473502419359962715", + "beacon_block_root": "0x097c5391fb6104e14b934cac5680419622e26aed2176acc404c395746f7ef4d5", + "source": { + "epoch": "218121908", + "root": "0x7c423091bb27407e0a25b8b04cb5bc6447f46459672aa12117ca2a268dc34016" + }, + "target": { + "epoch": "218506657", + "root": "0x55003c917b9081f4209fe959a4a393ca3bee6635fa984fadbbc7a395d801d200" + } + }, + "inclusion_delay": "10456977582898154139", + "proposer_index": "10455325095386502715" + }, + { + "aggregation_bits": "0x696d247befe49563ad922a94754c3d09c63eed1794770f4f06cdac61b976fe930b14c6838265dbfb3ba0426ca1864579d6cd3ec208fc8565a7bb7f45dd1e7c1dda841fefb3cef40b2a07689710ec8fc5d6f78bbd834be7f5fd512af73a225fd0841f676184629294d17e3d5ba7a5ab7fada39564d76478042740dde775e2a2b78419b06f3030949b98ffa8cbdc06093e46e9ce11b6f81823943fec63501940bee5bb9c16fe723e730d20ea3070fbff11721213ae6d8427cd948a12f1a5d4332dcbc44a3998ad116fe491ab65a6d1b52a3ff4ef2dbea705e58b97447dfa49b5595ad554b68db0f58073fa1813b13cbd39cd8bead8a815b16a50fb6939306e361b01", + "data": { + "slot": "10450367645736450330", + "index": "10448715158224798906", + "beacon_block_root": "0xdbe71291dba19cd6d473bc896e61236667036033f6156dc4fb4f7c0fd1a7d5cb", + "source": { + "epoch": "216775287", + "root": "0xea8bab919cf3eed7eca63f21ef7b0d92c4b4795f72b348dc5531a1b8a3d135b5" + }, + "target": { + "epoch": "221777023", + "root": "0xc449b7915c5c304e022171ca486ae4f7b8ae7b3b0522f767fa2e1a28ee0fc79f" + } + }, + "inclusion_delay": "10498289676200159228", + "proposer_index": "10490027260116738587" + }, + { + "aggregation_bits": "0x9148df7be014de7c40c8ae64024cc6f55ed7189d0a9c014ddefbb44634104059518556d1b2cacf99ed5155e710a65822b557798b1b512d12eb7e4dbbfb98d36ac7680cb7fbdc68886947f5e6de5c4cf26cae09d6941a804092c2c648f88dadadf749575101f87cc1ab961ab4b057f344c1ea1b1fa4df11bcd74a16d8194ce8130787da8b96eff3a3c01efc18ca145acd0dfe6335d05de92e17b230175b166c93567783012272c336e043fa472699b4755849bfea72b0332c4e8221689d0f92502448b236d87bf8320457bf7095479ff11b2bd65aba9f2cc14b2210b101f8643a4e8bd12c0de37b93f0c2e36f090c3c7a4eb9106ea4fc5fd0e7c22fc592255ffb01", + "data": { + "slot": "10491679743333422715", + "index": "10483417322955034779", + "beacon_block_root": "0x96b576913b9cc8438b01e1a7604bc6c7fccf7081dbc1b767f1bb00c35139a895", + "source": { + "epoch": "220815150", + "root": "0x70738291fb040abaa17b1251b9399d2df0c9725d6e3066f396b979329c773980" + }, + "target": { + "epoch": "219660904", + "root": "0xe3395f91bbca4557600d7e55af6e18fc15dc6cc9b4e45a50a8c00ee4babc85c0" + } + }, + "inclusion_delay": "10480112352226699227", + "proposer_index": "10478459873304982395" + }, + { + "aggregation_bits": "0x09602575709e7df892147500a107d58baa3b79ff321117cd423fa648fa3b81ca62dadbf9c5d7b23aa9cfd399eddc35872bddd5e19539c466206004ef8d91366932ec0f6ca4c832141b5eb2d88e4b8b200736f252594a031ff8a33486e07e8cfc3bf73052b151822962a2d2be099bc2ae5091506e1195218819313d7d0c63f21b9021123380e854bbbf213af4072f8f1b1874f6143f1d0c2b4f26bcab730dd67e97a60774b5f4e0cefab781780a76994720f1d73f34508afa176162e1240f24ca9743de5a6b3c7bc03dede90e7633bac148a38a5f8fed9e160040a57c1bfdcb8b2e686a479933804cd0d3238732a09a9eef16cb6e409f03091e455668cd7f024401", + "data": { + "slot": "10420622934951234138", + "index": "10418970451734550010", + "beacon_block_root": "0xcc437a9019504ad5bc4039f2ec46393a095246077b7891aca16e5766ff7d75e2", + "source": { + "epoch": "211773551", + "root": "0xa5018690dab88b4bd2ba6a9b453510a0fd4b48e30fe73f38466cd0d54abc06cd" + }, + "target": { + "epoch": "212158300", + "root": "0x18c86290997ec7e8914cd69f3b6a8b6e225e424f559b3495587365876801530d" + } + }, + "inclusion_delay": "10402445610977774137", + "proposer_index": "10407403064922793817" + }, + { + "aggregation_bits": "0x5bb1dd7848b08b4ef93af2d85feb3ebd419037b7f7b9d78a6a1606cd1a5412486a33da454f80ac0bf63a44219b7f869b33d99c0c9f03fbd6c04d03619b27f7bfbaf5f3bdb3945d09246b4800f51a8616277a488ff0bdd2d6e2f747432545dd96fb62f9469d903aa25908205c8cd20308e1fb8b46c95a0b03ef22bea7e020bd3a5111903177bbb7bc004f7893457cbb039480c355f53337d43394762af5562dc7dd5094a4e3ad7017c5496c10202b86060dee43d48daaac04eb01f74f3879a0d95364efcb214d7afa03587b3b0c6afcb2b9a356f7ab2137e95bb3098cea02657c34ac2c0c969bdd6eac2e624b206502ac8bfaef9728e7f0ebb23e95e420ed435d01", + "data": { + "slot": "10395835678111037625", + "index": "10400793127761090009", + "beacon_block_root": "0x512b5190796165b771150c22b604c9d535673f0578f5aec3e2f62fe0f82379ad", + "source": { + "epoch": "215813415", + "root": "0x61cfe9903ab3b7b889488fb9371fb30192185931f3928adb3cd85489ca4dd996" + }, + "target": { + "epoch": "216198163", + "root": "0x3b8df590fa1bf92e9ec2c062900d8a6786125b0d86013967e0d5cdf8158c6a81" + } + }, + "inclusion_delay": "10437147771413042714", + "proposer_index": "10435495288196358586" + }, + { + "aggregation_bits": "0x890c9f93cd096717568f95f1759e0cba1824cc6df2d6235801e090971a4a56ff05c0f93a4bd21c5f16a5c23ebb0304d9e85b0d6f19ab04f6480f7655c5e2d721f3b0b5b9a54a631ec056915bc29f5cafc5c31c43194ecf6f083180a47862350a3e80c64815d1f6243c15cedb32490dc1eb64add4864a9023a9ac32b1ca9fc14904b8b5373be2329e4c1d7b31cad6479fb797fa58595c4ec98002e978ce81e876371044ffbb11cfaf96f175304bf6bf985371e03398779d4e2926416e5e5cd54150cb5ee416a5488a330155932c15d592d539040b8205848bc822b8a44eee57340addc3d20d793f44c99ba8e076f8a3cd79e0d93f40df7da32da76b3451a32cad01", + "data": { + "slot": "10430537834251338906", + "index": "10428885355329622074", + "beacon_block_root": "0xc074cc905a2d14115397939259cb1903b227540b837e567e215ea6720e326e4c", + "source": { + "epoch": "214466793", + "root": "0x333ba9901af34fae1229ff964f0095d1d7394e77c9324bdb33653b242c77ba8c" + }, + "target": { + "epoch": "213312547", + "root": "0x0df9b490da5b912428a33040a8ee6b37cb3350535ca1f966d862b49377b54b77" + } + }, + "inclusion_delay": "10425580388896253818", + "proposer_index": "10787474372263867811" + }, + { + "aggregation_bits": "0x1ff81e4014af9cff228d16075808fc0de9c288b88aadbdd435fde9183bae4c3b661e215fb9b8d626d065711505ba20e642c5fe88ab3cf8e0830e9cd3969b9f46eab72dd9f51680c634e4c4511950e75692495bd15d98f5c9d5a843d459122db294d13de8665d5c4b6bc5f2bceeac38e78f728a5b6493c66e4065a7a58467971e8bc1ec5a69d2cb6fe3c37c751f523f088a0eff5c49a1926931e335b2b8297342a2aaaea3fb69411f0dd0068911c5dc3661ccc48d6d864a8ff85de48707ae7fbf591628b070f51e125d6a6512a34dacb67e92bd433dcb1e306b1eea6535ae1dfcefd9a51333248577730294787ba00e0559759e52975edeb36ee047e89955f20e01", + "data": { + "slot": "10789126855480551939", + "index": "10780864430807196707", + "beacon_block_root": "0x28749795c36fc7d61eed45239316569597af22daa5a10a83c3e789f3c51fb80c", + "source": { + "epoch": "255442551", + "root": "0x0232a39583d8084d336777ccec042dfb8ba924b63810b90e67e50263105e49f7" + }, + "target": { + "epoch": "254288305", + "root": "0x75f87f95429e44eaf2f8e2d0e139a8c9b0bb1e227ec4ad6b7aec97142ea39537" + } + }, + "inclusion_delay": "10777559468668795747", + "proposer_index": "10775906985452111618" + }, + { + "aggregation_bits": "0x0b1150d0cdfc0eca01aa9a65047441d5feb8476071e06e9642ec85feda355160572d8e7a738363e8c99d262eb1ec4de8f6e3e6c4439fa5d207aacbb68b1e2468fbdac985a682063d869642c17c36b803b346bbe6a360b8b82955bd17199de731e5e81f647a12c15264d9abc1266f7421e48a27ce64b19de6487894368de0e83d58fbb0c2b7796dec0591e8a8883ff95b5f2077b6713dc22e11f9478305b40332b32f0de2087fa8762e8467a71909523075327af6c71779bfc9f43596d097f261c8067ba1db86b40a3e3176e08bbe8c434fc3a4160def6f35b6ac9015297c2c825669acbb59decd7b0dc2e15fa9bf04b9b0848a586b8b2c600bde1b9bd694991601", + "data": { + "slot": "10770949531507091938", + "index": "10769297048290407810", + "beacon_block_root": "0x97bd1296a33b7630006fcd9337dda6c2147037e0b02ab23d024f0086db2dadab", + "source": { + "epoch": "258712917", + "root": "0x717b1e9663a4b7a615e9fe3c8fcb7d28086a39bc439960c9a64c79f5266c3e96" + }, + "target": { + "epoch": "259097666", + "root": "0xe441fb95236af343d57a6a418500f9f62d7c3328894d5526b9530ea744b18ad6" + } + }, + "inclusion_delay": "10805651691942360515", + "proposer_index": "10810609145887380195" + }, + { + "aggregation_bits": "0x452abf40a90c43f5acf411357174e8406ec937f4ac094533c0cd17903241edfe8ff81a38c3dcd5aaad34336d014cd573b3fb298d107b6907f73efc98339a9cdbbcf288b9fcdc0dc789860b00603667adbd5131471e539fc10350f128d22698cffaffefdddd992c9e7a75843e321ce59fbc831bbcb532bb163a346c4bf8daa6f51de5d5449ac61bb781721e6eda2db52416d1cef6f5973b118b36ffea0c323a7f00223337d479456db3675e3f5f7ab91c5ff1f132cc0bd50c9f96e64ce5545ff03b0e1a0f6bb196538f66eae1a81407c87b5215530ad3e409021827bab8fdcb62cf1f6103dbed46c0daf89d535b85976c1b1f756a176342b5e6a5bde3459abdb401", + "data": { + "slot": "10799041754780656707", + "index": "10803999208725676387", + "beacon_block_root": "0x1da5e995034d9112b443a0c3009b365e408530deaca7cf5442d7d8ffd3d3b076", + "source": { + "epoch": "256596798", + "root": "0x906bc695c312cdaf74d50bc8f6cfb12c65972a4af25bc4b155de6db1f118fdb6" + }, + "target": { + "epoch": "256981547", + "root": "0x6929d295837b0e26894f3d714fbe889259912c2685ca723df9dbe6203d578ea1" + } + }, + "inclusion_delay": "10734594883560171937", + "proposer_index": "10732942400343487809" + }, + { + "aggregation_bits": "0x173ff9281191e7dc9d6add4a2e10fe50e07078693bf647e1c8a3cdacddfc7ab4081b86b14da28cceab81a485b83dd53c579488fcabf331271907ade82843b3328edf85dda924ca9299ff8074110a457b2f0ec040f1ed38262b4721289834844b5ab88cd1f4f5bfe7754646596ebbcc70f3faeda60e4806f8b895a3ec13b6ae24ac574bf082d73957e7c11d691f9c225bd67b4403c4253eb4b76f7ce3295ae785c3df6b4812134b60b12dab791b9cf44b7345dc04c6d455ebd7c60d052df9f50685378067b6aac2ee2fb15bfa063f6fd590b06df3ed579f44b8cdb1f07a3ab69016beade47e5ce1983a28adfc89b859b1e8ab51015f78fca06699041948c1867001", + "data": { + "slot": "10727984950693435425", + "index": "10726332467476751297", + "beacon_block_root": "0x5233ed94e10013a4e582f80d8c96a9d04d0706644d5ea999f2892fa381187ec3", + "source": { + "epoch": "249094194", + "root": "0xc5f9c994a1c64e41a514641282cb249f721900d093129ef60591c454a05dca03" + }, + "target": { + "epoch": "247939948", + "root": "0x9fb7d594612f90b7ba8e95bbdbb9fb04661302ac26814c82a98e3dc4eb9b5bee" + } + }, + "inclusion_delay": "10723027496748415745", + "proposer_index": "10714765076370027809" + }, + { + "aggregation_bits": "0x53ed223313edfa3e9c781f8e43698c0603db52b36e0e05a3f3c6c7ef21984d32d47a85b9a7f5420e7511677e5b14720ccfa0595343190a8a9b2aa20d4bb526a57ae6b9842fbcbd9fae4862c466cb01494e414c923839ebbfeb1e5ae4501df7bdf8ef6565b880134f2eecf0bb819a0b45ab7c1589cfefe06b0f44631fa5f1ed2deb5c8bee1d84da0255dc5f07676b066b5fcfa5f08fc58c97436d2e40e0851aaf851fd29eec6b11b987eccb173014680b52d24ece390dc273038b881a918a722d4138b9c4a833c2d21d360bdf7e7531ad4b2bb55a6aa373bf617a74a093a0c0661e328ebee31fbc3afe61e67943693132264631b95709bfc8e086d25bb610c17601", + "data": { + "slot": "10716417559586711937", + "index": "10761034627912019874", + "beacon_block_root": "0x0e01519542fb3e119c101d2c7e804c32e2d316b2310af43ce8f5b35601aa508d", + "source": { + "epoch": "253134058", + "root": "0xe7be5c9502648087b28a4ed5d76e2398d6cd188ec478a2c88cf32cc64ce8e177" + }, + "target": { + "epoch": "251979811", + "root": "0x5a853995c229bc24711cbad9cda39e66fbdf12fa0a2d97259ffac1776b2d2eb8" + } + }, + "inclusion_delay": "10757729661478651618", + "proposer_index": "10756077173967000194" + }, + { + "aggregation_bits": "0xcd708af8a003faa7fe724d2027a573662971e64efcf2f50a3cd19b425c1b7dd838d9b5d73b45c76693d8b4bcb26324a8a83e6f6900c9e0cb8227c266df4a1973fbbea0b7b3ca35800c9c4fad325ff7c0083230133ba470ae7cb7aec5537d31ec36665ec8eb90a2f22cf614d8a063538fbaad5c21d7a753a5c4c00a2811118ea31b7bbcba7967e884cd823c62d8eae57026e401f9de9395669586861eb901aabbf044f0671d22df538448f81f16699165545dc3aba2b96b694c0006ab3d073563dd59b75620ae13eb6821885a4726c47af5784d27094d6eebd4a9cc8ffeeb686f66609bfcc2570b0f8f1364d4ae7048dd16e5f3b33340c0e574b0fe8ad27ccaa201", + "data": { + "slot": "10751119724316947810", + "index": "10749467236805296386", + "beacon_block_root": "0xe06c1095223bd70626f18c0996612e0227f50bf807aab43cdf829af163d33183", + "source": { + "epoch": "250248441", + "root": "0xba2a1c95e2a3187d3b6bbeb2ef4f05681bef0dd49a1863c884801361ae11c36d" + }, + "target": { + "epoch": "250633190", + "root": "0x8f133d94a0dd3db6a25b1224599f11d90862e87fabe3706a4fad181b1972fb04" + } + }, + "inclusion_delay": "10680062911639791936", + "proposer_index": "10685020365584811616" + }, + { + "aggregation_bits": "0x17c8c08ffca1f2b9e1af5184c443b66dcffc0f7e2a8891ccaedecf0c2e7cb67f292cfb63f0c53be7c5e7f4819ac503da26809a30b4ac47f55cf5f3af9f362811ab04a9cf693963a49414f83bfa7f2bbca3099173c23b0f502428d48485688f8c457556f1c7271ae09d307e2c256c76453b86c9adb7121c24db71ca0416753c297e464ab624041e202204ed31d246326db516581217a5aac7d826afa7cd88881f67c2c33b4fd68f1570ccaec6481cadd640618b5ea2ea66408a08e88b1b4553f21d957fa257a2e05ccc18c3a4ee8606db5ef251133941ed0fd00d3c814a95329c7d074496774cd96ec8d49de581fda68c46da3007ed068785e479a8565d67f86e01", + "data": { + "slot": "10673452978773055424", + "index": "10678410428423107808", + "beacon_block_root": "0xc9762b9480c0db84822448a6d4394f401b6be535ce3deb98d830e373a89421a5", + "source": { + "epoch": "241976340", + "root": "0x3b3d08944086172241b6b3aaca6eca0e407ddfa114f2dff5eb377825c6d96de5" + }, + "target": { + "epoch": "242361089", + "root": "0x15fb139400ef58985730e553225da1743477e17da7608e819035f1941118ffcf" + } + }, + "inclusion_delay": "10661885587666331936", + "proposer_index": "10660233108744615104" + }, + { + "aggregation_bits": "0xdba309c98ff30105c35c55133150cac74e60024126f5adfe48b14b3b46cb9b6da8bf7b5246e410cb8ae9f006e6429856d0f42f2741e90b6a140792f3756e63441508e083f6abb71f2678b3726a921b74cd6c5f403520b69115bc9c9bd1766e943ab6c6780da0f97739ab6c5611cda65283e6d270403c01d471a24f58762b6457edc23c9664d12cbdc9cf5936662d16af2d93c46ea4c521a8ccc56f94f396fe18fc6097c4750d0b32cac94534547fe025080a1547d2fefc02ec3870184bf53d1db71b101f46ff67ceda6d6b3e8386d3a5ed646612f6b5f818a380ac18dcb4633b474d3c11e235d04f0708bbdd317d42801bfc79e2b1de9cffbae309be67acac2901", + "data": { + "slot": "10708155143503291297", + "index": "10706502655991639873", + "beacon_block_root": "0x37c0a694618c8ade64a6cf167800a06d982bfa3bd9c6925317985906bea21644", + "source": { + "epoch": "246785701", + "root": "0xaa8683942152c67b23383b1b6d351b3cbd3df4a71f7b87b02a9feeb7dce76284" + }, + "target": { + "epoch": "245631454", + "root": "0x84448f94e1ba07f239b26cc4c623f2a1b137f683b2e9353cce9c67272826f46e" + } + }, + "inclusion_delay": "10703197689558271617", + "proposer_index": "10694935264884916384" + }, + { + "aggregation_bits": "0x9980facac0166e58230ac0570e48763ecd11f8ddab2fa67fa09e9973aeb4e1c7e73ee9c03b7b9483761df52c74e8138d91f66be2d24c465d7813b38ddfd689fb5abb97be7addeaa0462893a806e24c6375657d77a33dc1253e9c40a4ba5c31fb0020284a416216af435742c9171efcebe4e3640b31af2e0e2ba8857152a02a6b6ad8c5b2528c7b46592d8de5093ecb4c26a1517e2145caf55716b3fc7810b227456d8831e90ee6be11064ceb1b1c8b0b32b19f13cde85be1b6db87b5740684fccb437439e743c7a240a6773fa0f06ddcc3f0df2775a1f169117f20b30f4306aa567a3989628e7416f4b84692c00f5bcfd9262242cf06d96e16989762d162c6c301", + "data": { + "slot": "10696587752396567809", + "index": "10688325332018179872", + "beacon_block_root": "0x56b04e94c0fa9fe7c292dca1de04d471f558ebc98889f63bc6294ec28a4fd564", + "source": { + "epoch": "244669582", + "root": "0x306e5a948063e15dd80c0e4b37f3aad7e952eda51bf8a4c76a27c731d58d664f" + }, + "target": { + "epoch": "237359353", + "root": "0x06577b933f9d06973ffd61bca142b748d6c5c7512cc3b2693654cceb3fee9ee6" + } + }, + "inclusion_delay": "10632140876881115743", + "proposer_index": "10630488393664431615" + }, + { + "aggregation_bits": "0x130fc866501c49aae7694bb1b2106479ab47dff9828231f51481475d48658070dd6d44c8005ee9343a1760f12312661077e4ac249124cf18f62e4bd9b3ecad7cf77d50e0b22f5171350f8cc7fcad99d11bae0fe77e61427b40d69e6960eb96ab091e2ccc730ec9cd8b7b86ca3d728b5125be0f7494c15c8a67c5ae45fd2e377f73d6ae4e9dcddc1bae14db09934036fa232bd8679e2506c84e967e70708ae8c80dbd0466e6a8818e0f7221e60663a46a524d11e3498818315dfd440ce11610e28b47121fb17d21e8cb52294c73048ca29859816b69d1516b079d557c0d8011f336190462d6f48dab9ca0846bd1e1702f5c20f756d0752dde7e8183c3dcbd0f3401", + "data": { + "slot": "10625530944014379231", + "index": "10623878460797695103", + "beacon_block_root": "0x8b3e52939fae2179f3d134ec6a0047e402dbc04f2940d08076dca4653894a2b1", + "source": { + "epoch": "235627983", + "root": "0x65fc5d935f1763ef094c6695c3ee1d4af6d4c22bbcae7e0c1ada1dd583d2339c" + }, + "target": { + "epoch": "236012732", + "root": "0xd8c23a931edd9e8cc8ddd199b92399181be7bc97026373692de1b286a11780dc" + } + }, + "inclusion_delay": "10607353620040919230", + "proposer_index": "10612311069690971614" + }, + { + "aggregation_bits": "0xdd2d136e03cc26cd0a39c4c1cd008e9619f22c55cfe93e50e4e2a7d2a2531ed602e44098f847ed46f2c6e4c3933a4a0f38f6e8e43641076eabfaec3b8968430bab5505bd7e55403eee5f0db7901c4ed4f13c4dbc69946d5a2b65d2d7e348e4d607825ed472d12e10f5a38925a629d12b6cf1b15de55a560155ed4172a8b079953a8843ea2a10bd4c5eff2ddb46577d194c5a6c77fa29fd85dc1ba71c611c80d7b6985a862ea07d02d2932d32c3d931cef8469b2746a9fcfb4f16d784d4c7b551714fe39d18c2ab9d3a043c4c700e066aa46dba586ce3e811d520e592ae63f070254fb3c894cf04185a907186429bab6af3ba49c42d863b0bd3b10def5e93afdb01", + "data": { + "slot": "10653623171582911295", + "index": "10658580625527930976", + "beacon_block_root": "0xae03e593004c53bf01481fafbfa345dd668fd90d5aa6d452fe3e0dd7e51eba25", + "source": { + "epoch": "239667846", + "root": "0x20cac193bf118f5cc0d98ab3b5d8c0ab8ba1d379a05ac9af1046a28803640666" + }, + "target": { + "epoch": "240052595", + "root": "0xfa87cd937f7ad0d2d653bc5c0ec797117f9bd55534c9773bb5431bf84ea29750" + } + }, + "inclusion_delay": "10642055784771155103", + "proposer_index": "10640403301554470975" + }, + { + "aggregation_bits": "0x1342f260e90ad7722dc5e2464883387c4869a8294354077259d678a3c8e53741f33f6e2eca438643c9ede054dd4bf197ce6395e6d9265fb9d9128b71a30e050f9f350bb160edc0e3cb23de5c02215e16df68e187bee41e0bf8760ac83b73a85f4879da57dc23cda2c79d9eaea70804fcfc49e28bd31eebb5f77ac13c8c74032d4d4e11ce6dc58bf545fc9abc3cd05b067555e0230a637e2a49be2aab0d06d4d5290a4d63706c78234530428c5b3ba214012d27bba69be585673c663fbe6443355d4194a0491e16380efd95c74d82eb9507e50f6fa637655646dc41820953fdce5795ab530ff418d385c83f5e34ab4c7cba9a2591411d723fec818e8740c133c501", + "data": { + "slot": "10635445847609451295", + "index": "10633793360097799871", + "beacon_block_root": "0x806fa493df8bebb48a288f8cd78427adabb0ce5330469552f5cbf37147489b1b", + "source": { + "epoch": "238321225", + "root": "0x3c45a498a825c50eb623a096a000ab09581da600e95adacbfbca77e850ce72fb" + }, + "target": { + "epoch": "280258855", + "root": "0x1603b098688e0685cb9dd13ff9ee816f4c17a8dc7cc98857a0c8f0579b0c04e6" + } + }, + "inclusion_delay": "11000644797410433544", + "proposer_index": "10992382381327012904" + }, + { + "aggregation_bits": "0x0f853bf134b8389b7dc5689b511018e285b34eec630787e46a11c60815224bc5d1c7a6887e51853a49a8ebffcaf6e3486e79cd454ab5b5e7219242e13ae7e918253cb6d4743382b29e958bbf71aeedeb8ba0c66e4ea7bc353da8d1aa2202b527623882f2a255ff2d8e9cabc96a2d771ab17df5e780e6fdcc3e931518499855e6ca13316736b97bcef3f6edb140698e8ae159a9a6e99c3a8d305f775919adad36b1b8a595b03426bb7af1b0c71b73c1da17552645334dc046502683eea7b6e1af57c57cbd089469b25a96e552865bda4ba669a43ec1b1e94d6801626f135bd70dd659cf3638abb8a83fb903967afbe030c86fa830866470278e64bf6fce92783c01", + "data": { + "slot": "10994034860248729736", + "index": "10985772444165309096", + "beacon_block_root": "0xe86e6f9848ce9e7a557e411d11d0633f91389d22526949579755d7f2fe35e5db", + "source": { + "epoch": "279296983", + "root": "0xc22c7b980837e0f06af872c66abe3aa584329ffee5d7f7e23c535062497476c6" + }, + "target": { + "epoch": "278142736", + "root": "0x34f35798c7fc1b8e2a8adeca60f3b573aa44996a2b8cec3f4e5ae51367b9c206" + } + }, + "inclusion_delay": "10982467473436973544", + "proposer_index": "10980814990220289416" + }, + { + "aggregation_bits": "0xa120cbae17f6ab52f7caa7749cfdf096871efe82416bf71db59a268f60b2e9ef3de614afd2440810d9497d1db90815fafde69f792c455eef2c5d34a8bb18d65cf3456b85b7442b996e44a5163d78726accd14bff093a272cb291218045c07e7680813b76f4074fe888bd6afc089d3fc462f41d4788974887d1367c21ac7426fa3bf5233b21c259584b24add21f81a931ad669dc61c032a6cded45edeb16e3fe0d9e785a8e179a661b86523cdfcfaf2343392202209f36b4d0eeac51f1c39eec8e32c63afc801e125e520b8d5b7fa7e955b085ee15ab9f0755dbff742d619fb2edfea6b681983371842474a7b9ee0eddfdacc6b2aecfb5f5a2a5ab3beba5b51d801", + "data": { + "slot": "11028737024978965609", + "index": "11027084541762281481", + "beacon_block_root": "0x57b8ea98289a4dd43700c98db596b46c0df9b1285df2f011d6bc4d851444da7a", + "source": { + "epoch": "282567349", + "root": "0x3176f698e9028f4a4c7afa360e858bd201f3b304f0609f9d7bbac6f45f826b65" + }, + "target": { + "epoch": "282952098", + "root": "0xa33cd398a8c8cae70c0c663b03ba06a12605ae70361594fa8dc15ba67dc7b7a5" + } + }, + "inclusion_delay": "11010559701005505608", + "proposer_index": "11015517154950525288" + }, + { + "aggregation_bits": "0xff7cb1c00e8af5d5cdaa7f8470c516c45c84d2e20c83b78b9ebba8cc88e5ccc47b0785a34a150e925674b987cd841a4ca5d158c4e9ee64c87e22332ec1f6c28b737d1b543e192e9e47d35dee72a87f58a494f72aa9eef6a5cb145e0499770a894cd658c294d2c2689336d05aa4d54a42b9be54e8526b483444c4fcb01b3161937d3acd3dcca52b19d787dfb2694708852c82fc19f6aa11db07d47c190bb6ccca9231746d9f05d0b144a2e1a956cda6b40801baeef36bcc7792a58453005c63ca668b6616b4f0e097838a2ada4f8371c5a302860ef62919b204444e1a1b461510c69f4d20a1b0524d86a30a9ed88470c9bd2108520e9804680f0d407c56d820c801", + "data": { + "slot": "11003949768138769096", + "index": "11008907222083788776", + "beacon_block_root": "0xdd9fc19888ab68b6ecd49bbd7e544408390eab26596f0e29174526ff0ceadd45", + "source": { + "epoch": "274295247", + "root": "0xb288e29747e58def52c5ef2ee8a35079278185d26a3a1ccbe2712bb9774a16dd" + }, + "target": { + "epoch": "274679996", + "root": "0x8c46ee97074ecf65683f21d8419227df1a7b87aefea8ca56866fa428c288a7c7" + } + }, + "inclusion_delay": "10939502892623317031", + "proposer_index": "10937850409406632902" + }, + { + "aggregation_bits": "0x95c3549b318741f8ea03a3ef23024096e31c1a2f8b65a7c9c25d62d873795b48afa61966844b97f5367c2bae47619813b3bdbf317a46ae4888796a7c0e3ded6290c23edd6623a8871f88ef0b61f58fc6308507bc03d2715a9f3b9d44ffe32c0cacc121cf37140425d99a56387872c21ffff3b23b0b74177ac07779d1b05f2c904d8f660997b499edffb4ec9421879bc2fc243e48465b8da617cfb608ea7d5b80ddf1605ad166b4207cc496e5361ceb672dfd5eded9ae7ea69857ab48c9c9e3bea856d426e3c0bc1e51409ba9710a59d84a6474d6356173bf3eb08b563c4d74689e87cdc53135ed7f46de581182ed77806fd4e36966b3f2540409d4ae5b049f8a01", + "data": { + "slot": "10932892955461613222", + "index": "10931240472244929094", + "beacon_block_root": "0x122ec597665fea471d14f4070a50b77a469080acfa25e86dc7f77ca2bb2eab92", + "source": { + "epoch": "272948626", + "root": "0x85f4a197262526e5dca55f0c008532496ba27a1840dadccad9fe1154d973f7d2" + }, + "target": { + "epoch": "271794380", + "root": "0x5eb2ad97e68d675bf11f91b5597309af5f9c7cf4d3488b567efc8ac324b288bd" + } + }, + "inclusion_delay": "10927935501516593542", + "proposer_index": "10972552574136868775" + }, + { + "aggregation_bits": "0xf7e5e91d52e392cf024bbbcad683c9594339ad03160eac68087474b69a1fe7fce6270d64963213f777cd3badf563828840af74fc68c3303fe4ed4b43edb3c45105625f84767db42944dc72d30f8541c1b896458b95a3d43ff088c77b0843eef1d487c3d736d58fddd20619e7ab41d0e47eba8c507bce35abb01bf2eeb7e546ba59d71c2f382b7ab21f5f2a47de34c281b1b58c60075364c7a4627774e16f27bd6ed33e3685435bafad0b8f3ff1f7d84b15779498d6b8c041c2bcb8c1fc380795cf9ab88087549c63ab061ba4489cd673dce04d01b511eec3886c9bfacfc4576a8fd1587da30e70849468ed3df897fed56c0659bb1e6bc6a0d009da56c9efbdf001", + "data": { + "slot": "10974205057353552903", + "index": "10965942636975164967", + "beacon_block_root": "0xcdfb2898c75916b5d4a11826fd395adcdc5c91faded13211bd6301563ac07d5c", + "source": { + "epoch": "276988490", + "root": "0xa7b9349887c2572be91b4acf55283142cf5693d67240e19c61617ac585fe0e47" + }, + "target": { + "epoch": "275834243", + "root": "0x1a801198478893c8a9adb5d34b5dac10f5688d42b8f4d5f974680f77a4435b87" + } + }, + "inclusion_delay": "10962637666246829415", + "proposer_index": "10960985183030145287" + }, + { + "aggregation_bits": "0xf739b76b82944ec783bc37d92abd449970370e0a8d41572a77e46058eeb6f9600f02224cba8c3c7028802bd664296996e08d2aa0c0442f2475710a52fd1e4ffaf6b73f7e6ced3288e2a39c526ae97c750599ec9e16df39ca8de31ce91dee9178018e73d720d219e0c5b044b134caf847812263155afbaa07ba2e90e5dce248c95a2cd2876584e9225b97dddd6889d4c35cb35f2a7fef74b4b13e65c5fae41c3dfe5ab117fe67fe87531dce8b32ebce59828da0651d69e226f710a9d8ca1fa3d39201eb5b7aa6604bc4dc4812b2d1f2e7256454da267b8b5657f223aa74566614ee41759dc9fcc48cffe4511a0621e668c5ff4199228a2e13a524831d873ed58801", + "data": { + "slot": "10956027733380092903", + "index": "10954375250163408775", + "beacon_block_root": "0x038a2c97a50d984605e170708935cd4ee8de66807f880c566d1658f9e8044ba9", + "source": { + "epoch": "267946891", + "root": "0xdc4738976576d9bc1a5ba219e123a4b4dcd8685c12f7bae11114d1683443dc93" + }, + "target": { + "epoch": "268331639", + "root": "0x4f0e1597253c155ad9ec0d1ed7581f8301eb62c858abaf3e241b661a528828d4" + } + }, + "inclusion_delay": "10884970920702937029", + "proposer_index": "10889928374647956709" + }, + { + "aggregation_bits": "0x8d94ef3ade27465fd2c93f210d6241435e3ce478cb3f32fea4bbb437f09b24d38a9204f073bc60f15dae7feb5c9d50804229db7d7f214afbcfbb8299a9c476c646df52ce2c9d80ed3b618f940081210d98aa04e8ed02471df53d4724cad8aeca739c7bec0eafa9d262e92b09b14558481fab12b9104d27e69d833899618cf88f5f83d68278661f8fff112cc4793c29af9549a6c0ae88927d98c12c4c4e29b7e97dd88089c4a9aa8d878d1050568db6f2129970c29c10cd0da318cff6f14cd54a1095a3f70a9a169ca3660aedff9931740e30cc4c8c3331a27f10d7a36c2c4cecf0e77c333c15d6b194032a3802aec83ba1f5263bff65c9110dfd70f14aa7e1d601", + "data": { + "slot": "10878360983541233221", + "index": "10883318437486252901", + "beacon_block_root": "0x88710397051fb328b9b543a052f35cea14f45f7e7b052a6dad9e3073e1aa4e74", + "source": { + "epoch": "265830772", + "root": "0xfb37e096c5e4eec57947afa44828d8b83a065aeac1b91ecac0a5c524ffef9ab4" + }, + "target": { + "epoch": "266215521", + "root": "0xd5f5eb96854d303c8ec1e04da016af1e2d005cc65528cd5564a33e944b2e2c9f" + } + }, + "inclusion_delay": "10919673085433172902", + "proposer_index": "10918020602216488774" + }, + { + "aggregation_bits": "0x7faaafa75effb09d1558549aa0dbda64640239a7c605075dd1297166fc4db3f0f022aa8f67fb41358035b9fc4ce05152dd6a02d8eeabebdf67ecf3bd732dc278908a5f833b63fefae1de36628bc5c3ac0bf19a7a087a19d03c7a83048dee76869e5e70ea82fc65d10585e58abf3668d120348a693816fd1fce6f948f4a1c6eec6c036b31fd2a3889934f2e1cdfd2d6e7c5c05a1daaf7ca6823d8f2b3056d730c1aaa37ecd4036531da3d015cb19ddd4f0cbace0139cbce69153f0377265ba5b41b2811597de17df785dd6549bfae1178f2e79db525d7ffe04d8752472bd2fe25cebf3ac3ef642459441684a2052bab66d7be9a44167c2c51da61d3bf3863e8af01", + "data": { + "slot": "10913063148271469094", + "index": "10911410665054784966", + "beacon_block_root": "0xf7ba7e97e6ea61829b37cb10f6b9ad1791b47484868ed127ec05a705f7b84313", + "source": { + "epoch": "270640133", + "root": "0x6a815b97a6b09d1f5bc93615ecee28e6b6c66ef0cc42c684ff0c3cb715fe8f53" + }, + "target": { + "epoch": "269485886", + "root": "0x443f67976619df95704368be44ddff4baac070cc60b17410a30ab526613c213e" + } + }, + "inclusion_delay": "10908105698621416710", + "proposer_index": "10899843278243028774" + }, + { + "aggregation_bits": "0x2bfcc5d86481483a1e74b6f35df293d2ad5157931bad94d3ef60726184bbb77354cba2157ff20f97cf44ef44aa60c4cac7ced22eb291d032ad8ff43b39af97a715372b5fadfb99fdca79dc977414d6defbdfe0a20d87b869c7b9f38c504d013e24c1a9d3ea2ac9ffbc0f13688737b7a6df46bb46d1b2d78c217e274fb65b6fcd2b0b69490c6f5aed0cd96c30b655faf35c77af8c216bf81fdfac5307bbb58591db6ecf23aa13936967bf61ac1ba886a7208954cbd832488af849a6d08a3e2c8ed79729f834013d41ef98f74dc4bf4a0311ac461a013b07949620cb974c3e8cc1de7a51aa710741d9886bd399415ed17437659758df05b6bbdebc58fdc6a289af01", + "data": { + "slot": "10901495761459712902", + "index": "10840353856672596388", + "beacon_block_root": "0x79cd6a9644cd6027a182c008d0d872beb642465200684e5553bd0bca0f81ee8a", + "source": { + "epoch": "262368032", + "root": "0x538b76960436a29db7fcf1b129c74924aa3c482e94d6fce0f8ba84395abf7f75" + }, + "target": { + "epoch": "261213785", + "root": "0xc5515396c4fbdd3a768e5db61ffcc4f2cf4e429ada8af13d0ac219eb7804ccb5" + } + }, + "inclusion_delay": "10837048890239228132", + "proposer_index": "10835396402727576708" + }, + { + "aggregation_bits": "0x91d3e5d4775bff88aec3b564ef0812b4590734bd2b4493d37dff1867c6c8b0e42897a11f89b7722cb35a6c3af51aab7f11ddbb4958d9321f4792bd6db794f334fb37eac97b08d369ff70cf2b84d21161084199bac9cf1a36ae9a0b490ab9277faf77cbd5ba8eb296752fdf6ba333a45d033374301081e53073231cf8b2ddf1941a9d81f6d72fecb4fb20aab66842336bc97d4b2c8d893502ae6afd9bb3bf1b7d19af20522dcdb412d0331e821785bf9a08154a4976c25768ea9cf75d1b7e8ef2e4944b36c407d64cc4aca91790dbb23f42061c1431fba5d48da25acac63fdf1cbe996c83f55d9264a13a7124d8d29fda926f656cdba7aa428798e9548b5b95e801", + "data": { + "slot": "10830438953077524324", + "index": "10828786465565872900", + "beacon_block_root": "0x4b392a96240df91c2b6330e6e8b9548efb633b98d6070f554b4af26471aacf80", + "source": { + "epoch": "259482415", + "root": "0x25f73596e4753a9340dd618f41a82bf4ef5d3d746976bde0ef476bd4bce8606b" + }, + "target": { + "epoch": "259867164", + "root": "0x349bce96a5c78c945810e526c3c215204c0f57a0e51399f84929907d8e12c154" + } + }, + "inclusion_delay": "10865141113512792901", + "proposer_index": "10870098567457812581" + }, + { + "aggregation_bits": "0x77f136dca1ea90b94b93b8788e18bb784136ce11f4cbc8f0bfd64ace4ef70d6af1069f053b8ef65e6f8b7fa96e3235a17cde59857b588e282b06ab19dd04599b76dbbab4bb375752e12046f8eaa2c26c62de990956ae2c87821b317ad0197441b12bebc7b30ccd760ff3d8d43091dee6687c6a402b4beb813b0bd2cf4f1bbfe15f07bb7270709cef5bcafc442770e48886add2081904d43f1cb745f782f91571a8b35f56f5cc19c71456077cc86e04f4b6fed11f79f5edba20acf4c124f521418f88af88c59175617ef6b416301931c5f491a165b2833cec5f770fb6379aba0dacefdb29efc618df1642e40a80ca549b51b1efeea72c15d61a9377680dd1b7e201", + "data": { + "slot": "10858531180646056389", + "index": "10863488630296108773", + "beacon_block_root": "0x6dfebc9685aa2a6338d91aa93e5d53875f185456086e1327d2ac5ad61e35e7f4", + "source": { + "epoch": "263522278", + "root": "0xe0c4999644706600f76a86ad3392ce55852a4ec24e220884e5b3ef873c7a3335" + }, + "target": { + "epoch": "263907027", + "root": "0xba82a59604d9a7760de5b7568c80a5bb7824509ee190b60f89b168f787b8c41f" + } + }, + "inclusion_delay": "10846963789539332900", + "proposer_index": "10845311306322648772" + }, + { + "aggregation_bits": "0x3bb6cff0eb9d734869e69cff0b8bcfc3cbab636fbbe6b442562fc7b1e2e9a37d468f15fb87aadd4962b868bd53873a20820ae40a82bf50770b8c8d6737731ad610ff927875e882eb2550cca074df54a34eb63d3281c97746400e9f4191879859ea9839ce5d2b22d1a3cac38f15602ab3c1cc9d9f566a5e1f89985b067f8ac6df2c934ef2b12fa95292c92f42b7b9aab61e025670aa6755a04d0ea8500e232363b3114a5101511d833201fc8a568dad72fb956d462bc0e6c81ecdce72116d6e2f2104c0a9bc56e9b90443158c4adf8d28df9296b2751bb9ff45d3c2a3832823a4ff040336701d151cd9729a13b5ea80c10c8d168bfbe7f4ac0409d6081706efd501", + "data": { + "slot": "9518366703504708996", + "index": "9516714220288024867", + "beacon_block_root": "0xefc52384443e8f921bf83b29acd360372bad32d9b04747e6d1e83444ee08d767", + "source": { + "epoch": "108276097", + "root": "0x628c00840304cb2fda89a72da208dc0550bf2c45f6fb3b43e4efc9f50d4e23a8" + }, + "target": { + "epoch": "107121850", + "root": "0x3c4a0c84c36c0ca6f003d9d6fbf6b26b44b92e218a6aeace88ed4265588cb492" + } + }, + "inclusion_delay": "9513409249559689315", + "proposer_index": "9505146829181301379" + }, + { + "aggregation_bits": "0xefb1ba29bab480520fbd35b1741b9c8cb3d396dcc49fd78b6153eecfffd3c1ff8b3eb073c2e77c111ef8df734ae6030f275d4da81fafb1ff6d7eae6a6f7b8fc5646a2265bca4dc7d5e09b0114ed12ed3216edbcfad832319a383fde365389fa70ea447b928e7e5ce1dbad90cf46d2accf3ab7ddcf5827226851caa0d5c333c1402a40e1d4d7657b3ee20faa00b263b9095fede94516bc2cb75182b008f4ecb425cc18d99e568ec4d40fd6d8cf8d0c3f3fe6e1b9361b8fed373c852a4cbe65c3d6a418e942304f545c08a9cd8928c5b3c316df8aa75b4511735ebd677e06f07b20a5e1b9518b983f82395cbcc66abb6c8a4ffa21b561d553d750b8536cd09f94901", + "data": { + "slot": "9506799312397985507", + "index": "9498536896314564867", + "beacon_block_root": "0x0eb6cb83a3aca49b79e448b413d8943b89da2367600aabce807a2900bab59588", + "source": { + "epoch": "106159978", + "root": "0xe873d7836315e6118f5e7a5d6cc66ba17cd42543f378595a2478a26f05f42673" + }, + "target": { + "epoch": "111161714", + "root": "0xf717708424673813a791fdf4ede055cdda853f6f6e1635727e59c718d81d875c" + } + }, + "inclusion_delay": "9548111414289925188", + "proposer_index": "9546458926778273764" + }, + { + "aggregation_bits": "0x95720bf421e83b5b2f7fe34a93d664bcd99176b2f6c1d6352e5daac1cd5026474696a855046fb1ffd63909912058f58cce8f598675571bfa7539dae3df1c9d01aad21904a4c24523e8ce9c2d3e5ffd92271d60c6593b98040c7ac4eb242e15b2c819b8352ff4546a9d319ded9ccc3b0a167dd550edca458ceebf52354c9f6faa16033c00283d653776f6cf07070a5a0f6d950afde02e73baabf2025f85cf296621da1f45f57d788b4348d8050e2eb11d64a49f22702876d8b4075ce5f568785fdb3ac45eea1179177f6d3bdcefcf420a4e0c084416cc40a980016ed81da537ad627f8fff3b919c49546f81288bb28507a01c751ba3362f0895b1a3a7b9e0ba9e01", + "data": { + "slot": "9541501477128221380", + "index": "9539848989616569956", + "beacon_block_root": "0x7dff4684847853f55b66d024b79ee568069b386d6a935289bfe19f92d0c38a27", + "source": { + "epoch": "109430344", + "root": "0x57bd528444e1946b71e001ce0f8dbccef9943a49fe01011563df18021b021c12" + }, + "target": { + "epoch": "109815093", + "root": "0xc9832f8404a7d00830726dd205c2379d1fa734b544b6f57176e6adb33a476852" + } + }, + "inclusion_delay": "9523324153154761380", + "proposer_index": "9528281607099781060" + }, + { + "aggregation_bits": "0xe7dc5396795cf8d012aa79b7f54930aa57f41660a97e63813523f2adf7ff63e7e6e68fe9875c4d6f9e9749be2cbcf811d65fa6cbdb32f315cbf3db1e1be465319e8a1066ea201f527e55abeffc76a2f2b02e8220a6e2a663e6e03f3270046b98f90fb80e03c48459a863f29328e71fac51f3a1348d7b0b2de948789935b34f30173eea45f5cac791c9305996162fada2bf6561066b0bc5d3b65b33d2b95219faba1ccc3be607a1f195c24ed400189db6f08ddf86f05a5ae16aa966b0ef2f5b8634578af6e49d9d6154c4dda34276a09b317044d53620ea7d84b4ae5321eb753c7dc911058e4adafeb5a8fc52a67f6b4c85bb0ba9da74624821685a1b7638c24201", + "data": { + "slot": "9463834731584328994", + "index": "9468792185529348674", + "beacon_block_root": "0x66096283e2fd5773b7998bc1f47606a7f91012ab322789e5b88fe81415857a49", + "source": { + "epoch": "101158242", + "root": "0xd8cf3e83a2c39310772bf7c5eaab81751f230c1778db7d42ca967dc633cac689" + }, + "target": { + "epoch": "101542991", + "root": "0xb28d4a83622cd5868ca5286f439a58db121d0ef30b4a2cce6f94f6357e085874" + } + }, + "inclusion_delay": "9452267344772572802", + "proposer_index": "9450614861555888674" + }, + { + "aggregation_bits": "0xa3ff90d1978819683267dff00249ce90b4e3023d14c77f027e1eea8ad9c1d578153f179c336e2e4a6b1c4caae36562d132452bdc3467e81ad93ddd3ee3a32335c1840a2ff4fbc6efda29f0a61a1895ae8a2b4e1b51d3ec362471f30da41f0692c2fd7cad0de667a38a7061ed6c42c6dba3275a607d151ab17bdef64499a0274e413a2825b417b4896237ae413a466beca2eded3afa6c647c63fae6755e4c1ff4258fd8e6943bc4d19783c22eb57bca6fc9e7611e892e70b3306adf07819cd569145b66f7ad9235a5ae5de8322dfe1f771f6b3972f93cf77ad7483e42a6792cb70302212a0033c70d63fea128d3b7837a9c0561d8b2ff5f2ad9e2de3f6cff8e1501", + "data": { + "slot": "9445657407610868994", + "index": "9444004924394184866", + "beacon_block_root": "0x38752183c23df068417afb9e0c58e8763e3207f108c749e5af1ccfaf77ae5b3f", + "source": { + "epoch": "99811621", + "root": "0x4719ba83838f426a59ad7e368e72d2a29be3201d836425fd09fef35849d8bb28" + }, + "target": { + "epoch": "104813357", + "root": "0x21d7c58343f883e06e27b0dfe660a9088fdd22f916d3d388aefb6cc895164d13" + } + }, + "inclusion_delay": "9493579442369545187", + "proposer_index": "9485317026286124547" + }, + { + "aggregation_bits": "0x47b46b44c5597f17d225e8e494d865ffacea2231a9be35053e7fa8f313ef6966c996ad068251a88828fc4d8142c16ace79597d18d7d365aca0ebe7995b8f8eca4c660a072df4ce408079e96c27aa46b9d25a6c10c6a64b934e41ab924f3c052cfc774e108d64803ef484ce7633b19c620808461b4a96380219d76d6be74e79ca3120454503dad2dfa2df7832dd56653f6d1afa5abfe41521e1636f9d57de71cb95a2b73660991144ca647efc831991c3e30dbbca8459cf34faf84e9b94dd2a06e3171a790c04a699141a64b21e4009aca8ac9a81780656084df602ed65f8cb271a46afda8b484f162bc44666e14c32bf171edbeade30b9bb62416007ea74fefb01", + "data": { + "slot": "9486969509502808675", + "index": "9478707084829453443", + "beacon_block_root": "0xf342858323381cd6f80720bdfe418bd8d4fe173fec729488a5885363f73f2e09", + "source": { + "epoch": "103851485", + "root": "0xcd009183e3a05d4c0e8251665730623ec7f8191b7fe142144a86ccd2427ebff3" + }, + "target": { + "epoch": "102697238", + "root": "0x40c76d83a26699e9cd13bd6a4d65dd0ced0a1487c59537715c8d618460c30b34" + } + }, + "inclusion_delay": "9475402118396085186", + "proposer_index": "9473749635179401058" + }, + { + "aggregation_bits": "0xef91307e7d4180f3443ce1eb866326b95886468c311543842e6cf665d1ac7761f0c328077754d7abe94b5e4f8132336f8b5ff8dff99f00dfcaf2e78c373661492360984eb077a652d378ee53a4a7e4cf31630f97817a69cc29037b4fd5c9f0f135d50b173ded5fd43e8c4c7d9ab5a9881d7d87c5af68ca0ec5ba165ca2e0f646148aaefb1edf71a355603cfc4f61fdb1e850d13b408cf01cb8e372054a40292cd472cb412fc73f7dc077e1f64f62b5dffbb4450e1a69c482a98b1f122359dcbce83402154e035d1b1f1eab499d7462b8ff369c8d46d67f9b5315f7622ffd5e7172b383f896369e0d01d5859e7442b5bdb68040765043e019974cd1aaa5acb70d01", + "data": { + "slot": "9415912696825652801", + "index": "9414260213608968673", + "beacon_block_root": "0x28d1888201ec9d67294778078a3dfe4ae080edc48d296ecd553baa06a584fb55", + "source": { + "epoch": "94809886", + "root": "0x028f9482c154dfdd3fc1a9b0e32bd5b0d47aefa020981c59fa382376f0c28c40" + }, + "target": { + "epoch": "95194634", + "root": "0x75557182811a1b7bfe5215b5d960507ff98ce90c664c11b60c40b8270e08d980" + } + }, + "inclusion_delay": "9397735372852192801", + "proposer_index": "9402692826797212481" + }, + { + "aggregation_bits": "0xabc5abe7e83eba454a8e201aa001cfafa3cdec0a649d83931051d472e9eb7be2d40a2a1eaf1bd98b22bedaf7d5afb03293318a2121350ffa82d5ed5b5d9a389723d9e51db43bafdff67190a919eef4f5512e15492007f837ca3022af19728553d908e1a9941cc255cb0ef89c07b46cae682fba4a678768ad0328910c1c27b5435737a9e3b18c72f6e6367e9063b659d161a640fa0acfda2fccd53081f29ef11f97a7b095d1d7b8237ce2c18be549b3d2e6b15fd4aec8d3b8415f1a3799b9519d3c3b83a6164a1d27753a3b4e234f3ceb181d20e06262c57c9cfc3ab3871089972c2698901c14ebe3f921c6610ef41c2b5a6c200a003b02aaba1372ea595cf21901", + "data": { + "slot": "9391125435690488992", + "index": "9396082889635508673", + "beacon_block_root": "0xaeb85f8260fdb849de1b4b3754fb8de60c96e6c289a68be496c382809e2aff20", + "source": { + "epoch": "98849749", + "root": "0xbe5cf882224f0b4bf64ececed51578126a4700ef044467fcf0a4a72970545f0a" + }, + "target": { + "epoch": "99234498", + "root": "0x971a0483e2b74cc10bc9ff772e044f785d4102cb97b2158894a22099bb92f0f4" + } + }, + "inclusion_delay": "9432437537582428673", + "proposer_index": "9430785054365744545" + }, + { + "aggregation_bits": "0x4bfc6a7c48e7849c8d8241b9a6f0feaafa49d3d7e1e5175455234132f5ac7dc8bfd39ae87b49baca15005df9aafa22302cba1b0cf73dac5b3e94d6e62751982dc998a20be7e5b15420600dc8727bd2c4711fe7c7cb5d96bc01b7ef4fce551c01302a7d0d9844576be24b5a9fa9c76767749028f2e847f224f5f3192b26dfe194229e295dbc9715c4aeac7d0cd0183549372bd97716e0b23e77c226cab2cc1578f0c5a2eb815fbfde3551c18e42589b3e398563436d4bf1f49758be301c0a212737a693a0a6f36a45f3c13642e3700b8fe0a25229899ee72c1a65e3516aeeb25e533aff70c7f68b5d5abd6dfb106ac90e386612337a739bc220aceea6299a89e101", + "data": { + "slot": "9425827600420724865", + "index": "9424175117204040737", + "beacon_block_root": "0x1d02db8241c967a3c09dd2a7f8c1de138956fbc8942f339fd42af912b438f4bf", + "source": { + "epoch": "97503128", + "root": "0x90c8b782018fa3407f2f3eacedf659e2ae68f534dae327fce7318ec4d27d4000" + }, + "target": { + "epoch": "96348881", + "root": "0x6986c382c1f7e4b695a96f5546e53048a262f7106d52d6878c2f07341dbcd1ea" + } + }, + "inclusion_delay": "9420870150770672481", + "proposer_index": "9359728241688588672" + }, + { + "aggregation_bits": "0x3114060f3454c51e816ee875c86f3b32b4ec5a072fdfb6f9166cd45c6b8538723fb6aee4b36ac6cc05a4199dc9582ca6b402eec549584b2d10424e2ff7892205f1cdab653901a931f9aa3256b87a0b8dcea243a55a82e9ebeb689d1a186ea2af22f8761cb77fef48679bb5842d0cc46c2319119a0cf237b7fa52a1578971c3562199585125322645407c8f51343dc2d5ecd1209d5fd7049e6e731fef0e5132b0e243063fdb316691411b4f51647fa3a1d9c571aeed23f74ee354200c6f5c14fab502ff3590670093373600756e93c95dcbde8fc5391a390816c7135ed698b2ae642c05cd36ad8929f3daa6d83fb5a2444acbdf8720c1d4826151ba09e680eb6f01", + "data": { + "slot": "9361380724905272800", + "index": "9353118308821852159", + "beacon_block_root": "0x9f14c7819fab6648c6e8c79fd2e0a3baafe4cc960e09b0cc3ce25dd7cb009f37", + "source": { + "epoch": "89231026", + "root": "0x79d2d2816014a8bedb62f9482bcf7a20a2dece72a1775e58e0dfd646173f3022" + }, + "target": { + "epoch": "88076780", + "root": "0xeb98af811fdae35b9bf4644d2104f6eec8f0c8dee72b53b5f3e66bf835847c62" + } + }, + "inclusion_delay": "9349813338093516607", + "proposer_index": "9348160854876832479" + }, + { + "aggregation_bits": "0xa58d441fec134306d449cc06d61314baa6649c8dacf6abbae95e50b38f982bec406f95f07f81cb435e4a58ae2c0a40b906347e0401ef1617977659776308bdebb605cd11abc58f8b7f5cf4055f1f5650f2af849d8cda651814f36651c8d13cbe855342b4e03c11405cc56e7eb58381bb7523bcb32554e81bd1ced1c4c7769475766bce89f8c9c08962727c87674044851191f956214f6e45cb6d69b601ec51a8e3d6b55e228566fd2a5fcee9ecb2b9a3ee2de7dd467b3cddd2f9131591fef12458186aff9f9548bb5ae85a8dd85dfec8d302728454be1d964849eb8e890382d32358880ccd4fad148c1a8a7f9d83ab98e5b3cf91a87c94543872f10f08c0957f01", + "data": { + "slot": "9343203400931812799", + "index": "9341550917715128671", + "beacon_block_root": "0x0e5e4282807715a2a86a4f1076a7f4e72ba5e19c199257877a49d469e20e94d6", + "source": { + "epoch": "92501392", + "root": "0xe71b4e8240e05618bde480b9cf95cb4d1f9fe378ac0006131f474dd92d4d25c1" + }, + "target": { + "epoch": "92886141", + "root": "0x5ae22a8200a692b57d76ecbdc4ca461c44b1dde4f2b4fa6f324ee28a4b927101" + } + }, + "inclusion_delay": "9377905565662048672", + "proposer_index": "9382863019607068352" + }, + { + "aggregation_bits": "0x43a4379fbdc70831b10dff57e113bf1675e7666189db201ea159c28c664e97129ee603fac7bc4d6138fb49e5dca2fce25d2e59c0a042de216fc22ec140e8038eafac8c5d21fb11202c886d47f30d9955c29aa6b4bdcb93e93d509ce6d1321fc09fd1a40c2dbaf69d02194485a4f0db003c4880dbd43fe2c886c746cae3ccf49db6b0a02ffe04f5d2629dad5071d3137a1c42453ea56dad4c58a8958e1a5a7987508aea38f020c2b2f71c86372bc1c28f46de6c19492fca6f8893038a88279697a7000d790b23c8d7a1aad72c6bcf42d3e4d4c7d13ec0c4229a8de3205aa766723c620f8ecfd5238fd9604f5219113fdb668175d1c035e405e55957331e08ffbd01", + "data": { + "slot": "9371295632795312160", + "index": "9376253082445364544", + "beacon_block_root": "0x93451982e08830845c3f22403f65848357bada9a150f759ebbd1ace3dab497a1", + "source": { + "epoch": "90385273", + "root": "0x060cf681a04e6c211cd18d44359aff517dccd4065bc369fbcdd84195f8f9e3e1" + }, + "target": { + "epoch": "90770022", + "root": "0xe0c9018260b7ad97314bbfed8e88d6b770c6d6e2ee31188772d6ba04443875cc" + } + }, + "inclusion_delay": "9729884645434590601", + "proposer_index": "9728232162217906473" + }, + { + "aggregation_bits": "0xe59fcf07a01c0a977bce29ee91b0444216cc439aa9d277ecd6a55d4bed62c1cb1020f7b6abc8f96e6a05d903b2cbe396531e9dce07d85789579526d887e4f6528c5f836df55fda4679d99c9f05f623105afa95c67fddf3e576c762ca0a83584250da97167b711e996b483e9ff5fdaad63f6e380a201d017666c8a847edb59cd928f5f62a46e0185d25601871dd5e222d365f450cbafdcb6649ba2a6dc6139a612c288f7d58243bd38ac61ae67f5cd13780014a86a47ce05761b060979fa20ec20231e92e0a358c63a3dc8ceedd72b788213b69302a0675ec2e18298cd6323bf8da29815ad9f3f019eb2e0de5c34fe670292dd84963841891ab90860b31d8173401", + "data": { + "slot": "9723274708272886793", + "index": "9721622225056202665", + "beacon_block_root": "0xafc0fb86c99c6636528937232a8d6ee12436ad215e0f86baa6568243281f0437", + "source": { + "epoch": "132130529", + "root": "0x2287d8868862a2d3111ba32720c2e9af4a48a78da4c37a17b95d17f546645077" + }, + "target": { + "epoch": "130976282", + "root": "0xfb44e48648cbe3492795d4d079b0c0153d42a969373229a35d5b906491a2e161" + } + }, + "inclusion_delay": "9718317258622834408", + "proposer_index": "9710054838244446472" + }, + { + "aggregation_bits": "0xf14927b89a33142157d54b0668072d66e1977d986d3875a31ead9356c91bc0402cc1772e00cea71fa5b45db90dce54a10fe85c619fb26ab1bca2007efb02bf8c69e7ab2439099f515472e24fde2f2b22ba942f16eaa8725e13dc230bc6280df0fac14e2a310da7aaf1a28c7d42f467e1c2a00203e1d30984a9db10844beaf9f46b7bc0a4139d7b18bf155b3df60ff619ada9a0dfd0757041f5ace8e96ccb74d4c7faccab241cc98d37485a8af5454cdfa9069c6e1ee0f78aaff155f33146c241a60ad49d445e0edded785c33a542adb0e830d1ddafda80ba27f4245de7947cac82fff3b063508c3f2fce4e46a5e8196175d093b53ff7dbaba88d6589dc49643701", + "data": { + "slot": "9711707321461130600", + "index": "9756324389786438537", + "beacon_block_root": "0x6a8e5f87299792a309175c411d771143ba02be6f42bbd05d9cc206f7a7b0d600", + "source": { + "epoch": "136170392", + "root": "0x444c6b87e9ffd3191f918dea7565e8a8adfcbf4bd5297fe940c07f66f2ee67eb" + }, + "target": { + "epoch": "135016146", + "root": "0xb7124887a9c50fb7de22f9ee6b9a6377d30ebab71bde734653c714181134b42b" + } + }, + "inclusion_delay": "9753019419058102985", + "proposer_index": "9751366940136386153" + }, + { + "aggregation_bits": "0x1f25a77781ef0bac41fbbde8d0edd056c9cfacf40f52e50341234199e78c66bba2e657008d8ea0ef577d0b7bf610321388362a4bbcde86f4e025465479d1c6dbe21a86e5e9edf76b0ea3cb824ee1f58b3ee6fdd5eb14d16ff4b67327edde2d673c70452de234172df6c2ce042a0d312e6b68aa013992bc0e9855e99baf64afdaffd4627035546d9ae7c33afab020eb8297d23424216360b06f46e0b4c6085fd137e17e1576504b533e496cc01babb6993f30d5b8055077b5a967599758d1cc07b6429b1b9559066670d0fb9f1c2824a79ef3030949be8d46035a95f04a8aad84faefa7de207ad38e581544e561e363fa67034033a1fc20d47db97910ae2767e201", + "data": { + "slot": "9746409486191366473", + "index": "9744757002974682345", + "beacon_block_root": "0x3cfa1e8709d72a9993f7cb1e3558f312ff23b3b5185b915d934fed9109dab7f6", + "source": { + "epoch": "133284776", + "root": "0x16b82a87c93f6c0fa871fdc78d46ca78f21db591abc93fe9384d6601551849e1" + }, + "target": { + "epoch": "133669524", + "root": "0xeca04b86877991480f625139f795d6e9e0908f3dbc944d8b037a6bbbbf788178" + } + }, + "inclusion_delay": "9675352673514210599", + "proposer_index": "9680310127459230280" + }, + { + "aggregation_bits": "0xd584f624594a49b26b429704bb5345ee8db0f02489ecc1a59a5e9df75dd2f7511507623442f55a7f054b4b5cccb42537a2f89f83123b899a3aef9edc2d897fb09a43bf6f3f85f5467420fc00008968d7bdd54eb51049e7b01e2cab6a3f56d2894f2f4d15ca8bbf1f435ea3babe8c18e577f2c8281d24748f17bee587f86a89d476fb567cab23bf3a6845e821a4041440d722dbd0781754313fb7b009fad7665ca407c78fbd3a563542ef325a0fae888cea74181c45c053dc367ac5e91b07bf343ad6d7ffb3dd66e3f83a1de171e1d616e96dd7a8b3921fe08be965758ed49e74f5c6792095c3dd7399f339dc073c1929174cbb83d37a6dd46c702fdc217e49ea01", + "data": { + "slot": "9668742740647474087", + "index": "9673700190297526471", + "beacon_block_root": "0x25043a86675c2f17ef2a87bb72301451f2998cf3dfeec7b98cfd35144e9ba718", + "source": { + "epoch": "125012674", + "root": "0x98ca168627226bb4aebcf2bf68658f1f18ac865f25a3bc169f04cbc56ce0f358" + }, + "target": { + "epoch": "125397423", + "root": "0x72882286e78aac2ac4362469c15366850ba6883bb9116ba243024435b81e8543" + } + }, + "inclusion_delay": "9657175349540750599", + "proposer_index": "9655522866324066471" + }, + { + "aggregation_bits": "0x3982ad40970eac0a4133b1535ed07b55ec2d897be551dd9235e21396e744d4462284c8c1fab7375eda4c4fc0ec79abfe567d2a15effce3554e11b808c7d838e40c0fd7322add75b5f57da6f9424e9d1f13b7b286e57dbf71c93b737566c996153590ff37a52c5cab77213890daabcdf49e0a25fcaa41e33325ad64ebd80be0aa4127855cfaf48da723065f17b565fa5fd9b65fe0db31d53e631425be9d596a44bb9ddbf4cd66c35160fef5e894cdc58bb39f82c4f5d248fa5a523f402885c159584c38f6f281d245caa228ebe8c129d84ebe202d3f4e1a897055fd646884e7428b82202b4abac1d856a516c57384cdc75a0ad2e6939079de32e8a6ac3fbd116d01", + "data": { + "slot": "9703444901082742664", + "index": "9701792422161025832", + "beacon_block_root": "0x944db5864828de70d1ac0e2c16f7647e6f5aa1f9ea776f74cb64aca664a99cb7", + "source": { + "epoch": "129822035", + "root": "0x0714928608ee190e903e7a300c2ce04c956c9b65302c64d1de6b415882eee8f7" + }, + "target": { + "epoch": "128667789", + "root": "0xe1d19d86c8565b84a6b8abd9641ab7b288669d41c39a125d8269bac7ce2c7ae2" + } + }, + "inclusion_delay": "9698487451432690280", + "proposer_index": "9690225031054302344" + }, + { + "aggregation_bits": "0x5fa8d5c4e4decb71ad6f9c51cbc0959d3facff77191c96367dc94ba95f6268f87b05dcd348f87392b6b15afb3e1b3560317764d59e1a2b623295b9af2572c4d741bb90ae28f3e846ae282f03541c4e08e9b4a0f1710c1acca6bc1d5aa4690d6a080e0b0f6eaea75a0dd9bf5f81f8974f37073917cacbc1a02731bad2adb5beb2d8fbf9f8dcbbda7cb3ed89d56b74b5bc974dd6887f99360fe0d3cf528459465902f0a40403e6329cbdade53292beaee719752512fb82547908396cce34d424dafc545860da3e51383ae4a0ca6bc5af0172fb39ec3e7a81f5c6a079ccb343414192f6c5b9a881429f279fc3a5e21c5406d1b06972d77a372e9fd11090bdb3738301", + "data": { + "slot": "9691877514270986472", + "index": "9683615098187565832", + "beacon_block_root": "0xb33d5d86a896f3792f991bb77cfb9882cd879287993ad35c7af6a06230565bd8", + "source": { + "epoch": "127705916", + "root": "0x8dfb688668ff34f045134d60d5e96fe8c08194632ca981e81ef419d27b94ecc2" + }, + "target": { + "epoch": "120395687", + "root": "0x62e4898526395a29ac03a1d13f397c59aef46e0f3d748f8ae9201f8ce5f4245a" + } + }, + "inclusion_delay": "9627430643050501702", + "proposer_index": "9625778155538850278" + }, + { + "aggregation_bits": "0xc9cf5dcc5c4634813cd4bf58cd4b8777c94a84d889b761fc61023b76bb8227df675215daba8d0cb57a83dc8525aa50fcef6da9b63d42817c19cee1ba114b6254edfb07637d11b11add219cb75479fbfb0afe5b60be54289adcd7f587fedd6b2613763508fa8a7c3285dd145caebde4f42978fec07a3cf7bce95885e7051b30a6556537440aff79056454cd21a00a4c2883076248d191fb56b857b1fea9c6b0b8c8608e51ccba59ed3552dc3946c1a6f0e1fc0f553833e98982d339578940f284c4517e54392ae26353ec6b583c2354372d4205c02e8883e2d14a4e40a9c095987a937bd99c5bb9a24d8e20d3bf104e883596365a7b994faf76c92939b4ccaff501", + "data": { + "slot": "9620820705888797894", + "index": "9619168222672113766", + "beacon_block_root": "0xe8cb6085864a750b60d8730108f70bf5da09680d3af1aca12aa9f705de9a2825", + "source": { + "epoch": "118664317", + "root": "0xc2896c8546b3b6817652a5aa61e5e25acd036ae9cd5f5b2dcea6707529d9b90f" + }, + "target": { + "epoch": "119049066", + "root": "0x345049850679f21e35e410af571a5e29f31564551314508ae1ad0527481e0650" + } + }, + "inclusion_delay": "9602643386210305190", + "proposer_index": "9607600831565390278" + }, + { + "aggregation_bits": "0x0fed244d2ab3dbd6909c1049bac27ddfdb8f336e565a0b792931674f52ec5ba51cebe3d80e548ad72264c94cdd086ce69d75ef7e0ae749cff57ad70d71fd46aba257020f2d77aab91d71157ceaa80cfe06f1d9492b4d46b2f3c61d38752f585b2de145b97b0ddfefbb251de1254eb70b203df0d18a27bc8899723ad902b1fcc8943f9b00a4231c5eb4b63be3d6195beb8df4ef1c97b9106f2bca59962214dc95712db0f43c5fa720e811c5ea40ae04dc0b1385832025d04afafaa8deb61b0935a0f91aca2cbc0316aaaa63519b63f83f03e6b497af901a9643ff9cec5877758ba5cacf531c40179989b6ddbf20c991c9b2adc8483750db1b9b3aaa252682879f01", + "data": { + "slot": "9648912933457329959", + "index": "9653870383107382343", + "beacon_block_root": "0x0b91f385e7e7a6516d4e5ec45e9a0aee3dbe80cb6b57b173b20b60778b254099", + "source": { + "epoch": "122704181", + "root": "0x7d57d085a7ade2ee2de0c9c853cf85bc63d07a37b10ba6d0c412f528a96a8cd9" + }, + "target": { + "epoch": "123088930", + "root": "0x5715dc8567162465425afb71acbd5c2256ca7c13457a545c69106e98f4a81dc4" + } + }, + "inclusion_delay": "9637345542350606470", + "proposer_index": "9635693063428889638" + }, + { + "aggregation_bits": "0xc1e257ece8e03266fa69360cbfd2cb663a153b930877254b679e6c28797a3c3a4920733db060e1d28c49dd12d7b4e73fe883a0e1bfa0b384ab88815393a8c1af045339c37ee1e0002b150f3408c55c7d6891b962fc73d7e280536127252484d61647d332518f3c5f53bb083a39ef6a5a519d37af794b19969945a2134064a7f4c16fca24f9fe2ce73f9d88d16b10a47585706b24749e93f4f76aec21314ae28f6a9ec553c8039a03e2106a115fcd860a137839991431fa39da8a194dff22a7530a77f5e95da194841cbfe641a6876de0b45bcb146bac1f97113210fdf9536025fb0a97559079ceda56c6dae6706943f3eb6ca3297bd9955f65800301385887ed01", + "data": { + "slot": "9630735609483869958", + "index": "9629083126267185830", + "beacon_block_root": "0xddfcb285c6273f47f72ecea1767becbd82df751141f77173a9984612ed4e218f", + "source": { + "epoch": "121357560", + "root": "0xb2e5d384856164805e1f2213dfcaf82e705250bd52c27f1574c54bcc57af5926" + }, + "target": { + "epoch": "114047331", + "root": "0x8ca3df8445caa5f6739953bc38b9cf94634c5299e5302ea119c3c43ba2edea10" + } + }, + "inclusion_delay": "9572898671130121701", + "proposer_index": "9564636250751733765" + }, + { + "aggregation_bits": "0x395a2b3e3053707db11c1ad29777eebc7c2cd5419e5802cd5df131444b29b9c8cc011d197af30d52dd679f776f10ef8bd4e9552018cd0462c14e90d9c1f0709d7c433360fc060a25b7ff7d3b46c58134f359d71421ada88f1a8d1ab6fb3c73280711fb037c32ac6c8c5425ed1dc54bd115166e8689e0aa358aa43fa9578a07aa60476e207148d6ea311bfa88eb1e72148786a2cebdfbb5f5eacf9f1c4dd5e084fd50758d9a4c8121b6b67cc749eebebf877cb327507bde050da70769c045a0c8cecba4016e2d1731189ac03f58caaf501b8a16b0c960dcf514d0aa7ad32178dd6ca969ae2528cdeebf2123933de66db58db46c990317d21f9d4956def440f31501", + "data": { + "slot": "9566288738263385189", + "index": "9558026313590029957", + "beacon_block_root": "0x5e0f9f84240a3eecfd79c399509ab164a86d47dfbbd0eea01050abd60517cc06", + "source": { + "epoch": "113085458", + "root": "0x38cdaa84e5727f6212f4f442a98888ca9b6749bb4f3f9d2cb54d244650555df1" + }, + "target": { + "epoch": "111931212", + "root": "0xab938784a438bbffd28560479fbd0399c179432795f39189c754b9f76e9aa931" + } + }, + "inclusion_delay": "9554721347156661700", + "proposer_index": "9553068868234944868" + }, + { + "aggregation_bits": "0x05ace765a3afe2b4c73a680d4cb837ccd634a73fe892b368226e638b34bf8f2320ee0c37e61e981a4c960c9534ef153d00b10b0a2e25c823bd03e6796123494fc79f2f007a64822eb16851dbbe621c93b598c18d26106b1c9d307ac6949845fce9bbf4a66f2c0de2ec67e38e3f50070efc87a72c81b23ddb67004699f36275d294c95c2c4143fe7d28970dafbe7b02adfbe956217e3dac942c62b4c317063431194377a4cd0f89afb5ad4b4925400cc1198bbd08cd575e2a036b09d8fcc8868e7622d28ba6229a028df077ba66213e06c5c76caf4f188b2d844f16d5367716ff1ab39dc58c0ad1d6e1bfa172f8fd467f8bf38f971356b16a29e70c04d40ff0e101", + "data": { + "slot": "9600990898698653766", + "index": "9599338415481969638", + "beacon_block_root": "0xcd581a8505d6ec45dffb4a0af4600292252e5ce5c659965b4fb721691b25c1a5", + "source": { + "epoch": "116355824", + "root": "0xa7162685c53e2ebcf5757cb34d4fd9f718285ec159c844e7f3b49ad866635290" + }, + "target": { + "epoch": "116740573", + "root": "0x1add028585046a59b407e8b7428454c63e3a582d9f7c394406bc2f8a84a89ed0" + } + }, + "inclusion_delay": "9582813574725193765", + "proposer_index": "9587771024375246149" + }, + { + "aggregation_bits": "0xc9f84a0e8fd13813e8a388e09d8acbba252fc96739b892260b2f6998c8cab2a42c070eab4415167b83b7cf0f496e16ce1917480de2dfd55ffd7ef9d72691591d262657d0765cdb2882d52f2a01b392e5d53c3a33bca1ea85e53d0b425823969429a82d17e65c95e9f9cd156c12bbf00949c1df85785b1f48d801d553472736fbd7e2da36e4648435bb284885b2a0a619661df3e0b4418aa75844544595df8d304290ed68b1cdf736027968212f15dab1388e2fc175c759b2e3a8a4d1603f00afba955338fc699e74ff16177c8b10646e3e0ad08cfafa25db51b28b00d8188521146766afc4792c50845bea9a9800fc6ce11e4f6bcb2faad90448adc009eeb1e301", + "data": { + "slot": "9576203637563489957", + "index": "9581161091508509637", + "beacon_block_root": "0x5340f18465e7072894d01d3abd1e922d504355e3c2d6b3728f3ffae213cbc470", + "source": { + "epoch": "157331582", + "root": "0x0f16f1892e81e181bfcb2e44869a158afeaf2c907bebf8eb963e7e591d519c50" + }, + "target": { + "epoch": "157716331", + "root": "0xe9d3fc89eee922f8d54560eddf88eceff1a92e6c0f5aa7773a3cf7c8688f2d3b" + } + }, + "inclusion_delay": "9934792654497735694", + "proposer_index": "9933140171281051566" + }, + { + "aggregation_bits": "0x55d3f396045bbcf740a6574fc488d1acc30195de0858c1d4ad1933731fca5275a39b48230751e26cf3d85b687483be7a5774bce9c6555c06c6e848cea088a54f21c41948701b080cf7a0ffd35f4935bd43544a7b51f3babb873df0a340d64185c3b3988bbab975de934963b2eb9ca1bb0257460ce449fed51c7e126a1a4e58e969287ed31ac238fbb56568a422eff1b84e9893ef29c1e1bcc80ee9b6c517edd7b87fe86f31590a425dc3b6387fd0ced9b6514b4e8a92439e2c6944ba20bb22da5f29386bf62e5bc045224ca4be6dd325f9eaf24dfe2a80103947d0a8d84db1a3c26ae97bba3fddee97f1a82a420c29c4be2a2975407f16044c087b9c261d0a8e01", + "data": { + "slot": "9928182721630999182", + "index": "9926530234119347758", + "beacon_block_root": "0x6fbbd3894efb3dda891a331da8467c8b1dbf276a0bd7c48e7bc4cf4261353106", + "source": { + "epoch": "155984961", + "root": "0xe181b0890dc1797749ac9e219e7bf75943d121d6518bb9eb8dcb64f47f7a7d46" + }, + "target": { + "epoch": "154830714", + "root": "0xbb3fbc89ce29bbed5e26d0caf769cebf36cb23b2e5f9677732c9dd63cab80e31" + } + }, + "inclusion_delay": "9923225267685979501", + "proposer_index": "9967842331716320143" + }, + { + "aggregation_bits": "0x11f0c8d653eb3980a5f66f0fb1903b4091c4777894e5cd51e5962049e17ccc9f7c08fef3b678ec56b76bce53e5abb425282c700db4a4d4918e3d6a70c9248bb13c644b3cb85d52e79d3026b85279e3aa2d4aaa0c4782dddcea2a8c9d9e7552f8d6adf8b8be39b2008d81c40d280a3b462a54585495d3dd203e14c9556fcc1e67fc348355ac1e7ba8b5963c776c76fc53058b0fe969c758915aa317dedc11f1f82d66d643cb99e79e83a09ae070b3e9b1dea2c49a91c2d67f7ee1d7721f68dbf9a0b5d4c177d9dafeb7e461a492fb45eafd7f433af4081f6259f1404629b8d2029a1466f1688d760d464f4e0dd2d4f0173d90f2a30c972491d5025d8498b62df901", + "data": { + "slot": "9969494814933004271", + "index": "9961232398849583630", + "beacon_block_root": "0x2a89378aaef5694740a8573b9b301fedb38b38b8ef820f32703054f6e0c603d0", + "source": { + "epoch": "160024824", + "root": "0x0447438a6e5eabbd562289e4f41ef652a7853a9483f1bdbd152ecd652b0595ba" + }, + "target": { + "epoch": "158870577", + "root": "0x760d208a2e24e75a15b4f4e8e9537121cc973400c9a5b21a283562174a4ae1fa" + } + }, + "inclusion_delay": "9957927428121248078", + "proposer_index": "9956274944904563950" + }, + { + "aggregation_bits": "0x05d98ac3a268bfce3091cb7d4c7da79a820b0330aff8433b1ba774af1d29550d111d54d559175bc0e80499147afc4f3e8c0f3b8df4c3cdbb3bc9216055a90cde7d952cec3a49b45e02d681c6bc1fef2e176c3930dcbe902b58c3f7070bcbfc211f8142b6a94e6cdf0ada9631b8241ee1cde4779d30c681ace6a33b8220aa6934de0dcfcde3f34d289df7cb277b497630be85d643305f4c4e6eaf63c7658da0673cff75273f0c2e77e9bc53d6302febf5294a56c12a9b5cbe4bfef24ab8d342b72907c712de2af0e4462e3be439b41abac4ebb27cc98078ff056739d64076c27ef2846b794177f6092c8ae1aa60a0f8e99560da8c1846cc428c2d0497ffa74de001", + "data": { + "slot": "9951317490959544270", + "index": "9949665012037827438", + "beacon_block_root": "0x5f173b898da9ebd871e7af85272c925fc00d0e3e9039e97621e3aa998e0bd11c", + "source": { + "epoch": "150983225", + "root": "0x39d546894d122d4f8761e12e801a69c5b307101a23a89702c5e02309da496207" + }, + "target": { + "epoch": "151367974", + "root": "0xac9b23890cd868ec46f34c33754fe493d9190a86695c8c5fd8e7b8baf88eae47" + } + }, + "inclusion_delay": "9880260686872322988", + "proposer_index": "9885218136522375373" + }, + { + "aggregation_bits": "0x5f69ca9579cdefd01c6de9a9e24ff310eceb7b627a46f29fc8e020c34f489eeda0bc75e14b3c91419c02c935527a66a8a6c0cf0653a702d5ad3310ea0f7036ce45d9252ef082f23adb7e975d321f6b672e59d90c25278edcea5a0cc6dda7424f69d6428b8653dc6fbd1ffbee668d31fa427fb735ba54cd1f611c673a9f0d49b47b216fc9fe41be953174a8fdbb62e1dd257d2dabf1787aeb2f0550e21940d229ba55c09d7cc777bdb52e956e162b9360894c52642abc4c171de2a0aef2d0212ce78b8fbaefa67952c38f9ddab5b6f0297f9f7b9f49acf01b29d7c9ddcc24c087ec761101f21ce0b0c52c0e814f6dd698f043cd1bc0812b028cf6d74b31be559a01", + "data": { + "slot": "9873650749710619180", + "index": "9878608203655638860", + "beacon_block_root": "0xe5fe1189ecba06bb26bc82b5f0e921fbeb22073c8db6068e616b831387b1d4e7", + "source": { + "epoch": "148867106", + "root": "0x58c5ee88ac804258e54deeb9e61e9dc9113501a8d36afbea747218c5a5f62028" + }, + "target": { + "epoch": "149251855", + "root": "0x3183fa886ce983cefbc71f633f0d742f042f038466d9a97618709134f134b212" + } + }, + "inclusion_delay": "9914962847307591565", + "proposer_index": "9913310364090907437" + }, + { + "aggregation_bits": "0x9db2023ed6d44192fb718412e72b6917946f26bdf53f675cc892a5894f62f099ca4d505d4f6036a4c09d1faa441c77ea69481679802e8d712174711ed57a8e5009887b33634c6eb119e9620d1523d1d69c21e79ecaf4003344ddcff01b92cb5f887459a10b38502edb8b51e8385006316ec07fe5366706b382f2bf3ca4193f35faa017fb771a999379a62a2e3c8aac1535e6f632c64737fecc396e290981475e511f1398326afd01f21dbd42357fe8cd563a58137f617818abc1469d451f54e064363914f90e1e3c11b2135c34a9c7181b798952a4a8856f9a42083b0bba714eb2637e4449ee90c81710250943f9a5e10e4a39b1acb04ec0536b5e35097258ef01", + "data": { + "slot": "9908352910145887757", + "index": "9906700426929203629", + "beacon_block_root": "0x54488d89cd86b514083e0a2694b0722868e31b42973fae48a0d2f9a59dbfc986", + "source": { + "epoch": "153676467", + "root": "0xc60e6a898d4cf1b1c8cf752a8ae5edf68ef515aeddf3a2a5b2d98e57bb0416c7" + }, + "target": { + "epoch": "152522221", + "root": "0xa0cc75894db53228dd49a7d3e3d3c45c81ef178a7162513157d707c70743a7b1" + } + }, + "inclusion_delay": "9903395460495835373", + "proposer_index": "9895133040117447437" + }, + { + "aggregation_bits": "0xdd6cf833c4d9ff31ddc1a6fa02dc28536f6c1cf3b006a48e03b7269ced08090aceec5306c52178264de0d850b817f277754e97145c87304dc3195489850ede878d308febe3562b3e604714cecce2dcb1e80735444723d3a81ef89866c63bfebf2fa7b00463acfc80676be70a1559fb91938a628a7d9fee317d6908ec5a5a6a16bdadf0a1c859ebd3c2986808165d0824be1204c54cb700cd202d0c2987dcb87f1aeb895cda02d7986cd8d1369f22b19d43bc46f9c7de7d324103cbb5d9e890eab0890425a57f8f88675a01c9ebd2d15aa22330118648740cc1bfd18a993e3d38abff691cf38445485b6476a8231febf346a3584cf4c950fa56b5fd37adf329ab01", + "data": { + "slot": "9896785523334131565", + "index": "9835643618547015051", + "beacon_block_root": "0xd65a79882b69b4b90e89ff1d6fcf37cf8e71ed0f11192b76078a5e6ab58774fe", + "source": { + "epoch": "145404366", + "root": "0xaf188588ebd1f52f240331c7c7bd0e35816befeba587d901ab87d7d900c605e9" + }, + "target": { + "epoch": "144250119", + "root": "0x22df6188ab9731cde3949ccbbdf28903a77de957eb3bce5ebe8e6c8b1e0b5229" + } + }, + "inclusion_delay": "9832338652113646795", + "proposer_index": "9830686168896962667" + }, + { + "aggregation_bits": "0x53e3e07d7ed114a3098ac9ec90d8b19d8b0a6f9eb82cd7ce27bfc8222903a2c394b8de4fbbac05ade1de5fecebe58dd2f1949d7256c7ca338d00289e112eb8956035dc2b2fb4d32f1e4453e82e467b0a971c86dc087751f744b846ab1c8c5b62a49ff09233520261eb1765012cd4ceff1ef7a19cfa44043cbf26337b5ff470eb3cb1593d571c49aebd61acd09a22fd9b39c88c97f2fdcfd41cbf3135ae83469eda3a846381a67c206293aa1f534d9ad4b342cccdc5ea62d45e6298ad7802663c1b9a2269e078bce2f4d0eb124ba6324af1998abff9a8567f4e570065a2377be2c70a50fef3d237753435850dbe518011c1bd8760e0fb01728e934c96f24a20ec01", + "data": { + "slot": "9825728714951942987", + "index": "9824076231735258859", + "beacon_block_root": "0xa8c638880ba94caf98696ffb86b0199fd392e255e7b8eb75fe16450517b155f4", + "source": { + "epoch": "142518749", + "root": "0x81844488cb118e25ade3a0a4df9ef004c68ce4317b279a01a314be7462efe6de" + }, + "target": { + "epoch": "142903498", + "root": "0x9128dd888c63e026c516243c61b9da30243efe5df6c47519fdf5e21d351947c8" + } + }, + "inclusion_delay": "9860430879682178860", + "proposer_index": "9865388329332231244" + }, + { + "aggregation_bits": "0x958119dd1f345fbee1de7efca5d848622343d12ab6e198c987d51a7de4653a11eb394c8f939d81cfab2d4ba75ac52749981e5cb3c772420061960939738314b76ddc9d26a5d2cba031000a111a563c071d0e648e9ce237c63b9b9a94e7be4c8c9b0942a23ac2e5ab51bd4eccb3059c443798afc70176072ae184e074e14a3a38fbad26b9f0493fe5bd82fa376532aa78f49b39cf56c424adab769d5da5996aa169369b675d2280243f74fae7652e11f81d6b43099edfdf05948a8b235913c707ecd642c750c6b5be1417e3327b3c8e98d11e15eaf91aff4dcaa294ca5b9a4fe29c6e875627e50846c5cdca108aba5b7c062f74f29c8277a7539af2fa7cc00aa101", + "data": { + "slot": "9853820942520475052", + "index": "9858778392170527436", + "beacon_block_root": "0xca8bcb886c467ef5a5df59bedc5318983647fb13191ff0478679ad76c43b6d68", + "source": { + "epoch": "146558613", + "root": "0x3d52a8882c0cba926471c5c2d28893665c59f57f5fd3e4a499804228e280b9a8" + }, + "target": { + "epoch": "146943361", + "root": "0x1710b488ec74fb087aebf66b2a776acc4f53f75bf24193303d7ebb972dbf4a93" + } + }, + "inclusion_delay": "9842253555708718860", + "proposer_index": "9840601068197067435" + }, + { + "aggregation_bits": "0xd1affa5bc8e6a643c30748bff0cb7e886157cc9538dc806b28e8835c8b530c86faa8e4ac25b92ae932044f58111c1c8dee2be1a27e3538cb71146f4199d45bf699d8a7eab9ce420dc54c507b583b5ec951686cf549509e87780ed28b23b064d4e1ee0639d6e7063cb9f059631f0645970f804c33bd1f2496878b20ac858d63088871f699271c0c4a5e88a964547394e6ef2795dbe5b3ad24b3df4df8520f7cbb76acc6010b76eda318855655744ddce24002fa402be9d352a0b3338213b99dfbc55aa8ec49a90f34306c663914985b696c0dc069b6c2ca6a910e1cffbd28afdde380fbf0fb9de01d0a553f2cfb39bc404d599514d08b528d8c0071926e1f7e9501", + "data": { + "slot": "9782764134138286474", + "index": "9781111650921602346", + "beacon_block_root": "0xff19cf874afaff86d61eb208684f8b0a43c9d099b9d5c98c362c041a72803ab5", + "source": { + "epoch": "139056009", + "root": "0x72e0ab870ac03b2495b01d0d5e8406d969dbca05ff89bee9493399cb90c586f5" + }, + "target": { + "epoch": "137901762", + "root": "0x4c9eb787ca287d9aab2a4fb6b672dd3e5cd5cce193f86c75ed30123bdb0318e0" + } + }, + "inclusion_delay": "9777806680193266794", + "proposer_index": "9769544259814878858" + }, + { + "aggregation_bits": "0x038696ac1044e65dd8d2446796655e424e793d456cea20ffa317da12f1bc8df47afbc20cff9a124a463a1f1c219c3295c0d514edd050bfad67d257edc5ac6ac8e6988c68e6a0444d18860fed163bc0a1e9db09199647e150b6c3a9c6d58d5b7e91f8008af130d62e1c247c9883ae419f009b31933c8dc19704662c009465c1ca0d9ce2987febff4fa90e1b775e766fab3dd4dc01a4c4976ff33d5cb7cec25f12ef0a78994188b4edc5f782eb5a48a1dbd52cfcfd2a95c87a54bfc13438ed7e60839ef048371ce9009665006ebd5d99eb45d119fd86ca019f99adc0f839de8367e513618b4a63d2218bb6d64edcb793005a366ca109fc9dcb7ccd2f4da1866ccd01", + "data": { + "slot": "9771196743031562986", + "index": "9762934326948142346", + "beacon_block_root": "0x1e0a7787aa681590340bbf93ce53bf0ea1f6c12769982d75e5bdf8d53e2df9d5", + "source": { + "epoch": "136939890", + "root": "0xf8c782876ad156064a85f03c2742967494f0c303fc06dc0089bb7145896b8ac0" + }, + "target": { + "epoch": "141941626", + "root": "0x076c1b882b23a90762b873d4a95c80a0f2a1dd2f77a4b718e39c96ee5b95eaa9" + } + }, + "inclusion_delay": "9812508844923502667", + "proposer_index": "9810856361706818539" + }, + { + "aggregation_bits": "0x8dc21ae70108e6d4b6d016a9b3a083264570a5b95a1830407c989fb48e3b0e9e9758db64438ed30cd4db89fed163c4134f0a2283f7b81bec6e1d316f4f5b338e6800b509bf428570f6156a24c6b51e2aac217d1803f93a697d74986a76c8d5e95fd2d9bfbee066890f2cbaabab1068515916993b67e44c1919eed4353489b276dd3051555f20eeda31423f5a605eb23581bee8525d43891e29d65428540bca1306515a8484c0061fc94875852cc519b507615f94f00d7163d97a879093b080367af4ae8ebf196502a14cb5eac46e089b1f10e592a92a57810d10fdf7748cdc4b9252f7e48f53fc11bce484be39a488ef6cd5ffab71b4f5fec8fbab8fcd3e6f8b01", + "data": { + "slot": "9805898907761798859", + "index": "9804246420250147435", + "beacon_block_root": "0x8d53f2878a34c4e9168d4604721a103c1eb7d62d7321d52f24256f68543bee74", + "source": { + "epoch": "140210256", + "root": "0x6711fe874a9d05602c0778adcb08e7a111b1d809079083bbc822e8d79f797f5f" + }, + "target": { + "epoch": "140595005", + "root": "0xd9d7da870a6341fdeb98e3b1c13d627037c3d2754d447818db297d89bdbecb9f" + } + }, + "inclusion_delay": "9787721583788338858", + "proposer_index": "9792679037733358538" + }, + { + "aggregation_bits": "0x1362df66c7bcdd2d86919277ea1e4098c296637ebed6f8f1419b450fbbd8124aa0a23281f2dd1675961b44174fdaf6ede7985e307529bd93319cc1244ea278e95023aedcab2ce3a369a37b64757eadc576a282a171f953e73cec0b18ef9881ddf4d1a97bd9e41c67182fa0cc6e331df5542edf27c53cd0f0f03e41197861c5707b3f986c0c761729871e385e3c688f3cb567a5c5a72c96f89716886240827572bd43b452967c88ad082306eefc91703be7923bee41fc06926a697f50ca6eaa8ef9401842f8013a984cab3d6f6f1a3ad43fbf48d31a8c4eaba2dee65e6cc4d744b51de1502906d5a204dcb95e74fd73803561f28a17fcf4fcba949a575134acfc01", + "data": { + "slot": "10151268050372636979", + "index": "10156225504317656659", + "beacon_block_root": "0x5c4aec8cf3197d8837cbbe390f1fa865d226ad6ce3fe426358a536a738227ddf", + "source": { + "epoch": "181186014", + "root": "0xcf10c98cb3dfb825f65c2a3e04542334f738a7d829b337c06aaccb585667c91f" + }, + "target": { + "epoch": "181570762", + "root": "0xa9ced48c7348fa9b0cd75be75d42fa99eb32a9b4bc21e64b0faa44c8a1a55a0a" + } + }, + "inclusion_delay": "10139700663560880787", + "proposer_index": "10138048180344196659" + }, + { + "aggregation_bits": "0x5f2d1e6024fca88120c034b20b9e2662e1017e98b0ebe1f2e36fce6531c732ed477b9a74c6f81b706d9044860b1f7d5d15cd232588ccc76831769778f4f5bb4dee479640a7b42b189ce7200cad97bf0dfea7fe5ae4caebde7f595527a3c4f1d1af522dd176e2dfaefc97a3d36d748e2004da9d517511c74512b482d5d0a59e0408fa43ea4da90292f4548b1881a140122ce728b128ce7597ecf6ed5d26907362a265e9d7e2686d8e2d22891c6663f7f9ece981f655c808d55ed9e7e9c091b4e801cc7662a962a5186a9c8df73abae13e09b43b10101051abb15a7a291bf04e13ebda955ea5be4a61cb825f27405d8f3d6c341f4f5b35fbd8842f133f5f7f90ea01", + "data": { + "slot": "10133090726399176979", + "index": "10131438247477460147", + "beacon_block_root": "0x2eb6ab8cd359157ec1ab2e1726008a351648a2b2b99e03634f321d429a4b5ed5", + "source": { + "epoch": "179839392", + "root": "0x3e5a448d94ab677fd9deb1aea81a746174f9bbde343cdf7aa91342eb6c75bebe" + }, + "target": { + "epoch": "184841128", + "root": "0x1718508d5414a9f5ee58e35701094bc767f3bdbac7aa8d064e11bb5ab7b34fa9" + } + }, + "inclusion_delay": "10181012765452820468", + "proposer_index": "10172750340779465236" + }, + { + "aggregation_bits": "0xa90ee5e473698ee6cc8c11a6b88f8aa86100443c2f06eef9ab489b59d9a8cd2b8fb210667cc1bf502c2144b9b9a4633244c701e86f29075e5de0a046c759d1a8b2ebd53ded9a34a7d3f768ff81c76b1a34866cb971bd8ca3527e1fb170a4ea27b1c45f717d1150e2e64b8c2c9c61961a0dd3230816c3f09a40fb5cedbe17520794e16f6cf276524f64b75deaf31745e03fd4b993a8fed2da5d0fd535bf0e0d4f33f8d753a2cdb28b70e1b0e67511ecd554520f220cbeb7161438d437f1445749bfe480ec8dd0054dc05ba176312c6b87a423c2571528f29f72ae9ae66ad70879b2940cd4200549da1fb04b6333871ee2ab8fe1dd27cc2a042856a5038d71b28001", + "data": { + "slot": "10174402828291116660", + "index": "10166140403617761427", + "beacon_block_root": "0xea830f8d335441eb7839533519ea2c97ac14b3009d4a4e06459ea1f519dd309f", + "source": { + "epoch": "183879256", + "root": "0xc3411b8df4bc82618db384de72d803fda00eb5dc30b9fc91e99b1a65651bc289" + }, + "target": { + "epoch": "182725009", + "root": "0x3608f88cb382befe4d45f0e2670d7fcbc520af48766df1eefca2af1683600eca" + } + }, + "inclusion_delay": "10162835441479360467", + "proposer_index": "10161182958262676339" + }, + { + "aggregation_bits": "0x1fa33fdccba5651e4c173e32888013c80d643394b32d55f8bdd7c1cf1d8b04bc96a3bf6e06c4c2b9e9ef9747e25f8d93fadda8c667597677177dd852226875292def86f1b138edb6acbc3bc33322ffa897ef9f913f699e801a3ec7642e110bfa3a8812664dc5af0b4f6f5e65f469a3f006a8595fa7fc1a5a8ed267d0afb1cd2add7787826573f4129b161b262d08d478a25c16b90cbe73f725aff9b9b794c1a6503873286d8b90327e9ea9cd9cea5984fc0a2543ae9aa8f22e0c83ffe21db1171fe3f40856d3cf06fbd14f8ca218b8b9db999e7b397acc89756d3f2be0d42cc9dee1bbfe304e136535b7e0b18e89b4170d993dd93b1e769d404191a6c6e8fbc601", + "data": { + "slot": "10103346015613960786", + "index": "10101693532397276658", + "beacon_block_root": "0x1f12138c1208c37ca978ab7fa5e59f09b99688863d01284bf550f898c821feeb", + "source": { + "epoch": "174837657", + "root": "0xf9cf1e8cd27004f3bef2dc28fed3766fac908a62d16fd6d69a4e710813608fd6" + }, + "target": { + "epoch": "175222406", + "root": "0x6b96fb8b923640907e84482df308f23dd2a284ce1724cb33ac5506ba31a5db16" + } + }, + "inclusion_delay": "10085168691640500785", + "proposer_index": "10090126145585520466" + }, + { + "aggregation_bits": "0x477fa707daca7bfc7c2fde5ae55e16bf7e0f8366c29514af8796c9c8b1ed8e17864e8ef68e8d8819277352df9542bb84eaf9f8eb9f324d9a751ce7dd030e20dfcd56fa23f1a7a273950fd1336ae173da37a22549b61cdf994017968efeb27218dc9ff3d24d7142e954c5aa8740647e576c72a8717e00b1f579c2959055f68e0b9af6abb0c2220e74244059004a5bf04c0eaa33f8c3444940cbb9db199a440d9f297ec1ec33b313abe26baba113af8e44d79693a81766a75ac19303535cd8bf18a808f9b310b68fbe8d755d8f942baec027c362e20dc621e6a882b2dacabb0affc4f6fe249b3dee77d91fab6acc36382526537c25ea6385bf65eebae06e698a8401", + "data": { + "slot": "10078558758773764273", + "index": "10083516208423816657", + "beacon_block_root": "0xa5f9e98b7119de5e5d4d7eaf6ea32fa5e5ab81843a7e456235d9d012c0c701b7", + "source": { + "epoch": "178877520", + "root": "0xb49d828c326b306075800147f0bd19d1425d9bb0b51b217a8fbaf5bb92f161a0" + }, + "target": { + "epoch": "179262269", + "root": "0x8e5b8e8cf3d371d68bfa32f049acf03636579d8c488acf0534b86e2bde2ff38a" + } + }, + "inclusion_delay": "10119870856370736658", + "proposer_index": "10118218373154052530" + }, + { + "aggregation_bits": "0xb7c6ad9df61775f49bbabbe7aa13dc994f3bfceb55ad406cb2279e99bffb9a2578b385888cd9ad9c1bdd96c00056388c3b7a639c49bb86bff56a9caaf183d4d4c603e530b2683ca476942840459cd967858b730d5d4e414ca098434c9185f74e3fdd64ecca70a96e218812c0ae39291e57cda4f1e0113d31be0d04a36b64fb58ab7f0884773ba17468d31bd6d3f11df55da10ef5a77b33157a8d8c62ca0cf9f8568c168ae3071c91a7d80e841dfae7f94c8e128b60a9a957d29de8f4bb0752d8c9b7e917264fe4fdbf0cd39ff434a18ec205122ff4b250f41c1da31f8543b974bbca16472a2fd40d2b8b1ac4c3a9cb50c951ce992f7a0977b263aea25ab4c7f701", + "data": { + "slot": "10113260923504000146", + "index": "10111608435992348722", + "beacon_block_root": "0x1343658c52e58cb83fcf0520126a80d2616c968a4507ed1c744047a5d6d5f655", + "source": { + "epoch": "177530899", + "root": "0x8609428c12abc855ff607124089ffba0877e90f68bbbe1798747dc56f51a4396" + }, + "target": { + "epoch": "176376652", + "root": "0x60c74d8cd2130acc14dba2cd618dd2067a7892d21e2a90052b4555c64059d480" + } + }, + "inclusion_delay": "10108303469558980466", + "proposer_index": "10047161564771863953" + }, + { + "aggregation_bits": "0x4de68fee8eb074e271cf1331c538d803e102241f81c228892b59c3f7858609c759f6223d0edad55d076998f5a8762150819e9257ffdf096befa1a521a2db6544be6186da782f56c48a77ba820bdd0c0329a8d3e5e4957c037847281067b3006c0fcf6d75ef073d54945437be5b10ac801ac6515d54a5d6f8b9b6998f5468891b2c513885de9c5eddc711ab01df58e04a8691661f42dcd1744b1ec47ff685d8aaf40c0f16b967c9ddfbfa083fbbd5190ad8ca9d4f61cd893e01f4bec0ab1171ca85b927a111d3304a93e520e141b323169d518f8f64bedb13b0bb5335991dd18da4f8b9db9ba4c6304a3c67d5ee77a518bb1ab578dc99c0352aafe25f948cd79f01", + "data": { + "slot": "10048814047988548081", + "index": "10040551627610160144", + "beacon_block_root": "0x9555518bb0c78b5d451afb17ed88457987fa6758bfe0694adcf7ab69ee9da1cd", + "source": { + "epoch": "169258798", + "root": "0x6f135d8b7030cdd35b942cc145771cdf7bf46934524f18d680f524d939dc32b8" + }, + "target": { + "epoch": "168104551", + "root": "0xe2d9398b30f608711a2698c53bac97ada00664a098030d3393fcb98a58217ff8" + } + }, + "inclusion_delay": "10037246656881824592", + "proposer_index": "10035594173665140464" + }, + { + "aggregation_bits": "0x5b3dcfee5ef782e76260b74bd3c44459f2f6c3921ecef4e21cc9e418973fd831220f091c6621fe9b5897d9021c2d4adfb5bd0e9f9fd8557d0e1cd6087ff68689e9bc622aeabbd067301b04054eb871878e8730d92bc910b6ace8d2635f5eebf512f64bcfaa18e98d1a4278e09a3fc14236de4e88dd101d8ec0e0a9549a25b7199f6ae4ad0573e89ba9101d4d4d35e01b539ebed562c0ed3f5d03d20e6f16f9294509813152d389b0959605837bd885a8cd3a9e31fa94283f3572bff096bbd848568e74689e654f42ca2f2f656f7986c921c593c24d16bb846e00abf764ace9f7cf6a3c1ff21722f83066d2e23e40afb606eabd7ae06106e66fb7b601eb8cfb9601", + "data": { + "slot": "10030636724015088080", + "index": "10028984240798403952", + "beacon_block_root": "0x049fcc8b91933ab7279c8288904f96a604bb7c5eca6911051a5f22fc04ac966c", + "source": { + "epoch": "172529163", + "root": "0xde5cd88b51fc7b2d3d16b431e93d6d0cf7b47e3a5dd8bf90bf5c9b6b4fea2757" + }, + "target": { + "epoch": "172913912", + "root": "0x5023b58b11c2b7cafca71f36df72e8da1dc778a6a38cb4edd163301d6e2f7497" + } + }, + "inclusion_delay": "10065338888745323953", + "proposer_index": "10070296338395376337" + }, + { + "aggregation_bits": "0xb71e342e1d23e5988f32054fe4d4ce8c60051a3c0363bae3dceaf5660e492eafd984911e703c5ad93477c0cdae8fd244fca7457adcff990bd288e62f55fe6fd6e000126272b5ddc47f4f48df60c8b2b22486b23eb898768bc3ff69bc8cfeb58a2a60bf7df1d2261920fe1f3d872c99f91b95d0da842a6bb0efeb736deea3f9549a7088c12bacaf4868f3cb8aca022fc01ecc07b567ca2e66ed861ea6669c1516f6a4dc59965361ed4df50e717cab3e4467f100f5e18596dd47130c6ca96a733ff1961dc60797fa4f59e903e84caba8108c488ab7512420b0ccbd6f4a95ad8c1c943eabf560ac25e3f1566eddcbfa34c1c53047ca8ea86873b08e18fd6906906001", + "data": { + "slot": "10058728951583620145", + "index": "10063686405528639825", + "beacon_block_root": "0x8a86a38bf1a45599dc7055b85a0d264230d0755cc6e62e1c5be7fa75fd519a37", + "source": { + "epoch": "170413044", + "root": "0xfc4c808bb16a91369b02c1bc5042a11055e26fc80c9b23796dee8f271b97e677" + }, + "target": { + "epoch": "170797793", + "root": "0xd60a8c8b71d3d2acb17cf265a830787649dc71a49f09d20412ec089766d57762" + } + }, + "inclusion_delay": "9994282076068168079", + "proposer_index": "9992629592851483951" + }, + { + "aggregation_bits": "0xc52d460682bc4cb1a681f964b78e8a9ce6bcd4f301899091920e262ea3d5fbe1cd2385d3fe42d3bcb2875b2c01f9d22b98ea6263ac37808f4c911f55ec45701f0ba927f6a69d5ed52f46fa3e1714ce3fd04b4231199e912c96b15ec8c4ea9a09c696dc28fa3ee6788257895bf143fb84544cf4e0a5351682b500b9ce858b80042bc71dfff1f9bde04b4ce82c9a1a2a1fdafcd7204b58b692fd9d55bd03961a189969c34a70ad47eaeec69f5de88c77b3cb42a8ee8bdb2741ce45c7636156f26bfbbb8ffed823b2f6993e5219ea23e15d71275c6fd63a4fd4e649b804170be2e8eb94ab509e8c02e53b2d1e721553faaa14c4fae1f0dbc2c6b0122922455682e101", + "data": { + "slot": "9987672138906464271", + "index": "9986019655689780143", + "beacon_block_root": "0xbf14a78acf58d72a0db0ad02e60899b43c524be2679d08610b9a5119ab966784", + "source": { + "epoch": "162910441", + "root": "0x32db838a8f1e13c8cc411907dc3d14836264454ead51fdbd1da1e6cac9dbb3c4" + }, + "target": { + "epoch": "161756194", + "root": "0x0b998f8a4f87543ee2bb4ab0342cebe8555e472a40c0ab49c29e5f3a151a45af" + } + }, + "inclusion_delay": "9982714689256411887", + "proposer_index": "9974452268878023951" + }, + { + "aggregation_bits": "0x81f9bb1f32c2d23fafbb2afcc968698b1f97de03c521d7d7ec6ba7291f92c462c96a45dd3613c17ced728dd6f4c6e13284fc258415ddfca3feae2bfbeb5135e22b9157212385575954e102e26cc5da1070257cecb04090346eb6354a14ddcbfb2681959532ca7bd873ff3db175462e222a9e4acb7ed970057a9a9e1c31dc47386c89dfe50e8adf64f83baa6ab5419e2b57cb6e7205988bad7311f6ecad4729f3f3107bab03f5b16d1076b73c52cda577eed63e453f4f41b3be0fe2cfd7b27a505d94be4dc0563688e35bc0049c12a7679d2da08236fef722bbf645d43ff1050efd130cae40def5a6c7cd51e057b630b9f8299b1b18e63148b5c7ffe2bac067e101", + "data": { + "slot": "9976104752094708079", + "index": "10020721820420016016", + "beacon_block_root": "0x7ae20a8b30530398c43dd220d8f23b16d21e5c304b4953040106d6cc2b283a4e", + "source": { + "epoch": "166950304", + "root": "0x54a0168bf0bb440edab703ca31e1127cc6185e0cdeb70190a5034f3c7666cb38" + }, + "target": { + "epoch": "165796058", + "root": "0xc766f38ab08180ab99496fce27168e4aeb2a5878246cf6ecb80ae4ed94ab1779" + } + }, + "inclusion_delay": "10017416849691680464", + "proposer_index": "10015764370769963632" + }, + { + "aggregation_bits": "0xb3d63756201e56b28db46812b69194e925b54afde3ab067637a474a62812780027a137f1882748144f9b9b141f290bae6b2a7746172110a2e3a1ffd96b266b9665a80a64b8e7e750da64ac6b340b148e9543b92df4d77b24c18805625d5f2d2f783b4e7475fbdf5df77dcad23d7b63fc6b197667e6b8e7bb451d070a6572f007bce6ede90ac14df36571ce85db74ab302ae8ba89cc6e1bdbcb7ed7f3f78cdfa596cb499657bc72935a4940b33071129d64791c5c1ff5a8bca082a4cf333c3e0605bdf05741453ab31ebef101a1f96ef2ce6c7c7f7130b65a8f0c45fad2b937108f428b41e1d6eb96a03713d1bbb76312fe8a4890686eca2130fbd3389af8e73301", + "data": { + "slot": "10010806916824943952", + "index": "10009154433608259824", + "beacon_block_root": "0x4c4eca8a0f939b8d4e1e42fef0d31de61740517621e91304f892bc678d511b44", + "source": { + "epoch": "164064688", + "root": "0x260cd68acffbdc03639873a749c2f44b0a3a5352b457c28f9d9035d7d88fac2e" + }, + "target": { + "epoch": "164449436", + "root": "0x492e5a786f15e5da7c68904e958c9bfab7bf36fbcd452aacb746be5b657f07ec" + } + }, + "inclusion_delay": "8670642439683596559", + "proposer_index": "8675599893628616239" + }, + { + "aggregation_bits": "0x26355b856096a4b9dc6ac348ccb5e6d67d8dfb0ed8d7f1b8541909dab40148328f12106f66ae2d5e55dd549ac46a128f537f9bed4e31f93672783c76836e32b411659cdd73ae9d4caf0f60cd2e056a3d490c8b3258fceccf038f6696a9d36a5059086450421f4ee20d48f55978627b432a1f1724e3f9df9a49a3de2d048a880dd0d9cf162f337a009a8c6e8a67ca6e92230676fd0bc36cffc156548376b3338443babfbe91199843e90fd3a58f6eb92011a004ac712471afc1042a5060fb0c58c5c8bab08693066b72f74e5512c4386b08f23f6a76abfe615db67f4aa2f80b0fa81905eb194ee7f24af158dc69a6176ad638789fe1b3ca75617b800e58afe5a201", + "data": { + "slot": "8664032502521892751", + "index": "8668989956466912431", + "beacon_block_root": "0x829148784ff882a95c31c6d01027d961cac833b1f09fa4da40ca88b4f4a12d8c", + "source": { + "epoch": "8049009", + "root": "0xf55725780ebebe461bc331d5065c5430efda2d1d3654993753d11d6612e779cc" + }, + "target": { + "epoch": "8433757", + "root": "0xce153178ce2600bd303d637e5f4a2b96e3d42ff9cac247c3f7ce96d55e250bb7" + } + }, + "inclusion_delay": "8652465115710136558", + "proposer_index": "8650812632493452430" + }, + { + "aggregation_bits": "0xea7a9ae73ad454c9ba8665d9c9ac996c9f11f6a2566ad99bd921862598b7f9ed1c9bba9f5894c25f12e051aaba9e8d13269d3eb833568379a0987a2e615d7dd8a70dc2103d7045f71543ba279c78fe742562e349afcff4fae01b2a09f0f8fa1867fae4d32c30ad5ced3dc2065857a3d452de75fa01745a0c8b3e5fc4305af1f3c40d1b963ec62cbfc927d9a99d23e0ac3808dacd9421ad409cd6f930b83115965808f9c1c755b771427d7977918d709908cb3ce087385748e7a453a22843a33f2846d4abbed6bc8a84d05cee67e0c4893b09c7afb453e9666612e67a00cc0aacf74351fd85343d5185a3b6f01d86f344038c01fc89789b8e3be12166c6a4010d01", + "data": { + "slot": "8698734662957161327", + "index": "8697082179740477199", + "beacon_block_root": "0xf1dac3782fc431033eb34d41b4ed298f478948b7fb284c957f31ff460ab0222b", + "source": { + "epoch": "12858370", + "root": "0x64a1a078ef896da0fd44b945aa22a55d6c9b422341dd40f2923894f828f56e6b" + }, + "target": { + "epoch": "11704123", + "root": "0x3d5fac78aff2ae1613bfeaee03117cc3609544ffd44bef7d36360d6874330056" + } + }, + "inclusion_delay": "8693777213307108943", + "proposer_index": "8685514792928721007" + }, + { + "aggregation_bits": "0xcc5861374d6036fe1ec66e99b4a426839fc0440c1ab4d71f1b42178e71c94713c10a269de8eb443ba317407d0ab603c85d9d51ef30b3c38e440d0c9c03cd93d7fa2da64cf547481c5e577746f9e814639f686924b09c130fde39f2ba325ec4e7defc126ae73a6a85d3afe9bd0a84f1ec7b90eb9be4b63b31ff36d1f947f4bb5ff455701399bc3f6679c48f7bfa30b6ce757b6fa110090a191e130148ab372999c304f6549791482c9f9d31add666abf5a20022249c276083bd47017e1980fc9e134230252e0035b73f1ad2cc21a25758b56435dab94b625495c763f6d343edbeaa11e8570b06328a7299631da4fe6aa180dad3eee596f51fd3f8bf1a84aadbdf01", + "data": { + "slot": "8687167280440372431", + "index": "8678904855767017199", + "beacon_block_root": "0x0fcb6b788f32470c9c9f5acc1bf25d93a4b63945aaebaf7d2ec3f302d65ce14b", + "source": { + "epoch": "10742251", + "root": "0xe98877784f9b8882b2198c7573e034f998b03b213d5a5e09d2c06c72219b7236" + }, + "target": { + "epoch": "3432022", + "root": "0xbf7198770dd5adbb180ae0e6dd2f416a852316cd4f256cab9ded712c8bfbaacd" + } + }, + "inclusion_delay": "8622720404924920365", + "proposer_index": "8621067921708236237" + }, + { + "aggregation_bits": "0xae7f7a6ffda8dd4a9ef96b5c26eb75647bb60ba60a9d45951d54a98a92195eb4f953a3859eb63bb4b62fc3437dcd76558a2fbd99bbdb61d74b50048ab5f6379474b930932b74a7cc2f17007c2acdf490fc2382a4640c6120a5712a6d68ae632f10511667773784ef5ac361b06c598e56e285a1cc512d3311b55bea44ab59a053d1c5c8ac84dac03f0eb54997660262da72b3e1c3ac410b0047aeadd4876587762bd5ea654853e2dd95d17c87430d93cc0a3a9815961fd7553e2553b3aac80fc0336b52094d07d6bf25ac1c97e756fb6a8edce3daf73370d7de47963fcde83862ca565f7d115428371ac809e89f5244cd6300adc26145a9afff42bebf495512d101", + "data": { + "slot": "8616110467763216557", + "index": "8614457984546532429", + "beacon_block_root": "0x45596f776de6c89dcddeb216a7edd005b1380fcb4ba289c2de754aa684a1ae98", + "source": { + "epoch": "1700652", + "root": "0x1f177b772d4f0a14e358e4bfffdba76ba43211a7de10384e8273c315cfdf3f83" + }, + "target": { + "epoch": "2085401", + "root": "0x91dd5777ed1446b1a2ea4fc4f510233aca440b1324c52cab957a58c7ee248cc3" + } + }, + "inclusion_delay": "8597933143789756557", + "proposer_index": "8602890597734776237" + }, + { + "aggregation_bits": "0xc8558181be3d7a7d3331500965eadeedabc379a4f5724b3455733be4392fe10aa4d43b4fac9ff7d663c8d698cfe55a4efdb9da5ccc6aa9e117c035b6d75a0da73951348f23caaa73e5434985665e2695122920cff37d8f51cac671fac31630d22bcf7c7fb2a16a32407f476bafae5ca5edc865f7324717efc77b312bdef7ce11905da24a2015ff445e563fc429db20b93fe152a3ec49ae79d50b11b88e71bb09b019b461957547d04a3058f5046e2020b1c337919d47c1f444a0652d9349ea53cfb63607f9b3551baeeb90a6d54460d2b259520de60bf92f9ebb86d07c779a62d900d2e5dfc72b84d8b0fca76e6adc0ee15f23500dbc3cfa1613241757db329f01", + "data": { + "slot": "8644202695331748622", + "index": "8649160144981801006", + "beacon_block_root": "0x671e0278ce83fae3da549dd9fc90cffe15ed27897c088e9465d8b217312cc60c", + "source": { + "epoch": "5740515", + "root": "0xdae4de778e4936819ae608def2c54acd3aff21f5c2bc82f178df47c94f71124d" + }, + "target": { + "epoch": "6125264", + "root": "0xb4a2ea774eb277f7af603a874ab421332ef923d1562b317d1cddc0389aafa337" + } + }, + "inclusion_delay": "8632635308519992430", + "proposer_index": "8630982821008341006" + }, + { + "aggregation_bits": "0x00134a4f403d8dad5040e28cc2782857d83876e9ba4f7106b20dbedb1799d11c170b817210ba96f24ccdd2ac8365c04208caa75931bfc32b651c33ac3d9d9ec50f552e422ad23acaf92f03eff61912173e056ca4244bdc2017d3bc45d29bfcca1525a86fd39289e08c275d54ba9901d805790e628766327b0590bdb0fea7b20df7c956ee76c88d59f5d40c63897aaa8ba144ce8f9b0e6f6408abd08d7ee3bf4eaf73a926e7c1427288b39e4fdc0da780f8a8bf897351cea070d4729dd1d2772fe138d9b6a0def14bd440a014bde0947993c26d9aa9d7ec38c7670aebdf57e45fa7cbe3ea5237f75f07a27ad9daf27d32bbe118344135774e4989a47bd5490ea901", + "data": { + "slot": "8626025375653255918", + "index": "8624372888141604494", + "beacon_block_root": "0x398ac177aec392d964350db71472b1ce5a0e1dcf52a84e945d6599b29355a702", + "source": { + "epoch": "4393894", + "root": "0x0f73e2766cfdb712cb2561287ec1bd3f4781f77a63735c3628929e6cfdb5df99" + }, + "target": { + "epoch": "997083665", + "root": "0xe930ee762c66f988e09f92d1d6af94a53a7bf956f6e10ac2cd8f17dc48f47084" + } + }, + "inclusion_delay": "8568188433004540364", + "proposer_index": "8559926016921119724" + }, + { + "aggregation_bits": "0xfab20ebd09d98cf74bc86e3860175cae9ed13e2f1e7910e035526b3328f712f7b4bea6c6dad06c631c6986b101e6c924316a520284da4c4dbbc63b636b773799f7a427d2e2aa286f47c5f5383a314b7f03208ed0fb94e36ee70a455a20094320257fe256f5a701d31976322bcf2021765cf2fb8667745e9a063b141aa98980d3e6e473eaaf3b33f05b52fc909bda116672a23165f60b99ab1d0ad83642349efa1ef50398ec3b1b331cb7c0dcca089b332cd0a0057344e499a0d84a9bc291451c2d9c8d4a9a7389b808a993eb19a177a9aa14601b89fb2f5ccd95f267572194a6b82d7d40a3a5f9666c0687aa7b3d5252dc42af8b19d7302e9942d7048a51565501", + "data": { + "slot": "8561578495842836556", + "index": "8553316079759415916", + "beacon_block_root": "0xbb9cad760ca6917e6a8002afee9076757f9cee9ccc81cbc1c41cfe76ab1d527a", + "source": { + "epoch": "996121793", + "root": "0x955ab976cc0ed3f47ffa3358477f4ddb7396f07860f0794d681a77e6f65be364" + }, + "target": { + "epoch": "994967546", + "root": "0x072196768cd40e923f8c9f5c3db4c8a998a8eae4a6a46eaa7b210c9814a12fa5" + } + }, + "inclusion_delay": "8550011109031080364", + "proposer_index": "8548358625814396236" + }, + { + "aggregation_bits": "0x549c8feaba41213e65d7bc01077a84d42439b84cfd21e309ee2db6340f74b60dba95bce07404ef039c20d14362502394a4d82c78e203a00ca5810d4acb8408fdfcbd1ca13c4c90f14154997062aeb6f8af463d5bfe22507b0031353602afa9f1e3cc5f4666a0b05d9efdd388bddde1b8b542d32a6b0fcb543b97fd2a1d26e70ff268c5f48f504367c2169b7f3c373cff0bddd50601cd4c4ed3a150697b67a9fe5f6eb1907c3699ce5f0bf797244029d9aa5f290972f46f92a311448e391f684a1935bbde536611edf13ca26f2916fb5f745d90e5868171c851384fa89a679287927e680ac685e7533099856b9e2649fddae57c8261ca170b2cbeeb86261e45a101", + "data": { + "slot": "8596280660573072429", + "index": "8594628177356388301", + "beacon_block_root": "0x2ae62877ed7140d84c028a1f9257c7a2fc5c03a3d70a737c03847409c12b4719", + "source": { + "epoch": "999392158", + "root": "0x04a43477adda814e617cbbc8eb459e08ef56057f6a792108a781ed780c6ad803" + }, + "target": { + "epoch": "999776907", + "root": "0x766a11776ca0bdeb210e27cde17a19d71569ffeab02d1665ba88822a2aaf2444" + } + }, + "inclusion_delay": "8578103336599612428", + "proposer_index": "8583060790544632109" + }, + { + "aggregation_bits": "0x024875a4ab2f9d184dc77c61e8bf68e257d2825ebad9a20fd5683d332539bd87163c9cb8ac03b1e3431146d9119d30a0fcde4c8636691d3b82e60bec82260511ad852070e85893ce7ae773e53967b98eee28e7877edd8124fdb664a5cf94fc052351347a6a602cb625d2616c91cc9e2e4504380190fb61e37426fef8eb4da220f1c5c7fc7401c12f7161dc3bd1e098eec22b70cfcabd7633af850aabd4b753470d0ec15cc32e2f1220d8b1facffffe1d83cbbda31369e9484f5f5ba2c17be1c9dd9abe77189651f98fb5707a107dfc279d154c0ab741d47e07d7d21eac1954db88fb5f104abe9ad1d57dc692dea5c2eb3a08ddbff1f34c898d6108a650bf10a701", + "data": { + "slot": "8571493403732875916", + "index": "8576450857677895596", + "beacon_block_root": "0xb0cdff764c835bba00d75c4f5c15573e2872fca0d3879093430c4d83b9d14ae4", + "source": { + "epoch": "991120057", + "root": "0x85b620760bbd80f367c7b0c0c56463af15e5d64ce5529e350e39523d2432837b" + }, + "target": { + "epoch": "991504806", + "root": "0x5f742c76cb25c2697d41e2691e533a1509dfd82878c14cc1b336cbac6f701466" + } + }, + "inclusion_delay": "8507046528217423851", + "proposer_index": "8505394045000739723" + }, + { + "aggregation_bits": "0xe0fd04d194a474a57d4fb41916cd1ef2d96a4e43bd23b0fd1c0de6670ea52499b2bb512922a9798365179fe0d86d12ebec922636a121d58b51f51a9a7dab3ac852ba17d5f97710bbe2e8d1856c735f42baad5380f4cb2e81a9983ba58184da88eb0e516b418aa7de9fb9efce6d72df60806c5c7bc5e49d2d84dd305b647029e1c7706dcc5a3291c956dafa9883310d25001718187bbd6cc49bba81823127fc2f6a9a50633d19050d03884ebe0f6fb28b277877ad9ba27afc7528323849e250bcc32f25bf96a54544677a4103fef2f42a6423b0c3fa59971a46370b123c373fb3d313cff7ee1f3d811409d727048985c0efbc6ed0b1881a314b7f9639dded232e01", + "data": { + "slot": "8500436591055720042", + "index": "8498784107839035914", + "beacon_block_root": "0xe55b03762b37dd4b3116b599e810cab034f4d126743e6ad8f3bea32668161831", + "source": { + "epoch": "989773436", + "root": "0x5822e075eafc18e9f1a7209edd45457f5a06cc92baf25e3506c638d8865b6471" + }, + "target": { + "epoch": "988619189", + "root": "0x31e0eb75aa655a5f0622524736341ce54d00ce6e4e610dc1aac3b147d199f55b" + } + }, + "inclusion_delay": "8495479137110700362", + "proposer_index": "8540096209730975595" + }, + { + "aggregation_bits": "0x06dbfd51f73073d2900db36d21dce51fc85be4c7e35e9a7c7e3fb505b7d9ba03e902313b9070ddef33a582f3284d8cf41f9c20f626860ddc1c413eb11b3f1a8757181688f56c4f502cbcd07450538d5754a411376418c1fc46aad31a4b6ca9e7b790a37dcc126203e54c80311ae506d8aa2fc209b4d6b2fe80f3faa656dec50fc76a366ae5ff9694d2393c4ae7835acf0f6085203bb54fff09333dafba70b072f9bf4f77e95ae000ce695764490d1937ccbb197996a6c11e2f4823b47d32b31f76a341b51533e459de384d42dde853f942958124fd692e2a84c6a3dfcf967fc3e265ca4f6c643013c2f30229f4f05eb7682ed672d5518ca1c6269005d7a245d001", + "data": { + "slot": "8541748692947659724", + "index": "8533486272569271787", + "beacon_block_root": "0xa02967768b3109b9e9a3d9b7dafa6c12cac0e27458eab47be92a28dae7a7eafa", + "source": { + "epoch": "993813299", + "root": "0x7ae772764b9a4a2ffe1d0b6133e94378bebae450ec5863078e28a14932e67be5" + }, + "target": { + "epoch": "992659053", + "root": "0xedad4f760b6086ccbdaf7665281ebf46e3ccdebc320d5864a02f36fb512bc825" + } + }, + "inclusion_delay": "8530181301840936235", + "proposer_index": "8528528818624252107" + }, + { + "aggregation_bits": "0x0206b70d2f33e6ab95f0353c9c22fa65db25528d7622421e882f98e30302ab100a7943165c59732b7ccfcf98bc1ae2febbbaa3e20a3155f6a86533949e9a216b04cff87f62ed99889dda35d23d36c8d34e85b602b3864c0b7f402a494af167bef78a87677f61fe0f6212dd4703ca663a59beecfc1161e851fba498b93c991b7eb099b282ab12629efc508851d02ec8aed80c49eb613dc394ac2e4bda61b5b3936833c50a126c012cb5471ec8c190d5b19943a34aee6fc7691aff3a8dcb18a2d1a93b12ae92c1844120e21e8afd2f7f0d1bab917ebd416e877064dbef200d672d83954fead2d6dc16ad125b0e36e7105b9156de62b9b56ef28f10a923016364e801", + "data": { + "slot": "8523571368974199723", + "index": "8521918885757515595", + "beacon_block_root": "0xbca4497b74453f6bdeedee9ac5225770973cb5fba1eac597d4affd3935125790", + "source": { + "epoch": "34019559", + "root": "0x9662557b34ae80e1f46720441e112ed68b36b7d73459742379ad76a98050e87a" + }, + "target": { + "epoch": "34404308", + "root": "0x0829327bf473bc7eb3f98b481446a9a4b048b1437b0d69808bb40b5b9e9534bb" + } + }, + "inclusion_delay": "8875550444451774356", + "proposer_index": "8880507898396794036" + }, + { + "aggregation_bits": "0x9e6bf617419110d3a780f5e993af121a8ec7140af0e4c6963f6760483ee7d9843ca7832ea927f642dc84c47100a241011640ea0489aceee8e384fbc0a71769ecdcfa03bce6a27e58234e03b2cefb782c7085358ed757b5bfb2daf92a4b803a466ce1594b09d7653065138530eeeb57de05da682354a1a6b8675f4c8171714f69ff86a32f5956dbe7dbbcbed382a2df2bc1d18ca69beccf18c1ec965835b4cc32d9a0eeeeda74af1f1f0e6db393ebb65e2b7ac6744dd632e7a1accd5d9692806888cfe6f1fbd9f9d9d749ec0b76d30ef0d80c353522d7039cfeab90ca38054d7d80b929ae72bbf125162ae79229a5f91721cf4787ea7d4de284ff408941edfcda01", + "data": { + "slot": "8868940511585037844", + "index": "8873897965530057524", + "beacon_block_root": "0x428c207bd4565a4d93c2c1ca8ee0e60bc351aef99e67e3ae1538d6b32db85a5b", + "source": { + "epoch": "31903440", + "root": "0xb452fd7a931c96ea52542dcf841562dae863a865e41bd80b273f6b654bfda69b" + }, + "target": { + "epoch": "32288189", + "root": "0x8e10097b5385d76068ce5e78dd033940dc5daa41778a8697cc3ce4d4973b3886" + } + }, + "inclusion_delay": "8910252609182010229", + "proposer_index": "8908600125965326101" + }, + { + "aggregation_bits": "0x4e52159df308bd184895d0d2986b0a1f76732eda779e13612ed4b71023b84d2b56546158f9519106533a066d02ff410f888153671c04554cdbe7c0656bdfc9f4128e4c80b4746053aa97fa947dbfb7bde6fc265812c5cb7259d5249a34a5a350839242d58284b1b3055f077ff2bded973f2e6ee1dd2a2e3c1ce148f718db92c8de078c31a36d38cd97a7fca32e408226465275b9bd9b03013ef800072ee23816b700dfa80bdcb96154be7c9f547eccd1ff677233c859158606bb292bc5cdf886e360d5d78d718aa97350c09b5acc2ec5acf647c8eb3376de48151104efa8b4b4bfa042bc8169c34bc6260d116a3a08224fdce1bd9208e8a01e62f967f0ebf5e301", + "data": { + "slot": "8903642676315273716", + "index": "8901990193098589588", + "beacon_block_root": "0xb1d59b7bb42209a77544493b32a737394012c3ffa8f08a69549f4c4643c64ffa", + "source": { + "epoch": "36712802", + "root": "0x239c787b74e8444434d6b43f28dcb2076524bd6beea47fc666a6e1f7620b9c3a" + }, + "target": { + "epoch": "35558555", + "root": "0xfd59847b345186ba4a50e6e881ca896d591ebf4782132e520ba45a67ad492d25" + } + }, + "inclusion_delay": "8898685222370254036", + "proposer_index": "8890422806286833396" + }, + { + "aggregation_bits": "0x5e068cb5dd66a6da63ad503ef13cdb691d9982482334f02757f6f6979fd7662d7af19140232a1f27881ec497f6ecd09f11278281d92e4c419990faaa27b1900f36b69841b5606b589162000983763ecb16b2dd82973a5a4b225e5d1af08ed6b2298d8f61ae7049773174b9949cad90314eae968d17ea0c9393f06b46a40c79af998c0ceb465e8ecb20f1fea64913265e0e2494eab307aff29afcc283c838f42fdd56a5ec74ec6fbc4858dcfbde629011f87ae0b9a3ed030ee7b5a427f98872a64eca686cd138ca1711e7529420f521e76798ffe74f919fa915fa88f43f76b352a32405323c88374d0ec244b16ca9e5111715c345ee2db383b7bf7b85d54ab4c301", + "data": { + "slot": "8892075285208550228", + "index": "8830933380421433715", + "beacon_block_root": "0x32e8877a1305084c7b8f3e330dc6fcdf65a094cd23ca0797bb56b10a5b8efa71", + "source": { + "epoch": "28440700", + "root": "0x0ca6937ad36d49c2900970dc65b4d345599a96a9b638b6225f542a7aa6cc8b5c" + }, + "target": { + "epoch": "27286454", + "root": "0x7f6c707a9233855f509bdbe05be94e147eac9015fcecaa7f725bbf2bc511d89c" + } + }, + "inclusion_delay": "8827628409693098163", + "proposer_index": "8825975926476414034" + }, + { + "aggregation_bits": "0x842357fecfaea928f3371dede7f6408f6b7760e0b81fe7a74228d49958b40f2a4fa33cc0593fe094217a412da915bb3ace148c70fa42ae0cf18dcabcfba96d957b30cb9afc93708cc46a475152b2f901e1c87719522078565d3dadc5aa3ba3eba6b9e97ebe56b78dbb5131d5feb0a1db5600ec9894794e83cbb930c8a5b26432981264d7d033688657c0b868916cdf6819ecb7b19c6d336bc35e4b2fc4e238c2bcc6ea37db26094100b4c2807299be60a8c2dafda3459ecee11975de4cd082587ced0e081502286d78339cc2c381cd435602eee57251b5fe5a183b7b0f13a649d3c731581a9105f86703ac155d03ae3490130c5c821fe713069ac30c121389ad01", + "data": { + "slot": "8821018476826361650", + "index": "8819365993609677522", + "beacon_block_root": "0x0454477af244a0410470ae1025a7deafaac18913f869c896b2e397a5bdb7db67", + "source": { + "epoch": "25555083", + "root": "0xde11537ab2ade1b71aeadfb97d95b5159ebb8bef8cd8762257e1101508f66c52" + }, + "target": { + "epoch": "25939832", + "root": "0xeeb5eb7a73ff33b9321d6351ffaf9f41fb6ca51b0776523ab1c235bedb1fcd3b" + } + }, + "inclusion_delay": "8855720641556597523", + "proposer_index": "8860678091206649907" + }, + { + "aggregation_bits": "0x46002c321e5aeed75e7d0eb472e66a63d1be96e405d0e8804a0fccb6939ab1b4177bbcda612666ce7a80d470103f01e1b915499009e722af049cba0ad13752f7f4deaa82f0ec2967db1e9a1a34803e2c0bf3346a4c53de3577b8c57a7980a1959d6659e7105710d48da91e2a39eff1e1db555aebe7337c5ded918bd70f480ad5dd08bc73767e5efbd7237c3b97fa900a14bf38e13d74987256b39243cdf4c6ff2f0bb35bdf41d6049df57e3b24c8354ace1d5429ac3baa3d3f70c4725b457e73d3e56a8e24b98a38805911e7f05346c96285dbd07e6506d298e5cff5ffc2c198d091bbc2896aae4194eb6b29ee79f7f3172997662ef697a6db9355b00019aadd01", + "data": { + "slot": "8849110704394893715", + "index": "8854068158339913395", + "beacon_block_root": "0x2719da7a53e2d18712e698d37a4adda80e76a2d12ad0cc683a4600176a42f3db", + "source": { + "epoch": "29594947", + "root": "0x99dfb67a13a80d25d17704d8707f587733889c3d7084c1c54d4d95c888873f1c" + }, + "target": { + "epoch": "29979696", + "root": "0x739dc27ad3104f9be7f13581c86d2fdd27829e1903f36f51f14a0e38d3c5d006" + } + }, + "inclusion_delay": "8837543317583137523", + "proposer_index": "8835890834366453395" + }, + { + "aggregation_bits": "0x024b6d5c643a1fc930aa8c3b97679c98913ad7bb3bfdd236ecab53c7398c10aae0b0162fd1330decf7c050c20f6b0b654ee3f4b4f862dca4b622ee3a3b4394d28b58b14aef7671de357a44f082a71ca6a5bdb151bb659564e4bd3965358b4d1de3c43f745a53f36377f62d708cf22f35027451351734c9a95b040f1f694c71f18e5aeb53232b2d60bce1addc4c3337101b93bed59a0379df4c171336fd6e88d9b429a036ad8f71a3efe6a3c9b1a9f89ce2f6ec715c0f9dea1d4055e472ef719fbe6d85b75da50fbb32ac287fdff5b234c99a24c7fff909c3d27847c159604a3ebf4bcfc91512f0825bddd73499b113871cef4e14425fb8f9859bfcd0968ec3d301", + "data": { + "slot": "8778053891717737841", + "index": "8776401408501053713", + "beacon_block_root": "0x5ca7dd79319653194325f11d0646501b1bf87757ca86a6adeaf856ba1887c028", + "source": { + "epoch": "22092343", + "root": "0xcf6dba79f15b8fb602b75c22fc7acbe9400a72c3113b9b0afdffeb6b36cc0c69" + }, + "target": { + "epoch": "20938097", + "root": "0xa92bc679b1c4d02c17318ecb5469a24f3404749fa4a94996a1fd64db820a9e53" + } + }, + "inclusion_delay": "8773096446362652753", + "proposer_index": "8764834021689297521" + }, + { + "aggregation_bits": "0x58e7230f289f19561ef6008ff99bad40dd1db66befd224da7fc486290a9b830bc45433131509f57b87b590fb67ce0639757f016e4ec7434228c9f7d76b1a2dc0ff38bb9b3185aa2be8b0f37648cfc3ca1e8a7ab746baaa130e67c2b6e3b8f3f59296334d3cec67d1e23b720e49c90e3f687fc09a5720232058f587235e624133af315b53fbdc9a5543e71d4d68b8a1d4196147365f342ff81dec7a9d81b3a25e0aff54a8af466c87ab566732df8c840b46fa6add4cbdbd42ea49a9c039f9d30470d1dd076f295e1b371751833a6a41a4726afd661999f121cfce93475d9e4a8eb1fc1525a068f6a118292055f27c9deb0ac095a530107fb9f546a88fd097ddcd01", + "data": { + "slot": "8766486504905981649", + "index": "8758224088822561009", + "beacon_block_root": "0x7b97857991046922a111fea86c4a841f782569e57a490a96998a4b76e4337f49", + "source": { + "epoch": "19976224", + "root": "0x54559179516daa98b78b2f52c5385b856c1f6bc10db8b8213d88c4e52f721034" + }, + "target": { + "epoch": "24977960", + "root": "0x64f9297a12bffc99cfbeb2e9475345b1c9d084ed885594399769e98e019c701d" + } + }, + "inclusion_delay": "8807798606797921330", + "proposer_index": "8806146123581237202" + }, + { + "aggregation_bits": "0x4e66a65a9b47175c1cbdc22004607034f55d4208d9ba44390053cd277588a7b509678335b18db41d077c4329edb8f2bba0e137bc299eeb41348d831ceffd7e867124a3c9a9eb03301e27debf38113c50bafce8dec104319aa056bb86e8ffb924403de8c8377cd15dc32a86e529f402f581cb9c33cd51b4f6c771ef165add23af5996690fdb37c9c0db233b62971c8547610ac3fdb2f375afd5079392586716494774f690ff03fc0faa4ac01829f73c75dca56ba0472d345d6cc16df1d1767472a5b2c3d7ae26478caba3621c0f0385e2ac8f03986eb3b431db0de7e890d478948bde816b8150e8946de220a61e65a6403c7257ba6a50119c41f2061535efff8b01", + "data": { + "slot": "8801188669636217522", + "index": "8799536186419533394", + "beacon_block_root": "0xeae0007a72d0177c839385191011d54cf5e57deb84d2b150d7f1c108fa4174e8", + "source": { + "epoch": "23246590", + "root": "0xc39e0c7a323959f2990db7c269ffabb2e9df7fc7184160dc7cef3a78458005d3" + }, + "target": { + "epoch": "23631339", + "root": "0x3665e979f1fe948f589f22c75f3427810ef279335ef554398ff6cf2963c55113" + } + }, + "inclusion_delay": "8783011345662757521", + "proposer_index": "8787968799607777202" + }, + { + "aggregation_bits": "0x94cac2b1e27155df214b4c0d2e5f95a6d938baf28304bcfd4a1e904babf46816b98eac09d2bd0e9c43d2139e833cdf2f9c4bca65857b241fba530bf53c85c7fc1f7caa58e7090714c2edc929f67821388f4b0b2a14134fcd58c9c0d63ece06d63428e8eb03cf5d6e54e2a9b8bddea37fd4444452a5c1331dc49c67ba65761131d0bbad9b43d47a1564a18972978137a2f3fa3a37f5560b89c4a6ea3da4fe348aeb9a475fa4a9a4235efa0fea0f88444c8c89ae05c758197533e8add7bb1052e9e9fe9f67883a6c3f226b1012aae9065387775a194eff6bc05bb117670cba384484e99fd5348bfbedc604dfc730888d0145ddb20bd0bb5ccef129779a5bf4efd101", + "data": { + "slot": "8723521924092325136", + "index": "8728479373742377520", + "beacon_block_root": "0xd2ea1b79d0551cfadfc640b64ee9f58ae95b57294c66e8acd09f0a8b3e03640a", + "source": { + "epoch": "14974489", + "root": "0x45b1f878901b58979f58acba441e71590e6e5195921add09e3a69f3c5d48b04a" + }, + "target": { + "epoch": "15359238", + "root": "0x1f6f04795084990db4d2dd639c0c48bf0268537125898b9588a418aca8864135" + } + }, + "inclusion_delay": "8711954537280568944", + "proposer_index": "8710302049768917520" + }, + { + "aggregation_bits": "0x58a12b77b4a3a0c501a1ca9a8bddeb1d88aea6850db986cf66930b6864e2552120051cbce49022b9f85f170a8ee1e5c3e838577a78bc5ae480a84dad17c020b89af08a94fa9396af6da991c80c8c51f6b36fe725e36077fc41dc88c962d16a5e4c4fa870c8ed9ebcf4fba6e3db9bf52f3461072654b0a28ba603e3628fb3e84da6ef7cbb14d929ee8fef5b272c5e30ac2a4ca65b78b1c2641f46634932e02a98e288517366256099e4e9701006eb897f55e23454b76e13228dd81767a5aadc0c8cf271fec1f6dbaf50518118cf68928db4fa2d8e894162c3c86d9636fa88f1c2daa367d6a1b33266085a52aa46d8223d087bdb7e98321dec8fe3e2aec16ba9c601", + "data": { + "slot": "8705344604413832432", + "index": "8703692116902181007", + "beacon_block_root": "0xa556db78b095b4ef69a7b09366cad75a2e7d4c6f2206a9acc82cf125a12c4500", + "source": { + "epoch": "13627868", + "root": "0xb4fa737971e706f181da332be7e4c1868b2e669b9da384c4220e16cf7356a5e9" + }, + "target": { + "epoch": "18629603", + "root": "0x8eb87f7931504867965465d440d398ec7f28687730123350c60b8f3ebe9436d4" + } + }, + "inclusion_delay": "8753266634877541329", + "proposer_index": "8745004214499153393" + }, + { + "aggregation_bits": "0x9492f0aad776c73ae1e7c7da5ecc55f31a1f1f8102d4a9c834d8df158de4aba7deb48ae659b9a6fbb8f802393c034f789ba091334b111693cc7d7a273f434c8bdb11918020ed1c1012f90aba22ec8fe34d3fe5ea5e358099ef4f54f621fab92151791ee0852e41610a15d15c8a8dad919d28b95d638ac977fc09505df021026baeb11217f2d4be2d8f4c8dc75ac8ef7f651f3b7bf8994935899bbf243976079563440e45aa2715c03cac6aec60880251df4fbb80a95e0ed14f3d84ff982f352f2baa197060491bebe0878d39f8ed2d0418a79059091bfb930edb4bd809a99461c964aa6e3389bc949e68a7e675a3b156eb21644ad4dba33d23aa4db2d7e193a801", + "data": { + "slot": "8746656697715837521", + "index": "8738394281632416880", + "beacon_block_root": "0x60243f791090e05c2035d5b158b47abcc3495dbd06b2f34fbe9875d920be17ca", + "source": { + "epoch": "17667731", + "root": "0x3ae24a79d0f821d335af065bb1a25122b7435f999920a2db6296ee486bfca8b4" + }, + "target": { + "epoch": "16513484", + "root": "0xaca8277990be5d70f540725fa6d7ccf0dc555905dfd49638759d83fa8a41f5f4" + } + }, + "inclusion_delay": "8735089310904081328", + "proposer_index": "8733436827687397200" + } + ], + "current_epoch_attestations": [ + { + "aggregation_bits": "0xd84302696f1b99d5dbfaeeb37fe46aca6f18f86d110f25e0cad5147c7c948b9f8ebcfcf8ba9f3730387b8085f8a68b7f7b5fbcacd9cf18db75e773718edd32bd16cb81e0af157b3d469eefe84bd475a211134e6564ae754b833b2a12182fb473108f8121c44992d623716ae77782cd46c855acd0cd3951a1d24b4c6b03b74cf7995d1f48e106cd0871ff1c0a5646d298127a1f9672684fe1daee973f3cf88d5993a5d930e7797c42d5393051186a793e675f976580248cea9232ea4e43781bf170ac194032ada2ce9313b959392df7ecf81618a178252754e36c643484c4b1320a2cc7c5fbc521ec2ed141aaec938b344d3fd5c553f29ccc48087e3c3bb953c601", + "data": { + "slot": "9098635781783346745", + "index": "9096983294271695321", + "beacon_block_root": "0x7c9f217ef9a3160f157fea9443dc641a90c52f444fb2046ca91d4b396e28845f", + "source": { + "epoch": "57873991", + "root": "0x555d2d7eb90c58852bf91b3e9cca3b8084bf3120e220b3f74d1bc4a8b966154a" + }, + "target": { + "epoch": "58258740", + "root": "0xc8230a7e79d29322ea8a874292ffb64ea9d12b8c28d5a7546022595ad7ab618a" + } + }, + "inclusion_delay": "9080458457809886745", + "proposer_index": "9085415907459939129" + }, + { + "aggregation_bits": "0x9c87b1a4433786f3d6ce8e5e9a86a5f4cec2dc4c416664a663d39f7d88fabb38887d7cf2208e6d5867ce461fcfad8c6662b9fb41d12525e72498d5e4e5db637bd672fdb12d05783065311d30b4057195697f70afe471f4707a3e5d22c0808b93da40cb95c48d37169ad2dc05da821cf131d731ffd4f51d3a15fdfebabff48bd0be5714da5475eb4acac95f2c389142bf9b8eba55b8f4f5d2544815bff6217af7c67bc1dc0949029fc8cb5a3f9255abf67d4a85ce369ebbe87a7cee25ff8a3650d71f95fdece02370b9162d4a476468dd005fac48c8d5d267f2f5a9e47ebbf7941831418d7536dcea0a31025baad126a6e5c4f7adfb8f632e6cc73d3e160812c001", + "data": { + "slot": "9073848520648182937", + "index": "9078805970298235321", + "beacon_block_root": "0x0187f87d59b531f1ca53bdc40c9af4b5bcda28424b2f2283e9a523b366ce872a", + "source": { + "epoch": "61913855", + "root": "0x112b917e1a0784f2e286405c8eb4dee11a8c426ec6ccfd9a4387485c38f8e713" + }, + "target": { + "epoch": "62298603", + "root": "0xebe89c7eda6fc568f8007205e7a2b5470d86444a593bac26e884c1cb843679fe" + } + }, + "inclusion_delay": "9115160618245155322", + "proposer_index": "9113508135028471194" + }, + { + "aggregation_bits": "0x541e780fd30f083b11d7ff6f85773fdbbf16c79ec61d40416ca04a229d141c1fe0acde8f34d8da18cb7380220ee11a206db862ae578dca030adb32590f3edbddde03f3a8fcfb666f94a2ac4b8f40b30c5156aaad0deb8a3fb8bbbeb207b40bc735f35f8b40ec1811ff864606645442aa1a29117f5a65d78e62135b0cc5205da1bfdf30ccf90c806c02971d7e993b3ba5ad0527ca6c870fc1bd5ccbeced24af20371b923940e0cca3c7fbc21b5bead35da51f81b9f7071bcf6c6b076468c1e63ebeaa91dafb1a95303fad00c22f1b58db748af6253649b3674344780099535f1f27012ed9ee86e4949e9dbadda969f79f98cf558511b2e636fb6a11e0a78d7bbb01", + "data": { + "slot": "9108550681083451513", + "index": "9106898202161734681", + "beacon_block_root": "0x70d0737e3a81e04aacd54435b06045e3399b3d4856b8c93d280d9a457cdc7cc9", + "source": { + "epoch": "60567233", + "root": "0xe396507ef9461ce86c67b039a695c0b15ead37b49c6cbe9a3b142ff79b21c909" + }, + "target": { + "epoch": "59412987", + "root": "0xbd545c7eb9af5d5e81e1e1e2ff83971752a739902fdb6c26df11a866e65f5af4" + } + }, + "inclusion_delay": "9103593231433399129", + "proposer_index": "9042451322351315320" + }, + { + "aggregation_bits": "0x4cb430d99baec9e99e29e71320c83b19937fabec0ae36cd5f61793ecbe7197ac414df03bfee922cd87dd8471b60d16b664f29732fb68ed4db4358292585020e5a46eb8692e03f6024a48ba4d45696e6df672024b36b575e84061457ad3842c6904a554b166db40a34a4229dcd0fee2229622b8db3ae03ea565b3f264a80ffde6aa7ee4ccc8bbbfe1a7102fef0f1a88b886f5cd102d60294af4febad5d8eb05c4b3912363430f95ad545b94e031e76940633f8316d7ed3766b847c21283c781a47eaecb7ec58ef5c5b91f46f4cad69b4b7c5eaba4aa6d2b9666af88093d355de7f877d4f05b2bd2311d3b47e8cae498ddfeec2e34ef75a166afa0273de81547d701", + "data": { + "slot": "9044103809862966744", + "index": "9035841389484578808", + "beacon_block_root": "0xf2e25f7d9863dfefb2203a2d8b7f0a8a5e290f16d091466b8fc4fe0994a42741", + "source": { + "epoch": "52295132", + "root": "0xcca06b7d58cc2066c89a6bd6e46de1ef522311f26300f5f634c27779dfe2b82b" + }, + "target": { + "epoch": "51140885", + "root": "0x3e67487d17925c03872cd7dad9a25cbe77350b5ea9b4e95346c90c2bfe27056c" + } + }, + "inclusion_delay": "9032536423051210552", + "proposer_index": "9030883939834526424" + }, + { + "aggregation_bits": "0x9c49fa0c6a293dc8814c7382f8e4d761803988a40dacd49f488e3aa162b0af96bc18db1df0d29b08983251c4261b68bcd134193733dfb5436081cd8e5951ce89e3ba54baf49772b1c83b5d8ee00463a9da16e95ee94a191ff4c83f8d406b12bc149078a0518cdc5a451860e848d1aae4791b97063725e721ce6f92f36649a2c6b9cd78668d5049e147d19b743c77cee9a19b097a1d7010f9e3e2c8a463664c74a61c8587b2ba1c80ff75fd5e7b3aa502f6d61d27dcbc058399c8f683f5fd3c2c2184d8256278bfcdd6c554b8201e6bbe847a65b0086f4801d905f1d912ae4c99dbc758796098123d63783bde54409111561c3e349bbde187e6be339b06d567ce01", + "data": { + "slot": "9025926485889506743", + "index": "9024273998377855319", + "beacon_block_root": "0x612cdb7d782f8e4994a2c19d2f465bb7dbe9231cdb1aee25ce2b759caab21ce0", + "source": { + "epoch": "55565498", + "root": "0x3beae67d3998cfbfaa1cf3468734321dcfe325f86e899cb17329ee0bf5f0adca" + }, + "target": { + "epoch": "55950247", + "root": "0xadb0c37df85d0b5d69ae5e4b7d69adebf4f51f64b43d910e853083bd1436fa0a" + } + }, + "inclusion_delay": "9060628646324775320", + "proposer_index": "9065586100269795000" + }, + { + "aggregation_bits": "0x746e01a43cdc5a972d1e71013b743f8f80783522a443deba20f9e58aafd612c5e389e70dc02f3df8e0c1561bf433c4f39d2e40e3403a65308c11ee1cf14b687efa1715cb34894e2f9d6bd47cdc36bc9c925bebfb7afdb76a9ff942d61ad18941388f86a8591e11863ff06b4f0946fa5ec65001fe6b77c19d937758ce40a3ccad3cd3118a3a9d4e1a8632cda64044099aee688c1e9d5a9398525750806af050793510b24b2c2ef18c6294c70f39590e7edc659ef193f1a866d348e31ae83ed0cb1c48308a53ea7cb06f87d1bc87ac7065bbdec6f58857d3790bf075f5e1bd09f3c8b9d7e3e2a3b1eea040cef02d2c0a4294a684cfe3448923388dbd27105f052501", + "data": { + "slot": "9054018713458038808", + "index": "9058976163108091192", + "beacon_block_root": "0xe613b27dd840a92b497794cdf803eb5207ff1c1ad7970b3d0fb44d16a35820ab", + "source": { + "epoch": "53449379", + "root": "0x59da8e7d9806e5c8080900d2ee3866212c1117861d4c009a21bbe2c7c19d6ceb" + }, + "target": { + "epoch": "53834128", + "root": "0x33989a7d586f263f1e83317b47273d87200b1962b0baae25c6b85b370cdcfdd5" + } + }, + "inclusion_delay": "8989571842237554039", + "proposer_index": "8987919359020869910" + }, + { + "aggregation_bits": "0x16d976e12693b23a08acbde650c069dcb680ff0882b8c4b8ea5936add86a811a77087b940ff0b40df209d4aa1f0ac4c839636547d230e4a03e16bf664e802d13b08210667c368c168f70fe7a09a8dc50471f1ffdd1e23aef8fd209165253b78498fcc7a4f27a92e71cc3ddb5e2a11224a8386e6c188cf83b9b17962d6bdec45d8d60a37c75ef1cdaa9816e953a549c6dbac87c4da6e18e652644db810b7ba541daec633c9a0e9f9b54c43ac24d0c422d3807fbddb83e09b779b7a8910914423d88bd26b76d5d203ddf51201725041860d2b84afc5b43bd75f114a0b87b2266839349170e722326fc4802be617718c52d455221e5eb07220739b9abb8bdc7b2a101", + "data": { + "slot": "8982961905075850230", + "index": "8981309417564198806", + "beacon_block_root": "0x1ca2b57cb6f42abd7ab6ec1784ff5dc51481f29f784ee581bf66a4b9519dedf7", + "source": { + "epoch": "45946775", + "root": "0x8e68927c76ba665a3948581c7a34d9933993ec0bbe02daded16d396b6fe23938" + }, + "target": { + "epoch": "44792528", + "root": "0x68269e7c3623a8d04fc289c5d322b0f92d8deee75171886a766bb2dabb20cb22" + } + }, + "inclusion_delay": "8978004451130830550", + "proposer_index": "8969742035047409910" + }, + { + "aggregation_bits": "0x420dce9e0a1cab3c74167f3abe890baa6d5bd12d574087ee503835b9b010e39173e15c8e95a0be6d3df61218e801d7de601530ab135b9a9dbc35bcc50dee7c4330bb00b77422cd13a6ed9a8bda79d16a2771a52a7013fb54b61358ae8bea82b734ff9c90bf6e1e2528290b73ffa8458077329f45d07c9aa0240715bf9d9d8747c8ab852e84beaa3e12d22cf87783b059a13fc9fc4e0836568954bb6202275528912c57fa66124d4fe8135b26d61d9d6d1402694541e7b60f11318d9595e0cd346e8292063538600bb9e7b1945f5d071a2ab2f659f7a7149b6cd11de98fe5a0f589dc7906cb50e33c10fafdd8330fbe1ea9bf209f237ad1251cce5018c571c3a701", + "data": { + "slot": "8971394518264094038", + "index": "9016011582294434679", + "beacon_block_root": "0xd76f197d17ef562a3144113676e90027a94d03ee5cfa2f25b5d2286dd12ec0c1", + "source": { + "epoch": "49986639", + "root": "0xb12d257dd75798a046be42dfcfd7d78c9d4705caef68deb059d0a1dc1c6d51ac" + }, + "target": { + "epoch": "48832392", + "root": "0x23f4017d971dd43d0650aee3c50c535bc259ff35351dd30d6cd7368e3ab29dec" + } + }, + "inclusion_delay": "9012706615861066423", + "proposer_index": "9011054128349414999" + }, + { + "aggregation_bits": "0x6c2a0059b9c0a3357a11b4d5596d65dac781814e6008761b5ba6205bc985076bbf8c50e238342f85ce37c4c619f42d0cceca42d7619b74dea733d4288d916592e7ef3dc466c5452e3072b0c34aef2ec1213274ab36af78e5792a48abeb2a002276543591fc3faea22933df24bf1d0d5aa6eee72788250d26c9877cadbc72e5da1845363285d6e82d0b00ca9e603e10c41a5d3daeb2de677555bf11398be2e0fd5177f7a3b55ecbb37cef682c32732703c6fda47a785f16041ee8cb343e6cd242faeb9c9afd19fc2c8e5daa546a9c332f7ef10ec538cb45ccdc539cccf2b9aaf8a3c78f4caa59cc0b7139b7e9d7345cf1ab7cc3944b32ae40b8f0749263a9627301", + "data": { + "slot": "9006096678699362615", + "index": "9004444195482678487", + "beacon_block_root": "0xa9dbd87cf72eef1fba2481138ecae2f6ee6ef833329af024ac5f0f083358a1b7", + "source": { + "epoch": "47101022", + "root": "0x8399e47cb7973096d09eb2bce7b8b95ce268fa0fc5089fb0505d88777e9632a2" + }, + "target": { + "epoch": "47485771", + "root": "0x5982057c75d155cf378f062e5108c6cdcfdbd4bbd6d3ac521c8a8d31e8f66a39" + } + }, + "inclusion_delay": "8935039870317174037", + "proposer_index": "8939997324262193717" + }, + { + "aggregation_bits": "0x0682ef02c167e3bf500533a276c36120817844b632e61bc584993d15dbd87c801a3d67567315c7c4df0b80f525722610d8b6f388c7fe7b317bdcc5e358699cb3d3f730d0382c054eefb8864404cfa18d8eb09cc7bb300eaba1d0527ead9ebe8003417be0c3c13690bcf5f09d4fb62c00e0645b4e2495e6afda63d425ee9cd5d09d6f022338245aace594becd228e8600f1a5d05077683136454e2a84b77bc3bce2f14b7ff784d3f3a93f3cf72c3f5bb0c2f5ecdb7882123ccaf48d891f3ff49d247fd466d7150abd08d4d06f9fbf70bc5cafd374cec78f79d1e4ecd54245d203fc6565f45f029e2abadf4aceb2db32b0812180231a714b103a390a6d0c31a4af01", + "data": { + "slot": "8928429933155470229", + "index": "8933387387100489909", + "beacon_block_root": "0x92e5f37b55b4f39d16583cb0cca20335e2e4d171f92d2781a50d588a781991d9", + "source": { + "epoch": "38828921", + "root": "0x05acd07b157a2f3bd6e9a7b4c2d77e0307f7cbdd3fe21bdeb814ed3b965edd19" + }, + "target": { + "epoch": "39213669", + "root": "0xde69dc7bd5e270b1eb63d95d1ac65569fbf0cdb9d350ca695c1266abe19c6e04" + } + }, + "inclusion_delay": "8916862546343714037", + "proposer_index": "8915210063127029909" + }, + { + "aggregation_bits": "0x4acd06a4062100e772c8b46fc8d05dd942eb6581aa1b24ef29677278d64ed597c7e4eb616d1580254302956541bb2c84a501429d3139137a3b3481b933bc5aa5057b749d27b4c5e70394ce3ed602d24fa4d6babe5c4636baf0f11e414a413a4b78a62fe9ad65d5292e2af7924d93f8b61bfc783892f8db3bd9655bdd4ac8ae1ccebfd01301fb28118e9a0bfe567ea11ff10a5420c98cd0af1fe2e4b2f5e5959efd5336018fd8cfd1bf6cd5453e5c9c518b9e72ceac95886bc2d5b4165eb74b2490d13fd3bccaa49f3ead497e883d2450feaca4f1453b9e3ecb70f454e1f5a338c2a229f3c27a16e965e1e5d4c7dbec8c9e65e94642f8535876831b0992ab94d901", + "data": { + "slot": "8963132093590738806", + "index": "8961479610374054678", + "beacon_block_root": "0x012f6f7c3680a2f7f9d9c320706954625fa5e67704b7ce3be474ce1c8e278678", + "source": { + "epoch": "43638282", + "root": "0x74f54b7cf645de94b86b2f25659ecf3084b7e0e34a6bc398f67b63ceac6cd2b8" + }, + "target": { + "epoch": "42484035", + "root": "0x4db3577cb6ae1f0bcee560cebe8ca69678b1e2bfddd971249b79dc3df7aa63a3" + } + }, + "inclusion_delay": "8958174643940686422", + "proposer_index": "8949912223562298486" + }, + { + "aggregation_bits": "0x88ee5d2a77d173589f88b8731650b01973e6d385b2e72fe263e422632f684b192c6d54b3fd002dc123b18052f39b925fff0b8a5a8b8c9bcc57a1a50d191a775a12dfaac5a7cafe4c5c804fe75212954ad4d578dffb17d1c69b51e6fef3ab00346630cdfb6ee53af570d29d7d3c64a28eb8b1e7516bfaf085aacfc0f12f4ac4934b67ad87ae340f4b1e797f38a96efefc1e58ed28e9a479d68e2f7edffef3f9a1645e085d735a325c6b8ddc9a7d2e0f7da165f8c8b580278810bda78a72652917e6fd5d79ba1825626c7b4c7b883a198bc0791da44307114e1b84f0f80a520638d1dcc7491ac9ab73921b34ab76e36f6b1dd251547a3125e8c9ba35318025981201", + "data": { + "slot": "8951564711073949910", + "index": "8943302286400594677", + "beacon_block_root": "0x1f1f177c95eeb70057c6d0abd66d8866bcd2d705b37932249206c3d859d44499", + "source": { + "epoch": "41522163", + "root": "0xf9dc227c5557f9766d4002552f5c5fccb0ccd9e146e8e0af37043c48a512d683" + }, + "target": { + "epoch": "83459793", + "root": "0xb6b222811ef1d2d0983b135ff8d7e2285e39b18efffc25293d03c0beae98ad63" + } + }, + "inclusion_delay": "9310153723713228350", + "proposer_index": "9308501240496544222" + }, + { + "aggregation_bits": "0xd30d67ca5d1d2c37a0d4901e237c5d202e55152ba0a596c1d8e93f60de39ab293b35336d7d16082eb3a2ca6f0fe06cf93f2d854198722395fc7b0f45088209ec9a501ee8683a6e28e9c3a0b4b967ff131affb2a2db150e1c3e5e8f4e767ec467a7661f181d196620e8202b86e16bc6abe550f7c5496afa01feb9e6f4a2588a979402a2e17f66e4a580ca2cd7ed2d47403839814c6366deeb520a14f47bbdfbec8d9eda003c0509924378960510ef6c123121d5ed27fc87a1e980cd57efc1e78d2f7d441d4ed7560ed5e1791e581a8041a04a35dcd98ed28dec33d610426f5f5a0384e962b01d2e2b22aec4774e916c01ba3d45ec48b83a19a05c3eaf6a595cac01", + "data": { + "slot": "9303543790846491838", + "index": "9301891307629807710", + "beacon_block_root": "0x3b9af9807e02eeb24d10e68ec19572c4894eaa8cfc7943407e8b9838a73eb12e", + "source": { + "epoch": "81728423", + "root": "0x155805813e6b2f29628a17381a84492a7d48ac688fe8f1cb228911a8f27c4219" + }, + "target": { + "epoch": "82113172", + "root": "0x881ee280fe306bc6221c833c10b9c4f8a25aa6d4d59ce6283590a65910c28e59" + } + }, + "inclusion_delay": "9285366466873031838", + "proposer_index": "9290323916523084222" + }, + { + "aggregation_bits": "0x392f1e720cc96b40858b8f5f422db5dfae102dae7c5adccc88a20c4f515d16f6e294a72f1509aa4c65119fb3b7c856f25c6582bd7af7dbc30aef1ff2e21c65cf87f4cbb166057587aed799475553393626a9b0074c6a6bf1517ac111985dd399aeb86d1b4789a1fdb6e81079a078de95dc15c9b43a53d0ba8e932de987eec47b15dcc257d9baf7fe10095a14873f084377fa1530e64e3d82f9479a8862bbd78136b3c410f445fc8fde1998cf53af1cbc93b85f7938e9b942a36b1c8ad2100eea182124b3ff43f65326a6757b7b008a83949e00ab5bb64dbd18d742bfb15e18c812d216c23037a4f86090332b1da8ff4051869f5e347794c80e64a0133897be4201", + "data": { + "slot": "9331636014120056607", + "index": "9336593468065076287", + "beacon_block_root": "0x5e5f8c81df9f1ff95a86d051163971bded02c34a2de0471205ee00aa53c9c8a2", + "source": { + "epoch": "85768286", + "root": "0xd02569819f655b9619183c560c6eec8b1315bdb673943c6f18f5955b720e15e3" + }, + "target": { + "epoch": "86153035", + "root": "0xaae374815fce9c0c2f926dff655cc3f1060fbf920703ebfabcf20ecbbd4ca6cd" + } + }, + "inclusion_delay": "9320068631603267711", + "proposer_index": "9318416144091616287" + }, + { + "aggregation_bits": "0xf56dc5b4f3893a5d647b89ccc76f8b75cdda01d820a7e27f031ea13eff99bcc1554f0d9ae521610848189b80c80ddd2e3b13f7ca8fd0818d98457dca0961838d5198e9ed6bdfb52a1af3c32fd7beb99448895cb4bb50c34800ee192eef423a81c01ae912a92e424716c71763d21d4c252ca41e6a8f31e8060cf4a92063cf9d4572083df7ad6fa1435ba26c03f0178e1ce75299004fa8bc0b8de6493d0e31d3962929910b829de92f226af775434fcb2f8b81c361eaffb2009153e419909b400ef0bfcb1a264e6bd29013ccb10a04ff72afddfd78d46e4c88c35bc2a2137c89676b1146f8ad1ff953b2c63f562838736e3cc077bb58fce1cab2dc0d77f64c625501", + "data": { + "slot": "9313458694441563902", + "index": "9311806206929912478", + "beacon_block_root": "0x30cb4b81bfdfb7eee466402f2e1a538d3224b89003800812fd7ae744b5f2a998", + "source": { + "epoch": "84421665", + "root": "0x06b46c807d19dd274a5794a098695ffe1f97923c144b16b4c8a7ecfe2053e22f" + }, + "target": { + "epoch": "77111436", + "root": "0xdf7178803d821e9e60d1c549f157366413919418a7b9c43f6ca5656e6b91731a" + } + }, + "inclusion_delay": "9255621756087815645", + "proposer_index": "9247359335709427709" + }, + { + "aggregation_bits": "0x4f489d1dbb2949dbfd6781246dd08affc33341a8ba494f58c8637fd144b02532f2f67bae7f2039d91c8587b9e081c39a00ce22d338f56e43068b64245c393be92d600ae9a5a4f50a8539f4b0cd9e66d8e7b8bed646893c8cf82de170315584efa248f12ba7d3f27fb11970754297294fab2f67a78ba087473b51619c74e13f9fe324d9f314991542b4a49f58b03939383daa72e79c1c0a48b0077a3e3aecf270aa8b26f10a63b05dd61e29f61d6266bc19cf41cdeaa7bc29665e626966cc2794326397fb10832be494e6d60facf1ade6a4e22499f647ce2febf9322d3f0ab79e51bf99d708ecffae5120c23501c75f3c2c9f9b0ce49fae9a42055d8ab95718cf01", + "data": { + "slot": "9249011818926111837", + "index": "9240749398547723901", + "beacon_block_root": "0xb2dd37801dc2b693e9b135270939183458b2895e7d59853f64324c09cdba5410", + "source": { + "epoch": "76149564", + "root": "0x8b9b4380dd2af809ff2b67d06227ef994bac8b3a11c833cb0830c57818f9e5fa" + }, + "target": { + "epoch": "74995317", + "root": "0xfe6120809df033a7bebdd2d4575c6a6871be85a6577c28281b375a2a373e323b" + } + }, + "inclusion_delay": "9237444432114355645", + "proposer_index": "9235791948897671517" + }, + { + "aggregation_bits": "0x3960d50a28f5d2525b6c474b003d6793e9fbd550ed217e5dd7ec099e731703d85cd51080a590f8c39aed106b087f2508c11174c95e05e2461b4e26e45cd26abdb33cf7967d525d1703aad97a410bb173a9c8ac574031a697371cd17e5c364ab8ecf15e27a08842c0e13bc594362361a5b2bf8f0dd3c0120470f149a0501fcd411688efad14fa45c10c72fe3d977c1c6301cda48c4dca996b46fdd1e8932d45664ad415ed5c717293cdaebdec9acc1442814247f4571f173268dae44898534197ec82c968d1d623fc01fd07ab94f288d01a81d9a3c1acd77357060f82d3c8f9b1428c5c3879cce01f30ef0844edec68e31a5c1c0f98d5d6bff631ab8a4f0f5b1801", + "data": { + "slot": "9283713983656347710", + "index": "9282061496144696286", + "beacon_block_root": "0x2027b380fe8d65edcc33bd97adff6861d4729e6488e22cfaa399c29be3c849af", + "source": { + "epoch": "79419930", + "root": "0xfae4be80bef6a663e1adee4005ee3fc7c86ca0401b51db8547973b0b2e07db99" + }, + "target": { + "epoch": "79804678", + "root": "0x6dab9b807dbce200a03f5a45fb22bb95ed7e9aac6105d0e25a9ed0bc4d4c27da" + } + }, + "inclusion_delay": "9265536659682887709", + "proposer_index": "9270494113627907389" + }, + { + "aggregation_bits": "0x7db27c151ddbecf155f40702e46d84404238fd6618f97dbb6fd50a994d7b027b507850d80dc4b6f147dcc7d5f2713b9edb27352e80affe7b5b0f012a1f903a6953058e4ba9065c1a3014a3a1aec8b64b89a45784c9c6f70e6f959c9ed0011b4e0ee627338004eea2d4b13bf69f2e941364fdfe60c82fb2bfc782ca60e6580848550565bda1bd67b59e07bc5bf9273c33843b164d8e27a75892ebf13b3b77af4c2b02b939255384497113f180309d929286d5dd5fee83312b899940cf043645be410944c31d866340737a11fa27a91670e9aa4d88c06c368404ab96532316f7474179bdc6e5269729e81b4b9f246fc4f542b13cd5f08eccddd04de0ac67fb1c1801", + "data": { + "slot": "9258926722521183901", + "index": "9263884172171236285", + "beacon_block_root": "0xa60e8a805d9f80cf800890c776bdf8fc00889762845f4a11e3219b15dc6e4d7a", + "source": { + "epoch": "71147828", + "root": "0x7cf7aa7f1cd9a508e7f8e338e00c056eeefa710e952a58b3ae4ea0cf46cf8511" + }, + "target": { + "epoch": "71532577", + "root": "0x56b5b67fdc41e77efc7215e239fbdbd3e1f473ea2999063f534c193f920d17fc" + } + }, + "inclusion_delay": "9194479847005731836", + "proposer_index": "9192827363789047708" + }, + { + "aggregation_bits": "0x06c71f73161431d86b644b791b4ad670ccc1314e372b7689a12edb91e2e7f1a4c5f3ce4182396f1363db144c59063f451d4a56871b85afafa7da7054e0e917807808abef3f3adf4b202d3615dd7654e55cb5e3006ad843a102978f8ef4442dc2ee91481ebbf23941ee5aad9156a89cfba3b5116bc9f34fb9c5e105d1adb546c9eeb92eac2b8c85fd38b49f40b17da9fe4a9fca1eb79e2faf86f63b2acdbe12a6cce260164b33aad2a361068454894f010a55394487cd000e99cfafc6ecabacc1c6a07fe2921dbfdcb3ada4c21193eeaf02e8f7b1a65f6088784b5919f19fb4f31be9fbeb09fe387b24759b38f74b0a9db64512df999d8cc2d861563faaa16ddb01", + "data": { + "slot": "9187869914138995323", + "index": "9186217430922311195", + "beacon_block_root": "0xdb9c8d7f3b530261b147e81102b96b6f0d0a6de82516245693d4f1b88ab31ac7", + "source": { + "epoch": "69801207", + "root": "0x4e636a7ffb183efe70d95316f8ede63d321c67546bca18b3a6db866aa8f86607" + }, + "target": { + "epoch": "68646960", + "root": "0x2821767fbb817f74865385bf51dcbda326166930ff38c73e4ad9ffd9f436f8f1" + } + }, + "inclusion_delay": "9182912460193975643", + "proposer_index": "9227529528519283580" + }, + { + "aggregation_bits": "0xe3a545f845c4d2af06344a6d2c033acc1db9cacb5fee1daceb0903ae0bc84deaab62d4532486eb753e2041fbca24834a7e501c56b80127b8c3c255c74c6968f629b5e897b420c2f56ff96dde57b40a70d5ac2133db0974126587772953b55e2cd097a8063270929fd082820e955b4e81a7f81512bc9a6d229bd9f6aac90e044123a9d6821c51b60f585749926e6c76150d6c562a23bedcc0245df607d63c5cfa7fe67f5289174b5e7ce01e5e13eb242de4a0b3180ec0b5fe03a6fd52f95bd39cec381b041fa77ea04b7b28e76234e1f23e794ae6a4c58bf082d4edb68099157902b76a49cb1db76273416f0446335bd8c1ffe9ccad580a171749d801bdab033901", + "data": { + "slot": "9229182011735967708", + "index": "9220919591357579772", + "beacon_block_root": "0x976af17f9c4d2ece68d50c30f4a20ed1a3d67d3609c26ef98940766c0a45ed90", + "source": { + "epoch": "73841070", + "root": "0x7128fd7f5cb66f447e4f3ed94d91e53696d07f129d301d852e3eefdb55837e7b" + }, + "target": { + "epoch": "72686824", + "root": "0xe3eed97f1c7cabe13de1a9dd43c66005bce2797ee3e411e24045848d73c8cabb" + } + }, + "inclusion_delay": "9217614624924211516", + "proposer_index": "9215962141707527388" + }, + { + "aggregation_bits": "0xf67c3defd9c717932353de66927dd3140ac32dcad082d42754988f496b2156dd4c39fff3fcfdc4b3742e46a4577eec40ce72531ab0067f90536e389a01cc3f5b2e61a64737d0644ebf0fe10cfe1166742889a316349128a1c16ece63153880f7c0bc960e352504e4d2f19f110d5426071ae1f8fb087c3084bb4cc421658b203271999ac2d0bcd00e1675af43fa43607192068f6021a240f7345bf0ea09e55f9b4b69e87374222a731fa657e252f6382f954d86e607819f4f533ab84fce654a8eb7af481a805982b820a16b03dbcb1500a72c97f890e59876564a15e66d0604037b27e7cde1b793ce1d2a1231d4635b44614ff1cc51e9e6c45a44a82d726b682301", + "data": { + "slot": "9211004687762507708", + "index": "9209352204545823580", + "beacon_block_root": "0xccf8f47e7a01b05f9914657a809e8143af5853bcaa78483e39f3cc0fb889badd", + "source": { + "epoch": "64799471", + "root": "0xa6b6007f3b6af1d5af8e9623d98c58a9a35255983de7f6c9def0457f03c84bc8" + }, + "target": { + "epoch": "65184220", + "root": "0x187ddd7efa2f2d736e200228cfc1d377c8644f04849beb26f0f7da30220d9808" + } + }, + "inclusion_delay": "9139947879380319130", + "proposer_index": "9144905329030371514" + }, + { + "aggregation_bits": "0x0e5c4393e160579d3caf851371cad6cd52adc7f01475a942c7e544257141df3ce4c5dbc3beccdc700442021dfbdae1b6f49c27c10e67f0fee9a008555e1688235eaecfbdfdab666b29c5f69a3411ba35b33860708d9e57f649b4e732cb0bfe05f1ec963f1810c4d4672cb0e4d95f268dc7eba073c9c1dd2db4c54e1d286712a4fcb43e4e2c4f62029ca15f18f9ec9f9989f3c68b664532fc61faa96f747e7d0f7ceb686d3ef9f67f7a2e807134bb1292b00d171245fbb9f784452a78f4276a357b0188aba745d54c052234bd5d22c6918c984a4b38c1588450fbc5f1417404fb755509f1504711b5f6a8ef20fb9af50d1626613d294b2584da95faf20d733aaf01", + "data": { + "slot": "9133337942218615322", + "index": "9138295396163635002", + "beacon_block_root": "0x52e0cb7eda12cb414ee937aa4a5c11dfdb6d4cbaa7f565557a7ba589b12fbea8", + "source": { + "epoch": "62683352", + "root": "0xc4a6a87e9ad806df0d7ba3ae40918cad01804626eda95ab28c823a3bcf740ae9" + }, + "target": { + "epoch": "63068101", + "root": "0x9e64b47e5a41485523f5d457987f6313f47948028018093e3180b3aa1ab39bd3" + } + }, + "inclusion_delay": "9174650039815587707", + "proposer_index": "9172997560893870875" + }, + { + "aggregation_bits": "0xeee4891241f9e91d8ab2b42c7a1b6cc99a8b9a33db4fbd15f253c36f6dc95949d73753bddc8ef9d455dcc40a6bdf7294a31d2e629aebde7e41c36de530d32c99dc7dc099ee74e872e8500979177d180d66c172e76445a939eb7170da96084109144e093b175149d106003ae38728b284fd5622a336410f9c4329c21a76cc07174d3553f8953005b5d40d1cc66d0463159979f615003a786f9acd7f95672fb82e1799baa96a56d1c9219e817cdfae2f3cee38a89962269395474784f93320128f1e9ab28f9d7dfe3c653d5a2ddf14e492f8699a9692dd69c6d466040f27883e744b49e8b2c227fb9f222c5683f027046a7024cb11611a60f4070973a5cc75757f01", + "data": { + "slot": "9168040106948851195", + "index": "9166387623732167067", + "beacon_block_root": "0xc129477fbbde799b306bbf1aee22620c582e61c0b17e0d10b8e21b1cc73db347", + "source": { + "epoch": "67492714", + "root": "0x33f0237f7ba4b538effc2a1fe357ddda7d405b2cf732026dcbe9b0cde582ff87" + }, + "target": { + "epoch": "66338467", + "root": "0x0dae2f7f3b0df7ae05775cc83c46b440713a5d088ba1b0f870e7293d30c19072" + } + }, + "inclusion_delay": "9163082653003831515", + "proposer_index": "9154820236920410875" + }, + { + "aggregation_bits": "0xa220299d55d6717efe0296c4815206dfe1a0384387651dd24912ef7a918858c49bdff1303481fedd9aec02b015d77140bb3bfb8dc2c5c00282bc4b3917653d409d4434ccee2cfb79d7d56589c8ac1d3fd74abe7accb8b8a61334211252bb90f3d09140a6efa5d49799caec01aa2ded23069c0acccea60e0784bc134eec9b04364a6ca1fe7a5727e44f4c1eec06574745b68ed7c74aea425c0ed7dc24ddf44f17785d016f104c479c964ae3157dbbb0c1e3bd3252c2d83c87ba4401578f549a87b815037cc732fe420bc48c260f057fa2112406f9f72de4b1919bf87e14efe842595cef68594486bcee801135b6f4c8fadacce3ed296b7a76a0b4c0a691e7244e01", + "data": { + "slot": "9156472720137095003", + "index": "7826223142295852378", + "beacon_block_root": "0x8f75966cfaa05bdee8957d48abbcc1f03dcf3b8b347be4b76f2304ab019580e5", + "source": { + "epoch": "911477035", + "root": "0x6933a26cba099d54fd0faff104ab985630c93d67c7e9924313217d1a4cd311d0" + }, + "target": { + "epoch": "910322788", + "root": "0xdbf97e6c7acfd8f1bda11af6f9df132556db37d30d9e87a0262812cc6b185e10" + } + }, + "inclusion_delay": "7822918175862484122", + "proposer_index": "7821265692645799994" + }, + { + "aggregation_bits": "0x64df6310c132f4237053db213837e388510bbf5b0b3fb7aefe6b1732f26b3011739dec93c12d831474c5ecb3b5fa8d932eef89cd244046a5b29fe0cf5d5c62b9d236ec08f28f244224798f1ee04cbe7bb031bb97921133b5051fd02334048aeea8d2d23916eb4ad275cee5537d4ec37591a45b163c0cf5284532cbe30ba327ef1cb1fd9f5c04c9d8bd89be436124a13aeada367e43911f39351f8cc1418eed9877e3ea827a59d371a835575eb73a8b7a4b1f48ff9e25b93e59ef3a4c0796711e87f3e74505c5cbb00a3dc6f58ce6059eb38d6042374ace438d4d630679530b109f050fc3901e117b96840b2e33c214f3d1c5f7dc9ae305c207f364f669821de301", + "data": { + "slot": "7816308242995747610", + "index": "7814655759779063482", + "beacon_block_root": "0x61e1556cd9e0f3d37176ed25c39da3c082f030d1091ba5b766b0ea4563be61db", + "source": { + "epoch": "908591418", + "root": "0x3b9f616c9949354a87f01ecf1c8c7a2675ea32ad9d8953430bae63b5affcf2c5" + }, + "target": { + "epoch": "908976167", + "root": "0x4a43fa6c5b9b874b9f23a2669da66452d39b4cd918272f5b648f885e812653af" + } + }, + "inclusion_delay": "7851010399136048891", + "proposer_index": "7855967853081068571" + }, + { + "aggregation_bits": "0x88f899b1b3c3135c9c91da150d26991113b20dde86f2bca53448c48b7a1dccde8d4492c1e72603763a24e9b40658760c7df54f8827adced3de0356f17fd80b56cebabc70aec93bad2b6987ecef3c7466fc24e9ac0462d4dc6e3c289ceff5b1108644601199fba12b2b12e2e8aa999b4b92a1476f4d869ed1330a20d8770ddf0c5d2b9139ea59db832d6e68819cbcb7f9a11aa74a43a06446ac424ce152189197ccded56fa0792e30a7d74784a0581c9666c8e22b8301b685830ea9c03a559e3f34ab064a88074ab5b8eb46f02356b234c59add13b7fe75735ff9f7ab8ac2cc73cc54c2690ae59ec843bcda1d88f6cd32f6df0d6d703a7156f688ca4a1b083f9d01", + "data": { + "slot": "7844400466269312378", + "index": "7849357920214332058", + "beacon_block_root": "0x84a6e86c3a7e251a7eecd7e81841a2b9e5a4498f3b81a989ee1253b71049794f", + "source": { + "epoch": "912631281", + "root": "0xf66cc56cfa4361b73e7e43ed0e761d880bb743fb81359ee6001ae8682e8ec58f" + }, + "target": { + "epoch": "913016030", + "root": "0xd02ad16cbaaca22d53f874966764f4edfeb045d714a44c72a51761d879cc567a" + } + }, + "inclusion_delay": "7832833079457556186", + "proposer_index": "7831180596240872058" + }, + { + "aggregation_bits": "0xc0bb40f67d94f0c6beef7cf3e8b42f9bf32799e2886fb217903845e4542bfbc95e8f0e515b006a77276fec844b932dcc8962f39fd4ca8618ccbbd089ddefc95a105e96fdb151fb54df45dc85bc5122adf2655197b255d8a59f997483abfe311ebda22411d3df42df2ba8e9b64ebc40937af5a7b9f9614346b559a4b4d776b4a83aef529ded0c8c7e5660bbf2aa5d49b2bbb53e32f753d549fb02dd1c9802b784f3dca802d4ed2bd0c5472b16b0bbcd1439af6c37fa37ac9fab6e387d5cad80d9c92769faa9daf8618ed35b6e54c22cc9ba01aa94782af8544c357fb26d40d5e4969ea27f951dc6038ceaf60dfde21d2c4f39e54838b17bb809935b6eddd761d201", + "data": { + "slot": "7773343657887123801", + "index": "7771691174670439673", + "beacon_block_root": "0xb934ec6b1932a7abaf2b3033a43c152cf2261f15dc3783ce9ec5a95abe8d469c", + "source": { + "epoch": "905128678", + "root": "0x2cfbc86bd8f7e2486fbd9b379a7190fa1839198122ec772bb1cc3e0cdcd292dc" + }, + "target": { + "epoch": "903974431", + "root": "0x05b9d46b996024bf8437cde0f35f67600b331b5db55a26b755cab77b281124c7" + } + }, + "inclusion_delay": "7768386203942104120", + "proposer_index": "7760123787858683480" + }, + { + "aggregation_bits": "0xfe5b5d808d2bb1d6a509d60f0a9b0e59bd60e99044f156d1022d16806a403e22dc4f6144a01380f2c301a2a77d31205b153a275466ed297f4245906089b57160643fbf1b7b3bbaf1008fe99ff351adb04456a7630d88a3a247043f597dc68e788cb42a28be79daec3c790660da376419af6ac514fb5588acb6dabc88a03254eea3d3849955ef3a0fada6896cbbf89e06e945e4d830a75282e22da623a5ddb48441f200dc8f67eab73955ffad9ef6a5a56dff3cc97a5683fe571316ba4f8f23420fc3254ecad61e9623fba791f123ef79f5e5732cd026326018918f39e19ee77589796d5422f644bc4d0f896c900da36c43c717bd22789cf8b94b0d91b8ce718801", + "data": { + "slot": "7761776271075367608", + "index": "7753513850696979672", + "beacon_block_root": "0xd724946b78a0bcb40e183dbe0b414930505410a38bfae6b64c579e168a3a05bd", + "source": { + "epoch": "903012559", + "root": "0xb1e29f6b3809fe2a23926e67632f2096434e127f1e699542f1541786d57896a7" + }, + "target": { + "epoch": "908014295", + "root": "0xc186386cf95a502c3bc5f1fee5490ac2a1ff2bab9906715a4b363c2fa7a2f690" + } + }, + "inclusion_delay": "7803088368672339993", + "proposer_index": "7801435881160688569" + }, + { + "aggregation_bits": "0x9c36b559beff685f831610647b5ef33917015d72c29b0430cd0759db5c4688c823e0756b1d3e019c87e87c6dafcfc4462061313c0501873e5202e81f096a3da2f222847ee5dd33fbce03c3522ae5761b4325b07a591459f398f766755e40083d420fd3042c786866bc545401aa82655bceaf6196a71c1f4fcb7c44b4a4f626d27f3db6c75d046898b1723ccd9d56efbd912e42f2ec23c96122628d3da70e6110a0a99ab15929206c32e948a6ea371f4b6f50f8a26bc208e5d08f100bf002bf14d0a8eb984a4c8ac5dfa13811c46477b709340f6327c847bc886abe9604d4b57eef09989d43dfdb0d3ec5811d743799836524c43652acfb8d4cf980d348e45acf01", + "data": { + "slot": "7796478435805603481", + "index": "7794825948293952057", + "beacon_block_root": "0x466e0f6c596c6b0ef099c42eae079a5dcd1425a995838e718bbe14a9a048fa5b", + "source": { + "epoch": "906282924", + "root": "0x202c1b6c19d5ac840614f6d707f670c3c00e278529f23cfd30bc8d18eb868b46" + }, + "target": { + "epoch": "906667673", + "root": "0x93f2f76bd99ae821c5a561dcfd2aec91e62021f16fa6315a42c322ca09ccd786" + } + }, + "inclusion_delay": "7778301111832143481", + "proposer_index": "7783258561482195865" + }, + { + "aggregation_bits": "0x6616ff0e625ea85583de9980d9b1e6b4590535500034c8d416580c3442070939059150ca602f791f137e34589fe3b8c7b80acc73bb64c0306cc8f9d6dc328bd886dbad7a3f2451de33fb55d060e42b53d91fde88c6cb264c404dbf3888f3fe533b5fd3bd8b43a8d50d8539be7b3bc5d908b0117e0facf1e6c09f1859997204c8769316e345f2de1da8e00f525fdf185213dc9954a9c277623b12b6b59b93427c2b2f056b3ad375036e5dde7d6c3a68d67f1c38072bf22ecd8692c627ef44948d023da3243d645ab0b81467e321cc9626b2f896d7c1e4895b85cc4e1a28aa95aff86ae3f7f6041d7855227e7a5298b5c027497b87aa47bc4f7d30d20ca7ed5e9101", + "data": { + "slot": "7718811685966743799", + "index": "7723769139911763479", + "beacon_block_root": "0x2f782a6bb7f16f8c4ccd7fcbecdfba9bc08afee65d17c5cd846c5d2be509ea7d", + "source": { + "epoch": "898010823", + "root": "0xa23e076b77b7ab290b5febcfe214366ae69cf852a3cbb92a9773f2dc034f36be" + }, + "target": { + "epoch": "898395572", + "root": "0x7cfc126b3720ed9f21d91c793a030dd0d996fa2e363a68b63b716b4c4e8dc7a8" + } + }, + "inclusion_delay": "7707244299154987607", + "proposer_index": "7705591815938303479" + }, + { + "aggregation_bits": "0xa2111e28883d498ce38d3e525c21591efa13bd7c0c8af6e6b8245bd04c110a0eba0afeaa501bd2393cfd20d8d492f7234cfa43624623f89b7e32af8eb765659599f79f0624ecb065e7878daae6081f9de5bdbee331dd3c0db9fa63a7fc6b165f46cd813561506b61ebfd3a05486c980ef9c4f3a8ba8544327a1c80c171486db4804d40e3d0afa8a425c6cd91aa16de58ba702d741721feffe9976147f48f5473249c5d064e0f702d4e6cd1cfe7598d596737a6d695c40d9b32b27e9c84fc22723bb6ccb3050dde624ca1db7904406cd811e3bb144a3890429f61c4088e8a6cb886283f682bbc016b9954f223621a2dde58bd10e4c28cb78d23ca6d64b93a2cc601", + "data": { + "slot": "7700634366288251095", + "index": "7698981883071566967", + "beacon_block_root": "0x01e4e96a97310882d6adefa804c19c6b05acf32c33b785cd7cf943c64733cb73", + "source": { + "epoch": "896664202", + "root": "0x1188826b58835a83eee0724086db8697635d0d59ae5461e5d6da686f195d2b5d" + }, + "target": { + "epoch": "901665938", + "root": "0xeb458e6b18ec9bf9035ba4e9dec95dfd56570f3541c30f717ad8e1de649bbc47" + } + }, + "inclusion_delay": "7748556401046927288", + "proposer_index": "7740293976373572056" + }, + { + "aggregation_bits": "0x4472c528dec82eb14ec711522120b6e2e26a40fb9074fdc5580b0b6af66f96d5e28b7a28d820515b695435b764ba699a1bec84a1a79670ac84e4d9d49dc50e2b40139e7724ca8ceee8d316731b18dd98bb623c0c860cdb78d2cc091817cb10a2de1327072ec2ac3cc14335da09fb4237d0c7fdc1585762c930107bae5ea713b2021789ed7ef39b33e1258be2a1a6d12b91a3901097293582765ae2be651f3a4c8591665b9ec2cda0938feeb5e52a26a50d9c9c10deb03b69e8d36b05b067c54bc4bf31b915b77d57f4efdb7c2feaff512f741e634c003b2e4d9c52a67dbd49b8ddb09ee2fb0788104d6e855f1368ae9bbaa7cf77aa17c01dae21eb589b3002aa01", + "data": { + "slot": "7741946463885223480", + "index": "7733684043506835544", + "beacon_block_root": "0xbdb14d6bf82b34ef8d3b14c7f6aa3fcd9b78047b1763d0707265c879c6c49d3d", + "source": { + "epoch": "900704065", + "root": "0x966f596bb8947565a2b545704f9916338e720657aad17efc166341e912032f28" + }, + "target": { + "epoch": "899549819", + "root": "0x0936366b775ab1026247b17445ce9101b48400c3f0857359296ad69a30487b68" + } + }, + "inclusion_delay": "7730379077073467288", + "proposer_index": "7728726593856783159" + }, + { + "aggregation_bits": "0xeeddffb64642d117de5910d5bfe3a1b4163621d0ac7fe2cdfd0665703459fd97d3d4f720a0a52bc8aca6b3093645062de5fa8043a8df89d4efe9e1a8c0ee8fe9eb970d6de33057ba97d0112d78af3b7e58f8c71ccb14e967ae9ee9d54d1ee57e7d8542803e6242dc5b0de7d1e56f77cd403e37a7e47c30ed6a79609b5e893c9f3709e34be8c76c2e30544f277dbd480744e9187f2441589f3dfafd236880c6e947414124c1826a9519c1f19f6d510ba96d40228ec48090adeb335a8c273713d1e6b22dd5f6b4be4cfddf9932f4de977f64dc5f6f51600938167ea52f67ae2e62f555a308ff7c5b21656f45bb8a8ea03539b1b052a6219efc472ddba9500babed01", + "data": { + "slot": "7670889651208067606", + "index": "7669237167991383478", + "beacon_block_root": "0xf23f516ad6dfb580be7a6c1182a6b23fa7fad900b819aab522181f1d75096b8a", + "source": { + "epoch": "891662466", + "root": "0xccfd5c6a9648f7f6d3f49dbadb9489a59bf4dbdc4b885841c615988cc047fc74" + }, + "target": { + "epoch": "892047215", + "root": "0x3ec4396a560e3394938609bfd1c90474c006d648913c4d9ed91c2d3ede8c48b5" + } + }, + "inclusion_delay": "7652712327234607606", + "proposer_index": "7657669781179627286" + }, + { + "aggregation_bits": "0xba0b876b776c4f90e701c03d5ac1582bcd6d4fc07cd5018bf4676873dc61d4949b3df33828ea654a731724d34a4a51f8b54c63ac5175b768adc0d70893d8ce3e1fae792564261921ae7fedb0257e354c39967dc147ab28fa56b5804b8184109cbb1a1a3452a2ee17f38f1331457c327bb1fc2688bd90d2660c6ad589a4ce7ff9344361751db44e02a1620d49b7eeec23d915f0b8ce8268a806fcbda2c05dbb590690f1f07b882c81840151bb834854f04c47b845f472a6002d799fa21cf19fd213112864acd17ff29b6a09270ce709569d94afc6d4ace04e8f8158f79e404914a9d1cc52601f3ea48989045afa558a27f57ab1ee7a50cd1e6553c0aba888fae801", + "data": { + "slot": "7646102394367871093", + "index": "7651059848312890774", + "beacon_block_root": "0x7827286a36f1d062724f3f414c6442dbd30fd3feb496c7cc62a0f7966daf6e55", + "source": { + "epoch": "895702330", + "root": "0x87cbc06af74223648a82c2d8cd7e2c0731c1ec2a2f34a3e4bc811c403fd9ce3e" + }, + "target": { + "epoch": "896087079", + "root": "0x6189cc6ab7ab64daa0fcf381266d036d24bbee06c2a25170617f95af8b176029" + } + }, + "inclusion_delay": "7687414491964843478", + "proposer_index": "7685762008748159350" + }, + { + "aggregation_bits": "0x4ab0ccd1d7d4d5da1894a9075770e8a5e59994136dafd478f754af2ed039e273fd8ec5c728b8c3ab1e98a28ec96f92e2526df2d786fffb4899a7e02c851d628a95fb377c34f8c6b82dcc54860e5a5bfd1e8b295eaa511617543a5df5d6aa09c85c58941a98c34a9197eac3369b28bd22ae43aa38238186e7dea41daf8b362aec018204c39dcf2988ed3c0ed3b047817bcb9e2123b8ed003dfceaa3f8d00c7efee5f622a74f2aa33cc1b25897ac512f5c1e10148a31a78508776253a33960c65a32b4b86e9b2988973f31a587eac82c68e92ed52b1e88950c1d1fb99b5b3cf2ddd6cc0c37fb3dccdb3d053ed2efec7d3a8f790324824143467c8c6c5ddcde779001", + "data": { + "slot": "7680804559098106966", + "index": "7679152071586455542", + "beacon_block_root": "0xe770a36a16bd7fbc54d1c6b1ef2a930850d0e704bf1f6f87a1076e2983bd63f4", + "source": { + "epoch": "894355709", + "root": "0x5937806ad682bb59146332b6e55f0ed775e2e17005d463e4b40e03dba202b034" + }, + "target": { + "epoch": "893201462", + "root": "0x33f58b6a96ebfccf29dd635f3e4ee53c69dce34c98421270580c7c4aed40411f" + } + }, + "inclusion_delay": "7675847105153087286", + "proposer_index": "8037741088520701279" + }, + { + "aggregation_bits": "0x9a100513325ea2322c8425d35b83883a334af0d619d85cfe9a8457415debba97ff700d625ce24744d6503b07f4bb301fec739228556a9522d2af28a8fce56ec53dece94922b4a468b97a2764fcb56c0690876e8f7e06be2999a08e9ec5fbdcf156834ffeefe7e5be944b7d5252198986d33dadf7905dd00ea36dc9c7460f7cbf0edd5d2645cb9dfb69d039df6cf096df72d349bb42b0cc9c022b7efb0d26619573645bd3c3184d8d2458317c74274cfeaa233134945602da06398d2242936ce01120e73bf579d51bac5a150200094516cbe5757ac954c82eb7e092325965f01e52b24844516a64a88c9de2c0a085966eafe2cd24f1894347a78880a79144eaf701", + "data": { + "slot": "8039393571737385407", + "index": "8031131155653964767", + "beacon_block_root": "0x4f706e6f7fff32821f2779422976cf9a3658b6d3e142238c439151aa3aabadb4", + "source": { + "epoch": "935331466", + "root": "0x282e7a6f3f6874f834a1aaeb8264a6002952b8af74b1d117e88eca1985e93e9f" + }, + "target": { + "epoch": "934177220", + "root": "0x9bf4566fff2db095f43216f0789921cf4f64b21bba65c674fa955fcba42e8bdf" + } + }, + "inclusion_delay": "8027826184925629215", + "proposer_index": "8026173701708945087" + }, + { + "aggregation_bits": "0x46885f83e3b4c40b0ff5a1802f3e35f24245155fee958096a4156a66184621ad8633b34213c82808c89e6e5960e05e1042d410046d45e9aa62032ffde92719695c39630d212ce2522a0ccb509af229c22dcabeaa313e72d8e94b752ff6543a390fbb7174dd003da79f1eb43ecb87cc40a4ad400ad85b8e8232783958c84862bf5d2743ac4a66e87badb89feefa1f1c9b01ad800170aca84336b30e2002ab12bc63f9e9bab904e4e14dd47940bcbe90d65dc34347ab4f33712796997ff18dc56adaf2b46d5686b143468102bceb53d3e367f5a93fc3f439ba8352aa26b2aec062271465e4ef921cacb05f9ee70293de52079ae521a11983156eb5dc597ec4c2cb01", + "data": { + "slot": "8021216247763925407", + "index": "8019563764547241279", + "beacon_block_root": "0xbeb9e96f60cbe1db01a900b3cd3c20c8b318cbd9eccbca4682f8c73c50b9a253", + "source": { + "epoch": "938601832", + "root": "0x9777f56f203423521723325c262bf72da612cdb57f3a79d226f640ac9bf7333e" + }, + "target": { + "epoch": "938986581", + "root": "0x0a3ed26fe0f95eefd6b49d601b6072fccc24c721c5ee6d2f39fdd55dba3c807e" + } + }, + "inclusion_delay": "8055918412494161280", + "proposer_index": "8060875866439180960" + }, + { + "aggregation_bits": "0x80a6e6039044a73ce6bbada0503e9c9ff2746fda3e688e937e3e3bb9d0219d627fb635d82ab78a68a16d7b5df8d0a11b39cc34c5ee34059d0e9f08671b84255a4bb926f96b4e28f9e454c031ffc27ed7c78b145daa459da98758af3025e66144b2ad9dc95083e87be1c6bbc1c8b3d4f6acac3c71a1d2a5735df8a775bdf20870187dc540fcfbeb244c5bc91c359e43689a583d19d0ae6f0ca4b6a40a11bd2ea1d28db63fe14d09bc90327392b8ddabf825388cc3b45b8dda6dfe8a91d65c20ad6b7ed8d3f63d193faf468ebdc0d1de395b45506ecf8cb1ce54a326c94999e2831070ea4c2d28807f37676f6303e50787444a3f73d9b02fc2b1843aa548cea42501", + "data": { + "slot": "8049308475332457471", + "index": "8054265929277477152", + "beacon_block_root": "0x43a1c06fbfdcfcbdb67dd3e296faaf63de2dc4d7e848e85dc280a0b6495fa61e", + "source": { + "epoch": "936485713", + "root": "0xb6679d6f7fa2385b750f3fe78c2f2b320440be432efddcbad587356867a4f25e" + }, + "target": { + "epoch": "936870462", + "root": "0x9025a96f3f0b7ad18b897090e51d0298f739c01fc16b8b467985aed7b2e28349" + } + }, + "inclusion_delay": "7984861599817005406", + "proposer_index": "7983209116600321278" + }, + { + "aggregation_bits": "0x96510b6a3f411b11f33341ca2d70d2cf5c6d2202b19af4e137dbf2903ab9ae393b15ba8ca5bb558d23acac735d74e3646da3747c578c2cccf08e1801e03f2ab3a88415543a22aefc757f62d1fb6eba3b31c2e15b03d37306f356e470557445cd9acafec37be623125a8d612660477483e3f59b5ef2c8599d4f8fbd86d25cd5a00941ba96eac839c0e5e06ab36d1c96bf08e6f76ae93570f39081a74bfc71f1031d1b2f01a2606bbb7265869f1d4c660522fb6f1d7e941caf459925e01ec0a1d9e7e34ae8392245a3678177c2fe6a16213567ac5298dc4eea2473fbc7df623b7b5fc872b8e9a8377d9d84cfdc7088c9cd94bc8f7c91ebc17775b00652c09e1fed01", + "data": { + "slot": "7978251666950268894", + "index": "7976599183733584766", + "beacon_block_root": "0x792fc46e9e907e4fe7bc2b2d22f622d6ebaf995d89ffc1a27233f759f7a3736b", + "source": { + "epoch": "928983110", + "root": "0xebf5a06e5d56baeca64e9731182b9ea411c293c9cfb3b6ff853a8c0b15e9bfab" + }, + "target": { + "epoch": "927828863", + "root": "0xc5b3ac6e1ebffb62bcc8c8da7119750a04bc95a56222658b2a38057b61275196" + } + }, + "inclusion_delay": "7973294213005249214", + "proposer_index": "7965031796921828573" + }, + { + "aggregation_bits": "0xd4056934ad2c04b7d277a9b24187babc8f260a56f472f7e31cfa68d6c8ef2ebe6dd4be1165ba5becdc582fcbaaf9e1777117349bef767238d2ab16d6a9c93b67a9bd3416e83ee9b546de9e5082afb301938879ceaaa6f2dfaf519351bddf3a3eba9da77737b2abfae427d7c5687c2b24bbd3ba413a01f30ea8182e05639992966e0c3864018d2b20f8d328d50ddb03a7011a529722d852c2669565c846fa0a7056c915cedc4a1d2fceb0cafbb733b89937c7fff7c4898ab5adc3f065b4a42d72814c7f5b15e7c5971d046fc10578d9432b3c3a7bbc1ce719368c46bfebed3db7010d45f107535b3941f49c61504885d9f041a3c1099033145df79712bd285aef01", + "data": { + "slot": "7966684275843545405", + "index": "8011301348463820638", + "beacon_block_root": "0x34fd276ffe8aaabc9e4a504b15e0c537817caaab6dab0c46689f7b0d77354635", + "source": { + "epoch": "933022973", + "root": "0x0ebb336fbef3eb32b3c481f46dce9c9d7476ac87001abbd10d9df47cc273d71f" + }, + "target": { + "epoch": "931868726", + "root": "0x8081106f7eb927d07356edf86303186c9a88a6f346ceaf2e1fa4892ee0b82360" + } + }, + "inclusion_delay": "8007996377735485086", + "proposer_index": "8006343894518800958" + }, + { + "aggregation_bits": "0x8eca88eb9c785e7ff07d76fd26cc46d0d54cbf24e238260ac761b4d8b66a894481b78a36dbff58a41eb1fe09414713e124c142f1ed9cbc71cdae741fa7162033fe6d1bf630f815ef404c309cf21b6caa5eee256d6e3e108620abe34df41178ab74362cde74a21a577705052438f36ee2f22a3a8b224566c5b592df3e5225e1231ee10ef811ee4917c1414832207a5e36d979b404dd0fcaa3a28e6d9fa4ab9c373af2b751884595a1c7a4fcf1f7b302ef3da0f27a5a2923beab1eb6421c3a233c9dec31d89926dca7b015d8467593d112d96e8006bfc6be650a13d7b006894b87770ef3fe0071948a22be16c495575676e2f6348c51de4d31b9f9f9401930521b01", + "data": { + "slot": "8001386440573781278", + "index": "7999733957357097150", + "beacon_block_root": "0x0669e76edeca42b2272bc0282cc1a707c69d9ff1434bcd45602c62a8d95e272b", + "source": { + "epoch": "930137356", + "root": "0xe026f36e9e3384283da5f1d185af7e6db997a1cdd6b97bd1042adb17249db815" + }, + "target": { + "epoch": "930522105", + "root": "0xb60f146e5c6da961a4954543effe8adea70a7c79e7848973d056e0d18efdf0ac" + } + }, + "inclusion_delay": "7930329632191592700", + "proposer_index": "7935287081841645085" + }, + { + "aggregation_bits": "0xd460d09940d91c34efb8ef234793d21a73455fd4b3044bec58266534e80348e3b832971b9186a2254a97be334bab51f99c17b73a6af90b1f177424e0fecf9133481336177ea287881d8603cf3c1bb3e7d0c7600971654701983319943e21c7050d2f64a44a15824572df7853ccd24624afb96e62caf08f04b67de206458fc3ad1bccbad8f819ffb63755baebb4e4a0d24b8bef9f18dceca8bfaf352a581e9cc8a534477bd3a704831b1ca06b69bf3eba69a478ef5f2a2f067402c0761e6d00695d60fd39c22aad311cfaa7b8f5dba2e9eba41d8a078e7ee004b377baae495f7ff0b80fd2b1870ab76959ebd5d8d93c35d0564b1f299da0f1b3102dbf742800a301", + "data": { + "slot": "7923719695029888892", + "index": "7928677148974908572", + "beacon_block_root": "0xef72026e3c504730835e7bc56a99c845b913792f0adf03a259daaa2a1e20174d", + "source": { + "epoch": "921865255", + "root": "0x6139df6dfc1583cd43f0e6c960ce4314df25739b5093f8fe6be13fdc3c65638d" + }, + "target": { + "epoch": "922250004", + "root": "0x3bf7ea6dbc7ec443586a1873b9bc1a7ad21f7577e401a78a10dfb84b87a3f477" + } + }, + "inclusion_delay": "7912152308218132700", + "proposer_index": "7910499825001448572" + }, + { + "aggregation_bits": "0x984f2389aa3bfde4894540e70210acf0a2df523a383944ded7a4e4c7a69d7ab809f11dffade6c33d83a6ba12435e8a2c68c052afafbef3d4e9ae26da353116153473440f718a9731ebe25aa7def615047e076a3a06763d704db6d1ab7c3ea3db72e4b42ea293619612346329ca259311c748acbcb8d739b017ea306ea68aabc16b984df88ecc880964e20ccc0d3ccfed910f7387a75d6d6de827a09cf788a8c63eae5094053b17a19d0d6dd9f8dcb8e930cfe57eaa3e34d67e6259c76cef8e4277ee93b2d9764091625f1b2a827ada61cd1be22b8c9e7fff1d3fef0b4dfd46d38e61554f26fd06fcb2c755ec8948d26b8fbb229b6136b158ff8a9cfbeef86c9c01", + "data": { + "slot": "7958421859760124765", + "index": "7956769376543440637", + "beacon_block_root": "0x5ebc7d6e1d1cf68965e002360e60197336d48d351568ab5c984121bd342e0cec", + "source": { + "epoch": "926674616", + "root": "0xd0825a6edde1312725726e3a049594415ce687a15b1ca0b9aa48b66e5273582c" + }, + "target": { + "epoch": "925520369", + "root": "0xaa40666e9d4a739d3aec9fe35c836ba74fe0897dee8a4e454f462fde9db1e916" + } + }, + "inclusion_delay": "7953464405815105085", + "proposer_index": "7945201989731684445" + }, + { + "aggregation_bits": "0x5e7cfa19fbcfbad32d053ef731000209112ae8bf31d64ffd17f7f2684cd3c7631660a5fd5f094a43f3153fdda174a4a61fc08d67ed5b73e315ba1f66b7ad307229f88d77f96e9e8eaea6174ce986d721808de81931239a1562b18d94279f78a5687ae6dee7108a5a2cb864b6bf92cdaaec44a2dfc50f1b6b26e0ef53915cd54a6f84355c2813aad1f430fb1f7bae0c8ef9fc66c39654840878aa4075e69a04fb8dc24c69dd3fec6c404e5501fcbe38c51bc046aaa1280036e0c3c858553ff3f19bf275b46ae783efcb1413238b7d91f27de7934ec8bee6c7cdc3ab86be12a3c21111f2c7b0c295df413510a29b3d412a4ca4d85da9ddcf9945b192a3c9741c5a01", + "data": { + "slot": "7946854472948368573", + "index": "7938592052569980637", + "beacon_block_root": "0x7cac256e7d8a0b93c4cc0fc174644d7794017fc3c42a0f4546d31579ffdaca0c", + "source": { + "epoch": "924558497", + "root": "0x566a316e3df34c09d946416acd5224dd87fb809f5899bdd0ebd08ee84b195cf7" + }, + "target": { + "epoch": "917248268", + "root": "0x2c53526dfb2c7242403795db37a2304e756e5b4b6964cb72b6fd93a2b579948e" + } + }, + "inclusion_delay": "7882407601727883803", + "proposer_index": "7880755114216232379" + }, + { + "aggregation_bits": "0xdc21d32141c5e577bd367666b37b906b56fe8f1615fdf0f90379c8648e105ce5243328f5695cb0f4276ba8e7d20fd122c9d3c50c6f0292db3fa51f38f29594f9e58f920c251dd59ed88f40fa285131fa63461a99fe7f982f02d45369af2a5fe8cb6cc699ef383132a5c8abb4f787ba20753b688a603a097fe89fd2679c4afaf73e589db2b7744c896307bef1a081f99e7fb66a00373c4815391e3cd8cd8dfa5edd53421552cdcf1d4ea80e1860d5129773386856a1d894e4b781b9f1843a87e9abf355d02ef528adf3205d501389f1c23d4ec6428d5ec4c593630f1ba459f41fe9f4cfadb0955ee42174f2720a95e684eb2e016c8dab8229bba1a30e55cd558501", + "data": { + "slot": "7875797660271212699", + "index": "7874145177054528571", + "beacon_block_root": "0xb23a296d5b3e8d24f50b680b0060c0e9a183544965e1e889f6856c1cae1f9859", + "source": { + "epoch": "915516898", + "root": "0x8bf8346d1ba7ce9a0a8699b4594e974f947d5625f84f97159b83e58bf95d2944" + }, + "target": { + "epoch": "915901647", + "root": "0xfebe116ddb6c0a38ca1705b94f83121eba8f50913e048c72ad8a7a3d17a37584" + } + }, + "inclusion_delay": "7857620340592719995", + "proposer_index": "7862577790242772379" + }, + { + "aggregation_bits": "0x1e1328252534a24010727074e66aeaa1f50f743a5b00dbf80b56581a4636e07afbba3aed192136b471daac30622f1b7ca2c106c67aa75acc527169428236fe0aea269f3cef63f13557dfaa037671ffc56b4178f46b4227db6553cec65d084d96d7f32c8aeda2f2ed9f6494491b96695a785e76d111f26647b2b40c18e8d896323bc0f39c901b5ad3f3e668212e95ee7d3147d30ab774ab68abf3c0b5c49f975b641e3d9ad60b73d011e675c3263e71ba0983e212fecda425f962e849b3fae64a843b314e954ae9d1ca7658543b9bce18095b77718e6e7db74196afa57524d51cb0a05c116446c0ffe7080f36dbad77c13c389afbc17236bc455a09b252c7174e01", + "data": { + "slot": "7903889887839744764", + "index": "7908847341784764444", + "beacon_block_root": "0xd4ffbb6dbcdbbe6a028252ce5603bfe204386d079647ed5b7ee8d48d5aaaafcd", + "source": { + "epoch": "919556762", + "root": "0x47c6986d7ca1fa07c113bed24b383ab12a4a6773dcfbe1b891ef693f78effb0d" + }, + "target": { + "epoch": "919941510", + "root": "0x2084a46d3c0a3c7ed78def7ba42611171d44694f706a904435ede2aec42d8df8" + } + }, + "inclusion_delay": "7892322501027988572", + "proposer_index": "7890670017811304443" + }, + { + "aggregation_bits": "0x522cf961f5f24390728ad7b203685c0af4d05845d53de75aaeaad638ea90d2cd4a319212a7101891ddc1a80044e3417d46f4891767623207049b2f1ae9733d0e1c26ad71a3fba48c03b773e9f4c5d74c0160f4c9dc7a577bac56c6f9b63af11cac313c83431911577b3f93530df134afacce9525a7ddf3d590628f925c9ded1d681c22b081e6096e7809ff265b6090c3a9c9536c19d32ae77e5661031309804af9ad0937245fe6f836b57a71bfd5307800a85e434edb8741895270daff4878686db15c6fc6961315facfe5cb4c1d9af133d24e76c8ba70b11a0a339ff3072036ee68e014b93e8b1c301e595f6e8dde9f6dde138c89bbfdda89c099c2c88c6b2801", + "data": { + "slot": "7885712563866284763", + "index": "7884060080649600635", + "beacon_block_root": "0xa66b7b6d9b1b57608c62c2ab6de4a0b24959624d6ce7ad5b7675bb28bcd390c3", + "source": { + "epoch": "918210140", + "root": "0x62417b7264b530bab75dd3b53660240ff7c539fa25fcf2d47c743f9fc65968a3" + }, + "target": { + "epoch": "960147770", + "root": "0x3cff8672241e7230cdd7045f8f4efb74eabf3bd6b96aa1602072b80e1198f98d" + } + }, + "inclusion_delay": "8250911517962234308", + "proposer_index": "8242649097583846372" + }, + { + "aggregation_bits": "0x887d38a213d8b45053ca536c5a1439f5a14e5e9269eb6f449430a933ec47ba0948d95ab5943bcc584c01b969ba52f532e04e2365d4ffac7d4c13e79c7a9c74c932673444f792771c7707602b8f4a6cb3bb68e3329ca0e76d65c71c928f4aeda4206ac8e70d2783882c0f8c37c1d2c469e5bbd22b6405ecbc91ca5a3f88f4ba426f03c39bd2a2b45c7ee59862baf90f4a889cdbc9c38cf65707d7fc404ea99fa26d7e62c32045604dfdbd89285d8053d62019327dcb8bd891d8a8af53ae9ad2f08735bb32a52c6c4f96a4974ee7d663bf173ee8177f3c3d82bdbf6912cb0a6e644926a4614e436a2f802665af63d471db7d695e28daf34cdacf8cf828c0c6a18f01", + "data": { + "slot": "8244301580800530500", + "index": "8236039160422142564", + "beacon_block_root": "0x0e6b4672045e0a2656b8743ca72fdd442fe1301c8e0a626018ff9ea973c1da83", + "source": { + "epoch": "959185898", + "root": "0xe8285272c4c64b9c6c32a6e5001eb4aa23db32f8227910ecbcfc1719beff6b6e" + }, + "target": { + "epoch": "958031652", + "root": "0x5bef2e72848c87392bc411eaf6522f7948ed2c64682d0549cf03adcadd44b8ae" + } + }, + "inclusion_delay": "8232734193988774308", + "proposer_index": "8231081706477122884" + }, + { + "aggregation_bits": "0xe298912968282dd9e8c111a33fd584855b278e68df452a740ba6d93182c00773846a6a921113df52dd403fab48a503a065d851cbd213022a55d484f7f2672f9da11ec5046074af7ff3904de3ffbdf308bf1f7a9138344d5deabd6092ca0d2731e2d345622b34bf1faf354e53e1498a8fec7bda1b7c5d7a22ac76a28bbcdcd1bc36af7047d3c9e4cbe63bfa806530769771fb2f23335a64b0b9bc955614692b2e0861a1daf408eab3fba93c34395c21b83277dbd0e933598bda32a9d21f17acd3931da5254589e7207b107ccf9cbf3be96f3e97d80c57a4d24941d57df7c05e4e2f45b026eb43109a63e8a55fa5cd736c4fca8d37823972af7f3a3470303ee35901", + "data": { + "slot": "8279003745530766373", + "index": "8277351262314082245", + "beacon_block_root": "0x7db4c172e529b97f383afcac4bf62d72aca145229993091b5766153c89cfcf22", + "source": { + "epoch": "962456264", + "root": "0x5772cd72a592faf54eb42d56a4e404d89f9b47fe2c02b8a6fb638eabd50d610d" + }, + "target": { + "epoch": "962841013", + "root": "0xca38aa72655836930d46995a991980a6c5ad416a72b6ac030e6b235df352ad4d" + } + }, + "inclusion_delay": "8260826421557306373", + "proposer_index": "8265783871207358757" + }, + { + "aggregation_bits": "0x3ac64b92f047175ac3f5d307533866f3a20d809c9bef68a301c3daa46ea439d4ca4be82faa5ed5701a70f913bc8c48b73dee2525a6393852bdbb8f50a96d7e49c026b9d8ed2accb1ca05fb7e846cfc60de51824099edfce617b55378063652c30d8c1ed61bc0da1d189ffab45c6affb9b9a92364a68219a16b97b5cb481b8a9171a67ef124ba438f546eb8e34be7d2e1700fda60f1925b87250e2793963ada174a97b30c2a307c2e47b3dc5eb55db6cc1d600f5b0ba3c63134e72dfe25e0a6d036368c962968e79e43b84eeee48e68818a35293209b64c35d0fe8c4d472438b839e0836f6688c5b83b1de8ae43b4ea7e83218f09da42211d58a507321daab25d01", + "data": { + "slot": "8254216484395602564", + "index": "8259173938340622245", + "beacon_block_root": "0x039c9872453bd461ed0ecfdc14b4bd0dd8b63e209510273297eeedb58275d3ed", + "source": { + "epoch": "954184163", + "root": "0xd984b9710375f99a54ff224e7e03ca7ec52919cca7db34d4621bf36fecd50b85" + }, + "target": { + "epoch": "954568911", + "root": "0xb242c571c3dd3a11697954f7d7f1a0e4b9231ba83a4ae35f07196cdf38149d6f" + } + }, + "inclusion_delay": "8189769613175117795", + "proposer_index": "8188117125663466371" + }, + { + "aggregation_bits": "0x943f3c5a1fc68f13804c3f39386826202cb56a00150042c14d6d89828a1cec8fcfc8f59f64221c93aa652b9853f428e83d0a41119511e79261d2de26444251e06f8d8c5da9856d88da0e229e83d0beaf2a4c36c630f82a420b30407d4a30754beda373dab22e58dcb24c3857d3c6ff5edf51d4c2679e241f097c26ef63a7925048179667bfab23e7f2d59b6e9a36074c2239c9b5c80a535a70776484fffe0f550d0c2613e9067eb30100a61b11fb7abb78802de4217c76f03e2bd634e4c115a5792716a96e59bb13e176ff955a9620d6e77b316f6faea331aa2e9147d59f55e846680e9bc7790eeaf15b3a01b188257052939952b2416ea39528f1edd378d5d701", + "data": { + "slot": "8183159676013413987", + "index": "8181507188501762563", + "beacon_block_root": "0x382a9c7123ef55f31e4e2727a0af3080e43814a636c7007747a1445930baa03a", + "source": { + "epoch": "952837541", + "root": "0xabf07871e3b49190dddf922b96e4ab4e0a4b0e127c7bf5d35aa8d90a4effec7a" + }, + "target": { + "epoch": "951683295", + "root": "0x85ae8471a31dd306f359c4d4efd282b4fd4410ee10eaa35ffea5527a9a3d7e65" + } + }, + "inclusion_delay": "8178202226363361603", + "proposer_index": "8222819290393702244" + }, + { + "aggregation_bits": "0x501ce35a6c3b6924ac109c2b7b7889cebf44d5a8848fcdc9978edb8b706a1b40173967d5dc2d98b57a843b3da05eb4e35e9909d5c6f46f94a946ecaca6ee7dd33031df07e3aa90079ddef9e7e440789a405c74e503ad4df3b4870fc3c502673dd6fd8161b9e6af48c8841fa856b62127b217ea18868706af17569990770df41c0d89abcb9826173536764facbc2441a77d6877a56c02b01383a8b8bcfe782326bc515b2631e4137c5e4382c1168105975478a3296e68e847b4cc93acdb0134da8f2f76470acc192e42346bb0f9513b0fb9f7843c639e38655c8bb5892c89b0811b3a12334112a16b20e7871c20b3643b988903c4feb8e8361b425f93c1b2a73901", + "data": { + "slot": "8224471773610386372", + "index": "8216209353231998435", + "beacon_block_root": "0xf3f7ff7183e98160d5db4b459399d3e17a0525f41a734b1a3d0dc90cb04b7304", + "source": { + "epoch": "956877405", + "root": "0xcdb50b724452c3d6eb557deeeb87aa476eff26d0aee1f9a5e10a427cfb8904ef" + }, + "target": { + "epoch": "955723158", + "root": "0x407ce8710318ff73aae7e8f2e1bc25169311213cf495ee02f411d72d19cf502f" + } + }, + "inclusion_delay": "8212904386798630179", + "proposer_index": "8211251903581946051" + }, + { + "aggregation_bits": "0x3685216afd7ace1c94b7284a71f5300ee8ae746013a4902aa89fdfe488f7ebfe7e0e5fc1d2c6e3b2a5bcfae2550bdaec6abad730ac03b3be1df2bf29b76b727b35ecb1dff77fc6a04f393dcb80ad6c1f7f54d9d0f4916148dd4a1181a325c8fec3d7a9c3bde971194f5e69cc8e3a40a4d52545d5e601d967fd636b839d4aa3cf7f7a23294f8bf130d834b9ff0b09c3e62232ac5f5e12fc48c6b6eee447adcaa32dccf447c350f2913405c37d560c1d95079831527431e873e144d71dbd33b5c8427765d5e53e3336acee1c0e118cafd90433597b593658d8430d45b1413281e97ebe9bdb6f3021474a25b32b160034cf30f90bd07a3502e4524509c70e72cd2301", + "data": { + "slot": "8206294449636926371", + "index": "8204641966420242243", + "beacon_block_root": "0x29860371629d03f2061ba48f1f9546548787fa79bb29255fedbf1fb05e904051", + "source": { + "epoch": "947835806", + "root": "0x03440f71220645681b95d53877831dba7a81fc554f98d3ea92bd981fa9ced13b" + }, + "target": { + "epoch": "948220555", + "root": "0x750aec70e2cb8005db26413d6db89888a093f6c1954cc847a4c42dd1c8131e7c" + } + }, + "inclusion_delay": "8135237641254737794", + "proposer_index": "8140195095199757474" + }, + { + "aggregation_bits": "0xcc2ca579e4de9a969ec2c1960e8f75d4a201b8920f8e795f23b2828a1aee78550aec28c51ccf3b61c5c7bdddad25865ad83e22dc02641e50823826e4e0b3cb27458cb81fab8f8480d3d34a01cee5b17e4b6835b44f0c1e7735d782dc57307780bbc6adfa819cf12b981a24165ab3692b972c3565e0943694ea9a71bfe664035d5a1fe724ba78471076304b2403ac156b69c445e519b5c828bf1bd7c95b3aab6ebf6646d9909aa25fc489158f703b270613f8373774d0f14b296a6729f2758e5340632579d73b139123466ef9d60d4c483b1714fd7bbaa33d0aae9dace574a01069982571ca6a077421c64c1839cfda8c57e0f82531f74724529c553840eabb6b01", + "data": { + "slot": "8128627708388001281", + "index": "8133585153743086369", + "beacon_block_root": "0xae6dda70c1ae1ed4bbef76bfe852d6efb29cf377b8a642762d48f8295736441c", + "source": { + "epoch": "945719687", + "root": "0x2134b77081745a717a81e2c3de8751bed8aeede3fe5a37d3404f8ddb757b905c" + }, + "target": { + "epoch": "946104436", + "root": "0xfbf1c27041dd9be78ffb136d37762824cba8efbf91c9e55ee54c064bc0b92147" + } + }, + "inclusion_delay": "8169939801690006370", + "proposer_index": "8168287318473322242" + }, + { + "aggregation_bits": "0x1c54ec93e12710565957a42c19fbffd3dab7034958f5ed1c2ec157de1e324e7ee93c963a2cb58e75856879cc6c79443803fd3bc1c0ecb651867dd7d4923663b145d9e60bb851181530469d52e9a15a67f919af21ae7c02d8f2505f3e0027ff845e24127c1f8c7c2cfe5ec85544cad830b08befa7fc94ee38ad34f9d988f05d4e4993db379103a48f3e6409c6ac4219632b5dfcf0678605f44508f91b236a06d0502c52fce83229eb8bf42ca3576a0faa45663f98851b4627fb7deb0b4174f3eb6bd49ad6e051fcf235ef2111b413200f5ff05e94934ea24fd33958704398b38d3780c88c69a8d68e718afe92fe553bcd21f2481d5ace82248b0394f7b426d01601", + "data": { + "slot": "8163329868823269858", + "index": "8161677385606585730", + "beacon_block_root": "0x1db75571a27acd2d9d71fe2f8c19271d2f5d087ec22fea306caf6ebc6d4439bb", + "source": { + "epoch": "950529048", + "root": "0x907d3271624009cb5c036a34824ea2eb556f02ea08e4de8d7fb6036e8b8985fb" + }, + "target": { + "epoch": "949374801", + "root": "0x6a3b3e7122a94a41727d9bddda3c7951486904c69c528d1923b47cddd6c716e6" + } + }, + "inclusion_delay": "8158372414878250178", + "proposer_index": "8150109994499862242" + }, + { + "aggregation_bits": "0x4c00179bd9498ef1506d44447e1cbfc501dc27f98d4c2ddb00d9fd54685e67fda5d5922096f094555a59ad321b2077a95bfbfeae2cc6b8ecf426c25273d06266a56012de3a095d9207eb6982907057138957d7fc0e09d3459b7536fcec4ce873de9359c16739f148c6fd3cb769c18785cb48ddce245b84fb5a2e7c6906b3000f4e495825747082fc8d140ac2cc9d3d1e22ab5d89257aaacbf8068b0ea5bed35b1bd809381662cb7eb66b4b4ffd3b85eb6078217238f240df1732ee23ed827fc19763af25bb886ccce7aad371cc68a7ffa09bfa3b36d4173a42d681c0b2e77d2928859bc69f4bd22e3da6b52dd87e67de895a686902a79947a1bc6e24dcd6910201", + "data": { + "slot": "8151762477716546370", + "index": "8090620572929429856", + "beacon_block_root": "0x9fc94170005dccd2a3bcf3276638ecc355ebd94b3d09675ed366d380850ce432", + "source": { + "epoch": "942256947", + "root": "0x79874d70c0c50d49b83625d1bf26c32948e5db27d07715ea78644cf0d04a751d" + }, + "target": { + "epoch": "941102700", + "root": "0xeb4d2a70808b49e678c890d5b55b3ef86ef7d593162c0a478b6be1a1ee8fc15d" + } + }, + "inclusion_delay": "8087315606496061600", + "proposer_index": "8085663123279377472" + }, + { + "aggregation_bits": "0xd62ffe9061836115c1dc28cb68526683e1bb4c52b54657d30a8f277fb4bc0c7992891f2ae4d5e9eebe332e8c449218048d6374c826875db5bc3b1a4ed669ce7638444001f89ba4c376aa2eb7d2b72203fa8cac6469d9d158f231c621a6fbcebf6f8d3dc725fc3e274ed1fad5408c903ed31413dca103fe95976407fe73b53a035fc731886315eda1fa33df0c02e2c02d1561fcd396307fc791a2b6138e280da8c209050f19b8a8c9bb3d322c09402dd210c0ab389e025f2f5c989faa782289db366c89b959cfd7271c9c9d0b231ec7e9e710cc3d0b24317b113d569ba262f33d40e427cc839160735ca7379cd9d40d396c7c37759d50cd9750b13e99070ecc3d01", + "data": { + "slot": "8080705673629325088", + "index": "8079053190412640960", + "beacon_block_root": "0x71350170e09c64c82c9d63057e19ce939a0ccf9112a9275ecbf3b91be735c528", + "source": { + "epoch": "939371330", + "root": "0x4bf30c70a005a63e421795aed707a5f98d06d16da617d6e96ff1328b32745613" + }, + "target": { + "epoch": "939756079", + "root": "0x5a97a5706157f83f5a4a184659228f25ebb7ea9921b5b101c9d25734049eb6fc" + } + }, + "inclusion_delay": "8115407829769626369", + "proposer_index": "8120365283714646049" + }, + { + "aggregation_bits": "0x344d37144637066a659e0ecbbf58cf6ff5cbba766aaf39d140a8f1742c92f0e4480ab3b850cc6dacea823fd9fe32c69bf6e93d0d9532d38144af3f74b45fe03265a8007dfc85b37d2daef74d26c6f534749cbe43c4e876bf9c16781e3f583dc27158a977243ed9db702dd5280d7fe28568530f8dd6a2dce5e4429cf11d335043da9bc82c94fcea7cead189ded5f04b4a581061e1b6189ea22a0f027687b821ef78051a2ec5ff56d063df6ad60f1976be3b9b24ee8134e3acc6f24e344df9705acb7c6d0648197660f6d2d00a18866861d186fc4c2e18aa4bc3c944a553d317e51998b2760babcf70ab978a3b7aaaccf8ef078dd7e9b8b9200dda70210581ec5b01", + "data": { + "slot": "8108797896902889857", + "index": "8113755350847909537", + "beacon_block_root": "0x94fa9370413a960e39134ec8d4bccc8cfdc0e74f440f2c305356228d93c0dc9c", + "source": { + "epoch": "943411193", + "root": "0x06c170700100d2abf9a4b9ccc9f1475b23d3e1bb8ac3208d655db73eb20529dd" + }, + "target": { + "epoch": "943795942", + "root": "0xe07e7c70c16813220e1feb7522e01ec116cde3971d32cf180a5b30aefd43bac7" + } + }, + "inclusion_delay": "8097230514386100961", + "proposer_index": "8095578026874449537" + }, + { + "aggregation_bits": "0xd84bd4f2d575f7f303eba91908cbadd406f4730124924162c89639010204d379f5d13d8f66c98b8d65892a6ba2ab0c53089f9c5a2e65090bd607792c5f0a6717d3ac12f0e2dd73c788c2ad34863bc55838d8586873de2eae65830001796f715b0bc86bdcc2193a248877c6523bd81bd293c2fa7326884a5fa6d8142cbd62297129dfbe0cd52598c7117e7ab9ed0a2900939fed9d8afe1fed7ea6c2d8d1ac37fd679b4c41b7235171215cc56c9270218452f09cfb5300ee1ec081f78d1651f8b061f8022239d6ecf4c47141983932a49e6e8d030ba404ad589075cabcf5f04e4666ebcb7196d3a7db6cedeca10eda306eba81e5f2a931fb7b43e051459b4ae44401", + "data": { + "slot": "8460776980970399082", + "index": "8459124493458747657", + "beacon_block_root": "0xaf7576752a4eccc02f5d63abbfe4b6eaca3cbad68c0f3d4c3edbf7ece12a4932", + "source": { + "epoch": "985156449", + "root": "0x223c5375e913085eeeeeceafb41932b9f04eb442d3c331a950e28c9eff6f9572" + }, + "target": { + "epoch": "984002202", + "root": "0xfcf95e75a97c49d4046900590d08091fe348b61e6632e034f5df050e4aae265d" + } + }, + "inclusion_delay": "8455819527025379401", + "proposer_index": "8447557106646991465" + }, + { + "aggregation_bits": "0x82a3952033cb003033a02cc9051c6f1fe80aad84c879c963ff5f802e0642cff5ba2ff5ac11929560c7cc09882d1e2e6da46f3cac9cb663139d4e8b6e56630e38eaaf22243eb775145b5279dd55f4363322d237e5a39ba700ac1b937a691a7d32914b3159c40d18e3cf96d5d7f7bb6e74c496c92fe7115738cf30c830e9997d222672eef08e45a4b427d0ecbe919fba9ba34ba512f181d375e7633fa3cd2d4806cf2920f97b7915e18bbcb6874114482a7ce1d0e7f6f1d35af1d0088c4f8a5c0cea7dd7f6ca86b2efbb1a531dd6439510cd22eb42b70bc4733aa3c114acb1248f4186cc402d8e47e0dd7dd06342c38b22da7ee2130b390a2e2816079bd7833f7501", + "data": { + "slot": "8449209589863675593", + "index": "8440947169485287657", + "beacon_block_root": "0xce651e7589bce1c98d49703625e9eaee286aab643cd2a034ec6ceca8acd70753", + "source": { + "epoch": "983040330", + "root": "0xa8232a7549252340a3c3a1df7ed7c1541c64ad40cf404fc0916a6518f815993d" + }, + "target": { + "epoch": "988042066", + "root": "0xb7c7c2750a777541bbf6247700f2ab807915c76c4ade2ad8eb4b8ac1ca3ff926" + } + }, + "inclusion_delay": "8490521691755615274", + "proposer_index": "8488869204243963850" + }, + { + "aggregation_bits": "0x78ccbfb94a2f8bfb95ae5f167ac1b06f42e2686afee598cc30d066213c652fcd7d00fdc33f8e3446010d1d43c4a9c8ab43f1408e9b8e8d54834847e5d434354a2c977b45b4d1dc09adc557b4874ae9b8a6b5a53886072c1b03e4825e03989f7757f2ca7de37ca86bce77127ee70227a3cd76a586bf09c230c0903d2079261f9cd375dcfebeae44603e0a4b1d9c1bcf229b241171200442523d0c36bd57ee191816f282c83f7d8f338808802c3cd970c4604fd94adf697055af0b8cadb50f336bde1efb2c12c9b8d82fee7c99eb6015b43fe31bb51865622fce167cdb61fd94b337551aa3eca617550bb38282a69c90c9dcdd3119a9705c1b8c3e44d36bf83e1001", + "data": { + "slot": "8483911750298944170", + "index": "8482259267082260042", + "beacon_block_root": "0x3daf99756a88902370cbf7a6c9af3b1ca52ac06a465b48ef2bd4623bc2e5fcf1", + "source": { + "epoch": "986310696", + "root": "0x176da5752af1d19985452950229e12829824c246dac9f67ad0d1dbaa0e248edc" + }, + "target": { + "epoch": "986695445", + "root": "0x89338275eab60d3745d7945417d38d50be36bcb2207eebd7e2d8705c2c69da1c" + } + }, + "inclusion_delay": "8465734430620451466", + "proposer_index": "8470691880270503850" + }, + { + "aggregation_bits": "0xc22cf4aff082c9293f7b62cad45697850c6b0839a29e7d68a3efbacf2e44fce4dff1c8f6d5a9ec8715b71d61ecafb71b4967b68625eba2121887d60889ec840818d732cd7a7b9a29700f051ac14334d49fd36e487952536efb791b1af52ca11925e1c2c6cd0b5058716a7b2052898720496d452f17b82a33d37d04f844092f8252563cfbb65d7094c08e7b8284a6388ac9d49f9aeb61e4396c7f2f45636136f6ad70355e7c97d65ddcd4d6df1a9c144d54075cffff90726f581748db4e5955f116b2b3903d94d848ae47122626a1c627941fc715b849f98bb3b58c206785b60b30fb56e8198d10c46846ebf7895bbe8cfaf843acf218395b64f61a0e04e0002c01", + "data": { + "slot": "8406245009050019080", + "index": "8411202462995038760", + "beacon_block_root": "0x26b9b474c80d95a1ccfeb24306885c5a99a099a80eef7e4b2482abbd07a7ec13", + "source": { + "epoch": "978038594", + "root": "0x987f917488d3d03e8b901e48fcbcd728beb2931454a373a83789406f25ec3854" + }, + "target": { + "epoch": "978423343", + "root": "0x723d9d74483c12b5a10a50f155abae8eb2ac95f0e7112234db86b9de712aca3e" + } + }, + "inclusion_delay": "8394677622238262888", + "proposer_index": "8393025139021578760" + }, + { + "aggregation_bits": "0x4e6b11c93cc4b873d5a6458c7356b12ceff1c9442ca361fa021124fe2012dd53ec6a4242e98ba783383c09d0b4badd97393a5ad8d88cfadd877db130223b03ece6132338e4a34dd4dc6b1d739127341e93b7aa7386c66a3fabddd785a8a3e4165b12c044a16cf3eec916683a47acd071d8182bd723d29daf35b094512c4c547c258c495f2188820fab80ea81a05d7ec4d07e1afe5a46659071dbe27f18fb38e4925661332a7bdb74d4811925127f419f6f78e62e0da37db93476f27f45f91b95247e5ea4821966539ccc3fbc1b0116db3b0838923795749cb911086143a48f826e38857e84f40927af78bdae3ad91ab1ebc429caaa9b303d686fa96a863a480b01", + "data": { + "slot": "8388067685076559080", + "index": "8386415201859874952", + "beacon_block_root": "0xf8247474a84d2d9755df22211e693e2addc18eeee48e3f4b1c0f925869d0cd09", + "source": { + "epoch": "976691973", + "root": "0x07c90c75699f7f986d12a6b8a08328563b73a81a5f2c1b6376f0b6013bfa2df3" + }, + "target": { + "epoch": "981693709", + "root": "0xe18618752908c10e838cd761f971ffbb2e6daaf6f29ac9ee1aee2f718738bfdd" + } + }, + "inclusion_delay": "8435989719835235273", + "proposer_index": "8427727299456847337" + }, + { + "aggregation_bits": "0x68404ec90c3cdf44f8f4fa98244f5d24bf843fe822486bfd88323491ca6463dca1c3fe0059b403e965c91cdf0693676c7a306c100f6926ca7ac8b29e0082376beaba400c2485432b971396b19c97fab359b6a80018170c9ec5fbad2b4a53bfe96094347871ae5c3737cc67c5407f68ca9311b38458d3bf1d41b84b6c11f630dc67d6a3b8874727902b63be524b4ff536972f81d64f2f24d9d31e581e19fd5481204a5e367a19667c0966319717141ab306a669f013924318645c71f1742ea026d1202b0b15a7e70e6c8aafbd18869d102bab0971a7a9cdbc59d0988d32346ae233667a144e4f8ebc7d1850c0e0a783c66c1ab3f8d77e46a9f77e2794b8746e5101", + "data": { + "slot": "8429379782673531465", + "index": "8421117362295143529", + "beacon_block_root": "0xb3f2d774084859040c6d473f1153e18b738e9f3cc83a8aee127b160ce961a0d3", + "source": { + "epoch": "980731837", + "root": "0x8db0e374c9b09a7a22e778e86941b8f16788a1185ba9387ab6788f7b34a031be" + }, + "target": { + "epoch": "979577590", + "root": "0xff76c0748876d617e178e4ec5f7633c08c9a9b84a15d2dd7c97f242d52e57dfe" + } + }, + "inclusion_delay": "8417812395861775272", + "proposer_index": "8416159908350123848" + }, + { + "aggregation_bits": "0x8a66f145f6b630fae8b55f97b260c54643d45cdc2a67ddfd9ee07a9e081fca4a91947f582d357e5aa87bfa3555680cc18c2ac0730c098bf230c3ea80d53881a0053f03d3e0348a7ad51387adcf8234a93efcf69cdf47ce41b49755f654c71a35f8b873f5d8428255fee881c5e2b37d354f63f196fd2be1910b9570d197c8865072c8cb07116940bedc1c2cffd5c828989ee146f5e067c1f0aad566931677aa70c10b7245f5d7cdca832038fdf2bb34865c9f43e29562dc4b2f966068c75e364868015e4d74084cd45d1c7ccedbb21d041a151f7d28c1efef3450e550c005ed5e618f0f3c580554215d5da234796ca83bc9404cf44e3d9a088e4353af370e751701", + "data": { + "slot": "8358322974291342887", + "index": "8356670491074658759", + "beacon_block_root": "0xe880db73e7fbda953dac9f899d4e54fe801075c269f16333c22d6daf97a66d20", + "source": { + "epoch": "971690237", + "root": "0xc23ee773a7641c0c5326d132f53c2b64730a779efc5f12bf662be61ee2e4fe0a" + }, + "target": { + "epoch": "972074986", + "root": "0x3505c473672a58a912b83c37eb71a632991c710a4214071c79327bd0012a4b4b" + } + }, + "inclusion_delay": "8340145650317882887", + "proposer_index": "8345103104262902567" + }, + { + "aggregation_bits": "0x46b108cad5182afce52fbf6759968538f48f70d2ee7dd77364dcfe9a307231e9ed5d7fd0d57e787b778a2dacb26dcd56940c1315cd71d58e10a6f956c4d2947e810767162468e6f5f8a26d7cb6d3bac95e3ae941faa25f3ac59a247095c467d65caf9b4118d61ed9414357276cfa2012b0030ab965c44d32c404e111299fc57131a34115e61a663d66072ad9fc8f44fa9316b3b6ea89fac31eb35632b8bd5751a07d49890bc7875f37e03b90798c38224108d528698dda30c3f9444459383a63af9e5274ac414ce26fb9eca3b3025e77f14ba100b98146d8a9f11c88d78baaea41104954c5e629d93535d9c73a9ea53985abcc41126d4938ab8e81af138c361701", + "data": { + "slot": "8333535713156179078", + "index": "8338493167101198759", + "beacon_block_root": "0x6e68b273460df677f28072b9660ce499ac256ec0656e814a02b64529904c71eb", + "source": { + "epoch": "975730101", + "root": "0x7d0c4b74085f48790ab4f550e826cec509d787ece00b5d625c976ad26276d1d4" + }, + "target": { + "epoch": "976114850", + "root": "0x57ca5674c8c789ef1f2e27fa4015a52bfdd089c8737a0bee0095e341adb462bf" + } + }, + "inclusion_delay": "8374847815048118759", + "proposer_index": "8373195327536467335" + }, + { + "aggregation_bits": "0xa40ac12101202436223bd2c552f30b15a07aeb0fe943db24516f3dc02c3f75ca9fc658af812c556b1e31cb82a3019d1607c48a2418f9bf2e4ae18ae21a5838f3ce56d80277d77b6e2a3bd41f995f58dee89338941d4063b52e15a1d6caf2a6c0b9cd8d6d548f867e200d9920d06357df8e9f10397bc447babfca6b27d23711a2044264836e42a53baf51691b4a2120e5810a66abe6fa8356e5a41bc8a0ef9264433f3bce0b4e48637e719eb579ba12cf0f1f7573f840fd7a95cfc872be6d6f972703c2d29d7927224bd0e147c78c5e638589d5e9672573f25f61f1f0902319673e20202d560503494531595d3d16d454c7a07a275a1dc4f07d036c50abc21b2f01", + "data": { + "slot": "8368237877886414951", + "index": "8366585390374763527", + "beacon_block_root": "0xddb12d7427d9a4d1d402fa290ad334c728e682c670f72805411dbcbba65a668a", + "source": { + "epoch": "974383480", + "root": "0x50780a74e79ee06e9394652e0008b0954ef87c32b6ab1d625424516dc49fb2ca" + }, + "target": { + "epoch": "973229233", + "root": "0x29361674a70722e5a90e97d758f686fb41f27e0e491accedf821cadc0fde43b5" + } + }, + "inclusion_delay": "8363280423941395271", + "proposer_index": "8302138519154278758" + }, + { + "aggregation_bits": "0x1eb29137998b64a4b5effb0db9784a95eeb3075e35b9ba00ca226a2e9230967916e77f1b690f2dbe5e96eb419f81b1822f6b7fedaf9c1d60c8239b29459183a4b61a17c229382c5abfb1e38f176f87b348369b79d48e5de2f6c8bace1454102ac9df84546ab0104cb5d1fcd745caf2d40104e19d13719c2bb075c74bad99e370056fa00f3a9433460ad5db880ba4d7ec8a709e53bf9d3173b0474149d466b3acf53d8f5221b315258a48c44e5ffe2e7b7b7afbd4b823f4c663c22a56af3b0e85a23f8c67ab65910bceb18fb82e9995e1bedd8c2cd329b30e2382016d9045119a21966e03e3ea01152ed7b4f65293bb34368a859c22bf8b9075cf1a8d859aa97701", + "data": { + "slot": "8303791002370962886", + "index": "8295528586287542245", + "beacon_block_root": "0x5fc4197385bba376da4def21e4f1f96d4e745494ead0a532a8d42080be221102", + "source": { + "epoch": "966111378", + "root": "0x388225734524e5ecefc720cb3de0d0d3426e56707d3f54be4dd299ef0961a2ec" + }, + "target": { + "epoch": "964957132", + "root": "0xab48027305ea208aaf598ccf33154ca2678050dcc3f3481b5fd92ea127a6ee2c" + } + }, + "inclusion_delay": "8292223615559206693", + "proposer_index": "8290571132342522565" + }, + { + "aggregation_bits": "0x4a5bc3224104d327f28a577e2f44d34db97fa414068465c27c935e4b563927c72358d03f25644aba017eac640bda4fb98b486f21e71e446a2907d46898349806b5cbff083bbce2c33cf73dc9f208aab6e377617506f390150b65608d54e9fe7b18b4285c0ce7c4451683a3c8d4e59f33ee99ccc00757c785eba29550a65efc63361d2c757d7bf506aa064f91bdc854a96d2f4689c50d5f2c951255600daf93a4d43a1c79d8849d40297c85e21fe230fa4a90f9a182fa747244683eef93433f53792cdfad049e8d92286a1c4a4643b93437e955607b03eca20e08fdbd6a9f09e458440bcbcc5865bc40dc98c9d0a2f388ba738f9f961a6b4331ff5632524ac26701", + "data": { + "slot": "8285613678397502885", + "index": "8283961195180818757", + "beacon_block_root": "0xce0d9573668752d0bccf769288b84a9bcb34699af5594dede73b9712d43006a1", + "source": { + "epoch": "969381744", + "root": "0xa7cba07326f09346d249a83be1a62101be2e6b7688c8fb788b3910821f6f978b" + }, + "target": { + "epoch": "969766493", + "root": "0x1a927d73e6b5cfe391db1340d7db9ccfe44065e2ce7cf0d59e40a5333db4e3cb" + } + }, + "inclusion_delay": "8320315843127738758", + "proposer_index": "8325273297072758438" + }, + { + "aggregation_bits": "0xa670da8262b1f08a1ed46c2ab0443c802a9211b09a3d2ae73e940e649edf9150fef1446d9d4de69271cfb9bf99f80186da5068e895bbd48ff593f0e790a0a335a86b8e503180b06822e3b4b0dc3879210d3e6286b3c637e0247af9329709a5050730526cc1542b19497984459f36c78c47d6709856dca177caa8276dd3e094ad934f4455c996c3dd2ae5b953c2da1ad26263ffbe0527bc2102af838d043dffd96797133c0e82750eb41a9c181a894b56e4636775bdeeeae30e8929ebac41d86392e0370b32210dca9929104b6d011eee0bd8c431f02343d2ccd47401916ced871118db534827e2a797e43df4b8fb2a4d38c135cdfac3b7b7ece6c08e1c40f02101", + "data": { + "slot": "8313705905966034950", + "index": "8318663359911054630", + "beacon_block_root": "0x53f56b73c6986db271a449c25276da36f7496298f1d66a0427c46f8cccd6096c", + "source": { + "epoch": "967265625", + "root": "0xc6bb4873865ea94f3036b5c647ab55051c5c5c04378b5f613acb043eeb1b56ac" + }, + "target": { + "epoch": "967650374", + "root": "0xa079547346c7eac546b0e66fa0992c6b10565ee0caf90deddec87dad365ae796" + } + }, + "inclusion_delay": "13748725597936915948", + "proposer_index": "13747073110425264524" + }, + { + "aggregation_bits": "0x81b07794e590d1795b2b9f0fe9804f31f87caba4425e21bc01b55fc9a877824000b28b1d253b79dd6e3604db9038b6c464be9a72dfaa65f9cd80d06f508f22bf97fe839406939ab55af6c1013d84ae75545ca6edbb09d7f4fe8a7b48e7543b4a056a9f3bdc90cf3034adbd60a1c6805b4927c601a38d6f9986945c73ab01be1b2a3f35993fdf7c6b092189c493e8c100738ee3f19af116e1251f41b7da7972688773391b77a7cd52cdab7a234d89c42f3173771214215ebf144bc508031b4a4064da69bdb1e69116c0ac75580a43e824e181713cea4edeaf6078b12d5a4e6afa373c9cad7a5d33afc7f6d17661a002c8e2a3b3ac1c249b1aeb3289afa65a275c01", + "data": { + "slot": "13742115660775212139", + "index": "13740463173263560715", + "beacon_block_root": "0x3c8bc1be2c2d18ed9f6f3bceb2b25a9ec67a102b1a4b1337d72337c28f04ec68", + "source": { + "epoch": "599985191", + "root": "0xaf519ebeebf2538a5e01a7d2a7e7d56cec8c0a9760ff0794e92acc73ae4938a9" + }, + "target": { + "epoch": "598830945", + "root": "0x880faabeab5b9500747bd87b00d6acd2df860c73f36db61f8e2845e3f987c993" + } + }, + "inclusion_delay": "13737158211125159755", + "proposer_index": "13728895786451804523" + }, + { + "aggregation_bits": "0x91e48c6fd1eee97f538a75e38d562e0e0357dd3656f401fe3fc0d98e800a9dc7e45b9b05af7e67762187c353af3d7531b48b7b9617a058d46dbfd7e501a976795346ff41860dd3b06541b3d0a655ad07f4701c260af6c6ed079c0f9c2ea50ea8e9f154afb4641ad626064b821cc7e5ed2c6f3d2f6866c57b01c59d611c46b3606d70b2cbc8a6fe7e0355cbb4fcaf556cda7054b0717dbdf69519cb52742d8c49e41350cf19fe37ca703c1a0ef7aa52cf52ee6df8f0b94165f4c9e18b9f6ac949e27d608659a4112abb2ae71d757a664e08c1c91d4fc6136879934cfdeda9204e3ee9cb67543e76ff2b4e96cb01430edaee4a8238445d546decedfaad46c9445c01", + "data": { + "slot": "13730548273963455947", + "index": "13775165337993796588", + "beacon_block_root": "0xf75825bf8c27445a56fd5feca49cfdff5c472179fef65ddacd8fbb750f96be32", + "source": { + "epoch": "604025055", + "root": "0xd11631bf4c9085d06b779195fd8ad4655041235591650c66718d34e55ad44f1d" + }, + "target": { + "epoch": "602870808", + "root": "0x44dd0dbf0c56c16d2b09fd99f2bf4f3475531dc1d71901c38494c99678199c5d" + } + }, + "inclusion_delay": "13771860367265461036", + "proposer_index": "13770207888343744204" + }, + { + "aggregation_bits": "0xe36840b4b222707629040a6ce6fb53fe3b750fe0c4fe7147fe4e1984f6b82d2ca164a80b83ef6654a26744a1b4c30b81b1144dce75f8b49771b0b980a7de43bfc9df86341f6943bfe7d49f9876d150ee11c450af6e6e5df6c1f22eb46e2184bd294b4d276355b6f50125fbe37e7ab92f45b277a7f02642f1f841f5d38dc9cd5c3d5f80d7e06d8ffc0d03aec3f2a640678253a21b826bed951bf386176ee61f5c0500e2fe59b6a8307b28ad659237a1019e49fafdd189c31efb14efbae4e7ae3f16d61e85b9a21e3306b07099491b6f5b5480b001dcf42654cd2754d242f33e6347fa38b99315184c5c8cdcdfc4489771d88941317c122f54181732a47a8166ae01", + "data": { + "slot": "13765250434398724524", + "index": "13763597951182040396", + "beacon_block_root": "0xc9c4e4be6c67dc4fdfddcfc9bc7ddfcfa16816bfd3961edac41ca21071bf9f28", + "source": { + "epoch": "601139438", + "root": "0xa382f0be2cd01dc6f5570173146cb6359462189b6705cd65681a1b80bcfd3013" + }, + "target": { + "epoch": "601524187", + "root": "0x796b11beea0943ff5c4855e47ebbc2a682d5f24678d0da073447203a275e69aa" + } + }, + "inclusion_delay": "13694193626016535946", + "proposer_index": "13699151079961555626" + }, + { + "aggregation_bits": "0xbdc02ee74a8471f627f521e9cf545e04ef54d39a101091b16570c46888c72eca05859e8f4dc68c97c11c54b2c865243d096ab895cadc8a58bb72284b77263a8db3a8edc2c091b3dd7e1f890f3ce14da63f7135ddd1ffe2b3916e1dedb8913a8b1a5f070e6d6262e594f99414e8d118648139d70f981729f4fff45d3bbe43e716382034cff85f3a1c8c8d7918eb40f73f18a94cb9cb1c8bbf4a50dfba5a691eb1874e51681a4ab176258072de2c2a99968b0d694c5b9de1362f0831969f85dca4587ac6658e267b8422498566e4dc0dea6bf46de47c18aea1d4ccaccf2e8d5ed25df4e6d7024e0ef19d6921ffcdc9bdb70654f6c6a5d0e21ca8c7657897bc701201", + "data": { + "slot": "13687583693149799434", + "index": "13692541138504884522", + "beacon_block_root": "0xb2ceffbdcaece0cd3b118b66f955000e95deeffc9b2a5536bdcaea92b6808f4a", + "source": { + "epoch": "592867337", + "root": "0x2595dcbd8ab21c6bfba2f66aef8a7bdcbaf0e968e1de4993d0d17f44d4c5db8a" + }, + "target": { + "epoch": "593252086", + "root": "0xff52e8bd4a1b5ee1101d281448795242aeeaeb44744df81e74cff8b31f046d75" + } + }, + "inclusion_delay": "13676016302043075946", + "proposer_index": "13674363818826391818" + }, + { + "aggregation_bits": "0xd78fc7c7d5d292ac051c06feeac478bf0ee6e9fe0ebda983e68d497fe6518bd9b04e36ea77c6c5f1df77508bc69aeefbfddf1d823598d813cdb26f9115b3798907a8c74f5c19c260c49bd367e21c3d6a55151df666ac0bc2e87b6752ef0a97c52420c79e0347817a30c4972e8eb447f970e0f9d768f50d4c6da1b9a2dbf78a2a69ee56676f8a59c18f23cfbaebc941b08e50c99df8390a1a13f84a8601ff3abd904e450628143df437a3956cbcd9d8434076d1411b8bff550fa9890d943d83d93cf4a94fda73c090d0f090f59ffa7414ccef1225ff04b18e6e2025c8c8ae9345269793598d3642325237dfc7d869596ded908de3ed5b7e7f74cdfd1c9117102401", + "data": { + "slot": "13722285849290100715", + "index": "13720633370368383883", + "beacon_block_root": "0x21187bbeabb88f271e9312d79d1c513b119f0403a6b3fcf0fc316125cc8e84e9", + "source": { + "epoch": "597676698", + "root": "0x94de57be6b7ecbc4dd247edb9351cc0937b1fe6eec67f14d0e39f6d6ead3d029" + }, + "target": { + "epoch": "596522451", + "root": "0x6e9c63be2be70c3bf29eaf84ec3fa36f2aab004b7fd69fd9b3366f4635126214" + } + }, + "inclusion_delay": "13717328403935015627", + "proposer_index": "13709065979261660395" + }, + { + "aggregation_bits": "0x39ad7c47f417411aec5ea2fa8dd596359d1956599b10c632eeaa1b361e5731336bbfa0c8c7d961b3378201557eb8b4e082d56d4f8674188580264e67371bd1765a50973fd617e6cf8f0f1a9c6e2ce36def17dfd3f1f32fe7c2f889cf25a994333f2e9186c9876e324a1cb8f1df0317c37a8e6f245f680fff0789528f6e99ec5c6c74bbcbc985fd121de4196824fa1f53820670fdfc93eb5aa167a2fd80f106c023221a023cdac0ffeac00516b9aabb6ff08d4e8515dfe0929561d8b0a0ee2f228e78c5f3e6c5414f6ab619f4bff166fff248a3407374dab69894b0663b3ed2ae7fe1584103adfb8805073a98883782ac0aaac3918c92bcecbb855b300bbd5aea01", + "data": { + "slot": "13710718462478344523", + "index": "13702456046394923882", + "beacon_block_root": "0x400823be0a27a5307c7f1f620421853f6fccf590557660d9aac355e1973b430a", + "source": { + "epoch": "595560579", + "root": "0x1ac62ebecb8fe6a692f9500b5c0f5ca563c6f76ce8e40e654fc1ce50e379d4f4" + }, + "target": { + "epoch": "588250350", + "root": "0xefae4fbd89c90be0f8e9a47cc65e68165039d218f9af1c071aeed30a4dda0c8c" + } + }, + "inclusion_delay": "13646271591257859753", + "proposer_index": "13644619108041175625" + }, + { + "aggregation_bits": "0xa380265a4e5b8ab538cb48fd394a0053eae32576e07b35b2fa37411cfe967864bde00970b5f69c5c7ff0806f234a576714cfce61a13cbbb4c23b12374130fff19654d5e61aa4a5defe464dba7d2a6f9a845c6d4b342fad98bf916d10395e21fec2c4b423796aa8dbc23824f1628b6661efa321d4bacd2d534184797261b6de006dfe9334578e9b6f84855f04baace7cd049ef59670192e50d8e2da6aa77aec25633314b7a31ca74970367e3c4455902a929074d5ba6f5f46ee0a891d15f69f9c2449ebed27f0fa34710ed38e4b050f4bedf2bf4c6ea438f4977565fba09ae59f17820d2b33f049360c06f8591bfd6e038d0e359d81a7c04c3aaa2eb90264873c01", + "data": { + "slot": "13639661654096155945", + "index": "13638009175174439113", + "beacon_block_root": "0x759626bde9da26c2adbe77ac901cf8b17c4ecb16f62c3a1e5a76ac8446801057", + "source": { + "epoch": "586518980", + "root": "0x4f5432bda9436838c338a955e80acf176f48cdf2899be8a9ff7325f491bea141" + }, + "target": { + "epoch": "586903729", + "root": "0xc11a0fbd6909a4d582ca145ade3f4ae6955ac75ecf4fdd06127bbaa5af03ee81" + } + }, + "inclusion_delay": "13621484334417663241", + "proposer_index": "13626441784067715625" + }, + { + "aggregation_bits": "0x65a3ddda1fef8d81dc89aebc4edaaebf397edbf2fd977a35227c359616f986a246619d7203e5187ea75b14b2b3ea4dfc27d5ca6c42ad73833eee2199e3b413969bf407fed2932461345640c2d09aa18f4845ae188b1ac229d48a41afc2fc7800d8564532fcec4707f8c6031e7945bf9bd6f6afee4b1552e37badbf4d050cbc4839a479b3715119300066bbd6dd30a916687d48b6a4b0cd7b5f6f3247b6fc1030d27f0c975b3d4851af7165ce43234b84ba6afa11ac5c40a5aca03ca10a272abf93050ad211461b61fed9d9cf6f1331d3d175861b6d9ee1c40599f54e731a00340ddcd285b38fc6849d388505ca03b4436a34af2fed1e9c99f7b32045b06a27f601", + "data": { + "slot": "13667753881664688010", + "index": "13672711331314740394", + "beacon_block_root": "0x985bb9bd4a785808ba34626fe5bff6aae002e4d427933ef0e2d814f6f20a28cb", + "source": { + "epoch": "590558843", + "root": "0x0a2296bd093e94a57ac6cd73dbf471790515de406d47334df5dfa9a71150740b" + }, + "target": { + "epoch": "590943592", + "root": "0xe4dfa1bdcaa6d51b8f40ff1c33e348dff90ee01c00b6e1d899dd22175c8e05f6" + } + }, + "inclusion_delay": "13656186494852931817", + "proposer_index": "13654534011636247689" + }, + { + "aggregation_bits": "0x25e41cbe7b2b38d9fad489afcbd9c80478ed82c573eb220784d03762386767b5dbba2f8737d03679c85a8089c567863bd3018729b78a89442e15763149c3549327982f37cd4db4d8282a4e292abff148663081237c286248051b993084ca8d18e7f5c3b994eea4f20cdf2c907d58e0c72656c899fc93c779e96b3ee6a54ac5664b603d972084fe8981c81c1065940f10f2b3f5ca57974c7087cfcbb9d96616324d4557f925d06ef0d4748a74cfc08656e111520c7e684ef3d2d1a8326baded53ea8b6d720c1b85e185e86d0750b3247c74667318a3a424d05e1579dff52b39a2769f28322bf70f5f5266117c7f87551d33f0960985d59a93a92893a5be781f8101", + "data": { + "slot": "13649576557691228009", + "index": "13647924074474543881", + "beacon_block_root": "0x6ac778bd29b8f0fd4415d24cfda0d87a2424d91afd32ffefda65fb90543409c1", + "source": { + "epoch": "589212222", + "root": "0x3fb099bce8f11537ab0526be67f0e4eb1297b3c60efe0c92a592004bbf944158" + }, + "target": { + "epoch": "581901993", + "root": "0x196ea5bca85a57adc07f5767bfdebb510591b5a2a16cbb1d499079ba0ad3d242" + } + }, + "inclusion_delay": "13591739619337479752", + "proposer_index": "13583477203254059112" + }, + { + "aggregation_bits": "0x5b0456e9208eea1bc551a4276962c598148433ff379452d14ebf63ad0e3d74574ec240b3f4c0ceba987c44b96dc3f28f6d8e7af601af362232eb6fc8979b6db951e006e583b2a6b4978831b360f7ac51f93f60ceedb79c17fdc10a6172fb33f8d680c70adb1e08c0fb836342c8f2415de1dc31b5188600deee847618502627204ecdac926c77e88c1dc2fe81e53098f920472d311ff078f196f6f3a4cd6b35a9d603eb6e673073a661d85cc369c8baedf41d04e97e2666c20cddd2077cfd87c8a86fa19a729707c65a8b58b18de226acd11aae90016cf73642b089c4d94f0b52ddb9745c9a093c62dba0fe3f56427a5e1e4e27fc7db755d799f64d7a14e0d35f01", + "data": { + "slot": "13585129686470743240", + "index": "13576867266092355303", + "beacon_block_root": "0xebd964bc879aefa24a60c744d7bf9d214ab2aae8770c7c1d411d60556cfcb338", + "source": { + "epoch": "580940121", + "root": "0xc59770bc470331195fdaf8ed30ae74873eacacc40a7b2aa9e51ad9c4b73a4523" + }, + "target": { + "epoch": "579785874", + "root": "0x385e4dbc07c96cb61f6c64f226e3ef5563bea630502f1f06f8216e76d67f9163" + } + }, + "inclusion_delay": "13573562295364019751", + "proposer_index": "13571909816442302919" + }, + { + "aggregation_bits": "0x6969fcb290b275d2e74fdfa83c8b3c223ccc8f18315e9328d921398670aad0bca261b29ce274ceb958b5926a067c94b73b110c886647fa672daf19871f6c9cef86383fb48b4056c1915f547ee54a23f2ff68f08caf090f060a710f41175df32dd01ffc0ed9cdbc4b3f039475e15f058f986c190700c7f734c709df2cb4cfd41e9e121e0c583c3a0b84169ca6fafda9403c48c94aafb769104c9fdbf143aac4a6bf18495ab27df24cabdcebad1f1c0143b0f384985f0eeecb4b109c224060e9be7507a710f8928fd5a592af34910163fa277b566fbb46782ada2a9cfa340f0b7807828238ff231251ac4668ca9e09e3f578ede47f29ec3eea6dc20da86198d08801", + "data": { + "slot": "13619831851200979112", + "index": "13618179363689327688", + "beacon_block_root": "0x5a23e0bc68669efc2ce24eb57b86ee4ec772bfee829523d88084d6e7820aa9d7", + "source": { + "epoch": "584210486", + "root": "0x34e1ebbc28cfdf72415c805ed474c5b4ba6cc1ca1504d26324824f57ce483ac2" + }, + "target": { + "epoch": "584595235", + "root": "0xa7a7c8bce8941b1001eeeb62caa94083e07ebb365bb8c6c03789e408ec8d8602" + } + }, + "inclusion_delay": "13601654527227519112", + "proposer_index": "13606611972582604200" + }, + { + "aggregation_bits": "0x29bda59d8add6b54ac7e3741c0dec814c787affb7034d22af20871c189dfdb3ff48c72812a24949a878544c16b9f03ca32b56df7b8efe7186f4e0e56377aed300781432589181ddc28f23ea62b0b36808f0700513afed61d6b595eec9be68edf78881d9a215d0885aea92091564a5809eeaeb8b9d909f5b7101979be20805d7bdb6c1c549d57187b1160dee8ac2e1d7eb11f6c9b874cd723300139f4ed31629dc5497b0e48650097551d99852433cfebab641042fbca6979a75210acfd8563a5ca2c92a3e0938f63df07bf4b7e3aada2fe238f803ef204dd0fe565aac5604d0efc57dd7063d0d791c08b733572caaac5f50545c63583e552489fb6f88f86818c01", + "data": { + "slot": "13595044590065815304", + "index": "13600002039715867688", + "beacon_block_root": "0xe00ab7bcc877b9dee0b621e544447eeaf387b8ec7e1241efc00caf617bb0aca2", + "source": { + "epoch": "625186244", + "root": "0x9ce0b6c1911193380cb232ef0dc00147a0f48f9937278668c60b33d884368482" + }, + "target": { + "epoch": "625570993", + "root": "0x769ec2c1517ad4ae212c649866aed8ac94ee9175ca9534f46b09ac47d074156d" + } + }, + "inclusion_delay": "13953633602705093745", + "proposer_index": "13951981123783376913" + }, + { + "aggregation_bits": "0xbb8ede052586631b3cb1e1a0b09dfadca0acb0e0b9dc839c4e52689cd2db83def30014882aa202c5f7ef9f3357717ffee896893a07376ef6755c9f1d74e13cee18671cddc3b65cd877832e5e657ba0cccdf4730e982a9691227dcc94c506895db28708201dd8ed30c4fcec08270bab366da9991d35f9102af0578ecb7c6a7a6f4fa308e04bb5fc45191578192cc3489151d145a38aefb40ba0bb020439bd8d6f9b3c7a0904fbe8d73bae573c562eed075fe935cb20db17747c31c6d18e014c703a1d3df4ea544bdefd50f52b6a14defb39ff68e114343f10676d1b13c13180043e1cf48c55346420d3ed743be8f1ec6f20b4063a3e6e1dc22216f128b09d234401", + "data": { + "slot": "13947023669838357233", + "index": "13945371186621673104", + "beacon_block_root": "0xfc8599c1b18bef90d60037c8306c6848bf038b73c712520bab9184c1c81a1938", + "source": { + "epoch": "623839623", + "root": "0x6e4c76c170512b2e9592a2cc25a1e316e51585df0dc74668be981973e75f6578" + }, + "target": { + "epoch": "622685376", + "root": "0x480a82c130ba6ca4ab0cd4757e8fba7cd80f87bba035f5f3629692e2329ef662" + } + }, + "inclusion_delay": "13942066215893337552", + "proposer_index": "13986683279923678193" + }, + { + "aggregation_bits": "0x75fd2785476200e555ebd0a6958d116433755ee47519889466e07af33afdbd00ae8840c21a09a6a723589bbce75ba125038c4e6b3cf2e6c102c8b5af176fd6cd078b59c1cf99dc56bed772a6630b67cb276e212f83fd78640c4e141b16be53a28f19f03919100e49d264e3f7763cf3ce848f2766044032db9e5b24f40af194c74dfb6064f5680c9ed9f6aa5e63d117f62222d8934fce571432565a2c302fa1590235608de0ff3dddf6cd7acd124de4a9f540a70f3fdf2ab6e61a434cb3d0b9c18015517b4a4acb9b6597eb2a45d79d020c4a7136100084209790ebe63ad481042700d936d365ef9905970537218bf7bceeaab90973b7e3129d6f56243616859001", + "data": { + "slot": "13988335767435329618", + "index": "13980073347056941681", + "beacon_block_root": "0xb753fdc111861bfe8d8e5be622560baa55d09bc1abbe9caea1fd087548aceb01", + "source": { + "epoch": "627879487", + "root": "0x911109c2d1ee5c74a3088d8f7b44e20f49ca9d9d3e2d4b3a46fb81e493ea7cec" + }, + "target": { + "epoch": "626725240", + "root": "0x03d8e5c191b49811629af89370795dde6edc970984e13f9758021796b12fc92c" + } + }, + "inclusion_delay": "13976768380623573425", + "proposer_index": "13975115893111922001" + }, + { + "aggregation_bits": "0x41347d1592f5e4d454ec75dfa961e67068bbeda6723c137590f0769c5a34289613823bd64466cd687c37cf4b504fce2ab5aa1c2fbc6dffd9a06cf79207811c6746163b3dc84df2ed2883bc6f8667525f98c88e3a5c43149b7087a738a653bc78ce22da396eaff035ed7cbe8aee33b66073ff58bab576ef5784cf667f64140ab4da02bcaebe8daed625364b4a75edd59f790c5068b157d95b134300de69f3c8da9fb2e3c40acbddf48ed913729293be39c0b0a95184c6ac5196e6c7f50cfb08075b6f46886fb0e1930a4cb0daed8c5555045f28b42a8edbad433a1f74440e84784ed2549cecdc0791605f79400f08fc4046bfb10976da2181e05f4e3369e77d8301", + "data": { + "slot": "13970158443461869617", + "index": "13968505960245185489", + "beacon_block_root": "0xece100c1f0399d8fbecdb330ae517e1c625271474c7576f351b05f18f6f0b84e", + "source": { + "epoch": "618837887", + "root": "0xc69f0cc1b0a2de05d447e5d907405582554c7323dfe3247ff6add887412f4a39" + }, + "target": { + "epoch": "619222636", + "root": "0x3966e9c06f681aa393d950defc74d0507b5e6d8f259819dc08b56d3960749679" + } + }, + "inclusion_delay": "13899101635079681039", + "proposer_index": "13904059084729733423" + }, + { + "aggregation_bits": "0xbf8c41266a46e5960d385f5a8a5ee2ec2e3019deb98236920a8f6a724079ff24b2370d5a864795a95811cf5c65a9633a0d62c9f00ac931872eaeef7f5259a70a3a7672cf8776f5c8f248cfe1481fcf1220ebe85ca75cabc4081a9d657840439ebc72d602027a48066faad1756a3893caa434a813394312748321cbc379b820625bbfa8bb677e1ab399b838d475784ab832fc9af27a70af5c4fb03d419d6e20041114563a113d8cfe72cf458a14be86a0d0b82bf544e5b8fa41b917e36eac6a94b7bb2824531c650d85fb65224281b6c5b7aae03b88a25f5c6799cfeee07294a851648bf65907093681ba84336cce531ae1dbc7b82e3b6c814097dcc7862e7ddb01", + "data": { + "slot": "13892491697917977231", + "index": "13897449151862996911", + "beacon_block_root": "0x72c9d7c04f4bb87173a28660770f0eb88e676a4548f2930a92383892ef96bc19", + "source": { + "epoch": "616721768", + "root": "0xe58fb4c00f11f40e3234f2646d448986b37964b18ea68867a43fcd430ddc085a" + }, + "target": { + "epoch": "617106517", + "root": "0xbe4dc0c0cf79358548ae230ec63260eca773668d221537f3493d46b3581a9a44" + } + }, + "inclusion_delay": "13933803799809916912", + "proposer_index": "13932151312298265488" + }, + { + "aggregation_bits": "0x73b709eddadefb56d32d32f3b30d4aed76878a0afcfb33011dbffa225cf62b06d8a8af6de211b04dddaa0d614efd167fd6d830df9c02bf27b269c6df03b19bb5306375cd97c8ea453bdf37162f5b65a796c3f8df46a6b14bc3bd1ae7b747c9825940610d8c5b9dc48ce75712646f0cd8ba0ba0ce86d3d84cf0af4aa5e2262db16e6f459c6221ffb5d5e6ba3372d606b960376bed644be243b4f50399913d81eb7b46a5fe059f13e2a179d4ac2d23ed0f8fce9f96d13884d7a6bffbe6f9933af27646b80b65740e2b22e089c2a09f9e89d27680d260b6be7cc523429205c22a612e54439aca672a4c5398fcb1ef17e00fd7d07dc45620e149574a5c11f7f860a201", + "data": { + "slot": "13927193862648213104", + "index": "13925541375136561680", + "beacon_block_root": "0xe11253c1301767cb55240ed11bd65ee50a287f4b537b3bc5d09fae2405a5b1b8", + "source": { + "epoch": "621531130", + "root": "0x53d92fc1f0dca26814b679d5110bdab3303a79b7992f3022e3a643d623eafdf8" + }, + "target": { + "epoch": "620376883", + "root": "0x2d973bc1b045e4de2a30ab7e6af9b01923347b932c9edead88a4bc456e288fe3" + } + }, + "inclusion_delay": "13922236408703193424", + "proposer_index": "13913973992619772784" + }, + { + "aggregation_bits": "0x33e169e4f680e170c914d80ff6cd23fb8dccbc5d29d3708624de7424a89944859c65bf950a50ba8f0adb4fbbbae4e16f8eecf0a0dced130b5218cf7053730e6b989b0d3e013ae4cb00704dc2bc9ae9d4e6af820cc659663432bc494367fc9c61db57a839c44f6469b14de1f0594a594c6d8114f07e3cb2de316fc8343f642ab42d274712956e5d3750d1f8f51e99a2c179d082ae6fbec9f840d9631c61e650f63da01d32ffa6253b1db5b3929d3eb2c7a0d10d7d6bc78bdd4fb83fc945f6b35a7079b09eb98d1e5d454dd9af9ca749f228372a3d5542070b9ec97b42b405689d76eb74e3440cd64d1a74bf068946cc59f93d75f88e48137a521727931a7b21e201", + "data": { + "slot": "13915626475836456912", + "index": "13854484566754373102", + "beacon_block_root": "0x63253fc08ef965705b6f03c9f6f4238c30b65019cd54b8f2385713e91d6d5c30", + "source": { + "epoch": "613259028", + "root": "0x3ce34ac04e62a7e670e934724ee3faf124b052f560c3667edc548c5868abed1a" + }, + "target": { + "epoch": "612104782", + "root": "0xafa927c00e28e383307ba076441876c049c24c61a7775bdbef5b210a86f0395b" + } + }, + "inclusion_delay": "13851179600321004846", + "proposer_index": "13849527117104320718" + }, + { + "aggregation_bits": "0xbbde0bce6f581dd569a7774aecdeb0fd698acd7015d8868eb0d18a226612e9928c36baf5775de74cc7ed8207cc168cc050f6bdc45ca5f46b1927de056fc189a84fdecac7dfa8b79e55b30e560d7c7d2f9db6f90e8903e4eb53fcd398bd49fb39f529c83eb43bdb8b38716498706b64fcf8bc4e8bfbd0c0c37f47e38a8e4b19792c2bab070a6f9a0a15f03cb9559656746ec84bedd17408f1585a5891647d9a937c601341706482c145f3cabb4fd19fdec820735cafb7561f0f1a0e40d4ff21a4697da0e9d983a5972eb11799bf9279c631ae383338b2e53f902ecedfa6663c641e0ae988507dccf970f5ddb690eec6bb5a2184e5803fcef2ea86567675a2188401", + "data": { + "slot": "13844569663159301038", + "index": "13842917179942616910", + "beacon_block_root": "0x3591febf6e39fe65e44f73a60ed6055c75d7455fa3f478f22fe4f9837f963d26", + "source": { + "epoch": "610373412", + "root": "0x0e4f0ac02ea23fdcfac9a44f66c4dcc168d1473b3663277ed4e172f3cad4ce10" + }, + "target": { + "epoch": "610758161", + "root": "0x1ef3a2c0eff391dd12fd27e7e8dec6edc6826167b10003962ec3979c9cfe2efa" + } + }, + "inclusion_delay": "13879271827889536911", + "proposer_index": "13884229281834556591" + }, + { + "aggregation_bits": "0x57edf04a3de938e385e3c81f51cf5b5569fb72b45d25cc8c78c2588eac54579cf18f92afcee44364b61c97787c3682cb23fc7b210b6070dcc1b3fede05482017167b9fb757b687751a07568d222ca93273eefba91c70834e3ddfce032a68c944eebddaad3fe83cf606916b67ed6cb4c4f2f3d0e28643ea510d4b2d75e7e57dbcf873c58b2db2b9d397136a6a6b041097033af7e1d5defdb0dbcba3fc757ba704cb7d0d8530407f84c810da624fb234b0f0b2b8c9a0822becd4791fdce53b8c07ce4556fb4c1c24ebd46719940c04d67400238d46f5a21e5b0492066055a55e65057c38a090ccc323814700986b125ff699331f17e4f4fa4d16fdf9cee24a3aee01", + "data": { + "slot": "13872661890727833103", + "index": "13877619344672852783", + "beacon_block_root": "0x575691c0cfd62facf1c55d6963790455d98b5e1dd45a7dc4b74662f52b21559a", + "source": { + "epoch": "614413275", + "root": "0xca1c6ec08f9c6b49b157c96d59ae7f23fe9d58891a0f7221c94df7a64a66a1da" + }, + "target": { + "epoch": "614798024", + "root": "0xa4da79c04f05adbfc6d1fa16b19c5689f2975a65ae7d20ad6e4b701695a432c5" + } + }, + "inclusion_delay": "13861094503916076910", + "proposer_index": "13859442020699392782" + }, + { + "aggregation_bits": "0xbfea210cdbfc59bba712e61a84dd7dee8aa7e881d358903ffb8fdd75c6c2762b6a04183efb498549331792ea33eb5917d335d6c4f60702ebbb49f8856fbf0a5bad179432ce6ac68ea47b0df47041fbb95fce1f9ecb061b1ffc4e063ce65b15cc905c1a2451eedb44e60f78fdcb19ef1b035a930974ef7eef8f99ac79c2b103c228bb34ab3c67cf2cdc79b9cd1aff3ec9c8e5638144bb389fcf7b2c42dae1a1065c5f58ea76c43b240b3135f0d6519122bb6817d081b425bbb94b876b8f81f163a65b397775509a61621ead06e1b40299aeb8f24577ded129df4e925fb714dbda5fb76437043619806e5da6815dd2bbe8c4e3f623ac3f950e48266eb2e9bf56fc01", + "data": { + "slot": "13801605082345644525", + "index": "13799952599128960397", + "beacon_block_root": "0x8ce494bfad8ab13d2205b6b3ef7477c7e50d34a37511570967f9b898da6522e7", + "source": { + "epoch": "606910672", + "root": "0xffaa71bf6d50eddae29621b8e5a9f2950b202e0fbbc54b667a004e4af8aa6e27" + }, + "target": { + "epoch": "605756425", + "root": "0xd9687dbf2db92e51f71053613d98c9fbfe1930eb4f34faf11efec6b943e9ff11" + } + }, + "inclusion_delay": "13796647628400624845", + "proposer_index": "13788385208022236909" + }, + { + "aggregation_bits": "0x614a397e03095839bc2efa8ce27add768ce894fb8f2675db20428a99b4a3b5a3e8613d26b369dda8032982d7ab4d33816b77635f48228d7de587a05eba65ba23dd7fdccc169504bab9e31ab61e4164c466f5b5795698ed791497bce9306be22ee04d101576d14b7653c01363df1bcb10c3d14eb19c9abf6c947b944595dbeb482d9390afa2947be141f78b1e1c428d4c6a191b6b8fcc4a7a9348336faa6e83ce4859e87e250c722ed699630f605ca783ef45c77540cc7c9b4265714e95c697f8076771d307cefa5666b798f8e83dd12285462b7563d21889e7ec20c317f6d1214411df5de1ad19e587fb5bf07715f5abac2811c674b5d24e50ae2dfd07864c2401", + "data": { + "slot": "13790037691238921037", + "index": "13781775275155500396", + "beacon_block_root": "0xabd43cbf0cf9c64681f1c23e5579abcb433b253124d4baf1158bad54a512e107", + "source": { + "epoch": "604794553", + "root": "0x859248bfcc6108bd966bf4e7ae6782313735270db842697dba8826c4f15072f2" + }, + "target": { + "epoch": "609796288", + "root": "0x9436e1bf8eb35abeae9e777f30826c5d94e6403933e04495146a4b6dc37ad2db" + } + }, + "inclusion_delay": "13831349793130860718", + "proposer_index": "13829697309914176590" + }, + { + "aggregation_bits": "0x5b85d1a33095c1b09225a013259508c66680641c98dc241bf39dd4deca06c12387da25412ffd55a5d1e80005d3b3e1117ea91d450eda2128fd82c6b71b32a6e34ba3a2b9c8e681a19f22b33a6ff5bb4fe283667980274e60ba3c8cccff0dd2ab22e6c91419c1ff7b50dbd501ff37cad0aa49561ba4960af6f3ff6974303414e6fdefa2f3865f0be4db232d736bd618d0163f5fa97ecadeff4d63382ae0ad3392af0248ea7900f598de0d55030cb91cede54bc2404a54c58444ea377fad48db9e3a4eff1486e3f067fb28af7c51565577fe055f1a652468d3523b145c7ab0ad002e02ea9fa08e05d4f8745d95970a0c44ba6fd3c50836a03f94c0f12f73de6ee001", + "data": { + "slot": "13824739855969156910", + "index": "13823087372752472781", + "beacon_block_root": "0x1a1eb8bfedc475a063734aaff93ffcf8c0fb39372f5d62ac54f223e7bb20d6a6", + "source": { + "epoch": "608064918", + "root": "0xf4dbc3bfad2db71679ed7b58522ed35eb3f53b13c2cb1038f9ef9c56075f6791" + }, + "target": { + "epoch": "608449667", + "root": "0x66a2a0bf6df3f2b3387fe75c48634e2dd907367f088005950bf7310825a4b3d1" + } + }, + "inclusion_delay": "13806562531995696909", + "proposer_index": "13811519985940716589" + }, + { + "aggregation_bits": "0xebed10f1d9733661e6242cc6380e41b9807ec0d9040abcb592c515b37ec0cb97f034ed235def52dd43a819fc6d2bf35ed83b7de8bd458b72b4881fbb004968f46384bc995de8ef714b9426da553800b0d80b31a0d1d2f6de52a41ea34e5c5f072901b1f45ecd757447caae6732167765f8654014455f0c1f9876b90c3dcd40f07030b25c5703f34f3fcfaa7732c32753b26a23280425075ef7a24719942625ff1b902036b95a7bac67c4264a7e4d3fe1dc7ac27cefa5b2592395d83f7492fd00bbcaac49f5d32eed8ceb94f83a2f4428d9aaf65b5bd2c5eafcef46a461b987c3880edcae8acb342e416468ddde52750aacfadd65ff56732e9e5491f7ff0ca49101", + "data": { + "slot": "14170108998579995030", + "index": "14175066452525014710", + "beacon_block_root": "0xe914b2c456aa2e3f84b1c2e496449422746b10769e3ad0df8872eb259f076511", + "source": { + "epoch": "649040676", + "root": "0x5cdb8ec416706adc43432ee98b790ff1997d0ae2e5eec43c9b7980d7be4cb151" + }, + "target": { + "epoch": "649425425", + "root": "0x36999ac4d6d8ab5259bd5f92e467e6568d770cbe785d73c83f77f946098b423c" + } + }, + "inclusion_delay": "14158541611768238838", + "proposer_index": "14156889128551554710" + }, + { + "aggregation_bits": "0x29cbe1b70729d7b144dd8b11ff8d3f1663c15ca619679087780c85966056572a45fd6755ebcb99db6ca31d5801ff2851ac6f28f7c4e2f139a26029a9a2186ef1d4e8a6d45a900fc8bdd03c3297ed3a78b40bdf1b6684ffdf8b3142bc3e53d09f14e6357d904b92c62bb1b57d356226b956a0a241f4a5a9aa98a13f04d19a3c8e0474c05410d6d5f454201935dfa9f925ab07bdd829c28283a00380ef3a383bdb802e7759cf8ebf4d7c47e9b877aef2f30d91fe751b93b83a43a063857c28d2c8574443f0951d34ef3b8f3561cf8bb8d2ea25c9ded40ac0e9ef33521387881a7d76dc0aa916b169e58f1a55852bf38b96d5ae3413b7dd1255c18e049fe1dfb8aa01", + "data": { + "slot": "14151931678901502326", + "index": "14150279195684818198", + "beacon_block_root": "0xbb8071c436eac6340d9232c2ae2576f2b98c05bc74da90df80ffd1c001314607", + "source": { + "epoch": "647694055", + "root": "0xcb240ac5f73b193625c5b5592f40601e163e1fe8ef776cf7dae0f669d45aa6f0" + }, + "target": { + "epoch": "652695791", + "root": "0xa5e215c5b7a45aac3b3fe702882e37840a3821c483e61a837ede6fd91f9937db" + } + }, + "inclusion_delay": "14199853713660178519", + "proposer_index": "14191591293281790583" + }, + { + "aggregation_bits": "0x4fe11a3666f5b4852889a711cc9d89ea23b1a422c48abaa0b807d38d98b888b61f68dff5d3b03db9b81218539b57626ae7bd662ef5673d8eded43f9b303ac10f9948c70c1a3e7a63b0883575bbfde57f3ae4dde0b0d7192de432cb07d569c3e328f047e2fad85d1b113db392c0f4bc83319bec2b8336eb71a8a9b459e83852e3c42abd9f2709b621c0e3cde3f9bba64fe8550a4c0df247fe32a2fb8621a8d6ee9922693d138b5c182388e1223fc9d99daf0ee4f302a703f93d46701949c83ddb7c9821769d2a359bca4d2b60640b231bd433786bd633599d3dcf5acc74ab7bfeafa0b1138d88e3765b2c92fa89c668493e048e21db3425c46465aaa363d19ae801", + "data": { + "slot": "14193243776498474711", + "index": "14184981360415054070", + "beacon_block_root": "0x774ed5c496e4f2a1c41f57e0a00f19544e59160a5886db82766b567481c218d1", + "source": { + "epoch": "651733918", + "root": "0x500ce1c4564d3418da998889f9fdefb9425318e6ecf4890e1a69cfe3cc00aabb" + }, + "target": { + "epoch": "650579672", + "root": "0xc3d2bdc4161370b5992bf48dee326b886765125232a97e6b2d706495eb45f6fb" + } + }, + "inclusion_delay": "14181676389686718518", + "proposer_index": "14180023906470034390" + }, + { + "aggregation_bits": "0x75a61618dc6c4f33706ac1977e87123cc7c5d008d8e104a0399a99e6589afd330c3952cdadf5609aac7c0aadc4ac18c5417f8bdc7f2b429db5cd278f7693ec8d76cc9495ce1cef27c78b62690858c28d594ea2f23d8d3b319d5a4b4b8febe6a26b1802edfae4b67199493f92a0408971e0f3267924ccd5a562d4df4de81ee9ae71a454a0f84a117c73de8f0b228c7f55d5df80c3aba2a6e1791294090d362c0b73f7e5ce083b77e339ee886827267498cff67ac500c71c3b7a1531907ec1fb016f9b6590782cde51e3b1f5124f7cc3311b3a0623c3727f9a6b4daf194eac2cef5fc1840183e0f8eb312d3a1f286623b9bf215d3c5310317c8c6d9b427caec3a701", + "data": { + "slot": "14122186963821318837", + "index": "14120534480604634709", + "beacon_block_root": "0xacdcd8c375987433f55eaf2a2c0b8cc65bdbeb8ff93cb5c7261ead172f07e61d", + "source": { + "epoch": "642692319", + "root": "0x869ae4c33501b6a90bd9e0d385f9622c4fd5ed6b8dab6353ca1b26877b457708" + }, + "target": { + "epoch": "643077068", + "root": "0xf860c1c3f4c6f146ca6a4cd87a2edefa74e7e7d7d35f58b0dd22bb38998ac348" + } + }, + "inclusion_delay": "14104009639847858836", + "proposer_index": "14108967093792878517" + }, + { + "aggregation_bits": "0x25f26c946a51d0b4585221ff914a552338f7aa58092904ae14f39326f2f0df9044c852c502be66b1a358cd15b3a59a045959db3953007fc8bdb231697425d552f6f5c8c4125bf6a4f4f154bcfa89c7ab39009e693072ea8864570a0a0370d350899bf9998a103b3023a389789c71fcd712f9d742bf37fb9efdc758dc545be483127ddb0233157312c889c96d465f5b21c9aaa505e14d9cd4cf0cb88adeead52a0e075f0ac241e91a8d0eef0c193b8b4ceee0282fbb3f1bb19a6b96b8c0b4f638eaa5742924459e6ba917e5392306d058e477fb4e429292edefa25668d3c37b7959c5a3533c9205abcdc573fc2e9e5cab73cd7d8017a30a550532a040d069a7ef01", + "data": { + "slot": "14097399706981122324", + "index": "14102357160926142004", + "beacon_block_root": "0x32c4afc3d4a98f15aa33825af5c81b6287f0e48df6b9d2de66a6859128ade9e8", + "source": { + "epoch": "646732183", + "root": "0x416848c495fbe116c26605f277e3058ee4a1feb97157aef6c087aa3afad649d2" + }, + "target": { + "epoch": "647116932", + "root": "0x1b2654c45564238dd7e0369bd0d1dcf3d89b009604c65c82658523aa4515dbbc" + } + }, + "inclusion_delay": "14138711804578094709", + "proposer_index": "14137059321361410581" + }, + { + "aggregation_bits": "0xd3aa3c5ee8c86d56bf474c449e06cf2d24cb554e4851122153419618feeafa9a2f19783a03e84b7556e60b0b22c04990f2d8421ad08ab46927f50349bbe855ec34ac8e0040ec683755a2c1987da475928f2d4476fd81d40522d89deb50565a146e29f4d747d9b626472f07f7f2b603169907dad2238763ce9e69d89a2dc9ead887f4eb242e40769840938befddf5b608da60999f8474e0813418e252d6ba105df55daeee8eebe626963cee003caef0e1bcf66d58fef599dcce441c9b15bf0ec2a81aed2f1b7de98b6d1e49999308a86200aca9a784bc4bb7ca3eabb4163fc09216dca8bbc56225832e4bd97e6c061ff211cfcdfa7752ce959eec2786e03aee9e01", + "data": { + "slot": "14132101871711358197", + "index": "14130449388494674069", + "beacon_block_root": "0xa10d2bc4b5753e6f8cb509cb998f6c8f04b1f99300437a99a50dfc233ebbde87", + "source": { + "epoch": "645385562", + "root": "0x13d407c4753b7a0c4c4775cf8fc4e75d29c3f3ff46f76ef6b81491d55c002bc8" + }, + "target": { + "epoch": "644231315", + "root": "0xed9113c435a4bb8261c1a678e8b2bec31dbdf5dbda651d825c120a45a73ebcb2" + } + }, + "inclusion_delay": "14127144417766338517", + "proposer_index": "14066002512979222003" + }, + { + "aggregation_bits": "0x2d0364e9b67c2f8e3592c5901928dbef22a28cb8022e7fdd803ecb54c0b3f134cb7c5e0660a903f403184f7b8a8727c4fa2ef7c177af3b0f6d3f12a4f4306d8080e087960fcf78128a1af70f33a5b972a70cec856496a850db012d27866666a4767e74ac68666425d2f86800173d261d9f8c2c3ac796a08799acf02652c6ca8f069f6b3083a3a2a9e39538bcd9d041a5d19ad040c1d0f6402b3aabef6a2534975ec79930cc153f2ca88438db2aab08d6b9922edfff94bfff10cc3abe3ff8325a638ea7ba2b69219fe997816716916bd237123c2ba0b0a21dee9f4baf9463c22219fba40430292f734fafb65d478910b36080ba4d27118df56e3df0632f22dec601", + "data": { + "slot": "14067655000490873427", + "index": "14059392575817518195", + "beacon_block_root": "0x222017c313583d149200ffc274ae3136293fcb617b1cf7c60cc560e8568389ff", + "source": { + "epoch": "637113460", + "root": "0xfcdd22c3d3c07e8aa87a306ccc9c089c1d39cd3d0e8ba552b1c2d957a1c11aea" + }, + "target": { + "epoch": "635959214", + "root": "0x6fa4ffc29386ba27670c9c70c2d1836a424bc7a9543f9aafc3c96e09bf06672a" + } + }, + "inclusion_delay": "14056087609384149939", + "proposer_index": "14054435121872498515" + } + ], + "justification_bits": "0x05", + "previous_justified_checkpoint": { + "epoch": "223123644", + "root": "0x8be6c8917c79927f22583b48cdcfa690a5a57e85e2c77c3971ab4fcf5feda0ff" + }, + "current_justified_checkpoint": { + "epoch": "228125379", + "root": "0x9a8a61923dcbe4803a8bbedf4fea90bc025798b15d655851cb8c7478311701e9" + }, + "finalized_checkpoint": { + "epoch": "228510128", + "root": "0x74486d92fd3326f74f05f088a8d86722f6509a8df0d306dd6f8aede77d5592d3" + } + } +} \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/validator/postAggregateAndProofsRequestBodyELECTRA.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/validator/postAggregateAndProofsRequestBodyELECTRA.json new file mode 100644 index 00000000000..09830b2763c --- /dev/null +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/validator/postAggregateAndProofsRequestBodyELECTRA.json @@ -0,0 +1,27 @@ +[ + { + "message": { + "aggregator_index": "4665021361504678828", + "aggregate": { + "aggregation_bits": "0xd837d68714980f385c05b1c4e60e08695d100bd93ba04e50555a513c03bd99ce5c71e4a2a5a91419669bc583aab06a4e8f5d03f406f837e1a1d5bbec09cef1d8d9e33e9b65986cb7c3a274160d8245732ae9bf069db0adc8c4b9550069bfba37b8831ae257e4435f9910b4f4833226fa4830001eab94dc4fb0c094ac3876f98df571f6287b2093a52d404dc4bc3ae98f220a5127f647a3ba73545715870cc3e15051d024ea5de67f28429fd3139d978cc4aec10f360ef8e1f2207665a62887850b6ab8094cde4d7683e37ba631c8dc6e8ea826e6d12d1bf0962970755d49f8451035b8e305c6352b7de6753e459f404b760689dd4f53dd9ff6b0d221849b10aa01", + "data": { + "slot": "4666673844721362956", + "index": "0", + "beacon_block_root": "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f", + "source": { + "epoch": "542310465", + "root": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + }, + "target": { + "epoch": "542695214", + "root": "0x1f86d83f0bf91cc0d7e07410828140e0dddbb331dc20b6743f9f79e549b50b11" + } + }, + "signature": "0xb3a22ab9ec46aec35a9dacfb9036375ea1528041a926cb9d2d315ab964e82be5d6990e7fef2343f2dbb4c2b7dd74687f11144beaeb5758ebe349762b4dbde5e67bbc8d89a95a803c6610631d178249917cbf0d8b11bd8740f3cb767c843aa88c", + "committee_bits": "0x08" + }, + "selection_proof": "0xae757bc04a0f7ee8e8d1668c8de3fd4ca45ca7e8f7ad7d3323350213956386cfc97094f156a7d6ab2d3ebe6a7eb7ce2c10d0d32091ee4867224ef5856bff529e9f0c2cb9c0085a28f6a47d75aae926913f681a6b21e25b093b78e3cf188bb6be" + }, + "signature": "0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483" + } +] \ No newline at end of file diff --git a/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/validator/postAggregateAndProofsRequestBodyPHASE0.json b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/validator/postAggregateAndProofsRequestBodyPHASE0.json new file mode 100644 index 00000000000..893912823c3 --- /dev/null +++ b/data/beaconrestapi/src/test/resources/tech/pegasys/teku/beaconrestapi/handlers/v2/validator/postAggregateAndProofsRequestBodyPHASE0.json @@ -0,0 +1,26 @@ +[ + { + "message": { + "aggregator_index": "4665021361504678828", + "aggregate": { + "aggregation_bits": "0xd837d68714980f385c05b1c4e60e08695d100bd93ba04e50555a513c03bd99ce5c71e4a2a5a91419669bc583aab06a4e8f5d03f406f837e1a1d5bbec09cef1d8d9e33e9b65986cb7c3a274160d8245732ae9bf069db0adc8c4b9550069bfba37b8831ae257e4435f9910b4f4833226fa4830001eab94dc4fb0c094ac3876f98df571f6287b2093a52d404dc4bc3ae98f220a5127f647a3ba73545715870cc3e15051d024ea5de67f28429fd3139d978cc4aec10f360ef8e1f2207665a62887850b6ab8094cde4d7683e37ba631c8dc6e8ea826e6d12d1bf0962970755d49f8451035b8e305c6352b7de6753e459f404b760689dd4f53dd9ff6b0d221849b10aa01", + "data": { + "slot": "4666673844721362956", + "index": "4668326327938047084", + "beacon_block_root": "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f", + "source": { + "epoch": "542310465", + "root": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + }, + "target": { + "epoch": "542695214", + "root": "0x1f86d83f0bf91cc0d7e07410828140e0dddbb331dc20b6743f9f79e549b50b11" + } + }, + "signature": "0xb3a22ab9ec46aec35a9dacfb9036375ea1528041a926cb9d2d315ab964e82be5d6990e7fef2343f2dbb4c2b7dd74687f11144beaeb5758ebe349762b4dbde5e67bbc8d89a95a803c6610631d178249917cbf0d8b11bd8740f3cb767c843aa88c" + }, + "selection_proof": "0xae757bc04a0f7ee8e8d1668c8de3fd4ca45ca7e8f7ad7d3323350213956386cfc97094f156a7d6ab2d3ebe6a7eb7ce2c10d0d32091ee4867224ef5856bff529e9f0c2cb9c0085a28f6a47d75aae926913f681a6b21e25b093b78e3cf188bb6be" + }, + "signature": "0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483" + } +] \ No newline at end of file diff --git a/data/dataexchange/src/main/java/tech/pegasys/teku/data/SlashingProtectionExporter.java b/data/dataexchange/src/main/java/tech/pegasys/teku/data/SlashingProtectionExporter.java index 55acf733cb8..ff56df78372 100644 --- a/data/dataexchange/src/main/java/tech/pegasys/teku/data/SlashingProtectionExporter.java +++ b/data/dataexchange/src/main/java/tech/pegasys/teku/data/SlashingProtectionExporter.java @@ -13,6 +13,7 @@ package tech.pegasys.teku.data; +import static tech.pegasys.teku.data.SlashingProtectionRepairer.parsePublicKey; import static tech.pegasys.teku.data.slashinginterchange.Metadata.INTERCHANGE_VERSION; import com.fasterxml.jackson.core.JsonProcessingException; @@ -30,7 +31,6 @@ import org.apache.tuweni.bytes.Bytes; import org.apache.tuweni.bytes.Bytes32; import org.apache.tuweni.bytes.Bytes48; -import tech.pegasys.teku.api.schema.BLSPubKey; import tech.pegasys.teku.api.schema.PublicKeyException; import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.data.slashinginterchange.Metadata; @@ -38,12 +38,11 @@ import tech.pegasys.teku.data.slashinginterchange.SlashingProtectionInterchangeFormat; import tech.pegasys.teku.ethereum.signingrecord.ValidatorSigningRecord; import tech.pegasys.teku.infrastructure.io.SyncDataAccessor; -import tech.pegasys.teku.provider.JsonProvider; +import tech.pegasys.teku.infrastructure.json.JsonUtil; public class SlashingProtectionExporter { - private final JsonProvider jsonProvider = new JsonProvider(); private final List signingHistoryList = new ArrayList<>(); - private Bytes32 genesisValidatorsRoot = null; + private Optional genesisValidatorsRoot = Optional.empty(); private final SyncDataAccessor syncDataAccessor; protected final Path slashProtectionPath; @@ -54,7 +53,7 @@ public SlashingProtectionExporter(final Path slashProtectionPath) { // returns a map of errors and the associated keys. public Map initialise(final Consumer infoLogger) { - File slashingProtectionRecords = slashProtectionPath.toFile(); + final File slashingProtectionRecords = slashProtectionPath.toFile(); final Map importErrors = new HashMap<>(); for (File currentFile : slashingProtectionRecords.listFiles()) { final Optional maybeError = readSlashProtectionFile(currentFile, infoLogger); @@ -72,30 +71,31 @@ public Map initialise(final Consumer infoLogger) { // returns an error if there was one Optional readSlashProtectionFile(final File file, final Consumer infoLogger) { try { - Optional maybeRecord = + final Optional maybeRecord = syncDataAccessor.read(file.toPath()).map(ValidatorSigningRecord::fromBytes); if (maybeRecord.isEmpty()) { return Optional.of("Failed to read from file " + file.getName()); } - ValidatorSigningRecord validatorSigningRecord = maybeRecord.get(); + final ValidatorSigningRecord validatorSigningRecord = maybeRecord.get(); - if (validatorSigningRecord.getGenesisValidatorsRoot() != null) { - if (genesisValidatorsRoot == null) { - this.genesisValidatorsRoot = validatorSigningRecord.getGenesisValidatorsRoot(); - } else if (!genesisValidatorsRoot.equals( - validatorSigningRecord.getGenesisValidatorsRoot())) { + if (validatorSigningRecord.genesisValidatorsRoot().isPresent()) { + if (genesisValidatorsRoot.isEmpty()) { + this.genesisValidatorsRoot = validatorSigningRecord.genesisValidatorsRoot(); + } else if (!genesisValidatorsRoot + .get() + .equals(validatorSigningRecord.genesisValidatorsRoot().get())) { return Optional.of( "The genesisValidatorsRoot of " + file.getName() + " does not match the expected " - + genesisValidatorsRoot.toHexString()); + + genesisValidatorsRoot.get().toHexString()); } } final String pubkey = file.getName().substring(0, file.getName().length() - ".yml".length()); infoLogger.accept("Exporting " + pubkey); signingHistoryList.add( - new SigningHistory(BLSPubKey.fromHexString(pubkey), validatorSigningRecord)); + SigningHistory.createSigningHistory(parsePublicKey(pubkey), validatorSigningRecord)); return Optional.empty(); } catch (UncheckedIOException | IOException e) { return Optional.of("Failed to read from file " + file); @@ -119,14 +119,19 @@ private Bytes getJsonByteData() throws JsonProcessingException { } String getPrettyJson() throws JsonProcessingException { - return jsonProvider.objectToPrettyJSON( + final SlashingProtectionInterchangeFormat data = new SlashingProtectionInterchangeFormat( - new Metadata(INTERCHANGE_VERSION, genesisValidatorsRoot), signingHistoryList)); + new Metadata(Optional.empty(), INTERCHANGE_VERSION, genesisValidatorsRoot), + signingHistoryList); + return JsonUtil.prettySerialize( + data, SlashingProtectionInterchangeFormat.getJsonTypeDefinition()); } String getJson() throws JsonProcessingException { - return jsonProvider.objectToJSON( + final SlashingProtectionInterchangeFormat data = new SlashingProtectionInterchangeFormat( - new Metadata(INTERCHANGE_VERSION, genesisValidatorsRoot), signingHistoryList)); + new Metadata(Optional.empty(), INTERCHANGE_VERSION, genesisValidatorsRoot), + signingHistoryList); + return JsonUtil.serialize(data, SlashingProtectionInterchangeFormat.getJsonTypeDefinition()); } } diff --git a/data/dataexchange/src/main/java/tech/pegasys/teku/data/SlashingProtectionImporter.java b/data/dataexchange/src/main/java/tech/pegasys/teku/data/SlashingProtectionImporter.java index dc083559694..94588956bbe 100644 --- a/data/dataexchange/src/main/java/tech/pegasys/teku/data/SlashingProtectionImporter.java +++ b/data/dataexchange/src/main/java/tech/pegasys/teku/data/SlashingProtectionImporter.java @@ -17,8 +17,6 @@ import com.fasterxml.jackson.core.JsonParseException; import com.fasterxml.jackson.databind.JsonMappingException; -import com.fasterxml.jackson.databind.JsonNode; -import com.fasterxml.jackson.databind.ObjectMapper; import java.io.File; import java.io.FileInputStream; import java.io.IOException; @@ -26,7 +24,6 @@ import java.io.UncheckedIOException; import java.nio.file.Path; import java.util.ArrayList; -import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Locale; @@ -34,19 +31,19 @@ import java.util.Objects; import java.util.Optional; import java.util.function.Consumer; -import tech.pegasys.teku.api.schema.BLSPubKey; import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.data.slashinginterchange.Metadata; import tech.pegasys.teku.data.slashinginterchange.SignedAttestation; import tech.pegasys.teku.data.slashinginterchange.SignedBlock; import tech.pegasys.teku.data.slashinginterchange.SigningHistory; +import tech.pegasys.teku.data.slashinginterchange.SlashingProtectionInterchangeFormat; import tech.pegasys.teku.ethereum.signingrecord.ValidatorSigningRecord; import tech.pegasys.teku.infrastructure.io.SyncDataAccessor; +import tech.pegasys.teku.infrastructure.json.JsonUtil; +import tech.pegasys.teku.infrastructure.json.exceptions.MissingRequiredFieldException; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.provider.JsonProvider; public class SlashingProtectionImporter { - private final JsonProvider jsonProvider = new JsonProvider(); private final Path slashingProtectionPath; private List data = new ArrayList<>(); private Metadata metadata; @@ -62,33 +59,31 @@ public Optional initialise(final File inputFile) throws IOException { } public Optional initialise(final InputStream inputStream) throws IOException { - final ObjectMapper jsonMapper = jsonProvider.getObjectMapper(); try { - final JsonNode jsonNode = jsonMapper.readTree(inputStream); + final SlashingProtectionInterchangeFormat interchangeFormat = + JsonUtil.parse(inputStream, SlashingProtectionInterchangeFormat.getJsonTypeDefinition()); - metadata = jsonMapper.treeToValue(jsonNode.get("metadata"), Metadata.class); + metadata = interchangeFormat.metadata(); if (metadata == null) { return Optional.of( "Import data does not appear to have metadata information, and cannot be loaded."); } if (!INTERCHANGE_VERSION.equals(UInt64.valueOf(4)) - && !INTERCHANGE_VERSION.equals(metadata.interchangeFormatVersion)) { + && !INTERCHANGE_VERSION.equals(metadata.interchangeFormatVersion())) { return Optional.of( String.format( "Import data has unsupported format version %s. Required version is %s", - metadata.interchangeFormatVersion, INTERCHANGE_VERSION)); + metadata.interchangeFormat(), INTERCHANGE_VERSION)); } - data = - summariseCompleteInterchangeFormat( - Arrays.asList(jsonMapper.treeToValue(jsonNode.get("data"), SigningHistory[].class))); + data = summariseCompleteInterchangeFormat(interchangeFormat.data()); - } catch (JsonMappingException e) { - String cause = e.getCause() != null ? e.getCause().getMessage() : e.getMessage(); + } catch (JsonMappingException | MissingRequiredFieldException e) { + final String cause = e.getCause() != null ? e.getCause().getMessage() : e.getMessage(); return Optional.of("Failed to load data. " + cause); - } catch (JsonParseException e) { - String cause = e.getCause() != null ? e.getCause().getMessage() : e.getMessage(); + } catch (JsonParseException | IllegalArgumentException e) { + final String cause = e.getCause() != null ? e.getCause().getMessage() : e.getMessage(); return Optional.of(String.format("Json does not appear valid. %s", cause)); } return Optional.empty(); @@ -101,27 +96,27 @@ private List summariseCompleteInterchangeFormat( private SigningHistory signingHistoryConverter(final SigningHistory signingHistory) { final Optional lastSlot = - signingHistory.signedBlocks.stream() - .map(SignedBlock::getSlot) + signingHistory.signedBlocks().stream() + .map(SignedBlock::slot) .filter(Objects::nonNull) .max(UInt64::compareTo); final Optional sourceEpoch = - signingHistory.signedAttestations.stream() - .map(SignedAttestation::getSourceEpoch) + signingHistory.signedAttestations().stream() + .map(SignedAttestation::sourceEpoch) .filter(Objects::nonNull) .max(UInt64::compareTo); final Optional targetEpoch = - signingHistory.signedAttestations.stream() - .map(SignedAttestation::getTargetEpoch) + signingHistory.signedAttestations().stream() + .map(SignedAttestation::targetEpoch) .filter(Objects::nonNull) .max(UInt64::compareTo); final ValidatorSigningRecord record = new ValidatorSigningRecord( - metadata.genesisValidatorsRoot, + metadata.genesisValidatorsRoot(), lastSlot.orElse(UInt64.ZERO), sourceEpoch.orElse(ValidatorSigningRecord.NEVER_SIGNED), targetEpoch.orElse(ValidatorSigningRecord.NEVER_SIGNED)); - return new SigningHistory(signingHistory.pubkey, record); + return SigningHistory.createSigningHistory(signingHistory.pubkey(), record); } /** @@ -137,10 +132,10 @@ public Map updateLocalRecords(final Consumer statu data.forEach( record -> { Optional error = updateLocalRecord(record, statusConsumer); - error.ifPresent(errorString -> errors.put(record.pubkey.asBLSPublicKey(), errorString)); + error.ifPresent(errorString -> errors.put(record.pubkey(), errorString)); }); statusConsumer.accept("Updated " + data.size() + " validator slashing protection records"); - if (errors.size() > 0) { + if (!errors.isEmpty()) { statusConsumer.accept("There were " + errors.size() + " errors found during import."); } return errors; @@ -156,21 +151,24 @@ record -> { */ public Optional updateSigningRecord( final BLSPublicKey publicKey, final Consumer statusConsumer) { - final BLSPubKey key = new BLSPubKey(publicKey); return data.stream() - .filter(signingHistory -> signingHistory.pubkey.equals(key)) + .filter(signingHistory -> signingHistory.pubkey().equals(publicKey)) .flatMap(record -> updateLocalRecord(record, statusConsumer).stream()) .findFirst(); } private Optional updateLocalRecord( final SigningHistory signingHistory, final Consumer statusConsumer) { - String validatorString = - signingHistory.pubkey.toBytes().toUnprefixedHexString().toLowerCase(Locale.ROOT); - final String hexValidatorPubkey = signingHistory.pubkey.toHexString(); + final String validatorString = + signingHistory + .pubkey() + .toBytesCompressed() + .toUnprefixedHexString() + .toLowerCase(Locale.ROOT); + final String hexValidatorPubkey = signingHistory.pubkey().toHexString(); statusConsumer.accept("Importing " + validatorString); - Path outputFile = slashingProtectionPath.resolve(validatorString + ".yml"); + final Path outputFile = slashingProtectionPath.resolve(validatorString + ".yml"); Optional existingRecord = Optional.empty(); if (outputFile.toFile().exists()) { try { @@ -181,9 +179,12 @@ private Optional updateLocalRecord( } } if (existingRecord.isPresent() - && existingRecord.get().getGenesisValidatorsRoot() != null - && metadata.genesisValidatorsRoot != null - && metadata.genesisValidatorsRoot.compareTo(existingRecord.get().getGenesisValidatorsRoot()) + && existingRecord.get().genesisValidatorsRoot().isPresent() + && metadata.genesisValidatorsRoot().isPresent() + && metadata + .genesisValidatorsRoot() + .get() + .compareTo(existingRecord.get().genesisValidatorsRoot().get()) != 0) { statusConsumer.accept( "Validator " @@ -196,7 +197,8 @@ private Optional updateLocalRecord( syncDataAccessor.syncedWrite( outputFile, signingHistory - .toValidatorSigningRecord(existingRecord, metadata.genesisValidatorsRoot) + .toValidatorSigningRecord( + existingRecord, metadata.genesisValidatorsRoot().orElse(null)) .toBytes()); } catch (IOException e) { statusConsumer.accept("Validator " + hexValidatorPubkey + " was not updated."); diff --git a/data/dataexchange/src/main/java/tech/pegasys/teku/data/SlashingProtectionRepairer.java b/data/dataexchange/src/main/java/tech/pegasys/teku/data/SlashingProtectionRepairer.java index 8611bc56081..ab585084441 100644 --- a/data/dataexchange/src/main/java/tech/pegasys/teku/data/SlashingProtectionRepairer.java +++ b/data/dataexchange/src/main/java/tech/pegasys/teku/data/SlashingProtectionRepairer.java @@ -23,8 +23,9 @@ import java.util.Locale; import java.util.Optional; import java.util.Set; -import tech.pegasys.teku.api.schema.BLSPubKey; +import org.apache.tuweni.bytes.Bytes32; import tech.pegasys.teku.api.schema.PublicKeyException; +import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.data.slashinginterchange.SigningHistory; import tech.pegasys.teku.ethereum.signingrecord.ValidatorSigningRecord; import tech.pegasys.teku.infrastructure.io.SyncDataAccessor; @@ -59,7 +60,7 @@ public static SlashingProtectionRepairer create( private void initialise(final Path slashProtectionPath) { this.slashingProtectionPath = slashProtectionPath; - File slashingProtectionRecords = slashProtectionPath.toFile(); + final File slashingProtectionRecords = slashProtectionPath.toFile(); Arrays.stream(slashingProtectionRecords.listFiles()) .filter(file -> file.isFile() && file.getName().endsWith(".yml")) .forEach(this::readSlashProtectionFile); @@ -69,9 +70,9 @@ private void readSlashProtectionFile(final File file) { final String filePrefix = file.getName().substring(0, file.getName().length() - ".yml".length()); try { - BLSPubKey pubkey = BLSPubKey.fromHexString(filePrefix); + final BLSPublicKey pubkey = parsePublicKey(filePrefix); - Optional maybeRecord = + final Optional maybeRecord = syncDataAccessor.read(file.toPath()).map(ValidatorSigningRecord::fromBytes); if (maybeRecord.isEmpty() && invalidRecords.add(filePrefix)) { log.display(filePrefix + ": Empty slashing protection record"); @@ -81,8 +82,8 @@ private void readSlashProtectionFile(final File file) { if (updateAllEnabled) { log.display(filePrefix + ": looks valid"); } - ValidatorSigningRecord validatorSigningRecord = maybeRecord.get(); - signingHistoryList.add(new SigningHistory(pubkey, validatorSigningRecord)); + final ValidatorSigningRecord validatorSigningRecord = maybeRecord.get(); + signingHistoryList.add(SigningHistory.createSigningHistory(pubkey, validatorSigningRecord)); } catch (PublicKeyException e) { log.display(" --- " + file.getName() + " - invalid public key - ignoring file"); @@ -93,11 +94,20 @@ private void readSlashProtectionFile(final File file) { } } + static BLSPublicKey parsePublicKey(final String value) { + try { + return BLSPublicKey.fromHexString(value); + } catch (IllegalArgumentException e) { + throw new PublicKeyException( + String.format("Public key %s is invalid: %s", value, e.getMessage()), e); + } + } + public void updateRecords(final UInt64 slot, final UInt64 epoch) { invalidRecords.forEach( pubkey -> writeValidatorSigningRecord( - new ValidatorSigningRecord(null, slot, epoch, epoch), pubkey)); + new ValidatorSigningRecord(Optional.empty(), slot, epoch, epoch), pubkey)); if (updateAllEnabled) { signingHistoryList.forEach( (historyRecord) -> updateValidatorSigningRecord(slot, epoch, historyRecord)); @@ -112,7 +122,7 @@ private void updateValidatorSigningRecord( final ValidatorSigningRecord updatedRecord = updateSigningRecord(slot, epoch, Optional.of(currentRecord)); if (!currentRecord.equals(updatedRecord)) { - writeValidatorSigningRecord(updatedRecord, toDisplayString(historyRecord.pubkey)); + writeValidatorSigningRecord(updatedRecord, toDisplayString(historyRecord.pubkey())); } } @@ -127,8 +137,8 @@ private void writeValidatorSigningRecord( } } - private String toDisplayString(final BLSPubKey pubkey) { - return pubkey.toBytes().toUnprefixedHexString().toLowerCase(Locale.ROOT); + private String toDisplayString(final BLSPublicKey pubkey) { + return pubkey.toBytesCompressed().toUnprefixedHexString().toLowerCase(Locale.ROOT); } private void displayUpdateErrors() { @@ -147,7 +157,7 @@ public boolean hasUpdates() { if (updateAllEnabled) { return signingHistoryList.size() + invalidRecords.size() > 0; } - return invalidRecords.size() > 0; + return !invalidRecords.isEmpty(); } static ValidatorSigningRecord updateSigningRecord( @@ -156,20 +166,18 @@ static ValidatorSigningRecord updateSigningRecord( final Optional maybeRecord) { final UInt64 sourceEpoch = maybeRecord - .map(ValidatorSigningRecord::getAttestationSourceEpoch) + .map(ValidatorSigningRecord::attestationSourceEpoch) .orElse(attestationEpoch) .max(attestationEpoch); final UInt64 targetEpoch = maybeRecord - .map(ValidatorSigningRecord::getAttestationTargetEpoch) + .map(ValidatorSigningRecord::attestationTargetEpoch) .orElse(attestationEpoch) .max(attestationEpoch); final UInt64 slot = - maybeRecord.map(ValidatorSigningRecord::getBlockSlot).orElse(blockSlot).max(blockSlot); - return new ValidatorSigningRecord( - maybeRecord.map(ValidatorSigningRecord::getGenesisValidatorsRoot).orElse(null), - slot, - sourceEpoch, - targetEpoch); + maybeRecord.map(ValidatorSigningRecord::blockSlot).orElse(blockSlot).max(blockSlot); + final Optional maybeGenesisRoot = + maybeRecord.isPresent() ? maybeRecord.get().genesisValidatorsRoot() : Optional.empty(); + return new ValidatorSigningRecord(maybeGenesisRoot, slot, sourceEpoch, targetEpoch); } } diff --git a/data/dataexchange/src/main/java/tech/pegasys/teku/data/eraFileFormat/EraFile.java b/data/dataexchange/src/main/java/tech/pegasys/teku/data/eraFileFormat/EraFile.java index 32cb23d08e5..ee64be4a9bd 100644 --- a/data/dataexchange/src/main/java/tech/pegasys/teku/data/eraFileFormat/EraFile.java +++ b/data/dataexchange/src/main/java/tech/pegasys/teku/data/eraFileFormat/EraFile.java @@ -166,7 +166,7 @@ public SignedBeaconBlock getLastBlock() { } private void verifyBlocksWithReferenceState( - BeaconState verifiedState, final SignedBeaconBlock previousArchiveLastBlock) + final BeaconState verifiedState, final SignedBeaconBlock previousArchiveLastBlock) throws IOException { currentSlot = blockIndices.getStartSlot(); Bytes32 lastRoot = Bytes32.ZERO; diff --git a/data/dataexchange/src/main/java/tech/pegasys/teku/data/slashinginterchange/Metadata.java b/data/dataexchange/src/main/java/tech/pegasys/teku/data/slashinginterchange/Metadata.java index 155e06e4cfe..2aa9c11dfd6 100644 --- a/data/dataexchange/src/main/java/tech/pegasys/teku/data/slashinginterchange/Metadata.java +++ b/data/dataexchange/src/main/java/tech/pegasys/teku/data/slashinginterchange/Metadata.java @@ -13,42 +13,44 @@ package tech.pegasys.teku.data.slashinginterchange; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonInclude; -import com.fasterxml.jackson.annotation.JsonProperty; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.BYTES32_TYPE; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.STRING_TYPE; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; + import com.google.common.base.MoreObjects; import java.util.Objects; +import java.util.Optional; import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -@JsonInclude(JsonInclude.Include.NON_NULL) -public class Metadata { +public record Metadata( + Optional interchangeFormat, + UInt64 interchangeFormatVersion, + Optional genesisValidatorsRoot) { public static final UInt64 INTERCHANGE_VERSION = UInt64.valueOf(5); - @JsonProperty("interchange_format") - public final String interchangeFormat; - - @JsonProperty("interchange_format_version") - public final UInt64 interchangeFormatVersion; - - @JsonProperty("genesis_validators_root") - public final Bytes32 genesisValidatorsRoot; - - public Metadata(final UInt64 interchangeFormatVersion, final Bytes32 genesisValidatorsRoot) { - this.interchangeFormat = null; - this.interchangeFormatVersion = interchangeFormatVersion; - this.genesisValidatorsRoot = genesisValidatorsRoot; - } - - @JsonCreator - public Metadata( - @JsonProperty("interchange_format") final String interchangeFormat, - @JsonProperty("interchange_format_version") final UInt64 interchangeFormatVersion, - @JsonProperty("genesis_validators_root") final Bytes32 genesisValidatorsRoot) { - this.interchangeFormatVersion = interchangeFormatVersion; - this.genesisValidatorsRoot = genesisValidatorsRoot; - this.interchangeFormat = interchangeFormat; + public static DeserializableTypeDefinition getJsonTypeDefinition() { + return DeserializableTypeDefinition.object(Metadata.class, MetadataBuilder.class) + .initializer(MetadataBuilder::new) + .finisher(MetadataBuilder::build) + .withOptionalField( + "interchange_format", + STRING_TYPE, + Metadata::interchangeFormat, + MetadataBuilder::interchangeFormat) + .withField( + "interchange_format_version", + UINT64_TYPE, + Metadata::interchangeFormatVersion, + MetadataBuilder::interchangeFormatVersion) + .withOptionalField( + "genesis_validators_root", + BYTES32_TYPE, + Metadata::genesisValidatorsRoot, + MetadataBuilder::genesisValidatorsRoot) + .build(); } @Override @@ -77,4 +79,29 @@ public String toString() { .add("genesisValidatorsRoot", genesisValidatorsRoot) .toString(); } + + static class MetadataBuilder { + Optional interchangeFormat = Optional.empty(); + UInt64 interchangeFormatVersion; + Optional genesisValidatorsRoot = Optional.empty(); + + MetadataBuilder interchangeFormat(final Optional interchangeFormat) { + this.interchangeFormat = interchangeFormat; + return this; + } + + MetadataBuilder interchangeFormatVersion(final UInt64 interchangeFormatVersion) { + this.interchangeFormatVersion = interchangeFormatVersion; + return this; + } + + MetadataBuilder genesisValidatorsRoot(final Optional genesisValidatorsRoot) { + this.genesisValidatorsRoot = genesisValidatorsRoot; + return this; + } + + Metadata build() { + return new Metadata(interchangeFormat, interchangeFormatVersion, genesisValidatorsRoot); + } + } } diff --git a/data/dataexchange/src/main/java/tech/pegasys/teku/data/slashinginterchange/SignedAttestation.java b/data/dataexchange/src/main/java/tech/pegasys/teku/data/slashinginterchange/SignedAttestation.java index c285032a52a..a08643a9ef1 100644 --- a/data/dataexchange/src/main/java/tech/pegasys/teku/data/slashinginterchange/SignedAttestation.java +++ b/data/dataexchange/src/main/java/tech/pegasys/teku/data/slashinginterchange/SignedAttestation.java @@ -13,55 +13,39 @@ package tech.pegasys.teku.data.slashinginterchange; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonInclude; -import com.fasterxml.jackson.annotation.JsonProperty; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.BYTES32_TYPE; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; + import com.google.common.base.MoreObjects; -import java.util.Objects; +import java.util.Optional; import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -@JsonInclude(JsonInclude.Include.NON_NULL) -public class SignedAttestation { - @JsonProperty("source_epoch") - public final UInt64 sourceEpoch; - - @JsonProperty("target_epoch") - public final UInt64 targetEpoch; - - @JsonProperty("signing_root") - public final Bytes32 signingRoot; +public record SignedAttestation( + UInt64 sourceEpoch, UInt64 targetEpoch, Optional signingRoot) { - @JsonCreator - public SignedAttestation( - @JsonProperty("source_epoch") final UInt64 sourceEpoch, - @JsonProperty("target_epoch") final UInt64 targetEpoch, - @JsonProperty("signing_root") final Bytes32 signingRoot) { - this.sourceEpoch = sourceEpoch; - this.targetEpoch = targetEpoch; - this.signingRoot = signingRoot; - } - - @Override - public boolean equals(final Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - final SignedAttestation that = (SignedAttestation) o; - return Objects.equals(sourceEpoch, that.sourceEpoch) - && Objects.equals(targetEpoch, that.targetEpoch) - && Objects.equals(signingRoot, that.signingRoot); - } - - public UInt64 getSourceEpoch() { - return sourceEpoch; - } - - public UInt64 getTargetEpoch() { - return targetEpoch; + public static DeserializableTypeDefinition getJsonTypeDefinition() { + return DeserializableTypeDefinition.object( + SignedAttestation.class, SignedAttestationBuilder.class) + .initializer(SignedAttestationBuilder::new) + .finisher(SignedAttestationBuilder::build) + .withField( + "source_epoch", + UINT64_TYPE, + SignedAttestation::sourceEpoch, + SignedAttestationBuilder::sourceEpoch) + .withField( + "target_epoch", + UINT64_TYPE, + SignedAttestation::targetEpoch, + SignedAttestationBuilder::targetEpoch) + .withOptionalField( + "signing_root", + BYTES32_TYPE, + SignedAttestation::signingRoot, + SignedAttestationBuilder::signingRoot) + .build(); } @Override @@ -73,8 +57,28 @@ public String toString() { .toString(); } - @Override - public int hashCode() { - return Objects.hash(sourceEpoch, targetEpoch, signingRoot); + static class SignedAttestationBuilder { + UInt64 sourceEpoch; + UInt64 targetEpoch; + Optional signingRoot = Optional.empty(); + + SignedAttestationBuilder sourceEpoch(final UInt64 sourceEpoch) { + this.sourceEpoch = sourceEpoch; + return this; + } + + SignedAttestationBuilder targetEpoch(final UInt64 targetEpoch) { + this.targetEpoch = targetEpoch; + return this; + } + + SignedAttestationBuilder signingRoot(final Optional signingRoot) { + this.signingRoot = signingRoot; + return this; + } + + SignedAttestation build() { + return new SignedAttestation(sourceEpoch, targetEpoch, signingRoot); + } } } diff --git a/data/dataexchange/src/main/java/tech/pegasys/teku/data/slashinginterchange/SignedBlock.java b/data/dataexchange/src/main/java/tech/pegasys/teku/data/slashinginterchange/SignedBlock.java index 13cb0abbb55..ea213ec793d 100644 --- a/data/dataexchange/src/main/java/tech/pegasys/teku/data/slashinginterchange/SignedBlock.java +++ b/data/dataexchange/src/main/java/tech/pegasys/teku/data/slashinginterchange/SignedBlock.java @@ -13,28 +13,25 @@ package tech.pegasys.teku.data.slashinginterchange; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonInclude; -import com.fasterxml.jackson.annotation.JsonProperty; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.BYTES32_TYPE; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; + import com.google.common.base.MoreObjects; -import java.util.Objects; +import java.util.Optional; import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -@JsonInclude(JsonInclude.Include.NON_NULL) -public class SignedBlock { - @JsonProperty("slot") - public final UInt64 slot; - - @JsonProperty("signing_root") - public final Bytes32 signingRoot; +public record SignedBlock(UInt64 slot, Optional signingRoot) { - @JsonCreator - public SignedBlock( - @JsonProperty("slot") final UInt64 slot, - @JsonProperty("signing_root") final Bytes32 signingRoot) { - this.slot = slot; - this.signingRoot = signingRoot; + public static DeserializableTypeDefinition getJsonTypeDefinition() { + return DeserializableTypeDefinition.object(SignedBlock.class, SignedBlockBuilder.class) + .initializer(SignedBlockBuilder::new) + .finisher(SignedBlockBuilder::build) + .withField("slot", UINT64_TYPE, SignedBlock::slot, SignedBlockBuilder::slot) + .withOptionalField( + "signing_root", BYTES32_TYPE, SignedBlock::signingRoot, SignedBlockBuilder::signingRoot) + .build(); } @Override @@ -45,24 +42,22 @@ public String toString() { .toString(); } - @Override - public boolean equals(final Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; + static class SignedBlockBuilder { + UInt64 slot; + Optional signingRoot = Optional.empty(); + + SignedBlockBuilder slot(final UInt64 slot) { + this.slot = slot; + return this; } - final SignedBlock that = (SignedBlock) o; - return Objects.equals(slot, that.slot) && Objects.equals(signingRoot, that.signingRoot); - } - public UInt64 getSlot() { - return slot; - } + SignedBlockBuilder signingRoot(final Optional signingRoot) { + this.signingRoot = signingRoot; + return this; + } - @Override - public int hashCode() { - return Objects.hash(slot, signingRoot); + SignedBlock build() { + return new SignedBlock(slot, signingRoot); + } } } diff --git a/data/dataexchange/src/main/java/tech/pegasys/teku/data/slashinginterchange/SigningHistory.java b/data/dataexchange/src/main/java/tech/pegasys/teku/data/slashinginterchange/SigningHistory.java index cac5cf8b3eb..e4bb9599c9e 100644 --- a/data/dataexchange/src/main/java/tech/pegasys/teku/data/slashinginterchange/SigningHistory.java +++ b/data/dataexchange/src/main/java/tech/pegasys/teku/data/slashinginterchange/SigningHistory.java @@ -15,63 +15,58 @@ import static tech.pegasys.teku.ethereum.signingrecord.ValidatorSigningRecord.isNeverSigned; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; import com.google.common.base.MoreObjects; import java.util.ArrayList; import java.util.List; import java.util.Objects; import java.util.Optional; import org.apache.tuweni.bytes.Bytes32; -import tech.pegasys.teku.api.schema.BLSPubKey; +import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.ethereum.signingrecord.ValidatorSigningRecord; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -public class SigningHistory { - @JsonProperty("pubkey") - public final BLSPubKey pubkey; +public record SigningHistory( + BLSPublicKey pubkey, + List signedBlocks, + List signedAttestations) { - @JsonProperty("signed_blocks") - public final List signedBlocks; + public static final DeserializableTypeDefinition PUBKEY_TYPE = + DeserializableTypeDefinition.string(BLSPublicKey.class) + .formatter(BLSPublicKey::toHexString) + .parser(BLSPublicKey::fromHexString) + .build(); - @JsonProperty("signed_attestations") - public final List signedAttestations; - - @JsonCreator - public SigningHistory( - @JsonProperty("pubkey") final BLSPubKey pubkey, - @JsonProperty("signed_blocks") final List signedBlocks, - @JsonProperty("signed_attestations") final List signedAttestations) { - this.pubkey = pubkey; - this.signedBlocks = signedBlocks; - this.signedAttestations = signedAttestations; - } - - public SigningHistory(final BLSPubKey pubkey, final ValidatorSigningRecord record) { - this.pubkey = pubkey; - this.signedBlocks = new ArrayList<>(); - signedBlocks.add(new SignedBlock(record.getBlockSlot(), null)); - this.signedAttestations = new ArrayList<>(); - if (!isNeverSigned(record.getAttestationSourceEpoch()) - || !isNeverSigned(record.getAttestationTargetEpoch())) { - signedAttestations.add( + public static SigningHistory createSigningHistory( + final BLSPublicKey pubkey, final ValidatorSigningRecord record) { + final List blocks = new ArrayList<>(); + final List attestations = new ArrayList<>(); + blocks.add(new SignedBlock(record.blockSlot(), Optional.empty())); + if (!isNeverSigned(record.attestationSourceEpoch()) + || !isNeverSigned(record.attestationTargetEpoch())) { + attestations.add( new SignedAttestation( - record.getAttestationSourceEpoch(), record.getAttestationTargetEpoch(), null)); + record.attestationSourceEpoch(), record.attestationTargetEpoch(), Optional.empty())); } + return new SigningHistory(pubkey, blocks, attestations); } - @Override - public boolean equals(final Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - final SigningHistory that = (SigningHistory) o; - return Objects.equals(pubkey, that.pubkey) - && Objects.equals(signedBlocks, that.signedBlocks) - && Objects.equals(signedAttestations, that.signedAttestations); + public static DeserializableTypeDefinition getJsonTypeDefinition() { + return DeserializableTypeDefinition.object(SigningHistory.class, SigningHistoryBuilder.class) + .initializer(SigningHistoryBuilder::new) + .finisher(SigningHistoryBuilder::build) + .withField("pubkey", PUBKEY_TYPE, SigningHistory::pubkey, SigningHistoryBuilder::pubkey) + .withField( + "signed_blocks", + DeserializableTypeDefinition.listOf(SignedBlock.getJsonTypeDefinition()), + SigningHistory::signedBlocks, + SigningHistoryBuilder::signedBlocks) + .withField( + "signed_attestations", + DeserializableTypeDefinition.listOf(SignedAttestation.getJsonTypeDefinition()), + SigningHistory::signedAttestations, + SigningHistoryBuilder::signedAttestations) + .build(); } @Override @@ -83,29 +78,24 @@ public String toString() { .toString(); } - @Override - public int hashCode() { - return Objects.hash(pubkey, signedBlocks, signedAttestations); - } - public ValidatorSigningRecord toValidatorSigningRecord( final Optional maybeRecord, final Bytes32 genesisValidatorsRoot) { final UInt64 lastSignedBlockSlot = signedBlocks.stream() - .map(SignedBlock::getSlot) + .map(SignedBlock::slot) .filter(Objects::nonNull) .max(UInt64::compareTo) .orElse(UInt64.ZERO); final UInt64 lastSignedAttestationSourceEpoch = signedAttestations.stream() - .map(SignedAttestation::getSourceEpoch) + .map(SignedAttestation::sourceEpoch) .filter(Objects::nonNull) .max(UInt64::compareTo) .orElse(null); final UInt64 lastSignedAttestationTargetEpoch = signedAttestations.stream() - .map(SignedAttestation::getTargetEpoch) + .map(SignedAttestation::targetEpoch) .filter(Objects::nonNull) .max(UInt64::compareTo) .orElse(null); @@ -113,13 +103,13 @@ public ValidatorSigningRecord toValidatorSigningRecord( if (maybeRecord.isPresent()) { final ValidatorSigningRecord record = maybeRecord.get(); return new ValidatorSigningRecord( - genesisValidatorsRoot, - record.getBlockSlot().max(lastSignedBlockSlot), - nullSafeMax(record.getAttestationSourceEpoch(), lastSignedAttestationSourceEpoch), - nullSafeMax(record.getAttestationTargetEpoch(), lastSignedAttestationTargetEpoch)); + Optional.ofNullable(genesisValidatorsRoot), + record.blockSlot().max(lastSignedBlockSlot), + nullSafeMax(record.attestationSourceEpoch(), lastSignedAttestationSourceEpoch), + nullSafeMax(record.attestationTargetEpoch(), lastSignedAttestationTargetEpoch)); } return new ValidatorSigningRecord( - genesisValidatorsRoot, + Optional.ofNullable(genesisValidatorsRoot), lastSignedBlockSlot, lastSignedAttestationSourceEpoch, lastSignedAttestationTargetEpoch); @@ -133,4 +123,29 @@ private UInt64 nullSafeMax(final UInt64 a, final UInt64 b) { } return a.max(b); } + + static class SigningHistoryBuilder { + BLSPublicKey pubkey; + List signedBlocks; + List signedAttestations; + + SigningHistoryBuilder pubkey(final BLSPublicKey pubkey) { + this.pubkey = pubkey; + return this; + } + + SigningHistoryBuilder signedBlocks(final List signedBlocks) { + this.signedBlocks = signedBlocks; + return this; + } + + SigningHistoryBuilder signedAttestations(final List signedAttestations) { + this.signedAttestations = signedAttestations; + return this; + } + + SigningHistory build() { + return new SigningHistory(pubkey, signedBlocks, signedAttestations); + } + } } diff --git a/data/dataexchange/src/main/java/tech/pegasys/teku/data/slashinginterchange/SlashingProtectionInterchangeFormat.java b/data/dataexchange/src/main/java/tech/pegasys/teku/data/slashinginterchange/SlashingProtectionInterchangeFormat.java index 4c3834f3c30..7da7b87f555 100644 --- a/data/dataexchange/src/main/java/tech/pegasys/teku/data/slashinginterchange/SlashingProtectionInterchangeFormat.java +++ b/data/dataexchange/src/main/java/tech/pegasys/teku/data/slashinginterchange/SlashingProtectionInterchangeFormat.java @@ -13,43 +13,53 @@ package tech.pegasys.teku.data.slashinginterchange; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; import com.google.common.base.MoreObjects; import java.util.List; -import java.util.Objects; - -public class SlashingProtectionInterchangeFormat { - public final Metadata metadata; - public final List data; - - @JsonCreator - public SlashingProtectionInterchangeFormat( - @JsonProperty("metadata") final Metadata metadata, - @JsonProperty("data") final List data) { - this.metadata = metadata; - this.data = data; - } +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; - @Override - public boolean equals(final Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - final SlashingProtectionInterchangeFormat that = (SlashingProtectionInterchangeFormat) o; - return Objects.equals(metadata, that.metadata) && Objects.equals(data, that.data); - } +public record SlashingProtectionInterchangeFormat(Metadata metadata, List data) { - @Override - public int hashCode() { - return Objects.hash(metadata, data); + public static DeserializableTypeDefinition + getJsonTypeDefinition() { + return DeserializableTypeDefinition.object( + SlashingProtectionInterchangeFormat.class, + SlashingProtectionInterchangeFormatBuilder.class) + .initializer(SlashingProtectionInterchangeFormatBuilder::new) + .finisher(SlashingProtectionInterchangeFormatBuilder::build) + .withField( + "metadata", + Metadata.getJsonTypeDefinition(), + SlashingProtectionInterchangeFormat::metadata, + SlashingProtectionInterchangeFormatBuilder::metadata) + .withField( + "data", + DeserializableTypeDefinition.listOf(SigningHistory.getJsonTypeDefinition()), + SlashingProtectionInterchangeFormat::data, + SlashingProtectionInterchangeFormatBuilder::data) + .build(); } @Override public String toString() { return MoreObjects.toStringHelper(this).add("metadata", metadata).add("data", data).toString(); } + + static class SlashingProtectionInterchangeFormatBuilder { + Metadata metadata; + List data; + + SlashingProtectionInterchangeFormatBuilder metadata(final Metadata metadata) { + this.metadata = metadata; + return this; + } + + SlashingProtectionInterchangeFormatBuilder data(final List data) { + this.data = data; + return this; + } + + SlashingProtectionInterchangeFormat build() { + return new SlashingProtectionInterchangeFormat(metadata, data); + } + } } diff --git a/data/dataexchange/src/test/java/tech/pegasys/teku/data/SlashingProtectedIncrementalExporterTest.java b/data/dataexchange/src/test/java/tech/pegasys/teku/data/SlashingProtectedIncrementalExporterTest.java index f448bf29d5b..cb76ffec56b 100644 --- a/data/dataexchange/src/test/java/tech/pegasys/teku/data/SlashingProtectedIncrementalExporterTest.java +++ b/data/dataexchange/src/test/java/tech/pegasys/teku/data/SlashingProtectedIncrementalExporterTest.java @@ -35,7 +35,7 @@ public class SlashingProtectedIncrementalExporterTest { "b845089a1457f811bfc000588fbb4e713669be8ce060ea6be3c6ece09afc3794106c91ca73acda5e5457122d58723bed"; @Test - public void shouldExportSlashProtection(@TempDir Path tempDir) + public void shouldExportSlashProtection(@TempDir final Path tempDir) throws IOException, URISyntaxException { final Path exportedFile = tempDir.resolve("exportedFile.json").toAbsolutePath(); final SlashingProtectionIncrementalExporter exporter = @@ -54,7 +54,7 @@ public void shouldExportSlashProtection(@TempDir Path tempDir) } @Test - void shouldCreateEmptySlashingProtectionDocument(@TempDir Path tempDir) throws IOException { + void shouldCreateEmptySlashingProtectionDocument(@TempDir final Path tempDir) throws IOException { final SlashingProtectionIncrementalExporter exporter = new SlashingProtectionIncrementalExporter(tempDir); assertThat(exporter.finalise()).isEqualTo(resourceFileAsString("emptySlashingData.json")); diff --git a/data/dataexchange/src/test/java/tech/pegasys/teku/data/SlashingProtectionExporterTest.java b/data/dataexchange/src/test/java/tech/pegasys/teku/data/SlashingProtectionExporterTest.java index a1647e8e295..710c767d703 100644 --- a/data/dataexchange/src/test/java/tech/pegasys/teku/data/SlashingProtectionExporterTest.java +++ b/data/dataexchange/src/test/java/tech/pegasys/teku/data/SlashingProtectionExporterTest.java @@ -32,28 +32,27 @@ import org.apache.tuweni.bytes.Bytes32; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.io.TempDir; -import tech.pegasys.teku.api.schema.BLSPubKey; +import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.cli.OSUtils; import tech.pegasys.teku.data.slashinginterchange.Metadata; import tech.pegasys.teku.data.slashinginterchange.SignedBlock; import tech.pegasys.teku.data.slashinginterchange.SigningHistory; import tech.pegasys.teku.data.slashinginterchange.SlashingProtectionInterchangeFormat; import tech.pegasys.teku.ethereum.signingrecord.ValidatorSigningRecord; +import tech.pegasys.teku.infrastructure.json.JsonUtil; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.provider.JsonProvider; public class SlashingProtectionExporterTest { private static final Logger LOG = LogManager.getLogger(); final List log = new ArrayList<>(); - private final JsonProvider jsonProvider = new JsonProvider(); private final String pubkey = "b845089a1457f811bfc000588fbb4e713669be8ce060ea6be3c6ece09afc3794106c91ca73acda5e5457122d58723bed"; private final Bytes32 validatorsRoot = Bytes32.fromHexString("0x6e2c5d8a89dfe121a92c8812bea69fe9f84ae48f63aafe34ef7e18c7eac9af70"); @Test - public void shouldReadSlashingProtectionFile_withEmptyGenesisValidatorsRoot(@TempDir Path tempDir) - throws IOException, URISyntaxException { + public void shouldReadSlashingProtectionFile_withEmptyGenesisValidatorsRoot( + @TempDir final Path tempDir) throws IOException, URISyntaxException { final SlashingProtectionExporter exporter = new SlashingProtectionExporter(tempDir); Optional error = exporter.readSlashProtectionFile( @@ -62,15 +61,15 @@ public void shouldReadSlashingProtectionFile_withEmptyGenesisValidatorsRoot(@Tem assertThat(error).isEmpty(); final SlashingProtectionInterchangeFormat parsedData = - jsonProvider.jsonToObject( - exporter.getPrettyJson(), SlashingProtectionInterchangeFormat.class); + JsonUtil.parse( + exporter.getPrettyJson(), SlashingProtectionInterchangeFormat.getJsonTypeDefinition()); final SlashingProtectionInterchangeFormat expectedData = getExportData(null, 327, 51, 1741); assertThat(parsedData).isEqualTo(expectedData); } @Test - public void shouldReadSlashingProtectionFile_withGenesisValidatorsRoot(@TempDir Path tempDir) - throws IOException, URISyntaxException { + public void shouldReadSlashingProtectionFile_withGenesisValidatorsRoot( + @TempDir final Path tempDir) throws IOException, URISyntaxException { final SlashingProtectionExporter exporter = new SlashingProtectionExporter(tempDir); Optional error = exporter.readSlashProtectionFile( @@ -79,15 +78,15 @@ public void shouldReadSlashingProtectionFile_withGenesisValidatorsRoot(@TempDir assertThat(error).isEmpty(); final SlashingProtectionInterchangeFormat parsedData = - jsonProvider.jsonToObject( - exporter.getPrettyJson(), SlashingProtectionInterchangeFormat.class); + JsonUtil.parse( + exporter.getPrettyJson(), SlashingProtectionInterchangeFormat.getJsonTypeDefinition()); final SlashingProtectionInterchangeFormat expectedData = getExportData(validatorsRoot, 327, 51, 1741); assertThat(parsedData).isEqualTo(expectedData); } @Test - public void shouldReadFilesWithEmptyRootAfterGenesisRootIsDefined(@TempDir Path tempDir) + public void shouldReadFilesWithEmptyRootAfterGenesisRootIsDefined(@TempDir final Path tempDir) throws URISyntaxException, IOException { final SlashingProtectionExporter exporter = new SlashingProtectionExporter(tempDir); Optional error = @@ -103,7 +102,7 @@ public void shouldReadFilesWithEmptyRootAfterGenesisRootIsDefined(@TempDir Path } @Test - public void shouldReadFileWithGenesisRootDefinedSecond(@TempDir Path tempDir) + public void shouldReadFileWithGenesisRootDefinedSecond(@TempDir final Path tempDir) throws URISyntaxException, IOException { final SlashingProtectionExporter exporter = new SlashingProtectionExporter(tempDir); Optional error = @@ -119,7 +118,7 @@ public void shouldReadFileWithGenesisRootDefinedSecond(@TempDir Path tempDir) } @Test - public void shouldNotAcceptDifferentGenesisValidatorsRoot(@TempDir Path tempDir) + public void shouldNotAcceptDifferentGenesisValidatorsRoot(@TempDir final Path tempDir) throws URISyntaxException, IOException { final SlashingProtectionExporter exporter = new SlashingProtectionExporter(tempDir); Optional error = @@ -133,7 +132,7 @@ public void shouldNotAcceptDifferentGenesisValidatorsRoot(@TempDir Path tempDir) } @Test - public void shouldRequirePubkeyInFilename(@TempDir Path tempDir) throws URISyntaxException { + public void shouldRequirePubkeyInFilename(@TempDir final Path tempDir) throws URISyntaxException { final SlashingProtectionExporter exporter = new SlashingProtectionExporter(tempDir); final Optional error = exporter.readSlashProtectionFile( @@ -144,7 +143,7 @@ public void shouldRequirePubkeyInFilename(@TempDir Path tempDir) throws URISynta } @Test - public void shouldPrintIfFileCannotBeRead(@TempDir Path tempDir) + public void shouldPrintIfFileCannotBeRead(@TempDir final Path tempDir) throws URISyntaxException, IOException { final SlashingProtectionExporter exporter = new SlashingProtectionExporter(tempDir); final File file = usingResourceFile("slashProtection.yml", tempDir); @@ -156,7 +155,7 @@ public void shouldPrintIfFileCannotBeRead(@TempDir Path tempDir) } @Test - public void shouldExportSlashProtection(@TempDir Path tempDir) + public void shouldExportSlashProtection(@TempDir final Path tempDir) throws IOException, URISyntaxException { final Path exportedFile = tempDir.resolve("exportedFile.json").toAbsolutePath(); final SlashingProtectionExporter exporter = new SlashingProtectionExporter(tempDir); @@ -171,14 +170,14 @@ public void shouldExportSlashProtection(@TempDir Path tempDir) } @Test - void shouldHaveNoSignedAttestationsWhenNoAttestationsSigned(@TempDir Path tempDir) + void shouldHaveNoSignedAttestationsWhenNoAttestationsSigned(@TempDir final Path tempDir) throws Exception { final Path exportedFile = tempDir.resolve("exportedFile.json").toAbsolutePath(); final SlashingProtectionExporter exporter = new SlashingProtectionExporter(tempDir); final UInt64 blockSlot = UInt64.ONE; final ValidatorSigningRecord signingRecord = - new ValidatorSigningRecord(validatorsRoot) + ValidatorSigningRecord.emptySigningRecord(validatorsRoot) .maySignBlock(validatorsRoot, blockSlot) .orElseThrow(); final Path recordFile = tempDir.resolve(pubkey + ".yml"); @@ -191,12 +190,15 @@ void shouldHaveNoSignedAttestationsWhenNoAttestationsSigned(@TempDir Path tempDi assertThat(exportedFile).exists(); final SlashingProtectionInterchangeFormat exportedRecords = - jsonProvider.jsonToObject( - Files.readString(exportedFile), SlashingProtectionInterchangeFormat.class); - assertThat(exportedRecords.data).hasSize(1); - final SigningHistory signingHistory = exportedRecords.data.get(0); - assertThat(signingHistory.signedBlocks).containsExactly(new SignedBlock(blockSlot, null)); - assertThat(signingHistory.signedAttestations).isEmpty(); + JsonUtil.parse( + Files.readString(exportedFile), + SlashingProtectionInterchangeFormat.getJsonTypeDefinition()); + + assertThat(exportedRecords.data()).hasSize(1); + final SigningHistory signingHistory = exportedRecords.data().get(0); + assertThat(signingHistory.signedBlocks()) + .containsExactly(new SignedBlock(blockSlot, Optional.empty())); + assertThat(signingHistory.signedAttestations()).isEmpty(); } private File usingResourceFile(final String resourceFileName, final Path tempDir) @@ -215,12 +217,13 @@ private SlashingProtectionInterchangeFormat getExportData( final int lastSignedAttestationSourceEpoch, final int lastSignedAttestationTargetEpoch) { return new SlashingProtectionInterchangeFormat( - new Metadata(INTERCHANGE_VERSION, genesisValidatorsRoot), + new Metadata( + Optional.empty(), INTERCHANGE_VERSION, Optional.ofNullable(genesisValidatorsRoot)), List.of( - new SigningHistory( - BLSPubKey.fromHexString(pubkey), + SigningHistory.createSigningHistory( + BLSPublicKey.fromHexString(pubkey), new ValidatorSigningRecord( - genesisValidatorsRoot, + Optional.ofNullable(genesisValidatorsRoot), UInt64.valueOf(lastSignedBlockSlot), UInt64.valueOf(lastSignedAttestationSourceEpoch), UInt64.valueOf(lastSignedAttestationTargetEpoch))))); diff --git a/data/dataexchange/src/test/java/tech/pegasys/teku/data/SlashingProtectionImporterTest.java b/data/dataexchange/src/test/java/tech/pegasys/teku/data/SlashingProtectionImporterTest.java index 29f443e8e1e..52d5db61c21 100644 --- a/data/dataexchange/src/test/java/tech/pegasys/teku/data/SlashingProtectionImporterTest.java +++ b/data/dataexchange/src/test/java/tech/pegasys/teku/data/SlashingProtectionImporterTest.java @@ -51,7 +51,7 @@ public class SlashingProtectionImporterTest { public void shouldFailWithParseError(@TempDir final Path tempDir) throws URISyntaxException, IOException { final String errorString = loadAndGetErrorText("minimal_invalidKey.json", tempDir); - assertThat(errorString).startsWith("Failed to load data"); + assertThat(errorString).startsWith("Json does not appear valid."); } @Test @@ -73,11 +73,11 @@ public void shouldFailWithVersionCheckFailure(@TempDir final Path tempDir) public void shouldFailIfMetadataNotPresent(@TempDir final Path tempDir) throws IOException, URISyntaxException { final String errorString = loadAndGetErrorText("signedBlock.json", tempDir); - assertThat(errorString).contains("does not appear to have metadata"); + assertThat(errorString).contains("required fields: (metadata"); } @Test - public void shouldImportSingleRecord(@TempDir Path tempDir) + public void shouldImportSingleRecord(@TempDir final Path tempDir) throws URISyntaxException, IOException { final File ruleFile = usingResourceFile("slashProtection.yml", tempDir); final SlashingProtectionImporter importer = new SlashingProtectionImporter(tempDir); @@ -88,7 +88,7 @@ public void shouldImportSingleRecord(@TempDir Path tempDir) } @Test - public void shouldExportAndImportFile(@TempDir Path tempDir) + public void shouldExportAndImportFile(@TempDir final Path tempDir) throws IOException, URISyntaxException { final Path exportedFile = tempDir.resolve("exportedFile.json").toAbsolutePath(); @@ -115,7 +115,7 @@ public void shouldExportAndImportFile(@TempDir Path tempDir) } @Test - void shouldImportFileOverRepairedRecords(@TempDir Path tempDir) throws Exception { + void shouldImportFileOverRepairedRecords(@TempDir final Path tempDir) throws Exception { final SubCommandLogger logger = mock(SubCommandLogger.class); final Path initialRecords = tempDir.resolve("initial"); final Path repairedRecords = tempDir.resolve("repaired"); @@ -157,10 +157,32 @@ void shouldImportFileOverRepairedRecords(@TempDir Path tempDir) throws Exception assertThat(importedRecord) .isEqualTo( new ValidatorSigningRecord( - initialRecord.getGenesisValidatorsRoot(), - repairedSlot, - repairedEpoch, - repairedEpoch)); + initialRecord.genesisValidatorsRoot(), repairedSlot, repairedEpoch, repairedEpoch)); + } + + @Test + void shouldFailImportingIfValidatorExistingRecordHasDifferentGenesisValidatorsRoot( + @TempDir final Path tempDir) throws URISyntaxException, IOException { + final SlashingProtectionImporter importer = new SlashingProtectionImporter(tempDir); + + final File slashProtection = getResourceFile("format2_minimal.json"); + + importer.initialise(slashProtection); + + Map errors = importer.updateLocalRecords(__ -> {}); + + assertThat(errors).isEmpty(); + + final File slashProtectionWithDifferentGvr = + getResourceFile("format2_minimal_different_genesis_validators_root.json"); + + importer.initialise(slashProtectionWithDifferentGvr); + + errors = importer.updateLocalRecords(__ -> {}); + + assertThat(errors) + .hasSize(1) + .containsEntry(publicKey, "Genesis validators root did not match what was expected."); } private ValidatorSigningRecord loadSigningRecord(final File repairedRuleFile) throws IOException { @@ -182,9 +204,11 @@ private File usingResourceFile(final String resourceFileName, final Path tempDir throws URISyntaxException, IOException { final Path tempFile = tempDir.resolve(pubkey + ".yml").toAbsolutePath(); Files.copy( - new File(Resources.getResource(resourceFileName).toURI()).toPath(), - tempFile, - StandardCopyOption.REPLACE_EXISTING); + getResourceFile(resourceFileName).toPath(), tempFile, StandardCopyOption.REPLACE_EXISTING); return tempFile.toFile(); } + + private File getResourceFile(final String resourceFileName) throws URISyntaxException { + return new File(Resources.getResource(resourceFileName).toURI()); + } } diff --git a/data/dataexchange/src/test/java/tech/pegasys/teku/data/SlashingProtectionRepairerTest.java b/data/dataexchange/src/test/java/tech/pegasys/teku/data/SlashingProtectionRepairerTest.java index dd3930c149f..19e8133981d 100644 --- a/data/dataexchange/src/test/java/tech/pegasys/teku/data/SlashingProtectionRepairerTest.java +++ b/data/dataexchange/src/test/java/tech/pegasys/teku/data/SlashingProtectionRepairerTest.java @@ -39,7 +39,7 @@ public class SlashingProtectionRepairerTest { private static final UInt64 TWO = UInt64.valueOf(2); final ValidatorSigningRecord validatorSigningRecord = - new ValidatorSigningRecord(null, ONE, ONE, ONE); + new ValidatorSigningRecord(Optional.empty(), ONE, ONE, ONE); private SyncDataAccessor syncDataAccessor; private final SubCommandLogger subCommandLogger = mock(SubCommandLogger.class); final Spec spec = TestSpecFactory.createMinimalPhase0(); @@ -78,7 +78,8 @@ void updateSigningRecord_shouldNotRequireInitialRecord() { @Test void updateSigningRecord_shouldUpdateBlockSlot() { - final ValidatorSigningRecord expectedValue = new ValidatorSigningRecord(null, TWO, ONE, ONE); + final ValidatorSigningRecord expectedValue = + new ValidatorSigningRecord(Optional.empty(), TWO, ONE, ONE); assertThat( SlashingProtectionRepairer.updateSigningRecord( TWO, ZERO, Optional.of(validatorSigningRecord))) @@ -87,7 +88,8 @@ void updateSigningRecord_shouldUpdateBlockSlot() { @Test void updateSigningRecord_shouldUpdateAttestationEpoch() { - final ValidatorSigningRecord expectedValue = new ValidatorSigningRecord(null, ONE, TWO, TWO); + final ValidatorSigningRecord expectedValue = + new ValidatorSigningRecord(Optional.empty(), ONE, TWO, TWO); assertThat( SlashingProtectionRepairer.updateSigningRecord( ONE, TWO, Optional.of(validatorSigningRecord))) @@ -96,24 +98,29 @@ void updateSigningRecord_shouldUpdateAttestationEpoch() { @Test void updateSigningRecord_shouldUpdateSourceAttestationEpoch() { - final ValidatorSigningRecord initialValue = new ValidatorSigningRecord(null, ONE, ZERO, TWO); - final ValidatorSigningRecord expectedValue = new ValidatorSigningRecord(null, ONE, ONE, TWO); + final ValidatorSigningRecord initialValue = + new ValidatorSigningRecord(Optional.empty(), ONE, ZERO, TWO); + final ValidatorSigningRecord expectedValue = + new ValidatorSigningRecord(Optional.empty(), ONE, ONE, TWO); assertThat(SlashingProtectionRepairer.updateSigningRecord(ONE, ONE, Optional.of(initialValue))) .isEqualTo(expectedValue); } @Test void updateSigningRecord_shouldUpdateTargetAttestationEpoch() { - final ValidatorSigningRecord initialValue = new ValidatorSigningRecord(null, ONE, TWO, ONE); - final ValidatorSigningRecord expectedValue = new ValidatorSigningRecord(null, ONE, TWO, TWO); + final ValidatorSigningRecord initialValue = + new ValidatorSigningRecord(Optional.empty(), ONE, TWO, ONE); + final ValidatorSigningRecord expectedValue = + new ValidatorSigningRecord(Optional.empty(), ONE, TWO, TWO); assertThat(SlashingProtectionRepairer.updateSigningRecord(ZERO, TWO, Optional.of(initialValue))) .isEqualTo(expectedValue); } @Test - public void shouldNotUpdateFilesWithInvalidPubkeys(@TempDir Path tempDir) throws IOException { + public void shouldNotUpdateFilesWithInvalidPubkeys(@TempDir final Path tempDir) + throws IOException { setupPathForTest(tempDir, Map.of("a.yml", Optional.of(validatorSigningRecord))); - SlashingProtectionRepairer repairer = + final SlashingProtectionRepairer repairer = SlashingProtectionRepairer.create(subCommandLogger, tempDir, true); assertThat(repairer.hasUpdates()).isFalse(); verify(subCommandLogger).display(" --- a.yml - invalid public key - ignoring file"); @@ -126,7 +133,7 @@ public void shouldNotUpdateFilesWithInvalidPubkeys(@TempDir Path tempDir) throws } @Test - public void shouldUpdateValidAndInvalidFiles(@TempDir Path tempDir) throws IOException { + public void shouldUpdateValidAndInvalidFiles(@TempDir final Path tempDir) throws IOException { setupPathForTest(tempDir, testData); SlashingProtectionRepairer repairer = SlashingProtectionRepairer.create(subCommandLogger, tempDir, true); @@ -138,7 +145,8 @@ public void shouldUpdateValidAndInvalidFiles(@TempDir Path tempDir) throws IOExc final Optional defaultRecord = Optional.of( - new ValidatorSigningRecord(null, blockSlot, attestationEpoch, attestationEpoch)); + new ValidatorSigningRecord( + Optional.empty(), blockSlot, attestationEpoch, attestationEpoch)); assertThat(fileContents(tempDir.resolve(keys.get(0)))).isEqualTo(defaultRecord); // all original values were lower, so the entire file should get updated @@ -152,7 +160,7 @@ public void shouldUpdateValidAndInvalidFiles(@TempDir Path tempDir) throws IOExc } @Test - public void shouldUpdateInvalidFiles(@TempDir Path tempDir) throws IOException { + public void shouldUpdateInvalidFiles(@TempDir final Path tempDir) throws IOException { setupPathForTest(tempDir, testData); SlashingProtectionRepairer repairer = SlashingProtectionRepairer.create(subCommandLogger, tempDir, false); @@ -164,7 +172,8 @@ public void shouldUpdateInvalidFiles(@TempDir Path tempDir) throws IOException { final Optional defaultRecord = Optional.of( - new ValidatorSigningRecord(null, blockSlot, attestationEpoch, attestationEpoch)); + new ValidatorSigningRecord( + Optional.empty(), blockSlot, attestationEpoch, attestationEpoch)); assertThat(fileContents(tempDir.resolve(keys.get(0)))).isEqualTo(defaultRecord); assertThat(fileContents(tempDir.resolve(keys.get(1)))).isEqualTo(testData.get(keys.get(1))); @@ -179,7 +188,8 @@ private Optional fileContents(final Path file) throws IO private Optional optionalSigningRecord( final UInt64 blockSlot, final UInt64 sourceEpoch, final UInt64 targetEpoch) { - return Optional.of(new ValidatorSigningRecord(null, blockSlot, sourceEpoch, targetEpoch)); + return Optional.of( + new ValidatorSigningRecord(Optional.empty(), blockSlot, sourceEpoch, targetEpoch)); } private String randomValidatorFile() { @@ -187,7 +197,8 @@ private String randomValidatorFile() { } private void setupPathForTest( - Path slashingProtectionPath, Map> records) + final Path slashingProtectionPath, + final Map> records) throws IOException { syncDataAccessor = SyncDataAccessor.create(slashingProtectionPath); for (Map.Entry> entry : records.entrySet()) { diff --git a/data/dataexchange/src/test/java/tech/pegasys/teku/data/slashinginterchange/MetadataTest.java b/data/dataexchange/src/test/java/tech/pegasys/teku/data/slashinginterchange/MetadataTest.java index d5c194404d4..b8dc2ce8904 100644 --- a/data/dataexchange/src/test/java/tech/pegasys/teku/data/slashinginterchange/MetadataTest.java +++ b/data/dataexchange/src/test/java/tech/pegasys/teku/data/slashinginterchange/MetadataTest.java @@ -17,24 +17,22 @@ import static tech.pegasys.teku.data.slashinginterchange.Metadata.INTERCHANGE_VERSION; import com.fasterxml.jackson.core.JsonProcessingException; -import com.fasterxml.jackson.databind.JsonNode; -import com.fasterxml.jackson.databind.ObjectMapper; import com.google.common.io.Resources; import java.io.IOException; import java.nio.charset.StandardCharsets; +import java.util.Optional; import org.apache.tuweni.bytes.Bytes32; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.provider.JsonProvider; +import tech.pegasys.teku.infrastructure.json.JsonUtil; public class MetadataTest { private final String jsonData; - private final JsonProvider jsonProvider = new JsonProvider(); - private final ObjectMapper mapper = jsonProvider.getObjectMapper(); final Bytes32 root = Bytes32.fromHexString("0x6e2c5d8a89dfe121a92c8812bea69fe9f84ae48f63aafe34ef7e18c7eac9af70"); final Metadata expectedMetadata = - new Metadata(INTERCHANGE_VERSION, Bytes32.fromHexString("0x123456")); + new Metadata( + Optional.empty(), INTERCHANGE_VERSION, Optional.of(Bytes32.fromHexString("0x123456"))); public MetadataTest() throws IOException { jsonData = Resources.toString(Resources.getResource("metadata.json"), StandardCharsets.UTF_8); @@ -42,48 +40,50 @@ public MetadataTest() throws IOException { @Test public void shouldSerializeMinimalFormat() throws JsonProcessingException { - final Metadata metadata = new Metadata(INTERCHANGE_VERSION, root); - assertThat(jsonProvider.objectToPrettyJSON(metadata)).isEqualToNormalizingNewlines(jsonData); + final Metadata metadata = + new Metadata(Optional.empty(), INTERCHANGE_VERSION, Optional.of(root)); + assertThat(JsonUtil.prettySerialize(metadata, Metadata.getJsonTypeDefinition())) + .isEqualToNormalizingNewlines(jsonData); } @Test public void shouldSerializeWithoutRoot() throws JsonProcessingException { - final Metadata metadata = new Metadata(INTERCHANGE_VERSION, null); - assertThat(jsonProvider.objectToPrettyJSON(metadata)) + final Metadata metadata = new Metadata(Optional.empty(), INTERCHANGE_VERSION, Optional.empty()); + assertThat(JsonUtil.prettySerialize(metadata, Metadata.getJsonTypeDefinition())) .isEqualToIgnoringWhitespace("{\"interchange_format_version\":\"5\"}"); } @Test public void shouldSerializeCompleteFormat() throws JsonProcessingException { - final Metadata metadata = new Metadata(INTERCHANGE_VERSION, root); - assertThat(jsonProvider.objectToPrettyJSON(metadata)).isEqualToNormalizingNewlines(jsonData); + final Metadata metadata = + new Metadata(Optional.empty(), INTERCHANGE_VERSION, Optional.of(root)); + assertThat(JsonUtil.prettySerialize(metadata, Metadata.getJsonTypeDefinition())) + .isEqualToNormalizingNewlines(jsonData); } @Test public void shouldDeserialize() throws JsonProcessingException { - final Metadata metadata = jsonProvider.jsonToObject(jsonData, Metadata.class); - assertThat(metadata.interchangeFormatVersion).isEqualTo(INTERCHANGE_VERSION); - assertThat(metadata.genesisValidatorsRoot).isEqualTo(root); + final Metadata metadata = JsonUtil.parse(jsonData, Metadata.getJsonTypeDefinition()); + assertThat(metadata.interchangeFormatVersion()).isEqualTo(INTERCHANGE_VERSION); + assertThat(metadata.genesisValidatorsRoot()).contains(root); } @Test public void shouldReadMetadataFromCompleteJson() throws IOException { final String completeJson = Resources.toString(Resources.getResource("format1_complete.json"), StandardCharsets.UTF_8); + final SlashingProtectionInterchangeFormat format = + JsonUtil.parse(completeJson, SlashingProtectionInterchangeFormat.getJsonTypeDefinition()); - JsonNode metadataJson = mapper.readTree(completeJson).get("metadata"); - Metadata metadata = mapper.treeToValue(metadataJson, Metadata.class); - - assertThat(metadata).isEqualTo(expectedMetadata); + assertThat(format.metadata()).isEqualTo(expectedMetadata); } @Test public void shouldReadMetadataFromJson() throws IOException { final String minimalJson = Resources.toString(Resources.getResource("format2_minimal.json"), StandardCharsets.UTF_8); - - JsonNode metadataJson = mapper.readTree(minimalJson).get("metadata"); - Metadata metadata = mapper.treeToValue(metadataJson, Metadata.class); - assertThat(metadata).isEqualTo(expectedMetadata); + final SlashingProtectionInterchangeFormat format = + JsonUtil.parse(minimalJson, SlashingProtectionInterchangeFormat.getJsonTypeDefinition()); + assertThat(format.metadata()).isEqualTo(expectedMetadata); } } diff --git a/data/dataexchange/src/test/java/tech/pegasys/teku/data/slashinginterchange/MinimalSigningHistoryTest.java b/data/dataexchange/src/test/java/tech/pegasys/teku/data/slashinginterchange/MinimalSigningHistoryTest.java index 7fbaaeb5c91..9b070d38e1d 100644 --- a/data/dataexchange/src/test/java/tech/pegasys/teku/data/slashinginterchange/MinimalSigningHistoryTest.java +++ b/data/dataexchange/src/test/java/tech/pegasys/teku/data/slashinginterchange/MinimalSigningHistoryTest.java @@ -16,27 +16,25 @@ import static org.assertj.core.api.Assertions.assertThat; import static tech.pegasys.teku.data.slashinginterchange.Metadata.INTERCHANGE_VERSION; -import com.fasterxml.jackson.databind.JsonNode; -import com.fasterxml.jackson.databind.ObjectMapper; import com.google.common.io.Resources; import java.io.IOException; import java.nio.charset.StandardCharsets; -import java.util.Arrays; import java.util.List; +import java.util.Optional; import org.apache.tuweni.bytes.Bytes32; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.schema.BLSPubKey; +import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.ethereum.signingrecord.ValidatorSigningRecord; +import tech.pegasys.teku.infrastructure.json.JsonUtil; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.provider.JsonProvider; public class MinimalSigningHistoryTest { - private static final Bytes32 GENESIS_ROOT = - Bytes32.fromHexString("0x0000000000000000000000000000000000000000000000000000000000123456"); - private final JsonProvider jsonProvider = new JsonProvider(); - private final ObjectMapper mapper = jsonProvider.getObjectMapper(); - private final BLSPubKey blsPubKey = - BLSPubKey.fromHexString( + private static final Optional GENESIS_ROOT = + Optional.of( + Bytes32.fromHexString( + "0x0000000000000000000000000000000000000000000000000000000000123456")); + private final BLSPublicKey blsPubKey = + BLSPublicKey.fromHexString( "0xb845089a1457f811bfc000588fbb4e713669be8ce060ea6be3c6ece09afc3794106c91ca73acda5e5457122d58723bed"); @Test @@ -44,16 +42,16 @@ public void shouldReadMetadataFromMinimalJson() throws IOException { final String minimalJson = Resources.toString(Resources.getResource("format2_minimal.json"), StandardCharsets.UTF_8); - JsonNode jsonNode = mapper.readTree(minimalJson); - JsonNode metadataJson = jsonNode.get("metadata"); - Metadata metadata = mapper.treeToValue(metadataJson, Metadata.class); - assertThat(metadata).isEqualTo(new Metadata(INTERCHANGE_VERSION, GENESIS_ROOT)); + final SlashingProtectionInterchangeFormat parsed = + JsonUtil.parse(minimalJson, SlashingProtectionInterchangeFormat.getJsonTypeDefinition()); - List minimalSigningHistoryList = - Arrays.asList(mapper.readValue(jsonNode.get("data").toString(), SigningHistory[].class)); + assertThat(parsed.metadata()) + .isEqualTo(new Metadata(Optional.empty(), INTERCHANGE_VERSION, GENESIS_ROOT)); - SigningHistory element = - new SigningHistory( + final List minimalSigningHistoryList = parsed.data(); + + final SigningHistory element = + SigningHistory.createSigningHistory( blsPubKey, new ValidatorSigningRecord( GENESIS_ROOT, UInt64.valueOf(81952), UInt64.valueOf(2290), UInt64.valueOf(3007))); diff --git a/data/dataexchange/src/test/java/tech/pegasys/teku/data/slashinginterchange/SignedAttestationTest.java b/data/dataexchange/src/test/java/tech/pegasys/teku/data/slashinginterchange/SignedAttestationTest.java index 932693946b6..01fb0f37d2e 100644 --- a/data/dataexchange/src/test/java/tech/pegasys/teku/data/slashinginterchange/SignedAttestationTest.java +++ b/data/dataexchange/src/test/java/tech/pegasys/teku/data/slashinginterchange/SignedAttestationTest.java @@ -19,13 +19,13 @@ import com.google.common.io.Resources; import java.io.IOException; import java.nio.charset.StandardCharsets; +import java.util.Optional; import org.apache.tuweni.bytes.Bytes32; import org.junit.jupiter.api.Test; +import tech.pegasys.teku.infrastructure.json.JsonUtil; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.provider.JsonProvider; public class SignedAttestationTest { - private final JsonProvider jsonProvider = new JsonProvider(); final UInt64 target = UInt64.valueOf(1024); final UInt64 source = UInt64.valueOf(2048); final Bytes32 signingRoot = @@ -37,25 +37,37 @@ public SignedAttestationTest() throws IOException {} @Test public void shouldCreate() { - final SignedAttestation signedAttestation = new SignedAttestation(source, target, signingRoot); - assertThat(signedAttestation.sourceEpoch).isEqualTo(source); - assertThat(signedAttestation.targetEpoch).isEqualTo(target); - assertThat(signedAttestation.signingRoot).isEqualTo(signingRoot); + final SignedAttestation signedAttestation = + new SignedAttestation(source, target, Optional.of(signingRoot)); + assertThat(signedAttestation.sourceEpoch()).isEqualTo(source); + assertThat(signedAttestation.targetEpoch()).isEqualTo(target); + assertThat(signedAttestation.signingRoot()).contains(signingRoot); + } + + @Test + public void shouldCreateWithoutSigningRoot() { + final SignedAttestation signedAttestation = + new SignedAttestation(source, target, Optional.empty()); + assertThat(signedAttestation.sourceEpoch()).isEqualTo(source); + assertThat(signedAttestation.targetEpoch()).isEqualTo(target); + assertThat(signedAttestation.signingRoot()).isEmpty(); } @Test public void shouldSerialize() throws JsonProcessingException { - final SignedAttestation signedAttestation = new SignedAttestation(source, target, signingRoot); - String str = jsonProvider.objectToPrettyJSON(signedAttestation); + final SignedAttestation signedAttestation = + new SignedAttestation(source, target, Optional.of(signingRoot)); + String str = + JsonUtil.prettySerialize(signedAttestation, SignedAttestation.getJsonTypeDefinition()); assertThat(str).isEqualToNormalizingNewlines(jsonData); } @Test public void shouldDeserialize() throws JsonProcessingException { final SignedAttestation signedAttestation = - jsonProvider.jsonToObject(jsonData, SignedAttestation.class); - assertThat(signedAttestation.sourceEpoch).isEqualTo(source); - assertThat(signedAttestation.targetEpoch).isEqualTo(target); - assertThat(signedAttestation.signingRoot).isEqualTo(signingRoot); + JsonUtil.parse(jsonData, SignedAttestation.getJsonTypeDefinition()); + assertThat(signedAttestation.sourceEpoch()).isEqualTo(source); + assertThat(signedAttestation.targetEpoch()).isEqualTo(target); + assertThat(signedAttestation.signingRoot()).contains(signingRoot); } } diff --git a/data/dataexchange/src/test/java/tech/pegasys/teku/data/slashinginterchange/SignedBlockTest.java b/data/dataexchange/src/test/java/tech/pegasys/teku/data/slashinginterchange/SignedBlockTest.java index b8bfb1db2a8..c7673a9bf36 100644 --- a/data/dataexchange/src/test/java/tech/pegasys/teku/data/slashinginterchange/SignedBlockTest.java +++ b/data/dataexchange/src/test/java/tech/pegasys/teku/data/slashinginterchange/SignedBlockTest.java @@ -19,13 +19,13 @@ import com.google.common.io.Resources; import java.io.IOException; import java.nio.charset.StandardCharsets; +import java.util.Optional; import org.apache.tuweni.bytes.Bytes32; import org.junit.jupiter.api.Test; +import tech.pegasys.teku.infrastructure.json.JsonUtil; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.provider.JsonProvider; public class SignedBlockTest { - private final JsonProvider jsonProvider = new JsonProvider(); final UInt64 slot = UInt64.MAX_VALUE; final Bytes32 signingRoot = Bytes32.fromHexString("0x6e2c5d8a89dfe121a92c8812bea69fe9f84ae48f63aafe34ef7e18c7eac9af70"); @@ -36,15 +36,15 @@ public SignedBlockTest() throws IOException {} @Test public void shouldSerialize() throws JsonProcessingException { - final SignedBlock signedBlock = new SignedBlock(slot, signingRoot); - String str = jsonProvider.objectToPrettyJSON(signedBlock); + final SignedBlock signedBlock = new SignedBlock(slot, Optional.of(signingRoot)); + final String str = JsonUtil.prettySerialize(signedBlock, SignedBlock.getJsonTypeDefinition()); assertThat(str).isEqualToNormalizingNewlines(jsonData); } @Test public void shouldDeserialize() throws JsonProcessingException { - final SignedBlock signedBlock = jsonProvider.jsonToObject(jsonData, SignedBlock.class); - assertThat(signedBlock.slot).isEqualTo(slot); - assertThat(signedBlock.signingRoot).isEqualTo(signingRoot); + final SignedBlock signedBlock = JsonUtil.parse(jsonData, SignedBlock.getJsonTypeDefinition()); + assertThat(signedBlock.slot()).isEqualTo(slot); + assertThat(signedBlock.signingRoot()).contains(signingRoot); } } diff --git a/data/dataexchange/src/test/java/tech/pegasys/teku/data/slashinginterchange/SigningHistoryTest.java b/data/dataexchange/src/test/java/tech/pegasys/teku/data/slashinginterchange/SigningHistoryTest.java index 2f9e97301a9..8cf803791a3 100644 --- a/data/dataexchange/src/test/java/tech/pegasys/teku/data/slashinginterchange/SigningHistoryTest.java +++ b/data/dataexchange/src/test/java/tech/pegasys/teku/data/slashinginterchange/SigningHistoryTest.java @@ -16,26 +16,22 @@ import static org.assertj.core.api.Assertions.assertThat; import static tech.pegasys.teku.data.slashinginterchange.Metadata.INTERCHANGE_VERSION; -import com.fasterxml.jackson.databind.JsonNode; -import com.fasterxml.jackson.databind.ObjectMapper; import com.google.common.io.Resources; import java.io.IOException; import java.nio.charset.StandardCharsets; -import java.util.Arrays; import java.util.List; +import java.util.Optional; import org.apache.tuweni.bytes.Bytes32; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.schema.BLSPubKey; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.infrastructure.json.JsonUtil; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.provider.JsonProvider; public class SigningHistoryTest { private static final Bytes32 GENESIS_ROOT = Bytes32.fromHexString("0x0000000000000000000000000000000000000000000000000000000000123456"); - private final JsonProvider jsonProvider = new JsonProvider(); - private final ObjectMapper mapper = jsonProvider.getObjectMapper(); - private final BLSPubKey blsPubKey = - BLSPubKey.fromHexString( + private final BLSPublicKey blsPubKey = + BLSPublicKey.fromHexString( "0xb845089a1457f811bfc000588fbb4e713669be8ce060ea6be3c6ece09afc3794106c91ca73acda5e5457122d58723bed"); @Test @@ -43,28 +39,28 @@ public void shouldReadMetadataFromCompleteJson() throws IOException { final String minimalJson = Resources.toString(Resources.getResource("format1_complete.json"), StandardCharsets.UTF_8); - JsonNode jsonNode = mapper.readTree(minimalJson); - JsonNode metadataJson = jsonNode.get("metadata"); - Metadata metadata = mapper.treeToValue(metadataJson, Metadata.class); - assertThat(metadata).isEqualTo(new Metadata(INTERCHANGE_VERSION, GENESIS_ROOT)); + final SlashingProtectionInterchangeFormat parsed = + JsonUtil.parse(minimalJson, SlashingProtectionInterchangeFormat.getJsonTypeDefinition()); - List completeSigningHistories = - Arrays.asList(mapper.readValue(jsonNode.get("data").toString(), SigningHistory[].class)); + assertThat(parsed.metadata()) + .isEqualTo(new Metadata(Optional.empty(), INTERCHANGE_VERSION, Optional.of(GENESIS_ROOT))); - assertThat(completeSigningHistories) + assertThat(parsed.data()) .containsExactly( new SigningHistory( blsPubKey, List.of( new SignedBlock( UInt64.valueOf(81952), - Bytes32.fromHexString( - "0x0000000000000000000000000000000000000000000000000000000000001234"))), + Optional.of( + Bytes32.fromHexString( + "0x0000000000000000000000000000000000000000000000000000000000001234")))), List.of( new SignedAttestation( UInt64.valueOf(2290), UInt64.valueOf(3007), - Bytes32.fromHexString( - "0x0000000000000000000000000000000000000000000000000000000000000123"))))); + Optional.of( + Bytes32.fromHexString( + "0x0000000000000000000000000000000000000000000000000000000000000123")))))); } } diff --git a/data/dataexchange/src/test/resources/format2_minimal.json b/data/dataexchange/src/test/resources/format2_minimal.json index 9a4f1645fef..89c0bab40c1 100644 --- a/data/dataexchange/src/test/resources/format2_minimal.json +++ b/data/dataexchange/src/test/resources/format2_minimal.json @@ -7,7 +7,8 @@ { "pubkey": "0xb845089a1457f811bfc000588fbb4e713669be8ce060ea6be3c6ece09afc3794106c91ca73acda5e5457122d58723bed", "signed_blocks": [ - {"slot": "81952" + { + "slot": "81952" } ], "signed_attestations": [ diff --git a/data/dataexchange/src/test/resources/format2_minimal_different_genesis_validators_root.json b/data/dataexchange/src/test/resources/format2_minimal_different_genesis_validators_root.json new file mode 100644 index 00000000000..9a926c08fd6 --- /dev/null +++ b/data/dataexchange/src/test/resources/format2_minimal_different_genesis_validators_root.json @@ -0,0 +1,22 @@ +{ + "metadata": { + "interchange_format_version": "5", + "genesis_validators_root": "0x0000000000000000000000000000000000000000000000000000000000123457" + }, + "data": [ + { + "pubkey": "0xb845089a1457f811bfc000588fbb4e713669be8ce060ea6be3c6ece09afc3794106c91ca73acda5e5457122d58723bed", + "signed_blocks": [ + { + "slot": "81952" + } + ], + "signed_attestations": [ + { + "source_epoch": "2290", + "target_epoch": "3007" + } + ] + } + ] +} \ No newline at end of file diff --git a/data/provider/build.gradle b/data/provider/build.gradle index 4cc4a6eaf06..7ebbfbdfa02 100644 --- a/data/provider/build.gradle +++ b/data/provider/build.gradle @@ -17,7 +17,7 @@ dependencies { implementation project(':ethereum:json-types') - implementation 'org.apache.tuweni:tuweni-units' + implementation 'io.tmio:tuweni-units' testImplementation testFixtures(project(':ethereum:spec')) testImplementation testFixtures(project(':infrastructure:async')) diff --git a/data/provider/src/main/java/tech/pegasys/teku/api/AbstractSelectorFactory.java b/data/provider/src/main/java/tech/pegasys/teku/api/AbstractSelectorFactory.java index 90462b99cef..9e65b2509a8 100644 --- a/data/provider/src/main/java/tech/pegasys/teku/api/AbstractSelectorFactory.java +++ b/data/provider/src/main/java/tech/pegasys/teku/api/AbstractSelectorFactory.java @@ -60,11 +60,11 @@ public T createSelectorForBlockId(final String blockId) { } } - public T stateRootSelector(Bytes32 stateRoot) { + public T stateRootSelector(final Bytes32 stateRoot) { throw new UnsupportedOperationException(); } - public T blockRootSelector(Bytes32 blockRoot) { + public T blockRootSelector(final Bytes32 blockRoot) { throw new UnsupportedOperationException(); } @@ -84,7 +84,7 @@ public T justifiedSelector() { throw new UnsupportedOperationException(); } - public T slotSelector(UInt64 slot) { + public T slotSelector(final UInt64 slot) { throw new UnsupportedOperationException(); } diff --git a/data/provider/src/main/java/tech/pegasys/teku/api/ChainDataProvider.java b/data/provider/src/main/java/tech/pegasys/teku/api/ChainDataProvider.java index 7c0defb4a3b..3d80b8ebb08 100644 --- a/data/provider/src/main/java/tech/pegasys/teku/api/ChainDataProvider.java +++ b/data/provider/src/main/java/tech/pegasys/teku/api/ChainDataProvider.java @@ -48,8 +48,6 @@ import tech.pegasys.teku.api.response.v1.beacon.GenesisData; import tech.pegasys.teku.api.response.v1.beacon.ValidatorStatus; import tech.pegasys.teku.api.rewards.EpochAttestationRewardsCalculator; -import tech.pegasys.teku.api.schema.BeaconState; -import tech.pegasys.teku.api.schema.Fork; import tech.pegasys.teku.api.stateselector.StateSelectorFactory; import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.ethereum.json.types.beacon.StateValidatorData; @@ -67,12 +65,14 @@ import tech.pegasys.teku.spec.datastructures.forkchoice.ProtoNodeData; import tech.pegasys.teku.spec.datastructures.forkchoice.ReadOnlyForkChoiceStrategy; import tech.pegasys.teku.spec.datastructures.lightclient.LightClientBootstrap; +import tech.pegasys.teku.spec.datastructures.metadata.BlobSidecarsAndMetaData; import tech.pegasys.teku.spec.datastructures.metadata.BlockAndMetaData; import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; import tech.pegasys.teku.spec.datastructures.metadata.StateAndMetaData; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.state.CommitteeAssignment; import tech.pegasys.teku.spec.datastructures.state.SyncCommittee; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.logic.common.statetransition.epoch.status.ValidatorStatuses; import tech.pegasys.teku.spec.logic.common.statetransition.exceptions.EpochProcessingException; import tech.pegasys.teku.spec.logic.common.statetransition.exceptions.SlotProcessingException; @@ -89,7 +89,6 @@ public class ChainDataProvider { private final DataColumnSidecarSelectorFactory dataColumnSidecarSelectorFactory; private final Spec spec; private final CombinedChainDataClient combinedChainDataClient; - private final SchemaObjectProvider schemaObjectProvider; private final RecentChainData recentChainData; private final RewardCalculator rewardCalculator; @@ -124,7 +123,6 @@ public ChainDataProvider( this.spec = spec; this.combinedChainDataClient = combinedChainDataClient; this.recentChainData = recentChainData; - this.schemaObjectProvider = new SchemaObjectProvider(spec); this.blockSelectorFactory = blockSelectorFactory; this.stateSelectorFactory = stateSelectorFactory; this.blobSidecarSelectorFactory = blobSidecarSelectorFactory; @@ -132,8 +130,7 @@ public ChainDataProvider( this.rewardCalculator = rewardCalculator; } - public UInt64 getCurrentEpoch( - tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState state) { + public UInt64 getCurrentEpoch(final BeaconState state) { return spec.getCurrentEpoch(state); } @@ -188,7 +185,7 @@ public SafeFuture>> getBlock( return fromBlock(blockIdParam, Function.identity()); } - public SafeFuture>> getBlobSidecars( + public SafeFuture> getBlobSidecars( final String blockIdParam, final List indices) { return blobSidecarSelectorFactory .createSelectorForBlockId(blockIdParam) @@ -197,7 +194,11 @@ public SafeFuture>> getBlobSidecars( public SafeFuture>> getAllBlobSidecarsAtSlot( final UInt64 slot, final List indices) { - return blobSidecarSelectorFactory.slotSelectorForAll(slot).getBlobSidecars(indices); + return blobSidecarSelectorFactory + .slotSelectorForAll(slot) + .getBlobSidecars(indices) + .thenApply( + maybeBlobSideCarsMetaData -> maybeBlobSideCarsMetaData.map(ObjectAndMetaData::getData)); } public SafeFuture>> getDataColumnSidecars( @@ -221,11 +222,6 @@ public boolean isStoreAvailable() { return combinedChainDataClient.isStoreAvailable(); } - public SafeFuture>> getSchemaBeaconState( - final String stateIdParam) { - return fromState(stateIdParam, schemaObjectProvider::getBeaconState); - } - public SafeFuture> getBeaconStateAtHead() { return stateSelectorFactory.headSelector().getState(); } @@ -239,8 +235,7 @@ public SafeFuture> getAllBlocksAtSlot(final UInt64 slot) return blockSelectorFactory.nonCanonicalBlocksSelector(slot).getBlocks(); } - public SafeFuture> - getBeaconStateByBlockId(final String blockIdParam) { + public SafeFuture> getBeaconStateByBlockId(final String blockIdParam) { return stateSelectorFactory .createSelectorForBlockId(blockIdParam) .getState() @@ -261,8 +256,7 @@ public ForkChoiceData getForkChoiceData() { } private Optional validatorParameterToIndex( - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState state, - final String validatorParameter) { + final BeaconState state, final String validatorParameter) { if (!isStoreAvailable()) { throw new ChainDataUnavailableException(); } @@ -307,10 +301,6 @@ private Bytes48 getBytes48FromParameter(final String validatorParameter) { } } - public SafeFuture>> getStateFork(final String stateIdParam) { - return fromState(stateIdParam, state -> new Fork(state.getFork())); - } - public SafeFuture>>> getStateValidatorBalances(final String stateIdParam, final List validators) { return fromState(stateIdParam, state -> getValidatorBalancesFromState(state, validators)); @@ -318,8 +308,7 @@ public SafeFuture>> getStateFork(final String s @VisibleForTesting List getValidatorBalancesFromState( - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState state, - final List validators) { + final BeaconState state, final List validators) { return getValidatorSelector(state, validators) .mapToObj(index -> StateValidatorBalanceData.fromState(state, index)) .flatMap(Optional::stream) @@ -372,8 +361,7 @@ public SafeFuture>>> getRandaoAtEpo @VisibleForTesting Optional getRandaoAtEpochFromState( - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState state, - final Optional maybeEpoch) { + final BeaconState state, final Optional maybeEpoch) { final UInt64 stateEpoch = spec.computeEpochAtSlot(state.getSlot()); final int epochsPerHistoricalVector = spec.atEpoch(stateEpoch).getConfig().getEpochsPerHistoricalVector(); @@ -393,7 +381,7 @@ Optional getRandaoAtEpochFromState( @VisibleForTesting List getFilteredValidatorList( - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState state, + final BeaconState state, final List validators, final Set statusFilter) { final UInt64 epoch = spec.getCurrentEpoch(state); @@ -406,8 +394,7 @@ List getFilteredValidatorList( public Optional> getStateValidator( final StateAndMetaData stateData, final String validatorIdParam) { - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState state = - stateData.getData(); + final BeaconState state = stateData.getData(); final UInt64 epoch = getCurrentEpoch(state); final Optional maybeValidator = getValidatorSelector(state, List.of(validatorIdParam)) @@ -456,17 +443,17 @@ public Optional getCurrentEpoch() { } List getCommitteesFromState( - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState state, + final BeaconState state, final Optional epoch, final Optional committeeIndex, final Optional slot) { final Predicate slotFilter = - slot.isEmpty() ? __ -> true : (assignment) -> assignment.getSlot().equals(slot.get()); + slot.isEmpty() ? __ -> true : (assignment) -> assignment.slot().equals(slot.get()); final Predicate committeeFilter = committeeIndex.isEmpty() ? __ -> true - : (assignment) -> assignment.getCommitteeIndex().compareTo(committeeIndex.get()) == 0; + : (assignment) -> assignment.committeeIndex().compareTo(committeeIndex.get()) == 0; final UInt64 stateEpoch = spec.computeEpochAtSlot(state.getSlot()); if (epoch.isPresent() && epoch.get().isGreaterThan(stateEpoch.plus(ONE))) { @@ -487,17 +474,14 @@ List getCommitteesFromState( } private IntPredicate getStatusPredicate( - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState state, - final Set statusFilter) { + final BeaconState state, final Set statusFilter) { final UInt64 epoch = spec.getCurrentEpoch(state); return statusFilter.isEmpty() ? i -> true : i -> statusFilter.contains(getValidatorStatus(state, i, epoch, FAR_FUTURE_EPOCH)); } - private IntStream getValidatorSelector( - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState state, - final List validators) { + private IntStream getValidatorSelector(final BeaconState state, final List validators) { return validators.isEmpty() ? IntStream.range(0, state.getValidators().size()) : validators.stream() @@ -548,8 +532,7 @@ public SafeFuture>> getState } private StateSyncCommitteesData getSyncCommitteesFromState( - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState state, - final Optional epochQueryParam) { + final BeaconState state, final Optional epochQueryParam) { final UInt64 epoch = epochQueryParam.orElse(spec.computeEpochAtSlot(state.getSlot())); final UInt64 slot = spec.computeStartSlotAtEpoch(epoch); @@ -692,7 +675,7 @@ private Optional findLatestAvailableEpochForRewardCalculation() { } public SafeFuture>>> getExpectedWithdrawals( - String stateIdParam, Optional optionalProposalSlot) { + final String stateIdParam, final Optional optionalProposalSlot) { return stateSelectorFactory .createSelectorForStateId(stateIdParam) .getState() @@ -713,8 +696,7 @@ public SafeFuture>>> getExpectedWith } List getExpectedWithdrawalsFromState( - tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState data, - Optional optionalProposalSlot) { + final BeaconState data, final Optional optionalProposalSlot) { final UInt64 proposalSlot = optionalProposalSlot.orElse(data.getSlot().increment()); // Apply some sanity checks prior to computing pre-state if (!spec.atSlot(proposalSlot).getMilestone().isGreaterThanOrEqualTo(SpecMilestone.CAPELLA)) { @@ -738,12 +720,11 @@ List getExpectedWithdrawalsFromState( } try { // need to get preState - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState preState = - spec.processSlots(data, proposalSlot); + final BeaconState preState = spec.processSlots(data, proposalSlot); return spec.atSlot(proposalSlot) .getBlockProcessor() .getExpectedWithdrawals(preState) - .orElse(List.of()); + .getWithdrawalList(); } catch (SlotProcessingException | EpochProcessingException e) { LOG.debug("Failed to get expected withdrawals for slot {}", proposalSlot, e); } @@ -769,12 +750,16 @@ private SafeFuture>> fromBlock( } private SafeFuture>> fromState( - final String stateIdParam, - final Function - mapper) { + final String stateIdParam, final Function mapper) { return stateSelectorFactory .createSelectorForStateId(stateIdParam) .getState() .thenApply(maybeStateData -> maybeStateData.map(blockData -> blockData.map(mapper))); } + + public SafeFuture> getFinalizedStateSlot(final UInt64 beforeSlot) { + return combinedChainDataClient + .getLatestAvailableFinalizedState(beforeSlot) + .thenApply(maybeState -> maybeState.map(BeaconState::getSlot)); + } } diff --git a/data/provider/src/main/java/tech/pegasys/teku/api/ConfigProvider.java b/data/provider/src/main/java/tech/pegasys/teku/api/ConfigProvider.java index cc201684a3d..5770ec16ca9 100644 --- a/data/provider/src/main/java/tech/pegasys/teku/api/ConfigProvider.java +++ b/data/provider/src/main/java/tech/pegasys/teku/api/ConfigProvider.java @@ -42,6 +42,9 @@ public static String formatValue(final Object v) { if (v instanceof UInt256) { return ((UInt256) v).toDecimalString(); } + if (v == null) { + return null; + } return v.toString(); } diff --git a/data/provider/src/main/java/tech/pegasys/teku/api/DataProvider.java b/data/provider/src/main/java/tech/pegasys/teku/api/DataProvider.java index e5421a7ab2b..2af0c466c79 100644 --- a/data/provider/src/main/java/tech/pegasys/teku/api/DataProvider.java +++ b/data/provider/src/main/java/tech/pegasys/teku/api/DataProvider.java @@ -241,8 +241,9 @@ public DataProvider build() { isLivenessTrackingEnabled, activeValidatorChannel, proposersDataManager, - forkChoiceNotifier); - + forkChoiceNotifier, + recentChainData, + spec); final ChainDataProvider chainDataProvider = new ChainDataProvider( spec, diff --git a/data/provider/src/main/java/tech/pegasys/teku/api/NetworkDataProvider.java b/data/provider/src/main/java/tech/pegasys/teku/api/NetworkDataProvider.java index 8f440e3431c..94ef405237f 100644 --- a/data/provider/src/main/java/tech/pegasys/teku/api/NetworkDataProvider.java +++ b/data/provider/src/main/java/tech/pegasys/teku/api/NetworkDataProvider.java @@ -21,6 +21,9 @@ import tech.pegasys.teku.api.response.v1.node.Direction; import tech.pegasys.teku.api.response.v1.node.Peer; import tech.pegasys.teku.api.response.v1.node.State; +import tech.pegasys.teku.ethereum.json.types.node.PeerCount; +import tech.pegasys.teku.ethereum.json.types.node.PeerCountBuilder; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.networking.eth2.Eth2P2PNetwork; import tech.pegasys.teku.networking.eth2.peers.Eth2Peer; import tech.pegasys.teku.networking.p2p.discovery.DiscoveryNetwork; @@ -70,26 +73,16 @@ public String getNodeIdAsBase58() { * * @return the the number of peers currently connected to the client */ - public long getPeerCount() { + public long countPeers() { return network.streamPeers().count(); } - /** - * Get the listen port - * - * @return the port this client is listening on - */ - public int getListenPort() { - return network.getListenPort(); - } - public List getListeningAddresses() { - return List.of(network.getNodeAddress()); + return network.getNodeAddresses(); } public List getDiscoveryAddresses() { - Optional discoveryAddressOptional = network.getDiscoveryAddress(); - return discoveryAddressOptional.map(List::of).orElseGet(List::of); + return network.getDiscoveryAddresses().orElseGet(List::of); } public MetadataMessage getMetadata() { @@ -114,6 +107,24 @@ public List getEth2PeersWithEnr() { .toList(); } + public PeerCount getPeerCount() { + long disconnected = 0; + long connected = 0; + + for (Eth2Peer peer : getEth2Peers()) { + if (peer.isConnected()) { + connected++; + } else { + disconnected++; + } + } + + return new PeerCountBuilder() + .disconnected(UInt64.valueOf(disconnected)) + .connected(UInt64.valueOf(connected)) + .build(); + } + public List getPeerScores() { return network.streamPeers().toList(); } diff --git a/data/provider/src/main/java/tech/pegasys/teku/api/NodeDataProvider.java b/data/provider/src/main/java/tech/pegasys/teku/api/NodeDataProvider.java index cd33ea4cdd1..79ed78e51ca 100644 --- a/data/provider/src/main/java/tech/pegasys/teku/api/NodeDataProvider.java +++ b/data/provider/src/main/java/tech/pegasys/teku/api/NodeDataProvider.java @@ -26,7 +26,9 @@ import tech.pegasys.teku.api.migrated.ValidatorLivenessAtEpoch; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.attestation.ProcessedAttestationListener; +import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; import tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing; @@ -47,6 +49,7 @@ import tech.pegasys.teku.statetransition.synccommittee.SyncCommitteeContributionPool; import tech.pegasys.teku.statetransition.validation.InternalValidationResult; import tech.pegasys.teku.statetransition.validatorcache.ActiveValidatorChannel; +import tech.pegasys.teku.storage.client.RecentChainData; import tech.pegasys.teku.validator.api.SubmitDataError; public class NodeDataProvider { @@ -63,6 +66,8 @@ public class NodeDataProvider { private final boolean isLivenessTrackingEnabled; private final ProposersDataManager proposersDataManager; private final ForkChoiceNotifier forkChoiceNotifier; + private final RecentChainData recentChainData; + private final Spec spec; public NodeDataProvider( final AggregatingAttestationPool attestationPool, @@ -76,7 +81,9 @@ public NodeDataProvider( final boolean isLivenessTrackingEnabled, final ActiveValidatorChannel activeValidatorChannel, final ProposersDataManager proposersDataManager, - final ForkChoiceNotifier forkChoiceNotifier) { + final ForkChoiceNotifier forkChoiceNotifier, + final RecentChainData recentChainData, + final Spec spec) { this.attestationPool = attestationPool; this.attesterSlashingPool = attesterSlashingsPool; this.proposerSlashingPool = proposerSlashingPool; @@ -89,6 +96,8 @@ public NodeDataProvider( this.isLivenessTrackingEnabled = isLivenessTrackingEnabled; this.proposersDataManager = proposersDataManager; this.forkChoiceNotifier = forkChoiceNotifier; + this.recentChainData = recentChainData; + this.spec = spec; } public List getAttestations( @@ -96,10 +105,46 @@ public List getAttestations( return attestationPool.getAttestations(maybeSlot, maybeCommitteeIndex); } + public ObjectAndMetaData> getAttestationsAndMetaData( + final Optional maybeSlot, final Optional maybeCommitteeIndex) { + return lookupMetaData( + attestationPool.getAttestations(maybeSlot, maybeCommitteeIndex), maybeSlot); + } + + private ObjectAndMetaData> lookupMetaData( + final List attestations, final Optional maybeSlot) { + final UInt64 slot = getSlot(attestations, maybeSlot); + return new ObjectAndMetaData<>( + attestations, spec.atSlot(slot).getMilestone(), false, false, false); + } + + private UInt64 getSlot(final List attestations, final Optional maybeSlot) { + return maybeSlot.orElseGet( + () -> + attestations.stream() + .findFirst() + .map(attestation -> attestation.getData().getSlot()) + .orElseGet(() -> recentChainData.getCurrentSlot().orElse(UInt64.ZERO))); + } + public List getAttesterSlashings() { return new ArrayList<>(attesterSlashingPool.getAll()); } + public ObjectAndMetaData> getAttesterSlashingsAndMetaData() { + final List attesterSlashings = new ArrayList<>(attesterSlashingPool.getAll()); + final UInt64 slot = getSlot(attesterSlashings); + return new ObjectAndMetaData<>( + attesterSlashings, spec.atSlot(slot).getMilestone(), false, false, false); + } + + private UInt64 getSlot(final List attesterSlashings) { + return attesterSlashings.stream() + .findFirst() + .map(attesterSlashing -> attesterSlashing.getAttestation1().getData().getSlot()) + .orElseGet(() -> recentChainData.getCurrentSlot().orElse(UInt64.ZERO)); + } + public List getProposerSlashings() { return new ArrayList<>(proposerSlashingPool.getAll()); } diff --git a/data/provider/src/main/java/tech/pegasys/teku/api/RewardCalculator.java b/data/provider/src/main/java/tech/pegasys/teku/api/RewardCalculator.java index 86d02edfaab..e50964238f7 100644 --- a/data/provider/src/main/java/tech/pegasys/teku/api/RewardCalculator.java +++ b/data/provider/src/main/java/tech/pegasys/teku/api/RewardCalculator.java @@ -98,7 +98,9 @@ Map getCommitteeIndices( } public SyncCommitteeRewardData getSyncCommitteeRewardData( - Set validators, BlockAndMetaData blockAndMetadata, BeaconState state) { + final Set validators, + final BlockAndMetaData blockAndMetadata, + final BeaconState state) { final BeaconBlock block = blockAndMetadata.getData().getMessage(); if (!spec.atSlot(block.getSlot()).getMilestone().isGreaterThanOrEqualTo(SpecMilestone.ALTAIR)) { throw new BadRequestException( diff --git a/data/provider/src/main/java/tech/pegasys/teku/api/SchemaObjectProvider.java b/data/provider/src/main/java/tech/pegasys/teku/api/SchemaObjectProvider.java index 40190519cf7..c35e678d588 100644 --- a/data/provider/src/main/java/tech/pegasys/teku/api/SchemaObjectProvider.java +++ b/data/provider/src/main/java/tech/pegasys/teku/api/SchemaObjectProvider.java @@ -13,37 +13,27 @@ package tech.pegasys.teku.api; -import tech.pegasys.teku.api.schema.BLSSignature; import tech.pegasys.teku.api.schema.BeaconBlock; import tech.pegasys.teku.api.schema.BeaconBlockBody; -import tech.pegasys.teku.api.schema.BeaconState; -import tech.pegasys.teku.api.schema.SignedBeaconBlock; import tech.pegasys.teku.api.schema.altair.BeaconBlockAltair; import tech.pegasys.teku.api.schema.altair.BeaconBlockBodyAltair; -import tech.pegasys.teku.api.schema.altair.BeaconStateAltair; import tech.pegasys.teku.api.schema.bellatrix.BeaconBlockBellatrix; import tech.pegasys.teku.api.schema.bellatrix.BeaconBlockBodyBellatrix; -import tech.pegasys.teku.api.schema.bellatrix.BeaconStateBellatrix; import tech.pegasys.teku.api.schema.bellatrix.BlindedBeaconBlockBodyBellatrix; import tech.pegasys.teku.api.schema.bellatrix.BlindedBlockBellatrix; import tech.pegasys.teku.api.schema.capella.BeaconBlockBodyCapella; import tech.pegasys.teku.api.schema.capella.BeaconBlockCapella; -import tech.pegasys.teku.api.schema.capella.BeaconStateCapella; import tech.pegasys.teku.api.schema.capella.BlindedBeaconBlockBodyCapella; import tech.pegasys.teku.api.schema.capella.BlindedBlockCapella; import tech.pegasys.teku.api.schema.deneb.BeaconBlockBodyDeneb; import tech.pegasys.teku.api.schema.deneb.BeaconBlockDeneb; -import tech.pegasys.teku.api.schema.deneb.BeaconStateDeneb; import tech.pegasys.teku.api.schema.deneb.BlindedBeaconBlockBodyDeneb; import tech.pegasys.teku.api.schema.deneb.BlindedBlockDeneb; -import tech.pegasys.teku.api.schema.eip7594.BeaconBlockBodyEip7594; -import tech.pegasys.teku.api.schema.eip7594.BeaconBlockEip7594; -import tech.pegasys.teku.api.schema.eip7594.BeaconStateEip7594; -import tech.pegasys.teku.api.schema.eip7594.BlindedBeaconBlockBodyEip7594; -import tech.pegasys.teku.api.schema.eip7594.BlindedBlockEip7594; +import tech.pegasys.teku.api.schema.electra.BeaconBlockBodyElectra; +import tech.pegasys.teku.api.schema.electra.BeaconBlockElectra; +import tech.pegasys.teku.api.schema.electra.BlindedBeaconBlockBodyElectra; +import tech.pegasys.teku.api.schema.electra.BlindedBlockElectra; import tech.pegasys.teku.api.schema.phase0.BeaconBlockPhase0; -import tech.pegasys.teku.api.schema.phase0.BeaconStatePhase0; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; @@ -59,21 +49,6 @@ public SchemaObjectProvider(final Spec spec) { this.spec = spec; } - public SignedBeaconBlock getSignedBeaconBlock( - final tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock internalBlock) { - - return new SignedBeaconBlock( - getBeaconBlock(internalBlock.getMessage()), new BLSSignature(internalBlock.getSignature())); - } - - public SignedBeaconBlock getSignedBlindedBeaconBlock( - final tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock internalBlock) { - - return new SignedBeaconBlock( - getBlindedBlock(internalBlock.getMessage()), - new BLSSignature(internalBlock.getSignature())); - } - public BeaconBlock getBeaconBlock( final tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock block) { return getBeaconBlock(block, spec.atSlot(block.getSlot()).getMilestone()); @@ -88,42 +63,48 @@ public BeaconBlock getBlindedBlock( final tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock block, final SpecMilestone milestone) { return switch (milestone) { - case PHASE0 -> new BeaconBlockPhase0( - block.getSlot(), - block.getProposerIndex(), - block.getParentRoot(), - block.getStateRoot(), - new BeaconBlockBody(block.getBody())); - case ALTAIR -> new BeaconBlockAltair( - block.getSlot(), - block.getProposerIndex(), - block.getParentRoot(), - block.getStateRoot(), - getBeaconBlockBodyAltair(block.getBody())); - case BELLATRIX -> new BlindedBlockBellatrix( - block.getSlot(), - block.getProposerIndex(), - block.getParentRoot(), - block.getStateRoot(), - getBlindedBlockBodyBellatrix(block.getBody())); - case CAPELLA -> new BlindedBlockCapella( - block.getSlot(), - block.getProposerIndex(), - block.getParentRoot(), - block.getStateRoot(), - getBlindedBlockBodyCapella(block.getBody())); - case DENEB -> new BlindedBlockDeneb( - block.getSlot(), - block.getProposerIndex(), - block.getParentRoot(), - block.getStateRoot(), - getBlindedBlockBodyDeneb(block.getBody())); - case EIP7594 -> new BlindedBlockEip7594( - block.getSlot(), - block.getProposerIndex(), - block.getParentRoot(), - block.getStateRoot(), - getBlindedBlockBodyEip7594(block.getBody())); + case PHASE0 -> + new BeaconBlockPhase0( + block.getSlot(), + block.getProposerIndex(), + block.getParentRoot(), + block.getStateRoot(), + new BeaconBlockBody(block.getBody())); + case ALTAIR -> + new BeaconBlockAltair( + block.getSlot(), + block.getProposerIndex(), + block.getParentRoot(), + block.getStateRoot(), + getBeaconBlockBodyAltair(block.getBody())); + case BELLATRIX -> + new BlindedBlockBellatrix( + block.getSlot(), + block.getProposerIndex(), + block.getParentRoot(), + block.getStateRoot(), + getBlindedBlockBodyBellatrix(block.getBody())); + case CAPELLA -> + new BlindedBlockCapella( + block.getSlot(), + block.getProposerIndex(), + block.getParentRoot(), + block.getStateRoot(), + getBlindedBlockBodyCapella(block.getBody())); + case DENEB -> + new BlindedBlockDeneb( + block.getSlot(), + block.getProposerIndex(), + block.getParentRoot(), + block.getStateRoot(), + getBlindedBlockBodyDeneb(block.getBody())); + case ELECTRA, FULU -> + new BlindedBlockElectra( + block.getSlot(), + block.getProposerIndex(), + block.getParentRoot(), + block.getStateRoot(), + getBlindedBlockBodyElectra(block.getBody())); }; } @@ -131,42 +112,48 @@ public BeaconBlock getBeaconBlock( final tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock block, final SpecMilestone milestone) { return switch (milestone) { - case PHASE0 -> new BeaconBlockPhase0( - block.getSlot(), - block.getProposerIndex(), - block.getParentRoot(), - block.getStateRoot(), - new BeaconBlockBody(block.getBody())); - case ALTAIR -> new BeaconBlockAltair( - block.getSlot(), - block.getProposerIndex(), - block.getParentRoot(), - block.getStateRoot(), - getBeaconBlockBodyAltair(block.getBody())); - case BELLATRIX -> new BeaconBlockBellatrix( - block.getSlot(), - block.getProposerIndex(), - block.getParentRoot(), - block.getStateRoot(), - getBeaconBlockBodyBellatrix(block.getBody())); - case CAPELLA -> new BeaconBlockCapella( - block.getSlot(), - block.getProposerIndex(), - block.getParentRoot(), - block.getStateRoot(), - getBeaconBlockBodyCapella(block.getBody())); - case DENEB -> new BeaconBlockDeneb( - block.getSlot(), - block.getProposerIndex(), - block.getParentRoot(), - block.getStateRoot(), - getBeaconBlockBodyDeneb(block.getBody())); - case EIP7594 -> new BeaconBlockEip7594( - block.getSlot(), - block.getProposerIndex(), - block.getParentRoot(), - block.getStateRoot(), - getBeaconBlockBodyEip7594(block.getBody())); + case PHASE0 -> + new BeaconBlockPhase0( + block.getSlot(), + block.getProposerIndex(), + block.getParentRoot(), + block.getStateRoot(), + new BeaconBlockBody(block.getBody())); + case ALTAIR -> + new BeaconBlockAltair( + block.getSlot(), + block.getProposerIndex(), + block.getParentRoot(), + block.getStateRoot(), + getBeaconBlockBodyAltair(block.getBody())); + case BELLATRIX -> + new BeaconBlockBellatrix( + block.getSlot(), + block.getProposerIndex(), + block.getParentRoot(), + block.getStateRoot(), + getBeaconBlockBodyBellatrix(block.getBody())); + case CAPELLA -> + new BeaconBlockCapella( + block.getSlot(), + block.getProposerIndex(), + block.getParentRoot(), + block.getStateRoot(), + getBeaconBlockBodyCapella(block.getBody())); + case DENEB -> + new BeaconBlockDeneb( + block.getSlot(), + block.getProposerIndex(), + block.getParentRoot(), + block.getStateRoot(), + getBeaconBlockBodyDeneb(block.getBody())); + case ELECTRA, FULU -> + new BeaconBlockElectra( + block.getSlot(), + block.getProposerIndex(), + block.getParentRoot(), + block.getStateRoot(), + getBeaconBlockBodyElectra(block.getBody())); }; } @@ -198,11 +185,11 @@ private BeaconBlockBodyDeneb getBeaconBlockBodyDeneb( .required(body)); } - private BeaconBlockBodyEip7594 getBeaconBlockBodyEip7594( + private BeaconBlockBodyElectra getBeaconBlockBodyElectra( final tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody body) { - return new BeaconBlockBodyEip7594( - tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594 - .BeaconBlockBodyEip7594.required(body)); + return new BeaconBlockBodyElectra( + tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra + .BeaconBlockBodyElectra.required(body)); } private BlindedBeaconBlockBodyBellatrix getBlindedBlockBodyBellatrix( @@ -226,23 +213,10 @@ private BlindedBeaconBlockBodyDeneb getBlindedBlockBodyDeneb( .BlindedBeaconBlockBodyDeneb.required(body)); } - private BlindedBeaconBlockBodyEip7594 getBlindedBlockBodyEip7594( + private BlindedBeaconBlockBodyElectra getBlindedBlockBodyElectra( final tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody body) { - return new BlindedBeaconBlockBodyEip7594( - tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594 - .BlindedBeaconBlockBodyEip7594.required(body)); - } - - public BeaconState getBeaconState( - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState state) { - final UInt64 slot = state.getSlot(); - return switch (spec.atSlot(slot).getMilestone()) { - case PHASE0 -> new BeaconStatePhase0(state); - case ALTAIR -> new BeaconStateAltair(state); - case BELLATRIX -> new BeaconStateBellatrix(state); - case CAPELLA -> new BeaconStateCapella(state); - case DENEB -> new BeaconStateDeneb(state); - case EIP7594 -> new BeaconStateEip7594(state); - }; + return new BlindedBeaconBlockBodyElectra( + tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra + .BlindedBeaconBlockBodyElectra.required(body)); } } diff --git a/data/provider/src/main/java/tech/pegasys/teku/api/SpecConfigData.java b/data/provider/src/main/java/tech/pegasys/teku/api/SpecConfigData.java index 84b4eddfe1e..b324789e475 100644 --- a/data/provider/src/main/java/tech/pegasys/teku/api/SpecConfigData.java +++ b/data/provider/src/main/java/tech/pegasys/teku/api/SpecConfigData.java @@ -16,6 +16,8 @@ import java.util.HashMap; import java.util.Map; import java.util.Optional; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; import org.apache.tuweni.bytes.Bytes; import tech.pegasys.teku.infrastructure.bytes.Bytes4; import tech.pegasys.teku.spec.config.SpecConfig; @@ -24,9 +26,10 @@ import tech.pegasys.teku.spec.constants.ValidatorConstants; public class SpecConfigData { + private static final Logger LOG = LogManager.getLogger(); private final SpecConfig specConfig; - public SpecConfigData(SpecConfig specConfig) { + public SpecConfigData(final SpecConfig specConfig) { this.specConfig = specConfig; } @@ -34,7 +37,14 @@ public Map getConfigMap() { final Map configAttributes = new HashMap<>(); specConfig .getRawConfig() - .forEach((name, value) -> configAttributes.put(name, ConfigProvider.formatValue(value))); + .forEach( + (name, value) -> { + if (value != null) { + configAttributes.put(name, ConfigProvider.formatValue(value)); + } else { + LOG.warn("Config field {} was set to null in runtime configuration", name); + } + }); configAttributes.put("BLS_WITHDRAWAL_PREFIX", getBlsWithdrawalPrefix().toHexString()); configAttributes.put("TARGET_AGGREGATORS_PER_COMMITTEE", getTargetAggregatorsPerCommittee()); @@ -129,7 +139,7 @@ private Optional getSyncCommitteeSubnetCount() { return getLegacyAltairConstant(Integer.toString(NetworkConstants.SYNC_COMMITTEE_SUBNET_COUNT)); } - private Optional getLegacyAltairConstant(T value) { + private Optional getLegacyAltairConstant(final T value) { return specConfig.toVersionAltair().isPresent() ? Optional.of(value) : Optional.empty(); } } diff --git a/data/provider/src/main/java/tech/pegasys/teku/api/SyncDataProvider.java b/data/provider/src/main/java/tech/pegasys/teku/api/SyncDataProvider.java index ea3c462e7dd..81b20925b74 100644 --- a/data/provider/src/main/java/tech/pegasys/teku/api/SyncDataProvider.java +++ b/data/provider/src/main/java/tech/pegasys/teku/api/SyncDataProvider.java @@ -24,7 +24,8 @@ public class SyncDataProvider { private final SyncService syncService; private final IntSupplier rejectedExecutionSupplier; - public SyncDataProvider(SyncService syncService, final IntSupplier rejectedExecutionSupplier) { + public SyncDataProvider( + final SyncService syncService, final IntSupplier rejectedExecutionSupplier) { this.syncService = syncService; this.rejectedExecutionSupplier = rejectedExecutionSupplier; } @@ -37,11 +38,11 @@ public int getRejectedExecutionCount() { return rejectedExecutionSupplier.getAsInt(); } - public long subscribeToSyncStateChanges(SyncStateProvider.SyncStateSubscriber subscriber) { + public long subscribeToSyncStateChanges(final SyncStateProvider.SyncStateSubscriber subscriber) { return syncService.subscribeToSyncStateChanges(subscriber); } - public boolean unsubscribeFromSyncStateChanges(long subscriberId) { + public boolean unsubscribeFromSyncStateChanges(final long subscriberId) { return syncService.unsubscribeFromSyncStateChanges(subscriberId); } diff --git a/data/provider/src/main/java/tech/pegasys/teku/api/ValidatorDataProvider.java b/data/provider/src/main/java/tech/pegasys/teku/api/ValidatorDataProvider.java index fb2551d4511..909aad6dee7 100644 --- a/data/provider/src/main/java/tech/pegasys/teku/api/ValidatorDataProvider.java +++ b/data/provider/src/main/java/tech/pegasys/teku/api/ValidatorDataProvider.java @@ -13,11 +13,6 @@ package tech.pegasys.teku.api; -import static com.google.common.base.Preconditions.checkNotNull; - -import com.fasterxml.jackson.core.JsonProcessingException; -import com.fasterxml.jackson.databind.JsonNode; -import com.fasterxml.jackson.databind.ObjectMapper; import com.google.common.base.Throwables; import it.unimi.dsi.fastutil.ints.IntList; import java.util.Collection; @@ -27,36 +22,27 @@ import tech.pegasys.teku.api.exceptions.BadRequestException; import tech.pegasys.teku.api.schema.SignedBeaconBlock; import tech.pegasys.teku.api.schema.ValidatorBlockResult; -import tech.pegasys.teku.api.schema.altair.SignedBeaconBlockAltair; -import tech.pegasys.teku.api.schema.bellatrix.SignedBeaconBlockBellatrix; -import tech.pegasys.teku.api.schema.bellatrix.SignedBlindedBeaconBlockBellatrix; -import tech.pegasys.teku.api.schema.capella.SignedBeaconBlockCapella; -import tech.pegasys.teku.api.schema.capella.SignedBlindedBeaconBlockCapella; -import tech.pegasys.teku.api.schema.deneb.SignedBeaconBlockDeneb; -import tech.pegasys.teku.api.schema.deneb.SignedBlindedBeaconBlockDeneb; -import tech.pegasys.teku.api.schema.eip7594.SignedBeaconBlockEip7594; -import tech.pegasys.teku.api.schema.eip7594.SignedBlindedBeaconBlockEip7594; -import tech.pegasys.teku.api.schema.phase0.SignedBeaconBlockPhase0; import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.ethereum.json.types.validator.AttesterDuties; import tech.pegasys.teku.ethereum.json.types.validator.ProposerDuties; import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeDuties; +import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.provider.JsonProvider; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockContainer; import tech.pegasys.teku.spec.datastructures.builder.SignedValidatorRegistration; import tech.pegasys.teku.spec.datastructures.metadata.BlockContainerAndMetaData; +import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SignedContributionAndProof; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeContribution; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeMessage; -import tech.pegasys.teku.spec.datastructures.operations.versions.bellatrix.BeaconPreparableProposer; +import tech.pegasys.teku.spec.datastructures.validator.BeaconPreparableProposer; import tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel; import tech.pegasys.teku.spec.logic.common.statetransition.results.BlockImportResult.FailureReason; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsAltair; @@ -65,7 +51,6 @@ import tech.pegasys.teku.validator.api.CommitteeSubscriptionRequest; import tech.pegasys.teku.validator.api.SendSignedBlockResult; import tech.pegasys.teku.validator.api.SubmitDataError; -import tech.pegasys.teku.validator.api.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.validator.api.ValidatorApiChannel; public class ValidatorDataProvider { @@ -96,19 +81,6 @@ public boolean isStoreAvailable() { return combinedChainDataClient.isStoreAvailable(); } - @Deprecated // This method is used within the blockV1 and blockV2 flow. It will be deprecated in - // the future. - public SafeFuture> getUnsignedBeaconBlockAtSlot( - final UInt64 slot, - final BLSSignature randao, - final Optional graffiti, - final boolean isBlinded, - final Optional requestedBuilderBoostFactor) { - checkBlockProducingParameters(slot, randao); - return validatorApiChannel.createUnsignedBlock( - slot, randao, graffiti, Optional.of(isBlinded), requestedBuilderBoostFactor); - } - public SafeFuture> produceBlock( final UInt64 slot, final BLSSignature randao, @@ -116,7 +88,7 @@ public SafeFuture> produceBlock( final Optional requestedBuilderBoostFactor) { checkBlockProducingParameters(slot, randao); return validatorApiChannel.createUnsignedBlock( - slot, randao, graffiti, Optional.empty(), requestedBuilderBoostFactor); + slot, randao, graffiti, requestedBuilderBoostFactor); } private void checkBlockProducingParameters(final UInt64 slot, final BLSSignature randao) { @@ -142,7 +114,7 @@ public SpecMilestone getMilestoneAtSlot(final UInt64 slot) { } public SafeFuture> createAttestationDataAtSlot( - UInt64 slot, int committeeIndex) { + final UInt64 slot, final int committeeIndex) { if (!isStoreAvailable()) { return SafeFuture.failedFuture(new ChainDataUnavailableException()); } @@ -159,42 +131,11 @@ public SafeFuture> createAttestationDataAtSlot( }); } - public SafeFuture> submitAttestations(List attestations) { + public SafeFuture> submitAttestations( + final List attestations) { return validatorApiChannel.sendSignedAttestations(attestations); } - public SignedBeaconBlock parseBlock(final JsonProvider jsonProvider, final String jsonBlock) - throws JsonProcessingException { - final ObjectMapper mapper = jsonProvider.getObjectMapper(); - final JsonNode jsonNode = mapper.readTree(jsonBlock); - final UInt64 slot = mapper.treeToValue(jsonNode.findValue("slot"), UInt64.class); - checkNotNull(slot, "Slot was not found in json block"); - return switch (spec.atSlot(slot).getMilestone()) { - case PHASE0 -> mapper.treeToValue(jsonNode, SignedBeaconBlockPhase0.class); - case ALTAIR -> mapper.treeToValue(jsonNode, SignedBeaconBlockAltair.class); - case BELLATRIX -> mapper.treeToValue(jsonNode, SignedBeaconBlockBellatrix.class); - case CAPELLA -> mapper.treeToValue(jsonNode, SignedBeaconBlockCapella.class); - case DENEB -> mapper.treeToValue(jsonNode, SignedBeaconBlockDeneb.class); - case EIP7594 -> mapper.treeToValue(jsonNode, SignedBeaconBlockEip7594.class); - }; - } - - public SignedBeaconBlock parseBlindedBlock( - final JsonProvider jsonProvider, final String jsonBlock) throws JsonProcessingException { - final ObjectMapper mapper = jsonProvider.getObjectMapper(); - final JsonNode jsonNode = mapper.readTree(jsonBlock); - final UInt64 slot = mapper.treeToValue(jsonNode.findValue("slot"), UInt64.class); - checkNotNull(slot, "Slot was not found in json block"); - return switch (spec.atSlot(slot).getMilestone()) { - case PHASE0 -> mapper.treeToValue(jsonNode, SignedBeaconBlockPhase0.class); - case ALTAIR -> mapper.treeToValue(jsonNode, SignedBeaconBlockAltair.class); - case BELLATRIX -> mapper.treeToValue(jsonNode, SignedBlindedBeaconBlockBellatrix.class); - case CAPELLA -> mapper.treeToValue(jsonNode, SignedBlindedBeaconBlockCapella.class); - case DENEB -> mapper.treeToValue(jsonNode, SignedBlindedBeaconBlockDeneb.class); - case EIP7594 -> mapper.treeToValue(jsonNode, SignedBlindedBeaconBlockEip7594.class); - }; - } - public SafeFuture submitSignedBlock( final SignedBeaconBlock signedBeaconBlock, final BroadcastValidationLevel broadcastValidationLevel) { @@ -239,8 +180,16 @@ private Optional checkInternalCommitteeSignature( } public SafeFuture> createAggregate( - final UInt64 slot, final Bytes32 attestationHashTreeRoot) { - return validatorApiChannel.createAggregate(slot, attestationHashTreeRoot); + final UInt64 slot, + final Bytes32 attestationHashTreeRoot, + final Optional committeeIndex) { + return validatorApiChannel.createAggregate(slot, attestationHashTreeRoot, committeeIndex); + } + + public SafeFuture>> createAggregateAndMetaData( + final UInt64 slot, final Bytes32 attestationHashTreeRoot, final UInt64 committeeIndex) { + return createAggregate(slot, attestationHashTreeRoot, Optional.of(committeeIndex)) + .thenApply(maybeAttestation -> maybeAttestation.map(this::lookUpMetadata)); } public SafeFuture> sendAggregateAndProofs( @@ -326,7 +275,7 @@ public boolean isPhase0Slot(final UInt64 slot) { } private static ValidatorBlockResult generateSubmitSignedBlockResponse( - SendSignedBlockResult result) { + final SendSignedBlockResult result) { int responseCode; Optional hashRoot = result.getBlockRoot(); if (result.getRejectionReason().isEmpty()) { @@ -339,4 +288,13 @@ private static ValidatorBlockResult generateSubmitSignedBlockResponse( return new ValidatorBlockResult(responseCode, result.getRejectionReason(), hashRoot); } + + private ObjectAndMetaData lookUpMetadata(final Attestation attestation) { + return new ObjectAndMetaData<>( + attestation, + spec.atSlot(attestation.getData().getSlot()).getMilestone(), + false, + false, + false); + } } diff --git a/data/provider/src/main/java/tech/pegasys/teku/api/blobselector/BlobSidecarSelector.java b/data/provider/src/main/java/tech/pegasys/teku/api/blobselector/BlobSidecarSelector.java index 1bb32c560af..fdb553b099e 100644 --- a/data/provider/src/main/java/tech/pegasys/teku/api/blobselector/BlobSidecarSelector.java +++ b/data/provider/src/main/java/tech/pegasys/teku/api/blobselector/BlobSidecarSelector.java @@ -17,8 +17,8 @@ import java.util.Optional; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; +import tech.pegasys.teku.spec.datastructures.metadata.BlobSidecarsAndMetaData; public interface BlobSidecarSelector { - SafeFuture>> getBlobSidecars(List indices); + SafeFuture> getBlobSidecars(List indices); } diff --git a/data/provider/src/main/java/tech/pegasys/teku/api/blobselector/BlobSidecarSelectorFactory.java b/data/provider/src/main/java/tech/pegasys/teku/api/blobselector/BlobSidecarSelectorFactory.java index 6dd1100077e..4f36633b9d6 100644 --- a/data/provider/src/main/java/tech/pegasys/teku/api/blobselector/BlobSidecarSelectorFactory.java +++ b/data/provider/src/main/java/tech/pegasys/teku/api/blobselector/BlobSidecarSelectorFactory.java @@ -23,12 +23,14 @@ import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.SpecFeature; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.blocks.SlotAndBlockRoot; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.deneb.BeaconBlockBodyDeneb; +import tech.pegasys.teku.spec.datastructures.metadata.BlobSidecarsAndMetaData; import tech.pegasys.teku.storage.client.BlobSidecarReconstructionProvider; +import tech.pegasys.teku.storage.client.ChainHead; import tech.pegasys.teku.storage.client.CombinedChainDataClient; public class BlobSidecarSelectorFactory extends AbstractSelectorFactory { @@ -54,11 +56,23 @@ public BlobSidecarSelector blockRootSelector(final Bytes32 blockRoot) { if (maybeSlot.isPresent()) { final SlotAndBlockRoot slotAndBlockRoot = new SlotAndBlockRoot(maybeSlot.get(), blockRoot); - return getBlobSidecars(slotAndBlockRoot, indices); + return getBlobSidecars(slotAndBlockRoot, indices) + .thenApply(blobSidecars -> addMetaData(blobSidecars, slotAndBlockRoot)); } return client .getBlockByBlockRoot(blockRoot) - .thenCompose(maybeBlock -> getBlobSidecarsForBlock(maybeBlock, indices)); + .thenCompose( + maybeBlock -> { + if (maybeBlock.isEmpty()) { + return SafeFuture.completedFuture(Optional.empty()); + } + final SignedBeaconBlock block = maybeBlock.get(); + final SlotAndBlockRoot slotAndBlockRoot = + new SlotAndBlockRoot(block.getSlot(), blockRoot); + return getBlobSidecarsForBlock(maybeBlock, indices) + .thenApply( + blobSidecars -> addMetaData(blobSidecars, slotAndBlockRoot)); + }); }); } @@ -67,7 +81,13 @@ public BlobSidecarSelector headSelector() { return indices -> client .getChainHead() - .map(head -> getBlobSidecars(head.getSlotAndBlockRoot(), indices)) + .map( + head -> + getBlobSidecars(head.getSlotAndBlockRoot(), indices) + .thenApply( + blobSideCars -> + addMetaData( + blobSideCars, head.getSlotAndBlockRoot(), head.isOptimistic()))) .orElse(SafeFuture.completedFuture(Optional.empty())); } @@ -76,7 +96,17 @@ public BlobSidecarSelector genesisSelector() { return indices -> client .getBlockAtSlotExact(GENESIS_SLOT) - .thenCompose(maybeGenesisBlock -> getBlobSidecarsForBlock(maybeGenesisBlock, indices)); + .thenCompose( + maybeGenesisBlock -> + getBlobSidecarsForBlock(maybeGenesisBlock, indices) + .thenApply( + blobSidecars -> + addMetaData( + blobSidecars, + GENESIS_SLOT, + false, + true, + client.isFinalized(GENESIS_SLOT)))); } @Override @@ -84,7 +114,15 @@ public BlobSidecarSelector finalizedSelector() { return indices -> client .getLatestFinalized() - .map(anchorPoint -> getBlobSidecars(anchorPoint.getSlotAndBlockRoot(), indices)) + .map( + anchorPoint -> + getBlobSidecars(anchorPoint.getSlotAndBlockRoot(), indices) + .thenApply( + blobSideCars -> + addMetaData( + blobSideCars, + anchorPoint.getSlotAndBlockRoot(), + client.isChainHeadOptimistic()))) .orElse(SafeFuture.completedFuture(Optional.empty())); } @@ -92,11 +130,24 @@ public BlobSidecarSelector finalizedSelector() { public BlobSidecarSelector slotSelector(final UInt64 slot) { return indices -> { if (client.isFinalized(slot)) { - return getBlobSidecars(slot, indices); + return getBlobSidecars(slot, indices) + .thenApply( + blobSidecars -> + addMetaData(blobSidecars, slot, client.isChainHeadOptimistic(), true, true)); } return client .getBlockAtSlotExact(slot) - .thenCompose(maybeBlock -> getBlobSidecarsForBlock(maybeBlock, indices)); + .thenCompose( + maybeBlock -> + getBlobSidecarsForBlock(maybeBlock, indices) + .thenApply( + blobSidecars -> + addMetaData( + blobSidecars, + slot, + client.isChainHeadOptimistic(), + false, + client.isFinalized(slot)))); }; } @@ -106,7 +157,12 @@ public BlobSidecarSelector slotSelectorForAll(final UInt64 slot) { .getAllBlobSidecars(slot, indices) .thenApply( blobSidecars -> - blobSidecars.isEmpty() ? Optional.empty() : Optional.of(blobSidecars)); + blobSidecars.isEmpty() + ? Optional.empty() + : addMetaData( + // We don't care about metadata since the api (teku only) that + // consumes the return value doesn't use it + Optional.of(blobSidecars), new SlotAndBlockRoot(slot, Bytes32.ZERO))); } private SafeFuture>> getBlobSidecarsForBlock( @@ -128,9 +184,8 @@ private SafeFuture>> getBlobSidecarsForBlock( private SafeFuture>> getBlobSidecars( final SlotAndBlockRoot slotAndBlockRoot, final List indices) { - if (spec.atSlot(slotAndBlockRoot.getSlot()) - .getMilestone() - .isGreaterThanOrEqualTo(SpecMilestone.EIP7594)) { + if (spec.isFeatureActivatedAtEpoch( + SpecFeature.EIP7594, spec.computeEpochAtSlot(slotAndBlockRoot.getSlot()))) { return blobSidecarReconstructionProvider .reconstructBlobSidecars(slotAndBlockRoot, indices) .thenApply(Optional::of); @@ -140,11 +195,67 @@ private SafeFuture>> getBlobSidecars( private SafeFuture>> getBlobSidecars( final UInt64 slot, final List indices) { - if (spec.atSlot(slot).getMilestone().isGreaterThanOrEqualTo(SpecMilestone.EIP7594)) { + if (spec.isFeatureActivatedAtEpoch(SpecFeature.EIP7594, spec.computeEpochAtSlot(slot))) { return blobSidecarReconstructionProvider .reconstructBlobSidecars(slot, indices) .thenApply(Optional::of); } return client.getBlobSidecars(slot, indices).thenApply(Optional::of); } + + private Optional addMetaData( + final Optional> maybeBlobSidecarList, + final SlotAndBlockRoot slotAndBlockRoot) { + if (maybeBlobSidecarList.isEmpty()) { + return Optional.empty(); + } + + final UInt64 slot = slotAndBlockRoot.getSlot(); + final Bytes32 blockRoot = slotAndBlockRoot.getBlockRoot(); + final Optional maybeChainHead = client.getChainHead(); + final boolean isFinalized = client.isFinalized(slot); + boolean isOptimistic; + boolean isCanonical = false; + + if (maybeChainHead.isPresent()) { + ChainHead chainHead = maybeChainHead.get(); + isOptimistic = chainHead.isOptimistic() || client.isOptimisticBlock(blockRoot); + isCanonical = client.isCanonicalBlock(slot, blockRoot, chainHead.getRoot()); + } else { + // If there's no chain head, we assume the block is not optimistic and not canonical + isOptimistic = client.isOptimisticBlock(blockRoot); + } + return addMetaData(maybeBlobSidecarList, slot, isOptimistic, isCanonical, isFinalized); + } + + private Optional addMetaData( + final Optional> maybeBlobSidecarList, + final SlotAndBlockRoot slotAndBlockRoot, + final boolean isOptimistic) { + if (maybeBlobSidecarList.isEmpty()) { + return Optional.empty(); + } + return addMetaData( + maybeBlobSidecarList, + slotAndBlockRoot.getSlot(), + isOptimistic, + true, + client.isFinalized(slotAndBlockRoot.getSlot())); + } + + private Optional addMetaData( + final Optional> maybeBlobSidecarList, + final UInt64 blockSlot, + final boolean executionOptimistic, + final boolean canonical, + final boolean finalized) { + return maybeBlobSidecarList.map( + blobSidecarList -> + new BlobSidecarsAndMetaData( + blobSidecarList, + spec.atSlot(blockSlot).getMilestone(), + executionOptimistic, + canonical, + finalized)); + } } diff --git a/data/provider/src/test/java/tech/pegasys/teku/api/ChainDataProviderTest.java b/data/provider/src/test/java/tech/pegasys/teku/api/ChainDataProviderTest.java index 8a27723a43d..34a5f987bb3 100644 --- a/data/provider/src/test/java/tech/pegasys/teku/api/ChainDataProviderTest.java +++ b/data/provider/src/test/java/tech/pegasys/teku/api/ChainDataProviderTest.java @@ -56,7 +56,6 @@ import tech.pegasys.teku.api.migrated.SyncCommitteeRewardData; import tech.pegasys.teku.api.response.v1.beacon.GenesisData; import tech.pegasys.teku.api.response.v1.beacon.ValidatorStatus; -import tech.pegasys.teku.api.schema.BeaconState; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.async.SafeFutureAssert; import tech.pegasys.teku.infrastructure.bytes.Bytes20; @@ -77,6 +76,7 @@ import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.state.Validator; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.altair.BeaconStateAltair; import tech.pegasys.teku.spec.generator.AttestationGenerator; import tech.pegasys.teku.spec.generator.ChainBuilder; @@ -178,36 +178,6 @@ public void getGenesisData_shouldReturnValueIfStoreAvailable() { .isEqualTo(new GenesisData(genesisTime, genesisValidatorsRoot, genesisForkVersion)); } - @Test - public void getBeaconState_shouldReturnEmptyWhenRootNotFound() { - final ChainDataProvider provider = - new ChainDataProvider( - spec, - recentChainData, - combinedChainDataClient, - rewardCalculatorMock, - mockBlobSidecarReconstructionProvider); - SafeFuture>> future = - provider.getSchemaBeaconState(data.randomBytes32().toHexString()); - assertThatSafeFuture(future).isCompletedWithEmptyOptional(); - } - - @Test - public void getBeaconState_shouldFindHeadState() { - final ChainDataProvider provider = - new ChainDataProvider( - spec, - recentChainData, - combinedChainDataClient, - rewardCalculatorMock, - mockBlobSidecarReconstructionProvider); - SafeFuture>> future = - provider.getSchemaBeaconState("head"); - final Optional> maybeState = safeJoin(future); - assertThat(maybeState.orElseThrow().getData().asInternalBeaconState(spec).hashTreeRoot()) - .isEqualTo(beaconStateInternal.hashTreeRoot()); - } - @Test public void getBlockAndMetaDataByBlockId_shouldGetHeadBlock() throws ExecutionException, InterruptedException { @@ -279,8 +249,7 @@ public void shouldGetBlockHeadersOnEmptyChainHeadSlot() { @Test public void filteredValidatorsList_shouldFilterByValidatorIndex() { - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState internalState = - data.randomBeaconState(1024); + final BeaconState internalState = data.randomBeaconState(1024); final ChainDataProvider provider = new ChainDataProvider( spec, @@ -297,8 +266,7 @@ public void filteredValidatorsList_shouldFilterByValidatorIndex() { @Test public void filteredValidatorsList_shouldFilterByValidatorPubkey() { - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState internalState = - data.randomBeaconState(1024); + final BeaconState internalState = data.randomBeaconState(1024); final ChainDataProvider provider = new ChainDataProvider( spec, @@ -320,8 +288,7 @@ public void filteredValidatorsList_shouldFilterByValidatorPubkey() { @Test public void filteredValidatorsList_shouldFilterByValidatorStatus() { - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState internalState = - data.randomBeaconState(11); + final BeaconState internalState = data.randomBeaconState(11); final ChainDataProvider provider = new ChainDataProvider( spec, @@ -363,8 +330,7 @@ public void getStateCommittees_shouldReturnEmptyIfStateNotFound() @Test public void getCommitteesFromState_shouldNotRequireFilters() { - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState internalState = - data.randomBeaconState(64); + final BeaconState internalState = data.randomBeaconState(64); final ChainDataProvider provider = new ChainDataProvider( spec, @@ -383,8 +349,7 @@ public void getCommitteesFromState_shouldNotRequireFilters() { @Test public void getCommitteesFromState_shouldFilterOnSlot() { - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState internalState = - data.randomBeaconState(64); + final BeaconState internalState = data.randomBeaconState(64); final ChainDataProvider provider = new ChainDataProvider( spec, @@ -597,8 +562,7 @@ private void mockBlockSelectorFactory() { @Test public void getLightClientBootstrap_shouldGetBootstrap() { final ChainDataProvider provider = setupBySpec(spec, data, 16); - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState internalState = - getHeadState(); + final BeaconState internalState = getHeadState(); BeaconBlockHeader expectedBlockHeader = BeaconBlockHeader.fromState(internalState); @@ -618,8 +582,7 @@ public void getLightClientBootstrap_shouldGetBootstrap() { @Test public void getLightClientBootstrap_shouldReturnEmptyWhenBlockNotFound() { final ChainDataProvider provider = setupBySpec(spec, data, 16); - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState internalState = - getHeadState(); + final BeaconState internalState = getHeadState(); BeaconBlockHeader expectedBlockHeader = BeaconBlockHeader.fromState(internalState); @@ -640,8 +603,7 @@ public void getLightClientBootstrap_shouldReturnEmptyBeforeAltair() { combinedChainDataClient, rewardCalculatorMock, mockBlobSidecarReconstructionProvider); - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState internalState = - data.randomBeaconState(); + final BeaconState internalState = data.randomBeaconState(); BeaconBlockHeader expectedBlockHeader = BeaconBlockHeader.fromState(internalState); @@ -662,8 +624,7 @@ public void getValidatorBalancesFromState_shouldGetBalances() { combinedChainDataClient, rewardCalculatorMock, mockBlobSidecarReconstructionProvider); - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState internalState = - data.randomBeaconState(1024); + final BeaconState internalState = data.randomBeaconState(1024); assertThat(provider.getValidatorBalancesFromState(internalState, emptyList())).hasSize(1024); assertThat( @@ -894,8 +855,7 @@ void getExpectedWithdrawalsGeneratesList() { @MethodSource("getRandaoIndexCases") void getRandaoIndex( final int stateSlot, final int queryEpoch, final Optional maybeRandao) { - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState state = - data.randomBeaconState(UInt64.valueOf(stateSlot)); + final BeaconState state = data.randomBeaconState(UInt64.valueOf(stateSlot)); final UInt64 epoch = UInt64.valueOf(queryEpoch); final ChainDataProvider provider = new ChainDataProvider( @@ -932,7 +892,7 @@ public static Stream getRandaoIndexCases() { return args.stream(); } - private tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState getHeadState() { + private BeaconState getHeadState() { return safeJoin(mockCombinedChainDataClient.getChainHead().orElseThrow().getState()); } } diff --git a/data/provider/src/test/java/tech/pegasys/teku/api/ChainDataProviderTestPhase0.java b/data/provider/src/test/java/tech/pegasys/teku/api/ChainDataProviderTestPhase0.java index f8ec44463e0..19440f9eb31 100644 --- a/data/provider/src/test/java/tech/pegasys/teku/api/ChainDataProviderTestPhase0.java +++ b/data/provider/src/test/java/tech/pegasys/teku/api/ChainDataProviderTestPhase0.java @@ -49,8 +49,6 @@ import tech.pegasys.teku.api.migrated.SyncCommitteeRewardData; import tech.pegasys.teku.api.response.v1.beacon.GenesisData; import tech.pegasys.teku.api.response.v1.beacon.ValidatorStatus; -import tech.pegasys.teku.api.schema.BeaconState; -import tech.pegasys.teku.api.schema.Fork; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.bytes.Bytes4; import tech.pegasys.teku.infrastructure.unsigned.UInt64; @@ -65,6 +63,7 @@ import tech.pegasys.teku.spec.datastructures.metadata.BlockAndMetaData; import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.generator.AttestationGenerator; import tech.pegasys.teku.spec.generator.ChainBuilder; import tech.pegasys.teku.spec.logic.common.util.BlockRewardCalculatorUtil; @@ -162,36 +161,6 @@ public void getGenesisData_shouldReturnValueIfStoreAvailable() { .isEqualTo(new GenesisData(genesisTime, genesisValidatorsRoot, genesisForkVersion)); } - @Test - public void getBeaconState_shouldReturnEmptyWhenRootNotFound() { - final ChainDataProvider provider = - new ChainDataProvider( - spec, - recentChainData, - combinedChainDataClient, - rewardCalculatorMock, - mockBlobSidecarReconstructionProvider); - SafeFuture>> future = - provider.getSchemaBeaconState(data.randomBytes32().toHexString()); - assertThatSafeFuture(future).isCompletedWithEmptyOptional(); - } - - @Test - public void getBeaconState_shouldFindHeadState() { - final ChainDataProvider provider = - new ChainDataProvider( - spec, - recentChainData, - combinedChainDataClient, - rewardCalculatorMock, - mockBlobSidecarReconstructionProvider); - SafeFuture>> future = - provider.getSchemaBeaconState("head"); - final Optional> maybeState = safeJoin(future); - assertThat(maybeState.orElseThrow().getData().asInternalBeaconState(spec).hashTreeRoot()) - .isEqualTo(beaconStateInternal.hashTreeRoot()); - } - @Test public void getBlockAndMetaDataByBlockId_shouldGetHeadBlock() throws ExecutionException, InterruptedException { @@ -263,8 +232,7 @@ public void shouldGetBlockHeadersOnEmptyChainHeadSlot() { @Test public void filteredValidatorsList_shouldFilterByValidatorIndex() { - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState internalState = - data.randomBeaconState(1024); + final BeaconState internalState = data.randomBeaconState(1024); final ChainDataProvider provider = new ChainDataProvider( spec, @@ -281,8 +249,7 @@ public void filteredValidatorsList_shouldFilterByValidatorIndex() { @Test public void filteredValidatorsList_shouldFilterByValidatorPubkey() { - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState internalState = - data.randomBeaconState(1024); + final BeaconState internalState = data.randomBeaconState(1024); final ChainDataProvider provider = new ChainDataProvider( spec, @@ -304,8 +271,7 @@ public void filteredValidatorsList_shouldFilterByValidatorPubkey() { @Test public void filteredValidatorsList_shouldFilterByValidatorStatus() { - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState internalState = - data.randomBeaconState(11); + final BeaconState internalState = data.randomBeaconState(11); final ChainDataProvider provider = new ChainDataProvider( spec, @@ -347,8 +313,7 @@ public void getStateCommittees_shouldReturnEmptyIfStateNotFound() @Test public void getCommitteesFromState_shouldNotRequireFilters() { - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState internalState = - data.randomBeaconState(64); + final BeaconState internalState = data.randomBeaconState(64); final ChainDataProvider provider = new ChainDataProvider( spec, @@ -367,8 +332,7 @@ public void getCommitteesFromState_shouldNotRequireFilters() { @Test public void getCommitteesFromState_shouldFilterOnSlot() { - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState internalState = - data.randomBeaconState(64); + final BeaconState internalState = data.randomBeaconState(64); final ChainDataProvider provider = new ChainDataProvider( spec, @@ -397,8 +361,7 @@ public void getStateSyncCommittees_shouldReturnEmptyListBeforeAltair() { combinedChainDataClient, rewardCalculatorMock, mockBlobSidecarReconstructionProvider); - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState internalState = - data.randomBeaconState(); + final BeaconState internalState = data.randomBeaconState(); when(mockCombinedChainDataClient.getBestState()) .thenReturn(Optional.of(completedFuture(internalState))); @@ -437,8 +400,7 @@ public void getLightClientBootstrap_shouldReturnEmptyBeforeAltair() { combinedChainDataClient, rewardCalculatorMock, mockBlobSidecarReconstructionProvider); - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState internalState = - data.randomBeaconState(); + final BeaconState internalState = data.randomBeaconState(); BeaconBlockHeader expectedBlockHeader = BeaconBlockHeader.fromState(internalState); @@ -450,22 +412,6 @@ public void getLightClientBootstrap_shouldReturnEmptyBeforeAltair() { assertThatSafeFuture(future).isCompletedWithEmptyOptional(); } - @Test - public void getStateFork_shouldGetForkAtGenesis() { - final ChainDataProvider provider = - new ChainDataProvider( - spec, - recentChainData, - combinedChainDataClient, - rewardCalculatorMock, - mockBlobSidecarReconstructionProvider); - - final Bytes4 bytes4 = Bytes4.fromHexString("0x00000001"); - final SafeFuture>> result = provider.getStateFork("genesis"); - assertThatSafeFuture(result) - .isCompletedWithOptionalContaining(addMetaData(new Fork(bytes4, bytes4, ZERO), ZERO)); - } - @Test public void getValidatorBalancesFromState_shouldGetBalances() { final ChainDataProvider provider = @@ -475,8 +421,7 @@ public void getValidatorBalancesFromState_shouldGetBalances() { combinedChainDataClient, rewardCalculatorMock, mockBlobSidecarReconstructionProvider); - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState internalState = - data.randomBeaconState(1024); + final BeaconState internalState = data.randomBeaconState(1024); assertThat(provider.getValidatorBalancesFromState(internalState, emptyList())).hasSize(1024); assertThat( @@ -645,8 +590,7 @@ void getExpectedWithdrawalsFailsPreCapella() { @MethodSource("getRandaoIndexCases") void getRandaoIndex( final int stateSlot, final int queryEpoch, final Optional maybeRandao) { - final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState state = - data.randomBeaconState(UInt64.valueOf(stateSlot)); + final BeaconState state = data.randomBeaconState(UInt64.valueOf(stateSlot)); final UInt64 epoch = UInt64.valueOf(queryEpoch); final ChainDataProvider provider = new ChainDataProvider( diff --git a/data/provider/src/test/java/tech/pegasys/teku/api/ConfigProviderTest.java b/data/provider/src/test/java/tech/pegasys/teku/api/ConfigProviderTest.java deleted file mode 100644 index 48b22954b99..00000000000 --- a/data/provider/src/test/java/tech/pegasys/teku/api/ConfigProviderTest.java +++ /dev/null @@ -1,37 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.api; - -import static org.assertj.core.api.Assertions.assertThat; - -import java.util.Map; -import org.junit.jupiter.api.Test; -import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.SpecFactory; -import tech.pegasys.teku.spec.config.SpecConfig; -import tech.pegasys.teku.spec.config.SpecConfigLoader; - -class ConfigProviderTest { - private final Spec spec = SpecFactory.create("prater"); - - private final ConfigProvider configProvider = new ConfigProvider(spec); - - @Test - void shouldParseResultOfConfig() { - final Map configMap = configProvider.getConfig(); - final SpecConfig specConfig = SpecConfigLoader.loadRemoteConfig(configMap); - final SpecConfig expectedConfig = spec.getGenesisSpecConfig(); - assertThat(specConfig).isEqualToComparingFieldByField(expectedConfig); - } -} diff --git a/data/provider/src/test/java/tech/pegasys/teku/api/NetworkDataProviderTest.java b/data/provider/src/test/java/tech/pegasys/teku/api/NetworkDataProviderTest.java index 29564af0243..329ae81d4e5 100644 --- a/data/provider/src/test/java/tech/pegasys/teku/api/NetworkDataProviderTest.java +++ b/data/provider/src/test/java/tech/pegasys/teku/api/NetworkDataProviderTest.java @@ -36,7 +36,7 @@ void getPeerCount_shouldReturnTotalPeers() { final Eth2Peer peer2 = mock(Eth2Peer.class); when(p2pNetwork.streamPeers()).thenReturn(Stream.of(peer1, peer2)); - assertThat(network.getPeerCount()).isEqualTo(2); + assertThat(network.countPeers()).isEqualTo(2); verify(p2pNetwork).streamPeers(); } @@ -45,17 +45,17 @@ void getPeerCount_shouldReturnTotalPeersIfEmpty() { final NetworkDataProvider network = new NetworkDataProvider(p2pNetwork); when(p2pNetwork.streamPeers()).thenReturn(Stream.of()); - assertThat(network.getPeerCount()).isEqualTo(0); + assertThat(network.countPeers()).isEqualTo(0); verify(p2pNetwork).streamPeers(); } @Test void getListeningAddresses_shouldReturnAddressFromNetwork() { final NetworkDataProvider network = new NetworkDataProvider(p2pNetwork); - final String nodeAddress = "/some/libp2p/addr"; + final List nodeAddresses = List.of("/some/libp2p/addr"); - when(p2pNetwork.getNodeAddress()).thenReturn(nodeAddress); + when(p2pNetwork.getNodeAddresses()).thenReturn(nodeAddresses); - assertThat(network.getListeningAddresses()).isEqualTo(List.of(nodeAddress)); + assertThat(network.getListeningAddresses()).isEqualTo(nodeAddresses); } } diff --git a/data/provider/src/test/java/tech/pegasys/teku/api/NodeDataProviderTest.java b/data/provider/src/test/java/tech/pegasys/teku/api/NodeDataProviderTest.java index 052a0c70726..29bd11b9180 100644 --- a/data/provider/src/test/java/tech/pegasys/teku/api/NodeDataProviderTest.java +++ b/data/provider/src/test/java/tech/pegasys/teku/api/NodeDataProviderTest.java @@ -15,16 +15,23 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import java.util.Collections; import java.util.List; +import java.util.Optional; +import java.util.Set; import java.util.concurrent.ExecutionException; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.SpecVersion; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; import tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing; @@ -40,6 +47,7 @@ import tech.pegasys.teku.statetransition.synccommittee.SyncCommitteeContributionPool; import tech.pegasys.teku.statetransition.validation.InternalValidationResult; import tech.pegasys.teku.statetransition.validatorcache.ActiveValidatorChannel; +import tech.pegasys.teku.storage.client.RecentChainData; import tech.pegasys.teku.validator.api.SubmitDataError; @SuppressWarnings("unchecked") @@ -53,17 +61,18 @@ public class NodeDataProviderTest { private final ActiveValidatorChannel validatorChannel = mock(ActiveValidatorChannel.class); private final ProposersDataManager proposersDataManager = mock(ProposersDataManager.class); private final ForkChoiceNotifier forkChoiceNotifier = mock(ForkChoiceNotifier.class); + private final RecentChainData recentChainData = mock(RecentChainData.class); - private OperationPool attesterSlashingPool = mock(OperationPool.class); + private final OperationPool attesterSlashingPool = mock(OperationPool.class); - private OperationPool proposerSlashingPool = mock(OperationPool.class); + private final OperationPool proposerSlashingPool = mock(OperationPool.class); - private OperationPool voluntaryExitPool = mock(OperationPool.class); + private final OperationPool voluntaryExitPool = mock(OperationPool.class); - private OperationPool blsToExecutionChangePool = + private final OperationPool blsToExecutionChangePool = mock(OperationPool.class); - private SyncCommitteeContributionPool syncCommitteeContributionPool = + private final SyncCommitteeContributionPool syncCommitteeContributionPool = mock(SyncCommitteeContributionPool.class); private NodeDataProvider provider; @@ -82,7 +91,9 @@ public void setup() { false, validatorChannel, proposersDataManager, - forkChoiceNotifier); + forkChoiceNotifier, + recentChainData, + spec); } @Test @@ -113,4 +124,99 @@ void blsToExecutionChanges_ReturnsListOfErrors() throws ExecutionException, Inte assertThat(future.get()) .isEqualTo(List.of(new SubmitDataError(UInt64.ONE, "Computer says no"))); } + + @Test + void attestationsMetaDataLookUp_UseFirstAttestationSlot_WhenSlotParamNotProvided() { + final Spec specMock = setUpMockedSpec(); + when(attestationPool.getAttestations(any(), any())) + .thenReturn( + List.of( + dataStructureUtil.randomAttestation(5), dataStructureUtil.randomAttestation(10))); + provider.getAttestationsAndMetaData(Optional.empty(), Optional.empty()); + verify(specMock).atSlot(eq(UInt64.valueOf(5))); + } + + @Test + void attestationsMetaDataLookUp_UseSlot_WhenSlotParamProvided() { + final Spec specMock = setUpMockedSpec(); + when(attestationPool.getAttestations(any(), any())) + .thenReturn( + List.of( + dataStructureUtil.randomAttestation(5), dataStructureUtil.randomAttestation(10))); + provider.getAttestationsAndMetaData(Optional.of(UInt64.valueOf(8)), Optional.empty()); + verify(specMock).atSlot(eq(UInt64.valueOf(8))); + } + + @Test + void attestationsMetaDataLookUp_UseCurrentSlot_WhenSlotParamNotProvided_EmptyList() { + final Spec specMock = setUpMockedSpec(); + when(attestationPool.getAttestations(any(), any())).thenReturn(Collections.emptyList()); + final UInt64 currentSlot = UInt64.valueOf(8); + when(recentChainData.getCurrentSlot()).thenReturn(Optional.of(currentSlot)); + provider.getAttestationsAndMetaData(Optional.empty(), Optional.empty()); + verify(specMock).atSlot(eq(currentSlot)); + } + + @Test + void attestationsMetaDataLookUp_UseSlotZero_WhenSlotParamNotProvided_EmptyList_NoCurrentSlot() { + final Spec specMock = setUpMockedSpec(); + when(attestationPool.getAttestations(any(), any())).thenReturn(Collections.emptyList()); + when(recentChainData.getCurrentSlot()).thenReturn(Optional.empty()); + provider.getAttestationsAndMetaData(Optional.empty(), Optional.empty()); + verify(specMock).atSlot(eq(UInt64.ZERO)); + } + + @Test + void attesterSlashingsMetaDataLookUp_UseAttesterSlashingSlot_WhenListIsNotEmpty() { + final UInt64 slot = UInt64.valueOf(12); + final Spec specMock = setUpMockedSpec(); + when(attesterSlashingPool.getAll()) + .thenReturn(Set.of(dataStructureUtil.randomAttesterSlashingAtSlot(slot))); + provider.getAttesterSlashingsAndMetaData(); + verify(specMock).atSlot(eq(slot)); + } + + @Test + void attesterSlashingsMetaDataLookUp_UseCurrentSlot_WhenSlotParamNotProvided_EmptyList() { + final Spec specMock = setUpMockedSpec(); + when(attesterSlashingPool.getAll()).thenReturn(Set.of()); + final UInt64 currentSlot = UInt64.valueOf(8); + when(recentChainData.getCurrentSlot()).thenReturn(Optional.of(currentSlot)); + provider.getAttesterSlashingsAndMetaData(); + verify(specMock).atSlot(eq(currentSlot)); + } + + @Test + void attesterSlashingsMetaDataLookUp_UseSlotZero_WhenEmptyList_NoCurrentSlot() { + final Spec specMock = setUpMockedSpec(); + when(attesterSlashingPool.getAll()).thenReturn(Set.of()); + when(recentChainData.getCurrentSlot()).thenReturn(Optional.empty()); + provider.getAttesterSlashingsAndMetaData(); + verify(specMock).atSlot(eq(UInt64.ZERO)); + } + + private Spec setUpMockedSpec() { + final Spec specMock = mock(Spec.class); + final SpecVersion specVersionMock = mock(SpecVersion.class); + final SpecMilestone specMilestone = mock(SpecMilestone.class); + when(specVersionMock.getMilestone()).thenReturn(specMilestone); + when(specMock.atSlot(any())).thenReturn(specVersionMock); + provider = + new NodeDataProvider( + attestationPool, + attesterSlashingPool, + proposerSlashingPool, + voluntaryExitPool, + blsToExecutionChangePool, + syncCommitteeContributionPool, + blockBlobSidecarsTrackersPool, + attestationManager, + false, + validatorChannel, + proposersDataManager, + forkChoiceNotifier, + recentChainData, + specMock); + return specMock; + } } diff --git a/data/provider/src/test/java/tech/pegasys/teku/api/ValidatorDataProviderTest.java b/data/provider/src/test/java/tech/pegasys/teku/api/ValidatorDataProviderTest.java index 16a769569c8..d6a1a93a526 100644 --- a/data/provider/src/test/java/tech/pegasys/teku/api/ValidatorDataProviderTest.java +++ b/data/provider/src/test/java/tech/pegasys/teku/api/ValidatorDataProviderTest.java @@ -33,7 +33,6 @@ import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ZERO; import static tech.pegasys.teku.spec.logic.common.statetransition.results.BlockImportResult.FailureReason; -import com.fasterxml.jackson.core.JsonProcessingException; import it.unimi.dsi.fastutil.ints.IntList; import java.util.Collection; import java.util.List; @@ -52,12 +51,6 @@ import tech.pegasys.teku.api.exceptions.BadRequestException; import tech.pegasys.teku.api.response.v1.beacon.ValidatorStatus; import tech.pegasys.teku.api.schema.ValidatorBlockResult; -import tech.pegasys.teku.api.schema.altair.SignedBeaconBlockAltair; -import tech.pegasys.teku.api.schema.bellatrix.SignedBeaconBlockBellatrix; -import tech.pegasys.teku.api.schema.capella.SignedBeaconBlockCapella; -import tech.pegasys.teku.api.schema.deneb.SignedBeaconBlockDeneb; -import tech.pegasys.teku.api.schema.eip7594.SignedBeaconBlockEip7594; -import tech.pegasys.teku.api.schema.phase0.SignedBeaconBlockPhase0; import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.bls.BLSTestUtil; @@ -67,7 +60,6 @@ import tech.pegasys.teku.infrastructure.async.SafeFutureAssert; import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.provider.JsonProvider; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.TestSpecContext; @@ -91,11 +83,9 @@ public class ValidatorDataProviderTest { @SuppressWarnings("unchecked") private final ArgumentCaptor> args = ArgumentCaptor.forClass(List.class); - private final JsonProvider jsonProvider = new JsonProvider(); private Spec spec; private SpecMilestone specMilestone; private DataStructureUtil dataStructureUtil; - private SchemaObjectProvider schemaProvider; private final CombinedChainDataClient combinedChainDataClient = mock(CombinedChainDataClient.class); private final ValidatorApiChannel validatorApiChannel = mock(ValidatorApiChannel.class); @@ -104,10 +94,9 @@ public class ValidatorDataProviderTest { private final BLSSignature signatureInternal = BLSTestUtil.randomSignature(1234); @BeforeEach - public void setup(SpecContext specContext) { + public void setup(final SpecContext specContext) { spec = specContext.getSpec(); dataStructureUtil = specContext.getDataStructureUtil(); - schemaProvider = new SchemaObjectProvider(spec); provider = new ValidatorDataProvider(spec, validatorApiChannel, combinedChainDataClient); blockContainerAndMetaDataInternal = dataStructureUtil.randomBlockContainerAndMetaData(123); specMilestone = specContext.getSpecMilestone(); @@ -116,19 +105,13 @@ public void setup(SpecContext specContext) { @TestTemplate void getUnsignedBeaconBlockAtSlot_throwsWithoutSlotDefined() { assertThatExceptionOfType(IllegalArgumentException.class) - .isThrownBy( - () -> - provider.getUnsignedBeaconBlockAtSlot( - null, null, Optional.empty(), false, Optional.empty())); + .isThrownBy(() -> provider.produceBlock(null, null, Optional.empty(), Optional.empty())); } @TestTemplate void getUnsignedBeaconBlockAtSlot_shouldThrowWithoutRandaoDefined() { assertThatExceptionOfType(IllegalArgumentException.class) - .isThrownBy( - () -> - provider.getUnsignedBeaconBlockAtSlot( - ONE, null, Optional.empty(), false, Optional.empty())); + .isThrownBy(() -> provider.produceBlock(ONE, null, Optional.empty(), Optional.empty())); } @TestTemplate @@ -138,8 +121,7 @@ void getUnsignedBeaconBlockAtSlot_shouldThrowIfHistoricSlotRequested() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy( () -> - provider.getUnsignedBeaconBlockAtSlot( - ZERO, signatureInternal, Optional.empty(), false, Optional.empty())); + provider.produceBlock(ZERO, signatureInternal, Optional.empty(), Optional.empty())); } @TestTemplate @@ -149,12 +131,8 @@ void getUnsignedBeaconBlockAtSlot_shouldThrowIfFarFutureSlotRequested() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy( () -> - provider.getUnsignedBeaconBlockAtSlot( - UInt64.valueOf(10L), - signatureInternal, - Optional.empty(), - false, - Optional.empty())); + provider.produceBlock( + UInt64.valueOf(10L), signatureInternal, Optional.empty(), Optional.empty())); } @TestTemplate @@ -162,16 +140,14 @@ void getUnsignedBeaconBlockAtSlot_PreDeneb_shouldCreateAnUnsignedBlock() { assumeThat(specMilestone).isLessThan(SpecMilestone.DENEB); when(combinedChainDataClient.getCurrentSlot()).thenReturn(ZERO); when(validatorApiChannel.createUnsignedBlock( - ONE, signatureInternal, Optional.empty(), Optional.of(false), Optional.empty())) + ONE, signatureInternal, Optional.empty(), Optional.empty())) .thenReturn(completedFuture(Optional.of(blockContainerAndMetaDataInternal))); SafeFuture> data = - provider.getUnsignedBeaconBlockAtSlot( - ONE, signatureInternal, Optional.empty(), false, Optional.empty()); + provider.produceBlock(ONE, signatureInternal, Optional.empty(), Optional.empty()); verify(validatorApiChannel) - .createUnsignedBlock( - ONE, signatureInternal, Optional.empty(), Optional.of(false), Optional.empty()); + .createUnsignedBlock(ONE, signatureInternal, Optional.empty(), Optional.empty()); assertThat(data).isCompleted(); @@ -221,15 +197,14 @@ void produceBlock_shouldCreateAnUnsignedBlock() { .thenReturn(completedFuture(Optional.of(dataStructureUtil.randomBeaconState()))); when(validatorApiChannel.createUnsignedBlock( - ONE, signatureInternal, Optional.empty(), Optional.empty(), Optional.of(ONE))) + ONE, signatureInternal, Optional.empty(), Optional.of(ONE))) .thenReturn(completedFuture(Optional.of(blockContainerAndMetaDataInternal))); SafeFuture> data = provider.produceBlock(ONE, signatureInternal, Optional.empty(), Optional.of(ONE)); verify(validatorApiChannel) - .createUnsignedBlock( - ONE, signatureInternal, Optional.empty(), Optional.empty(), Optional.of(ONE)); + .createUnsignedBlock(ONE, signatureInternal, Optional.empty(), Optional.of(ONE)); assertThat(data).isCompleted(); @@ -273,71 +248,6 @@ void getAttestationDataAtSlot_shouldReturnEmptyIfBlockNotFound() { assertThat(result).isCompletedWithValue(Optional.empty()); } - @TestTemplate - void parseBlock_shouldParseBlocks() throws JsonProcessingException { - final SignedBeaconBlock internalSignedBlock = dataStructureUtil.randomSignedBeaconBlock(ONE); - final tech.pegasys.teku.api.schema.SignedBeaconBlock signedBlock = - schemaProvider.getSignedBeaconBlock(internalSignedBlock); - final String signedBlockJson = jsonProvider.objectToJSON(signedBlock); - - final tech.pegasys.teku.api.schema.SignedBeaconBlock parsedBlock = - provider.parseBlock(jsonProvider, signedBlockJson); - - assertThat(parsedBlock).isEqualTo(signedBlock); - assertThat(parsedBlock).isInstanceOf(tech.pegasys.teku.api.schema.SignedBeaconBlock.class); - } - - @TestTemplate - void parseBlock_shouldParseBlindedBlocks() throws JsonProcessingException { - final SignedBeaconBlock internalSignedBlock = - dataStructureUtil.randomSignedBlindedBeaconBlock(ONE); - final tech.pegasys.teku.api.schema.SignedBeaconBlock signedBlock = - schemaProvider.getSignedBlindedBeaconBlock(internalSignedBlock); - final String signedBlockJson = jsonProvider.objectToJSON(signedBlock); - - final tech.pegasys.teku.api.schema.SignedBeaconBlock parsedBlock = - provider.parseBlindedBlock(jsonProvider, signedBlockJson); - - assertThat(parsedBlock).isEqualTo(signedBlock); - assertThat(parsedBlock).isInstanceOf(tech.pegasys.teku.api.schema.SignedBeaconBlock.class); - } - - @TestTemplate - void parseBlock_shouldParseMilestoneSpecificBlocks(SpecContext specContext) - throws JsonProcessingException { - final SignedBeaconBlock internalSignedBlock = dataStructureUtil.randomSignedBeaconBlock(ONE); - final tech.pegasys.teku.api.schema.SignedBeaconBlock signedBlock = - schemaProvider.getSignedBeaconBlock(internalSignedBlock); - final String signedBlockJson = jsonProvider.objectToJSON(signedBlock); - - final tech.pegasys.teku.api.schema.SignedBeaconBlock parsedBlock = - provider.parseBlock(jsonProvider, signedBlockJson); - - assertThat(parsedBlock).isEqualTo(signedBlock); - switch (specContext.getSpecMilestone()) { - case PHASE0: - assertThat(parsedBlock).isInstanceOf(SignedBeaconBlockPhase0.class); - break; - case ALTAIR: - assertThat(parsedBlock).isInstanceOf(SignedBeaconBlockAltair.class); - break; - case BELLATRIX: - assertThat(parsedBlock).isInstanceOf(SignedBeaconBlockBellatrix.class); - break; - case CAPELLA: - assertThat(parsedBlock).isInstanceOf(SignedBeaconBlockCapella.class); - break; - case DENEB: - assertThat(parsedBlock).isInstanceOf(SignedBeaconBlockDeneb.class); - break; - case EIP7594: - assertThat(parsedBlock).isInstanceOf(SignedBeaconBlockEip7594.class); - break; - default: - throw new RuntimeException("notImplemented"); - } - } - @TestTemplate void getAttestationDataAtSlot_shouldReturnAttestationData() { when(combinedChainDataClient.isStoreAvailable()).thenReturn(true); diff --git a/data/provider/src/test/java/tech/pegasys/teku/api/blobselector/BlobSidecarSelectorFactoryTest.java b/data/provider/src/test/java/tech/pegasys/teku/api/blobselector/BlobSidecarSelectorFactoryTest.java index 37959379836..30500ee0259 100644 --- a/data/provider/src/test/java/tech/pegasys/teku/api/blobselector/BlobSidecarSelectorFactoryTest.java +++ b/data/provider/src/test/java/tech/pegasys/teku/api/blobselector/BlobSidecarSelectorFactoryTest.java @@ -39,6 +39,8 @@ import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockAndState; import tech.pegasys.teku.spec.datastructures.blocks.SlotAndBlockRoot; +import tech.pegasys.teku.spec.datastructures.metadata.BlobSidecarsAndMetaData; +import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; import tech.pegasys.teku.spec.datastructures.state.AnchorPoint; import tech.pegasys.teku.spec.util.DataStructureUtil; import tech.pegasys.teku.storage.client.BlobSidecarReconstructionProvider; @@ -67,9 +69,9 @@ public void headSelector_shouldGetHeadBlobSidecars() when(client.getBlobSidecars(blockAndState.getSlotAndBlockRoot(), indices)) .thenReturn(SafeFuture.completedFuture(blobSidecars)); - final Optional> result = + final Optional result = blobSidecarSelectorFactory.headSelector().getBlobSidecars(indices).get(); - assertThat(result).hasValue(blobSidecars); + assertThat(result.get().getData()).isEqualTo(blobSidecars); } @Test @@ -81,9 +83,9 @@ public void finalizedSelector_shouldGetFinalizedBlobSidecars() when(client.getBlobSidecars(anchorPoint.getSlotAndBlockRoot(), indices)) .thenReturn(SafeFuture.completedFuture(blobSidecars)); - final Optional> result = + final Optional result = blobSidecarSelectorFactory.finalizedSelector().getBlobSidecars(indices).get(); - assertThat(result).hasValue(blobSidecars); + assertThat(result.get().getData()).isEqualTo(blobSidecars); } @Test @@ -94,31 +96,37 @@ public void genesisSelector_shouldGetGenesisBlobSidecars() when(client.getBlobSidecars(block.getSlotAndBlockRoot(), indices)) .thenReturn(SafeFuture.completedFuture(blobSidecars)); - final Optional> result = + final Optional result = blobSidecarSelectorFactory.genesisSelector().getBlobSidecars(indices).get(); - assertThat(result).hasValue(blobSidecars); + assertThat(result.get().getData()).isEqualTo(blobSidecars); } @Test public void blockRootSelector_shouldGetBlobSidecarsForFinalizedSlot() throws ExecutionException, InterruptedException { final UInt64 finalizedSlot = UInt64.valueOf(42); + final SignedBlockAndState blockAndState = data.randomSignedBlockAndState(100); + when(client.getChainHead()).thenReturn(Optional.of(ChainHead.create(blockAndState))); + when(client.getFinalizedSlotByBlockRoot(block.getRoot())) .thenReturn(SafeFuture.completedFuture(Optional.of(finalizedSlot))); when(client.getBlobSidecars(new SlotAndBlockRoot(finalizedSlot, block.getRoot()), indices)) .thenReturn(SafeFuture.completedFuture(blobSidecars)); - final Optional> result = + final Optional result = blobSidecarSelectorFactory .blockRootSelector(block.getRoot()) .getBlobSidecars(indices) .get(); - assertThat(result).hasValue(blobSidecars); + assertThat(result.get().getData()).isEqualTo(blobSidecars); } @Test public void blockRootSelector_shouldGetBlobSidecarsByRetrievingBlock() throws ExecutionException, InterruptedException { + final SignedBlockAndState blockAndState = data.randomSignedBlockAndState(100); + when(client.getChainHead()).thenReturn(Optional.of(ChainHead.create(blockAndState))); + when(client.getFinalizedSlotByBlockRoot(block.getRoot())) .thenReturn(SafeFuture.completedFuture(Optional.empty())); when(client.getBlockByBlockRoot(block.getRoot())) @@ -126,12 +134,12 @@ public void blockRootSelector_shouldGetBlobSidecarsByRetrievingBlock() when(client.getBlobSidecars(block.getSlotAndBlockRoot(), indices)) .thenReturn(SafeFuture.completedFuture(blobSidecars)); - final Optional> result = + final Optional result = blobSidecarSelectorFactory .blockRootSelector(block.getRoot()) .getBlobSidecars(indices) .get(); - assertThat(result).hasValue(blobSidecars); + assertThat(result.get().getData()).isEqualTo(blobSidecars); } @Test @@ -140,24 +148,29 @@ public void slotSelector_shouldGetBlobSidecarsFromFinalizedSlot() when(client.isFinalized(block.getSlot())).thenReturn(true); when(client.getBlobSidecars(block.getSlot(), indices)) .thenReturn(SafeFuture.completedFuture(blobSidecars)); + when(client.isChainHeadOptimistic()).thenReturn(false); - final Optional> result = + final Optional result = blobSidecarSelectorFactory.slotSelector(block.getSlot()).getBlobSidecars(indices).get(); - assertThat(result).hasValue(blobSidecars); + assertThat(result.get().getData()).isEqualTo(blobSidecars); } @Test public void slotSelector_shouldGetBlobSidecarsByRetrievingBlockWhenSlotNotFinalized() throws ExecutionException, InterruptedException { + + final SignedBlockAndState blockAndState = data.randomSignedBlockAndState(100); + when(client.isFinalized(block.getSlot())).thenReturn(false); when(client.getBlockAtSlotExact(block.getSlot())) .thenReturn(SafeFuture.completedFuture(Optional.of(block))); when(client.getBlobSidecars(block.getSlotAndBlockRoot(), indices)) .thenReturn(SafeFuture.completedFuture(blobSidecars)); + when(client.getChainHead()).thenReturn(Optional.of(ChainHead.create(blockAndState))); - final Optional> result = + final Optional result = blobSidecarSelectorFactory.slotSelector(block.getSlot()).getBlobSidecars(indices).get(); - assertThat(result).hasValue(blobSidecars); + assertThat(result.get().getData()).isEqualTo(blobSidecars); } @Test @@ -189,24 +202,27 @@ public void justifiedSelector_shouldThrowUnsupportedOperationException() { @Test public void shouldNotLookForBlobSidecarsWhenNoKzgCommitments() throws ExecutionException, InterruptedException { + final SignedBlockAndState blockAndState = data.randomSignedBlockAndState(100); + final SignedBeaconBlock blockWithEmptyCommitments = data.randomSignedBeaconBlockWithEmptyCommitments(); when(client.isFinalized(blockWithEmptyCommitments.getSlot())).thenReturn(false); when(client.getBlockAtSlotExact(blockWithEmptyCommitments.getSlot())) .thenReturn(SafeFuture.completedFuture(Optional.of(blockWithEmptyCommitments))); - Optional> maybeBlobsidecars = + when(client.getChainHead()).thenReturn(Optional.of(ChainHead.create(blockAndState))); + Optional maybeBlobsidecars = blobSidecarSelectorFactory .slotSelector(blockWithEmptyCommitments.getSlot()) .getBlobSidecars(indices) .get(); verify(client, never()).getBlobSidecars(any(SlotAndBlockRoot.class), anyList()); assertThat(maybeBlobsidecars).isPresent(); - assertThat(maybeBlobsidecars.get()).isEmpty(); + assertThat(maybeBlobsidecars.get().getData()).isEmpty(); } @TestTemplate public void shouldLookForBlobSidecarsOnlyAfterDeneb( - TestSpecInvocationContextProvider.SpecContext ctx) + final TestSpecInvocationContextProvider.SpecContext ctx) throws ExecutionException, InterruptedException { final SignedBeaconBlock block = new DataStructureUtil(ctx.getSpec()).randomSignedBeaconBlock(); when(client.isFinalized(block.getSlot())).thenReturn(false); @@ -229,7 +245,9 @@ public void shouldForwardRequestsToReconstructionProviderAfterEip7594() mock(BlobSidecarReconstructionProvider.class); final BlobSidecarSelectorFactory blobSidecarSelectorFactoryEip7594 = new BlobSidecarSelectorFactory( - TestSpecFactory.createMinimalEip7594(), client, blobSidecarReconstructionProviderMock); + TestSpecFactory.createMinimalElectraEip7594(), + client, + blobSidecarReconstructionProviderMock); final SignedBlockAndState blockAndState = data.randomSignedBlockAndState(100); @@ -239,7 +257,11 @@ public void shouldForwardRequestsToReconstructionProviderAfterEip7594() .thenReturn(SafeFuture.completedFuture(blobSidecars)); final Optional> result = - blobSidecarSelectorFactoryEip7594.headSelector().getBlobSidecars(indices).get(); + blobSidecarSelectorFactoryEip7594 + .headSelector() + .getBlobSidecars(indices) + .get() + .map(ObjectAndMetaData::getData); assertThat(result).hasValue(blobSidecars); verify(blobSidecarReconstructionProviderMock) .reconstructBlobSidecars(any(SlotAndBlockRoot.class), anyList()); @@ -252,7 +274,9 @@ public void shouldForwardSlotSelectorRequestsToReconstructionProviderAfterEip759 mock(BlobSidecarReconstructionProvider.class); final BlobSidecarSelectorFactory blobSidecarSelectorFactoryEip7594 = new BlobSidecarSelectorFactory( - TestSpecFactory.createMinimalEip7594(), client, blobSidecarReconstructionProviderMock); + TestSpecFactory.createMinimalElectraEip7594(), + client, + blobSidecarReconstructionProviderMock); when(client.isFinalized(block.getSlot())).thenReturn(true); when(blobSidecarReconstructionProviderMock.reconstructBlobSidecars(block.getSlot(), indices)) @@ -262,9 +286,61 @@ public void shouldForwardSlotSelectorRequestsToReconstructionProviderAfterEip759 blobSidecarSelectorFactoryEip7594 .slotSelector(block.getSlot()) .getBlobSidecars(indices) - .get(); + .get() + .map(ObjectAndMetaData::getData); assertThat(result).hasValue(blobSidecars); verify(blobSidecarReconstructionProviderMock) .reconstructBlobSidecars(any(UInt64.class), anyList()); } + + @Test + public void genesisSelector_shouldAlwaysReturnOptimisticMetadataFieldFalse() + throws ExecutionException, InterruptedException { + when(client.getBlockAtSlotExact(UInt64.ZERO)) + .thenReturn(SafeFuture.completedFuture(Optional.of(block))); + when(client.getBlobSidecars(block.getSlotAndBlockRoot(), indices)) + .thenReturn(SafeFuture.completedFuture(blobSidecars)); + + final Optional result = + blobSidecarSelectorFactory.genesisSelector().getBlobSidecars(indices).get(); + assertThat(result).isNotEmpty(); + final BlobSidecarsAndMetaData blobSidecarsAndMetaData = result.get(); + assertThat(blobSidecarsAndMetaData.isExecutionOptimistic()).isFalse(); + } + + @Test + public void slotSelector_whenSelectingFinalizedBlockMetadataReturnsFinalizedTrue() + throws ExecutionException, InterruptedException { + when(client.isFinalized(block.getSlot())).thenReturn(true); + when(client.getBlobSidecars(block.getSlot(), indices)) + .thenReturn(SafeFuture.completedFuture(blobSidecars)); + when(client.isChainHeadOptimistic()).thenReturn(false); + + final Optional result = + blobSidecarSelectorFactory.slotSelector(block.getSlot()).getBlobSidecars(indices).get(); + + assertThat(result).isNotEmpty(); + final BlobSidecarsAndMetaData blobSidecarsAndMetaData = result.get(); + assertThat(blobSidecarsAndMetaData.isFinalized()).isTrue(); + } + + @Test + public void slotSelector_whenSelectingNonFinalizedBlockMetadataReturnsFinalizedFalse() + throws ExecutionException, InterruptedException { + when(client.isFinalized(block.getSlot())).thenReturn(false); + when(client.getBlockAtSlotExact(block.getSlot())) + .thenReturn(SafeFuture.completedFuture(Optional.of(block))); + when(client.getBlobSidecars(block.getSlot(), indices)) + .thenReturn(SafeFuture.completedFuture(blobSidecars)); + when(client.isChainHeadOptimistic()).thenReturn(false); + when(client.getBlobSidecars(block.getSlotAndBlockRoot(), indices)) + .thenReturn(SafeFuture.completedFuture(blobSidecars)); + + final Optional result = + blobSidecarSelectorFactory.slotSelector(block.getSlot()).getBlobSidecars(indices).get(); + + assertThat(result).isNotEmpty(); + final BlobSidecarsAndMetaData blobSidecarsAndMetaData = result.get(); + assertThat(blobSidecarsAndMetaData.isFinalized()).isFalse(); + } } diff --git a/data/publisher/build.gradle b/data/publisher/build.gradle index 348c5439061..f96bd6f4d36 100644 --- a/data/publisher/build.gradle +++ b/data/publisher/build.gradle @@ -4,7 +4,6 @@ dependencies { implementation project (':infrastructure:metrics') implementation project (':infrastructure:version') implementation project (':infrastructure:time') - implementation project (':data:serializer') implementation project (':infrastructure:serviceutils') implementation project (':infrastructure:http') diff --git a/data/publisher/src/main/java/tech/pegasys/teku/data/publisher/BaseMetricData.java b/data/publisher/src/main/java/tech/pegasys/teku/data/publisher/BaseMetricData.java index 6c5587b4c46..b70b23c87be 100644 --- a/data/publisher/src/main/java/tech/pegasys/teku/data/publisher/BaseMetricData.java +++ b/data/publisher/src/main/java/tech/pegasys/teku/data/publisher/BaseMetricData.java @@ -25,7 +25,7 @@ public class BaseMetricData { @JsonProperty("process") private final String process; - public BaseMetricData(long timestamp, String process) { + public BaseMetricData(final long timestamp, final String process) { this.timestamp = timestamp; this.process = process; } diff --git a/data/publisher/src/main/java/tech/pegasys/teku/data/publisher/MetricsPublisherManager.java b/data/publisher/src/main/java/tech/pegasys/teku/data/publisher/MetricsPublisherManager.java index 0792ef81e68..1b8569efb9c 100644 --- a/data/publisher/src/main/java/tech/pegasys/teku/data/publisher/MetricsPublisherManager.java +++ b/data/publisher/src/main/java/tech/pegasys/teku/data/publisher/MetricsPublisherManager.java @@ -14,6 +14,7 @@ package tech.pegasys.teku.data.publisher; import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; import com.google.common.base.Throwables; import java.io.File; import java.io.IOException; @@ -30,7 +31,6 @@ import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.metrics.MetricsEndpoint; import tech.pegasys.teku.infrastructure.time.TimeProvider; -import tech.pegasys.teku.provider.JsonProvider; import tech.pegasys.teku.service.serviceutils.Service; public class MetricsPublisherManager extends Service { @@ -39,7 +39,7 @@ public class MetricsPublisherManager extends Service { private final long intervalBetweenPublications; private final AsyncRunnerFactory asyncRunnerFactory; private final MetricsDataFactory metricsDataFactory; - private final JsonProvider jsonProvider = new JsonProvider(); + private final ObjectMapper objectMapper = new ObjectMapper(); private final Optional metricsUrl; private final MetricsPublisher metricsPublisher; @@ -86,7 +86,7 @@ public SafeFuture start() { private void publishMetrics() throws IOException { List clientData = metricsDataFactory.getMetricData(); if (!clientData.isEmpty()) { - metricsPublisher.publishMetrics(jsonProvider.objectToJSON(clientData)); + metricsPublisher.publishMetrics(objectMapper.writeValueAsString(clientData)); } } diff --git a/data/publisher/src/main/java/tech/pegasys/teku/data/publisher/SystemMetricData.java b/data/publisher/src/main/java/tech/pegasys/teku/data/publisher/SystemMetricData.java index 67e3d23e3c9..63717c91a00 100644 --- a/data/publisher/src/main/java/tech/pegasys/teku/data/publisher/SystemMetricData.java +++ b/data/publisher/src/main/java/tech/pegasys/teku/data/publisher/SystemMetricData.java @@ -83,7 +83,7 @@ public class SystemMetricData extends BaseMetricData { @JsonProperty("misc_os") private final String miscOs = getNormalizedOSVersion(); - public SystemMetricData(long timestamp, final File beaconNodeDirectory) { + public SystemMetricData(final long timestamp, final File beaconNodeDirectory) { super(timestamp, SYSTEM.getDisplayName()); SystemInfo systemInfo = new SystemInfo(); diff --git a/data/publisher/src/test/java/tech/pegasys/teku/data/publisher/BaseMetricDataTest.java b/data/publisher/src/test/java/tech/pegasys/teku/data/publisher/BaseMetricDataTest.java index 79a2b4a17ae..3f51e90efdd 100644 --- a/data/publisher/src/test/java/tech/pegasys/teku/data/publisher/BaseMetricDataTest.java +++ b/data/publisher/src/test/java/tech/pegasys/teku/data/publisher/BaseMetricDataTest.java @@ -19,17 +19,15 @@ import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.provider.JsonProvider; public class BaseMetricDataTest { - private final JsonProvider jsonProvider = new JsonProvider(); + private final ObjectMapper mapper = new ObjectMapper(); @Test public void shouldSerializeObject() throws JsonProcessingException { final String processField = "system"; final BaseMetricData process = new BaseMetricData(10L, processField); - final String data = jsonProvider.objectToJSON(process); - final ObjectMapper mapper = jsonProvider.getObjectMapper(); + final String data = mapper.writeValueAsString(process); final JsonNode node = mapper.readTree(data); assertThat(node.get("version").asInt()).isEqualTo(1); assertThat(node.get("process").asText()).isEqualTo(processField); diff --git a/data/publisher/src/test/java/tech/pegasys/teku/data/publisher/BeaconNodeMetricDataTest.java b/data/publisher/src/test/java/tech/pegasys/teku/data/publisher/BeaconNodeMetricDataTest.java index ceb58de546b..89bc80f4de0 100644 --- a/data/publisher/src/test/java/tech/pegasys/teku/data/publisher/BeaconNodeMetricDataTest.java +++ b/data/publisher/src/test/java/tech/pegasys/teku/data/publisher/BeaconNodeMetricDataTest.java @@ -19,11 +19,10 @@ import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.provider.JsonProvider; import tech.pegasys.teku.test.data.publisher.StubMetricsPublisherSource; public class BeaconNodeMetricDataTest { - private final JsonProvider jsonProvider = new JsonProvider(); + private final ObjectMapper mapper = new ObjectMapper(); @Test void shouldSerialize() throws JsonProcessingException { @@ -35,8 +34,7 @@ void shouldSerialize() throws JsonProcessingException { .isEth2Synced(true) .build(); final BeaconNodeMetricData process = new BeaconNodeMetricData(10L, source); - final String data = jsonProvider.objectToJSON(process); - final ObjectMapper mapper = jsonProvider.getObjectMapper(); + final String data = mapper.writeValueAsString(process); final JsonNode node = mapper.readTree(data); assertThat(node.size()).isEqualTo(20); assertThat(node.get("process").asText()).isEqualTo("beaconnode"); diff --git a/data/publisher/src/test/java/tech/pegasys/teku/data/publisher/GeneralProcessMetricDataTest.java b/data/publisher/src/test/java/tech/pegasys/teku/data/publisher/GeneralProcessMetricDataTest.java index 4185524da9c..d77b29f5a9d 100644 --- a/data/publisher/src/test/java/tech/pegasys/teku/data/publisher/GeneralProcessMetricDataTest.java +++ b/data/publisher/src/test/java/tech/pegasys/teku/data/publisher/GeneralProcessMetricDataTest.java @@ -19,12 +19,11 @@ import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.provider.JsonProvider; import tech.pegasys.teku.test.data.publisher.StubMetricsPublisherSource; public class GeneralProcessMetricDataTest { - private final JsonProvider jsonProvider = new JsonProvider(); + private final ObjectMapper mapper = new ObjectMapper(); @Test public void shouldSerializeObject() throws JsonProcessingException { @@ -36,8 +35,7 @@ public void shouldSerializeObject() throws JsonProcessingException { .build(); final GeneralProcessMetricData process = new GeneralProcessMetricData(10L, processField, source); - final String data = jsonProvider.objectToJSON(process); - final ObjectMapper mapper = jsonProvider.getObjectMapper(); + final String data = mapper.writeValueAsString(process); final JsonNode node = mapper.readTree(data); assertThat(node.size()).isEqualTo(10); assertThat(node.get("client_build").asInt()).isEqualTo(0); diff --git a/data/publisher/src/test/java/tech/pegasys/teku/data/publisher/MetricsPublisherManagerTest.java b/data/publisher/src/test/java/tech/pegasys/teku/data/publisher/MetricsPublisherManagerTest.java index 03ff3079c1c..3c641d4ffb1 100644 --- a/data/publisher/src/test/java/tech/pegasys/teku/data/publisher/MetricsPublisherManagerTest.java +++ b/data/publisher/src/test/java/tech/pegasys/teku/data/publisher/MetricsPublisherManagerTest.java @@ -22,7 +22,7 @@ import static org.mockito.Mockito.when; import java.io.IOException; -import java.net.URL; +import java.net.URI; import java.nio.file.Path; import java.util.List; import java.util.Optional; @@ -56,7 +56,8 @@ void setup() throws IOException { when(metricsConfig.getPublicationInterval()).thenReturn(1); when(metricsEndpoint.getMetricsSystem()).thenReturn(prometheusMetricsSystem); when(metricsEndpoint.getMetricConfig()).thenReturn(metricsConfig); - when(metricsConfig.getMetricsEndpoint()).thenReturn(Optional.of(new URL("http://host.com/"))); + when(metricsConfig.getMetricsEndpoint()) + .thenReturn(Optional.of(URI.create("http://host.com/").toURL())); } @Test diff --git a/data/publisher/src/test/java/tech/pegasys/teku/data/publisher/ValidatorMetricDataTest.java b/data/publisher/src/test/java/tech/pegasys/teku/data/publisher/ValidatorMetricDataTest.java index 4516c829ddd..0dfc19f1ba5 100644 --- a/data/publisher/src/test/java/tech/pegasys/teku/data/publisher/ValidatorMetricDataTest.java +++ b/data/publisher/src/test/java/tech/pegasys/teku/data/publisher/ValidatorMetricDataTest.java @@ -19,19 +19,17 @@ import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.provider.JsonProvider; import tech.pegasys.teku.test.data.publisher.StubMetricsPublisherSource; class ValidatorMetricDataTest { - private final JsonProvider jsonProvider = new JsonProvider(); + private final ObjectMapper mapper = new ObjectMapper(); @Test public void shouldSerializeObject() throws JsonProcessingException { final MetricsPublisherSource source = StubMetricsPublisherSource.builder().validatorsActive(33).validatorsTotal(44).build(); final ValidatorMetricData process = new ValidatorMetricData(10L, source); - final String data = jsonProvider.objectToJSON(process); - final ObjectMapper mapper = jsonProvider.getObjectMapper(); + final String data = mapper.writeValueAsString(process); final JsonNode node = mapper.readTree(data); assertThat(node.size()).isEqualTo(12); assertThat(node.get("process").asText()).isEqualTo("validator"); diff --git a/data/serializer/build.gradle b/data/serializer/build.gradle index 12b1e3d679f..4302d4d8e80 100644 --- a/data/serializer/build.gradle +++ b/data/serializer/build.gradle @@ -10,7 +10,7 @@ dependencies { implementation project(':infrastructure:jackson') implementation project(':infrastructure:async') - implementation 'org.apache.tuweni:tuweni-units' + implementation 'io.tmio:tuweni-units' testImplementation project(':data:provider') testImplementation testFixtures(project(':ethereum:spec')) diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/exceptions/BadRequestException.java b/data/serializer/src/main/java/tech/pegasys/teku/api/exceptions/BadRequestException.java index ad4e700bcde..2cad2a94646 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/exceptions/BadRequestException.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/exceptions/BadRequestException.java @@ -14,11 +14,11 @@ package tech.pegasys.teku.api.exceptions; public class BadRequestException extends RuntimeException { - public BadRequestException(String message, Throwable cause) { + public BadRequestException(final String message, final Throwable cause) { super(message, cause); } - public BadRequestException(String message) { + public BadRequestException(final String message) { super(message); } } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/exceptions/RemoteServiceNotAvailableException.java b/data/serializer/src/main/java/tech/pegasys/teku/api/exceptions/RemoteServiceNotAvailableException.java index c4bdf033e8b..e8b3f901979 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/exceptions/RemoteServiceNotAvailableException.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/exceptions/RemoteServiceNotAvailableException.java @@ -14,11 +14,11 @@ package tech.pegasys.teku.api.exceptions; public class RemoteServiceNotAvailableException extends RuntimeException { - public RemoteServiceNotAvailableException(String message, Throwable cause) { + public RemoteServiceNotAvailableException(final String message, final Throwable cause) { super(message, cause); } - public RemoteServiceNotAvailableException(String message) { + public RemoteServiceNotAvailableException(final String message) { super(message); } } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/AllBlocksAtSlotData.java b/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/AllBlocksAtSlotData.java index 57b501a86b8..7a66cbc4dba 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/AllBlocksAtSlotData.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/AllBlocksAtSlotData.java @@ -45,7 +45,7 @@ public List getBlocks() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/AttestationRewardsData.java b/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/AttestationRewardsData.java index 4d5cf1a8e85..f9023e0bea5 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/AttestationRewardsData.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/AttestationRewardsData.java @@ -22,8 +22,8 @@ public class AttestationRewardsData { final List totalAttestationRewards; public AttestationRewardsData( - List idealAttestationRewards, - List totalAttestationRewards) { + final List idealAttestationRewards, + final List totalAttestationRewards) { this.idealAttestationRewards = idealAttestationRewards; this.totalAttestationRewards = totalAttestationRewards; } @@ -37,7 +37,7 @@ public List getTotalAttestationRewards() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/BlockHeadersResponse.java b/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/BlockHeadersResponse.java index 621dfed6f1c..81c80a99bdd 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/BlockHeadersResponse.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/BlockHeadersResponse.java @@ -44,7 +44,7 @@ public List getData() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/GetAttestationRewardsResponse.java b/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/GetAttestationRewardsResponse.java index 15558bea429..6079c151d6d 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/GetAttestationRewardsResponse.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/GetAttestationRewardsResponse.java @@ -22,9 +22,9 @@ public class GetAttestationRewardsResponse { private final AttestationRewardsData attestationRewardsData; public GetAttestationRewardsResponse( - boolean executionOptimistic, - boolean finalized, - AttestationRewardsData attestationRewardsData) { + final boolean executionOptimistic, + final boolean finalized, + final AttestationRewardsData attestationRewardsData) { this.executionOptimistic = executionOptimistic; this.finalized = finalized; this.attestationRewardsData = attestationRewardsData; @@ -43,7 +43,7 @@ public AttestationRewardsData getAttestationRewardsData() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/IdealAttestationReward.java b/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/IdealAttestationReward.java index a880ed2cdc1..b3a76308347 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/IdealAttestationReward.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/IdealAttestationReward.java @@ -71,7 +71,7 @@ public void addInactivity(final long inactivity) { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/StateSyncCommitteesData.java b/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/StateSyncCommitteesData.java index 7b47b7b7cb8..8927d02b3c7 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/StateSyncCommitteesData.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/StateSyncCommitteesData.java @@ -37,7 +37,7 @@ public List> getValidatorAggregates() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/StateValidatorBalanceData.java b/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/StateValidatorBalanceData.java index 030641ec626..4b1df8bdf2e 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/StateValidatorBalanceData.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/StateValidatorBalanceData.java @@ -59,7 +59,7 @@ public static SerializableTypeDefinition getJsonTypeD } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/SyncCommitteeRewardData.java b/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/SyncCommitteeRewardData.java index ea33c230e75..13bc1ea5d22 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/SyncCommitteeRewardData.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/SyncCommitteeRewardData.java @@ -53,7 +53,7 @@ public List> getRewardData() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/TotalAttestationReward.java b/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/TotalAttestationReward.java index 744ea6ca4ad..8acaa255bb3 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/TotalAttestationReward.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/TotalAttestationReward.java @@ -30,12 +30,12 @@ public class TotalAttestationReward { private final long inactivity; public TotalAttestationReward( - long validatorIndex, - long head, - long target, - long source, - Optional inclusionDelay, - long inactivity) { + final long validatorIndex, + final long head, + final long target, + final long source, + final Optional inclusionDelay, + final long inactivity) { this.validatorIndex = validatorIndex; this.head = head; this.target = target; @@ -44,7 +44,8 @@ public TotalAttestationReward( this.inactivity = inactivity; } - public TotalAttestationReward(long validatorIndex, final RewardAndPenalty rewardAndPenalty) { + public TotalAttestationReward( + final long validatorIndex, final RewardAndPenalty rewardAndPenalty) { this.validatorIndex = validatorIndex; final DetailedRewardAndPenalty detailedRewardAndPenalty = @@ -97,7 +98,7 @@ public long getInactivity() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/ValidatorLivenessAtEpoch.java b/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/ValidatorLivenessAtEpoch.java index 9911abc090d..919170f94c8 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/ValidatorLivenessAtEpoch.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/migrated/ValidatorLivenessAtEpoch.java @@ -16,53 +16,44 @@ import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.BOOLEAN_TYPE; import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; -import java.util.Objects; -import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -public class ValidatorLivenessAtEpoch { - private final UInt64 index; - private final boolean isLive; +public record ValidatorLivenessAtEpoch(UInt64 index, boolean isLive) { - public ValidatorLivenessAtEpoch(final UInt64 index, final boolean isLive) { - this.index = index; - this.isLive = isLive; + public static DeserializableTypeDefinition getJsonTypeDefinition() { + return DeserializableTypeDefinition.object( + ValidatorLivenessAtEpoch.class, ValidatorLivenessAtEpoch.Builder.class) + .initializer(Builder::new) + .finisher(Builder::build) + .withField("index", UINT64_TYPE, ValidatorLivenessAtEpoch::index, Builder::index) + .withField("is_live", BOOLEAN_TYPE, ValidatorLivenessAtEpoch::isLive, Builder::isLive) + .build(); } - public UInt64 getIndex() { - return index; + @Override + public String toString() { + return "ValidatorLivenessAtEpoch{" + "index=" + index + ", isLive=" + isLive + '}'; } - public boolean isLive() { - return isLive; - } + public static class Builder { + private UInt64 index; + private boolean isLive; - public static SerializableTypeDefinition getJsonTypeDefinition() { - return SerializableTypeDefinition.object(ValidatorLivenessAtEpoch.class) - .withField("index", UINT64_TYPE, ValidatorLivenessAtEpoch::getIndex) - .withField("is_live", BOOLEAN_TYPE, ValidatorLivenessAtEpoch::isLive) - .build(); - } + public Builder() {} - @Override - public boolean equals(final Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; + public Builder isLive(final boolean isLive) { + this.isLive = isLive; + return this; } - final ValidatorLivenessAtEpoch that = (ValidatorLivenessAtEpoch) o; - return isLive == that.isLive && Objects.equals(index, that.index); - } - @Override - public int hashCode() { - return Objects.hash(index, isLive); - } + public Builder index(final UInt64 index) { + this.index = index; + return this; + } - @Override - public String toString() { - return "ValidatorLivenessAtEpoch{" + "index=" + index + ", isLive=" + isLive + '}'; + public ValidatorLivenessAtEpoch build() { + return new ValidatorLivenessAtEpoch(index, isLive); + } } } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/request/v1/validator/BeaconCommitteeSubscriptionRequest.java b/data/serializer/src/main/java/tech/pegasys/teku/api/request/v1/validator/BeaconCommitteeSubscriptionRequest.java deleted file mode 100644 index a6214660977..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/request/v1/validator/BeaconCommitteeSubscriptionRequest.java +++ /dev/null @@ -1,52 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.api.request.v1.validator; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.google.common.base.Preconditions; -import io.swagger.v3.oas.annotations.media.Schema; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; - -@SuppressWarnings("JavaCase") -public class BeaconCommitteeSubscriptionRequest { - - public final String validator_index; - - public final String committee_index; - - @Schema(type = "string", format = "uint64") - public final UInt64 committees_at_slot; - - @Schema(type = "string", format = "uint64") - public final UInt64 slot; - - public final boolean is_aggregator; - - @JsonCreator - public BeaconCommitteeSubscriptionRequest( - @JsonProperty("validator_index") final String validator_index, - @JsonProperty("committee_index") final String committee_index, - @JsonProperty("committees_at_slot") final UInt64 committees_at_slot, - @JsonProperty("slot") final UInt64 slot, - @JsonProperty("is_aggregator") final boolean is_aggregator) { - Preconditions.checkNotNull(validator_index, "validator_index should be specified"); - this.validator_index = validator_index; - Preconditions.checkNotNull(committee_index, "committee_index should be specified"); - this.committee_index = committee_index; - this.committees_at_slot = committees_at_slot; - this.slot = slot; - this.is_aggregator = is_aggregator; - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/request/v1/validator/PostRegisterValidatorRequest.java b/data/serializer/src/main/java/tech/pegasys/teku/api/request/v1/validator/PostRegisterValidatorRequest.java deleted file mode 100644 index 0bf2bb88d9f..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/request/v1/validator/PostRegisterValidatorRequest.java +++ /dev/null @@ -1,61 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.api.request.v1.validator; - -import static tech.pegasys.teku.api.schema.SchemaConstants.DESCRIPTION_BYTES96; -import static tech.pegasys.teku.api.schema.SchemaConstants.DESCRIPTION_EXECUTION_ADDRESS; -import static tech.pegasys.teku.api.schema.SchemaConstants.EXAMPLE_EXECUTION_ADDRESS; -import static tech.pegasys.teku.api.schema.SchemaConstants.EXAMPLE_PUBKEY; -import static tech.pegasys.teku.api.schema.SchemaConstants.EXAMPLE_UINT64; -import static tech.pegasys.teku.api.schema.SchemaConstants.PATTERN_EXECUTION_ADDRESS; -import static tech.pegasys.teku.api.schema.SchemaConstants.PATTERN_PUBKEY; - -import io.swagger.v3.oas.annotations.media.Schema; -import tech.pegasys.teku.api.schema.BLSPubKey; -import tech.pegasys.teku.api.schema.BLSSignature; -import tech.pegasys.teku.ethereum.execution.types.Eth1Address; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; - -@SuppressWarnings("JavaCase") -public class PostRegisterValidatorRequest { - public ValidatorRegistration message; - - @Schema(type = "string", format = "byte", description = DESCRIPTION_BYTES96) - public BLSSignature signature; - - public static class ValidatorRegistration { - - @Schema( - type = "string", - pattern = PATTERN_EXECUTION_ADDRESS, - example = EXAMPLE_EXECUTION_ADDRESS, - description = DESCRIPTION_EXECUTION_ADDRESS) - public Eth1Address fee_recipient; - - @Schema(type = "string", format = "uint64", example = EXAMPLE_UINT64) - public UInt64 gas_limit; - - @Schema(type = "string", format = "uint64", example = EXAMPLE_UINT64) - public UInt64 timestamp; - - @Schema( - type = "string", - pattern = PATTERN_PUBKEY, - example = EXAMPLE_PUBKEY, - description = - "The validator's BLS public key, uniquely identifying them. " - + "48-bytes, hex encoded with 0x prefix, case insensitive.") - public BLSPubKey pubkey; - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/GetForkResponse.java b/data/serializer/src/main/java/tech/pegasys/teku/api/response/GetForkResponse.java deleted file mode 100644 index cc239d838ff..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/GetForkResponse.java +++ /dev/null @@ -1,63 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.api.response; - -import static tech.pegasys.teku.api.schema.SchemaConstants.DESCRIPTION_BYTES32; -import static tech.pegasys.teku.api.schema.SchemaConstants.DESCRIPTION_BYTES4; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import io.swagger.v3.oas.annotations.media.Schema; -import org.apache.tuweni.bytes.Bytes32; -import tech.pegasys.teku.infrastructure.bytes.Bytes4; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.datastructures.state.Fork; -import tech.pegasys.teku.spec.datastructures.state.ForkInfo; - -@SuppressWarnings("JavaCase") -public class GetForkResponse { - @Schema(type = "string", format = "byte", description = DESCRIPTION_BYTES4) - public Bytes4 previous_version; - - @Schema(type = "string", format = "byte", description = DESCRIPTION_BYTES4) - public Bytes4 current_version; - - @Schema(type = "string", format = "uint64") - public UInt64 epoch; - - @Schema(type = "string", format = "byte", description = DESCRIPTION_BYTES32) - public final Bytes32 genesis_validators_root; - - @JsonCreator - public GetForkResponse( - @JsonProperty("previous_version") final Bytes4 previous_version, - @JsonProperty("current_version") final Bytes4 current_version, - @JsonProperty("epoch") final UInt64 epoch, - @JsonProperty("genesis_validators_root") final Bytes32 genesis_validators_root) { - this.previous_version = previous_version; - this.current_version = current_version; - this.epoch = epoch; - this.genesis_validators_root = genesis_validators_root; - } - - public GetForkResponse(final ForkInfo forkInfo) { - final Fork fork = forkInfo.getFork(); - if (fork != null) { - this.previous_version = fork.getPreviousVersion(); - this.current_version = fork.getCurrentVersion(); - this.epoch = fork.getEpoch(); - } - genesis_validators_root = forkInfo.getGenesisValidatorsRoot(); - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/EventType.java b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/EventType.java index d32ffbc279d..95e42fff52f 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/EventType.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/EventType.java @@ -32,7 +32,7 @@ public enum EventType { payload_attributes, block_gossip; - public static List getTopics(List topics) { + public static List getTopics(final List topics) { return topics.stream().map(EventType::valueOf).toList(); } } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/HeadEvent.java b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/HeadEvent.java deleted file mode 100644 index 9c41741a91c..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/HeadEvent.java +++ /dev/null @@ -1,103 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.api.response.v1; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonInclude; -import com.fasterxml.jackson.annotation.JsonInclude.Include; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.google.common.base.MoreObjects; -import java.util.Objects; -import org.apache.tuweni.bytes.Bytes32; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; - -@JsonIgnoreProperties(ignoreUnknown = true) -public class HeadEvent { - @JsonProperty(value = "slot", required = true) - public final UInt64 slot; - - @JsonProperty("block") - public final Bytes32 block; - - @JsonProperty("state") - public final Bytes32 state; - - @JsonProperty("epoch_transition") - public final boolean epochTransition; - - @JsonProperty("previous_duty_dependent_root") - @JsonInclude(Include.NON_NULL) - public final Bytes32 previousDutyDependentRoot; - - @JsonProperty("current_duty_dependent_root") - @JsonInclude(Include.NON_NULL) - public final Bytes32 currentDutyDependentRoot; - - @JsonProperty("execution_optimistic") - public final Boolean executionOptimistic; - - @JsonCreator - public HeadEvent( - @JsonProperty(value = "slot", required = true) final UInt64 slot, - @JsonProperty("block") final Bytes32 block, - @JsonProperty("state") final Bytes32 state, - @JsonProperty("epoch_transition") final boolean epochTransition, - @JsonProperty("execution_optimistic") final Boolean executionOptimistic, - @JsonProperty("previous_duty_dependent_root") final Bytes32 previousDutyDependentRoot, - @JsonProperty("current_duty_dependent_root") final Bytes32 currentDutyDependentRoot) { - this.slot = slot; - this.block = block; - this.state = state; - this.epochTransition = epochTransition; - this.previousDutyDependentRoot = previousDutyDependentRoot; - this.currentDutyDependentRoot = currentDutyDependentRoot; - this.executionOptimistic = executionOptimistic; - } - - @Override - public boolean equals(final Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - final HeadEvent headEvent = (HeadEvent) o; - return epochTransition == headEvent.epochTransition - && Objects.equals(slot, headEvent.slot) - && Objects.equals(block, headEvent.block) - && Objects.equals(state, headEvent.state) - && Objects.equals(previousDutyDependentRoot, headEvent.previousDutyDependentRoot) - && Objects.equals(currentDutyDependentRoot, headEvent.currentDutyDependentRoot); - } - - @Override - public int hashCode() { - return Objects.hash( - slot, block, state, epochTransition, previousDutyDependentRoot, currentDutyDependentRoot); - } - - @Override - public String toString() { - return MoreObjects.toStringHelper(this) - .add("slot", slot) - .add("block", block) - .add("state", state) - .add("epochTransition", epochTransition) - .add("previousDutyDependentRoot", previousDutyDependentRoot) - .add("currentDutyDependentRoot", currentDutyDependentRoot) - .toString(); - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/SyncStateChangeEvent.java b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/SyncStateChangeEvent.java deleted file mode 100644 index 07c2d9ec5b9..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/SyncStateChangeEvent.java +++ /dev/null @@ -1,51 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.api.response.v1; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import java.util.Objects; - -@SuppressWarnings("JavaCase") -public class SyncStateChangeEvent { - @JsonProperty("sync_state") - public final String sync_state; - - @JsonCreator - public SyncStateChangeEvent(@JsonProperty("sync_state") final String sync_state) { - this.sync_state = sync_state; - } - - @Override - public boolean equals(Object o) { - if (this == o) { - return true; - } - if (!(o instanceof SyncStateChangeEvent)) { - return false; - } - SyncStateChangeEvent that = (SyncStateChangeEvent) o; - return Objects.equals(sync_state, that.sync_state); - } - - @Override - public int hashCode() { - return Objects.hash(sync_state); - } - - @Override - public String toString() { - return "SyncStateEvent{" + "sync_state='" + sync_state + '\'' + '}'; - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/beacon/EpochCommitteeResponse.java b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/beacon/EpochCommitteeResponse.java index da7f88608b6..0e69dbab747 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/beacon/EpochCommitteeResponse.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/beacon/EpochCommitteeResponse.java @@ -41,10 +41,10 @@ public class EpochCommitteeResponse { @ArraySchema(schema = @Schema(type = "string", example = EXAMPLE_UINT64)) public final List validators; - public EpochCommitteeResponse(CommitteeAssignment committeeAssignment) { - this.slot = committeeAssignment.getSlot(); - this.index = committeeAssignment.getCommitteeIndex(); - this.validators = UInt64Util.intToUInt64List(committeeAssignment.getCommittee()); + public EpochCommitteeResponse(final CommitteeAssignment committeeAssignment) { + this.slot = committeeAssignment.slot(); + this.index = committeeAssignment.committeeIndex(); + this.validators = UInt64Util.intToUInt64List(committeeAssignment.committee()); } @JsonCreator @@ -58,7 +58,7 @@ public EpochCommitteeResponse( } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/beacon/FinalityCheckpointsResponse.java b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/beacon/FinalityCheckpointsResponse.java index 9d053c5653c..5bcc7f6e168 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/beacon/FinalityCheckpointsResponse.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/beacon/FinalityCheckpointsResponse.java @@ -34,15 +34,15 @@ public class FinalityCheckpointsResponse { @JsonCreator public FinalityCheckpointsResponse( - @JsonProperty("previous_justified") Checkpoint previous_justified, - @JsonProperty("current_justified") Checkpoint current_justified, - @JsonProperty("finalized") Checkpoint finalized) { + final @JsonProperty("previous_justified") Checkpoint previous_justified, + final @JsonProperty("current_justified") Checkpoint current_justified, + final @JsonProperty("finalized") Checkpoint finalized) { this.previous_justified = previous_justified; this.current_justified = current_justified; this.finalized = finalized; } - public static FinalityCheckpointsResponse fromState(BeaconState state) { + public static FinalityCheckpointsResponse fromState(final BeaconState state) { if (state.getFinalizedCheckpoint().getEpoch().equals(UInt64.ZERO)) { return new FinalityCheckpointsResponse(Checkpoint.EMPTY, Checkpoint.EMPTY, Checkpoint.EMPTY); } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/beacon/GetAttesterSlashingsResponse.java b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/beacon/GetAttesterSlashingsResponse.java deleted file mode 100644 index 9f8bfaacc32..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/beacon/GetAttesterSlashingsResponse.java +++ /dev/null @@ -1,29 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.api.response.v1.beacon; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import java.util.List; -import tech.pegasys.teku.api.schema.AttesterSlashing; - -public class GetAttesterSlashingsResponse { - @JsonProperty("data") - public final List data; - - @JsonCreator - public GetAttesterSlashingsResponse(@JsonProperty("data") final List data) { - this.data = data; - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/beacon/GetBlockAttestationsResponse.java b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/beacon/GetBlockAttestationsResponse.java deleted file mode 100644 index 850c7fc0814..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/beacon/GetBlockAttestationsResponse.java +++ /dev/null @@ -1,36 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.api.response.v1.beacon; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import java.util.List; -import tech.pegasys.teku.api.schema.Attestation; - -@SuppressWarnings("JavaCase") -public class GetBlockAttestationsResponse { - @JsonProperty("execution_optimistic") - public final boolean execution_optimistic; - - @JsonProperty("data") - public final List data; - - @JsonCreator - public GetBlockAttestationsResponse( - @JsonProperty("execution_optimistic") final boolean executionOptimistic, - @JsonProperty("data") final List data) { - this.execution_optimistic = executionOptimistic; - this.data = data; - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/beacon/GetBlockHeaderResponse.java b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/beacon/GetBlockHeaderResponse.java deleted file mode 100644 index 1f48c7891f3..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/beacon/GetBlockHeaderResponse.java +++ /dev/null @@ -1,34 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.api.response.v1.beacon; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; - -@SuppressWarnings("JavaCase") -public class GetBlockHeaderResponse { - @JsonProperty("execution_optimistic") - public final boolean execution_optimistic; - - @JsonProperty("data") - public final BlockHeader data; - - @JsonCreator - public GetBlockHeaderResponse( - @JsonProperty("execution_optimistic") final boolean executionOptimistic, - @JsonProperty("data") final BlockHeader data) { - this.execution_optimistic = executionOptimistic; - this.data = data; - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/beacon/ValidatorBalanceResponse.java b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/beacon/ValidatorBalanceResponse.java index b0e517b3916..b34114fee6a 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/beacon/ValidatorBalanceResponse.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/beacon/ValidatorBalanceResponse.java @@ -56,7 +56,7 @@ public static Optional fromState( } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/node/Meta.java b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/node/Meta.java index 85aca0cf67c..387f5e61cbd 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/node/Meta.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/node/Meta.java @@ -36,7 +36,7 @@ public String toString() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/node/PeersResponse.java b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/node/PeersResponse.java index 4f22fd47360..b2986458097 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/node/PeersResponse.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/node/PeersResponse.java @@ -30,7 +30,7 @@ public PeersResponse( } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/teku/Eth1VotingSummarySchema.java b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/teku/Eth1VotingSummarySchema.java index 07c11825c91..9427e7c245b 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/teku/Eth1VotingSummarySchema.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/teku/Eth1VotingSummarySchema.java @@ -41,11 +41,11 @@ public class Eth1VotingSummarySchema { @JsonCreator public Eth1VotingSummarySchema( - @JsonProperty("state_eth1_data") Eth1Data stateEth1Data, - @JsonProperty("eth1_data_votes") List eth1DataVotes, - @JsonProperty("votes_required") UInt64 votesRequired, - @JsonProperty("voting_period_slots") UInt64 votingPeriodSlots, - @JsonProperty("voting_period_slots_left") UInt64 votingPeriodSlotsLeft) { + final @JsonProperty("state_eth1_data") Eth1Data stateEth1Data, + final @JsonProperty("eth1_data_votes") List eth1DataVotes, + final @JsonProperty("votes_required") UInt64 votesRequired, + final @JsonProperty("voting_period_slots") UInt64 votingPeriodSlots, + final @JsonProperty("voting_period_slots_left") UInt64 votingPeriodSlotsLeft) { this.stateEth1Data = stateEth1Data; this.eth1DataVotes = eth1DataVotes; this.votesRequired = votesRequired; diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/teku/GetDepositsResponse.java b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/teku/GetDepositsResponse.java index fc5004758b5..24ecfd73609 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/teku/GetDepositsResponse.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/teku/GetDepositsResponse.java @@ -27,7 +27,7 @@ public GetDepositsResponse(@JsonProperty("data") final List da } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/teku/PeerScore.java b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/teku/PeerScore.java index c48be8c29c2..934f15b3bfb 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/teku/PeerScore.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/teku/PeerScore.java @@ -48,7 +48,7 @@ public PeerScore( } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/validator/GetNewBlindedBlockResponse.java b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/validator/GetNewBlindedBlockResponse.java index 274b5f835fc..19a0dc813c6 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/validator/GetNewBlindedBlockResponse.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/validator/GetNewBlindedBlockResponse.java @@ -15,7 +15,6 @@ import tech.pegasys.teku.api.schema.Version; import tech.pegasys.teku.api.schema.interfaces.UnsignedBlindedBlock; -import tech.pegasys.teku.spec.SpecMilestone; public class GetNewBlindedBlockResponse { public final Version version; @@ -25,9 +24,4 @@ public GetNewBlindedBlockResponse(final Version version, final UnsignedBlindedBl this.version = version; this.data = data; } - - public GetNewBlindedBlockResponse( - final SpecMilestone milestone, final UnsignedBlindedBlock data) { - this(Version.fromMilestone(milestone), data); - } } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/validator/GetProposerDutiesResponse.java b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/validator/GetProposerDutiesResponse.java deleted file mode 100644 index df95bd14f74..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/validator/GetProposerDutiesResponse.java +++ /dev/null @@ -1,78 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.api.response.v1.validator; - -import static tech.pegasys.teku.api.schema.SchemaConstants.EXAMPLE_BYTES32; -import static tech.pegasys.teku.api.schema.SchemaConstants.PATTERN_BYTES32; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.google.common.base.MoreObjects; -import io.swagger.v3.oas.annotations.media.Schema; -import java.util.List; -import java.util.Objects; -import org.apache.tuweni.bytes.Bytes32; - -public class GetProposerDutiesResponse { - @JsonProperty("dependent_root") - @Schema( - type = "string", - example = EXAMPLE_BYTES32, - pattern = PATTERN_BYTES32, - description = "The block root that this response is dependent on.") - public final Bytes32 dependentRoot; - - public final List data; - - @JsonProperty("execution_optimistic") - public final boolean executionOptimistic; - - @JsonCreator - public GetProposerDutiesResponse( - @JsonProperty("dependent_root") final Bytes32 dependentRoot, - @JsonProperty("data") final List data, - @JsonProperty("execution_optimistic") final boolean executionOptimistic) { - this.dependentRoot = dependentRoot; - this.data = data; - this.executionOptimistic = executionOptimistic; - } - - @Override - public boolean equals(final Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - final GetProposerDutiesResponse that = (GetProposerDutiesResponse) o; - return executionOptimistic == that.executionOptimistic - && Objects.equals(dependentRoot, that.dependentRoot) - && Objects.equals(data, that.data); - } - - @Override - public int hashCode() { - return Objects.hash(dependentRoot, data, executionOptimistic); - } - - @Override - public String toString() { - return MoreObjects.toStringHelper(this) - .add("dependentRoot", dependentRoot) - .add("data", data) - .add("execution_optimistic", executionOptimistic) - .toString(); - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/validator/GetSyncCommitteeContributionResponse.java b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/validator/GetSyncCommitteeContributionResponse.java deleted file mode 100644 index 3882d7aec1a..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/validator/GetSyncCommitteeContributionResponse.java +++ /dev/null @@ -1,29 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.api.response.v1.validator; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import tech.pegasys.teku.api.schema.altair.SyncCommitteeContribution; - -public class GetSyncCommitteeContributionResponse { - @JsonProperty("data") - public final SyncCommitteeContribution data; - - @JsonCreator - public GetSyncCommitteeContributionResponse( - @JsonProperty("data") final SyncCommitteeContribution data) { - this.data = data; - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/validator/ProposerDuty.java b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/validator/ProposerDuty.java deleted file mode 100644 index 9ab18c55ee0..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/validator/ProposerDuty.java +++ /dev/null @@ -1,78 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.api.response.v1.validator; - -import static tech.pegasys.teku.api.schema.SchemaConstants.EXAMPLE_PUBKEY; -import static tech.pegasys.teku.api.schema.SchemaConstants.EXAMPLE_UINT64; -import static tech.pegasys.teku.api.schema.SchemaConstants.PATTERN_PUBKEY; - -import com.fasterxml.jackson.annotation.JsonProperty; -import io.swagger.v3.oas.annotations.media.Schema; -import java.util.Objects; -import tech.pegasys.teku.api.schema.BLSPubKey; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; - -public class ProposerDuty { - @JsonProperty("pubkey") - @Schema( - type = "string", - pattern = PATTERN_PUBKEY, - example = EXAMPLE_PUBKEY, - description = - "The validator's BLS public key, uniquely identifying them. " - + "48-bytes, hex encoded with 0x prefix, case insensitive.") - public final BLSPubKey pubkey; - - @JsonProperty("validator_index") - @Schema( - type = "string", - example = EXAMPLE_UINT64, - description = "Index of validator in validator registry") - public final UInt64 validatorIndex; - - @JsonProperty("slot") - @Schema( - type = "string", - example = EXAMPLE_UINT64, - description = "The slot at which the validator must propose block.") - public final UInt64 slot; - - public ProposerDuty( - @JsonProperty("pubkey") final BLSPubKey pubkey, - @JsonProperty("validator_index") final int validatorIndex, - @JsonProperty("slot") final UInt64 slot) { - this.pubkey = pubkey; - this.validatorIndex = UInt64.valueOf(validatorIndex); - this.slot = slot; - } - - @Override - public boolean equals(final Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - final ProposerDuty that = (ProposerDuty) o; - return Objects.equals(pubkey, that.pubkey) - && Objects.equals(validatorIndex, that.validatorIndex) - && Objects.equals(slot, that.slot); - } - - @Override - public int hashCode() { - return Objects.hash(pubkey, validatorIndex, slot); - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v2/beacon/GetBlockResponseV2.java b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v2/beacon/GetBlockResponseV2.java index f38fe72704a..62117046994 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v2/beacon/GetBlockResponseV2.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v2/beacon/GetBlockResponseV2.java @@ -23,12 +23,13 @@ import tech.pegasys.teku.api.schema.bellatrix.SignedBeaconBlockBellatrix; import tech.pegasys.teku.api.schema.capella.SignedBeaconBlockCapella; import tech.pegasys.teku.api.schema.deneb.SignedBeaconBlockDeneb; -import tech.pegasys.teku.api.schema.eip7594.SignedBeaconBlockEip7594; +import tech.pegasys.teku.api.schema.electra.SignedBeaconBlockElectra; import tech.pegasys.teku.api.schema.interfaces.SignedBlock; import tech.pegasys.teku.api.schema.phase0.SignedBeaconBlockPhase0; @SuppressWarnings("JavaCase") public class GetBlockResponseV2 { + private final Version version; @JsonProperty("execution_optimistic") @@ -44,7 +45,7 @@ public class GetBlockResponseV2 { @JsonSubTypes.Type(value = SignedBeaconBlockBellatrix.class, name = "bellatrix"), @JsonSubTypes.Type(value = SignedBeaconBlockCapella.class, name = "capella"), @JsonSubTypes.Type(value = SignedBeaconBlockDeneb.class, name = "deneb"), - @JsonSubTypes.Type(value = SignedBeaconBlockEip7594.class, name = "eip7594") + @JsonSubTypes.Type(value = SignedBeaconBlockElectra.class, name = "electra") }) public final SignedBlock data; diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v2/debug/ChainHeadV2.java b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v2/debug/ChainHeadV2.java deleted file mode 100644 index 16509a7a14a..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v2/debug/ChainHeadV2.java +++ /dev/null @@ -1,64 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.api.response.v2.debug; - -import static tech.pegasys.teku.api.schema.SchemaConstants.DESCRIPTION_BYTES32; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import io.swagger.v3.oas.annotations.media.Schema; -import java.util.Objects; -import org.apache.tuweni.bytes.Bytes32; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; - -@SuppressWarnings("JavaCase") -public class ChainHeadV2 { - @Schema(type = "string", format = "uint64") - public final UInt64 slot; - - @Schema(type = "string", format = "byte", description = DESCRIPTION_BYTES32) - public final Bytes32 root; - - @JsonProperty("execution_optimistic") - public final boolean execution_optimistic; - - @JsonCreator - public ChainHeadV2( - @JsonProperty("slot") final UInt64 slot, - @JsonProperty("root") final Bytes32 root, - @JsonProperty("execution_optimistic") final boolean executionOptimistic) { - this.slot = slot; - this.root = root; - this.execution_optimistic = executionOptimistic; - } - - @Override - public boolean equals(final Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - final ChainHeadV2 that = (ChainHeadV2) o; - return execution_optimistic == that.execution_optimistic - && Objects.equals(slot, that.slot) - && Objects.equals(root, that.root); - } - - @Override - public int hashCode() { - return Objects.hash(slot, root, execution_optimistic); - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v2/validator/GetNewBlockResponseV2.java b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v2/validator/GetNewBlockResponseV2.java index ece2a4f1a93..4cf7f043346 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v2/validator/GetNewBlockResponseV2.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/response/v2/validator/GetNewBlockResponseV2.java @@ -15,7 +15,6 @@ import tech.pegasys.teku.api.schema.Version; import tech.pegasys.teku.api.schema.interfaces.UnsignedBlock; -import tech.pegasys.teku.spec.SpecMilestone; public class GetNewBlockResponseV2 { @@ -26,8 +25,4 @@ public GetNewBlockResponseV2(final Version version, final UnsignedBlock data) { this.version = version; this.data = data; } - - public GetNewBlockResponseV2(final SpecMilestone milestone, final UnsignedBlock data) { - this(Version.fromMilestone(milestone), data); - } } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/AggregateAndProof.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/AggregateAndProof.java index 62c89634952..a1478a52b44 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/AggregateAndProof.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/AggregateAndProof.java @@ -44,7 +44,7 @@ public AggregateAndProof( } public AggregateAndProof( - tech.pegasys.teku.spec.datastructures.operations.AggregateAndProof aggregateAndProof) { + final tech.pegasys.teku.spec.datastructures.operations.AggregateAndProof aggregateAndProof) { aggregator_index = aggregateAndProof.getIndex(); aggregate = new Attestation(aggregateAndProof.getAggregate()); selection_proof = new BLSSignature(aggregateAndProof.getSelectionProof()); diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Attestation.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Attestation.java index f5f85d1666d..0741720a7a0 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Attestation.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Attestation.java @@ -17,13 +17,18 @@ import static tech.pegasys.teku.api.schema.SchemaConstants.DESCRIPTION_BYTES_SSZ; import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonInclude.Include; import com.fasterxml.jackson.annotation.JsonProperty; import io.swagger.v3.oas.annotations.media.Schema; import java.util.Objects; +import java.util.function.Supplier; import org.apache.tuweni.bytes.Bytes; +import tech.pegasys.teku.infrastructure.ssz.SszData; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecVersion; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; @SuppressWarnings("JavaCase") public class Attestation { @@ -32,12 +37,18 @@ public class Attestation { public final AttestationData data; + @JsonInclude(Include.NON_NULL) + @Schema(type = "string", format = "byte", description = DESCRIPTION_BYTES_SSZ) + public final Bytes committee_bits; + @Schema(type = "string", format = "byte", description = DESCRIPTION_BYTES96) public final BLSSignature signature; - public Attestation(tech.pegasys.teku.spec.datastructures.operations.Attestation attestation) { + public Attestation( + final tech.pegasys.teku.spec.datastructures.operations.Attestation attestation) { this.aggregation_bits = attestation.getAggregationBits().sszSerialize(); this.data = new AttestationData(attestation.getData()); + this.committee_bits = attestation.getCommitteeBits().map(SszData::sszSerialize).orElse(null); this.signature = new BLSSignature(attestation.getAggregateSignature()); } @@ -45,9 +56,11 @@ public Attestation(tech.pegasys.teku.spec.datastructures.operations.Attestation public Attestation( @JsonProperty("aggregation_bits") final Bytes aggregation_bits, @JsonProperty("data") final AttestationData data, + @JsonProperty("committee_bits") final Bytes committee_bits, @JsonProperty("signature") final BLSSignature signature) { this.aggregation_bits = aggregation_bits; this.data = data; + this.committee_bits = committee_bits; this.signature = signature; } @@ -58,16 +71,22 @@ public tech.pegasys.teku.spec.datastructures.operations.Attestation asInternalAt public tech.pegasys.teku.spec.datastructures.operations.Attestation asInternalAttestation( final SpecVersion specVersion) { - final AttestationSchema attestationSchema = + final AttestationSchema attestationSchema = specVersion.getSchemaDefinitions().getAttestationSchema(); return attestationSchema.create( attestationSchema.getAggregationBitsSchema().sszDeserialize(aggregation_bits), data.asInternalAttestationData(), - signature.asInternalBLSSignature()); + signature.asInternalBLSSignature(), + attestationSchema + .getCommitteeBitsSchema() + .map( + committeeBits -> + (Supplier) () -> committeeBits.sszDeserialize(committee_bits)) + .orElse(() -> null)); } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } @@ -77,11 +96,12 @@ public boolean equals(Object o) { Attestation that = (Attestation) o; return Objects.equals(aggregation_bits, that.aggregation_bits) && Objects.equals(data, that.data) + && Objects.equals(committee_bits, that.committee_bits) && Objects.equals(signature, that.signature); } @Override public int hashCode() { - return Objects.hash(aggregation_bits, data, signature); + return Objects.hash(aggregation_bits, data, committee_bits, signature); } } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/AttestationData.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/AttestationData.java index e5e79a382fe..2bf78f192e5 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/AttestationData.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/AttestationData.java @@ -50,7 +50,8 @@ public AttestationData( this.target = target; } - public AttestationData(tech.pegasys.teku.spec.datastructures.operations.AttestationData data) { + public AttestationData( + final tech.pegasys.teku.spec.datastructures.operations.AttestationData data) { this.slot = data.getSlot(); this.index = data.getIndex(); this.beacon_block_root = data.getBeaconBlockRoot(); @@ -68,7 +69,7 @@ public AttestationData(tech.pegasys.teku.spec.datastructures.operations.Attestat } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/AttesterSlashing.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/AttesterSlashing.java index 69e7a9cb208..77e11250a18 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/AttesterSlashing.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/AttesterSlashing.java @@ -18,7 +18,7 @@ import java.util.Objects; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecVersion; -import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing.AttesterSlashingSchema; +import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashingSchema; @SuppressWarnings("JavaCase") public class AttesterSlashing { @@ -26,7 +26,7 @@ public class AttesterSlashing { public final IndexedAttestation attestation_2; public AttesterSlashing( - tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing attesterSlashing) { + final tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing attesterSlashing) { this.attestation_1 = new IndexedAttestation(attesterSlashing.getAttestation1()); this.attestation_2 = new IndexedAttestation(attesterSlashing.getAttestation2()); } @@ -54,14 +54,13 @@ public AttesterSlashing( } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } - if (!(o instanceof AttesterSlashing)) { + if (!(o instanceof AttesterSlashing that)) { return false; } - AttesterSlashing that = (AttesterSlashing) o; return Objects.equals(attestation_1, that.attestation_1) && Objects.equals(attestation_2, that.attestation_2); } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/BLSPubKey.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/BLSPubKey.java index 081cf0fd049..e054d7b0f5a 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/BLSPubKey.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/BLSPubKey.java @@ -27,7 +27,7 @@ public class BLSPubKey { private final Bytes bytes; - public BLSPubKey(Bytes bytes) { + public BLSPubKey(final Bytes bytes) { checkArgument( bytes.size() == SIZE, "Bytes%s should be %s bytes, but was %s bytes.", @@ -37,7 +37,7 @@ public BLSPubKey(Bytes bytes) { this.bytes = bytes; } - public BLSPubKey(BLSPublicKey publicKey) { + public BLSPubKey(final BLSPublicKey publicKey) { this(publicKey.toSSZBytes()); } @@ -63,7 +63,7 @@ public String toString() { return bytes.toString(); } - public static BLSPubKey fromHexString(String value) { + public static BLSPubKey fromHexString(final String value) { try { return new BLSPubKey(BLSPublicKey.fromBytesCompressedValidate(Bytes48.fromHexString(value))); } catch (IllegalArgumentException e) { diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/BLSSignature.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/BLSSignature.java index 0f70a1fe1b6..43c73d4c897 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/BLSSignature.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/BLSSignature.java @@ -25,7 +25,7 @@ public class BLSSignature { private final Bytes bytes; - public BLSSignature(Bytes bytes) { + public BLSSignature(final Bytes bytes) { checkArgument( bytes.size() == SIZE, "Bytes%s should be %s bytes, but was %s bytes.", @@ -35,7 +35,7 @@ public BLSSignature(Bytes bytes) { this.bytes = bytes; } - public BLSSignature(tech.pegasys.teku.bls.BLSSignature signature) { + public BLSSignature(final tech.pegasys.teku.bls.BLSSignature signature) { this(signature.toBytesCompressed()); } @@ -61,7 +61,7 @@ public String toString() { return bytes.toString(); } - public static BLSSignature fromHexString(String value) { + public static BLSSignature fromHexString(final String value) { return new BLSSignature(Bytes.fromHexString(value)); } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/BeaconBlock.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/BeaconBlock.java index 863d59d0a4d..0d81b1ed0f4 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/BeaconBlock.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/BeaconBlock.java @@ -47,7 +47,7 @@ public BeaconBlockBody getBody() { return body; } - protected BeaconBlock(tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock message) { + protected BeaconBlock(final tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock message) { this.slot = message.getSlot(); this.proposer_index = message.getProposerIndex(); this.parent_root = message.getParentRoot(); @@ -86,7 +86,7 @@ public tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock asInternalBeacon } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/BeaconBlockBody.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/BeaconBlockBody.java index 47c37027290..b5272c33d49 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/BeaconBlockBody.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/BeaconBlockBody.java @@ -66,7 +66,7 @@ public BeaconBlockBody( } public BeaconBlockBody( - tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody body) { + final tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody body) { this.randao_reveal = new BLSSignature(body.getRandaoReveal().toSSZBytes()); this.eth1_data = new Eth1Data(body.getEth1Data()); this.graffiti = body.getGraffiti(); @@ -137,7 +137,7 @@ public BeaconBlockBodySchema getBeaconBlockBodySchema(final SpecVersion spec) } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Checkpoint.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Checkpoint.java index 96e663d3fc6..3b5a2fbcb0e 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Checkpoint.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Checkpoint.java @@ -32,7 +32,7 @@ public class Checkpoint { @Schema(type = "string", format = "byte", description = DESCRIPTION_BYTES32) public final Bytes32 root; - public Checkpoint(tech.pegasys.teku.spec.datastructures.state.Checkpoint checkpoint) { + public Checkpoint(final tech.pegasys.teku.spec.datastructures.state.Checkpoint checkpoint) { this.epoch = checkpoint.getEpoch(); this.root = checkpoint.getRoot(); } @@ -49,7 +49,7 @@ public tech.pegasys.teku.spec.datastructures.state.Checkpoint asInternalCheckpoi } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Committee.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Committee.java deleted file mode 100644 index a2584258ff5..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Committee.java +++ /dev/null @@ -1,47 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.api.schema; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import io.swagger.v3.oas.annotations.media.Schema; -import java.util.List; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.datastructures.state.CommitteeAssignment; - -public class Committee { - @Schema(type = "string", format = "uint64") - public final UInt64 slot; - - @Schema(type = "string", format = "uint64") - public final UInt64 index; - - public final List committee; - - public Committee(CommitteeAssignment committeeAssignment) { - this.slot = committeeAssignment.getSlot(); - this.index = committeeAssignment.getCommitteeIndex(); - this.committee = committeeAssignment.getCommittee(); - } - - @JsonCreator - public Committee( - @JsonProperty("slot") final UInt64 slot, - @JsonProperty("index") final UInt64 index, - @JsonProperty("committee") final List committee) { - this.slot = slot; - this.index = index; - this.committee = committee; - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Deposit.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Deposit.java index fa90311f884..8dc0d6cf26b 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Deposit.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Deposit.java @@ -30,7 +30,7 @@ public class Deposit { public final DepositData data; - public Deposit(tech.pegasys.teku.spec.datastructures.operations.Deposit deposit) { + public Deposit(final tech.pegasys.teku.spec.datastructures.operations.Deposit deposit) { this.proof = deposit.getProof().streamUnboxed().toList(); this.data = new DepositData(deposit.getData()); } @@ -52,7 +52,7 @@ public tech.pegasys.teku.spec.datastructures.operations.Deposit asInternalDeposi } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/DepositData.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/DepositData.java index b2157099834..5cf7027215b 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/DepositData.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/DepositData.java @@ -38,7 +38,8 @@ public class DepositData { @Schema(type = "string", format = "byte", description = DESCRIPTION_BYTES96) public final BLSSignature signature; - public DepositData(tech.pegasys.teku.spec.datastructures.operations.DepositData depositData) { + public DepositData( + final tech.pegasys.teku.spec.datastructures.operations.DepositData depositData) { this.pubkey = new BLSPubKey(depositData.getPubkey().toSSZBytes()); this.withdrawal_credentials = depositData.getWithdrawalCredentials(); this.amount = depositData.getAmount(); @@ -65,7 +66,7 @@ public tech.pegasys.teku.spec.datastructures.operations.DepositData asInternalDe } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Eth1Data.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Eth1Data.java index 0fbe6198bf4..5e4536b83a3 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Eth1Data.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Eth1Data.java @@ -55,7 +55,7 @@ public tech.pegasys.teku.spec.datastructures.blocks.Eth1Data asInternalEth1Data( } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/ExecutionPayload.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/ExecutionPayload.java index cca9d4fd57e..cfaa0b823df 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/ExecutionPayload.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/ExecutionPayload.java @@ -17,7 +17,6 @@ import tech.pegasys.teku.api.schema.bellatrix.ExecutionPayloadBellatrix; import tech.pegasys.teku.api.schema.capella.ExecutionPayloadCapella; import tech.pegasys.teku.api.schema.deneb.ExecutionPayloadDeneb; -import tech.pegasys.teku.api.schema.eip7594.ExecutionPayloadEip7594; public interface ExecutionPayload { @@ -32,8 +31,4 @@ default Optional toVersionCapella() { default Optional toVersionDeneb() { return Optional.empty(); } - - default Optional toVersionEip7594() { - return Optional.empty(); - } } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/ExecutionPayloadHeader.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/ExecutionPayloadHeader.java index eceed5f78b6..592f930abac 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/ExecutionPayloadHeader.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/ExecutionPayloadHeader.java @@ -17,7 +17,6 @@ import tech.pegasys.teku.api.schema.bellatrix.ExecutionPayloadHeaderBellatrix; import tech.pegasys.teku.api.schema.capella.ExecutionPayloadHeaderCapella; import tech.pegasys.teku.api.schema.deneb.ExecutionPayloadHeaderDeneb; -import tech.pegasys.teku.api.schema.eip7594.ExecutionPayloadHeaderEip7594; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeaderSchema; public interface ExecutionPayloadHeader { @@ -35,8 +34,4 @@ default Optional toVersionCapella() { default Optional toVersionDeneb() { return Optional.empty(); } - - default Optional toVersionEip7594() { - return Optional.empty(); - } } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/IndexedAttestation.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/IndexedAttestation.java index 575ede2072b..0adcad6b9c5 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/IndexedAttestation.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/IndexedAttestation.java @@ -24,7 +24,7 @@ import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecVersion; -import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestation.IndexedAttestationSchema; +import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestationSchema; @SuppressWarnings("JavaCase") public class IndexedAttestation { @@ -37,7 +37,8 @@ public class IndexedAttestation { public final BLSSignature signature; public IndexedAttestation( - tech.pegasys.teku.spec.datastructures.operations.IndexedAttestation indexedAttestation) { + final tech.pegasys.teku.spec.datastructures.operations.IndexedAttestation + indexedAttestation) { this.attesting_indices = indexedAttestation.getAttestingIndices().streamUnboxed().toList(); this.data = new AttestationData(indexedAttestation.getData()); this.signature = new BLSSignature(indexedAttestation.getSignature()); @@ -69,14 +70,13 @@ public IndexedAttestation( } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } - if (!(o instanceof IndexedAttestation)) { + if (!(o instanceof IndexedAttestation that)) { return false; } - IndexedAttestation that = (IndexedAttestation) o; return Objects.equals(attesting_indices, that.attesting_indices) && Objects.equals(data, that.data) && Objects.equals(signature, that.signature); diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/PendingAttestation.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/PendingAttestation.java index fb7aa7e1f2e..e96a1c45c7f 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/PendingAttestation.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/PendingAttestation.java @@ -66,7 +66,7 @@ public PendingAttestation( } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/ProposerSlashing.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/ProposerSlashing.java index a490e0aa0ef..7ee8dc06c23 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/ProposerSlashing.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/ProposerSlashing.java @@ -23,7 +23,7 @@ public class ProposerSlashing { public final SignedBeaconBlockHeader signed_header_2; public ProposerSlashing( - tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing proposerSlashing) { + final tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing proposerSlashing) { signed_header_1 = new SignedBeaconBlockHeader(proposerSlashing.getHeader1()); signed_header_2 = new SignedBeaconBlockHeader(proposerSlashing.getHeader2()); } @@ -44,7 +44,7 @@ public ProposerSlashing( } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/PublicKeyException.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/PublicKeyException.java index d8c46566152..e6fc1ee6da4 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/PublicKeyException.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/PublicKeyException.java @@ -15,11 +15,11 @@ public class PublicKeyException extends RuntimeException { - public PublicKeyException(String message, Throwable cause) { + public PublicKeyException(final String message, final Throwable cause) { super(message, cause); } - public PublicKeyException(String err) { + public PublicKeyException(final String err) { super(err); } } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Root.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Root.java index b2c14d91784..e66f00027a8 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Root.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Root.java @@ -31,7 +31,7 @@ public Root(@JsonProperty("root") final Bytes32 root) { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/SignedBeaconBlock.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/SignedBeaconBlock.java index 1692893cc93..d88ff3a8b2b 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/SignedBeaconBlock.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/SignedBeaconBlock.java @@ -29,8 +29,8 @@ import tech.pegasys.teku.api.schema.capella.SignedBlindedBeaconBlockCapella; import tech.pegasys.teku.api.schema.deneb.SignedBeaconBlockDeneb; import tech.pegasys.teku.api.schema.deneb.SignedBlindedBeaconBlockDeneb; -import tech.pegasys.teku.api.schema.eip7594.SignedBeaconBlockEip7594; -import tech.pegasys.teku.api.schema.eip7594.SignedBlindedBeaconBlockEip7594; +import tech.pegasys.teku.api.schema.electra.SignedBeaconBlockElectra; +import tech.pegasys.teku.api.schema.electra.SignedBlindedBeaconBlockElectra; import tech.pegasys.teku.api.schema.interfaces.SignedBlock; import tech.pegasys.teku.api.schema.phase0.SignedBeaconBlockPhase0; import tech.pegasys.teku.spec.Spec; @@ -46,7 +46,7 @@ public BeaconBlock getMessage() { } protected SignedBeaconBlock( - tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock internalBlock) { + final tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock internalBlock) { this.signature = new BLSSignature(internalBlock.getSignature()); this.message = new BeaconBlock(internalBlock.getMessage()); } @@ -60,19 +60,19 @@ public SignedBeaconBlock( } public static SignedBeaconBlock create( - tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock internalBlock) { + final tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock internalBlock) { tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody beaconBlock = internalBlock.getMessage().getBody(); return Stream.of( () -> beaconBlock - .toBlindedVersionEip7594() - .map(__ -> new SignedBlindedBeaconBlockEip7594(internalBlock)), + .toBlindedVersionElectra() + .map(__ -> new SignedBlindedBeaconBlockElectra(internalBlock)), () -> beaconBlock - .toVersionEip7594() - .map(__ -> new SignedBeaconBlockEip7594(internalBlock)), + .toVersionElectra() + .map(__ -> new SignedBeaconBlockElectra(internalBlock)), () -> beaconBlock .toBlindedVersionDeneb() @@ -113,7 +113,7 @@ public tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock asInternal } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/SignedBeaconBlockHeader.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/SignedBeaconBlockHeader.java index e49ba7c58e5..a29572e2e16 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/SignedBeaconBlockHeader.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/SignedBeaconBlockHeader.java @@ -28,7 +28,7 @@ public class SignedBeaconBlockHeader { public final BLSSignature signature; public SignedBeaconBlockHeader( - tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockHeader signedHeader) { + final tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockHeader signedHeader) { this.message = new BeaconBlockHeader(signedHeader.getMessage()); this.signature = new BLSSignature(signedHeader.getSignature()); } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/SignedVoluntaryExit.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/SignedVoluntaryExit.java index 8844950222b..89f1ab3757b 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/SignedVoluntaryExit.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/SignedVoluntaryExit.java @@ -26,7 +26,8 @@ public class SignedVoluntaryExit { public final BLSSignature signature; public SignedVoluntaryExit( - tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit signedVoluntaryExit) { + final tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit + signedVoluntaryExit) { this.signature = new BLSSignature(signedVoluntaryExit.getSignature()); this.message = new VoluntaryExit(signedVoluntaryExit.getMessage()); } @@ -52,7 +53,7 @@ public SignedVoluntaryExit( } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/SyncStatus.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/SyncStatus.java deleted file mode 100644 index 492588ec71f..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/SyncStatus.java +++ /dev/null @@ -1,34 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.api.schema; - -import io.swagger.v3.oas.annotations.media.Schema; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; - -public class SyncStatus { - @Schema(type = "string", format = "uint64") - public final UInt64 startingSlot; - - @Schema(type = "string", format = "uint64") - public final UInt64 currentSlot; - - @Schema(type = "string", format = "uint64") - public final UInt64 highestSlot; - - public SyncStatus(final UInt64 startingSlot, final UInt64 currentSlot, final UInt64 highestSlot) { - this.startingSlot = startingSlot; - this.currentSlot = currentSlot; - this.highestSlot = highestSlot; - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Version.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Version.java index d5ab6453b17..5796ecd5227 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Version.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/Version.java @@ -22,7 +22,7 @@ public enum Version { bellatrix, capella, deneb, - eip7594; + electra; public static Version fromMilestone(final SpecMilestone milestone) { return switch (milestone) { @@ -31,8 +31,9 @@ public static Version fromMilestone(final SpecMilestone milestone) { case BELLATRIX -> bellatrix; case CAPELLA -> capella; case DENEB -> deneb; - // FIXME: hack for devnet - case EIP7594 -> deneb; + case ELECTRA -> electra; + // TODO: when it's compatible with Dora switch to fulu + case FULU -> electra; }; } } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/VoluntaryExit.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/VoluntaryExit.java index 1f0d9ff61e1..c3835fad2d5 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/VoluntaryExit.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/VoluntaryExit.java @@ -28,7 +28,7 @@ public class VoluntaryExit { public final UInt64 validator_index; public VoluntaryExit( - tech.pegasys.teku.spec.datastructures.operations.VoluntaryExit voluntaryExit) { + final tech.pegasys.teku.spec.datastructures.operations.VoluntaryExit voluntaryExit) { this.epoch = voluntaryExit.getEpoch(); this.validator_index = voluntaryExit.getValidatorIndex(); } @@ -47,7 +47,7 @@ public tech.pegasys.teku.spec.datastructures.operations.VoluntaryExit asInternal } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/altair/BeaconBlockAltair.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/altair/BeaconBlockAltair.java index 575a6f17dc4..f7b5c30fa5f 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/altair/BeaconBlockAltair.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/altair/BeaconBlockAltair.java @@ -26,7 +26,7 @@ @SuppressWarnings("JavaCase") public class BeaconBlockAltair extends BeaconBlock implements UnsignedBlock { - public BeaconBlockAltair(tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock message) { + public BeaconBlockAltair(final tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock message) { super( message.getSlot(), message.getProposerIndex(), diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/altair/BeaconStateAltair.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/altair/BeaconStateAltair.java index 9bee03ac534..dc4081977fd 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/altair/BeaconStateAltair.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/altair/BeaconStateAltair.java @@ -137,9 +137,9 @@ protected void applyAdditionalFields( } public static void applyAltairFields( - MutableBeaconStateAltair state, - SyncCommitteeSchema syncCommitteeSchema, - BeaconStateAltair instance) { + final MutableBeaconStateAltair state, + final SyncCommitteeSchema syncCommitteeSchema, + final BeaconStateAltair instance) { final SszList previousEpochParticipation = state .getPreviousEpochParticipation() diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/altair/ContributionAndProof.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/altair/ContributionAndProof.java index 74d4281b248..befcfba67e3 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/altair/ContributionAndProof.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/altair/ContributionAndProof.java @@ -45,7 +45,7 @@ public ContributionAndProof( } public ContributionAndProof( - tech.pegasys.teku.spec.datastructures.operations.versions.altair.ContributionAndProof + final tech.pegasys.teku.spec.datastructures.operations.versions.altair.ContributionAndProof contributionAndProof) { this( contributionAndProof.getAggregatorIndex(), diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/altair/SignedBeaconBlockAltair.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/altair/SignedBeaconBlockAltair.java index c6d44574220..2a942b55a18 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/altair/SignedBeaconBlockAltair.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/altair/SignedBeaconBlockAltair.java @@ -23,7 +23,7 @@ public class SignedBeaconBlockAltair extends SignedBeaconBlock implements Signed private final BeaconBlockAltair message; public SignedBeaconBlockAltair( - tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock internalBlock) { + final tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock internalBlock) { super(internalBlock); this.message = new BeaconBlockAltair(internalBlock.getMessage()); } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/altair/SyncCommittee.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/altair/SyncCommittee.java index c0cd0e4603c..848f44e3861 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/altair/SyncCommittee.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/altair/SyncCommittee.java @@ -60,7 +60,7 @@ public tech.pegasys.teku.spec.datastructures.state.SyncCommittee asInternalSyncC } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/BeaconBlockBellatrix.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/BeaconBlockBellatrix.java index 95878930d23..9c0a27165a3 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/BeaconBlockBellatrix.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/BeaconBlockBellatrix.java @@ -25,7 +25,7 @@ public class BeaconBlockBellatrix extends BeaconBlockAltair { - public BeaconBlockBellatrix(BeaconBlock message) { + public BeaconBlockBellatrix(final BeaconBlock message) { super( message.getSlot(), message.getProposerIndex(), @@ -35,7 +35,7 @@ public BeaconBlockBellatrix(BeaconBlock message) { } @Override - public BeaconBlock asInternalBeaconBlock(Spec spec) { + public BeaconBlock asInternalBeaconBlock(final Spec spec) { final SpecVersion specVersion = spec.atSlot(slot); return SchemaDefinitionsBellatrix.required(specVersion.getSchemaDefinitions()) .getBeaconBlockSchema() diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/BeaconBlockBodyBellatrix.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/BeaconBlockBodyBellatrix.java index 51ce5da3c95..376850fd7bb 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/BeaconBlockBodyBellatrix.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/BeaconBlockBodyBellatrix.java @@ -66,7 +66,7 @@ public BeaconBlockBodyBellatrix( } public BeaconBlockBodyBellatrix( - tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.bellatrix + final tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.bellatrix .BeaconBlockBodyBellatrix message) { super(message); diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/BeaconPreparableProposer.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/BeaconPreparableProposer.java index becf4aecc0c..087ca3fd09e 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/BeaconPreparableProposer.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/BeaconPreparableProposer.java @@ -40,8 +40,8 @@ public class BeaconPreparableProposer { @JsonCreator public BeaconPreparableProposer( - @JsonProperty("validator_index") UInt64 validator_index, - @JsonProperty("fee_recipient") Eth1Address fee_recipient) { + final @JsonProperty("validator_index") UInt64 validator_index, + final @JsonProperty("fee_recipient") Eth1Address fee_recipient) { this.validator_index = validator_index; this.fee_recipient = fee_recipient; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/BeaconStateBellatrix.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/BeaconStateBellatrix.java index c38c9d5017e..eb09c3df862 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/BeaconStateBellatrix.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/BeaconStateBellatrix.java @@ -97,7 +97,8 @@ public BeaconStateBellatrix( } @Override - protected void applyAdditionalFields(MutableBeaconState state, final SpecVersion specVersion) { + protected void applyAdditionalFields( + final MutableBeaconState state, final SpecVersion specVersion) { state .toMutableVersionBellatrix() .ifPresent( @@ -112,10 +113,10 @@ protected void applyAdditionalFields(MutableBeaconState state, final SpecVersion } public static void applyBellatrixFields( - MutableBeaconStateBellatrix state, - SyncCommitteeSchema syncCommitteeSchema, - ExecutionPayloadHeaderSchemaBellatrix executionPayloadHeaderSchema, - BeaconStateBellatrix instance) { + final MutableBeaconStateBellatrix state, + final SyncCommitteeSchema syncCommitteeSchema, + final ExecutionPayloadHeaderSchemaBellatrix executionPayloadHeaderSchema, + final BeaconStateBellatrix instance) { BeaconStateAltair.applyAltairFields(state, syncCommitteeSchema, instance); state.setLatestExecutionPayloadHeader( @@ -123,7 +124,7 @@ public static void applyBellatrixFields( executionPayloadHeaderSchema)); } - public BeaconStateBellatrix(BeaconState beaconState) { + public BeaconStateBellatrix(final BeaconState beaconState) { super(beaconState); final tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.bellatrix .BeaconStateBellatrix @@ -133,7 +134,7 @@ public BeaconStateBellatrix(BeaconState beaconState) { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/BlindedBlockBellatrix.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/BlindedBlockBellatrix.java index 62ff9050160..dbe25c9e573 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/BlindedBlockBellatrix.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/BlindedBlockBellatrix.java @@ -25,7 +25,7 @@ public class BlindedBlockBellatrix extends BeaconBlockAltair { - public BlindedBlockBellatrix(BeaconBlock message) { + public BlindedBlockBellatrix(final BeaconBlock message) { super( message.getSlot(), message.getProposerIndex(), @@ -41,7 +41,7 @@ public BeaconBlockSchema getBeaconBlockSchema(final SpecVersion spec) { } @Override - public BeaconBlock asInternalBeaconBlock(Spec spec) { + public BeaconBlock asInternalBeaconBlock(final Spec spec) { final SpecVersion specVersion = spec.atSlot(slot); return getBeaconBlockSchema(specVersion) .create( diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/ExecutionPayloadBellatrix.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/ExecutionPayloadBellatrix.java index c1ede836076..c28e1bf3279 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/ExecutionPayloadBellatrix.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/ExecutionPayloadBellatrix.java @@ -42,20 +42,20 @@ public class ExecutionPayloadBellatrix extends ExecutionPayloadCommon implements @JsonCreator public ExecutionPayloadBellatrix( - @JsonProperty("parent_hash") Bytes32 parentHash, - @JsonProperty("fee_recipient") Bytes20 feeRecipient, - @JsonProperty("state_root") Bytes32 stateRoot, - @JsonProperty("receipts_root") Bytes32 receiptsRoot, - @JsonProperty("logs_bloom") Bytes logsBloom, - @JsonProperty("prev_randao") Bytes32 prevRandao, - @JsonProperty("block_number") UInt64 blockNumber, - @JsonProperty("gas_limit") UInt64 gasLimit, - @JsonProperty("gas_used") UInt64 gasUsed, - @JsonProperty("timestamp") UInt64 timestamp, - @JsonProperty("extra_data") Bytes extraData, - @JsonProperty("base_fee_per_gas") UInt256 baseFeePerGas, - @JsonProperty("block_hash") Bytes32 blockHash, - @JsonProperty("transactions") List transactions) { + final @JsonProperty("parent_hash") Bytes32 parentHash, + final @JsonProperty("fee_recipient") Bytes20 feeRecipient, + final @JsonProperty("state_root") Bytes32 stateRoot, + final @JsonProperty("receipts_root") Bytes32 receiptsRoot, + final @JsonProperty("logs_bloom") Bytes logsBloom, + final @JsonProperty("prev_randao") Bytes32 prevRandao, + final @JsonProperty("block_number") UInt64 blockNumber, + final @JsonProperty("gas_limit") UInt64 gasLimit, + final @JsonProperty("gas_used") UInt64 gasUsed, + final @JsonProperty("timestamp") UInt64 timestamp, + final @JsonProperty("extra_data") Bytes extraData, + final @JsonProperty("base_fee_per_gas") UInt256 baseFeePerGas, + final @JsonProperty("block_hash") Bytes32 blockHash, + final @JsonProperty("transactions") List transactions) { super( parentHash, feeRecipient, @@ -74,7 +74,7 @@ public ExecutionPayloadBellatrix( } public ExecutionPayloadBellatrix( - tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload executionPayload) { + final tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload executionPayload) { super( executionPayload.getParentHash(), executionPayload.getFeeRecipient(), diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/ExecutionPayloadCommon.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/ExecutionPayloadCommon.java index 809434f8aa5..8ba86de11b9 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/ExecutionPayloadCommon.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/ExecutionPayloadCommon.java @@ -106,19 +106,19 @@ public abstract class ExecutionPayloadCommon { public final Bytes32 blockHash; public ExecutionPayloadCommon( - @JsonProperty("parent_hash") Bytes32 parentHash, - @JsonProperty("fee_recipient") Bytes20 feeRecipient, - @JsonProperty("state_root") Bytes32 stateRoot, - @JsonProperty("receipts_root") Bytes32 receiptsRoot, - @JsonProperty("logs_bloom") Bytes logsBloom, - @JsonProperty("prev_randao") Bytes32 prevRandao, - @JsonProperty("block_number") UInt64 blockNumber, - @JsonProperty("gas_limit") UInt64 gasLimit, - @JsonProperty("gas_used") UInt64 gasUsed, - @JsonProperty("timestamp") UInt64 timestamp, - @JsonProperty("extra_data") Bytes extraData, - @JsonProperty("base_fee_per_gas") UInt256 baseFeePerGas, - @JsonProperty("block_hash") Bytes32 blockHash) { + final @JsonProperty("parent_hash") Bytes32 parentHash, + final @JsonProperty("fee_recipient") Bytes20 feeRecipient, + final @JsonProperty("state_root") Bytes32 stateRoot, + final @JsonProperty("receipts_root") Bytes32 receiptsRoot, + final @JsonProperty("logs_bloom") Bytes logsBloom, + final @JsonProperty("prev_randao") Bytes32 prevRandao, + final @JsonProperty("block_number") UInt64 blockNumber, + final @JsonProperty("gas_limit") UInt64 gasLimit, + final @JsonProperty("gas_used") UInt64 gasUsed, + final @JsonProperty("timestamp") UInt64 timestamp, + final @JsonProperty("extra_data") Bytes extraData, + final @JsonProperty("base_fee_per_gas") UInt256 baseFeePerGas, + final @JsonProperty("block_hash") Bytes32 blockHash) { this.parentHash = parentHash; this.feeRecipient = feeRecipient; this.stateRoot = stateRoot; diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/ExecutionPayloadHeaderBellatrix.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/ExecutionPayloadHeaderBellatrix.java index 28e2539cd4d..57d3a134b5c 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/ExecutionPayloadHeaderBellatrix.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/ExecutionPayloadHeaderBellatrix.java @@ -39,20 +39,20 @@ public class ExecutionPayloadHeaderBellatrix extends ExecutionPayloadCommon @JsonCreator public ExecutionPayloadHeaderBellatrix( - @JsonProperty("parent_hash") Bytes32 parentHash, - @JsonProperty("fee_recipient") Bytes20 feeRecipient, - @JsonProperty("state_root") Bytes32 stateRoot, - @JsonProperty("receipts_root") Bytes32 receiptsRoot, - @JsonProperty("logs_bloom") Bytes logsBloom, - @JsonProperty("prev_randao") Bytes32 prevRandao, - @JsonProperty("block_number") UInt64 blockNumber, - @JsonProperty("gas_limit") UInt64 gasLimit, - @JsonProperty("gas_used") UInt64 gasUsed, - @JsonProperty("timestamp") UInt64 timestamp, - @JsonProperty("extra_data") Bytes extraData, - @JsonProperty("base_fee_per_gas") UInt256 baseFeePerGas, - @JsonProperty("block_hash") Bytes32 blockHash, - @JsonProperty("transactions_root") Bytes32 transactionsRoot) { + final @JsonProperty("parent_hash") Bytes32 parentHash, + final @JsonProperty("fee_recipient") Bytes20 feeRecipient, + final @JsonProperty("state_root") Bytes32 stateRoot, + final @JsonProperty("receipts_root") Bytes32 receiptsRoot, + final @JsonProperty("logs_bloom") Bytes logsBloom, + final @JsonProperty("prev_randao") Bytes32 prevRandao, + final @JsonProperty("block_number") UInt64 blockNumber, + final @JsonProperty("gas_limit") UInt64 gasLimit, + final @JsonProperty("gas_used") UInt64 gasUsed, + final @JsonProperty("timestamp") UInt64 timestamp, + final @JsonProperty("extra_data") Bytes extraData, + final @JsonProperty("base_fee_per_gas") UInt256 baseFeePerGas, + final @JsonProperty("block_hash") Bytes32 blockHash, + final @JsonProperty("transactions_root") Bytes32 transactionsRoot) { super( parentHash, feeRecipient, @@ -71,7 +71,7 @@ public ExecutionPayloadHeaderBellatrix( } public ExecutionPayloadHeaderBellatrix( - tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader + final tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader executionPayloadHeader) { super( executionPayloadHeader.getParentHash(), @@ -90,7 +90,7 @@ public ExecutionPayloadHeaderBellatrix( this.transactionsRoot = executionPayloadHeader.getTransactionsRoot(); } - public ExecutionPayloadHeaderBellatrix(ExecutionPayload executionPayload) { + public ExecutionPayloadHeaderBellatrix(final ExecutionPayload executionPayload) { super( executionPayload.getParentHash(), executionPayload.getFeeRecipient(), diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/SignedBeaconBlockBellatrix.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/SignedBeaconBlockBellatrix.java index dc7565cf4ac..aa9e62cf0e6 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/SignedBeaconBlockBellatrix.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/SignedBeaconBlockBellatrix.java @@ -23,7 +23,7 @@ public class SignedBeaconBlockBellatrix extends SignedBeaconBlock implements Sig private final BeaconBlockBellatrix message; public SignedBeaconBlockBellatrix( - tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock internalBlock) { + final tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock internalBlock) { super(internalBlock); this.message = new BeaconBlockBellatrix(internalBlock.getMessage()); } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/SignedBlindedBeaconBlockBellatrix.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/SignedBlindedBeaconBlockBellatrix.java index 31ca0521407..7e73b03930a 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/SignedBlindedBeaconBlockBellatrix.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/bellatrix/SignedBlindedBeaconBlockBellatrix.java @@ -25,7 +25,7 @@ public class SignedBlindedBeaconBlockBellatrix extends SignedBeaconBlock impleme private final BlindedBlockBellatrix message; public SignedBlindedBeaconBlockBellatrix( - tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock internalBlock) { + final tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock internalBlock) { super(internalBlock); checkArgument( internalBlock.getMessage().getBody().isBlinded(), "requires a signed blinded beacon block"); diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/BeaconBlockBodyCapella.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/BeaconBlockBodyCapella.java index 0345a797e14..810d97ea93f 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/BeaconBlockBodyCapella.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/BeaconBlockBodyCapella.java @@ -73,7 +73,8 @@ public BeaconBlockBodyCapella( } public BeaconBlockBodyCapella( - tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.capella.BeaconBlockBodyCapella + final tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.capella + .BeaconBlockBodyCapella message) { super(message); checkNotNull(message.getExecutionPayload(), "Execution Payload is required for capella blocks"); diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/BeaconBlockCapella.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/BeaconBlockCapella.java index 93cd9655d17..e8c87a7d2d3 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/BeaconBlockCapella.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/BeaconBlockCapella.java @@ -25,7 +25,7 @@ public class BeaconBlockCapella extends BeaconBlockAltair { - public BeaconBlockCapella(BeaconBlock message) { + public BeaconBlockCapella(final BeaconBlock message) { super( message.getSlot(), message.getProposerIndex(), @@ -35,7 +35,7 @@ public BeaconBlockCapella(BeaconBlock message) { } @Override - public BeaconBlock asInternalBeaconBlock(Spec spec) { + public BeaconBlock asInternalBeaconBlock(final Spec spec) { final SpecVersion specVersion = spec.atSlot(slot); return SchemaDefinitionsCapella.required(specVersion.getSchemaDefinitions()) .getBeaconBlockSchema() diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/BeaconStateCapella.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/BeaconStateCapella.java index 4a659c338c1..7ac03d83486 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/BeaconStateCapella.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/BeaconStateCapella.java @@ -114,7 +114,7 @@ public BeaconStateCapella( this.historicalSummaries = historicalSummaries; } - public BeaconStateCapella(BeaconState beaconState) { + public BeaconStateCapella(final BeaconState beaconState) { super(beaconState); final tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.capella .BeaconStateCapella @@ -151,13 +151,13 @@ protected void applyAdditionalFields( protected static void applyCapellaFields( final SpecVersion specVersion, - MutableBeaconStateCapella state, - SyncCommitteeSchema syncCommitteeSchema, - ExecutionPayloadHeaderSchemaCapella executionPayloadHeaderSchema, - SszListSchema< + final MutableBeaconStateCapella state, + final SyncCommitteeSchema syncCommitteeSchema, + final ExecutionPayloadHeaderSchemaCapella executionPayloadHeaderSchema, + final SszListSchema< tech.pegasys.teku.spec.datastructures.state.versions.capella.HistoricalSummary, ?> historicalSummariesSchema, - BeaconStateCapella instance) { + final BeaconStateCapella instance) { BeaconStateAltair.applyAltairFields(state, syncCommitteeSchema, instance); diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/BlindedBlockCapella.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/BlindedBlockCapella.java index 9ae1a890771..660a8fd3303 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/BlindedBlockCapella.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/BlindedBlockCapella.java @@ -25,7 +25,7 @@ public class BlindedBlockCapella extends BeaconBlockAltair { - public BlindedBlockCapella(BeaconBlock message) { + public BlindedBlockCapella(final BeaconBlock message) { super( message.getSlot(), message.getProposerIndex(), @@ -41,7 +41,7 @@ public BeaconBlockSchema getBeaconBlockSchema(final SpecVersion spec) { } @Override - public BeaconBlock asInternalBeaconBlock(Spec spec) { + public BeaconBlock asInternalBeaconBlock(final Spec spec) { final SpecVersion specVersion = spec.atSlot(slot); return getBeaconBlockSchema(specVersion) .create( diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/ExecutionPayloadCapella.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/ExecutionPayloadCapella.java index 02966a7b7a4..2eb3d75083c 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/ExecutionPayloadCapella.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/ExecutionPayloadCapella.java @@ -40,21 +40,21 @@ public class ExecutionPayloadCapella extends ExecutionPayloadBellatrix implement @JsonCreator public ExecutionPayloadCapella( - @JsonProperty("parent_hash") Bytes32 parentHash, - @JsonProperty("fee_recipient") Bytes20 feeRecipient, - @JsonProperty("state_root") Bytes32 stateRoot, - @JsonProperty("receipts_root") Bytes32 receiptsRoot, - @JsonProperty("logs_bloom") Bytes logsBloom, - @JsonProperty("prev_randao") Bytes32 prevRandao, - @JsonProperty("block_number") UInt64 blockNumber, - @JsonProperty("gas_limit") UInt64 gasLimit, - @JsonProperty("gas_used") UInt64 gasUsed, - @JsonProperty("timestamp") UInt64 timestamp, - @JsonProperty("extra_data") Bytes extraData, - @JsonProperty("base_fee_per_gas") UInt256 baseFeePerGas, - @JsonProperty("block_hash") Bytes32 blockHash, - @JsonProperty("transactions") List transactions, - @JsonProperty("withdrawals") List withdrawals) { + final @JsonProperty("parent_hash") Bytes32 parentHash, + final @JsonProperty("fee_recipient") Bytes20 feeRecipient, + final @JsonProperty("state_root") Bytes32 stateRoot, + final @JsonProperty("receipts_root") Bytes32 receiptsRoot, + final @JsonProperty("logs_bloom") Bytes logsBloom, + final @JsonProperty("prev_randao") Bytes32 prevRandao, + final @JsonProperty("block_number") UInt64 blockNumber, + final @JsonProperty("gas_limit") UInt64 gasLimit, + final @JsonProperty("gas_used") UInt64 gasUsed, + final @JsonProperty("timestamp") UInt64 timestamp, + final @JsonProperty("extra_data") Bytes extraData, + final @JsonProperty("base_fee_per_gas") UInt256 baseFeePerGas, + final @JsonProperty("block_hash") Bytes32 blockHash, + final @JsonProperty("transactions") List transactions, + final @JsonProperty("withdrawals") List withdrawals) { super( parentHash, feeRecipient, @@ -74,7 +74,7 @@ public ExecutionPayloadCapella( } public ExecutionPayloadCapella( - tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload executionPayload) { + final tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload executionPayload) { super(executionPayload); this.withdrawals = executionPayload.getOptionalWithdrawals().orElseThrow().stream() diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/ExecutionPayloadHeaderCapella.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/ExecutionPayloadHeaderCapella.java index 71ca7d7a628..1c527cfcdef 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/ExecutionPayloadHeaderCapella.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/ExecutionPayloadHeaderCapella.java @@ -37,21 +37,21 @@ public class ExecutionPayloadHeaderCapella extends ExecutionPayloadHeaderBellatr @JsonCreator public ExecutionPayloadHeaderCapella( - @JsonProperty("parent_hash") Bytes32 parentHash, - @JsonProperty("fee_recipient") Bytes20 feeRecipient, - @JsonProperty("state_root") Bytes32 stateRoot, - @JsonProperty("receipts_root") Bytes32 receiptsRoot, - @JsonProperty("logs_bloom") Bytes logsBloom, - @JsonProperty("prev_randao") Bytes32 prevRandao, - @JsonProperty("block_number") UInt64 blockNumber, - @JsonProperty("gas_limit") UInt64 gasLimit, - @JsonProperty("gas_used") UInt64 gasUsed, - @JsonProperty("timestamp") UInt64 timestamp, - @JsonProperty("extra_data") Bytes extraData, - @JsonProperty("base_fee_per_gas") UInt256 baseFeePerGas, - @JsonProperty("block_hash") Bytes32 blockHash, - @JsonProperty("transactions_root") Bytes32 transactionsRoot, - @JsonProperty("withdrawals_root") Bytes32 withdrawalsRoot) { + final @JsonProperty("parent_hash") Bytes32 parentHash, + final @JsonProperty("fee_recipient") Bytes20 feeRecipient, + final @JsonProperty("state_root") Bytes32 stateRoot, + final @JsonProperty("receipts_root") Bytes32 receiptsRoot, + final @JsonProperty("logs_bloom") Bytes logsBloom, + final @JsonProperty("prev_randao") Bytes32 prevRandao, + final @JsonProperty("block_number") UInt64 blockNumber, + final @JsonProperty("gas_limit") UInt64 gasLimit, + final @JsonProperty("gas_used") UInt64 gasUsed, + final @JsonProperty("timestamp") UInt64 timestamp, + final @JsonProperty("extra_data") Bytes extraData, + final @JsonProperty("base_fee_per_gas") UInt256 baseFeePerGas, + final @JsonProperty("block_hash") Bytes32 blockHash, + final @JsonProperty("transactions_root") Bytes32 transactionsRoot, + final @JsonProperty("withdrawals_root") Bytes32 withdrawalsRoot) { super( parentHash, feeRecipient, @@ -70,7 +70,7 @@ public ExecutionPayloadHeaderCapella( this.withdrawalsRoot = withdrawalsRoot; } - public ExecutionPayloadHeaderCapella(ExecutionPayloadHeader executionPayloadHeader) { + public ExecutionPayloadHeaderCapella(final ExecutionPayloadHeader executionPayloadHeader) { super( executionPayloadHeader.getParentHash(), executionPayloadHeader.getFeeRecipient(), diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/SignedBeaconBlockCapella.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/SignedBeaconBlockCapella.java index 561dd77f44b..3a55e9cd157 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/SignedBeaconBlockCapella.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/SignedBeaconBlockCapella.java @@ -23,7 +23,7 @@ public class SignedBeaconBlockCapella extends SignedBeaconBlock implements Signe private final BeaconBlockCapella message; public SignedBeaconBlockCapella( - tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock internalBlock) { + final tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock internalBlock) { super(internalBlock); this.message = new BeaconBlockCapella(internalBlock.getMessage()); } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/SignedBlindedBeaconBlockCapella.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/SignedBlindedBeaconBlockCapella.java index 78f38f447e6..64eb2742a10 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/SignedBlindedBeaconBlockCapella.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/capella/SignedBlindedBeaconBlockCapella.java @@ -25,7 +25,7 @@ public class SignedBlindedBeaconBlockCapella extends SignedBeaconBlock implement private final BlindedBlockCapella message; public SignedBlindedBeaconBlockCapella( - tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock internalBlock) { + final tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock internalBlock) { super(internalBlock); checkArgument( internalBlock.getMessage().getBody().isBlinded(), "requires a signed blinded beacon block"); diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/deneb/BeaconBlockBodyDeneb.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/deneb/BeaconBlockBodyDeneb.java index 3266a849e3c..2e6076acb6f 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/deneb/BeaconBlockBodyDeneb.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/deneb/BeaconBlockBodyDeneb.java @@ -82,7 +82,8 @@ public BeaconBlockBodyDeneb( } public BeaconBlockBodyDeneb( - tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.deneb.BeaconBlockBodyDeneb + final tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.deneb + .BeaconBlockBodyDeneb message) { super(message); checkNotNull(message.getExecutionPayload(), "Execution Payload is required for Deneb blocks"); diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/deneb/BeaconStateDeneb.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/deneb/BeaconStateDeneb.java index 35b7629d566..07ec4e04c3f 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/deneb/BeaconStateDeneb.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/deneb/BeaconStateDeneb.java @@ -151,7 +151,7 @@ protected static void applyDenebFields( final MutableBeaconStateDeneb state, final SyncCommitteeSchema syncCommitteeSchema, final ExecutionPayloadHeaderSchemaDeneb executionPayloadHeaderSchema, - SszListSchema< + final SszListSchema< tech.pegasys.teku.spec.datastructures.state.versions.capella.HistoricalSummary, ?> historicalSummariesSchema, final BeaconStateDeneb instance) { diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/BeaconStateEip7594.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/BeaconStateEip7594.java deleted file mode 100644 index 33d7011dac1..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/BeaconStateEip7594.java +++ /dev/null @@ -1,178 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.api.schema.eip7594; - -import static tech.pegasys.teku.api.schema.SchemaConstants.EXAMPLE_UINT64; - -import com.fasterxml.jackson.annotation.JsonProperty; -import io.swagger.v3.oas.annotations.media.Schema; -import java.util.List; -import org.apache.tuweni.bytes.Bytes32; -import tech.pegasys.teku.api.schema.BeaconBlockHeader; -import tech.pegasys.teku.api.schema.Checkpoint; -import tech.pegasys.teku.api.schema.Eth1Data; -import tech.pegasys.teku.api.schema.Fork; -import tech.pegasys.teku.api.schema.Validator; -import tech.pegasys.teku.api.schema.altair.BeaconStateAltair; -import tech.pegasys.teku.api.schema.altair.SyncCommittee; -import tech.pegasys.teku.api.schema.capella.HistoricalSummary; -import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; -import tech.pegasys.teku.infrastructure.ssz.schema.SszListSchema; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.SpecVersion; -import tech.pegasys.teku.spec.datastructures.execution.versions.eip7594.ExecutionPayloadHeaderSchemaEip7594; -import tech.pegasys.teku.spec.datastructures.state.SyncCommittee.SyncCommitteeSchema; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.MutableBeaconState; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.eip7594.BeaconStateSchemaEip7594; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.eip7594.MutableBeaconStateEip7594; - -public class BeaconStateEip7594 extends BeaconStateAltair { - - @JsonProperty("latest_execution_payload_header") - public final ExecutionPayloadHeaderEip7594 latestExecutionPayloadHeader; - - @JsonProperty("next_withdrawal_index") - @Schema(type = "string", example = EXAMPLE_UINT64) - public final UInt64 nextWithdrawalIndex; - - @JsonProperty("next_withdrawal_validator_index") - @Schema(type = "string", example = EXAMPLE_UINT64) - public final UInt64 nextWithdrawalValidatorIndex; - - @JsonProperty("historical_summaries") - public final List historicalSummaries; - - public BeaconStateEip7594( - @JsonProperty("genesis_time") final UInt64 genesisTime, - @JsonProperty("genesis_validators_root") final Bytes32 genesisValidatorsRoot, - @JsonProperty("slot") final UInt64 slot, - @JsonProperty("fork") final Fork fork, - @JsonProperty("latest_block_header") final BeaconBlockHeader latestBlockHeader, - @JsonProperty("block_roots") final List blockRoots, - @JsonProperty("state_roots") final List stateRoots, - @JsonProperty("historical_roots") final List historicalRoots, - @JsonProperty("eth1_data") final Eth1Data eth1Data, - @JsonProperty("eth1_data_votes") final List eth1DataVotes, - @JsonProperty("eth1_deposit_index") final UInt64 eth1DepositIndex, - @JsonProperty("validators") final List validators, - @JsonProperty("balances") final List balances, - @JsonProperty("randao_mixes") final List randaoMixes, - @JsonProperty("slashings") final List slashings, - @JsonProperty("previous_epoch_participation") final byte[] previousEpochParticipation, - @JsonProperty("current_epoch_participation") final byte[] currentEpochParticipation, - @JsonProperty("justification_bits") final SszBitvector justificationBits, - @JsonProperty("previous_justified_checkpoint") final Checkpoint previousJustifiedCheckpoint, - @JsonProperty("current_justified_checkpoint") final Checkpoint currentJustifiedCheckpoint, - @JsonProperty("finalized_checkpoint") final Checkpoint finalizedCheckpoint, - @JsonProperty("inactivity_scores") final List inactivityScores, - @JsonProperty("current_sync_committee") final SyncCommittee currentSyncCommittee, - @JsonProperty("next_sync_committee") final SyncCommittee nextSyncCommittee, - @JsonProperty("latest_execution_payload_header") - final ExecutionPayloadHeaderEip7594 latestExecutionPayloadHeader, - @JsonProperty("next_withdrawal_index") final UInt64 nextWithdrawalIndex, - @JsonProperty("next_withdrawal_validator_index") final UInt64 nextWithdrawalValidatorIndex, - @JsonProperty("historical_summaries") final List historicalSummaries) { - super( - genesisTime, - genesisValidatorsRoot, - slot, - fork, - latestBlockHeader, - blockRoots, - stateRoots, - historicalRoots, - eth1Data, - eth1DataVotes, - eth1DepositIndex, - validators, - balances, - randaoMixes, - slashings, - previousEpochParticipation, - currentEpochParticipation, - justificationBits, - previousJustifiedCheckpoint, - currentJustifiedCheckpoint, - finalizedCheckpoint, - inactivityScores, - currentSyncCommittee, - nextSyncCommittee); - this.latestExecutionPayloadHeader = latestExecutionPayloadHeader; - this.nextWithdrawalIndex = nextWithdrawalIndex; - this.nextWithdrawalValidatorIndex = nextWithdrawalValidatorIndex; - this.historicalSummaries = historicalSummaries; - } - - public BeaconStateEip7594(final BeaconState beaconState) { - super(beaconState); - final tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.eip7594 - .BeaconStateEip7594 - eip7594 = beaconState.toVersionEip7594().orElseThrow(); - this.latestExecutionPayloadHeader = - new ExecutionPayloadHeaderEip7594(eip7594.getLatestExecutionPayloadHeader()); - this.nextWithdrawalIndex = eip7594.getNextWithdrawalIndex(); - this.nextWithdrawalValidatorIndex = eip7594.getNextWithdrawalValidatorIndex(); - this.historicalSummaries = - eip7594.getHistoricalSummaries().stream().map(HistoricalSummary::new).toList(); - } - - @Override - protected void applyAdditionalFields( - final MutableBeaconState state, final SpecVersion specVersion) { - state - .toMutableVersionEip7594() - .ifPresent( - mutableBeaconStateEip7594 -> - applyEip7594Fields( - specVersion, - mutableBeaconStateEip7594, - BeaconStateSchemaEip7594.required( - mutableBeaconStateEip7594.getBeaconStateSchema()) - .getCurrentSyncCommitteeSchema(), - BeaconStateSchemaEip7594.required( - mutableBeaconStateEip7594.getBeaconStateSchema()) - .getLastExecutionPayloadHeaderSchema(), - BeaconStateSchemaEip7594.required( - mutableBeaconStateEip7594.getBeaconStateSchema()) - .getHistoricalSummariesSchema(), - this)); - } - - protected static void applyEip7594Fields( - final SpecVersion specVersion, - final MutableBeaconStateEip7594 state, - final SyncCommitteeSchema syncCommitteeSchema, - final ExecutionPayloadHeaderSchemaEip7594 executionPayloadHeaderSchema, - final SszListSchema< - tech.pegasys.teku.spec.datastructures.state.versions.capella.HistoricalSummary, ?> - historicalSummariesSchema, - final BeaconStateEip7594 instance) { - - BeaconStateAltair.applyAltairFields(state, syncCommitteeSchema, instance); - - state.setLatestExecutionPayloadHeader( - instance.latestExecutionPayloadHeader.asInternalExecutionPayloadHeader( - executionPayloadHeaderSchema)); - - state.setNextWithdrawalIndex(instance.nextWithdrawalIndex); - state.setNextWithdrawalValidatorIndex(instance.nextWithdrawalValidatorIndex); - state.setHistoricalSummaries( - historicalSummariesSchema.createFromElements( - instance.historicalSummaries.stream() - .map( - historicalSummary -> historicalSummary.asInternalHistoricalSummary(specVersion)) - .toList())); - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/ExecutionPayloadEip7594.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/ExecutionPayloadEip7594.java deleted file mode 100644 index 2f5dff2a204..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/ExecutionPayloadEip7594.java +++ /dev/null @@ -1,79 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.api.schema.eip7594; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import java.util.List; -import java.util.Optional; -import org.apache.tuweni.bytes.Bytes; -import org.apache.tuweni.bytes.Bytes32; -import org.apache.tuweni.units.bigints.UInt256; -import tech.pegasys.teku.api.schema.ExecutionPayload; -import tech.pegasys.teku.api.schema.capella.Withdrawal; -import tech.pegasys.teku.api.schema.deneb.ExecutionPayloadDeneb; -import tech.pegasys.teku.infrastructure.bytes.Bytes20; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; - -public class ExecutionPayloadEip7594 extends ExecutionPayloadDeneb implements ExecutionPayload { - - @JsonCreator - public ExecutionPayloadEip7594( - @JsonProperty("parent_hash") final Bytes32 parentHash, - @JsonProperty("fee_recipient") final Bytes20 feeRecipient, - @JsonProperty("state_root") final Bytes32 stateRoot, - @JsonProperty("receipts_root") final Bytes32 receiptsRoot, - @JsonProperty("logs_bloom") final Bytes logsBloom, - @JsonProperty("prev_randao") final Bytes32 prevRandao, - @JsonProperty("block_number") final UInt64 blockNumber, - @JsonProperty("gas_limit") final UInt64 gasLimit, - @JsonProperty("gas_used") final UInt64 gasUsed, - @JsonProperty("timestamp") final UInt64 timestamp, - @JsonProperty("extra_data") final Bytes extraData, - @JsonProperty("base_fee_per_gas") final UInt256 baseFeePerGas, - @JsonProperty("block_hash") final Bytes32 blockHash, - @JsonProperty("transactions") final List transactions, - @JsonProperty("withdrawals") final List withdrawals, - @JsonProperty("blob_gas_used") final UInt64 blobGasUsed, - @JsonProperty("excess_blob_gas") final UInt64 excessBlobGas) { - super( - parentHash, - feeRecipient, - stateRoot, - receiptsRoot, - logsBloom, - prevRandao, - blockNumber, - gasLimit, - gasUsed, - timestamp, - extraData, - baseFeePerGas, - blockHash, - transactions, - withdrawals, - blobGasUsed, - excessBlobGas); - } - - public ExecutionPayloadEip7594( - final tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload executionPayload) { - super(executionPayload); - } - - @Override - public Optional toVersionEip7594() { - return Optional.of(this); - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/ExecutionPayloadHeaderEip7594.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/ExecutionPayloadHeaderEip7594.java deleted file mode 100644 index e90125e7be0..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/ExecutionPayloadHeaderEip7594.java +++ /dev/null @@ -1,93 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.api.schema.eip7594; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import java.util.Optional; -import org.apache.tuweni.bytes.Bytes; -import org.apache.tuweni.bytes.Bytes32; -import org.apache.tuweni.units.bigints.UInt256; -import tech.pegasys.teku.api.schema.deneb.ExecutionPayloadHeaderDeneb; -import tech.pegasys.teku.infrastructure.bytes.Bytes20; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; - -public class ExecutionPayloadHeaderEip7594 extends ExecutionPayloadHeaderDeneb { - - @JsonCreator - public ExecutionPayloadHeaderEip7594( - @JsonProperty("parent_hash") final Bytes32 parentHash, - @JsonProperty("fee_recipient") final Bytes20 feeRecipient, - @JsonProperty("state_root") final Bytes32 stateRoot, - @JsonProperty("receipts_root") final Bytes32 receiptsRoot, - @JsonProperty("logs_bloom") final Bytes logsBloom, - @JsonProperty("prev_randao") final Bytes32 prevRandao, - @JsonProperty("block_number") final UInt64 blockNumber, - @JsonProperty("gas_limit") final UInt64 gasLimit, - @JsonProperty("gas_used") final UInt64 gasUsed, - @JsonProperty("timestamp") final UInt64 timestamp, - @JsonProperty("extra_data") final Bytes extraData, - @JsonProperty("base_fee_per_gas") final UInt256 baseFeePerGas, - @JsonProperty("block_hash") final Bytes32 blockHash, - @JsonProperty("transactions_root") final Bytes32 transactionsRoot, - @JsonProperty("withdrawals_root") final Bytes32 withdrawalsRoot, - @JsonProperty("blob_gas_used") final UInt64 blobGasUsed, - @JsonProperty("excess_blob_gas") final UInt64 excessBlobGas) { - super( - parentHash, - feeRecipient, - stateRoot, - receiptsRoot, - logsBloom, - prevRandao, - blockNumber, - gasLimit, - gasUsed, - timestamp, - extraData, - baseFeePerGas, - blockHash, - transactionsRoot, - withdrawalsRoot, - blobGasUsed, - excessBlobGas); - } - - public ExecutionPayloadHeaderEip7594(final ExecutionPayloadHeader executionPayloadHeader) { - super( - executionPayloadHeader.getParentHash(), - executionPayloadHeader.getFeeRecipient(), - executionPayloadHeader.getStateRoot(), - executionPayloadHeader.getReceiptsRoot(), - executionPayloadHeader.getLogsBloom(), - executionPayloadHeader.getPrevRandao(), - executionPayloadHeader.getBlockNumber(), - executionPayloadHeader.getGasLimit(), - executionPayloadHeader.getGasUsed(), - executionPayloadHeader.getTimestamp(), - executionPayloadHeader.getExtraData(), - executionPayloadHeader.getBaseFeePerGas(), - executionPayloadHeader.getBlockHash(), - executionPayloadHeader.getTransactionsRoot(), - executionPayloadHeader.getOptionalWithdrawalsRoot().orElseThrow(), - executionPayloadHeader.toVersionDeneb().orElseThrow().getBlobGasUsed(), - executionPayloadHeader.toVersionDeneb().orElseThrow().getExcessBlobGas()); - } - - @Override - public Optional toVersionEip7594() { - return Optional.of(this); - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/BeaconBlockBodyEip7594.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/BeaconBlockBodyElectra.java similarity index 70% rename from data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/BeaconBlockBodyEip7594.java rename to data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/BeaconBlockBodyElectra.java index de51a6a83cf..f8dcdd2772c 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/BeaconBlockBodyEip7594.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/BeaconBlockBodyElectra.java @@ -11,7 +11,7 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.api.schema.eip7594; +package tech.pegasys.teku.api.schema.electra; import static com.google.common.base.Preconditions.checkNotNull; @@ -30,17 +30,19 @@ import tech.pegasys.teku.api.schema.altair.BeaconBlockBodyAltair; import tech.pegasys.teku.api.schema.altair.SyncAggregate; import tech.pegasys.teku.api.schema.capella.SignedBlsToExecutionChange; +import tech.pegasys.teku.api.schema.deneb.ExecutionPayloadDeneb; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.ssz.schema.SszListSchema; import tech.pegasys.teku.spec.SpecVersion; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594.BeaconBlockBodySchemaEip7594; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra.BeaconBlockBodySchemaElectra; import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; -public class BeaconBlockBodyEip7594 extends BeaconBlockBodyAltair { +public class BeaconBlockBodyElectra extends BeaconBlockBodyAltair { @JsonProperty("execution_payload") - public final ExecutionPayloadEip7594 executionPayload; + public final ExecutionPayloadDeneb executionPayload; @JsonProperty("bls_to_execution_changes") public final List blsToExecutionChanges; @@ -48,8 +50,11 @@ public class BeaconBlockBodyEip7594 extends BeaconBlockBodyAltair { @JsonProperty("blob_kzg_commitments") public final List blobKZGCommitments; + @JsonProperty("execution_requests") + public final ExecutionRequests executionRequests; + @JsonCreator - public BeaconBlockBodyEip7594( + public BeaconBlockBodyElectra( @JsonProperty("randao_reveal") final BLSSignature randaoReveal, @JsonProperty("eth1_data") final Eth1Data eth1Data, @JsonProperty("graffiti") final Bytes32 graffiti, @@ -59,10 +64,11 @@ public BeaconBlockBodyEip7594( @JsonProperty("deposits") final List deposits, @JsonProperty("voluntary_exits") final List voluntaryExits, @JsonProperty("sync_aggregate") final SyncAggregate syncAggregate, - @JsonProperty("execution_payload") final ExecutionPayloadEip7594 executionPayload, + @JsonProperty("execution_payload") final ExecutionPayloadDeneb executionPayload, @JsonProperty("bls_to_execution_changes") final List blsToExecutionChanges, - @JsonProperty("blob_kzg_commitments") final List blobKZGCommitments) { + @JsonProperty("blob_kzg_commitments") final List blobKZGCommitments, + @JsonProperty("execution_requests") final ExecutionRequests executionRequests) { super( randaoReveal, eth1Data, @@ -73,37 +79,42 @@ public BeaconBlockBodyEip7594( deposits, voluntaryExits, syncAggregate); - checkNotNull(executionPayload, "Execution Payload is required for EIP7594 blocks"); + checkNotNull(executionPayload, "ExecutionPayload is required for Electra blocks"); this.executionPayload = executionPayload; - checkNotNull(blsToExecutionChanges, "BlsToExecutionChanges is required for EIP7594 blocks"); + checkNotNull(blsToExecutionChanges, "BlsToExecutionChanges is required for Electra blocks"); this.blsToExecutionChanges = blsToExecutionChanges; - checkNotNull(blobKZGCommitments, "blobKZGCommitments is required for EIP7594 blocks"); + checkNotNull(blobKZGCommitments, "BlobKZGCommitments is required for Electra blocks"); this.blobKZGCommitments = blobKZGCommitments; + checkNotNull(executionRequests, "ExecutionRequests is required for Electra blocks"); + this.executionRequests = executionRequests; } - public BeaconBlockBodyEip7594( - tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594.BeaconBlockBodyEip7594 + public BeaconBlockBodyElectra( + final tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra + .BeaconBlockBodyElectra message) { super(message); - checkNotNull(message.getExecutionPayload(), "Execution Payload is required for EIP7594 blocks"); - this.executionPayload = new ExecutionPayloadEip7594(message.getExecutionPayload()); + checkNotNull(message.getExecutionPayload(), "ExecutionPayload is required for Electra blocks"); + this.executionPayload = new ExecutionPayloadDeneb(message.getExecutionPayload()); checkNotNull( - message.getBlsToExecutionChanges(), - "BlsToExecutionChanges are required for EIP7594 blocks"); + message.getBlsToExecutionChanges(), "BlsToExecutionChanges is required for Electra blocks"); this.blsToExecutionChanges = message.getBlsToExecutionChanges().stream().map(SignedBlsToExecutionChange::new).toList(); checkNotNull( - message.getBlobKzgCommitments(), "BlobKzgCommitments are required for EIP7594 blocks"); + message.getBlobKzgCommitments(), "BlobKzgCommitments is required for Electra blocks"); this.blobKZGCommitments = message.getBlobKzgCommitments().stream() .map(SszKZGCommitment::getKZGCommitment) .map(KZGCommitment::new) .toList(); + checkNotNull( + message.getExecutionRequests(), "ExecutionRequests is required for Electra blocks"); + this.executionRequests = new ExecutionRequests(message.getExecutionRequests()); } @Override - public BeaconBlockBodySchemaEip7594 getBeaconBlockBodySchema(final SpecVersion spec) { - return (BeaconBlockBodySchemaEip7594) spec.getSchemaDefinitions().getBeaconBlockBodySchema(); + public BeaconBlockBodySchemaElectra getBeaconBlockBodySchema(final SpecVersion spec) { + return (BeaconBlockBodySchemaElectra) spec.getSchemaDefinitions().getBeaconBlockBodySchema(); } @Override @@ -127,6 +138,11 @@ public BeaconBlockBody asInternalBeaconBlockBody(final SpecVersion spec) { .map(KZGCommitment::asInternalKZGCommitment) .map(SszKZGCommitment::new) .collect(blobKZGCommitmentsSchema.collector())); + builder.executionRequests( + this.executionRequests.asInternalConsolidationRequest( + SchemaDefinitionsElectra.required(spec.getSchemaDefinitions()) + .getExecutionRequestsSchema())); + return SafeFuture.COMPLETE; }); } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/BeaconBlockEip7594.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/BeaconBlockElectra.java similarity index 76% rename from data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/BeaconBlockEip7594.java rename to data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/BeaconBlockElectra.java index 1bdae66d5bd..3b2d0b3e9b4 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/BeaconBlockEip7594.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/BeaconBlockElectra.java @@ -11,7 +11,7 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.api.schema.eip7594; +package tech.pegasys.teku.api.schema.electra; import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonProperty; @@ -21,23 +21,23 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecVersion; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock; -import tech.pegasys.teku.spec.schemas.SchemaDefinitionsEip7594; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; -public class BeaconBlockEip7594 extends BeaconBlockAltair { +public class BeaconBlockElectra extends BeaconBlockAltair { - public BeaconBlockEip7594(final BeaconBlock message) { + public BeaconBlockElectra(final BeaconBlock message) { super( message.getSlot(), message.getProposerIndex(), message.getParentRoot(), message.getStateRoot(), - new BeaconBlockBodyEip7594(message.getBody().toVersionEip7594().orElseThrow())); + new BeaconBlockBodyElectra(message.getBody().toVersionElectra().orElseThrow())); } @Override public BeaconBlock asInternalBeaconBlock(final Spec spec) { final SpecVersion specVersion = spec.atSlot(slot); - return SchemaDefinitionsEip7594.required(specVersion.getSchemaDefinitions()) + return SchemaDefinitionsElectra.required(specVersion.getSchemaDefinitions()) .getBeaconBlockSchema() .create( slot, @@ -49,17 +49,17 @@ public BeaconBlock asInternalBeaconBlock(final Spec spec) { @JsonProperty("body") @Override - public BeaconBlockBodyEip7594 getBody() { - return (BeaconBlockBodyEip7594) body; + public BeaconBlockBodyElectra getBody() { + return (BeaconBlockBodyElectra) body; } @JsonCreator - public BeaconBlockEip7594( + public BeaconBlockElectra( @JsonProperty("slot") final UInt64 slot, @JsonProperty("proposer_index") final UInt64 proposerIndex, @JsonProperty("parent_root") final Bytes32 parentRoot, @JsonProperty("state_root") final Bytes32 stateRoot, - @JsonProperty("body") final BeaconBlockBodyEip7594 body) { + @JsonProperty("body") final BeaconBlockBodyElectra body) { super(slot, proposerIndex, parentRoot, stateRoot, body); } } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/BeaconStateElectra.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/BeaconStateElectra.java new file mode 100644 index 00000000000..0317d461e6b --- /dev/null +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/BeaconStateElectra.java @@ -0,0 +1,282 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.api.schema.electra; + +import static tech.pegasys.teku.api.schema.SchemaConstants.EXAMPLE_UINT64; + +import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.v3.oas.annotations.media.Schema; +import java.util.List; +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.api.schema.BeaconBlockHeader; +import tech.pegasys.teku.api.schema.Checkpoint; +import tech.pegasys.teku.api.schema.Eth1Data; +import tech.pegasys.teku.api.schema.Fork; +import tech.pegasys.teku.api.schema.Validator; +import tech.pegasys.teku.api.schema.altair.BeaconStateAltair; +import tech.pegasys.teku.api.schema.altair.SyncCommittee; +import tech.pegasys.teku.api.schema.capella.HistoricalSummary; +import tech.pegasys.teku.api.schema.deneb.ExecutionPayloadHeaderDeneb; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; +import tech.pegasys.teku.infrastructure.ssz.schema.SszListSchema; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecVersion; +import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadHeaderSchemaDeneb; +import tech.pegasys.teku.spec.datastructures.state.SyncCommittee.SyncCommitteeSchema; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.MutableBeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.BeaconStateSchemaElectra; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.MutableBeaconStateElectra; + +public class BeaconStateElectra extends BeaconStateAltair { + + @JsonProperty("latest_execution_payload_header") + public final ExecutionPayloadHeaderDeneb latestExecutionPayloadHeader; + + @JsonProperty("next_withdrawal_index") + @Schema(type = "string", example = EXAMPLE_UINT64) + public final UInt64 nextWithdrawalIndex; + + @JsonProperty("next_withdrawal_validator_index") + @Schema(type = "string", example = EXAMPLE_UINT64) + public final UInt64 nextWithdrawalValidatorIndex; + + @JsonProperty("historical_summaries") + public final List historicalSummaries; + + @JsonProperty("deposit_requests_start_index") + public final UInt64 depositRequestsStartIndex; + + @JsonProperty("deposit_balance_to_consume") + public final UInt64 depositBalanceToConsume; + + @JsonProperty("exit_balance_to_consume") + public final UInt64 exitBalanceToConsume; + + @JsonProperty("earliest_exit_epoch") + public final UInt64 earliestExitEpoch; + + @JsonProperty("consolidation_balance_to_consume") + public final UInt64 consolidationBalanceToConsume; + + @JsonProperty("earliest_consolidation_epoch") + public final UInt64 earliestConsolidationEpoch; + + @JsonProperty("pending_deposits") + public final List pendingDeposits; + + @JsonProperty("pending_partial_withdrawals") + public final List pendingPartialWithdrawals; + + @JsonProperty("pending_consolidations") + public final List pendingConsolidations; + + public BeaconStateElectra( + @JsonProperty("genesis_time") final UInt64 genesisTime, + @JsonProperty("genesis_validators_root") final Bytes32 genesisValidatorsRoot, + @JsonProperty("slot") final UInt64 slot, + @JsonProperty("fork") final Fork fork, + @JsonProperty("latest_block_header") final BeaconBlockHeader latestBlockHeader, + @JsonProperty("block_roots") final List blockRoots, + @JsonProperty("state_roots") final List stateRoots, + @JsonProperty("historical_roots") final List historicalRoots, + @JsonProperty("eth1_data") final Eth1Data eth1Data, + @JsonProperty("eth1_data_votes") final List eth1DataVotes, + @JsonProperty("eth1_deposit_index") final UInt64 eth1DepositIndex, + @JsonProperty("validators") final List validators, + @JsonProperty("balances") final List balances, + @JsonProperty("randao_mixes") final List randaoMixes, + @JsonProperty("slashings") final List slashings, + @JsonProperty("previous_epoch_participation") final byte[] previousEpochParticipation, + @JsonProperty("current_epoch_participation") final byte[] currentEpochParticipation, + @JsonProperty("justification_bits") final SszBitvector justificationBits, + @JsonProperty("previous_justified_checkpoint") final Checkpoint previousJustifiedCheckpoint, + @JsonProperty("current_justified_checkpoint") final Checkpoint currentJustifiedCheckpoint, + @JsonProperty("finalized_checkpoint") final Checkpoint finalizedCheckpoint, + @JsonProperty("inactivity_scores") final List inactivityScores, + @JsonProperty("current_sync_committee") final SyncCommittee currentSyncCommittee, + @JsonProperty("next_sync_committee") final SyncCommittee nextSyncCommittee, + @JsonProperty("latest_execution_payload_header") + final ExecutionPayloadHeaderDeneb latestExecutionPayloadHeader, + @JsonProperty("next_withdrawal_index") final UInt64 nextWithdrawalIndex, + @JsonProperty("next_withdrawal_validator_index") final UInt64 nextWithdrawalValidatorIndex, + @JsonProperty("historical_summaries") final List historicalSummaries, + @JsonProperty("deposit_requests_start_index") final UInt64 depositRequestsStartIndex, + @JsonProperty("deposit_balance_to_consume") final UInt64 depositBalanceToConsume, + @JsonProperty("exit_balance_to_consume") final UInt64 exitBalanceToConsume, + @JsonProperty("earliest_exit_epoch") final UInt64 earliestExitEpoch, + @JsonProperty("consolidation_balance_to_consume") final UInt64 consolidationBalanceToConsume, + @JsonProperty("earliest_consolidation_epoch") final UInt64 earliestConsolidationEpoch, + @JsonProperty("pending_deposits") final List pendingDeposits, + @JsonProperty("pending_partial_withdrawals") + final List pendingPartialWithdrawals, + @JsonProperty("pending_consolidations") + final List pendingConsolidations) { + super( + genesisTime, + genesisValidatorsRoot, + slot, + fork, + latestBlockHeader, + blockRoots, + stateRoots, + historicalRoots, + eth1Data, + eth1DataVotes, + eth1DepositIndex, + validators, + balances, + randaoMixes, + slashings, + previousEpochParticipation, + currentEpochParticipation, + justificationBits, + previousJustifiedCheckpoint, + currentJustifiedCheckpoint, + finalizedCheckpoint, + inactivityScores, + currentSyncCommittee, + nextSyncCommittee); + this.latestExecutionPayloadHeader = latestExecutionPayloadHeader; + this.nextWithdrawalIndex = nextWithdrawalIndex; + this.nextWithdrawalValidatorIndex = nextWithdrawalValidatorIndex; + this.historicalSummaries = historicalSummaries; + this.depositRequestsStartIndex = depositRequestsStartIndex; + this.depositBalanceToConsume = depositBalanceToConsume; + this.exitBalanceToConsume = exitBalanceToConsume; + this.earliestExitEpoch = earliestExitEpoch; + this.consolidationBalanceToConsume = consolidationBalanceToConsume; + this.earliestConsolidationEpoch = earliestConsolidationEpoch; + this.pendingDeposits = pendingDeposits; + this.pendingPartialWithdrawals = pendingPartialWithdrawals; + this.pendingConsolidations = pendingConsolidations; + } + + public BeaconStateElectra(final BeaconState beaconState) { + super(beaconState); + final tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra + .BeaconStateElectra + electra = beaconState.toVersionElectra().orElseThrow(); + + this.latestExecutionPayloadHeader = + new ExecutionPayloadHeaderDeneb(electra.getLatestExecutionPayloadHeader()); + this.nextWithdrawalIndex = electra.getNextWithdrawalIndex(); + this.nextWithdrawalValidatorIndex = electra.getNextWithdrawalValidatorIndex(); + this.historicalSummaries = + electra.getHistoricalSummaries().stream().map(HistoricalSummary::new).toList(); + this.depositRequestsStartIndex = electra.getDepositRequestsStartIndex(); + this.depositBalanceToConsume = electra.getDepositBalanceToConsume(); + this.exitBalanceToConsume = electra.getExitBalanceToConsume(); + this.earliestExitEpoch = electra.getEarliestExitEpoch(); + this.consolidationBalanceToConsume = electra.getConsolidationBalanceToConsume(); + this.earliestConsolidationEpoch = electra.getEarliestConsolidationEpoch(); + this.pendingDeposits = electra.getPendingDeposits().stream().map(PendingDeposit::new).toList(); + this.pendingPartialWithdrawals = + electra.getPendingPartialWithdrawals().stream().map(PendingPartialWithdrawal::new).toList(); + this.pendingConsolidations = + electra.getPendingConsolidations().stream().map(PendingConsolidation::new).toList(); + } + + @Override + protected void applyAdditionalFields( + final MutableBeaconState state, final SpecVersion specVersion) { + state + .toMutableVersionElectra() + .ifPresent( + mutableBeaconStateElectra -> + applyElectraFields( + specVersion, + mutableBeaconStateElectra, + BeaconStateSchemaElectra.required( + mutableBeaconStateElectra.getBeaconStateSchema()) + .getCurrentSyncCommitteeSchema(), + BeaconStateSchemaElectra.required( + mutableBeaconStateElectra.getBeaconStateSchema()) + .getLastExecutionPayloadHeaderSchema(), + BeaconStateSchemaElectra.required( + mutableBeaconStateElectra.getBeaconStateSchema()) + .getHistoricalSummariesSchema(), + BeaconStateSchemaElectra.required( + mutableBeaconStateElectra.getBeaconStateSchema()) + .getPendingDepositsSchema(), + BeaconStateSchemaElectra.required( + mutableBeaconStateElectra.getBeaconStateSchema()) + .getPendingPartialWithdrawalsSchema(), + BeaconStateSchemaElectra.required( + mutableBeaconStateElectra.getBeaconStateSchema()) + .getPendingConsolidationsSchema(), + this)); + } + + protected static void applyElectraFields( + final SpecVersion specVersion, + final MutableBeaconStateElectra state, + final SyncCommitteeSchema syncCommitteeSchema, + final ExecutionPayloadHeaderSchemaDeneb executionPayloadHeaderSchema, + final SszListSchema< + tech.pegasys.teku.spec.datastructures.state.versions.capella.HistoricalSummary, ?> + historicalSummariesSchema, + final SszListSchema< + tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingDeposit, ?> + pendingDepositsSchema, + final SszListSchema< + tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingPartialWithdrawal, + ?> + pendingPartialWithdrawalsSchema, + final SszListSchema< + tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingConsolidation, ?> + pendingConsolidationsSchema, + final BeaconStateElectra instance) { + + BeaconStateAltair.applyAltairFields(state, syncCommitteeSchema, instance); + + state.setLatestExecutionPayloadHeader( + instance.latestExecutionPayloadHeader.asInternalExecutionPayloadHeader( + executionPayloadHeaderSchema)); + + state.setNextWithdrawalIndex(instance.nextWithdrawalIndex); + state.setNextWithdrawalValidatorIndex(instance.nextWithdrawalValidatorIndex); + state.setHistoricalSummaries( + historicalSummariesSchema.createFromElements( + instance.historicalSummaries.stream() + .map( + historicalSummary -> historicalSummary.asInternalHistoricalSummary(specVersion)) + .toList())); + state.setDepositRequestsStartIndex(instance.depositRequestsStartIndex); + state.setDepositBalanceToConsume(instance.depositBalanceToConsume); + state.setExitBalanceToConsume(instance.exitBalanceToConsume); + state.setEarliestExitEpoch(instance.earliestExitEpoch); + state.setConsolidationBalanceToConsume(instance.consolidationBalanceToConsume); + state.setEarliestConsolidationEpoch(instance.earliestConsolidationEpoch); + state.setPendingDeposits( + pendingDepositsSchema.createFromElements( + instance.pendingDeposits.stream() + .map(pendingDeposit -> pendingDeposit.asInternalPendingDeposit(specVersion)) + .toList())); + state.setPendingPartialWithdrawals( + pendingPartialWithdrawalsSchema.createFromElements( + instance.pendingPartialWithdrawals.stream() + .map( + pendingPartialWithdrawal -> + pendingPartialWithdrawal.asInternalPendingPartialWithdrawal(specVersion)) + .toList())); + state.setPendingConsolidations( + pendingConsolidationsSchema.createFromElements( + instance.pendingConsolidations.stream() + .map( + pendingConsolidation -> + pendingConsolidation.asInternalPendingConsolidation(specVersion)) + .toList())); + } +} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/BlindedBeaconBlockBodyEip7594.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/BlindedBeaconBlockBodyElectra.java similarity index 75% rename from data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/BlindedBeaconBlockBodyEip7594.java rename to data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/BlindedBeaconBlockBodyElectra.java index 4714e9219b8..8623b4d4855 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/BlindedBeaconBlockBodyEip7594.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/BlindedBeaconBlockBodyElectra.java @@ -11,7 +11,7 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.api.schema.eip7594; +package tech.pegasys.teku.api.schema.electra; import static com.google.common.base.Preconditions.checkNotNull; @@ -30,18 +30,20 @@ import tech.pegasys.teku.api.schema.altair.BeaconBlockBodyAltair; import tech.pegasys.teku.api.schema.altair.SyncAggregate; import tech.pegasys.teku.api.schema.capella.SignedBlsToExecutionChange; +import tech.pegasys.teku.api.schema.deneb.ExecutionPayloadHeaderDeneb; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.ssz.schema.SszListSchema; import tech.pegasys.teku.spec.SpecVersion; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594.BlindedBeaconBlockBodySchemaEip7594; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra.BlindedBeaconBlockBodySchemaElectra; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeaderSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsSchema; import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; -public class BlindedBeaconBlockBodyEip7594 extends BeaconBlockBodyAltair { +public class BlindedBeaconBlockBodyElectra extends BeaconBlockBodyAltair { @JsonProperty("execution_payload_header") - public final ExecutionPayloadHeaderEip7594 executionPayloadHeader; + public final ExecutionPayloadHeaderDeneb executionPayloadHeader; @JsonProperty("bls_to_execution_changes") public final List blsToExecutionChanges; @@ -49,8 +51,11 @@ public class BlindedBeaconBlockBodyEip7594 extends BeaconBlockBodyAltair { @JsonProperty("blob_kzg_commitments") public final List blobKZGCommitments; + @JsonProperty("execution_requests") + public final ExecutionRequests executionRequests; + @JsonCreator - public BlindedBeaconBlockBodyEip7594( + public BlindedBeaconBlockBodyElectra( @JsonProperty("randao_reveal") final BLSSignature randaoReveal, @JsonProperty("eth1_data") final Eth1Data eth1Data, @JsonProperty("graffiti") final Bytes32 graffiti, @@ -61,10 +66,11 @@ public BlindedBeaconBlockBodyEip7594( @JsonProperty("voluntary_exits") final List voluntaryExits, @JsonProperty("sync_aggregate") final SyncAggregate syncAggregate, @JsonProperty("execution_payload_header") - final ExecutionPayloadHeaderEip7594 executionPayloadHeader, + final ExecutionPayloadHeaderDeneb executionPayloadHeader, @JsonProperty("bls_to_execution_changes") final List blsToExecutionChanges, - @JsonProperty("blob_kzg_commitments") final List blobKZGCommitments) { + @JsonProperty("blob_kzg_commitments") final List blobKZGCommitments, + @JsonProperty("execution_requests") final ExecutionRequests executionRequests) { super( randaoReveal, eth1Data, @@ -76,22 +82,24 @@ public BlindedBeaconBlockBodyEip7594( voluntaryExits, syncAggregate); checkNotNull( - executionPayloadHeader, "Execution Payload Header is required for EIP7594 blinded blocks"); + executionPayloadHeader, "ExecutionPayloadHeader is required for Electra blinded blocks"); this.executionPayloadHeader = executionPayloadHeader; checkNotNull( - blsToExecutionChanges, "blsToExecutionChanges is required for EIP7594 blinded blocks"); + blsToExecutionChanges, "BlsToExecutionChanges is required for Electra blinded blocks"); this.blsToExecutionChanges = blsToExecutionChanges; - checkNotNull(blobKZGCommitments, "blobKZGCommitments is required for EIP7594 blinded blocks"); + checkNotNull(blobKZGCommitments, "BlobKZGCommitments is required for Electra blinded blocks"); this.blobKZGCommitments = blobKZGCommitments; + checkNotNull(executionRequests, "ExecutionRequests is required for Electra blinded blocks"); + this.executionRequests = executionRequests; } - public BlindedBeaconBlockBodyEip7594( - final tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594 - .BlindedBeaconBlockBodyEip7594 + public BlindedBeaconBlockBodyElectra( + final tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra + .BlindedBeaconBlockBodyElectra blockBody) { super(blockBody); this.executionPayloadHeader = - new ExecutionPayloadHeaderEip7594(blockBody.getExecutionPayloadHeader()); + new ExecutionPayloadHeaderDeneb(blockBody.getExecutionPayloadHeader()); this.blsToExecutionChanges = blockBody.getBlsToExecutionChanges().stream().map(SignedBlsToExecutionChange::new).toList(); this.blobKZGCommitments = @@ -99,11 +107,12 @@ public BlindedBeaconBlockBodyEip7594( .map(SszKZGCommitment::getKZGCommitment) .map(KZGCommitment::new) .toList(); + this.executionRequests = new ExecutionRequests(blockBody.getExecutionRequests()); } @Override - public BlindedBeaconBlockBodySchemaEip7594 getBeaconBlockBodySchema(final SpecVersion spec) { - return (BlindedBeaconBlockBodySchemaEip7594) + public BlindedBeaconBlockBodySchemaElectra getBeaconBlockBodySchema(final SpecVersion spec) { + return (BlindedBeaconBlockBodySchemaElectra) spec.getSchemaDefinitions().getBlindedBeaconBlockBodySchema(); } @@ -125,6 +134,9 @@ public BeaconBlockBody asInternalBeaconBlockBody(final SpecVersion spec) { final SszListSchema blobKZGCommitmentsSchema = getBeaconBlockBodySchema(spec).getBlobKzgCommitmentsSchema(); + final ExecutionRequestsSchema executionRequestsSchema = + getBeaconBlockBodySchema(spec).getExecutionRequestsSchema(); + return super.asInternalBeaconBlockBody( spec, builder -> { @@ -140,6 +152,8 @@ public BeaconBlockBody asInternalBeaconBlockBody(final SpecVersion spec) { .map(KZGCommitment::asInternalKZGCommitment) .map(SszKZGCommitment::new) .collect(blobKZGCommitmentsSchema.collector())); + builder.executionRequests( + this.executionRequests.asInternalConsolidationRequest(executionRequestsSchema)); return SafeFuture.COMPLETE; }); } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/BlindedBlockEip7594.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/BlindedBlockElectra.java similarity index 81% rename from data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/BlindedBlockEip7594.java rename to data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/BlindedBlockElectra.java index 8030e100446..cd66627ae0a 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/BlindedBlockEip7594.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/BlindedBlockElectra.java @@ -11,7 +11,7 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.api.schema.eip7594; +package tech.pegasys.teku.api.schema.electra; import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonProperty; @@ -23,16 +23,16 @@ import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlockSchema; -public class BlindedBlockEip7594 extends BeaconBlockAltair { +public class BlindedBlockElectra extends BeaconBlockAltair { - public BlindedBlockEip7594(final BeaconBlock message) { + public BlindedBlockElectra(final BeaconBlock message) { super( message.getSlot(), message.getProposerIndex(), message.getParentRoot(), message.getStateRoot(), - new BlindedBeaconBlockBodyEip7594( - message.getBody().toBlindedVersionEip7594().orElseThrow())); + new BlindedBeaconBlockBodyElectra( + message.getBody().toBlindedVersionElectra().orElseThrow())); } @Override @@ -54,17 +54,17 @@ public BeaconBlock asInternalBeaconBlock(final Spec spec) { @JsonProperty("body") @Override - public BlindedBeaconBlockBodyEip7594 getBody() { - return (BlindedBeaconBlockBodyEip7594) body; + public BlindedBeaconBlockBodyElectra getBody() { + return (BlindedBeaconBlockBodyElectra) body; } @JsonCreator - public BlindedBlockEip7594( + public BlindedBlockElectra( @JsonProperty("slot") final UInt64 slot, @JsonProperty("proposer_index") final UInt64 proposerIndex, @JsonProperty("parent_root") final Bytes32 parentRoot, @JsonProperty("state_root") final Bytes32 stateRoot, - @JsonProperty("body") final BlindedBeaconBlockBodyEip7594 body) { + @JsonProperty("body") final BlindedBeaconBlockBodyElectra body) { super(slot, proposerIndex, parentRoot, stateRoot, body); } } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/ConsolidationRequest.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/ConsolidationRequest.java new file mode 100644 index 00000000000..d624b12a985 --- /dev/null +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/ConsolidationRequest.java @@ -0,0 +1,54 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.api.schema.electra; + +import com.fasterxml.jackson.annotation.JsonProperty; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.ethereum.execution.types.Eth1Address; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequestSchema; + +public class ConsolidationRequest { + + @JsonProperty("source_address") + private final Eth1Address sourceAddress; + + @JsonProperty("source_pubkey") + private final BLSPublicKey sourcePubkey; + + @JsonProperty("target_pubkey") + private final BLSPublicKey targetPubkey; + + public ConsolidationRequest( + @JsonProperty("source_address") final Eth1Address sourceAddress, + @JsonProperty("source_pubkey") final BLSPublicKey sourcePubkey, + @JsonProperty("target_pubkey") final BLSPublicKey targetPubkey) { + this.sourceAddress = sourceAddress; + this.sourcePubkey = sourcePubkey; + this.targetPubkey = targetPubkey; + } + + public ConsolidationRequest( + final tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequest + consolidationRequest) { + this.sourceAddress = + Eth1Address.fromBytes(consolidationRequest.getSourceAddress().getWrappedBytes()); + this.sourcePubkey = consolidationRequest.getSourcePubkey(); + this.targetPubkey = consolidationRequest.getTargetPubkey(); + } + + public final tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequest + asInternalConsolidationRequest(final ConsolidationRequestSchema schema) { + return schema.create(sourceAddress, sourcePubkey, targetPubkey); + } +} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/DepositRequest.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/DepositRequest.java new file mode 100644 index 00000000000..74d00337e36 --- /dev/null +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/DepositRequest.java @@ -0,0 +1,72 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.api.schema.electra; + +import com.fasterxml.jackson.annotation.JsonProperty; +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.api.schema.BLSPubKey; +import tech.pegasys.teku.api.schema.BLSSignature; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequestSchema; + +public class DepositRequest { + + @JsonProperty("pubkey") + private final BLSPubKey pubkey; + + @JsonProperty("withdrawal_credentials") + private final Bytes32 withdrawalCredentials; + + @JsonProperty("amount") + private final UInt64 amount; + + @JsonProperty("signature") + private final BLSSignature signature; + + @JsonProperty("index") + private final UInt64 index; + + public DepositRequest( + @JsonProperty("pubkey") final BLSPubKey pubkey, + @JsonProperty("withdrawal_credentials") final Bytes32 withdrawalCredentials, + @JsonProperty("amount") final UInt64 amount, + @JsonProperty("signature") final BLSSignature signature, + @JsonProperty("index") final UInt64 index) { + this.pubkey = pubkey; + this.withdrawalCredentials = withdrawalCredentials; + this.amount = amount; + this.signature = signature; + this.index = index; + } + + public DepositRequest( + final tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequest + depositRequest) { + this.pubkey = new BLSPubKey(depositRequest.getPubkey()); + this.withdrawalCredentials = depositRequest.getWithdrawalCredentials(); + this.amount = depositRequest.getAmount(); + this.signature = new BLSSignature(depositRequest.getSignature()); + this.index = depositRequest.getIndex(); + } + + public tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequest + asInternalDepositRequest(final DepositRequestSchema schema) { + return schema.create( + pubkey.asBLSPublicKey(), + withdrawalCredentials, + amount, + signature.asInternalBLSSignature(), + index); + } +} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/ExecutionRequests.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/ExecutionRequests.java new file mode 100644 index 00000000000..8d1ef190f57 --- /dev/null +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/ExecutionRequests.java @@ -0,0 +1,85 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.api.schema.electra; + +import com.fasterxml.jackson.annotation.JsonProperty; +import java.util.List; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequestSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequestSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequestSchema; + +public class ExecutionRequests { + + @JsonProperty("deposits") + private final List deposits; + + @JsonProperty("withdrawals") + private final List withdrawals; + + @JsonProperty("consolidations") + private final List consolidations; + + public ExecutionRequests( + @JsonProperty("deposits") final List deposits, + @JsonProperty("withdrawals") final List withdrawals, + @JsonProperty("consolidations") final List consolidations) { + this.deposits = deposits; + this.withdrawals = withdrawals; + this.consolidations = consolidations; + } + + public ExecutionRequests( + final tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests + executionRequests) { + this.deposits = executionRequests.getDeposits().stream().map(DepositRequest::new).toList(); + this.withdrawals = + executionRequests.getWithdrawals().stream().map(WithdrawalRequest::new).toList(); + this.consolidations = + executionRequests.getConsolidations().stream().map(ConsolidationRequest::new).toList(); + } + + public final tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests + asInternalConsolidationRequest(final ExecutionRequestsSchema schema) { + + final DepositRequestSchema depositSchema = + (DepositRequestSchema) schema.getDepositRequestsSchema().getElementSchema(); + final WithdrawalRequestSchema withdrawalSchema = + (WithdrawalRequestSchema) schema.getWithdrawalRequestsSchema().getElementSchema(); + final ConsolidationRequestSchema consolidationSchema = + (ConsolidationRequestSchema) schema.getConsolidationRequestsSchema().getElementSchema(); + + final List + depositsInternal = + deposits.stream() + .map(depositRequest -> depositRequest.asInternalDepositRequest(depositSchema)) + .toList(); + final List + withdrawalsInternal = + withdrawals.stream() + .map( + withdrawalRequest -> + withdrawalRequest.asInternalWithdrawalRequest(withdrawalSchema)) + .toList(); + final List< + tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequest> + consolidationsInternal = + consolidations.stream() + .map( + consolidationRequest -> + consolidationRequest.asInternalConsolidationRequest(consolidationSchema)) + .toList(); + return schema.create(depositsInternal, withdrawalsInternal, consolidationsInternal); + } +} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/PendingConsolidation.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/PendingConsolidation.java new file mode 100644 index 00000000000..16c0ac39e71 --- /dev/null +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/PendingConsolidation.java @@ -0,0 +1,59 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.api.schema.electra; + +import com.fasterxml.jackson.annotation.JsonProperty; +import java.util.Optional; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecVersion; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; + +public class PendingConsolidation { + @JsonProperty("source_index") + public final int sourceIndex; + + @JsonProperty("target_index") + public final int targetIndex; + + PendingConsolidation( + final @JsonProperty("source_index") int sourceIndex, + final @JsonProperty("target_index") int targetIndex) { + this.sourceIndex = sourceIndex; + this.targetIndex = targetIndex; + } + + public PendingConsolidation( + final tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingConsolidation + internalPendingConsolidation) { + this.sourceIndex = internalPendingConsolidation.getSourceIndex(); + this.targetIndex = internalPendingConsolidation.getTargetIndex(); + } + + public tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingConsolidation + asInternalPendingConsolidation(final SpecVersion spec) { + final Optional schemaDefinitionsElectra = + spec.getSchemaDefinitions().toVersionElectra(); + if (schemaDefinitionsElectra.isEmpty()) { + throw new IllegalArgumentException( + "Could not create PendingConsolidation for pre-electra spec"); + } + return schemaDefinitionsElectra + .get() + .getPendingConsolidationSchema() + .create( + SszUInt64.of(UInt64.valueOf(this.sourceIndex)), + SszUInt64.of(UInt64.valueOf(this.targetIndex))); + } +} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/PendingDeposit.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/PendingDeposit.java new file mode 100644 index 00000000000..3c14bfaf062 --- /dev/null +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/PendingDeposit.java @@ -0,0 +1,91 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.api.schema.electra; + +import static tech.pegasys.teku.api.schema.SchemaConstants.DESCRIPTION_BYTES96; + +import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.v3.oas.annotations.media.Schema; +import java.util.Optional; +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.api.schema.BLSSignature; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.ethereum.execution.types.Eth1Address; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszBytes32; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecVersion; +import tech.pegasys.teku.spec.datastructures.type.SszPublicKey; +import tech.pegasys.teku.spec.datastructures.type.SszSignature; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; + +public class PendingDeposit { + + @JsonProperty("pubkey") + private final BLSPublicKey publicKey; + + @JsonProperty("withdrawal_credentials") + private final Eth1Address withdrawalCredentials; + + @JsonProperty("amount") + public final UInt64 amount; + + @Schema(type = "string", format = "byte", description = DESCRIPTION_BYTES96) + public final BLSSignature signature; + + @JsonProperty("slot") + public final UInt64 slot; + + public PendingDeposit( + final @JsonProperty("pubkey") BLSPublicKey publicKey, + final @JsonProperty("withdrawal_credentials") Eth1Address withdrawalCredentials, + final @JsonProperty("amount") UInt64 amount, + final @JsonProperty("signature") BLSSignature signature, + final @JsonProperty("slot") UInt64 slot) { + this.publicKey = publicKey; + this.withdrawalCredentials = withdrawalCredentials; + this.amount = amount; + this.signature = signature; + this.slot = slot; + } + + public PendingDeposit( + final tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingDeposit + internalPendingDeposit) { + this.publicKey = internalPendingDeposit.getPublicKey(); + this.withdrawalCredentials = + Eth1Address.fromBytes(internalPendingDeposit.getWithdrawalCredentials()); + this.amount = internalPendingDeposit.getAmount(); + this.signature = new BLSSignature(internalPendingDeposit.getSignature()); + this.slot = internalPendingDeposit.getSlot(); + } + + public tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingDeposit + asInternalPendingDeposit(final SpecVersion spec) { + final Optional schemaDefinitionsElectra = + spec.getSchemaDefinitions().toVersionElectra(); + if (schemaDefinitionsElectra.isEmpty()) { + throw new IllegalArgumentException("Could not create PendingDeposit for pre-electra spec"); + } + return schemaDefinitionsElectra + .get() + .getPendingDepositSchema() + .create( + new SszPublicKey(publicKey), + SszBytes32.of(Bytes32.wrap(withdrawalCredentials.getWrappedBytes())), + SszUInt64.of(amount), + new SszSignature(signature.asInternalBLSSignature()), + SszUInt64.of(slot)); + } +} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/PendingPartialWithdrawal.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/PendingPartialWithdrawal.java new file mode 100644 index 00000000000..ca18e709f9f --- /dev/null +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/PendingPartialWithdrawal.java @@ -0,0 +1,66 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.api.schema.electra; + +import com.fasterxml.jackson.annotation.JsonProperty; +import java.util.Optional; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecVersion; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; + +public class PendingPartialWithdrawal { + @JsonProperty("index") + public final int index; + + @JsonProperty("amount") + public final UInt64 amount; + + @JsonProperty("withdrawable_epoch") + public final UInt64 withdrawableEpoch; + + public PendingPartialWithdrawal( + final @JsonProperty("index") int index, + final @JsonProperty("amount") UInt64 amount, + final @JsonProperty("withdrawable_epoch") UInt64 withdrawableEpoch) { + this.index = index; + this.amount = amount; + this.withdrawableEpoch = withdrawableEpoch; + } + + public PendingPartialWithdrawal( + final tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingPartialWithdrawal + pendingPartialWithdrawal) { + this.index = pendingPartialWithdrawal.getIndex(); + this.amount = pendingPartialWithdrawal.getAmount(); + this.withdrawableEpoch = pendingPartialWithdrawal.getWithdrawableEpoch(); + } + + public tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingPartialWithdrawal + asInternalPendingPartialWithdrawal(final SpecVersion spec) { + final Optional schemaDefinitionsElectra = + spec.getSchemaDefinitions().toVersionElectra(); + if (schemaDefinitionsElectra.isEmpty()) { + throw new IllegalArgumentException( + "Could not create PendingPartialWithdrawal for pre-electra spec"); + } + return schemaDefinitionsElectra + .get() + .getPendingPartialWithdrawalSchema() + .create( + SszUInt64.of(UInt64.valueOf(this.index)), + SszUInt64.of(this.amount), + SszUInt64.of(this.withdrawableEpoch)); + } +} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/SignedBeaconBlockEip7594.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/SignedBeaconBlockElectra.java similarity index 75% rename from data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/SignedBeaconBlockEip7594.java rename to data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/SignedBeaconBlockElectra.java index 9500de417d8..66ebc964edf 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/SignedBeaconBlockEip7594.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/SignedBeaconBlockElectra.java @@ -11,7 +11,7 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.api.schema.eip7594; +package tech.pegasys.teku.api.schema.electra; import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonProperty; @@ -19,23 +19,23 @@ import tech.pegasys.teku.api.schema.SignedBeaconBlock; import tech.pegasys.teku.api.schema.interfaces.SignedBlock; -public class SignedBeaconBlockEip7594 extends SignedBeaconBlock implements SignedBlock { - private final BeaconBlockEip7594 message; +public class SignedBeaconBlockElectra extends SignedBeaconBlock implements SignedBlock { + private final BeaconBlockElectra message; - public SignedBeaconBlockEip7594( + public SignedBeaconBlockElectra( final tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock internalBlock) { super(internalBlock); - this.message = new BeaconBlockEip7594(internalBlock.getMessage()); + this.message = new BeaconBlockElectra(internalBlock.getMessage()); } @Override - public BeaconBlockEip7594 getMessage() { + public BeaconBlockElectra getMessage() { return message; } @JsonCreator - public SignedBeaconBlockEip7594( - @JsonProperty("message") final BeaconBlockEip7594 message, + public SignedBeaconBlockElectra( + @JsonProperty("message") final BeaconBlockElectra message, @JsonProperty("signature") final BLSSignature signature) { super(message, signature); this.message = message; diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/SignedBlindedBeaconBlockEip7594.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/SignedBlindedBeaconBlockElectra.java similarity index 77% rename from data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/SignedBlindedBeaconBlockEip7594.java rename to data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/SignedBlindedBeaconBlockElectra.java index 35e57715f8b..b977a164978 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/eip7594/SignedBlindedBeaconBlockEip7594.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/SignedBlindedBeaconBlockElectra.java @@ -11,7 +11,7 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.api.schema.eip7594; +package tech.pegasys.teku.api.schema.electra; import static com.google.common.base.Preconditions.checkArgument; @@ -21,25 +21,25 @@ import tech.pegasys.teku.api.schema.SignedBeaconBlock; import tech.pegasys.teku.api.schema.interfaces.SignedBlock; -public class SignedBlindedBeaconBlockEip7594 extends SignedBeaconBlock implements SignedBlock { - private final BlindedBlockEip7594 message; +public class SignedBlindedBeaconBlockElectra extends SignedBeaconBlock implements SignedBlock { + private final BlindedBlockElectra message; - public SignedBlindedBeaconBlockEip7594( + public SignedBlindedBeaconBlockElectra( final tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock internalBlock) { super(internalBlock); checkArgument( internalBlock.getMessage().getBody().isBlinded(), "requires a signed blinded beacon block"); - this.message = new BlindedBlockEip7594(internalBlock.getMessage()); + this.message = new BlindedBlockElectra(internalBlock.getMessage()); } @Override - public BlindedBlockEip7594 getMessage() { + public BlindedBlockElectra getMessage() { return message; } @JsonCreator - public SignedBlindedBeaconBlockEip7594( - @JsonProperty("message") final BlindedBlockEip7594 message, + public SignedBlindedBeaconBlockElectra( + @JsonProperty("message") final BlindedBlockElectra message, @JsonProperty("signature") final BLSSignature signature) { super(message, signature); this.message = message; diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/WithdrawalRequest.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/WithdrawalRequest.java new file mode 100644 index 00000000000..b434fb3df31 --- /dev/null +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/electra/WithdrawalRequest.java @@ -0,0 +1,55 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.api.schema.electra; + +import com.fasterxml.jackson.annotation.JsonProperty; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.ethereum.execution.types.Eth1Address; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequestSchema; + +public class WithdrawalRequest { + + @JsonProperty("source_address") + private final Eth1Address sourceAddress; + + @JsonProperty("validator_pubkey") + private final BLSPublicKey validatorPubkey; + + @JsonProperty("amount") + private final UInt64 amount; + + public WithdrawalRequest( + @JsonProperty("source_address") final Eth1Address sourceAddress, + @JsonProperty("validator_pubkey") final BLSPublicKey validatorPubkey, + @JsonProperty("amount") final UInt64 amount) { + this.sourceAddress = sourceAddress; + this.validatorPubkey = validatorPubkey; + this.amount = amount; + } + + public WithdrawalRequest( + final tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequest + withdrawalRequest) { + this.sourceAddress = + Eth1Address.fromBytes(withdrawalRequest.getSourceAddress().getWrappedBytes()); + this.validatorPubkey = withdrawalRequest.getValidatorPubkey(); + this.amount = withdrawalRequest.getAmount(); + } + + public final tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequest + asInternalWithdrawalRequest(final WithdrawalRequestSchema schema) { + return schema.create(sourceAddress, validatorPubkey, amount); + } +} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/interfaces/SignedBlindedBlock.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/interfaces/SignedBlindedBlock.java index 639ae6bb926..3429bdb17a7 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/interfaces/SignedBlindedBlock.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/interfaces/SignedBlindedBlock.java @@ -18,6 +18,7 @@ import tech.pegasys.teku.api.schema.bellatrix.SignedBlindedBeaconBlockBellatrix; import tech.pegasys.teku.api.schema.capella.SignedBlindedBeaconBlockCapella; import tech.pegasys.teku.api.schema.deneb.SignedBlindedBeaconBlockDeneb; +import tech.pegasys.teku.api.schema.electra.SignedBlindedBeaconBlockElectra; import tech.pegasys.teku.api.schema.phase0.SignedBeaconBlockPhase0; @Schema( @@ -26,6 +27,7 @@ SignedBeaconBlockAltair.class, SignedBlindedBeaconBlockBellatrix.class, SignedBlindedBeaconBlockCapella.class, - SignedBlindedBeaconBlockDeneb.class + SignedBlindedBeaconBlockDeneb.class, + SignedBlindedBeaconBlockElectra.class }) public interface SignedBlindedBlock {} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/interfaces/SignedBlock.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/interfaces/SignedBlock.java index 1a73c683bdd..692e51d5efd 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/interfaces/SignedBlock.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/interfaces/SignedBlock.java @@ -18,6 +18,7 @@ import tech.pegasys.teku.api.schema.bellatrix.SignedBeaconBlockBellatrix; import tech.pegasys.teku.api.schema.capella.SignedBeaconBlockCapella; import tech.pegasys.teku.api.schema.deneb.SignedBeaconBlockDeneb; +import tech.pegasys.teku.api.schema.electra.SignedBeaconBlockElectra; import tech.pegasys.teku.api.schema.phase0.SignedBeaconBlockPhase0; @Schema( @@ -26,6 +27,7 @@ SignedBeaconBlockAltair.class, SignedBeaconBlockBellatrix.class, SignedBeaconBlockCapella.class, - SignedBeaconBlockDeneb.class + SignedBeaconBlockDeneb.class, + SignedBeaconBlockElectra.class }) public interface SignedBlock {} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/interfaces/State.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/interfaces/State.java index 648208a0edd..dcde87b11bf 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/interfaces/State.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/interfaces/State.java @@ -18,6 +18,7 @@ import tech.pegasys.teku.api.schema.bellatrix.BeaconStateBellatrix; import tech.pegasys.teku.api.schema.capella.BeaconStateCapella; import tech.pegasys.teku.api.schema.deneb.BeaconStateDeneb; +import tech.pegasys.teku.api.schema.electra.BeaconStateElectra; import tech.pegasys.teku.api.schema.phase0.BeaconStatePhase0; @Schema( @@ -26,6 +27,7 @@ BeaconStateAltair.class, BeaconStateBellatrix.class, BeaconStateCapella.class, - BeaconStateDeneb.class + BeaconStateDeneb.class, + BeaconStateElectra.class }) public interface State {} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/interfaces/UnsignedBlindedBlock.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/interfaces/UnsignedBlindedBlock.java index a302f6c76e2..3ca117efc16 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/interfaces/UnsignedBlindedBlock.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/interfaces/UnsignedBlindedBlock.java @@ -18,6 +18,7 @@ import tech.pegasys.teku.api.schema.bellatrix.BlindedBlockBellatrix; import tech.pegasys.teku.api.schema.capella.BlindedBlockCapella; import tech.pegasys.teku.api.schema.deneb.BlindedBlockDeneb; +import tech.pegasys.teku.api.schema.electra.BlindedBlockElectra; import tech.pegasys.teku.api.schema.phase0.BeaconBlockPhase0; @Schema( @@ -26,6 +27,7 @@ BeaconBlockAltair.class, BlindedBlockBellatrix.class, BlindedBlockCapella.class, - BlindedBlockDeneb.class + BlindedBlockDeneb.class, + BlindedBlockElectra.class }) public interface UnsignedBlindedBlock {} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/interfaces/UnsignedBlock.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/interfaces/UnsignedBlock.java index 764534b411a..df8b98b1761 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/interfaces/UnsignedBlock.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/interfaces/UnsignedBlock.java @@ -18,6 +18,7 @@ import tech.pegasys.teku.api.schema.bellatrix.BeaconBlockBellatrix; import tech.pegasys.teku.api.schema.capella.BeaconBlockCapella; import tech.pegasys.teku.api.schema.deneb.BeaconBlockDeneb; +import tech.pegasys.teku.api.schema.electra.BeaconBlockElectra; import tech.pegasys.teku.api.schema.phase0.BeaconBlockPhase0; @Schema( @@ -26,6 +27,7 @@ BeaconBlockAltair.class, BeaconBlockBellatrix.class, BeaconBlockCapella.class, - BeaconBlockDeneb.class + BeaconBlockDeneb.class, + BeaconBlockElectra.class }) public interface UnsignedBlock {} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/package-info.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/package-info.java new file mode 100644 index 00000000000..7a0ca0f4fc3 --- /dev/null +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/package-info.java @@ -0,0 +1,5 @@ +/** + * @deprecated As of release 2024.09.00, api.schema is not maintained any longer. + */ +@Deprecated +package tech.pegasys.teku.api.schema; diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/phase0/BeaconBlockPhase0.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/phase0/BeaconBlockPhase0.java index 75a93e4a6e4..ccd72331396 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/phase0/BeaconBlockPhase0.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/phase0/BeaconBlockPhase0.java @@ -23,7 +23,7 @@ @SuppressWarnings("JavaCase") public class BeaconBlockPhase0 extends BeaconBlock implements UnsignedBlock { - public BeaconBlockPhase0(tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock message) { + public BeaconBlockPhase0(final tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock message) { super( message.getSlot(), message.getProposerIndex(), diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/phase0/SignedBeaconBlockPhase0.java b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/phase0/SignedBeaconBlockPhase0.java index a8dcda150ca..8de51e43ef6 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/schema/phase0/SignedBeaconBlockPhase0.java +++ b/data/serializer/src/main/java/tech/pegasys/teku/api/schema/phase0/SignedBeaconBlockPhase0.java @@ -23,7 +23,7 @@ public class SignedBeaconBlockPhase0 extends SignedBeaconBlock implements SignedBlock { public SignedBeaconBlockPhase0( - tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock internalBlock) { + final tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock internalBlock) { super(internalBlock); } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/provider/BLSPubKeySerializer.java b/data/serializer/src/main/java/tech/pegasys/teku/provider/BLSPubKeySerializer.java deleted file mode 100644 index abd2f3b2557..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/provider/BLSPubKeySerializer.java +++ /dev/null @@ -1,29 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.provider; - -import com.fasterxml.jackson.core.JsonGenerator; -import com.fasterxml.jackson.databind.JsonSerializer; -import com.fasterxml.jackson.databind.SerializerProvider; -import java.io.IOException; -import java.util.Locale; -import tech.pegasys.teku.api.schema.BLSPubKey; - -public class BLSPubKeySerializer extends JsonSerializer { - @Override - public void serialize(BLSPubKey value, JsonGenerator gen, SerializerProvider serializers) - throws IOException { - gen.writeString(value.toHexString().toLowerCase(Locale.ROOT)); - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/provider/BLSSignatureDeserializer.java b/data/serializer/src/main/java/tech/pegasys/teku/provider/BLSSignatureDeserializer.java deleted file mode 100644 index 87e97fb0214..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/provider/BLSSignatureDeserializer.java +++ /dev/null @@ -1,27 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.provider; - -import com.fasterxml.jackson.core.JsonParser; -import com.fasterxml.jackson.databind.DeserializationContext; -import com.fasterxml.jackson.databind.JsonDeserializer; -import java.io.IOException; -import tech.pegasys.teku.api.schema.BLSSignature; - -public class BLSSignatureDeserializer extends JsonDeserializer { - @Override - public BLSSignature deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { - return BLSSignature.fromHexString(p.getValueAsString()); - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/provider/BLSSignatureSerializer.java b/data/serializer/src/main/java/tech/pegasys/teku/provider/BLSSignatureSerializer.java deleted file mode 100644 index 478a95eb760..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/provider/BLSSignatureSerializer.java +++ /dev/null @@ -1,29 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.provider; - -import com.fasterxml.jackson.core.JsonGenerator; -import com.fasterxml.jackson.databind.JsonSerializer; -import com.fasterxml.jackson.databind.SerializerProvider; -import java.io.IOException; -import java.util.Locale; -import tech.pegasys.teku.api.schema.BLSSignature; - -public class BLSSignatureSerializer extends JsonSerializer { - @Override - public void serialize(BLSSignature value, JsonGenerator gen, SerializerProvider serializers) - throws IOException { - gen.writeString(value.toHexString().toLowerCase(Locale.ROOT)); - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/provider/GetNewBlindedBlockResponseDeserializer.java b/data/serializer/src/main/java/tech/pegasys/teku/provider/GetNewBlindedBlockResponseDeserializer.java deleted file mode 100644 index 5debd77e176..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/provider/GetNewBlindedBlockResponseDeserializer.java +++ /dev/null @@ -1,60 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.provider; - -import com.fasterxml.jackson.core.JsonParser; -import com.fasterxml.jackson.databind.DeserializationContext; -import com.fasterxml.jackson.databind.JsonDeserializer; -import com.fasterxml.jackson.databind.JsonNode; -import com.fasterxml.jackson.databind.ObjectMapper; -import java.io.IOException; -import java.util.Locale; -import tech.pegasys.teku.api.response.v1.validator.GetNewBlindedBlockResponse; -import tech.pegasys.teku.api.schema.BeaconBlock; -import tech.pegasys.teku.api.schema.Version; -import tech.pegasys.teku.api.schema.altair.BeaconBlockAltair; -import tech.pegasys.teku.api.schema.bellatrix.BlindedBlockBellatrix; -import tech.pegasys.teku.api.schema.phase0.BeaconBlockPhase0; - -public class GetNewBlindedBlockResponseDeserializer - extends JsonDeserializer { - private final ObjectMapper mapper; - - public GetNewBlindedBlockResponseDeserializer(final ObjectMapper mapper) { - this.mapper = mapper; - } - - @Override - public GetNewBlindedBlockResponse deserialize( - final JsonParser jp, final DeserializationContext ctxt) throws IOException { - JsonNode node = jp.getCodec().readTree(jp); - final Version version = - Version.valueOf(node.findValue("version").asText().toLowerCase(Locale.ROOT)); - final BeaconBlock block; - switch (version) { - case bellatrix: - block = mapper.treeToValue(node.findValue("data"), BlindedBlockBellatrix.class); - break; - case altair: - block = mapper.treeToValue(node.findValue("data"), BeaconBlockAltair.class); - break; - case phase0: - block = mapper.treeToValue(node.findValue("data"), BeaconBlockPhase0.class); - break; - default: - throw new IOException("Milestone was not able to be decoded"); - } - return new GetNewBlindedBlockResponse(version, block); - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/provider/GetNewBlockResponseV1Deserializer.java b/data/serializer/src/main/java/tech/pegasys/teku/provider/GetNewBlockResponseV1Deserializer.java deleted file mode 100644 index 2b7a3eeee75..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/provider/GetNewBlockResponseV1Deserializer.java +++ /dev/null @@ -1,40 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.provider; - -import com.fasterxml.jackson.core.JsonParser; -import com.fasterxml.jackson.databind.DeserializationContext; -import com.fasterxml.jackson.databind.JsonDeserializer; -import com.fasterxml.jackson.databind.JsonNode; -import com.fasterxml.jackson.databind.ObjectMapper; -import java.io.IOException; -import tech.pegasys.teku.api.response.v1.validator.GetNewBlockResponse; -import tech.pegasys.teku.api.schema.BeaconBlock; -import tech.pegasys.teku.api.schema.phase0.BeaconBlockPhase0; - -public class GetNewBlockResponseV1Deserializer extends JsonDeserializer { - private final ObjectMapper mapper; - - public GetNewBlockResponseV1Deserializer(final ObjectMapper mapper) { - this.mapper = mapper; - } - - @Override - public GetNewBlockResponse deserialize(final JsonParser jp, final DeserializationContext ctxt) - throws IOException { - JsonNode node = jp.getCodec().readTree(jp); - final BeaconBlock block = mapper.treeToValue(node.findValue("data"), BeaconBlockPhase0.class); - return new GetNewBlockResponse(block); - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/provider/GetNewBlockResponseV2Deserializer.java b/data/serializer/src/main/java/tech/pegasys/teku/provider/GetNewBlockResponseV2Deserializer.java deleted file mode 100644 index 75c9af5af95..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/provider/GetNewBlockResponseV2Deserializer.java +++ /dev/null @@ -1,59 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.provider; - -import com.fasterxml.jackson.core.JsonParser; -import com.fasterxml.jackson.databind.DeserializationContext; -import com.fasterxml.jackson.databind.JsonDeserializer; -import com.fasterxml.jackson.databind.JsonNode; -import com.fasterxml.jackson.databind.ObjectMapper; -import java.io.IOException; -import java.util.Locale; -import tech.pegasys.teku.api.response.v2.validator.GetNewBlockResponseV2; -import tech.pegasys.teku.api.schema.BeaconBlock; -import tech.pegasys.teku.api.schema.Version; -import tech.pegasys.teku.api.schema.altair.BeaconBlockAltair; -import tech.pegasys.teku.api.schema.bellatrix.BeaconBlockBellatrix; -import tech.pegasys.teku.api.schema.phase0.BeaconBlockPhase0; - -public class GetNewBlockResponseV2Deserializer extends JsonDeserializer { - private final ObjectMapper mapper; - - public GetNewBlockResponseV2Deserializer(final ObjectMapper mapper) { - this.mapper = mapper; - } - - @Override - public GetNewBlockResponseV2 deserialize(final JsonParser jp, final DeserializationContext ctxt) - throws IOException { - JsonNode node = jp.getCodec().readTree(jp); - final Version version = - Version.valueOf(node.findValue("version").asText().toLowerCase(Locale.ROOT)); - final BeaconBlock block; - switch (version) { - case bellatrix: - block = mapper.treeToValue(node.findValue("data"), BeaconBlockBellatrix.class); - break; - case altair: - block = mapper.treeToValue(node.findValue("data"), BeaconBlockAltair.class); - break; - case phase0: - block = mapper.treeToValue(node.findValue("data"), BeaconBlockPhase0.class); - break; - default: - throw new IOException("Milestone was not able to be decoded"); - } - return new GetNewBlockResponseV2(version, block); - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/provider/GetStateResponseV2Deserializer.java b/data/serializer/src/main/java/tech/pegasys/teku/provider/GetStateResponseV2Deserializer.java deleted file mode 100644 index 23e71d11bdb..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/provider/GetStateResponseV2Deserializer.java +++ /dev/null @@ -1,56 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.provider; - -import com.fasterxml.jackson.core.JsonParser; -import com.fasterxml.jackson.databind.DeserializationContext; -import com.fasterxml.jackson.databind.JsonDeserializer; -import com.fasterxml.jackson.databind.JsonNode; -import com.fasterxml.jackson.databind.ObjectMapper; -import java.io.IOException; -import java.util.Locale; -import tech.pegasys.teku.api.response.v2.debug.GetStateResponseV2; -import tech.pegasys.teku.api.schema.BeaconState; -import tech.pegasys.teku.api.schema.Version; -import tech.pegasys.teku.api.schema.altair.BeaconStateAltair; -import tech.pegasys.teku.api.schema.phase0.BeaconStatePhase0; - -public class GetStateResponseV2Deserializer extends JsonDeserializer { - private final ObjectMapper mapper; - - public GetStateResponseV2Deserializer(final ObjectMapper mapper) { - this.mapper = mapper; - } - - @Override - public GetStateResponseV2 deserialize(final JsonParser jp, final DeserializationContext ctxt) - throws IOException { - JsonNode node = jp.getCodec().readTree(jp); - final Version version = - Version.valueOf(node.findValue("version").asText().toLowerCase(Locale.ROOT)); - final boolean executionOptimistic = node.findValue("execution_optimistic").asBoolean(); - final BeaconState state; - switch (version) { - case altair: - state = mapper.treeToValue(node.findValue("data"), BeaconStateAltair.class); - break; - case phase0: - state = mapper.treeToValue(node.findValue("data"), BeaconStatePhase0.class); - break; - default: - throw new IOException("Milestone was not able to be decoded"); - } - return new GetStateResponseV2(version, executionOptimistic, state); - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/provider/JsonProvider.java b/data/serializer/src/main/java/tech/pegasys/teku/provider/JsonProvider.java deleted file mode 100644 index 1e320d991dc..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/provider/JsonProvider.java +++ /dev/null @@ -1,135 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.provider; - -import com.fasterxml.jackson.core.JsonProcessingException; -import com.fasterxml.jackson.core.Version; -import com.fasterxml.jackson.databind.DeserializationFeature; -import com.fasterxml.jackson.databind.ObjectMapper; -import com.fasterxml.jackson.databind.module.SimpleModule; -import org.apache.tuweni.bytes.Bytes; -import org.apache.tuweni.bytes.Bytes32; -import org.apache.tuweni.bytes.Bytes48; -import org.apache.tuweni.units.bigints.UInt256; -import tech.pegasys.teku.api.response.v1.validator.GetNewBlindedBlockResponse; -import tech.pegasys.teku.api.response.v1.validator.GetNewBlockResponse; -import tech.pegasys.teku.api.response.v2.debug.GetStateResponseV2; -import tech.pegasys.teku.api.response.v2.validator.GetNewBlockResponseV2; -import tech.pegasys.teku.api.schema.BLSPubKey; -import tech.pegasys.teku.api.schema.BLSSignature; -import tech.pegasys.teku.api.schema.KZGCommitment; -import tech.pegasys.teku.api.schema.KZGProof; -import tech.pegasys.teku.bls.BLSPublicKey; -import tech.pegasys.teku.ethereum.execution.types.Eth1Address; -import tech.pegasys.teku.ethereum.jackson.Eth1AddressDeserializer; -import tech.pegasys.teku.infrastructure.bytes.Bytes20; -import tech.pegasys.teku.infrastructure.bytes.Bytes4; -import tech.pegasys.teku.infrastructure.jackson.deserializers.bytes.ByteArrayDeserializer; -import tech.pegasys.teku.infrastructure.jackson.deserializers.bytes.ByteArraySerializer; -import tech.pegasys.teku.infrastructure.jackson.deserializers.bytes.Bytes20Deserializer; -import tech.pegasys.teku.infrastructure.jackson.deserializers.bytes.Bytes20Serializer; -import tech.pegasys.teku.infrastructure.jackson.deserializers.bytes.Bytes32Deserializer; -import tech.pegasys.teku.infrastructure.jackson.deserializers.bytes.Bytes48KeyDeserializer; -import tech.pegasys.teku.infrastructure.jackson.deserializers.bytes.Bytes4Deserializer; -import tech.pegasys.teku.infrastructure.jackson.deserializers.bytes.Bytes4Serializer; -import tech.pegasys.teku.infrastructure.jackson.deserializers.bytes.BytesDeserializer; -import tech.pegasys.teku.infrastructure.jackson.deserializers.bytes.BytesSerializer; -import tech.pegasys.teku.infrastructure.jackson.deserializers.bytes.DoubleDeserializer; -import tech.pegasys.teku.infrastructure.jackson.deserializers.bytes.DoubleSerializer; -import tech.pegasys.teku.infrastructure.jackson.deserializers.uints.UInt256Deserializer; -import tech.pegasys.teku.infrastructure.jackson.deserializers.uints.UInt256Serializer; -import tech.pegasys.teku.infrastructure.jackson.deserializers.uints.UInt64Deserializer; -import tech.pegasys.teku.infrastructure.jackson.deserializers.uints.UInt64Serializer; -import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; - -public class JsonProvider { - private void addTekuMappers() { - SimpleModule module = new SimpleModule("TekuJson", new Version(1, 0, 0, null, null, null)); - - module.addSerializer(SszBitvector.class, new SszBitvectorSerializer()); - - module.addSerializer(BLSPubKey.class, new BLSPubKeySerializer()); - module.addDeserializer(BLSPubKey.class, new BLSPubKeyDeserializer()); - module.addDeserializer(BLSPublicKey.class, new BLSPublicKeyDeserializer()); - module.addSerializer(BLSPublicKey.class, new BLSPublicKeySerializer()); - module.addDeserializer(BLSSignature.class, new BLSSignatureDeserializer()); - module.addSerializer(BLSSignature.class, new BLSSignatureSerializer()); - - module.addKeyDeserializer(Bytes48.class, new Bytes48KeyDeserializer()); - - module.addDeserializer(Bytes32.class, new Bytes32Deserializer()); - module.addDeserializer(Bytes4.class, new Bytes4Deserializer()); - module.addSerializer(Bytes4.class, new Bytes4Serializer()); - module.addDeserializer(Bytes20.class, new Bytes20Deserializer()); - module.addDeserializer(Eth1Address.class, new Eth1AddressDeserializer()); - - module.addSerializer(Bytes20.class, new Bytes20Serializer()); - module.addDeserializer(Bytes.class, new BytesDeserializer()); - module.addSerializer(Bytes.class, new BytesSerializer()); - module.addDeserializer(Double.class, new DoubleDeserializer()); - module.addSerializer(Double.class, new DoubleSerializer()); - - module.addDeserializer(UInt64.class, new UInt64Deserializer()); - module.addSerializer(UInt64.class, new UInt64Serializer()); - - module.addDeserializer(UInt256.class, new UInt256Deserializer()); - module.addSerializer(UInt256.class, new UInt256Serializer()); - - module.addSerializer(byte[].class, new ByteArraySerializer()); - module.addDeserializer(byte[].class, new ByteArrayDeserializer()); - - module.addDeserializer( - GetNewBlockResponse.class, new GetNewBlockResponseV1Deserializer(objectMapper)); - - module.addDeserializer( - GetNewBlockResponseV2.class, new GetNewBlockResponseV2Deserializer(objectMapper)); - module.addDeserializer( - GetStateResponseV2.class, new GetStateResponseV2Deserializer(objectMapper)); - module.addDeserializer( - GetNewBlindedBlockResponse.class, new GetNewBlindedBlockResponseDeserializer(objectMapper)); - - module.addSerializer(KZGCommitment.class, new KZGCommitmentSerializer()); - module.addDeserializer(KZGCommitment.class, new KZGCommitmentDeserializer()); - - module.addSerializer(KZGProof.class, new KZGProofSerializer()); - module.addDeserializer(KZGProof.class, new KZGProofDeserializer()); - - objectMapper.registerModule(module); - } - - private final ObjectMapper objectMapper; - - public JsonProvider() { - objectMapper = new ObjectMapper(); - objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); - addTekuMappers(); - } - - public String objectToJSON(T object) throws JsonProcessingException { - return objectMapper.writeValueAsString(object); - } - - public String objectToPrettyJSON(T object) throws JsonProcessingException { - return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(object); - } - - public T jsonToObject(String json, Class clazz) throws JsonProcessingException { - return objectMapper.readValue(json, clazz); - } - - public ObjectMapper getObjectMapper() { - return objectMapper; - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/provider/KZGCommitmentDeserializer.java b/data/serializer/src/main/java/tech/pegasys/teku/provider/KZGCommitmentDeserializer.java deleted file mode 100644 index 29c75ef3fd1..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/provider/KZGCommitmentDeserializer.java +++ /dev/null @@ -1,29 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.provider; - -import com.fasterxml.jackson.core.JsonParser; -import com.fasterxml.jackson.databind.DeserializationContext; -import com.fasterxml.jackson.databind.JsonDeserializer; -import java.io.IOException; -import org.apache.tuweni.bytes.Bytes; -import tech.pegasys.teku.api.schema.KZGCommitment; - -public class KZGCommitmentDeserializer extends JsonDeserializer { - @Override - public KZGCommitment deserialize(final JsonParser p, final DeserializationContext ctxt) - throws IOException { - return new KZGCommitment(Bytes.fromHexString(p.getValueAsString())); - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/provider/KZGCommitmentSerializer.java b/data/serializer/src/main/java/tech/pegasys/teku/provider/KZGCommitmentSerializer.java deleted file mode 100644 index ef219cfe2fc..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/provider/KZGCommitmentSerializer.java +++ /dev/null @@ -1,30 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.provider; - -import com.fasterxml.jackson.core.JsonGenerator; -import com.fasterxml.jackson.databind.JsonSerializer; -import com.fasterxml.jackson.databind.SerializerProvider; -import java.io.IOException; -import java.util.Locale; -import tech.pegasys.teku.api.schema.KZGCommitment; - -public class KZGCommitmentSerializer extends JsonSerializer { - @Override - public void serialize( - final KZGCommitment value, final JsonGenerator gen, final SerializerProvider serializers) - throws IOException { - gen.writeString(value.toHexString().toLowerCase(Locale.ROOT)); - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/provider/KZGProofDeserializer.java b/data/serializer/src/main/java/tech/pegasys/teku/provider/KZGProofDeserializer.java deleted file mode 100644 index 48a221df1e7..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/provider/KZGProofDeserializer.java +++ /dev/null @@ -1,29 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.provider; - -import com.fasterxml.jackson.core.JsonParser; -import com.fasterxml.jackson.databind.DeserializationContext; -import com.fasterxml.jackson.databind.JsonDeserializer; -import java.io.IOException; -import org.apache.tuweni.bytes.Bytes; -import tech.pegasys.teku.api.schema.KZGProof; - -public class KZGProofDeserializer extends JsonDeserializer { - @Override - public KZGProof deserialize(final JsonParser p, final DeserializationContext ignore) - throws IOException { - return new KZGProof(Bytes.fromHexString(p.getValueAsString())); - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/provider/KZGProofSerializer.java b/data/serializer/src/main/java/tech/pegasys/teku/provider/KZGProofSerializer.java deleted file mode 100644 index 60343505098..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/provider/KZGProofSerializer.java +++ /dev/null @@ -1,30 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.provider; - -import com.fasterxml.jackson.core.JsonGenerator; -import com.fasterxml.jackson.databind.JsonSerializer; -import com.fasterxml.jackson.databind.SerializerProvider; -import java.io.IOException; -import java.util.Locale; -import tech.pegasys.teku.api.schema.KZGProof; - -public class KZGProofSerializer extends JsonSerializer { - @Override - public void serialize( - final KZGProof value, final JsonGenerator gen, final SerializerProvider serializers) - throws IOException { - gen.writeString(value.toHexString().toLowerCase(Locale.ROOT)); - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/provider/SszBitvectorSerializer.java b/data/serializer/src/main/java/tech/pegasys/teku/provider/SszBitvectorSerializer.java deleted file mode 100644 index 5d948b6e5bb..00000000000 --- a/data/serializer/src/main/java/tech/pegasys/teku/provider/SszBitvectorSerializer.java +++ /dev/null @@ -1,29 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.provider; - -import com.fasterxml.jackson.core.JsonGenerator; -import com.fasterxml.jackson.databind.JsonSerializer; -import com.fasterxml.jackson.databind.SerializerProvider; -import java.io.IOException; -import java.util.Locale; -import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; - -public class SszBitvectorSerializer extends JsonSerializer { - @Override - public void serialize(SszBitvector value, JsonGenerator gen, SerializerProvider serializers) - throws IOException { - gen.writeString(value.sszSerialize().toHexString().toLowerCase(Locale.ROOT)); - } -} diff --git a/data/serializer/src/property-test/java/tech/pegasys/teku/provider/JsonProviderPropertyTest.java b/data/serializer/src/property-test/java/tech/pegasys/teku/provider/JsonProviderPropertyTest.java deleted file mode 100644 index bd1a3e55d54..00000000000 --- a/data/serializer/src/property-test/java/tech/pegasys/teku/provider/JsonProviderPropertyTest.java +++ /dev/null @@ -1,427 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.provider; - -import static java.nio.charset.StandardCharsets.UTF_8; -import static org.apache.commons.lang3.StringEscapeUtils.unescapeJava; -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.assertEquals; - -import com.fasterxml.jackson.core.JsonProcessingException; -import java.lang.reflect.Constructor; -import java.util.Arrays; -import java.util.Locale; -import java.util.Map; -import net.jqwik.api.ForAll; -import net.jqwik.api.Property; -import net.jqwik.api.constraints.IntRange; -import net.jqwik.api.constraints.Size; -import org.apache.commons.lang3.ArrayUtils; -import org.apache.tuweni.bytes.Bytes; -import org.apache.tuweni.bytes.Bytes32; -import org.apache.tuweni.units.bigints.UInt256; -import tech.pegasys.teku.api.schema.Attestation; -import tech.pegasys.teku.api.schema.AttestationData; -import tech.pegasys.teku.api.schema.AttesterSlashing; -import tech.pegasys.teku.api.schema.BLSPubKey; -import tech.pegasys.teku.api.schema.BLSSignature; -import tech.pegasys.teku.api.schema.BeaconBlockHeader; -import tech.pegasys.teku.api.schema.BeaconState; -import tech.pegasys.teku.api.schema.Checkpoint; -import tech.pegasys.teku.api.schema.Deposit; -import tech.pegasys.teku.api.schema.DepositData; -import tech.pegasys.teku.api.schema.Eth1Data; -import tech.pegasys.teku.api.schema.Fork; -import tech.pegasys.teku.api.schema.IndexedAttestation; -import tech.pegasys.teku.api.schema.KZGCommitment; -import tech.pegasys.teku.api.schema.PendingAttestation; -import tech.pegasys.teku.api.schema.ProposerSlashing; -import tech.pegasys.teku.api.schema.SignedBeaconBlock; -import tech.pegasys.teku.api.schema.Validator; -import tech.pegasys.teku.api.schema.VoluntaryExit; -import tech.pegasys.teku.api.schema.altair.BeaconStateAltair; -import tech.pegasys.teku.api.schema.altair.SignedBeaconBlockAltair; -import tech.pegasys.teku.api.schema.bellatrix.BeaconStateBellatrix; -import tech.pegasys.teku.api.schema.bellatrix.SignedBeaconBlockBellatrix; -import tech.pegasys.teku.api.schema.capella.BeaconStateCapella; -import tech.pegasys.teku.api.schema.capella.SignedBeaconBlockCapella; -import tech.pegasys.teku.api.schema.deneb.BeaconStateDeneb; -import tech.pegasys.teku.api.schema.deneb.SignedBeaconBlockDeneb; -import tech.pegasys.teku.api.schema.eip7594.BeaconStateEip7594; -import tech.pegasys.teku.api.schema.eip7594.SignedBeaconBlockEip7594; -import tech.pegasys.teku.api.schema.phase0.BeaconStatePhase0; -import tech.pegasys.teku.api.schema.phase0.SignedBeaconBlockPhase0; -import tech.pegasys.teku.infrastructure.json.JsonUtil; -import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; -import tech.pegasys.teku.infrastructure.ssz.SszData; -import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.SpecMilestone; -import tech.pegasys.teku.spec.TestSpecFactory; -import tech.pegasys.teku.spec.networks.Eth2Network; -import tech.pegasys.teku.spec.propertytest.suppliers.SpecSupplier; -import tech.pegasys.teku.spec.util.DataStructureUtil; - -public class JsonProviderPropertyTest { - private static final String Q = "\""; - private final JsonProvider jsonProvider = new JsonProvider(); - - private static final Map> - SIGNED_BEACON_BLOCK_CLASS_MAP = - Map.of( - SpecMilestone.PHASE0, - SignedBeaconBlockPhase0.class, - SpecMilestone.ALTAIR, - SignedBeaconBlockAltair.class, - SpecMilestone.BELLATRIX, - SignedBeaconBlockBellatrix.class, - SpecMilestone.CAPELLA, - SignedBeaconBlockCapella.class, - SpecMilestone.DENEB, - SignedBeaconBlockDeneb.class, - SpecMilestone.EIP7594, - SignedBeaconBlockEip7594.class); - - private static final Map> BEACON_STATE_CLASS_MAP = - Map.of( - SpecMilestone.PHASE0, - BeaconStatePhase0.class, - SpecMilestone.ALTAIR, - BeaconStateAltair.class, - SpecMilestone.BELLATRIX, - BeaconStateBellatrix.class, - SpecMilestone.CAPELLA, - BeaconStateCapella.class, - SpecMilestone.DENEB, - BeaconStateDeneb.class, - SpecMilestone.EIP7594, - BeaconStateEip7594.class); - - @Property - void roundTripBytes32(@ForAll @Size(32) final byte[] value) throws JsonProcessingException { - Bytes32 data = Bytes32.wrap(value); - String serialized = jsonProvider.objectToJSON(data); - assertEquals(Q + data.toHexString().toLowerCase(Locale.ROOT) + Q, serialized); - Bytes32 deserialize = jsonProvider.jsonToObject(serialized, Bytes32.class); - assertEquals(data, deserialize); - } - - @Property - void roundTripUInt256(@ForAll @Size(32) final byte[] value) throws JsonProcessingException { - final Bytes bytes = Bytes.wrap(value); - final UInt256 original = UInt256.fromBytes(bytes); - final String serialized = jsonProvider.objectToJSON(original); - assertEquals(serialized, Q + original.toDecimalString() + Q); - final UInt256 deserialized = jsonProvider.jsonToObject(serialized, UInt256.class); - assertEquals(deserialized, original); - } - - @Property - void roundTripUInt64(@ForAll final long value) throws JsonProcessingException { - final UInt64 original = UInt64.fromLongBits(value); - final String serialized = jsonProvider.objectToJSON(original); - assertEquals(serialized, Q + original.toString() + Q); - final UInt64 deserialized = jsonProvider.jsonToObject(serialized, UInt64.class); - assertEquals(deserialized, original); - } - - @Property - void serializeString(@ForAll final String original) throws JsonProcessingException { - final String serialized = jsonProvider.objectToJSON(original); - assertThat(unescapeJava(serialized).getBytes(UTF_8)) - .isEqualTo((Q + original + Q).getBytes(UTF_8)); - } - - @Property - void roundTripByteArray(@ForAll final byte[] original) throws JsonProcessingException { - final String serialized = jsonProvider.objectToJSON(original); - assertEquals(serialized, byteArrayToUnsignedStringWithQuotesAndNoSpaces(original)); - final byte[] deserialized = jsonProvider.jsonToObject(serialized, byte[].class); - assertThat(deserialized).isEqualTo(original); - } - - static String byteArrayToUnsignedStringWithQuotesAndNoSpaces(final byte[] bytes) { - return Arrays.toString( - Arrays.asList(ArrayUtils.toObject(bytes)).stream() - .map(Byte::toUnsignedInt) - .map(s -> Q + s + Q) - .toArray()) - .replace(" ", ""); - } - - @Property - void roundTripBlsPubKey(@ForAll final int seed, @ForAll(supplier = SpecSupplier.class) Spec spec) - throws JsonProcessingException { - final DataStructureUtil dataStructureUtil = new DataStructureUtil(seed, spec); - final BLSPubKey original = new BLSPubKey(dataStructureUtil.randomPublicKey()); - final String serialized = jsonProvider.objectToJSON(original); - final BLSPubKey deserialized = jsonProvider.jsonToObject(serialized, BLSPubKey.class); - assertThat(deserialized).isEqualTo(original); - } - - @Property - void roundTripBlsSignature( - @ForAll final int seed, @ForAll(supplier = SpecSupplier.class) Spec spec) - throws JsonProcessingException { - final DataStructureUtil dataStructureUtil = new DataStructureUtil(seed, spec); - final BLSSignature original = new BLSSignature(dataStructureUtil.randomSignature()); - final String serialized = jsonProvider.objectToJSON(original); - final BLSSignature deserialized = jsonProvider.jsonToObject(serialized, BLSSignature.class); - assertThat(deserialized).isEqualTo(original); - } - - @Property - public void roundTripBitVector( - @ForAll final int seed, - @ForAll(supplier = SpecSupplier.class) Spec spec, - @ForAll @IntRange(min = 1, max = 1000) final int size) - throws JsonProcessingException { - final DataStructureUtil dataStructureUtil = new DataStructureUtil(seed, spec); - final SszBitvector original = dataStructureUtil.randomSszBitvector(size); - final String serialized = jsonProvider.objectToJSON(original); - final SszBitvector deserialized = - JsonUtil.parse(serialized, original.getSchema().getJsonTypeDefinition()); - assertThat(deserialized).isEqualTo(original); - } - - @Property - public void roundTripFork( - @ForAll final int seed, @ForAll(supplier = SpecSupplier.class) Spec spec) - throws JsonProcessingException { - final DataStructureUtil dataStructureUtil = new DataStructureUtil(seed, spec); - final Fork original = new Fork(dataStructureUtil.randomFork()); - final String serialized = jsonProvider.objectToJSON(original); - final Object deserialized = jsonProvider.jsonToObject(serialized, Fork.class); - assertThat(deserialized).isEqualToComparingFieldByField(original); - } - - @Property - public void roundTripCheckpoint( - @ForAll final int seed, - @ForAll(supplier = SpecSupplier.class) Spec spec, - @ForAll final long epoch) - throws JsonProcessingException { - final DataStructureUtil dataStructureUtil = new DataStructureUtil(seed, spec); - final Checkpoint original = - new Checkpoint(dataStructureUtil.randomCheckpoint(UInt64.fromLongBits(epoch))); - final String serialized = jsonProvider.objectToJSON(original); - final Object deserialized = jsonProvider.jsonToObject(serialized, Checkpoint.class); - assertThat(deserialized).isEqualToComparingFieldByField(original); - } - - @Property - public void roundTripValidator( - @ForAll final int seed, @ForAll(supplier = SpecSupplier.class) Spec spec) - throws JsonProcessingException { - final DataStructureUtil dataStructureUtil = new DataStructureUtil(seed, spec); - final Validator original = new Validator(dataStructureUtil.randomValidator()); - final String serialized = jsonProvider.objectToJSON(original); - final Object deserialized = jsonProvider.jsonToObject(serialized, Validator.class); - assertThat(deserialized).isEqualToComparingFieldByField(original); - } - - @Property - public void roundTripAttestationData( - @ForAll final int seed, @ForAll(supplier = SpecSupplier.class) Spec spec) - throws JsonProcessingException { - final DataStructureUtil dataStructureUtil = new DataStructureUtil(seed, spec); - final AttestationData original = new AttestationData(dataStructureUtil.randomAttestationData()); - final String serialized = jsonProvider.objectToJSON(original); - final Object deserialized = jsonProvider.jsonToObject(serialized, AttestationData.class); - assertThat(deserialized).isEqualToComparingFieldByField(original); - } - - @Property - public void roundTripIndexedAttestation( - @ForAll final int seed, @ForAll(supplier = SpecSupplier.class) Spec spec) - throws JsonProcessingException { - final DataStructureUtil dataStructureUtil = new DataStructureUtil(seed, spec); - final IndexedAttestation original = - new IndexedAttestation(dataStructureUtil.randomIndexedAttestation()); - final String serialized = jsonProvider.objectToJSON(original); - final Object deserialized = jsonProvider.jsonToObject(serialized, IndexedAttestation.class); - assertThat(deserialized).isEqualToComparingFieldByField(original); - } - - @Property - public void roundTripPendingAttestation(@ForAll final int seed, @ForAll final Eth2Network network) - throws JsonProcessingException { - final SpecMilestone specMilestone = SpecMilestone.PHASE0; - final Spec spec = TestSpecFactory.create(specMilestone, network); - final DataStructureUtil dataStructureUtil = new DataStructureUtil(seed, spec); - final PendingAttestation original = - new PendingAttestation(dataStructureUtil.randomPendingAttestation()); - final String serialized = jsonProvider.objectToJSON(original); - final Object deserialized = jsonProvider.jsonToObject(serialized, PendingAttestation.class); - assertThat(deserialized).isEqualToComparingFieldByField(original); - } - - @Property - public void roundTripEth1Data( - @ForAll final int seed, @ForAll(supplier = SpecSupplier.class) Spec spec) - throws JsonProcessingException { - final DataStructureUtil dataStructureUtil = new DataStructureUtil(seed, spec); - final Eth1Data original = new Eth1Data(dataStructureUtil.randomEth1Data()); - final String serialized = jsonProvider.objectToJSON(original); - final Object deserialized = jsonProvider.jsonToObject(serialized, Eth1Data.class); - assertThat(deserialized).isEqualToComparingFieldByField(original); - } - - @Property - public void roundTripDepositData( - @ForAll final int seed, @ForAll(supplier = SpecSupplier.class) Spec spec) - throws JsonProcessingException { - final DataStructureUtil dataStructureUtil = new DataStructureUtil(seed, spec); - final DepositData original = new DepositData(dataStructureUtil.randomDepositData()); - final String serialized = jsonProvider.objectToJSON(original); - final Object deserialized = jsonProvider.jsonToObject(serialized, DepositData.class); - assertThat(deserialized).isEqualToComparingFieldByField(original); - } - - @Property - public void roundTripBeaconBlockHeader( - @ForAll final int seed, @ForAll(supplier = SpecSupplier.class) Spec spec) - throws JsonProcessingException { - final DataStructureUtil dataStructureUtil = new DataStructureUtil(seed, spec); - final BeaconBlockHeader original = - new BeaconBlockHeader(dataStructureUtil.randomBeaconBlockHeader()); - final String serialized = jsonProvider.objectToJSON(original); - final Object deserialized = jsonProvider.jsonToObject(serialized, BeaconBlockHeader.class); - assertThat(deserialized).isEqualToComparingFieldByField(original); - } - - @Property - public void roundTripBeaconProposerSlashing( - @ForAll final int seed, @ForAll(supplier = SpecSupplier.class) Spec spec) - throws JsonProcessingException { - final DataStructureUtil dataStructureUtil = new DataStructureUtil(seed, spec); - final ProposerSlashing original = - new ProposerSlashing(dataStructureUtil.randomProposerSlashing()); - final String serialized = jsonProvider.objectToJSON(original); - final Object deserialized = jsonProvider.jsonToObject(serialized, ProposerSlashing.class); - assertThat(deserialized).isEqualToComparingFieldByField(original); - } - - @Property - public void roundTripBeaconAttesterSlashing( - @ForAll final int seed, @ForAll(supplier = SpecSupplier.class) Spec spec) - throws JsonProcessingException { - final DataStructureUtil dataStructureUtil = new DataStructureUtil(seed, spec); - final AttesterSlashing original = - new AttesterSlashing(dataStructureUtil.randomAttesterSlashing()); - final String serialized = jsonProvider.objectToJSON(original); - final Object deserialized = jsonProvider.jsonToObject(serialized, AttesterSlashing.class); - assertThat(deserialized).isEqualToComparingFieldByField(original); - } - - @Property - public void roundTripBeaconAttestation( - @ForAll final int seed, @ForAll(supplier = SpecSupplier.class) Spec spec) - throws JsonProcessingException { - final DataStructureUtil dataStructureUtil = new DataStructureUtil(seed, spec); - final Attestation original = new Attestation(dataStructureUtil.randomAttestation()); - final String serialized = jsonProvider.objectToJSON(original); - final Object deserialized = jsonProvider.jsonToObject(serialized, Attestation.class); - assertThat(deserialized).isEqualToComparingFieldByField(original); - } - - @Property - public void roundTripDeposit( - @ForAll final int seed, @ForAll(supplier = SpecSupplier.class) Spec spec) - throws JsonProcessingException { - final DataStructureUtil dataStructureUtil = new DataStructureUtil(seed, spec); - final Deposit original = new Deposit(dataStructureUtil.randomDeposit()); - final String serialized = jsonProvider.objectToJSON(original); - final Object deserialized = jsonProvider.jsonToObject(serialized, Deposit.class); - assertThat(deserialized).isEqualToComparingFieldByField(original); - } - - @Property - public void roundTripVoluntaryExit( - @ForAll final int seed, @ForAll(supplier = SpecSupplier.class) Spec spec) - throws JsonProcessingException { - final DataStructureUtil dataStructureUtil = new DataStructureUtil(seed, spec); - final VoluntaryExit original = new VoluntaryExit(dataStructureUtil.randomVoluntaryExit()); - final String serialized = jsonProvider.objectToJSON(original); - final Object deserialized = jsonProvider.jsonToObject(serialized, VoluntaryExit.class); - assertThat(deserialized).isEqualToComparingFieldByField(original); - } - - @Property(tries = 100) - public void roundTripSignedBeaconBlock( - @ForAll final int seed, - @ForAll(supplier = SpecSupplier.class) Spec spec, - @ForAll final long slot, - @ForAll @Size(32) final byte[] parentRoot, - @ForAll @Size(32) final byte[] stateRoot, - @ForAll final boolean isFull) - throws Exception { - final DataStructureUtil dataStructureUtil = new DataStructureUtil(seed, spec); - final Class clazz = - SIGNED_BEACON_BLOCK_CLASS_MAP.get(spec.getForkSchedule().getHighestSupportedMilestone()); - final Constructor constructor = - clazz.getConstructor(tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock.class); - final Object original = - constructor.newInstance( - dataStructureUtil.signedBlock( - dataStructureUtil.randomBeaconBlock( - UInt64.fromLongBits(slot), - Bytes32.wrap(parentRoot), - Bytes32.wrap(stateRoot), - isFull))); - final String serialized = jsonProvider.objectToJSON(original); - final Object deserialized = jsonProvider.jsonToObject(serialized, clazz); - assertThat(deserialized).isEqualToComparingFieldByField(original); - } - - @Property(tries = 100) - public void roundTripBeaconState( - @ForAll final int seed, - @ForAll(supplier = SpecSupplier.class) Spec spec, - @ForAll @IntRange(max = 1000) final int validatorCount, - @ForAll @IntRange(max = 1000) final int numItemsInSSZLists) - throws Exception { - final SpecMilestone specMilestone = spec.getForkSchedule().getHighestSupportedMilestone(); - final DataStructureUtil dataStructureUtil = new DataStructureUtil(seed, spec); - final Class clazz = BEACON_STATE_CLASS_MAP.get(specMilestone); - final Constructor constructor = - clazz.getConstructor( - tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState.class); - final BeaconState original = - constructor.newInstance( - dataStructureUtil.randomBeaconState(validatorCount, numItemsInSSZLists)); - final DeserializableTypeDefinition stateTypeDefinition = - spec.forMilestone(specMilestone) - .getSchemaDefinitions() - .getBeaconStateSchema() - .getJsonTypeDefinition(); - - final String serialized = jsonProvider.objectToJSON(original); - final SszData deserialized = JsonUtil.parse(serialized, stateTypeDefinition); - assertThat(deserialized.hashTreeRoot()) - .isEqualTo(original.asInternalBeaconState(spec).hashTreeRoot()); - } - - @Property - void roundTripKZGCommitment(@ForAll final int seed) throws JsonProcessingException { - final SpecMilestone specMilestone = SpecMilestone.DENEB; - final Spec spec = TestSpecFactory.create(specMilestone, Eth2Network.MINIMAL); - final DataStructureUtil dataStructureUtil = new DataStructureUtil(seed, spec); - final KZGCommitment original = new KZGCommitment(dataStructureUtil.randomKZGCommitment()); - final String serialized = jsonProvider.objectToJSON(original); - final KZGCommitment deserialized = jsonProvider.jsonToObject(serialized, KZGCommitment.class); - assertThat(deserialized).isEqualTo(original); - } -} diff --git a/data/serializer/src/test/java/tech/pegasys/teku/api/request/v1/validator/BeaconCommitteeSubscriptionRequestTest.java b/data/serializer/src/test/java/tech/pegasys/teku/api/request/v1/validator/BeaconCommitteeSubscriptionRequestTest.java deleted file mode 100644 index 446cd2b05d7..00000000000 --- a/data/serializer/src/test/java/tech/pegasys/teku/api/request/v1/validator/BeaconCommitteeSubscriptionRequestTest.java +++ /dev/null @@ -1,41 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.api.request.v1.validator; - -import static org.assertj.core.api.Assertions.assertThat; - -import org.junit.jupiter.api.Assertions; -import org.junit.jupiter.api.Test; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; - -public class BeaconCommitteeSubscriptionRequestTest { - - @Test - public void shouldFailInitializingIfValidatorIndexIsNull() { - final NullPointerException exception = - Assertions.assertThrows( - NullPointerException.class, - () -> new BeaconCommitteeSubscriptionRequest(null, "1", UInt64.ONE, UInt64.ONE, true)); - assertThat(exception).hasMessage("validator_index should be specified"); - } - - @Test - public void shouldFailInitializingIfCommitteeIndexIsNull() { - final NullPointerException exception = - Assertions.assertThrows( - NullPointerException.class, - () -> new BeaconCommitteeSubscriptionRequest("1", null, UInt64.ONE, UInt64.ONE, true)); - assertThat(exception).hasMessage("committee_index should be specified"); - } -} diff --git a/data/serializer/src/test/java/tech/pegasys/teku/api/response/v1/HeadEventTest.java b/data/serializer/src/test/java/tech/pegasys/teku/api/response/v1/HeadEventTest.java deleted file mode 100644 index 388a9a9dd05..00000000000 --- a/data/serializer/src/test/java/tech/pegasys/teku/api/response/v1/HeadEventTest.java +++ /dev/null @@ -1,66 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.api.response.v1; - -import static org.assertj.core.api.Assertions.assertThat; - -import org.apache.tuweni.bytes.Bytes32; -import org.junit.jupiter.api.Test; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.provider.JsonProvider; -import tech.pegasys.teku.spec.TestSpecFactory; -import tech.pegasys.teku.spec.util.DataStructureUtil; - -class HeadEventTest { - - private final DataStructureUtil dataStructureUtil = - new DataStructureUtil(TestSpecFactory.createDefault()); - - private final JsonProvider jsonProvider = new JsonProvider(); - - @Test - void shouldParseFromEventWithoutDependentRoots() throws Exception { - final String json = - "{\"slot\":\"4666673844721362956\",\"block\":\"0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef\",\"state\":\"0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e\",\"epoch_transition\":true}\n"; - final HeadEvent result = jsonProvider.jsonToObject(json, HeadEvent.class); - assertThat(result) - .isEqualTo( - new HeadEvent( - UInt64.valueOf(4666673844721362956L), - Bytes32.fromHexString( - "0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef"), - Bytes32.fromHexString( - "0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e"), - true, - null, - null, - null)); - } - - @Test - void shouldRoundTripJsonParsing() throws Exception { - final HeadEvent input = - new HeadEvent( - dataStructureUtil.randomUInt64(), - dataStructureUtil.randomBytes32(), - dataStructureUtil.randomBytes32(), - true, - false, - dataStructureUtil.randomBytes32(), - dataStructureUtil.randomBytes32()); - final String json = jsonProvider.objectToJSON(input); - final HeadEvent result = jsonProvider.jsonToObject(json, HeadEvent.class); - assertThat(result).isEqualTo(input); - } -} diff --git a/data/serializer/src/test/java/tech/pegasys/teku/api/schema/BeaconStateTest.java b/data/serializer/src/test/java/tech/pegasys/teku/api/schema/BeaconStateTest.java index 649ba439c37..584b6e08867 100644 --- a/data/serializer/src/test/java/tech/pegasys/teku/api/schema/BeaconStateTest.java +++ b/data/serializer/src/test/java/tech/pegasys/teku/api/schema/BeaconStateTest.java @@ -20,7 +20,7 @@ import tech.pegasys.teku.api.schema.bellatrix.BeaconStateBellatrix; import tech.pegasys.teku.api.schema.capella.BeaconStateCapella; import tech.pegasys.teku.api.schema.deneb.BeaconStateDeneb; -import tech.pegasys.teku.api.schema.eip7594.BeaconStateEip7594; +import tech.pegasys.teku.api.schema.electra.BeaconStateElectra; import tech.pegasys.teku.api.schema.phase0.BeaconStatePhase0; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.TestSpecContext; @@ -30,7 +30,7 @@ public class BeaconStateTest { @TestTemplate - public void shouldConvertToInternalObject(SpecContext ctx) { + public void shouldConvertToInternalObject(final SpecContext ctx) { final tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState beaconStateInternal = ctx.getDataStructureUtil().randomBeaconState(); final Spec spec = ctx.getSpec(); @@ -41,7 +41,7 @@ public void shouldConvertToInternalObject(SpecContext ctx) { case BELLATRIX -> new BeaconStateBellatrix(beaconStateInternal); case CAPELLA -> new BeaconStateCapella(beaconStateInternal); case DENEB -> new BeaconStateDeneb(beaconStateInternal); - case EIP7594 -> new BeaconStateEip7594(beaconStateInternal); + case ELECTRA, FULU -> new BeaconStateElectra(beaconStateInternal); }; assertThat(beaconState.asInternalBeaconState(spec)).isEqualTo(beaconStateInternal); diff --git a/data/serializer/src/test/java/tech/pegasys/teku/api/schema/SignedBeaconBlockTest.java b/data/serializer/src/test/java/tech/pegasys/teku/api/schema/SignedBeaconBlockTest.java index 2233d9e8292..30d59e3a600 100644 --- a/data/serializer/src/test/java/tech/pegasys/teku/api/schema/SignedBeaconBlockTest.java +++ b/data/serializer/src/test/java/tech/pegasys/teku/api/schema/SignedBeaconBlockTest.java @@ -23,7 +23,7 @@ class SignedBeaconBlockTest { @TestTemplate - public void shouldConvertSchemaToInternalCorrectly(SpecContext ctx) { + public void shouldConvertSchemaToInternalCorrectly(final SpecContext ctx) { final tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock internalBlock = ctx.getDataStructureUtil().randomSignedBeaconBlock(1); diff --git a/data/serializer/src/test/java/tech/pegasys/teku/provider/JsonProviderTest.java b/data/serializer/src/test/java/tech/pegasys/teku/provider/JsonProviderTest.java deleted file mode 100644 index 0d093028591..00000000000 --- a/data/serializer/src/test/java/tech/pegasys/teku/provider/JsonProviderTest.java +++ /dev/null @@ -1,183 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.provider; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.assertThatThrownBy; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import com.fasterxml.jackson.core.JsonProcessingException; -import java.util.Locale; -import org.apache.tuweni.bytes.Bytes; -import org.apache.tuweni.bytes.Bytes32; -import org.apache.tuweni.units.bigints.UInt256; -import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.schema.BeaconState; -import tech.pegasys.teku.api.schema.phase0.BeaconStatePhase0; -import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.TestSpecFactory; -import tech.pegasys.teku.spec.util.DataStructureUtil; - -class JsonProviderTest { - private static final String Q = "\""; - private final DataStructureUtil dataStructureUtil = - new DataStructureUtil(TestSpecFactory.createDefault()); - private final JsonProvider jsonProvider = new JsonProvider(); - - @Test - public void bytes32ShouldSerializeToJsonAndBack() throws JsonProcessingException { - Bytes32 data = Bytes32.random(); - String serialized = jsonProvider.objectToJSON(data); - assertEquals(Q + data.toHexString().toLowerCase(Locale.ROOT) + Q, serialized); - - Bytes32 deserialize = jsonProvider.jsonToObject(serialized, Bytes32.class); - assertEquals(data, deserialize); - } - - @Test - public void minUInt256ShouldSerializeAndDeserialize() throws JsonProcessingException { - final UInt256 data = UInt256.ZERO; - final String serialized = jsonProvider.objectToJSON(data); - assertEquals(serialized, Q + "0" + Q); - final UInt256 data2 = jsonProvider.jsonToObject(serialized, UInt256.class); - assertEquals(data2, data); - } - - @Test - public void UInt64ShouldSerializeAndDeserialize() throws JsonProcessingException { - final UInt64 data = dataStructureUtil.randomUInt64(); - final String serialized = jsonProvider.objectToJSON(data); - assertEquals(serialized, Q + data.toString() + Q); - final UInt64 data2 = jsonProvider.jsonToObject(serialized, UInt64.class); - assertEquals(data2, data); - } - - @Test - public void maxUInt64ShouldSerializeAndDeserialize() throws JsonProcessingException { - final UInt64 data = UInt64.MAX_VALUE; - final String serialized = jsonProvider.objectToJSON(data); - assertEquals(serialized, Q + data.toString() + Q); - final UInt64 data2 = jsonProvider.jsonToObject(serialized, UInt64.class); - assertEquals(data2, data); - } - - @Test - public void UInt256ShouldSerializeAndDeserialize() throws JsonProcessingException { - final UInt256 data = dataStructureUtil.randomUInt256(); - final String serialized = jsonProvider.objectToJSON(data); - assertEquals(serialized, Q + data.toDecimalString() + Q); - final UInt256 data2 = jsonProvider.jsonToObject(serialized, UInt256.class); - assertEquals(data2, data); - } - - @Test - public void maxUInt256ShouldSerializeAndDeserialize() throws JsonProcessingException { - final UInt256 data = UInt256.MAX_VALUE; - final String serialized = jsonProvider.objectToJSON(data); - assertEquals(serialized, Q + data.toDecimalString() + Q); - final UInt256 data2 = jsonProvider.jsonToObject(serialized, UInt256.class); - assertEquals(data2, data); - } - - @Test - public void UInt64ShouldDeserializeNonHex() throws JsonProcessingException { - final UInt256 data = jsonProvider.jsonToObject("10", UInt256.class); - assertEquals(data, UInt256.fromHexString("0xa")); - } - - @Test - public void bitVectorShouldSerializeAsSsz() throws JsonProcessingException { - final int bitvectorSize = 40; - final SszBitvector data = dataStructureUtil.randomSszBitvector(bitvectorSize); - final String asJson = jsonProvider.objectToJSON(data); - final String hexData = jsonProvider.jsonToObject(asJson, String.class); - final SszBitvector asData = data.getSchema().sszDeserialize(Bytes.fromHexString(hexData)); - - assertThat(data).isEqualTo(asData); - assertThat(asData.size()).isEqualTo(bitvectorSize); - } - - @Test - public void doubleShouldSerializeAndDeserialize() throws JsonProcessingException { - Double fewDecimals = 1.4; - final String serializedFewDecimals = jsonProvider.objectToJSON(fewDecimals); - final Double deserializedFewDecimals = - jsonProvider.jsonToObject(serializedFewDecimals, Double.class); - assertThat(fewDecimals).isEqualTo(deserializedFewDecimals); - - Double multipleDecimals = 1.41234; - Double truncatedMultipleDecimals = 1.4123; - final String serializedMultipleDecimals = jsonProvider.objectToJSON(multipleDecimals); - final Double deserializedMultipleDecimals = - jsonProvider.jsonToObject(serializedMultipleDecimals, Double.class); - assertThat(truncatedMultipleDecimals).isEqualTo(deserializedMultipleDecimals); - } - - @Test - public void stringShouldSerializeToJson() throws JsonProcessingException { - String data = "test"; - assertEquals(Q + data + Q, jsonProvider.objectToJSON(data)); - } - - @Test - public void byteArrayShouldSerializeToJson() throws JsonProcessingException { - final byte[] bytes = Bytes.fromHexString("0x00A0F0FF").toArray(); - assertEquals("[\"0\",\"160\",\"240\",\"255\"]", jsonProvider.objectToJSON(bytes)); - } - - @Test - public void zeroLengthByteArrayShouldSerializeToJson() throws JsonProcessingException { - assertEquals("[]", jsonProvider.objectToJSON(new byte[0])); - } - - @Test - public void deserializeToBytesShouldAllowZeroLengthArray() throws JsonProcessingException { - assertThat(jsonProvider.jsonToObject("[]", byte[].class)).isEqualTo(new byte[0]); - } - - @Test - public void deserializeToBytesShouldHandleSignedBits() throws JsonProcessingException { - assertThat(jsonProvider.jsonToObject("[\"0\",\"160\",\"240\",\"255\"]", byte[].class)) - .isEqualTo(Bytes.fromHexString("0x00A0F0FF").toArray()); - } - - @Test - public void deserializeToBytesShouldRejectValuesThatAreTooLarge() { - assertThatThrownBy(() -> jsonProvider.jsonToObject("[\"256\"]", byte[].class)) - .hasMessage("Expected \"256\" to be a byte value between 0 and 255 inclusive"); - } - - @Test - public void deserializeToBytesShouldRejectValuesThatAreBelowZero() { - assertThatThrownBy(() -> jsonProvider.jsonToObject("[\"-999\"]", byte[].class)) - .hasMessage("Expected \"-999\" to be a byte value between 0 and 255 inclusive"); - } - - @Test - public void deserializeToBytesShouldRejectValuesThatNotNumeric() { - assertThatThrownBy(() -> jsonProvider.jsonToObject("[\"a\"]", byte[].class)) - .hasMessage("Expected \"a\" to be a byte value between 0 and 255 inclusive"); - } - - @Test - void beaconStateJsonTest() throws JsonProcessingException { - tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState stateInternal = - dataStructureUtil.randomBeaconState(UInt64.valueOf(16)); - BeaconState state = new BeaconStatePhase0(stateInternal); - String jsonState = jsonProvider.objectToJSON(state); - assertTrue(jsonState.length() > 0); - } -} diff --git a/eth-benchmark-tests/build.gradle b/eth-benchmark-tests/build.gradle index cd91412cdac..5114ae3208a 100644 --- a/eth-benchmark-tests/build.gradle +++ b/eth-benchmark-tests/build.gradle @@ -17,10 +17,10 @@ dependencies { implementation testFixtures(project(':ethereum:statetransition')) jmhImplementation testFixtures(project(':eth-benchmark-tests')) - implementation 'org.apache.tuweni:tuweni-bytes' + implementation 'io.tmio:tuweni-bytes' jmhImplementation project(':infrastructure:crypto') - jmhImplementation 'org.apache.tuweni:tuweni-ssz' + jmhImplementation 'io.tmio:tuweni-ssz' jmhImplementation testFixtures(project(':ethereum:weaksubjectivity')) jmhImplementation testFixtures(project(':infrastructure:async')) @@ -34,6 +34,6 @@ dependencies { testFixturesImplementation testFixtures(project(':ethereum:statetransition')) testFixturesImplementation testFixtures(project(':storage')) - testFixturesImplementation 'org.apache.tuweni:tuweni-bytes' - testFixturesImplementation 'org.apache.tuweni:tuweni-ssz' + testFixturesImplementation 'io.tmio:tuweni-bytes' + testFixturesImplementation 'io.tmio:tuweni-ssz' } \ No newline at end of file diff --git a/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/EpochTransitionBenchmark.java b/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/EpochTransitionBenchmark.java index c98f81fd97d..6caeac08de4 100644 --- a/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/EpochTransitionBenchmark.java +++ b/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/EpochTransitionBenchmark.java @@ -36,6 +36,8 @@ import tech.pegasys.teku.benchmarks.util.CustomRunner; import tech.pegasys.teku.bls.BLSKeyPair; import tech.pegasys.teku.bls.BLSSignatureVerifier; +import tech.pegasys.teku.infrastructure.async.AsyncRunner; +import tech.pegasys.teku.infrastructure.async.DelayedExecutorAsyncRunner; import tech.pegasys.teku.infrastructure.async.eventthread.InlineEventThread; import tech.pegasys.teku.infrastructure.metrics.StubMetricsSystem; import tech.pegasys.teku.infrastructure.ssz.collections.SszMutableUInt64List; @@ -72,6 +74,7 @@ @Threads(1) @Fork(1) public class EpochTransitionBenchmark { + AsyncRunner asyncRunner; Spec spec; WeakSubjectivityValidator wsValidator; RecentChainData recentChainData; @@ -100,6 +103,7 @@ public void init() throws Exception { AbstractBlockProcessor.depositSignatureVerifier = BLSSignatureVerifier.NO_OP; spec = TestSpecFactory.createMainnetAltair(); + asyncRunner = DelayedExecutorAsyncRunner.create(); String blocksFile = "/blocks/blocks_epoch_" + spec.getSlotsPerEpoch(UInt64.ZERO) @@ -131,6 +135,7 @@ public void init() throws Exception { blockImporter = new BlockImporter( + asyncRunner, spec, receivedBlockEventsChannelPublisher, recentChainData, diff --git a/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/NoOpValidatorIndexCacheBenchmark.java b/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/NoOpValidatorIndexCacheBenchmark.java new file mode 100644 index 00000000000..f2e4fcbfb3c --- /dev/null +++ b/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/NoOpValidatorIndexCacheBenchmark.java @@ -0,0 +1,70 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.benchmarks; + +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Fork; +import org.openjdk.jmh.annotations.Level; +import org.openjdk.jmh.annotations.Measurement; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.annotations.State; +import org.openjdk.jmh.annotations.Warmup; +import org.openjdk.jmh.infra.Blackhole; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.common.ValidatorIndexCache; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +@Fork(1) +@State(Scope.Thread) +@BenchmarkMode(Mode.Throughput) +@Warmup(iterations = 0) +@Measurement(iterations = 5) +public class NoOpValidatorIndexCacheBenchmark { + + private static final int VALIDATORS_MAX_IDX = 399_999; + private static final Spec SPEC = TestSpecFactory.createMinimalDeneb(); + + private static final DataStructureUtil dataStructureUtil = new DataStructureUtil(0, SPEC); + private static final BeaconState STATE = + dataStructureUtil.randomBeaconState(VALIDATORS_MAX_IDX + 1); + private static final ValidatorIndexCache CACHE = ValidatorIndexCache.NO_OP_INSTANCE; + private static final BLSPublicKey RANDOM_KEY = dataStructureUtil.randomPublicKey(); + + @Setup(Level.Trial) + public void doSetup() { + CACHE.getValidatorIndex(STATE, STATE.getValidators().get(VALIDATORS_MAX_IDX).getPublicKey()); + } + + @Benchmark + public void cacheHit(Blackhole bh) { + bh.consume( + CACHE.getValidatorIndex( + STATE, + STATE + .getValidators() + .get(dataStructureUtil.randomPositiveInt(VALIDATORS_MAX_IDX)) + .getPublicKey())); + } + + @Benchmark + public void cacheMiss(Blackhole bh) { + bh.consume(CACHE.getValidatorIndex(STATE, RANDOM_KEY)); + } +} diff --git a/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/ProfilingRun.java b/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/ProfilingRun.java index 735a6fe25c1..4e2d92dde26 100644 --- a/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/ProfilingRun.java +++ b/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/ProfilingRun.java @@ -31,6 +31,8 @@ import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.bls.BLSSignatureVerifier; import tech.pegasys.teku.bls.BLSTestUtil; +import tech.pegasys.teku.infrastructure.async.AsyncRunner; +import tech.pegasys.teku.infrastructure.async.DelayedExecutorAsyncRunner; import tech.pegasys.teku.infrastructure.async.eventthread.InlineEventThread; import tech.pegasys.teku.infrastructure.metrics.StubMetricsSystem; import tech.pegasys.teku.infrastructure.unsigned.UInt64; @@ -63,6 +65,7 @@ public class ProfilingRun { private Spec spec = TestSpecFactory.createMainnetPhase0(); private final MetricsSystem metricsSystem = new StubMetricsSystem(); + private final AsyncRunner asyncRunner = DelayedExecutorAsyncRunner.create(); @Disabled @Test @@ -111,6 +114,7 @@ public void importBlocks() throws Exception { BeaconChainUtil.create(spec, recentChainData, validatorKeys, false); BlockImporter blockImporter = new BlockImporter( + asyncRunner, spec, receivedBlockEventsChannelPublisher, recentChainData, @@ -203,6 +207,7 @@ public void importBlocksMemProfiling() throws Exception { metricsSystem); BlockImporter blockImporter = new BlockImporter( + asyncRunner, spec, receivedBlockEventsChannelPublisher, recentChainData, diff --git a/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/TransitionBenchmark.java b/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/TransitionBenchmark.java index bdddc99d8f7..295b2062c8b 100644 --- a/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/TransitionBenchmark.java +++ b/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/TransitionBenchmark.java @@ -33,6 +33,8 @@ import tech.pegasys.teku.benchmarks.gen.KeyFileGenerator; import tech.pegasys.teku.bls.BLSKeyPair; import tech.pegasys.teku.bls.BLSSignatureVerifier; +import tech.pegasys.teku.infrastructure.async.AsyncRunner; +import tech.pegasys.teku.infrastructure.async.DelayedExecutorAsyncRunner; import tech.pegasys.teku.infrastructure.async.eventthread.InlineEventThread; import tech.pegasys.teku.infrastructure.metrics.StubMetricsSystem; import tech.pegasys.teku.infrastructure.unsigned.UInt64; @@ -79,6 +81,7 @@ public abstract class TransitionBenchmark { public void init() throws Exception { spec = TestSpecFactory.createMainnetAltair(); AbstractBlockProcessor.depositSignatureVerifier = BLSSignatureVerifier.NO_OP; + AsyncRunner asyncRunner = DelayedExecutorAsyncRunner.create(); String blocksFile = "/blocks/blocks_epoch_" @@ -109,6 +112,7 @@ public void init() throws Exception { blockImporter = new BlockImporter( + asyncRunner, spec, receivedBlockEventsChannelPublisher, recentChainData, diff --git a/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/ValidatorIndexCacheBenchmark.java b/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/ValidatorIndexCacheBenchmark.java new file mode 100644 index 00000000000..3d2e4b8225b --- /dev/null +++ b/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/ValidatorIndexCacheBenchmark.java @@ -0,0 +1,69 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.benchmarks; + +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Fork; +import org.openjdk.jmh.annotations.Level; +import org.openjdk.jmh.annotations.Measurement; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.annotations.State; +import org.openjdk.jmh.annotations.Warmup; +import org.openjdk.jmh.infra.Blackhole; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.common.ValidatorIndexCache; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +@Fork(1) +@State(Scope.Thread) +@BenchmarkMode(Mode.Throughput) +@Warmup(iterations = 2) +@Measurement(iterations = 5) +public class ValidatorIndexCacheBenchmark { + static final int VALIDATORS_MAX_IDX = 399_999; + private static final Spec SPEC = TestSpecFactory.createMinimalDeneb(); + + private static final DataStructureUtil dataStructureUtil = new DataStructureUtil(0, SPEC); + private static final BeaconState STATE = + dataStructureUtil.randomBeaconState(VALIDATORS_MAX_IDX + 1); + private static final ValidatorIndexCache CACHE = new ValidatorIndexCache(); + private static final BLSPublicKey RANDOM_KEY = dataStructureUtil.randomPublicKey(); + + @Setup(Level.Trial) + public void doSetup() { + CACHE.getValidatorIndex(STATE, STATE.getValidators().get(VALIDATORS_MAX_IDX).getPublicKey()); + } + + @Benchmark + public void cacheHit(Blackhole bh) { + bh.consume( + CACHE.getValidatorIndex( + STATE, + STATE + .getValidators() + .get(dataStructureUtil.randomPositiveInt(VALIDATORS_MAX_IDX)) + .getPublicKey())); + } + + @Benchmark + public void cacheMiss(Blackhole bh) { + bh.consume(CACHE.getValidatorIndex(STATE, RANDOM_KEY)); + } +} diff --git a/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/ssz/SszAttestationBenchmark.java b/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/ssz/SszAttestationBenchmark.java index 3fde20a8ec2..c96985746c8 100644 --- a/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/ssz/SszAttestationBenchmark.java +++ b/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/ssz/SszAttestationBenchmark.java @@ -19,8 +19,8 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; import tech.pegasys.teku.spec.util.DataStructureUtil; public class SszAttestationBenchmark extends SszAbstractContainerBenchmark { @@ -39,7 +39,7 @@ protected Attestation createContainer() { } @Override - protected AttestationSchema getContainerType() { + protected AttestationSchema getContainerType() { return spec.getGenesisSchemaDefinitions().getAttestationSchema(); } diff --git a/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/util/CustomRunner.java b/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/util/CustomRunner.java index 808d102bb81..004eb5e5f77 100644 --- a/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/util/CustomRunner.java +++ b/eth-benchmark-tests/src/jmh/java/tech/pegasys/teku/benchmarks/util/CustomRunner.java @@ -42,8 +42,8 @@ public double getNanosPerOperations() { new Blackhole( "Today's password is swordfish. I understand instantiating Blackholes directly is dangerous."); private final Map> benches = new LinkedHashMap<>(); - private int runIterations = 10; - private int runsCount = 10; + private final int runIterations; + private final int runsCount; public CustomRunner(int runIterations, int runsCount) { this.runIterations = runIterations; diff --git a/eth-benchmark-tests/src/testFixtures/java/tech/pegasys/teku/benchmarks/gen/BlockArchiveGenerator.java b/eth-benchmark-tests/src/testFixtures/java/tech/pegasys/teku/benchmarks/gen/BlockArchiveGenerator.java index 9c97bd76c2d..57cd09bd1c0 100644 --- a/eth-benchmark-tests/src/testFixtures/java/tech/pegasys/teku/benchmarks/gen/BlockArchiveGenerator.java +++ b/eth-benchmark-tests/src/testFixtures/java/tech/pegasys/teku/benchmarks/gen/BlockArchiveGenerator.java @@ -51,7 +51,7 @@ public class BlockArchiveGenerator { private final ValidatorsUtil validatorsUtil; private final BeaconStateAccessors beaconStateAccessors; - public static void main(String[] args) throws Exception { + public static void main(final String[] args) throws Exception { // default values if nothing is specified int validatorCount = 32_768; int epochCount = 50; diff --git a/eth-benchmark-tests/src/testFixtures/java/tech/pegasys/teku/benchmarks/gen/BlockIO.java b/eth-benchmark-tests/src/testFixtures/java/tech/pegasys/teku/benchmarks/gen/BlockIO.java index 6483e025236..f7ced608a87 100644 --- a/eth-benchmark-tests/src/testFixtures/java/tech/pegasys/teku/benchmarks/gen/BlockIO.java +++ b/eth-benchmark-tests/src/testFixtures/java/tech/pegasys/teku/benchmarks/gen/BlockIO.java @@ -42,7 +42,7 @@ public static class Reader private final ObjectInputStream inputStream; private final Spec spec; - Reader(ObjectInputStream inputStream, final Spec spec) { + Reader(final ObjectInputStream inputStream, final Spec spec) { this.inputStream = inputStream; this.spec = spec; } @@ -71,7 +71,7 @@ public Iterator iterator() { } @SuppressWarnings("EmptyCatch") - public List readAll(int limit) { + public List readAll(final int limit) { try { return StreamSupport.stream(spliterator(), false).limit(limit).collect(Collectors.toList()); } finally { @@ -86,7 +86,7 @@ public List readAll(int limit) { public static class Writer implements AutoCloseable, Consumer { private final ObjectOutputStream outputStream; - Writer(ObjectOutputStream outputStream) { + Writer(final ObjectOutputStream outputStream) { this.outputStream = outputStream; } @@ -96,7 +96,7 @@ public void close() throws Exception { } @Override - public void accept(SignedBeaconBlock block) { + public void accept(final SignedBeaconBlock block) { try { Bytes bytes = block.sszSerialize(); outputStream.writeInt(bytes.size()); @@ -108,7 +108,7 @@ public void accept(SignedBeaconBlock block) { } } - public static Writer createFileWriter(String outFile) { + public static Writer createFileWriter(final String outFile) { try { return new Writer( new ObjectOutputStream(new GZIPOutputStream(new FileOutputStream(outFile)))); @@ -117,7 +117,7 @@ public static Writer createFileWriter(String outFile) { } } - public static Reader createResourceReader(Spec spec, String resourcePath) { + public static Reader createResourceReader(final Spec spec, final String resourcePath) { try { return createReader( spec, BlockIO.class.getResourceAsStream(resourcePath), resourcePath.endsWith(".gz")); @@ -126,7 +126,7 @@ public static Reader createResourceReader(Spec spec, String resourcePath) { } } - public static Reader createFileReader(Spec spec, String inFile) { + public static Reader createFileReader(final Spec spec, final String inFile) { try { return createReader(spec, new FileInputStream(inFile), inFile.endsWith(".gz")); } catch (FileNotFoundException e) { @@ -134,7 +134,8 @@ public static Reader createFileReader(Spec spec, String inFile) { } } - public static Reader createReader(Spec spec, InputStream inputStream, boolean gzipped) { + public static Reader createReader( + final Spec spec, final InputStream inputStream, final boolean gzipped) { try { return new Reader( new ObjectInputStream(gzipped ? new GZIPInputStream(inputStream) : inputStream), spec); diff --git a/eth-benchmark-tests/src/testFixtures/java/tech/pegasys/teku/benchmarks/gen/BlsKeyPairIO.java b/eth-benchmark-tests/src/testFixtures/java/tech/pegasys/teku/benchmarks/gen/BlsKeyPairIO.java index 306266360ce..232717496b7 100644 --- a/eth-benchmark-tests/src/testFixtures/java/tech/pegasys/teku/benchmarks/gen/BlsKeyPairIO.java +++ b/eth-benchmark-tests/src/testFixtures/java/tech/pegasys/teku/benchmarks/gen/BlsKeyPairIO.java @@ -47,11 +47,11 @@ public static class Reader implements AutoCloseable, Supplier, Itera private final BufferedReader reader; private int pairsToRead = Integer.MAX_VALUE; - public Reader(BufferedReader reader) { + public Reader(final BufferedReader reader) { this.reader = reader; } - public Reader withLimit(int limit) { + public Reader withLimit(final int limit) { pairsToRead = limit; return this; } @@ -68,7 +68,7 @@ public Iterator iterator() { } @SuppressWarnings("EmptyCatch") - public List readAll(int limit) { + public List readAll(final int limit) { try { return StreamSupport.stream(withLimit(limit).spliterator(), false) .collect(Collectors.toList()); @@ -119,12 +119,12 @@ public static class Writer implements AutoCloseable { private final Supplier generator; private final BufferedWriter writer; - private Writer(Supplier generator, BufferedWriter writer) { + private Writer(final Supplier generator, final BufferedWriter writer) { this.generator = generator; this.writer = writer; } - public void write(int count) throws IOException { + public void write(final int count) throws IOException { for (int i = 0; i < count; i++) { BLSKeyPair blsKeyPair = generator.get(); writer @@ -151,7 +151,7 @@ public static Reader createReaderWithDefaultSource() { return createReaderForResource("/bls-key-pairs/bls-pairs-1m-seed_1.gz"); } - public static Reader createReaderForResource(String resourceName) { + public static Reader createReaderForResource(final String resourceName) { try { return createReaderFromStream( BlsKeyPairIO.class.getResourceAsStream(resourceName), resourceName.endsWith(".gz")); @@ -160,7 +160,7 @@ public static Reader createReaderForResource(String resourceName) { } } - public static Reader createReaderForFile(File file) { + public static Reader createReaderForFile(final File file) { try { return createReaderFromStream(new FileInputStream(file), file.getName().endsWith(".gz")); } catch (IOException e) { @@ -168,7 +168,7 @@ public static Reader createReaderForFile(File file) { } } - public static Reader createReaderFromStream(InputStream input, boolean gzipped) + public static Reader createReaderFromStream(final InputStream input, final boolean gzipped) throws IOException { BufferedReader reader = new BufferedReader( @@ -176,7 +176,7 @@ public static Reader createReaderFromStream(InputStream input, boolean gzipped) return new Reader(reader); } - public static Writer createWriter(File outFile, Supplier generator) { + public static Writer createWriter(final File outFile, final Supplier generator) { try { return new Writer(generator, new BufferedWriter(new FileWriter(outFile, UTF_8))); } catch (IOException e) { diff --git a/eth-benchmark-tests/src/testFixtures/java/tech/pegasys/teku/benchmarks/gen/KeyFileGenerator.java b/eth-benchmark-tests/src/testFixtures/java/tech/pegasys/teku/benchmarks/gen/KeyFileGenerator.java index 86bbb688785..2dcc5c0ac1b 100644 --- a/eth-benchmark-tests/src/testFixtures/java/tech/pegasys/teku/benchmarks/gen/KeyFileGenerator.java +++ b/eth-benchmark-tests/src/testFixtures/java/tech/pegasys/teku/benchmarks/gen/KeyFileGenerator.java @@ -27,7 +27,7 @@ */ public class KeyFileGenerator { - public static void main(String[] args) throws Exception { + public static void main(final String[] args) throws Exception { final int randomSeed = 0; final Iterator keyPairIterator = IntStream.range(randomSeed, randomSeed + Integer.MAX_VALUE) @@ -62,7 +62,7 @@ private static void dieUsage(final Optional maybeContext) { // Used by other processes to read the keys generated and stored in bls-key-pairs // can specify up to 3_276_800 keys and a list will be returned to the caller - public static List readValidatorKeys(int limit) { + public static List readValidatorKeys(final int limit) { if (limit > 3_276_800) { System.out.println( "Only resource files up to 3200K validators has been generated, insufficient stored keys to satisfy request."); diff --git a/eth-benchmark-tests/src/testFixtures/java/tech/pegasys/teku/benchmarks/gen/Utils.java b/eth-benchmark-tests/src/testFixtures/java/tech/pegasys/teku/benchmarks/gen/Utils.java index b46fc7a6df6..5aca981c27b 100644 --- a/eth-benchmark-tests/src/testFixtures/java/tech/pegasys/teku/benchmarks/gen/Utils.java +++ b/eth-benchmark-tests/src/testFixtures/java/tech/pegasys/teku/benchmarks/gen/Utils.java @@ -19,7 +19,7 @@ public class Utils { - static Iterator fromSupplier(Supplier supplier) { + static Iterator fromSupplier(final Supplier supplier) { return new Iterator() { T next = supplier.get(); diff --git a/eth-reference-tests/build.gradle b/eth-reference-tests/build.gradle index 0f693efdce2..91cb2a10c90 100644 --- a/eth-reference-tests/build.gradle +++ b/eth-reference-tests/build.gradle @@ -15,16 +15,18 @@ dependencies { referenceTestImplementation project(':storage') referenceTestImplementation testFixtures(project(':storage')) referenceTestImplementation project(':infrastructure:async') + referenceTestImplementation project(':infrastructure:io') referenceTestImplementation testFixtures(project(':infrastructure:async')) referenceTestImplementation testFixtures(project(':infrastructure:metrics')) referenceTestImplementation project(':infrastructure:time') + referenceTestImplementation project(':data:dataexchange') referenceTestImplementation 'org.hyperledger.besu:plugin-api' referenceTestImplementation 'com.fasterxml.jackson.core:jackson-databind' referenceTestImplementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-yaml' - referenceTestImplementation 'org.apache.tuweni:tuweni-bytes' - referenceTestImplementation 'org.apache.tuweni:tuweni-junit' - referenceTestImplementation 'org.apache.tuweni:tuweni-ssz' + referenceTestImplementation 'io.tmio:tuweni-bytes' + referenceTestImplementation 'io.tmio:tuweni-junit' + referenceTestImplementation 'io.tmio:tuweni-ssz' referenceTestImplementation 'org.xerial.snappy:snappy-java' } diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/Eth2ReferenceTestCase.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/Eth2ReferenceTestCase.java index 4b21f61f7f3..10a144a977d 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/Eth2ReferenceTestCase.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/Eth2ReferenceTestCase.java @@ -32,6 +32,7 @@ import tech.pegasys.teku.reference.phase0.rewards.RewardsTestExecutorPhase0; import tech.pegasys.teku.reference.phase0.sanity.SanityTests; import tech.pegasys.teku.reference.phase0.shuffling.ShufflingTestExecutor; +import tech.pegasys.teku.reference.phase0.slashing_protection_interchange.SlashingProtectionInterchangeTestExecutor; import tech.pegasys.teku.reference.phase0.ssz_generic.SszGenericTests; import tech.pegasys.teku.reference.phase0.ssz_static.SszTestExecutor; @@ -49,6 +50,7 @@ public abstract class Eth2ReferenceTestCase { .putAll(SszGenericTests.SSZ_GENERIC_TEST_TYPES) .putAll(OperationsTestExecutor.OPERATIONS_TEST_TYPES) .putAll(SanityTests.SANITY_TEST_TYPES) + .put("slashing-protection-interchange", new SlashingProtectionInterchangeTestExecutor()) .put("light_client/single_merkle_proof", TestExecutor.IGNORE_TESTS) .put("light_client/sync", TestExecutor.IGNORE_TESTS) .put("light_client/update_ranking", TestExecutor.IGNORE_TESTS) @@ -88,6 +90,14 @@ public abstract class Eth2ReferenceTestCase { .putAll(MerkleProofTests.MERKLE_PROOF_TEST_TYPES) .build(); + private static final ImmutableMap ELECTRA_TEST_TYPES = + ImmutableMap.builder() + .putAll(TransitionTestExecutor.TRANSITION_TEST_TYPES) + .putAll(ForkUpgradeTestExecutor.FORK_UPGRADE_TEST_TYPES) + .putAll(RewardsTestExecutorBellatrix.REWARDS_TEST_TYPES) + .putAll(MerkleProofTests.MERKLE_PROOF_TEST_TYPES) + .build(); + private static final ImmutableMap EIP7594_TEST_TYPES = ImmutableMap.builder() .putAll(MerkleProofTests.MERKLE_PROOF_TEST_TYPES) @@ -107,6 +117,7 @@ private TestExecutor getExecutorFor(final TestDefinition testDefinition) { case TestFork.BELLATRIX -> BELLATRIX_TEST_TYPES.get(testDefinition.getTestType()); case TestFork.CAPELLA -> CAPELLA_TEST_TYPES.get(testDefinition.getTestType()); case TestFork.DENEB -> DENEB_TEST_TYPES.get(testDefinition.getTestType()); + case TestFork.ELECTRA -> ELECTRA_TEST_TYPES.get(testDefinition.getTestType()); case TestFork.EIP7594 -> EIP7594_TEST_TYPES.get(testDefinition.getTestType()); default -> null; }; diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/KzgRetriever.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/KzgRetriever.java index 8980728ea57..7703e57043e 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/KzgRetriever.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/KzgRetriever.java @@ -26,7 +26,7 @@ public class KzgRetriever { public static KZG getKzgWithLoadedTrustedSetup(final Spec spec, final String network) { if (spec.isMilestoneSupported(SpecMilestone.DENEB) - || spec.isMilestoneSupported(SpecMilestone.EIP7594)) { + || spec.isMilestoneSupported(SpecMilestone.ELECTRA)) { return getKzgWithLoadedTrustedSetup(network); } return KZG.NOOP; diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/ManualReferenceTestRunner.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/ManualReferenceTestRunner.java index 8db4b6cbafb..abdbc308224 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/ManualReferenceTestRunner.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/ManualReferenceTestRunner.java @@ -42,7 +42,7 @@ public class ManualReferenceTestRunner extends Eth2ReferenceTestCase { * *

May be overridden by the ENV_TEST_TYPE environment variable. */ - private static final String TEST_TYPE = "fork_choice"; + private static final String TEST_TYPE = ""; /** * Filter test to run to those from the specified spec. One of general, minimal or mainnet diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/TestDataUtils.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/TestDataUtils.java index ddedd55c3af..e20df04dc40 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/TestDataUtils.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/TestDataUtils.java @@ -26,6 +26,7 @@ import org.xerial.snappy.Snappy; import org.yaml.snakeyaml.LoaderOptions; import tech.pegasys.teku.ethtests.finder.TestDefinition; +import tech.pegasys.teku.infrastructure.json.JsonUtil; import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; import tech.pegasys.teku.infrastructure.ssz.SszData; import tech.pegasys.teku.infrastructure.ssz.schema.SszSchema; @@ -85,7 +86,7 @@ public static T loadYaml( throws IOException { final Path path = testDefinition.getTestDirectory().resolve(fileName); try (final InputStream in = Files.newInputStream(path)) { - return new ObjectMapper(YAML_FACTORY).readerFor(type).readValue(in); + return new ObjectMapper(YAML_FACTORY).readValue(in, type); } } @@ -100,4 +101,15 @@ public static T loadYaml( return type.deserialize(in); } } + + public static T loadJson( + final TestDefinition testDefinition, + final String fileName, + final DeserializableTypeDefinition type) + throws IOException { + final Path path = testDefinition.getTestDirectory().resolve(fileName); + try (final InputStream in = Files.newInputStream(path)) { + return JsonUtil.parse(in, type); + } + } } diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/altair/fork/ForkUpgradeTestExecutor.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/altair/fork/ForkUpgradeTestExecutor.java index e9221441bb7..ca3584bb4fa 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/altair/fork/ForkUpgradeTestExecutor.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/altair/fork/ForkUpgradeTestExecutor.java @@ -14,6 +14,7 @@ package tech.pegasys.teku.reference.altair.fork; import static tech.pegasys.teku.infrastructure.ssz.SszDataAssert.assertThatSszData; +import static tech.pegasys.teku.spec.SpecMilestone.BELLATRIX; import com.fasterxml.jackson.annotation.JsonProperty; import com.google.common.collect.ImmutableMap; @@ -27,6 +28,7 @@ import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.altair.BeaconStateSchemaAltair; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.bellatrix.BeaconStateSchemaBellatrix; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.capella.BeaconStateSchemaCapella; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.deneb.BeaconStateSchemaDeneb; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.phase0.BeaconStateSchemaPhase0; import tech.pegasys.teku.spec.logic.common.forktransition.StateUpgrade; @@ -43,18 +45,32 @@ public void runTest(final TestDefinition testDefinition) throws Throwable { } private void processUpgrade(final TestDefinition testDefinition, final SpecMilestone milestone) { - final SpecVersion spec = testDefinition.getSpec().getGenesisSpec(); + final SpecMilestone previousMilestone = milestone.getPreviousMilestone(); + final SpecVersion previousMilestoneSpecVersion = + testDefinition.getSpec().forMilestone(previousMilestone); final BeaconStateSchema fromMilestoneSchema = switch (milestone) { - case ALTAIR -> BeaconStateSchemaPhase0.create(spec.getConfig()); - case BELLATRIX -> BeaconStateSchemaAltair.create(spec.getConfig()); - case CAPELLA -> BeaconStateSchemaBellatrix.create(spec.getConfig()); - case DENEB -> BeaconStateSchemaCapella.create(spec.getConfig()); - default -> throw new IllegalStateException( - "Unhandled fork upgrade for test " - + testDefinition.getDisplayName() - + ": " - + milestone); + case ALTAIR -> BeaconStateSchemaPhase0.create(previousMilestoneSpecVersion.getConfig()); + case BELLATRIX -> + BeaconStateSchemaAltair.create(previousMilestoneSpecVersion.getConfig()); + case CAPELLA -> + BeaconStateSchemaBellatrix.create( + previousMilestoneSpecVersion.getConfig(), + previousMilestoneSpecVersion.getSchemaDefinitions().getSchemaRegistry()); + case DENEB -> + BeaconStateSchemaCapella.create( + previousMilestoneSpecVersion.getConfig(), + previousMilestoneSpecVersion.getSchemaDefinitions().getSchemaRegistry()); + case ELECTRA -> + BeaconStateSchemaDeneb.create( + previousMilestoneSpecVersion.getConfig(), + previousMilestoneSpecVersion.getSchemaDefinitions().getSchemaRegistry()); + default -> + throw new IllegalStateException( + "Unhandled fork upgrade for test " + + testDefinition.getDisplayName() + + ": " + + milestone); }; final BeaconState preState = TestDataUtils.loadSsz(testDefinition, "pre.ssz_snappy", fromMilestoneSchema); diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/altair/fork/TransitionTestExecutor.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/altair/fork/TransitionTestExecutor.java index d807a338d47..94bfc6711ed 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/altair/fork/TransitionTestExecutor.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/altair/fork/TransitionTestExecutor.java @@ -28,6 +28,7 @@ import tech.pegasys.teku.spec.SpecFactory; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.config.SpecConfigAndParent; import tech.pegasys.teku.spec.config.SpecConfigLoader; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; @@ -47,29 +48,40 @@ public void runTest(final TestDefinition testDefinition) throws Throwable { private void processUpgrade(final TestDefinition testDefinition, final MetaData metadata) { final SpecMilestone milestone = SpecMilestone.forName(metadata.postFork); final UInt64 forkEpoch = UInt64.valueOf(metadata.forkEpoch); - final SpecConfig config = + final SpecConfigAndParent config = SpecConfigLoader.loadConfig( testDefinition.getConfigName(), builder -> { switch (milestone) { case ALTAIR -> builder.altairBuilder(a -> a.altairForkEpoch(forkEpoch)); - case BELLATRIX -> builder - .altairBuilder(a -> a.altairForkEpoch(UInt64.ZERO)) - .bellatrixBuilder(b -> b.bellatrixForkEpoch(forkEpoch)); - case CAPELLA -> builder - .altairBuilder(a -> a.altairForkEpoch(UInt64.ZERO)) - .bellatrixBuilder(b -> b.bellatrixForkEpoch(UInt64.ZERO)) - .capellaBuilder(c -> c.capellaForkEpoch(forkEpoch)); - case DENEB -> builder - .altairBuilder(a -> a.altairForkEpoch(UInt64.ZERO)) - .bellatrixBuilder(b -> b.bellatrixForkEpoch(UInt64.ZERO)) - .capellaBuilder(c -> c.capellaForkEpoch(UInt64.ZERO)) - .denebBuilder(d -> d.denebForkEpoch(forkEpoch)); - default -> throw new IllegalStateException( - "Unhandled fork transition for test " - + testDefinition.getDisplayName() - + ": " - + milestone); + case BELLATRIX -> + builder + .altairBuilder(a -> a.altairForkEpoch(UInt64.ZERO)) + .bellatrixBuilder(b -> b.bellatrixForkEpoch(forkEpoch)); + case CAPELLA -> + builder + .altairBuilder(a -> a.altairForkEpoch(UInt64.ZERO)) + .bellatrixBuilder(b -> b.bellatrixForkEpoch(UInt64.ZERO)) + .capellaBuilder(c -> c.capellaForkEpoch(forkEpoch)); + case DENEB -> + builder + .altairBuilder(a -> a.altairForkEpoch(UInt64.ZERO)) + .bellatrixBuilder(b -> b.bellatrixForkEpoch(UInt64.ZERO)) + .capellaBuilder(c -> c.capellaForkEpoch(UInt64.ZERO)) + .denebBuilder(d -> d.denebForkEpoch(forkEpoch)); + case ELECTRA -> + builder + .altairBuilder(a -> a.altairForkEpoch(UInt64.ZERO)) + .bellatrixBuilder(b -> b.bellatrixForkEpoch(UInt64.ZERO)) + .capellaBuilder(c -> c.capellaForkEpoch(UInt64.ZERO)) + .denebBuilder(d -> d.denebForkEpoch(UInt64.ZERO)) + .electraBuilder(e -> e.electraForkEpoch(forkEpoch)); + default -> + throw new IllegalStateException( + "Unhandled fork transition for test " + + testDefinition.getDisplayName() + + ": " + + milestone); } }); final Spec spec = SpecFactory.create(config); @@ -112,6 +124,7 @@ private static class MetaData { @JsonProperty(value = "fork_block", required = true) private int forkBlock; + @SuppressWarnings("FieldCanBeFinal") @JsonProperty(value = "bls_setting", defaultValue = "0") private int blsSetting = 0; } diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/common/epoch_processing/EpochOperation.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/common/epoch_processing/EpochOperation.java index 3583e5ecb4a..10fbd73a09e 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/common/epoch_processing/EpochOperation.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/common/epoch_processing/EpochOperation.java @@ -26,5 +26,7 @@ public enum EpochOperation { PROCESS_HISTORICAL_ROOTS_UPDATE, SYNC_COMMITTEE_UPDATES, PROCESS_HISTORICAL_SUMMARIES_UPDATE, + PENDING_DEPOSITS, + PENDING_CONSOLIDATIONS, INACTIVITY_UPDATES } diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/common/epoch_processing/EpochProcessingExecutor.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/common/epoch_processing/EpochProcessingExecutor.java index 48b21dd8d81..258d9a1f36a 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/common/epoch_processing/EpochProcessingExecutor.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/common/epoch_processing/EpochProcessingExecutor.java @@ -41,12 +41,15 @@ public void executeOperation(final EpochOperation operation, final MutableBeacon case PROCESS_SLASHINGS_RESET -> epochProcessor.processSlashingsReset(state); case PROCESS_RANDAO_MIXES_RESET -> epochProcessor.processRandaoMixesReset(state); case PROCESS_HISTORICAL_ROOTS_UPDATE -> epochProcessor.processHistoricalRootsUpdate(state); - case PROCESS_HISTORICAL_SUMMARIES_UPDATE -> epochProcessor.processHistoricalSummariesUpdate( - state); + case PROCESS_HISTORICAL_SUMMARIES_UPDATE -> + epochProcessor.processHistoricalSummariesUpdate(state); case SYNC_COMMITTEE_UPDATES -> epochProcessor.processSyncCommitteeUpdates(state); case INACTIVITY_UPDATES -> processInactivityUpdates(state); - default -> throw new UnsupportedOperationException( - "Attempted to execute unknown operation type: " + operation); + case PENDING_DEPOSITS -> processPendingDeposits(state); + case PENDING_CONSOLIDATIONS -> processPendingConsolidations(state); + default -> + throw new UnsupportedOperationException( + "Attempted to execute unknown operation type: " + operation); } } @@ -55,6 +58,14 @@ private void processInactivityUpdates(final MutableBeaconState state) { state, validatorStatusFactory.createValidatorStatuses(state)); } + private void processPendingDeposits(final MutableBeaconState state) { + epochProcessor.processPendingDeposits(state); + } + + private void processPendingConsolidations(final MutableBeaconState state) { + epochProcessor.processPendingConsolidations(state); + } + public void processSlashings(final MutableBeaconState state) { epochProcessor.processSlashings(state, validatorStatusFactory.createValidatorStatuses(state)); } diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/common/epoch_processing/EpochProcessingTestExecutor.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/common/epoch_processing/EpochProcessingTestExecutor.java index 70ea286a119..c6d0996219f 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/common/epoch_processing/EpochProcessingTestExecutor.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/common/epoch_processing/EpochProcessingTestExecutor.java @@ -78,6 +78,12 @@ public class EpochProcessingTestExecutor implements TestExecutor { .put( "epoch_processing/inactivity_updates", new EpochProcessingTestExecutor(EpochOperation.INACTIVITY_UPDATES)) + .put( + "epoch_processing/pending_consolidations", + new EpochProcessingTestExecutor(EpochOperation.PENDING_CONSOLIDATIONS)) + .put( + "epoch_processing/pending_deposits", + new EpochProcessingTestExecutor(EpochOperation.PENDING_DEPOSITS)) .build(); private final EpochOperation operation; diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/common/operations/DefaultOperationProcessor.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/common/operations/DefaultOperationProcessor.java index 96b11054690..c861fbbab61 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/common/operations/DefaultOperationProcessor.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/common/operations/DefaultOperationProcessor.java @@ -13,7 +13,9 @@ package tech.pegasys.teku.reference.common.operations; +import java.util.List; import java.util.Optional; +import java.util.function.Supplier; import tech.pegasys.teku.bls.BLSSignatureVerifier; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlockSummary; @@ -22,6 +24,9 @@ import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.SyncAggregate; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.capella.BeaconBlockBodySchemaCapella; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSummary; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequest; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; import tech.pegasys.teku.spec.datastructures.operations.Deposit; @@ -29,6 +34,7 @@ import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChange; import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; import tech.pegasys.teku.spec.datastructures.state.beaconstate.MutableBeaconState; +import tech.pegasys.teku.spec.logic.common.helpers.BeaconStateMutators.ValidatorExitContext; import tech.pegasys.teku.spec.logic.common.statetransition.exceptions.BlockProcessingException; import tech.pegasys.teku.spec.logic.versions.bellatrix.block.OptimisticExecutionPayloadExecutor; @@ -133,4 +139,31 @@ public void processWithdrawals( throws BlockProcessingException { spec.getBlockProcessor(state.getSlot()).processWithdrawals(state, payloadSummary); } + + @Override + public void processDepositRequest( + final MutableBeaconState state, final List depositRequests) + throws BlockProcessingException { + spec.getBlockProcessor(state.getSlot()).processDepositRequests(state, depositRequests); + } + + @Override + public void processWithdrawalRequest( + final MutableBeaconState state, final List withdrawalRequests) + throws BlockProcessingException { + final Supplier validatorExitContextSupplier = + spec.atSlot(state.getSlot()) + .beaconStateMutators() + .createValidatorExitContextSupplier(state); + spec.getBlockProcessor(state.getSlot()) + .processWithdrawalRequests(state, withdrawalRequests, validatorExitContextSupplier); + } + + @Override + public void processConsolidationRequest( + final MutableBeaconState state, final List consolidationRequests) + throws BlockProcessingException { + spec.getBlockProcessor(state.getSlot()) + .processConsolidationRequests(state, consolidationRequests); + } } diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/common/operations/OperationProcessor.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/common/operations/OperationProcessor.java index de6475205a0..519468ce32f 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/common/operations/OperationProcessor.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/common/operations/OperationProcessor.java @@ -13,11 +13,15 @@ package tech.pegasys.teku.reference.common.operations; +import java.util.List; import java.util.Optional; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlockSummary; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.SyncAggregate; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSummary; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequest; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; import tech.pegasys.teku.spec.datastructures.operations.Deposit; @@ -62,4 +66,14 @@ void processBlsToExecutionChange( void processWithdrawals(MutableBeaconState state, ExecutionPayloadSummary payloadSummary) throws BlockProcessingException; + + void processDepositRequest(MutableBeaconState state, List depositRequest) + throws BlockProcessingException; + + void processWithdrawalRequest(MutableBeaconState state, List withdrawalRequest) + throws BlockProcessingException; + + void processConsolidationRequest( + MutableBeaconState state, List consolidationRequest) + throws BlockProcessingException; } diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/common/operations/OperationsTestExecutor.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/common/operations/OperationsTestExecutor.java index 61caa502ae2..df11615cc16 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/common/operations/OperationsTestExecutor.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/common/operations/OperationsTestExecutor.java @@ -24,6 +24,8 @@ import java.util.Optional; import tech.pegasys.teku.ethtests.finder.TestDefinition; import tech.pegasys.teku.infrastructure.ssz.SszData; +import tech.pegasys.teku.infrastructure.ssz.SszList; +import tech.pegasys.teku.infrastructure.ssz.schema.SszListSchema; import tech.pegasys.teku.infrastructure.time.SystemTimeProvider; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.reference.TestExecutor; @@ -34,6 +36,9 @@ import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.BeaconBlockBodySchemaAltair; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.SyncAggregate; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequest; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; import tech.pegasys.teku.spec.datastructures.operations.Deposit; @@ -50,6 +55,7 @@ import tech.pegasys.teku.spec.logic.common.statetransition.exceptions.SlotProcessingException; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsBellatrix; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsCapella; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; import tech.pegasys.teku.statetransition.validation.AttesterSlashingValidator; import tech.pegasys.teku.statetransition.validation.OperationValidator; import tech.pegasys.teku.statetransition.validation.ProposerSlashingValidator; @@ -71,7 +77,10 @@ private enum Operation { SYNC_AGGREGATE, EXECUTION_PAYLOAD, BLS_TO_EXECUTION_CHANGE, - WITHDRAWAL + WITHDRAWAL, + DEPOSIT_REQUEST, + WITHDRAWAL_REQUEST, + CONSOLIDATION_REQUEST } public static final ImmutableMap OPERATIONS_TEST_TYPES = @@ -112,6 +121,17 @@ private enum Operation { .put( "operations/withdrawals", new OperationsTestExecutor<>("execution_payload.ssz_snappy", Operation.WITHDRAWAL)) + .put( + "operations/deposit_request", + new OperationsTestExecutor<>("deposit_request.ssz_snappy", Operation.DEPOSIT_REQUEST)) + .put( + "operations/withdrawal_request", + new OperationsTestExecutor<>( + "withdrawal_request.ssz_snappy", Operation.WITHDRAWAL_REQUEST)) + .put( + "operations/consolidation_request", + new OperationsTestExecutor<>( + "consolidation_request.ssz_snappy", Operation.CONSOLIDATION_REQUEST)) .build(); private final String dataFileName; @@ -298,8 +318,12 @@ private void processOperation( } case BLS_TO_EXECUTION_CHANGE -> processBlsToExecutionChange(testDefinition, state, processor); case WITHDRAWAL -> processWithdrawal(testDefinition, state, processor); - default -> throw new UnsupportedOperationException( - "Operation " + operation + " not implemented in OperationTestExecutor"); + case DEPOSIT_REQUEST -> processDepositRequest(testDefinition, state, processor); + case WITHDRAWAL_REQUEST -> processWithdrawalRequest(testDefinition, state, processor); + case CONSOLIDATION_REQUEST -> processConsolidation(testDefinition, state, processor); + default -> + throw new UnsupportedOperationException( + "Operation " + operation + " not implemented in OperationTestExecutor"); } } @@ -325,6 +349,54 @@ private void processBlsToExecutionChange( processor.processBlsToExecutionChange(state, blsToExecutionChange); } + private void processDepositRequest( + final TestDefinition testDefinition, + final MutableBeaconState state, + final OperationProcessor processor) + throws BlockProcessingException { + final SszListSchema depositRequestsSchema = + SchemaDefinitionsElectra.required( + testDefinition.getSpec().forMilestone(SpecMilestone.ELECTRA).getSchemaDefinitions()) + .getExecutionRequestsSchema() + .getDepositRequestsSchema(); + final SszList depositRequests = + loadSsz(testDefinition, dataFileName, depositRequestsSchema); + + processor.processDepositRequest(state, depositRequests.asList()); + } + + private void processWithdrawalRequest( + final TestDefinition testDefinition, + final MutableBeaconState state, + final OperationProcessor processor) + throws BlockProcessingException { + final SszListSchema withdrawalRequestsSchema = + SchemaDefinitionsElectra.required( + testDefinition.getSpec().forMilestone(SpecMilestone.ELECTRA).getSchemaDefinitions()) + .getExecutionRequestsSchema() + .getWithdrawalRequestsSchema(); + final SszList withdrawalRequests = + loadSsz(testDefinition, dataFileName, withdrawalRequestsSchema); + + processor.processWithdrawalRequest(state, withdrawalRequests.asList()); + } + + private void processConsolidation( + final TestDefinition testDefinition, + final MutableBeaconState state, + final OperationProcessor processor) + throws BlockProcessingException { + final SszListSchema consolidationRequestsSchema = + SchemaDefinitionsElectra.required( + testDefinition.getSpec().forMilestone(SpecMilestone.ELECTRA).getSchemaDefinitions()) + .getExecutionRequestsSchema() + .getConsolidationRequestsSchema(); + final SszList consolidationRequests = + loadSsz(testDefinition, dataFileName, consolidationRequestsSchema); + + processor.processConsolidationRequest(state, consolidationRequests.asList()); + } + private SignedVoluntaryExit loadVoluntaryExit(final TestDefinition testDefinition) { return loadSsz(testDefinition, dataFileName, SignedVoluntaryExit.SSZ_SCHEMA); } @@ -381,13 +453,16 @@ public void checkBlockInclusionValidation( checkValidationForBlockInclusion( blsToExecutionChangeValidator, state, blsToExecutionChange, expectInclusion); } - // Not yet testing inclusion rules + // Not yet testing inclusion rules case PROCESS_BLOCK_HEADER, DEPOSIT, ATTESTATION, SYNC_AGGREGATE, EXECUTION_PAYLOAD, - WITHDRAWAL -> {} + WITHDRAWAL, + DEPOSIT_REQUEST, + WITHDRAWAL_REQUEST, + CONSOLIDATION_REQUEST -> {} } } diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/deneb/merkle_proof/SingleMerkleProofTestExecutor.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/deneb/merkle_proof/SingleMerkleProofTestExecutor.java index f9a735dc87b..98320630d74 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/deneb/merkle_proof/SingleMerkleProofTestExecutor.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/deneb/merkle_proof/SingleMerkleProofTestExecutor.java @@ -32,12 +32,13 @@ import tech.pegasys.teku.reference.TestDataUtils; import tech.pegasys.teku.reference.TestExecutor; import tech.pegasys.teku.spec.config.SpecConfigDeneb; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.features.Eip7594; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody; import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; import tech.pegasys.teku.spec.logic.common.helpers.Predicates; import tech.pegasys.teku.spec.logic.versions.deneb.helpers.MiscHelpersDeneb; -import tech.pegasys.teku.spec.logic.versions.eip7594.helpers.MiscHelpersEip7594; +import tech.pegasys.teku.spec.logic.versions.feature.eip7594.helpers.MiscHelpersEip7594; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsEip7594; public class SingleMerkleProofTestExecutor implements TestExecutor { private static final Pattern TEST_NAME_PATTERN = Pattern.compile("(.+)/(.+)"); @@ -186,11 +187,7 @@ private int getKzgCommitmentInclusionProofDepth(final TestDefinition testDefinit private SszBytes32Vector createKzgCommitmentsMerkleProofBranchFromData( final TestDefinition testDefinition, final List branch) { final SszBytes32VectorSchema kzgCommitmentsInclusionProofSchema = - testDefinition - .getSpec() - .getGenesisSchemaDefinitions() - .toVersionEip7594() - .orElseThrow() + SchemaDefinitionsEip7594.required(testDefinition.getSpec().getGenesisSchemaDefinitions()) .getDataColumnSidecarSchema() .getKzgCommitmentsInclusionProofSchema(); return kzgCommitmentsInclusionProofSchema.createFromElements( @@ -198,7 +195,7 @@ private SszBytes32Vector createKzgCommitmentsMerkleProofBranchFromData( } private int getKzgCommitmentsInclusionProofDepth(final TestDefinition testDefinition) { - return SpecConfigEip7594.required(testDefinition.getSpec().getGenesisSpecConfig()) + return Eip7594.required(testDefinition.getSpec().getGenesisSpecConfig()) .getKzgCommitmentsInclusionProofDepth() .intValue(); } diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/eip7594/networking/GetCustodyColumnsTestExecutor.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/eip7594/networking/GetCustodyColumnsTestExecutor.java index f8429257143..e89fca50b19 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/eip7594/networking/GetCustodyColumnsTestExecutor.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/eip7594/networking/GetCustodyColumnsTestExecutor.java @@ -27,7 +27,7 @@ import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.reference.TestExecutor; import tech.pegasys.teku.spec.SpecVersion; -import tech.pegasys.teku.spec.logic.versions.eip7594.helpers.MiscHelpersEip7594; +import tech.pegasys.teku.spec.logic.versions.feature.eip7594.helpers.MiscHelpersEip7594; public class GetCustodyColumnsTestExecutor implements TestExecutor { diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/bls/BlsTestExecutor.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/bls/BlsTestExecutor.java index 021384a7bba..f6e86996c4b 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/bls/BlsTestExecutor.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/bls/BlsTestExecutor.java @@ -25,7 +25,7 @@ public abstract class BlsTestExecutor implements TestExecutor { @Override - public final void runTest(TestDefinition testDefinition) throws Throwable { + public final void runTest(final TestDefinition testDefinition) throws Throwable { if (BlstLoader.INSTANCE.isPresent()) { try { BLS.setBlsImplementation(BlstLoader.INSTANCE.get()); diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/forkchoice/ForkChoiceTestExecutor.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/forkchoice/ForkChoiceTestExecutor.java index d38a84ba016..64250d30e9e 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/forkchoice/ForkChoiceTestExecutor.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/forkchoice/ForkChoiceTestExecutor.java @@ -70,6 +70,7 @@ import tech.pegasys.teku.statetransition.forkchoice.MergeTransitionBlockValidator; import tech.pegasys.teku.statetransition.forkchoice.NoopForkChoiceNotifier; import tech.pegasys.teku.statetransition.forkchoice.TickProcessor; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.statetransition.validation.BlockBroadcastValidator; import tech.pegasys.teku.statetransition.validation.InternalValidationResult; import tech.pegasys.teku.storage.client.RecentChainData; @@ -96,7 +97,7 @@ public class ForkChoiceTestExecutor implements TestExecutor { private final List testsToSkip; - public ForkChoiceTestExecutor(String... testsToSkip) { + public ForkChoiceTestExecutor(final String... testsToSkip) { this.testsToSkip = List.of(testsToSkip); } @@ -141,6 +142,7 @@ spec, new SignedBlockAndState(anchorBlock, anchorState)), new TickProcessor(spec, recentChainData), transitionBlockValidator, true, + DebugDataDumper.NOOP, storageSystem.getMetricsSystem()); final ExecutionLayerChannelStub executionLayer = new ExecutionLayerChannelStub(spec, false, Optional.empty()); @@ -404,8 +406,8 @@ private void applyChecks( for (String checkType : checks.keySet()) { try { switch (checkType) { - case "genesis_time" -> assertThat(recentChainData.getGenesisTime()) - .isEqualTo(getUInt64(checks, checkType)); + case "genesis_time" -> + assertThat(recentChainData.getGenesisTime()).isEqualTo(getUInt64(checks, checkType)); case "head" -> { final Map expectedHead = get(checks, checkType); @@ -431,13 +433,15 @@ private void applyChecks( .isEqualTo(expectedJustifiedRoot); } - case "justified_checkpoint" -> assertCheckpoint( - "justified checkpoint", store.getJustifiedCheckpoint(), get(checks, checkType)); + case "justified_checkpoint" -> + assertCheckpoint( + "justified checkpoint", store.getJustifiedCheckpoint(), get(checks, checkType)); - case "best_justified_checkpoint" -> assertCheckpoint( - "best justified checkpoint", - store.getBestJustifiedCheckpoint(), - get(checks, checkType)); + case "best_justified_checkpoint" -> + assertCheckpoint( + "best justified checkpoint", + store.getBestJustifiedCheckpoint(), + get(checks, checkType)); case "finalized_checkpoint_root" -> { final Bytes32 expectedFinalizedRoot = getBytes32(checks, checkType); @@ -446,8 +450,9 @@ private void applyChecks( .isEqualTo(expectedFinalizedRoot); } - case "finalized_checkpoint" -> assertCheckpoint( - "finalized checkpoint", store.getFinalizedCheckpoint(), get(checks, checkType)); + case "finalized_checkpoint" -> + assertCheckpoint( + "finalized checkpoint", store.getFinalizedCheckpoint(), get(checks, checkType)); case "proposer_boost_root" -> { final Optional boostedRoot = store.getProposerBoostRoot(); @@ -483,8 +488,8 @@ private void applyChecks( assertThat(expectedValidatorIsConnected).isTrue(); } - default -> throw new UnsupportedOperationException( - "Unsupported check type: " + checkType); + default -> + throw new UnsupportedOperationException("Unsupported check type: " + checkType); } } catch (final AssertionError failure) { failures.add(failure); diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/genesis/GenesisInitializationTestExecutor.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/genesis/GenesisInitializationTestExecutor.java index 143ac32d3e9..cd2ac6d6ea4 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/genesis/GenesisInitializationTestExecutor.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/genesis/GenesisInitializationTestExecutor.java @@ -79,6 +79,7 @@ private static class GenesisMetaData { @JsonProperty(value = "deposits_count", required = true) private int depositsCount; + @SuppressWarnings("FieldCanBeFinal") @JsonProperty(value = "execution_payload_header", required = false) private boolean executionPayloadHeader = false; diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/sanity/SanityBlocksTestExecutor.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/sanity/SanityBlocksTestExecutor.java index aa81f5b312c..0c9027b3da9 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/sanity/SanityBlocksTestExecutor.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/sanity/SanityBlocksTestExecutor.java @@ -41,8 +41,14 @@ public class SanityBlocksTestExecutor implements TestExecutor { private static final String STATE_ROOT_MISMATCH_ERROR_MESSAGE = "Block state root does NOT match the calculated state root"; + private static final List IGNORED_TEST_NAMES = List.of(); + @Override public void runTest(final TestDefinition testDefinition) throws Exception { + if (IGNORED_TEST_NAMES.contains(testDefinition.getTestName())) { + return; + } + final SanityBlocksMetaData metaData = loadYaml(testDefinition, "meta.yaml", SanityBlocksMetaData.class); final BeaconState preState = loadStateFromSsz(testDefinition, "pre.ssz_snappy"); diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/shuffling/ShufflingTestExecutor.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/shuffling/ShufflingTestExecutor.java index d2016a4aa88..9164cbd7c80 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/shuffling/ShufflingTestExecutor.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/shuffling/ShufflingTestExecutor.java @@ -67,7 +67,7 @@ public int[] getMapping() { return mapping; } - public int getMapping(int index) { + public int getMapping(final int index) { return mapping[index]; } } diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/slashing_protection_interchange/Attestation.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/slashing_protection_interchange/Attestation.java new file mode 100644 index 00000000000..0aa107d2e3c --- /dev/null +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/slashing_protection_interchange/Attestation.java @@ -0,0 +1,89 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.reference.phase0.slashing_protection_interchange; + +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.BOOLEAN_TYPE; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.BYTES32_TYPE; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; + +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.data.slashinginterchange.SigningHistory; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; + +record Attestation( + BLSPublicKey pubkey, + UInt64 sourceEpoch, + UInt64 targetEpoch, + Bytes32 signingRoot, + boolean shouldSucceed) { + + static DeserializableTypeDefinition getJsonTypeDefinition() { + return DeserializableTypeDefinition.object(Attestation.class, AttestationBuilder.class) + .initializer(AttestationBuilder::new) + .finisher(AttestationBuilder::build) + .withField( + "pubkey", SigningHistory.PUBKEY_TYPE, Attestation::pubkey, AttestationBuilder::pubkey) + .withField( + "source_epoch", UINT64_TYPE, Attestation::sourceEpoch, AttestationBuilder::sourceEpoch) + .withField( + "target_epoch", UINT64_TYPE, Attestation::targetEpoch, AttestationBuilder::targetEpoch) + .withField( + "signing_root", BYTES32_TYPE, Attestation::signingRoot, AttestationBuilder::signingRoot) + .withField( + "should_succeed", + BOOLEAN_TYPE, + Attestation::shouldSucceed, + AttestationBuilder::shouldSucceed) + .build(); + } + + private static class AttestationBuilder { + BLSPublicKey pubkey; + UInt64 sourceEpoch; + UInt64 targetEpoch; + Bytes32 signingRoot; + boolean shouldSucceed; + + AttestationBuilder pubkey(final BLSPublicKey pubkey) { + this.pubkey = pubkey; + return this; + } + + AttestationBuilder sourceEpoch(final UInt64 sourceEpoch) { + this.sourceEpoch = sourceEpoch; + return this; + } + + AttestationBuilder targetEpoch(final UInt64 targetEpoch) { + this.targetEpoch = targetEpoch; + return this; + } + + AttestationBuilder signingRoot(final Bytes32 signingRoot) { + this.signingRoot = signingRoot; + return this; + } + + AttestationBuilder shouldSucceed(final boolean shouldSucceed) { + this.shouldSucceed = shouldSucceed; + return this; + } + + Attestation build() { + return new Attestation(pubkey, sourceEpoch, targetEpoch, signingRoot, shouldSucceed); + } + } +} diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/slashing_protection_interchange/Block.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/slashing_protection_interchange/Block.java new file mode 100644 index 00000000000..2629baa3c45 --- /dev/null +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/slashing_protection_interchange/Block.java @@ -0,0 +1,70 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.reference.phase0.slashing_protection_interchange; + +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.BOOLEAN_TYPE; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.BYTES32_TYPE; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; + +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.data.slashinginterchange.SigningHistory; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; + +record Block(BLSPublicKey pubkey, UInt64 slot, Bytes32 signingRoot, boolean shouldSucceed) { + + static DeserializableTypeDefinition getJsonTypeDefinition() { + return DeserializableTypeDefinition.object(Block.class, BlockBuilder.class) + .initializer(BlockBuilder::new) + .finisher(BlockBuilder::build) + .withField("slot", UINT64_TYPE, Block::slot, BlockBuilder::slot) + .withField("pubkey", SigningHistory.PUBKEY_TYPE, Block::pubkey, BlockBuilder::pubkey) + .withField("signing_root", BYTES32_TYPE, Block::signingRoot, BlockBuilder::signingRoot) + .withField( + "should_succeed", BOOLEAN_TYPE, Block::shouldSucceed, BlockBuilder::shouldSucceed) + .build(); + } + + static class BlockBuilder { + BLSPublicKey pubkey; + UInt64 slot; + Bytes32 signingRoot; + boolean shouldSucceed; + + BlockBuilder pubkey(final BLSPublicKey pubkey) { + this.pubkey = pubkey; + return this; + } + + BlockBuilder slot(final UInt64 slot) { + this.slot = slot; + return this; + } + + BlockBuilder signingRoot(final Bytes32 signingRoot) { + this.signingRoot = signingRoot; + return this; + } + + BlockBuilder shouldSucceed(final boolean shouldSucceed) { + this.shouldSucceed = shouldSucceed; + return this; + } + + public Block build() { + return new Block(pubkey, slot, signingRoot, shouldSucceed); + } + } +} diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/slashing_protection_interchange/SlashingProtectionInterchangeTestExecutor.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/slashing_protection_interchange/SlashingProtectionInterchangeTestExecutor.java new file mode 100644 index 00000000000..9652b21f184 --- /dev/null +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/slashing_protection_interchange/SlashingProtectionInterchangeTestExecutor.java @@ -0,0 +1,138 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.reference.phase0.slashing_protection_interchange; + +import static org.assertj.core.api.Assertions.assertThat; + +import java.io.IOException; +import java.io.UncheckedIOException; +import java.nio.file.DirectoryStream; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.Map; +import java.util.Optional; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.data.SlashingProtectionImporter; +import tech.pegasys.teku.data.slashinginterchange.SlashingProtectionInterchangeFormat; +import tech.pegasys.teku.ethtests.finder.TestDefinition; +import tech.pegasys.teku.infrastructure.io.SyncDataAccessor; +import tech.pegasys.teku.infrastructure.json.JsonUtil; +import tech.pegasys.teku.reference.TestDataUtils; +import tech.pegasys.teku.reference.TestExecutor; +import tech.pegasys.teku.spec.signatures.LocalSlashingProtector; + +public class SlashingProtectionInterchangeTestExecutor implements TestExecutor { + + private static final Logger LOG = LogManager.getLogger(); + + @Override + public void runTest(final TestDefinition testDefinition) throws Throwable { + final TestData testData = + TestDataUtils.loadJson( + testDefinition, testDefinition.getTestName(), TestData.getJsonTypeDefinition()); + + // our implementation fails when importing one of the keys in an interchange, which is already + // in our slashprotection directory with a different genesis validators root. However, the test + // does not import any keys. This case is covered by + // SlashingProtectionImporterTest#shouldFailImportingIfValidatorExistingRecordHasDifferentGenesisValidatorsRoot() + if (testData.name().startsWith("wrong_genesis_validators_root")) { + LOG.info("Skipping {}", testData.name()); + return; + } + + LOG.info("Running {}", testData.name()); + + final Path slashingProtectionPath = Files.createTempDirectory("slashprotection"); + try { + runTest(testData, slashingProtectionPath); + } finally { + deleteDirectory(slashingProtectionPath); + } + } + + private void runTest(final TestData testData, final Path slashingProtectionPath) { + final SlashingProtectionImporter importer = + new SlashingProtectionImporter(slashingProtectionPath); + final LocalSlashingProtector slashingProtector = + new LocalSlashingProtector( + SyncDataAccessor.create(slashingProtectionPath), slashingProtectionPath); + testData.steps().forEach(step -> runStep(step, importer, slashingProtector)); + } + + private void runStep( + final Step step, + final SlashingProtectionImporter importer, + final LocalSlashingProtector slashingProtector) { + final Map importErrors = importInterchange(importer, step.interchange()); + if (step.shouldSucceed()) { + assertThat(importErrors).isEmpty(); + } else { + assertThat(importErrors).isNotEmpty(); + } + final Bytes32 genesisValidatorsRoot = + step.interchange().metadata().genesisValidatorsRoot().orElse(null); + step.blocks() + .forEach( + block -> + assertThat( + slashingProtector.maySignBlock( + block.pubkey(), genesisValidatorsRoot, block.slot())) + .isCompletedWithValue(block.shouldSucceed())); + step.attestations() + .forEach( + attestation -> + assertThat( + slashingProtector.maySignAttestation( + attestation.pubkey(), + genesisValidatorsRoot, + attestation.sourceEpoch(), + attestation.targetEpoch())) + .isCompletedWithValue(attestation.shouldSucceed())); + } + + private Map importInterchange( + final SlashingProtectionImporter importer, + final SlashingProtectionInterchangeFormat interchange) { + try { + final Path importFile = Files.createTempFile("import", ".json"); + final String data = + JsonUtil.serialize( + interchange, SlashingProtectionInterchangeFormat.getJsonTypeDefinition()); + Files.writeString(importFile, data); + final Optional initialiseError = importer.initialise(importFile.toFile()); + assertThat(initialiseError).isEmpty(); + // cleanup + Files.delete(importFile); + } catch (IOException ex) { + throw new UncheckedIOException(ex); + } + return importer.updateLocalRecords(status -> LOG.info("Import status: " + status)); + } + + private void deleteDirectory(final Path dir) { + try (DirectoryStream files = Files.newDirectoryStream(dir)) { + for (Path file : files) { + if (Files.isRegularFile(file)) { + Files.delete(file); + } + } + Files.delete(dir); + } catch (IOException ex) { + throw new UncheckedIOException(ex); + } + } +} diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/slashing_protection_interchange/Step.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/slashing_protection_interchange/Step.java new file mode 100644 index 00000000000..f3e3d8fa96c --- /dev/null +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/slashing_protection_interchange/Step.java @@ -0,0 +1,94 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.reference.phase0.slashing_protection_interchange; + +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.BOOLEAN_TYPE; + +import java.util.List; +import tech.pegasys.teku.data.slashinginterchange.SlashingProtectionInterchangeFormat; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; + +record Step( + boolean shouldSucceed, + // we don't fail importing when the interchange contains slashable data, so can safely + // ignore this field in the tests + boolean containsSlashableData, + SlashingProtectionInterchangeFormat interchange, + List blocks, + List attestations) { + static DeserializableTypeDefinition getJsonTypeDefinition() { + return DeserializableTypeDefinition.object(Step.class, StepBuilder.class) + .initializer(StepBuilder::new) + .finisher(StepBuilder::build) + .withField("should_succeed", BOOLEAN_TYPE, Step::shouldSucceed, StepBuilder::shouldSucceed) + .withField( + "contains_slashable_data", + BOOLEAN_TYPE, + Step::containsSlashableData, + StepBuilder::containsSlashableData) + .withField( + "interchange", + SlashingProtectionInterchangeFormat.getJsonTypeDefinition(), + Step::interchange, + StepBuilder::interchange) + .withField( + "blocks", + DeserializableTypeDefinition.listOf(Block.getJsonTypeDefinition()), + Step::blocks, + StepBuilder::blocks) + .withField( + "attestations", + DeserializableTypeDefinition.listOf(Attestation.getJsonTypeDefinition()), + Step::attestations, + StepBuilder::attestations) + .build(); + } + + static class StepBuilder { + boolean shouldSucceed; + boolean containsSlashableData; + SlashingProtectionInterchangeFormat interchange; + List blocks; + List attestations; + + StepBuilder shouldSucceed(final boolean shouldSucceed) { + this.shouldSucceed = shouldSucceed; + return this; + } + + StepBuilder containsSlashableData(final boolean containsSlashableData) { + this.containsSlashableData = containsSlashableData; + return this; + } + + StepBuilder interchange(final SlashingProtectionInterchangeFormat interchange) { + this.interchange = interchange; + return this; + } + + StepBuilder blocks(final List blocks) { + this.blocks = blocks; + return this; + } + + StepBuilder attestations(final List attestations) { + this.attestations = attestations; + return this; + } + + Step build() { + return new Step(shouldSucceed, containsSlashableData, interchange, blocks, attestations); + } + } +} diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/slashing_protection_interchange/TestData.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/slashing_protection_interchange/TestData.java new file mode 100644 index 00000000000..9a91e8545e4 --- /dev/null +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/slashing_protection_interchange/TestData.java @@ -0,0 +1,65 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.reference.phase0.slashing_protection_interchange; + +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.BYTES32_TYPE; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.STRING_TYPE; +import static tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition.listOf; + +import java.util.List; +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; + +record TestData(String name, Bytes32 genesisValidatorsRoot, List steps) { + + static DeserializableTypeDefinition getJsonTypeDefinition() { + return DeserializableTypeDefinition.object(TestData.class, TestDataBuilder.class) + .initializer(TestDataBuilder::new) + .finisher(TestDataBuilder::build) + .withField("name", STRING_TYPE, TestData::name, TestDataBuilder::name) + .withField( + "genesis_validators_root", + BYTES32_TYPE, + TestData::genesisValidatorsRoot, + TestDataBuilder::genesisValidatorsRoot) + .withField( + "steps", listOf(Step.getJsonTypeDefinition()), TestData::steps, TestDataBuilder::steps) + .build(); + } + + static class TestDataBuilder { + private String name; + private Bytes32 genesisValidatorsRoot; + private List steps; + + TestDataBuilder steps(final List steps) { + this.steps = steps; + return this; + } + + TestDataBuilder name(final String name) { + this.name = name; + return this; + } + + TestDataBuilder genesisValidatorsRoot(final Bytes32 genesisValidatorsRoot) { + this.genesisValidatorsRoot = genesisValidatorsRoot; + return this; + } + + TestData build() { + return new TestData(name, genesisValidatorsRoot, steps); + } + } +} diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/ssz_generic/SszGenericBasicVectorTestExecutor.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/ssz_generic/SszGenericBasicVectorTestExecutor.java index c6d25d2dc93..8f6174f6f8b 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/ssz_generic/SszGenericBasicVectorTestExecutor.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/ssz_generic/SszGenericBasicVectorTestExecutor.java @@ -78,15 +78,20 @@ protected String parseString(final TestDefinition testDefinition, final String v private SszSchema getElementSchema(final TestDefinition testDefinition) { final String elementType = getElementType(testDefinition); return switch (elementType) { - // bool is not a bit in this case, it's a full one byte boolean which we don't support + // bool is not a bit in this case, it's a full one byte boolean which we don't support case "bool", "uint8" -> SszPrimitiveSchemas.BYTE_SCHEMA; case "uint16" -> UINT16_SCHEMA; case "uint64" -> SszPrimitiveSchemas.UINT64_SCHEMA; case "uint256" -> SszPrimitiveSchemas.UINT256_SCHEMA; - case "uint32", "uint128" -> throw new TestAbortedException( - "Element type not supported: " + elementType + " From: " + testDefinition.getTestName()); - default -> throw new UnsupportedOperationException( - "No schema for type: " + testDefinition.getTestName()); + case "uint32", "uint128" -> + throw new TestAbortedException( + "Element type not supported: " + + elementType + + " From: " + + testDefinition.getTestName()); + default -> + throw new UnsupportedOperationException( + "No schema for type: " + testDefinition.getTestName()); }; } diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/ssz_generic/SszGenericContainerTestExecutor.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/ssz_generic/SszGenericContainerTestExecutor.java index 26254162655..9cadc40622f 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/ssz_generic/SszGenericContainerTestExecutor.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/ssz_generic/SszGenericContainerTestExecutor.java @@ -70,7 +70,7 @@ protected SszSchema getSchema(final TestDefinition testDefinition) { case "VarTestStruct" -> new VarTestStructSchema(); case "FixedTestStruct" -> new FixedTestStructSchema(); case "ComplexTestStruct" -> // Not implemented yet - new ComplexTestStructSchema(); + new ComplexTestStructSchema(); default -> throw new UnsupportedOperationException("Unsupported container type: " + type); }; } @@ -91,8 +91,8 @@ private Map formatSszContainer(final SszContainer container) { private String format(final Object value) { return switch (value) { case SszByte sszByte -> Integer.toString(Byte.toUnsignedInt(sszByte.get())); - case SszBytes4 sszBytes4 -> Long.toString( - sszBytes4.get().getWrappedBytes().toLong(ByteOrder.LITTLE_ENDIAN)); + case SszBytes4 sszBytes4 -> + Long.toString(sszBytes4.get().getWrappedBytes().toLong(ByteOrder.LITTLE_ENDIAN)); case SszBitlist sszBits -> sszBits.sszSerialize().toHexString(); case SszByteList sszBytes -> sszBytes.sszSerialize().toHexString(); case SszBitvector bitvector -> bitvector.sszSerialize().toHexString(); diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/ssz_generic/SszGenericUIntTestExecutor.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/ssz_generic/SszGenericUIntTestExecutor.java index c587e003411..3619d7859d5 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/ssz_generic/SszGenericUIntTestExecutor.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/ssz_generic/SszGenericUIntTestExecutor.java @@ -36,10 +36,12 @@ protected SszSchema getSchema(final TestDefinition testDefinition) { case 16 -> UINT16_SCHEMA; case 64 -> SszPrimitiveSchemas.UINT64_SCHEMA; case 256 -> SszPrimitiveSchemas.UINT256_SCHEMA; - case 32, 128 -> throw new TestAbortedException( - "UInt type not supported: " + testDefinition.getTestName()); - default -> throw new UnsupportedOperationException( - "No schema for type: " + testDefinition.getTestName()); + case 32, 128 -> + throw new TestAbortedException( + "UInt type not supported: " + testDefinition.getTestName()); + default -> + throw new UnsupportedOperationException( + "No schema for type: " + testDefinition.getTestName()); }; } @@ -50,10 +52,12 @@ protected Object parseString(final TestDefinition testDefinition, final String v case 16 -> SszUInt16.of(Integer.parseInt(value)); case 64 -> SszUInt64.of(UInt64.valueOf(value)); case 256 -> SszUInt256.of(UInt256.valueOf(new BigInteger(value))); - case 32, 128 -> throw new TestAbortedException( - "UInt type not supported: " + testDefinition.getTestName()); - default -> throw new UnsupportedOperationException( - "No parser for type: " + testDefinition.getTestName()); + case 32, 128 -> + throw new TestAbortedException( + "UInt type not supported: " + testDefinition.getTestName()); + default -> + throw new UnsupportedOperationException( + "No parser for type: " + testDefinition.getTestName()); }; } } diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/ssz_generic/containers/SszUInt16.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/ssz_generic/containers/SszUInt16.java index 7ccb7abab9d..2f9d5636754 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/ssz_generic/containers/SszUInt16.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/ssz_generic/containers/SszUInt16.java @@ -15,13 +15,13 @@ import tech.pegasys.teku.infrastructure.ssz.impl.AbstractSszPrimitive; -public class SszUInt16 extends AbstractSszPrimitive { +public class SszUInt16 extends AbstractSszPrimitive { - public static SszUInt16 of(Integer val) { + public static SszUInt16 of(final Integer val) { return new SszUInt16(val); } - private SszUInt16(Integer val) { + private SszUInt16(final Integer val) { super(val, UInt16PrimitiveSchema.UINT16_SCHEMA); } } diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/ssz_generic/containers/UInt16PrimitiveSchema.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/ssz_generic/containers/UInt16PrimitiveSchema.java index e471907f01b..6da07d002be 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/ssz_generic/containers/UInt16PrimitiveSchema.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/ssz_generic/containers/UInt16PrimitiveSchema.java @@ -33,7 +33,7 @@ private UInt16PrimitiveSchema() { } @Override - public Integer createFromLeafBackingNode(LeafDataNode node, int internalIndex) { + public Integer createFromLeafBackingNode(final LeafDataNode node, final int internalIndex) { // reverse() is due to LE -> BE conversion Bytes leafNodeBytes = node.getData(); Bytes elementBytes = leafNodeBytes.slice(internalIndex * 2, 2); @@ -41,13 +41,14 @@ public Integer createFromLeafBackingNode(LeafDataNode node, int internalIndex) { } @Override - public TreeNode updateBackingNode(TreeNode srcNode, int internalIndex, SszData newValue) { + public TreeNode updateBackingNode( + final TreeNode srcNode, final int internalIndex, final SszData newValue) { final Integer intValue = ((SszUInt16) newValue).get(); return LeafNode.create(Bytes.ofUnsignedInt(intValue, ByteOrder.LITTLE_ENDIAN)); } @Override - public SszUInt16 boxed(Integer rawValue) { + public SszUInt16 boxed(final Integer rawValue) { return SszUInt16.of(rawValue); } diff --git a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/ssz_static/SszTestExecutor.java b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/ssz_static/SszTestExecutor.java index 4cf8c8d6f69..affcc9c802e 100644 --- a/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/ssz_static/SszTestExecutor.java +++ b/eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/ssz_static/SszTestExecutor.java @@ -49,6 +49,7 @@ import tech.pegasys.teku.spec.schemas.SchemaDefinitionsCapella; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsDeneb; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsEip7594; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; public class SszTestExecutor implements TestExecutor { private final SchemaProvider sszType; @@ -186,6 +187,42 @@ public class SszTestExecutor implements TestExecutor { "ssz_static/BlobIdentifier", new SszTestExecutor<>(schemas -> BlobIdentifier.SSZ_SCHEMA)) + // Electra types + .put( + "ssz_static/ExecutionRequests", + new SszTestExecutor<>( + schemas -> + SchemaDefinitionsElectra.required(schemas).getExecutionRequestsSchema())) + .put( + "ssz_static/DepositRequest", + new SszTestExecutor<>( + schemas -> SchemaDefinitionsElectra.required(schemas).getDepositRequestSchema())) + .put( + "ssz_static/WithdrawalRequest", + new SszTestExecutor<>( + schemas -> + SchemaDefinitionsElectra.required(schemas).getWithdrawalRequestSchema())) + .put( + "ssz_static/ConsolidationRequest", + new SszTestExecutor<>( + schemas -> + SchemaDefinitionsElectra.required(schemas).getConsolidationRequestSchema())) + .put( + "ssz_static/PendingDeposit", + new SszTestExecutor<>( + schemas -> SchemaDefinitionsElectra.required(schemas).getPendingDepositSchema())) + .put( + "ssz_static/PendingConsolidation", + new SszTestExecutor<>( + schemas -> + SchemaDefinitionsElectra.required(schemas).getPendingConsolidationSchema())) + .put( + "ssz_static/PendingPartialWithdrawal", + new SszTestExecutor<>( + schemas -> + SchemaDefinitionsElectra.required(schemas) + .getPendingPartialWithdrawalSchema())) + // EIP7594 types .put( "ssz_static/DataColumnIdentifier", @@ -199,6 +236,7 @@ public class SszTestExecutor implements TestExecutor { "ssz_static/MatrixEntry", new SszTestExecutor<>( schemas -> SchemaDefinitionsEip7594.required(schemas).getMatrixEntrySchema())) + // Legacy Schemas (Not yet migrated to SchemaDefinitions) .put( "ssz_static/AttestationData", new SszTestExecutor<>(__ -> AttestationData.SSZ_SCHEMA)) diff --git a/eth-tests/build.gradle b/eth-tests/build.gradle index 4536695d768..8b36a75caf4 100644 --- a/eth-tests/build.gradle +++ b/eth-tests/build.gradle @@ -11,7 +11,7 @@ dependencies { implementation 'com.fasterxml.jackson.core:jackson-databind' implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-yaml' implementation 'org.apache.commons:commons-text' - implementation 'org.apache.tuweni:tuweni-bytes' - implementation 'org.apache.tuweni:tuweni-units' + implementation 'io.tmio:tuweni-bytes' + implementation 'io.tmio:tuweni-units' implementation 'org.junit.jupiter:junit-jupiter-params' } diff --git a/eth-tests/src/main/java/tech/pegasys/teku/ethtests/ReferenceTestGenerator.java b/eth-tests/src/main/java/tech/pegasys/teku/ethtests/ReferenceTestGenerator.java index 62828c3e1af..07cab09c138 100644 --- a/eth-tests/src/main/java/tech/pegasys/teku/ethtests/ReferenceTestGenerator.java +++ b/eth-tests/src/main/java/tech/pegasys/teku/ethtests/ReferenceTestGenerator.java @@ -32,7 +32,7 @@ public class ReferenceTestGenerator { public static final Charset CHARSET = StandardCharsets.UTF_8; - public static void main(String[] args) throws IOException { + public static void main(final String[] args) throws IOException { final Path outputDir = Path.of(args[0]); try (final Stream tests = ReferenceTestFinder.findReferenceTests()) { tests.forEach(testDefinition -> generateReferenceTest(outputDir, testDefinition)); diff --git a/eth-tests/src/main/java/tech/pegasys/teku/ethtests/TestFork.java b/eth-tests/src/main/java/tech/pegasys/teku/ethtests/TestFork.java index 7204446920d..824216c1806 100644 --- a/eth-tests/src/main/java/tech/pegasys/teku/ethtests/TestFork.java +++ b/eth-tests/src/main/java/tech/pegasys/teku/ethtests/TestFork.java @@ -19,5 +19,6 @@ public class TestFork { public static final String BELLATRIX = "bellatrix"; public static final String CAPELLA = "capella"; public static final String DENEB = "deneb"; + public static final String ELECTRA = "electra"; public static final String EIP7594 = "eip7594"; } diff --git a/eth-tests/src/main/java/tech/pegasys/teku/ethtests/finder/BlsRefTestFinder.java b/eth-tests/src/main/java/tech/pegasys/teku/ethtests/finder/BlsRefTestFinder.java index 14ede1f211d..a67f28e2af7 100644 --- a/eth-tests/src/main/java/tech/pegasys/teku/ethtests/finder/BlsRefTestFinder.java +++ b/eth-tests/src/main/java/tech/pegasys/teku/ethtests/finder/BlsRefTestFinder.java @@ -26,27 +26,27 @@ public class BlsRefTestFinder implements TestFinder { @Override @MustBeClosed - public Stream findTests(final String fork, final String spec, final Path testRoot) - throws IOException { - if (!spec.equals("bls")) { + public Stream findTests( + final String fork, final String config, final Path testRoot) throws IOException { + if (!config.equals("bls")) { return Stream.empty(); } return Files.list(testRoot) .filter(path -> path.toFile().isDirectory()) - .flatMap(unchecked(path -> findBlsTests(spec, testRoot, path))); + .flatMap(unchecked(path -> findBlsTests(config, testRoot, path))); } @MustBeClosed private Stream findBlsTests( - final String spec, final Path testRoot, final Path testCategoryDir) throws IOException { - final String testType = "bls/" + testRoot.relativize(testCategoryDir).toString(); + final String config, final Path testRoot, final Path testCategoryDir) throws IOException { + final String testType = "bls/" + testRoot.relativize(testCategoryDir); return Files.list(testCategoryDir) .filter(file -> file.toFile().getName().endsWith(".yaml")) .map( testFile -> new TestDefinition( "", - spec, + config, testType, testFile.toFile().getName(), testRoot.relativize(testCategoryDir))); diff --git a/eth-tests/src/main/java/tech/pegasys/teku/ethtests/finder/ReferenceTestFinder.java b/eth-tests/src/main/java/tech/pegasys/teku/ethtests/finder/ReferenceTestFinder.java index 6160811ca70..cd802da99f7 100644 --- a/eth-tests/src/main/java/tech/pegasys/teku/ethtests/finder/ReferenceTestFinder.java +++ b/eth-tests/src/main/java/tech/pegasys/teku/ethtests/finder/ReferenceTestFinder.java @@ -36,6 +36,7 @@ public class ReferenceTestFinder { TestFork.BELLATRIX, TestFork.CAPELLA, TestFork.DENEB, + TestFork.ELECTRA, TestFork.EIP7594); @MustBeClosed @@ -47,7 +48,10 @@ public static Stream findReferenceTests() throws IOException { private static Stream findTestTypes(final Path specDirectory) throws IOException { final String spec = specDirectory.getFileName().toString(); if (spec.equals("bls")) { - return new BlsRefTestFinder().findTests(TestFork.PHASE0, spec, specDirectory); + return new BlsRefTestFinder().findTests("", spec, specDirectory); + } + if (spec.equals("slashing-protection-interchange")) { + return new SlashingProtectionInterchangeRefTestFinder().findTests("", spec, specDirectory); } return SUPPORTED_FORKS.stream() .flatMap( @@ -60,7 +64,6 @@ private static Stream findTestTypes(final Path specDirectory) th return Stream.of( new BlsTestFinder(), new KzgTestFinder(), - new BlsRefTestFinder(), new SszTestFinder("ssz_generic"), new SszTestFinder("ssz_static"), new ShufflingTestFinder(), diff --git a/eth-tests/src/main/java/tech/pegasys/teku/ethtests/finder/SlashingProtectionInterchangeRefTestFinder.java b/eth-tests/src/main/java/tech/pegasys/teku/ethtests/finder/SlashingProtectionInterchangeRefTestFinder.java new file mode 100644 index 00000000000..6470bb4ea3f --- /dev/null +++ b/eth-tests/src/main/java/tech/pegasys/teku/ethtests/finder/SlashingProtectionInterchangeRefTestFinder.java @@ -0,0 +1,42 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.ethtests.finder; + +import com.google.errorprone.annotations.MustBeClosed; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.stream.Stream; + +public class SlashingProtectionInterchangeRefTestFinder implements TestFinder { + + @Override + @MustBeClosed + public Stream findTests( + final String fork, final String config, final Path testRoot) throws IOException { + if (!config.equals("slashing-protection-interchange")) { + return Stream.empty(); + } + return Files.list(testRoot) + .filter(file -> file.toFile().getName().endsWith(".json")) + .map( + testFile -> + new TestDefinition( + fork, + config, + config, + testFile.toFile().getName(), + testRoot.relativize(testFile.getParent()))); + } +} diff --git a/eth-tests/src/main/java/tech/pegasys/teku/ethtests/finder/TestDefinition.java b/eth-tests/src/main/java/tech/pegasys/teku/ethtests/finder/TestDefinition.java index bfce0401d5b..304ba32f35d 100644 --- a/eth-tests/src/main/java/tech/pegasys/teku/ethtests/finder/TestDefinition.java +++ b/eth-tests/src/main/java/tech/pegasys/teku/ethtests/finder/TestDefinition.java @@ -72,10 +72,20 @@ private void createSpec() { case TestFork.BELLATRIX -> SpecMilestone.BELLATRIX; case TestFork.CAPELLA -> SpecMilestone.CAPELLA; case TestFork.DENEB -> SpecMilestone.DENEB; - case TestFork.EIP7594 -> SpecMilestone.EIP7594; + case TestFork.ELECTRA -> SpecMilestone.ELECTRA; + case TestFork.EIP7594 -> SpecMilestone.ELECTRA; default -> throw new IllegalArgumentException("Unknown fork: " + fork); }; - spec = TestSpecFactory.create(milestone, network); + // TODO: refactor + if (fork.equals(TestFork.EIP7594)) { + if (configName.equals(TestSpecConfig.MAINNET)) { + spec = TestSpecFactory.createMainnetElectraEip7594(); + } else { + spec = TestSpecFactory.createMinimalElectraEip7594(); + } + } else { + spec = TestSpecFactory.create(milestone, network); + } } public String getTestType() { diff --git a/ethereum/dataproviders/build.gradle b/ethereum/dataproviders/build.gradle index 5628beade60..62b4dfc745d 100644 --- a/ethereum/dataproviders/build.gradle +++ b/ethereum/dataproviders/build.gradle @@ -3,7 +3,7 @@ dependencies { implementation project(':infrastructure:async') implementation project(':infrastructure:metrics') - implementation 'org.apache.tuweni:tuweni-bytes' + implementation 'io.tmio:tuweni-bytes' testImplementation testFixtures(project(':ethereum:spec')) testImplementation testFixtures(project(':ethereum:networks')) diff --git a/ethereum/dataproviders/src/main/java/tech/pegasys/teku/dataproviders/generators/StateGenerator.java b/ethereum/dataproviders/src/main/java/tech/pegasys/teku/dataproviders/generators/StateGenerator.java index dadb22a485e..d18047f5695 100644 --- a/ethereum/dataproviders/src/main/java/tech/pegasys/teku/dataproviders/generators/StateGenerator.java +++ b/ethereum/dataproviders/src/main/java/tech/pegasys/teku/dataproviders/generators/StateGenerator.java @@ -47,7 +47,7 @@ private StateGenerator( } public static StateGenerator create( - Spec spec, + final Spec spec, final HashTree blockTree, final StateAndBlockSummary rootBlockAndState, final BlockProvider blockProvider) { diff --git a/ethereum/dataproviders/src/main/java/tech/pegasys/teku/dataproviders/lookup/BlockProvider.java b/ethereum/dataproviders/src/main/java/tech/pegasys/teku/dataproviders/lookup/BlockProvider.java index c5e61f4a22f..e37c19d009d 100644 --- a/ethereum/dataproviders/src/main/java/tech/pegasys/teku/dataproviders/lookup/BlockProvider.java +++ b/ethereum/dataproviders/src/main/java/tech/pegasys/teku/dataproviders/lookup/BlockProvider.java @@ -32,7 +32,7 @@ public interface BlockProvider { BlockProvider NOOP = (roots) -> SafeFuture.completedFuture(Collections.emptyMap()); - static BlockProvider fromDynamicMap(Supplier> mapSupplier) { + static BlockProvider fromDynamicMap(final Supplier> mapSupplier) { return (roots) -> fromMap(mapSupplier.get()).getBlocks(roots); } diff --git a/ethereum/dataproviders/src/test/java/tech/pegasys/teku/dataproviders/generators/StateCacheTest.java b/ethereum/dataproviders/src/test/java/tech/pegasys/teku/dataproviders/generators/StateCacheTest.java index 5d1897b4586..ba4ddb97bfb 100644 --- a/ethereum/dataproviders/src/test/java/tech/pegasys/teku/dataproviders/generators/StateCacheTest.java +++ b/ethereum/dataproviders/src/test/java/tech/pegasys/teku/dataproviders/generators/StateCacheTest.java @@ -65,7 +65,7 @@ public void put_exceedsMaxSize() { chain.stream() .filter(b -> !knownStates.containsKey(b.getRoot())) .limit(maxSize + 1) - .collect(Collectors.toList()); + .toList(); for (int i = 0; i < toAdd.size(); i++) { SignedBlockAndState blockAndState = toAdd.get(i); cache.put(blockAndState.getRoot(), blockAndState.getState()); diff --git a/ethereum/dataproviders/src/test/java/tech/pegasys/teku/dataproviders/generators/StateGeneratorTest.java b/ethereum/dataproviders/src/test/java/tech/pegasys/teku/dataproviders/generators/StateGeneratorTest.java index 7f5c42e830f..c8e1a5f4c38 100644 --- a/ethereum/dataproviders/src/test/java/tech/pegasys/teku/dataproviders/generators/StateGeneratorTest.java +++ b/ethereum/dataproviders/src/test/java/tech/pegasys/teku/dataproviders/generators/StateGeneratorTest.java @@ -119,7 +119,7 @@ public void regenerateStateForBlock_blockPastTargetIsMissing() { } private void testGeneratorWithMissingBlock( - BiConsumer processor) { + final BiConsumer processor) { // Build a small chain final SignedBlockAndState genesis = chainBuilder.generateGenesis(); chainBuilder.generateBlocksUpToSlot(5); diff --git a/ethereum/dataproviders/src/test/java/tech/pegasys/teku/dataproviders/generators/StreamingStateRegeneratorTest.java b/ethereum/dataproviders/src/test/java/tech/pegasys/teku/dataproviders/generators/StreamingStateRegeneratorTest.java index 5f822586fc3..97afaa071e6 100644 --- a/ethereum/dataproviders/src/test/java/tech/pegasys/teku/dataproviders/generators/StreamingStateRegeneratorTest.java +++ b/ethereum/dataproviders/src/test/java/tech/pegasys/teku/dataproviders/generators/StreamingStateRegeneratorTest.java @@ -16,7 +16,6 @@ import static org.assertj.core.api.Assertions.assertThat; import java.util.List; -import java.util.stream.Collectors; import org.junit.jupiter.api.Test; import tech.pegasys.teku.bls.BLSKeyGenerator; import tech.pegasys.teku.bls.BLSKeyPair; @@ -41,10 +40,9 @@ void shouldHandleValidChainFromGenesis() throws Exception { final List newBlocksAndStates = chainBuilder .streamBlocksAndStates(genesis.getSlot().plus(UInt64.ONE), chainBuilder.getLatestSlot()) - .collect(Collectors.toList()); + .toList(); - final SignedBlockAndState lastBlockAndState = - newBlocksAndStates.get(newBlocksAndStates.size() - 1); + final SignedBlockAndState lastBlockAndState = newBlocksAndStates.getLast(); final BeaconState result = StreamingStateRegenerator.regenerate( spec, diff --git a/ethereum/execution-types/build.gradle b/ethereum/execution-types/build.gradle index d45f6e99947..c8ce4745c85 100644 --- a/ethereum/execution-types/build.gradle +++ b/ethereum/execution-types/build.gradle @@ -1,7 +1,7 @@ dependencies { implementation project(':infrastructure:bytes') implementation project(':infrastructure:crypto') - + implementation project(':infrastructure:json') testFixturesApi project(':infrastructure:jackson') testImplementation project(':ethereum:json-types') diff --git a/ethereum/execution-types/src/main/java/tech/pegasys/teku/ethereum/execution/types/Eth1Address.java b/ethereum/execution-types/src/main/java/tech/pegasys/teku/ethereum/execution/types/Eth1Address.java index 4d261c191b5..acaba0cf867 100644 --- a/ethereum/execution-types/src/main/java/tech/pegasys/teku/ethereum/execution/types/Eth1Address.java +++ b/ethereum/execution-types/src/main/java/tech/pegasys/teku/ethereum/execution/types/Eth1Address.java @@ -21,8 +21,17 @@ import org.apache.tuweni.bytes.Bytes; import tech.pegasys.teku.infrastructure.bytes.Bytes20; import tech.pegasys.teku.infrastructure.crypto.Hash; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; public class Eth1Address extends Bytes20 { + public static final DeserializableTypeDefinition ETH1ADDRESS_TYPE = + DeserializableTypeDefinition.string(Eth1Address.class) + .formatter(Eth1Address::toHexString) + .parser(Eth1Address::fromHexString) + .example("0x1Db3439a222C519ab44bb1144fC28167b4Fa6EE6") + .description("Hex encoded deposit contract address with 0x prefix") + .format("byte") + .build(); private static final String ZERO_ADDRESS_STRING = "0x0000000000000000000000000000000000000000"; private static final int HEX_ADDRESS_STRING_LENGTH = ZERO_ADDRESS_STRING.length(); @@ -30,23 +39,24 @@ public class Eth1Address extends Bytes20 { private final String encodedAddress; - private Eth1Address(String value) { + private Eth1Address(final String value) { super(Bytes.fromHexString(value)); + String valueWithPrefix = value; if (!value.startsWith("0x")) { - value = "0x" + value; + valueWithPrefix = "0x" + value; } - this.encodedAddress = toChecksumAddress(value); - validate(value); + this.encodedAddress = toChecksumAddress(valueWithPrefix); + validate(valueWithPrefix); } - private Eth1Address(Bytes bytes) { + private Eth1Address(final Bytes bytes) { super(bytes); final String value = bytes.toHexString(); this.encodedAddress = toChecksumAddress(value); validate(value); } - private void validate(String value) { + private void validate(final String value) { if (isMixedCase(value.substring("0x".length()))) { checkArgument( value.equals(encodedAddress), @@ -56,11 +66,11 @@ private void validate(String value) { } } - public static Eth1Address fromBytes(Bytes value) { + public static Eth1Address fromBytes(final Bytes value) { return new Eth1Address(value); } - public static Eth1Address fromHexString(String value) { + public static Eth1Address fromHexString(final String value) { try { return new Eth1Address(value); } catch (RuntimeException ex) { @@ -75,7 +85,7 @@ public static Eth1Address fromHexString(String value) { * @param value The string representation of an Ethereum address. * @return The encoded address with mixed-case checksum. */ - private static String toChecksumAddress(String value) { + private static String toChecksumAddress(final String value) { final String address = value.replace("0x", "").toLowerCase(Locale.ROOT); final String hashString = Hash.keccak256(Bytes.wrap(address.getBytes(StandardCharsets.US_ASCII))) diff --git a/ethereum/execution-types/src/test/java/tech/pegasys/teku/ethereum/execution/types/Eth1AddressTest.java b/ethereum/execution-types/src/test/java/tech/pegasys/teku/ethereum/execution/types/Eth1AddressTest.java index 3e6f3bdaa77..48382c25b62 100644 --- a/ethereum/execution-types/src/test/java/tech/pegasys/teku/ethereum/execution/types/Eth1AddressTest.java +++ b/ethereum/execution-types/src/test/java/tech/pegasys/teku/ethereum/execution/types/Eth1AddressTest.java @@ -15,7 +15,7 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; -import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.ETH1ADDRESS_TYPE; +import static tech.pegasys.teku.ethereum.execution.types.Eth1Address.ETH1ADDRESS_TYPE; import static tech.pegasys.teku.infrastructure.json.DeserializableTypeUtil.assertRoundTrip; import org.apache.tuweni.bytes.Bytes; diff --git a/ethereum/executionclient/build.gradle b/ethereum/executionclient/build.gradle index b841ed91e78..24346553426 100644 --- a/ethereum/executionclient/build.gradle +++ b/ethereum/executionclient/build.gradle @@ -14,7 +14,7 @@ dependencies { implementation project(':ethereum:events') api 'org.web3j:core' - implementation 'org.apache.tuweni:tuweni-units' + implementation 'io.tmio:tuweni-units' implementation 'io.jsonwebtoken:jjwt-api' runtimeOnly 'io.jsonwebtoken:jjwt-impl' diff --git a/ethereum/executionclient/src/integration-test/java/tech/pegasys/teku/ethereum/executionclient/rest/RestBuilderClientTest.java b/ethereum/executionclient/src/integration-test/java/tech/pegasys/teku/ethereum/executionclient/rest/RestBuilderClientTest.java index 25104ce0e42..c7fb14d6100 100644 --- a/ethereum/executionclient/src/integration-test/java/tech/pegasys/teku/ethereum/executionclient/rest/RestBuilderClientTest.java +++ b/ethereum/executionclient/src/integration-test/java/tech/pegasys/teku/ethereum/executionclient/rest/RestBuilderClientTest.java @@ -17,6 +17,7 @@ import static tech.pegasys.teku.spec.SpecMilestone.BELLATRIX; import static tech.pegasys.teku.spec.SpecMilestone.CAPELLA; import static tech.pegasys.teku.spec.SpecMilestone.DENEB; +import static tech.pegasys.teku.spec.SpecMilestone.ELECTRA; import static tech.pegasys.teku.spec.schemas.ApiSchemas.SIGNED_VALIDATOR_REGISTRATIONS_SCHEMA; import com.fasterxml.jackson.core.JsonProcessingException; @@ -61,7 +62,7 @@ import tech.pegasys.teku.spec.schemas.SchemaDefinitionsBellatrix; @TestSpecContext( - milestone = {BELLATRIX, CAPELLA, DENEB}, + milestone = {BELLATRIX, CAPELLA, DENEB, ELECTRA}, network = Eth2Network.MAINNET) class RestBuilderClientTest { diff --git a/ethereum/executionclient/src/integration-test/java/tech/pegasys/teku/ethereum/executionclient/web3j/Web3JExecutionEngineClientTest.java b/ethereum/executionclient/src/integration-test/java/tech/pegasys/teku/ethereum/executionclient/web3j/Web3JExecutionEngineClientTest.java index d6829baa2c2..77a277721f0 100644 --- a/ethereum/executionclient/src/integration-test/java/tech/pegasys/teku/ethereum/executionclient/web3j/Web3JExecutionEngineClientTest.java +++ b/ethereum/executionclient/src/integration-test/java/tech/pegasys/teku/ethereum/executionclient/web3j/Web3JExecutionEngineClientTest.java @@ -23,7 +23,7 @@ import static org.mockito.Mockito.mock; import static tech.pegasys.teku.spec.SpecMilestone.CAPELLA; import static tech.pegasys.teku.spec.SpecMilestone.DENEB; -import static tech.pegasys.teku.spec.SpecMilestone.EIP7594; +import static tech.pegasys.teku.spec.SpecMilestone.ELECTRA; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.core.JsonFactory; @@ -48,6 +48,7 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.TestTemplate; import tech.pegasys.teku.ethereum.events.ExecutionClientEventsChannel; +import tech.pegasys.teku.ethereum.executionclient.schema.BlobAndProofV1; import tech.pegasys.teku.ethereum.executionclient.schema.ClientVersionV1; import tech.pegasys.teku.ethereum.executionclient.schema.ExecutionPayloadV3; import tech.pegasys.teku.ethereum.executionclient.schema.ForkChoiceStateV1; @@ -65,12 +66,13 @@ import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.TestSpecContext; import tech.pegasys.teku.spec.TestSpecInvocationContextProvider.SpecContext; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; import tech.pegasys.teku.spec.executionlayer.PayloadStatus; import tech.pegasys.teku.spec.logic.versions.deneb.types.VersionedHash; import tech.pegasys.teku.spec.util.DataStructureUtil; -@TestSpecContext(milestone = {CAPELLA, DENEB, EIP7594}) +@TestSpecContext(milestone = {CAPELLA, DENEB, ELECTRA}) public class Web3JExecutionEngineClientTest { private static final Duration DEFAULT_TIMEOUT = Duration.ofMinutes(1); @@ -89,7 +91,7 @@ public class Web3JExecutionEngineClientTest { Web3JExecutionEngineClient eeClient; @BeforeEach - void setUp(SpecContext specContext) throws IOException { + void setUp(final SpecContext specContext) throws IOException { jsonWriter = new StringWriter(); jsonGenerator = new JsonFactory().createGenerator(jsonWriter); objectMapper = new ObjectMapper(); @@ -299,6 +301,111 @@ public void newPayloadV3_shouldBuildRequestAndResponseSuccessfully() { .isEqualTo(parentBeaconBlockRoot.toHexString()); } + @TestTemplate + @SuppressWarnings("unchecked") + public void newPayloadV4_shouldBuildRequestAndResponseSuccessfully() { + assumeThat(specMilestone).isGreaterThanOrEqualTo(ELECTRA); + final Bytes32 latestValidHash = dataStructureUtil.randomBytes32(); + final PayloadStatus payloadStatusResponse = + PayloadStatus.valid(Optional.of(latestValidHash), Optional.empty()); + + final String bodyResponse = + "{\"jsonrpc\": \"2.0\", \"id\": 0, \"result\":" + + "{ \"status\": \"VALID\", \"latestValidHash\": \"" + + latestValidHash + + "\", \"validationError\": null}}"; + + mockSuccessfulResponse(bodyResponse); + + final ExecutionPayload executionPayload = dataStructureUtil.randomExecutionPayload(); + final ExecutionPayloadV3 executionPayloadV3 = + ExecutionPayloadV3.fromInternalExecutionPayload(executionPayload); + + final List blobVersionedHashes = dataStructureUtil.randomVersionedHashes(3); + final Bytes32 parentBeaconBlockRoot = dataStructureUtil.randomBytes32(); + final List executionRequests = dataStructureUtil.randomEncodedExecutionRequests(); + + final SafeFuture> futureResponse = + eeClient.newPayloadV4( + executionPayloadV3, blobVersionedHashes, parentBeaconBlockRoot, executionRequests); + + assertThat(futureResponse) + .succeedsWithin(1, TimeUnit.SECONDS) + .matches( + response -> + response.getPayload().asInternalExecutionPayload().equals(payloadStatusResponse)); + + final Map requestData = takeRequest(); + verifyJsonRpcMethodCall(requestData, "engine_newPayloadV4"); + + final Map executionPayloadV3Parameter = + (Map) ((List) requestData.get("params")).get(0); + // 17 fields in ExecutionPayloadV4 + assertThat(executionPayloadV3Parameter).hasSize(17); + // sanity check + assertThat(executionPayloadV3Parameter.get("parentHash")) + .isEqualTo(executionPayloadV3.parentHash.toHexString()); + + assertThat(((List) requestData.get("params")).get(1)) + .asInstanceOf(LIST) + .containsExactlyElementsOf( + blobVersionedHashes.stream() + .map(VersionedHash::toHexString) + .collect(Collectors.toList())); + assertThat(((List) requestData.get("params")).get(2)) + .asString() + .isEqualTo(parentBeaconBlockRoot.toHexString()); + assertThat(((List) requestData.get("params")).get(3)) + .asInstanceOf(LIST) + .containsExactlyElementsOf( + executionRequests.stream().map(Bytes::toHexString).collect(Collectors.toList())); + } + + @TestTemplate + @SuppressWarnings("unchecked") + public void getBlobsV1_shouldBuildRequestAndResponseSuccessfully() { + assumeThat(specMilestone).isGreaterThanOrEqualTo(DENEB); + final List blobSidecars = + dataStructureUtil.randomBlobSidecars( + spec.getMaxBlobsPerBlockForHighestMilestone().orElseThrow()); + final List blobsAndProofsV1 = + blobSidecars.stream() + .map( + blobSidecar -> + new BlobAndProofV1( + blobSidecar.getBlob().getBytes(), + blobSidecar.getKZGProof().getBytesCompressed())) + .toList(); + final String blobsAndProofsJson = + blobSidecars.stream() + .map( + blobSidecar -> + String.format( + "{ \"blob\": \"%s\", \"proof\": \"%s\" }", + blobSidecar.getBlob().getBytes().toHexString(), + blobSidecar.getKZGProof().getBytesCompressed().toHexString())) + .collect(Collectors.joining(", ")); + final String bodyResponse = + "{\"jsonrpc\": \"2.0\", \"id\": 0, \"result\": [" + blobsAndProofsJson + "]}"; + + mockSuccessfulResponse(bodyResponse); + + final List blobVersionedHashes = dataStructureUtil.randomVersionedHashes(3); + + final SafeFuture>> futureResponse = + eeClient.getBlobsV1(blobVersionedHashes); + + assertThat(futureResponse) + .succeedsWithin(1, TimeUnit.SECONDS) + .matches(response -> response.getPayload().equals(blobsAndProofsV1)); + + final Map requestData = takeRequest(); + verifyJsonRpcMethodCall(requestData, "engine_getBlobsV1"); + assertThat(requestData.get("params")) + .asInstanceOf(LIST) + .containsExactly(blobVersionedHashes.stream().map(VersionedHash::toHexString).toList()); + } + private void mockSuccessfulResponse(final String responseBody) { mockWebServer.enqueue( new MockResponse() diff --git a/ethereum/executionclient/src/integration-test/resources/builder/electra/signedBlindedBeaconBlock.json b/ethereum/executionclient/src/integration-test/resources/builder/electra/signedBlindedBeaconBlock.json new file mode 100644 index 00000000000..d2b5be60a88 --- /dev/null +++ b/ethereum/executionclient/src/integration-test/resources/builder/electra/signedBlindedBeaconBlock.json @@ -0,0 +1,386 @@ +{ + "message": { + "slot": "15072177864", + "proposer_index": "16245407908225876048", + "parent_root": "0xcbed55e1707a7c096f821b07d6c76b3848de6dfbf20b84f27492be74d57c28f5", + "state_root": "0xdf0e50e110c65b4e65c58232aa5080054ee16c8da8d4acaca213023dafdddf7f", + "body": { + "randao_reveal": "0xa67f2ce68ffd1652408e438379e52c2fcf199992268197ccd8254a5dbe944211985c8f69c02c4ecfe4994262ac238c480fc667bfbf034976ab33dadb5be68d331b64fb08f3ace18470853d9e3f7f3e226596f296c13e3ec15528aa48f773762c", + "eth1_data": { + "deposit_root": "0xb8cc5be1d02e9dc47a3fb4db023f576b42db6e693c435b3847117bacfa1b716a", + "deposit_count": "16230535554980751600", + "block_hash": "0x2b9338e190f4d8613ad11fe0f873d23967ed68d582f74f955918105e1861bdaa" + }, + "graffiti": "0x0000000000000000000000000000000000000000000000000000000000000000", + "proposer_slashings": [ + { + "signed_header_1": { + "message": { + "slot": "16233840521414119856", + "proposer_index": "16232188038197435728", + "parent_root": "0x64f626e170d77630199a5562730e10a17af6658ba551cac3e39bdab6a883e34a", + "state_root": "0x771721e1102356750eddbc8d4797246e80f9641d5b1af37d101d1e7f82e49ad5", + "body_root": "0x3eb432e13040b8a62f14870bccfce6066df0676738c0784f87995326f3c17435" + }, + "signature": "0x9546312bca8c3d15c7d65037c73cf1f655b9b733b15963ed11841a95393b4a5ef4701f0519b246ee4b5401143adec73d19e9ab66edd7f5b80a697efe7ef385c202c5eda60aef5a9ab5538ff472c88a71e51b6c9e57562e2a54276a6593878e10" + }, + "signed_header_2": { + "message": { + "slot": "16233840521414119856", + "proposer_index": "16232188038197435728", + "parent_root": "0x149d53e0ee79dddf9604db7c364cf3775b634213498b86f152c658e05d22adcc", + "state_root": "0x27be4de08ec5bc248b4742a809d50745616641a5ff53afab80479ca838836457", + "body_root": "0xee5a5fe0aee21e56ab7e0c268e3acadd4e5d44efdcf9347df7c3d14fa8603eb7" + }, + "signature": "0x8bcb16753558383288ed9c48d46479460a0731641b42d9255701dca118feff47fd739ac1c61bf5eb02025b69b5eaeba705236225246a0c5710f4f9ed7a07eb4281e6695f67d2287ca7aeef4cd2f6517d7d39a5f7d3f3aa1fc79025d9ffd90133" + } + } + ], + "attester_slashings": [ + { + "attestation_1": { + "attesting_indices": [ + "16157826259086911598", + "16156173775870227470", + "16161131229815247150" + ], + "data": { + "slot": "16159478742303595726", + "index": "16151216326220175086", + "beacon_block_root": "0xc0c61ee08e22b74b355f7c03a61bacad937e3935b299f57cee50b8ea0b8a1fad", + "source": { + "epoch": "880633795", + "root": "0x9a842ae04e8bf8c14ad9adacff09831387783b114508a408934e315a56c8b097" + }, + "target": { + "epoch": "879479548", + "root": "0x0c4b07e00e51345f0a6b19b1f53efee1ac8a357d8cbc9865a555c60b740dfdd7" + } + }, + "signature": "0xad1cea8ff7286e585a3795159cdfc8fb68596583a8681bc2dcb77ef016773e9c55e55bf8415fee3ba36dc9e7717337f6105dfcaa9a526aad4c6d7cf7e34cbeda7b185f2affd90b5d812e319493d06d44bf321a966833c1252757b1c7853c8952" + }, + "attestation_2": { + "attesting_indices": [ + "16157826259086911598", + "16156173775870227470", + "16161131229815247150" + ], + "data": { + "slot": "16146258872275155406", + "index": "16190875936305496047", + "beacon_block_root": "0xf5acabe08f0bc8d63718cef1cf47bf73fd3551859ac82209a43464249275eeab", + "source": { + "epoch": "885250782", + "root": "0xcf6ab7e04f74094d4d92ff9a283696d9f12f53612d37d1944832dd93ddb37f96" + }, + "target": { + "epoch": "884096535", + "root": "0x423194e00f3a45ea0c246b9f1e6b11a816424dcd73ebc5f15b397245fbf8cbd6" + } + }, + "signature": "0xb3e0837438c4e6d2b29f523b90d0e139d4f9be749962b3df8a78a5911dcccd0955cde2bf6d7bf3f82ed60fa7dd0a431d0c457f2ce861a4a312c2741783ae1ba660d63216890ee50d40e35cf1e60d3df4944917e051f8f08950874417f50ec2b5" + } + } + ], + "attestations": [ + { + "aggregation_bits": "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", + "data": { + "slot": "4605531939934246443", + "index": "4610489389584298827", + "beacon_block_root": "0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b", + "source": { + "epoch": "529421377", + "root": "0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2" + }, + "target": { + "epoch": "529806126", + "root": "0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd" + } + }, + "committee_bits": "0x4ac567b296efbf7c", + "signature": "0x8f8d16b39e14569aab1b712e5c19ed51afe3600a6b017e8ab432f43a02ee720a733c33ef087d2f3653a9701e8d8a836301655b9195c0373b775c88ba1368e5d55354a70a3096bd26dee29dddbe7a4820e2b1653e84122beacbc01af7d93e6bdc" + }, + { + "aggregation_bits": "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", + "data": { + "slot": "4542737547635478505", + "index": "4534475127257090569", + "beacon_block_root": "0x2ed2e73ea915e0c71d9afe03676b8ab8dd578b9311463e45934f49f843386a48", + "source": { + "epoch": "528267130", + "root": "0x0890f33e697e213e331430adc059611ed0518d6fa4b4ecd0384dc2678e76fb32" + }, + "target": { + "epoch": "527112883", + "root": "0x7a56d03e29445ddbf2a59bb1b68edcecf66387dbea68e12d4a545719acbb4773" + } + }, + "committee_bits": "0x4ac567b296efbf7c", + "signature": "0x8b88a54eb155233ec6d52f2e549cacd5d9bc79e05bf0915d9278a94c9a3c75e0d75167129d10e728550df65875ecef551085599499b226b88d238a71dfdd199be5de9fde058fbaf60cf7765b0e614d3bfa76c1c47281283d7bb2ff9a30247fc5" + }, + { + "aggregation_bits": "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", + "data": { + "slot": "4572482262715661994", + "index": "4577439708070747082", + "beacon_block_root": "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", + "source": { + "epoch": "531729870", + "root": "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672" + }, + "target": { + "epoch": "532114619", + "root": "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c" + } + }, + "committee_bits": "0x4ac567b296efbf7c", + "signature": "0x8ab48d0165e8cc8bfc6804760141896946c3be751af5f16d1a03ead456ebceab88a8168e1da194df56c512edc15ca6350c413cb819d31a7ef69b329d8cb9fa8e5d93ae66289a445f1465d57d97e72d4c0866e48a806df7f58ebcd060e2d03a72" + } + ], + "deposits": [ + { + "proof": [ + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688", + "0x6ca564ce8e7cf641b18d4912ab42adec72a03d0c4aa81b9a22608d9e71fdd688" + ], + "data": { + "pubkey": "0x95f491f3e77fa1dc8a187c1a78717adedfdbb563175c56d782aff2144e7daf336959b4ce6c24323418e0e21d93ce487f", + "withdrawal_credentials": "0xdf6b41ce4e4232df701fb516a17728bb97b23778905c10f7356722508f4223c9", + "amount": "32000000000", + "signature": "0x8d2d5871895de5f735e4b42874b7e525375e07cd132a6252021a32544fea3313c0b6230c05565bd9974280c5c06206ad142cbed575bbfd28ec79dde017844ad7aad978d7946c45cd8fb096b57367aa696ba1a993976eddcb71e697505f0cd3be" + } + } + ], + "voluntary_exits": [ + { + "message": { + "epoch": "14865583816704240398", + "validator_index": "14860626367054188014" + }, + "signature": "0xafc3937894fb5fd3475a6ab83a36ee846844fceb58d9dcbcfd21ba537a983a2de1bbcfde84b3da33c227626689c41da3078da1d7a734991407cd67ff2f8b09720e804270996dc2c6558ee8fdef4e68c40c532dd2c40ac586bc572c666a563df1" + } + ], + "sync_aggregate": { + "sync_committee_bits": "0x145d5c188ceac5989ccd022005035da255b149a1f4bfe2a1d4ff074188777c7db6f13f4a2fb490a312df10b5bb11e2ba2ddd66c2b3ada8b4dbd4c456a9f17ac7", + "sync_committee_signature": "0x8a2dd5f9ae4c22342cbf53f11035f6a514da5002a18751990d27d72622d887d9e618447b14e34dddbaa201e640ef988d051b6cf13392924d5239f4c1e831a3cebcf8da68adf74853d278244b5dd351b086723f2a1463d4ef0bd38ee75c62e5bc" + }, + "execution_payload_header": { + "parent_hash": "0x777412ce4e9f2c061a37ef713ebecc23c9ca2f0843a256c8a3703e926249de1e", + "fee_recipient": "0x8a950cceeeea0b4b0f7a569d1247e1f0cfcd2e9a", + "state_root": "0x51321ece0e086e7c2fb1201b97aca389bdc431e4d6100554476eb701ae876f09", + "receipts_root": "0x645318ceae534dc125f487466a35b856c3c730768cd92d0e75effac988e82694", + "logs_bloom": "0x271b3fcdcc4193b596a1748c01fcaffaaa370c90e7db12f6129bbcbb18e8a7a0616b1a74f7f3f023fe34a8e1e144bccafd9c344cc329aef2ea7fec601bf0a77b08c61998a96c80299ab92e336a2bd7402960a7698a993e07e9c52f596dedb62da7e2e6be068493e6ead1bb320fb07f362b14376de9debbd64f854e091d50aefcc934123ee4b755190e667e2c19d2727741447e767f7aff6a4152480b4d20869e81e8442f4eaeefc54d347ed32216550b6db8e4e962e48d7a46552acfb16c80a4e3ee05f50288a84d92f1ea189a5c96eff9c958079b866afdcbf35f5a1509e4bd881a6409f402ef88eaf9fe4446088a10eec72e2aa58780b9a10840e4d49ce056", + "prev_randao": "0x3a3c39cd6c8d72fa8be4dbb7d484c4c7b03a0b229ea43bb0401c0084f2485f2b", + "block_number": "14792874525105367692", + "gas_limit": "14791222041888683564", + "gas_used": "14782959617215328332", + "timestamp": "14781307133998644204", + "extra_data": "0x4d5d33cd0cd9513f812743e3a80dd994b63d0ab4546d646a6e9d434ccda916b6", + "base_fee_per_gas": "43644972317658925330071100051921012247097862885198854541507281920566244331072", + "block_hash": "0xc02310cdcc9e8ddc40b9aee79e425463dc4f04209a2159c781a4d8fdebee62f6", + "transactions_root": "0xd3440acd6cea6c2135fc151371cb6830e25203b250ea8181ae251cc6c54f1a81", + "withdrawals_root": "0x18cf2fce2e25d0ad50e8ea981c126622aabb342eb3b68a25beeaeca81f654969", + "blob_gas_used": "14779654655076927372", + "excess_blob_gas": "14778002167565275948" + }, + "bls_to_execution_changes": [ + { + "message": { + "validator_index": "616380", + "from_bls_pubkey": "0xa9c07fb07bb2ab59e94a2ae11b35e37f39c36da1350d21d812e3692cf20c11ce9e49c36030de2d53777bcf87391964fb", + "to_execution_address": "0x082b97cd6dd37dac38b567019af77bf64c0a1b02" + }, + "signature": "0xa4f518b47af3fce361cf801dd5694e0eeedee84a0bc22de77e4ff521f8e49121548fe668ae754ff57f1a26281967bae300c08c00496c3a4d71800262281753ce8a20d9e5ff11e5920c2e38ce1e9676ff71d4755a7d737a1e0bc9ffc5a18ea52b" + }, + { + "message": { + "validator_index": "1848618", + "from_bls_pubkey": "0x8de0e2a1ed7d5c5620f55873e325f7ce7b08aea26a18ae94345f6a36514ddc1b79b9f65fac66cef6f530234d67f1c043", + "to_execution_address": "0x2f6d8bcdad6a3c36223b36584109a59059101926" + }, + "signature": "0xaf83410f4e5481f2ee5a631717872f6e0fe15b0da9954d3e941dcdfd1f1771c5ef338d1384cb9485c9c15eb42a1210c70268a6ee5c06336c462a35ce76a732e062e5cb000089211da9796f0ccaccfdae8edb57e928f33a86da94e470cb8176f8" + }, + { + "message": { + "validator_index": "1463869", + "from_bls_pubkey": "0x8e1dc350c8260e1860e322e85fe07e11cee1d1c7f1b6c848fe2c31dd16527ee8be59f9903a07894fe40b1f00c34ed9da", + "to_execution_address": "0xeeb750cded5ef5e6b7d83e0a86617293972e0fda" + }, + "signature": "0xa349790d2e0ab35e5018818f3da26a7a4933e61dfe71850f1cd34096d31ebb1b00c1c11cd81fb89781c5dd57fa5edd790a14de6128807be822a8fef4cc8f75cd4f382b1ec0e0507541db7ebf71b504a5319b612661d7cb8affef9daf87e35d5f" + }, + { + "message": { + "validator_index": "2384142", + "from_bls_pubkey": "0x96ebb5f0d8ba89c10ab0ec92123e3f797b6d9d95b6c248e7a16f80c9f282c1a4512ce698829c8df38cb36df22e95d640", + "to_execution_address": "0x771c89cc2b6a9d0c48bdf5cda18d2cd06c95ed3d" + }, + "signature": "0x8f9b66c4596f7d6553e21865fd09e4e1b7db735bd45350e7320f30755eaad395d5bba1da96db43a178dadf9c4976c015019fc8a40d5b57dd50c67216bbd99bec9edd0444e665d27ba55e0f693b71a56b5b616e7fe03189c4408f0759d2efa553" + }, + { + "message": { + "validator_index": "1999393", + "from_bls_pubkey": "0x99ff77d3cb9ebe943ddf570446b4279553e33e4761ef72e07ef399d119a365a57064a3aab0a701a919241e333245d5db", + "to_execution_address": "0x36674ecc6b5e56bddd5afe7fe5e5f9d2aab3e3f1" + }, + "signature": "0x8aed6b590d6377a026cbf06c2d8affa749a199a2da2214a8d5ca287e4c2722a768965afb79b4481d8d9f3793eadd8be7110a8c25fb7e3e1dbf706e7feb206b33829d4a8ffbc847abf288db9085e0332b0e9bced233c974e50089f8ee4a533cd0" + }, + { + "message": { + "validator_index": "75649", + "from_bls_pubkey": "0x94791a293424f7a1927b9acfe42b03d5dfa7b21b1541be4923e65bafc38118fb4751e65f76dc93b9492bb65d3bbe923a", + "to_execution_address": "0x5ca942ccabf51447c7e0ccd68df7226db7b9e115" + }, + "signature": "0xb45dd73c93a6742875d7ecd441e39df013a773c82ba7f04c4dfbd24a937c7e190af498524ada6bf32c8a44a1f67ac03212b8d254fafcfd703aa1753a56a7318268f63696373539ee1da7ccb299f56d9218bfc6e069ad16f9a925a44e161f3e9a" + }, + { + "message": { + "validator_index": "2846882", + "from_bls_pubkey": "0x86b39b69857f971adff6b13347593d961f84b77d0521781d2328edaac6768dd7185bcd20cc81c48ae984a8e827862889", + "to_execution_address": "0xb8d1c3ccec75e45bb41fed1b5d355fcd2d77f789" + }, + "signature": "0x8c0fd9c42d50c589cd99b5988feb4e051452834651930f973790ceb96aede3c37b035d9d6c6a27e1e73224de81a219f004f576ea8ef12c1ebc2bad687d29d5427924c84c1e34bf0e161ca20f9a99d1096998cf5d9a2fc74f372b6a7a2f9db692" + }, + { + "message": { + "validator_index": "923138", + "from_bls_pubkey": "0xa9a6751a4ef74b70d052874cada64cda784da4f6263ea5ee6133a76e55019602d30c65f6b563b1e7302af0fa140f82e5", + "to_execution_address": "0xde13b8cc2b0da3e59fa5bb72044788673a7df5ad" + }, + "signature": "0x9663977855cb39b3d7b8fff6008abdd73ea81fcb51542c7faceecd989c31b53d4cb4956858099f2098a593f105b0cbf707f9a1fbf308c5c92084c434294d47e2449f8cb6b0436acffe14800ebc079863a6bc27067d139a4c6aa76bfea2b87185" + }, + { + "message": { + "validator_index": "538389", + "from_bls_pubkey": "0x859d767ff457655c1b524fd4a3df6be0af408dea2843ad7f4ecec1523249c036de2edb10c0d4c5a7e9cfb69285016449", + "to_execution_address": "0x0081c1cb6a754532daa1ac91bcb9e60c40fccba1" + }, + "signature": "0x8928aa86dd870cd4431802c379d58e48773c20ac05dd8b5c9d5f639bf47a8ab8c6eaac7d6b183873b7e05ae449c307760f0cd74b2528c947fd385f188a0d2813ceaf2d37aad1da3b4e242a0c6d90e5c1e3667635ee847fa220d6c3d08caebee2" + }, + { + "message": { + "validator_index": "1458662", + "from_bls_pubkey": "0xa109adf57c6440a07c7830f5d79e997de1b1c339266dda4a875fd3c30e29515e4f9b99f070393d50fe422b67cf7a4c76", + "to_execution_address": "0x27c3b5cbaa0c04bcc5277be864cb0fa74d02cac5" + }, + "signature": "0x8751adcb11b8aa695b7e42cbaf31630c264bdda5e1db14044420eb6e1078c699af668c0416b356c312164392a5d6e3c5195c999fec158ada67dd7c980a578595e1e83b66dec45c5d58dc208f27d169c23620c98820956ba7edf07e6ed1599537" + }, + { + "message": { + "validator_index": "1073913", + "from_bls_pubkey": "0xac84c3b1a00f3175af595ac3c15d81697a2b20b23de7bcc715224d3f5a0e45555437d1b0b5c00dbc3c1b7c2205e989b7", + "to_execution_address": "0xe60d7bcbe900bd6c59c5839aa823dda98b20c079" + }, + "signature": "0xb6883807bc6555abb3d7da5a83b29ce9c1ca4e24637e8643e4297fa3aeb49026e76ed4dcb752ca754f29ef4d2edbfaa3153601fa1b61e71af8189e5519a38dbf395995b75a19647433392718fea6187edf87bb53180c752ff47b1b823fd68b03" + }, + { + "message": { + "validator_index": "2306151", + "from_bls_pubkey": "0x92c4dc055523821aec87056412e818d8a4348e48e10ae55dd22bf2d79b274a662a5e37c402a3944c4fe0e7e2887dc03f", + "to_execution_address": "0xa92d2bcc2b24925a9cec6984db1a75a1d0c5dd5d" + }, + "signature": "0x819c5348a5b8b2cf5e205187a9460a7574694000ae83257204d8eca570391b5971ff13e700a2c57c1ff300aeef2093ea1316dbc55609a42c7fef00ea1495cd0a3c8695e8459933161eac5c6d16524a868b8810ff532da71c1801c7c09c7fb6b0" + }, + { + "message": { + "validator_index": "1921402", + "from_bls_pubkey": "0x89c8439ffd564acbbbff3836e3e7b404321fba4ca0772c8a95fba2fc0bd34093ccd99aa7ba67c568f0165ee0b39a54e1", + "to_execution_address": "0x6878f0cb6a184b0b308a72361f7342a40ee4d311" + }, + "signature": "0xa842edf604c6b7b97717e6fd102276b83bce2b515c35dd80bfb2f03e20d70afe09676087017b132ecad55d1bca84547f179c9dc32ab2c64cdd1a068a65b1217dd336b578339dd259eff0f01255e4c9f1e529f53d5ecb8e87636745a9b16f50ca" + }, + { + "message": { + "validator_index": "2997658", + "from_bls_pubkey": "0x803b73824109aeba69def534a90a7e10a81c1779c60b514419abc9ebfe2995159165365787e783e858fafe57118ed22b", + "to_execution_address": "0x8ebae4cbaaaf09951b10418dc7846b3e1bead135" + }, + "signature": "0x8cfa0af3a8fd0f21583396f885e56dcbaa456edd3b12f2bded9e06117628a667b5cad96a896f9eae37011355da34f76f007012a39c15d379e88e0303ebb933dc18a006d23badc0c5ee0615c34e0801ec3b3eb19acb15f0dabfedc324155ff491" + }, + { + "message": { + "validator_index": "704786", + "from_bls_pubkey": "0x99f5de9afde1b673746d060fc38c8e4d032c16b29dfada47cb1bde607fb8015148202a2a4af30e92f001b852a516cbd4", + "to_execution_address": "0x9614cdd0f37760021b17ef44de2341cfe162a52a" + }, + "signature": "0xabcab86c2e9d2ba13c3ec90a10f1ab60b45572b8c40943e1397048b60491e0550c56710a9a97e54e560222de2c72cdc91737dfd193ed93dd9c703882c8de761d42b316203b62e1fbe0edfa5d67fdf97f40779caf9722b085e00225ab7be2fb13" + }, + { + "message": { + "validator_index": "1781041", + "from_bls_pubkey": "0xace54ea47185418187a0a5159fbbe87ada7f8d0da849638ad22e53115b9016c72e4a7f4149c570b68867bdab24be38fa", + "to_execution_address": "0xbd56c1d0330f1f8c069dbd9b85356a69ee68a34e" + }, + "signature": "0xa3002d71933bb56589973eca4f79da2a5cbb93d98eda587ebee39ef6dfaf66479e60109b64be3cd2d12797556091349c10125b6f543a68c5da383f89acf4e0145d8234ef3c3160737d707f89360e11458e8b365974c223933648900c6a55c2f4" + } + ], + "blob_kzg_commitments": [ + "0xa94170080872584e54a1cf092d845703b13907f2e6b3b1c0ad573b910530499e3bcd48c6378846b80d2bfa58c81cf3d5" + ], + "execution_requests": { + "deposits": [ + { + "pubkey": "0x99c16f59ffb2e2138feb9b6f1804752cdbfe3796e20c52a3ae489f8348df4c1a9614cb6ce6860bed51544aaa1d22cc80", + "withdrawal_credentials": "0x01000000000000000000000096792942ef2204941676b7f0048626f766aa1798", + "amount": "4706333459101651213", + "signature": "0x819666da9089ad1a3879b16a3c7dbab04454cb7da5eb5737c18fd5be53b54c3b38dda74617a27683fe5620a3b213e55e083a85f6223d89e16ce7b93ceb55c5c7e227da6e03bd60f1845e66983d339937d5981e541dedb49d47c3f0573a9b6f41", + "index": "4709638425535019469" + }, + { + "pubkey": "0x9786334738ef86988505249871273257e40b3e3c47995e751a40a52bc46f915fbaab7e2b1802ca3dcbf2db0567e8c9ae", + "withdrawal_credentials": "0x010000000000000000000000b8e632412d8ba6e05272a80fbcf8849c6c29ee8b", + "amount": "4703028492668282957", + "signature": "0xad2792e9c241d24ba5ff5f4ae1f7839009dae5f9de18e56a77510d695c4fcc4ffe40c5fa688e06476ae50dc93a7882d60630e2d4d8deb9ec43469ed6caf8067823e18f8c44de05433aaae7f39f7576c860e331e99681e7eebff012ddf1e3b0b4", + "index": "4693113584778243597" + } + ], + "withdrawals": [ + { + "source_address": "0xde2827416d22656a3cf87666640aae36792fecaf", + "validator_pubkey": "0xa52467f43393c040dbac590c4fa4fdf260f050357947fa261f2285f35c8381f256c8ab0584c940f30766a40ebc447340", + "amount": "4684851168694822957" + } + ], + "consolidations": [ + { + "source_address": "0x2730ae410e57553a34f42f8060bfd5c9e9e90292", + "source_pubkey": "0xb8a7fcd7c58854073db5f088cddf200b04864b6980925343c0d0b3238d5ce3880197ba175c59b61aade73eb79a74cb28", + "target_pubkey": "0x88f8fa6c349ee56559e614799a5788c17fdcde24ea5922a7c7fe6bed8df5c0140aeebbb46d0cadc7a9107e98344194f1" + } + ] + } + } + }, + "signature": "0xa208fa451f0cb280d1bad7212a5b619097885383a9fdf300b91b33e73fd360329161843794ad1c2c7e84a3f0826a4f181165840b29947d2e681005811ee84f4d222510b1287eb1d4de480ce50be7cb2eeb007bdb4ed6c23358fc03b225abc8a8" +} \ No newline at end of file diff --git a/ethereum/executionclient/src/integration-test/resources/builder/electra/signedBuilderBid.json b/ethereum/executionclient/src/integration-test/resources/builder/electra/signedBuilderBid.json new file mode 100644 index 00000000000..c99ec7d1266 --- /dev/null +++ b/ethereum/executionclient/src/integration-test/resources/builder/electra/signedBuilderBid.json @@ -0,0 +1,57 @@ +{ + "version": "electra", + "data": { + "message": { + "header": { + "parent_hash": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", + "fee_recipient": "0xabcf8e0d4e9587369b2301d0790347320302cc09", + "state_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", + "receipts_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", + "logs_bloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "prev_randao": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", + "block_number": "1", + "gas_limit": "1", + "gas_used": "1", + "timestamp": "1", + "extra_data": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", + "base_fee_per_gas": "1", + "blob_gas_used": "1", + "excess_blob_gas": "1", + "block_hash": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", + "transactions_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", + "withdrawals_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2" + }, + "blob_kzg_commitments": [ + "0xa94170080872584e54a1cf092d845703b13907f2e6b3b1c0ad573b910530499e3bcd48c6378846b80d2bfa58c81cf3d5" + ], + "execution_requests": { + "deposits": [ + { + "pubkey": "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a", + "withdrawal_credentials": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", + "amount": "1", + "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505", + "index": "1" + } + ], + "withdrawals": [ + { + "source_address": "0xabcf8e0d4e9587369b2301d0790347320302cc09", + "validator_pubkey": "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a", + "amount": "1" + } + ], + "consolidations": [ + { + "source_address": "0xabcf8e0d4e9587369b2301d0790347320302cc09", + "source_pubkey": "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a", + "target_pubkey": "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a" + } + ] + }, + "value": "1", + "pubkey": "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a" + }, + "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505" + } +} \ No newline at end of file diff --git a/ethereum/executionclient/src/integration-test/resources/builder/electra/unblindedBuilderPayload.json b/ethereum/executionclient/src/integration-test/resources/builder/electra/unblindedBuilderPayload.json new file mode 100644 index 00000000000..10fd97ff686 --- /dev/null +++ b/ethereum/executionclient/src/integration-test/resources/builder/electra/unblindedBuilderPayload.json @@ -0,0 +1,44 @@ +{ + "version": "electra", + "data": { + "execution_payload": { + "parent_hash": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", + "fee_recipient": "0xabcf8e0d4e9587369b2301d0790347320302cc09", + "state_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", + "receipts_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", + "logs_bloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "prev_randao": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", + "block_number": "1", + "gas_limit": "1", + "gas_used": "1", + "timestamp": "1", + "extra_data": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", + "base_fee_per_gas": "1", + "blob_gas_used": "1", + "excess_blob_gas": "1", + "block_hash": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", + "transactions": [ + "0x02f878831469668303f51d843b9ac9f9843b9aca0082520894c93269b73096998db66be0441e836d873535cb9c8894a19041886f000080c001a031cc29234036afbf9a1fb9476b463367cb1f957ac0b919b69bbc798436e604aaa018c4e9c3914eb27aadd0b91e10b18655739fcf8c1fc398763a9f1beecb8ddc86" + ], + "withdrawals": [ + { + "index": "1", + "validator_index": "1", + "address": "0xabcf8e0d4e9587369b2301d0790347320302cc09", + "amount": "32000000000" + } + ] + }, + "blobs_bundle": { + "commitments": [ + "0x8dab030c51e16e84be9caab84ee3d0b8bbec1db4a0e4de76439da8424d9b957370a10a78851f97e4b54d2ce1ab0d686f" + ], + "proofs": [ + "0xb4021b0de10f743893d4f71e1bf830c019e832958efd6795baf2f83b8699a9eccc5dc99015d8d4d8ec370d0cc333c06a" + ], + "blobs": [ + "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" + ] + } + } +} \ No newline at end of file diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/ExecutionClientVersionChannel.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/ExecutionClientVersionChannel.java index 34dd99d1b94..95dd3fa8c39 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/ExecutionClientVersionChannel.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/ExecutionClientVersionChannel.java @@ -18,5 +18,13 @@ public interface ExecutionClientVersionChannel extends VoidReturningChannelInterface { + /** + * Provides an execution {@link ClientVersion} based on engine_getClientVersion. + * This method will be called on startup and every time the {@link ClientVersion} changes. + */ void onExecutionClientVersion(ClientVersion executionClientVersion); + + /** Called when engine_getClientVersion method is not available or has failed on startup */ + void onExecutionClientVersionNotAvailable(); } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/ExecutionClientVersionProvider.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/ExecutionClientVersionProvider.java index 27d268ea630..ab39e806350 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/ExecutionClientVersionProvider.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/ExecutionClientVersionProvider.java @@ -15,6 +15,7 @@ import static tech.pegasys.teku.infrastructure.logging.EventLogger.EVENT_LOG; +import java.util.Objects; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicReference; import org.apache.logging.log4j.LogManager; @@ -35,12 +36,12 @@ public class ExecutionClientVersionProvider implements ExecutionClientEventsChan private final AtomicBoolean lastExecutionClientAvailability = new AtomicBoolean(true); + private final AtomicReference executionClientVersion = new AtomicReference<>(); + private final ExecutionLayerChannel executionLayerChannel; private final ExecutionClientVersionChannel executionClientVersionChannel; private final ClientVersion consensusClientVersion; - private final AtomicReference executionClientVersion = new AtomicReference<>(null); - public ExecutionClientVersionProvider( final ExecutionLayerChannel executionLayerChannel, final ExecutionClientVersionChannel executionClientVersionChannel, @@ -49,20 +50,20 @@ public ExecutionClientVersionProvider( this.executionClientVersionChannel = executionClientVersionChannel; this.consensusClientVersion = consensusClientVersion; // update client info on initialization - updateClientInfo(); + updateClientInfo(true); } @Override public void onAvailabilityUpdated(final boolean isAvailable) { // only update info after EL has been unavailable if (isAvailable && lastExecutionClientAvailability.compareAndSet(false, true)) { - updateClientInfo(); + updateClientInfo(false); } else { lastExecutionClientAvailability.set(isAvailable); } } - private void updateClientInfo() { + private void updateClientInfo(final boolean notifyNotAvailable) { executionLayerChannel .engineGetClientVersion(consensusClientVersion) .thenAccept( @@ -72,24 +73,20 @@ private void updateClientInfo() { }) .finish( ex -> { + if (notifyNotAvailable) { + executionClientVersionChannel.onExecutionClientVersionNotAvailable(); + } LOG.debug("Exception while calling engine_getClientVersion", ex); - updateVersionIfNeeded(ClientVersion.UNKNOWN); }); } private synchronized void updateVersionIfNeeded(final ClientVersion executionClientVersion) { - if (executionClientVersion.equals(this.executionClientVersion.get())) { + if (Objects.equals(this.executionClientVersion.get(), executionClientVersion)) { return; } - if (!executionClientVersion.equals(ClientVersion.UNKNOWN)) { - EVENT_LOG.logExecutionClientVersion( - executionClientVersion.name(), executionClientVersion.version()); - } - // push UNKNOWN forward only when it's set for the first time - if (!executionClientVersion.equals(ClientVersion.UNKNOWN) - || this.executionClientVersion.get() == null) { - this.executionClientVersion.set(executionClientVersion); - executionClientVersionChannel.onExecutionClientVersion(executionClientVersion); - } + EVENT_LOG.logExecutionClientVersion( + executionClientVersion.name(), executionClientVersion.version()); + this.executionClientVersion.set(executionClientVersion); + executionClientVersionChannel.onExecutionClientVersion(executionClientVersion); } } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/ExecutionEngineClient.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/ExecutionEngineClient.java index c4e94d8b45e..0277f3de9c6 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/ExecutionEngineClient.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/ExecutionEngineClient.java @@ -15,7 +15,9 @@ import java.util.List; import java.util.Optional; +import org.apache.tuweni.bytes.Bytes; import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.ethereum.executionclient.schema.BlobAndProofV1; import tech.pegasys.teku.ethereum.executionclient.schema.ClientVersionV1; import tech.pegasys.teku.ethereum.executionclient.schema.ExecutionPayloadV1; import tech.pegasys.teku.ethereum.executionclient.schema.ExecutionPayloadV2; @@ -24,9 +26,11 @@ import tech.pegasys.teku.ethereum.executionclient.schema.ForkChoiceUpdatedResult; import tech.pegasys.teku.ethereum.executionclient.schema.GetPayloadV2Response; import tech.pegasys.teku.ethereum.executionclient.schema.GetPayloadV3Response; +import tech.pegasys.teku.ethereum.executionclient.schema.GetPayloadV4Response; import tech.pegasys.teku.ethereum.executionclient.schema.PayloadAttributesV1; import tech.pegasys.teku.ethereum.executionclient.schema.PayloadAttributesV2; import tech.pegasys.teku.ethereum.executionclient.schema.PayloadAttributesV3; +import tech.pegasys.teku.ethereum.executionclient.schema.PayloadAttributesV4; import tech.pegasys.teku.ethereum.executionclient.schema.PayloadStatusV1; import tech.pegasys.teku.ethereum.executionclient.schema.Response; import tech.pegasys.teku.infrastructure.async.SafeFuture; @@ -47,6 +51,8 @@ public interface ExecutionEngineClient { SafeFuture> getPayloadV3(Bytes8 payloadId); + SafeFuture> getPayloadV4(Bytes8 payloadId); + SafeFuture> newPayloadV1(ExecutionPayloadV1 executionPayload); SafeFuture> newPayloadV2(ExecutionPayloadV2 executionPayload); @@ -56,6 +62,12 @@ SafeFuture> newPayloadV3( List blobVersionedHashes, Bytes32 parentBeaconBlockRoot); + SafeFuture> newPayloadV4( + ExecutionPayloadV3 executionPayload, + List blobVersionedHashes, + Bytes32 parentBeaconBlockRoot, + List executionRequests); + SafeFuture> forkChoiceUpdatedV1( ForkChoiceStateV1 forkChoiceState, Optional payloadAttributes); @@ -65,7 +77,12 @@ SafeFuture> forkChoiceUpdatedV2( SafeFuture> forkChoiceUpdatedV3( ForkChoiceStateV1 forkChoiceState, Optional payloadAttributes); + SafeFuture> forkChoiceUpdatedV4( + ForkChoiceStateV1 forkChoiceState, Optional payloadAttributes); + SafeFuture>> exchangeCapabilities(List capabilities); SafeFuture>> getClientVersionV1(ClientVersionV1 clientVersion); + + SafeFuture>> getBlobsV1(List blobVersionedHashes); } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/ThrottlingExecutionEngineClient.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/ThrottlingExecutionEngineClient.java index 45bb127707a..50e1a969a2e 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/ThrottlingExecutionEngineClient.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/ThrottlingExecutionEngineClient.java @@ -15,8 +15,10 @@ import java.util.List; import java.util.Optional; +import org.apache.tuweni.bytes.Bytes; import org.apache.tuweni.bytes.Bytes32; import org.hyperledger.besu.plugin.services.MetricsSystem; +import tech.pegasys.teku.ethereum.executionclient.schema.BlobAndProofV1; import tech.pegasys.teku.ethereum.executionclient.schema.ClientVersionV1; import tech.pegasys.teku.ethereum.executionclient.schema.ExecutionPayloadV1; import tech.pegasys.teku.ethereum.executionclient.schema.ExecutionPayloadV2; @@ -25,9 +27,11 @@ import tech.pegasys.teku.ethereum.executionclient.schema.ForkChoiceUpdatedResult; import tech.pegasys.teku.ethereum.executionclient.schema.GetPayloadV2Response; import tech.pegasys.teku.ethereum.executionclient.schema.GetPayloadV3Response; +import tech.pegasys.teku.ethereum.executionclient.schema.GetPayloadV4Response; import tech.pegasys.teku.ethereum.executionclient.schema.PayloadAttributesV1; import tech.pegasys.teku.ethereum.executionclient.schema.PayloadAttributesV2; import tech.pegasys.teku.ethereum.executionclient.schema.PayloadAttributesV3; +import tech.pegasys.teku.ethereum.executionclient.schema.PayloadAttributesV4; import tech.pegasys.teku.ethereum.executionclient.schema.PayloadStatusV1; import tech.pegasys.teku.ethereum.executionclient.schema.Response; import tech.pegasys.teku.infrastructure.async.SafeFuture; @@ -79,6 +83,11 @@ public SafeFuture> getPayloadV3(final Bytes8 payl return taskQueue.queueTask(() -> delegate.getPayloadV3(payloadId)); } + @Override + public SafeFuture> getPayloadV4(final Bytes8 payloadId) { + return taskQueue.queueTask(() -> delegate.getPayloadV4(payloadId)); + } + @Override public SafeFuture> newPayloadV1( final ExecutionPayloadV1 executionPayload) { @@ -100,6 +109,18 @@ public SafeFuture> newPayloadV3( () -> delegate.newPayloadV3(executionPayload, blobVersionedHashes, parentBeaconBlockRoot)); } + @Override + public SafeFuture> newPayloadV4( + final ExecutionPayloadV3 executionPayload, + final List blobVersionedHashes, + final Bytes32 parentBeaconBlockRoot, + final List executionRequests) { + return taskQueue.queueTask( + () -> + delegate.newPayloadV4( + executionPayload, blobVersionedHashes, parentBeaconBlockRoot, executionRequests)); + } + @Override public SafeFuture> forkChoiceUpdatedV1( final ForkChoiceStateV1 forkChoiceState, @@ -124,6 +145,14 @@ public SafeFuture> forkChoiceUpdatedV3( () -> delegate.forkChoiceUpdatedV3(forkChoiceState, payloadAttributes)); } + @Override + public SafeFuture> forkChoiceUpdatedV4( + final ForkChoiceStateV1 forkChoiceState, + final Optional payloadAttributes) { + return taskQueue.queueTask( + () -> delegate.forkChoiceUpdatedV4(forkChoiceState, payloadAttributes)); + } + @Override public SafeFuture>> exchangeCapabilities(final List capabilities) { return taskQueue.queueTask(() -> delegate.exchangeCapabilities(capabilities)); @@ -134,4 +163,10 @@ public SafeFuture>> getClientVersionV1( final ClientVersionV1 clientVersion) { return taskQueue.queueTask(() -> delegate.getClientVersionV1(clientVersion)); } + + @Override + public SafeFuture>> getBlobsV1( + final List blobVersionedHashes) { + return taskQueue.queueTask(() -> delegate.getBlobsV1(blobVersionedHashes)); + } } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/auth/Token.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/auth/Token.java index f76304213cb..b4fb2d8eb9d 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/auth/Token.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/auth/Token.java @@ -34,7 +34,7 @@ public String getJwtToken() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineApiMethod.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineApiMethod.java index 44ec33d7a4c..a47654c47fe 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineApiMethod.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineApiMethod.java @@ -16,7 +16,8 @@ public enum EngineApiMethod { ENGINE_NEW_PAYLOAD("engine_newPayload"), ENGINE_GET_PAYLOAD("engine_getPayload"), - ENGINE_FORK_CHOICE_UPDATED("engine_forkchoiceUpdated"); + ENGINE_FORK_CHOICE_UPDATED("engine_forkchoiceUpdated"), + ENGINE_GET_BLOBS("engine_getBlobs"); private final String name; diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineForkChoiceUpdatedV4.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineForkChoiceUpdatedV4.java new file mode 100644 index 00000000000..d00676e03dd --- /dev/null +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineForkChoiceUpdatedV4.java @@ -0,0 +1,81 @@ +/* + * Copyright Consensys Software Inc., 2023 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.ethereum.executionclient.methods; + +import java.util.Optional; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import tech.pegasys.teku.ethereum.executionclient.ExecutionEngineClient; +import tech.pegasys.teku.ethereum.executionclient.response.ResponseUnwrapper; +import tech.pegasys.teku.ethereum.executionclient.schema.ForkChoiceStateV1; +import tech.pegasys.teku.ethereum.executionclient.schema.ForkChoiceUpdatedResult; +import tech.pegasys.teku.ethereum.executionclient.schema.PayloadAttributesV4; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.spec.executionlayer.ForkChoiceState; +import tech.pegasys.teku.spec.executionlayer.PayloadBuildingAttributes; + +public class EngineForkChoiceUpdatedV4 + extends AbstractEngineJsonRpcMethod< + tech.pegasys.teku.spec.executionlayer.ForkChoiceUpdatedResult> { + + private static final Logger LOG = LogManager.getLogger(); + + public EngineForkChoiceUpdatedV4(final ExecutionEngineClient executionEngineClient) { + super(executionEngineClient); + } + + @Override + public String getName() { + return EngineApiMethod.ENGINE_FORK_CHOICE_UPDATED.getName(); + } + + @Override + public int getVersion() { + return 4; + } + + @Override + public SafeFuture execute( + final JsonRpcRequestParams params) { + final ForkChoiceState forkChoiceState = params.getRequiredParameter(0, ForkChoiceState.class); + final Optional payloadBuildingAttributes = + params.getOptionalParameter(1, PayloadBuildingAttributes.class); + + LOG.trace( + "Calling {}(forkChoiceState={}, payloadAttributes={})", + getVersionedName(), + forkChoiceState, + payloadBuildingAttributes); + + final Optional maybePayloadAttributes = + payloadBuildingAttributes.flatMap( + attributes -> + PayloadAttributesV4.fromInternalPayloadBuildingAttributesV4( + payloadBuildingAttributes)); + + return executionEngineClient + .forkChoiceUpdatedV4( + ForkChoiceStateV1.fromInternalForkChoiceState(forkChoiceState), maybePayloadAttributes) + .thenApply(ResponseUnwrapper::unwrapExecutionClientResponseOrThrow) + .thenApply(ForkChoiceUpdatedResult::asInternalExecutionPayload) + .thenPeek( + forkChoiceUpdatedResult -> + LOG.trace( + "Response {}(forkChoiceState={}, payloadAttributes={}) -> {}", + getVersionedName(), + forkChoiceState, + payloadBuildingAttributes, + forkChoiceUpdatedResult)); + } +} diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineGetBlobsV1.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineGetBlobsV1.java new file mode 100644 index 00000000000..40426616b87 --- /dev/null +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineGetBlobsV1.java @@ -0,0 +1,93 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.ethereum.executionclient.methods; + +import java.util.List; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import tech.pegasys.teku.ethereum.executionclient.ExecutionEngineClient; +import tech.pegasys.teku.ethereum.executionclient.response.ResponseUnwrapper; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSchema; +import tech.pegasys.teku.spec.datastructures.execution.BlobAndProof; +import tech.pegasys.teku.spec.logic.versions.deneb.types.VersionedHash; +import tech.pegasys.teku.spec.schemas.SchemaDefinitions; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsDeneb; + +public class EngineGetBlobsV1 extends AbstractEngineJsonRpcMethod> { + + private static final Logger LOG = LogManager.getLogger(); + private final Spec spec; + + public EngineGetBlobsV1(final ExecutionEngineClient executionEngineClient, final Spec spec) { + super(executionEngineClient); + this.spec = spec; + } + + @Override + public String getName() { + return EngineApiMethod.ENGINE_GET_BLOBS.getName(); + } + + @Override + public int getVersion() { + return 1; + } + + @Override + public boolean isOptional() { + return true; + } + + @Override + public SafeFuture> execute(final JsonRpcRequestParams params) { + + final List blobVersionedHashes = + params.getRequiredListParameter(0, VersionedHash.class); + + final UInt64 slot = params.getRequiredParameter(1, UInt64.class); + + LOG.trace( + "Calling {}(blobVersionedHashes={}, slot={})", + getVersionedName(), + blobVersionedHashes, + slot); + + return executionEngineClient + .getBlobsV1(blobVersionedHashes) + .thenApply(ResponseUnwrapper::unwrapExecutionClientResponseOrThrow) + .thenApply( + response -> { + final SchemaDefinitions schemaDefinitions = spec.atSlot(slot).getSchemaDefinitions(); + final BlobSchema blobSchema = + SchemaDefinitionsDeneb.required(schemaDefinitions).getBlobSchema(); + return response.stream() + .map( + blobAndProofV1 -> + blobAndProofV1 == null + ? null + : blobAndProofV1.asInternalBlobsAndProofs(blobSchema)) + .toList(); + }) + .thenPeek( + blobsAndProofs -> + LOG.trace( + "Response {}(blobVersionedHashes={}) -> {}", + getVersionedName(), + blobVersionedHashes, + blobsAndProofs)); + } +} diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineGetPayloadV4.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineGetPayloadV4.java new file mode 100644 index 00000000000..60a1fbd62fa --- /dev/null +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineGetPayloadV4.java @@ -0,0 +1,114 @@ +/* + * Copyright Consensys Software Inc., 2023 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.ethereum.executionclient.methods; + +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import tech.pegasys.teku.ethereum.executionclient.ExecutionEngineClient; +import tech.pegasys.teku.ethereum.executionclient.response.ResponseUnwrapper; +import tech.pegasys.teku.ethereum.executionclient.schema.GetPayloadV4Response; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSchema; +import tech.pegasys.teku.spec.datastructures.execution.BlobsBundle; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadContext; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSchema; +import tech.pegasys.teku.spec.datastructures.execution.GetPayloadResponse; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsDataCodec; +import tech.pegasys.teku.spec.schemas.SchemaDefinitions; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsBellatrix; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsDeneb; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; + +public class EngineGetPayloadV4 extends AbstractEngineJsonRpcMethod { + + private static final Logger LOG = LogManager.getLogger(); + + private final Spec spec; + private final ExecutionRequestsDataCodec executionRequestsDataDecoder; + + public EngineGetPayloadV4(final ExecutionEngineClient executionEngineClient, final Spec spec) { + super(executionEngineClient); + this.spec = spec; + this.executionRequestsDataDecoder = + new ExecutionRequestsDataCodec( + SchemaDefinitionsElectra.required( + spec.forMilestone(SpecMilestone.ELECTRA).getSchemaDefinitions()) + .getExecutionRequestsSchema()); + } + + @Override + public String getName() { + return EngineApiMethod.ENGINE_GET_PAYLOAD.getName(); + } + + @Override + public int getVersion() { + return 4; + } + + @Override + public SafeFuture execute(final JsonRpcRequestParams params) { + final ExecutionPayloadContext executionPayloadContext = + params.getRequiredParameter(0, ExecutionPayloadContext.class); + final UInt64 slot = params.getRequiredParameter(1, UInt64.class); + + LOG.trace( + "Calling {}(payloadId={}, slot={})", + getVersionedName(), + executionPayloadContext.getPayloadId(), + slot); + + return executionEngineClient + .getPayloadV4(executionPayloadContext.getPayloadId()) + .thenApply(ResponseUnwrapper::unwrapExecutionClientResponseOrThrow) + .thenApply( + response -> { + final SchemaDefinitions schemaDefinitions = spec.atSlot(slot).getSchemaDefinitions(); + final ExecutionPayloadSchema payloadSchema = + SchemaDefinitionsBellatrix.required(schemaDefinitions) + .getExecutionPayloadSchema(); + final ExecutionPayload executionPayload = + response.executionPayload.asInternalExecutionPayload(payloadSchema); + final BlobsBundle blobsBundle = getBlobsBundle(response, schemaDefinitions); + final ExecutionRequests executionRequests = + executionRequestsDataDecoder.decode(response.executionRequests); + return new GetPayloadResponse( + executionPayload, + response.blockValue, + blobsBundle, + response.shouldOverrideBuilder, + executionRequests); + }) + .thenPeek( + getPayloadResponse -> + LOG.trace( + "Response {}(payloadId={}, slot={}) -> {}", + getVersionedName(), + executionPayloadContext.getPayloadId(), + slot, + getPayloadResponse)); + } + + private BlobsBundle getBlobsBundle( + final GetPayloadV4Response response, final SchemaDefinitions schemaDefinitions) { + final BlobSchema blobSchema = + SchemaDefinitionsDeneb.required(schemaDefinitions).getBlobSchema(); + return response.blobsBundle.asInternalBlobsBundle(blobSchema); + } +} diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineJsonRpcMethod.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineJsonRpcMethod.java index ddc4b4f196e..8c41f711697 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineJsonRpcMethod.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineJsonRpcMethod.java @@ -28,6 +28,12 @@ default boolean isDeprecated() { return false; } + // TODO should be remove once all ELs implement engine_getBlobsV1. It has been added only to + // better handle the use case when the method is missing in the EL side + default boolean isOptional() { + return false; + } + default String getVersionedName() { return getVersion() == 0 ? getName() : getName() + "V" + getVersion(); } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineNewPayloadV4.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineNewPayloadV4.java new file mode 100644 index 00000000000..57ff1341bd7 --- /dev/null +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineNewPayloadV4.java @@ -0,0 +1,81 @@ +/* + * Copyright Consensys Software Inc., 2023 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.ethereum.executionclient.methods; + +import java.util.List; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.apache.tuweni.bytes.Bytes; +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.ethereum.executionclient.ExecutionEngineClient; +import tech.pegasys.teku.ethereum.executionclient.response.ResponseUnwrapper; +import tech.pegasys.teku.ethereum.executionclient.schema.ExecutionPayloadV3; +import tech.pegasys.teku.ethereum.executionclient.schema.PayloadStatusV1; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; +import tech.pegasys.teku.spec.executionlayer.PayloadStatus; +import tech.pegasys.teku.spec.logic.versions.deneb.types.VersionedHash; + +public class EngineNewPayloadV4 extends AbstractEngineJsonRpcMethod { + + private static final Logger LOG = LogManager.getLogger(); + + public EngineNewPayloadV4(final ExecutionEngineClient executionEngineClient) { + super(executionEngineClient); + } + + @Override + public String getName() { + return EngineApiMethod.ENGINE_NEW_PAYLOAD.getName(); + } + + @Override + public int getVersion() { + return 4; + } + + @Override + public SafeFuture execute(final JsonRpcRequestParams params) { + final ExecutionPayload executionPayload = + params.getRequiredParameter(0, ExecutionPayload.class); + final List blobVersionedHashes = + params.getRequiredListParameter(1, VersionedHash.class); + final Bytes32 parentBeaconBlockRoot = params.getRequiredParameter(2, Bytes32.class); + final List executionRequests = params.getRequiredListParameter(3, Bytes.class); + + LOG.trace( + "Calling {}(executionPayload={}, blobVersionedHashes={}, parentBeaconBlockRoot={}, executionRequests={})", + getVersionedName(), + executionPayload, + blobVersionedHashes, + parentBeaconBlockRoot, + executionRequests); + + final ExecutionPayloadV3 executionPayloadV3 = + ExecutionPayloadV3.fromInternalExecutionPayload(executionPayload); + return executionEngineClient + .newPayloadV4( + executionPayloadV3, blobVersionedHashes, parentBeaconBlockRoot, executionRequests) + .thenApply(ResponseUnwrapper::unwrapExecutionClientResponseOrThrow) + .thenApply(PayloadStatusV1::asInternalExecutionPayload) + .thenPeek( + payloadStatus -> + LOG.trace( + "Response {}(executionPayload={}) -> {}", + getVersionedName(), + executionPayload, + payloadStatus)) + .exceptionally(PayloadStatus::failedExecution); + } +} diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/metrics/MetricRecordingExecutionEngineClient.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/metrics/MetricRecordingExecutionEngineClient.java index 6a4815b58c8..ec4b9249a08 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/metrics/MetricRecordingExecutionEngineClient.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/metrics/MetricRecordingExecutionEngineClient.java @@ -16,9 +16,11 @@ import java.util.List; import java.util.Map; import java.util.Optional; +import org.apache.tuweni.bytes.Bytes; import org.apache.tuweni.bytes.Bytes32; import org.hyperledger.besu.plugin.services.MetricsSystem; import tech.pegasys.teku.ethereum.executionclient.ExecutionEngineClient; +import tech.pegasys.teku.ethereum.executionclient.schema.BlobAndProofV1; import tech.pegasys.teku.ethereum.executionclient.schema.ClientVersionV1; import tech.pegasys.teku.ethereum.executionclient.schema.ExecutionPayloadV1; import tech.pegasys.teku.ethereum.executionclient.schema.ExecutionPayloadV2; @@ -27,9 +29,11 @@ import tech.pegasys.teku.ethereum.executionclient.schema.ForkChoiceUpdatedResult; import tech.pegasys.teku.ethereum.executionclient.schema.GetPayloadV2Response; import tech.pegasys.teku.ethereum.executionclient.schema.GetPayloadV3Response; +import tech.pegasys.teku.ethereum.executionclient.schema.GetPayloadV4Response; import tech.pegasys.teku.ethereum.executionclient.schema.PayloadAttributesV1; import tech.pegasys.teku.ethereum.executionclient.schema.PayloadAttributesV2; import tech.pegasys.teku.ethereum.executionclient.schema.PayloadAttributesV3; +import tech.pegasys.teku.ethereum.executionclient.schema.PayloadAttributesV4; import tech.pegasys.teku.ethereum.executionclient.schema.PayloadStatusV1; import tech.pegasys.teku.ethereum.executionclient.schema.Response; import tech.pegasys.teku.infrastructure.async.SafeFuture; @@ -56,12 +60,18 @@ public class MetricRecordingExecutionEngineClient extends MetricRecordingAbstrac public static final String FORKCHOICE_UPDATED_WITH_ATTRIBUTES_V2_METHOD = "forkchoice_updated_with_attributesV2"; public static final String FORKCHOICE_UPDATED_V3_METHOD = "forkchoice_updatedV3"; + public static final String FORKCHOICE_UPDATED_V4_METHOD = "forkchoice_updatedV4"; public static final String FORKCHOICE_UPDATED_WITH_ATTRIBUTES_V3_METHOD = "forkchoice_updated_with_attributesV3"; + public static final String FORKCHOICE_UPDATED_WITH_ATTRIBUTES_V4_METHOD = + "forkchoice_updated_with_attributesV4"; public static final String GET_PAYLOAD_V3_METHOD = "get_payloadV3"; + public static final String GET_PAYLOAD_V4_METHOD = "get_payloadV4"; public static final String NEW_PAYLOAD_V3_METHOD = "new_payloadV3"; + public static final String NEW_PAYLOAD_V4_METHOD = "new_payloadV4"; public static final String EXCHANGE_CAPABILITIES_METHOD = "exchange_capabilities"; public static final String GET_CLIENT_VERSION_V1_METHOD = "get_client_versionV1"; + public static final String GET_BLOBS_V1_METHOD = "get_blobs_versionV1"; private final ExecutionEngineClient delegate; @@ -106,6 +116,11 @@ public SafeFuture> getPayloadV3(final Bytes8 payl return countRequest(() -> delegate.getPayloadV3(payloadId), GET_PAYLOAD_V3_METHOD); } + @Override + public SafeFuture> getPayloadV4(final Bytes8 payloadId) { + return countRequest(() -> delegate.getPayloadV4(payloadId), GET_PAYLOAD_V4_METHOD); + } + @Override public SafeFuture> newPayloadV1( final ExecutionPayloadV1 executionPayload) { @@ -128,6 +143,19 @@ public SafeFuture> newPayloadV3( NEW_PAYLOAD_V3_METHOD); } + @Override + public SafeFuture> newPayloadV4( + final ExecutionPayloadV3 executionPayload, + final List blobVersionedHashes, + final Bytes32 parentBeaconBlockRoot, + final List executionRequests) { + return countRequest( + () -> + delegate.newPayloadV4( + executionPayload, blobVersionedHashes, parentBeaconBlockRoot, executionRequests), + NEW_PAYLOAD_V4_METHOD); + } + @Override public SafeFuture> forkChoiceUpdatedV1( final ForkChoiceStateV1 forkChoiceState, @@ -161,6 +189,17 @@ public SafeFuture> forkChoiceUpdatedV3( : FORKCHOICE_UPDATED_V3_METHOD); } + @Override + public SafeFuture> forkChoiceUpdatedV4( + final ForkChoiceStateV1 forkChoiceState, + final Optional payloadAttributes) { + return countRequest( + () -> delegate.forkChoiceUpdatedV4(forkChoiceState, payloadAttributes), + payloadAttributes.isPresent() + ? FORKCHOICE_UPDATED_WITH_ATTRIBUTES_V4_METHOD + : FORKCHOICE_UPDATED_V4_METHOD); + } + @Override public SafeFuture>> exchangeCapabilities(final List capabilities) { return countRequest( @@ -173,4 +212,10 @@ public SafeFuture>> getClientVersionV1( return countRequest( () -> delegate.getClientVersionV1(clientVersion), GET_CLIENT_VERSION_V1_METHOD); } + + @Override + public SafeFuture>> getBlobsV1( + final List blobVersionedHashes) { + return countRequest(() -> delegate.getBlobsV1(blobVersionedHashes), GET_BLOBS_V1_METHOD); + } } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/rest/RestBuilderClient.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/rest/RestBuilderClient.java index 94b6ce672f0..d87f563b9e0 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/rest/RestBuilderClient.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/rest/RestBuilderClient.java @@ -39,13 +39,13 @@ import tech.pegasys.teku.infrastructure.version.VersionProvider; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.SpecVersion; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.builder.BuilderPayload; import tech.pegasys.teku.spec.datastructures.builder.BuilderPayloadSchema; import tech.pegasys.teku.spec.datastructures.builder.SignedBuilderBid; import tech.pegasys.teku.spec.datastructures.builder.SignedBuilderBidSchema; import tech.pegasys.teku.spec.datastructures.builder.SignedValidatorRegistration; -import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsBellatrix; public class RestBuilderClient implements BuilderClient { @@ -65,13 +65,13 @@ public class RestBuilderClient implements BuilderClient { cachedBuilderApiSignedBuilderBidResponseType = new ConcurrentHashMap<>(); private final RestClient restClient; - private final SchemaDefinitionCache schemaDefinitionCache; + private final Spec spec; private final boolean setUserAgentHeader; public RestBuilderClient( final RestClient restClient, final Spec spec, final boolean setUserAgentHeader) { this.restClient = restClient; - this.schemaDefinitionCache = new SchemaDefinitionCache(spec); + this.spec = spec; this.setUserAgentHeader = setUserAgentHeader; } @@ -109,7 +109,8 @@ public SafeFuture>> getHeader( urlParams.put("parent_hash", parentHash.toHexString()); urlParams.put("pubkey", pubKey.toBytesCompressed().toHexString()); - final SpecMilestone milestone = schemaDefinitionCache.milestoneAtSlot(slot); + final SpecVersion specVersion = spec.atSlot(slot); + final SpecMilestone milestone = specVersion.getMilestone(); final DeserializableTypeDefinition> responseTypeDefinition = @@ -117,7 +118,7 @@ public SafeFuture>> getHeader( milestone, __ -> { final SchemaDefinitionsBellatrix schemaDefinitionsBellatrix = - getSchemaDefinitionsBellatrix(milestone); + getSchemaDefinitionsBellatrix(specVersion); final SignedBuilderBidSchema signedBuilderBidSchema = schemaDefinitionsBellatrix.getSignedBuilderBidSchema(); return BuilderApiResponse.createTypeDefinition( @@ -146,10 +147,10 @@ public SafeFuture> getPayload( final SignedBeaconBlock signedBlindedBeaconBlock) { final UInt64 blockSlot = signedBlindedBeaconBlock.getSlot(); - final SpecMilestone milestone = schemaDefinitionCache.milestoneAtSlot(blockSlot); - + final SpecVersion specVersion = spec.atSlot(blockSlot); + final SpecMilestone milestone = specVersion.getMilestone(); final SchemaDefinitionsBellatrix schemaDefinitionsBellatrix = - getSchemaDefinitionsBellatrix(milestone); + getSchemaDefinitionsBellatrix(specVersion); final DeserializableTypeDefinition requestTypeDefinition = schemaDefinitionsBellatrix.getSignedBlindedBeaconBlockSchema().getJsonTypeDefinition(); @@ -195,15 +196,14 @@ private BuilderPayload extractBuilderPayload( return builderApiResponse.getData(); } - private SchemaDefinitionsBellatrix getSchemaDefinitionsBellatrix( - final SpecMilestone specMilestone) { - return schemaDefinitionCache - .getSchemaDefinition(specMilestone) + private SchemaDefinitionsBellatrix getSchemaDefinitionsBellatrix(final SpecVersion specVersion) { + return specVersion + .getSchemaDefinitions() .toVersionBellatrix() .orElseThrow( () -> new IllegalArgumentException( - specMilestone + specVersion.getMilestone() + " is not a supported milestone for the builder rest api. Milestones >= Bellatrix are supported.")); } } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/BlobAndProofV1.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/BlobAndProofV1.java new file mode 100644 index 00000000000..1a73026a865 --- /dev/null +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/BlobAndProofV1.java @@ -0,0 +1,88 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.ethereum.executionclient.schema; + +import static com.google.common.base.Preconditions.checkNotNull; + +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.google.common.base.MoreObjects; +import java.util.Objects; +import org.apache.tuweni.bytes.Bytes; +import org.apache.tuweni.bytes.Bytes48; +import tech.pegasys.teku.ethereum.executionclient.serialization.Bytes48Deserializer; +import tech.pegasys.teku.ethereum.executionclient.serialization.BytesDeserializer; +import tech.pegasys.teku.ethereum.executionclient.serialization.BytesSerializer; +import tech.pegasys.teku.kzg.KZGProof; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.Blob; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSchema; +import tech.pegasys.teku.spec.datastructures.execution.BlobAndProof; + +public class BlobAndProofV1 { + + @JsonSerialize(using = BytesSerializer.class) + @JsonDeserialize(using = BytesDeserializer.class) + private final Bytes blob; + + @JsonSerialize(using = BytesSerializer.class) + @JsonDeserialize(using = Bytes48Deserializer.class) + private final Bytes48 proof; + + public BlobAndProofV1( + @JsonProperty("blob") final Bytes blob, @JsonProperty("proof") final Bytes48 proof) { + checkNotNull(blob, "blob"); + checkNotNull(proof, "proof"); + this.proof = proof; + this.blob = blob; + } + + public BlobAndProof asInternalBlobsAndProofs(final BlobSchema blobSchema) { + return new BlobAndProof(new Blob(blobSchema, blob), new KZGProof(proof)); + } + + public static BlobAndProofV1 fromInternalBlobsBundle(final BlobAndProof blobAndProof) { + return new BlobAndProofV1( + blobAndProof.blob().getBytes(), blobAndProof.proof().getBytesCompressed()); + } + + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + final BlobAndProofV1 that = (BlobAndProofV1) o; + return Objects.equals(blob, that.blob) && Objects.equals(proof, that.proof); + } + + @Override + public int hashCode() { + return Objects.hash(blob, proof); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(this) + .add("blob", bytesToBriefString(blob)) + .add("proof", bytesToBriefString(proof)) + .toString(); + } + + private String bytesToBriefString(final Bytes bytes) { + return bytes.slice(0, 7).toUnprefixedHexString(); + } +} diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ClientVersionV1.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ClientVersionV1.java index 6709fe15065..084a1d1bf24 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ClientVersionV1.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ClientVersionV1.java @@ -36,10 +36,10 @@ public class ClientVersionV1 { public final Bytes4 commit; public ClientVersionV1( - @JsonProperty("code") String code, - @JsonProperty("name") String name, - @JsonProperty("version") String version, - @JsonProperty("commit") Bytes4 commit) { + final @JsonProperty("code") String code, + final @JsonProperty("name") String name, + final @JsonProperty("version") String version, + final @JsonProperty("commit") Bytes4 commit) { checkNotNull(code, "code"); checkNotNull(name, "name"); checkNotNull(version, "version"); diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ExitV1.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ConsolidationRequestV1.java similarity index 51% rename from ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ExitV1.java rename to ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ConsolidationRequestV1.java index aa8bede2a75..92bb0f96463 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ExitV1.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ConsolidationRequestV1.java @@ -13,9 +13,13 @@ package tech.pegasys.teku.ethereum.executionclient.schema; +import static com.google.common.base.Preconditions.checkNotNull; + import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.databind.annotation.JsonDeserialize; import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.google.common.base.MoreObjects; +import java.util.Objects; import org.apache.tuweni.bytes.Bytes48; import tech.pegasys.teku.ethereum.executionclient.serialization.Bytes20Deserializer; import tech.pegasys.teku.ethereum.executionclient.serialization.Bytes20Serializer; @@ -23,19 +27,56 @@ import tech.pegasys.teku.ethereum.executionclient.serialization.BytesSerializer; import tech.pegasys.teku.infrastructure.bytes.Bytes20; -public class ExitV1 { +public class ConsolidationRequestV1 { @JsonSerialize(using = Bytes20Serializer.class) @JsonDeserialize(using = Bytes20Deserializer.class) public final Bytes20 sourceAddress; @JsonSerialize(using = BytesSerializer.class) @JsonDeserialize(using = Bytes48Deserializer.class) - public final Bytes48 validatorPublicKey; + public final Bytes48 sourcePubkey; - public ExitV1( + @JsonSerialize(using = BytesSerializer.class) + @JsonDeserialize(using = Bytes48Deserializer.class) + public final Bytes48 targetPubkey; + + public ConsolidationRequestV1( @JsonProperty("sourceAddress") final Bytes20 sourceAddress, - @JsonProperty("validatorPublicKey") final Bytes48 validatorPublicKey) { + @JsonProperty("sourcePubkey") final Bytes48 sourcePubkey, + @JsonProperty("targetPubkey") final Bytes48 targetPubkey) { + checkNotNull(sourceAddress, "sourceAddress"); + checkNotNull(sourcePubkey, "sourcePubkey"); + checkNotNull(targetPubkey, "targetPubkey"); this.sourceAddress = sourceAddress; - this.validatorPublicKey = validatorPublicKey; + this.sourcePubkey = sourcePubkey; + this.targetPubkey = targetPubkey; + } + + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + final ConsolidationRequestV1 that = (ConsolidationRequestV1) o; + return Objects.equals(sourceAddress, that.sourceAddress) + && Objects.equals(sourcePubkey, that.sourcePubkey) + && Objects.equals(targetPubkey, that.targetPubkey); + } + + @Override + public int hashCode() { + return Objects.hash(sourceAddress, sourceAddress, targetPubkey); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(this) + .add("sourceAddress", sourceAddress) + .add("sourcePubkey", sourcePubkey) + .add("targetPubkey", targetPubkey) + .toString(); } } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/DepositReceiptV1.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/DepositRequestV1.java similarity index 66% rename from ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/DepositReceiptV1.java rename to ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/DepositRequestV1.java index 7d2b70f0ac8..1fe6256e062 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/DepositReceiptV1.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/DepositRequestV1.java @@ -13,9 +13,13 @@ package tech.pegasys.teku.ethereum.executionclient.schema; +import static com.google.common.base.Preconditions.checkNotNull; + import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.databind.annotation.JsonDeserialize; import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.google.common.base.MoreObjects; +import java.util.Objects; import org.apache.tuweni.bytes.Bytes; import org.apache.tuweni.bytes.Bytes32; import org.apache.tuweni.bytes.Bytes48; @@ -27,7 +31,7 @@ import tech.pegasys.teku.ethereum.executionclient.serialization.UInt64AsHexSerializer; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -public class DepositReceiptV1 { +public class DepositRequestV1 { @JsonSerialize(using = BytesSerializer.class) @JsonDeserialize(using = Bytes48Deserializer.class) public final Bytes48 pubkey; @@ -48,16 +52,53 @@ public class DepositReceiptV1 { @JsonDeserialize(using = UInt64AsHexDeserializer.class) public final UInt64 index; - public DepositReceiptV1( + public DepositRequestV1( @JsonProperty("pubkey") final Bytes48 pubkey, @JsonProperty("withdrawalCredentials") final Bytes32 withdrawalCredentials, @JsonProperty("amount") final UInt64 amount, @JsonProperty("signature") final Bytes signature, @JsonProperty("index") final UInt64 index) { + checkNotNull(pubkey, "pubkey"); + checkNotNull(withdrawalCredentials, "withdrawalCredentials"); + checkNotNull(amount, "amount"); + checkNotNull(signature, "signature"); + checkNotNull(index, "index"); this.pubkey = pubkey; this.withdrawalCredentials = withdrawalCredentials; this.amount = amount; this.signature = signature; this.index = index; } + + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + final DepositRequestV1 that = (DepositRequestV1) o; + return Objects.equals(pubkey, that.pubkey) + && Objects.equals(withdrawalCredentials, that.withdrawalCredentials) + && Objects.equals(amount, that.amount) + && Objects.equals(signature, that.signature) + && Objects.equals(index, that.index); + } + + @Override + public int hashCode() { + return Objects.hash(pubkey, withdrawalCredentials, amount, signature, index); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(this) + .add("pubkey", pubkey) + .add("withdrawalCredentials", withdrawalCredentials) + .add("amount", amount) + .add("signature", signature) + .add("index", index) + .toString(); + } } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ExecutionPayloadCommon.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ExecutionPayloadCommon.java index 545422f691e..6a51159318a 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ExecutionPayloadCommon.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ExecutionPayloadCommon.java @@ -89,19 +89,19 @@ public class ExecutionPayloadCommon { public final Bytes32 blockHash; public ExecutionPayloadCommon( - @JsonProperty("parentHash") Bytes32 parentHash, - @JsonProperty("feeRecipient") Bytes20 feeRecipient, - @JsonProperty("stateRoot") Bytes32 stateRoot, - @JsonProperty("receiptsRoot") Bytes32 receiptsRoot, - @JsonProperty("logsBloom") Bytes logsBloom, - @JsonProperty("prevRandao") Bytes32 prevRandao, - @JsonProperty("blockNumber") UInt64 blockNumber, - @JsonProperty("gasLimit") UInt64 gasLimit, - @JsonProperty("gasUsed") UInt64 gasUsed, - @JsonProperty("timestamp") UInt64 timestamp, - @JsonProperty("extraData") Bytes extraData, - @JsonProperty("baseFeePerGas") UInt256 baseFeePerGas, - @JsonProperty("blockHash") Bytes32 blockHash) { + final @JsonProperty("parentHash") Bytes32 parentHash, + final @JsonProperty("feeRecipient") Bytes20 feeRecipient, + final @JsonProperty("stateRoot") Bytes32 stateRoot, + final @JsonProperty("receiptsRoot") Bytes32 receiptsRoot, + final @JsonProperty("logsBloom") Bytes logsBloom, + final @JsonProperty("prevRandao") Bytes32 prevRandao, + final @JsonProperty("blockNumber") UInt64 blockNumber, + final @JsonProperty("gasLimit") UInt64 gasLimit, + final @JsonProperty("gasUsed") UInt64 gasUsed, + final @JsonProperty("timestamp") UInt64 timestamp, + final @JsonProperty("extraData") Bytes extraData, + final @JsonProperty("baseFeePerGas") UInt256 baseFeePerGas, + final @JsonProperty("blockHash") Bytes32 blockHash) { checkNotNull(parentHash, "parentHash"); checkNotNull(feeRecipient, "feeRecipient"); checkNotNull(stateRoot, "stateRoot"); diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ExecutionPayloadV1.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ExecutionPayloadV1.java index 1dde13dee36..514a8c270d2 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ExecutionPayloadV1.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ExecutionPayloadV1.java @@ -13,6 +13,8 @@ package tech.pegasys.teku.ethereum.executionclient.schema; +import static com.google.common.base.Preconditions.checkNotNull; + import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.databind.annotation.JsonDeserialize; import com.fasterxml.jackson.databind.annotation.JsonSerialize; @@ -37,20 +39,20 @@ public class ExecutionPayloadV1 extends ExecutionPayloadCommon { public final List transactions; public ExecutionPayloadV1( - @JsonProperty("parentHash") Bytes32 parentHash, - @JsonProperty("feeRecipient") Bytes20 feeRecipient, - @JsonProperty("stateRoot") Bytes32 stateRoot, - @JsonProperty("receiptsRoot") Bytes32 receiptsRoot, - @JsonProperty("logsBloom") Bytes logsBloom, - @JsonProperty("prevRandao") Bytes32 prevRandao, - @JsonProperty("blockNumber") UInt64 blockNumber, - @JsonProperty("gasLimit") UInt64 gasLimit, - @JsonProperty("gasUsed") UInt64 gasUsed, - @JsonProperty("timestamp") UInt64 timestamp, - @JsonProperty("extraData") Bytes extraData, - @JsonProperty("baseFeePerGas") UInt256 baseFeePerGas, - @JsonProperty("blockHash") Bytes32 blockHash, - @JsonProperty("transactions") List transactions) { + final @JsonProperty("parentHash") Bytes32 parentHash, + final @JsonProperty("feeRecipient") Bytes20 feeRecipient, + final @JsonProperty("stateRoot") Bytes32 stateRoot, + final @JsonProperty("receiptsRoot") Bytes32 receiptsRoot, + final @JsonProperty("logsBloom") Bytes logsBloom, + final @JsonProperty("prevRandao") Bytes32 prevRandao, + final @JsonProperty("blockNumber") UInt64 blockNumber, + final @JsonProperty("gasLimit") UInt64 gasLimit, + final @JsonProperty("gasUsed") UInt64 gasUsed, + final @JsonProperty("timestamp") UInt64 timestamp, + final @JsonProperty("extraData") Bytes extraData, + final @JsonProperty("baseFeePerGas") UInt256 baseFeePerGas, + final @JsonProperty("blockHash") Bytes32 blockHash, + final @JsonProperty("transactions") List transactions) { super( parentHash, feeRecipient, @@ -65,11 +67,12 @@ public ExecutionPayloadV1( extraData, baseFeePerGas, blockHash); - this.transactions = transactions != null ? transactions : List.of(); + checkNotNull(transactions, "transactions"); + this.transactions = transactions; } public ExecutionPayload asInternalExecutionPayload( - ExecutionPayloadSchema executionPayloadSchema) { + final ExecutionPayloadSchema executionPayloadSchema) { return executionPayloadSchema.createExecutionPayload( builder -> applyToBuilder(executionPayloadSchema, builder)); } @@ -94,7 +97,8 @@ protected ExecutionPayloadBuilder applyToBuilder( .transactions(transactions); } - public static ExecutionPayloadV1 fromInternalExecutionPayload(ExecutionPayload executionPayload) { + public static ExecutionPayloadV1 fromInternalExecutionPayload( + final ExecutionPayload executionPayload) { return new ExecutionPayloadV1( executionPayload.getParentHash(), executionPayload.getFeeRecipient(), @@ -109,7 +113,11 @@ public static ExecutionPayloadV1 fromInternalExecutionPayload(ExecutionPayload e executionPayload.getExtraData(), executionPayload.getBaseFeePerGas(), executionPayload.getBlockHash(), - executionPayload.getTransactions().stream().map(SszByteListImpl::getBytes).toList()); + getTransactions(executionPayload)); + } + + public static List getTransactions(final ExecutionPayload executionPayload) { + return executionPayload.getTransactions().stream().map(SszByteListImpl::getBytes).toList(); } @Override diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ExecutionPayloadV2.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ExecutionPayloadV2.java index 59ca7794e81..13bc0285b84 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ExecutionPayloadV2.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ExecutionPayloadV2.java @@ -16,40 +16,40 @@ import static com.google.common.base.Preconditions.checkNotNull; import com.fasterxml.jackson.annotation.JsonProperty; -import java.util.ArrayList; +import com.google.common.base.MoreObjects; import java.util.List; -import java.util.Optional; +import java.util.Objects; import org.apache.tuweni.bytes.Bytes; import org.apache.tuweni.bytes.Bytes32; import org.apache.tuweni.units.bigints.UInt256; import tech.pegasys.teku.infrastructure.bytes.Bytes20; import tech.pegasys.teku.infrastructure.ssz.SszList; -import tech.pegasys.teku.infrastructure.ssz.collections.impl.SszByteListImpl; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadBuilder; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.capella.ExecutionPayloadCapella; import tech.pegasys.teku.spec.datastructures.execution.versions.capella.Withdrawal; public class ExecutionPayloadV2 extends ExecutionPayloadV1 { public final List withdrawals; public ExecutionPayloadV2( - @JsonProperty("parentHash") Bytes32 parentHash, - @JsonProperty("feeRecipient") Bytes20 feeRecipient, - @JsonProperty("stateRoot") Bytes32 stateRoot, - @JsonProperty("receiptsRoot") Bytes32 receiptsRoot, - @JsonProperty("logsBloom") Bytes logsBloom, - @JsonProperty("prevRandao") Bytes32 prevRandao, - @JsonProperty("blockNumber") UInt64 blockNumber, - @JsonProperty("gasLimit") UInt64 gasLimit, - @JsonProperty("gasUsed") UInt64 gasUsed, - @JsonProperty("timestamp") UInt64 timestamp, - @JsonProperty("extraData") Bytes extraData, - @JsonProperty("baseFeePerGas") UInt256 baseFeePerGas, - @JsonProperty("blockHash") Bytes32 blockHash, - @JsonProperty("transactions") List transactions, - @JsonProperty("withdrawals") List withdrawals) { + final @JsonProperty("parentHash") Bytes32 parentHash, + final @JsonProperty("feeRecipient") Bytes20 feeRecipient, + final @JsonProperty("stateRoot") Bytes32 stateRoot, + final @JsonProperty("receiptsRoot") Bytes32 receiptsRoot, + final @JsonProperty("logsBloom") Bytes logsBloom, + final @JsonProperty("prevRandao") Bytes32 prevRandao, + final @JsonProperty("blockNumber") UInt64 blockNumber, + final @JsonProperty("gasLimit") UInt64 gasLimit, + final @JsonProperty("gasUsed") UInt64 gasUsed, + final @JsonProperty("timestamp") UInt64 timestamp, + final @JsonProperty("extraData") Bytes extraData, + final @JsonProperty("baseFeePerGas") UInt256 baseFeePerGas, + final @JsonProperty("blockHash") Bytes32 blockHash, + final @JsonProperty("transactions") List transactions, + final @JsonProperty("withdrawals") List withdrawals) { super( parentHash, feeRecipient, @@ -65,29 +65,10 @@ public ExecutionPayloadV2( baseFeePerGas, blockHash, transactions); + checkNotNull(withdrawals, "withdrawals"); this.withdrawals = withdrawals; } - public static ExecutionPayloadV2 fromInternalExecutionPayload(ExecutionPayload executionPayload) { - List withdrawalsList = getWithdrawals(executionPayload.getOptionalWithdrawals()); - return new ExecutionPayloadV2( - executionPayload.getParentHash(), - executionPayload.getFeeRecipient(), - executionPayload.getStateRoot(), - executionPayload.getReceiptsRoot(), - executionPayload.getLogsBloom(), - executionPayload.getPrevRandao(), - executionPayload.getBlockNumber(), - executionPayload.getGasLimit(), - executionPayload.getGasUsed(), - executionPayload.getTimestamp(), - executionPayload.getExtraData(), - executionPayload.getBaseFeePerGas(), - executionPayload.getBlockHash(), - executionPayload.getTransactions().stream().map(SszByteListImpl::getBytes).toList(), - withdrawalsList); - } - @Override protected ExecutionPayloadBuilder applyToBuilder( final ExecutionPayloadSchema executionPayloadSchema, @@ -95,7 +76,7 @@ protected ExecutionPayloadBuilder applyToBuilder( return super.applyToBuilder(executionPayloadSchema, builder) .withdrawals( () -> - checkNotNull(withdrawals, "Withdrawals not provided when required").stream() + withdrawals.stream() .map( withdrawalV1 -> createInternalWithdrawal(withdrawalV1, executionPayloadSchema)) @@ -103,7 +84,7 @@ protected ExecutionPayloadBuilder applyToBuilder( } private Withdrawal createInternalWithdrawal( - final WithdrawalV1 withdrawalV1, ExecutionPayloadSchema executionPayloadSchema) { + final WithdrawalV1 withdrawalV1, final ExecutionPayloadSchema executionPayloadSchema) { return executionPayloadSchema .getWithdrawalSchemaRequired() .create( @@ -113,18 +94,76 @@ private Withdrawal createInternalWithdrawal( withdrawalV1.amount); } - public static List getWithdrawals( - final Optional> maybeWithdrawals) { - if (maybeWithdrawals.isEmpty()) { - return List.of(); - } + public static ExecutionPayloadV2 fromInternalExecutionPayload( + final ExecutionPayload executionPayload) { + return new ExecutionPayloadV2( + executionPayload.getParentHash(), + executionPayload.getFeeRecipient(), + executionPayload.getStateRoot(), + executionPayload.getReceiptsRoot(), + executionPayload.getLogsBloom(), + executionPayload.getPrevRandao(), + executionPayload.getBlockNumber(), + executionPayload.getGasLimit(), + executionPayload.getGasUsed(), + executionPayload.getTimestamp(), + executionPayload.getExtraData(), + executionPayload.getBaseFeePerGas(), + executionPayload.getBlockHash(), + getTransactions(executionPayload), + getWithdrawals(ExecutionPayloadCapella.required(executionPayload).getWithdrawals())); + } - final List withdrawals = new ArrayList<>(); + public static List getWithdrawals(final SszList withdrawals) { + return withdrawals.stream() + .map( + withdrawal -> + new WithdrawalV1( + withdrawal.getIndex(), + withdrawal.getValidatorIndex(), + withdrawal.getAddress(), + withdrawal.getAmount())) + .toList(); + } - for (Withdrawal w : maybeWithdrawals.get()) { - withdrawals.add( - new WithdrawalV1(w.getIndex(), w.getValidatorIndex(), w.getAddress(), w.getAmount())); + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; } - return withdrawals; + if (!super.equals(o)) { + return false; + } + final ExecutionPayloadV2 that = (ExecutionPayloadV2) o; + return Objects.equals(withdrawals, that.withdrawals); + } + + @Override + public int hashCode() { + return Objects.hash(super.hashCode(), withdrawals); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(this) + .add("parentHash", parentHash) + .add("feeRecipient", feeRecipient) + .add("stateRoot", stateRoot) + .add("receiptsRoot", receiptsRoot) + .add("logsBloom", logsBloom) + .add("prevRandao", prevRandao) + .add("blockNumber", blockNumber) + .add("gasLimit", gasLimit) + .add("gasUsed", gasUsed) + .add("timestamp", timestamp) + .add("extraData", extraData) + .add("baseFeePerGas", baseFeePerGas) + .add("blockHash", blockHash) + .add("transactions", transactions) + .add("withdrawals", withdrawals) + .toString(); } } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ExecutionPayloadV3.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ExecutionPayloadV3.java index d15b5986cbf..60df4f404c2 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ExecutionPayloadV3.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ExecutionPayloadV3.java @@ -18,18 +18,20 @@ import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.databind.annotation.JsonDeserialize; import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.google.common.base.MoreObjects; import java.util.List; +import java.util.Objects; import org.apache.tuweni.bytes.Bytes; import org.apache.tuweni.bytes.Bytes32; import org.apache.tuweni.units.bigints.UInt256; import tech.pegasys.teku.ethereum.executionclient.serialization.UInt64AsHexDeserializer; import tech.pegasys.teku.ethereum.executionclient.serialization.UInt64AsHexSerializer; import tech.pegasys.teku.infrastructure.bytes.Bytes20; -import tech.pegasys.teku.infrastructure.ssz.collections.impl.SszByteListImpl; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadBuilder; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.capella.ExecutionPayloadCapella; import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadDeneb; public class ExecutionPayloadV3 extends ExecutionPayloadV2 { @@ -42,23 +44,23 @@ public class ExecutionPayloadV3 extends ExecutionPayloadV2 { public final UInt64 excessBlobGas; public ExecutionPayloadV3( - @JsonProperty("parentHash") Bytes32 parentHash, - @JsonProperty("feeRecipient") Bytes20 feeRecipient, - @JsonProperty("stateRoot") Bytes32 stateRoot, - @JsonProperty("receiptsRoot") Bytes32 receiptsRoot, - @JsonProperty("logsBloom") Bytes logsBloom, - @JsonProperty("prevRandao") Bytes32 prevRandao, - @JsonProperty("blockNumber") UInt64 blockNumber, - @JsonProperty("gasLimit") UInt64 gasLimit, - @JsonProperty("gasUsed") UInt64 gasUsed, - @JsonProperty("timestamp") UInt64 timestamp, - @JsonProperty("extraData") Bytes extraData, - @JsonProperty("baseFeePerGas") UInt256 baseFeePerGas, - @JsonProperty("blockHash") Bytes32 blockHash, - @JsonProperty("transactions") List transactions, - @JsonProperty("withdrawals") List withdrawals, - @JsonProperty("blobGasUsed") UInt64 blobGasUsed, - @JsonProperty("excessBlobGas") UInt64 excessBlobGas) { + final @JsonProperty("parentHash") Bytes32 parentHash, + final @JsonProperty("feeRecipient") Bytes20 feeRecipient, + final @JsonProperty("stateRoot") Bytes32 stateRoot, + final @JsonProperty("receiptsRoot") Bytes32 receiptsRoot, + final @JsonProperty("logsBloom") Bytes logsBloom, + final @JsonProperty("prevRandao") Bytes32 prevRandao, + final @JsonProperty("blockNumber") UInt64 blockNumber, + final @JsonProperty("gasLimit") UInt64 gasLimit, + final @JsonProperty("gasUsed") UInt64 gasUsed, + final @JsonProperty("timestamp") UInt64 timestamp, + final @JsonProperty("extraData") Bytes extraData, + final @JsonProperty("baseFeePerGas") UInt256 baseFeePerGas, + final @JsonProperty("blockHash") Bytes32 blockHash, + final @JsonProperty("transactions") List transactions, + final @JsonProperty("withdrawals") List withdrawals, + final @JsonProperty("blobGasUsed") UInt64 blobGasUsed, + final @JsonProperty("excessBlobGas") UInt64 excessBlobGas) { super( parentHash, feeRecipient, @@ -75,14 +77,23 @@ public ExecutionPayloadV3( blockHash, transactions, withdrawals); + checkNotNull(blobGasUsed, "blobGasUsed"); + checkNotNull(excessBlobGas, "excessBlobGas"); this.blobGasUsed = blobGasUsed; this.excessBlobGas = excessBlobGas; } + @Override + protected ExecutionPayloadBuilder applyToBuilder( + final ExecutionPayloadSchema executionPayloadSchema, + final ExecutionPayloadBuilder builder) { + return super.applyToBuilder(executionPayloadSchema, builder) + .blobGasUsed(() -> blobGasUsed) + .excessBlobGas(() -> excessBlobGas); + } + public static ExecutionPayloadV3 fromInternalExecutionPayload( final ExecutionPayload executionPayload) { - final List withdrawalsList = - getWithdrawals(executionPayload.getOptionalWithdrawals()); return new ExecutionPayloadV3( executionPayload.getParentHash(), executionPayload.getFeeRecipient(), @@ -97,22 +108,53 @@ public static ExecutionPayloadV3 fromInternalExecutionPayload( executionPayload.getExtraData(), executionPayload.getBaseFeePerGas(), executionPayload.getBlockHash(), - executionPayload.getTransactions().stream().map(SszByteListImpl::getBytes).toList(), - withdrawalsList, - executionPayload.toVersionDeneb().map(ExecutionPayloadDeneb::getBlobGasUsed).orElse(null), - executionPayload - .toVersionDeneb() - .map(ExecutionPayloadDeneb::getExcessBlobGas) - .orElse(null)); + getTransactions(executionPayload), + getWithdrawals(ExecutionPayloadCapella.required(executionPayload).getWithdrawals()), + ExecutionPayloadDeneb.required(executionPayload).getBlobGasUsed(), + ExecutionPayloadDeneb.required(executionPayload).getExcessBlobGas()); } @Override - protected ExecutionPayloadBuilder applyToBuilder( - final ExecutionPayloadSchema executionPayloadSchema, - final ExecutionPayloadBuilder builder) { - return super.applyToBuilder(executionPayloadSchema, builder) - .blobGasUsed(() -> checkNotNull(blobGasUsed, "blobGasUsed not provided when required")) - .excessBlobGas( - () -> checkNotNull(excessBlobGas, "excessBlobGas not provided when required")); + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + if (!super.equals(o)) { + return false; + } + final ExecutionPayloadV3 that = (ExecutionPayloadV3) o; + return Objects.equals(blobGasUsed, that.blobGasUsed) + && Objects.equals(excessBlobGas, that.excessBlobGas); + } + + @Override + public int hashCode() { + return Objects.hash(super.hashCode(), blobGasUsed, excessBlobGas); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(this) + .add("parentHash", parentHash) + .add("feeRecipient", feeRecipient) + .add("stateRoot", stateRoot) + .add("receiptsRoot", receiptsRoot) + .add("logsBloom", logsBloom) + .add("prevRandao", prevRandao) + .add("blockNumber", blockNumber) + .add("gasLimit", gasLimit) + .add("gasUsed", gasUsed) + .add("timestamp", timestamp) + .add("extraData", extraData) + .add("baseFeePerGas", baseFeePerGas) + .add("blockHash", blockHash) + .add("transactions", transactions) + .add("withdrawals", withdrawals) + .add("blobGasUsed", blobGasUsed) + .add("excessBlobGas", excessBlobGas) + .toString(); } } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ForkChoiceStateV1.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ForkChoiceStateV1.java index 3375d67efd3..10c783e6b9a 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ForkChoiceStateV1.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ForkChoiceStateV1.java @@ -39,9 +39,9 @@ public class ForkChoiceStateV1 { private final Bytes32 finalizedBlockHash; public ForkChoiceStateV1( - @JsonProperty("headBlockHash") Bytes32 headBlockHash, - @JsonProperty("safeBlockHash") Bytes32 safeBlockHash, - @JsonProperty("finalizedBlockHash") Bytes32 finalizedBlockHash) { + final @JsonProperty("headBlockHash") Bytes32 headBlockHash, + final @JsonProperty("safeBlockHash") Bytes32 safeBlockHash, + final @JsonProperty("finalizedBlockHash") Bytes32 finalizedBlockHash) { checkNotNull(headBlockHash, "headBlockHash"); checkNotNull(safeBlockHash, "safeBlockHash"); checkNotNull(finalizedBlockHash, "finalizedBlockHash"); @@ -50,7 +50,8 @@ public ForkChoiceStateV1( this.finalizedBlockHash = finalizedBlockHash; } - public static ForkChoiceStateV1 fromInternalForkChoiceState(ForkChoiceState forkChoiceState) { + public static ForkChoiceStateV1 fromInternalForkChoiceState( + final ForkChoiceState forkChoiceState) { return new ForkChoiceStateV1( forkChoiceState.getHeadExecutionBlockHash(), forkChoiceState.getSafeExecutionBlockHash(), diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ForkChoiceUpdatedResult.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ForkChoiceUpdatedResult.java index 7ebf12140d3..6817f741459 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ForkChoiceUpdatedResult.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/ForkChoiceUpdatedResult.java @@ -30,9 +30,9 @@ public class ForkChoiceUpdatedResult { private final Bytes8 payloadId; public ForkChoiceUpdatedResult( - @JsonProperty("payloadStatus") PayloadStatusV1 payloadStatus, - @JsonProperty("payloadId") Bytes8 payloadId) { - checkNotNull(payloadStatus, "payloadStatus cannot be null"); + final @JsonProperty("payloadStatus") PayloadStatusV1 payloadStatus, + final @JsonProperty("payloadId") Bytes8 payloadId) { + checkNotNull(payloadStatus, "payloadStatus"); this.payloadStatus = payloadStatus; this.payloadId = payloadId; } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/GetPayloadV2Response.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/GetPayloadV2Response.java index c57899218d7..1bdbdad99f7 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/GetPayloadV2Response.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/GetPayloadV2Response.java @@ -13,12 +13,16 @@ package tech.pegasys.teku.ethereum.executionclient.schema; +import static com.google.common.base.Preconditions.checkNotNull; + import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.databind.annotation.JsonDeserialize; import com.fasterxml.jackson.databind.annotation.JsonSerialize; import org.apache.tuweni.units.bigints.UInt256; import tech.pegasys.teku.ethereum.executionclient.serialization.UInt256AsHexDeserializer; import tech.pegasys.teku.ethereum.executionclient.serialization.UInt256AsHexSerializer; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSchema; +import tech.pegasys.teku.spec.datastructures.execution.GetPayloadResponse; public class GetPayloadV2Response { public final ExecutionPayloadV2 executionPayload; @@ -28,9 +32,17 @@ public class GetPayloadV2Response { public final UInt256 blockValue; public GetPayloadV2Response( - @JsonProperty("executionPayload") final ExecutionPayloadV2 executionPayload, - @JsonProperty("blockValue") final UInt256 blockValue) { + final @JsonProperty("executionPayload") ExecutionPayloadV2 executionPayload, + final @JsonProperty("blockValue") UInt256 blockValue) { + checkNotNull(executionPayload, "executionPayload"); + checkNotNull(blockValue, "blockValue"); this.executionPayload = executionPayload; this.blockValue = blockValue; } + + public GetPayloadResponse asInternalGetPayloadResponse( + final ExecutionPayloadSchema executionPayloadSchema) { + return new GetPayloadResponse( + executionPayload.asInternalExecutionPayload(executionPayloadSchema), blockValue); + } } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/GetPayloadV3Response.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/GetPayloadV3Response.java index 96a47f6e4c1..3e7dbd3b4ee 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/GetPayloadV3Response.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/GetPayloadV3Response.java @@ -13,12 +13,17 @@ package tech.pegasys.teku.ethereum.executionclient.schema; +import static com.google.common.base.Preconditions.checkNotNull; + import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.databind.annotation.JsonDeserialize; import com.fasterxml.jackson.databind.annotation.JsonSerialize; import org.apache.tuweni.units.bigints.UInt256; import tech.pegasys.teku.ethereum.executionclient.serialization.UInt256AsHexDeserializer; import tech.pegasys.teku.ethereum.executionclient.serialization.UInt256AsHexSerializer; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSchema; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSchema; +import tech.pegasys.teku.spec.datastructures.execution.GetPayloadResponse; public class GetPayloadV3Response { public final ExecutionPayloadV3 executionPayload; @@ -32,13 +37,25 @@ public class GetPayloadV3Response { public final boolean shouldOverrideBuilder; public GetPayloadV3Response( - @JsonProperty("executionPayload") final ExecutionPayloadV3 executionPayload, - @JsonProperty("blockValue") final UInt256 blockValue, - @JsonProperty("blobsBundle") final BlobsBundleV1 blobsBundle, - @JsonProperty("shouldOverrideBuilder") final boolean shouldOverrideBuilder) { + final @JsonProperty("executionPayload") ExecutionPayloadV3 executionPayload, + final @JsonProperty("blockValue") UInt256 blockValue, + final @JsonProperty("blobsBundle") BlobsBundleV1 blobsBundle, + final @JsonProperty("shouldOverrideBuilder") boolean shouldOverrideBuilder) { + checkNotNull(executionPayload, "executionPayload"); + checkNotNull(blockValue, "blockValue"); + checkNotNull(blobsBundle, "blobsBundle"); this.executionPayload = executionPayload; this.blockValue = blockValue; this.blobsBundle = blobsBundle; this.shouldOverrideBuilder = shouldOverrideBuilder; } + + public GetPayloadResponse asInternalGetPayloadResponse( + final ExecutionPayloadSchema executionPayloadSchema, final BlobSchema blobSchema) { + return new GetPayloadResponse( + executionPayload.asInternalExecutionPayload(executionPayloadSchema), + blockValue, + blobsBundle.asInternalBlobsBundle(blobSchema), + shouldOverrideBuilder); + } } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/GetPayloadV4Response.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/GetPayloadV4Response.java new file mode 100644 index 00000000000..8ee030d0c53 --- /dev/null +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/GetPayloadV4Response.java @@ -0,0 +1,77 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.ethereum.executionclient.schema; + +import static com.google.common.base.Preconditions.checkNotNull; + +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import java.util.List; +import org.apache.tuweni.bytes.Bytes; +import org.apache.tuweni.units.bigints.UInt256; +import tech.pegasys.teku.ethereum.executionclient.serialization.BytesDeserializer; +import tech.pegasys.teku.ethereum.executionclient.serialization.BytesSerializer; +import tech.pegasys.teku.ethereum.executionclient.serialization.UInt256AsHexDeserializer; +import tech.pegasys.teku.ethereum.executionclient.serialization.UInt256AsHexSerializer; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSchema; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSchema; +import tech.pegasys.teku.spec.datastructures.execution.GetPayloadResponse; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsDataCodec; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsSchema; + +public class GetPayloadV4Response { + public final ExecutionPayloadV3 executionPayload; + + @JsonSerialize(using = UInt256AsHexSerializer.class) + @JsonDeserialize(using = UInt256AsHexDeserializer.class) + public final UInt256 blockValue; + + public final BlobsBundleV1 blobsBundle; + + public final boolean shouldOverrideBuilder; + + @JsonSerialize(contentUsing = BytesSerializer.class) + @JsonDeserialize(contentUsing = BytesDeserializer.class) + public final List executionRequests; + + public GetPayloadV4Response( + final @JsonProperty("executionPayload") ExecutionPayloadV3 executionPayload, + final @JsonProperty("blockValue") UInt256 blockValue, + final @JsonProperty("blobsBundle") BlobsBundleV1 blobsBundle, + final @JsonProperty("shouldOverrideBuilder") boolean shouldOverrideBuilder, + final @JsonProperty("executionRequests") List executionRequests) { + checkNotNull(executionPayload, "executionPayload"); + checkNotNull(blockValue, "blockValue"); + checkNotNull(blobsBundle, "blobsBundle"); + checkNotNull(executionRequests, "executionRequests"); + this.executionPayload = executionPayload; + this.blockValue = blockValue; + this.blobsBundle = blobsBundle; + this.shouldOverrideBuilder = shouldOverrideBuilder; + this.executionRequests = executionRequests; + } + + public GetPayloadResponse asInternalGetPayloadResponse( + final ExecutionPayloadSchema executionPayloadSchema, + final BlobSchema blobSchema, + final ExecutionRequestsSchema executionRequestsSchema) { + return new GetPayloadResponse( + executionPayload.asInternalExecutionPayload(executionPayloadSchema), + blockValue, + blobsBundle.asInternalBlobsBundle(blobSchema), + shouldOverrideBuilder, + new ExecutionRequestsDataCodec(executionRequestsSchema).decode(executionRequests)); + } +} diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/PayloadAttributesV1.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/PayloadAttributesV1.java index 2e9c9179c49..c974a73bc28 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/PayloadAttributesV1.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/PayloadAttributesV1.java @@ -46,9 +46,9 @@ public class PayloadAttributesV1 { public final Bytes20 suggestedFeeRecipient; public PayloadAttributesV1( - @JsonProperty("timestamp") UInt64 timestamp, - @JsonProperty("prevRandao") Bytes32 prevRandao, - @JsonProperty("suggestedFeeRecipient") Bytes20 suggestedFeeRecipient) { + final @JsonProperty("timestamp") UInt64 timestamp, + final @JsonProperty("prevRandao") Bytes32 prevRandao, + final @JsonProperty("suggestedFeeRecipient") Bytes20 suggestedFeeRecipient) { checkNotNull(timestamp, "timestamp"); checkNotNull(prevRandao, "prevRandao"); checkNotNull(suggestedFeeRecipient, "suggestedFeeRecipient"); @@ -58,9 +58,9 @@ public PayloadAttributesV1( } public static Optional fromInternalPayloadBuildingAttributes( - Optional payloadBuildingAttributes) { + final Optional payloadBuildingAttributes) { return payloadBuildingAttributes.map( - (payloadAttributes) -> + payloadAttributes -> new PayloadAttributesV1( payloadAttributes.getTimestamp(), payloadAttributes.getPrevRandao(), diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/PayloadAttributesV2.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/PayloadAttributesV2.java index 0c935089eff..011b02d5829 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/PayloadAttributesV2.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/PayloadAttributesV2.java @@ -13,14 +13,16 @@ package tech.pegasys.teku.ethereum.executionclient.schema; +import static com.google.common.base.Preconditions.checkNotNull; + import com.fasterxml.jackson.annotation.JsonProperty; -import java.util.ArrayList; +import com.google.common.base.MoreObjects; import java.util.List; +import java.util.Objects; import java.util.Optional; import org.apache.tuweni.bytes.Bytes32; import tech.pegasys.teku.infrastructure.bytes.Bytes20; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.datastructures.execution.versions.capella.Withdrawal; import tech.pegasys.teku.spec.executionlayer.PayloadBuildingAttributes; public class PayloadAttributesV2 extends PayloadAttributesV1 { @@ -28,37 +30,73 @@ public class PayloadAttributesV2 extends PayloadAttributesV1 { public final List withdrawals; public PayloadAttributesV2( - @JsonProperty("timestamp") UInt64 timestamp, - @JsonProperty("prevRandao") Bytes32 prevRandao, - @JsonProperty("suggestedFeeRecipient") Bytes20 suggestedFeeRecipient, - @JsonProperty("withdrawals") final List withdrawals) { + final @JsonProperty("timestamp") UInt64 timestamp, + final @JsonProperty("prevRandao") Bytes32 prevRandao, + final @JsonProperty("suggestedFeeRecipient") Bytes20 suggestedFeeRecipient, + final @JsonProperty("withdrawals") List withdrawals) { super(timestamp, prevRandao, suggestedFeeRecipient); + checkNotNull(withdrawals, "withdrawals"); this.withdrawals = withdrawals; } public static Optional fromInternalPayloadBuildingAttributesV2( - Optional payloadBuildingAttributes) { + final Optional payloadBuildingAttributes) { return payloadBuildingAttributes.map( - (payloadAttributes) -> + payloadAttributes -> new PayloadAttributesV2( payloadAttributes.getTimestamp(), payloadAttributes.getPrevRandao(), payloadAttributes.getFeeRecipient(), - PayloadAttributesV2.getWithdrawals(payloadAttributes.getWithdrawals()))); + getWithdrawals(payloadAttributes))); } public static List getWithdrawals( - final Optional> maybeWithdrawals) { - if (maybeWithdrawals.isEmpty()) { - return null; + final PayloadBuildingAttributes payloadAttributes) { + return payloadAttributes + .getWithdrawals() + .orElseThrow( + () -> + new IllegalArgumentException( + "Withdrawals were expected to be part of the payload attributes for slot " + + payloadAttributes.getProposalSlot())) + .stream() + .map( + withdrawal -> + new WithdrawalV1( + withdrawal.getIndex(), + withdrawal.getValidatorIndex(), + withdrawal.getAddress(), + withdrawal.getAmount())) + .toList(); + } + + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; } + if (!super.equals(o)) { + return false; + } + final PayloadAttributesV2 that = (PayloadAttributesV2) o; + return Objects.equals(withdrawals, that.withdrawals); + } - final List withdrawals = new ArrayList<>(); + @Override + public int hashCode() { + return Objects.hash(super.hashCode(), withdrawals); + } - for (final Withdrawal w : maybeWithdrawals.get()) { - withdrawals.add( - new WithdrawalV1(w.getIndex(), w.getValidatorIndex(), w.getAddress(), w.getAmount())); - } - return withdrawals; + @Override + public String toString() { + return MoreObjects.toStringHelper(this) + .add("timestamp", timestamp) + .add("prevRandao", prevRandao) + .add("suggestedFeeRecipient", suggestedFeeRecipient) + .add("withdrawals", withdrawals) + .toString(); } } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/PayloadAttributesV3.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/PayloadAttributesV3.java index 7d62f80d8ec..964a057994b 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/PayloadAttributesV3.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/PayloadAttributesV3.java @@ -13,10 +13,14 @@ package tech.pegasys.teku.ethereum.executionclient.schema; +import static com.google.common.base.Preconditions.checkNotNull; + import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.databind.annotation.JsonDeserialize; import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.google.common.base.MoreObjects; import java.util.List; +import java.util.Objects; import java.util.Optional; import org.apache.tuweni.bytes.Bytes32; import tech.pegasys.teku.ethereum.executionclient.serialization.Bytes32Deserializer; @@ -32,24 +36,56 @@ public class PayloadAttributesV3 extends PayloadAttributesV2 { public final Bytes32 parentBeaconBlockRoot; public PayloadAttributesV3( - @JsonProperty("timestamp") UInt64 timestamp, - @JsonProperty("prevRandao") Bytes32 prevRandao, - @JsonProperty("suggestedFeeRecipient") Bytes20 suggestedFeeRecipient, - @JsonProperty("withdrawals") List withdrawals, - @JsonProperty("parentBeaconBlockRoot") final Bytes32 parentBeaconBlockRoot) { + final @JsonProperty("timestamp") UInt64 timestamp, + final @JsonProperty("prevRandao") Bytes32 prevRandao, + final @JsonProperty("suggestedFeeRecipient") Bytes20 suggestedFeeRecipient, + final @JsonProperty("withdrawals") List withdrawals, + final @JsonProperty("parentBeaconBlockRoot") Bytes32 parentBeaconBlockRoot) { super(timestamp, prevRandao, suggestedFeeRecipient, withdrawals); + checkNotNull(parentBeaconBlockRoot, "parentBeaconBlockRoot"); this.parentBeaconBlockRoot = parentBeaconBlockRoot; } public static Optional fromInternalPayloadBuildingAttributesV3( - Optional payloadBuildingAttributes) { + final Optional payloadBuildingAttributes) { return payloadBuildingAttributes.map( - (payloadAttributes) -> + payloadAttributes -> new PayloadAttributesV3( payloadAttributes.getTimestamp(), payloadAttributes.getPrevRandao(), payloadAttributes.getFeeRecipient(), - getWithdrawals(payloadAttributes.getWithdrawals()), + getWithdrawals(payloadAttributes), payloadAttributes.getParentBeaconBlockRoot())); } + + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + if (!super.equals(o)) { + return false; + } + final PayloadAttributesV3 that = (PayloadAttributesV3) o; + return Objects.equals(parentBeaconBlockRoot, that.parentBeaconBlockRoot); + } + + @Override + public int hashCode() { + return Objects.hash(super.hashCode(), parentBeaconBlockRoot); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(this) + .add("timestamp", timestamp) + .add("prevRandao", prevRandao) + .add("suggestedFeeRecipient", suggestedFeeRecipient) + .add("withdrawals", withdrawals) + .add("parentBeaconBlockRoot", parentBeaconBlockRoot) + .toString(); + } } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/PayloadAttributesV4.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/PayloadAttributesV4.java new file mode 100644 index 00000000000..e3ed4caa59f --- /dev/null +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/PayloadAttributesV4.java @@ -0,0 +1,115 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.ethereum.executionclient.schema; + +import static com.google.common.base.Preconditions.checkNotNull; + +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.google.common.base.MoreObjects; +import java.util.List; +import java.util.Objects; +import java.util.Optional; +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.ethereum.executionclient.serialization.UInt64AsHexDeserializer; +import tech.pegasys.teku.ethereum.executionclient.serialization.UInt64AsHexSerializer; +import tech.pegasys.teku.infrastructure.bytes.Bytes20; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.executionlayer.PayloadBuildingAttributes; + +public class PayloadAttributesV4 extends PayloadAttributesV3 { + + @JsonSerialize(using = UInt64AsHexSerializer.class) + @JsonDeserialize(using = UInt64AsHexDeserializer.class) + public final UInt64 targetBlobCount; + + @JsonSerialize(using = UInt64AsHexSerializer.class) + @JsonDeserialize(using = UInt64AsHexDeserializer.class) + public final UInt64 maximumBlobCount; + + public PayloadAttributesV4( + final @JsonProperty("timestamp") UInt64 timestamp, + final @JsonProperty("prevRandao") Bytes32 prevRandao, + final @JsonProperty("suggestedFeeRecipient") Bytes20 suggestedFeeRecipient, + final @JsonProperty("withdrawals") List withdrawals, + final @JsonProperty("parentBeaconBlockRoot") Bytes32 parentBeaconBlockRoot, + final @JsonProperty("targetBlobCount") UInt64 targetBlobCount, + final @JsonProperty("maximumBlobCount") UInt64 maximumBlobCount) { + super(timestamp, prevRandao, suggestedFeeRecipient, withdrawals, parentBeaconBlockRoot); + + checkNotNull(targetBlobCount, "targetBlobCount"); + checkNotNull(maximumBlobCount, "maximumBlobCount"); + this.targetBlobCount = targetBlobCount; + this.maximumBlobCount = maximumBlobCount; + } + + public static Optional fromInternalPayloadBuildingAttributesV4( + final Optional payloadBuildingAttributes) { + return payloadBuildingAttributes.map( + payloadAttributes -> + new PayloadAttributesV4( + payloadAttributes.getTimestamp(), + payloadAttributes.getPrevRandao(), + payloadAttributes.getFeeRecipient(), + getWithdrawals(payloadAttributes), + payloadAttributes.getParentBeaconBlockRoot(), + payloadAttributes + .getTargetBlobCount() + .orElseThrow( + () -> + new IllegalArgumentException( + "targetBlobCount is required for PayloadAttributesV4")), + payloadAttributes + .getMaximumBlobCount() + .orElseThrow( + () -> + new IllegalArgumentException( + "maximumBlobCount is required for PayloadAttributesV4")))); + } + + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + if (!super.equals(o)) { + return false; + } + final PayloadAttributesV4 that = (PayloadAttributesV4) o; + return Objects.equals(targetBlobCount, that.targetBlobCount) + && Objects.equals(maximumBlobCount, that.maximumBlobCount); + } + + @Override + public int hashCode() { + return Objects.hash(super.hashCode(), targetBlobCount, maximumBlobCount); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(this) + .add("timestamp", timestamp) + .add("prevRandao", prevRandao) + .add("suggestedFeeRecipient", suggestedFeeRecipient) + .add("withdrawals", withdrawals) + .add("parentBeaconBlockRoot", parentBeaconBlockRoot) + .add("targetBlobCount", targetBlobCount) + .add("maximumBlobCount", maximumBlobCount) + .toString(); + } +} diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/PayloadStatusV1.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/PayloadStatusV1.java index c48bca98e6c..79cc3196386 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/PayloadStatusV1.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/PayloadStatusV1.java @@ -34,10 +34,10 @@ public class PayloadStatusV1 { private final String validationError; public PayloadStatusV1( - @JsonProperty("status") ExecutionPayloadStatus status, - @JsonProperty("latestValidHash") Bytes32 latestValidHash, - @JsonProperty("validationError") String validationError) { - checkNotNull(status, "status cannot be null"); + final @JsonProperty("status") ExecutionPayloadStatus status, + final @JsonProperty("latestValidHash") Bytes32 latestValidHash, + final @JsonProperty("validationError") String validationError) { + checkNotNull(status, "status"); this.status = status; this.latestValidHash = latestValidHash; this.validationError = validationError; diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/Response.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/Response.java index 8ea4fd261cd..6d9f849b769 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/Response.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/Response.java @@ -38,7 +38,7 @@ public Response(final T payload) { } public static Response withNullPayload() { - return new Response<>(null, null); + return new Response<>(null); } public static Response withErrorMessage(final String errorMessage) { @@ -112,7 +112,7 @@ public boolean isFailure() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/WithdrawalRequestV1.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/WithdrawalRequestV1.java new file mode 100644 index 00000000000..ef54d28de51 --- /dev/null +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/WithdrawalRequestV1.java @@ -0,0 +1,85 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.ethereum.executionclient.schema; + +import static com.google.common.base.Preconditions.checkNotNull; + +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.google.common.base.MoreObjects; +import java.util.Objects; +import org.apache.tuweni.bytes.Bytes48; +import tech.pegasys.teku.ethereum.executionclient.serialization.Bytes20Deserializer; +import tech.pegasys.teku.ethereum.executionclient.serialization.Bytes20Serializer; +import tech.pegasys.teku.ethereum.executionclient.serialization.Bytes48Deserializer; +import tech.pegasys.teku.ethereum.executionclient.serialization.BytesSerializer; +import tech.pegasys.teku.ethereum.executionclient.serialization.UInt64AsHexDeserializer; +import tech.pegasys.teku.ethereum.executionclient.serialization.UInt64AsHexSerializer; +import tech.pegasys.teku.infrastructure.bytes.Bytes20; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; + +public class WithdrawalRequestV1 { + @JsonSerialize(using = Bytes20Serializer.class) + @JsonDeserialize(using = Bytes20Deserializer.class) + public final Bytes20 sourceAddress; + + @JsonSerialize(using = BytesSerializer.class) + @JsonDeserialize(using = Bytes48Deserializer.class) + public final Bytes48 validatorPubkey; + + @JsonSerialize(using = UInt64AsHexSerializer.class) + @JsonDeserialize(using = UInt64AsHexDeserializer.class) + public final UInt64 amount; + + public WithdrawalRequestV1( + @JsonProperty("sourceAddress") final Bytes20 sourceAddress, + @JsonProperty("validatorPubkey") final Bytes48 validatorPubkey, + @JsonProperty("amount") final UInt64 amount) { + checkNotNull(sourceAddress, "sourceAddress"); + checkNotNull(validatorPubkey, "validatorPubkey"); + checkNotNull(amount, "amount"); + this.sourceAddress = sourceAddress; + this.validatorPubkey = validatorPubkey; + this.amount = amount; + } + + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + final WithdrawalRequestV1 that = (WithdrawalRequestV1) o; + return Objects.equals(sourceAddress, that.sourceAddress) + && Objects.equals(validatorPubkey, that.validatorPubkey) + && Objects.equals(amount, that.amount); + } + + @Override + public int hashCode() { + return Objects.hash(sourceAddress, validatorPubkey, amount); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(this) + .add("sourceAddress", sourceAddress) + .add("validatorPubkey", validatorPubkey) + .add("amount", amount) + .toString(); + } +} diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/WithdrawalV1.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/WithdrawalV1.java index c4fe0a7b469..74b00fe80e5 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/WithdrawalV1.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/schema/WithdrawalV1.java @@ -13,9 +13,13 @@ package tech.pegasys.teku.ethereum.executionclient.schema; +import static com.google.common.base.Preconditions.checkNotNull; + import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.databind.annotation.JsonDeserialize; import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.google.common.base.MoreObjects; +import java.util.Objects; import tech.pegasys.teku.ethereum.executionclient.serialization.Bytes20Deserializer; import tech.pegasys.teku.ethereum.executionclient.serialization.Bytes20Serializer; import tech.pegasys.teku.ethereum.executionclient.serialization.UInt64AsHexDeserializer; @@ -45,9 +49,43 @@ public WithdrawalV1( @JsonProperty("validatorIndex") final UInt64 validatorIndex, @JsonProperty("address") final Bytes20 address, @JsonProperty("amount") final UInt64 amount) { + checkNotNull(index, "index"); + checkNotNull(validatorIndex, "validatorIndex"); + checkNotNull(address, "address"); + checkNotNull(amount, "amount"); this.index = index; this.validatorIndex = validatorIndex; this.address = address; this.amount = amount; } + + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + final WithdrawalV1 that = (WithdrawalV1) o; + return Objects.equals(index, that.index) + && Objects.equals(validatorIndex, that.validatorIndex) + && Objects.equals(address, that.address) + && Objects.equals(amount, that.amount); + } + + @Override + public int hashCode() { + return Objects.hash(index, validatorIndex, address, amount); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(this) + .add("index", index) + .add("validatorIndex", validatorIndex) + .add("address", address) + .add("amount", amount) + .toString(); + } } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/Bytes20Deserializer.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/Bytes20Deserializer.java index cfaea7a9cc1..9aee57b4caf 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/Bytes20Deserializer.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/Bytes20Deserializer.java @@ -22,7 +22,8 @@ public class Bytes20Deserializer extends JsonDeserializer { @Override - public Bytes20 deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { + public Bytes20 deserialize(final JsonParser p, final DeserializationContext ctxt) + throws IOException { return Bytes20.fromHexString(p.getValueAsString()); } } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/Bytes20Serializer.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/Bytes20Serializer.java index a84f03e49e4..4ca39eadff0 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/Bytes20Serializer.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/Bytes20Serializer.java @@ -22,7 +22,8 @@ public class Bytes20Serializer extends JsonSerializer { @Override - public void serialize(Bytes20 value, JsonGenerator gen, SerializerProvider serializers) + public void serialize( + final Bytes20 value, final JsonGenerator gen, final SerializerProvider serializers) throws IOException { gen.writeString(value.toHexString().toLowerCase(Locale.ROOT)); } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/Bytes32Deserializer.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/Bytes32Deserializer.java index f636a9ed3e9..ca9b5037a03 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/Bytes32Deserializer.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/Bytes32Deserializer.java @@ -22,7 +22,8 @@ public class Bytes32Deserializer extends JsonDeserializer { @Override - public Bytes32 deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { + public Bytes32 deserialize(final JsonParser p, final DeserializationContext ctxt) + throws IOException { return Bytes32.fromHexStringStrict(p.getValueAsString()); } } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/Bytes8Deserializer.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/Bytes8Deserializer.java index e08542c8609..41f31a15f3b 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/Bytes8Deserializer.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/Bytes8Deserializer.java @@ -22,7 +22,8 @@ public class Bytes8Deserializer extends JsonDeserializer { @Override - public Bytes8 deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { + public Bytes8 deserialize(final JsonParser p, final DeserializationContext ctxt) + throws IOException { return Bytes8.fromHexString(p.getValueAsString()); } } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/BytesDeserializer.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/BytesDeserializer.java index ed8c206a5c9..6c1e38cc22b 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/BytesDeserializer.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/BytesDeserializer.java @@ -22,7 +22,8 @@ public class BytesDeserializer extends JsonDeserializer { @Override - public Bytes deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { + public Bytes deserialize(final JsonParser p, final DeserializationContext ctxt) + throws IOException { return Bytes.fromHexString(p.getValueAsString()); } } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/BytesSerializer.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/BytesSerializer.java index a911448e375..6d5beff0691 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/BytesSerializer.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/BytesSerializer.java @@ -22,7 +22,8 @@ public class BytesSerializer extends JsonSerializer { @Override - public void serialize(Bytes value, JsonGenerator gen, SerializerProvider provider) + public void serialize( + final Bytes value, final JsonGenerator gen, final SerializerProvider provider) throws IOException { gen.writeString(value.toHexString().toLowerCase(Locale.ROOT)); } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/UInt256AsHexDeserializer.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/UInt256AsHexDeserializer.java index e030eeb4e66..a41bac0ba71 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/UInt256AsHexDeserializer.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/UInt256AsHexDeserializer.java @@ -22,7 +22,8 @@ public class UInt256AsHexDeserializer extends JsonDeserializer { @Override - public UInt256 deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { + public UInt256 deserialize(final JsonParser p, final DeserializationContext ctxt) + throws IOException { final String hexValue = p.getValueAsString(); QuantityChecker.check(hexValue); return UInt256.fromHexString(hexValue); diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/UInt256AsHexSerializer.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/UInt256AsHexSerializer.java index efb076b66fd..40ff68176f0 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/UInt256AsHexSerializer.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/UInt256AsHexSerializer.java @@ -21,7 +21,8 @@ public class UInt256AsHexSerializer extends JsonSerializer { @Override - public void serialize(UInt256 value, JsonGenerator gen, SerializerProvider serializers) + public void serialize( + final UInt256 value, final JsonGenerator gen, final SerializerProvider serializers) throws IOException { gen.writeString(value.toMinimalBytes().toQuantityHexString()); } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/UInt64AsHexDeserializer.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/UInt64AsHexDeserializer.java index 33c854e5698..b8fa45c8ea2 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/UInt64AsHexDeserializer.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/UInt64AsHexDeserializer.java @@ -22,7 +22,8 @@ public class UInt64AsHexDeserializer extends JsonDeserializer { @Override - public UInt64 deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { + public UInt64 deserialize(final JsonParser p, final DeserializationContext ctxt) + throws IOException { final String hexValue = p.getValueAsString(); QuantityChecker.check(hexValue); return UInt64.valueOf(Bytes.fromHexStringLenient(hexValue).toUnsignedBigInteger()); diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/UInt64AsHexSerializer.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/UInt64AsHexSerializer.java index 6162a81bff5..ff6c11185d5 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/UInt64AsHexSerializer.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/serialization/UInt64AsHexSerializer.java @@ -22,12 +22,13 @@ public class UInt64AsHexSerializer extends JsonSerializer { @Override - public void serialize(UInt64 value, JsonGenerator gen, SerializerProvider serializers) + public void serialize( + final UInt64 value, final JsonGenerator gen, final SerializerProvider serializers) throws IOException { gen.writeString(toHexString(value)); } - public static String toHexString(UInt64 value) { + public static String toHexString(final UInt64 value) { return Bytes.ofUnsignedLong(value.longValue()).toQuantityHexString(); } } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/web3j/DefaultExecutionWeb3jClientProvider.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/web3j/DefaultExecutionWeb3jClientProvider.java index b414b3756a9..dd3465735b6 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/web3j/DefaultExecutionWeb3jClientProvider.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/web3j/DefaultExecutionWeb3jClientProvider.java @@ -58,7 +58,8 @@ private synchronized void buildClient() { .jwtConfigOpt(jwtConfig) .timeProvider(timeProvider) .executionClientEventsPublisher(executionClientEventsPublisher) - .nonCriticalMethods("engine_exchangeCapabilities", "engine_getClientVersionV1") + .nonCriticalMethods( + "engine_exchangeCapabilities", "engine_getClientVersionV1", "engine_getBlobsV1") .build(); this.alreadyBuilt = true; } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/web3j/JsonRpcErrorCodes.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/web3j/JsonRpcErrorCodes.java new file mode 100644 index 00000000000..d83f6429dfe --- /dev/null +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/web3j/JsonRpcErrorCodes.java @@ -0,0 +1,61 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.ethereum.executionclient.web3j; + +import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap; + +enum JsonRpcErrorCodes { + PARSE_ERROR(-32700, "Parse error"), + INVALID_REQUEST(-32600, "Invalid Request"), + METHOD_NOT_FOUND(-32601, "Method not found"), + INVALID_PARAMS(-32602, "Invalid params"), + INTERNAL_ERROR(-32603, "Internal error"), + SERVER_ERROR(-32000, "Server error"); + + private final int errorCode; + private final String description; + private static final Int2ObjectOpenHashMap CODE_TO_ERROR_MAP; + + static { + CODE_TO_ERROR_MAP = new Int2ObjectOpenHashMap<>(); + for (final JsonRpcErrorCodes error : values()) { + CODE_TO_ERROR_MAP.put(error.getErrorCode(), error); + } + } + + JsonRpcErrorCodes(final int errorCode, final String description) { + this.errorCode = errorCode; + this.description = description; + } + + public int getErrorCode() { + return errorCode; + } + + public String getDescription() { + return description; + } + + public static String getDescription(final int errorCode) { + return fromCode(errorCode).getDescription(); + } + + public static JsonRpcErrorCodes fromCode(final int errorCode) { + final JsonRpcErrorCodes error = CODE_TO_ERROR_MAP.get(errorCode); + if (error != null) { + return error; + } + return errorCode >= -32099 && errorCode <= -32000 ? SERVER_ERROR : INTERNAL_ERROR; + } +} diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/web3j/Web3JClient.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/web3j/Web3JClient.java index dd2cf18775d..c1bcc331e29 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/web3j/Web3JClient.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/web3j/Web3JClient.java @@ -15,7 +15,6 @@ import static tech.pegasys.teku.infrastructure.exceptions.ExceptionUtil.getMessageOrSimpleName; -import java.io.IOException; import java.net.ConnectException; import java.time.Duration; import java.util.Collection; @@ -77,7 +76,7 @@ private void throwIfNotInitialized() { } public SafeFuture> doRequest( - Request> web3jRequest, + final Request> web3jRequest, final Duration timeout) { throwIfNotInitialized(); return SafeFuture.of(web3jRequest.sendAsync()) @@ -86,14 +85,9 @@ public SafeFuture> doRequest( (response, exception) -> { final boolean isCriticalRequest = isCriticalRequest(web3jRequest); if (exception != null) { - final boolean couldBeAuthError = isAuthenticationException(exception); - handleError(isCriticalRequest, exception, couldBeAuthError); - return Response.withErrorMessage(getMessageOrSimpleName(exception)); + return handleException(exception, isCriticalRequest); } else if (response.hasError()) { - final String errorMessage = - response.getError().getCode() + ": " + response.getError().getMessage(); - handleError(isCriticalRequest, new IOException(errorMessage), false); - return Response.withErrorMessage(errorMessage); + return handleJsonRpcError(response.getError(), isCriticalRequest); } else { handleSuccess(isCriticalRequest); return new Response<>(response.getResult()); @@ -101,7 +95,32 @@ public SafeFuture> doRequest( }); } - private boolean isCriticalRequest(Request request) { + private Response handleException( + final Throwable exception, final boolean isCriticalRequest) { + final boolean couldBeAuthError = isAuthenticationException(exception); + handleError(isCriticalRequest, exception, couldBeAuthError); + return Response.withErrorMessage(getMessageOrSimpleName(exception)); + } + + private Response handleJsonRpcError( + final org.web3j.protocol.core.Response.Error error, final boolean isCriticalRequest) { + final int errorCode = error.getCode(); + final String errorType = JsonRpcErrorCodes.getDescription(errorCode); + final String formattedError = + String.format("JSON-RPC error: %s (%d): %s", errorType, errorCode, error.getMessage()); + + if (isCriticalRequest) { + logError(formattedError); + } + + return Response.withErrorMessage(formattedError); + } + + private void logError(final String errorMessage) { + eventLog.executionClientRequestFailed(new Exception(errorMessage), false); + } + + private boolean isCriticalRequest(final Request request) { return !nonCriticalMethods.contains(request.getMethod()); } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/web3j/Web3JExecutionEngineClient.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/web3j/Web3JExecutionEngineClient.java index 633cf0c55a6..d029d8e4dfc 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/web3j/Web3JExecutionEngineClient.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/web3j/Web3JExecutionEngineClient.java @@ -21,12 +21,14 @@ import java.util.Collections; import java.util.List; import java.util.Optional; +import org.apache.tuweni.bytes.Bytes; import org.apache.tuweni.bytes.Bytes32; import org.apache.tuweni.units.bigints.UInt256; import org.web3j.protocol.core.DefaultBlockParameterName; import org.web3j.protocol.core.Request; import org.web3j.protocol.core.methods.response.EthBlock; import tech.pegasys.teku.ethereum.executionclient.ExecutionEngineClient; +import tech.pegasys.teku.ethereum.executionclient.schema.BlobAndProofV1; import tech.pegasys.teku.ethereum.executionclient.schema.ClientVersionV1; import tech.pegasys.teku.ethereum.executionclient.schema.ExecutionPayloadV1; import tech.pegasys.teku.ethereum.executionclient.schema.ExecutionPayloadV2; @@ -35,9 +37,11 @@ import tech.pegasys.teku.ethereum.executionclient.schema.ForkChoiceUpdatedResult; import tech.pegasys.teku.ethereum.executionclient.schema.GetPayloadV2Response; import tech.pegasys.teku.ethereum.executionclient.schema.GetPayloadV3Response; +import tech.pegasys.teku.ethereum.executionclient.schema.GetPayloadV4Response; import tech.pegasys.teku.ethereum.executionclient.schema.PayloadAttributesV1; import tech.pegasys.teku.ethereum.executionclient.schema.PayloadAttributesV2; import tech.pegasys.teku.ethereum.executionclient.schema.PayloadAttributesV3; +import tech.pegasys.teku.ethereum.executionclient.schema.PayloadAttributesV4; import tech.pegasys.teku.ethereum.executionclient.schema.PayloadStatusV1; import tech.pegasys.teku.ethereum.executionclient.schema.Response; import tech.pegasys.teku.infrastructure.async.SafeFuture; @@ -50,6 +54,7 @@ public class Web3JExecutionEngineClient implements ExecutionEngineClient { private static final Duration EXCHANGE_CAPABILITIES_TIMEOUT = Duration.ofSeconds(1); private static final Duration GET_CLIENT_VERSION_TIMEOUT = Duration.ofSeconds(1); + private static final Duration GET_BLOBS_TIMEOUT = Duration.ofSeconds(1); private final Web3JClient web3JClient; @@ -58,7 +63,7 @@ public Web3JExecutionEngineClient(final Web3JClient web3JClient) { } @Override - public SafeFuture getPowBlock(Bytes32 blockHash) { + public SafeFuture getPowBlock(final Bytes32 blockHash) { return web3JClient .doRequest( web3JClient.getEth1Web3j().ethGetBlockByHash(blockHash.toHexString(), false), @@ -77,7 +82,7 @@ public SafeFuture getPowChainHead() { .thenApply(Web3JExecutionEngineClient::eth1BlockToPowBlock); } - private static PowBlock eth1BlockToPowBlock(EthBlock.Block eth1Block) { + private static PowBlock eth1BlockToPowBlock(final EthBlock.Block eth1Block) { return eth1Block == null ? null : new PowBlock( @@ -88,7 +93,7 @@ private static PowBlock eth1BlockToPowBlock(EthBlock.Block eth1Block) { } @Override - public SafeFuture> getPayloadV1(Bytes8 payloadId) { + public SafeFuture> getPayloadV1(final Bytes8 payloadId) { final Request web3jRequest = new Request<>( "engine_getPayloadV1", @@ -121,7 +126,19 @@ public SafeFuture> getPayloadV3(final Bytes8 payl } @Override - public SafeFuture> newPayloadV1(ExecutionPayloadV1 executionPayload) { + public SafeFuture> getPayloadV4(final Bytes8 payloadId) { + final Request web3jRequest = + new Request<>( + "engine_getPayloadV4", + Collections.singletonList(payloadId.toHexString()), + web3JClient.getWeb3jService(), + GetPayloadV4Web3jResponse.class); + return web3JClient.doRequest(web3jRequest, EL_ENGINE_NON_BLOCK_EXECUTION_TIMEOUT); + } + + @Override + public SafeFuture> newPayloadV1( + final ExecutionPayloadV1 executionPayload) { final Request web3jRequest = new Request<>( "engine_newPayloadV1", @@ -160,9 +177,33 @@ public SafeFuture> newPayloadV3( return web3JClient.doRequest(web3jRequest, EL_ENGINE_BLOCK_EXECUTION_TIMEOUT); } + @Override + public SafeFuture> newPayloadV4( + final ExecutionPayloadV3 executionPayload, + final List blobVersionedHashes, + final Bytes32 parentBeaconBlockRoot, + final List executionRequests) { + final List expectedBlobVersionedHashes = + blobVersionedHashes.stream().map(VersionedHash::toHexString).toList(); + final List executionRequestsHexList = + executionRequests.stream().map(Bytes::toHexString).toList(); + final Request web3jRequest = + new Request<>( + "engine_newPayloadV4", + list( + executionPayload, + expectedBlobVersionedHashes, + parentBeaconBlockRoot.toHexString(), + executionRequestsHexList), + web3JClient.getWeb3jService(), + PayloadStatusV1Web3jResponse.class); + return web3JClient.doRequest(web3jRequest, EL_ENGINE_BLOCK_EXECUTION_TIMEOUT); + } + @Override public SafeFuture> forkChoiceUpdatedV1( - ForkChoiceStateV1 forkChoiceState, Optional payloadAttributes) { + final ForkChoiceStateV1 forkChoiceState, + final Optional payloadAttributes) { final Request web3jRequest = new Request<>( "engine_forkchoiceUpdatedV1", @@ -198,6 +239,19 @@ public SafeFuture> forkChoiceUpdatedV3( return web3JClient.doRequest(web3jRequest, EL_ENGINE_BLOCK_EXECUTION_TIMEOUT); } + @Override + public SafeFuture> forkChoiceUpdatedV4( + final ForkChoiceStateV1 forkChoiceState, + final Optional payloadAttributes) { + final Request web3jRequest = + new Request<>( + "engine_forkchoiceUpdatedV4", + list(forkChoiceState, payloadAttributes.orElse(null)), + web3JClient.getWeb3jService(), + ForkChoiceUpdatedResultWeb3jResponse.class); + return web3JClient.doRequest(web3jRequest, EL_ENGINE_BLOCK_EXECUTION_TIMEOUT); + } + @Override public SafeFuture>> exchangeCapabilities(final List capabilities) { final Request web3jRequest = @@ -221,6 +275,20 @@ public SafeFuture>> getClientVersionV1( return web3JClient.doRequest(web3jRequest, GET_CLIENT_VERSION_TIMEOUT); } + @Override + public SafeFuture>> getBlobsV1( + final List blobVersionedHashes) { + final List expectedBlobVersionedHashes = + blobVersionedHashes.stream().map(VersionedHash::toHexString).toList(); + final Request web3jRequest = + new Request<>( + "engine_getBlobsV1", + list(expectedBlobVersionedHashes), + web3JClient.getWeb3jService(), + GetBlobsVersionV1Web3jResponse.class); + return web3JClient.doRequest(web3jRequest, GET_BLOBS_TIMEOUT); + } + static class ExecutionPayloadV1Web3jResponse extends org.web3j.protocol.core.Response {} @@ -230,6 +298,9 @@ static class GetPayloadV2Web3jResponse static class GetPayloadV3Web3jResponse extends org.web3j.protocol.core.Response {} + static class GetPayloadV4Web3jResponse + extends org.web3j.protocol.core.Response {} + static class PayloadStatusV1Web3jResponse extends org.web3j.protocol.core.Response {} @@ -242,6 +313,9 @@ static class ExchangeCapabilitiesWeb3jResponse static class GetClientVersionV1Web3jResponse extends org.web3j.protocol.core.Response> {} + static class GetBlobsVersionV1Web3jResponse + extends org.web3j.protocol.core.Response> {} + /** * Returns a list that supports null items. * diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/web3j/Web3jClientBuilder.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/web3j/Web3jClientBuilder.java index 4e276dabe4a..0560ff6af28 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/web3j/Web3jClientBuilder.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/web3j/Web3jClientBuilder.java @@ -37,12 +37,12 @@ public class Web3jClientBuilder { private ExecutionClientEventsChannel executionClientEventsPublisher; private final Collection nonCriticalMethods = new HashSet<>(); - public Web3jClientBuilder endpoint(String endpoint) { + public Web3jClientBuilder endpoint(final String endpoint) { this.endpoint = parseEndpoint(endpoint); return this; } - public Web3jClientBuilder timeout(Duration timeout) { + public Web3jClientBuilder timeout(final Duration timeout) { this.timeout = timeout; return this; } @@ -58,12 +58,12 @@ private URI parseEndpoint(final String endpoint) { return endpointUri; } - public Web3jClientBuilder jwtConfigOpt(Optional jwtConfig) { + public Web3jClientBuilder jwtConfigOpt(final Optional jwtConfig) { this.jwtConfigOpt = jwtConfig; return this; } - public Web3jClientBuilder timeProvider(TimeProvider timeProvider) { + public Web3jClientBuilder timeProvider(final TimeProvider timeProvider) { this.timeProvider = timeProvider; return this; } @@ -74,7 +74,7 @@ public Web3jClientBuilder executionClientEventsPublisher( return this; } - public Web3jClientBuilder nonCriticalMethods(String... methods) { + public Web3jClientBuilder nonCriticalMethods(final String... methods) { nonCriticalMethods.addAll(Arrays.asList(methods)); return this; } @@ -86,28 +86,31 @@ public Web3JClient build() { checkNotNull(timeout); requireNonNull(endpoint.getScheme(), () -> prepareInvalidSchemeMessage(endpoint)); return switch (endpoint.getScheme()) { - case "http", "https" -> new Web3jHttpClient( - EVENT_LOG, - endpoint, - timeProvider, - timeout, - jwtConfigOpt, - executionClientEventsPublisher, - nonCriticalMethods); - case "ws", "wss" -> new Web3jWebsocketClient( - EVENT_LOG, - endpoint, - timeProvider, - jwtConfigOpt, - executionClientEventsPublisher, - nonCriticalMethods); - case "file" -> new Web3jIpcClient( - EVENT_LOG, - endpoint, - timeProvider, - jwtConfigOpt, - executionClientEventsPublisher, - nonCriticalMethods); + case "http", "https" -> + new Web3jHttpClient( + EVENT_LOG, + endpoint, + timeProvider, + timeout, + jwtConfigOpt, + executionClientEventsPublisher, + nonCriticalMethods); + case "ws", "wss" -> + new Web3jWebsocketClient( + EVENT_LOG, + endpoint, + timeProvider, + jwtConfigOpt, + executionClientEventsPublisher, + nonCriticalMethods); + case "file" -> + new Web3jIpcClient( + EVENT_LOG, + endpoint, + timeProvider, + jwtConfigOpt, + executionClientEventsPublisher, + nonCriticalMethods); default -> throw new InvalidConfigurationException(prepareInvalidSchemeMessage(endpoint)); }; } diff --git a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/web3j/Web3jWebsocketClient.java b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/web3j/Web3jWebsocketClient.java index e2bc682cf12..2285cce0c1c 100644 --- a/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/web3j/Web3jWebsocketClient.java +++ b/ethereum/executionclient/src/main/java/tech/pegasys/teku/ethereum/executionclient/web3j/Web3jWebsocketClient.java @@ -76,7 +76,7 @@ private Optional tryToConnect() { @Override public SafeFuture> doRequest( - Request> web3jRequest, + final Request> web3jRequest, final Duration timeout) { return tryToConnect() .>>map(SafeFuture::failedFuture) diff --git a/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/ExecutionClientVersionProviderTest.java b/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/ExecutionClientVersionProviderTest.java index 19cc20c2dc8..ce2cd36820e 100644 --- a/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/ExecutionClientVersionProviderTest.java +++ b/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/ExecutionClientVersionProviderTest.java @@ -19,6 +19,7 @@ import static org.mockito.Mockito.reset; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.when; import java.util.List; @@ -34,6 +35,9 @@ public class ExecutionClientVersionProviderTest { private final ExecutionLayerChannel executionLayerChannel = mock(ExecutionLayerChannel.class); private final ExecutionClientVersionChannel publishChannel = mock(ExecutionClientVersionChannel.class); + private final ClientVersion consensusClientVersion = + new ClientVersion( + ClientVersion.TEKU_CLIENT_CODE, "teku", "1.0.0", Bytes4.fromHexString("8ddce8bb")); private final ClientVersion executionClientVersion = new ClientVersion("BU", "besu", "1.0.0", Bytes4.fromHexString("8dba2981")); @@ -44,24 +48,27 @@ public void setUp() { } @Test - public void pushUnknownExecutionClientVersionInChannel_whenFailed() { + public void doesNotPushExecutionClientVersionInChannel_whenFailed() { when(executionLayerChannel.engineGetClientVersion(any())) .thenReturn(SafeFuture.failedFuture(new IllegalStateException("oopsy"))); new ExecutionClientVersionProvider( - executionLayerChannel, publishChannel, ClientVersion.UNKNOWN); - verify(publishChannel).onExecutionClientVersion(ClientVersion.UNKNOWN); + executionLayerChannel, publishChannel, consensusClientVersion); + + // only called once (on initialization) + verify(publishChannel).onExecutionClientVersionNotAvailable(); + verifyNoMoreInteractions(publishChannel); } @Test public void doesNotTryToUpdateExecutionClientVersion_whenElHasNotBeenUnavailable() { final ExecutionClientVersionProvider executionClientVersionProvider = new ExecutionClientVersionProvider( - executionLayerChannel, publishChannel, ClientVersion.UNKNOWN); + executionLayerChannel, publishChannel, consensusClientVersion); executionClientVersionProvider.onAvailabilityUpdated(true); // EL called only one time - verify(executionLayerChannel).engineGetClientVersion(any()); + verify(executionLayerChannel).engineGetClientVersion(consensusClientVersion); verify(publishChannel).onExecutionClientVersion(executionClientVersion); } @@ -69,7 +76,7 @@ public void doesNotTryToUpdateExecutionClientVersion_whenElHasNotBeenUnavailable public void updatesExecutionClientVersion_whenElIsAvailableAfterBeingUnavailable() { final ExecutionClientVersionProvider executionClientVersionProvider = new ExecutionClientVersionProvider( - executionLayerChannel, publishChannel, ClientVersion.UNKNOWN); + executionLayerChannel, publishChannel, consensusClientVersion); verify(publishChannel).onExecutionClientVersion(executionClientVersion); @@ -81,7 +88,7 @@ public void updatesExecutionClientVersion_whenElIsAvailableAfterBeingUnavailable executionClientVersionProvider.onAvailabilityUpdated(false); executionClientVersionProvider.onAvailabilityUpdated(true); // EL called two times - verify(executionLayerChannel, times(2)).engineGetClientVersion(any()); + verify(executionLayerChannel, times(2)).engineGetClientVersion(consensusClientVersion); verify(publishChannel).onExecutionClientVersion(updatedExecutionClientVersion); @@ -89,7 +96,7 @@ public void updatesExecutionClientVersion_whenElIsAvailableAfterBeingUnavailable executionClientVersionProvider.onAvailabilityUpdated(true); // EL called three times - verify(executionLayerChannel, times(3)).engineGetClientVersion(any()); + verify(executionLayerChannel, times(3)).engineGetClientVersion(consensusClientVersion); // 1st time - executionClientVersion, 2nd time - updatedExecutionClientVersion, 3rd time - // ignoring the same @@ -97,10 +104,10 @@ public void updatesExecutionClientVersion_whenElIsAvailableAfterBeingUnavailable } @Test - public void doesNotPushUnknownVersionInChannel_whenELIsDownInTheMiddle() { + public void doesNotPushExecutionClientVersionInChannel_whenELIsDownInTheMiddle() { final ExecutionClientVersionProvider executionClientVersionProvider = new ExecutionClientVersionProvider( - executionLayerChannel, publishChannel, ClientVersion.UNKNOWN); + executionLayerChannel, publishChannel, consensusClientVersion); // Good start verify(publishChannel).onExecutionClientVersion(executionClientVersion); @@ -113,9 +120,11 @@ public void doesNotPushUnknownVersionInChannel_whenELIsDownInTheMiddle() { executionClientVersionProvider.onAvailabilityUpdated(false); executionClientVersionProvider.onAvailabilityUpdated(true); // EL called two times - verify(executionLayerChannel, times(2)).engineGetClientVersion(any()); - // UNKNOWN version is not pushed in the channel + verify(executionLayerChannel, times(2)).engineGetClientVersion(consensusClientVersion); + // no version is pushed in the channel verify(publishChannel, never()).onExecutionClientVersion(any()); + // non-availability has not been called if EL has been available on initialization + verify(publishChannel, never()).onExecutionClientVersionNotAvailable(); // EL is back when(executionLayerChannel.engineGetClientVersion(any())) @@ -124,7 +133,7 @@ public void doesNotPushUnknownVersionInChannel_whenELIsDownInTheMiddle() { executionClientVersionProvider.onAvailabilityUpdated(false); executionClientVersionProvider.onAvailabilityUpdated(true); // EL called 3 times - verify(executionLayerChannel, times(3)).engineGetClientVersion(any()); + verify(executionLayerChannel, times(3)).engineGetClientVersion(consensusClientVersion); // Version is the same, not pushed in the channel verify(publishChannel, never()).onExecutionClientVersion(any()); } diff --git a/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/SchemaSerializationTests.java b/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/SchemaSerializationTests.java index 87f72a88912..8de202173c1 100644 --- a/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/SchemaSerializationTests.java +++ b/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/SchemaSerializationTests.java @@ -67,7 +67,7 @@ public class SchemaSerializationTests { DataStructureUtil dataStructureUtil; @BeforeEach - void setUp(SpecContext specContext) throws IOException { + void setUp(final SpecContext specContext) throws IOException { jsonWriter = new StringWriter(); jsonGenerator = new JsonFactory().createGenerator(jsonWriter); objectMapper = new ObjectMapper(); @@ -216,7 +216,8 @@ void shouldDeserializingUInt64Quantity0x0() throws IOException { deserializer.deserialize(parser, objectMapper.getDeserializationContext()); } - private JsonParser prepareDeserializationContext(String serializedValue) throws IOException { + private JsonParser prepareDeserializationContext(final String serializedValue) + throws IOException { String json = String.format("{\"value\":%s}", serializedValue); JsonParser parser = objectMapper.getFactory().createParser(json); parser.nextToken(); @@ -448,16 +449,16 @@ void shouldSerializePayloadAttributes() throws IOException { } private ForkChoiceUpdatedResult createExternalForkChoiceUpdatedResult( - ExecutionPayloadStatus status, Bytes32 latestValidHash, Bytes8 payloadId) { + final ExecutionPayloadStatus status, final Bytes32 latestValidHash, final Bytes8 payloadId) { return new ForkChoiceUpdatedResult( new PayloadStatusV1(status, latestValidHash, null), payloadId); } private tech.pegasys.teku.spec.executionlayer.ForkChoiceUpdatedResult createInternalForkChoiceUpdatedResult( - ExecutionPayloadStatus status, - Optional latestValidHash, - Optional payloadId) { + final ExecutionPayloadStatus status, + final Optional latestValidHash, + final Optional payloadId) { return new tech.pegasys.teku.spec.executionlayer.ForkChoiceUpdatedResult( PayloadStatus.create(status, latestValidHash, Optional.empty()), payloadId); } diff --git a/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineForkChoiceUpdatedV4Test.java b/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineForkChoiceUpdatedV4Test.java new file mode 100644 index 00000000000..e666b69bb31 --- /dev/null +++ b/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineForkChoiceUpdatedV4Test.java @@ -0,0 +1,149 @@ +/* + * Copyright Consensys Software Inc., 2023 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.ethereum.executionclient.methods; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoInteractions; +import static org.mockito.Mockito.when; + +import java.util.Optional; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.ethereum.executionclient.ExecutionEngineClient; +import tech.pegasys.teku.ethereum.executionclient.response.InvalidRemoteResponseException; +import tech.pegasys.teku.ethereum.executionclient.schema.ForkChoiceStateV1; +import tech.pegasys.teku.ethereum.executionclient.schema.ForkChoiceUpdatedResult; +import tech.pegasys.teku.ethereum.executionclient.schema.PayloadAttributesV4; +import tech.pegasys.teku.ethereum.executionclient.schema.PayloadStatusV1; +import tech.pegasys.teku.ethereum.executionclient.schema.Response; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.executionlayer.ExecutionPayloadStatus; +import tech.pegasys.teku.spec.executionlayer.ForkChoiceState; +import tech.pegasys.teku.spec.executionlayer.PayloadBuildingAttributes; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +class EngineForkChoiceUpdatedV4Test { + + private final Spec spec = TestSpecFactory.createMinimalDeneb(); + private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); + private final ExecutionEngineClient executionEngineClient = mock(ExecutionEngineClient.class); + private EngineForkChoiceUpdatedV4 jsonRpcMethod; + + @BeforeEach + public void setUp() { + jsonRpcMethod = new EngineForkChoiceUpdatedV4(executionEngineClient); + } + + @Test + public void shouldReturnExpectedNameAndVersion() { + assertThat(jsonRpcMethod.getName()).isEqualTo("engine_forkchoiceUpdated"); + assertThat(jsonRpcMethod.getVersion()).isEqualTo(4); + assertThat(jsonRpcMethod.getVersionedName()).isEqualTo("engine_forkchoiceUpdatedV4"); + } + + @Test + public void forkChoiceStateParamIsRequired() { + final JsonRpcRequestParams params = new JsonRpcRequestParams.Builder().build(); + + assertThatThrownBy(() -> jsonRpcMethod.execute(params)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("Missing required parameter at index 0"); + + verifyNoInteractions(executionEngineClient); + } + + @Test + public void payloadBuildingAttributesParamIsOptional() { + final ForkChoiceState forkChoiceState = dataStructureUtil.randomForkChoiceState(false); + + when(executionEngineClient.forkChoiceUpdatedV4(any(), eq(Optional.empty()))) + .thenReturn(dummySuccessfulResponse()); + + final JsonRpcRequestParams params = + new JsonRpcRequestParams.Builder().add(forkChoiceState).build(); + + assertThat(jsonRpcMethod.execute(params)).isCompleted(); + + verify(executionEngineClient).forkChoiceUpdatedV4(any(), eq(Optional.empty())); + } + + @Test + public void shouldReturnFailedFutureWithMessageWhenEngineClientRequestFails() { + final ForkChoiceState forkChoiceState = dataStructureUtil.randomForkChoiceState(false); + final String errorResponseFromClient = "error!"; + + when(executionEngineClient.forkChoiceUpdatedV4(any(), any())) + .thenReturn(dummyFailedResponse(errorResponseFromClient)); + + final JsonRpcRequestParams params = + new JsonRpcRequestParams.Builder().add(forkChoiceState).build(); + + assertThat(jsonRpcMethod.execute(params)) + .failsWithin(1, TimeUnit.SECONDS) + .withThrowableOfType(ExecutionException.class) + .withRootCauseInstanceOf(InvalidRemoteResponseException.class) + .withMessageContaining( + "Invalid remote response from the execution client: %s", errorResponseFromClient); + } + + @Test + public void shouldCallForkChoiceUpdateV4WithPayloadAttributesV4WhenInElectra() { + final ForkChoiceState forkChoiceState = dataStructureUtil.randomForkChoiceState(false); + final PayloadBuildingAttributes payloadBuildingAttributes = + dataStructureUtil.randomPayloadBuildingAttributes(false); + final ForkChoiceStateV1 forkChoiceStateV1 = + ForkChoiceStateV1.fromInternalForkChoiceState(forkChoiceState); + final Optional payloadAttributesV4 = + PayloadAttributesV4.fromInternalPayloadBuildingAttributesV4( + Optional.of(payloadBuildingAttributes)); + + jsonRpcMethod = new EngineForkChoiceUpdatedV4(executionEngineClient); + + when(executionEngineClient.forkChoiceUpdatedV4(forkChoiceStateV1, payloadAttributesV4)) + .thenReturn(dummySuccessfulResponse()); + + final JsonRpcRequestParams params = + new JsonRpcRequestParams.Builder() + .add(forkChoiceState) + .add(payloadBuildingAttributes) + .build(); + + assertThat(jsonRpcMethod.execute(params)).isCompleted(); + + verify(executionEngineClient).forkChoiceUpdatedV4(forkChoiceStateV1, payloadAttributesV4); + } + + private SafeFuture> dummySuccessfulResponse() { + return SafeFuture.completedFuture( + new Response<>( + new ForkChoiceUpdatedResult( + new PayloadStatusV1( + ExecutionPayloadStatus.ACCEPTED, dataStructureUtil.randomBytes32(), ""), + dataStructureUtil.randomBytes8()))); + } + + private SafeFuture> dummyFailedResponse( + final String errorMessage) { + return SafeFuture.completedFuture(Response.withErrorMessage(errorMessage)); + } +} diff --git a/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineGetBlobsV1Test.java b/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineGetBlobsV1Test.java new file mode 100644 index 00000000000..6501e6a2aaa --- /dev/null +++ b/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineGetBlobsV1Test.java @@ -0,0 +1,151 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.ethereum.executionclient.methods; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoInteractions; +import static org.mockito.Mockito.verifyNoMoreInteractions; +import static org.mockito.Mockito.when; + +import java.util.List; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.ethereum.executionclient.ExecutionEngineClient; +import tech.pegasys.teku.ethereum.executionclient.response.InvalidRemoteResponseException; +import tech.pegasys.teku.ethereum.executionclient.schema.BlobAndProofV1; +import tech.pegasys.teku.ethereum.executionclient.schema.Response; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.config.SpecConfigDeneb; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; +import tech.pegasys.teku.spec.datastructures.execution.BlobAndProof; +import tech.pegasys.teku.spec.logic.versions.deneb.types.VersionedHash; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +public class EngineGetBlobsV1Test { + + private final Spec spec = TestSpecFactory.createMinimalElectra(); + private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); + private final ExecutionEngineClient executionEngineClient = mock(ExecutionEngineClient.class); + private EngineGetBlobsV1 jsonRpcMethod; + + @BeforeEach + public void setUp() { + jsonRpcMethod = new EngineGetBlobsV1(executionEngineClient, spec); + } + + @Test + public void shouldReturnExpectedNameAndVersion() { + assertThat(jsonRpcMethod.getName()).isEqualTo("engine_getBlobs"); + assertThat(jsonRpcMethod.isOptional()).isTrue(); + assertThat(jsonRpcMethod.getVersion()).isEqualTo(1); + assertThat(jsonRpcMethod.getVersionedName()).isEqualTo("engine_getBlobsV1"); + } + + @Test + public void blobVersionedHashesParamIsRequired() { + final JsonRpcRequestParams params = new JsonRpcRequestParams.Builder().build(); + + assertThatThrownBy(() -> jsonRpcMethod.execute(params)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("Missing required parameter at index 0"); + + verifyNoInteractions(executionEngineClient); + } + + @Test + public void slotParamIsRequired() { + final List versionedHashes = dataStructureUtil.randomVersionedHashes(4); + + final JsonRpcRequestParams params = + new JsonRpcRequestParams.Builder().add(versionedHashes).build(); + + assertThatThrownBy(() -> jsonRpcMethod.execute(params)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("Missing required parameter at index 1"); + + verifyNoInteractions(executionEngineClient); + } + + @Test + public void shouldReturnFailedExecutionWhenEngineClientRequestFails() { + final List versionedHashes = dataStructureUtil.randomVersionedHashes(4); + final String errorResponseFromClient = "error!"; + + when(executionEngineClient.getBlobsV1(any())) + .thenReturn(dummyFailedResponse(errorResponseFromClient)); + + final JsonRpcRequestParams params = + new JsonRpcRequestParams.Builder().add(versionedHashes).add(UInt64.ZERO).build(); + + assertThat(jsonRpcMethod.execute(params)) + .failsWithin(1, TimeUnit.SECONDS) + .withThrowableOfType(ExecutionException.class) + .withRootCauseInstanceOf(InvalidRemoteResponseException.class) + .withMessageContaining( + "Invalid remote response from the execution client: %s", errorResponseFromClient); + } + + @Test + public void shouldCallGetBlobsV1AndParseResponseSuccessfully() { + final List versionedHashes = dataStructureUtil.randomVersionedHashes(4); + final List blobSidecars = + dataStructureUtil.randomBlobSidecars( + SpecConfigDeneb.required(spec.getGenesisSpecConfig()).getMaxBlobsPerBlock()); + + when(executionEngineClient.getBlobsV1(eq(versionedHashes))) + .thenReturn(dummySuccessfulResponse(blobSidecars)); + + final JsonRpcRequestParams params = + new JsonRpcRequestParams.Builder().add(versionedHashes).add(UInt64.ZERO).build(); + + jsonRpcMethod = new EngineGetBlobsV1(executionEngineClient, spec); + + final List expectedResponse = + blobSidecars.stream() + .map(blobSidecar -> new BlobAndProof(blobSidecar.getBlob(), blobSidecar.getKZGProof())) + .toList(); + assertThat(jsonRpcMethod.execute(params)).isCompletedWithValue(expectedResponse); + + verify(executionEngineClient).getBlobsV1(eq(versionedHashes)); + verifyNoMoreInteractions(executionEngineClient); + } + + private SafeFuture>> dummySuccessfulResponse( + final List blobSidecars) { + return SafeFuture.completedFuture( + new Response<>( + blobSidecars.stream() + .map( + blobSidecar -> + new BlobAndProofV1( + blobSidecar.getBlob().getBytes(), + blobSidecar.getKZGProof().getBytesCompressed())) + .toList())); + } + + private SafeFuture>> dummyFailedResponse( + final String errorMessage) { + return SafeFuture.completedFuture(Response.withErrorMessage(errorMessage)); + } +} diff --git a/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineGetPayloadV4Test.java b/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineGetPayloadV4Test.java new file mode 100644 index 00000000000..1d79c160606 --- /dev/null +++ b/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineGetPayloadV4Test.java @@ -0,0 +1,174 @@ +/* + * Copyright Consensys Software Inc., 2023 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.ethereum.executionclient.methods; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoInteractions; +import static org.mockito.Mockito.verifyNoMoreInteractions; +import static org.mockito.Mockito.when; + +import java.util.List; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import org.apache.tuweni.bytes.Bytes; +import org.apache.tuweni.units.bigints.UInt256; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.ethereum.executionclient.ExecutionEngineClient; +import tech.pegasys.teku.ethereum.executionclient.response.InvalidRemoteResponseException; +import tech.pegasys.teku.ethereum.executionclient.schema.BlobsBundleV1; +import tech.pegasys.teku.ethereum.executionclient.schema.ExecutionPayloadV3; +import tech.pegasys.teku.ethereum.executionclient.schema.GetPayloadV4Response; +import tech.pegasys.teku.ethereum.executionclient.schema.Response; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.datastructures.execution.BlobsBundle; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadContext; +import tech.pegasys.teku.spec.datastructures.execution.GetPayloadResponse; +import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadDeneb; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsDataCodec; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +class EngineGetPayloadV4Test { + + private final Spec spec = TestSpecFactory.createMinimalElectra(); + private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); + private final ExecutionEngineClient executionEngineClient = mock(ExecutionEngineClient.class); + private final ExecutionRequestsDataCodec executionRequestsDataCodec = + new ExecutionRequestsDataCodec( + SchemaDefinitionsElectra.required( + spec.forMilestone(SpecMilestone.ELECTRA).getSchemaDefinitions()) + .getExecutionRequestsSchema()); + private EngineGetPayloadV4 jsonRpcMethod; + + @BeforeEach + public void setUp() { + jsonRpcMethod = new EngineGetPayloadV4(executionEngineClient, spec); + } + + @Test + public void shouldReturnExpectedNameAndVersion() { + assertThat(jsonRpcMethod.getName()).isEqualTo("engine_getPayload"); + assertThat(jsonRpcMethod.getVersion()).isEqualTo(4); + assertThat(jsonRpcMethod.getVersionedName()).isEqualTo("engine_getPayloadV4"); + } + + @Test + public void executionPayloadContextParamIsRequired() { + final JsonRpcRequestParams params = new JsonRpcRequestParams.Builder().build(); + + assertThatThrownBy(() -> jsonRpcMethod.execute(params)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("Missing required parameter at index 0"); + + verifyNoInteractions(executionEngineClient); + } + + @Test + public void slotParamIsRequired() { + final ExecutionPayloadContext executionPayloadContext = + dataStructureUtil.randomPayloadExecutionContext(false); + + final JsonRpcRequestParams params = + new JsonRpcRequestParams.Builder().add(executionPayloadContext).build(); + + assertThatThrownBy(() -> jsonRpcMethod.execute(params)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("Missing required parameter at index 1"); + + verifyNoInteractions(executionEngineClient); + } + + @Test + public void shouldReturnFailedExecutionWhenEngineClientRequestFails() { + final ExecutionPayloadContext executionPayloadContext = + dataStructureUtil.randomPayloadExecutionContext(false); + final String errorResponseFromClient = "error!"; + + when(executionEngineClient.getPayloadV4(any())) + .thenReturn(dummyFailedResponse(errorResponseFromClient)); + + final JsonRpcRequestParams params = + new JsonRpcRequestParams.Builder().add(executionPayloadContext).add(UInt64.ZERO).build(); + + assertThat(jsonRpcMethod.execute(params)) + .failsWithin(1, TimeUnit.SECONDS) + .withThrowableOfType(ExecutionException.class) + .withRootCauseInstanceOf(InvalidRemoteResponseException.class) + .withMessageContaining( + "Invalid remote response from the execution client: %s", errorResponseFromClient); + } + + @Test + public void shouldCallGetPayloadV4AndParseResponseSuccessfully() { + final ExecutionPayloadContext executionPayloadContext = + dataStructureUtil.randomPayloadExecutionContext(false); + final UInt256 blockValue = UInt256.MAX_VALUE; + final BlobsBundle blobsBundle = dataStructureUtil.randomBlobsBundle(); + final ExecutionPayload executionPayloadElectra = dataStructureUtil.randomExecutionPayload(); + final ExecutionRequests executionRequests = dataStructureUtil.randomExecutionRequests(); + final List encodedExecutionRequests = + executionRequestsDataCodec.encode(executionRequests); + assertThat(executionPayloadElectra).isInstanceOf(ExecutionPayloadDeneb.class); + + when(executionEngineClient.getPayloadV4(eq(executionPayloadContext.getPayloadId()))) + .thenReturn( + dummySuccessfulResponse( + executionPayloadElectra, blockValue, blobsBundle, encodedExecutionRequests)); + + final JsonRpcRequestParams params = + new JsonRpcRequestParams.Builder().add(executionPayloadContext).add(UInt64.ZERO).build(); + + jsonRpcMethod = new EngineGetPayloadV4(executionEngineClient, spec); + + final GetPayloadResponse expectedGetPayloadResponse = + new GetPayloadResponse( + executionPayloadElectra, blockValue, blobsBundle, false, executionRequests); + assertThat(jsonRpcMethod.execute(params)).isCompletedWithValue(expectedGetPayloadResponse); + + verify(executionEngineClient).getPayloadV4(eq(executionPayloadContext.getPayloadId())); + verifyNoMoreInteractions(executionEngineClient); + } + + private SafeFuture> dummySuccessfulResponse( + final ExecutionPayload executionPayload, + final UInt256 blockValue, + final BlobsBundle blobsBundle, + final List encodedExecutionRequests) { + return SafeFuture.completedFuture( + new Response<>( + new GetPayloadV4Response( + ExecutionPayloadV3.fromInternalExecutionPayload(executionPayload), + blockValue, + BlobsBundleV1.fromInternalBlobsBundle(blobsBundle), + false, + encodedExecutionRequests))); + } + + private SafeFuture> dummyFailedResponse( + final String errorMessage) { + return SafeFuture.completedFuture(Response.withErrorMessage(errorMessage)); + } +} diff --git a/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineNewPayloadV4Test.java b/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineNewPayloadV4Test.java new file mode 100644 index 00000000000..9035576e852 --- /dev/null +++ b/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/methods/EngineNewPayloadV4Test.java @@ -0,0 +1,191 @@ +/* + * Copyright Consensys Software Inc., 2023 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.ethereum.executionclient.methods; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoInteractions; +import static org.mockito.Mockito.verifyNoMoreInteractions; +import static org.mockito.Mockito.when; + +import java.util.List; +import java.util.concurrent.TimeUnit; +import org.apache.tuweni.bytes.Bytes; +import org.apache.tuweni.bytes.Bytes32; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.ethereum.executionclient.ExecutionEngineClient; +import tech.pegasys.teku.ethereum.executionclient.schema.ExecutionPayloadV3; +import tech.pegasys.teku.ethereum.executionclient.schema.PayloadStatusV1; +import tech.pegasys.teku.ethereum.executionclient.schema.Response; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; +import tech.pegasys.teku.spec.executionlayer.ExecutionPayloadStatus; +import tech.pegasys.teku.spec.executionlayer.PayloadStatus; +import tech.pegasys.teku.spec.logic.versions.deneb.types.VersionedHash; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +class EngineNewPayloadV4Test { + + private final Spec spec = TestSpecFactory.createMinimalElectra(); + private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); + private final ExecutionEngineClient executionEngineClient = mock(ExecutionEngineClient.class); + private EngineNewPayloadV4 jsonRpcMethod; + + @BeforeEach + public void setUp() { + jsonRpcMethod = new EngineNewPayloadV4(executionEngineClient); + } + + @Test + public void shouldReturnExpectedNameAndVersion() { + assertThat(jsonRpcMethod.getName()).isEqualTo("engine_newPayload"); + assertThat(jsonRpcMethod.getVersion()).isEqualTo(4); + assertThat(jsonRpcMethod.getVersionedName()).isEqualTo("engine_newPayloadV4"); + } + + @Test + public void executionPayloadParamIsRequired() { + final JsonRpcRequestParams params = new JsonRpcRequestParams.Builder().build(); + + assertThatThrownBy(() -> jsonRpcMethod.execute(params)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("Missing required parameter at index 0"); + + verifyNoInteractions(executionEngineClient); + } + + @Test + public void blobVersionedHashesParamIsRequired() { + final JsonRpcRequestParams params = + new JsonRpcRequestParams.Builder().add(dataStructureUtil.randomExecutionPayload()).build(); + + assertThatThrownBy(() -> jsonRpcMethod.execute(params)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("Missing required parameter at index 1"); + + verifyNoInteractions(executionEngineClient); + } + + @Test + public void parentBeaconBlockRootParamIsRequired() { + final JsonRpcRequestParams params = + new JsonRpcRequestParams.Builder() + .add(dataStructureUtil.randomExecutionPayload()) + .add(dataStructureUtil.randomVersionedHashes(3)) + .build(); + + assertThatThrownBy(() -> jsonRpcMethod.execute(params)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("Missing required parameter at index 2"); + + verifyNoInteractions(executionEngineClient); + } + + @Test + public void executionRequestHashParamIsRequired() { + final JsonRpcRequestParams params = + new JsonRpcRequestParams.Builder() + .add(dataStructureUtil.randomExecutionPayload()) + .add(dataStructureUtil.randomVersionedHashes(3)) + .add(dataStructureUtil.randomBytes32()) + .build(); + + assertThatThrownBy(() -> jsonRpcMethod.execute(params)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("Missing required parameter at index 3"); + + verifyNoInteractions(executionEngineClient); + } + + @Test + public void shouldReturnFailedExecutionWhenEngineClientRequestFails() { + final ExecutionPayload executionPayload = dataStructureUtil.randomExecutionPayload(); + final List blobVersionedHashes = dataStructureUtil.randomVersionedHashes(3); + final Bytes32 parentBeaconBlockRoot = dataStructureUtil.randomBytes32(); + final List executionRequests = dataStructureUtil.randomEncodedExecutionRequests(); + final String errorResponseFromClient = "error!"; + + when(executionEngineClient.newPayloadV4(any(), any(), any(), any())) + .thenReturn(dummyFailedResponse(errorResponseFromClient)); + + final JsonRpcRequestParams params = + new JsonRpcRequestParams.Builder() + .add(executionPayload) + .add(blobVersionedHashes) + .add(parentBeaconBlockRoot) + .add(executionRequests) + .build(); + + assertThat(jsonRpcMethod.execute(params)) + .succeedsWithin(1, TimeUnit.SECONDS) + .matches(PayloadStatus::hasFailedExecution); + } + + @Test + public void shouldCallNewPayloadV4WithExecutionPayloadV3AndCorrectParameters() { + final ExecutionPayload executionPayload = dataStructureUtil.randomExecutionPayload(); + final List blobVersionedHashes = dataStructureUtil.randomVersionedHashes(4); + final Bytes32 parentBeaconBlockRoot = dataStructureUtil.randomBytes32(); + final List executionRequests = dataStructureUtil.randomEncodedExecutionRequests(); + + final ExecutionPayloadV3 executionPayloadV3 = + ExecutionPayloadV3.fromInternalExecutionPayload(executionPayload); + assertThat(executionPayloadV3).isExactlyInstanceOf(ExecutionPayloadV3.class); + + jsonRpcMethod = new EngineNewPayloadV4(executionEngineClient); + + when(executionEngineClient.newPayloadV4( + eq(executionPayloadV3), + eq(blobVersionedHashes), + eq(parentBeaconBlockRoot), + eq(executionRequests))) + .thenReturn(dummySuccessfulResponse()); + + final JsonRpcRequestParams params = + new JsonRpcRequestParams.Builder() + .add(executionPayload) + .add(blobVersionedHashes) + .add(parentBeaconBlockRoot) + .add(executionRequests) + .build(); + + assertThat(jsonRpcMethod.execute(params)).isCompleted(); + + verify(executionEngineClient) + .newPayloadV4( + eq(executionPayloadV3), + eq(blobVersionedHashes), + eq(parentBeaconBlockRoot), + eq(executionRequests)); + verifyNoMoreInteractions(executionEngineClient); + } + + private SafeFuture> dummySuccessfulResponse() { + return SafeFuture.completedFuture( + new Response<>( + new PayloadStatusV1( + ExecutionPayloadStatus.ACCEPTED, dataStructureUtil.randomBytes32(), null))); + } + + private SafeFuture> dummyFailedResponse(final String errorMessage) { + return SafeFuture.completedFuture(Response.withErrorMessage(errorMessage)); + } +} diff --git a/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/metrics/MetricRecordingAbstractClientTest.java b/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/metrics/MetricRecordingAbstractClientTest.java index 20beb230d3d..69be696bf65 100644 --- a/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/metrics/MetricRecordingAbstractClientTest.java +++ b/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/metrics/MetricRecordingAbstractClientTest.java @@ -68,7 +68,7 @@ public void shouldCountRequestWithFailedFutureResponse() { @Test public void shouldCountRequestWithResponseFailure() { - final Response response = new Response<>(null, "error"); + final Response response = Response.withErrorMessage("error"); setupResponse(SafeFuture.completedFuture(response)); final SafeFuture> result = clientTest.testMethod("test"); @@ -83,9 +83,9 @@ private static class TestClient extends MetricRecordingAbstractClient { private final TestClient delegate; protected TestClient( - TestClient delegate, - TimeProvider timeProvider, - MetricsCountersByIntervals clientRequestsCountersByIntervals) { + final TestClient delegate, + final TimeProvider timeProvider, + final MetricsCountersByIntervals clientRequestsCountersByIntervals) { super(timeProvider, clientRequestsCountersByIntervals); this.delegate = delegate; } diff --git a/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/rest/RestClientProviderTest.java b/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/rest/RestClientProviderTest.java index c153c0f7fc0..19d6c9e25ab 100644 --- a/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/rest/RestClientProviderTest.java +++ b/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/rest/RestClientProviderTest.java @@ -32,7 +32,7 @@ class RestClientProviderTest { private static final TimeProvider STUB_TIME_PROVIDER = StubTimeProvider.withTimeInSeconds(10); @Test - void createsStubProvider(@TempDir Path tempDir) { + void createsStubProvider(@TempDir final Path tempDir) { RestClientProvider restClientProvider = RestClientProvider.create( ExecutionLayerChannel.STUB_ENDPOINT_PREFIX, @@ -50,7 +50,7 @@ void createsStubProvider(@TempDir Path tempDir) { } @Test - void createsOkHttpRestClientProvider(@TempDir Path tempDir) { + void createsOkHttpRestClientProvider(@TempDir final Path tempDir) { RestClientProvider restClientProvider = RestClientProvider.create( "http://127.0.0.1:28545", diff --git a/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/schema/PayloadAttributesV4Test.java b/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/schema/PayloadAttributesV4Test.java new file mode 100644 index 00000000000..a02d7cd6308 --- /dev/null +++ b/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/schema/PayloadAttributesV4Test.java @@ -0,0 +1,101 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.ethereum.executionclient.schema; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.util.Optional; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.executionlayer.PayloadBuildingAttributes; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +class PayloadAttributesV4Test { + + private final Spec spec = TestSpecFactory.createMinimalElectra(); + private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); + + @Test + public void buildFromInternalPayload_RequiresTargetBlobCount() { + final PayloadBuildingAttributes pbaMissingTargetBlobCount = + new PayloadBuildingAttributes( + dataStructureUtil.randomUInt64(), + dataStructureUtil.randomUInt64(), + dataStructureUtil.randomUInt64(), + dataStructureUtil.randomBytes32(), + dataStructureUtil.randomEth1Address(), + Optional.empty(), + Optional.empty(), + dataStructureUtil.randomBytes32(), + Optional.empty(), + Optional.of(dataStructureUtil.randomUInt64())); + + assertThrows( + IllegalArgumentException.class, + () -> + PayloadAttributesV4.fromInternalPayloadBuildingAttributesV4( + Optional.of(pbaMissingTargetBlobCount))); + } + + @Test + public void buildFromInternalPayload_RequiresMaximumBlobCount() { + final PayloadBuildingAttributes pbaMissingMaximumBlobCount = + new PayloadBuildingAttributes( + dataStructureUtil.randomUInt64(), + dataStructureUtil.randomUInt64(), + dataStructureUtil.randomUInt64(), + dataStructureUtil.randomBytes32(), + dataStructureUtil.randomEth1Address(), + Optional.empty(), + Optional.empty(), + dataStructureUtil.randomBytes32(), + Optional.of(dataStructureUtil.randomUInt64()), + Optional.empty()); + + assertThrows( + IllegalArgumentException.class, + () -> + PayloadAttributesV4.fromInternalPayloadBuildingAttributesV4( + Optional.of(pbaMissingMaximumBlobCount))); + } + + @Test + public void buildFromInternalPayload_HasCorrectValues() { + final PayloadBuildingAttributes payloadBuildingAttributes = + dataStructureUtil.randomPayloadBuildingAttributes(false); + + final PayloadAttributesV4 payloadAttributesV4 = + PayloadAttributesV4.fromInternalPayloadBuildingAttributesV4( + Optional.of(payloadBuildingAttributes)) + .orElseThrow(); + + assertThat(payloadBuildingAttributes.getTimestamp()).isEqualTo(payloadAttributesV4.timestamp); + assertThat(payloadBuildingAttributes.getPrevRandao()).isEqualTo(payloadAttributesV4.prevRandao); + assertThat(payloadBuildingAttributes.getFeeRecipient()) + .isEqualTo(payloadAttributesV4.suggestedFeeRecipient); + assertThat(payloadBuildingAttributes.getWithdrawals()) + .hasValueSatisfying( + withdrawals -> + assertEquals(withdrawals.size(), payloadAttributesV4.withdrawals.size())); + assertThat(payloadBuildingAttributes.getParentBeaconBlockRoot()) + .isEqualTo(payloadAttributesV4.parentBeaconBlockRoot); + assertThat(payloadBuildingAttributes.getTargetBlobCount()) + .hasValue(payloadAttributesV4.targetBlobCount); + assertThat(payloadBuildingAttributes.getMaximumBlobCount()) + .hasValue(payloadAttributesV4.maximumBlobCount); + } +} diff --git a/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/web3j/Web3JClientTest.java b/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/web3j/Web3JClientTest.java index dce5771ce05..5ef46e59e4a 100644 --- a/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/web3j/Web3JClientTest.java +++ b/ethereum/executionclient/src/test/java/tech/pegasys/teku/ethereum/executionclient/web3j/Web3JClientTest.java @@ -14,6 +14,7 @@ package tech.pegasys.teku.ethereum.executionclient.web3j; import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; @@ -272,6 +273,40 @@ void shouldNotUpdateAvailabilityWhenNonCriticalMethodFailsWithErrorResponse( verifyNoInteractions(executionClientEventsPublisher); } + @ParameterizedTest + @MethodSource("getClientInstances") + void shouldDecodeJsonRpcErrorCodesCorrectly(final ClientFactory clientFactory) throws Exception { + final Web3JClient client = clientFactory.create(eventLog, executionClientEventsPublisher); + Request request = createRequest(client); + + // Create a response with a specific JSON-RPC error + VoidResponse errorResponse = new VoidResponse(); + Error rpcError = + new Error( + JsonRpcErrorCodes.INVALID_PARAMS.getErrorCode(), + "engine_newPayload method has been called with invalid parameters"); + errorResponse.setError(rpcError); + + when(client.getWeb3jService().sendAsync(request, VoidResponse.class)) + .thenReturn(SafeFuture.completedFuture(errorResponse)); + + final SafeFuture> result = client.doRequest(request, DEFAULT_TIMEOUT); + Waiter.waitFor(result); + + SafeFutureAssert.assertThatSafeFuture(result).isCompleted(); + final Response response = SafeFutureAssert.safeJoin(result); + + assertThat(response.getErrorMessage()) + .isEqualTo( + String.format( + "JSON-RPC error: %s (%d): %s", + JsonRpcErrorCodes.INVALID_PARAMS.getDescription(), + JsonRpcErrorCodes.INVALID_PARAMS.getErrorCode(), + "engine_newPayload method has been called with invalid parameters")); + + verify(eventLog).executionClientRequestFailed(any(Exception.class), eq(false)); + } + private static Request createRequest(final Web3JClient client) { return new Request<>("test", new ArrayList<>(), client.getWeb3jService(), VoidResponse.class); } diff --git a/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/EngineCapabilitiesMonitor.java b/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/EngineCapabilitiesMonitor.java index 702835fe05a..8ecc3afbcce 100644 --- a/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/EngineCapabilitiesMonitor.java +++ b/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/EngineCapabilitiesMonitor.java @@ -18,6 +18,7 @@ import java.util.List; import java.util.concurrent.atomic.AtomicReference; import java.util.function.Supplier; +import java.util.stream.Stream; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import tech.pegasys.teku.ethereum.events.SlotEventsChannel; @@ -40,6 +41,7 @@ public class EngineCapabilitiesMonitor implements SlotEventsChannel { private final Spec spec; private final EventLogger eventLogger; private final Supplier> capabilitiesSupplier; + private final Supplier> optionalCapabilitiesSupplier; private final ExecutionEngineClient executionEngineClient; public EngineCapabilitiesMonitor( @@ -51,6 +53,8 @@ public EngineCapabilitiesMonitor( this.eventLogger = eventLogger; this.capabilitiesSupplier = Suppliers.memoize(() -> new ArrayList<>(engineMethodsResolver.getCapabilities())); + this.optionalCapabilitiesSupplier = + Suppliers.memoize(() -> new ArrayList<>(engineMethodsResolver.getOptionalCapabilities())); this.executionEngineClient = executionEngineClient; } @@ -79,18 +83,35 @@ private boolean slotIsApplicable(final UInt64 slot) { private SafeFuture monitor() { final List capabilities = capabilitiesSupplier.get(); + final List optionalCapabilities = optionalCapabilitiesSupplier.get(); return executionEngineClient - .exchangeCapabilities(capabilities) + .exchangeCapabilities( + Stream.concat(capabilities.stream(), optionalCapabilities.stream()).toList()) .thenApply(ResponseUnwrapper::unwrapExecutionClientResponseOrThrow) .thenAccept( engineCapabilities -> { LOG.debug("Engine API capabilities response: " + engineCapabilities); + final List missingEngineCapabilities = capabilities.stream() - .filter(capability -> !engineCapabilities.contains(capability)) + .filter( + capability -> + !engineCapabilities.contains(capability) + && !optionalCapabilities.contains(capability)) + .toList(); + + final List missingOptionalCapabilities = + optionalCapabilities.stream() + .filter( + optionalCapability -> !engineCapabilities.contains(optionalCapability)) .toList(); + if (!missingEngineCapabilities.isEmpty()) { - eventLogger.missingEngineApiCapabilities(missingEngineCapabilities); + eventLogger.missingEngineApiCapabilities(missingEngineCapabilities, false); + } + + if (!missingOptionalCapabilities.isEmpty()) { + eventLogger.missingEngineApiCapabilities(missingOptionalCapabilities, true); } }); } diff --git a/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/EngineJsonRpcMethodsResolver.java b/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/EngineJsonRpcMethodsResolver.java index bcf580c3659..ce182addfea 100644 --- a/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/EngineJsonRpcMethodsResolver.java +++ b/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/EngineJsonRpcMethodsResolver.java @@ -13,6 +13,7 @@ package tech.pegasys.teku.ethereum.executionlayer; +import java.util.List; import java.util.Set; import java.util.function.Supplier; import tech.pegasys.teku.ethereum.executionclient.methods.EngineApiMethod; @@ -24,10 +25,19 @@ public interface EngineJsonRpcMethodsResolver { EngineJsonRpcMethod getMethod( EngineApiMethod method, Supplier milestoneSupplier, Class resultType); + EngineJsonRpcMethod> getListMethod( + EngineApiMethod method, Supplier milestoneSupplier, Class resultType); + /** * Get CL capabilities required for the engine_exchangeCapabilities * request */ Set getCapabilities(); + + /** + * TODO this optionality notion should be removed once all ELs implement the engine_getBlobsV1 RPC + * method. It has been added to ensure a softer and better logging when the method is missing only + */ + Set getOptionalCapabilities(); } diff --git a/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionBuilderModule.java b/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionBuilderModule.java index 78da180a058..7d1f14f289b 100644 --- a/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionBuilderModule.java +++ b/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionBuilderModule.java @@ -34,13 +34,13 @@ import tech.pegasys.teku.infrastructure.logging.EventLogger; import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.builder.BlobsBundle; import tech.pegasys.teku.spec.datastructures.builder.BuilderBid; -import tech.pegasys.teku.spec.datastructures.builder.BuilderPayload; import tech.pegasys.teku.spec.datastructures.builder.SignedBuilderBid; import tech.pegasys.teku.spec.datastructures.builder.SignedValidatorRegistration; +import tech.pegasys.teku.spec.datastructures.execution.BuilderBidOrFallbackData; +import tech.pegasys.teku.spec.datastructures.execution.BuilderPayloadOrFallbackData; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadContext; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; @@ -48,11 +48,7 @@ import tech.pegasys.teku.spec.datastructures.execution.FallbackData; import tech.pegasys.teku.spec.datastructures.execution.FallbackReason; import tech.pegasys.teku.spec.datastructures.execution.GetPayloadResponse; -import tech.pegasys.teku.spec.datastructures.execution.HeaderWithFallbackData; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; -import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; -import tech.pegasys.teku.spec.schemas.SchemaDefinitions; -import tech.pegasys.teku.spec.schemas.SchemaDefinitionsDeneb; public class ExecutionBuilderModule { @@ -63,7 +59,6 @@ public class ExecutionBuilderModule { public static final UInt64 BUILDER_BOOST_FACTOR_PREFER_EXECUTION = UInt64.ZERO; public static final UInt64 BUILDER_BOOST_FACTOR_PREFER_BUILDER = UInt64.MAX_VALUE; - private final Spec spec; private final AtomicBoolean latestBuilderAvailability; private final ExecutionLayerManagerImpl executionLayerManager; private final BuilderBidValidator builderBidValidator; @@ -74,7 +69,6 @@ public class ExecutionBuilderModule { private final boolean useShouldOverrideBuilderFlag; public ExecutionBuilderModule( - final Spec spec, final ExecutionLayerManagerImpl executionLayerManager, final BuilderBidValidator builderBidValidator, final BuilderCircuitBreaker builderCircuitBreaker, @@ -82,7 +76,6 @@ public ExecutionBuilderModule( final EventLogger eventLogger, final UInt64 builderBidCompareFactor, final boolean useShouldOverrideBuilderFlag) { - this.spec = spec; this.latestBuilderAvailability = new AtomicBoolean(builderClient.isPresent()); this.executionLayerManager = executionLayerManager; this.builderBidValidator = builderBidValidator; @@ -93,11 +86,10 @@ public ExecutionBuilderModule( this.useShouldOverrideBuilderFlag = useShouldOverrideBuilderFlag; } - private Optional> isBuilderFlowViable( + private Optional> isBuilderFlowViable( final ExecutionPayloadContext executionPayloadContext, final BeaconState state, - final SafeFuture localGetPayloadResponse, - final SafeFuture payloadValueResult) { + final SafeFuture localGetPayloadResponse) { final Optional validatorRegistration = executionPayloadContext.getPayloadBuildingAttributes().getValidatorRegistration(); @@ -121,34 +113,31 @@ private Optional> isBuilderFlowViable( if (fallbackReason != null) { return Optional.of( - getResultFromLocalGetPayloadResponse( - localGetPayloadResponse, state.getSlot(), fallbackReason, payloadValueResult)); + getResultFromLocalGetPayloadResponse(localGetPayloadResponse, fallbackReason)); } return Optional.empty(); } - public SafeFuture builderGetHeader( + public SafeFuture builderGetHeader( final ExecutionPayloadContext executionPayloadContext, final BeaconState state, - final SafeFuture payloadValueResult, final Optional requestedBuilderBoostFactor, final BlockProductionPerformance blockProductionPerformance) { final SafeFuture localGetPayloadResponse = executionLayerManager .engineGetPayloadForFallback(executionPayloadContext, state.getSlot()) - .thenPeek(__ -> blockProductionPerformance.engineGetPayload()); + .alwaysRun(blockProductionPerformance::engineGetPayload); - final Optional> maybeFallback = - isBuilderFlowViable( - executionPayloadContext, state, localGetPayloadResponse, payloadValueResult); + final Optional> maybeFallback = + isBuilderFlowViable(executionPayloadContext, state, localGetPayloadResponse); if (maybeFallback.isPresent()) { return maybeFallback .get() .thenPeek( - headerWithFallbackData -> - headerWithFallbackData + builderBidOrFallbackData -> + builderBidOrFallbackData .getFallbackData() .ifPresent(this::recordAndLogFallbackToLocallyProducedExecutionData)); } @@ -176,24 +165,20 @@ public SafeFuture builderGetHeader( .getHeader(slot, validatorPublicKey, executionPayloadContext.getParentHash()) .thenApply(ResponseUnwrapper::unwrapBuilderResponseOrThrow) .thenPeek( - signedBuilderBidMaybe -> { - blockProductionPerformance.builderGetHeader(); - LOG.trace( - "builderGetHeader(slot={}, pubKey={}, parentHash={}) -> {}", - slot, - validatorPublicKey, - executionPayloadContext.getParentHash(), - signedBuilderBidMaybe); - }) + signedBuilderBidMaybe -> + LOG.trace( + "builderGetHeader(slot={}, pubKey={}, parentHash={}) -> {}", + slot, + validatorPublicKey, + executionPayloadContext.getParentHash(), + signedBuilderBidMaybe)) + .alwaysRun(blockProductionPerformance::builderGetHeader) .thenComposeCombined( safeLocalGetPayloadResponse, (signedBuilderBidMaybe, maybeLocalGetPayloadResponse) -> { if (signedBuilderBidMaybe.isEmpty()) { return getResultFromLocalGetPayloadResponse( - localGetPayloadResponse, - slot, - FallbackReason.BUILDER_HEADER_NOT_AVAILABLE, - payloadValueResult); + localGetPayloadResponse, FallbackReason.BUILDER_HEADER_NOT_AVAILABLE); } else { // Treat the shouldOverrideBuilder flag as false if local payload is unavailable final boolean shouldOverrideBuilder = @@ -202,10 +187,7 @@ public SafeFuture builderGetHeader( .orElse(false); if (useShouldOverrideBuilderFlag && shouldOverrideBuilder) { return getResultFromLocalGetPayloadResponse( - localGetPayloadResponse, - slot, - FallbackReason.SHOULD_OVERRIDE_BUILDER_FLAG_IS_TRUE, - payloadValueResult); + localGetPayloadResponse, FallbackReason.SHOULD_OVERRIDE_BUILDER_FLAG_IS_TRUE); } final SignedBuilderBid signedBuilderBid = signedBuilderBidMaybe.get(); @@ -224,10 +206,7 @@ public SafeFuture builderGetHeader( if (localPayloadValueWon) { return getResultFromLocalGetPayloadResponse( - localGetPayloadResponse, - slot, - FallbackReason.LOCAL_BLOCK_VALUE_WON, - payloadValueResult); + localGetPayloadResponse, FallbackReason.LOCAL_BLOCK_VALUE_WON); } final Optional localExecutionPayload = @@ -237,7 +216,6 @@ public SafeFuture builderGetHeader( state, validatorRegistration.get(), localExecutionPayload, - payloadValueResult, blockProductionPerformance); } }) @@ -247,11 +225,11 @@ public SafeFuture builderGetHeader( "Unable to obtain a valid bid from builder. Falling back to local execution engine.", error); return getResultFromLocalGetPayloadResponse( - localGetPayloadResponse, slot, FallbackReason.BUILDER_ERROR, payloadValueResult); + localGetPayloadResponse, FallbackReason.BUILDER_ERROR); }) .thenPeek( - headerWithFallbackData -> - headerWithFallbackData + builderBidOrFallbackData -> + builderBidOrFallbackData .getFallbackData() .ifPresent(this::recordAndLogFallbackToLocallyProducedExecutionData)); } @@ -306,21 +284,17 @@ private boolean isLocalPayloadValueWinning( .lessOrEqualThan(localPayloadValue.multiply(HUNDRED_PERCENT)); } - private SafeFuture getResultFromSignedBuilderBid( + private SafeFuture getResultFromSignedBuilderBid( final SignedBuilderBid signedBuilderBid, final BeaconState state, final SignedValidatorRegistration validatorRegistration, final Optional localExecutionPayload, - final SafeFuture payloadValueResult, final BlockProductionPerformance blockProductionPerformance) { builderBidValidator.validateBuilderBid( signedBuilderBid, validatorRegistration, state, localExecutionPayload); blockProductionPerformance.builderBidValidated(); final BuilderBid builderBid = signedBuilderBid.getMessage(); - payloadValueResult.complete(builderBid.getValue()); - return SafeFuture.completedFuture( - HeaderWithFallbackData.create( - builderBid.getHeader(), builderBid.getOptionalBlobKzgCommitments())); + return SafeFuture.completedFuture(BuilderBidOrFallbackData.create(builderBid)); } public SafeFuture builderRegisterValidators( @@ -353,7 +327,7 @@ public SafeFuture builderRegisterValidators( signedValidatorRegistrations)); } - public SafeFuture builderGetPayload( + public SafeFuture builderGetPayload( final SignedBeaconBlock signedBeaconBlock, final Function> getPayloadResultFunction) { @@ -361,10 +335,10 @@ public SafeFuture builderGetPayload( final UInt64 slot = signedBeaconBlock.getSlot(); - final Optional> maybeProcessedSlot = + final Optional> maybeProcessedSlot = getPayloadResultFunction .apply(slot) - .flatMap(ExecutionPayloadResult::getHeaderWithFallbackDataFuture); + .flatMap(ExecutionPayloadResult::getBuilderBidOrFallbackDataFuture); if (maybeProcessedSlot.isEmpty()) { LOG.warn( @@ -372,10 +346,10 @@ public SafeFuture builderGetPayload( return getPayloadFromBuilder(signedBeaconBlock); } - final SafeFuture headerWithFallbackDataFuture = + final SafeFuture builderBidOrFallbackDataFuture = maybeProcessedSlot.get(); - return getPayloadFromBuilderOrFallbackData(signedBeaconBlock, headerWithFallbackDataFuture); + return getPayloadFromBuilderOrFallbackData(signedBeaconBlock, builderBidOrFallbackDataFuture); } private boolean isTransitionNotFinalized(final ExecutionPayloadContext executionPayloadContext) { @@ -398,38 +372,16 @@ private boolean isCircuitBreakerEngaged(final BeaconState state) { } } - private SafeFuture getResultFromLocalGetPayloadResponse( - final SafeFuture localGetPayloadResponse, - final UInt64 slot, - final FallbackReason reason, - final SafeFuture payloadValueResult) { + private SafeFuture getResultFromLocalGetPayloadResponse( + final SafeFuture localGetPayloadResponse, final FallbackReason reason) { return localGetPayloadResponse.thenApply( getPayloadResponse -> { - payloadValueResult.complete(getPayloadResponse.getExecutionPayloadValue()); - final SchemaDefinitions schemaDefinitions = spec.atSlot(slot).getSchemaDefinitions(); - final ExecutionPayload executionPayload = getPayloadResponse.getExecutionPayload(); - final ExecutionPayloadHeader executionPayloadHeader = - schemaDefinitions - .toVersionBellatrix() - .orElseThrow() - .getExecutionPayloadHeaderSchema() - .createFromExecutionPayload(executionPayload); - final Optional> blobKzgCommitments = - getPayloadResponse - .getBlobsBundle() - .map( - blobsBundle -> - SchemaDefinitionsDeneb.required(schemaDefinitions) - .getBlobKzgCommitmentsSchema() - .createFromBlobsBundle(blobsBundle)); - final FallbackData fallbackData = - new FallbackData(executionPayload, getPayloadResponse.getBlobsBundle(), reason); - return HeaderWithFallbackData.create( - executionPayloadHeader, blobKzgCommitments, fallbackData); + final FallbackData fallbackData = new FallbackData(getPayloadResponse, reason); + return BuilderBidOrFallbackData.create(fallbackData); }); } - private SafeFuture getPayloadFromBuilder( + private SafeFuture getPayloadFromBuilder( final SignedBeaconBlock signedBlindedBeaconBlock) { LOG.trace("calling builderGetPayload(signedBlindedBeaconBlock={})", signedBlindedBeaconBlock); @@ -453,45 +405,27 @@ private SafeFuture getPayloadFromBuilder( "builderGetPayload(signedBlindedBeaconBlock={}) -> {}", signedBlindedBeaconBlock, builderPayload); - }); + }) + .thenApply(BuilderPayloadOrFallbackData::create); } - private SafeFuture getPayloadFromBuilderOrFallbackData( + private SafeFuture getPayloadFromBuilderOrFallbackData( final SignedBeaconBlock signedBlindedBeaconBlock, - final SafeFuture headerWithFallbackDataFuture) { + final SafeFuture builderBidOrFallbackDataFuture) { // note: we don't do any particular consistency check here. // the header/payload compatibility check is done by SignedBeaconBlockUnblinder // the blobs bundle compatibility check is done by // BlockOperationSelectorFactory#createBlobSidecarsSelector - return headerWithFallbackDataFuture.thenCompose( - headerWithFallbackData -> { - if (headerWithFallbackData.getFallbackData().isEmpty()) { + return builderBidOrFallbackDataFuture.thenCompose( + builderBidOrFallbackData -> { + if (builderBidOrFallbackData.getFallbackData().isEmpty()) { return getPayloadFromBuilder(signedBlindedBeaconBlock); } else { - final FallbackData fallbackData = headerWithFallbackData.getFallbackData().get(); + final FallbackData fallbackData = builderBidOrFallbackData.getFallbackDataRequired(); LOG.debug( "Using FallbackData to provide unblinded execution data (FallbackReason: {})", fallbackData.getReason()); - final BuilderPayload builderPayload = - fallbackData - .getBlobsBundle() - .map( - executionBlobsBundle -> { - final SchemaDefinitionsDeneb schemaDefinitions = - SchemaDefinitionsDeneb.required( - spec.atSlot(signedBlindedBeaconBlock.getSlot()) - .getSchemaDefinitions()); - final BlobsBundle blobsBundle = - schemaDefinitions - .getBlobsBundleSchema() - .createFromExecutionBlobsBundle(executionBlobsBundle); - return (BuilderPayload) - schemaDefinitions - .getExecutionPayloadAndBlobsBundleSchema() - .create(fallbackData.getExecutionPayload(), blobsBundle); - }) - .orElseGet(fallbackData::getExecutionPayload); - return SafeFuture.completedFuture(builderPayload); + return SafeFuture.completedFuture(BuilderPayloadOrFallbackData.create(fallbackData)); } }); } diff --git a/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionClientHandler.java b/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionClientHandler.java index 9c8290fd1d6..4799f24bd10 100644 --- a/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionClientHandler.java +++ b/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionClientHandler.java @@ -18,6 +18,7 @@ import org.apache.tuweni.bytes.Bytes32; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.datastructures.execution.BlobAndProof; import tech.pegasys.teku.spec.datastructures.execution.ClientVersion; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadContext; import tech.pegasys.teku.spec.datastructures.execution.GetPayloadResponse; @@ -27,6 +28,7 @@ import tech.pegasys.teku.spec.executionlayer.ForkChoiceUpdatedResult; import tech.pegasys.teku.spec.executionlayer.PayloadBuildingAttributes; import tech.pegasys.teku.spec.executionlayer.PayloadStatus; +import tech.pegasys.teku.spec.logic.versions.deneb.types.VersionedHash; public interface ExecutionClientHandler { @@ -41,7 +43,10 @@ SafeFuture engineForkChoiceUpdated( SafeFuture engineGetPayload( ExecutionPayloadContext executionPayloadContext, UInt64 slot); - SafeFuture engineNewPayload(NewPayloadRequest newPayloadRequest); + SafeFuture engineNewPayload(NewPayloadRequest newPayloadRequest, UInt64 slot); SafeFuture> engineGetClientVersion(ClientVersion clientVersion); + + SafeFuture> engineGetBlobs( + List blobVersionedHashes, UInt64 slot); } diff --git a/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionClientHandlerImpl.java b/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionClientHandlerImpl.java index 301d4d46ca0..581f494cb0a 100644 --- a/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionClientHandlerImpl.java +++ b/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionClientHandlerImpl.java @@ -24,6 +24,7 @@ import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.datastructures.execution.BlobAndProof; import tech.pegasys.teku.spec.datastructures.execution.ClientVersion; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadContext; @@ -34,6 +35,7 @@ import tech.pegasys.teku.spec.executionlayer.ForkChoiceUpdatedResult; import tech.pegasys.teku.spec.executionlayer.PayloadBuildingAttributes; import tech.pegasys.teku.spec.executionlayer.PayloadStatus; +import tech.pegasys.teku.spec.logic.versions.deneb.types.VersionedHash; public class ExecutionClientHandlerImpl implements ExecutionClientHandler { @@ -100,17 +102,21 @@ public SafeFuture engineGetPayload( } @Override - public SafeFuture engineNewPayload(final NewPayloadRequest newPayloadRequest) { + public SafeFuture engineNewPayload( + final NewPayloadRequest newPayloadRequest, final UInt64 slot) { final ExecutionPayload executionPayload = newPayloadRequest.getExecutionPayload(); final JsonRpcRequestParams.Builder paramsBuilder = new JsonRpcRequestParams.Builder() .add(executionPayload) .addOptional(newPayloadRequest.getVersionedHashes()) - .addOptional(newPayloadRequest.getParentBeaconBlockRoot()); + .addOptional(newPayloadRequest.getParentBeaconBlockRoot()) + .addOptional(newPayloadRequest.getExecutionRequests()); return engineMethodsResolver .getMethod( - EngineApiMethod.ENGINE_NEW_PAYLOAD, executionPayload::getMilestone, PayloadStatus.class) + EngineApiMethod.ENGINE_NEW_PAYLOAD, + () -> spec.atSlot(slot).getMilestone(), + PayloadStatus.class) .execute(paramsBuilder.build()); } @@ -123,4 +129,17 @@ public SafeFuture> engineGetClientVersion(final ClientVersio clientVersions -> clientVersions.stream().map(ClientVersionV1::asInternalClientVersion).toList()); } + + @Override + public SafeFuture> engineGetBlobs( + final List blobVersionedHashes, final UInt64 slot) { + final JsonRpcRequestParams params = + new JsonRpcRequestParams.Builder().add(blobVersionedHashes).add(slot).build(); + return engineMethodsResolver + .getListMethod( + EngineApiMethod.ENGINE_GET_BLOBS, + () -> spec.atSlot(slot).getMilestone(), + BlobAndProof.class) + .execute(params); + } } diff --git a/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionLayerBlockProductionManagerImpl.java b/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionLayerBlockProductionManagerImpl.java index 6f047f38d3f..4ccb7a6b3f8 100644 --- a/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionLayerBlockProductionManagerImpl.java +++ b/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionLayerBlockProductionManagerImpl.java @@ -16,20 +16,17 @@ import java.util.NavigableMap; import java.util.Optional; import java.util.concurrent.ConcurrentSkipListMap; -import org.apache.tuweni.units.bigints.UInt256; import tech.pegasys.teku.ethereum.events.SlotEventsChannel; import tech.pegasys.teku.ethereum.performance.trackers.BlockProductionPerformance; import tech.pegasys.teku.ethereum.performance.trackers.BlockPublishingPerformance; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; -import tech.pegasys.teku.spec.datastructures.builder.BuilderPayload; -import tech.pegasys.teku.spec.datastructures.execution.BlobsBundle; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; +import tech.pegasys.teku.spec.datastructures.execution.BuilderBidOrFallbackData; +import tech.pegasys.teku.spec.datastructures.execution.BuilderPayloadOrFallbackData; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadContext; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadResult; import tech.pegasys.teku.spec.datastructures.execution.GetPayloadResponse; -import tech.pegasys.teku.spec.datastructures.execution.HeaderWithFallbackData; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.executionlayer.ExecutionLayerBlockProductionManager; import tech.pegasys.teku.spec.executionlayer.ExecutionLayerChannel; @@ -43,7 +40,7 @@ public class ExecutionLayerBlockProductionManagerImpl private final NavigableMap executionResultCache = new ConcurrentSkipListMap<>(); - private final NavigableMap builderResultCache = + private final NavigableMap builderResultCache = new ConcurrentSkipListMap<>(); private final ExecutionLayerChannel executionLayerChannel; @@ -63,120 +60,68 @@ public void onSlot(final UInt64 slot) { .clear(); } - @Override - public Optional getCachedPayloadResult(final UInt64 slot) { - return Optional.ofNullable(executionResultCache.get(slot)); - } - @Override public ExecutionPayloadResult initiateBlockProduction( final ExecutionPayloadContext context, final BeaconState blockSlotState, - final boolean isBlind, + final boolean attemptBuilderFlow, final Optional requestedBuilderBoostFactor, final BlockProductionPerformance blockProductionPerformance) { final ExecutionPayloadResult result; - if (!isBlind) { - final SafeFuture getPayloadResponseFuture = - executionLayerChannel - .engineGetPayload(context, blockSlotState) - .thenPeek(__ -> blockProductionPerformance.engineGetPayload()); - final SafeFuture executionPayloadFuture = - getPayloadResponseFuture.thenApply(GetPayloadResponse::getExecutionPayload); - final SafeFuture executionPayloadValueFuture = - getPayloadResponseFuture.thenApply(GetPayloadResponse::getExecutionPayloadValue); + if (attemptBuilderFlow) { result = - new ExecutionPayloadResult( - context, - Optional.of(executionPayloadFuture), - Optional.empty(), - Optional.empty(), - Optional.of(executionPayloadValueFuture)); - } else { - result = - builderGetHeader( + executeBuilderFlow( context, blockSlotState, requestedBuilderBoostFactor, blockProductionPerformance); + } else { + result = executeLocalFlow(context, blockSlotState, blockProductionPerformance); } executionResultCache.put(blockSlotState.getSlot(), result); return result; } @Override - public ExecutionPayloadResult initiateBlockAndBlobsProduction( - final ExecutionPayloadContext context, - final BeaconState blockSlotState, - final boolean isBlind, - final Optional requestedBuilderBoostFactor, - final BlockProductionPerformance blockProductionPerformance) { - final ExecutionPayloadResult result; - if (!isBlind) { - final SafeFuture getPayloadResponseFuture = - executionLayerChannel - .engineGetPayload(context, blockSlotState) - .thenPeek(__ -> blockProductionPerformance.engineGetPayload()); - final SafeFuture executionPayloadFuture = - getPayloadResponseFuture.thenApply(GetPayloadResponse::getExecutionPayload); - final SafeFuture> blobsBundleFuture = - getPayloadResponseFuture.thenApply(GetPayloadResponse::getBlobsBundle); - final SafeFuture executionPayloadValueFuture = - getPayloadResponseFuture.thenApply(GetPayloadResponse::getExecutionPayloadValue); - result = - new ExecutionPayloadResult( - context, - Optional.of(executionPayloadFuture), - Optional.of(blobsBundleFuture), - Optional.empty(), - Optional.of(executionPayloadValueFuture)); - } else { - result = - builderGetHeader( - context, blockSlotState, requestedBuilderBoostFactor, blockProductionPerformance); - } - executionResultCache.put(blockSlotState.getSlot(), result); - return result; + public Optional getCachedPayloadResult(final UInt64 slot) { + return Optional.ofNullable(executionResultCache.get(slot)); } @Override - public SafeFuture getUnblindedPayload( + public SafeFuture getUnblindedPayload( final SignedBeaconBlock signedBeaconBlock, final BlockPublishingPerformance blockPublishingPerformance) { return executionLayerChannel .builderGetPayload(signedBeaconBlock, this::getCachedPayloadResult) .thenPeek( - builderPayload -> { - builderResultCache.put(signedBeaconBlock.getSlot(), builderPayload); - blockPublishingPerformance.builderGetPayload(); - }); + builderPayloadOrFallbackData -> + builderResultCache.put(signedBeaconBlock.getSlot(), builderPayloadOrFallbackData)) + .alwaysRun(blockPublishingPerformance::builderGetPayload); } @Override - public Optional getCachedUnblindedPayload(final UInt64 slot) { + public Optional getCachedUnblindedPayload(final UInt64 slot) { return Optional.ofNullable(builderResultCache.get(slot)); } - private ExecutionPayloadResult builderGetHeader( - final ExecutionPayloadContext executionPayloadContext, - final BeaconState state, - final Optional requestedBuilderBoostFactor, + private ExecutionPayloadResult executeLocalFlow( + final ExecutionPayloadContext context, + final BeaconState blockSlotState, final BlockProductionPerformance blockProductionPerformance) { + final SafeFuture getPayloadResponseFuture = + executionLayerChannel + .engineGetPayload(context, blockSlotState) + .alwaysRun(blockProductionPerformance::engineGetPayload); - final SafeFuture executionPayloadValueFuture = new SafeFuture<>(); + return ExecutionPayloadResult.createForLocalFlow(context, getPayloadResponseFuture); + } - final SafeFuture headerWithFallbackDataFuture = - executionLayerChannel - .builderGetHeader( - executionPayloadContext, - state, - executionPayloadValueFuture, - requestedBuilderBoostFactor, - blockProductionPerformance) - .whenException(executionPayloadValueFuture::completeExceptionally); - - return new ExecutionPayloadResult( - executionPayloadContext, - Optional.empty(), - Optional.empty(), - Optional.of(headerWithFallbackDataFuture), - Optional.of(executionPayloadValueFuture)); + private ExecutionPayloadResult executeBuilderFlow( + final ExecutionPayloadContext context, + final BeaconState blockSlotState, + final Optional requestedBuilderBoostFactor, + final BlockProductionPerformance blockProductionPerformance) { + final SafeFuture builderBidOrFallbackDataFuture = + executionLayerChannel.builderGetHeader( + context, blockSlotState, requestedBuilderBoostFactor, blockProductionPerformance); + + return ExecutionPayloadResult.createForBuilderFlow(context, builderBidOrFallbackDataFuture); } } diff --git a/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionLayerManagerImpl.java b/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionLayerManagerImpl.java index 75847ebd7f9..1ef114e771f 100644 --- a/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionLayerManagerImpl.java +++ b/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionLayerManagerImpl.java @@ -24,7 +24,6 @@ import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.apache.tuweni.bytes.Bytes32; -import org.apache.tuweni.units.bigints.UInt256; import org.hyperledger.besu.plugin.services.MetricsSystem; import org.hyperledger.besu.plugin.services.metrics.Counter; import org.hyperledger.besu.plugin.services.metrics.LabelledMetric; @@ -46,16 +45,16 @@ import tech.pegasys.teku.infrastructure.time.TimeProvider; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; -import tech.pegasys.teku.spec.datastructures.builder.BuilderPayload; import tech.pegasys.teku.spec.datastructures.builder.SignedValidatorRegistration; +import tech.pegasys.teku.spec.datastructures.execution.BlobAndProof; +import tech.pegasys.teku.spec.datastructures.execution.BuilderBidOrFallbackData; +import tech.pegasys.teku.spec.datastructures.execution.BuilderPayloadOrFallbackData; import tech.pegasys.teku.spec.datastructures.execution.ClientVersion; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadContext; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadResult; import tech.pegasys.teku.spec.datastructures.execution.FallbackReason; import tech.pegasys.teku.spec.datastructures.execution.GetPayloadResponse; -import tech.pegasys.teku.spec.datastructures.execution.HeaderWithFallbackData; import tech.pegasys.teku.spec.datastructures.execution.NewPayloadRequest; import tech.pegasys.teku.spec.datastructures.execution.PowBlock; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; @@ -63,12 +62,12 @@ import tech.pegasys.teku.spec.executionlayer.ForkChoiceUpdatedResult; import tech.pegasys.teku.spec.executionlayer.PayloadBuildingAttributes; import tech.pegasys.teku.spec.executionlayer.PayloadStatus; +import tech.pegasys.teku.spec.logic.versions.deneb.types.VersionedHash; public class ExecutionLayerManagerImpl implements ExecutionLayerManager { private static final Logger LOG = LogManager.getLogger(); - private final Spec spec; private final ExecutionClientHandler executionClientHandler; private final ExecutionBuilderModule executionBuilderModule; private final LabelledMetric executionPayloadSourceCounter; @@ -77,7 +76,6 @@ public static ExecutionLayerManagerImpl create( final EventLogger eventLogger, final ExecutionClientHandler executionClientHandler, final Optional builderClient, - final Spec spec, final MetricsSystem metricsSystem, final BuilderBidValidator builderBidValidator, final BuilderCircuitBreaker builderCircuitBreaker, @@ -86,7 +84,7 @@ public static ExecutionLayerManagerImpl create( final LabelledMetric executionPayloadSourceCounter = metricsSystem.createLabelledCounter( TekuMetricCategory.BEACON, - "execution_payload_source", + "execution_payload_source_total", "Counter recording the source of the execution payload during block production", "source", "fallback_reason"); @@ -105,7 +103,6 @@ public static ExecutionLayerManagerImpl create( return new ExecutionLayerManagerImpl( executionClientHandler, builderClient, - spec, eventLogger, builderBidValidator, builderCircuitBreaker, @@ -143,7 +140,6 @@ public static BuilderClient createBuilderClient( private ExecutionLayerManagerImpl( final ExecutionClientHandler executionClientHandler, final Optional builderClient, - final Spec spec, final EventLogger eventLogger, final BuilderBidValidator builderBidValidator, final BuilderCircuitBreaker builderCircuitBreaker, @@ -151,11 +147,9 @@ private ExecutionLayerManagerImpl( final UInt64 builderBidCompareFactor, final boolean useShouldOverrideBuilderFlag) { this.executionClientHandler = executionClientHandler; - this.spec = spec; this.executionPayloadSourceCounter = executionPayloadSourceCounter; this.executionBuilderModule = new ExecutionBuilderModule( - spec, this, builderBidValidator, builderCircuitBreaker, @@ -196,35 +190,29 @@ public SafeFuture engineForkChoiceUpdated( @Override public SafeFuture engineGetPayload( final ExecutionPayloadContext executionPayloadContext, final BeaconState state) { - return engineGetPayload(executionPayloadContext, state.getSlot(), false) + return engineGetPayload(executionPayloadContext, state.getSlot()) .thenPeek(__ -> recordExecutionPayloadFallbackSource(Source.LOCAL_EL, FallbackReason.NONE)); } SafeFuture engineGetPayloadForFallback( final ExecutionPayloadContext executionPayloadContext, final UInt64 slot) { - return engineGetPayload(executionPayloadContext, slot, true); + return engineGetPayload(executionPayloadContext, slot); } private SafeFuture engineGetPayload( - final ExecutionPayloadContext executionPayloadContext, - final UInt64 slot, - final boolean isFallbackCall) { + final ExecutionPayloadContext executionPayloadContext, final UInt64 slot) { LOG.trace( "calling engineGetPayload(payloadId={}, slot={})", executionPayloadContext.getPayloadId(), slot); - if (!isFallbackCall - && executionBuilderModule.isBuilderAvailable() - && spec.atSlot(slot).getMilestone().isGreaterThanOrEqualTo(SpecMilestone.BELLATRIX)) { - LOG.warn("Builder endpoint is available but a non-blinded block has been requested"); - } return executionClientHandler.engineGetPayload(executionPayloadContext, slot); } @Override - public SafeFuture engineNewPayload(final NewPayloadRequest newPayloadRequest) { + public SafeFuture engineNewPayload( + final NewPayloadRequest newPayloadRequest, final UInt64 slot) { LOG.trace("calling engineNewPayload(newPayloadRequest={})", newPayloadRequest); - return executionClientHandler.engineNewPayload(newPayloadRequest); + return executionClientHandler.engineNewPayload(newPayloadRequest, slot); } @Override @@ -233,6 +221,15 @@ public SafeFuture> engineGetClientVersion(final ClientVersio return executionClientHandler.engineGetClientVersion(clientVersion); } + @Override + public SafeFuture>> engineGetBlobs( + final List blobVersionedHashes, final UInt64 slot) { + LOG.trace("calling engineGetBlobs(blobVersionedHashes={}, slot={})", blobVersionedHashes, slot); + return executionClientHandler + .engineGetBlobs(blobVersionedHashes, slot) + .thenApply(blobsAndProofs -> blobsAndProofs.stream().map(Optional::ofNullable).toList()); + } + @Override public SafeFuture builderRegisterValidators( final SszList signedValidatorRegistrations, final UInt64 slot) { @@ -240,7 +237,7 @@ public SafeFuture builderRegisterValidators( } @Override - public SafeFuture builderGetPayload( + public SafeFuture builderGetPayload( final SignedBeaconBlock signedBeaconBlock, final Function> getCachedPayloadResultFunction) { return executionBuilderModule.builderGetPayload( @@ -248,18 +245,13 @@ public SafeFuture builderGetPayload( } @Override - public SafeFuture builderGetHeader( + public SafeFuture builderGetHeader( final ExecutionPayloadContext executionPayloadContext, final BeaconState state, - final SafeFuture payloadValueResult, final Optional requestedBuilderBoostFactor, final BlockProductionPerformance blockProductionPerformance) { return executionBuilderModule.builderGetHeader( - executionPayloadContext, - state, - payloadValueResult, - requestedBuilderBoostFactor, - blockProductionPerformance); + executionPayloadContext, state, requestedBuilderBoostFactor, blockProductionPerformance); } @VisibleForTesting diff --git a/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionLayerManagerStub.java b/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionLayerManagerStub.java index 2792225f45c..65e221e22cc 100644 --- a/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionLayerManagerStub.java +++ b/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionLayerManagerStub.java @@ -17,16 +17,15 @@ import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.apache.tuweni.bytes.Bytes32; -import org.apache.tuweni.units.bigints.UInt256; import tech.pegasys.teku.ethereum.performance.trackers.BlockProductionPerformance; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.time.TimeProvider; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.datastructures.execution.BuilderBidOrFallbackData; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadContext; import tech.pegasys.teku.spec.datastructures.execution.FallbackData; import tech.pegasys.teku.spec.datastructures.execution.FallbackReason; -import tech.pegasys.teku.spec.datastructures.execution.HeaderWithFallbackData; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.executionlayer.ExecutionLayerChannelStub; @@ -47,41 +46,32 @@ public ExecutionLayerManagerStub( } @Override - public void onSlot(UInt64 slot) { + public void onSlot(final UInt64 slot) { // NOOP } @Override - public SafeFuture builderGetHeader( + public SafeFuture builderGetHeader( final ExecutionPayloadContext executionPayloadContext, final BeaconState state, - final SafeFuture payloadValueResult, final Optional requestedBuilderBoostFactor, final BlockProductionPerformance blockProductionPerformance) { final boolean builderCircuitBreakerEngaged = builderCircuitBreaker.isEngaged(state); LOG.info("Builder Circuit Breaker isEngaged: " + builderCircuitBreakerEngaged); return super.builderGetHeader( - executionPayloadContext, - state, - payloadValueResult, - requestedBuilderBoostFactor, - blockProductionPerformance) + executionPayloadContext, state, requestedBuilderBoostFactor, blockProductionPerformance) .thenCompose( - headerWithFallbackData -> { + builderBidOrFallbackData -> { if (builderCircuitBreakerEngaged) { return engineGetPayload(executionPayloadContext, state) .thenApply( - payload -> - HeaderWithFallbackData.create( - headerWithFallbackData.getExecutionPayloadHeader(), - headerWithFallbackData.getBlobKzgCommitments(), + getPayloadResponse -> + BuilderBidOrFallbackData.create( new FallbackData( - payload.getExecutionPayload(), - payload.getBlobsBundle(), - FallbackReason.CIRCUIT_BREAKER_ENGAGED))); + getPayloadResponse, FallbackReason.CIRCUIT_BREAKER_ENGAGED))); } else { - return SafeFuture.completedFuture(headerWithFallbackData); + return SafeFuture.completedFuture(builderBidOrFallbackData); } }); } diff --git a/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/MilestoneBasedEngineJsonRpcMethodsResolver.java b/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/MilestoneBasedEngineJsonRpcMethodsResolver.java index 8f30f8a6570..19e53beccee 100644 --- a/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/MilestoneBasedEngineJsonRpcMethodsResolver.java +++ b/ethereum/executionlayer/src/main/java/tech/pegasys/teku/ethereum/executionlayer/MilestoneBasedEngineJsonRpcMethodsResolver.java @@ -14,14 +14,16 @@ package tech.pegasys.teku.ethereum.executionlayer; import static tech.pegasys.teku.ethereum.executionclient.methods.EngineApiMethod.ENGINE_FORK_CHOICE_UPDATED; +import static tech.pegasys.teku.ethereum.executionclient.methods.EngineApiMethod.ENGINE_GET_BLOBS; import static tech.pegasys.teku.ethereum.executionclient.methods.EngineApiMethod.ENGINE_GET_PAYLOAD; import static tech.pegasys.teku.ethereum.executionclient.methods.EngineApiMethod.ENGINE_NEW_PAYLOAD; import java.util.Collections; +import java.util.EnumMap; import java.util.HashMap; +import java.util.List; import java.util.Map; import java.util.Set; -import java.util.TreeMap; import java.util.function.Supplier; import java.util.stream.Collectors; import tech.pegasys.teku.ethereum.executionclient.ExecutionEngineClient; @@ -29,21 +31,25 @@ import tech.pegasys.teku.ethereum.executionclient.methods.EngineForkChoiceUpdatedV1; import tech.pegasys.teku.ethereum.executionclient.methods.EngineForkChoiceUpdatedV2; import tech.pegasys.teku.ethereum.executionclient.methods.EngineForkChoiceUpdatedV3; +import tech.pegasys.teku.ethereum.executionclient.methods.EngineForkChoiceUpdatedV4; +import tech.pegasys.teku.ethereum.executionclient.methods.EngineGetBlobsV1; import tech.pegasys.teku.ethereum.executionclient.methods.EngineGetPayloadV1; import tech.pegasys.teku.ethereum.executionclient.methods.EngineGetPayloadV2; import tech.pegasys.teku.ethereum.executionclient.methods.EngineGetPayloadV3; +import tech.pegasys.teku.ethereum.executionclient.methods.EngineGetPayloadV4; import tech.pegasys.teku.ethereum.executionclient.methods.EngineJsonRpcMethod; import tech.pegasys.teku.ethereum.executionclient.methods.EngineNewPayloadV1; import tech.pegasys.teku.ethereum.executionclient.methods.EngineNewPayloadV2; import tech.pegasys.teku.ethereum.executionclient.methods.EngineNewPayloadV3; +import tech.pegasys.teku.ethereum.executionclient.methods.EngineNewPayloadV4; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.datastructures.util.ForkAndSpecMilestone; public class MilestoneBasedEngineJsonRpcMethodsResolver implements EngineJsonRpcMethodsResolver { - private final Map>> - methodsByMilestone = new TreeMap<>(); + private final EnumMap>> + methodsByMilestone = new EnumMap<>(SpecMilestone.class); private final Spec spec; private final ExecutionEngineClient executionEngineClient; @@ -71,9 +77,8 @@ public MilestoneBasedEngineJsonRpcMethodsResolver( case DENEB: methodsByMilestone.put(milestone, denebSupportedMethods()); break; - case EIP7594: - // not changed - methodsByMilestone.put(milestone, denebSupportedMethods()); + case ELECTRA, FULU: + methodsByMilestone.put(milestone, electraSupportedMethods()); break; } }); @@ -105,6 +110,18 @@ private Map> denebSupportedMethods() { methods.put(ENGINE_NEW_PAYLOAD, new EngineNewPayloadV3(executionEngineClient)); methods.put(ENGINE_GET_PAYLOAD, new EngineGetPayloadV3(executionEngineClient, spec)); methods.put(ENGINE_FORK_CHOICE_UPDATED, new EngineForkChoiceUpdatedV3(executionEngineClient)); + methods.put(ENGINE_GET_BLOBS, new EngineGetBlobsV1(executionEngineClient, spec)); + + return methods; + } + + private Map> electraSupportedMethods() { + final Map> methods = new HashMap<>(); + + methods.put(ENGINE_NEW_PAYLOAD, new EngineNewPayloadV4(executionEngineClient)); + methods.put(ENGINE_GET_PAYLOAD, new EngineGetPayloadV4(executionEngineClient, spec)); + methods.put(ENGINE_FORK_CHOICE_UPDATED, new EngineForkChoiceUpdatedV4(executionEngineClient)); + methods.put(ENGINE_GET_BLOBS, new EngineGetBlobsV1(executionEngineClient, spec)); return methods; } @@ -127,10 +144,39 @@ public EngineJsonRpcMethod getMethod( return foundMethod; } + @Override + @SuppressWarnings({"unchecked", "unused"}) + public EngineJsonRpcMethod> getListMethod( + final EngineApiMethod method, + final Supplier milestoneSupplier, + final Class resultType) { + final SpecMilestone milestone = milestoneSupplier.get(); + final Map> milestoneMethods = + methodsByMilestone.getOrDefault(milestone, Collections.emptyMap()); + final EngineJsonRpcMethod> foundMethod = + (EngineJsonRpcMethod>) milestoneMethods.get(method); + if (foundMethod == null) { + throw new IllegalArgumentException( + "Can't find method with name " + method.getName() + " for milestone " + milestone); + } + return foundMethod; + } + @Override public Set getCapabilities() { return methodsByMilestone.values().stream() .flatMap(methods -> methods.values().stream()) + .filter(method -> !method.isOptional()) + .filter(method -> !method.isDeprecated()) + .map(EngineJsonRpcMethod::getVersionedName) + .collect(Collectors.toSet()); + } + + @Override + public Set getOptionalCapabilities() { + return methodsByMilestone.values().stream() + .flatMap(methods -> methods.values().stream()) + .filter(EngineJsonRpcMethod::isOptional) .filter(method -> !method.isDeprecated()) .map(EngineJsonRpcMethod::getVersionedName) .collect(Collectors.toSet()); diff --git a/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/BellatrixExecutionClientHandlerTest.java b/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/BellatrixExecutionClientHandlerTest.java index 96e11434079..b97c46c29d5 100644 --- a/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/BellatrixExecutionClientHandlerTest.java +++ b/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/BellatrixExecutionClientHandlerTest.java @@ -13,6 +13,7 @@ package tech.pegasys.teku.ethereum.executionlayer; +import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -30,10 +31,12 @@ import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadContext; +import tech.pegasys.teku.spec.datastructures.execution.GetPayloadResponse; import tech.pegasys.teku.spec.datastructures.execution.NewPayloadRequest; import tech.pegasys.teku.spec.executionlayer.ExecutionPayloadStatus; import tech.pegasys.teku.spec.executionlayer.ForkChoiceState; import tech.pegasys.teku.spec.executionlayer.PayloadBuildingAttributes; +import tech.pegasys.teku.spec.executionlayer.PayloadStatus; import tech.pegasys.teku.spec.util.DataStructureUtil; class BellatrixExecutionClientHandlerTest extends ExecutionHandlerClientTest { @@ -43,7 +46,6 @@ void setup() { dataStructureUtil = new DataStructureUtil(spec); } - @SuppressWarnings("FutureReturnValueIgnored") @Test void engineGetPayload_shouldCallGetPayloadV1() { final ExecutionClientHandler handler = getHandler(); @@ -54,35 +56,36 @@ void engineGetPayload_shouldCallGetPayloadV1() { dataStructureUtil.randomForkChoiceState(false), dataStructureUtil.randomPayloadBuildingAttributes(false)); + final ExecutionPayload executionPayload = dataStructureUtil.randomExecutionPayload(); + final ExecutionPayloadV1 responseData = + ExecutionPayloadV1.fromInternalExecutionPayload(executionPayload); final SafeFuture> dummyResponse = - SafeFuture.completedFuture( - new Response<>( - ExecutionPayloadV1.fromInternalExecutionPayload( - dataStructureUtil.randomExecutionPayload()))); + SafeFuture.completedFuture(new Response<>(responseData)); when(executionEngineClient.getPayloadV1(context.getPayloadId())).thenReturn(dummyResponse); - handler.engineGetPayload(context, slot); + final SafeFuture future = handler.engineGetPayload(context, slot); verify(executionEngineClient).getPayloadV1(context.getPayloadId()); + assertThat(future).isCompletedWithValue(new GetPayloadResponse(executionPayload)); } - @SuppressWarnings("FutureReturnValueIgnored") @Test void engineNewPayload_shouldCallNewPayloadV1() { final ExecutionClientHandler handler = getHandler(); final ExecutionPayload payload = dataStructureUtil.randomExecutionPayload(); final NewPayloadRequest newPayloadRequest = new NewPayloadRequest(payload); final ExecutionPayloadV1 payloadV1 = ExecutionPayloadV1.fromInternalExecutionPayload(payload); + final PayloadStatusV1 responseData = + new PayloadStatusV1( + ExecutionPayloadStatus.ACCEPTED, dataStructureUtil.randomBytes32(), null); final SafeFuture> dummyResponse = - SafeFuture.completedFuture( - new Response<>( - new PayloadStatusV1( - ExecutionPayloadStatus.ACCEPTED, dataStructureUtil.randomBytes32(), null))); + SafeFuture.completedFuture(new Response<>(responseData)); when(executionEngineClient.newPayloadV1(payloadV1)).thenReturn(dummyResponse); - handler.engineNewPayload(newPayloadRequest); + final SafeFuture future = + handler.engineNewPayload(newPayloadRequest, UInt64.ZERO); verify(executionEngineClient).newPayloadV1(payloadV1); + assertThat(future).isCompletedWithValue(responseData.asInternalExecutionPayload()); } - @SuppressWarnings("FutureReturnValueIgnored") @Test void engineForkChoiceUpdated_shouldCallEngineForkChoiceUpdatedV1() { final ExecutionClientHandler handler = getHandler(); @@ -101,16 +104,18 @@ void engineForkChoiceUpdated_shouldCallEngineForkChoiceUpdatedV1() { dataStructureUtil.randomBytes32()); final Optional payloadAttributes = PayloadAttributesV1.fromInternalPayloadBuildingAttributes(Optional.of(attributes)); + final ForkChoiceUpdatedResult responseData = + new ForkChoiceUpdatedResult( + new PayloadStatusV1( + ExecutionPayloadStatus.ACCEPTED, dataStructureUtil.randomBytes32(), ""), + dataStructureUtil.randomBytes8()); final SafeFuture> dummyResponse = - SafeFuture.completedFuture( - new Response<>( - new ForkChoiceUpdatedResult( - new PayloadStatusV1( - ExecutionPayloadStatus.ACCEPTED, dataStructureUtil.randomBytes32(), ""), - dataStructureUtil.randomBytes8()))); + SafeFuture.completedFuture(new Response<>(responseData)); when(executionEngineClient.forkChoiceUpdatedV1(forkChoiceStateV1, payloadAttributes)) .thenReturn(dummyResponse); - handler.engineForkChoiceUpdated(forkChoiceState, Optional.of(attributes)); + final SafeFuture future = + handler.engineForkChoiceUpdated(forkChoiceState, Optional.of(attributes)); verify(executionEngineClient).forkChoiceUpdatedV1(forkChoiceStateV1, payloadAttributes); + assertThat(future).isCompletedWithValue(responseData.asInternalExecutionPayload()); } } diff --git a/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/BuilderBidValidatorTest.java b/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/BuilderBidValidatorTest.java index 9f637c91f55..c858ff89295 100644 --- a/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/BuilderBidValidatorTest.java +++ b/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/BuilderBidValidatorTest.java @@ -209,7 +209,8 @@ void shouldLogEventIfGasLimitDoesNotIncrease() throws BuilderBidValidationExcept private void prepareValidSignedBuilderBid() { final BLSKeyPair keyPair = BLSTestUtil.randomKeyPair(1); - final BuilderBid builderBid = dataStructureUtil.randomBuilderBid(keyPair.getPublicKey()); + final BuilderBid builderBid = + dataStructureUtil.randomBuilderBid(builder -> builder.publicKey(keyPair.getPublicKey())); final Bytes signingRoot = spec.computeBuilderApplicationSigningRoot(state.getSlot(), builderBid); @@ -224,7 +225,7 @@ private void prepareValidSignedBuilderBid() { } private void prepareGasLimit( - UInt64 parentGasLimit, UInt64 proposedGasLimit, UInt64 preferredGasLimit) { + final UInt64 parentGasLimit, final UInt64 proposedGasLimit, final UInt64 preferredGasLimit) { UInt64 slot = dataStructureUtil.randomUInt64(); @@ -274,7 +275,7 @@ private void prepareGasLimit( } private ExecutionPayloadHeader createExecutionPayloadHeaderWithGasLimit( - SchemaDefinitionsBellatrix schemaDefinitions, UInt64 gasLimit) { + final SchemaDefinitionsBellatrix schemaDefinitions, final UInt64 gasLimit) { return schemaDefinitions .getExecutionPayloadHeaderSchema() .createExecutionPayloadHeader( diff --git a/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/CapellaExecutionClientHandlerTest.java b/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/CapellaExecutionClientHandlerTest.java index 3b20b22790d..a8ef2d41953 100644 --- a/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/CapellaExecutionClientHandlerTest.java +++ b/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/CapellaExecutionClientHandlerTest.java @@ -19,7 +19,6 @@ import java.util.List; import java.util.Optional; -import java.util.concurrent.ExecutionException; import org.apache.tuweni.units.bigints.UInt256; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -35,13 +34,14 @@ import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadContext; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSchema; import tech.pegasys.teku.spec.datastructures.execution.GetPayloadResponse; import tech.pegasys.teku.spec.datastructures.execution.NewPayloadRequest; -import tech.pegasys.teku.spec.datastructures.execution.versions.capella.ExecutionPayloadCapella; import tech.pegasys.teku.spec.executionlayer.ExecutionPayloadStatus; import tech.pegasys.teku.spec.executionlayer.ForkChoiceState; import tech.pegasys.teku.spec.executionlayer.PayloadBuildingAttributes; import tech.pegasys.teku.spec.executionlayer.PayloadStatus; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsCapella; import tech.pegasys.teku.spec.util.DataStructureUtil; public class CapellaExecutionClientHandlerTest extends ExecutionHandlerClientTest { @@ -53,7 +53,7 @@ void setup() { } @Test - void engineGetPayload_shouldCallGetPayloadV2() throws ExecutionException, InterruptedException { + void engineGetPayload_shouldCallGetPayloadV2() { final ExecutionClientHandler handler = getHandler(); final UInt64 slot = dataStructureUtil.randomUInt64(1_000_000); final ExecutionPayloadContext context = @@ -62,19 +62,23 @@ void engineGetPayload_shouldCallGetPayloadV2() throws ExecutionException, Interr dataStructureUtil.randomForkChoiceState(false), dataStructureUtil.randomPayloadBuildingAttributes(false)); + final GetPayloadV2Response responseData = + new GetPayloadV2Response( + ExecutionPayloadV2.fromInternalExecutionPayload( + dataStructureUtil.randomExecutionPayload()), + UInt256.MAX_VALUE); final SafeFuture> dummyResponse = - SafeFuture.completedFuture( - new Response<>( - new GetPayloadV2Response( - ExecutionPayloadV2.fromInternalExecutionPayload( - dataStructureUtil.randomExecutionPayload()), - UInt256.MAX_VALUE))); + SafeFuture.completedFuture(new Response<>(responseData)); when(executionEngineClient.getPayloadV2(context.getPayloadId())).thenReturn(dummyResponse); final SafeFuture future = handler.engineGetPayload(context, slot); verify(executionEngineClient).getPayloadV2(context.getPayloadId()); - assertThat(future).isCompleted(); - assertThat(future.get().getExecutionPayload()).isInstanceOf(ExecutionPayloadCapella.class); + final SchemaDefinitionsCapella schemaDefinitionCapella = + spec.atSlot(slot).getSchemaDefinitions().toVersionCapella().orElseThrow(); + final ExecutionPayloadSchema executionPayloadSchema = + schemaDefinitionCapella.getExecutionPayloadSchema(); + assertThat(future) + .isCompletedWithValue(responseData.asInternalGetPayloadResponse(executionPayloadSchema)); } @Test @@ -83,15 +87,16 @@ void engineNewPayload_shouldCallNewPayloadV2() { final ExecutionPayload payload = dataStructureUtil.randomExecutionPayload(); final NewPayloadRequest newPayloadRequest = new NewPayloadRequest(payload); final ExecutionPayloadV2 payloadV2 = ExecutionPayloadV2.fromInternalExecutionPayload(payload); + final PayloadStatusV1 responseData = + new PayloadStatusV1( + ExecutionPayloadStatus.ACCEPTED, dataStructureUtil.randomBytes32(), null); final SafeFuture> dummyResponse = - SafeFuture.completedFuture( - new Response<>( - new PayloadStatusV1( - ExecutionPayloadStatus.ACCEPTED, dataStructureUtil.randomBytes32(), null))); + SafeFuture.completedFuture(new Response<>(responseData)); when(executionEngineClient.newPayloadV2(payloadV2)).thenReturn(dummyResponse); - final SafeFuture future = handler.engineNewPayload(newPayloadRequest); + final SafeFuture future = + handler.engineNewPayload(newPayloadRequest, UInt64.ZERO); verify(executionEngineClient).newPayloadV2(payloadV2); - assertThat(future).isCompleted(); + assertThat(future).isCompletedWithValue(responseData.asInternalExecutionPayload()); } @Test @@ -100,19 +105,19 @@ void engineForkChoiceUpdated_shouldCallEngineForkChoiceUpdatedV2() { final ForkChoiceState forkChoiceState = dataStructureUtil.randomForkChoiceState(false); final ForkChoiceStateV1 forkChoiceStateV1 = ForkChoiceStateV1.fromInternalForkChoiceState(forkChoiceState); + final ForkChoiceUpdatedResult responseData = + new ForkChoiceUpdatedResult( + new PayloadStatusV1( + ExecutionPayloadStatus.ACCEPTED, dataStructureUtil.randomBytes32(), ""), + dataStructureUtil.randomBytes8()); final SafeFuture> dummyResponse = - SafeFuture.completedFuture( - new Response<>( - new ForkChoiceUpdatedResult( - new PayloadStatusV1( - ExecutionPayloadStatus.ACCEPTED, dataStructureUtil.randomBytes32(), ""), - dataStructureUtil.randomBytes8()))); + SafeFuture.completedFuture(new Response<>(responseData)); when(executionEngineClient.forkChoiceUpdatedV2(forkChoiceStateV1, Optional.empty())) .thenReturn(dummyResponse); final SafeFuture future = handler.engineForkChoiceUpdated(forkChoiceState, Optional.empty()); verify(executionEngineClient).forkChoiceUpdatedV2(forkChoiceStateV1, Optional.empty()); - assertThat(future).isCompleted(); + assertThat(future).isCompletedWithValue(responseData.asInternalExecutionPayload()); } @Test @@ -140,18 +145,18 @@ void engineForkChoiceUpdatedBuildingBlockOnForkTransition_shouldCallEngineForkCh capellaStartSlot.minusMinZero(1), dataStructureUtil.randomBytes32(), false); final ForkChoiceStateV1 forkChoiceStateV1 = ForkChoiceStateV1.fromInternalForkChoiceState(forkChoiceState); + final ForkChoiceUpdatedResult responseData = + new ForkChoiceUpdatedResult( + new PayloadStatusV1( + ExecutionPayloadStatus.ACCEPTED, dataStructureUtil.randomBytes32(), ""), + dataStructureUtil.randomBytes8()); final SafeFuture> dummyResponse = - SafeFuture.completedFuture( - new Response<>( - new ForkChoiceUpdatedResult( - new PayloadStatusV1( - ExecutionPayloadStatus.ACCEPTED, dataStructureUtil.randomBytes32(), ""), - dataStructureUtil.randomBytes8()))); + SafeFuture.completedFuture(new Response<>(responseData)); when(executionEngineClient.forkChoiceUpdatedV2(forkChoiceStateV1, payloadAttributes)) .thenReturn(dummyResponse); final SafeFuture future = handler.engineForkChoiceUpdated(forkChoiceState, Optional.of(attributes)); verify(executionEngineClient).forkChoiceUpdatedV2(forkChoiceStateV1, payloadAttributes); - assertThat(future).isCompleted(); + assertThat(future).isCompletedWithValue(responseData.asInternalExecutionPayload()); } } diff --git a/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/DenebExecutionClientHandlerTest.java b/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/DenebExecutionClientHandlerTest.java index af50e6cecfe..e65dce90a49 100644 --- a/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/DenebExecutionClientHandlerTest.java +++ b/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/DenebExecutionClientHandlerTest.java @@ -19,11 +19,11 @@ import java.util.List; import java.util.Optional; -import java.util.concurrent.ExecutionException; import org.apache.tuweni.bytes.Bytes32; import org.apache.tuweni.units.bigints.UInt256; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import tech.pegasys.teku.ethereum.executionclient.schema.BlobAndProofV1; import tech.pegasys.teku.ethereum.executionclient.schema.BlobsBundleV1; import tech.pegasys.teku.ethereum.executionclient.schema.ExecutionPayloadV3; import tech.pegasys.teku.ethereum.executionclient.schema.ForkChoiceStateV1; @@ -35,16 +35,21 @@ import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.config.SpecConfigDeneb; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSchema; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; +import tech.pegasys.teku.spec.datastructures.execution.BlobAndProof; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadContext; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSchema; import tech.pegasys.teku.spec.datastructures.execution.GetPayloadResponse; import tech.pegasys.teku.spec.datastructures.execution.NewPayloadRequest; -import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadDeneb; import tech.pegasys.teku.spec.executionlayer.ExecutionPayloadStatus; import tech.pegasys.teku.spec.executionlayer.ForkChoiceState; import tech.pegasys.teku.spec.executionlayer.PayloadBuildingAttributes; import tech.pegasys.teku.spec.executionlayer.PayloadStatus; import tech.pegasys.teku.spec.logic.versions.deneb.types.VersionedHash; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsDeneb; import tech.pegasys.teku.spec.util.DataStructureUtil; public class DenebExecutionClientHandlerTest extends ExecutionHandlerClientTest { @@ -56,28 +61,31 @@ void setup() { } @Test - void engineGetPayload_shouldCallGetPayloadV3() throws ExecutionException, InterruptedException { + void engineGetPayload_shouldCallGetPayloadV3() { final ExecutionClientHandler handler = getHandler(); final ExecutionPayloadContext context = randomContext(); + final GetPayloadV3Response responseData = + new GetPayloadV3Response( + ExecutionPayloadV3.fromInternalExecutionPayload( + dataStructureUtil.randomExecutionPayload()), + UInt256.MAX_VALUE, + BlobsBundleV1.fromInternalBlobsBundle(dataStructureUtil.randomBlobsBundle()), + true); final SafeFuture> dummyResponse = - SafeFuture.completedFuture( - new Response<>( - new GetPayloadV3Response( - ExecutionPayloadV3.fromInternalExecutionPayload( - dataStructureUtil.randomExecutionPayload()), - UInt256.MAX_VALUE, - BlobsBundleV1.fromInternalBlobsBundle(dataStructureUtil.randomBlobsBundle()), - true))); + SafeFuture.completedFuture(new Response<>(responseData)); when(executionEngineClient.getPayloadV3(context.getPayloadId())).thenReturn(dummyResponse); final UInt64 slot = dataStructureUtil.randomUInt64(1_000_000); final SafeFuture future = handler.engineGetPayload(context, slot); verify(executionEngineClient).getPayloadV3(context.getPayloadId()); - assertThat(future).isCompleted(); - assertThat(future.get().getExecutionPayload()).isInstanceOf(ExecutionPayloadDeneb.class); - assertThat(future.get().getExecutionPayloadValue()).isEqualTo(UInt256.MAX_VALUE); - assertThat(future.get().getBlobsBundle()).isPresent(); - assertThat(future.get().getShouldOverrideBuilder()).isTrue(); + final SchemaDefinitionsDeneb schemaDefinitionDeneb = + spec.atSlot(slot).getSchemaDefinitions().toVersionDeneb().orElseThrow(); + final ExecutionPayloadSchema executionPayloadSchema = + schemaDefinitionDeneb.getExecutionPayloadSchema(); + final BlobSchema blobSchema = schemaDefinitionDeneb.getBlobSchema(); + assertThat(future) + .isCompletedWithValue( + responseData.asInternalGetPayloadResponse(executionPayloadSchema, blobSchema)); } @Test @@ -89,16 +97,17 @@ void engineNewPayload_shouldCallNewPayloadV3() { final NewPayloadRequest newPayloadRequest = new NewPayloadRequest(payload, versionedHashes, parentBeaconBlockRoot); final ExecutionPayloadV3 payloadV3 = ExecutionPayloadV3.fromInternalExecutionPayload(payload); + final PayloadStatusV1 responseData = + new PayloadStatusV1( + ExecutionPayloadStatus.ACCEPTED, dataStructureUtil.randomBytes32(), null); final SafeFuture> dummyResponse = - SafeFuture.completedFuture( - new Response<>( - new PayloadStatusV1( - ExecutionPayloadStatus.ACCEPTED, dataStructureUtil.randomBytes32(), null))); + SafeFuture.completedFuture(new Response<>(responseData)); when(executionEngineClient.newPayloadV3(payloadV3, versionedHashes, parentBeaconBlockRoot)) .thenReturn(dummyResponse); - final SafeFuture future = handler.engineNewPayload(newPayloadRequest); + final SafeFuture future = + handler.engineNewPayload(newPayloadRequest, UInt64.ZERO); verify(executionEngineClient).newPayloadV3(payloadV3, versionedHashes, parentBeaconBlockRoot); - assertThat(future).isCompleted(); + assertThat(future).isCompletedWithValue(responseData.asInternalExecutionPayload()); } @Test @@ -119,19 +128,50 @@ void engineForkChoiceUpdated_shouldCallEngineForkChoiceUpdatedV3() { dataStructureUtil.randomBytes32()); final Optional payloadAttributes = PayloadAttributesV3.fromInternalPayloadBuildingAttributesV3(Optional.of(attributes)); + final ForkChoiceUpdatedResult responseData = + new ForkChoiceUpdatedResult( + new PayloadStatusV1( + ExecutionPayloadStatus.ACCEPTED, dataStructureUtil.randomBytes32(), ""), + dataStructureUtil.randomBytes8()); final SafeFuture> dummyResponse = - SafeFuture.completedFuture( - new Response<>( - new ForkChoiceUpdatedResult( - new PayloadStatusV1( - ExecutionPayloadStatus.ACCEPTED, dataStructureUtil.randomBytes32(), ""), - dataStructureUtil.randomBytes8()))); + SafeFuture.completedFuture(new Response<>(responseData)); when(executionEngineClient.forkChoiceUpdatedV3(forkChoiceStateV1, payloadAttributes)) .thenReturn(dummyResponse); final SafeFuture future = handler.engineForkChoiceUpdated(forkChoiceState, Optional.of(attributes)); verify(executionEngineClient).forkChoiceUpdatedV3(forkChoiceStateV1, payloadAttributes); - assertThat(future).isCompleted(); + assertThat(future).isCompletedWithValue(responseData.asInternalExecutionPayload()); + } + + @Test + void engineGetBlobs_shouldCallGetBlobsV1() { + final ExecutionClientHandler handler = getHandler(); + final int maxBlobsPerBlock = + SpecConfigDeneb.required(spec.getGenesisSpecConfig()).getMaxBlobsPerBlock(); + final List versionedHashes = + dataStructureUtil.randomVersionedHashes(maxBlobsPerBlock - 1); + final List blobSidecars = dataStructureUtil.randomBlobSidecars(maxBlobsPerBlock); + final UInt64 slot = dataStructureUtil.randomUInt64(1_000_000); + final List responseData = + blobSidecars.stream() + .map( + blobSidecar -> + new BlobAndProofV1( + blobSidecar.getBlob().getBytes(), + blobSidecar.getKZGProof().getBytesCompressed())) + .toList(); + final SafeFuture>> dummyResponse = + SafeFuture.completedFuture(new Response<>(responseData)); + when(executionEngineClient.getBlobsV1(versionedHashes)).thenReturn(dummyResponse); + final SafeFuture> future = handler.engineGetBlobs(versionedHashes, slot); + verify(executionEngineClient).getBlobsV1(versionedHashes); + final BlobSchema blobSchema = + spec.atSlot(slot).getSchemaDefinitions().toVersionDeneb().orElseThrow().getBlobSchema(); + assertThat(future) + .isCompletedWithValue( + responseData.stream() + .map(blobAndProofV1 -> blobAndProofV1.asInternalBlobsAndProofs(blobSchema)) + .toList()); } private ExecutionPayloadContext randomContext() { diff --git a/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/ElectraExecutionClientHandlerTest.java b/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/ElectraExecutionClientHandlerTest.java new file mode 100644 index 00000000000..122d203b86d --- /dev/null +++ b/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/ElectraExecutionClientHandlerTest.java @@ -0,0 +1,203 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.ethereum.executionlayer; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.util.List; +import java.util.Optional; +import org.apache.tuweni.bytes.Bytes; +import org.apache.tuweni.bytes.Bytes32; +import org.apache.tuweni.units.bigints.UInt256; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.ethereum.executionclient.schema.BlobAndProofV1; +import tech.pegasys.teku.ethereum.executionclient.schema.BlobsBundleV1; +import tech.pegasys.teku.ethereum.executionclient.schema.ExecutionPayloadV3; +import tech.pegasys.teku.ethereum.executionclient.schema.ForkChoiceStateV1; +import tech.pegasys.teku.ethereum.executionclient.schema.ForkChoiceUpdatedResult; +import tech.pegasys.teku.ethereum.executionclient.schema.GetPayloadV4Response; +import tech.pegasys.teku.ethereum.executionclient.schema.PayloadAttributesV4; +import tech.pegasys.teku.ethereum.executionclient.schema.PayloadStatusV1; +import tech.pegasys.teku.ethereum.executionclient.schema.Response; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.config.SpecConfigDeneb; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSchema; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; +import tech.pegasys.teku.spec.datastructures.execution.BlobAndProof; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadContext; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSchema; +import tech.pegasys.teku.spec.datastructures.execution.GetPayloadResponse; +import tech.pegasys.teku.spec.datastructures.execution.NewPayloadRequest; +import tech.pegasys.teku.spec.executionlayer.ExecutionPayloadStatus; +import tech.pegasys.teku.spec.executionlayer.ForkChoiceState; +import tech.pegasys.teku.spec.executionlayer.PayloadBuildingAttributes; +import tech.pegasys.teku.spec.executionlayer.PayloadStatus; +import tech.pegasys.teku.spec.logic.versions.deneb.types.VersionedHash; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +public class ElectraExecutionClientHandlerTest extends ExecutionHandlerClientTest { + + @BeforeEach + void setup() { + spec = TestSpecFactory.createMinimalElectra(); + dataStructureUtil = new DataStructureUtil(spec); + } + + @Test + void engineGetPayload_shouldCallGetPayloadV4() { + final ExecutionClientHandler handler = getHandler(); + final ExecutionPayloadContext context = randomContext(); + final GetPayloadV4Response responseData = + new GetPayloadV4Response( + ExecutionPayloadV3.fromInternalExecutionPayload( + dataStructureUtil.randomExecutionPayload()), + UInt256.MAX_VALUE, + BlobsBundleV1.fromInternalBlobsBundle(dataStructureUtil.randomBlobsBundle()), + true, + dataStructureUtil.randomEncodedExecutionRequests()); + final SafeFuture> dummyResponse = + SafeFuture.completedFuture(new Response<>(responseData)); + when(executionEngineClient.getPayloadV4(context.getPayloadId())).thenReturn(dummyResponse); + + final UInt64 slot = dataStructureUtil.randomUInt64(1_000_000); + final SafeFuture future = handler.engineGetPayload(context, slot); + verify(executionEngineClient).getPayloadV4(context.getPayloadId()); + final SchemaDefinitionsElectra schemaDefinitionElectra = + spec.atSlot(slot).getSchemaDefinitions().toVersionElectra().orElseThrow(); + final ExecutionPayloadSchema executionPayloadSchema = + schemaDefinitionElectra.getExecutionPayloadSchema(); + final BlobSchema blobSchema = schemaDefinitionElectra.getBlobSchema(); + final GetPayloadResponse expectedGetPayloadResponse = + responseData.asInternalGetPayloadResponse( + executionPayloadSchema, + blobSchema, + schemaDefinitionElectra.getExecutionRequestsSchema()); + assertThat(future).isCompletedWithValue(expectedGetPayloadResponse); + } + + @Test + void engineNewPayload_shouldCallNewPayloadV4() { + final ExecutionClientHandler handler = getHandler(); + final ExecutionPayload payload = dataStructureUtil.randomExecutionPayload(); + final List versionedHashes = dataStructureUtil.randomVersionedHashes(3); + final Bytes32 parentBeaconBlockRoot = dataStructureUtil.randomBytes32(); + final List encodedExecutionRequests = dataStructureUtil.randomEncodedExecutionRequests(); + final NewPayloadRequest newPayloadRequest = + new NewPayloadRequest( + payload, versionedHashes, parentBeaconBlockRoot, encodedExecutionRequests); + final ExecutionPayloadV3 payloadV3 = ExecutionPayloadV3.fromInternalExecutionPayload(payload); + final PayloadStatusV1 responseData = + new PayloadStatusV1( + ExecutionPayloadStatus.ACCEPTED, dataStructureUtil.randomBytes32(), null); + final SafeFuture> dummyResponse = + SafeFuture.completedFuture(new Response<>(responseData)); + when(executionEngineClient.newPayloadV4( + eq(payloadV3), + eq(versionedHashes), + eq(parentBeaconBlockRoot), + eq(encodedExecutionRequests))) + .thenReturn(dummyResponse); + final SafeFuture future = + handler.engineNewPayload(newPayloadRequest, UInt64.ZERO); + verify(executionEngineClient) + .newPayloadV4( + eq(payloadV3), + eq(versionedHashes), + eq(parentBeaconBlockRoot), + eq(encodedExecutionRequests)); + assertThat(future).isCompletedWithValue(responseData.asInternalExecutionPayload()); + } + + @Test + void engineForkChoiceUpdated_shouldCallEngineForkChoiceUpdatedV4() { + final ExecutionClientHandler handler = getHandler(); + final ForkChoiceState forkChoiceState = dataStructureUtil.randomForkChoiceState(false); + final ForkChoiceStateV1 forkChoiceStateV1 = + ForkChoiceStateV1.fromInternalForkChoiceState(forkChoiceState); + final SpecConfigDeneb specConfigDeneb = SpecConfigDeneb.required(spec.getGenesisSpecConfig()); + final PayloadBuildingAttributes attributes = + new PayloadBuildingAttributes( + dataStructureUtil.randomUInt64(), + dataStructureUtil.randomUInt64(), + dataStructureUtil.randomUInt64(), + dataStructureUtil.randomBytes32(), + dataStructureUtil.randomEth1Address(), + Optional.empty(), + Optional.of(List.of()), + dataStructureUtil.randomBytes32(), + Optional.of(UInt64.valueOf(specConfigDeneb.getTargetBlobsPerBlock())), + Optional.of(UInt64.valueOf(specConfigDeneb.getMaxBlobsPerBlock()))); + final Optional payloadAttributes = + PayloadAttributesV4.fromInternalPayloadBuildingAttributesV4(Optional.of(attributes)); + final ForkChoiceUpdatedResult responseData = + new ForkChoiceUpdatedResult( + new PayloadStatusV1( + ExecutionPayloadStatus.ACCEPTED, dataStructureUtil.randomBytes32(), ""), + dataStructureUtil.randomBytes8()); + final SafeFuture> dummyResponse = + SafeFuture.completedFuture(new Response<>(responseData)); + when(executionEngineClient.forkChoiceUpdatedV4(forkChoiceStateV1, payloadAttributes)) + .thenReturn(dummyResponse); + final SafeFuture future = + handler.engineForkChoiceUpdated(forkChoiceState, Optional.of(attributes)); + verify(executionEngineClient).forkChoiceUpdatedV4(forkChoiceStateV1, payloadAttributes); + assertThat(future).isCompletedWithValue(responseData.asInternalExecutionPayload()); + } + + @Test + void engineGetBlobs_shouldCallGetBlobsV1() { + final ExecutionClientHandler handler = getHandler(); + final int maxBlobsPerBlock = + SpecConfigDeneb.required(spec.getGenesisSpecConfig()).getMaxBlobsPerBlock(); + final List versionedHashes = + dataStructureUtil.randomVersionedHashes(maxBlobsPerBlock); + final List blobSidecars = dataStructureUtil.randomBlobSidecars(maxBlobsPerBlock); + final UInt64 slot = dataStructureUtil.randomUInt64(1_000_000); + final List responseData = + blobSidecars.stream() + .map( + blobSidecar -> + new BlobAndProofV1( + blobSidecar.getBlob().getBytes(), + blobSidecar.getKZGProof().getBytesCompressed())) + .toList(); + final SafeFuture>> dummyResponse = + SafeFuture.completedFuture(new Response<>(responseData)); + when(executionEngineClient.getBlobsV1(versionedHashes)).thenReturn(dummyResponse); + final SafeFuture> future = handler.engineGetBlobs(versionedHashes, slot); + verify(executionEngineClient).getBlobsV1(versionedHashes); + final BlobSchema blobSchema = + spec.atSlot(slot).getSchemaDefinitions().toVersionDeneb().orElseThrow().getBlobSchema(); + assertThat(future) + .isCompletedWithValue( + responseData.stream() + .map(blobAndProofV1 -> blobAndProofV1.asInternalBlobsAndProofs(blobSchema)) + .toList()); + } + + private ExecutionPayloadContext randomContext() { + return new ExecutionPayloadContext( + dataStructureUtil.randomBytes8(), + dataStructureUtil.randomForkChoiceState(false), + dataStructureUtil.randomPayloadBuildingAttributes(false)); + } +} diff --git a/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/EngineCapabilitiesMonitorTest.java b/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/EngineCapabilitiesMonitorTest.java index ff4d6c5343c..9849430c6f1 100644 --- a/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/EngineCapabilitiesMonitorTest.java +++ b/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/EngineCapabilitiesMonitorTest.java @@ -25,6 +25,7 @@ import java.util.HashSet; import java.util.List; +import java.util.stream.Stream; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import tech.pegasys.teku.ethereum.executionclient.ExecutionEngineClient; @@ -43,14 +44,18 @@ public class EngineCapabilitiesMonitorTest { mock(EngineJsonRpcMethodsResolver.class); private final ExecutionEngineClient executionEngineClient = mock(ExecutionEngineClient.class); + private final List engineCapabilities = List.of("method1", "method2", "method3"); private final List capabilities = List.of("method1", "method2"); + private final List optionalCapabilities = List.of("method3"); private EngineCapabilitiesMonitor engineCapabilitiesMonitor; @BeforeEach public void setUp() { when(engineMethodsResolver.getCapabilities()).thenReturn(new HashSet<>(capabilities)); - mockEngineCapabilitiesResponse(capabilities); + when(engineMethodsResolver.getOptionalCapabilities()) + .thenReturn(new HashSet<>(optionalCapabilities)); + mockEngineCapabilitiesResponse(engineCapabilities); engineCapabilitiesMonitor = new EngineCapabilitiesMonitor( spec, eventLogger, engineMethodsResolver, executionEngineClient); @@ -64,7 +69,18 @@ public void logsWarningIfEngineDoesNotSupportCapabilities() { // 3rd slot in epoch engineCapabilitiesMonitor.onSlot(UInt64.valueOf(2)); - verify(eventLogger).missingEngineApiCapabilities(List.of("method2")); + verify(eventLogger).missingEngineApiCapabilities(List.of("method2"), false); + } + + @Test + public void logsWarningIfEngineDoesNotSupportOptionalCapabilities() { + // engine only supports one of the methods + mockEngineCapabilitiesResponse(List.of("method1", "method2")); + + // 3rd slot in epoch + engineCapabilitiesMonitor.onSlot(UInt64.valueOf(2)); + + verify(eventLogger).missingEngineApiCapabilities(List.of("method3"), true); } @Test @@ -129,7 +145,8 @@ public void doesNotRunMonitoringIfNotAtRequiredSlot() { } private void mockEngineCapabilitiesResponse(final List engineCapabilities) { - when(executionEngineClient.exchangeCapabilities(capabilities)) + when(executionEngineClient.exchangeCapabilities( + Stream.concat(capabilities.stream(), optionalCapabilities.stream()).toList())) .thenReturn(SafeFuture.completedFuture(new Response<>(engineCapabilities))); } diff --git a/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionBuilderModuleTest.java b/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionBuilderModuleTest.java index bed45538afc..2958d27e842 100644 --- a/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionBuilderModuleTest.java +++ b/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionBuilderModuleTest.java @@ -38,20 +38,16 @@ import tech.pegasys.teku.ethereum.performance.trackers.BlockProductionPerformance; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.logging.EventLogger; -import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.datastructures.builder.BuilderBid; import tech.pegasys.teku.spec.datastructures.builder.SignedBuilderBid; +import tech.pegasys.teku.spec.datastructures.execution.BuilderBidOrFallbackData; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadContext; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; import tech.pegasys.teku.spec.datastructures.execution.FallbackReason; import tech.pegasys.teku.spec.datastructures.execution.GetPayloadResponse; -import tech.pegasys.teku.spec.datastructures.execution.HeaderWithFallbackData; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; -import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; -import tech.pegasys.teku.spec.schemas.SchemaDefinitionsDeneb; import tech.pegasys.teku.spec.util.DataStructureUtil; public class ExecutionBuilderModuleTest { @@ -71,7 +67,6 @@ public class ExecutionBuilderModuleTest { private final EventLogger eventLogger = mock(EventLogger.class); private final BeaconState state = dataStructureUtil.randomBeaconState(slot); - private final SafeFuture payloadValueResult = new SafeFuture<>(); private ExecutionPayloadContext executionPayloadContext; private ExecutionBuilderModule executionBuilderModule; @@ -105,18 +100,14 @@ void builderGetHeader_shouldRespectComparisonFactors( final BuilderBid builderBid = prepareBuilderGetHeaderResponse(false, builderValue); - final SafeFuture result = + final SafeFuture result = callBuilderGetHeader(requestedComparisonFactor); if (localShouldWin) { assertGetHeaderResultFallbacksToLocal( result, localFallback, FallbackReason.LOCAL_BLOCK_VALUE_WON); - - assertThatSafeFuture(payloadValueResult).isCompletedWithValue(localValue); } else { assertGetHeaderResultIsFromBuilder(result, builderBid); - - assertThatSafeFuture(payloadValueResult).isCompletedWithValue(builderValue); } logCaptor.assertInfoLog(comparisonLogMessage); @@ -192,12 +183,11 @@ private static Stream generateComparisonFactorScenarios() { "Local execution payload (0.000000 ETH) is chosen over builder bid (333.000001 ETH) - builder compare factor: PREFER_EXECUTION, source: BN.")); } - private SafeFuture callBuilderGetHeader( + private SafeFuture callBuilderGetHeader( final Optional requestedBuilderBoostFactor) { return executionBuilderModule.builderGetHeader( executionPayloadContext, state, - payloadValueResult, requestedBuilderBoostFactor, BlockProductionPerformance.NOOP); } @@ -227,7 +217,6 @@ private void prepareExecutionBuilderModule( executionBuilderModule = new ExecutionBuilderModule( - spec, executionLayerManager, builderBidValidator, builderCircuitBreaker, @@ -242,7 +231,7 @@ private BuilderBid prepareBuilderGetHeaderResponse( final UInt64 slot = executionPayloadContext.getForkChoiceState().getHeadBlockSlot(); final BuilderBid builderBid = - dataStructureUtil.randomBuilderBid(dataStructureUtil.randomPublicKey(), builderBlockValue); + dataStructureUtil.randomBuilderBid(builder -> builder.value(builderBlockValue)); final SignedBuilderBid signedBuilderBid = dataStructureUtil.randomSignedBuilderBid(builderBid); doAnswer( @@ -265,74 +254,72 @@ private BuilderBid prepareBuilderGetHeaderResponse( } void assertGetHeaderResultIsFromBuilder( - final SafeFuture result, final BuilderBid builderBid) { + final SafeFuture result, final BuilderBid builderBid) { assertThatSafeFuture(result) .isCompletedWithValueMatching( - headerWithFallbackData -> headerWithFallbackData.getFallbackData().isEmpty(), + builderBidOrFallbackData -> builderBidOrFallbackData.getFallbackData().isEmpty(), "no fallback") .isCompletedWithValueMatching( - headerWithFallbackData -> - headerWithFallbackData.getExecutionPayloadHeader().equals(builderBid.getHeader()), + builderBidOrFallbackData -> + builderBidOrFallbackData + .getBuilderBid() + .orElseThrow() + .getHeader() + .equals(builderBid.getHeader()), "header from builder") .isCompletedWithValueMatching( - headerWithFallbackData -> - headerWithFallbackData - .getBlobKzgCommitments() + builderBidOrFallbackData -> + builderBidOrFallbackData + .getBuilderBid() + .orElseThrow() + .getOptionalBlobKzgCommitments() .equals(builderBid.getOptionalBlobKzgCommitments()), - "kzg commitments from builder"); + "kzg commitments from builder") + .isCompletedWithValueMatching( + builderBidOrFallbackData -> + builderBidOrFallbackData + .getBuilderBid() + .orElseThrow() + .getValue() + .equals(builderBid.getValue()), + "value from builder"); } void assertGetHeaderResultFallbacksToLocal( - final SafeFuture result, + final SafeFuture result, final GetPayloadResponse localFallback, final FallbackReason reason) { - final SchemaDefinitionsDeneb schemaDefinitionsDeneb = - spec.atSlot(slot).getSchemaDefinitions().toVersionDeneb().orElseThrow(); - - final ExecutionPayloadHeader executionPayloadHeader = - schemaDefinitionsDeneb - .getExecutionPayloadHeaderSchema() - .createFromExecutionPayload(localFallback.getExecutionPayload()); - final Optional> blobKzgCommitments = - localFallback - .getBlobsBundle() - .map( - blobsBundle -> - schemaDefinitionsDeneb - .getBlobKzgCommitmentsSchema() - .createFromBlobsBundle(blobsBundle)); - assertThatSafeFuture(result) .isCompletedWithValueMatching( - headerWithFallbackData -> headerWithFallbackData.getFallbackData().isPresent(), - "fallback is present") + builderBidOrFallbackData -> builderBidOrFallbackData.getBuilderBid().isEmpty(), + "no builder bid") .isCompletedWithValueMatching( - headerWithFallbackData -> - headerWithFallbackData + builderBidOrFallbackData -> + builderBidOrFallbackData .getFallbackData() .orElseThrow() .getExecutionPayload() .equals(localFallback.getExecutionPayload()), "fallback payload equals local payload") .isCompletedWithValueMatching( - headerWithFallbackData -> - headerWithFallbackData + builderBidOrFallbackData -> + builderBidOrFallbackData .getFallbackData() .orElseThrow() .getBlobsBundle() .equals(localFallback.getBlobsBundle()), "fallback bundle equals local bundle") .isCompletedWithValueMatching( - headerWithFallbackData -> - headerWithFallbackData.getFallbackData().orElseThrow().getReason().equals(reason), - "fallback reason matches") - .isCompletedWithValueMatching( - headerWithFallbackData -> - headerWithFallbackData.getExecutionPayloadHeader().equals(executionPayloadHeader), - "header from local") + builderBidOrFallbackData -> + builderBidOrFallbackData + .getFallbackData() + .orElseThrow() + .getExecutionPayloadValue() + .equals(localFallback.getExecutionPayloadValue()), + "fallback payload value equals local payload value") .isCompletedWithValueMatching( - headerWithFallbackData -> - headerWithFallbackData.getBlobKzgCommitments().equals(blobKzgCommitments), - "kzg commitments from local"); + builderBidOrFallbackData -> + builderBidOrFallbackData.getFallbackData().orElseThrow().getReason().equals(reason), + "fallback reason matches"); } } diff --git a/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionLayerBlockProductionManagerImplTest.java b/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionLayerBlockProductionManagerImplTest.java index 3a7159eccc2..6059e89dab2 100644 --- a/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionLayerBlockProductionManagerImplTest.java +++ b/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionLayerBlockProductionManagerImplTest.java @@ -39,28 +39,24 @@ import tech.pegasys.teku.infrastructure.logging.EventLogger; import tech.pegasys.teku.infrastructure.metrics.StubMetricsSystem; import tech.pegasys.teku.infrastructure.metrics.TekuMetricCategory; -import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockContainer; import tech.pegasys.teku.spec.datastructures.builder.BuilderBid; -import tech.pegasys.teku.spec.datastructures.builder.BuilderPayload; import tech.pegasys.teku.spec.datastructures.builder.ExecutionPayloadAndBlobsBundle; import tech.pegasys.teku.spec.datastructures.builder.SignedBuilderBid; import tech.pegasys.teku.spec.datastructures.execution.BlobsBundle; +import tech.pegasys.teku.spec.datastructures.execution.BuilderBidOrFallbackData; +import tech.pegasys.teku.spec.datastructures.execution.BuilderPayloadOrFallbackData; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadContext; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadResult; import tech.pegasys.teku.spec.datastructures.execution.FallbackData; import tech.pegasys.teku.spec.datastructures.execution.FallbackReason; import tech.pegasys.teku.spec.datastructures.execution.GetPayloadResponse; -import tech.pegasys.teku.spec.datastructures.execution.HeaderWithFallbackData; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; -import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; -import tech.pegasys.teku.spec.schemas.SchemaDefinitionsDeneb; import tech.pegasys.teku.spec.util.DataStructureUtil; class ExecutionLayerBlockProductionManagerImplTest { @@ -99,17 +95,9 @@ public void preDeneb_builderOffline() throws Exception { final UInt64 slot = executionPayloadContext.getForkChoiceState().getHeadBlockSlot(); final BeaconState state = dataStructureUtil.randomBeaconState(slot); - final ExecutionPayload payload = + final GetPayloadResponse getPayloadResponse = prepareEngineGetPayloadResponse(executionPayloadContext, executionPayloadValue, slot); - final ExecutionPayloadHeader header = - spec.getGenesisSpec() - .getSchemaDefinitions() - .toVersionBellatrix() - .orElseThrow() - .getExecutionPayloadHeaderSchema() - .createFromExecutionPayload(payload); - final ExecutionPayloadResult executionPayloadResult = blockProductionManager.initiateBlockProduction( executionPayloadContext, @@ -119,21 +107,20 @@ public void preDeneb_builderOffline() throws Exception { BlockProductionPerformance.NOOP); assertThat(executionPayloadResult.getExecutionPayloadContext()) .isEqualTo(executionPayloadContext); - assertThat(executionPayloadResult.getExecutionPayloadFuture()).isEmpty(); - assertThat(executionPayloadResult.getBlobsBundleFuture()).isEmpty(); - assertThat(executionPayloadResult.getExecutionPayloadValueFuture()).isPresent(); - assertThat(executionPayloadResult.getExecutionPayloadValueFuture().orElseThrow().get()) + assertThat(executionPayloadResult.getExecutionPayloadFutureFromLocalFlow()).isEmpty(); + assertThat(executionPayloadResult.getBlobsBundleFutureFromLocalFlow()).isEmpty(); + assertThat(executionPayloadResult.getExecutionPayloadValueFuture().get()) .isEqualTo(executionPayloadValue); verify(executionClientHandler).engineGetPayload(any(), any()); - // we expect local engine header as result - final HeaderWithFallbackData expectedResult = - HeaderWithFallbackData.create( - header, new FallbackData(payload, FallbackReason.BUILDER_NOT_AVAILABLE)); - final SafeFuture headerWithFallbackDataFuture = - executionPayloadResult.getHeaderWithFallbackDataFuture().orElseThrow(); - assertThat(headerWithFallbackDataFuture.get()).isEqualTo(expectedResult); - final BuilderPayload localPayload = + // we expect local builder bid as result + final BuilderBidOrFallbackData expectedResult = + BuilderBidOrFallbackData.create( + new FallbackData(getPayloadResponse, FallbackReason.BUILDER_NOT_AVAILABLE)); + final SafeFuture builderBidOrFallbackDataFuture = + executionPayloadResult.getBuilderBidOrFallbackDataFuture().orElseThrow(); + assertThat(builderBidOrFallbackDataFuture.get()).isEqualTo(expectedResult); + final FallbackData localFallback = verifyFallbackToLocalEL(slot, executionPayloadContext, expectedResult); assertThat(blockProductionManager.getCachedPayloadResult(slot)) @@ -141,11 +128,11 @@ public void preDeneb_builderOffline() throws Exception { // wrong slot assertThat(blockProductionManager.getCachedPayloadResult(slot.plus(1))).isEmpty(); - final SafeFuture unblindedPayload = + final SafeFuture unblindedPayload = blockProductionManager.getUnblindedPayload( dataStructureUtil.randomSignedBlindedBeaconBlock(slot), BlockPublishingPerformance.NOOP); - assertThat(unblindedPayload.get()).isEqualTo(localPayload); + assertThat(unblindedPayload.get().getFallbackData()).hasValue(localFallback); // wrong slot, we will hit builder client by this call final SignedBeaconBlock signedBlindedBeaconBlock = @@ -169,8 +156,7 @@ public void preDeneb_builderOnline() throws Exception { // we expect result from the builder final BuilderBid builderBid = prepareBuilderGetHeaderResponse(executionPayloadContext, false); prepareEngineGetPayloadResponse(executionPayloadContext, executionPayloadValue, slot); - final ExecutionPayloadHeader header = builderBid.getHeader(); - final HeaderWithFallbackData expectedResult = HeaderWithFallbackData.create(header); + final BuilderBidOrFallbackData expectedResult = BuilderBidOrFallbackData.create(builderBid); final ExecutionPayloadResult executionPayloadResult = blockProductionManager.initiateBlockProduction( @@ -181,14 +167,13 @@ public void preDeneb_builderOnline() throws Exception { BlockProductionPerformance.NOOP); assertThat(executionPayloadResult.getExecutionPayloadContext()) .isEqualTo(executionPayloadContext); - assertThat(executionPayloadResult.getExecutionPayloadFuture()).isEmpty(); - assertThat(executionPayloadResult.getBlobsBundleFuture()).isEmpty(); - final SafeFuture headerWithFallbackDataFuture = - executionPayloadResult.getHeaderWithFallbackDataFuture().orElseThrow(); - assertThat(headerWithFallbackDataFuture.get()).isEqualTo(expectedResult); - final SafeFuture executionPayloadValueFuture = - executionPayloadResult.getExecutionPayloadValueFuture().orElseThrow(); - assertThat(executionPayloadValueFuture.get()).isEqualTo(builderBid.getValue()); + assertThat(executionPayloadResult.getExecutionPayloadFutureFromLocalFlow()).isEmpty(); + assertThat(executionPayloadResult.getBlobsBundleFutureFromLocalFlow()).isEmpty(); + final SafeFuture builderBidOrFallbackDataFuture = + executionPayloadResult.getBuilderBidOrFallbackDataFuture().orElseThrow(); + assertThat(builderBidOrFallbackDataFuture.get()).isEqualTo(expectedResult); + assertThat(executionPayloadResult.getExecutionPayloadValueFuture().get()) + .isEqualTo(builderBid.getValue()); // we expect both builder and local engine have been called verifyBuilderCalled(slot, executionPayloadContext); @@ -203,7 +188,7 @@ public void preDeneb_builderOnline() throws Exception { assertThat( blockProductionManager.getUnblindedPayload( signedBlindedBeaconBlock, BlockPublishingPerformance.NOOP)) - .isCompletedWithValue(payload); + .isCompletedWithValue(BuilderPayloadOrFallbackData.create(payload)); // we expect both builder and local engine have been called verify(builderClient).getPayload(signedBlindedBeaconBlock); @@ -220,7 +205,7 @@ public void preDeneb_noBuilder() throws Exception { final UInt64 slot = executionPayloadContext.getForkChoiceState().getHeadBlockSlot(); final BeaconState state = dataStructureUtil.randomBeaconState(slot); - final ExecutionPayload payload = + final GetPayloadResponse getPayloadResponse = prepareEngineGetPayloadResponse(executionPayloadContext, executionPayloadValue, slot); final ExecutionPayloadResult executionPayloadResult = @@ -232,15 +217,18 @@ public void preDeneb_noBuilder() throws Exception { BlockProductionPerformance.NOOP); assertThat(executionPayloadResult.getExecutionPayloadContext()) .isEqualTo(executionPayloadContext); - assertThat(executionPayloadResult.getHeaderWithFallbackDataFuture()).isEmpty(); - assertThat(executionPayloadResult.getBlobsBundleFuture()).isEmpty(); - assertThat(executionPayloadResult.getExecutionPayloadValueFuture()).isPresent(); - assertThat(executionPayloadResult.getExecutionPayloadValueFuture().orElseThrow().get()) + assertThat(executionPayloadResult.getBuilderBidOrFallbackDataFuture()).isEmpty(); + assertThat(executionPayloadResult.getExecutionPayloadValueFuture().get()) .isEqualTo(executionPayloadValue); + // no blobs before Deneb + final Optional blobsBundle = + executionPayloadResult.getBlobsBundleFutureFromLocalFlow().orElseThrow().get(); + assertThat(blobsBundle).isEmpty(); + final ExecutionPayload executionPayload = - executionPayloadResult.getExecutionPayloadFuture().orElseThrow().get(); - assertThat(executionPayload).isEqualTo(payload); + executionPayloadResult.getExecutionPayloadFutureFromLocalFlow().orElseThrow().get(); + assertThat(executionPayload).isEqualTo(getPayloadResponse.getExecutionPayload()); assertThat(blockProductionManager.getCachedPayloadResult(slot)) .contains(executionPayloadResult); @@ -269,20 +257,8 @@ public void postDeneb_builderOffline() throws Exception { prepareEngineGetPayloadResponseWithBlobs( executionPayloadContext, executionPayloadValue, slot); - final ExecutionPayload payload = getPayloadResponse.getExecutionPayload(); - final BlobsBundle blobsBundle = getPayloadResponse.getBlobsBundle().orElseThrow(); - - final SchemaDefinitionsDeneb schemaDefinitions = - SchemaDefinitionsDeneb.required(spec.getGenesisSchemaDefinitions()); - - final ExecutionPayloadHeader header = - schemaDefinitions.getExecutionPayloadHeaderSchema().createFromExecutionPayload(payload); - - final SszList blobKzgCommitments = - schemaDefinitions.getBlobKzgCommitmentsSchema().createFromBlobsBundle(blobsBundle); - final ExecutionPayloadResult executionPayloadResult = - blockProductionManager.initiateBlockAndBlobsProduction( + blockProductionManager.initiateBlockProduction( executionPayloadContext, state, true, @@ -290,33 +266,29 @@ public void postDeneb_builderOffline() throws Exception { BlockProductionPerformance.NOOP); assertThat(executionPayloadResult.getExecutionPayloadContext()) .isEqualTo(executionPayloadContext); - assertThat(executionPayloadResult.getExecutionPayloadFuture()).isEmpty(); - assertThat(executionPayloadResult.getBlobsBundleFuture()).isEmpty(); - assertThat(executionPayloadResult.getExecutionPayloadValueFuture()).isPresent(); - assertThat(executionPayloadResult.getExecutionPayloadValueFuture().orElseThrow().get()) + assertThat(executionPayloadResult.getExecutionPayloadFutureFromLocalFlow()).isEmpty(); + assertThat(executionPayloadResult.getBlobsBundleFutureFromLocalFlow()).isEmpty(); + assertThat(executionPayloadResult.getExecutionPayloadValueFuture().get()) .isEqualTo(executionPayloadValue); - // we expect local engine header as result - final HeaderWithFallbackData expectedResult = - HeaderWithFallbackData.create( - header, - Optional.of(blobKzgCommitments), - new FallbackData( - payload, Optional.of(blobsBundle), FallbackReason.BUILDER_NOT_AVAILABLE)); - final SafeFuture headerWithFallbackDataFuture = - executionPayloadResult.getHeaderWithFallbackDataFuture().orElseThrow(); - assertThat(headerWithFallbackDataFuture.get()).isEqualTo(expectedResult); - final BuilderPayload localPayload = + // we expect local builder bid as result + final BuilderBidOrFallbackData expectedResult = + BuilderBidOrFallbackData.create( + new FallbackData(getPayloadResponse, FallbackReason.BUILDER_NOT_AVAILABLE)); + final SafeFuture builderBidOrFallbackDataFuture = + executionPayloadResult.getBuilderBidOrFallbackDataFuture().orElseThrow(); + assertThat(builderBidOrFallbackDataFuture.get()).isEqualTo(expectedResult); + final FallbackData localFallback = verifyFallbackToLocalEL(slot, executionPayloadContext, expectedResult); assertThat(blockProductionManager.getCachedPayloadResult(slot)) .contains(executionPayloadResult); - final SafeFuture unblindedPayload = + final SafeFuture unblindedPayload = blockProductionManager.getUnblindedPayload( dataStructureUtil.randomSignedBlindedBeaconBlock(slot), BlockPublishingPerformance.NOOP); - assertThat(unblindedPayload.get()).isEqualTo(localPayload); + assertThat(unblindedPayload.get().getFallbackData()).hasValue(localFallback); verifyNoMoreInteractions(builderClient); verifyNoMoreInteractions(executionClientHandler); @@ -336,12 +308,10 @@ public void postDeneb_builderOnline() throws Exception { final BuilderBid builderBid = prepareBuilderGetHeaderResponse(executionPayloadContext, false); prepareEngineGetPayloadResponseWithBlobs(executionPayloadContext, executionPayloadValue, slot); - final HeaderWithFallbackData expectedResult = - HeaderWithFallbackData.create( - builderBid.getHeader(), builderBid.getOptionalBlobKzgCommitments()); + final BuilderBidOrFallbackData expectedResult = BuilderBidOrFallbackData.create(builderBid); final ExecutionPayloadResult executionPayloadResult = - blockProductionManager.initiateBlockAndBlobsProduction( + blockProductionManager.initiateBlockProduction( executionPayloadContext, state, true, @@ -349,12 +319,12 @@ public void postDeneb_builderOnline() throws Exception { BlockProductionPerformance.NOOP); assertThat(executionPayloadResult.getExecutionPayloadContext()) .isEqualTo(executionPayloadContext); - assertThat(executionPayloadResult.getExecutionPayloadFuture()).isEmpty(); - assertThat(executionPayloadResult.getBlobsBundleFuture()).isEmpty(); + assertThat(executionPayloadResult.getExecutionPayloadFutureFromLocalFlow()).isEmpty(); + assertThat(executionPayloadResult.getBlobsBundleFutureFromLocalFlow()).isEmpty(); - final SafeFuture headerWithFallbackDataFuture = - executionPayloadResult.getHeaderWithFallbackDataFuture().orElseThrow(); - assertThat(headerWithFallbackDataFuture.get()).isEqualTo(expectedResult); + final SafeFuture builderBidOrFallbackDataFuture = + executionPayloadResult.getBuilderBidOrFallbackDataFuture().orElseThrow(); + assertThat(builderBidOrFallbackDataFuture.get()).isEqualTo(expectedResult); // we expect both builder and local engine have been called verifyBuilderCalled(slot, executionPayloadContext); @@ -370,7 +340,7 @@ public void postDeneb_builderOnline() throws Exception { assertThat( blockProductionManager.getUnblindedPayload( signedBlindedBeaconBlock, BlockPublishingPerformance.NOOP)) - .isCompletedWithValue(payloadAndBlobsBundle); + .isCompletedWithValue(BuilderPayloadOrFallbackData.create(payloadAndBlobsBundle)); // we expect both builder and local engine have been called verify(builderClient).getPayload(signedBlindedBeaconBlock); @@ -393,7 +363,7 @@ public void postDeneb_noBuilder() throws Exception { executionPayloadContext, executionPayloadValue, slot); final ExecutionPayloadResult executionPayloadResult = - blockProductionManager.initiateBlockAndBlobsProduction( + blockProductionManager.initiateBlockProduction( executionPayloadContext, state, false, @@ -401,17 +371,15 @@ public void postDeneb_noBuilder() throws Exception { BlockProductionPerformance.NOOP); assertThat(executionPayloadResult.getExecutionPayloadContext()) .isEqualTo(executionPayloadContext); - assertThat(executionPayloadResult.getHeaderWithFallbackDataFuture()).isEmpty(); - - assertThat(executionPayloadResult.getExecutionPayloadValueFuture()).isPresent(); - assertThat(executionPayloadResult.getExecutionPayloadValueFuture().orElseThrow().get()) + assertThat(executionPayloadResult.getBuilderBidOrFallbackDataFuture()).isEmpty(); + assertThat(executionPayloadResult.getExecutionPayloadValueFuture().get()) .isEqualTo(executionPayloadValue); final ExecutionPayload executionPayload = - executionPayloadResult.getExecutionPayloadFuture().orElseThrow().get(); + executionPayloadResult.getExecutionPayloadFutureFromLocalFlow().orElseThrow().get(); assertThat(executionPayload).isEqualTo(getPayloadResponse.getExecutionPayload()); final Optional blobsBundle = - executionPayloadResult.getBlobsBundleFuture().orElseThrow().get(); + executionPayloadResult.getBlobsBundleFutureFromLocalFlow().orElseThrow().get(); assertThat(blobsBundle).isEqualTo(getPayloadResponse.getBlobsBundle()); assertThat(blockProductionManager.getCachedPayloadResult(slot)) @@ -460,11 +428,11 @@ private BuilderBid prepareBuilderGetHeaderResponse( return signedBuilderBid.getMessage(); } - private BuilderPayload verifyFallbackToLocalEL( + private FallbackData verifyFallbackToLocalEL( final UInt64 slot, final ExecutionPayloadContext executionPayloadContext, - final HeaderWithFallbackData headerWithFallbackData) { - final FallbackData fallbackData = headerWithFallbackData.getFallbackData().orElseThrow(); + final BuilderBidOrFallbackData builderBidOrFallbackData) { + final FallbackData fallbackData = builderBidOrFallbackData.getFallbackData().orElseThrow(); final FallbackReason fallbackReason = fallbackData.getReason(); if (fallbackReason == FallbackReason.BUILDER_HEADER_NOT_AVAILABLE || fallbackReason == FallbackReason.BUILDER_ERROR @@ -480,37 +448,16 @@ private BuilderPayload verifyFallbackToLocalEL( final SignedBeaconBlock signedBlindedBeaconBlock = dataStructureUtil.randomSignedBlindedBeaconBlock(slot); - final BuilderPayload builderPayload = - spec.atSlot(slot) - .getSchemaDefinitions() - .toVersionDeneb() - .map( - schemaDefinitionsDeneb -> { - final tech.pegasys.teku.spec.datastructures.builder.BlobsBundle blobsBundle = - schemaDefinitionsDeneb - .getBlobsBundleSchema() - .createFromExecutionBlobsBundle( - fallbackData.getBlobsBundle().orElseThrow()); - return (BuilderPayload) - schemaDefinitionsDeneb - .getExecutionPayloadAndBlobsBundleSchema() - .create(fallbackData.getExecutionPayload(), blobsBundle); - }) - .orElseGet(fallbackData::getExecutionPayload); - // we expect result from the cached payload assertThat( executionLayerManager.builderGetPayload( signedBlindedBeaconBlock, (aSlot) -> Optional.of( - new ExecutionPayloadResult( + ExecutionPayloadResult.createForBuilderFlow( executionPayloadContext, - Optional.empty(), - Optional.empty(), - Optional.of(SafeFuture.completedFuture(headerWithFallbackData)), - Optional.empty())))) - .isCompletedWithValue(builderPayload); + SafeFuture.completedFuture(builderBidOrFallbackData))))) + .isCompletedWithValue(BuilderPayloadOrFallbackData.create(fallbackData)); // we expect no additional calls verifyNoMoreInteractions(builderClient); @@ -518,7 +465,7 @@ private BuilderPayload verifyFallbackToLocalEL( verifySourceCounter(Source.BUILDER_LOCAL_EL_FALLBACK, fallbackReason); - return builderPayload; + return fallbackData; } private ExecutionPayload prepareBuilderGetPayloadResponse( @@ -538,15 +485,15 @@ private ExecutionPayloadAndBlobsBundle prepareBuilderGetPayloadResponseWithBlobs return payloadAndBlobsBundle; } - private ExecutionPayload prepareEngineGetPayloadResponse( + private GetPayloadResponse prepareEngineGetPayloadResponse( final ExecutionPayloadContext executionPayloadContext, final UInt256 executionPayloadValue, final UInt64 slot) { - final ExecutionPayload payload = dataStructureUtil.randomExecutionPayload(); + final GetPayloadResponse getPayloadResponse = + new GetPayloadResponse(dataStructureUtil.randomExecutionPayload(), executionPayloadValue); when(executionClientHandler.engineGetPayload(executionPayloadContext, slot)) - .thenReturn( - SafeFuture.completedFuture(new GetPayloadResponse(payload, executionPayloadValue))); - return payload; + .thenReturn(SafeFuture.completedFuture(getPayloadResponse)); + return getPayloadResponse; } private GetPayloadResponse prepareEngineGetPayloadResponseWithBlobs( @@ -569,7 +516,6 @@ private ExecutionLayerManagerImpl createExecutionLayerChannelImpl( eventLogger, executionClientHandler, builderEnabled ? Optional.of(builderClient) : Optional.empty(), - spec, stubMetricsSystem, builderValidatorEnabled ? new BuilderBidValidatorImpl(spec, eventLogger) @@ -579,7 +525,8 @@ private ExecutionLayerManagerImpl createExecutionLayerChannelImpl( true); } - private void updateBuilderStatus(SafeFuture> builderClientResponse, UInt64 slot) { + private void updateBuilderStatus( + final SafeFuture> builderClientResponse, final UInt64 slot) { when(builderClient.status()).thenReturn(builderClientResponse); // trigger update of the builder status executionLayerManager.onSlot(slot); @@ -621,7 +568,7 @@ private void verifyEngineCalled( private void verifySourceCounter(final Source source, final FallbackReason reason) { final long actualCount = stubMetricsSystem - .getCounter(TekuMetricCategory.BEACON, "execution_payload_source") + .getCounter(TekuMetricCategory.BEACON, "execution_payload_source_total") .getValue(source.toString(), reason.toString()); assertThat(actualCount).isOne(); } diff --git a/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionLayerManagerImplTest.java b/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionLayerManagerImplTest.java index f6cc7ac0c7d..6dd9c84b009 100644 --- a/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionLayerManagerImplTest.java +++ b/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/ExecutionLayerManagerImplTest.java @@ -41,27 +41,27 @@ import tech.pegasys.teku.infrastructure.logging.EventLogger; import tech.pegasys.teku.infrastructure.metrics.StubMetricsSystem; import tech.pegasys.teku.infrastructure.metrics.TekuMetricCategory; -import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.config.SpecConfigDeneb; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.builder.BuilderBid; -import tech.pegasys.teku.spec.datastructures.builder.BuilderPayload; import tech.pegasys.teku.spec.datastructures.builder.SignedBuilderBid; +import tech.pegasys.teku.spec.datastructures.execution.BlobAndProof; import tech.pegasys.teku.spec.datastructures.execution.BlobsBundle; +import tech.pegasys.teku.spec.datastructures.execution.BuilderBidOrFallbackData; +import tech.pegasys.teku.spec.datastructures.execution.BuilderPayloadOrFallbackData; import tech.pegasys.teku.spec.datastructures.execution.ClientVersion; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadContext; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadResult; import tech.pegasys.teku.spec.datastructures.execution.FallbackData; import tech.pegasys.teku.spec.datastructures.execution.FallbackReason; import tech.pegasys.teku.spec.datastructures.execution.GetPayloadResponse; -import tech.pegasys.teku.spec.datastructures.execution.HeaderWithFallbackData; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; -import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; -import tech.pegasys.teku.spec.schemas.SchemaDefinitionsDeneb; +import tech.pegasys.teku.spec.logic.versions.deneb.types.VersionedHash; import tech.pegasys.teku.spec.util.DataStructureUtil; class ExecutionLayerManagerImplTest { @@ -223,24 +223,16 @@ public void builderGetHeaderGetPayload_shouldReturnHeaderAndPayloadViaBuilder() final UInt64 slot = executionPayloadContext.getForkChoiceState().getHeadBlockSlot(); final BeaconState state = dataStructureUtil.randomBeaconState(slot); - final ExecutionPayloadHeader header = + final BuilderBid builderBid = prepareBuilderGetHeaderResponse( - executionPayloadContext, false, builderExecutionPayloadValue) - .getHeader(); + executionPayloadContext, false, builderExecutionPayloadValue); prepareEngineGetPayloadResponse(executionPayloadContext, localExecutionPayloadValue, slot); - final SafeFuture blockValueResult = new SafeFuture<>(); - // we expect result from the builder assertThat( executionLayerManager.builderGetHeader( - executionPayloadContext, - state, - blockValueResult, - Optional.empty(), - BlockProductionPerformance.NOOP)) - .isCompletedWithValue(HeaderWithFallbackData.create(header)); - assertThat(blockValueResult).isCompletedWithValue(builderExecutionPayloadValue); + executionPayloadContext, state, Optional.empty(), BlockProductionPerformance.NOOP)) + .isCompletedWithValue(BuilderBidOrFallbackData.create(builderBid)); // we expect both builder and local engine have been called verifyBuilderCalled(slot, executionPayloadContext); @@ -255,7 +247,7 @@ public void builderGetHeaderGetPayload_shouldReturnHeaderAndPayloadViaBuilder() assertThat( executionLayerManager.builderGetPayload( signedBlindedBeaconBlock, (aSlot) -> Optional.empty())) - .isCompletedWithValue(payload); + .isCompletedWithValue(BuilderPayloadOrFallbackData.create(payload)); // we expect both builder and local engine have been called verify(builderClient).getPayload(signedBlindedBeaconBlock); @@ -273,24 +265,16 @@ public void builderGetHeaderGetPayload_shouldReturnHeaderAndPayloadViaBuilderWhe final UInt64 slot = executionPayloadContext.getForkChoiceState().getHeadBlockSlot(); final BeaconState state = dataStructureUtil.randomBeaconState(slot); - final ExecutionPayloadHeader header = + final BuilderBid builderBid = prepareBuilderGetHeaderResponse( - executionPayloadContext, false, builderExecutionPayloadValue) - .getHeader(); + executionPayloadContext, false, builderExecutionPayloadValue); prepareEngineFailedPayloadResponse(executionPayloadContext, slot); - final SafeFuture blockValueResult = new SafeFuture<>(); - // we expect result from the builder assertThat( executionLayerManager.builderGetHeader( - executionPayloadContext, - state, - blockValueResult, - Optional.empty(), - BlockProductionPerformance.NOOP)) - .isCompletedWithValue(HeaderWithFallbackData.create(header)); - assertThat(blockValueResult).isCompletedWithValue(builderExecutionPayloadValue); + executionPayloadContext, state, Optional.empty(), BlockProductionPerformance.NOOP)) + .isCompletedWithValue(BuilderBidOrFallbackData.create(builderBid)); // we expect both builder and local engine have been called verifyBuilderCalled(slot, executionPayloadContext); @@ -305,7 +289,7 @@ public void builderGetHeaderGetPayload_shouldReturnHeaderAndPayloadViaBuilderWhe assertThat( executionLayerManager.builderGetPayload( signedBlindedBeaconBlock, (aSlot) -> Optional.empty())) - .isCompletedWithValue(payload); + .isCompletedWithValue(BuilderPayloadOrFallbackData.create(payload)); // we expect both builder and local engine have been called verify(builderClient).getPayload(signedBlindedBeaconBlock); @@ -328,34 +312,17 @@ public void builderGetHeaderGetPayload_shouldReturnHeaderAndPayloadViaEngineWhen executionPayloadContext, false, builderExecutionPayloadValue) .getValue(); final UInt256 localValueOverride = builderValue.multiply(2); - final ExecutionPayload localExecutionPayload = - prepareEngineGetPayloadResponse(executionPayloadContext, localValueOverride, slot) - .getExecutionPayload(); - - // we expect result from the local engine - final ExecutionPayloadHeader expectedHeader = - spec.getGenesisSpec() - .getSchemaDefinitions() - .toVersionBellatrix() - .orElseThrow() - .getExecutionPayloadHeaderSchema() - .createFromExecutionPayload(localExecutionPayload); + final GetPayloadResponse getPayloadResponse = + prepareEngineGetPayloadResponse(executionPayloadContext, localValueOverride, slot); // we expect local engine header as result - final HeaderWithFallbackData expectedResult = - HeaderWithFallbackData.create( - expectedHeader, - new FallbackData(localExecutionPayload, FallbackReason.LOCAL_BLOCK_VALUE_WON)); - final SafeFuture blockValueResult = new SafeFuture<>(); + final BuilderBidOrFallbackData expectedResult = + BuilderBidOrFallbackData.create( + new FallbackData(getPayloadResponse, FallbackReason.LOCAL_BLOCK_VALUE_WON)); assertThat( executionLayerManager.builderGetHeader( - executionPayloadContext, - state, - blockValueResult, - Optional.empty(), - BlockProductionPerformance.NOOP)) + executionPayloadContext, state, Optional.empty(), BlockProductionPerformance.NOOP)) .isCompletedWithValue(expectedResult); - assertThat(blockValueResult).isCompletedWithValue(localValueOverride); verifyFallbackToLocalEL(slot, executionPayloadContext, expectedResult); } @@ -373,32 +340,17 @@ public void builderGetHeaderGetPayload_shouldReturnHeaderAndPayloadViaEngineWhen final BeaconState state = dataStructureUtil.randomBeaconState(slot); prepareBuilderGetHeaderResponse(executionPayloadContext, false, builderExecutionPayloadValue); - final ExecutionPayload payload = - prepareEngineGetPayloadResponse(executionPayloadContext, localExecutionPayloadValue, slot) - .getExecutionPayload(); - - final ExecutionPayloadHeader header = - spec.getGenesisSpec() - .getSchemaDefinitions() - .toVersionBellatrix() - .orElseThrow() - .getExecutionPayloadHeaderSchema() - .createFromExecutionPayload(payload); + final GetPayloadResponse getPayloadResponse = + prepareEngineGetPayloadResponse(executionPayloadContext, localExecutionPayloadValue, slot); // we expect local engine header as result - final HeaderWithFallbackData expectedResult = - HeaderWithFallbackData.create( - header, new FallbackData(payload, FallbackReason.BUILDER_ERROR)); - final SafeFuture blockValueResult = new SafeFuture<>(); + final BuilderBidOrFallbackData expectedResult = + BuilderBidOrFallbackData.create( + new FallbackData(getPayloadResponse, FallbackReason.BUILDER_ERROR)); assertThat( executionLayerManager.builderGetHeader( - executionPayloadContext, - state, - blockValueResult, - Optional.empty(), - BlockProductionPerformance.NOOP)) + executionPayloadContext, state, Optional.empty(), BlockProductionPerformance.NOOP)) .isCompletedWithValue(expectedResult); - assertThat(blockValueResult).isCompletedWithValue(localExecutionPayloadValue); verifyFallbackToLocalEL(slot, executionPayloadContext, expectedResult); } @@ -413,32 +365,17 @@ public void builderGetHeaderGetPayload_shouldReturnHeaderAndPayloadViaEngineOnBu final BeaconState state = dataStructureUtil.randomBeaconState(slot); prepareBuilderGetHeaderFailure(executionPayloadContext); - final ExecutionPayload payload = - prepareEngineGetPayloadResponse(executionPayloadContext, localExecutionPayloadValue, slot) - .getExecutionPayload(); - - final ExecutionPayloadHeader header = - spec.getGenesisSpec() - .getSchemaDefinitions() - .toVersionBellatrix() - .orElseThrow() - .getExecutionPayloadHeaderSchema() - .createFromExecutionPayload(payload); + final GetPayloadResponse getPayloadResponse = + prepareEngineGetPayloadResponse(executionPayloadContext, localExecutionPayloadValue, slot); // we expect local engine header as result - HeaderWithFallbackData expectedResult = - HeaderWithFallbackData.create( - header, new FallbackData(payload, FallbackReason.BUILDER_ERROR)); - final SafeFuture blockValueResult = new SafeFuture<>(); + final FallbackData fallbackData = + new FallbackData(getPayloadResponse, FallbackReason.BUILDER_ERROR); + final BuilderBidOrFallbackData expectedResult = BuilderBidOrFallbackData.create(fallbackData); assertThat( executionLayerManager.builderGetHeader( - executionPayloadContext, - state, - blockValueResult, - Optional.empty(), - BlockProductionPerformance.NOOP)) + executionPayloadContext, state, Optional.empty(), BlockProductionPerformance.NOOP)) .isCompletedWithValue(expectedResult); - assertThat(blockValueResult).isCompletedWithValue(localExecutionPayloadValue); // we expect both builder and local engine have been called verifyBuilderCalled(slot, executionPayloadContext); @@ -453,13 +390,9 @@ public void builderGetHeaderGetPayload_shouldReturnHeaderAndPayloadViaEngineOnBu signedBlindedBeaconBlock, (aSlot) -> Optional.of( - new ExecutionPayloadResult( - executionPayloadContext, - Optional.empty(), - Optional.empty(), - Optional.of(SafeFuture.completedFuture(expectedResult)), - Optional.empty())))) - .isCompletedWithValue(payload); + ExecutionPayloadResult.createForBuilderFlow( + executionPayloadContext, SafeFuture.completedFuture(expectedResult))))) + .isCompletedWithValue(BuilderPayloadOrFallbackData.create(fallbackData)); // we expect no additional calls verifyNoMoreInteractions(builderClient); @@ -483,44 +416,18 @@ public void builderGetHeaderGetPayload_shouldReturnHeaderAndPayloadViaEngineOnBu prepareBuilderGetHeaderResponse(executionPayloadContext, false, builderExecutionPayloadValue); final GetPayloadResponse getPayloadResponse = - prepareEngineGetPayloadResponse( + prepareEngineGetPayloadResponseWithBlobs( executionPayloadContext, localExecutionPayloadValue, true, slot); - // we expect result from the local engine - final ExecutionPayloadHeader expectedHeader = - spec.atSlot(slot) - .getSchemaDefinitions() - .toVersionBellatrix() - .orElseThrow() - .getExecutionPayloadHeaderSchema() - .createFromExecutionPayload(getPayloadResponse.getExecutionPayload()); - final SszList expectedBlobKzgCommitments = - spec.atSlot(slot) - .getSchemaDefinitions() - .toVersionDeneb() - .orElseThrow() - .getBlobKzgCommitmentsSchema() - .createFromBlobsBundle(getPayloadResponse.getBlobsBundle().orElseThrow()); - // we expect local engine header as result - final HeaderWithFallbackData expectedResult = - HeaderWithFallbackData.create( - expectedHeader, - Optional.of(expectedBlobKzgCommitments), + final BuilderBidOrFallbackData expectedResult = + BuilderBidOrFallbackData.create( new FallbackData( - getPayloadResponse.getExecutionPayload(), - getPayloadResponse.getBlobsBundle(), - FallbackReason.SHOULD_OVERRIDE_BUILDER_FLAG_IS_TRUE)); - final SafeFuture blockValueResult = new SafeFuture<>(); + getPayloadResponse, FallbackReason.SHOULD_OVERRIDE_BUILDER_FLAG_IS_TRUE)); assertThat( executionLayerManager.builderGetHeader( - executionPayloadContext, - state, - blockValueResult, - Optional.empty(), - BlockProductionPerformance.NOOP)) + executionPayloadContext, state, Optional.empty(), BlockProductionPerformance.NOOP)) .isCompletedWithValue(expectedResult); - assertThat(blockValueResult).isCompletedWithValue(localExecutionPayloadValue); verifyFallbackToLocalEL(slot, executionPayloadContext, expectedResult); } @@ -536,32 +443,17 @@ public void builderGetHeaderGetPayload_shouldReturnHeaderAndPayloadViaEngineOnBu final BeaconState state = dataStructureUtil.randomBeaconState(slot); prepareBuilderGetHeaderResponse(executionPayloadContext, false, builderExecutionPayloadValue); - final ExecutionPayload payload = - prepareEngineGetPayloadResponse(executionPayloadContext, localExecutionPayloadValue, slot) - .getExecutionPayload(); - - final ExecutionPayloadHeader header = - spec.getGenesisSpec() - .getSchemaDefinitions() - .toVersionBellatrix() - .orElseThrow() - .getExecutionPayloadHeaderSchema() - .createFromExecutionPayload(payload); + final GetPayloadResponse getPayloadResponse = + prepareEngineGetPayloadResponse(executionPayloadContext, localExecutionPayloadValue, slot); // we expect local engine header as result - final HeaderWithFallbackData expectedResult = - HeaderWithFallbackData.create( - header, new FallbackData(payload, FallbackReason.BUILDER_ERROR)); - final SafeFuture blockValueResult = new SafeFuture<>(); + final BuilderBidOrFallbackData expectedResult = + BuilderBidOrFallbackData.create( + new FallbackData(getPayloadResponse, FallbackReason.BUILDER_ERROR)); assertThat( executionLayerManager.builderGetHeader( - executionPayloadContext, - state, - blockValueResult, - Optional.empty(), - BlockProductionPerformance.NOOP)) + executionPayloadContext, state, Optional.empty(), BlockProductionPerformance.NOOP)) .isCompletedWithValue(expectedResult); - assertThat(blockValueResult).isCompletedWithValue(localExecutionPayloadValue); verifyFallbackToLocalEL(slot, executionPayloadContext, expectedResult); } @@ -575,32 +467,17 @@ public void builderGetHeaderGetPayload_shouldReturnHeaderAndPayloadViaEngineIfBu final UInt64 slot = executionPayloadContext.getForkChoiceState().getHeadBlockSlot(); final BeaconState state = dataStructureUtil.randomBeaconState(slot); - final ExecutionPayload payload = - prepareEngineGetPayloadResponse(executionPayloadContext, localExecutionPayloadValue, slot) - .getExecutionPayload(); - - final ExecutionPayloadHeader header = - spec.getGenesisSpec() - .getSchemaDefinitions() - .toVersionBellatrix() - .orElseThrow() - .getExecutionPayloadHeaderSchema() - .createFromExecutionPayload(payload); + final GetPayloadResponse getPayloadResponse = + prepareEngineGetPayloadResponse(executionPayloadContext, localExecutionPayloadValue, slot); // we expect local engine header as result - final HeaderWithFallbackData expectedResult = - HeaderWithFallbackData.create( - header, new FallbackData(payload, FallbackReason.BUILDER_NOT_AVAILABLE)); - final SafeFuture blockValueResult = new SafeFuture<>(); + final BuilderBidOrFallbackData expectedResult = + BuilderBidOrFallbackData.create( + new FallbackData(getPayloadResponse, FallbackReason.BUILDER_NOT_AVAILABLE)); assertThat( executionLayerManager.builderGetHeader( - executionPayloadContext, - state, - blockValueResult, - Optional.empty(), - BlockProductionPerformance.NOOP)) + executionPayloadContext, state, Optional.empty(), BlockProductionPerformance.NOOP)) .isCompletedWithValue(expectedResult); - assertThat(blockValueResult).isCompletedWithValue(localExecutionPayloadValue); verifyFallbackToLocalEL(slot, executionPayloadContext, expectedResult); } @@ -617,32 +494,17 @@ public void builderGetHeaderGetPayload_shouldReturnHeaderAndPayloadViaEngineIfBu prepareBuilderGetHeaderResponse(executionPayloadContext, true, builderExecutionPayloadValue); - final ExecutionPayload payload = - prepareEngineGetPayloadResponse(executionPayloadContext, localExecutionPayloadValue, slot) - .getExecutionPayload(); - - final ExecutionPayloadHeader header = - spec.getGenesisSpec() - .getSchemaDefinitions() - .toVersionBellatrix() - .orElseThrow() - .getExecutionPayloadHeaderSchema() - .createFromExecutionPayload(payload); + final GetPayloadResponse getPayloadResponse = + prepareEngineGetPayloadResponse(executionPayloadContext, localExecutionPayloadValue, slot); // we expect local engine header as result - final HeaderWithFallbackData expectedResult = - HeaderWithFallbackData.create( - header, new FallbackData(payload, FallbackReason.BUILDER_HEADER_NOT_AVAILABLE)); - final SafeFuture blockValueResult = new SafeFuture<>(); + final BuilderBidOrFallbackData expectedResult = + BuilderBidOrFallbackData.create( + new FallbackData(getPayloadResponse, FallbackReason.BUILDER_HEADER_NOT_AVAILABLE)); assertThat( executionLayerManager.builderGetHeader( - executionPayloadContext, - state, - blockValueResult, - Optional.empty(), - BlockProductionPerformance.NOOP)) + executionPayloadContext, state, Optional.empty(), BlockProductionPerformance.NOOP)) .isCompletedWithValue(expectedResult); - assertThat(blockValueResult).isCompletedWithValue(localExecutionPayloadValue); verifyFallbackToLocalEL(slot, executionPayloadContext, expectedResult); } @@ -657,32 +519,17 @@ public void builderGetHeaderGetPayload_shouldReturnHeaderAndPayloadViaEngineIfBu final UInt64 slot = executionPayloadContext.getForkChoiceState().getHeadBlockSlot(); final BeaconState state = dataStructureUtil.randomBeaconStatePreMerge(slot); - final ExecutionPayload payload = - prepareEngineGetPayloadResponse(executionPayloadContext, localExecutionPayloadValue, slot) - .getExecutionPayload(); - - final ExecutionPayloadHeader header = - spec.getGenesisSpec() - .getSchemaDefinitions() - .toVersionBellatrix() - .orElseThrow() - .getExecutionPayloadHeaderSchema() - .createFromExecutionPayload(payload); + final GetPayloadResponse getPayloadResponse = + prepareEngineGetPayloadResponse(executionPayloadContext, localExecutionPayloadValue, slot); // we expect local engine header as result - final HeaderWithFallbackData expectedResult = - HeaderWithFallbackData.create( - header, new FallbackData(payload, FallbackReason.TRANSITION_NOT_FINALIZED)); - final SafeFuture blockValueResult = new SafeFuture<>(); + final BuilderBidOrFallbackData expectedResult = + BuilderBidOrFallbackData.create( + new FallbackData(getPayloadResponse, FallbackReason.TRANSITION_NOT_FINALIZED)); assertThat( executionLayerManager.builderGetHeader( - executionPayloadContext, - state, - blockValueResult, - Optional.empty(), - BlockProductionPerformance.NOOP)) + executionPayloadContext, state, Optional.empty(), BlockProductionPerformance.NOOP)) .isCompletedWithValue(expectedResult); - assertThat(blockValueResult).isCompletedWithValue(localExecutionPayloadValue); verifyFallbackToLocalEL(slot, executionPayloadContext, expectedResult); } @@ -697,34 +544,19 @@ public void builderGetHeaderGetPayload_shouldReturnHeaderAndPayloadViaEngineIfBu final UInt64 slot = executionPayloadContext.getForkChoiceState().getHeadBlockSlot(); final BeaconState state = dataStructureUtil.randomBeaconState(slot); - final ExecutionPayload payload = - prepareEngineGetPayloadResponse(executionPayloadContext, localExecutionPayloadValue, slot) - .getExecutionPayload(); - - final ExecutionPayloadHeader header = - spec.getGenesisSpec() - .getSchemaDefinitions() - .toVersionBellatrix() - .orElseThrow() - .getExecutionPayloadHeaderSchema() - .createFromExecutionPayload(payload); + final GetPayloadResponse getPayloadResponse = + prepareEngineGetPayloadResponse(executionPayloadContext, localExecutionPayloadValue, slot); when(builderCircuitBreaker.isEngaged(any())).thenReturn(true); // we expect local engine header as result - final HeaderWithFallbackData expectedResult = - HeaderWithFallbackData.create( - header, new FallbackData(payload, FallbackReason.CIRCUIT_BREAKER_ENGAGED)); - final SafeFuture blockValueResult = new SafeFuture<>(); + final BuilderBidOrFallbackData expectedResult = + BuilderBidOrFallbackData.create( + new FallbackData(getPayloadResponse, FallbackReason.CIRCUIT_BREAKER_ENGAGED)); assertThat( executionLayerManager.builderGetHeader( - executionPayloadContext, - state, - blockValueResult, - Optional.empty(), - BlockProductionPerformance.NOOP)) + executionPayloadContext, state, Optional.empty(), BlockProductionPerformance.NOOP)) .isCompletedWithValue(expectedResult); - assertThat(blockValueResult).isCompletedWithValue(localExecutionPayloadValue); verifyFallbackToLocalEL(slot, executionPayloadContext, expectedResult); } @@ -739,34 +571,19 @@ public void builderGetHeaderGetPayload_shouldReturnHeaderAndPayloadViaEngineIfBu final UInt64 slot = executionPayloadContext.getForkChoiceState().getHeadBlockSlot(); final BeaconState state = dataStructureUtil.randomBeaconState(slot); - final ExecutionPayload payload = - prepareEngineGetPayloadResponse(executionPayloadContext, localExecutionPayloadValue, slot) - .getExecutionPayload(); - - final ExecutionPayloadHeader header = - spec.getGenesisSpec() - .getSchemaDefinitions() - .toVersionBellatrix() - .orElseThrow() - .getExecutionPayloadHeaderSchema() - .createFromExecutionPayload(payload); + final GetPayloadResponse getPayloadResponse = + prepareEngineGetPayloadResponse(executionPayloadContext, localExecutionPayloadValue, slot); when(builderCircuitBreaker.isEngaged(any())).thenThrow(new RuntimeException("error")); // we expect local engine header as result - final HeaderWithFallbackData expectedResult = - HeaderWithFallbackData.create( - header, new FallbackData(payload, FallbackReason.CIRCUIT_BREAKER_ENGAGED)); - final SafeFuture blockValueResult = new SafeFuture<>(); + final BuilderBidOrFallbackData expectedResult = + BuilderBidOrFallbackData.create( + new FallbackData(getPayloadResponse, FallbackReason.CIRCUIT_BREAKER_ENGAGED)); assertThat( executionLayerManager.builderGetHeader( - executionPayloadContext, - state, - blockValueResult, - Optional.empty(), - BlockProductionPerformance.NOOP)) + executionPayloadContext, state, Optional.empty(), BlockProductionPerformance.NOOP)) .isCompletedWithValue(expectedResult); - assertThat(blockValueResult).isCompletedWithValue(localExecutionPayloadValue); verifyFallbackToLocalEL(slot, executionPayloadContext, expectedResult); } @@ -781,32 +598,17 @@ public void builderGetHeaderGetPayload_shouldReturnHeaderAndPayloadViaEngineIfBu final UInt64 slot = executionPayloadContext.getForkChoiceState().getHeadBlockSlot(); final BeaconState state = dataStructureUtil.randomBeaconState(slot); - final ExecutionPayload payload = - prepareEngineGetPayloadResponse(executionPayloadContext, localExecutionPayloadValue, slot) - .getExecutionPayload(); - - final ExecutionPayloadHeader header = - spec.getGenesisSpec() - .getSchemaDefinitions() - .toVersionBellatrix() - .orElseThrow() - .getExecutionPayloadHeaderSchema() - .createFromExecutionPayload(payload); + final GetPayloadResponse getPayloadResponse = + prepareEngineGetPayloadResponse(executionPayloadContext, localExecutionPayloadValue, slot); // we expect local engine header as result - final HeaderWithFallbackData expectedResult = - HeaderWithFallbackData.create( - header, new FallbackData(payload, FallbackReason.VALIDATOR_NOT_REGISTERED)); - final SafeFuture blockValueResult = new SafeFuture<>(); + final BuilderBidOrFallbackData expectedResult = + BuilderBidOrFallbackData.create( + new FallbackData(getPayloadResponse, FallbackReason.VALIDATOR_NOT_REGISTERED)); assertThat( executionLayerManager.builderGetHeader( - executionPayloadContext, - state, - blockValueResult, - Optional.empty(), - BlockProductionPerformance.NOOP)) + executionPayloadContext, state, Optional.empty(), BlockProductionPerformance.NOOP)) .isCompletedWithValue(expectedResult); - assertThat(blockValueResult).isCompletedWithValue(localExecutionPayloadValue); verifyFallbackToLocalEL(slot, executionPayloadContext, expectedResult); } @@ -828,7 +630,6 @@ void onSlot_shouldCleanUpFallbackCache() { executionLayerManager.builderGetHeader( executionPayloadContext, state, - SafeFuture.completedFuture(localExecutionPayloadValue), Optional.empty(), BlockProductionPerformance.NOOP)) .isCompleted(); @@ -852,13 +653,26 @@ void onSlot_shouldCleanUpFallbackCache() { assertThat( executionLayerManager.builderGetPayload( signedBlindedBeaconBlock, (aSlot) -> Optional.empty())) - .isCompletedWithValue(payload); + .isCompletedWithValue(BuilderPayloadOrFallbackData.create(payload)); // we expect both builder and local engine have been called verify(builderClient).getPayload(signedBlindedBeaconBlock); verifyNoMoreInteractions(executionClientHandler); } + @Test + public void engineGetBlobs_shouldReturnGetBlobsResponseViaEngine() { + setupDeneb(); + final List versionedHashes = + dataStructureUtil.randomVersionedHashes( + SpecConfigDeneb.required(spec.getGenesisSpecConfig()).getMaxBlobsPerBlock()); + final UInt64 slot = dataStructureUtil.randomSlot(); + final List getBlobsResponse = + prepareEngineGetBlobsResponse(versionedHashes, slot); + assertThat(executionLayerManager.engineGetBlobs(versionedHashes, slot)) + .isCompletedWithValue(getBlobsResponse.stream().map(Optional::ofNullable).toList()); + } + private void setupDeneb() { spec = TestSpecFactory.createMinimalDeneb(); dataStructureUtil = new DataStructureUtil(spec); @@ -872,7 +686,7 @@ private BuilderBid prepareBuilderGetHeaderResponse( final UInt64 slot = executionPayloadContext.getForkChoiceState().getHeadBlockSlot(); final BuilderBid builderBid = - dataStructureUtil.randomBuilderBid(dataStructureUtil.randomPublicKey(), builderBlockValue); + dataStructureUtil.randomBuilderBid(builder -> builder.value(builderBlockValue)); final SignedBuilderBid signedBuilderBid = dataStructureUtil.randomSignedBuilderBid(builderBid); doAnswer( @@ -897,8 +711,8 @@ private BuilderBid prepareBuilderGetHeaderResponse( private void verifyFallbackToLocalEL( final UInt64 slot, final ExecutionPayloadContext executionPayloadContext, - final HeaderWithFallbackData headerWithFallbackData) { - final FallbackData fallbackData = headerWithFallbackData.getFallbackData().orElseThrow(); + final BuilderBidOrFallbackData builderBidOrFallbackData) { + final FallbackData fallbackData = builderBidOrFallbackData.getFallbackData().orElseThrow(); final FallbackReason fallbackReason = fallbackData.getReason(); if (fallbackReason == FallbackReason.BUILDER_HEADER_NOT_AVAILABLE || fallbackReason == FallbackReason.BUILDER_ERROR @@ -912,24 +726,6 @@ private void verifyFallbackToLocalEL( } verifyEngineCalled(executionPayloadContext, slot); - final BuilderPayload builderPayload = - fallbackData - .getBlobsBundle() - .map( - executionBlobsBundle -> { - final SchemaDefinitionsDeneb schemaDefinitions = - SchemaDefinitionsDeneb.required(spec.atSlot(slot).getSchemaDefinitions()); - final tech.pegasys.teku.spec.datastructures.builder.BlobsBundle blobsBundle = - schemaDefinitions - .getBlobsBundleSchema() - .createFromExecutionBlobsBundle(executionBlobsBundle); - return (BuilderPayload) - schemaDefinitions - .getExecutionPayloadAndBlobsBundleSchema() - .create(fallbackData.getExecutionPayload(), blobsBundle); - }) - .orElse(fallbackData.getExecutionPayload()); - final SignedBeaconBlock signedBlindedBeaconBlock = dataStructureUtil.randomSignedBlindedBeaconBlock(slot); @@ -939,13 +735,10 @@ private void verifyFallbackToLocalEL( signedBlindedBeaconBlock, (aSlot) -> Optional.of( - new ExecutionPayloadResult( + ExecutionPayloadResult.createForBuilderFlow( executionPayloadContext, - Optional.empty(), - Optional.empty(), - Optional.of(SafeFuture.completedFuture(headerWithFallbackData)), - Optional.empty())))) - .isCompletedWithValue(builderPayload); + SafeFuture.completedFuture(builderBidOrFallbackData))))) + .isCompletedWithValue(BuilderPayloadOrFallbackData.create(fallbackData)); // we expect no additional calls verifyNoMoreInteractions(builderClient); @@ -996,7 +789,7 @@ private void prepareEngineFailedPayloadResponse( .thenReturn(SafeFuture.failedFuture(new RuntimeException(""))); } - private GetPayloadResponse prepareEngineGetPayloadResponse( + private GetPayloadResponse prepareEngineGetPayloadResponseWithBlobs( final ExecutionPayloadContext executionPayloadContext, final UInt256 blockValue, final boolean shouldOverrideBuilder, @@ -1010,6 +803,20 @@ private GetPayloadResponse prepareEngineGetPayloadResponse( return getPayloadResponse; } + private List prepareEngineGetBlobsResponse( + final List blobVersionedHashes, final UInt64 slot) { + final List blobSidecars = + dataStructureUtil.randomBlobSidecars( + SpecConfigDeneb.required(spec.getGenesisSpecConfig()).getMaxBlobsPerBlock()); + final List getBlobsResponse = + blobSidecars.stream() + .map(blobSidecar -> new BlobAndProof(blobSidecar.getBlob(), blobSidecar.getKZGProof())) + .toList(); + when(executionClientHandler.engineGetBlobs(blobVersionedHashes, slot)) + .thenReturn(SafeFuture.completedFuture(getBlobsResponse)); + return getBlobsResponse; + } + private ExecutionLayerManagerImpl createExecutionLayerChannelImpl( final boolean builderEnabled, final boolean builderValidatorEnabled) { return createExecutionLayerChannelImpl( @@ -1025,7 +832,6 @@ private ExecutionLayerManagerImpl createExecutionLayerChannelImpl( eventLogger, executionClientHandler, builderEnabled ? Optional.of(builderClient) : Optional.empty(), - spec, stubMetricsSystem, builderValidatorEnabled ? new BuilderBidValidatorImpl(spec, eventLogger) @@ -1039,7 +845,8 @@ private void updateBuilderStatus(final SafeFuture> builderClientR updateBuilderStatus(builderClientResponse, UInt64.ONE); } - private void updateBuilderStatus(SafeFuture> builderClientResponse, UInt64 slot) { + private void updateBuilderStatus( + final SafeFuture> builderClientResponse, final UInt64 slot) { when(builderClient.status()).thenReturn(builderClientResponse); // trigger update of the builder status executionLayerManager.onSlot(slot); @@ -1081,7 +888,7 @@ private void verifyEngineCalled( private void verifySourceCounter(final Source source, final FallbackReason reason) { final long actualCount = stubMetricsSystem - .getCounter(TekuMetricCategory.BEACON, "execution_payload_source") + .getCounter(TekuMetricCategory.BEACON, "execution_payload_source_total") .getValue(source.toString(), reason.toString()); assertThat(actualCount).isOne(); } diff --git a/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/MilestoneBasedEngineJsonRpcMethodsResolverTest.java b/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/MilestoneBasedEngineJsonRpcMethodsResolverTest.java index eb30f4108b4..3e670e7d8be 100644 --- a/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/MilestoneBasedEngineJsonRpcMethodsResolverTest.java +++ b/ethereum/executionlayer/src/test/java/tech/pegasys/teku/ethereum/executionlayer/MilestoneBasedEngineJsonRpcMethodsResolverTest.java @@ -18,6 +18,7 @@ import static org.junit.jupiter.params.provider.Arguments.arguments; import static org.mockito.Mockito.mock; import static tech.pegasys.teku.ethereum.executionclient.methods.EngineApiMethod.ENGINE_FORK_CHOICE_UPDATED; +import static tech.pegasys.teku.ethereum.executionclient.methods.EngineApiMethod.ENGINE_GET_BLOBS; import static tech.pegasys.teku.ethereum.executionclient.methods.EngineApiMethod.ENGINE_GET_PAYLOAD; import static tech.pegasys.teku.ethereum.executionclient.methods.EngineApiMethod.ENGINE_NEW_PAYLOAD; @@ -33,13 +34,17 @@ import tech.pegasys.teku.ethereum.executionclient.methods.EngineForkChoiceUpdatedV1; import tech.pegasys.teku.ethereum.executionclient.methods.EngineForkChoiceUpdatedV2; import tech.pegasys.teku.ethereum.executionclient.methods.EngineForkChoiceUpdatedV3; +import tech.pegasys.teku.ethereum.executionclient.methods.EngineForkChoiceUpdatedV4; +import tech.pegasys.teku.ethereum.executionclient.methods.EngineGetBlobsV1; import tech.pegasys.teku.ethereum.executionclient.methods.EngineGetPayloadV1; import tech.pegasys.teku.ethereum.executionclient.methods.EngineGetPayloadV2; import tech.pegasys.teku.ethereum.executionclient.methods.EngineGetPayloadV3; +import tech.pegasys.teku.ethereum.executionclient.methods.EngineGetPayloadV4; import tech.pegasys.teku.ethereum.executionclient.methods.EngineJsonRpcMethod; import tech.pegasys.teku.ethereum.executionclient.methods.EngineNewPayloadV1; import tech.pegasys.teku.ethereum.executionclient.methods.EngineNewPayloadV2; import tech.pegasys.teku.ethereum.executionclient.methods.EngineNewPayloadV3; +import tech.pegasys.teku.ethereum.executionclient.methods.EngineNewPayloadV4; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; @@ -143,7 +148,7 @@ void denebMilestoneMethodIsNotSupportedInCapella() { @ParameterizedTest @MethodSource("denebMethods") void shouldProvideExpectedMethodsForDeneb( - EngineApiMethod method, Class> expectedMethodClass) { + final EngineApiMethod method, final Class> expectedMethodClass) { final Spec denebSpec = TestSpecFactory.createMinimalDeneb(); final MilestoneBasedEngineJsonRpcMethodsResolver engineMethodsResolver = @@ -159,13 +164,51 @@ private static Stream denebMethods() { return Stream.of( arguments(ENGINE_NEW_PAYLOAD, EngineNewPayloadV3.class), arguments(ENGINE_GET_PAYLOAD, EngineGetPayloadV3.class), - arguments(ENGINE_FORK_CHOICE_UPDATED, EngineForkChoiceUpdatedV3.class)); + arguments(ENGINE_FORK_CHOICE_UPDATED, EngineForkChoiceUpdatedV3.class), + arguments(ENGINE_GET_BLOBS, EngineGetBlobsV1.class)); + } + + @Test + void electraMilestoneMethodIsNotSupportedInDeneb() { + final Spec capellaSpec = TestSpecFactory.createMinimalDeneb(); + + final MilestoneBasedEngineJsonRpcMethodsResolver engineMethodsResolver = + new MilestoneBasedEngineJsonRpcMethodsResolver(capellaSpec, executionEngineClient); + + assertThatThrownBy( + () -> + engineMethodsResolver.getMethod( + ENGINE_GET_PAYLOAD, () -> SpecMilestone.ELECTRA, Object.class)) + .hasMessage("Can't find method with name engine_getPayload for milestone ELECTRA"); + } + + @ParameterizedTest + @MethodSource("electraMethods") + void shouldProvideExpectedMethodsForElectra( + final EngineApiMethod method, final Class> expectedMethodClass) { + final Spec electraSpec = TestSpecFactory.createMinimalElectra(); + + final MilestoneBasedEngineJsonRpcMethodsResolver engineMethodsResolver = + new MilestoneBasedEngineJsonRpcMethodsResolver(electraSpec, executionEngineClient); + + final EngineJsonRpcMethod providedMethod = + engineMethodsResolver.getMethod(method, () -> SpecMilestone.ELECTRA, Object.class); + + assertThat(providedMethod).isExactlyInstanceOf(expectedMethodClass); + } + + private static Stream electraMethods() { + return Stream.of( + arguments(ENGINE_NEW_PAYLOAD, EngineNewPayloadV4.class), + arguments(ENGINE_GET_PAYLOAD, EngineGetPayloadV4.class), + arguments(ENGINE_FORK_CHOICE_UPDATED, EngineForkChoiceUpdatedV4.class), + arguments(ENGINE_GET_BLOBS, EngineGetBlobsV1.class)); } @Test void getsCapabilities() { final Spec spec = - TestSpecFactory.createMinimalWithCapellaDenebAndEip7594ForkEpoch( + TestSpecFactory.createMinimalWithCapellaDenebAndElectraForkEpoch( UInt64.ONE, UInt64.valueOf(2), UInt64.valueOf(3)); final MilestoneBasedEngineJsonRpcMethodsResolver engineMethodsResolver = @@ -183,6 +226,23 @@ void getsCapabilities() { "engine_forkchoiceUpdatedV2", "engine_newPayloadV3", "engine_getPayloadV3", - "engine_forkchoiceUpdatedV3"); + "engine_forkchoiceUpdatedV3", + "engine_newPayloadV4", + "engine_getPayloadV4", + "engine_forkchoiceUpdatedV4"); + } + + @Test + void getsOptionalCapabilities() { + final Spec spec = + TestSpecFactory.createMinimalWithCapellaDenebAndElectraForkEpoch( + UInt64.ONE, UInt64.valueOf(2), UInt64.valueOf(3)); + + final MilestoneBasedEngineJsonRpcMethodsResolver engineMethodsResolver = + new MilestoneBasedEngineJsonRpcMethodsResolver(spec, executionEngineClient); + + final Set capabilities = engineMethodsResolver.getOptionalCapabilities(); + + assertThat(capabilities).containsExactlyInAnyOrder("engine_getBlobsV1"); } } diff --git a/ethereum/jackson-deserializers/src/main/java/tech/pegasys/teku/ethereum/jackson/Eth1AddressDeserializer.java b/ethereum/jackson-deserializers/src/main/java/tech/pegasys/teku/ethereum/jackson/Eth1AddressDeserializer.java index e637e8a2da5..5f789385890 100644 --- a/ethereum/jackson-deserializers/src/main/java/tech/pegasys/teku/ethereum/jackson/Eth1AddressDeserializer.java +++ b/ethereum/jackson-deserializers/src/main/java/tech/pegasys/teku/ethereum/jackson/Eth1AddressDeserializer.java @@ -24,7 +24,7 @@ public class Eth1AddressDeserializer extends JsonDeserializer { @Override - public Eth1Address deserialize(JsonParser p, DeserializationContext ctxt) + public Eth1Address deserialize(final JsonParser p, final DeserializationContext ctxt) throws JacksonException { try { return Eth1Address.fromHexString(p.getValueAsString()); diff --git a/ethereum/json-types/build.gradle b/ethereum/json-types/build.gradle index ea84e3b7cb3..3fac462fbee 100644 --- a/ethereum/json-types/build.gradle +++ b/ethereum/json-types/build.gradle @@ -5,5 +5,7 @@ dependencies { implementation project(':infrastructure:restapi') implementation project(':infrastructure:http') + implementation 'io.tmio:tuweni-units' + testImplementation testFixtures(project(':ethereum:spec')) } \ No newline at end of file diff --git a/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/EthereumTypes.java b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/EthereumTypes.java index f2ff54461c9..a2db56f96aa 100644 --- a/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/EthereumTypes.java +++ b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/EthereumTypes.java @@ -13,19 +13,29 @@ package tech.pegasys.teku.ethereum.json.types; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_BLOCK_VALUE; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_EXECUTION_PAYLOAD_BLINDED; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_EXECUTION_PAYLOAD_VALUE; + +import java.math.BigInteger; import java.util.Locale; import java.util.Map; +import java.util.Optional; import java.util.Set; import java.util.function.Function; import org.apache.tuweni.bytes.Bytes; +import org.apache.tuweni.units.bigints.UInt256; import org.jetbrains.annotations.NotNull; import tech.pegasys.teku.api.schema.Version; import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.bls.BLSSignature; -import tech.pegasys.teku.ethereum.execution.types.Eth1Address; import tech.pegasys.teku.infrastructure.http.RestApiConstants; +import tech.pegasys.teku.infrastructure.json.types.BooleanHeaderTypeDefinition; import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.json.types.EnumHeaderTypeDefinition; import tech.pegasys.teku.infrastructure.json.types.EnumTypeDefinition; +import tech.pegasys.teku.infrastructure.json.types.StringBasedHeaderTypeDefinition; import tech.pegasys.teku.infrastructure.json.types.StringValueTypeDefinition; import tech.pegasys.teku.infrastructure.restapi.openapi.response.OctetStreamResponseContentTypeDefinition; import tech.pegasys.teku.infrastructure.restapi.openapi.response.ResponseContentTypeDefinition; @@ -38,15 +48,6 @@ public class EthereumTypes { - public static final DeserializableTypeDefinition ETH1ADDRESS_TYPE = - DeserializableTypeDefinition.string(Eth1Address.class) - .formatter(Eth1Address::toHexString) - .parser(Eth1Address::fromHexString) - .example("0x1Db3439a222C519ab44bb1144fC28167b4Fa6EE6") - .description("Hex encoded deposit contract address with 0x prefix") - .format("byte") - .build(); - public static final StringValueTypeDefinition SIGNATURE_TYPE = DeserializableTypeDefinition.string(BLSSignature.class) .formatter(BLSSignature::toString) @@ -94,15 +95,47 @@ public class EthereumTypes { public static final StringValueTypeDefinition MILESTONE_TYPE = new EnumTypeDefinition<>( - SpecMilestone.class, - milestone -> { - // FIXME: remove me, bad hack to make Kurtosis working - if (milestone.equals(SpecMilestone.EIP7594)) { - return "deneb"; - } - return milestone.name().toLowerCase(Locale.ROOT); - }, - Set.of()); + SpecMilestone.class, milestone -> milestone.name().toLowerCase(Locale.ROOT), Set.of()); + + public static final EnumHeaderTypeDefinition ETH_CONSENSUS_HEADER_TYPE = + new EnumHeaderTypeDefinition.EnumTypeHeaderDefinitionBuilder<>( + SpecMilestone.class, milestone -> milestone.name().toLowerCase(Locale.ROOT)) + .title(HEADER_CONSENSUS_VERSION) + .required(true) + .description( + "Required in response so client can deserialize returned json or ssz data more effectively.") + .example("phase0") + .build(); + + public static final BooleanHeaderTypeDefinition ETH_HEADER_EXECUTION_PAYLOAD_BLINDED_TYPE = + new BooleanHeaderTypeDefinition( + HEADER_EXECUTION_PAYLOAD_BLINDED, + Optional.of(true), + "Required in response so client can deserialize returned json or ssz data to the correct object."); + + public static final StringBasedHeaderTypeDefinition + ETH_HEADER_EXECUTION_PAYLOAD_VALUE_TYPE = + new StringBasedHeaderTypeDefinition.Builder() + .title(HEADER_EXECUTION_PAYLOAD_VALUE) + .description( + "Execution payload value in Wei. Required in response so client can determine relative value of execution payloads.") + .formatter(value -> value.toBigInteger().toString(10)) + .parser(value -> UInt256.valueOf(new BigInteger(value, 10))) + .example("1") + .required(true) + .build(); + + public static final StringBasedHeaderTypeDefinition + ETH_HEADER_CONSENSUS_BLOCK_VALUE_TYPE = + new StringBasedHeaderTypeDefinition.Builder() + .title(HEADER_CONSENSUS_BLOCK_VALUE) + .description( + "Consensus rewards paid to the proposer for this block, in Wei. Required in response so client can determine relative value of consensus blocks.") + .formatter(value -> value.toBigInteger().toString(10)) + .parser(value -> UInt256.valueOf(new BigInteger(value, 10))) + .example("1") + .required(true) + .build(); public static > ResponseContentTypeDefinition sszResponseType() { @@ -128,7 +161,7 @@ public static ResponseContentTypeDefinition sszResponseTy private static Map getSszHeaders( final Function milestoneSelector, final T value) { return Map.of( - RestApiConstants.HEADER_CONSENSUS_VERSION, + HEADER_CONSENSUS_VERSION, Version.fromMilestone(milestoneSelector.apply(value)).name(), RestApiConstants.HEADER_CONTENT_DISPOSITION, getSszFilename(value)); diff --git a/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/beacon/GetGenesisApiDataBuilder.java b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/beacon/GetGenesisApiDataBuilder.java index f954031104e..66187e92d5b 100644 --- a/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/beacon/GetGenesisApiDataBuilder.java +++ b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/beacon/GetGenesisApiDataBuilder.java @@ -52,17 +52,17 @@ public class GetGenesisApiDataBuilder { private Bytes32 genesisValidatorsRoot; private Bytes4 genesisForkVersion; - public GetGenesisApiDataBuilder genesisTime(UInt64 genesisTime) { + public GetGenesisApiDataBuilder genesisTime(final UInt64 genesisTime) { this.genesisTime = genesisTime; return this; } - public GetGenesisApiDataBuilder genesisValidatorsRoot(Bytes32 genesisValidatorsRoot) { + public GetGenesisApiDataBuilder genesisValidatorsRoot(final Bytes32 genesisValidatorsRoot) { this.genesisValidatorsRoot = genesisValidatorsRoot; return this; } - public GetGenesisApiDataBuilder genesisForkVersion(Bytes4 genesisForkVersion) { + public GetGenesisApiDataBuilder genesisForkVersion(final Bytes4 genesisForkVersion) { this.genesisForkVersion = genesisForkVersion; return this; } diff --git a/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/beacon/StateValidatorData.java b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/beacon/StateValidatorData.java index ce36f35bde1..8dc0305a035 100644 --- a/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/beacon/StateValidatorData.java +++ b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/beacon/StateValidatorData.java @@ -84,7 +84,7 @@ public BLSPublicKey getPublicKey() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/beacon/StateValidatorDataBuilder.java b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/beacon/StateValidatorDataBuilder.java index f787a524ca8..459b3f942ad 100644 --- a/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/beacon/StateValidatorDataBuilder.java +++ b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/beacon/StateValidatorDataBuilder.java @@ -85,22 +85,22 @@ public class StateValidatorDataBuilder { private ValidatorStatus status; private Validator validator; - public StateValidatorDataBuilder index(UInt64 index) { + public StateValidatorDataBuilder index(final UInt64 index) { this.index = index; return this; } - public StateValidatorDataBuilder balance(UInt64 balance) { + public StateValidatorDataBuilder balance(final UInt64 balance) { this.balance = balance; return this; } - public StateValidatorDataBuilder status(ValidatorStatus status) { + public StateValidatorDataBuilder status(final ValidatorStatus status) { this.status = status; return this; } - public StateValidatorDataBuilder validator(Validator validator) { + public StateValidatorDataBuilder validator(final Validator validator) { this.validator = validator; return this; } diff --git a/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/node/PeerCount.java b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/node/PeerCount.java new file mode 100644 index 00000000000..b987fdd1ce6 --- /dev/null +++ b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/node/PeerCount.java @@ -0,0 +1,71 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.ethereum.json.types.node; + +import java.util.Objects; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; + +public class PeerCount { + final UInt64 disconnected; + final UInt64 connecting; + final UInt64 connected; + final UInt64 disconnecting; + + PeerCount( + final UInt64 disconnected, + final UInt64 connecting, + final UInt64 connected, + final UInt64 disconnecting) { + this.disconnected = disconnected; + this.connecting = connecting; + this.connected = connected; + this.disconnecting = disconnecting; + } + + public UInt64 getDisconnected() { + return disconnected; + } + + public UInt64 getConnecting() { + return connecting; + } + + public UInt64 getConnected() { + return connected; + } + + public UInt64 getDisconnecting() { + return disconnecting; + } + + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + final PeerCount that = (PeerCount) o; + return Objects.equals(disconnected, that.disconnected) + && Objects.equals(connecting, that.connecting) + && Objects.equals(connected, that.connected) + && Objects.equals(disconnecting, that.disconnecting); + } + + @Override + public int hashCode() { + return Objects.hash(disconnected, connecting, connected, disconnecting); + } +} diff --git a/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/node/PeerCountBuilder.java b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/node/PeerCountBuilder.java new file mode 100644 index 00000000000..17c67595a26 --- /dev/null +++ b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/node/PeerCountBuilder.java @@ -0,0 +1,87 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.ethereum.json.types.node; + +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; + +import java.util.function.Function; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; + +public class PeerCountBuilder { + + public static final DeserializableTypeDefinition PEER_COUNT_DATA_TYPE = + DeserializableTypeDefinition.object(PeerCount.class, PeerCountBuilder.class) + .initializer(PeerCountBuilder::new) + .finisher(PeerCountBuilder::build) + .withField( + "disconnected", + UINT64_TYPE, + PeerCount::getDisconnected, + PeerCountBuilder::disconnected) + .withField( + "connecting", UINT64_TYPE, PeerCount::getConnecting, PeerCountBuilder::connecting) + .withField("connected", UINT64_TYPE, PeerCount::getConnected, PeerCountBuilder::connected) + .withField( + "disconnecting", + UINT64_TYPE, + PeerCount::getDisconnecting, + PeerCountBuilder::disconnecting) + .build(); + + public static final DeserializableTypeDefinition PEER_COUNT_TYPE = + DeserializableTypeDefinition.object(PeerCount.class, PeerCountBuilder.class) + .name("GetPeerCountResponse") + .initializer(PeerCountBuilder::new) + .finisher(PeerCountBuilder::build) + .withField("data", PEER_COUNT_DATA_TYPE, Function.identity(), PeerCountBuilder::peerCount) + .build(); + + private UInt64 disconnected = UInt64.ZERO; + private UInt64 connecting = UInt64.ZERO; + private UInt64 connected = UInt64.ZERO; + private UInt64 disconnecting = UInt64.ZERO; + + public PeerCountBuilder disconnected(final UInt64 disconnected) { + this.disconnected = disconnected; + return this; + } + + public PeerCountBuilder connecting(final UInt64 connecting) { + this.connecting = connecting; + return this; + } + + public PeerCountBuilder connected(final UInt64 connected) { + this.connected = connected; + return this; + } + + public PeerCountBuilder disconnecting(final UInt64 disconnecting) { + this.disconnecting = disconnecting; + return this; + } + + public PeerCountBuilder peerCount(final PeerCount peerCount) { + this.disconnected = peerCount.getDisconnected(); + this.connecting = peerCount.getConnecting(); + this.connected = peerCount.getConnected(); + this.disconnecting = peerCount.getDisconnecting(); + return this; + } + + public PeerCount build() { + return new PeerCount(disconnected, connecting, connected, disconnecting); + } +} diff --git a/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/AttesterDutiesBuilder.java b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/AttesterDutiesBuilder.java index 4e4d678a300..ac73dbb31cf 100644 --- a/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/AttesterDutiesBuilder.java +++ b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/AttesterDutiesBuilder.java @@ -49,17 +49,17 @@ public class AttesterDutiesBuilder { private Bytes32 dependentRoot; private List duties; - public AttesterDutiesBuilder executionOptimistic(boolean executionOptimistic) { + public AttesterDutiesBuilder executionOptimistic(final boolean executionOptimistic) { this.executionOptimistic = executionOptimistic; return this; } - public AttesterDutiesBuilder dependentRoot(Bytes32 dependentRoot) { + public AttesterDutiesBuilder dependentRoot(final Bytes32 dependentRoot) { this.dependentRoot = dependentRoot; return this; } - public AttesterDutiesBuilder duties(List duties) { + public AttesterDutiesBuilder duties(final List duties) { this.duties = duties; return this; } diff --git a/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/AttesterDutyBuilder.java b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/AttesterDutyBuilder.java index 0ced8c31ab6..eef5197d9ca 100644 --- a/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/AttesterDutyBuilder.java +++ b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/AttesterDutyBuilder.java @@ -65,37 +65,37 @@ public class AttesterDutyBuilder { private int validatorCommitteeIndex; private UInt64 slot; - public AttesterDutyBuilder publicKey(BLSPublicKey publicKey) { + public AttesterDutyBuilder publicKey(final BLSPublicKey publicKey) { this.publicKey = publicKey; return this; } - public AttesterDutyBuilder validatorIndex(int validatorIndex) { + public AttesterDutyBuilder validatorIndex(final int validatorIndex) { this.validatorIndex = validatorIndex; return this; } - public AttesterDutyBuilder committeeLength(int committeeLength) { + public AttesterDutyBuilder committeeLength(final int committeeLength) { this.committeeLength = committeeLength; return this; } - public AttesterDutyBuilder committeeIndex(int committeeIndex) { + public AttesterDutyBuilder committeeIndex(final int committeeIndex) { this.committeeIndex = committeeIndex; return this; } - public AttesterDutyBuilder committeesAtSlot(int committeesAtSlot) { + public AttesterDutyBuilder committeesAtSlot(final int committeesAtSlot) { this.committeesAtSlot = committeesAtSlot; return this; } - public AttesterDutyBuilder validatorCommitteeIndex(int validatorCommitteeIndex) { + public AttesterDutyBuilder validatorCommitteeIndex(final int validatorCommitteeIndex) { this.validatorCommitteeIndex = validatorCommitteeIndex; return this; } - public AttesterDutyBuilder slot(UInt64 slot) { + public AttesterDutyBuilder slot(final UInt64 slot) { this.slot = slot; return this; } diff --git a/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/PostSyncCommitteeData.java b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/PostSyncCommitteeData.java new file mode 100644 index 00000000000..c3ba00f0969 --- /dev/null +++ b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/PostSyncCommitteeData.java @@ -0,0 +1,128 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.ethereum.json.types.validator; + +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.INTEGER_TYPE; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; + +import it.unimi.dsi.fastutil.ints.IntArrayList; +import it.unimi.dsi.fastutil.ints.IntOpenHashSet; +import it.unimi.dsi.fastutil.ints.IntSet; +import java.util.List; +import java.util.Objects; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; + +public class PostSyncCommitteeData { + private int validatorIndex; + private IntSet syncCommitteeIndices; + private UInt64 untilEpoch; + + public static final DeserializableTypeDefinition + SYNC_COMMITTEE_SUBSCRIPTION = + DeserializableTypeDefinition.object(PostSyncCommitteeData.class) + .name("PostSyncCommitteeData") + .initializer(PostSyncCommitteeData::new) + .withField( + "validator_index", + INTEGER_TYPE, + PostSyncCommitteeData::getValidatorIndex, + PostSyncCommitteeData::setValidatorIndex) + .withField( + "sync_committee_indices", + DeserializableTypeDefinition.listOf(INTEGER_TYPE), + PostSyncCommitteeData::getSyncCommitteeIndices, + PostSyncCommitteeData::setSyncCommitteeIndices) + .withField( + "until_epoch", + UINT64_TYPE, + PostSyncCommitteeData::getUntilEpoch, + PostSyncCommitteeData::setUntilEpoch) + .build(); + + public PostSyncCommitteeData() {} + + public PostSyncCommitteeData( + final int validatorIndex, final IntSet syncCommitteeIndices, final UInt64 untilEpoch) { + this.validatorIndex = validatorIndex; + this.syncCommitteeIndices = syncCommitteeIndices; + this.untilEpoch = untilEpoch; + } + + public PostSyncCommitteeData( + final SyncCommitteeSubnetSubscription syncCommitteeSubnetSubscription) { + this.validatorIndex = syncCommitteeSubnetSubscription.validatorIndex(); + this.syncCommitteeIndices = syncCommitteeSubnetSubscription.syncCommitteeIndices(); + this.untilEpoch = syncCommitteeSubnetSubscription.untilEpoch(); + } + + public SyncCommitteeSubnetSubscription toSyncCommitteeSubnetSubscription() { + return new SyncCommitteeSubnetSubscription(validatorIndex, syncCommitteeIndices, untilEpoch); + } + + public int getValidatorIndex() { + return validatorIndex; + } + + public void setValidatorIndex(final int validatorIndex) { + this.validatorIndex = validatorIndex; + } + + public List getSyncCommitteeIndices() { + return new IntArrayList(syncCommitteeIndices); + } + + public void setSyncCommitteeIndices(final List syncCommitteeIndices) { + this.syncCommitteeIndices = new IntOpenHashSet(syncCommitteeIndices); + } + + public UInt64 getUntilEpoch() { + return untilEpoch; + } + + public void setUntilEpoch(final UInt64 untilEpoch) { + this.untilEpoch = untilEpoch; + } + + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + PostSyncCommitteeData that = (PostSyncCommitteeData) o; + return validatorIndex == that.validatorIndex + && Objects.equals(syncCommitteeIndices, that.syncCommitteeIndices) + && Objects.equals(untilEpoch, that.untilEpoch); + } + + @Override + public int hashCode() { + return Objects.hash(validatorIndex, syncCommitteeIndices, untilEpoch); + } + + @Override + public String toString() { + return "PostSyncCommitteeData{" + + "validatorIndex=" + + validatorIndex + + ", syncCommitteeIndices=" + + syncCommitteeIndices + + ", untilEpoch=" + + untilEpoch + + '}'; + } +} diff --git a/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/ProposerDutiesBuilder.java b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/ProposerDutiesBuilder.java index 479387d0816..f7eae2df78e 100644 --- a/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/ProposerDutiesBuilder.java +++ b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/ProposerDutiesBuilder.java @@ -50,17 +50,17 @@ public class ProposerDutiesBuilder { private boolean executionOptimistic; private List duties; - public ProposerDutiesBuilder dependentRoot(Bytes32 dependentRoot) { + public ProposerDutiesBuilder dependentRoot(final Bytes32 dependentRoot) { this.dependentRoot = dependentRoot; return this; } - public ProposerDutiesBuilder executionOptimistic(boolean executionOptimistic) { + public ProposerDutiesBuilder executionOptimistic(final boolean executionOptimistic) { this.executionOptimistic = executionOptimistic; return this; } - public ProposerDutiesBuilder duties(List duties) { + public ProposerDutiesBuilder duties(final List duties) { this.duties = duties; return this; } diff --git a/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/ProposerDutyBuilder.java b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/ProposerDutyBuilder.java index fa7d6413e80..322f1f2eaa6 100644 --- a/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/ProposerDutyBuilder.java +++ b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/ProposerDutyBuilder.java @@ -40,17 +40,17 @@ public class ProposerDutyBuilder { private int validatorIndex; private UInt64 slot; - public ProposerDutyBuilder publicKey(BLSPublicKey publicKey) { + public ProposerDutyBuilder publicKey(final BLSPublicKey publicKey) { this.publicKey = publicKey; return this; } - public ProposerDutyBuilder validatorIndex(int validatorIndex) { + public ProposerDutyBuilder validatorIndex(final int validatorIndex) { this.validatorIndex = validatorIndex; return this; } - public ProposerDutyBuilder slot(UInt64 slot) { + public ProposerDutyBuilder slot(final UInt64 slot) { this.slot = slot; return this; } diff --git a/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/SyncCommitteeDutiesBuilder.java b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/SyncCommitteeDutiesBuilder.java index 61e31ce89f2..aceab5a8566 100644 --- a/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/SyncCommitteeDutiesBuilder.java +++ b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/SyncCommitteeDutiesBuilder.java @@ -43,12 +43,12 @@ public class SyncCommitteeDutiesBuilder { private boolean executionOptimistic; private List duties; - public SyncCommitteeDutiesBuilder executionOptimistic(boolean executionOptimistic) { + public SyncCommitteeDutiesBuilder executionOptimistic(final boolean executionOptimistic) { this.executionOptimistic = executionOptimistic; return this; } - public SyncCommitteeDutiesBuilder duties(List duties) { + public SyncCommitteeDutiesBuilder duties(final List duties) { this.duties = duties; return this; } diff --git a/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/SyncCommitteeDutyBuilder.java b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/SyncCommitteeDutyBuilder.java index d33314f89e3..6d61eb3e58b 100644 --- a/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/SyncCommitteeDutyBuilder.java +++ b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/SyncCommitteeDutyBuilder.java @@ -51,18 +51,18 @@ public class SyncCommitteeDutyBuilder { private int validatorIndex; private IntSet validatorSyncCommitteeIndices; - public SyncCommitteeDutyBuilder publicKey(BLSPublicKey publicKey) { + public SyncCommitteeDutyBuilder publicKey(final BLSPublicKey publicKey) { this.publicKey = publicKey; return this; } - public SyncCommitteeDutyBuilder validatorIndex(int validatorIndex) { + public SyncCommitteeDutyBuilder validatorIndex(final int validatorIndex) { this.validatorIndex = validatorIndex; return this; } public SyncCommitteeDutyBuilder validatorSyncCommitteeIndices( - IntSet validatorSyncCommitteeIndices) { + final IntSet validatorSyncCommitteeIndices) { this.validatorSyncCommitteeIndices = validatorSyncCommitteeIndices; return this; } diff --git a/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/SyncCommitteeSubnetSubscription.java b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/SyncCommitteeSubnetSubscription.java new file mode 100644 index 00000000000..c9e20eab2a5 --- /dev/null +++ b/ethereum/json-types/src/main/java/tech/pegasys/teku/ethereum/json/types/validator/SyncCommitteeSubnetSubscription.java @@ -0,0 +1,20 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.ethereum.json.types.validator; + +import it.unimi.dsi.fastutil.ints.IntSet; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; + +public record SyncCommitteeSubnetSubscription( + int validatorIndex, IntSet syncCommitteeIndices, UInt64 untilEpoch) {} diff --git a/ethereum/networks/build.gradle b/ethereum/networks/build.gradle index 1a65d5bf82c..442bb20fe18 100644 --- a/ethereum/networks/build.gradle +++ b/ethereum/networks/build.gradle @@ -6,12 +6,13 @@ dependencies { implementation project(':infrastructure:http') implementation project(':infrastructure:io') implementation project(':infrastructure:exceptions') - - implementation 'org.apache.tuweni:tuweni-units' + implementation project(':infrastructure:time') + implementation 'io.tmio:tuweni-units' testImplementation 'tech.pegasys.discovery:discovery' testFixturesImplementation project(':ethereum:spec') testFixturesImplementation project(':infrastructure:io') + testImplementation testFixtures(project(':infrastructure:time')) testFixturesImplementation 'com.google.guava:guava' } diff --git a/ethereum/networks/src/main/java/tech/pegasys/teku/networks/EphemeryNetwork.java b/ethereum/networks/src/main/java/tech/pegasys/teku/networks/EphemeryNetwork.java new file mode 100644 index 00000000000..999e843a894 --- /dev/null +++ b/ethereum/networks/src/main/java/tech/pegasys/teku/networks/EphemeryNetwork.java @@ -0,0 +1,61 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.networks; + +import java.time.Instant; +import java.time.temporal.ChronoUnit; +import tech.pegasys.teku.infrastructure.time.SystemTimeProvider; +import tech.pegasys.teku.infrastructure.time.TimeProvider; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.config.SpecConfigLoader; +import tech.pegasys.teku.spec.config.builder.SpecConfigBuilder; + +public class EphemeryNetwork { + private static final long GENESIS_CHAINID = 39438135; + private static final long INITIAL_GENESIS_TIMESTAMP = 1720119600; + private static final int PERIOD = 28; + private static final long PERIOD_IN_SECONDS = (PERIOD * 24 * 60 * 60); + public static final long MAX_EPHEMERY_SLOT = (PERIOD_IN_SECONDS / 12) - 1; + + static long getPeriodsSinceGenesis(final TimeProvider timeProvider) { + return ChronoUnit.DAYS.between( + Instant.ofEpochSecond(INITIAL_GENESIS_TIMESTAMP), + Instant.ofEpochMilli(timeProvider.getTimeInMillis().longValue())) + / PERIOD; + } + + public static void updateConfig(final SpecConfigBuilder builder) { + updateConfig(builder, new SystemTimeProvider()); + } + + static void updateConfig(final SpecConfigBuilder builder, final TimeProvider timeProvider) { + final SpecConfig config = SpecConfigLoader.loadConfig("ephemery").specConfig(); + final SpecConfigBuilder rawConfigBuilder = builder.rawConfig(config.getRawConfig()); + final long periodsSinceInitialGenesis = getPeriodsSinceGenesis(timeProvider); + + try { + if (periodsSinceInitialGenesis > 0L) { + final long updatedChainId = GENESIS_CHAINID + periodsSinceInitialGenesis; + final long currentPeriodGenesis = + INITIAL_GENESIS_TIMESTAMP + (periodsSinceInitialGenesis * PERIOD_IN_SECONDS); + rawConfigBuilder.depositNetworkId(updatedChainId); + rawConfigBuilder.depositChainId(updatedChainId); + rawConfigBuilder.minGenesisTime(UInt64.valueOf(currentPeriodGenesis)); + } + } catch (RuntimeException e) { + throw new RuntimeException("Error updating genesis file: " + e.getMessage(), e); + } + } +} diff --git a/ethereum/networks/src/main/java/tech/pegasys/teku/networks/Eth2NetworkConfiguration.java b/ethereum/networks/src/main/java/tech/pegasys/teku/networks/Eth2NetworkConfiguration.java index 0002dc5a4be..a2f4a560b17 100644 --- a/ethereum/networks/src/main/java/tech/pegasys/teku/networks/Eth2NetworkConfiguration.java +++ b/ethereum/networks/src/main/java/tech/pegasys/teku/networks/Eth2NetworkConfiguration.java @@ -19,13 +19,13 @@ import static tech.pegasys.teku.infrastructure.async.AsyncRunnerFactory.DEFAULT_MAX_QUEUE_SIZE; import static tech.pegasys.teku.spec.constants.NetworkConstants.DEFAULT_SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY; import static tech.pegasys.teku.spec.networks.Eth2Network.CHIADO; +import static tech.pegasys.teku.spec.networks.Eth2Network.EPHEMERY; import static tech.pegasys.teku.spec.networks.Eth2Network.GNOSIS; import static tech.pegasys.teku.spec.networks.Eth2Network.HOLESKY; import static tech.pegasys.teku.spec.networks.Eth2Network.LESS_SWIFT; import static tech.pegasys.teku.spec.networks.Eth2Network.LUKSO; import static tech.pegasys.teku.spec.networks.Eth2Network.MAINNET; import static tech.pegasys.teku.spec.networks.Eth2Network.MINIMAL; -import static tech.pegasys.teku.spec.networks.Eth2Network.PRATER; import static tech.pegasys.teku.spec.networks.Eth2Network.SEPOLIA; import static tech.pegasys.teku.spec.networks.Eth2Network.SWIFT; @@ -34,6 +34,9 @@ import java.util.List; import java.util.Objects; import java.util.Optional; +import java.util.OptionalInt; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; import org.apache.tuweni.bytes.Bytes32; import org.apache.tuweni.units.bigints.UInt256; import tech.pegasys.teku.ethereum.execution.types.Eth1Address; @@ -47,6 +50,7 @@ import tech.pegasys.teku.spec.networks.Eth2Network; public class Eth2NetworkConfiguration { + private static final Logger LOG = LogManager.getLogger(); private static final int DEFAULT_STARTUP_TARGET_PEER_COUNT = 5; private static final int DEFAULT_STARTUP_TIMEOUT_SECONDS = 30; @@ -89,6 +93,7 @@ public class Eth2NetworkConfiguration { private final Optional bellatrixForkEpoch; private final Optional capellaForkEpoch; private final Optional denebForkEpoch; + private final Optional electraForkEpoch; private final Optional eip7594ForkEpoch; private final Eth1Address eth1DepositContractAddress; private final Optional eth1DepositContractDeployBlock; @@ -120,6 +125,7 @@ private Eth2NetworkConfiguration( final Optional bellatrixForkEpoch, final Optional capellaForkEpoch, final Optional denebForkEpoch, + final Optional electraForkEpoch, final Optional eip7594ForkEpoch, final Optional terminalBlockHashOverride, final Optional totalTerminalDifficultyOverride, @@ -143,6 +149,7 @@ private Eth2NetworkConfiguration( this.bellatrixForkEpoch = bellatrixForkEpoch; this.capellaForkEpoch = capellaForkEpoch; this.denebForkEpoch = denebForkEpoch; + this.electraForkEpoch = electraForkEpoch; this.eip7594ForkEpoch = eip7594ForkEpoch; this.eth1DepositContractAddress = eth1DepositContractAddress == null @@ -163,6 +170,13 @@ private Eth2NetworkConfiguration( this.forkChoiceUpdatedAlwaysSendPayloadAttributes = forkChoiceUpdatedAlwaysSendPayloadAttributes; this.rustKzgEnabled = rustKzgEnabled; + + LOG.debug( + "P2P async queue - {} threads, max queue size {} ", asyncP2pMaxThreads, asyncP2pMaxQueue); + LOG.debug( + "P2p beacon chain queue - {} threads, max queue size {} ", + asyncBeaconChainMaxThreads, + asyncBeaconChainMaxQueue); } public static Eth2NetworkConfiguration.Builder builder(final String network) { @@ -182,8 +196,8 @@ public Spec getSpec() { } /** - * @deprecated Constants should be accessed via {@link SpecVersion} * @return The constants resource name or url + * @deprecated Constants should be accessed via {@link SpecVersion} */ @Deprecated public String getConstants() { @@ -224,7 +238,7 @@ public Optional getForkEpoch(final SpecMilestone specMilestone) { case BELLATRIX -> bellatrixForkEpoch; case CAPELLA -> capellaForkEpoch; case DENEB -> denebForkEpoch; - case EIP7594 -> eip7594ForkEpoch; + case ELECTRA -> electraForkEpoch; default -> Optional.empty(); }; } @@ -308,6 +322,7 @@ public boolean equals(final Object o) { && Objects.equals(bellatrixForkEpoch, that.bellatrixForkEpoch) && Objects.equals(capellaForkEpoch, that.capellaForkEpoch) && Objects.equals(denebForkEpoch, that.denebForkEpoch) + && Objects.equals(electraForkEpoch, that.electraForkEpoch) && Objects.equals(eip7594ForkEpoch, that.eip7594ForkEpoch) && Objects.equals(eth1DepositContractAddress, that.eth1DepositContractAddress) && Objects.equals(eth1DepositContractDeployBlock, that.eth1DepositContractDeployBlock) @@ -332,6 +347,7 @@ public int hashCode() { bellatrixForkEpoch, capellaForkEpoch, denebForkEpoch, + electraForkEpoch, eip7594ForkEpoch, eth1DepositContractAddress, eth1DepositContractDeployBlock, @@ -361,9 +377,9 @@ public static class Builder { private int startupTargetPeerCount = DEFAULT_STARTUP_TARGET_PEER_COUNT; private int startupTimeoutSeconds = DEFAULT_STARTUP_TIMEOUT_SECONDS; private int asyncP2pMaxThreads = DEFAULT_ASYNC_P2P_MAX_THREADS; - private int asyncP2pMaxQueue = DEFAULT_ASYNC_P2P_MAX_QUEUE; + private OptionalInt asyncP2pMaxQueue = OptionalInt.empty(); private int asyncBeaconChainMaxThreads = DEFAULT_ASYNC_BEACON_CHAIN_MAX_THREADS; - private int asyncBeaconChainMaxQueue = DEFAULT_ASYNC_BEACON_CHAIN_MAX_QUEUE; + private OptionalInt asyncBeaconChainMaxQueue = OptionalInt.empty(); private List discoveryBootnodes = new ArrayList<>(); private Eth1Address eth1DepositContractAddress; private Optional eth1DepositContractDeployBlock = Optional.empty(); @@ -372,6 +388,7 @@ public static class Builder { private Optional bellatrixForkEpoch = Optional.empty(); private Optional capellaForkEpoch = Optional.empty(); private Optional denebForkEpoch = Optional.empty(); + private Optional electraForkEpoch = Optional.empty(); private Optional eip7594ForkEpoch = Optional.empty(); private Optional terminalBlockHashOverride = Optional.empty(); private Optional totalTerminalDifficultyOverride = Optional.empty(); @@ -384,7 +401,7 @@ public static class Builder { DEFAULT_FORK_CHOICE_UPDATED_ALWAYS_SEND_PAYLOAD_ATTRIBUTES; private boolean rustKzgEnabled = DEFAULT_RUST_KZG_ENABLED; - public void spec(Spec spec) { + public void spec(final Spec spec) { this.spec = spec; } @@ -399,6 +416,10 @@ public Eth2NetworkConfiguration build() { SpecFactory.create( constants, builder -> { + // Ephemery network field change periodically, update to current + if (constants.equals(EPHEMERY.configName())) { + EphemeryNetwork.updateConfig(builder); + } altairForkEpoch.ifPresent( forkEpoch -> builder.altairBuilder( @@ -423,7 +444,15 @@ public Eth2NetworkConfiguration build() { if (maybeEpochsStoreBlobs.isPresent()) { denebBuilder.epochsStoreBlobs(maybeEpochsStoreBlobs); } + if (trustedSetup.isEmpty()) { + LOG.warn( + "Setting a default for trusted setup as nothing was set explicitly"); + trustedSetupFromClasspath(MAINNET_TRUSTED_SETUP_FILENAME); + } }); + builder.electraBuilder( + electraBuilder -> + electraForkEpoch.ifPresent(electraBuilder::electraForkEpoch)); builder.eip7594Builder( eip7594Builder -> eip7594ForkEpoch.ifPresent(eip7594Builder::eip7594ForkEpoch)); @@ -458,6 +487,7 @@ public Eth2NetworkConfiguration build() { bellatrixForkEpoch, capellaForkEpoch, denebForkEpoch, + electraForkEpoch, eip7594ForkEpoch, terminalBlockHashOverride, totalTerminalDifficultyOverride, @@ -465,9 +495,9 @@ public Eth2NetworkConfiguration build() { eth2Network, maybeEpochsStoreBlobs, asyncP2pMaxThreads, - asyncP2pMaxQueue, + asyncP2pMaxQueue.orElse(DEFAULT_ASYNC_P2P_MAX_QUEUE), asyncBeaconChainMaxThreads, - asyncBeaconChainMaxQueue, + asyncBeaconChainMaxQueue.orElse(DEFAULT_ASYNC_BEACON_CHAIN_MAX_QUEUE), forkChoiceLateBlockReorgEnabled, forkChoiceUpdatedAlwaysSendPayloadAttributes, rustKzgEnabled); @@ -484,18 +514,18 @@ private void validateCommandLineParameters() { asyncP2pMaxThreads < 256, "P2P Max threads must be <= 255 (Xnetwork-async-p2p-max-threads - default 10)"); checkArgument( - asyncP2pMaxQueue >= 2000, - "P2P Max Queue size must be at least 2000 (Xnetwork-async-p2p-max-queue - default 5000)"); + asyncP2pMaxQueue.orElse(DEFAULT_ASYNC_P2P_MAX_QUEUE) >= 2000, + "P2P Max Queue size must be at least 2000 (Xnetwork-async-p2p-max-queue - default 10000)"); checkArgument( asyncBeaconChainMaxThreads > 1, - "P2P Max threads must be >= 2 (Xnetwork-async-beaconchain-max-threads - default 5)"); + "BeaconChain Max threads must be >= 2 (Xnetwork-async-beaconchain-max-threads - default 5)"); checkArgument( asyncBeaconChainMaxThreads < 256, - "P2P Max threads must be <= 255 (Xnetwork-async-beaconchain-max-threads - default 5)"); + "BeaconChain Max threads must be <= 255 (Xnetwork-async-beaconchain-max-threads - default 5)"); checkArgument( - asyncBeaconChainMaxQueue >= 2000, - "BeaconChain Max Queue size must be at least 2000 (Xnetwork-async-beaconchain-max-queue - default 5000)"); + asyncBeaconChainMaxQueue.orElse(DEFAULT_ASYNC_BEACON_CHAIN_MAX_QUEUE) >= 2000, + "BeaconChain Max Queue size must be at least 2000 (Xnetwork-async-beaconchain-max-queue - default 10000)"); } public Builder constants(final String constants) { @@ -548,7 +578,7 @@ public Builder customGenesisState(final String genesisState) { } public Builder ignoreWeakSubjectivityPeriodEnabled( - boolean ignoreWeakSubjectivityPeriodEnabled) { + final boolean ignoreWeakSubjectivityPeriodEnabled) { this.allowSyncOutsideWeakSubjectivityPeriod = ignoreWeakSubjectivityPeriodEnabled; return this; } @@ -558,8 +588,15 @@ public Builder asyncP2pMaxThreads(final int asyncP2pMaxThreads) { return this; } - public Builder asyncP2pMaxQueue(Integer asyncP2pMaxQueue) { - this.asyncP2pMaxQueue = asyncP2pMaxQueue; + public Builder asyncP2pMaxQueue(final Integer asyncP2pMaxQueue) { + this.asyncP2pMaxQueue = OptionalInt.of(asyncP2pMaxQueue); + return this; + } + + public Builder asyncP2pMaxQueueIfDefault(final Integer asyncP2pMaxQueue) { + if (this.asyncP2pMaxQueue.isEmpty()) { + return asyncP2pMaxQueue(asyncP2pMaxQueue); + } return this; } @@ -569,7 +606,14 @@ public Builder asyncBeaconChainMaxThreads(final int asyncBeaconChainMaxThreads) } public Builder asyncBeaconChainMaxQueue(final int asyncBeaconChainMaxQueue) { - this.asyncBeaconChainMaxQueue = asyncBeaconChainMaxQueue; + this.asyncBeaconChainMaxQueue = OptionalInt.of(asyncBeaconChainMaxQueue); + return this; + } + + public Builder asyncBeaconChainMaxQueueIfDefault(final int asyncBeaconChainMaxQueue) { + if (this.asyncBeaconChainMaxQueue.isEmpty()) { + return asyncBeaconChainMaxQueue(asyncBeaconChainMaxQueue); + } return this; } @@ -652,6 +696,11 @@ public Builder denebForkEpoch(final UInt64 denebForkEpoch) { return this; } + public Builder electraForkEpoch(final UInt64 electraForkEpoch) { + this.electraForkEpoch = Optional.of(electraForkEpoch); + return this; + } + public Builder eip7594ForkEpoch(final UInt64 eip7594ForkEpoch) { this.eip7594ForkEpoch = Optional.of(eip7594ForkEpoch); return this; @@ -709,10 +758,10 @@ public Builder applyNetworkDefaults(final Eth2Network network) { return switch (network) { case MAINNET -> applyMainnetNetworkDefaults(); case MINIMAL -> applyMinimalNetworkDefaults(); - case PRATER -> applyPraterNetworkDefaults(); case SEPOLIA -> applySepoliaNetworkDefaults(); case LUKSO -> applyLuksoNetworkDefaults(); case HOLESKY -> applyHoleskyNetworkDefaults(); + case EPHEMERY -> applyEphemeryNetworkDefaults(); case GNOSIS -> applyGnosisNetworkDefaults(); case CHIADO -> applyChiadoNetworkDefaults(); case SWIFT -> applySwiftNetworkDefaults(); @@ -787,34 +836,6 @@ public Builder applyMainnetNetworkDefaults() { "enr:-LK4QKWrXTpV9T78hNG6s8AM6IO4XH9kFT91uZtFg1GcsJ6dKovDOr1jtAAFPnS2lvNltkOGA9k29BUN7lFh_sjuc9QBh2F0dG5ldHOIAAAAAAAAAACEZXRoMpC1MD8qAAAAAP__________gmlkgnY0gmlwhANAdd-Jc2VjcDI1NmsxoQLQa6ai7y9PMN5hpLe5HmiJSlYzMuzP7ZhwRiwHvqNXdoN0Y3CCI4yDdWRwgiOM"); } - public Builder applyPraterNetworkDefaults() { - return applyTestnetDefaults() - .constants(PRATER.configName()) - .trustedSetupFromClasspath(MAINNET_TRUSTED_SETUP_FILENAME) - .startupTimeoutSeconds(120) - .eth1DepositContractDeployBlock(4367322) - .defaultInitialStateFromUrl( - "https://github.com/eth2-clients/eth2-testnets/raw/192c1b48ea5ff4adb4e6ef7d2a9e5f82fb5ffd72/shared/prater/genesis.ssz") - .customGenesisState( - "https://github.com/eth2-clients/eth2-testnets/raw/192c1b48ea5ff4adb4e6ef7d2a9e5f82fb5ffd72/shared/prater/genesis.ssz") - .discoveryBootnodes( - // Teku bootnode - "enr:-KK4QH0RsNJmIG0EX9LSnVxMvg-CAOr3ZFF92hunU63uE7wcYBjG1cFbUTvEa5G_4nDJkRhUq9q2ck9xY-VX1RtBsruBtIRldGgykIL0pysBABAg__________-CaWSCdjSCaXCEEnXQ0YlzZWNwMjU2azGhA1grTzOdMgBvjNrk-vqWtTZsYQIi0QawrhoZrsn5Hd56g3RjcIIjKIN1ZHCCIyg", - // q9f bootnode errai (lighthouse) - "enr:-LK4QH1xnjotgXwg25IDPjrqRGFnH1ScgNHA3dv1Z8xHCp4uP3N3Jjl_aYv_WIxQRdwZvSukzbwspXZ7JjpldyeVDzMCh2F0dG5ldHOIAAAAAAAAAACEZXRoMpB53wQoAAAQIP__________gmlkgnY0gmlwhIe1te-Jc2VjcDI1NmsxoQOkcGXqbCJYbcClZ3z5f6NWhX_1YPFRYRRWQpJjwSHpVIN0Y3CCIyiDdWRwgiMo", - // q9f bootnode gudja (teku) - "enr:-KG4QCIzJZTY_fs_2vqWEatJL9RrtnPwDCv-jRBuO5FQ2qBrfJubWOWazri6s9HsyZdu-fRUfEzkebhf1nvO42_FVzwDhGV0aDKQed8EKAAAECD__________4JpZIJ2NIJpcISHtbYziXNlY3AyNTZrMaED4m9AqVs6F32rSCGsjtYcsyfQE2K8nDiGmocUY_iq-TSDdGNwgiMog3VkcIIjKA", - // Prysm bootnode #1 - "enr:-Ku4QFmUkNp0g9bsLX2PfVeIyT-9WO-PZlrqZBNtEyofOOfLMScDjaTzGxIb1Ns9Wo5Pm_8nlq-SZwcQfTH2cgO-s88Bh2F0dG5ldHOIAAAAAAAAAACEZXRoMpDkvpOTAAAQIP__________gmlkgnY0gmlwhBLf22SJc2VjcDI1NmsxoQLV_jMOIxKbjHFKgrkFvwDvpexo6Nd58TK5k7ss4Vt0IoN1ZHCCG1g", - // Lighthouse bootnode #1 - "enr:-Ly4QFPk-cTMxZ3jWTafiNblEZkQIXGF2aVzCIGW0uHp6KaEAvBMoctE8S7YU0qZtuS7By0AA4YMfKoN9ls_GJRccVpFh2F0dG5ldHOI__________-EZXRoMpCC9KcrAgAQIIS2AQAAAAAAgmlkgnY0gmlwhKh3joWJc2VjcDI1NmsxoQKrxz8M1IHwJqRIpDqdVW_U1PeixMW5SfnBD-8idYIQrIhzeW5jbmV0cw-DdGNwgiMog3VkcIIjKA", - // Lighthouse bootnode #2 - "enr:-L64QJmwSDtaHVgGiqIxJWUtxWg6uLCipsms6j-8BdsOJfTWAs7CLF9HJnVqFE728O-JYUDCxzKvRdeMqBSauHVCMdaCAVWHYXR0bmV0c4j__________4RldGgykIL0pysCABAghLYBAAAAAACCaWSCdjSCaXCEQWxOdolzZWNwMjU2azGhA7Qmod9fK86WidPOzLsn5_8QyzL7ZcJ1Reca7RnD54vuiHN5bmNuZXRzD4N0Y3CCIyiDdWRwgiMo", - // Nimbus bootstrap nodes - "enr:-LK4QMzPq4Q7w5R-rnGQDcI8BYky6oPVBGQTbS1JJLVtNi_8PzBLV7Bdzsoame9nJK5bcJYpGHn4SkaDN2CM6tR5G_4Bh2F0dG5ldHOIAAAAAAAAAACEZXRoMpB53wQoAAAQIP__________gmlkgnY0gmlwhAN4yvyJc2VjcDI1NmsxoQKa8Qnp_P2clLIP6VqLKOp_INvEjLszalEnW0LoBZo4YYN0Y3CCI4yDdWRwgiOM", - "enr:-LK4QLM_pPHa78R8xlcU_s40Y3XhFjlb3kPddW9lRlY67N5qeFE2Wo7RgzDgRs2KLCXODnacVHMFw1SfpsW3R474RZEBh2F0dG5ldHOIAAAAAAAAAACEZXRoMpB53wQoAAAQIP__________gmlkgnY0gmlwhANBY-yJc2VjcDI1NmsxoQNsZkFXgKbTzuxF7uwxlGauTGJelE6HD269CcFlZ_R7A4N0Y3CCI4yDdWRwgiOM"); - } - private Builder applySepoliaNetworkDefaults() { return applyTestnetDefaults() .constants(SEPOLIA.configName()) @@ -827,12 +848,17 @@ private Builder applySepoliaNetworkDefaults() { "https://github.com/eth-clients/merge-testnets/raw/9c873ab67b902aa676370a549129e5e91013afa3/sepolia/genesis.ssz") .discoveryBootnodes( // EF bootnodes - "enr:-Iq4QMCTfIMXnow27baRUb35Q8iiFHSIDBJh6hQM5Axohhf4b6Kr_cOCu0htQ5WvVqKvFgY28893DHAg8gnBAXsAVqmGAX53x8JggmlkgnY0gmlwhLKAlv6Jc2VjcDI1NmsxoQK6S-Cii_KmfFdUJL2TANL3ksaKUnNXvTCv1tLwXs0QgIN1ZHCCIyk", - "enr:-KG4QE5OIg5ThTjkzrlVF32WT_-XT14WeJtIz2zoTqLLjQhYAmJlnk4ItSoH41_2x0RX0wTFIe5GgjRzU2u7Q1fN4vADhGV0aDKQqP7o7pAAAHAyAAAAAAAAAIJpZIJ2NIJpcISlFsStiXNlY3AyNTZrMaEC-Rrd_bBZwhKpXzFCrStKp1q_HmGOewxY3KwM8ofAj_ODdGNwgiMog3VkcIIjKA", + "enr:-Ku4QDZ_rCowZFsozeWr60WwLgOfHzv1Fz2cuMvJqN5iJzLxKtVjoIURY42X_YTokMi3IGstW5v32uSYZyGUXj9Q_IECh2F0dG5ldHOIAAAAAAAAAACEZXRoMpCo_ujukAAAaf__________gmlkgnY0gmlwhIpEe5iJc2VjcDI1NmsxoQNHTpFdaNSCEWiN_QqT396nb0PzcUpLe3OVtLph-AciBYN1ZHCCIy0", + "enr:-Ku4QHRyRwEPT7s0XLYzJ_EeeWvZTXBQb4UCGy1F_3m-YtCNTtDlGsCMr4UTgo4uR89pv11uM-xq4w6GKfKhqU31hTgCh2F0dG5ldHOIAAAAAAAAAACEZXRoMpCo_ujukAAAaf__________gmlkgnY0gmlwhIrFM7WJc2VjcDI1NmsxoQI4diTwChN3zAAkarf7smOHCdFb1q3DSwdiQ_Lc_FdzFIN1ZHCCIy0", + "enr:-Ku4QOkvvf0u5Hg4-HhY-SJmEyft77G5h3rUM8VF_e-Hag5cAma3jtmFoX4WElLAqdILCA-UWFRN1ZCDJJVuEHrFeLkDh2F0dG5ldHOIAAAAAAAAAACEZXRoMpCo_ujukAAAaf__________gmlkgnY0gmlwhJK-AWeJc2VjcDI1NmsxoQLFcT5VE_NMiIC8Ll7GypWDnQ4UEmuzD7hF_Hf4veDJwIN1ZHCCIy0", + "enr:-Ku4QH6tYsHKITYeHUu5kdfXgEZWI18EWk_2RtGOn1jBPlx2UlS_uF3Pm5Dx7tnjOvla_zs-wwlPgjnEOcQDWXey51QCh2F0dG5ldHOIAAAAAAAAAACEZXRoMpCo_ujukAAAaf__________gmlkgnY0gmlwhIs7Mc6Jc2VjcDI1NmsxoQIET4Mlv9YzhrYhX_H9D7aWMemUrvki6W4J2Qo0YmFMp4N1ZHCCIy0", + "enr:-Ku4QDmz-4c1InchGitsgNk4qzorWMiFUoaPJT4G0IiF8r2UaevrekND1o7fdoftNucirj7sFFTTn2-JdC2Ej0p1Mn8Ch2F0dG5ldHOIAAAAAAAAAACEZXRoMpCo_ujukAAAaf__________gmlkgnY0gmlwhKpA-liJc2VjcDI1NmsxoQMpHP5U1DK8O_JQU6FadmWbE42qEdcGlllR8HcSkkfWq4N1ZHCCIy0", // Teku bootnode - "enr:-Ly4QFoZTWR8ulxGVsWydTNGdwEESueIdj-wB6UmmjUcm-AOPxnQi7wprzwcdo7-1jBW_JxELlUKJdJES8TDsbl1EdNlh2F0dG5ldHOI__78_v2bsV-EZXRoMpA2-lATkAAAcf__________gmlkgnY0gmlwhBLYJjGJc2VjcDI1NmsxoQI0gujXac9rMAb48NtMqtSTyHIeNYlpjkbYpWJw46PmYYhzeW5jbmV0cw-DdGNwgiMog3VkcIIjKA", + "enr:-KO4QP7MmB3juk8rUjJHcUoxZDU9Np4FlW0HyDEGIjSO7GD9PbSsabu7713cWSUWKDkxIypIXg1A-6lG7ySRGOMZHeGCAmuEZXRoMpDTH2GRkAAAc___________gmlkgnY0gmlwhBSoyGOJc2VjcDI1NmsxoQNta5b_bexSSwwrGW2Re24MjfMntzFd0f2SAxQtMj3ueYN0Y3CCIyiDdWRwgiMo", // Another bootnode - "enr:-L64QC9Hhov4DhQ7mRukTOz4_jHm4DHlGL726NWH4ojH1wFgEwSin_6H95Gs6nW2fktTWbPachHJ6rUFu0iJNgA0SB2CARqHYXR0bmV0c4j__________4RldGgykDb6UBOQAABx__________-CaWSCdjSCaXCEA-2vzolzZWNwMjU2azGhA17lsUg60R776rauYMdrAz383UUgESoaHEzMkvm4K6k6iHN5bmNuZXRzD4N0Y3CCIyiDdWRwgiMo"); + "enr:-L64QC9Hhov4DhQ7mRukTOz4_jHm4DHlGL726NWH4ojH1wFgEwSin_6H95Gs6nW2fktTWbPachHJ6rUFu0iJNgA0SB2CARqHYXR0bmV0c4j__________4RldGgykDb6UBOQAABx__________-CaWSCdjSCaXCEA-2vzolzZWNwMjU2azGhA17lsUg60R776rauYMdrAz383UUgESoaHEzMkvm4K6k6iHN5bmNuZXRzD4N0Y3CCIyiDdWRwgiMo", + // Lodestart bootnode + "enr:-KG4QJejf8KVtMeAPWFhN_P0c4efuwu1pZHELTveiXUeim6nKYcYcMIQpGxxdgT2Xp9h-M5pr9gn2NbbwEAtxzu50Y8BgmlkgnY0gmlwhEEVkQCDaXA2kCoBBPnAEJg4AAAAAAAAAAGJc2VjcDI1NmsxoQLEh_eVvk07AQABvLkTGBQTrrIOQkzouMgSBtNHIRUxOIN1ZHCCIyiEdWRwNoIjKA"); } private Builder applyLuksoNetworkDefaults() { @@ -913,12 +939,29 @@ private Builder applyHoleskyNetworkDefaults() { // EF bootnodes "enr:-Ku4QFo-9q73SspYI8cac_4kTX7yF800VXqJW4Lj3HkIkb5CMqFLxciNHePmMt4XdJzHvhrCC5ADI4D_GkAsxGJRLnQBh2F0dG5ldHOIAAAAAAAAAACEZXRoMpAhnTT-AQFwAP__________gmlkgnY0gmlwhLKAiOmJc2VjcDI1NmsxoQORcM6e19T1T9gi7jxEZjk_sjVLGFscUNqAY9obgZaxbIN1ZHCCIyk", "enr:-Ku4QPG7F72mbKx3gEQEx07wpYYusGDh-ni6SNkLvOS-hhN-BxIggN7tKlmalb0L5JPoAfqD-akTZ-gX06hFeBEz4WoBh2F0dG5ldHOIAAAAAAAAAACEZXRoMpAhnTT-AQFwAP__________gmlkgnY0gmlwhJK-DYCJc2VjcDI1NmsxoQKLVXFOhp2uX6jeT0DvvDpPcU8FWMjQdR4wMuORMhpX24N1ZHCCIyk", - "enr:-KG4QF6d6vMSboSujAXTI4vYqArccm0eIlXfcxf2Lx_VE1q6IkQo_2D5LAO3ZSBVUs0w5rrVDmABJZuMzISe_pZundADhGV0aDKQqX6DZjABcAAAAQAAAAAAAIJpZIJ2NIJpcISygIjpiXNlY3AyNTZrMaEDF3aSa7QSCvdqLpANNd8GML4PLEZVg45fKQwMWhDZjd2DdGNwgiMog3VkcIIjKA", - "enr:-Ly4QJLXSSAj3ggPBIcodvBU6IyfpU_yW7E9J-5syoJorBuvcYj_Fokcjr303bQoTdWXADf8po0ssh75Mr5wVGzZZsMBh2F0dG5ldHOIAAAAAAAAAACEZXRoMpCpfoNmMAFwAAABAAAAAAAAgmlkgnY0gmlwhJK-DYCJc2VjcDI1NmsxoQJrIlXIQDvQ6t9yDySqJYDXgZgLXzTvq8W7OI51jfmxJohzeW5jbmV0cwCDdGNwgiMog3VkcIIjKA", + "enr:-LK4QPxe-mDiSOtEB_Y82ozvxn9aQM07Ui8A-vQHNgYGMMthfsfOabaaTHhhJHFCBQQVRjBww_A5bM1rf8MlkJU_l68Eh2F0dG5ldHOIAADAAAAAAACEZXRoMpBpt9l0BAFwAAABAAAAAAAAgmlkgnY0gmlwhLKAiOmJc2VjcDI1NmsxoQJu6T9pclPObAzEVQ53DpVQqjadmVxdTLL-J3h9NFoCeIN0Y3CCIyiDdWRwgiMo", + "enr:-Ly4QGbOw4xNel5EhmDsJJ-QhC9XycWtsetnWoZ0uRy381GHdHsNHJiCwDTOkb3S1Ade0SFQkWJX_pgb3g8Jfh93rvMBh2F0dG5ldHOIAAAAAAAAAACEZXRoMpBpt9l0BAFwAAABAAAAAAAAgmlkgnY0gmlwhJK-DYCJc2VjcDI1NmsxoQOxKv9sv3zKF8GDewgFGGHKP5HCZZpPpTrwl9eXKAWGxIhzeW5jbmV0cwCDdGNwgiMog3VkcIIjKA", // Sigma Prime "enr:-Le4QLoE1wFHSlGcm48a9ZESb_MRLqPPu6G0vHqu4MaUcQNDHS69tsy-zkN0K6pglyzX8m24mkb-LtBcbjAYdP1uxm4BhGV0aDKQabfZdAQBcAAAAQAAAAAAAIJpZIJ2NIJpcIQ5gR6Wg2lwNpAgAUHQBwEQAAAAAAAAADR-iXNlY3AyNTZrMaEDPMSNdcL92uNIyCsS177Z6KTXlbZakQqxv3aQcWawNXeDdWRwgiMohHVkcDaCI4I", // TEKU bootnode - "enr:-LS4QG0uV4qvcpJ-HFDJRGBmnlD3TJo7yc4jwK8iP7iKaTlfQ5kZvIDspLMJhk7j9KapuL9yyHaZmwTEZqr10k9XumyCEcmHYXR0bmV0c4gAAAAABgAAAIRldGgykGm32XQEAXAAAAEAAAAAAACCaWSCdjSCaXCErK4j-YlzZWNwMjU2azGhAgfWRBEJlb7gAhXIB5ePmjj2b8io0UpEenq1Kl9cxStJg3RjcIIjKIN1ZHCCIyg"); + "enr:-KO4QCi3ZY4TM5KL7bAG6laSYiYelDWu0crvUjCXlyc_cwEfUpMIuARuMJYGxWe-UYYpHEw_aBbZ1u-4tHQ8imyI5uaCAsGEZXRoMpBprg6ZBQFwAP__________gmlkgnY0gmlwhKyuI_mJc2VjcDI1NmsxoQLoFG5-vuNX6N49vnkTBaA3ZsBDF8B30DGqWOGtRGz5w4N0Y3CCIyiDdWRwgiMo", + // Lodestar bootnode + "enr:-KG4QC9Wm32mtzB5Fbj2ri2TEKglHmIWgvwTQCvNHBopuwpNAi1X6qOsBg_Z1-Bee-kfSrhzUQZSgDUyfH5outUprtoBgmlkgnY0gmlwhHEel3eDaXA2kP6AAAAAAAAAAlBW__4Srr-Jc2VjcDI1NmsxoQO7KE63Z4eSI55S1Yn7q9_xFkJ1Wt-a3LgiXuKGs19s0YN1ZHCCIyiEdWRwNoIjKA"); + } + + private Builder applyEphemeryNetworkDefaults() { + return applyTestnetDefaults() + .constants(EPHEMERY.configName()) + .startupTimeoutSeconds(120) + .trustedSetupFromClasspath(MAINNET_TRUSTED_SETUP_FILENAME) + .eth1DepositContractDeployBlock(0) + .checkpointSyncUrl("https://ephemery.beaconstate.ethstaker.cc") + .discoveryBootnodes( + "enr:-Iq4QNMYHuJGbnXyBj6FPS2UkOQ-hnxT-mIdNMMr7evR9UYtLemaluorL6J10RoUG1V4iTPTEbl3huijSNs5_ssBWFiGAYhBNHOzgmlkgnY0gmlwhIlKy_CJc2VjcDI1NmsxoQNULnJBzD8Sakd9EufSXhM4rQTIkhKBBTmWVJUtLCp8KoN1ZHCCIyk", + "enr:-LK4QDvXfoKH4pVoVoJx3vz0q-3nFtxYKgIacrYPuorPO-KrGlOwQOlCDEPh0e_1x9O2Ob6YWajVU6y7IjIGYOQfXkwEh2F0dG5ldHOIAAAAAACAAQCEZXRoMpDKcygcUAAQG___________gmlkgnY0gmlwhIlKy_CJc2VjcDI1NmsxoQOqgG9xgvsFBhOI6mfWosFJheJOxvVz2zlbQzMeK-S7dIN0Y3CCI4yDdWRwgiOM", + "enr:-Jq4QI0JCZcwDmfiuBbzjtmE_QTQVi4-jRUJko5RMq1RCjQeTXncHIoCtriXgU_FrCtl9R2AKSyHcmF0fCuS4pIL4h0BhGV0aDKQynMoHFAAEBv__________4JpZIJ2NIJpcIRBbZouiXNlY3AyNTZrMaEC8GXWOjFPp85Cpv9CY6V-CfzNPkMm0VyNNeuiFxfjg3mDdWRwgiMp", + "enr:-Iq4QIc297-de1P6hznMX2cIdVsQkve9BD9NUsJ7vVQa7eh5UpekA9rLid5A-yLiS3gZwOGugYZPi58x76zNs2cEQFCGAYhBJlTYgmlkgnY0gmlwhEFtmi6Jc2VjcDI1NmsxoQJDyix-IHa_mVwLBEN9NeG8I-RUjNQK_MGxk9OqRQUAtIN1ZHCCIyg", + "enr:-MS4QPNnPV4zZJkeytVQTm8fg3Mrtyq7l3oVy9ht4229w5OUOftE2EsXAfgxEopHavIPTzdWGchD-rXDh_eS6fdF_dsBh2F0dG5ldHOIAAAAAAAAAACEZXRoMpDKcygcUAAQG___________gmlkgnY0gmlwhKfrAbmEcXVpY4IjUYlzZWNwMjU2azGhAwnM8CLwGlnZFe7XhDoC4PSYZMvWypChdu0NX9vmCGjKiHN5bmNuZXRzAIN0Y3CCI1CDdWRwgiNQ"); } private Optional validateAndParseEpochsStoreBlobs(final String epochsStoreBlobs) { @@ -942,13 +985,13 @@ private Optional validateAndParseEpochsStoreBlobs(final String epochsSt return Optional.of(epochsStoreBlobsInt); } - public Builder forkChoiceLateBlockReorgEnabled(boolean forkChoiceLateBlockReorgEnabled) { + public Builder forkChoiceLateBlockReorgEnabled(final boolean forkChoiceLateBlockReorgEnabled) { this.forkChoiceLateBlockReorgEnabled = forkChoiceLateBlockReorgEnabled; return this; } public Builder forkChoiceUpdatedAlwaysSendPayloadAttributes( - boolean forkChoiceUpdatedAlwaysSendPayloadAttributes) { + final boolean forkChoiceUpdatedAlwaysSendPayloadAttributes) { this.forkChoiceUpdatedAlwaysSendPayloadAttributes = forkChoiceUpdatedAlwaysSendPayloadAttributes; return this; diff --git a/ethereum/networks/src/main/resources/tech/pegasys/teku/networks/minimal-trusted-setup.txt b/ethereum/networks/src/main/resources/tech/pegasys/teku/networks/minimal-trusted-setup.txt index 5ecccf5e5e5..47d17784051 100644 --- a/ethereum/networks/src/main/resources/tech/pegasys/teku/networks/minimal-trusted-setup.txt +++ b/ethereum/networks/src/main/resources/tech/pegasys/teku/networks/minimal-trusted-setup.txt @@ -8256,4 +8256,4 @@ b417fdaf719caf38854e89ce52031b30ce61a632e6c3135adec9002280e022d82ab0ea4ac5ebdb21 9367a6feb5e23ea2eab8ddd5e7bdf32b4d2419fad1c71a1ed327b77362d8942dad971a1c2e6f7073885149cdf0a0c339 a71c5c08d50c57d094d6a4f02e97d3799bada92f238ffc07bd223bbe8379507b7310d20b28f5bbbf331e5e153515e491 9630a9a3bcb044b51299c4d3d3388a4ff47308dd27be3229601985478c0f6b55faa7e20815d8694f910611396a9d0d45 -b0bfaf56a5aa59b48960aa7c1617e832e65c823523fb2a5cd44ba606800501cf873e8db1d0dda64065285743dc40786e \ No newline at end of file +b0bfaf56a5aa59b48960aa7c1617e832e65c823523fb2a5cd44ba606800501cf873e8db1d0dda64065285743dc40786e diff --git a/ethereum/networks/src/test/java/tech/pegasys/teku/networks/EphemeryNetworkTest.java b/ethereum/networks/src/test/java/tech/pegasys/teku/networks/EphemeryNetworkTest.java new file mode 100644 index 00000000000..4cf1a8d9bea --- /dev/null +++ b/ethereum/networks/src/test/java/tech/pegasys/teku/networks/EphemeryNetworkTest.java @@ -0,0 +1,263 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.networks; + +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.io.IOException; +import java.io.InputStream; +import java.util.function.Consumer; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.infrastructure.time.StubTimeProvider; +import tech.pegasys.teku.infrastructure.time.SystemTimeProvider; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecFactory; +import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.config.SpecConfigAndParent; +import tech.pegasys.teku.spec.config.SpecConfigLoader; +import tech.pegasys.teku.spec.config.SpecConfigReader; +import tech.pegasys.teku.spec.config.builder.SpecConfigBuilder; +import tech.pegasys.teku.spec.logic.common.helpers.MiscHelpers; + +public class EphemeryNetworkTest { + private static final long GENESIS_CHAINID = 39438135; + private static final long ONE_PERIOD = 1; + private static final int MANY_PERIOD = 1000; + private static final long MIN_GENESIS_TIME = 1720119600; + private final SystemTimeProvider timeProvider = new SystemTimeProvider(); + + private SpecConfigBuilder builder; + private static final long CURRENT_TIMESTAMP = 1725547734; + private static final int PERIOD = 28; + private static final long PERIOD_IN_SECONDS = (PERIOD * 24 * 60 * 60); + private long expectedMinGenesisTime; + private long expectedChainId; + private long periodSinceGenesis; + private final SpecConfigReader reader = new SpecConfigReader(); + private SpecConfigAndParent configFile; + private SpecConfig config; + + @BeforeEach + void setUp() { + periodSinceGenesis = EphemeryNetwork.getPeriodsSinceGenesis(timeProvider); + expectedMinGenesisTime = MIN_GENESIS_TIME + (periodSinceGenesis * PERIOD_IN_SECONDS); + expectedChainId = GENESIS_CHAINID + periodSinceGenesis; + builder = mock(SpecConfigBuilder.class); + configFile = SpecConfigLoader.loadConfig("ephemery"); + config = mock(SpecConfig.class); + } + + @Test + public void testUpdateConfig() { + when(config.getRawConfig()).thenReturn(configFile.specConfig().getRawConfig()); + when(builder.rawConfig(config.getRawConfig())).thenReturn(builder); + when(builder.depositChainId(expectedChainId)).thenReturn(builder); + when(builder.depositNetworkId(expectedChainId)).thenReturn(builder); + when(builder.minGenesisTime(UInt64.valueOf(expectedMinGenesisTime))).thenReturn(builder); + + EphemeryNetwork.updateConfig(builder); + + verify(builder, times(1)).rawConfig(config.getRawConfig()); // Only verify once + verify(builder, times(1)).depositNetworkId(expectedChainId); + verify(builder, times(1)).depositChainId(expectedChainId); + verify(builder, times(1)).minGenesisTime(UInt64.valueOf(expectedMinGenesisTime)); + assertThat(CURRENT_TIMESTAMP).isGreaterThan(GENESIS_CHAINID + PERIOD_IN_SECONDS); + } + + @Test + public void shouldLoadDepositNetworkId() { + final Spec spec = getSpec(phase0Builder -> phase0Builder.depositNetworkId(GENESIS_CHAINID)); + + assertThat(spec.getGenesisSpec().getConfig().getRawConfig().get("DEPOSIT_NETWORK_ID")) + .isEqualTo(String.valueOf(GENESIS_CHAINID)); + } + + @Test + public void shouldLoadDepositChainId() { + final Spec spec = getSpec(phase0Builder -> phase0Builder.depositChainId(GENESIS_CHAINID)); + + assertThat(spec.getGenesisSpec().getConfig().getRawConfig().get("DEPOSIT_CHAIN_ID")) + .isEqualTo(String.valueOf(GENESIS_CHAINID)); + } + + @Test + public void shouldLoadMinGenesisTime() { + final Spec spec = + getSpec(phase0Builder -> phase0Builder.minGenesisTime(UInt64.valueOf(MIN_GENESIS_TIME))); + + assertThat(spec.getGenesisSpec().getConfig().getRawConfig().get("MIN_GENESIS_TIME")) + .isEqualTo(String.valueOf(MIN_GENESIS_TIME)); + } + + @Test + public void read_missingConfig() { + processFileAsInputStream(getInvalidConfigPath("missingChurnLimit"), this::readConfig); + + assertThatThrownBy(reader::build) + .isInstanceOf(IllegalArgumentException.class) + .hasMessageContaining("MIN_PER_EPOCH_CHURN_LIMIT"); + } + + @Test + void shouldNotUpdateConfigBeforeGenesis() { + final Spec spec = + getSpec(phase0Builder -> phase0Builder.minGenesisTime(UInt64.valueOf(MIN_GENESIS_TIME))); + + final long preGenesisTime = MIN_GENESIS_TIME - ONE_PERIOD; + final StubTimeProvider stubTimeProvider = StubTimeProvider.withTimeInSeconds(preGenesisTime); + EphemeryNetwork.updateConfig(builder, stubTimeProvider); + + assertThat(spec.getGenesisSpec().getConfig().getRawConfig().get("MIN_GENESIS_TIME")) + .isEqualTo(String.valueOf(MIN_GENESIS_TIME)); + assertThat(spec.getGenesisSpec().getConfig().getRawConfig().get("DEPOSIT_CHAIN_ID")) + .isEqualTo(String.valueOf(GENESIS_CHAINID)); + assertThat(spec.getGenesisSpec().getConfig().getRawConfig().get("DEPOSIT_NETWORK_ID")) + .isEqualTo(String.valueOf(GENESIS_CHAINID)); + } + + @Test + public void shouldUpdateConfigAfterFirstPeriod() { + + final long onePeriodSinceGenesis = MIN_GENESIS_TIME + PERIOD_IN_SECONDS + ONE_PERIOD; + + final StubTimeProvider stubTimeProvider = + StubTimeProvider.withTimeInSeconds(onePeriodSinceGenesis); + final long genesisChainidAfterFirstPeriod = GENESIS_CHAINID + ONE_PERIOD; + + final long expectedMinGenesisTime = MIN_GENESIS_TIME + (ONE_PERIOD * PERIOD_IN_SECONDS); + + when(config.getRawConfig()).thenReturn(configFile.specConfig().getRawConfig()); + when(builder.rawConfig(config.getRawConfig())).thenReturn(builder); + when(builder.depositChainId(genesisChainidAfterFirstPeriod)).thenReturn(builder); + when(builder.depositNetworkId(genesisChainidAfterFirstPeriod)).thenReturn(builder); + when(builder.minGenesisTime(UInt64.valueOf(expectedMinGenesisTime))).thenReturn(builder); + + EphemeryNetwork.updateConfig(builder, stubTimeProvider); + + verify(builder, times(1)).rawConfig(config.getRawConfig()); // Only verify once + verify(builder, times(1)).depositNetworkId(genesisChainidAfterFirstPeriod); + verify(builder, times(1)).depositChainId(genesisChainidAfterFirstPeriod); + verify(builder, times(1)).minGenesisTime(UInt64.valueOf(expectedMinGenesisTime)); + assertThat(CURRENT_TIMESTAMP).isGreaterThan(genesisChainidAfterFirstPeriod + PERIOD_IN_SECONDS); + } + + @Test + public void shouldUpdateConfigForManyPeriods() { + + final long timeFor1000Periods = MIN_GENESIS_TIME + (MANY_PERIOD * PERIOD_IN_SECONDS); + final StubTimeProvider stubTimeProvider = + StubTimeProvider.withTimeInSeconds(timeFor1000Periods); + + final long genesisChainIdAfter1000Period = GENESIS_CHAINID + MANY_PERIOD; + + final long expectedMinGenesisTime = MIN_GENESIS_TIME + MANY_PERIOD * PERIOD_IN_SECONDS; + + when(config.getRawConfig()).thenReturn(configFile.specConfig().getRawConfig()); + when(builder.rawConfig(config.getRawConfig())).thenReturn(builder); + when(builder.depositChainId(genesisChainIdAfter1000Period)).thenReturn(builder); + when(builder.depositNetworkId(genesisChainIdAfter1000Period)).thenReturn(builder); + when(builder.minGenesisTime(UInt64.valueOf(expectedMinGenesisTime))).thenReturn(builder); + + EphemeryNetwork.updateConfig(builder, stubTimeProvider); + + verify(builder, times(1)).rawConfig(config.getRawConfig()); // Only verify once + verify(builder, times(1)).depositNetworkId(genesisChainIdAfter1000Period); + verify(builder, times(1)).depositChainId(genesisChainIdAfter1000Period); + verify(builder, times(1)).minGenesisTime(UInt64.valueOf(expectedMinGenesisTime)); + + assertThat(expectedMinGenesisTime).isGreaterThan(MIN_GENESIS_TIME); + assertThat(genesisChainIdAfter1000Period).isGreaterThan(GENESIS_CHAINID); + assertThat(CURRENT_TIMESTAMP + expectedMinGenesisTime) + .isGreaterThan(genesisChainIdAfter1000Period + PERIOD_IN_SECONDS); + } + + @Test + void checkEphemeryMaxSlot() { + final Spec spec = + getSpec(phase0Builder -> phase0Builder.minGenesisTime(UInt64.valueOf(MIN_GENESIS_TIME))); + final long timeBeforeNextPeriod = MIN_GENESIS_TIME + PERIOD_IN_SECONDS - 1; + final MiscHelpers miscHelpers = new MiscHelpers(spec.getGenesisSpecConfig()); + assertThat( + miscHelpers + .computeSlotAtTime( + UInt64.valueOf(MIN_GENESIS_TIME), UInt64.valueOf(timeBeforeNextPeriod)) + .longValue()) + .isEqualTo(EphemeryNetwork.MAX_EPHEMERY_SLOT); + } + + @Test + void shouldNotUpdateConfigBeforeNextPeriod() { + final Spec spec = + getSpec(phase0Builder -> phase0Builder.minGenesisTime(UInt64.valueOf(MIN_GENESIS_TIME))); + final long timeBeforeNextPeriod = MIN_GENESIS_TIME + PERIOD_IN_SECONDS - 1; + final StubTimeProvider stubTimeProvider = + StubTimeProvider.withTimeInSeconds(timeBeforeNextPeriod); + + EphemeryNetwork.updateConfig(builder, stubTimeProvider); + + assertThat(spec.getGenesisSpec().getConfig().getRawConfig().get("MIN_GENESIS_TIME")) + .isEqualTo(String.valueOf(MIN_GENESIS_TIME)); + assertThat(spec.getGenesisSpec().getConfig().getRawConfig().get("DEPOSIT_CHAIN_ID")) + .isEqualTo(String.valueOf(GENESIS_CHAINID)); + assertThat(spec.getGenesisSpec().getConfig().getRawConfig().get("DEPOSIT_NETWORK_ID")) + .isEqualTo(String.valueOf(GENESIS_CHAINID)); + } + + private static String getInvalidConfigPath(final String name) { + return getConfigPath(name); + } + + private static String getConfigPath(final String name) { + final String path = "tech/pegasys/teku/networks/"; + return path + name + ".yaml"; + } + + private void processFileAsInputStream(final String fileName, final InputStreamHandler handler) { + try (final InputStream inputStream = getFileFromResourceAsStream(fileName)) { + handler.accept(inputStream); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + private InputStream getFileFromResourceAsStream(final String fileName) { + final InputStream inputStream = getClass().getClassLoader().getResourceAsStream(fileName); + if (inputStream == null) { + throw new IllegalArgumentException("File not found: " + fileName); + } + + return inputStream; + } + + private interface InputStreamHandler { + void accept(InputStream inputStream) throws IOException; + } + + private void readConfig(final InputStream preset) throws IOException { + reader.readAndApply(preset, false); + } + + private Spec getSpec(final Consumer consumer) { + final SpecConfigAndParent config = + SpecConfigLoader.loadConfig("ephemery", consumer); + return SpecFactory.create(config); + } +} diff --git a/ethereum/networks/src/test/java/tech/pegasys/teku/networks/Eth2NetworkConfigurationTest.java b/ethereum/networks/src/test/java/tech/pegasys/teku/networks/Eth2NetworkConfigurationTest.java index 5486358e7a6..33ae685fefa 100644 --- a/ethereum/networks/src/test/java/tech/pegasys/teku/networks/Eth2NetworkConfigurationTest.java +++ b/ethereum/networks/src/test/java/tech/pegasys/teku/networks/Eth2NetworkConfigurationTest.java @@ -47,15 +47,6 @@ public void build_shouldBuildKnownNetworks( assertThat(networkConfig.getNetworkBoostrapConfig().isUsingCustomInitialState()).isFalse(); } - @Test - void shouldAliasGoerliToPrater() { - final Eth2NetworkConfiguration goerliConfig = - Eth2NetworkConfiguration.builder("goerli").build(); - final Eth2NetworkConfiguration praterConfig = - Eth2NetworkConfiguration.builder("prater").build(); - assertThat(goerliConfig).isEqualTo(praterConfig); - } - @Test @SuppressWarnings("deprecation") public void builder_usingConstantsUrl() { @@ -137,13 +128,15 @@ public static Stream getDefinedNetworks() { return Stream.of( Arguments.of(Eth2Network.MAINNET, (NetworkDefinition) b -> b.applyMainnetNetworkDefaults()), Arguments.of(Eth2Network.MINIMAL, (NetworkDefinition) b -> b.applyMinimalNetworkDefaults()), - Arguments.of(Eth2Network.PRATER, (NetworkDefinition) b -> b.applyPraterNetworkDefaults()), Arguments.of( Eth2Network.HOLESKY, (NetworkDefinition) b -> b.applyNetworkDefaults(Eth2Network.HOLESKY)), Arguments.of( Eth2Network.SEPOLIA, (NetworkDefinition) b -> b.applyNetworkDefaults(Eth2Network.SEPOLIA)), + Arguments.of( + Eth2Network.EPHEMERY, + (NetworkDefinition) b -> b.applyNetworkDefaults(Eth2Network.EPHEMERY)), Arguments.of(Eth2Network.SWIFT, (NetworkDefinition) b -> b.applySwiftNetworkDefaults()), Arguments.of( Eth2Network.LESS_SWIFT, (NetworkDefinition) b -> b.applyLessSwiftNetworkDefaults()), @@ -151,7 +144,7 @@ public static Stream getDefinedNetworks() { Arguments.of(Eth2Network.CHIADO, (NetworkDefinition) b -> b.applyChiadoNetworkDefaults())); } - private List parseBootnodes(List bootnodes) { + private List parseBootnodes(final List bootnodes) { final NodeRecordFactory nodeRecordFactory = NodeRecordFactory.DEFAULT; return bootnodes.stream() diff --git a/ethereum/networks/src/test/resources/tech/pegasys/teku/networks/missingChurnLimit.yaml b/ethereum/networks/src/test/resources/tech/pegasys/teku/networks/missingChurnLimit.yaml new file mode 100644 index 00000000000..c0f9f4f24e5 --- /dev/null +++ b/ethereum/networks/src/test/resources/tech/pegasys/teku/networks/missingChurnLimit.yaml @@ -0,0 +1,152 @@ +# Mainnet with missing constants +# Hide MIN_PER_EPOCH_CHURN_LIMIT + +# Misc +# --------------------------------------------------------------- +# 2**6 (= 64) +MAX_COMMITTEES_PER_SLOT: 64 +# 2**7 (= 128) +TARGET_COMMITTEE_SIZE: 128 +# 2**11 (= 2,048) +MAX_VALIDATORS_PER_COMMITTEE: 2048 +# 2**2 (= 4) +#MIN_PER_EPOCH_CHURN_LIMIT: 4 +# 2**16 (= 65,536) +CHURN_LIMIT_QUOTIENT: 65536 +# See issue 563 +SHUFFLE_ROUND_COUNT: 90 +# `2**14` (= 16,384) +MIN_GENESIS_ACTIVE_VALIDATOR_COUNT: 16384 +# Dec 1, 2020, 12pm UTC +MIN_GENESIS_TIME: 1606824000 +# 4 +HYSTERESIS_QUOTIENT: 4 +# 1 (minus 0.25) +HYSTERESIS_DOWNWARD_MULTIPLIER: 1 +# 5 (plus 1.25) +HYSTERESIS_UPWARD_MULTIPLIER: 5 + + +# Fork Choice +# --------------------------------------------------------------- +# 2**3 (= 8) +SAFE_SLOTS_TO_UPDATE_JUSTIFIED: 8 + + +# Validator +# --------------------------------------------------------------- +# 2**11 (= 2,048) +ETH1_FOLLOW_DISTANCE: 2048 +# 2**4 (= 16) +TARGET_AGGREGATORS_PER_COMMITTEE: 16 +# 2**8 (= 256) +EPOCHS_PER_RANDOM_SUBNET_SUBSCRIPTION: 256 +# 14 (estimate from Eth1 mainnet) +SECONDS_PER_ETH1_BLOCK: 14 + + +# Deposit contract +# --------------------------------------------------------------- +# Ethereum PoW Mainnet +DEPOSIT_CHAIN_ID: 1 +DEPOSIT_NETWORK_ID: 1 +# **TBD** +DEPOSIT_CONTRACT_ADDRESS: 0x00000000219ab540356cBB839Cbe05303d7705Fa + + +# Gwei values +# --------------------------------------------------------------- +# 2**0 * 10**9 (= 1,000,000,000) Gwei +MIN_DEPOSIT_AMOUNT: 1000000000 +# 2**5 * 10**9 (= 32,000,000,000) Gwei +MAX_EFFECTIVE_BALANCE: 32000000000 +# 2**4 * 10**9 (= 16,000,000,000) Gwei +EJECTION_BALANCE: 16000000000 +# 2**0 * 10**9 (= 1,000,000,000) Gwei +EFFECTIVE_BALANCE_INCREMENT: 1000000000 + + +# Initial values +# --------------------------------------------------------------- +# Mainnet initial fork version, recommend altering for testnets +GENESIS_FORK_VERSION: 0x00000000 +BLS_WITHDRAWAL_PREFIX: 0x00 + + +# Time parameters +# --------------------------------------------------------------- +# 604800 seconds (7 days) +GENESIS_DELAY: 604800 +# 12 seconds +SECONDS_PER_SLOT: 12 +# 2**0 (= 1) slots 12 seconds +MIN_ATTESTATION_INCLUSION_DELAY: 1 +# 2**5 (= 32) slots 6.4 minutes +SLOTS_PER_EPOCH: 32 +# 2**0 (= 1) epochs 6.4 minutes +MIN_SEED_LOOKAHEAD: 1 +# 2**2 (= 4) epochs 25.6 minutes +MAX_SEED_LOOKAHEAD: 4 +# 2**6 (= 64) epochs ~6.8 hours +EPOCHS_PER_ETH1_VOTING_PERIOD: 64 +# 2**13 (= 8,192) slots ~13 hours +SLOTS_PER_HISTORICAL_ROOT: 8192 +# 2**8 (= 256) epochs ~27 hours +MIN_VALIDATOR_WITHDRAWABILITY_DELAY: 256 +# 2**8 (= 256) epochs ~27 hours +SHARD_COMMITTEE_PERIOD: 256 +# 2**2 (= 4) epochs 25.6 minutes +MIN_EPOCHS_TO_INACTIVITY_PENALTY: 4 + + +# State vector lengths +# --------------------------------------------------------------- +# 2**16 (= 65,536) epochs ~0.8 years +EPOCHS_PER_HISTORICAL_VECTOR: 65536 +# 2**13 (= 8,192) epochs ~36 days +EPOCHS_PER_SLASHINGS_VECTOR: 8192 +# 2**24 (= 16,777,216) historical roots, ~26,131 years +HISTORICAL_ROOTS_LIMIT: 16777216 +# 2**40 (= 1,099,511,627,776) validator spots +VALIDATOR_REGISTRY_LIMIT: 1099511627776 + + +# Reward and penalty quotients +# --------------------------------------------------------------- +# 2**6 (= 64) +BASE_REWARD_FACTOR: 64 +# 2**9 (= 512) +WHISTLEBLOWER_REWARD_QUOTIENT: 512 +# 2**3 (= 8) +PROPOSER_REWARD_QUOTIENT: 8 +# 2**26 (= 67,108,864) +INACTIVITY_PENALTY_QUOTIENT: 67108864 +# 2**7 (= 128) (lower safety margin at Phase 0 genesis) +MIN_SLASHING_PENALTY_QUOTIENT: 128 +# 1 (lower safety margin at Phase 0 genesis) +PROPORTIONAL_SLASHING_MULTIPLIER: 1 + + +# Max operations per block +# --------------------------------------------------------------- +# 2**4 (= 16) +MAX_PROPOSER_SLASHINGS: 16 +# 2**1 (= 2) +MAX_ATTESTER_SLASHINGS: 2 +# 2**7 (= 128) +MAX_ATTESTATIONS: 128 +# 2**4 (= 16) +MAX_DEPOSITS: 16 +# 2**4 (= 16) +MAX_VOLUNTARY_EXITS: 16 + + +# Signature domains +# --------------------------------------------------------------- +DOMAIN_BEACON_PROPOSER: 0x00000000 +DOMAIN_BEACON_ATTESTER: 0x01000000 +DOMAIN_RANDAO: 0x02000000 +DOMAIN_DEPOSIT: 0x03000000 +DOMAIN_VOLUNTARY_EXIT: 0x04000000 +DOMAIN_SELECTION_PROOF: 0x05000000 +DOMAIN_AGGREGATE_AND_PROOF: 0x06000000 \ No newline at end of file diff --git a/ethereum/performance-trackers/src/main/java/tech/pegasys/teku/ethereum/performance/trackers/BlockProductionAndPublishingPerformanceFactory.java b/ethereum/performance-trackers/src/main/java/tech/pegasys/teku/ethereum/performance/trackers/BlockProductionAndPublishingPerformanceFactory.java index 7d196542cad..eb189526782 100644 --- a/ethereum/performance-trackers/src/main/java/tech/pegasys/teku/ethereum/performance/trackers/BlockProductionAndPublishingPerformanceFactory.java +++ b/ethereum/performance-trackers/src/main/java/tech/pegasys/teku/ethereum/performance/trackers/BlockProductionAndPublishingPerformanceFactory.java @@ -13,34 +13,48 @@ package tech.pegasys.teku.ethereum.performance.trackers; +import java.util.Map; import java.util.function.Function; import tech.pegasys.teku.infrastructure.time.TimeProvider; import tech.pegasys.teku.infrastructure.unsigned.UInt64; public class BlockProductionAndPublishingPerformanceFactory { + private final TimeProvider timeProvider; - private final boolean enabled; - private final int lateProductionEventThreshold; - private final int latePublishingEventThreshold; private final Function slotTimeCalculator; + private final boolean enabled; + private final Map lateProductionEventThresholds; + private final Map latePublishingEventThresholds; public BlockProductionAndPublishingPerformanceFactory( final TimeProvider timeProvider, final Function slotTimeCalculator, final boolean enabled, - final int lateProductionEventThreshold, - final int latePublishingEventThreshold) { + final int lateProductionEventLocalThreshold, + final int lateProductionEventBuilderThreshold, + final int latePublishingEventLocalThreshold, + final int latePublishingEvenBuilderThreshold) { this.timeProvider = timeProvider; this.slotTimeCalculator = slotTimeCalculator; this.enabled = enabled; - this.lateProductionEventThreshold = lateProductionEventThreshold; - this.latePublishingEventThreshold = latePublishingEventThreshold; + this.lateProductionEventThresholds = + Map.of( + Flow.LOCAL, + lateProductionEventLocalThreshold, + Flow.BUILDER, + lateProductionEventBuilderThreshold); + this.latePublishingEventThresholds = + Map.of( + Flow.LOCAL, + latePublishingEventLocalThreshold, + Flow.BUILDER, + latePublishingEvenBuilderThreshold); } public BlockProductionPerformance createForProduction(final UInt64 slot) { if (enabled) { return new BlockProductionPerformanceImpl( - timeProvider, slot, slotTimeCalculator.apply(slot), lateProductionEventThreshold); + timeProvider, slot, slotTimeCalculator.apply(slot), lateProductionEventThresholds); } else { return BlockProductionPerformance.NOOP; } @@ -49,7 +63,7 @@ public BlockProductionPerformance createForProduction(final UInt64 slot) { public BlockPublishingPerformance createForPublishing(final UInt64 slot) { if (enabled) { return new BlockPublishingPerformanceImpl( - timeProvider, slot, slotTimeCalculator.apply(slot), latePublishingEventThreshold); + timeProvider, slot, slotTimeCalculator.apply(slot), latePublishingEventThresholds); } else { return BlockPublishingPerformance.NOOP; } diff --git a/ethereum/performance-trackers/src/main/java/tech/pegasys/teku/ethereum/performance/trackers/BlockProductionPerformanceImpl.java b/ethereum/performance-trackers/src/main/java/tech/pegasys/teku/ethereum/performance/trackers/BlockProductionPerformanceImpl.java index 185d762998e..be8eefaf535 100644 --- a/ethereum/performance-trackers/src/main/java/tech/pegasys/teku/ethereum/performance/trackers/BlockProductionPerformanceImpl.java +++ b/ethereum/performance-trackers/src/main/java/tech/pegasys/teku/ethereum/performance/trackers/BlockProductionPerformanceImpl.java @@ -13,24 +13,28 @@ package tech.pegasys.teku.ethereum.performance.trackers; +import java.util.Map; import tech.pegasys.teku.infrastructure.logging.EventLogger; import tech.pegasys.teku.infrastructure.time.PerformanceTracker; import tech.pegasys.teku.infrastructure.time.TimeProvider; import tech.pegasys.teku.infrastructure.unsigned.UInt64; public class BlockProductionPerformanceImpl implements BlockProductionPerformance { + private final PerformanceTracker performanceTracker; private final UInt64 slot; private final UInt64 slotTime; - private final int lateThreshold; + private final Map lateThresholds; + + private volatile Flow flow = Flow.LOCAL; BlockProductionPerformanceImpl( final TimeProvider timeProvider, final UInt64 slot, final UInt64 slotTime, - final int lateThreshold) { + final Map lateThresholds) { this.performanceTracker = new PerformanceTracker(timeProvider); - this.lateThreshold = lateThreshold; + this.lateThresholds = lateThresholds; this.slot = slot; this.slotTime = slotTime; performanceTracker.addEvent("start"); @@ -39,7 +43,8 @@ public class BlockProductionPerformanceImpl implements BlockProductionPerformanc @Override public void complete() { final UInt64 completionTime = performanceTracker.addEvent(COMPLETE_LABEL); - final boolean isLateEvent = completionTime.minusMinZero(slotTime).isGreaterThan(lateThreshold); + final boolean isLateEvent = + completionTime.minusMinZero(slotTime).isGreaterThan(lateThresholds.get(flow)); performanceTracker.report( slotTime, isLateEvent, @@ -82,6 +87,8 @@ public void engineGetPayload() { @Override public void builderGetHeader() { performanceTracker.addEvent("builder_get_header"); + // set the flow to BUILDER when builderGetHeader has been called + flow = Flow.BUILDER; } @Override diff --git a/ethereum/performance-trackers/src/main/java/tech/pegasys/teku/ethereum/performance/trackers/BlockPublishingPerformance.java b/ethereum/performance-trackers/src/main/java/tech/pegasys/teku/ethereum/performance/trackers/BlockPublishingPerformance.java index fe9e468ec08..e55dd1f9e9a 100644 --- a/ethereum/performance-trackers/src/main/java/tech/pegasys/teku/ethereum/performance/trackers/BlockPublishingPerformance.java +++ b/ethereum/performance-trackers/src/main/java/tech/pegasys/teku/ethereum/performance/trackers/BlockPublishingPerformance.java @@ -29,16 +29,19 @@ public void builderGetPayload() {} public void blobSidecarsPrepared() {} @Override - public void blockAndBlobSidecarsPublishingInitiated() {} + public void blobSidecarsPublishingInitiated() {} @Override public void blockPublishingInitiated() {} @Override public void blockImportCompleted() {} + + @Override + public void blobSidecarsImportCompleted() {} }; - void blockAndBlobSidecarsPublishingInitiated(); + void blobSidecarsPublishingInitiated(); void blockPublishingInitiated(); @@ -46,6 +49,8 @@ public void blockImportCompleted() {} void blobSidecarsPrepared(); + void blobSidecarsImportCompleted(); + void blockImportCompleted(); void complete(); diff --git a/ethereum/performance-trackers/src/main/java/tech/pegasys/teku/ethereum/performance/trackers/BlockPublishingPerformanceImpl.java b/ethereum/performance-trackers/src/main/java/tech/pegasys/teku/ethereum/performance/trackers/BlockPublishingPerformanceImpl.java index 83367e434ab..6461a8a0cae 100644 --- a/ethereum/performance-trackers/src/main/java/tech/pegasys/teku/ethereum/performance/trackers/BlockPublishingPerformanceImpl.java +++ b/ethereum/performance-trackers/src/main/java/tech/pegasys/teku/ethereum/performance/trackers/BlockPublishingPerformanceImpl.java @@ -13,24 +13,28 @@ package tech.pegasys.teku.ethereum.performance.trackers; +import java.util.Map; import tech.pegasys.teku.infrastructure.logging.EventLogger; import tech.pegasys.teku.infrastructure.time.PerformanceTracker; import tech.pegasys.teku.infrastructure.time.TimeProvider; import tech.pegasys.teku.infrastructure.unsigned.UInt64; public class BlockPublishingPerformanceImpl implements BlockPublishingPerformance { + private final PerformanceTracker performanceTracker; private final UInt64 slot; private final UInt64 slotTime; - private final int lateThreshold; + private final Map lateThresholds; + + private volatile Flow flow = Flow.LOCAL; BlockPublishingPerformanceImpl( final TimeProvider timeProvider, final UInt64 slot, final UInt64 slotTime, - final int lateThreshold) { + final Map lateThresholds) { this.performanceTracker = new PerformanceTracker(timeProvider); - this.lateThreshold = lateThreshold; + this.lateThresholds = lateThresholds; this.slot = slot; this.slotTime = slotTime; performanceTracker.addEvent("start"); @@ -39,7 +43,8 @@ public class BlockPublishingPerformanceImpl implements BlockPublishingPerformanc @Override public void complete() { final UInt64 completionTime = performanceTracker.addEvent(COMPLETE_LABEL); - final boolean isLateEvent = completionTime.minusMinZero(slotTime).isGreaterThan(lateThreshold); + final boolean isLateEvent = + completionTime.minusMinZero(slotTime).isGreaterThan(lateThresholds.get(flow)); performanceTracker.report( slotTime, isLateEvent, @@ -52,6 +57,8 @@ public void complete() { @Override public void builderGetPayload() { performanceTracker.addEvent("builder_get_payload"); + // set the flow to BUILDER when builderGetPayload has been called + flow = Flow.BUILDER; } @Override @@ -60,8 +67,8 @@ public void blobSidecarsPrepared() { } @Override - public void blockAndBlobSidecarsPublishingInitiated() { - performanceTracker.addEvent("block_and_blob_sidecars_publishing_initiated"); + public void blobSidecarsImportCompleted() { + performanceTracker.addEvent("blob_sidecars_imported"); } @Override @@ -69,6 +76,11 @@ public void blockPublishingInitiated() { performanceTracker.addEvent("block_publishing_initiated"); } + @Override + public void blobSidecarsPublishingInitiated() { + performanceTracker.addEvent("blob_sidecars_publishing_initiated"); + } + @Override public void blockImportCompleted() { performanceTracker.addEvent("block_import_completed"); diff --git a/ethereum/performance-trackers/src/main/java/tech/pegasys/teku/ethereum/performance/trackers/Flow.java b/ethereum/performance-trackers/src/main/java/tech/pegasys/teku/ethereum/performance/trackers/Flow.java new file mode 100644 index 00000000000..6e0f15c0a09 --- /dev/null +++ b/ethereum/performance-trackers/src/main/java/tech/pegasys/teku/ethereum/performance/trackers/Flow.java @@ -0,0 +1,19 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.ethereum.performance.trackers; + +public enum Flow { + LOCAL, + BUILDER +} diff --git a/ethereum/pow/api/src/main/java/tech/pegasys/teku/ethereum/pow/api/Deposit.java b/ethereum/pow/api/src/main/java/tech/pegasys/teku/ethereum/pow/api/Deposit.java index bd1689fcb47..249182aaaab 100644 --- a/ethereum/pow/api/src/main/java/tech/pegasys/teku/ethereum/pow/api/Deposit.java +++ b/ethereum/pow/api/src/main/java/tech/pegasys/teku/ethereum/pow/api/Deposit.java @@ -30,11 +30,11 @@ public class Deposit { private final UInt64 merkle_tree_index; public Deposit( - BLSPublicKey pubkey, - Bytes32 withdrawal_credentials, - BLSSignature signature, - UInt64 amount, - UInt64 merkle_tree_index) { + final BLSPublicKey pubkey, + final Bytes32 withdrawal_credentials, + final BLSSignature signature, + final UInt64 amount, + final UInt64 merkle_tree_index) { this.pubkey = pubkey; this.withdrawal_credentials = withdrawal_credentials; this.signature = signature; diff --git a/ethereum/pow/api/src/main/java/tech/pegasys/teku/ethereum/pow/api/DepositsFromBlockEvent.java b/ethereum/pow/api/src/main/java/tech/pegasys/teku/ethereum/pow/api/DepositsFromBlockEvent.java index 010886cb1ef..67e24cf6139 100644 --- a/ethereum/pow/api/src/main/java/tech/pegasys/teku/ethereum/pow/api/DepositsFromBlockEvent.java +++ b/ethereum/pow/api/src/main/java/tech/pegasys/teku/ethereum/pow/api/DepositsFromBlockEvent.java @@ -72,11 +72,11 @@ public static DepositsFromBlockEvent create( } public UInt64 getFirstDepositIndex() { - return deposits.get(0).getMerkle_tree_index(); + return deposits.getFirst().getMerkle_tree_index(); } public UInt64 getLastDepositIndex() { - return deposits.get(deposits.size() - 1).getMerkle_tree_index(); + return deposits.getLast().getMerkle_tree_index(); } public UInt64 getBlockNumber() { diff --git a/ethereum/pow/api/src/main/java/tech/pegasys/teku/ethereum/pow/api/Eth1EventsChannel.java b/ethereum/pow/api/src/main/java/tech/pegasys/teku/ethereum/pow/api/Eth1EventsChannel.java index cf8e72e430f..509c8774da4 100644 --- a/ethereum/pow/api/src/main/java/tech/pegasys/teku/ethereum/pow/api/Eth1EventsChannel.java +++ b/ethereum/pow/api/src/main/java/tech/pegasys/teku/ethereum/pow/api/Eth1EventsChannel.java @@ -22,7 +22,8 @@ public interface Eth1EventsChannel extends VoidReturningChannelInterface { void onMinGenesisTimeBlock(MinGenesisTimeBlockEvent event); - default void onEth1Block(UInt64 blockHeight, Bytes32 blockHash, UInt64 blockTimestamp) {} + default void onEth1Block( + final UInt64 blockHeight, final Bytes32 blockHash, final UInt64 blockTimestamp) {} - default void onInitialDepositTreeSnapshot(DepositTreeSnapshot depositTreeSnapshot) {} + default void onInitialDepositTreeSnapshot(final DepositTreeSnapshot depositTreeSnapshot) {} } diff --git a/ethereum/pow/api/src/main/java/tech/pegasys/teku/ethereum/pow/api/MinGenesisTimeBlockEvent.java b/ethereum/pow/api/src/main/java/tech/pegasys/teku/ethereum/pow/api/MinGenesisTimeBlockEvent.java index 3f431a5e3e6..a86c60a7136 100644 --- a/ethereum/pow/api/src/main/java/tech/pegasys/teku/ethereum/pow/api/MinGenesisTimeBlockEvent.java +++ b/ethereum/pow/api/src/main/java/tech/pegasys/teku/ethereum/pow/api/MinGenesisTimeBlockEvent.java @@ -23,7 +23,8 @@ public class MinGenesisTimeBlockEvent { private final UInt64 blockNumber; private final Bytes32 blockHash; - public MinGenesisTimeBlockEvent(UInt64 timestamp, UInt64 blockNumber, Bytes32 blockHash) { + public MinGenesisTimeBlockEvent( + final UInt64 timestamp, final UInt64 blockNumber, final Bytes32 blockHash) { this.timestamp = timestamp; this.blockNumber = blockNumber; this.blockHash = blockHash; diff --git a/ethereum/signingrecord/build.gradle b/ethereum/signingrecord/build.gradle index dfbe033c8e6..b1b545b1dff 100644 --- a/ethereum/signingrecord/build.gradle +++ b/ethereum/signingrecord/build.gradle @@ -1,6 +1,6 @@ dependencies { implementation project(':infrastructure:yaml') - implementation 'org.apache.tuweni:tuweni-bytes' + implementation 'io.tmio:tuweni-bytes' implementation 'com.fasterxml.jackson.core:jackson-databind' implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-yaml' } diff --git a/ethereum/signingrecord/src/main/java/tech/pegasys/teku/ethereum/signingrecord/ValidatorSigningRecord.java b/ethereum/signingrecord/src/main/java/tech/pegasys/teku/ethereum/signingrecord/ValidatorSigningRecord.java index b0351635110..7cb9a177593 100644 --- a/ethereum/signingrecord/src/main/java/tech/pegasys/teku/ethereum/signingrecord/ValidatorSigningRecord.java +++ b/ethereum/signingrecord/src/main/java/tech/pegasys/teku/ethereum/signingrecord/ValidatorSigningRecord.java @@ -31,32 +31,18 @@ *

For attestations, the last source epoch and target epoch are recorded. An attestation may only * be signed if source >= previousSource AND target > previousTarget */ -public class ValidatorSigningRecord { +public record ValidatorSigningRecord( + Optional genesisValidatorsRoot, + UInt64 blockSlot, + UInt64 attestationSourceEpoch, + UInt64 attestationTargetEpoch) { private static final Logger LOG = LogManager.getLogger(); public static final UInt64 NEVER_SIGNED = null; - private final Bytes32 genesisValidatorsRoot; - - private final UInt64 blockSlot; - - private final UInt64 attestationSourceEpoch; - - private final UInt64 attestationTargetEpoch; - - public ValidatorSigningRecord(final Bytes32 genesisValidatorsRoot) { - this(genesisValidatorsRoot, UInt64.ZERO, NEVER_SIGNED, NEVER_SIGNED); - } - - public ValidatorSigningRecord( - final Bytes32 genesisValidatorsRoot, - final UInt64 blockSlot, - final UInt64 attestationSourceEpoch, - final UInt64 attestationTargetEpoch) { - this.genesisValidatorsRoot = genesisValidatorsRoot; - this.blockSlot = blockSlot; - this.attestationSourceEpoch = attestationSourceEpoch; - this.attestationTargetEpoch = attestationTargetEpoch; + public static ValidatorSigningRecord emptySigningRecord(final Bytes32 genesisValidatorsRoot) { + return new ValidatorSigningRecord( + Optional.ofNullable(genesisValidatorsRoot), UInt64.ZERO, NEVER_SIGNED, NEVER_SIGNED); } public static boolean isNeverSigned(final UInt64 value) { @@ -81,20 +67,22 @@ public Bytes toBytes() { */ public Optional maySignBlock( final Bytes32 genesisValidatorsRoot, final UInt64 slot) { - if (this.genesisValidatorsRoot != null - && !this.genesisValidatorsRoot.equals(genesisValidatorsRoot)) { + if (this.genesisValidatorsRoot.isPresent() + && !this.genesisValidatorsRoot.get().equals(genesisValidatorsRoot)) { LOG.error( - "Refusing to sign block because validator signing record is from the wrong chain. Expected genesis validators root " - + this.genesisValidatorsRoot - + " but attempting to sign for " - + genesisValidatorsRoot); + "Refusing to sign block because validator signing record is from the wrong chain. Expected genesis validators root {} but attempting to sign for {}", + this.genesisValidatorsRoot.get(), + genesisValidatorsRoot); return Optional.empty(); } // We never allow signing a block at slot 0 because we shouldn't be signing the genesis block. if (blockSlot.compareTo(slot) < 0) { return Optional.of( new ValidatorSigningRecord( - genesisValidatorsRoot, slot, attestationSourceEpoch, attestationTargetEpoch)); + Optional.ofNullable(genesisValidatorsRoot), + slot, + attestationSourceEpoch, + attestationTargetEpoch)); } return Optional.empty(); } @@ -110,13 +98,13 @@ public Optional maySignBlock( */ public Optional maySignAttestation( final Bytes32 genesisValidatorsRoot, final UInt64 sourceEpoch, final UInt64 targetEpoch) { - if (this.genesisValidatorsRoot != null - && !this.genesisValidatorsRoot.equals(genesisValidatorsRoot)) { + if (this.genesisValidatorsRoot.isPresent() + && !this.genesisValidatorsRoot.get().equals(genesisValidatorsRoot)) { LOG.error( - "Refusing to sign attestation because validator signing record is from the wrong chain. Expected genesis validators root " - + this.genesisValidatorsRoot - + " but attempting to sign for " - + genesisValidatorsRoot); + "Refusing to sign attestation because validator signing record is from the wrong chain. " + + "Expected genesis validators root {} but attempting to sign for {}", + this.genesisValidatorsRoot.get(), + genesisValidatorsRoot); return Optional.empty(); } @@ -124,7 +112,8 @@ public Optional maySignAttestation( boolean targetEpochIsSafe = isSafeTargetEpoch(targetEpoch); if (sourceEpochIsSafe && targetEpochIsSafe) { return Optional.of( - new ValidatorSigningRecord(genesisValidatorsRoot, blockSlot, sourceEpoch, targetEpoch)); + new ValidatorSigningRecord( + Optional.ofNullable(genesisValidatorsRoot), blockSlot, sourceEpoch, targetEpoch)); } else { LOG.error( "Refusing to sign attestation: source epoch ({}) is {}, target epoch ({}) is {}. " @@ -148,20 +137,26 @@ private boolean isSafeTargetEpoch(final UInt64 targetEpoch) { return isNeverSigned(attestationTargetEpoch) || attestationTargetEpoch.isLessThan(targetEpoch); } - public Bytes32 getGenesisValidatorsRoot() { - return genesisValidatorsRoot; - } - - public UInt64 getBlockSlot() { - return blockSlot; - } - - public UInt64 getAttestationSourceEpoch() { - return attestationSourceEpoch; + @Override + public String toString() { + final String genesisValidatorsRootString = + genesisValidatorsRoot.isPresent() ? genesisValidatorsRoot.get().toString() : "EMPTY"; + return MoreObjects.toStringHelper(this) + .add("genesisValidatorsRoot", genesisValidatorsRootString) + .add("blockSlot", blockSlot) + .add("attestationSourceEpoch", attestationSourceEpoch) + .add("attestationTargetEpoch", attestationTargetEpoch) + .toString(); } - public UInt64 getAttestationTargetEpoch() { - return attestationTargetEpoch; + public boolean genesisValidatorsRootIsEqualTo( + final Optional maybeGenesisValidatorsRoot) { + if (maybeGenesisValidatorsRoot.isPresent() && genesisValidatorsRoot.isPresent()) { + return maybeGenesisValidatorsRoot.get().equals(genesisValidatorsRoot.get()); + } else if (maybeGenesisValidatorsRoot.isEmpty() && genesisValidatorsRoot.isEmpty()) { + return true; + } + return false; } @Override @@ -173,24 +168,9 @@ public boolean equals(final Object o) { return false; } final ValidatorSigningRecord that = (ValidatorSigningRecord) o; - return Objects.equals(genesisValidatorsRoot, that.genesisValidatorsRoot) + return genesisValidatorsRootIsEqualTo(that.genesisValidatorsRoot) && Objects.equals(blockSlot, that.blockSlot) && Objects.equals(attestationSourceEpoch, that.attestationSourceEpoch) && Objects.equals(attestationTargetEpoch, that.attestationTargetEpoch); } - - @Override - public int hashCode() { - return Objects.hash( - genesisValidatorsRoot, blockSlot, attestationSourceEpoch, attestationTargetEpoch); - } - - @Override - public String toString() { - return MoreObjects.toStringHelper(this) - .add("blockSlot", blockSlot) - .add("attestationSourceEpoch", attestationSourceEpoch) - .add("attestationTargetEpoch", attestationTargetEpoch) - .toString(); - } } diff --git a/ethereum/signingrecord/src/main/java/tech/pegasys/teku/ethereum/signingrecord/ValidatorSigningRecordSerialization.java b/ethereum/signingrecord/src/main/java/tech/pegasys/teku/ethereum/signingrecord/ValidatorSigningRecordSerialization.java index a2c4dcc68d0..938a9b3cdfc 100644 --- a/ethereum/signingrecord/src/main/java/tech/pegasys/teku/ethereum/signingrecord/ValidatorSigningRecordSerialization.java +++ b/ethereum/signingrecord/src/main/java/tech/pegasys/teku/ethereum/signingrecord/ValidatorSigningRecordSerialization.java @@ -26,6 +26,7 @@ import com.fasterxml.jackson.databind.node.TextNode; import java.io.IOException; import java.io.UncheckedIOException; +import java.util.Optional; import org.apache.tuweni.bytes.Bytes; import org.apache.tuweni.bytes.Bytes32; import tech.pegasys.teku.data.yaml.YamlProvider; @@ -67,13 +68,13 @@ public void serialize( final SerializerProvider serializers) throws IOException { gen.writeStartObject(); - if (value.getGenesisValidatorsRoot() != null) { + if (value.genesisValidatorsRoot().isPresent()) { gen.writeStringField( - GENESIS_VALIDATORS_ROOT_FIELD_NAME, value.getGenesisValidatorsRoot().toHexString()); + GENESIS_VALIDATORS_ROOT_FIELD_NAME, value.genesisValidatorsRoot().get().toHexString()); } - writeUInt64(gen, BLOCK_SLOT_FIELD_NAME, value.getBlockSlot()); - writeUInt64(gen, SOURCE_EPOCH_FIELD_NAME, value.getAttestationSourceEpoch()); - writeUInt64(gen, TARGET_EPOCH_FIELD_NAME, value.getAttestationTargetEpoch()); + writeUInt64(gen, BLOCK_SLOT_FIELD_NAME, value.blockSlot()); + writeUInt64(gen, SOURCE_EPOCH_FIELD_NAME, value.attestationSourceEpoch()); + writeUInt64(gen, TARGET_EPOCH_FIELD_NAME, value.attestationTargetEpoch()); gen.writeEndObject(); } @@ -98,7 +99,10 @@ public ValidatorSigningRecord deserialize(final JsonParser p, final Deserializat final UInt64 attestationSourceEpoch = getUInt64(node, SOURCE_EPOCH_FIELD_NAME); final UInt64 attestationTargetEpoch = getUInt64(node, TARGET_EPOCH_FIELD_NAME); return new ValidatorSigningRecord( - genesisValidatorsRoot, blockSlot, attestationSourceEpoch, attestationTargetEpoch); + Optional.ofNullable(genesisValidatorsRoot), + blockSlot, + attestationSourceEpoch, + attestationTargetEpoch); } private Bytes32 getBytes32(final TreeNode node, final String fieldName) { diff --git a/ethereum/signingrecord/src/test/java/tech/pegasys/teku/ethereum/signingrecord/ValidatorSigningRecordTest.java b/ethereum/signingrecord/src/test/java/tech/pegasys/teku/ethereum/signingrecord/ValidatorSigningRecordTest.java index 12c4fa16a82..cbc1b380a84 100644 --- a/ethereum/signingrecord/src/test/java/tech/pegasys/teku/ethereum/signingrecord/ValidatorSigningRecordTest.java +++ b/ethereum/signingrecord/src/test/java/tech/pegasys/teku/ethereum/signingrecord/ValidatorSigningRecordTest.java @@ -42,7 +42,7 @@ void shouldReadSigningRecordWithoutGenesisRoot() throws IOException { assertThat(record) .isEqualTo( new ValidatorSigningRecord( - null, UInt64.valueOf(11), UInt64.valueOf(12), UInt64.valueOf(13))); + Optional.empty(), UInt64.valueOf(11), UInt64.valueOf(12), UInt64.valueOf(13))); } @Test @@ -52,7 +52,8 @@ void shouldReadSigningRecordWitOldNeverSignedValue() throws IOException { Bytes yamlByteData = Bytes.wrap(yamlData.getBytes(UTF_8)); ValidatorSigningRecord record = ValidatorSigningRecord.fromBytes(yamlByteData); - assertThat(record).isEqualTo(new ValidatorSigningRecord(null, UInt64.valueOf(11), null, null)); + assertThat(record) + .isEqualTo(new ValidatorSigningRecord(Optional.empty(), UInt64.valueOf(11), null, null)); } @Test @@ -63,7 +64,10 @@ void shouldReadSigningRecordWithGenesisRoot() throws IOException { assertThat(record) .isEqualTo( new ValidatorSigningRecord( - GENESIS_VALIDATORS_ROOT, UInt64.valueOf(1), UInt64.valueOf(2), UInt64.valueOf(3))); + Optional.of(GENESIS_VALIDATORS_ROOT), + UInt64.valueOf(1), + UInt64.valueOf(2), + UInt64.valueOf(3))); } @Test @@ -72,13 +76,17 @@ void shouldSerializeToBytes() throws IOException { final Bytes yamlByteData = Bytes.of(yamlData.getBytes(UTF_8)); ValidatorSigningRecord record = new ValidatorSigningRecord( - GENESIS_VALIDATORS_ROOT, UInt64.valueOf(1), UInt64.valueOf(2), UInt64.valueOf(3)); + Optional.of(GENESIS_VALIDATORS_ROOT), + UInt64.valueOf(1), + UInt64.valueOf(2), + UInt64.valueOf(3)); assertThat(record.toBytes()).isEqualTo(yamlByteData); } @Test void shouldRoundTripDefaultValuesToBytes() { - final ValidatorSigningRecord record = new ValidatorSigningRecord(GENESIS_VALIDATORS_ROOT); + final ValidatorSigningRecord record = + ValidatorSigningRecord.emptySigningRecord(GENESIS_VALIDATORS_ROOT); final Bytes bytes = record.toBytes(); final ValidatorSigningRecord result = ValidatorSigningRecord.fromBytes(bytes); assertThat(result).isEqualTo(record); @@ -88,7 +96,10 @@ void shouldRoundTripDefaultValuesToBytes() { void shouldRoundTripToBytes() { final ValidatorSigningRecord record = new ValidatorSigningRecord( - GENESIS_VALIDATORS_ROOT, UInt64.valueOf(10), UInt64.valueOf(20), UInt64.valueOf(30)); + Optional.of(GENESIS_VALIDATORS_ROOT), + UInt64.valueOf(10), + UInt64.valueOf(20), + UInt64.valueOf(30)); final Bytes bytes = record.toBytes(); final ValidatorSigningRecord result = ValidatorSigningRecord.fromBytes(bytes); assertThat(result).isEqualTo(record); @@ -107,15 +118,18 @@ void signBlock( static List blockCases() { final ValidatorSigningRecord startingRecord = new ValidatorSigningRecord( - GENESIS_VALIDATORS_ROOT, UInt64.valueOf(3), UInt64.valueOf(6), UInt64.valueOf(7)); + Optional.of(GENESIS_VALIDATORS_ROOT), + UInt64.valueOf(3), + UInt64.valueOf(6), + UInt64.valueOf(7)); return List.of( Arguments.of( "noExistingRecord", - new ValidatorSigningRecord(GENESIS_VALIDATORS_ROOT), + ValidatorSigningRecord.emptySigningRecord(GENESIS_VALIDATORS_ROOT), ONE, Optional.of( new ValidatorSigningRecord( - GENESIS_VALIDATORS_ROOT, + Optional.of(GENESIS_VALIDATORS_ROOT), ONE, ValidatorSigningRecord.NEVER_SIGNED, ValidatorSigningRecord.NEVER_SIGNED))), @@ -139,13 +153,13 @@ void maySignAttestation( static List attestationCases() { final ValidatorSigningRecord startingRecord = new ValidatorSigningRecord( - GENESIS_VALIDATORS_ROOT, ONE, UInt64.valueOf(4), UInt64.valueOf(6)); + Optional.of(GENESIS_VALIDATORS_ROOT), ONE, UInt64.valueOf(4), UInt64.valueOf(6)); return List.of( // No record attestationArguments( "NEVER_SIGNED", "NEVER_SIGNED", - new ValidatorSigningRecord(GENESIS_VALIDATORS_ROOT), + ValidatorSigningRecord.emptySigningRecord(GENESIS_VALIDATORS_ROOT), 1, 2, allowed(0, 1, 2)), @@ -168,7 +182,7 @@ private static Optional allowed( final int blockSlot, final int sourceEpoch, final int targetEpoch) { return Optional.of( new ValidatorSigningRecord( - GENESIS_VALIDATORS_ROOT, + Optional.of(GENESIS_VALIDATORS_ROOT), UInt64.valueOf(blockSlot), UInt64.valueOf(sourceEpoch), UInt64.valueOf(targetEpoch))); diff --git a/ethereum/spec/build.gradle b/ethereum/spec/build.gradle index 65638a739b8..ae6f9070023 100644 --- a/ethereum/spec/build.gradle +++ b/ethereum/spec/build.gradle @@ -1,6 +1,6 @@ dependencies { api 'it.unimi.dsi:fastutil' - api 'org.apache.tuweni:tuweni-bytes' + api 'io.tmio:tuweni-bytes' api project(':infrastructure:bls') api project(':infrastructure:bytes') api project(':infrastructure:collections') @@ -9,10 +9,9 @@ dependencies { implementation 'com.fasterxml.jackson.core:jackson-databind' implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-yaml' - implementation 'org.apache.tuweni:tuweni-bytes' - implementation 'org.apache.tuweni:tuweni-ssz' - implementation 'org.apache.tuweni:tuweni-ssz' - implementation 'org.apache.tuweni:tuweni-units' + implementation 'io.tmio:tuweni-bytes' + implementation 'io.tmio:tuweni-ssz' + implementation 'io.tmio:tuweni-units' implementation project(':ethereum:performance-trackers') implementation project(':ethereum:execution-types') implementation project(':ethereum:pow:api') @@ -29,7 +28,7 @@ dependencies { implementation project(':infrastructure:time') testFixturesApi 'com.google.guava:guava' - testFixturesApi 'org.apache.tuweni:tuweni-bytes' + testFixturesApi 'io.tmio:tuweni-bytes' testFixturesApi project(':ethereum:pow:api') testFixturesApi project(':infrastructure:ssz') testFixturesApi project(':infrastructure:unsigned') @@ -37,8 +36,8 @@ dependencies { testFixturesImplementation 'com.fasterxml.jackson.core:jackson-databind' testFixturesImplementation 'net.jqwik:jqwik' testFixturesImplementation 'org.apache.logging.log4j:log4j-api' - testFixturesImplementation 'org.apache.tuweni:tuweni-units' - testFixturesImplementation 'org.apache.tuweni:tuweni-ssz' + testFixturesImplementation 'io.tmio:tuweni-units' + testFixturesImplementation 'io.tmio:tuweni-ssz' testFixturesImplementation 'org.hyperledger.besu.internal:core' testFixturesImplementation 'org.hyperledger.besu.internal:config' testFixturesImplementation 'org.hyperledger.besu:besu-datatypes' @@ -75,4 +74,7 @@ dependencies { testImplementation testFixtures(project(':infrastructure:kzg')) testImplementation testFixtures(project(':infrastructure:ssz')) testImplementation testFixtures(project(':infrastructure:metrics')) + testImplementation testFixtures(project(':infrastructure:time')) + + testFixturesImplementation 'org.hyperledger.besu.internal:metrics-core' } \ No newline at end of file diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/ForkSchedule.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/ForkSchedule.java index 2e4a9189657..2dc6478763b 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/ForkSchedule.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/ForkSchedule.java @@ -16,6 +16,7 @@ import static com.google.common.base.Preconditions.checkState; import java.util.Comparator; +import java.util.EnumMap; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -36,8 +37,8 @@ public class ForkSchedule { private final NavigableMap slotToMilestone; private final NavigableMap genesisOffsetToMilestone; private final Map forkVersionToMilestone; - private final Map milestoneToFork; - private final NavigableMap fullMilestoneToForkMap; + private final EnumMap milestoneToFork; + private final EnumMap fullMilestoneToForkMap; private final Fork genesisFork; private ForkSchedule( @@ -46,8 +47,8 @@ private ForkSchedule( final NavigableMap slotToMilestone, final NavigableMap genesisOffsetToMilestone, final Map forkVersionToMilestone, - final Map milestoneToFork, - final NavigableMap fullMilestoneToForkMap) { + final EnumMap milestoneToFork, + final EnumMap fullMilestoneToForkMap) { this.genesisFork = genesisFork; this.epochToMilestone = epochToMilestone; this.slotToMilestone = slotToMilestone; @@ -180,8 +181,9 @@ public static class Builder { private final NavigableMap slotToMilestone = new TreeMap<>(); private final NavigableMap genesisOffsetToMilestone = new TreeMap<>(); private final Map forkVersionToMilestone = new HashMap<>(); - private final Map milestoneToFork = new HashMap<>(); - private final NavigableMap fullMilestoneToForkMap = new TreeMap<>(); + private final EnumMap milestoneToFork = new EnumMap<>(SpecMilestone.class); + private final EnumMap fullMilestoneToForkMap = + new EnumMap<>(SpecMilestone.class); // Track info on the last processed milestone private Optional prevForkVersion = Optional.empty(); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/Spec.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/Spec.java index fd5066ddeb2..d2d6a8dabf6 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/Spec.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/Spec.java @@ -17,14 +17,17 @@ import static tech.pegasys.teku.infrastructure.time.TimeUtilities.millisToSeconds; import static tech.pegasys.teku.infrastructure.time.TimeUtilities.secondsToMillis; import static tech.pegasys.teku.spec.SpecMilestone.DENEB; -import static tech.pegasys.teku.spec.SpecMilestone.EIP7594; +import static tech.pegasys.teku.spec.config.SpecConfig.FAR_FUTURE_EPOCH; import com.fasterxml.jackson.databind.ObjectMapper; import com.google.common.base.Preconditions; +import it.unimi.dsi.fastutil.ints.Int2IntMap; +import it.unimi.dsi.fastutil.ints.Int2ObjectMap; import it.unimi.dsi.fastutil.ints.IntList; import java.io.File; import java.io.IOException; -import java.util.HashMap; +import java.util.Arrays; +import java.util.EnumMap; import java.util.List; import java.util.Map; import java.util.NavigableMap; @@ -47,11 +50,11 @@ import tech.pegasys.teku.spec.cache.IndexedAttestationCache; import tech.pegasys.teku.spec.config.NetworkingSpecConfig; import tech.pegasys.teku.spec.config.NetworkingSpecConfigDeneb; -import tech.pegasys.teku.spec.config.NetworkingSpecConfigEip7594; import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.config.SpecConfigAltair; +import tech.pegasys.teku.spec.config.SpecConfigAndParent; import tech.pegasys.teku.spec.config.SpecConfigDeneb; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.features.Eip7594; import tech.pegasys.teku.spec.constants.Domain; import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.Blob; @@ -104,15 +107,21 @@ import tech.pegasys.teku.spec.logic.common.util.SyncCommitteeUtil; import tech.pegasys.teku.spec.logic.versions.bellatrix.block.OptimisticExecutionPayloadExecutor; import tech.pegasys.teku.spec.schemas.SchemaDefinitions; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistryBuilder; public class Spec { private final Map specVersions; private final ForkSchedule forkSchedule; private final StateTransition stateTransition; + private final SpecConfigAndParent specConfigAndParent; - private Spec(Map specVersions, final ForkSchedule forkSchedule) { - Preconditions.checkArgument(specVersions != null && specVersions.size() > 0); + private Spec( + final SpecConfigAndParent specConfigAndParent, + final Map specVersions, + final ForkSchedule forkSchedule) { + Preconditions.checkArgument(specVersions != null && !specVersions.isEmpty()); Preconditions.checkArgument(forkSchedule != null); + this.specConfigAndParent = specConfigAndParent; this.specVersions = specVersions; this.forkSchedule = forkSchedule; @@ -120,12 +129,16 @@ private Spec(Map specVersions, final ForkSchedule fo this.stateTransition = new StateTransition(this::atSlot); } - static Spec create(final SpecConfig config, final SpecMilestone highestMilestoneSupported) { - final Map specVersions = new HashMap<>(); + static Spec create( + final SpecConfigAndParent specConfigAndParent, + final SpecMilestone highestMilestoneSupported) { + final Map specVersions = new EnumMap<>(SpecMilestone.class); final ForkSchedule.Builder forkScheduleBuilder = ForkSchedule.builder(); + final SchemaRegistryBuilder schemaRegistryBuilder = SchemaRegistryBuilder.create(); for (SpecMilestone milestone : SpecMilestone.getMilestonesUpTo(highestMilestoneSupported)) { - SpecVersion.create(milestone, config) + SpecVersion.create( + milestone, specConfigAndParent.forMilestone(milestone), schemaRegistryBuilder) .ifPresent( milestoneSpec -> { forkScheduleBuilder.addNextMilestone(milestoneSpec); @@ -135,7 +148,7 @@ static Spec create(final SpecConfig config, final SpecMilestone highestMilestone final ForkSchedule forkSchedule = forkScheduleBuilder.build(); - return new Spec(specVersions, forkSchedule); + return new Spec(specConfigAndParent, specVersions, forkSchedule); } public SpecVersion forMilestone(final SpecMilestone milestone) { @@ -158,6 +171,10 @@ private SpecVersion atTimeMillis(final UInt64 genesisTimeMillis, final UInt64 cu return atTime(millisToSeconds(genesisTimeMillis), millisToSeconds(currentTimeMillis)); } + public SpecConfigAndParent getSpecConfigAndParent() { + return specConfigAndParent; + } + public SpecConfig getSpecConfig(final UInt64 epoch) { return atEpoch(epoch).getConfig(); } @@ -219,16 +236,6 @@ public Optional getNetworkingConfigDeneb() { .map(specConfig -> (NetworkingSpecConfigDeneb) specConfig.getNetworkingConfig()); } - /** - * Networking config with EIP7594 constants. Use {@link SpecConfigEip7594#required(SpecConfig)} - * when you are sure that EIP7594 is available, otherwise use this method - */ - public Optional getNetworkingConfigEip7594() { - return Optional.ofNullable(forMilestone(EIP7594)) - .map(SpecVersion::getConfig) - .map(specConfig -> (NetworkingSpecConfigEip7594) specConfig.getNetworkingConfig()); - } - public SchemaDefinitions getGenesisSchemaDefinitions() { return getGenesisSpec().getSchemaDefinitions(); } @@ -245,6 +252,10 @@ public List getEnabledMilestones() { return forkSchedule.getActiveMilestones(); } + public List getEnabledFeatures() { + return Arrays.stream(SpecFeature.values()).filter(this::isFeatureScheduled).toList(); + } + /** * Returns true if the given milestone is at or prior to our highest supported milestone * @@ -308,7 +319,7 @@ public int getSyncCommitteeSize(final UInt64 slot) { public BeaconState initializeBeaconStateFromEth1( final Bytes32 eth1BlockHash, final UInt64 eth1Timestamp, - final List deposits, + final List deposits, final Optional payloadHeader) { final GenesisGenerator genesisGenerator = createGenesisGenerator(); genesisGenerator.updateCandidateState(eth1BlockHash, eth1Timestamp, deposits); @@ -423,7 +434,7 @@ public ExecutionPayloadHeader deserializeJsonExecutionPayloadHeader( public DataColumnSidecar deserializeSidecar(final Bytes serializedSidecar, final UInt64 slot) { return atSlot(slot) .getSchemaDefinitions() - .toVersionEip7594() + .getOptionalSchemaDefinitionsEip7594() .orElseThrow( () -> new RuntimeException("EIP7594 milestone is required to deserialize column sidecar")) @@ -526,9 +537,9 @@ public Bytes32 getRandaoMix(final BeaconState state, final UInt64 epoch) { } public boolean verifyProposerSlashingSignature( - BeaconState state, - ProposerSlashing proposerSlashing, - BLSSignatureVerifier signatureVerifier) { + final BeaconState state, + final ProposerSlashing proposerSlashing, + final BLSSignatureVerifier signatureVerifier) { final UInt64 epoch = getProposerSlashingEpoch(proposerSlashing); return atEpoch(epoch) .operationSignatureVerifier() @@ -537,18 +548,20 @@ public boolean verifyProposerSlashingSignature( } public boolean verifyVoluntaryExitSignature( - BeaconState state, SignedVoluntaryExit signedExit, BLSSignatureVerifier signatureVerifier) { + final BeaconState state, + final SignedVoluntaryExit signedExit, + final BLSSignatureVerifier signatureVerifier) { final UInt64 epoch = signedExit.getMessage().getEpoch(); return atEpoch(epoch) .operationSignatureVerifier() .verifyVoluntaryExitSignature(state, signedExit, signatureVerifier); } - public Bytes32 getPreviousDutyDependentRoot(BeaconState state) { + public Bytes32 getPreviousDutyDependentRoot(final BeaconState state) { return atState(state).getBeaconStateUtil().getPreviousDutyDependentRoot(state); } - public Bytes32 getCurrentDutyDependentRoot(BeaconState state) { + public Bytes32 getCurrentDutyDependentRoot(final BeaconState state) { return atState(state).getBeaconStateUtil().getCurrentDutyDependentRoot(state); } @@ -574,13 +587,14 @@ public UInt64 getEarliestQueryableSlotForBeaconCommitteeInTargetEpoch(final UInt } // ForkChoice utils - public UInt64 getCurrentSlot(UInt64 currentTime, UInt64 genesisTime) { + public UInt64 getCurrentSlot(final UInt64 currentTime, final UInt64 genesisTime) { return atTime(genesisTime, currentTime) .getForkChoiceUtil() .getCurrentSlot(currentTime, genesisTime); } - public UInt64 getCurrentSlotForMillis(UInt64 currentTimeMillis, UInt64 genesisTimeMillis) { + public UInt64 getCurrentSlotForMillis( + final UInt64 currentTimeMillis, final UInt64 genesisTimeMillis) { return atTimeMillis(genesisTimeMillis, currentTimeMillis) .getForkChoiceUtil() .getCurrentSlotForMillis(currentTimeMillis, genesisTimeMillis); @@ -715,7 +729,7 @@ public boolean blockDescendsFromLatestFinalizedBlock( blockSlot, blockParentRoot, store, forkChoiceStrategy); } - public BeaconState processSlots(BeaconState preState, UInt64 slot) + public BeaconState processSlots(final BeaconState preState, final UInt64 slot) throws SlotProcessingException, EpochProcessingException { return stateTransition.processSlots(preState, slot); } @@ -776,7 +790,11 @@ public SignedBeaconBlock blindSignedBeaconBlock( } public Optional> getExpectedWithdrawals(final BeaconState state) { - return atState(state).getBlockProcessor().getExpectedWithdrawals(state); + if (!atState(state).getMilestone().isGreaterThanOrEqualTo(SpecMilestone.CAPELLA)) { + return Optional.empty(); + } + return Optional.of( + atState(state).getBlockProcessor().getExpectedWithdrawals(state).getWithdrawalList()); } // Block Processor Utils @@ -837,7 +855,7 @@ public UInt64 getSyncCommitteeParticipantReward(final BeaconState state) { } public boolean isEnoughVotesToUpdateEth1Data( - BeaconState state, Eth1Data eth1Data, final int additionalVotes) { + final BeaconState state, final Eth1Data eth1Data, final int additionalVotes) { final BlockProcessor blockProcessor = atState(state).getBlockProcessor(); final long existingVotes = blockProcessor.getVoteCount(state, eth1Data); return blockProcessor.isEnoughVotesToUpdateEth1Data(existingVotes + additionalVotes); @@ -851,11 +869,11 @@ public IntList getActiveValidatorIndices(final BeaconState state, final UInt64 e return atEpoch(epoch).beaconStateAccessors().getActiveValidatorIndices(state, epoch); } - public UInt64 getTotalActiveBalance(BeaconState state) { + public UInt64 getTotalActiveBalance(final BeaconState state) { return atState(state).beaconStateAccessors().getTotalActiveBalance(state); } - public UInt64 getProposerBoostAmount(BeaconState state) { + public UInt64 getProposerBoostAmount(final BeaconState state) { return atState(state).beaconStateAccessors().getProposerBoostAmount(state); } @@ -863,10 +881,15 @@ public int getPreviousEpochAttestationCapacity(final BeaconState state) { return atState(state).beaconStateAccessors().getPreviousEpochAttestationCapacity(state); } - public IntList getBeaconCommittee(BeaconState state, UInt64 slot, UInt64 index) { + public IntList getBeaconCommittee( + final BeaconState state, final UInt64 slot, final UInt64 index) { return atState(state).beaconStateAccessors().getBeaconCommittee(state, slot, index); } + public Int2IntMap getBeaconCommitteesSize(final BeaconState state, final UInt64 slot) { + return atState(state).beaconStateAccessors().getBeaconCommitteesSize(state, slot); + } + public Optional getValidatorPubKey( final BeaconState state, final UInt64 validatorIndex) { return atState(state).beaconStateAccessors().getValidatorPubKey(state, validatorIndex); @@ -883,11 +906,11 @@ public Optional getValidatorIndex( } public Optional getCommitteeAssignment( - BeaconState state, UInt64 epoch, int validatorIndex) { + final BeaconState state, final UInt64 epoch, final int validatorIndex) { return atEpoch(epoch).getValidatorsUtil().getCommitteeAssignment(state, epoch, validatorIndex); } - public Map getValidatorIndexToCommitteeAssignmentMap( + public Int2ObjectMap getValidatorIndexToCommitteeAssignmentMap( final BeaconState state, final UInt64 epoch) { return atEpoch(epoch) .getValidatorsUtil() @@ -896,7 +919,9 @@ public Map getValidatorIndexToCommitteeAssignmentM // Attestation helpers public IntList getAttestingIndices(final BeaconState state, final Attestation attestation) { - return atState(state).getAttestationUtil().getAttestingIndices(state, attestation); + return atSlot(attestation.getData().getSlot()) + .getAttestationUtil() + .getAttestingIndices(state, attestation); } public AttestationData getGenericAttestationData( @@ -910,9 +935,9 @@ public AttestationData getGenericAttestationData( } public SafeFuture isValidIndexedAttestation( - BeaconState state, - ValidatableAttestation attestation, - AsyncBLSSignatureVerifier blsSignatureVerifier) { + final BeaconState state, + final ValidatableAttestation attestation, + final AsyncBLSSignatureVerifier blsSignatureVerifier) { final UInt64 slot = attestation.getData().getSlot(); return atSlot(slot) .getAttestationUtil() @@ -942,31 +967,63 @@ public boolean isAvailabilityOfBlobSidecarsRequiredAtEpoch( .orElse(false); } - public Optional getMaxBlobsPerBlock() { - return getSpecConfigDeneb().map(SpecConfigDeneb::getMaxBlobsPerBlock); - } + /** + * This method is used to setup caches and limits during the initialization of the node. We + * normally increase the blobs with each fork, but in case we will decrease them, let's consider + * the last two forks. + */ + public Optional getMaxBlobsPerBlockForHighestMilestone() { + final SpecMilestone highestSupportedMilestone = + getForkSchedule().getHighestSupportedMilestone(); + + final Optional maybeHighestMaxBlobsPerBlock = + forMilestone(highestSupportedMilestone) + .getConfig() + .toVersionDeneb() + .map(SpecConfigDeneb::getMaxBlobsPerBlock); + + final Optional maybeSecondHighestMaxBlobsPerBlock = + highestSupportedMilestone + .getPreviousMilestoneIfExists() + .map(this::forMilestone) + .map(SpecVersion::getConfig) + .flatMap(SpecConfig::toVersionDeneb) + .map(SpecConfigDeneb::getMaxBlobsPerBlock); + + if (maybeHighestMaxBlobsPerBlock.isEmpty() && maybeSecondHighestMaxBlobsPerBlock.isEmpty()) { + return Optional.empty(); + } - public Optional getMaxBlobsPerBlock(final UInt64 slot) { - return getSpecConfigDeneb(slot).map(SpecConfigDeneb::getMaxBlobsPerBlock); + final int highestMaxBlobsPerBlock = maybeHighestMaxBlobsPerBlock.orElse(0); + final int secondHighestMaxBlobsPerBlock = maybeSecondHighestMaxBlobsPerBlock.orElse(0); + final int max = Math.max(highestMaxBlobsPerBlock, secondHighestMaxBlobsPerBlock); + + return Optional.of(max); } public UInt64 computeSubnetForBlobSidecar(final BlobSidecar blobSidecar) { - final SpecConfig config = atSlot(blobSidecar.getSlot()).getConfig(); - final SpecConfigDeneb specConfigDeneb = SpecConfigDeneb.required(config); - return blobSidecar.getIndex().mod(specConfigDeneb.getBlobSidecarSubnetCount()); + return blobSidecar + .getIndex() + .mod( + SpecConfigDeneb.required(atSlot(blobSidecar.getSlot()).getConfig()) + .getBlobSidecarSubnetCount()); } public Optional getNumberOfDataColumns() { - return getSpecConfigEip7594().map(SpecConfigEip7594::getNumberOfColumns); + return getFeatureConfigEip7594().map(Eip7594::getNumberOfColumns); + } + + public Optional getNumberOfDataColumnSubnets() { + return getFeatureConfigEip7594().map(Eip7594::getDataColumnSidecarSubnetCount); } public boolean isAvailabilityOfDataColumnSidecarsRequiredAtEpoch( final ReadOnlyStore store, final UInt64 epoch) { - if (!forkSchedule.getSpecMilestoneAtEpoch(epoch).isGreaterThanOrEqualTo(EIP7594)) { + if (!isFeatureActivatedAtEpoch(SpecFeature.EIP7594, epoch)) { return false; } final SpecConfig config = atEpoch(epoch).getConfig(); - final SpecConfigEip7594 specConfigEip7594 = SpecConfigEip7594.required(config); + final Eip7594 specConfigEip7594 = Eip7594.required(config); return getCurrentEpoch(store) .minusMinZero(epoch) .isLessThanOrEqualTo(specConfigEip7594.getMinEpochsForDataColumnSidecarsRequests()); @@ -974,7 +1031,7 @@ public boolean isAvailabilityOfDataColumnSidecarsRequiredAtEpoch( public UInt64 computeSubnetForDataColumnSidecar(final DataColumnSidecar dataColumnSidecar) { final SpecConfig config = atSlot(dataColumnSidecar.getSlot()).getConfig(); - final SpecConfigEip7594 specConfigEip7594 = SpecConfigEip7594.required(config); + final Eip7594 specConfigEip7594 = Eip7594.required(config); return dataColumnSidecar.getIndex().mod(specConfigEip7594.getDataColumnSidecarSubnetCount()); } @@ -984,6 +1041,35 @@ public Optional computeFirstSlotWithBlobSupport() { .map(this::computeStartSlotAtEpoch); } + // Electra Utils + public boolean isFormerDepositMechanismDisabled(final BeaconState state) { + return atState(state).miscHelpers().isFormerDepositMechanismDisabled(state); + } + + public boolean isFeatureScheduled(final SpecFeature feature) { + return switch (feature) { + case EIP7594 -> + this.getFeatureConfigEip7594() + .map(eip7594 -> eip7594.getEip7594FeatureEpoch().isLessThan(FAR_FUTURE_EPOCH)) + .orElse(false); + default -> false; + }; + } + + public boolean isFeatureActivated(final SpecFeature feature, final ReadOnlyStore store) { + return isFeatureActivatedAtEpoch(feature, getCurrentEpoch(store)); + } + + public boolean isFeatureActivatedAtEpoch(final SpecFeature feature, final UInt64 epoch) { + return switch (feature) { + case EIP7594 -> + this.getFeatureConfigEip7594() + .map(eip7594 -> epoch.isGreaterThanOrEqualTo(eip7594.getEip7594FeatureEpoch())) + .orElse(false); + default -> false; + }; + } + // Deneb private helpers private Optional getSpecConfigDeneb() { final SpecMilestone highestSupportedMilestone = @@ -993,17 +1079,13 @@ private Optional getSpecConfigDeneb() { .flatMap(SpecConfig::toVersionDeneb); } - private Optional getSpecConfigDeneb(final UInt64 slot) { - return atSlot(slot).getConfig().toVersionDeneb(); - } - // EIP7594 private helpers - private Optional getSpecConfigEip7594() { + private Optional getFeatureConfigEip7594() { final SpecMilestone highestSupportedMilestone = getForkSchedule().getHighestSupportedMilestone(); return Optional.ofNullable(forMilestone(highestSupportedMilestone)) .map(SpecVersion::getConfig) - .flatMap(SpecConfig::toVersionEip7594); + .flatMap(SpecConfig::getOptionalEip7594Config); } // Private helpers diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/SpecFactory.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/SpecFactory.java index a76e7e31b1a..4b9854cd43e 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/SpecFactory.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/SpecFactory.java @@ -17,7 +17,8 @@ import static tech.pegasys.teku.spec.SpecMilestone.BELLATRIX; import static tech.pegasys.teku.spec.SpecMilestone.CAPELLA; import static tech.pegasys.teku.spec.SpecMilestone.DENEB; -import static tech.pegasys.teku.spec.SpecMilestone.EIP7594; +import static tech.pegasys.teku.spec.SpecMilestone.ELECTRA; +import static tech.pegasys.teku.spec.SpecMilestone.FULU; import static tech.pegasys.teku.spec.SpecMilestone.PHASE0; import static tech.pegasys.teku.spec.config.SpecConfig.FAR_FUTURE_EPOCH; @@ -25,48 +26,70 @@ import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.config.SpecConfigAltair; +import tech.pegasys.teku.spec.config.SpecConfigAndParent; import tech.pegasys.teku.spec.config.SpecConfigBellatrix; import tech.pegasys.teku.spec.config.SpecConfigCapella; import tech.pegasys.teku.spec.config.SpecConfigDeneb; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.config.SpecConfigFulu; import tech.pegasys.teku.spec.config.SpecConfigLoader; import tech.pegasys.teku.spec.config.builder.SpecConfigBuilder; public class SpecFactory { - public static Spec create(String configName) { + public static Spec create(final String configName) { return create(configName, __ -> {}); } public static Spec create(final String configName, final Consumer modifier) { - final SpecConfig config = SpecConfigLoader.loadConfig(configName, modifier); + final SpecConfigAndParent config = + SpecConfigLoader.loadConfig(configName, modifier); return create(config); } - public static Spec create(final SpecConfig config) { + public static Spec create(final SpecConfigAndParent config) { final UInt64 altairForkEpoch = - config.toVersionAltair().map(SpecConfigAltair::getAltairForkEpoch).orElse(FAR_FUTURE_EPOCH); + config + .specConfig() + .toVersionAltair() + .map(SpecConfigAltair::getAltairForkEpoch) + .orElse(FAR_FUTURE_EPOCH); final UInt64 bellatrixForkEpoch = config + .specConfig() .toVersionBellatrix() .map(SpecConfigBellatrix::getBellatrixForkEpoch) .orElse(FAR_FUTURE_EPOCH); final UInt64 capellaForkEpoch = config + .specConfig() .toVersionCapella() .map(SpecConfigCapella::getCapellaForkEpoch) .orElse(FAR_FUTURE_EPOCH); final UInt64 denebForkEpoch = - config.toVersionDeneb().map(SpecConfigDeneb::getDenebForkEpoch).orElse(FAR_FUTURE_EPOCH); - final UInt64 eip7594ForkEpoch = config - .toVersionEip7594() - .map(SpecConfigEip7594::getEip7594ForkEpoch) + .specConfig() + .toVersionDeneb() + .map(SpecConfigDeneb::getDenebForkEpoch) + .orElse(FAR_FUTURE_EPOCH); + final UInt64 electraForkEpoch = + config + .specConfig() + .toVersionElectra() + .map(SpecConfigElectra::getElectraForkEpoch) + .orElse(FAR_FUTURE_EPOCH); + final UInt64 fuluForkEpoch = + config + .specConfig() + .toVersionFulu() + .map(SpecConfigFulu::getFuluForkEpoch) .orElse(FAR_FUTURE_EPOCH); final SpecMilestone highestMilestoneSupported; - if (!eip7594ForkEpoch.equals(FAR_FUTURE_EPOCH)) { - highestMilestoneSupported = EIP7594; + if (!fuluForkEpoch.equals(FAR_FUTURE_EPOCH)) { + highestMilestoneSupported = FULU; + } else if (!electraForkEpoch.equals(FAR_FUTURE_EPOCH)) { + highestMilestoneSupported = ELECTRA; } else if (!denebForkEpoch.equals(FAR_FUTURE_EPOCH)) { highestMilestoneSupported = DENEB; } else if (!capellaForkEpoch.equals(FAR_FUTURE_EPOCH)) { diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/SpecFeature.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/SpecFeature.java new file mode 100644 index 00000000000..65ff3d1a9c6 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/SpecFeature.java @@ -0,0 +1,18 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec; + +public enum SpecFeature { + EIP7594 +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/SpecMilestone.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/SpecMilestone.java index a865759da1f..b125ef9aa77 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/SpecMilestone.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/SpecMilestone.java @@ -13,6 +13,7 @@ package tech.pegasys.teku.spec; +import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.base.Preconditions.checkNotNull; import java.util.Arrays; @@ -26,7 +27,8 @@ import tech.pegasys.teku.spec.config.SpecConfigBellatrix; import tech.pegasys.teku.spec.config.SpecConfigCapella; import tech.pegasys.teku.spec.config.SpecConfigDeneb; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.config.SpecConfigFulu; public enum SpecMilestone { PHASE0, @@ -34,7 +36,8 @@ public enum SpecMilestone { BELLATRIX, CAPELLA, DENEB, - EIP7594; + ELECTRA, + FULU; /** * Returns true if this milestone is at or after the supplied milestone ({@code other}) @@ -46,13 +49,30 @@ public boolean isGreaterThanOrEqualTo(final SpecMilestone other) { return compareTo(other) >= 0; } + public boolean isGreaterThan(final SpecMilestone other) { + return compareTo(other) > 0; + } + + public boolean isLessThanOrEqualTo(final SpecMilestone other) { + return compareTo(other) <= 0; + } + /** Returns the milestone prior to this milestone */ + @SuppressWarnings("EnumOrdinal") public SpecMilestone getPreviousMilestone() { - if (equals(PHASE0)) { - throw new IllegalArgumentException("There is no milestone prior to Phase0"); + checkArgument(!equals(PHASE0), "There is no milestone prior to Phase0"); + final SpecMilestone[] values = SpecMilestone.values(); + return values[ordinal() - 1]; + } + + /** Returns the milestone prior to this milestone */ + @SuppressWarnings("EnumOrdinal") + public Optional getPreviousMilestoneIfExists() { + if (this.equals(PHASE0)) { + return Optional.empty(); } - final List priorMilestones = getAllPriorMilestones(this); - return priorMilestones.get(priorMilestones.size() - 1); + final SpecMilestone[] values = SpecMilestone.values(); + return Optional.of(values[ordinal() - 1]); } /** @@ -108,28 +128,28 @@ static Optional getForkVersion( return switch (milestone) { case PHASE0 -> Optional.of(specConfig.getGenesisForkVersion()); case ALTAIR -> specConfig.toVersionAltair().map(SpecConfigAltair::getAltairForkVersion); - case BELLATRIX -> specConfig - .toVersionBellatrix() - .map(SpecConfigBellatrix::getBellatrixForkVersion); + case BELLATRIX -> + specConfig.toVersionBellatrix().map(SpecConfigBellatrix::getBellatrixForkVersion); case CAPELLA -> specConfig.toVersionCapella().map(SpecConfigCapella::getCapellaForkVersion); case DENEB -> specConfig.toVersionDeneb().map(SpecConfigDeneb::getDenebForkVersion); - case EIP7594 -> specConfig.toVersionEip7594().map(SpecConfigEip7594::getEip7594ForkVersion); + case ELECTRA -> specConfig.toVersionElectra().map(SpecConfigElectra::getElectraForkVersion); + case FULU -> specConfig.toVersionFulu().map(SpecConfigFulu::getFuluForkVersion); }; } static Optional getForkEpoch(final SpecConfig specConfig, final SpecMilestone milestone) { return switch (milestone) { case PHASE0 -> - // Phase0 can only ever start at epoch 0 - no non-zero slot is valid. However, another fork - // may also be configured to start at epoch 0, effectively overriding phase0 - Optional.of(UInt64.ZERO); + // Phase0 can only ever start at epoch 0 - no non-zero slot is valid. However, another + // fork may also be configured to start at epoch 0, effectively overriding phase0 + Optional.of(UInt64.ZERO); case ALTAIR -> specConfig.toVersionAltair().map(SpecConfigAltair::getAltairForkEpoch); - case BELLATRIX -> specConfig - .toVersionBellatrix() - .map(SpecConfigBellatrix::getBellatrixForkEpoch); + case BELLATRIX -> + specConfig.toVersionBellatrix().map(SpecConfigBellatrix::getBellatrixForkEpoch); case CAPELLA -> specConfig.toVersionCapella().map(SpecConfigCapella::getCapellaForkEpoch); case DENEB -> specConfig.toVersionDeneb().map(SpecConfigDeneb::getDenebForkEpoch); - case EIP7594 -> specConfig.toVersionEip7594().map(SpecConfigEip7594::getEip7594ForkEpoch); + case ELECTRA -> specConfig.toVersionElectra().map(SpecConfigElectra::getElectraForkEpoch); + case FULU -> specConfig.toVersionFulu().map(SpecConfigFulu::getFuluForkEpoch); }; } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/SpecVersion.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/SpecVersion.java index 79a7d430700..72cf0158a37 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/SpecVersion.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/SpecVersion.java @@ -13,20 +13,24 @@ package tech.pegasys.teku.spec; +import static tech.pegasys.teku.infrastructure.time.SystemTimeProvider.SYSTEM_TIME_PROVIDER; + import java.util.Optional; import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.config.SpecConfigAltair; import tech.pegasys.teku.spec.config.SpecConfigBellatrix; import tech.pegasys.teku.spec.config.SpecConfigCapella; import tech.pegasys.teku.spec.config.SpecConfigDeneb; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.config.SpecConfigFulu; import tech.pegasys.teku.spec.logic.DelegatingSpecLogic; import tech.pegasys.teku.spec.logic.SpecLogic; import tech.pegasys.teku.spec.logic.versions.altair.SpecLogicAltair; import tech.pegasys.teku.spec.logic.versions.bellatrix.SpecLogicBellatrix; import tech.pegasys.teku.spec.logic.versions.capella.SpecLogicCapella; import tech.pegasys.teku.spec.logic.versions.deneb.SpecLogicDeneb; -import tech.pegasys.teku.spec.logic.versions.eip7594.SpecLogicEip7594; +import tech.pegasys.teku.spec.logic.versions.electra.SpecLogicElectra; +import tech.pegasys.teku.spec.logic.versions.fulu.SpecLogicFulu; import tech.pegasys.teku.spec.logic.versions.phase0.SpecLogicPhase0; import tech.pegasys.teku.spec.schemas.SchemaDefinitions; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsAltair; @@ -34,7 +38,10 @@ import tech.pegasys.teku.spec.schemas.SchemaDefinitionsCapella; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsDeneb; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsEip7594; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsPhase0; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistryBuilder; public class SpecVersion extends DelegatingSpecLogic { private final SpecMilestone milestone; @@ -53,51 +60,120 @@ private SpecVersion( } public static Optional create( - final SpecMilestone milestone, final SpecConfig specConfig) { + final SpecMilestone milestone, + final SpecConfig specConfig, + final SchemaRegistryBuilder schemaRegistryBuilder) { + return switch (milestone) { - case PHASE0 -> Optional.of(createPhase0(specConfig)); - case ALTAIR -> specConfig.toVersionAltair().map(SpecVersion::createAltair); - case BELLATRIX -> specConfig.toVersionBellatrix().map(SpecVersion::createBellatrix); - case CAPELLA -> specConfig.toVersionCapella().map(SpecVersion::createCapella); - case DENEB -> specConfig.toVersionDeneb().map(SpecVersion::createDeneb); - case EIP7594 -> specConfig.toVersionEip7594().map(SpecVersion::createEip7594); + case PHASE0 -> Optional.of(createPhase0(specConfig, schemaRegistryBuilder)); + case ALTAIR -> + specConfig + .toVersionAltair() + .map(specConfigAltair -> createAltair(specConfigAltair, schemaRegistryBuilder)); + case BELLATRIX -> + specConfig + .toVersionBellatrix() + .map( + specConfigBellatrix -> + createBellatrix(specConfigBellatrix, schemaRegistryBuilder)); + case CAPELLA -> + specConfig + .toVersionCapella() + .map(specConfigCapella -> createCapella(specConfigCapella, schemaRegistryBuilder)); + case DENEB -> + specConfig + .toVersionDeneb() + .map(specConfigDeneb -> createDeneb(specConfigDeneb, schemaRegistryBuilder)); + case ELECTRA -> + specConfig + .toVersionElectra() + .map(specConfigElectra -> createElectra(specConfigElectra, schemaRegistryBuilder)); + case FULU -> + specConfig + .toVersionFulu() + .map(specConfigFulu -> createFulu(specConfigFulu, schemaRegistryBuilder)); }; } - static SpecVersion createPhase0(final SpecConfig specConfig) { - final SchemaDefinitions schemaDefinitions = new SchemaDefinitionsPhase0(specConfig); - final SpecLogic specLogic = SpecLogicPhase0.create(specConfig, schemaDefinitions); + static SpecVersion createPhase0( + final SpecConfig specConfig, final SchemaRegistryBuilder schemaRegistryBuilder) { + final SchemaRegistry schemaRegistry = + schemaRegistryBuilder.build(SpecMilestone.PHASE0, specConfig); + final SchemaDefinitions schemaDefinitions = new SchemaDefinitionsPhase0(schemaRegistry); + final SpecLogic specLogic = + SpecLogicPhase0.create(specConfig, schemaDefinitions, SYSTEM_TIME_PROVIDER); return new SpecVersion(SpecMilestone.PHASE0, specConfig, schemaDefinitions, specLogic); } - static SpecVersion createAltair(final SpecConfigAltair specConfig) { - final SchemaDefinitionsAltair schemaDefinitions = new SchemaDefinitionsAltair(specConfig); - final SpecLogic specLogic = SpecLogicAltair.create(specConfig, schemaDefinitions); + static SpecVersion createAltair( + final SpecConfigAltair specConfig, final SchemaRegistryBuilder schemaRegistryBuilder) { + final SchemaRegistry schemaRegistry = + schemaRegistryBuilder.build(SpecMilestone.ALTAIR, specConfig); + final SchemaDefinitionsAltair schemaDefinitions = new SchemaDefinitionsAltair(schemaRegistry); + final SpecLogic specLogic = + SpecLogicAltair.create(specConfig, schemaDefinitions, SYSTEM_TIME_PROVIDER); return new SpecVersion(SpecMilestone.ALTAIR, specConfig, schemaDefinitions, specLogic); } - static SpecVersion createBellatrix(final SpecConfigBellatrix specConfig) { - final SchemaDefinitionsBellatrix schemaDefinitions = new SchemaDefinitionsBellatrix(specConfig); - final SpecLogic specLogic = SpecLogicBellatrix.create(specConfig, schemaDefinitions); + static SpecVersion createBellatrix( + final SpecConfigBellatrix specConfig, final SchemaRegistryBuilder schemaRegistryBuilder) { + final SchemaRegistry schemaRegistry = + schemaRegistryBuilder.build(SpecMilestone.BELLATRIX, specConfig); + final SchemaDefinitionsBellatrix schemaDefinitions = + new SchemaDefinitionsBellatrix(schemaRegistry); + final SpecLogic specLogic = + SpecLogicBellatrix.create(specConfig, schemaDefinitions, SYSTEM_TIME_PROVIDER); return new SpecVersion(SpecMilestone.BELLATRIX, specConfig, schemaDefinitions, specLogic); } - static SpecVersion createCapella(final SpecConfigCapella specConfig) { - final SchemaDefinitionsCapella schemaDefinitions = new SchemaDefinitionsCapella(specConfig); - final SpecLogicCapella specLogic = SpecLogicCapella.create(specConfig, schemaDefinitions); + static SpecVersion createCapella( + final SpecConfigCapella specConfig, final SchemaRegistryBuilder schemaRegistryBuilder) { + final SchemaRegistry schemaRegistry = + schemaRegistryBuilder.build(SpecMilestone.CAPELLA, specConfig); + final SchemaDefinitionsCapella schemaDefinitions = new SchemaDefinitionsCapella(schemaRegistry); + final SpecLogicCapella specLogic = + SpecLogicCapella.create(specConfig, schemaDefinitions, SYSTEM_TIME_PROVIDER); return new SpecVersion(SpecMilestone.CAPELLA, specConfig, schemaDefinitions, specLogic); } - static SpecVersion createDeneb(final SpecConfigDeneb specConfig) { - final SchemaDefinitionsDeneb schemaDefinitions = new SchemaDefinitionsDeneb(specConfig); - final SpecLogicDeneb specLogic = SpecLogicDeneb.create(specConfig, schemaDefinitions); + static SpecVersion createDeneb( + final SpecConfigDeneb specConfig, final SchemaRegistryBuilder schemaRegistryBuilder) { + final SchemaRegistry schemaRegistry = + schemaRegistryBuilder.build(SpecMilestone.DENEB, specConfig); + final SchemaDefinitionsDeneb schemaDefinitions = new SchemaDefinitionsDeneb(schemaRegistry); + final SpecLogicDeneb specLogic = + SpecLogicDeneb.create(specConfig, schemaDefinitions, SYSTEM_TIME_PROVIDER); return new SpecVersion(SpecMilestone.DENEB, specConfig, schemaDefinitions, specLogic); } - static SpecVersion createEip7594(final SpecConfigEip7594 specConfig) { - final SchemaDefinitionsEip7594 schemaDefinitions = new SchemaDefinitionsEip7594(specConfig); - final SpecLogicEip7594 specLogic = SpecLogicEip7594.create(specConfig, schemaDefinitions); - return new SpecVersion(SpecMilestone.EIP7594, specConfig, schemaDefinitions, specLogic); + static SpecVersion createElectra( + final SpecConfigElectra specConfig, final SchemaRegistryBuilder schemaRegistryBuilder) { + final SchemaRegistry schemaRegistry = + schemaRegistryBuilder.build(SpecMilestone.ELECTRA, specConfig); + final SchemaDefinitionsElectra schemaDefinitions = + new SchemaDefinitionsElectra( + schemaRegistry, + specConfig + .getOptionalEip7594Config() + .map(__ -> new SchemaDefinitionsEip7594(schemaRegistry))); + final SpecLogicElectra specLogic = + SpecLogicElectra.create(specConfig, schemaDefinitions, SYSTEM_TIME_PROVIDER); + return new SpecVersion(SpecMilestone.ELECTRA, specConfig, schemaDefinitions, specLogic); + } + + static SpecVersion createFulu( + final SpecConfigFulu specConfig, final SchemaRegistryBuilder schemaRegistryBuilder) { + final SchemaRegistry schemaRegistry = + schemaRegistryBuilder.build(SpecMilestone.FULU, specConfig); + final SchemaDefinitionsElectra schemaDefinitions = + new SchemaDefinitionsElectra( + schemaRegistry, + specConfig + .getOptionalEip7594Config() + .map(__ -> new SchemaDefinitionsEip7594(schemaRegistry))); + final SpecLogicFulu specLogic = + SpecLogicFulu.create(specConfig, schemaDefinitions, SYSTEM_TIME_PROVIDER); + return new SpecVersion(SpecMilestone.FULU, specConfig, schemaDefinitions, specLogic); } public SpecMilestone getMilestone() { diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/DelegatingSpecConfig.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/DelegatingSpecConfig.java index 19d4970cc86..b513c9b16bf 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/DelegatingSpecConfig.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/DelegatingSpecConfig.java @@ -18,6 +18,7 @@ import tech.pegasys.teku.ethereum.execution.types.Eth1Address; import tech.pegasys.teku.infrastructure.bytes.Bytes4; import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecMilestone; public class DelegatingSpecConfig implements SpecConfig { protected final SpecConfig specConfig; @@ -71,6 +72,11 @@ public int getMinPerEpochChurnLimit() { return specConfig.getMinPerEpochChurnLimit(); } + @Override + public UInt64 getMaxPerEpochActivationExitChurnLimit() { + return specConfig.getMaxPerEpochActivationExitChurnLimit(); + } + @Override public int getChurnLimitQuotient() { return specConfig.getChurnLimitQuotient(); @@ -390,4 +396,9 @@ public int getAttestationSubnetPrefixBits() { public int getProposerScoreBoost() { return specConfig.getProposerScoreBoost(); } + + @Override + public SpecMilestone getMilestone() { + return specConfig.getMilestone(); + } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/DelegatingSpecConfigDeneb.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/DelegatingSpecConfigDeneb.java index 28f2d9b29d3..47fe150a92f 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/DelegatingSpecConfigDeneb.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/DelegatingSpecConfigDeneb.java @@ -61,6 +61,11 @@ public int getMaxBlobsPerBlock() { return specConfigDeneb.getMaxBlobsPerBlock(); } + @Override + public int getTargetBlobsPerBlock() { + return specConfigDeneb.getTargetBlobsPerBlock(); + } + @Override public int getKzgCommitmentInclusionProofDepth() { return specConfigDeneb.getKzgCommitmentInclusionProofDepth(); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/DelegatingSpecConfigElectra.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/DelegatingSpecConfigElectra.java new file mode 100644 index 00000000000..d1b899d1c74 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/DelegatingSpecConfigElectra.java @@ -0,0 +1,152 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.config; + +import java.util.Objects; +import java.util.Optional; +import tech.pegasys.teku.infrastructure.bytes.Bytes4; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.config.features.Eip7594; + +public class DelegatingSpecConfigElectra extends DelegatingSpecConfigDeneb + implements SpecConfigElectra { + private final SpecConfigElectra specConfigElectra; + // FIXME: why are we setting it in Electra if it's any fork feature? + // maybe say because it should be at least electra to set? Is it viable? + private final Optional eip7594; + + public DelegatingSpecConfigElectra(final SpecConfigElectra specConfig) { + this(specConfig, Optional.empty()); + } + + public DelegatingSpecConfigElectra( + final SpecConfigElectra specConfig, final Optional eip7594) { + super(specConfig); + this.specConfigElectra = SpecConfigElectra.required(specConfig); + this.eip7594 = eip7594; + } + + @Override + public Optional toVersionElectra() { + return Optional.of(this); + } + + @Override + public Optional getOptionalEip7594Config() { + return specConfigElectra.getOptionalEip7594Config().or(() -> eip7594); + } + + @Override + public Bytes4 getElectraForkVersion() { + return specConfigElectra.getElectraForkVersion(); + } + + @Override + public UInt64 getElectraForkEpoch() { + return specConfigElectra.getElectraForkEpoch(); + } + + @Override + public UInt64 getMinPerEpochChurnLimitElectra() { + return specConfigElectra.getMinPerEpochChurnLimitElectra(); + } + + @Override + public UInt64 getMinActivationBalance() { + return specConfigElectra.getMinActivationBalance(); + } + + @Override + public UInt64 getMaxEffectiveBalanceElectra() { + return specConfigElectra.getMaxEffectiveBalanceElectra(); + } + + @Override + public int getPendingDepositsLimit() { + return specConfigElectra.getPendingDepositsLimit(); + } + + @Override + public int getPendingPartialWithdrawalsLimit() { + return specConfigElectra.getPendingPartialWithdrawalsLimit(); + } + + @Override + public int getPendingConsolidationsLimit() { + return specConfigElectra.getPendingConsolidationsLimit(); + } + + @Override + public int getMinSlashingPenaltyQuotientElectra() { + return specConfigElectra.getMinSlashingPenaltyQuotientElectra(); + } + + @Override + public int getWhistleblowerRewardQuotientElectra() { + return specConfigElectra.getWhistleblowerRewardQuotientElectra(); + } + + @Override + public int getMaxAttesterSlashingsElectra() { + return specConfigElectra.getMaxAttesterSlashingsElectra(); + } + + @Override + public int getMaxAttestationsElectra() { + return specConfigElectra.getMaxAttestationsElectra(); + } + + @Override + public int getMaxConsolidationRequestsPerPayload() { + return specConfigElectra.getMaxConsolidationRequestsPerPayload(); + } + + @Override + public int getMaxDepositRequestsPerPayload() { + return specConfigElectra.getMaxDepositRequestsPerPayload(); + } + + @Override + public int getMaxWithdrawalRequestsPerPayload() { + return specConfigElectra.getMaxWithdrawalRequestsPerPayload(); + } + + @Override + public int getMaxPendingPartialsPerWithdrawalsSweep() { + return specConfigElectra.getMaxPendingPartialsPerWithdrawalsSweep(); + } + + @Override + public int getMaxPendingDepositsPerEpoch() { + return specConfigElectra.getMaxPendingDepositsPerEpoch(); + } + + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + final DelegatingSpecConfigElectra that = (DelegatingSpecConfigElectra) o; + return Objects.equals(specConfigElectra, that.specConfigElectra) + && Objects.equals(eip7594, that.eip7594); + } + + @Override + public int hashCode() { + return Objects.hash(specConfigElectra, eip7594); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/DelegatingSpecConfigFulu.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/DelegatingSpecConfigFulu.java new file mode 100644 index 00000000000..dd75f80ea53 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/DelegatingSpecConfigFulu.java @@ -0,0 +1,61 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.config; + +import java.util.Objects; +import java.util.Optional; +import tech.pegasys.teku.infrastructure.bytes.Bytes4; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; + +public class DelegatingSpecConfigFulu extends DelegatingSpecConfigElectra + implements SpecConfigFulu { + private final SpecConfigFulu specConfigFulu; + + public DelegatingSpecConfigFulu(final SpecConfigFulu specConfig) { + super(specConfig); + this.specConfigFulu = SpecConfigFulu.required(specConfig); + } + + @Override + public Optional toVersionFulu() { + return Optional.of(this); + } + + @Override + public Bytes4 getFuluForkVersion() { + return specConfigFulu.getFuluForkVersion(); + } + + @Override + public UInt64 getFuluForkEpoch() { + return specConfigFulu.getFuluForkEpoch(); + } + + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + final DelegatingSpecConfigFulu that = (DelegatingSpecConfigFulu) o; + return Objects.equals(specConfigFulu, that.specConfigFulu); + } + + @Override + public int hashCode() { + return Objects.hash(specConfigFulu); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/NetworkingSpecConfigEip7594.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/FeatureSpecConfig.java similarity index 55% rename from ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/NetworkingSpecConfigEip7594.java rename to ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/FeatureSpecConfig.java index 76ca882030b..53a3ed8e92d 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/NetworkingSpecConfigEip7594.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/FeatureSpecConfig.java @@ -1,5 +1,5 @@ /* - * Copyright Consensys Software Inc., 2022 + * Copyright Consensys Software Inc., 2024 * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at @@ -13,21 +13,11 @@ package tech.pegasys.teku.spec.config; -/** - * Networking constants - * - *

These constants are unified among forks and are not overridden, new constant name is used if - * it's changed in the new fork - */ -public interface NetworkingSpecConfigEip7594 extends NetworkingSpecConfig { - - int getDataColumnSidecarSubnetCount(); - - int getCustodyRequirement(); - - int getSamplesPerSlot(); - - int getMinEpochsForDataColumnSidecarsRequests(); +import java.util.Optional; +import tech.pegasys.teku.spec.config.features.Eip7594; - int getMaxRequestDataColumnSidecars(); +public interface FeatureSpecConfig { + default Optional getOptionalEip7594Config() { + return Optional.empty(); + } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfig.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfig.java index 2616309ccac..5e9d38e3c33 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfig.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfig.java @@ -19,9 +19,10 @@ import tech.pegasys.teku.ethereum.execution.types.Eth1Address; import tech.pegasys.teku.infrastructure.bytes.Bytes4; import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.config.builder.SpecConfigBuilder; -public interface SpecConfig extends NetworkingSpecConfig { +public interface SpecConfig extends NetworkingSpecConfig, FeatureSpecConfig { // Non-configurable constants UInt64 GENESIS_SLOT = UInt64.ZERO; UInt64 GENESIS_EPOCH = UInt64.ZERO; @@ -62,6 +63,8 @@ default int getMillisPerSlot() { int getMinPerEpochChurnLimit(); + UInt64 getMaxPerEpochActivationExitChurnLimit(); + int getChurnLimitQuotient(); // Config: Fork choice @@ -183,7 +186,13 @@ default Optional toVersionDeneb() { return Optional.empty(); } - default Optional toVersionEip7594() { + default Optional toVersionElectra() { return Optional.empty(); } + + default Optional toVersionFulu() { + return Optional.empty(); + } + + SpecMilestone getMilestone(); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigAltair.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigAltair.java index 9d9e17627b7..d336d069a50 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigAltair.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigAltair.java @@ -19,7 +19,7 @@ public interface SpecConfigAltair extends SpecConfig { - static SpecConfigAltair required(SpecConfig specConfig) { + static SpecConfigAltair required(final SpecConfig specConfig) { return specConfig .toVersionAltair() .orElseThrow( diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigAltairImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigAltairImpl.java index 0cbfd20f76f..9acadbec46a 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigAltairImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigAltairImpl.java @@ -17,6 +17,7 @@ import java.util.Optional; import tech.pegasys.teku.infrastructure.bytes.Bytes4; import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecMilestone; public class SpecConfigAltairImpl extends DelegatingSpecConfig implements SpecConfigAltair { @@ -156,6 +157,11 @@ public Optional toVersionAltair() { return Optional.of(this); } + @Override + public SpecMilestone getMilestone() { + return SpecMilestone.ALTAIR; + } + @Override public boolean equals(final Object o) { if (this == o) { diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigAndParent.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigAndParent.java new file mode 100644 index 00000000000..3d62340947d --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigAndParent.java @@ -0,0 +1,41 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.config; + +import java.util.Optional; +import tech.pegasys.teku.spec.SpecMilestone; + +public record SpecConfigAndParent( + TConfig specConfig, Optional> parentSpecConfig) { + + public static + SpecConfigAndParent of( + final TConfig spec, final SpecConfigAndParent parentSpec) { + return new SpecConfigAndParent<>(spec, Optional.of(parentSpec)); + } + + public static SpecConfigAndParent of(final TConfig spec) { + return new SpecConfigAndParent<>(spec, Optional.empty()); + } + + public SpecConfig forMilestone(final SpecMilestone milestone) { + if (specConfig.getMilestone() == milestone) { + return specConfig; + } + if (parentSpecConfig.isEmpty()) { + throw new IllegalArgumentException("No config available for milestone " + milestone); + } + return parentSpecConfig.get().forMilestone(milestone); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigBellatrix.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigBellatrix.java index bc550da19ce..f011a07137e 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigBellatrix.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigBellatrix.java @@ -21,7 +21,7 @@ public interface SpecConfigBellatrix extends SpecConfigAltair { - static SpecConfigBellatrix required(SpecConfig specConfig) { + static SpecConfigBellatrix required(final SpecConfig specConfig) { return specConfig .toVersionBellatrix() .orElseThrow( diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigBellatrixImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigBellatrixImpl.java index 199102da252..f06186aceb5 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigBellatrixImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigBellatrixImpl.java @@ -19,6 +19,7 @@ import org.apache.tuweni.units.bigints.UInt256; import tech.pegasys.teku.infrastructure.bytes.Bytes4; import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecMilestone; public class SpecConfigBellatrixImpl extends DelegatingSpecConfigAltair implements SpecConfigBellatrix { @@ -153,6 +154,11 @@ public Optional toVersionBellatrix() { return Optional.of(this); } + @Override + public SpecMilestone getMilestone() { + return SpecMilestone.BELLATRIX; + } + @Override public boolean equals(final Object o) { if (this == o) { diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigCapella.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigCapella.java index 1f0553ee6b0..a4cac7dbb89 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigCapella.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigCapella.java @@ -19,7 +19,7 @@ public interface SpecConfigCapella extends SpecConfigBellatrix { - static SpecConfigCapella required(SpecConfig specConfig) { + static SpecConfigCapella required(final SpecConfig specConfig) { return specConfig .toVersionCapella() .orElseThrow( diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigCapellaImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigCapellaImpl.java index 53e42fa486f..ad4626f05e3 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigCapellaImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigCapellaImpl.java @@ -17,6 +17,7 @@ import java.util.Optional; import tech.pegasys.teku.infrastructure.bytes.Bytes4; import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecMilestone; public class SpecConfigCapellaImpl extends DelegatingSpecConfigBellatrix implements SpecConfigCapella { @@ -100,4 +101,9 @@ public int getMaxValidatorsPerWithdrawalSweep() { public Optional toVersionCapella() { return Optional.of(this); } + + @Override + public SpecMilestone getMilestone() { + return SpecMilestone.CAPELLA; + } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigDeneb.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigDeneb.java index 1f25c8822c0..1f0a3a1e7d3 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigDeneb.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigDeneb.java @@ -54,7 +54,8 @@ static SpecConfigDeneb required(final SpecConfig specConfig) { int getMaxBlobsPerBlock(); - /** BlobSidecar's */ + int getTargetBlobsPerBlock(); + int getKzgCommitmentInclusionProofDepth(); int getEpochsStoreBlobs(); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigDenebImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigDenebImpl.java index 53ced36b5af..e944a8fd228 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigDenebImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigDenebImpl.java @@ -17,6 +17,7 @@ import java.util.Optional; import tech.pegasys.teku.infrastructure.bytes.Bytes4; import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecMilestone; public class SpecConfigDenebImpl extends DelegatingSpecConfigCapella implements SpecConfigDeneb { @@ -93,6 +94,11 @@ public int getMaxBlobsPerBlock() { return maxBlobsPerBlock; } + @Override + public int getTargetBlobsPerBlock() { + return maxBlobsPerBlock / 2; + } + @Override public int getKzgCommitmentInclusionProofDepth() { return kzgCommitmentInclusionProofDepth; @@ -130,6 +136,11 @@ public Optional toVersionDeneb() { return Optional.of(this); } + @Override + public SpecMilestone getMilestone() { + return SpecMilestone.DENEB; + } + @Override public boolean equals(final Object o) { if (this == o) { diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigElectra.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigElectra.java new file mode 100644 index 00000000000..05700c3f294 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigElectra.java @@ -0,0 +1,71 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.config; + +import java.util.Optional; +import tech.pegasys.teku.infrastructure.bytes.Bytes4; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; + +public interface SpecConfigElectra extends SpecConfigDeneb, NetworkingSpecConfigDeneb { + + UInt64 UNSET_DEPOSIT_REQUESTS_START_INDEX = UInt64.MAX_VALUE; + UInt64 FULL_EXIT_REQUEST_AMOUNT = UInt64.ZERO; + + static SpecConfigElectra required(final SpecConfig specConfig) { + return specConfig + .toVersionElectra() + .orElseThrow( + () -> + new IllegalArgumentException( + "Expected Electra spec config but got: " + + specConfig.getClass().getSimpleName())); + } + + Bytes4 getElectraForkVersion(); + + UInt64 getElectraForkEpoch(); + + UInt64 getMinPerEpochChurnLimitElectra(); + + UInt64 getMinActivationBalance(); + + UInt64 getMaxEffectiveBalanceElectra(); + + int getPendingDepositsLimit(); + + int getPendingPartialWithdrawalsLimit(); + + int getPendingConsolidationsLimit(); + + int getMinSlashingPenaltyQuotientElectra(); + + int getWhistleblowerRewardQuotientElectra(); + + int getMaxAttesterSlashingsElectra(); + + int getMaxAttestationsElectra(); + + int getMaxConsolidationRequestsPerPayload(); + + int getMaxDepositRequestsPerPayload(); + + int getMaxWithdrawalRequestsPerPayload(); + + int getMaxPendingPartialsPerWithdrawalsSweep(); + + int getMaxPendingDepositsPerEpoch(); + + @Override + Optional toVersionElectra(); +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigElectraImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigElectraImpl.java new file mode 100644 index 00000000000..76aa8e62b14 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigElectraImpl.java @@ -0,0 +1,269 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.config; + +import java.util.Objects; +import java.util.Optional; +import tech.pegasys.teku.infrastructure.bytes.Bytes4; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecMilestone; + +public class SpecConfigElectraImpl extends DelegatingSpecConfigDeneb implements SpecConfigElectra { + + private final Bytes4 electraForkVersion; + private final UInt64 electraForkEpoch; + + private final UInt64 minPerEpochChurnLimitElectra; + + private final UInt64 minActivationBalance; + private final UInt64 maxEffectiveBalanceElectra; + private final int minSlashingPenaltyQuotientElectra; + private final int whistleblowerRewardQuotientElectra; + private final int pendingDepositsLimit; + private final int pendingPartialWithdrawalsLimit; + private final int pendingConsolidationsLimit; + private final int maxAttesterSlashingsElectra; + private final int maxAttestationsElectra; + private final int maxDepositRequestsPerPayload; + private final int maxWithdrawalRequestsPerPayload; + private final int maxConsolidationRequestsPerPayload; + private final int maxPendingPartialsPerWithdrawalsSweep; + private final int maxPendingDepositsPerEpoch; + private final int maxBlobsPerBlockElectra; + private final int targetBlobsPerBlockElectra; + private final int maxRequestBlobSidecarsElectra; + private final int blobSidecarSubnetCountElectra; + + public SpecConfigElectraImpl( + final SpecConfigDeneb specConfig, + final Bytes4 electraForkVersion, + final UInt64 electraForkEpoch, + final UInt64 minPerEpochChurnLimitElectra, + final UInt64 minActivationBalance, + final UInt64 maxEffectiveBalanceElectra, + final int minSlashingPenaltyQuotientElectra, + final int whistleblowerRewardQuotientElectra, + final int pendingDepositsLimit, + final int pendingPartialWithdrawalsLimit, + final int pendingConsolidationsLimit, + final int maxAttesterSlashingsElectra, + final int maxAttestationsElectra, + final int maxDepositRequestsPerPayload, + final int maxWithdrawalRequestsPerPayload, + final int maxConsolidationRequestsPerPayload, + final int maxPendingPartialsPerWithdrawalsSweep, + final int maxPendingDepositsPerEpoch, + final int maxBlobsPerBlockElectra, + final int targetBlobsPerBlockElectra, + final int maxRequestBlobSidecarsElectra, + final int blobSidecarSubnetCountElectra) { + super(specConfig); + this.electraForkVersion = electraForkVersion; + this.electraForkEpoch = electraForkEpoch; + this.minPerEpochChurnLimitElectra = minPerEpochChurnLimitElectra; + this.minActivationBalance = minActivationBalance; + this.maxEffectiveBalanceElectra = maxEffectiveBalanceElectra; + this.minSlashingPenaltyQuotientElectra = minSlashingPenaltyQuotientElectra; + this.whistleblowerRewardQuotientElectra = whistleblowerRewardQuotientElectra; + this.pendingDepositsLimit = pendingDepositsLimit; + this.pendingPartialWithdrawalsLimit = pendingPartialWithdrawalsLimit; + this.pendingConsolidationsLimit = pendingConsolidationsLimit; + this.maxAttesterSlashingsElectra = maxAttesterSlashingsElectra; + this.maxAttestationsElectra = maxAttestationsElectra; + this.maxDepositRequestsPerPayload = maxDepositRequestsPerPayload; + this.maxWithdrawalRequestsPerPayload = maxWithdrawalRequestsPerPayload; + this.maxConsolidationRequestsPerPayload = maxConsolidationRequestsPerPayload; + this.maxPendingPartialsPerWithdrawalsSweep = maxPendingPartialsPerWithdrawalsSweep; + this.maxPendingDepositsPerEpoch = maxPendingDepositsPerEpoch; + this.maxBlobsPerBlockElectra = maxBlobsPerBlockElectra; + this.targetBlobsPerBlockElectra = targetBlobsPerBlockElectra; + this.maxRequestBlobSidecarsElectra = maxRequestBlobSidecarsElectra; + this.blobSidecarSubnetCountElectra = blobSidecarSubnetCountElectra; + } + + @Override + public Bytes4 getElectraForkVersion() { + return electraForkVersion; + } + + @Override + public UInt64 getElectraForkEpoch() { + return electraForkEpoch; + } + + @Override + public UInt64 getMinPerEpochChurnLimitElectra() { + return minPerEpochChurnLimitElectra; + } + + @Override + public UInt64 getMinActivationBalance() { + return minActivationBalance; + } + + @Override + public UInt64 getMaxEffectiveBalanceElectra() { + return maxEffectiveBalanceElectra; + } + + @Override + public int getMinSlashingPenaltyQuotientElectra() { + return minSlashingPenaltyQuotientElectra; + } + + @Override + public int getWhistleblowerRewardQuotientElectra() { + return whistleblowerRewardQuotientElectra; + } + + @Override + public int getPendingDepositsLimit() { + return pendingDepositsLimit; + } + + @Override + public int getPendingPartialWithdrawalsLimit() { + return pendingPartialWithdrawalsLimit; + } + + @Override + public int getPendingConsolidationsLimit() { + return pendingConsolidationsLimit; + } + + @Override + public int getMaxAttesterSlashingsElectra() { + return maxAttesterSlashingsElectra; + } + + @Override + public int getMaxAttestationsElectra() { + return maxAttestationsElectra; + } + + @Override + public int getMaxDepositRequestsPerPayload() { + return maxDepositRequestsPerPayload; + } + + @Override + public int getMaxWithdrawalRequestsPerPayload() { + return maxWithdrawalRequestsPerPayload; + } + + @Override + public int getMaxConsolidationRequestsPerPayload() { + return maxConsolidationRequestsPerPayload; + } + + @Override + public int getMaxPendingPartialsPerWithdrawalsSweep() { + return maxPendingPartialsPerWithdrawalsSweep; + } + + @Override + public int getMaxPendingDepositsPerEpoch() { + return maxPendingDepositsPerEpoch; + } + + @Override + public int getMaxBlobsPerBlock() { + return maxBlobsPerBlockElectra; + } + + @Override + public int getTargetBlobsPerBlock() { + return targetBlobsPerBlockElectra; + } + + @Override + public int getBlobSidecarSubnetCount() { + return blobSidecarSubnetCountElectra; + } + + @Override + public int getMaxRequestBlobSidecars() { + return maxRequestBlobSidecarsElectra; + } + + @Override + public Optional toVersionElectra() { + return Optional.of(this); + } + + @Override + public SpecMilestone getMilestone() { + return SpecMilestone.ELECTRA; + } + + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + final SpecConfigElectraImpl that = (SpecConfigElectraImpl) o; + return Objects.equals(specConfig, that.specConfig) + && Objects.equals(electraForkVersion, that.electraForkVersion) + && Objects.equals(electraForkEpoch, that.electraForkEpoch) + && Objects.equals(minPerEpochChurnLimitElectra, that.minPerEpochChurnLimitElectra) + && Objects.equals(minActivationBalance, that.minActivationBalance) + && Objects.equals(maxEffectiveBalanceElectra, that.maxEffectiveBalanceElectra) + && minSlashingPenaltyQuotientElectra == that.minSlashingPenaltyQuotientElectra + && whistleblowerRewardQuotientElectra == that.whistleblowerRewardQuotientElectra + && pendingDepositsLimit == that.pendingDepositsLimit + && pendingPartialWithdrawalsLimit == that.pendingPartialWithdrawalsLimit + && pendingConsolidationsLimit == that.pendingConsolidationsLimit + && maxAttesterSlashingsElectra == that.maxAttesterSlashingsElectra + && maxAttestationsElectra == that.maxAttestationsElectra + && maxDepositRequestsPerPayload == that.maxDepositRequestsPerPayload + && maxWithdrawalRequestsPerPayload == that.maxWithdrawalRequestsPerPayload + && maxConsolidationRequestsPerPayload == that.maxConsolidationRequestsPerPayload + && maxPendingPartialsPerWithdrawalsSweep == that.maxPendingPartialsPerWithdrawalsSweep + && maxPendingDepositsPerEpoch == that.maxPendingDepositsPerEpoch + && maxBlobsPerBlockElectra == that.maxBlobsPerBlockElectra + && targetBlobsPerBlockElectra == that.targetBlobsPerBlockElectra + && maxRequestBlobSidecarsElectra == that.maxRequestBlobSidecarsElectra + && blobSidecarSubnetCountElectra == that.blobSidecarSubnetCountElectra; + } + + @Override + public int hashCode() { + return Objects.hash( + specConfig, + electraForkVersion, + electraForkEpoch, + minPerEpochChurnLimitElectra, + minActivationBalance, + maxEffectiveBalanceElectra, + minSlashingPenaltyQuotientElectra, + whistleblowerRewardQuotientElectra, + pendingDepositsLimit, + pendingPartialWithdrawalsLimit, + pendingConsolidationsLimit, + maxAttesterSlashingsElectra, + maxAttestationsElectra, + maxDepositRequestsPerPayload, + maxWithdrawalRequestsPerPayload, + maxConsolidationRequestsPerPayload, + maxPendingPartialsPerWithdrawalsSweep, + maxPendingDepositsPerEpoch, + maxBlobsPerBlockElectra, + targetBlobsPerBlockElectra, + maxRequestBlobSidecarsElectra, + blobSidecarSubnetCountElectra); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigFulu.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigFulu.java new file mode 100644 index 00000000000..a7a7fbe9470 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigFulu.java @@ -0,0 +1,37 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.config; + +import java.util.Optional; +import tech.pegasys.teku.infrastructure.bytes.Bytes4; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; + +public interface SpecConfigFulu extends SpecConfigElectra { + + static SpecConfigFulu required(final SpecConfig specConfig) { + return specConfig + .toVersionFulu() + .orElseThrow( + () -> + new IllegalArgumentException( + "Expected Fulu spec config but got: " + specConfig.getClass().getSimpleName())); + } + + Bytes4 getFuluForkVersion(); + + UInt64 getFuluForkEpoch(); + + @Override + Optional toVersionFulu(); +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigFuluImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigFuluImpl.java new file mode 100644 index 00000000000..0cc94af4e98 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigFuluImpl.java @@ -0,0 +1,74 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.config; + +import java.util.Objects; +import java.util.Optional; +import tech.pegasys.teku.infrastructure.bytes.Bytes4; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecMilestone; + +public class SpecConfigFuluImpl extends DelegatingSpecConfigElectra implements SpecConfigFulu { + + private final Bytes4 fuluForkVersion; + private final UInt64 fuluForkEpoch; + + public SpecConfigFuluImpl( + final SpecConfigElectra specConfig, + final Bytes4 fuluForkVersion, + final UInt64 fuluForkEpoch) { + super(specConfig); + this.fuluForkVersion = fuluForkVersion; + this.fuluForkEpoch = fuluForkEpoch; + } + + @Override + public Bytes4 getFuluForkVersion() { + return fuluForkVersion; + } + + @Override + public UInt64 getFuluForkEpoch() { + return fuluForkEpoch; + } + + @Override + public SpecMilestone getMilestone() { + return SpecMilestone.FULU; + } + + @Override + public Optional toVersionFulu() { + return Optional.of(this); + } + + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + final SpecConfigFuluImpl that = (SpecConfigFuluImpl) o; + return Objects.equals(specConfig, that.specConfig) + && Objects.equals(fuluForkVersion, that.fuluForkVersion) + && Objects.equals(fuluForkEpoch, that.fuluForkEpoch); + } + + @Override + public int hashCode() { + return Objects.hash(specConfig, fuluForkVersion, fuluForkEpoch); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigLoader.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigLoader.java index 643ca14bd09..e40e5e8c006 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigLoader.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigLoader.java @@ -32,24 +32,25 @@ public class SpecConfigLoader { private static final Logger LOG = LogManager.getLogger(); private static final List AVAILABLE_PRESETS = - List.of("phase0", "altair", "bellatrix", "capella", "deneb", "eip7594"); + List.of("phase0", "altair", "bellatrix", "capella", "deneb", "electra", "eip7594"); private static final String CONFIG_PATH = "configs/"; private static final String PRESET_PATH = "presets/"; - public static SpecConfig loadConfigStrict(final String configName) { + public static SpecConfigAndParent loadConfigStrict( + final String configName) { return loadConfig(configName, false, __ -> {}); } - public static SpecConfig loadConfig(final String configName) { + public static SpecConfigAndParent loadConfig(final String configName) { return loadConfig(configName, __ -> {}); } - public static SpecConfig loadConfig( + public static SpecConfigAndParent loadConfig( final String configName, final Consumer modifier) { return loadConfig(configName, true, modifier); } - public static SpecConfig loadConfig( + public static SpecConfigAndParent loadConfig( final String configName, final boolean ignoreUnknownConfigItems, final Consumer modifier) { @@ -58,7 +59,8 @@ public static SpecConfig loadConfig( return reader.build(modifier); } - public static SpecConfig loadRemoteConfig(final Map config) { + public static SpecConfigAndParent loadRemoteConfig( + final Map config) { final SpecConfigReader reader = new SpecConfigReader(); if (config.containsKey(SpecConfigReader.PRESET_KEY)) { try { diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigPhase0.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigPhase0.java index 87c070098d0..6d41969704c 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigPhase0.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigPhase0.java @@ -19,6 +19,7 @@ import tech.pegasys.teku.ethereum.execution.types.Eth1Address; import tech.pegasys.teku.infrastructure.bytes.Bytes4; import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.constants.WithdrawalPrefixes; import tech.pegasys.teku.spec.logic.common.helpers.MathHelpers; @@ -120,6 +121,8 @@ public class SpecConfigPhase0 implements SpecConfig { private final int reorgHeadWeightThreshold; private final int reorgParentWeightThreshold; + private final UInt64 maxPerEpochActivationExitChurnLimit; + public SpecConfigPhase0( final Map rawConfig, final UInt64 eth1FollowDistance, @@ -188,7 +191,8 @@ public SpecConfigPhase0( final int attestationSubnetPrefixBits, final int reorgMaxEpochsSinceFinalization, final int reorgHeadWeightThreshold, - final int reorgParentWeightThreshold) { + final int reorgParentWeightThreshold, + final UInt64 maxPerEpochActivationExitChurnLimit) { this.rawConfig = rawConfig; this.eth1FollowDistance = eth1FollowDistance; this.maxCommitteesPerSlot = maxCommitteesPerSlot; @@ -258,6 +262,7 @@ public SpecConfigPhase0( this.reorgMaxEpochsSinceFinalization = reorgMaxEpochsSinceFinalization; this.reorgHeadWeightThreshold = reorgHeadWeightThreshold; this.reorgParentWeightThreshold = reorgParentWeightThreshold; + this.maxPerEpochActivationExitChurnLimit = maxPerEpochActivationExitChurnLimit; } @Override @@ -305,6 +310,11 @@ public int getMinPerEpochChurnLimit() { return minPerEpochChurnLimit; } + @Override + public UInt64 getMaxPerEpochActivationExitChurnLimit() { + return maxPerEpochActivationExitChurnLimit; + } + @Override public int getChurnLimitQuotient() { return churnLimitQuotient; @@ -625,6 +635,11 @@ public int getAttestationSubnetPrefixBits() { return attestationSubnetPrefixBits; } + @Override + public SpecMilestone getMilestone() { + return SpecMilestone.PHASE0; + } + @Override public boolean equals(final Object o) { if (this == o) { diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigReader.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigReader.java index 85ae6256752..1312068f460 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigReader.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigReader.java @@ -49,6 +49,8 @@ import tech.pegasys.teku.spec.config.builder.CapellaBuilder; import tech.pegasys.teku.spec.config.builder.DenebBuilder; import tech.pegasys.teku.spec.config.builder.Eip7594Builder; +import tech.pegasys.teku.spec.config.builder.ElectraBuilder; +import tech.pegasys.teku.spec.config.builder.FuluBuilder; import tech.pegasys.teku.spec.config.builder.SpecConfigBuilder; public class SpecConfigReader { @@ -110,11 +112,12 @@ public class SpecConfigReader { final SpecConfigBuilder configBuilder = SpecConfig.builder(); - public SpecConfig build() { + public SpecConfigAndParent build() { return configBuilder.build(); } - public SpecConfig build(Consumer modifier) { + public SpecConfigAndParent build( + final Consumer modifier) { modifier.accept(configBuilder); return build(); } @@ -197,7 +200,17 @@ public void loadFromMap( unprocessedConfig.remove(constantKey); }); - // Process EIP7594 config + // Process electra config + streamConfigSetters(ElectraBuilder.class) + .forEach( + setter -> { + final String constantKey = camelToSnakeCase(setter.getName()); + final Object rawValue = unprocessedConfig.get(constantKey); + invokeSetter(setter, configBuilder::electraBuilder, constantKey, rawValue); + unprocessedConfig.remove(constantKey); + }); + + // Process EIP7594 feature config streamConfigSetters(Eip7594Builder.class) .forEach( setter -> { @@ -207,6 +220,16 @@ public void loadFromMap( unprocessedConfig.remove(constantKey); }); + // Process Fulu config + streamConfigSetters(FuluBuilder.class) + .forEach( + setter -> { + final String constantKey = camelToSnakeCase(setter.getName()); + final Object rawValue = unprocessedConfig.get(constantKey); + invokeSetter(setter, configBuilder::fuluBuilder, constantKey, rawValue); + unprocessedConfig.remove(constantKey); + }); + // Check any constants that have been configured and then ignore final Set configuredConstants = Sets.intersection(CONSTANT_KEYS, unprocessedConfig.keySet()); @@ -222,7 +245,7 @@ public void loadFromMap( if (!ignoreUnknownConfigItems) { throw new IllegalArgumentException("Detected unknown spec config entries: " + unknownKeys); } else { - LOG.info("Ignoring unknown items in network configuration: {}", unknownKeys); + LOG.warn("Ignoring unknown items in network configuration: {}", unknownKeys); } } } @@ -244,7 +267,7 @@ public Map readValues(final InputStream source) throws IOExcepti } } - private Stream streamConfigSetters(Class builderClass) { + private Stream streamConfigSetters(final Class builderClass) { // Ignore any setters that aren't for individual config entries final Set ignoredSetters = Set.of("rawConfig"); @@ -325,7 +348,7 @@ private Function fromString(final Function function) { } private interface BuilderSupplier { - static BuilderSupplier fromBuilder(T builder) { + static BuilderSupplier fromBuilder(final T builder) { return (consumer) -> consumer.accept(builder); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/AltairBuilder.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/AltairBuilder.java index bd30f3552b9..feccb2e8d0b 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/AltairBuilder.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/AltairBuilder.java @@ -24,6 +24,7 @@ import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.config.SpecConfigAltair; import tech.pegasys.teku.spec.config.SpecConfigAltairImpl; +import tech.pegasys.teku.spec.config.SpecConfigAndParent; public class AltairBuilder implements ForkConfigBuilder { @@ -57,22 +58,25 @@ public class AltairBuilder implements ForkConfigBuilder build( + final SpecConfigAndParent specConfigAndParent) { + return SpecConfigAndParent.of( + new SpecConfigAltairImpl( + specConfigAndParent.specConfig(), + inactivityPenaltyQuotientAltair, + minSlashingPenaltyQuotientAltair, + proportionalSlashingMultiplierAltair, + syncCommitteeSize, + inactivityScoreBias, + inactivityScoreRecoveryRate, + epochsPerSyncCommitteePeriod, + altairForkVersion, + altairForkEpoch, + minSyncCommitteeParticipants, + updateTimeout, + syncCommitteeBranchLength, + finalityBranchLength), + specConfigAndParent); } @Override diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/BellatrixBuilder.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/BellatrixBuilder.java index e6d6bc53c07..621ad059c0a 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/BellatrixBuilder.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/BellatrixBuilder.java @@ -27,6 +27,7 @@ import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.config.SpecConfigAltair; +import tech.pegasys.teku.spec.config.SpecConfigAndParent; import tech.pegasys.teku.spec.config.SpecConfigBellatrix; import tech.pegasys.teku.spec.config.SpecConfigBellatrixImpl; @@ -54,22 +55,25 @@ public class BellatrixBuilder implements ForkConfigBuilder build( + final SpecConfigAndParent specConfigAndParent) { + return SpecConfigAndParent.of( + new SpecConfigBellatrixImpl( + specConfigAndParent.specConfig(), + bellatrixForkVersion, + bellatrixForkEpoch, + inactivityPenaltyQuotientBellatrix, + minSlashingPenaltyQuotientBellatrix, + proportionalSlashingMultiplierBellatrix, + maxBytesPerTransaction, + maxTransactionsPerPayload, + bytesPerLogsBloom, + maxExtraDataBytes, + terminalTotalDifficulty, + terminalBlockHash, + terminalBlockHashActivationEpoch, + safeSlotsToImportOptimistically), + specConfigAndParent); } @Override diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/BuilderChain.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/BuilderChain.java index 7e2d99a6817..8b97525cf20 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/BuilderChain.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/BuilderChain.java @@ -17,6 +17,7 @@ import java.util.function.BiConsumer; import java.util.function.Consumer; import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.config.SpecConfigAndParent; /** * Hides some serious abuse of Java's type system so that from the outside we have a type safe chain @@ -76,9 +77,9 @@ public void addOverridableItemsToRawConfig(final BiConsumer rawC @Override @SuppressWarnings("unchecked") - public Out build(final In specConfig) { - final SpecConfig config = builderToApply.build(specConfig); - return (Out) tail.build(config); + public SpecConfigAndParent build(final SpecConfigAndParent specConfig) { + final SpecConfigAndParent config = builderToApply.build(specConfig); + return tail.build(config); } @Override @@ -95,7 +96,7 @@ public Map getValidationMap() { private static class NoOpForkBuilder implements ForkConfigBuilder { @Override - public T build(final T specConfig) { + public SpecConfigAndParent build(final SpecConfigAndParent specConfig) { return specConfig; } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/CapellaBuilder.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/CapellaBuilder.java index 5d8736dd9f2..42d77643db3 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/CapellaBuilder.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/CapellaBuilder.java @@ -22,6 +22,7 @@ import tech.pegasys.teku.infrastructure.bytes.Bytes4; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.config.SpecConfigAndParent; import tech.pegasys.teku.spec.config.SpecConfigBellatrix; import tech.pegasys.teku.spec.config.SpecConfigCapella; import tech.pegasys.teku.spec.config.SpecConfigCapellaImpl; @@ -38,14 +39,17 @@ public class CapellaBuilder implements ForkConfigBuilder build( + final SpecConfigAndParent specConfig) { + return SpecConfigAndParent.of( + new SpecConfigCapellaImpl( + specConfig.specConfig(), + capellaForkVersion, + capellaForkEpoch, + maxBlsToExecutionChanges, + maxWithdrawalsPerPayload, + maxValidatorsPerWithdrawalSweep), + specConfig); } public CapellaBuilder capellaForkEpoch(final UInt64 capellaForkEpoch) { diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/DenebBuilder.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/DenebBuilder.java index 2ddd5990e00..b352c3e60e8 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/DenebBuilder.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/DenebBuilder.java @@ -23,6 +23,7 @@ import tech.pegasys.teku.infrastructure.bytes.Bytes4; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.config.SpecConfigAndParent; import tech.pegasys.teku.spec.config.SpecConfigCapella; import tech.pegasys.teku.spec.config.SpecConfigDeneb; import tech.pegasys.teku.spec.config.SpecConfigDenebImpl; @@ -46,21 +47,24 @@ public class DenebBuilder implements ForkConfigBuilder build( + final SpecConfigAndParent specConfigAndParent) { + return SpecConfigAndParent.of( + new SpecConfigDenebImpl( + specConfigAndParent.specConfig(), + denebForkVersion, + denebForkEpoch, + maxPerEpochActivationChurnLimit, + fieldElementsPerBlob, + maxBlobCommitmentsPerBlock, + maxBlobsPerBlock, + kzgCommitmentInclusionProofDepth, + maxRequestBlocksDeneb, + maxRequestBlobSidecars, + minEpochsForBlobSidecarsRequests, + blobSidecarSubnetCount, + epochsStoreBlobs), + specConfigAndParent); } public DenebBuilder denebForkEpoch(final UInt64 denebForkEpoch) { diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/Eip7594Builder.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/Eip7594Builder.java index 912dd68aeec..03770ce8465 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/Eip7594Builder.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/Eip7594Builder.java @@ -18,17 +18,17 @@ import java.util.HashMap; import java.util.Map; +import java.util.Optional; import java.util.function.BiConsumer; -import tech.pegasys.teku.infrastructure.bytes.Bytes4; import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.config.DelegatingSpecConfigElectra; import tech.pegasys.teku.spec.config.SpecConfig; -import tech.pegasys.teku.spec.config.SpecConfigDeneb; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; -import tech.pegasys.teku.spec.config.SpecConfigEip7594Impl; +import tech.pegasys.teku.spec.config.SpecConfigAndParent; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.config.features.Eip7594Impl; -public class Eip7594Builder implements ForkConfigBuilder { +public class Eip7594Builder implements ForkConfigBuilder { - private Bytes4 eip7594ForkVersion; private UInt64 eip7594ForkEpoch; private UInt64 fieldElementsPerCell; private UInt64 fieldElementsPerExtBlob; @@ -43,20 +43,23 @@ public class Eip7594Builder implements ForkConfigBuilder build( + final SpecConfigAndParent specConfigAndParent) { + final Eip7594Impl eip7594 = + new Eip7594Impl( + eip7594ForkEpoch, + fieldElementsPerCell, + fieldElementsPerExtBlob, + kzgCommitmentsInclusionProofDepth, + numberOfColumns, + dataColumnSidecarSubnetCount, + custodyRequirement, + samplesPerSlot, + minEpochsForDataColumnSidecarsRequests, + maxRequestDataColumnSidecars); + return SpecConfigAndParent.of( + new DelegatingSpecConfigElectra(specConfigAndParent.specConfig(), Optional.of(eip7594)), + specConfigAndParent); } public Eip7594Builder eip7594ForkEpoch(final UInt64 eip7594ForkEpoch) { @@ -65,12 +68,6 @@ public Eip7594Builder eip7594ForkEpoch(final UInt64 eip7594ForkEpoch) { return this; } - public Eip7594Builder eip7594ForkVersion(final Bytes4 eip7594ForkVersion) { - checkNotNull(eip7594ForkVersion); - this.eip7594ForkVersion = eip7594ForkVersion; - return this; - } - public Eip7594Builder fieldElementsPerCell(final UInt64 fieldElementsPerCell) { checkNotNull(fieldElementsPerCell); this.fieldElementsPerCell = fieldElementsPerCell; @@ -128,7 +125,6 @@ public Eip7594Builder maxRequestDataColumnSidecars(final Integer maxRequestDataC public void validate() { if (eip7594ForkEpoch == null) { eip7594ForkEpoch = SpecConfig.FAR_FUTURE_EPOCH; - eip7594ForkVersion = SpecBuilderUtil.PLACEHOLDER_FORK_VERSION; } // Fill default zeros if fork is unsupported @@ -144,7 +140,6 @@ public Map getValidationMap() { final Map constants = new HashMap<>(); constants.put("eip7594ForkEpoch", eip7594ForkEpoch); - constants.put("eip7594ForkVersion", eip7594ForkVersion); constants.put("numberOfColumns", numberOfColumns); constants.put("dataColumnSidecarSubnetCount", dataColumnSidecarSubnetCount); constants.put("custodyRequirement", custodyRequirement); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/ElectraBuilder.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/ElectraBuilder.java new file mode 100644 index 00000000000..bd7d39253df --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/ElectraBuilder.java @@ -0,0 +1,269 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.config.builder; + +import static com.google.common.base.Preconditions.checkNotNull; +import static tech.pegasys.teku.spec.config.SpecConfig.FAR_FUTURE_EPOCH; + +import java.util.HashMap; +import java.util.Map; +import java.util.function.BiConsumer; +import tech.pegasys.teku.infrastructure.bytes.Bytes4; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.config.SpecConfigAndParent; +import tech.pegasys.teku.spec.config.SpecConfigDeneb; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.config.SpecConfigElectraImpl; + +public class ElectraBuilder implements ForkConfigBuilder { + + private Bytes4 electraForkVersion; + private UInt64 electraForkEpoch; + + private UInt64 minPerEpochChurnLimitElectra; + + private UInt64 minActivationBalance; + private UInt64 maxEffectiveBalanceElectra; + private Integer minSlashingPenaltyQuotientElectra; + private Integer whistleblowerRewardQuotientElectra; + private Integer pendingDepositsLimit; + private Integer pendingPartialWithdrawalsLimit; + private Integer pendingConsolidationsLimit; + private Integer maxAttesterSlashingsElectra; + private Integer maxAttestationsElectra; + private Integer maxDepositRequestsPerPayload; + private Integer maxWithdrawalRequestsPerPayload; + private Integer maxConsolidationRequestsPerPayload; + private Integer maxPendingPartialsPerWithdrawalsSweep; + private Integer maxPendingDepositsPerEpoch; + // FIXME: remove hardcode, missed in Kurtosis config + private Integer maxBlobsPerBlockElectra = 6; + private Integer targetBlobsPerBlockElectra = 3; + private Integer maxRequestBlobSidecarsElectra = 768; + private Integer blobSidecarSubnetCountElectra = 6; + + ElectraBuilder() {} + + @Override + public SpecConfigAndParent build( + final SpecConfigAndParent specConfigAndParent) { + return SpecConfigAndParent.of( + new SpecConfigElectraImpl( + specConfigAndParent.specConfig(), + electraForkVersion, + electraForkEpoch, + minPerEpochChurnLimitElectra, + minActivationBalance, + maxEffectiveBalanceElectra, + minSlashingPenaltyQuotientElectra, + whistleblowerRewardQuotientElectra, + pendingDepositsLimit, + pendingPartialWithdrawalsLimit, + pendingConsolidationsLimit, + maxAttesterSlashingsElectra, + maxAttestationsElectra, + maxDepositRequestsPerPayload, + maxWithdrawalRequestsPerPayload, + maxConsolidationRequestsPerPayload, + maxPendingPartialsPerWithdrawalsSweep, + maxPendingDepositsPerEpoch, + maxBlobsPerBlockElectra, + targetBlobsPerBlockElectra, + maxRequestBlobSidecarsElectra, + blobSidecarSubnetCountElectra), + specConfigAndParent); + } + + public ElectraBuilder electraForkVersion(final Bytes4 electraForkVersion) { + checkNotNull(electraForkVersion); + this.electraForkVersion = electraForkVersion; + return this; + } + + public ElectraBuilder electraForkEpoch(final UInt64 electraForkEpoch) { + checkNotNull(electraForkEpoch); + this.electraForkEpoch = electraForkEpoch; + return this; + } + + public ElectraBuilder minPerEpochChurnLimitElectra(final UInt64 minPerEpochChurnLimitElectra) { + checkNotNull(minPerEpochChurnLimitElectra); + this.minPerEpochChurnLimitElectra = minPerEpochChurnLimitElectra; + return this; + } + + public ElectraBuilder minActivationBalance(final UInt64 minActivationBalance) { + checkNotNull(minActivationBalance); + this.minActivationBalance = minActivationBalance; + return this; + } + + public ElectraBuilder maxEffectiveBalanceElectra(final UInt64 maxEffectiveBalanceElectra) { + checkNotNull(maxEffectiveBalanceElectra); + this.maxEffectiveBalanceElectra = maxEffectiveBalanceElectra; + return this; + } + + public ElectraBuilder minSlashingPenaltyQuotientElectra( + final Integer minSlashingPenaltyQuotientElectra) { + checkNotNull(minSlashingPenaltyQuotientElectra); + this.minSlashingPenaltyQuotientElectra = minSlashingPenaltyQuotientElectra; + return this; + } + + public ElectraBuilder whistleblowerRewardQuotientElectra( + final Integer whistleblowerRewardQuotientElectra) { + checkNotNull(whistleblowerRewardQuotientElectra); + this.whistleblowerRewardQuotientElectra = whistleblowerRewardQuotientElectra; + return this; + } + + public ElectraBuilder pendingDepositsLimit(final Integer pendingDepositsLimit) { + checkNotNull(pendingDepositsLimit); + this.pendingDepositsLimit = pendingDepositsLimit; + return this; + } + + public ElectraBuilder pendingPartialWithdrawalsLimit( + final Integer pendingPartialWithdrawalsLimit) { + checkNotNull(pendingPartialWithdrawalsLimit); + this.pendingPartialWithdrawalsLimit = pendingPartialWithdrawalsLimit; + return this; + } + + public ElectraBuilder pendingConsolidationsLimit(final Integer pendingConsolidationsLimit) { + checkNotNull(pendingConsolidationsLimit); + this.pendingConsolidationsLimit = pendingConsolidationsLimit; + return this; + } + + public ElectraBuilder maxAttesterSlashingsElectra(final Integer maxAttesterSlashingsElectra) { + checkNotNull(maxAttesterSlashingsElectra); + this.maxAttesterSlashingsElectra = maxAttesterSlashingsElectra; + return this; + } + + public ElectraBuilder maxAttestationsElectra(final Integer maxAttestationsElectra) { + checkNotNull(maxAttestationsElectra); + this.maxAttestationsElectra = maxAttestationsElectra; + return this; + } + + public ElectraBuilder maxDepositRequestsPerPayload(final Integer maxDepositRequestsPerPayload) { + checkNotNull(maxDepositRequestsPerPayload); + this.maxDepositRequestsPerPayload = maxDepositRequestsPerPayload; + return this; + } + + public ElectraBuilder maxWithdrawalRequestsPerPayload( + final Integer maxWithdrawalRequestsPerPayload) { + checkNotNull(maxWithdrawalRequestsPerPayload); + this.maxWithdrawalRequestsPerPayload = maxWithdrawalRequestsPerPayload; + return this; + } + + public ElectraBuilder maxConsolidationRequestsPerPayload( + final Integer maxConsolidationsRequestPerPayload) { + checkNotNull(maxConsolidationsRequestPerPayload); + this.maxConsolidationRequestsPerPayload = maxConsolidationsRequestPerPayload; + return this; + } + + public ElectraBuilder maxPendingPartialsPerWithdrawalsSweep( + final Integer maxPendingPartialsPerWithdrawalsSweep) { + checkNotNull(maxPendingPartialsPerWithdrawalsSweep); + this.maxPendingPartialsPerWithdrawalsSweep = maxPendingPartialsPerWithdrawalsSweep; + return this; + } + + public ElectraBuilder maxPendingDepositsPerEpoch(final Integer maxPendingDepositsPerEpoch) { + checkNotNull(maxPendingDepositsPerEpoch); + this.maxPendingDepositsPerEpoch = maxPendingDepositsPerEpoch; + return this; + } + + public ElectraBuilder maxBlobsPerBlockElectra(final Integer maxBlobsPerBlockElectra) { + checkNotNull(maxBlobsPerBlockElectra); + this.maxBlobsPerBlockElectra = maxBlobsPerBlockElectra; + return this; + } + + public ElectraBuilder targetBlobsPerBlockElectra(final Integer targetBlobsPerBlockElectra) { + checkNotNull(targetBlobsPerBlockElectra); + this.targetBlobsPerBlockElectra = targetBlobsPerBlockElectra; + return this; + } + + public ElectraBuilder maxRequestBlobSidecarsElectra(final Integer maxRequestBlobSidecarsElectra) { + checkNotNull(maxRequestBlobSidecarsElectra); + this.maxRequestBlobSidecarsElectra = maxRequestBlobSidecarsElectra; + return this; + } + + public ElectraBuilder blobSidecarSubnetCountElectra(final Integer blobSidecarSubnetCountElectra) { + checkNotNull(blobSidecarSubnetCountElectra); + this.blobSidecarSubnetCountElectra = blobSidecarSubnetCountElectra; + return this; + } + + @Override + public void validate() { + if (electraForkEpoch == null) { + electraForkEpoch = SpecConfig.FAR_FUTURE_EPOCH; + electraForkVersion = SpecBuilderUtil.PLACEHOLDER_FORK_VERSION; + } + + // Fill default zeros if fork is unsupported + if (electraForkEpoch.equals(FAR_FUTURE_EPOCH)) { + SpecBuilderUtil.fillMissingValuesWithZeros(this); + } + + validateConstants(); + } + + @Override + public Map getValidationMap() { + final Map constants = new HashMap<>(); + + constants.put("electraForkEpoch", electraForkEpoch); + constants.put("electraForkVersion", electraForkVersion); + constants.put("minPerEpochChurnLimitElectra", minPerEpochChurnLimitElectra); + constants.put("minActivationBalance", minActivationBalance); + constants.put("maxEffectiveBalanceElectra", maxEffectiveBalanceElectra); + constants.put("pendingDepositsLimit", pendingDepositsLimit); + constants.put("pendingPartialWithdrawalsLimit", pendingPartialWithdrawalsLimit); + constants.put("pendingConsolidationsLimit", pendingConsolidationsLimit); + constants.put("minSlashingPenaltyQuotientElectra", minSlashingPenaltyQuotientElectra); + constants.put("whistleblowerRewardQuotientElectra", whistleblowerRewardQuotientElectra); + constants.put("maxAttesterSlashingsElectra", maxAttesterSlashingsElectra); + constants.put("maxAttestationsElectra", maxAttestationsElectra); + constants.put("maxConsolidationRequestsPerPayload", maxConsolidationRequestsPerPayload); + constants.put("maxDepositRequestsPerPayload", maxDepositRequestsPerPayload); + constants.put("maxWithdrawalRequestsPerPayload", maxWithdrawalRequestsPerPayload); + constants.put("maxPendingPartialsPerWithdrawalsSweep", maxPendingPartialsPerWithdrawalsSweep); + constants.put("maxPendingDepositsPerEpoch", maxPendingDepositsPerEpoch); + constants.put("maxBlobsPerBlockElectra", maxBlobsPerBlockElectra); + constants.put("targetBlobsPerBlockElectra", targetBlobsPerBlockElectra); + constants.put("maxRequestBlobSidecarsElectra", maxRequestBlobSidecarsElectra); + constants.put("blobSidecarSubnetCountElectra", blobSidecarSubnetCountElectra); + + return constants; + } + + @Override + public void addOverridableItemsToRawConfig(final BiConsumer rawConfig) { + rawConfig.accept("ELECTRA_FORK_EPOCH", electraForkEpoch); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/ForkConfigBuilder.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/ForkConfigBuilder.java index d811492d378..52e8bfe5be2 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/ForkConfigBuilder.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/ForkConfigBuilder.java @@ -19,10 +19,11 @@ import java.util.Optional; import java.util.function.BiConsumer; import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.config.SpecConfigAndParent; interface ForkConfigBuilder { - ForkType build(ParentType specConfig); + SpecConfigAndParent build(SpecConfigAndParent specConfigAndParent); void validate(); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/FuluBuilder.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/FuluBuilder.java new file mode 100644 index 00000000000..05a1299d677 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/FuluBuilder.java @@ -0,0 +1,86 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.config.builder; + +import static com.google.common.base.Preconditions.checkNotNull; +import static tech.pegasys.teku.spec.config.SpecConfig.FAR_FUTURE_EPOCH; + +import java.util.HashMap; +import java.util.Map; +import java.util.function.BiConsumer; +import tech.pegasys.teku.infrastructure.bytes.Bytes4; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.config.SpecConfigAndParent; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.config.SpecConfigFulu; +import tech.pegasys.teku.spec.config.SpecConfigFuluImpl; + +public class FuluBuilder implements ForkConfigBuilder { + + private Bytes4 fuluForkVersion; + private UInt64 fuluForkEpoch; + + FuluBuilder() {} + + @Override + public SpecConfigAndParent build( + final SpecConfigAndParent specConfigAndParent) { + return SpecConfigAndParent.of( + new SpecConfigFuluImpl(specConfigAndParent.specConfig(), fuluForkVersion, fuluForkEpoch), + specConfigAndParent); + } + + public FuluBuilder fuluForkEpoch(final UInt64 fuluForkEpoch) { + checkNotNull(fuluForkEpoch); + this.fuluForkEpoch = fuluForkEpoch; + return this; + } + + public FuluBuilder fuluForkVersion(final Bytes4 fuluForkVersion) { + checkNotNull(fuluForkVersion); + this.fuluForkVersion = fuluForkVersion; + return this; + } + + @Override + public void validate() { + if (fuluForkEpoch == null) { + fuluForkEpoch = SpecConfig.FAR_FUTURE_EPOCH; + fuluForkVersion = SpecBuilderUtil.PLACEHOLDER_FORK_VERSION; + } + + // Fill default zeros if fork is unsupported + if (fuluForkEpoch.equals(FAR_FUTURE_EPOCH)) { + SpecBuilderUtil.fillMissingValuesWithZeros(this); + } + + validateConstants(); + } + + @Override + public Map getValidationMap() { + final Map constants = new HashMap<>(); + + constants.put("fuluForkEpoch", fuluForkEpoch); + constants.put("fuluForkVersion", fuluForkVersion); + + return constants; + } + + @Override + public void addOverridableItemsToRawConfig(final BiConsumer rawConfig) { + rawConfig.accept("FULU_FORK_EPOCH", fuluForkEpoch); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/SpecConfigBuilder.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/SpecConfigBuilder.java index 868ea7df9e1..c5298b8d7e0 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/SpecConfigBuilder.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/builder/SpecConfigBuilder.java @@ -28,7 +28,8 @@ import tech.pegasys.teku.infrastructure.bytes.Bytes4; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.config.SpecConfig; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.SpecConfigAndParent; +import tech.pegasys.teku.spec.config.SpecConfigFulu; import tech.pegasys.teku.spec.config.SpecConfigPhase0; @SuppressWarnings({"UnusedReturnValue", "unused"}) @@ -130,14 +131,17 @@ public class SpecConfigBuilder { private Integer reorgParentWeightThreshold = 160; - private final BuilderChain builderChain = + private UInt64 maxPerEpochActivationExitChurnLimit = UInt64.valueOf(256000000000L); + private final BuilderChain builderChain = BuilderChain.create(new AltairBuilder()) .appendBuilder(new BellatrixBuilder()) .appendBuilder(new CapellaBuilder()) .appendBuilder(new DenebBuilder()) - .appendBuilder(new Eip7594Builder()); + .appendBuilder(new ElectraBuilder()) + .appendBuilder(new Eip7594Builder()) + .appendBuilder(new FuluBuilder()); - public SpecConfig build() { + public SpecConfigAndParent build() { builderChain.addOverridableItemsToRawConfig( (key, value) -> { if (value != null) { @@ -145,76 +149,78 @@ public SpecConfig build() { } }); validate(); - final SpecConfig config = - new SpecConfigPhase0( - rawConfig, - eth1FollowDistance, - maxCommitteesPerSlot, - targetCommitteeSize, - maxValidatorsPerCommittee, - minPerEpochChurnLimit, - churnLimitQuotient, - shuffleRoundCount, - minGenesisActiveValidatorCount, - minGenesisTime, - hysteresisQuotient, - hysteresisDownwardMultiplier, - hysteresisUpwardMultiplier, - proportionalSlashingMultiplier, - minDepositAmount, - maxEffectiveBalance, - ejectionBalance, - effectiveBalanceIncrement, - genesisForkVersion, - genesisDelay, - secondsPerSlot, - minAttestationInclusionDelay, - slotsPerEpoch, - minSeedLookahead, - maxSeedLookahead, - minEpochsToInactivityPenalty, - epochsPerEth1VotingPeriod, - slotsPerHistoricalRoot, - minValidatorWithdrawabilityDelay, - shardCommitteePeriod, - epochsPerHistoricalVector, - epochsPerSlashingsVector, - historicalRootsLimit, - validatorRegistryLimit, - baseRewardFactor, - whistleblowerRewardQuotient, - proposerRewardQuotient, - inactivityPenaltyQuotient, - minSlashingPenaltyQuotient, - maxProposerSlashings, - maxAttesterSlashings, - maxAttestations, - maxDeposits, - maxVoluntaryExits, - secondsPerEth1Block, - safeSlotsToUpdateJustified, - proposerScoreBoost, - depositChainId, - depositNetworkId, - depositContractAddress, - gossipMaxSize, - maxChunkSize, - maxRequestBlocks, - epochsPerSubnetSubscription, - minEpochsForBlockRequests, - ttfbTimeout, - respTimeout, - attestationPropagationSlotRange, - maximumGossipClockDisparity, - messageDomainInvalidSnappy, - messageDomainValidSnappy, - subnetsPerNode, - attestationSubnetCount, - attestationSubnetExtraBits, - attestationSubnetPrefixBits, - reorgMaxEpochsSinceFinalization, - reorgHeadWeightThreshold, - reorgParentWeightThreshold); + final SpecConfigAndParent config = + SpecConfigAndParent.of( + new SpecConfigPhase0( + rawConfig, + eth1FollowDistance, + maxCommitteesPerSlot, + targetCommitteeSize, + maxValidatorsPerCommittee, + minPerEpochChurnLimit, + churnLimitQuotient, + shuffleRoundCount, + minGenesisActiveValidatorCount, + minGenesisTime, + hysteresisQuotient, + hysteresisDownwardMultiplier, + hysteresisUpwardMultiplier, + proportionalSlashingMultiplier, + minDepositAmount, + maxEffectiveBalance, + ejectionBalance, + effectiveBalanceIncrement, + genesisForkVersion, + genesisDelay, + secondsPerSlot, + minAttestationInclusionDelay, + slotsPerEpoch, + minSeedLookahead, + maxSeedLookahead, + minEpochsToInactivityPenalty, + epochsPerEth1VotingPeriod, + slotsPerHistoricalRoot, + minValidatorWithdrawabilityDelay, + shardCommitteePeriod, + epochsPerHistoricalVector, + epochsPerSlashingsVector, + historicalRootsLimit, + validatorRegistryLimit, + baseRewardFactor, + whistleblowerRewardQuotient, + proposerRewardQuotient, + inactivityPenaltyQuotient, + minSlashingPenaltyQuotient, + maxProposerSlashings, + maxAttesterSlashings, + maxAttestations, + maxDeposits, + maxVoluntaryExits, + secondsPerEth1Block, + safeSlotsToUpdateJustified, + proposerScoreBoost, + depositChainId, + depositNetworkId, + depositContractAddress, + gossipMaxSize, + maxChunkSize, + maxRequestBlocks, + epochsPerSubnetSubscription, + minEpochsForBlockRequests, + ttfbTimeout, + respTimeout, + attestationPropagationSlotRange, + maximumGossipClockDisparity, + messageDomainInvalidSnappy, + messageDomainValidSnappy, + subnetsPerNode, + attestationSubnetCount, + attestationSubnetExtraBits, + attestationSubnetPrefixBits, + reorgMaxEpochsSinceFinalization, + reorgHeadWeightThreshold, + reorgParentWeightThreshold, + maxPerEpochActivationExitChurnLimit)); return builderChain.build(config); } @@ -537,6 +543,13 @@ public SpecConfigBuilder proposerRewardQuotient(final UInt64 proposerRewardQuoti return this; } + public SpecConfigBuilder maxPerEpochActivationExitChurnLimit( + final UInt64 maxPerEpochActivationExitChurnLimit) { + checkNotNull(maxPerEpochActivationExitChurnLimit); + this.maxPerEpochActivationExitChurnLimit = maxPerEpochActivationExitChurnLimit; + return this; + } + public SpecConfigBuilder inactivityPenaltyQuotient(final UInt64 inactivityPenaltyQuotient) { checkNotNull(inactivityPenaltyQuotient); this.inactivityPenaltyQuotient = inactivityPenaltyQuotient; @@ -727,8 +740,18 @@ public SpecConfigBuilder denebBuilder(final Consumer consumer) { return this; } + public SpecConfigBuilder electraBuilder(final Consumer consumer) { + builderChain.withBuilder(ElectraBuilder.class, consumer); + return this; + } + public SpecConfigBuilder eip7594Builder(final Consumer consumer) { builderChain.withBuilder(Eip7594Builder.class, consumer); return this; } + + public SpecConfigBuilder fuluBuilder(final Consumer consumer) { + builderChain.withBuilder(FuluBuilder.class, consumer); + return this; + } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigEip7594.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/features/Eip7594.java similarity index 65% rename from ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigEip7594.java rename to ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/features/Eip7594.java index 8556136b425..67e2e32afd8 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigEip7594.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/features/Eip7594.java @@ -11,27 +11,24 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.spec.config; +package tech.pegasys.teku.spec.config.features; -import java.util.Optional; -import tech.pegasys.teku.infrastructure.bytes.Bytes4; import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.config.SpecConfig; -public interface SpecConfigEip7594 extends SpecConfigDeneb, NetworkingSpecConfigEip7594 { +public interface Eip7594 { - static SpecConfigEip7594 required(final SpecConfig specConfig) { + static Eip7594 required(final SpecConfig specConfig) { return specConfig - .toVersionEip7594() + .getOptionalEip7594Config() .orElseThrow( () -> new IllegalArgumentException( - "Expected EIP7594 spec config but got: " + "Expected spec config with EIP7594 feature but got: " + specConfig.getClass().getSimpleName())); } - Bytes4 getEip7594ForkVersion(); - - UInt64 getEip7594ForkEpoch(); + UInt64 getEip7594FeatureEpoch(); UInt64 getFieldElementsPerCell(); @@ -42,6 +39,14 @@ static SpecConfigEip7594 required(final SpecConfig specConfig) { int getNumberOfColumns(); - @Override - Optional toVersionEip7594(); + // networking + int getDataColumnSidecarSubnetCount(); + + int getCustodyRequirement(); + + int getSamplesPerSlot(); + + int getMinEpochsForDataColumnSidecarsRequests(); + + int getMaxRequestDataColumnSidecars(); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigEip7594Impl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/features/Eip7594Impl.java similarity index 81% rename from ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigEip7594Impl.java rename to ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/features/Eip7594Impl.java index da24538b84a..389178eebce 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigEip7594Impl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/features/Eip7594Impl.java @@ -11,16 +11,12 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.spec.config; +package tech.pegasys.teku.spec.config.features; import java.util.Objects; -import java.util.Optional; -import tech.pegasys.teku.infrastructure.bytes.Bytes4; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -public class SpecConfigEip7594Impl extends DelegatingSpecConfigDeneb implements SpecConfigEip7594 { - - private final Bytes4 eip7594ForkVersion; +public class Eip7594Impl implements Eip7594 { private final UInt64 eip7594ForkEpoch; private final int numberOfColumns; @@ -33,9 +29,7 @@ public class SpecConfigEip7594Impl extends DelegatingSpecConfigDeneb implements private final int minEpochsForDataColumnSidecarsRequests; private final int maxRequestDataColumnSidecars; - public SpecConfigEip7594Impl( - final SpecConfigDeneb specConfig, - final Bytes4 eip7594ForkVersion, + public Eip7594Impl( final UInt64 eip7594ForkEpoch, final UInt64 fieldElementsPerCell, final UInt64 fieldElementsPerExtBlob, @@ -46,8 +40,6 @@ public SpecConfigEip7594Impl( final int samplesPerSlot, final int minEpochsForDataColumnSidecarsRequests, final int maxRequestDataColumnSidecars) { - super(specConfig); - this.eip7594ForkVersion = eip7594ForkVersion; this.eip7594ForkEpoch = eip7594ForkEpoch; this.fieldElementsPerCell = fieldElementsPerCell; this.fieldElementsPerExtBlob = fieldElementsPerExtBlob; @@ -61,12 +53,7 @@ public SpecConfigEip7594Impl( } @Override - public Bytes4 getEip7594ForkVersion() { - return eip7594ForkVersion; - } - - @Override - public UInt64 getEip7594ForkEpoch() { + public UInt64 getEip7594FeatureEpoch() { return eip7594ForkEpoch; } @@ -115,11 +102,6 @@ public int getMaxRequestDataColumnSidecars() { return maxRequestDataColumnSidecars; } - @Override - public Optional toVersionEip7594() { - return Optional.of(this); - } - @Override public boolean equals(final Object o) { if (this == o) { @@ -128,10 +110,8 @@ public boolean equals(final Object o) { if (o == null || getClass() != o.getClass()) { return false; } - final SpecConfigEip7594Impl that = (SpecConfigEip7594Impl) o; - return Objects.equals(specConfig, that.specConfig) - && Objects.equals(eip7594ForkVersion, that.eip7594ForkVersion) - && Objects.equals(eip7594ForkEpoch, that.eip7594ForkEpoch) + final Eip7594Impl that = (Eip7594Impl) o; + return Objects.equals(eip7594ForkEpoch, that.eip7594ForkEpoch) && Objects.equals(fieldElementsPerCell, that.fieldElementsPerCell) && Objects.equals(fieldElementsPerExtBlob, that.fieldElementsPerExtBlob) && Objects.equals(kzgCommitmentsInclusionProofDepth, that.kzgCommitmentsInclusionProofDepth) @@ -145,8 +125,6 @@ public boolean equals(final Object o) { @Override public int hashCode() { return Objects.hash( - specConfig, - eip7594ForkVersion, eip7594ForkEpoch, numberOfColumns, dataColumnSidecarSubnetCount, diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/constants/ParticipationFlags.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/constants/ParticipationFlags.java index 4e3570e2b31..1adb0d1f226 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/constants/ParticipationFlags.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/constants/ParticipationFlags.java @@ -25,11 +25,11 @@ public class ParticipationFlags { private static final int ALL_FLAGS = combineFlags(TIMELY_HEAD_FLAG, TIMELY_SOURCE_FLAG, TIMELY_TARGET_FLAG); - public static boolean isTimelyTarget(int value) { + public static boolean isTimelyTarget(final int value) { return checkIfAnyFlagIsSet(value, TIMELY_TARGET_FLAG); } - public static boolean isAnyFlagSet(int value) { + public static boolean isAnyFlagSet(final int value) { return checkIfAnyFlagIsSet(value, ALL_FLAGS); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/constants/WithdrawalPrefixes.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/constants/WithdrawalPrefixes.java index c4d385d5820..d2bd4b0cedd 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/constants/WithdrawalPrefixes.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/constants/WithdrawalPrefixes.java @@ -18,5 +18,7 @@ public class WithdrawalPrefixes { public static final Bytes BLS_WITHDRAWAL_PREFIX = Bytes.fromHexString("0x00"); public static final byte ETH1_ADDRESS_WITHDRAWAL_BYTE = 0x01; + public static final byte COMPOUNDING_WITHDRAWAL_BYTE = 0x02; public static final Bytes ETH1_ADDRESS_WITHDRAWAL_PREFIX = Bytes.of(ETH1_ADDRESS_WITHDRAWAL_BYTE); + public static final Bytes COMPOUNDING_WITHDRAWAL_PREFIX = Bytes.of(COMPOUNDING_WITHDRAWAL_BYTE); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/attestation/ValidatableAttestation.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/attestation/ValidatableAttestation.java index 5b8fe4467b6..04ed1897c58 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/attestation/ValidatableAttestation.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/attestation/ValidatableAttestation.java @@ -13,9 +13,11 @@ package tech.pegasys.teku.spec.datastructures.attestation; +import com.google.common.annotations.VisibleForTesting; import com.google.common.base.MoreObjects; import com.google.common.base.Objects; import com.google.common.base.Suppliers; +import it.unimi.dsi.fastutil.ints.Int2IntMap; import java.util.Collection; import java.util.Optional; import java.util.OptionalInt; @@ -45,12 +47,20 @@ public class ValidatableAttestation { private volatile Optional indexedAttestation = Optional.empty(); private volatile Optional committeeShufflingSeed = Optional.empty(); + private volatile Optional committeesSize = Optional.empty(); public static ValidatableAttestation from(final Spec spec, final Attestation attestation) { return new ValidatableAttestation( spec, attestation, Optional.empty(), OptionalInt.empty(), false); } + @VisibleForTesting + public static ValidatableAttestation from( + final Spec spec, final Attestation attestation, final Int2IntMap committeeSizes) { + return new ValidatableAttestation( + spec, attestation, Optional.empty(), OptionalInt.empty(), false, committeeSizes); + } + public static ValidatableAttestation fromValidator( final Spec spec, final Attestation attestation) { return new ValidatableAttestation( @@ -108,6 +118,22 @@ private ValidatableAttestation( this.producedLocally = producedLocally; } + private ValidatableAttestation( + final Spec spec, + final Attestation attestation, + final Optional aggregateAndProof, + final OptionalInt receivedSubnetId, + final boolean producedLocally, + final Int2IntMap committeeSizes) { + this.spec = spec; + this.maybeAggregate = aggregateAndProof; + this.attestation = attestation; + this.receivedSubnetId = receivedSubnetId; + this.hashTreeRoot = Suppliers.memoize(attestation::hashTreeRoot); + this.producedLocally = producedLocally; + this.committeesSize = Optional.of(committeeSizes); + } + public boolean isProducedLocally() { return producedLocally; } @@ -136,6 +162,10 @@ public Optional getCommitteeShufflingSeed() { return committeeShufflingSeed; } + public Optional getCommitteesSize() { + return committeesSize; + } + public OptionalInt getReceivedSubnetId() { return receivedSubnetId; } @@ -144,11 +174,19 @@ public void setIndexedAttestation(final IndexedAttestation indexedAttestation) { this.indexedAttestation = Optional.of(indexedAttestation); } - public void saveCommitteeShufflingSeed(final BeaconState state) { + public void saveCommitteeShufflingSeedAndCommitteesSize(final BeaconState state) { + saveCommitteeShufflingSeed(state); + // The committees size is only required when the committee_bits field is present in the + // Attestation + if (attestation.requiresCommitteeBits()) { + saveCommitteesSize(state); + } + } + + private void saveCommitteeShufflingSeed(final BeaconState state) { if (committeeShufflingSeed.isPresent()) { return; } - final Bytes32 committeeShufflingSeed = spec.getSeed( state, @@ -157,6 +195,15 @@ public void saveCommitteeShufflingSeed(final BeaconState state) { this.committeeShufflingSeed = Optional.of(committeeShufflingSeed); } + private void saveCommitteesSize(final BeaconState state) { + if (committeesSize.isPresent()) { + return; + } + final Int2IntMap committeesSize = + spec.getBeaconCommitteesSize(state, attestation.getData().getSlot()); + this.committeesSize = Optional.of(committeesSize); + } + public boolean isGossiped() { return gossiped.get(); } @@ -175,7 +222,7 @@ public Attestation getAttestation() { public SignedAggregateAndProof getSignedAggregateAndProof() { return maybeAggregate.orElseThrow( - () -> new UnsupportedOperationException("ValidateableAttestation is not an aggregate.")); + () -> new UnsupportedOperationException("ValidatableAttestation is not an aggregate.")); } public AttestationData getData() { @@ -195,7 +242,7 @@ public Bytes32 hashTreeRoot() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } @@ -224,6 +271,7 @@ public String toString() { .add("isValidIndexedAttestation", isValidIndexedAttestation) .add("indexedAttestation", indexedAttestation) .add("committeeShufflingSeed", committeeShufflingSeed) + .add("committeesSize", committeesSize) .add("receivedSubnetId", receivedSubnetId) .toString(); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/deneb/BlobSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/deneb/BlobSchema.java index 8769d94f7ac..a1fe76bf2ec 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/deneb/BlobSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/deneb/BlobSchema.java @@ -34,7 +34,7 @@ public Blob create(final Bytes bytes) { } @Override - public Blob createFromBackingNode(TreeNode node) { + public Blob createFromBackingNode(final TreeNode node) { return new Blob(this, node); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/deneb/BlobSidecar.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/deneb/BlobSidecar.java index 4c0598462ca..812cfeb2c63 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/deneb/BlobSidecar.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/deneb/BlobSidecar.java @@ -138,4 +138,9 @@ public String toLogString() { getKZGCommitment().toAbbreviatedString(), getKZGProof().toAbbreviatedString()); } + + @Override + public BlobSidecarSchema getSchema() { + return (BlobSidecarSchema) super.getSchema(); + } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/deneb/BlobSidecarSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/deneb/BlobSidecarSchema.java index c75d7b1a6a0..a28d8f4cc20 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/deneb/BlobSidecarSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/deneb/BlobSidecarSchema.java @@ -143,7 +143,7 @@ public static BlobSidecarSchema create( } @Override - public BlobSidecar createFromBackingNode(TreeNode node) { + public BlobSidecar createFromBackingNode(final TreeNode node) { return new BlobSidecar(this, node); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/eip7594/CellSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/eip7594/CellSchema.java index 0135682971d..9709dc9a64f 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/eip7594/CellSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/eip7594/CellSchema.java @@ -17,14 +17,14 @@ import tech.pegasys.teku.infrastructure.ssz.schema.collections.impl.SszByteVectorSchemaImpl; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; import tech.pegasys.teku.spec.config.SpecConfigDeneb; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.features.Eip7594; public class CellSchema extends SszByteVectorSchemaImpl { - public CellSchema(final SpecConfigEip7594 specConfig) { + public CellSchema(final Eip7594 featureConfig) { super( SpecConfigDeneb.BYTES_PER_FIELD_ELEMENT.longValue() - * specConfig.getFieldElementsPerCell().longValue()); + * featureConfig.getFieldElementsPerCell().longValue()); } public Cell create(final Bytes bytes) { @@ -32,7 +32,7 @@ public Cell create(final Bytes bytes) { } @Override - public Cell createFromBackingNode(TreeNode node) { + public Cell createFromBackingNode(final TreeNode node) { return new Cell(this, node); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/eip7594/DataColumn.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/eip7594/DataColumn.java index c6f5b2e80e8..ee9c4061623 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/eip7594/DataColumn.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/eip7594/DataColumn.java @@ -19,7 +19,7 @@ public class DataColumn extends SszListImpl implements SszList { - DataColumn(DataColumnSchema schema, TreeNode node) { + DataColumn(final DataColumnSchema schema, final TreeNode node) { super(schema, node); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/eip7594/DataColumnSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/eip7594/DataColumnSchema.java index 0e104ec375e..d0e1e3df318 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/eip7594/DataColumnSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/eip7594/DataColumnSchema.java @@ -16,12 +16,13 @@ import java.util.List; import tech.pegasys.teku.infrastructure.ssz.schema.impl.AbstractSszListSchema; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.SpecConfigDeneb; +import tech.pegasys.teku.spec.config.features.Eip7594; public class DataColumnSchema extends AbstractSszListSchema { - public DataColumnSchema(final SpecConfigEip7594 specConfig) { - super(new CellSchema(specConfig), specConfig.getMaxBlobCommitmentsPerBlock()); + public DataColumnSchema(final Eip7594 featureConfig, final SpecConfigDeneb specConfigDeneb) { + super(new CellSchema(featureConfig), specConfigDeneb.getMaxBlobCommitmentsPerBlock()); } public DataColumn create(final List cells) { @@ -30,7 +31,7 @@ public DataColumn create(final List cells) { } @Override - public DataColumn createFromBackingNode(TreeNode node) { + public DataColumn createFromBackingNode(final TreeNode node) { return new DataColumn(this, node); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/eip7594/DataColumnSidecarSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/eip7594/DataColumnSidecarSchema.java index 4f72d91b63b..903620dba6d 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/eip7594/DataColumnSidecarSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/eip7594/DataColumnSidecarSchema.java @@ -27,7 +27,8 @@ import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.kzg.KZGCommitment; import tech.pegasys.teku.kzg.KZGProof; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.SpecConfigDeneb; +import tech.pegasys.teku.spec.config.features.Eip7594; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockHeader; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockHeaderSchema; import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; @@ -55,7 +56,8 @@ public class DataColumnSidecarSchema DataColumnSidecarSchema( final SignedBeaconBlockHeaderSchema signedBeaconBlockHeaderSchema, final DataColumnSchema dataColumnSchema, - final SpecConfigEip7594 specConfig) { + final Eip7594 featureConfig, + final SpecConfigDeneb specConfigDeneb) { super( "DataColumnSidecar", namedSchema("index", SszPrimitiveSchemas.UINT64_SCHEMA), @@ -63,16 +65,16 @@ public class DataColumnSidecarSchema namedSchema( FIELD_KZG_COMMITMENTS, SszListSchema.create( - SszKZGCommitmentSchema.INSTANCE, specConfig.getMaxBlobCommitmentsPerBlock())), + SszKZGCommitmentSchema.INSTANCE, specConfigDeneb.getMaxBlobCommitmentsPerBlock())), namedSchema( FIELD_KZG_PROOFS, SszListSchema.create( - SszKZGProofSchema.INSTANCE, specConfig.getMaxBlobCommitmentsPerBlock())), + SszKZGProofSchema.INSTANCE, specConfigDeneb.getMaxBlobCommitmentsPerBlock())), namedSchema(FIELD_SIGNED_BLOCK_HEADER, signedBeaconBlockHeaderSchema), namedSchema( FIELD_KZG_COMMITMENTS_INCLUSION_PROOF, SszBytes32VectorSchema.create( - specConfig.getKzgCommitmentsInclusionProofDepth().intValue()))); + featureConfig.getKzgCommitmentsInclusionProofDepth().intValue()))); } @SuppressWarnings("unchecked") @@ -153,12 +155,14 @@ public DataColumnSidecar create( public static DataColumnSidecarSchema create( final SignedBeaconBlockHeaderSchema signedBeaconBlockHeaderSchema, final DataColumnSchema dataColumnSchema, - final SpecConfigEip7594 specConfig) { - return new DataColumnSidecarSchema(signedBeaconBlockHeaderSchema, dataColumnSchema, specConfig); + final Eip7594 featureConfig, + final SpecConfigDeneb specConfigDeneb) { + return new DataColumnSidecarSchema( + signedBeaconBlockHeaderSchema, dataColumnSchema, featureConfig, specConfigDeneb); } @Override - public DataColumnSidecar createFromBackingNode(TreeNode node) { + public DataColumnSidecar createFromBackingNode(final TreeNode node) { return new DataColumnSidecar(this, node); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/eip7594/MatrixEntrySchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/eip7594/MatrixEntrySchema.java index 2770f2d41e1..50952f9a3eb 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/eip7594/MatrixEntrySchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/eip7594/MatrixEntrySchema.java @@ -60,7 +60,7 @@ public static MatrixEntrySchema create(final CellSchema cellSchema) { } @Override - public MatrixEntry createFromBackingNode(TreeNode node) { + public MatrixEntry createFromBackingNode(final TreeNode node) { return new MatrixEntry(this, node); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/BeaconBlock.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/BeaconBlock.java index 72786f776f9..6dd1281383f 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/BeaconBlock.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/BeaconBlock.java @@ -29,17 +29,17 @@ public class BeaconBlock extends Container5 implements BeaconBlockSummary, BlockContainer { - BeaconBlock(final BeaconBlockSchema type, TreeNode backingNode) { + BeaconBlock(final BeaconBlockSchema type, final TreeNode backingNode) { super(type, backingNode); } public BeaconBlock( - BeaconBlockSchema type, - UInt64 slot, - UInt64 proposerIndex, - Bytes32 parentRoot, - Bytes32 stateRoot, - BeaconBlockBody body) { + final BeaconBlockSchema type, + final UInt64 slot, + final UInt64 proposerIndex, + final Bytes32 parentRoot, + final Bytes32 stateRoot, + final BeaconBlockBody body) { super( type, SszUInt64.of(slot), @@ -64,7 +64,7 @@ public static BeaconBlock fromGenesisState( genesisSchema.getBeaconBlockBodySchema().createEmpty()); } - public BeaconBlock withStateRoot(Bytes32 stateRoot) { + public BeaconBlock withStateRoot(final Bytes32 stateRoot) { return new BeaconBlock( this.getSchema(), getSlot(), getProposerIndex(), getParentRoot(), stateRoot, getBody()); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/BeaconBlockHeader.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/BeaconBlockHeader.java index c481cbd4115..83d15057327 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/BeaconBlockHeader.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/BeaconBlockHeader.java @@ -42,19 +42,23 @@ public BeaconBlockHeaderSchema() { } @Override - public BeaconBlockHeader createFromBackingNode(TreeNode node) { + public BeaconBlockHeader createFromBackingNode(final TreeNode node) { return new BeaconBlockHeader(this, node); } } public static final BeaconBlockHeaderSchema SSZ_SCHEMA = new BeaconBlockHeaderSchema(); - private BeaconBlockHeader(BeaconBlockHeaderSchema type, TreeNode backingNode) { + private BeaconBlockHeader(final BeaconBlockHeaderSchema type, final TreeNode backingNode) { super(type, backingNode); } public BeaconBlockHeader( - UInt64 slot, UInt64 proposerIndex, Bytes32 parentRoot, Bytes32 stateRoot, Bytes32 bodyRoot) { + final UInt64 slot, + final UInt64 proposerIndex, + final Bytes32 parentRoot, + final Bytes32 stateRoot, + final Bytes32 bodyRoot) { super( SSZ_SCHEMA, SszUInt64.of(slot), @@ -64,7 +68,7 @@ public BeaconBlockHeader( SszBytes32.of(bodyRoot)); } - public BeaconBlockHeader(BeaconBlockHeader header) { + public BeaconBlockHeader(final BeaconBlockHeader header) { super(SSZ_SCHEMA, header.getBackingNode()); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/BeaconBlockSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/BeaconBlockSchema.java index 3dd31cc6a36..7bfed57a8de 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/BeaconBlockSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/BeaconBlockSchema.java @@ -43,7 +43,7 @@ public BeaconBlockSchema( } @Override - public BeaconBlock createFromBackingNode(TreeNode node) { + public BeaconBlock createFromBackingNode(final TreeNode node) { return new BeaconBlock(this, node); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/BlockContainer.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/BlockContainer.java index 8a7e6c7f798..f2134b996be 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/BlockContainer.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/BlockContainer.java @@ -14,6 +14,7 @@ package tech.pegasys.teku.spec.datastructures.blocks; import java.util.Optional; +import org.apache.tuweni.bytes.Bytes32; import tech.pegasys.teku.infrastructure.ssz.SszContainer; import tech.pegasys.teku.infrastructure.ssz.SszData; import tech.pegasys.teku.infrastructure.ssz.SszList; @@ -35,6 +36,10 @@ default UInt64 getSlot() { return getBlock().getSlot(); } + default Bytes32 getRoot() { + return getBlock().getRoot(); + } + default Optional> getKzgProofs() { return Optional.empty(); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/Eth1Data.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/Eth1Data.java index 411b94595e2..f4b6e666aa9 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/Eth1Data.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/Eth1Data.java @@ -36,7 +36,7 @@ public Eth1DataSchema() { } @Override - public Eth1Data createFromBackingNode(TreeNode node) { + public Eth1Data createFromBackingNode(final TreeNode node) { return new Eth1Data(this, node); } } @@ -49,11 +49,11 @@ public Eth1Data createFromBackingNode(TreeNode node) { public static final Bytes32 EMPTY_DEPOSIT_ROOT = Bytes32.fromHexString("0xd70a234731285c6804c2a4f56711ddb8c82c99740f207854891028af34e27e5e"); - private Eth1Data(Eth1DataSchema type, TreeNode backingNode) { + private Eth1Data(final Eth1DataSchema type, final TreeNode backingNode) { super(type, backingNode); } - public Eth1Data(Bytes32 depositRoot, UInt64 depositCount, Bytes32 blockHash) { + public Eth1Data(final Bytes32 depositRoot, final UInt64 depositCount, final Bytes32 blockHash) { super( SSZ_SCHEMA, SszBytes32.of(depositRoot), diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/NodeSlot.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/NodeSlot.java index dfc8628a281..7c16ae78858 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/NodeSlot.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/NodeSlot.java @@ -18,7 +18,7 @@ public class NodeSlot { private volatile UInt64 value; - public NodeSlot(UInt64 value) { + public NodeSlot(final UInt64 value) { this.value = value; } @@ -31,7 +31,7 @@ public UInt64 inc() { return value; } - public void setValue(UInt64 value) { + public void setValue(final UInt64 value) { this.value = value; } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/SignedBeaconBlock.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/SignedBeaconBlock.java index 2dd065d1287..7c814014906 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/SignedBeaconBlock.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/SignedBeaconBlock.java @@ -34,7 +34,7 @@ public class SignedBeaconBlock extends Container2 implements BeaconBlockSummary, SignedBlockContainer { - SignedBeaconBlock(SignedBeaconBlockSchema type, TreeNode backingNode) { + SignedBeaconBlock(final SignedBeaconBlockSchema type, final TreeNode backingNode) { super(type, backingNode); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/SignedBeaconBlockHeader.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/SignedBeaconBlockHeader.java index 6516bcfd560..56dac0c8fe1 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/SignedBeaconBlockHeader.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/SignedBeaconBlockHeader.java @@ -24,7 +24,7 @@ public class SignedBeaconBlockHeader public static final SignedBeaconBlockHeaderSchema SSZ_SCHEMA = new SignedBeaconBlockHeaderSchema(); - SignedBeaconBlockHeader(SignedBeaconBlockHeaderSchema type, TreeNode backingNode) { + SignedBeaconBlockHeader(final SignedBeaconBlockHeaderSchema type, final TreeNode backingNode) { super(type, backingNode); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/SignedBeaconBlockHeaderSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/SignedBeaconBlockHeaderSchema.java index fa911dfc78e..c248f252741 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/SignedBeaconBlockHeaderSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/SignedBeaconBlockHeaderSchema.java @@ -29,7 +29,7 @@ public SignedBeaconBlockHeaderSchema() { } @Override - public SignedBeaconBlockHeader createFromBackingNode(TreeNode node) { + public SignedBeaconBlockHeader createFromBackingNode(final TreeNode node) { return new SignedBeaconBlockHeader(this, node); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/SignedBeaconBlockSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/SignedBeaconBlockSchema.java index 38336a9650c..553e27f8e86 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/SignedBeaconBlockSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/SignedBeaconBlockSchema.java @@ -38,7 +38,7 @@ public SignedBeaconBlock create(final BeaconBlock message, final BLSSignature si } @Override - public SignedBeaconBlock createFromBackingNode(TreeNode node) { + public SignedBeaconBlock createFromBackingNode(final TreeNode node) { return new SignedBeaconBlock(this, node); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/SlotAndBlockRoot.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/SlotAndBlockRoot.java index 6b8fee0a1ee..5cf778fec34 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/SlotAndBlockRoot.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/SlotAndBlockRoot.java @@ -64,7 +64,7 @@ public boolean equals(final Object o) { } @Override - public int compareTo(@NotNull SlotAndBlockRoot o) { + public int compareTo(final @NotNull SlotAndBlockRoot o) { return Comparator.comparing(SlotAndBlockRoot::getSlot) .thenComparing(SlotAndBlockRoot::getBlockRoot) .compare(this, o); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/BeaconBlockBody.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/BeaconBlockBody.java index 082b8fa6dbf..369bafe934e 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/BeaconBlockBody.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/BeaconBlockBody.java @@ -28,11 +28,12 @@ import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.capella.BlindedBeaconBlockBodyCapella; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.deneb.BeaconBlockBodyDeneb; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.deneb.BlindedBeaconBlockBodyDeneb; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594.BeaconBlockBodyEip7594; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594.BlindedBeaconBlockBodyEip7594; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra.BeaconBlockBodyElectra; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra.BlindedBeaconBlockBodyElectra; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSummary; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; import tech.pegasys.teku.spec.datastructures.operations.Deposit; @@ -87,6 +88,10 @@ default Optional> getOptionalBlobKzgCommitments() { return Optional.empty(); } + default Optional getOptionalExecutionRequests() { + return Optional.empty(); + } + default boolean isBlinded() { return false; } @@ -118,7 +123,7 @@ default Optional toVersionDeneb() { return Optional.empty(); } - default Optional toVersionEip7594() { + default Optional toVersionElectra() { return Optional.empty(); } @@ -126,7 +131,7 @@ default Optional toBlindedVersionDeneb() { return Optional.empty(); } - default Optional toBlindedVersionEip7594() { + default Optional toBlindedVersionElectra() { return Optional.empty(); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/BeaconBlockBodyBuilder.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/BeaconBlockBodyBuilder.java index abaf77057b9..35dc7eb0c7a 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/BeaconBlockBodyBuilder.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/BeaconBlockBodyBuilder.java @@ -20,6 +20,7 @@ import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.SyncAggregate; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; import tech.pegasys.teku.spec.datastructures.operations.Deposit; @@ -73,5 +74,11 @@ default Boolean supportsKzgCommitments() { BeaconBlockBodyBuilder blobKzgCommitments(SszList blobKzgCommitments); + default boolean supportsExecutionRequests() { + return false; + } + + BeaconBlockBodyBuilder executionRequests(ExecutionRequests executionRequests); + BeaconBlockBody build(); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/BeaconBlockBodySchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/BeaconBlockBodySchema.java index fb1d76fc7cd..00602d42578 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/BeaconBlockBodySchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/BeaconBlockBodySchema.java @@ -22,9 +22,13 @@ import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.BeaconBlockBodySchemaAltair; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.bellatrix.BeaconBlockBodySchemaBellatrix; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.bellatrix.BlindedBeaconBlockBodySchemaBellatrix; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.capella.BeaconBlockBodySchemaCapella; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.capella.BlindedBeaconBlockBodySchemaCapella; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.deneb.BeaconBlockBodySchemaDeneb; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594.BeaconBlockBodySchemaEip7594; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.deneb.BlindedBeaconBlockBodySchemaDeneb; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra.BeaconBlockBodySchemaElectra; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra.BlindedBeaconBlockBodySchemaElectra; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; import tech.pegasys.teku.spec.datastructures.operations.Deposit; @@ -66,7 +70,23 @@ default Optional> toVersionDeneb() { return Optional.empty(); } - default Optional> toVersionEip7594() { + default Optional> toVersionElectra() { + return Optional.empty(); + } + + default Optional> toBlindedVersionBellatrix() { + return Optional.empty(); + } + + default Optional> toBlindedVersionCapella() { + return Optional.empty(); + } + + default Optional> toBlindedVersionDeneb() { + return Optional.empty(); + } + + default Optional> toBlindedVersionElectra() { return Optional.empty(); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/common/AbstractSignedBeaconBlockBlinder.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/common/AbstractSignedBeaconBlockBlinder.java index 33308e24f9e..0f278e7d694 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/common/AbstractSignedBeaconBlockBlinder.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/common/AbstractSignedBeaconBlockBlinder.java @@ -27,7 +27,7 @@ public AbstractSignedBeaconBlockBlinder(final SchemaDefinitions schemaDefinition } @Override - public SignedBeaconBlock blind(SignedBeaconBlock signedUnblindedBlock) { + public SignedBeaconBlock blind(final SignedBeaconBlock signedUnblindedBlock) { final SignedBeaconBlock blindedSignedBeaconBlock = signedUnblindedBlock.blind(schemaDefinitions); checkState( diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/common/BlockBodyFields.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/common/BlockBodyFields.java index a58873a67f1..95608eabd54 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/common/BlockBodyFields.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/common/BlockBodyFields.java @@ -29,7 +29,8 @@ public enum BlockBodyFields implements SszFieldName { EXECUTION_PAYLOAD, EXECUTION_PAYLOAD_HEADER, BLS_TO_EXECUTION_CHANGES, - BLOB_KZG_COMMITMENTS; + BLOB_KZG_COMMITMENTS, + EXECUTION_REQUESTS; private final String sszFieldName; diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/altair/BeaconBlockBodyAltairImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/altair/BeaconBlockBodyAltairImpl.java index a6f5ace04ec..04dbf0b9f91 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/altair/BeaconBlockBodyAltairImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/altair/BeaconBlockBodyAltairImpl.java @@ -43,25 +43,26 @@ public class BeaconBlockBodyAltairImpl SyncAggregate> implements BeaconBlockBodyAltair { - BeaconBlockBodyAltairImpl(BeaconBlockBodySchemaAltairImpl type) { + BeaconBlockBodyAltairImpl(final BeaconBlockBodySchemaAltairImpl type) { super(type); } - BeaconBlockBodyAltairImpl(BeaconBlockBodySchemaAltairImpl type, TreeNode backingNode) { + BeaconBlockBodyAltairImpl( + final BeaconBlockBodySchemaAltairImpl type, final TreeNode backingNode) { super(type, backingNode); } BeaconBlockBodyAltairImpl( - BeaconBlockBodySchemaAltairImpl type, - SszSignature randaoReveal, - Eth1Data eth1Data, - SszBytes32 graffiti, - SszList proposerSlashings, - SszList attesterSlashings, - SszList attestations, - SszList deposits, - SszList voluntaryExits, - SyncAggregate syncAggregate) { + final BeaconBlockBodySchemaAltairImpl type, + final SszSignature randaoReveal, + final Eth1Data eth1Data, + final SszBytes32 graffiti, + final SszList proposerSlashings, + final SszList attesterSlashings, + final SszList attestations, + final SszList deposits, + final SszList voluntaryExits, + final SyncAggregate syncAggregate) { super( type, randaoReveal, diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/altair/BeaconBlockBodySchemaAltairImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/altair/BeaconBlockBodySchemaAltairImpl.java index 30b608c90a5..63248b9cece 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/altair/BeaconBlockBodySchemaAltairImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/altair/BeaconBlockBodySchemaAltairImpl.java @@ -13,6 +13,9 @@ package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.ATTESTATION_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.ATTESTER_SLASHING_SCHEMA; + import it.unimi.dsi.fastutil.longs.LongList; import java.util.function.Function; import tech.pegasys.teku.infrastructure.async.SafeFuture; @@ -28,14 +31,13 @@ import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodyBuilder; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.common.BlockBodyFields; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; -import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing.AttesterSlashingSchema; import tech.pegasys.teku.spec.datastructures.operations.Deposit; import tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing; import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; import tech.pegasys.teku.spec.datastructures.type.SszSignature; import tech.pegasys.teku.spec.datastructures.type.SszSignatureSchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; public class BeaconBlockBodySchemaAltairImpl extends ContainerSchema9< @@ -53,15 +55,15 @@ public class BeaconBlockBodySchemaAltairImpl private BeaconBlockBodySchemaAltairImpl( final String containerName, - NamedSchema randaoRevealSchema, - NamedSchema eth1DataSchema, - NamedSchema graffitiSchema, - NamedSchema> proposerSlashingsSchema, - NamedSchema> attesterSlashingsSchema, - NamedSchema> attestationsSchema, - NamedSchema> depositsSchema, - NamedSchema> voluntaryExitsSchema, - NamedSchema syncAggregateSchema) { + final NamedSchema randaoRevealSchema, + final NamedSchema eth1DataSchema, + final NamedSchema graffitiSchema, + final NamedSchema> proposerSlashingsSchema, + final NamedSchema> attesterSlashingsSchema, + final NamedSchema> attestationsSchema, + final NamedSchema> depositsSchema, + final NamedSchema> voluntaryExitsSchema, + final NamedSchema syncAggregateSchema) { super( containerName, randaoRevealSchema, @@ -77,8 +79,8 @@ private BeaconBlockBodySchemaAltairImpl( public static BeaconBlockBodySchemaAltairImpl create( final SpecConfig specConfig, - final AttesterSlashingSchema attesterSlashingSchema, - final String containerName) { + final String containerName, + final SchemaRegistry schemaRegistry) { return new BeaconBlockBodySchemaAltairImpl( containerName, namedSchema(BlockBodyFields.RANDAO_REVEAL, SszSignatureSchema.INSTANCE), @@ -90,11 +92,13 @@ public static BeaconBlockBodySchemaAltairImpl create( ProposerSlashing.SSZ_SCHEMA, specConfig.getMaxProposerSlashings())), namedSchema( BlockBodyFields.ATTESTER_SLASHINGS, - SszListSchema.create(attesterSlashingSchema, specConfig.getMaxAttesterSlashings())), + SszListSchema.create( + schemaRegistry.get(ATTESTER_SLASHING_SCHEMA), + specConfig.getMaxAttesterSlashings())), namedSchema( BlockBodyFields.ATTESTATIONS, SszListSchema.create( - new AttestationSchema(specConfig), specConfig.getMaxAttestations())), + schemaRegistry.get(ATTESTATION_SCHEMA), specConfig.getMaxAttestations())), namedSchema( BlockBodyFields.DEPOSITS, SszListSchema.create(Deposit.SSZ_SCHEMA, specConfig.getMaxDeposits())), @@ -161,7 +165,7 @@ public SyncAggregateSchema getSyncAggregateSchema() { } @Override - public BeaconBlockBodyAltairImpl createFromBackingNode(TreeNode node) { + public BeaconBlockBodyAltairImpl createFromBackingNode(final TreeNode node) { return new BeaconBlockBodyAltairImpl(this, node); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/bellatrix/BeaconBlockBodyBellatrixImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/bellatrix/BeaconBlockBodyBellatrixImpl.java index 1dc5aa1ae65..b5317d636bb 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/bellatrix/BeaconBlockBodyBellatrixImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/bellatrix/BeaconBlockBodyBellatrixImpl.java @@ -49,26 +49,27 @@ class BeaconBlockBodyBellatrixImpl ExecutionPayloadBellatrix> implements BeaconBlockBodyBellatrix { - BeaconBlockBodyBellatrixImpl(BeaconBlockBodySchemaBellatrixImpl type) { + BeaconBlockBodyBellatrixImpl(final BeaconBlockBodySchemaBellatrixImpl type) { super(type); } - BeaconBlockBodyBellatrixImpl(BeaconBlockBodySchemaBellatrixImpl type, TreeNode backingNode) { + BeaconBlockBodyBellatrixImpl( + final BeaconBlockBodySchemaBellatrixImpl type, final TreeNode backingNode) { super(type, backingNode); } BeaconBlockBodyBellatrixImpl( - BeaconBlockBodySchemaBellatrixImpl type, - SszSignature randaoReveal, - Eth1Data eth1Data, - SszBytes32 graffiti, - SszList proposerSlashings, - SszList attesterSlashings, - SszList attestations, - SszList deposits, - SszList voluntaryExits, - SyncAggregate syncAggregate, - ExecutionPayloadBellatrix executionPayload) { + final BeaconBlockBodySchemaBellatrixImpl type, + final SszSignature randaoReveal, + final Eth1Data eth1Data, + final SszBytes32 graffiti, + final SszList proposerSlashings, + final SszList attesterSlashings, + final SszList attestations, + final SszList deposits, + final SszList voluntaryExits, + final SyncAggregate syncAggregate, + final ExecutionPayloadBellatrix executionPayload) { super( type, randaoReveal, diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/bellatrix/BeaconBlockBodySchemaBellatrixImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/bellatrix/BeaconBlockBodySchemaBellatrixImpl.java index e9bc678e1cb..cbc80a75857 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/bellatrix/BeaconBlockBodySchemaBellatrixImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/bellatrix/BeaconBlockBodySchemaBellatrixImpl.java @@ -13,6 +13,8 @@ package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.bellatrix; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_PAYLOAD_SCHEMA; + import it.unimi.dsi.fastutil.longs.LongList; import java.util.function.Function; import tech.pegasys.teku.infrastructure.async.SafeFuture; @@ -32,16 +34,15 @@ import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.SyncAggregateSchema; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSchema; import tech.pegasys.teku.spec.datastructures.execution.versions.bellatrix.ExecutionPayloadBellatrix; -import tech.pegasys.teku.spec.datastructures.execution.versions.bellatrix.ExecutionPayloadSchemaBellatrix; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; -import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing.AttesterSlashingSchema; import tech.pegasys.teku.spec.datastructures.operations.Deposit; import tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing; import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; import tech.pegasys.teku.spec.datastructures.type.SszSignature; import tech.pegasys.teku.spec.datastructures.type.SszSignatureSchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; +import tech.pegasys.teku.spec.schemas.registry.SchemaTypes; public class BeaconBlockBodySchemaBellatrixImpl extends ContainerSchema10< @@ -60,16 +61,16 @@ public class BeaconBlockBodySchemaBellatrixImpl private BeaconBlockBodySchemaBellatrixImpl( final String containerName, - NamedSchema randaoRevealSchema, - NamedSchema eth1DataSchema, - NamedSchema graffitiSchema, - NamedSchema> proposerSlashingsSchema, - NamedSchema> attesterSlashingsSchema, - NamedSchema> attestationsSchema, - NamedSchema> depositsSchema, - NamedSchema> voluntaryExitsSchema, - NamedSchema syncAggregateSchema, - NamedSchema executionPayloadSchema) { + final NamedSchema randaoRevealSchema, + final NamedSchema eth1DataSchema, + final NamedSchema graffitiSchema, + final NamedSchema> proposerSlashingsSchema, + final NamedSchema> attesterSlashingsSchema, + final NamedSchema> attestationsSchema, + final NamedSchema> depositsSchema, + final NamedSchema> voluntaryExitsSchema, + final NamedSchema syncAggregateSchema, + final NamedSchema executionPayloadSchema) { super( containerName, randaoRevealSchema, @@ -86,10 +87,8 @@ private BeaconBlockBodySchemaBellatrixImpl( public static BeaconBlockBodySchemaBellatrixImpl create( final SpecConfigBellatrix specConfig, - final AttesterSlashingSchema attesterSlashingSchema, - final String containerName) { - final ExecutionPayloadSchemaBellatrix executionPayloadSchemaBellatrix = - new ExecutionPayloadSchemaBellatrix(specConfig); + final String containerName, + final SchemaRegistry schemaRegistry) { return new BeaconBlockBodySchemaBellatrixImpl( containerName, namedSchema(BlockBodyFields.RANDAO_REVEAL, SszSignatureSchema.INSTANCE), @@ -101,11 +100,14 @@ public static BeaconBlockBodySchemaBellatrixImpl create( ProposerSlashing.SSZ_SCHEMA, specConfig.getMaxProposerSlashings())), namedSchema( BlockBodyFields.ATTESTER_SLASHINGS, - SszListSchema.create(attesterSlashingSchema, specConfig.getMaxAttesterSlashings())), + SszListSchema.create( + schemaRegistry.get(SchemaTypes.ATTESTER_SLASHING_SCHEMA), + specConfig.getMaxAttesterSlashings())), namedSchema( BlockBodyFields.ATTESTATIONS, SszListSchema.create( - new AttestationSchema(specConfig), specConfig.getMaxAttestations())), + schemaRegistry.get(SchemaTypes.ATTESTATION_SCHEMA), + specConfig.getMaxAttestations())), namedSchema( BlockBodyFields.DEPOSITS, SszListSchema.create(Deposit.SSZ_SCHEMA, specConfig.getMaxDeposits())), @@ -116,7 +118,9 @@ public static BeaconBlockBodySchemaBellatrixImpl create( namedSchema( BlockBodyFields.SYNC_AGGREGATE, SyncAggregateSchema.create(specConfig.getSyncCommitteeSize())), - namedSchema(BlockBodyFields.EXECUTION_PAYLOAD, executionPayloadSchemaBellatrix)); + namedSchema( + BlockBodyFields.EXECUTION_PAYLOAD, + schemaRegistry.get(EXECUTION_PAYLOAD_SCHEMA).toVersionBellatrixRequired())); } @Override @@ -167,7 +171,7 @@ public SyncAggregateSchema getSyncAggregateSchema() { } @Override - public BeaconBlockBodyBellatrixImpl createFromBackingNode(TreeNode node) { + public BeaconBlockBodyBellatrixImpl createFromBackingNode(final TreeNode node) { return new BeaconBlockBodyBellatrixImpl(this, node); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/bellatrix/BlindedBeaconBlockBodyBellatrixImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/bellatrix/BlindedBeaconBlockBodyBellatrixImpl.java index c6c86ffb6bb..7da09fe4064 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/bellatrix/BlindedBeaconBlockBodyBellatrixImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/bellatrix/BlindedBeaconBlockBodyBellatrixImpl.java @@ -49,27 +49,27 @@ class BlindedBeaconBlockBodyBellatrixImpl ExecutionPayloadHeaderBellatrix> implements BlindedBeaconBlockBodyBellatrix { - BlindedBeaconBlockBodyBellatrixImpl(BlindedBeaconBlockBodySchemaBellatrixImpl type) { + BlindedBeaconBlockBodyBellatrixImpl(final BlindedBeaconBlockBodySchemaBellatrixImpl type) { super(type); } BlindedBeaconBlockBodyBellatrixImpl( - BlindedBeaconBlockBodySchemaBellatrixImpl type, TreeNode backingNode) { + final BlindedBeaconBlockBodySchemaBellatrixImpl type, final TreeNode backingNode) { super(type, backingNode); } BlindedBeaconBlockBodyBellatrixImpl( - BlindedBeaconBlockBodySchemaBellatrixImpl type, - SszSignature randaoReveal, - Eth1Data eth1Data, - SszBytes32 graffiti, - SszList proposerSlashings, - SszList attesterSlashings, - SszList attestations, - SszList deposits, - SszList voluntaryExits, - SyncAggregate syncAggregate, - ExecutionPayloadHeaderBellatrix executionPayloadHeader) { + final BlindedBeaconBlockBodySchemaBellatrixImpl type, + final SszSignature randaoReveal, + final Eth1Data eth1Data, + final SszBytes32 graffiti, + final SszList proposerSlashings, + final SszList attesterSlashings, + final SszList attestations, + final SszList deposits, + final SszList voluntaryExits, + final SyncAggregate syncAggregate, + final ExecutionPayloadHeaderBellatrix executionPayloadHeader) { super( type, randaoReveal, diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/bellatrix/BlindedBeaconBlockBodySchemaBellatrixImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/bellatrix/BlindedBeaconBlockBodySchemaBellatrixImpl.java index 58d72b33fd2..32e9ef2bae6 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/bellatrix/BlindedBeaconBlockBodySchemaBellatrixImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/bellatrix/BlindedBeaconBlockBodySchemaBellatrixImpl.java @@ -13,7 +13,12 @@ package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.bellatrix; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.ATTESTATION_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.ATTESTER_SLASHING_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_PAYLOAD_HEADER_SCHEMA; + import it.unimi.dsi.fastutil.longs.LongList; +import java.util.Optional; import java.util.function.Function; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.ssz.SszList; @@ -33,14 +38,13 @@ import tech.pegasys.teku.spec.datastructures.execution.versions.bellatrix.ExecutionPayloadHeaderBellatrix; import tech.pegasys.teku.spec.datastructures.execution.versions.bellatrix.ExecutionPayloadHeaderSchemaBellatrix; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; -import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing.AttesterSlashingSchema; import tech.pegasys.teku.spec.datastructures.operations.Deposit; import tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing; import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; import tech.pegasys.teku.spec.datastructures.type.SszSignature; import tech.pegasys.teku.spec.datastructures.type.SszSignatureSchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; public class BlindedBeaconBlockBodySchemaBellatrixImpl extends ContainerSchema10< @@ -59,16 +63,16 @@ public class BlindedBeaconBlockBodySchemaBellatrixImpl private BlindedBeaconBlockBodySchemaBellatrixImpl( final String containerName, - NamedSchema randaoRevealSchema, - NamedSchema eth1DataSchema, - NamedSchema graffitiSchema, - NamedSchema> proposerSlashingsSchema, - NamedSchema> attesterSlashingsSchema, - NamedSchema> attestationsSchema, - NamedSchema> depositsSchema, - NamedSchema> voluntaryExitsSchema, - NamedSchema syncAggregateSchema, - NamedSchema executionPayloadHeaderSchema) { + final NamedSchema randaoRevealSchema, + final NamedSchema eth1DataSchema, + final NamedSchema graffitiSchema, + final NamedSchema> proposerSlashingsSchema, + final NamedSchema> attesterSlashingsSchema, + final NamedSchema> attestationsSchema, + final NamedSchema> depositsSchema, + final NamedSchema> voluntaryExitsSchema, + final NamedSchema syncAggregateSchema, + final NamedSchema executionPayloadHeaderSchema) { super( containerName, randaoRevealSchema, @@ -85,9 +89,8 @@ private BlindedBeaconBlockBodySchemaBellatrixImpl( public static BlindedBeaconBlockBodySchemaBellatrixImpl create( final SpecConfigBellatrix specConfig, - final AttesterSlashingSchema attesterSlashingSchema, final String containerName, - final ExecutionPayloadHeaderSchemaBellatrix executionPayloadHeaderSchema) { + final SchemaRegistry schemaRegistry) { return new BlindedBeaconBlockBodySchemaBellatrixImpl( containerName, namedSchema(BlockBodyFields.RANDAO_REVEAL, SszSignatureSchema.INSTANCE), @@ -99,11 +102,13 @@ public static BlindedBeaconBlockBodySchemaBellatrixImpl create( ProposerSlashing.SSZ_SCHEMA, specConfig.getMaxProposerSlashings())), namedSchema( BlockBodyFields.ATTESTER_SLASHINGS, - SszListSchema.create(attesterSlashingSchema, specConfig.getMaxAttesterSlashings())), + SszListSchema.create( + schemaRegistry.get(ATTESTER_SLASHING_SCHEMA), + specConfig.getMaxAttesterSlashings())), namedSchema( BlockBodyFields.ATTESTATIONS, SszListSchema.create( - new AttestationSchema(specConfig), specConfig.getMaxAttestations())), + schemaRegistry.get(ATTESTATION_SCHEMA), specConfig.getMaxAttestations())), namedSchema( BlockBodyFields.DEPOSITS, SszListSchema.create(Deposit.SSZ_SCHEMA, specConfig.getMaxDeposits())), @@ -114,7 +119,9 @@ public static BlindedBeaconBlockBodySchemaBellatrixImpl create( namedSchema( BlockBodyFields.SYNC_AGGREGATE, SyncAggregateSchema.create(specConfig.getSyncCommitteeSize())), - namedSchema(BlockBodyFields.EXECUTION_PAYLOAD_HEADER, executionPayloadHeaderSchema)); + namedSchema( + BlockBodyFields.EXECUTION_PAYLOAD_HEADER, + schemaRegistry.get(EXECUTION_PAYLOAD_HEADER_SCHEMA).toVersionBellatrixRequired())); } @Override @@ -165,7 +172,7 @@ public SyncAggregateSchema getSyncAggregateSchema() { } @Override - public BlindedBeaconBlockBodyBellatrixImpl createFromBackingNode(TreeNode node) { + public BlindedBeaconBlockBodyBellatrixImpl createFromBackingNode(final TreeNode node) { return new BlindedBeaconBlockBodyBellatrixImpl(this, node); } @@ -174,6 +181,11 @@ public ExecutionPayloadHeaderSchemaBellatrix getExecutionPayloadHeaderSchema() { return (ExecutionPayloadHeaderSchemaBellatrix) getFieldSchema9(); } + @Override + public Optional> toBlindedVersionBellatrix() { + return Optional.of(this); + } + @Override public LongList getBlindedNodeGeneralizedIndices() { return GIndexUtil.gIdxComposeAll( diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/bellatrix/SignedBeaconBlockUnblinderBellatrix.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/bellatrix/SignedBeaconBlockUnblinderBellatrix.java index b1f147c6b37..41dfb389e80 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/bellatrix/SignedBeaconBlockUnblinderBellatrix.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/bellatrix/SignedBeaconBlockUnblinderBellatrix.java @@ -34,7 +34,7 @@ public SignedBeaconBlockUnblinderBellatrix( @Override public void setExecutionPayloadSupplier( - Supplier> executionPayloadSupplier) { + final Supplier> executionPayloadSupplier) { this.executionPayloadFuture = executionPayloadSupplier.get(); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/capella/BeaconBlockBodyCapellaImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/capella/BeaconBlockBodyCapellaImpl.java index 9af1dc313bf..2062748cd9e 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/capella/BeaconBlockBodyCapellaImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/capella/BeaconBlockBodyCapellaImpl.java @@ -48,18 +48,18 @@ public class BeaconBlockBodyCapellaImpl implements BeaconBlockBodyCapella { BeaconBlockBodyCapellaImpl( - BeaconBlockBodySchemaCapellaImpl type, - SszSignature randaoReveal, - Eth1Data eth1Data, - SszBytes32 graffiti, - SszList proposerSlashings, - SszList attesterSlashings, - SszList attestations, - SszList deposits, - SszList voluntaryExits, - SyncAggregate syncAggregate, - ExecutionPayloadCapellaImpl executionPayload, - SszList blsToExecutionChanges) { + final BeaconBlockBodySchemaCapellaImpl type, + final SszSignature randaoReveal, + final Eth1Data eth1Data, + final SszBytes32 graffiti, + final SszList proposerSlashings, + final SszList attesterSlashings, + final SszList attestations, + final SszList deposits, + final SszList voluntaryExits, + final SyncAggregate syncAggregate, + final ExecutionPayloadCapellaImpl executionPayload, + final SszList blsToExecutionChanges) { super( type, randaoReveal, @@ -75,11 +75,12 @@ public class BeaconBlockBodyCapellaImpl blsToExecutionChanges); } - BeaconBlockBodyCapellaImpl(BeaconBlockBodySchemaCapellaImpl type) { + BeaconBlockBodyCapellaImpl(final BeaconBlockBodySchemaCapellaImpl type) { super(type); } - BeaconBlockBodyCapellaImpl(BeaconBlockBodySchemaCapellaImpl type, TreeNode backingNode) { + BeaconBlockBodyCapellaImpl( + final BeaconBlockBodySchemaCapellaImpl type, final TreeNode backingNode) { super(type, backingNode); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/capella/BeaconBlockBodySchemaCapellaImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/capella/BeaconBlockBodySchemaCapellaImpl.java index 16081288231..647bfb08c48 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/capella/BeaconBlockBodySchemaCapellaImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/capella/BeaconBlockBodySchemaCapellaImpl.java @@ -13,6 +13,10 @@ package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.capella; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.ATTESTATION_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_PAYLOAD_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SIGNED_BLS_TO_EXECUTION_CHANGE_SCHEMA; + import it.unimi.dsi.fastutil.longs.LongList; import java.util.function.Function; import tech.pegasys.teku.infrastructure.async.SafeFuture; @@ -32,18 +36,16 @@ import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.SyncAggregateSchema; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSchema; import tech.pegasys.teku.spec.datastructures.execution.versions.capella.ExecutionPayloadCapellaImpl; -import tech.pegasys.teku.spec.datastructures.execution.versions.capella.ExecutionPayloadSchemaCapella; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; -import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing.AttesterSlashingSchema; import tech.pegasys.teku.spec.datastructures.operations.Deposit; import tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing; import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChange; -import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChangeSchema; import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; import tech.pegasys.teku.spec.datastructures.type.SszSignature; import tech.pegasys.teku.spec.datastructures.type.SszSignatureSchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; +import tech.pegasys.teku.spec.schemas.registry.SchemaTypes; public class BeaconBlockBodySchemaCapellaImpl extends ContainerSchema11< @@ -91,9 +93,8 @@ protected BeaconBlockBodySchemaCapellaImpl( public static BeaconBlockBodySchemaCapellaImpl create( final SpecConfigCapella specConfig, - final AttesterSlashingSchema attesterSlashingSchema, - final SignedBlsToExecutionChangeSchema blsToExecutionChangeSchema, - final String containerName) { + final String containerName, + final SchemaRegistry schemaRegistry) { return new BeaconBlockBodySchemaCapellaImpl( containerName, namedSchema(BlockBodyFields.RANDAO_REVEAL, SszSignatureSchema.INSTANCE), @@ -105,11 +106,13 @@ public static BeaconBlockBodySchemaCapellaImpl create( ProposerSlashing.SSZ_SCHEMA, specConfig.getMaxProposerSlashings())), namedSchema( BlockBodyFields.ATTESTER_SLASHINGS, - SszListSchema.create(attesterSlashingSchema, specConfig.getMaxAttesterSlashings())), + SszListSchema.create( + schemaRegistry.get(SchemaTypes.ATTESTER_SLASHING_SCHEMA), + specConfig.getMaxAttesterSlashings())), namedSchema( BlockBodyFields.ATTESTATIONS, SszListSchema.create( - new AttestationSchema(specConfig), specConfig.getMaxAttestations())), + schemaRegistry.get(ATTESTATION_SCHEMA), specConfig.getMaxAttestations())), namedSchema( BlockBodyFields.DEPOSITS, SszListSchema.create(Deposit.SSZ_SCHEMA, specConfig.getMaxDeposits())), @@ -121,11 +124,13 @@ public static BeaconBlockBodySchemaCapellaImpl create( BlockBodyFields.SYNC_AGGREGATE, SyncAggregateSchema.create(specConfig.getSyncCommitteeSize())), namedSchema( - BlockBodyFields.EXECUTION_PAYLOAD, new ExecutionPayloadSchemaCapella(specConfig)), + BlockBodyFields.EXECUTION_PAYLOAD, + schemaRegistry.get(EXECUTION_PAYLOAD_SCHEMA).toVersionCapellaRequired()), namedSchema( BlockBodyFields.BLS_TO_EXECUTION_CHANGES, SszListSchema.create( - blsToExecutionChangeSchema, specConfig.getMaxBlsToExecutionChanges()))); + schemaRegistry.get(SIGNED_BLS_TO_EXECUTION_CHANGE_SCHEMA), + specConfig.getMaxBlsToExecutionChanges()))); } @Override @@ -176,7 +181,7 @@ public SyncAggregateSchema getSyncAggregateSchema() { } @Override - public BeaconBlockBodyCapellaImpl createFromBackingNode(TreeNode node) { + public BeaconBlockBodyCapellaImpl createFromBackingNode(final TreeNode node) { return new BeaconBlockBodyCapellaImpl(this, node); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/capella/BlindedBeaconBlockBodyCapellaImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/capella/BlindedBeaconBlockBodyCapellaImpl.java index ee42e7e530b..6bfc79fd536 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/capella/BlindedBeaconBlockBodyCapellaImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/capella/BlindedBeaconBlockBodyCapellaImpl.java @@ -50,12 +50,12 @@ class BlindedBeaconBlockBodyCapellaImpl SszList> implements BlindedBeaconBlockBodyCapella { - BlindedBeaconBlockBodyCapellaImpl(BlindedBeaconBlockBodySchemaCapellaImpl type) { + BlindedBeaconBlockBodyCapellaImpl(final BlindedBeaconBlockBodySchemaCapellaImpl type) { super(type); } BlindedBeaconBlockBodyCapellaImpl( - BlindedBeaconBlockBodySchemaCapellaImpl type, TreeNode backingNode) { + final BlindedBeaconBlockBodySchemaCapellaImpl type, final TreeNode backingNode) { super(type, backingNode); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/capella/BlindedBeaconBlockBodySchemaCapellaImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/capella/BlindedBeaconBlockBodySchemaCapellaImpl.java index 1b8e2e39ac4..41a665a8373 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/capella/BlindedBeaconBlockBodySchemaCapellaImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/capella/BlindedBeaconBlockBodySchemaCapellaImpl.java @@ -13,7 +13,13 @@ package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.capella; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.ATTESTATION_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.ATTESTER_SLASHING_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_PAYLOAD_HEADER_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SIGNED_BLS_TO_EXECUTION_CHANGE_SCHEMA; + import it.unimi.dsi.fastutil.longs.LongList; +import java.util.Optional; import java.util.function.Function; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.ssz.SszList; @@ -33,16 +39,14 @@ import tech.pegasys.teku.spec.datastructures.execution.versions.capella.ExecutionPayloadHeaderCapellaImpl; import tech.pegasys.teku.spec.datastructures.execution.versions.capella.ExecutionPayloadHeaderSchemaCapella; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; -import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing.AttesterSlashingSchema; import tech.pegasys.teku.spec.datastructures.operations.Deposit; import tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing; import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChange; -import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChangeSchema; import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; import tech.pegasys.teku.spec.datastructures.type.SszSignature; import tech.pegasys.teku.spec.datastructures.type.SszSignatureSchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; public class BlindedBeaconBlockBodySchemaCapellaImpl extends ContainerSchema11< @@ -62,17 +66,17 @@ public class BlindedBeaconBlockBodySchemaCapellaImpl private BlindedBeaconBlockBodySchemaCapellaImpl( final String containerName, - NamedSchema randaoReveal, - NamedSchema eth1Data, - NamedSchema graffiti, - NamedSchema> proposerSlashings, - NamedSchema> attesterSlashings, - NamedSchema> attestations, - NamedSchema> deposits, - NamedSchema> voluntaryExits, - NamedSchema syncAggregate, - NamedSchema executionPayloadHeader, - NamedSchema> blsToExecutionChanges) { + final NamedSchema randaoReveal, + final NamedSchema eth1Data, + final NamedSchema graffiti, + final NamedSchema> proposerSlashings, + final NamedSchema> attesterSlashings, + final NamedSchema> attestations, + final NamedSchema> deposits, + final NamedSchema> voluntaryExits, + final NamedSchema syncAggregate, + final NamedSchema executionPayloadHeader, + final NamedSchema> blsToExecutionChanges) { super( containerName, randaoReveal, @@ -90,9 +94,8 @@ private BlindedBeaconBlockBodySchemaCapellaImpl( public static BlindedBeaconBlockBodySchemaCapellaImpl create( final SpecConfigCapella specConfig, - final AttesterSlashingSchema attesterSlashingSchema, - final SignedBlsToExecutionChangeSchema signedBlsToExecutionChangeSchema, - final String containerName) { + final String containerName, + final SchemaRegistry schemaRegistry) { return new BlindedBeaconBlockBodySchemaCapellaImpl( containerName, namedSchema(BlockBodyFields.RANDAO_REVEAL, SszSignatureSchema.INSTANCE), @@ -104,11 +107,13 @@ public static BlindedBeaconBlockBodySchemaCapellaImpl create( ProposerSlashing.SSZ_SCHEMA, specConfig.getMaxProposerSlashings())), namedSchema( BlockBodyFields.ATTESTER_SLASHINGS, - SszListSchema.create(attesterSlashingSchema, specConfig.getMaxAttesterSlashings())), + SszListSchema.create( + schemaRegistry.get(ATTESTER_SLASHING_SCHEMA), + specConfig.getMaxAttesterSlashings())), namedSchema( BlockBodyFields.ATTESTATIONS, SszListSchema.create( - new AttestationSchema(specConfig), specConfig.getMaxAttestations())), + schemaRegistry.get(ATTESTATION_SCHEMA), specConfig.getMaxAttestations())), namedSchema( BlockBodyFields.DEPOSITS, SszListSchema.create(Deposit.SSZ_SCHEMA, specConfig.getMaxDeposits())), @@ -121,11 +126,12 @@ public static BlindedBeaconBlockBodySchemaCapellaImpl create( SyncAggregateSchema.create(specConfig.getSyncCommitteeSize())), namedSchema( BlockBodyFields.EXECUTION_PAYLOAD_HEADER, - new ExecutionPayloadHeaderSchemaCapella(specConfig)), + schemaRegistry.get(EXECUTION_PAYLOAD_HEADER_SCHEMA).toVersionCapellaRequired()), namedSchema( BlockBodyFields.BLS_TO_EXECUTION_CHANGES, SszListSchema.create( - signedBlsToExecutionChangeSchema, specConfig.getMaxBlsToExecutionChanges()))); + schemaRegistry.get(SIGNED_BLS_TO_EXECUTION_CHANGE_SCHEMA), + specConfig.getMaxBlsToExecutionChanges()))); } @Override @@ -176,7 +182,7 @@ public SyncAggregateSchema getSyncAggregateSchema() { } @Override - public BlindedBeaconBlockBodyCapellaImpl createFromBackingNode(TreeNode node) { + public BlindedBeaconBlockBodyCapellaImpl createFromBackingNode(final TreeNode node) { return new BlindedBeaconBlockBodyCapellaImpl(this, node); } @@ -191,6 +197,11 @@ public ExecutionPayloadHeaderSchemaCapella getExecutionPayloadHeaderSchema() { return (SszListSchema) getFieldSchema10(); } + @Override + public Optional> toBlindedVersionCapella() { + return Optional.of(this); + } + @Override public LongList getBlindedNodeGeneralizedIndices() { return GIndexUtil.gIdxComposeAll( diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/deneb/BeaconBlockBodyDenebImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/deneb/BeaconBlockBodyDenebImpl.java index ce17e0a101c..b17f645edac 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/deneb/BeaconBlockBodyDenebImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/deneb/BeaconBlockBodyDenebImpl.java @@ -53,19 +53,19 @@ public class BeaconBlockBodyDenebImpl implements BeaconBlockBodyDeneb { BeaconBlockBodyDenebImpl( - BeaconBlockBodySchemaDenebImpl type, - SszSignature randaoReveal, - Eth1Data eth1Data, - SszBytes32 graffiti, - SszList proposerSlashings, - SszList attesterSlashings, - SszList attestations, - SszList deposits, - SszList voluntaryExits, - SyncAggregate syncAggregate, - ExecutionPayloadDenebImpl executionPayload, - SszList blsToExecutionChanges, - SszList blobKzgCommitments) { + final BeaconBlockBodySchemaDenebImpl type, + final SszSignature randaoReveal, + final Eth1Data eth1Data, + final SszBytes32 graffiti, + final SszList proposerSlashings, + final SszList attesterSlashings, + final SszList attestations, + final SszList deposits, + final SszList voluntaryExits, + final SyncAggregate syncAggregate, + final ExecutionPayloadDenebImpl executionPayload, + final SszList blsToExecutionChanges, + final SszList blobKzgCommitments) { super( type, randaoReveal, diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/deneb/BeaconBlockBodySchemaDenebImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/deneb/BeaconBlockBodySchemaDenebImpl.java index d7d22576adf..89328e6bc61 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/deneb/BeaconBlockBodySchemaDenebImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/deneb/BeaconBlockBodySchemaDenebImpl.java @@ -13,6 +13,12 @@ package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.deneb; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.ATTESTATION_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.ATTESTER_SLASHING_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOB_KZG_COMMITMENTS_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_PAYLOAD_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SIGNED_BLS_TO_EXECUTION_CHANGE_SCHEMA; + import it.unimi.dsi.fastutil.longs.LongList; import java.util.function.Function; import tech.pegasys.teku.infrastructure.async.SafeFuture; @@ -24,7 +30,6 @@ import tech.pegasys.teku.infrastructure.ssz.tree.GIndexUtil; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; import tech.pegasys.teku.spec.config.SpecConfigDeneb; -import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobKzgCommitmentsSchema; import tech.pegasys.teku.spec.datastructures.blocks.Eth1Data; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodyBuilder; @@ -33,19 +38,16 @@ import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.SyncAggregateSchema; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSchema; import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadDenebImpl; -import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadSchemaDeneb; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; -import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing.AttesterSlashingSchema; import tech.pegasys.teku.spec.datastructures.operations.Deposit; import tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing; import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChange; -import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChangeSchema; import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; import tech.pegasys.teku.spec.datastructures.type.SszSignature; import tech.pegasys.teku.spec.datastructures.type.SszSignatureSchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; public class BeaconBlockBodySchemaDenebImpl extends ContainerSchema12< @@ -96,10 +98,8 @@ protected BeaconBlockBodySchemaDenebImpl( public static BeaconBlockBodySchemaDenebImpl create( final SpecConfigDeneb specConfig, - final AttesterSlashingSchema attesterSlashingSchema, - final SignedBlsToExecutionChangeSchema blsToExecutionChangeSchema, - final BlobKzgCommitmentsSchema blobKzgCommitmentsSchema, - final String containerName) { + final String containerName, + final SchemaRegistry schemaRegistry) { return new BeaconBlockBodySchemaDenebImpl( containerName, namedSchema(BlockBodyFields.RANDAO_REVEAL, SszSignatureSchema.INSTANCE), @@ -111,11 +111,13 @@ public static BeaconBlockBodySchemaDenebImpl create( ProposerSlashing.SSZ_SCHEMA, specConfig.getMaxProposerSlashings())), namedSchema( BlockBodyFields.ATTESTER_SLASHINGS, - SszListSchema.create(attesterSlashingSchema, specConfig.getMaxAttesterSlashings())), + SszListSchema.create( + schemaRegistry.get(ATTESTER_SLASHING_SCHEMA), + specConfig.getMaxAttesterSlashings())), namedSchema( BlockBodyFields.ATTESTATIONS, SszListSchema.create( - new AttestationSchema(specConfig), specConfig.getMaxAttestations())), + schemaRegistry.get(ATTESTATION_SCHEMA), specConfig.getMaxAttestations())), namedSchema( BlockBodyFields.DEPOSITS, SszListSchema.create(Deposit.SSZ_SCHEMA, specConfig.getMaxDeposits())), @@ -126,12 +128,16 @@ public static BeaconBlockBodySchemaDenebImpl create( namedSchema( BlockBodyFields.SYNC_AGGREGATE, SyncAggregateSchema.create(specConfig.getSyncCommitteeSize())), - namedSchema(BlockBodyFields.EXECUTION_PAYLOAD, new ExecutionPayloadSchemaDeneb(specConfig)), + namedSchema( + BlockBodyFields.EXECUTION_PAYLOAD, + schemaRegistry.get(EXECUTION_PAYLOAD_SCHEMA).toVersionDenebRequired()), namedSchema( BlockBodyFields.BLS_TO_EXECUTION_CHANGES, SszListSchema.create( - blsToExecutionChangeSchema, specConfig.getMaxBlsToExecutionChanges())), - namedSchema(BlockBodyFields.BLOB_KZG_COMMITMENTS, blobKzgCommitmentsSchema)); + schemaRegistry.get(SIGNED_BLS_TO_EXECUTION_CHANGE_SCHEMA), + specConfig.getMaxBlsToExecutionChanges())), + namedSchema( + BlockBodyFields.BLOB_KZG_COMMITMENTS, schemaRegistry.get(BLOB_KZG_COMMITMENTS_SCHEMA))); } @Override diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/deneb/BlindedBeaconBlockBodySchemaDenebImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/deneb/BlindedBeaconBlockBodySchemaDenebImpl.java index 33a1ab1a759..fefed226d29 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/deneb/BlindedBeaconBlockBodySchemaDenebImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/deneb/BlindedBeaconBlockBodySchemaDenebImpl.java @@ -13,7 +13,13 @@ package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.deneb; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.ATTESTATION_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOB_KZG_COMMITMENTS_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_PAYLOAD_HEADER_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SIGNED_BLS_TO_EXECUTION_CHANGE_SCHEMA; + import it.unimi.dsi.fastutil.longs.LongList; +import java.util.Optional; import java.util.function.Function; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.ssz.SszList; @@ -24,7 +30,6 @@ import tech.pegasys.teku.infrastructure.ssz.tree.GIndexUtil; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; import tech.pegasys.teku.spec.config.SpecConfigDeneb; -import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobKzgCommitmentsSchema; import tech.pegasys.teku.spec.datastructures.blocks.Eth1Data; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodyBuilder; @@ -34,17 +39,16 @@ import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadHeaderDenebImpl; import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadHeaderSchemaDeneb; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; -import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing.AttesterSlashingSchema; import tech.pegasys.teku.spec.datastructures.operations.Deposit; import tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing; import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChange; -import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChangeSchema; import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; import tech.pegasys.teku.spec.datastructures.type.SszSignature; import tech.pegasys.teku.spec.datastructures.type.SszSignatureSchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; +import tech.pegasys.teku.spec.schemas.registry.SchemaTypes; public class BlindedBeaconBlockBodySchemaDenebImpl extends ContainerSchema12< @@ -95,10 +99,8 @@ private BlindedBeaconBlockBodySchemaDenebImpl( public static BlindedBeaconBlockBodySchemaDenebImpl create( final SpecConfigDeneb specConfig, - final AttesterSlashingSchema attesterSlashingSchema, - final SignedBlsToExecutionChangeSchema signedBlsToExecutionChangeSchema, - final BlobKzgCommitmentsSchema blobKzgCommitmentsSchema, - final String containerName) { + final String containerName, + final SchemaRegistry schemaRegistry) { return new BlindedBeaconBlockBodySchemaDenebImpl( containerName, namedSchema(BlockBodyFields.RANDAO_REVEAL, SszSignatureSchema.INSTANCE), @@ -110,11 +112,13 @@ public static BlindedBeaconBlockBodySchemaDenebImpl create( ProposerSlashing.SSZ_SCHEMA, specConfig.getMaxProposerSlashings())), namedSchema( BlockBodyFields.ATTESTER_SLASHINGS, - SszListSchema.create(attesterSlashingSchema, specConfig.getMaxAttesterSlashings())), + SszListSchema.create( + schemaRegistry.get(SchemaTypes.ATTESTER_SLASHING_SCHEMA), + specConfig.getMaxAttesterSlashings())), namedSchema( BlockBodyFields.ATTESTATIONS, SszListSchema.create( - new AttestationSchema(specConfig), specConfig.getMaxAttestations())), + schemaRegistry.get(ATTESTATION_SCHEMA), specConfig.getMaxAttestations())), namedSchema( BlockBodyFields.DEPOSITS, SszListSchema.create(Deposit.SSZ_SCHEMA, specConfig.getMaxDeposits())), @@ -127,12 +131,14 @@ public static BlindedBeaconBlockBodySchemaDenebImpl create( SyncAggregateSchema.create(specConfig.getSyncCommitteeSize())), namedSchema( BlockBodyFields.EXECUTION_PAYLOAD_HEADER, - new ExecutionPayloadHeaderSchemaDeneb(specConfig)), + schemaRegistry.get(EXECUTION_PAYLOAD_HEADER_SCHEMA).toVersionDenebRequired()), namedSchema( BlockBodyFields.BLS_TO_EXECUTION_CHANGES, SszListSchema.create( - signedBlsToExecutionChangeSchema, specConfig.getMaxBlsToExecutionChanges())), - namedSchema(BlockBodyFields.BLOB_KZG_COMMITMENTS, blobKzgCommitmentsSchema)); + schemaRegistry.get(SIGNED_BLS_TO_EXECUTION_CHANGE_SCHEMA), + specConfig.getMaxBlsToExecutionChanges())), + namedSchema( + BlockBodyFields.BLOB_KZG_COMMITMENTS, schemaRegistry.get(BLOB_KZG_COMMITMENTS_SCHEMA))); } @Override @@ -217,4 +223,9 @@ public LongList getBlindedNodeGeneralizedIndices() { getChildGeneralizedIndex(getFieldIndex(BlockBodyFields.EXECUTION_PAYLOAD_HEADER)), getExecutionPayloadHeaderSchema().getBlindedNodeGeneralizedIndices()); } + + @Override + public Optional> toBlindedVersionDeneb() { + return Optional.of(this); + } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BeaconBlockBodyBuilderEip7594.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BeaconBlockBodyBuilderElectra.java similarity index 58% rename from ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BeaconBlockBodyBuilderEip7594.java rename to ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BeaconBlockBodyBuilderElectra.java index 7eab2263082..3974f24f8ac 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BeaconBlockBodyBuilderEip7594.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BeaconBlockBodyBuilderElectra.java @@ -11,36 +11,54 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594; +package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra; + +import static com.google.common.base.Preconditions.checkNotNull; import tech.pegasys.teku.infrastructure.ssz.primitive.SszBytes32; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodyBuilder; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodySchema; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.deneb.BeaconBlockBodyBuilderDeneb; -import tech.pegasys.teku.spec.datastructures.execution.versions.eip7594.ExecutionPayloadEip7594Impl; -import tech.pegasys.teku.spec.datastructures.execution.versions.eip7594.ExecutionPayloadHeaderEip7594Impl; +import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadDenebImpl; +import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadHeaderDenebImpl; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; import tech.pegasys.teku.spec.datastructures.type.SszSignature; -public class BeaconBlockBodyBuilderEip7594 extends BeaconBlockBodyBuilderDeneb { +public class BeaconBlockBodyBuilderElectra extends BeaconBlockBodyBuilderDeneb { + + private ExecutionRequests executionRequests; - public BeaconBlockBodyBuilderEip7594( - final BeaconBlockBodySchema schema, - final BeaconBlockBodySchema blindedSchema) { + public BeaconBlockBodyBuilderElectra( + final BeaconBlockBodySchema schema, + final BeaconBlockBodySchema blindedSchema) { super(schema, blindedSchema); } @Override protected void validate() { super.validate(); + checkNotNull(executionRequests, "execution_requests must be specified"); + } + + @Override + public boolean supportsExecutionRequests() { + return true; + } + + @Override + public BeaconBlockBodyBuilder executionRequests(final ExecutionRequests executionRequests) { + this.executionRequests = executionRequests; + return this; } @Override public BeaconBlockBody build() { validate(); if (isBlinded()) { - final BlindedBeaconBlockBodySchemaEip7594Impl schema = - getAndValidateSchema(true, BlindedBeaconBlockBodySchemaEip7594Impl.class); - return new BlindedBeaconBlockBodyEip7594Impl( + final BlindedBeaconBlockBodySchemaElectraImpl schema = + getAndValidateSchema(true, BlindedBeaconBlockBodySchemaElectraImpl.class); + return new BlindedBeaconBlockBodyElectraImpl( schema, new SszSignature(randaoReveal), eth1Data, @@ -51,15 +69,15 @@ public BeaconBlockBody build() { deposits, voluntaryExits, syncAggregate, - (ExecutionPayloadHeaderEip7594Impl) - executionPayloadHeader.toVersionEip7594().orElseThrow(), + (ExecutionPayloadHeaderDenebImpl) executionPayloadHeader.toVersionDeneb().orElseThrow(), getBlsToExecutionChanges(), - getBlobKzgCommitments()); + getBlobKzgCommitments(), + executionRequests); } - final BeaconBlockBodySchemaEip7594Impl schema = - getAndValidateSchema(false, BeaconBlockBodySchemaEip7594Impl.class); - return new BeaconBlockBodyEip7594Impl( + final BeaconBlockBodySchemaElectraImpl schema = + getAndValidateSchema(false, BeaconBlockBodySchemaElectraImpl.class); + return new BeaconBlockBodyElectraImpl( schema, new SszSignature(randaoReveal), eth1Data, @@ -70,8 +88,9 @@ public BeaconBlockBody build() { deposits, voluntaryExits, syncAggregate, - (ExecutionPayloadEip7594Impl) executionPayload.toVersionEip7594().orElseThrow(), + (ExecutionPayloadDenebImpl) executionPayload.toVersionDeneb().orElseThrow(), getBlsToExecutionChanges(), - getBlobKzgCommitments()); + getBlobKzgCommitments(), + executionRequests); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BeaconBlockBodyEip7594.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BeaconBlockBodyElectra.java similarity index 71% rename from ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BeaconBlockBodyEip7594.java rename to ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BeaconBlockBodyElectra.java index 9921802f69a..e6ea4fb31a0 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BeaconBlockBodyEip7594.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BeaconBlockBodyElectra.java @@ -11,30 +11,29 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594; +package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra; import java.util.Optional; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.deneb.BeaconBlockBodyDeneb; -import tech.pegasys.teku.spec.datastructures.execution.versions.eip7594.ExecutionPayloadEip7594; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; -public interface BeaconBlockBodyEip7594 extends BeaconBlockBodyDeneb { - static BeaconBlockBodyEip7594 required(final BeaconBlockBody body) { - return body.toVersionEip7594() +public interface BeaconBlockBodyElectra extends BeaconBlockBodyDeneb { + static BeaconBlockBodyElectra required(final BeaconBlockBody body) { + return body.toVersionElectra() .orElseThrow( () -> new IllegalArgumentException( - "Expected EIP7594 block body but got " + body.getClass().getSimpleName())); + "Expected Electra block body but got " + body.getClass().getSimpleName())); } @Override - BeaconBlockBodySchemaEip7594 getSchema(); + BeaconBlockBodySchemaElectra getSchema(); - @Override - ExecutionPayloadEip7594 getExecutionPayload(); + ExecutionRequests getExecutionRequests(); @Override - default Optional toVersionEip7594() { + default Optional toVersionElectra() { return Optional.of(this); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BeaconBlockBodyEip7594Impl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BeaconBlockBodyElectraImpl.java similarity index 68% rename from ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BeaconBlockBodyEip7594Impl.java rename to ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BeaconBlockBodyElectraImpl.java index a0bd1d12d57..dcbd4520d04 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BeaconBlockBodyEip7594Impl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BeaconBlockBodyElectraImpl.java @@ -11,21 +11,22 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594; +package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra; import static com.google.common.base.Preconditions.checkArgument; import org.apache.tuweni.bytes.Bytes32; import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.infrastructure.ssz.SszList; -import tech.pegasys.teku.infrastructure.ssz.containers.Container12; +import tech.pegasys.teku.infrastructure.ssz.containers.Container13; import tech.pegasys.teku.infrastructure.ssz.primitive.SszBytes32; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; import tech.pegasys.teku.spec.datastructures.blocks.Eth1Data; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.SyncAggregate; -import tech.pegasys.teku.spec.datastructures.execution.versions.eip7594.ExecutionPayloadEip7594; -import tech.pegasys.teku.spec.datastructures.execution.versions.eip7594.ExecutionPayloadEip7594Impl; +import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadDeneb; +import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadDenebImpl; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; import tech.pegasys.teku.spec.datastructures.operations.Deposit; @@ -35,9 +36,9 @@ import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; import tech.pegasys.teku.spec.datastructures.type.SszSignature; -public class BeaconBlockBodyEip7594Impl - extends Container12< - BeaconBlockBodyEip7594Impl, +public class BeaconBlockBodyElectraImpl + extends Container13< + BeaconBlockBodyElectraImpl, SszSignature, Eth1Data, SszBytes32, @@ -47,25 +48,27 @@ public class BeaconBlockBodyEip7594Impl SszList, SszList, SyncAggregate, - ExecutionPayloadEip7594Impl, + ExecutionPayloadDenebImpl, SszList, - SszList> - implements BeaconBlockBodyEip7594 { - - BeaconBlockBodyEip7594Impl( - BeaconBlockBodySchemaEip7594Impl type, - SszSignature randaoReveal, - Eth1Data eth1Data, - SszBytes32 graffiti, - SszList proposerSlashings, - SszList attesterSlashings, - SszList attestations, - SszList deposits, - SszList voluntaryExits, - SyncAggregate syncAggregate, - ExecutionPayloadEip7594Impl executionPayload, - SszList blsToExecutionChanges, - SszList blobKzgCommitments) { + SszList, + ExecutionRequests> + implements BeaconBlockBodyElectra { + + BeaconBlockBodyElectraImpl( + final BeaconBlockBodySchemaElectraImpl type, + final SszSignature randaoReveal, + final Eth1Data eth1Data, + final SszBytes32 graffiti, + final SszList proposerSlashings, + final SszList attesterSlashings, + final SszList attestations, + final SszList deposits, + final SszList voluntaryExits, + final SyncAggregate syncAggregate, + final ExecutionPayloadDenebImpl executionPayload, + final SszList blsToExecutionChanges, + final SszList blobKzgCommitments, + final ExecutionRequests executionRequests) { super( type, randaoReveal, @@ -79,24 +82,25 @@ public class BeaconBlockBodyEip7594Impl syncAggregate, executionPayload, blsToExecutionChanges, - blobKzgCommitments); + blobKzgCommitments, + executionRequests); } - BeaconBlockBodyEip7594Impl(final BeaconBlockBodySchemaEip7594Impl type) { + BeaconBlockBodyElectraImpl(final BeaconBlockBodySchemaElectraImpl type) { super(type); } - BeaconBlockBodyEip7594Impl( - final BeaconBlockBodySchemaEip7594Impl type, final TreeNode backingNode) { + BeaconBlockBodyElectraImpl( + final BeaconBlockBodySchemaElectraImpl type, final TreeNode backingNode) { super(type, backingNode); } - public static BeaconBlockBodyEip7594Impl required(final BeaconBlockBody body) { + public static BeaconBlockBodyElectraImpl required(final BeaconBlockBody body) { checkArgument( - body instanceof BeaconBlockBodyEip7594Impl, - "Expected EIP7594 block body but got %s", + body instanceof BeaconBlockBodyElectraImpl, + "Expected Electra block body but got %s", body.getClass()); - return (BeaconBlockBodyEip7594Impl) body; + return (BeaconBlockBodyElectraImpl) body; } @Override @@ -155,7 +159,7 @@ public SyncAggregate getSyncAggregate() { } @Override - public ExecutionPayloadEip7594 getExecutionPayload() { + public ExecutionPayloadDeneb getExecutionPayload() { return getField9(); } @@ -170,7 +174,12 @@ public SszList getBlobKzgCommitments() { } @Override - public BeaconBlockBodySchemaEip7594Impl getSchema() { - return (BeaconBlockBodySchemaEip7594Impl) super.getSchema(); + public ExecutionRequests getExecutionRequests() { + return getField12(); + } + + @Override + public BeaconBlockBodySchemaElectraImpl getSchema() { + return (BeaconBlockBodySchemaElectraImpl) super.getSchema(); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BeaconBlockBodySchemaEip7594.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BeaconBlockBodySchemaElectra.java similarity index 66% rename from ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BeaconBlockBodySchemaEip7594.java rename to ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BeaconBlockBodySchemaElectra.java index 25464319424..e50fc698a0e 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BeaconBlockBodySchemaEip7594.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BeaconBlockBodySchemaElectra.java @@ -11,27 +11,30 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594; +package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra; import static com.google.common.base.Preconditions.checkArgument; import java.util.Optional; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodySchema; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.deneb.BeaconBlockBodySchemaDeneb; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsSchema; -public interface BeaconBlockBodySchemaEip7594 +public interface BeaconBlockBodySchemaElectra extends BeaconBlockBodySchemaDeneb { - static BeaconBlockBodySchemaEip7594 required(final BeaconBlockBodySchema schema) { + static BeaconBlockBodySchemaElectra required(final BeaconBlockBodySchema schema) { checkArgument( - schema instanceof BeaconBlockBodySchemaEip7594, - "Expected a BeaconBlockBodySchemaEip7594 but was %s", + schema instanceof BeaconBlockBodySchemaElectra, + "Expected a BeaconBlockBodySchemaElectra but was %s", schema.getClass()); - return (BeaconBlockBodySchemaEip7594) schema; + return (BeaconBlockBodySchemaElectra) schema; } + ExecutionRequestsSchema getExecutionRequestsSchema(); + @Override - default Optional> toVersionEip7594() { + default Optional> toVersionElectra() { return Optional.of(this); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BeaconBlockBodySchemaEip7594Impl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BeaconBlockBodySchemaElectraImpl.java similarity index 74% rename from ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BeaconBlockBodySchemaEip7594Impl.java rename to ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BeaconBlockBodySchemaElectraImpl.java index 4f644d4b2c8..ab5eeca408c 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BeaconBlockBodySchemaEip7594Impl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BeaconBlockBodySchemaElectraImpl.java @@ -11,20 +11,24 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594; +package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra; + +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOB_KZG_COMMITMENTS_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_PAYLOAD_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_REQUESTS_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SIGNED_BLS_TO_EXECUTION_CHANGE_SCHEMA; import it.unimi.dsi.fastutil.longs.LongList; import java.util.function.Function; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.ssz.SszList; -import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema12; +import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema13; import tech.pegasys.teku.infrastructure.ssz.primitive.SszBytes32; import tech.pegasys.teku.infrastructure.ssz.schema.SszListSchema; import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; import tech.pegasys.teku.infrastructure.ssz.tree.GIndexUtil; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; -import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobKzgCommitmentsSchema; +import tech.pegasys.teku.spec.config.SpecConfigElectra; import tech.pegasys.teku.spec.datastructures.blocks.Eth1Data; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodyBuilder; @@ -32,24 +36,24 @@ import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.SyncAggregate; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.SyncAggregateSchema; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSchema; -import tech.pegasys.teku.spec.datastructures.execution.versions.eip7594.ExecutionPayloadEip7594Impl; -import tech.pegasys.teku.spec.datastructures.execution.versions.eip7594.ExecutionPayloadSchemaEip7594; +import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadDenebImpl; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsSchema; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; -import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing.AttesterSlashingSchema; import tech.pegasys.teku.spec.datastructures.operations.Deposit; import tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing; import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChange; -import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChangeSchema; import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; import tech.pegasys.teku.spec.datastructures.type.SszSignature; import tech.pegasys.teku.spec.datastructures.type.SszSignatureSchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; +import tech.pegasys.teku.spec.schemas.registry.SchemaTypes; -public class BeaconBlockBodySchemaEip7594Impl - extends ContainerSchema12< - BeaconBlockBodyEip7594Impl, +public class BeaconBlockBodySchemaElectraImpl + extends ContainerSchema13< + BeaconBlockBodyElectraImpl, SszSignature, Eth1Data, SszBytes32, @@ -59,12 +63,13 @@ public class BeaconBlockBodySchemaEip7594Impl SszList, SszList, SyncAggregate, - ExecutionPayloadEip7594Impl, + ExecutionPayloadDenebImpl, SszList, - SszList> - implements BeaconBlockBodySchemaEip7594 { + SszList, + ExecutionRequests> + implements BeaconBlockBodySchemaElectra { - protected BeaconBlockBodySchemaEip7594Impl( + protected BeaconBlockBodySchemaElectraImpl( final String containerName, final NamedSchema randaoRevealSchema, final NamedSchema eth1DataSchema, @@ -75,9 +80,10 @@ protected BeaconBlockBodySchemaEip7594Impl( final NamedSchema> depositsSchema, final NamedSchema> voluntaryExitsSchema, final NamedSchema syncAggregateSchema, - final NamedSchema executionPayloadSchema, + final NamedSchema executionPayloadSchema, final NamedSchema> blsToExecutionChange, - final NamedSchema> blobKzgCommitments) { + final NamedSchema> blobKzgCommitments, + final NamedSchema executionRequests) { super( containerName, randaoRevealSchema, @@ -91,16 +97,15 @@ protected BeaconBlockBodySchemaEip7594Impl( syncAggregateSchema, executionPayloadSchema, blsToExecutionChange, - blobKzgCommitments); + blobKzgCommitments, + executionRequests); } - public static BeaconBlockBodySchemaEip7594Impl create( - final SpecConfigEip7594 specConfig, - final AttesterSlashingSchema attesterSlashingSchema, - final SignedBlsToExecutionChangeSchema blsToExecutionChangeSchema, - final BlobKzgCommitmentsSchema blobKzgCommitmentsSchema, - final String containerName) { - return new BeaconBlockBodySchemaEip7594Impl( + public static BeaconBlockBodySchemaElectraImpl create( + final SpecConfigElectra specConfig, + final String containerName, + final SchemaRegistry schemaRegistry) { + return new BeaconBlockBodySchemaElectraImpl( containerName, namedSchema(BlockBodyFields.RANDAO_REVEAL, SszSignatureSchema.INSTANCE), namedSchema(BlockBodyFields.ETH1_DATA, Eth1Data.SSZ_SCHEMA), @@ -111,11 +116,14 @@ public static BeaconBlockBodySchemaEip7594Impl create( ProposerSlashing.SSZ_SCHEMA, specConfig.getMaxProposerSlashings())), namedSchema( BlockBodyFields.ATTESTER_SLASHINGS, - SszListSchema.create(attesterSlashingSchema, specConfig.getMaxAttesterSlashings())), + SszListSchema.create( + schemaRegistry.get(SchemaTypes.ATTESTER_SLASHING_SCHEMA), + specConfig.getMaxAttesterSlashingsElectra())), namedSchema( BlockBodyFields.ATTESTATIONS, SszListSchema.create( - new AttestationSchema(specConfig), specConfig.getMaxAttestations())), + schemaRegistry.get(SchemaTypes.ATTESTATION_SCHEMA), + specConfig.getMaxAttestationsElectra())), namedSchema( BlockBodyFields.DEPOSITS, SszListSchema.create(Deposit.SSZ_SCHEMA, specConfig.getMaxDeposits())), @@ -127,24 +135,29 @@ public static BeaconBlockBodySchemaEip7594Impl create( BlockBodyFields.SYNC_AGGREGATE, SyncAggregateSchema.create(specConfig.getSyncCommitteeSize())), namedSchema( - BlockBodyFields.EXECUTION_PAYLOAD, new ExecutionPayloadSchemaEip7594(specConfig)), + BlockBodyFields.EXECUTION_PAYLOAD, + schemaRegistry.get(EXECUTION_PAYLOAD_SCHEMA).toVersionDenebRequired()), namedSchema( BlockBodyFields.BLS_TO_EXECUTION_CHANGES, SszListSchema.create( - blsToExecutionChangeSchema, specConfig.getMaxBlsToExecutionChanges())), - namedSchema(BlockBodyFields.BLOB_KZG_COMMITMENTS, blobKzgCommitmentsSchema)); + schemaRegistry.get(SIGNED_BLS_TO_EXECUTION_CHANGE_SCHEMA), + specConfig.getMaxBlsToExecutionChanges())), + namedSchema( + BlockBodyFields.BLOB_KZG_COMMITMENTS, schemaRegistry.get(BLOB_KZG_COMMITMENTS_SCHEMA)), + namedSchema( + BlockBodyFields.EXECUTION_REQUESTS, schemaRegistry.get(EXECUTION_REQUESTS_SCHEMA))); } @Override public SafeFuture createBlockBody( final Function> bodyBuilder) { - final BeaconBlockBodyBuilderEip7594 builder = new BeaconBlockBodyBuilderEip7594(this, null); + final BeaconBlockBodyBuilderElectra builder = new BeaconBlockBodyBuilderElectra(this, null); return bodyBuilder.apply(builder).thenApply(__ -> builder.build()); } @Override public BeaconBlockBody createEmpty() { - return new BeaconBlockBodyEip7594Impl(this); + return new BeaconBlockBodyElectraImpl(this); } @SuppressWarnings("unchecked") @@ -187,8 +200,8 @@ public SyncAggregateSchema getSyncAggregateSchema() { } @Override - public BeaconBlockBodyEip7594Impl createFromBackingNode(final TreeNode node) { - return new BeaconBlockBodyEip7594Impl(this, node); + public BeaconBlockBodyElectraImpl createFromBackingNode(final TreeNode node) { + return new BeaconBlockBodyElectraImpl(this, node); } @Override @@ -211,6 +224,12 @@ public ExecutionPayloadSchema getExecutionPayloadSchema() { getChildSchema(getFieldIndex(BlockBodyFields.BLOB_KZG_COMMITMENTS)); } + @Override + public ExecutionRequestsSchema getExecutionRequestsSchema() { + return (ExecutionRequestsSchema) + getChildSchema(getFieldIndex(BlockBodyFields.EXECUTION_REQUESTS)); + } + @Override public long getBlobKzgCommitmentsGeneralizedIndex() { return getChildGeneralizedIndex(getFieldIndex(BlockBodyFields.BLOB_KZG_COMMITMENTS)); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BlindedBeaconBlockBodyEip7594.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BlindedBeaconBlockBodyElectra.java similarity index 63% rename from ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BlindedBeaconBlockBodyEip7594.java rename to ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BlindedBeaconBlockBodyElectra.java index 14947e525c9..c97c7916b36 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BlindedBeaconBlockBodyEip7594.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BlindedBeaconBlockBodyElectra.java @@ -11,27 +11,35 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594; +package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra; import java.util.Optional; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.deneb.BlindedBeaconBlockBodyDeneb; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; -public interface BlindedBeaconBlockBodyEip7594 extends BlindedBeaconBlockBodyDeneb { - static BlindedBeaconBlockBodyEip7594 required(final BeaconBlockBody body) { - return body.toBlindedVersionEip7594() +public interface BlindedBeaconBlockBodyElectra extends BlindedBeaconBlockBodyDeneb { + static BlindedBeaconBlockBodyElectra required(final BeaconBlockBody body) { + return body.toBlindedVersionElectra() .orElseThrow( () -> new IllegalArgumentException( - "Expected an EIP7594 blinded block body but got: " + "Expected an Electra blinded block body but got: " + body.getClass().getSimpleName())); } + ExecutionRequests getExecutionRequests(); + + @Override + default Optional getOptionalExecutionRequests() { + return Optional.of(getExecutionRequests()); + } + @Override - default Optional toBlindedVersionEip7594() { + default Optional toBlindedVersionElectra() { return Optional.of(this); } @Override - BlindedBeaconBlockBodySchemaEip7594 getSchema(); + BlindedBeaconBlockBodySchemaElectra getSchema(); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BlindedBeaconBlockBodyEip7594Impl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BlindedBeaconBlockBodyElectraImpl.java similarity index 76% rename from ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BlindedBeaconBlockBodyEip7594Impl.java rename to ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BlindedBeaconBlockBodyElectraImpl.java index 0439fd8db72..55348da1584 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BlindedBeaconBlockBodyEip7594Impl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BlindedBeaconBlockBodyElectraImpl.java @@ -11,21 +11,22 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594; +package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra; import static com.google.common.base.Preconditions.checkArgument; import org.apache.tuweni.bytes.Bytes32; import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.infrastructure.ssz.SszList; -import tech.pegasys.teku.infrastructure.ssz.containers.Container12; +import tech.pegasys.teku.infrastructure.ssz.containers.Container13; import tech.pegasys.teku.infrastructure.ssz.primitive.SszBytes32; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; import tech.pegasys.teku.spec.datastructures.blocks.Eth1Data; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.SyncAggregate; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; -import tech.pegasys.teku.spec.datastructures.execution.versions.eip7594.ExecutionPayloadHeaderEip7594Impl; +import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadHeaderDenebImpl; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; import tech.pegasys.teku.spec.datastructures.operations.Deposit; @@ -35,9 +36,9 @@ import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; import tech.pegasys.teku.spec.datastructures.type.SszSignature; -class BlindedBeaconBlockBodyEip7594Impl - extends Container12< - BlindedBeaconBlockBodyEip7594Impl, +class BlindedBeaconBlockBodyElectraImpl + extends Container13< + BlindedBeaconBlockBodyElectraImpl, SszSignature, Eth1Data, SszBytes32, @@ -47,22 +48,23 @@ class BlindedBeaconBlockBodyEip7594Impl SszList, SszList, SyncAggregate, - ExecutionPayloadHeaderEip7594Impl, + ExecutionPayloadHeaderDenebImpl, SszList, - SszList> - implements BlindedBeaconBlockBodyEip7594 { + SszList, + ExecutionRequests> + implements BlindedBeaconBlockBodyElectra { - BlindedBeaconBlockBodyEip7594Impl(final BlindedBeaconBlockBodySchemaEip7594Impl type) { + BlindedBeaconBlockBodyElectraImpl(final BlindedBeaconBlockBodySchemaElectraImpl type) { super(type); } - BlindedBeaconBlockBodyEip7594Impl( - final BlindedBeaconBlockBodySchemaEip7594Impl type, final TreeNode backingNode) { + BlindedBeaconBlockBodyElectraImpl( + final BlindedBeaconBlockBodySchemaElectraImpl type, final TreeNode backingNode) { super(type, backingNode); } - BlindedBeaconBlockBodyEip7594Impl( - final BlindedBeaconBlockBodySchemaEip7594Impl type, + BlindedBeaconBlockBodyElectraImpl( + final BlindedBeaconBlockBodySchemaElectraImpl type, final SszSignature randaoReveal, final Eth1Data eth1Data, final SszBytes32 graffiti, @@ -72,9 +74,10 @@ class BlindedBeaconBlockBodyEip7594Impl final SszList deposits, final SszList voluntaryExits, final SyncAggregate syncAggregate, - final ExecutionPayloadHeaderEip7594Impl executionPayloadHeader, + final ExecutionPayloadHeaderDenebImpl executionPayloadHeader, final SszList blsToExecutionChanges, - final SszList blobKzgCommitments) { + final SszList blobKzgCommitments, + final ExecutionRequests executionRequests) { super( type, randaoReveal, @@ -88,15 +91,16 @@ class BlindedBeaconBlockBodyEip7594Impl syncAggregate, executionPayloadHeader, blsToExecutionChanges, - blobKzgCommitments); + blobKzgCommitments, + executionRequests); } - public static BlindedBeaconBlockBodyEip7594Impl required(final BeaconBlockBody body) { + public static BlindedBeaconBlockBodyElectraImpl required(final BeaconBlockBody body) { checkArgument( - body instanceof BlindedBeaconBlockBodyEip7594Impl, - "Expected EIP7594 blinded block body but got %s", + body instanceof BlindedBeaconBlockBodyElectraImpl, + "Expected Electra blinded block body but got %s", body.getClass()); - return (BlindedBeaconBlockBodyEip7594Impl) body; + return (BlindedBeaconBlockBodyElectraImpl) body; } @Override @@ -170,7 +174,12 @@ public SszList getBlobKzgCommitments() { } @Override - public BlindedBeaconBlockBodySchemaEip7594Impl getSchema() { - return (BlindedBeaconBlockBodySchemaEip7594Impl) super.getSchema(); + public ExecutionRequests getExecutionRequests() { + return getField12(); + } + + @Override + public BlindedBeaconBlockBodySchemaElectraImpl getSchema() { + return (BlindedBeaconBlockBodySchemaElectraImpl) super.getSchema(); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BlindedBeaconBlockBodySchemaEip7594.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BlindedBeaconBlockBodySchemaElectra.java similarity index 67% rename from ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BlindedBeaconBlockBodySchemaEip7594.java rename to ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BlindedBeaconBlockBodySchemaElectra.java index 8561d6fd35e..d2a85a39ca3 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BlindedBeaconBlockBodySchemaEip7594.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BlindedBeaconBlockBodySchemaElectra.java @@ -11,21 +11,24 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594; +package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra; import static com.google.common.base.Preconditions.checkArgument; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodySchema; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.deneb.BlindedBeaconBlockBodySchemaDeneb; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsSchema; -public interface BlindedBeaconBlockBodySchemaEip7594 +public interface BlindedBeaconBlockBodySchemaElectra extends BlindedBeaconBlockBodySchemaDeneb { - static BlindedBeaconBlockBodySchemaEip7594 required(final BeaconBlockBodySchema schema) { + ExecutionRequestsSchema getExecutionRequestsSchema(); + + static BlindedBeaconBlockBodySchemaElectra required(final BeaconBlockBodySchema schema) { checkArgument( - schema instanceof BlindedBeaconBlockBodySchemaEip7594, - "Expected a BlindedBeaconBlockBodySchemaEip7594 but was %s", + schema instanceof BlindedBeaconBlockBodySchemaElectra, + "Expected a BlindedBeaconBlockBodySchemaElectra but was %s", schema.getClass()); - return (BlindedBeaconBlockBodySchemaEip7594) schema; + return (BlindedBeaconBlockBodySchemaElectra) schema; } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BlindedBeaconBlockBodySchemaEip7594Impl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BlindedBeaconBlockBodySchemaElectraImpl.java similarity index 69% rename from ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BlindedBeaconBlockBodySchemaEip7594Impl.java rename to ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BlindedBeaconBlockBodySchemaElectraImpl.java index 30625bde096..30d3a53e5f2 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/eip7594/BlindedBeaconBlockBodySchemaEip7594Impl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BlindedBeaconBlockBodySchemaElectraImpl.java @@ -11,44 +11,51 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594; +package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra; + +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.ATTESTATION_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOB_KZG_COMMITMENTS_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_PAYLOAD_HEADER_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_REQUESTS_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SIGNED_BLS_TO_EXECUTION_CHANGE_SCHEMA; import it.unimi.dsi.fastutil.longs.LongList; +import java.util.Optional; import java.util.function.Function; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.ssz.SszList; -import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema12; +import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema13; import tech.pegasys.teku.infrastructure.ssz.primitive.SszBytes32; import tech.pegasys.teku.infrastructure.ssz.schema.SszListSchema; import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; import tech.pegasys.teku.infrastructure.ssz.tree.GIndexUtil; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; -import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobKzgCommitmentsSchema; +import tech.pegasys.teku.spec.config.SpecConfigElectra; import tech.pegasys.teku.spec.datastructures.blocks.Eth1Data; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodyBuilder; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.common.BlockBodyFields; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.SyncAggregate; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.SyncAggregateSchema; -import tech.pegasys.teku.spec.datastructures.execution.versions.eip7594.ExecutionPayloadHeaderEip7594Impl; -import tech.pegasys.teku.spec.datastructures.execution.versions.eip7594.ExecutionPayloadHeaderSchemaEip7594; +import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadHeaderDenebImpl; +import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadHeaderSchemaDeneb; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsSchema; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; -import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing.AttesterSlashingSchema; import tech.pegasys.teku.spec.datastructures.operations.Deposit; import tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing; import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChange; -import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChangeSchema; import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; import tech.pegasys.teku.spec.datastructures.type.SszSignature; import tech.pegasys.teku.spec.datastructures.type.SszSignatureSchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; +import tech.pegasys.teku.spec.schemas.registry.SchemaTypes; -public class BlindedBeaconBlockBodySchemaEip7594Impl - extends ContainerSchema12< - BlindedBeaconBlockBodyEip7594Impl, +public class BlindedBeaconBlockBodySchemaElectraImpl + extends ContainerSchema13< + BlindedBeaconBlockBodyElectraImpl, SszSignature, Eth1Data, SszBytes32, @@ -58,12 +65,13 @@ public class BlindedBeaconBlockBodySchemaEip7594Impl SszList, SszList, SyncAggregate, - ExecutionPayloadHeaderEip7594Impl, + ExecutionPayloadHeaderDenebImpl, SszList, - SszList> - implements BlindedBeaconBlockBodySchemaEip7594 { + SszList, + ExecutionRequests> + implements BlindedBeaconBlockBodySchemaElectra { - private BlindedBeaconBlockBodySchemaEip7594Impl( + private BlindedBeaconBlockBodySchemaElectraImpl( final String containerName, final NamedSchema randaoReveal, final NamedSchema eth1Data, @@ -74,9 +82,10 @@ private BlindedBeaconBlockBodySchemaEip7594Impl( final NamedSchema> deposits, final NamedSchema> voluntaryExits, final NamedSchema syncAggregate, - final NamedSchema executionPayloadHeader, + final NamedSchema executionPayloadHeader, final NamedSchema> blsToExecutionChanges, - final NamedSchema> blobKzgCommitments) { + final NamedSchema> blobKzgCommitments, + final NamedSchema executionRequests) { super( containerName, randaoReveal, @@ -90,16 +99,15 @@ private BlindedBeaconBlockBodySchemaEip7594Impl( syncAggregate, executionPayloadHeader, blsToExecutionChanges, - blobKzgCommitments); + blobKzgCommitments, + executionRequests); } - public static BlindedBeaconBlockBodySchemaEip7594Impl create( - final SpecConfigEip7594 specConfig, - final AttesterSlashingSchema attesterSlashingSchema, - final SignedBlsToExecutionChangeSchema signedBlsToExecutionChangeSchema, - final BlobKzgCommitmentsSchema blobKzgCommitmentsSchema, - final String containerName) { - return new BlindedBeaconBlockBodySchemaEip7594Impl( + public static BlindedBeaconBlockBodySchemaElectraImpl create( + final SpecConfigElectra specConfig, + final String containerName, + final SchemaRegistry schemaRegistry) { + return new BlindedBeaconBlockBodySchemaElectraImpl( containerName, namedSchema(BlockBodyFields.RANDAO_REVEAL, SszSignatureSchema.INSTANCE), namedSchema(BlockBodyFields.ETH1_DATA, Eth1Data.SSZ_SCHEMA), @@ -110,11 +118,13 @@ public static BlindedBeaconBlockBodySchemaEip7594Impl create( ProposerSlashing.SSZ_SCHEMA, specConfig.getMaxProposerSlashings())), namedSchema( BlockBodyFields.ATTESTER_SLASHINGS, - SszListSchema.create(attesterSlashingSchema, specConfig.getMaxAttesterSlashings())), + SszListSchema.create( + schemaRegistry.get(SchemaTypes.ATTESTER_SLASHING_SCHEMA), + specConfig.getMaxAttesterSlashingsElectra())), namedSchema( BlockBodyFields.ATTESTATIONS, SszListSchema.create( - new AttestationSchema(specConfig), specConfig.getMaxAttestations())), + schemaRegistry.get(ATTESTATION_SCHEMA), specConfig.getMaxAttestationsElectra())), namedSchema( BlockBodyFields.DEPOSITS, SszListSchema.create(Deposit.SSZ_SCHEMA, specConfig.getMaxDeposits())), @@ -127,24 +137,28 @@ public static BlindedBeaconBlockBodySchemaEip7594Impl create( SyncAggregateSchema.create(specConfig.getSyncCommitteeSize())), namedSchema( BlockBodyFields.EXECUTION_PAYLOAD_HEADER, - new ExecutionPayloadHeaderSchemaEip7594(specConfig)), + schemaRegistry.get(EXECUTION_PAYLOAD_HEADER_SCHEMA).toVersionDenebRequired()), namedSchema( BlockBodyFields.BLS_TO_EXECUTION_CHANGES, SszListSchema.create( - signedBlsToExecutionChangeSchema, specConfig.getMaxBlsToExecutionChanges())), - namedSchema(BlockBodyFields.BLOB_KZG_COMMITMENTS, blobKzgCommitmentsSchema)); + schemaRegistry.get(SIGNED_BLS_TO_EXECUTION_CHANGE_SCHEMA), + specConfig.getMaxBlsToExecutionChanges())), + namedSchema( + BlockBodyFields.BLOB_KZG_COMMITMENTS, schemaRegistry.get(BLOB_KZG_COMMITMENTS_SCHEMA)), + namedSchema( + BlockBodyFields.EXECUTION_REQUESTS, schemaRegistry.get(EXECUTION_REQUESTS_SCHEMA))); } @Override public SafeFuture createBlockBody( final Function> bodyBuilder) { - final BeaconBlockBodyBuilderEip7594 builder = new BeaconBlockBodyBuilderEip7594(null, this); + final BeaconBlockBodyBuilderElectra builder = new BeaconBlockBodyBuilderElectra(null, this); return bodyBuilder.apply(builder).thenApply(__ -> builder.build()); } @Override - public BlindedBeaconBlockBodyEip7594Impl createEmpty() { - return new BlindedBeaconBlockBodyEip7594Impl(this); + public BlindedBeaconBlockBodyElectraImpl createEmpty() { + return new BlindedBeaconBlockBodyElectraImpl(this); } @SuppressWarnings("unchecked") @@ -187,13 +201,13 @@ public SyncAggregateSchema getSyncAggregateSchema() { } @Override - public BlindedBeaconBlockBodyEip7594Impl createFromBackingNode(final TreeNode node) { - return new BlindedBeaconBlockBodyEip7594Impl(this, node); + public BlindedBeaconBlockBodyElectraImpl createFromBackingNode(final TreeNode node) { + return new BlindedBeaconBlockBodyElectraImpl(this, node); } @Override - public ExecutionPayloadHeaderSchemaEip7594 getExecutionPayloadHeaderSchema() { - return (ExecutionPayloadHeaderSchemaEip7594) + public ExecutionPayloadHeaderSchemaDeneb getExecutionPayloadHeaderSchema() { + return (ExecutionPayloadHeaderSchemaDeneb) getChildSchema(getFieldIndex(BlockBodyFields.EXECUTION_PAYLOAD_HEADER)); } @@ -211,10 +225,21 @@ public ExecutionPayloadHeaderSchemaEip7594 getExecutionPayloadHeaderSchema() { getChildSchema(getFieldIndex(BlockBodyFields.BLOB_KZG_COMMITMENTS)); } + @Override + public ExecutionRequestsSchema getExecutionRequestsSchema() { + return (ExecutionRequestsSchema) + getChildSchema(getFieldIndex(BlockBodyFields.EXECUTION_REQUESTS)); + } + @Override public LongList getBlindedNodeGeneralizedIndices() { return GIndexUtil.gIdxComposeAll( getChildGeneralizedIndex(getFieldIndex(BlockBodyFields.EXECUTION_PAYLOAD_HEADER)), getExecutionPayloadHeaderSchema().getBlindedNodeGeneralizedIndices()); } + + @Override + public Optional> toBlindedVersionElectra() { + return Optional.of(this); + } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/phase0/BeaconBlockBodyBuilderPhase0.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/phase0/BeaconBlockBodyBuilderPhase0.java index f7600483e82..e590326c161 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/phase0/BeaconBlockBodyBuilderPhase0.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/phase0/BeaconBlockBodyBuilderPhase0.java @@ -27,6 +27,7 @@ import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.SyncAggregate; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; import tech.pegasys.teku.spec.datastructures.operations.Deposit; @@ -135,6 +136,12 @@ public BeaconBlockBodyBuilder blobKzgCommitments( return this; } + @Override + public BeaconBlockBodyBuilder executionRequests(final ExecutionRequests executionRequests) { + // No ExecutionRequests in phase 0 + return this; + } + protected void validate() { checkNotNull(randaoReveal, "randaoReveal must be specified"); checkNotNull(eth1Data, "eth1Data must be specified"); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/phase0/BeaconBlockBodyPhase0.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/phase0/BeaconBlockBodyPhase0.java index d83699beaf9..a5351c50768 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/phase0/BeaconBlockBodyPhase0.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/phase0/BeaconBlockBodyPhase0.java @@ -42,24 +42,24 @@ public class BeaconBlockBodyPhase0 SszList> implements BeaconBlockBody { - BeaconBlockBodyPhase0(BeaconBlockBodySchemaPhase0 type) { + BeaconBlockBodyPhase0(final BeaconBlockBodySchemaPhase0 type) { super(type); } - BeaconBlockBodyPhase0(BeaconBlockBodySchemaPhase0 type, TreeNode backingNode) { + BeaconBlockBodyPhase0(final BeaconBlockBodySchemaPhase0 type, final TreeNode backingNode) { super(type, backingNode); } BeaconBlockBodyPhase0( - BeaconBlockBodySchemaPhase0 type, - SszSignature randaoReveal, - Eth1Data eth1Data, - SszBytes32 graffiti, - SszList proposerSlashings, - SszList attesterSlashings, - SszList attestations, - SszList deposits, - SszList voluntaryExits) { + final BeaconBlockBodySchemaPhase0 type, + final SszSignature randaoReveal, + final Eth1Data eth1Data, + final SszBytes32 graffiti, + final SszList proposerSlashings, + final SszList attesterSlashings, + final SszList attestations, + final SszList deposits, + final SszList voluntaryExits) { super( type, randaoReveal, diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/phase0/BeaconBlockBodySchemaPhase0.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/phase0/BeaconBlockBodySchemaPhase0.java index 0106ad71053..92651425e3e 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/phase0/BeaconBlockBodySchemaPhase0.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/phase0/BeaconBlockBodySchemaPhase0.java @@ -29,14 +29,14 @@ import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodySchema; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.common.BlockBodyFields; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; -import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing.AttesterSlashingSchema; import tech.pegasys.teku.spec.datastructures.operations.Deposit; import tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing; import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; import tech.pegasys.teku.spec.datastructures.type.SszSignature; import tech.pegasys.teku.spec.datastructures.type.SszSignatureSchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; +import tech.pegasys.teku.spec.schemas.registry.SchemaTypes; public class BeaconBlockBodySchemaPhase0 extends ContainerSchema8< @@ -53,14 +53,14 @@ public class BeaconBlockBodySchemaPhase0 private BeaconBlockBodySchemaPhase0( final String containerName, - NamedSchema randaoRevealSchema, - NamedSchema eth1DataSchema, - NamedSchema graffitiSchema, - NamedSchema> proposerSlashingsSchema, - NamedSchema> attesterSlashingsSchema, - NamedSchema> attestationsSchema, - NamedSchema> depositsSchema, - NamedSchema> voluntaryExitsSchema) { + final NamedSchema randaoRevealSchema, + final NamedSchema eth1DataSchema, + final NamedSchema graffitiSchema, + final NamedSchema> proposerSlashingsSchema, + final NamedSchema> attesterSlashingsSchema, + final NamedSchema> attestationsSchema, + final NamedSchema> depositsSchema, + final NamedSchema> voluntaryExitsSchema) { super( containerName, randaoRevealSchema, @@ -75,8 +75,8 @@ private BeaconBlockBodySchemaPhase0( public static BeaconBlockBodySchemaPhase0 create( final SpecConfig specConfig, - final AttesterSlashingSchema attesterSlashingSchema, - final String containerName) { + final String containerName, + final SchemaRegistry schemaRegistry) { return new BeaconBlockBodySchemaPhase0( containerName, namedSchema(BlockBodyFields.RANDAO_REVEAL, SszSignatureSchema.INSTANCE), @@ -88,11 +88,14 @@ public static BeaconBlockBodySchemaPhase0 create( ProposerSlashing.SSZ_SCHEMA, specConfig.getMaxProposerSlashings())), namedSchema( BlockBodyFields.ATTESTER_SLASHINGS, - SszListSchema.create(attesterSlashingSchema, specConfig.getMaxAttesterSlashings())), + SszListSchema.create( + schemaRegistry.get(SchemaTypes.ATTESTER_SLASHING_SCHEMA), + specConfig.getMaxAttesterSlashings())), namedSchema( BlockBodyFields.ATTESTATIONS, SszListSchema.create( - new AttestationSchema(specConfig), specConfig.getMaxAttestations())), + schemaRegistry.get(SchemaTypes.ATTESTATION_SCHEMA), + specConfig.getMaxAttestations())), namedSchema( BlockBodyFields.DEPOSITS, SszListSchema.create(Deposit.SSZ_SCHEMA, specConfig.getMaxDeposits())), @@ -150,7 +153,7 @@ public LongList getBlindedNodeGeneralizedIndices() { } @Override - public BeaconBlockBodyPhase0 createFromBackingNode(TreeNode node) { + public BeaconBlockBodyPhase0 createFromBackingNode(final TreeNode node) { return new BeaconBlockBodyPhase0(this, node); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/versions/deneb/BlockContentsSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/versions/deneb/BlockContentsSchema.java index f0d0bee0657..5a507439e86 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/versions/deneb/BlockContentsSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/versions/deneb/BlockContentsSchema.java @@ -13,6 +13,9 @@ package tech.pegasys.teku.spec.datastructures.blocks.versions.deneb; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BEACON_BLOCK_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOB_SCHEMA; + import java.util.List; import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema3; @@ -22,12 +25,11 @@ import tech.pegasys.teku.kzg.KZGProof; import tech.pegasys.teku.spec.config.SpecConfigDeneb; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.Blob; -import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSchema; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock; -import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlockSchema; import tech.pegasys.teku.spec.datastructures.blocks.BlockContainerSchema; import tech.pegasys.teku.spec.datastructures.type.SszKZGProof; import tech.pegasys.teku.spec.datastructures.type.SszKZGProofSchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; public class BlockContentsSchema extends ContainerSchema3, SszList> @@ -36,27 +38,20 @@ public class BlockContentsSchema static final SszFieldName FIELD_KZG_PROOFS = () -> "kzg_proofs"; static final SszFieldName FIELD_BLOBS = () -> "blobs"; - BlockContentsSchema( + public BlockContentsSchema( final String containerName, final SpecConfigDeneb specConfig, - final BeaconBlockSchema beaconBlockSchema, - final BlobSchema blobSchema) { + final SchemaRegistry schemaRegistry) { super( containerName, - namedSchema("block", beaconBlockSchema), + namedSchema("block", schemaRegistry.get(BEACON_BLOCK_SCHEMA)), namedSchema( FIELD_KZG_PROOFS, SszListSchema.create(SszKZGProofSchema.INSTANCE, specConfig.getMaxBlobsPerBlock())), namedSchema( - FIELD_BLOBS, SszListSchema.create(blobSchema, specConfig.getMaxBlobsPerBlock()))); - } - - public static BlockContentsSchema create( - final SpecConfigDeneb specConfig, - final BeaconBlockSchema beaconBlockSchema, - final BlobSchema blobSchema, - final String containerName) { - return new BlockContentsSchema(containerName, specConfig, beaconBlockSchema, blobSchema); + FIELD_BLOBS, + SszListSchema.create( + schemaRegistry.get(BLOB_SCHEMA), specConfig.getMaxBlobsPerBlock()))); } public BlockContents create( diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/versions/deneb/SignedBlockContentsSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/versions/deneb/SignedBlockContentsSchema.java index 34f68ca6540..88dde53f8a2 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/versions/deneb/SignedBlockContentsSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blocks/versions/deneb/SignedBlockContentsSchema.java @@ -13,6 +13,9 @@ package tech.pegasys.teku.spec.datastructures.blocks.versions.deneb; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOB_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SIGNED_BEACON_BLOCK_SCHEMA; + import java.util.List; import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema3; @@ -22,12 +25,12 @@ import tech.pegasys.teku.kzg.KZGProof; import tech.pegasys.teku.spec.config.SpecConfigDeneb; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.Blob; -import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSchema; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockSchema; import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockContainerSchema; import tech.pegasys.teku.spec.datastructures.type.SszKZGProof; import tech.pegasys.teku.spec.datastructures.type.SszKZGProofSchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; public class SignedBlockContentsSchema extends ContainerSchema3< @@ -37,28 +40,20 @@ public class SignedBlockContentsSchema static final SszFieldName FIELD_KZG_PROOFS = () -> "kzg_proofs"; static final SszFieldName FIELD_BLOBS = () -> "blobs"; - SignedBlockContentsSchema( + public SignedBlockContentsSchema( final String containerName, final SpecConfigDeneb specConfig, - final SignedBeaconBlockSchema signedBeaconBlockSchema, - final BlobSchema blobSchema) { + final SchemaRegistry schemaRegistry) { super( containerName, - namedSchema("signed_block", signedBeaconBlockSchema), + namedSchema("signed_block", schemaRegistry.get(SIGNED_BEACON_BLOCK_SCHEMA)), namedSchema( FIELD_KZG_PROOFS, SszListSchema.create(SszKZGProofSchema.INSTANCE, specConfig.getMaxBlobsPerBlock())), namedSchema( - FIELD_BLOBS, SszListSchema.create(blobSchema, specConfig.getMaxBlobsPerBlock()))); - } - - public static SignedBlockContentsSchema create( - final SpecConfigDeneb specConfig, - final SignedBeaconBlockSchema signedBeaconBlockSchema, - final BlobSchema blobSchema, - final String containerName) { - return new SignedBlockContentsSchema( - containerName, specConfig, signedBeaconBlockSchema, blobSchema); + FIELD_BLOBS, + SszListSchema.create( + schemaRegistry.get(BLOB_SCHEMA), specConfig.getMaxBlobsPerBlock()))); } public SignedBlockContents create( diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/BlobsBundleSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/BlobsBundleSchema.java index 7110879d5bc..51ba5f4eeef 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/BlobsBundleSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/BlobsBundleSchema.java @@ -13,36 +13,36 @@ package tech.pegasys.teku.spec.datastructures.builder; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOB_KZG_COMMITMENTS_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOB_SCHEMA; + import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema3; import tech.pegasys.teku.infrastructure.ssz.schema.SszListSchema; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; import tech.pegasys.teku.spec.config.SpecConfigDeneb; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.Blob; -import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobKzgCommitmentsSchema; -import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSchema; import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; import tech.pegasys.teku.spec.datastructures.type.SszKZGProof; import tech.pegasys.teku.spec.datastructures.type.SszKZGProofSchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; public class BlobsBundleSchema extends ContainerSchema3< BlobsBundle, SszList, SszList, SszList> { - public BlobsBundleSchema( - final String containerName, - final BlobSchema blobSchema, - final BlobKzgCommitmentsSchema blobKzgCommitmentsSchema, - final SpecConfigDeneb specConfig) { + public BlobsBundleSchema(final SchemaRegistry schemaRegistry, final SpecConfigDeneb specConfig) { super( - containerName, - namedSchema("commitments", blobKzgCommitmentsSchema), + "BlobsBundle", + namedSchema("commitments", schemaRegistry.get(BLOB_KZG_COMMITMENTS_SCHEMA)), namedSchema( "proofs", SszListSchema.create( SszKZGProofSchema.INSTANCE, specConfig.getMaxBlobCommitmentsPerBlock())), namedSchema( - "blobs", SszListSchema.create(blobSchema, specConfig.getMaxBlobCommitmentsPerBlock()))); + "blobs", + SszListSchema.create( + schemaRegistry.get(BLOB_SCHEMA), specConfig.getMaxBlobCommitmentsPerBlock()))); } @SuppressWarnings("unchecked") diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/BuilderBid.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/BuilderBid.java index 2b1cab3dd2e..b0959338a1d 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/BuilderBid.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/BuilderBid.java @@ -19,6 +19,7 @@ import tech.pegasys.teku.infrastructure.ssz.SszContainer; import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; public interface BuilderBid extends SszContainer { @@ -27,6 +28,8 @@ public interface BuilderBid extends SszContainer { Optional> getOptionalBlobKzgCommitments(); + Optional getOptionalExecutionRequests(); + UInt256 getValue(); BLSPublicKey getPublicKey(); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/BuilderBidBuilder.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/BuilderBidBuilder.java index 2b68923909c..16652e504f6 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/BuilderBidBuilder.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/BuilderBidBuilder.java @@ -17,6 +17,7 @@ import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; public interface BuilderBidBuilder { @@ -25,6 +26,8 @@ public interface BuilderBidBuilder { BuilderBidBuilder blobKzgCommitments(SszList blobKzgCommitments); + BuilderBidBuilder executionRequests(ExecutionRequests executionRequests); + BuilderBidBuilder value(UInt256 value); BuilderBidBuilder publicKey(BLSPublicKey publicKey); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/ExecutionPayloadAndBlobsBundleSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/ExecutionPayloadAndBlobsBundleSchema.java index 7f20e4b998b..ac9a3f36845 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/ExecutionPayloadAndBlobsBundleSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/ExecutionPayloadAndBlobsBundleSchema.java @@ -13,24 +13,26 @@ package tech.pegasys.teku.spec.datastructures.builder; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOBS_BUNDLE_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_PAYLOAD_SCHEMA; + import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema2; import tech.pegasys.teku.infrastructure.ssz.schema.SszSchema; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; public class ExecutionPayloadAndBlobsBundleSchema extends ContainerSchema2 implements BuilderPayloadSchema { - public ExecutionPayloadAndBlobsBundleSchema( - final ExecutionPayloadSchema executionPayloadSchema, - final BlobsBundleSchema blobsBundleSchema) { + public ExecutionPayloadAndBlobsBundleSchema(final SchemaRegistry schemaRegistry) { super( "ExecutionPayloadAndBlobsBundle", namedSchema( - "execution_payload", SszSchema.as(ExecutionPayload.class, executionPayloadSchema)), - namedSchema("blobs_bundle", blobsBundleSchema)); + "execution_payload", + SszSchema.as(ExecutionPayload.class, schemaRegistry.get(EXECUTION_PAYLOAD_SCHEMA))), + namedSchema("blobs_bundle", schemaRegistry.get(BLOBS_BUNDLE_SCHEMA))); } @Override diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/SignedBuilderBid.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/SignedBuilderBid.java index d19c6d196b7..af1b35383ab 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/SignedBuilderBid.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/SignedBuilderBid.java @@ -22,7 +22,7 @@ public class SignedBuilderBid extends Container2 implements SszContainer { - SignedBuilderBid(SignedBuilderBidSchema type, TreeNode backingNode) { + SignedBuilderBid(final SignedBuilderBidSchema type, final TreeNode backingNode) { super(type, backingNode); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/SignedBuilderBidSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/SignedBuilderBidSchema.java index c41d1405187..c5f51f6dfad 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/SignedBuilderBidSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/SignedBuilderBidSchema.java @@ -13,6 +13,8 @@ package tech.pegasys.teku.spec.datastructures.builder; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BUILDER_BID_SCHEMA; + import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema2; import tech.pegasys.teku.infrastructure.ssz.schema.SszContainerSchema; @@ -20,16 +22,17 @@ import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; import tech.pegasys.teku.spec.datastructures.type.SszSignature; import tech.pegasys.teku.spec.datastructures.type.SszSignatureSchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; public class SignedBuilderBidSchema extends ContainerSchema2 implements SszContainerSchema { - public SignedBuilderBidSchema( - final String schemaName, final BuilderBidSchema builderBidSchema) { + public SignedBuilderBidSchema(final String schemaName, final SchemaRegistry schemaRegistry) { super( schemaName, - namedSchema("message", SszSchema.as(BuilderBid.class, builderBidSchema)), + namedSchema( + "message", SszSchema.as(BuilderBid.class, schemaRegistry.get(BUILDER_BID_SCHEMA))), namedSchema("signature", SszSignatureSchema.INSTANCE)); } @@ -38,7 +41,7 @@ public SignedBuilderBid create(final BuilderBid message, final BLSSignature sign } @Override - public SignedBuilderBid createFromBackingNode(TreeNode node) { + public SignedBuilderBid createFromBackingNode(final TreeNode node) { return new SignedBuilderBid(this, node); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/SignedValidatorRegistration.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/SignedValidatorRegistration.java index d3eb0a5ff82..ae385e80bd2 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/SignedValidatorRegistration.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/SignedValidatorRegistration.java @@ -21,7 +21,8 @@ public class SignedValidatorRegistration extends Container2 { - SignedValidatorRegistration(SignedValidatorRegistrationSchema type, TreeNode backingNode) { + SignedValidatorRegistration( + final SignedValidatorRegistrationSchema type, final TreeNode backingNode) { super(type, backingNode); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/SignedValidatorRegistrationSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/SignedValidatorRegistrationSchema.java index 70419684f93..44e1cac72b4 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/SignedValidatorRegistrationSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/SignedValidatorRegistrationSchema.java @@ -36,7 +36,7 @@ public SignedValidatorRegistration create( } @Override - public SignedValidatorRegistration createFromBackingNode(TreeNode node) { + public SignedValidatorRegistration createFromBackingNode(final TreeNode node) { return new SignedValidatorRegistration(this, node); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/SignedValidatorRegistrationsSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/SignedValidatorRegistrationsSchema.java index a42326486a6..dccc303f455 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/SignedValidatorRegistrationsSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/SignedValidatorRegistrationsSchema.java @@ -23,12 +23,13 @@ public class SignedValidatorRegistrationsSchema SignedValidatorRegistration, SszList> { public SignedValidatorRegistrationsSchema( - SignedValidatorRegistrationSchema signedValidatorRegistrationSchema, long maxLength) { + final SignedValidatorRegistrationSchema signedValidatorRegistrationSchema, + final long maxLength) { super(signedValidatorRegistrationSchema, maxLength); } @Override - public SszList createFromBackingNode(TreeNode node) { + public SszList createFromBackingNode(final TreeNode node) { return new SszListImpl<>(this, node); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/ValidatorRegistration.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/ValidatorRegistration.java index 60c758c7ca5..56784b04f91 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/ValidatorRegistration.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/ValidatorRegistration.java @@ -24,17 +24,19 @@ public class ValidatorRegistration extends Container4 { + public static final ValidatorRegistrationSchema SSZ_SCHEMA = new ValidatorRegistrationSchema(); - protected ValidatorRegistration(ValidatorRegistrationSchema schema, TreeNode backingNode) { + protected ValidatorRegistration( + final ValidatorRegistrationSchema schema, final TreeNode backingNode) { super(schema, backingNode); } protected ValidatorRegistration( - ValidatorRegistrationSchema schema, - SszByteVector feeRecipient, - SszUInt64 gasLimit, - SszUInt64 timestamp, - SszPublicKey publicKey) { + final ValidatorRegistrationSchema schema, + final SszByteVector feeRecipient, + final SszUInt64 gasLimit, + final SszUInt64 timestamp, + final SszPublicKey publicKey) { super(schema, feeRecipient, gasLimit, timestamp, publicKey); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/ValidatorRegistrationSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/ValidatorRegistrationSchema.java index b58bf3a9797..527c56df90d 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/ValidatorRegistrationSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/ValidatorRegistrationSchema.java @@ -51,7 +51,7 @@ public ValidatorRegistration create( } @Override - public ValidatorRegistration createFromBackingNode(TreeNode node) { + public ValidatorRegistration createFromBackingNode(final TreeNode node) { return new ValidatorRegistration(this, node); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/bellatrix/BuilderBidBellatrix.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/bellatrix/BuilderBidBellatrix.java index 19708164ad9..ca6eaabda44 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/bellatrix/BuilderBidBellatrix.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/bellatrix/BuilderBidBellatrix.java @@ -22,6 +22,7 @@ import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; import tech.pegasys.teku.spec.datastructures.builder.BuilderBid; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; import tech.pegasys.teku.spec.datastructures.type.SszPublicKey; @@ -51,6 +52,11 @@ public Optional> getOptionalBlobKzgCommitments() { return Optional.empty(); } + @Override + public Optional getOptionalExecutionRequests() { + return Optional.empty(); + } + @Override public UInt256 getValue() { return getField1().get(); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/bellatrix/BuilderBidBuilderBellatrix.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/bellatrix/BuilderBidBuilderBellatrix.java index 0ebbbcd70aa..c875389adf0 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/bellatrix/BuilderBidBuilderBellatrix.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/bellatrix/BuilderBidBuilderBellatrix.java @@ -22,6 +22,7 @@ import tech.pegasys.teku.spec.datastructures.builder.BuilderBid; import tech.pegasys.teku.spec.datastructures.builder.BuilderBidBuilder; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; import tech.pegasys.teku.spec.datastructures.type.SszPublicKey; @@ -49,6 +50,11 @@ public BuilderBidBuilder blobKzgCommitments(final SszList blob return this; } + @Override + public BuilderBidBuilder executionRequests(final ExecutionRequests executionRequests) { + return this; + } + @Override public BuilderBidBuilder value(final UInt256 value) { this.value = value; diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/bellatrix/BuilderBidSchemaBellatrix.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/bellatrix/BuilderBidSchemaBellatrix.java index 5b0794521c0..332809233b2 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/bellatrix/BuilderBidSchemaBellatrix.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/bellatrix/BuilderBidSchemaBellatrix.java @@ -13,6 +13,8 @@ package tech.pegasys.teku.spec.datastructures.builder.versions.bellatrix; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_PAYLOAD_HEADER_SCHEMA; + import java.util.function.Consumer; import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema3; import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt256; @@ -23,27 +25,28 @@ import tech.pegasys.teku.spec.datastructures.builder.BuilderBidBuilder; import tech.pegasys.teku.spec.datastructures.builder.BuilderBidSchema; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeaderSchema; import tech.pegasys.teku.spec.datastructures.type.SszPublicKey; import tech.pegasys.teku.spec.datastructures.type.SszPublicKeySchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; public class BuilderBidSchemaBellatrix extends ContainerSchema3 implements BuilderBidSchema { public BuilderBidSchemaBellatrix( - final String containerName, - final ExecutionPayloadHeaderSchema executionPayloadHeaderSchema) { + final String containerName, final SchemaRegistry schemaRegistry) { super( containerName, namedSchema( - "header", SszSchema.as(ExecutionPayloadHeader.class, executionPayloadHeaderSchema)), + "header", + SszSchema.as( + ExecutionPayloadHeader.class, schemaRegistry.get(EXECUTION_PAYLOAD_HEADER_SCHEMA))), namedSchema("value", SszPrimitiveSchemas.UINT256_SCHEMA), namedSchema("pubkey", SszPublicKeySchema.INSTANCE)); } @Override - public BuilderBidBellatrix createFromBackingNode(TreeNode node) { + public BuilderBidBellatrix createFromBackingNode(final TreeNode node) { return new BuilderBidBellatrix(this, node); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/deneb/BuilderBidDenebImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/deneb/BuilderBidDenebImpl.java index 24cbc9540f3..dd0467da195 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/deneb/BuilderBidDenebImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/deneb/BuilderBidDenebImpl.java @@ -13,6 +13,7 @@ package tech.pegasys.teku.spec.datastructures.builder.versions.deneb; +import java.util.Optional; import org.apache.tuweni.units.bigints.UInt256; import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.infrastructure.ssz.SszList; @@ -20,6 +21,7 @@ import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt256; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; import tech.pegasys.teku.spec.datastructures.type.SszPublicKey; @@ -50,6 +52,11 @@ public ExecutionPayloadHeader getHeader() { return getField0(); } + @Override + public Optional getOptionalExecutionRequests() { + return Optional.empty(); + } + @Override public SszList getBlobKzgCommitments() { return getField1(); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/deneb/BuilderBidSchemaDeneb.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/deneb/BuilderBidSchemaDeneb.java index 1b4f9c7749e..5d0ec060a0d 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/deneb/BuilderBidSchemaDeneb.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/deneb/BuilderBidSchemaDeneb.java @@ -13,6 +13,9 @@ package tech.pegasys.teku.spec.datastructures.builder.versions.deneb; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOB_KZG_COMMITMENTS_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_PAYLOAD_HEADER_SCHEMA; + import java.util.function.Consumer; import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema4; @@ -20,15 +23,14 @@ import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; import tech.pegasys.teku.infrastructure.ssz.schema.SszSchema; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; -import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobKzgCommitmentsSchema; import tech.pegasys.teku.spec.datastructures.builder.BuilderBid; import tech.pegasys.teku.spec.datastructures.builder.BuilderBidBuilder; import tech.pegasys.teku.spec.datastructures.builder.BuilderBidSchema; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeaderSchema; import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; import tech.pegasys.teku.spec.datastructures.type.SszPublicKey; import tech.pegasys.teku.spec.datastructures.type.SszPublicKeySchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; public class BuilderBidSchemaDeneb extends ContainerSchema4< @@ -39,15 +41,14 @@ public class BuilderBidSchemaDeneb SszPublicKey> implements BuilderBidSchema { - public BuilderBidSchemaDeneb( - final String containerName, - final ExecutionPayloadHeaderSchema executionPayloadHeaderSchema, - final BlobKzgCommitmentsSchema blobKzgCommitmentsSchema) { + public BuilderBidSchemaDeneb(final String containerName, final SchemaRegistry schemaRegistry) { super( containerName, namedSchema( - "header", SszSchema.as(ExecutionPayloadHeader.class, executionPayloadHeaderSchema)), - namedSchema("blob_kzg_commitments", blobKzgCommitmentsSchema), + "header", + SszSchema.as( + ExecutionPayloadHeader.class, schemaRegistry.get(EXECUTION_PAYLOAD_HEADER_SCHEMA))), + namedSchema("blob_kzg_commitments", schemaRegistry.get(BLOB_KZG_COMMITMENTS_SCHEMA)), namedSchema("value", SszPrimitiveSchemas.UINT256_SCHEMA), namedSchema("pubkey", SszPublicKeySchema.INSTANCE)); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/electra/BuilderBidBuilderElectra.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/electra/BuilderBidBuilderElectra.java new file mode 100644 index 00000000000..6f52613f3ce --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/electra/BuilderBidBuilderElectra.java @@ -0,0 +1,58 @@ +/* + * Copyright Consensys Software Inc., 2023 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.builder.versions.electra; + +import static com.google.common.base.Preconditions.checkNotNull; + +import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt256; +import tech.pegasys.teku.spec.datastructures.builder.BuilderBid; +import tech.pegasys.teku.spec.datastructures.builder.BuilderBidBuilder; +import tech.pegasys.teku.spec.datastructures.builder.versions.deneb.BuilderBidBuilderDeneb; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; +import tech.pegasys.teku.spec.datastructures.type.SszPublicKey; + +public class BuilderBidBuilderElectra extends BuilderBidBuilderDeneb { + + private BuilderBidSchemaElectra schema; + + protected ExecutionRequests executionRequests; + + public BuilderBidBuilderElectra schema(final BuilderBidSchemaElectra schema) { + this.schema = schema; + return this; + } + + @Override + public BuilderBidBuilder executionRequests(final ExecutionRequests executionRequests) { + this.executionRequests = executionRequests; + return this; + } + + @Override + public BuilderBid build() { + return new BuilderBidElectraImpl( + schema, + header, + blobKzgCommitments, + executionRequests, + SszUInt256.of(value), + new SszPublicKey(publicKey)); + } + + @Override + protected void validate() { + super.validate(); + checkNotNull(executionRequests, "executionRequests must be specified"); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/electra/BuilderBidElectra.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/electra/BuilderBidElectra.java new file mode 100644 index 00000000000..a4ca8f3087e --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/electra/BuilderBidElectra.java @@ -0,0 +1,28 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.builder.versions.electra; + +import java.util.Optional; +import tech.pegasys.teku.spec.datastructures.builder.versions.deneb.BuilderBidDeneb; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; + +public interface BuilderBidElectra extends BuilderBidDeneb { + + ExecutionRequests getExecutionRequests(); + + @Override + default Optional getOptionalExecutionRequests() { + return Optional.of(getExecutionRequests()); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/electra/BuilderBidElectraImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/electra/BuilderBidElectraImpl.java new file mode 100644 index 00000000000..9a5d2541d5a --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/electra/BuilderBidElectraImpl.java @@ -0,0 +1,75 @@ +/* + * Copyright Consensys Software Inc., 2023 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.builder.versions.electra; + +import org.apache.tuweni.units.bigints.UInt256; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.infrastructure.ssz.SszList; +import tech.pegasys.teku.infrastructure.ssz.containers.Container5; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt256; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; +import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; +import tech.pegasys.teku.spec.datastructures.type.SszPublicKey; + +public class BuilderBidElectraImpl + extends Container5< + BuilderBidElectraImpl, + ExecutionPayloadHeader, + SszList, + ExecutionRequests, + SszUInt256, + SszPublicKey> + implements BuilderBidElectra { + + BuilderBidElectraImpl(final BuilderBidSchemaElectra schema, final TreeNode backingNode) { + super(schema, backingNode); + } + + public BuilderBidElectraImpl( + final BuilderBidSchemaElectra schema, + final ExecutionPayloadHeader header, + final SszList blobKzgCommitments, + final ExecutionRequests executionRequests, + final SszUInt256 value, + final SszPublicKey publicKey) { + super(schema, header, blobKzgCommitments, executionRequests, value, publicKey); + } + + @Override + public ExecutionPayloadHeader getHeader() { + return getField0(); + } + + @Override + public SszList getBlobKzgCommitments() { + return getField1(); + } + + @Override + public ExecutionRequests getExecutionRequests() { + return getField2(); + } + + @Override + public UInt256 getValue() { + return getField3().get(); + } + + @Override + public BLSPublicKey getPublicKey() { + return getField4().getBLSPublicKey(); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/electra/BuilderBidSchemaElectra.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/electra/BuilderBidSchemaElectra.java new file mode 100644 index 00000000000..0db152239a1 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/builder/versions/electra/BuilderBidSchemaElectra.java @@ -0,0 +1,71 @@ +/* + * Copyright Consensys Software Inc., 2023 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.builder.versions.electra; + +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOB_KZG_COMMITMENTS_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_PAYLOAD_HEADER_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_REQUESTS_SCHEMA; + +import java.util.function.Consumer; +import tech.pegasys.teku.infrastructure.ssz.SszList; +import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema5; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt256; +import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; +import tech.pegasys.teku.infrastructure.ssz.schema.SszSchema; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.spec.datastructures.builder.BuilderBid; +import tech.pegasys.teku.spec.datastructures.builder.BuilderBidBuilder; +import tech.pegasys.teku.spec.datastructures.builder.BuilderBidSchema; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; +import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; +import tech.pegasys.teku.spec.datastructures.type.SszPublicKey; +import tech.pegasys.teku.spec.datastructures.type.SszPublicKeySchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; + +public class BuilderBidSchemaElectra + extends ContainerSchema5< + BuilderBidElectraImpl, + ExecutionPayloadHeader, + SszList, + ExecutionRequests, + SszUInt256, + SszPublicKey> + implements BuilderBidSchema { + + public BuilderBidSchemaElectra(final String containerName, final SchemaRegistry schemaRegistry) { + super( + containerName, + namedSchema( + "header", + SszSchema.as( + ExecutionPayloadHeader.class, schemaRegistry.get(EXECUTION_PAYLOAD_HEADER_SCHEMA))), + namedSchema("blob_kzg_commitments", schemaRegistry.get(BLOB_KZG_COMMITMENTS_SCHEMA)), + namedSchema("execution_requests", schemaRegistry.get(EXECUTION_REQUESTS_SCHEMA)), + namedSchema("value", SszPrimitiveSchemas.UINT256_SCHEMA), + namedSchema("pubkey", SszPublicKeySchema.INSTANCE)); + } + + @Override + public BuilderBidElectraImpl createFromBackingNode(final TreeNode node) { + return new BuilderBidElectraImpl(this, node); + } + + @Override + public BuilderBid createBuilderBid(final Consumer builderConsumer) { + final BuilderBidBuilderElectra builder = new BuilderBidBuilderElectra().schema(this); + builderConsumer.accept(builder); + return builder.build(); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/BlobAndProof.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/BlobAndProof.java new file mode 100644 index 00000000000..8509e4be196 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/BlobAndProof.java @@ -0,0 +1,19 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.execution; + +import tech.pegasys.teku.kzg.KZGProof; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.Blob; + +public record BlobAndProof(Blob blob, KZGProof proof) {} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/BuilderBidOrFallbackData.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/BuilderBidOrFallbackData.java new file mode 100644 index 00000000000..3b418e07a4e --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/BuilderBidOrFallbackData.java @@ -0,0 +1,82 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.execution; + +import com.google.common.base.MoreObjects; +import java.util.Objects; +import java.util.Optional; +import tech.pegasys.teku.spec.datastructures.builder.BuilderBid; + +/** + * Either {@link #builderBid} or {@link #fallbackData} would be present, depending on if builder has + * been used or there has been a local fallback + */ +public class BuilderBidOrFallbackData { + + private final Optional builderBid; + private final Optional fallbackData; + + private BuilderBidOrFallbackData( + final Optional builderBid, final Optional fallbackData) { + this.builderBid = builderBid; + this.fallbackData = fallbackData; + } + + public static BuilderBidOrFallbackData create(final BuilderBid builderBid) { + return new BuilderBidOrFallbackData(Optional.of(builderBid), Optional.empty()); + } + + public static BuilderBidOrFallbackData create(final FallbackData fallbackData) { + return new BuilderBidOrFallbackData(Optional.empty(), Optional.of(fallbackData)); + } + + public Optional getBuilderBid() { + return builderBid; + } + + public Optional getFallbackData() { + return fallbackData; + } + + public FallbackData getFallbackDataRequired() { + return fallbackData.orElseThrow( + () -> new IllegalStateException("FallbackData is not available in " + this)); + } + + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + final BuilderBidOrFallbackData that = (BuilderBidOrFallbackData) o; + return Objects.equals(builderBid, that.builderBid) + && Objects.equals(fallbackData, that.fallbackData); + } + + @Override + public int hashCode() { + return Objects.hash(builderBid, fallbackData); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(this) + .add("builderBid", builderBid) + .add("fallbackData", fallbackData) + .toString(); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/BuilderPayloadOrFallbackData.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/BuilderPayloadOrFallbackData.java new file mode 100644 index 00000000000..462517c7439 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/BuilderPayloadOrFallbackData.java @@ -0,0 +1,81 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.execution; + +import com.google.common.base.MoreObjects; +import java.util.Objects; +import java.util.Optional; +import tech.pegasys.teku.spec.datastructures.builder.BuilderPayload; + +/** + * Either {@link #builderPayload} or {@link #fallbackData} would be present, depending on if builder + * has been used or there has been a local fallback + */ +public class BuilderPayloadOrFallbackData { + private final Optional builderPayload; + private final Optional fallbackData; + + private BuilderPayloadOrFallbackData( + final Optional builderPayload, final Optional fallbackData) { + this.builderPayload = builderPayload; + this.fallbackData = fallbackData; + } + + public static BuilderPayloadOrFallbackData create(final BuilderPayload builderPayload) { + return new BuilderPayloadOrFallbackData(Optional.ofNullable(builderPayload), Optional.empty()); + } + + public static BuilderPayloadOrFallbackData create(final FallbackData fallbackData) { + return new BuilderPayloadOrFallbackData(Optional.empty(), Optional.ofNullable(fallbackData)); + } + + public Optional getBuilderPayload() { + return builderPayload; + } + + public Optional getFallbackData() { + return fallbackData; + } + + public FallbackData getFallbackDataRequired() { + return fallbackData.orElseThrow( + () -> new IllegalStateException("FallbackData is not available in " + this)); + } + + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + final BuilderPayloadOrFallbackData that = (BuilderPayloadOrFallbackData) o; + return Objects.equals(builderPayload, that.builderPayload) + && Objects.equals(fallbackData, that.fallbackData); + } + + @Override + public int hashCode() { + return Objects.hash(builderPayload, fallbackData); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(this) + .add("builderPayload", builderPayload) + .add("fallbackData", fallbackData) + .toString(); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ClientVersion.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ClientVersion.java index c2e77e36e3e..6496f755e39 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ClientVersion.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ClientVersion.java @@ -18,6 +18,5 @@ public record ClientVersion(String code, String name, String version, Bytes4 commit) { public static final String TEKU_CLIENT_CODE = "TK"; - - public static final ClientVersion UNKNOWN = new ClientVersion("NA", "", "", Bytes4.ZERO); + public static final String UNKNOWN_CLIENT_CODE = "NA"; } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionPayload.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionPayload.java index bcf3dc3656f..ff34555f82b 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionPayload.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionPayload.java @@ -25,7 +25,6 @@ import tech.pegasys.teku.spec.datastructures.execution.versions.capella.ExecutionPayloadCapella; import tech.pegasys.teku.spec.datastructures.execution.versions.capella.Withdrawal; import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadDeneb; -import tech.pegasys.teku.spec.datastructures.execution.versions.eip7594.ExecutionPayloadEip7594; public interface ExecutionPayload extends ExecutionPayloadSummary, SszContainer, BuilderPayload { @@ -57,10 +56,6 @@ default Optional toVersionDeneb() { return Optional.empty(); } - default Optional toVersionEip7594() { - return Optional.empty(); - } - @Override default ExecutionPayload getExecutionPayload() { return this; diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionPayloadHeader.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionPayloadHeader.java index ba20035c13c..6a0a11829bd 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionPayloadHeader.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionPayloadHeader.java @@ -19,7 +19,6 @@ import tech.pegasys.teku.spec.datastructures.execution.versions.bellatrix.ExecutionPayloadHeaderBellatrix; import tech.pegasys.teku.spec.datastructures.execution.versions.capella.ExecutionPayloadHeaderCapella; import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadHeaderDeneb; -import tech.pegasys.teku.spec.datastructures.execution.versions.eip7594.ExecutionPayloadHeaderEip7594; public interface ExecutionPayloadHeader extends ExecutionPayloadSummary, SszContainer { @@ -38,8 +37,4 @@ default Optional toVersionCapella() { default Optional toVersionDeneb() { return Optional.empty(); } - - default Optional toVersionEip7594() { - return Optional.empty(); - } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionPayloadHeaderSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionPayloadHeaderSchema.java index 6ff1c819864..6afec32ce6c 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionPayloadHeaderSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionPayloadHeaderSchema.java @@ -17,6 +17,9 @@ import java.util.function.Consumer; import tech.pegasys.teku.infrastructure.ssz.schema.SszContainerSchema; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.spec.datastructures.execution.versions.bellatrix.ExecutionPayloadHeaderSchemaBellatrix; +import tech.pegasys.teku.spec.datastructures.execution.versions.capella.ExecutionPayloadHeaderSchemaCapella; +import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadHeaderSchemaDeneb; public interface ExecutionPayloadHeaderSchema extends SszContainerSchema { @@ -37,4 +40,16 @@ public interface ExecutionPayloadHeaderSchema ExecutionPayloadHeader createExecutionPayloadHeader( Consumer builderConsumer); + + default ExecutionPayloadHeaderSchemaBellatrix toVersionBellatrixRequired() { + throw new UnsupportedOperationException("Not a Bellatrix schema"); + } + + default ExecutionPayloadHeaderSchemaCapella toVersionCapellaRequired() { + throw new UnsupportedOperationException("Not a Capella schema"); + } + + default ExecutionPayloadHeaderSchemaDeneb toVersionDenebRequired() { + throw new UnsupportedOperationException("Not a Deneb schema"); + } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionPayloadResult.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionPayloadResult.java index 930d446f150..edab3ab3196 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionPayloadResult.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionPayloadResult.java @@ -13,56 +13,104 @@ package tech.pegasys.teku.spec.datastructures.execution; -import static com.google.common.base.Preconditions.checkArgument; - import com.google.common.base.MoreObjects; import java.util.Objects; import java.util.Optional; import org.apache.tuweni.units.bigints.UInt256; import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.spec.datastructures.builder.BuilderBid; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; +/** + * In non-blinded flow, {@link #getPayloadResponseFuture} will be present. + * + *

In blinded flow, {@link #builderBidOrFallbackDataFuture} would be present. + */ public class ExecutionPayloadResult { private final ExecutionPayloadContext executionPayloadContext; - private final Optional> executionPayloadFuture; - private final Optional>> blobsBundleFuture; - private final Optional> headerWithFallbackDataFuture; - private final Optional> executionPayloadValueFuture; + private final Optional> getPayloadResponseFuture; + private final Optional> builderBidOrFallbackDataFuture; - public ExecutionPayloadResult( + private ExecutionPayloadResult( final ExecutionPayloadContext executionPayloadContext, - final Optional> executionPayloadFuture, - final Optional>> blobsBundleFuture, - final Optional> headerWithFallbackDataFuture, - final Optional> executionPayloadValueFuture) { - checkArgument( - executionPayloadFuture.isPresent() != headerWithFallbackDataFuture.isPresent(), - "Either executionPayloadFuture or headerWithFallbackDataFuture must be present"); + final Optional> getPayloadResponseFuture, + final Optional> builderBidOrFallbackDataFuture) { this.executionPayloadContext = executionPayloadContext; - this.executionPayloadFuture = executionPayloadFuture; - this.blobsBundleFuture = blobsBundleFuture; - this.headerWithFallbackDataFuture = headerWithFallbackDataFuture; - this.executionPayloadValueFuture = executionPayloadValueFuture; + this.getPayloadResponseFuture = getPayloadResponseFuture; + this.builderBidOrFallbackDataFuture = builderBidOrFallbackDataFuture; + } + + public static ExecutionPayloadResult createForLocalFlow( + final ExecutionPayloadContext executionPayloadContext, + final SafeFuture getPayloadResponseFuture) { + return new ExecutionPayloadResult( + executionPayloadContext, Optional.of(getPayloadResponseFuture), Optional.empty()); + } + + public static ExecutionPayloadResult createForBuilderFlow( + final ExecutionPayloadContext executionPayloadContext, + final SafeFuture builderBidOrFallbackDataFuture) { + return new ExecutionPayloadResult( + executionPayloadContext, Optional.empty(), Optional.of(builderBidOrFallbackDataFuture)); } public ExecutionPayloadContext getExecutionPayloadContext() { return executionPayloadContext; } - public Optional> getExecutionPayloadFuture() { - return executionPayloadFuture; + public Optional> getExecutionPayloadFutureFromLocalFlow() { + return getPayloadResponseFuture.map( + getPayloadResponse -> + getPayloadResponse.thenApply(GetPayloadResponse::getExecutionPayload)); + } + + public Optional>> getBlobsBundleFutureFromLocalFlow() { + return getPayloadResponseFuture.map( + getPayloadResponse -> getPayloadResponse.thenApply(GetPayloadResponse::getBlobsBundle)); + } + + public Optional>> + getExecutionRequestsFutureFromLocalFlow() { + return getPayloadResponseFuture.map( + getPayloadResponse -> + getPayloadResponse.thenApply(GetPayloadResponse::getExecutionRequests)); + } + + public Optional> getBuilderBidOrFallbackDataFuture() { + return builderBidOrFallbackDataFuture; } - public Optional>> getBlobsBundleFuture() { - return blobsBundleFuture; + /** + * @return the value from the local payload, the builder bid or the local fallback payload + */ + public SafeFuture getExecutionPayloadValueFuture() { + return getPayloadResponseFuture + .map( + getPayloadResponse -> + getPayloadResponse.thenApply(GetPayloadResponse::getExecutionPayloadValue)) + .orElseGet(this::getExecutionPayloadValueFutureFromBuilderFlow); } - public Optional> getHeaderWithFallbackDataFuture() { - return headerWithFallbackDataFuture; + public boolean isFromLocalFlow() { + return getPayloadResponseFuture.isPresent(); } - public Optional> getExecutionPayloadValueFuture() { - return executionPayloadValueFuture; + private SafeFuture getExecutionPayloadValueFutureFromBuilderFlow() { + return builderBidOrFallbackDataFuture + .orElseThrow() + .thenApply( + builderBidOrFallbackData -> + builderBidOrFallbackData + .getBuilderBid() + // from the builder bid + .map(BuilderBid::getValue) + // from the local fallback + .orElseGet( + () -> + builderBidOrFallbackData + .getFallbackDataRequired() + .getExecutionPayloadValue())); } @Override @@ -75,30 +123,22 @@ public boolean equals(final Object o) { } final ExecutionPayloadResult that = (ExecutionPayloadResult) o; return Objects.equals(executionPayloadContext, that.executionPayloadContext) - && Objects.equals(executionPayloadFuture, that.executionPayloadFuture) - && Objects.equals(blobsBundleFuture, that.blobsBundleFuture) - && Objects.equals(headerWithFallbackDataFuture, that.headerWithFallbackDataFuture) - && Objects.equals(executionPayloadValueFuture, that.executionPayloadValueFuture); + && Objects.equals(getPayloadResponseFuture, that.getPayloadResponseFuture) + && Objects.equals(builderBidOrFallbackDataFuture, that.builderBidOrFallbackDataFuture); } @Override public int hashCode() { return Objects.hash( - executionPayloadContext, - executionPayloadFuture, - blobsBundleFuture, - headerWithFallbackDataFuture, - executionPayloadValueFuture); + executionPayloadContext, getPayloadResponseFuture, builderBidOrFallbackDataFuture); } @Override public String toString() { return MoreObjects.toStringHelper(this) .add("executionPayloadContext", executionPayloadContext) - .add("executionPayloadFuture", executionPayloadFuture) - .add("blobsBundleFuture", blobsBundleFuture) - .add("headerWithFallbackDataFuture", headerWithFallbackDataFuture) - .add("executionPayloadValueFuture", executionPayloadValueFuture) + .add("getPayloadResponseFuture", getPayloadResponseFuture) + .add("builderBidOrFallbackDataFuture", builderBidOrFallbackDataFuture) .toString(); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionPayloadSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionPayloadSchema.java index a7fb9238aa5..88bf465c217 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionPayloadSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionPayloadSchema.java @@ -20,8 +20,17 @@ import tech.pegasys.teku.infrastructure.ssz.schema.SszListSchema; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; import tech.pegasys.teku.spec.datastructures.builder.BuilderPayloadSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.bellatrix.ExecutionPayloadSchemaBellatrix; +import tech.pegasys.teku.spec.datastructures.execution.versions.capella.ExecutionPayloadSchemaCapella; import tech.pegasys.teku.spec.datastructures.execution.versions.capella.Withdrawal; import tech.pegasys.teku.spec.datastructures.execution.versions.capella.WithdrawalSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadSchemaDeneb; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequestSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequestSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequestSchema; public interface ExecutionPayloadSchema extends SszContainerSchema, BuilderPayloadSchema { @@ -35,7 +44,34 @@ public interface ExecutionPayloadSchema WithdrawalSchema getWithdrawalSchemaRequired(); + SszListSchema> + getDepositRequestsSchemaRequired(); + + DepositRequestSchema getDepositRequestSchemaRequired(); + + SszListSchema> + getWithdrawalRequestsSchemaRequired(); + + WithdrawalRequestSchema getWithdrawalRequestSchemaRequired(); + + ConsolidationRequestSchema getConsolidationRequestSchemaRequired(); + + SszListSchema> + getConsolidationRequestsSchemaRequired(); + LongList getBlindedNodeGeneralizedIndices(); ExecutionPayload createExecutionPayload(Consumer builderConsumer); + + default ExecutionPayloadSchemaBellatrix toVersionBellatrixRequired() { + throw new UnsupportedOperationException("Not a Bellatrix schema"); + } + + default ExecutionPayloadSchemaCapella toVersionCapellaRequired() { + throw new UnsupportedOperationException("Not a Capella schema"); + } + + default ExecutionPayloadSchemaDeneb toVersionDenebRequired() { + throw new UnsupportedOperationException("Not a Deneb schema"); + } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionRequestsBuilder.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionRequestsBuilder.java new file mode 100644 index 00000000000..c0295d571d7 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionRequestsBuilder.java @@ -0,0 +1,31 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.execution; + +import java.util.List; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequest; + +public interface ExecutionRequestsBuilder { + + ExecutionRequestsBuilder deposits(List deposits); + + ExecutionRequestsBuilder withdrawals(List withdrawals); + + ExecutionRequestsBuilder consolidations(List consolidations); + + ExecutionRequests build(); +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExpectedWithdrawals.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExpectedWithdrawals.java new file mode 100644 index 00000000000..d839ba747de --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/ExpectedWithdrawals.java @@ -0,0 +1,380 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.execution; + +import static tech.pegasys.teku.spec.config.SpecConfig.FAR_FUTURE_EPOCH; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.apache.tuweni.bytes.Bytes; +import tech.pegasys.teku.infrastructure.bytes.Bytes20; +import tech.pegasys.teku.infrastructure.ssz.SszList; +import tech.pegasys.teku.infrastructure.ssz.collections.SszUInt64List; +import tech.pegasys.teku.infrastructure.ssz.schema.SszListSchema; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.config.SpecConfigCapella; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.datastructures.execution.versions.capella.Withdrawal; +import tech.pegasys.teku.spec.datastructures.execution.versions.capella.WithdrawalSchema; +import tech.pegasys.teku.spec.datastructures.state.Validator; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.MutableBeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.capella.BeaconStateCapella; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.capella.MutableBeaconStateCapella; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.BeaconStateElectra; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.MutableBeaconStateElectra; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingPartialWithdrawal; +import tech.pegasys.teku.spec.logic.common.helpers.BeaconStateMutators; +import tech.pegasys.teku.spec.logic.common.helpers.MiscHelpers; +import tech.pegasys.teku.spec.logic.common.helpers.Predicates; +import tech.pegasys.teku.spec.logic.common.statetransition.exceptions.BlockProcessingException; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.MiscHelpersElectra; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.PredicatesElectra; +import tech.pegasys.teku.spec.schemas.SchemaDefinitions; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsCapella; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; + +public class ExpectedWithdrawals { + private static final Logger LOG = LogManager.getLogger(); + public static final ExpectedWithdrawals NOOP = new ExpectedWithdrawals(List.of(), 0); + private final List withdrawalList; + private Optional> maybeWithdrawalsSszList = Optional.empty(); + private final int partialWithdrawalCount; + + private ExpectedWithdrawals( + final List withdrawalList, final int partialWithdrawalCount) { + LOG.debug( + "Expected withdrawals created with withdrawals list size {}, partials {}", + withdrawalList == null ? -1 : withdrawalList.size(), + partialWithdrawalCount); + this.withdrawalList = withdrawalList; + this.partialWithdrawalCount = partialWithdrawalCount; + } + + private ExpectedWithdrawals( + final List withdrawalList, + final int partialWithdrawalCount, + final SchemaDefinitionsCapella schemaDefinitions) { + this.withdrawalList = withdrawalList; + this.partialWithdrawalCount = partialWithdrawalCount; + LOG.debug( + "Expected withdrawals created with withdrawals list size {}, partials {}, schema definition class: {}", + withdrawalList == null ? -1 : withdrawalList.size(), + partialWithdrawalCount, + schemaDefinitions.getClass()); + + getExpectedWithdrawalsSszList(schemaDefinitions); + } + + public static ExpectedWithdrawals create( + final BeaconState preState, + final SchemaDefinitions schemaDefinitions, + final MiscHelpers miscHelpers, + final SpecConfig specConfig, + final Predicates predicates) { + + if (preState.toVersionElectra().isPresent()) { + return createFromElectraState( + BeaconStateElectra.required(preState), + SchemaDefinitionsElectra.required(schemaDefinitions), + MiscHelpersElectra.required(miscHelpers), + SpecConfigElectra.required(specConfig), + PredicatesElectra.required(predicates)); + } else if (preState.toVersionCapella().isPresent()) { + return createFromCapellaState( + BeaconStateCapella.required(preState), + SchemaDefinitionsCapella.required(schemaDefinitions), + miscHelpers, + SpecConfigCapella.required(specConfig), + predicates); + } + + return NOOP; + } + + private static ExpectedWithdrawals createFromCapellaState( + final BeaconStateCapella preState, + final SchemaDefinitionsCapella schemaDefinitionsCapella, + final MiscHelpers miscHelpers, + final SpecConfigCapella specConfigCapella, + final Predicates predicates) { + final List capellaWithdrawals = + getExpectedWithdrawals( + preState, + schemaDefinitionsCapella, + miscHelpers, + specConfigCapella, + predicates, + new ArrayList<>()); + return new ExpectedWithdrawals(capellaWithdrawals, 0, schemaDefinitionsCapella); + } + + private static ExpectedWithdrawals createFromElectraState( + final BeaconStateElectra preState, + final SchemaDefinitionsElectra schemaDefinitions, + final MiscHelpersElectra miscHelpers, + final SpecConfigElectra specConfig, + final PredicatesElectra predicates) { + final WithdrawalSummary expectedPendingPartialWithdrawals = + getPendingPartialWithdrawals(preState, schemaDefinitions, miscHelpers, specConfig); + final List partialPendingWithdrawals = + expectedPendingPartialWithdrawals.withdrawalList(); + final int partialWithdrawalsCount = expectedPendingPartialWithdrawals.partialWithdrawalCount(); + final List withdrawals = + getExpectedWithdrawals( + preState, + schemaDefinitions, + miscHelpers, + specConfig, + predicates, + partialPendingWithdrawals); + return new ExpectedWithdrawals(withdrawals, partialWithdrawalsCount, schemaDefinitions); + } + + public List getWithdrawalList() { + return withdrawalList; + } + + public int getPartialWithdrawalCount() { + return partialWithdrawalCount; + } + + private static WithdrawalSummary getPendingPartialWithdrawals( + final BeaconStateElectra preState, + final SchemaDefinitionsElectra schemaDefinitions, + final MiscHelpersElectra miscHelpers, + final SpecConfigElectra specConfig) { + final UInt64 epoch = miscHelpers.computeEpochAtSlot(preState.getSlot()); + final int maxPendingPartialWithdrawals = specConfig.getMaxPendingPartialsPerWithdrawalsSweep(); + final List partialWithdrawals = new ArrayList<>(); + final SszList pendingPartialWithdrawals = + preState.getPendingPartialWithdrawals(); + int partialWithdrawalsCount = 0; + UInt64 withdrawalIndex = preState.getNextWithdrawalIndex(); + + for (int i = 0; i < pendingPartialWithdrawals.size() && i < maxPendingPartialWithdrawals; i++) { + final PendingPartialWithdrawal pendingPartialWithdrawal = pendingPartialWithdrawals.get(i); + if (pendingPartialWithdrawal.getWithdrawableEpoch().isGreaterThan(epoch)) { + break; + } + final Validator validator = preState.getValidators().get(pendingPartialWithdrawal.getIndex()); + final boolean hasSufficientBalance = + validator + .getEffectiveBalance() + .isGreaterThanOrEqualTo(specConfig.getMinActivationBalance()); + final UInt64 validatorBalance = + preState.getBalances().get(pendingPartialWithdrawal.getIndex()).get(); + final boolean hasExcessBalance = + validatorBalance.isGreaterThan(specConfig.getMinActivationBalance()); + if (validator.getExitEpoch().equals(FAR_FUTURE_EPOCH) + && hasSufficientBalance + && hasExcessBalance) { + final UInt64 withdrawableBalance = + pendingPartialWithdrawal + .getAmount() + .min(validatorBalance.minusMinZero(specConfig.getMinActivationBalance())); + partialWithdrawals.add( + schemaDefinitions + .getWithdrawalSchema() + .create( + withdrawalIndex, + UInt64.valueOf(pendingPartialWithdrawal.getIndex()), + new Bytes20(validator.getWithdrawalCredentials().slice(12)), + withdrawableBalance)); + withdrawalIndex = withdrawalIndex.increment(); + } + partialWithdrawalsCount++; + } + return new WithdrawalSummary(partialWithdrawals, partialWithdrawalsCount); + } + + // get_expected_withdrawals + private static List getExpectedWithdrawals( + final BeaconStateCapella preState, + final SchemaDefinitionsCapella schemaDefinitionsCapella, + final MiscHelpers miscHelpers, + final SpecConfigCapella specConfigCapella, + final Predicates predicates, + final List partialWithdrawals) { + final List expectedWithdrawals = partialWithdrawals; + final WithdrawalSchema withdrawalSchema = schemaDefinitionsCapella.getWithdrawalSchema(); + final UInt64 epoch = miscHelpers.computeEpochAtSlot(preState.getSlot()); + final SszList validators = preState.getValidators(); + final SszUInt64List balances = preState.getBalances(); + final int validatorCount = validators.size(); + final int maxWithdrawalsPerPayload = specConfigCapella.getMaxWithdrawalsPerPayload(); + final int maxValidatorsPerWithdrawalsSweep = + specConfigCapella.getMaxValidatorsPerWithdrawalSweep(); + final int bound = Math.min(validatorCount, maxValidatorsPerWithdrawalsSweep); + + UInt64 withdrawalIndex = + partialWithdrawals.isEmpty() + ? preState.getNextWithdrawalIndex() + : nextWithdrawalAfter(partialWithdrawals); + int validatorIndex = preState.getNextWithdrawalValidatorIndex().intValue(); + + for (int i = 0; i < bound; i++) { + final Validator validator = validators.get(validatorIndex); + if (predicates.hasExecutionWithdrawalCredential(validator)) { + final UInt64 balance = balances.get(validatorIndex).get(); + + if (predicates.isFullyWithdrawableValidatorCredentialsChecked(validator, balance, epoch)) { + expectedWithdrawals.add( + withdrawalSchema.create( + withdrawalIndex, + UInt64.valueOf(validatorIndex), + new Bytes20(validator.getWithdrawalCredentials().slice(12)), + balance)); + withdrawalIndex = withdrawalIndex.increment(); + } else if (predicates.isPartiallyWithdrawableValidatorEth1CredentialsChecked( + validator, balance)) { + expectedWithdrawals.add( + withdrawalSchema.create( + withdrawalIndex, + UInt64.valueOf(validatorIndex), + new Bytes20(validator.getWithdrawalCredentials().slice(12)), + balance.minusMinZero(miscHelpers.getMaxEffectiveBalance(validator)))); + withdrawalIndex = withdrawalIndex.increment(); + } + + if (expectedWithdrawals.size() == maxWithdrawalsPerPayload) { + break; + } + } + + validatorIndex = (validatorIndex + 1) % validatorCount; + } + + return expectedWithdrawals; + } + + public void processWithdrawals( + final MutableBeaconState genericState, + final ExecutionPayloadSummary payloadSummary, + final SchemaDefinitionsCapella schemaDefinitionsCapella, + final BeaconStateMutators beaconStateMutators, + final SpecConfigCapella specConfigCapella) + throws BlockProcessingException { + final SszList expectedWithdrawals = + getExpectedWithdrawalsSszList(schemaDefinitionsCapella); + + assertWithdrawalsInExecutionPayloadMatchExpected(payloadSummary, expectedWithdrawals); + + processWithdrawalsUnchecked( + genericState, schemaDefinitionsCapella, beaconStateMutators, specConfigCapella); + } + + void processWithdrawalsUnchecked( + final MutableBeaconState genericState, + final SchemaDefinitionsCapella schemaDefinitionsCapella, + final BeaconStateMutators beaconStateMutators, + final SpecConfigCapella specConfigCapella) { + final MutableBeaconStateCapella state = MutableBeaconStateCapella.required(genericState); + final SszList expectedWithdrawals = + getExpectedWithdrawalsSszList(schemaDefinitionsCapella); + + for (int i = 0; i < expectedWithdrawals.size(); i++) { + final Withdrawal withdrawal = expectedWithdrawals.get(i); + beaconStateMutators.decreaseBalance( + state, withdrawal.getValidatorIndex().intValue(), withdrawal.getAmount()); + } + + if (partialWithdrawalCount > 0) { + // new in electra + reducePendingWithdrawals(MutableBeaconStateElectra.required(state)); + } + + final int validatorCount = genericState.getValidators().size(); + final int maxWithdrawalsPerPayload = specConfigCapella.getMaxWithdrawalsPerPayload(); + final int maxValidatorsPerWithdrawalsSweep = + specConfigCapella.getMaxValidatorsPerWithdrawalSweep(); + if (!expectedWithdrawals.isEmpty()) { + final Withdrawal latestWithdrawal = expectedWithdrawals.get(expectedWithdrawals.size() - 1); + state.setNextWithdrawalIndex(latestWithdrawal.getIndex().increment()); + } + + if (expectedWithdrawals.size() == maxWithdrawalsPerPayload) { + // Update the next validator index to start the next withdrawal sweep + final Withdrawal latestWithdrawal = expectedWithdrawals.get(expectedWithdrawals.size() - 1); + final int nextWithdrawalValidatorIndex = latestWithdrawal.getValidatorIndex().intValue() + 1; + state.setNextWithdrawalValidatorIndex( + UInt64.valueOf(nextWithdrawalValidatorIndex % validatorCount)); + } else { + // Advance sweep by the max length of the sweep if there was not a full set of withdrawals + final int nextWithdrawalValidatorIndex = + state.getNextWithdrawalValidatorIndex().intValue() + maxValidatorsPerWithdrawalsSweep; + state.setNextWithdrawalValidatorIndex( + UInt64.valueOf(nextWithdrawalValidatorIndex % validatorCount)); + } + } + + private SszList getExpectedWithdrawalsSszList( + final SchemaDefinitionsCapella schemaDefinitions) { + if (maybeWithdrawalsSszList.isEmpty()) { + maybeWithdrawalsSszList = + Optional.of( + schemaDefinitions + .getExecutionPayloadSchema() + .getWithdrawalsSchemaRequired() + .createFromElements(withdrawalList)); + } + return maybeWithdrawalsSszList.get(); + } + + private void reducePendingWithdrawals(final MutableBeaconStateElectra state) { + final SszListSchema schema = + state.getPendingPartialWithdrawals().getSchema(); + if (state.getPendingPartialWithdrawals().size() == partialWithdrawalCount) { + state.setPendingPartialWithdrawals(schema.createFromElements(List.of())); + } else { + final List pendingPartialWithdrawals = + state.getPendingPartialWithdrawals().asList(); + state.setPendingPartialWithdrawals( + schema.createFromElements( + pendingPartialWithdrawals.subList( + partialWithdrawalCount, pendingPartialWithdrawals.size()))); + } + } + + private static void assertWithdrawalsInExecutionPayloadMatchExpected( + final ExecutionPayloadSummary payloadSummary, final SszList expectedWithdrawals) + throws BlockProcessingException { + // the spec does an element-to-element comparison but Teku is comparing the hash of the tree + if (payloadSummary.getOptionalWithdrawalsRoot().isEmpty() + || !expectedWithdrawals + .hashTreeRoot() + .equals(payloadSummary.getOptionalWithdrawalsRoot().get())) { + final String msg = + String.format( + "Withdrawals in execution payload are different from expected (expected withdrawals root is %s but was " + + "%s)", + expectedWithdrawals.hashTreeRoot(), + payloadSummary + .getOptionalWithdrawalsRoot() + .map(Bytes::toHexString) + .orElse("MISSING")); + throw new BlockProcessingException(msg); + } + } + + private static UInt64 nextWithdrawalAfter(final List partialWithdrawals) { + return partialWithdrawals.getLast().getIndex().increment(); + } + + public record WithdrawalSummary(List withdrawalList, int partialWithdrawalCount) {} +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/FallbackData.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/FallbackData.java index 5a72345cfce..085dec5d35a 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/FallbackData.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/FallbackData.java @@ -16,34 +16,33 @@ import com.google.common.base.MoreObjects; import java.util.Objects; import java.util.Optional; +import org.apache.tuweni.units.bigints.UInt256; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; public class FallbackData { - private final ExecutionPayload executionPayload; - private final Optional blobsBundle; + private final GetPayloadResponse getPayloadResponse; private final FallbackReason reason; - public FallbackData(final ExecutionPayload executionPayload, final FallbackReason reason) { - this.executionPayload = executionPayload; - this.blobsBundle = Optional.empty(); - this.reason = reason; - } - - public FallbackData( - final ExecutionPayload executionPayload, - final Optional blobsBundle, - final FallbackReason reason) { - this.executionPayload = executionPayload; - this.blobsBundle = blobsBundle; + public FallbackData(final GetPayloadResponse getPayloadResponse, final FallbackReason reason) { + this.getPayloadResponse = getPayloadResponse; this.reason = reason; } public ExecutionPayload getExecutionPayload() { - return executionPayload; + return getPayloadResponse.getExecutionPayload(); } public Optional getBlobsBundle() { - return blobsBundle; + return getPayloadResponse.getBlobsBundle(); + } + + public UInt256 getExecutionPayloadValue() { + return getPayloadResponse.getExecutionPayloadValue(); + } + + public Optional getExecutionRequests() { + return getPayloadResponse.getExecutionRequests(); } public FallbackReason getReason() { @@ -59,21 +58,18 @@ public boolean equals(final Object o) { return false; } final FallbackData that = (FallbackData) o; - return Objects.equals(executionPayload, that.executionPayload) - && Objects.equals(blobsBundle, that.blobsBundle) - && reason == that.reason; + return Objects.equals(getPayloadResponse, that.getPayloadResponse) && reason == that.reason; } @Override public int hashCode() { - return Objects.hash(executionPayload, blobsBundle, reason); + return Objects.hash(getPayloadResponse, reason); } @Override public String toString() { return MoreObjects.toStringHelper(this) - .add("executionPayload", executionPayload) - .add("blobsBundle", blobsBundle) + .add("getPayloadResponse", getPayloadResponse) .add("reason", reason) .toString(); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/GetPayloadResponse.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/GetPayloadResponse.java index 49076414a51..52ef3bb38ac 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/GetPayloadResponse.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/GetPayloadResponse.java @@ -17,6 +17,7 @@ import java.util.Objects; import java.util.Optional; import org.apache.tuweni.units.bigints.UInt256; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; public class GetPayloadResponse { @@ -24,12 +25,14 @@ public class GetPayloadResponse { private final UInt256 executionPayloadValue; private final Optional blobsBundle; private final boolean shouldOverrideBuilder; + private final Optional executionRequests; public GetPayloadResponse(final ExecutionPayload executionPayload) { this.executionPayload = executionPayload; this.executionPayloadValue = UInt256.ZERO; this.blobsBundle = Optional.empty(); this.shouldOverrideBuilder = false; + this.executionRequests = Optional.empty(); } public GetPayloadResponse( @@ -38,6 +41,7 @@ public GetPayloadResponse( this.executionPayloadValue = executionPayloadValue; this.blobsBundle = Optional.empty(); this.shouldOverrideBuilder = false; + this.executionRequests = Optional.empty(); } public GetPayloadResponse( @@ -49,6 +53,20 @@ public GetPayloadResponse( this.executionPayloadValue = executionPayloadValue; this.blobsBundle = Optional.of(blobsBundle); this.shouldOverrideBuilder = shouldOverrideBuilder; + this.executionRequests = Optional.empty(); + } + + public GetPayloadResponse( + final ExecutionPayload executionPayload, + final UInt256 executionPayloadValue, + final BlobsBundle blobsBundle, + final boolean shouldOverrideBuilder, + final ExecutionRequests executionRequests) { + this.executionPayload = executionPayload; + this.executionPayloadValue = executionPayloadValue; + this.blobsBundle = Optional.of(blobsBundle); + this.shouldOverrideBuilder = shouldOverrideBuilder; + this.executionRequests = Optional.of(executionRequests); } public ExecutionPayload getExecutionPayload() { @@ -67,6 +85,10 @@ public boolean getShouldOverrideBuilder() { return shouldOverrideBuilder; } + public Optional getExecutionRequests() { + return executionRequests; + } + @Override public boolean equals(final Object o) { if (this == o) { @@ -79,13 +101,18 @@ public boolean equals(final Object o) { return shouldOverrideBuilder == that.shouldOverrideBuilder && Objects.equals(executionPayload, that.executionPayload) && Objects.equals(executionPayloadValue, that.executionPayloadValue) - && Objects.equals(blobsBundle, that.blobsBundle); + && Objects.equals(blobsBundle, that.blobsBundle) + && Objects.equals(executionRequests, that.executionRequests); } @Override public int hashCode() { return Objects.hash( - executionPayload, executionPayloadValue, blobsBundle, shouldOverrideBuilder); + executionPayload, + executionPayloadValue, + blobsBundle, + shouldOverrideBuilder, + executionRequests); } @Override @@ -95,6 +122,7 @@ public String toString() { .add("executionPayloadValue", executionPayloadValue) .add("blobsBundle", blobsBundle) .add("shouldOverrideBuilder", shouldOverrideBuilder) + .add("executionRequests", executionRequests) .toString(); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/HeaderWithFallbackData.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/HeaderWithFallbackData.java deleted file mode 100644 index d65be64ff81..00000000000 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/HeaderWithFallbackData.java +++ /dev/null @@ -1,109 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.spec.datastructures.execution; - -import com.google.common.base.MoreObjects; -import java.util.Objects; -import java.util.Optional; -import tech.pegasys.teku.infrastructure.ssz.SszList; -import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; - -/** - * if we serve unblind production, external optional is empty - * - *

if we serve builderGetHeader using local execution engine, we store fallback in internal - * optional - * - *

if we serve builderGetHeader using builder, we store slot->Optional.empty() in internal - * optional to signal that we must call the builder to serve builderGetPayload later - */ -public class HeaderWithFallbackData { - - private final ExecutionPayloadHeader executionPayloadHeader; - private final Optional> blobKzgCommitments; - private final Optional fallbackData; - - private HeaderWithFallbackData( - final ExecutionPayloadHeader executionPayloadHeader, - final Optional> blobKzgCommitments, - final Optional fallbackData) { - this.executionPayloadHeader = executionPayloadHeader; - this.blobKzgCommitments = blobKzgCommitments; - this.fallbackData = fallbackData; - } - - public static HeaderWithFallbackData create( - final ExecutionPayloadHeader executionPayloadHeader, final FallbackData fallbackData) { - return new HeaderWithFallbackData( - executionPayloadHeader, Optional.empty(), Optional.of(fallbackData)); - } - - public static HeaderWithFallbackData create(final ExecutionPayloadHeader executionPayloadHeader) { - return new HeaderWithFallbackData(executionPayloadHeader, Optional.empty(), Optional.empty()); - } - - public static HeaderWithFallbackData create( - final ExecutionPayloadHeader executionPayloadHeader, - final Optional> blobKzgCommitments, - final FallbackData fallbackData) { - return new HeaderWithFallbackData( - executionPayloadHeader, blobKzgCommitments, Optional.of(fallbackData)); - } - - public static HeaderWithFallbackData create( - final ExecutionPayloadHeader executionPayloadHeader, - final Optional> blobKzgCommitments) { - return new HeaderWithFallbackData(executionPayloadHeader, blobKzgCommitments, Optional.empty()); - } - - public ExecutionPayloadHeader getExecutionPayloadHeader() { - return executionPayloadHeader; - } - - public Optional> getBlobKzgCommitments() { - return blobKzgCommitments; - } - - public Optional getFallbackData() { - return fallbackData; - } - - @Override - public boolean equals(final Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - final HeaderWithFallbackData that = (HeaderWithFallbackData) o; - return Objects.equals(executionPayloadHeader, that.executionPayloadHeader) - && Objects.equals(blobKzgCommitments, that.blobKzgCommitments) - && Objects.equals(fallbackData, that.fallbackData); - } - - @Override - public int hashCode() { - return Objects.hash(executionPayloadHeader, blobKzgCommitments, fallbackData); - } - - @Override - public String toString() { - return MoreObjects.toStringHelper(this) - .add("executionPayloadHeader", executionPayloadHeader) - .add("blobKzgCommitments", blobKzgCommitments) - .add("fallbackData", fallbackData) - .toString(); - } -} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/NewPayloadRequest.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/NewPayloadRequest.java index eb2ccc740b2..174e7e686a4 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/NewPayloadRequest.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/NewPayloadRequest.java @@ -17,6 +17,7 @@ import java.util.List; import java.util.Objects; import java.util.Optional; +import org.apache.tuweni.bytes.Bytes; import org.apache.tuweni.bytes.Bytes32; import tech.pegasys.teku.spec.logic.versions.deneb.types.VersionedHash; @@ -25,11 +26,13 @@ public class NewPayloadRequest { private final ExecutionPayload executionPayload; private final Optional> versionedHashes; private final Optional parentBeaconBlockRoot; + private final Optional> executionRequests; public NewPayloadRequest(final ExecutionPayload executionPayload) { this.executionPayload = executionPayload; this.versionedHashes = Optional.empty(); this.parentBeaconBlockRoot = Optional.empty(); + this.executionRequests = Optional.empty(); } public NewPayloadRequest( @@ -39,6 +42,18 @@ public NewPayloadRequest( this.executionPayload = executionPayload; this.versionedHashes = Optional.of(versionedHashes); this.parentBeaconBlockRoot = Optional.of(parentBeaconBlockRoot); + this.executionRequests = Optional.empty(); + } + + public NewPayloadRequest( + final ExecutionPayload executionPayload, + final List versionedHashes, + final Bytes32 parentBeaconBlockRoot, + final List executionRequests) { + this.executionPayload = executionPayload; + this.versionedHashes = Optional.of(versionedHashes); + this.parentBeaconBlockRoot = Optional.of(parentBeaconBlockRoot); + this.executionRequests = Optional.of(executionRequests); } public ExecutionPayload getExecutionPayload() { @@ -53,6 +68,10 @@ public Optional getParentBeaconBlockRoot() { return parentBeaconBlockRoot; } + public Optional> getExecutionRequests() { + return executionRequests; + } + @Override public boolean equals(final Object o) { if (this == o) { @@ -64,12 +83,14 @@ public boolean equals(final Object o) { final NewPayloadRequest that = (NewPayloadRequest) o; return Objects.equals(executionPayload, that.executionPayload) && Objects.equals(versionedHashes, that.versionedHashes) - && Objects.equals(parentBeaconBlockRoot, that.parentBeaconBlockRoot); + && Objects.equals(parentBeaconBlockRoot, that.parentBeaconBlockRoot) + && Objects.equals(executionRequests, that.executionRequests); } @Override public int hashCode() { - return Objects.hash(executionPayload, versionedHashes, parentBeaconBlockRoot); + return Objects.hash( + executionPayload, versionedHashes, parentBeaconBlockRoot, executionRequests); } @Override @@ -78,6 +99,7 @@ public String toString() { .add("executionPayload", executionPayload) .add("versionedHashes", versionedHashes) .add("parentBeaconBlockRoot", parentBeaconBlockRoot) + .add("executionRequests", executionRequests) .toString(); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/PowBlock.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/PowBlock.java index 145b0699a31..cdeebd85868 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/PowBlock.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/PowBlock.java @@ -26,7 +26,10 @@ public class PowBlock { private final UInt64 blockTimestamp; public PowBlock( - Bytes32 blockHash, Bytes32 parentHash, UInt256 totalDifficulty, UInt64 blockTimestamp) { + final Bytes32 blockHash, + final Bytes32 parentHash, + final UInt256 totalDifficulty, + final UInt64 blockTimestamp) { this.blockHash = blockHash; this.parentHash = parentHash; this.totalDifficulty = totalDifficulty; diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/Transaction.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/Transaction.java index 4a0175d9059..2fd6a1a7630 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/Transaction.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/Transaction.java @@ -18,7 +18,7 @@ public class Transaction extends SszByteListImpl { - Transaction(TransactionSchema schema, TreeNode backingNode) { + Transaction(final TransactionSchema schema, final TreeNode backingNode) { super(schema, backingNode); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/TransactionSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/TransactionSchema.java index 56635079c6d..53b2b50ce14 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/TransactionSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/TransactionSchema.java @@ -25,7 +25,7 @@ public TransactionSchema(final SpecConfigBellatrix specConfig) { } @Override - public Transaction createFromBackingNode(TreeNode node) { + public Transaction createFromBackingNode(final TreeNode node) { return new Transaction(this, node); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/bellatrix/ExecutionPayloadBellatrix.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/bellatrix/ExecutionPayloadBellatrix.java index 2c9b27d839b..59aebb9c566 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/bellatrix/ExecutionPayloadBellatrix.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/bellatrix/ExecutionPayloadBellatrix.java @@ -53,7 +53,7 @@ public class ExecutionPayloadBellatrix implements ExecutionPayload { public ExecutionPayloadBellatrix( - ContainerSchema14< + final ContainerSchema14< ExecutionPayloadBellatrix, SszBytes32, SszByteVector, @@ -70,26 +70,26 @@ public ExecutionPayloadBellatrix( SszBytes32, SszList> type, - TreeNode backingNode) { + final TreeNode backingNode) { super(type, backingNode); } public ExecutionPayloadBellatrix( - ExecutionPayloadSchemaBellatrix schema, - SszBytes32 parentHash, - SszByteVector feeRecipient, - SszBytes32 stateRoot, - SszBytes32 receiptsRoot, - SszByteVector logsBloom, - SszBytes32 prevRandao, - SszUInt64 blockNumber, - SszUInt64 gasLimit, - SszUInt64 gasUsed, - SszUInt64 timestamp, - SszByteList extraData, - SszUInt256 baseFeePerGas, - SszBytes32 blockHash, - SszList transactions) { + final ExecutionPayloadSchemaBellatrix schema, + final SszBytes32 parentHash, + final SszByteVector feeRecipient, + final SszBytes32 stateRoot, + final SszBytes32 receiptsRoot, + final SszByteVector logsBloom, + final SszBytes32 prevRandao, + final SszUInt64 blockNumber, + final SszUInt64 gasLimit, + final SszUInt64 gasUsed, + final SszUInt64 timestamp, + final SszByteList extraData, + final SszUInt256 baseFeePerGas, + final SszBytes32 blockHash, + final SszList transactions) { super( schema, parentHash, diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/bellatrix/ExecutionPayloadHeaderBellatrix.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/bellatrix/ExecutionPayloadHeaderBellatrix.java index a96a4b15a14..1d7c64ba916 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/bellatrix/ExecutionPayloadHeaderBellatrix.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/bellatrix/ExecutionPayloadHeaderBellatrix.java @@ -49,7 +49,7 @@ public class ExecutionPayloadHeaderBellatrix implements ExecutionPayloadHeader { public ExecutionPayloadHeaderBellatrix( - ContainerSchema14< + final ContainerSchema14< ExecutionPayloadHeaderBellatrix, SszBytes32, SszByteVector, @@ -66,26 +66,26 @@ public ExecutionPayloadHeaderBellatrix( SszBytes32, SszBytes32> type, - TreeNode backingNode) { + final TreeNode backingNode) { super(type, backingNode); } public ExecutionPayloadHeaderBellatrix( - ExecutionPayloadHeaderSchemaBellatrix schema, - SszBytes32 parentHash, - SszByteVector feeRecipient, - SszBytes32 stateRoot, - SszBytes32 receiptsRoot, - SszByteVector logsBloom, - SszBytes32 prevRandao, - SszUInt64 blockNumber, - SszUInt64 gasLimit, - SszUInt64 gasUsed, - SszUInt64 timestamp, - SszByteList extraData, - SszUInt256 baseFeePerGas, - SszBytes32 blockHash, - SszBytes32 transactionsRoot) { + final ExecutionPayloadHeaderSchemaBellatrix schema, + final SszBytes32 parentHash, + final SszByteVector feeRecipient, + final SszBytes32 stateRoot, + final SszBytes32 receiptsRoot, + final SszByteVector logsBloom, + final SszBytes32 prevRandao, + final SszUInt64 blockNumber, + final SszUInt64 gasLimit, + final SszUInt64 gasUsed, + final SszUInt64 timestamp, + final SszByteList extraData, + final SszUInt256 baseFeePerGas, + final SszBytes32 blockHash, + final SszBytes32 transactionsRoot) { super( schema, parentHash, diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/bellatrix/ExecutionPayloadHeaderSchemaBellatrix.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/bellatrix/ExecutionPayloadHeaderSchemaBellatrix.java index 6808fcab5ec..c7273bb6caa 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/bellatrix/ExecutionPayloadHeaderSchemaBellatrix.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/bellatrix/ExecutionPayloadHeaderSchemaBellatrix.java @@ -128,7 +128,7 @@ public ExecutionPayloadHeaderBellatrix getHeaderOfDefaultPayload() { } @Override - public ExecutionPayloadHeaderBellatrix createFromBackingNode(TreeNode node) { + public ExecutionPayloadHeaderBellatrix createFromBackingNode(final TreeNode node) { return new ExecutionPayloadHeaderBellatrix(this, node); } @@ -149,4 +149,9 @@ public ExecutionPayloadHeader createExecutionPayloadHeader( public SszByteListSchema getExtraDataSchema() { return (SszByteListSchema) getFieldSchema10(); } + + @Override + public ExecutionPayloadHeaderSchemaBellatrix toVersionBellatrixRequired() { + return this; + } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/bellatrix/ExecutionPayloadSchemaBellatrix.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/bellatrix/ExecutionPayloadSchemaBellatrix.java index 1df2a1c9ea0..8e61e48b72e 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/bellatrix/ExecutionPayloadSchemaBellatrix.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/bellatrix/ExecutionPayloadSchemaBellatrix.java @@ -51,6 +51,12 @@ import tech.pegasys.teku.spec.datastructures.execution.TransactionSchema; import tech.pegasys.teku.spec.datastructures.execution.versions.capella.Withdrawal; import tech.pegasys.teku.spec.datastructures.execution.versions.capella.WithdrawalSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequestSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequestSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequestSchema; public class ExecutionPayloadSchemaBellatrix extends ContainerSchema14< @@ -112,6 +118,41 @@ public WithdrawalSchema getWithdrawalSchemaRequired() { throw new IllegalStateException("Attempted to get a withdrawal schema from bellatrix"); } + @Override + public SszListSchema> + getDepositRequestsSchemaRequired() { + throw new IllegalStateException("Attempted to get a deposit requests schema from bellatrix"); + } + + @Override + public DepositRequestSchema getDepositRequestSchemaRequired() { + throw new IllegalStateException("Attempted to get a deposit request schema from bellatrix"); + } + + @Override + public SszListSchema> + getWithdrawalRequestsSchemaRequired() { + throw new IllegalStateException("Attempted to get withdrawal requests schema from bellatrix"); + } + + @Override + public WithdrawalRequestSchema getWithdrawalRequestSchemaRequired() { + throw new IllegalStateException("Attempted to get a withdrawal request schema from bellatrix"); + } + + @Override + public SszListSchema> + getConsolidationRequestsSchemaRequired() { + throw new IllegalStateException( + "Attempted to get consolidation requests schema from bellatrix"); + } + + @Override + public ConsolidationRequestSchema getConsolidationRequestSchemaRequired() { + throw new IllegalStateException( + "Attempted to get a consolidation request schema from bellatrix"); + } + @Override public LongList getBlindedNodeGeneralizedIndices() { return LongList.of(getChildGeneralizedIndex(getFieldIndex(TRANSACTIONS))); @@ -132,7 +173,7 @@ public ExecutionPayloadBellatrix getDefault() { } @Override - public ExecutionPayloadBellatrix createFromBackingNode(TreeNode node) { + public ExecutionPayloadBellatrix createFromBackingNode(final TreeNode node) { return new ExecutionPayloadBellatrix(this, node); } @@ -145,4 +186,9 @@ public ExecutionPayloadBellatrix createFromBackingNode(TreeNode node) { public SszByteListSchema getExtraDataSchema() { return (SszByteListSchema) getFieldSchema10(); } + + @Override + public ExecutionPayloadSchemaBellatrix toVersionBellatrixRequired() { + return this; + } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/capella/ExecutionPayloadCapellaImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/capella/ExecutionPayloadCapellaImpl.java index 1d6c09f8d32..9b4eacf5ec4 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/capella/ExecutionPayloadCapellaImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/capella/ExecutionPayloadCapellaImpl.java @@ -52,7 +52,7 @@ public class ExecutionPayloadCapellaImpl implements ExecutionPayloadCapella { public ExecutionPayloadCapellaImpl( - ContainerSchema15< + final ContainerSchema15< ExecutionPayloadCapellaImpl, SszBytes32, SszByteVector, @@ -70,27 +70,27 @@ public ExecutionPayloadCapellaImpl( SszList, SszList> schema, - TreeNode backingNode) { + final TreeNode backingNode) { super(schema, backingNode); } public ExecutionPayloadCapellaImpl( - ExecutionPayloadSchemaCapella schema, - SszBytes32 parentHash, - SszByteVector feeRecipient, - SszBytes32 stateRoot, - SszBytes32 receiptsRoot, - SszByteVector logsBloom, - SszBytes32 prevRandao, - SszUInt64 blockNumber, - SszUInt64 gasLimit, - SszUInt64 gasUsed, - SszUInt64 timestamp, - SszByteList extraData, - SszUInt256 baseFeePerGas, - SszBytes32 blockHash, - SszList transactions, - SszList withdrawals) { + final ExecutionPayloadSchemaCapella schema, + final SszBytes32 parentHash, + final SszByteVector feeRecipient, + final SszBytes32 stateRoot, + final SszBytes32 receiptsRoot, + final SszByteVector logsBloom, + final SszBytes32 prevRandao, + final SszUInt64 blockNumber, + final SszUInt64 gasLimit, + final SszUInt64 gasUsed, + final SszUInt64 timestamp, + final SszByteList extraData, + final SszUInt256 baseFeePerGas, + final SszBytes32 blockHash, + final SszList transactions, + final SszList withdrawals) { super( schema, parentHash, diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/capella/ExecutionPayloadHeaderCapellaImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/capella/ExecutionPayloadHeaderCapellaImpl.java index 425cf9089e7..1ca05a31419 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/capella/ExecutionPayloadHeaderCapellaImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/capella/ExecutionPayloadHeaderCapellaImpl.java @@ -48,7 +48,7 @@ public class ExecutionPayloadHeaderCapellaImpl implements ExecutionPayloadHeaderCapella { protected ExecutionPayloadHeaderCapellaImpl( - ContainerSchema15< + final ContainerSchema15< ExecutionPayloadHeaderCapellaImpl, SszBytes32, SszByteVector, @@ -66,27 +66,27 @@ protected ExecutionPayloadHeaderCapellaImpl( SszBytes32, SszBytes32> schema, - TreeNode backingTree) { + final TreeNode backingTree) { super(schema, backingTree); } public ExecutionPayloadHeaderCapellaImpl( - ExecutionPayloadHeaderSchemaCapella schema, - SszBytes32 parentHash, - SszByteVector feeRecipient, - SszBytes32 stateRoot, - SszBytes32 receiptsRoot, - SszByteVector logsBloom, - SszBytes32 prevRandao, - SszUInt64 blockNumber, - SszUInt64 gasLimit, - SszUInt64 gasUsed, - SszUInt64 timestamp, - SszByteList extraData, - SszUInt256 baseFeePerGas, - SszBytes32 blockHash, - SszBytes32 transactionsRoot, - SszBytes32 withdrawalsRoot) { + final ExecutionPayloadHeaderSchemaCapella schema, + final SszBytes32 parentHash, + final SszByteVector feeRecipient, + final SszBytes32 stateRoot, + final SszBytes32 receiptsRoot, + final SszByteVector logsBloom, + final SszBytes32 prevRandao, + final SszUInt64 blockNumber, + final SszUInt64 gasLimit, + final SszUInt64 gasUsed, + final SszUInt64 timestamp, + final SszByteList extraData, + final SszUInt256 baseFeePerGas, + final SszBytes32 blockHash, + final SszBytes32 transactionsRoot, + final SszBytes32 withdrawalsRoot) { super( schema, parentHash, diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/capella/ExecutionPayloadHeaderSchemaCapella.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/capella/ExecutionPayloadHeaderSchemaCapella.java index 153e7f4f28c..72894c9857e 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/capella/ExecutionPayloadHeaderSchemaCapella.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/capella/ExecutionPayloadHeaderSchemaCapella.java @@ -152,7 +152,7 @@ public ExecutionPayloadHeaderCapella getHeaderOfDefaultPayload() { } @Override - public ExecutionPayloadHeaderCapellaImpl createFromBackingNode(TreeNode node) { + public ExecutionPayloadHeaderCapellaImpl createFromBackingNode(final TreeNode node) { return new ExecutionPayloadHeaderCapellaImpl(this, node); } @@ -178,4 +178,9 @@ public ExecutionPayloadHeaderCapellaImpl createFromExecutionPayload( SszBytes32.of(executionPayload.getTransactions().hashTreeRoot()), SszBytes32.of(executionPayload.getWithdrawals().hashTreeRoot())); } + + @Override + public ExecutionPayloadHeaderSchemaCapella toVersionCapellaRequired() { + return this; + } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/capella/ExecutionPayloadSchemaCapella.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/capella/ExecutionPayloadSchemaCapella.java index 78a0761b9fd..aba7ac25def 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/capella/ExecutionPayloadSchemaCapella.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/capella/ExecutionPayloadSchemaCapella.java @@ -50,6 +50,12 @@ import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSchema; import tech.pegasys.teku.spec.datastructures.execution.Transaction; import tech.pegasys.teku.spec.datastructures.execution.TransactionSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequestSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequestSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequestSchema; public class ExecutionPayloadSchemaCapella extends ContainerSchema15< @@ -119,6 +125,39 @@ public WithdrawalSchema getWithdrawalSchemaRequired() { return getWithdrawalSchema(); } + @Override + public SszListSchema> + getDepositRequestsSchemaRequired() { + throw new IllegalStateException("Attempted to get a deposit requests schema from capella"); + } + + @Override + public DepositRequestSchema getDepositRequestSchemaRequired() { + throw new IllegalStateException("Attempted to get a deposit request schema from capella"); + } + + @Override + public SszListSchema> + getWithdrawalRequestsSchemaRequired() { + throw new IllegalStateException("Attempted to get withdrawal requests schema from capella"); + } + + @Override + public WithdrawalRequestSchema getWithdrawalRequestSchemaRequired() { + throw new IllegalStateException("Attempted to get a withdrawal request schema from capella"); + } + + @Override + public ConsolidationRequestSchema getConsolidationRequestSchemaRequired() { + throw new IllegalStateException("Attempted to get a consolidation request schema from capella"); + } + + @Override + public SszListSchema> + getConsolidationRequestsSchemaRequired() { + throw new IllegalStateException("Attempted to get consolidation requests schema from capella"); + } + public WithdrawalSchema getWithdrawalSchema() { return (WithdrawalSchema) getWithdrawalsSchema().getElementSchema(); } @@ -140,7 +179,7 @@ public ExecutionPayload createExecutionPayload( } @Override - public ExecutionPayloadCapellaImpl createFromBackingNode(TreeNode node) { + public ExecutionPayloadCapellaImpl createFromBackingNode(final TreeNode node) { return new ExecutionPayloadCapellaImpl(this, node); } @@ -158,4 +197,9 @@ public SszByteListSchema getExtraDataSchema() { public SszListSchema getWithdrawalsSchema() { return (SszListSchema) getFieldSchema14(); } + + @Override + public ExecutionPayloadSchemaCapella toVersionCapellaRequired() { + return this; + } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/deneb/ExecutionPayloadDenebImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/deneb/ExecutionPayloadDenebImpl.java index a85a82754b4..7150f97583f 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/deneb/ExecutionPayloadDenebImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/deneb/ExecutionPayloadDenebImpl.java @@ -55,7 +55,7 @@ public class ExecutionPayloadDenebImpl implements ExecutionPayloadDeneb { public ExecutionPayloadDenebImpl( - ContainerSchema17< + final ContainerSchema17< ExecutionPayloadDenebImpl, SszBytes32, SszByteVector, @@ -75,29 +75,29 @@ public ExecutionPayloadDenebImpl( SszUInt64, SszUInt64> schema, - TreeNode backingNode) { + final TreeNode backingNode) { super(schema, backingNode); } public ExecutionPayloadDenebImpl( - ExecutionPayloadSchemaDeneb schema, - SszBytes32 parentHash, - SszByteVector feeRecipient, - SszBytes32 stateRoot, - SszBytes32 receiptsRoot, - SszByteVector logsBloom, - SszBytes32 prevRandao, - SszUInt64 blockNumber, - SszUInt64 gasLimit, - SszUInt64 gasUsed, - SszUInt64 timestamp, - SszByteList extraData, - SszUInt256 baseFeePerGas, - SszBytes32 blockHash, - SszList transactions, - SszList withdrawals, - SszUInt64 blobGasUsed, - SszUInt64 excessBlobGas) { + final ExecutionPayloadSchemaDeneb schema, + final SszBytes32 parentHash, + final SszByteVector feeRecipient, + final SszBytes32 stateRoot, + final SszBytes32 receiptsRoot, + final SszByteVector logsBloom, + final SszBytes32 prevRandao, + final SszUInt64 blockNumber, + final SszUInt64 gasLimit, + final SszUInt64 gasUsed, + final SszUInt64 timestamp, + final SszByteList extraData, + final SszUInt256 baseFeePerGas, + final SszBytes32 blockHash, + final SszList transactions, + final SszList withdrawals, + final SszUInt64 blobGasUsed, + final SszUInt64 excessBlobGas) { super( schema, parentHash, diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/deneb/ExecutionPayloadHeaderDenebImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/deneb/ExecutionPayloadHeaderDenebImpl.java index 5394769e9bf..797197945a2 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/deneb/ExecutionPayloadHeaderDenebImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/deneb/ExecutionPayloadHeaderDenebImpl.java @@ -50,7 +50,7 @@ public class ExecutionPayloadHeaderDenebImpl implements ExecutionPayloadHeaderDeneb { protected ExecutionPayloadHeaderDenebImpl( - ContainerSchema17< + final ContainerSchema17< ExecutionPayloadHeaderDenebImpl, SszBytes32, SszByteVector, @@ -70,29 +70,29 @@ protected ExecutionPayloadHeaderDenebImpl( SszUInt64, SszUInt64> schema, - TreeNode backingTree) { + final TreeNode backingTree) { super(schema, backingTree); } public ExecutionPayloadHeaderDenebImpl( - ExecutionPayloadHeaderSchemaDeneb schema, - SszBytes32 parentHash, - SszByteVector feeRecipient, - SszBytes32 stateRoot, - SszBytes32 receiptsRoot, - SszByteVector logsBloom, - SszBytes32 prevRandao, - SszUInt64 blockNumber, - SszUInt64 gasLimit, - SszUInt64 gasUsed, - SszUInt64 timestamp, - SszByteList extraData, - SszUInt256 baseFeePerGas, - SszBytes32 blockHash, - SszBytes32 transactionsRoot, - SszBytes32 withdrawalsRoot, - SszUInt64 blobGasUsed, - SszUInt64 excessBlobGas) { + final ExecutionPayloadHeaderSchemaDeneb schema, + final SszBytes32 parentHash, + final SszByteVector feeRecipient, + final SszBytes32 stateRoot, + final SszBytes32 receiptsRoot, + final SszByteVector logsBloom, + final SszBytes32 prevRandao, + final SszUInt64 blockNumber, + final SszUInt64 gasLimit, + final SszUInt64 gasUsed, + final SszUInt64 timestamp, + final SszByteList extraData, + final SszUInt256 baseFeePerGas, + final SszBytes32 blockHash, + final SszBytes32 transactionsRoot, + final SszBytes32 withdrawalsRoot, + final SszUInt64 blobGasUsed, + final SszUInt64 excessBlobGas) { super( schema, parentHash, diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/deneb/ExecutionPayloadHeaderSchemaDeneb.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/deneb/ExecutionPayloadHeaderSchemaDeneb.java index dc1dc227ea1..5b0192ba2fb 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/deneb/ExecutionPayloadHeaderSchemaDeneb.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/deneb/ExecutionPayloadHeaderSchemaDeneb.java @@ -164,4 +164,9 @@ public ExecutionPayloadHeaderDenebImpl createFromExecutionPayload( SszUInt64.of(executionPayload.getBlobGasUsed()), SszUInt64.of(executionPayload.getExcessBlobGas())); } + + @Override + public ExecutionPayloadHeaderSchemaDeneb toVersionDenebRequired() { + return this; + } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/deneb/ExecutionPayloadSchemaDeneb.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/deneb/ExecutionPayloadSchemaDeneb.java index 0f909dc564e..e072e918ab3 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/deneb/ExecutionPayloadSchemaDeneb.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/deneb/ExecutionPayloadSchemaDeneb.java @@ -54,6 +54,12 @@ import tech.pegasys.teku.spec.datastructures.execution.TransactionSchema; import tech.pegasys.teku.spec.datastructures.execution.versions.capella.Withdrawal; import tech.pegasys.teku.spec.datastructures.execution.versions.capella.WithdrawalSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequestSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequestSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequestSchema; public class ExecutionPayloadSchemaDeneb extends ContainerSchema17< @@ -127,6 +133,39 @@ public WithdrawalSchema getWithdrawalSchemaRequired() { return getWithdrawalSchema(); } + @Override + public SszListSchema> + getDepositRequestsSchemaRequired() { + throw new IllegalStateException("Attempted to get a deposit requests schema from deneb"); + } + + @Override + public DepositRequestSchema getDepositRequestSchemaRequired() { + throw new IllegalStateException("Attempted to get a deposit request schema from deneb"); + } + + @Override + public SszListSchema> + getWithdrawalRequestsSchemaRequired() { + throw new IllegalStateException("Attempted to get withdrawal requests schema from deneb"); + } + + @Override + public WithdrawalRequestSchema getWithdrawalRequestSchemaRequired() { + throw new IllegalStateException("Attempted to get a withdrawal request schema from deneb"); + } + + @Override + public ConsolidationRequestSchema getConsolidationRequestSchemaRequired() { + throw new IllegalStateException("Attempted to get a consolidation request schema from deneb"); + } + + @Override + public SszListSchema> + getConsolidationRequestsSchemaRequired() { + throw new IllegalStateException("Attempted to get consolidation requests schema from deneb"); + } + public WithdrawalSchema getWithdrawalSchema() { return (WithdrawalSchema) getWithdrawalsSchema().getElementSchema(); } @@ -164,4 +203,9 @@ public SszByteListSchema getExtraDataSchema() { public SszListSchema getWithdrawalsSchema() { return (SszListSchema) getChildSchema(getFieldIndex(WITHDRAWALS)); } + + @Override + public ExecutionPayloadSchemaDeneb toVersionDenebRequired() { + return this; + } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/eip7594/ExecutionPayloadBuilderEip7594.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/eip7594/ExecutionPayloadBuilderEip7594.java deleted file mode 100644 index 4771480d184..00000000000 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/eip7594/ExecutionPayloadBuilderEip7594.java +++ /dev/null @@ -1,63 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.spec.datastructures.execution.versions.eip7594; - -import static com.google.common.base.Preconditions.checkNotNull; - -import tech.pegasys.teku.infrastructure.ssz.collections.SszByteVector; -import tech.pegasys.teku.infrastructure.ssz.primitive.SszBytes32; -import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt256; -import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; -import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadBuilderDeneb; - -public class ExecutionPayloadBuilderEip7594 extends ExecutionPayloadBuilderDeneb { - private ExecutionPayloadSchemaEip7594 schema; - - public ExecutionPayloadBuilderEip7594 schema(final ExecutionPayloadSchemaEip7594 schema) { - this.schema = schema; - return this; - } - - @Override - protected void validateSchema() { - checkNotNull(schema, "schema must be specified"); - } - - @Override - public ExecutionPayload build() { - validate(); - return new ExecutionPayloadEip7594Impl( - schema, - SszBytes32.of(parentHash), - SszByteVector.fromBytes(feeRecipient.getWrappedBytes()), - SszBytes32.of(stateRoot), - SszBytes32.of(receiptsRoot), - SszByteVector.fromBytes(logsBloom), - SszBytes32.of(prevRandao), - SszUInt64.of(blockNumber), - SszUInt64.of(gasLimit), - SszUInt64.of(gasUsed), - SszUInt64.of(timestamp), - schema.getExtraDataSchema().fromBytes(extraData), - SszUInt256.of(baseFeePerGas), - SszBytes32.of(blockHash), - transactions.stream() - .map(schema.getTransactionSchema()::fromBytes) - .collect(schema.getTransactionsSchema().collector()), - schema.getWithdrawalsSchema().createFromElements(withdrawals), - SszUInt64.of(blobGasUsed), - SszUInt64.of(excessBlobGas)); - } -} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/eip7594/ExecutionPayloadEip7594.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/eip7594/ExecutionPayloadEip7594.java deleted file mode 100644 index 3fe8d54a03a..00000000000 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/eip7594/ExecutionPayloadEip7594.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.spec.datastructures.execution.versions.eip7594; - -import java.util.Optional; -import tech.pegasys.teku.spec.SpecMilestone; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; -import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadDeneb; - -public interface ExecutionPayloadEip7594 extends ExecutionPayload, ExecutionPayloadDeneb { - - static ExecutionPayloadEip7594 required(final ExecutionPayload payload) { - return payload - .toVersionEip7594() - .orElseThrow( - () -> - new IllegalArgumentException( - "Expected EIP7594 execution payload but got " - + payload.getClass().getSimpleName())); - } - - @Override - default Optional toVersionEip7594() { - return Optional.of(this); - } - - @Override - default SpecMilestone getMilestone() { - return SpecMilestone.EIP7594; - } -} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/eip7594/ExecutionPayloadEip7594Impl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/eip7594/ExecutionPayloadEip7594Impl.java deleted file mode 100644 index 7865c21a38e..00000000000 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/eip7594/ExecutionPayloadEip7594Impl.java +++ /dev/null @@ -1,231 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.spec.datastructures.execution.versions.eip7594; - -import java.util.List; -import java.util.Optional; -import org.apache.tuweni.bytes.Bytes; -import org.apache.tuweni.bytes.Bytes32; -import org.apache.tuweni.units.bigints.UInt256; -import tech.pegasys.teku.infrastructure.bytes.Bytes20; -import tech.pegasys.teku.infrastructure.ssz.SszList; -import tech.pegasys.teku.infrastructure.ssz.collections.SszByteList; -import tech.pegasys.teku.infrastructure.ssz.collections.SszByteVector; -import tech.pegasys.teku.infrastructure.ssz.containers.Container17; -import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema17; -import tech.pegasys.teku.infrastructure.ssz.primitive.SszBytes32; -import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt256; -import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; -import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.datastructures.execution.Transaction; -import tech.pegasys.teku.spec.datastructures.execution.versions.capella.Withdrawal; - -public class ExecutionPayloadEip7594Impl - extends Container17< - ExecutionPayloadEip7594Impl, - SszBytes32, - SszByteVector, - SszBytes32, - SszBytes32, - SszByteVector, - SszBytes32, - SszUInt64, - SszUInt64, - SszUInt64, - SszUInt64, - SszByteList, - SszUInt256, - SszBytes32, - SszList, - SszList, - SszUInt64, - SszUInt64> - implements ExecutionPayloadEip7594 { - - public ExecutionPayloadEip7594Impl( - ContainerSchema17< - ExecutionPayloadEip7594Impl, - SszBytes32, - SszByteVector, - SszBytes32, - SszBytes32, - SszByteVector, - SszBytes32, - SszUInt64, - SszUInt64, - SszUInt64, - SszUInt64, - SszByteList, - SszUInt256, - SszBytes32, - SszList, - SszList, - SszUInt64, - SszUInt64> - schema, - TreeNode backingNode) { - super(schema, backingNode); - } - - public ExecutionPayloadEip7594Impl( - ExecutionPayloadSchemaEip7594 schema, - SszBytes32 parentHash, - SszByteVector feeRecipient, - SszBytes32 stateRoot, - SszBytes32 receiptsRoot, - SszByteVector logsBloom, - SszBytes32 prevRandao, - SszUInt64 blockNumber, - SszUInt64 gasLimit, - SszUInt64 gasUsed, - SszUInt64 timestamp, - SszByteList extraData, - SszUInt256 baseFeePerGas, - SszBytes32 blockHash, - SszList transactions, - SszList withdrawals, - SszUInt64 blobGasUsed, - SszUInt64 excessBlobGas) { - super( - schema, - parentHash, - feeRecipient, - stateRoot, - receiptsRoot, - logsBloom, - prevRandao, - blockNumber, - gasLimit, - gasUsed, - timestamp, - extraData, - baseFeePerGas, - blockHash, - transactions, - withdrawals, - blobGasUsed, - excessBlobGas); - } - - @Override - public boolean isDefaultPayload() { - return super.isDefault(); - } - - @Override - public Optional getOptionalWithdrawalsRoot() { - return Optional.of(getWithdrawals().hashTreeRoot()); - } - - @Override - public ExecutionPayloadSchemaEip7594 getSchema() { - return (ExecutionPayloadSchemaEip7594) super.getSchema(); - } - - @Override - public Bytes32 getParentHash() { - return getField0().get(); - } - - @Override - public Bytes20 getFeeRecipient() { - return Bytes20.leftPad(getField1().getBytes()); - } - - @Override - public Bytes32 getStateRoot() { - return getField2().get(); - } - - @Override - public Bytes32 getReceiptsRoot() { - return getField3().get(); - } - - @Override - public Bytes getLogsBloom() { - return getField4().getBytes(); - } - - @Override - public Bytes32 getPrevRandao() { - return getField5().get(); - } - - @Override - public UInt64 getBlockNumber() { - return getField6().get(); - } - - @Override - public UInt64 getGasLimit() { - return getField7().get(); - } - - @Override - public UInt64 getGasUsed() { - return getField8().get(); - } - - @Override - public UInt64 getTimestamp() { - return getField9().get(); - } - - @Override - public Bytes getExtraData() { - return getField10().getBytes(); - } - - @Override - public UInt256 getBaseFeePerGas() { - return getField11().get(); - } - - @Override - public Bytes32 getBlockHash() { - return getField12().get(); - } - - @Override - public Bytes32 getPayloadHash() { - return hashTreeRoot(); - } - - @Override - public SszList getTransactions() { - return getField13(); - } - - @Override - public SszList getWithdrawals() { - return getField14(); - } - - @Override - public UInt64 getBlobGasUsed() { - return getField15().get(); - } - - @Override - public UInt64 getExcessBlobGas() { - return getField16().get(); - } - - @Override - public List getUnblindedTreeNodes() { - return List.of(getTransactions().getBackingNode(), getWithdrawals().getBackingNode()); - } -} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/eip7594/ExecutionPayloadHeaderBuilderEip7594.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/eip7594/ExecutionPayloadHeaderBuilderEip7594.java deleted file mode 100644 index e0ca992259d..00000000000 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/eip7594/ExecutionPayloadHeaderBuilderEip7594.java +++ /dev/null @@ -1,62 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.spec.datastructures.execution.versions.eip7594; - -import static com.google.common.base.Preconditions.checkNotNull; - -import tech.pegasys.teku.infrastructure.ssz.collections.SszByteVector; -import tech.pegasys.teku.infrastructure.ssz.primitive.SszBytes32; -import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt256; -import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; -import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadHeaderBuilderDeneb; - -public class ExecutionPayloadHeaderBuilderEip7594 extends ExecutionPayloadHeaderBuilderDeneb { - private ExecutionPayloadHeaderSchemaEip7594 schema; - - public ExecutionPayloadHeaderBuilderEip7594 schema( - final ExecutionPayloadHeaderSchemaEip7594 schema) { - this.schema = schema; - return this; - } - - @Override - protected void validateSchema() { - checkNotNull(schema, "schema must be specified"); - } - - @Override - public ExecutionPayloadHeader build() { - validate(); - return new ExecutionPayloadHeaderEip7594Impl( - schema, - SszBytes32.of(parentHash), - SszByteVector.fromBytes(feeRecipient.getWrappedBytes()), - SszBytes32.of(stateRoot), - SszBytes32.of(receiptsRoot), - SszByteVector.fromBytes(logsBloom), - SszBytes32.of(prevRandao), - SszUInt64.of(blockNumber), - SszUInt64.of(gasLimit), - SszUInt64.of(gasUsed), - SszUInt64.of(timestamp), - schema.getExtraDataSchema().fromBytes(extraData), - SszUInt256.of(baseFeePerGas), - SszBytes32.of(blockHash), - SszBytes32.of(transactionsRoot), - SszBytes32.of(withdrawalsRoot), - SszUInt64.of(blobGasUsed), - SszUInt64.of(excessBlobGas)); - } -} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/eip7594/ExecutionPayloadHeaderEip7594Impl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/eip7594/ExecutionPayloadHeaderEip7594Impl.java deleted file mode 100644 index c1739e9f3f1..00000000000 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/eip7594/ExecutionPayloadHeaderEip7594Impl.java +++ /dev/null @@ -1,221 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.spec.datastructures.execution.versions.eip7594; - -import org.apache.tuweni.bytes.Bytes; -import org.apache.tuweni.bytes.Bytes32; -import org.apache.tuweni.units.bigints.UInt256; -import tech.pegasys.teku.infrastructure.bytes.Bytes20; -import tech.pegasys.teku.infrastructure.ssz.collections.SszByteList; -import tech.pegasys.teku.infrastructure.ssz.collections.SszByteVector; -import tech.pegasys.teku.infrastructure.ssz.containers.Container17; -import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema17; -import tech.pegasys.teku.infrastructure.ssz.primitive.SszBytes32; -import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt256; -import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; -import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; - -public class ExecutionPayloadHeaderEip7594Impl - extends Container17< - ExecutionPayloadHeaderEip7594Impl, - SszBytes32, - SszByteVector, - SszBytes32, - SszBytes32, - SszByteVector, - SszBytes32, - SszUInt64, - SszUInt64, - SszUInt64, - SszUInt64, - SszByteList, - SszUInt256, - SszBytes32, - SszBytes32, - SszBytes32, - SszUInt64, - SszUInt64> - implements ExecutionPayloadHeaderEip7594 { - - protected ExecutionPayloadHeaderEip7594Impl( - ContainerSchema17< - ExecutionPayloadHeaderEip7594Impl, - SszBytes32, - SszByteVector, - SszBytes32, - SszBytes32, - SszByteVector, - SszBytes32, - SszUInt64, - SszUInt64, - SszUInt64, - SszUInt64, - SszByteList, - SszUInt256, - SszBytes32, - SszBytes32, - SszBytes32, - SszUInt64, - SszUInt64> - schema, - TreeNode backingTree) { - super(schema, backingTree); - } - - public ExecutionPayloadHeaderEip7594Impl( - ExecutionPayloadHeaderSchemaEip7594 schema, - SszBytes32 parentHash, - SszByteVector feeRecipient, - SszBytes32 stateRoot, - SszBytes32 receiptsRoot, - SszByteVector logsBloom, - SszBytes32 prevRandao, - SszUInt64 blockNumber, - SszUInt64 gasLimit, - SszUInt64 gasUsed, - SszUInt64 timestamp, - SszByteList extraData, - SszUInt256 baseFeePerGas, - SszBytes32 blockHash, - SszBytes32 transactionsRoot, - SszBytes32 withdrawalsRoot, - SszUInt64 blobGasUsed, - SszUInt64 excessBlobGas) { - super( - schema, - parentHash, - feeRecipient, - stateRoot, - receiptsRoot, - logsBloom, - prevRandao, - blockNumber, - gasLimit, - gasUsed, - timestamp, - extraData, - baseFeePerGas, - blockHash, - transactionsRoot, - withdrawalsRoot, - blobGasUsed, - excessBlobGas); - } - - @Override - public boolean isDefaultPayload() { - return isHeaderOfDefaultPayload(); - } - - @Override - public ExecutionPayloadHeaderSchemaEip7594 getSchema() { - return (ExecutionPayloadHeaderSchemaEip7594) super.getSchema(); - } - - @Override - public boolean isHeaderOfDefaultPayload() { - return equals(getSchema().getHeaderOfDefaultPayload()); - } - - @Override - public Bytes32 getParentHash() { - return getField0().get(); - } - - @Override - public Bytes20 getFeeRecipient() { - return Bytes20.leftPad(getField1().getBytes()); - } - - @Override - public Bytes32 getStateRoot() { - return getField2().get(); - } - - @Override - public Bytes32 getReceiptsRoot() { - return getField3().get(); - } - - @Override - public Bytes getLogsBloom() { - return getField4().getBytes(); - } - - @Override - public Bytes32 getPrevRandao() { - return getField5().get(); - } - - @Override - public UInt64 getBlockNumber() { - return getField6().get(); - } - - @Override - public UInt64 getGasLimit() { - return getField7().get(); - } - - @Override - public UInt64 getGasUsed() { - return getField8().get(); - } - - @Override - public UInt64 getTimestamp() { - return getField9().get(); - } - - @Override - public Bytes getExtraData() { - return getField10().getBytes(); - } - - @Override - public UInt256 getBaseFeePerGas() { - return getField11().get(); - } - - @Override - public Bytes32 getBlockHash() { - return getField12().get(); - } - - @Override - public Bytes32 getTransactionsRoot() { - return getField13().get(); - } - - @Override - public Bytes32 getPayloadHash() { - return hashTreeRoot(); - } - - @Override - public Bytes32 getWithdrawalsRoot() { - return getField14().get(); - } - - @Override - public UInt64 getBlobGasUsed() { - return getField15().get(); - } - - @Override - public UInt64 getExcessBlobGas() { - return getField16().get(); - } -} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/eip7594/ExecutionPayloadHeaderSchemaEip7594.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/eip7594/ExecutionPayloadHeaderSchemaEip7594.java deleted file mode 100644 index 52cb0aa3140..00000000000 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/eip7594/ExecutionPayloadHeaderSchemaEip7594.java +++ /dev/null @@ -1,167 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.spec.datastructures.execution.versions.eip7594; - -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.BASE_FEE_PER_GAS; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.BLOB_GAS_USED; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.BLOCK_HASH; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.BLOCK_NUMBER; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.EXCESS_BLOB_GAS; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.EXTRA_DATA; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.FEE_RECIPIENT; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.GAS_LIMIT; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.GAS_USED; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.LOGS_BLOOM; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.PARENT_HASH; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.PREV_RANDAO; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.RECEIPTS_ROOT; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.STATE_ROOT; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.TIMESTAMP; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.TRANSACTIONS_ROOT; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.WITHDRAWALS_ROOT; - -import it.unimi.dsi.fastutil.longs.LongList; -import java.util.function.Consumer; -import tech.pegasys.teku.infrastructure.bytes.Bytes20; -import tech.pegasys.teku.infrastructure.ssz.collections.SszByteList; -import tech.pegasys.teku.infrastructure.ssz.collections.SszByteVector; -import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema17; -import tech.pegasys.teku.infrastructure.ssz.primitive.SszBytes32; -import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt256; -import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; -import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; -import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszByteListSchema; -import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszByteVectorSchema; -import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeaderBuilder; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeaderSchema; - -public class ExecutionPayloadHeaderSchemaEip7594 - extends ContainerSchema17< - ExecutionPayloadHeaderEip7594Impl, - SszBytes32, - SszByteVector, - SszBytes32, - SszBytes32, - SszByteVector, - SszBytes32, - SszUInt64, - SszUInt64, - SszUInt64, - SszUInt64, - SszByteList, - SszUInt256, - SszBytes32, - SszBytes32, - SszBytes32, - SszUInt64, - SszUInt64> - implements ExecutionPayloadHeaderSchema { - - private final ExecutionPayloadHeaderEip7594Impl defaultExecutionPayloadHeader; - private final ExecutionPayloadHeaderEip7594Impl executionPayloadHeaderOfDefaultPayload; - - public ExecutionPayloadHeaderSchemaEip7594(final SpecConfigEip7594 specConfig) { - super( - "ExecutionPayloadHeaderEip7594", - namedSchema(PARENT_HASH, SszPrimitiveSchemas.BYTES32_SCHEMA), - namedSchema(FEE_RECIPIENT, SszByteVectorSchema.create(Bytes20.SIZE)), - namedSchema(STATE_ROOT, SszPrimitiveSchemas.BYTES32_SCHEMA), - namedSchema(RECEIPTS_ROOT, SszPrimitiveSchemas.BYTES32_SCHEMA), - namedSchema(LOGS_BLOOM, SszByteVectorSchema.create(specConfig.getBytesPerLogsBloom())), - namedSchema(PREV_RANDAO, SszPrimitiveSchemas.BYTES32_SCHEMA), - namedSchema(BLOCK_NUMBER, SszPrimitiveSchemas.UINT64_SCHEMA), - namedSchema(GAS_LIMIT, SszPrimitiveSchemas.UINT64_SCHEMA), - namedSchema(GAS_USED, SszPrimitiveSchemas.UINT64_SCHEMA), - namedSchema(TIMESTAMP, SszPrimitiveSchemas.UINT64_SCHEMA), - namedSchema(EXTRA_DATA, SszByteListSchema.create(specConfig.getMaxExtraDataBytes())), - namedSchema(BASE_FEE_PER_GAS, SszPrimitiveSchemas.UINT256_SCHEMA), - namedSchema(BLOCK_HASH, SszPrimitiveSchemas.BYTES32_SCHEMA), - namedSchema(TRANSACTIONS_ROOT, SszPrimitiveSchemas.BYTES32_SCHEMA), - namedSchema(WITHDRAWALS_ROOT, SszPrimitiveSchemas.BYTES32_SCHEMA), - namedSchema(BLOB_GAS_USED, SszPrimitiveSchemas.UINT64_SCHEMA), - namedSchema(EXCESS_BLOB_GAS, SszPrimitiveSchemas.UINT64_SCHEMA)); - - final ExecutionPayloadEip7594Impl defaultExecutionPayload = - new ExecutionPayloadSchemaEip7594(specConfig).getDefault(); - - this.executionPayloadHeaderOfDefaultPayload = - createFromExecutionPayload(defaultExecutionPayload); - - this.defaultExecutionPayloadHeader = createFromBackingNode(getDefaultTree()); - } - - public SszByteListSchema getExtraDataSchema() { - return (SszByteListSchema) getChildSchema(getFieldIndex(EXTRA_DATA)); - } - - @Override - public LongList getBlindedNodeGeneralizedIndices() { - return LongList.of( - getChildGeneralizedIndex(getFieldIndex(TRANSACTIONS_ROOT)), - getChildGeneralizedIndex(getFieldIndex(WITHDRAWALS_ROOT))); - } - - @Override - public ExecutionPayloadHeader createExecutionPayloadHeader( - final Consumer builderConsumer) { - final ExecutionPayloadHeaderBuilderEip7594 builder = - new ExecutionPayloadHeaderBuilderEip7594().schema(this); - builderConsumer.accept(builder); - return builder.build(); - } - - @Override - public ExecutionPayloadHeaderEip7594Impl getDefault() { - return defaultExecutionPayloadHeader; - } - - @Override - public ExecutionPayloadHeaderEip7594 getHeaderOfDefaultPayload() { - return executionPayloadHeaderOfDefaultPayload; - } - - @Override - public ExecutionPayloadHeaderEip7594Impl createFromBackingNode(final TreeNode node) { - return new ExecutionPayloadHeaderEip7594Impl(this, node); - } - - @Override - public ExecutionPayloadHeaderEip7594Impl createFromExecutionPayload( - final ExecutionPayload payload) { - final ExecutionPayloadEip7594 executionPayload = ExecutionPayloadEip7594.required(payload); - return new ExecutionPayloadHeaderEip7594Impl( - this, - SszBytes32.of(executionPayload.getParentHash()), - SszByteVector.fromBytes(executionPayload.getFeeRecipient().getWrappedBytes()), - SszBytes32.of(executionPayload.getStateRoot()), - SszBytes32.of(executionPayload.getReceiptsRoot()), - SszByteVector.fromBytes(executionPayload.getLogsBloom()), - SszBytes32.of(executionPayload.getPrevRandao()), - SszUInt64.of(executionPayload.getBlockNumber()), - SszUInt64.of(executionPayload.getGasLimit()), - SszUInt64.of(executionPayload.getGasUsed()), - SszUInt64.of(executionPayload.getTimestamp()), - getExtraDataSchema().fromBytes(executionPayload.getExtraData()), - SszUInt256.of(executionPayload.getBaseFeePerGas()), - SszBytes32.of(executionPayload.getBlockHash()), - SszBytes32.of(executionPayload.getTransactions().hashTreeRoot()), - SszBytes32.of(executionPayload.getWithdrawals().hashTreeRoot()), - SszUInt64.of(executionPayload.getBlobGasUsed()), - SszUInt64.of(executionPayload.getExcessBlobGas())); - } -} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/eip7594/ExecutionPayloadSchemaEip7594.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/eip7594/ExecutionPayloadSchemaEip7594.java deleted file mode 100644 index 12e9c4b1396..00000000000 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/eip7594/ExecutionPayloadSchemaEip7594.java +++ /dev/null @@ -1,168 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.spec.datastructures.execution.versions.eip7594; - -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.BASE_FEE_PER_GAS; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.BLOB_GAS_USED; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.BLOCK_HASH; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.BLOCK_NUMBER; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.EXCESS_BLOB_GAS; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.EXTRA_DATA; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.FEE_RECIPIENT; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.GAS_LIMIT; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.GAS_USED; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.LOGS_BLOOM; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.PARENT_HASH; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.PREV_RANDAO; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.RECEIPTS_ROOT; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.STATE_ROOT; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.TIMESTAMP; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.TRANSACTIONS; -import static tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadFields.WITHDRAWALS; - -import it.unimi.dsi.fastutil.longs.LongList; -import java.util.function.Consumer; -import tech.pegasys.teku.infrastructure.bytes.Bytes20; -import tech.pegasys.teku.infrastructure.ssz.SszList; -import tech.pegasys.teku.infrastructure.ssz.collections.SszByteList; -import tech.pegasys.teku.infrastructure.ssz.collections.SszByteVector; -import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema17; -import tech.pegasys.teku.infrastructure.ssz.primitive.SszBytes32; -import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt256; -import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; -import tech.pegasys.teku.infrastructure.ssz.schema.SszListSchema; -import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; -import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszByteListSchema; -import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszByteVectorSchema; -import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadBuilder; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSchema; -import tech.pegasys.teku.spec.datastructures.execution.Transaction; -import tech.pegasys.teku.spec.datastructures.execution.TransactionSchema; -import tech.pegasys.teku.spec.datastructures.execution.versions.capella.Withdrawal; -import tech.pegasys.teku.spec.datastructures.execution.versions.capella.WithdrawalSchema; - -public class ExecutionPayloadSchemaEip7594 - extends ContainerSchema17< - ExecutionPayloadEip7594Impl, - SszBytes32, - SszByteVector, - SszBytes32, - SszBytes32, - SszByteVector, - SszBytes32, - SszUInt64, - SszUInt64, - SszUInt64, - SszUInt64, - SszByteList, - SszUInt256, - SszBytes32, - SszList, - SszList, - SszUInt64, - SszUInt64> - implements ExecutionPayloadSchema { - - private final ExecutionPayloadEip7594Impl defaultExecutionPayload; - - public ExecutionPayloadSchemaEip7594(final SpecConfigEip7594 specConfig) { - super( - "ExecutionPayloadEip7594", - namedSchema(PARENT_HASH, SszPrimitiveSchemas.BYTES32_SCHEMA), - namedSchema(FEE_RECIPIENT, SszByteVectorSchema.create(Bytes20.SIZE)), - namedSchema(STATE_ROOT, SszPrimitiveSchemas.BYTES32_SCHEMA), - namedSchema(RECEIPTS_ROOT, SszPrimitiveSchemas.BYTES32_SCHEMA), - namedSchema(LOGS_BLOOM, SszByteVectorSchema.create(specConfig.getBytesPerLogsBloom())), - namedSchema(PREV_RANDAO, SszPrimitiveSchemas.BYTES32_SCHEMA), - namedSchema(BLOCK_NUMBER, SszPrimitiveSchemas.UINT64_SCHEMA), - namedSchema(GAS_LIMIT, SszPrimitiveSchemas.UINT64_SCHEMA), - namedSchema(GAS_USED, SszPrimitiveSchemas.UINT64_SCHEMA), - namedSchema(TIMESTAMP, SszPrimitiveSchemas.UINT64_SCHEMA), - namedSchema(EXTRA_DATA, SszByteListSchema.create(specConfig.getMaxExtraDataBytes())), - namedSchema(BASE_FEE_PER_GAS, SszPrimitiveSchemas.UINT256_SCHEMA), - namedSchema(BLOCK_HASH, SszPrimitiveSchemas.BYTES32_SCHEMA), - namedSchema( - TRANSACTIONS, - SszListSchema.create( - new TransactionSchema(specConfig), specConfig.getMaxTransactionsPerPayload())), - namedSchema( - WITHDRAWALS, - SszListSchema.create(Withdrawal.SSZ_SCHEMA, specConfig.getMaxWithdrawalsPerPayload())), - namedSchema(BLOB_GAS_USED, SszPrimitiveSchemas.UINT64_SCHEMA), - namedSchema(EXCESS_BLOB_GAS, SszPrimitiveSchemas.UINT64_SCHEMA)); - this.defaultExecutionPayload = createFromBackingNode(getDefaultTree()); - } - - @Override - public ExecutionPayloadEip7594Impl getDefault() { - return defaultExecutionPayload; - } - - @Override - public TransactionSchema getTransactionSchema() { - return (TransactionSchema) getTransactionsSchema().getElementSchema(); - } - - @Override - public SszListSchema> getWithdrawalsSchemaRequired() { - return getWithdrawalsSchema(); - } - - @Override - public WithdrawalSchema getWithdrawalSchemaRequired() { - return getWithdrawalSchema(); - } - - public WithdrawalSchema getWithdrawalSchema() { - return (WithdrawalSchema) getWithdrawalsSchema().getElementSchema(); - } - - @Override - public LongList getBlindedNodeGeneralizedIndices() { - return LongList.of( - getChildGeneralizedIndex(getFieldIndex(TRANSACTIONS)), - getChildGeneralizedIndex(getFieldIndex(WITHDRAWALS))); - } - - @Override - public ExecutionPayload createExecutionPayload( - final Consumer builderConsumer) { - final ExecutionPayloadBuilderEip7594 builder = - new ExecutionPayloadBuilderEip7594().schema(this); - builderConsumer.accept(builder); - return builder.build(); - } - - @Override - public ExecutionPayloadEip7594Impl createFromBackingNode(final TreeNode node) { - return new ExecutionPayloadEip7594Impl(this, node); - } - - public SszByteListSchema getExtraDataSchema() { - return (SszByteListSchema) getChildSchema(getFieldIndex(EXTRA_DATA)); - } - - @SuppressWarnings("unchecked") - public SszListSchema getTransactionsSchema() { - return (SszListSchema) getChildSchema(getFieldIndex(TRANSACTIONS)); - } - - @SuppressWarnings("unchecked") - public SszListSchema getWithdrawalsSchema() { - return (SszListSchema) getChildSchema(getFieldIndex(WITHDRAWALS)); - } -} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ConsolidationRequest.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ConsolidationRequest.java new file mode 100644 index 00000000000..3327b990f65 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ConsolidationRequest.java @@ -0,0 +1,63 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.execution.versions.electra; + +import org.apache.tuweni.bytes.Bytes; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.infrastructure.bytes.Bytes20; +import tech.pegasys.teku.infrastructure.ssz.collections.SszByteVector; +import tech.pegasys.teku.infrastructure.ssz.containers.Container3; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.spec.datastructures.type.SszPublicKey; + +// https://eips.ethereum.org/EIPS/eip-7251 +public class ConsolidationRequest + extends Container3 { + + public static final byte REQUEST_TYPE = 0x2; + public static final Bytes REQUEST_TYPE_PREFIX = Bytes.of(REQUEST_TYPE); + + protected ConsolidationRequest( + final ConsolidationRequestSchema schema, + final Bytes20 sourceAddress, + final BLSPublicKey sourcePubkey, + final BLSPublicKey targetPubkey) { + super( + schema, + SszByteVector.fromBytes(sourceAddress.getWrappedBytes()), + new SszPublicKey(sourcePubkey), + new SszPublicKey(targetPubkey)); + } + + ConsolidationRequest(final ConsolidationRequestSchema type, final TreeNode backingNode) { + super(type, backingNode); + } + + public Bytes20 getSourceAddress() { + return new Bytes20(getField0().getBytes()); + } + + public BLSPublicKey getSourcePubkey() { + return getField1().getBLSPublicKey(); + } + + public BLSPublicKey getTargetPubkey() { + return getField2().getBLSPublicKey(); + } + + @Override + public ConsolidationRequestSchema getSchema() { + return (ConsolidationRequestSchema) super.getSchema(); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ConsolidationRequestSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ConsolidationRequestSchema.java new file mode 100644 index 00000000000..4341e58944c --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ConsolidationRequestSchema.java @@ -0,0 +1,47 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.execution.versions.electra; + +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.infrastructure.bytes.Bytes20; +import tech.pegasys.teku.infrastructure.ssz.collections.SszByteVector; +import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema3; +import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszByteVectorSchema; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.spec.datastructures.type.SszPublicKey; +import tech.pegasys.teku.spec.datastructures.type.SszPublicKeySchema; + +public class ConsolidationRequestSchema + extends ContainerSchema3 { + + public ConsolidationRequestSchema() { + super( + "ConsolidationRequest", + namedSchema("source_address", SszByteVectorSchema.create(Bytes20.SIZE)), + namedSchema("source_pubkey", SszPublicKeySchema.INSTANCE), + namedSchema("target_pubkey", SszPublicKeySchema.INSTANCE)); + } + + public ConsolidationRequest create( + final Bytes20 sourceAddress, + final BLSPublicKey sourcePubkey, + final BLSPublicKey targetPubkey) { + return new ConsolidationRequest(this, sourceAddress, sourcePubkey, targetPubkey); + } + + @Override + public ConsolidationRequest createFromBackingNode(final TreeNode node) { + return new ConsolidationRequest(this, node); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/DepositRequest.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/DepositRequest.java new file mode 100644 index 00000000000..72f504cbed5 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/DepositRequest.java @@ -0,0 +1,80 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.execution.versions.electra; + +import org.apache.tuweni.bytes.Bytes; +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.bls.BLSSignature; +import tech.pegasys.teku.infrastructure.ssz.containers.Container5; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszBytes32; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.datastructures.type.SszPublicKey; +import tech.pegasys.teku.spec.datastructures.type.SszSignature; + +// https://eips.ethereum.org/EIPS/eip-6110 +public class DepositRequest + extends Container5< + DepositRequest, SszPublicKey, SszBytes32, SszUInt64, SszSignature, SszUInt64> { + + public static final byte REQUEST_TYPE = 0x0; + public static final Bytes REQUEST_TYPE_PREFIX = Bytes.of(REQUEST_TYPE); + + DepositRequest( + final DepositRequestSchema schema, + final BLSPublicKey pubkey, + final Bytes32 withdrawalCredentials, + final UInt64 amount, + final BLSSignature signature, + final UInt64 index) { + super( + schema, + new SszPublicKey(pubkey), + SszBytes32.of(withdrawalCredentials), + SszUInt64.of(amount), + new SszSignature(signature), + SszUInt64.of(index)); + } + + DepositRequest(final DepositRequestSchema type, final TreeNode backingNode) { + super(type, backingNode); + } + + public BLSPublicKey getPubkey() { + return getField0().getBLSPublicKey(); + } + + public Bytes32 getWithdrawalCredentials() { + return getField1().get(); + } + + public UInt64 getAmount() { + return getField2().get(); + } + + public BLSSignature getSignature() { + return getField3().getSignature(); + } + + public UInt64 getIndex() { + return getField4().get(); + } + + @Override + public DepositRequestSchema getSchema() { + return (DepositRequestSchema) super.getSchema(); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/DepositRequestSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/DepositRequestSchema.java new file mode 100644 index 00000000000..d435a011244 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/DepositRequestSchema.java @@ -0,0 +1,57 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.execution.versions.electra; + +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.bls.BLSSignature; +import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema5; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszBytes32; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; +import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.datastructures.type.SszPublicKey; +import tech.pegasys.teku.spec.datastructures.type.SszPublicKeySchema; +import tech.pegasys.teku.spec.datastructures.type.SszSignature; +import tech.pegasys.teku.spec.datastructures.type.SszSignatureSchema; + +public class DepositRequestSchema + extends ContainerSchema5< + DepositRequest, SszPublicKey, SszBytes32, SszUInt64, SszSignature, SszUInt64> { + + public DepositRequestSchema() { + super( + "DepositRequest", + namedSchema("pubkey", SszPublicKeySchema.INSTANCE), + namedSchema("withdrawal_credentials", SszPrimitiveSchemas.BYTES32_SCHEMA), + namedSchema("amount", SszPrimitiveSchemas.UINT64_SCHEMA), + namedSchema("signature", SszSignatureSchema.INSTANCE), + namedSchema("index", SszPrimitiveSchemas.UINT64_SCHEMA)); + } + + public DepositRequest create( + final BLSPublicKey pubkey, + final Bytes32 withdrawalCredentials, + final UInt64 amount, + final BLSSignature signature, + final UInt64 index) { + return new DepositRequest(this, pubkey, withdrawalCredentials, amount, signature, index); + } + + @Override + public DepositRequest createFromBackingNode(final TreeNode node) { + return new DepositRequest(this, node); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ExecutionRequests.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ExecutionRequests.java new file mode 100644 index 00000000000..2fa29e03705 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ExecutionRequests.java @@ -0,0 +1,60 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.execution.versions.electra; + +import java.util.List; +import tech.pegasys.teku.infrastructure.ssz.SszList; +import tech.pegasys.teku.infrastructure.ssz.containers.Container3; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; + +public class ExecutionRequests + extends Container3< + ExecutionRequests, + SszList, + SszList, + SszList> { + + ExecutionRequests( + final ExecutionRequestsSchema schema, + final List deposits, + final List withdrawals, + final List consolidations) { + super( + schema, + schema.getDepositRequestsSchema().createFromElements(deposits), + schema.getWithdrawalRequestsSchema().createFromElements(withdrawals), + schema.getConsolidationRequestsSchema().createFromElements(consolidations)); + } + + ExecutionRequests(final ExecutionRequestsSchema type, final TreeNode backingNode) { + super(type, backingNode); + } + + public List getDeposits() { + return getField0().stream().toList(); + } + + public List getWithdrawals() { + return getField1().stream().toList(); + } + + public List getConsolidations() { + return getField2().stream().toList(); + } + + @Override + public ExecutionRequestsSchema getSchema() { + return (ExecutionRequestsSchema) super.getSchema(); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ExecutionRequestsBuilderElectra.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ExecutionRequestsBuilderElectra.java new file mode 100644 index 00000000000..38f06b5a3ab --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ExecutionRequestsBuilderElectra.java @@ -0,0 +1,62 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.execution.versions.electra; + +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_REQUESTS_SCHEMA; + +import com.google.common.annotations.VisibleForTesting; +import java.util.List; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionRequestsBuilder; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; + +public class ExecutionRequestsBuilderElectra implements ExecutionRequestsBuilder { + + private final ExecutionRequestsSchema executionRequestsSchemaElectra; + private List deposits = List.of(); + private List withdrawals = List.of(); + private List consolidations = List.of(); + + @VisibleForTesting + public ExecutionRequestsBuilderElectra(final SchemaRegistry schemaRegistry) { + this(schemaRegistry.get(EXECUTION_REQUESTS_SCHEMA)); + } + + public ExecutionRequestsBuilderElectra(final ExecutionRequestsSchema executionRequestsSchema) { + this.executionRequestsSchemaElectra = executionRequestsSchema; + } + + @Override + public ExecutionRequestsBuilder deposits(final List deposits) { + this.deposits = deposits; + return this; + } + + @Override + public ExecutionRequestsBuilder withdrawals(final List withdrawals) { + this.withdrawals = withdrawals; + return this; + } + + @Override + public ExecutionRequestsBuilder consolidations(final List consolidations) { + this.consolidations = consolidations; + return this; + } + + @Override + public ExecutionRequests build() { + return new ExecutionRequests( + executionRequestsSchemaElectra, deposits, withdrawals, consolidations); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ExecutionRequestsDataCodec.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ExecutionRequestsDataCodec.java new file mode 100644 index 00000000000..82a78cacff2 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ExecutionRequestsDataCodec.java @@ -0,0 +1,121 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.execution.versions.electra; + +import java.util.ArrayList; +import java.util.List; +import org.apache.tuweni.bytes.Bytes; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionRequestsBuilder; + +/* + Implement the rules for decoding and hashing execution requests according to https://eips.ethereum.org/EIPS/eip-7685 +*/ +public class ExecutionRequestsDataCodec { + + private final ExecutionRequestsSchema executionRequestsSchema; + + public ExecutionRequestsDataCodec(final ExecutionRequestsSchema executionRequestsSchema) { + this.executionRequestsSchema = executionRequestsSchema; + } + + /** + * Decodes the execution requests received from the EL. + * + * @param executionRequests list of encoded execution requests from the EL + * @return an ExecutionRequests object with the requests + */ + public ExecutionRequests decode(final List executionRequests) { + final ExecutionRequestsBuilder executionRequestsBuilder = + new ExecutionRequestsBuilderElectra(executionRequestsSchema); + + byte previousRequestType = -1; + for (final Bytes request : executionRequests) { + if (request.isEmpty()) { + throw new IllegalArgumentException("Execution request data must not be empty"); + } + final byte requestType = request.get(0); + if (requestType <= previousRequestType) { + throw new IllegalArgumentException( + "Execution requests are not in strictly ascending order"); + } + final Bytes requestData = request.slice(1); + switch (requestType) { + case DepositRequest.REQUEST_TYPE -> + executionRequestsBuilder.deposits( + executionRequestsSchema + .getDepositRequestsSchema() + .sszDeserialize(requestData) + .asList()); + case WithdrawalRequest.REQUEST_TYPE -> + executionRequestsBuilder.withdrawals( + executionRequestsSchema + .getWithdrawalRequestsSchema() + .sszDeserialize(requestData) + .asList()); + case ConsolidationRequest.REQUEST_TYPE -> + executionRequestsBuilder.consolidations( + executionRequestsSchema + .getConsolidationRequestsSchema() + .sszDeserialize(requestData) + .asList()); + default -> + throw new IllegalArgumentException("Invalid execution request type: " + requestType); + } + previousRequestType = requestType; + } + + return executionRequestsBuilder.build(); + } + + /** + * Encodes the provided ExecutionRequests object to send the requests to the EL for validation. + * + * @param executionRequests the execution requests in the BeaconBlock + * @return list of encoded execution requests + */ + public List encode(final ExecutionRequests executionRequests) { + final List executionRequestsData = new ArrayList<>(); + final List deposits = executionRequests.getDeposits(); + if (!deposits.isEmpty()) { + final Bytes depositRequestsData = + executionRequestsSchema + .getDepositRequestsSchema() + .createFromElements(deposits) + .sszSerialize(); + executionRequestsData.add( + Bytes.concatenate(DepositRequest.REQUEST_TYPE_PREFIX, depositRequestsData)); + } + final List withdrawals = executionRequests.getWithdrawals(); + if (!withdrawals.isEmpty()) { + final Bytes withdrawalsRequestsData = + executionRequestsSchema + .getWithdrawalRequestsSchema() + .createFromElements(withdrawals) + .sszSerialize(); + executionRequestsData.add( + Bytes.concatenate(WithdrawalRequest.REQUEST_TYPE_PREFIX, withdrawalsRequestsData)); + } + final List consolidations = executionRequests.getConsolidations(); + if (!consolidations.isEmpty()) { + final Bytes consolidationRequestsData = + executionRequestsSchema + .getConsolidationRequestsSchema() + .createFromElements(consolidations) + .sszSerialize(); + executionRequestsData.add( + Bytes.concatenate(ConsolidationRequest.REQUEST_TYPE_PREFIX, consolidationRequestsData)); + } + return executionRequestsData; + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/eip7594/ExecutionPayloadHeaderEip7594.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ExecutionRequestsFields.java similarity index 63% rename from ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/eip7594/ExecutionPayloadHeaderEip7594.java rename to ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ExecutionRequestsFields.java index fa288730288..e4abb9d309f 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/eip7594/ExecutionPayloadHeaderEip7594.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ExecutionRequestsFields.java @@ -11,15 +11,24 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.spec.datastructures.execution.versions.eip7594; +package tech.pegasys.teku.spec.datastructures.execution.versions.electra; -import java.util.Optional; -import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadHeaderDeneb; +import java.util.Locale; +import tech.pegasys.teku.infrastructure.ssz.schema.SszFieldName; -public interface ExecutionPayloadHeaderEip7594 extends ExecutionPayloadHeaderDeneb { +public enum ExecutionRequestsFields implements SszFieldName { + DEPOSITS, + WITHDRAWALS, + CONSOLIDATIONS; + + private final String sszFieldName; + + ExecutionRequestsFields() { + this.sszFieldName = name().toLowerCase(Locale.ROOT); + } @Override - default Optional toVersionEip7594() { - return Optional.of(this); + public String getSszFieldName() { + return sszFieldName; } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ExecutionRequestsSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ExecutionRequestsSchema.java new file mode 100644 index 00000000000..8c138299aba --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ExecutionRequestsSchema.java @@ -0,0 +1,87 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.execution.versions.electra; + +import static tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsFields.CONSOLIDATIONS; +import static tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsFields.DEPOSITS; +import static tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsFields.WITHDRAWALS; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.CONSOLIDATION_REQUEST_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.DEPOSIT_REQUEST_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.WITHDRAWAL_REQUEST_SCHEMA; + +import java.util.List; +import tech.pegasys.teku.infrastructure.ssz.SszList; +import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema3; +import tech.pegasys.teku.infrastructure.ssz.schema.SszListSchema; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; + +public class ExecutionRequestsSchema + extends ContainerSchema3< + ExecutionRequests, + SszList, + SszList, + SszList> { + + public ExecutionRequestsSchema( + final SpecConfigElectra specConfig, + final SchemaRegistry schemaRegistry, + final String containerName) { + super( + containerName, + namedSchema( + DEPOSITS, + SszListSchema.create( + schemaRegistry.get(DEPOSIT_REQUEST_SCHEMA), + specConfig.getMaxDepositRequestsPerPayload())), + namedSchema( + WITHDRAWALS, + SszListSchema.create( + schemaRegistry.get(WITHDRAWAL_REQUEST_SCHEMA), + specConfig.getMaxWithdrawalRequestsPerPayload())), + namedSchema( + CONSOLIDATIONS, + SszListSchema.create( + schemaRegistry.get(CONSOLIDATION_REQUEST_SCHEMA), + specConfig.getMaxConsolidationRequestsPerPayload()))); + } + + public ExecutionRequests create( + final List deposits, + final List withdrawals, + final List consolidations) { + return new ExecutionRequests(this, deposits, withdrawals, consolidations); + } + + @Override + public ExecutionRequests createFromBackingNode(final TreeNode node) { + return new ExecutionRequests(this, node); + } + + @SuppressWarnings("unchecked") + public SszListSchema getDepositRequestsSchema() { + return (SszListSchema) getChildSchema(getFieldIndex(DEPOSITS)); + } + + @SuppressWarnings("unchecked") + public SszListSchema getWithdrawalRequestsSchema() { + return (SszListSchema) getChildSchema(getFieldIndex(WITHDRAWALS)); + } + + @SuppressWarnings("unchecked") + public SszListSchema getConsolidationRequestsSchema() { + return (SszListSchema) getChildSchema(getFieldIndex(CONSOLIDATIONS)); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/WithdrawalRequest.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/WithdrawalRequest.java new file mode 100644 index 00000000000..335ad7d9b2c --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/WithdrawalRequest.java @@ -0,0 +1,65 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.execution.versions.electra; + +import org.apache.tuweni.bytes.Bytes; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.infrastructure.bytes.Bytes20; +import tech.pegasys.teku.infrastructure.ssz.collections.SszByteVector; +import tech.pegasys.teku.infrastructure.ssz.containers.Container3; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.datastructures.type.SszPublicKey; + +// https://eips.ethereum.org/EIPS/eip-7002 +public class WithdrawalRequest + extends Container3 { + + public static final byte REQUEST_TYPE = 0x1; + public static final Bytes REQUEST_TYPE_PREFIX = Bytes.of(REQUEST_TYPE); + + protected WithdrawalRequest( + final WithdrawalRequestSchema schema, + final Bytes20 sourceAddress, + final BLSPublicKey validatorPubkey, + final UInt64 amount) { + super( + schema, + SszByteVector.fromBytes(sourceAddress.getWrappedBytes()), + new SszPublicKey(validatorPubkey), + SszUInt64.of(amount)); + } + + WithdrawalRequest(final WithdrawalRequestSchema type, final TreeNode backingNode) { + super(type, backingNode); + } + + public Bytes20 getSourceAddress() { + return new Bytes20(getField0().getBytes()); + } + + public BLSPublicKey getValidatorPubkey() { + return getField1().getBLSPublicKey(); + } + + public UInt64 getAmount() { + return getField2().get(); + } + + @Override + public WithdrawalRequestSchema getSchema() { + return (WithdrawalRequestSchema) super.getSchema(); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/WithdrawalRequestSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/WithdrawalRequestSchema.java new file mode 100644 index 00000000000..6aad998cd30 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/WithdrawalRequestSchema.java @@ -0,0 +1,48 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.execution.versions.electra; + +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.infrastructure.bytes.Bytes20; +import tech.pegasys.teku.infrastructure.ssz.collections.SszByteVector; +import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema3; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; +import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; +import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszByteVectorSchema; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.datastructures.type.SszPublicKey; +import tech.pegasys.teku.spec.datastructures.type.SszPublicKeySchema; + +public class WithdrawalRequestSchema + extends ContainerSchema3 { + + public WithdrawalRequestSchema() { + super( + "WithdrawalRequest", + namedSchema("source_address", SszByteVectorSchema.create(Bytes20.SIZE)), + namedSchema("validator_pubkey", SszPublicKeySchema.INSTANCE), + namedSchema("amount", SszPrimitiveSchemas.UINT64_SCHEMA)); + } + + public WithdrawalRequest create( + final Bytes20 sourceAddress, final BLSPublicKey validatorPubkey, final UInt64 amount) { + return new WithdrawalRequest(this, sourceAddress, validatorPubkey, amount); + } + + @Override + public WithdrawalRequest createFromBackingNode(final TreeNode node) { + return new WithdrawalRequest(this, node); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/forkchoice/ReadOnlyStore.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/forkchoice/ReadOnlyStore.java index de4524c27d3..e2aad9a79d7 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/forkchoice/ReadOnlyStore.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/forkchoice/ReadOnlyStore.java @@ -102,11 +102,11 @@ default UInt64 getGenesisTimeMillis() { * @param blockRoot The block root of the block to retrieve * @return The block if available. */ - Optional getBlockIfAvailable(final Bytes32 blockRoot); + Optional getBlockIfAvailable(Bytes32 blockRoot); Optional> getBlobSidecarsIfAvailable(SlotAndBlockRoot slotAndBlockRoot); - default SafeFuture> retrieveBlock(Bytes32 blockRoot) { + default SafeFuture> retrieveBlock(final Bytes32 blockRoot) { return retrieveSignedBlock(blockRoot).thenApply(res -> res.map(SignedBeaconBlock::getMessage)); } @@ -135,8 +135,8 @@ SafeFuture> retrieveCheckpointState( // implements is_parent_strong from fork-choice Consensus Spec boolean isParentStrong(Bytes32 parentRoot); - void computeBalanceThresholds(final BeaconState justifiedState); + void computeBalanceThresholds(BeaconState justifiedState); // implements is_ffg_competitive from Consensus Spec - Optional isFfgCompetitive(final Bytes32 headRoot, final Bytes32 parentRoot); + Optional isFfgCompetitive(Bytes32 headRoot, Bytes32 parentRoot); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/forkchoice/VoteTracker.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/forkchoice/VoteTracker.java index 3ddc18f0a3c..90c6344b7ab 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/forkchoice/VoteTracker.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/forkchoice/VoteTracker.java @@ -34,11 +34,11 @@ public VoteTracker(final Bytes32 currentRoot, final Bytes32 nextRoot, final UInt } public VoteTracker( - Bytes32 currentRoot, - Bytes32 nextRoot, - UInt64 nextEpoch, - boolean nextEquivocating, - boolean currentEquivocating) { + final Bytes32 currentRoot, + final Bytes32 nextRoot, + final UInt64 nextEpoch, + final boolean nextEquivocating, + final boolean currentEquivocating) { this.currentRoot = currentRoot; this.nextRoot = nextRoot; this.nextEpoch = nextEpoch; @@ -75,7 +75,7 @@ public VoteTracker createNextEquivocating() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/hashtree/HashTree.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/hashtree/HashTree.java index 3f45285c83f..0d0b89746a8 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/hashtree/HashTree.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/hashtree/HashTree.java @@ -94,7 +94,7 @@ public Set getAllRoots() { * @param head The root defining the head of the chain to process * @param processor The callback to invoke for each child-parent pair */ - public void processHashesInChain(final Bytes32 head, NodeProcessor processor) { + public void processHashesInChain(final Bytes32 head, final NodeProcessor processor) { processHashesInChainWhile(head, HaltableNodeProcessor.fromNodeProcessor(processor)); } @@ -107,7 +107,7 @@ public void processHashesInChain(final Bytes32 head, NodeProcessor processor) { * @return A list of roots in ascending order belonging to the chain defined by {@code head} */ public List collectChainRoots( - final Bytes32 head, Function shouldContinue) { + final Bytes32 head, final Function shouldContinue) { final Deque chain = new ArrayDeque<>(); processHashesInChainWhile( head, @@ -126,7 +126,8 @@ public List collectChainRoots( * @param nodeProcessor The callback receiving hashes and determining whether to continue * processing */ - public void processHashesInChainWhile(final Bytes32 head, HaltableNodeProcessor nodeProcessor) { + public void processHashesInChainWhile( + final Bytes32 head, final HaltableNodeProcessor nodeProcessor) { checkArgument(contains(head), "Unknown root supplied: " + head); Optional currentRoot = Optional.of(head); @@ -182,7 +183,7 @@ private Stream createBreadthFirstStream(final Bytes32 rootNodeHash) { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (o == this) { return true; } @@ -242,7 +243,7 @@ public Builder rootHash(final Bytes32 rootBlockHash) { return this; } - public Builder childAndParentRoots(Map childToParentMap) { + public Builder childAndParentRoots(final Map childToParentMap) { checkNotNull(childToParentMap); this.childToParentMap.putAll(childToParentMap); return this; diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/hashtree/traversal/BreadthFirstTraversalTreeIterator.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/hashtree/traversal/BreadthFirstTraversalTreeIterator.java index 7cd532e6348..a77695b6b46 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/hashtree/traversal/BreadthFirstTraversalTreeIterator.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/hashtree/traversal/BreadthFirstTraversalTreeIterator.java @@ -23,12 +23,12 @@ class BreadthFirstTraversalTreeIterator implements Iterator { private final Deque remainingNodes = new ArrayDeque<>(); private final ChildLookup childLookup; - private BreadthFirstTraversalTreeIterator(final Bytes32 rootHash, ChildLookup childLookup) { + private BreadthFirstTraversalTreeIterator(final Bytes32 rootHash, final ChildLookup childLookup) { this.childLookup = childLookup; remainingNodes.push(rootHash); } - public static Iterator create(final Bytes32 rootNode, ChildLookup childLookup) { + public static Iterator create(final Bytes32 rootNode, final ChildLookup childLookup) { return new BreadthFirstTraversalTreeIterator(rootNode, childLookup); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/hashtree/traversal/OrderedTreeStream.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/hashtree/traversal/OrderedTreeStream.java index 33f8addedeb..160589aa74b 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/hashtree/traversal/OrderedTreeStream.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/hashtree/traversal/OrderedTreeStream.java @@ -22,18 +22,18 @@ public class OrderedTreeStream { public static Stream createPreOrderTraversalStream( - final Bytes32 rootHash, ChildLookup childLookup) { + final Bytes32 rootHash, final ChildLookup childLookup) { Iterator iterator = PreOrderTraversalTreeIterator.create(rootHash, childLookup); return iteratorToStream(iterator); } public static Stream createBreadthFirstStream( - final Bytes32 rootHash, ChildLookup childLookup) { + final Bytes32 rootHash, final ChildLookup childLookup) { Iterator iterator = BreadthFirstTraversalTreeIterator.create(rootHash, childLookup); return iteratorToStream(iterator); } - private static Stream iteratorToStream(Iterator iterator) { + private static Stream iteratorToStream(final Iterator iterator) { final Spliterator split = Spliterators.spliteratorUnknownSize( iterator, diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/hashtree/traversal/PreOrderTraversalTreeIterator.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/hashtree/traversal/PreOrderTraversalTreeIterator.java index cc06887ea61..55c90d87aeb 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/hashtree/traversal/PreOrderTraversalTreeIterator.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/hashtree/traversal/PreOrderTraversalTreeIterator.java @@ -23,12 +23,12 @@ class PreOrderTraversalTreeIterator implements Iterator { private final Deque remainingNodes = new ArrayDeque<>(); private final ChildLookup childLookup; - private PreOrderTraversalTreeIterator(final Bytes32 rootHash, ChildLookup childLookup) { + private PreOrderTraversalTreeIterator(final Bytes32 rootHash, final ChildLookup childLookup) { this.childLookup = childLookup; remainingNodes.push(rootHash); } - public static Iterator create(final Bytes32 rootNode, ChildLookup childLookup) { + public static Iterator create(final Bytes32 rootNode, final ChildLookup childLookup) { return new PreOrderTraversalTreeIterator(rootNode, childLookup); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/interop/GenesisStateBuilder.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/interop/GenesisStateBuilder.java index 646bb2b6f20..96970adefde 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/interop/GenesisStateBuilder.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/interop/GenesisStateBuilder.java @@ -18,19 +18,24 @@ import java.util.ArrayList; import java.util.List; import java.util.Optional; +import org.apache.tuweni.bytes.Bytes; import org.apache.tuweni.bytes.Bytes32; +import org.apache.tuweni.units.bigints.UInt256; import tech.pegasys.teku.bls.BLSKeyPair; import tech.pegasys.teku.infrastructure.bytes.Bytes20; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSummary; import tech.pegasys.teku.spec.datastructures.operations.Deposit; import tech.pegasys.teku.spec.datastructures.operations.DepositData; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.datastructures.util.DepositGenerator; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsBellatrix; public class GenesisStateBuilder { + private Spec spec; private boolean signDeposits = true; private UInt64 genesisTime = UInt64.ZERO; @@ -39,10 +44,19 @@ public class GenesisStateBuilder { public BeaconState build() { checkNotNull(spec, "Must provide a spec"); + + // If our Genesis is post-Bellatrix, we must have a non-default Execution Payload Header (but we + // should not override if one has been specified) + if (executionPayloadHeader.isEmpty() + && spec.getGenesisSpec().getMilestone().isGreaterThanOrEqualTo(SpecMilestone.CAPELLA)) { + executionPayloadHeader = Optional.of(mockExecutionPayloadHeader()); + } + final Bytes32 eth1BlockHash = executionPayloadHeader .map(ExecutionPayloadSummary::getBlockHash) .orElseGet(this::generateMockGenesisBlockHash); + final BeaconState initialState = spec.initializeBeaconStateFromEth1( eth1BlockHash, genesisTime, genesisDeposits, executionPayloadHeader); @@ -126,4 +140,31 @@ public GenesisStateBuilder executionPayloadHeader( private Bytes32 generateMockGenesisBlockHash() { return Bytes32.repeat((byte) 0x42); } + + private ExecutionPayloadHeader mockExecutionPayloadHeader() { + return SchemaDefinitionsBellatrix.required(spec.getGenesisSchemaDefinitions()) + .getExecutionPayloadHeaderSchema() + .createExecutionPayloadHeader( + b -> { + b.blockHash(generateMockGenesisBlockHash()); + b.parentHash(Bytes32.ZERO); + b.feeRecipient(Bytes20.ZERO); + b.stateRoot(Bytes32.ZERO); + b.receiptsRoot(Bytes32.ZERO); + b.logsBloom(Bytes.repeat((byte) 0x00, 256)); + b.prevRandao(Bytes32.ZERO); + b.blockNumber(UInt64.ZERO); + b.gasLimit(UInt64.ZERO); + b.gasUsed(UInt64.ZERO); + b.timestamp(UInt64.ZERO); + b.extraData(Bytes.repeat((byte) 0x00, 20)); + b.baseFeePerGas(UInt256.ZERO); + b.transactionsRoot(Bytes32.ZERO); + // Capella + b.withdrawalsRoot(() -> Bytes32.ZERO); + // Deneb + b.blobGasUsed(() -> UInt64.ZERO); + b.excessBlobGas(() -> UInt64.ZERO); + }); + } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/lightclient/LightClientBootstrapSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/lightclient/LightClientBootstrapSchema.java index 603c332b339..72ffbc1d29a 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/lightclient/LightClientBootstrapSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/lightclient/LightClientBootstrapSchema.java @@ -36,9 +36,9 @@ public LightClientBootstrapSchema(final SpecConfigAltair specConfigAltair) { } public LightClientBootstrap create( - LightClientHeader lightClientHeader, - SyncCommittee syncCommittee, - SszBytes32Vector syncCommitteeBranch) { + final LightClientHeader lightClientHeader, + final SyncCommittee syncCommittee, + final SszBytes32Vector syncCommitteeBranch) { return new LightClientBootstrap(this, lightClientHeader, syncCommittee, syncCommitteeBranch); } @@ -48,7 +48,7 @@ public SszBytes32VectorSchema getSyncCommitteeBranchSchema() { } @Override - public LightClientBootstrap createFromBackingNode(TreeNode node) { + public LightClientBootstrap createFromBackingNode(final TreeNode node) { return new LightClientBootstrap(this, node); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/lightclient/LightClientHeaderSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/lightclient/LightClientHeaderSchema.java index 3b8ae7a2aa2..3726020af82 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/lightclient/LightClientHeaderSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/lightclient/LightClientHeaderSchema.java @@ -24,12 +24,12 @@ public LightClientHeaderSchema() { super("LightClientHeader", namedSchema("beacon", BeaconBlockHeader.SSZ_SCHEMA)); } - public LightClientHeader create(BeaconBlockHeader beaconBlockHeader) { + public LightClientHeader create(final BeaconBlockHeader beaconBlockHeader) { return new LightClientHeader(this, beaconBlockHeader); } @Override - public LightClientHeader createFromBackingNode(TreeNode node) { + public LightClientHeader createFromBackingNode(final TreeNode node) { return new LightClientHeader(this, node); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/lightclient/LightClientUpdateResponseSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/lightclient/LightClientUpdateResponseSchema.java index 41885b26e0e..71036720f29 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/lightclient/LightClientUpdateResponseSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/lightclient/LightClientUpdateResponseSchema.java @@ -32,12 +32,12 @@ public LightClientUpdateResponseSchema(final SpecConfigAltair specConfigAltair) } public LightClientUpdateResponse create( - SszUInt64 responseChunkLen, SszBytes4 context, LightClientUpdate payload) { + final SszUInt64 responseChunkLen, final SszBytes4 context, final LightClientUpdate payload) { return new LightClientUpdateResponse(this, responseChunkLen, context, payload); } @Override - public LightClientUpdateResponse createFromBackingNode(TreeNode node) { + public LightClientUpdateResponse createFromBackingNode(final TreeNode node) { return new LightClientUpdateResponse(this, node); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/lightclient/LightClientUpdateSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/lightclient/LightClientUpdateSchema.java index 8013371403f..d9516525926 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/lightclient/LightClientUpdateSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/lightclient/LightClientUpdateSchema.java @@ -53,13 +53,13 @@ public LightClientUpdateSchema(final SpecConfigAltair specConfigAltair) { } public LightClientUpdate create( - LightClientHeader attestedHeader, - SyncCommittee nextSyncCommittee, - SszBytes32Vector nextSyncCommitteeBranch, - LightClientHeader finalizedHeader, - SszBytes32Vector finalityBranch, - SyncAggregate syncAggregate, - SszUInt64 signatureSlot) { + final LightClientHeader attestedHeader, + final SyncCommittee nextSyncCommittee, + final SszBytes32Vector nextSyncCommitteeBranch, + final LightClientHeader finalizedHeader, + final SszBytes32Vector finalityBranch, + final SyncAggregate syncAggregate, + final SszUInt64 signatureSlot) { return new LightClientUpdate( this, attestedHeader, @@ -72,7 +72,7 @@ public LightClientUpdate create( } @Override - public LightClientUpdate createFromBackingNode(TreeNode node) { + public LightClientUpdate createFromBackingNode(final TreeNode node) { return new LightClientUpdate(this, node); } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/SszResponse.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/metadata/BlobSidecarsAndMetaData.java similarity index 50% rename from data/serializer/src/main/java/tech/pegasys/teku/api/response/SszResponse.java rename to ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/metadata/BlobSidecarsAndMetaData.java index 519be2e24e9..01e96a178ff 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/SszResponse.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/metadata/BlobSidecarsAndMetaData.java @@ -1,5 +1,5 @@ /* - * Copyright Consensys Software Inc., 2022 + * Copyright Consensys Software Inc., 2024 * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at @@ -11,23 +11,20 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.api.response; +package tech.pegasys.teku.spec.datastructures.metadata; -import java.io.ByteArrayInputStream; -import tech.pegasys.teku.api.schema.Version; +import java.util.List; import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; -public class SszResponse { - public final ByteArrayInputStream byteStream; - public final Version version; - public final String abbreviatedHash; +public class BlobSidecarsAndMetaData extends ObjectAndMetaData> { - public SszResponse( - final ByteArrayInputStream byteStream, - final String abbreviatedHash, - final SpecMilestone specMilestone) { - this.byteStream = byteStream; - this.abbreviatedHash = abbreviatedHash; - this.version = Version.fromMilestone(specMilestone); + public BlobSidecarsAndMetaData( + final List data, + final SpecMilestone milestone, + final boolean executionOptimistic, + final boolean canonical, + final boolean finalized) { + super(data, milestone, executionOptimistic, canonical, finalized); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/metadata/ObjectAndMetaDataBuilder.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/metadata/ObjectAndMetaDataBuilder.java index fd24c550f16..adadac23ede 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/metadata/ObjectAndMetaDataBuilder.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/metadata/ObjectAndMetaDataBuilder.java @@ -22,27 +22,27 @@ public class ObjectAndMetaDataBuilder { private boolean canonical; private boolean finalized; - public ObjectAndMetaDataBuilder data(T data) { + public ObjectAndMetaDataBuilder data(final T data) { this.data = data; return this; } - public ObjectAndMetaDataBuilder milestone(SpecMilestone milestone) { + public ObjectAndMetaDataBuilder milestone(final SpecMilestone milestone) { this.milestone = milestone; return this; } - public ObjectAndMetaDataBuilder executionOptimistic(boolean executionOptimistic) { + public ObjectAndMetaDataBuilder executionOptimistic(final boolean executionOptimistic) { this.executionOptimistic = executionOptimistic; return this; } - public ObjectAndMetaDataBuilder canonical(boolean canonical) { + public ObjectAndMetaDataBuilder canonical(final boolean canonical) { this.canonical = canonical; return this; } - public ObjectAndMetaDataBuilder finalized(boolean finalized) { + public ObjectAndMetaDataBuilder finalized(final boolean finalized) { this.finalized = finalized; return this; } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/BeaconBlocksByRangeRequestMessage.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/BeaconBlocksByRangeRequestMessage.java index 36edd39f17d..f589b7ac105 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/BeaconBlocksByRangeRequestMessage.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/BeaconBlocksByRangeRequestMessage.java @@ -36,7 +36,7 @@ public BeaconBlocksByRangeRequestMessageSchema() { } @Override - public BeaconBlocksByRangeRequestMessage createFromBackingNode(TreeNode node) { + public BeaconBlocksByRangeRequestMessage createFromBackingNode(final TreeNode node) { return new BeaconBlocksByRangeRequestMessage(this, node); } } @@ -45,7 +45,7 @@ public BeaconBlocksByRangeRequestMessage createFromBackingNode(TreeNode node) { new BeaconBlocksByRangeRequestMessageSchema(); private BeaconBlocksByRangeRequestMessage( - BeaconBlocksByRangeRequestMessageSchema type, TreeNode backingNode) { + final BeaconBlocksByRangeRequestMessageSchema type, final TreeNode backingNode) { super(type, backingNode); } @@ -67,7 +67,7 @@ public UInt64 getStep() { } public UInt64 getMaxSlot() { - return getStartSlot().plus(getCount().minus(1).times(getStep())); + return getStartSlot().plus(getCount().minusMinZero(1).times(getStep())); } @Override diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/BeaconBlocksByRootRequestMessage.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/BeaconBlocksByRootRequestMessage.java index b34c39067ed..08ddbfe6c2e 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/BeaconBlocksByRootRequestMessage.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/BeaconBlocksByRootRequestMessage.java @@ -35,18 +35,18 @@ public BeaconBlocksByRootRequestMessageSchema(final SpecConfig specConfig) { } @Override - public BeaconBlocksByRootRequestMessage createFromBackingNode(TreeNode node) { + public BeaconBlocksByRootRequestMessage createFromBackingNode(final TreeNode node) { return new BeaconBlocksByRootRequestMessage(this, node); } } public BeaconBlocksByRootRequestMessage( - final BeaconBlocksByRootRequestMessageSchema schema, List roots) { + final BeaconBlocksByRootRequestMessageSchema schema, final List roots) { super(schema, schema.createTreeFromElements(roots.stream().map(SszBytes32::of).toList())); } private BeaconBlocksByRootRequestMessage( - BeaconBlocksByRootRequestMessageSchema schema, TreeNode node) { + final BeaconBlocksByRootRequestMessageSchema schema, final TreeNode node) { super(schema, node); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/BlobSidecarsByRangeRequestMessage.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/BlobSidecarsByRangeRequestMessage.java index 6ab04e4efd0..3285704f85f 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/BlobSidecarsByRangeRequestMessage.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/BlobSidecarsByRangeRequestMessage.java @@ -68,7 +68,7 @@ public UInt64 getCount() { } public UInt64 getMaxSlot() { - return getStartSlot().plus(getCount()).minusMinZero(1); + return getStartSlot().plus(getCount().minusMinZero(1)); } @Override diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/DataColumnIdentifier.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/DataColumnIdentifier.java index 5e706a599b4..1e49016bee4 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/DataColumnIdentifier.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/DataColumnIdentifier.java @@ -43,7 +43,7 @@ public DataColumnIdentifier createFromBackingNode(final TreeNode node) { public static final DataColumnIdentifierSchema SSZ_SCHEMA = new DataColumnIdentifierSchema(); - public static DataColumnIdentifier createFromSidecar(DataColumnSidecar sidecar) { + public static DataColumnIdentifier createFromSidecar(final DataColumnSidecar sidecar) { return new DataColumnIdentifier(sidecar.getBlockRoot(), sidecar.getIndex()); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/DataColumnSidecarsByRangeRequestMessage.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/DataColumnSidecarsByRangeRequestMessage.java index 8085620b13a..b92875ac4a9 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/DataColumnSidecarsByRangeRequestMessage.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/DataColumnSidecarsByRangeRequestMessage.java @@ -24,7 +24,7 @@ import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszUInt64ListSchema; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.features.Eip7594; public class DataColumnSidecarsByRangeRequestMessage extends Container3 @@ -34,14 +34,12 @@ public static class DataColumnSidecarsByRangeRequestMessageSchema extends ContainerSchema3< DataColumnSidecarsByRangeRequestMessage, SszUInt64, SszUInt64, SszUInt64List> { - public DataColumnSidecarsByRangeRequestMessageSchema( - final SpecConfigEip7594 specConfigEip7594) { + public DataColumnSidecarsByRangeRequestMessageSchema(final Eip7594 featureConfig) { super( "DataColumnSidecarsByRangeRequestMessage", namedSchema("start_slot", SszPrimitiveSchemas.UINT64_SCHEMA), namedSchema("count", SszPrimitiveSchemas.UINT64_SCHEMA), - namedSchema( - "columns", SszUInt64ListSchema.create(specConfigEip7594.getNumberOfColumns()))); + namedSchema("columns", SszUInt64ListSchema.create(featureConfig.getNumberOfColumns()))); } @Override diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/DataColumnSidecarsByRootRequestMessageSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/DataColumnSidecarsByRootRequestMessageSchema.java index b7f91f8cae1..492d563fde0 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/DataColumnSidecarsByRootRequestMessageSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/DataColumnSidecarsByRootRequestMessageSchema.java @@ -15,13 +15,13 @@ import tech.pegasys.teku.infrastructure.ssz.schema.impl.AbstractSszListSchema; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.features.Eip7594; public class DataColumnSidecarsByRootRequestMessageSchema extends AbstractSszListSchema { - public DataColumnSidecarsByRootRequestMessageSchema(final SpecConfigEip7594 specConfigEip7594) { - super(DataColumnIdentifier.SSZ_SCHEMA, specConfigEip7594.getMaxRequestDataColumnSidecars()); + public DataColumnSidecarsByRootRequestMessageSchema(final Eip7594 featureConfig) { + super(DataColumnIdentifier.SSZ_SCHEMA, featureConfig.getMaxRequestDataColumnSidecars()); } @Override diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/EmptyMessage.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/EmptyMessage.java index c57256102c5..a34fb52d644 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/EmptyMessage.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/EmptyMessage.java @@ -27,7 +27,7 @@ private EmptyMessageSchema() { } @Override - public EmptyMessage createFromBackingNode(TreeNode node) { + public EmptyMessage createFromBackingNode(final TreeNode node) { return EMPTY_MESSAGE; } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/EnrForkId.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/EnrForkId.java index 22c7b10cbd1..cf8a51c1ec3 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/EnrForkId.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/EnrForkId.java @@ -36,14 +36,14 @@ public EnrForkIdSchema() { } @Override - public EnrForkId createFromBackingNode(TreeNode node) { + public EnrForkId createFromBackingNode(final TreeNode node) { return new EnrForkId(this, node); } } public static final EnrForkIdSchema SSZ_SCHEMA = new EnrForkIdSchema(); - private EnrForkId(EnrForkIdSchema type, TreeNode backingNode) { + private EnrForkId(final EnrForkIdSchema type, final TreeNode backingNode) { super(type, backingNode); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/GoodbyeMessage.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/GoodbyeMessage.java index 808e876b7f2..1dc7debacb9 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/GoodbyeMessage.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/GoodbyeMessage.java @@ -32,7 +32,7 @@ public GoodbyeMessageSchema() { } @Override - public GoodbyeMessage createFromBackingNode(TreeNode node) { + public GoodbyeMessage createFromBackingNode(final TreeNode node) { return new GoodbyeMessage(this, node); } } @@ -51,11 +51,11 @@ public GoodbyeMessage createFromBackingNode(TreeNode node) { public static final UInt64 REASON_BAD_SCORE = UInt64.valueOf(250); public static final UInt64 REASON_BANNED = UInt64.valueOf(251); - private GoodbyeMessage(GoodbyeMessageSchema type, TreeNode backingNode) { + private GoodbyeMessage(final GoodbyeMessageSchema type, final TreeNode backingNode) { super(type, backingNode); } - public GoodbyeMessage(UInt64 reason) { + public GoodbyeMessage(final UInt64 reason) { super(SSZ_SCHEMA, SszUInt64.of(reason)); checkArgument( REASON_CLIENT_SHUT_DOWN.equals(reason) diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/PingMessage.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/PingMessage.java index 3662e5a9603..8821627ccbe 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/PingMessage.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/PingMessage.java @@ -33,18 +33,18 @@ public PingMessageSchema() { } @Override - public PingMessage createFromBackingNode(TreeNode node) { + public PingMessage createFromBackingNode(final TreeNode node) { return new PingMessage(this, node); } } public static final PingMessageSchema SSZ_SCHEMA = new PingMessageSchema(); - public PingMessage(PingMessageSchema type, TreeNode backingNode) { + public PingMessage(final PingMessageSchema type, final TreeNode backingNode) { super(type, backingNode); } - public PingMessage(UInt64 seqNumber) { + public PingMessage(final UInt64 seqNumber) { super(SSZ_SCHEMA, SszUInt64.of(seqNumber)); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/RpcErrorMessage.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/RpcErrorMessage.java index 339e342d0b6..7d5b850cd6b 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/RpcErrorMessage.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/RpcErrorMessage.java @@ -36,18 +36,18 @@ private RpcErrorMessageSchema() { } @Override - public RpcErrorMessage createFromBackingNode(TreeNode node) { + public RpcErrorMessage createFromBackingNode(final TreeNode node) { return new RpcErrorMessage(node); } } public static final RpcErrorMessageSchema SSZ_SCHEMA = new RpcErrorMessageSchema(); - public RpcErrorMessage(Bytes bytes) { + public RpcErrorMessage(final Bytes bytes) { super(SSZ_SCHEMA, SszUtils.toSszByteList(SSZ_SCHEMA, bytes).getBackingNode()); } - private RpcErrorMessage(TreeNode node) { + private RpcErrorMessage(final TreeNode node) { super(SSZ_SCHEMA, node); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/StatusMessage.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/StatusMessage.java index b39aafe7fdd..83ccd29b91d 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/StatusMessage.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/StatusMessage.java @@ -45,23 +45,23 @@ public StatusMessageSchema() { } @Override - public StatusMessage createFromBackingNode(TreeNode node) { + public StatusMessage createFromBackingNode(final TreeNode node) { return new StatusMessage(this, node); } } public static final StatusMessageSchema SSZ_SCHEMA = new StatusMessageSchema(); - private StatusMessage(StatusMessageSchema type, TreeNode backingNode) { + private StatusMessage(final StatusMessageSchema type, final TreeNode backingNode) { super(type, backingNode); } public StatusMessage( - Bytes4 forkDigest, - Bytes32 finalizedRoot, - UInt64 finalizedEpoch, - Bytes32 headRoot, - UInt64 headSlot) { + final Bytes4 forkDigest, + final Bytes32 finalizedRoot, + final UInt64 finalizedEpoch, + final Bytes32 headRoot, + final UInt64 headSlot) { super( SSZ_SCHEMA, SszBytes4.of(forkDigest), diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/metadata/versions/phase0/MetadataMessagePhase0.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/metadata/versions/phase0/MetadataMessagePhase0.java index 4da0a3c2f73..888df0907ba 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/metadata/versions/phase0/MetadataMessagePhase0.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/metadata/versions/phase0/MetadataMessagePhase0.java @@ -26,16 +26,18 @@ public class MetadataMessagePhase0 extends Container2 implements MetadataMessage { - MetadataMessagePhase0(MetadataMessageSchemaPhase0 type, TreeNode backingNode) { + MetadataMessagePhase0(final MetadataMessageSchemaPhase0 type, final TreeNode backingNode) { super(type, backingNode); } - MetadataMessagePhase0(MetadataMessageSchemaPhase0 type) { + MetadataMessagePhase0(final MetadataMessageSchemaPhase0 type) { super(type); } MetadataMessagePhase0( - MetadataMessageSchemaPhase0 schema, UInt64 seqNumber, SszBitvector attnets) { + final MetadataMessageSchemaPhase0 schema, + final UInt64 seqNumber, + final SszBitvector attnets) { super(schema, SszUInt64.of(seqNumber), attnets); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/metadata/versions/phase0/MetadataMessageSchemaPhase0.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/metadata/versions/phase0/MetadataMessageSchemaPhase0.java index 69cfa362ff4..c4e4b5a8ac9 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/metadata/versions/phase0/MetadataMessageSchemaPhase0.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/metadata/versions/phase0/MetadataMessageSchemaPhase0.java @@ -38,7 +38,7 @@ public MetadataMessageSchemaPhase0(final NetworkingSpecConfig networkingSpecConf } @Override - public MetadataMessagePhase0 createFromBackingNode(TreeNode node) { + public MetadataMessagePhase0 createFromBackingNode(final TreeNode node) { return new MetadataMessagePhase0(this, node); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/AggregateAndProof.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/AggregateAndProof.java index 85ff610d89a..f826573b161 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/AggregateAndProof.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/AggregateAndProof.java @@ -13,6 +13,8 @@ package tech.pegasys.teku.spec.datastructures.operations; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.ATTESTATION_SCHEMA; + import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.infrastructure.ssz.containers.Container3; import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema3; @@ -20,10 +22,10 @@ import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.config.SpecConfig; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; +import tech.pegasys.teku.spec.datastructures.operations.versions.phase0.AttestationPhase0; import tech.pegasys.teku.spec.datastructures.type.SszSignature; import tech.pegasys.teku.spec.datastructures.type.SszSignatureSchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; public class AggregateAndProof extends Container3 { @@ -31,38 +33,52 @@ public class AggregateAndProof public static class AggregateAndProofSchema extends ContainerSchema3 { - public AggregateAndProofSchema(final SpecConfig specConfig) { + public AggregateAndProofSchema( + final String containerName, final SchemaRegistry schemaRegistry) { super( - "AggregateAndProof", + containerName, namedSchema("aggregator_index", SszPrimitiveSchemas.UINT64_SCHEMA), - namedSchema("aggregate", new AttestationSchema(specConfig)), + namedSchema("aggregate", schemaRegistry.get(ATTESTATION_SCHEMA)), namedSchema("selection_proof", SszSignatureSchema.INSTANCE)); } - public AttestationSchema getAttestationSchema() { - return (AttestationSchema) getFieldSchema1(); + public AttestationSchema getAttestationSchema() { + return (AttestationSchema) getFieldSchema1(); } @Override - public AggregateAndProof createFromBackingNode(TreeNode node) { + public AggregateAndProof createFromBackingNode(final TreeNode node) { return new AggregateAndProof(this, node); } + public AggregateAndProof create( + final UInt64 index, final AttestationPhase0 aggregate, final BLSSignature selectionProof) { + return new AggregateAndProof(this, index, aggregate, selectionProof); + } + public AggregateAndProof create( final UInt64 index, final Attestation aggregate, final BLSSignature selectionProof) { return new AggregateAndProof(this, index, aggregate, selectionProof); } } - private AggregateAndProof(AggregateAndProofSchema type, TreeNode backingNode) { + private AggregateAndProof(final AggregateAndProofSchema type, final TreeNode backingNode) { super(type, backingNode); } private AggregateAndProof( - AggregateAndProofSchema schema, - UInt64 index, - Attestation aggregate, - BLSSignature selectionProof) { + final AggregateAndProofSchema schema, + final UInt64 index, + final AttestationPhase0 aggregate, + final BLSSignature selectionProof) { + super(schema, SszUInt64.of(index), aggregate, new SszSignature(selectionProof)); + } + + private AggregateAndProof( + final AggregateAndProofSchema schema, + final UInt64 index, + final Attestation aggregate, + final BLSSignature selectionProof) { super(schema, SszUInt64.of(index), aggregate, new SszSignature(selectionProof)); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/Attestation.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/Attestation.java index f0ee74a4fdc..57f0ff3f234 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/Attestation.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/Attestation.java @@ -1,5 +1,5 @@ /* - * Copyright Consensys Software Inc., 2022 + * Copyright Consensys Software Inc., 2024 * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at @@ -13,95 +13,56 @@ package tech.pegasys.teku.spec.datastructures.operations; -import com.google.common.collect.Sets; import java.util.Collection; +import java.util.List; +import java.util.Optional; import org.apache.tuweni.bytes.Bytes32; import tech.pegasys.teku.bls.BLSSignature; +import tech.pegasys.teku.infrastructure.ssz.SszContainer; import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; -import tech.pegasys.teku.infrastructure.ssz.containers.Container3; -import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema3; -import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszBitlistSchema; -import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.config.SpecConfig; -import tech.pegasys.teku.spec.datastructures.type.SszSignature; -import tech.pegasys.teku.spec.datastructures.type.SszSignatureSchema; +import tech.pegasys.teku.spec.datastructures.operations.versions.phase0.AttestationPhase0; -public class Attestation extends Container3 - implements AttestationContainer { - - public static class AttestationSchema - extends ContainerSchema3 { - - public AttestationSchema(final SpecConfig specConfig) { - super( - "Attestation", - namedSchema( - "aggregation_bits", - SszBitlistSchema.create(specConfig.getMaxValidatorsPerCommittee())), - namedSchema("data", AttestationData.SSZ_SCHEMA), - namedSchema("signature", SszSignatureSchema.INSTANCE)); - } +/** + * Interface used to represent different types of attestations ({@link AttestationPhase0} and {@link + * tech.pegasys.teku.spec.datastructures.state.PendingAttestation}) + */ +public interface Attestation extends SszContainer { - public SszBitlistSchema getAggregationBitsSchema() { - return (SszBitlistSchema) getFieldSchema0(); - } + @Override + AttestationSchema getSchema(); - @Override - public Attestation createFromBackingNode(TreeNode node) { - return new Attestation(this, node); - } + UInt64 getEarliestSlotForForkChoiceProcessing(final Spec spec); - public Attestation create( - final SszBitlist aggregationBits, - final AttestationData data, - final BLSSignature signature) { - return new Attestation(this, aggregationBits, data, signature); - } + Collection getDependentBlockRoots(); - public SszBitlist createEmptyAggregationBits() { - final SszBitlistSchema bitsSchema = getAggregationBitsSchema(); - return bitsSchema.ofBits(Math.toIntExact(bitsSchema.getMaxLength())); - } - } + AttestationData getData(); - private Attestation(final AttestationSchema type, final TreeNode backingNode) { - super(type, backingNode); - } + SszBitlist getAggregationBits(); - private Attestation( - final AttestationSchema schema, - final SszBitlist aggregationBits, - final AttestationData data, - final BLSSignature signature) { - super(schema, aggregationBits, data, new SszSignature(signature)); - } + UInt64 getFirstCommitteeIndex(); - @Override - public AttestationSchema getSchema() { - return (AttestationSchema) super.getSchema(); + default Optional getCommitteeBits() { + return Optional.empty(); } - public UInt64 getEarliestSlotForForkChoiceProcessing(final Spec spec) { - return getData().getEarliestSlotForForkChoice(spec); + default SszBitvector getCommitteeBitsRequired() { + return getCommitteeBits() + .orElseThrow(() -> new IllegalArgumentException("Missing committee bits")); } - public Collection getDependentBlockRoots() { - return Sets.newHashSet(getData().getTarget().getRoot(), getData().getBeaconBlockRoot()); - } + BLSSignature getAggregateSignature(); - @Override - public SszBitlist getAggregationBits() { - return getField0(); + default Optional> getCommitteeIndices() { + return Optional.empty(); } - @Override - public AttestationData getData() { - return getField1(); + default List getCommitteeIndicesRequired() { + return getCommitteeIndices() + .orElseThrow(() -> new IllegalArgumentException("Missing committee indices")); } - public BLSSignature getAggregateSignature() { - return getField2().getSignature(); - } + boolean requiresCommitteeBits(); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/AttestationData.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/AttestationData.java index 2caf81bc9cb..fac336790a6 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/AttestationData.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/AttestationData.java @@ -43,19 +43,23 @@ public AttestationDataSchema() { } @Override - public AttestationData createFromBackingNode(TreeNode node) { + public AttestationData createFromBackingNode(final TreeNode node) { return new AttestationData(this, node); } } public static final AttestationDataSchema SSZ_SCHEMA = new AttestationDataSchema(); - private AttestationData(AttestationDataSchema type, TreeNode backingNode) { + private AttestationData(final AttestationDataSchema type, final TreeNode backingNode) { super(type, backingNode); } public AttestationData( - UInt64 slot, UInt64 index, Bytes32 beaconBlockRoot, Checkpoint source, Checkpoint target) { + final UInt64 slot, + final UInt64 index, + final Bytes32 beaconBlockRoot, + final Checkpoint source, + final Checkpoint target) { super( SSZ_SCHEMA, SszUInt64.of(slot), @@ -65,7 +69,7 @@ public AttestationData( target); } - public AttestationData(UInt64 slot, AttestationData data) { + public AttestationData(final UInt64 slot, final AttestationData data) { this(slot, data.getIndex(), data.getBeaconBlockRoot(), data.getSource(), data.getTarget()); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/AttestationSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/AttestationSchema.java new file mode 100644 index 00000000000..3b0b0f880ec --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/AttestationSchema.java @@ -0,0 +1,62 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.operations; + +import java.util.Optional; +import java.util.function.Supplier; +import tech.pegasys.teku.bls.BLSSignature; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; +import tech.pegasys.teku.infrastructure.ssz.schema.SszContainerSchema; +import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszBitlistSchema; +import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszBitvectorSchema; +import tech.pegasys.teku.spec.datastructures.operations.versions.electra.AttestationElectraSchema; + +public interface AttestationSchema extends SszContainerSchema { + + Attestation create( + final SszBitlist aggregationBits, + final AttestationData data, + final BLSSignature signature, + final Supplier committeeBits); + + default Attestation create( + final SszBitlist aggregationBits, final AttestationData data, final BLSSignature signature) { + return create(aggregationBits, data, signature, () -> null); + } + + default SszBitlist createEmptyAggregationBits() { + final SszBitlistSchema bitsSchema = getAggregationBitsSchema(); + return bitsSchema.ofBits(Math.toIntExact(bitsSchema.getMaxLength())); + } + + default Optional createEmptyCommitteeBits() { + return getCommitteeBitsSchema().map(SszBitvectorSchema::ofBits); + } + + @SuppressWarnings("unchecked") + default AttestationSchema castTypeToAttestationSchema() { + return (AttestationSchema) this; + } + + default Optional toVersionElectra() { + return Optional.empty(); + } + + SszBitlistSchema getAggregationBitsSchema(); + + Optional> getCommitteeBitsSchema(); + + boolean requiresCommitteeBits(); +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/AttesterSlashing.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/AttesterSlashing.java index 897f1ec29ab..7d8467a8e55 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/AttesterSlashing.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/AttesterSlashing.java @@ -1,5 +1,5 @@ /* - * Copyright Consensys Software Inc., 2022 + * Copyright Consensys Software Inc., 2024 * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at @@ -13,61 +13,26 @@ package tech.pegasys.teku.spec.datastructures.operations; -import com.google.common.base.Suppliers; -import com.google.common.collect.Sets; -import java.util.HashSet; import java.util.Set; -import java.util.TreeSet; -import java.util.function.Supplier; import tech.pegasys.teku.infrastructure.ssz.containers.Container2; -import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema2; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestation.IndexedAttestationSchema; public class AttesterSlashing extends Container2 { + private final IntersectingIndicesCalculator intersectingIndicesCalculator; - public static class AttesterSlashingSchema - extends ContainerSchema2 { - - public AttesterSlashingSchema(final IndexedAttestationSchema indexedAttestationSchema) { - super( - "AttesterSlashing", - namedSchema("attestation_1", indexedAttestationSchema), - namedSchema("attestation_2", indexedAttestationSchema)); - } - - @Override - public AttesterSlashing createFromBackingNode(TreeNode node) { - return new AttesterSlashing(this, node); - } - - public AttesterSlashing create( - final IndexedAttestation attestation1, final IndexedAttestation attestation2) { - return new AttesterSlashing(this, attestation1, attestation2); - } - } - - private final Supplier> intersectingIndices = - Suppliers.memoize( - () -> - Sets.intersection( - new TreeSet<>( - getAttestation1() - .getAttestingIndices() - .asListUnboxed()), // TreeSet as must be sorted - new HashSet<>(getAttestation2().getAttestingIndices().asListUnboxed()))); - - private AttesterSlashing(AttesterSlashingSchema type, TreeNode backingNode) { + AttesterSlashing(final AttesterSlashingSchema type, final TreeNode backingNode) { super(type, backingNode); + this.intersectingIndicesCalculator = new IntersectingIndicesCalculator(this); } - private AttesterSlashing( + AttesterSlashing( final AttesterSlashingSchema schema, final IndexedAttestation attestation1, final IndexedAttestation attestation2) { super(schema, attestation1, attestation2); + this.intersectingIndicesCalculator = new IntersectingIndicesCalculator(this); } @Override @@ -76,7 +41,7 @@ public AttesterSlashingSchema getSchema() { } public Set getIntersectingValidatorIndices() { - return intersectingIndices.get(); + return intersectingIndicesCalculator.getIntersectingValidatorIndices(); } public IndexedAttestation getAttestation1() { diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/AttesterSlashingSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/AttesterSlashingSchema.java new file mode 100644 index 00000000000..28f0ad29536 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/AttesterSlashingSchema.java @@ -0,0 +1,41 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.operations; + +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.INDEXED_ATTESTATION_SCHEMA; + +import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema2; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; + +public class AttesterSlashingSchema + extends ContainerSchema2 { + + public AttesterSlashingSchema(final String containerName, final SchemaRegistry schemaRegistry) { + super( + containerName, + namedSchema("attestation_1", schemaRegistry.get(INDEXED_ATTESTATION_SCHEMA)), + namedSchema("attestation_2", schemaRegistry.get(INDEXED_ATTESTATION_SCHEMA))); + } + + @Override + public AttesterSlashing createFromBackingNode(final TreeNode node) { + return new AttesterSlashing(this, node); + } + + public AttesterSlashing create( + final IndexedAttestation attestation1, final IndexedAttestation attestation2) { + return new AttesterSlashing(this, attestation1, attestation2); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/Deposit.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/Deposit.java index a290fe38298..7efedb8251d 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/Deposit.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/Deposit.java @@ -38,7 +38,7 @@ public SszBytes32VectorSchema getProofSchema() { } @Override - public Deposit createFromBackingNode(TreeNode node) { + public Deposit createFromBackingNode(final TreeNode node) { return new Deposit(this, node); } } @@ -47,15 +47,15 @@ public Deposit createFromBackingNode(TreeNode node) { private static final SszBytes32Vector EMPTY_PROOF = SSZ_SCHEMA.getProofSchema().getDefault(); - private Deposit(DepositSchema type, TreeNode backingNode) { + private Deposit(final DepositSchema type, final TreeNode backingNode) { super(type, backingNode); } - public Deposit(DepositData data) { + public Deposit(final DepositData data) { this(EMPTY_PROOF, data); } - public Deposit(SszBytes32Vector proof, DepositData data) { + public Deposit(final SszBytes32Vector proof, final DepositData data) { super(SSZ_SCHEMA, proof, data); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/DepositData.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/DepositData.java index 1f95d8c3e20..704544307d4 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/DepositData.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/DepositData.java @@ -44,19 +44,22 @@ public DepositDataSchema() { } @Override - public DepositData createFromBackingNode(TreeNode node) { + public DepositData createFromBackingNode(final TreeNode node) { return new DepositData(this, node); } } public static final DepositDataSchema SSZ_SCHEMA = new DepositDataSchema(); - private DepositData(DepositDataSchema type, TreeNode backingNode) { + private DepositData(final DepositDataSchema type, final TreeNode backingNode) { super(type, backingNode); } public DepositData( - BLSPublicKey pubkey, Bytes32 withdrawalCredentials, UInt64 amount, BLSSignature signature) { + final BLSPublicKey pubkey, + final Bytes32 withdrawalCredentials, + final UInt64 amount, + final BLSSignature signature) { super( SSZ_SCHEMA, new SszPublicKey(pubkey), diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/DepositMessage.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/DepositMessage.java index 3b8fc6742b6..53a4ba89da4 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/DepositMessage.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/DepositMessage.java @@ -40,14 +40,14 @@ public DepositMessageSchema() { } @Override - public DepositMessage createFromBackingNode(TreeNode node) { + public DepositMessage createFromBackingNode(final TreeNode node) { return new DepositMessage(this, node); } } public static final DepositMessageSchema SSZ_SCHEMA = new DepositMessageSchema(); - private DepositMessage(DepositMessageSchema type, TreeNode backingNode) { + private DepositMessage(final DepositMessageSchema type, final TreeNode backingNode) { super(type, backingNode); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/DepositWithIndex.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/DepositWithIndex.java index 5b03cd79c59..50b1153f12b 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/DepositWithIndex.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/DepositWithIndex.java @@ -13,52 +13,15 @@ package tech.pegasys.teku.spec.datastructures.operations; -import java.util.Objects; import org.jetbrains.annotations.NotNull; -import tech.pegasys.teku.infrastructure.ssz.collections.SszBytes32Vector; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -public class DepositWithIndex extends Deposit implements Comparable { - - private final UInt64 index; - - public DepositWithIndex(SszBytes32Vector proof, DepositData data, UInt64 index) { - super(proof, data); - this.index = index; - } - - public DepositWithIndex(DepositData data, UInt64 index) { - super(data); - this.index = index; - } - - public UInt64 getIndex() { - return index; - } - - @Override - public int compareTo(@NotNull DepositWithIndex o) { - return this.getIndex().compareTo(o.getIndex()); - } - - @Override - public boolean equals(final Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - if (!super.equals(o)) { - return false; - } - final DepositWithIndex that = (DepositWithIndex) o; - return index.equals(that.index); - } +public record DepositWithIndex(Deposit deposit, UInt64 index) + implements Comparable { @Override - public int hashCode() { - return Objects.hash(super.hashCode(), index); + public int compareTo(final @NotNull DepositWithIndex o) { + return this.index().compareTo(o.index()); } @Override diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/IndexedAttestation.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/IndexedAttestation.java index 0976f586f40..09b54890150 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/IndexedAttestation.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/IndexedAttestation.java @@ -1,5 +1,5 @@ /* - * Copyright Consensys Software Inc., 2022 + * Copyright Consensys Software Inc., 2024 * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at @@ -16,51 +16,17 @@ import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.infrastructure.ssz.collections.SszUInt64List; import tech.pegasys.teku.infrastructure.ssz.containers.Container3; -import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema3; -import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszUInt64ListSchema; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; -import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.datastructures.type.SszSignature; -import tech.pegasys.teku.spec.datastructures.type.SszSignatureSchema; public class IndexedAttestation extends Container3 { - public static class IndexedAttestationSchema - extends ContainerSchema3 { - - public IndexedAttestationSchema(final SpecConfig config) { - super( - "IndexedAttestation", - namedSchema( - "attesting_indices", - SszUInt64ListSchema.create(config.getMaxValidatorsPerCommittee())), - namedSchema("data", AttestationData.SSZ_SCHEMA), - namedSchema("signature", SszSignatureSchema.INSTANCE)); - } - - public SszUInt64ListSchema getAttestingIndicesSchema() { - return (SszUInt64ListSchema) super.getFieldSchema0(); - } - - @Override - public IndexedAttestation createFromBackingNode(TreeNode node) { - return new IndexedAttestation(this, node); - } - - public IndexedAttestation create( - final SszUInt64List attestingIndices, - final AttestationData data, - final BLSSignature signature) { - return new IndexedAttestation(this, attestingIndices, data, signature); - } - } - - private IndexedAttestation(IndexedAttestationSchema type, TreeNode backingNode) { + IndexedAttestation(final IndexedAttestationSchema type, final TreeNode backingNode) { super(type, backingNode); } - private IndexedAttestation( + IndexedAttestation( final IndexedAttestationSchema schema, final SszUInt64List attestingIndices, final AttestationData data, diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/IndexedAttestationSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/IndexedAttestationSchema.java new file mode 100644 index 00000000000..da153fe5bfe --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/IndexedAttestationSchema.java @@ -0,0 +1,51 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.operations; + +import tech.pegasys.teku.bls.BLSSignature; +import tech.pegasys.teku.infrastructure.ssz.collections.SszUInt64List; +import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema3; +import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszUInt64ListSchema; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.spec.datastructures.type.SszSignature; +import tech.pegasys.teku.spec.datastructures.type.SszSignatureSchema; + +public class IndexedAttestationSchema + extends ContainerSchema3 { + + public IndexedAttestationSchema( + final String containerName, final long maxValidatorsPerAttestation) { + super( + containerName, + namedSchema("attesting_indices", SszUInt64ListSchema.create(maxValidatorsPerAttestation)), + namedSchema("data", AttestationData.SSZ_SCHEMA), + namedSchema("signature", SszSignatureSchema.INSTANCE)); + } + + public SszUInt64ListSchema getAttestingIndicesSchema() { + return (SszUInt64ListSchema) super.getFieldSchema0(); + } + + @Override + public IndexedAttestation createFromBackingNode(final TreeNode node) { + return new IndexedAttestation(this, node); + } + + public IndexedAttestation create( + final SszUInt64List attestingIndices, + final AttestationData data, + final BLSSignature signature) { + return new IndexedAttestation(this, attestingIndices, data, signature); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/IntersectingIndicesCalculator.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/IntersectingIndicesCalculator.java new file mode 100644 index 00000000000..3c2e891ce1d --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/IntersectingIndicesCalculator.java @@ -0,0 +1,45 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.operations; + +import com.google.common.base.Suppliers; +import com.google.common.collect.Sets; +import java.util.HashSet; +import java.util.Set; +import java.util.TreeSet; +import java.util.function.Supplier; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; + +public class IntersectingIndicesCalculator { + private final Supplier> intersectingIndices; + + public IntersectingIndicesCalculator(final AttesterSlashing attesterSlashing) { + this.intersectingIndices = + Suppliers.memoize(() -> calculateIntersectionIndices(attesterSlashing)); + } + + private static Set calculateIntersectionIndices(final AttesterSlashing attesterSlashing) { + return Sets.intersection( + new TreeSet<>( + attesterSlashing + .getAttestation1() + .getAttestingIndices() + .asListUnboxed()), // TreeSet as must be sorted + new HashSet<>(attesterSlashing.getAttestation2().getAttestingIndices().asListUnboxed())); + } + + public Set getIntersectingValidatorIndices() { + return intersectingIndices.get(); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/ProposerSlashing.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/ProposerSlashing.java index edca1680dc6..71b73bce823 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/ProposerSlashing.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/ProposerSlashing.java @@ -32,18 +32,19 @@ public ProposerSlashingSchema() { } @Override - public ProposerSlashing createFromBackingNode(TreeNode node) { + public ProposerSlashing createFromBackingNode(final TreeNode node) { return new ProposerSlashing(this, node); } } public static final ProposerSlashingSchema SSZ_SCHEMA = new ProposerSlashingSchema(); - private ProposerSlashing(ProposerSlashingSchema type, TreeNode backingNode) { + private ProposerSlashing(final ProposerSlashingSchema type, final TreeNode backingNode) { super(type, backingNode); } - public ProposerSlashing(SignedBeaconBlockHeader header1, SignedBeaconBlockHeader header2) { + public ProposerSlashing( + final SignedBeaconBlockHeader header1, final SignedBeaconBlockHeader header2) { super(SSZ_SCHEMA, header1, header2); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/SignedAggregateAndProof.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/SignedAggregateAndProof.java index 6f6569889d6..6c62014b238 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/SignedAggregateAndProof.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/SignedAggregateAndProof.java @@ -13,14 +13,16 @@ package tech.pegasys.teku.spec.datastructures.operations; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.AGGREGATE_AND_PROOF_SCHEMA; + import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.infrastructure.ssz.containers.Container2; import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema2; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; -import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.datastructures.operations.AggregateAndProof.AggregateAndProofSchema; import tech.pegasys.teku.spec.datastructures.type.SszSignature; import tech.pegasys.teku.spec.datastructures.type.SszSignatureSchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; public class SignedAggregateAndProof extends Container2 { @@ -28,10 +30,11 @@ public class SignedAggregateAndProof public static class SignedAggregateAndProofSchema extends ContainerSchema2 { - public SignedAggregateAndProofSchema(final SpecConfig specConfig) { + public SignedAggregateAndProofSchema( + final String containerName, final SchemaRegistry schemaRegistry) { super( - "SignedAggregateAndProof", - namedSchema("message", new AggregateAndProofSchema(specConfig)), + containerName, + namedSchema("message", schemaRegistry.get(AGGREGATE_AND_PROOF_SCHEMA)), namedSchema("signature", SszSignatureSchema.INSTANCE)); } @@ -40,16 +43,18 @@ public AggregateAndProofSchema getAggregateAndProofSchema() { } @Override - public SignedAggregateAndProof createFromBackingNode(TreeNode node) { + public SignedAggregateAndProof createFromBackingNode(final TreeNode node) { return new SignedAggregateAndProof(this, node); } - public SignedAggregateAndProof create(final AggregateAndProof message, BLSSignature signature) { + public SignedAggregateAndProof create( + final AggregateAndProof message, final BLSSignature signature) { return new SignedAggregateAndProof(this, message, signature); } } - private SignedAggregateAndProof(SignedAggregateAndProofSchema type, TreeNode backingNode) { + private SignedAggregateAndProof( + final SignedAggregateAndProofSchema type, final TreeNode backingNode) { super(type, backingNode); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/SignedBlsToExecutionChangeSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/SignedBlsToExecutionChangeSchema.java index 43c01f24754..f003d122d9e 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/SignedBlsToExecutionChangeSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/SignedBlsToExecutionChangeSchema.java @@ -13,19 +13,22 @@ package tech.pegasys.teku.spec.datastructures.operations; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLS_TO_EXECUTION_CHANGE_SCHEMA; + import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema2; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; import tech.pegasys.teku.spec.datastructures.type.SszSignature; import tech.pegasys.teku.spec.datastructures.type.SszSignatureSchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; public class SignedBlsToExecutionChangeSchema extends ContainerSchema2 { - public SignedBlsToExecutionChangeSchema() { + public SignedBlsToExecutionChangeSchema(final SchemaRegistry schemaRegistry) { super( "SignedBLSToExecutionChange", - namedSchema("message", new BlsToExecutionChangeSchema()), + namedSchema("message", schemaRegistry.get(BLS_TO_EXECUTION_CHANGE_SCHEMA)), namedSchema("signature", SszSignatureSchema.INSTANCE)); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/SignedVoluntaryExit.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/SignedVoluntaryExit.java index 1badae5f717..c82db5faf55 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/SignedVoluntaryExit.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/SignedVoluntaryExit.java @@ -36,14 +36,14 @@ public SignedVoluntaryExitSchema() { } @Override - public SignedVoluntaryExit createFromBackingNode(TreeNode node) { + public SignedVoluntaryExit createFromBackingNode(final TreeNode node) { return new SignedVoluntaryExit(this, node); } } public static final SignedVoluntaryExitSchema SSZ_SCHEMA = new SignedVoluntaryExitSchema(); - private SignedVoluntaryExit(SignedVoluntaryExitSchema type, TreeNode backingNode) { + private SignedVoluntaryExit(final SignedVoluntaryExitSchema type, final TreeNode backingNode) { super(type, backingNode); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/VoluntaryExit.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/VoluntaryExit.java index e51b94b5712..049f87ad334 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/VoluntaryExit.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/VoluntaryExit.java @@ -33,18 +33,18 @@ public VoluntaryExitSchema() { } @Override - public VoluntaryExit createFromBackingNode(TreeNode node) { + public VoluntaryExit createFromBackingNode(final TreeNode node) { return new VoluntaryExit(this, node); } } public static final VoluntaryExitSchema SSZ_SCHEMA = new VoluntaryExitSchema(); - private VoluntaryExit(VoluntaryExitSchema type, TreeNode backingNode) { + private VoluntaryExit(final VoluntaryExitSchema type, final TreeNode backingNode) { super(type, backingNode); } - public VoluntaryExit(UInt64 epoch, UInt64 validatorIndex) { + public VoluntaryExit(final UInt64 epoch, final UInt64 validatorIndex) { super(SSZ_SCHEMA, SszUInt64.of(epoch), SszUInt64.of(validatorIndex)); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/versions/electra/AttestationElectra.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/versions/electra/AttestationElectra.java new file mode 100644 index 00000000000..1842c46e897 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/versions/electra/AttestationElectra.java @@ -0,0 +1,99 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.operations.versions.electra; + +import com.google.common.collect.Sets; +import java.util.Collection; +import java.util.List; +import java.util.Optional; +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.bls.BLSSignature; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; +import tech.pegasys.teku.infrastructure.ssz.containers.Container4; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.datastructures.operations.AttestationData; +import tech.pegasys.teku.spec.datastructures.type.SszSignature; + +public class AttestationElectra + extends Container4 + implements Attestation { + + public AttestationElectra(final AttestationElectraSchema type, final TreeNode backingNode) { + super(type, backingNode); + } + + public AttestationElectra( + final AttestationElectraSchema schema, + final SszBitlist aggregationBits, + final AttestationData data, + final BLSSignature signature, + final SszBitvector committeeBits) { + super(schema, aggregationBits, data, new SszSignature(signature), committeeBits); + } + + @Override + public AttestationElectraSchema getSchema() { + return (AttestationElectraSchema) super.getSchema(); + } + + @Override + public UInt64 getEarliestSlotForForkChoiceProcessing(final Spec spec) { + return getData().getEarliestSlotForForkChoice(spec); + } + + @Override + public Collection getDependentBlockRoots() { + return Sets.newHashSet(getData().getTarget().getRoot(), getData().getBeaconBlockRoot()); + } + + @Override + public SszBitlist getAggregationBits() { + return getField0(); + } + + @Override + public AttestationData getData() { + return getField1(); + } + + @Override + public Optional getCommitteeBits() { + return Optional.of(getField3()); + } + + @Override + public BLSSignature getAggregateSignature() { + return getField2().getSignature(); + } + + @Override + public Optional> getCommitteeIndices() { + return Optional.of( + getCommitteeBitsRequired().getAllSetBits().intStream().mapToObj(UInt64::valueOf).toList()); + } + + @Override + public UInt64 getFirstCommitteeIndex() { + return UInt64.valueOf(getCommitteeBitsRequired().streamAllSetBits().findFirst().orElseThrow()); + } + + @Override + public boolean requiresCommitteeBits() { + return true; + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/versions/electra/AttestationElectraSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/versions/electra/AttestationElectraSchema.java new file mode 100644 index 00000000000..0c9d5c60bb7 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/versions/electra/AttestationElectraSchema.java @@ -0,0 +1,91 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.operations.versions.electra; + +import static com.google.common.base.Preconditions.checkNotNull; + +import java.util.Optional; +import java.util.function.Supplier; +import tech.pegasys.teku.bls.BLSSignature; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; +import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema4; +import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszBitlistSchema; +import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszBitvectorSchema; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.datastructures.operations.AttestationData; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; +import tech.pegasys.teku.spec.datastructures.type.SszSignature; +import tech.pegasys.teku.spec.datastructures.type.SszSignatureSchema; + +public class AttestationElectraSchema + extends ContainerSchema4< + AttestationElectra, SszBitlist, AttestationData, SszSignature, SszBitvector> + implements AttestationSchema { + + public AttestationElectraSchema( + final long maxValidatorsPerAttestation, final long maxCommitteesPerSlot) { + super( + "AttestationElectra", + namedSchema("aggregation_bits", SszBitlistSchema.create(maxValidatorsPerAttestation)), + namedSchema("data", AttestationData.SSZ_SCHEMA), + namedSchema("signature", SszSignatureSchema.INSTANCE), + namedSchema("committee_bits", SszBitvectorSchema.create(maxCommitteesPerSlot))); + } + + @Override + public SszBitlistSchema getAggregationBitsSchema() { + return (SszBitlistSchema) getFieldSchema0(); + } + + @Override + public Optional> getCommitteeBitsSchema() { + return Optional.of((SszBitvectorSchema) getFieldSchema3()); + } + + @Override + public AttestationElectra createFromBackingNode(final TreeNode node) { + return new AttestationElectra(this, node); + } + + @Override + public Attestation create( + final SszBitlist aggregationBits, + final AttestationData data, + final BLSSignature signature, + final Supplier committeeBits) { + final SszBitvector suppliedCommitteeBits = committeeBits.get(); + checkNotNull(suppliedCommitteeBits, "committeeBits must be provided in Electra"); + return new AttestationElectra(this, aggregationBits, data, signature, suppliedCommitteeBits); + } + + public AttestationElectra create( + final SszBitlist aggregationBits, + final AttestationData data, + final BLSSignature signature, + final SszBitvector committeeBits) { + return new AttestationElectra(this, aggregationBits, data, signature, committeeBits); + } + + @Override + public Optional toVersionElectra() { + return Optional.of(this); + } + + @Override + public boolean requiresCommitteeBits() { + return true; + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/versions/phase0/AttestationPhase0.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/versions/phase0/AttestationPhase0.java new file mode 100644 index 00000000000..dd343f37361 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/versions/phase0/AttestationPhase0.java @@ -0,0 +1,84 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.operations.versions.phase0; + +import com.google.common.collect.Sets; +import java.util.Collection; +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.bls.BLSSignature; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; +import tech.pegasys.teku.infrastructure.ssz.containers.Container3; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.datastructures.operations.AttestationData; +import tech.pegasys.teku.spec.datastructures.type.SszSignature; + +public class AttestationPhase0 + extends Container3 + implements Attestation { + + AttestationPhase0(final AttestationPhase0Schema type, final TreeNode backingNode) { + super(type, backingNode); + } + + AttestationPhase0( + final AttestationPhase0Schema schema, + final SszBitlist aggregationBits, + final AttestationData data, + final BLSSignature signature) { + super(schema, aggregationBits, data, new SszSignature(signature)); + } + + @Override + public AttestationPhase0Schema getSchema() { + return (AttestationPhase0Schema) super.getSchema(); + } + + @Override + public UInt64 getEarliestSlotForForkChoiceProcessing(final Spec spec) { + return getData().getEarliestSlotForForkChoice(spec); + } + + @Override + public Collection getDependentBlockRoots() { + return Sets.newHashSet(getData().getTarget().getRoot(), getData().getBeaconBlockRoot()); + } + + @Override + public SszBitlist getAggregationBits() { + return getField0(); + } + + @Override + public AttestationData getData() { + return getField1(); + } + + @Override + public UInt64 getFirstCommitteeIndex() { + return getField1().getIndex(); + } + + @Override + public BLSSignature getAggregateSignature() { + return getField2().getSignature(); + } + + @Override + public boolean requiresCommitteeBits() { + return false; + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/versions/phase0/AttestationPhase0Schema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/versions/phase0/AttestationPhase0Schema.java new file mode 100644 index 00000000000..9cdd2248084 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/versions/phase0/AttestationPhase0Schema.java @@ -0,0 +1,71 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.operations.versions.phase0; + +import java.util.Optional; +import java.util.function.Supplier; +import tech.pegasys.teku.bls.BLSSignature; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; +import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema3; +import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszBitlistSchema; +import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszBitvectorSchema; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.datastructures.operations.AttestationData; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; +import tech.pegasys.teku.spec.datastructures.type.SszSignature; +import tech.pegasys.teku.spec.datastructures.type.SszSignatureSchema; + +public class AttestationPhase0Schema + extends ContainerSchema3 + implements AttestationSchema { + + public AttestationPhase0Schema(final long maxValidatorsPerAttestation) { + super( + "AttestationPhase0", + namedSchema("aggregation_bits", SszBitlistSchema.create(maxValidatorsPerAttestation)), + namedSchema("data", AttestationData.SSZ_SCHEMA), + namedSchema("signature", SszSignatureSchema.INSTANCE)); + } + + @Override + public SszBitlistSchema getAggregationBitsSchema() { + return (SszBitlistSchema) getFieldSchema0(); + } + + @Override + public Optional> getCommitteeBitsSchema() { + return Optional.empty(); + } + + @Override + public AttestationPhase0 createFromBackingNode(final TreeNode node) { + return new AttestationPhase0(this, node); + } + + @Override + public Attestation create( + final SszBitlist aggregationBits, + final AttestationData data, + final BLSSignature signature, + final Supplier committeeBits) { + return new AttestationPhase0(this, aggregationBits, data, signature); + } + + @Override + public boolean requiresCommitteeBits() { + return false; + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/AnchorPoint.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/AnchorPoint.java index 69046334b66..97ab43e0244 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/AnchorPoint.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/AnchorPoint.java @@ -58,21 +58,24 @@ private AnchorPoint( public static AnchorPoint create( final Spec spec, - Checkpoint checkpoint, - BeaconState state, - Optional block) { + final Checkpoint checkpoint, + final BeaconState state, + final Optional block) { final BeaconBlockSummary blockSummary = block.map(a -> a).orElseGet(() -> BeaconBlockHeader.fromState(state)); return new AnchorPoint(spec, checkpoint, state, blockSummary); } public static AnchorPoint create( - final Spec spec, Checkpoint checkpoint, SignedBeaconBlock block, BeaconState state) { + final Spec spec, + final Checkpoint checkpoint, + final SignedBeaconBlock block, + final BeaconState state) { return new AnchorPoint(spec, checkpoint, state, block); } public static AnchorPoint create( - final Spec spec, Checkpoint checkpoint, SignedBlockAndState blockAndState) { + final Spec spec, final Checkpoint checkpoint, final SignedBlockAndState blockAndState) { return new AnchorPoint(spec, checkpoint, blockAndState.getState(), blockAndState.getBlock()); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/Checkpoint.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/Checkpoint.java index ec673c97364..bc692dba672 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/Checkpoint.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/Checkpoint.java @@ -36,18 +36,18 @@ public CheckpointSchema() { } @Override - public Checkpoint createFromBackingNode(TreeNode node) { + public Checkpoint createFromBackingNode(final TreeNode node) { return new Checkpoint(this, node); } } public static final CheckpointSchema SSZ_SCHEMA = new CheckpointSchema(); - private Checkpoint(CheckpointSchema type, TreeNode backingNode) { + private Checkpoint(final CheckpointSchema type, final TreeNode backingNode) { super(type, backingNode); } - public Checkpoint(UInt64 epoch, Bytes32 root) { + public Checkpoint(final UInt64 epoch, final Bytes32 root) { super(SSZ_SCHEMA, SszUInt64.of(epoch), SszBytes32.of(root)); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/CommitteeAssignment.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/CommitteeAssignment.java index df0271bce65..b0bb15cfc3d 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/CommitteeAssignment.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/CommitteeAssignment.java @@ -14,61 +14,6 @@ package tech.pegasys.teku.spec.datastructures.state; import it.unimi.dsi.fastutil.ints.IntList; -import java.util.Objects; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -public class CommitteeAssignment { - - private IntList committee; - private UInt64 committeeIndex; - private UInt64 slot; - - public CommitteeAssignment(IntList committee, UInt64 committeeIndex, UInt64 slot) { - this.committee = committee; - this.committeeIndex = committeeIndex; - this.slot = slot; - } - - public IntList getCommittee() { - return committee; - } - - public UInt64 getCommitteeIndex() { - return committeeIndex; - } - - public UInt64 getSlot() { - return slot; - } - - @Override - public String toString() { - return "CommitteeAssignment{" - + "committee=" - + committee - + ", committeeIndex=" - + committeeIndex - + ", slot=" - + slot - + '}'; - } - - @Override - public boolean equals(Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - CommitteeAssignment that = (CommitteeAssignment) o; - return Objects.equals(committee, that.committee) - && Objects.equals(committeeIndex, that.committeeIndex) - && Objects.equals(slot, that.slot); - } - - @Override - public int hashCode() { - return Objects.hash(committee, committeeIndex, slot); - } -} +public record CommitteeAssignment(IntList committee, UInt64 committeeIndex, UInt64 slot) {} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/Fork.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/Fork.java index 47b444a3b6f..f025904d8a1 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/Fork.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/Fork.java @@ -36,18 +36,18 @@ public ForkSchema() { } @Override - public Fork createFromBackingNode(TreeNode node) { + public Fork createFromBackingNode(final TreeNode node) { return new Fork(this, node); } } public static final ForkSchema SSZ_SCHEMA = new ForkSchema(); - private Fork(ForkSchema type, TreeNode backingNode) { + private Fork(final ForkSchema type, final TreeNode backingNode) { super(type, backingNode); } - public Fork(Bytes4 previousVersion, Bytes4 currentVersion, UInt64 epoch) { + public Fork(final Bytes4 previousVersion, final Bytes4 currentVersion, final UInt64 epoch) { super( SSZ_SCHEMA, SszBytes4.of(previousVersion), diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/ForkData.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/ForkData.java index de378af5165..43dbb15889e 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/ForkData.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/ForkData.java @@ -34,14 +34,14 @@ public ForkDataSchema() { } @Override - public ForkData createFromBackingNode(TreeNode node) { + public ForkData createFromBackingNode(final TreeNode node) { return new ForkData(this, node); } } public static final ForkDataSchema SSZ_SCHEMA = new ForkDataSchema(); - private ForkData(ForkDataSchema type, TreeNode backingNode) { + private ForkData(final ForkDataSchema type, final TreeNode backingNode) { super(type, backingNode); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/ForkInfo.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/ForkInfo.java index ae625209707..797f52da6c1 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/ForkInfo.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/ForkInfo.java @@ -13,10 +13,13 @@ package tech.pegasys.teku.spec.datastructures.state; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.BYTES32_TYPE; + import com.google.common.base.MoreObjects; import java.util.Objects; import org.apache.tuweni.bytes.Bytes32; import tech.pegasys.teku.infrastructure.bytes.Bytes4; +import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition; import tech.pegasys.teku.spec.Spec; public class ForkInfo { @@ -63,6 +66,13 @@ public boolean equals(final Object o) { && Objects.equals(genesisValidatorsRoot, forkInfo.genesisValidatorsRoot); } + public static SerializableTypeDefinition getJsonTypeDefinition() { + return SerializableTypeDefinition.object(ForkInfo.class) + .withField("fork", Fork.SSZ_SCHEMA.getJsonTypeDefinition(), ForkInfo::getFork) + .withField("genesis_validators_root", BYTES32_TYPE, ForkInfo::getGenesisValidatorsRoot) + .build(); + } + @Override public int hashCode() { return Objects.hash(fork, genesisValidatorsRoot); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/HistoricalBatch.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/HistoricalBatch.java index 4ab7cb039bc..cc79f2446c7 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/HistoricalBatch.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/HistoricalBatch.java @@ -33,11 +33,12 @@ public HistoricalBatchSchema(final int slotsPerHistoricalRoot) { } @Override - public HistoricalBatch createFromBackingNode(TreeNode node) { + public HistoricalBatch createFromBackingNode(final TreeNode node) { return new HistoricalBatch(this, node); } - public HistoricalBatch create(SszBytes32Vector blockRoots, SszBytes32Vector stateRoots) { + public HistoricalBatch create( + final SszBytes32Vector blockRoots, final SszBytes32Vector stateRoots) { return new HistoricalBatch(this, blockRoots, stateRoots); } @@ -50,12 +51,14 @@ public SszBytes32VectorSchema getStateRootsSchema() { } } - private HistoricalBatch(HistoricalBatchSchema type, TreeNode backingNode) { + private HistoricalBatch(final HistoricalBatchSchema type, final TreeNode backingNode) { super(type, backingNode); } private HistoricalBatch( - HistoricalBatchSchema type, SszBytes32Vector blockRoots, SszBytes32Vector stateRoots) { + final HistoricalBatchSchema type, + final SszBytes32Vector blockRoots, + final SszBytes32Vector stateRoots) { super(type, blockRoots, stateRoots); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/PendingAttestation.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/PendingAttestation.java index a293bf22bd3..24329aa83ef 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/PendingAttestation.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/PendingAttestation.java @@ -22,12 +22,10 @@ import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.config.SpecConfig; -import tech.pegasys.teku.spec.datastructures.operations.AttestationContainer; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; public class PendingAttestation - extends Container4 - implements AttestationContainer { + extends Container4 { public static class PendingAttestationSchema extends ContainerSchema4< @@ -56,12 +54,12 @@ public SszBitlistSchema getAggregationBitfieldSchema() { } @Override - public PendingAttestation createFromBackingNode(TreeNode node) { + public PendingAttestation createFromBackingNode(final TreeNode node) { return new PendingAttestation(this, node); } } - private PendingAttestation(PendingAttestationSchema type, TreeNode backingNode) { + private PendingAttestation(final PendingAttestationSchema type, final TreeNode backingNode) { super(type, backingNode); } @@ -84,12 +82,10 @@ public PendingAttestationSchema getSchema() { return (PendingAttestationSchema) super.getSchema(); } - @Override public SszBitlist getAggregationBits() { return getField0(); } - @Override public AttestationData getData() { return getField1(); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/SigningData.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/SigningData.java index 64986a2bfc3..f7186b205ce 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/SigningData.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/SigningData.java @@ -33,18 +33,18 @@ public SigningDataSchema() { } @Override - public SigningData createFromBackingNode(TreeNode node) { + public SigningData createFromBackingNode(final TreeNode node) { return new SigningData(this, node); } } public static final SigningDataSchema SSZ_SCHEMA = new SigningDataSchema(); - private SigningData(SigningDataSchema type, TreeNode backingNode) { + private SigningData(final SigningDataSchema type, final TreeNode backingNode) { super(type, backingNode); } - public SigningData(Bytes32 objectRoot, Bytes32 domain) { + public SigningData(final Bytes32 objectRoot, final Bytes32 domain) { super(SSZ_SCHEMA, SszBytes32.of(objectRoot), SszBytes32.of(domain)); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/SyncCommittee.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/SyncCommittee.java index e06aa9a46e1..7e9e59b4bb2 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/SyncCommittee.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/SyncCommittee.java @@ -40,7 +40,7 @@ public SyncCommitteeSchema(final SpecConfigAltair specConfigAltair) { } @Override - public SyncCommittee createFromBackingNode(TreeNode node) { + public SyncCommittee createFromBackingNode(final TreeNode node) { return new SyncCommittee(this, node); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/Validator.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/Validator.java index c27b73be63d..5d990c055ae 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/Validator.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/Validator.java @@ -67,26 +67,26 @@ public ValidatorSchema() { } @Override - public Validator createFromBackingNode(TreeNode node) { + public Validator createFromBackingNode(final TreeNode node) { return new Validator(this, node); } } public static final ValidatorSchema SSZ_SCHEMA = new ValidatorSchema(); - private Validator(ValidatorSchema type, TreeNode backingNode) { + private Validator(final ValidatorSchema type, final TreeNode backingNode) { super(type, backingNode); } public Validator( - BLSPublicKey pubkey, - Bytes32 withdrawalCredentials, - UInt64 effectiveBalance, - boolean slashed, - UInt64 activationEligibilityEpoch, - UInt64 activationEpoch, - UInt64 exitEpoch, - UInt64 withdrawableEpoch) { + final BLSPublicKey pubkey, + final Bytes32 withdrawalCredentials, + final UInt64 effectiveBalance, + final boolean slashed, + final UInt64 activationEligibilityEpoch, + final UInt64 activationEpoch, + final UInt64 exitEpoch, + final UInt64 withdrawableEpoch) { super( SSZ_SCHEMA, new SszPublicKey(pubkey), @@ -100,14 +100,14 @@ public Validator( } public Validator( - Bytes48 pubkey, - Bytes32 withdrawalCredentials, - UInt64 effectiveBalance, - boolean slashed, - UInt64 activationEligibilityEpoch, - UInt64 activationEpoch, - UInt64 exitEpoch, - UInt64 withdrawableEpoch) { + final Bytes48 pubkey, + final Bytes32 withdrawalCredentials, + final UInt64 effectiveBalance, + final boolean slashed, + final UInt64 activationEligibilityEpoch, + final UInt64 activationEpoch, + final UInt64 exitEpoch, + final UInt64 withdrawableEpoch) { super( SSZ_SCHEMA, new SszPublicKey(pubkey), @@ -164,7 +164,7 @@ public UInt64 getWithdrawableEpoch() { return getField7().get(); } - public Validator withEffectiveBalance(UInt64 effectiveBalance) { + public Validator withEffectiveBalance(final UInt64 effectiveBalance) { return new Validator( getPubkeyBytes(), getWithdrawalCredentials(), @@ -176,7 +176,7 @@ public Validator withEffectiveBalance(UInt64 effectiveBalance) { getWithdrawableEpoch()); } - public Validator withSlashed(boolean slashed) { + public Validator withSlashed(final boolean slashed) { return new Validator( getPubkeyBytes(), getWithdrawalCredentials(), @@ -188,7 +188,7 @@ public Validator withSlashed(boolean slashed) { getWithdrawableEpoch()); } - public Validator withActivationEligibilityEpoch(UInt64 activationEligibilityEpoch) { + public Validator withActivationEligibilityEpoch(final UInt64 activationEligibilityEpoch) { return new Validator( getPubkeyBytes(), getWithdrawalCredentials(), @@ -200,7 +200,7 @@ public Validator withActivationEligibilityEpoch(UInt64 activationEligibilityEpoc getWithdrawableEpoch()); } - public Validator withActivationEpoch(UInt64 activationEpoch) { + public Validator withActivationEpoch(final UInt64 activationEpoch) { return new Validator( getPubkeyBytes(), getWithdrawalCredentials(), @@ -212,7 +212,7 @@ public Validator withActivationEpoch(UInt64 activationEpoch) { getWithdrawableEpoch()); } - public Validator withExitEpoch(UInt64 exitEpoch) { + public Validator withExitEpoch(final UInt64 exitEpoch) { return new Validator( getPubkeyBytes(), getWithdrawalCredentials(), @@ -224,7 +224,7 @@ public Validator withExitEpoch(UInt64 exitEpoch) { getWithdrawableEpoch()); } - public Validator withWithdrawableEpoch(UInt64 withdrawableEpoch) { + public Validator withWithdrawableEpoch(final UInt64 withdrawableEpoch) { return new Validator( getPubkeyBytes(), getWithdrawalCredentials(), diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/BeaconState.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/BeaconState.java index 6c91fd16cea..25d9e6545d6 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/BeaconState.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/BeaconState.java @@ -39,7 +39,7 @@ import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.bellatrix.BeaconStateBellatrix; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.capella.BeaconStateCapella; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.deneb.BeaconStateDeneb; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.eip7594.BeaconStateEip7594; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.BeaconStateElectra; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.phase0.BeaconStatePhase0; public interface BeaconState extends SszContainer, ValidatorStats { @@ -189,7 +189,7 @@ default Optional toVersionDeneb() { return Optional.empty(); } - default Optional toVersionEip7594() { + default Optional toVersionElectra() { return Optional.empty(); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/BeaconStateCache.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/BeaconStateCache.java index f05901a7f3c..90cefbdcb1a 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/BeaconStateCache.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/BeaconStateCache.java @@ -18,13 +18,13 @@ public interface BeaconStateCache { - static TransitionCaches getTransitionCaches(BeaconState state) { + static TransitionCaches getTransitionCaches(final BeaconState state) { return state instanceof BeaconStateCache ? ((BeaconStateCache) state).getTransitionCaches() : TransitionCaches.getNoOp(); } - static SlotCaches getSlotCaches(BeaconState state) { + static SlotCaches getSlotCaches(final BeaconState state) { return state instanceof BeaconStateCache ? ((BeaconStateCache) state).getSlotCaches() : SlotCaches.getNoOp(); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/MutableBeaconState.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/MutableBeaconState.java index a526bfd1a27..f8168fafe37 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/MutableBeaconState.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/MutableBeaconState.java @@ -40,35 +40,35 @@ import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.bellatrix.MutableBeaconStateBellatrix; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.capella.MutableBeaconStateCapella; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.deneb.MutableBeaconStateDeneb; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.eip7594.MutableBeaconStateEip7594; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.MutableBeaconStateElectra; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.phase0.MutableBeaconStatePhase0; public interface MutableBeaconState extends BeaconState, SszMutableRefContainer { // Versioning - default void setGenesisTime(UInt64 genesisTime) { + default void setGenesisTime(final UInt64 genesisTime) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.GENESIS_TIME); set(fieldIndex, SszUInt64.of(genesisTime)); } - default void setGenesisValidatorsRoot(Bytes32 genesisValidatorsRoot) { + default void setGenesisValidatorsRoot(final Bytes32 genesisValidatorsRoot) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.GENESIS_VALIDATORS_ROOT); set(fieldIndex, SszBytes32.of(genesisValidatorsRoot)); } - default void setSlot(UInt64 slot) { + default void setSlot(final UInt64 slot) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.SLOT); set(fieldIndex, SszUInt64.of(slot)); } - default void setFork(Fork fork) { + default void setFork(final Fork fork) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.FORK); set(fieldIndex, fork); } // History - default void setLatestBlockHeader(BeaconBlockHeader latestBlockHeader) { + default void setLatestBlockHeader(final BeaconBlockHeader latestBlockHeader) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.LATEST_BLOCK_HEADER); set(fieldIndex, latestBlockHeader); } @@ -79,7 +79,7 @@ default SszMutableBytes32Vector getBlockRoots() { return getAnyByRef(fieldIndex); } - default void setBlockRoots(SszBytes32Vector blockRoots) { + default void setBlockRoots(final SszBytes32Vector blockRoots) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.BLOCK_ROOTS); set(fieldIndex, blockRoots); } @@ -90,7 +90,7 @@ default SszMutableBytes32Vector getStateRoots() { return getAnyByRef(fieldIndex); } - default void setStateRoots(SszBytes32Vector stateRoots) { + default void setStateRoots(final SszBytes32Vector stateRoots) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.STATE_ROOTS); set(fieldIndex, stateRoots); } @@ -101,13 +101,13 @@ default SszMutablePrimitiveList getHistoricalRoots() { return getAnyByRef(fieldIndex); } - default void setHistoricalRoots(SszPrimitiveList historicalRoots) { + default void setHistoricalRoots(final SszPrimitiveList historicalRoots) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.HISTORICAL_ROOTS); set(fieldIndex, historicalRoots); } // Eth1 - default void setEth1Data(Eth1Data eth1Data) { + default void setEth1Data(final Eth1Data eth1Data) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.ETH1_DATA); set(fieldIndex, eth1Data); } @@ -118,12 +118,12 @@ default SszMutableList getEth1DataVotes() { return getAnyByRef(fieldIndex); } - default void setEth1DataVotes(SszList eth1DataList) { + default void setEth1DataVotes(final SszList eth1DataList) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.ETH1_DATA_VOTES); set(fieldIndex, eth1DataList); } - default void setEth1DepositIndex(UInt64 eth1DepositIndex) { + default void setEth1DepositIndex(final UInt64 eth1DepositIndex) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.ETH1_DEPOSIT_INDEX); set(fieldIndex, SszUInt64.of(eth1DepositIndex)); } @@ -135,7 +135,7 @@ default SszMutableList getValidators() { return getAnyByRef(fieldIndex); } - default void setValidators(SszList validators) { + default void setValidators(final SszList validators) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.VALIDATORS); set(fieldIndex, validators); } @@ -146,7 +146,7 @@ default SszMutableUInt64List getBalances() { return getAnyByRef(fieldIndex); } - default void setBalances(SszUInt64List balances) { + default void setBalances(final SszUInt64List balances) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.BALANCES); set(fieldIndex, balances); } @@ -157,7 +157,7 @@ default SszMutableBytes32Vector getRandaoMixes() { return getAnyByRef(fieldIndex); } - default void setRandaoMixes(SszBytes32Vector randaoMixes) { + default void setRandaoMixes(final SszBytes32Vector randaoMixes) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.RANDAO_MIXES); set(fieldIndex, randaoMixes); } @@ -169,30 +169,30 @@ default SszMutablePrimitiveVector getSlashings() { return getAnyByRef(fieldIndex); } - default void setSlashings(SszPrimitiveVector slashings) { + default void setSlashings(final SszPrimitiveVector slashings) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.SLASHINGS); set(fieldIndex, slashings); } // Finality - default void setJustificationBits(SszBitvector justificationBits) { + default void setJustificationBits(final SszBitvector justificationBits) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.JUSTIFICATION_BITS); set(fieldIndex, justificationBits); } - default void setPreviousJustifiedCheckpoint(Checkpoint previousJustifiedCheckpoint) { + default void setPreviousJustifiedCheckpoint(final Checkpoint previousJustifiedCheckpoint) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.PREVIOUS_JUSTIFIED_CHECKPOINT); set(fieldIndex, previousJustifiedCheckpoint); } - default void setCurrentJustifiedCheckpoint(Checkpoint currentJustifiedCheckpoint) { + default void setCurrentJustifiedCheckpoint(final Checkpoint currentJustifiedCheckpoint) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.CURRENT_JUSTIFIED_CHECKPOINT); set(fieldIndex, currentJustifiedCheckpoint); } - default void setFinalizedCheckpoint(Checkpoint finalizedCheckpoint) { + default void setFinalizedCheckpoint(final Checkpoint finalizedCheckpoint) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.FINALIZED_CHECKPOINT); set(fieldIndex, finalizedCheckpoint); } @@ -220,7 +220,7 @@ default Optional toMutableVersionDeneb() { return Optional.empty(); } - default Optional toMutableVersionEip7594() { + default Optional toMutableVersionElectra() { return Optional.empty(); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/AbstractBeaconState.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/AbstractBeaconState.java index 67e3ebffc82..4dc22b8813b 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/AbstractBeaconState.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/AbstractBeaconState.java @@ -51,7 +51,7 @@ protected AbstractBeaconState( } protected AbstractBeaconState( - AbstractSszContainerSchema type, TreeNode backingNode) { + final AbstractSszContainerSchema type, final TreeNode backingNode) { super(type, backingNode); this.transitionCaches = TransitionCaches.createNewEmpty(); this.slotCaches = SlotCaches.createNewEmpty(); @@ -64,7 +64,7 @@ protected AbstractBeaconState( @Override public BeaconState updated( - Mutator mutator) throws E1, E2, E3 { + final Mutator mutator) throws E1, E2, E3 { MutableBeaconState writableCopy = createWritableCopy(); mutator.mutate(writableCopy); return writableCopy.commitChanges(); @@ -76,7 +76,7 @@ public int hashCode() { } @Override - public boolean equals(Object obj) { + public boolean equals(final Object obj) { return BeaconStateInvariants.equals(this, obj); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/AbstractBeaconStateSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/AbstractBeaconStateSchema.java index 47fb39138da..9cde4448638 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/AbstractBeaconStateSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/AbstractBeaconStateSchema.java @@ -39,7 +39,8 @@ protected AbstractBeaconStateSchema( this(name, combineFields(BeaconStateFields.getCommonFields(specConfig), uniqueFields)); } - private static List combineFields(List fieldsA, List fieldsB) { + private static List combineFields( + final List fieldsA, final List fieldsB) { return Stream.concat(fieldsA.stream(), fieldsB.stream()) .sorted(Comparator.comparing(SszField::getIndex)) .toList(); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/AbstractMutableBeaconState.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/AbstractMutableBeaconState.java index 8b0b6be52f2..d806ffb4208 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/AbstractMutableBeaconState.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/AbstractMutableBeaconState.java @@ -33,11 +33,11 @@ public abstract class AbstractMutableBeaconState< private final SlotCaches slotCaches; private final boolean builder; - protected AbstractMutableBeaconState(T backingImmutableView) { + protected AbstractMutableBeaconState(final T backingImmutableView) { this(backingImmutableView, false); } - protected AbstractMutableBeaconState(T backingImmutableView, boolean builder) { + protected AbstractMutableBeaconState(final T backingImmutableView, final boolean builder) { super(backingImmutableView); this.transitionCaches = builder ? TransitionCaches.getNoOp() : backingImmutableView.getTransitionCaches().copy(); @@ -51,7 +51,8 @@ protected AbstractMutableBeaconState(T backingImmutableView, boolean builder) { } @Override - protected T createImmutableSszComposite(TreeNode backingNode, IntCache viewCache) { + protected T createImmutableSszComposite( + final TreeNode backingNode, final IntCache viewCache) { return createImmutableBeaconState( backingNode, viewCache, @@ -92,7 +93,7 @@ public MutableBeaconState createWritableCopy() { @Override public BeaconState updated( - Mutator mutator) { + final Mutator mutator) { throw new UnsupportedOperationException(); } @@ -102,7 +103,7 @@ public int hashCode() { } @Override - public boolean equals(Object obj) { + public boolean equals(final Object obj) { return BeaconStateInvariants.equals(this, obj); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/BeaconStateFields.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/BeaconStateFields.java index 868fe63781e..c4c64b47e9a 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/BeaconStateFields.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/BeaconStateFields.java @@ -68,7 +68,17 @@ public enum BeaconStateFields implements SszFieldName { // Capella fields NEXT_WITHDRAWAL_INDEX, NEXT_WITHDRAWAL_VALIDATOR_INDEX, - HISTORICAL_SUMMARIES; + HISTORICAL_SUMMARIES, + // Electra fields + DEPOSIT_REQUESTS_START_INDEX, + DEPOSIT_BALANCE_TO_CONSUME, + EXIT_BALANCE_TO_CONSUME, + EARLIEST_EXIT_EPOCH, + CONSOLIDATION_BALANCE_TO_CONSUME, + EARLIEST_CONSOLIDATION_EPOCH, + PENDING_DEPOSITS, + PENDING_PARTIAL_WITHDRAWALS, + PENDING_CONSOLIDATIONS; private final String sszFieldName; diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/BeaconStateInvariants.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/BeaconStateInvariants.java index a7bf2f4e5f3..241c9be5e47 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/BeaconStateInvariants.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/BeaconStateInvariants.java @@ -73,7 +73,7 @@ public static UInt64 extractSlot(final Bytes bytes) { } @SuppressWarnings("ReferenceComparison") - static boolean equals(BeaconState state, Object obj) { + static boolean equals(final BeaconState state, final Object obj) { if (Objects.isNull(obj)) { return false; } @@ -90,11 +90,11 @@ static boolean equals(BeaconState state, Object obj) { return state.hashTreeRoot().equals(other.hashTreeRoot()); } - static int hashCode(BeaconState state) { + static int hashCode(final BeaconState state) { return state.hashTreeRoot().slice(0, 4).toInt(); } - static String toString(BeaconState state, final Consumer modifier) { + static String toString(final BeaconState state, final Consumer modifier) { final ToStringHelper builder = MoreObjects.toStringHelper(state) .add("genesis_time", state.getGenesisTime()) diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/TransitionCaches.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/TransitionCaches.java index 8ccb2a63cd2..51ae447c218 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/TransitionCaches.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/TransitionCaches.java @@ -13,6 +13,7 @@ package tech.pegasys.teku.spec.datastructures.state.beaconstate.common; +import it.unimi.dsi.fastutil.ints.Int2IntMap; import it.unimi.dsi.fastutil.ints.IntList; import java.util.List; import java.util.Map; @@ -34,6 +35,7 @@ public class TransitionCaches { private static final int MAX_ACTIVE_VALIDATORS_CACHE = 8; private static final int MAX_BEACON_PROPOSER_INDEX_CACHE = 1; private static final int MAX_BEACON_COMMITTEE_CACHE = 64 * 64; + private static final int MAX_BEACON_COMMITTEES_SIZE_CACHE = 64; private static final int MAX_TOTAL_ACTIVE_BALANCE_CACHE = 2; private static final int MAX_COMMITTEE_SHUFFLE_CACHE = 3; private static final int MAX_EFFECTIVE_BALANCE_CACHE = 1; @@ -48,6 +50,7 @@ public class TransitionCaches { NoOpCache.getNoOpCache(), NoOpCache.getNoOpCache(), NoOpCache.getNoOpCache(), + NoOpCache.getNoOpCache(), ValidatorIndexCache.NO_OP_INSTANCE, NoOpCache.getNoOpCache(), NoOpCache.getNoOpCache(), @@ -74,6 +77,7 @@ public static TransitionCaches getNoOp() { private final Cache activeValidators; private final Cache beaconProposerIndex; private final Cache, IntList> beaconCommittee; + private final Cache beaconCommitteesSize; private final Cache attestersTotalBalance; private final Cache totalActiveBalance; private final Cache validatorsPubKeys; @@ -91,6 +95,7 @@ private TransitionCaches() { activeValidators = LRUCache.create(MAX_ACTIVE_VALIDATORS_CACHE); beaconProposerIndex = LRUCache.create(MAX_BEACON_PROPOSER_INDEX_CACHE); beaconCommittee = LRUCache.create(MAX_BEACON_COMMITTEE_CACHE); + beaconCommitteesSize = LRUCache.create(MAX_BEACON_COMMITTEES_SIZE_CACHE); attestersTotalBalance = LRUCache.create(MAX_BEACON_COMMITTEE_CACHE); totalActiveBalance = LRUCache.create(MAX_TOTAL_ACTIVE_BALANCE_CACHE); validatorsPubKeys = LRUCache.create(Integer.MAX_VALUE - 1); @@ -103,21 +108,23 @@ private TransitionCaches() { } private TransitionCaches( - Cache activeValidators, - Cache beaconProposerIndex, - Cache, IntList> beaconCommittee, - Cache attestersTotalBalance, - Cache totalActiveBalance, - Cache validatorsPubKeys, - ValidatorIndexCache validatorIndexCache, - Cache committeeShuffle, - Cache> effectiveBalances, - Cache> syncCommitteeCache, - Cache baseRewardPerIncrement, - ProgressiveTotalBalancesUpdates progressiveTotalBalances) { + final Cache activeValidators, + final Cache beaconProposerIndex, + final Cache, IntList> beaconCommittee, + final Cache beaconCommitteesSize, + final Cache attestersTotalBalance, + final Cache totalActiveBalance, + final Cache validatorsPubKeys, + final ValidatorIndexCache validatorIndexCache, + final Cache committeeShuffle, + final Cache> effectiveBalances, + final Cache> syncCommitteeCache, + final Cache baseRewardPerIncrement, + final ProgressiveTotalBalancesUpdates progressiveTotalBalances) { this.activeValidators = activeValidators; this.beaconProposerIndex = beaconProposerIndex; this.beaconCommittee = beaconCommittee; + this.beaconCommitteesSize = beaconCommitteesSize; this.attestersTotalBalance = attestersTotalBalance; this.totalActiveBalance = totalActiveBalance; this.validatorsPubKeys = validatorsPubKeys; @@ -129,7 +136,7 @@ private TransitionCaches( this.progressiveTotalBalances = progressiveTotalBalances; } - public void setLatestTotalBalances(TotalBalances totalBalances) { + public void setLatestTotalBalances(final TotalBalances totalBalances) { this.latestTotalBalances = Optional.of(totalBalances); } @@ -161,6 +168,11 @@ public Cache, IntList> getBeaconCommittee() { return beaconCommittee; } + /** (slot) -> Map(committeeIndex, size of a committee) */ + public Cache getBeaconCommitteesSize() { + return beaconCommitteesSize; + } + /** (slot) -> (total effective balance of attesters in slot) */ public Cache getAttestersTotalBalance() { return attestersTotalBalance; @@ -221,6 +233,7 @@ public TransitionCaches copy() { activeValidators.copy(), beaconProposerIndex.copy(), beaconCommittee.copy(), + beaconCommitteesSize.copy(), attestersTotalBalance.copy(), totalActiveBalance.copy(), validatorsPubKeys, diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/ValidatorIndexCache.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/ValidatorIndexCache.java index 98713f69066..de7019f287f 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/ValidatorIndexCache.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/ValidatorIndexCache.java @@ -25,15 +25,13 @@ import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; public class ValidatorIndexCache { + private final Cache validatorIndices; + private final AtomicInteger lastCachedIndex; private static final int INDEX_NONE = -1; - - static final ValidatorIndexCache NO_OP_INSTANCE = - new ValidatorIndexCache(NoOpCache.getNoOpCache(), INDEX_NONE, INDEX_NONE); - - private final Cache validatorIndices; private final AtomicInteger latestFinalizedIndex; - private final AtomicInteger lastCachedIndex; + public static final ValidatorIndexCache NO_OP_INSTANCE = + new ValidatorIndexCache(NoOpCache.getNoOpCache(), INDEX_NONE, INDEX_NONE); @VisibleForTesting ValidatorIndexCache( @@ -46,61 +44,23 @@ public class ValidatorIndexCache { } public ValidatorIndexCache() { - validatorIndices = LRUCache.create(Integer.MAX_VALUE - 1); + this.validatorIndices = LRUCache.create(Integer.MAX_VALUE - 1); + this.lastCachedIndex = new AtomicInteger(INDEX_NONE); latestFinalizedIndex = new AtomicInteger(INDEX_NONE); - lastCachedIndex = new AtomicInteger(INDEX_NONE); } public Optional getValidatorIndex( final BeaconState state, final BLSPublicKey publicKey) { - final SszList validators = state.getValidators(); final Optional validatorIndex = validatorIndices.getCached(publicKey); if (validatorIndex.isPresent()) { - return validatorIndex.filter(index -> index < validators.size()); - } - // Using the same latestFinalizedIndex when scanning through - // the finalized and the non-finalized states ensures consistency - final int latestFinalizedIndexSnapshot = latestFinalizedIndex.get(); - return findIndexFromFinalizedState(validators, publicKey, latestFinalizedIndexSnapshot) - .or( - () -> - findIndexFromNonFinalizedState( - validators, publicKey, latestFinalizedIndexSnapshot)); - } - - private Optional findIndexFromFinalizedState( - final SszList validators, - final BLSPublicKey publicKey, - final int latestFinalizedIndex) { - for (int i = lastCachedIndex.get() + 1; - i <= Math.min(latestFinalizedIndex, validators.size() - 1); - i++) { - final BLSPublicKey pubKey = validators.get(i).getPublicKey(); - // cache finalized mapping - validatorIndices.invalidateWithNewValue(pubKey, i); - updateLastCachedIndex(i); - if (pubKey.equals(publicKey)) { - return Optional.of(i); - } + return validatorIndex.filter(index -> index < state.getValidators().size()); } - return Optional.empty(); - } - private void updateLastCachedIndex(final int updatedIndex) { - lastCachedIndex.updateAndGet(curr -> Math.max(curr, updatedIndex)); + return findIndexFromState(state.getValidators(), publicKey); } - private Optional findIndexFromNonFinalizedState( - final SszList validators, - final BLSPublicKey publicKey, - final int latestFinalizedIndex) { - for (int i = latestFinalizedIndex + 1; i < validators.size(); i++) { - final BLSPublicKey pubKey = validators.get(i).getPublicKey(); - if (pubKey.equals(publicKey)) { - return Optional.of(i); - } - } - return Optional.empty(); + public void invalidateWithNewValue(final BLSPublicKey pubKey, final int updatedIndex) { + validatorIndices.invalidateWithNewValue(pubKey, updatedIndex); } public void updateLatestFinalizedIndex(final BeaconState finalizedState) { @@ -108,26 +68,41 @@ public void updateLatestFinalizedIndex(final BeaconState finalizedState) { curr -> Math.max(curr, finalizedState.getValidators().size() - 1)); } - public void invalidateWithNewValue(final BLSPublicKey pubKey, final int updatedIndex) { - if (updatedIndex > latestFinalizedIndex.get()) { - // do not cache if index is not finalized - return; - } - validatorIndices.invalidateWithNewValue(pubKey, updatedIndex); - } - @VisibleForTesting public int getLatestFinalizedIndex() { return latestFinalizedIndex.get(); } @VisibleForTesting - Cache getValidatorIndices() { - return validatorIndices; + int getLastCachedIndex() { + return lastCachedIndex.get(); } @VisibleForTesting - int getLastCachedIndex() { - return lastCachedIndex.get(); + int getCacheSize() { + return validatorIndices.size(); + } + + private void updateLastIndex(final int i) { + lastCachedIndex.updateAndGet(curr -> Math.max(curr, i)); + } + + private Optional findIndexFromState( + final SszList validatorList, final BLSPublicKey publicKey) { + final int initialCacheSize = getCacheSize(); + for (int i = Math.max(lastCachedIndex.get() + 1, 0); i < validatorList.size(); i++) { + final BLSPublicKey pubKey = validatorList.get(i).getPublicKey(); + validatorIndices.invalidateWithNewValue(pubKey, i); + if (pubKey.equals(publicKey)) { + if (initialCacheSize < getCacheSize()) { + updateLastIndex(i); + } + return Optional.of(i); + } + } + if (initialCacheSize < getCacheSize()) { + updateLastIndex(getCacheSize() - 1); + } + return Optional.empty(); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/analysis/ValidatorStats.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/analysis/ValidatorStats.java index abe0d82e8c4..813211b3859 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/analysis/ValidatorStats.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/analysis/ValidatorStats.java @@ -24,7 +24,8 @@ class CorrectAndLiveValidators { private final int numberOfCorrectValidators; private final int numberOfLiveValidators; - public CorrectAndLiveValidators(int numberOfCorrectValidators, int numberOfLiveValidators) { + public CorrectAndLiveValidators( + final int numberOfCorrectValidators, final int numberOfLiveValidators) { this.numberOfCorrectValidators = numberOfCorrectValidators; this.numberOfLiveValidators = numberOfLiveValidators; } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/BeaconStateAltair.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/BeaconStateAltair.java index 687a528feba..7ead36a73e6 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/BeaconStateAltair.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/BeaconStateAltair.java @@ -86,7 +86,7 @@ default Optional toVersionAltair() { MutableBeaconStateAltair createWritableCopy(); default - BeaconStateAltair updatedAltair(Mutator mutator) + BeaconStateAltair updatedAltair(final Mutator mutator) throws E1, E2, E3 { MutableBeaconStateAltair writableCopy = createWritableCopy(); mutator.mutate(writableCopy); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/BeaconStateAltairImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/BeaconStateAltairImpl.java index 1b201a21a02..cb94de57ab7 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/BeaconStateAltairImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/BeaconStateAltairImpl.java @@ -35,16 +35,16 @@ class BeaconStateAltairImpl extends AbstractBeaconState type, - TreeNode backingNode, - IntCache cache, - TransitionCaches transitionCaches, - SlotCaches slotCaches) { + final SszCompositeSchema type, + final TreeNode backingNode, + final IntCache cache, + final TransitionCaches transitionCaches, + final SlotCaches slotCaches) { super(type, backingNode, cache, transitionCaches, slotCaches); } BeaconStateAltairImpl( - AbstractSszContainerSchema type, TreeNode backingNode) { + final AbstractSszContainerSchema type, final TreeNode backingNode) { super(type, backingNode); } @@ -59,11 +59,12 @@ public MutableBeaconStateAltair createWritableCopy() { } @Override - protected void describeCustomFields(ToStringHelper stringBuilder) { + protected void describeCustomFields(final ToStringHelper stringBuilder) { describeCustomFields(stringBuilder, this); } - static void describeCustomFields(ToStringHelper stringBuilder, final BeaconStateAltair state) { + static void describeCustomFields( + final ToStringHelper stringBuilder, final BeaconStateAltair state) { stringBuilder .add("previous_epoch_participation", state.getPreviousEpochParticipation()) .add("current_epoch_participation", state.getCurrentEpochParticipation()) diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/BeaconStateSchemaAltair.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/BeaconStateSchemaAltair.java index 7ea4a766d99..14850053fe6 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/BeaconStateSchemaAltair.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/BeaconStateSchemaAltair.java @@ -14,9 +14,12 @@ package tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.altair; import static com.google.common.base.Preconditions.checkArgument; +import static tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.phase0.BeaconStateSchemaPhase0.CURRENT_EPOCH_PARTICIPATION_FIELD_INDEX; +import static tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.phase0.BeaconStateSchemaPhase0.PREVIOUS_EPOCH_PARTICIPATION_FIELD_INDEX; import com.google.common.annotations.VisibleForTesting; import java.util.List; +import java.util.stream.Stream; import tech.pegasys.teku.infrastructure.ssz.primitive.SszByte; import tech.pegasys.teku.infrastructure.ssz.schema.SszListSchema; import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; @@ -30,15 +33,14 @@ import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconStateSchema; import tech.pegasys.teku.spec.datastructures.state.beaconstate.common.AbstractBeaconStateSchema; import tech.pegasys.teku.spec.datastructures.state.beaconstate.common.BeaconStateFields; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.phase0.BeaconStateSchemaPhase0; public class BeaconStateSchemaAltair extends AbstractBeaconStateSchema { - private static final int PREVIOUS_EPOCH_PARTICIPATION_FIELD_INDEX = 15; - private static final int CURRENT_EPOCH_PARTICIPATION_FIELD_INDEX = 16; - private static final int INACTIVITY_SCORES_FIELD_INDEX = 21; - private static final int CURRENT_SYNC_COMMITTEE_FIELD_INDEX = 22; - private static final int NEXT_SYNC_COMMITTEE_FIELD_INDEX = 23; + public static final int INACTIVITY_SCORES_FIELD_INDEX = 21; + public static final int CURRENT_SYNC_COMMITTEE_FIELD_INDEX = 22; + public static final int NEXT_SYNC_COMMITTEE_FIELD_INDEX = 23; @VisibleForTesting BeaconStateSchemaAltair(final SpecConfig specConfig) { @@ -50,42 +52,45 @@ public static BeaconStateSchemaAltair create(final SpecConfig specConfig) { } public static List getUniqueFields(final SpecConfig specConfig) { - final SszField previousEpochAttestationsField = - new SszField( - PREVIOUS_EPOCH_PARTICIPATION_FIELD_INDEX, - BeaconStateFields.PREVIOUS_EPOCH_PARTICIPATION, - () -> - SszListSchema.create( - SszPrimitiveSchemas.UINT8_SCHEMA, specConfig.getValidatorRegistryLimit())); - final SszField currentEpochAttestationsField = - new SszField( - CURRENT_EPOCH_PARTICIPATION_FIELD_INDEX, - BeaconStateFields.CURRENT_EPOCH_PARTICIPATION, - () -> - SszListSchema.create( - SszPrimitiveSchemas.UINT8_SCHEMA, specConfig.getValidatorRegistryLimit())); - - final SszField inactivityScores = - new SszField( - INACTIVITY_SCORES_FIELD_INDEX, - BeaconStateFields.INACTIVITY_SCORES, - SszUInt64ListSchema.create(specConfig.getValidatorRegistryLimit())); - final SszField currentSyncCommitteeField = - new SszField( - CURRENT_SYNC_COMMITTEE_FIELD_INDEX, - BeaconStateFields.CURRENT_SYNC_COMMITTEE, - () -> new SyncCommitteeSchema(SpecConfigAltair.required(specConfig))); - final SszField nextSyncCommitteeField = - new SszField( - NEXT_SYNC_COMMITTEE_FIELD_INDEX, - BeaconStateFields.NEXT_SYNC_COMMITTEE, - () -> new SyncCommitteeSchema(SpecConfigAltair.required(specConfig))); - return List.of( - previousEpochAttestationsField, - currentEpochAttestationsField, - inactivityScores, - currentSyncCommitteeField, - nextSyncCommitteeField); + final List updatedFields = + List.of( + new SszField( + PREVIOUS_EPOCH_PARTICIPATION_FIELD_INDEX, + BeaconStateFields.PREVIOUS_EPOCH_PARTICIPATION, + () -> + SszListSchema.create( + SszPrimitiveSchemas.UINT8_SCHEMA, specConfig.getValidatorRegistryLimit())), + new SszField( + CURRENT_EPOCH_PARTICIPATION_FIELD_INDEX, + BeaconStateFields.CURRENT_EPOCH_PARTICIPATION, + () -> + SszListSchema.create( + SszPrimitiveSchemas.UINT8_SCHEMA, specConfig.getValidatorRegistryLimit()))); + + final List newFields = + List.of( + new SszField( + INACTIVITY_SCORES_FIELD_INDEX, + BeaconStateFields.INACTIVITY_SCORES, + SszUInt64ListSchema.create(specConfig.getValidatorRegistryLimit())), + new SszField( + CURRENT_SYNC_COMMITTEE_FIELD_INDEX, + BeaconStateFields.CURRENT_SYNC_COMMITTEE, + () -> new SyncCommitteeSchema(SpecConfigAltair.required(specConfig))), + new SszField( + NEXT_SYNC_COMMITTEE_FIELD_INDEX, + BeaconStateFields.NEXT_SYNC_COMMITTEE, + () -> new SyncCommitteeSchema(SpecConfigAltair.required(specConfig)))); + + return Stream.concat( + BeaconStateSchemaPhase0.getUniqueFields(specConfig).stream(), newFields.stream()) + .map( + field -> + updatedFields.stream() + .filter(updatedField -> updatedField.getIndex() == field.getIndex()) + .findFirst() + .orElse(field)) + .toList(); } public static BeaconStateSchemaAltair required(final BeaconStateSchema schema) { @@ -119,7 +124,7 @@ public SyncCommitteeSchema getCurrentSyncCommitteeSchema() { } @Override - public BeaconStateAltair createFromBackingNode(TreeNode node) { + public BeaconStateAltair createFromBackingNode(final TreeNode node) { return new BeaconStateAltairImpl(this, node); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/MutableBeaconStateAltair.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/MutableBeaconStateAltair.java index c9f097bfb99..75fd42c36d4 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/MutableBeaconStateAltair.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/MutableBeaconStateAltair.java @@ -64,17 +64,17 @@ default SszMutableUInt64List getInactivityScores() { return getAnyByRef(fieldIndex); } - default void setInactivityScores(SszUInt64List newValue) { + default void setInactivityScores(final SszUInt64List newValue) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.INACTIVITY_SCORES); set(fieldIndex, newValue); } - default void setCurrentSyncCommittee(SyncCommittee currentSyncCommittee) { + default void setCurrentSyncCommittee(final SyncCommittee currentSyncCommittee) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.CURRENT_SYNC_COMMITTEE); set(fieldIndex, currentSyncCommittee); } - default void setNextSyncCommittee(SyncCommittee nextSyncCommittee) { + default void setNextSyncCommittee(final SyncCommittee nextSyncCommittee) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.NEXT_SYNC_COMMITTEE); set(fieldIndex, nextSyncCommittee); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/MutableBeaconStateAltairImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/MutableBeaconStateAltairImpl.java index 23944be2e51..e83fdb03ebb 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/MutableBeaconStateAltairImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/MutableBeaconStateAltairImpl.java @@ -25,11 +25,12 @@ class MutableBeaconStateAltairImpl extends AbstractMutableBeaconState implements MutableBeaconStateAltair, BeaconStateCache, ValidatorStatsAltair { - MutableBeaconStateAltairImpl(BeaconStateAltairImpl backingImmutableView) { + MutableBeaconStateAltairImpl(final BeaconStateAltairImpl backingImmutableView) { super(backingImmutableView); } - MutableBeaconStateAltairImpl(BeaconStateAltairImpl backingImmutableView, boolean builder) { + MutableBeaconStateAltairImpl( + final BeaconStateAltairImpl backingImmutableView, final boolean builder) { super(backingImmutableView, builder); } @@ -40,10 +41,10 @@ public BeaconStateSchemaAltair getBeaconStateSchema() { @Override protected BeaconStateAltairImpl createImmutableBeaconState( - TreeNode backingNode, - IntCache viewCache, - TransitionCaches transitionCaches, - SlotCaches slotCaches) { + final TreeNode backingNode, + final IntCache viewCache, + final TransitionCaches transitionCaches, + final SlotCaches slotCaches) { return new BeaconStateAltairImpl( getSchema(), backingNode, viewCache, transitionCaches, slotCaches); } @@ -54,7 +55,7 @@ public BeaconStateAltair commitChanges() { } @Override - protected void addCustomFields(ToStringHelper stringBuilder) { + protected void addCustomFields(final ToStringHelper stringBuilder) { BeaconStateAltairImpl.describeCustomFields(stringBuilder, this); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/bellatrix/BeaconStateBellatrix.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/bellatrix/BeaconStateBellatrix.java index 17b1eefb9f8..1ceb2a0b026 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/bellatrix/BeaconStateBellatrix.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/bellatrix/BeaconStateBellatrix.java @@ -47,14 +47,14 @@ default Optional toVersionBellatrix() { default BeaconStateBellatrix updatedBellatrix( - Mutator mutator) throws E1, E2, E3 { + final Mutator mutator) throws E1, E2, E3 { MutableBeaconStateBellatrix writableCopy = createWritableCopy(); mutator.mutate(writableCopy); return writableCopy.commitChanges(); } static void describeCustomBellatrixFields( - MoreObjects.ToStringHelper stringBuilder, final BeaconStateBellatrix state) { + final MoreObjects.ToStringHelper stringBuilder, final BeaconStateBellatrix state) { stringBuilder.add("execution_payload_header", state.getLatestExecutionPayloadHeader()); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/bellatrix/BeaconStateBellatrixImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/bellatrix/BeaconStateBellatrixImpl.java index 365d62f6a45..4388b3461c6 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/bellatrix/BeaconStateBellatrixImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/bellatrix/BeaconStateBellatrixImpl.java @@ -36,16 +36,16 @@ class BeaconStateBellatrixImpl extends AbstractBeaconState type, - TreeNode backingNode, - IntCache cache, - TransitionCaches transitionCaches, - SlotCaches slotCaches) { + final SszCompositeSchema type, + final TreeNode backingNode, + final IntCache cache, + final TransitionCaches transitionCaches, + final SlotCaches slotCaches) { super(type, backingNode, cache, transitionCaches, slotCaches); } BeaconStateBellatrixImpl( - AbstractSszContainerSchema type, TreeNode backingNode) { + final AbstractSszContainerSchema type, final TreeNode backingNode) { super(type, backingNode); } @@ -60,7 +60,7 @@ public MutableBeaconStateBellatrix createWritableCopy() { } @Override - protected void describeCustomFields(ToStringHelper stringBuilder) { + protected void describeCustomFields(final ToStringHelper stringBuilder) { BeaconStateBellatrix.describeCustomBellatrixFields(stringBuilder, this); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/bellatrix/BeaconStateSchemaBellatrix.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/bellatrix/BeaconStateSchemaBellatrix.java index 81588b14952..f964acc165c 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/bellatrix/BeaconStateSchemaBellatrix.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/bellatrix/BeaconStateSchemaBellatrix.java @@ -14,6 +14,7 @@ package tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.bellatrix; import static com.google.common.base.Preconditions.checkArgument; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_PAYLOAD_HEADER_SCHEMA; import com.google.common.annotations.VisibleForTesting; import java.util.List; @@ -24,13 +25,13 @@ import tech.pegasys.teku.infrastructure.ssz.sos.SszField; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; import tech.pegasys.teku.spec.config.SpecConfig; -import tech.pegasys.teku.spec.config.SpecConfigBellatrix; import tech.pegasys.teku.spec.datastructures.execution.versions.bellatrix.ExecutionPayloadHeaderSchemaBellatrix; import tech.pegasys.teku.spec.datastructures.state.SyncCommittee.SyncCommitteeSchema; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconStateSchema; import tech.pegasys.teku.spec.datastructures.state.beaconstate.common.AbstractBeaconStateSchema; import tech.pegasys.teku.spec.datastructures.state.beaconstate.common.BeaconStateFields; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.altair.BeaconStateSchemaAltair; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; public class BeaconStateSchemaBellatrix extends AbstractBeaconStateSchema { @@ -38,25 +39,26 @@ public class BeaconStateSchemaBellatrix public static final int LATEST_EXECUTION_PAYLOAD_HEADER_FIELD_INDEX = 24; @VisibleForTesting - BeaconStateSchemaBellatrix(final SpecConfig specConfig) { - super("BeaconStateBellatrix", getUniqueFields(specConfig), specConfig); + BeaconStateSchemaBellatrix(final SpecConfig specConfig, final SchemaRegistry schemaRegistry) { + super("BeaconStateBellatrix", getUniqueFields(specConfig, schemaRegistry), specConfig); } - public static BeaconStateSchemaBellatrix create(final SpecConfig specConfig) { - return new BeaconStateSchemaBellatrix(specConfig); + public static BeaconStateSchemaBellatrix create( + final SpecConfig specConfig, final SchemaRegistry schemaRegistry) { + return new BeaconStateSchemaBellatrix(specConfig, schemaRegistry); } - public static List getUniqueFields(final SpecConfig specConfig) { - final SszField latestExecutionPayloadHeaderField = - new SszField( - LATEST_EXECUTION_PAYLOAD_HEADER_FIELD_INDEX, - BeaconStateFields.LATEST_EXECUTION_PAYLOAD_HEADER, - () -> - new ExecutionPayloadHeaderSchemaBellatrix( - SpecConfigBellatrix.required(specConfig))); + public static List getUniqueFields( + final SpecConfig specConfig, final SchemaRegistry schemaRegistry) { + final List newFields = + List.of( + new SszField( + LATEST_EXECUTION_PAYLOAD_HEADER_FIELD_INDEX, + BeaconStateFields.LATEST_EXECUTION_PAYLOAD_HEADER, + () -> schemaRegistry.get(EXECUTION_PAYLOAD_HEADER_SCHEMA))); + return Stream.concat( - BeaconStateSchemaAltair.getUniqueFields(specConfig).stream(), - Stream.of(latestExecutionPayloadHeaderField)) + BeaconStateSchemaAltair.getUniqueFields(specConfig).stream(), newFields.stream()) .toList(); } @@ -101,7 +103,7 @@ public ExecutionPayloadHeaderSchemaBellatrix getLastExecutionPayloadHeaderSchema } @Override - public BeaconStateBellatrix createFromBackingNode(TreeNode node) { + public BeaconStateBellatrix createFromBackingNode(final TreeNode node) { return new BeaconStateBellatrixImpl(this, node); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/bellatrix/MutableBeaconStateBellatrix.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/bellatrix/MutableBeaconStateBellatrix.java index 2e3a569cf71..b81b6e0b284 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/bellatrix/MutableBeaconStateBellatrix.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/bellatrix/MutableBeaconStateBellatrix.java @@ -31,7 +31,8 @@ static MutableBeaconStateBellatrix required(final MutableBeaconState state) { "Expected a bellatrix state but got: " + state.getClass().getSimpleName())); } - default void setLatestExecutionPayloadHeader(ExecutionPayloadHeader executionPayloadHeader) { + default void setLatestExecutionPayloadHeader( + final ExecutionPayloadHeader executionPayloadHeader) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.LATEST_EXECUTION_PAYLOAD_HEADER); set(fieldIndex, executionPayloadHeader); @@ -48,7 +49,7 @@ default Optional toMutableVersionBellatrix() { @Override default BeaconStateBellatrix updatedBellatrix( - Mutator mutator) throws E1, E2, E3 { + final Mutator mutator) throws E1, E2, E3 { throw new UnsupportedOperationException(); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/bellatrix/MutableBeaconStateBellatrixImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/bellatrix/MutableBeaconStateBellatrixImpl.java index 3652518f0bc..713b316e859 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/bellatrix/MutableBeaconStateBellatrixImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/bellatrix/MutableBeaconStateBellatrixImpl.java @@ -28,11 +28,12 @@ class MutableBeaconStateBellatrixImpl extends AbstractMutableBeaconState implements MutableBeaconStateBellatrix, BeaconStateCache, ValidatorStatsAltair { - MutableBeaconStateBellatrixImpl(BeaconStateBellatrixImpl backingImmutableView) { + MutableBeaconStateBellatrixImpl(final BeaconStateBellatrixImpl backingImmutableView) { super(backingImmutableView); } - MutableBeaconStateBellatrixImpl(BeaconStateBellatrixImpl backingImmutableView, boolean builder) { + MutableBeaconStateBellatrixImpl( + final BeaconStateBellatrixImpl backingImmutableView, final boolean builder) { super(backingImmutableView, builder); } @@ -43,10 +44,10 @@ public BeaconStateSchemaBellatrix getBeaconStateSchema() { @Override protected BeaconStateBellatrixImpl createImmutableBeaconState( - TreeNode backingNode, - IntCache viewCache, - TransitionCaches transitionCaches, - SlotCaches slotCaches) { + final TreeNode backingNode, + final IntCache viewCache, + final TransitionCaches transitionCaches, + final SlotCaches slotCaches) { return new BeaconStateBellatrixImpl( getSchema(), backingNode, viewCache, transitionCaches, slotCaches); } @@ -58,12 +59,12 @@ public BeaconStateBellatrix commitChanges() { @Override public BeaconState updated( - Mutator mutator) { + final Mutator mutator) { throw new UnsupportedOperationException(); } @Override - protected void addCustomFields(ToStringHelper stringBuilder) { + protected void addCustomFields(final ToStringHelper stringBuilder) { BeaconStateBellatrix.describeCustomBellatrixFields(stringBuilder, this); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/capella/BeaconStateCapella.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/capella/BeaconStateCapella.java index c69ec60bbd4..9b4681c3821 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/capella/BeaconStateCapella.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/capella/BeaconStateCapella.java @@ -37,7 +37,7 @@ static BeaconStateCapella required(final BeaconState state) { } static void describeCustomCapellaFields( - MoreObjects.ToStringHelper stringBuilder, BeaconStateCapella state) { + final MoreObjects.ToStringHelper stringBuilder, final BeaconStateCapella state) { BeaconStateBellatrix.describeCustomBellatrixFields(stringBuilder, state); stringBuilder.add("next_withdrawal_index", state.getNextWithdrawalIndex()); stringBuilder.add("next_withdrawal_validator_index", state.getNextWithdrawalValidatorIndex()); @@ -48,8 +48,8 @@ static void describeCustomCapellaFields( MutableBeaconStateCapella createWritableCopy(); default - BeaconStateCapella updatedCapella(Mutator mutator) - throws E1, E2, E3 { + BeaconStateCapella updatedCapella( + final Mutator mutator) throws E1, E2, E3 { MutableBeaconStateCapella writableCopy = createWritableCopy(); mutator.mutate(writableCopy); return writableCopy.commitChanges(); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/capella/BeaconStateCapellaImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/capella/BeaconStateCapellaImpl.java index 94f8d8ec2dc..f4d78bfff52 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/capella/BeaconStateCapellaImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/capella/BeaconStateCapellaImpl.java @@ -36,16 +36,16 @@ public class BeaconStateCapellaImpl extends AbstractBeaconState type, - TreeNode backingNode, - IntCache cache, - TransitionCaches transitionCaches, - SlotCaches slotCaches) { + final SszCompositeSchema type, + final TreeNode backingNode, + final IntCache cache, + final TransitionCaches transitionCaches, + final SlotCaches slotCaches) { super(type, backingNode, cache, transitionCaches, slotCaches); } BeaconStateCapellaImpl( - AbstractSszContainerSchema type, TreeNode backingNode) { + final AbstractSszContainerSchema type, final TreeNode backingNode) { super(type, backingNode); } @@ -60,7 +60,7 @@ public MutableBeaconStateCapella createWritableCopy() { } @Override - protected void describeCustomFields(MoreObjects.ToStringHelper stringBuilder) { + protected void describeCustomFields(final MoreObjects.ToStringHelper stringBuilder) { BeaconStateCapella.describeCustomCapellaFields(stringBuilder, this); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/capella/BeaconStateSchemaCapella.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/capella/BeaconStateSchemaCapella.java index f8dcb0e0d54..fd4a6f7fb95 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/capella/BeaconStateSchemaCapella.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/capella/BeaconStateSchemaCapella.java @@ -14,7 +14,7 @@ package tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.capella; import static com.google.common.base.Preconditions.checkArgument; -import static tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.bellatrix.BeaconStateSchemaBellatrix.LATEST_EXECUTION_PAYLOAD_HEADER_FIELD_INDEX; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.HISTORICAL_SUMMARIES_SCHEMA; import com.google.common.annotations.VisibleForTesting; import java.util.List; @@ -27,59 +27,46 @@ import tech.pegasys.teku.infrastructure.ssz.sos.SszField; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; import tech.pegasys.teku.spec.config.SpecConfig; -import tech.pegasys.teku.spec.config.SpecConfigCapella; import tech.pegasys.teku.spec.datastructures.execution.versions.capella.ExecutionPayloadHeaderSchemaCapella; import tech.pegasys.teku.spec.datastructures.state.SyncCommittee; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconStateSchema; import tech.pegasys.teku.spec.datastructures.state.beaconstate.common.AbstractBeaconStateSchema; import tech.pegasys.teku.spec.datastructures.state.beaconstate.common.BeaconStateFields; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.altair.BeaconStateSchemaAltair; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.bellatrix.BeaconStateSchemaBellatrix; import tech.pegasys.teku.spec.datastructures.state.versions.capella.HistoricalSummary; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; public class BeaconStateSchemaCapella extends AbstractBeaconStateSchema { - public static final int NEXT_WITHDRAWAL_INDEX = 25; - public static final int NEXT_WITHDRAWAL_VALIDATOR_INDEX = 26; - public static final int HISTORICAL_SUMMARIES_INDEX = 27; + public static final int NEXT_WITHDRAWAL_INDEX_FIELD_INDEX = 25; + public static final int NEXT_WITHDRAWAL_VALIDATOR_INDEX_FIELD_INDEX = 26; + public static final int HISTORICAL_SUMMARIES_FIELD_INDEX = 27; @VisibleForTesting - BeaconStateSchemaCapella(final SpecConfig specConfig) { - super("BeaconStateCapella", getUniqueFields(specConfig), specConfig); + BeaconStateSchemaCapella(final SpecConfig specConfig, final SchemaRegistry schemaRegistry) { + super("BeaconStateCapella", getUniqueFields(specConfig, schemaRegistry), specConfig); } - private static List getUniqueFields(final SpecConfig specConfig) { - final HistoricalSummary.HistoricalSummarySchema historicalSummarySchema = - new HistoricalSummary.HistoricalSummarySchema(); - final SszField latestExecutionPayloadHeaderField = - new SszField( - LATEST_EXECUTION_PAYLOAD_HEADER_FIELD_INDEX, - BeaconStateFields.LATEST_EXECUTION_PAYLOAD_HEADER, - () -> new ExecutionPayloadHeaderSchemaCapella(SpecConfigCapella.required(specConfig))); - final SszField nextWithdrawalIndexField = - new SszField( - NEXT_WITHDRAWAL_INDEX, - BeaconStateFields.NEXT_WITHDRAWAL_INDEX, - () -> SszPrimitiveSchemas.UINT64_SCHEMA); - final SszField nextWithdrawalValidatorIndexField = - new SszField( - NEXT_WITHDRAWAL_VALIDATOR_INDEX, - BeaconStateFields.NEXT_WITHDRAWAL_VALIDATOR_INDEX, - () -> SszPrimitiveSchemas.UINT64_SCHEMA); - - final SszField historicalSummariesField = - new SszField( - HISTORICAL_SUMMARIES_INDEX, - BeaconStateFields.HISTORICAL_SUMMARIES, - () -> - SszListSchema.create( - historicalSummarySchema, specConfig.getHistoricalRootsLimit())); + public static List getUniqueFields( + final SpecConfig specConfig, final SchemaRegistry schemaRegistry) { + final List newFields = + List.of( + new SszField( + NEXT_WITHDRAWAL_INDEX_FIELD_INDEX, + BeaconStateFields.NEXT_WITHDRAWAL_INDEX, + () -> SszPrimitiveSchemas.UINT64_SCHEMA), + new SszField( + NEXT_WITHDRAWAL_VALIDATOR_INDEX_FIELD_INDEX, + BeaconStateFields.NEXT_WITHDRAWAL_VALIDATOR_INDEX, + () -> SszPrimitiveSchemas.UINT64_SCHEMA), + new SszField( + HISTORICAL_SUMMARIES_FIELD_INDEX, + BeaconStateFields.HISTORICAL_SUMMARIES, + () -> schemaRegistry.get(HISTORICAL_SUMMARIES_SCHEMA))); + return Stream.concat( - BeaconStateSchemaAltair.getUniqueFields(specConfig).stream(), - Stream.of( - latestExecutionPayloadHeaderField, - nextWithdrawalIndexField, - nextWithdrawalValidatorIndexField, - historicalSummariesField)) + BeaconStateSchemaBellatrix.getUniqueFields(specConfig, schemaRegistry).stream(), + newFields.stream()) .toList(); } @@ -121,8 +108,9 @@ public MutableBeaconStateCapella createBuilder() { return new MutableBeaconStateCapellaImpl(createEmptyBeaconStateImpl(), true); } - public static BeaconStateSchemaCapella create(final SpecConfig specConfig) { - return new BeaconStateSchemaCapella(specConfig); + public static BeaconStateSchemaCapella create( + final SpecConfig specConfig, final SchemaRegistry schemaRegistry) { + return new BeaconStateSchemaCapella(specConfig, schemaRegistry); } public static BeaconStateSchemaCapella required(final BeaconStateSchema schema) { @@ -143,7 +131,7 @@ private BeaconStateCapellaImpl createEmptyBeaconStateImpl() { } @Override - public BeaconStateCapella createFromBackingNode(TreeNode node) { + public BeaconStateCapella createFromBackingNode(final TreeNode node) { return new BeaconStateCapellaImpl(this, node); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/capella/MutableBeaconStateCapella.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/capella/MutableBeaconStateCapella.java index b45d91a994e..1c36a0c84e8 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/capella/MutableBeaconStateCapella.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/capella/MutableBeaconStateCapella.java @@ -36,12 +36,12 @@ static MutableBeaconStateCapella required(final MutableBeaconState state) { @Override BeaconStateCapella commitChanges(); - default void setNextWithdrawalIndex(UInt64 nextWithdrawalIndex) { + default void setNextWithdrawalIndex(final UInt64 nextWithdrawalIndex) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.NEXT_WITHDRAWAL_INDEX); set(fieldIndex, SszUInt64.of(nextWithdrawalIndex)); } - default void setNextWithdrawalValidatorIndex(UInt64 nextWithdrawalValidatorIndex) { + default void setNextWithdrawalValidatorIndex(final UInt64 nextWithdrawalValidatorIndex) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.NEXT_WITHDRAWAL_VALIDATOR_INDEX); set(fieldIndex, SszUInt64.of(nextWithdrawalValidatorIndex)); @@ -53,7 +53,7 @@ default SszMutableList getHistoricalSummaries() { return getAnyByRef(fieldIndex); } - default void setHistoricalSummaries(SszList historicalsummaries) { + default void setHistoricalSummaries(final SszList historicalsummaries) { final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.HISTORICAL_SUMMARIES); set(fieldIndex, historicalsummaries); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/capella/MutableBeaconStateCapellaImpl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/capella/MutableBeaconStateCapellaImpl.java index b61a10c114f..ccb05936356 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/capella/MutableBeaconStateCapellaImpl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/capella/MutableBeaconStateCapellaImpl.java @@ -27,11 +27,12 @@ public class MutableBeaconStateCapellaImpl extends AbstractMutableBeaconState implements MutableBeaconStateCapella, BeaconStateCache, ValidatorStatsAltair { - MutableBeaconStateCapellaImpl(BeaconStateCapellaImpl backingImmutableView) { + MutableBeaconStateCapellaImpl(final BeaconStateCapellaImpl backingImmutableView) { super(backingImmutableView); } - MutableBeaconStateCapellaImpl(BeaconStateCapellaImpl backingImmutableView, boolean builder) { + MutableBeaconStateCapellaImpl( + final BeaconStateCapellaImpl backingImmutableView, final boolean builder) { super(backingImmutableView, builder); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/deneb/BeaconStateDeneb.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/deneb/BeaconStateDeneb.java index ea135073b5f..e5bfb81ab42 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/deneb/BeaconStateDeneb.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/deneb/BeaconStateDeneb.java @@ -29,7 +29,7 @@ static BeaconStateDeneb required(final BeaconState state) { } static void describeCustomDenebFields( - MoreObjects.ToStringHelper stringBuilder, BeaconStateCapella state) { + final MoreObjects.ToStringHelper stringBuilder, final BeaconStateCapella state) { BeaconStateCapella.describeCustomCapellaFields(stringBuilder, state); // no new fields } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/deneb/BeaconStateSchemaDeneb.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/deneb/BeaconStateSchemaDeneb.java index c1b15a97450..d4376fb5178 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/deneb/BeaconStateSchemaDeneb.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/deneb/BeaconStateSchemaDeneb.java @@ -14,73 +14,36 @@ package tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.deneb; import static com.google.common.base.Preconditions.checkArgument; -import static tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.bellatrix.BeaconStateSchemaBellatrix.LATEST_EXECUTION_PAYLOAD_HEADER_FIELD_INDEX; -import static tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.capella.BeaconStateSchemaCapella.HISTORICAL_SUMMARIES_INDEX; -import static tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.capella.BeaconStateSchemaCapella.NEXT_WITHDRAWAL_INDEX; -import static tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.capella.BeaconStateSchemaCapella.NEXT_WITHDRAWAL_VALIDATOR_INDEX; import com.google.common.annotations.VisibleForTesting; import java.util.List; -import java.util.stream.Stream; import tech.pegasys.teku.infrastructure.ssz.primitive.SszByte; import tech.pegasys.teku.infrastructure.ssz.schema.SszListSchema; -import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszPrimitiveListSchema; import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszUInt64ListSchema; import tech.pegasys.teku.infrastructure.ssz.sos.SszField; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; import tech.pegasys.teku.spec.config.SpecConfig; -import tech.pegasys.teku.spec.config.SpecConfigDeneb; import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadHeaderSchemaDeneb; import tech.pegasys.teku.spec.datastructures.state.SyncCommittee; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconStateSchema; import tech.pegasys.teku.spec.datastructures.state.beaconstate.common.AbstractBeaconStateSchema; import tech.pegasys.teku.spec.datastructures.state.beaconstate.common.BeaconStateFields; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.altair.BeaconStateSchemaAltair; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.capella.BeaconStateSchemaCapella; import tech.pegasys.teku.spec.datastructures.state.versions.capella.HistoricalSummary; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; public class BeaconStateSchemaDeneb extends AbstractBeaconStateSchema { @VisibleForTesting - BeaconStateSchemaDeneb(final SpecConfig specConfig) { - super("BeaconStateDeneb", getUniqueFields(specConfig), specConfig); + BeaconStateSchemaDeneb(final SpecConfig specConfig, final SchemaRegistry schemaRegistry) { + super("BeaconStateDeneb", getUniqueFields(specConfig, schemaRegistry), specConfig); } - private static List getUniqueFields(final SpecConfig specConfig) { - final HistoricalSummary.HistoricalSummarySchema historicalSummarySchema = - new HistoricalSummary.HistoricalSummarySchema(); - final SszField latestExecutionPayloadHeaderField = - new SszField( - LATEST_EXECUTION_PAYLOAD_HEADER_FIELD_INDEX, - BeaconStateFields.LATEST_EXECUTION_PAYLOAD_HEADER, - () -> new ExecutionPayloadHeaderSchemaDeneb(SpecConfigDeneb.required(specConfig))); - final SszField nextWithdrawalIndexField = - new SszField( - NEXT_WITHDRAWAL_INDEX, - BeaconStateFields.NEXT_WITHDRAWAL_INDEX, - () -> SszPrimitiveSchemas.UINT64_SCHEMA); - final SszField nextWithdrawalValidatorIndexField = - new SszField( - NEXT_WITHDRAWAL_VALIDATOR_INDEX, - BeaconStateFields.NEXT_WITHDRAWAL_VALIDATOR_INDEX, - () -> SszPrimitiveSchemas.UINT64_SCHEMA); - - final SszField historicalSummariesField = - new SszField( - HISTORICAL_SUMMARIES_INDEX, - BeaconStateFields.HISTORICAL_SUMMARIES, - () -> - SszListSchema.create( - historicalSummarySchema, specConfig.getHistoricalRootsLimit())); - return Stream.concat( - BeaconStateSchemaAltair.getUniqueFields(specConfig).stream(), - Stream.of( - latestExecutionPayloadHeaderField, - nextWithdrawalIndexField, - nextWithdrawalValidatorIndexField, - historicalSummariesField)) - .toList(); + public static List getUniqueFields( + final SpecConfig specConfig, final SchemaRegistry schemaRegistry) { + return BeaconStateSchemaCapella.getUniqueFields(specConfig, schemaRegistry).stream().toList(); } @SuppressWarnings("unchecked") @@ -115,8 +78,9 @@ public MutableBeaconStateDeneb createBuilder() { return new MutableBeaconStateDenebImpl(createEmptyBeaconStateImpl(), true); } - public static BeaconStateSchemaDeneb create(final SpecConfig specConfig) { - return new BeaconStateSchemaDeneb(specConfig); + public static BeaconStateSchemaDeneb create( + final SpecConfig specConfig, final SchemaRegistry schemaRegistry) { + return new BeaconStateSchemaDeneb(specConfig, schemaRegistry); } public static BeaconStateSchemaDeneb required(final BeaconStateSchema schema) { @@ -143,7 +107,7 @@ private BeaconStateDenebImpl createEmptyBeaconStateImpl() { } @Override - public BeaconStateDeneb createFromBackingNode(TreeNode node) { + public BeaconStateDeneb createFromBackingNode(final TreeNode node) { return new BeaconStateDenebImpl(this, node); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/eip7594/BeaconStateEip7594.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/eip7594/BeaconStateEip7594.java deleted file mode 100644 index 3a9389326ff..00000000000 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/eip7594/BeaconStateEip7594.java +++ /dev/null @@ -1,51 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2024 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.eip7594; - -import com.google.common.base.MoreObjects; -import java.util.Optional; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.deneb.BeaconStateDeneb; - -public interface BeaconStateEip7594 extends BeaconStateDeneb { - static BeaconStateEip7594 required(final BeaconState state) { - return state - .toVersionEip7594() - .orElseThrow( - () -> - new IllegalArgumentException( - "Expected an EIP7594 state but got: " + state.getClass().getSimpleName())); - } - - static void describeCustomEip7594Fields( - MoreObjects.ToStringHelper stringBuilder, BeaconStateDeneb state) { - BeaconStateDeneb.describeCustomDenebFields(stringBuilder, state); - } - - @Override - MutableBeaconStateEip7594 createWritableCopy(); - - default - BeaconStateEip7594 updatedEip7594( - final Mutator mutator) throws E1, E2, E3 { - MutableBeaconStateEip7594 writableCopy = createWritableCopy(); - mutator.mutate(writableCopy); - return writableCopy.commitChanges(); - } - - @Override - default Optional toVersionEip7594() { - return Optional.of(this); - } -} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/eip7594/BeaconStateSchemaEip7594.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/eip7594/BeaconStateSchemaEip7594.java deleted file mode 100644 index 771adc14cf7..00000000000 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/eip7594/BeaconStateSchemaEip7594.java +++ /dev/null @@ -1,150 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.eip7594; - -import static com.google.common.base.Preconditions.checkArgument; -import static tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.bellatrix.BeaconStateSchemaBellatrix.LATEST_EXECUTION_PAYLOAD_HEADER_FIELD_INDEX; -import static tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.capella.BeaconStateSchemaCapella.HISTORICAL_SUMMARIES_INDEX; -import static tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.capella.BeaconStateSchemaCapella.NEXT_WITHDRAWAL_INDEX; -import static tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.capella.BeaconStateSchemaCapella.NEXT_WITHDRAWAL_VALIDATOR_INDEX; - -import com.google.common.annotations.VisibleForTesting; -import java.util.List; -import java.util.stream.Stream; -import tech.pegasys.teku.infrastructure.ssz.primitive.SszByte; -import tech.pegasys.teku.infrastructure.ssz.schema.SszListSchema; -import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; -import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszPrimitiveListSchema; -import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszUInt64ListSchema; -import tech.pegasys.teku.infrastructure.ssz.sos.SszField; -import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; -import tech.pegasys.teku.spec.config.SpecConfig; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; -import tech.pegasys.teku.spec.datastructures.execution.versions.eip7594.ExecutionPayloadHeaderSchemaEip7594; -import tech.pegasys.teku.spec.datastructures.state.SyncCommittee; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconStateSchema; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.common.AbstractBeaconStateSchema; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.common.BeaconStateFields; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.altair.BeaconStateSchemaAltair; -import tech.pegasys.teku.spec.datastructures.state.versions.capella.HistoricalSummary; - -public class BeaconStateSchemaEip7594 - extends AbstractBeaconStateSchema { - - @VisibleForTesting - BeaconStateSchemaEip7594(final SpecConfig specConfig) { - super("BeaconStateEip7594", getUniqueFields(specConfig), specConfig); - } - - private static List getUniqueFields(final SpecConfig specConfig) { - final HistoricalSummary.HistoricalSummarySchema historicalSummarySchema = - new HistoricalSummary.HistoricalSummarySchema(); - final SpecConfigEip7594 specConfigEip7594 = SpecConfigEip7594.required(specConfig); - final SszField latestExecutionPayloadHeaderField = - new SszField( - LATEST_EXECUTION_PAYLOAD_HEADER_FIELD_INDEX, - BeaconStateFields.LATEST_EXECUTION_PAYLOAD_HEADER, - () -> new ExecutionPayloadHeaderSchemaEip7594(specConfigEip7594)); - final SszField nextWithdrawalIndexField = - new SszField( - NEXT_WITHDRAWAL_INDEX, - BeaconStateFields.NEXT_WITHDRAWAL_INDEX, - () -> SszPrimitiveSchemas.UINT64_SCHEMA); - final SszField nextWithdrawalValidatorIndexField = - new SszField( - NEXT_WITHDRAWAL_VALIDATOR_INDEX, - BeaconStateFields.NEXT_WITHDRAWAL_VALIDATOR_INDEX, - () -> SszPrimitiveSchemas.UINT64_SCHEMA); - - final SszField historicalSummariesField = - new SszField( - HISTORICAL_SUMMARIES_INDEX, - BeaconStateFields.HISTORICAL_SUMMARIES, - () -> - SszListSchema.create( - historicalSummarySchema, specConfig.getHistoricalRootsLimit())); - return Stream.concat( - BeaconStateSchemaAltair.getUniqueFields(specConfig).stream(), - Stream.of( - latestExecutionPayloadHeaderField, - nextWithdrawalIndexField, - nextWithdrawalValidatorIndexField, - historicalSummariesField)) - .toList(); - } - - @SuppressWarnings("unchecked") - public SszPrimitiveListSchema getPreviousEpochParticipationSchema() { - return (SszPrimitiveListSchema) - getChildSchema(getFieldIndex(BeaconStateFields.PREVIOUS_EPOCH_PARTICIPATION)); - } - - @SuppressWarnings("unchecked") - public SszPrimitiveListSchema getCurrentEpochParticipationSchema() { - return (SszPrimitiveListSchema) - getChildSchema(getFieldIndex(BeaconStateFields.CURRENT_EPOCH_PARTICIPATION)); - } - - public SszUInt64ListSchema getInactivityScoresSchema() { - return (SszUInt64ListSchema) - getChildSchema(getFieldIndex(BeaconStateFields.INACTIVITY_SCORES)); - } - - public SyncCommittee.SyncCommitteeSchema getCurrentSyncCommitteeSchema() { - return (SyncCommittee.SyncCommitteeSchema) - getChildSchema(getFieldIndex(BeaconStateFields.CURRENT_SYNC_COMMITTEE)); - } - - public ExecutionPayloadHeaderSchemaEip7594 getLastExecutionPayloadHeaderSchema() { - return (ExecutionPayloadHeaderSchemaEip7594) - getChildSchema(getFieldIndex(BeaconStateFields.LATEST_EXECUTION_PAYLOAD_HEADER)); - } - - @Override - public MutableBeaconStateEip7594 createBuilder() { - return new MutableBeaconStateEip7594Impl(createEmptyBeaconStateImpl(), true); - } - - public static BeaconStateSchemaEip7594 create(final SpecConfig specConfig) { - return new BeaconStateSchemaEip7594(specConfig); - } - - public static BeaconStateSchemaEip7594 required(final BeaconStateSchema schema) { - checkArgument( - schema instanceof BeaconStateSchemaEip7594, - "Expected a BeaconStateSchemaEip7594 but was %s", - schema.getClass()); - return (BeaconStateSchemaEip7594) schema; - } - - @SuppressWarnings("unchecked") - public SszListSchema getHistoricalSummariesSchema() { - return (SszListSchema) - getChildSchema(getFieldIndex(BeaconStateFields.HISTORICAL_SUMMARIES)); - } - - @Override - public BeaconStateEip7594 createEmpty() { - return createEmptyBeaconStateImpl(); - } - - private BeaconStateEip7594Impl createEmptyBeaconStateImpl() { - return new BeaconStateEip7594Impl(this); - } - - @Override - public BeaconStateEip7594Impl createFromBackingNode(TreeNode node) { - return new BeaconStateEip7594Impl(this, node); - } -} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/eip7594/MutableBeaconStateEip7594.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/eip7594/MutableBeaconStateEip7594.java deleted file mode 100644 index 7891fd2c829..00000000000 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/eip7594/MutableBeaconStateEip7594.java +++ /dev/null @@ -1,37 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2024 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.eip7594; - -import java.util.Optional; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.MutableBeaconState; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.deneb.MutableBeaconStateDeneb; - -public interface MutableBeaconStateEip7594 extends MutableBeaconStateDeneb, BeaconStateEip7594 { - static MutableBeaconStateEip7594 required(final MutableBeaconState state) { - return state - .toMutableVersionEip7594() - .orElseThrow( - () -> - new IllegalArgumentException( - "Expected an EIP7594 state but got: " + state.getClass().getSimpleName())); - } - - @Override - BeaconStateEip7594 commitChanges(); - - @Override - default Optional toMutableVersionEip7594() { - return Optional.of(this); - } -} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/electra/BeaconStateElectra.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/electra/BeaconStateElectra.java new file mode 100644 index 00000000000..164c45160a2 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/electra/BeaconStateElectra.java @@ -0,0 +1,131 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra; + +import static tech.pegasys.teku.spec.datastructures.state.beaconstate.common.BeaconStateFields.CONSOLIDATION_BALANCE_TO_CONSUME; +import static tech.pegasys.teku.spec.datastructures.state.beaconstate.common.BeaconStateFields.DEPOSIT_BALANCE_TO_CONSUME; +import static tech.pegasys.teku.spec.datastructures.state.beaconstate.common.BeaconStateFields.DEPOSIT_REQUESTS_START_INDEX; +import static tech.pegasys.teku.spec.datastructures.state.beaconstate.common.BeaconStateFields.EARLIEST_CONSOLIDATION_EPOCH; +import static tech.pegasys.teku.spec.datastructures.state.beaconstate.common.BeaconStateFields.EARLIEST_EXIT_EPOCH; +import static tech.pegasys.teku.spec.datastructures.state.beaconstate.common.BeaconStateFields.EXIT_BALANCE_TO_CONSUME; +import static tech.pegasys.teku.spec.datastructures.state.beaconstate.common.BeaconStateFields.PENDING_CONSOLIDATIONS; +import static tech.pegasys.teku.spec.datastructures.state.beaconstate.common.BeaconStateFields.PENDING_DEPOSITS; +import static tech.pegasys.teku.spec.datastructures.state.beaconstate.common.BeaconStateFields.PENDING_PARTIAL_WITHDRAWALS; + +import com.google.common.base.MoreObjects; +import java.util.Optional; +import tech.pegasys.teku.infrastructure.ssz.SszData; +import tech.pegasys.teku.infrastructure.ssz.SszList; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.deneb.BeaconStateDeneb; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingConsolidation; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingDeposit; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingPartialWithdrawal; + +public interface BeaconStateElectra extends BeaconStateDeneb { + static BeaconStateElectra required(final BeaconState state) { + return state + .toVersionElectra() + .orElseThrow( + () -> + new IllegalArgumentException( + "Expected an Electra state but got: " + state.getClass().getSimpleName())); + } + + private static void addItems( + final MoreObjects.ToStringHelper stringBuilder, + final String keyPrefix, + final SszList items) { + for (int i = 0; i < items.size(); i++) { + stringBuilder.add(keyPrefix + "[" + i + "]", items.get(i)); + } + } + + static void describeCustomElectraFields( + final MoreObjects.ToStringHelper stringBuilder, final BeaconStateElectra state) { + BeaconStateDeneb.describeCustomDenebFields(stringBuilder, state); + stringBuilder.add("deposit_requests_start_index", state.getDepositRequestsStartIndex()); + stringBuilder.add("deposit_balance_to_consume", state.getDepositBalanceToConsume()); + stringBuilder.add("exit_balance_to_consume", state.getExitBalanceToConsume()); + stringBuilder.add("earliest_exit_epoch", state.getEarliestExitEpoch()); + stringBuilder.add("consolidation_balance_to_consume", state.getConsolidationBalanceToConsume()); + stringBuilder.add("earliest_consolidation_epoch", state.getEarliestConsolidationEpoch()); + addItems(stringBuilder, "pending_deposits", state.getPendingDeposits()); + addItems(stringBuilder, "pending_partial_withdrawals", state.getPendingPartialWithdrawals()); + addItems(stringBuilder, "pending_consolidations", state.getPendingConsolidations()); + } + + @Override + MutableBeaconStateElectra createWritableCopy(); + + default + BeaconStateElectra updatedElectra( + final Mutator mutator) throws E1, E2, E3 { + MutableBeaconStateElectra writableCopy = createWritableCopy(); + mutator.mutate(writableCopy); + return writableCopy.commitChanges(); + } + + @Override + default Optional toVersionElectra() { + return Optional.of(this); + } + + default UInt64 getDepositRequestsStartIndex() { + final int index = getSchema().getFieldIndex(DEPOSIT_REQUESTS_START_INDEX); + return ((SszUInt64) get(index)).get(); + } + + default UInt64 getDepositBalanceToConsume() { + final int index = getSchema().getFieldIndex(DEPOSIT_BALANCE_TO_CONSUME); + return ((SszUInt64) get(index)).get(); + } + + default UInt64 getExitBalanceToConsume() { + final int index = getSchema().getFieldIndex(EXIT_BALANCE_TO_CONSUME); + return ((SszUInt64) get(index)).get(); + } + + default UInt64 getEarliestExitEpoch() { + final int index = getSchema().getFieldIndex(EARLIEST_EXIT_EPOCH); + return ((SszUInt64) get(index)).get(); + } + + default UInt64 getConsolidationBalanceToConsume() { + final int index = getSchema().getFieldIndex(CONSOLIDATION_BALANCE_TO_CONSUME); + return ((SszUInt64) get(index)).get(); + } + + default UInt64 getEarliestConsolidationEpoch() { + final int index = getSchema().getFieldIndex(EARLIEST_CONSOLIDATION_EPOCH); + return ((SszUInt64) get(index)).get(); + } + + default SszList getPendingDeposits() { + final int index = getSchema().getFieldIndex(PENDING_DEPOSITS); + return getAny(index); + } + + default SszList getPendingPartialWithdrawals() { + final int index = getSchema().getFieldIndex(PENDING_PARTIAL_WITHDRAWALS); + return getAny(index); + } + + default SszList getPendingConsolidations() { + final int index = getSchema().getFieldIndex(PENDING_CONSOLIDATIONS); + return getAny(index); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/eip7594/BeaconStateEip7594Impl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/electra/BeaconStateElectraImpl.java similarity index 77% rename from ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/eip7594/BeaconStateEip7594Impl.java rename to ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/electra/BeaconStateElectraImpl.java index 98369e39027..1d1263e31e1 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/eip7594/BeaconStateEip7594Impl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/electra/BeaconStateElectraImpl.java @@ -11,7 +11,7 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.eip7594; +package tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra; import com.google.common.base.MoreObjects; import tech.pegasys.teku.infrastructure.ssz.SszContainer; @@ -27,15 +27,15 @@ import tech.pegasys.teku.spec.datastructures.state.beaconstate.common.TransitionCaches; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.altair.ValidatorStatsAltair; -public class BeaconStateEip7594Impl extends AbstractBeaconState - implements BeaconStateEip7594, BeaconStateCache, ValidatorStatsAltair { +public class BeaconStateElectraImpl extends AbstractBeaconState + implements BeaconStateElectra, BeaconStateCache, ValidatorStatsAltair { - BeaconStateEip7594Impl( - final BeaconStateSchema schema) { + BeaconStateElectraImpl( + final BeaconStateSchema schema) { super(schema); } - BeaconStateEip7594Impl( + BeaconStateElectraImpl( final SszCompositeSchema type, final TreeNode backingNode, final IntCache cache, @@ -44,23 +44,23 @@ public class BeaconStateEip7594Impl extends AbstractBeaconState type, final TreeNode backingNode) { super(type, backingNode); } @Override - public BeaconStateSchemaEip7594 getBeaconStateSchema() { - return (BeaconStateSchemaEip7594) getSchema(); + public BeaconStateSchemaElectra getBeaconStateSchema() { + return (BeaconStateSchemaElectra) getSchema(); } @Override - public MutableBeaconStateEip7594 createWritableCopy() { - return new MutableBeaconStateEip7594Impl(this); + public MutableBeaconStateElectra createWritableCopy() { + return new MutableBeaconStateElectraImpl(this); } @Override protected void describeCustomFields(final MoreObjects.ToStringHelper stringBuilder) { - BeaconStateEip7594.describeCustomEip7594Fields(stringBuilder, this); + BeaconStateElectra.describeCustomElectraFields(stringBuilder, this); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/electra/BeaconStateSchemaElectra.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/electra/BeaconStateSchemaElectra.java new file mode 100644 index 00000000000..319acd1fcfa --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/electra/BeaconStateSchemaElectra.java @@ -0,0 +1,190 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra; + +import static com.google.common.base.Preconditions.checkArgument; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.PENDING_CONSOLIDATIONS_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.PENDING_DEPOSITS_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.PENDING_PARTIAL_WITHDRAWALS_SCHEMA; + +import com.google.common.annotations.VisibleForTesting; +import java.util.List; +import java.util.stream.Stream; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszByte; +import tech.pegasys.teku.infrastructure.ssz.schema.SszListSchema; +import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; +import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszPrimitiveListSchema; +import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszUInt64ListSchema; +import tech.pegasys.teku.infrastructure.ssz.sos.SszField; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadHeaderSchemaDeneb; +import tech.pegasys.teku.spec.datastructures.state.SyncCommittee; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconStateSchema; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.common.AbstractBeaconStateSchema; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.common.BeaconStateFields; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.deneb.BeaconStateSchemaDeneb; +import tech.pegasys.teku.spec.datastructures.state.versions.capella.HistoricalSummary; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingConsolidation; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingDeposit; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingPartialWithdrawal; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; + +public class BeaconStateSchemaElectra + extends AbstractBeaconStateSchema { + public static final int DEPOSIT_REQUESTS_START_INDEX_FIELD_INDEX = 28; + public static final int DEPOSIT_BALANCE_TO_CONSUME_FIELD_INDEX = 29; + public static final int EXIT_BALANCE_TO_CONSUME_FIELD_INDEX = 30; + public static final int EARLIEST_EXIT_EPOCH_FIELD_INDEX = 31; + public static final int CONSOLIDATION_BALANCE_TO_CONSUME_FIELD_INDEX = 32; + public static final int EARLIEST_CONSOLIDATION_EPOCH_FIELD_INDEX = 33; + public static final int PENDING_DEPOSITS_FIELD_INDEX = 34; + public static final int PENDING_PARTIAL_WITHDRAWALS_FIELD_INDEX = 35; + public static final int PENDING_CONSOLIDATIONS_FIELD_INDEX = 36; + + @VisibleForTesting + BeaconStateSchemaElectra(final SpecConfig specConfig, final SchemaRegistry schemaRegistry) { + super("BeaconStateElectra", getUniqueFields(specConfig, schemaRegistry), specConfig); + } + + private static List getUniqueFields( + final SpecConfig specConfig, final SchemaRegistry schemaRegistry) { + final List newFields = + List.of( + new SszField( + DEPOSIT_REQUESTS_START_INDEX_FIELD_INDEX, + BeaconStateFields.DEPOSIT_REQUESTS_START_INDEX, + () -> SszPrimitiveSchemas.UINT64_SCHEMA), + new SszField( + DEPOSIT_BALANCE_TO_CONSUME_FIELD_INDEX, + BeaconStateFields.DEPOSIT_BALANCE_TO_CONSUME, + () -> SszPrimitiveSchemas.UINT64_SCHEMA), + new SszField( + EXIT_BALANCE_TO_CONSUME_FIELD_INDEX, + BeaconStateFields.EXIT_BALANCE_TO_CONSUME, + () -> SszPrimitiveSchemas.UINT64_SCHEMA), + new SszField( + EARLIEST_EXIT_EPOCH_FIELD_INDEX, + BeaconStateFields.EARLIEST_EXIT_EPOCH, + () -> SszPrimitiveSchemas.UINT64_SCHEMA), + new SszField( + CONSOLIDATION_BALANCE_TO_CONSUME_FIELD_INDEX, + BeaconStateFields.CONSOLIDATION_BALANCE_TO_CONSUME, + () -> SszPrimitiveSchemas.UINT64_SCHEMA), + new SszField( + EARLIEST_CONSOLIDATION_EPOCH_FIELD_INDEX, + BeaconStateFields.EARLIEST_CONSOLIDATION_EPOCH, + () -> SszPrimitiveSchemas.UINT64_SCHEMA), + new SszField( + PENDING_DEPOSITS_FIELD_INDEX, + BeaconStateFields.PENDING_DEPOSITS, + () -> schemaRegistry.get(PENDING_DEPOSITS_SCHEMA)), + new SszField( + PENDING_PARTIAL_WITHDRAWALS_FIELD_INDEX, + BeaconStateFields.PENDING_PARTIAL_WITHDRAWALS, + () -> schemaRegistry.get(PENDING_PARTIAL_WITHDRAWALS_SCHEMA)), + new SszField( + PENDING_CONSOLIDATIONS_FIELD_INDEX, + BeaconStateFields.PENDING_CONSOLIDATIONS, + () -> schemaRegistry.get(PENDING_CONSOLIDATIONS_SCHEMA))); + + return Stream.concat( + BeaconStateSchemaDeneb.getUniqueFields(specConfig, schemaRegistry).stream(), + newFields.stream()) + .toList(); + } + + @SuppressWarnings("unchecked") + public SszPrimitiveListSchema getPreviousEpochParticipationSchema() { + return (SszPrimitiveListSchema) + getChildSchema(getFieldIndex(BeaconStateFields.PREVIOUS_EPOCH_PARTICIPATION)); + } + + @SuppressWarnings("unchecked") + public SszPrimitiveListSchema getCurrentEpochParticipationSchema() { + return (SszPrimitiveListSchema) + getChildSchema(getFieldIndex(BeaconStateFields.CURRENT_EPOCH_PARTICIPATION)); + } + + public SszUInt64ListSchema getInactivityScoresSchema() { + return (SszUInt64ListSchema) + getChildSchema(getFieldIndex(BeaconStateFields.INACTIVITY_SCORES)); + } + + public SyncCommittee.SyncCommitteeSchema getCurrentSyncCommitteeSchema() { + return (SyncCommittee.SyncCommitteeSchema) + getChildSchema(getFieldIndex(BeaconStateFields.CURRENT_SYNC_COMMITTEE)); + } + + public ExecutionPayloadHeaderSchemaDeneb getLastExecutionPayloadHeaderSchema() { + return (ExecutionPayloadHeaderSchemaDeneb) + getChildSchema(getFieldIndex(BeaconStateFields.LATEST_EXECUTION_PAYLOAD_HEADER)); + } + + @Override + public MutableBeaconStateElectra createBuilder() { + return new MutableBeaconStateElectraImpl(createEmptyBeaconStateImpl(), true); + } + + public static BeaconStateSchemaElectra create( + final SpecConfig specConfig, final SchemaRegistry schemaRegistry) { + return new BeaconStateSchemaElectra(specConfig, schemaRegistry); + } + + public static BeaconStateSchemaElectra required(final BeaconStateSchema schema) { + checkArgument( + schema instanceof BeaconStateSchemaElectra, + "Expected a BeaconStateSchemaElectra but was %s", + schema.getClass()); + return (BeaconStateSchemaElectra) schema; + } + + @SuppressWarnings("unchecked") + public SszListSchema getHistoricalSummariesSchema() { + return (SszListSchema) + getChildSchema(getFieldIndex(BeaconStateFields.HISTORICAL_SUMMARIES)); + } + + @Override + public BeaconStateElectra createEmpty() { + return createEmptyBeaconStateImpl(); + } + + private BeaconStateElectraImpl createEmptyBeaconStateImpl() { + return new BeaconStateElectraImpl(this); + } + + @Override + public BeaconStateElectraImpl createFromBackingNode(final TreeNode node) { + return new BeaconStateElectraImpl(this, node); + } + + @SuppressWarnings("unchecked") + public SszListSchema getPendingDepositsSchema() { + return (SszListSchema) + getChildSchema(getFieldIndex(BeaconStateFields.PENDING_DEPOSITS)); + } + + @SuppressWarnings("unchecked") + public SszListSchema getPendingPartialWithdrawalsSchema() { + return (SszListSchema) + getChildSchema(getFieldIndex(BeaconStateFields.PENDING_PARTIAL_WITHDRAWALS)); + } + + @SuppressWarnings("unchecked") + public SszListSchema getPendingConsolidationsSchema() { + return (SszListSchema) + getChildSchema(getFieldIndex(BeaconStateFields.PENDING_CONSOLIDATIONS)); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/electra/MutableBeaconStateElectra.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/electra/MutableBeaconStateElectra.java new file mode 100644 index 00000000000..5dd99414be0 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/electra/MutableBeaconStateElectra.java @@ -0,0 +1,116 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra; + +import static tech.pegasys.teku.spec.datastructures.state.beaconstate.common.BeaconStateFields.PENDING_CONSOLIDATIONS; +import static tech.pegasys.teku.spec.datastructures.state.beaconstate.common.BeaconStateFields.PENDING_DEPOSITS; +import static tech.pegasys.teku.spec.datastructures.state.beaconstate.common.BeaconStateFields.PENDING_PARTIAL_WITHDRAWALS; + +import java.util.Optional; +import tech.pegasys.teku.infrastructure.ssz.SszList; +import tech.pegasys.teku.infrastructure.ssz.SszMutableList; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.MutableBeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.common.BeaconStateFields; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.deneb.MutableBeaconStateDeneb; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingConsolidation; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingDeposit; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingPartialWithdrawal; + +public interface MutableBeaconStateElectra extends MutableBeaconStateDeneb, BeaconStateElectra { + static MutableBeaconStateElectra required(final MutableBeaconState state) { + return state + .toMutableVersionElectra() + .orElseThrow( + () -> + new IllegalArgumentException( + "Expected an Electra state but got: " + state.getClass().getSimpleName())); + } + + @Override + BeaconStateElectra commitChanges(); + + @Override + default Optional toMutableVersionElectra() { + return Optional.of(this); + } + + default void setDepositRequestsStartIndex(final UInt64 depositRequestsStartIndex) { + final int fieldIndex = + getSchema().getFieldIndex(BeaconStateFields.DEPOSIT_REQUESTS_START_INDEX); + set(fieldIndex, SszUInt64.of(depositRequestsStartIndex)); + } + + default void setDepositBalanceToConsume(final UInt64 depositBalanceToConsume) { + final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.DEPOSIT_BALANCE_TO_CONSUME); + set(fieldIndex, SszUInt64.of(depositBalanceToConsume)); + } + + default void setExitBalanceToConsume(final UInt64 exitBalanceToConsume) { + final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.EXIT_BALANCE_TO_CONSUME); + set(fieldIndex, SszUInt64.of(exitBalanceToConsume)); + } + + default void setEarliestExitEpoch(final UInt64 earliestExitEpoch) { + final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.EARLIEST_EXIT_EPOCH); + set(fieldIndex, SszUInt64.of(earliestExitEpoch)); + } + + default void setConsolidationBalanceToConsume(final UInt64 consolidationBalanceToConsume) { + final int fieldIndex = + getSchema().getFieldIndex(BeaconStateFields.CONSOLIDATION_BALANCE_TO_CONSUME); + set(fieldIndex, SszUInt64.of(consolidationBalanceToConsume)); + } + + default void setEarliestConsolidationEpoch(final UInt64 earliestConsolidationEpoch) { + final int fieldIndex = + getSchema().getFieldIndex(BeaconStateFields.EARLIEST_CONSOLIDATION_EPOCH); + set(fieldIndex, SszUInt64.of(earliestConsolidationEpoch)); + } + + default void setPendingDeposits(final SszList pendingDeposits) { + final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.PENDING_DEPOSITS); + set(fieldIndex, pendingDeposits); + } + + @Override + default SszMutableList getPendingDeposits() { + final int index = getSchema().getFieldIndex(PENDING_DEPOSITS); + return getAnyByRef(index); + } + + default void setPendingPartialWithdrawals( + final SszList pendingPartialWithdrawals) { + final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.PENDING_PARTIAL_WITHDRAWALS); + set(fieldIndex, pendingPartialWithdrawals); + } + + @Override + default SszMutableList getPendingPartialWithdrawals() { + final int index = getSchema().getFieldIndex(PENDING_PARTIAL_WITHDRAWALS); + return getAnyByRef(index); + } + + default void setPendingConsolidations(final SszList pendingConsolidations) { + final int fieldIndex = getSchema().getFieldIndex(BeaconStateFields.PENDING_CONSOLIDATIONS); + set(fieldIndex, pendingConsolidations); + } + + @Override + default SszMutableList getPendingConsolidations() { + final int index = getSchema().getFieldIndex(PENDING_CONSOLIDATIONS); + return getAnyByRef(index); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/eip7594/MutableBeaconStateEip7594Impl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/electra/MutableBeaconStateElectraImpl.java similarity index 71% rename from ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/eip7594/MutableBeaconStateEip7594Impl.java rename to ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/electra/MutableBeaconStateElectraImpl.java index 73a2e702c37..79ebe2f6e43 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/eip7594/MutableBeaconStateEip7594Impl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/electra/MutableBeaconStateElectraImpl.java @@ -11,7 +11,7 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.eip7594; +package tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra; import com.google.common.base.MoreObjects; import tech.pegasys.teku.infrastructure.ssz.SszData; @@ -23,41 +23,41 @@ import tech.pegasys.teku.spec.datastructures.state.beaconstate.common.TransitionCaches; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.altair.ValidatorStatsAltair; -public class MutableBeaconStateEip7594Impl - extends AbstractMutableBeaconState - implements MutableBeaconStateEip7594, BeaconStateCache, ValidatorStatsAltair { +public class MutableBeaconStateElectraImpl + extends AbstractMutableBeaconState + implements MutableBeaconStateElectra, BeaconStateCache, ValidatorStatsAltair { - MutableBeaconStateEip7594Impl(final BeaconStateEip7594Impl backingImmutableView) { + MutableBeaconStateElectraImpl(final BeaconStateElectraImpl backingImmutableView) { super(backingImmutableView); } - MutableBeaconStateEip7594Impl( - final BeaconStateEip7594Impl backingImmutableView, final boolean builder) { + MutableBeaconStateElectraImpl( + final BeaconStateElectraImpl backingImmutableView, final boolean builder) { super(backingImmutableView, builder); } @Override - protected BeaconStateEip7594Impl createImmutableBeaconState( + protected BeaconStateElectraImpl createImmutableBeaconState( final TreeNode backingNode, final IntCache viewCache, final TransitionCaches transitionCaches, final SlotCaches slotCaches) { - return new BeaconStateEip7594Impl( + return new BeaconStateElectraImpl( getSchema(), backingNode, viewCache, transitionCaches, slotCaches); } @Override protected void addCustomFields(final MoreObjects.ToStringHelper stringBuilder) { - BeaconStateEip7594.describeCustomEip7594Fields(stringBuilder, this); + BeaconStateElectra.describeCustomElectraFields(stringBuilder, this); } @Override - public BeaconStateEip7594 commitChanges() { - return (BeaconStateEip7594) super.commitChanges(); + public BeaconStateElectra commitChanges() { + return (BeaconStateElectra) super.commitChanges(); } @Override - public MutableBeaconStateEip7594 createWritableCopy() { - return (MutableBeaconStateEip7594) super.createWritableCopy(); + public MutableBeaconStateElectra createWritableCopy() { + return (MutableBeaconStateElectra) super.createWritableCopy(); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/phase0/BeaconStatePhase0Impl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/phase0/BeaconStatePhase0Impl.java index 9fa62ce6954..13d463355fa 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/phase0/BeaconStatePhase0Impl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/phase0/BeaconStatePhase0Impl.java @@ -35,16 +35,16 @@ class BeaconStatePhase0Impl extends AbstractBeaconState type, - TreeNode backingNode, - IntCache cache, - TransitionCaches transitionCaches, - SlotCaches slotCaches) { + final SszCompositeSchema type, + final TreeNode backingNode, + final IntCache cache, + final TransitionCaches transitionCaches, + final SlotCaches slotCaches) { super(type, backingNode, cache, transitionCaches, slotCaches); } BeaconStatePhase0Impl( - AbstractSszContainerSchema type, TreeNode backingNode) { + final AbstractSszContainerSchema type, final TreeNode backingNode) { super(type, backingNode); } @@ -55,7 +55,7 @@ public BeaconStateSchemaPhase0 getBeaconStateSchema() { @Override public - BeaconStatePhase0 updatedPhase0(Mutator mutator) + BeaconStatePhase0 updatedPhase0(final Mutator mutator) throws E1, E2, E3 { MutableBeaconStatePhase0 writableCopy = createWritableCopy(); mutator.mutate(writableCopy); @@ -68,11 +68,12 @@ public MutableBeaconStatePhase0 createWritableCopy() { } @Override - protected void describeCustomFields(ToStringHelper stringBuilder) { + protected void describeCustomFields(final ToStringHelper stringBuilder) { describeCustomFields(stringBuilder, this); } - static void describeCustomFields(ToStringHelper stringBuilder, final BeaconStatePhase0 state) { + static void describeCustomFields( + final ToStringHelper stringBuilder, final BeaconStatePhase0 state) { stringBuilder .add("previous_epoch_attestations", state.getPreviousEpochAttestations()) .add("current_epoch_attestations", state.getCurrentEpochAttestations()); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/phase0/BeaconStateSchemaPhase0.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/phase0/BeaconStateSchemaPhase0.java index e035237d392..014da2c9a76 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/phase0/BeaconStateSchemaPhase0.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/phase0/BeaconStateSchemaPhase0.java @@ -30,6 +30,8 @@ public class BeaconStateSchemaPhase0 extends AbstractBeaconStateSchema { + public static final int PREVIOUS_EPOCH_PARTICIPATION_FIELD_INDEX = 15; + public static final int CURRENT_EPOCH_PARTICIPATION_FIELD_INDEX = 16; @VisibleForTesting BeaconStateSchemaPhase0(final SpecConfig specConfig) { @@ -48,12 +50,13 @@ public static BeaconStateSchemaPhase0 required(final SszSchema getUniqueFields(final SpecConfig specConfig) { + public static List getUniqueFields(final SpecConfig specConfig) { final PendingAttestationSchema pendingAttestationSchema = new PendingAttestationSchema(specConfig); + final SszField previousEpochAttestationsField = new SszField( - 15, + PREVIOUS_EPOCH_PARTICIPATION_FIELD_INDEX, BeaconStateFields.PREVIOUS_EPOCH_ATTESTATIONS, () -> SszListSchema.create( @@ -61,7 +64,7 @@ private static List getUniqueFields(final SpecConfig specConfig) { (long) specConfig.getMaxAttestations() * specConfig.getSlotsPerEpoch())); final SszField currentEpochAttestationsField = new SszField( - 16, + CURRENT_EPOCH_PARTICIPATION_FIELD_INDEX, BeaconStateFields.CURRENT_EPOCH_ATTESTATIONS, () -> SszListSchema.create( @@ -88,7 +91,7 @@ public PendingAttestationSchema getPendingAttestationSchema() { } @Override - public BeaconStatePhase0 createFromBackingNode(TreeNode node) { + public BeaconStatePhase0 createFromBackingNode(final TreeNode node) { return new BeaconStatePhase0Impl(this, node); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/phase0/MutableBeaconStatePhase0Impl.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/phase0/MutableBeaconStatePhase0Impl.java index 2239cded74c..8ec71f3b779 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/phase0/MutableBeaconStatePhase0Impl.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/phase0/MutableBeaconStatePhase0Impl.java @@ -27,11 +27,12 @@ class MutableBeaconStatePhase0Impl extends AbstractMutableBeaconState implements MutableBeaconStatePhase0, BeaconStateCache, ValidatorStatsPhase0 { - MutableBeaconStatePhase0Impl(BeaconStatePhase0Impl backingImmutableView) { + MutableBeaconStatePhase0Impl(final BeaconStatePhase0Impl backingImmutableView) { super(backingImmutableView); } - MutableBeaconStatePhase0Impl(BeaconStatePhase0Impl backingImmutableView, boolean builder) { + MutableBeaconStatePhase0Impl( + final BeaconStatePhase0Impl backingImmutableView, final boolean builder) { super(backingImmutableView, builder); } @@ -42,10 +43,10 @@ public BeaconStateSchemaPhase0 getBeaconStateSchema() { @Override protected BeaconStatePhase0Impl createImmutableBeaconState( - TreeNode backingNode, - IntCache viewCache, - TransitionCaches transitionCaches, - SlotCaches slotCaches) { + final TreeNode backingNode, + final IntCache viewCache, + final TransitionCaches transitionCaches, + final SlotCaches slotCaches) { return new BeaconStatePhase0Impl( getSchema(), backingNode, viewCache, transitionCaches, slotCaches); } @@ -57,19 +58,19 @@ public BeaconStatePhase0 commitChanges() { @Override public BeaconState updated( - Mutator mutator) { + final Mutator mutator) { throw new UnsupportedOperationException(); } @Override public - BeaconStatePhase0 updatedPhase0(Mutator mutator) + BeaconStatePhase0 updatedPhase0(final Mutator mutator) throws E1, E2, E3 { throw new UnsupportedOperationException(); } @Override - protected void addCustomFields(ToStringHelper stringBuilder) { + protected void addCustomFields(final ToStringHelper stringBuilder) { BeaconStatePhase0Impl.describeCustomFields(stringBuilder, this); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/versions/capella/HistoricalSummary.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/versions/capella/HistoricalSummary.java index e367f051843..d1dfb2f6fab 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/versions/capella/HistoricalSummary.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/versions/capella/HistoricalSummary.java @@ -31,11 +31,12 @@ public HistoricalSummarySchema() { } @Override - public HistoricalSummary createFromBackingNode(TreeNode node) { + public HistoricalSummary createFromBackingNode(final TreeNode node) { return new HistoricalSummary(this, node); } - public HistoricalSummary create(SszBytes32 blockSummaryRoot, SszBytes32 stateSummaryRoot) { + public HistoricalSummary create( + final SszBytes32 blockSummaryRoot, final SszBytes32 stateSummaryRoot) { return new HistoricalSummary(this, blockSummaryRoot, stateSummaryRoot); } @@ -48,12 +49,14 @@ public SszBytes32 getStateSummaryRootSchema() { } } - private HistoricalSummary(HistoricalSummarySchema type, TreeNode backingNode) { + private HistoricalSummary(final HistoricalSummarySchema type, final TreeNode backingNode) { super(type, backingNode); } private HistoricalSummary( - HistoricalSummarySchema type, SszBytes32 blockSummaryRoot, SszBytes32 stateSummaryRoot) { + final HistoricalSummarySchema type, + final SszBytes32 blockSummaryRoot, + final SszBytes32 stateSummaryRoot) { super(type, blockSummaryRoot, stateSummaryRoot); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/versions/electra/PendingConsolidation.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/versions/electra/PendingConsolidation.java new file mode 100644 index 00000000000..77d53c0cfb7 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/versions/electra/PendingConsolidation.java @@ -0,0 +1,65 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.state.versions.electra; + +import tech.pegasys.teku.infrastructure.ssz.containers.Container2; +import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema2; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; +import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; + +public class PendingConsolidation extends Container2 { + protected PendingConsolidation( + final ContainerSchema2 schema) { + super(schema); + } + + public PendingConsolidation( + final PendingConsolidationSchema pendingConsolidationSchema, + final SszUInt64 sourceIndex, + final SszUInt64 targetIndex) { + super(pendingConsolidationSchema, sourceIndex, targetIndex); + } + + public static class PendingConsolidationSchema + extends ContainerSchema2 { + public PendingConsolidationSchema() { + super( + "PendingConsolidation", + namedSchema("source_index", SszPrimitiveSchemas.UINT64_SCHEMA), + namedSchema("target_index", SszPrimitiveSchemas.UINT64_SCHEMA)); + } + + @Override + public PendingConsolidation createFromBackingNode(final TreeNode node) { + return new PendingConsolidation(this, node); + } + + public PendingConsolidation create(final SszUInt64 sourceIndex, final SszUInt64 targetIndex) { + return new PendingConsolidation(this, sourceIndex, targetIndex); + } + } + + private PendingConsolidation(final PendingConsolidationSchema type, final TreeNode backingNode) { + super(type, backingNode); + } + + public int getSourceIndex() { + return ((SszUInt64) get(0)).get().intValue(); + } + + public int getTargetIndex() { + return ((SszUInt64) get(1)).get().intValue(); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/versions/electra/PendingDeposit.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/versions/electra/PendingDeposit.java new file mode 100644 index 00000000000..69d11d07f42 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/versions/electra/PendingDeposit.java @@ -0,0 +1,117 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.state.versions.electra; + +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.bls.BLSSignature; +import tech.pegasys.teku.infrastructure.ssz.containers.Container5; +import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema5; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszBytes32; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; +import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.datastructures.type.SszPublicKey; +import tech.pegasys.teku.spec.datastructures.type.SszPublicKeySchema; +import tech.pegasys.teku.spec.datastructures.type.SszSignature; +import tech.pegasys.teku.spec.datastructures.type.SszSignatureSchema; + +public class PendingDeposit + extends Container5< + PendingDeposit, SszPublicKey, SszBytes32, SszUInt64, SszSignature, SszUInt64> { + + public static class PendingDepositSchema + extends ContainerSchema5< + PendingDeposit, SszPublicKey, SszBytes32, SszUInt64, SszSignature, SszUInt64> { + + public PendingDepositSchema() { + super( + "PendingDeposit", + namedSchema("pubkey", SszPublicKeySchema.INSTANCE), + namedSchema("withdrawal_credentials", SszPrimitiveSchemas.BYTES32_SCHEMA), + namedSchema("amount", SszPrimitiveSchemas.UINT64_SCHEMA), + namedSchema("signature", SszSignatureSchema.INSTANCE), + namedSchema("slot", SszPrimitiveSchemas.UINT64_SCHEMA)); + } + + @Override + public PendingDeposit createFromBackingNode(final TreeNode node) { + return new PendingDeposit(this, node); + } + + public PendingDeposit create( + final SszPublicKey publicKey, + final SszBytes32 withdrawalCredentials, + final SszUInt64 amount, + final SszSignature signature, + final SszUInt64 slot) { + return new PendingDeposit(this, publicKey, withdrawalCredentials, amount, signature, slot); + } + + public SszPublicKey getPublicKeySchema() { + return (SszPublicKey) getFieldSchema0(); + } + + public SszBytes32 getWithdrawalCredentialsSchema() { + return (SszBytes32) getFieldSchema1(); + } + + public SszUInt64 getAmountSchema() { + return (SszUInt64) getFieldSchema2(); + } + + public SszSignatureSchema getSignatureSchema() { + return (SszSignatureSchema) getFieldSchema3(); + } + + public SszUInt64 getSlotSchema() { + return (SszUInt64) getFieldSchema4(); + } + } + + private PendingDeposit(final PendingDepositSchema type, final TreeNode backingNode) { + super(type, backingNode); + } + + private PendingDeposit( + final PendingDepositSchema type, + final SszPublicKey publicKey, + final SszBytes32 withdrawalCredentials, + final SszUInt64 amount, + final SszSignature signature, + final SszUInt64 slot) { + super(type, publicKey, withdrawalCredentials, amount, signature, slot); + } + + public BLSPublicKey getPublicKey() { + return ((SszPublicKey) get(0)).getBLSPublicKey(); + } + + public Bytes32 getWithdrawalCredentials() { + return ((SszBytes32) get(1)).get(); + } + + public UInt64 getAmount() { + return ((SszUInt64) get(2)).get(); + } + + public BLSSignature getSignature() { + return ((SszSignature) get(3)).getSignature(); + } + + public UInt64 getSlot() { + return ((SszUInt64) get(4)).get(); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/versions/electra/PendingPartialWithdrawal.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/versions/electra/PendingPartialWithdrawal.java new file mode 100644 index 00000000000..a7b00bd0e2d --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/state/versions/electra/PendingPartialWithdrawal.java @@ -0,0 +1,88 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.state.versions.electra; + +import tech.pegasys.teku.infrastructure.ssz.containers.Container3; +import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema3; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; +import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; + +public class PendingPartialWithdrawal + extends Container3 { + protected PendingPartialWithdrawal( + final ContainerSchema3 schema) { + super(schema); + } + + public PendingPartialWithdrawal( + final PendingPartialWithdrawalSchema pendingPartialWithdrawalSchema, + final SszUInt64 index, + final SszUInt64 amount, + final SszUInt64 withdrawableEpoch) { + super(pendingPartialWithdrawalSchema, index, amount, withdrawableEpoch); + } + + public static class PendingPartialWithdrawalSchema + extends ContainerSchema3 { + public PendingPartialWithdrawalSchema() { + super( + "PendingPartialWithdrawal", + namedSchema("index", SszPrimitiveSchemas.UINT64_SCHEMA), + namedSchema("amount", SszPrimitiveSchemas.UINT64_SCHEMA), + namedSchema("withdrawable_epoch", SszPrimitiveSchemas.UINT64_SCHEMA)); + } + + public PendingPartialWithdrawal create( + final SszUInt64 index, final SszUInt64 amount, final SszUInt64 withdrawableEpoch) { + return new PendingPartialWithdrawal(this, index, amount, withdrawableEpoch); + } + + public SszUInt64 getIndexSchema() { + return (SszUInt64) getFieldSchema0(); + } + + public SszUInt64 getAmountSchema() { + return (SszUInt64) getFieldSchema1(); + } + + public SszUInt64 getWithdrawableEpochSchema() { + return (SszUInt64) getFieldSchema2(); + } + + @Override + public PendingPartialWithdrawal createFromBackingNode(final TreeNode node) { + return new PendingPartialWithdrawal(this, node); + } + } + + private PendingPartialWithdrawal( + final PendingPartialWithdrawal.PendingPartialWithdrawalSchema type, + final TreeNode backingNode) { + super(type, backingNode); + } + + public int getIndex() { + return ((SszUInt64) get(0)).get().intValue(); + } + + public UInt64 getAmount() { + return ((SszUInt64) get(1)).get(); + } + + public UInt64 getWithdrawableEpoch() { + return ((SszUInt64) get(2)).get(); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/type/SszPublicKey.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/type/SszPublicKey.java index 32df9fbda2b..bb4d81fd5aa 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/type/SszPublicKey.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/type/SszPublicKey.java @@ -24,17 +24,17 @@ public class SszPublicKey extends SszByteVectorImpl { private final Supplier publicKey; - public SszPublicKey(Bytes48 publicKeyBytes) { + public SszPublicKey(final Bytes48 publicKeyBytes) { super(SszPublicKeySchema.INSTANCE, publicKeyBytes); this.publicKey = Suppliers.memoize(this::createBLSPublicKey); } - public SszPublicKey(BLSPublicKey publicKey) { + public SszPublicKey(final BLSPublicKey publicKey) { super(SszPublicKeySchema.INSTANCE, publicKey.toBytesCompressed()); this.publicKey = () -> publicKey; } - SszPublicKey(TreeNode backingNode) { + SszPublicKey(final TreeNode backingNode) { super(SszPublicKeySchema.INSTANCE, backingNode); this.publicKey = Suppliers.memoize(this::createBLSPublicKey); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/type/SszPublicKeySchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/type/SszPublicKeySchema.java index 518da0f5897..89792d15a80 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/type/SszPublicKeySchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/type/SszPublicKeySchema.java @@ -34,7 +34,7 @@ protected DeserializableTypeDefinition createTypeDefinition() { } @Override - public SszPublicKey createFromBackingNode(TreeNode node) { + public SszPublicKey createFromBackingNode(final TreeNode node) { return new SszPublicKey(node); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/type/SszSignature.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/type/SszSignature.java index a9fecf7412c..113e70bf207 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/type/SszSignature.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/type/SszSignature.java @@ -23,12 +23,12 @@ public class SszSignature extends SszByteVectorImpl { private final Supplier signature; - public SszSignature(BLSSignature signature) { + public SszSignature(final BLSSignature signature) { super(SszSignatureSchema.INSTANCE, signature.toBytesCompressed()); this.signature = () -> signature; } - SszSignature(TreeNode backingNode) { + SszSignature(final TreeNode backingNode) { super(SszSignatureSchema.INSTANCE, backingNode); signature = Suppliers.memoize(this::createBLSSignature); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/type/SszSignatureSchema.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/type/SszSignatureSchema.java index d0928a5e6de..3886cb5ad9b 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/type/SszSignatureSchema.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/type/SszSignatureSchema.java @@ -27,7 +27,7 @@ private SszSignatureSchema() { } @Override - public SszSignature createFromBackingNode(TreeNode node) { + public SszSignature createFromBackingNode(final TreeNode node) { return new SszSignature(node); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/util/DataColumnSlotAndIdentifier.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/util/DataColumnSlotAndIdentifier.java index 0d72019465a..6974856b257 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/util/DataColumnSlotAndIdentifier.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/util/DataColumnSlotAndIdentifier.java @@ -23,7 +23,8 @@ public record DataColumnSlotAndIdentifier(UInt64 slot, Bytes32 blockRoot, UInt64 columnIndex) implements Comparable { - public DataColumnSlotAndIdentifier(UInt64 slot, DataColumnIdentifier dataColumnIdentifier) { + public DataColumnSlotAndIdentifier( + final UInt64 slot, final DataColumnIdentifier dataColumnIdentifier) { this(slot, dataColumnIdentifier.getBlockRoot(), dataColumnIdentifier.getIndex()); } @@ -35,7 +36,7 @@ public static DataColumnSlotAndIdentifier fromDataColumn( dataColumnSidecar.getIndex()); } - public static DataColumnSlotAndIdentifier minimalComparableForSlot(UInt64 slot) { + public static DataColumnSlotAndIdentifier minimalComparableForSlot(final UInt64 slot) { return new DataColumnSlotAndIdentifier(slot, Bytes32.ZERO, UInt64.ZERO); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/util/DepositUtil.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/util/DepositUtil.java index 7223ee0f60e..91586b04013 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/util/DepositUtil.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/util/DepositUtil.java @@ -27,7 +27,7 @@ public DepositUtil(final Spec spec) { this.spec = spec; } - public DepositWithIndex convertDepositEventToOperationDeposit(Deposit event) { + public DepositWithIndex convertDepositEventToOperationDeposit(final Deposit event) { checkArgument( event.getAmount().isGreaterThanOrEqualTo(spec.getGenesisSpecConfig().getMinDepositAmount()), "Deposit amount too low"); @@ -37,6 +37,8 @@ public DepositWithIndex convertDepositEventToOperationDeposit(Deposit event) { event.getWithdrawal_credentials(), event.getAmount(), event.getSignature()); - return new DepositWithIndex(data, event.getMerkle_tree_index()); + return new DepositWithIndex( + new tech.pegasys.teku.spec.datastructures.operations.Deposit(data), + event.getMerkle_tree_index()); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/util/SlotAndBlockRootAndBlobIndex.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/util/SlotAndBlockRootAndBlobIndex.java index cf3f7a748b5..07ce0a33e03 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/util/SlotAndBlockRootAndBlobIndex.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/util/SlotAndBlockRootAndBlobIndex.java @@ -66,7 +66,7 @@ public boolean equals(final Object o) { } @Override - public int compareTo(@NotNull SlotAndBlockRootAndBlobIndex o) { + public int compareTo(final @NotNull SlotAndBlockRootAndBlobIndex o) { return Comparator.comparing(SlotAndBlockRootAndBlobIndex::getSlot) .thenComparing(SlotAndBlockRootAndBlobIndex::getBlockRoot) .thenComparing(SlotAndBlockRootAndBlobIndex::getBlobIndex) diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/versions/bellatrix/BeaconPreparableProposer.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/validator/BeaconPreparableProposer.java similarity index 54% rename from ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/versions/bellatrix/BeaconPreparableProposer.java rename to ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/validator/BeaconPreparableProposer.java index 8528344b5b8..fd1c3632af3 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/versions/bellatrix/BeaconPreparableProposer.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/validator/BeaconPreparableProposer.java @@ -11,47 +11,36 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.spec.datastructures.operations.versions.bellatrix; +package tech.pegasys.teku.spec.datastructures.validator; + +import static tech.pegasys.teku.ethereum.execution.types.Eth1Address.ETH1ADDRESS_TYPE; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; import com.google.common.base.MoreObjects; -import java.util.Objects; import tech.pegasys.teku.ethereum.execution.types.Eth1Address; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -public class BeaconPreparableProposer { - private final UInt64 validatorIndex; - private final Eth1Address feeRecipient; - - public BeaconPreparableProposer(UInt64 validatorIndex, Eth1Address feeRecipient) { - this.validatorIndex = validatorIndex; - this.feeRecipient = feeRecipient; - } - - public UInt64 getValidatorIndex() { - return validatorIndex; - } - - public Eth1Address getFeeRecipient() { - return feeRecipient; - } - - @Override - public boolean equals(final Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - final BeaconPreparableProposer that = (BeaconPreparableProposer) o; - return Objects.equals(validatorIndex, that.validatorIndex) - && Objects.equals(feeRecipient, that.feeRecipient); - } +public record BeaconPreparableProposer(UInt64 validatorIndex, Eth1Address feeRecipient) { - @Override - public int hashCode() { - return Objects.hash(validatorIndex, feeRecipient); - } + public static final DeserializableTypeDefinition SSZ_DATA = + DeserializableTypeDefinition.object( + BeaconPreparableProposer.class, BeaconPreparableProposer.Builder.class) + .name("BeaconPreparableProposer") + .finisher(BeaconPreparableProposer.Builder::build) + .initializer(BeaconPreparableProposer::builder) + .description("The fee recipient that should be used by an associated validator index.") + .withField( + "validator_index", + UINT64_TYPE, + BeaconPreparableProposer::validatorIndex, + BeaconPreparableProposer.Builder::validatorIndex) + .withField( + "fee_recipient", + ETH1ADDRESS_TYPE, + BeaconPreparableProposer::feeRecipient, + BeaconPreparableProposer.Builder::feeRecipient) + .build(); @Override public String toString() { diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/validator/BroadcastValidationLevel.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/validator/BroadcastValidationLevel.java index f93cd2507cc..c82c374af28 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/validator/BroadcastValidationLevel.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/validator/BroadcastValidationLevel.java @@ -14,8 +14,9 @@ package tech.pegasys.teku.spec.datastructures.validator; public enum BroadcastValidationLevel { - NOT_REQUIRED, - GOSSIP, - CONSENSUS, - CONSENSUS_AND_EQUIVOCATION + NOT_REQUIRED, // no validation + EQUIVOCATION, // equivocation only validation + GOSSIP, // gossip only validation (includes equivocation) + CONSENSUS, // gossip + consensus validation + CONSENSUS_AND_EQUIVOCATION // gossip + consensus + final equivocation validation at the end } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/validator/SubnetSubscription.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/validator/SubnetSubscription.java index 9197b8cfa31..f75b955aa48 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/validator/SubnetSubscription.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/validator/SubnetSubscription.java @@ -13,54 +13,41 @@ package tech.pegasys.teku.spec.datastructures.validator; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.INTEGER_TYPE; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; + import com.google.common.base.MoreObjects; import java.util.Comparator; -import java.util.Objects; import org.jetbrains.annotations.NotNull; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -public class SubnetSubscription implements Comparable { - - private final int subnetId; - private final UInt64 unsubscriptionSlot; - - public SubnetSubscription(int subnetId, UInt64 unsubscriptionSlot) { - this.subnetId = subnetId; - this.unsubscriptionSlot = unsubscriptionSlot; - } - - public int getSubnetId() { - return subnetId; - } +public record SubnetSubscription(int subnetId, UInt64 unsubscriptionSlot) + implements Comparable { - public UInt64 getUnsubscriptionSlot() { - return unsubscriptionSlot; - } + public static final DeserializableTypeDefinition SSZ_DATA = + DeserializableTypeDefinition.object(SubnetSubscription.class, SubnetSubscriptionBuilder.class) + .initializer(SubnetSubscriptionBuilder::new) + .withField( + "subnet_id", + INTEGER_TYPE, + SubnetSubscription::subnetId, + SubnetSubscriptionBuilder::subnetId) + .withField( + "unsubscription_slot", + UINT64_TYPE, + SubnetSubscription::unsubscriptionSlot, + SubnetSubscriptionBuilder::unsubscriptionSlot) + .finisher(SubnetSubscriptionBuilder::build) + .build(); @Override public int compareTo(@NotNull final SubnetSubscription o) { - return Comparator.comparing(SubnetSubscription::getUnsubscriptionSlot) - .thenComparing(SubnetSubscription::getSubnetId) + return Comparator.comparing(SubnetSubscription::unsubscriptionSlot) + .thenComparing(SubnetSubscription::subnetId) .compare(this, o); } - @Override - public boolean equals(final Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - final SubnetSubscription that = (SubnetSubscription) o; - return subnetId == that.subnetId && Objects.equals(unsubscriptionSlot, that.unsubscriptionSlot); - } - - @Override - public int hashCode() { - return Objects.hash(subnetId, unsubscriptionSlot); - } - @Override public String toString() { return MoreObjects.toStringHelper(this) @@ -68,4 +55,25 @@ public String toString() { .add("unsubscriptionSlot", unsubscriptionSlot) .toString(); } + + static class SubnetSubscriptionBuilder { + private int subnetId; + private UInt64 unsubscriptionSlot; + + SubnetSubscriptionBuilder() {} + + public SubnetSubscriptionBuilder subnetId(final int subnetId) { + this.subnetId = subnetId; + return this; + } + + public SubnetSubscriptionBuilder unsubscriptionSlot(final UInt64 unsubscriptionSlot) { + this.unsubscriptionSlot = unsubscriptionSlot; + return this; + } + + SubnetSubscription build() { + return new SubnetSubscription(subnetId, unsubscriptionSlot); + } + } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/executionlayer/ExecutionLayerBlockProductionManager.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/executionlayer/ExecutionLayerBlockProductionManager.java index 7f52c0dd619..435be8b119f 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/executionlayer/ExecutionLayerBlockProductionManager.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/executionlayer/ExecutionLayerBlockProductionManager.java @@ -19,7 +19,7 @@ import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; -import tech.pegasys.teku.spec.datastructures.builder.BuilderPayload; +import tech.pegasys.teku.spec.datastructures.execution.BuilderPayloadOrFallbackData; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadContext; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadResult; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; @@ -33,93 +33,65 @@ public interface ExecutionLayerBlockProductionManager { ExecutionLayerBlockProductionManager NOOP = new ExecutionLayerBlockProductionManager() { - @Override - public Optional getCachedPayloadResult(final UInt64 slot) { - return Optional.empty(); - } - @Override public ExecutionPayloadResult initiateBlockProduction( final ExecutionPayloadContext context, final BeaconState blockSlotState, - final boolean isBlind, + final boolean attemptBuilderFlow, final Optional requestedBuilderBoostFactor, final BlockProductionPerformance blockProductionPerformance) { return null; } @Override - public ExecutionPayloadResult initiateBlockAndBlobsProduction( - final ExecutionPayloadContext context, - final BeaconState blockSlotState, - final boolean isBlind, - final Optional requestedBuilderBoostFactor, - final BlockProductionPerformance blockProductionPerformance) { - return null; + public Optional getCachedPayloadResult(final UInt64 slot) { + return Optional.empty(); } @Override - public SafeFuture getUnblindedPayload( + public SafeFuture getUnblindedPayload( final SignedBeaconBlock signedBeaconBlock, final BlockPublishingPerformance blockPublishingPerformance) { return SafeFuture.completedFuture(null); } @Override - public Optional getCachedUnblindedPayload(final UInt64 slot) { + public Optional getCachedUnblindedPayload(final UInt64 slot) { return Optional.empty(); } }; /** - * Initiates block production flow with execution client or builder + * Initiates block (and sidecar blobs after Deneb) production flow with execution client or + * builder * - * @param context Payload context - * @param blockSlotState pre state - * @param isBlind Block type. Use blind for builder building - * @param requestedBuilderBoostFactor The proposer boost factor requested by vc + * @param context context required for the production flow + * @param blockSlotState pre-state + * @param attemptBuilderFlow set if builder flow should be attempted + * @param requestedBuilderBoostFactor The proposer boost factor requested by VC * @param blockProductionPerformance Block production performance tracker - * @return Container with filled Payload or Payload Header futures + * @return {@link ExecutionPayloadResult} coming from local, builder or a local fallback */ ExecutionPayloadResult initiateBlockProduction( ExecutionPayloadContext context, BeaconState blockSlotState, - boolean isBlind, - Optional requestedBuilderBoostFactor, - BlockProductionPerformance blockProductionPerformance); - - /** - * Initiates block and sidecar blobs production flow with execution client or builder. Use since - * Deneb. - * - * @param context Payload context - * @param blockSlotState pre state - * @param isBlind Block type. Use blind for builder building - * @param requestedBuilderBoostFactor The proposer boost factor requested by vc - * @param blockProductionPerformance Block production performance tracker - * @return Container with filled Payload or Payload Header futures - */ - ExecutionPayloadResult initiateBlockAndBlobsProduction( - ExecutionPayloadContext context, - BeaconState blockSlotState, - boolean isBlind, + boolean attemptBuilderFlow, Optional requestedBuilderBoostFactor, BlockProductionPerformance blockProductionPerformance); /** - * Required {@link #initiateBlockProduction(ExecutionPayloadContext, BeaconState, boolean, - * Optional, BlockProductionPerformance)} or {@link - * #initiateBlockAndBlobsProduction(ExecutionPayloadContext, BeaconState, boolean, Optional, - * BlockProductionPerformance)} to have been called first in order for a value to be present + * Requires {@link #initiateBlockProduction(ExecutionPayloadContext, BeaconState, boolean, + * Optional, BlockProductionPerformance)} to have been called first in order for a value to be + * present */ Optional getCachedPayloadResult(UInt64 slot); - SafeFuture getUnblindedPayload( + SafeFuture getUnblindedPayload( SignedBeaconBlock signedBeaconBlock, BlockPublishingPerformance blockPublishingPerformance); /** * Requires {@link #getUnblindedPayload(SignedBeaconBlock, BlockPublishingPerformance)} to have * been called first in order for a value to be present */ - Optional getCachedUnblindedPayload(UInt64 slot); + Optional getCachedUnblindedPayload(UInt64 slot); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/executionlayer/ExecutionLayerChannel.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/executionlayer/ExecutionLayerChannel.java index 3199e384002..f4cfac0dba1 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/executionlayer/ExecutionLayerChannel.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/executionlayer/ExecutionLayerChannel.java @@ -17,23 +17,25 @@ import java.util.Optional; import java.util.function.Function; import org.apache.tuweni.bytes.Bytes32; -import org.apache.tuweni.units.bigints.UInt256; import tech.pegasys.teku.ethereum.performance.trackers.BlockProductionPerformance; +import tech.pegasys.teku.ethereum.performance.trackers.BlockPublishingPerformance; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.events.ChannelInterface; import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; -import tech.pegasys.teku.spec.datastructures.builder.BuilderPayload; import tech.pegasys.teku.spec.datastructures.builder.SignedValidatorRegistration; +import tech.pegasys.teku.spec.datastructures.execution.BlobAndProof; +import tech.pegasys.teku.spec.datastructures.execution.BuilderBidOrFallbackData; +import tech.pegasys.teku.spec.datastructures.execution.BuilderPayloadOrFallbackData; import tech.pegasys.teku.spec.datastructures.execution.ClientVersion; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadContext; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadResult; import tech.pegasys.teku.spec.datastructures.execution.GetPayloadResponse; -import tech.pegasys.teku.spec.datastructures.execution.HeaderWithFallbackData; import tech.pegasys.teku.spec.datastructures.execution.NewPayloadRequest; import tech.pegasys.teku.spec.datastructures.execution.PowBlock; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.logic.versions.deneb.types.VersionedHash; public interface ExecutionLayerChannel extends ChannelInterface { String PREVIOUS_STUB_ENDPOINT_PREFIX = "stub"; @@ -66,7 +68,7 @@ public SafeFuture engineGetPayload( @Override public SafeFuture engineNewPayload( - final NewPayloadRequest newPayloadRequest) { + final NewPayloadRequest newPayloadRequest, final UInt64 slot) { return SafeFuture.completedFuture(PayloadStatus.SYNCING); } @@ -76,6 +78,13 @@ public SafeFuture> engineGetClientVersion( return SafeFuture.completedFuture(List.of()); } + @Override + public SafeFuture>> engineGetBlobs( + final List blobVersionedHashes, final UInt64 slot) { + return SafeFuture.completedFuture( + blobVersionedHashes.stream().map(e -> Optional.empty()).toList()); + } + @Override public SafeFuture builderRegisterValidators( final SszList signedValidatorRegistrations, @@ -84,7 +93,7 @@ public SafeFuture builderRegisterValidators( } @Override - public SafeFuture builderGetPayload( + public SafeFuture builderGetPayload( final SignedBeaconBlock signedBeaconBlock, final Function> getCachedPayloadResultFunction) { @@ -92,13 +101,11 @@ public SafeFuture builderGetPayload( } @Override - public SafeFuture builderGetHeader( + public SafeFuture builderGetHeader( final ExecutionPayloadContext executionPayloadContext, final BeaconState state, - final SafeFuture payloadValueResult, final Optional requestedBuilderBoostFactor, final BlockProductionPerformance blockProductionPerformance) { - payloadValueResult.complete(null); return SafeFuture.completedFuture(null); } }; @@ -113,10 +120,14 @@ SafeFuture engineForkChoiceUpdated( ForkChoiceState forkChoiceState, Optional payloadBuildingAttributes); - SafeFuture engineNewPayload(NewPayloadRequest newPayloadRequest); + SafeFuture engineNewPayload( + NewPayloadRequest newPayloadRequest, final UInt64 slot); SafeFuture> engineGetClientVersion(ClientVersion clientVersion); + SafeFuture>> engineGetBlobs( + List blobVersionedHashes, UInt64 slot); + /** * This is low level method, use {@link * ExecutionLayerBlockProductionManager#initiateBlockProduction(ExecutionPayloadContext, @@ -131,9 +142,10 @@ SafeFuture builderRegisterValidators( /** * This is low level method, use {@link - * ExecutionLayerBlockProductionManager#getUnblindedPayload(SignedBeaconBlock)} instead + * ExecutionLayerBlockProductionManager#getUnblindedPayload(SignedBeaconBlock, + * BlockPublishingPerformance)} instead */ - SafeFuture builderGetPayload( + SafeFuture builderGetPayload( SignedBeaconBlock signedBeaconBlock, Function> getCachedPayloadResultFunction); @@ -144,14 +156,12 @@ SafeFuture builderGetPayload( * * @param executionPayloadContext The execution payload context * @param state The beacon state - * @param payloadValueResult A callback that will contain the payload execution value (local or - * builder, whichever payload is chosen) + * @param requestedBuilderBoostFactor The requested builder boost factor * @param blockProductionPerformance The performance tracker */ - SafeFuture builderGetHeader( + SafeFuture builderGetHeader( ExecutionPayloadContext executionPayloadContext, BeaconState state, - SafeFuture payloadValueResult, Optional requestedBuilderBoostFactor, BlockProductionPerformance blockProductionPerformance); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/executionlayer/ExecutionLayerChannelStub.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/executionlayer/ExecutionLayerChannelStub.java index 363d5929cda..7ac5b384c89 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/executionlayer/ExecutionLayerChannelStub.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/executionlayer/ExecutionLayerChannelStub.java @@ -15,6 +15,7 @@ import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkState; +import static tech.pegasys.teku.infrastructure.time.SystemTimeProvider.SYSTEM_TIME_PROVIDER; import java.util.ArrayList; import java.util.HashSet; @@ -31,13 +32,13 @@ import org.apache.tuweni.bytes.Bytes; import org.apache.tuweni.bytes.Bytes32; import org.apache.tuweni.units.bigints.UInt256; +import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.ethereum.performance.trackers.BlockProductionPerformance; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.bytes.Bytes4; import tech.pegasys.teku.infrastructure.bytes.Bytes8; import tech.pegasys.teku.infrastructure.collections.cache.LRUCache; import tech.pegasys.teku.infrastructure.ssz.SszList; -import tech.pegasys.teku.infrastructure.time.SystemTimeProvider; import tech.pegasys.teku.infrastructure.time.TimeProvider; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.kzg.KZG; @@ -47,28 +48,38 @@ import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.SpecVersion; import tech.pegasys.teku.spec.config.SpecConfigBellatrix; +import tech.pegasys.teku.spec.config.SpecConfigDeneb; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.Blob; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; +import tech.pegasys.teku.spec.datastructures.builder.BuilderBid; import tech.pegasys.teku.spec.datastructures.builder.BuilderPayload; import tech.pegasys.teku.spec.datastructures.builder.SignedValidatorRegistration; +import tech.pegasys.teku.spec.datastructures.execution.BlobAndProof; import tech.pegasys.teku.spec.datastructures.execution.BlobsBundle; +import tech.pegasys.teku.spec.datastructures.execution.BuilderBidOrFallbackData; +import tech.pegasys.teku.spec.datastructures.execution.BuilderPayloadOrFallbackData; import tech.pegasys.teku.spec.datastructures.execution.ClientVersion; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadContext; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadResult; import tech.pegasys.teku.spec.datastructures.execution.GetPayloadResponse; -import tech.pegasys.teku.spec.datastructures.execution.HeaderWithFallbackData; import tech.pegasys.teku.spec.datastructures.execution.NewPayloadRequest; import tech.pegasys.teku.spec.datastructures.execution.PowBlock; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsBuilderElectra; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsSchema; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; import tech.pegasys.teku.spec.datastructures.util.BlobsUtil; +import tech.pegasys.teku.spec.logic.versions.deneb.types.VersionedHash; import tech.pegasys.teku.spec.schemas.SchemaDefinitions; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsBellatrix; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsDeneb; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; public class ExecutionLayerChannelStub implements ExecutionLayerChannel { + private static final Logger LOG = LogManager.getLogger(); private static final ClientVersion STUB_CLIENT_VERSION = new ClientVersion("SB", ExecutionLayerChannel.STUB_ENDPOINT_PREFIX, "0.0.0", Bytes4.ZERO); @@ -103,6 +114,8 @@ public class ExecutionLayerChannelStub implements ExecutionLayerChannel { lastBuilderBlobsBundle = Optional.empty(); private Optional lastValidBlock = Optional.empty(); + private boolean online = true; + public ExecutionLayerChannelStub( final Spec spec, final TimeProvider timeProvider, @@ -128,7 +141,7 @@ public ExecutionLayerChannelStub( final Spec spec, final boolean enableTransitionEmulation, final Optional terminalBlockHashInTTDMode) { - this(spec, new SystemTimeProvider(), enableTransitionEmulation, terminalBlockHashInTTDMode); + this(spec, SYSTEM_TIME_PROVIDER, enableTransitionEmulation, terminalBlockHashInTTDMode); } public void addPowBlock(final PowBlock block) { @@ -141,6 +154,8 @@ public void addPosBlock(final Bytes32 blockHash, final PayloadStatus payloadStat @Override public SafeFuture> eth1GetPowBlock(final Bytes32 blockHash) { + offlineCheck(); + if (!transitionEmulationEnabled) { requestedPowBlocks.add(blockHash); return SafeFuture.completedFuture(Optional.ofNullable(knownBlocks.get(blockHash))); @@ -166,6 +181,8 @@ public SafeFuture> eth1GetPowBlock(final Bytes32 blockHash) { @Override public SafeFuture eth1GetPowChainHead() { + offlineCheck(); + if (!transitionEmulationEnabled) { return SafeFuture.failedFuture( new UnsupportedOperationException("getPowChainHead not supported")); @@ -189,6 +206,8 @@ public SafeFuture eth1GetPowChainHead() { public SafeFuture engineForkChoiceUpdated( final ForkChoiceState forkChoiceState, final Optional payloadBuildingAttributes) { + offlineCheck(); + if (!bellatrixActivationDetected) { LOG.info( "forkChoiceUpdated received before terminalBlock has been sent. Assuming transition already happened"); @@ -223,6 +242,8 @@ public SafeFuture engineForkChoiceUpdated( @Override public SafeFuture engineGetPayload( final ExecutionPayloadContext executionPayloadContext, final BeaconState state) { + offlineCheck(); + if (!bellatrixActivationDetected) { LOG.info( "getPayload received before terminalBlock has been sent. Assuming transition already happened"); @@ -288,22 +309,48 @@ public SafeFuture engineGetPayload( state.getSlot(), executionPayload.getBlockHash()); + final Optional maybeExecutionRequests = getExecutionRequests(slot); + final GetPayloadResponse getPayloadResponse = headAndAttrs .currentBlobsBundle .map( blobsBundle -> { LOG.info("getPayload: blobsBundle: {}", blobsBundle.toBriefString()); - return new GetPayloadResponse( - executionPayload, UInt256.valueOf(424242424242424242L), blobsBundle, false); + if (maybeExecutionRequests.isPresent()) { + return new GetPayloadResponse( + executionPayload, + UInt256.valueOf(424242424242424242L), + blobsBundle, + false, + maybeExecutionRequests.get()); + } else { + return new GetPayloadResponse( + executionPayload, UInt256.valueOf(424242424242424242L), blobsBundle, false); + } }) .orElse(new GetPayloadResponse(executionPayload, UInt256.valueOf(434242424242424242L))); return SafeFuture.completedFuture(getPayloadResponse); } + private Optional getExecutionRequests(final UInt64 slot) { + if (spec.atSlot(slot).getMilestone().isGreaterThanOrEqualTo(SpecMilestone.ELECTRA)) { + final ExecutionRequestsSchema executionRequestsSchema = + SchemaDefinitionsElectra.required( + spec.forMilestone(SpecMilestone.ELECTRA).getSchemaDefinitions()) + .getExecutionRequestsSchema(); + return Optional.of(new ExecutionRequestsBuilderElectra(executionRequestsSchema).build()); + } else { + return Optional.empty(); + } + } + @Override - public SafeFuture engineNewPayload(final NewPayloadRequest newPayloadRequest) { + public SafeFuture engineNewPayload( + final NewPayloadRequest newPayloadRequest, final UInt64 slot) { + offlineCheck(); + final ExecutionPayload executionPayload = newPayloadRequest.getExecutionPayload(); final PayloadStatus returnedStatus = Optional.ofNullable(knownPosBlocks.get(executionPayload.getBlockHash())) @@ -319,36 +366,47 @@ public SafeFuture engineNewPayload(final NewPayloadRequest newPay @Override public SafeFuture> engineGetClientVersion(final ClientVersion clientVersion) { + offlineCheck(); + return SafeFuture.completedFuture(List.of(STUB_CLIENT_VERSION)); } + @Override + public SafeFuture>> engineGetBlobs( + final List blobVersionedHashes, final UInt64 slot) { + return SafeFuture.completedFuture( + blobVersionedHashes.stream().map(e -> Optional.empty()).toList()); + } + @Override public SafeFuture builderRegisterValidators( final SszList signedValidatorRegistrations, final UInt64 slot) { + offlineCheck(); return SafeFuture.COMPLETE; } @Override - public SafeFuture builderGetHeader( + public SafeFuture builderGetHeader( final ExecutionPayloadContext executionPayloadContext, final BeaconState state, - final SafeFuture payloadValueResult, final Optional requestedBuilderBoostFactor, final BlockProductionPerformance blockProductionPerformance) { + offlineCheck(); + final UInt64 slot = state.getSlot(); LOG.info( "getPayloadHeader: payloadId: {} slot: {} ... delegating to getPayload ...", executionPayloadContext, slot); - final SchemaDefinitions schemaDefinitions = spec.atSlot(slot).getSchemaDefinitions(); + final SchemaDefinitionsBellatrix schemaDefinitions = + SchemaDefinitionsBellatrix.required(spec.atSlot(slot).getSchemaDefinitions()); return engineGetPayload(executionPayloadContext, state) - .thenPeek(__ -> blockProductionPerformance.engineGetPayload()) + .alwaysRun(blockProductionPerformance::engineGetPayload) .thenApply( getPayloadResponse -> { final ExecutionPayload executionPayload = getPayloadResponse.getExecutionPayload(); - payloadValueResult.complete(getPayloadResponse.getExecutionPayloadValue()); LOG.info( "getPayloadHeader: payloadId: {} slot: {} -> executionPayload blockHash: {}", executionPayloadContext, @@ -356,7 +414,7 @@ public SafeFuture builderGetHeader( executionPayload.getBlockHash()); lastBuilderPayloadToBeUnblinded = Optional.of(executionPayload); final ExecutionPayloadHeader payloadHeader = - SchemaDefinitionsBellatrix.required(schemaDefinitions) + schemaDefinitions .getExecutionPayloadHeaderSchema() .createFromExecutionPayload(executionPayload); final Optional> blobKzgCommitments = @@ -375,15 +433,28 @@ public SafeFuture builderGetHeader( .getBlobKzgCommitmentsSchema() .createFromBlobsBundle(blobsBundle); }); - return HeaderWithFallbackData.create(payloadHeader, blobKzgCommitments); + final BuilderBid builderBid = + schemaDefinitions + .getBuilderBidSchema() + .createBuilderBid( + builder -> { + builder.header(payloadHeader); + blobKzgCommitments.ifPresent(builder::blobKzgCommitments); + builder.value(getPayloadResponse.getExecutionPayloadValue()); + // using an empty public key for the stub + builder.publicKey(BLSPublicKey.empty()); + }); + return BuilderBidOrFallbackData.create(builderBid); }) - .thenPeek(__ -> blockProductionPerformance.builderGetHeader()); + .alwaysRun(blockProductionPerformance::builderGetHeader); } @Override - public SafeFuture builderGetPayload( + public SafeFuture builderGetPayload( final SignedBeaconBlock signedBeaconBlock, final Function> getCachedPayloadResultFunction) { + offlineCheck(); + final UInt64 slot = signedBeaconBlock.getSlot(); final SchemaDefinitions schemaDefinitions = spec.atSlot(slot).getSchemaDefinitions(); final Optional schemaDefinitionsBellatrix = @@ -408,7 +479,8 @@ public SafeFuture builderGetPayload( executionPayloadHeader .hashTreeRoot() .equals(lastBuilderPayloadToBeUnblinded.get().hashTreeRoot()), - "provided signed blinded block contains an execution payload header not matching the previously retrieved execution payload via getPayloadHeader"); + "provided signed blinded block contains an execution payload header not matching the previously retrieved " + + "execution payload via getPayloadHeader"); LOG.info( "proposeBlindedBlock: slot: {} block: {} -> unblinded executionPayload blockHash: {}", @@ -439,10 +511,10 @@ public SafeFuture builderGetPayload( // pre Deneb .orElse(lastBuilderPayloadToBeUnblinded.get()); - return SafeFuture.completedFuture(builderPayload); + return SafeFuture.completedFuture(BuilderPayloadOrFallbackData.create(builderPayload)); } - public void setPayloadStatus(PayloadStatus payloadStatus) { + public void setPayloadStatus(final PayloadStatus payloadStatus) { this.payloadStatus = payloadStatus; } @@ -455,6 +527,10 @@ public Set getRequestedPowBlocks() { return requestedPowBlocks; } + public void setOnline(final boolean online) { + this.online = online; + } + @SuppressWarnings("unused") private static class HeadAndAttributes { private final Bytes32 head; @@ -468,6 +544,12 @@ private HeadAndAttributes(final Bytes32 head, final PayloadBuildingAttributes at } } + private void offlineCheck() { + if (!online) { + throw new RuntimeException("stub is offline"); + } + } + private void checkBellatrixActivation() { if (!bellatrixActivationDetected) { LOG.info("Bellatrix activation detected"); @@ -541,7 +623,11 @@ private Bytes generateBlobsAndTransaction( blobsUtil.generateBlobs( slot, blobsToGenerate.orElseGet( - () -> random.nextInt(spec.getMaxBlobsPerBlock().orElseThrow() + 1))); + () -> + random.nextInt( + SpecConfigDeneb.required(spec.atSlot(slot).getConfig()) + .getMaxBlobsPerBlock() + + 1))); final List commitments = blobsUtil.blobsToKzgCommitments(blobs); final List proofs = blobsUtil.computeKzgProofs(blobs, commitments); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/executionlayer/ForkChoiceUpdatedResult.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/executionlayer/ForkChoiceUpdatedResult.java index 27dc02b779a..a3b3d65e350 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/executionlayer/ForkChoiceUpdatedResult.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/executionlayer/ForkChoiceUpdatedResult.java @@ -22,7 +22,8 @@ public class ForkChoiceUpdatedResult { private final PayloadStatus payloadStatus; private final Optional payloadId; - public ForkChoiceUpdatedResult(PayloadStatus payloadStatus, Optional payloadId) { + public ForkChoiceUpdatedResult( + final PayloadStatus payloadStatus, final Optional payloadId) { this.payloadStatus = payloadStatus; this.payloadId = payloadId; } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/executionlayer/PayloadBuildingAttributes.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/executionlayer/PayloadBuildingAttributes.java index 30a505f1d6e..7ec469600b8 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/executionlayer/PayloadBuildingAttributes.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/executionlayer/PayloadBuildingAttributes.java @@ -34,6 +34,8 @@ public class PayloadBuildingAttributes { private final Optional validatorRegistration; private final Optional> withdrawals; private final Bytes32 parentBeaconBlockRoot; + private final Optional targetBlobCount; + private final Optional maximumBlobCount; public PayloadBuildingAttributes( final UInt64 proposerIndex, @@ -44,6 +46,30 @@ public PayloadBuildingAttributes( final Optional validatorRegistration, final Optional> withdrawals, final Bytes32 parentBeaconBlockRoot) { + this( + proposerIndex, + proposalSlot, + timestamp, + prevRandao, + feeRecipient, + validatorRegistration, + withdrawals, + parentBeaconBlockRoot, + Optional.empty(), + Optional.empty()); + } + + public PayloadBuildingAttributes( + final UInt64 proposerIndex, + final UInt64 proposalSlot, + final UInt64 timestamp, + final Bytes32 prevRandao, + final Eth1Address feeRecipient, + final Optional validatorRegistration, + final Optional> withdrawals, + final Bytes32 parentBeaconBlockRoot, + final Optional targetBlobCount, + final Optional maximumBlobCount) { this.proposerIndex = proposerIndex; this.proposalSlot = proposalSlot; this.timestamp = timestamp; @@ -52,6 +78,8 @@ public PayloadBuildingAttributes( this.validatorRegistration = validatorRegistration; this.withdrawals = withdrawals; this.parentBeaconBlockRoot = parentBeaconBlockRoot; + this.targetBlobCount = targetBlobCount; + this.maximumBlobCount = maximumBlobCount; } public UInt64 getProposerIndex() { @@ -78,6 +106,14 @@ public Bytes32 getParentBeaconBlockRoot() { return parentBeaconBlockRoot; } + public Optional getTargetBlobCount() { + return targetBlobCount; + } + + public Optional getMaximumBlobCount() { + return maximumBlobCount; + } + public Optional getValidatorRegistration() { return validatorRegistration; } @@ -107,7 +143,9 @@ public boolean equals(final Object o) { && Objects.equals(feeRecipient, that.feeRecipient) && Objects.equals(validatorRegistration, that.validatorRegistration) && Objects.equals(withdrawals, that.withdrawals) - && Objects.equals(parentBeaconBlockRoot, that.parentBeaconBlockRoot); + && Objects.equals(parentBeaconBlockRoot, that.parentBeaconBlockRoot) + && Objects.equals(targetBlobCount, that.targetBlobCount) + && Objects.equals(maximumBlobCount, that.maximumBlobCount); } @Override @@ -120,7 +158,9 @@ public int hashCode() { feeRecipient, validatorRegistration, withdrawals, - parentBeaconBlockRoot); + parentBeaconBlockRoot, + targetBlobCount, + maximumBlobCount); } @Override @@ -134,6 +174,8 @@ public String toString() { .add("validatorRegistration", validatorRegistration) .add("withdrawals", withdrawals) .add("parentBeaconBlockRoot", parentBeaconBlockRoot) + .add("targetBlobCount", targetBlobCount) + .add("maximumBlobCount", maximumBlobCount) .toString(); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/executionlayer/PayloadStatus.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/executionlayer/PayloadStatus.java index d1fab3a526a..133aefa4d30 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/executionlayer/PayloadStatus.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/executionlayer/PayloadStatus.java @@ -44,7 +44,7 @@ public static PayloadStatus failedExecution(final Throwable cause) { } public static PayloadStatus invalid( - Optional latestValidHash, Optional validationError) { + final Optional latestValidHash, final Optional validationError) { return new PayloadStatus( Optional.of(ExecutionPayloadStatus.INVALID), latestValidHash, @@ -53,7 +53,7 @@ public static PayloadStatus invalid( } public static PayloadStatus valid( - Optional latestValidHash, Optional validationError) { + final Optional latestValidHash, final Optional validationError) { return new PayloadStatus( Optional.of(ExecutionPayloadStatus.VALID), latestValidHash, @@ -62,9 +62,9 @@ public static PayloadStatus valid( } public static PayloadStatus create( - ExecutionPayloadStatus status, - Optional latestValidHash, - Optional validationError) { + final ExecutionPayloadStatus status, + final Optional latestValidHash, + final Optional validationError) { return new PayloadStatus( Optional.of(status), latestValidHash, validationError, Optional.empty()); } @@ -75,10 +75,10 @@ public static PayloadStatus create( private final Optional failureCause; private PayloadStatus( - Optional status, - Optional latestValidHash, - Optional validationError, - Optional failureCause) { + final Optional status, + final Optional latestValidHash, + final Optional validationError, + final Optional failureCause) { this.status = status; this.latestValidHash = latestValidHash; this.validationError = validationError; @@ -97,7 +97,7 @@ public Optional getStatus() { return status; } - public boolean hasStatus(ExecutionPayloadStatus status) { + public boolean hasStatus(final ExecutionPayloadStatus status) { return this.status.map(s -> s == status).orElse(false); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/genesis/GenesisGenerator.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/genesis/GenesisGenerator.java index e49e7fb7ce1..ba1e27c0373 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/genesis/GenesisGenerator.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/genesis/GenesisGenerator.java @@ -14,6 +14,7 @@ package tech.pegasys.teku.spec.genesis; import static tech.pegasys.teku.spec.config.SpecConfig.GENESIS_EPOCH; +import static tech.pegasys.teku.spec.config.SpecConfigElectra.UNSET_DEPOSIT_REQUESTS_START_INDEX; import it.unimi.dsi.fastutil.objects.Object2IntMap; import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; @@ -26,6 +27,7 @@ import tech.pegasys.teku.infrastructure.ssz.SszMutableList; import tech.pegasys.teku.infrastructure.ssz.schema.SszListSchema; import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.SpecVersion; import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlockHeader; @@ -37,7 +39,11 @@ import tech.pegasys.teku.spec.datastructures.state.Validator; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.datastructures.state.beaconstate.MutableBeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.BeaconStateElectra; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.MutableBeaconStateElectra; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.BeaconStateMutatorsElectra; import tech.pegasys.teku.spec.schemas.SchemaDefinitions; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; public class GenesisGenerator { @@ -58,9 +64,9 @@ public GenesisGenerator(final SpecVersion genesisSpec, final Fork genesisFork) { final SchemaDefinitions schemaDefinitions = genesisSpec.getSchemaDefinitions(); state = schemaDefinitions.getBeaconStateSchema().createBuilder(); - Bytes32 latestBlockRoot = + final Bytes32 latestBlockRoot = schemaDefinitions.getBeaconBlockBodySchema().createEmpty().hashTreeRoot(); - BeaconBlockHeader beaconBlockHeader = + final BeaconBlockHeader beaconBlockHeader = new BeaconBlockHeader( SpecConfig.GENESIS_SLOT, UInt64.ZERO, Bytes32.ZERO, Bytes32.ZERO, latestBlockRoot); state.setLatestBlockHeader(beaconBlockHeader); @@ -72,24 +78,28 @@ public GenesisGenerator(final SpecVersion genesisSpec, final Fork genesisFork) { .createWritableCopy(); } - public void updateExecutionPayloadHeader(ExecutionPayloadHeader payloadHeader) { + public void updateExecutionPayloadHeader(final ExecutionPayloadHeader payloadHeader) { state .toMutableVersionBellatrix() .ifPresent(stateBellatrix -> stateBellatrix.setLatestExecutionPayloadHeader(payloadHeader)); } public void updateCandidateState( - Bytes32 eth1BlockHash, UInt64 eth1Timestamp, List deposits) { + final Bytes32 eth1BlockHash, final UInt64 eth1Timestamp, final List deposits) { updateGenesisTime(eth1Timestamp); state.setEth1Data( new Eth1Data( Bytes32.ZERO, UInt64.valueOf(depositDataList.size() + deposits.size()), eth1BlockHash)); + if (genesisSpec.getMilestone().isGreaterThanOrEqualTo(SpecMilestone.ELECTRA)) { + MutableBeaconStateElectra.required(state) + .setDepositRequestsStartIndex(UNSET_DEPOSIT_REQUESTS_START_INDEX); + } // Process deposits deposits.forEach( deposit -> { - LOG.trace("About to process deposit: {}", depositDataList::size); + LOG.trace("About to process deposit: {}", depositDataList.size()); depositDataList.append(deposit.getData()); // Skip verifying the merkle proof as these deposits come directly from an Eth1 event. @@ -99,37 +109,73 @@ public void updateCandidateState( .processDepositWithoutCheckingMerkleProof( state, deposit, Optional.of(keyCache), false); - processActivation(deposit); + if (!genesisSpec.getMilestone().isGreaterThanOrEqualTo(SpecMilestone.ELECTRA)) { + processActivation(deposit); + } }); + + // Process deposit balance updates + if (genesisSpec.getMilestone().isGreaterThanOrEqualTo(SpecMilestone.ELECTRA)) { + final SchemaDefinitionsElectra schemaDefinitionsElectra = + SchemaDefinitionsElectra.required(genesisSpec.getSchemaDefinitions()); + final BeaconStateMutatorsElectra mutatorsElectra = + new BeaconStateMutatorsElectra( + specConfig, + genesisSpec.miscHelpers(), + genesisSpec.beaconStateAccessors(), + schemaDefinitionsElectra); + BeaconStateElectra.required(state) + .getPendingDeposits() + .forEach( + pendingDeposit -> { + mutatorsElectra.increaseBalance( + state, + keyCache.getInt(pendingDeposit.getPublicKey()), + pendingDeposit.getAmount()); + }); + MutableBeaconStateElectra.required(state) + .setPendingDeposits( + schemaDefinitionsElectra.getPendingDepositsSchema().createFromElements(List.of())); + + // Process activations + keyCache.values().intStream().forEach(this::processActivation); + } } private void processActivation(final Deposit deposit) { - final int index = keyCache.getOrDefault(deposit.getData().getPubkey(), -1); + processActivation(keyCache.getOrDefault(deposit.getData().getPubkey(), -1)); + } + + private void processActivation(final int index) { if (index == -1) { // Could be absent if the deposit was invalid return; } - Validator validator = state.getValidators().get(index); + final Validator validator = state.getValidators().get(index); if (validator.getActivationEpoch().equals(GENESIS_EPOCH)) { // Validator is already activated (and thus already has the max effective balance) return; } - UInt64 balance = state.getBalances().getElement(index); - UInt64 effectiveBalance = + + final UInt64 balance = state.getBalances().getElement(index); + final UInt64 effectiveBalance = balance .minus(balance.mod(specConfig.getEffectiveBalanceIncrement())) .min(specConfig.getMaxEffectiveBalance()); - UInt64 activationEligibilityEpoch = validator.getActivationEligibilityEpoch(); - UInt64 activationEpoch = validator.getActivationEpoch(); + final UInt64 activationEligibilityEpoch; + final UInt64 activationEpoch; if (effectiveBalance.equals(specConfig.getMaxEffectiveBalance())) { activationEligibilityEpoch = GENESIS_EPOCH; activationEpoch = GENESIS_EPOCH; activeValidatorCount++; + } else { + activationEligibilityEpoch = validator.getActivationEligibilityEpoch(); + activationEpoch = validator.getActivationEpoch(); } - Validator modifiedValidator = + final Validator modifiedValidator = new Validator( validator.getPubkeyBytes(), validator.getWithdrawalCredentials(), @@ -178,14 +224,14 @@ private void calculateRandaoMixes() { } private void calculateDepositRoot() { - Eth1Data eth1Data = state.getEth1Data(); + final Eth1Data eth1Data = state.getEth1Data(); state.setEth1Data( new Eth1Data( depositDataList.hashTreeRoot(), eth1Data.getDepositCount(), eth1Data.getBlockHash())); } private void updateGenesisTime(final UInt64 eth1Timestamp) { - UInt64 genesisTime = eth1Timestamp.plus(specConfig.getGenesisDelay()); + final UInt64 genesisTime = eth1Timestamp.plus(specConfig.getGenesisDelay()); state.setGenesisTime(genesisTime); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/StateTransition.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/StateTransition.java index 5170e4c129f..9341a28161c 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/StateTransition.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/StateTransition.java @@ -36,7 +36,7 @@ public StateTransition(final SpecProvider specProvider) { this.specProvider = specProvider; } - public BeaconState processSlots(BeaconState preState, UInt64 slot) + public BeaconState processSlots(final BeaconState preState, final UInt64 slot) throws SlotProcessingException, EpochProcessingException { try { checkArgument( diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/block/AbstractBlockProcessor.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/block/AbstractBlockProcessor.java index f3b4b4b00fb..acd4e37dbf5 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/block/AbstractBlockProcessor.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/block/AbstractBlockProcessor.java @@ -14,7 +14,6 @@ package tech.pegasys.teku.spec.logic.common.block; import static com.google.common.base.Preconditions.checkArgument; -import static tech.pegasys.teku.spec.config.SpecConfig.FAR_FUTURE_EPOCH; import com.google.common.annotations.VisibleForTesting; import it.unimi.dsi.fastutil.ints.IntList; @@ -46,12 +45,14 @@ import tech.pegasys.teku.spec.datastructures.blocks.Eth1Data; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequest; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; import tech.pegasys.teku.spec.datastructures.operations.Deposit; import tech.pegasys.teku.spec.datastructures.operations.DepositData; -import tech.pegasys.teku.spec.datastructures.operations.DepositMessage; import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestation; import tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing; import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; @@ -88,6 +89,7 @@ public abstract class AbstractBlockProcessor implements BlockProcessor { * Setting to false significantly speeds up state initialization */ @VisibleForTesting + @SuppressWarnings("NonFinalStaticField") public static BLSSignatureVerifier depositSignatureVerifier = DEFAULT_DEPOSIT_SIGNATURE_VERIFIER; private static final Logger LOG = LogManager.getLogger(); @@ -306,7 +308,10 @@ protected void assertAttestationValid( beaconStateAccessors.getBeaconCommittee(state, data.getSlot(), data.getIndex()); checkArgument( attestation.getAggregationBits().size() == committee.size(), - "process_attestations: Attestation aggregation bits and committee don't have the same length"); + "process_attestations: Attestation aggregation bits and committee don't have the same length - committee " + + committee.size() + + ", aggregation bits " + + attestation.getAggregationBits().size()); } @Override @@ -334,11 +339,18 @@ protected void processBlock( processBlockHeader(state, block); processRandaoNoValidation(state, block.getBody()); processEth1Data(state, block.getBody()); - processOperationsNoValidation(state, block.getBody(), indexedAttestationCache); + processOperationsNoValidation( + state, block.getBody(), indexedAttestationCache, getValidatorExitContextSupplier(state)); + } + + protected Supplier getValidatorExitContextSupplier( + final MutableBeaconState state) { + return beaconStateMutators.createValidatorExitContextSupplier(state); } @Override - public void processBlockHeader(MutableBeaconState state, BeaconBlockSummary blockHeader) + public void processBlockHeader( + final MutableBeaconState state, final BeaconBlockSummary blockHeader) throws BlockProcessingException { safelyProcess( () -> { @@ -366,30 +378,31 @@ public void processBlockHeader(MutableBeaconState state, BeaconBlockSummary bloc blockHeader.getBodyRoot())); // Only if we are processing blocks (not proposing them) - Validator proposer = state.getValidators().get(blockHeader.getProposerIndex().intValue()); + final Validator proposer = + state.getValidators().get(blockHeader.getProposerIndex().intValue()); checkArgument( !proposer.isSlashed(), "process_block_header: Verify proposer is not slashed"); }); } - protected void processRandaoNoValidation(MutableBeaconState state, BeaconBlockBody body) - throws BlockProcessingException { + protected void processRandaoNoValidation( + final MutableBeaconState state, final BeaconBlockBody body) throws BlockProcessingException { safelyProcess( () -> { - UInt64 epoch = beaconStateAccessors.getCurrentEpoch(state); + final UInt64 epoch = beaconStateAccessors.getCurrentEpoch(state); - Bytes32 mix = + final Bytes32 mix = beaconStateAccessors .getRandaoMix(state, epoch) .xor(Hash.sha256(body.getRandaoReveal().toSSZBytes())); - int index = epoch.mod(specConfig.getEpochsPerHistoricalVector()).intValue(); + final int index = epoch.mod(specConfig.getEpochsPerHistoricalVector()).intValue(); state.getRandaoMixes().setElement(index, mix); }); } protected BlockValidationResult verifyRandao( final BeaconState state, final BeaconBlock block, final BLSSignatureVerifier bls) { - UInt64 epoch = miscHelpers.computeEpochAtSlot(block.getSlot()); + final UInt64 epoch = miscHelpers.computeEpochAtSlot(block.getSlot()); // Verify RANDAO reveal final BLSPublicKey proposerPublicKey = beaconStateAccessors.getValidatorPubKey(state, block.getProposerIndex()).orElseThrow(); @@ -403,7 +416,7 @@ protected BlockValidationResult verifyRandao( protected void processEth1Data(final MutableBeaconState state, final BeaconBlockBody body) { state.getEth1DataVotes().append(body.getEth1Data()); - long voteCount = getVoteCount(state, body.getEth1Data()); + final long voteCount = getVoteCount(state, body.getEth1Data()); if (isEnoughVotesToUpdateEth1Data(voteCount)) { state.setEth1Data(body.getEth1Data()); } @@ -423,15 +436,13 @@ public long getVoteCount(final BeaconState state, final Eth1Data eth1Data) { protected void processOperationsNoValidation( final MutableBeaconState state, final BeaconBlockBody body, - final IndexedAttestationCache indexedAttestationCache) + final IndexedAttestationCache indexedAttestationCache, + final Supplier validatorExitContextSupplier) throws BlockProcessingException { safelyProcess( () -> { verifyOutstandingDepositsAreProcessed(state, body); - final Supplier validatorExitContextSupplier = - beaconStateMutators.createValidatorExitContextSupplier(state); - processProposerSlashingsNoValidation( state, body.getProposerSlashings(), validatorExitContextSupplier); processAttesterSlashings( @@ -462,7 +473,7 @@ public void processProposerSlashings( final BLSSignatureVerifier signatureVerifier) throws BlockProcessingException { final Supplier validatorExitContextSupplier = - beaconStateMutators.createValidatorExitContextSupplier(state); + getValidatorExitContextSupplier(state); processProposerSlashingsNoValidation(state, proposerSlashings, validatorExitContextSupplier); final BlockValidationResult validationResult = verifyProposerSlashings(state, proposerSlashings, signatureVerifier); @@ -521,7 +532,7 @@ public void processAttesterSlashings( safelyProcess( () -> { final Supplier validatorExitContextSupplier = - beaconStateMutators.createValidatorExitContextSupplier(state); + getValidatorExitContextSupplier(state); processAttesterSlashings(state, attesterSlashings, validatorExitContextSupplier); }); } @@ -573,9 +584,9 @@ public void processAttestations( } protected void processAttestationsNoVerification( - MutableBeaconState state, - SszList attestations, - IndexedAttestationCache indexedAttestationCache) + final MutableBeaconState state, + final SszList attestations, + final IndexedAttestationCache indexedAttestationCache) throws BlockProcessingException { final IndexedAttestationProvider indexedAttestationProvider = createIndexedAttestationProvider(state, indexedAttestationCache); @@ -590,7 +601,7 @@ protected void processAttestationsNoVerification( } public IndexedAttestationProvider createIndexedAttestationProvider( - BeaconState state, IndexedAttestationCache indexedAttestationCache) { + final BeaconState state, final IndexedAttestationCache indexedAttestationCache) { return (attestation) -> indexedAttestationCache.computeIfAbsent( attestation, () -> attestationUtil.getIndexedAttestation(state, attestation)); @@ -613,10 +624,10 @@ protected abstract void processAttestation( @CheckReturnValue protected BlockValidationResult verifyAttestationSignatures( - BeaconState state, - SszList attestations, - BLSSignatureVerifier signatureVerifier, - IndexedAttestationCache indexedAttestationCache) { + final BeaconState state, + final SszList attestations, + final BLSSignatureVerifier signatureVerifier, + final IndexedAttestationCache indexedAttestationCache) { return verifyAttestationSignatures( state, attestations, @@ -626,10 +637,10 @@ protected BlockValidationResult verifyAttestationSignatures( @CheckReturnValue protected BlockValidationResult verifyAttestationSignatures( - BeaconState state, - SszList attestations, - BLSSignatureVerifier signatureVerifier, - IndexedAttestationProvider indexedAttestationProvider) { + final BeaconState state, + final SszList attestations, + final BLSSignatureVerifier signatureVerifier, + final IndexedAttestationProvider indexedAttestationProvider) { Optional processResult = attestations.stream() @@ -649,7 +660,7 @@ protected BlockValidationResult verifyAttestationSignatures( } @Override - public void processDeposits(MutableBeaconState state, SszList deposits) + public void processDeposits(final MutableBeaconState state, final SszList deposits) throws BlockProcessingException { safelyProcess( () -> { @@ -660,7 +671,7 @@ public void processDeposits(MutableBeaconState state, SszList }); } - private boolean batchVerifyDepositSignatures(final SszList deposits) { + private boolean batchVerifyDepositSignatures(final SszList deposits) { try { final List> publicKeys = new ArrayList<>(); final List messages = new ArrayList<>(); @@ -669,7 +680,7 @@ private boolean batchVerifyDepositSignatures(final SszList de final BLSPublicKey pubkey = deposit.getData().getPubkey(); publicKeys.add(List.of(pubkey)); messages.add( - computeDepositSigningRoot( + miscHelpers.computeDepositSigningRoot( pubkey, deposit.getData().getWithdrawalCredentials(), deposit.getData().getAmount())); @@ -682,6 +693,7 @@ private boolean batchVerifyDepositSignatures(final SszList de } } + /** process_deposit */ public void processDeposit( final MutableBeaconState state, final Deposit deposit, @@ -718,6 +730,7 @@ public void processDepositWithoutCheckingMerkleProof( signatureAlreadyVerified); } + /** apply_deposit */ public void applyDeposit( final MutableBeaconState state, final BLSPublicKey pubkey, @@ -745,18 +758,19 @@ public void applyDeposit( // Verify the deposit signature (proof of possession) which is not checked by the deposit // contract if (signatureAlreadyVerified - || depositSignatureIsValid(pubkey, withdrawalCredentials, amount, signature)) { - addValidatorToRegistry(state, pubkey, withdrawalCredentials, amount); + || miscHelpers.isValidDepositSignature( + pubkey, withdrawalCredentials, amount, signature)) { + beaconStateMutators.addValidatorToRegistry(state, pubkey, withdrawalCredentials, amount); } else { handleInvalidDeposit(pubkey, maybePubkeyToIndexMap); } } else { - // This validator already exists, increase their balance + // Increase balance by deposit amount beaconStateMutators.increaseBalance(state, existingIndex.get(), amount); } } - private void handleInvalidDeposit( + protected void handleInvalidDeposit( final BLSPublicKey pubkey, final Optional> maybePubkeyToIndexMap) { LOG.debug("Skipping invalid deposit with pubkey {}", pubkey); @@ -767,54 +781,6 @@ private void handleInvalidDeposit( }); } - private boolean depositSignatureIsValid( - final BLSPublicKey pubkey, - final Bytes32 withdrawalCredentials, - final UInt64 amount, - final BLSSignature signature) { - try { - return depositSignatureVerifier.verify( - pubkey, computeDepositSigningRoot(pubkey, withdrawalCredentials, amount), signature); - } catch (final BlsException e) { - return false; - } - } - - private Bytes computeDepositSigningRoot( - final BLSPublicKey pubkey, final Bytes32 withdrawalCredentials, final UInt64 amount) { - final Bytes32 domain = miscHelpers.computeDomain(Domain.DEPOSIT); - final DepositMessage depositMessage = new DepositMessage(pubkey, withdrawalCredentials, amount); - return miscHelpers.computeSigningRoot(depositMessage, domain); - } - - protected void addValidatorToRegistry( - final MutableBeaconState state, - final BLSPublicKey pubkey, - final Bytes32 withdrawalCredentials, - final UInt64 amount) { - final Validator validator = getValidatorFromDeposit(pubkey, withdrawalCredentials, amount); - LOG.debug("Adding new validator with index {} to state", state.getValidators().size()); - state.getValidators().append(validator); - state.getBalances().appendElement(amount); - } - - private Validator getValidatorFromDeposit( - final BLSPublicKey pubkey, final Bytes32 withdrawalCredentials, final UInt64 amount) { - final UInt64 effectiveBalance = - amount - .minus(amount.mod(specConfig.getEffectiveBalanceIncrement())) - .min(specConfig.getMaxEffectiveBalance()); - return new Validator( - pubkey, - withdrawalCredentials, - effectiveBalance, - false, - FAR_FUTURE_EPOCH, - FAR_FUTURE_EPOCH, - FAR_FUTURE_EPOCH, - FAR_FUTURE_EPOCH); - } - @Override public void processVoluntaryExits( final MutableBeaconState state, @@ -822,7 +788,7 @@ public void processVoluntaryExits( final BLSSignatureVerifier signatureVerifier) throws BlockProcessingException { final Supplier validatorExitContextSupplier = - beaconStateMutators.createValidatorExitContextSupplier(state); + getValidatorExitContextSupplier(state); processVoluntaryExitsNoValidation(state, exits, validatorExitContextSupplier); BlockValidationResult signaturesValid = verifyVoluntaryExits(state, exits, signatureVerifier); if (!signaturesValid.isValid()) { @@ -840,7 +806,7 @@ protected void processVoluntaryExitsNoValidation( () -> { // For each exit in block.body.voluntaryExits: for (SignedVoluntaryExit signedExit : exits) { - Optional invalidReason = + final Optional invalidReason = operationValidator.validateVoluntaryExit(state.getFork(), state, signedExit); checkArgument( invalidReason.isEmpty(), @@ -858,11 +824,11 @@ protected void processVoluntaryExitsNoValidation( } protected BlockValidationResult verifyVoluntaryExits( - BeaconState state, - SszList exits, - BLSSignatureVerifier signatureVerifier) { + final BeaconState state, + final SszList exits, + final BLSSignatureVerifier signatureVerifier) { for (SignedVoluntaryExit signedExit : exits) { - boolean exitSignatureValid = + final boolean exitSignatureValid = operationSignatureVerifier.verifyVoluntaryExitSignature( state, signedExit, signatureVerifier); if (!exitSignatureValid) { @@ -872,8 +838,38 @@ protected BlockValidationResult verifyVoluntaryExits( return BlockValidationResult.SUCCESSFUL; } + @Override + public void processDepositRequests( + final MutableBeaconState state, final List depositRequests) { + // No DepositRequests until Electra + } + + @Override + public void processWithdrawalRequests( + final MutableBeaconState state, + final List withdrawalRequests, + final Supplier validatorExitContextSupplier) + throws BlockProcessingException { + // No WithdrawalRequests until Electra + } + + @Override + public void processConsolidationRequests( + final MutableBeaconState state, final List consolidationRequests) + throws BlockProcessingException { + // No Consolidations until Electra + } + + @Override + public boolean isValidSwitchToCompoundingRequest( + final BeaconState beaconState, final ConsolidationRequest consolidationRequest) + throws BlockProcessingException { + // No Consolidations until Electra + return false; + } + // Catch generic errors and wrap them in a BlockProcessingException - protected void safelyProcess(BlockProcessingAction action) throws BlockProcessingException { + protected void safelyProcess(final BlockProcessingAction action) throws BlockProcessingException { try { action.run(); } catch (ArithmeticException | IllegalArgumentException | IndexOutOfBoundsException e) { diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/block/BlockProcessor.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/block/BlockProcessor.java index 0f21a58f1a0..8976f5e7363 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/block/BlockProcessor.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/block/BlockProcessor.java @@ -30,8 +30,11 @@ import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.SyncAggregate; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSummary; +import tech.pegasys.teku.spec.datastructures.execution.ExpectedWithdrawals; import tech.pegasys.teku.spec.datastructures.execution.NewPayloadRequest; -import tech.pegasys.teku.spec.datastructures.execution.versions.capella.Withdrawal; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequest; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; @@ -50,8 +53,8 @@ import tech.pegasys.teku.spec.logic.versions.bellatrix.block.OptimisticExecutionPayloadExecutor; public interface BlockProcessor { - Optional validateAttestation( - final BeaconState state, final AttestationData data); + + Optional validateAttestation(BeaconState state, AttestationData data); BeaconState processAndValidateBlock( SignedBeaconBlock signedBlock, @@ -117,14 +120,14 @@ void processAttestations( BLSSignatureVerifier signatureVerifier) throws BlockProcessingException; - void processDeposits(MutableBeaconState state, SszList deposits) + void processDeposits(MutableBeaconState state, SszList deposits) throws BlockProcessingException; void processDepositWithoutCheckingMerkleProof( - final MutableBeaconState state, - final Deposit deposit, - final Optional> maybePubkeyToIndexMap, - final boolean signatureAlreadyVerified); + MutableBeaconState state, + Deposit deposit, + Optional> maybePubkeyToIndexMap, + boolean signatureAlreadyVerified); void processVoluntaryExits( MutableBeaconState state, @@ -136,7 +139,7 @@ void processSyncAggregate( MutableBeaconState state, SyncAggregate syncAggregate, BLSSignatureVerifier signatureVerifier) throws BlockProcessingException; - UInt64 computeParticipantReward(final BeaconStateAltair state); + UInt64 computeParticipantReward(BeaconStateAltair state); void processExecutionPayload( MutableBeaconState state, @@ -166,7 +169,24 @@ void processBlsToExecutionChanges( void processWithdrawals(MutableBeaconState state, ExecutionPayloadSummary payloadSummary) throws BlockProcessingException; - Optional> getExpectedWithdrawals(BeaconState preState); + void processDepositRequests(MutableBeaconState state, List depositRequests) + throws BlockProcessingException; + + void processWithdrawalRequests( + MutableBeaconState state, + List exits, + Supplier validatorExitContextSupplier) + throws BlockProcessingException; + + void processConsolidationRequests( + MutableBeaconState state, List consolidationRequests) + throws BlockProcessingException; + + boolean isValidSwitchToCompoundingRequest( + BeaconState beaconState, ConsolidationRequest consolidationRequest) + throws BlockProcessingException; + + ExpectedWithdrawals getExpectedWithdrawals(BeaconState preState); default Optional toVersionAltair() { return Optional.empty(); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/helpers/BeaconStateAccessors.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/helpers/BeaconStateAccessors.java index d37edf0327b..04304403ee1 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/helpers/BeaconStateAccessors.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/helpers/BeaconStateAccessors.java @@ -17,6 +17,8 @@ import static tech.pegasys.teku.spec.config.SpecConfig.GENESIS_EPOCH; import static tech.pegasys.teku.spec.logic.common.helpers.MathHelpers.uint64ToBytes; +import it.unimi.dsi.fastutil.ints.Int2IntMap; +import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap; import it.unimi.dsi.fastutil.ints.IntList; import java.util.Collection; import java.util.Optional; @@ -49,11 +51,11 @@ protected BeaconStateAccessors( this.miscHelpers = miscHelpers; } - public UInt64 getCurrentEpoch(BeaconState state) { + public UInt64 getCurrentEpoch(final BeaconState state) { return miscHelpers.computeEpochAtSlot(state.getSlot()); } - public UInt64 getPreviousEpoch(BeaconState state) { + public UInt64 getPreviousEpoch(final BeaconState state) { UInt64 currentEpoch = getCurrentEpoch(state); return currentEpoch.equals(GENESIS_EPOCH) ? GENESIS_EPOCH : currentEpoch.minus(UInt64.ONE); } @@ -73,7 +75,8 @@ public UInt64 getValidatorActivationChurnLimit(final BeaconState state) { return getValidatorChurnLimit(state); } - public Optional getValidatorPubKey(BeaconState state, UInt64 validatorIndex) { + public Optional getValidatorPubKey( + final BeaconState state, final UInt64 validatorIndex) { if (state.getValidators().size() <= validatorIndex.longValue() || validatorIndex.longValue() < 0) { return Optional.empty(); @@ -101,7 +104,7 @@ public Optional getValidatorPubKey(BeaconState state, UInt64 valid * @param epoch - The epoch under consideration. * @return A list of indices representing the active validators for the given epoch. */ - public IntList getActiveValidatorIndices(BeaconState state, UInt64 epoch) { + public IntList getActiveValidatorIndices(final BeaconState state, final UInt64 epoch) { final UInt64 stateEpoch = getCurrentEpoch(state); final UInt64 maxLookaheadEpoch = getMaxLookaheadEpoch(stateEpoch); checkArgument( @@ -130,7 +133,7 @@ private UInt64 getMaxLookaheadEpoch(final UInt64 stateEpoch) { return stateEpoch.plus(config.getMaxSeedLookahead()); } - public UInt64 getTotalBalance(BeaconState state, Collection indices) { + public UInt64 getTotalBalance(final BeaconState state, final Collection indices) { UInt64 sum = UInt64.ZERO; SszList validatorRegistry = state.getValidators(); for (Integer index : indices) { @@ -139,7 +142,7 @@ public UInt64 getTotalBalance(BeaconState state, Collection indices) { return sum.max(config.getEffectiveBalanceIncrement()); } - public UInt64 getTotalActiveBalance(BeaconState state) { + public UInt64 getTotalActiveBalance(final BeaconState state) { return BeaconStateCache.getTransitionCaches(state) .getTotalActiveBalance() .get( @@ -153,7 +156,7 @@ public UInt64 getProposerBoostAmount(final BeaconState state) { return committeeWeight.times(config.getProposerScoreBoost()).dividedBy(100); } - public Bytes32 getSeed(BeaconState state, UInt64 epoch, Bytes4 domainType) + public Bytes32 getSeed(final BeaconState state, final UInt64 epoch, final Bytes4 domainType) throws IllegalArgumentException { UInt64 randaoIndex = epoch.plus(config.getEpochsPerHistoricalVector() - config.getMinSeedLookahead() - 1); @@ -183,7 +186,7 @@ public UInt64 calculateCommitteeFraction( * @param epoch * @return */ - public UInt64 getCommitteeCountPerSlot(BeaconState state, UInt64 epoch) { + public UInt64 getCommitteeCountPerSlot(final BeaconState state, final UInt64 epoch) { IntList activeValidatorIndices = getActiveValidatorIndices(state, epoch); return getCommitteeCountPerSlot(activeValidatorIndices.size()); } @@ -199,16 +202,16 @@ public UInt64 getCommitteeCountPerSlot(final long activeValidatorCount) { config.getTargetCommitteeSize())))); } - public Bytes32 getRandaoMix(BeaconState state, UInt64 epoch) { + public Bytes32 getRandaoMix(final BeaconState state, final UInt64 epoch) { int index = epoch.mod(config.getEpochsPerHistoricalVector()).intValue(); return state.getRandaoMixes().getElement(index); } - public int getBeaconProposerIndex(BeaconState state) { + public int getBeaconProposerIndex(final BeaconState state) { return getBeaconProposerIndex(state, state.getSlot()); } - public int getBeaconProposerIndex(BeaconState state, UInt64 requestedSlot) { + public int getBeaconProposerIndex(final BeaconState state, final UInt64 requestedSlot) { validateStateCanCalculateProposerIndexAtSlot(state, requestedSlot); return BeaconStateCache.getTransitionCaches(state) .getBeaconProposerIndex() @@ -248,7 +251,7 @@ private void validateStateCanCalculateProposerIndexAtSlot( stateEpoch); } - public Bytes32 getBlockRootAtSlot(BeaconState state, UInt64 slot) + public Bytes32 getBlockRootAtSlot(final BeaconState state, final UInt64 slot) throws IllegalArgumentException { checkArgument( isBlockRootAvailableFromState(state, slot), @@ -259,11 +262,12 @@ public Bytes32 getBlockRootAtSlot(BeaconState state, UInt64 slot) return state.getBlockRoots().getElement(latestBlockRootIndex); } - public Bytes32 getBlockRoot(BeaconState state, UInt64 epoch) throws IllegalArgumentException { + public Bytes32 getBlockRoot(final BeaconState state, final UInt64 epoch) + throws IllegalArgumentException { return getBlockRootAtSlot(state, miscHelpers.computeStartSlotAtEpoch(epoch)); } - private boolean isBlockRootAvailableFromState(BeaconState state, UInt64 slot) { + private boolean isBlockRootAvailableFromState(final BeaconState state, final UInt64 slot) { UInt64 slotPlusHistoricalRoot = slot.plus(config.getSlotsPerHistoricalRoot()); return slot.isLessThan(state.getSlot()) && state.getSlot().isLessThanOrEqualTo(slotPlusHistoricalRoot); @@ -284,7 +288,8 @@ public int getPreviousEpochAttestationCapacity(final BeaconState state) { return Integer.MAX_VALUE; } - public IntList getBeaconCommittee(BeaconState state, UInt64 slot, UInt64 index) { + public IntList getBeaconCommittee( + final BeaconState state, final UInt64 slot, final UInt64 index) { // Make sure state is within range of the slot being queried validateStateForCommitteeQuery(state, slot); @@ -292,7 +297,7 @@ public IntList getBeaconCommittee(BeaconState state, UInt64 slot, UInt64 index) .getBeaconCommittee() .get( TekuPair.of(slot, index), - p -> { + __ -> { UInt64 epoch = miscHelpers.computeEpochAtSlot(slot); UInt64 committeesPerSlot = getCommitteeCountPerSlot(state, epoch); int committeeIndex = @@ -310,7 +315,26 @@ public IntList getBeaconCommittee(BeaconState state, UInt64 slot, UInt64 index) }); } - public void validateStateForCommitteeQuery(BeaconState state, UInt64 slot) { + public Int2IntMap getBeaconCommitteesSize(final BeaconState state, final UInt64 slot) { + return BeaconStateCache.getTransitionCaches(state) + .getBeaconCommitteesSize() + .get( + slot, + __ -> { + final UInt64 epoch = miscHelpers.computeEpochAtSlot(slot); + final UInt64 committees = getCommitteeCountPerSlot(state, epoch); + final Int2IntMap committeesSize = new Int2IntOpenHashMap(committees.intValue()); + UInt64.range(UInt64.ZERO, committees) + .forEach( + index -> { + final IntList committee = getBeaconCommittee(state, slot, index); + committeesSize.put(index.intValue(), committee.size()); + }); + return committeesSize; + }); + } + + public void validateStateForCommitteeQuery(final BeaconState state, final UInt64 slot) { final UInt64 oldestQueryableSlot = miscHelpers.getEarliestQueryableSlotForBeaconCommitteeAtTargetSlot(slot); checkArgument( diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/helpers/BeaconStateMutators.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/helpers/BeaconStateMutators.java index 930ca0f9c69..628e5ff437d 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/helpers/BeaconStateMutators.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/helpers/BeaconStateMutators.java @@ -19,6 +19,10 @@ import java.util.ArrayList; import java.util.List; import java.util.function.Supplier; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.datastructures.state.Validator; @@ -27,8 +31,10 @@ import tech.pegasys.teku.spec.datastructures.state.beaconstate.MutableBeaconState; public class BeaconStateMutators { - private final SpecConfig specConfig; - private final MiscHelpers miscHelpers; + private static final Logger LOG = LogManager.getLogger(); + + protected final SpecConfig specConfig; + protected final MiscHelpers miscHelpers; private final BeaconStateAccessors beaconStateAccessors; public BeaconStateMutators( @@ -48,7 +54,8 @@ public BeaconStateMutators( * @param proposerIndex * @param delta */ - public void increaseProposerBalance(MutableBeaconState state, int proposerIndex, UInt64 delta) { + public void increaseProposerBalance( + final MutableBeaconState state, final int proposerIndex, final UInt64 delta) { increaseBalance(state, proposerIndex, delta); BeaconStateCache.getSlotCaches(state).increaseBlockProposerRewards(delta); } @@ -62,7 +69,7 @@ public void increaseProposerBalance(MutableBeaconState state, int proposerIndex, * @see * https://github.com/ethereum/consensus-specs/blob/v0.8.0/specs/core/0_beacon-chain.md#increase_balance */ - public void increaseBalance(MutableBeaconState state, int index, UInt64 delta) { + public void increaseBalance(final MutableBeaconState state, final int index, final UInt64 delta) { state.getBalances().setElement(index, state.getBalances().getElement(index).plus(delta)); } @@ -75,7 +82,7 @@ public void increaseBalance(MutableBeaconState state, int index, UInt64 delta) { * @see * https://github.com/ethereum/consensus-specs/blob/v0.8.0/specs/core/0_beacon-chain.md#decrease_balance */ - public void decreaseBalance(MutableBeaconState state, int index, UInt64 delta) { + public void decreaseBalance(final MutableBeaconState state, final int index, final UInt64 delta) { state .getBalances() .setElement(index, state.getBalances().getElement(index).minusMinZero(delta)); @@ -141,6 +148,22 @@ public Supplier createValidatorExitContextSupplier( return Suppliers.memoize(() -> createValidatorExitContext(state)); } + /** + * add_validator_to_registry + */ + public void addValidatorToRegistry( + final MutableBeaconState state, + final BLSPublicKey pubkey, + final Bytes32 withdrawalCredentials, + final UInt64 amount) { + final Validator validator = + miscHelpers.getValidatorFromDeposit(pubkey, withdrawalCredentials, amount); + LOG.debug("Adding new validator with index {} to state", state.getValidators().size()); + state.getValidators().append(validator); + state.getBalances().appendElement(amount); + } + /** * This function implements an optimized version of exitQueueEpoch and exitQueueChurn calculation, * compared to the `initiate_validator_exit` reference implementation. @@ -194,6 +217,26 @@ public static class ValidatorExitContext { private ValidatorExitContext(final UInt64 churnLimit) { this.churnLimit = churnLimit; } + + public UInt64 getExitQueueEpoch() { + return exitQueueEpoch; + } + + public UInt64 getExitQueueChurn() { + return exitQueueChurn; + } + + public UInt64 getChurnLimit() { + return churnLimit; + } + + public void setExitQueueEpoch(final UInt64 exitQueueEpoch) { + this.exitQueueEpoch = exitQueueEpoch; + } + + public void setExitQueueChurn(final UInt64 exitQueueChurn) { + this.exitQueueChurn = exitQueueChurn; + } } public void slashValidator( @@ -206,12 +249,12 @@ public void slashValidator( private void slashValidator( final MutableBeaconState state, final int slashedIndex, - int whistleblowerIndex, + final int whistleblowerIndex, final Supplier validatorExitContextSupplier) { - UInt64 epoch = beaconStateAccessors.getCurrentEpoch(state); + final UInt64 epoch = beaconStateAccessors.getCurrentEpoch(state); initiateValidatorExit(state, slashedIndex, validatorExitContextSupplier); - Validator validator = state.getValidators().get(slashedIndex); + final Validator validator = state.getValidators().get(slashedIndex); state .getValidators() @@ -238,7 +281,7 @@ private void slashValidator( int proposerIndex = beaconStateAccessors.getBeaconProposerIndex(state); final UInt64 whistleblowerReward = - validator.getEffectiveBalance().dividedBy(specConfig.getWhistleblowerRewardQuotient()); + validator.getEffectiveBalance().dividedBy(getWhistleblowerRewardQuotient()); if (whistleblowerIndex == -1) { // proposer takes all rewards @@ -258,4 +301,8 @@ protected UInt64 calculateProposerReward(final UInt64 whistleblowerReward) { protected int getMinSlashingPenaltyQuotient() { return specConfig.getMinSlashingPenaltyQuotient(); } + + protected int getWhistleblowerRewardQuotient() { + return specConfig.getWhistleblowerRewardQuotient(); + } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/helpers/MiscHelpers.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/helpers/MiscHelpers.java index e5d07fbff38..e2bd41de99e 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/helpers/MiscHelpers.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/helpers/MiscHelpers.java @@ -15,6 +15,8 @@ import static com.google.common.base.Preconditions.checkArgument; import static tech.pegasys.teku.infrastructure.crypto.Hash.getSha256Instance; +import static tech.pegasys.teku.spec.config.SpecConfig.FAR_FUTURE_EPOCH; +import static tech.pegasys.teku.spec.logic.common.block.AbstractBlockProcessor.depositSignatureVerifier; import static tech.pegasys.teku.spec.logic.common.helpers.MathHelpers.bytesToUInt64; import static tech.pegasys.teku.spec.logic.common.helpers.MathHelpers.uint64ToBytes; import static tech.pegasys.teku.spec.logic.common.helpers.MathHelpers.uintTo4Bytes; @@ -27,6 +29,9 @@ import org.apache.tuweni.bytes.Bytes; import org.apache.tuweni.bytes.Bytes32; import org.apache.tuweni.units.bigints.UInt256; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.bls.BLSSignature; +import tech.pegasys.teku.bls.impl.BlsException; import tech.pegasys.teku.infrastructure.bytes.Bytes4; import tech.pegasys.teku.infrastructure.crypto.Hash; import tech.pegasys.teku.infrastructure.crypto.Sha256; @@ -37,17 +42,21 @@ import tech.pegasys.teku.kzg.KZG; import tech.pegasys.teku.kzg.KZGCommitment; import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.constants.Domain; import tech.pegasys.teku.spec.constants.NetworkConstants; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; -import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSidecar; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock; +import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; +import tech.pegasys.teku.spec.datastructures.operations.DepositMessage; import tech.pegasys.teku.spec.datastructures.state.ForkData; import tech.pegasys.teku.spec.datastructures.state.SigningData; +import tech.pegasys.teku.spec.datastructures.state.Validator; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconStateCache; import tech.pegasys.teku.spec.logic.versions.deneb.helpers.MiscHelpersDeneb; import tech.pegasys.teku.spec.logic.versions.deneb.types.VersionedHash; -import tech.pegasys.teku.spec.logic.versions.eip7594.helpers.MiscHelpersEip7594; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.MiscHelpersElectra; +import tech.pegasys.teku.spec.logic.versions.feature.eip7594.helpers.MiscHelpersEip7594; public class MiscHelpers { @@ -62,7 +71,7 @@ public MiscHelpers(final SpecConfig specConfig) { this.specConfig = specConfig; } - public int computeShuffledIndex(int index, int indexCount, Bytes32 seed) { + public int computeShuffledIndex(final int index, final int indexCount, final Bytes32 seed) { checkArgument(index < indexCount, "CommitteeUtil.computeShuffledIndex1"); final Sha256 sha256 = getSha256Instance(); @@ -98,6 +107,14 @@ public int computeShuffledIndex(int index, int indexCount, Bytes32 seed) { public int computeProposerIndex( final BeaconState state, final IntList indices, final Bytes32 seed) { + return computeProposerIndex(state, indices, seed, specConfig.getMaxEffectiveBalance()); + } + + protected int computeProposerIndex( + final BeaconState state, + final IntList indices, + final Bytes32 seed, + final UInt64 maxEffectiveBalance) { checkArgument(!indices.isEmpty(), "compute_proposer_index indices must not be empty"); final Sha256 sha256 = getSha256Instance(); @@ -106,15 +123,16 @@ public int computeProposerIndex( final int total = indices.size(); byte[] hash = null; while (true) { - int candidateIndex = indices.getInt(computeShuffledIndex(i % total, total, seed)); + final int candidateIndex = indices.getInt(computeShuffledIndex(i % total, total, seed)); if (i % 32 == 0) { hash = sha256.digest(seed, uint64ToBytes(Math.floorDiv(i, 32L))); } - int randomByte = UnsignedBytes.toInt(hash[i % 32]); - UInt64 effectiveBalance = state.getValidators().get(candidateIndex).getEffectiveBalance(); - if (effectiveBalance + final int randomByte = UnsignedBytes.toInt(hash[i % 32]); + final UInt64 validatorEffectiveBalance = + state.getValidators().get(candidateIndex).getEffectiveBalance(); + if (validatorEffectiveBalance .times(MAX_RANDOM_BYTE) - .isGreaterThanOrEqualTo(specConfig.getMaxEffectiveBalance().times(randomByte))) { + .isGreaterThanOrEqualTo(maxEffectiveBalance.times(randomByte))) { return candidateIndex; } i++; @@ -150,7 +168,7 @@ public boolean isSlotAtNthEpochBoundary( return blockEpoch.dividedBy(n).isGreaterThan(parentEpoch.dividedBy(n)); } - public UInt64 computeActivationExitEpoch(UInt64 epoch) { + public UInt64 computeActivationExitEpoch(final UInt64 epoch) { return epoch.plus(UInt64.ONE).plus(specConfig.getMaxSeedLookahead()); } @@ -248,13 +266,13 @@ public UInt64 calculateNodeSubnetUnsubscriptionSlot( return computeStartSlotAtEpoch(nextPeriodEpoch); } - IntList shuffleList(IntList input, Bytes32 seed) { + IntList shuffleList(final IntList input, final Bytes32 seed) { final int[] indices = input.toIntArray(); shuffleList(indices, seed); return IntList.of(indices); } - public void shuffleList(int[] input, Bytes32 seed) { + public void shuffleList(final int[] input, final Bytes32 seed) { int listSize = input.length; if (listSize == 0) { @@ -301,26 +319,34 @@ public void shuffleList(int[] input, Bytes32 seed) { } } - public Bytes computeSigningRoot(Merkleizable object, Bytes32 domain) { + public Bytes computeSigningRoot(final Merkleizable object, final Bytes32 domain) { return new SigningData(object.hashTreeRoot(), domain).hashTreeRoot(); } - public Bytes computeSigningRoot(UInt64 number, Bytes32 domain) { + public Bytes computeSigningRoot(final UInt64 number, final Bytes32 domain) { SigningData domainWrappedObject = new SigningData(SszUInt64.of(number).hashTreeRoot(), domain); return domainWrappedObject.hashTreeRoot(); } - public Bytes32 computeSigningRoot(Bytes bytes, Bytes32 domain) { + public Bytes32 computeSigningRoot(final Bytes bytes, final Bytes32 domain) { SigningData domainWrappedObject = new SigningData(SszByteVector.computeHashTreeRoot(bytes), domain); return domainWrappedObject.hashTreeRoot(); } - public Bytes4 computeForkDigest(Bytes4 currentVersion, Bytes32 genesisValidatorsRoot) { + public Bytes computeDepositSigningRoot( + final BLSPublicKey pubkey, final Bytes32 withdrawalCredentials, final UInt64 amount) { + final Bytes32 domain = computeDomain(Domain.DEPOSIT); + final DepositMessage depositMessage = new DepositMessage(pubkey, withdrawalCredentials, amount); + return computeSigningRoot(depositMessage, domain); + } + + public Bytes4 computeForkDigest( + final Bytes4 currentVersion, final Bytes32 genesisValidatorsRoot) { return new Bytes4(computeForkDataRoot(currentVersion, genesisValidatorsRoot).slice(0, 4)); } - public Bytes32 computeDomain(Bytes4 domainType) { + public Bytes32 computeDomain(final Bytes4 domainType) { return computeDomain(domainType, specConfig.getGenesisForkVersion(), Bytes32.ZERO); } @@ -329,12 +355,13 @@ public Bytes32 computeDomain(final Bytes4 domainType, final Bytes32 genesisValid } public Bytes32 computeDomain( - Bytes4 domainType, Bytes4 forkVersion, Bytes32 genesisValidatorsRoot) { + final Bytes4 domainType, final Bytes4 forkVersion, final Bytes32 genesisValidatorsRoot) { final Bytes32 forkDataRoot = computeForkDataRoot(forkVersion, genesisValidatorsRoot); return Bytes32.wrap(Bytes.concatenate(domainType.getWrappedBytes(), forkDataRoot.slice(0, 28))); } - private Bytes32 computeForkDataRoot(Bytes4 currentVersion, Bytes32 genesisValidatorsRoot) { + private Bytes32 computeForkDataRoot( + final Bytes4 currentVersion, final Bytes32 genesisValidatorsRoot) { return new ForkData(currentVersion, genesisValidatorsRoot).hashTreeRoot(); } @@ -376,20 +403,59 @@ public UInt64 getMaxRequestBlocks() { return UInt64.valueOf(specConfig.getNetworkingConfig().getMaxRequestBlocks()); } - public boolean verifyDataColumnSidecarKzgProof( - final KZG kzg, final DataColumnSidecar dataColumnSidecar) { - return false; + public int getBlobKzgCommitmentsCount(final SignedBeaconBlock signedBeaconBlock) { + throw new UnsupportedOperationException("No Blob KZG Commitments before Deneb"); + } + + public UInt64 getMaxEffectiveBalance(final Validator validator) { + return specConfig.getMaxEffectiveBalance(); } - public boolean verifyDataColumnSidecarInclusionProof(final DataColumnSidecar dataColumnSidecar) { + public boolean isFormerDepositMechanismDisabled(final BeaconState state) { return false; } + /** is_valid_deposit_signature */ + public boolean isValidDepositSignature( + final BLSPublicKey pubkey, + final Bytes32 withdrawalCredentials, + final UInt64 amount, + final BLSSignature signature) { + try { + return depositSignatureVerifier.verify( + pubkey, computeDepositSigningRoot(pubkey, withdrawalCredentials, amount), signature); + } catch (final BlsException e) { + return false; + } + } + + /** get_validator_from_deposit */ + public Validator getValidatorFromDeposit( + final BLSPublicKey pubkey, final Bytes32 withdrawalCredentials, final UInt64 amount) { + final UInt64 effectiveBalance = + amount + .minus(amount.mod(specConfig.getEffectiveBalanceIncrement())) + .min(specConfig.getMaxEffectiveBalance()); + return new Validator( + pubkey, + withdrawalCredentials, + effectiveBalance, + false, + FAR_FUTURE_EPOCH, + FAR_FUTURE_EPOCH, + FAR_FUTURE_EPOCH, + FAR_FUTURE_EPOCH); + } + public Optional toVersionDeneb() { return Optional.empty(); } - public Optional toVersionEip7594() { + public Optional toVersionElectra() { + return Optional.empty(); + } + + public Optional getEip7594Helpers() { return Optional.empty(); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/helpers/Predicates.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/helpers/Predicates.java index de3d26d18f1..f5007fcb110 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/helpers/Predicates.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/helpers/Predicates.java @@ -16,12 +16,15 @@ import static tech.pegasys.teku.infrastructure.crypto.Hash.getSha256Instance; import static tech.pegasys.teku.spec.constants.WithdrawalPrefixes.ETH1_ADDRESS_WITHDRAWAL_BYTE; +import java.util.Optional; import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.ethereum.execution.types.Eth1Address; import tech.pegasys.teku.infrastructure.crypto.Sha256; import tech.pegasys.teku.infrastructure.ssz.collections.SszBytes32Vector; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.datastructures.state.Validator; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.PredicatesElectra; public class Predicates { @@ -40,11 +43,12 @@ public Predicates(final SpecConfig specConfig) { * @see is_active_validator */ - public boolean isActiveValidator(Validator validator, UInt64 epoch) { + public boolean isActiveValidator(final Validator validator, final UInt64 epoch) { return isActiveValidator(validator.getActivationEpoch(), validator.getExitEpoch(), epoch); } - public boolean isActiveValidator(UInt64 activationEpoch, UInt64 exitEpoch, UInt64 epoch) { + public boolean isActiveValidator( + final UInt64 activationEpoch, final UInt64 exitEpoch, final UInt64 epoch) { return activationEpoch.compareTo(epoch) <= 0 && epoch.compareTo(exitEpoch) < 0; } @@ -52,10 +56,11 @@ public boolean isValidMerkleBranch( final Bytes32 leaf, final SszBytes32Vector branch, final int depth, - int index, + final int startingIndex, final Bytes32 root) { final Sha256 sha256 = getSha256Instance(); Bytes32 value = leaf; + int index = startingIndex; for (int i = 0; i < depth; i++) { if ((index & 1) == 1) { value = sha256.wrappedDigest(branch.getElement(i), value); @@ -73,21 +78,50 @@ public boolean isValidMerkleBranch( * @see is_slashable_validator */ - public boolean isSlashableValidator(Validator validator, UInt64 epoch) { + public boolean isSlashableValidator(final Validator validator, final UInt64 epoch) { return !validator.isSlashed() && (validator.getActivationEpoch().compareTo(epoch) <= 0 && epoch.compareTo(validator.getWithdrawableEpoch()) < 0); } /** - * Implementation of has_eth1_withdrawal_credential Capella Helper function.
+ * Implementation of has_eth1_withdrawal_credential Capella helper function.
* Checks if validator has a 0x01 prefixed "eth1" withdrawal credential. * * @param validator the validator being checked * @return true if the validator has an "eth1" withdrawal credential, false otherwise */ public boolean hasEth1WithdrawalCredential(final Validator validator) { - return validator.getWithdrawalCredentials().get(0) == ETH1_ADDRESS_WITHDRAWAL_BYTE; + return isEth1WithdrawalCredential(validator.getWithdrawalCredentials()); + } + + public static boolean isEth1WithdrawalCredential(final Bytes32 withdrawalCredentials) { + return withdrawalCredentials.get(0) == ETH1_ADDRESS_WITHDRAWAL_BYTE; + } + + /** + * has_execution_withdrawal_credential + * + * @param validator + * @return + */ + public boolean hasExecutionWithdrawalCredential(final Validator validator) { + return hasEth1WithdrawalCredential(validator); + } + + /** + * Get the execution address from a validator's withdrawal credentials. This method does not check + * if the validator has the correct type of withdrawal credentials (e.g. prefixes 0x01 and 0x02). + * + *

This method can be used in conjunction with {@link + * PredicatesElectra#hasExecutionWithdrawalCredential(Validator)} to ensure a correct execution + * address will be returned. + * + * @param withdrawalCredentials the 32 bytes withdrawal credentials field of a validator + * @return the last 20 bytes of the input withdrawal credentials, wrapped as {@link Eth1Address}. + */ + public static Eth1Address getExecutionAddressUnchecked(final Bytes32 withdrawalCredentials) { + return Eth1Address.fromBytes(withdrawalCredentials.slice(12)); } /** @@ -102,10 +136,10 @@ public boolean hasEth1WithdrawalCredential(final Validator validator) { public boolean isFullyWithdrawableValidator( final Validator validator, final UInt64 balance, final UInt64 epoch) { return hasEth1WithdrawalCredential(validator) - && isFullyWithdrawableValidatorEth1CredentialsChecked(validator, balance, epoch); + && isFullyWithdrawableValidatorCredentialsChecked(validator, balance, epoch); } - public boolean isFullyWithdrawableValidatorEth1CredentialsChecked( + public boolean isFullyWithdrawableValidatorCredentialsChecked( final Validator validator, final UInt64 balance, final UInt64 epoch) { return validator.getWithdrawableEpoch().isLessThanOrEqualTo(epoch) && balance.isGreaterThan(UInt64.ZERO); @@ -133,4 +167,8 @@ public boolean isPartiallyWithdrawableValidatorEth1CredentialsChecked( return hasMaxEffectiveBalance && hasExcessBalance; } + + public Optional toVersionElectra() { + return Optional.empty(); + } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/operations/OperationSignatureVerifier.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/operations/OperationSignatureVerifier.java index f195b34f096..633782194fe 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/operations/OperationSignatureVerifier.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/operations/OperationSignatureVerifier.java @@ -49,10 +49,10 @@ public OperationSignatureVerifier( } public boolean verifyProposerSlashingSignature( - Fork fork, - BeaconState state, - ProposerSlashing proposerSlashing, - BLSSignatureVerifier signatureVerifier) { + final Fork fork, + final BeaconState state, + final ProposerSlashing proposerSlashing, + final BLSSignatureVerifier signatureVerifier) { final BeaconBlockHeader header1 = proposerSlashing.getHeader1().getMessage(); final BeaconBlockHeader header2 = proposerSlashing.getHeader2().getMessage(); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/operations/validation/AttestationDataValidator.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/operations/validation/AttestationDataValidator.java index b422f7d2a64..32d333ee982 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/operations/validation/AttestationDataValidator.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/operations/validation/AttestationDataValidator.java @@ -20,6 +20,8 @@ public interface AttestationDataValidator enum AttestationInvalidReason implements OperationInvalidReason { COMMITTEE_INDEX_TOO_HIGH("CommitteeIndex too high"), + COMMITTEE_INDEX_MUST_BE_ZERO("CommitteeIndex must be set to zero"), + PARTICIPANTS_COUNT_MISMATCH("Attesting participants count do not match aggregation bits"), NOT_FROM_CURRENT_OR_PREVIOUS_EPOCH("Attestation not from current or previous epoch"), SLOT_NOT_IN_EPOCH("Attestation slot not in specified epoch"), SUBMITTED_TOO_QUICKLY("Attestation submitted too quickly"), diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/blockvalidator/BatchSignatureVerifier.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/blockvalidator/BatchSignatureVerifier.java index 0080d7d587e..b1dd09cb74b 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/blockvalidator/BatchSignatureVerifier.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/blockvalidator/BatchSignatureVerifier.java @@ -43,7 +43,11 @@ private static class Job { final Bytes message; final BLSSignature signature; - public Job(int idx, List publicKeys, Bytes message, BLSSignature signature) { + public Job( + final int idx, + final List publicKeys, + final Bytes message, + final BLSSignature signature) { this.idx = idx; this.publicKeys = publicKeys; this.message = message; @@ -56,7 +60,7 @@ public Job(int idx, List publicKeys, Bytes message, BLSSignature s @Override public synchronized boolean verify( - List publicKeys, Bytes message, BLSSignature signature) { + final List publicKeys, final Bytes message, final BLSSignature signature) { if (complete) { throw new IllegalStateException("Reuse of disposable instance"); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/blockvalidator/BlockValidationResult.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/blockvalidator/BlockValidationResult.java index eb3e4511d37..60e5c269f15 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/blockvalidator/BlockValidationResult.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/blockvalidator/BlockValidationResult.java @@ -22,12 +22,12 @@ public class BlockValidationResult { private final boolean isValid; private final String failureReason; - private BlockValidationResult(String failureReason) { + private BlockValidationResult(final String failureReason) { this.failureReason = failureReason; this.isValid = false; } - private BlockValidationResult(boolean isValid) { + private BlockValidationResult(final boolean isValid) { this.isValid = isValid; failureReason = null; } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/epoch/AbstractEpochProcessor.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/epoch/AbstractEpochProcessor.java index 962f366f043..6ca58ced844 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/epoch/AbstractEpochProcessor.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/epoch/AbstractEpochProcessor.java @@ -27,6 +27,7 @@ import tech.pegasys.teku.infrastructure.ssz.collections.SszMutableUInt64List; import tech.pegasys.teku.infrastructure.ssz.collections.SszUInt64List; import tech.pegasys.teku.infrastructure.time.Throttler; +import tech.pegasys.teku.infrastructure.time.TimeProvider; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlockHeader; @@ -63,8 +64,10 @@ public abstract class AbstractEpochProcessor implements EpochProcessor { protected final BeaconStateMutators beaconStateMutators; private static final Logger LOG = LogManager.getLogger(); - // Used to log once per epoch (throttlingPeriod = 1) - private final Throttler loggerThrottler = new Throttler<>(LOG, UInt64.ONE); + protected final UInt64 maxEffectiveBalance; + // Used to log once per minute (throttlingPeriod = 60 seconds) + private final Throttler loggerThrottler = new Throttler<>(LOG, UInt64.valueOf(60)); + private final TimeProvider timeProvider; protected AbstractEpochProcessor( final SpecConfig specConfig, @@ -74,7 +77,8 @@ protected AbstractEpochProcessor( final ValidatorsUtil validatorsUtil, final BeaconStateUtil beaconStateUtil, final ValidatorStatusFactory validatorStatusFactory, - final SchemaDefinitions schemaDefinitions) { + final SchemaDefinitions schemaDefinitions, + final TimeProvider timeProvider) { this.specConfig = specConfig; this.miscHelpers = miscHelpers; this.beaconStateAccessors = beaconStateAccessors; @@ -83,6 +87,8 @@ protected AbstractEpochProcessor( this.beaconStateUtil = beaconStateUtil; this.validatorStatusFactory = validatorStatusFactory; this.schemaDefinitions = schemaDefinitions; + this.maxEffectiveBalance = specConfig.getMaxEffectiveBalance(); + this.timeProvider = timeProvider; } /** @@ -98,6 +104,16 @@ public BeaconState processEpoch(final BeaconState preState) throws EpochProcessi protected void processEpoch(final BeaconState preState, final MutableBeaconState state) throws EpochProcessingException { + /* + WARNING: After Electra, it is possible that the validator set is updated within epoch processing + (process_pending_deposits). This means that the validator set in the state can get out of sync with + our validatorStatuses cache. This is not a problem for the current epoch processing, but it can cause + undesired side effects in the future. + + Up until Electra, the only function that uses validatorStatuses after process_pending_deposits is + process_effective_balance_updates, and in this particular case it is ok that we don't have the new validators + in validatorStatuses. + */ final ValidatorStatuses validatorStatuses = validatorStatusFactory.createValidatorStatuses(preState); @@ -116,6 +132,8 @@ protected void processEpoch(final BeaconState preState, final MutableBeaconState processRegistryUpdates(state, validatorStatuses.getStatuses()); processSlashings(state, validatorStatuses); processEth1DataReset(state); + processPendingDeposits(state); + processPendingConsolidations(state); processEffectiveBalanceUpdates(state, validatorStatuses.getStatuses()); processSlashingsReset(state); processRandaoMixesReset(state); @@ -125,7 +143,8 @@ protected void processEpoch(final BeaconState preState, final MutableBeaconState processSyncCommitteeUpdates(state); if (beaconStateAccessors.isInactivityLeak(state)) { - loggerThrottler.invoke(currentEpoch, (log) -> log.info("Beacon chain is in inactivity leak")); + loggerThrottler.invoke( + timeProvider.getTimeInSeconds(), (log) -> log.info("Beacon chain is in inactivity leak")); } } @@ -166,7 +185,8 @@ public BlockCheckpoints calculateBlockCheckpoints(final BeaconState preState) { /** Processes justification and finalization */ @Override public void processJustificationAndFinalization( - MutableBeaconState state, TotalBalances totalBalances) throws EpochProcessingException { + final MutableBeaconState state, final TotalBalances totalBalances) + throws EpochProcessingException { try { UInt64 currentEpoch = beaconStateAccessors.getCurrentEpoch(state); if (currentEpoch.isLessThanOrEqualTo(SpecConfig.GENESIS_EPOCH.plus(1))) { @@ -267,7 +287,7 @@ public void processInactivityUpdates( @Override public void processRewardsAndPenalties( - MutableBeaconState state, ValidatorStatuses validatorStatuses) + final MutableBeaconState state, final ValidatorStatuses validatorStatuses) throws EpochProcessingException { try { if (beaconStateAccessors.getCurrentEpoch(state).equals(SpecConfig.GENESIS_EPOCH)) { @@ -310,7 +330,6 @@ public void processRegistryUpdates( SszMutableList validators = state.getValidators(); final UInt64 currentEpoch = beaconStateAccessors.getCurrentEpoch(state); final UInt64 finalizedEpoch = state.getFinalizedCheckpoint().getEpoch(); - final UInt64 maxEffectiveBalance = specConfig.getMaxEffectiveBalance(); final UInt64 ejectionBalance = specConfig.getEjectionBalance(); final Supplier validatorExitContextSupplier = beaconStateMutators.createValidatorExitContextSupplier(state); @@ -318,12 +337,7 @@ public void processRegistryUpdates( for (int index = 0; index < validators.size(); index++) { final ValidatorStatus status = statuses.get(index); - // Slightly optimised form of isEligibleForActivationQueue to avoid accessing the - // state for the majority of validators. Can't be eligible for activation if already active - // or if effective balance is too low. Only get the validator if both those checks pass to - // confirm it isn't already in the queue. - if (!status.isActiveInCurrentEpoch() - && status.getCurrentEpochEffectiveBalance().equals(maxEffectiveBalance)) { + if (isEligibleForActivationQueue(status)) { final Validator validator = validators.get(index); if (validator.getActivationEligibilityEpoch().equals(SpecConfig.FAR_FUTURE_EPOCH)) { validators.set( @@ -381,10 +395,21 @@ public void processRegistryUpdates( } } + /** + * Can't be eligible for activation if already active or if effective balance is too low. + * + * @param status - Validator status + * @return true if validator is eligible to be added to the activation queue + */ + protected boolean isEligibleForActivationQueue(final ValidatorStatus status) { + return !status.isActiveInCurrentEpoch() + && status.getCurrentEpochEffectiveBalance().equals(maxEffectiveBalance); + } + /** Processes slashings */ @Override public void processSlashings( - MutableBeaconState state, final ValidatorStatuses validatorStatuses) { + final MutableBeaconState state, final ValidatorStatuses validatorStatuses) { final UInt64 totalBalance = validatorStatuses.getTotalBalances().getCurrentEpochActiveValidators(); final UInt64 epoch = beaconStateAccessors.getCurrentEpoch(state); @@ -453,8 +478,10 @@ public void processEffectiveBalanceUpdates( hysteresisUpwardMultiplier, maxEffectiveBalance)) { final Validator validator = validators.get(index); + final UInt64 effectiveBalanceLimit = getEffectiveBalanceLimitForValidator(validator); final UInt64 newEffectiveBalance = - balance.minus(balance.mod(effectiveBalanceIncrement)).min(maxEffectiveBalance); + effectiveBalanceLimit.min( + balance.minus(balance.mod(effectiveBalanceIncrement)).min(maxEffectiveBalance)); BeaconStateCache.getTransitionCaches(state) .getProgressiveTotalBalances() .onEffectiveBalanceChange(status, newEffectiveBalance); @@ -463,7 +490,11 @@ public void processEffectiveBalanceUpdates( } } - private boolean shouldIncreaseEffectiveBalance( + protected UInt64 getEffectiveBalanceLimitForValidator(final Validator validator) { + return specConfig.getMaxEffectiveBalance(); + } + + protected boolean shouldIncreaseEffectiveBalance( final UInt64 balance, final UInt64 hysteresisIncrement, final UInt64 currentEffectiveBalance, @@ -476,7 +507,7 @@ private boolean shouldIncreaseEffectiveBalance( && currentEffectiveBalance.plus(upwardThreshold).isLessThan(balance); } - private boolean shouldDecreaseEffectiveBalance( + protected boolean shouldDecreaseEffectiveBalance( final UInt64 balance, final UInt64 hysteresisIncrement, final UInt64 currentEffectiveBalance, diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/epoch/EpochProcessor.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/epoch/EpochProcessor.java index fdb58f3ccbc..5ee5cede085 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/epoch/EpochProcessor.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/epoch/EpochProcessor.java @@ -18,6 +18,7 @@ import tech.pegasys.teku.spec.datastructures.blocks.BlockCheckpoints; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.datastructures.state.beaconstate.MutableBeaconState; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingDeposit; import tech.pegasys.teku.spec.logic.common.statetransition.epoch.status.TotalBalances; import tech.pegasys.teku.spec.logic.common.statetransition.epoch.status.ValidatorStatus; import tech.pegasys.teku.spec.logic.common.statetransition.epoch.status.ValidatorStatuses; @@ -38,7 +39,7 @@ public interface EpochProcessor { * @see tech.pegasys.teku.spec.logic.common.statetransition.epoch.RewardsAndPenaltiesCalculator */ default RewardAndPenaltyDeltas getRewardAndPenaltyDeltas( - BeaconState state, ValidatorStatuses validatorStatuses) { + final BeaconState state, final ValidatorStatuses validatorStatuses) { return getRewardAndPenaltyDeltas( state, validatorStatuses, RewardsAndPenaltiesCalculator::getDeltas); } @@ -67,7 +68,7 @@ RewardAndPenaltyDeltas getRewardAndPenaltyDeltas( BeaconState processEpoch(BeaconState preState) throws EpochProcessingException; default void initProgressiveTotalBalancesIfRequired( - BeaconState state, TotalBalances totalBalances) {} + final BeaconState state, final TotalBalances totalBalances) {} BlockCheckpoints calculateBlockCheckpoints(BeaconState state); @@ -99,4 +100,10 @@ void processRegistryUpdates(MutableBeaconState state, List stat void processHistoricalSummariesUpdate(MutableBeaconState state); void processSyncCommitteeUpdates(MutableBeaconState state); + + void applyPendingDeposits(MutableBeaconState state, PendingDeposit deposit); + + void processPendingDeposits(MutableBeaconState state); + + void processPendingConsolidations(MutableBeaconState state); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/exceptions/BlockProcessingException.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/exceptions/BlockProcessingException.java index 4f2ba850db7..f1b977958b6 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/exceptions/BlockProcessingException.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/exceptions/BlockProcessingException.java @@ -14,15 +14,15 @@ package tech.pegasys.teku.spec.logic.common.statetransition.exceptions; public final class BlockProcessingException extends Exception { - public BlockProcessingException(String message, Exception cause) { + public BlockProcessingException(final String message, final Exception cause) { super(message, cause); } - public BlockProcessingException(String err) { + public BlockProcessingException(final String err) { super(err); } - public BlockProcessingException(Exception e) { + public BlockProcessingException(final Exception e) { super(e); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/exceptions/EpochProcessingException.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/exceptions/EpochProcessingException.java index 1f608aae111..871e5cb91bd 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/exceptions/EpochProcessingException.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/exceptions/EpochProcessingException.java @@ -14,11 +14,11 @@ package tech.pegasys.teku.spec.logic.common.statetransition.exceptions; public final class EpochProcessingException extends Exception { - public EpochProcessingException(String err) { + public EpochProcessingException(final String err) { super(err); } - public EpochProcessingException(RuntimeException e) { + public EpochProcessingException(final RuntimeException e) { super(e); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/exceptions/SlotProcessingException.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/exceptions/SlotProcessingException.java index ec3a12e6b0e..a471e978ae2 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/exceptions/SlotProcessingException.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/exceptions/SlotProcessingException.java @@ -14,11 +14,11 @@ package tech.pegasys.teku.spec.logic.common.statetransition.exceptions; public final class SlotProcessingException extends Exception { - public SlotProcessingException(String err) { + public SlotProcessingException(final String err) { super(err); } - public SlotProcessingException(Exception e) { + public SlotProcessingException(final Exception e) { super(e); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/exceptions/StateTransitionException.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/exceptions/StateTransitionException.java index c6d9d386f90..f6731d7f95c 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/exceptions/StateTransitionException.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/exceptions/StateTransitionException.java @@ -17,11 +17,11 @@ public class StateTransitionException extends Exception { public StateTransitionException() {} - public StateTransitionException(String message) { + public StateTransitionException(final String message) { super(message); } - public StateTransitionException(Throwable e) { + public StateTransitionException(final Throwable e) { super(e); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/results/BlockImportResult.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/results/BlockImportResult.java index 3a39a95c99d..a2898c89b3d 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/results/BlockImportResult.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/results/BlockImportResult.java @@ -16,6 +16,7 @@ import java.util.Optional; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; +@SuppressWarnings("ClassInitializationDeadlock") public interface BlockImportResult { BlockImportResult FAILED_BLOCK_IS_FROM_FUTURE = new FailedBlockImportResult(FailureReason.BLOCK_IS_FROM_FUTURE, Optional.empty()); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/results/OptimisticSuccessfulBlockImportResult.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/results/OptimisticSuccessfulBlockImportResult.java index dba6271323e..b323a8f9e03 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/results/OptimisticSuccessfulBlockImportResult.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/statetransition/results/OptimisticSuccessfulBlockImportResult.java @@ -17,7 +17,7 @@ public class OptimisticSuccessfulBlockImportResult extends SuccessfulBlockImportResult { - public OptimisticSuccessfulBlockImportResult(SignedBeaconBlock block) { + public OptimisticSuccessfulBlockImportResult(final SignedBeaconBlock block) { super(block); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/AsyncBLSSignatureVerifier.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/AsyncBLSSignatureVerifier.java index 5528ecef448..ff7c505c66f 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/AsyncBLSSignatureVerifier.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/AsyncBLSSignatureVerifier.java @@ -22,7 +22,7 @@ import tech.pegasys.teku.infrastructure.async.SafeFuture; public interface AsyncBLSSignatureVerifier { - static AsyncBLSSignatureVerifier wrap(BLSSignatureVerifier syncVerifier) { + static AsyncBLSSignatureVerifier wrap(final BLSSignatureVerifier syncVerifier) { return new AsyncBLSSignatureVerifier() { @Override public SafeFuture verify( @@ -55,7 +55,7 @@ public SafeFuture verify( /** Shortcut to {@link #verify(List, Bytes, BLSSignature)} for non-aggregate case */ default SafeFuture verify( - BLSPublicKey publicKey, Bytes message, BLSSignature signature) { + final BLSPublicKey publicKey, final Bytes message, final BLSSignature signature) { return verify(Collections.singletonList(publicKey), message, signature); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/AttestationUtil.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/AttestationUtil.java index 39e1371b4b0..5da5b45f023 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/AttestationUtil.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/AttestationUtil.java @@ -38,10 +38,9 @@ import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlockSummary; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.AttestationContainer; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestation; -import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestation.IndexedAttestationSchema; +import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestationSchema; import tech.pegasys.teku.spec.datastructures.state.Checkpoint; import tech.pegasys.teku.spec.datastructures.state.Fork; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; @@ -103,6 +102,7 @@ public IndexedAttestation getIndexedAttestation( final IndexedAttestationSchema indexedAttestationSchema = schemaDefinitions.getIndexedAttestationSchema(); + return indexedAttestationSchema.create( attestingIndices.stream() .sorted() @@ -122,15 +122,14 @@ public IndexedAttestation getIndexedAttestation( * @see * https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/beacon-chain.md#get_attesting_indices */ - public IntList getAttestingIndices( - final BeaconState state, final AttestationContainer attestation) { - return IntList.of(streamAttestingIndices(state, attestation).toArray()); + public IntList getAttestingIndices(final BeaconState state, final Attestation attestation) { + return IntList.of( + streamAttestingIndices(state, attestation.getData(), attestation.getAggregationBits()) + .toArray()); } public IntStream streamAttestingIndices( - final BeaconState state, final AttestationContainer attestation) { - final AttestationData data = attestation.getData(); - final SszBitlist aggregationBits = attestation.getAggregationBits(); + final BeaconState state, final AttestationData data, final SszBitlist aggregationBits) { final IntList committee = beaconStateAccessors.getBeaconCommittee(state, data.getSlot(), data.getIndex()); checkArgument( @@ -188,7 +187,7 @@ public SafeFuture isValidIndexedAttestationAsync( .thenApply( result -> { if (result.isSuccessful()) { - attestation.saveCommitteeShufflingSeed(state); + attestation.saveCommitteeShufflingSeedAndCommitteesSize(state); attestation.setValidIndexedAttestation(); } return result; diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/BeaconStateUtil.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/BeaconStateUtil.java index 901dcf47f05..a33701b3852 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/BeaconStateUtil.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/BeaconStateUtil.java @@ -60,12 +60,12 @@ public BeaconStateUtil( this.beaconStateAccessors = beaconStateAccessors; } - public boolean isValidGenesisState(UInt64 genesisTime, int activeValidatorCount) { + public boolean isValidGenesisState(final UInt64 genesisTime, final int activeValidatorCount) { return isItMinGenesisTimeYet(genesisTime) && isThereEnoughNumberOfValidators(activeValidatorCount); } - private boolean isThereEnoughNumberOfValidators(int activeValidatorCount) { + private boolean isThereEnoughNumberOfValidators(final int activeValidatorCount) { return activeValidatorCount >= specConfig.getMinGenesisActiveValidatorCount(); } @@ -80,11 +80,11 @@ public UInt64 computeNextEpochBoundary(final UInt64 slot) { : currentEpoch.plus(1); } - public Bytes32 getPreviousDutyDependentRoot(BeaconState state) { + public Bytes32 getPreviousDutyDependentRoot(final BeaconState state) { return getDutyDependentRoot(state, beaconStateAccessors.getPreviousEpoch(state)); } - public Bytes32 getCurrentDutyDependentRoot(BeaconState state) { + public Bytes32 getCurrentDutyDependentRoot(final BeaconState state) { return getDutyDependentRoot(state, beaconStateAccessors.getCurrentEpoch(state)); } @@ -150,7 +150,7 @@ public List getEffectiveActiveUnslashedBalances(final BeaconState state) .toList()); } - public boolean all(SszBitvector bitvector, int start, int end) { + public boolean all(final SszBitvector bitvector, final int start, final int end) { for (int i = start; i < end; i++) { if (!bitvector.getBit(i)) { return false; @@ -187,7 +187,7 @@ private Stream streamEffectiveBalancesForCommittee( public int computeSubnetForAttestation(final BeaconState state, final Attestation attestation) { final UInt64 attestationSlot = attestation.getData().getSlot(); - final UInt64 committeeIndex = attestation.getData().getIndex(); + final UInt64 committeeIndex = attestation.getFirstCommitteeIndex(); return computeSubnetForCommittee(state, attestationSlot, committeeIndex); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/BlockRewardCalculatorUtil.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/BlockRewardCalculatorUtil.java index fb75e0a97d8..c1e229ddb26 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/BlockRewardCalculatorUtil.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/BlockRewardCalculatorUtil.java @@ -48,7 +48,7 @@ public class BlockRewardCalculatorUtil { private final Spec spec; private static final Logger LOG = LogManager.getLogger(); - public BlockRewardCalculatorUtil(Spec spec) { + public BlockRewardCalculatorUtil(final Spec spec) { this.spec = spec; } @@ -123,7 +123,8 @@ long calculateAttesterSlashingsRewards( } @VisibleForTesting - long calculateProposerSyncAggregateBlockRewards(long proposerReward, SyncAggregate aggregate) { + long calculateProposerSyncAggregateBlockRewards( + final long proposerReward, final SyncAggregate aggregate) { final SszBitvector syncCommitteeBits = aggregate.getSyncCommitteeBits(); return proposerReward * syncCommitteeBits.getBitCount(); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/EpochAttestationSchedule.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/EpochAttestationSchedule.java index 4b30f39f39b..e5ebf1185e6 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/EpochAttestationSchedule.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/EpochAttestationSchedule.java @@ -29,7 +29,7 @@ public static Builder builder() { return new Builder(); } - public SlotAttestationSchedule atSlot(UInt64 assignedSlot) { + public SlotAttestationSchedule atSlot(final UInt64 assignedSlot) { return slotSchedule.get(assignedSlot); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/ForkChoiceUtil.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/ForkChoiceUtil.java index 2593ad0c86d..859b5fe6e81 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/ForkChoiceUtil.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/ForkChoiceUtil.java @@ -67,20 +67,21 @@ public ForkChoiceUtil( this.miscHelpers = miscHelpers; } - public UInt64 getSlotsSinceGenesis(ReadOnlyStore store, boolean useUnixTime) { + public UInt64 getSlotsSinceGenesis(final ReadOnlyStore store, final boolean useUnixTime) { UInt64 time = useUnixTime ? UInt64.valueOf(Instant.now().getEpochSecond()) : store.getTimeSeconds(); return getCurrentSlot(time, store.getGenesisTime()); } - public UInt64 getCurrentSlot(UInt64 currentTime, UInt64 genesisTime) { + public UInt64 getCurrentSlot(final UInt64 currentTime, final UInt64 genesisTime) { if (currentTime.isLessThan(genesisTime)) { return UInt64.ZERO; } return currentTime.minus(genesisTime).dividedBy(specConfig.getSecondsPerSlot()); } - public UInt64 getCurrentSlotForMillis(UInt64 currentTimeMillis, UInt64 genesisTimeMillis) { + public UInt64 getCurrentSlotForMillis( + final UInt64 currentTimeMillis, final UInt64 genesisTimeMillis) { if (currentTimeMillis.isLessThan(genesisTimeMillis)) { return UInt64.ZERO; } @@ -89,24 +90,24 @@ public UInt64 getCurrentSlotForMillis(UInt64 currentTimeMillis, UInt64 genesisTi .dividedBy(specConfig.getSecondsPerSlot() * MILLIS_PER_SECOND.longValue()); } - public UInt64 getSlotStartTime(UInt64 slotNumber, UInt64 genesisTime) { + public UInt64 getSlotStartTime(final UInt64 slotNumber, final UInt64 genesisTime) { return genesisTime.plus(slotNumber.times(specConfig.getSecondsPerSlot())); } - public UInt64 getSlotStartTimeMillis(UInt64 slotNumber, UInt64 genesisTimeMillis) { + public UInt64 getSlotStartTimeMillis(final UInt64 slotNumber, final UInt64 genesisTimeMillis) { return genesisTimeMillis.plus( slotNumber.times(specConfig.getSecondsPerSlot() * MILLIS_PER_SECOND.longValue())); } - public UInt64 getCurrentSlot(ReadOnlyStore store, boolean useUnixTime) { + public UInt64 getCurrentSlot(final ReadOnlyStore store, final boolean useUnixTime) { return SpecConfig.GENESIS_SLOT.plus(getSlotsSinceGenesis(store, useUnixTime)); } - public UInt64 getCurrentSlot(ReadOnlyStore store) { + public UInt64 getCurrentSlot(final ReadOnlyStore store) { return getCurrentSlot(store, false); } - public UInt64 computeSlotsSinceEpochStart(UInt64 slot) { + public UInt64 computeSlotsSinceEpochStart(final UInt64 slot) { final UInt64 epoch = miscHelpers.computeEpochAtSlot(slot); final UInt64 epochStartSlot = miscHelpers.computeStartSlotAtEpoch(epoch); return slot.minus(epochStartSlot); @@ -123,19 +124,19 @@ public UInt64 computeSlotsSinceEpochStart(UInt64 slot) { * https://github.com/ethereum/consensus-specs/blob/v0.10.1/specs/phase0/fork-choice.md#get_ancestor */ public Optional getAncestor( - ReadOnlyForkChoiceStrategy forkChoiceStrategy, Bytes32 root, UInt64 slot) { + final ReadOnlyForkChoiceStrategy forkChoiceStrategy, final Bytes32 root, final UInt64 slot) { return forkChoiceStrategy.getAncestor(root, slot); } public NavigableMap getAncestors( - ReadOnlyForkChoiceStrategy forkChoiceStrategy, - Bytes32 root, - UInt64 startSlot, - UInt64 step, - UInt64 count) { + final ReadOnlyForkChoiceStrategy forkChoiceStrategy, + final Bytes32 root, + final UInt64 startSlot, + final UInt64 step, + final UInt64 count) { final NavigableMap roots = new TreeMap<>(); // minus(ONE) because the start block is included - final UInt64 endSlot = startSlot.plus(step.times(count)).minus(UInt64.ONE); + final UInt64 endSlot = startSlot.plus(step.times(count)).minusMinZero(1); Bytes32 parentRoot = root; Optional parentSlot = forkChoiceStrategy.blockSlot(parentRoot); while (parentSlot.isPresent() && parentSlot.get().compareTo(startSlot) > 0) { @@ -155,7 +156,9 @@ public NavigableMap getAncestors( * backwards */ public NavigableMap getAncestorsOnFork( - ReadOnlyForkChoiceStrategy forkChoiceStrategy, Bytes32 root, UInt64 startSlot) { + final ReadOnlyForkChoiceStrategy forkChoiceStrategy, + final Bytes32 root, + final UInt64 startSlot) { final NavigableMap roots = new TreeMap<>(); Bytes32 parentRoot = root; Optional parentSlot = forkChoiceStrategy.blockSlot(parentRoot); @@ -366,7 +369,7 @@ public AttestationProcessingResult validateOnAttestation( } private AttestationProcessingResult checkIfAttestationShouldBeSavedForFuture( - ReadOnlyStore store, Attestation attestation) { + final ReadOnlyStore store, final Attestation attestation) { // Attestations can only affect the fork choice of subsequent slots. // Delay consideration in the fork choice until their slot is in the past. @@ -460,7 +463,7 @@ public BlockImportResult checkOnBlockConditions( return BlockImportResult.successful(block); } - private boolean blockIsFromFuture(ReadOnlyStore store, final UInt64 blockSlot) { + private boolean blockIsFromFuture(final ReadOnlyStore store, final UInt64 blockSlot) { return getCurrentSlot(store).compareTo(blockSlot) < 0; } @@ -487,10 +490,10 @@ private boolean blockIsAfterLatestFinalizedSlot( } private boolean hasAncestorAtSlot( - ReadOnlyForkChoiceStrategy forkChoiceStrategy, - Bytes32 root, - UInt64 slot, - Bytes32 ancestorRoot) { + final ReadOnlyForkChoiceStrategy forkChoiceStrategy, + final Bytes32 root, + final UInt64 slot, + final Bytes32 ancestorRoot) { return getAncestor(forkChoiceStrategy, root, slot) .map(ancestorAtSlot -> ancestorAtSlot.equals(ancestorRoot)) .orElse(false); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/SyncCommitteeUtil.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/SyncCommitteeUtil.java index 365687ce9c1..e05a7de0c71 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/SyncCommitteeUtil.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/SyncCommitteeUtil.java @@ -155,9 +155,9 @@ public SyncSubcommitteeAssignments getSubcommitteeAssignments( } public int getCurrentSyncCommitteeParticipantValidatorIndex( - final BeaconStateAltair state, final int commiteeIndex) { + final BeaconStateAltair state, final int committeeIndex) { final BLSPublicKey uncachedPubkey = - state.getCurrentSyncCommittee().getPubkeys().get(commiteeIndex).getBLSPublicKey(); + state.getCurrentSyncCommittee().getPubkeys().get(committeeIndex).getBLSPublicKey(); return validatorsUtil .getValidatorIndex(state, uncachedPubkey) .orElseThrow( diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/ValidatorsUtil.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/ValidatorsUtil.java index 0200f8e48a0..c9e5d5d0941 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/ValidatorsUtil.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/ValidatorsUtil.java @@ -16,9 +16,9 @@ import static com.google.common.base.Preconditions.checkArgument; import static tech.pegasys.teku.spec.logic.common.helpers.MathHelpers.bytesToUInt64; +import it.unimi.dsi.fastutil.ints.Int2ObjectMap; +import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap; import it.unimi.dsi.fastutil.ints.IntList; -import java.util.HashMap; -import java.util.Map; import java.util.Optional; import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.bls.BLSSignature; @@ -30,6 +30,7 @@ import tech.pegasys.teku.spec.datastructures.state.Validator; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconStateCache; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingPartialWithdrawal; import tech.pegasys.teku.spec.logic.common.helpers.BeaconStateAccessors; import tech.pegasys.teku.spec.logic.common.helpers.MiscHelpers; @@ -52,7 +53,8 @@ public boolean isEligibleForActivation(final UInt64 finalizedEpoch, final Valida && validator.getActivationEpoch().equals(SpecConfig.FAR_FUTURE_EPOCH); } - public Optional getValidatorIndex(BeaconState state, BLSPublicKey publicKey) { + public Optional getValidatorIndex( + final BeaconState state, final BLSPublicKey publicKey) { return BeaconStateCache.getTransitionCaches(state) .getValidatorIndexCache() .getValidatorIndex(state, publicKey); @@ -75,9 +77,9 @@ public Optional getCommitteeAssignment( state, epoch, validatorIndex, beaconStateAccessors.getCommitteeCountPerSlot(state, epoch)); } - public Map getValidatorIndexToCommitteeAssignmentMap( + public Int2ObjectMap getValidatorIndexToCommitteeAssignmentMap( final BeaconState state, final UInt64 epoch) { - final Map assignmentMap = new HashMap<>(); + final Int2ObjectMap assignmentMap = new Int2ObjectOpenHashMap<>(); final int slotsPerEpoch = specConfig.getSlotsPerEpoch(); final int committeeCountPerSlot = @@ -160,4 +162,12 @@ public boolean isAggregator(final BLSSignature slotSignature, final int modulo) public int getAggregatorModulo(final int committeeSize) { return Math.max(1, committeeSize / ValidatorConstants.TARGET_AGGREGATORS_PER_COMMITTEE); } + + public UInt64 getPendingBalanceToWithdraw(final BeaconState state, final int validatorIndex) { + return state.toVersionElectra().orElseThrow().getPendingPartialWithdrawals().stream() + .filter(withdrawal -> withdrawal.getIndex() == validatorIndex) + .map(PendingPartialWithdrawal::getAmount) + .reduce(UInt64::plus) + .orElse(UInt64.ZERO); + } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/SpecLogicAltair.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/SpecLogicAltair.java index 62062a794d7..a216b593035 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/SpecLogicAltair.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/SpecLogicAltair.java @@ -14,6 +14,7 @@ package tech.pegasys.teku.spec.logic.versions.altair; import java.util.Optional; +import tech.pegasys.teku.infrastructure.time.TimeProvider; import tech.pegasys.teku.spec.config.SpecConfigAltair; import tech.pegasys.teku.spec.logic.common.AbstractSpecLogic; import tech.pegasys.teku.spec.logic.common.helpers.BeaconStateMutators; @@ -38,6 +39,7 @@ import tech.pegasys.teku.spec.logic.versions.bellatrix.helpers.BellatrixTransitionHelpers; import tech.pegasys.teku.spec.logic.versions.phase0.operations.validation.AttestationDataValidatorPhase0; import tech.pegasys.teku.spec.logic.versions.phase0.operations.validation.OperationValidatorPhase0; +import tech.pegasys.teku.spec.logic.versions.phase0.operations.validation.VoluntaryExitValidator; import tech.pegasys.teku.spec.logic.versions.phase0.util.AttestationUtilPhase0; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsAltair; @@ -85,7 +87,9 @@ private SpecLogicAltair( } public static SpecLogicAltair create( - final SpecConfigAltair config, final SchemaDefinitionsAltair schemaDefinitions) { + final SpecConfigAltair config, + final SchemaDefinitionsAltair schemaDefinitions, + final TimeProvider timeProvider) { // Helpers final Predicates predicates = new Predicates(config); final MiscHelpersAltair miscHelpers = new MiscHelpersAltair(config); @@ -110,9 +114,15 @@ public static SpecLogicAltair create( // execution change final AttestationDataValidator attestationDataValidator = new AttestationDataValidatorPhase0(config, miscHelpers, beaconStateAccessors); + final VoluntaryExitValidator voluntaryExitValidator = + new VoluntaryExitValidator(config, predicates, beaconStateAccessors); final OperationValidator operationValidator = new OperationValidatorPhase0( - config, predicates, beaconStateAccessors, attestationDataValidator, attestationUtil); + predicates, + beaconStateAccessors, + attestationDataValidator, + attestationUtil, + voluntaryExitValidator); final ValidatorStatusFactoryAltair validatorStatusFactory = new ValidatorStatusFactoryAltair( config, @@ -130,7 +140,8 @@ public static SpecLogicAltair create( validatorsUtil, beaconStateUtil, validatorStatusFactory, - schemaDefinitions); + schemaDefinitions, + timeProvider); final SyncCommitteeUtil syncCommitteeUtil = new SyncCommitteeUtil( beaconStateAccessors, validatorsUtil, config, miscHelpers, schemaDefinitions); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/block/BlockProcessorAltair.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/block/BlockProcessorAltair.java index 8fab58322b4..7f315226e5d 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/block/BlockProcessorAltair.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/block/BlockProcessorAltair.java @@ -43,8 +43,8 @@ import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.SyncAggregate; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSummary; +import tech.pegasys.teku.spec.datastructures.execution.ExpectedWithdrawals; import tech.pegasys.teku.spec.datastructures.execution.NewPayloadRequest; -import tech.pegasys.teku.spec.datastructures.execution.versions.capella.Withdrawal; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChange; @@ -213,20 +213,6 @@ public Optional processAttestationProposerReward( return Optional.empty(); } - @Override - protected void addValidatorToRegistry( - final MutableBeaconState state, - final BLSPublicKey pubkey, - final Bytes32 withdrawalCredentials, - final UInt64 amount) { - super.addValidatorToRegistry(state, pubkey, withdrawalCredentials, amount); - final MutableBeaconStateAltair stateAltair = MutableBeaconStateAltair.required(state); - - stateAltair.getPreviousEpochParticipation().append(SszByte.ZERO); - stateAltair.getCurrentEpochParticipation().append(SszByte.ZERO); - stateAltair.getInactivityScores().append(SszUInt64.ZERO); - } - @Override public void processSyncAggregate( final MutableBeaconState baseState, @@ -282,7 +268,7 @@ public void processSyncAggregate( } @Override - public UInt64 computeParticipantReward(BeaconStateAltair state) { + public UInt64 computeParticipantReward(final BeaconStateAltair state) { final UInt64 totalActiveIncrements = beaconStateAccessors .getTotalActiveBalance(state) @@ -351,15 +337,15 @@ public void processWithdrawals( } @Override - public Optional> getExpectedWithdrawals(final BeaconState preState) { - return Optional.empty(); + public ExpectedWithdrawals getExpectedWithdrawals(final BeaconState preState) { + return ExpectedWithdrawals.NOOP; } public static boolean eth2FastAggregateVerify( final BLSSignatureVerifier signatureVerifier, - List pubkeys, - Bytes32 message, - BLSSignature signature) { + final List pubkeys, + final Bytes32 message, + final BLSSignature signature) { // BLS verify logic would throw if we pass in an empty list of public keys, // so if the keys list is empty, return the isInfinity of the signature. // this is equivalent to the spec, and removes the possibility of an empty list diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/forktransition/AltairStateUpgrade.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/forktransition/AltairStateUpgrade.java index 87d84395f8c..355c02d1e52 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/forktransition/AltairStateUpgrade.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/forktransition/AltairStateUpgrade.java @@ -60,9 +60,7 @@ public BeaconStateAltair upgrade(final BeaconState preState) { final UInt64 epoch = beaconStateAccessors.getCurrentEpoch(preState); final int validatorCount = preState.getValidators().size(); - return schemaDefinitions - .getBeaconStateSchema() - .createEmpty() + return BeaconStateAltair.required(schemaDefinitions.getBeaconStateSchema().createEmpty()) .updatedAltair( state -> { BeaconStateFields.copyCommonFieldsFromSource(state, preState); @@ -102,7 +100,7 @@ private void translateParticipation( // Apply flags to all attesting validators final SszMutableList epochParticipation = state.getPreviousEpochParticipation(); attestationUtil - .streamAttestingIndices(state, attestation) + .streamAttestingIndices(state, attestation.getData(), attestation.getAggregationBits()) .forEach( index -> { final byte previousFlags = epochParticipation.get(index).get(); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/helpers/BeaconStateAccessorsAltair.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/helpers/BeaconStateAccessorsAltair.java index 592776c6fbd..d8826b49ecc 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/helpers/BeaconStateAccessorsAltair.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/helpers/BeaconStateAccessorsAltair.java @@ -98,6 +98,11 @@ public UInt64 getBaseReward(final BeaconState state, final int validatorIndex) { * @return the sequence of sync committee indices */ public IntList getNextSyncCommitteeIndices(final BeaconState state) { + return getNextSyncCommitteeIndices(state, config.getMaxEffectiveBalance()); + } + + protected IntList getNextSyncCommitteeIndices( + final BeaconState state, final UInt64 maxEffectiveBalance) { final UInt64 epoch = getCurrentEpoch(state).plus(1); final IntList activeValidatorIndices = getActiveValidatorIndices(state, epoch); final int activeValidatorCount = activeValidatorIndices.size(); @@ -107,7 +112,6 @@ public IntList getNextSyncCommitteeIndices(final BeaconState state) { int i = 0; final SszList validators = state.getValidators(); final IntList syncCommitteeIndices = new IntArrayList(); - final UInt64 maxEffectiveBalance = config.getMaxEffectiveBalance(); final int syncCommitteeSize = altairConfig.getSyncCommitteeSize(); final Sha256 sha256 = getSha256Instance(); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/helpers/BeaconStateMutatorsAltair.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/helpers/BeaconStateMutatorsAltair.java index 96dbbdd4859..4af34b7ed14 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/helpers/BeaconStateMutatorsAltair.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/helpers/BeaconStateMutatorsAltair.java @@ -17,10 +17,15 @@ import static tech.pegasys.teku.spec.constants.IncentivizationWeights.WEIGHT_DENOMINATOR; import java.util.function.Supplier; +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszByte; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.config.SpecConfigAltair; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconStateCache; import tech.pegasys.teku.spec.datastructures.state.beaconstate.MutableBeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.altair.MutableBeaconStateAltair; import tech.pegasys.teku.spec.logic.common.helpers.BeaconStateAccessors; import tech.pegasys.teku.spec.logic.common.helpers.BeaconStateMutators; import tech.pegasys.teku.spec.logic.common.helpers.MiscHelpers; @@ -36,6 +41,20 @@ public BeaconStateMutatorsAltair( this.specConfigAltair = specConfig; } + @Override + public void addValidatorToRegistry( + final MutableBeaconState state, + final BLSPublicKey pubkey, + final Bytes32 withdrawalCredentials, + final UInt64 amount) { + super.addValidatorToRegistry(state, pubkey, withdrawalCredentials, amount); + final MutableBeaconStateAltair stateAltair = MutableBeaconStateAltair.required(state); + + stateAltair.getPreviousEpochParticipation().append(SszByte.ZERO); + stateAltair.getCurrentEpochParticipation().append(SszByte.ZERO); + stateAltair.getInactivityScores().append(SszUInt64.ZERO); + } + @Override protected UInt64 calculateProposerReward(final UInt64 whistleblowerReward) { return whistleblowerReward.times(PROPOSER_WEIGHT).dividedBy(WEIGHT_DENOMINATOR); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/statetransition/epoch/EpochProcessorAltair.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/statetransition/epoch/EpochProcessorAltair.java index 6622bbc3764..ee3c9fb249e 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/statetransition/epoch/EpochProcessorAltair.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/statetransition/epoch/EpochProcessorAltair.java @@ -20,6 +20,7 @@ import tech.pegasys.teku.infrastructure.ssz.SszMutableList; import tech.pegasys.teku.infrastructure.ssz.collections.SszMutableUInt64List; import tech.pegasys.teku.infrastructure.ssz.primitive.SszByte; +import tech.pegasys.teku.infrastructure.time.TimeProvider; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.config.SpecConfigAltair; @@ -29,6 +30,7 @@ import tech.pegasys.teku.spec.datastructures.state.beaconstate.common.TransitionCaches; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.altair.BeaconStateAltair; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.altair.MutableBeaconStateAltair; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingDeposit; import tech.pegasys.teku.spec.logic.common.helpers.BeaconStateMutators; import tech.pegasys.teku.spec.logic.common.statetransition.epoch.AbstractEpochProcessor; import tech.pegasys.teku.spec.logic.common.statetransition.epoch.RewardAndPenaltyDeltas; @@ -60,7 +62,8 @@ public EpochProcessorAltair( final ValidatorsUtil validatorsUtil, final BeaconStateUtil beaconStateUtil, final ValidatorStatusFactory validatorStatusFactory, - final SchemaDefinitions schemaDefinitions) { + final SchemaDefinitions schemaDefinitions, + final TimeProvider timeProvider) { super( specConfig, miscHelpers, @@ -69,7 +72,8 @@ public EpochProcessorAltair( validatorsUtil, beaconStateUtil, validatorStatusFactory, - schemaDefinitions); + schemaDefinitions, + timeProvider); this.specConfigAltair = specConfig; this.miscHelpersAltair = miscHelpers; this.beaconStateAccessorsAltair = beaconStateAccessors; @@ -129,6 +133,21 @@ public void processSyncCommitteeUpdates(final MutableBeaconState genericState) { } } + @Override + public void applyPendingDeposits(final MutableBeaconState state, final PendingDeposit deposit) { + // Nothing to do + } + + @Override + public void processPendingDeposits(final MutableBeaconState state) { + // Nothing to do + } + + @Override + public void processPendingConsolidations(final MutableBeaconState state) { + // Nothing to do + } + /** * Replaces the progressive total balances in the state transition caches with an altair one if * not already in use. This handles both upgrading on milestone transition and switching from the diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/statetransition/epoch/RewardsAndPenaltiesCalculatorAltair.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/statetransition/epoch/RewardsAndPenaltiesCalculatorAltair.java index 0632b99526e..d768cb946dc 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/statetransition/epoch/RewardsAndPenaltiesCalculatorAltair.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/altair/statetransition/epoch/RewardsAndPenaltiesCalculatorAltair.java @@ -129,17 +129,13 @@ public void processFlagIndexDeltas(final RewardAndPenaltyDeltas deltas, final in } } - private RewardComponent getComponentForParticipationFlagIndex(int index) { - switch (index) { - case 0: - return RewardComponent.SOURCE; - case 1: - return RewardComponent.TARGET; - case 2: - return RewardComponent.HEAD; - } - - throw new IllegalArgumentException("Invalid participation flag index " + index); + private RewardComponent getComponentForParticipationFlagIndex(final int index) { + return switch (index) { + case 0 -> RewardComponent.SOURCE; + case 1 -> RewardComponent.TARGET; + case 2 -> RewardComponent.HEAD; + default -> throw new IllegalArgumentException("Invalid participation flag index " + index); + }; } /** diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/bellatrix/SpecLogicBellatrix.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/bellatrix/SpecLogicBellatrix.java index 0db09a51ee8..a68522b0496 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/bellatrix/SpecLogicBellatrix.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/bellatrix/SpecLogicBellatrix.java @@ -14,6 +14,7 @@ package tech.pegasys.teku.spec.logic.versions.bellatrix; import java.util.Optional; +import tech.pegasys.teku.infrastructure.time.TimeProvider; import tech.pegasys.teku.spec.config.SpecConfigBellatrix; import tech.pegasys.teku.spec.logic.common.AbstractSpecLogic; import tech.pegasys.teku.spec.logic.common.helpers.Predicates; @@ -39,6 +40,7 @@ import tech.pegasys.teku.spec.logic.versions.bellatrix.util.BlindBlockUtilBellatrix; import tech.pegasys.teku.spec.logic.versions.phase0.operations.validation.AttestationDataValidatorPhase0; import tech.pegasys.teku.spec.logic.versions.phase0.operations.validation.OperationValidatorPhase0; +import tech.pegasys.teku.spec.logic.versions.phase0.operations.validation.VoluntaryExitValidator; import tech.pegasys.teku.spec.logic.versions.phase0.util.AttestationUtilPhase0; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsBellatrix; @@ -91,7 +93,9 @@ private SpecLogicBellatrix( } public static SpecLogicBellatrix create( - final SpecConfigBellatrix config, final SchemaDefinitionsBellatrix schemaDefinitions) { + final SpecConfigBellatrix config, + final SchemaDefinitionsBellatrix schemaDefinitions, + final TimeProvider timeProvider) { // Helpers final Predicates predicates = new Predicates(config); final MiscHelpersBellatrix miscHelpers = new MiscHelpersBellatrix(config); @@ -114,9 +118,15 @@ public static SpecLogicBellatrix create( new AttestationUtilPhase0(config, schemaDefinitions, beaconStateAccessors, miscHelpers); final AttestationDataValidator attestationDataValidator = new AttestationDataValidatorPhase0(config, miscHelpers, beaconStateAccessors); + final VoluntaryExitValidator voluntaryExitValidator = + new VoluntaryExitValidator(config, predicates, beaconStateAccessors); final OperationValidator operationValidator = new OperationValidatorPhase0( - config, predicates, beaconStateAccessors, attestationDataValidator, attestationUtil); + predicates, + beaconStateAccessors, + attestationDataValidator, + attestationUtil, + voluntaryExitValidator); final ValidatorStatusFactoryAltair validatorStatusFactory = new ValidatorStatusFactoryAltair( config, @@ -134,7 +144,8 @@ public static SpecLogicBellatrix create( validatorsUtil, beaconStateUtil, validatorStatusFactory, - schemaDefinitions); + schemaDefinitions, + timeProvider); final SyncCommitteeUtil syncCommitteeUtil = new SyncCommitteeUtil( beaconStateAccessors, validatorsUtil, config, miscHelpers, schemaDefinitions); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/bellatrix/block/BlockProcessorBellatrix.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/bellatrix/block/BlockProcessorBellatrix.java index d5b0c3f1a29..1998fc8292e 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/bellatrix/block/BlockProcessorBellatrix.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/bellatrix/block/BlockProcessorBellatrix.java @@ -101,7 +101,8 @@ public void processBlock( } processRandaoNoValidation(state, block.getBody()); processEth1Data(state, block.getBody()); - processOperationsNoValidation(state, block.getBody(), indexedAttestationCache); + processOperationsNoValidation( + state, block.getBody(), indexedAttestationCache, getValidatorExitContextSupplier(state)); processSyncAggregate( state, blockBody.getOptionalSyncAggregate().orElseThrow(), signatureVerifier); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/bellatrix/forktransition/BellatrixStateUpgrade.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/bellatrix/forktransition/BellatrixStateUpgrade.java index a79d89a82a6..2788d1be564 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/bellatrix/forktransition/BellatrixStateUpgrade.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/bellatrix/forktransition/BellatrixStateUpgrade.java @@ -43,9 +43,7 @@ public BeaconStateBellatrix upgrade(final BeaconState preState) { final UInt64 epoch = beaconStateAccessors.getCurrentEpoch(preState); BeaconStateAltair preStateAltair = BeaconStateAltair.required(preState); - return schemaDefinitions - .getBeaconStateSchema() - .createEmpty() + return BeaconStateBellatrix.required(schemaDefinitions.getBeaconStateSchema().createEmpty()) .updatedBellatrix( state -> { BeaconStateFields.copyCommonFieldsFromSource(state, preState); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/bellatrix/statetransition/epoch/EpochProcessorBellatrix.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/bellatrix/statetransition/epoch/EpochProcessorBellatrix.java index 87cae7c9279..3c68a1f6362 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/bellatrix/statetransition/epoch/EpochProcessorBellatrix.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/bellatrix/statetransition/epoch/EpochProcessorBellatrix.java @@ -13,6 +13,7 @@ package tech.pegasys.teku.spec.logic.versions.bellatrix.statetransition.epoch; +import tech.pegasys.teku.infrastructure.time.TimeProvider; import tech.pegasys.teku.spec.config.SpecConfigBellatrix; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.bellatrix.BeaconStateBellatrix; @@ -39,7 +40,8 @@ public EpochProcessorBellatrix( final ValidatorsUtil validatorsUtil, final BeaconStateUtil beaconStateUtil, final ValidatorStatusFactory validatorStatusFactory, - final SchemaDefinitions schemaDefinitions) { + final SchemaDefinitions schemaDefinitions, + final TimeProvider timeProvider) { super( specConfig, miscHelpers, @@ -48,7 +50,8 @@ public EpochProcessorBellatrix( validatorsUtil, beaconStateUtil, validatorStatusFactory, - schemaDefinitions); + schemaDefinitions, + timeProvider); specConfigBellatrix = specConfig; } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/capella/SpecLogicCapella.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/capella/SpecLogicCapella.java index c69086e2500..fd7aa210f36 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/capella/SpecLogicCapella.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/capella/SpecLogicCapella.java @@ -14,6 +14,7 @@ package tech.pegasys.teku.spec.logic.versions.capella; import java.util.Optional; +import tech.pegasys.teku.infrastructure.time.TimeProvider; import tech.pegasys.teku.spec.config.SpecConfigCapella; import tech.pegasys.teku.spec.logic.common.AbstractSpecLogic; import tech.pegasys.teku.spec.logic.common.helpers.Predicates; @@ -40,6 +41,7 @@ import tech.pegasys.teku.spec.logic.versions.capella.operations.validation.OperationValidatorCapella; import tech.pegasys.teku.spec.logic.versions.capella.statetransition.epoch.EpochProcessorCapella; import tech.pegasys.teku.spec.logic.versions.phase0.operations.validation.AttestationDataValidatorPhase0; +import tech.pegasys.teku.spec.logic.versions.phase0.operations.validation.VoluntaryExitValidator; import tech.pegasys.teku.spec.logic.versions.phase0.util.AttestationUtilPhase0; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsCapella; @@ -91,7 +93,9 @@ private SpecLogicCapella( } public static SpecLogicCapella create( - final SpecConfigCapella config, final SchemaDefinitionsCapella schemaDefinitions) { + final SpecConfigCapella config, + final SchemaDefinitionsCapella schemaDefinitions, + final TimeProvider timeProvider) { // Helpers final Predicates predicates = new Predicates(config); final MiscHelpersCapella miscHelpers = new MiscHelpersCapella(config); @@ -114,9 +118,15 @@ public static SpecLogicCapella create( new AttestationUtilPhase0(config, schemaDefinitions, beaconStateAccessors, miscHelpers); final AttestationDataValidator attestationDataValidator = new AttestationDataValidatorPhase0(config, miscHelpers, beaconStateAccessors); + final VoluntaryExitValidator voluntaryExitValidator = + new VoluntaryExitValidator(config, predicates, beaconStateAccessors); final OperationValidator operationValidator = new OperationValidatorCapella( - config, predicates, beaconStateAccessors, attestationDataValidator, attestationUtil); + predicates, + beaconStateAccessors, + attestationDataValidator, + attestationUtil, + voluntaryExitValidator); final ValidatorStatusFactoryAltair validatorStatusFactory = new ValidatorStatusFactoryAltair( config, @@ -134,7 +144,8 @@ public static SpecLogicCapella create( validatorsUtil, beaconStateUtil, validatorStatusFactory, - schemaDefinitions); + schemaDefinitions, + timeProvider); final SyncCommitteeUtil syncCommitteeUtil = new SyncCommitteeUtil( beaconStateAccessors, validatorsUtil, config, miscHelpers, schemaDefinitions); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/capella/block/BlockProcessorCapella.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/capella/block/BlockProcessorCapella.java index 36b6fc4124c..d0f713654db 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/capella/block/BlockProcessorCapella.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/capella/block/BlockProcessorCapella.java @@ -16,18 +16,16 @@ import static tech.pegasys.teku.spec.constants.WithdrawalPrefixes.ETH1_ADDRESS_WITHDRAWAL_PREFIX; import com.google.common.annotations.VisibleForTesting; -import java.util.ArrayList; import java.util.HashSet; -import java.util.List; import java.util.Optional; import java.util.Set; +import java.util.function.Supplier; import javax.annotation.CheckReturnValue; import org.apache.tuweni.bytes.Bytes; import org.apache.tuweni.bytes.Bytes32; import tech.pegasys.teku.bls.BLSSignatureVerifier; import tech.pegasys.teku.infrastructure.bytes.Bytes20; import tech.pegasys.teku.infrastructure.ssz.SszList; -import tech.pegasys.teku.infrastructure.ssz.collections.SszUInt64List; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.cache.IndexedAttestationCache; import tech.pegasys.teku.spec.config.SpecConfigCapella; @@ -35,14 +33,12 @@ import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSummary; -import tech.pegasys.teku.spec.datastructures.execution.versions.capella.Withdrawal; -import tech.pegasys.teku.spec.datastructures.execution.versions.capella.WithdrawalSchema; +import tech.pegasys.teku.spec.datastructures.execution.ExpectedWithdrawals; import tech.pegasys.teku.spec.datastructures.operations.BlsToExecutionChange; import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChange; import tech.pegasys.teku.spec.datastructures.state.Validator; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.datastructures.state.beaconstate.MutableBeaconState; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.capella.BeaconStateCapella; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.capella.MutableBeaconStateCapella; import tech.pegasys.teku.spec.logic.common.helpers.BeaconStateMutators; import tech.pegasys.teku.spec.logic.common.helpers.Predicates; @@ -135,9 +131,11 @@ protected BlockValidationResult validateBlockPreProcessing( protected void processOperationsNoValidation( final MutableBeaconState state, final BeaconBlockBody body, - final IndexedAttestationCache indexedAttestationCache) + final IndexedAttestationCache indexedAttestationCache, + final Supplier validatorExitContextSupplier) throws BlockProcessingException { - super.processOperationsNoValidation(state, body, indexedAttestationCache); + super.processOperationsNoValidation( + state, body, indexedAttestationCache, validatorExitContextSupplier); safelyProcess( () -> @@ -188,122 +186,19 @@ public void processBlsToExecutionChangesNoValidation( public void processWithdrawals( final MutableBeaconState genericState, final ExecutionPayloadSummary payloadSummary) throws BlockProcessingException { - final MutableBeaconStateCapella state = MutableBeaconStateCapella.required(genericState); - final SszList expectedWithdrawals = - schemaDefinitionsCapella - .getExecutionPayloadSchema() - .getWithdrawalsSchemaRequired() - .createFromElements(getExpectedWithdrawals(state)); - - assertWithdrawalsInExecutionPayloadMatchExpected(payloadSummary, expectedWithdrawals); - - for (int i = 0; i < expectedWithdrawals.size(); i++) { - final Withdrawal withdrawal = expectedWithdrawals.get(i); - beaconStateMutators.decreaseBalance( - state, withdrawal.getValidatorIndex().intValue(), withdrawal.getAmount()); - } - - final int validatorCount = genericState.getValidators().size(); - final int maxWithdrawalsPerPayload = specConfigCapella.getMaxWithdrawalsPerPayload(); - final int maxValidatorsPerWithdrawalsSweep = - specConfigCapella.getMaxValidatorsPerWithdrawalSweep(); - if (expectedWithdrawals.size() != 0) { - final Withdrawal latestWithdrawal = expectedWithdrawals.get(expectedWithdrawals.size() - 1); - state.setNextWithdrawalIndex(latestWithdrawal.getIndex().increment()); - } - - final int nextWithdrawalValidatorIndex; - if (expectedWithdrawals.size() == maxWithdrawalsPerPayload) { - // Update the next validator index to start the next withdrawal sweep - final Withdrawal latestWithdrawal = expectedWithdrawals.get(expectedWithdrawals.size() - 1); - nextWithdrawalValidatorIndex = latestWithdrawal.getValidatorIndex().intValue() + 1; - } else { - // Advance sweep by the max length of the sweep if there was not a full set of withdrawals - nextWithdrawalValidatorIndex = - state.getNextWithdrawalValidatorIndex().intValue() + maxValidatorsPerWithdrawalsSweep; - } - state.setNextWithdrawalValidatorIndex( - UInt64.valueOf(nextWithdrawalValidatorIndex % validatorCount)); - } - - private static void assertWithdrawalsInExecutionPayloadMatchExpected( - final ExecutionPayloadSummary payloadSummary, final SszList expectedWithdrawals) - throws BlockProcessingException { - // the spec does a element-to-element comparison but Teku is comparing the hash of the tree - if (payloadSummary.getOptionalWithdrawalsRoot().isEmpty() - || !expectedWithdrawals - .hashTreeRoot() - .equals(payloadSummary.getOptionalWithdrawalsRoot().get())) { - final String msg = - String.format( - "Withdrawals in execution payload are different from expected (expected withdrawals root is %s but was " - + "%s)", - expectedWithdrawals.hashTreeRoot(), - payloadSummary - .getOptionalWithdrawalsRoot() - .map(Bytes::toHexString) - .orElse("MISSING")); - throw new BlockProcessingException(msg); - } + final ExpectedWithdrawals expectedWithdrawals = getExpectedWithdrawals(genericState); + expectedWithdrawals.processWithdrawals( + genericState, + payloadSummary, + schemaDefinitionsCapella, + beaconStateMutators, + specConfigCapella); } @Override - public Optional> getExpectedWithdrawals(final BeaconState preState) { - return Optional.of(getExpectedWithdrawals(BeaconStateCapella.required(preState))); - } - - // get_expected_withdrawals - private List getExpectedWithdrawals(final BeaconStateCapella preState) { - final List expectedWithdrawals = new ArrayList<>(); - final WithdrawalSchema withdrawalSchema = schemaDefinitionsCapella.getWithdrawalSchema(); - final UInt64 epoch = miscHelpers.computeEpochAtSlot(preState.getSlot()); - final SszList validators = preState.getValidators(); - final SszUInt64List balances = preState.getBalances(); - final int validatorCount = validators.size(); - final int maxWithdrawalsPerPayload = specConfigCapella.getMaxWithdrawalsPerPayload(); - final int maxValidatorsPerWithdrawalsSweep = - specConfigCapella.getMaxValidatorsPerWithdrawalSweep(); - final int bound = Math.min(validatorCount, maxValidatorsPerWithdrawalsSweep); - - final UInt64 maxEffectiveBalance = specConfig.getMaxEffectiveBalance(); - - UInt64 withdrawalIndex = preState.getNextWithdrawalIndex(); - int validatorIndex = preState.getNextWithdrawalValidatorIndex().intValue(); - - for (int i = 0; i < bound; i++) { - final Validator validator = validators.get(validatorIndex); - if (predicates.hasEth1WithdrawalCredential(validator)) { - final UInt64 balance = balances.get(validatorIndex).get(); - - if (predicates.isFullyWithdrawableValidatorEth1CredentialsChecked( - validator, balance, epoch)) { - expectedWithdrawals.add( - withdrawalSchema.create( - withdrawalIndex, - UInt64.valueOf(validatorIndex), - new Bytes20(validator.getWithdrawalCredentials().slice(12)), - balance)); - withdrawalIndex = withdrawalIndex.increment(); - } else if (predicates.isPartiallyWithdrawableValidatorEth1CredentialsChecked( - validator, balance)) { - expectedWithdrawals.add( - withdrawalSchema.create( - withdrawalIndex, - UInt64.valueOf(validatorIndex), - new Bytes20(validator.getWithdrawalCredentials().slice(12)), - balance.minus(maxEffectiveBalance))); - withdrawalIndex = withdrawalIndex.increment(); - } - - if (expectedWithdrawals.size() == maxWithdrawalsPerPayload) { - break; - } - } - - validatorIndex = (validatorIndex + 1) % validatorCount; - } - - return expectedWithdrawals; + public ExpectedWithdrawals getExpectedWithdrawals(final BeaconState preState) { + return ExpectedWithdrawals.create( + preState, schemaDefinitionsCapella, miscHelpers, specConfig, predicates); } @VisibleForTesting diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/capella/forktransition/CapellaStateUpgrade.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/capella/forktransition/CapellaStateUpgrade.java index 18377732c03..f2a73c088cf 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/capella/forktransition/CapellaStateUpgrade.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/capella/forktransition/CapellaStateUpgrade.java @@ -47,9 +47,7 @@ public CapellaStateUpgrade( public BeaconStateCapella upgrade(final BeaconState preState) { final UInt64 epoch = beaconStateAccessors.getCurrentEpoch(preState); BeaconStateBellatrix preStateBellatrix = BeaconStateBellatrix.required(preState); - return schemaDefinitions - .getBeaconStateSchema() - .createEmpty() + return BeaconStateCapella.required(schemaDefinitions.getBeaconStateSchema().createEmpty()) .updatedCapella( state -> { BeaconStateFields.copyCommonFieldsFromSource(state, preState); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/capella/operations/validation/OperationValidatorCapella.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/capella/operations/validation/OperationValidatorCapella.java index 3524874fd1b..a8a7d22a25c 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/capella/operations/validation/OperationValidatorCapella.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/capella/operations/validation/OperationValidatorCapella.java @@ -14,7 +14,6 @@ package tech.pegasys.teku.spec.logic.versions.capella.operations.validation; import java.util.Optional; -import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.datastructures.operations.BlsToExecutionChange; import tech.pegasys.teku.spec.datastructures.state.Fork; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; @@ -24,6 +23,7 @@ import tech.pegasys.teku.spec.logic.common.operations.validation.OperationInvalidReason; import tech.pegasys.teku.spec.logic.common.util.AttestationUtil; import tech.pegasys.teku.spec.logic.versions.phase0.operations.validation.OperationValidatorPhase0; +import tech.pegasys.teku.spec.logic.versions.phase0.operations.validation.VoluntaryExitValidator; public class OperationValidatorCapella extends OperationValidatorPhase0 { @@ -31,12 +31,17 @@ public class OperationValidatorCapella extends OperationValidatorPhase0 { new BlsToExecutionChangesValidator(); public OperationValidatorCapella( - final SpecConfig specConfig, final Predicates predicates, final BeaconStateAccessors beaconStateAccessors, final AttestationDataValidator attestationDataValidator, - final AttestationUtil attestationUtil) { - super(specConfig, predicates, beaconStateAccessors, attestationDataValidator, attestationUtil); + final AttestationUtil attestationUtil, + final VoluntaryExitValidator voluntaryExitValidator) { + super( + predicates, + beaconStateAccessors, + attestationDataValidator, + attestationUtil, + voluntaryExitValidator); } @Override diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/capella/statetransition/epoch/EpochProcessorCapella.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/capella/statetransition/epoch/EpochProcessorCapella.java index d21570b1d0d..cbf1038563d 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/capella/statetransition/epoch/EpochProcessorCapella.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/capella/statetransition/epoch/EpochProcessorCapella.java @@ -13,8 +13,11 @@ package tech.pegasys.teku.spec.logic.versions.capella.statetransition.epoch; +import com.google.common.annotations.VisibleForTesting; import tech.pegasys.teku.infrastructure.ssz.primitive.SszBytes32; +import tech.pegasys.teku.infrastructure.time.TimeProvider; import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.config.SpecConfigBellatrix; import tech.pegasys.teku.spec.config.SpecConfigCapella; import tech.pegasys.teku.spec.datastructures.state.beaconstate.MutableBeaconState; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.capella.MutableBeaconStateCapella; @@ -40,7 +43,8 @@ public EpochProcessorCapella( final ValidatorsUtil validatorsUtil, final BeaconStateUtil beaconStateUtil, final ValidatorStatusFactory validatorStatusFactory, - final SchemaDefinitions schemaDefinitions) { + final SchemaDefinitions schemaDefinitions, + final TimeProvider timeProvider) { super( specConfig, miscHelpers, @@ -49,10 +53,27 @@ public EpochProcessorCapella( validatorsUtil, beaconStateUtil, validatorStatusFactory, - schemaDefinitions); + schemaDefinitions, + timeProvider); this.schemaDefinitions = schemaDefinitions; } + @VisibleForTesting + public EpochProcessorCapella( + final EpochProcessorCapella processor, final TimeProvider timeProvider) { + super( + SpecConfigBellatrix.required(processor.specConfig), + processor.miscHelpersAltair, + processor.beaconStateAccessorsAltair, + processor.beaconStateMutators, + processor.validatorsUtil, + processor.beaconStateUtil, + processor.validatorStatusFactory, + processor.schemaDefinitions, + timeProvider); + this.schemaDefinitions = processor.schemaDefinitions; + } + @Override public void processHistoricalRootsUpdate(final MutableBeaconState state) { // no longer used in capella diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/deneb/SpecLogicDeneb.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/deneb/SpecLogicDeneb.java index e4acd92877c..92c6112f75b 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/deneb/SpecLogicDeneb.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/deneb/SpecLogicDeneb.java @@ -14,6 +14,7 @@ package tech.pegasys.teku.spec.logic.versions.deneb; import java.util.Optional; +import tech.pegasys.teku.infrastructure.time.TimeProvider; import tech.pegasys.teku.spec.config.SpecConfigDeneb; import tech.pegasys.teku.spec.logic.common.AbstractSpecLogic; import tech.pegasys.teku.spec.logic.common.helpers.Predicates; @@ -43,6 +44,7 @@ import tech.pegasys.teku.spec.logic.versions.deneb.operations.validation.AttestationDataValidatorDeneb; import tech.pegasys.teku.spec.logic.versions.deneb.util.AttestationUtilDeneb; import tech.pegasys.teku.spec.logic.versions.deneb.util.ForkChoiceUtilDeneb; +import tech.pegasys.teku.spec.logic.versions.phase0.operations.validation.VoluntaryExitValidator; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsDeneb; public class SpecLogicDeneb extends AbstractSpecLogic { @@ -90,7 +92,9 @@ private SpecLogicDeneb( } public static SpecLogicDeneb create( - final SpecConfigDeneb config, final SchemaDefinitionsDeneb schemaDefinitions) { + final SpecConfigDeneb config, + final SchemaDefinitionsDeneb schemaDefinitions, + final TimeProvider timeProvider) { // Helpers final Predicates predicates = new Predicates(config); final MiscHelpersDeneb miscHelpers = @@ -114,9 +118,15 @@ public static SpecLogicDeneb create( new AttestationUtilDeneb(config, schemaDefinitions, beaconStateAccessors, miscHelpers); final AttestationDataValidator attestationDataValidator = new AttestationDataValidatorDeneb(config, miscHelpers, beaconStateAccessors); + final VoluntaryExitValidator voluntaryExitValidator = + new VoluntaryExitValidator(config, predicates, beaconStateAccessors); final OperationValidator operationValidator = new OperationValidatorCapella( - config, predicates, beaconStateAccessors, attestationDataValidator, attestationUtil); + predicates, + beaconStateAccessors, + attestationDataValidator, + attestationUtil, + voluntaryExitValidator); final ValidatorStatusFactoryAltair validatorStatusFactory = new ValidatorStatusFactoryAltair( config, @@ -134,7 +144,8 @@ public static SpecLogicDeneb create( validatorsUtil, beaconStateUtil, validatorStatusFactory, - schemaDefinitions); + schemaDefinitions, + timeProvider); final SyncCommitteeUtil syncCommitteeUtil = new SyncCommitteeUtil( beaconStateAccessors, validatorsUtil, config, miscHelpers, schemaDefinitions); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/deneb/forktransition/DenebStateUpgrade.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/deneb/forktransition/DenebStateUpgrade.java index c124ff15876..54989337c08 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/deneb/forktransition/DenebStateUpgrade.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/deneb/forktransition/DenebStateUpgrade.java @@ -45,9 +45,7 @@ public DenebStateUpgrade( public BeaconStateDeneb upgrade(final BeaconState preState) { final UInt64 epoch = beaconStateAccessors.getCurrentEpoch(preState); final BeaconStateCapella preStateCapella = BeaconStateCapella.required(preState); - return schemaDefinitions - .getBeaconStateSchema() - .createEmpty() + return BeaconStateDeneb.required(schemaDefinitions.getBeaconStateSchema().createEmpty()) .updatedDeneb( state -> { BeaconStateFields.copyCommonFieldsFromSource(state, preState); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/deneb/helpers/MiscHelpersDeneb.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/deneb/helpers/MiscHelpersDeneb.java index 4b1404f6c2f..1c69ef71048 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/deneb/helpers/MiscHelpersDeneb.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/deneb/helpers/MiscHelpersDeneb.java @@ -213,6 +213,7 @@ public Optional toVersionDeneb() { return Optional.of(this); } + @Override public int getBlobKzgCommitmentsCount(final SignedBeaconBlock signedBeaconBlock) { return signedBeaconBlock .getMessage() diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/deneb/types/VersionedHash.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/deneb/types/VersionedHash.java index 46902f579fe..868807639c1 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/deneb/types/VersionedHash.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/deneb/types/VersionedHash.java @@ -26,7 +26,7 @@ public class VersionedHash { final Bytes version; final Bytes value; - private VersionedHash(Bytes version, Bytes value) { + private VersionedHash(final Bytes version, final Bytes value) { this.version = version; this.value = value; } @@ -58,7 +58,7 @@ public String toHexString() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/eip7594/block/BlockProcessorEip7594.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/eip7594/block/BlockProcessorEip7594.java deleted file mode 100644 index 2755ff7d0ac..00000000000 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/eip7594/block/BlockProcessorEip7594.java +++ /dev/null @@ -1,60 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.spec.logic.versions.eip7594.block; - -import tech.pegasys.teku.spec.config.SpecConfigEip7594; -import tech.pegasys.teku.spec.logic.common.helpers.BeaconStateMutators; -import tech.pegasys.teku.spec.logic.common.helpers.Predicates; -import tech.pegasys.teku.spec.logic.common.operations.OperationSignatureVerifier; -import tech.pegasys.teku.spec.logic.common.operations.validation.OperationValidator; -import tech.pegasys.teku.spec.logic.common.util.AttestationUtil; -import tech.pegasys.teku.spec.logic.common.util.BeaconStateUtil; -import tech.pegasys.teku.spec.logic.common.util.SyncCommitteeUtil; -import tech.pegasys.teku.spec.logic.common.util.ValidatorsUtil; -import tech.pegasys.teku.spec.logic.versions.altair.helpers.BeaconStateAccessorsAltair; -import tech.pegasys.teku.spec.logic.versions.deneb.block.BlockProcessorDeneb; -import tech.pegasys.teku.spec.logic.versions.deneb.helpers.MiscHelpersDeneb; -import tech.pegasys.teku.spec.schemas.SchemaDefinitionsDeneb; -import tech.pegasys.teku.spec.schemas.SchemaDefinitionsEip7594; - -public class BlockProcessorEip7594 extends BlockProcessorDeneb { - - public BlockProcessorEip7594( - final SpecConfigEip7594 specConfig, - final Predicates predicates, - final MiscHelpersDeneb miscHelpers, - final SyncCommitteeUtil syncCommitteeUtil, - final BeaconStateAccessorsAltair beaconStateAccessors, - final BeaconStateMutators beaconStateMutators, - final OperationSignatureVerifier operationSignatureVerifier, - final BeaconStateUtil beaconStateUtil, - final AttestationUtil attestationUtil, - final ValidatorsUtil validatorsUtil, - final OperationValidator operationValidator, - final SchemaDefinitionsEip7594 schemaDefinitions) { - super( - specConfig, - predicates, - miscHelpers, - syncCommitteeUtil, - beaconStateAccessors, - beaconStateMutators, - operationSignatureVerifier, - beaconStateUtil, - attestationUtil, - validatorsUtil, - operationValidator, - SchemaDefinitionsDeneb.required(schemaDefinitions)); - } -} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/eip7594/forktransition/Eip7594StateUpgrade.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/eip7594/forktransition/Eip7594StateUpgrade.java deleted file mode 100644 index c1288b43c73..00000000000 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/eip7594/forktransition/Eip7594StateUpgrade.java +++ /dev/null @@ -1,101 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2024 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.spec.logic.versions.eip7594.forktransition; - -import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; -import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadHeaderDeneb; -import tech.pegasys.teku.spec.datastructures.state.Fork; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.common.BeaconStateFields; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.deneb.BeaconStateDeneb; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.eip7594.BeaconStateEip7594; -import tech.pegasys.teku.spec.logic.common.forktransition.StateUpgrade; -import tech.pegasys.teku.spec.logic.versions.altair.helpers.BeaconStateAccessorsAltair; -import tech.pegasys.teku.spec.schemas.SchemaDefinitionsEip7594; - -public class Eip7594StateUpgrade implements StateUpgrade { - - private final SpecConfigEip7594 specConfig; - private final SchemaDefinitionsEip7594 schemaDefinitions; - private final BeaconStateAccessorsAltair beaconStateAccessors; - - public Eip7594StateUpgrade( - final SpecConfigEip7594 specConfig, - final SchemaDefinitionsEip7594 schemaDefinitions, - final BeaconStateAccessorsAltair beaconStateAccessors) { - this.specConfig = specConfig; - this.schemaDefinitions = schemaDefinitions; - this.beaconStateAccessors = beaconStateAccessors; - } - - @Override - public BeaconStateEip7594 upgrade(final BeaconState preState) { - final UInt64 epoch = beaconStateAccessors.getCurrentEpoch(preState); - final BeaconStateDeneb preStateDeneb = BeaconStateDeneb.required(preState); - return schemaDefinitions - .getBeaconStateSchema() - .createEmpty() - .updatedEip7594( - state -> { - BeaconStateFields.copyCommonFieldsFromSource(state, preState); - - state.setCurrentEpochParticipation(preStateDeneb.getCurrentEpochParticipation()); - state.setPreviousEpochParticipation(preStateDeneb.getPreviousEpochParticipation()); - state.setCurrentSyncCommittee(preStateDeneb.getCurrentSyncCommittee()); - state.setNextSyncCommittee(preStateDeneb.getNextSyncCommittee()); - state.setInactivityScores(preStateDeneb.getInactivityScores()); - - state.setFork( - new Fork( - preState.getFork().getCurrentVersion(), - specConfig.getEip7594ForkVersion(), - epoch)); - - final ExecutionPayloadHeaderDeneb denebHeader = - preStateDeneb.getLatestExecutionPayloadHeader().toVersionDeneb().orElseThrow(); - final ExecutionPayloadHeader upgradedExecutionPayloadHeader = - schemaDefinitions - .getExecutionPayloadHeaderSchema() - .createExecutionPayloadHeader( - builder -> - builder - .parentHash(denebHeader.getParentHash()) - .feeRecipient(denebHeader.getFeeRecipient()) - .stateRoot(denebHeader.getStateRoot()) - .receiptsRoot(denebHeader.getReceiptsRoot()) - .logsBloom(denebHeader.getLogsBloom()) - .prevRandao(denebHeader.getPrevRandao()) - .blockNumber(denebHeader.getBlockNumber()) - .gasLimit(denebHeader.getGasLimit()) - .gasUsed(denebHeader.getGasUsed()) - .timestamp(denebHeader.getTimestamp()) - .extraData(denebHeader.getExtraData()) - .baseFeePerGas(denebHeader.getBaseFeePerGas()) - .blockHash(denebHeader.getBlockHash()) - .transactionsRoot(denebHeader.getTransactionsRoot()) - .withdrawalsRoot(denebHeader::getWithdrawalsRoot) - .blobGasUsed(denebHeader::getBlobGasUsed) - .excessBlobGas(denebHeader::getExcessBlobGas)); - - state.setLatestExecutionPayloadHeader(upgradedExecutionPayloadHeader); - - state.setNextWithdrawalValidatorIndex( - preStateDeneb.getNextWithdrawalValidatorIndex()); - state.setNextWithdrawalIndex(preStateDeneb.getNextWithdrawalIndex()); - state.setHistoricalSummaries(preStateDeneb.getHistoricalSummaries()); - }); - } -} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/SpecLogicElectra.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/SpecLogicElectra.java new file mode 100644 index 00000000000..96cc8954090 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/SpecLogicElectra.java @@ -0,0 +1,222 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.logic.versions.electra; + +import java.util.Optional; +import tech.pegasys.teku.infrastructure.time.TimeProvider; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsDataCodec; +import tech.pegasys.teku.spec.logic.common.AbstractSpecLogic; +import tech.pegasys.teku.spec.logic.common.helpers.Predicates; +import tech.pegasys.teku.spec.logic.common.operations.OperationSignatureVerifier; +import tech.pegasys.teku.spec.logic.common.operations.validation.AttestationDataValidator; +import tech.pegasys.teku.spec.logic.common.operations.validation.OperationValidator; +import tech.pegasys.teku.spec.logic.common.util.AttestationUtil; +import tech.pegasys.teku.spec.logic.common.util.BeaconStateUtil; +import tech.pegasys.teku.spec.logic.common.util.BlindBlockUtil; +import tech.pegasys.teku.spec.logic.common.util.BlockProposalUtil; +import tech.pegasys.teku.spec.logic.common.util.ForkChoiceUtil; +import tech.pegasys.teku.spec.logic.common.util.LightClientUtil; +import tech.pegasys.teku.spec.logic.common.util.SyncCommitteeUtil; +import tech.pegasys.teku.spec.logic.common.util.ValidatorsUtil; +import tech.pegasys.teku.spec.logic.versions.altair.statetransition.epoch.ValidatorStatusFactoryAltair; +import tech.pegasys.teku.spec.logic.versions.bellatrix.helpers.BeaconStateMutatorsBellatrix; +import tech.pegasys.teku.spec.logic.versions.bellatrix.helpers.BellatrixTransitionHelpers; +import tech.pegasys.teku.spec.logic.versions.bellatrix.util.BlindBlockUtilBellatrix; +import tech.pegasys.teku.spec.logic.versions.capella.operations.validation.OperationValidatorCapella; +import tech.pegasys.teku.spec.logic.versions.deneb.helpers.MiscHelpersDeneb; +import tech.pegasys.teku.spec.logic.versions.deneb.util.ForkChoiceUtilDeneb; +import tech.pegasys.teku.spec.logic.versions.electra.block.BlockProcessorElectra; +import tech.pegasys.teku.spec.logic.versions.electra.forktransition.ElectraStateUpgrade; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.BeaconStateAccessorsElectra; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.BeaconStateMutatorsElectra; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.MiscHelpersElectra; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.PredicatesElectra; +import tech.pegasys.teku.spec.logic.versions.electra.operations.validation.AttestationDataValidatorElectra; +import tech.pegasys.teku.spec.logic.versions.electra.operations.validation.VoluntaryExitValidatorElectra; +import tech.pegasys.teku.spec.logic.versions.electra.statetransition.epoch.EpochProcessorElectra; +import tech.pegasys.teku.spec.logic.versions.electra.util.AttestationUtilElectra; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; + +public class SpecLogicElectra extends AbstractSpecLogic { + private final Optional syncCommitteeUtil; + private final Optional lightClientUtil; + + private SpecLogicElectra( + final Predicates predicates, + final MiscHelpersDeneb miscHelpers, + final BeaconStateAccessorsElectra beaconStateAccessors, + final BeaconStateMutatorsBellatrix beaconStateMutators, + final OperationSignatureVerifier operationSignatureVerifier, + final ValidatorsUtil validatorsUtil, + final BeaconStateUtil beaconStateUtil, + final AttestationUtil attestationUtil, + final OperationValidator operationValidator, + final ValidatorStatusFactoryAltair validatorStatusFactory, + final EpochProcessorElectra epochProcessor, + final BlockProcessorElectra blockProcessor, + final ForkChoiceUtil forkChoiceUtil, + final BlockProposalUtil blockProposalUtil, + final BlindBlockUtil blindBlockUtil, + final SyncCommitteeUtil syncCommitteeUtil, + final LightClientUtil lightClientUtil, + final ElectraStateUpgrade stateUpgrade) { + super( + predicates, + miscHelpers, + beaconStateAccessors, + beaconStateMutators, + operationSignatureVerifier, + validatorsUtil, + beaconStateUtil, + attestationUtil, + operationValidator, + validatorStatusFactory, + epochProcessor, + blockProcessor, + forkChoiceUtil, + blockProposalUtil, + Optional.of(blindBlockUtil), + Optional.of(stateUpgrade)); + this.syncCommitteeUtil = Optional.of(syncCommitteeUtil); + this.lightClientUtil = Optional.of(lightClientUtil); + } + + public static SpecLogicElectra create( + final SpecConfigElectra config, + final SchemaDefinitionsElectra schemaDefinitions, + final TimeProvider timeProvider) { + // Helpers + final PredicatesElectra predicates = new PredicatesElectra(config); + final MiscHelpersElectra miscHelpers = + new MiscHelpersElectra(config, predicates, schemaDefinitions); + final BeaconStateAccessorsElectra beaconStateAccessors = + new BeaconStateAccessorsElectra(config, predicates, miscHelpers); + final BeaconStateMutatorsElectra beaconStateMutators = + new BeaconStateMutatorsElectra( + config, miscHelpers, beaconStateAccessors, schemaDefinitions); + + // Operation validation + final OperationSignatureVerifier operationSignatureVerifier = + new OperationSignatureVerifier(miscHelpers, beaconStateAccessors); + + // Util + final ValidatorsUtil validatorsUtil = + new ValidatorsUtil(config, miscHelpers, beaconStateAccessors); + final BeaconStateUtil beaconStateUtil = + new BeaconStateUtil( + config, schemaDefinitions, predicates, miscHelpers, beaconStateAccessors); + final AttestationUtil attestationUtil = + new AttestationUtilElectra(config, schemaDefinitions, beaconStateAccessors, miscHelpers); + final AttestationDataValidator attestationDataValidator = + new AttestationDataValidatorElectra(config, miscHelpers, beaconStateAccessors); + final VoluntaryExitValidatorElectra voluntaryExitValidatorElectra = + new VoluntaryExitValidatorElectra(config, predicates, beaconStateAccessors); + final OperationValidator operationValidator = + new OperationValidatorCapella( + predicates, + beaconStateAccessors, + attestationDataValidator, + attestationUtil, + voluntaryExitValidatorElectra); + final ValidatorStatusFactoryAltair validatorStatusFactory = + new ValidatorStatusFactoryAltair( + config, + beaconStateUtil, + attestationUtil, + predicates, + miscHelpers, + beaconStateAccessors); + final EpochProcessorElectra epochProcessor = + new EpochProcessorElectra( + config, + miscHelpers, + beaconStateAccessors, + beaconStateMutators, + validatorsUtil, + beaconStateUtil, + validatorStatusFactory, + schemaDefinitions, + timeProvider); + final SyncCommitteeUtil syncCommitteeUtil = + new SyncCommitteeUtil( + beaconStateAccessors, validatorsUtil, config, miscHelpers, schemaDefinitions); + final LightClientUtil lightClientUtil = + new LightClientUtil(beaconStateAccessors, syncCommitteeUtil, schemaDefinitions); + final ExecutionRequestsDataCodec executionRequestsDataCodec = + new ExecutionRequestsDataCodec(schemaDefinitions.getExecutionRequestsSchema()); + final BlockProcessorElectra blockProcessor = + new BlockProcessorElectra( + config, + predicates, + miscHelpers, + syncCommitteeUtil, + beaconStateAccessors, + beaconStateMutators, + operationSignatureVerifier, + beaconStateUtil, + attestationUtil, + validatorsUtil, + operationValidator, + schemaDefinitions, + executionRequestsDataCodec); + final ForkChoiceUtil forkChoiceUtil = + new ForkChoiceUtilDeneb( + config, beaconStateAccessors, epochProcessor, attestationUtil, miscHelpers); + final BlockProposalUtil blockProposalUtil = + new BlockProposalUtil(schemaDefinitions, blockProcessor); + + final BlindBlockUtilBellatrix blindBlockUtil = new BlindBlockUtilBellatrix(schemaDefinitions); + + // State upgrade + final ElectraStateUpgrade stateUpgrade = + new ElectraStateUpgrade( + config, schemaDefinitions, beaconStateAccessors, beaconStateMutators); + + return new SpecLogicElectra( + predicates, + miscHelpers, + beaconStateAccessors, + beaconStateMutators, + operationSignatureVerifier, + validatorsUtil, + beaconStateUtil, + attestationUtil, + operationValidator, + validatorStatusFactory, + epochProcessor, + blockProcessor, + forkChoiceUtil, + blockProposalUtil, + blindBlockUtil, + syncCommitteeUtil, + lightClientUtil, + stateUpgrade); + } + + @Override + public Optional getSyncCommitteeUtil() { + return syncCommitteeUtil; + } + + @Override + public Optional getLightClientUtil() { + return lightClientUtil; + } + + @Override + public Optional getBellatrixTransitionHelpers() { + return Optional.empty(); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/block/BlockProcessorElectra.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/block/BlockProcessorElectra.java new file mode 100644 index 00000000000..49493302242 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/block/BlockProcessorElectra.java @@ -0,0 +1,728 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.logic.versions.electra.block; + +import static com.google.common.base.Preconditions.checkArgument; +import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ZERO; +import static tech.pegasys.teku.spec.config.SpecConfig.FAR_FUTURE_EPOCH; +import static tech.pegasys.teku.spec.config.SpecConfigElectra.FULL_EXIT_REQUEST_AMOUNT; + +import it.unimi.dsi.fastutil.ints.IntList; +import it.unimi.dsi.fastutil.objects.Object2IntMap; +import java.util.List; +import java.util.Optional; +import java.util.function.Supplier; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.bls.BLSSignature; +import tech.pegasys.teku.ethereum.execution.types.Eth1Address; +import tech.pegasys.teku.infrastructure.bytes.Bytes20; +import tech.pegasys.teku.infrastructure.ssz.SszList; +import tech.pegasys.teku.infrastructure.ssz.SszMutableList; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszBytes32; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.cache.IndexedAttestationCache; +import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra.BeaconBlockBodyElectra; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSummary; +import tech.pegasys.teku.spec.datastructures.execution.ExpectedWithdrawals; +import tech.pegasys.teku.spec.datastructures.execution.NewPayloadRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsDataCodec; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequest; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.datastructures.operations.Deposit; +import tech.pegasys.teku.spec.datastructures.state.Validator; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.MutableBeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.BeaconStateElectra; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.MutableBeaconStateElectra; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingConsolidation; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingDeposit; +import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; +import tech.pegasys.teku.spec.datastructures.type.SszPublicKey; +import tech.pegasys.teku.spec.datastructures.type.SszSignature; +import tech.pegasys.teku.spec.logic.common.helpers.BeaconStateMutators.ValidatorExitContext; +import tech.pegasys.teku.spec.logic.common.helpers.Predicates; +import tech.pegasys.teku.spec.logic.common.operations.OperationSignatureVerifier; +import tech.pegasys.teku.spec.logic.common.operations.validation.AttestationDataValidator.AttestationInvalidReason; +import tech.pegasys.teku.spec.logic.common.operations.validation.OperationInvalidReason; +import tech.pegasys.teku.spec.logic.common.operations.validation.OperationValidator; +import tech.pegasys.teku.spec.logic.common.statetransition.exceptions.BlockProcessingException; +import tech.pegasys.teku.spec.logic.common.util.AttestationUtil; +import tech.pegasys.teku.spec.logic.common.util.BeaconStateUtil; +import tech.pegasys.teku.spec.logic.common.util.SyncCommitteeUtil; +import tech.pegasys.teku.spec.logic.common.util.ValidatorsUtil; +import tech.pegasys.teku.spec.logic.versions.deneb.block.BlockProcessorDeneb; +import tech.pegasys.teku.spec.logic.versions.deneb.types.VersionedHash; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.BeaconStateAccessorsElectra; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.BeaconStateMutatorsElectra; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.MiscHelpersElectra; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.PredicatesElectra; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; + +public class BlockProcessorElectra extends BlockProcessorDeneb { + + private static final Logger LOG = LogManager.getLogger(); + + private final SpecConfigElectra specConfigElectra; + private final PredicatesElectra predicatesElectra; + private final BeaconStateMutatorsElectra beaconStateMutatorsElectra; + private final BeaconStateAccessorsElectra beaconStateAccessorsElectra; + private final SchemaDefinitionsElectra schemaDefinitionsElectra; + private final ExecutionRequestsDataCodec executionRequestsDataCodec; + + public BlockProcessorElectra( + final SpecConfigElectra specConfig, + final Predicates predicates, + final MiscHelpersElectra miscHelpers, + final SyncCommitteeUtil syncCommitteeUtil, + final BeaconStateAccessorsElectra beaconStateAccessors, + final BeaconStateMutatorsElectra beaconStateMutators, + final OperationSignatureVerifier operationSignatureVerifier, + final BeaconStateUtil beaconStateUtil, + final AttestationUtil attestationUtil, + final ValidatorsUtil validatorsUtil, + final OperationValidator operationValidator, + final SchemaDefinitionsElectra schemaDefinitions, + final ExecutionRequestsDataCodec executionRequestsDataCodec) { + super( + specConfig, + predicates, + miscHelpers, + syncCommitteeUtil, + beaconStateAccessors, + beaconStateMutators, + operationSignatureVerifier, + beaconStateUtil, + attestationUtil, + validatorsUtil, + operationValidator, + schemaDefinitions); + this.specConfigElectra = specConfig; + this.predicatesElectra = PredicatesElectra.required(predicates); + this.beaconStateMutatorsElectra = beaconStateMutators; + this.beaconStateAccessorsElectra = beaconStateAccessors; + this.schemaDefinitionsElectra = schemaDefinitions; + this.executionRequestsDataCodec = executionRequestsDataCodec; + } + + @Override + public NewPayloadRequest computeNewPayloadRequest( + final BeaconState state, final BeaconBlockBody beaconBlockBody) + throws BlockProcessingException { + final ExecutionPayload executionPayload = extractExecutionPayload(beaconBlockBody); + final SszList blobKzgCommitments = extractBlobKzgCommitments(beaconBlockBody); + final List versionedHashes = + blobKzgCommitments.stream() + .map(SszKZGCommitment::getKZGCommitment) + .map(miscHelpers::kzgCommitmentToVersionedHash) + .toList(); + final Bytes32 parentBeaconBlockRoot = state.getLatestBlockHeader().getParentRoot(); + final ExecutionRequests executionRequests = + BeaconBlockBodyElectra.required(beaconBlockBody).getExecutionRequests(); + return new NewPayloadRequest( + executionPayload, + versionedHashes, + parentBeaconBlockRoot, + executionRequestsDataCodec.encode(executionRequests)); + } + + @Override + protected void processOperationsNoValidation( + final MutableBeaconState state, + final BeaconBlockBody body, + final IndexedAttestationCache indexedAttestationCache, + final Supplier validatorExitContextSupplier) + throws BlockProcessingException { + super.processOperationsNoValidation( + state, body, indexedAttestationCache, validatorExitContextSupplier); + + safelyProcess( + () -> { + final ExecutionRequests executionRequests = + BeaconBlockBodyElectra.required(body).getExecutionRequests(); + + this.processDepositRequests(state, executionRequests.getDeposits()); + this.processWithdrawalRequests( + state, executionRequests.getWithdrawals(), validatorExitContextSupplier); + this.processConsolidationRequests(state, executionRequests.getConsolidations()); + }); + } + + @Override + protected void verifyOutstandingDepositsAreProcessed( + final BeaconState state, final BeaconBlockBody body) { + final UInt64 eth1DepositIndexLimit = + state + .getEth1Data() + .getDepositCount() + .min(BeaconStateElectra.required(state).getDepositRequestsStartIndex()); + + if (state.getEth1DepositIndex().isLessThan(eth1DepositIndexLimit)) { + final int expectedDepositCount = + Math.min( + specConfig.getMaxDeposits(), + eth1DepositIndexLimit.minusMinZero(state.getEth1DepositIndex()).intValue()); + + checkArgument( + body.getDeposits().size() == expectedDepositCount, + "process_operations: Verify that outstanding deposits are processed up to the maximum number of deposits"); + } else { + checkArgument( + body.getDeposits().isEmpty(), + "process_operations: Verify that former deposit mechanism has been disabled"); + } + } + + // process_withdrawals + @Override + public void processWithdrawals( + final MutableBeaconState genericState, final ExecutionPayloadSummary payloadSummary) + throws BlockProcessingException { + final ExpectedWithdrawals expectedWithdrawals = getExpectedWithdrawals(genericState); + expectedWithdrawals.processWithdrawals( + genericState, + payloadSummary, + schemaDefinitionsElectra, + beaconStateMutators, + specConfigElectra); + } + + /** Implements process_withdrawal_request from consensus-specs (EIP-7002 & EIP-7251). */ + @Override + public void processWithdrawalRequests( + final MutableBeaconState state, + final List withdrawalRequests, + final Supplier validatorExitContextSupplier) { + final UInt64 slot = state.getSlot(); + final UInt64 currentEpoch = miscHelpers.computeEpochAtSlot(slot); + + LOG.debug( + "process_withdrawal_request: {} withdrawal request to process from block at " + "slot {}", + withdrawalRequests.size(), + slot); + + withdrawalRequests.forEach( + withdrawalRequest -> { + LOG.debug( + "process_withdrawal_request: processing withdrawal request {}", withdrawalRequest); + + // If partial withdrawal queue is full, only full exits are processed + final boolean isFullExitRequest = + withdrawalRequest.getAmount().equals(FULL_EXIT_REQUEST_AMOUNT); + final boolean partialWithdrawalsQueueFull = + state.toVersionElectra().orElseThrow().getPendingPartialWithdrawals().size() + == specConfigElectra.getPendingPartialWithdrawalsLimit(); + if (partialWithdrawalsQueueFull && !isFullExitRequest) { + LOG.debug("process_withdrawal_request: partial withdrawal queue is full"); + return; + } + + final Optional maybeValidatorIndex = + validatorsUtil.getValidatorIndex(state, withdrawalRequest.getValidatorPubkey()); + if (maybeValidatorIndex.isEmpty()) { + LOG.debug( + "process_withdrawal_request: no matching validator for public key {}", + withdrawalRequest.getValidatorPubkey().toAbbreviatedString()); + return; + } + + final int validatorIndex = maybeValidatorIndex.get(); + final Validator validator = state.getValidators().get(validatorIndex); + + // Check if validator has an execution address set + final boolean hasExecutionAddress = + predicatesElectra.hasExecutionWithdrawalCredential(validator); + if (!hasExecutionAddress) { + LOG.debug( + "process_withdrawal_request: validator index {} does not have withdrawal credentials set", + validatorIndex); + return; + } + + // Check withdrawalRequest source_address matches validator eth1 withdrawal credentials + final Bytes20 validatorExecutionAddress = + new Bytes20(validator.getWithdrawalCredentials().slice(12)); + final Bytes20 withdrawalRequestSourceAddress = withdrawalRequest.getSourceAddress(); + final boolean isCorrectSourceAddress = + validatorExecutionAddress.equals(withdrawalRequestSourceAddress); + if (!isCorrectSourceAddress) { + LOG.debug( + "process_withdrawal_request: WithdrawalRequest source_address {} does not match " + + "validator {} withdrawal credentials {}", + withdrawalRequestSourceAddress, + validatorIndex, + validatorExecutionAddress); + return; + } + + // Check if validator is active + final boolean isValidatorActive = predicates.isActiveValidator(validator, currentEpoch); + if (!isValidatorActive) { + LOG.debug("process_withdrawal_request: Validator {} is not active", validatorIndex); + return; + } + + // Check if validator has already initiated exit + final boolean hasInitiatedExit = !validator.getExitEpoch().equals(FAR_FUTURE_EPOCH); + if (hasInitiatedExit) { + LOG.debug( + "process_withdrawal_request: Validator {} has already initiated exit", + validatorIndex); + return; + } + + // Check if validator has been active long enough + final boolean validatorActiveLongEnough = + currentEpoch.isGreaterThanOrEqualTo( + validator.getActivationEpoch().plus(specConfig.getShardCommitteePeriod())); + if (!validatorActiveLongEnough) { + LOG.debug( + "process_withdrawal_request: Validator {} is not active long enough", + validatorIndex); + return; + } + + final UInt64 pendingBalanceToWithdraw = + validatorsUtil.getPendingBalanceToWithdraw(state, validatorIndex); + if (isFullExitRequest) { + // Only exit validator if it has no pending withdrawals in the queue + if (pendingBalanceToWithdraw.isZero()) { + LOG.debug( + "process_withdrawal_request: Initiating exit for validator {}", validatorIndex); + + beaconStateMutators.initiateValidatorExit( + state, validatorIndex, validatorExitContextSupplier); + } + return; + } + + final UInt64 validatorBalance = state.getBalances().get(validatorIndex).get(); + final UInt64 minActivationBalance = specConfigElectra.getMinActivationBalance(); + + final boolean hasCompoundingWithdrawalCredential = + predicatesElectra.hasCompoundingWithdrawalCredential(validator); + final boolean hasSufficientEffectiveBalance = + validator.getEffectiveBalance().isGreaterThanOrEqualTo(minActivationBalance); + final boolean hasExcessBalance = + validatorBalance.isGreaterThan(minActivationBalance.plus(pendingBalanceToWithdraw)); + if (hasCompoundingWithdrawalCredential + && hasSufficientEffectiveBalance + && hasExcessBalance) { + final UInt64 toWithdraw = + validatorBalance + .minusMinZero(minActivationBalance) + .minusMinZero(pendingBalanceToWithdraw) + .min(withdrawalRequest.getAmount()); + final MutableBeaconStateElectra electraState = + MutableBeaconStateElectra.required(state); + final UInt64 exitQueueEpoch = + beaconStateMutatorsElectra.computeExitEpochAndUpdateChurn(electraState, toWithdraw); + final UInt64 withdrawableEpoch = + exitQueueEpoch.plus(specConfigElectra.getMinValidatorWithdrawabilityDelay()); + + LOG.debug( + "process_withdrawal_request: Creating pending partial withdrawal for validator {}", + validatorIndex); + + electraState + .getPendingPartialWithdrawals() + .append( + schemaDefinitionsElectra + .getPendingPartialWithdrawalSchema() + .create( + SszUInt64.of(UInt64.fromLongBits(validatorIndex)), + SszUInt64.of(toWithdraw), + SszUInt64.of(withdrawableEpoch))); + } + }); + } + + /* + Implements process_deposit_request from consensus-specs (EIP-6110) + */ + @Override + public void processDepositRequests( + final MutableBeaconState state, final List depositRequests) { + final MutableBeaconStateElectra electraState = MutableBeaconStateElectra.required(state); + final SszMutableList pendingDeposits = + MutableBeaconStateElectra.required(state).getPendingDeposits(); + for (DepositRequest depositRequest : depositRequests) { + // process_deposit_request + if (electraState + .getDepositRequestsStartIndex() + .equals(SpecConfigElectra.UNSET_DEPOSIT_REQUESTS_START_INDEX)) { + electraState.setDepositRequestsStartIndex(depositRequest.getIndex()); + } + + final PendingDeposit deposit = + schemaDefinitionsElectra + .getPendingDepositSchema() + .create( + new SszPublicKey(depositRequest.getPubkey()), + SszBytes32.of(depositRequest.getWithdrawalCredentials()), + SszUInt64.of(depositRequest.getAmount()), + new SszSignature(depositRequest.getSignature()), + SszUInt64.of(state.getSlot())); + pendingDeposits.append(deposit); + } + } + + /** + * Implements process_consolidation_request from consensus-spec (EIP-7251) + * + * @see + */ + @Override + public void processConsolidationRequests( + final MutableBeaconState state, final List consolidationRequests) { + LOG.debug( + "process_consolidation_request: {} consolidation requests to process from block at " + + "slot {}", + consolidationRequests.size(), + state.getSlot()); + + final MutableBeaconStateElectra electraState = MutableBeaconStateElectra.required(state); + consolidationRequests.forEach( + consolidationRequest -> processConsolidationRequest(electraState, consolidationRequest)); + } + + private void processConsolidationRequest( + final MutableBeaconStateElectra state, final ConsolidationRequest consolidationRequest) { + final UInt64 slot = state.getSlot(); + final UInt64 currentEpoch = miscHelpers.computeEpochAtSlot(slot); + + if (isValidSwitchToCompoundingRequest(state, consolidationRequest)) { + LOG.debug( + "process_consolidation_request: switching validator {} to compounding address", + consolidationRequest.getSourcePubkey().toAbbreviatedString()); + validatorsUtil + .getValidatorIndex(state, consolidationRequest.getSourcePubkey()) + .ifPresent( + sourceValidatorIndex -> + beaconStateMutatorsElectra.switchToCompoundingValidator( + state, sourceValidatorIndex)); + return; + } + + // Verify that source != target, so a consolidation cannot be used as an exit + if (consolidationRequest.getSourcePubkey().equals(consolidationRequest.getTargetPubkey())) { + LOG.debug( + "process_consolidation_request: source_pubkey and target_pubkey must be different (pubkey = {})", + consolidationRequest.getSourcePubkey().toAbbreviatedString()); + return; + } + + // If the pending consolidations queue is full, consolidation requests are ignored + if (state.getPendingConsolidations().size() + == specConfigElectra.getPendingConsolidationsLimit()) { + LOG.debug("process_consolidation_request: consolidation queue is full"); + return; + } + + // If there is too little available consolidation churn limit, consolidation requests are + // ignored + if (beaconStateAccessorsElectra + .getConsolidationChurnLimit(state) + .isLessThanOrEqualTo(specConfigElectra.getMinActivationBalance())) { + LOG.debug("process_consolidation_request: not enough consolidation churn limit available"); + return; + } + + // Verify source_pubkey exists + final Optional maybeSourceValidatorIndex = + validatorsUtil.getValidatorIndex(state, consolidationRequest.getSourcePubkey()); + if (maybeSourceValidatorIndex.isEmpty()) { + LOG.debug( + "process_consolidation_request: source_pubkey {} not found", + consolidationRequest.getSourcePubkey().toAbbreviatedString()); + return; + } + + // Verify target_pubkey exists + final Optional maybeTargetValidatorIndex = + validatorsUtil.getValidatorIndex(state, consolidationRequest.getTargetPubkey()); + if (maybeTargetValidatorIndex.isEmpty()) { + LOG.debug( + "process_consolidation_request: target_pubkey {} not found", + consolidationRequest.getTargetPubkey().toAbbreviatedString()); + return; + } + + final int sourceValidatorIndex = maybeSourceValidatorIndex.get(); + final Validator sourceValidator = state.getValidators().get(sourceValidatorIndex); + final int targetValidatorIndex = maybeTargetValidatorIndex.get(); + final Validator targetValidator = state.getValidators().get(targetValidatorIndex); + + // Verify source withdrawal credentials + final boolean sourceHasExecutionWithdrawalCredentials = + predicatesElectra.hasExecutionWithdrawalCredential(sourceValidator); + + final Eth1Address sourceValidatorExecutionAddress = + Predicates.getExecutionAddressUnchecked(sourceValidator.getWithdrawalCredentials()); + final boolean sourceHasCorrectCredentials = + sourceValidatorExecutionAddress.equals( + Eth1Address.fromBytes(consolidationRequest.getSourceAddress().getWrappedBytes())); + if (!(sourceHasExecutionWithdrawalCredentials && sourceHasCorrectCredentials)) { + LOG.debug("process_consolidation_request: invalid source credentials"); + return; + } + + // Verify that target has execution withdrawal credentials + if (!predicatesElectra.hasExecutionWithdrawalCredential(targetValidator)) { + LOG.debug("process_consolidation_request: invalid target credentials"); + return; + } + + // Verify the source and the target are active + if (!predicatesElectra.isActiveValidator(sourceValidator, currentEpoch)) { + LOG.debug( + "process_consolidation_request: source validator {} is inactive", sourceValidatorIndex); + return; + } + if (!predicatesElectra.isActiveValidator(targetValidator, currentEpoch)) { + LOG.debug( + "process_consolidation_request: target validator {} is inactive", targetValidatorIndex); + return; + } + + // Verify exits for source and target have not been initiated + if (!sourceValidator.getExitEpoch().equals(FAR_FUTURE_EPOCH)) { + LOG.debug( + "process_consolidation_request: source validator {} is exiting", sourceValidatorIndex); + return; + } + if (!targetValidator.getExitEpoch().equals(FAR_FUTURE_EPOCH)) { + LOG.debug( + "process_consolidation_request: target validator {} is exiting", targetValidatorIndex); + return; + } + + // Initiate source validator exit and append pending consolidation + final UInt64 exitEpoch = + beaconStateMutatorsElectra.computeConsolidationEpochAndUpdateChurn( + state, sourceValidator.getEffectiveBalance()); + final UInt64 withdrawableEpoch = + exitEpoch.plus(specConfigElectra.getMinValidatorWithdrawabilityDelay()); + + state + .getValidators() + .update( + sourceValidatorIndex, + v -> v.withExitEpoch(exitEpoch).withWithdrawableEpoch(withdrawableEpoch)); + LOG.debug( + "process_consolidation_request: updated validator {} with exit_epoch = {}, withdrawable_epoch = {}", + sourceValidatorIndex, + exitEpoch, + withdrawableEpoch); + + final PendingConsolidation pendingConsolidation = + new PendingConsolidation( + schemaDefinitionsElectra.getPendingConsolidationSchema(), + SszUInt64.of(UInt64.valueOf(sourceValidatorIndex)), + SszUInt64.of(UInt64.valueOf(targetValidatorIndex))); + state.getPendingConsolidations().append(pendingConsolidation); + + // Churn any target excess active balance of target and raise its max + if (predicatesElectra.hasEth1WithdrawalCredential(targetValidator)) { + beaconStateMutatorsElectra.switchToCompoundingValidator(state, targetValidatorIndex); + } + + LOG.debug("process_consolidation_request: created {}", pendingConsolidation); + } + + /** + * Implements function is_valid_switch_to_compounding_request + * + * @see + */ + @Override + public boolean isValidSwitchToCompoundingRequest( + final BeaconState state, final ConsolidationRequest consolidationRequest) { + + // Switch to compounding requires source and target be equal + if (!consolidationRequest.getSourcePubkey().equals(consolidationRequest.getTargetPubkey())) { + return false; + } + + // Verify source_pubkey exists + final Optional maybeSourceValidatorIndex = + validatorsUtil.getValidatorIndex(state, consolidationRequest.getSourcePubkey()); + if (maybeSourceValidatorIndex.isEmpty()) { + return false; + } + + final int sourceValidatorIndex = maybeSourceValidatorIndex.get(); + final Validator sourceValidator = state.getValidators().get(sourceValidatorIndex); + + // Verify request has been authorized + final Eth1Address sourceValidatorExecutionAddress = + Predicates.getExecutionAddressUnchecked(sourceValidator.getWithdrawalCredentials()); + if (!sourceValidatorExecutionAddress.equals( + Eth1Address.fromBytes(consolidationRequest.getSourceAddress().getWrappedBytes()))) { + return false; + } + + // Verify source withdrawal credentials + if (!predicatesElectra.hasEth1WithdrawalCredential(sourceValidator)) { + return false; + } + + // Verify the source is active + final UInt64 currentEpoch = miscHelpers.computeEpochAtSlot(state.getSlot()); + if (!predicatesElectra.isActiveValidator(sourceValidator, currentEpoch)) { + return false; + } + + // Verify exit for source has not been initiated + return sourceValidator.getExitEpoch().equals(FAR_FUTURE_EPOCH); + } + + @Override + public void applyDeposit( + final MutableBeaconState state, + final BLSPublicKey pubkey, + final Bytes32 withdrawalCredentials, + final UInt64 amount, + final BLSSignature signature, + final Optional> maybePubkeyToIndexMap, + final boolean signatureAlreadyVerified) { + + // Find the validator index associated with this deposit, if it exists + final Optional existingIndex = + maybePubkeyToIndexMap + .flatMap( + pubkeyToIndexMap -> { + if (pubkeyToIndexMap.containsKey(pubkey)) { + return Optional.of(pubkeyToIndexMap.getInt(pubkey)); + } else { + pubkeyToIndexMap.put(pubkey, state.getValidators().size()); + return Optional.empty(); + } + }) + .or(() -> validatorsUtil.getValidatorIndex(state, pubkey)); + + if (existingIndex.isEmpty()) { + // This is a new validator + // Verify the deposit signature (proof of possession) which is not checked by the deposit + // contract + if (signatureAlreadyVerified + || miscHelpers.isValidDepositSignature( + pubkey, withdrawalCredentials, amount, signature)) { + beaconStateMutators.addValidatorToRegistry(state, pubkey, withdrawalCredentials, ZERO); + final PendingDeposit deposit = + schemaDefinitionsElectra + .getPendingDepositSchema() + .create( + new SszPublicKey(pubkey), + SszBytes32.of(withdrawalCredentials), + SszUInt64.of(amount), + new SszSignature(signature), + SszUInt64.of(SpecConfig.GENESIS_SLOT)); + MutableBeaconStateElectra.required(state).getPendingDeposits().append(deposit); + } else { + handleInvalidDeposit(pubkey, maybePubkeyToIndexMap); + } + } else { + final PendingDeposit deposit = + schemaDefinitionsElectra + .getPendingDepositSchema() + .create( + new SszPublicKey(pubkey), + SszBytes32.of(withdrawalCredentials), + SszUInt64.of(amount), + new SszSignature(signature), + SszUInt64.of(SpecConfig.GENESIS_SLOT)); + MutableBeaconStateElectra.required(state).getPendingDeposits().append(deposit); + } + } + + @Override + public void processDepositWithoutCheckingMerkleProof( + final MutableBeaconState state, + final Deposit deposit, + final Optional> maybePubkeyToIndexMap, + final boolean signatureAlreadyVerified) { + state.setEth1DepositIndex(state.getEth1DepositIndex().plus(UInt64.ONE)); + + applyDeposit( + state, + deposit.getData().getPubkey(), + deposit.getData().getWithdrawalCredentials(), + deposit.getData().getAmount(), + deposit.getData().getSignature(), + maybePubkeyToIndexMap, + signatureAlreadyVerified); + } + + @Override + protected void assertAttestationValid( + final MutableBeaconState state, final Attestation attestation) { + final Optional invalidReason = + validateAttestation(state, attestation.getData()); + checkArgument( + invalidReason.isEmpty(), + "process_attestations: %s", + invalidReason.map(OperationInvalidReason::describe).orElse("")); + + final List committeeIndices = attestation.getCommitteeIndicesRequired(); + final UInt64 committeeCountPerSlot = + beaconStateAccessorsElectra.getCommitteeCountPerSlot( + state, attestation.getData().getTarget().getEpoch()); + final SszBitlist aggregationBits = attestation.getAggregationBits(); + final Optional committeeCheckResult = + checkCommittees( + committeeIndices, + committeeCountPerSlot, + state, + attestation.getData().getSlot(), + aggregationBits); + if (committeeCheckResult.isPresent()) { + throw new IllegalArgumentException(committeeCheckResult.get().describe()); + } + } + + private Optional checkCommittees( + final List committeeIndices, + final UInt64 committeeCountPerSlot, + final BeaconState state, + final UInt64 slot, + final SszBitlist aggregationBits) { + int participantsCount = 0; + for (final UInt64 committeeIndex : committeeIndices) { + if (committeeIndex.isGreaterThanOrEqualTo(committeeCountPerSlot)) { + return Optional.of(AttestationInvalidReason.COMMITTEE_INDEX_TOO_HIGH); + } + final IntList committee = + beaconStateAccessorsElectra.getBeaconCommittee(state, slot, committeeIndex); + participantsCount += committee.size(); + } + if (participantsCount != aggregationBits.size()) { + return Optional.of(AttestationInvalidReason.PARTICIPANTS_COUNT_MISMATCH); + } + return Optional.empty(); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/forktransition/ElectraStateUpgrade.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/forktransition/ElectraStateUpgrade.java new file mode 100644 index 00000000000..a5c71a7af76 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/forktransition/ElectraStateUpgrade.java @@ -0,0 +1,131 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.logic.versions.electra.forktransition; + +import static tech.pegasys.teku.spec.config.SpecConfig.FAR_FUTURE_EPOCH; + +import java.util.Comparator; +import java.util.stream.IntStream; +import tech.pegasys.teku.infrastructure.ssz.SszMutableList; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.datastructures.state.Fork; +import tech.pegasys.teku.spec.datastructures.state.Validator; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.common.BeaconStateFields; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.deneb.BeaconStateDeneb; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.BeaconStateElectra; +import tech.pegasys.teku.spec.logic.common.forktransition.StateUpgrade; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.BeaconStateAccessorsElectra; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.BeaconStateMutatorsElectra; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.MiscHelpersElectra; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.PredicatesElectra; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; + +public class ElectraStateUpgrade implements StateUpgrade { + + private final SpecConfigElectra specConfig; + private final SchemaDefinitionsElectra schemaDefinitions; + private final BeaconStateAccessorsElectra beaconStateAccessors; + private final BeaconStateMutatorsElectra beaconStateMutators; + + public ElectraStateUpgrade( + final SpecConfigElectra specConfig, + final SchemaDefinitionsElectra schemaDefinitions, + final BeaconStateAccessorsElectra beaconStateAccessors, + final BeaconStateMutatorsElectra beaconStateMutators) { + this.specConfig = specConfig; + this.schemaDefinitions = schemaDefinitions; + this.beaconStateAccessors = beaconStateAccessors; + this.beaconStateMutators = beaconStateMutators; + } + + @Override + public BeaconStateElectra upgrade(final BeaconState preState) { + final UInt64 epoch = beaconStateAccessors.getCurrentEpoch(preState); + final BeaconStateDeneb preStateDeneb = BeaconStateDeneb.required(preState); + final PredicatesElectra predicatesElectra = new PredicatesElectra(specConfig); + final MiscHelpersElectra miscHelpersElectra = + new MiscHelpersElectra(specConfig, predicatesElectra, schemaDefinitions); + return BeaconStateElectra.required(schemaDefinitions.getBeaconStateSchema().createEmpty()) + .updatedElectra( + state -> { + BeaconStateFields.copyCommonFieldsFromSource(state, preState); + + state.setCurrentEpochParticipation(preStateDeneb.getCurrentEpochParticipation()); + state.setPreviousEpochParticipation(preStateDeneb.getPreviousEpochParticipation()); + state.setCurrentSyncCommittee(preStateDeneb.getCurrentSyncCommittee()); + state.setNextSyncCommittee(preStateDeneb.getNextSyncCommittee()); + state.setInactivityScores(preStateDeneb.getInactivityScores()); + + state.setFork( + new Fork( + preState.getFork().getCurrentVersion(), + specConfig.getElectraForkVersion(), + epoch)); + + state.setLatestExecutionPayloadHeader( + preStateDeneb.getLatestExecutionPayloadHeader()); + state.setNextWithdrawalValidatorIndex( + preStateDeneb.getNextWithdrawalValidatorIndex()); + state.setNextWithdrawalIndex(preStateDeneb.getNextWithdrawalIndex()); + state.setHistoricalSummaries(preStateDeneb.getHistoricalSummaries()); + state.setDepositRequestsStartIndex( + SpecConfigElectra.UNSET_DEPOSIT_REQUESTS_START_INDEX); + state.setDepositBalanceToConsume(UInt64.ZERO); + state.setExitBalanceToConsume( + beaconStateAccessors.getActivationExitChurnLimit(state)); + state.setEarliestExitEpoch(findEarliestExitEpoch(state, epoch)); + state.setConsolidationBalanceToConsume( + beaconStateAccessors.getConsolidationChurnLimit(state)); + state.setEarliestConsolidationEpoch( + miscHelpersElectra.computeActivationExitEpoch(epoch)); + + final SszMutableList validators = state.getValidators(); + + // Add validators that are not yet active to pending balance deposits + IntStream.range(0, validators.size()) + .filter( + index -> validators.get(index).getActivationEpoch().equals(FAR_FUTURE_EPOCH)) + .boxed() + .sorted( + Comparator.comparing( + (Integer index) -> + validators.get(index).getActivationEligibilityEpoch()) + .thenComparing(index -> index)) + .forEach( + index -> + beaconStateMutators.queueEntireBalanceAndResetValidator(state, index)); + + // Ensure early adopters of compounding credentials go through the activation churn + IntStream.range(0, validators.size()) + .forEach( + index -> { + if (predicatesElectra.hasCompoundingWithdrawalCredential( + validators.get(index))) { + beaconStateMutators.queueExcessActiveBalance(state, index); + } + }); + }); + } + + private UInt64 findEarliestExitEpoch(final BeaconState state, final UInt64 currentEpoch) { + return state.getValidators().stream() + .map(Validator::getExitEpoch) + .filter(exitEpoch -> !exitEpoch.equals(FAR_FUTURE_EPOCH)) + .max(UInt64::compareTo) + .orElse(currentEpoch) + .increment(); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/helpers/BeaconStateAccessorsElectra.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/helpers/BeaconStateAccessorsElectra.java new file mode 100644 index 00000000000..2bc48d0ba4f --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/helpers/BeaconStateAccessorsElectra.java @@ -0,0 +1,122 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.logic.versions.electra.helpers; + +import static com.google.common.base.Preconditions.checkArgument; + +import it.unimi.dsi.fastutil.ints.IntList; +import java.util.List; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.config.SpecConfigDeneb; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.datastructures.state.Validator; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.BeaconStateElectra; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingPartialWithdrawal; +import tech.pegasys.teku.spec.logic.common.helpers.BeaconStateAccessors; +import tech.pegasys.teku.spec.logic.versions.deneb.helpers.BeaconStateAccessorsDeneb; + +public class BeaconStateAccessorsElectra extends BeaconStateAccessorsDeneb { + + private final SpecConfigElectra configElectra; + protected PredicatesElectra predicatesElectra; + + public BeaconStateAccessorsElectra( + final SpecConfig config, + final PredicatesElectra predicatesElectra, + final MiscHelpersElectra miscHelpers) { + super(SpecConfigDeneb.required(config), predicatesElectra, miscHelpers); + configElectra = config.toVersionElectra().orElseThrow(); + this.predicatesElectra = predicatesElectra; + } + + /** + * get_activation_exit_churn_limit + * + * @param state - the state to use to get the churn limit from + * @return Return the churn limit for the current epoch dedicated to activations and exits. + */ + public UInt64 getActivationExitChurnLimit(final BeaconStateElectra state) { + return getBalanceChurnLimit(state).min(configElectra.getMaxPerEpochActivationExitChurnLimit()); + } + + /** + * get_active_balance + * + * @param state The state to get the effective balance from + * @param validatorIndex the index of the validator + */ + public UInt64 getActiveBalance(final BeaconState state, final int validatorIndex) { + final Validator validator = state.getValidators().get(validatorIndex); + final UInt64 maxEffectiveBalance = miscHelpers.getMaxEffectiveBalance(validator); + final UInt64 validatorBalance = state.getBalances().get(validatorIndex).get(); + return validatorBalance.min(maxEffectiveBalance); + } + + /** + * get_pending_balance_to_withdraw + * + * @param state The state + * @param validatorIndex The index of the validator + * @return The sum of the withdrawal amounts for the validator in the partial withdrawal queue. + */ + public UInt64 getPendingBalanceToWithdraw( + final BeaconStateElectra state, final int validatorIndex) { + final List partialWithdrawals = + state.getPendingPartialWithdrawals().asList(); + return partialWithdrawals.stream() + .filter(z -> z.getIndex() == validatorIndex) + .map(PendingPartialWithdrawal::getAmount) + .reduce(UInt64.ZERO, UInt64::plus); + } + + /** + * get_balance_churn_limit + * + * @param state the state to read active balance from + * @return Return the churn limit for the current epoch. + */ + public UInt64 getBalanceChurnLimit(final BeaconStateElectra state) { + final UInt64 churn = + configElectra + .getMinPerEpochChurnLimitElectra() + .max(getTotalActiveBalance(state).dividedBy(configElectra.getChurnLimitQuotient())); + return churn.minusMinZero(churn.mod(configElectra.getEffectiveBalanceIncrement())); + } + + /** + * get_consolidation_churn_limit + * + * @param state state to read churn limits from + */ + public UInt64 getConsolidationChurnLimit(final BeaconStateElectra state) { + return getBalanceChurnLimit(state).minusMinZero(getActivationExitChurnLimit(state)); + } + + public static BeaconStateAccessorsElectra required( + final BeaconStateAccessors beaconStateAccessors) { + checkArgument( + beaconStateAccessors instanceof BeaconStateAccessorsElectra, + "Expected %s but it was %s", + BeaconStateAccessorsElectra.class, + beaconStateAccessors.getClass()); + return (BeaconStateAccessorsElectra) beaconStateAccessors; + } + + @Override + public IntList getNextSyncCommitteeIndices(final BeaconState state) { + return getNextSyncCommitteeIndices(state, configElectra.getMaxEffectiveBalanceElectra()); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/helpers/BeaconStateMutatorsElectra.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/helpers/BeaconStateMutatorsElectra.java new file mode 100644 index 00000000000..7b9e7b2a1ba --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/helpers/BeaconStateMutatorsElectra.java @@ -0,0 +1,271 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.logic.versions.electra.helpers; + +import static com.google.common.base.Preconditions.checkArgument; +import static tech.pegasys.teku.spec.config.SpecConfig.FAR_FUTURE_EPOCH; +import static tech.pegasys.teku.spec.constants.WithdrawalPrefixes.COMPOUNDING_WITHDRAWAL_BYTE; + +import java.util.function.Supplier; +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.bls.BLSSignature; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszBytes32; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.config.SpecConfigBellatrix; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.datastructures.state.Validator; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.MutableBeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.MutableBeaconStateElectra; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingDeposit; +import tech.pegasys.teku.spec.datastructures.type.SszPublicKey; +import tech.pegasys.teku.spec.datastructures.type.SszSignature; +import tech.pegasys.teku.spec.logic.common.helpers.BeaconStateAccessors; +import tech.pegasys.teku.spec.logic.common.helpers.BeaconStateMutators; +import tech.pegasys.teku.spec.logic.common.helpers.MiscHelpers; +import tech.pegasys.teku.spec.logic.versions.bellatrix.helpers.BeaconStateMutatorsBellatrix; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; + +public class BeaconStateMutatorsElectra extends BeaconStateMutatorsBellatrix { + + private final BeaconStateAccessorsElectra stateAccessorsElectra; + private final MiscHelpersElectra miscHelpersElectra; + + private final SpecConfigElectra specConfigElectra; + private final SchemaDefinitionsElectra schemaDefinitionsElectra; + + public static BeaconStateMutatorsElectra required(final BeaconStateMutators beaconStateMutators) { + checkArgument( + beaconStateMutators instanceof BeaconStateMutatorsElectra, + "Expected %s but it was %s", + BeaconStateMutatorsElectra.class, + beaconStateMutators.getClass()); + return (BeaconStateMutatorsElectra) beaconStateMutators; + } + + public BeaconStateMutatorsElectra( + final SpecConfig specConfig, + final MiscHelpers miscHelpers, + final BeaconStateAccessors beaconStateAccessors, + final SchemaDefinitionsElectra schemaDefinitionsElectra) { + super(SpecConfigBellatrix.required(specConfig), miscHelpers, beaconStateAccessors); + this.stateAccessorsElectra = BeaconStateAccessorsElectra.required(beaconStateAccessors); + this.miscHelpersElectra = MiscHelpersElectra.required(miscHelpers); + this.specConfigElectra = SpecConfigElectra.required(specConfig); + this.schemaDefinitionsElectra = schemaDefinitionsElectra; + } + + /** + * compute_exit_epoch_and_update_churn + * + * @param state mutable beacon state + * @param exitBalance exit balance + * @return earliest exit epoch (updated in state) + */ + public UInt64 computeExitEpochAndUpdateChurn( + final MutableBeaconStateElectra state, final UInt64 exitBalance) { + final UInt64 earliestExitEpoch = + miscHelpers + .computeActivationExitEpoch(stateAccessorsElectra.getCurrentEpoch(state)) + .max(state.getEarliestExitEpoch()); + final UInt64 perEpochChurn = stateAccessorsElectra.getActivationExitChurnLimit(state); + final UInt64 exitBalanceToConsume = + state.getEarliestExitEpoch().isLessThan(earliestExitEpoch) + ? perEpochChurn + : state.getExitBalanceToConsume(); + + if (exitBalance.isGreaterThan(exitBalanceToConsume)) { + final UInt64 balanceToProcess = exitBalance.minusMinZero(exitBalanceToConsume); + final UInt64 additionalEpochs = + balanceToProcess.minusMinZero(1).dividedBy(perEpochChurn).increment(); + state.setEarliestExitEpoch(earliestExitEpoch.plus(additionalEpochs)); + state.setExitBalanceToConsume( + exitBalanceToConsume + .plus(additionalEpochs.times(perEpochChurn)) + .minusMinZero(exitBalance)); + } else { + state.setExitBalanceToConsume(exitBalanceToConsume.minusMinZero(exitBalance)); + state.setEarliestExitEpoch(earliestExitEpoch); + } + + return state.getEarliestExitEpoch(); + } + + /** initiate_validator_exit */ + @Override + public void initiateValidatorExit( + final MutableBeaconState state, + final int index, + final Supplier validatorExitContextSupplier) { + final Validator validator = state.getValidators().get(index); + // Return if validator already initiated exit + if (!validator.getExitEpoch().equals(FAR_FUTURE_EPOCH)) { + return; + } + + final MutableBeaconStateElectra stateElectra = MutableBeaconStateElectra.required(state); + + final ValidatorExitContext validatorExitContext = validatorExitContextSupplier.get(); + + if (validatorExitContext.getExitQueueChurn().compareTo(validatorExitContext.getChurnLimit()) + >= 0) { + validatorExitContext.setExitQueueEpoch(validatorExitContext.getExitQueueEpoch().increment()); + validatorExitContext.setExitQueueChurn(UInt64.ONE); + } else { + validatorExitContext.setExitQueueChurn(validatorExitContext.getExitQueueChurn().increment()); + } + + final UInt64 exitQueueEpoch = + computeExitEpochAndUpdateChurn(stateElectra, validator.getEffectiveBalance()); + + // Set validator exit epoch and withdrawable epoch + stateElectra + .getValidators() + .set( + index, + validator + .withExitEpoch(exitQueueEpoch) + .withWithdrawableEpoch( + exitQueueEpoch.plus(specConfig.getMinValidatorWithdrawabilityDelay()))); + } + + /** compute_consolidation_epoch_and_update_churn */ + public UInt64 computeConsolidationEpochAndUpdateChurn( + final MutableBeaconState state, final UInt64 consolidationBalance) { + final MutableBeaconStateElectra stateElectra = MutableBeaconStateElectra.required(state); + final UInt64 epoch = miscHelpers.computeEpochAtSlot(state.getSlot()); + final UInt64 computedActivationExitEpoch = miscHelpersElectra.computeActivationExitEpoch(epoch); + final UInt64 perEpochConsolidationChurn = + stateAccessorsElectra.getConsolidationChurnLimit(stateElectra); + + UInt64 earliestConsolidationEpoch = + stateElectra.getEarliestConsolidationEpoch().max(computedActivationExitEpoch); + // New epoch for consolidations. + UInt64 consolidationBalanceToConsume = + stateElectra.getEarliestConsolidationEpoch().isLessThan(earliestConsolidationEpoch) + ? perEpochConsolidationChurn + : stateElectra.getConsolidationBalanceToConsume(); + + // Consolidation doesn't fit in the current earliest epoch. + if (consolidationBalance.isGreaterThan(consolidationBalanceToConsume)) { + final UInt64 balanceToProcess = + consolidationBalance.minusMinZero(consolidationBalanceToConsume); + final UInt64 additionalEpochs = + balanceToProcess.decrement().dividedBy(perEpochConsolidationChurn).increment(); + earliestConsolidationEpoch = earliestConsolidationEpoch.plus(additionalEpochs); + consolidationBalanceToConsume = + consolidationBalanceToConsume.plus(additionalEpochs.times(perEpochConsolidationChurn)); + } + + // Consume the balance and update state variables. + stateElectra.setConsolidationBalanceToConsume( + consolidationBalanceToConsume.minusMinZero(consolidationBalance)); + stateElectra.setEarliestConsolidationEpoch(earliestConsolidationEpoch); + + return stateElectra.getEarliestConsolidationEpoch(); + } + + /** + * switch_to_compounding_validator + * + * @param state beaconState + * @param index validatorIndex + */ + public void switchToCompoundingValidator(final MutableBeaconStateElectra state, final int index) { + final byte[] withdrawalCredentialsUpdated = + state.getValidators().get(index).getWithdrawalCredentials().toArray(); + withdrawalCredentialsUpdated[0] = COMPOUNDING_WITHDRAWAL_BYTE; + state + .getValidators() + .update( + index, + validator -> + validator.withWithdrawalCredentials(Bytes32.wrap(withdrawalCredentialsUpdated))); + queueExcessActiveBalance(state, index); + } + + /** + * queue_excess_active_balance + * + * @param state beaconState + * @param validatorIndex validatorIndex + */ + public void queueExcessActiveBalance( + final MutableBeaconStateElectra state, final int validatorIndex) { + final UInt64 balance = state.getBalances().get(validatorIndex).get(); + final UInt64 minActivationBalance = specConfigElectra.getMinActivationBalance(); + + if (balance.isGreaterThan(minActivationBalance)) { + final UInt64 excessBalance = balance.minusMinZero(minActivationBalance); + state.getBalances().set(validatorIndex, SszUInt64.of(minActivationBalance)); + + final Validator validator = state.getValidators().get(validatorIndex); + final PendingDeposit deposit = + schemaDefinitionsElectra + .getPendingDepositSchema() + .create( + new SszPublicKey(validator.getPublicKey()), + SszBytes32.of(validator.getWithdrawalCredentials()), + SszUInt64.of(excessBalance), + new SszSignature(BLSSignature.infinity()), + SszUInt64.of(SpecConfig.GENESIS_SLOT)); + + state.getPendingDeposits().append(deposit); + } + } + + /** + * queue_entire_balance_and_reset_validator + * + * @param state beaconState + * @param validatorIndex validatorIndex + */ + public void queueEntireBalanceAndResetValidator( + final MutableBeaconStateElectra state, final int validatorIndex) { + final UInt64 balance = state.getBalances().getElement(validatorIndex); + state.getBalances().set(validatorIndex, SszUInt64.ZERO); + state + .getValidators() + .update( + validatorIndex, + validator -> + validator + .withEffectiveBalance(UInt64.ZERO) + .withActivationEligibilityEpoch(FAR_FUTURE_EPOCH)); + + final Validator validator = state.getValidators().get(validatorIndex); + final PendingDeposit deposit = + schemaDefinitionsElectra + .getPendingDepositSchema() + .create( + new SszPublicKey(validator.getPublicKey()), + SszBytes32.of(validator.getWithdrawalCredentials()), + SszUInt64.of(balance), + new SszSignature(BLSSignature.infinity()), + SszUInt64.of(SpecConfig.GENESIS_SLOT)); + + state.getPendingDeposits().append(deposit); + } + + @Override + protected int getWhistleblowerRewardQuotient() { + return specConfigElectra.getWhistleblowerRewardQuotientElectra(); + } + + @Override + protected int getMinSlashingPenaltyQuotient() { + return specConfigElectra.getMinSlashingPenaltyQuotientElectra(); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/helpers/MiscHelpersElectra.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/helpers/MiscHelpersElectra.java new file mode 100644 index 00000000000..8626771c002 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/helpers/MiscHelpersElectra.java @@ -0,0 +1,144 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.logic.versions.electra.helpers; + +import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ZERO; +import static tech.pegasys.teku.spec.config.SpecConfig.FAR_FUTURE_EPOCH; + +import it.unimi.dsi.fastutil.ints.IntList; +import java.util.Optional; +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.config.SpecConfigDeneb; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.config.features.Eip7594; +import tech.pegasys.teku.spec.datastructures.state.Validator; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.BeaconStateElectra; +import tech.pegasys.teku.spec.logic.common.helpers.MiscHelpers; +import tech.pegasys.teku.spec.logic.common.helpers.Predicates; +import tech.pegasys.teku.spec.logic.versions.deneb.helpers.MiscHelpersDeneb; +import tech.pegasys.teku.spec.logic.versions.feature.eip7594.helpers.MiscHelpersEip7594; +import tech.pegasys.teku.spec.schemas.SchemaDefinitions; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsDeneb; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; + +public class MiscHelpersElectra extends MiscHelpersDeneb { + private final SpecConfigElectra specConfigElectra; + private final PredicatesElectra predicatesElectra; + private final Optional maybeEip7594Helpers; + + public MiscHelpersElectra( + final SpecConfigElectra specConfig, + final Predicates predicates, + final SchemaDefinitions schemaDefinitions) { + super( + SpecConfigDeneb.required(specConfig), + predicates, + SchemaDefinitionsDeneb.required(schemaDefinitions)); + this.specConfigElectra = SpecConfigElectra.required(specConfig); + this.predicatesElectra = PredicatesElectra.required(predicates); + if (specConfig.getOptionalEip7594Config().isPresent()) { + this.maybeEip7594Helpers = + Optional.of( + new MiscHelpersEip7594( + Eip7594.required(specConfig), + predicates, + SchemaDefinitionsElectra.required(schemaDefinitions))); + } else { + this.maybeEip7594Helpers = Optional.empty(); + } + } + + public static MiscHelpersElectra required(final MiscHelpers miscHelpers) { + return miscHelpers + .toVersionElectra() + .orElseThrow( + () -> + new IllegalArgumentException( + "Expected Electra misc helpers but got: " + + miscHelpers.getClass().getSimpleName())); + } + + @Override + public int computeProposerIndex( + final BeaconState state, final IntList indices, final Bytes32 seed) { + return computeProposerIndex( + state, + indices, + seed, + SpecConfigElectra.required(specConfig).getMaxEffectiveBalanceElectra()); + } + + @Override + public UInt64 getMaxEffectiveBalance(final Validator validator) { + return predicatesElectra.hasCompoundingWithdrawalCredential(validator) + ? specConfigElectra.getMaxEffectiveBalanceElectra() + : specConfigElectra.getMinActivationBalance(); + } + + @Override + public Validator getValidatorFromDeposit( + final BLSPublicKey pubkey, final Bytes32 withdrawalCredentials, final UInt64 amount) { + final Validator validator = + new Validator( + pubkey, + withdrawalCredentials, + ZERO, + false, + FAR_FUTURE_EPOCH, + FAR_FUTURE_EPOCH, + FAR_FUTURE_EPOCH, + FAR_FUTURE_EPOCH); + + final UInt64 maxEffectiveBalance = getMaxEffectiveBalance(validator); + final UInt64 validatorEffectiveBalance = + amount + .minusMinZero(amount.mod(specConfig.getEffectiveBalanceIncrement())) + .min(maxEffectiveBalance); + + return validator.withEffectiveBalance(validatorEffectiveBalance); + } + + @Override + public Optional toVersionElectra() { + return Optional.of(this); + } + + @Override + public boolean isFormerDepositMechanismDisabled(final BeaconState state) { + // if the next deposit to be processed by Eth1Data poll has the index of the first deposit + // processed with the new deposit flow, i.e. `eth1_deposit_index == + // deposit_requests_start_index`, we should stop Eth1Data deposits processing + return state + .getEth1DepositIndex() + .equals(BeaconStateElectra.required(state).getDepositRequestsStartIndex()); + } + + @Override + public boolean isAvailabilityOfBlobSidecarsRequiredAtEpoch( + final UInt64 currentEpoch, final UInt64 epoch) { + return getEip7594Helpers() + .map( + miscHelpersEip7594 -> + miscHelpersEip7594.isAvailabilityOfBlobSidecarsRequiredAtEpoch(currentEpoch, epoch)) + .orElseGet(() -> super.isAvailabilityOfBlobSidecarsRequiredAtEpoch(currentEpoch, epoch)); + } + + @Override + public Optional getEip7594Helpers() { + return maybeEip7594Helpers; + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/helpers/PredicatesElectra.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/helpers/PredicatesElectra.java new file mode 100644 index 00000000000..61798e22439 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/helpers/PredicatesElectra.java @@ -0,0 +1,121 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.logic.versions.electra.helpers; + +import static tech.pegasys.teku.spec.constants.WithdrawalPrefixes.COMPOUNDING_WITHDRAWAL_BYTE; + +import java.util.Optional; +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.datastructures.state.Validator; +import tech.pegasys.teku.spec.logic.common.helpers.Predicates; + +public class PredicatesElectra extends Predicates { + private final SpecConfigElectra configElectra; + + public PredicatesElectra(final SpecConfig specConfig) { + super(specConfig); + this.configElectra = SpecConfigElectra.required(specConfig); + } + + public static PredicatesElectra required(final Predicates predicates) { + return predicates + .toVersionElectra() + .orElseThrow( + () -> + new IllegalArgumentException( + "Expected Electra predicates but got " + + predicates.getClass().getSimpleName())); + } + + @Override + public Optional toVersionElectra() { + return Optional.of(this); + } + + /** + * is_partially_withdrawable_validator + * + * @param validator the validator being checked + * @param balance the validator's balance + * @return + */ + @Override + public boolean isPartiallyWithdrawableValidator(final Validator validator, final UInt64 balance) { + return hasExecutionWithdrawalCredential(validator) + && isPartiallyWithdrawableValidatorEth1CredentialsChecked(validator, balance); + } + + @Override + public boolean isPartiallyWithdrawableValidatorEth1CredentialsChecked( + final Validator validator, final UInt64 balance) { + final UInt64 maxEffectiveBalance = + hasCompoundingWithdrawalCredential(validator) + ? configElectra.getMaxEffectiveBalanceElectra() + : configElectra.getMinActivationBalance(); + final boolean hasMaxEffectiveBalance = + validator.getEffectiveBalance().equals(maxEffectiveBalance); + final boolean hasExcessBalance = balance.isGreaterThan(maxEffectiveBalance); + + return hasMaxEffectiveBalance && hasExcessBalance; + } + + /** + * is_fully_withdrawable_validator + * + * @param validator the validator being checked + * @param balance the validator's balance + * @param epoch the current epoch + * @return if the validator is exited and withdrawable + */ + @Override + public boolean isFullyWithdrawableValidator( + final Validator validator, final UInt64 balance, final UInt64 epoch) { + return hasExecutionWithdrawalCredential(validator) + && isFullyWithdrawableValidatorCredentialsChecked(validator, balance, epoch); + } + + /** + * has_execution_withdrawal_credential + * + * @param validator + * @return + */ + @Override + public boolean hasExecutionWithdrawalCredential(final Validator validator) { + return hasEth1WithdrawalCredential(validator) || hasCompoundingWithdrawalCredential(validator); + } + + /** + * has_compounding_withdrawal_credential + * + * @param validator + * @return + */ + public boolean hasCompoundingWithdrawalCredential(final Validator validator) { + return isCompoundingWithdrawalCredential(validator.getWithdrawalCredentials()); + } + + /** + * is_compounding_withdrawal_credential + * + * @param withdrawalCredentials + * @return + */ + public boolean isCompoundingWithdrawalCredential(final Bytes32 withdrawalCredentials) { + return withdrawalCredentials.get(0) == COMPOUNDING_WITHDRAWAL_BYTE; + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/operations/validation/AttestationDataValidatorElectra.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/operations/validation/AttestationDataValidatorElectra.java new file mode 100644 index 00000000000..7d2bee379ee --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/operations/validation/AttestationDataValidatorElectra.java @@ -0,0 +1,83 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.logic.versions.electra.operations.validation; + +import static tech.pegasys.teku.spec.logic.common.operations.validation.OperationInvalidReason.check; +import static tech.pegasys.teku.spec.logic.common.operations.validation.OperationInvalidReason.firstOf; + +import java.util.Optional; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.datastructures.operations.AttestationData; +import tech.pegasys.teku.spec.datastructures.state.Fork; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.logic.common.helpers.BeaconStateAccessors; +import tech.pegasys.teku.spec.logic.common.helpers.MiscHelpers; +import tech.pegasys.teku.spec.logic.common.operations.validation.AttestationDataValidator; +import tech.pegasys.teku.spec.logic.common.operations.validation.OperationInvalidReason; + +public class AttestationDataValidatorElectra implements AttestationDataValidator { + + private final SpecConfig specConfig; + private final MiscHelpers miscHelpers; + private final BeaconStateAccessors beaconStateAccessors; + + public AttestationDataValidatorElectra( + final SpecConfig specConfig, + final MiscHelpers miscHelpers, + final BeaconStateAccessors beaconStateAccessors) { + this.specConfig = specConfig; + this.miscHelpers = miscHelpers; + this.beaconStateAccessors = beaconStateAccessors; + } + + @Override + public Optional validate( + final Fork fork, final BeaconState state, final AttestationData data) { + return firstOf( + () -> + check( + data.getTarget().getEpoch().equals(beaconStateAccessors.getPreviousEpoch(state)) + || data.getTarget() + .getEpoch() + .equals(beaconStateAccessors.getCurrentEpoch(state)), + AttestationInvalidReason.NOT_FROM_CURRENT_OR_PREVIOUS_EPOCH), + () -> + check( + data.getTarget().getEpoch().equals(miscHelpers.computeEpochAtSlot(data.getSlot())), + AttestationInvalidReason.SLOT_NOT_IN_EPOCH), + () -> + check( + data.getSlot() + .plus(specConfig.getMinAttestationInclusionDelay()) + .compareTo(state.getSlot()) + <= 0, + AttestationInvalidReason.SUBMITTED_TOO_QUICKLY), + () -> + check( + data.getIndex().equals(UInt64.ZERO), + AttestationInvalidReason.COMMITTEE_INDEX_MUST_BE_ZERO), + () -> { + if (data.getTarget().getEpoch().equals(beaconStateAccessors.getCurrentEpoch(state))) { + return check( + data.getSource().equals(state.getCurrentJustifiedCheckpoint()), + AttestationInvalidReason.INCORRECT_CURRENT_JUSTIFIED_CHECKPOINT); + } else { + return check( + data.getSource().equals(state.getPreviousJustifiedCheckpoint()), + AttestationInvalidReason.INCORRECT_PREVIOUS_JUSTIFIED_CHECKPOINT); + } + }); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/operations/validation/VoluntaryExitValidatorElectra.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/operations/validation/VoluntaryExitValidatorElectra.java new file mode 100644 index 00000000000..794c0efc913 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/operations/validation/VoluntaryExitValidatorElectra.java @@ -0,0 +1,63 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.logic.versions.electra.operations.validation; + +import static tech.pegasys.teku.spec.logic.common.operations.validation.OperationInvalidReason.check; +import static tech.pegasys.teku.spec.logic.common.operations.validation.OperationInvalidReason.firstOf; + +import com.google.common.annotations.VisibleForTesting; +import java.util.Optional; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; +import tech.pegasys.teku.spec.datastructures.state.Fork; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.BeaconStateElectra; +import tech.pegasys.teku.spec.logic.common.helpers.BeaconStateAccessors; +import tech.pegasys.teku.spec.logic.common.helpers.Predicates; +import tech.pegasys.teku.spec.logic.common.operations.validation.OperationInvalidReason; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.BeaconStateAccessorsElectra; +import tech.pegasys.teku.spec.logic.versions.phase0.operations.validation.VoluntaryExitValidator; + +public class VoluntaryExitValidatorElectra extends VoluntaryExitValidator { + private final BeaconStateAccessorsElectra stateAccessorsElectra; + + public VoluntaryExitValidatorElectra( + final SpecConfig specConfig, + final Predicates predicates, + final BeaconStateAccessors beaconStateAccessors) { + super(specConfig, predicates, beaconStateAccessors); + this.stateAccessorsElectra = BeaconStateAccessorsElectra.required(beaconStateAccessors); + } + + @Override + public Optional validate( + final Fork fork, final BeaconState state, final SignedVoluntaryExit signedExit) { + final BeaconStateElectra stateElectra = BeaconStateElectra.required(state); + return firstOf( + () -> super.validate(fork, state, signedExit), + () -> validateElectraConditions(stateElectra, signedExit)); + } + + @VisibleForTesting + Optional validateElectraConditions( + final BeaconStateElectra stateElectra, final SignedVoluntaryExit exit) { + final int validatorId = exit.getValidatorId(); + return check( + stateAccessorsElectra + .getPendingBalanceToWithdraw(stateElectra, validatorId) + .equals(UInt64.ZERO), + VoluntaryExitValidator.ExitInvalidReason.pendingWithdrawalsInQueue()); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/statetransition/epoch/EpochProcessorElectra.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/statetransition/epoch/EpochProcessorElectra.java new file mode 100644 index 00000000000..ebd9a1edbc0 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/statetransition/epoch/EpochProcessorElectra.java @@ -0,0 +1,382 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.logic.versions.electra.statetransition.epoch; + +import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ZERO; +import static tech.pegasys.teku.spec.config.SpecConfig.FAR_FUTURE_EPOCH; +import static tech.pegasys.teku.spec.config.SpecConfig.GENESIS_SLOT; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import java.util.function.Supplier; +import java.util.stream.IntStream; +import tech.pegasys.teku.infrastructure.ssz.SszList; +import tech.pegasys.teku.infrastructure.ssz.SszMutableList; +import tech.pegasys.teku.infrastructure.ssz.collections.SszUInt64List; +import tech.pegasys.teku.infrastructure.time.TimeProvider; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.datastructures.state.Validator; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconStateCache; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.MutableBeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.MutableBeaconStateElectra; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingConsolidation; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingDeposit; +import tech.pegasys.teku.spec.logic.common.helpers.BeaconStateMutators; +import tech.pegasys.teku.spec.logic.common.statetransition.epoch.status.ValidatorStatus; +import tech.pegasys.teku.spec.logic.common.statetransition.epoch.status.ValidatorStatusFactory; +import tech.pegasys.teku.spec.logic.common.statetransition.epoch.status.ValidatorStatuses; +import tech.pegasys.teku.spec.logic.common.statetransition.exceptions.EpochProcessingException; +import tech.pegasys.teku.spec.logic.common.util.BeaconStateUtil; +import tech.pegasys.teku.spec.logic.common.util.ValidatorsUtil; +import tech.pegasys.teku.spec.logic.versions.altair.helpers.BeaconStateAccessorsAltair; +import tech.pegasys.teku.spec.logic.versions.capella.statetransition.epoch.EpochProcessorCapella; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.BeaconStateAccessorsElectra; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.MiscHelpersElectra; +import tech.pegasys.teku.spec.schemas.SchemaDefinitions; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; + +public class EpochProcessorElectra extends EpochProcessorCapella { + + private final UInt64 minActivationBalance; + private final BeaconStateAccessorsElectra stateAccessorsElectra; + private final SchemaDefinitionsElectra schemaDefinitionsElectra; + + public EpochProcessorElectra( + final SpecConfigElectra specConfig, + final MiscHelpersElectra miscHelpers, + final BeaconStateAccessorsAltair beaconStateAccessors, + final BeaconStateMutators beaconStateMutators, + final ValidatorsUtil validatorsUtil, + final BeaconStateUtil beaconStateUtil, + final ValidatorStatusFactory validatorStatusFactory, + final SchemaDefinitions schemaDefinitions, + final TimeProvider timeProvider) { + super( + specConfig, + miscHelpers, + beaconStateAccessors, + beaconStateMutators, + validatorsUtil, + beaconStateUtil, + validatorStatusFactory, + schemaDefinitions, + timeProvider); + this.minActivationBalance = + specConfig.toVersionElectra().orElseThrow().getMinActivationBalance(); + this.stateAccessorsElectra = BeaconStateAccessorsElectra.required(beaconStateAccessors); + this.schemaDefinitionsElectra = SchemaDefinitionsElectra.required(schemaDefinitions); + } + + /** process_registry_updates */ + @Override + public void processRegistryUpdates( + final MutableBeaconState state, final List statuses) + throws EpochProcessingException { + try { + + // Process activation eligibility and ejections + final SszMutableList validators = state.getValidators(); + final UInt64 currentEpoch = stateAccessorsElectra.getCurrentEpoch(state); + final UInt64 finalizedEpoch = state.getFinalizedCheckpoint().getEpoch(); + final UInt64 ejectionBalance = specConfig.getEjectionBalance(); + final Supplier validatorExitContextSupplier = + beaconStateMutators.createValidatorExitContextSupplier(state); + + final UInt64 activationEpoch = + miscHelpers.computeActivationExitEpoch(miscHelpers.computeEpochAtSlot(state.getSlot())); + + for (int index = 0; index < validators.size(); index++) { + final ValidatorStatus status = statuses.get(index); + + if (isEligibleForActivationQueue(status)) { + final Validator validator = validators.get(index); + if (validator.getActivationEligibilityEpoch().equals(SpecConfig.FAR_FUTURE_EPOCH)) { + state + .getValidators() + .update( + index, v -> v.withActivationEligibilityEpoch(currentEpoch.plus(UInt64.ONE))); + } + } else if (status.isActiveInCurrentEpoch() + && status.getCurrentEpochEffectiveBalance().isLessThanOrEqualTo(ejectionBalance)) { + beaconStateMutators.initiateValidatorExit(state, index, validatorExitContextSupplier); + } + // activate all eligible validators + final Validator validator = validators.get(index); + if (isEligibleForActivation(finalizedEpoch, validator)) { + state.getValidators().update(index, v -> v.withActivationEpoch(activationEpoch)); + } + } + } catch (IllegalArgumentException e) { + throw new EpochProcessingException(e); + } + } + + protected boolean isEligibleForActivation( + final UInt64 finalizedEpoch, final Validator validator) { + return validator.getActivationEpoch().equals(FAR_FUTURE_EPOCH) + && validator.getActivationEligibilityEpoch().isLessThanOrEqualTo(finalizedEpoch); + } + + /** + * is_eligible_for_activation_queue + * + * @param status - Validator status + */ + @Override + protected boolean isEligibleForActivationQueue(final ValidatorStatus status) { + return !status.isActiveInCurrentEpoch() + && status.getCurrentEpochEffectiveBalance().isGreaterThanOrEqualTo(minActivationBalance); + } + + @Override + protected UInt64 getEffectiveBalanceLimitForValidator(final Validator validator) { + return miscHelpers.getMaxEffectiveBalance(validator); + } + + // process_effective_balance_updates + @Override + public void processEffectiveBalanceUpdates( + final MutableBeaconState state, final List statuses) { + // Update effective balances with hysteresis + final SszMutableList validators = state.getValidators(); + final SszUInt64List balances = state.getBalances(); + final UInt64 hysteresisUpwardMultiplier = specConfig.getHysteresisUpwardMultiplier(); + final UInt64 hysteresisDownwardMultiplier = specConfig.getHysteresisDownwardMultiplier(); + final UInt64 hysteresisQuotient = specConfig.getHysteresisQuotient(); + final UInt64 effectiveBalanceIncrement = specConfig.getEffectiveBalanceIncrement(); + for (int index = 0; index < statuses.size(); index++) { + final ValidatorStatus status = statuses.get(index); + final UInt64 balance = balances.getElement(index); + + final UInt64 hysteresisIncrement = effectiveBalanceIncrement.dividedBy(hysteresisQuotient); + final UInt64 currentEffectiveBalance = status.getCurrentEpochEffectiveBalance(); + final Validator validator = validators.get(index); + final UInt64 maxEffectiveBalance = getEffectiveBalanceLimitForValidator(validator); + if (shouldDecreaseEffectiveBalance( + balance, hysteresisIncrement, currentEffectiveBalance, hysteresisDownwardMultiplier) + || shouldIncreaseEffectiveBalance( + balance, + hysteresisIncrement, + currentEffectiveBalance, + hysteresisUpwardMultiplier, + maxEffectiveBalance)) { + final UInt64 effectiveBalanceLimit = getEffectiveBalanceLimitForValidator(validator); + final UInt64 newEffectiveBalance = + effectiveBalanceLimit.min( + balance.minus(balance.mod(effectiveBalanceIncrement)).min(maxEffectiveBalance)); + BeaconStateCache.getTransitionCaches(state) + .getProgressiveTotalBalances() + .onEffectiveBalanceChange(status, newEffectiveBalance); + validators.set(index, validator.withEffectiveBalance(newEffectiveBalance)); + } + } + } + + /** apply_pending_deposit */ + @Override + public void applyPendingDeposits(final MutableBeaconState state, final PendingDeposit deposit) { + validatorsUtil + .getValidatorIndex(state, deposit.getPublicKey()) + .ifPresentOrElse( + validatorIndex -> + beaconStateMutators.increaseBalance(state, validatorIndex, deposit.getAmount()), + () -> { + if (isValidPendingDepositSignature(deposit)) { + beaconStateMutators.addValidatorToRegistry( + state, + deposit.getPublicKey(), + deposit.getWithdrawalCredentials(), + deposit.getAmount()); + } + }); + } + + private boolean isValidPendingDepositSignature(final PendingDeposit deposit) { + return miscHelpers.isValidDepositSignature( + deposit.getPublicKey(), + deposit.getWithdrawalCredentials(), + deposit.getAmount(), + deposit.getSignature()); + } + + /** process_pending_deposits */ + @Override + public void processPendingDeposits(final MutableBeaconState state) { + final MutableBeaconStateElectra stateElectra = MutableBeaconStateElectra.required(state); + + final UInt64 nextEpoch = beaconStateAccessors.getCurrentEpoch(state).plus(UInt64.ONE); + final UInt64 availableForProcessing = + stateElectra + .getDepositBalanceToConsume() + .plus(stateAccessorsElectra.getActivationExitChurnLimit(stateElectra)); + UInt64 processedAmount = UInt64.ZERO; + int nextDepositIndex = 0; + final List depositsToPostpone = new ArrayList<>(); + boolean isChurnLimitReached = false; + final UInt64 finalizedSlot = + miscHelpers.computeStartSlotAtEpoch(stateElectra.getFinalizedCheckpoint().getEpoch()); + + for (final PendingDeposit deposit : stateElectra.getPendingDeposits()) { + // Do not process deposit requests if Eth1 bridge deposits are not yet applied. + final boolean isDepositRequest = deposit.getSlot().isGreaterThan(GENESIS_SLOT); + final boolean hasPendingEth1BridgeDeposits = + stateElectra + .getEth1DepositIndex() + .isLessThan(stateElectra.getDepositRequestsStartIndex()); + if (isDepositRequest && hasPendingEth1BridgeDeposits) { + break; + } + + // Check if deposit has been finalized, otherwise stop processing + if (deposit.getSlot().isGreaterThan(finalizedSlot)) { + break; + } + + // Check if number of processed deposits has not reached the limit, otherwise, stop processing + if (nextDepositIndex + >= SpecConfigElectra.required(specConfig).getMaxPendingDepositsPerEpoch()) { + break; + } + + final Optional maybeValidatorIndex = + validatorsUtil.getValidatorIndex(state, deposit.getPublicKey()); + boolean isValidatorExited = false; + boolean isValidatorWithdrawn = false; + if (maybeValidatorIndex.isPresent()) { + Validator validator = state.getValidators().get(maybeValidatorIndex.get()); + isValidatorExited = validator.getExitEpoch().isLessThan(FAR_FUTURE_EPOCH); + isValidatorWithdrawn = validator.getWithdrawableEpoch().isLessThan(nextEpoch); + } + + if (isValidatorWithdrawn) { + // Deposited balance will never become active. Increase balance but do not consume churn + applyPendingDeposits(state, deposit); + } else if (isValidatorExited) { + // Validator is exiting, postpone the deposit until after withdrawable epoch + depositsToPostpone.add(deposit); + } else { + // Check if deposit fits in the churn, otherwise, do no more deposit processing in this + // epoch + isChurnLimitReached = + processedAmount.plus(deposit.getAmount()).isGreaterThan(availableForProcessing); + if (isChurnLimitReached) { + break; + } + // Consume churn and apply deposit + processedAmount = processedAmount.plus(deposit.getAmount()); + applyPendingDeposits(state, deposit); + } + + // Regardless of how the deposit was handled, we move on in the queue + nextDepositIndex += 1; + } + + final SszMutableList pendingDeposits = stateElectra.getPendingDeposits(); + final ArrayList newPendingDeposits = new ArrayList<>(); + IntStream.range(nextDepositIndex, pendingDeposits.size()) + .sorted() + .forEach(index -> newPendingDeposits.add(pendingDeposits.get(index))); + newPendingDeposits.addAll(depositsToPostpone); + stateElectra.setPendingDeposits( + schemaDefinitionsElectra.getPendingDepositsSchema().createFromElements(newPendingDeposits)); + + // Accumulate churn only if the churn limit has been hit + if (isChurnLimitReached) { + stateElectra.setDepositBalanceToConsume(availableForProcessing.minusMinZero(processedAmount)); + } else { + stateElectra.setDepositBalanceToConsume(UInt64.ZERO); + } + } + + /** process_pending_consolidations */ + @Override + public void processPendingConsolidations(final MutableBeaconState state) { + final MutableBeaconStateElectra stateElectra = MutableBeaconStateElectra.required(state); + int nextPendingBalanceConsolidation = 0; + final SszList pendingConsolidations = + stateElectra.getPendingConsolidations(); + final UInt64 nextEpoch = stateAccessorsElectra.getCurrentEpoch(state).plus(1L); + + for (final PendingConsolidation pendingConsolidation : pendingConsolidations) { + final Validator sourceValidator = + state.getValidators().get(pendingConsolidation.getSourceIndex()); + if (sourceValidator.isSlashed()) { + nextPendingBalanceConsolidation++; + continue; + } + if (sourceValidator.getWithdrawableEpoch().isGreaterThan(nextEpoch)) { + break; + } + + final UInt64 activeBalance = + stateAccessorsElectra.getActiveBalance(state, pendingConsolidation.getSourceIndex()); + beaconStateMutators.decreaseBalance( + state, pendingConsolidation.getSourceIndex(), activeBalance); + beaconStateMutators.increaseBalance( + state, pendingConsolidation.getTargetIndex(), activeBalance); + + nextPendingBalanceConsolidation++; + } + if (pendingConsolidations.size() <= nextPendingBalanceConsolidation) { + stateElectra.setPendingConsolidations( + schemaDefinitionsElectra.getPendingConsolidationsSchema().createFromElements(List.of())); + } else { + final List newList = + pendingConsolidations + .asList() + .subList(nextPendingBalanceConsolidation, pendingConsolidations.size()); + stateElectra.setPendingConsolidations( + schemaDefinitionsElectra.getPendingConsolidationsSchema().createFromElements(newList)); + } + } + + /** Processes slashings */ + @Override + public void processSlashings( + final MutableBeaconState state, final ValidatorStatuses validatorStatuses) { + final UInt64 totalBalance = + validatorStatuses.getTotalBalances().getCurrentEpochActiveValidators(); + final UInt64 epoch = beaconStateAccessors.getCurrentEpoch(state); + final UInt64 adjustedTotalSlashingBalance = + state + .getSlashings() + .streamUnboxed() + .reduce(ZERO, UInt64::plus) + .times(getProportionalSlashingMultiplier()) + .min(totalBalance); + + final List validatorStatusList = validatorStatuses.getStatuses(); + final int halfEpochsPerSlashingsVector = specConfig.getEpochsPerSlashingsVector() / 2; + + final UInt64 increment = specConfig.getEffectiveBalanceIncrement(); + final UInt64 penaltyPerEffectiveBalanceIncrement = + adjustedTotalSlashingBalance.dividedBy(totalBalance.dividedBy(increment)); + for (int index = 0; index < validatorStatusList.size(); index++) { + final ValidatorStatus status = validatorStatusList.get(index); + if (status.isSlashed() + && epoch.plus(halfEpochsPerSlashingsVector).equals(status.getWithdrawableEpoch())) { + + // EIP-7251 + final UInt64 effectiveBalanceIncrements = + status.getCurrentEpochEffectiveBalance().dividedBy(increment); + final UInt64 penalty = + penaltyPerEffectiveBalanceIncrement.times(effectiveBalanceIncrements); + beaconStateMutators.decreaseBalance(state, index, penalty); + } + } + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/util/AttestationUtilElectra.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/util/AttestationUtilElectra.java new file mode 100644 index 00000000000..943536e7bf6 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/electra/util/AttestationUtilElectra.java @@ -0,0 +1,96 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.logic.versions.electra.util; + +import it.unimi.dsi.fastutil.ints.IntArrayList; +import it.unimi.dsi.fastutil.ints.IntList; +import java.util.List; +import java.util.stream.IntStream; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlockSummary; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.datastructures.operations.AttestationData; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.logic.common.helpers.BeaconStateAccessors; +import tech.pegasys.teku.spec.logic.common.helpers.MiscHelpers; +import tech.pegasys.teku.spec.logic.versions.deneb.util.AttestationUtilDeneb; +import tech.pegasys.teku.spec.schemas.SchemaDefinitions; + +public class AttestationUtilElectra extends AttestationUtilDeneb { + public AttestationUtilElectra( + final SpecConfig specConfig, + final SchemaDefinitions schemaDefinitions, + final BeaconStateAccessors beaconStateAccessors, + final MiscHelpers miscHelpers) { + super(specConfig, schemaDefinitions, beaconStateAccessors, miscHelpers); + } + + /** + * Return the attesting indices corresponding to ``aggregation_bits`` and ``committee_bits``. + * + * @param state + * @param attestation + * @return + * @throws IllegalArgumentException + * @see + * https://github.com/ethereum/consensus-specs/blob/dev/specs/electra/beacon-chain.md#modified-get_attesting_indices + */ + @Override + public IntList getAttestingIndices(final BeaconState state, final Attestation attestation) { + final List committeeIndices = attestation.getCommitteeIndicesRequired(); + final SszBitlist aggregationBits = attestation.getAggregationBits(); + final IntList attestingIndices = new IntArrayList(); + int committeeOffset = 0; + for (final UInt64 committeeIndex : committeeIndices) { + final IntList committee = + beaconStateAccessors.getBeaconCommittee( + state, attestation.getData().getSlot(), committeeIndex); + final IntList committeeAttesters = + getCommitteeAttesters(committee, aggregationBits, committeeOffset); + attestingIndices.addAll(committeeAttesters); + committeeOffset += committee.size(); + } + return attestingIndices; + } + + public IntList getCommitteeAttesters( + final IntList committee, final SszBitlist aggregationBits, final int committeeOffset) { + return IntList.of( + streamCommitteeAttesters(committee, aggregationBits, committeeOffset).toArray()); + } + + public IntStream streamCommitteeAttesters( + final IntList committee, final SszBitlist aggregationBits, final int committeeOffset) { + return IntStream.range(committeeOffset, committeeOffset + committee.size()) + .filter(aggregationBits::isSet) + .map(attesterIndex -> committee.getInt(attesterIndex - committeeOffset)); + } + + /** + * In electra, attestationData must have committee index set to 0 + * + * @see + * https://github.com/ethereum/consensus-specs/blob/dev/specs/electra/validator.md#construct-attestation + */ + @Override + public AttestationData getGenericAttestationData( + final UInt64 slot, + final BeaconState state, + final BeaconBlockSummary block, + final UInt64 committeeIndex) { + return super.getGenericAttestationData(slot, state, block, UInt64.ZERO); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/eip7594/helpers/MiscHelpersEip7594.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/feature/eip7594/helpers/MiscHelpersEip7594.java similarity index 90% rename from ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/eip7594/helpers/MiscHelpersEip7594.java rename to ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/feature/eip7594/helpers/MiscHelpersEip7594.java index 40b6d0888dd..d9ddca49821 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/eip7594/helpers/MiscHelpersEip7594.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/feature/eip7594/helpers/MiscHelpersEip7594.java @@ -11,7 +11,7 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.spec.logic.versions.eip7594.helpers; +package tech.pegasys.teku.spec.logic.versions.feature.eip7594.helpers; import static tech.pegasys.teku.spec.logic.common.helpers.MathHelpers.bytesToUInt64; import static tech.pegasys.teku.spec.logic.common.helpers.MathHelpers.uint256ToBytes; @@ -21,7 +21,6 @@ import java.util.ArrayList; import java.util.Collections; import java.util.List; -import java.util.Optional; import java.util.stream.Collectors; import java.util.stream.IntStream; import java.util.stream.Stream; @@ -38,7 +37,7 @@ import tech.pegasys.teku.kzg.KZGCellAndProof; import tech.pegasys.teku.kzg.KZGCellID; import tech.pegasys.teku.kzg.KZGCellWithColumnId; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.features.Eip7594; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.Blob; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.Cell; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumn; @@ -50,43 +49,44 @@ import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockHeader; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594.BeaconBlockBodyEip7594; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594.BeaconBlockBodySchemaEip7594; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.deneb.BeaconBlockBodyDeneb; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra.BeaconBlockBodySchemaElectra; import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; import tech.pegasys.teku.spec.datastructures.type.SszKZGProof; import tech.pegasys.teku.spec.logic.common.helpers.MiscHelpers; import tech.pegasys.teku.spec.logic.common.helpers.Predicates; -import tech.pegasys.teku.spec.logic.versions.deneb.helpers.MiscHelpersDeneb; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsEip7594; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; -public class MiscHelpersEip7594 extends MiscHelpersDeneb { +public class MiscHelpersEip7594 { private static final MathContext BIGDECIMAL_PRECISION = MathContext.DECIMAL128; public static MiscHelpersEip7594 required(final MiscHelpers miscHelpers) { return miscHelpers - .toVersionEip7594() + .getEip7594Helpers() .orElseThrow( () -> new IllegalArgumentException( - "Expected EIP7594 misc helpers but got: " + "Expected misc helpers with EIP7594 but got: " + miscHelpers.getClass().getSimpleName())); } - private final SpecConfigEip7594 specConfigEip7594; + private final Eip7594 specConfigEip7594; private final Predicates predicates; private final SchemaDefinitionsEip7594 schemaDefinitions; + private final SchemaDefinitionsElectra schemaDefinitionsElectra; public MiscHelpersEip7594( - final SpecConfigEip7594 specConfig, + final Eip7594 specConfig, final Predicates predicates, - final SchemaDefinitionsEip7594 schemaDefinitions) { - super(specConfig, predicates, schemaDefinitions); + final SchemaDefinitionsElectra schemaDefinitionsElectra) { this.predicates = predicates; this.specConfigEip7594 = specConfig; - this.schemaDefinitions = schemaDefinitions; + this.schemaDefinitions = SchemaDefinitionsEip7594.required(schemaDefinitionsElectra); + this.schemaDefinitionsElectra = schemaDefinitionsElectra; } - public UInt64 computeSubnetForDataColumnSidecar(UInt64 columnIndex) { + public UInt64 computeSubnetForDataColumnSidecar(final UInt64 columnIndex) { return columnIndex.mod(specConfigEip7594.getDataColumnSidecarSubnetCount()); } @@ -112,7 +112,7 @@ public List computeCustodySubnetIndexes(final UInt256 nodeId, final int .toList(); } - private UInt256 incrementByModule(UInt256 n) { + private UInt256 incrementByModule(final UInt256 n) { if (n.equals(UInt256.MAX_VALUE)) { return UInt256.ZERO; } else { @@ -121,7 +121,7 @@ private UInt256 incrementByModule(UInt256 n) { } public List computeCustodyColumnIndexes(final UInt256 nodeId, final int subnetCount) { - List subnetIds = computeCustodySubnetIndexes(nodeId, subnetCount); + final List subnetIds = computeCustodySubnetIndexes(nodeId, subnetCount); final int columnsPerSubnet = specConfigEip7594.getNumberOfColumns() / specConfigEip7594.getDataColumnSidecarSubnetCount(); @@ -143,8 +143,8 @@ public List computeDataColumnSidecarBackboneSubnets( return computeCustodySubnetIndexes(nodeId, subnetCount); } - @Override - public boolean verifyDataColumnSidecarKzgProof(KZG kzg, DataColumnSidecar dataColumnSidecar) { + public boolean verifyDataColumnSidecarKzgProof( + final KZG kzg, final DataColumnSidecar dataColumnSidecar) { final int dataColumns = specConfigEip7594.getNumberOfColumns(); if (dataColumnSidecar.getIndex().isGreaterThanOrEqualTo(dataColumns)) { return false; @@ -174,7 +174,6 @@ public boolean verifyDataColumnSidecarKzgProof(KZG kzg, DataColumnSidecar dataCo dataColumnSidecar.getSszKZGProofs().stream().map(SszKZGProof::getKZGProof).toList()); } - @Override public boolean verifyDataColumnSidecarInclusionProof(final DataColumnSidecar dataColumnSidecar) { if (dataColumnSidecar.getSszKZGCommitments().isEmpty()) { return false; @@ -189,7 +188,7 @@ public boolean verifyDataColumnSidecarInclusionProof(final DataColumnSidecar dat public int getBlockBodyKzgCommitmentsGeneralizedIndex() { return (int) - BeaconBlockBodySchemaEip7594.required(schemaDefinitions.getBeaconBlockBodySchema()) + BeaconBlockBodySchemaElectra.required(schemaDefinitionsElectra.getBeaconBlockBodySchema()) .getBlobKzgCommitmentsGeneralizedIndex(); } @@ -244,8 +243,8 @@ public List constructDataColumnSidecars( if (extendedMatrix.isEmpty()) { return Collections.emptyList(); } - final BeaconBlockBodyEip7594 beaconBlockBody = - BeaconBlockBodyEip7594.required(beaconBlock.getBody()); + final BeaconBlockBodyDeneb beaconBlockBody = + BeaconBlockBodyDeneb.required(beaconBlock.getBody()); final SszList sszKZGCommitments = beaconBlockBody.getBlobKzgCommitments(); final List kzgCommitmentsInclusionProof = computeDataColumnKzgCommitmentsInclusionProof(beaconBlockBody); @@ -256,7 +255,7 @@ public List constructDataColumnSidecars( final SszListSchema kzgProofsSchema = dataColumnSidecarSchema.getKzgProofsSchema(); - int columnCount = extendedMatrix.getFirst().size(); + final int columnCount = extendedMatrix.getFirst().size(); return IntStream.range(0, columnCount) .mapToObj( @@ -391,9 +390,9 @@ private double hypergeomCdf(final UInt64 k, final UInt64 M, final UInt64 n, fina .sum(); } - @Override - public boolean isAvailabilityOfBlobSidecarsRequiredAtEpoch(UInt64 currentEpoch, UInt64 epoch) { - return false; + public boolean isAvailabilityOfBlobSidecarsRequiredAtEpoch( + final UInt64 currentEpoch, final UInt64 epoch) { + return !epoch.isGreaterThanOrEqualTo(specConfigEip7594.getEip7594FeatureEpoch()); } public boolean isAvailabilityOfDataColumnSidecarsRequiredAtEpoch( @@ -402,9 +401,4 @@ public boolean isAvailabilityOfDataColumnSidecarsRequiredAtEpoch( .minusMinZero(epoch) .isLessThanOrEqualTo(specConfigEip7594.getMinEpochsForDataColumnSidecarsRequests()); } - - @Override - public Optional toVersionEip7594() { - return Optional.of(this); - } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/eip7594/SpecLogicEip7594.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/fulu/SpecLogicFulu.java similarity index 66% rename from ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/eip7594/SpecLogicEip7594.java rename to ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/fulu/SpecLogicFulu.java index 64a67394ab5..3ce61947692 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/eip7594/SpecLogicEip7594.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/fulu/SpecLogicFulu.java @@ -11,10 +11,12 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.spec.logic.versions.eip7594; +package tech.pegasys.teku.spec.logic.versions.fulu; import java.util.Optional; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.infrastructure.time.TimeProvider; +import tech.pegasys.teku.spec.config.SpecConfigFulu; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsDataCodec; import tech.pegasys.teku.spec.logic.common.AbstractSpecLogic; import tech.pegasys.teku.spec.logic.common.helpers.Predicates; import tech.pegasys.teku.spec.logic.common.operations.OperationSignatureVerifier; @@ -28,32 +30,33 @@ import tech.pegasys.teku.spec.logic.common.util.LightClientUtil; import tech.pegasys.teku.spec.logic.common.util.SyncCommitteeUtil; import tech.pegasys.teku.spec.logic.common.util.ValidatorsUtil; -import tech.pegasys.teku.spec.logic.versions.altair.helpers.BeaconStateAccessorsAltair; import tech.pegasys.teku.spec.logic.versions.altair.statetransition.epoch.ValidatorStatusFactoryAltair; import tech.pegasys.teku.spec.logic.versions.bellatrix.helpers.BeaconStateMutatorsBellatrix; import tech.pegasys.teku.spec.logic.versions.bellatrix.helpers.BellatrixTransitionHelpers; import tech.pegasys.teku.spec.logic.versions.bellatrix.util.BlindBlockUtilBellatrix; -import tech.pegasys.teku.spec.logic.versions.capella.block.BlockProcessorCapella; import tech.pegasys.teku.spec.logic.versions.capella.operations.validation.OperationValidatorCapella; -import tech.pegasys.teku.spec.logic.versions.capella.statetransition.epoch.EpochProcessorCapella; -import tech.pegasys.teku.spec.logic.versions.deneb.helpers.BeaconStateAccessorsDeneb; import tech.pegasys.teku.spec.logic.versions.deneb.helpers.MiscHelpersDeneb; -import tech.pegasys.teku.spec.logic.versions.deneb.operations.validation.AttestationDataValidatorDeneb; -import tech.pegasys.teku.spec.logic.versions.deneb.util.AttestationUtilDeneb; import tech.pegasys.teku.spec.logic.versions.deneb.util.ForkChoiceUtilDeneb; -import tech.pegasys.teku.spec.logic.versions.eip7594.block.BlockProcessorEip7594; -import tech.pegasys.teku.spec.logic.versions.eip7594.forktransition.Eip7594StateUpgrade; -import tech.pegasys.teku.spec.logic.versions.eip7594.helpers.MiscHelpersEip7594; -import tech.pegasys.teku.spec.schemas.SchemaDefinitionsEip7594; +import tech.pegasys.teku.spec.logic.versions.electra.block.BlockProcessorElectra; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.BeaconStateAccessorsElectra; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.BeaconStateMutatorsElectra; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.MiscHelpersElectra; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.PredicatesElectra; +import tech.pegasys.teku.spec.logic.versions.electra.operations.validation.AttestationDataValidatorElectra; +import tech.pegasys.teku.spec.logic.versions.electra.operations.validation.VoluntaryExitValidatorElectra; +import tech.pegasys.teku.spec.logic.versions.electra.statetransition.epoch.EpochProcessorElectra; +import tech.pegasys.teku.spec.logic.versions.electra.util.AttestationUtilElectra; +import tech.pegasys.teku.spec.logic.versions.fulu.forktransition.FuluStateUpgrade; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; -public class SpecLogicEip7594 extends AbstractSpecLogic { +public class SpecLogicFulu extends AbstractSpecLogic { private final Optional syncCommitteeUtil; private final Optional lightClientUtil; - private SpecLogicEip7594( + private SpecLogicFulu( final Predicates predicates, final MiscHelpersDeneb miscHelpers, - final BeaconStateAccessorsAltair beaconStateAccessors, + final BeaconStateAccessorsElectra beaconStateAccessors, final BeaconStateMutatorsBellatrix beaconStateMutators, final OperationSignatureVerifier operationSignatureVerifier, final ValidatorsUtil validatorsUtil, @@ -61,14 +64,14 @@ private SpecLogicEip7594( final AttestationUtil attestationUtil, final OperationValidator operationValidator, final ValidatorStatusFactoryAltair validatorStatusFactory, - final EpochProcessorCapella epochProcessor, - final BlockProcessorCapella blockProcessor, + final EpochProcessorElectra epochProcessor, + final BlockProcessorElectra blockProcessor, final ForkChoiceUtil forkChoiceUtil, final BlockProposalUtil blockProposalUtil, final BlindBlockUtil blindBlockUtil, final SyncCommitteeUtil syncCommitteeUtil, final LightClientUtil lightClientUtil, - final Eip7594StateUpgrade stateUpgrade) { + final FuluStateUpgrade stateUpgrade) { super( predicates, miscHelpers, @@ -90,16 +93,19 @@ private SpecLogicEip7594( this.lightClientUtil = Optional.of(lightClientUtil); } - public static SpecLogicEip7594 create( - final SpecConfigEip7594 config, final SchemaDefinitionsEip7594 schemaDefinitions) { + public static SpecLogicFulu create( + final SpecConfigFulu config, + final SchemaDefinitionsElectra schemaDefinitions, + final TimeProvider timeProvider) { // Helpers - final Predicates predicates = new Predicates(config); - final MiscHelpersEip7594 miscHelpers = - new MiscHelpersEip7594(config, predicates, schemaDefinitions); - final BeaconStateAccessorsDeneb beaconStateAccessors = - new BeaconStateAccessorsDeneb(config, predicates, miscHelpers); - final BeaconStateMutatorsBellatrix beaconStateMutators = - new BeaconStateMutatorsBellatrix(config, miscHelpers, beaconStateAccessors); + final PredicatesElectra predicates = new PredicatesElectra(config); + final MiscHelpersElectra miscHelpers = + new MiscHelpersElectra(config, predicates, schemaDefinitions); + final BeaconStateAccessorsElectra beaconStateAccessors = + new BeaconStateAccessorsElectra(config, predicates, miscHelpers); + final BeaconStateMutatorsElectra beaconStateMutators = + new BeaconStateMutatorsElectra( + config, miscHelpers, beaconStateAccessors, schemaDefinitions); // Operation validation final OperationSignatureVerifier operationSignatureVerifier = @@ -112,12 +118,18 @@ public static SpecLogicEip7594 create( new BeaconStateUtil( config, schemaDefinitions, predicates, miscHelpers, beaconStateAccessors); final AttestationUtil attestationUtil = - new AttestationUtilDeneb(config, schemaDefinitions, beaconStateAccessors, miscHelpers); + new AttestationUtilElectra(config, schemaDefinitions, beaconStateAccessors, miscHelpers); final AttestationDataValidator attestationDataValidator = - new AttestationDataValidatorDeneb(config, miscHelpers, beaconStateAccessors); + new AttestationDataValidatorElectra(config, miscHelpers, beaconStateAccessors); + final VoluntaryExitValidatorElectra voluntaryExitValidatorElectra = + new VoluntaryExitValidatorElectra(config, predicates, beaconStateAccessors); final OperationValidator operationValidator = new OperationValidatorCapella( - config, predicates, beaconStateAccessors, attestationDataValidator, attestationUtil); + predicates, + beaconStateAccessors, + attestationDataValidator, + attestationUtil, + voluntaryExitValidatorElectra); final ValidatorStatusFactoryAltair validatorStatusFactory = new ValidatorStatusFactoryAltair( config, @@ -126,8 +138,8 @@ public static SpecLogicEip7594 create( predicates, miscHelpers, beaconStateAccessors); - final EpochProcessorCapella epochProcessor = - new EpochProcessorCapella( + final EpochProcessorElectra epochProcessor = + new EpochProcessorElectra( config, miscHelpers, beaconStateAccessors, @@ -135,14 +147,17 @@ public static SpecLogicEip7594 create( validatorsUtil, beaconStateUtil, validatorStatusFactory, - schemaDefinitions); + schemaDefinitions, + timeProvider); final SyncCommitteeUtil syncCommitteeUtil = new SyncCommitteeUtil( beaconStateAccessors, validatorsUtil, config, miscHelpers, schemaDefinitions); final LightClientUtil lightClientUtil = new LightClientUtil(beaconStateAccessors, syncCommitteeUtil, schemaDefinitions); - final BlockProcessorEip7594 blockProcessor = - new BlockProcessorEip7594( + final ExecutionRequestsDataCodec executionRequestsDataCodec = + new ExecutionRequestsDataCodec(schemaDefinitions.getExecutionRequestsSchema()); + final BlockProcessorElectra blockProcessor = + new BlockProcessorElectra( config, predicates, miscHelpers, @@ -154,7 +169,8 @@ public static SpecLogicEip7594 create( attestationUtil, validatorsUtil, operationValidator, - schemaDefinitions); + schemaDefinitions, + executionRequestsDataCodec); final ForkChoiceUtil forkChoiceUtil = new ForkChoiceUtilDeneb( config, beaconStateAccessors, epochProcessor, attestationUtil, miscHelpers); @@ -164,10 +180,9 @@ public static SpecLogicEip7594 create( final BlindBlockUtilBellatrix blindBlockUtil = new BlindBlockUtilBellatrix(schemaDefinitions); // State upgrade - final Eip7594StateUpgrade stateUpgrade = - new Eip7594StateUpgrade(config, schemaDefinitions, beaconStateAccessors); + final FuluStateUpgrade stateUpgrade = new FuluStateUpgrade(config, beaconStateAccessors); - return new SpecLogicEip7594( + return new SpecLogicFulu( predicates, miscHelpers, beaconStateAccessors, diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/fulu/forktransition/FuluStateUpgrade.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/fulu/forktransition/FuluStateUpgrade.java new file mode 100644 index 00000000000..8f84e96139f --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/fulu/forktransition/FuluStateUpgrade.java @@ -0,0 +1,47 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.logic.versions.fulu.forktransition; + +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.config.SpecConfigFulu; +import tech.pegasys.teku.spec.datastructures.state.Fork; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.BeaconStateElectra; +import tech.pegasys.teku.spec.logic.common.forktransition.StateUpgrade; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.BeaconStateAccessorsElectra; + +public class FuluStateUpgrade implements StateUpgrade { + + private final SpecConfigFulu specConfig; + private final BeaconStateAccessorsElectra beaconStateAccessors; + + public FuluStateUpgrade( + final SpecConfigFulu specConfig, final BeaconStateAccessorsElectra beaconStateAccessors) { + this.specConfig = specConfig; + this.beaconStateAccessors = beaconStateAccessors; + } + + @Override + public BeaconStateElectra upgrade(final BeaconState preState) { + final UInt64 epoch = beaconStateAccessors.getCurrentEpoch(preState); + final BeaconStateElectra preStateElectra = BeaconStateElectra.required(preState); + return preStateElectra.updatedElectra( + state -> + state.setFork( + new Fork( + preState.getFork().getCurrentVersion(), + specConfig.getFuluForkVersion(), + epoch))); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/phase0/SpecLogicPhase0.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/phase0/SpecLogicPhase0.java index aa357c516d5..09525caeb62 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/phase0/SpecLogicPhase0.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/phase0/SpecLogicPhase0.java @@ -14,6 +14,7 @@ package tech.pegasys.teku.spec.logic.versions.phase0; import java.util.Optional; +import tech.pegasys.teku.infrastructure.time.TimeProvider; import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.logic.common.AbstractSpecLogic; import tech.pegasys.teku.spec.logic.common.helpers.BeaconStateAccessors; @@ -35,6 +36,7 @@ import tech.pegasys.teku.spec.logic.versions.phase0.helpers.BeaconStateAccessorsPhase0; import tech.pegasys.teku.spec.logic.versions.phase0.operations.validation.AttestationDataValidatorPhase0; import tech.pegasys.teku.spec.logic.versions.phase0.operations.validation.OperationValidatorPhase0; +import tech.pegasys.teku.spec.logic.versions.phase0.operations.validation.VoluntaryExitValidator; import tech.pegasys.teku.spec.logic.versions.phase0.statetransition.epoch.EpochProcessorPhase0; import tech.pegasys.teku.spec.logic.versions.phase0.statetransition.epoch.ValidatorStatusFactoryPhase0; import tech.pegasys.teku.spec.logic.versions.phase0.util.AttestationUtilPhase0; @@ -77,7 +79,9 @@ private SpecLogicPhase0( } public static SpecLogicPhase0 create( - final SpecConfig config, final SchemaDefinitions schemaDefinitions) { + final SpecConfig config, + final SchemaDefinitions schemaDefinitions, + final TimeProvider timeProvider) { // Helpers final Predicates predicates = new Predicates(config); final MiscHelpers miscHelpers = new MiscHelpers(config); @@ -100,9 +104,15 @@ public static SpecLogicPhase0 create( new AttestationUtilPhase0(config, schemaDefinitions, beaconStateAccessors, miscHelpers); final AttestationDataValidator attestationDataValidator = new AttestationDataValidatorPhase0(config, miscHelpers, beaconStateAccessors); + final VoluntaryExitValidator voluntaryExitValidator = + new VoluntaryExitValidator(config, predicates, beaconStateAccessors); final OperationValidator operationValidator = new OperationValidatorPhase0( - config, predicates, beaconStateAccessors, attestationDataValidator, attestationUtil); + predicates, + beaconStateAccessors, + attestationDataValidator, + attestationUtil, + voluntaryExitValidator); final ValidatorStatusFactoryPhase0 validatorStatusFactory = new ValidatorStatusFactoryPhase0( config, beaconStateUtil, attestationUtil, beaconStateAccessors, predicates); @@ -115,7 +125,8 @@ public static SpecLogicPhase0 create( validatorsUtil, beaconStateUtil, validatorStatusFactory, - schemaDefinitions); + schemaDefinitions, + timeProvider); final BlockProcessorPhase0 blockProcessor = new BlockProcessorPhase0( config, diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/phase0/block/BlockProcessorPhase0.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/phase0/block/BlockProcessorPhase0.java index 89448be0760..92481a2ce14 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/phase0/block/BlockProcessorPhase0.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/phase0/block/BlockProcessorPhase0.java @@ -13,7 +13,6 @@ package tech.pegasys.teku.spec.logic.versions.phase0.block; -import java.util.List; import java.util.Optional; import tech.pegasys.teku.bls.BLSSignatureVerifier; import tech.pegasys.teku.infrastructure.ssz.SszList; @@ -23,8 +22,8 @@ import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.SyncAggregate; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSummary; +import tech.pegasys.teku.spec.datastructures.execution.ExpectedWithdrawals; import tech.pegasys.teku.spec.datastructures.execution.NewPayloadRequest; -import tech.pegasys.teku.spec.datastructures.execution.versions.capella.Withdrawal; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChange; @@ -107,7 +106,7 @@ public void processSyncAggregate( } @Override - public UInt64 computeParticipantReward(BeaconStateAltair state) { + public UInt64 computeParticipantReward(final BeaconStateAltair state) { return UInt64.ZERO; } @@ -163,7 +162,7 @@ public void processWithdrawals( } @Override - public Optional> getExpectedWithdrawals(final BeaconState preState) { - return Optional.empty(); + public ExpectedWithdrawals getExpectedWithdrawals(final BeaconState preState) { + return ExpectedWithdrawals.NOOP; } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/phase0/operations/validation/OperationValidatorPhase0.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/phase0/operations/validation/OperationValidatorPhase0.java index 50e471ae9ec..082515c1aad 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/phase0/operations/validation/OperationValidatorPhase0.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/phase0/operations/validation/OperationValidatorPhase0.java @@ -14,7 +14,6 @@ package tech.pegasys.teku.spec.logic.versions.phase0.operations.validation; import java.util.Optional; -import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; import tech.pegasys.teku.spec.datastructures.operations.BlsToExecutionChange; @@ -38,18 +37,17 @@ public class OperationValidatorPhase0 implements OperationValidator { private final VoluntaryExitValidator voluntaryExitValidator; public OperationValidatorPhase0( - final SpecConfig specConfig, final Predicates predicates, final BeaconStateAccessors beaconStateAccessors, final AttestationDataValidator attestationDataValidator, - final AttestationUtil attestationUtil) { + final AttestationUtil attestationUtil, + final VoluntaryExitValidator voluntaryExitValidator) { this.attestationDataValidator = attestationDataValidator; this.attesterSlashingValidator = new AttesterSlashingValidator(predicates, beaconStateAccessors, attestationUtil); this.proposerSlashingValidator = new ProposerSlashingValidator(predicates, beaconStateAccessors); - this.voluntaryExitValidator = - new VoluntaryExitValidator(specConfig, predicates, beaconStateAccessors); + this.voluntaryExitValidator = voluntaryExitValidator; } @Override @@ -69,7 +67,7 @@ public Optional validateAttesterSlashing( final Fork fork, final BeaconState state, final AttesterSlashing attesterSlashing, - SlashedIndicesCaptor slashedIndicesCaptor) { + final SlashedIndicesCaptor slashedIndicesCaptor) { return attesterSlashingValidator.validate(fork, state, attesterSlashing, slashedIndicesCaptor); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/phase0/operations/validation/VoluntaryExitValidator.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/phase0/operations/validation/VoluntaryExitValidator.java index 050a70210e0..1e553c8c53b 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/phase0/operations/validation/VoluntaryExitValidator.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/phase0/operations/validation/VoluntaryExitValidator.java @@ -37,7 +37,7 @@ public class VoluntaryExitValidator private final Predicates predicates; private final BeaconStateAccessors beaconStateAccessors; - VoluntaryExitValidator( + public VoluntaryExitValidator( final SpecConfig specConfig, final Predicates predicates, final BeaconStateAccessors beaconStateAccessors) { @@ -49,7 +49,7 @@ public class VoluntaryExitValidator @Override public Optional validate( final Fork fork, final BeaconState state, final SignedVoluntaryExit signedExit) { - VoluntaryExit exit = signedExit.getMessage(); + final VoluntaryExit exit = signedExit.getMessage(); return firstOf( () -> check( @@ -80,7 +80,7 @@ public Optional validate( }); } - private Validator getValidator(BeaconState state, VoluntaryExit exit) { + private Validator getValidator(final BeaconState state, final VoluntaryExit exit) { return state.getValidators().get(exit.getValidatorIndex().intValue()); } @@ -102,12 +102,17 @@ public static OperationInvalidReason submittedTooEarly() { return () -> "Specified exit epoch is still in the future"; } - public static OperationInvalidReason validatorTooYoung(UInt64 exitEpoch) { + public static OperationInvalidReason validatorTooYoung(final UInt64 exitEpoch) { return () -> "Validator cannot exit until epoch " + exitEpoch; } public static OperationInvalidReason invalidSignature() { return () -> "Signature is invalid"; } + + public static OperationInvalidReason pendingWithdrawalsInQueue() { + return () -> + "Validator cannot be exited while there are pending withdrawals in the withdrawal queue"; + } } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/phase0/statetransition/epoch/EpochProcessorPhase0.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/phase0/statetransition/epoch/EpochProcessorPhase0.java index 988ab9af061..4c57bd3b650 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/phase0/statetransition/epoch/EpochProcessorPhase0.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/phase0/statetransition/epoch/EpochProcessorPhase0.java @@ -14,10 +14,12 @@ package tech.pegasys.teku.spec.logic.versions.phase0.statetransition.epoch; import java.util.function.Function; +import tech.pegasys.teku.infrastructure.time.TimeProvider; import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.datastructures.state.beaconstate.MutableBeaconState; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.phase0.MutableBeaconStatePhase0; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingDeposit; import tech.pegasys.teku.spec.logic.common.helpers.BeaconStateAccessors; import tech.pegasys.teku.spec.logic.common.helpers.BeaconStateMutators; import tech.pegasys.teku.spec.logic.common.helpers.MiscHelpers; @@ -40,7 +42,8 @@ public EpochProcessorPhase0( final ValidatorsUtil validatorsUtil, final BeaconStateUtil beaconStateUtil, final ValidatorStatusFactory validatorStatusFactory, - final SchemaDefinitions schemaDefinitions) { + final SchemaDefinitions schemaDefinitions, + final TimeProvider timeProvider) { super( specConfig, miscHelpers, @@ -49,7 +52,8 @@ public EpochProcessorPhase0( validatorsUtil, beaconStateUtil, validatorStatusFactory, - schemaDefinitions); + schemaDefinitions, + timeProvider); } @Override @@ -65,7 +69,7 @@ public RewardAndPenaltyDeltas getRewardAndPenaltyDeltas( } @Override - public void processParticipationUpdates(MutableBeaconState genericState) { + public void processParticipationUpdates(final MutableBeaconState genericState) { // Rotate current/previous epoch attestations final MutableBeaconStatePhase0 state = MutableBeaconStatePhase0.required(genericState); state.getPreviousEpochAttestations().setAll(state.getCurrentEpochAttestations()); @@ -81,4 +85,19 @@ public void processHistoricalSummariesUpdate(final MutableBeaconState state) { public void processSyncCommitteeUpdates(final MutableBeaconState state) { // Nothing to do } + + @Override + public void applyPendingDeposits(final MutableBeaconState state, final PendingDeposit deposit) { + // Nothing to do + } + + @Override + public void processPendingDeposits(final MutableBeaconState state) { + // Nothing to do + } + + @Override + public void processPendingConsolidations(final MutableBeaconState state) { + // Nothing to do + } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/phase0/statetransition/epoch/ValidatorStatusFactoryPhase0.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/phase0/statetransition/epoch/ValidatorStatusFactoryPhase0.java index bc22f19b7ca..c881cb16183 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/phase0/statetransition/epoch/ValidatorStatusFactoryPhase0.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/phase0/statetransition/epoch/ValidatorStatusFactoryPhase0.java @@ -96,7 +96,8 @@ protected void processParticipation( // Apply flags to attestingIndices attestationUtil - .streamAttestingIndices(state, attestation) + .streamAttestingIndices( + state, attestation.getData(), attestation.getAggregationBits()) .mapToObj(statuses::get) .forEach(updates::apply); }); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/networks/Eth2Network.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/networks/Eth2Network.java index 37eea582652..2bd8b0c25c1 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/networks/Eth2Network.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/networks/Eth2Network.java @@ -19,12 +19,12 @@ public enum Eth2Network { // Live networks MAINNET("mainnet"), - PRATER("prater"), SEPOLIA("sepolia"), LUKSO("lukso"), GNOSIS("gnosis"), CHIADO("chiado"), HOLESKY("holesky"), + EPHEMERY("ephemery"), // Test networks MINIMAL("minimal"), SWIFT("swift"), @@ -53,9 +53,6 @@ public static Optional fromStringLenient(final String networkName) return Optional.of(value); } } - if (normalizedNetworkName.equals("GOERLI")) { - return Optional.of(PRATER); - } return Optional.empty(); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/AbstractSchemaDefinitions.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/AbstractSchemaDefinitions.java index ae4a06ddab2..8dfe9ec6c52 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/AbstractSchemaDefinitions.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/AbstractSchemaDefinitions.java @@ -13,36 +13,41 @@ package tech.pegasys.teku.spec.schemas; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.ATTNETS_ENR_FIELD_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BEACON_BLOCKS_BY_ROOT_REQUEST_MESSAGE_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.HISTORICAL_BATCH_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SYNCNETS_ENR_FIELD_SCHEMA; + import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszBitvectorSchema; import tech.pegasys.teku.spec.config.SpecConfig; -import tech.pegasys.teku.spec.constants.NetworkConstants; import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.BeaconBlocksByRootRequestMessage; -import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing.AttesterSlashingSchema; -import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestation.IndexedAttestationSchema; -import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof.SignedAggregateAndProofSchema; +import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.BeaconBlocksByRootRequestMessage.BeaconBlocksByRootRequestMessageSchema; import tech.pegasys.teku.spec.datastructures.state.HistoricalBatch.HistoricalBatchSchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; public abstract class AbstractSchemaDefinitions implements SchemaDefinitions { + protected SchemaRegistry schemaRegistry; final SszBitvectorSchema attnetsENRFieldSchema; - final SszBitvectorSchema syncnetsENRFieldSchema = - SszBitvectorSchema.create(NetworkConstants.SYNC_COMMITTEE_SUBNET_COUNT); + private final SszBitvectorSchema syncnetsENRFieldSchema; private final HistoricalBatchSchema historicalBatchSchema; - private final SignedAggregateAndProofSchema signedAggregateAndProofSchema; - private final IndexedAttestationSchema indexedAttestationSchema; - private final AttesterSlashingSchema attesterSlashingSchema; - private final BeaconBlocksByRootRequestMessage.BeaconBlocksByRootRequestMessageSchema - beaconBlocksByRootRequestMessageSchema; + private final BeaconBlocksByRootRequestMessageSchema beaconBlocksByRootRequestMessageSchema; - public AbstractSchemaDefinitions(final SpecConfig specConfig) { - this.historicalBatchSchema = new HistoricalBatchSchema(specConfig.getSlotsPerHistoricalRoot()); - this.signedAggregateAndProofSchema = new SignedAggregateAndProofSchema(specConfig); - this.indexedAttestationSchema = new IndexedAttestationSchema(specConfig); - this.attesterSlashingSchema = new AttesterSlashingSchema(indexedAttestationSchema); + public AbstractSchemaDefinitions(final SchemaRegistry schemaRegistry) { + this.schemaRegistry = schemaRegistry; + this.historicalBatchSchema = schemaRegistry.get(HISTORICAL_BATCH_SCHEMA); this.beaconBlocksByRootRequestMessageSchema = - new BeaconBlocksByRootRequestMessage.BeaconBlocksByRootRequestMessageSchema(specConfig); - this.attnetsENRFieldSchema = SszBitvectorSchema.create(specConfig.getAttestationSubnetCount()); + schemaRegistry.get(BEACON_BLOCKS_BY_ROOT_REQUEST_MESSAGE_SCHEMA); + this.syncnetsENRFieldSchema = schemaRegistry.get(SYNCNETS_ENR_FIELD_SCHEMA); + this.attnetsENRFieldSchema = schemaRegistry.get(ATTNETS_ENR_FIELD_SCHEMA); + } + + abstract long getMaxValidatorsPerAttestation(SpecConfig specConfig); + + @Override + public SchemaRegistry getSchemaRegistry() { + return schemaRegistry; } @Override @@ -60,21 +65,6 @@ public HistoricalBatchSchema getHistoricalBatchSchema() { return historicalBatchSchema; } - @Override - public SignedAggregateAndProofSchema getSignedAggregateAndProofSchema() { - return signedAggregateAndProofSchema; - } - - @Override - public IndexedAttestationSchema getIndexedAttestationSchema() { - return indexedAttestationSchema; - } - - @Override - public AttesterSlashingSchema getAttesterSlashingSchema() { - return attesterSlashingSchema; - } - @Override public BeaconBlocksByRootRequestMessage.BeaconBlocksByRootRequestMessageSchema getBeaconBlocksByRootRequestMessageSchema() { diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/FeatureSchemaDefinitions.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/FeatureSchemaDefinitions.java new file mode 100644 index 00000000000..4c7d53c3354 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/FeatureSchemaDefinitions.java @@ -0,0 +1,25 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.schemas; + +import static tech.pegasys.teku.spec.schemas.SchemaDefinitions.NonSchema; + +import java.util.Optional; + +public interface FeatureSchemaDefinitions { + @NonSchema + default Optional getOptionalSchemaDefinitionsEip7594() { + return Optional.empty(); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionCache.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionCache.java index fe4f9b5f27e..fa9b3050559 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionCache.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionCache.java @@ -20,6 +20,7 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.SpecVersion; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistryBuilder; public class SchemaDefinitionCache { private final Spec spec; @@ -46,7 +47,10 @@ private SchemaDefinitions createSchemaDefinition(final SpecMilestone milestone) if (specVersion != null) { return specVersion.getSchemaDefinitions(); } - return SpecVersion.create(milestone, spec.getGenesisSpecConfig()) + return SpecVersion.create( + milestone, + spec.getSpecConfigAndParent().forMilestone(milestone), + SchemaRegistryBuilder.create()) .orElseThrow( () -> new IllegalArgumentException( diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitions.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitions.java index 67ad42370b2..8f38d91f855 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitions.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitions.java @@ -31,14 +31,16 @@ import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.BeaconBlocksByRootRequestMessage; import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.metadata.MetadataMessageSchema; import tech.pegasys.teku.spec.datastructures.operations.AggregateAndProof.AggregateAndProofSchema; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; -import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing.AttesterSlashingSchema; -import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestation.IndexedAttestationSchema; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; +import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashingSchema; +import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof.SignedAggregateAndProofSchema; import tech.pegasys.teku.spec.datastructures.state.HistoricalBatch.HistoricalBatchSchema; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconStateSchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; -public interface SchemaDefinitions { +public interface SchemaDefinitions extends FeatureSchemaDefinitions { BeaconStateSchema getBeaconStateSchema(); @@ -72,13 +74,9 @@ public interface SchemaDefinitions { SignedAggregateAndProofSchema getSignedAggregateAndProofSchema(); - default AggregateAndProofSchema getAggregateAndProofSchema() { - return getSignedAggregateAndProofSchema().getAggregateAndProofSchema(); - } + AggregateAndProofSchema getAggregateAndProofSchema(); - default AttestationSchema getAttestationSchema() { - return getAggregateAndProofSchema().getAttestationSchema(); - } + AttestationSchema getAttestationSchema(); IndexedAttestationSchema getIndexedAttestationSchema(); @@ -90,6 +88,9 @@ default AttestationSchema getAttestationSchema() { @NonSchema BeaconBlockBodyBuilder createBeaconBlockBodyBuilder(); + @NonSchema + SchemaRegistry getSchemaRegistry(); + @NonSchema default Optional toVersionAltair() { return Optional.empty(); @@ -111,7 +112,7 @@ default Optional toVersionDeneb() { } @NonSchema - default Optional toVersionEip7594() { + default Optional toVersionElectra() { return Optional.empty(); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsAltair.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsAltair.java index a393428e0e9..cdedd69468e 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsAltair.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsAltair.java @@ -13,8 +13,16 @@ package tech.pegasys.teku.spec.schemas; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.AGGREGATE_AND_PROOF_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BEACON_BLOCK_BODY_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BEACON_BLOCK_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BEACON_STATE_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SIGNED_AGGREGATE_AND_PROOF_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SIGNED_BEACON_BLOCK_SCHEMA; + import com.google.common.base.Preconditions; import java.util.Optional; +import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.config.SpecConfigAltair; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlockSchema; import tech.pegasys.teku.spec.datastructures.blocks.BlockContainer; @@ -25,26 +33,38 @@ import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodyBuilder; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodySchema; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.BeaconBlockBodyBuilderAltair; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.BeaconBlockBodySchemaAltairImpl; import tech.pegasys.teku.spec.datastructures.lightclient.LightClientBootstrapSchema; import tech.pegasys.teku.spec.datastructures.lightclient.LightClientHeaderSchema; import tech.pegasys.teku.spec.datastructures.lightclient.LightClientUpdateResponseSchema; import tech.pegasys.teku.spec.datastructures.lightclient.LightClientUpdateSchema; import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.metadata.MetadataMessageSchema; import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.metadata.versions.altair.MetadataMessageSchemaAltair; +import tech.pegasys.teku.spec.datastructures.operations.AggregateAndProof.AggregateAndProofSchema; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; +import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashingSchema; +import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestationSchema; +import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof.SignedAggregateAndProofSchema; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.ContributionAndProofSchema; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SignedContributionAndProofSchema; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncAggregatorSelectionDataSchema; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeContributionSchema; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeMessageSchema; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconStateSchema; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.altair.BeaconStateAltair; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.altair.BeaconStateSchemaAltair; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.altair.MutableBeaconStateAltair; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.MutableBeaconState; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; +import tech.pegasys.teku.spec.schemas.registry.SchemaTypes; public class SchemaDefinitionsAltair extends AbstractSchemaDefinitions { - private final BeaconStateSchemaAltair beaconStateSchema; - private final BeaconBlockBodySchemaAltairImpl beaconBlockBodySchema; + private final IndexedAttestationSchema indexedAttestationSchema; + private final AttesterSlashingSchema attesterSlashingSchema; + private final AttestationSchema attestationSchema; + private final SignedAggregateAndProofSchema signedAggregateAndProofSchema; + private final AggregateAndProofSchema aggregateAndProofSchema; + private final BeaconStateSchema + beaconStateSchema; + private final BeaconBlockBodySchema beaconBlockBodySchema; private final BeaconBlockSchema beaconBlockSchema; private final SignedBeaconBlockSchema signedBeaconBlockSchema; private final SyncCommitteeContributionSchema syncCommitteeContributionSchema; @@ -56,15 +76,18 @@ public class SchemaDefinitionsAltair extends AbstractSchemaDefinitions { private final LightClientUpdateSchema lightClientUpdateSchema; private final LightClientUpdateResponseSchema lightClientUpdateResponseSchema; - public SchemaDefinitionsAltair(final SpecConfigAltair specConfig) { - super(specConfig); - this.beaconStateSchema = BeaconStateSchemaAltair.create(specConfig); - this.beaconBlockBodySchema = - BeaconBlockBodySchemaAltairImpl.create( - specConfig, getAttesterSlashingSchema(), "BeaconBlockBodyAltair"); - this.beaconBlockSchema = new BeaconBlockSchema(beaconBlockBodySchema, "BeaconBlockAltair"); - this.signedBeaconBlockSchema = - new SignedBeaconBlockSchema(beaconBlockSchema, "SignedBeaconBlockAltair"); + public SchemaDefinitionsAltair(final SchemaRegistry schemaRegistry) { + super(schemaRegistry); + final SpecConfigAltair specConfig = SpecConfigAltair.required(schemaRegistry.getSpecConfig()); + this.indexedAttestationSchema = schemaRegistry.get(SchemaTypes.INDEXED_ATTESTATION_SCHEMA); + this.attesterSlashingSchema = schemaRegistry.get(SchemaTypes.ATTESTER_SLASHING_SCHEMA); + this.attestationSchema = schemaRegistry.get(SchemaTypes.ATTESTATION_SCHEMA); + this.aggregateAndProofSchema = schemaRegistry.get(AGGREGATE_AND_PROOF_SCHEMA); + this.signedAggregateAndProofSchema = schemaRegistry.get(SIGNED_AGGREGATE_AND_PROOF_SCHEMA); + this.beaconStateSchema = schemaRegistry.get(BEACON_STATE_SCHEMA); + this.beaconBlockBodySchema = schemaRegistry.get(BEACON_BLOCK_BODY_SCHEMA); + this.beaconBlockSchema = schemaRegistry.get(BEACON_BLOCK_SCHEMA); + this.signedBeaconBlockSchema = schemaRegistry.get(SIGNED_BEACON_BLOCK_SCHEMA); this.syncCommitteeContributionSchema = SyncCommitteeContributionSchema.create(specConfig); this.contributionAndProofSchema = ContributionAndProofSchema.create(syncCommitteeContributionSchema); @@ -80,14 +103,39 @@ public SchemaDefinitionsAltair(final SpecConfigAltair specConfig) { public static SchemaDefinitionsAltair required(final SchemaDefinitions schemaDefinitions) { Preconditions.checkArgument( schemaDefinitions instanceof SchemaDefinitionsAltair, - "Expected definitions of type %s by got %s", + "Expected definitions of type %s but got %s", SchemaDefinitionsAltair.class, schemaDefinitions.getClass()); return (SchemaDefinitionsAltair) schemaDefinitions; } @Override - public BeaconStateSchema + public SignedAggregateAndProofSchema getSignedAggregateAndProofSchema() { + return signedAggregateAndProofSchema; + } + + @Override + public AggregateAndProofSchema getAggregateAndProofSchema() { + return aggregateAndProofSchema; + } + + @Override + public AttestationSchema getAttestationSchema() { + return attestationSchema; + } + + @Override + public IndexedAttestationSchema getIndexedAttestationSchema() { + return indexedAttestationSchema; + } + + @Override + public AttesterSlashingSchema getAttesterSlashingSchema() { + return attesterSlashingSchema; + } + + @Override + public BeaconStateSchema getBeaconStateSchema() { return beaconStateSchema; } @@ -192,4 +240,9 @@ public LightClientUpdateSchema getLightClientUpdateSchema() { public LightClientUpdateResponseSchema getLightClientUpdateResponseSchema() { return lightClientUpdateResponseSchema; } + + @Override + long getMaxValidatorsPerAttestation(final SpecConfig specConfig) { + return specConfig.getMaxValidatorsPerCommittee(); + } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsBellatrix.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsBellatrix.java index 9d55e5f1da0..65aedde7523 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsBellatrix.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsBellatrix.java @@ -14,9 +14,15 @@ package tech.pegasys.teku.spec.schemas; import static com.google.common.base.Preconditions.checkArgument; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLINDED_BEACON_BLOCK_BODY_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLINDED_BEACON_BLOCK_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BUILDER_BID_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_PAYLOAD_HEADER_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_PAYLOAD_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SIGNED_BLINDED_BEACON_BLOCK_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SIGNED_BUILDER_BID_SCHEMA; import java.util.Optional; -import tech.pegasys.teku.spec.config.SpecConfigBellatrix; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlockSchema; import tech.pegasys.teku.spec.datastructures.blocks.BlockContainer; import tech.pegasys.teku.spec.datastructures.blocks.BlockContainerSchema; @@ -26,83 +32,43 @@ import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodyBuilder; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodySchema; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.bellatrix.BeaconBlockBodyBuilderBellatrix; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.bellatrix.BeaconBlockBodySchemaBellatrixImpl; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.bellatrix.BlindedBeaconBlockBodySchemaBellatrixImpl; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.bellatrix.BlindedBeaconBlockBodySchemaBellatrix; import tech.pegasys.teku.spec.datastructures.builder.BuilderBidSchema; import tech.pegasys.teku.spec.datastructures.builder.BuilderPayloadSchema; import tech.pegasys.teku.spec.datastructures.builder.SignedBuilderBidSchema; -import tech.pegasys.teku.spec.datastructures.builder.versions.bellatrix.BuilderBidSchemaBellatrix; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeaderSchema; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSchema; -import tech.pegasys.teku.spec.datastructures.execution.versions.bellatrix.ExecutionPayloadHeaderSchemaBellatrix; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconStateSchema; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.bellatrix.BeaconStateBellatrix; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.bellatrix.BeaconStateSchemaBellatrix; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.bellatrix.MutableBeaconStateBellatrix; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; public class SchemaDefinitionsBellatrix extends SchemaDefinitionsAltair { - private final BeaconStateSchemaBellatrix beaconStateSchema; - private final BeaconBlockBodySchemaBellatrixImpl beaconBlockBodySchema; - private final BlindedBeaconBlockBodySchemaBellatrixImpl blindedBeaconBlockBodySchema; - private final BeaconBlockSchema beaconBlockSchema; + private final ExecutionPayloadSchema executionPayloadSchema; + private final BlindedBeaconBlockBodySchemaBellatrix blindedBeaconBlockBodySchema; private final BeaconBlockSchema blindedBeaconBlockSchema; - private final SignedBeaconBlockSchema signedBeaconBlockSchema; private final SignedBeaconBlockSchema signedBlindedBeaconBlockSchema; - private final ExecutionPayloadHeaderSchemaBellatrix executionPayloadHeaderSchema; + private final ExecutionPayloadHeaderSchema executionPayloadHeaderSchema; private final BuilderBidSchema builderBidSchema; private final SignedBuilderBidSchema signedBuilderBidSchema; - public SchemaDefinitionsBellatrix(final SpecConfigBellatrix specConfig) { - super(specConfig); - this.beaconStateSchema = BeaconStateSchemaBellatrix.create(specConfig); - this.executionPayloadHeaderSchema = beaconStateSchema.getLastExecutionPayloadHeaderSchema(); - this.beaconBlockBodySchema = - BeaconBlockBodySchemaBellatrixImpl.create( - specConfig, getAttesterSlashingSchema(), "BeaconBlockBodyBellatrix"); - this.blindedBeaconBlockBodySchema = - BlindedBeaconBlockBodySchemaBellatrixImpl.create( - specConfig, - getAttesterSlashingSchema(), - "BlindedBlockBodyBellatrix", - executionPayloadHeaderSchema); - this.beaconBlockSchema = new BeaconBlockSchema(beaconBlockBodySchema, "BeaconBlockBellatrix"); - this.blindedBeaconBlockSchema = - new BeaconBlockSchema(blindedBeaconBlockBodySchema, "BlindedBlockBellatrix"); - this.signedBeaconBlockSchema = - new SignedBeaconBlockSchema(beaconBlockSchema, "SignedBeaconBlockBellatrix"); - this.signedBlindedBeaconBlockSchema = - new SignedBeaconBlockSchema(blindedBeaconBlockSchema, "SignedBlindedBlockBellatrix"); - this.builderBidSchema = - new BuilderBidSchemaBellatrix("BuilderBidBellatrix", executionPayloadHeaderSchema); - this.signedBuilderBidSchema = - new SignedBuilderBidSchema("SignedBuilderBidBellatrix", builderBidSchema); + public SchemaDefinitionsBellatrix(final SchemaRegistry schemaRegistry) { + super(schemaRegistry); + this.executionPayloadSchema = schemaRegistry.get(EXECUTION_PAYLOAD_SCHEMA); + this.executionPayloadHeaderSchema = schemaRegistry.get(EXECUTION_PAYLOAD_HEADER_SCHEMA); + this.blindedBeaconBlockBodySchema = schemaRegistry.get(BLINDED_BEACON_BLOCK_BODY_SCHEMA); + this.blindedBeaconBlockSchema = schemaRegistry.get(BLINDED_BEACON_BLOCK_SCHEMA); + this.signedBlindedBeaconBlockSchema = schemaRegistry.get(SIGNED_BLINDED_BEACON_BLOCK_SCHEMA); + this.builderBidSchema = schemaRegistry.get(BUILDER_BID_SCHEMA); + this.signedBuilderBidSchema = schemaRegistry.get(SIGNED_BUILDER_BID_SCHEMA); } public static SchemaDefinitionsBellatrix required(final SchemaDefinitions schemaDefinitions) { checkArgument( schemaDefinitions instanceof SchemaDefinitionsBellatrix, - "Expected definitions of type %s by got %s", + "Expected definitions of type %s but got %s", SchemaDefinitionsBellatrix.class, schemaDefinitions.getClass()); return (SchemaDefinitionsBellatrix) schemaDefinitions; } - @Override - public BeaconStateSchema - getBeaconStateSchema() { - return beaconStateSchema; - } - - @Override - public SignedBeaconBlockSchema getSignedBeaconBlockSchema() { - return signedBeaconBlockSchema; - } - - @Override - public BeaconBlockSchema getBeaconBlockSchema() { - return beaconBlockSchema; - } - @Override public BeaconBlockSchema getBlindedBeaconBlockSchema() { return blindedBeaconBlockSchema; @@ -113,31 +79,16 @@ public BeaconBlockBodySchema getBlindedBeaconBlockBodySchema() { return blindedBeaconBlockBodySchema; } - @Override - public BeaconBlockBodySchema getBeaconBlockBodySchema() { - return beaconBlockBodySchema; - } - @Override public SignedBeaconBlockSchema getSignedBlindedBeaconBlockSchema() { return signedBlindedBeaconBlockSchema; } - @Override - public BlockContainerSchema getBlockContainerSchema() { - return getBeaconBlockSchema().castTypeToBlockContainer(); - } - @Override public BlockContainerSchema getBlindedBlockContainerSchema() { return getBlindedBeaconBlockSchema().castTypeToBlockContainer(); } - @Override - public SignedBlockContainerSchema getSignedBlockContainerSchema() { - return getSignedBeaconBlockSchema().castTypeToSignedBlockContainer(); - } - @Override public SignedBlockContainerSchema getSignedBlindedBlockContainerSchema() { return getSignedBlindedBeaconBlockSchema().castTypeToSignedBlockContainer(); @@ -145,11 +96,13 @@ public SignedBlockContainerSchema getSignedBlindedBlockCon @Override public BeaconBlockBodyBuilder createBeaconBlockBodyBuilder() { - return new BeaconBlockBodyBuilderBellatrix(beaconBlockBodySchema, blindedBeaconBlockBodySchema); + return new BeaconBlockBodyBuilderBellatrix( + getBeaconBlockBodySchema().toVersionBellatrix().orElseThrow(), + blindedBeaconBlockBodySchema); } public ExecutionPayloadSchema getExecutionPayloadSchema() { - return beaconBlockBodySchema.getExecutionPayloadSchema(); + return executionPayloadSchema; } public ExecutionPayloadHeaderSchema getExecutionPayloadHeaderSchema() { diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsCapella.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsCapella.java index 277773762bf..89464135c32 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsCapella.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsCapella.java @@ -14,176 +14,53 @@ package tech.pegasys.teku.spec.schemas; import static com.google.common.base.Preconditions.checkArgument; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLS_TO_EXECUTION_CHANGE_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.HISTORICAL_SUMMARIES_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SIGNED_BLS_TO_EXECUTION_CHANGE_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.WITHDRAWAL_SCHEMA; import java.util.Optional; -import tech.pegasys.teku.spec.config.SpecConfigCapella; -import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlockSchema; -import tech.pegasys.teku.spec.datastructures.blocks.BlockContainer; -import tech.pegasys.teku.spec.datastructures.blocks.BlockContainerSchema; -import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockSchema; -import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockContainer; -import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockContainerSchema; +import tech.pegasys.teku.infrastructure.ssz.schema.SszListSchema; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodyBuilder; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodySchema; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.capella.BeaconBlockBodyBuilderCapella; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.capella.BeaconBlockBodySchemaCapellaImpl; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.capella.BlindedBeaconBlockBodySchemaCapellaImpl; -import tech.pegasys.teku.spec.datastructures.builder.BuilderBidSchema; -import tech.pegasys.teku.spec.datastructures.builder.SignedBuilderBidSchema; -import tech.pegasys.teku.spec.datastructures.builder.versions.bellatrix.BuilderBidSchemaBellatrix; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeaderSchema; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSchema; -import tech.pegasys.teku.spec.datastructures.execution.versions.capella.ExecutionPayloadHeaderSchemaCapella; -import tech.pegasys.teku.spec.datastructures.execution.versions.capella.ExecutionPayloadSchemaCapella; -import tech.pegasys.teku.spec.datastructures.execution.versions.capella.Withdrawal; import tech.pegasys.teku.spec.datastructures.execution.versions.capella.WithdrawalSchema; import tech.pegasys.teku.spec.datastructures.operations.BlsToExecutionChangeSchema; import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChangeSchema; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconStateSchema; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.capella.BeaconStateCapella; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.capella.BeaconStateSchemaCapella; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.capella.MutableBeaconStateCapella; import tech.pegasys.teku.spec.datastructures.state.versions.capella.HistoricalSummary; +import tech.pegasys.teku.spec.datastructures.state.versions.capella.HistoricalSummary.HistoricalSummarySchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; public class SchemaDefinitionsCapella extends SchemaDefinitionsBellatrix { - - private final BeaconStateSchemaCapella beaconStateSchema; - - private final ExecutionPayloadSchemaCapella executionPayloadSchemaCapella; - private final ExecutionPayloadHeaderSchemaCapella executionPayloadHeaderSchemaCapella; - - private final BeaconBlockBodySchemaCapellaImpl beaconBlockBodySchema; - private final BlindedBeaconBlockBodySchemaCapellaImpl blindedBeaconBlockBodySchema; - - private final BeaconBlockSchema beaconBlockSchema; - private final BeaconBlockSchema blindedBeaconBlockSchema; - private final SignedBeaconBlockSchema signedBeaconBlockSchema; - private final SignedBeaconBlockSchema signedBlindedBeaconBlockSchema; - private final WithdrawalSchema withdrawalSchema; private final BlsToExecutionChangeSchema blsToExecutionChangeSchema; - private final SignedBlsToExecutionChangeSchema signedBlsToExecutionChangeSchema; - private final BuilderBidSchema builderBidSchemaCapella; - private final SignedBuilderBidSchema signedBuilderBidSchemaCapella; - - private final HistoricalSummary.HistoricalSummarySchema historicalSummarySchema; - public SchemaDefinitionsCapella(final SpecConfigCapella specConfig) { - super(specConfig); - this.executionPayloadSchemaCapella = new ExecutionPayloadSchemaCapella(specConfig); - this.blsToExecutionChangeSchema = new BlsToExecutionChangeSchema(); - this.signedBlsToExecutionChangeSchema = new SignedBlsToExecutionChangeSchema(); - this.withdrawalSchema = Withdrawal.SSZ_SCHEMA; + private final SszListSchema historicalSummariesSchema; - this.beaconStateSchema = BeaconStateSchemaCapella.create(specConfig); - this.executionPayloadHeaderSchemaCapella = - beaconStateSchema.getLastExecutionPayloadHeaderSchema(); - this.beaconBlockBodySchema = - BeaconBlockBodySchemaCapellaImpl.create( - specConfig, - getAttesterSlashingSchema(), - signedBlsToExecutionChangeSchema, - "BeaconBlockBodyCapella"); - this.blindedBeaconBlockBodySchema = - BlindedBeaconBlockBodySchemaCapellaImpl.create( - specConfig, - getAttesterSlashingSchema(), - signedBlsToExecutionChangeSchema, - "BlindedBlockBodyCapella"); - this.beaconBlockSchema = new BeaconBlockSchema(beaconBlockBodySchema, "BeaconBlockCapella"); - this.blindedBeaconBlockSchema = - new BeaconBlockSchema(blindedBeaconBlockBodySchema, "BlindedBlockCapella"); - this.signedBeaconBlockSchema = - new SignedBeaconBlockSchema(beaconBlockSchema, "SignedBeaconBlockCapella"); - this.signedBlindedBeaconBlockSchema = - new SignedBeaconBlockSchema(blindedBeaconBlockSchema, "SignedBlindedBlockCapella"); - this.builderBidSchemaCapella = - new BuilderBidSchemaBellatrix("BuilderBidCapella", executionPayloadHeaderSchemaCapella); - this.signedBuilderBidSchemaCapella = - new SignedBuilderBidSchema("SignedBuilderBidCapella", builderBidSchemaCapella); - this.historicalSummarySchema = new HistoricalSummary.HistoricalSummarySchema(); + public SchemaDefinitionsCapella(final SchemaRegistry schemaRegistry) { + super(schemaRegistry); + this.historicalSummariesSchema = schemaRegistry.get(HISTORICAL_SUMMARIES_SCHEMA); + this.blsToExecutionChangeSchema = schemaRegistry.get(BLS_TO_EXECUTION_CHANGE_SCHEMA); + this.signedBlsToExecutionChangeSchema = + schemaRegistry.get(SIGNED_BLS_TO_EXECUTION_CHANGE_SCHEMA); + this.withdrawalSchema = schemaRegistry.get(WITHDRAWAL_SCHEMA); } public static SchemaDefinitionsCapella required(final SchemaDefinitions schemaDefinitions) { checkArgument( schemaDefinitions instanceof SchemaDefinitionsCapella, - "Expected definitions of type %s by got %s", + "Expected definitions of type %s but got %s", SchemaDefinitionsCapella.class, schemaDefinitions.getClass()); return (SchemaDefinitionsCapella) schemaDefinitions; } - @Override - public BeaconStateSchema - getBeaconStateSchema() { - return beaconStateSchema; - } - - @Override - public BeaconBlockBodySchema getBeaconBlockBodySchema() { - return beaconBlockBodySchema; - } - - @Override - public BeaconBlockBodySchema getBlindedBeaconBlockBodySchema() { - return blindedBeaconBlockBodySchema; - } - - @Override - public BeaconBlockSchema getBeaconBlockSchema() { - return beaconBlockSchema; - } - - @Override - public BeaconBlockSchema getBlindedBeaconBlockSchema() { - return blindedBeaconBlockSchema; - } - - @Override - public SignedBeaconBlockSchema getSignedBeaconBlockSchema() { - return signedBeaconBlockSchema; - } - - @Override - public SignedBeaconBlockSchema getSignedBlindedBeaconBlockSchema() { - return signedBlindedBeaconBlockSchema; - } - - @Override - public BlockContainerSchema getBlockContainerSchema() { - return getBeaconBlockSchema().castTypeToBlockContainer(); - } - - @Override - public BlockContainerSchema getBlindedBlockContainerSchema() { - return getBlindedBeaconBlockSchema().castTypeToBlockContainer(); - } - - @Override - public SignedBlockContainerSchema getSignedBlockContainerSchema() { - return getSignedBeaconBlockSchema().castTypeToSignedBlockContainer(); - } - - @Override - public SignedBlockContainerSchema getSignedBlindedBlockContainerSchema() { - return getSignedBlindedBeaconBlockSchema().castTypeToSignedBlockContainer(); - } - - @Override - public ExecutionPayloadSchema getExecutionPayloadSchema() { - return executionPayloadSchemaCapella; - } - - @Override - public ExecutionPayloadHeaderSchema getExecutionPayloadHeaderSchema() { - return executionPayloadHeaderSchemaCapella; - } - @Override public BeaconBlockBodyBuilder createBeaconBlockBodyBuilder() { - return new BeaconBlockBodyBuilderCapella(beaconBlockBodySchema, blindedBeaconBlockBodySchema); + return new BeaconBlockBodyBuilderCapella( + getBeaconBlockBodySchema().toVersionCapella().orElseThrow(), + getBlindedBeaconBlockBodySchema().toBlindedVersionCapella().orElseThrow()); } public WithdrawalSchema getWithdrawalSchema() { @@ -198,18 +75,8 @@ public SignedBlsToExecutionChangeSchema getSignedBlsToExecutionChangeSchema() { return signedBlsToExecutionChangeSchema; } - public HistoricalSummary.HistoricalSummarySchema getHistoricalSummarySchema() { - return historicalSummarySchema; - } - - @Override - public BuilderBidSchema getBuilderBidSchema() { - return builderBidSchemaCapella; - } - - @Override - public SignedBuilderBidSchema getSignedBuilderBidSchema() { - return signedBuilderBidSchemaCapella; + public HistoricalSummarySchema getHistoricalSummarySchema() { + return (HistoricalSummarySchema) historicalSummariesSchema.getElementSchema(); } @Override diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsDeneb.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsDeneb.java index 16a4ec6e681..62b079e7aae 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsDeneb.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsDeneb.java @@ -14,65 +14,40 @@ package tech.pegasys.teku.spec.schemas; import static com.google.common.base.Preconditions.checkArgument; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOBS_BUNDLE_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOBS_IN_BLOCK_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOB_KZG_COMMITMENTS_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOB_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOB_SIDECARS_BY_ROOT_REQUEST_MESSAGE_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOB_SIDECAR_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOCK_CONTENTS_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_PAYLOAD_AND_BLOBS_BUNDLE_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SIGNED_BLOCK_CONTENTS_SCHEMA; import java.util.Optional; import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.ssz.schema.SszListSchema; -import tech.pegasys.teku.spec.config.SpecConfigDeneb; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.Blob; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobKzgCommitmentsSchema; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSchema; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecarSchema; -import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlockSchema; import tech.pegasys.teku.spec.datastructures.blocks.BlockContainer; import tech.pegasys.teku.spec.datastructures.blocks.BlockContainerSchema; -import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockHeader; -import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockSchema; import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockContainer; import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockContainerSchema; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodyBuilder; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodySchema; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.deneb.BeaconBlockBodyBuilderDeneb; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.deneb.BeaconBlockBodySchemaDenebImpl; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.deneb.BlindedBeaconBlockBodySchemaDenebImpl; import tech.pegasys.teku.spec.datastructures.blocks.versions.deneb.BlockContentsSchema; import tech.pegasys.teku.spec.datastructures.blocks.versions.deneb.SignedBlockContentsSchema; import tech.pegasys.teku.spec.datastructures.builder.BlobsBundleSchema; -import tech.pegasys.teku.spec.datastructures.builder.BuilderBidSchema; import tech.pegasys.teku.spec.datastructures.builder.BuilderPayloadSchema; import tech.pegasys.teku.spec.datastructures.builder.ExecutionPayloadAndBlobsBundleSchema; -import tech.pegasys.teku.spec.datastructures.builder.SignedBuilderBidSchema; -import tech.pegasys.teku.spec.datastructures.builder.versions.deneb.BuilderBidSchemaDeneb; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeaderSchema; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSchema; -import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadHeaderSchemaDeneb; -import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadSchemaDeneb; import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.BlobSidecarsByRootRequestMessageSchema; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconStateSchema; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.deneb.BeaconStateDeneb; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.deneb.BeaconStateSchemaDeneb; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.deneb.MutableBeaconStateDeneb; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; public class SchemaDefinitionsDeneb extends SchemaDefinitionsCapella { - - private final BeaconStateSchemaDeneb beaconStateSchema; - - private final ExecutionPayloadSchemaDeneb executionPayloadSchemaDeneb; - private final ExecutionPayloadHeaderSchemaDeneb executionPayloadHeaderSchemaDeneb; - private final BlobKzgCommitmentsSchema blobKzgCommitmentsSchema; - private final BeaconBlockBodySchemaDenebImpl beaconBlockBodySchema; - private final BlindedBeaconBlockBodySchemaDenebImpl blindedBeaconBlockBodySchema; - - private final BeaconBlockSchema beaconBlockSchema; - private final BeaconBlockSchema blindedBeaconBlockSchema; - private final SignedBeaconBlockSchema signedBeaconBlockSchema; - private final SignedBeaconBlockSchema signedBlindedBeaconBlockSchema; - - private final BuilderBidSchema builderBidSchemaDeneb; - private final SignedBuilderBidSchema signedBuilderBidSchemaDeneb; - private final BlobSchema blobSchema; private final SszListSchema> blobsInBlockSchema; private final BlobSidecarSchema blobSidecarSchema; @@ -82,146 +57,41 @@ public class SchemaDefinitionsDeneb extends SchemaDefinitionsCapella { private final ExecutionPayloadAndBlobsBundleSchema executionPayloadAndBlobsBundleSchema; private final BlobSidecarsByRootRequestMessageSchema blobSidecarsByRootRequestMessageSchema; - public SchemaDefinitionsDeneb(final SpecConfigDeneb specConfig) { - super(specConfig); - this.executionPayloadSchemaDeneb = new ExecutionPayloadSchemaDeneb(specConfig); + public SchemaDefinitionsDeneb(final SchemaRegistry schemaRegistry) { + super(schemaRegistry); - this.beaconStateSchema = BeaconStateSchemaDeneb.create(specConfig); - this.executionPayloadHeaderSchemaDeneb = - beaconStateSchema.getLastExecutionPayloadHeaderSchema(); - this.blobKzgCommitmentsSchema = new BlobKzgCommitmentsSchema(specConfig); - this.beaconBlockBodySchema = - BeaconBlockBodySchemaDenebImpl.create( - specConfig, - getAttesterSlashingSchema(), - getSignedBlsToExecutionChangeSchema(), - blobKzgCommitmentsSchema, - "BeaconBlockBodyDeneb"); - this.blindedBeaconBlockBodySchema = - BlindedBeaconBlockBodySchemaDenebImpl.create( - specConfig, - getAttesterSlashingSchema(), - getSignedBlsToExecutionChangeSchema(), - blobKzgCommitmentsSchema, - "BlindedBlockBodyDeneb"); - this.beaconBlockSchema = new BeaconBlockSchema(beaconBlockBodySchema, "BeaconBlockDeneb"); - this.blindedBeaconBlockSchema = - new BeaconBlockSchema(blindedBeaconBlockBodySchema, "BlindedBlockDeneb"); - this.signedBeaconBlockSchema = - new SignedBeaconBlockSchema(beaconBlockSchema, "SignedBeaconBlockDeneb"); - this.signedBlindedBeaconBlockSchema = - new SignedBeaconBlockSchema(blindedBeaconBlockSchema, "SignedBlindedBlockDeneb"); - this.builderBidSchemaDeneb = - new BuilderBidSchemaDeneb( - "BuilderBidDeneb", executionPayloadHeaderSchemaDeneb, blobKzgCommitmentsSchema); - this.signedBuilderBidSchemaDeneb = - new SignedBuilderBidSchema("SignedBuilderBidDeneb", builderBidSchemaDeneb); - - this.blobSchema = new BlobSchema(specConfig); - this.blobsInBlockSchema = SszListSchema.create(blobSchema, specConfig.getMaxBlobsPerBlock()); - this.blobSidecarSchema = - BlobSidecarSchema.create( - SignedBeaconBlockHeader.SSZ_SCHEMA, - blobSchema, - specConfig.getKzgCommitmentInclusionProofDepth()); - this.blockContentsSchema = - BlockContentsSchema.create(specConfig, beaconBlockSchema, blobSchema, "BlockContentsDeneb"); - this.signedBlockContentsSchema = - SignedBlockContentsSchema.create( - specConfig, signedBeaconBlockSchema, blobSchema, "SignedBlockContentsDeneb"); - this.blobsBundleSchema = - new BlobsBundleSchema("BlobsBundleDeneb", blobSchema, blobKzgCommitmentsSchema, specConfig); + this.blobKzgCommitmentsSchema = schemaRegistry.get(BLOB_KZG_COMMITMENTS_SCHEMA); + this.blobSchema = schemaRegistry.get(BLOB_SCHEMA); + this.blobsInBlockSchema = schemaRegistry.get(BLOBS_IN_BLOCK_SCHEMA); + this.blobSidecarSchema = schemaRegistry.get(BLOB_SIDECAR_SCHEMA); + this.blockContentsSchema = schemaRegistry.get(BLOCK_CONTENTS_SCHEMA); + this.signedBlockContentsSchema = schemaRegistry.get(SIGNED_BLOCK_CONTENTS_SCHEMA); + this.blobsBundleSchema = schemaRegistry.get(BLOBS_BUNDLE_SCHEMA); this.executionPayloadAndBlobsBundleSchema = - new ExecutionPayloadAndBlobsBundleSchema(executionPayloadSchemaDeneb, blobsBundleSchema); + schemaRegistry.get(EXECUTION_PAYLOAD_AND_BLOBS_BUNDLE_SCHEMA); this.blobSidecarsByRootRequestMessageSchema = - new BlobSidecarsByRootRequestMessageSchema(specConfig); + schemaRegistry.get(BLOB_SIDECARS_BY_ROOT_REQUEST_MESSAGE_SCHEMA); } public static SchemaDefinitionsDeneb required(final SchemaDefinitions schemaDefinitions) { checkArgument( schemaDefinitions instanceof SchemaDefinitionsDeneb, - "Expected definitions of type %s by got %s", + "Expected definitions of type %s but got %s", SchemaDefinitionsDeneb.class, schemaDefinitions.getClass()); return (SchemaDefinitionsDeneb) schemaDefinitions; } - @Override - public BeaconStateSchema - getBeaconStateSchema() { - return beaconStateSchema; - } - - @Override - public BeaconBlockBodySchema getBeaconBlockBodySchema() { - return beaconBlockBodySchema; - } - - @Override - public BeaconBlockBodySchema getBlindedBeaconBlockBodySchema() { - return blindedBeaconBlockBodySchema; - } - - @Override - public BeaconBlockSchema getBeaconBlockSchema() { - return beaconBlockSchema; - } - - @Override - public BeaconBlockSchema getBlindedBeaconBlockSchema() { - return blindedBeaconBlockSchema; - } - - @Override - public SignedBeaconBlockSchema getSignedBeaconBlockSchema() { - return signedBeaconBlockSchema; - } - - @Override - public SignedBeaconBlockSchema getSignedBlindedBeaconBlockSchema() { - return signedBlindedBeaconBlockSchema; - } - @Override public BlockContainerSchema getBlockContainerSchema() { return getBlockContentsSchema().castTypeToBlockContainer(); } - @Override - public BlockContainerSchema getBlindedBlockContainerSchema() { - return getBlindedBeaconBlockSchema().castTypeToBlockContainer(); - } - @Override public SignedBlockContainerSchema getSignedBlockContainerSchema() { return getSignedBlockContentsSchema().castTypeToSignedBlockContainer(); } - @Override - public SignedBlockContainerSchema getSignedBlindedBlockContainerSchema() { - return getSignedBlindedBeaconBlockSchema().castTypeToSignedBlockContainer(); - } - - @Override - public ExecutionPayloadSchema getExecutionPayloadSchema() { - return executionPayloadSchemaDeneb; - } - - @Override - public ExecutionPayloadHeaderSchema getExecutionPayloadHeaderSchema() { - return executionPayloadHeaderSchemaDeneb; - } - - @Override - public BuilderBidSchema getBuilderBidSchema() { - return builderBidSchemaDeneb; - } - - @Override - public SignedBuilderBidSchema getSignedBuilderBidSchema() { - return signedBuilderBidSchemaDeneb; - } - @Override public BuilderPayloadSchema getBuilderPayloadSchema() { return getExecutionPayloadAndBlobsBundleSchema(); @@ -229,7 +99,9 @@ public BuilderPayloadSchema getBuilderPayloadSchema() { @Override public BeaconBlockBodyBuilder createBeaconBlockBodyBuilder() { - return new BeaconBlockBodyBuilderDeneb(beaconBlockBodySchema, blindedBeaconBlockBodySchema); + return new BeaconBlockBodyBuilderDeneb( + getBeaconBlockBodySchema().toVersionDeneb().orElseThrow(), + getBlindedBeaconBlockBodySchema().toBlindedVersionDeneb().orElseThrow()); } public BlobSchema getBlobSchema() { diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsEip7594.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsEip7594.java index 2edcac06486..5966c79eba5 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsEip7594.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsEip7594.java @@ -15,68 +15,19 @@ import static com.google.common.base.Preconditions.checkArgument; -import java.util.Optional; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.config.features.Eip7594; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.CellSchema; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSchema; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSidecarSchema; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.MatrixEntrySchema; -import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlockSchema; -import tech.pegasys.teku.spec.datastructures.blocks.BlockContainer; -import tech.pegasys.teku.spec.datastructures.blocks.BlockContainerSchema; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockHeader; -import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockSchema; -import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockContainer; -import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockContainerSchema; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodyBuilder; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodySchema; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594.BeaconBlockBodyBuilderEip7594; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594.BeaconBlockBodySchemaEip7594; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594.BeaconBlockBodySchemaEip7594Impl; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594.BlindedBeaconBlockBodySchemaEip7594Impl; -import tech.pegasys.teku.spec.datastructures.blocks.versions.deneb.BlockContentsSchema; -import tech.pegasys.teku.spec.datastructures.blocks.versions.deneb.SignedBlockContentsSchema; -import tech.pegasys.teku.spec.datastructures.builder.BlobsBundleSchema; -import tech.pegasys.teku.spec.datastructures.builder.BuilderBidSchema; -import tech.pegasys.teku.spec.datastructures.builder.BuilderPayloadSchema; -import tech.pegasys.teku.spec.datastructures.builder.ExecutionPayloadAndBlobsBundleSchema; -import tech.pegasys.teku.spec.datastructures.builder.SignedBuilderBidSchema; -import tech.pegasys.teku.spec.datastructures.builder.versions.deneb.BuilderBidSchemaDeneb; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeaderSchema; -import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSchema; -import tech.pegasys.teku.spec.datastructures.execution.versions.eip7594.ExecutionPayloadHeaderSchemaEip7594; -import tech.pegasys.teku.spec.datastructures.execution.versions.eip7594.ExecutionPayloadSchemaEip7594; import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.DataColumnSidecarsByRangeRequestMessage; import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.DataColumnSidecarsByRootRequestMessageSchema; -import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.metadata.MetadataMessageSchema; import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.metadata.versions.eip7594.MetadataMessageSchemaEip7594; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconStateSchema; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.eip7594.BeaconStateEip7594; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.eip7594.BeaconStateSchemaEip7594; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.eip7594.MutableBeaconStateEip7594; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; -public class SchemaDefinitionsEip7594 extends SchemaDefinitionsDeneb { - - private final BeaconStateSchemaEip7594 beaconStateSchema; - - private final ExecutionPayloadSchemaEip7594 executionPayloadSchemaEip7594; - private final ExecutionPayloadHeaderSchemaEip7594 executionPayloadHeaderSchemaEip7594; - - private final BeaconBlockBodySchemaEip7594Impl beaconBlockBodySchema; - private final BlindedBeaconBlockBodySchemaEip7594Impl blindedBeaconBlockBodySchema; - - private final BeaconBlockSchema beaconBlockSchema; - private final BeaconBlockSchema blindedBeaconBlockSchema; - private final SignedBeaconBlockSchema signedBeaconBlockSchema; - private final SignedBeaconBlockSchema signedBlindedBeaconBlockSchema; - - private final BuilderBidSchema builderBidSchemaEip7594; - private final SignedBuilderBidSchema signedBuilderBidSchemaEip7594; - - private final BlockContentsSchema blockContentsSchema; - private final SignedBlockContentsSchema signedBlockContentsSchema; - private final BlobsBundleSchema blobsBundleSchema; - private final ExecutionPayloadAndBlobsBundleSchema executionPayloadAndBlobsBundleSchema; +public class SchemaDefinitionsEip7594 { private final CellSchema cellSchema; private final DataColumnSchema dataColumnSchema; @@ -89,194 +40,37 @@ public class SchemaDefinitionsEip7594 extends SchemaDefinitionsDeneb { dataColumnSidecarsByRangeRequestMessageSchema; private final MetadataMessageSchemaEip7594 metadataMessageSchema; - public SchemaDefinitionsEip7594(final SpecConfigEip7594 specConfig) { - super(specConfig); - this.executionPayloadSchemaEip7594 = new ExecutionPayloadSchemaEip7594(specConfig); - - this.beaconStateSchema = BeaconStateSchemaEip7594.create(specConfig); - this.executionPayloadHeaderSchemaEip7594 = - beaconStateSchema.getLastExecutionPayloadHeaderSchema(); - this.beaconBlockBodySchema = - BeaconBlockBodySchemaEip7594Impl.create( - specConfig, - getAttesterSlashingSchema(), - getSignedBlsToExecutionChangeSchema(), - getBlobKzgCommitmentsSchema(), - "BeaconBlockBodyEip7594"); - this.blindedBeaconBlockBodySchema = - BlindedBeaconBlockBodySchemaEip7594Impl.create( - specConfig, - getAttesterSlashingSchema(), - getSignedBlsToExecutionChangeSchema(), - getBlobKzgCommitmentsSchema(), - "BlindedBlockBodyEip7594"); - this.beaconBlockSchema = new BeaconBlockSchema(beaconBlockBodySchema, "BeaconBlockEip7594"); - this.blindedBeaconBlockSchema = - new BeaconBlockSchema(blindedBeaconBlockBodySchema, "BlindedBlockEip7594"); - this.signedBeaconBlockSchema = - new SignedBeaconBlockSchema(beaconBlockSchema, "SignedBeaconBlockEip7594"); - this.signedBlindedBeaconBlockSchema = - new SignedBeaconBlockSchema(blindedBeaconBlockSchema, "SignedBlindedBlockEip7594"); - this.builderBidSchemaEip7594 = - new BuilderBidSchemaDeneb( - "BuilderBidEip7594", - executionPayloadHeaderSchemaEip7594, - getBlobKzgCommitmentsSchema()); - this.signedBuilderBidSchemaEip7594 = - new SignedBuilderBidSchema("SignedBuilderBidEip7594", builderBidSchemaEip7594); - - this.blockContentsSchema = - BlockContentsSchema.create( - specConfig, beaconBlockSchema, getBlobSchema(), "BlockContentsEip7594"); - this.signedBlockContentsSchema = - SignedBlockContentsSchema.create( - specConfig, signedBeaconBlockSchema, getBlobSchema(), "SignedBlockContentsEip7594"); - this.blobsBundleSchema = - new BlobsBundleSchema( - "BlobsBundleEip7594", getBlobSchema(), getBlobKzgCommitmentsSchema(), specConfig); - this.executionPayloadAndBlobsBundleSchema = - new ExecutionPayloadAndBlobsBundleSchema(executionPayloadSchemaEip7594, blobsBundleSchema); - - this.cellSchema = new CellSchema(specConfig); - this.dataColumnSchema = new DataColumnSchema(specConfig); + public SchemaDefinitionsEip7594(final SchemaRegistry schemaRegistry) { + final SpecConfigElectra specConfig = SpecConfigElectra.required(schemaRegistry.getSpecConfig()); + final Eip7594 featureConfig = Eip7594.required(specConfig); + this.cellSchema = new CellSchema(featureConfig); + this.dataColumnSchema = new DataColumnSchema(featureConfig, specConfig); this.dataColumnSidecarSchema = DataColumnSidecarSchema.create( - SignedBeaconBlockHeader.SSZ_SCHEMA, dataColumnSchema, specConfig); + SignedBeaconBlockHeader.SSZ_SCHEMA, dataColumnSchema, featureConfig, specConfig); this.matrixEntrySchema = MatrixEntrySchema.create(cellSchema); this.dataColumnSidecarsByRootRequestMessageSchema = - new DataColumnSidecarsByRootRequestMessageSchema(specConfig); + new DataColumnSidecarsByRootRequestMessageSchema(featureConfig); this.dataColumnSidecarsByRangeRequestMessageSchema = new DataColumnSidecarsByRangeRequestMessage.DataColumnSidecarsByRangeRequestMessageSchema( - specConfig); + featureConfig); this.metadataMessageSchema = new MetadataMessageSchemaEip7594(specConfig); } public static SchemaDefinitionsEip7594 required(final SchemaDefinitions schemaDefinitions) { checkArgument( - schemaDefinitions instanceof SchemaDefinitionsEip7594, - "Expected definitions of type %s by got %s", + schemaDefinitions.getOptionalSchemaDefinitionsEip7594().isPresent(), + "Expected definitions of type %s but got %s", SchemaDefinitionsEip7594.class, schemaDefinitions.getClass()); - return (SchemaDefinitionsEip7594) schemaDefinitions; - } - - @Override - public BeaconStateSchema - getBeaconStateSchema() { - return beaconStateSchema; - } - - @Override - public BeaconBlockBodySchemaEip7594 getBeaconBlockBodySchema() { - return beaconBlockBodySchema; - } - - @Override - public BeaconBlockBodySchema getBlindedBeaconBlockBodySchema() { - return blindedBeaconBlockBodySchema; - } - - @Override - public BeaconBlockSchema getBeaconBlockSchema() { - return beaconBlockSchema; - } - - @Override - public BeaconBlockSchema getBlindedBeaconBlockSchema() { - return blindedBeaconBlockSchema; - } - - @Override - public SignedBeaconBlockSchema getSignedBeaconBlockSchema() { - return signedBeaconBlockSchema; - } - - @Override - public SignedBeaconBlockSchema getSignedBlindedBeaconBlockSchema() { - return signedBlindedBeaconBlockSchema; - } - - @Override - public BlockContainerSchema getBlockContainerSchema() { - return getBlockContentsSchema().castTypeToBlockContainer(); - } - - @Override - public BlockContainerSchema getBlindedBlockContainerSchema() { - return getBlindedBeaconBlockSchema().castTypeToBlockContainer(); + return schemaDefinitions.getOptionalSchemaDefinitionsEip7594().get(); } - @Override - public SignedBlockContainerSchema getSignedBlockContainerSchema() { - return getSignedBlockContentsSchema().castTypeToSignedBlockContainer(); - } - - @Override - public SignedBlockContainerSchema getSignedBlindedBlockContainerSchema() { - return getSignedBlindedBeaconBlockSchema().castTypeToSignedBlockContainer(); - } - - @Override - public ExecutionPayloadSchema getExecutionPayloadSchema() { - return executionPayloadSchemaEip7594; - } - - @Override - public ExecutionPayloadHeaderSchema getExecutionPayloadHeaderSchema() { - return executionPayloadHeaderSchemaEip7594; - } - - @Override - public BuilderBidSchema getBuilderBidSchema() { - return builderBidSchemaEip7594; - } - - @Override - public SignedBuilderBidSchema getSignedBuilderBidSchema() { - return signedBuilderBidSchemaEip7594; - } - - @Override - public BuilderPayloadSchema getBuilderPayloadSchema() { - return getExecutionPayloadAndBlobsBundleSchema(); - } - - @Override - public BeaconBlockBodyBuilder createBeaconBlockBodyBuilder() { - return new BeaconBlockBodyBuilderEip7594(beaconBlockBodySchema, blindedBeaconBlockBodySchema); - } - - @Override - public BlockContentsSchema getBlockContentsSchema() { - return blockContentsSchema; - } - - @Override - public SignedBlockContentsSchema getSignedBlockContentsSchema() { - return signedBlockContentsSchema; - } - - @Override - public BlobsBundleSchema getBlobsBundleSchema() { - return blobsBundleSchema; - } - - @Override - public ExecutionPayloadAndBlobsBundleSchema getExecutionPayloadAndBlobsBundleSchema() { - return executionPayloadAndBlobsBundleSchema; - } - - @Override - public MetadataMessageSchema getMetadataMessageSchema() { + public MetadataMessageSchemaEip7594 getMetadataMessageSchema() { return metadataMessageSchema; } - @Override - public Optional toVersionEip7594() { - return Optional.of(this); - } - public CellSchema getCellSchema() { return cellSchema; } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsElectra.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsElectra.java new file mode 100644 index 00000000000..6ad613793c7 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsElectra.java @@ -0,0 +1,152 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.schemas; + +import static com.google.common.base.Preconditions.checkArgument; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.CONSOLIDATION_REQUEST_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.DEPOSIT_REQUEST_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_REQUESTS_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.PENDING_CONSOLIDATIONS_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.PENDING_DEPOSITS_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.PENDING_PARTIAL_WITHDRAWALS_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.WITHDRAWAL_REQUEST_SCHEMA; + +import java.util.Optional; +import tech.pegasys.teku.infrastructure.ssz.schema.SszListSchema; +import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodyBuilder; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra.BeaconBlockBodyBuilderElectra; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequestSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequestSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequestSchema; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingConsolidation; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingConsolidation.PendingConsolidationSchema; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingDeposit; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingDeposit.PendingDepositSchema; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingPartialWithdrawal; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingPartialWithdrawal.PendingPartialWithdrawalSchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; + +public class SchemaDefinitionsElectra extends SchemaDefinitionsDeneb { + private final ExecutionRequestsSchema executionRequestsSchema; + private final DepositRequestSchema depositRequestSchema; + private final WithdrawalRequestSchema withdrawalRequestSchema; + private final ConsolidationRequestSchema consolidationRequestSchema; + + private final SszListSchema pendingDepositsSchema; + private final SszListSchema pendingPartialWithdrawalsSchema; + private final SszListSchema pendingConsolidationsSchema; + + private final PendingDepositSchema pendingDepositSchema; + private final PendingPartialWithdrawalSchema pendingPartialWithdrawalSchema; + private final PendingConsolidationSchema pendingConsolidationSchema; + + private final Optional maybeSchemaDefinitionsEip7594; + + public SchemaDefinitionsElectra( + final SchemaRegistry schemaRegistry, + final Optional maybeSchemaDefinitionsEip7594) { + super(schemaRegistry); + this.maybeSchemaDefinitionsEip7594 = maybeSchemaDefinitionsEip7594; + this.executionRequestsSchema = schemaRegistry.get(EXECUTION_REQUESTS_SCHEMA); + this.pendingDepositsSchema = schemaRegistry.get(PENDING_DEPOSITS_SCHEMA); + this.pendingPartialWithdrawalsSchema = schemaRegistry.get(PENDING_PARTIAL_WITHDRAWALS_SCHEMA); + this.pendingConsolidationsSchema = schemaRegistry.get(PENDING_CONSOLIDATIONS_SCHEMA); + + this.depositRequestSchema = schemaRegistry.get(DEPOSIT_REQUEST_SCHEMA); + this.withdrawalRequestSchema = schemaRegistry.get(WITHDRAWAL_REQUEST_SCHEMA); + this.consolidationRequestSchema = schemaRegistry.get(CONSOLIDATION_REQUEST_SCHEMA); + this.pendingDepositSchema = + (PendingDepositSchema) schemaRegistry.get(PENDING_DEPOSITS_SCHEMA).getElementSchema(); + this.pendingPartialWithdrawalSchema = + (PendingPartialWithdrawalSchema) + schemaRegistry.get(PENDING_PARTIAL_WITHDRAWALS_SCHEMA).getElementSchema(); + this.pendingConsolidationSchema = + (PendingConsolidationSchema) + schemaRegistry.get(PENDING_CONSOLIDATIONS_SCHEMA).getElementSchema(); + } + + public static SchemaDefinitionsElectra required(final SchemaDefinitions schemaDefinitions) { + checkArgument( + schemaDefinitions instanceof SchemaDefinitionsElectra, + "Expected definitions of type %s but got %s", + SchemaDefinitionsElectra.class, + schemaDefinitions.getClass()); + return (SchemaDefinitionsElectra) schemaDefinitions; + } + + @Override + public BeaconBlockBodyBuilder createBeaconBlockBodyBuilder() { + return new BeaconBlockBodyBuilderElectra( + getBeaconBlockBodySchema().toVersionElectra().orElseThrow(), + getBlindedBeaconBlockBodySchema().toBlindedVersionElectra().orElseThrow()); + } + + public ExecutionRequestsSchema getExecutionRequestsSchema() { + return executionRequestsSchema; + } + + public DepositRequestSchema getDepositRequestSchema() { + return depositRequestSchema; + } + + public WithdrawalRequestSchema getWithdrawalRequestSchema() { + return withdrawalRequestSchema; + } + + public ConsolidationRequestSchema getConsolidationRequestSchema() { + return consolidationRequestSchema; + } + + public PendingDeposit.PendingDepositSchema getPendingDepositSchema() { + return pendingDepositSchema; + } + + public PendingPartialWithdrawal.PendingPartialWithdrawalSchema + getPendingPartialWithdrawalSchema() { + return pendingPartialWithdrawalSchema; + } + + public PendingConsolidation.PendingConsolidationSchema getPendingConsolidationSchema() { + return pendingConsolidationSchema; + } + + public SszListSchema getPendingDepositsSchema() { + return pendingDepositsSchema; + } + + public SszListSchema getPendingPartialWithdrawalsSchema() { + return pendingPartialWithdrawalsSchema; + } + + public SszListSchema getPendingConsolidationsSchema() { + return pendingConsolidationsSchema; + } + + @Override + public Optional toVersionElectra() { + return Optional.of(this); + } + + @Override + long getMaxValidatorsPerAttestation(final SpecConfig specConfig) { + return (long) specConfig.getMaxValidatorsPerCommittee() * specConfig.getMaxCommitteesPerSlot(); + } + + @Override + public Optional getOptionalSchemaDefinitionsEip7594() { + return maybeSchemaDefinitionsEip7594; + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsPhase0.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsPhase0.java index 6b626578d0b..1cdaa3d5d30 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsPhase0.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionsPhase0.java @@ -13,6 +13,13 @@ package tech.pegasys.teku.spec.schemas; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.AGGREGATE_AND_PROOF_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BEACON_BLOCK_BODY_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BEACON_BLOCK_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BEACON_STATE_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SIGNED_AGGREGATE_AND_PROOF_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SIGNED_BEACON_BLOCK_SCHEMA; + import java.util.Optional; import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlockSchema; @@ -24,29 +31,77 @@ import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodyBuilder; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodySchema; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.phase0.BeaconBlockBodyBuilderPhase0; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.phase0.BeaconBlockBodySchemaPhase0; import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.metadata.MetadataMessageSchema; import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.metadata.versions.phase0.MetadataMessageSchemaPhase0; +import tech.pegasys.teku.spec.datastructures.operations.AggregateAndProof.AggregateAndProofSchema; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; +import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashingSchema; +import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestationSchema; +import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof.SignedAggregateAndProofSchema; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconStateSchema; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.phase0.BeaconStateSchemaPhase0; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.MutableBeaconState; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; +import tech.pegasys.teku.spec.schemas.registry.SchemaTypes; public class SchemaDefinitionsPhase0 extends AbstractSchemaDefinitions { - private final BeaconStateSchemaPhase0 beaconStateSchema; - private final BeaconBlockBodySchemaPhase0 beaconBlockBodySchema; + private final IndexedAttestationSchema indexedAttestationSchema; + private final AttesterSlashingSchema attesterSlashingSchema; + private final AttestationSchema attestationSchema; + private final SignedAggregateAndProofSchema signedAggregateAndProofSchema; + private final AggregateAndProofSchema aggregateAndProofSchema; + private final BeaconStateSchema + beaconStateSchema; + private final BeaconBlockBodySchema beaconBlockBodySchema; private final MetadataMessageSchemaPhase0 metadataMessageSchema; private final BeaconBlockSchema beaconBlockSchema; private final SignedBeaconBlockSchema signedBeaconBlockSchema; - public SchemaDefinitionsPhase0(final SpecConfig specConfig) { - super(specConfig); - this.beaconStateSchema = BeaconStateSchemaPhase0.create(specConfig); - this.beaconBlockBodySchema = - BeaconBlockBodySchemaPhase0.create( - specConfig, getAttesterSlashingSchema(), "BeaconBlockBodyPhase0"); + public SchemaDefinitionsPhase0(final SchemaRegistry schemaRegistry) { + super(schemaRegistry); + final SpecConfig specConfig = schemaRegistry.getSpecConfig(); + this.indexedAttestationSchema = schemaRegistry.get(SchemaTypes.INDEXED_ATTESTATION_SCHEMA); + this.attesterSlashingSchema = schemaRegistry.get(SchemaTypes.ATTESTER_SLASHING_SCHEMA); + + this.attestationSchema = schemaRegistry.get(SchemaTypes.ATTESTATION_SCHEMA); + this.aggregateAndProofSchema = schemaRegistry.get(AGGREGATE_AND_PROOF_SCHEMA); + this.signedAggregateAndProofSchema = schemaRegistry.get(SIGNED_AGGREGATE_AND_PROOF_SCHEMA); + this.beaconStateSchema = schemaRegistry.get(BEACON_STATE_SCHEMA); + this.beaconBlockBodySchema = schemaRegistry.get(BEACON_BLOCK_BODY_SCHEMA); this.metadataMessageSchema = new MetadataMessageSchemaPhase0(specConfig.getNetworkingConfig()); - beaconBlockSchema = new BeaconBlockSchema(beaconBlockBodySchema, "BeaconBlockPhase0"); - signedBeaconBlockSchema = - new SignedBeaconBlockSchema(beaconBlockSchema, "SignedBeaconBlockPhase0"); + this.beaconBlockSchema = schemaRegistry.get(BEACON_BLOCK_SCHEMA); + this.signedBeaconBlockSchema = schemaRegistry.get(SIGNED_BEACON_BLOCK_SCHEMA); + } + + @Override + long getMaxValidatorsPerAttestation(final SpecConfig specConfig) { + return specConfig.getMaxValidatorsPerCommittee(); + } + + @Override + public SignedAggregateAndProofSchema getSignedAggregateAndProofSchema() { + return signedAggregateAndProofSchema; + } + + @Override + public AggregateAndProofSchema getAggregateAndProofSchema() { + return aggregateAndProofSchema; + } + + @Override + public AttestationSchema getAttestationSchema() { + return attestationSchema; + } + + @Override + public IndexedAttestationSchema getIndexedAttestationSchema() { + return indexedAttestationSchema; + } + + @Override + public AttesterSlashingSchema getAttesterSlashingSchema() { + return attesterSlashingSchema; } @Override diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/registry/BaseSchemaProvider.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/registry/BaseSchemaProvider.java new file mode 100644 index 00000000000..65f72a7a51a --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/registry/BaseSchemaProvider.java @@ -0,0 +1,206 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.schemas.registry; + +import static com.google.common.base.Preconditions.checkArgument; + +import com.google.common.base.MoreObjects; +import java.util.ArrayList; +import java.util.List; +import java.util.Set; +import java.util.TreeMap; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SchemaId; + +class BaseSchemaProvider implements SchemaProvider { + private final TreeMap> milestoneToSchemaCreator = + new TreeMap<>(); + private final SchemaId schemaId; + private final boolean alwaysCreateNewSchema; + + private BaseSchemaProvider( + final SchemaId schemaId, + final List> schemaProviderCreators, + final SpecMilestone untilMilestone, + final boolean alwaysCreateNewSchema) { + this.schemaId = schemaId; + this.alwaysCreateNewSchema = alwaysCreateNewSchema; + final List> creatorsList = new ArrayList<>(schemaProviderCreators); + + SchemaProviderCreator lastCreator = null; + + for (final SpecMilestone milestone : SpecMilestone.getMilestonesUpTo(untilMilestone)) { + if (!creatorsList.isEmpty() && creatorsList.getFirst().baseMilestone == milestone) { + lastCreator = creatorsList.removeFirst(); + } + + if (lastCreator != null) { + milestoneToSchemaCreator.put(milestone, lastCreator); + } + } + } + + @Override + public SpecMilestone getBaseMilestone(final SpecMilestone milestone) { + return getSchemaCreator(milestone).baseMilestone; + } + + @Override + public boolean alwaysCreateNewSchema() { + return alwaysCreateNewSchema; + } + + @Override + public T getSchema(final SchemaRegistry registry) { + final SpecMilestone milestone = registry.getMilestone(); + return createSchema(registry, milestone, registry.getSpecConfig()); + } + + @Override + public SchemaId getSchemaId() { + return schemaId; + } + + protected T createSchema( + final SchemaRegistry registry, + final SpecMilestone effectiveMilestone, + final SpecConfig specConfig) { + return getSchemaCreator(effectiveMilestone) + .creator + .create(registry, specConfig, schemaId.getSchemaName(registry.getMilestone())); + } + + private SchemaProviderCreator getSchemaCreator(final SpecMilestone milestone) { + final SchemaProviderCreator maybeSchemaCreator = milestoneToSchemaCreator.get(milestone); + if (maybeSchemaCreator == null) { + throw new IllegalArgumentException( + "It is not supposed to create a specific version for " + milestone); + } + return maybeSchemaCreator; + } + + @Override + public Set getSupportedMilestones() { + return milestoneToSchemaCreator.keySet(); + } + + protected record SchemaProviderCreator(SpecMilestone baseMilestone, SchemaCreator creator) { + + @Override + public String toString() { + return MoreObjects.toStringHelper(this).add("baseMilestone", baseMilestone).toString(); + } + } + + /** + * Creates a builder for a schema provider.
+ * Example usage: + * + * 

{@code
+   * providerBuilder(EXAMPLE_SCHEMA)
+   *    .withCreator(ALTAIR, (registry, config) -> ExampleSchema1.create(registry, config))
+   *    .withCreator(ELECTRA, (registry, config) -> ExampleSchema2.create(registry, config))
+   *    .build();
+   *
+   * }
+ * + * this will create a schema provider that will generate:
+ * - a new ExampleSchema1 for each milestone from ALTAIR to CAPELLA
+ * - a new ExampleSchema2 for each milestone from ELECTRA to last known milestone
+ * + *

By default, the schema provider will check for schema equality when a creator is used + * multiple times. In the previous example, if ExampleSchema1.create generates schemas that are + * equals in both ALTAIR and BELLATRIX context, the ALTAIR instance will be used for + * BELLATRIX too.
+ * Since the equality check does not consider names, semantically equivalent schemas with + * different fields or container names will be considered equal.
+ * + *

If the equality check is relevant, this behavior can be avoided in two ways:
+ * - specifying a new creator like:
+ * + * 

{@code
+   * variableProviderBuilder(EXAMPLE_SCHEMA)
+   *    .withCreator(ALTAIR, (registry, config) -> ExampleSchema1.create(registry, config))
+   *    .withCreator(BELLATRIX, (registry, config) -> ExampleSchema1.create(registry, config))
+   *    .withCreator(ELECTRA, (registry, config) -> ExampleSchema2.create(registry, config))
+   *    .build();
+   *
+   * }
+ * + * - using {@link Builder#alwaysCreateNewSchema()} + */ + static Builder providerBuilder(final SchemaId schemaId) { + return new Builder<>(schemaId); + } + + static class Builder { + private final SchemaId schemaId; + final List> schemaProviderCreators = new ArrayList<>(); + private SpecMilestone untilMilestone = SpecMilestone.getHighestMilestone(); + private boolean alwaysCreateNewSchema = false; + + private Builder(final SchemaId schemaId) { + this.schemaId = schemaId; + } + + public Builder withCreator( + final SpecMilestone milestone, final SchemaCreator creationSchema) { + checkArgument( + schemaProviderCreators.isEmpty() + || milestone.isGreaterThan(schemaProviderCreators.getLast().baseMilestone), + "Creator's milestones must added in strict ascending order for %s", + schemaId); + + schemaProviderCreators.add(new SchemaProviderCreator<>(milestone, creationSchema)); + return this; + } + + /** + * This can be used when a schema is deprecated and should not be used for newer milestones. + * + * @param untilMilestone the last milestone for which the schema will be created + */ + public Builder until(final SpecMilestone untilMilestone) { + this.untilMilestone = untilMilestone; + return this; + } + + /** + * Forces schema provider to create a new schema on each milestone, disabling schema equality + * check with previous milestone. Refer to {@link BaseSchemaProvider} for more information. + */ + public Builder alwaysCreateNewSchema() { + this.alwaysCreateNewSchema = true; + return this; + } + + public BaseSchemaProvider build() { + checkArgument( + !schemaProviderCreators.isEmpty(), "There should be at least 1 creator for %s", schemaId); + + checkArgument( + untilMilestone.isGreaterThanOrEqualTo(schemaProviderCreators.getLast().baseMilestone), + "until must be greater or equal than last creator milestone in %s", + schemaId); + return new BaseSchemaProvider<>( + schemaId, schemaProviderCreators, untilMilestone, alwaysCreateNewSchema); + } + } + + @FunctionalInterface + public interface SchemaCreator { + T create(SchemaRegistry registry, SpecConfig specConfig, String schemaName); + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/registry/SchemaCache.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/registry/SchemaCache.java new file mode 100644 index 00000000000..5bd6dabee3b --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/registry/SchemaCache.java @@ -0,0 +1,49 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.schemas.registry; + +import java.util.EnumMap; +import java.util.HashMap; +import java.util.Map; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SchemaId; + +interface SchemaCache { + static SchemaCache createDefault() { + return new SchemaCache() { + private final Map, Object>> cache = + new EnumMap<>(SpecMilestone.class); + + @SuppressWarnings("unchecked") + @Override + public T get(final SpecMilestone milestone, final SchemaId schemaId) { + final Map milestoneSchemaIds = cache.get(milestone); + if (milestoneSchemaIds == null) { + return null; + } + return (T) milestoneSchemaIds.get(schemaId); + } + + @Override + public void put( + final SpecMilestone milestone, final SchemaId schemaId, final T schema) { + cache.computeIfAbsent(milestone, __ -> new HashMap<>()).put(schemaId, schema); + } + }; + } + + T get(SpecMilestone milestone, SchemaId schemaId); + + void put(SpecMilestone milestone, SchemaId schemaId, T schema); +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/registry/SchemaProvider.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/registry/SchemaProvider.java new file mode 100644 index 00000000000..d16da64c985 --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/registry/SchemaProvider.java @@ -0,0 +1,30 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.schemas.registry; + +import java.util.Set; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SchemaId; + +interface SchemaProvider { + T getSchema(SchemaRegistry registry); + + Set getSupportedMilestones(); + + SpecMilestone getBaseMilestone(SpecMilestone version); + + boolean alwaysCreateNewSchema(); + + SchemaId getSchemaId(); +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/registry/SchemaRegistry.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/registry/SchemaRegistry.java new file mode 100644 index 00000000000..34415dce95c --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/registry/SchemaRegistry.java @@ -0,0 +1,142 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.schemas.registry; + +import static com.google.common.base.Preconditions.checkState; + +import com.google.common.annotations.VisibleForTesting; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.Set; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SchemaId; + +public class SchemaRegistry { + // this is used for dependency loop detection during priming + private static final Set> INFLIGHT_PROVIDERS = new HashSet<>(); + + private final Map, SchemaProvider> providers = new HashMap<>(); + private final SpecMilestone milestone; + private final SchemaCache cache; + private final SpecConfig specConfig; + private boolean primed; + + SchemaRegistry( + final SpecMilestone milestone, final SpecConfig specConfig, final SchemaCache cache) { + this.milestone = milestone; + this.specConfig = specConfig; + this.cache = cache; + this.primed = false; + } + + /** + * This is supposed to be called only by {@link SchemaRegistryBuilder#build(SpecMilestone, + * SpecConfig)} which is synchronized + */ + void registerProvider(final SchemaProvider provider) { + if (primed) { + throw new IllegalStateException("Cannot add a provider to a primed registry"); + } + if (providers.put(provider.getSchemaId(), provider) != null) { + throw new IllegalStateException( + "Cannot add provider " + + provider.getClass().getSimpleName() + + " referencing " + + provider.getSchemaId() + + " which has been already added via another provider"); + } + } + + @VisibleForTesting + boolean isProviderRegistered(final SchemaProvider provider) { + return provider.equals(providers.get(provider.getSchemaId())); + } + + @SuppressWarnings("unchecked") + public T get(final SchemaId schemaId) { + final T schema = cache.get(milestone, schemaId); + if (schema != null) { + return schema; + } + + final SchemaProvider provider = (SchemaProvider) providers.get(schemaId); + if (provider == null) { + throw new IllegalArgumentException( + "No provider registered for schema " + + schemaId + + " or it does not support milestone " + + milestone); + } + + // The schema was not found. + // we reach this point only during priming when we actually ask providers to generate schemas + checkState(!primed, "Registry is primed but schema not found for %s", schemaId); + + // save the provider as "inflight" + if (!INFLIGHT_PROVIDERS.add(provider)) { + throw new IllegalStateException("loop detected creating schema for " + schemaId); + } + + // actual schema creation (may trigger recursive registry lookups) + final T createdSchema = provider.getSchema(this); + + // release the provider + INFLIGHT_PROVIDERS.remove(provider); + + // let's check if the created schema is equal to the one from the previous milestone + final SpecMilestone effectiveMilestone = provider.getBaseMilestone(milestone); + final T resolvedSchema; + if (provider.alwaysCreateNewSchema()) { + resolvedSchema = createdSchema; + } else { + resolvedSchema = + milestone + .getPreviousMilestoneIfExists() + .filter( + previousMilestone -> previousMilestone.isGreaterThanOrEqualTo(effectiveMilestone)) + .map(previousMilestone -> cache.get(previousMilestone, schemaId)) + .filter(previousSchema -> previousSchema.equals(createdSchema)) + .orElse(createdSchema); + } + + // cache the schema + cache.put(milestone, schemaId, resolvedSchema); + + return resolvedSchema; + } + + public SpecMilestone getMilestone() { + return milestone; + } + + public SpecConfig getSpecConfig() { + return specConfig; + } + + /** + * This is supposed to be called only by {@link SchemaRegistryBuilder#build(SpecMilestone, + * SpecConfig)} which is synchronized + */ + void primeRegistry() { + if (primed) { + throw new IllegalStateException("Registry already primed"); + } + for (final SchemaId schemaClass : providers.keySet()) { + get(schemaClass); + } + primed = true; + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/registry/SchemaRegistryBuilder.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/registry/SchemaRegistryBuilder.java new file mode 100644 index 00000000000..0f459fb0d4b --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/registry/SchemaRegistryBuilder.java @@ -0,0 +1,719 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.schemas.registry; + +import static com.google.common.base.Preconditions.checkArgument; +import static tech.pegasys.teku.spec.SpecMilestone.ALTAIR; +import static tech.pegasys.teku.spec.SpecMilestone.BELLATRIX; +import static tech.pegasys.teku.spec.SpecMilestone.CAPELLA; +import static tech.pegasys.teku.spec.SpecMilestone.DENEB; +import static tech.pegasys.teku.spec.SpecMilestone.ELECTRA; +import static tech.pegasys.teku.spec.SpecMilestone.PHASE0; +import static tech.pegasys.teku.spec.schemas.registry.BaseSchemaProvider.providerBuilder; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.AGGREGATE_AND_PROOF_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.ATTESTATION_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.ATTESTER_SLASHING_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.ATTNETS_ENR_FIELD_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BEACON_BLOCKS_BY_ROOT_REQUEST_MESSAGE_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BEACON_BLOCK_BODY_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BEACON_BLOCK_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BEACON_STATE_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLINDED_BEACON_BLOCK_BODY_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLINDED_BEACON_BLOCK_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOBS_BUNDLE_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOBS_IN_BLOCK_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOB_KZG_COMMITMENTS_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOB_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOB_SIDECARS_BY_ROOT_REQUEST_MESSAGE_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOB_SIDECAR_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLOCK_CONTENTS_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BLS_TO_EXECUTION_CHANGE_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.BUILDER_BID_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.CONSOLIDATION_REQUEST_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.DEPOSIT_REQUEST_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_PAYLOAD_AND_BLOBS_BUNDLE_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_PAYLOAD_HEADER_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_PAYLOAD_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.EXECUTION_REQUESTS_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.HISTORICAL_BATCH_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.HISTORICAL_SUMMARIES_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.INDEXED_ATTESTATION_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.PENDING_CONSOLIDATIONS_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.PENDING_DEPOSITS_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.PENDING_PARTIAL_WITHDRAWALS_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SIGNED_AGGREGATE_AND_PROOF_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SIGNED_BEACON_BLOCK_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SIGNED_BLINDED_BEACON_BLOCK_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SIGNED_BLOCK_CONTENTS_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SIGNED_BLS_TO_EXECUTION_CHANGE_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SIGNED_BUILDER_BID_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SYNCNETS_ENR_FIELD_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.WITHDRAWAL_REQUEST_SCHEMA; +import static tech.pegasys.teku.spec.schemas.registry.SchemaTypes.WITHDRAWAL_SCHEMA; + +import com.google.common.annotations.VisibleForTesting; +import java.util.HashSet; +import java.util.Set; +import tech.pegasys.teku.infrastructure.ssz.schema.SszListSchema; +import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszBitvectorSchema; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.config.SpecConfigBellatrix; +import tech.pegasys.teku.spec.config.SpecConfigCapella; +import tech.pegasys.teku.spec.config.SpecConfigDeneb; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.constants.NetworkConstants; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobKzgCommitmentsSchema; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSchema; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecarSchema; +import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlockSchema; +import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockHeader; +import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockSchema; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.BeaconBlockBodySchemaAltairImpl; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.bellatrix.BeaconBlockBodySchemaBellatrixImpl; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.bellatrix.BlindedBeaconBlockBodySchemaBellatrixImpl; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.capella.BeaconBlockBodySchemaCapellaImpl; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.capella.BlindedBeaconBlockBodySchemaCapellaImpl; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.deneb.BeaconBlockBodySchemaDenebImpl; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.deneb.BlindedBeaconBlockBodySchemaDenebImpl; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra.BeaconBlockBodySchemaElectraImpl; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra.BlindedBeaconBlockBodySchemaElectraImpl; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.phase0.BeaconBlockBodySchemaPhase0; +import tech.pegasys.teku.spec.datastructures.blocks.versions.deneb.BlockContentsSchema; +import tech.pegasys.teku.spec.datastructures.blocks.versions.deneb.SignedBlockContentsSchema; +import tech.pegasys.teku.spec.datastructures.builder.BlobsBundleSchema; +import tech.pegasys.teku.spec.datastructures.builder.ExecutionPayloadAndBlobsBundleSchema; +import tech.pegasys.teku.spec.datastructures.builder.SignedBuilderBidSchema; +import tech.pegasys.teku.spec.datastructures.builder.versions.bellatrix.BuilderBidSchemaBellatrix; +import tech.pegasys.teku.spec.datastructures.builder.versions.deneb.BuilderBidSchemaDeneb; +import tech.pegasys.teku.spec.datastructures.builder.versions.electra.BuilderBidSchemaElectra; +import tech.pegasys.teku.spec.datastructures.execution.versions.bellatrix.ExecutionPayloadHeaderSchemaBellatrix; +import tech.pegasys.teku.spec.datastructures.execution.versions.bellatrix.ExecutionPayloadSchemaBellatrix; +import tech.pegasys.teku.spec.datastructures.execution.versions.capella.ExecutionPayloadHeaderSchemaCapella; +import tech.pegasys.teku.spec.datastructures.execution.versions.capella.ExecutionPayloadSchemaCapella; +import tech.pegasys.teku.spec.datastructures.execution.versions.capella.WithdrawalSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadHeaderSchemaDeneb; +import tech.pegasys.teku.spec.datastructures.execution.versions.deneb.ExecutionPayloadSchemaDeneb; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequestSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequestSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequestSchema; +import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.BeaconBlocksByRootRequestMessage.BeaconBlocksByRootRequestMessageSchema; +import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.BlobSidecarsByRootRequestMessageSchema; +import tech.pegasys.teku.spec.datastructures.operations.AggregateAndProof.AggregateAndProofSchema; +import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashingSchema; +import tech.pegasys.teku.spec.datastructures.operations.BlsToExecutionChangeSchema; +import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestationSchema; +import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof.SignedAggregateAndProofSchema; +import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChangeSchema; +import tech.pegasys.teku.spec.datastructures.operations.versions.electra.AttestationElectraSchema; +import tech.pegasys.teku.spec.datastructures.operations.versions.phase0.AttestationPhase0Schema; +import tech.pegasys.teku.spec.datastructures.state.HistoricalBatch.HistoricalBatchSchema; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.altair.BeaconStateSchemaAltair; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.bellatrix.BeaconStateSchemaBellatrix; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.capella.BeaconStateSchemaCapella; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.deneb.BeaconStateSchemaDeneb; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.BeaconStateSchemaElectra; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.phase0.BeaconStateSchemaPhase0; +import tech.pegasys.teku.spec.datastructures.state.versions.capella.HistoricalSummary.HistoricalSummarySchema; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingConsolidation.PendingConsolidationSchema; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingDeposit.PendingDepositSchema; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingPartialWithdrawal.PendingPartialWithdrawalSchema; +import tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SchemaId; + +public class SchemaRegistryBuilder { + private final Set> providers = new HashSet<>(); + private final Set> schemaIds = new HashSet<>(); + private final SchemaCache cache; + private SpecMilestone lastBuiltSchemaRegistryMilestone; + + public static SchemaRegistryBuilder create() { + return new SchemaRegistryBuilder() + // PHASE0 + .addProvider(createAttnetsENRFieldSchemaProvider()) + .addProvider(createSyncnetsENRFieldSchemaProvider()) + .addProvider(createBeaconBlocksByRootRequestMessageSchemaProvider()) + .addProvider(createHistoricalBatchSchemaProvider()) + .addProvider(createIndexedAttestationSchemaProvider()) + .addProvider(createAttesterSlashingSchemaProvider()) + .addProvider(createAttestationSchemaProvider()) + .addProvider(createAggregateAndProofSchemaProvider()) + .addProvider(createSignedAggregateAndProofSchemaProvider()) + .addProvider(createBeaconBlockBodySchemaProvider()) + .addProvider(createBeaconBlockSchemaProvider()) + .addProvider(createSignedBeaconBlockSchemaProvider()) + .addProvider(createBeaconStateSchemaProvider()) + + // BELLATRIX + .addProvider(createExecutionPayloadSchemaProvider()) + .addProvider(createExecutionPayloadHeaderSchemaProvider()) + .addProvider(createBlindedBeaconBlockBodySchemaProvider()) + .addProvider(createBlindedBeaconBlockSchemaProvider()) + .addProvider(createSignedBlindedBeaconBlockSchemaProvider()) + .addProvider(createBuilderBidSchemaProvider()) + .addProvider(createSignedBuilderBidSchemaProvider()) + + // CAPELLA + .addProvider(createWithdrawalSchemaProvider()) + .addProvider(createBlsToExecutionChangeSchemaProvider()) + .addProvider(createSignedBlsToExecutionChangeSchemaProvider()) + .addProvider(createHistoricalSummariesSchemaProvider()) + + // DENEB + .addProvider(createBlobKzgCommitmentsSchemaProvider()) + .addProvider(createBlobSchemaProvider()) + .addProvider(createBlobsInBlockSchemaProvider()) + .addProvider(createBlobSidecarSchemaProvider()) + .addProvider(createBlobSidecarsByRootRequestMessageSchemaProvider()) + .addProvider(createBlobsBundleSchemaProvider()) + .addProvider(createBlockContentsSchema()) + .addProvider(createSignedBlockContentsSchema()) + .addProvider(createExecutionPayloadAndBlobsBundleSchemaProvider()) + + // ELECTRA + .addProvider(createPendingConsolidationsSchemaProvider()) + .addProvider(createPendingPartialWithdrawalsSchemaProvider()) + .addProvider(createPendingDepositsSchemaProvider()) + .addProvider(createDepositRequestSchemaProvider()) + .addProvider(createWithdrawalRequestSchemaProvider()) + .addProvider(createConsolidationRequestSchemaProvider()) + .addProvider(createExecutionRequestsSchemaProvider()); + } + + private static SchemaProvider createDepositRequestSchemaProvider() { + return providerBuilder(DEPOSIT_REQUEST_SCHEMA) + .withCreator(ELECTRA, (registry, specConfig, schemaName) -> new DepositRequestSchema()) + .build(); + } + + private static SchemaProvider createWithdrawalRequestSchemaProvider() { + return providerBuilder(WITHDRAWAL_REQUEST_SCHEMA) + .withCreator(ELECTRA, (registry, specConfig, schemaName) -> new WithdrawalRequestSchema()) + .build(); + } + + private static SchemaProvider createConsolidationRequestSchemaProvider() { + return providerBuilder(CONSOLIDATION_REQUEST_SCHEMA) + .withCreator( + ELECTRA, (registry, specConfig, schemaName) -> new ConsolidationRequestSchema()) + .build(); + } + + private static SchemaProvider createBlockContentsSchema() { + return providerBuilder(BLOCK_CONTENTS_SCHEMA) + .withCreator( + DENEB, + (registry, specConfig, schemaName) -> + new BlockContentsSchema(schemaName, SpecConfigDeneb.required(specConfig), registry)) + .build(); + } + + private static SchemaProvider createSignedBlockContentsSchema() { + return providerBuilder(SIGNED_BLOCK_CONTENTS_SCHEMA) + .withCreator( + DENEB, + (registry, specConfig, schemaName) -> + new SignedBlockContentsSchema( + schemaName, SpecConfigDeneb.required(specConfig), registry)) + .build(); + } + + private static SchemaProvider createSignedBuilderBidSchemaProvider() { + return providerBuilder(SIGNED_BUILDER_BID_SCHEMA) + .withCreator( + BELLATRIX, + (registry, specConfig, schemaName) -> new SignedBuilderBidSchema(schemaName, registry)) + .build(); + } + + private static SchemaProvider createBuilderBidSchemaProvider() { + return providerBuilder(BUILDER_BID_SCHEMA) + .withCreator( + BELLATRIX, + (registry, specConfig, schemaName) -> + new BuilderBidSchemaBellatrix(schemaName, registry)) + // CAPELLA is same as BELLATRIX + .withCreator( + DENEB, + (registry, specConfig, schemaName) -> new BuilderBidSchemaDeneb(schemaName, registry)) + .withCreator( + ELECTRA, + (registry, specConfig, schemaName) -> new BuilderBidSchemaElectra(schemaName, registry)) + .build(); + } + + private static SchemaProvider createPendingDepositsSchemaProvider() { + return providerBuilder(PENDING_DEPOSITS_SCHEMA) + .withCreator( + ELECTRA, + (registry, specConfig, schemaName) -> + SszListSchema.create( + new PendingDepositSchema(), + SpecConfigElectra.required(specConfig).getPendingDepositsLimit())) + .build(); + } + + private static SchemaProvider createPendingPartialWithdrawalsSchemaProvider() { + return providerBuilder(PENDING_PARTIAL_WITHDRAWALS_SCHEMA) + .withCreator( + ELECTRA, + (registry, specConfig, schemaName) -> + SszListSchema.create( + new PendingPartialWithdrawalSchema(), + SpecConfigElectra.required(specConfig).getPendingPartialWithdrawalsLimit())) + .build(); + } + + private static SchemaProvider createPendingConsolidationsSchemaProvider() { + return providerBuilder(PENDING_CONSOLIDATIONS_SCHEMA) + .withCreator( + ELECTRA, + (registry, specConfig, schemaName) -> + SszListSchema.create( + new PendingConsolidationSchema(), + SpecConfigElectra.required(specConfig).getPendingConsolidationsLimit())) + .build(); + } + + private static SchemaProvider createExecutionPayloadAndBlobsBundleSchemaProvider() { + return providerBuilder(EXECUTION_PAYLOAD_AND_BLOBS_BUNDLE_SCHEMA) + .withCreator( + DENEB, + (registry, specConfig, schemaName) -> + new ExecutionPayloadAndBlobsBundleSchema(registry)) + .build(); + } + + private static SchemaProvider createBeaconStateSchemaProvider() { + return providerBuilder(BEACON_STATE_SCHEMA) + .withCreator( + PHASE0, + (registry, specConfig, schemaName) -> BeaconStateSchemaPhase0.create(specConfig)) + .withCreator( + ALTAIR, + (registry, specConfig, schemaName) -> BeaconStateSchemaAltair.create(specConfig)) + .withCreator( + BELLATRIX, + (registry, specConfig, schemaName) -> + BeaconStateSchemaBellatrix.create(specConfig, registry)) + .withCreator( + CAPELLA, + (registry, specConfig, schemaName) -> + BeaconStateSchemaCapella.create(specConfig, registry)) + .withCreator( + DENEB, + (registry, specConfig, schemaName) -> + BeaconStateSchemaDeneb.create(SpecConfigDeneb.required(specConfig), registry)) + .withCreator( + ELECTRA, + (registry, specConfig, schemaName) -> + BeaconStateSchemaElectra.create(SpecConfigElectra.required(specConfig), registry)) + .build(); + } + + private static SchemaProvider createBlindedBeaconBlockSchemaProvider() { + return providerBuilder(BLINDED_BEACON_BLOCK_SCHEMA) + .withCreator( + BELLATRIX, + (registry, specConfig, schemaName) -> + new BeaconBlockSchema(registry.get(BLINDED_BEACON_BLOCK_BODY_SCHEMA), schemaName)) + .build(); + } + + private static SchemaProvider createSignedBlindedBeaconBlockSchemaProvider() { + return providerBuilder(SIGNED_BLINDED_BEACON_BLOCK_SCHEMA) + .withCreator( + BELLATRIX, + (registry, specConfig, schemaName) -> + new SignedBeaconBlockSchema(registry.get(BLINDED_BEACON_BLOCK_SCHEMA), schemaName)) + .build(); + } + + private static SchemaProvider createBeaconBlockSchemaProvider() { + return providerBuilder(BEACON_BLOCK_SCHEMA) + .withCreator( + PHASE0, + (registry, specConfig, schemaName) -> + new BeaconBlockSchema(registry.get(BEACON_BLOCK_BODY_SCHEMA), schemaName)) + .build(); + } + + private static SchemaProvider createSignedBeaconBlockSchemaProvider() { + return providerBuilder(SIGNED_BEACON_BLOCK_SCHEMA) + .withCreator( + PHASE0, + (registry, specConfig, schemaName) -> + new SignedBeaconBlockSchema(registry.get(BEACON_BLOCK_SCHEMA), schemaName)) + .build(); + } + + private static SchemaProvider createExecutionRequestsSchemaProvider() { + return providerBuilder(EXECUTION_REQUESTS_SCHEMA) + .withCreator( + ELECTRA, + (registry, specConfig, schemaName) -> + new ExecutionRequestsSchema( + SpecConfigElectra.required(specConfig), registry, schemaName)) + .build(); + } + + private static SchemaProvider createBlindedBeaconBlockBodySchemaProvider() { + return providerBuilder(BLINDED_BEACON_BLOCK_BODY_SCHEMA) + .withCreator( + BELLATRIX, + (registry, specConfig, schemaName) -> + BlindedBeaconBlockBodySchemaBellatrixImpl.create( + SpecConfigBellatrix.required(specConfig), schemaName, registry)) + .withCreator( + CAPELLA, + (registry, specConfig, schemaName) -> + BlindedBeaconBlockBodySchemaCapellaImpl.create( + SpecConfigCapella.required(specConfig), schemaName, registry)) + .withCreator( + DENEB, + (registry, specConfig, schemaName) -> + BlindedBeaconBlockBodySchemaDenebImpl.create( + SpecConfigDeneb.required(specConfig), schemaName, registry)) + .withCreator( + ELECTRA, + (registry, specConfig, schemaName) -> + BlindedBeaconBlockBodySchemaElectraImpl.create( + SpecConfigElectra.required(specConfig), schemaName, registry)) + .build(); + } + + private static SchemaProvider createBeaconBlockBodySchemaProvider() { + return providerBuilder(BEACON_BLOCK_BODY_SCHEMA) + .withCreator( + PHASE0, + (registry, specConfig, schemaName) -> + BeaconBlockBodySchemaPhase0.create(specConfig, schemaName, registry)) + .withCreator( + ALTAIR, + (registry, specConfig, schemaName) -> + BeaconBlockBodySchemaAltairImpl.create(specConfig, schemaName, registry)) + .withCreator( + BELLATRIX, + (registry, specConfig, schemaName) -> + BeaconBlockBodySchemaBellatrixImpl.create( + SpecConfigBellatrix.required(specConfig), schemaName, registry)) + .withCreator( + CAPELLA, + (registry, specConfig, schemaName) -> + BeaconBlockBodySchemaCapellaImpl.create( + SpecConfigCapella.required(specConfig), schemaName, registry)) + .withCreator( + DENEB, + (registry, specConfig, schemaName) -> + BeaconBlockBodySchemaDenebImpl.create( + SpecConfigDeneb.required(specConfig), schemaName, registry)) + .withCreator( + ELECTRA, + (registry, specConfig, schemaName) -> + BeaconBlockBodySchemaElectraImpl.create( + SpecConfigElectra.required(specConfig), schemaName, registry)) + .build(); + } + + private static SchemaProvider createExecutionPayloadHeaderSchemaProvider() { + return providerBuilder(EXECUTION_PAYLOAD_HEADER_SCHEMA) + .withCreator( + BELLATRIX, + (registry, specConfig, schemaName) -> + new ExecutionPayloadHeaderSchemaBellatrix(SpecConfigBellatrix.required(specConfig))) + .withCreator( + CAPELLA, + (registry, specConfig, schemaName) -> + new ExecutionPayloadHeaderSchemaCapella(SpecConfigCapella.required(specConfig))) + .withCreator( + DENEB, + (registry, specConfig, schemaName) -> + new ExecutionPayloadHeaderSchemaDeneb(SpecConfigDeneb.required(specConfig))) + // ELECTRA is same as DENEB + .build(); + } + + private static SchemaProvider createExecutionPayloadSchemaProvider() { + return providerBuilder(EXECUTION_PAYLOAD_SCHEMA) + .withCreator( + BELLATRIX, + (registry, specConfig, schemaName) -> + new ExecutionPayloadSchemaBellatrix(SpecConfigBellatrix.required(specConfig))) + .withCreator( + CAPELLA, + (registry, specConfig, schemaName) -> + new ExecutionPayloadSchemaCapella(SpecConfigCapella.required(specConfig))) + .withCreator( + DENEB, + (registry, specConfig, schemaName) -> + new ExecutionPayloadSchemaDeneb(SpecConfigDeneb.required(specConfig))) + // ELECTRA is same as DENEB + .build(); + } + + private static SchemaProvider createBlobsBundleSchemaProvider() { + return providerBuilder(BLOBS_BUNDLE_SCHEMA) + .withCreator( + DENEB, + (registry, specConfig, schemaName) -> + new BlobsBundleSchema(registry, SpecConfigDeneb.required(specConfig))) + .build(); + } + + private static SchemaProvider createBlobKzgCommitmentsSchemaProvider() { + return providerBuilder(BLOB_KZG_COMMITMENTS_SCHEMA) + .withCreator( + DENEB, + (registry, specConfig, schemaName) -> + new BlobKzgCommitmentsSchema(SpecConfigDeneb.required(specConfig))) + .build(); + } + + private static SchemaProvider createBlobSchemaProvider() { + return providerBuilder(BLOB_SCHEMA) + .withCreator( + DENEB, + (registry, specConfig, schemaName) -> + new BlobSchema(SpecConfigDeneb.required(specConfig))) + .build(); + } + + private static SchemaProvider createBlobsInBlockSchemaProvider() { + return providerBuilder(BLOBS_IN_BLOCK_SCHEMA) + .withCreator( + DENEB, + (registry, specConfig, schemaName) -> + SszListSchema.create( + registry.get(BLOB_SCHEMA), + SpecConfigDeneb.required(specConfig).getMaxBlobsPerBlock())) + .build(); + } + + private static SchemaProvider createBlobSidecarSchemaProvider() { + return providerBuilder(BLOB_SIDECAR_SCHEMA) + .withCreator( + DENEB, + (registry, specConfig, schemaName) -> + BlobSidecarSchema.create( + SignedBeaconBlockHeader.SSZ_SCHEMA, + registry.get(BLOB_SCHEMA), + SpecConfigDeneb.required(specConfig).getKzgCommitmentInclusionProofDepth())) + .build(); + } + + private static SchemaProvider createBlobSidecarsByRootRequestMessageSchemaProvider() { + return providerBuilder(BLOB_SIDECARS_BY_ROOT_REQUEST_MESSAGE_SCHEMA) + .withCreator( + DENEB, + (registry, specConfig, schemaName) -> + new BlobSidecarsByRootRequestMessageSchema(SpecConfigDeneb.required(specConfig))) + .build(); + } + + private static SchemaProvider createHistoricalSummariesSchemaProvider() { + return providerBuilder(HISTORICAL_SUMMARIES_SCHEMA) + .withCreator( + CAPELLA, + (registry, specConfig, schemaName) -> + SszListSchema.create( + new HistoricalSummarySchema(), specConfig.getHistoricalRootsLimit())) + .build(); + } + + private static SchemaProvider createSignedBlsToExecutionChangeSchemaProvider() { + return providerBuilder(SIGNED_BLS_TO_EXECUTION_CHANGE_SCHEMA) + .withCreator( + CAPELLA, + (registry, specConfig, schemaName) -> new SignedBlsToExecutionChangeSchema(registry)) + .build(); + } + + private static SchemaProvider createBlsToExecutionChangeSchemaProvider() { + return providerBuilder(BLS_TO_EXECUTION_CHANGE_SCHEMA) + .withCreator( + CAPELLA, (registry, specConfig, schemaName) -> new BlsToExecutionChangeSchema()) + .build(); + } + + private static SchemaProvider createWithdrawalSchemaProvider() { + return providerBuilder(WITHDRAWAL_SCHEMA) + .withCreator(CAPELLA, (registry, specConfig, schemaName) -> new WithdrawalSchema()) + .build(); + } + + private static SchemaProvider createAttnetsENRFieldSchemaProvider() { + return providerBuilder(ATTNETS_ENR_FIELD_SCHEMA) + .withCreator( + PHASE0, + (registry, specConfig, schemaName) -> + SszBitvectorSchema.create(specConfig.getAttestationSubnetCount())) + .build(); + } + + private static SchemaProvider createSyncnetsENRFieldSchemaProvider() { + return providerBuilder(SYNCNETS_ENR_FIELD_SCHEMA) + .withCreator( + PHASE0, + (registry, specConfig, schemaName) -> + SszBitvectorSchema.create(NetworkConstants.SYNC_COMMITTEE_SUBNET_COUNT)) + .build(); + } + + private static SchemaProvider createBeaconBlocksByRootRequestMessageSchemaProvider() { + return providerBuilder(BEACON_BLOCKS_BY_ROOT_REQUEST_MESSAGE_SCHEMA) + .withCreator( + PHASE0, + (registry, specConfig, schemaName) -> + new BeaconBlocksByRootRequestMessageSchema(specConfig)) + .build(); + } + + private static SchemaProvider createHistoricalBatchSchemaProvider() { + return providerBuilder(HISTORICAL_BATCH_SCHEMA) + .withCreator( + PHASE0, + (registry, specConfig, schemaName) -> + new HistoricalBatchSchema(specConfig.getSlotsPerHistoricalRoot())) + .build(); + } + + private static SchemaProvider createAttesterSlashingSchemaProvider() { + return providerBuilder(ATTESTER_SLASHING_SCHEMA) + .withCreator( + PHASE0, + (registry, specConfig, schemaName) -> new AttesterSlashingSchema(schemaName, registry)) + .withCreator( + ELECTRA, + (registry, specConfig, schemaName) -> new AttesterSlashingSchema(schemaName, registry)) + .build(); + } + + private static SchemaProvider createIndexedAttestationSchemaProvider() { + return providerBuilder(INDEXED_ATTESTATION_SCHEMA) + .withCreator( + PHASE0, + (registry, specConfig, schemaName) -> + new IndexedAttestationSchema( + schemaName, getMaxValidatorsPerAttestationPhase0(specConfig))) + .withCreator( + ELECTRA, + (registry, specConfig, schemaName) -> + new IndexedAttestationSchema( + schemaName, getMaxValidatorsPerAttestationElectra(specConfig))) + .build(); + } + + private static SchemaProvider createAttestationSchemaProvider() { + return providerBuilder(ATTESTATION_SCHEMA) + .withCreator( + PHASE0, + (registry, specConfig, schemaName) -> + new AttestationPhase0Schema(getMaxValidatorsPerAttestationPhase0(specConfig)) + .castTypeToAttestationSchema()) + .withCreator( + ELECTRA, + (registry, specConfig, schemaName) -> + new AttestationElectraSchema( + getMaxValidatorsPerAttestationElectra(specConfig), + specConfig.getMaxCommitteesPerSlot()) + .castTypeToAttestationSchema()) + .build(); + } + + private static SchemaProvider createAggregateAndProofSchemaProvider() { + return providerBuilder(AGGREGATE_AND_PROOF_SCHEMA) + .withCreator( + PHASE0, + (registry, specConfig, schemaName) -> new AggregateAndProofSchema(schemaName, registry)) + .withCreator( + ELECTRA, + (registry, specConfig, schemaName) -> new AggregateAndProofSchema(schemaName, registry)) + .build(); + } + + private static SchemaProvider createSignedAggregateAndProofSchemaProvider() { + return providerBuilder(SIGNED_AGGREGATE_AND_PROOF_SCHEMA) + .withCreator( + PHASE0, + (registry, specConfig, schemaName) -> + new SignedAggregateAndProofSchema(schemaName, registry)) + .withCreator( + ELECTRA, + (registry, specConfig, schemaName) -> + new SignedAggregateAndProofSchema(schemaName, registry)) + .build(); + } + + private static long getMaxValidatorsPerAttestationPhase0(final SpecConfig specConfig) { + return specConfig.getMaxValidatorsPerCommittee(); + } + + private static long getMaxValidatorsPerAttestationElectra(final SpecConfig specConfig) { + return (long) specConfig.getMaxValidatorsPerCommittee() * specConfig.getMaxCommitteesPerSlot(); + } + + public SchemaRegistryBuilder() { + this.cache = SchemaCache.createDefault(); + } + + @VisibleForTesting + SchemaRegistryBuilder(final SchemaCache cache) { + this.cache = cache; + } + + SchemaRegistryBuilder addProvider(final SchemaProvider provider) { + if (!providers.add(provider)) { + throw new IllegalArgumentException( + "The provider " + provider.getClass().getSimpleName() + " has been already added"); + } + if (!schemaIds.add(provider.getSchemaId())) { + throw new IllegalStateException( + "A previously added provider was already providing the schema for " + + provider.getSchemaId()); + } + return this; + } + + @SuppressWarnings("EnumOrdinal") + public synchronized SchemaRegistry build( + final SpecMilestone milestone, final SpecConfig specConfig) { + + if (lastBuiltSchemaRegistryMilestone == null) { + // we recursively build all previous milestones + milestone + .getPreviousMilestoneIfExists() + .ifPresent(previousMilestone -> build(previousMilestone, specConfig)); + } else { + checkArgument( + lastBuiltSchemaRegistryMilestone.ordinal() == milestone.ordinal() - 1, + "Build must follow the milestone ordering. Last built milestone: %s, requested milestone: %s", + lastBuiltSchemaRegistryMilestone, + milestone); + } + + lastBuiltSchemaRegistryMilestone = milestone; + + final SchemaRegistry registry = new SchemaRegistry(milestone, specConfig, cache); + + for (final SchemaProvider provider : providers) { + if (provider.getSupportedMilestones().contains(milestone)) { + registry.registerProvider(provider); + } + } + + registry.primeRegistry(); + + return registry; + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/registry/SchemaTypes.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/registry/SchemaTypes.java new file mode 100644 index 00000000000..4a8356d373a --- /dev/null +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/schemas/registry/SchemaTypes.java @@ -0,0 +1,233 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.schemas.registry; + +import com.google.common.annotations.VisibleForTesting; +import com.google.common.base.CaseFormat; +import com.google.common.base.Converter; +import com.google.common.base.MoreObjects; +import java.util.Locale; +import tech.pegasys.teku.infrastructure.ssz.SszList; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; +import tech.pegasys.teku.infrastructure.ssz.schema.SszListSchema; +import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszBitvectorSchema; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.Blob; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobKzgCommitmentsSchema; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSchema; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecarSchema; +import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlockSchema; +import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockSchema; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodySchema; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.bellatrix.BlindedBeaconBlockBodyBellatrix; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.bellatrix.BlindedBeaconBlockBodySchemaBellatrix; +import tech.pegasys.teku.spec.datastructures.blocks.versions.deneb.BlockContentsSchema; +import tech.pegasys.teku.spec.datastructures.blocks.versions.deneb.SignedBlockContentsSchema; +import tech.pegasys.teku.spec.datastructures.builder.BlobsBundleSchema; +import tech.pegasys.teku.spec.datastructures.builder.BuilderBid; +import tech.pegasys.teku.spec.datastructures.builder.BuilderBidSchema; +import tech.pegasys.teku.spec.datastructures.builder.ExecutionPayloadAndBlobsBundleSchema; +import tech.pegasys.teku.spec.datastructures.builder.SignedBuilderBidSchema; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeaderSchema; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.capella.WithdrawalSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequestSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequestSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequestSchema; +import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.BeaconBlocksByRootRequestMessage.BeaconBlocksByRootRequestMessageSchema; +import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.BlobSidecarsByRootRequestMessageSchema; +import tech.pegasys.teku.spec.datastructures.operations.AggregateAndProof.AggregateAndProofSchema; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; +import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashingSchema; +import tech.pegasys.teku.spec.datastructures.operations.BlsToExecutionChangeSchema; +import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestationSchema; +import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof.SignedAggregateAndProofSchema; +import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChangeSchema; +import tech.pegasys.teku.spec.datastructures.state.HistoricalBatch.HistoricalBatchSchema; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconStateSchema; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.MutableBeaconState; +import tech.pegasys.teku.spec.datastructures.state.versions.capella.HistoricalSummary; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingConsolidation; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingDeposit; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingPartialWithdrawal; + +public class SchemaTypes { + // PHASE0 + public static final SchemaId> ATTNETS_ENR_FIELD_SCHEMA = + create("ATTNETS_ENR_FIELD_SCHEMA"); + public static final SchemaId> SYNCNETS_ENR_FIELD_SCHEMA = + create("SYNCNETS_ENR_FIELD_SCHEMA"); + public static final SchemaId HISTORICAL_BATCH_SCHEMA = + create("HISTORICAL_BATCH_SCHEMA"); + public static final SchemaId + BEACON_BLOCKS_BY_ROOT_REQUEST_MESSAGE_SCHEMA = + create("BEACON_BLOCKS_BY_ROOT_REQUEST_MESSAGE_SCHEMA"); + public static final SchemaId ATTESTER_SLASHING_SCHEMA = + create("ATTESTER_SLASHING_SCHEMA"); + public static final SchemaId INDEXED_ATTESTATION_SCHEMA = + create("INDEXED_ATTESTATION_SCHEMA"); + + public static final SchemaId> ATTESTATION_SCHEMA = + create("ATTESTATION_SCHEMA"); + + public static final SchemaId AGGREGATE_AND_PROOF_SCHEMA = + create("AGGREGATE_AND_PROOF_SCHEMA"); + public static final SchemaId SIGNED_AGGREGATE_AND_PROOF_SCHEMA = + create("SIGNED_AGGREGATE_AND_PROOF_SCHEMA"); + + public static final SchemaId> + BEACON_BLOCK_BODY_SCHEMA = create("BEACON_BLOCK_BODY_SCHEMA"); + public static final SchemaId BEACON_BLOCK_SCHEMA = + create("BEACON_BLOCK_SCHEMA"); + public static final SchemaId SIGNED_BEACON_BLOCK_SCHEMA = + create("SIGNED_BEACON_BLOCK_SCHEMA"); + + public static final SchemaId< + BeaconStateSchema> + BEACON_STATE_SCHEMA = create("BEACON_STATE_SCHEMA"); + + // Altair + + // Bellatrix + public static final SchemaId> + EXECUTION_PAYLOAD_SCHEMA = create("EXECUTION_PAYLOAD_SCHEMA"); + public static final SchemaId> + EXECUTION_PAYLOAD_HEADER_SCHEMA = create("EXECUTION_PAYLOAD_HEADER_SCHEMA"); + + public static final SchemaId BLINDED_BEACON_BLOCK_SCHEMA = + create("BLINDED_BEACON_BLOCK_SCHEMA"); + public static final SchemaId< + BlindedBeaconBlockBodySchemaBellatrix> + BLINDED_BEACON_BLOCK_BODY_SCHEMA = create("BLINDED_BEACON_BLOCK_BODY_SCHEMA"); + public static final SchemaId SIGNED_BLINDED_BEACON_BLOCK_SCHEMA = + create("SIGNED_BLINDED_BEACON_BLOCK_SCHEMA"); + + public static final SchemaId> BUILDER_BID_SCHEMA = + create("BUILDER_BID_SCHEMA"); + public static final SchemaId SIGNED_BUILDER_BID_SCHEMA = + create("SIGNED_BUILDER_BID_SCHEMA"); + + // Capella + public static final SchemaId WITHDRAWAL_SCHEMA = create("WITHDRAWAL_SCHEMA"); + public static final SchemaId BLS_TO_EXECUTION_CHANGE_SCHEMA = + create("BLS_TO_EXECUTION_CHANGE_SCHEMA"); + public static final SchemaId + SIGNED_BLS_TO_EXECUTION_CHANGE_SCHEMA = create("SIGNED_BLS_TO_EXECUTION_CHANGE_SCHEMA"); + public static final SchemaId> HISTORICAL_SUMMARIES_SCHEMA = + create("HISTORICAL_SUMMARIES_SCHEMA"); + + // Deneb + public static final SchemaId BLOB_KZG_COMMITMENTS_SCHEMA = + create("BLOB_KZG_COMMITMENTS_SCHEMA"); + public static final SchemaId BLOB_SCHEMA = create("BLOB_SCHEMA"); + public static final SchemaId>> BLOBS_IN_BLOCK_SCHEMA = + create("BLOBS_IN_BLOCK_SCHEMA"); + public static final SchemaId BLOB_SIDECAR_SCHEMA = + create("BLOB_SIDECAR_SCHEMA"); + public static final SchemaId + BLOB_SIDECARS_BY_ROOT_REQUEST_MESSAGE_SCHEMA = + create("BLOB_SIDECARS_BY_ROOT_REQUEST_MESSAGE_SCHEMA"); + public static final SchemaId BLOCK_CONTENTS_SCHEMA = + create("BLOCK_CONTENTS_SCHEMA"); + public static final SchemaId SIGNED_BLOCK_CONTENTS_SCHEMA = + create("SIGNED_BLOCK_CONTENTS_SCHEMA"); + public static final SchemaId BLOBS_BUNDLE_SCHEMA = + create("BLOBS_BUNDLE_SCHEMA"); + + // Electra + public static final SchemaId EXECUTION_REQUESTS_SCHEMA = + create("EXECUTION_REQUESTS_SCHEMA"); + public static final SchemaId> + PENDING_PARTIAL_WITHDRAWALS_SCHEMA = create("PENDING_PARTIAL_WITHDRAWALS_SCHEMA"); + public static final SchemaId> + PENDING_CONSOLIDATIONS_SCHEMA = create("PENDING_CONSOLIDATIONS_SCHEMA"); + public static final SchemaId> PENDING_DEPOSITS_SCHEMA = + create("PENDING_DEPOSITS_SCHEMA"); + public static final SchemaId + EXECUTION_PAYLOAD_AND_BLOBS_BUNDLE_SCHEMA = + create("EXECUTION_PAYLOAD_AND_BLOBS_BUNDLE_SCHEMA"); + public static final SchemaId DEPOSIT_REQUEST_SCHEMA = + create("DEPOSIT_REQUEST_SCHEMA"); + public static final SchemaId WITHDRAWAL_REQUEST_SCHEMA = + create("WITHDRAWAL_REQUEST_SCHEMA"); + public static final SchemaId CONSOLIDATION_REQUEST_SCHEMA = + create("CONSOLIDATION_REQUEST_SCHEMA"); + + private SchemaTypes() { + // Prevent instantiation + } + + @VisibleForTesting + static SchemaId create(final String name) { + return new SchemaId<>(name); + } + + public static class SchemaId { + private static final Converter UPPER_UNDERSCORE_TO_UPPER_CAMEL = + CaseFormat.UPPER_UNDERSCORE.converterTo(CaseFormat.UPPER_CAMEL); + + public static String upperSnakeCaseToUpperCamel(final String camelCase) { + return UPPER_UNDERSCORE_TO_UPPER_CAMEL.convert(camelCase); + } + + private static String capitalizeMilestone(final SpecMilestone milestone) { + return milestone.name().charAt(0) + milestone.name().substring(1).toLowerCase(Locale.ROOT); + } + + private final String name; + + private SchemaId(final String name) { + this.name = name; + } + + public String getName() { + return name; + } + + public String getSchemaName(final SpecMilestone milestone) { + return getSchemaName() + capitalizeMilestone(milestone); + } + + public String getSchemaName() { + return upperSnakeCaseToUpperCamel(name.replace("_SCHEMA", "")); + } + + @Override + public int hashCode() { + return name.hashCode(); + } + + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o instanceof SchemaId other) { + return name.equals(other.name); + } + return false; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(this).add("name", name).toString(); + } + } +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/signatures/DeletableSigner.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/signatures/DeletableSigner.java index d37a75a8382..30bc8d78f54 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/signatures/DeletableSigner.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/signatures/DeletableSigner.java @@ -115,7 +115,8 @@ public Optional getSigningServiceUrl() { return delegate.getSigningServiceUrl(); } - private SafeFuture sign(ExceptionThrowingFutureSupplier supplier) { + private SafeFuture sign( + final ExceptionThrowingFutureSupplier supplier) { readLock.lock(); final SafeFuture future = deleted ? SafeFuture.failedFuture(new SignerNotActiveException()) : SafeFuture.of(supplier); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/signatures/LocalSlashingProtectionRecord.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/signatures/LocalSlashingProtectionRecord.java index ddfa0131c9e..ab373978fb5 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/signatures/LocalSlashingProtectionRecord.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/signatures/LocalSlashingProtectionRecord.java @@ -68,12 +68,13 @@ boolean writeSigningRecord( return true; } - Optional maySignBlock(Bytes32 genesisValidatorsRoot, UInt64 slot) { + Optional maySignBlock( + final Bytes32 genesisValidatorsRoot, final UInt64 slot) { return signingRecord.maySignBlock(genesisValidatorsRoot, slot); } Optional maySignAttestation( - Bytes32 genesisValidatorsRoot, UInt64 sourceEpoch, UInt64 targetEpoch) { + final Bytes32 genesisValidatorsRoot, final UInt64 sourceEpoch, final UInt64 targetEpoch) { return signingRecord.maySignAttestation(genesisValidatorsRoot, sourceEpoch, targetEpoch); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/signatures/LocalSlashingProtector.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/signatures/LocalSlashingProtector.java index 6e32511fff4..86bf8404bf6 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/signatures/LocalSlashingProtector.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/signatures/LocalSlashingProtector.java @@ -94,7 +94,7 @@ private ValidatorSigningRecord loadOrCreateSigningRecord( return record.orElseGet( () -> { final ValidatorSigningRecord newRecord = - new ValidatorSigningRecord(genesisValidatorsRoot); + ValidatorSigningRecord.emptySigningRecord(genesisValidatorsRoot); signingRecords.put(validator, newRecord); return newRecord; }); diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/signatures/LocalSlashingProtectorConcurrentAccess.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/signatures/LocalSlashingProtectorConcurrentAccess.java index f6c2d9e646c..fb608900725 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/signatures/LocalSlashingProtectorConcurrentAccess.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/signatures/LocalSlashingProtectorConcurrentAccess.java @@ -112,7 +112,7 @@ private LocalSlashingProtectionRecord addRecord( getValidatorSigningRecordFromFile(publicKey); return new LocalSlashingProtectionRecord( slashingProtectedPath, - maybeRecord.orElse(new ValidatorSigningRecord(genesisValidatorsRoot)), + maybeRecord.orElse(ValidatorSigningRecord.emptySigningRecord(genesisValidatorsRoot)), new ReentrantLock()); } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/signatures/RejectingSlashingProtector.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/signatures/RejectingSlashingProtector.java index 42be295319b..0cc4ca285c3 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/signatures/RejectingSlashingProtector.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/signatures/RejectingSlashingProtector.java @@ -37,7 +37,7 @@ public SafeFuture maySignAttestation( } @Override - public Optional getSigningRecord(BLSPublicKey validator) { + public Optional getSigningRecord(final BLSPublicKey validator) { return Optional.empty(); } } diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/signatures/SigningRootUtil.java b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/signatures/SigningRootUtil.java index 2f31b262822..4923887d55f 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/signatures/SigningRootUtil.java +++ b/ethereum/spec/src/main/java/tech/pegasys/teku/spec/signatures/SigningRootUtil.java @@ -53,7 +53,7 @@ public Bytes signingRootForSignBlockHeader( blockHeader, getDomainForSignBlock(blockHeader.getSlot(), forkInfo)); } - private Bytes32 getDomainForSignBlock(UInt64 slot, ForkInfo forkInfo) { + private Bytes32 getDomainForSignBlock(final UInt64 slot, final ForkInfo forkInfo) { return spec.getDomain( Domain.BEACON_PROPOSER, spec.computeEpochAtSlot(slot), diff --git a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/chiado.yaml b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/chiado.yaml index 930d8747c0c..fda0da2f5b4 100644 --- a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/chiado.yaml +++ b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/chiado.yaml @@ -133,4 +133,11 @@ MAX_REQUEST_BLOB_SIDECARS: 768 # `2**14` (= 16384 epochs, ~15 days) MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS: 16384 # `6` -BLOB_SIDECAR_SUBNET_COUNT: 6 \ No newline at end of file +BLOB_SIDECAR_SUBNET_COUNT: 6 + +# Electra +MAX_BLOBS_PER_BLOCK_ELECTRA: 6 +TARGET_BLOBS_PER_BLOCK_ELECTRA: 3 +# MAX_REQUEST_BLOCKS_DENEB * MAX_BLOBS_PER_BLOCK_ELECTRA +MAX_REQUEST_BLOB_SIDECARS_ELECTRA: 768 +BLOB_SIDECAR_SUBNET_COUNT_ELECTRA: 6 \ No newline at end of file diff --git a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/prater.yaml b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/ephemery.yaml similarity index 65% rename from ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/prater.yaml rename to ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/ephemery.yaml index 4deec5980fd..8df5977f605 100644 --- a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/prater.yaml +++ b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/ephemery.yaml @@ -1,28 +1,15 @@ # Extends the mainnet preset -PRESET_BASE: 'mainnet' +PRESET_BASE: mainnet +CONFIG_NAME: testnet # needs to exist because of Prysm. Otherwise it conflicts with mainnet genesis -# For backwards compatibility in the config/spec API -CONFIG_NAME: "prater" - -# Transition -# --------------------------------------------------------------- -# Expected August 10, 2022 -TERMINAL_TOTAL_DIFFICULTY: 10790000 -# By default, don't use these params -TERMINAL_BLOCK_HASH: 0x0000000000000000000000000000000000000000000000000000000000000000 -TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH: 18446744073709551615 - -# Prater config # Genesis # --------------------------------------------------------------- # `2**14` (= 16,384) -MIN_GENESIS_ACTIVE_VALIDATOR_COUNT: 16384 -# Mar-01-2021 08:53:32 AM +UTC -MIN_GENESIS_TIME: 1614588812 -# Prater area code (Vienna) -GENESIS_FORK_VERSION: 0x00001020 -# Customized for Prater: 1919188 seconds (Mar-23-2021 02:00:00 PM +UTC) -GENESIS_DELAY: 1919188 +MIN_GENESIS_ACTIVE_VALIDATOR_COUNT: 64 +# 2024-Jul-04 07:00:00 PM UTC +MIN_GENESIS_TIME: 1720119600 +GENESIS_FORK_VERSION: 0x1000101b +GENESIS_DELAY: 600 # Forking @@ -32,32 +19,39 @@ GENESIS_DELAY: 1919188 # - Temporarily set to max uint64 value: 2**64 - 1 # Altair -ALTAIR_FORK_VERSION: 0x01001020 -ALTAIR_FORK_EPOCH: 36660 -# Bellatrix -BELLATRIX_FORK_VERSION: 0x02001020 -BELLATRIX_FORK_EPOCH: 112260 +ALTAIR_FORK_VERSION: 0x2000101b +ALTAIR_FORK_EPOCH: 0 +# Merge +BELLATRIX_FORK_VERSION: 0x3000101b +BELLATRIX_FORK_EPOCH: 0 +TERMINAL_TOTAL_DIFFICULTY: 0 +TERMINAL_BLOCK_HASH: 0x0000000000000000000000000000000000000000000000000000000000000000 +TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH: 18446744073709551615 + # Capella -CAPELLA_FORK_VERSION: 0x03001020 -CAPELLA_FORK_EPOCH: 162304 -# Deneb -DENEB_FORK_VERSION: 0x04001020 -DENEB_FORK_EPOCH: 231680 +CAPELLA_FORK_VERSION: 0x4000101b +CAPELLA_FORK_EPOCH: 0 +# DENEB +DENEB_FORK_VERSION: 0x5000101b +DENEB_FORK_EPOCH: 0 + +# Electra +ELECTRA_FORK_VERSION: 0x6000101b +ELECTRA_FORK_EPOCH: 18446744073709551615 # Time parameters # --------------------------------------------------------------- # 12 seconds SECONDS_PER_SLOT: 12 # 14 (estimate from Eth1 mainnet) -SECONDS_PER_ETH1_BLOCK: 14 +SECONDS_PER_ETH1_BLOCK: 12 # 2**8 (= 256) epochs ~27 hours MIN_VALIDATOR_WITHDRAWABILITY_DELAY: 256 # 2**8 (= 256) epochs ~27 hours SHARD_COMMITTEE_PERIOD: 256 # 2**11 (= 2,048) Eth1 blocks ~8 hours -ETH1_FOLLOW_DISTANCE: 2048 - +ETH1_FOLLOW_DISTANCE: 12 # Validator cycle # --------------------------------------------------------------- @@ -66,7 +60,7 @@ INACTIVITY_SCORE_BIAS: 4 # 2**4 (= 16) INACTIVITY_SCORE_RECOVERY_RATE: 16 # 2**4 * 10**9 (= 16,000,000,000) Gwei -EJECTION_BALANCE: 16000000000 +EJECTION_BALANCE: 30000000000 # 2**2 (= 4) MIN_PER_EPOCH_CHURN_LIMIT: 4 # 2**16 (= 65,536) @@ -74,7 +68,6 @@ CHURN_LIMIT_QUOTIENT: 65536 # [New in Deneb:EIP7514] 2**3 (= 8) MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT: 8 - # Fork choice # --------------------------------------------------------------- # 40% @@ -88,11 +81,9 @@ REORG_MAX_EPOCHS_SINCE_FINALIZATION: 2 # Deposit contract # --------------------------------------------------------------- -# Ethereum Goerli testnet -DEPOSIT_CHAIN_ID: 5 -DEPOSIT_NETWORK_ID: 5 -# Prater test deposit contract on Goerli Testnet -DEPOSIT_CONTRACT_ADDRESS: 0xff50ed3d0ec03aC01D4C79aAd74928BFF48a7b2b +DEPOSIT_CHAIN_ID: 39438135 +DEPOSIT_NETWORK_ID: 39438135 +DEPOSIT_CONTRACT_ADDRESS: 0x4242424242424242424242424242424242424242 # Networking # --------------------------------------------------------------- @@ -102,7 +93,7 @@ GOSSIP_MAX_SIZE: 10485760 MAX_REQUEST_BLOCKS: 1024 # `2**8` (= 256) EPOCHS_PER_SUBNET_SUBSCRIPTION: 256 -## `MIN_VALIDATOR_WITHDRAWABILITY_DELAY + CHURN_LIMIT_QUOTIENT // 2` (= 33024, ~5 months) +# `MIN_VALIDATOR_WITHDRAWABILITY_DELAY + CHURN_LIMIT_QUOTIENT // 2` (= 33024, ~5 months) MIN_EPOCHS_FOR_BLOCK_REQUESTS: 33024 # `10 * 2**20` (=10485760, 10 MiB) MAX_CHUNK_SIZE: 10485760 @@ -131,4 +122,15 @@ MAX_REQUEST_BLOB_SIDECARS: 768 # `2**12` (= 4096 epochs, ~18 days) MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS: 4096 # `6` -BLOB_SIDECAR_SUBNET_COUNT: 6 \ No newline at end of file +BLOB_SIDECAR_SUBNET_COUNT: 6 + +# Electra +MAX_BLOBS_PER_BLOCK_ELECTRA: 6 +TARGET_BLOBS_PER_BLOCK_ELECTRA: 3 +# MAX_REQUEST_BLOCKS_DENEB * MAX_BLOBS_PER_BLOCK_ELECTRA +MAX_REQUEST_BLOB_SIDECARS_ELECTRA: 768 +BLOB_SIDECAR_SUBNET_COUNT_ELECTRA: 6 + +# [New in Electra:EIP7251] +MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA: 128000000000 # 2**7 * 10**9 (= 128,000,000,000) +MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT: 256000000000 # 2**8 * 10**9 (= 256,000,000,000) \ No newline at end of file diff --git a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/gnosis.yaml b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/gnosis.yaml index 96c573778cf..42b99807212 100644 --- a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/gnosis.yaml +++ b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/gnosis.yaml @@ -132,4 +132,11 @@ MAX_REQUEST_BLOB_SIDECARS: 768 # `2**14` (= 16384 epochs, ~15 days) MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS: 16384 # `6` -BLOB_SIDECAR_SUBNET_COUNT: 6 \ No newline at end of file +BLOB_SIDECAR_SUBNET_COUNT: 6 + +# Electra +MAX_BLOBS_PER_BLOCK_ELECTRA: 6 +TARGET_BLOBS_PER_BLOCK_ELECTRA: 3 +# MAX_REQUEST_BLOCKS_DENEB * MAX_BLOBS_PER_BLOCK_ELECTRA +MAX_REQUEST_BLOB_SIDECARS_ELECTRA: 768 +BLOB_SIDECAR_SUBNET_COUNT_ELECTRA: 6 \ No newline at end of file diff --git a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/holesky.yaml b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/holesky.yaml index eb7e843eddd..58f913a4f54 100644 --- a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/holesky.yaml +++ b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/holesky.yaml @@ -37,9 +37,9 @@ CAPELLA_FORK_EPOCH: 256 DENEB_FORK_VERSION: 0x05017000 DENEB_FORK_EPOCH: 29696 -## Electra -#ELECTRA_FORK_VERSION: 0x06017000 -#ELECTRA_FORK_EPOCH: 18446744073709551615 +# Electra +ELECTRA_FORK_VERSION: 0x06017000 +ELECTRA_FORK_EPOCH: 18446744073709551615 # Time parameters # --------------------------------------------------------------- @@ -126,4 +126,11 @@ MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS: 4096 # `6` BLOB_SIDECAR_SUBNET_COUNT: 6 # `uint64(6)` -MAX_BLOBS_PER_BLOCK: 6 \ No newline at end of file +MAX_BLOBS_PER_BLOCK: 6 + +# Electra +MAX_BLOBS_PER_BLOCK_ELECTRA: 6 +TARGET_BLOBS_PER_BLOCK_ELECTRA: 3 +# MAX_REQUEST_BLOCKS_DENEB * MAX_BLOBS_PER_BLOCK_ELECTRA +MAX_REQUEST_BLOB_SIDECARS_ELECTRA: 768 +BLOB_SIDECAR_SUBNET_COUNT_ELECTRA: 6 \ No newline at end of file diff --git a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/less-swift.yaml b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/less-swift.yaml index 9bd617c0a80..63cb669375b 100644 --- a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/less-swift.yaml +++ b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/less-swift.yaml @@ -35,9 +35,9 @@ CAPELLA_FORK_EPOCH: 18446744073709551615 # Deneb DENEB_FORK_VERSION: 0x04000001 DENEB_FORK_EPOCH: 18446744073709551615 -## Electra -#ELECTRA_FORK_VERSION: 0x05000001 -#ELECTRA_FORK_EPOCH: 18446744073709551615 +# Electra +ELECTRA_FORK_VERSION: 0x05000001 +ELECTRA_FORK_EPOCH: 18446744073709551615 # Transition # --------------------------------------------------------------- @@ -135,4 +135,11 @@ MAX_REQUEST_BLOB_SIDECARS: 768 # `2**12` (= 4096 epochs, ~18 days) MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS: 4096 # `6` -BLOB_SIDECAR_SUBNET_COUNT: 6 \ No newline at end of file +BLOB_SIDECAR_SUBNET_COUNT: 6 + +# Electra +MAX_BLOBS_PER_BLOCK_ELECTRA: 6 +TARGET_BLOBS_PER_BLOCK_ELECTRA: 3 +# MAX_REQUEST_BLOCKS_DENEB * MAX_BLOBS_PER_BLOCK_ELECTRA +MAX_REQUEST_BLOB_SIDECARS_ELECTRA: 768 +BLOB_SIDECAR_SUBNET_COUNT_ELECTRA: 6 \ No newline at end of file diff --git a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/lukso.yaml b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/lukso.yaml index e825952987d..578d711cccc 100644 --- a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/lukso.yaml +++ b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/lukso.yaml @@ -59,6 +59,11 @@ BELLATRIX_FORK_EPOCH: 0 CAPELLA_FORK_VERSION: 0x42000004 CAPELLA_FORK_EPOCH: 8100 +# Deneb +# Date and time (GMT): Wednesday, 20 November 2024 16:20:00 +DENEB_FORK_VERSION: 0x42000005 +DENEB_FORK_EPOCH: 123075 + # Fork choice # --------------------------------------------------------------- # 40% @@ -102,6 +107,8 @@ INACTIVITY_SCORE_RECOVERY_RATE: 16 MIN_PER_EPOCH_CHURN_LIMIT: 4 # 2**16 (= 65,536) CHURN_LIMIT_QUOTIENT: 65536 +# [New in Deneb:EIP7514] 2**3 (= 8) +MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT: 8 # Validator Stakes # --------------------------------------------------------------- @@ -137,4 +144,21 @@ SUBNETS_PER_NODE: 2 ATTESTATION_SUBNET_COUNT: 64 ATTESTATION_SUBNET_EXTRA_BITS: 0 # ceillog2(ATTESTATION_SUBNET_COUNT) + ATTESTATION_SUBNET_EXTRA_BITS -ATTESTATION_SUBNET_PREFIX_BITS: 6 \ No newline at end of file +ATTESTATION_SUBNET_PREFIX_BITS: 6 + +# Deneb +# `2**7` (=128) +MAX_REQUEST_BLOCKS_DENEB: 128 +# MAX_REQUEST_BLOCKS_DENEB * MAX_BLOBS_PER_BLOCK +MAX_REQUEST_BLOB_SIDECARS: 768 +# `2**12` (= 4096 epochs, ~18 days) +MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS: 4096 +# `6` +BLOB_SIDECAR_SUBNET_COUNT: 6 + +# Electra +MAX_BLOBS_PER_BLOCK_ELECTRA: 6 +TARGET_BLOBS_PER_BLOCK_ELECTRA: 3 +# MAX_REQUEST_BLOCKS_DENEB * MAX_BLOBS_PER_BLOCK_ELECTRA +MAX_REQUEST_BLOB_SIDECARS_ELECTRA: 768 +BLOB_SIDECAR_SUBNET_COUNT_ELECTRA: 6 diff --git a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/mainnet.yaml b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/mainnet.yaml index 145fc652717..406700473b6 100644 --- a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/mainnet.yaml +++ b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/mainnet.yaml @@ -50,11 +50,13 @@ CAPELLA_FORK_EPOCH: 194048 # April 12, 2023, 10:27:35pm UTC # Deneb DENEB_FORK_VERSION: 0x04000000 DENEB_FORK_EPOCH: 269568 # March 13, 2024, 01:55:35pm UTC -## Electra -#ELECTRA_FORK_VERSION: 0x05000000 -#ELECTRA_FORK_EPOCH: 18446744073709551615 +# Electra +ELECTRA_FORK_VERSION: 0x05000000 +ELECTRA_FORK_EPOCH: 18446744073709551615 +# Fulu +FULU_FORK_VERSION: 0x06000000 +FULU_FORK_EPOCH: 18446744073709551615 # EIP7594 -EIP7594_FORK_VERSION: 0x06000000 EIP7594_FORK_EPOCH: 18446744073709551615 # Time parameters @@ -86,7 +88,6 @@ CHURN_LIMIT_QUOTIENT: 65536 # [New in Deneb:EIP7514] 2**3 (= 8) MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT: 8 - # Fork choice # --------------------------------------------------------------- # 40% @@ -98,6 +99,7 @@ REORG_PARENT_WEIGHT_THRESHOLD: 160 # `2` epochs REORG_MAX_EPOCHS_SINCE_FINALIZATION: 2 + # Deposit contract # --------------------------------------------------------------- # Ethereum PoW Mainnet @@ -114,7 +116,7 @@ GOSSIP_MAX_SIZE: 10485760 MAX_REQUEST_BLOCKS: 1024 # `2**8` (= 256) EPOCHS_PER_SUBNET_SUBSCRIPTION: 256 -## `MIN_VALIDATOR_WITHDRAWABILITY_DELAY + CHURN_LIMIT_QUOTIENT // 2` (= 33024, ~5 months) +# `MIN_VALIDATOR_WITHDRAWABILITY_DELAY + CHURN_LIMIT_QUOTIENT // 2` (= 33024, ~5 months) MIN_EPOCHS_FOR_BLOCK_REQUESTS: 33024 # `10 * 2**20` (=10485760, 10 MiB) MAX_CHUNK_SIZE: 10485760 @@ -145,6 +147,17 @@ MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS: 4096 # `6` BLOB_SIDECAR_SUBNET_COUNT: 6 +# Electra +MAX_BLOBS_PER_BLOCK_ELECTRA: 6 +TARGET_BLOBS_PER_BLOCK_ELECTRA: 3 +# MAX_REQUEST_BLOCKS_DENEB * MAX_BLOBS_PER_BLOCK_ELECTRA +MAX_REQUEST_BLOB_SIDECARS_ELECTRA: 768 +BLOB_SIDECAR_SUBNET_COUNT_ELECTRA: 6 + +# [New in Electra:EIP7251] +MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA: 128000000000 # 2**7 * 10**9 (= 128,000,000,000) +MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT: 256000000000 # 2**8 * 10**9 (= 256,000,000,000) + # [New in EIP7594] NUMBER_OF_COLUMNS: 128 DATA_COLUMN_SIDECAR_SUBNET_COUNT: 128 diff --git a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/minimal.yaml b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/minimal.yaml index 37301ae77b1..73c4b55fd46 100644 --- a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/minimal.yaml +++ b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/minimal.yaml @@ -49,14 +49,15 @@ CAPELLA_FORK_EPOCH: 18446744073709551615 # Deneb DENEB_FORK_VERSION: 0x04000001 DENEB_FORK_EPOCH: 18446744073709551615 -## Electra -#ELECTRA_FORK_VERSION: 0x05000001 -#ELECTRA_FORK_EPOCH: 18446744073709551615 +# Electra +ELECTRA_FORK_VERSION: 0x05000001 +ELECTRA_FORK_EPOCH: 18446744073709551615 +# Fulu +FULU_FORK_VERSION: 0x06000001 +FULU_FORK_EPOCH: 18446744073709551615 # EIP7594 -EIP7594_FORK_VERSION: 0x06000001 EIP7594_FORK_EPOCH: 18446744073709551615 - # Time parameters # --------------------------------------------------------------- # [customized] Faster for testing purposes @@ -98,6 +99,7 @@ REORG_PARENT_WEIGHT_THRESHOLD: 160 # `2` epochs REORG_MAX_EPOCHS_SINCE_FINALIZATION: 2 + # Deposit contract # --------------------------------------------------------------- # Ethereum Goerli testnet @@ -115,7 +117,7 @@ GOSSIP_MAX_SIZE: 10485760 MAX_REQUEST_BLOCKS: 1024 # `2**8` (= 256) EPOCHS_PER_SUBNET_SUBSCRIPTION: 256 -## [customized] `MIN_VALIDATOR_WITHDRAWABILITY_DELAY + CHURN_LIMIT_QUOTIENT // 2` (= 272) +# [customized] `MIN_VALIDATOR_WITHDRAWABILITY_DELAY + CHURN_LIMIT_QUOTIENT // 2` (= 272) MIN_EPOCHS_FOR_BLOCK_REQUESTS: 272 # `10 * 2**20` (=10485760, 10 MiB) MAX_CHUNK_SIZE: 10485760 @@ -146,6 +148,17 @@ MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS: 4096 # `6` BLOB_SIDECAR_SUBNET_COUNT: 6 +# Electra +MAX_BLOBS_PER_BLOCK_ELECTRA: 6 +TARGET_BLOBS_PER_BLOCK_ELECTRA: 3 +# MAX_REQUEST_BLOCKS_DENEB * MAX_BLOBS_PER_BLOCK_ELECTRA +MAX_REQUEST_BLOB_SIDECARS_ELECTRA: 768 +BLOB_SIDECAR_SUBNET_COUNT_ELECTRA: 6 + +# [New in Electra:EIP7251] +MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA: 64000000000 # 2**6 * 10**9 (= 64,000,000,000) +MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT: 128000000000 # 2**7 * 10**9 (= 128,000,000,000) + # [New in EIP7594] NUMBER_OF_COLUMNS: 128 DATA_COLUMN_SIDECAR_SUBNET_COUNT: 128 diff --git a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/sepolia.yaml b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/sepolia.yaml index 06c2c072ce4..f4eac63a5b5 100644 --- a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/sepolia.yaml +++ b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/sepolia.yaml @@ -36,9 +36,9 @@ CAPELLA_FORK_EPOCH: 56832 DENEB_FORK_VERSION: 0x90000073 DENEB_FORK_EPOCH: 132608 -## Electra -#ELECTRA_FORK_VERSION: 0x90000074 -#ELECTRA_FORK_EPOCH: 18446744073709551615 +# Electra +ELECTRA_FORK_VERSION: 0x90000074 +ELECTRA_FORK_EPOCH: 18446744073709551615 # Time parameters # --------------------------------------------------------------- @@ -117,4 +117,11 @@ MAX_REQUEST_BLOB_SIDECARS: 768 # `2**12` (= 4096 epochs, ~18 days) MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS: 4096 # `6` -BLOB_SIDECAR_SUBNET_COUNT: 6 \ No newline at end of file +BLOB_SIDECAR_SUBNET_COUNT: 6 + +# Electra +MAX_BLOBS_PER_BLOCK_ELECTRA: 6 +TARGET_BLOBS_PER_BLOCK_ELECTRA: 3 +# MAX_REQUEST_BLOCKS_DENEB * MAX_BLOBS_PER_BLOCK_ELECTRA +MAX_REQUEST_BLOB_SIDECARS_ELECTRA: 768 +BLOB_SIDECAR_SUBNET_COUNT_ELECTRA: 6 \ No newline at end of file diff --git a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/swift.yaml b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/swift.yaml index 452bc9b0aa4..fdcab069c55 100644 --- a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/swift.yaml +++ b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/configs/swift.yaml @@ -43,14 +43,13 @@ CAPELLA_FORK_EPOCH: 18446744073709551615 # Deneb DENEB_FORK_VERSION: 0x04000001 DENEB_FORK_EPOCH: 18446744073709551615 -## Electra -#ELECTRA_FORK_VERSION: 0x05000001 -#ELECTRA_FORK_EPOCH: 18446744073709551615 +# Electra +ELECTRA_FORK_VERSION: 0x05000001 +ELECTRA_FORK_EPOCH: 18446744073709551615 # EIP7594 EIP7594_FORK_VERSION: 0x06000001 EIP7594_FORK_EPOCH: 18446744073709551615 - # Time parameters # --------------------------------------------------------------- # [customized] Faster for testing purposes @@ -141,9 +140,20 @@ MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS: 4096 # `6` BLOB_SIDECAR_SUBNET_COUNT: 6 +# Electra +MAX_BLOBS_PER_BLOCK_ELECTRA: 6 +TARGET_BLOBS_PER_BLOCK_ELECTRA: 3 +# MAX_REQUEST_BLOCKS_DENEB * MAX_BLOBS_PER_BLOCK_ELECTRA +MAX_REQUEST_BLOB_SIDECARS_ELECTRA: 768 +BLOB_SIDECAR_SUBNET_COUNT_ELECTRA: 6 + +# [New in Electra:EIP7251] +MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA: 64000000000 # 2**6 * 10**9 (= 64,000,000,000) +MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT: 128000000000 # 2**7 * 10**9 (= 128,000,000,000) + # [New in EIP7594] NUMBER_OF_COLUMNS: 128 DATA_COLUMN_SIDECAR_SUBNET_COUNT: 128 MAX_REQUEST_DATA_COLUMN_SIDECARS: 512 SAMPLES_PER_SLOT: 8 -CUSTODY_REQUIREMENT: 4 +CUSTODY_REQUIREMENT: 4 \ No newline at end of file diff --git a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/presets/mainnet/electra.yaml b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/presets/mainnet/electra.yaml new file mode 100644 index 00000000000..0b594ff3404 --- /dev/null +++ b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/presets/mainnet/electra.yaml @@ -0,0 +1,50 @@ +# Mainnet preset - Electra + +# Gwei values +# --------------------------------------------------------------- +# 2**5 * 10**9 (= 32,000,000,000) Gwei +MIN_ACTIVATION_BALANCE: 32000000000 +# 2**11 * 10**9 (= 2,048,000,000,000) Gwei +MAX_EFFECTIVE_BALANCE_ELECTRA: 2048000000000 + +# State list lengths +# --------------------------------------------------------------- +# `uint64(2**27)` (= 134,217,728) +PENDING_DEPOSITS_LIMIT: 134217728 +# `uint64(2**27)` (= 134,217,728) +PENDING_PARTIAL_WITHDRAWALS_LIMIT: 134217728 +# `uint64(2**18)` (= 262,144) +PENDING_CONSOLIDATIONS_LIMIT: 262144 + +# Reward and penalty quotients +# --------------------------------------------------------------- +# `uint64(2**12)` (= 4,096) +MIN_SLASHING_PENALTY_QUOTIENT_ELECTRA: 4096 +# `uint64(2**12)` (= 4,096) +WHISTLEBLOWER_REWARD_QUOTIENT_ELECTRA: 4096 + +# # Max operations per block +# --------------------------------------------------------------- +# `uint64(2**0)` (= 1) +MAX_ATTESTER_SLASHINGS_ELECTRA: 1 +# `uint64(2**3)` (= 8) +MAX_ATTESTATIONS_ELECTRA: 8 +# `uint64(2**0)` (= 1) +MAX_CONSOLIDATION_REQUESTS_PER_PAYLOAD: 1 + +# Execution +# --------------------------------------------------------------- +# 2**13 (= 8192) receipts +MAX_DEPOSIT_REQUESTS_PER_PAYLOAD: 8192 +# 2**4 (= 16) withdrawal requests +MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD: 16 + +# Withdrawals processing +# --------------------------------------------------------------- +# 2**3 ( = 8) pending withdrawals +MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP: 8 + +# Pending deposits processing +# --------------------------------------------------------------- +# 2**4 ( = 4) pending deposits +MAX_PENDING_DEPOSITS_PER_EPOCH: 16 \ No newline at end of file diff --git a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/presets/mainnet/fulu.yaml b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/presets/mainnet/fulu.yaml new file mode 100644 index 00000000000..ee25262107e --- /dev/null +++ b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/presets/mainnet/fulu.yaml @@ -0,0 +1 @@ +# Mainnet preset - Fulu diff --git a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/presets/minimal/electra.yaml b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/presets/minimal/electra.yaml new file mode 100644 index 00000000000..71adaa4aaa0 --- /dev/null +++ b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/presets/minimal/electra.yaml @@ -0,0 +1,50 @@ +# Minimal preset - Electra + +# Gwei values +# --------------------------------------------------------------- +# 2**5 * 10**9 (= 32,000,000,000) Gwei +MIN_ACTIVATION_BALANCE: 32000000000 +# 2**11 * 10**9 (= 2,048,000,000,000) Gwei +MAX_EFFECTIVE_BALANCE_ELECTRA: 2048000000000 + +# State list lengths +# --------------------------------------------------------------- +# `uint64(2**27)` (= 134,217,728) +PENDING_DEPOSITS_LIMIT: 134217728 +# [customized] `uint64(2**6)` (= 64) +PENDING_PARTIAL_WITHDRAWALS_LIMIT: 64 +# [customized] `uint64(2**6)` (= 64) +PENDING_CONSOLIDATIONS_LIMIT: 64 + +# Reward and penalty quotients +# --------------------------------------------------------------- +# `uint64(2**12)` (= 4,096) +MIN_SLASHING_PENALTY_QUOTIENT_ELECTRA: 4096 +# `uint64(2**12)` (= 4,096) +WHISTLEBLOWER_REWARD_QUOTIENT_ELECTRA: 4096 + +# # Max operations per block +# --------------------------------------------------------------- +# `uint64(2**0)` (= 1) +MAX_ATTESTER_SLASHINGS_ELECTRA: 1 +# `uint64(2**3)` (= 8) +MAX_ATTESTATIONS_ELECTRA: 8 +# `uint64(2**0)` (= 1) +MAX_CONSOLIDATION_REQUESTS_PER_PAYLOAD: 1 + +# Execution +# --------------------------------------------------------------- +# [customized] +MAX_DEPOSIT_REQUESTS_PER_PAYLOAD: 4 +# [customized] 2**1 (= 2) withdrawal requests +MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD: 2 + +# Withdrawals processing +# --------------------------------------------------------------- +# 2**1 ( = 2) pending withdrawals +MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP: 2 + +# Pending deposits processing +# --------------------------------------------------------------- +# 2**4 ( = 4) pending deposits +MAX_PENDING_DEPOSITS_PER_EPOCH: 16 \ No newline at end of file diff --git a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/presets/minimal/fulu.yaml b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/presets/minimal/fulu.yaml new file mode 100644 index 00000000000..62c5755f94a --- /dev/null +++ b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/presets/minimal/fulu.yaml @@ -0,0 +1 @@ +# Minimal preset - Fulu diff --git a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/presets/swift/electra.yaml b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/presets/swift/electra.yaml new file mode 100644 index 00000000000..71adaa4aaa0 --- /dev/null +++ b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/presets/swift/electra.yaml @@ -0,0 +1,50 @@ +# Minimal preset - Electra + +# Gwei values +# --------------------------------------------------------------- +# 2**5 * 10**9 (= 32,000,000,000) Gwei +MIN_ACTIVATION_BALANCE: 32000000000 +# 2**11 * 10**9 (= 2,048,000,000,000) Gwei +MAX_EFFECTIVE_BALANCE_ELECTRA: 2048000000000 + +# State list lengths +# --------------------------------------------------------------- +# `uint64(2**27)` (= 134,217,728) +PENDING_DEPOSITS_LIMIT: 134217728 +# [customized] `uint64(2**6)` (= 64) +PENDING_PARTIAL_WITHDRAWALS_LIMIT: 64 +# [customized] `uint64(2**6)` (= 64) +PENDING_CONSOLIDATIONS_LIMIT: 64 + +# Reward and penalty quotients +# --------------------------------------------------------------- +# `uint64(2**12)` (= 4,096) +MIN_SLASHING_PENALTY_QUOTIENT_ELECTRA: 4096 +# `uint64(2**12)` (= 4,096) +WHISTLEBLOWER_REWARD_QUOTIENT_ELECTRA: 4096 + +# # Max operations per block +# --------------------------------------------------------------- +# `uint64(2**0)` (= 1) +MAX_ATTESTER_SLASHINGS_ELECTRA: 1 +# `uint64(2**3)` (= 8) +MAX_ATTESTATIONS_ELECTRA: 8 +# `uint64(2**0)` (= 1) +MAX_CONSOLIDATION_REQUESTS_PER_PAYLOAD: 1 + +# Execution +# --------------------------------------------------------------- +# [customized] +MAX_DEPOSIT_REQUESTS_PER_PAYLOAD: 4 +# [customized] 2**1 (= 2) withdrawal requests +MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD: 2 + +# Withdrawals processing +# --------------------------------------------------------------- +# 2**1 ( = 2) pending withdrawals +MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP: 2 + +# Pending deposits processing +# --------------------------------------------------------------- +# 2**4 ( = 4) pending deposits +MAX_PENDING_DEPOSITS_PER_EPOCH: 16 \ No newline at end of file diff --git a/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/presets/swift/fulu.yaml b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/presets/swift/fulu.yaml new file mode 100644 index 00000000000..9c75a36740a --- /dev/null +++ b/ethereum/spec/src/main/resources/tech/pegasys/teku/spec/config/presets/swift/fulu.yaml @@ -0,0 +1 @@ +# Swift preset - Fulu diff --git a/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionPayloadHeaderPropertyTest.java b/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionPayloadHeaderPropertyTest.java index e9a37ed0baf..8413a6b2f62 100644 --- a/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionPayloadHeaderPropertyTest.java +++ b/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/datastructures/execution/ExecutionPayloadHeaderPropertyTest.java @@ -25,7 +25,7 @@ public class ExecutionPayloadHeaderPropertyTest { @Property void roundTrip( @ForAll(supplier = ExecutionPayloadHeaderSupplier.class) - ExecutionPayloadHeader executionPayloadHeader) + final ExecutionPayloadHeader executionPayloadHeader) throws JsonProcessingException { assertRoundTrip(executionPayloadHeader); } @@ -33,7 +33,7 @@ void roundTrip( @Property void deserializeMutated( @ForAll(supplier = ExecutionPayloadHeaderSupplier.class) - ExecutionPayloadHeader executionPayloadHeader, + final ExecutionPayloadHeader executionPayloadHeader, @ForAll final int seed) { assertDeserializeMutatedThrowsExpected(executionPayloadHeader, seed); } diff --git a/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ConsolidationRequestPropertyTest.java b/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ConsolidationRequestPropertyTest.java new file mode 100644 index 00000000000..59e93cacae2 --- /dev/null +++ b/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ConsolidationRequestPropertyTest.java @@ -0,0 +1,41 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.execution.versions.electra; + +import static tech.pegasys.teku.spec.propertytest.util.PropertyTestHelper.assertDeserializeMutatedThrowsExpected; +import static tech.pegasys.teku.spec.propertytest.util.PropertyTestHelper.assertRoundTrip; + +import com.fasterxml.jackson.core.JsonProcessingException; +import net.jqwik.api.ForAll; +import net.jqwik.api.Property; +import tech.pegasys.teku.spec.propertytest.suppliers.execution.versions.electra.ConsolidationRequestSupplier; + +public class ConsolidationRequestPropertyTest { + + @Property + void roundTrip( + @ForAll(supplier = ConsolidationRequestSupplier.class) + final ConsolidationRequest consolidationRequest) + throws JsonProcessingException { + assertRoundTrip(consolidationRequest); + } + + @Property + void deserializeMutated( + @ForAll(supplier = ConsolidationRequestSupplier.class) + final ConsolidationRequest consolidationRequest, + @ForAll final int seed) { + assertDeserializeMutatedThrowsExpected(consolidationRequest, seed); + } +} diff --git a/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/DepositRequestPropertyTest.java b/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/DepositRequestPropertyTest.java new file mode 100644 index 00000000000..0533b7d49c9 --- /dev/null +++ b/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/DepositRequestPropertyTest.java @@ -0,0 +1,39 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.execution.versions.electra; + +import static tech.pegasys.teku.spec.propertytest.util.PropertyTestHelper.assertDeserializeMutatedThrowsExpected; +import static tech.pegasys.teku.spec.propertytest.util.PropertyTestHelper.assertRoundTrip; + +import com.fasterxml.jackson.core.JsonProcessingException; +import net.jqwik.api.ForAll; +import net.jqwik.api.Property; +import tech.pegasys.teku.spec.propertytest.suppliers.execution.versions.electra.DepositRequestSupplier; + +public class DepositRequestPropertyTest { + + @Property + void roundTrip( + @ForAll(supplier = DepositRequestSupplier.class) final DepositRequest depositRequest) + throws JsonProcessingException { + assertRoundTrip(depositRequest); + } + + @Property + void deserializeMutated( + @ForAll(supplier = DepositRequestSupplier.class) final DepositRequest depositRequest, + @ForAll final int seed) { + assertDeserializeMutatedThrowsExpected(depositRequest, seed); + } +} diff --git a/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/WithdrawalRequestPropertyTest.java b/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/WithdrawalRequestPropertyTest.java new file mode 100644 index 00000000000..137fe7243ec --- /dev/null +++ b/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/WithdrawalRequestPropertyTest.java @@ -0,0 +1,39 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.execution.versions.electra; + +import static tech.pegasys.teku.spec.propertytest.util.PropertyTestHelper.assertDeserializeMutatedThrowsExpected; +import static tech.pegasys.teku.spec.propertytest.util.PropertyTestHelper.assertRoundTrip; + +import com.fasterxml.jackson.core.JsonProcessingException; +import net.jqwik.api.ForAll; +import net.jqwik.api.Property; +import tech.pegasys.teku.spec.propertytest.suppliers.execution.versions.electra.WithdrawalRequestSupplier; + +public class WithdrawalRequestPropertyTest { + + @Property + void roundTrip( + @ForAll(supplier = WithdrawalRequestSupplier.class) final WithdrawalRequest withdrawalRequest) + throws JsonProcessingException { + assertRoundTrip(withdrawalRequest); + } + + @Property + void deserializeMutated( + @ForAll(supplier = WithdrawalRequestSupplier.class) final WithdrawalRequest withdrawalRequest, + @ForAll final int seed) { + assertDeserializeMutatedThrowsExpected(withdrawalRequest, seed); + } +} diff --git a/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/datastructures/state/PendingConsolidationPropertyTest.java b/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/datastructures/state/PendingConsolidationPropertyTest.java new file mode 100644 index 00000000000..4c9018917a2 --- /dev/null +++ b/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/datastructures/state/PendingConsolidationPropertyTest.java @@ -0,0 +1,41 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.state; + +import static tech.pegasys.teku.spec.propertytest.util.PropertyTestHelper.assertDeserializeMutatedThrowsExpected; +import static tech.pegasys.teku.spec.propertytest.util.PropertyTestHelper.assertRoundTrip; + +import com.fasterxml.jackson.core.JsonProcessingException; +import net.jqwik.api.ForAll; +import net.jqwik.api.Property; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingConsolidation; +import tech.pegasys.teku.spec.propertytest.suppliers.state.PendingConsolidationSupplier; + +public class PendingConsolidationPropertyTest { + @Property + void roundTrip( + @ForAll(supplier = PendingConsolidationSupplier.class) + final PendingConsolidation pendingConsolidation) + throws JsonProcessingException { + assertRoundTrip(pendingConsolidation); + } + + @Property + void deserializeMutated( + @ForAll(supplier = PendingConsolidationSupplier.class) + final PendingConsolidation pendingConsolidation, + @ForAll final int seed) { + assertDeserializeMutatedThrowsExpected(pendingConsolidation, seed); + } +} diff --git a/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/datastructures/state/PendingDepositPropertyTest.java b/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/datastructures/state/PendingDepositPropertyTest.java new file mode 100644 index 00000000000..d77c2272a8f --- /dev/null +++ b/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/datastructures/state/PendingDepositPropertyTest.java @@ -0,0 +1,39 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.state; + +import static tech.pegasys.teku.spec.propertytest.util.PropertyTestHelper.assertDeserializeMutatedThrowsExpected; +import static tech.pegasys.teku.spec.propertytest.util.PropertyTestHelper.assertRoundTrip; + +import com.fasterxml.jackson.core.JsonProcessingException; +import net.jqwik.api.ForAll; +import net.jqwik.api.Property; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingDeposit; +import tech.pegasys.teku.spec.propertytest.suppliers.state.PendingDepositSupplier; + +public class PendingDepositPropertyTest { + @Property + void roundTrip( + @ForAll(supplier = PendingDepositSupplier.class) final PendingDeposit pendingDeposit) + throws JsonProcessingException { + assertRoundTrip(pendingDeposit); + } + + @Property + void deserializeMutated( + @ForAll(supplier = PendingDepositSupplier.class) final PendingDeposit pendingDeposit, + @ForAll final int seed) { + assertDeserializeMutatedThrowsExpected(pendingDeposit, seed); + } +} diff --git a/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/datastructures/state/PendingPartialWithdrawalPropertyTest.java b/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/datastructures/state/PendingPartialWithdrawalPropertyTest.java new file mode 100644 index 00000000000..a8cad074c60 --- /dev/null +++ b/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/datastructures/state/PendingPartialWithdrawalPropertyTest.java @@ -0,0 +1,41 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.state; + +import static tech.pegasys.teku.spec.propertytest.util.PropertyTestHelper.assertDeserializeMutatedThrowsExpected; +import static tech.pegasys.teku.spec.propertytest.util.PropertyTestHelper.assertRoundTrip; + +import com.fasterxml.jackson.core.JsonProcessingException; +import net.jqwik.api.ForAll; +import net.jqwik.api.Property; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingPartialWithdrawal; +import tech.pegasys.teku.spec.propertytest.suppliers.state.PendingPartialWithdrawalSupplier; + +public class PendingPartialWithdrawalPropertyTest { + @Property + void roundTrip( + @ForAll(supplier = PendingPartialWithdrawalSupplier.class) + final PendingPartialWithdrawal pendingPartialWithdrawal) + throws JsonProcessingException { + assertRoundTrip(pendingPartialWithdrawal); + } + + @Property + void deserializeMutated( + @ForAll(supplier = PendingPartialWithdrawalSupplier.class) + final PendingPartialWithdrawal pendingPartialWithdrawal, + @ForAll final int seed) { + assertDeserializeMutatedThrowsExpected(pendingPartialWithdrawal, seed); + } +} diff --git a/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/logic/versions/deneb/helpers/MiscHelpersDenebPropertyTest.java b/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/logic/versions/deneb/helpers/MiscHelpersDenebPropertyTest.java index 2216bb5d69d..f29ee89cd4b 100644 --- a/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/logic/versions/deneb/helpers/MiscHelpersDenebPropertyTest.java +++ b/ethereum/spec/src/property-test/java/tech/pegasys/teku/spec/logic/versions/deneb/helpers/MiscHelpersDenebPropertyTest.java @@ -65,7 +65,7 @@ void fuzzKzgCommitmentToVersionedHash( @AddLifecycleHook(KzgResolver.class) @Property(tries = 100) void fuzzVerifyBlobKzgProof( - final KZG kzg, @ForAll(supplier = BlobSidecarSupplier.class) BlobSidecar blobSidecar) { + final KZG kzg, @ForAll(supplier = BlobSidecarSupplier.class) final BlobSidecar blobSidecar) { try { miscHelpers.verifyBlobKzgProof(kzg, blobSidecar); } catch (Exception e) { diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/ForkScheduleTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/ForkScheduleTest.java index 76203ec6c0e..235f4c29c09 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/ForkScheduleTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/ForkScheduleTest.java @@ -25,10 +25,11 @@ import tech.pegasys.teku.spec.datastructures.state.Fork; import tech.pegasys.teku.spec.datastructures.util.ForkAndSpecMilestone; import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistryBuilder; public class ForkScheduleTest { private static final SpecConfig MINIMAL_CONFIG = - SpecConfigLoader.loadConfig(Eth2Network.MINIMAL.configName()); + SpecConfigLoader.loadConfig(Eth2Network.MINIMAL.configName()).specConfig(); // Set up config for a post-genesis altair transition private static final UInt64 FORK_EPOCH_ALTAIR = UInt64.valueOf(10); @@ -37,19 +38,21 @@ public class ForkScheduleTest { private static final SpecConfigAltair TRANSITION_CONFIG = SpecConfigAltair.required( SpecConfigLoader.loadConfig( - Eth2Network.MINIMAL.configName(), - c -> c.altairBuilder(a -> a.altairForkEpoch(FORK_EPOCH_ALTAIR)))); + Eth2Network.MINIMAL.configName(), + c -> c.altairBuilder(a -> a.altairForkEpoch(FORK_EPOCH_ALTAIR))) + .specConfig()); // Set config starting altair at genesis private static final SpecConfigAltair ALTAIR_CONFIG = SpecConfigAltair.required( SpecConfigLoader.loadConfig( - Eth2Network.MINIMAL.configName(), - c -> c.altairBuilder(a -> a.altairForkEpoch(UInt64.ZERO)))); + Eth2Network.MINIMAL.configName(), + c -> c.altairBuilder(a -> a.altairForkEpoch(UInt64.ZERO))) + .specConfig()); // Set up default config private static final SpecConfig PHASE0_CONFIG = - SpecConfigLoader.loadConfig(Eth2Network.MINIMAL.configName()); + SpecConfigLoader.loadConfig(Eth2Network.MINIMAL.configName()).specConfig(); // Fork versions static final Bytes4 PHASE_0_FORK_VERSION = TRANSITION_CONFIG.getGenesisForkVersion(); @@ -57,10 +60,12 @@ public class ForkScheduleTest { TRANSITION_CONFIG.toVersionAltair().orElseThrow().getAltairForkVersion(); static final Bytes4 UNKNOWN_FORK_VERSION = Bytes4.fromHexStringLenient("0xFFFFFFFF"); + final SchemaRegistryBuilder schemaRegistryBuilder = SchemaRegistryBuilder.create(); + @Test public void build_validScheduleWithAltairTransition() { - final SpecVersion phase0 = SpecVersion.createPhase0(TRANSITION_CONFIG); - final SpecVersion altair = SpecVersion.createAltair(TRANSITION_CONFIG); + final SpecVersion phase0 = SpecVersion.createPhase0(TRANSITION_CONFIG, schemaRegistryBuilder); + final SpecVersion altair = SpecVersion.createAltair(TRANSITION_CONFIG, schemaRegistryBuilder); final ForkSchedule forkSchedule = ForkSchedule.builder().addNextMilestone(phase0).addNextMilestone(altair).build(); @@ -70,8 +75,8 @@ public void build_validScheduleWithAltairTransition() { @Test public void build_validScheduleWithAltairAtGenesis_phase0AndAltairSupplied() { - final SpecVersion phase0 = SpecVersion.createPhase0(ALTAIR_CONFIG); - final SpecVersion altair = SpecVersion.createAltair(ALTAIR_CONFIG); + final SpecVersion phase0 = SpecVersion.createPhase0(ALTAIR_CONFIG, schemaRegistryBuilder); + final SpecVersion altair = SpecVersion.createAltair(ALTAIR_CONFIG, schemaRegistryBuilder); final ForkSchedule forkSchedule = ForkSchedule.builder().addNextMilestone(phase0).addNextMilestone(altair).build(); @@ -82,7 +87,7 @@ public void build_validScheduleWithAltairAtGenesis_phase0AndAltairSupplied() { @Test public void build_validScheduleWithAltairAtGenesis_onlyAltairSupplied() { - final SpecVersion altair = SpecVersion.createAltair(ALTAIR_CONFIG); + final SpecVersion altair = SpecVersion.createAltair(ALTAIR_CONFIG, schemaRegistryBuilder); final ForkSchedule forkSchedule = ForkSchedule.builder().addNextMilestone(altair).build(); @@ -92,7 +97,7 @@ public void build_validScheduleWithAltairAtGenesis_onlyAltairSupplied() { @Test public void build_validPhase0Schedule() { - final SpecVersion phase0 = SpecVersion.createPhase0(PHASE0_CONFIG); + final SpecVersion phase0 = SpecVersion.createPhase0(PHASE0_CONFIG, schemaRegistryBuilder); final ForkSchedule forkSchedule = ForkSchedule.builder().addNextMilestone(phase0).build(); @@ -102,7 +107,7 @@ public void build_validPhase0Schedule() { @Test public void builder_milestonesSuppliedOutOfOrder_altairProcessedAtNonZeroSlot() { - final SpecVersion altair = SpecVersion.createAltair(TRANSITION_CONFIG); + final SpecVersion altair = SpecVersion.createAltair(TRANSITION_CONFIG, schemaRegistryBuilder); final ForkSchedule.Builder builder = ForkSchedule.builder(); assertThatThrownBy(() -> builder.addNextMilestone(altair)) @@ -112,8 +117,9 @@ public void builder_milestonesSuppliedOutOfOrder_altairProcessedAtNonZeroSlot() @Test public void builder_milestonesSuppliedOutOfOrder_processAltairBeforePhase0() { - final SpecVersion altair = SpecVersion.createAltair(ALTAIR_CONFIG); - final SpecVersion phase0 = SpecVersion.createPhase0(ALTAIR_CONFIG); + final SpecVersion altair = SpecVersion.createAltair(ALTAIR_CONFIG, schemaRegistryBuilder); + final SpecVersion phase0 = + SpecVersion.createPhase0(ALTAIR_CONFIG, SchemaRegistryBuilder.create()); final ForkSchedule.Builder builder = ForkSchedule.builder(); builder.addNextMilestone(altair); @@ -132,7 +138,7 @@ public void getSupportedMilestones_withTransition() { @Test public void getSupportedMilestones_onlyAltairConfigured() { - final SpecVersion altair = SpecVersion.createAltair(ALTAIR_CONFIG); + final SpecVersion altair = SpecVersion.createAltair(ALTAIR_CONFIG, schemaRegistryBuilder); final ForkSchedule forkSchedule = ForkSchedule.builder().addNextMilestone(altair).build(); @@ -142,7 +148,7 @@ public void getSupportedMilestones_onlyAltairConfigured() { @Test public void getSupportedMilestones_onlyPhase0Configured() { - final SpecVersion phase0 = SpecVersion.createPhase0(PHASE0_CONFIG); + final SpecVersion phase0 = SpecVersion.createPhase0(PHASE0_CONFIG, schemaRegistryBuilder); final ForkSchedule forkSchedule = ForkSchedule.builder().addNextMilestone(phase0).build(); @@ -398,10 +404,11 @@ public void getGenesisFork_withTransition() { private ForkSchedule buildForkSchedule(final SpecConfig specConfig) { final ForkSchedule.Builder builder = ForkSchedule.builder(); - builder.addNextMilestone(SpecVersion.createPhase0(specConfig)); + builder.addNextMilestone(SpecVersion.createPhase0(specConfig, schemaRegistryBuilder)); specConfig .toVersionAltair() - .ifPresent(a -> builder.addNextMilestone(SpecVersion.createAltair(a))); + .ifPresent( + a -> builder.addNextMilestone(SpecVersion.createAltair(a, schemaRegistryBuilder))); return builder.build(); } diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/SpecMilestoneTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/SpecMilestoneTest.java index f49cedeff4c..9c13d192b1f 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/SpecMilestoneTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/SpecMilestoneTest.java @@ -24,23 +24,42 @@ import tech.pegasys.teku.spec.config.SpecConfigBellatrix; import tech.pegasys.teku.spec.config.SpecConfigCapella; import tech.pegasys.teku.spec.config.SpecConfigDeneb; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.config.SpecConfigFulu; import tech.pegasys.teku.spec.config.SpecConfigLoader; import tech.pegasys.teku.spec.networks.Eth2Network; public class SpecMilestoneTest { - private final SpecConfigEip7594 eip7594SpecConfig = - SpecConfigEip7594.required(SpecConfigLoader.loadConfig(Eth2Network.MINIMAL.configName())); + private final SpecConfigFulu fuluSpecConfig = + SpecConfigFulu.required( + SpecConfigLoader.loadConfig(Eth2Network.MINIMAL.configName()).specConfig()); + private final SpecConfigElectra electraSpecConfig = + SpecConfigLoader.loadConfig(Eth2Network.MINIMAL.configName()) + .specConfig() + .toVersionElectra() + .orElseThrow(); private final SpecConfigDeneb denebSpecConfig = - SpecConfigDeneb.required(SpecConfigLoader.loadConfig(Eth2Network.MINIMAL.configName())); + SpecConfigLoader.loadConfig(Eth2Network.MINIMAL.configName()) + .specConfig() + .toVersionDeneb() + .orElseThrow(); private final SpecConfigCapella capellaSpecConfig = - SpecConfigCapella.required(SpecConfigLoader.loadConfig(Eth2Network.MINIMAL.configName())); + SpecConfigLoader.loadConfig(Eth2Network.MINIMAL.configName()) + .specConfig() + .toVersionCapella() + .orElseThrow(); private final SpecConfigBellatrix bellatrixSpecConfig = - SpecConfigBellatrix.required(SpecConfigLoader.loadConfig(Eth2Network.MINIMAL.configName())); + SpecConfigLoader.loadConfig(Eth2Network.MINIMAL.configName()) + .specConfig() + .toVersionBellatrix() + .orElseThrow(); private final SpecConfigAltair altairSpecConfig = - SpecConfigAltair.required(SpecConfigLoader.loadConfig(Eth2Network.MINIMAL.configName())); + SpecConfigLoader.loadConfig(Eth2Network.MINIMAL.configName()) + .specConfig() + .toVersionAltair() + .orElseThrow(); private final SpecConfig phase0SpecConfig = - SpecConfigLoader.loadConfig(Eth2Network.MINIMAL.configName()); + SpecConfigLoader.loadConfig(Eth2Network.MINIMAL.configName()).specConfig(); @Test public void isGreaterThanOrEqualTo() { @@ -61,11 +80,11 @@ public void isGreaterThanOrEqualTo() { assertThat(SpecMilestone.DENEB.isGreaterThanOrEqualTo(SpecMilestone.BELLATRIX)).isTrue(); assertThat(SpecMilestone.DENEB.isGreaterThanOrEqualTo(SpecMilestone.CAPELLA)).isTrue(); assertThat(SpecMilestone.DENEB.isGreaterThanOrEqualTo(SpecMilestone.DENEB)).isTrue(); - assertThat(SpecMilestone.DENEB.isGreaterThanOrEqualTo(SpecMilestone.EIP7594)).isFalse(); + assertThat(SpecMilestone.DENEB.isGreaterThanOrEqualTo(SpecMilestone.ELECTRA)).isFalse(); - assertThat(SpecMilestone.EIP7594.isGreaterThanOrEqualTo(SpecMilestone.CAPELLA)).isTrue(); - assertThat(SpecMilestone.EIP7594.isGreaterThanOrEqualTo(SpecMilestone.DENEB)).isTrue(); - assertThat(SpecMilestone.EIP7594.isGreaterThanOrEqualTo(SpecMilestone.EIP7594)).isTrue(); + assertThat(SpecMilestone.ELECTRA.isGreaterThanOrEqualTo(SpecMilestone.CAPELLA)).isTrue(); + assertThat(SpecMilestone.ELECTRA.isGreaterThanOrEqualTo(SpecMilestone.DENEB)).isTrue(); + assertThat(SpecMilestone.ELECTRA.isGreaterThanOrEqualTo(SpecMilestone.ELECTRA)).isTrue(); } @Test @@ -75,7 +94,7 @@ public void getPreviousMilestone() { assertThat(SpecMilestone.BELLATRIX.getPreviousMilestone()).isEqualTo(SpecMilestone.ALTAIR); assertThat(SpecMilestone.CAPELLA.getPreviousMilestone()).isEqualTo(SpecMilestone.BELLATRIX); assertThat(SpecMilestone.DENEB.getPreviousMilestone()).isEqualTo(SpecMilestone.CAPELLA); - assertThat(SpecMilestone.EIP7594.getPreviousMilestone()).isEqualTo(SpecMilestone.DENEB); + assertThat(SpecMilestone.ELECTRA.getPreviousMilestone()).isEqualTo(SpecMilestone.DENEB); } @Test @@ -112,8 +131,8 @@ public void getAllPriorMilestones_deneb() { } @Test - public void getAllPriorMilestones_eip7594() { - assertThat(SpecMilestone.getAllPriorMilestones(SpecMilestone.EIP7594)) + public void getAllPriorMilestones_electra() { + assertThat(SpecMilestone.getAllPriorMilestones(SpecMilestone.ELECTRA)) .contains( SpecMilestone.PHASE0, SpecMilestone.ALTAIR, @@ -157,8 +176,8 @@ public void getMilestonesUpTo_deneb() { } @Test - public void getMilestonesUpTo_eip7594() { - assertThat(SpecMilestone.getMilestonesUpTo(SpecMilestone.EIP7594)) + public void getMilestonesUpTo_electra() { + assertThat(SpecMilestone.getMilestonesUpTo(SpecMilestone.ELECTRA)) .contains( SpecMilestone.PHASE0, SpecMilestone.ALTAIR, @@ -195,9 +214,9 @@ public void areMilestonesInOrder() { .isTrue(); assertThat(SpecMilestone.areMilestonesInOrder(SpecMilestone.DENEB, SpecMilestone.CAPELLA)) .isFalse(); - assertThat(SpecMilestone.areMilestonesInOrder(SpecMilestone.DENEB, SpecMilestone.EIP7594)) + assertThat(SpecMilestone.areMilestonesInOrder(SpecMilestone.DENEB, SpecMilestone.ELECTRA)) .isTrue(); - assertThat(SpecMilestone.areMilestonesInOrder(SpecMilestone.EIP7594, SpecMilestone.DENEB)) + assertThat(SpecMilestone.areMilestonesInOrder(SpecMilestone.ELECTRA, SpecMilestone.DENEB)) .isFalse(); } @@ -237,12 +256,18 @@ public void getForkVersion_deneb() { } @Test - public void getForkVersion_eip7594() { - final Bytes4 expected = eip7594SpecConfig.getEip7594ForkVersion(); - assertThat(SpecMilestone.getForkVersion(eip7594SpecConfig, SpecMilestone.EIP7594)) + public void getForkVersion_electra() { + final Bytes4 expected = electraSpecConfig.getElectraForkVersion(); + assertThat(SpecMilestone.getForkVersion(electraSpecConfig, SpecMilestone.ELECTRA)) .contains(expected); } + @Test + public void getForkVersion_fulu() { + final Bytes4 expected = fuluSpecConfig.getFuluForkVersion(); + assertThat(SpecMilestone.getForkVersion(fuluSpecConfig, SpecMilestone.FULU)).contains(expected); + } + @Test public void getForkEpoch_phase0() { final UInt64 expected = UInt64.ZERO; @@ -278,12 +303,18 @@ public void getForkEpoch_deneb() { } @Test - public void getForkEpoch_eip7594() { - final UInt64 expected = eip7594SpecConfig.getEip7594ForkEpoch(); - assertThat(SpecMilestone.getForkEpoch(eip7594SpecConfig, SpecMilestone.EIP7594)) + public void getForkEpoch_electra() { + final UInt64 expected = electraSpecConfig.getElectraForkEpoch(); + assertThat(SpecMilestone.getForkEpoch(electraSpecConfig, SpecMilestone.ELECTRA)) .contains(expected); } + @Test + public void getForkEpoch_fulu() { + final UInt64 expected = fuluSpecConfig.getFuluForkEpoch(); + assertThat(SpecMilestone.getForkEpoch(fuluSpecConfig, SpecMilestone.FULU)).contains(expected); + } + @Test public void getForkSlot_altairNotScheduled() { assertThat(SpecMilestone.getForkEpoch(phase0SpecConfig, SpecMilestone.ALTAIR)) @@ -309,8 +340,8 @@ public void getForkEpoch_denebNotScheduled() { } @Test - public void getForkEpoch_eip7594NotScheduled() { - assertThat(SpecMilestone.getForkEpoch(denebSpecConfig, SpecMilestone.EIP7594)) + public void getForkEpoch_electraNotScheduled() { + assertThat(SpecMilestone.getForkEpoch(denebSpecConfig, SpecMilestone.ELECTRA)) .contains(UInt64.MAX_VALUE); } } diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/SpecVersionTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/SpecVersionTest.java index c6bac77b5a7..efe5d8bc758 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/SpecVersionTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/SpecVersionTest.java @@ -16,87 +16,89 @@ import static org.assertj.core.api.Assertions.assertThat; import java.util.Optional; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; +import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.config.SpecConfigAltair; import tech.pegasys.teku.spec.config.SpecConfigBellatrix; import tech.pegasys.teku.spec.config.SpecConfigCapella; import tech.pegasys.teku.spec.config.SpecConfigDeneb; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.config.SpecConfigFulu; import tech.pegasys.teku.spec.config.SpecConfigLoader; import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistryBuilder; class SpecVersionTest { - private final SpecConfigAltair minimalConfig = - SpecConfigAltair.required(SpecConfigLoader.loadConfig(Eth2Network.MINIMAL.configName())); + private final SpecConfig minimalConfig = + SpecConfigLoader.loadConfig(Eth2Network.MINIMAL.configName()).specConfig(); - @Test - void shouldCreatePhase0Spec() { - final SpecVersion expectedVersion = SpecVersion.createPhase0(minimalConfig); - final Optional actualVersion = - SpecVersion.create(SpecMilestone.PHASE0, minimalConfig); - assertThat(actualVersion).isPresent(); - assertThat(actualVersion.get().getMilestone()).isEqualTo(SpecMilestone.PHASE0); - assertThat(actualVersion.get().getSchemaDefinitions()) - .hasSameClassAs(expectedVersion.getSchemaDefinitions()); - } - - @Test - void shouldCreateAltairSpec() { - final SpecConfigAltair altairSpecConfig = SpecConfigAltair.required(minimalConfig); - final SpecVersion expectedVersion = SpecVersion.createAltair(altairSpecConfig); - final Optional actualVersion = - SpecVersion.create(SpecMilestone.ALTAIR, minimalConfig); - assertThat(actualVersion).isPresent(); - assertThat(actualVersion.get().getMilestone()).isEqualTo(SpecMilestone.ALTAIR); - assertThat(actualVersion.get().getSchemaDefinitions()) - .hasSameClassAs(expectedVersion.getSchemaDefinitions()); - } - - @Test - void shouldCreateBellatrixSpec() { - final SpecConfigBellatrix bellatrixSpecConfig = SpecConfigBellatrix.required(minimalConfig); - final SpecVersion expectedVersion = SpecVersion.createBellatrix(bellatrixSpecConfig); - final Optional actualVersion = - SpecVersion.create(SpecMilestone.BELLATRIX, minimalConfig); - assertThat(actualVersion).isPresent(); - assertThat(actualVersion.get().getMilestone()).isEqualTo(SpecMilestone.BELLATRIX); - assertThat(actualVersion.get().getSchemaDefinitions()) - .hasSameClassAs(expectedVersion.getSchemaDefinitions()); - } + @ParameterizedTest + @EnumSource(SpecMilestone.class) + void shouldCreateSpec(final SpecMilestone milestone) { + // make intelliJ happy + SpecVersion expectedVersion = null; + Optional actualVersion = Optional.empty(); - @Test - void shouldCreateCapellaSpec() { - final SpecConfigCapella capellaSpecConfig = SpecConfigCapella.required(minimalConfig); - final SpecVersion expectedVersion = SpecVersion.createCapella(capellaSpecConfig); - final Optional actualVersion = - SpecVersion.create(SpecMilestone.CAPELLA, minimalConfig); - assertThat(actualVersion).isPresent(); - assertThat(actualVersion.get().getMilestone()).isEqualTo(SpecMilestone.CAPELLA); - assertThat(actualVersion.get().getSchemaDefinitions()) - .hasSameClassAs(expectedVersion.getSchemaDefinitions()); - } + switch (milestone) { + case PHASE0 -> { + expectedVersion = SpecVersion.createPhase0(minimalConfig, SchemaRegistryBuilder.create()); + actualVersion = + SpecVersion.create(SpecMilestone.PHASE0, minimalConfig, SchemaRegistryBuilder.create()); + } - @Test - void shouldCreateDenebSpec() { - final SpecConfigDeneb denebSpecConfig = SpecConfigDeneb.required(minimalConfig); - final SpecVersion expectedVersion = SpecVersion.createDeneb(denebSpecConfig); - final Optional actualVersion = - SpecVersion.create(SpecMilestone.DENEB, minimalConfig); - assertThat(actualVersion).isPresent(); - assertThat(actualVersion.get().getMilestone()).isEqualTo(SpecMilestone.DENEB); - assertThat(actualVersion.get().getSchemaDefinitions()) - .hasSameClassAs(expectedVersion.getSchemaDefinitions()); - } + case ALTAIR -> { + expectedVersion = + SpecVersion.createAltair( + SpecConfigAltair.required(minimalConfig), SchemaRegistryBuilder.create()); + actualVersion = + SpecVersion.create(SpecMilestone.ALTAIR, minimalConfig, SchemaRegistryBuilder.create()); + } + case BELLATRIX -> { + expectedVersion = + SpecVersion.createBellatrix( + SpecConfigBellatrix.required(minimalConfig), SchemaRegistryBuilder.create()); + actualVersion = + SpecVersion.create( + SpecMilestone.BELLATRIX, minimalConfig, SchemaRegistryBuilder.create()); + } + case CAPELLA -> { + expectedVersion = + SpecVersion.createCapella( + SpecConfigCapella.required(minimalConfig), SchemaRegistryBuilder.create()); + actualVersion = + SpecVersion.create( + SpecMilestone.CAPELLA, minimalConfig, SchemaRegistryBuilder.create()); + } + case DENEB -> { + expectedVersion = + SpecVersion.createDeneb( + SpecConfigDeneb.required(minimalConfig), SchemaRegistryBuilder.create()); + actualVersion = + SpecVersion.create(SpecMilestone.DENEB, minimalConfig, SchemaRegistryBuilder.create()); + } + case ELECTRA -> { + expectedVersion = + SpecVersion.createElectra( + SpecConfigElectra.required(minimalConfig), SchemaRegistryBuilder.create()); + actualVersion = + SpecVersion.create( + SpecMilestone.ELECTRA, minimalConfig, SchemaRegistryBuilder.create()); + } + case FULU -> { + expectedVersion = + SpecVersion.createFulu( + SpecConfigFulu.required(minimalConfig), SchemaRegistryBuilder.create()); + actualVersion = + SpecVersion.create(SpecMilestone.FULU, minimalConfig, SchemaRegistryBuilder.create()); + } + } - @Test - void shouldCreateEip7594Spec() { - final SpecConfigEip7594 eip7594SpecConfig = SpecConfigEip7594.required(minimalConfig); - final SpecVersion expectedVersion = SpecVersion.createEip7594(eip7594SpecConfig); - final Optional actualVersion = - SpecVersion.create(SpecMilestone.EIP7594, minimalConfig); assertThat(actualVersion).isPresent(); - assertThat(actualVersion.get().getMilestone()).isEqualTo(SpecMilestone.EIP7594); + assertThat(actualVersion.get().getMilestone()).isEqualTo(milestone); assertThat(actualVersion.get().getSchemaDefinitions()) .hasSameClassAs(expectedVersion.getSchemaDefinitions()); + assertThat(actualVersion.get().getSchemaDefinitions().getSchemaRegistry().getMilestone()) + .isSameAs(milestone); } } diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigAltairTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigAltairTest.java index 1908784ba61..60b79debefa 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigAltairTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigAltairTest.java @@ -26,9 +26,9 @@ public class SpecConfigAltairTest { @Test public void equals_mainnet() { SpecConfigAltair configA = - SpecConfigLoader.loadConfig("mainnet").toVersionAltair().orElseThrow(); + SpecConfigLoader.loadConfig("mainnet").specConfig().toVersionAltair().orElseThrow(); SpecConfigAltair configB = - SpecConfigLoader.loadConfig("mainnet").toVersionAltair().orElseThrow(); + SpecConfigLoader.loadConfig("mainnet").specConfig().toVersionAltair().orElseThrow(); assertThat(configA).isEqualTo(configB); assertThat(configA.hashCode()).isEqualTo(configB.hashCode()); @@ -36,7 +36,7 @@ public void equals_mainnet() { @Test public void equals_sameRandomValues() { - SpecConfig phase0 = SpecConfigLoader.loadConfig("mainnet"); + SpecConfig phase0 = SpecConfigLoader.loadConfig("mainnet").specConfig(); SpecConfigAltair configA = createRandomAltairConfig(phase0, 1); SpecConfigAltair configB = createRandomAltairConfig(phase0, 1); @@ -46,7 +46,7 @@ public void equals_sameRandomValues() { @Test public void equals_differentRandomValues() { - SpecConfig phase0 = SpecConfigLoader.loadConfig("mainnet"); + SpecConfig phase0 = SpecConfigLoader.loadConfig("mainnet").specConfig(); SpecConfigAltair configA = createRandomAltairConfig(phase0, 1); SpecConfigAltair configB = createRandomAltairConfig(phase0, 2); @@ -56,8 +56,9 @@ public void equals_differentRandomValues() { @Test public void equals_phase0ConfigDiffer() { - SpecConfig phase0A = SpecConfigLoader.loadConfig("swift", b -> {}); - SpecConfig phase0B = SpecConfigLoader.loadConfig("swift", b -> b.maxValidatorsPerCommittee(1)); + SpecConfig phase0A = SpecConfigLoader.loadConfig("swift", b -> {}).specConfig(); + SpecConfig phase0B = + SpecConfigLoader.loadConfig("swift", b -> b.maxValidatorsPerCommittee(1)).specConfig(); SpecConfigAltair configA = createRandomAltairConfig(phase0A, 1); SpecConfigAltair configB = createRandomAltairConfig(phase0B, 1); diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigAssertions.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigAssertions.java index 2c751b3b70d..2660fa4e5c8 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigAssertions.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigAssertions.java @@ -31,7 +31,8 @@ static void assertAllBellatrixFieldsSet(final SpecConfig config) throws Exceptio assertAllFieldsSet(config, SpecConfigBellatrix.class); } - static void assertAllFieldsSet(final SpecConfig config, Class targetConfig) throws Exception { + static void assertAllFieldsSet(final SpecConfig config, final Class targetConfig) + throws Exception { for (Method method : listGetters(targetConfig)) { final Object value = method.invoke(config); assertThat(value).describedAs(method.getName().substring(3)).isNotNull(); @@ -43,6 +44,7 @@ private static List listGetters(final Class clazz) { .filter(m -> Modifier.isPublic(m.getModifiers())) .filter(m -> m.getParameterTypes().length == 0) .filter(m -> m.getName().startsWith("get")) + .filter(m -> !m.getName().endsWith("InEffect")) .collect(Collectors.toList()); } } diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigBellatrixTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigBellatrixTest.java index 60136cc8731..ffaea8940b4 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigBellatrixTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigBellatrixTest.java @@ -26,9 +26,9 @@ public class SpecConfigBellatrixTest { @Test public void equals_mainnet() { SpecConfigBellatrix configA = - SpecConfigLoader.loadConfig("mainnet").toVersionBellatrix().orElseThrow(); + SpecConfigLoader.loadConfig("mainnet").specConfig().toVersionBellatrix().orElseThrow(); SpecConfigBellatrix configB = - SpecConfigLoader.loadConfig("mainnet").toVersionBellatrix().orElseThrow(); + SpecConfigLoader.loadConfig("mainnet").specConfig().toVersionBellatrix().orElseThrow(); assertThat(configA).isEqualTo(configB); assertThat(configA.hashCode()).isEqualTo(configB.hashCode()); @@ -37,7 +37,7 @@ public void equals_mainnet() { @Test public void equals_sameRandomValues() { SpecConfigAltair altair = - SpecConfigLoader.loadConfig("mainnet").toVersionAltair().orElseThrow(); + SpecConfigLoader.loadConfig("mainnet").specConfig().toVersionAltair().orElseThrow(); SpecConfigBellatrix configA = createRandomBellatrixConfig(altair, 1); SpecConfigBellatrix configB = createRandomBellatrixConfig(altair, 1); @@ -48,7 +48,7 @@ public void equals_sameRandomValues() { @Test public void equals_differentRandomValues() { SpecConfigAltair altair = - SpecConfigLoader.loadConfig("mainnet").toVersionAltair().orElseThrow(); + SpecConfigLoader.loadConfig("mainnet").specConfig().toVersionAltair().orElseThrow(); SpecConfigBellatrix configA = createRandomBellatrixConfig(altair, 1); SpecConfigBellatrix configB = createRandomBellatrixConfig(altair, 2); @@ -59,12 +59,16 @@ public void equals_differentRandomValues() { @Test public void equals_altairConfigDiffer() { SpecConfigAltair altairA = - SpecConfigLoader.loadConfig("mainnet", b -> {}).toVersionAltair().orElseThrow(); + SpecConfigLoader.loadConfig("mainnet", b -> {}) + .specConfig() + .toVersionAltair() + .orElseThrow(); SpecConfigAltair altairB = SpecConfigLoader.loadConfig( "mainnet", b -> b.altairBuilder(ab -> ab.syncCommitteeSize(altairA.getSyncCommitteeSize() + 4))) + .specConfig() .toVersionAltair() .orElseThrow(); diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigBuilderTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigBuilderTest.java index e20182159a4..da2f057932e 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigBuilderTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigBuilderTest.java @@ -14,6 +14,7 @@ package tech.pegasys.teku.spec.config; import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static tech.pegasys.teku.spec.SpecMilestone.ELECTRA; import java.lang.reflect.Method; import java.lang.reflect.Modifier; @@ -32,8 +33,9 @@ import tech.pegasys.teku.spec.config.builder.BellatrixBuilder; import tech.pegasys.teku.spec.config.builder.CapellaBuilder; import tech.pegasys.teku.spec.config.builder.DenebBuilder; -import tech.pegasys.teku.spec.config.builder.Eip7594Builder; +import tech.pegasys.teku.spec.config.builder.ElectraBuilder; import tech.pegasys.teku.spec.config.builder.SpecConfigBuilder; +import tech.pegasys.teku.spec.datastructures.util.ForkAndSpecMilestone; import tech.pegasys.teku.spec.util.DataStructureUtil; class SpecConfigBuilderTest { @@ -47,7 +49,7 @@ class SpecConfigBuilderTest { BellatrixBuilder.class, CapellaBuilder.class, DenebBuilder.class, - Eip7594Builder.class); + ElectraBuilder.class); /** * Ensures Builders have actually non-primitive setters, because primitive setters are silently @@ -96,6 +98,25 @@ public void shouldHaveOnlyNonPrimitiveFields() { } } + @Test + public void shouldCreateSpecVersionWithEffectiveSpecConfigVersion() { + final Spec spec = getSpec(__ -> {}); + spec.getForkSchedule().getActiveMilestones().stream() + .map(ForkAndSpecMilestone::getSpecMilestone) + .forEach( + milestone -> + assertThat(spec.forMilestone(milestone).getConfig().getMilestone()) + .isEqualTo(milestone)); + } + + @Test + public void shouldCreateSpecExposingNonActiveConfig() { + // we will need to update this when we schedule ELECTRA on mainnet + final Spec spec = getSpec(__ -> {}); + assertThat(spec.getForkSchedule().getHighestSupportedMilestone()).isNotEqualTo(ELECTRA); + assertThat(spec.getSpecConfigAndParent().specConfig().getMilestone()).isEqualTo(ELECTRA); + } + @Test public void shouldLoadAltairForkEpoch() { final UInt64 randomEpoch = dataStructureUtil.randomUInt64(100_000); @@ -168,8 +189,9 @@ public void shouldLoadTerminalBlockHashActivationEpoch() { .isEqualTo(randomUInt64); } - private Spec getSpec(Consumer consumer) { - final SpecConfig config = SpecConfigLoader.loadConfig("mainnet", consumer); + private Spec getSpec(final Consumer consumer) { + final SpecConfigAndParent config = + SpecConfigLoader.loadConfig("mainnet", consumer); return SpecFactory.create(config); } } diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigCapellaTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigCapellaTest.java index a95edb57a89..a996f5d4695 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigCapellaTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigCapellaTest.java @@ -26,9 +26,9 @@ public class SpecConfigCapellaTest { @Test public void equals_mainnet() { SpecConfigCapella configA = - SpecConfigLoader.loadConfig("mainnet").toVersionCapella().orElseThrow(); + SpecConfigLoader.loadConfig("mainnet").specConfig().toVersionCapella().orElseThrow(); SpecConfigCapella configB = - SpecConfigLoader.loadConfig("mainnet").toVersionCapella().orElseThrow(); + SpecConfigLoader.loadConfig("mainnet").specConfig().toVersionCapella().orElseThrow(); assertThat(configA).isEqualTo(configB); assertThat(configA.hashCode()).isEqualTo(configB.hashCode()); @@ -37,7 +37,7 @@ public void equals_mainnet() { @Test public void equals_sameRandomValues() { SpecConfigBellatrix specConfigBellatrix = - SpecConfigLoader.loadConfig("mainnet").toVersionBellatrix().orElseThrow(); + SpecConfigLoader.loadConfig("mainnet").specConfig().toVersionBellatrix().orElseThrow(); ; SpecConfigBellatrix configA = createRandomCapellaConfig(specConfigBellatrix, 1); SpecConfigBellatrix configB = createRandomCapellaConfig(specConfigBellatrix, 1); @@ -49,7 +49,7 @@ public void equals_sameRandomValues() { @Test public void equals_differentRandomValues() { SpecConfigBellatrix specConfigBellatrix = - SpecConfigLoader.loadConfig("mainnet").toVersionBellatrix().orElseThrow(); + SpecConfigLoader.loadConfig("mainnet").specConfig().toVersionBellatrix().orElseThrow(); ; SpecConfigBellatrix configA = createRandomCapellaConfig(specConfigBellatrix, 1); SpecConfigBellatrix configB = createRandomCapellaConfig(specConfigBellatrix, 2); @@ -61,7 +61,7 @@ public void equals_differentRandomValues() { @Test public void equals_bellatrixConfigDiffer() { SpecConfigBellatrix bellatrixA = - SpecConfigLoader.loadConfig("mainnet").toVersionBellatrix().orElseThrow(); + SpecConfigLoader.loadConfig("mainnet").specConfig().toVersionBellatrix().orElseThrow(); SpecConfigBellatrix bellatrixB = SpecConfigLoader.loadConfig( "mainnet", @@ -69,6 +69,7 @@ public void equals_bellatrixConfigDiffer() { b.bellatrixBuilder( ab -> ab.maxBytesPerTransaction(bellatrixA.getMaxBytesPerTransaction() + 4))) + .specConfig() .toVersionBellatrix() .orElseThrow(); diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigDenebTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigDenebTest.java index 6e73567060c..481545ab9d8 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigDenebTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigDenebTest.java @@ -26,8 +26,10 @@ public class SpecConfigDenebTest { @Test public void equals_mainnet() { - SpecConfigDeneb configA = SpecConfigLoader.loadConfig("mainnet").toVersionDeneb().orElseThrow(); - SpecConfigDeneb configB = SpecConfigLoader.loadConfig("mainnet").toVersionDeneb().orElseThrow(); + SpecConfigDeneb configA = + SpecConfigLoader.loadConfig("mainnet").specConfig().toVersionDeneb().orElseThrow(); + SpecConfigDeneb configB = + SpecConfigLoader.loadConfig("mainnet").specConfig().toVersionDeneb().orElseThrow(); assertThat(configA).isEqualTo(configB); assertThat(configA.hashCode()).isEqualTo(configB.hashCode()); @@ -36,7 +38,7 @@ public void equals_mainnet() { @Test public void equals_sameRandomValues() { SpecConfigCapella specConfigCapella = - SpecConfigLoader.loadConfig("mainnet").toVersionCapella().orElseThrow(); + SpecConfigLoader.loadConfig("mainnet").specConfig().toVersionCapella().orElseThrow(); SpecConfigDeneb configA = createRandomDenebConfig(specConfigCapella, 1); SpecConfigDeneb configB = createRandomDenebConfig(specConfigCapella, 1); @@ -47,7 +49,7 @@ public void equals_sameRandomValues() { @Test public void equals_differentRandomValues() { SpecConfigCapella specConfigCapella = - SpecConfigLoader.loadConfig("mainnet").toVersionCapella().orElseThrow(); + SpecConfigLoader.loadConfig("mainnet").specConfig().toVersionCapella().orElseThrow(); SpecConfigDeneb configA = createRandomDenebConfig(specConfigCapella, 1); SpecConfigDeneb configB = createRandomDenebConfig(specConfigCapella, 2); @@ -58,7 +60,7 @@ public void equals_differentRandomValues() { @Test public void equals_capellaConfigDiffer() { SpecConfigCapella capellaA = - SpecConfigLoader.loadConfig("mainnet").toVersionCapella().orElseThrow(); + SpecConfigLoader.loadConfig("mainnet").specConfig().toVersionCapella().orElseThrow(); SpecConfigCapella capellaB = SpecConfigLoader.loadConfig( "mainnet", @@ -67,6 +69,7 @@ public void equals_capellaConfigDiffer() { cb -> cb.maxWithdrawalsPerPayload( capellaA.getMaxWithdrawalsPerPayload() + 4))) + .specConfig() .toVersionCapella() .orElseThrow(); diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigEip7594Test.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigEip7594Test.java deleted file mode 100644 index f2afe200e7f..00000000000 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigEip7594Test.java +++ /dev/null @@ -1,95 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.spec.config; - -import static org.assertj.core.api.Assertions.assertThat; - -import org.junit.jupiter.api.Test; -import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.TestSpecFactory; -import tech.pegasys.teku.spec.util.DataStructureUtil; - -public class SpecConfigEip7594Test { - private final Spec spec = TestSpecFactory.createMinimalDeneb(); - - @Test - public void equals_mainnet() { - final SpecConfigEip7594 configA = - SpecConfigLoader.loadConfig("mainnet").toVersionEip7594().orElseThrow(); - final SpecConfigEip7594 configB = - SpecConfigLoader.loadConfig("mainnet").toVersionEip7594().orElseThrow(); - - assertThat(configA).isEqualTo(configB); - assertThat(configA.hashCode()).isEqualTo(configB.hashCode()); - } - - @Test - public void equals_sameRandomValues() { - final SpecConfigDeneb specConfigDeneb = - SpecConfigLoader.loadConfig("mainnet").toVersionDeneb().orElseThrow(); - final SpecConfigEip7594 configA = createRandomEip7594Config(specConfigDeneb, 1); - final SpecConfigEip7594 configB = createRandomEip7594Config(specConfigDeneb, 1); - - assertThat(configA).isEqualTo(configB); - assertThat(configA.hashCode()).isEqualTo(configB.hashCode()); - } - - @Test - public void equals_differentRandomValues() { - final SpecConfigDeneb specConfigDeneb = - SpecConfigLoader.loadConfig("mainnet").toVersionDeneb().orElseThrow(); - final SpecConfigEip7594 configA = createRandomEip7594Config(specConfigDeneb, 1); - final SpecConfigEip7594 configB = createRandomEip7594Config(specConfigDeneb, 2); - - assertThat(configA).isNotEqualTo(configB); - assertThat(configA.hashCode()).isNotEqualTo(configB.hashCode()); - } - - @Test - public void equals_denebConfigDiffer() { - final SpecConfigDeneb denebA = - SpecConfigLoader.loadConfig("mainnet").toVersionDeneb().orElseThrow(); - final SpecConfigDeneb denebB = - SpecConfigLoader.loadConfig( - "mainnet", - b -> b.denebBuilder(db -> db.maxBlobsPerBlock(denebA.getMaxBlobsPerBlock() + 4))) - .toVersionDeneb() - .orElseThrow(); - - final SpecConfigEip7594 configA = createRandomEip7594Config(denebA, 1); - final SpecConfigEip7594 configB = createRandomEip7594Config(denebB, 1); - - assertThat(configA).isNotEqualTo(configB); - assertThat(configA.hashCode()).isNotEqualTo(configB.hashCode()); - } - - private SpecConfigEip7594 createRandomEip7594Config( - final SpecConfigDeneb denebConfig, final int seed) { - final DataStructureUtil dataStructureUtil = new DataStructureUtil(seed, spec); - - return new SpecConfigEip7594Impl( - denebConfig, - dataStructureUtil.randomBytes4(), - dataStructureUtil.randomUInt64(999_999), - dataStructureUtil.randomUInt64(64), - dataStructureUtil.randomUInt64(8192), - dataStructureUtil.randomUInt64(10), - dataStructureUtil.randomPositiveInt(128), - dataStructureUtil.randomPositiveInt(64), - dataStructureUtil.randomPositiveInt(64), - dataStructureUtil.randomPositiveInt(64), - dataStructureUtil.randomPositiveInt(4096), - dataStructureUtil.randomPositiveInt(16384)) {}; - } -} diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigElectraTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigElectraTest.java new file mode 100644 index 00000000000..11819876ff4 --- /dev/null +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigElectraTest.java @@ -0,0 +1,147 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.config; + +import static org.assertj.core.api.Assertions.assertThat; + +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +public class SpecConfigElectraTest { + private final Spec spec = TestSpecFactory.createMinimalDeneb(); + + @Test + public void equals_mainnet() { + final SpecConfigElectra configA = + SpecConfigLoader.loadConfig("mainnet").specConfig().toVersionElectra().orElseThrow(); + final SpecConfigElectra configB = + SpecConfigLoader.loadConfig("mainnet").specConfig().toVersionElectra().orElseThrow(); + + assertThat(configA).isEqualTo(configB); + assertThat(configA.hashCode()).isEqualTo(configB.hashCode()); + } + + @Test + public void equals_sameRandomValues() { + final SpecConfigDeneb specConfigDeneb = + SpecConfigLoader.loadConfig("mainnet").specConfig().toVersionDeneb().orElseThrow(); + final SpecConfigElectra configA = createRandomElectraConfig(specConfigDeneb, 1); + final SpecConfigElectra configB = createRandomElectraConfig(specConfigDeneb, 1); + + assertThat(configA).isEqualTo(configB); + assertThat(configA.hashCode()).isEqualTo(configB.hashCode()); + } + + @Test + public void equals_differentRandomValues() { + final SpecConfigDeneb specConfigDeneb = + SpecConfigLoader.loadConfig("mainnet").specConfig().toVersionDeneb().orElseThrow(); + final SpecConfigElectra configA = createRandomElectraConfig(specConfigDeneb, 1); + final SpecConfigElectra configB = createRandomElectraConfig(specConfigDeneb, 2); + + assertThat(configA).isNotEqualTo(configB); + assertThat(configA.hashCode()).isNotEqualTo(configB.hashCode()); + } + + @Test + @SuppressWarnings("unchecked") + public void shouldOverrideBlobRelatedValuesValues() { + final SpecConfigAndParent specConfigAndParent = + (SpecConfigAndParent) + SpecConfigLoader.loadConfig( + "mainnet", + b -> { + b.denebBuilder( + eb -> + eb.maxBlobsPerBlock(4) + // target blobs is calculated in deneb + .blobSidecarSubnetCount(8) + .maxRequestBlobSidecars(16)); + + b.electraBuilder( + eb -> + eb.maxBlobsPerBlockElectra(8) + .targetBlobsPerBlockElectra(5) + .blobSidecarSubnetCountElectra(10) + .maxRequestBlobSidecarsElectra(13)); + }); + + final SpecConfigDeneb denebConfig = + specConfigAndParent.forMilestone(SpecMilestone.DENEB).toVersionDeneb().orElseThrow(); + + final SpecConfigDeneb electraConfig = + specConfigAndParent.forMilestone(SpecMilestone.ELECTRA).toVersionDeneb().orElseThrow(); + + assertThat(denebConfig.getMaxBlobsPerBlock()).isEqualTo(4); + assertThat(denebConfig.getTargetBlobsPerBlock()).isEqualTo(2); + assertThat(denebConfig.getBlobSidecarSubnetCount()).isEqualTo(8); + assertThat(denebConfig.getMaxRequestBlobSidecars()).isEqualTo(16); + + assertThat(electraConfig.getMaxBlobsPerBlock()).isEqualTo(8); + assertThat(electraConfig.getTargetBlobsPerBlock()).isEqualTo(5); + assertThat(electraConfig.getBlobSidecarSubnetCount()).isEqualTo(10); + assertThat(electraConfig.getMaxRequestBlobSidecars()).isEqualTo(13); + } + + @Test + public void equals_denebConfigDiffer() { + final SpecConfigDeneb denebA = + SpecConfigLoader.loadConfig("mainnet").specConfig().toVersionDeneb().orElseThrow(); + final SpecConfigDeneb denebB = + SpecConfigLoader.loadConfig( + "mainnet", + b -> b.denebBuilder(db -> db.maxBlobsPerBlock(denebA.getMaxBlobsPerBlock() + 4))) + .specConfig() + .toVersionDeneb() + .orElseThrow(); + + final SpecConfigElectra configA = createRandomElectraConfig(denebA, 1); + final SpecConfigElectra configB = createRandomElectraConfig(denebB, 1); + + assertThat(configA).isNotEqualTo(configB); + assertThat(configA.hashCode()).isNotEqualTo(configB.hashCode()); + } + + private SpecConfigElectra createRandomElectraConfig( + final SpecConfigDeneb denebConfig, final int seed) { + final DataStructureUtil dataStructureUtil = new DataStructureUtil(seed, spec); + + return new SpecConfigElectraImpl( + denebConfig, + dataStructureUtil.randomBytes4(), + dataStructureUtil.randomUInt64(999_999), + dataStructureUtil.randomUInt64(128000000000L), + dataStructureUtil.randomUInt64(32000000000L), + dataStructureUtil.randomUInt64(2048000000000L), + dataStructureUtil.randomPositiveInt(134217728), + dataStructureUtil.randomPositiveInt(134217728), + dataStructureUtil.randomPositiveInt(262144), + dataStructureUtil.randomPositiveInt(4096), + dataStructureUtil.randomPositiveInt(4096), + dataStructureUtil.randomPositiveInt(1), + dataStructureUtil.randomPositiveInt(8), + dataStructureUtil.randomPositiveInt(1), + dataStructureUtil.randomPositiveInt(8192), + dataStructureUtil.randomPositiveInt(16), + dataStructureUtil.randomPositiveInt(8), + dataStructureUtil.randomPositiveInt(16), + dataStructureUtil.randomPositiveInt(8), + dataStructureUtil.randomPositiveInt(4), + dataStructureUtil.randomPositiveInt(1024), + dataStructureUtil.randomPositiveInt(8)) {}; + } +} diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigLoaderTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigLoaderTest.java index 87168886ea5..d790ef2ecf9 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigLoaderTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigLoaderTest.java @@ -41,9 +41,9 @@ public class SpecConfigLoaderTest { @ParameterizedTest(name = "{0}") @EnumSource(Eth2Network.class) public void shouldLoadAllKnownNetworks(final Eth2Network network) throws Exception { - final SpecConfig config = SpecConfigLoader.loadConfigStrict(network.configName()); + final SpecConfig config = SpecConfigLoader.loadConfigStrict(network.configName()).specConfig(); // testing latest SpecConfig ensures all fields will be asserted on - assertAllFieldsSet(config, SpecConfigEip7594.class); + assertAllFieldsSet(config, SpecConfigElectra.class); } /** @@ -55,31 +55,32 @@ public void shouldLoadAllKnownNetworks(final Eth2Network network) throws Excepti * sufficient. */ @ParameterizedTest(name = "{0}") - @ValueSource(strings = {"prater", "mainnet"}) + @ValueSource(strings = {"holesky", "mainnet"}) public void shouldMaintainConfigNameBackwardsCompatibility(final String name) { - final SpecConfig config = SpecConfigLoader.loadConfig(name); + final SpecConfig config = SpecConfigLoader.loadConfig(name).specConfig(); assertThat(config.getRawConfig().get("CONFIG_NAME")).isEqualTo(name); } @Test public void shouldLoadMainnet() throws Exception { - final SpecConfig config = SpecConfigLoader.loadConfig("mainnet"); + final SpecConfig config = SpecConfigLoader.loadConfig("mainnet").specConfig(); assertAllBellatrixFieldsSet(config); } @Test public void shouldLoadMainnetFromFileUrl() throws Exception { final URL url = getMainnetConfigResourceAsUrl(); - final SpecConfig config = SpecConfigLoader.loadConfig(url.toString()); + final SpecConfig config = SpecConfigLoader.loadConfig(url.toString()).specConfig(); assertAllBellatrixFieldsSet(config); } @Test - public void shouldLoadMainnetFromFile(@TempDir Path tempDir) throws Exception { + public void shouldLoadMainnetFromFile(@TempDir final Path tempDir) throws Exception { try (final InputStream inputStream = getMainnetConfigAsStream()) { final Path file = tempDir.resolve("mainnet.yml"); writeStreamToFile(inputStream, file); - final SpecConfig config = SpecConfigLoader.loadConfig(file.toAbsolutePath().toString()); + final SpecConfig config = + SpecConfigLoader.loadConfig(file.toAbsolutePath().toString()).specConfig(); assertAllBellatrixFieldsSet(config); } } @@ -90,13 +91,14 @@ void shouldLoadMainnetPreservingBackwardsCompatibilityWithRestApi(final String s throws Exception { try (final InputStream in = Resources.getResource(SpecConfigLoaderTest.class, specFilename).openStream()) { - final SpecConfig config = SpecConfigLoader.loadRemoteConfig(readJsonConfig(in)); + final SpecConfig config = SpecConfigLoader.loadRemoteConfig(readJsonConfig(in)).specConfig(); assertAllAltairFieldsSet(config); } } @Test - public void shouldHandleInvalidPresetValue_wrongType(@TempDir Path tempDir) throws Exception { + public void shouldHandleInvalidPresetValue_wrongType(@TempDir final Path tempDir) + throws Exception { try (final InputStream inputStream = loadInvalidFile("invalidPreset_wrongType.yaml")) { final Path file = tempDir.resolve("invalid.yml"); writeStreamToFile(inputStream, file); @@ -112,7 +114,8 @@ public void shouldHandleInvalidPresetValue_wrongType(@TempDir Path tempDir) thro } @Test - public void shouldHandleInvalidPresetValue_unknownPreset(@TempDir Path tempDir) throws Exception { + public void shouldHandleInvalidPresetValue_unknownPreset(@TempDir final Path tempDir) + throws Exception { try (final InputStream inputStream = loadInvalidFile("invalidPreset_unknown.yaml")) { final Path file = tempDir.resolve("invalid.yml"); writeStreamToFile(inputStream, file); @@ -133,7 +136,8 @@ public void shouldHandleInvalidPresetValue_unknownPreset(@TempDir Path tempDir) @Test public void shouldBeAbleToOverridePresetValues() { final URL configUrl = SpecConfigLoaderTest.class.getResource("standard/with-overrides.yaml"); - final SpecConfig config = SpecConfigLoader.loadConfig(configUrl.toString(), false, __ -> {}); + final SpecConfig config = + SpecConfigLoader.loadConfig(configUrl.toString(), false, __ -> {}).specConfig(); assertThat(config).isNotNull(); assertThat(config.getMaxCommitteesPerSlot()).isEqualTo(12); // Mainnet preset is 64. } diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigReaderTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigReaderTest.java index a2c0c58aeca..592102ab47c 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigReaderTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/config/SpecConfigReaderTest.java @@ -68,7 +68,7 @@ void read_ignoringUnknownConstant() { processFileAsInputStream( getInvalidConfigPath("unknownField"), source -> reader.readAndApply(source, true)); - assertAllAltairFieldsSet(reader.build()); + assertAllAltairFieldsSet(reader.build().specConfig()); }) .doesNotThrowAnyException(); } @@ -230,7 +230,7 @@ private void processFileAsInputStream(final String fileName, final InputStreamHa } } - private InputStream getFileFromResourceAsStream(String fileName) { + private InputStream getFileFromResourceAsStream(final String fileName) { InputStream inputStream = getClass().getClassLoader().getResourceAsStream(fileName); if (inputStream == null) { throw new IllegalArgumentException("File not found: " + fileName); diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/Eth1DataTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/Eth1DataTest.java index ce075b77e10..1d3bbf9ac47 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/Eth1DataTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/Eth1DataTest.java @@ -24,12 +24,12 @@ class Eth1DataTest { - private Random random = new Random(100); - private Bytes32 depositRoot = Bytes32.random(random); - private Bytes32 blockHash = Bytes32.random(random); - private UInt64 depositCount = UInt64.valueOf(100); + private final Random random = new Random(100); + private final Bytes32 depositRoot = Bytes32.random(random); + private final Bytes32 blockHash = Bytes32.random(random); + private final UInt64 depositCount = UInt64.valueOf(100); - private Eth1Data eth1Data = new Eth1Data(depositRoot, depositCount, blockHash); + private final Eth1Data eth1Data = new Eth1Data(depositRoot, depositCount, blockHash); @Test void equalsReturnsTrueWhenObjectAreSame() { diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/common/AbstractBeaconBlockBodyTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/common/AbstractBeaconBlockBodyTest.java index 45a2f8b01d3..b1ecc4a1c5b 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/common/AbstractBeaconBlockBodyTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/common/AbstractBeaconBlockBodyTest.java @@ -22,7 +22,6 @@ import java.util.List; import java.util.function.Consumer; import java.util.stream.Collectors; -import java.util.stream.Stream; import org.apache.tuweni.bytes.Bytes32; import org.junit.jupiter.api.Test; import tech.pegasys.teku.bls.BLSSignature; @@ -64,7 +63,7 @@ public abstract class AbstractBeaconBlockBodyTest { protected boolean supportsExecutionPayload; - protected void setUpBaseClass(final SpecMilestone milestone, Runnable additionalSetup) { + protected void setUpBaseClass(final SpecMilestone milestone, final Runnable additionalSetup) { spec = TestSpecFactory.createMinimal(milestone); supportsExecutionPayload = spec.isMilestoneSupported(SpecMilestone.BELLATRIX); dataStructureUtil = new DataStructureUtil(spec); @@ -147,7 +146,7 @@ void equalsReturnsTrueWhenObjectFieldsAreEqual() { assertEquals(defaultBlockBody, testBeaconBlockBody); } - private SszList reversed(SszList list) { + private SszList reversed(final SszList list) { List reversedList = list.stream().collect(Collectors.toList()); Collections.reverse(reversedList); return list.getSchema().createFromElements(reversedList); @@ -166,9 +165,7 @@ void equalsReturnsFalseWhenProposerSlashingsAreDifferent() { void equalsReturnsFalseWhenAttesterSlashingsAreDifferent() { // Create copy of attesterSlashings and change the element to ensure it is different. attesterSlashings = - Stream.concat( - Stream.of(dataStructureUtil.randomAttesterSlashing()), attesterSlashings.stream()) - .collect(blockBodySchema.getAttesterSlashingsSchema().collector()); + blockBodySchema.getAttesterSlashingsSchema().of(dataStructureUtil.randomAttesterSlashing()); T testBeaconBlockBody = createBlockBody(); @@ -240,7 +237,7 @@ public void verifyExecutionPayloadSupport() { createBeaconBlockBodyBuilder().supportsExecutionPayload(), supportsExecutionPayload); } - protected Consumer createContentProvider(boolean blinded) { + protected Consumer createContentProvider(final boolean blinded) { return builder -> builder .randaoReveal(randaoReveal) diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/capella/BeaconBlockBodyCapellaTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/capella/BeaconBlockBodyCapellaTest.java index b29cab45c47..7ecdc6c0431 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/capella/BeaconBlockBodyCapellaTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/capella/BeaconBlockBodyCapellaTest.java @@ -66,7 +66,7 @@ protected BeaconBlockBodyCapella createBlockBody( @Override protected BlindedBeaconBlockBodyBellatrix createBlindedBlockBody( - Consumer contentProvider) { + final Consumer contentProvider) { final BeaconBlockBodyBuilder bodyBuilder = createBeaconBlockBodyBuilder(); contentProvider.accept(bodyBuilder); return bodyBuilder.build().toBlindedVersionCapella().orElseThrow(); diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/deneb/BeaconBlockBodyDenebTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/deneb/BeaconBlockBodyDenebTest.java index 603a7b6fa16..a2a532d53d3 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/deneb/BeaconBlockBodyDenebTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/deneb/BeaconBlockBodyDenebTest.java @@ -69,7 +69,7 @@ protected BeaconBlockBodyDeneb createBlockBody( @Override protected BlindedBeaconBlockBodyBellatrix createBlindedBlockBody( - Consumer contentProvider) { + final Consumer contentProvider) { final BeaconBlockBodyBuilder bodyBuilder = createBeaconBlockBodyBuilder(); contentProvider.accept(bodyBuilder); return bodyBuilder.build().toBlindedVersionDeneb().orElseThrow(); diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BeaconBlockBodyElectraTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BeaconBlockBodyElectraTest.java new file mode 100644 index 00000000000..a5c6364bf5b --- /dev/null +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/electra/BeaconBlockBodyElectraTest.java @@ -0,0 +1,86 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra; + +import java.util.function.Consumer; +import org.junit.jupiter.api.BeforeEach; +import tech.pegasys.teku.infrastructure.ssz.SszList; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodyBuilder; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.common.AbstractBeaconBlockBodyTest; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.SyncAggregate; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.bellatrix.BlindedBeaconBlockBodyBellatrix; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayload; +import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; +import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChange; +import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; + +class BeaconBlockBodyElectraTest extends AbstractBeaconBlockBodyTest { + + protected SyncAggregate syncAggregate; + protected ExecutionPayload executionPayload; + protected ExecutionPayloadHeader executionPayloadHeader; + protected SszList blsToExecutionChanges; + protected SszList blobKzgCommitments; + protected ExecutionRequests executionRequests; + + @BeforeEach + void setup() { + super.setUpBaseClass( + SpecMilestone.ELECTRA, + () -> { + syncAggregate = dataStructureUtil.randomSyncAggregate(); + executionPayload = dataStructureUtil.randomExecutionPayload(); + executionPayloadHeader = dataStructureUtil.randomExecutionPayloadHeader(); + blsToExecutionChanges = dataStructureUtil.randomSignedBlsToExecutionChangesList(); + blobKzgCommitments = dataStructureUtil.randomBlobKzgCommitments(); + executionRequests = dataStructureUtil.randomExecutionRequests(); + }); + } + + @Override + protected BeaconBlockBodyElectra createBlockBody( + final Consumer contentProvider) { + final BeaconBlockBodyBuilder bodyBuilder = createBeaconBlockBodyBuilder(); + contentProvider.accept(bodyBuilder); + return bodyBuilder.build().toVersionElectra().orElseThrow(); + } + + @Override + protected BlindedBeaconBlockBodyBellatrix createBlindedBlockBody( + final Consumer contentProvider) { + final BeaconBlockBodyBuilder bodyBuilder = createBeaconBlockBodyBuilder(); + contentProvider.accept(bodyBuilder); + return bodyBuilder.build().toBlindedVersionElectra().orElseThrow(); + } + + @Override + protected Consumer createContentProvider(final boolean blinded) { + return super.createContentProvider(blinded) + .andThen( + builder -> { + builder + .syncAggregate(syncAggregate) + .blsToExecutionChanges(blsToExecutionChanges) + .blobKzgCommitments(blobKzgCommitments) + .executionRequests(executionRequests); + if (blinded) { + builder.executionPayloadHeader(executionPayloadHeader); + } else { + builder.executionPayload(executionPayload); + } + }); + } +} diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/phase0/BeaconBlockBodyPhase0Test.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/phase0/BeaconBlockBodyPhase0Test.java index cdb00da1c64..535d2e3bc00 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/phase0/BeaconBlockBodyPhase0Test.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/phase0/BeaconBlockBodyPhase0Test.java @@ -37,7 +37,7 @@ protected BeaconBlockBodyPhase0 createBlockBody( @Override protected BlindedBeaconBlockBodyBellatrix createBlindedBlockBody( - Consumer contentProvider) { + final Consumer contentProvider) { return null; } } diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/phase0/BeaconBlockBodySchemaPhase0Test.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/phase0/BeaconBlockBodySchemaPhase0Test.java index ec64d11d263..8db06f2ca5f 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/phase0/BeaconBlockBodySchemaPhase0Test.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/blocks/blockbody/versions/phase0/BeaconBlockBodySchemaPhase0Test.java @@ -19,8 +19,6 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.config.SpecConfig; -import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing.AttesterSlashingSchema; -import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestation.IndexedAttestationSchema; public class BeaconBlockBodySchemaPhase0Test { @@ -31,13 +29,13 @@ public void create_minimal() { final BeaconBlockBodySchemaPhase0 specA = BeaconBlockBodySchemaPhase0.create( specConfig, - new AttesterSlashingSchema(new IndexedAttestationSchema(specConfig)), - "BeaconBlockBodyPhase0"); + "BeaconBlockBodyPhase0", + spec.getGenesisSchemaDefinitions().getSchemaRegistry()); final BeaconBlockBodySchemaPhase0 specB = BeaconBlockBodySchemaPhase0.create( specConfig, - new AttesterSlashingSchema(new IndexedAttestationSchema(specConfig)), - "BeaconBlockBodyPhase0"); + "BeaconBlockBodyPhase0", + spec.getGenesisSchemaDefinitions().getSchemaRegistry()); assertThat(specA).isEqualTo(specB); } @@ -49,13 +47,13 @@ public void create_mainnet() { final BeaconBlockBodySchemaPhase0 specA = BeaconBlockBodySchemaPhase0.create( specConfig, - new AttesterSlashingSchema(new IndexedAttestationSchema(specConfig)), - "BeaconBlockBodyPhase0"); + "BeaconBlockBodyPhase0", + spec.getGenesisSchemaDefinitions().getSchemaRegistry()); final BeaconBlockBodySchemaPhase0 specB = BeaconBlockBodySchemaPhase0.create( specConfig, - new AttesterSlashingSchema(new IndexedAttestationSchema(specConfig)), - "BeaconBlockBodyPhase0"); + "BeaconBlockBodyPhase0", + spec.getGenesisSchemaDefinitions().getSchemaRegistry()); assertThat(specA).isEqualTo(specB); } diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/execution/ExpectedWithdrawalsTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/execution/ExpectedWithdrawalsTest.java new file mode 100644 index 00000000000..1abd324d72d --- /dev/null +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/execution/ExpectedWithdrawalsTest.java @@ -0,0 +1,176 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.execution; + +import static org.assertj.core.api.Assertions.assertThat; + +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.datastructures.state.BeaconStateTestBuilder; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.BeaconStateElectra; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.MutableBeaconStateElectra; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +class ExpectedWithdrawalsTest { + + private Spec spec; + private DataStructureUtil dataStructureUtil; + + @Test + void bellatrixExpectedWithdrawals() { + spec = TestSpecFactory.createMinimalBellatrix(); + dataStructureUtil = new DataStructureUtil(spec); + final ExpectedWithdrawals expectedWithdrawals = + spec.getGenesisSpec() + .getBlockProcessor() + .getExpectedWithdrawals(dataStructureUtil.randomBeaconState()); + assertThat(expectedWithdrawals).isEqualTo(ExpectedWithdrawals.NOOP); + } + + @Test + void capellaExpectedWithdrawals() { + spec = TestSpecFactory.createMinimalCapella(); + dataStructureUtil = new DataStructureUtil(spec); + final UInt64 minActivationBalance = spec.getGenesisSpecConfig().getMaxEffectiveBalance(); + final long excessBalance = 1024000L; + final BeaconState preState = + new BeaconStateTestBuilder(dataStructureUtil) + .activeEth1Validator(minActivationBalance.plus(excessBalance)) + .build(); + final ExpectedWithdrawals withdrawals = + spec.getBlockProcessor(preState.getSlot()).getExpectedWithdrawals(preState); + assertThat(withdrawals.getWithdrawalList().get(0).getAmount()) + .isEqualTo(UInt64.valueOf(1024000)); + assertThat(withdrawals.getPartialWithdrawalCount()).isEqualTo(0); + } + + @Test + void electraExpectedWithdrawals() { + spec = TestSpecFactory.createMinimalElectra(); + dataStructureUtil = new DataStructureUtil(spec); + final SpecConfigElectra specConfigElectra = + SpecConfigElectra.required(spec.getGenesisSpec().getConfig()); + final UInt64 electraMaxBalance = specConfigElectra.getMaxEffectiveBalance(); + final long excessBalance = 1024000L; + final long partialWithdrawalBalance = 10241024L; + + final BeaconStateElectra preState = + BeaconStateElectra.required( + new BeaconStateTestBuilder(dataStructureUtil) + .activeEth1Validator(UInt64.THIRTY_TWO_ETH.plus(excessBalance)) + .activeConsolidatingValidator(electraMaxBalance.plus(partialWithdrawalBalance)) + .pendingPartialWithdrawal(1, electraMaxBalance.plus(partialWithdrawalBalance)) + .build()); + + final ExpectedWithdrawals withdrawals = + spec.getBlockProcessor(preState.getSlot()).getExpectedWithdrawals(preState); + + assertThat(withdrawals.getWithdrawalList().get(0).getAmount()) + .isEqualTo(UInt64.valueOf(partialWithdrawalBalance)); + assertThat(withdrawals.getWithdrawalList().get(1).getAmount()) + .isEqualTo(UInt64.valueOf(excessBalance)); + assertThat(withdrawals.getPartialWithdrawalCount()).isEqualTo(1); + final MutableBeaconStateElectra mutableBeaconStateElectra = + MutableBeaconStateElectra.required(preState.createWritableCopy()); + + withdrawals.processWithdrawalsUnchecked( + mutableBeaconStateElectra, + SchemaDefinitionsElectra.required(spec.getGenesisSchemaDefinitions()), + spec.getGenesisSpec().beaconStateMutators(), + SpecConfigElectra.required(spec.getGenesisSpecConfig())); + assertThat(mutableBeaconStateElectra.getPendingPartialWithdrawals().size()).isEqualTo(0); + + assertThat(mutableBeaconStateElectra.getNextWithdrawalIndex()).isEqualTo(UInt64.valueOf(2)); + assertThat(mutableBeaconStateElectra.getValidators().size()).isEqualTo(2); + } + + @Test + void electraPendingPartialWithdrawals() { + spec = TestSpecFactory.createMinimalElectra(); + dataStructureUtil = new DataStructureUtil(spec); + final SpecConfigElectra specConfigElectra = + SpecConfigElectra.required(spec.getGenesisSpec().getConfig()); + final UInt64 electraMaxBalance = specConfigElectra.getMaxEffectiveBalance(); + final long partialWithdrawalBalance = 10241024L; + + final BeaconStateElectra preState = + BeaconStateElectra.required( + new BeaconStateTestBuilder(dataStructureUtil) + .activeConsolidatingValidator(electraMaxBalance.plus(partialWithdrawalBalance)) + .activeConsolidatingValidator(electraMaxBalance.plus(partialWithdrawalBalance + 1)) + .activeConsolidatingValidator(electraMaxBalance.plus(partialWithdrawalBalance + 2)) + .pendingPartialWithdrawal(0, electraMaxBalance.plus(partialWithdrawalBalance)) + .pendingPartialWithdrawal( + 1, electraMaxBalance.plus(partialWithdrawalBalance).plus(1)) + .pendingPartialWithdrawal( + 2, electraMaxBalance.plus(partialWithdrawalBalance).plus(2)) + .build()); + + final ExpectedWithdrawals withdrawals = + spec.getBlockProcessor(preState.getSlot()).getExpectedWithdrawals(preState); + final MutableBeaconStateElectra mutableBeaconStateElectra = + MutableBeaconStateElectra.required(preState.createWritableCopy()); + assertThat(withdrawals.getPartialWithdrawalCount()).isEqualTo(2); + + withdrawals.processWithdrawalsUnchecked( + mutableBeaconStateElectra, + SchemaDefinitionsElectra.required(spec.getGenesisSchemaDefinitions()), + spec.getGenesisSpec().beaconStateMutators(), + SpecConfigElectra.required(spec.getGenesisSpecConfig())); + assertThat(mutableBeaconStateElectra.getPendingPartialWithdrawals().size()).isEqualTo(1); + assertThat(mutableBeaconStateElectra.getNextWithdrawalIndex()).isEqualTo(UInt64.valueOf(2)); + assertThat(mutableBeaconStateElectra.getValidators().size()).isEqualTo(3); + } + + @Test + void electraPendingPartialCountsSkippedWithdrawals() { + spec = TestSpecFactory.createMinimalElectra(); + dataStructureUtil = new DataStructureUtil(spec); + final SpecConfigElectra specConfigElectra = + SpecConfigElectra.required(spec.getGenesisSpec().getConfig()); + final UInt64 electraMaxBalance = specConfigElectra.getMaxEffectiveBalance(); + final long partialWithdrawalBalance = 10241024L; + + final BeaconStateElectra preState = + BeaconStateElectra.required( + new BeaconStateTestBuilder(dataStructureUtil) + .activeConsolidatingValidator(electraMaxBalance.plus(partialWithdrawalBalance)) + // the two validators below are skipped because they are queued for exit therefore + // they're withdrawals are skipped + .activeConsolidatingValidatorQueuedForExit( + electraMaxBalance.plus(partialWithdrawalBalance + 1)) + .activeConsolidatingValidatorQueuedForExit( + electraMaxBalance.plus(partialWithdrawalBalance + 2)) + .pendingPartialWithdrawal(0, electraMaxBalance.plus(partialWithdrawalBalance)) + .pendingPartialWithdrawal( + 1, electraMaxBalance.plus(partialWithdrawalBalance).plus(1)) + .pendingPartialWithdrawal( + 2, electraMaxBalance.plus(partialWithdrawalBalance).plus(2)) + .build()); + + final ExpectedWithdrawals withdrawals = + spec.getBlockProcessor(preState.getSlot()).getExpectedWithdrawals(preState); + + // even having 2 of the 3 partial withdrawals skipped, + // the count should be 2(which is the MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP for minimal + // spec) + // because we consider the skipped in the count + assertThat(withdrawals.getPartialWithdrawalCount()).isEqualTo(2); + } +} diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/execution/versions/capella/WithdrawalTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/execution/versions/capella/WithdrawalTest.java index 9c81825fead..d80a78d3f0d 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/execution/versions/capella/WithdrawalTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/execution/versions/capella/WithdrawalTest.java @@ -19,15 +19,16 @@ import org.junit.jupiter.api.Test; import tech.pegasys.teku.infrastructure.bytes.Bytes20; import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.util.DataStructureUtil; class WithdrawalTest { - - private final DataStructureUtil dataStructureUtil = - new DataStructureUtil(TestSpecFactory.createMinimal(SpecMilestone.CAPELLA)); - private final WithdrawalSchema withdrawalSchema = Withdrawal.SSZ_SCHEMA; + private final Spec spec = TestSpecFactory.createMinimal(SpecMilestone.CAPELLA); + private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); + private final WithdrawalSchema withdrawalSchema = + spec.getGenesisSchemaDefinitions().toVersionCapella().orElseThrow().getWithdrawalSchema(); private final UInt64 index = dataStructureUtil.randomUInt64(); private final UInt64 validatorIndex = dataStructureUtil.randomUInt64(); diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ExecutionRequestsDataCodecTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ExecutionRequestsDataCodecTest.java new file mode 100644 index 00000000000..70b5e0e0aba --- /dev/null +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/execution/versions/electra/ExecutionRequestsDataCodecTest.java @@ -0,0 +1,245 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.execution.versions.electra; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +import java.util.List; +import org.apache.tuweni.bytes.Bytes; +import org.apache.tuweni.bytes.Bytes32; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.bls.BLSSignature; +import tech.pegasys.teku.infrastructure.bytes.Bytes20; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecFactory; + +class ExecutionRequestsDataCodecTest { + + private final Spec spec = TestSpecFactory.createMinimalElectra(); + private final ExecutionRequestsSchema executionRequestsSchema = + spec.forMilestone(SpecMilestone.ELECTRA) + .getSchemaDefinitions() + .toVersionElectra() + .orElseThrow() + .getExecutionRequestsSchema(); + private final ExecutionRequestsDataCodec codec = + new ExecutionRequestsDataCodec(executionRequestsSchema); + + @Test + public void codecRoundTrip() { + final List expectedExecutionRequestsData = + List.of( + depositRequestListEncoded, + withdrawalRequestsListEncoded, + consolidationRequestsListEncoded); + + final List encodedExecutionRequestData = + codec.encode(codec.decode(expectedExecutionRequestsData)); + assertThat(encodedExecutionRequestData).isEqualTo(expectedExecutionRequestsData); + } + + @Test + public void decodeExecutionRequestData() { + final List executionRequestsData = + List.of( + depositRequestListEncoded, + withdrawalRequestsListEncoded, + consolidationRequestsListEncoded); + + final ExecutionRequests executionRequests = codec.decode(executionRequestsData); + + assertThat(executionRequests.getDeposits()).containsExactly(depositRequest1, depositRequest2); + assertThat(executionRequests.getWithdrawals()) + .containsExactly(withdrawalRequest1, withdrawalRequest2); + assertThat(executionRequests.getConsolidations()).containsExactly(consolidationRequest1); + } + + @Test + public void decodeExecutionRequestsDataWithNoRequests() { + final ExecutionRequests executionRequests = codec.decode(List.of()); + + assertThat(executionRequests.getDeposits()).isEmpty(); + assertThat(executionRequests.getWithdrawals()).isEmpty(); + assertThat(executionRequests.getConsolidations()).isEmpty(); + } + + @Test + public void decodeExecutionRequestsDataWithOneRequestMissing() { + final List executionRequestsData = + List.of(depositRequestListEncoded, consolidationRequestsListEncoded); + + final ExecutionRequests executionRequests = codec.decode(executionRequestsData); + + assertThat(executionRequests.getDeposits()).containsExactly(depositRequest1, depositRequest2); + assertThat(executionRequests.getWithdrawals()).isEmpty(); + assertThat(executionRequests.getConsolidations()).containsExactly(consolidationRequest1); + } + + @Test + public void decodeExecutionRequestsDataWithInvalidRequestType() { + final List invalidExecutionRequestsData = + List.of(depositRequestListEncoded, withdrawalRequestsListEncoded, Bytes.of(9)); + + assertThatThrownBy(() -> codec.decode(invalidExecutionRequestsData)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("Invalid execution request type: 9"); + } + + @Test + public void decodeExecutionRequestDataWithRequestsNotOrderedInAscendingOrder() { + final List invalidExecutionRequestsData = + List.of( + depositRequestListEncoded, + consolidationRequestsListEncoded, + withdrawalRequestsListEncoded); + + assertThatThrownBy(() -> codec.decode(invalidExecutionRequestsData)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("Execution requests are not in strictly ascending order"); + } + + @Test + public void decodeExecutionRequestDataWithRepeatedRequestsOfSameType() { + final List invalidExecutionRequestsData = + List.of( + depositRequestListEncoded, + consolidationRequestsListEncoded, + consolidationRequestsListEncoded); + + assertThatThrownBy(() -> codec.decode(invalidExecutionRequestsData)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("Execution requests are not in strictly ascending order"); + } + + @Test + public void encodeExecutionRequests() { + final ExecutionRequests executionRequests = + new ExecutionRequestsBuilderElectra(executionRequestsSchema) + .deposits(List.of(depositRequest1, depositRequest2)) + .withdrawals(List.of(withdrawalRequest1, withdrawalRequest2)) + .consolidations(List.of(consolidationRequest1)) + .build(); + + final List encodedRequests = codec.encode(executionRequests); + + assertThat(encodedRequests) + .containsExactly( + depositRequestListEncoded, + withdrawalRequestsListEncoded, + consolidationRequestsListEncoded); + } + + @Test + public void encodeWithWithOneEmptyRequestList() { + final ExecutionRequests executionRequests = + new ExecutionRequestsBuilderElectra(executionRequestsSchema) + .deposits(List.of(depositRequest1, depositRequest2)) + .withdrawals(List.of()) + .consolidations(List.of(consolidationRequest1)) + .build(); + + final List encodedRequests = codec.encode(executionRequests); + + assertThat(encodedRequests) + .containsExactly(depositRequestListEncoded, consolidationRequestsListEncoded); + } + + @Test + public void encodeWithAllEmptyRequestLists() { + final ExecutionRequests executionRequests = + new ExecutionRequestsBuilderElectra(executionRequestsSchema) + .deposits(List.of()) + .withdrawals(List.of()) + .consolidations(List.of()) + .build(); + + final List encodedRequests = codec.encode(executionRequests); + + assertThat(encodedRequests).isEmpty(); + } + + // Examples taken from + // https://github.com/ethereum/execution-apis/blob/main/src/engine/openrpc/methods/payload.yaml + private final Bytes depositRequestListEncoded = + Bytes.fromHexString( + "0x0096a96086cff07df17668f35f7418ef8798079167e3f4f9b72ecde17b28226137cf454ab1dd20ef5d924786ab3483c2f9003f5102dabe0a27b1746098d1dc17a5d3fbd478759fea9287e4e419b3c3cef20100000000000000b1acdb2c4d3df3f1b8d3bfd33421660df358d84d78d16c4603551935f4b67643373e7eb63dcb16ec359be0ec41fee33b03a16e80745f2374ff1d3c352508ac5d857c6476d3c3bcf7e6ca37427c9209f17be3af5264c0e2132b3dd1156c28b4e9f000000000000000a5c85a60ba2905c215f6a12872e62b1ee037051364244043a5f639aa81b04a204c55e7cc851f29c7c183be253ea1510b001db70c485b6264692f26b8aeaab5b0c384180df8e2184a21a808a3ec8e86ca01000000000000009561731785b48cf1886412234531e4940064584463e96ac63a1a154320227e333fb51addc4a89b7e0d3f862d7c1fd4ea03bd8eb3d8806f1e7daf591cbbbb92b0beb74d13c01617f22c5026b4f9f9f294a8a7c32db895de3b01bee0132c9209e1f100000000000000"); + + private final DepositRequest depositRequest1 = + new DepositRequest( + (DepositRequestSchema) + executionRequestsSchema.getDepositRequestsSchema().getElementSchema(), + BLSPublicKey.fromHexString( + "0x96a96086cff07df17668f35f7418ef8798079167e3f4f9b72ecde17b28226137cf454ab1dd20ef5d924786ab3483c2f9"), + Bytes32.fromHexString( + "0x003f5102dabe0a27b1746098d1dc17a5d3fbd478759fea9287e4e419b3c3cef2"), + UInt64.valueOf(1L), + BLSSignature.fromBytesCompressed( + Bytes.fromHexString( + "0xb1acdb2c4d3df3f1b8d3bfd33421660df358d84d78d16c4603551935f4b67643373e7eb63dcb16ec359be0ec41fee33b03a16e80745f2374ff1d3c352508ac5d857c6476d3c3bcf7e6ca37427c9209f17be3af5264c0e2132b3dd1156c28b4e9")), + UInt64.valueOf(240L)); + + private final DepositRequest depositRequest2 = + new DepositRequest( + (DepositRequestSchema) + executionRequestsSchema.getDepositRequestsSchema().getElementSchema(), + BLSPublicKey.fromHexString( + "0xa5c85a60ba2905c215f6a12872e62b1ee037051364244043a5f639aa81b04a204c55e7cc851f29c7c183be253ea1510b"), + Bytes32.fromHexString( + "0x001db70c485b6264692f26b8aeaab5b0c384180df8e2184a21a808a3ec8e86ca"), + UInt64.valueOf(1L), + BLSSignature.fromBytesCompressed( + Bytes.fromHexString( + "0x9561731785b48cf1886412234531e4940064584463e96ac63a1a154320227e333fb51addc4a89b7e0d3f862d7c1fd4ea03bd8eb3d8806f1e7daf591cbbbb92b0beb74d13c01617f22c5026b4f9f9f294a8a7c32db895de3b01bee0132c9209e1")), + UInt64.valueOf(241L)); + + private final Bytes withdrawalRequestsListEncoded = + Bytes.fromHexString( + "0x01a94f5374fce5edbc8e2a8697c15331677e6ebf0b85103a5617937691dfeeb89b86a80d5dc9e3c9d3a1a0e7ce311e26e0bb732eabaa47ffa288f0d54de28209a62a7d29d0000000000000000000000000000000000000000000000000000010f698daeed734da114470da559bd4b4c7259e1f7952555241dcbc90cf194a2ef676fc6005f3672fada2a3645edb297a75530100000000000000"); + + private final WithdrawalRequest withdrawalRequest1 = + new WithdrawalRequest( + (WithdrawalRequestSchema) + executionRequestsSchema.getWithdrawalRequestsSchema().getElementSchema(), + Bytes20.fromHexString("0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b"), + BLSPublicKey.fromHexString( + "0x85103a5617937691dfeeb89b86a80d5dc9e3c9d3a1a0e7ce311e26e0bb732eabaa47ffa288f0d54de28209a62a7d29d0"), + UInt64.valueOf(0L)); + + private final WithdrawalRequest withdrawalRequest2 = + new WithdrawalRequest( + (WithdrawalRequestSchema) + executionRequestsSchema.getWithdrawalRequestsSchema().getElementSchema(), + Bytes20.fromHexString("0x00000000000000000000000000000000000010f6"), + BLSPublicKey.fromHexString( + "0x98daeed734da114470da559bd4b4c7259e1f7952555241dcbc90cf194a2ef676fc6005f3672fada2a3645edb297a7553"), + UInt64.valueOf(1L)); + + private final Bytes consolidationRequestsListEncoded = + Bytes.fromHexString( + "0x02a94f5374fce5edbc8e2a8697c15331677e6ebf0b85103a5617937691dfeeb89b86a80d5dc9e3c9d3a1a0e7ce311e26e0bb732eabaa47ffa288f0d54de28209a62a7d29d098daeed734da114470da559bd4b4c7259e1f7952555241dcbc90cf194a2ef676fc6005f3672fada2a3645edb297a7553"); + + private final ConsolidationRequest consolidationRequest1 = + new ConsolidationRequest( + (ConsolidationRequestSchema) + executionRequestsSchema.getConsolidationRequestsSchema().getElementSchema(), + Bytes20.fromHexString("0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b"), + BLSPublicKey.fromHexString( + "0x85103a5617937691dfeeb89b86a80d5dc9e3c9d3a1a0e7ce311e26e0bb732eabaa47ffa288f0d54de28209a62a7d29d0"), + BLSPublicKey.fromHexString( + "0x98daeed734da114470da559bd4b4c7259e1f7952555241dcbc90cf194a2ef676fc6005f3672fada2a3645edb297a7553")); +} diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/hashtree/HashTreeTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/hashtree/HashTreeTest.java index 8c20d06fc2a..83eac0ae5bc 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/hashtree/HashTreeTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/hashtree/HashTreeTest.java @@ -205,7 +205,7 @@ private void validateTreeRepresentsChains( assertThat(actualHashes).containsExactlyInAnyOrderElementsOf(expectedHashes); for (List chain : chains) { - SignedBeaconBlock lastBlock = chain.get(chain.size() - 1); + SignedBeaconBlock lastBlock = chain.getLast(); // All blocks should be available for (SignedBeaconBlock block : chain) { @@ -228,7 +228,7 @@ private void validateTreeRepresentsChains( private void validateChildCountsForChain( final HashTree tree, final List chain) { - final SignedBeaconBlock lastBlock = chain.get(chain.size() - 1); + final SignedBeaconBlock lastBlock = chain.getLast(); for (int i = 0; i < chain.size() - 1; i++) { SignedBeaconBlock block = chain.get(i); assertThat(tree.countChildren(block.getRoot())).isEqualTo(1); diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/merkletree/MerkleTreeTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/merkletree/MerkleTreeTest.java index 4fa42c04ba2..86d08ac8a79 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/merkletree/MerkleTreeTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/merkletree/MerkleTreeTest.java @@ -78,7 +78,7 @@ void getProof() { assertThatBooleanCollection(results).allSatisfy(Assertions::assertTrue); } - private SszBytes32Vector toSszBytes32Vector(List list) { + private SszBytes32Vector toSszBytes32Vector(final List list) { return SszBytes32VectorSchema.create(list.size()).of(list); } diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/BeaconBlocksByRangeRequestMessageTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/BeaconBlocksByRangeRequestMessageTest.java index 9fc6a04930c..5173a2f7792 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/BeaconBlocksByRangeRequestMessageTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/BeaconBlocksByRangeRequestMessageTest.java @@ -56,6 +56,8 @@ public static Stream getMaxSlotParams() { Arguments.of(0, 2, 2, 2), Arguments.of(10, 2, 2, 12), Arguments.of(0, 5, 2, 8), - Arguments.of(10, 5, 2, 18)); + Arguments.of(10, 5, 2, 18), + Arguments.of(10, 3, 5, 20), + Arguments.of(0, 0, 1, 0)); } } diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/BlobSidecarsByRangeRequestMessageTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/BlobSidecarsByRangeRequestMessageTest.java index 1b45601ed64..d5844da9f51 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/BlobSidecarsByRangeRequestMessageTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/networking/libp2p/rpc/BlobSidecarsByRangeRequestMessageTest.java @@ -61,6 +61,8 @@ public static Stream getMaxSlotParams() { Arguments.of(0, 2, 1), Arguments.of(10, 2, 11), Arguments.of(0, 5, 4), - Arguments.of(10, 5, 14)); + Arguments.of(10, 5, 14), + Arguments.of(1, 0, 1), + Arguments.of(0, 0, 0)); } } diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/AttestationTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/AttestationTest.java index d0e7cdb0eba..733582115cb 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/AttestationTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/AttestationTest.java @@ -26,20 +26,20 @@ import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.TestSpecFactory; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; import tech.pegasys.teku.spec.datastructures.state.Checkpoint; import tech.pegasys.teku.spec.util.DataStructureUtil; class AttestationTest { private final Spec spec = TestSpecFactory.createDefault(); private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); - private final AttestationSchema schema = + private final AttestationSchema schema = spec.getGenesisSchemaDefinitions().getAttestationSchema(); - private SszBitlist aggregationBitfield = dataStructureUtil.randomBitlist(); - private AttestationData data = dataStructureUtil.randomAttestationData(); - private BLSSignature aggregateSignature = dataStructureUtil.randomSignature(); + private final SszBitlist aggregationBitfield = dataStructureUtil.randomBitlist(); + private final AttestationData data = dataStructureUtil.randomAttestationData(); + private final BLSSignature aggregateSignature = dataStructureUtil.randomSignature(); - private Attestation attestation = schema.create(aggregationBitfield, data, aggregateSignature); + private final Attestation attestation = + schema.create(aggregationBitfield, data, aggregateSignature); @Test public void shouldBeDependentOnTargetBlockAndBeaconBlockRoot() { diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/AttesterSlashingTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/AttesterSlashingTest.java index 6ddc4704439..8326d117d3c 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/AttesterSlashingTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/AttesterSlashingTest.java @@ -20,7 +20,6 @@ import org.junit.jupiter.api.Test; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.TestSpecFactory; -import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing.AttesterSlashingSchema; import tech.pegasys.teku.spec.util.DataStructureUtil; class AttesterSlashingTest { @@ -34,7 +33,7 @@ class AttesterSlashingTest { private final IndexedAttestation indexedAttestation2 = dataStructureUtil.randomIndexedAttestation(); - private AttesterSlashing attesterSlashing = + private final AttesterSlashing attesterSlashing = attesterSlashingSchema.create(indexedAttestation1, indexedAttestation2); @Test diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/BlsToExecutionChangeTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/BlsToExecutionChangeTest.java index 99ef89e13a5..0a3a983a164 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/BlsToExecutionChangeTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/BlsToExecutionChangeTest.java @@ -20,17 +20,20 @@ import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.infrastructure.bytes.Bytes20; import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.util.DataStructureUtil; class BlsToExecutionChangeTest { - - private final DataStructureUtil dataStructureUtil = - new DataStructureUtil(TestSpecFactory.createMinimal(SpecMilestone.CAPELLA)); + private final Spec spec = TestSpecFactory.createMinimal(SpecMilestone.CAPELLA); + private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); private final BlsToExecutionChangeSchema blsToExecutionChangeSchema = - new BlsToExecutionChangeSchema(); + spec.getGenesisSchemaDefinitions() + .toVersionCapella() + .orElseThrow() + .getBlsToExecutionChangeSchema(); private final UInt64 validatorIndex = dataStructureUtil.randomUInt64(); private final BLSPublicKey fromBlsPubkey = dataStructureUtil.randomPublicKey(); diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/DepositDataTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/DepositDataTest.java index db25543adc0..af67cafa796 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/DepositDataTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/DepositDataTest.java @@ -27,12 +27,12 @@ class DepositDataTest { private final DataStructureUtil dataStructureUtil = new DataStructureUtil(TestSpecFactory.createDefault()); - private BLSPublicKey pubkey = dataStructureUtil.randomPublicKey(); - private Bytes32 withdrawalCredentials = dataStructureUtil.randomBytes32(); - private UInt64 amount = dataStructureUtil.randomUInt64(); - private BLSSignature signature = dataStructureUtil.randomSignature(); + private final BLSPublicKey pubkey = dataStructureUtil.randomPublicKey(); + private final Bytes32 withdrawalCredentials = dataStructureUtil.randomBytes32(); + private final UInt64 amount = dataStructureUtil.randomUInt64(); + private final BLSSignature signature = dataStructureUtil.randomSignature(); - private DepositData depositData = + private final DepositData depositData = new DepositData(pubkey, withdrawalCredentials, amount, signature); @Test diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/DepositMessageTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/DepositMessageTest.java index f64ea93ffa0..03dcd00ef7c 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/DepositMessageTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/DepositMessageTest.java @@ -26,9 +26,9 @@ class DepositMessageTest { private final DataStructureUtil dataStructureUtil = new DataStructureUtil(TestSpecFactory.createDefault()); - private BLSPublicKey pubkey = dataStructureUtil.randomPublicKey(); - private Bytes32 withdrawalCredentials = dataStructureUtil.randomBytes32(); - private UInt64 amount = dataStructureUtil.randomUInt64(); + private final BLSPublicKey pubkey = dataStructureUtil.randomPublicKey(); + private final Bytes32 withdrawalCredentials = dataStructureUtil.randomBytes32(); + private final UInt64 amount = dataStructureUtil.randomUInt64(); @Test public void shouldRoundTripViaSsz() { diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/DepositTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/DepositTest.java index 15493a63def..5769bfb7860 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/DepositTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/DepositTest.java @@ -22,7 +22,6 @@ import java.util.Collections; import java.util.List; import java.util.Objects; -import java.util.function.Supplier; import org.apache.tuweni.bytes.Bytes; import org.apache.tuweni.bytes.Bytes32; import org.apache.tuweni.junit.BouncyCastleExtension; @@ -37,10 +36,10 @@ class DepositTest { private final DataStructureUtil dataStructureUtil = new DataStructureUtil(TestSpecFactory.createDefault()); - private SszBytes32Vector branch = setupMerkleBranch(); - private DepositData depositData = dataStructureUtil.randomDepositData(); + private final SszBytes32Vector branch = setupMerkleBranch(); + private final DepositData depositData = dataStructureUtil.randomDepositData(); - private Deposit deposit = new Deposit(branch, depositData); + private final Deposit deposit = new Deposit(branch, depositData); @Test void equalsReturnsTrueWhenObjectsAreSame() { @@ -99,6 +98,6 @@ void vectorLengthsTest() { private SszBytes32Vector setupMerkleBranch() { return dataStructureUtil.randomSszBytes32Vector( - Deposit.SSZ_SCHEMA.getProofSchema(), (Supplier) Bytes32::random); + Deposit.SSZ_SCHEMA.getProofSchema(), Bytes32::random); } } diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/ProposerSlashingTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/ProposerSlashingTest.java index 75dd6a5ceb0..b28988b647c 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/ProposerSlashingTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/ProposerSlashingTest.java @@ -26,10 +26,12 @@ class ProposerSlashingTest { private final DataStructureUtil dataStructureUtil = new DataStructureUtil(TestSpecFactory.createDefault()); - private SignedBeaconBlockHeader proposal1 = dataStructureUtil.randomSignedBeaconBlockHeader(); - private SignedBeaconBlockHeader proposal2 = dataStructureUtil.randomSignedBeaconBlockHeader(); + private final SignedBeaconBlockHeader proposal1 = + dataStructureUtil.randomSignedBeaconBlockHeader(); + private final SignedBeaconBlockHeader proposal2 = + dataStructureUtil.randomSignedBeaconBlockHeader(); - private ProposerSlashing proposerSlashing = new ProposerSlashing(proposal1, proposal2); + private final ProposerSlashing proposerSlashing = new ProposerSlashing(proposal1, proposal2); @Test void equalsReturnsTrueWhenObjectAreSame() { diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/SignedBlsToExecutionChangeTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/SignedBlsToExecutionChangeTest.java index cb79569fee2..ca60de0e76a 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/SignedBlsToExecutionChangeTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/SignedBlsToExecutionChangeTest.java @@ -18,17 +18,20 @@ import org.apache.tuweni.bytes.Bytes; import org.junit.jupiter.api.Test; import tech.pegasys.teku.bls.BLSSignature; +import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.util.DataStructureUtil; class SignedBlsToExecutionChangeTest { - - private final DataStructureUtil dataStructureUtil = - new DataStructureUtil(TestSpecFactory.createMinimal(SpecMilestone.CAPELLA)); + private final Spec spec = TestSpecFactory.createMinimal(SpecMilestone.CAPELLA); + private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); private final SignedBlsToExecutionChangeSchema signedBlsToExecutionChangeSchema = - new SignedBlsToExecutionChangeSchema(); + spec.getGenesisSchemaDefinitions() + .toVersionCapella() + .orElseThrow() + .getSignedBlsToExecutionChangeSchema(); private final BlsToExecutionChange message = dataStructureUtil.randomBlsToExecutionChange(); diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/VoluntaryExitTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/VoluntaryExitTest.java index ff8c8555893..37201903707 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/VoluntaryExitTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/VoluntaryExitTest.java @@ -25,10 +25,10 @@ class VoluntaryExitTest { private final DataStructureUtil dataStructureUtil = new DataStructureUtil(TestSpecFactory.createDefault()); - private UInt64 epoch = dataStructureUtil.randomUInt64(); - private UInt64 validatorIndex = dataStructureUtil.randomUInt64(); + private final UInt64 epoch = dataStructureUtil.randomUInt64(); + private final UInt64 validatorIndex = dataStructureUtil.randomUInt64(); - private VoluntaryExit voluntaryExit = new VoluntaryExit(epoch, validatorIndex); + private final VoluntaryExit voluntaryExit = new VoluntaryExit(epoch, validatorIndex); @Test void equalsReturnsTrueWhenObjectsAreSame() { diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/WithdrawalRequestTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/WithdrawalRequestTest.java new file mode 100644 index 00000000000..f43b29088eb --- /dev/null +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/operations/WithdrawalRequestTest.java @@ -0,0 +1,66 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.datastructures.operations; + +import static org.assertj.core.api.Assertions.assertThat; + +import org.apache.tuweni.bytes.Bytes; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.infrastructure.bytes.Bytes20; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequestSchema; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +class WithdrawalRequestTest { + private final DataStructureUtil dataStructureUtil = + new DataStructureUtil(TestSpecFactory.createMinimal(SpecMilestone.ELECTRA)); + private final WithdrawalRequestSchema withdrawalRequestSchema = new WithdrawalRequestSchema(); + private final Bytes20 sourceAddress = dataStructureUtil.randomBytes20(); + private final BLSPublicKey validatorPubkey = dataStructureUtil.randomPublicKey(); + private final UInt64 amount = dataStructureUtil.randomUInt64(); + + @Test + public void objectEquality() { + final WithdrawalRequest withdrawalRequest1 = + withdrawalRequestSchema.create(sourceAddress, validatorPubkey, amount); + final WithdrawalRequest withdrawalRequest2 = + withdrawalRequestSchema.create(sourceAddress, validatorPubkey, amount); + + assertThat(withdrawalRequest1).isEqualTo(withdrawalRequest2); + } + + @Test + public void objectAccessorMethods() { + final WithdrawalRequest withdrawalRequest = + withdrawalRequestSchema.create(sourceAddress, validatorPubkey, amount); + + assertThat(withdrawalRequest.getSourceAddress()).isEqualTo(sourceAddress); + assertThat(withdrawalRequest.getValidatorPubkey()).isEqualTo(validatorPubkey); + } + + @Test + public void roundTripSSZ() { + final WithdrawalRequest withdrawalRequest = + withdrawalRequestSchema.create(sourceAddress, validatorPubkey, amount); + + final Bytes sszBytes = withdrawalRequest.sszSerialize(); + final WithdrawalRequest deserializedObject = withdrawalRequestSchema.sszDeserialize(sszBytes); + + assertThat(withdrawalRequest).isEqualTo(deserializedObject); + } +} diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/sostests/IsVariableTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/sostests/IsVariableTest.java index d23587fe4d5..9a74e4d9c87 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/sostests/IsVariableTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/sostests/IsVariableTest.java @@ -71,13 +71,13 @@ static Stream fixedSizeTypes() { @ParameterizedTest @MethodSource("variableSizeTypes") - void testTheTypeIsVariableSize(SszSchema type) { + void testTheTypeIsVariableSize(final SszSchema type) { assertFalse(type.isFixedSize()); } @ParameterizedTest @MethodSource("fixedSizeTypes") - void testTheTypeIsFixedSize(SszSchema type) { + void testTheTypeIsFixedSize(final SszSchema type) { assertTrue(type.isFixedSize()); } } diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/ForkTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/ForkTest.java index 64bf8eac43d..5c7ca508335 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/ForkTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/ForkTest.java @@ -26,11 +26,11 @@ class ForkTest { private final DataStructureUtil dataStructureUtil = new DataStructureUtil(TestSpecFactory.createDefault()); - private Bytes4 previousVersion = new Bytes4(Bytes.of(1, 2, 3, 4)); - private Bytes4 currentVersion = new Bytes4(Bytes.of(5, 6, 7, 8)); - private UInt64 epoch = dataStructureUtil.randomUInt64(); + private final Bytes4 previousVersion = new Bytes4(Bytes.of(1, 2, 3, 4)); + private final Bytes4 currentVersion = new Bytes4(Bytes.of(5, 6, 7, 8)); + private final UInt64 epoch = dataStructureUtil.randomUInt64(); - private Fork fork = new Fork(previousVersion, currentVersion, epoch); + private final Fork fork = new Fork(previousVersion, currentVersion, epoch); @Test void equalsReturnsTrueWhenObjectAreSame() { diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/ValidatorTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/ValidatorTest.java index 591456793e1..67fdcef032c 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/ValidatorTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/ValidatorTest.java @@ -29,17 +29,17 @@ class ValidatorTest { private final DataStructureUtil dataStructureUtil = new DataStructureUtil(TestSpecFactory.createDefault()); - private int seed = 100; - private Bytes48 pubkey = BLSTestUtil.randomPublicKey(seed).toBytesCompressed(); - private Bytes32 withdrawalCredentials = dataStructureUtil.randomBytes32(); - private UInt64 activationEligibilityEpoch = dataStructureUtil.randomUInt64(); - private UInt64 activationEpoch = dataStructureUtil.randomUInt64(); - private UInt64 exitEpoch = dataStructureUtil.randomUInt64(); - private UInt64 withdrawalEpoch = dataStructureUtil.randomUInt64(); - private boolean slashed = false; - private UInt64 effectiveBalance = dataStructureUtil.randomUInt64(); - - private Validator validator = + private final int seed = 100; + private final Bytes48 pubkey = BLSTestUtil.randomPublicKey(seed).toBytesCompressed(); + private final Bytes32 withdrawalCredentials = dataStructureUtil.randomBytes32(); + private final UInt64 activationEligibilityEpoch = dataStructureUtil.randomUInt64(); + private final UInt64 activationEpoch = dataStructureUtil.randomUInt64(); + private final UInt64 exitEpoch = dataStructureUtil.randomUInt64(); + private final UInt64 withdrawalEpoch = dataStructureUtil.randomUInt64(); + private final boolean slashed = false; + private final UInt64 effectiveBalance = dataStructureUtil.randomUInt64(); + + private final Validator validator = new Validator( pubkey, withdrawalCredentials, diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/AbstractBeaconStateSchemaTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/AbstractBeaconStateSchemaTest.java index f83b19ee38c..015ac23ba02 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/AbstractBeaconStateSchemaTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/AbstractBeaconStateSchemaTest.java @@ -70,18 +70,19 @@ void vectorLengthsTest() { @Test public void changeSpecConfigTest() { - final Spec standardSpec = TestSpecFactory.createMinimalPhase0(); + final Spec standardSpec = TestSpecFactory.createMinimal(genesisConfig.getMilestone()); final SpecConfig modifiedConfig = SpecConfigLoader.loadConfig( - "minimal", - b -> - b.slotsPerHistoricalRoot(123) - .historicalRootsLimit(123) - .epochsPerEth1VotingPeriod(123) - .validatorRegistryLimit(123L) - .epochsPerHistoricalVector(123) - .epochsPerSlashingsVector(123) - .maxAttestations(123)); + "minimal", + b -> + b.slotsPerHistoricalRoot(123) + .historicalRootsLimit(123) + .epochsPerEth1VotingPeriod(123) + .validatorRegistryLimit(123L) + .epochsPerHistoricalVector(123) + .epochsPerSlashingsVector(123) + .maxAttestations(123)) + .specConfig(); BeaconState s1 = getSchema(modifiedConfig).createEmpty(); BeaconState s2 = getSchema(standardSpec.getGenesisSpecConfig()).createEmpty(); @@ -109,9 +110,11 @@ void roundTripViaSsz() { @Test public void create_compareDifferentSpecs() { final BeaconStateSchema minimalState = - getSchema(TestSpecFactory.createMinimalPhase0().getGenesisSpecConfig()); + getSchema( + TestSpecFactory.createMinimal(genesisConfig.getMilestone()).getGenesisSpecConfig()); final BeaconStateSchema mainnetState = - getSchema(TestSpecFactory.createMainnetPhase0().getGenesisSpecConfig()); + getSchema( + TestSpecFactory.createMainnet(genesisConfig.getMilestone()).getGenesisSpecConfig()); assertThat(minimalState).isNotEqualTo(mainnetState); } diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/AbstractBeaconStateTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/AbstractBeaconStateTest.java index bc4a60e9c50..18421bada2e 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/AbstractBeaconStateTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/AbstractBeaconStateTest.java @@ -24,6 +24,7 @@ import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconStateSchema; import tech.pegasys.teku.spec.datastructures.state.beaconstate.MutableBeaconState; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; import tech.pegasys.teku.spec.util.DataStructureUtil; @ExtendWith(BouncyCastleExtension.class) @@ -35,10 +36,12 @@ public abstract class AbstractBeaconStateTest< protected abstract Spec createSpec(); private final SpecConfig genesisConfig = spec.getGenesisSpecConfig(); - private final BeaconStateSchema schema = getSchema(genesisConfig); + private final BeaconStateSchema schema = + getSchema(genesisConfig, spec.getGenesisSchemaDefinitions().getSchemaRegistry()); protected DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); - protected abstract BeaconStateSchema getSchema(final SpecConfig specConfig); + protected abstract BeaconStateSchema getSchema( + final SpecConfig specConfig, final SchemaRegistry schemaRegistry); protected abstract T randomState(); diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/ValidatorIndexCacheTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/ValidatorIndexCacheTest.java index 3e09ce9b3c8..7a3d9e2276a 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/ValidatorIndexCacheTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/common/ValidatorIndexCacheTest.java @@ -16,12 +16,12 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.never; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import java.util.Optional; +import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.infrastructure.collections.cache.Cache; @@ -73,7 +73,7 @@ public void shouldScanFinalizedStateAndCache() { assertThat(index).hasValue(latestFinalizedIndex); - assertThat(validatorIndexCache.getValidatorIndices().size()).isEqualTo(NUMBER_OF_VALIDATORS); + assertThat(validatorIndexCache.getCacheSize()).isEqualTo(NUMBER_OF_VALIDATORS); assertThat(validatorIndexCache.getLastCachedIndex()).isEqualTo(latestFinalizedIndex); } @@ -86,6 +86,8 @@ public void shouldStartScanningFinalizedStateFromLastCachedIndex() { new ValidatorIndexCache(cache, latestFinalizedIndex, lastCachedIndex); when(cache.getCached(any())).thenReturn(Optional.empty()); + // mock cache needs to report the size changed + when(cache.size()).thenReturn(31).thenReturn(32); final Optional index = validatorIndexCache.getValidatorIndex( @@ -98,25 +100,6 @@ public void shouldStartScanningFinalizedStateFromLastCachedIndex() { assertThat(validatorIndexCache.getLastCachedIndex()).isEqualTo(latestFinalizedIndex); } - @Test - public void shouldScanNonFinalizedStateButDoNotCacheIfIndexNotFoundInFinalizedState() { - final SszList validators = state.getValidators(); - final int latestFinalizedIndex = 31; - final ValidatorIndexCache validatorIndexCache = - new ValidatorIndexCache(cache, latestFinalizedIndex, latestFinalizedIndex); - - when(cache.getCached(any())).thenReturn(Optional.empty()); - - final Optional index = - validatorIndexCache.getValidatorIndex( - state, validators.get(NUMBER_OF_VALIDATORS - 1).getPublicKey()); - - verify(cache, never()).invalidateWithNewValue(any(), any()); - assertThat(index).hasValue(NUMBER_OF_VALIDATORS - 1); - - assertThat(validatorIndexCache.getLastCachedIndex()).isEqualTo(latestFinalizedIndex); - } - @Test public void shouldReturnEmptyIfPubkeyNotFoundInState() { final ValidatorIndexCache validatorIndexCache = new ValidatorIndexCache(); @@ -126,7 +109,7 @@ public void shouldReturnEmptyIfPubkeyNotFoundInState() { validatorIndexCache.getValidatorIndex(state, dataStructureUtil.randomPublicKey()); // all keys were cached - assertThat(validatorIndexCache.getValidatorIndices().size()).isEqualTo(NUMBER_OF_VALIDATORS); + assertThat(validatorIndexCache.getCacheSize()).isEqualTo(NUMBER_OF_VALIDATORS); assertThat(index).isEmpty(); } @@ -150,11 +133,12 @@ public void shouldInvalidatePublicKeyIfFinalized() { final BLSPublicKey updatedPublicKey = dataStructureUtil.randomPublicKey(); validatorIndexCache.invalidateWithNewValue(updatedPublicKey, 30); - assertThat(validatorIndexCache.getValidatorIndices().size()).isOne(); + assertThat(validatorIndexCache.getCacheSize()).isOne(); assertThat(validatorIndexCache.getValidatorIndex(state, updatedPublicKey)).hasValue(30); } @Test + @Disabled public void shouldNotInvalidatePublicKeyIfIndexIsNotFinalized() { final ValidatorIndexCache validatorIndexCache = new ValidatorIndexCache(); @@ -162,7 +146,22 @@ public void shouldNotInvalidatePublicKeyIfIndexIsNotFinalized() { validatorIndexCache.invalidateWithNewValue(updatedPublicKey, 30); // nothing has been cached because the state is not finalized - assertThat(validatorIndexCache.getValidatorIndices().size()).isZero(); + assertThat(validatorIndexCache.getCacheSize()).isZero(); assertThat(validatorIndexCache.getValidatorIndex(state, updatedPublicKey)).isEmpty(); } + + @Test + public void noopCacheShouldFindTheSameIndexMoreThanOnce() { + final int validatorIndex = 2; + assertThat(ValidatorIndexCache.NO_OP_INSTANCE.getLastCachedIndex()).isEqualTo(-1); + assertThat( + ValidatorIndexCache.NO_OP_INSTANCE.getValidatorIndex( + state, state.getValidators().get(validatorIndex).getPublicKey())) + .contains(validatorIndex); + assertThat(ValidatorIndexCache.NO_OP_INSTANCE.getLastCachedIndex()).isEqualTo(-1); + assertThat( + ValidatorIndexCache.NO_OP_INSTANCE.getValidatorIndex( + state, state.getValidators().get(validatorIndex).getPublicKey())) + .contains(validatorIndex); + } } diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/BeaconStateAltairTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/BeaconStateAltairTest.java index b41b409958f..d4ec14d4a8b 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/BeaconStateAltairTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/BeaconStateAltairTest.java @@ -18,6 +18,7 @@ import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconStateSchema; import tech.pegasys.teku.spec.datastructures.state.beaconstate.common.AbstractBeaconStateTest; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; public class BeaconStateAltairTest extends AbstractBeaconStateTest { @@ -29,7 +30,7 @@ protected Spec createSpec() { @Override protected BeaconStateSchema getSchema( - final SpecConfig specConfig) { + final SpecConfig specConfig, final SchemaRegistry schemaRegistry) { return BeaconStateSchemaAltair.create(specConfig); } diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/BeaconStateSchemaAltairTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/BeaconStateSchemaAltairTest.java index 1ed45ba5087..edfa58c135d 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/BeaconStateSchemaAltairTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/altair/BeaconStateSchemaAltairTest.java @@ -60,9 +60,9 @@ protected BeaconStateAltair randomState() { @Test public void changeSpecConfigTest_checkAltairFields() { - final Spec standardSpec = TestSpecFactory.createMinimalPhase0(); + final Spec standardSpec = TestSpecFactory.createMinimalAltair(); final SpecConfig modifiedConstants = - SpecConfigLoader.loadConfig("minimal", b -> b.validatorRegistryLimit(123L)); + SpecConfigLoader.loadConfig("minimal", b -> b.validatorRegistryLimit(123L)).specConfig(); BeaconStateAltair s1 = getSchema(modifiedConstants).createEmpty(); BeaconStateAltair s2 = getSchema(standardSpec.getGenesisSpecConfig()).createEmpty(); diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/capella/BeaconStateCapellaTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/capella/BeaconStateCapellaTest.java index 6732d27e343..e5d9f69e4a2 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/capella/BeaconStateCapellaTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/capella/BeaconStateCapellaTest.java @@ -18,6 +18,7 @@ import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconStateSchema; import tech.pegasys.teku.spec.datastructures.state.beaconstate.common.AbstractBeaconStateTest; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; public class BeaconStateCapellaTest extends AbstractBeaconStateTest { @@ -28,8 +29,8 @@ protected Spec createSpec() { @Override protected BeaconStateSchema getSchema( - final SpecConfig specConfig) { - return BeaconStateSchemaCapella.create(specConfig); + final SpecConfig specConfig, final SchemaRegistry schemaRegistry) { + return BeaconStateSchemaCapella.create(specConfig, schemaRegistry); } @Override diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/phase0/BeaconStatePhase0Test.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/phase0/BeaconStatePhase0Test.java index ed7436a957c..5412571cd77 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/phase0/BeaconStatePhase0Test.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/phase0/BeaconStatePhase0Test.java @@ -18,6 +18,7 @@ import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconStateSchema; import tech.pegasys.teku.spec.datastructures.state.beaconstate.common.AbstractBeaconStateTest; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistry; public class BeaconStatePhase0Test extends AbstractBeaconStateTest { @@ -29,7 +30,7 @@ protected Spec createSpec() { @Override protected BeaconStateSchema getSchema( - final SpecConfig specConfig) { + final SpecConfig specConfig, final SchemaRegistry schemaRegistry) { return BeaconStateSchemaPhase0.create(specConfig); } diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/phase0/BeaconStateSchemaPhase0Test.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/phase0/BeaconStateSchemaPhase0Test.java index 3c8834462a0..9d0897377c9 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/phase0/BeaconStateSchemaPhase0Test.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/datastructures/state/beaconstate/versions/phase0/BeaconStateSchemaPhase0Test.java @@ -46,7 +46,7 @@ protected BeaconStatePhase0 randomState() { public void changeSpecConfigTest_checkPhase0Fields() { final Spec standardSpec = TestSpecFactory.createMinimalPhase0(); final SpecConfig modifiedConfig = - SpecConfigLoader.loadConfig("minimal", b -> b.maxAttestations(123)); + SpecConfigLoader.loadConfig("minimal", b -> b.maxAttestations(123)).specConfig(); BeaconStatePhase0 s1 = getSchema(modifiedConfig).createEmpty(); BeaconStatePhase0 s2 = getSchema(standardSpec.getGenesisSpecConfig()).createEmpty(); diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/genesis/GenesisGeneratorTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/genesis/GenesisGeneratorTest.java index f5ce021ef0e..024d9991d0a 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/genesis/GenesisGeneratorTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/genesis/GenesisGeneratorTest.java @@ -22,7 +22,6 @@ import java.util.Collections; import java.util.List; import java.util.Optional; -import java.util.stream.IntStream; import org.apache.tuweni.bytes.Bytes32; import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; @@ -58,37 +57,33 @@ class GenesisGeneratorTest { new MockStartDepositGenerator(spec, new DepositGenerator(spec, true)) .createDeposits(VALIDATOR_KEYS); private final List initialDeposits = - IntStream.range(0, initialDepositData.size()) - .mapToObj( - index -> { - final DepositData data = initialDepositData.get(index); - return new DepositWithIndex(data, UInt64.valueOf(index)); - }) - .collect(toList()); + initialDepositData.stream().map(Deposit::new).toList(); @Test void initializeBeaconStateFromEth1_shouldIgnoreInvalidSignedDeposits() { - List deposits = dataStructureUtil.randomDeposits(3); - DepositWithIndex deposit = deposits.get(1); - DepositData depositData = deposit.getData(); + List depositsWithIndex = dataStructureUtil.randomDepositsWithIndex(3); + DepositWithIndex deposit = depositsWithIndex.get(1); + DepositData depositData = deposit.deposit().getData(); DepositWithIndex invalidSigDeposit = new DepositWithIndex( - new DepositData( - depositData.getPubkey(), - depositData.getWithdrawalCredentials(), - depositData.getAmount(), - BLSSignature.empty()), - deposit.getIndex()); - deposits.set(1, invalidSigDeposit); + new Deposit( + new DepositData( + depositData.getPubkey(), + depositData.getWithdrawalCredentials(), + depositData.getAmount(), + BLSSignature.empty())), + deposit.index()); + depositsWithIndex.set(1, invalidSigDeposit); + List deposits = depositsWithIndex.stream().map(DepositWithIndex::deposit).toList(); BeaconState state = spec.initializeBeaconStateFromEth1(Bytes32.ZERO, UInt64.ZERO, deposits, Optional.empty()); assertEquals(2, state.getValidators().size()); assertEquals( - deposits.get(0).getData().getPubkey().toBytesCompressed(), + depositsWithIndex.get(0).deposit().getData().getPubkey().toBytesCompressed(), state.getValidators().get(0).getPubkeyBytes()); assertEquals( - deposits.get(2).getData().getPubkey().toBytesCompressed(), + depositsWithIndex.get(2).deposit().getData().getPubkey().toBytesCompressed(), state.getValidators().get(1).getPubkeyBytes()); } @@ -145,14 +140,7 @@ public void shouldActivateToppedUpValidator() { List initialDepositData = List.of(partialDepositData, topUpDepositData); - List initialDeposits = - IntStream.range(0, initialDepositData.size()) - .mapToObj( - index -> { - final DepositData data = initialDepositData.get(index); - return new DepositWithIndex(data, UInt64.valueOf(index)); - }) - .collect(toList()); + List initialDeposits = initialDepositData.stream().map(Deposit::new).collect(toList()); genesisGenerator.updateCandidateState(Bytes32.ZERO, UInt64.ZERO, initialDeposits); diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/StateUpgradeTransitionTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/StateUpgradeTransitionTest.java index d652fe3c9ab..3366df13d24 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/StateUpgradeTransitionTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/StateUpgradeTransitionTest.java @@ -15,7 +15,6 @@ import static org.assertj.core.api.Assertions.assertThat; -import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Optional; @@ -31,14 +30,14 @@ import tech.pegasys.teku.spec.TestSpecInvocationContextProvider.SpecContext; import tech.pegasys.teku.spec.datastructures.interop.MockStartDepositGenerator; import tech.pegasys.teku.spec.datastructures.interop.MockStartValidatorKeyPairFactory; +import tech.pegasys.teku.spec.datastructures.operations.Deposit; import tech.pegasys.teku.spec.datastructures.operations.DepositData; -import tech.pegasys.teku.spec.datastructures.operations.DepositWithIndex; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.altair.BeaconStateAltair; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.bellatrix.BeaconStateBellatrix; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.capella.BeaconStateCapella; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.deneb.BeaconStateDeneb; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.eip7594.BeaconStateEip7594; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.BeaconStateElectra; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.phase0.BeaconStatePhase0; import tech.pegasys.teku.spec.datastructures.util.DepositGenerator; @@ -48,7 +47,7 @@ SpecMilestone.BELLATRIX, SpecMilestone.CAPELLA, SpecMilestone.DENEB, - SpecMilestone.EIP7594 + SpecMilestone.ELECTRA }, doNotGenerateSpec = true) public class StateUpgradeTransitionTest { @@ -65,7 +64,7 @@ public class StateUpgradeTransitionTest { private Class afterBeaconStateClass; @BeforeEach - public void setup(SpecContext specContext) { + public void setup(final SpecContext specContext) { final Spec spec = switch (specContext.getSpecMilestone()) { case PHASE0 -> throw new IllegalArgumentException("Phase0 is an unsupported milestone"); @@ -89,10 +88,15 @@ public void setup(SpecContext specContext) { afterBeaconStateClass = BeaconStateDeneb.class; yield TestSpecFactory.createMinimalWithDenebForkEpoch(milestoneTransitionEpoch); } - case EIP7594 -> { + case ELECTRA -> { beforeBeaconStateClass = BeaconStateDeneb.class; - afterBeaconStateClass = BeaconStateEip7594.class; - yield TestSpecFactory.createMinimalWithEip7594ForkEpoch(milestoneTransitionEpoch); + afterBeaconStateClass = BeaconStateElectra.class; + yield TestSpecFactory.createMinimalWithElectraForkEpoch(milestoneTransitionEpoch); + } + case FULU -> { + beforeBeaconStateClass = BeaconStateElectra.class; + afterBeaconStateClass = BeaconStateElectra.class; + yield TestSpecFactory.createMinimalWithElectraForkEpoch(milestoneTransitionEpoch); } }; @@ -135,12 +139,7 @@ private BeaconState createGenesis(final Spec spec) { new MockStartDepositGenerator(spec, new DepositGenerator(spec, true)) .createDeposits(VALIDATOR_KEYS, spec.getGenesisSpecConfig().getMaxEffectiveBalance()); - final List deposits = new ArrayList<>(); - for (int index = 0; index < initialDepositData.size(); index++) { - final DepositData data = initialDepositData.get(index); - DepositWithIndex deposit = new DepositWithIndex(data, UInt64.valueOf(index)); - deposits.add(deposit); - } + final List deposits = initialDepositData.stream().map(Deposit::new).toList(); final BeaconState initialState = spec.initializeBeaconStateFromEth1(Bytes32.ZERO, UInt64.ZERO, deposits, Optional.empty()); return initialState.updated(state -> state.setGenesisTime(UInt64.ZERO)); diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/block/BlockProcessorTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/block/BlockProcessorTest.java index 37ff3c44a46..4b146409389 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/block/BlockProcessorTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/block/BlockProcessorTest.java @@ -31,13 +31,13 @@ import tech.pegasys.teku.infrastructure.ssz.schema.SszListSchema; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.SpecVersion; import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.datastructures.blocks.Eth1Data; import tech.pegasys.teku.spec.datastructures.operations.Deposit; import tech.pegasys.teku.spec.datastructures.operations.DepositData; import tech.pegasys.teku.spec.datastructures.operations.DepositMessage; -import tech.pegasys.teku.spec.datastructures.operations.DepositWithIndex; import tech.pegasys.teku.spec.datastructures.state.Fork; import tech.pegasys.teku.spec.datastructures.state.Validator; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; @@ -51,7 +51,7 @@ public abstract class BlockProcessorTest { protected final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); private final SpecVersion genesisSpec = spec.getGenesisSpec(); - private final SpecConfig specConfig = genesisSpec.getConfig(); + protected final SpecConfig specConfig = genesisSpec.getConfig(); private final BlockProcessor blockProcessor = genesisSpec.getBlockProcessor(); protected abstract Spec createSpec(); @@ -63,7 +63,7 @@ void ensureDepositSignatureVerifierHasDefaultValue() { } @Test - void processDepositAddsNewValidatorWhenPubkeyIsNotFoundInRegistry() + public void processDepositAddsNewValidatorWhenPubkeyIsNotFoundInRegistry() throws BlockProcessingException { // Create a deposit DepositData depositInput = dataStructureUtil.randomDepositData(); @@ -86,14 +86,21 @@ void processDepositAddsNewValidatorWhenPubkeyIsNotFoundInRegistry() postState.getBalances().size(), originalValidatorBalancesSize + 1, "No balance was added to the validator balances."); - assertEquals( - makeValidator(pubkey, withdrawalCredentials), - postState.getValidators().get(originalValidatorRegistrySize)); - assertEquals(amount, postState.getBalances().getElement(originalValidatorBalancesSize)); + if (spec.atSlot(postState.getSlot()).getMilestone().equals(SpecMilestone.ELECTRA)) { + assertEquals( + makeValidator(pubkey, withdrawalCredentials).withEffectiveBalance(UInt64.ZERO), + postState.getValidators().get(originalValidatorRegistrySize)); + assertEquals(UInt64.ZERO, postState.getBalances().getElement(originalValidatorBalancesSize)); + } else { + assertEquals( + makeValidator(pubkey, withdrawalCredentials), + postState.getValidators().get(originalValidatorRegistrySize)); + assertEquals(amount, postState.getBalances().getElement(originalValidatorBalancesSize)); + } } @Test - void processDepositTopsUpValidatorBalanceWhenPubkeyIsFoundInRegistry() + public void processDepositTopsUpValidatorBalanceWhenPubkeyIsFoundInRegistry() throws BlockProcessingException { // Create a deposit DepositData depositInput = dataStructureUtil.randomDepositData(); @@ -203,12 +210,12 @@ protected BeaconState createBeaconState() { return createBeaconState(false, null, null); } - private BeaconState createBeaconState(UInt64 amount, Validator knownValidator) { + protected BeaconState createBeaconState(final UInt64 amount, final Validator knownValidator) { return createBeaconState(true, amount, knownValidator); } protected BeaconState createBeaconState( - boolean addToList, UInt64 amount, Validator knownValidator) { + final boolean addToList, final UInt64 amount, final Validator knownValidator) { return spec.getGenesisSpec() .getSchemaDefinitions() .getBeaconStateSchema() @@ -245,30 +252,31 @@ protected BeaconState createBeaconState( }); } - private BeaconState processDepositHelper(BeaconState beaconState, DepositData depositData) + protected BeaconState processDepositHelper( + final BeaconState beaconState, final DepositData depositData) throws BlockProcessingException { // Add the deposit to a Merkle tree so that we can get the root to put into the state Eth1 data MerkleTree depositMerkleTree = new MerkleTree(specConfig.getDepositContractTreeDepth()); depositMerkleTree.add(depositData.hashTreeRoot()); - beaconState = + final BeaconState updatedBeaconState = beaconState.updated( state -> state.setEth1Data( new Eth1Data(depositMerkleTree.getRoot(), UInt64.valueOf(1), Bytes32.ZERO))); SszListSchema schema = - SszListSchema.create(DepositWithIndex.SSZ_SCHEMA, specConfig.getMaxDeposits()); + SszListSchema.create(Deposit.SSZ_SCHEMA, specConfig.getMaxDeposits()); SszBytes32Vector proof = Deposit.SSZ_SCHEMA.getProofSchema().of(depositMerkleTree.getProof(0)); - SszList deposits = - schema.of(new DepositWithIndex(proof, depositData, UInt64.valueOf(0))); + SszList deposits = schema.of(new Deposit(proof, depositData)); // Attempt to process deposit with above data. - return beaconState.updated(state -> blockProcessor.processDeposits(state, deposits)); + return updatedBeaconState.updated(state -> blockProcessor.processDeposits(state, deposits)); } - protected Validator makeValidator(BLSPublicKey pubkey, Bytes32 withdrawalCredentials) { + protected Validator makeValidator( + final BLSPublicKey pubkey, final Bytes32 withdrawalCredentials) { return makeValidator( pubkey, withdrawalCredentials, SpecConfig.FAR_FUTURE_EPOCH, SpecConfig.FAR_FUTURE_EPOCH); } diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/helpers/BeaconStateAccessorsTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/helpers/BeaconStateAccessorsTest.java index 8fb520913fb..a752058137b 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/helpers/BeaconStateAccessorsTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/helpers/BeaconStateAccessorsTest.java @@ -21,6 +21,7 @@ import static tech.pegasys.teku.spec.config.SpecConfig.GENESIS_EPOCH; import static tech.pegasys.teku.spec.config.SpecConfig.GENESIS_SLOT; +import it.unimi.dsi.fastutil.ints.Int2IntMap; import it.unimi.dsi.fastutil.ints.IntList; import org.junit.jupiter.api.Test; import tech.pegasys.teku.infrastructure.unsigned.UInt64; @@ -130,6 +131,32 @@ public void getBeaconCommittee_stateIsNewerThanSlot() { assertDoesNotThrow(() -> beaconStateAccessors.getBeaconCommittee(state, oldSlot, ONE)); } + @Test + public void getBeaconCommitteesSize_stateIsTooOld() { + final UInt64 epoch = ONE; + final UInt64 epochSlot = spec.computeStartSlotAtEpoch(epoch); + final BeaconState state = dataStructureUtil.randomBeaconState(epochSlot); + + final UInt64 outOfRangeSlot = spec.computeStartSlotAtEpoch(epoch.plus(2)); + assertThatThrownBy(() -> beaconStateAccessors.getBeaconCommitteesSize(state, outOfRangeSlot)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessageContaining( + "Committee information must be derived from a state no older than the previous epoch"); + } + + @Test + public void getBeaconCommitteesSize_hasTheSizeOfTheCommitteeCount() { + final BeaconState state = dataStructureUtil.randomBeaconState(); + final UInt64 epoch = spec.computeEpochAtSlot(state.getSlot()); + + final Int2IntMap committeesSize = + beaconStateAccessors.getBeaconCommitteesSize(state, state.getSlot()); + + final UInt64 committeeCount = beaconStateAccessors.getCommitteeCountPerSlot(state, epoch); + + assertThat(committeesSize).hasSize(committeeCount.intValue()); + } + @Test void calculateCommitteeFraction_full() { final BeaconState state = dataStructureUtil.randomBeaconState(1024); diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/helpers/MiscHelpersTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/helpers/MiscHelpersTest.java index 65ac51aa561..7a4df053154 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/helpers/MiscHelpersTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/helpers/MiscHelpersTest.java @@ -34,8 +34,10 @@ import org.junit.jupiter.params.provider.MethodSource; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.networks.Eth2Network; import tech.pegasys.teku.spec.util.DataStructureUtil; class MiscHelpersTest { @@ -173,7 +175,7 @@ public void isSlotAtNthEpochBoundary_invalidNParameter_negative() { @ParameterizedTest @MethodSource("provideSubnetsForNodeIds") public void testDiscoveryNodeBasedSubnetIds( - final UInt256 nodeId, final UInt64 epoch, List subnetIds) { + final UInt256 nodeId, final UInt64 epoch, final List subnetIds) { final List nodeSubnetIds = miscHelpers.computeSubscribedSubnets(nodeId, epoch); assertThat(nodeSubnetIds).hasSize(subnetIds.size()); assertThat(nodeSubnetIds).isEqualTo(subnetIds); @@ -218,7 +220,8 @@ public void computesTimeAtSlot(final UInt64 slot, final long expectedTime) { @ParameterizedTest @MethodSource("getCommitteeComputationArguments") - public void committeeComputationShouldNotOverflow(int activeValidatorsCount, int committeeIndex) { + public void committeeComputationShouldNotOverflow( + final int activeValidatorsCount, final int committeeIndex) { final IntList indices = IntList.of(IntStream.range(0, activeValidatorsCount).toArray()); Assertions.assertDoesNotThrow( () -> { @@ -231,6 +234,20 @@ public void committeeComputationShouldNotOverflow(int activeValidatorsCount, int }); } + @Test + public void isFormerDepositMechanismDisabled_returnsFalseForAllForksPriorToElectra() { + SpecMilestone.getAllPriorMilestones(SpecMilestone.ELECTRA) + .forEach( + milestone -> { + final Spec spec = TestSpecFactory.create(milestone, Eth2Network.MINIMAL); + final MiscHelpers miscHelpers = spec.atSlot(UInt64.ZERO).miscHelpers(); + assertThat( + miscHelpers.isFormerDepositMechanismDisabled( + dataStructureUtil.randomBeaconState())) + .isFalse(); + }); + } + public static Stream getComputesSlotAtTimeArguments() { // 6 seconds per slot return Stream.of( diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/helpers/PredicatesTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/helpers/PredicatesTest.java index 07c9465a107..e620c99d2ce 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/helpers/PredicatesTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/helpers/PredicatesTest.java @@ -22,6 +22,7 @@ import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; +import tech.pegasys.teku.ethereum.execution.types.Eth1Address; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; @@ -31,6 +32,7 @@ import tech.pegasys.teku.spec.util.DataStructureUtil; public class PredicatesTest { + private Predicates predicates; private static final Spec SPEC = TestSpecFactory.createMainnet(SpecMilestone.CAPELLA); private static final SpecConfigCapella SPEC_CONFIG_CAPELLA = @@ -46,6 +48,38 @@ public void before() { this.predicates = new Predicates(SPEC_CONFIG_CAPELLA); } + @ParameterizedTest + @MethodSource("getExecutionAddressUncheckedArgs") + public void getExecutionAddressUnchecked(final Validator validator) { + final Eth1Address executionAddress = + Predicates.getExecutionAddressUnchecked(validator.getWithdrawalCredentials()); + assertThat(executionAddress) + .isEqualTo(Eth1Address.fromBytes(validator.getWithdrawalCredentials().slice(12))); + } + + private static Stream getExecutionAddressUncheckedArgs() { + final Bytes32 eth1WithdrawalCredentials = DATA_STRUCTURE_UTIL.randomEth1WithdrawalCredentials(); + final Bytes32 compoundingWithdrawalCredentials = + DATA_STRUCTURE_UTIL.randomCompoundingWithdrawalCredentials(); + // Even though it does not make sense to extract Eth1 address from blsWithdrawalCredentials, the + // method does not check for it so it will return the last 20 bytes of "anything". + final Bytes32 blsWithdrawalCredentials = DATA_STRUCTURE_UTIL.randomBlsWithdrawalCredentials(); + + return Stream.of( + Arguments.of( + DATA_STRUCTURE_UTIL + .randomValidator() + .withWithdrawalCredentials(eth1WithdrawalCredentials)), + Arguments.of( + DATA_STRUCTURE_UTIL + .randomValidator() + .withWithdrawalCredentials(compoundingWithdrawalCredentials)), + Arguments.of( + DATA_STRUCTURE_UTIL + .randomValidator() + .withWithdrawalCredentials(blsWithdrawalCredentials))); + } + @Test public void hasEth1WithdrawalCredentialShouldReturnTrueForValidatorWithEth1WithdrawalCredentials() { @@ -74,7 +108,7 @@ public void isFullyWithdrawableValidator( final UInt64 withdrawableEpoch, final UInt64 balance, final UInt64 epoch, - boolean expectedValue) { + final boolean expectedValue) { final Validator validator = DATA_STRUCTURE_UTIL @@ -143,7 +177,7 @@ public void isPartiallyWithdrawableValidator( final Bytes32 withdrawalCredentials, final UInt64 effectiveBalance, final UInt64 balance, - boolean expectedValue) { + final boolean expectedValue) { final Validator validator = DATA_STRUCTURE_UTIL diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/statetransition/blockvalidator/BatchSignatureVerifierTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/statetransition/blockvalidator/BatchSignatureVerifierTest.java index 89ea5b3ff97..2d3d96b2758 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/statetransition/blockvalidator/BatchSignatureVerifierTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/statetransition/blockvalidator/BatchSignatureVerifierTest.java @@ -23,7 +23,6 @@ import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; -import java.util.stream.Collectors; import java.util.stream.IntStream; import org.apache.tuweni.bytes.Bytes; import org.junit.jupiter.api.Test; @@ -86,7 +85,7 @@ public void testParallel() throws Exception { } return ret; })) - .collect(Collectors.toList()); + .toList(); for (Future future : futures) { assertThat(future.get()).isTrue(); diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/statetransition/epoch/AbstractEpochProcessorTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/statetransition/epoch/AbstractEpochProcessorTest.java index b781689315f..97f9dafe3c9 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/statetransition/epoch/AbstractEpochProcessorTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/statetransition/epoch/AbstractEpochProcessorTest.java @@ -15,7 +15,6 @@ import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyString; -import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.times; @@ -23,12 +22,14 @@ import static org.mockito.Mockito.when; import java.lang.reflect.Field; +import java.time.Duration; import org.apache.logging.log4j.Logger; import org.junit.jupiter.api.Test; import org.junit.platform.commons.util.ReflectionUtils; import org.junit.platform.commons.util.ReflectionUtils.HierarchyTraversalMode; import tech.pegasys.teku.infrastructure.ssz.collections.SszPrimitiveVector; import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; +import tech.pegasys.teku.infrastructure.time.StubTimeProvider; import tech.pegasys.teku.infrastructure.time.Throttler; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; @@ -42,29 +43,29 @@ class AbstractEpochProcessorTest { private final Spec spec = TestSpecFactory.createMinimalCapella(); private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); + private final StubTimeProvider timeProvider = StubTimeProvider.withTimeInSeconds(100_000L); private final EpochProcessorCapella epochProcessor = - (EpochProcessorCapella) spec.getGenesisSpec().getEpochProcessor(); + new EpochProcessorCapella( + (EpochProcessorCapella) spec.getGenesisSpec().getEpochProcessor(), timeProvider); - private final int throttlingPeriod = 1; // expect maximum of one call per epoch + private final int throttlingPeriod = 1; // expect maximum of one call per second private static final Logger LOGGER = mock(Logger.class); private final Throttler loggerThrottler = spyLogThrottler(LOGGER, throttlingPeriod); private final BeaconState state = createStateInInactivityLeak(); - private final UInt64 currentEpoch = spec.getCurrentEpoch(state); private final int slotsPerEpoch = spec.getSlotsPerEpoch(state.getSlot()); @Test public void shouldThrottleInactivityLeakLogs() throws Exception { - // First two processEpoch calls within the same epoch + // First two processEpoch calls within the same second epochProcessor.processEpoch(state); epochProcessor.processEpoch(advanceNSlots(state, 1)); - // Third processEpoch call in the next epoch + timeProvider.advanceTimeBy(Duration.ofSeconds(1)); epochProcessor.processEpoch(advanceNSlots(state, slotsPerEpoch)); // Logger throttler called 3 times - verify(loggerThrottler, times(2)).invoke(eq(currentEpoch), any()); - verify(loggerThrottler, times(1)).invoke(eq(currentEpoch.increment()), any()); + verify(loggerThrottler, times(3)).invoke(any(), any()); - // Real logger only called 2 times (one per epoch) + // Real logger only called 2 times (one per second) verify(LOGGER, times(2)).info(anyString()); } diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/util/AttestationUtilTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/util/AttestationUtilTest.java index 255470c5d84..7d98b7fbc15 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/util/AttestationUtilTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/util/AttestationUtilTest.java @@ -125,6 +125,7 @@ void createsAndValidatesIndexedAttestation(final SpecContext specContext) { assertThat(validatableAttestation.isValidIndexedAttestation()).isTrue(); assertThat(validatableAttestation.getIndexedAttestation()).isPresent(); assertThat(validatableAttestation.getCommitteeShufflingSeed()).isPresent(); + assertThat(validatableAttestation.getCommitteesSize()).isEmpty(); verify(asyncBLSSignatureVerifier).verify(anyList(), any(Bytes.class), any(BLSSignature.class)); } @@ -147,6 +148,7 @@ void createsButDoesNotValidateIndexedAttestationBecauseItHasAlreadyBeenValidated assertThat(validatableAttestation.isValidIndexedAttestation()).isTrue(); assertThat(validatableAttestation.getIndexedAttestation()).isPresent(); assertThat(validatableAttestation.getCommitteeShufflingSeed()).isPresent(); + assertThat(validatableAttestation.getCommitteesSize()).isEmpty(); verifyNoInteractions(miscHelpers, asyncBLSSignatureVerifier); } diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/util/BeaconStateUtilTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/util/BeaconStateUtilTest.java index e75818b91a2..93876a268f4 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/util/BeaconStateUtilTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/util/BeaconStateUtilTest.java @@ -155,9 +155,12 @@ void getCurrentDutyDependentRoot_returnsBlockRootAtLastSlotOfPriorEpoch() { public void getAttestersTotalEffectiveBalance_shouldCombinedAllCommitteesForSlot() { final BeaconStateTestBuilder stateBuilder = new BeaconStateTestBuilder(dataStructureUtil).slot(5); + int totalEffectiveEth = 0; for (int i = 0; i < specConfig.getSlotsPerEpoch() * ValidatorConstants.TARGET_AGGREGATORS_PER_COMMITTEE * 2; i++) { + // the total effective balance includes validators in the range of 16-32 eth + totalEffectiveEth += i < 16 ? 0 : Math.min(i, 32); stateBuilder.activeValidator( UInt64.valueOf(i).times(specConfig.getEffectiveBalanceIncrement())); } @@ -165,9 +168,12 @@ public void getAttestersTotalEffectiveBalance_shouldCombinedAllCommitteesForSlot assertThat(genesisSpec.beaconStateAccessors().getCommitteeCountPerSlot(state, UInt64.ZERO)) .isGreaterThan(UInt64.ZERO); - // Randao seed is fixed for state so we know the committee allocations will be the same + // Randao seed is fixed for state, so we know the committee allocations will be the same + // the Eth in each attestation committee is the total effective eth / slots per epoch assertThat(beaconStateUtil.getAttestersTotalEffectiveBalance(state, UInt64.valueOf(0))) - .isEqualTo(UInt64.valueOf(4394).times(specConfig.getEffectiveBalanceIncrement())); + .isEqualTo( + UInt64.valueOf(totalEffectiveEth / specConfig.getSlotsPerEpoch()) + .times(specConfig.getEffectiveBalanceIncrement())); assertAttestersBalancesSumToTotalBalancesOverEpoch(state); } diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/util/BlindBlockUtilTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/util/BlindBlockUtilTest.java index d9c61f8f9d8..f2562b6a839 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/util/BlindBlockUtilTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/util/BlindBlockUtilTest.java @@ -31,7 +31,7 @@ SpecMilestone.BELLATRIX, SpecMilestone.CAPELLA, SpecMilestone.DENEB, - SpecMilestone.EIP7594 + SpecMilestone.ELECTRA }) class BlindBlockUtilTest { diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/util/ForkChoiceUtilTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/util/ForkChoiceUtilTest.java index f8da1efc1fd..ead209e70d0 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/util/ForkChoiceUtilTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/common/util/ForkChoiceUtilTest.java @@ -35,6 +35,7 @@ import org.junit.jupiter.params.provider.MethodSource; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.datastructures.blocks.BlockCheckpoints; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; @@ -53,7 +54,7 @@ class ForkChoiceUtilTest { private static final UInt64 GENESIS_TIME = UInt64.valueOf("1591924193"); private static final UInt64 GENESIS_TIME_MILLIS = GENESIS_TIME.times(1000L); - private final Spec spec = TestSpecFactory.createMinimalPhase0(); + private final Spec spec = TestSpecFactory.createMinimalBellatrix(); private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); private final RandomChainBuilder chainBuilder = new RandomChainBuilder(dataStructureUtil); private final RandomChainBuilderForkChoiceStrategy forkChoiceStrategy = @@ -396,7 +397,8 @@ private ReadOnlyStore mockStore( } private int getSafeSyncDistance() { - return spec.getGenesisSpecConfig() + return spec.forMilestone(SpecMilestone.BELLATRIX) + .getConfig() .toVersionBellatrix() .orElseThrow() .getSafeSlotsToImportOptimistically(); diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/bellatrix/helpers/BellatrixTransitionHelpersTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/bellatrix/helpers/BellatrixTransitionHelpersTest.java index 7656c57926e..a95bc2e08ae 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/bellatrix/helpers/BellatrixTransitionHelpersTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/bellatrix/helpers/BellatrixTransitionHelpersTest.java @@ -43,7 +43,7 @@ class BellatrixTransitionHelpersTest { private final UInt256 terminalDifficulty = spec.getGenesisSpecConfig().toVersionBellatrix().orElseThrow().getTerminalTotalDifficulty(); - private UInt64 slot = dataStructureUtil.randomUInt64(); + private final UInt64 slot = dataStructureUtil.randomUInt64(); private final ExecutionPayload payload = dataStructureUtil.randomExecutionPayload(); diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/capella/block/BlockProcessorCapellaTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/capella/block/BlockProcessorCapellaTest.java index 909bd617dc3..14b61b99de7 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/capella/block/BlockProcessorCapellaTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/capella/block/BlockProcessorCapellaTest.java @@ -17,7 +17,6 @@ import java.util.ArrayList; import java.util.List; -import java.util.Optional; import org.apache.tuweni.bytes.Bytes32; import org.junit.jupiter.api.Test; import tech.pegasys.teku.bls.BLSPublicKey; @@ -28,7 +27,7 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.config.SpecConfig; -import tech.pegasys.teku.spec.datastructures.execution.versions.capella.Withdrawal; +import tech.pegasys.teku.spec.datastructures.execution.ExpectedWithdrawals; import tech.pegasys.teku.spec.datastructures.operations.BlsToExecutionChange; import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChange; import tech.pegasys.teku.spec.datastructures.state.Fork; @@ -91,24 +90,24 @@ public void shouldNotSweepMoreValidatorsThanLimit() { final BeaconState preState = createBeaconStateWithValidatorsAndBalances(validators, balances); - final Optional> withdrawals = + final ExpectedWithdrawals withdrawals = spec.getBlockProcessor(preState.getSlot()).getExpectedWithdrawals(preState); - assertThat(withdrawals).isPresent(); - assertThat(withdrawals.get()).hasSize(1); + assertThat(withdrawals.getWithdrawalList()).hasSize(1); } @Test public void shouldFindPartialWithdrawals() { - Validator validator = + final Validator validator = makeValidator( dataStructureUtil.randomPublicKey(), dataStructureUtil.randomEth1WithdrawalCredentials()); BeaconState preState = createBeaconState( true, spec.getGenesisSpecConfig().getMaxEffectiveBalance().plus(1024000), validator); - final Optional> withdrawals = + final ExpectedWithdrawals withdrawals = spec.getBlockProcessor(preState.getSlot()).getExpectedWithdrawals(preState); - assertThat(withdrawals.get().get(0).getAmount()).isEqualTo(UInt64.valueOf(1024000)); + assertThat(withdrawals.getWithdrawalList().get(0).getAmount()) + .isEqualTo(UInt64.valueOf(1024000)); } @Test @@ -121,9 +120,9 @@ public void shouldFindFullWithdrawals() { UInt64.ZERO); final UInt64 balance = spec.getGenesisSpecConfig().getMaxEffectiveBalance().plus(1024000); BeaconState preState = createBeaconState(true, balance, validator); - final Optional> withdrawals = + final ExpectedWithdrawals withdrawals = spec.getBlockProcessor(preState.getSlot()).getExpectedWithdrawals(preState); - assertThat(withdrawals.get().get(0).getAmount()).isEqualTo(balance); + assertThat(withdrawals.getWithdrawalList().get(0).getAmount()).isEqualTo(balance); } @Test diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/deneb/block/BlockProcessorDenebTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/deneb/block/BlockProcessorDenebTest.java index 6dd2c4cbfe7..effbc93b5e4 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/deneb/block/BlockProcessorDenebTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/deneb/block/BlockProcessorDenebTest.java @@ -44,7 +44,8 @@ protected Spec createSpec() { void shouldFailProcessingIfCommitmentsInBlockAreMoreThanMaxBlobsPerBlock() { final BeaconState preState = createBeaconState(); final UInt64 slot = preState.getSlot().increment(); - final int maxBlobsPerBlock = spec.getMaxBlobsPerBlock(slot).orElseThrow(); + final int maxBlobsPerBlock = + SpecConfigDeneb.required(spec.atSlot(slot).getConfig()).getMaxBlobsPerBlock(); final BeaconBlockBody blockBody = dataStructureUtil.randomBeaconBlockBodyWithCommitments(maxBlobsPerBlock + 1); assertThatThrownBy( diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/eip7594/helpers/MiscHelpersEip7594Test.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/eip7594/helpers/MiscHelpersEip7594Test.java index 7f7d8d72a1b..53f2a6482c6 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/eip7594/helpers/MiscHelpersEip7594Test.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/eip7594/helpers/MiscHelpersEip7594Test.java @@ -47,25 +47,27 @@ import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockHeader; import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; import tech.pegasys.teku.spec.logic.common.helpers.Predicates; +import tech.pegasys.teku.spec.logic.versions.feature.eip7594.helpers.MiscHelpersEip7594; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsDeneb; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsEip7594; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; import tech.pegasys.teku.spec.util.DataStructureUtil; public class MiscHelpersEip7594Test extends KZGAbstractBenchmark { private final Spec spec = - TestSpecFactory.createMinimalEip7594( + TestSpecFactory.createMinimalElectraEip7594( builder -> builder.eip7594Builder( eip7594Builder -> eip7594Builder.numberOfColumns(128).samplesPerSlot(16))); private final Predicates predicates = new Predicates(spec.getGenesisSpecConfig()); - private final SchemaDefinitionsEip7594 schemaDefinitionsEip7594 = - SchemaDefinitionsEip7594.required(spec.getGenesisSchemaDefinitions()); + private final SchemaDefinitionsElectra schemaDefinitionsElectra = + SchemaDefinitionsElectra.required(spec.getGenesisSchemaDefinitions()); private final MiscHelpersEip7594 miscHelpersEip7594 = new MiscHelpersEip7594( - spec.getGenesisSpecConfig().toVersionEip7594().orElseThrow(), + spec.getGenesisSpecConfig().getOptionalEip7594Config().orElseThrow(), predicates, - schemaDefinitionsEip7594); + schemaDefinitionsElectra); @ParameterizedTest(name = "{0} allowed failure(s)") @MethodSource("getExtendedSampleCountFixtures") @@ -143,16 +145,18 @@ public void emptyInclusionProof_shouldFailValidation() { .thenReturn(true); final MiscHelpersEip7594 miscHelpersEip7594WithMockPredicates = new MiscHelpersEip7594( - spec.getGenesisSpecConfig().toVersionEip7594().orElseThrow(), + spec.getGenesisSpecConfig().getOptionalEip7594Config().orElseThrow(), predicatesMock, - schemaDefinitionsEip7594); + schemaDefinitionsElectra); final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); final DataColumnSidecar dataColumnSidecar = - schemaDefinitionsEip7594 + SchemaDefinitionsEip7594.required(schemaDefinitionsElectra) .getDataColumnSidecarSchema() .create( UInt64.ZERO, - schemaDefinitionsEip7594.getDataColumnSchema().create(List.of()), + SchemaDefinitionsEip7594.required(schemaDefinitionsElectra) + .getDataColumnSchema() + .create(List.of()), List.of(), List.of(), dataStructureUtil.randomSignedBeaconBlockHeader(), @@ -167,7 +171,7 @@ public void emptyInclusionProof_shouldFailValidation() { dataColumnSidecar.getSszKZGCommitments().hashTreeRoot(), dataColumnSidecar.getKzgCommitmentsInclusionProof(), spec.getGenesisSpecConfig() - .toVersionEip7594() + .getOptionalEip7594Config() .orElseThrow() .getKzgCommitmentsInclusionProofDepth() .intValue(), @@ -182,21 +186,23 @@ public void emptyInclusionProof_shouldFailValidation() { @Test public void emptyInclusionProofFromRealNetwork_shouldFailValidation() { - final Spec specMainnet = TestSpecFactory.createMainnetEip7594(); + final Spec specMainnet = TestSpecFactory.createMainnetElectraEip7594(); final Predicates predicatesMainnet = new Predicates(specMainnet.getGenesisSpecConfig()); - final SchemaDefinitionsEip7594 schemaDefinitionsEip7594Mainnet = - SchemaDefinitionsEip7594.required(specMainnet.getGenesisSchemaDefinitions()); + final SchemaDefinitionsElectra schemaDefinitionsElectraMainnet = + SchemaDefinitionsElectra.required(specMainnet.getGenesisSchemaDefinitions()); final MiscHelpersEip7594 miscHelpersEip7594Mainnet = new MiscHelpersEip7594( - specMainnet.getGenesisSpecConfig().toVersionEip7594().orElseThrow(), + specMainnet.getGenesisSpecConfig().getOptionalEip7594Config().orElseThrow(), predicatesMainnet, - schemaDefinitionsEip7594Mainnet); + schemaDefinitionsElectraMainnet); final DataColumnSidecar dataColumnSidecar = - schemaDefinitionsEip7594Mainnet + SchemaDefinitionsEip7594.required(schemaDefinitionsElectraMainnet) .getDataColumnSidecarSchema() .create( UInt64.ZERO, - schemaDefinitionsEip7594Mainnet.getDataColumnSchema().create(List.of()), + SchemaDefinitionsEip7594.required(schemaDefinitionsElectraMainnet) + .getDataColumnSchema() + .create(List.of()), List.of(), List.of(), new SignedBeaconBlockHeader( diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/electra/block/BlockProcessorElectraTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/electra/block/BlockProcessorElectraTest.java new file mode 100644 index 00000000000..dad9ebc47d2 --- /dev/null +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/electra/block/BlockProcessorElectraTest.java @@ -0,0 +1,585 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.logic.versions.electra.block; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static tech.pegasys.teku.spec.config.SpecConfig.FAR_FUTURE_EPOCH; +import static tech.pegasys.teku.spec.config.SpecConfigElectra.FULL_EXIT_REQUEST_AMOUNT; + +import java.util.List; +import java.util.function.Supplier; +import java.util.stream.Collectors; +import java.util.stream.IntStream; +import org.apache.tuweni.bytes.Bytes; +import org.apache.tuweni.bytes.Bytes32; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.infrastructure.ssz.SszMutableList; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.config.SpecConfigDeneb; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.datastructures.blocks.Eth1Data; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra.BeaconBlockBodyElectra; +import tech.pegasys.teku.spec.datastructures.execution.NewPayloadRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsDataCodec; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequest; +import tech.pegasys.teku.spec.datastructures.operations.DepositData; +import tech.pegasys.teku.spec.datastructures.state.Validator; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.BeaconStateElectra; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.MutableBeaconStateElectra; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingPartialWithdrawal; +import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; +import tech.pegasys.teku.spec.logic.common.helpers.BeaconStateMutators.ValidatorExitContext; +import tech.pegasys.teku.spec.logic.common.helpers.MiscHelpers; +import tech.pegasys.teku.spec.logic.common.statetransition.exceptions.BlockProcessingException; +import tech.pegasys.teku.spec.logic.versions.deneb.block.BlockProcessorDenebTest; +import tech.pegasys.teku.spec.logic.versions.deneb.types.VersionedHash; +import tech.pegasys.teku.spec.logic.versions.electra.util.AttestationUtilElectra; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; + +class BlockProcessorElectraTest extends BlockProcessorDenebTest { + + @Override + protected Spec createSpec() { + return TestSpecFactory.createMainnetElectra(); + } + + @Test + public void verifiesOutstandingEth1DepositsAreProcessed() { + final BeaconState state = + createBeaconState() + .updated( + mutableState -> { + final UInt64 eth1DepositCount = UInt64.valueOf(25); + mutableState.setEth1Data( + new Eth1Data( + dataStructureUtil.randomBytes32(), + eth1DepositCount, + dataStructureUtil.randomBytes32())); + final UInt64 eth1DepositIndex = UInt64.valueOf(13); + mutableState.setEth1DepositIndex(eth1DepositIndex); + final UInt64 depositRequestsStartIndex = UInt64.valueOf(20); + MutableBeaconStateElectra.required(mutableState) + .setDepositRequestsStartIndex(depositRequestsStartIndex); + }); + + final BeaconBlockBody body = + dataStructureUtil.randomBeaconBlockBody( + // 20 - 13 = 7 + builder -> builder.deposits(dataStructureUtil.randomSszDeposits(7))); + + getBlockProcessor(state).verifyOutstandingDepositsAreProcessed(state, body); + } + + @Test + public void + verifiesNoOutstandingEth1DepositsAreProcessedWhenFormerDepositMechanismHasBeenDisabled() { + final BeaconState state = + createBeaconState() + .updated( + mutableState -> { + final UInt64 eth1DepositCount = UInt64.valueOf(25); + mutableState.setEth1Data( + new Eth1Data( + dataStructureUtil.randomBytes32(), + eth1DepositCount, + dataStructureUtil.randomBytes32())); + final UInt64 eth1DepositIndex = UInt64.valueOf(20); + mutableState.setEth1DepositIndex(eth1DepositIndex); + final UInt64 depositRequestsStartIndex = UInt64.valueOf(20); + MutableBeaconStateElectra.required(mutableState) + .setDepositRequestsStartIndex(depositRequestsStartIndex); + }); + + final BeaconBlockBody body = + dataStructureUtil.randomBeaconBlockBody( + // 20 - 20 = 0 + modifier -> modifier.deposits(dataStructureUtil.randomSszDeposits(0))); + + getBlockProcessor(state).verifyOutstandingDepositsAreProcessed(state, body); + } + + @Test + public void processesDepositRequests() { + final BeaconStateElectra preState = + BeaconStateElectra.required( + createBeaconState() + .updated( + mutableState -> + MutableBeaconStateElectra.required(mutableState) + .setDepositRequestsStartIndex( + SpecConfigElectra.UNSET_DEPOSIT_REQUESTS_START_INDEX))); + final int firstElectraDepositRequestIndex = preState.getValidators().size(); + + final int depositRequestsCount = 3; + final List depositRequests = + IntStream.range(0, depositRequestsCount) + .mapToObj( + i -> + dataStructureUtil.randomDepositRequestWithValidSignature( + UInt64.valueOf(firstElectraDepositRequestIndex + i))) + .toList(); + + final BeaconStateElectra state = + BeaconStateElectra.required( + preState.updated( + mutableState -> + getBlockProcessor(preState) + .processDepositRequests( + MutableBeaconStateElectra.required(mutableState), depositRequests))); + + // verify deposit_requests_start_index has been set + assertThat(state.getDepositRequestsStartIndex()) + .isEqualTo(UInt64.valueOf(firstElectraDepositRequestIndex)); + // verify validators have been added to the state + assertThat(state.getPendingDeposits()).hasSize(depositRequestsCount); + } + + @Test + public void processWithdrawalRequests_WithEmptyWithdrawalRequestsList_DoesNothing() { + final BeaconStateElectra preState = BeaconStateElectra.required(createBeaconState()); + + final BeaconStateElectra postState = + BeaconStateElectra.required( + preState.updated( + mutableState -> + getBlockProcessor(preState) + .processWithdrawalRequests( + mutableState, List.of(), validatorExitContextSupplier(preState)))); + + assertThat(postState.hashTreeRoot()).isEqualTo(preState.hashTreeRoot()); + } + + @Test + public void processWithdrawalRequests_ExitForAbsentValidator_DoesNothing() { + final BeaconStateElectra preState = BeaconStateElectra.required(createBeaconState()); + final WithdrawalRequest withdrawalRequest = dataStructureUtil.randomWithdrawalRequest(); + + // Assert the request does not correspond to an existing validator + assertThat( + preState.getValidators().stream() + .filter( + validator -> + validator.getPublicKey().equals(withdrawalRequest.getValidatorPubkey()))) + .isEmpty(); + + final BeaconStateElectra postState = + BeaconStateElectra.required( + preState.updated( + mutableState -> + getBlockProcessor(preState) + .processWithdrawalRequests( + mutableState, + List.of(withdrawalRequest), + validatorExitContextSupplier(preState)))); + + assertThat(postState.hashTreeRoot()).isEqualTo(preState.hashTreeRoot()); + } + + @Test + public void + processWithdrawalRequests_WithdrawalRequestForValidatorWithoutEth1Credentials_DoesNothing() { + final Validator validator = + dataStructureUtil.validatorBuilder().withRandomBlsWithdrawalCredentials().build(); + + final BeaconStateElectra preState = + BeaconStateElectra.required( + createBeaconState() + .updated( + mutableState -> { + final SszMutableList validators = mutableState.getValidators(); + validators.append(validator); + mutableState.setValidators(validators); + })); + + final BeaconStateElectra postState = + BeaconStateElectra.required( + preState.updated( + mutableState -> + getBlockProcessor(preState) + .processWithdrawalRequests( + mutableState, + List.of(dataStructureUtil.withdrawalRequest(validator)), + validatorExitContextSupplier(preState)))); + + assertThat(postState.hashTreeRoot()).isEqualTo(preState.hashTreeRoot()); + } + + @Test + public void processWithdrawalRequests_WithdrawalRequestWithWrongSourceAddress_DoesNothing() { + final Validator validator = + dataStructureUtil.validatorBuilder().withRandomEth1WithdrawalCredentials().build(); + + final BeaconStateElectra preState = + BeaconStateElectra.required( + createBeaconState() + .updated( + mutableState -> { + final SszMutableList validators = mutableState.getValidators(); + validators.append(validator); + mutableState.setValidators(validators); + })); + + final WithdrawalRequest withdrawalRequestWithInvalidSourceAddress = + dataStructureUtil.withdrawalRequest( + dataStructureUtil.randomEth1Address(), validator.getPublicKey(), UInt64.ZERO); + + final BeaconStateElectra postState = + BeaconStateElectra.required( + preState.updated( + mutableState -> + getBlockProcessor(preState) + .processWithdrawalRequests( + mutableState, + List.of(withdrawalRequestWithInvalidSourceAddress), + validatorExitContextSupplier(preState)))); + + assertThat(postState.hashTreeRoot()).isEqualTo(preState.hashTreeRoot()); + } + + @Test + public void processWithdrawalRequests_WithdrawalRequestForInactiveValidator_DoesNothing() { + final Validator validator = + dataStructureUtil + .validatorBuilder() + .withRandomEth1WithdrawalCredentials() + .activationEpoch(FAR_FUTURE_EPOCH) + .build(); + + final BeaconStateElectra preState = + BeaconStateElectra.required( + createBeaconState() + .updated( + mutableState -> { + final SszMutableList validators = mutableState.getValidators(); + validators.append(validator); + mutableState.setValidators(validators); + })); + + final BeaconStateElectra postState = + BeaconStateElectra.required( + preState.updated( + mutableState -> + getBlockProcessor(preState) + .processWithdrawalRequests( + mutableState, + List.of(dataStructureUtil.withdrawalRequest(validator)), + validatorExitContextSupplier(preState)))); + + assertThat(postState.hashTreeRoot()).isEqualTo(preState.hashTreeRoot()); + } + + @Test + public void processWithdrawalRequests_WithdrawalRequestForValidatorAlreadyExiting_DoesNothing() { + final UInt64 currentEpoch = UInt64.valueOf(1_000); + final Validator validator = + dataStructureUtil + .validatorBuilder() + .withRandomEth1WithdrawalCredentials() + .activationEpoch(UInt64.ZERO) + .exitEpoch(UInt64.valueOf(1_001)) + .build(); + + final BeaconStateElectra preState = + BeaconStateElectra.required( + createBeaconState() + .updated( + mutableState -> { + final SszMutableList validators = mutableState.getValidators(); + validators.append(validator); + mutableState.setValidators(validators); + mutableState.setSlot(spec.computeStartSlotAtEpoch(currentEpoch)); + })); + + final BeaconStateElectra postState = + BeaconStateElectra.required( + preState.updated( + mutableState -> + getBlockProcessor(preState) + .processWithdrawalRequests( + mutableState, + List.of(dataStructureUtil.withdrawalRequest(validator)), + validatorExitContextSupplier(preState)))); + + assertThat(postState.hashTreeRoot()).isEqualTo(preState.hashTreeRoot()); + } + + @Test + public void processWithdrawalRequests_ExitForValidatorNotActiveLongEnough_DoesNothing() { + final UInt64 currentEpoch = UInt64.valueOf(1_000); + final Validator validator = + dataStructureUtil + .validatorBuilder() + .withRandomEth1WithdrawalCredentials() + .activationEpoch(UInt64.valueOf(999)) + .exitEpoch(FAR_FUTURE_EPOCH) + .build(); + + final BeaconStateElectra preState = + BeaconStateElectra.required( + createBeaconState() + .updated( + mutableState -> { + final SszMutableList validators = mutableState.getValidators(); + validators.append(validator); + mutableState.setValidators(validators); + mutableState.setSlot(spec.computeStartSlotAtEpoch(currentEpoch)); + })); + + final BeaconStateElectra postState = + BeaconStateElectra.required( + preState.updated( + mutableState -> + getBlockProcessor(preState) + .processWithdrawalRequests( + mutableState, + List.of(dataStructureUtil.withdrawalRequest(validator)), + validatorExitContextSupplier(preState)))); + + assertThat(postState.hashTreeRoot()).isEqualTo(preState.hashTreeRoot()); + } + + @Test + public void processWithdrawalRequests_ExitForEligibleValidator() throws BlockProcessingException { + final UInt64 currentEpoch = UInt64.valueOf(1_000); + final Validator validator = + dataStructureUtil + .validatorBuilder() + .withRandomEth1WithdrawalCredentials() + .activationEpoch(UInt64.ZERO) + .exitEpoch(FAR_FUTURE_EPOCH) + .build(); + + final BeaconStateElectra preState = + BeaconStateElectra.required( + createBeaconState() + .updated( + mutableState -> { + final SszMutableList validators = mutableState.getValidators(); + validators.append(validator); + mutableState.setValidators(validators); + mutableState.setSlot(spec.computeStartSlotAtEpoch(currentEpoch)); + })); + // The validator we created was the last one added to the list of validators + int validatorIndex = preState.getValidators().size() - 1; + + // Before processing the exit, the validator has FAR_FUTURE_EPOCH for exit_epoch and + // withdrawable_epoch + assertThat(preState.getValidators().get(validatorIndex).getExitEpoch()) + .isEqualTo(FAR_FUTURE_EPOCH); + assertThat(preState.getValidators().get(validatorIndex).getWithdrawableEpoch()) + .isEqualTo(FAR_FUTURE_EPOCH); + + final BeaconStateElectra postState = + BeaconStateElectra.required( + preState.updated( + mutableState -> + getBlockProcessor(preState) + .processWithdrawalRequests( + mutableState, + List.of( + dataStructureUtil.withdrawalRequest( + validator, FULL_EXIT_REQUEST_AMOUNT)), + validatorExitContextSupplier(preState)))); + + // After processing the exit, the validator has exit_epoch and withdrawable_epoch set + assertThat(postState.getValidators().get(validatorIndex).getExitEpoch()) + .isLessThan(FAR_FUTURE_EPOCH); + assertThat(postState.getValidators().get(validatorIndex).getWithdrawableEpoch()) + .isLessThan(FAR_FUTURE_EPOCH); + } + + @Override + @Test + public void processDepositTopsUpValidatorBalanceWhenPubkeyIsFoundInRegistry() + throws BlockProcessingException { + // Create a deposit + final Bytes32 withdrawalCredentials = + dataStructureUtil.randomCompoundingWithdrawalCredentials(); + DepositData depositInput = dataStructureUtil.randomDepositData(withdrawalCredentials); + BLSPublicKey pubkey = depositInput.getPubkey(); + UInt64 amount = depositInput.getAmount(); + + Validator knownValidator = makeValidator(pubkey, withdrawalCredentials); + + BeaconState preState = createBeaconState(amount, knownValidator); + + int originalValidatorRegistrySize = preState.getValidators().size(); + int originalValidatorBalancesSize = preState.getBalances().size(); + + BeaconState postState = processDepositHelper(preState, depositInput); + + assertEquals( + postState.getValidators().size(), + originalValidatorRegistrySize, + "A new validator was added to the validator registry, but should not have been."); + assertEquals( + postState.getBalances().size(), + originalValidatorBalancesSize, + "A new balance was added to the validator balances, but should not have been."); + assertEquals(knownValidator, postState.getValidators().get(originalValidatorRegistrySize - 1)); + // as of electra, the balance increase is in the queue, and yet to be applied to the validator. + assertEquals(amount, postState.getBalances().getElement(originalValidatorBalancesSize - 1)); + assertThat(BeaconStateElectra.required(postState).getPendingDeposits().get(0).getPublicKey()) + .isEqualTo(postState.getValidators().get(originalValidatorBalancesSize - 1).getPublicKey()); + assertThat(BeaconStateElectra.required(postState).getPendingDeposits().get(0).getAmount()) + .isEqualTo(UInt64.THIRTY_TWO_ETH); + } + + @Test + public void processWithdrawalRequests_PartialWithdrawalRequestForEligibleValidator() { + final UInt64 currentEpoch = UInt64.valueOf(1_000); + final Validator validator = + dataStructureUtil + .validatorBuilder() + .withRandomCompoundingWithdrawalCredentials() + .activationEpoch(UInt64.ZERO) + .exitEpoch(FAR_FUTURE_EPOCH) + .build(); + + final SpecConfigElectra specConfigElectra = + spec.getSpecConfig(currentEpoch).toVersionElectra().orElseThrow(); + + final BeaconStateElectra preState = + BeaconStateElectra.required( + createBeaconState() + .updated( + mutableState -> { + final SszMutableList validators = mutableState.getValidators(); + validators.append(validator); + mutableState.setValidators(validators); + mutableState.setSlot(spec.computeStartSlotAtEpoch(currentEpoch)); + + // Give the validator an excessBalance + int validatorIndex = mutableState.getValidators().size() - 1; + mutableState + .getBalances() + .set( + validatorIndex, + SszUInt64.of( + specConfigElectra + .getMinActivationBalance() + .plus(UInt64.valueOf(123_456_789)))); + })); + // The validator we created was the last one added to the list of validators + int validatorIndex = preState.getValidators().size() - 1; + + // Before processing the withdrawal, the validator has FAR_FUTURE_EPOCH for exit_epoch and + // withdrawable_epoch + assertThat(preState.getValidators().get(validatorIndex).getExitEpoch()) + .isEqualTo(FAR_FUTURE_EPOCH); + assertThat(preState.getValidators().get(validatorIndex).getWithdrawableEpoch()) + .isEqualTo(FAR_FUTURE_EPOCH); + + // Set withdrawal request amount to the validator's excess balance + final UInt64 amount = + preState + .getBalances() + .get(validatorIndex) + .get() + .minus(specConfigElectra.getMinActivationBalance()); + assertThat(amount).isEqualTo(UInt64.valueOf(123_456_789)); + + final BeaconStateElectra postState = + BeaconStateElectra.required( + preState.updated( + mutableState -> + getBlockProcessor(preState) + .processWithdrawalRequests( + mutableState, + List.of(dataStructureUtil.withdrawalRequest(validator, amount)), + validatorExitContextSupplier(preState)))); + + // After processing the request, the validator hasn't updated these + assertThat(postState.getValidators().get(validatorIndex).getExitEpoch()) + .isEqualTo(FAR_FUTURE_EPOCH); + assertThat(postState.getValidators().get(validatorIndex).getWithdrawableEpoch()) + .isEqualTo(FAR_FUTURE_EPOCH); + + // The validator's balance should be equal to the minimum activation balance + assertThat(postState.getPendingPartialWithdrawals().size()).isEqualTo(1); + final PendingPartialWithdrawal mostRecentPendingPartialWithdrawal = + postState + .getPendingPartialWithdrawals() + .get(postState.getPendingPartialWithdrawals().size() - 1); + + assertThat(mostRecentPendingPartialWithdrawal.getIndex()).isEqualTo(validatorIndex); + assertThat(mostRecentPendingPartialWithdrawal.getAmount()) + .isEqualTo(UInt64.valueOf(123_456_789)); + assertThat(mostRecentPendingPartialWithdrawal.getWithdrawableEpoch()) + .isEqualTo(UInt64.valueOf(1_261)); + } + + @Test + void shouldUseElectraAttestationUtil() { + assertThat(spec.getGenesisSpec().getAttestationUtil()) + .isInstanceOf(AttestationUtilElectra.class); + } + + @Test + public void shouldCreateNewPayloadRequestWithExecutionRequestsHash() throws Exception { + final BeaconState preState = createBeaconState(); + final BeaconBlockBodyElectra blockBody = + BeaconBlockBodyElectra.required(dataStructureUtil.randomBeaconBlockBodyWithCommitments(3)); + final MiscHelpers miscHelpers = spec.atSlot(UInt64.ONE).miscHelpers(); + final List expectedVersionedHashes = + blockBody.getOptionalBlobKzgCommitments().orElseThrow().stream() + .map(SszKZGCommitment::getKZGCommitment) + .map(miscHelpers::kzgCommitmentToVersionedHash) + .collect(Collectors.toList()); + final List expectedExecutionRequests = + getExecutionRequestsDataCodec().encode(blockBody.getExecutionRequests()); + + final NewPayloadRequest newPayloadRequest = + spec.getBlockProcessor(UInt64.ONE).computeNewPayloadRequest(preState, blockBody); + + assertThat(newPayloadRequest.getExecutionPayload()) + .isEqualTo(blockBody.getOptionalExecutionPayload().orElseThrow()); + assertThat(newPayloadRequest.getVersionedHashes()).isPresent(); + assertThat(newPayloadRequest.getVersionedHashes().get()) + .hasSize(3) + .allSatisfy( + versionedHash -> + assertThat(versionedHash.getVersion()) + .isEqualTo(SpecConfigDeneb.VERSIONED_HASH_VERSION_KZG)) + .hasSameElementsAs(expectedVersionedHashes); + assertThat(newPayloadRequest.getParentBeaconBlockRoot()).isPresent(); + assertThat(newPayloadRequest.getParentBeaconBlockRoot().get()) + .isEqualTo(preState.getLatestBlockHeader().getParentRoot()); + assertThat(newPayloadRequest.getExecutionRequests()).hasValue(expectedExecutionRequests); + } + + private Supplier validatorExitContextSupplier(final BeaconState state) { + return spec.getGenesisSpec().beaconStateMutators().createValidatorExitContextSupplier(state); + } + + private BlockProcessorElectra getBlockProcessor(final BeaconState state) { + return (BlockProcessorElectra) spec.getBlockProcessor(state.getSlot()); + } + + private ExecutionRequestsDataCodec getExecutionRequestsDataCodec() { + return new ExecutionRequestsDataCodec( + SchemaDefinitionsElectra.required( + spec.forMilestone(SpecMilestone.ELECTRA).getSchemaDefinitions()) + .getExecutionRequestsSchema()); + } +} diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/electra/forktransition/ElectraStateUpgradeTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/electra/forktransition/ElectraStateUpgradeTest.java new file mode 100644 index 00000000000..a4b1f00a64d --- /dev/null +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/electra/forktransition/ElectraStateUpgradeTest.java @@ -0,0 +1,204 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.logic.versions.electra.forktransition; + +import static org.assertj.core.api.Assertions.assertThat; +import static tech.pegasys.teku.spec.config.SpecConfig.FAR_FUTURE_EPOCH; + +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.infrastructure.ssz.SszList; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.datastructures.state.Validator; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.deneb.BeaconStateDeneb; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.BeaconStateElectra; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingDeposit; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.BeaconStateAccessorsElectra; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.BeaconStateMutatorsElectra; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.MiscHelpersElectra; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.PredicatesElectra; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +class ElectraStateUpgradeTest { + + private final Spec spec = TestSpecFactory.createMinimalElectra(); + private final PredicatesElectra predicatesElectra = + new PredicatesElectra(spec.getGenesisSpecConfig()); + final SchemaDefinitionsElectra schemaDefinitionsElectra = + SchemaDefinitionsElectra.required(spec.getGenesisSchemaDefinitions()); + private final MiscHelpersElectra miscHelpersElectra = + new MiscHelpersElectra( + spec.getGenesisSpecConfig().toVersionElectra().orElseThrow(), + predicatesElectra, + spec.getGenesisSchemaDefinitions()); + final BeaconStateAccessorsElectra stateAccessorsElectra = + new BeaconStateAccessorsElectra( + spec.getGenesisSpecConfig(), predicatesElectra, miscHelpersElectra); + final BeaconStateMutatorsElectra stateMutatorsElectra = + new BeaconStateMutatorsElectra( + spec.getGenesisSpecConfig(), + miscHelpersElectra, + stateAccessorsElectra, + schemaDefinitionsElectra); + private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); + + @Test + void canUpgradeFromDeneb() { + final UInt64 slot = UInt64.valueOf(80_000L); + final BeaconStateDeneb pre = + BeaconStateDeneb.required( + dataStructureUtil.stateBuilder(SpecMilestone.DENEB, 0, 0).slot(slot).build()); + + final ElectraStateUpgrade upgrade = + new ElectraStateUpgrade( + SpecConfigElectra.required(spec.getGenesisSpecConfig()), + schemaDefinitionsElectra, + stateAccessorsElectra, + stateMutatorsElectra); + + final BeaconStateElectra post = upgrade.upgrade(pre); + + assertThat(post.getDepositBalanceToConsume()).isEqualTo(UInt64.ZERO); + // min churn - churn % balance_increment + // = (64 *10^9) - (64 *10^9) MOD 10^9 + // = (64 *10^9) - 0 + assertThat(post.getExitBalanceToConsume()).isEqualTo(UInt64.valueOf(64_000_000_000L)); + assertThat(post.getEarliestExitEpoch()).isEqualTo(slot.dividedBy(8).increment()); + assertThat(post.getConsolidationBalanceToConsume()).isEqualTo(UInt64.ZERO); + // 80_000/8 (slots -> epochs) + max_seed_lookahead + 1 + assertThat(post.getEarliestConsolidationEpoch()).isEqualTo(UInt64.valueOf(10005)); + assertThat(post.getPendingDeposits()).isEmpty(); + assertThat(post.getPendingConsolidations()).isEmpty(); + assertThat(post.getPendingPartialWithdrawals()).isEmpty(); + } + + @Test + public void shouldAddNonActiveValidatorsToPendingBalanceDeposits() { + final UInt64 maxEffectiveBalance = spec.getGenesisSpecConfig().getMaxEffectiveBalance(); + + // Not-active validator 1 + final Validator validator1 = + dataStructureUtil + .validatorBuilder() + .activationEpoch(FAR_FUTURE_EPOCH) + .activationEligibilityEpoch(UInt64.valueOf(1)) + .build(); + // Not-active validator 2 + final Validator validator2 = + dataStructureUtil + .validatorBuilder() + .activationEpoch(FAR_FUTURE_EPOCH) + .activationEligibilityEpoch(UInt64.valueOf(10)) + .build(); + // Not-active validator 3, with activation eligibility epoch lower than validator 2 + final Validator validator3 = + dataStructureUtil + .validatorBuilder() + .activationEpoch(FAR_FUTURE_EPOCH) + .activationEligibilityEpoch(UInt64.valueOf(5)) + .build(); + + final BeaconStateDeneb preState = + BeaconStateDeneb.required( + dataStructureUtil + .stateBuilder(SpecMilestone.DENEB, 3, 0) + .validators(validator1, validator2, validator3) + // All validators have their balance = maxEffectiveBalance + .balances(maxEffectiveBalance, maxEffectiveBalance, maxEffectiveBalance) + .build()); + + final ElectraStateUpgrade upgrade = + new ElectraStateUpgrade( + SpecConfigElectra.required(spec.getGenesisSpecConfig()), + schemaDefinitionsElectra, + stateAccessorsElectra, + stateMutatorsElectra); + + final BeaconStateElectra postState = upgrade.upgrade(preState); + + final SszList pendingDeposits = postState.getPendingDeposits(); + assertThat(pendingDeposits.size()).isEqualTo(3); + + assertPendingDeposit( + pendingDeposits.get(0), postState.getValidators().get(0), maxEffectiveBalance); + // During Electra fork upgrade, pending balance deposits must be ordered by activation + // eligibility epoch. + // Because Validator3 (index = 2) activation eligibility epoch is lower than validator2, + // Validator3's pending balance deposit must come before Validator2 (index = 1) + assertPendingDeposit( + pendingDeposits.get(1), postState.getValidators().get(2), maxEffectiveBalance); + assertPendingDeposit( + pendingDeposits.get(2), postState.getValidators().get(1), maxEffectiveBalance); + } + + @Test + public void shouldAddValidatorsWithCompoundingCredentialsExcessBalanceToPendingBalanceDeposits() { + final UInt64 maxEffectiveBalance = spec.getGenesisSpecConfig().getMaxEffectiveBalance(); + final UInt64 excessBalance = UInt64.valueOf(1_000); + + // Compounding validator with excess balance + final Validator validator1 = + dataStructureUtil + .validatorBuilder() + .activationEpoch(UInt64.ZERO) + .withRandomCompoundingWithdrawalCredentials() + .build(); + + // Another compounding validator with excess balance + final Validator validator2 = + dataStructureUtil + .validatorBuilder() + .activationEpoch(UInt64.ZERO) + .withRandomCompoundingWithdrawalCredentials() + .build(); + + final BeaconStateDeneb preState = + BeaconStateDeneb.required( + dataStructureUtil + .stateBuilder(SpecMilestone.DENEB, 4, 0) + .slot(UInt64.valueOf(100_000)) + .validators(validator1, validator2) + // All validators have their balance = maxEffectiveBalance + .balances( + maxEffectiveBalance.plus(excessBalance), + maxEffectiveBalance.plus(excessBalance)) + .build()); + + final ElectraStateUpgrade upgrade = + new ElectraStateUpgrade( + SpecConfigElectra.required(spec.getGenesisSpecConfig()), + schemaDefinitionsElectra, + stateAccessorsElectra, + stateMutatorsElectra); + + final BeaconStateElectra postState = upgrade.upgrade(preState); + + final SszList pendingDeposits = postState.getPendingDeposits(); + assertThat(pendingDeposits.size()).isEqualTo(2); + // Compounding validator will have a pending balance deposit only of the excess, in their index + // order + assertPendingDeposit(pendingDeposits.get(0), postState.getValidators().get(0), excessBalance); + assertPendingDeposit(pendingDeposits.get(1), postState.getValidators().get(1), excessBalance); + } + + private void assertPendingDeposit( + final PendingDeposit pendingDeposit, final Validator validator, final UInt64 expectedAmount) { + assertThat(pendingDeposit.getPublicKey()).isEqualTo(validator.getPublicKey()); + assertThat(pendingDeposit.getAmount()).isEqualTo(expectedAmount); + } +} diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/electra/helpers/BeaconStateAccessorsElectraTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/electra/helpers/BeaconStateAccessorsElectraTest.java new file mode 100644 index 00000000000..2a00a816b9d --- /dev/null +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/electra/helpers/BeaconStateAccessorsElectraTest.java @@ -0,0 +1,62 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.logic.versions.electra.helpers; + +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; + +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.datastructures.state.BeaconStateTestBuilder; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +class BeaconStateAccessorsElectraTest { + + private final Spec spec = TestSpecFactory.createMinimalElectra(); + private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); + private final SpecConfigElectra specConfig = + spy(SpecConfigElectra.required(spec.atSlot(UInt64.ZERO).getConfig())); + private final PredicatesElectra predicatesElectra = new PredicatesElectra(specConfig); + private final SchemaDefinitionsElectra schemaDefinitionsElectra = + spec.getGenesisSchemaDefinitions().toVersionElectra().orElseThrow(); + private final MiscHelpersElectra miscHelpersElectra = + new MiscHelpersElectra( + SpecConfigElectra.required(specConfig), predicatesElectra, schemaDefinitionsElectra); + + @Test + public void getNextSyncCommitteeIndicesShouldUseMaxEffectiveBalanceElectra() { + final BeaconStateAccessorsElectra beaconStateAccessorsElectra = + new BeaconStateAccessorsElectra(specConfig, predicatesElectra, miscHelpersElectra); + + beaconStateAccessorsElectra.getNextSyncCommitteeIndices(createBeaconState()); + + verify(specConfig).getMaxEffectiveBalanceElectra(); + verify(specConfig, never()).getMaxEffectiveBalance(); + } + + private BeaconState createBeaconState() { + return new BeaconStateTestBuilder(dataStructureUtil) + .forkVersion(specConfig.getGenesisForkVersion()) + .activeValidator(UInt64.THIRTY_TWO_ETH) + .activeValidator(UInt64.THIRTY_TWO_ETH) + .activeValidator(UInt64.THIRTY_TWO_ETH) + .build(); + } +} diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/electra/helpers/BeaconStateMutatorsElectraTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/electra/helpers/BeaconStateMutatorsElectraTest.java new file mode 100644 index 00000000000..53d43b45603 --- /dev/null +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/electra/helpers/BeaconStateMutatorsElectraTest.java @@ -0,0 +1,175 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.logic.versions.electra.helpers; + +import static org.assertj.core.api.Assertions.assertThat; +import static tech.pegasys.teku.spec.config.SpecConfig.FAR_FUTURE_EPOCH; + +import org.apache.tuweni.bytes.Bytes32; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.infrastructure.ssz.SszList; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.datastructures.state.BeaconStateTestBuilder; +import tech.pegasys.teku.spec.datastructures.state.Validator; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.BeaconStateElectra; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.MutableBeaconStateElectra; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingDeposit; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +class BeaconStateMutatorsElectraTest { + + private final Spec spec = TestSpecFactory.createMainnetElectra(); + private final PredicatesElectra predicates = new PredicatesElectra(spec.getGenesisSpecConfig()); + private final SchemaDefinitionsElectra schemaDefinitionsElectra = + SchemaDefinitionsElectra.required(spec.getGenesisSchemaDefinitions()); + private final SpecConfigElectra specConfig = + spec.getGenesisSpecConfig().toVersionElectra().orElseThrow(); + private final MiscHelpersElectra miscHelpersElectra = + new MiscHelpersElectra(specConfig, predicates, schemaDefinitionsElectra); + final BeaconStateAccessorsElectra stateAccessorsElectra = + new BeaconStateAccessorsElectra(specConfig, predicates, miscHelpersElectra); + private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); + + private BeaconStateMutatorsElectra stateMutatorsElectra; + + @BeforeEach + public void setUp() { + stateMutatorsElectra = + new BeaconStateMutatorsElectra( + specConfig, miscHelpersElectra, stateAccessorsElectra, schemaDefinitionsElectra); + } + + @Test + public void queueExcessActiveBalance_withExcessBalance_ShouldCreatePendingBalanceDeposit() { + final UInt64 minActivationBalance = specConfig.getMinActivationBalance(); + final long excessBalance = 1L; + final BeaconStateElectra preState = + BeaconStateElectra.required( + new BeaconStateTestBuilder(dataStructureUtil) + .activeValidator(minActivationBalance.plus(excessBalance)) + .build()); + + final BeaconStateElectra postState = + preState.updatedElectra(state -> stateMutatorsElectra.queueExcessActiveBalance(state, 0)); + final SszList postPendingDeposits = postState.getPendingDeposits(); + + assertThat(postPendingDeposits.size()).isEqualTo(1); + assertThat(postPendingDeposits.get(0).getAmount()).isEqualTo(UInt64.valueOf(excessBalance)); + } + + @Test + public void queueExcessActiveBalance_withoutExcessBalance_ShouldNotCreatePendingBalanceDeposit() { + final UInt64 minActivationBalance = specConfig.getMinActivationBalance(); + final BeaconStateElectra preState = + BeaconStateElectra.required( + new BeaconStateTestBuilder(dataStructureUtil) + .activeValidator(minActivationBalance) + .build()); + + final BeaconStateElectra postState = + preState.updatedElectra(state -> stateMutatorsElectra.queueExcessActiveBalance(state, 0)); + final SszList postPendingBalanceDeposits = postState.getPendingDeposits(); + + assertThat(postPendingBalanceDeposits.size()).isEqualTo(0); + } + + @Test + public void queueExcessActiveBalance_correctlyAppendsNewBalanceDeposits() { + final UInt64 minActivationBalance = specConfig.getMinActivationBalance(); + final long excessBalance = 1L; + final BeaconStateElectra preState = + BeaconStateElectra.required( + new BeaconStateTestBuilder(dataStructureUtil) + .activeValidator(minActivationBalance.plus(excessBalance)) + .activeValidator(minActivationBalance.plus(excessBalance)) + .build()); + + BeaconStateElectra postState = + preState.updatedElectra(state -> stateMutatorsElectra.queueExcessActiveBalance(state, 0)); + + assertThat(postState.getPendingDeposits().size()).isEqualTo(1); + + postState = + postState.updatedElectra(state -> stateMutatorsElectra.queueExcessActiveBalance(state, 1)); + assertThat(postState.getPendingDeposits().size()).isEqualTo(2); + } + + @Test + public void queueEntireBalanceAndResetValidator_updateStateAsRequired() { + final UInt64 validatorBalance = specConfig.getMinActivationBalance(); + final BeaconStateElectra preState = + BeaconStateElectra.required( + new BeaconStateTestBuilder(dataStructureUtil) + .activeValidator(validatorBalance) + .build()); + + // Sanity check preState values + final Validator preValidator = preState.getValidators().get(0); + assertThat(preValidator.getEffectiveBalance()).isEqualTo(validatorBalance); + assertThat(preValidator.getActivationEpoch()).isNotEqualTo(FAR_FUTURE_EPOCH); + assertThat(preState.getBalances().get(0)).isEqualTo(SszUInt64.of(validatorBalance)); + assertThat(preState.getPendingDeposits().size()).isEqualTo(0); + + final BeaconStateElectra postState = + preState.updatedElectra( + state -> stateMutatorsElectra.queueEntireBalanceAndResetValidator(state, 0)); + + // Validator has been reset + final Validator postValidator = postState.getValidators().get(0); + assertThat(postValidator.getEffectiveBalance()).isEqualTo(UInt64.ZERO); + assertThat(postValidator.getActivationEpoch()).isEqualTo(UInt64.ZERO); + assertThat(postValidator.getActivationEligibilityEpoch()).isEqualTo(FAR_FUTURE_EPOCH); + + // Updated state balances + assertThat(postState.getBalances().get(0)).isEqualTo(SszUInt64.ZERO); + + // Created pending balance deposit + final SszList postPendingBalanceDeposits = postState.getPendingDeposits(); + assertThat(postPendingBalanceDeposits.size()).isEqualTo(1); + assertThat(postPendingBalanceDeposits.get(0).getAmount()).isEqualTo(validatorBalance); + } + + @Test + void switchToCompoundingValidator_shouldGeneratePendingBalanceDeposit() { + final int index = 3; + MutableBeaconStateElectra state = + BeaconStateElectra.required( + dataStructureUtil + .randomBeaconState() + .updated( + mutableBeaconState -> + mutableBeaconState + .getBalances() + .set(index, SszUInt64.of(UInt64.valueOf(33_000_000_000L))))) + .createWritableCopy(); + state + .getValidators() + .update( + index, + validator -> + validator.withWithdrawalCredentials( + Bytes32.wrap(dataStructureUtil.randomEth1WithdrawalCredentials()))); + stateMutatorsElectra.switchToCompoundingValidator(state, index); + + assertThat(state.getBalances().get(index).get()).isEqualTo(UInt64.valueOf(32_000_000_000L)); + assertThat(state.getPendingDeposits().get(0).getAmount()) + .isEqualTo(UInt64.valueOf(1_000_000_000L)); + } +} diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/electra/helpers/MiscHelpersElectraTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/electra/helpers/MiscHelpersElectraTest.java new file mode 100644 index 00000000000..86acdd78d47 --- /dev/null +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/electra/helpers/MiscHelpersElectraTest.java @@ -0,0 +1,156 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.logic.versions.electra.helpers; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; +import static tech.pegasys.teku.spec.logic.common.helpers.MathHelpers.uint64ToBytes; + +import it.unimi.dsi.fastutil.ints.IntArrayList; +import it.unimi.dsi.fastutil.ints.IntList; +import org.apache.tuweni.bytes.Bytes32; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.infrastructure.crypto.Hash; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.config.SpecConfigElectra; +import tech.pegasys.teku.spec.constants.Domain; +import tech.pegasys.teku.spec.datastructures.state.BeaconStateTestBuilder; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.BeaconStateElectra; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.MutableBeaconStateElectra; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +public class MiscHelpersElectraTest { + + private final Spec spec = TestSpecFactory.createMinimalElectra(); + private static final int PROPOSER_INDEX = 3; + private final PredicatesElectra predicatesElectra = + new PredicatesElectra(spec.getGenesisSpecConfig()); + private final SchemaDefinitionsElectra schemaDefinitionsElectra = + SchemaDefinitionsElectra.required(spec.getGenesisSchemaDefinitions()); + private final MiscHelpersElectra miscHelpersElectra = + new MiscHelpersElectra( + spec.getGenesisSpecConfig().toVersionElectra().orElseThrow(), + predicatesElectra, + schemaDefinitionsElectra); + private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); + final BeaconStateAccessorsElectra beaconStateAccessors = + new BeaconStateAccessorsElectra( + spec.getGenesisSpecConfig(), predicatesElectra, miscHelpersElectra); + + private final IntList validatorIndices = IntArrayList.of(1, 2, 3, 4, 5, 6, 7, 0); + + @Test + public void isFormerDepositMechanismDisabled_returnsTrueIfDisabled() { + final BeaconState preState = dataStructureUtil.randomBeaconState(); + + final BeaconState state = + BeaconStateElectra.required(preState) + .updated( + mutableState -> { + final UInt64 eth1DepositIndex = dataStructureUtil.randomUInt64(); + mutableState.setEth1DepositIndex(eth1DepositIndex); + MutableBeaconStateElectra.required(mutableState) + .setDepositRequestsStartIndex(eth1DepositIndex); + }); + + assertThat(miscHelpersElectra.isFormerDepositMechanismDisabled(state)).isTrue(); + } + + @Test + public void isFormerDepositMechanismDisabled_returnsFalseIfNotDisabled() { + final BeaconState preState = dataStructureUtil.randomBeaconState(); + + final BeaconState state = + BeaconStateElectra.required(preState) + .updated( + mutableState -> { + mutableState.setEth1DepositIndex(UInt64.valueOf(64)); + MutableBeaconStateElectra.required(mutableState) + .setDepositRequestsStartIndex( + SpecConfigElectra.UNSET_DEPOSIT_REQUESTS_START_INDEX); + }); + + assertThat(miscHelpersElectra.isFormerDepositMechanismDisabled(state)).isFalse(); + } + + @Test + public void computeProposerIndexShouldUseMaxEffectiveBalanceElectra() { + final SpecConfigElectra specConfigElectra = + spy(SpecConfigElectra.required(spec.getGenesisSpecConfig())); + final MiscHelpersElectra miscHelpersElectra = + new MiscHelpersElectra(specConfigElectra, predicatesElectra, schemaDefinitionsElectra); + + final BeaconState state = + new BeaconStateTestBuilder(dataStructureUtil) + .forkVersion(spec.getGenesisSpecConfig().getGenesisForkVersion()) + .activeValidator(UInt64.THIRTY_TWO_ETH) + .activeValidator(UInt64.THIRTY_TWO_ETH) + .activeValidator(UInt64.THIRTY_TWO_ETH) + .build(); + + miscHelpersElectra.computeProposerIndex(state, IntList.of(0, 1, 2), Bytes32.ZERO); + + verify(specConfigElectra).getMaxEffectiveBalanceElectra(); + verify(specConfigElectra, never()).getMaxEffectiveBalance(); + } + + @Test + void consolidatedValidatorsMoreLikelyToPropose() { + final int consolidationAmount = 16; + final BeaconState state = randomStateWithConsolidatedValidator(consolidationAmount); + int proposerIndexCount = 0; + for (int i = 1; i < 8; i++) { + final UInt64 slot = UInt64.valueOf(8 + i); + final Bytes32 seed = + Hash.sha256( + beaconStateAccessors.getSeed(state, UInt64.ONE, Domain.BEACON_PROPOSER), + uint64ToBytes(slot)); + + if (miscHelpersElectra.computeProposerIndex(state, validatorIndices, seed) + == PROPOSER_INDEX) { + proposerIndexCount++; + } + } + assertThat(proposerIndexCount).isEqualTo(4); + } + + private BeaconState randomStateWithConsolidatedValidator(final int consolidationAmount) { + final BeaconState preState = dataStructureUtil.randomBeaconState(8); + return BeaconStateElectra.required(preState) + .updated( + mutableState -> { + mutableState + .getValidators() + .set( + PROPOSER_INDEX, + dataStructureUtil + .validatorBuilder() + .withdrawalCredentials( + dataStructureUtil.randomCompoundingWithdrawalCredentials()) + .effectiveBalance(UInt64.THIRTY_TWO_ETH.times(consolidationAmount)) + .build()); + mutableState + .getBalances() + .set(3, SszUInt64.of(UInt64.THIRTY_TWO_ETH.times(consolidationAmount))); + mutableState.setSlot(UInt64.valueOf(8)); + }); + } +} diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/electra/helpers/PredicatesElectraTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/electra/helpers/PredicatesElectraTest.java new file mode 100644 index 00000000000..26f8f2ba1b4 --- /dev/null +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/electra/helpers/PredicatesElectraTest.java @@ -0,0 +1,85 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.logic.versions.electra.helpers; + +import static org.assertj.core.api.Assertions.assertThat; + +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.datastructures.state.Validator; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +class PredicatesElectraTest { + private final Spec spec = TestSpecFactory.createMinimalElectra(); + private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); + private final PredicatesElectra predicates = new PredicatesElectra(spec.getGenesisSpecConfig()); + + private final UInt64 excessLargeValidatorBalance = UInt64.valueOf(2050_000_000_000L); + + private final UInt64 maxEffectiveBalanceNonCompounding = UInt64.THIRTY_TWO_ETH; + + private final UInt64 maxEffectiveBalanceCompounding = UInt64.valueOf(2048_000_000_000L); + + @Test + void isPartiallyWithdrawableValidator_shouldNotDetermineBlsWithdrawalAsNotWithdrawable() { + final Validator validator = + dataStructureUtil + .validatorBuilder() + .withdrawalCredentials(dataStructureUtil.randomBlsWithdrawalCredentials()) + .effectiveBalance(maxEffectiveBalanceNonCompounding) + .build(); + assertThat(predicates.isPartiallyWithdrawableValidator(validator, excessLargeValidatorBalance)) + .isFalse(); + } + + @Test + void isPartiallyWithdrawableValidator_shouldDetermineEth1WithdrawalAsWithdrawable() { + final Validator validator = + dataStructureUtil + .validatorBuilder() + .withdrawalCredentials(dataStructureUtil.randomEth1WithdrawalCredentials()) + .effectiveBalance(maxEffectiveBalanceNonCompounding) + .build(); + assertThat(predicates.isPartiallyWithdrawableValidator(validator, excessLargeValidatorBalance)) + .isTrue(); + } + + @Test + void isPartiallyWithdrawableValidator_shouldDetermineCompoundingWithdrawalAsWithdrawable() { + final Validator validator = + dataStructureUtil + .validatorBuilder() + .withdrawalCredentials(dataStructureUtil.randomCompoundingWithdrawalCredentials()) + .effectiveBalance(maxEffectiveBalanceCompounding) + .build(); + assertThat(predicates.isPartiallyWithdrawableValidator(validator, excessLargeValidatorBalance)) + .isTrue(); + } + + @Test + void isPartiallyWithdrawableValidator_shouldDetermineCompoundingWithdrawalAsAsNotWithdrawable() { + final Validator validator = + dataStructureUtil + .validatorBuilder() + .withdrawalCredentials(dataStructureUtil.randomCompoundingWithdrawalCredentials()) + .effectiveBalance(maxEffectiveBalanceNonCompounding) + .build(); + assertThat( + predicates.isPartiallyWithdrawableValidator( + validator, maxEffectiveBalanceNonCompounding)) + .isFalse(); + } +} diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/electra/operations/validation/VoluntaryExitValidatorElectraTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/electra/operations/validation/VoluntaryExitValidatorElectraTest.java new file mode 100644 index 00000000000..0024e446d5b --- /dev/null +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/electra/operations/validation/VoluntaryExitValidatorElectraTest.java @@ -0,0 +1,88 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.logic.versions.electra.operations.validation; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import java.util.List; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.bls.BLSKeyPair; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.datastructures.interop.MockStartValidatorKeyPairFactory; +import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.BeaconStateElectra; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.BeaconStateAccessorsElectra; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.PredicatesElectra; +import tech.pegasys.teku.spec.logic.versions.phase0.operations.validation.VoluntaryExitValidator; +import tech.pegasys.teku.spec.util.DataStructureUtil; +import tech.pegasys.teku.statetransition.BeaconChainUtil; +import tech.pegasys.teku.storage.client.MemoryOnlyRecentChainData; +import tech.pegasys.teku.storage.client.RecentChainData; + +class VoluntaryExitValidatorElectraTest { + private static final List VALIDATOR_KEYS = + new MockStartValidatorKeyPairFactory().generateKeyPairs(0, 25); + + private RecentChainData recentChainData; + private final Spec spec = TestSpecFactory.createMinimalElectra(); + private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); + + private VoluntaryExitValidatorElectra validatorElectra; + + private final PredicatesElectra predicates = new PredicatesElectra(spec.getGenesisSpecConfig()); + private final BeaconStateAccessorsElectra stateAccessors = + mock(BeaconStateAccessorsElectra.class); + + @BeforeEach + void setup() throws Exception { + recentChainData = MemoryOnlyRecentChainData.create(spec); + final BeaconChainUtil beaconChainUtil = + BeaconChainUtil.create(spec, recentChainData, VALIDATOR_KEYS, true); + validatorElectra = + new VoluntaryExitValidatorElectra(spec.getGenesisSpecConfig(), predicates, stateAccessors); + + beaconChainUtil.initializeStorage(); + beaconChainUtil.createAndImportBlockAtSlot(6); + } + + @Test + public void shouldAcceptValidVoluntaryExit() throws Exception { + when(stateAccessors.getPendingBalanceToWithdraw(any(), anyInt())).thenReturn(UInt64.ZERO); + + final SignedVoluntaryExit exit = + dataStructureUtil.randomSignedVoluntaryExit(dataStructureUtil.randomUInt64(24)); + final BeaconStateElectra stateElectra = + BeaconStateElectra.required(recentChainData.getBestState().orElseThrow().get()); + assertThat(validatorElectra.validateElectraConditions(stateElectra, exit)).isEmpty(); + } + + @Test + public void shouldRejectValidVoluntaryExitWithPendingWithdrawals() throws Exception { + when(stateAccessors.getPendingBalanceToWithdraw(any(), anyInt())).thenReturn(UInt64.ONE); + + final SignedVoluntaryExit exit = + dataStructureUtil.randomSignedVoluntaryExit(dataStructureUtil.randomUInt64(24)); + final BeaconStateElectra stateElectra = + BeaconStateElectra.required(recentChainData.getBestState().orElseThrow().get()); + assertThat(validatorElectra.validateElectraConditions(stateElectra, exit)) + .contains(VoluntaryExitValidator.ExitInvalidReason.pendingWithdrawalsInQueue()); + } +} diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/phase0/operations/validation/OperationValidatorPhase0Test.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/phase0/operations/validation/OperationValidatorPhase0Test.java index ec203b5da34..bf6c04e540f 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/phase0/operations/validation/OperationValidatorPhase0Test.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/logic/versions/phase0/operations/validation/OperationValidatorPhase0Test.java @@ -18,7 +18,6 @@ import static org.mockito.Mockito.verifyNoInteractions; import org.junit.jupiter.api.Test; -import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.datastructures.operations.BlsToExecutionChange; import tech.pegasys.teku.spec.datastructures.state.Fork; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; @@ -33,27 +32,27 @@ public class OperationValidatorPhase0Test { @Test void shouldRejectBlsOperationsPhase0() { - final SpecConfig specConfig = mock(SpecConfig.class); final Predicates predicates = mock(Predicates.class); final BeaconStateAccessors beaconStateAccessors = mock(BeaconStateAccessors.class); final AttestationDataValidator attestationDataValidator = mock(AttestationDataValidator.class); final AttestationUtil attestationUtil = mock(AttestationUtil.class); + final VoluntaryExitValidator voluntaryExitValidator = mock(VoluntaryExitValidator.class); final OperationValidator operationValidator = new OperationValidatorPhase0( - specConfig, predicates, beaconStateAccessors, attestationDataValidator, - attestationUtil); + attestationUtil, + voluntaryExitValidator); assertThat( operationValidator.validateBlsToExecutionChange( mock(Fork.class), mock(BeaconState.class), mock(BlsToExecutionChange.class))) .containsInstanceOf(OperationInvalidReason.class); - verifyNoInteractions(specConfig); verifyNoInteractions(predicates); verifyNoInteractions(beaconStateAccessors); verifyNoInteractions(attestationDataValidator); verifyNoInteractions(attestationUtil); + verifyNoInteractions(voluntaryExitValidator); } } diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionCacheTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionCacheTest.java index 2eb238995fd..adf512454e3 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionCacheTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/schemas/SchemaDefinitionCacheTest.java @@ -40,6 +40,7 @@ import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.config.SpecConfigAndParent; import tech.pegasys.teku.spec.config.SpecConfigLoader; import tech.pegasys.teku.spec.networks.Eth2Network; import tech.pegasys.teku.spec.schemas.SchemaDefinitions.NonSchema; @@ -51,7 +52,8 @@ public class SchemaDefinitionCacheTest { @MethodSource("allNetworksWithAllMilestones") void shouldGetSchemasForAllMilestonesOnAllNetworks( final Eth2Network network, final SpecMilestone specMilestone) { - final SpecConfig specConfig = SpecConfigLoader.loadConfigStrict(network.configName()); + final SpecConfigAndParent specConfig = + SpecConfigLoader.loadConfigStrict(network.configName()); final Spec spec = SpecFactory.create(specConfig); final SchemaDefinitionCache cache = new SchemaDefinitionCache(spec); assertThat(cache.getSchemaDefinition(specMilestone)).isNotNull(); diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/schemas/registry/BaseSchemaProviderTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/schemas/registry/BaseSchemaProviderTest.java new file mode 100644 index 00000000000..282910c679b --- /dev/null +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/schemas/registry/BaseSchemaProviderTest.java @@ -0,0 +1,199 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.schemas.registry; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; +import static tech.pegasys.teku.spec.SpecMilestone.ALTAIR; +import static tech.pegasys.teku.spec.SpecMilestone.BELLATRIX; +import static tech.pegasys.teku.spec.SpecMilestone.CAPELLA; +import static tech.pegasys.teku.spec.SpecMilestone.DENEB; +import static tech.pegasys.teku.spec.SpecMilestone.PHASE0; +import static tech.pegasys.teku.spec.schemas.registry.BaseSchemaProvider.providerBuilder; + +import java.util.concurrent.atomic.AtomicReference; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SchemaId; + +class BaseSchemaProviderTest { + @SuppressWarnings("unchecked") + private static final SchemaId STRING_SCHEMA_ID = mock(SchemaId.class); + + private final SchemaRegistry mockRegistry = mock(SchemaRegistry.class); + + @Test + void shouldCallCreatorWithCorrectParams() { + final AtomicReference registryRef = new AtomicReference<>(); + final AtomicReference configRef = new AtomicReference<>(); + final AtomicReference schemaNameRef = new AtomicReference<>(); + final SpecConfig specConfig = mock(SpecConfig.class); + + final SchemaProvider provider = + providerBuilder(STRING_SCHEMA_ID) + .withCreator( + PHASE0, + (r, c, n) -> { + registryRef.set(r); + configRef.set(c); + schemaNameRef.set(n); + return "TestSchema"; + }) + .build(); + + when(mockRegistry.getMilestone()).thenReturn(PHASE0); + when(mockRegistry.getSpecConfig()).thenReturn(specConfig); + when(STRING_SCHEMA_ID.getSchemaName(PHASE0)).thenReturn("TestSchemaPhase0"); + when(mockRegistry.getMilestone()).thenReturn(PHASE0); + when(mockRegistry.getSpecConfig()).thenReturn(specConfig); + + assertEquals("TestSchema", provider.getSchema(mockRegistry)); + + assertEquals(mockRegistry, registryRef.get()); + assertEquals(specConfig, configRef.get()); + assertEquals("TestSchemaPhase0", schemaNameRef.get()); + } + + @Test + void shouldSupportContinuousUntilHighestMilestone() { + final SchemaProvider provider = + providerBuilder(STRING_SCHEMA_ID) + .withCreator(ALTAIR, (r, c, n) -> "TestSchemaAltair") + .withCreator(BELLATRIX, (r, c, n) -> "TestSchemaBellatrix") + .build(); + + assertEquals(ALTAIR, provider.getBaseMilestone(ALTAIR)); + assertEquals(BELLATRIX, provider.getBaseMilestone(BELLATRIX)); + + when(mockRegistry.getMilestone()).thenReturn(ALTAIR); + assertEquals("TestSchemaAltair", provider.getSchema(mockRegistry)); + + when(mockRegistry.getMilestone()).thenReturn(BELLATRIX); + assertEquals("TestSchemaBellatrix", provider.getSchema(mockRegistry)); + + assertThat(provider.getSupportedMilestones()) + .containsAll(SpecMilestone.getAllMilestonesFrom(ALTAIR)); + } + + @Test + void shouldSupportContinuousConstantWithUntil() { + final SchemaProvider provider = + providerBuilder(STRING_SCHEMA_ID) + .withCreator(PHASE0, (r, c, n) -> "TestSchemaPhase0") + .withCreator(BELLATRIX, (r, c, n) -> "TestSchemaBellatrix") + .until(CAPELLA) + .build(); + + assertEquals(PHASE0, provider.getBaseMilestone(PHASE0)); + assertEquals(PHASE0, provider.getBaseMilestone(ALTAIR)); + assertEquals(BELLATRIX, provider.getBaseMilestone(BELLATRIX)); + assertEquals(BELLATRIX, provider.getBaseMilestone(CAPELLA)); + + when(mockRegistry.getMilestone()).thenReturn(PHASE0); + assertEquals("TestSchemaPhase0", provider.getSchema(mockRegistry)); + + when(mockRegistry.getMilestone()).thenReturn(ALTAIR); + assertEquals("TestSchemaPhase0", provider.getSchema(mockRegistry)); + + when(mockRegistry.getMilestone()).thenReturn(BELLATRIX); + assertEquals("TestSchemaBellatrix", provider.getSchema(mockRegistry)); + + when(mockRegistry.getMilestone()).thenReturn(CAPELLA); + assertEquals("TestSchemaBellatrix", provider.getSchema(mockRegistry)); + + assertThat(provider.getSupportedMilestones()) + .containsExactly(PHASE0, ALTAIR, BELLATRIX, CAPELLA); + } + + @Test + void shouldAlwaysCreateNewSchemaDisabledByDefault() { + final SchemaProvider provider = + providerBuilder(STRING_SCHEMA_ID) + .withCreator(PHASE0, (r, c, n) -> "TestSchema" + r.getMilestone()) + .build(); + + assertFalse(provider.alwaysCreateNewSchema()); + } + + @Test + void shouldSupportAlwaysCreateNewSchema() { + final SchemaProvider provider = + providerBuilder(STRING_SCHEMA_ID) + .withCreator(PHASE0, (r, c, n) -> "TestSchema" + r.getMilestone()) + .alwaysCreateNewSchema() + .build(); + + assertTrue(provider.alwaysCreateNewSchema()); + } + + @Test + void shouldThrowWhenNoCreators() { + assertThatThrownBy(() -> providerBuilder(STRING_SCHEMA_ID).build()) + .isInstanceOf(IllegalArgumentException.class) + .hasMessageStartingWith("There should be at least 1 creator"); + } + + @Test + void shouldThrowWhenAskingForAnUnsupportedMilestone() { + final SchemaProvider provider = + providerBuilder(STRING_SCHEMA_ID) + .withCreator(ALTAIR, (r, c, n) -> "TestSchemaAltair") + .until(ALTAIR) + .build(); + + when(mockRegistry.getMilestone()).thenReturn(DENEB); + + assertThatThrownBy(() -> provider.getSchema(mockRegistry)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("It is not supposed to create a specific version for DENEB"); + } + + @Test + void shouldThrowWhenNotAscendingMilestones() { + assertThatThrownBy( + () -> + providerBuilder(STRING_SCHEMA_ID) + .withCreator(PHASE0, (r, c, n) -> "TestSchema") + .withCreator(PHASE0, (r, c, n) -> "TestSchema")) + .isInstanceOf(IllegalArgumentException.class) + .hasMessageStartingWith("Creator's milestones must added in strict ascending order"); + + assertThatThrownBy( + () -> + providerBuilder(STRING_SCHEMA_ID) + .withCreator(ALTAIR, (r, c, n) -> "TestSchema") + .withCreator(PHASE0, (r, c, n) -> "TestSchema")) + .isInstanceOf(IllegalArgumentException.class) + .hasMessageStartingWith("Creator's milestones must added in strict ascending order"); + } + + @Test + void shouldThrowWhenWithUntilIsPriorToMilestone() { + assertThatThrownBy( + () -> + providerBuilder(STRING_SCHEMA_ID) + .withCreator(PHASE0, (r, c, n) -> "TestSchema") + .withCreator(CAPELLA, (r, c, n) -> "TestSchema") + .until(ALTAIR) + .build()) + .isInstanceOf(IllegalArgumentException.class) + .hasMessageStartingWith("until must be greater or equal than last creator milestone"); + } +} diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/schemas/registry/SchemaCacheTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/schemas/registry/SchemaCacheTest.java new file mode 100644 index 00000000000..920c4b3954a --- /dev/null +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/schemas/registry/SchemaCacheTest.java @@ -0,0 +1,105 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.schemas.registry; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SchemaId; + +public class SchemaCacheTest { + + private SchemaCache schemaCache; + + @BeforeEach + void setUp() { + schemaCache = SchemaCache.createDefault(); + } + + @Test + void shouldPutAndGetSchema() { + final SchemaId schemaId = SchemaTypes.create("test"); + final SpecMilestone milestone = SpecMilestone.PHASE0; + final String schema = "Test Schema"; + + schemaCache.put(milestone, schemaId, schema); + final String retrievedSchema = schemaCache.get(milestone, schemaId); + + assertEquals(schema, retrievedSchema); + } + + @Test + void shouldReturnNullForNonExistentSchema() { + final SchemaId schemaId = SchemaTypes.create("nonexistent"); + final SpecMilestone milestone = SpecMilestone.PHASE0; + + final String retrievedSchema = schemaCache.get(milestone, schemaId); + + assertNull(retrievedSchema); + } + + @Test + void shouldPutAndGetMultipleSchemasForSameMilestone() { + final SchemaId schemaId1 = SchemaTypes.create("test1"); + final SchemaId schemaId2 = SchemaTypes.create("test2"); + final SpecMilestone milestone = SpecMilestone.PHASE0; + final String schema1 = "Test Schema 1"; + final Integer schema2 = 42; + + schemaCache.put(milestone, schemaId1, schema1); + schemaCache.put(milestone, schemaId2, schema2); + + final String retrievedSchema1 = schemaCache.get(milestone, schemaId1); + final Integer retrievedSchema2 = schemaCache.get(milestone, schemaId2); + + assertEquals(schema1, retrievedSchema1); + assertEquals(schema2, retrievedSchema2); + } + + @Test + void shouldPutAndGetSchemasForDifferentMilestones() { + final SchemaId schemaId = SchemaTypes.create("test"); + final SpecMilestone milestone1 = SpecMilestone.PHASE0; + final SpecMilestone milestone2 = SpecMilestone.ALTAIR; + final String schema1 = "Test Schema 1"; + final String schema2 = "Test Schema 2"; + + schemaCache.put(milestone1, schemaId, schema1); + schemaCache.put(milestone2, schemaId, schema2); + + final String retrievedSchema1 = schemaCache.get(milestone1, schemaId); + final String retrievedSchema2 = schemaCache.get(milestone2, schemaId); + + assertEquals(schema1, retrievedSchema1); + assertEquals(schema2, retrievedSchema2); + } + + @Test + void shouldOverwriteExistingSchema() { + final SchemaId schemaId = SchemaTypes.create("test"); + final SpecMilestone milestone = SpecMilestone.PHASE0; + final String schema1 = "Test Schema 1"; + final String schema2 = "Test Schema 2"; + + schemaCache.put(milestone, schemaId, schema1); + schemaCache.put(milestone, schemaId, schema2); + + final String retrievedSchema = schemaCache.get(milestone, schemaId); + + assertEquals(schema2, retrievedSchema); + } +} diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/schemas/registry/SchemaRegistryBuilderTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/schemas/registry/SchemaRegistryBuilderTest.java new file mode 100644 index 00000000000..028384e3938 --- /dev/null +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/schemas/registry/SchemaRegistryBuilderTest.java @@ -0,0 +1,131 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.schemas.registry; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static tech.pegasys.teku.spec.SpecMilestone.ALTAIR; +import static tech.pegasys.teku.spec.SpecMilestone.BELLATRIX; +import static tech.pegasys.teku.spec.SpecMilestone.PHASE0; + +import java.util.EnumSet; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SchemaId; + +public class SchemaRegistryBuilderTest { + private final SpecConfig specConfig = mock(SpecConfig.class); + private final SchemaCache cache = spy(SchemaCache.createDefault()); + private final SchemaRegistryBuilder builder = new SchemaRegistryBuilder(cache); + private final SchemaId stringId = SchemaTypes.create("stringType"); + private final String stringSchema = "stringSchema"; + + @SuppressWarnings("unchecked") + private final SchemaProvider mockProvider = mock(SchemaProvider.class); + + private final EnumSet supportedMilestones = EnumSet.of(PHASE0, ALTAIR); + + @BeforeEach + void setUp() { + when(mockProvider.getSchemaId()).thenReturn(stringId); + when(mockProvider.getSchema(any())).thenReturn(stringSchema); + when(mockProvider.getSupportedMilestones()).thenReturn(supportedMilestones); + when(mockProvider.getBaseMilestone(any())).thenReturn(PHASE0); + } + + @Test + void shouldAddProviderForSupportedMilestone() { + + builder.addProvider(mockProvider); + + for (final SpecMilestone milestone : SpecMilestone.values()) { + final SchemaRegistry registry = builder.build(milestone, specConfig); + if (supportedMilestones.contains(milestone)) { + assertThat(registry.isProviderRegistered(mockProvider)).isTrue(); + } else { + assertThat(registry.isProviderRegistered(mockProvider)).isFalse(); + } + } + + verify(mockProvider, times(SpecMilestone.values().length)).getSupportedMilestones(); + } + + @Test + void shouldPrimeRegistry() { + builder.addProvider(mockProvider); + builder.build(PHASE0, specConfig); + + // we should have it in cache immediately + verify(cache).put(PHASE0, stringId, stringSchema); + } + + @Test + void shouldAutomaticallyBuildPreviousMilestones() { + builder.addProvider(mockProvider); + builder.build(ALTAIR, specConfig); + + verify(cache).put(PHASE0, stringId, stringSchema); + verify(cache).put(ALTAIR, stringId, stringSchema); + } + + @Test + void shouldThrowWhenNotBuildingInOrder() { + builder.build(PHASE0, specConfig); + + assertThatThrownBy(() -> builder.build(BELLATRIX, specConfig)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessageContaining( + "Build must follow the milestone ordering. Last built milestone: PHASE0, requested milestone: BELLATRIX"); + } + + @Test + void shouldThrowWhenBuildingSameMilestoneTwice() { + builder.build(PHASE0, specConfig); + builder.build(ALTAIR, specConfig); + + assertThatThrownBy(() -> builder.build(ALTAIR, specConfig)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessageContaining( + "Build must follow the milestone ordering. Last built milestone: ALTAIR, requested milestone: ALTAIR"); + } + + @Test + void shouldThrowWhenAddingTheSameProviderTwice() { + builder.addProvider(mockProvider); + assertThatThrownBy(() -> builder.addProvider(mockProvider)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessageContaining("has been already added"); + } + + @Test + void shouldThrowWhenAddingTwoProvidersReferencingTheSameSchemaId() { + @SuppressWarnings("unchecked") + final SchemaProvider mockProvider2 = mock(SchemaProvider.class); + when(mockProvider2.getSchemaId()).thenReturn(stringId); + + builder.addProvider(mockProvider); + + assertThatThrownBy(() -> builder.addProvider(mockProvider2)) + .isInstanceOf(IllegalStateException.class) + .hasMessageContaining("A previously added provider was already providing the"); + } +} diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/schemas/registry/SchemaRegistryTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/schemas/registry/SchemaRegistryTest.java new file mode 100644 index 00000000000..3cdfc78b5ff --- /dev/null +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/schemas/registry/SchemaRegistryTest.java @@ -0,0 +1,362 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.schemas.registry; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.infrastructure.ssz.collections.SszByteList; +import tech.pegasys.teku.infrastructure.ssz.containers.Container1; +import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema1; +import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszByteListSchema; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SchemaId; + +public class SchemaRegistryTest { + + private final SpecConfig specConfig = mock(SpecConfig.class); + private final SchemaCache schemaCache = spy(SchemaCache.createDefault()); + + @SuppressWarnings("unchecked") + private final SchemaProvider schemaProvider = mock(SchemaProvider.class); + + @SuppressWarnings("unchecked") + private final SchemaId schemaId = mock(SchemaId.class); + + private final SchemaRegistry schemaRegistry = + new SchemaRegistry(SpecMilestone.ALTAIR, specConfig, schemaCache); + + @Test + void shouldGetSchemaFromCache() { + final TestSchema cachedSchema = new TestSchema("test", 2); + when(schemaProvider.getSchemaId()).thenReturn(schemaId); + when(schemaCache.get(SpecMilestone.ALTAIR, schemaId)).thenReturn(cachedSchema); + + schemaRegistry.registerProvider(schemaProvider); + final TestSchema result = schemaRegistry.get(schemaId); + + assertEquals(cachedSchema, result); + verify(schemaCache).get(SpecMilestone.ALTAIR, schemaId); + verify(schemaProvider, never()).getSchema(any()); + } + + @Test + void shouldGetNewInstanceWhenSchemaEqualityCheckIsDisabled() { + + // two different schema instances but equal + final TestSchema newSchema = new TestSchema("test", 2); + final TestSchema cachedPhase0Schema = new TestSchema("test1", 2); + + assertThat(newSchema).isNotSameAs(cachedPhase0Schema); + assertThat(newSchema).isEqualTo(cachedPhase0Schema); + + when(schemaProvider.getSchemaId()).thenReturn(schemaId); + when(schemaCache.get(SpecMilestone.PHASE0, schemaId)).thenReturn(cachedPhase0Schema); + when(schemaProvider.getBaseMilestone(SpecMilestone.ALTAIR)).thenReturn(SpecMilestone.PHASE0); + when(schemaProvider.getSchema(schemaRegistry)).thenReturn(newSchema); + when(schemaProvider.alwaysCreateNewSchema()).thenReturn(true); + + schemaRegistry.registerProvider(schemaProvider); + final TestSchema result = schemaRegistry.get(schemaId); + + assertThat(result).isSameAs(newSchema); + + verify(schemaCache, never()).get(SpecMilestone.PHASE0, schemaId); + verify(schemaCache).get(SpecMilestone.ALTAIR, schemaId); + verify(schemaProvider).getSchema(schemaRegistry); + verify(schemaCache).put(SpecMilestone.ALTAIR, schemaId, result); + } + + @Test + void shouldGetPreviousMilestoneInstanceWhenSchemaAreEqual() { + + // two different schema instances but equal + final TestSchema newSchema = new TestSchema("test", 2); + final TestSchema cachedPhase0Schema = new TestSchema("test1", 2); + + assertThat(newSchema).isNotSameAs(cachedPhase0Schema); + assertThat(newSchema).isEqualTo(cachedPhase0Schema); + + when(schemaProvider.getSchemaId()).thenReturn(schemaId); + when(schemaCache.get(SpecMilestone.PHASE0, schemaId)).thenReturn(cachedPhase0Schema); + when(schemaProvider.getBaseMilestone(SpecMilestone.ALTAIR)).thenReturn(SpecMilestone.PHASE0); + when(schemaProvider.getSchema(schemaRegistry)).thenReturn(newSchema); + when(schemaProvider.alwaysCreateNewSchema()).thenReturn(false); + + schemaRegistry.registerProvider(schemaProvider); + final TestSchema result = schemaRegistry.get(schemaId); + + assertThat(result).isSameAs(cachedPhase0Schema); + + verify(schemaCache).get(SpecMilestone.PHASE0, schemaId); + verify(schemaCache).get(SpecMilestone.ALTAIR, schemaId); + verify(schemaProvider).getSchema(schemaRegistry); + verify(schemaCache).put(SpecMilestone.ALTAIR, schemaId, result); + } + + @Test + void shouldGetNewInstanceWhenSchemaAreNotEqual() { + + // two different schema instances but equal + final TestSchema newSchema = new TestSchema("test", 3); + final TestSchema cachedPhase0Schema = new TestSchema("test1", 2); + + assertThat(newSchema).isNotEqualTo(cachedPhase0Schema); + + when(schemaProvider.getSchemaId()).thenReturn(schemaId); + when(schemaCache.get(SpecMilestone.PHASE0, schemaId)).thenReturn(cachedPhase0Schema); + when(schemaProvider.getBaseMilestone(SpecMilestone.ALTAIR)).thenReturn(SpecMilestone.PHASE0); + when(schemaProvider.getSchema(schemaRegistry)).thenReturn(newSchema); + when(schemaProvider.alwaysCreateNewSchema()).thenReturn(false); + + schemaRegistry.registerProvider(schemaProvider); + final TestSchema result = schemaRegistry.get(schemaId); + + assertThat(result).isSameAs(newSchema); + + verify(schemaCache).get(SpecMilestone.PHASE0, schemaId); + verify(schemaCache).get(SpecMilestone.ALTAIR, schemaId); + verify(schemaProvider).getSchema(schemaRegistry); + verify(schemaCache).put(SpecMilestone.ALTAIR, schemaId, result); + } + + @Test + void shouldGetNewInstanceWhenNoPreviousCachedSchemaExists() { + final TestSchema newSchema = new TestSchema("test", 3); + + when(schemaProvider.getSchemaId()).thenReturn(schemaId); + when(schemaCache.get(SpecMilestone.PHASE0, schemaId)).thenReturn(null); + when(schemaProvider.getBaseMilestone(SpecMilestone.ALTAIR)).thenReturn(SpecMilestone.PHASE0); + when(schemaProvider.getSchema(schemaRegistry)).thenReturn(newSchema); + when(schemaProvider.alwaysCreateNewSchema()).thenReturn(false); + + schemaRegistry.registerProvider(schemaProvider); + final TestSchema result = schemaRegistry.get(schemaId); + + assertThat(result).isSameAs(newSchema); + + verify(schemaCache).get(SpecMilestone.PHASE0, schemaId); + verify(schemaCache).get(SpecMilestone.ALTAIR, schemaId); + verify(schemaProvider).getSchema(schemaRegistry); + verify(schemaCache).put(SpecMilestone.ALTAIR, schemaId, result); + } + + @Test + void shouldGetNewInstanceWhenPhase0() { + final SchemaRegistry schemaRegistry = + new SchemaRegistry(SpecMilestone.PHASE0, specConfig, schemaCache); + + // two different schema instances but equal + final TestSchema newSchema = new TestSchema("test", 3); + + when(schemaProvider.getSchemaId()).thenReturn(schemaId); + when(schemaCache.get(SpecMilestone.PHASE0, schemaId)).thenReturn(null); + when(schemaProvider.getBaseMilestone(SpecMilestone.PHASE0)).thenReturn(SpecMilestone.PHASE0); + when(schemaProvider.getSchema(schemaRegistry)).thenReturn(newSchema); + when(schemaProvider.alwaysCreateNewSchema()).thenReturn(false); + + schemaRegistry.registerProvider(schemaProvider); + final TestSchema result = schemaRegistry.get(schemaId); + + assertThat(result).isSameAs(newSchema); + + verify(schemaCache).get(SpecMilestone.PHASE0, schemaId); + verify(schemaProvider).getSchema(schemaRegistry); + verify(schemaCache).put(SpecMilestone.PHASE0, schemaId, result); + } + + @Test + void shouldThrowExceptionWhenGettingSchemaForUnregisteredProvider() { + assertThrows(IllegalArgumentException.class, () -> schemaRegistry.get(schemaId)); + } + + @Test + @SuppressWarnings("unchecked") + void shouldThrowIfDependencyWhenDependencyLoop() { + final SchemaProvider provider1 = mock(SchemaProvider.class); + final SchemaProvider provider2 = mock(SchemaProvider.class); + final SchemaProvider provider3 = mock(SchemaProvider.class); + final SchemaId id1 = mock(SchemaId.class); + final SchemaId id2 = mock(SchemaId.class); + final SchemaId id3 = mock(SchemaId.class); + + when(provider1.getSchemaId()).thenReturn(id1); + when(provider2.getSchemaId()).thenReturn(id2); + when(provider3.getSchemaId()).thenReturn(id3); + + // create a dependency loop + when(provider1.getSchema(schemaRegistry)) + .thenAnswer( + invocation -> { + invocation.getArgument(0, SchemaRegistry.class).get(id2); + return "test"; + }); + + when(provider2.getSchema(schemaRegistry)) + .thenAnswer( + invocation -> { + invocation.getArgument(0, SchemaRegistry.class).get(id3); + return 42; + }); + + when(provider3.getSchema(schemaRegistry)) + .thenAnswer( + invocation -> { + invocation.getArgument(0, SchemaRegistry.class).get(id1); + return 42; + }); + + schemaRegistry.registerProvider(provider1); + schemaRegistry.registerProvider(provider2); + schemaRegistry.registerProvider(provider3); + + assertThatThrownBy(schemaRegistry::primeRegistry) + .isInstanceOf(IllegalStateException.class) + .hasMessageStartingWith("loop detected creating schema"); + } + + @Test + @SuppressWarnings("unchecked") + void shouldThrowIfDependencyWhenMutualDependencyLoop() { + final SchemaProvider provider1 = mock(SchemaProvider.class); + final SchemaProvider provider2 = mock(SchemaProvider.class); + final SchemaId id1 = mock(SchemaId.class); + final SchemaId id2 = mock(SchemaId.class); + + when(provider1.getSchemaId()).thenReturn(id1); + when(provider2.getSchemaId()).thenReturn(id2); + + // create a mutual dependency + when(provider2.getSchema(schemaRegistry)) + .thenAnswer( + invocation -> { + invocation.getArgument(0, SchemaRegistry.class).get(id1); + return 42; + }); + + when(provider1.getSchema(schemaRegistry)) + .thenAnswer( + invocation -> { + invocation.getArgument(0, SchemaRegistry.class).get(id2); + return "test"; + }); + + schemaRegistry.registerProvider(provider1); + schemaRegistry.registerProvider(provider2); + + assertThatThrownBy(schemaRegistry::primeRegistry) + .isInstanceOf(IllegalStateException.class) + .hasMessageStartingWith("loop detected creating schema"); + } + + @Test + @SuppressWarnings("unchecked") + void shouldResolveNonLoopedDependencies() { + final SchemaProvider provider1 = mock(SchemaProvider.class); + final SchemaProvider provider2 = mock(SchemaProvider.class); + + final SchemaId id1 = mock(SchemaId.class); + final SchemaId id2 = mock(SchemaId.class); + + when(provider1.getBaseMilestone(SpecMilestone.ALTAIR)).thenReturn(SpecMilestone.ALTAIR); + when(provider2.getBaseMilestone(SpecMilestone.ALTAIR)).thenReturn(SpecMilestone.ALTAIR); + when(provider1.getSchemaId()).thenReturn(id1); + when(provider2.getSchemaId()).thenReturn(id2); + + // create a mutual dependency + when(provider1.getSchema(schemaRegistry)).thenReturn("test"); + when(provider2.getSchema(schemaRegistry)) + .thenAnswer( + invocation -> { + invocation.getArgument(0, SchemaRegistry.class).get(id1); + return 42; + }); + + schemaRegistry.registerProvider(provider1); + schemaRegistry.registerProvider(provider2); + + schemaRegistry.primeRegistry(); + + verify(schemaCache).put(SpecMilestone.ALTAIR, id1, "test"); + verify(schemaCache).put(SpecMilestone.ALTAIR, id2, 42); + } + + @Test + @SuppressWarnings("unchecked") + void shouldPrimeRegistry() { + final SchemaProvider provider1 = mock(SchemaProvider.class); + final SchemaProvider provider2 = mock(SchemaProvider.class); + final SchemaId id1 = mock(SchemaId.class); + final SchemaId id2 = mock(SchemaId.class); + + when(provider1.getBaseMilestone(SpecMilestone.ALTAIR)).thenReturn(SpecMilestone.ALTAIR); + when(provider2.getBaseMilestone(SpecMilestone.ALTAIR)).thenReturn(SpecMilestone.ALTAIR); + when(provider1.getSchemaId()).thenReturn(id1); + when(provider2.getSchemaId()).thenReturn(id2); + + schemaRegistry.registerProvider(provider1); + schemaRegistry.registerProvider(provider2); + + schemaRegistry.primeRegistry(); + + verify(provider1).getSchema(schemaRegistry); + verify(provider2).getSchema(schemaRegistry); + } + + @Test + void shouldThrowIfPrimeTwice() { + schemaRegistry.primeRegistry(); + assertThatThrownBy(schemaRegistry::primeRegistry) + .isInstanceOf(IllegalStateException.class) + .hasMessage("Registry already primed"); + } + + @Test + @SuppressWarnings("unchecked") + void shouldThrowIfRegisteringTheSameSchemaIdTwice() { + final SchemaProvider provider1 = mock(SchemaProvider.class); + schemaRegistry.registerProvider(provider1); + assertThatThrownBy(() -> schemaRegistry.registerProvider(provider1)) + .isInstanceOf(IllegalStateException.class) + .hasMessageContaining("has been already added via another provider"); + } + + static class TestView extends Container1 { + public TestView(final TestSchema schema, final SszByteList field0) { + super(schema, field0); + } + } + + static class TestSchema extends ContainerSchema1 { + public TestSchema(final String containerName, final int size) { + super(containerName, namedSchema("field0", SszByteListSchema.create(size))); + } + + @Override + public TestView createFromBackingNode(final TreeNode node) { + return null; + } + } +} diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/schemas/registry/SchemaTypesTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/schemas/registry/SchemaTypesTest.java new file mode 100644 index 00000000000..3d96d111ac2 --- /dev/null +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/schemas/registry/SchemaTypesTest.java @@ -0,0 +1,59 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.schemas.registry; + +import static java.lang.reflect.Modifier.isFinal; +import static java.lang.reflect.Modifier.isStatic; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.lang.reflect.Field; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.schemas.registry.SchemaTypes.SchemaId; + +public class SchemaTypesTest { + + @Test + public void shouldProvideContainerNameViaSchemaId() { + final SchemaId schemaId = SchemaTypes.create("MY_TEST_SCHEMA"); + assertEquals("MyTest", schemaId.getSchemaName()); + assertEquals("MyTestDeneb", schemaId.getSchemaName(SpecMilestone.DENEB)); + } + + @Test + public void validateStaticFieldNamesAndSchemaIdNames() throws IllegalAccessException { + // Get all declared fields in the SchemaTypes class + final Field[] fields = SchemaTypes.class.getDeclaredFields(); + + for (final Field field : fields) { + // Ensure the field is static and final + if (isStatic(field.getModifiers()) && isFinal(field.getModifiers())) { + + // Get the field name + final String fieldName = field.getName(); + + assertThat(fieldName).matches("^[A-Z][A-Z_]*_SCHEMA$"); + + // Get the value of the field + if (field.get(null) instanceof SchemaId schemaId) { + assertEquals( + fieldName, + schemaId.getName(), + "Field name does not match the create argument for field: " + fieldName); + } + } + } + } +} diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/signatures/LocalSignerTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/signatures/LocalSignerTest.java index 195e1d1f462..63100d4914f 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/signatures/LocalSignerTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/signatures/LocalSignerTest.java @@ -73,7 +73,7 @@ public void shouldSignBlindedBlock() { final BLSSignature expectedSignature = BLSSignature.fromBytesCompressed( Bytes.fromBase64String( - "pbSSuf7h70JkzI/U157flTWPZDuaBXgRLj1HLMoCwjA4Xd0hMdGewn7G2HLZiQcNC9G6FSd1+0BT5PwknYez4ya6TccwpaGnsvWYLPf3SNIX5Ug7Yi1CF1fvEr3x9sZ0")); + "o2ekZJkMs5GPMFR7sVgIf/ikm9QATJRSnXCk8AR/58c/t6C4H5RJKNhU662xS6XBC2i/I0PF4HaTOV4gX8pNMWcHnGB06ZHTSWQ5NFwnhEMQ3GLO2/BYYd5arJkVp/Tc")); final SafeFuture result = signer.signBlock(block, fork); asyncRunner.executeQueuedActions(); diff --git a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/signatures/LocalSlashingProtectorTest.java b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/signatures/LocalSlashingProtectorTest.java index fc31f4068cb..bc3793168be 100644 --- a/ethereum/spec/src/test/java/tech/pegasys/teku/spec/signatures/LocalSlashingProtectorTest.java +++ b/ethereum/spec/src/test/java/tech/pegasys/teku/spec/signatures/LocalSlashingProtectorTest.java @@ -101,7 +101,7 @@ static List attestationCases() { final Optional existingRecord = Optional.of( new ValidatorSigningRecord( - GENESIS_VALIDATORS_ROOT, + Optional.of(GENESIS_VALIDATORS_ROOT), ATTESTATION_TEST_BLOCK_SLOT, UInt64.valueOf(4), UInt64.valueOf(6))); @@ -150,7 +150,7 @@ private void assertAttestationSigningAllowed( final ValidatorSigningRecord updatedRecord = new ValidatorSigningRecord( - GENESIS_VALIDATORS_ROOT, + Optional.of(GENESIS_VALIDATORS_ROOT), lastSignedAttestation.isPresent() ? ATTESTATION_TEST_BLOCK_SLOT : UInt64.ZERO, sourceEpoch, targetEpoch); @@ -186,7 +186,7 @@ private void assertBlockSigningAllowed( lastSignedBlockSlot.isPresent() ? blockTestSigningRecord(newBlockSlot) : new ValidatorSigningRecord( - GENESIS_VALIDATORS_ROOT, + Optional.of(GENESIS_VALIDATORS_ROOT), newBlockSlot, ValidatorSigningRecord.NEVER_SIGNED, ValidatorSigningRecord.NEVER_SIGNED) @@ -196,7 +196,10 @@ private void assertBlockSigningAllowed( private Bytes blockTestSigningRecord(final UInt64 blockSlot) { return new ValidatorSigningRecord( - GENESIS_VALIDATORS_ROOT, blockSlot, BLOCK_TEST_SOURCE_EPOCH, BLOCK_TEST_TARGET_EPOCH) + Optional.of(GENESIS_VALIDATORS_ROOT), + blockSlot, + BLOCK_TEST_SOURCE_EPOCH, + BLOCK_TEST_TARGET_EPOCH) .toBytes(); } diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/TestSpecFactory.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/TestSpecFactory.java index a7d9e84818f..54063587e5e 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/TestSpecFactory.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/TestSpecFactory.java @@ -13,15 +13,14 @@ package tech.pegasys.teku.spec; +import static com.google.common.base.Preconditions.checkArgument; +import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ZERO; + import com.google.common.base.Preconditions; import java.util.function.Consumer; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.config.SpecConfig; -import tech.pegasys.teku.spec.config.SpecConfigAltair; -import tech.pegasys.teku.spec.config.SpecConfigBellatrix; -import tech.pegasys.teku.spec.config.SpecConfigCapella; -import tech.pegasys.teku.spec.config.SpecConfigDeneb; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.SpecConfigAndParent; import tech.pegasys.teku.spec.config.SpecConfigLoader; import tech.pegasys.teku.spec.config.builder.SpecConfigBuilder; import tech.pegasys.teku.spec.networks.Eth2Network; @@ -33,7 +32,7 @@ public static Spec createDefault() { } public static Spec createDefault(final Consumer modifier) { - final SpecConfig config = + final SpecConfigAndParent config = SpecConfigLoader.loadConfig(Eth2Network.MINIMAL.configName(), modifier); return create(config, SpecMilestone.PHASE0); } @@ -45,7 +44,8 @@ public static Spec createMinimal(final SpecMilestone specMilestone) { case BELLATRIX -> createMinimalBellatrix(); case CAPELLA -> createMinimalCapella(); case DENEB -> createMinimalDeneb(); - case EIP7594 -> createMinimalEip7594(); + case ELECTRA -> createMinimalElectra(); + case FULU -> createMinimalFulu(); }; } @@ -56,7 +56,8 @@ public static Spec createMainnet(final SpecMilestone specMilestone) { case BELLATRIX -> createMainnetBellatrix(); case CAPELLA -> createMainnetCapella(); case DENEB -> createMainnetDeneb(); - case EIP7594 -> createMainnetEip7594(); + case ELECTRA -> createMainnetElectra(); + case FULU -> createMainnetFulu(); }; } @@ -67,50 +68,81 @@ public static Spec createMinimalWithAltairAndBellatrixForkEpoch( String.format( "Altair epoch %s must be less than bellatrix epoch %s", altairEpoch, bellatrixForkEpoch)); - final SpecConfigBellatrix config = + final SpecConfigAndParent specConfig = getBellatrixSpecConfig(Eth2Network.MINIMAL, altairEpoch, bellatrixForkEpoch); - return create(config, SpecMilestone.BELLATRIX); + return create(specConfig, SpecMilestone.BELLATRIX); } public static Spec createMinimalBellatrix() { - final SpecConfigBellatrix specConfig = getBellatrixSpecConfig(Eth2Network.MINIMAL); + final SpecConfigAndParent specConfig = + getBellatrixSpecConfig(Eth2Network.MINIMAL); return create(specConfig, SpecMilestone.BELLATRIX); } public static Spec createMinimalBellatrix(final Consumer configAdapter) { - final SpecConfigBellatrix specConfig = + final SpecConfigAndParent specConfig = getBellatrixSpecConfig(Eth2Network.MINIMAL, configAdapter); return create(specConfig, SpecMilestone.BELLATRIX); } public static Spec createMinimalAltair() { - final SpecConfigAltair specConfig = getAltairSpecConfig(Eth2Network.MINIMAL); + final SpecConfigAndParent specConfig = + getAltairSpecConfig(Eth2Network.MINIMAL); return create(specConfig, SpecMilestone.ALTAIR); } public static Spec createMinimalCapella() { - final SpecConfigCapella specConfig = getCapellaSpecConfig(Eth2Network.MINIMAL); + final SpecConfigAndParent specConfig = + getCapellaSpecConfig(Eth2Network.MINIMAL); return create(specConfig, SpecMilestone.CAPELLA); } public static Spec createMinimalDeneb() { - final SpecConfigDeneb specConfig = getDenebSpecConfig(Eth2Network.MINIMAL); + final SpecConfigAndParent specConfig = + getDenebSpecConfig(Eth2Network.MINIMAL); return create(specConfig, SpecMilestone.DENEB); } public static Spec createMinimalDeneb(final Consumer configAdapter) { - final SpecConfigDeneb specConfig = getDenebSpecConfig(Eth2Network.MINIMAL, configAdapter); + final SpecConfigAndParent specConfig = + getDenebSpecConfig(Eth2Network.MINIMAL, configAdapter); return create(specConfig, SpecMilestone.DENEB); } - public static Spec createMinimalEip7594() { - final SpecConfigEip7594 specConfig = getEip7594SpecConfig(Eth2Network.MINIMAL); - return create(specConfig, SpecMilestone.EIP7594); + public static Spec createMinimalElectra() { + final SpecConfigAndParent specConfig = + getElectraSpecConfig(Eth2Network.MINIMAL); + return create(specConfig, SpecMilestone.ELECTRA); + } + + public static Spec createMinimalElectra(final Consumer configAdapter) { + final SpecConfigAndParent specConfig = + getElectraSpecConfig(Eth2Network.MINIMAL, configAdapter); + return create(specConfig, SpecMilestone.ELECTRA); } - public static Spec createMinimalEip7594(final Consumer configAdapter) { - final SpecConfigEip7594 specConfig = getEip7594SpecConfig(Eth2Network.MINIMAL, configAdapter); - return create(specConfig, SpecMilestone.EIP7594); + public static Spec createMinimalElectraEip7594() { + final SpecConfigAndParent specConfig = + getElectraEip7594SpecConfig(Eth2Network.MINIMAL); + return create(specConfig, SpecMilestone.ELECTRA); + } + + public static Spec createMinimalElectraEip7594(final Consumer configAdapter) { + final SpecConfigAndParent specConfig = + getElectraEip7594SpecConfig(Eth2Network.MINIMAL, configAdapter); + return create(specConfig, SpecMilestone.ELECTRA); + } + + public static Spec createMinimalFulu() { + final SpecConfigAndParent specConfig = + getFuluSpecConfig(Eth2Network.MINIMAL); + return create(specConfig, SpecMilestone.FULU); + } + + public static Spec createMinimalFulu(final Consumer configAdapter) { + final SpecConfigAndParent specConfig = + getFuluSpecConfig(Eth2Network.MINIMAL, configAdapter); + return create(specConfig, SpecMilestone.FULU); } /** @@ -120,7 +152,8 @@ public static Spec createMinimalEip7594(final Consumer config * @return A spec with phase0 and altair enabled, forking to altair at the given epoch */ public static Spec createMinimalWithAltairForkEpoch(final UInt64 altairForkEpoch) { - final SpecConfigAltair config = getAltairSpecConfig(Eth2Network.MINIMAL, altairForkEpoch); + final SpecConfigAndParent config = + getAltairSpecConfig(Eth2Network.MINIMAL, altairForkEpoch); return create(config, SpecMilestone.ALTAIR); } @@ -131,7 +164,7 @@ public static Spec createMinimalWithAltairForkEpoch(final UInt64 altairForkEpoch * @return A spec with altair and bellatrix enabled, forking to bellatrix at the given epoch */ public static Spec createMinimalWithBellatrixForkEpoch(final UInt64 bellatrixForkEpoch) { - final SpecConfigBellatrix config = + final SpecConfigAndParent config = getBellatrixSpecConfig(Eth2Network.MINIMAL, UInt64.ZERO, bellatrixForkEpoch); return create(config, SpecMilestone.BELLATRIX); } @@ -144,7 +177,8 @@ public static Spec createMinimalWithBellatrixForkEpoch(final UInt64 bellatrixFor * epoch */ public static Spec createMinimalWithCapellaForkEpoch(final UInt64 capellaForkEpoch) { - final SpecConfigCapella config = getCapellaSpecConfig(Eth2Network.MINIMAL, capellaForkEpoch); + final SpecConfigAndParent config = + getCapellaSpecConfig(Eth2Network.MINIMAL, capellaForkEpoch); return create(config, SpecMilestone.CAPELLA); } @@ -155,67 +189,92 @@ public static Spec createMinimalWithCapellaForkEpoch(final UInt64 capellaForkEpo * @return A spec with Deneb enabled, forking to Deneb at the given epoch */ public static Spec createMinimalWithDenebForkEpoch(final UInt64 denebForkEpoch) { - final SpecConfigDeneb config = + final SpecConfigAndParent config = getDenebSpecConfig(Eth2Network.MINIMAL, UInt64.ZERO, denebForkEpoch); return create(config, SpecMilestone.DENEB); } /** - * Create a spec that forks to EIP7594 at the provided epoch + * Create a spec that forks to Electra at the provided epoch * - * @param eip7594ForkEpoch The EIP7594 fork epoch - * @return A spec with EIP7594 enabled, forking to EIP7594 at the given epoch + * @param electraForkEpoch The Electra fork epoch + * @return A spec with Electra enabled, forking to Electra at the given epoch */ - public static Spec createMinimalWithEip7594ForkEpoch(final UInt64 eip7594ForkEpoch) { - final SpecConfigEip7594 config = - getEip7594SpecConfig(Eth2Network.MINIMAL, UInt64.ZERO, UInt64.ZERO, eip7594ForkEpoch); - return create(config, SpecMilestone.EIP7594); + public static Spec createMinimalWithElectraForkEpoch(final UInt64 electraForkEpoch) { + final SpecConfigAndParent config = + getElectraSpecConfig(Eth2Network.MINIMAL, UInt64.ZERO, UInt64.ZERO, electraForkEpoch); + return create(config, SpecMilestone.ELECTRA); + } + + public static Spec createMinimalWithFuluForkEpoch(final UInt64 fuluForkEpoch) { + final SpecConfigAndParent config = + getFuluSpecConfig(Eth2Network.MINIMAL, ZERO, ZERO, fuluForkEpoch); + return create(config, SpecMilestone.ELECTRA); } public static Spec createMinimalPhase0() { - final SpecConfig specConfig = SpecConfigLoader.loadConfig(Eth2Network.MINIMAL.configName()); - return create(specConfig, SpecMilestone.PHASE0); + final SpecConfigAndParent configAndParent = + SpecConfigLoader.loadConfig(Eth2Network.MINIMAL.configName()); + return create(configAndParent, SpecMilestone.PHASE0); } public static Spec createMainnetPhase0() { - final SpecConfig specConfig = SpecConfigLoader.loadConfig(Eth2Network.MAINNET.configName()); - return create(specConfig, SpecMilestone.PHASE0); + final SpecConfigAndParent configAndParent = + SpecConfigLoader.loadConfig(Eth2Network.MAINNET.configName()); + return create(configAndParent, SpecMilestone.PHASE0); } public static Spec createMainnetBellatrix() { - final SpecConfigBellatrix specConfig = getBellatrixSpecConfig(Eth2Network.MAINNET); - return create(specConfig, SpecMilestone.BELLATRIX); + final SpecConfigAndParent configAndParent = + getBellatrixSpecConfig(Eth2Network.MAINNET); + return create(configAndParent, SpecMilestone.BELLATRIX); } public static Spec createMainnetAltair() { - final SpecConfigAltair specConfig = getAltairSpecConfig(Eth2Network.MAINNET); + final SpecConfigAndParent specConfig = + getAltairSpecConfig(Eth2Network.MAINNET); return create(specConfig, SpecMilestone.ALTAIR); } public static Spec createMainnetCapella() { - final SpecConfigCapella specConfig = getCapellaSpecConfig(Eth2Network.MAINNET); + final SpecConfigAndParent specConfig = + getCapellaSpecConfig(Eth2Network.MAINNET); return create(specConfig, SpecMilestone.CAPELLA); } public static Spec createMainnetDeneb() { - final SpecConfigDeneb specConfig = getDenebSpecConfig(Eth2Network.MAINNET); + final SpecConfigAndParent specConfig = + getDenebSpecConfig(Eth2Network.MAINNET); return create(specConfig, SpecMilestone.DENEB); } - public static Spec createMainnetEip7594() { - final SpecConfigEip7594 specConfig = getEip7594SpecConfig(Eth2Network.MAINNET); - return create(specConfig, SpecMilestone.EIP7594); + public static Spec createMainnetElectra() { + final SpecConfigAndParent specConfig = + getElectraSpecConfig(Eth2Network.MAINNET); + return create(specConfig, SpecMilestone.ELECTRA); } - public static Spec createPhase0(final SpecConfig config) { + public static Spec createMainnetElectraEip7594() { + final SpecConfigAndParent specConfig = + getElectraEip7594SpecConfig(Eth2Network.MAINNET); + return create(specConfig, SpecMilestone.ELECTRA); + } + + public static Spec createMainnetFulu() { + final SpecConfigAndParent specConfig = + getFuluSpecConfig(Eth2Network.MAINNET); + return create(specConfig, SpecMilestone.FULU); + } + + public static Spec createPhase0(final SpecConfigAndParent config) { return create(config, SpecMilestone.PHASE0); } - public static Spec createAltair(final SpecConfig config) { + public static Spec createAltair(final SpecConfigAndParent config) { return create(config, SpecMilestone.ALTAIR); } - public static Spec createBellatrix(final SpecConfig config) { + public static Spec createBellatrix(final SpecConfigAndParent config) { return create(config, SpecMilestone.BELLATRIX); } @@ -230,29 +289,42 @@ public static Spec create( final Consumer defaultModifier = switch (specMilestone) { case PHASE0 -> __ -> {}; - case ALTAIR -> builder -> builder.altairBuilder(a -> a.altairForkEpoch(UInt64.ZERO)); - case BELLATRIX -> builder -> - builder - .altairBuilder(a -> a.altairForkEpoch(UInt64.ZERO)) - .bellatrixBuilder(b -> b.bellatrixForkEpoch(UInt64.ZERO)); - case CAPELLA -> builder -> - builder - .altairBuilder(a -> a.altairForkEpoch(UInt64.ZERO)) - .bellatrixBuilder(b -> b.bellatrixForkEpoch(UInt64.ZERO)) - .capellaBuilder(c -> c.capellaForkEpoch(UInt64.ZERO)); - case DENEB -> builder -> - builder - .altairBuilder(a -> a.altairForkEpoch(UInt64.ZERO)) - .bellatrixBuilder(b -> b.bellatrixForkEpoch(UInt64.ZERO)) - .capellaBuilder(c -> c.capellaForkEpoch(UInt64.ZERO)) - .denebBuilder(d -> d.denebForkEpoch(UInt64.ZERO)); - case EIP7594 -> builder -> - builder - .altairBuilder(a -> a.altairForkEpoch(UInt64.ZERO)) - .bellatrixBuilder(b -> b.bellatrixForkEpoch(UInt64.ZERO)) - .capellaBuilder(c -> c.capellaForkEpoch(UInt64.ZERO)) - .denebBuilder(d -> d.denebForkEpoch(UInt64.ZERO)) - .eip7594Builder(e -> e.eip7594ForkEpoch(UInt64.ZERO)); + case ALTAIR -> builder -> builder.altairBuilder(a -> a.altairForkEpoch(ZERO)); + case BELLATRIX -> + builder -> + builder + .altairBuilder(a -> a.altairForkEpoch(ZERO)) + .bellatrixBuilder(b -> b.bellatrixForkEpoch(ZERO)); + case CAPELLA -> + builder -> + builder + .altairBuilder(a -> a.altairForkEpoch(ZERO)) + .bellatrixBuilder(b -> b.bellatrixForkEpoch(ZERO)) + .capellaBuilder(c -> c.capellaForkEpoch(ZERO)); + case DENEB -> + builder -> + builder + .altairBuilder(a -> a.altairForkEpoch(ZERO)) + .bellatrixBuilder(b -> b.bellatrixForkEpoch(ZERO)) + .capellaBuilder(c -> c.capellaForkEpoch(ZERO)) + .denebBuilder(d -> d.denebForkEpoch(ZERO)); + case ELECTRA -> + builder -> + builder + .altairBuilder(a -> a.altairForkEpoch(ZERO)) + .bellatrixBuilder(b -> b.bellatrixForkEpoch(ZERO)) + .capellaBuilder(c -> c.capellaForkEpoch(ZERO)) + .denebBuilder(d -> d.denebForkEpoch(ZERO)) + .electraBuilder(e -> e.electraForkEpoch(ZERO)); + case FULU -> + builder -> + builder + .altairBuilder(a -> a.altairForkEpoch(ZERO)) + .bellatrixBuilder(b -> b.bellatrixForkEpoch(ZERO)) + .capellaBuilder(c -> c.capellaForkEpoch(ZERO)) + .denebBuilder(d -> d.denebForkEpoch(ZERO)) + .electraBuilder(e -> e.electraForkEpoch(ZERO)) + .fuluBuilder(f -> f.fuluForkEpoch(ZERO)); }; return create( SpecConfigLoader.loadConfig(network.configName(), defaultModifier.andThen(configModifier)), @@ -260,28 +332,31 @@ public static Spec create( } public static Spec create( - final SpecConfig config, final SpecMilestone highestSupportedMilestone) { + final SpecConfigAndParent config, + final SpecMilestone highestSupportedMilestone) { return Spec.create(config, highestSupportedMilestone); } - private static SpecConfigAltair getAltairSpecConfig(final Eth2Network network) { + private static SpecConfigAndParent getAltairSpecConfig( + final Eth2Network network) { return getAltairSpecConfig(network, UInt64.ZERO); } - private static SpecConfigAltair getAltairSpecConfig( + private static SpecConfigAndParent getAltairSpecConfig( final Eth2Network network, final UInt64 altairForkEpoch) { - return SpecConfigAltair.required( + return requireAltair( SpecConfigLoader.loadConfig( network.configName(), builder -> builder.altairBuilder(a -> a.altairForkEpoch(altairForkEpoch)))); } - private static SpecConfigBellatrix getBellatrixSpecConfig(final Eth2Network network) { + private static SpecConfigAndParent getBellatrixSpecConfig( + final Eth2Network network) { return getBellatrixSpecConfig(network, UInt64.ZERO, UInt64.ZERO); } - private static SpecConfigBellatrix getBellatrixSpecConfig( - final Eth2Network network, final UInt64 altairForkEpoch, UInt64 bellatrixForkEpoch) { + private static SpecConfigAndParent getBellatrixSpecConfig( + final Eth2Network network, final UInt64 altairForkEpoch, final UInt64 bellatrixForkEpoch) { return getBellatrixSpecConfig( network, builder -> @@ -290,120 +365,243 @@ private static SpecConfigBellatrix getBellatrixSpecConfig( .bellatrixBuilder(b -> b.bellatrixForkEpoch(bellatrixForkEpoch))); } - private static SpecConfigBellatrix getBellatrixSpecConfig( + private static SpecConfigAndParent getBellatrixSpecConfig( final Eth2Network network, final Consumer configAdapter) { - return SpecConfigBellatrix.required( + return requireBellatrix( SpecConfigLoader.loadConfig( network.configName(), builder -> { builder - .altairBuilder(a -> a.altairForkEpoch(UInt64.ZERO)) - .bellatrixBuilder(b -> b.bellatrixForkEpoch(UInt64.ZERO)); + .altairBuilder(a -> a.altairForkEpoch(ZERO)) + .bellatrixBuilder(b -> b.bellatrixForkEpoch(ZERO)); configAdapter.accept(builder); })); } - private static SpecConfigCapella getCapellaSpecConfig(final Eth2Network network) { + private static SpecConfigAndParent getCapellaSpecConfig( + final Eth2Network network) { return getCapellaSpecConfig(network, UInt64.ZERO); } - private static SpecConfigCapella getCapellaSpecConfig( + private static SpecConfigAndParent getCapellaSpecConfig( final Eth2Network network, final UInt64 capellaForkEpoch) { return getCapellaSpecConfig( network, builder -> builder - .altairBuilder(a -> a.altairForkEpoch(UInt64.ZERO)) - .bellatrixBuilder(b -> b.bellatrixForkEpoch(UInt64.ZERO)) + .altairBuilder(a -> a.altairForkEpoch(ZERO)) + .bellatrixBuilder(b -> b.bellatrixForkEpoch(ZERO)) .capellaBuilder(c -> c.capellaForkEpoch(capellaForkEpoch))); } - private static SpecConfigCapella getCapellaSpecConfig( + private static SpecConfigAndParent getCapellaSpecConfig( final Eth2Network network, final Consumer configAdapter) { - return SpecConfigCapella.required( + return requireCapella( SpecConfigLoader.loadConfig( network.configName(), builder -> { builder - .altairBuilder(a -> a.altairForkEpoch(UInt64.ZERO)) - .bellatrixBuilder(b -> b.bellatrixForkEpoch(UInt64.ZERO)) - .capellaBuilder(c -> c.capellaForkEpoch(UInt64.ZERO)); + .altairBuilder(a -> a.altairForkEpoch(ZERO)) + .bellatrixBuilder(b -> b.bellatrixForkEpoch(ZERO)) + .capellaBuilder(c -> c.capellaForkEpoch(ZERO)); configAdapter.accept(builder); })); } - private static SpecConfigDeneb getDenebSpecConfig(final Eth2Network network) { - return getDenebSpecConfig(network, UInt64.ZERO, UInt64.ZERO); + private static SpecConfigAndParent getDenebSpecConfig( + final Eth2Network network) { + return getDenebSpecConfig(network, ZERO, ZERO); } - private static SpecConfigDeneb getDenebSpecConfig( + private static SpecConfigAndParent getDenebSpecConfig( final Eth2Network network, final UInt64 capellaForkEpoch, final UInt64 denebForkEpoch) { return getDenebSpecConfig( network, builder -> builder - .altairBuilder(a -> a.altairForkEpoch(UInt64.ZERO)) - .bellatrixBuilder(b -> b.bellatrixForkEpoch(UInt64.ZERO)) + .altairBuilder(a -> a.altairForkEpoch(ZERO)) + .bellatrixBuilder(b -> b.bellatrixForkEpoch(ZERO)) .capellaBuilder(c -> c.capellaForkEpoch(capellaForkEpoch)) .denebBuilder(d -> d.denebForkEpoch(denebForkEpoch))); } - private static SpecConfigDeneb getDenebSpecConfig( + private static SpecConfigAndParent getDenebSpecConfig( final Eth2Network network, final Consumer configAdapter) { - return SpecConfigDeneb.required( + return requireDeneb( SpecConfigLoader.loadConfig( network.configName(), builder -> { builder - .altairBuilder(a -> a.altairForkEpoch(UInt64.ZERO)) - .bellatrixBuilder(b -> b.bellatrixForkEpoch(UInt64.ZERO)) - .capellaBuilder(c -> c.capellaForkEpoch(UInt64.ZERO)) - .denebBuilder(d -> d.denebForkEpoch(UInt64.ZERO)); + .altairBuilder(a -> a.altairForkEpoch(ZERO)) + .bellatrixBuilder(b -> b.bellatrixForkEpoch(ZERO)) + .capellaBuilder(c -> c.capellaForkEpoch(ZERO)) + .denebBuilder(d -> d.denebForkEpoch(ZERO)); configAdapter.accept(builder); })); } - private static SpecConfigEip7594 getEip7594SpecConfig(final Eth2Network network) { - return getEip7594SpecConfig(network, UInt64.ZERO, UInt64.ZERO, UInt64.ZERO); + private static SpecConfigAndParent getElectraSpecConfig( + final Eth2Network network) { + return getElectraSpecConfig(network, UInt64.ZERO, UInt64.ZERO, UInt64.ZERO); } - private static SpecConfigEip7594 getEip7594SpecConfig( + private static SpecConfigAndParent getElectraSpecConfig( final Eth2Network network, final UInt64 capellaForkEpoch, final UInt64 denebForkEpoch, + final UInt64 electraForkEpoch) { + return getElectraSpecConfig( + network, + builder -> + builder + .altairBuilder(a -> a.altairForkEpoch(ZERO)) + .bellatrixBuilder(b -> b.bellatrixForkEpoch(ZERO)) + .capellaBuilder(c -> c.capellaForkEpoch(capellaForkEpoch)) + .denebBuilder(d -> d.denebForkEpoch(denebForkEpoch)) + .electraBuilder(e -> e.electraForkEpoch(electraForkEpoch))); + } + + private static SpecConfigAndParent getElectraSpecConfig( + final Eth2Network network, final Consumer configAdapter) { + return requireElectra( + SpecConfigLoader.loadConfig( + network.configName(), + builder -> { + builder + .altairBuilder(a -> a.altairForkEpoch(ZERO)) + .bellatrixBuilder(b -> b.bellatrixForkEpoch(ZERO)) + .capellaBuilder(c -> c.capellaForkEpoch(ZERO)) + .denebBuilder(d -> d.denebForkEpoch(ZERO)) + .electraBuilder(e -> e.electraForkEpoch(ZERO)); + configAdapter.accept(builder); + })); + } + + private static SpecConfigAndParent getElectraEip7594SpecConfig( + final Eth2Network network) { + return getElectraEip7594SpecConfig(network, ZERO, ZERO, ZERO, ZERO); + } + + private static SpecConfigAndParent getElectraEip7594SpecConfig( + final Eth2Network network, + final UInt64 capellaForkEpoch, + final UInt64 denebForkEpoch, + final UInt64 electraForkEpoch, final UInt64 eip7594ForkEpoch) { - return getEip7594SpecConfig( + return getElectraSpecConfig( network, builder -> builder - .altairBuilder(a -> a.altairForkEpoch(UInt64.ZERO)) - .bellatrixBuilder(b -> b.bellatrixForkEpoch(UInt64.ZERO)) + .altairBuilder(a -> a.altairForkEpoch(ZERO)) + .bellatrixBuilder(b -> b.bellatrixForkEpoch(ZERO)) .capellaBuilder(c -> c.capellaForkEpoch(capellaForkEpoch)) .denebBuilder(d -> d.denebForkEpoch(denebForkEpoch)) - .eip7594Builder(e -> e.eip7594ForkEpoch(eip7594ForkEpoch))); + .electraBuilder(e -> e.electraForkEpoch(electraForkEpoch)) + .eip7594Builder(eip7594 -> eip7594.eip7594ForkEpoch(eip7594ForkEpoch))); } - private static SpecConfigEip7594 getEip7594SpecConfig( + private static SpecConfigAndParent getElectraEip7594SpecConfig( final Eth2Network network, final Consumer configAdapter) { - return SpecConfigEip7594.required( + return requireElectra( SpecConfigLoader.loadConfig( network.configName(), builder -> { builder - .altairBuilder(a -> a.altairForkEpoch(UInt64.ZERO)) - .bellatrixBuilder(b -> b.bellatrixForkEpoch(UInt64.ZERO)) - .capellaBuilder(c -> c.capellaForkEpoch(UInt64.ZERO)) - .denebBuilder(d -> d.denebForkEpoch(UInt64.ZERO)) - .eip7594Builder(e -> e.eip7594ForkEpoch(UInt64.ZERO)); + .altairBuilder(a -> a.altairForkEpoch(ZERO)) + .bellatrixBuilder(b -> b.bellatrixForkEpoch(ZERO)) + .capellaBuilder(c -> c.capellaForkEpoch(ZERO)) + .denebBuilder(d -> d.denebForkEpoch(ZERO)) + .electraBuilder(e -> e.electraForkEpoch(ZERO)) + .eip7594Builder(eip7594 -> eip7594.eip7594ForkEpoch(ZERO)); configAdapter.accept(builder); })); } - public static Spec createMinimalWithCapellaDenebAndEip7594ForkEpoch( - final UInt64 capellaForkEpoch, final UInt64 denebForkEpoch, final UInt64 eip7594ForkEpoch) { - final SpecConfigBellatrix config = - getEip7594SpecConfig( - Eth2Network.MINIMAL, capellaForkEpoch, denebForkEpoch, eip7594ForkEpoch); - return create(config, SpecMilestone.EIP7594); + private static SpecConfigAndParent getFuluSpecConfig( + final Eth2Network network) { + return getFuluSpecConfig(network, ZERO, ZERO, ZERO); + } + + private static SpecConfigAndParent getFuluSpecConfig( + final Eth2Network network, + final UInt64 denebForkEpoch, + final UInt64 electraForkEpoch, + final UInt64 fuluForkEpoch) { + return getFuluSpecConfig( + network, + builder -> + builder + .altairBuilder(a -> a.altairForkEpoch(ZERO)) + .bellatrixBuilder(b -> b.bellatrixForkEpoch(ZERO)) + .capellaBuilder(c -> c.capellaForkEpoch(ZERO)) + .denebBuilder(d -> d.denebForkEpoch(denebForkEpoch)) + .electraBuilder(e -> e.electraForkEpoch(electraForkEpoch)) + .fuluBuilder(f -> f.fuluForkEpoch(fuluForkEpoch))); + } + + private static SpecConfigAndParent getFuluSpecConfig( + final Eth2Network network, final Consumer configAdapter) { + return requireFulu( + SpecConfigLoader.loadConfig( + network.configName(), + builder -> { + builder + .altairBuilder(a -> a.altairForkEpoch(ZERO)) + .bellatrixBuilder(b -> b.bellatrixForkEpoch(ZERO)) + .capellaBuilder(c -> c.capellaForkEpoch(ZERO)) + .denebBuilder(d -> d.denebForkEpoch(ZERO)) + .electraBuilder(e -> e.electraForkEpoch(ZERO)) + .fuluBuilder(f -> f.fuluForkEpoch(ZERO)); + configAdapter.accept(builder); + })); + } + + public static Spec createMinimalWithCapellaDenebAndElectraForkEpoch( + final UInt64 capellaForkEpoch, final UInt64 denebForkEpoch, final UInt64 electraForkEpoch) { + final SpecConfigAndParent config = + getElectraSpecConfig( + Eth2Network.MINIMAL, capellaForkEpoch, denebForkEpoch, electraForkEpoch); + return create(config, SpecMilestone.ELECTRA); + } + + // Our current config files contain ELECTRA params. + // So all specConfigs created from them will be ELECTRA. + // Here we just want to make sure that a given config supports the given milestone + // (which useless in theory because they are all ELECTRA) + + private static SpecConfigAndParent requireAltair( + final SpecConfigAndParent specConfigAndParent) { + checkArgument(specConfigAndParent.specConfig().toVersionAltair().isPresent()); + return specConfigAndParent; + } + + private static SpecConfigAndParent requireBellatrix( + final SpecConfigAndParent specConfigAndParent) { + checkArgument(specConfigAndParent.specConfig().toVersionBellatrix().isPresent()); + return specConfigAndParent; + } + + private static SpecConfigAndParent requireCapella( + final SpecConfigAndParent specConfigAndParent) { + checkArgument(specConfigAndParent.specConfig().toVersionCapella().isPresent()); + return specConfigAndParent; + } + + private static SpecConfigAndParent requireDeneb( + final SpecConfigAndParent specConfigAndParent) { + checkArgument(specConfigAndParent.specConfig().toVersionDeneb().isPresent()); + return specConfigAndParent; + } + + private static SpecConfigAndParent requireElectra( + final SpecConfigAndParent specConfigAndParent) { + checkArgument(specConfigAndParent.specConfig().toVersionElectra().isPresent()); + return specConfigAndParent; + } + + private static SpecConfigAndParent requireFulu( + final SpecConfigAndParent specConfigAndParent) { + checkArgument(specConfigAndParent.specConfig().toVersionFulu().isPresent()); + return specConfigAndParent; } } diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/TestSpecInvocationContextProvider.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/TestSpecInvocationContextProvider.java index 65d1b46caa1..688a570a4c1 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/TestSpecInvocationContextProvider.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/TestSpecInvocationContextProvider.java @@ -32,13 +32,13 @@ public class TestSpecInvocationContextProvider implements TestTemplateInvocationContextProvider { @Override - public boolean supportsTestTemplate(ExtensionContext extensionContext) { + public boolean supportsTestTemplate(final ExtensionContext extensionContext) { return true; } @Override public Stream provideTestTemplateInvocationContexts( - ExtensionContext extensionContext) { + final ExtensionContext extensionContext) { Class clazz = extensionContext.getRequiredTestClass(); TestSpecContext testSpecContext = clazz.getAnnotation(TestSpecContext.class); @@ -74,10 +74,10 @@ public Stream provideTestTemplateInvocationContex return invocations.stream(); } - private TestTemplateInvocationContext generateContext(SpecContext specContext) { + private TestTemplateInvocationContext generateContext(final SpecContext specContext) { return new TestTemplateInvocationContext() { @Override - public String getDisplayName(int invocationIndex) { + public String getDisplayName(final int invocationIndex) { return specContext.getDisplayName(); } @@ -97,7 +97,10 @@ public static class SpecContext { private final SpecMilestone specMilestone; private final Eth2Network network; - SpecContext(SpecMilestone specMilestone, Eth2Network network, boolean doNotGenerateSpec) { + SpecContext( + final SpecMilestone specMilestone, + final Eth2Network network, + final boolean doNotGenerateSpec) { if (doNotGenerateSpec) { spec = null; dataStructureUtil = null; @@ -136,26 +139,30 @@ public Eth2Network getNetwork() { return network; } - public void assumeIsOneOf(SpecMilestone... milestones) { + public void assumeIsOneOf(final SpecMilestone... milestones) { Assumptions.assumeTrue(List.of(milestones).contains(specMilestone), "Milestone skipped"); } - public void assumeIsOneOf(Eth2Network... networks) { + public void assumeIsOneOf(final Eth2Network... networks) { Assumptions.assumeTrue(List.of(networks).contains(network), "Network skipped"); } - public void assumeIsNotOneOf(SpecMilestone... milestones) { + public void assumeIsNotOneOf(final SpecMilestone... milestones) { Assumptions.assumeFalse(List.of(milestones).contains(specMilestone), "Milestone skipped"); } - public void assumeIsNotOneOf(Eth2Network... networks) { + public void assumeIsNotOneOf(final Eth2Network... networks) { Assumptions.assumeFalse(List.of(networks).contains(network), "Network skipped"); } - public void assumeMilestoneActive(SpecMilestone milestone) { + public void assumeMilestoneActive(final SpecMilestone milestone) { Assumptions.assumeTrue(specMilestone.isGreaterThanOrEqualTo(milestone), "Milestone skipped"); } + public void assumeElectraActive() { + assumeMilestoneActive(SpecMilestone.ELECTRA); + } + public void assumeDenebActive() { assumeMilestoneActive(SpecMilestone.DENEB); } @@ -176,20 +183,20 @@ public void assumeAltairActive() { public static class SpecContextParameterResolver implements ParameterResolver { T data; - public SpecContextParameterResolver(T data) { + public SpecContextParameterResolver(final T data) { this.data = data; } @Override public boolean supportsParameter( - ParameterContext parameterContext, ExtensionContext extensionContext) + final ParameterContext parameterContext, final ExtensionContext extensionContext) throws ParameterResolutionException { return parameterContext.getParameter().getType().isInstance(data); } @Override public Object resolveParameter( - ParameterContext parameterContext, ExtensionContext extensionContext) + final ParameterContext parameterContext, final ExtensionContext extensionContext) throws ParameterResolutionException { return data; } diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/datastructures/forkchoice/TestStoreImpl.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/datastructures/forkchoice/TestStoreImpl.java index 41d8f21363a..38f733281ab 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/datastructures/forkchoice/TestStoreImpl.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/datastructures/forkchoice/TestStoreImpl.java @@ -188,22 +188,22 @@ public UInt64 getHighestVotedValidatorIndex() { // Prunable methods @Override - public Optional getBlockStateIfAvailable(Bytes32 blockRoot) { + public Optional getBlockStateIfAvailable(final Bytes32 blockRoot) { return Optional.ofNullable(getBlockState(blockRoot)); } @Override - public Optional getBlockIfAvailable(Bytes32 blockRoot) { + public Optional getBlockIfAvailable(final Bytes32 blockRoot) { return Optional.ofNullable(getSignedBlock(blockRoot)); } @Override - public SafeFuture> retrieveSignedBlock(Bytes32 blockRoot) { + public SafeFuture> retrieveSignedBlock(final Bytes32 blockRoot) { return SafeFuture.completedFuture(getBlockIfAvailable(blockRoot)); } @Override - public SafeFuture> retrieveBlockAndState(Bytes32 blockRoot) { + public SafeFuture> retrieveBlockAndState(final Bytes32 blockRoot) { return SafeFuture.completedFuture(getBlockAndState(blockRoot)); } @@ -214,12 +214,12 @@ public SafeFuture> retrieveStateAndBlockSummary( } @Override - public SafeFuture> retrieveBlockState(Bytes32 blockRoot) { + public SafeFuture> retrieveBlockState(final Bytes32 blockRoot) { return SafeFuture.completedFuture(getBlockStateIfAvailable(blockRoot)); } @Override - public SafeFuture> retrieveCheckpointState(Checkpoint checkpoint) { + public SafeFuture> retrieveCheckpointState(final Checkpoint checkpoint) { return SafeFuture.completedFuture(getCheckpointState(checkpoint)); } @@ -257,10 +257,10 @@ public boolean isParentStrong(final Bytes32 parentRoot) { } @Override - public void computeBalanceThresholds(BeaconState justifiedState) {} + public void computeBalanceThresholds(final BeaconState justifiedState) {} @Override - public Optional isFfgCompetitive(Bytes32 headRoot, Bytes32 parentRoot) { + public Optional isFfgCompetitive(final Bytes32 headRoot, final Bytes32 parentRoot) { return Optional.empty(); } @@ -353,7 +353,7 @@ public VoteTracker getVote(final UInt64 validatorIndex) { } @Override - public void putVote(UInt64 validatorIndex, VoteTracker vote) { + public void putVote(final UInt64 validatorIndex, final VoteTracker vote) { votes.put(validatorIndex, vote); } diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/datastructures/interop/MergedGenesisTestBuilder.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/datastructures/interop/MergedGenesisTestBuilder.java index e17d97257f7..7907edaeb49 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/datastructures/interop/MergedGenesisTestBuilder.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/datastructures/interop/MergedGenesisTestBuilder.java @@ -43,7 +43,7 @@ public static ExecutionPayloadHeader createPayloadForBesuGenesis( genesisConfigOptions, MiningParameters.MINING_DISABLED, badBlockManager, - true, + false, metricsSystem); final GenesisState genesisState = GenesisState.fromConfig(configFile, protocolSchedule); final Block genesisBlock = genesisState.getBlock(); @@ -67,12 +67,16 @@ public static ExecutionPayloadHeader createPayloadForBesuGenesis( .stateRoot(header.getStateRoot()) .feeRecipient(new Bytes20(header.getCoinbase())) .parentHash(header.getParentHash()) + .transactionsRoot(headerSchema.getHeaderOfDefaultPayload().getTransactionsRoot()) + // New in Capella .withdrawalsRoot( () -> headerSchema .getHeaderOfDefaultPayload() .getOptionalWithdrawalsRoot() .orElseThrow()) - .transactionsRoot(headerSchema.getHeaderOfDefaultPayload().getTransactionsRoot())); + // New in Deneb + .blobGasUsed(() -> UInt64.ZERO) + .excessBlobGas(() -> UInt64.ZERO)); } } diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/datastructures/state/BeaconStateTestBuilder.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/datastructures/state/BeaconStateTestBuilder.java index b182a12fdc8..687d856d212 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/datastructures/state/BeaconStateTestBuilder.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/datastructures/state/BeaconStateTestBuilder.java @@ -19,22 +19,37 @@ import java.util.ArrayList; import java.util.List; import tech.pegasys.teku.infrastructure.bytes.Bytes4; +import tech.pegasys.teku.infrastructure.ssz.SszList; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecVersion; +import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.config.SpecConfigElectra; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.MutableBeaconStateElectra; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingPartialWithdrawal; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; import tech.pegasys.teku.spec.util.DataStructureUtil; public class BeaconStateTestBuilder { private final List validators = new ArrayList<>(); private final List balances = new ArrayList<>(); + + private final List pendingPartialWithdrawals = new ArrayList<>(); private UInt64 slot; private Fork fork; private final DataStructureUtil dataStructureUtil; + private final SpecConfig specConfig; + private final Spec spec; + public BeaconStateTestBuilder(final DataStructureUtil dataStructureUtil) { this.slot = dataStructureUtil.randomUInt64(); this.fork = dataStructureUtil.randomFork(); this.dataStructureUtil = dataStructureUtil; + this.specConfig = dataStructureUtil.getSpec().getGenesisSpecConfig(); + this.spec = dataStructureUtil.getSpec(); } public BeaconStateTestBuilder slot(final long slot) { @@ -53,13 +68,54 @@ public BeaconStateTestBuilder validator(final Validator validator) { return this; } - public BeaconStateTestBuilder activeValidator(final UInt64 effectiveBalance) { + public BeaconStateTestBuilder activeValidator(final UInt64 balance) { + final UInt64 maxEffectiveBalance = + spec.getSpecConfig(spec.computeEpochAtSlot(slot)).getMaxEffectiveBalance(); validators.add( dataStructureUtil .randomValidator() - .withEffectiveBalance(effectiveBalance) + .withEffectiveBalance(maxEffectiveBalance.min(balance)) .withActivationEpoch(UInt64.ZERO) .withExitEpoch(FAR_FUTURE_EPOCH)); + balances.add(balance); + return this; + } + + public BeaconStateTestBuilder activeEth1Validator(final UInt64 balance) { + validators.add( + dataStructureUtil + .randomValidator() + .withWithdrawalCredentials(dataStructureUtil.randomEth1WithdrawalCredentials()) + .withEffectiveBalance(specConfig.getMaxEffectiveBalance().min(balance)) + .withActivationEpoch(UInt64.ZERO) + .withExitEpoch(FAR_FUTURE_EPOCH)); + balances.add(balance); + return this; + } + + public BeaconStateTestBuilder activeConsolidatingValidator(final UInt64 balance) { + validators.add( + dataStructureUtil + .randomValidator() + .withWithdrawalCredentials(dataStructureUtil.randomCompoundingWithdrawalCredentials()) + .withEffectiveBalance( + SpecConfigElectra.required(specConfig).getMaxEffectiveBalanceElectra().min(balance)) + .withActivationEpoch(UInt64.ZERO) + .withExitEpoch(FAR_FUTURE_EPOCH)); + balances.add(balance); + return this; + } + + public BeaconStateTestBuilder activeConsolidatingValidatorQueuedForExit(final UInt64 balance) { + validators.add( + dataStructureUtil + .randomValidator() + .withWithdrawalCredentials(dataStructureUtil.randomCompoundingWithdrawalCredentials()) + .withEffectiveBalance( + SpecConfigElectra.required(specConfig).getMaxEffectiveBalanceElectra().min(balance)) + .withActivationEpoch(UInt64.ZERO) + .withExitEpoch(FAR_FUTURE_EPOCH.minus(1))); + balances.add(balance); return this; } @@ -75,6 +131,35 @@ public BeaconState build() { state.setFork(fork); state.getValidators().appendAll(validators); state.getBalances().appendAllElements(balances); + if (!pendingPartialWithdrawals.isEmpty()) { + final SszList partialWithdrawalSszList = + SchemaDefinitionsElectra.required( + dataStructureUtil.getSpec().atSlot(slot).getSchemaDefinitions()) + .getPendingPartialWithdrawalsSchema() + .createFromElements(pendingPartialWithdrawals); + MutableBeaconStateElectra.required(state) + .setPendingPartialWithdrawals(partialWithdrawalSszList); + } }); } + + public BeaconStateTestBuilder pendingPartialWithdrawal( + final int validatorIndex, final UInt64 partialBalanceAmount) { + final PendingPartialWithdrawal pendingPartialWithdrawal = + SchemaDefinitionsElectra.required( + dataStructureUtil.getSpec().atSlot(slot).getSchemaDefinitions()) + .getPendingPartialWithdrawalSchema() + .create( + SszUInt64.of(UInt64.valueOf(validatorIndex)), + SszUInt64.of(partialBalanceAmount), + SszUInt64.of( + dataStructureUtil + .getSpec() + .atSlot(slot) + .miscHelpers() + .computeEpochAtSlot(slot))); + + pendingPartialWithdrawals.add(pendingPartialWithdrawal); + return this; + } } diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/datastructures/util/BeaconBlockBodyLists.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/datastructures/util/BeaconBlockBodyLists.java index 7eb272566c5..f896b1a5fdb 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/datastructures/util/BeaconBlockBodyLists.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/datastructures/util/BeaconBlockBodyLists.java @@ -13,7 +13,10 @@ package tech.pegasys.teku.spec.datastructures.util; +import static tech.pegasys.teku.spec.config.SpecConfig.GENESIS_SLOT; + import tech.pegasys.teku.infrastructure.ssz.SszList; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBodySchema; import tech.pegasys.teku.spec.datastructures.operations.Attestation; @@ -25,38 +28,45 @@ public class BeaconBlockBodyLists { - public static BeaconBlockBodyLists ofSpec(Spec spec) { - return new BeaconBlockBodyLists(spec); + public static BeaconBlockBodyLists ofSpecAtSlot(final Spec spec, final UInt64 slot) { + return new BeaconBlockBodyLists(spec, slot); + } + + public static BeaconBlockBodyLists ofSpec(final Spec spec) { + return new BeaconBlockBodyLists(spec, GENESIS_SLOT); } private final BeaconBlockBodySchema blockBodySchema; - public BeaconBlockBodyLists(Spec spec) { - blockBodySchema = spec.getGenesisSpec().getSchemaDefinitions().getBeaconBlockBodySchema(); + public BeaconBlockBodyLists(final Spec spec, final UInt64 slot) { + blockBodySchema = spec.atSlot(slot).getSchemaDefinitions().getBeaconBlockBodySchema(); } - public SszList createProposerSlashings(ProposerSlashing... proposerSlashings) { + public SszList createProposerSlashings( + final ProposerSlashing... proposerSlashings) { return blockBodySchema.getProposerSlashingsSchema().of(proposerSlashings); } - public SszList createAttesterSlashings(AttesterSlashing... attesterSlashings) { + public SszList createAttesterSlashings( + final AttesterSlashing... attesterSlashings) { return blockBodySchema.getAttesterSlashingsSchema().of(attesterSlashings); } - public SszList createAttestations(Attestation... attestations) { + public SszList createAttestations(final Attestation... attestations) { return blockBodySchema.getAttestationsSchema().of(attestations); } - public SszList createDeposits(Deposit... deposits) { + public SszList createDeposits(final Deposit... deposits) { return blockBodySchema.getDepositsSchema().of(deposits); } - public SszList createVoluntaryExits(SignedVoluntaryExit... voluntaryExits) { + public SszList createVoluntaryExits( + final SignedVoluntaryExit... voluntaryExits) { return blockBodySchema.getVoluntaryExitsSchema().of(voluntaryExits); } public SszList createBlsToExecutionChanges( - SignedBlsToExecutionChange... blsToExecutionChanges) { + final SignedBlsToExecutionChange... blsToExecutionChanges) { return blockBodySchema .toVersionCapella() .map(schema -> schema.getBlsToExecutionChangesSchema().of(blsToExecutionChanges)) diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/datastructures/util/MerkleTree.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/datastructures/util/MerkleTree.java index 0af8a9a3bd4..e40d1607c6b 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/datastructures/util/MerkleTree.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/datastructures/util/MerkleTree.java @@ -30,7 +30,7 @@ public class MerkleTree { private final List zeroHashes; protected final int treeDepth; // Root does not count as depth, i.e. tree height is treeDepth + 1 - public MerkleTree(int treeDepth) { + public MerkleTree(final int treeDepth) { checkArgument(treeDepth > 1, "MerkleTree: treeDepth must be greater than 1"); this.treeDepth = treeDepth; this.tree = new ArrayList<>(); @@ -40,8 +40,8 @@ public MerkleTree(int treeDepth) { this.zeroHashes = generateZeroHashes(treeDepth); } - protected static List generateZeroHashes(int height) { - List zeroHashes = new ArrayList<>(); + protected static List generateZeroHashes(final int height) { + final List zeroHashes = new ArrayList<>(); zeroHashes.add(Bytes32.ZERO); for (int i = 1; i < height; i++) { zeroHashes.add(i, Hash.sha256(zeroHashes.get(i - 1), zeroHashes.get(i - 1))); @@ -49,57 +49,57 @@ protected static List generateZeroHashes(int height) { return zeroHashes; } - public void add(Bytes32 leaf) { - if (!tree.get(0).isEmpty() - && tree.get(0).get(tree.get(0).size() - 1).equals(zeroHashes.get(0))) { - tree.get(0).remove(tree.get(0).size() - 1); + public void add(final Bytes32 leaf) { + if (!tree.getFirst().isEmpty() && tree.getFirst().getLast().equals(zeroHashes.getFirst())) { + tree.getFirst().removeLast(); } - int stageSize = tree.get(0).size(); - tree.get(0).add(leaf); - for (int h = 0; h <= treeDepth; h++) { - List stage = tree.get(h); - if (h > 0) { + int mutableStageSize = tree.getFirst().size(); + tree.getFirst().add(leaf); + for (int depth = 0; depth <= treeDepth; depth++) { + final List stage = tree.get(depth); + if (depth > 0) { // Remove elements that should be modified - stageSize = stageSize / 2; - while (stage.size() != stageSize) { - stage.remove(stage.size() - 1); + mutableStageSize /= 2; + while (stage.size() != mutableStageSize) { + stage.removeLast(); } - List previousStage = tree.get(h - 1); - int previousStageSize = previousStage.size(); + final List previousStage = tree.get(depth - 1); + final int previousStageSize = previousStage.size(); stage.add( Hash.sha256( previousStage.get(previousStageSize - 2), previousStage.get(previousStageSize - 1))); } - if (stage.size() % 2 == 1 && h != treeDepth) { - stage.add(zeroHashes.get(h)); + if (stage.size() % 2 == 1 && depth != treeDepth) { + stage.add(zeroHashes.get(depth)); } } } public int getNumberOfLeaves() { - int lastLeafIndex = tree.get(0).size() - 1; - if (tree.get(0).get(lastLeafIndex).equals(Bytes32.ZERO)) { - return tree.get(0).size() - 1; + final int lastLeafIndex = tree.getFirst().size() - 1; + if (tree.getFirst().get(lastLeafIndex).equals(Bytes32.ZERO)) { + return tree.getFirst().size() - 1; } - return tree.get(0).size(); + return tree.getFirst().size(); } - public List getProof(Bytes32 value) { - int index = tree.get(0).indexOf(value); + public List getProof(final Bytes32 value) { + final int index = tree.getFirst().indexOf(value); if (index == -1) { throw new IllegalArgumentException("Leaf value is missing from the MerkleTree"); } return getProof(index); } - public List getProof(int itemIndex) { - List proof = new ArrayList<>(); + public List getProof(final int itemIndex) { + int mutableIndex = itemIndex; + final List proof = new ArrayList<>(); for (int i = 0; i < treeDepth; i++) { // Get index of sibling node - int siblingIndex = itemIndex % 2 == 1 ? itemIndex - 1 : itemIndex + 1; + final int siblingIndex = mutableIndex % 2 == 1 ? mutableIndex - 1 : mutableIndex + 1; // If sibling is contained in the tree if (siblingIndex < tree.get(i).size()) { @@ -113,25 +113,25 @@ public List getProof(int itemIndex) { proof.add(zeroHashes.get(i)); } - itemIndex /= 2; + mutableIndex /= 2; } proof.add(calcMixInValue()); return proof; } - private Bytes32 calcViewBoundaryRoot(int depth, int viewLimit) { + private Bytes32 calcViewBoundaryRoot(final int depth, final int viewLimit) { if (depth == 0) { - return zeroHashes.get(0); + return zeroHashes.getFirst(); } - depth -= 1; - Bytes32 deeperRoot = calcViewBoundaryRoot(depth, viewLimit); + final int deeperDepth = depth - 1; + final Bytes32 deeperRoot = calcViewBoundaryRoot(deeperDepth, viewLimit); // Check if given the viewLimit at the leaf layer, is root in left or right subtree - if ((viewLimit & (1 << depth)) != 0) { + if ((viewLimit & (1 << deeperDepth)) != 0) { // For the right subtree - return Hash.sha256(tree.get(depth).get((viewLimit >> depth) - 1), deeperRoot); + return Hash.sha256(tree.get(deeperDepth).get((viewLimit >> deeperDepth) - 1), deeperRoot); } else { // For the left subtree - return Hash.sha256(deeperRoot, zeroHashes.get(depth)); + return Hash.sha256(deeperRoot, zeroHashes.get(deeperDepth)); } } @@ -140,8 +140,8 @@ private Bytes32 calcViewBoundaryRoot(int depth, int viewLimit) { * @param viewLimit number of leaves in the tree * @return proof (i.e. collection of siblings on the way to root for the given leaf) */ - public List getProofWithViewBoundary(Bytes32 value, int viewLimit) { - return getProofWithViewBoundary(tree.get(0).indexOf(value), viewLimit); + public List getProofWithViewBoundary(final Bytes32 value, final int viewLimit) { + return getProofWithViewBoundary(tree.getFirst().indexOf(value), viewLimit); } /** @@ -149,13 +149,13 @@ public List getProofWithViewBoundary(Bytes32 value, int viewLimit) { * @param viewLimit number of leaves in the tree * @return proof (i.e. collection of siblings on the way to root for the given leaf) */ - public List getProofWithViewBoundary(int itemIndex, int viewLimit) { + public List getProofWithViewBoundary(final int itemIndex, final int viewLimit) { checkArgument(itemIndex < viewLimit, "MerkleTree: Index must be less than the view limit"); - - List proof = new ArrayList<>(); + int mutableIndex = itemIndex; + final List proof = new ArrayList<>(); for (int i = 0; i < treeDepth; i++) { // Get index of sibling node - int siblingIndex = itemIndex % 2 == 1 ? itemIndex - 1 : itemIndex + 1; + final int siblingIndex = mutableIndex % 2 == 1 ? mutableIndex - 1 : mutableIndex + 1; // Check how much of the tree at this level is strictly within the view limit. int limit = viewLimit >> i; @@ -176,13 +176,13 @@ public List getProofWithViewBoundary(int itemIndex, int viewLimit) { // Return the tree node as-is without modifications proof.add(tree.get(i).get(siblingIndex)); } - itemIndex >>>= 1; + mutableIndex >>>= 1; } proof.add(calcMixInValue(viewLimit)); return proof; } - public Bytes32 calcMixInValue(int viewLimit) { + public Bytes32 calcMixInValue(final int viewLimit) { return (Bytes32) Bytes.concatenate(Bytes.ofUnsignedLong(viewLimit, LITTLE_ENDIAN), Bytes.wrap(new byte[24])); } @@ -192,19 +192,18 @@ public Bytes32 calcMixInValue() { } public Bytes32 getRoot() { - return Hash.sha256(tree.get(treeDepth).get(0), calcMixInValue()); + return Hash.sha256(tree.get(treeDepth).getFirst(), calcMixInValue()); } @Override public String toString() { StringBuilder returnString = new StringBuilder(); - int numLeaves = (int) Math.pow(2, treeDepth); - int height = 0; - int stageFullSize; + final int numLeaves = (int) Math.pow(2, treeDepth); + int mutableHeight = 0; for (int i = treeDepth; i >= 0; i--) { - stageFullSize = (int) Math.pow(2, height); - height++; - int stageNonZeroSize = tree.get(i).size(); + final int stageFullSize = (int) Math.pow(2, mutableHeight); + mutableHeight++; + final int stageNonZeroSize = tree.get(i).size(); List stageItems = new ArrayList<>(tree.get(i)); for (int j = stageNonZeroSize; j < stageFullSize; j++) { stageItems.add(zeroHashes.get(i)); @@ -214,15 +213,15 @@ public String toString() { return "MerkleTree{" + "tree=" + returnString + ", treeDepth=" + treeDepth + '}'; } - private String centerPrint(List stageItems, int numLeaves) { - String emptySpaceOnSide = - IntStream.range(0, (numLeaves - stageItems.size())) - .mapToObj(i -> " ") - .collect(Collectors.joining(" ")); - if (numLeaves == stageItems.size()) { - emptySpaceOnSide = " "; - } - String stageString = + private String centerPrint(final List stageItems, final int numLeaves) { + final String emptySpaceOnSide = + numLeaves == stageItems.size() + ? " " + : IntStream.range(0, (numLeaves - stageItems.size())) + .mapToObj(i -> " ") + .collect(Collectors.joining(" ")); + + final String stageString = stageItems.stream() .map(item -> item.toHexString().substring(63)) .collect(Collectors.joining(emptySpaceOnSide)); diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/AggregateGenerator.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/AggregateGenerator.java index 1dc16924cba..9c0d9915b4b 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/AggregateGenerator.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/AggregateGenerator.java @@ -122,7 +122,7 @@ private SignedAggregateAndProof generateWithAnyValidAggregatorIndex( final Attestation aggregate) { final List beaconCommittee = spec.getBeaconCommittee( - stateAtSlot, aggregate.getData().getSlot(), aggregate.getData().getIndex()); + stateAtSlot, aggregate.getData().getSlot(), aggregate.getFirstCommitteeIndex()); for (int validatorIndex : beaconCommittee) { final Optional maybeSelectionProof = createValidSelectionProof(validatorIndex, stateAtSlot, aggregate); @@ -164,7 +164,7 @@ private Attestation createAttestationForCommittee( final UInt64 slot, final UInt64 committeeIndex) { return attestationGenerator .streamAttestations(blockAndState, slot) - .filter(attestation -> attestation.getData().getIndex().equals(committeeIndex)) + .filter(attestation -> attestation.getFirstCommitteeIndex().equals(committeeIndex)) .findFirst() .orElseThrow(); } @@ -172,7 +172,7 @@ private Attestation createAttestationForCommittee( private Optional createValidSelectionProof( final int validatorIndex, final BeaconState state, final Attestation attestation) { final UInt64 slot = attestation.getData().getSlot(); - final UInt64 committeeIndex = attestation.getData().getIndex(); + final UInt64 committeeIndex = attestation.getFirstCommitteeIndex(); final SpecVersion specVersion = spec.atSlot(slot); final List beaconCommittee = spec.getBeaconCommittee(state, slot, committeeIndex); final int aggregatorModulo = diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/AttestationGenerator.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/AttestationGenerator.java index b10949910e9..f321b64040c 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/AttestationGenerator.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/AttestationGenerator.java @@ -23,6 +23,7 @@ import java.util.Spliterator; import java.util.Spliterators; import java.util.function.Function; +import java.util.function.Supplier; import java.util.stream.Collectors; import java.util.stream.Stream; import java.util.stream.StreamSupport; @@ -32,13 +33,14 @@ import tech.pegasys.teku.bls.BLSTestUtil; import tech.pegasys.teku.infrastructure.async.SyncAsyncRunner; import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlockSummary; import tech.pegasys.teku.spec.datastructures.blocks.StateAndBlockSummary; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; import tech.pegasys.teku.spec.datastructures.state.Committee; import tech.pegasys.teku.spec.datastructures.state.CommitteeAssignment; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; @@ -58,11 +60,12 @@ public AttestationGenerator(final Spec spec, final List validatorKey this.validatorKeys = validatorKeys; } - public static int getSingleAttesterIndex(Attestation attestation) { + public static int getSingleAttesterIndex(final Attestation attestation) { return attestation.getAggregationBits().streamAllSetBits().findFirst().orElse(-1); } - public static AttestationData diffSlotAttestationData(UInt64 slot, AttestationData data) { + public static AttestationData diffSlotAttestationData( + final UInt64 slot, final AttestationData data) { return new AttestationData( slot, data.getIndex(), data.getBeaconBlockRoot(), data.getSource(), data.getTarget()); } @@ -75,7 +78,8 @@ public static AttestationData diffSlotAttestationData(UInt64 slot, AttestationDa * @return a list of aggregated {@link Attestation}s with distinct {@link * tech.pegasys.teku.spec.datastructures.operations.AttestationData} */ - public static List groupAndAggregateAttestations(List srcAttestations) { + public static List groupAndAggregateAttestations( + final List srcAttestations) { Collection> groupedAtt = srcAttestations.stream().collect(Collectors.groupingBy(Attestation::getData)).values(); return groupedAtt.stream() @@ -83,25 +87,31 @@ public static List groupAndAggregateAttestations(List .collect(Collectors.toList()); } - private static Attestation aggregateAttestations(List srcAttestations) { + private static Attestation aggregateAttestations(final List srcAttestations) { Preconditions.checkArgument(!srcAttestations.isEmpty(), "Expected at least one attestation"); - final AttestationSchema attestationSchema = srcAttestations.get(0).getSchema(); - int targetBitlistSize = + + final AttestationSchema attestationSchema = + srcAttestations.get(0).getSchema(); + final int targetBitlistSize = srcAttestations.stream().mapToInt(a -> a.getAggregationBits().size()).max().getAsInt(); - SszBitlist targetBitlist = + final SszBitlist targetBitlist = srcAttestations.stream() .map(Attestation::getAggregationBits) .reduce( attestationSchema.getAggregationBitsSchema().ofBits(targetBitlistSize), SszBitlist::or, SszBitlist::or); - BLSSignature targetSig = + final BLSSignature targetSig = BLS.aggregate( srcAttestations.stream() - .map(Attestation::getAggregateSignature) + .map(attestation -> attestation.getAggregateSignature()) .collect(Collectors.toList())); - return attestationSchema.create(targetBitlist, srcAttestations.get(0).getData(), targetSig); + return attestationSchema.create( + targetBitlist, + srcAttestations.get(0).getData(), + targetSig, + () -> srcAttestations.get(0).getCommitteeBitsRequired()); } public Attestation validAttestation(final StateAndBlockSummary blockAndState) { @@ -333,12 +343,12 @@ private void generateNextAttestation() { } final CommitteeAssignment assignment = maybeAssignment.get(); - if (!assignment.getSlot().equals(assignedSlot)) { + if (!assignment.slot().equals(assignedSlot)) { continue; } - final IntList committeeIndices = assignment.getCommittee(); - final UInt64 committeeIndex = assignment.getCommitteeIndex(); + final IntList committeeIndices = assignment.committee(); + final UInt64 committeeIndex = assignment.committeeIndex(); final Committee committee = new Committee(committeeIndex, committeeIndices); final int indexIntoCommittee = committeeIndices.indexOf(validatorIndex); final AttestationData genericAttestationData = @@ -351,7 +361,8 @@ private void generateNextAttestation() { validatorKeyPair, indexIntoCommittee, committee, - genericAttestationData)); + genericAttestationData, + committeeIndex)); break; } @@ -363,45 +374,67 @@ private void generateNextAttestationFromSchedule() { if (schedule.isDone()) { nextAttestation = Optional.empty(); } else { - final UInt64 currentCommittee = schedule.getCurrentCommittee(); - final IntList indices = schedule.getCommittee(currentCommittee); + final UInt64 currentCommitteeIndex = schedule.getCurrentCommittee(); + final IntList indices = schedule.getCommittee(currentCommitteeIndex); final Integer indexIntoCommittee = schedule.getIndexIntoCommittee(); final Integer validatorIndex = indices.getInt(indexIntoCommittee); - final Committee cc = new Committee(currentCommittee, indices); + final Committee currentCommittee = new Committee(currentCommitteeIndex, indices); final BLSKeyPair validatorKeyPair = validatorKeySupplier.apply(validatorIndex); final AttestationData genericAttestationData = - spec.getGenericAttestationData(assignedSlot, headState, headBlock, currentCommittee); + spec.getGenericAttestationData( + assignedSlot, headState, headBlock, currentCommitteeIndex); nextAttestation = Optional.of( createAttestation( - headState, validatorKeyPair, indexIntoCommittee, cc, genericAttestationData)); + headState, + validatorKeyPair, + indexIntoCommittee, + currentCommittee, + genericAttestationData, + currentCommittee.getIndex())); schedule.next(); } } private Attestation createAttestation( - BeaconState state, - BLSKeyPair attesterKeyPair, - int indexIntoCommittee, - Committee committee, - AttestationData attestationData) { - int committeeSize = committee.getCommitteeSize(); - final AttestationSchema attestationSchema = + final BeaconState state, + final BLSKeyPair attesterKeyPair, + final int indexIntoCommittee, + final Committee committee, + final AttestationData attestationData, + final UInt64 committeeIndex) { + final int committeeSize = committee.getCommitteeSize(); + final AttestationSchema attestationSchema = spec.atSlot(attestationData.getSlot()).getSchemaDefinitions().getAttestationSchema(); - SszBitlist aggregationBitfield = + final SszBitlist aggregationBitfield = getAggregationBits(attestationSchema, committeeSize, indexIntoCommittee); - BLSSignature signature = + final BLSSignature signature = new LocalSigner(spec, attesterKeyPair, SyncAsyncRunner.SYNC_RUNNER) .signAttestationData(attestationData, state.getForkInfo()) .join(); - return attestationSchema.create(aggregationBitfield, attestationData, signature); + return attestationSchema.create( + aggregationBitfield, + attestationData, + signature, + getCommitteeBitsSupplier(attestationSchema, committeeIndex)); } private SszBitlist getAggregationBits( - AttestationSchema attestationSchema, int committeeSize, int indexIntoCommittee) { + final AttestationSchema attestationSchema, + final int committeeSize, + final int indexIntoCommittee) { // Create aggregation bitfield return attestationSchema.getAggregationBitsSchema().ofBits(committeeSize, indexIntoCommittee); } + + private Supplier getCommitteeBitsSupplier( + final AttestationSchema attestationSchema, final UInt64 committeeIndex) { + return () -> + attestationSchema + .getCommitteeBitsSchema() + .orElseThrow() + .ofBits(committeeIndex.intValue()); + } } } diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/AttesterSlashingGenerator.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/AttesterSlashingGenerator.java index cd00de4af58..58abc41bfe3 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/AttesterSlashingGenerator.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/AttesterSlashingGenerator.java @@ -24,8 +24,8 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockAndState; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestation; import tech.pegasys.teku.spec.datastructures.state.Checkpoint; @@ -63,8 +63,8 @@ public AttesterSlashing createAttesterSlashingForAttestation( UInt64 epoch = spec.computeEpochAtSlot(blockAndState.getSlot()); Optional maybeAssignment = spec.getCommitteeAssignment(blockAndState.getState(), epoch, validatorIndex); - IntList committeeIndices = maybeAssignment.orElseThrow().getCommittee(); - UInt64 committeeIndex = maybeAssignment.orElseThrow().getCommitteeIndex(); + IntList committeeIndices = maybeAssignment.orElseThrow().committee(); + UInt64 committeeIndex = maybeAssignment.orElseThrow().committeeIndex(); Committee committee = new Committee(committeeIndex, committeeIndices); int indexIntoCommittee = committeeIndices.indexOf(validatorIndex); @@ -105,7 +105,7 @@ private Attestation createAttestation( final Committee committee, final AttestationData attestationData) { int committeeSize = committee.getCommitteeSize(); - AttestationSchema attestationSchema = + AttestationSchema attestationSchema = spec.atSlot(attestationData.getSlot()).getSchemaDefinitions().getAttestationSchema(); SszBitlist aggregationBitfield = attestationSchema.getAggregationBitsSchema().ofBits(committeeSize, indexIntoCommittee); diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/BlockProposalTestUtil.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/BlockProposalTestUtil.java index 4b914df0f00..e7cd6850ac3 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/BlockProposalTestUtil.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/BlockProposalTestUtil.java @@ -61,12 +61,10 @@ public class BlockProposalTestUtil { private final Spec spec; private final DataStructureUtil dataStructureUtil; - private final BeaconBlockBodyLists blockBodyLists; public BlockProposalTestUtil(final Spec spec) { this.spec = spec; this.dataStructureUtil = new DataStructureUtil(spec); - blockBodyLists = BeaconBlockBodyLists.ofSpec(spec); } public SafeFuture createNewBlock( @@ -130,6 +128,9 @@ public SafeFuture createNewBlock( builder.blobKzgCommitments( kzgCommitments.orElseGet(dataStructureUtil::emptyBlobKzgCommitments)); } + if (builder.supportsExecutionRequests()) { + builder.executionRequests(dataStructureUtil.randomExecutionRequests()); + } return SafeFuture.COMPLETE; }, BlockProductionPerformance.NOOP) @@ -203,6 +204,9 @@ public SafeFuture createNewBlockSkippingStateTransition( builder.blobKzgCommitments( kzgCommitments.orElseGet(dataStructureUtil::emptyBlobKzgCommitments)); } + if (builder.supportsExecutionRequests()) { + builder.executionRequests(dataStructureUtil.randomExecutionRequests()); + } return SafeFuture.COMPLETE; }) .thenApply( @@ -295,6 +299,7 @@ public SafeFuture createBlock( final boolean skipStateTransition) throws EpochProcessingException, SlotProcessingException { final UInt64 newEpoch = spec.computeEpochAtSlot(newSlot); + final BeaconBlockBodyLists blockBodyLists = BeaconBlockBodyLists.ofSpecAtSlot(spec, newSlot); if (skipStateTransition) { return createNewBlockSkippingStateTransition( signer, @@ -353,6 +358,7 @@ public SafeFuture createBlockWithBlobs( final boolean skipStateTransition) throws EpochProcessingException, SlotProcessingException { final UInt64 newEpoch = spec.computeEpochAtSlot(newSlot); + final BeaconBlockBodyLists blockBodyLists = BeaconBlockBodyLists.ofSpecAtSlot(spec, newSlot); final List generatedBlobKzgCommitments = blobsUtil.blobsToKzgCommitments(blobs); final SszListSchema blobKZGCommitmentsSchema = @@ -403,7 +409,7 @@ public SafeFuture createBlockWithBlobs( } } - private Eth1Data getEth1DataStub(BeaconState state, UInt64 currentEpoch) { + private Eth1Data getEth1DataStub(final BeaconState state, final UInt64 currentEpoch) { final SpecConfig specConfig = spec.atSlot(state.getSlot()).getConfig(); final int epochsPerPeriod = specConfig.getEpochsPerEth1VotingPeriod(); UInt64 votingPeriod = currentEpoch.dividedBy(epochsPerPeriod); diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/BlsToExecutionChangeGenerator.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/BlsToExecutionChangeGenerator.java index 85adbb65f80..010e078be26 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/BlsToExecutionChangeGenerator.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/BlsToExecutionChangeGenerator.java @@ -64,7 +64,7 @@ public SignedBlsToExecutionChange createAndSign( } public SszList asSszList( - final UInt64 epoch, SignedBlsToExecutionChange... changes) { + final UInt64 epoch, final SignedBlsToExecutionChange... changes) { return BeaconBlockBodySchemaCapella.required( spec.atEpoch(epoch).getSchemaDefinitions().getBeaconBlockBodySchema()) .getBlsToExecutionChangesSchema() diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/ChainBuilder.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/ChainBuilder.java index 582ddce809d..736eed15586 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/ChainBuilder.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/ChainBuilder.java @@ -567,18 +567,16 @@ private SignedBlockAndState appendNewBlockToChain(final UInt64 slot, final Block } final Signer signer = getSigner(proposerIndex); final SignedBlockAndState nextBlockAndState; + final BeaconBlockBodyLists blockBodyLists = BeaconBlockBodyLists.ofSpecAtSlot(spec, slot); try { SszList attestations = - BeaconBlockBodyLists.ofSpec(spec) - .createAttestations(options.getAttestations().toArray(new Attestation[0])); + blockBodyLists.createAttestations(options.getAttestations().toArray(new Attestation[0])); SszList attesterSlashings = - BeaconBlockBodyLists.ofSpec(spec) - .createAttesterSlashings( - options.getAttesterSlashings().toArray(new AttesterSlashing[0])); + blockBodyLists.createAttesterSlashings( + options.getAttesterSlashings().toArray(new AttesterSlashing[0])); SszList proposerSlashings = - BeaconBlockBodyLists.ofSpec(spec) - .createProposerSlashings( - options.getProposerSlashings().toArray(new ProposerSlashing[0])); + blockBodyLists.createProposerSlashings( + options.getProposerSlashings().toArray(new ProposerSlashing[0])); if (denebMilestoneReached(slot)) { nextBlockAndState = @@ -983,12 +981,12 @@ public BlockOptions setSyncAggregate(final SyncAggregate syncAggregate) { return this; } - public BlockOptions setSkipStateTransition(boolean skipStateTransition) { + public BlockOptions setSkipStateTransition(final boolean skipStateTransition) { this.skipStateTransition = skipStateTransition; return this; } - public BlockOptions setWrongProposer(boolean wrongProposer) { + public BlockOptions setWrongProposer(final boolean wrongProposer) { this.wrongProposer = wrongProposer; return this; } diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/ChainProperties.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/ChainProperties.java index b6186c9a66e..9a929e34791 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/ChainProperties.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/ChainProperties.java @@ -32,7 +32,7 @@ public ChainProperties(final Spec spec) { * @param slot The slot we want to finalize. * @return The earliest epoch that can be finalized at this slot. */ - public UInt64 computeBestEpochFinalizableAtSlot(long slot) { + public UInt64 computeBestEpochFinalizableAtSlot(final long slot) { return computeBestEpochFinalizableAtSlot(UInt64.valueOf(slot)); } @@ -44,7 +44,7 @@ public UInt64 computeBestEpochFinalizableAtSlot(long slot) { * @param slot The slot we want to finalize. * @return The earliest epoch that can be finalized at this slot. */ - public UInt64 computeBestEpochFinalizableAtSlot(UInt64 slot) { + public UInt64 computeBestEpochFinalizableAtSlot(final UInt64 slot) { final UInt64 currentEpoch = spec.computeEpochAtSlot(slot); final UInt64 startSlotAtCurrentEpoch = spec.computeStartSlotAtEpoch(currentEpoch); return startSlotAtCurrentEpoch.equals(slot) ? currentEpoch : currentEpoch.plus(UInt64.ONE); diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/VoluntaryExitGenerator.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/VoluntaryExitGenerator.java index 791233a45de..d2653458936 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/VoluntaryExitGenerator.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/VoluntaryExitGenerator.java @@ -37,7 +37,7 @@ public VoluntaryExitGenerator(final Spec spec, final List validatorK } private SignedVoluntaryExit create( - ForkInfo forkInfo, UInt64 epoch, int validatorIndex, boolean valid) { + final ForkInfo forkInfo, final UInt64 epoch, final int validatorIndex, final boolean valid) { VoluntaryExit exit = new VoluntaryExit(epoch, UInt64.valueOf(validatorIndex)); BLSSignature exitSignature = @@ -48,13 +48,16 @@ private SignedVoluntaryExit create( return new SignedVoluntaryExit(exit, exitSignature); } - public SignedVoluntaryExit withInvalidSignature(BeaconState state, int validatorIndex) { + public SignedVoluntaryExit withInvalidSignature( + final BeaconState state, final int validatorIndex) { return create( state.getForkInfo(), spec.computeEpochAtSlot(state.getSlot()), validatorIndex, false); } public SignedVoluntaryExit valid( - BeaconState state, int validatorIndex, boolean checkForHavingBeenActiveLongEnough) { + final BeaconState state, + final int validatorIndex, + final boolean checkForHavingBeenActiveLongEnough) { if (checkForHavingBeenActiveLongEnough) { checkForValidatorHavingBeenActiveLongEnough(state, validatorIndex); } @@ -62,22 +65,24 @@ public SignedVoluntaryExit valid( state.getForkInfo(), spec.computeEpochAtSlot(state.getSlot()), validatorIndex, true); } - public SignedVoluntaryExit valid(BeaconState state, int validatorIndex) { + public SignedVoluntaryExit valid(final BeaconState state, final int validatorIndex) { return valid(state, validatorIndex, true); } - public SignedVoluntaryExit withEpoch(BeaconState state, int epoch, int validatorIndex) { + public SignedVoluntaryExit withEpoch( + final BeaconState state, final int epoch, final int validatorIndex) { return create(state.getForkInfo(), UInt64.valueOf(epoch), validatorIndex, true); } - private BLSKeyPair getKeypair(int validatorIndex, boolean valid) { + private BLSKeyPair getKeypair(final int validatorIndex, final boolean valid) { return valid ? validatorKeys.get(validatorIndex) : BLSTestUtil.randomKeyPair(12345); } // It is easy to miss to update the state to a slot where validator can finally exit. This check // is to // ensure that the passed state slot is high enough to make sure that doesn't happen. - private void checkForValidatorHavingBeenActiveLongEnough(BeaconState state, int validatorIndex) { + private void checkForValidatorHavingBeenActiveLongEnough( + final BeaconState state, final int validatorIndex) { if (state .getValidators() .get(validatorIndex) diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/signatures/NoOpRemoteSigner.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/signatures/NoOpRemoteSigner.java index b3958ef98b1..593b9896380 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/signatures/NoOpRemoteSigner.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/signatures/NoOpRemoteSigner.java @@ -14,6 +14,8 @@ package tech.pegasys.teku.spec.generator.signatures; import java.net.MalformedURLException; +import java.net.URI; +import java.net.URISyntaxException; import java.net.URL; import java.util.Optional; import org.apache.logging.log4j.LogManager; @@ -27,8 +29,8 @@ public class NoOpRemoteSigner extends NoOpSigner { public Optional getSigningServiceUrl() { Optional result; try { - result = Optional.of(new URL("http://example.com/")); - } catch (MalformedURLException e) { + result = Optional.of(new URI("http://example.com/").toURL()); + } catch (MalformedURLException | URISyntaxException e) { result = Optional.empty(); LOG.error("Failed to get signing service URL", e); } diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/stategenerator/CheckpointStateGenerator.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/stategenerator/CheckpointStateGenerator.java index 6258c0760ec..8bd8fee19c7 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/stategenerator/CheckpointStateGenerator.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/generator/stategenerator/CheckpointStateGenerator.java @@ -37,7 +37,7 @@ public static CheckpointState generate( } public static BeaconState regenerateCheckpointState( - final Spec spec, final Checkpoint checkpoint, BeaconState baseState) { + final Spec spec, final Checkpoint checkpoint, final BeaconState baseState) { if (baseState.getSlot().isGreaterThan(checkpoint.getEpochStartSlot(spec))) { throw new InvalidCheckpointException( "Checkpoint state must be at or prior to checkpoint slot boundary"); diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/propertytest/suppliers/execution/versions/electra/ConsolidationRequestSupplier.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/propertytest/suppliers/execution/versions/electra/ConsolidationRequestSupplier.java new file mode 100644 index 00000000000..18000d60cff --- /dev/null +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/propertytest/suppliers/execution/versions/electra/ConsolidationRequestSupplier.java @@ -0,0 +1,26 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.propertytest.suppliers.execution.versions.electra; + +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequest; +import tech.pegasys.teku.spec.propertytest.suppliers.DataStructureUtilSupplier; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +public class ConsolidationRequestSupplier extends DataStructureUtilSupplier { + + public ConsolidationRequestSupplier() { + super(DataStructureUtil::randomConsolidationRequest, SpecMilestone.ELECTRA); + } +} diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/propertytest/suppliers/execution/versions/electra/DepositRequestSupplier.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/propertytest/suppliers/execution/versions/electra/DepositRequestSupplier.java new file mode 100644 index 00000000000..359284b2bff --- /dev/null +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/propertytest/suppliers/execution/versions/electra/DepositRequestSupplier.java @@ -0,0 +1,26 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.propertytest.suppliers.execution.versions.electra; + +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequest; +import tech.pegasys.teku.spec.propertytest.suppliers.DataStructureUtilSupplier; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +public class DepositRequestSupplier extends DataStructureUtilSupplier { + + public DepositRequestSupplier() { + super(DataStructureUtil::randomDepositRequest, SpecMilestone.ELECTRA); + } +} diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/propertytest/suppliers/execution/versions/electra/WithdrawalRequestSupplier.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/propertytest/suppliers/execution/versions/electra/WithdrawalRequestSupplier.java new file mode 100644 index 00000000000..a29f8addf16 --- /dev/null +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/propertytest/suppliers/execution/versions/electra/WithdrawalRequestSupplier.java @@ -0,0 +1,26 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.propertytest.suppliers.execution.versions.electra; + +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequest; +import tech.pegasys.teku.spec.propertytest.suppliers.DataStructureUtilSupplier; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +public class WithdrawalRequestSupplier extends DataStructureUtilSupplier { + + public WithdrawalRequestSupplier() { + super(DataStructureUtil::randomWithdrawalRequest, SpecMilestone.ELECTRA); + } +} diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/propertytest/suppliers/state/PendingConsolidationSupplier.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/propertytest/suppliers/state/PendingConsolidationSupplier.java new file mode 100644 index 00000000000..e0b239deda0 --- /dev/null +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/propertytest/suppliers/state/PendingConsolidationSupplier.java @@ -0,0 +1,25 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.propertytest.suppliers.state; + +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingConsolidation; +import tech.pegasys.teku.spec.propertytest.suppliers.DataStructureUtilSupplier; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +public class PendingConsolidationSupplier extends DataStructureUtilSupplier { + public PendingConsolidationSupplier() { + super(DataStructureUtil::randomPendingConsolidation, SpecMilestone.ELECTRA); + } +} diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/propertytest/suppliers/state/PendingDepositSupplier.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/propertytest/suppliers/state/PendingDepositSupplier.java new file mode 100644 index 00000000000..04647731dae --- /dev/null +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/propertytest/suppliers/state/PendingDepositSupplier.java @@ -0,0 +1,25 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.propertytest.suppliers.state; + +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingDeposit; +import tech.pegasys.teku.spec.propertytest.suppliers.DataStructureUtilSupplier; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +public class PendingDepositSupplier extends DataStructureUtilSupplier { + public PendingDepositSupplier() { + super(DataStructureUtil::randomPendingDeposit, SpecMilestone.ELECTRA); + } +} diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/propertytest/suppliers/state/PendingPartialWithdrawalSupplier.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/propertytest/suppliers/state/PendingPartialWithdrawalSupplier.java new file mode 100644 index 00000000000..4d74cfcf3cb --- /dev/null +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/propertytest/suppliers/state/PendingPartialWithdrawalSupplier.java @@ -0,0 +1,26 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.spec.propertytest.suppliers.state; + +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingPartialWithdrawal; +import tech.pegasys.teku.spec.propertytest.suppliers.DataStructureUtilSupplier; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +public class PendingPartialWithdrawalSupplier + extends DataStructureUtilSupplier { + public PendingPartialWithdrawalSupplier() { + super(DataStructureUtil::randomPendingPartialWithdrawal, SpecMilestone.ELECTRA); + } +} diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/BeaconBlockBuilder.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/BeaconBlockBuilder.java index 4d0eb961294..0e107d61c64 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/BeaconBlockBuilder.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/BeaconBlockBuilder.java @@ -51,7 +51,7 @@ public BeaconBlockBuilder syncAggregate(final SyncAggregate syncAggregate) { } public BeaconBlockBuilder blsToExecutionChanges( - SszList blsToExecutionChanges) { + final SszList blsToExecutionChanges) { this.blsToExecutionChanges = blsToExecutionChanges; return this; } @@ -61,17 +61,17 @@ public BeaconBlockBuilder executionPayload(final ExecutionPayload executionPaylo return this; } - public BeaconBlockBuilder proposerSlashings(SszList proposerSlashings) { + public BeaconBlockBuilder proposerSlashings(final SszList proposerSlashings) { this.proposerSlashings = proposerSlashings; return this; } - public BeaconBlockBuilder attesterSlashings(SszList attesterSlashings) { + public BeaconBlockBuilder attesterSlashings(final SszList attesterSlashings) { this.attesterSlashings = attesterSlashings; return this; } - public BeaconBlockBuilder attestations(SszList attestations) { + public BeaconBlockBuilder attestations(final SszList attestations) { this.attestations = attestations; return this; } diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/BeaconStateBuilderBellatrix.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/BeaconStateBuilderBellatrix.java index 29b34d06850..488ec040d46 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/BeaconStateBuilderBellatrix.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/BeaconStateBuilderBellatrix.java @@ -48,7 +48,9 @@ private BeaconStateBuilderBellatrix( @Override protected BeaconStateBellatrix getEmptyState() { - return BeaconStateSchemaBellatrix.create(spec.getConfig()).createEmpty(); + return BeaconStateSchemaBellatrix.create( + spec.getConfig(), spec.getSchemaDefinitions().getSchemaRegistry()) + .createEmpty(); } @Override diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/BeaconStateBuilderCapella.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/BeaconStateBuilderCapella.java index 92eb12fd6c0..92708e3a7de 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/BeaconStateBuilderCapella.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/BeaconStateBuilderCapella.java @@ -54,7 +54,9 @@ protected BeaconStateBuilderCapella( @Override protected BeaconStateCapella getEmptyState() { - return BeaconStateSchemaCapella.create(spec.getConfig()).createEmpty(); + return BeaconStateSchemaCapella.create( + spec.getConfig(), spec.getSchemaDefinitions().getSchemaRegistry()) + .createEmpty(); } @Override diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/BeaconStateBuilderDeneb.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/BeaconStateBuilderDeneb.java index 7623ad31580..c1a9d8de1cc 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/BeaconStateBuilderDeneb.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/BeaconStateBuilderDeneb.java @@ -51,7 +51,9 @@ protected BeaconStateBuilderDeneb( @Override protected BeaconStateDeneb getEmptyState() { - return BeaconStateSchemaDeneb.create(spec.getConfig()).createEmpty(); + return BeaconStateSchemaDeneb.create( + spec.getConfig(), spec.getSchemaDefinitions().getSchemaRegistry()) + .createEmpty(); } @Override diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/BeaconStateBuilderEip7594.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/BeaconStateBuilderElectra.java similarity index 55% rename from ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/BeaconStateBuilderEip7594.java rename to ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/BeaconStateBuilderElectra.java index d7aaecbf09e..2ee68ac8026 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/BeaconStateBuilderEip7594.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/BeaconStateBuilderElectra.java @@ -15,6 +15,7 @@ import static com.google.common.base.Preconditions.checkNotNull; +import java.util.List; import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.ssz.collections.SszUInt64List; import tech.pegasys.teku.infrastructure.ssz.primitive.SszByte; @@ -22,15 +23,19 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.SpecVersion; +import tech.pegasys.teku.spec.config.SpecConfigElectra; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader; import tech.pegasys.teku.spec.datastructures.state.SyncCommittee; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.eip7594.BeaconStateEip7594; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.eip7594.BeaconStateSchemaEip7594; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.eip7594.MutableBeaconStateEip7594; - -public class BeaconStateBuilderEip7594 +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.BeaconStateElectra; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.BeaconStateSchemaElectra; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.MutableBeaconStateElectra; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingConsolidation; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingDeposit; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingPartialWithdrawal; + +public class BeaconStateBuilderElectra extends AbstractBeaconStateBuilder< - BeaconStateEip7594, MutableBeaconStateEip7594, BeaconStateBuilderEip7594> { + BeaconStateElectra, MutableBeaconStateElectra, BeaconStateBuilderElectra> { private UInt64 nextWithdrawalIndex; private UInt64 nextWithdrawalValidatorIndex; @@ -41,7 +46,20 @@ public class BeaconStateBuilderEip7594 private SyncCommittee nextSyncCommittee; private ExecutionPayloadHeader latestExecutionPayloadHeader; - protected BeaconStateBuilderEip7594( + private UInt64 depositRequestsStartIndex; + private UInt64 depositBalanceToConsume; + private UInt64 exitBalanceToConsume; + private UInt64 earliestExitEpoch; + + private UInt64 consolidationBalanceToConsume; + + private UInt64 earliestConsolidationEpoch; + + private SszList pendingDeposits; + private SszList pendingPartialWithdrawals; + private SszList pendingConsolidations; + + protected BeaconStateBuilderElectra( final SpecVersion spec, final DataStructureUtil dataStructureUtil, final int defaultValidatorCount, @@ -50,12 +68,14 @@ protected BeaconStateBuilderEip7594( } @Override - protected BeaconStateEip7594 getEmptyState() { - return BeaconStateSchemaEip7594.create(spec.getConfig()).createEmpty(); + protected BeaconStateElectra getEmptyState() { + return BeaconStateSchemaElectra.create( + spec.getConfig(), spec.getSchemaDefinitions().getSchemaRegistry()) + .createEmpty(); } @Override - protected void setUniqueFields(final MutableBeaconStateEip7594 state) { + protected void setUniqueFields(final MutableBeaconStateElectra state) { state.setPreviousEpochParticipation(previousEpochParticipation); state.setCurrentEpochParticipation(currentEpochParticipation); state.setInactivityScores(inactivityScores); @@ -64,42 +84,64 @@ protected void setUniqueFields(final MutableBeaconStateEip7594 state) { state.setLatestExecutionPayloadHeader(latestExecutionPayloadHeader); state.setNextWithdrawalIndex(nextWithdrawalIndex); state.setNextWithdrawalValidatorIndex(nextWithdrawalValidatorIndex); + state.setDepositRequestsStartIndex(depositRequestsStartIndex); + state.setDepositBalanceToConsume(depositBalanceToConsume); + state.setExitBalanceToConsume(exitBalanceToConsume); + state.setEarliestExitEpoch(earliestExitEpoch); + state.setConsolidationBalanceToConsume(consolidationBalanceToConsume); + state.setEarliestConsolidationEpoch(earliestConsolidationEpoch); + state.setPendingDeposits(pendingDeposits); + state.setPendingPartialWithdrawals(pendingPartialWithdrawals); + state.setPendingConsolidations(pendingConsolidations); } - public static BeaconStateBuilderEip7594 create( + public static BeaconStateBuilderElectra create( final DataStructureUtil dataStructureUtil, final Spec spec, final int defaultValidatorCount, final int defaultItemsInSSZLists) { - return new BeaconStateBuilderEip7594( - spec.forMilestone(SpecMilestone.EIP7594), + return new BeaconStateBuilderElectra( + spec.forMilestone(SpecMilestone.ELECTRA), dataStructureUtil, defaultValidatorCount, defaultItemsInSSZLists); } - public BeaconStateBuilderEip7594 nextWithdrawalIndex(final UInt64 nextWithdrawalIndex) { + public BeaconStateBuilderElectra nextWithdrawalIndex(final UInt64 nextWithdrawalIndex) { checkNotNull(nextWithdrawalIndex); this.nextWithdrawalIndex = nextWithdrawalIndex; return this; } - public BeaconStateBuilderEip7594 nextWithdrawalValidatorIndex( + public BeaconStateBuilderElectra nextWithdrawalValidatorIndex( final UInt64 nextWithdrawalValidatorIndex) { checkNotNull(nextWithdrawalValidatorIndex); this.nextWithdrawalValidatorIndex = nextWithdrawalValidatorIndex; return this; } - private BeaconStateSchemaEip7594 getBeaconStateSchema() { - return (BeaconStateSchemaEip7594) spec.getSchemaDefinitions().getBeaconStateSchema(); + public BeaconStateBuilderElectra depositRequestsStartIndex( + final UInt64 depositRequestsStartIndex) { + checkNotNull(depositRequestsStartIndex); + this.depositRequestsStartIndex = depositRequestsStartIndex; + return this; + } + + public BeaconStateBuilderElectra depositBalanceToConsume(final UInt64 depositBalanceToConsume) { + checkNotNull(depositBalanceToConsume); + this.depositBalanceToConsume = depositBalanceToConsume; + return this; + } + + private BeaconStateSchemaElectra getBeaconStateSchema() { + return (BeaconStateSchemaElectra) spec.getSchemaDefinitions().getBeaconStateSchema(); } @Override protected void initDefaults() { super.initDefaults(); - final BeaconStateSchemaEip7594 schema = getBeaconStateSchema(); + final BeaconStateSchemaElectra schema = getBeaconStateSchema(); previousEpochParticipation = dataStructureUtil.randomSszList( @@ -118,12 +160,24 @@ protected void initDefaults() { nextSyncCommittee = dataStructureUtil.randomSyncCommittee(); latestExecutionPayloadHeader = dataStructureUtil.randomExecutionPayloadHeader( - dataStructureUtil.getSpec().forMilestone(SpecMilestone.EIP7594)); + dataStructureUtil.getSpec().forMilestone(SpecMilestone.ELECTRA)); this.nextWithdrawalIndex = UInt64.ZERO; this.nextWithdrawalValidatorIndex = defaultValidatorCount > 0 ? dataStructureUtil.randomUInt64(defaultValidatorCount) : UInt64.ZERO; + + this.depositRequestsStartIndex = SpecConfigElectra.UNSET_DEPOSIT_REQUESTS_START_INDEX; + this.depositBalanceToConsume = UInt64.ZERO; + this.exitBalanceToConsume = UInt64.ZERO; + this.earliestExitEpoch = UInt64.ZERO; + this.consolidationBalanceToConsume = UInt64.ZERO; + this.earliestConsolidationEpoch = UInt64.ZERO; + this.pendingDeposits = schema.getPendingDepositsSchema().createFromElements(List.of()); + this.pendingPartialWithdrawals = + schema.getPendingPartialWithdrawalsSchema().createFromElements(List.of()); + this.pendingConsolidations = + schema.getPendingConsolidationsSchema().createFromElements(List.of()); } } diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/DataStructureUtil.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/DataStructureUtil.java index b00f52d459c..188a2b70a37 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/DataStructureUtil.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/DataStructureUtil.java @@ -32,6 +32,7 @@ import java.util.function.Consumer; import java.util.function.Function; import java.util.function.Supplier; +import java.util.stream.Collectors; import java.util.stream.IntStream; import java.util.stream.Stream; import org.apache.tuweni.bytes.Bytes; @@ -117,6 +118,7 @@ import tech.pegasys.teku.spec.datastructures.blocks.versions.deneb.SignedBlockContents; import tech.pegasys.teku.spec.datastructures.builder.BlobsBundleSchema; import tech.pegasys.teku.spec.datastructures.builder.BuilderBid; +import tech.pegasys.teku.spec.datastructures.builder.BuilderBidBuilder; import tech.pegasys.teku.spec.datastructures.builder.ExecutionPayloadAndBlobsBundle; import tech.pegasys.teku.spec.datastructures.builder.ExecutionPayloadAndBlobsBundleSchema; import tech.pegasys.teku.spec.datastructures.builder.SignedBuilderBid; @@ -131,6 +133,13 @@ import tech.pegasys.teku.spec.datastructures.execution.Transaction; import tech.pegasys.teku.spec.datastructures.execution.TransactionSchema; import tech.pegasys.teku.spec.datastructures.execution.versions.capella.Withdrawal; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequests; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsBuilderElectra; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsDataCodec; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ExecutionRequestsSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequest; import tech.pegasys.teku.spec.datastructures.forkchoice.VoteTracker; import tech.pegasys.teku.spec.datastructures.lightclient.LightClientBootstrap; import tech.pegasys.teku.spec.datastructures.lightclient.LightClientBootstrapSchema; @@ -152,7 +161,7 @@ import tech.pegasys.teku.spec.datastructures.operations.DepositMessage; import tech.pegasys.teku.spec.datastructures.operations.DepositWithIndex; import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestation; -import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestation.IndexedAttestationSchema; +import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing; import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof; import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChange; @@ -163,7 +172,6 @@ import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncAggregatorSelectionData; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeContribution; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeMessage; -import tech.pegasys.teku.spec.datastructures.operations.versions.bellatrix.BeaconPreparableProposer; import tech.pegasys.teku.spec.datastructures.state.AnchorPoint; import tech.pegasys.teku.spec.datastructures.state.Checkpoint; import tech.pegasys.teku.spec.datastructures.state.Fork; @@ -179,20 +187,26 @@ import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.altair.BeaconStateSchemaAltair; import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.phase0.BeaconStateSchemaPhase0; import tech.pegasys.teku.spec.datastructures.state.versions.capella.HistoricalSummary; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingConsolidation; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingDeposit; +import tech.pegasys.teku.spec.datastructures.state.versions.electra.PendingPartialWithdrawal; import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; import tech.pegasys.teku.spec.datastructures.type.SszKZGProof; import tech.pegasys.teku.spec.datastructures.type.SszPublicKey; import tech.pegasys.teku.spec.datastructures.type.SszSignature; +import tech.pegasys.teku.spec.datastructures.validator.BeaconPreparableProposer; import tech.pegasys.teku.spec.executionlayer.ForkChoiceState; import tech.pegasys.teku.spec.executionlayer.PayloadBuildingAttributes; +import tech.pegasys.teku.spec.logic.versions.deneb.helpers.MiscHelpersDeneb; import tech.pegasys.teku.spec.logic.versions.deneb.types.VersionedHash; -import tech.pegasys.teku.spec.logic.versions.eip7594.helpers.MiscHelpersEip7594; +import tech.pegasys.teku.spec.logic.versions.feature.eip7594.helpers.MiscHelpersEip7594; import tech.pegasys.teku.spec.schemas.SchemaDefinitions; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsAltair; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsBellatrix; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsCapella; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsDeneb; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsEip7594; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; public final class DataStructureUtil { @@ -200,6 +214,9 @@ public final class DataStructureUtil { private static final int MAX_EP_RANDOM_TRANSACTIONS_SIZE = 32; private static final int MAX_EP_RANDOM_WITHDRAWALS = 4; + private static final int MAX_EP_RANDOM_DEPOSIT_REQUESTS = 4; + private static final int MAX_EP_RANDOM_WITHDRAWAL_REQUESTS = 2; + private static final int MAX_EP_RANDOM_CONSOLIDATION_REQUESTS = 1; private final Spec spec; @@ -222,7 +239,7 @@ public DataStructureUtil withPubKeyGenerator(final Supplier pubKey } public DataStructureUtil withSignatureGenerator( - Function signatureGenerator) { + final Function signatureGenerator) { this.signatureGenerator = signatureGenerator; return this; } @@ -315,23 +332,23 @@ public SszSignature randomSszSignature() { } public SszList randomSszList( - SszListSchema schema, Supplier valueGenerator, long numItems) { + final SszListSchema schema, final Supplier valueGenerator, final long numItems) { return randomSszList(schema, numItems, valueGenerator); } public SszList randomFullSszList( - SszListSchema schema, Supplier valueGenerator) { + final SszListSchema schema, final Supplier valueGenerator) { return randomSszList(schema, schema.getMaxLength(), valueGenerator); } public SszList randomSszList( - SszListSchema schema, final long numItems, Supplier valueGenerator) { + final SszListSchema schema, final long numItems, final Supplier valueGenerator) { return Stream.generate(valueGenerator) .limit(Math.min(numItems, schema.getMaxLength())) .collect(schema.collector()); } - public > + public > SszPrimitiveList randomSszPrimitiveList( final SszPrimitiveListSchema schema, final long numItems, @@ -363,7 +380,7 @@ public SszBytes32Vector randomSszBytes32Vector( .collect(schema.collectorUnboxed()); } - public > + public > SszPrimitiveVector randomSszPrimitiveVector( final SszPrimitiveVectorSchema schema, final Supplier valueGenerator) { @@ -377,7 +394,8 @@ SszPrimitiveVector randomSszPrimitiveVector( public > VectorT randomSszVector( - SszVectorSchema schema, Supplier valueGenerator) { + final SszVectorSchema schema, + final Supplier valueGenerator) { final int numItems = schema.getLength() / 10; final SszElementT defaultElement = schema.getElementSchema().getDefault(); return Stream.concat( @@ -391,7 +409,11 @@ public SszByte randomSszByte() { } public SszBitlist randomBitlist() { - return randomBitlist(getMaxValidatorsPerCommittee()); + return randomBitlist(randomSlot()); + } + + public SszBitlist randomBitlist(final UInt64 slot) { + return randomBitlist(getMaxValidatorsPerCommittee(slot)); } public SszBitlist randomBitlist(final int n) { @@ -400,6 +422,10 @@ public SszBitlist randomBitlist(final int n) { return SszBitlistSchema.create(n).ofBits(n, bits); } + public SszBitvector randomCommitteeBitvector() { + return randomSszBitvector(getMaxCommitteesPerSlot()); + } + public SszBitvector randomSszBitvector(final int n) { Random random = new Random(nextSeed()); int[] bits = IntStream.range(0, n).sequential().filter(__ -> random.nextBoolean()).toArray(); @@ -609,48 +635,35 @@ public ExecutionPayloadHeader randomExecutionPayloadHeader() { } public BuilderBid randomBuilderBid() { - return randomBuilderBid(randomPublicKey()); + return randomBuilderBid(__ -> {}); } - public BuilderBid randomBuilderBid(final BLSPublicKey builderPublicKey) { - // 1 ETH is 10^18 wei, Uint256 max is more than 10^77, so just to avoid - // overflows in - // computation - final UInt256 value = randomUInt256().divide(1000); - return randomBuilderBid(builderPublicKey, value); + public BuilderBid randomBuilderBid(final Bytes32 withdrawalsRoot) { + return randomBuilderBid( + builder -> + builder.header(randomExecutionPayloadHeader(spec.getGenesisSpec(), withdrawalsRoot))); } - public BuilderBid randomBuilderBid(final BLSPublicKey builderPublicKey, final UInt256 value) { + public BuilderBid randomBuilderBid(final Consumer builderModifier) { final SchemaDefinitionsBellatrix schemaDefinitions = getBellatrixSchemaDefinitions(randomSlot()); return schemaDefinitions .getBuilderBidSchema() .createBuilderBid( builder -> { - builder - .header(randomExecutionPayloadHeader(spec.getGenesisSpec())) - .value(value) - .publicKey(builderPublicKey); + builder.header(randomExecutionPayloadHeader()); schemaDefinitions .toVersionDeneb() .ifPresent(__ -> builder.blobKzgCommitments(randomBlobKzgCommitments())); - }); - } - - public BuilderBid randomBuilderBid(final Bytes32 withdrawalsRoot) { - final SchemaDefinitionsBellatrix schemaDefinitions = - getBellatrixSchemaDefinitions(randomSlot()); - return schemaDefinitions - .getBuilderBidSchema() - .createBuilderBid( - builder -> { - builder - .header(randomExecutionPayloadHeader(spec.getGenesisSpec(), withdrawalsRoot)) - .value(randomUInt256()) - .publicKey(randomPublicKey()); schemaDefinitions - .toVersionDeneb() - .ifPresent(__ -> builder.blobKzgCommitments(randomBlobKzgCommitments())); + .toVersionElectra() + .ifPresent(__ -> builder.executionRequests(randomExecutionRequests())); + // 1 ETH is 10^18 wei, Uint256 max is more than 10^77, so just to avoid + // overflows in + // computation + builder.value(randomUInt256().divide(1000)); + builder.publicKey(randomPublicKey()); + builderModifier.accept(builder); }); } @@ -731,6 +744,24 @@ public List randomExecutionPayloadWithdrawals() { .collect(toList()); } + public List randomDepositRequests() { + return IntStream.rangeClosed(0, randomInt(MAX_EP_RANDOM_DEPOSIT_REQUESTS)) + .mapToObj(__ -> randomDepositRequest()) + .collect(toList()); + } + + public List randomWithdrawalRequests() { + return IntStream.rangeClosed(0, randomInt(MAX_EP_RANDOM_WITHDRAWAL_REQUESTS)) + .mapToObj(__ -> randomWithdrawalRequest()) + .collect(toList()); + } + + public List randomConsolidationRequests() { + return IntStream.rangeClosed(0, randomInt(MAX_EP_RANDOM_CONSOLIDATION_REQUESTS)) + .mapToObj(__ -> randomConsolidationRequest()) + .collect(toList()); + } + public ExecutionPayloadAndBlobsBundle randomExecutionPayloadAndBlobsBundle() { final SchemaDefinitionsDeneb schemaDefinitionsDeneb = getDenebSchemaDefinitions(randomSlot()); final ExecutionPayload executionPayload = randomExecutionPayload(); @@ -796,7 +827,11 @@ public AttestationData randomAttestationData(final UInt64 slot, final Bytes32 bl public Attestation randomAttestation() { return spec.getGenesisSchemaDefinitions() .getAttestationSchema() - .create(randomBitlist(), randomAttestationData(), randomSignature()); + .create( + randomBitlist(), + randomAttestationData(), + randomSignature(), + this::randomCommitteeBitvector); } public Attestation randomAttestation(final long slot) { @@ -804,15 +839,21 @@ public Attestation randomAttestation(final long slot) { } public Attestation randomAttestation(final UInt64 slot) { - return spec.getGenesisSchemaDefinitions() + return spec.atSlot(slot) + .getSchemaDefinitions() .getAttestationSchema() - .create(randomBitlist(), randomAttestationData(slot), randomSignature()); + .create( + randomBitlist(slot), + randomAttestationData(slot), + randomSignature(), + this::randomCommitteeBitvector); } public Attestation randomAttestation(final AttestationData attestationData) { return spec.getGenesisSchemaDefinitions() .getAttestationSchema() - .create(randomBitlist(), attestationData, randomSignature()); + .create( + randomBitlist(), attestationData, randomSignature(), this::randomCommitteeBitvector); } public AggregateAndProof randomAggregateAndProof() { @@ -857,7 +898,8 @@ public PendingAttestation randomPendingAttestation( public AttesterSlashing randomAttesterSlashingAtSlot(final UInt64 slot) { final UInt64[] attestingIndices = {randomUInt64(), randomUInt64(), randomUInt64()}; - return spec.getGenesisSchemaDefinitions() + return spec.atSlot(slot) + .getSchemaDefinitions() .getAttesterSlashingSchema() .create( randomIndexedAttestation(randomAttestationData(slot), attestingIndices), @@ -865,13 +907,20 @@ public AttesterSlashing randomAttesterSlashingAtSlot(final UInt64 slot) { } public AttesterSlashing randomAttesterSlashing() { - return randomAttesterSlashing(randomUInt64(), randomUInt64(), randomUInt64()); + return randomAttesterSlashing( + randomSlot().longValue(), randomUInt64(), randomUInt64(), randomUInt64()); } public AttesterSlashing randomAttesterSlashing(final UInt64... attestingIndices) { + return randomAttesterSlashing(randomSlot().longValue(), attestingIndices); + } + + public AttesterSlashing randomAttesterSlashing( + final long slot, final UInt64... attestingIndices) { IndexedAttestation attestation1 = randomIndexedAttestation(attestingIndices); IndexedAttestation attestation2 = randomIndexedAttestation(attestingIndices); - return spec.getGenesisSchemaDefinitions() + return spec.atSlot(UInt64.valueOf(slot)) + .getSchemaDefinitions() .getAttesterSlashingSchema() .create(attestation1, attestation2); } @@ -994,10 +1043,19 @@ public SignedBeaconBlock randomSignedBeaconBlockWithCommitments(final int count) return randomSignedBeaconBlockWithCommitments(randomBlobKzgCommitments(count)); } + public SignedBeaconBlock randomSignedBeaconBlockWithCommitments( + final UInt64 slot, final int count) { + return randomSignedBeaconBlockWithCommitments(slot, randomBlobKzgCommitments(count)); + } + public SignedBeaconBlock randomSignedBeaconBlockWithCommitments( final SszList commitments) { + return randomSignedBeaconBlockWithCommitments(randomUInt64(), commitments); + } + + public SignedBeaconBlock randomSignedBeaconBlockWithCommitments( + final UInt64 slot, final SszList commitments) { final UInt64 proposerIndex = randomUInt64(); - final UInt64 slot = randomUInt64(); final Bytes32 stateRoot = randomBytes32(); final Bytes32 parentRoot = randomBytes32(); @@ -1054,7 +1112,7 @@ public BeaconBlock randomBeaconBlock(final UInt64 slotNum) { return randomBeaconBlock(slotNum, randomBeaconBlockBody(slotNum)); } - public BeaconBlock randomBeaconBlock(final UInt64 slotNum, BeaconBlockBody body) { + public BeaconBlock randomBeaconBlock(final UInt64 slotNum, final BeaconBlockBody body) { final UInt64 proposerIndex = randomUInt64(); final Bytes32 previousRoot = randomBytes32(); final Bytes32 stateRoot = randomBytes32(); @@ -1213,14 +1271,15 @@ public BeaconBlock randomBeaconBlock( } public BeaconBlock randomBeaconBlock( - final long slot, Bytes32 parentRoot, final Bytes32 stateRoot, final boolean isFull) { + final long slot, final Bytes32 parentRoot, final Bytes32 stateRoot, final boolean isFull) { return randomBeaconBlock(UInt64.valueOf(slot), parentRoot, stateRoot, isFull); } public BeaconBlock randomBeaconBlock( final UInt64 slot, final Bytes32 parentRoot, final Bytes32 stateRoot, final boolean isFull) { final UInt64 proposerIndex = randomUInt64(); - final BeaconBlockBody body = !isFull ? randomBeaconBlockBody() : randomFullBeaconBlockBody(); + final BeaconBlockBody body = + !isFull ? randomBeaconBlockBody(slot) : randomFullBeaconBlockBody(slot); return new BeaconBlock( spec.atSlot(slot).getSchemaDefinitions().getBeaconBlockSchema(), @@ -1313,6 +1372,9 @@ public BeaconBlockBody randomBlindedBeaconBlockBody( if (builder.supportsKzgCommitments()) { builder.blobKzgCommitments(randomBlobKzgCommitments()); } + if (builder.supportsExecutionRequests()) { + builder.executionRequests(randomExecutionRequests()); + } builderModifier.accept(builder); return SafeFuture.COMPLETE; }) @@ -1395,9 +1457,12 @@ public BeaconBlockBody randomBeaconBlockBody( schema.getProposerSlashingsSchema(), this::randomProposerSlashing, 1)) .attesterSlashings( randomSszList( - schema.getAttesterSlashingsSchema(), this::randomAttesterSlashing, 1)) + schema.getAttesterSlashingsSchema(), + () -> randomAttesterSlashingAtSlot(slot), + 1)) .attestations( - randomSszList(schema.getAttestationsSchema(), this::randomAttestation, 3)) + randomSszList( + schema.getAttestationsSchema(), () -> randomAttestation(slot), 3)) .deposits( randomSszList(schema.getDepositsSchema(), this::randomDepositWithoutIndex, 1)) .voluntaryExits( @@ -1415,20 +1480,23 @@ public BeaconBlockBody randomBeaconBlockBody( if (builder.supportsKzgCommitments()) { builder.blobKzgCommitments(randomBlobKzgCommitments()); } + if (builder.supportsExecutionRequests()) { + builder.executionRequests(randomExecutionRequests()); + } builderModifier.accept(builder); return SafeFuture.COMPLETE; }) .join(); } - public BeaconBlockBody randomFullBeaconBlockBody() { - return randomFullBeaconBlockBody(__ -> {}); + public BeaconBlockBody randomFullBeaconBlockBody(final UInt64 slot) { + return randomFullBeaconBlockBody(slot, __ -> {}); } public BeaconBlockBody randomFullBeaconBlockBody( - final Consumer builderModifier) { + final UInt64 slot, final Consumer builderModifier) { final BeaconBlockBodySchema schema = - spec.getGenesisSpec().getSchemaDefinitions().getBeaconBlockBodySchema(); + spec.atSlot(slot).getSchemaDefinitions().getBeaconBlockBodySchema(); return schema .createBlockBody( builder -> { @@ -1441,9 +1509,10 @@ public BeaconBlockBody randomFullBeaconBlockBody( schema.getProposerSlashingsSchema(), this::randomProposerSlashing)) .attesterSlashings( randomFullSszList( - schema.getAttesterSlashingsSchema(), this::randomAttesterSlashing)) + schema.getAttesterSlashingsSchema(), () -> randomAttesterSlashing(slot))) .attestations( - randomFullSszList(schema.getAttestationsSchema(), this::randomAttestation)) + randomFullSszList( + schema.getAttestationsSchema(), () -> randomAttestation(slot))) .deposits( randomFullSszList( schema.getDepositsSchema(), this::randomDepositWithoutIndex)) @@ -1469,6 +1538,9 @@ public BeaconBlockBody randomFullBeaconBlockBody( BeaconBlockBodySchemaDeneb.required(schema).getBlobKzgCommitmentsSchema(), this::randomSszKZGCommitment)); } + if (builder.supportsExecutionRequests()) { + builder.executionRequests(randomExecutionRequests()); + } builderModifier.accept(builder); return SafeFuture.COMPLETE; }) @@ -1504,26 +1576,40 @@ public IndexedAttestation randomIndexedAttestation(final UInt64... attestingIndi public IndexedAttestation randomIndexedAttestation( final AttestationData data, final UInt64... attestingIndicesInput) { final IndexedAttestationSchema indexedAttestationSchema = - spec.getGenesisSchemaDefinitions().getIndexedAttestationSchema(); + spec.atSlot(data.getSlot()).getSchemaDefinitions().getIndexedAttestationSchema(); final SszUInt64List attestingIndices = indexedAttestationSchema.getAttestingIndicesSchema().of(attestingIndicesInput); return indexedAttestationSchema.create(attestingIndices, data, randomSignature()); } - public DepositMessage randomDepositMessage(final BLSKeyPair keyPair) { + public DepositMessage randomDepositMessage( + final BLSKeyPair keyPair, final Optional maybeWithdrawalCredentials) { final BLSPublicKey pubkey = keyPair.getPublicKey(); - final Bytes32 withdrawalCredentials = randomBytes32(); + final Bytes32 withdrawalCredentials = maybeWithdrawalCredentials.orElse(randomBytes32()); return new DepositMessage(pubkey, withdrawalCredentials, getMaxEffectiveBalance()); } public DepositMessage randomDepositMessage() { final BLSKeyPair keyPair = randomKeyPair(); - return randomDepositMessage(keyPair); + return randomDepositMessage(keyPair, Optional.empty()); } public DepositData randomDepositData() { final BLSKeyPair keyPair = randomKeyPair(); - final DepositMessage depositMessage = randomDepositMessage(keyPair); + final DepositMessage depositMessage = randomDepositMessage(keyPair, Optional.empty()); + + final Bytes32 domain = computeDepositDomain(); + final Bytes signingRoot = getSigningRoot(depositMessage, domain); + + final BLSSignature signature = BLS.sign(keyPair.getSecretKey(), signingRoot); + + return new DepositData(depositMessage, signature); + } + + public DepositData randomDepositData(final Bytes32 withdrawalCredentials) { + final BLSKeyPair keyPair = randomKeyPair(); + final DepositMessage depositMessage = + randomDepositMessage(keyPair, Optional.of(withdrawalCredentials)); final Bytes32 domain = computeDepositDomain(); final Bytes signingRoot = getSigningRoot(depositMessage, domain); @@ -1541,10 +1627,11 @@ public DepositWithIndex randomDepositWithIndex(final long depositIndex) { final Bytes32 randomBytes32 = randomBytes32(); final SszBytes32VectorSchema proofSchema = Deposit.SSZ_SCHEMA.getProofSchema(); return new DepositWithIndex( - Stream.generate(() -> randomBytes32) - .limit(proofSchema.getLength()) - .collect(proofSchema.collectorUnboxed()), - randomDepositData(), + new Deposit( + Stream.generate(() -> randomBytes32) + .limit(proofSchema.getLength()) + .collect(proofSchema.collectorUnboxed()), + randomDepositData()), UInt64.valueOf(depositIndex)); } @@ -1610,14 +1697,12 @@ public tech.pegasys.teku.ethereum.pow.api.Deposit randomDepositEvent() { return randomDepositEvent(randomUInt64()); } - public List randomDeposits(final int num) { - final ArrayList deposits = new ArrayList<>(); - - for (int i = 0; i < num; i++) { - deposits.add(randomDepositWithIndex()); - } + public List randomDeposits(final int num) { + return randomDepositsWithIndex(num).stream().map(DepositWithIndex::deposit).toList(); + } - return deposits; + public List randomDepositsWithIndex(final int num) { + return Stream.generate(this::randomDepositWithIndex).limit(num).collect(Collectors.toList()); } public SszList randomSszDeposits(final int num) { @@ -1734,7 +1819,9 @@ public PayloadBuildingAttributes randomPayloadBuildingAttributes( ? Optional.of(randomSignedValidatorRegistration()) : Optional.empty(), randomWithdrawalList(), - randomBytes32()); + randomBytes32(), + Optional.of(randomUInt64()), + Optional.of(randomUInt64())); } public ClientVersion randomClientVersion() { @@ -1809,6 +1896,13 @@ public BeaconState randomBeaconState(final int validatorCount, final int numItem .build(); } + public BeaconState randomBeaconState( + final int validatorCount, final int numItemsInSSZLists, final UInt64 slot) { + return stateBuilder(spec.getGenesisSpec().getMilestone(), validatorCount, numItemsInSSZLists) + .slot(slot) + .build(); + } + public AbstractBeaconStateBuilder< ? extends BeaconState, ? extends MutableBeaconState, @@ -1821,7 +1915,7 @@ public BeaconState randomBeaconState(final int validatorCount, final int numItem case BELLATRIX -> stateBuilderBellatrix(validatorCount, numItemsInSszLists); case CAPELLA -> stateBuilderCapella(validatorCount, numItemsInSszLists); case DENEB -> stateBuilderDeneb(validatorCount, numItemsInSszLists); - case EIP7594 -> stateBuilderEip7594(validatorCount, numItemsInSszLists); + case ELECTRA, FULU -> stateBuilderElectra(validatorCount, numItemsInSszLists); }; } @@ -1866,9 +1960,9 @@ public BeaconStateBuilderDeneb stateBuilderDeneb( this, spec, defaultValidatorCount, defaultItemsInSSZLists); } - public BeaconStateBuilderEip7594 stateBuilderEip7594( + public BeaconStateBuilderElectra stateBuilderElectra( final int defaultValidatorCount, final int defaultItemsInSSZLists) { - return BeaconStateBuilderEip7594.create( + return BeaconStateBuilderElectra.create( this, spec, defaultValidatorCount, defaultItemsInSSZLists); } @@ -2032,6 +2126,34 @@ public Withdrawal randomWithdrawal() { .create(randomUInt64(), randomValidatorIndex(), randomBytes20(), randomUInt64()); } + public DepositRequest randomDepositRequestWithValidSignature(final UInt64 index) { + final BLSKeyPair keyPair = randomKeyPair(); + final DepositMessage depositMessage = + new DepositMessage(keyPair.getPublicKey(), randomBytes32(), randomUInt64()); + final Bytes32 domain = computeDepositDomain(); + final Bytes signingRoot = getSigningRoot(depositMessage, domain); + final BLSSignature signature = BLS.sign(keyPair.getSecretKey(), signingRoot); + return getElectraSchemaDefinitions(randomSlot()) + .getDepositRequestSchema() + .create( + depositMessage.getPubkey(), + depositMessage.getWithdrawalCredentials(), + depositMessage.getAmount(), + signature, + index); + } + + public DepositRequest randomDepositRequest() { + return getElectraSchemaDefinitions(randomSlot()) + .getDepositRequestSchema() + .create( + randomPublicKey(), + randomEth1WithdrawalCredentials(), + randomUInt64(), + randomSignature(), + randomUInt64()); + } + public HistoricalSummary randomHistoricalSummary() { return getCapellaSchemaDefinitions(randomSlot()) .getHistoricalSummarySchema() @@ -2104,6 +2226,13 @@ public Bytes32 randomEth1WithdrawalCredentials() { randomEth1Address().getWrappedBytes())); } + public Bytes32 randomCompoundingWithdrawalCredentials() { + return Bytes32.wrap( + Bytes.concatenate( + Bytes.fromHexString("0x020000000000000000000000"), + randomEth1Address().getWrappedBytes())); + } + public List randomVersionedHashes(final int count) { return IntStream.range(0, count) .mapToObj(__ -> new VersionedHash(randomBytes32())) @@ -2164,6 +2293,23 @@ public BlobSidecar randomBlobSidecarForBlock( .build(); } + public BlobSidecar randomBlobSidecarWithValidInclusionProofForBlock( + final SignedBeaconBlock signedBeaconBlock, final int index) { + return new RandomBlobSidecarBuilder() + .signedBeaconBlockHeader(signedBeaconBlock.asHeader()) + .index(UInt64.valueOf(index)) + .kzgCommitment( + BeaconBlockBodyDeneb.required(signedBeaconBlock.getMessage().getBody()) + .getBlobKzgCommitments() + .get(index) + .getKZGCommitment() + .getBytesCompressed()) + .kzgCommitmentInclusionProof( + validKzgCommitmentInclusionProof( + UInt64.valueOf(index), signedBeaconBlock.getBeaconBlock().orElseThrow().getBody())) + .build(); + } + public List randomBlobs(final int count, final UInt64 slot) { final List blobs = new ArrayList<>(); final BlobSchema blobSchema = getDenebSchemaDefinitions(slot).getBlobSchema(); @@ -2187,7 +2333,10 @@ public BlobIdentifier randomBlobIdentifier() { public BlobIdentifier randomBlobIdentifier(final Bytes32 blockRoot) { final int maxBlobsPerBlock = - SpecConfigDeneb.required(spec.forMilestone(SpecMilestone.DENEB).getConfig()) + spec.forMilestone(SpecMilestone.DENEB) + .getConfig() + .toVersionDeneb() + .orElseThrow() .getMaxBlobsPerBlock(); return new BlobIdentifier(blockRoot, randomUInt64(maxBlobsPerBlock)); } @@ -2518,6 +2667,12 @@ public List randomKzgCommitmentInclusionProof() { return IntStream.range(0, depth).mapToObj(__ -> randomBytes32()).toList(); } + public List validKzgCommitmentInclusionProof( + final UInt64 blobIndex, final BeaconBlockBody beaconBlockBody) { + return MiscHelpersDeneb.required(spec.forMilestone(SpecMilestone.DENEB).miscHelpers()) + .computeBlobKzgCommitmentInclusionProof(blobIndex, beaconBlockBody); + } + public SszList randomBlobKzgCommitments() { // use MAX_BLOBS_PER_BLOCK as a limit return randomBlobKzgCommitments(randomNumberOfBlobsPerBlock()); @@ -2531,13 +2686,102 @@ public SszList emptyBlobKzgCommitments() { return getBlobKzgCommitmentsSchema().of(); } + public ExecutionRequests randomExecutionRequests() { + return new ExecutionRequestsBuilderElectra( + spec.forMilestone(SpecMilestone.ELECTRA).getSchemaDefinitions().getSchemaRegistry()) + .deposits(randomDepositRequests()) + .withdrawals(randomWithdrawalRequests()) + .consolidations(randomConsolidationRequests()) + .build(); + } + + public List randomEncodedExecutionRequests() { + final ExecutionRequestsSchema executionRequestsSchema = + SchemaDefinitionsElectra.required( + spec.forMilestone(SpecMilestone.ELECTRA).getSchemaDefinitions()) + .getExecutionRequestsSchema(); + return new ExecutionRequestsDataCodec(executionRequestsSchema) + .encode(randomExecutionRequests()); + } + + public WithdrawalRequest randomWithdrawalRequest() { + return getElectraSchemaDefinitions(randomSlot()) + .getWithdrawalRequestSchema() + .create(randomEth1Address(), randomPublicKey(), randomUInt64()); + } + + public WithdrawalRequest withdrawalRequest( + final Bytes20 sourceAddress, final BLSPublicKey validatorPubKey, final UInt64 amount) { + return getElectraSchemaDefinitions(randomSlot()) + .getWithdrawalRequestSchema() + .create(sourceAddress, validatorPubKey, amount); + } + + public WithdrawalRequest withdrawalRequest(final Validator validator) { + final Bytes20 executionAddress = new Bytes20(validator.getWithdrawalCredentials().slice(12)); + return getElectraSchemaDefinitions(randomSlot()) + .getWithdrawalRequestSchema() + .create(executionAddress, validator.getPublicKey(), randomUInt64()); + } + + public WithdrawalRequest withdrawalRequest(final Validator validator, final UInt64 amount) { + final Bytes20 executionAddress = new Bytes20(validator.getWithdrawalCredentials().slice(12)); + return getElectraSchemaDefinitions(randomSlot()) + .getWithdrawalRequestSchema() + .create(executionAddress, validator.getPublicKey(), amount); + } + + public PendingDeposit randomPendingDeposit() { + return getElectraSchemaDefinitions(randomSlot()) + .getPendingDepositSchema() + .create( + randomSszPublicKey(), + SszBytes32.of(randomEth1WithdrawalCredentials()), + SszUInt64.of(randomUInt64()), + randomSszSignature(), + SszUInt64.of(randomUInt64())); + } + + public ConsolidationRequest randomConsolidationRequest() { + return getElectraSchemaDefinitions(randomSlot()) + .getConsolidationRequestSchema() + .create(randomEth1Address(), randomPublicKey(), randomPublicKey()); + } + + public PendingConsolidation randomPendingConsolidation() { + return getElectraSchemaDefinitions(randomSlot()) + .getPendingConsolidationSchema() + .create(SszUInt64.of(randomUInt64()), SszUInt64.of(randomUInt64())); + } + + public PendingPartialWithdrawal randomPendingPartialWithdrawal() { + return getElectraSchemaDefinitions(randomSlot()) + .getPendingPartialWithdrawalSchema() + .create( + SszUInt64.of(randomUInt64()), + SszUInt64.of(randomUInt64()), + SszUInt64.of(randomUInt64())); + } + public UInt64 randomBlobSidecarIndex() { - return randomUInt64(spec.getMaxBlobsPerBlock().orElseThrow()); + return randomUInt64( + spec.forMilestone(spec.getForkSchedule().getHighestSupportedMilestone()) + .getConfig() + .toVersionDeneb() + .orElseThrow() + .getMaxBlobsPerBlock()); } private int randomNumberOfBlobsPerBlock() { // minimum 1 blob - return randomInt(1, spec.getMaxBlobsPerBlock().orElseThrow() + 1); + return randomInt( + 1, + spec.forMilestone(spec.getForkSchedule().getHighestSupportedMilestone()) + .getConfig() + .toVersionDeneb() + .orElseThrow() + .getMaxBlobsPerBlock() + + 1); } private int randomInt(final int origin, final int bound) { @@ -2564,6 +2808,10 @@ private SchemaDefinitionsDeneb getDenebSchemaDefinitions(final UInt64 slot) { return SchemaDefinitionsDeneb.required(spec.atSlot(slot).getSchemaDefinitions()); } + private SchemaDefinitionsElectra getElectraSchemaDefinitions(final UInt64 slot) { + return SchemaDefinitionsElectra.required(spec.atSlot(slot).getSchemaDefinitions()); + } + private SchemaDefinitionsEip7594 getEip7594SchemaDefinitions(final UInt64 slot) { return SchemaDefinitionsEip7594.required(spec.atSlot(slot).getSchemaDefinitions()); } @@ -2580,10 +2828,18 @@ int getJustificationBitsLength() { return getConstant(SpecConfig::getJustificationBitsLength); } - private int getMaxValidatorsPerCommittee() { + private int getMaxValidatorsPerCommittee(final UInt64 slot) { + if (spec.atSlot(slot).getMilestone().isGreaterThanOrEqualTo(SpecMilestone.ELECTRA)) { + return getConstant(SpecConfig::getMaxValidatorsPerCommittee) + * getConstant(SpecConfig::getMaxCommitteesPerSlot); + } return getConstant(SpecConfig::getMaxValidatorsPerCommittee); } + private int getMaxCommitteesPerSlot() { + return getConstant(SpecConfig::getMaxCommitteesPerSlot); + } + private UInt64 getMaxEffectiveBalance() { return getConstant(SpecConfig::getMaxEffectiveBalance); } diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/RandomChainBuilderForkChoiceStrategy.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/RandomChainBuilderForkChoiceStrategy.java index 8631bb9f7a1..d66006f2afe 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/RandomChainBuilderForkChoiceStrategy.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/RandomChainBuilderForkChoiceStrategy.java @@ -137,7 +137,7 @@ public Optional isOptimistic(final Bytes32 blockRoot) { } @Override - public boolean isFullyValidated(Bytes32 blockRoot) { + public boolean isFullyValidated(final Bytes32 blockRoot) { return true; } diff --git a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/ValidatorBuilder.java b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/ValidatorBuilder.java index efa13649d28..630089c685d 100644 --- a/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/ValidatorBuilder.java +++ b/ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/ValidatorBuilder.java @@ -55,6 +55,11 @@ public ValidatorBuilder withRandomEth1WithdrawalCredentials() { return this; } + public ValidatorBuilder withRandomCompoundingWithdrawalCredentials() { + this.withdrawalCredentials = dataStructureUtil.randomCompoundingWithdrawalCredentials(); + return this; + } + public ValidatorBuilder withRandomBlsWithdrawalCredentials() { this.withdrawalCredentials = dataStructureUtil.randomBlsWithdrawalCredentials(); return this; diff --git a/ethereum/statetransition/build.gradle b/ethereum/statetransition/build.gradle index 7a2622677b8..c6b08c33fec 100644 --- a/ethereum/statetransition/build.gradle +++ b/ethereum/statetransition/build.gradle @@ -25,7 +25,7 @@ dependencies { implementation project(':storage') implementation project(':storage:api') - implementation 'org.apache.tuweni:tuweni-units' + implementation 'io.tmio:tuweni-units' implementation 'org.hyperledger.besu.internal:metrics-core' testImplementation testFixtures(project(':ethereum:spec')) diff --git a/ethereum/statetransition/src/integration-test/java/tech/pegasys/teku/statetransition/attestation/AttestationManagerIntegrationTest.java b/ethereum/statetransition/src/integration-test/java/tech/pegasys/teku/statetransition/attestation/AttestationManagerIntegrationTest.java index 23832af9dce..dddd5fc0d34 100644 --- a/ethereum/statetransition/src/integration-test/java/tech/pegasys/teku/statetransition/attestation/AttestationManagerIntegrationTest.java +++ b/ethereum/statetransition/src/integration-test/java/tech/pegasys/teku/statetransition/attestation/AttestationManagerIntegrationTest.java @@ -35,8 +35,8 @@ import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockAndState; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof; import tech.pegasys.teku.spec.datastructures.state.Fork; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; @@ -75,7 +75,7 @@ class AttestationManagerIntegrationTest { private final AggregatingAttestationPool attestationPool = new AggregatingAttestationPool( - spec, new NoOpMetricsSystem(), DEFAULT_MAXIMUM_ATTESTATION_COUNT); + spec, recentChainData, new NoOpMetricsSystem(), DEFAULT_MAXIMUM_ATTESTATION_COUNT); private final MergeTransitionBlockValidator transitionBlockValidator = new MergeTransitionBlockValidator(spec, recentChainData, ExecutionLayerChannel.NOOP); private final ForkChoice forkChoice = @@ -262,7 +262,7 @@ private ValidatableAttestation createAttestation( .chainBuilder() .sign(validatorId, signer -> signer.signAttestationData(attestationData, forkInfo)); - final AttestationSchema attestationSchema = + final AttestationSchema attestationSchema = spec.atSlot(attestationSlot).getSchemaDefinitions().getAttestationSchema(); SszBitlist aggregationBits = attestationSchema diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/EpochCachePrimer.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/EpochCachePrimer.java index c4a305c5f3e..023f873314c 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/EpochCachePrimer.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/EpochCachePrimer.java @@ -93,12 +93,9 @@ private void primeEpochStateCaches(final BeaconState state) { final UInt64 lookaheadEpoch = stateEpoch.plus(spec.getSpecConfig(stateEpoch).getMinSeedLookahead()); final UInt64 lookAheadEpochStartSlot = spec.computeStartSlotAtEpoch(lookaheadEpoch); - final UInt64 committeeCount = spec.getCommitteeCountPerSlot(state, lookaheadEpoch); UInt64.range(lookAheadEpochStartSlot, spec.computeStartSlotAtEpoch(lookaheadEpoch.plus(1))) - .forEach( - slot -> - UInt64.range(UInt64.ZERO, committeeCount) - .forEach(index -> spec.getBeaconCommittee(state, slot, index))); + // Note: calculating the committeesSize for a slot also calculates the committees + .forEach(slot -> spec.getBeaconCommitteesSize(state, slot)); } private void primeJustifiedState(final Checkpoint justifiedCheckpoint) { diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/MappedOperationPool.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/MappedOperationPool.java index fa2149d31a7..1f2c4f538eb 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/MappedOperationPool.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/MappedOperationPool.java @@ -98,7 +98,7 @@ public MappedOperationPool( validationReasonCounter = metricsSystem.createLabelledCounter( TekuMetricCategory.BEACON, - OPERATION_POOL_SIZE_VALIDATION_REASON + metricType, + OPERATION_POOL_SIZE_VALIDATION_REASON + metricType + "_total", "Total number of attempts to add an operation to the pool, broken down by validation result", "result"); @@ -109,13 +109,12 @@ public MappedOperationPool( this::updateLocalSubmissionsErrorHandler); } - private void updateLocalSubmissionsErrorHandler(Throwable throwable) { + private void updateLocalSubmissionsErrorHandler(final Throwable throwable) { LOG.debug("Failed to update " + metricType, throwable); } private void updateLocalSubmissions() { - final UInt64 staleTime = - timeProvider.getTimeInSeconds().minus(Duration.ofHours(2).getSeconds()); + final UInt64 staleTime = timeProvider.getTimeInSeconds().minus(Duration.ofHours(2).toSeconds()); final List> staleLocalOperations = operations.values().stream() .filter(OperationPoolEntry::isLocal) @@ -152,7 +151,7 @@ private void updateLocalSubmissions() { } private static InternalValidationResult rejectForDuplicatedMessage( - String metricType, final int validatorIndex) { + final String metricType, final int validatorIndex) { final String logMessage = String.format( "Cannot add to %s as validator %s is already in this pool.", @@ -264,7 +263,7 @@ public int size() { return operations.size(); } - private SafeFuture add(T item, boolean fromNetwork) { + private SafeFuture add(final T item, final boolean fromNetwork) { final int validatorIndex = item.getValidatorId(); return operationValidator .validateForGossip(item) diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/OperationPoolEntry.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/OperationPoolEntry.java index 131a50e900f..837b51f1097 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/OperationPoolEntry.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/OperationPoolEntry.java @@ -25,7 +25,7 @@ public class OperationPoolEntry private UInt64 timeSubmitted; - public OperationPoolEntry(T message, boolean isLocal, final UInt64 timeSubmitted) { + public OperationPoolEntry(final T message, final boolean isLocal, final UInt64 timeSubmitted) { this.message = message; this.isLocal = isLocal; this.timeSubmitted = timeSubmitted; @@ -48,7 +48,7 @@ public void setTimeSubmitted(final UInt64 timeSubmitted) { } @Override - public int compareTo(@NotNull OperationPoolEntry o) { + public int compareTo(final @NotNull OperationPoolEntry o) { if (isLocal && !o.isLocal) { return -1; } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/SimpleOperationPool.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/SimpleOperationPool.java index 4253eda5a3a..5193668bf06 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/SimpleOperationPool.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/SimpleOperationPool.java @@ -113,7 +113,7 @@ private SimpleOperationPool( validationReasonCounter = metricsSystem.createLabelledCounter( TekuMetricCategory.BEACON, - OPERATION_POOL_SIZE_VALIDATION_REASON + metricType, + OPERATION_POOL_SIZE_VALIDATION_REASON + metricType + "_total", "Total number of attempts to add an operation to the pool, broken down by validation result", "result"); } @@ -188,7 +188,7 @@ public Set getAll() { return Collections.unmodifiableSet(operations); } - private SafeFuture add(T item, boolean fromNetwork) { + private SafeFuture add(final T item, final boolean fromNetwork) { return operationValidator .validateForGossip(item) .thenApply( diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/AggregateAttestationBuilder.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/AggregateAttestationBuilder.java index e5d53c78282..ef1e4903530 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/AggregateAttestationBuilder.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/AggregateAttestationBuilder.java @@ -19,11 +19,12 @@ import java.util.HashSet; import java.util.Set; import tech.pegasys.teku.bls.BLS; -import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecVersion; import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; +import tech.pegasys.teku.statetransition.attestation.utils.AttestationBitsAggregator; /** * Builds an aggregate attestation, providing functions to test if an attestation can be added or is @@ -33,48 +34,49 @@ class AggregateAttestationBuilder { private final Spec spec; private final Set includedAttestations = new HashSet<>(); private final AttestationData attestationData; - private SszBitlist currentAggregateBits; + private AttestationBitsAggregator currentAggregateBits; AggregateAttestationBuilder(final Spec spec, final AttestationData attestationData) { this.spec = spec; this.attestationData = attestationData; } - public boolean canAggregate(final ValidatableAttestation candidate) { - return currentAggregateBits == null - || !currentAggregateBits.intersects(candidate.getAttestation().getAggregationBits()); - } - public boolean isFullyIncluded(final ValidatableAttestation candidate) { return currentAggregateBits != null - && currentAggregateBits.isSuperSetOf(candidate.getAttestation().getAggregationBits()); + && currentAggregateBits.isSuperSetOf(candidate.getAttestation()); } - public void aggregate(final ValidatableAttestation attestation) { - includedAttestations.add(attestation); + public boolean aggregate(final ValidatableAttestation attestation) { + if (currentAggregateBits == null) { - currentAggregateBits = attestation.getAttestation().getAggregationBits(); - } else { - currentAggregateBits = - currentAggregateBits.or(attestation.getAttestation().getAggregationBits()); + includedAttestations.add(attestation); + currentAggregateBits = AttestationBitsAggregator.of(attestation); + return true; + } + if (currentAggregateBits.aggregateWith(attestation.getAttestation())) { + includedAttestations.add(attestation); + return true; } + return false; } public ValidatableAttestation buildAggregate() { checkState(currentAggregateBits != null, "Must aggregate at least one attestation"); + final SpecVersion specVersion = spec.atSlot(attestationData.getSlot()); return ValidatableAttestation.from( spec, - spec.atSlot(attestationData.getSlot()) + specVersion .getSchemaDefinitions() .getAttestationSchema() .create( - currentAggregateBits, + currentAggregateBits.getAggregationBits(), attestationData, BLS.aggregate( includedAttestations.stream() .map(ValidatableAttestation::getAttestation) .map(Attestation::getAggregateSignature) - .toList()))); + .toList()), + currentAggregateBits::getCommitteeBits)); } public Collection getIncludedAttestations() { diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/AggregatingAttestationPool.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/AggregatingAttestationPool.java index a63e635222e..b9e658cc645 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/AggregatingAttestationPool.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/AggregatingAttestationPool.java @@ -13,6 +13,7 @@ package tech.pegasys.teku.statetransition.attestation; +import it.unimi.dsi.fastutil.ints.Int2IntMap; import java.util.Collection; import java.util.HashMap; import java.util.HashSet; @@ -41,6 +42,8 @@ import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.schemas.SchemaDefinitions; +import tech.pegasys.teku.storage.client.RecentChainData; /** * Maintains a pool of attestations. Attestations can be retrieved either for inclusion in a block @@ -80,13 +83,19 @@ public class AggregatingAttestationPool implements SlotEventsChannel { private final NavigableMap> dataHashBySlot = new TreeMap<>(); private final Spec spec; - private final AtomicInteger size = new AtomicInteger(0); + private final RecentChainData recentChainData; private final SettableGauge sizeGauge; private final int maximumAttestationCount; + private final AtomicInteger size = new AtomicInteger(0); + public AggregatingAttestationPool( - final Spec spec, final MetricsSystem metricsSystem, final int maximumAttestationCount) { + final Spec spec, + final RecentChainData recentChainData, + final MetricsSystem metricsSystem, + final int maximumAttestationCount) { this.spec = spec; + this.recentChainData = recentChainData; this.sizeGauge = SettableGauge.create( metricsSystem, @@ -97,12 +106,17 @@ public AggregatingAttestationPool( } public synchronized void add(final ValidatableAttestation attestation) { - final AttestationData attestationData = attestation.getAttestation().getData(); - final boolean add = getOrCreateAttestationGroup(attestationData).add(attestation); - if (add) { - updateSize(1); - } - // Always keep the latest slot attestations so we don't discard everything + final Optional committeesSize = + attestation.getCommitteesSize().or(() -> getCommitteesSize(attestation.getAttestation())); + getOrCreateAttestationGroup(attestation.getAttestation(), committeesSize) + .ifPresent( + attestationGroup -> { + final boolean added = attestationGroup.add(attestation); + if (added) { + updateSize(1); + } + }); + // Always keep the latest slot attestations, so we don't discard everything int currentSize = getSize(); while (dataHashBySlot.size() > 1 && currentSize > maximumAttestationCount) { LOG.trace("Attestation cache at {} exceeds {}, ", currentSize, maximumAttestationCount); @@ -112,14 +126,48 @@ public synchronized void add(final ValidatableAttestation attestation) { } } - private MatchingDataAttestationGroup getOrCreateAttestationGroup( - final AttestationData attestationData) { + private Optional getCommitteesSize(final Attestation attestation) { + if (attestation.requiresCommitteeBits()) { + return getCommitteesSizeUsingTheState(attestation.getData()); + } + return Optional.empty(); + } + + /** + * @param committeesSize Required for aggregating attestations as per EIP-7549 + */ + private Optional getOrCreateAttestationGroup( + final Attestation attestation, final Optional committeesSize) { + final AttestationData attestationData = attestation.getData(); + // if an attestation has committee bits, committees size should have been computed. If this is + // not the case, we should ignore this attestation and not add it to the pool + if (attestation.requiresCommitteeBits() && committeesSize.isEmpty()) { + LOG.warn( + "Committees size couldn't be retrieved for attestation at slot {}, block root {} and target root {}. Will NOT add this attestation to the pool.", + attestationData.getSlot(), + attestationData.getBeaconBlockRoot(), + attestationData.getTarget().getRoot()); + return Optional.empty(); + } dataHashBySlot .computeIfAbsent(attestationData.getSlot(), slot -> new HashSet<>()) .add(attestationData.hashTreeRoot()); - return attestationGroupByDataHash.computeIfAbsent( - attestationData.hashTreeRoot(), - key -> new MatchingDataAttestationGroup(spec, attestationData)); + final MatchingDataAttestationGroup attestationGroup = + attestationGroupByDataHash.computeIfAbsent( + attestationData.hashTreeRoot(), + key -> new MatchingDataAttestationGroup(spec, attestationData, committeesSize)); + return Optional.of(attestationGroup); + } + + // We only have the committees size already available via attestations received in the gossip + // flow and have been successfully validated, so querying the state is required for other cases + private Optional getCommitteesSizeUsingTheState( + final AttestationData attestationData) { + return recentChainData + .getStore() + .getBlockStateIfAvailable(attestationData.getTarget().getRoot()) + .map(state -> spec.getBeaconCommitteesSize(state, attestationData.getSlot())); } @Override @@ -157,10 +205,13 @@ public synchronized void onAttestationsIncludedInBlock( } private void onAttestationIncludedInBlock(final UInt64 slot, final Attestation attestation) { - final AttestationData attestationData = attestation.getData(); - final MatchingDataAttestationGroup attestations = getOrCreateAttestationGroup(attestationData); - final int numRemoved = attestations.onAttestationIncludedInBlock(slot, attestation); - updateSize(-numRemoved); + getOrCreateAttestationGroup(attestation, getCommitteesSize(attestation)) + .ifPresent( + attestationGroup -> { + final int numRemoved = + attestationGroup.onAttestationIncludedInBlock(slot, attestation); + updateSize(-numRemoved); + }); } private void updateSize(final int delta) { @@ -177,11 +228,14 @@ public synchronized SszList getAttestationsForBlock( final UInt64 currentEpoch = spec.getCurrentEpoch(stateAtBlockSlot); final int previousEpochLimit = spec.getPreviousEpochAttestationCapacity(stateAtBlockSlot); + final SchemaDefinitions schemaDefinitions = + spec.atSlot(stateAtBlockSlot.getSlot()).getSchemaDefinitions(); + final SszListSchema attestationsSchema = - spec.atSlot(stateAtBlockSlot.getSlot()) - .getSchemaDefinitions() - .getBeaconBlockBodySchema() - .getAttestationsSchema(); + schemaDefinitions.getBeaconBlockBodySchema().getAttestationsSchema(); + + final boolean blockRequiresAttestationsWithCommitteeBits = + schemaDefinitions.getAttestationSchema().requiresCommitteeBits(); final AtomicInteger prevEpochCount = new AtomicInteger(0); return dataHashBySlot @@ -196,11 +250,15 @@ public synchronized SszList getAttestationsForBlock( .filter(group -> isValid(stateAtBlockSlot, group.getAttestationData())) .filter(forkChecker::areAttestationsFromCorrectFork) .flatMap(MatchingDataAttestationGroup::stream) - .limit(attestationsSchema.getMaxLength()) .map(ValidatableAttestation::getAttestation) .filter( - att -> { - if (spec.computeEpochAtSlot(att.getData().getSlot()).isLessThan(currentEpoch)) { + attestation -> + attestation.requiresCommitteeBits() == blockRequiresAttestationsWithCommitteeBits) + .limit(attestationsSchema.getMaxLength()) + .filter( + attestation -> { + if (spec.computeEpochAtSlot(attestation.getData().getSlot()) + .isLessThan(currentEpoch)) { final int currentCount = prevEpochCount.getAndIncrement(); return currentCount < previousEpochLimit; } @@ -211,14 +269,15 @@ public synchronized SszList getAttestationsForBlock( public synchronized List getAttestations( final Optional maybeSlot, final Optional maybeCommitteeIndex) { + final Predicate>> filterForSlot = (entry) -> maybeSlot.map(slot -> entry.getKey().equals(slot)).orElse(true); - final Predicate filterForCommitteeIndex = - (group) -> - maybeCommitteeIndex - .map(index -> group.getAttestationData().getIndex().equals(index)) - .orElse(true); + final UInt64 slot = maybeSlot.orElse(recentChainData.getCurrentSlot().orElse(UInt64.ZERO)); + final SchemaDefinitions schemaDefinitions = spec.atSlot(slot).getSchemaDefinitions(); + + final boolean requiresCommitteeBits = + schemaDefinitions.getAttestationSchema().requiresCommitteeBits(); return dataHashBySlot.descendingMap().entrySet().stream() .filter(filterForSlot) @@ -226,8 +285,9 @@ public synchronized List getAttestations( .flatMap(Collection::stream) .map(attestationGroupByDataHash::get) .filter(Objects::nonNull) - .filter(filterForCommitteeIndex) - .flatMap(MatchingDataAttestationGroup::stream) + .flatMap( + matchingDataAttestationGroup -> + matchingDataAttestationGroup.stream(maybeCommitteeIndex, requiresCommitteeBits)) .map(ValidatableAttestation::getAttestation) .toList(); } @@ -238,9 +298,9 @@ private boolean isValid( } public synchronized Optional createAggregateFor( - final Bytes32 attestationHashTreeRoot) { + final Bytes32 attestationHashTreeRoot, final Optional committeeIndex) { return Optional.ofNullable(attestationGroupByDataHash.get(attestationHashTreeRoot)) - .flatMap(attestations -> attestations.stream().findFirst()); + .flatMap(attestations -> attestations.stream(committeeIndex).findFirst()); } public synchronized void onReorg(final UInt64 commonAncestorSlot) { diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/AttestationForkChecker.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/AttestationForkChecker.java index fb421a7fca1..5dd28b92cee 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/AttestationForkChecker.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/AttestationForkChecker.java @@ -25,7 +25,7 @@ public class AttestationForkChecker { private final Set validCommitteeShufflingSeeds = new HashSet<>(); - public AttestationForkChecker(final Spec spec, BeaconState state) { + public AttestationForkChecker(final Spec spec, final BeaconState state) { UInt64 epoch = spec.computeEpochAtSlot(state.getSlot()); Bytes32 currentEpochSeed = spec.getSeed(state, epoch, Domain.BEACON_ATTESTER); diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/AttestationManager.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/AttestationManager.java index 736d7ae3e09..950311468fc 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/AttestationManager.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/AttestationManager.java @@ -102,20 +102,20 @@ public static AttestationManager create( activeValidatorChannel); } - public void subscribeToAllValidAttestations(ProcessedAttestationListener listener) { + public void subscribeToAllValidAttestations(final ProcessedAttestationListener listener) { allValidAttestationsSubscribers.subscribe(listener); } - private void notifyAllValidAttestationsSubscribers(ValidatableAttestation attestation) { + private void notifyAllValidAttestationsSubscribers(final ValidatableAttestation attestation) { allValidAttestationsSubscribers.forEach(s -> s.accept(attestation)); } public void subscribeToAttestationsToSend( - ProcessedAttestationListener attestationsToSendListener) { + final ProcessedAttestationListener attestationsToSendListener) { attestationsToSendSubscribers.subscribe(attestationsToSendListener); } - private void validateForGossipAndNotifySendSubscribers(ValidatableAttestation attestation) { + private void validateForGossipAndNotifySendSubscribers(final ValidatableAttestation attestation) { if (attestation.isAggregate() && !attestation.isAcceptedAsGossip()) { // We know the Attestation is valid, but need to validate the SignedAggregateAndProof wrapper aggregateValidator @@ -265,7 +265,7 @@ public SafeFuture onAttestation( }); } - private void sendToSubscribersIfProducedLocally(ValidatableAttestation attestation) { + private void sendToSubscribersIfProducedLocally(final ValidatableAttestation attestation) { if (!attestation.isProducedLocally()) { return; } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/MatchingDataAttestationGroup.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/MatchingDataAttestationGroup.java index 2424e42ce40..27303e656bd 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/MatchingDataAttestationGroup.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/MatchingDataAttestationGroup.java @@ -13,6 +13,7 @@ package tech.pegasys.teku.statetransition.attestation; +import it.unimi.dsi.fastutil.ints.Int2IntMap; import java.util.Collection; import java.util.Comparator; import java.util.HashSet; @@ -20,16 +21,19 @@ import java.util.NavigableMap; import java.util.Optional; import java.util.Set; +import java.util.Spliterator; +import java.util.Spliterators; import java.util.TreeMap; import java.util.stream.Stream; import java.util.stream.StreamSupport; import org.apache.tuweni.bytes.Bytes32; -import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; +import tech.pegasys.teku.statetransition.attestation.utils.AttestationBitsAggregator; /** * Maintains an aggregated collection of attestations which all share the same {@link @@ -43,7 +47,7 @@ *

Note that the resulting aggregate will be invalid if attestations with different * AttestationData are added. */ -class MatchingDataAttestationGroup implements Iterable { +public class MatchingDataAttestationGroup implements Iterable { private final NavigableMap> attestationsByValidatorCount = new TreeMap<>(Comparator.reverseOrder()); // Most validators first @@ -51,35 +55,40 @@ class MatchingDataAttestationGroup implements Iterable { private final Spec spec; private Optional committeeShufflingSeed = Optional.empty(); private final AttestationData attestationData; + private final Optional committeesSize; /** * Tracks which validators were included in attestations at a given slot on the canonical chain. * *

When a reorg occurs we can accurately compute the set of included validators at the common * ancestor by removing blocks in slots after the ancestor then recalculating {@link - * #includedValidators}. Otherwise we might remove a validator from the included list because it + * #includedValidators}. Otherwise, we might remove a validator from the included list because it * was in a block moved off the canonical chain even though that validator was also included in an * earlier block which is still on the canonical chain. * *

Pruning isn't required for this map because the entire attestation group is dropped by * {@link AggregatingAttestationPool} once it is too old to be included in blocks (32 slots). */ - private final NavigableMap includedValidatorsBySlot = new TreeMap<>(); + private final NavigableMap includedValidatorsBySlot = + new TreeMap<>(); /** Precalculated combined list of included validators across all blocks. */ - private SszBitlist includedValidators; + private AttestationBitsAggregator includedValidators; - public MatchingDataAttestationGroup(final Spec spec, final AttestationData attestationData) { + public MatchingDataAttestationGroup( + final Spec spec, + final AttestationData attestationData, + final Optional committeesSize) { this.spec = spec; this.attestationData = attestationData; - this.includedValidators = createEmptyAggregationBits(); + this.committeesSize = committeesSize; + this.includedValidators = createEmptyAttestationBits(); } - private SszBitlist createEmptyAggregationBits() { - return spec.atSlot(attestationData.getSlot()) - .getSchemaDefinitions() - .getAttestationSchema() - .createEmptyAggregationBits(); + private AttestationBitsAggregator createEmptyAttestationBits() { + return AttestationBitsAggregator.fromEmptyFromAttestationSchema( + spec.atSlot(attestationData.getSlot()).getSchemaDefinitions().getAttestationSchema(), + committeesSize); } public AttestationData getAttestationData() { @@ -94,7 +103,7 @@ public AttestationData getAttestationData() { * @return True if the attestation was added, false otherwise */ public boolean add(final ValidatableAttestation attestation) { - if (includedValidators.isSuperSetOf(attestation.getAttestation().getAggregationBits())) { + if (includedValidators.isSuperSetOf(attestation.getAttestation())) { // All attestation bits have already been included on chain return false; } @@ -112,6 +121,9 @@ public boolean add(final ValidatableAttestation attestation) { * Iterates through the aggregation of attestations in this group. The iterator attempts to create * the minimum number of attestations that include all attestations in the group. * + *

committeeIndex is an optional parameter that enables aggregation over a specified committee + * (applies to Electra only) + * *

While it is guaranteed that every validator from an attestation in this group is included in * an aggregate produced by this iterator, there is no guarantee that the added attestation * instances themselves will be included. @@ -120,11 +132,31 @@ public boolean add(final ValidatableAttestation attestation) { */ @Override public Iterator iterator() { - return new AggregatingIterator(); + return new AggregatingIterator(Optional.empty()); + } + + public Iterator iterator(final Optional committeeIndex) { + return new AggregatingIterator(committeeIndex); } public Stream stream() { - return StreamSupport.stream(spliterator(), false); + return StreamSupport.stream(spliterator(Optional.empty()), false); + } + + public Stream stream(final Optional committeeIndex) { + return StreamSupport.stream(spliterator(committeeIndex), false); + } + + public Stream stream( + final Optional committeeIndex, final boolean requiresCommitteeBits) { + if (noMatchingAttestations(committeeIndex, requiresCommitteeBits)) { + return Stream.empty(); + } + return StreamSupport.stream(spliterator(committeeIndex), false); + } + + public Spliterator spliterator(final Optional committeeIndex) { + return Spliterators.spliteratorUnknownSize(iterator(committeeIndex), 0); } /** @@ -151,13 +183,21 @@ public int size() { public int onAttestationIncludedInBlock(final UInt64 slot, final Attestation attestation) { // Record validators in attestation as seen in this slot // Important to do even if the attestation is redundant so we handle re-orgs correctly - includedValidatorsBySlot.merge(slot, attestation.getAggregationBits(), SszBitlist::or); + includedValidatorsBySlot.compute( + slot, + (__, attestationBitsCalculator) -> { + if (attestationBitsCalculator == null) { + return AttestationBitsAggregator.of(attestation, committeesSize); + } + attestationBitsCalculator.or(attestation); + return attestationBitsCalculator; + }); - if (includedValidators.isSuperSetOf(attestation.getAggregationBits())) { + if (includedValidators.isSuperSetOf(attestation)) { // We've already seen and filtered out all of these bits, nothing to do return 0; } - includedValidators = includedValidators.or(attestation.getAggregationBits()); + includedValidators.or(attestation); final Collection> attestationSets = attestationsByValidatorCount.values(); @@ -167,7 +207,7 @@ public int onAttestationIncludedInBlock(final UInt64 slot, final Attestation att for (Iterator iterator = candidates.iterator(); iterator.hasNext(); ) { ValidatableAttestation candidate = iterator.next(); - if (includedValidators.isSuperSetOf(candidate.getAttestation().getAggregationBits())) { + if (includedValidators.isSuperSetOf(candidate.getAttestation())) { iterator.remove(); numRemoved++; } @@ -180,7 +220,7 @@ public int onAttestationIncludedInBlock(final UInt64 slot, final Attestation att } public void onReorg(final UInt64 commonAncestorSlot) { - final NavigableMap removedSlots = + final NavigableMap removedSlots = includedValidatorsBySlot.tailMap(commonAncestorSlot, false); if (removedSlots.isEmpty()) { // No relevant attestations in affected slots, so nothing to do. @@ -189,47 +229,82 @@ public void onReorg(final UInt64 commonAncestorSlot) { removedSlots.clear(); // Recalculate totalSeenAggregationBits as validators may have been seen in multiple blocks so // can't do a simple remove - includedValidators = - includedValidatorsBySlot.values().stream() - .reduce(createEmptyAggregationBits(), SszBitlist::or); + includedValidators = createEmptyAttestationBits(); + includedValidatorsBySlot.values().forEach(includedValidators::or); } public boolean matchesCommitteeShufflingSeed(final Set validSeeds) { return committeeShufflingSeed.map(validSeeds::contains).orElse(false); } + private boolean noMatchingAttestations( + final Optional committeeIndex, final boolean requiresCommitteeBits) { + return requiresCommitteeBits != includedValidators.requiresCommitteeBits() + || noMatchingPreElectraAttestations(committeeIndex); + } + + private boolean noMatchingPreElectraAttestations(final Optional committeeIndex) { + return committeeIndex.isPresent() + && !includedValidators.requiresCommitteeBits() + && !attestationData.getIndex().equals(committeeIndex.get()); + } + private class AggregatingIterator implements Iterator { - private SszBitlist includedValidators = MatchingDataAttestationGroup.this.includedValidators; + + private final Optional maybeCommitteeIndex; + private final AttestationBitsAggregator includedValidators; + + private Iterator remainingAttestations = getRemainingAttestations(); + + private AggregatingIterator(final Optional committeeIndex) { + this.maybeCommitteeIndex = committeeIndex; + includedValidators = MatchingDataAttestationGroup.this.includedValidators.copy(); + } @Override public boolean hasNext() { - return streamRemainingAttestations().findAny().isPresent(); + if (!remainingAttestations.hasNext()) { + remainingAttestations = getRemainingAttestations(); + } + return remainingAttestations.hasNext(); } @Override public ValidatableAttestation next() { final AggregateAttestationBuilder builder = new AggregateAttestationBuilder(spec, attestationData); - streamRemainingAttestations() - .forEach( - candidate -> { - final SszBitlist candidateAggregationBits = - candidate.getAttestation().getAggregationBits(); - if (builder.canAggregate(candidate)) { - builder.aggregate(candidate); - includedValidators = includedValidators.or(candidateAggregationBits); - } - }); + remainingAttestations.forEachRemaining( + candidate -> { + if (builder.aggregate(candidate)) { + includedValidators.or(candidate.getAttestation()); + } + }); return builder.buildAggregate(); } - public Stream streamRemainingAttestations() { + public Iterator getRemainingAttestations() { return attestationsByValidatorCount.values().stream() .flatMap(Set::stream) - .filter( - candidate -> - !includedValidators.isSuperSetOf( - candidate.getAttestation().getAggregationBits())); + .filter(this::maybeFilterOnCommitteeIndex) + .filter(candidate -> !includedValidators.isSuperSetOf(candidate.getAttestation())) + .iterator(); + } + + /* + If we have attestations with committeeBits (Electra) then, if maybeCommitteeIndex is specified, we will consider attestation related to that committee only + */ + private boolean maybeFilterOnCommitteeIndex(final ValidatableAttestation candidate) { + final Optional maybeCommitteeBits = + candidate.getAttestation().getCommitteeBits(); + if (maybeCommitteeBits.isEmpty() || maybeCommitteeIndex.isEmpty()) { + return true; + } + + final SszBitvector committeeBits = maybeCommitteeBits.get(); + if (committeeBits.getBitCount() != 1) { + return false; + } + return committeeBits.isSet(maybeCommitteeIndex.get().intValue()); } } } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/utils/AttestationBitsAggregator.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/utils/AttestationBitsAggregator.java new file mode 100644 index 00000000000..7dacd61a5fe --- /dev/null +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/utils/AttestationBitsAggregator.java @@ -0,0 +1,89 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.statetransition.attestation.utils; + +import it.unimi.dsi.fastutil.ints.Int2IntMap; +import java.util.Optional; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; +import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; + +public interface AttestationBitsAggregator { + + static AttestationBitsAggregator fromEmptyFromAttestationSchema( + final AttestationSchema attestationSchema, final Optional committeesSize) { + return attestationSchema + .toVersionElectra() + .map( + schema -> + AttestationBitsAggregatorElectra.fromAttestationSchema( + schema, committeesSize.orElseThrow())) + .orElseGet(() -> AttestationBitsAggregatorPhase0.fromAttestationSchema(attestationSchema)); + } + + static AttestationBitsAggregator of(final ValidatableAttestation attestation) { + return attestation + .getAttestation() + .getCommitteeBits() + .map( + committeeBits -> + (AttestationBitsAggregator) + new AttestationBitsAggregatorElectra( + attestation.getAttestation().getAggregationBits(), + committeeBits, + attestation.getCommitteesSize().orElseThrow())) + .orElseGet( + () -> + new AttestationBitsAggregatorPhase0( + attestation.getAttestation().getAggregationBits())); + } + + static AttestationBitsAggregator of( + final Attestation attestation, final Optional committeesSize) { + return attestation + .getCommitteeBits() + .map( + committeeBits -> + new AttestationBitsAggregatorElectra( + attestation.getAggregationBits(), committeeBits, committeesSize.orElseThrow())) + .orElseGet(() -> new AttestationBitsAggregatorPhase0(attestation.getAggregationBits())); + } + + void or(AttestationBitsAggregator other); + + boolean aggregateWith(Attestation other); + + void or(Attestation other); + + boolean isSuperSetOf(Attestation other); + + SszBitlist getAggregationBits(); + + SszBitvector getCommitteeBits(); + + Int2IntMap getCommitteesSize(); + + boolean requiresCommitteeBits(); + + /** Creates an independent copy of this instance */ + default AttestationBitsAggregator copy() { + if (requiresCommitteeBits()) { + return new AttestationBitsAggregatorElectra( + getAggregationBits(), getCommitteeBits(), getCommitteesSize()); + } + return new AttestationBitsAggregatorPhase0(getAggregationBits()); + } +} diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/utils/AttestationBitsAggregatorElectra.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/utils/AttestationBitsAggregatorElectra.java new file mode 100644 index 00000000000..4242922ed8a --- /dev/null +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/utils/AttestationBitsAggregatorElectra.java @@ -0,0 +1,255 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.statetransition.attestation.utils; + +import com.google.common.base.MoreObjects; +import it.unimi.dsi.fastutil.ints.Int2IntMap; +import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap; +import java.util.BitSet; +import java.util.stream.IntStream; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; + +class AttestationBitsAggregatorElectra implements AttestationBitsAggregator { + private SszBitlist aggregationBits; + private SszBitvector committeeBits; + private Int2IntMap committeeBitsStartingPositions; + private final Int2IntMap committeesSize; + + AttestationBitsAggregatorElectra( + final SszBitlist aggregationBits, + final SszBitvector committeeBits, + final Int2IntMap committeesSize) { + this.aggregationBits = aggregationBits; + this.committeeBits = committeeBits; + this.committeesSize = committeesSize; + this.committeeBitsStartingPositions = calculateCommitteeStartingPositions(committeeBits); + } + + static AttestationBitsAggregator fromAttestationSchema( + final AttestationSchema attestationSchema, final Int2IntMap committeesSize) { + return new AttestationBitsAggregatorElectra( + attestationSchema.createEmptyAggregationBits(), + attestationSchema.createEmptyCommitteeBits().orElseThrow(), + committeesSize); + } + + @Override + public void or(final AttestationBitsAggregator other) { + or(other.getCommitteeBits(), other.getAggregationBits(), false); + } + + @Override + public boolean aggregateWith(final Attestation other) { + return or(other.getCommitteeBitsRequired(), other.getAggregationBits(), true); + } + + @Override + public void or(final Attestation other) { + or(other.getCommitteeBitsRequired(), other.getAggregationBits(), false); + } + + private static class CannotAggregateException extends RuntimeException {} + + private boolean or( + final SszBitvector otherCommitteeBits, + final SszBitlist otherAggregatedBits, + final boolean isAggregation) { + + final SszBitvector combinedCommitteeBits = committeeBits.or(otherCommitteeBits); + + final Int2IntMap otherCommitteeBitsStartingPositions = + calculateCommitteeStartingPositions(otherCommitteeBits); + final Int2IntMap aggregatedCommitteeBitsStartingPositions = + calculateCommitteeStartingPositions(combinedCommitteeBits); + + // create an aggregation bit big as last boundary for last committee bit + final int lastCommitteeIndex = combinedCommitteeBits.getLastSetBitIndex(); + final int lastCommitteeStartingPosition = + aggregatedCommitteeBitsStartingPositions.get(lastCommitteeIndex); + final int combinedAggregationBitsSize = + lastCommitteeStartingPosition + committeesSize.get(lastCommitteeIndex); + + final BitSet combinedAggregationIndices = new BitSet(combinedAggregationBitsSize); + + // let's go over all aggregated committees to calculate indices for the combined aggregation + // bits + try { + combinedCommitteeBits + .streamAllSetBits() + .forEach( + committeeIndex -> { + int committeeSize = committeesSize.get(committeeIndex); + int destinationStart = aggregatedCommitteeBitsStartingPositions.get(committeeIndex); + + SszBitlist source1 = null, maybeSource2 = null; + int source1StartingPosition = 0, source2StartingPosition = 0; + + if (committeeBitsStartingPositions.containsKey(committeeIndex)) { + source1 = aggregationBits; + source1StartingPosition = committeeBitsStartingPositions.get(committeeIndex); + } + if (otherCommitteeBitsStartingPositions.containsKey(committeeIndex)) { + if (source1 != null) { + maybeSource2 = otherAggregatedBits; + source2StartingPosition = + otherCommitteeBitsStartingPositions.get(committeeIndex); + } else { + source1 = otherAggregatedBits; + source1StartingPosition = + otherCommitteeBitsStartingPositions.get(committeeIndex); + } + } + + // Now that we know: + // 1. which aggregationBits (this or other or both) will contribute to the result + // 2. the offset of the committee for each contributing aggregation bits + // We can go over the committee and calculate the combined aggregate bits + for (int positionInCommittee = 0; + positionInCommittee < committeeSize; + positionInCommittee++) { + if (orSingleBit( + positionInCommittee, + source1, + source1StartingPosition, + maybeSource2, + source2StartingPosition, + isAggregation)) { + combinedAggregationIndices.set(destinationStart + positionInCommittee); + } + } + }); + } catch (final CannotAggregateException __) { + return false; + } + + committeeBits = combinedCommitteeBits; + aggregationBits = + aggregationBits + .getSchema() + .wrapBitSet(combinedAggregationBitsSize, combinedAggregationIndices); + committeeBitsStartingPositions = aggregatedCommitteeBitsStartingPositions; + + return true; + } + + private boolean orSingleBit( + final int positionInCommittee, + final SszBitlist source1, + final int source1StartingPosition, + final SszBitlist maybeSource2, + final int source2StartingPosition, + final boolean isAggregation) { + + final boolean source1Bit = source1.getBit(source1StartingPosition + positionInCommittee); + + if (maybeSource2 == null) { + return source1Bit; + } + + final boolean source2Bit = maybeSource2.getBit(source2StartingPosition + positionInCommittee); + + if (isAggregation && source1Bit && source2Bit) { + throw new CannotAggregateException(); + } + + return source1Bit || source2Bit; + } + + private Int2IntMap calculateCommitteeStartingPositions(final SszBitvector committeeBits) { + final Int2IntMap committeeBitsStartingPositions = new Int2IntOpenHashMap(); + final int[] currentOffset = {0}; + committeeBits + .streamAllSetBits() + .forEach( + index -> { + committeeBitsStartingPositions.put(index, currentOffset[0]); + currentOffset[0] += committeesSize.get(index); + }); + + return committeeBitsStartingPositions; + } + + @Override + public boolean isSuperSetOf(final Attestation other) { + if (!committeeBits.isSuperSetOf(other.getCommitteeBitsRequired())) { + return false; + } + + if (committeeBits.getBitCount() == other.getCommitteeBitsRequired().getBitCount()) { + // this committeeBits is a superset of the other, and bit count is the same, so they are the + // same set and we can directly compare aggregation bits. + return aggregationBits.isSuperSetOf(other.getAggregationBits()); + } + + final SszBitvector otherCommitteeBits = other.getCommitteeBitsRequired(); + + final Int2IntMap otherCommitteeBitsStartingPositions = + calculateCommitteeStartingPositions(otherCommitteeBits); + + final SszBitvector commonCommittees = committeeBits.and(otherCommitteeBits); + + return commonCommittees + .streamAllSetBits() + .mapToObj( + committeeIndex -> { + int committeeSize = committeesSize.get(committeeIndex); + + final int startingPosition = committeeBitsStartingPositions.get(committeeIndex); + final int otherStartingPosition = + otherCommitteeBitsStartingPositions.get(committeeIndex); + + return IntStream.range(0, committeeSize) + .anyMatch( + positionInCommittee -> + other + .getAggregationBits() + .getBit(otherStartingPosition + positionInCommittee) + && !aggregationBits.getBit(startingPosition + positionInCommittee)); + }) + .noneMatch(aBitFoundInOtherButNotInThis -> aBitFoundInOtherButNotInThis); + } + + @Override + public SszBitlist getAggregationBits() { + return aggregationBits; + } + + @Override + public SszBitvector getCommitteeBits() { + return committeeBits; + } + + @Override + public Int2IntMap getCommitteesSize() { + return committeesSize; + } + + @Override + public boolean requiresCommitteeBits() { + return true; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(this) + .add("aggregationBits", aggregationBits) + .add("committeeBits", committeeBits) + .add("committeesSize", committeesSize) + .add("committeeBitsStartingPositions", committeeBitsStartingPositions) + .toString(); + } +} diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/utils/AttestationBitsAggregatorPhase0.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/utils/AttestationBitsAggregatorPhase0.java new file mode 100644 index 00000000000..b6ddecbde83 --- /dev/null +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/attestation/utils/AttestationBitsAggregatorPhase0.java @@ -0,0 +1,87 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.statetransition.attestation.utils; + +import com.google.common.base.MoreObjects; +import it.unimi.dsi.fastutil.ints.Int2IntMap; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; + +class AttestationBitsAggregatorPhase0 implements AttestationBitsAggregator { + private SszBitlist aggregationBits; + + AttestationBitsAggregatorPhase0(final SszBitlist aggregationBits) { + this.aggregationBits = aggregationBits; + } + + static AttestationBitsAggregator fromAttestationSchema( + final AttestationSchema attestationSchema) { + return new AttestationBitsAggregatorPhase0(attestationSchema.createEmptyAggregationBits()); + } + + @Override + public void or(final AttestationBitsAggregator other) { + aggregationBits = aggregationBits.or(other.getAggregationBits()); + } + + @Override + public boolean aggregateWith(final Attestation other) { + return aggregateWith(other.getAggregationBits()); + } + + private boolean aggregateWith(final SszBitlist otherAggregationBits) { + if (aggregationBits.intersects(otherAggregationBits)) { + return false; + } + aggregationBits = aggregationBits.or(otherAggregationBits); + return true; + } + + @Override + public void or(final Attestation other) { + aggregationBits = aggregationBits.or(other.getAggregationBits()); + } + + @Override + public boolean isSuperSetOf(final Attestation other) { + return aggregationBits.isSuperSetOf(other.getAggregationBits()); + } + + @Override + public SszBitlist getAggregationBits() { + return aggregationBits; + } + + @Override + public SszBitvector getCommitteeBits() { + throw new IllegalStateException("Committee bits not available in phase0"); + } + + @Override + public Int2IntMap getCommitteesSize() { + throw new IllegalStateException("Committee sizes not available in phase0"); + } + + @Override + public boolean requiresCommitteeBits() { + return false; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(this).add("aggregationBits", aggregationBits).toString(); + } +} diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/blobs/BlobSidecarManager.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/blobs/BlobSidecarManager.java index 28acadd8854..4ca78296b9c 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/blobs/BlobSidecarManager.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/blobs/BlobSidecarManager.java @@ -69,6 +69,9 @@ SafeFuture validateAndPrepareForBlockImport( boolean isAvailabilityRequiredAtSlot(UInt64 slot); + @Override + AvailabilityChecker createAvailabilityChecker(SignedBeaconBlock block); + DataAndValidationResult createAvailabilityCheckerAndValidateImmediately( SignedBeaconBlock block, List blobSidecars); @@ -78,6 +81,8 @@ interface ReceivedBlobSidecarListener { enum RemoteOrigin { RPC, - GOSSIP + GOSSIP, + LOCAL_EL, + LOCAL_PROPOSAL } } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/blobs/BlobSidecarManagerImpl.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/blobs/BlobSidecarManagerImpl.java index 5d0a141e7c5..1ab8e97f746 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/blobs/BlobSidecarManagerImpl.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/blobs/BlobSidecarManagerImpl.java @@ -141,7 +141,7 @@ public DataAndValidationResult createAvailabilityCheckerAndValidate return DataAndValidationResult.notRequired(); } - if (spec.atSlot(block.getSlot()).getMilestone().isGreaterThanOrEqualTo(SpecMilestone.EIP7594)) { + if (spec.atSlot(block.getSlot()).getMilestone().isGreaterThanOrEqualTo(SpecMilestone.ELECTRA)) { throw new RuntimeException( String.format("PeerDAS block %s shouldn't be verified in BlobSidecarManager", block)); } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/blobs/BlockBlobSidecarsTracker.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/blobs/BlockBlobSidecarsTracker.java index b762dc83800..721211524f3 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/blobs/BlockBlobSidecarsTracker.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/blobs/BlockBlobSidecarsTracker.java @@ -36,14 +36,14 @@ import tech.pegasys.teku.spec.datastructures.blocks.SlotAndBlockRoot; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.deneb.BeaconBlockBodyDeneb; import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.BlobIdentifier; -import tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel; import tech.pegasys.teku.statetransition.block.BlockImportChannel; public class BlockBlobSidecarsTracker { private static final Logger LOG = LogManager.getLogger(); private static final UInt64 CREATION_TIMING_IDX = UInt64.MAX_VALUE; private static final UInt64 BLOCK_ARRIVAL_TIMING_IDX = CREATION_TIMING_IDX.decrement(); - private static final UInt64 FETCH_TIMING_IDX = BLOCK_ARRIVAL_TIMING_IDX.decrement(); + private static final UInt64 RPC_FETCH_TIMING_IDX = BLOCK_ARRIVAL_TIMING_IDX.decrement(); + private static final UInt64 LOCAL_EL_FETCH_TIMING_IDX = RPC_FETCH_TIMING_IDX.decrement(); private final SlotAndBlockRoot slotAndBlockRoot; private final UInt64 maxBlobsPerBlock; @@ -56,7 +56,8 @@ public class BlockBlobSidecarsTracker { private final NavigableMap blobSidecars = new ConcurrentSkipListMap<>(); private final SafeFuture blobSidecarsComplete = new SafeFuture<>(); - private volatile boolean fetchTriggered = false; + private volatile boolean rpcFetchTriggered = false; + private volatile boolean localElFetchTriggered = false; private final Optional> maybeDebugTimings; @@ -203,8 +204,7 @@ public void enableBlockImportOnCompletion(final BlockImportChannel blockImportCh .thenCompose( __ -> { LOG.debug("Tracker completed: importing block {}", slotAndBlockRoot::toLogString); - return blockImportChannel.importBlock( - getBlock().orElseThrow(), BroadcastValidationLevel.NOT_REQUIRED); + return blockImportChannel.importBlock(getBlock().orElseThrow()); }) .finish( () -> @@ -247,14 +247,24 @@ public boolean isCompleted() { return blobSidecarsComplete.isDone(); } - public boolean isFetchTriggered() { - return fetchTriggered; + public boolean isRpcFetchTriggered() { + return rpcFetchTriggered; } - public void setFetchTriggered() { - this.fetchTriggered = true; + public void setRpcFetchTriggered() { + this.rpcFetchTriggered = true; maybeDebugTimings.ifPresent( - debugTimings -> debugTimings.put(FETCH_TIMING_IDX, System.currentTimeMillis())); + debugTimings -> debugTimings.put(RPC_FETCH_TIMING_IDX, System.currentTimeMillis())); + } + + public boolean isLocalElFetchTriggered() { + return localElFetchTriggered; + } + + public void setLocalElFetchTriggered() { + this.localElFetchTriggered = true; + maybeDebugTimings.ifPresent( + debugTimings -> debugTimings.put(LOCAL_EL_FETCH_TIMING_IDX, System.currentTimeMillis())); } private boolean areBlobsComplete() { @@ -305,13 +315,22 @@ private void printDebugTimings(final Map debugTimings) { .append(debugTimings.getOrDefault(BLOCK_ARRIVAL_TIMING_IDX, 0L) - creationTime) .append("ms - "); - if (debugTimings.containsKey(FETCH_TIMING_IDX)) { + if (debugTimings.containsKey(LOCAL_EL_FETCH_TIMING_IDX)) { + timingsReport + .append("Local EL fetch delay ") + .append(debugTimings.get(LOCAL_EL_FETCH_TIMING_IDX) - creationTime) + .append("ms - "); + } else { + timingsReport.append("Local EL fetch wasn't required - "); + } + + if (debugTimings.containsKey(RPC_FETCH_TIMING_IDX)) { timingsReport - .append("Fetch delay ") - .append(debugTimings.get(FETCH_TIMING_IDX) - creationTime) + .append("RPC fetch delay ") + .append(debugTimings.get(RPC_FETCH_TIMING_IDX) - creationTime) .append("ms"); } else { - timingsReport.append("Fetch wasn't required"); + timingsReport.append("RPC fetch wasn't required"); } LOG.debug(timingsReport.toString()); @@ -323,7 +342,8 @@ public String toString() { .add("slotAndBlockRoot", slotAndBlockRoot) .add("isBlockPresent", block.get().isPresent()) .add("isCompleted", isCompleted()) - .add("fetchTriggered", fetchTriggered) + .add("rpcFetchTriggered", rpcFetchTriggered) + .add("localElFetchTriggered", localElFetchTriggered) .add("blockImportOnCompletionEnabled", blockImportOnCompletionEnabled.get()) .add( "blobSidecars", diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/block/BlockImportChannel.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/block/BlockImportChannel.java index 1aafbde63c2..1a62ef5f45c 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/block/BlockImportChannel.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/block/BlockImportChannel.java @@ -31,8 +31,18 @@ SafeFuture importBlock( Optional origin); default SafeFuture importBlock( - SignedBeaconBlock block, BroadcastValidationLevel broadcastValidationLevel) { - return importBlock(block, broadcastValidationLevel, Optional.empty()); + final SignedBeaconBlock block) { + return importBlock(block, BroadcastValidationLevel.NOT_REQUIRED, Optional.empty()); + } + + default SafeFuture importBlock( + final SignedBeaconBlock block, final RemoteOrigin origin) { + return importBlock(block, BroadcastValidationLevel.NOT_REQUIRED, Optional.of(origin)); + } + + default SafeFuture importBlock( + final SignedBeaconBlock block, final BroadcastValidationLevel broadcastValidationLevel) { + return importBlock(block, broadcastValidationLevel, Optional.of(RemoteOrigin.LOCAL_PROPOSAL)); } record BlockImportAndBroadcastValidationResults( diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/block/BlockImportMetrics.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/block/BlockImportMetrics.java index 040fa9b9baf..cc16e9ff1fe 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/block/BlockImportMetrics.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/block/BlockImportMetrics.java @@ -67,7 +67,7 @@ public static BlockImportMetrics create(final MetricsSystem metricsSystem) { MetricsCountersByIntervals.create( TekuMetricCategory.BEACON, metricsSystem, - "block_import_delay_counter", + "block_import_delay_counter_total", "Counter of blocks falling in different time frames in each import stages", List.of("stage", "result"), eventsAndBoundaries); diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/block/BlockImporter.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/block/BlockImporter.java index ae1b8b794fa..0bae14716a2 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/block/BlockImporter.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/block/BlockImporter.java @@ -20,6 +20,7 @@ import javax.annotation.CheckReturnValue; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; +import tech.pegasys.teku.infrastructure.async.AsyncRunner; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.logging.EventLogger; import tech.pegasys.teku.infrastructure.ssz.SszList; @@ -65,13 +66,17 @@ public class BlockImporter { private final AtomicReference latestFinalizedCheckpointState = new AtomicReference<>(null); + private final AsyncRunner asyncRunner; + public BlockImporter( + final AsyncRunner asyncRunner, final Spec spec, final ReceivedBlockEventsChannel receivedBlockEventsChannelPublisher, final RecentChainData recentChainData, final ForkChoice forkChoice, final WeakSubjectivityValidator weakSubjectivityValidator, final ExecutionLayerChannel executionLayer) { + this.asyncRunner = asyncRunner; this.spec = spec; this.receivedBlockEventsChannelPublisher = receivedBlockEventsChannelPublisher; this.recentChainData = recentChainData; @@ -106,8 +111,13 @@ public SafeFuture importBlock( return validateWeakSubjectivityPeriod() .thenCompose( __ -> - forkChoice.onBlock( - block, blockImportPerformance, blockBroadcastValidator, executionLayer)) + asyncRunner.runAsync( + () -> + forkChoice.onBlock( + block, + blockImportPerformance, + blockBroadcastValidator, + executionLayer))) .thenApply( result -> { if (!result.isSuccessful()) { @@ -141,7 +151,7 @@ public SafeFuture importBlock( }); } - private SafeFuture validateWeakSubjectivityPeriod() { + private SafeFuture validateWeakSubjectivityPeriod() { return getLatestCheckpointState() .thenCombine( SafeFuture.of(() -> recentChainData.getCurrentSlot().orElseThrow()), @@ -186,7 +196,7 @@ SafeFuture getLatestCheckpointState() { Objects.equals(curVal, finalizedCheckpoint) ? updatedCheckpoint : curVal)); } - private void notifyBlockOperationSubscribers(SignedBeaconBlock block) { + private void notifyBlockOperationSubscribers(final SignedBeaconBlock block) { final BeaconBlockBody blockBody = block.getMessage().getBody(); attestationSubscribers.forEach( @@ -206,27 +216,30 @@ private void notifyBlockOperationSubscribers(SignedBeaconBlock block) { } public void subscribeToVerifiedBlockAttestations( - VerifiedBlockAttestationListener verifiedBlockAttestationsListener) { + final VerifiedBlockAttestationListener verifiedBlockAttestationsListener) { attestationSubscribers.subscribe(verifiedBlockAttestationsListener); } public void subscribeToVerifiedBlockAttesterSlashings( - VerifiedBlockOperationsListener verifiedBlockAttesterSlashingsListener) { + final VerifiedBlockOperationsListener + verifiedBlockAttesterSlashingsListener) { attesterSlashingSubscribers.subscribe(verifiedBlockAttesterSlashingsListener); } public void subscribeToVerifiedBlockProposerSlashings( - VerifiedBlockOperationsListener verifiedBlockProposerSlashingsListener) { + final VerifiedBlockOperationsListener + verifiedBlockProposerSlashingsListener) { proposerSlashingSubscribers.subscribe(verifiedBlockProposerSlashingsListener); } public void subscribeToVerifiedBlockVoluntaryExits( - VerifiedBlockOperationsListener verifiedBlockVoluntaryExitsListener) { + final VerifiedBlockOperationsListener + verifiedBlockVoluntaryExitsListener) { voluntaryExitSubscribers.subscribe(verifiedBlockVoluntaryExitsListener); } public void subscribeToVerifiedBlockBlsToExecutionChanges( - VerifiedBlockOperationsListener + final VerifiedBlockOperationsListener verifiedBlockBlsToExecutionChangeListener) { blsToExecutionChangeSubscribers.subscribe(verifiedBlockBlsToExecutionChangeListener); } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/block/BlockManager.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/block/BlockManager.java index aa51fbd841b..f89510373b4 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/block/BlockManager.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/block/BlockManager.java @@ -146,16 +146,17 @@ public SafeFuture validateAndImportBlock( validationResult.thenAccept( result -> { switch (result.code()) { - case ACCEPT, SAVE_FOR_FUTURE -> doImportBlock( - block, - blockImportPerformance, - BlockBroadcastValidator.NOOP, - Optional.of(RemoteOrigin.GOSSIP)) - .finish(err -> LOG.error("Failed to process received block.", err)); - - // block failed gossip validation, let's drop it from the pool, so it won't be served - // via RPC anymore. This should not be done on ignore result (i.e. duplicate blocks - // could cause an unwanted drop) + case ACCEPT, SAVE_FOR_FUTURE -> + doImportBlock( + block, + blockImportPerformance, + BlockBroadcastValidator.NOOP, + Optional.of(RemoteOrigin.GOSSIP)) + .finish(err -> LOG.error("Failed to process received block.", err)); + + // block failed gossip validation, let's drop it from the pool, so it won't be served + // via RPC anymore. This should not be done on ignore result (i.e. duplicate blocks + // could cause an unwanted drop) case REJECT -> blockBlobSidecarsTrackersPool.removeAllForBlock(block.getRoot()); case IGNORE -> {} } @@ -307,7 +308,7 @@ private SafeFuture handleBlockImport( "Unable to import block {} due to failed broadcast validation", block.toLogString()); break; - // let's avoid default: so we don't forget to explicitly handle new cases + // let's avoid default: so we don't forget to explicitly handle new cases case DOES_NOT_DESCEND_FROM_LATEST_FINALIZED, FAILED_STATE_TRANSITION, FAILED_WEAK_SUBJECTIVITY_CHECKS, diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/block/FailedExecutionPool.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/block/FailedExecutionPool.java index 8ec633c217f..cf147759b93 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/block/FailedExecutionPool.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/block/FailedExecutionPool.java @@ -27,7 +27,6 @@ import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.exceptions.ExceptionUtil; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; -import tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel; import tech.pegasys.teku.spec.logic.common.statetransition.results.BlockImportResult; import tech.pegasys.teku.statetransition.block.BlockImportChannel.BlockImportAndBroadcastValidationResults; import tech.pegasys.teku.storage.server.ShuttingDownException; @@ -112,7 +111,7 @@ private synchronized void retryExecution(final SignedBeaconBlock block) { SafeFuture.of( () -> blockManager - .importBlock(block, BroadcastValidationLevel.NOT_REQUIRED) + .importBlock(block) .thenCompose(BlockImportAndBroadcastValidationResults::blockImportResult)) .exceptionally(BlockImportResult::internalError) .thenAccept(result -> handleExecutionResult(block, result)) diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/CurrentSlotProvider.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/CurrentSlotProvider.java index ea24e6533e7..7228d92abbb 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/CurrentSlotProvider.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/CurrentSlotProvider.java @@ -19,7 +19,7 @@ public interface CurrentSlotProvider { - static CurrentSlotProvider create(Spec spec, ReadOnlyStore store) { + static CurrentSlotProvider create(final Spec spec, final ReadOnlyStore store) { return () -> spec.getCurrentSlot(store); } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DasCustodySync.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DasCustodySync.java index 6df9286b6c4..35a1e7ff6c3 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DasCustodySync.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DasCustodySync.java @@ -51,10 +51,10 @@ public class DasCustodySync implements SlotEventsChannel { private final AtomicLong syncedColumnCount = new AtomicLong(); public DasCustodySync( - UpdatableDataColumnSidecarCustody custody, - DataColumnSidecarRetriever retriever, - int maxPendingColumnRequests, - int minPendingColumnRequests) { + final UpdatableDataColumnSidecarCustody custody, + final DataColumnSidecarRetriever retriever, + final int maxPendingColumnRequests, + final int minPendingColumnRequests) { this.custody = custody; this.retriever = retriever; this.maxPendingColumnRequests = maxPendingColumnRequests; @@ -62,11 +62,11 @@ public DasCustodySync( } public DasCustodySync( - UpdatableDataColumnSidecarCustody custody, DataColumnSidecarRetriever retriever) { + final UpdatableDataColumnSidecarCustody custody, final DataColumnSidecarRetriever retriever) { this(custody, retriever, 10 * 1024, 2 * 1024); } - private void onRequestComplete(PendingRequest request, DataColumnSidecar response) { + private void onRequestComplete(final PendingRequest request, final DataColumnSidecar response) { custody .onNewValidatedDataColumnSidecar(response) .thenRun( @@ -80,13 +80,14 @@ private void onRequestComplete(PendingRequest request, DataColumnSidecar respons .ifExceptionGetsHereRaiseABug(); } - private boolean wasCancelledImplicitly(Throwable exception) { + private boolean wasCancelledImplicitly(final Throwable exception) { return exception instanceof CancellationException || (exception instanceof CompletionException && exception.getCause() instanceof CancellationException); } - private synchronized void onRequestException(PendingRequest request, Throwable exception) { + private synchronized void onRequestException( + final PendingRequest request, final Throwable exception) { if (wasCancelledImplicitly(exception)) { // request was cancelled explicitly here } else { @@ -116,22 +117,22 @@ private void fillUp() { coolDownTillNextSlot = true; } - Set missingColumnsToRequest = + final Set missingColumnsToRequest = missingColumns.stream() .filter(columnSlotId -> !pendingRequests.containsKey(columnSlotId)) .collect(Collectors.toSet()); - Collection pendingRequestsToCancel = + final Collection pendingRequestsToCancel = removeNotMissingPendingRequests(missingColumns); pendingRequestsToCancel.forEach( pendingRequest -> pendingRequest.columnPromise().cancel(true)); - for (DataColumnSlotAndIdentifier missingColumn : missingColumnsToRequest) { + for (final DataColumnSlotAndIdentifier missingColumn : missingColumnsToRequest) { addPendingRequest(missingColumn); } { - Set missingSlots = + final Set missingSlots = missingColumnsToRequest.stream() .map(DataColumnSlotAndIdentifier::slot) .collect(Collectors.toSet()); @@ -159,7 +160,7 @@ private synchronized void addPendingRequest(final DataColumnSlotAndIdentifier mi } private synchronized Collection removeNotMissingPendingRequests( - Set missingColumns) { + final Set missingColumns) { return removeIf(pendingRequests, id -> !missingColumns.contains(id)); } @@ -170,14 +171,14 @@ public void start() { public synchronized void stop() { started = false; - for (PendingRequest request : pendingRequests.values()) { + for (final PendingRequest request : pendingRequests.values()) { request.columnPromise.cancel(true); } pendingRequests.clear(); } @Override - public void onSlot(UInt64 slot) { + public void onSlot(final UInt64 slot) { coolDownTillNextSlot = false; fillUpIfNeeded(); } @@ -185,11 +186,11 @@ public void onSlot(UInt64 slot) { private record PendingRequest( DataColumnSlotAndIdentifier columnId, SafeFuture columnPromise) {} - private static List removeIf(Map map, Predicate removeFilter) { - ArrayList removedValues = new ArrayList<>(); - Iterator> iterator = map.entrySet().iterator(); + private static List removeIf(final Map map, final Predicate removeFilter) { + final ArrayList removedValues = new ArrayList<>(); + final Iterator> iterator = map.entrySet().iterator(); while (iterator.hasNext()) { - Map.Entry entry = iterator.next(); + final Map.Entry entry = iterator.next(); if (removeFilter.test(entry.getKey())) { removedValues.add(entry.getValue()); iterator.remove(); diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DasLongPollCustody.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DasLongPollCustody.java index 759d8eaaff4..563d2fa903e 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DasLongPollCustody.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DasLongPollCustody.java @@ -41,16 +41,17 @@ public class DasLongPollCustody implements UpdatableDataColumnSidecarCustody, Sl @VisibleForTesting final PendingRequests pendingRequests = new PendingRequests(); public DasLongPollCustody( - UpdatableDataColumnSidecarCustody delegate, - AsyncRunner asyncRunner, - Duration waitPeriodForCurrentSlot) { + final UpdatableDataColumnSidecarCustody delegate, + final AsyncRunner asyncRunner, + final Duration waitPeriodForCurrentSlot) { this.delegate = delegate; this.asyncRunner = asyncRunner; this.waitPeriodForCurrentSlot = waitPeriodForCurrentSlot; } @Override - public SafeFuture onNewValidatedDataColumnSidecar(DataColumnSidecar dataColumnSidecar) { + public SafeFuture onNewValidatedDataColumnSidecar( + final DataColumnSidecar dataColumnSidecar) { return delegate .onNewValidatedDataColumnSidecar(dataColumnSidecar) .thenRun( @@ -66,15 +67,16 @@ public SafeFuture onNewValidatedDataColumnSidecar(DataColumnSidecar dataCo @Override public SafeFuture> getCustodyDataColumnSidecar( - DataColumnSlotAndIdentifier columnId) { - SafeFuture> pendingFuture = addPendingRequest(columnId); - SafeFuture> existingFuture = + final DataColumnSlotAndIdentifier columnId) { + final SafeFuture> pendingFuture = addPendingRequest(columnId); + final SafeFuture> existingFuture = delegate.getCustodyDataColumnSidecar(columnId); return anyNonEmpty(pendingFuture, existingFuture); } @Override - public SafeFuture hasCustodyDataColumnSidecar(DataColumnSlotAndIdentifier columnId) { + public SafeFuture hasCustodyDataColumnSidecar( + final DataColumnSlotAndIdentifier columnId) { SafeFuture> pendingFuture = addPendingRequest(columnId).thenApply(maybeSidecar -> maybeSidecar.map(__ -> true)); SafeFuture> existingFuture = @@ -98,7 +100,7 @@ private SafeFuture> addPendingRequest( } @Override - public void onSlot(UInt64 slot) { + public void onSlot(final UInt64 slot) { asyncRunner .runAfterDelay( () -> pendingRequests.setNoWaitSlot(slot.increment()), waitPeriodForCurrentSlot) @@ -106,7 +108,7 @@ public void onSlot(UInt64 slot) { } private static SafeFuture> anyNonEmpty( - SafeFuture> future1, SafeFuture> future2) { + final SafeFuture> future1, final SafeFuture> future2) { return SafeFuture.anyOf(future1, future2) .thenCompose( __ -> { @@ -154,15 +156,15 @@ void add( synchronized List>> remove( final DataColumnSlotAndIdentifier columnId) { - List>> ret = requests.remove(columnId); + final List>> ret = requests.remove(columnId); return ret == null ? Collections.emptyList() : ret; } - void setNoWaitSlot(UInt64 tillSlotExclusive) { + void setNoWaitSlot(final UInt64 tillSlotExclusive) { final List>> toCancel; synchronized (this) { this.noWaitSlot = tillSlotExclusive; - SortedMap>>> + final SortedMap>>> toRemove = requests.headMap( DataColumnSlotAndIdentifier.minimalComparableForSlot(tillSlotExclusive)); diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DasPreSampler.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DasPreSampler.java index b7390edfd31..1847c311254 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DasPreSampler.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DasPreSampler.java @@ -28,16 +28,16 @@ public class DasPreSampler { private final DataAvailabilitySampler sampler; - public DasPreSampler(DataAvailabilitySampler sampler) { + public DasPreSampler(final DataAvailabilitySampler sampler) { this.sampler = sampler; } - private boolean isSamplingRequired(SignedBeaconBlock block) { + private boolean isSamplingRequired(final SignedBeaconBlock block) { return sampler.checkSamplingEligibility(block.getMessage()) == REQUIRED; } - public void onNewPreImportBlocks(Collection blocks) { - List blocksToSample = + public void onNewPreImportBlocks(final Collection blocks) { + final List blocksToSample = blocks.stream().filter(this::isSamplingRequired).toList(); LOG.info( @@ -50,7 +50,7 @@ public void onNewPreImportBlocks(Collection blocks) { blocksToSample.forEach(this::onNewPreImportBlock); } - private void onNewPreImportBlock(SignedBeaconBlock block) { + private void onNewPreImportBlock(final SignedBeaconBlock block) { sampler .checkDataAvailability(block.getSlot(), block.getRoot(), block.getParentRoot()) .finish( diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DasSamplerBasic.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DasSamplerBasic.java index dede67c9d5d..bfbc13dad72 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DasSamplerBasic.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DasSamplerBasic.java @@ -29,13 +29,13 @@ import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.SpecMilestone; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.SpecFeature; +import tech.pegasys.teku.spec.config.features.Eip7594; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSidecar; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock; import tech.pegasys.teku.spec.datastructures.state.Checkpoint; import tech.pegasys.teku.spec.datastructures.util.DataColumnSlotAndIdentifier; -import tech.pegasys.teku.spec.logic.versions.eip7594.helpers.MiscHelpersEip7594; +import tech.pegasys.teku.spec.logic.versions.feature.eip7594.helpers.MiscHelpersEip7594; import tech.pegasys.teku.statetransition.datacolumns.db.DataColumnSidecarDbAccessor; import tech.pegasys.teku.statetransition.datacolumns.retriever.DataColumnSidecarRetriever; import tech.pegasys.teku.statetransition.datacolumns.util.StringifyUtil; @@ -74,14 +74,14 @@ public DasSamplerBasic( this.totalCustodySubnetCount = totalCustodySubnetCount; } - private int getColumnCount(UInt64 slot) { - return SpecConfigEip7594.required(spec.atSlot(slot).getConfig()).getNumberOfColumns(); + private int getColumnCount(final UInt64 slot) { + return Eip7594.required(spec.atSlot(slot).getConfig()).getNumberOfColumns(); } private List calculateSamplingColumnIds( - UInt64 slot, Bytes32 blockRoot) { + final UInt64 slot, final Bytes32 blockRoot) { final Optional maybeMiscHelpers = - spec.atSlot(slot).miscHelpers().toVersionEip7594(); + spec.atSlot(slot).miscHelpers().getEip7594Helpers(); return maybeMiscHelpers .map( miscHelpersEip7594 -> @@ -93,21 +93,21 @@ private List calculateSamplingColumnIds( } private SafeFuture> checkColumnInCustody( - DataColumnSlotAndIdentifier columnIdentifier) { + final DataColumnSlotAndIdentifier columnIdentifier) { return custody .hasCustodyDataColumnSidecar(columnIdentifier) .thenApply(hasColumn -> hasColumn ? Optional.of(columnIdentifier) : Optional.empty()); } private SafeFuture> maybeHasColumnsInCustody( - Collection columnIdentifiers) { + final Collection columnIdentifiers) { return SafeFuture.collectAll(columnIdentifiers.stream().map(this::checkColumnInCustody)) .thenApply(list -> list.stream().flatMap(Optional::stream).toList()); } @Override public SafeFuture> checkDataAvailability( - UInt64 slot, Bytes32 blockRoot, Bytes32 parentRoot) { + final UInt64 slot, final Bytes32 blockRoot, final Bytes32 parentRoot) { final Set requiredColumnIdentifiers = new HashSet<>(calculateSamplingColumnIds(slot, blockRoot)); @@ -118,18 +118,19 @@ public SafeFuture> checkDataAvailability( slot, blockRoot); - SafeFuture> columnsInCustodyFuture = + final SafeFuture> columnsInCustodyFuture = maybeHasColumnsInCustody(requiredColumnIdentifiers); return columnsInCustodyFuture.thenCompose( columnsInCustodyList -> { - Set columnsInCustody = new HashSet<>(columnsInCustodyList); + final Set columnsInCustody = + new HashSet<>(columnsInCustodyList); - Set missingColumn = + final Set missingColumn = Sets.difference(requiredColumnIdentifiers, columnsInCustody); if (LOG.isInfoEnabled()) { - List existingColumnIndexes = + final List existingColumnIndexes = Sets.intersection(requiredColumnIdentifiers, columnsInCustody).stream() .map(it -> it.columnIndex().intValue()) .sorted() @@ -144,7 +145,7 @@ public SafeFuture> checkDataAvailability( StringifyUtil.columnIndexesToString(existingColumnIndexes, getColumnCount(slot))); } - SafeFuture> columnsRetrievedFuture = + final SafeFuture> columnsRetrievedFuture = SafeFuture.collectAll(missingColumn.stream().map(retriever::retrieve)) .thenPeek( retrievedColumns -> { @@ -169,26 +170,25 @@ public SafeFuture> checkDataAvailability( }); } - private boolean isEIP7594(BeaconBlock block) { - return spec.atSlot(block.getSlot()) - .getMilestone() - .isGreaterThanOrEqualTo(SpecMilestone.EIP7594); + private boolean isEIP7594(final BeaconBlock block) { + return spec.isFeatureActivatedAtEpoch( + SpecFeature.EIP7594, spec.computeEpochAtSlot(block.getSlot())); } - private boolean hasBlobs(BeaconBlock block) { + private boolean hasBlobs(final BeaconBlock block) { return !block.getBody().getOptionalBlobKzgCommitments().orElseThrow().isEmpty(); } - private boolean isInCustodyPeriod(BeaconBlock block) { + private boolean isInCustodyPeriod(final BeaconBlock block) { final MiscHelpersEip7594 miscHelpersEip7594 = MiscHelpersEip7594.required(spec.atSlot(block.getSlot()).miscHelpers()); - UInt64 currentEpoch = spec.computeEpochAtSlot(currentSlotProvider.getCurrentSlot()); + final UInt64 currentEpoch = spec.computeEpochAtSlot(currentSlotProvider.getCurrentSlot()); return miscHelpersEip7594.isAvailabilityOfDataColumnSidecarsRequiredAtEpoch( currentEpoch, spec.computeEpochAtSlot(block.getSlot())); } @Override - public SamplingEligibilityStatus checkSamplingEligibility(BeaconBlock block) { + public SamplingEligibilityStatus checkSamplingEligibility(final BeaconBlock block) { if (!isEIP7594(block)) { return SamplingEligibilityStatus.NOT_REQUIRED_BEFORE_EIP7594; } else if (!isInCustodyPeriod(block)) { @@ -201,7 +201,8 @@ public SamplingEligibilityStatus checkSamplingEligibility(BeaconBlock block) { } @Override - public void onNewFinalizedCheckpoint(Checkpoint checkpoint, boolean fromOptimisticBlock) { + public void onNewFinalizedCheckpoint( + final Checkpoint checkpoint, final boolean fromOptimisticBlock) { db.getFirstSamplerIncompleteSlot() .thenCompose( maybeSlot -> diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DataColumnSidecarByRootCustodyImpl.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DataColumnSidecarByRootCustodyImpl.java index 425eac8019b..5e326fa855b 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DataColumnSidecarByRootCustodyImpl.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DataColumnSidecarByRootCustodyImpl.java @@ -42,9 +42,9 @@ public class DataColumnSidecarByRootCustodyImpl private final ColumnSlotCache cache = new ColumnSlotCache(); public DataColumnSidecarByRootCustodyImpl( - UpdatableDataColumnSidecarCustody custody, - CombinedChainDataClient combinedChainDataClient, - UInt64 maxCacheSizeInSlots) { + final UpdatableDataColumnSidecarCustody custody, + final CombinedChainDataClient combinedChainDataClient, + final UInt64 maxCacheSizeInSlots) { this.custody = custody; this.combinedChainDataClient = combinedChainDataClient; this.maxCacheSizeInSlots = maxCacheSizeInSlots; @@ -52,7 +52,7 @@ public DataColumnSidecarByRootCustodyImpl( @Override public SafeFuture> getCustodyDataColumnSidecarByRoot( - DataColumnIdentifier columnId) { + final DataColumnIdentifier columnId) { return cache .getOrComputeAsync( @@ -69,7 +69,8 @@ public SafeFuture> getCustodyDataColumnSidecarByRoot } @Override - public SafeFuture onNewValidatedDataColumnSidecar(DataColumnSidecar dataColumnSidecar) { + public SafeFuture onNewValidatedDataColumnSidecar( + final DataColumnSidecar dataColumnSidecar) { cache.pruneCaches(dataColumnSidecar.getSlot().minusMinZero(maxCacheSizeInSlots)); cache.addColumnSlotIdFromSidecar(dataColumnSidecar); return custody.onNewValidatedDataColumnSidecar(dataColumnSidecar); @@ -82,12 +83,13 @@ public AsyncStream retrieveMissingColumns() { @Override public SafeFuture> getCustodyDataColumnSidecar( - DataColumnSlotAndIdentifier columnId) { + final DataColumnSlotAndIdentifier columnId) { return custody.getCustodyDataColumnSidecar(columnId); } @Override - public SafeFuture hasCustodyDataColumnSidecar(DataColumnSlotAndIdentifier columnId) { + public SafeFuture hasCustodyDataColumnSidecar( + final DataColumnSlotAndIdentifier columnId) { return custody.hasCustodyDataColumnSidecar(columnId); } @@ -96,14 +98,14 @@ private static class ColumnSlotCache { private final NavigableMap slotToBlockRoot = new TreeMap<>(); public synchronized Optional get( - DataColumnIdentifier dataColumnIdentifier) { + final DataColumnIdentifier dataColumnIdentifier) { return Optional.ofNullable(blockRootToSlot.get(dataColumnIdentifier.getBlockRoot())) .map(slot -> new DataColumnSlotAndIdentifier(slot, dataColumnIdentifier)); } public SafeFuture> getOrComputeAsync( - DataColumnIdentifier dataColumnIdentifier, - Function>> asyncRootToSlotSupplier) { + final DataColumnIdentifier dataColumnIdentifier, + final Function>> asyncRootToSlotSupplier) { return get(dataColumnIdentifier) .map(id -> SafeFuture.completedFuture(Optional.of(id))) .orElseGet( @@ -124,17 +126,17 @@ public SafeFuture> getOrComputeAsync( slot, dataColumnIdentifier)))); } - public void addColumnSlotIdFromSidecar(DataColumnSidecar sidecar) { + public void addColumnSlotIdFromSidecar(final DataColumnSidecar sidecar) { addBlockRootToSlot(sidecar.getBlockRoot(), sidecar.getSlot()); } - public synchronized void addBlockRootToSlot(Bytes32 blockRoot, UInt64 slot) { + public synchronized void addBlockRootToSlot(final Bytes32 blockRoot, final UInt64 slot) { blockRootToSlot.put(blockRoot, slot); slotToBlockRoot.put(slot, blockRoot); } - public synchronized void pruneCaches(UInt64 tillSlotExclusive) { - SortedMap toPrune = slotToBlockRoot.headMap(tillSlotExclusive); + public synchronized void pruneCaches(final UInt64 tillSlotExclusive) { + final SortedMap toPrune = slotToBlockRoot.headMap(tillSlotExclusive); toPrune.values().forEach(blockRootToSlot::remove); toPrune.clear(); } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DataColumnSidecarCustodyImpl.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DataColumnSidecarCustodyImpl.java index 60e923a57c6..aaa84493f31 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DataColumnSidecarCustodyImpl.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DataColumnSidecarCustodyImpl.java @@ -16,6 +16,7 @@ import static com.google.common.base.Preconditions.checkNotNull; import java.util.Collection; +import java.util.Collections; import java.util.List; import java.util.Optional; import java.util.Set; @@ -28,12 +29,13 @@ import tech.pegasys.teku.infrastructure.async.stream.AsyncStream; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecFeature; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSidecar; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock; import tech.pegasys.teku.spec.datastructures.blocks.SlotAndBlockRoot; import tech.pegasys.teku.spec.datastructures.state.Checkpoint; import tech.pegasys.teku.spec.datastructures.util.DataColumnSlotAndIdentifier; -import tech.pegasys.teku.spec.logic.versions.eip7594.helpers.MiscHelpersEip7594; +import tech.pegasys.teku.spec.logic.versions.feature.eip7594.helpers.MiscHelpersEip7594; import tech.pegasys.teku.statetransition.datacolumns.db.DataColumnSidecarDbAccessor; import tech.pegasys.teku.storage.api.FinalizedCheckpointChannel; @@ -91,12 +93,12 @@ public boolean isIncomplete() { private volatile UInt64 currentSlot = null; public DataColumnSidecarCustodyImpl( - Spec spec, - CanonicalBlockResolver blockResolver, - DataColumnSidecarDbAccessor db, - MinCustodyPeriodSlotCalculator minCustodyPeriodSlotCalculator, - UInt256 nodeId, - int totalCustodySubnetCount) { + final Spec spec, + final CanonicalBlockResolver blockResolver, + final DataColumnSidecarDbAccessor db, + final MinCustodyPeriodSlotCalculator minCustodyPeriodSlotCalculator, + final UInt256 nodeId, + final int totalCustodySubnetCount) { checkNotNull(spec); checkNotNull(blockResolver); checkNotNull(minCustodyPeriodSlotCalculator); @@ -111,17 +113,18 @@ public DataColumnSidecarCustodyImpl( this.totalCustodySubnetCount = totalCustodySubnetCount; } - private List getCustodyColumnsForSlot(UInt64 slot) { + private List getCustodyColumnsForSlot(final UInt64 slot) { return getCustodyColumnsForEpoch(spec.computeEpochAtSlot(slot)); } - private List getCustodyColumnsForEpoch(UInt64 epoch) { + private List getCustodyColumnsForEpoch(final UInt64 epoch) { return MiscHelpersEip7594.required(spec.atEpoch(epoch).miscHelpers()) .computeCustodyColumnIndexes(nodeId, totalCustodySubnetCount); } @Override - public SafeFuture onNewValidatedDataColumnSidecar(DataColumnSidecar dataColumnSidecar) { + public SafeFuture onNewValidatedDataColumnSidecar( + final DataColumnSidecar dataColumnSidecar) { if (isMyCustody(dataColumnSidecar.getSlot(), dataColumnSidecar.getIndex())) { return db.addSidecar(dataColumnSidecar); } else { @@ -129,11 +132,11 @@ public SafeFuture onNewValidatedDataColumnSidecar(DataColumnSidecar dataCo } } - private boolean isMyCustody(UInt64 slot, UInt64 columnIndex) { - UInt64 epoch = spec.computeEpochAtSlot(slot); + private boolean isMyCustody(final UInt64 slot, final UInt64 columnIndex) { + final UInt64 epoch = spec.computeEpochAtSlot(slot); return spec.atEpoch(epoch) .miscHelpers() - .toVersionEip7594() + .getEip7594Helpers() .map( miscHelpersEip7594 -> miscHelpersEip7594 @@ -144,28 +147,30 @@ private boolean isMyCustody(UInt64 slot, UInt64 columnIndex) { @Override public SafeFuture> getCustodyDataColumnSidecar( - DataColumnSlotAndIdentifier columnId) { + final DataColumnSlotAndIdentifier columnId) { return db.getSidecar(columnId); } @Override - public SafeFuture hasCustodyDataColumnSidecar(DataColumnSlotAndIdentifier columnId) { + public SafeFuture hasCustodyDataColumnSidecar( + final DataColumnSlotAndIdentifier columnId) { return db.getColumnIdentifiers(new SlotAndBlockRoot(columnId.slot(), columnId.blockRoot())) .thenApply(ids -> ids.contains(columnId)); } @Override - public void onSlot(UInt64 slot) { + public void onSlot(final UInt64 slot) { currentSlot = slot; } @Override - public void onNewFinalizedCheckpoint(Checkpoint checkpoint, boolean fromOptimisticBlock) { + public void onNewFinalizedCheckpoint( + final Checkpoint checkpoint, final boolean fromOptimisticBlock) { advanceFirstIncompleteSlot(checkpoint.getEpoch()).ifExceptionGetsHereRaiseABug(); } - private SafeFuture advanceFirstIncompleteSlot(UInt64 finalizedEpoch) { - UInt64 firstNonFinalizedSlot = spec.computeStartSlotAtEpoch(finalizedEpoch.increment()); + private SafeFuture advanceFirstIncompleteSlot(final UInt64 finalizedEpoch) { + final UInt64 firstNonFinalizedSlot = spec.computeStartSlotAtEpoch(finalizedEpoch.increment()); return retrievePotentiallyIncompleteSlotCustodies(firstNonFinalizedSlot) .takeUntil(SlotCustody::isIncomplete, true) .findLast() @@ -196,6 +201,11 @@ private AsyncStream retrievePotentiallyIncompleteSlotCustodies( } private SafeFuture retrieveSlotCustody(final UInt64 slot) { + if (!spec.isFeatureActivatedAtEpoch(SpecFeature.EIP7594, spec.computeEpochAtSlot(slot))) { + return SafeFuture.completedFuture( + new SlotCustody( + slot, Optional.empty(), Collections.emptyList(), Collections.emptyList())); + } final SafeFuture> maybeCanonicalBlockRoot = getBlockRootIfHaveBlobs(slot); final List requiredColumns = getCustodyColumnsForSlot(slot); final SafeFuture> existingColumns = @@ -210,7 +220,7 @@ private SafeFuture retrieveSlotCustody(final UInt64 slot) { existingColumns.getImmediately())); } - private SafeFuture> getBlockRootIfHaveBlobs(UInt64 slot) { + private SafeFuture> getBlockRootIfHaveBlobs(final UInt64 slot) { return blockResolver .getBlockAtSlot(slot) .thenApply( @@ -220,7 +230,7 @@ private SafeFuture> getBlockRootIfHaveBlobs(UInt64 slot) { block -> block .getBeaconBlock() - .flatMap(b -> b.getBody().toVersionEip7594()) + .flatMap(b -> b.getBody().toVersionDeneb()) .map(b -> b.getBlobKzgCommitments().size()) .orElse(0) > 0) diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DataColumnSidecarManagerImpl.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DataColumnSidecarManagerImpl.java index 5a265d5cfd1..fdff0314f21 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DataColumnSidecarManagerImpl.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/DataColumnSidecarManagerImpl.java @@ -52,7 +52,7 @@ public DataColumnSidecarManagerImpl( @Override public SafeFuture onDataColumnSidecarGossip( - DataColumnSidecar dataColumnSidecar, Optional arrivalTimestamp) { + final DataColumnSidecar dataColumnSidecar, final Optional arrivalTimestamp) { final SafeFuture validation; try (Timer ignored = histogram.startTimer()) { validation = validator.validate(dataColumnSidecar); @@ -73,12 +73,13 @@ public SafeFuture onDataColumnSidecarGossip( } @Override - public void onDataColumnSidecarPublish(DataColumnSidecar sidecar) { + public void onDataColumnSidecarPublish(final DataColumnSidecar sidecar) { validDataColumnSidecarsSubscribers.forEach(l -> l.onNewValidSidecar(sidecar)); } @Override - public void subscribeToValidDataColumnSidecars(ValidDataColumnSidecarsListener sidecarsListener) { + public void subscribeToValidDataColumnSidecars( + final ValidDataColumnSidecarsListener sidecarsListener) { validDataColumnSidecarsSubscribers.subscribe(sidecarsListener); } } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/LateInitDataColumnSidecarCustody.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/LateInitDataColumnSidecarCustody.java index d1b8cb9af3f..ddc12632d1d 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/LateInitDataColumnSidecarCustody.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/LateInitDataColumnSidecarCustody.java @@ -22,7 +22,7 @@ public class LateInitDataColumnSidecarCustody implements DataColumnSidecarByRootCustody { private DataColumnSidecarByRootCustody delegate = null; - public void init(DataColumnSidecarByRootCustody delegate) { + public void init(final DataColumnSidecarByRootCustody delegate) { if (this.delegate != null) { throw new IllegalStateException("Delegate was initialized already"); } @@ -31,7 +31,7 @@ public void init(DataColumnSidecarByRootCustody delegate) { @Override public SafeFuture> getCustodyDataColumnSidecar( - DataColumnSlotAndIdentifier columnId) { + final DataColumnSlotAndIdentifier columnId) { if (delegate == null) { throw new IllegalStateException("Delegate was not initialized"); } @@ -39,13 +39,14 @@ public SafeFuture> getCustodyDataColumnSidecar( } @Override - public SafeFuture hasCustodyDataColumnSidecar(DataColumnSlotAndIdentifier columnId) { + public SafeFuture hasCustodyDataColumnSidecar( + final DataColumnSlotAndIdentifier columnId) { return delegate.hasCustodyDataColumnSidecar(columnId); } @Override public SafeFuture> getCustodyDataColumnSidecarByRoot( - DataColumnIdentifier columnId) { + final DataColumnIdentifier columnId) { if (delegate == null) { throw new IllegalStateException("Delegate was not initialized"); } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/MinCustodyPeriodSlotCalculator.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/MinCustodyPeriodSlotCalculator.java index 054992d7a4c..b3630580842 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/MinCustodyPeriodSlotCalculator.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/MinCustodyPeriodSlotCalculator.java @@ -15,22 +15,22 @@ import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.config.NetworkingSpecConfigEip7594; +import tech.pegasys.teku.spec.config.features.Eip7594; public interface MinCustodyPeriodSlotCalculator { - static MinCustodyPeriodSlotCalculator createFromSpec(Spec spec) { + static MinCustodyPeriodSlotCalculator createFromSpec(final Spec spec) { return currentSlot -> { - UInt64 currentEpoch = spec.computeEpochAtSlot(currentSlot); - int custodyPeriodEpochs = + final UInt64 currentEpoch = spec.computeEpochAtSlot(currentSlot); + final int custodyPeriodEpochs = spec.getSpecConfig(currentEpoch) - .toVersionEip7594() - .map(NetworkingSpecConfigEip7594::getMinEpochsForDataColumnSidecarsRequests) + .getOptionalEip7594Config() + .map(Eip7594::getMinEpochsForDataColumnSidecarsRequests) .orElse(0); if (custodyPeriodEpochs == 0) { return currentSlot; } else { - UInt64 minCustodyEpoch = currentEpoch.minusMinZero(custodyPeriodEpochs); + final UInt64 minCustodyEpoch = currentEpoch.minusMinZero(custodyPeriodEpochs); return spec.computeStartSlotAtEpoch(minCustodyEpoch); } }; diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/AbstractDelegatingDasDb.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/AbstractDelegatingDasDb.java index 79838c5052b..650938f9385 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/AbstractDelegatingDasDb.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/AbstractDelegatingDasDb.java @@ -23,23 +23,23 @@ abstract class AbstractDelegatingDasDb implements DataColumnSidecarCoreDB { private final DataColumnSidecarCoreDB delegateDb; - public AbstractDelegatingDasDb(DataColumnSidecarCoreDB delegateDb) { + public AbstractDelegatingDasDb(final DataColumnSidecarCoreDB delegateDb) { this.delegateDb = delegateDb; } @Override public SafeFuture> getSidecar( - DataColumnSlotAndIdentifier identifier) { + final DataColumnSlotAndIdentifier identifier) { return delegateDb.getSidecar(identifier); } @Override - public SafeFuture> getColumnIdentifiers(UInt64 slot) { + public SafeFuture> getColumnIdentifiers(final UInt64 slot) { return delegateDb.getColumnIdentifiers(slot); } @Override - public SafeFuture addSidecar(DataColumnSidecar sidecar) { + public SafeFuture addSidecar(final DataColumnSidecar sidecar) { return delegateDb.addSidecar(sidecar); } } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/AutoPruningDasDb.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/AutoPruningDasDb.java index 360ceae1e65..ef4dccc579c 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/AutoPruningDasDb.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/AutoPruningDasDb.java @@ -32,10 +32,10 @@ class AutoPruningDasDb extends AbstractDelegatingDasDb implements DataColumnSide private volatile UInt64 nextPruneSlot = UInt64.ZERO; public AutoPruningDasDb( - DataColumnSidecarDB delegate, - MinCustodyPeriodSlotCalculator minCustodyPeriodSlotCalculator, - int marginPruneSlots, - int prunePeriod) { + final DataColumnSidecarDB delegate, + final MinCustodyPeriodSlotCalculator minCustodyPeriodSlotCalculator, + final int marginPruneSlots, + final int prunePeriod) { super(delegate); this.delegate = checkNotNull(delegate); this.minCustodyPeriodSlotCalculator = checkNotNull(minCustodyPeriodSlotCalculator); @@ -44,19 +44,19 @@ public AutoPruningDasDb( this.prunePeriod = prunePeriod; } - private UInt64 calculatePruneSlot(UInt64 currentSlot) { + private UInt64 calculatePruneSlot(final UInt64 currentSlot) { return minCustodyPeriodSlotCalculator .getMinCustodyPeriodSlot(currentSlot) .minusMinZero(marginPruneSlots); } @Override - public SafeFuture addSidecar(DataColumnSidecar sidecar) { - SafeFuture addFuture = super.addSidecar(sidecar); + public SafeFuture addSidecar(final DataColumnSidecar sidecar) { + final SafeFuture addFuture = super.addSidecar(sidecar); final SafeFuture pruneFuture; if (sidecar.getSlot().isGreaterThanOrEqualTo(nextPruneSlot)) { nextPruneSlot = sidecar.getSlot().plus(prunePeriod); - UInt64 minCustodySlot = calculatePruneSlot(sidecar.getSlot()); + final UInt64 minCustodySlot = calculatePruneSlot(sidecar.getSlot()); pruneFuture = delegate.pruneAllSidecars(minCustodySlot); } else { pruneFuture = SafeFuture.COMPLETE; @@ -75,12 +75,12 @@ public SafeFuture> getFirstSamplerIncompleteSlot() { } @Override - public SafeFuture setFirstCustodyIncompleteSlot(UInt64 slot) { + public SafeFuture setFirstCustodyIncompleteSlot(final UInt64 slot) { return delegate.setFirstCustodyIncompleteSlot(slot); } @Override - public SafeFuture setFirstSamplerIncompleteSlot(UInt64 slot) { + public SafeFuture setFirstSamplerIncompleteSlot(final UInt64 slot) { return delegate.setFirstSamplerIncompleteSlot(slot); } } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/ColumnIdCachingDasDb.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/ColumnIdCachingDasDb.java index 30ac5ae06cc..77d1a76917d 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/ColumnIdCachingDasDb.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/ColumnIdCachingDasDb.java @@ -34,15 +34,15 @@ class ColumnIdCachingDasDb implements DataColumnSidecarDB { private final Map slotCaches; public ColumnIdCachingDasDb( - DataColumnSidecarDB delegateDb, - Function slotToNumberOfColumns, - int maxCacheSize) { + final DataColumnSidecarDB delegateDb, + final Function slotToNumberOfColumns, + final int maxCacheSize) { this.delegateDb = delegateDb; this.slotToNumberOfColumns = slotToNumberOfColumns; this.slotCaches = LimitedMap.createSynchronizedLRU(maxCacheSize); } - private SlotCache getOrCreateSlotCache(UInt64 slot) { + private SlotCache getOrCreateSlotCache(final UInt64 slot) { return slotCaches.computeIfAbsent( slot, __ -> @@ -50,17 +50,17 @@ private SlotCache getOrCreateSlotCache(UInt64 slot) { delegateDb.getColumnIdentifiers(slot), slotToNumberOfColumns.apply(slot))); } - private void invalidateSlotCache(UInt64 slot) { + private void invalidateSlotCache(final UInt64 slot) { slotCaches.remove(slot); } @Override - public SafeFuture> getColumnIdentifiers(UInt64 slot) { + public SafeFuture> getColumnIdentifiers(final UInt64 slot) { return getOrCreateSlotCache(slot).generateColumnIdentifiers(slot); } @Override - public SafeFuture addSidecar(DataColumnSidecar sidecar) { + public SafeFuture addSidecar(final DataColumnSidecar sidecar) { invalidateSlotCache(sidecar.getSlot()); return delegateDb.addSidecar(sidecar); } @@ -69,17 +69,19 @@ private static class SlotCache { private final SafeFuture> compactCacheFuture; public SlotCache( - SafeFuture> dbResponseFuture, int numberOfColumns) { + final SafeFuture> dbResponseFuture, + final int numberOfColumns) { this.compactCacheFuture = dbResponseFuture.thenApply(slotColumns -> toCompactCache(slotColumns, numberOfColumns)); } - public SafeFuture> generateColumnIdentifiers(UInt64 slot) { + public SafeFuture> generateColumnIdentifiers( + final UInt64 slot) { return compactCacheFuture.thenApply(compactCache -> toColumnIdentifiers(slot, compactCache)); } private static Map toCompactCache( - List slotColumns, int numberOfColumns) { + final List slotColumns, final int numberOfColumns) { final Map compactCache = new HashMap<>(); slotColumns.forEach( colId -> @@ -90,7 +92,7 @@ private static Map toCompactCache( } private static List toColumnIdentifiers( - UInt64 slot, Map compactCache) { + final UInt64 slot, final Map compactCache) { return compactCache.entrySet().stream() .flatMap( entry -> @@ -115,22 +117,22 @@ public SafeFuture> getFirstSamplerIncompleteSlot() { @Override public SafeFuture> getSidecar( - DataColumnSlotAndIdentifier identifier) { + final DataColumnSlotAndIdentifier identifier) { return delegateDb.getSidecar(identifier); } @Override - public SafeFuture setFirstCustodyIncompleteSlot(UInt64 slot) { + public SafeFuture setFirstCustodyIncompleteSlot(final UInt64 slot) { return delegateDb.setFirstCustodyIncompleteSlot(slot); } @Override - public SafeFuture setFirstSamplerIncompleteSlot(UInt64 slot) { + public SafeFuture setFirstSamplerIncompleteSlot(final UInt64 slot) { return delegateDb.setFirstSamplerIncompleteSlot(slot); } @Override - public SafeFuture pruneAllSidecars(UInt64 tillSlot) { + public SafeFuture pruneAllSidecars(final UInt64 tillSlot) { return delegateDb.pruneAllSidecars(tillSlot); } } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/DataColumnSidecarCoreDB.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/DataColumnSidecarCoreDB.java index 8b3dfcca11a..750a56f8cd5 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/DataColumnSidecarCoreDB.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/DataColumnSidecarCoreDB.java @@ -30,7 +30,7 @@ interface DataColumnSidecarCoreDB { SafeFuture> getColumnIdentifiers(UInt64 slot); default SafeFuture> getColumnIdentifiers( - SlotAndBlockRoot blockId) { + final SlotAndBlockRoot blockId) { return getColumnIdentifiers(blockId.getSlot()) .thenApply( ids -> diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/DataColumnSidecarDBImpl.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/DataColumnSidecarDBImpl.java index 91684f9f5a8..ebe6f4a5973 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/DataColumnSidecarDBImpl.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/DataColumnSidecarDBImpl.java @@ -95,9 +95,9 @@ private class DetailLogger { private final AtomicInteger addCounter = new AtomicInteger(); private long maxAddedSlot = 0; - private void logOnNewSidecar(DataColumnSidecar sidecar) { - int currentAddCounter = addCounter.incrementAndGet(); - int slot = sidecar.getSlot().intValue(); + private void logOnNewSidecar(final DataColumnSidecar sidecar) { + final int currentAddCounter = addCounter.incrementAndGet(); + final int slot = sidecar.getSlot().intValue(); final long prevMaxAddedSlot; final long curMaxAddedSlot; synchronized (this) { @@ -131,7 +131,7 @@ private void logOnNewSidecar(DataColumnSidecar sidecar) { } private SafeFuture logNewFirstCustodyIncompleteSlot( - Optional maybeCurrentSlot, final UInt64 newSlot) { + final Optional maybeCurrentSlot, final UInt64 newSlot) { if (maybeCurrentSlot.isEmpty() || !maybeCurrentSlot.get().equals(newSlot)) { return getColumnIdentifiers(newSlot) .thenCompose( @@ -160,7 +160,7 @@ private SafeFuture logNewFirstCustodyIncompleteSlot( } private void logNewFirstSamplerIncompleteSlot( - Optional maybeCurrentSlot, final UInt64 newSlot) { + final Optional maybeCurrentSlot, final UInt64 newSlot) { if (maybeCurrentSlot.isEmpty() || !maybeCurrentSlot.get().equals(newSlot)) { LOG.info( "[nyota] DataColumnSidecarDB: setFirstSamplerIncompleteSlot {} ~> {}", diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/DataColumnSidecarDbAccessor.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/DataColumnSidecarDbAccessor.java index 2aba702b710..90e29d12796 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/DataColumnSidecarDbAccessor.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/DataColumnSidecarDbAccessor.java @@ -20,7 +20,7 @@ /** Higher level {@link DataColumnSidecarDB} accessor */ public interface DataColumnSidecarDbAccessor extends DataColumnSidecarCoreDB { - static DataColumnSidecarDbAccessorBuilder builder(DataColumnSidecarDB db) { + static DataColumnSidecarDbAccessorBuilder builder(final DataColumnSidecarDB db) { return new DataColumnSidecarDbAccessorBuilder(db); } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/DataColumnSidecarDbAccessorBuilder.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/DataColumnSidecarDbAccessorBuilder.java index bc4d38ae1dd..06518f0b299 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/DataColumnSidecarDbAccessorBuilder.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/db/DataColumnSidecarDbAccessorBuilder.java @@ -18,7 +18,7 @@ import java.util.function.Consumer; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.features.Eip7594; import tech.pegasys.teku.statetransition.datacolumns.MinCustodyPeriodSlotCalculator; public class DataColumnSidecarDbAccessorBuilder { @@ -32,38 +32,38 @@ public class DataColumnSidecarDbAccessorBuilder { private final AutoPruneDbBuilder autoPruneDbBuilder = new AutoPruneDbBuilder(); private int columnIdCacheMaxSlotCount = DEFAULT_COLUMN_ID_CACHE_MAX_SLOT_COUNT; - DataColumnSidecarDbAccessorBuilder(DataColumnSidecarDB db) { + DataColumnSidecarDbAccessorBuilder(final DataColumnSidecarDB db) { this.db = db; } - public DataColumnSidecarDbAccessorBuilder spec(Spec spec) { + public DataColumnSidecarDbAccessorBuilder spec(final Spec spec) { this.spec = spec; return this; } public DataColumnSidecarDbAccessorBuilder minCustodyPeriodSlotCalculator( - MinCustodyPeriodSlotCalculator minCustodyPeriodSlotCalculator) { + final MinCustodyPeriodSlotCalculator minCustodyPeriodSlotCalculator) { this.minCustodyPeriodSlotCalculator = minCustodyPeriodSlotCalculator; return this; } public DataColumnSidecarDbAccessorBuilder columnIdCacheMaxSlotCount( - int columnIdCacheMaxSlotCount) { + final int columnIdCacheMaxSlotCount) { this.columnIdCacheMaxSlotCount = columnIdCacheMaxSlotCount; return this; } public DataColumnSidecarDbAccessorBuilder withAutoPrune( - Consumer builderConsumer) { + final Consumer builderConsumer) { builderConsumer.accept(this.autoPruneDbBuilder); return this; } - private int getNumberOfColumnsForSlot(UInt64 slot) { + private int getNumberOfColumnsForSlot(final UInt64 slot) { return spec.atSlot(slot) .getConfig() - .toVersionEip7594() - .map(SpecConfigEip7594::getNumberOfColumns) + .getOptionalEip7594Config() + .map(Eip7594::getNumberOfColumns) .orElse(0); } @@ -86,7 +86,7 @@ public class AutoPruneDbBuilder { private int prunePeriodInSlots = 1; /** Additional period in slots to retain data column sidecars in DB before pruning */ - public AutoPruneDbBuilder pruneMarginSlots(int pruneMarginSlots) { + public AutoPruneDbBuilder pruneMarginSlots(final int pruneMarginSlots) { this.pruneMarginSlots = pruneMarginSlots; return this; } @@ -95,11 +95,11 @@ public AutoPruneDbBuilder pruneMarginSlots(int pruneMarginSlots) { * Specifies how often (in slots) the db prune will be performed 1 means that the prune is to be * called every slot */ - public void prunePeriodSlots(int prunePeriodInSlots) { + public void prunePeriodSlots(final int prunePeriodInSlots) { this.prunePeriodInSlots = prunePeriodInSlots; } - AutoPruningDasDb build(DataColumnSidecarDB db) { + AutoPruningDasDb build(final DataColumnSidecarDB db) { return new AutoPruningDasDb( db, getMinCustodyPeriodSlotCalculator(), pruneMarginSlots, prunePeriodInSlots); } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/gossip/DasGossipBatchLogger.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/gossip/DasGossipBatchLogger.java index ffc8d6b647b..f95a95267a7 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/gossip/DasGossipBatchLogger.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/gossip/DasGossipBatchLogger.java @@ -40,7 +40,7 @@ public class DasGossipBatchLogger implements DasGossipLogger { private List events = new ArrayList<>(); - public DasGossipBatchLogger(AsyncRunner asyncRunner, TimeProvider timeProvider) { + public DasGossipBatchLogger(final AsyncRunner asyncRunner, final TimeProvider timeProvider) { this.timeProvider = timeProvider; asyncRunner.runWithFixedDelay( this::logBatchedEvents, @@ -83,8 +83,8 @@ private void logBatchedEvents() { logSubscriptionEvents(eventsLoc); } - private void logReceiveEvents(SlotAndBlockRoot blockId, List events) { - Map> eventsByValidateCode = + private void logReceiveEvents(final SlotAndBlockRoot blockId, final List events) { + final Map> eventsByValidateCode = events.stream().collect(Collectors.groupingBy(e -> e.validationResult().code())); eventsByValidateCode.forEach( (validationCode, codeEvents) -> { @@ -100,8 +100,8 @@ private void logReceiveEvents(SlotAndBlockRoot blockId, List event }); } - private void logPublishEvents(SlotAndBlockRoot blockId, List events) { - Map>, List> eventsByError = + private void logPublishEvents(final SlotAndBlockRoot blockId, final List events) { + final Map>, List> eventsByError = events.stream() .collect( Collectors.groupingBy( @@ -130,9 +130,9 @@ private void logPublishEvents(SlotAndBlockRoot blockId, List event }); } - private void logSubscriptionEvents(List events) { - List subscribedSubnets = new ArrayList<>(); - List unsubscribedSubnets = new ArrayList<>(); + private void logSubscriptionEvents(final List events) { + final List subscribedSubnets = new ArrayList<>(); + final List unsubscribedSubnets = new ArrayList<>(); events.forEach( e -> { switch (e) { @@ -160,13 +160,13 @@ private void logSubscriptionEvents(List events) { } } - private String columnIndexesString(List events) { - List columnIndexes = + private String columnIndexesString(final List events) { + final List columnIndexes = events.stream().map(e -> e.sidecar().getIndex().intValue()).toList(); return StringifyUtil.toIntRangeString(columnIndexes); } - private static String blockIdString(SlotAndBlockRoot blockId) { + private static String blockIdString(final SlotAndBlockRoot blockId) { return "#" + blockId.getSlot() + " (0x" @@ -174,7 +174,7 @@ private static String blockIdString(SlotAndBlockRoot blockId) { + ")"; } - private String msAgoString(List events) { + private String msAgoString(final List events) { long curTime = timeProvider.getTimeInMillis().longValue(); long firstMillisAgo = curTime - events.getFirst().time(); long lastMillisAgo = curTime - events.getLast().time(); @@ -184,13 +184,13 @@ private String msAgoString(List events) { + " ago"; } - private boolean needToLogEvent(boolean isSevereEvent) { + private boolean needToLogEvent(final boolean isSevereEvent) { return LOG.isDebugEnabled() || (isSevereEvent && LOG.isInfoEnabled()); } @Override public synchronized void onReceive( - DataColumnSidecar sidecar, InternalValidationResult validationResult) { + final DataColumnSidecar sidecar, final InternalValidationResult validationResult) { if (needToLogEvent(validationResult.isReject())) { events.add( new ReceiveEvent(timeProvider.getTimeInMillis().longValue(), sidecar, validationResult)); @@ -198,21 +198,22 @@ public synchronized void onReceive( } @Override - public synchronized void onPublish(DataColumnSidecar sidecar, Optional result) { + public synchronized void onPublish( + final DataColumnSidecar sidecar, final Optional result) { if (needToLogEvent(result.isPresent())) { events.add(new PublishEvent(timeProvider.getTimeInMillis().longValue(), sidecar, result)); } } @Override - public void onDataColumnSubnetSubscribe(int subnetId) { + public void onDataColumnSubnetSubscribe(final int subnetId) { if (needToLogEvent(false)) { events.add(new SubscribeEvent(timeProvider.getTimeInMillis().longValue(), subnetId)); } } @Override - public void onDataColumnSubnetUnsubscribe(int subnetId) { + public void onDataColumnSubnetUnsubscribe(final int subnetId) { if (needToLogEvent(false)) { events.add(new UnsubscribeEvent(timeProvider.getTimeInMillis().longValue(), subnetId)); } @@ -220,14 +221,15 @@ public void onDataColumnSubnetUnsubscribe(int subnetId) { private static SortedMap> groupByBlock( - Class eventClass, List allEvents) { - SortedMap> eventsByBlock = new TreeMap<>(); - for (Event event : allEvents) { + final Class eventClass, final List allEvents) { + final SortedMap> eventsByBlock = new TreeMap<>(); + for (final Event event : allEvents) { if (eventClass.isAssignableFrom(event.getClass())) { @SuppressWarnings("unchecked") - TEvent e = (TEvent) event; - DataColumnSidecar sidecar = e.sidecar(); - SlotAndBlockRoot blockId = new SlotAndBlockRoot(sidecar.getSlot(), sidecar.getBlockRoot()); + final TEvent e = (TEvent) event; + final DataColumnSidecar sidecar = e.sidecar(); + final SlotAndBlockRoot blockId = + new SlotAndBlockRoot(sidecar.getSlot(), sidecar.getBlockRoot()); eventsByBlock.computeIfAbsent(blockId, __ -> new ArrayList<>()).add(e); } } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/AbstractDasResponseLogger.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/AbstractDasResponseLogger.java index 9fa04779c6e..23a1f520196 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/AbstractDasResponseLogger.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/AbstractDasResponseLogger.java @@ -40,7 +40,10 @@ abstract class AbstractDasResponseLogger private final int maxResponseLongStringLength = 512; public AbstractDasResponseLogger( - TimeProvider timeProvider, Direction direction, LoggingPeerId peerId, TRequest request) { + final TimeProvider timeProvider, + final Direction direction, + final LoggingPeerId peerId, + final TRequest request) { super(timeProvider, direction, peerId, request, DataColumnSlotAndIdentifier::fromDataColumn); } @@ -52,7 +55,7 @@ protected Logger getLogger() { } protected String responseString( - List responses, Optional result) { + final List responses, final Optional result) { final String responsesString; if (responses.isEmpty()) { responsesString = ""; @@ -71,8 +74,8 @@ protected String responseString( } } - protected String columnIdsToString(List responses) { - String longString = columnIdsToStringLong(responses); + protected String columnIdsToString(final List responses) { + final String longString = columnIdsToStringLong(responses); if (longString.length() <= maxResponseLongStringLength) { return longString; } else { @@ -80,7 +83,7 @@ protected String columnIdsToString(List responses) } } - protected String columnIdsToStringLong(List responses) { + protected String columnIdsToStringLong(final List responses) { return responses.size() + " columns: " + mapGroupingByBlock( @@ -90,7 +93,7 @@ protected String columnIdsToStringLong(List respons .collect(Collectors.joining(", ")); } - protected String columnIdsToStringShorter(List responses) { + protected String columnIdsToStringShorter(final List responses) { return mapGroupingByBlock( responses, (blockId, columns) -> blockIdString(blockId) + ": " + columns.size()) @@ -98,8 +101,8 @@ protected String columnIdsToStringShorter(List resp } protected Stream mapGroupingByBlock( - List responses, - BiFunction, R> mapper) { + final List responses, + final BiFunction, R> mapper) { SortedMap> responsesByBlock = new TreeMap<>( responses.stream() @@ -108,12 +111,12 @@ protected Stream mapGroupingByBlock( .map(entry -> mapper.apply(entry.getKey(), entry.getValue())); } - protected String blockResponsesToString(List responses) { + protected String blockResponsesToString(final List responses) { return StringifyUtil.columnIndexesToString( responses.stream().map(it -> it.columnIndex().intValue()).toList(), columnCount); } - private static String blockIdString(SlotAndBlockRoot blockId) { + private static String blockIdString(final SlotAndBlockRoot blockId) { if (blockId.getSlot().equals(UNKNOWN_SLOT)) { return blockId.getBlockRoot().toHexString(); } else { @@ -125,7 +128,7 @@ private static String blockIdString(SlotAndBlockRoot blockId) { } } - private static SlotAndBlockRoot blockIdFromColumnId(DataColumnSlotAndIdentifier columnId) { + private static SlotAndBlockRoot blockIdFromColumnId(final DataColumnSlotAndIdentifier columnId) { return new SlotAndBlockRoot(columnId.slot(), columnId.blockRoot()); } } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/AbstractResponseLogger.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/AbstractResponseLogger.java index 0cbcfecae96..7bb00b0f36f 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/AbstractResponseLogger.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/AbstractResponseLogger.java @@ -47,11 +47,11 @@ protected record Timestamped(long time, T value) {} private volatile boolean done = false; public AbstractResponseLogger( - TimeProvider timeProvider, - Direction direction, - LoggingPeerId peerId, - TRequest request, - Function responseSummarizer) { + final TimeProvider timeProvider, + final Direction direction, + final LoggingPeerId peerId, + final TRequest request, + final Function responseSummarizer) { this.timeProvider = timeProvider; this.direction = direction; this.peerId = peerId; @@ -66,9 +66,9 @@ protected abstract void responseComplete( List> responseSummaries, Optional result); @Override - public synchronized void onNextItem(TResponse responseItem) { + public synchronized void onNextItem(final TResponse responseItem) { if (getLogger().isDebugEnabled()) { - TResponseSummary responseSummary = responseSummarizer.apply(responseItem); + final TResponseSummary responseSummary = responseSummarizer.apply(responseItem); if (done) { getLogger().debug("ERROR: Extra onNextItem: " + responseSummary); return; @@ -90,7 +90,7 @@ public void onComplete() { } @Override - public void onError(Throwable error) { + public void onError(final Throwable error) { if (getLogger().isDebugEnabled()) { if (done) { getLogger().debug("ERROR: Extra onError: " + error); @@ -100,7 +100,7 @@ public void onError(Throwable error) { } } - private void finalize(Optional result) { + private void finalize(final Optional result) { done = true; responseComplete(responseSummaries, result); } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/DasByRangeResponseLogger.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/DasByRangeResponseLogger.java index c27519a35e5..f1c2577a397 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/DasByRangeResponseLogger.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/DasByRangeResponseLogger.java @@ -22,21 +22,21 @@ class DasByRangeResponseLogger extends AbstractDasResponseLogger { public DasByRangeResponseLogger( - TimeProvider timeProvider, - Direction direction, - LoggingPeerId peerId, - DasReqRespLogger.ByRangeRequest request) { + final TimeProvider timeProvider, + final Direction direction, + final LoggingPeerId peerId, + final DasReqRespLogger.ByRangeRequest request) { super(timeProvider, direction, peerId, request); } @Override protected void responseComplete( - List> responseSummaries, - Optional result) { + final List> responseSummaries, + final Optional result) { - List responseSummariesUnboxed = + final List responseSummariesUnboxed = responseSummaries.stream().map(Timestamped::value).toList(); - long curTime = timeProvider.getTimeInMillis().longValue(); + final long curTime = timeProvider.getTimeInMillis().longValue(); getLogger() .debug( diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/DasByRootResponseLogger.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/DasByRootResponseLogger.java index 8cee592d955..dd729749913 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/DasByRootResponseLogger.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/DasByRootResponseLogger.java @@ -26,21 +26,21 @@ class DasByRootResponseLogger extends AbstractDasResponseLogger> { public DasByRootResponseLogger( - TimeProvider timeProvider, - Direction direction, - LoggingPeerId peerId, - List dataColumnIdentifiers) { + final TimeProvider timeProvider, + final Direction direction, + final LoggingPeerId peerId, + final List dataColumnIdentifiers) { super(timeProvider, direction, peerId, dataColumnIdentifiers); } @Override protected void responseComplete( - List> responseSummaries, - Optional result) { + final List> responseSummaries, + final Optional result) { - List responseSummariesUnboxed = + final List responseSummariesUnboxed = responseSummaries.stream().map(Timestamped::value).toList(); - long curTime = timeProvider.getTimeInMillis().longValue(); + final long curTime = timeProvider.getTimeInMillis().longValue(); getLogger() .debug( @@ -61,15 +61,15 @@ protected int requestedMaxCount() { return request.size(); } - protected String requestToString(List responses) { - Map blockRootToSlot = + protected String requestToString(final List responses) { + final Map blockRootToSlot = responses.stream() .collect( Collectors.toMap( DataColumnSlotAndIdentifier::blockRoot, DataColumnSlotAndIdentifier::slot, (s1, s2) -> s1)); - List idsWithMaybeSlot = + final List idsWithMaybeSlot = request.stream() .map( it -> diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/DasReqRespLogger.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/DasReqRespLogger.java index 52ce3f7a5f1..2dead67ec72 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/DasReqRespLogger.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/DasReqRespLogger.java @@ -23,7 +23,7 @@ public interface DasReqRespLogger { record ByRangeRequest(UInt64 startSlot, int slotCount, List columnIndexes) {} - static DasReqRespLogger create(TimeProvider timeProvider) { + static DasReqRespLogger create(final TimeProvider timeProvider) { return new DasReqRespLoggerImpl(timeProvider); } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/DasReqRespLoggerImpl.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/DasReqRespLoggerImpl.java index 12f4ca444a9..173e12c634e 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/DasReqRespLoggerImpl.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/DasReqRespLoggerImpl.java @@ -27,14 +27,14 @@ class DasReqRespLoggerImpl implements DasReqRespLogger { new ReqRespMethodLogger<>() { @Override public ReqRespResponseLogger onInboundRequest( - LoggingPeerId fromPeer, List request) { + final LoggingPeerId fromPeer, final List request) { return new DasByRootResponseLogger( timeProvider, AbstractResponseLogger.Direction.INBOUND, fromPeer, request); } @Override public ReqRespResponseLogger onOutboundRequest( - LoggingPeerId toPeer, List request) { + final LoggingPeerId toPeer, final List request) { return new DasByRootResponseLogger( timeProvider, AbstractResponseLogger.Direction.OUTBOUND, toPeer, request); } @@ -44,20 +44,20 @@ public ReqRespResponseLogger onOutboundRequest( new ReqRespMethodLogger<>() { @Override public ReqRespResponseLogger onInboundRequest( - LoggingPeerId fromPeer, ByRangeRequest request) { + final LoggingPeerId fromPeer, final ByRangeRequest request) { return new DasByRangeResponseLogger( timeProvider, AbstractResponseLogger.Direction.INBOUND, fromPeer, request); } @Override public ReqRespResponseLogger onOutboundRequest( - LoggingPeerId toPeer, ByRangeRequest request) { + final LoggingPeerId toPeer, final ByRangeRequest request) { return new DasByRangeResponseLogger( timeProvider, AbstractResponseLogger.Direction.OUTBOUND, toPeer, request); } }; - public DasReqRespLoggerImpl(TimeProvider timeProvider) { + public DasReqRespLoggerImpl(final TimeProvider timeProvider) { this.timeProvider = timeProvider; } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/LoggingBatchDataColumnsByRangeReqResp.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/LoggingBatchDataColumnsByRangeReqResp.java index b737ee88886..519c8630606 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/LoggingBatchDataColumnsByRangeReqResp.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/LoggingBatchDataColumnsByRangeReqResp.java @@ -26,15 +26,18 @@ public class LoggingBatchDataColumnsByRangeReqResp implements BatchDataColumnsBy private final DasReqRespLogger logger; public LoggingBatchDataColumnsByRangeReqResp( - BatchDataColumnsByRangeReqResp delegate, DasReqRespLogger logger) { + final BatchDataColumnsByRangeReqResp delegate, final DasReqRespLogger logger) { this.delegate = delegate; this.logger = logger; } @Override public AsyncStream requestDataColumnSidecarsByRange( - UInt256 nodeId, UInt64 startSlot, int slotCount, List columnIndexes) { - ReqRespResponseLogger responseLogger = + final UInt256 nodeId, + final UInt64 startSlot, + final int slotCount, + final List columnIndexes) { + final ReqRespResponseLogger responseLogger = logger .getDataColumnSidecarsByRangeLogger() .onOutboundRequest( @@ -46,7 +49,7 @@ public AsyncStream requestDataColumnSidecarsByRange( } @Override - public int getCurrentRequestLimit(UInt256 nodeId) { + public int getCurrentRequestLimit(final UInt256 nodeId) { return delegate.getCurrentRequestLimit(nodeId); } } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/LoggingBatchDataColumnsByRootReqResp.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/LoggingBatchDataColumnsByRootReqResp.java index 16607eead5d..00023a053d6 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/LoggingBatchDataColumnsByRootReqResp.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/LoggingBatchDataColumnsByRootReqResp.java @@ -25,15 +25,15 @@ public class LoggingBatchDataColumnsByRootReqResp implements BatchDataColumnsByR private final DasReqRespLogger logger; public LoggingBatchDataColumnsByRootReqResp( - BatchDataColumnsByRootReqResp delegate, DasReqRespLogger logger) { + final BatchDataColumnsByRootReqResp delegate, final DasReqRespLogger logger) { this.delegate = delegate; this.logger = logger; } @Override public AsyncStream requestDataColumnSidecarsByRoot( - UInt256 nodeId, List columnIdentifiers) { - ReqRespResponseLogger responseLogger = + final UInt256 nodeId, final List columnIdentifiers) { + final ReqRespResponseLogger responseLogger = logger .getDataColumnSidecarsByRootLogger() .onOutboundRequest(LoggingPeerId.fromNodeId(nodeId), columnIdentifiers); @@ -43,7 +43,7 @@ public AsyncStream requestDataColumnSidecarsByRoot( } @Override - public int getCurrentRequestLimit(UInt256 nodeId) { + public int getCurrentRequestLimit(final UInt256 nodeId) { return delegate.getCurrentRequestLimit(nodeId); } } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/LoggingPeerId.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/LoggingPeerId.java index 57730d8c70c..5aa8b573a6c 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/LoggingPeerId.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/LoggingPeerId.java @@ -17,26 +17,26 @@ import org.apache.tuweni.units.bigints.UInt256; public class LoggingPeerId { - public static LoggingPeerId fromNodeId(UInt256 nodeId) { + public static LoggingPeerId fromNodeId(final UInt256 nodeId) { return new LoggingPeerId(nodeId, Optional.empty()); } - public static LoggingPeerId fromPeerAndNodeId(String base58PeerId, UInt256 nodeId) { + public static LoggingPeerId fromPeerAndNodeId(final String base58PeerId, final UInt256 nodeId) { return new LoggingPeerId(nodeId, Optional.of(base58PeerId)); } private final UInt256 nodeId; private final Optional base58PeerId; - public LoggingPeerId(UInt256 nodeId, Optional base58PeerId) { + public LoggingPeerId(final UInt256 nodeId, final Optional base58PeerId) { this.nodeId = nodeId; this.base58PeerId = base58PeerId; } @Override public String toString() { - String sNodeId = nodeId.toHexString(); - String sShortNodeId = + final String sNodeId = nodeId.toHexString(); + final String sShortNodeId = sNodeId.substring(0, 10) + "..." + sNodeId.substring(sNodeId.length() - 8); return base58PeerId.map(s -> s + " (nodeId = " + sShortNodeId + ")").orElse(sShortNodeId); } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/NoopReqRespMethodLogger.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/NoopReqRespMethodLogger.java index 882f31be225..e7b547750eb 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/NoopReqRespMethodLogger.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/log/rpc/NoopReqRespMethodLogger.java @@ -18,26 +18,26 @@ class NoopReqRespMethodLogger @Override public ReqRespResponseLogger onInboundRequest( - LoggingPeerId fromPeer, TRequest request) { + final LoggingPeerId fromPeer, final TRequest request) { return noopResponseLogger(); } @Override public ReqRespResponseLogger onOutboundRequest( - LoggingPeerId toPeer, TRequest request) { + final LoggingPeerId toPeer, final TRequest request) { return noopResponseLogger(); } static ReqRespResponseLogger noopResponseLogger() { return new ReqRespResponseLogger<>() { @Override - public void onNextItem(TResponse s) {} + public void onNextItem(final TResponse s) {} @Override public void onComplete() {} @Override - public void onError(Throwable error) {} + public void onError(final Throwable error) {} }; } } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DasPeerCustodyCountSupplier.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DasPeerCustodyCountSupplier.java index 67f0b3bc8e6..e373873e497 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DasPeerCustodyCountSupplier.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DasPeerCustodyCountSupplier.java @@ -20,12 +20,12 @@ public interface DasPeerCustodyCountSupplier { - static DasPeerCustodyCountSupplier createStub(int defaultValue) { + static DasPeerCustodyCountSupplier createStub(final int defaultValue) { return (__) -> defaultValue; } static DasPeerCustodyCountSupplier capped( - DasPeerCustodyCountSupplier delegate, int minValue, int maxValue) { + final DasPeerCustodyCountSupplier delegate, final int minValue, final int maxValue) { return (nodeId) -> min(maxValue, max(minValue, delegate.getCustodyCountForPeer(nodeId))); } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DataColumnReqResp.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DataColumnReqResp.java index ad1fc7c9f67..d401d3caf8b 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DataColumnReqResp.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DataColumnReqResp.java @@ -20,16 +20,16 @@ public interface DataColumnReqResp { - class DataColumnReqRespException extends RuntimeException {} - - class DasColumnNotAvailableException extends DataColumnReqRespException {} - - class DasPeerDisconnectedException extends DataColumnReqRespException {} - SafeFuture requestDataColumnSidecar( UInt256 nodeId, DataColumnIdentifier columnIdentifier); void flush(); int getCurrentRequestLimit(UInt256 nodeId); + + class DataColumnReqRespException extends RuntimeException {} + + class DasColumnNotAvailableException extends DataColumnReqRespException {} + + class DasPeerDisconnectedException extends DataColumnReqRespException {} } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DataColumnReqRespBatchingImpl.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DataColumnReqRespBatchingImpl.java index a36f0e05d29..e30c4712e8a 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DataColumnReqRespBatchingImpl.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DataColumnReqRespBatchingImpl.java @@ -30,7 +30,7 @@ public class DataColumnReqRespBatchingImpl implements DataColumnReqResp { private final BatchDataColumnsByRootReqResp batchRpc; - public DataColumnReqRespBatchingImpl(BatchDataColumnsByRootReqResp batchRpc) { + public DataColumnReqRespBatchingImpl(final BatchDataColumnsByRootReqResp batchRpc) { this.batchRpc = batchRpc; } @@ -44,7 +44,7 @@ private record RequestEntry( @Override public SafeFuture requestDataColumnSidecar( - UInt256 nodeId, DataColumnIdentifier columnIdentifier) { + final UInt256 nodeId, final DataColumnIdentifier columnIdentifier) { RequestEntry entry = new RequestEntry(nodeId, columnIdentifier, new SafeFuture<>()); bufferedRequests.add(entry); return entry.promise(); @@ -62,7 +62,7 @@ public void flush() { } } - private void flushForNode(UInt256 nodeId, List nodeRequests) { + private void flushForNode(final UInt256 nodeId, final List nodeRequests) { AsyncStream response = batchRpc.requestDataColumnSidecarsByRoot( nodeId, nodeRequests.stream().map(e -> e.columnIdentifier).toList()); @@ -75,9 +75,10 @@ private void flushForNode(UInt256 nodeId, List nodeRequests) { .collect(Collectors.toMap(RequestEntry::columnIdentifier, req -> req)); @Override - public SafeFuture onNext(DataColumnSidecar dataColumnSidecar) { - DataColumnIdentifier colId = DataColumnIdentifier.createFromSidecar(dataColumnSidecar); - RequestEntry request = requestsNyColumnId.get(colId); + public SafeFuture onNext(final DataColumnSidecar dataColumnSidecar) { + final DataColumnIdentifier colId = + DataColumnIdentifier.createFromSidecar(dataColumnSidecar); + final RequestEntry request = requestsNyColumnId.get(colId); if (request == null) { return SafeFuture.failedFuture( new IllegalArgumentException( @@ -99,14 +100,14 @@ public void onComplete() { } @Override - public void onError(Throwable err) { + public void onError(final Throwable err) { nodeRequests.forEach(e -> e.promise().completeExceptionally(err)); } }); } @Override - public int getCurrentRequestLimit(UInt256 nodeId) { + public int getCurrentRequestLimit(final UInt256 nodeId) { return batchRpc.getCurrentRequestLimit(nodeId); } } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DataColumnSidecarRetriever.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DataColumnSidecarRetriever.java index d0d0af62095..8e14fbdf149 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DataColumnSidecarRetriever.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DataColumnSidecarRetriever.java @@ -22,17 +22,26 @@ /** The class which searches for a specific {@link DataColumnSidecar} across nodes in the network */ public interface DataColumnSidecarRetriever { + /** + * Queues the specified sidecar for search + * + * @return a future which may run indefinitely until finds a requested data or cancelled or may + * complete exceptionally when cancelled or with {@link NotOnCanonicalChainException} + */ + SafeFuture retrieve(DataColumnSlotAndIdentifier columnId); + /** * The request may complete with this exception when requested column is no more on our local * canonical chain */ class NotOnCanonicalChainException extends RuntimeException { - public NotOnCanonicalChainException(String msg) { + public NotOnCanonicalChainException(final String msg) { super(msg); } public NotOnCanonicalChainException( - DataColumnSlotAndIdentifier columnId, Optional maybeCanonicalBlock) { + final DataColumnSlotAndIdentifier columnId, + final Optional maybeCanonicalBlock) { super( "The column requested is not on local canonical chain: " + columnId @@ -40,12 +49,4 @@ public NotOnCanonicalChainException( + maybeCanonicalBlock.map(BeaconBlock::getRoot)); } } - - /** - * Queues the specified sidecar for search - * - * @return a future which may run indefinitely until finds a requested data or cancelled or may - * complete exceptionally when cancelled or with {@link NotOnCanonicalChainException} - */ - SafeFuture retrieve(DataColumnSlotAndIdentifier columnId); } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/retriever/RecoveringSidecarRetriever.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/retriever/RecoveringSidecarRetriever.java index 79ad483747d..0e09e80b08b 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/retriever/RecoveringSidecarRetriever.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/retriever/RecoveringSidecarRetriever.java @@ -35,7 +35,7 @@ import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockHeader; import tech.pegasys.teku.spec.datastructures.util.DataColumnSlotAndIdentifier; -import tech.pegasys.teku.spec.logic.versions.eip7594.helpers.MiscHelpersEip7594; +import tech.pegasys.teku.spec.logic.versions.feature.eip7594.helpers.MiscHelpersEip7594; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsEip7594; import tech.pegasys.teku.statetransition.datacolumns.CanonicalBlockResolver; import tech.pegasys.teku.statetransition.datacolumns.db.DataColumnSidecarDbAccessor; @@ -57,19 +57,19 @@ public class RecoveringSidecarRetriever implements DataColumnSidecarRetriever { private final Map recoveryBySlot = new ConcurrentHashMap<>(); public RecoveringSidecarRetriever( - DataColumnSidecarRetriever delegate, - KZG kzg, - MiscHelpersEip7594 specHelpers, - SchemaDefinitionsEip7594 schemaDefinitionsEip7594, - CanonicalBlockResolver blockResolver, - DataColumnSidecarDbAccessor sidecarDB, - AsyncRunner asyncRunner, - Duration recoverInitiationTimeout, - int columnCount) { + final DataColumnSidecarRetriever delegate, + final KZG kzg, + final MiscHelpersEip7594 specHelpers, + final SchemaDefinitionsEip7594 schemaDefinitionsElectra, + final CanonicalBlockResolver blockResolver, + final DataColumnSidecarDbAccessor sidecarDB, + final AsyncRunner asyncRunner, + final Duration recoverInitiationTimeout, + final int columnCount) { this.delegate = delegate; this.kzg = kzg; this.specHelpers = specHelpers; - this.schemaDefinitions = schemaDefinitionsEip7594; + this.schemaDefinitions = schemaDefinitionsElectra; this.blockResolver = blockResolver; this.sidecarDB = sidecarDB; this.asyncRunner = asyncRunner; @@ -79,8 +79,8 @@ public RecoveringSidecarRetriever( } @Override - public SafeFuture retrieve(DataColumnSlotAndIdentifier columnId) { - SafeFuture promise = delegate.retrieve(columnId); + public SafeFuture retrieve(final DataColumnSlotAndIdentifier columnId) { + final SafeFuture promise = delegate.retrieve(columnId); // TODO we probably need a better heuristics to submit requests for recovery asyncRunner .runAfterDelay( @@ -96,7 +96,7 @@ public SafeFuture retrieve(DataColumnSlotAndIdentifier column @VisibleForTesting void maybeInitiateRecovery( - DataColumnSlotAndIdentifier columnId, SafeFuture promise) { + final DataColumnSlotAndIdentifier columnId, final SafeFuture promise) { blockResolver .getBlockAtSlot(columnId.slot()) .thenPeek( @@ -159,7 +159,7 @@ private RecoveryEntry createNewRecovery(final BeaconBlock block) { return recoveryEntry; } - private synchronized void recoveryComplete(RecoveryEntry entry) { + private synchronized void recoveryComplete(final RecoveryEntry entry) { LOG.trace("Recovery complete for entry {}", entry); } @@ -175,13 +175,15 @@ private class RecoveryEntry { private boolean recovered = false; private boolean cancelled = false; - public RecoveryEntry(BeaconBlock block, KZG kzg, MiscHelpersEip7594 specHelpers) { + public RecoveryEntry( + final BeaconBlock block, final KZG kzg, final MiscHelpersEip7594 specHelpers) { this.block = block; this.kzg = kzg; this.specHelpers = specHelpers; } - public synchronized void addRequest(UInt64 columnIndex, SafeFuture promise) { + public synchronized void addRequest( + final UInt64 columnIndex, final SafeFuture promise) { if (recovered) { promise.completeAsync(existingSidecarsByColIdx.get(columnIndex), asyncRunner); } else { @@ -190,7 +192,8 @@ public synchronized void addRequest(UInt64 columnIndex, SafeFuture request) { + private void handleRequestCancel( + final UInt64 columnIndex, final SafeFuture request) { request.finish( __ -> { if (request.isCancelled()) { @@ -199,15 +202,15 @@ private void handleRequestCancel(UInt64 columnIndex, SafeFuture> promises = promisesByColIdx.remove(columnIndex); + private synchronized void onRequestCancel(final UInt64 columnIndex) { + final List> promises = promisesByColIdx.remove(columnIndex); promises.stream().filter(p -> !p.isDone()).forEach(promise -> promise.cancel(true)); if (promisesByColIdx.isEmpty()) { cancel(); } } - public synchronized void addSidecar(DataColumnSidecar sidecar) { + public synchronized void addSidecar(final DataColumnSidecar sidecar) { if (!recovered && sidecar.getBlockRoot().equals(block.getRoot())) { existingSidecarsByColIdx.put(sidecar.getIndex(), sidecar); if (existingSidecarsByColIdx.size() >= recoverColumnCount) { @@ -272,7 +275,7 @@ public synchronized void cancel() { } private void recover() { - List> columnBlobEntries = + final List> columnBlobEntries = existingSidecarsByColIdx.values().stream() .map( sideCar -> @@ -288,25 +291,26 @@ private void recover() { UInt64.valueOf(rowIndex))) .toList()) .toList(); - List> blobColumnEntries = transpose(columnBlobEntries); - List> extendedMatrix = specHelpers.recoverMatrix(blobColumnEntries, kzg); - DataColumnSidecar anyExistingSidecar = + final List> blobColumnEntries = transpose(columnBlobEntries); + final List> extendedMatrix = + specHelpers.recoverMatrix(blobColumnEntries, kzg); + final DataColumnSidecar anyExistingSidecar = existingSidecarsByColIdx.values().stream().findFirst().orElseThrow(); - SignedBeaconBlockHeader signedBeaconBlockHeader = + final SignedBeaconBlockHeader signedBeaconBlockHeader = anyExistingSidecar.getSignedBeaconBlockHeader(); - List recoveredSidecars = + final List recoveredSidecars = specHelpers.constructDataColumnSidecars(block, signedBeaconBlockHeader, extendedMatrix); - Map recoveredSidecarsAsMap = + final Map recoveredSidecarsAsMap = recoveredSidecars.stream() .collect(Collectors.toUnmodifiableMap(DataColumnSidecar::getIndex, i -> i)); existingSidecarsByColIdx.putAll(recoveredSidecarsAsMap); } } - private static List> transpose(List> matrix) { - int rowCount = matrix.size(); - int colCount = matrix.get(0).size(); - List> ret = + private static List> transpose(final List> matrix) { + final int rowCount = matrix.size(); + final int colCount = matrix.get(0).size(); + final List> ret = Stream.generate(() -> (List) new ArrayList(rowCount)).limit(colCount).toList(); for (int row = 0; row < rowCount; row++) { @@ -314,7 +318,7 @@ private static List> transpose(List> matrix) { throw new IllegalArgumentException("Different number columns in the matrix"); } for (int col = 0; col < colCount; col++) { - T val = matrix.get(row).get(col); + final T val = matrix.get(row).get(col); ret.get(col).add(row, val); } } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/retriever/SimpleSidecarRetriever.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/retriever/SimpleSidecarRetriever.java index b3c84f5d1cd..021bc456ae8 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/retriever/SimpleSidecarRetriever.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/retriever/SimpleSidecarRetriever.java @@ -40,10 +40,10 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.SpecVersion; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.features.Eip7594; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSidecar; import tech.pegasys.teku.spec.datastructures.util.DataColumnSlotAndIdentifier; -import tech.pegasys.teku.spec.logic.versions.eip7594.helpers.MiscHelpersEip7594; +import tech.pegasys.teku.spec.logic.versions.feature.eip7594.helpers.MiscHelpersEip7594; // TODO improve thread-safety: external calls are better to do outside of the synchronize block to // prevent potential dead locks @@ -63,17 +63,17 @@ public class SimpleSidecarRetriever new LinkedHashMap<>(); private final Map connectedPeers = new HashMap<>(); private boolean started = false; - private AtomicLong retrieveCounter = new AtomicLong(); - private AtomicLong errorCounter = new AtomicLong(); + private final AtomicLong retrieveCounter = new AtomicLong(); + private final AtomicLong errorCounter = new AtomicLong(); public SimpleSidecarRetriever( - Spec spec, - DataColumnPeerManager peerManager, - DataColumnPeerSearcher peerSearcher, - DasPeerCustodyCountSupplier custodyCountSupplier, - DataColumnReqResp reqResp, - AsyncRunner asyncRunner, - Duration roundPeriod) { + final Spec spec, + final DataColumnPeerManager peerManager, + final DataColumnPeerSearcher peerSearcher, + final DasPeerCustodyCountSupplier custodyCountSupplier, + final DataColumnReqResp reqResp, + final AsyncRunner asyncRunner, + final Duration roundPeriod) { this.spec = spec; this.peerSearcher = peerSearcher; this.custodyCountSupplier = custodyCountSupplier; @@ -82,7 +82,7 @@ public SimpleSidecarRetriever( this.reqResp = reqResp; peerManager.addPeerListener(this); this.maxRequestCount = - SpecConfigEip7594.required(spec.forMilestone(SpecMilestone.EIP7594).getConfig()) + Eip7594.required(spec.forMilestone(SpecMilestone.ELECTRA).getConfig()) .getMaxRequestDataColumnSidecars(); } @@ -95,13 +95,14 @@ private void startIfNecessary() { } @Override - public synchronized SafeFuture retrieve(DataColumnSlotAndIdentifier columnId) { - DataColumnPeerSearcher.PeerSearchRequest peerSearchRequest = + public synchronized SafeFuture retrieve( + final DataColumnSlotAndIdentifier columnId) { + final DataColumnPeerSearcher.PeerSearchRequest peerSearchRequest = peerSearcher.requestPeers(columnId.slot(), columnId.columnIndex()); - RetrieveRequest existingRequest = pendingRequests.get(columnId); + final RetrieveRequest existingRequest = pendingRequests.get(columnId); if (existingRequest == null) { - RetrieveRequest request = new RetrieveRequest(columnId, peerSearchRequest); + final RetrieveRequest request = new RetrieveRequest(columnId, peerSearchRequest); pendingRequests.put(columnId, request); startIfNecessary(); return request.result; @@ -113,7 +114,7 @@ public synchronized SafeFuture retrieve(DataColumnSlotAndIden private synchronized List matchRequestsAndPeers() { disposeCompletedRequests(); - RequestTracker ongoingRequestsTracker = createFromCurrentPendingRequests(); + final RequestTracker ongoingRequestsTracker = createFromCurrentPendingRequests(); return pendingRequests.entrySet().stream() .filter(entry -> entry.getValue().activeRpcRequest == null) .flatMap( @@ -127,11 +128,12 @@ private synchronized List matchRequestsAndPeers() { } private Optional findBestMatchingPeer( - RetrieveRequest request, RequestTracker ongoingRequestsTracker) { - Collection matchingPeers = findMatchingPeers(request, ongoingRequestsTracker); + final RetrieveRequest request, final RequestTracker ongoingRequestsTracker) { + final Collection matchingPeers = + findMatchingPeers(request, ongoingRequestsTracker); // taking first the peers which were not requested yet, then peers which are less busy - Comparator comparator = + final Comparator comparator = Comparator.comparing((ConnectedPeer peer) -> request.getPeerRequestCount(peer.nodeId)) .reversed() .thenComparing( @@ -141,7 +143,7 @@ private Optional findBestMatchingPeer( } private Collection findMatchingPeers( - RetrieveRequest request, RequestTracker ongoingRequestsTracker) { + final RetrieveRequest request, final RequestTracker ongoingRequestsTracker) { return connectedPeers.values().stream() .filter(peer -> peer.isCustodyFor(request.columnId)) .filter(peer -> ongoingRequestsTracker.hasAvailableRequests(peer.nodeId)) @@ -149,11 +151,12 @@ private Collection findMatchingPeers( } private void disposeCompletedRequests() { - Iterator> pendingIterator = + final Iterator> pendingIterator = pendingRequests.entrySet().iterator(); while (pendingIterator.hasNext()) { - Map.Entry pendingEntry = pendingIterator.next(); - RetrieveRequest pendingRequest = pendingEntry.getValue(); + final Map.Entry pendingEntry = + pendingIterator.next(); + final RetrieveRequest pendingRequest = pendingEntry.getValue(); if (pendingRequest.result.isDone()) { pendingIterator.remove(); pendingRequest.peerSearchRequest.dispose(); @@ -165,9 +168,9 @@ private void disposeCompletedRequests() { } private synchronized void nextRound() { - List matches = matchRequestsAndPeers(); - for (RequestMatch match : matches) { - SafeFuture reqRespPromise = + final List matches = matchRequestsAndPeers(); + for (final RequestMatch match : matches) { + final SafeFuture reqRespPromise = reqResp.requestDataColumnSidecar( match.peer.nodeId, match.request.columnId.toDataColumnIdentifier()); match.request().onPeerRequest(match.peer().nodeId); @@ -178,7 +181,7 @@ private synchronized void nextRound() { match.peer); } - long activeRequestCount = + final long activeRequestCount = pendingRequests.values().stream().filter(r -> r.activeRpcRequest != null).count(); LOG.info( "[nyota] SimpleSidecarRetriever.nextRound: completed: {}, errored: {}, total pending: {}, active pending: {}, new active: {}, number of custody peers: {}", @@ -194,7 +197,9 @@ private synchronized void nextRound() { @SuppressWarnings("unused") private synchronized void reqRespCompleted( - RetrieveRequest request, DataColumnSidecar maybeResult, Throwable maybeError) { + final RetrieveRequest request, + final DataColumnSidecar maybeResult, + final Throwable maybeError) { if (maybeResult != null) { pendingRequests.remove(request.columnId); request.result.completeAsync(maybeResult, asyncRunner); @@ -207,17 +212,17 @@ private synchronized void reqRespCompleted( } private String gatherAvailableCustodiesInfo() { - SpecVersion specVersion = spec.forMilestone(SpecMilestone.EIP7594); - Map colIndexToCount = + final SpecVersion specVersion = spec.forMilestone(SpecMilestone.ELECTRA); + final Map colIndexToCount = connectedPeers.values().stream() .flatMap(p -> p.getNodeCustodyIndexes(specVersion).stream()) .collect(Collectors.groupingBy(i -> i, Collectors.counting())); - int numberOfColumns = SpecConfigEip7594.required(specVersion.getConfig()).getNumberOfColumns(); + final int numberOfColumns = Eip7594.required(specVersion.getConfig()).getNumberOfColumns(); IntStream.range(0, numberOfColumns) .mapToObj(UInt64::valueOf) .forEach(idx -> colIndexToCount.putIfAbsent(idx, 0L)); colIndexToCount.replaceAll((colIdx, count) -> Long.min(3, count)); - Map custodyCountToPeerCount = + final Map custodyCountToPeerCount = colIndexToCount.entrySet().stream() .collect(Collectors.groupingBy(Map.Entry::getValue, Collectors.counting())); return new TreeMap<>(custodyCountToPeerCount) @@ -231,7 +236,7 @@ private String gatherAvailableCustodiesInfo() { } @Override - public synchronized void peerConnected(UInt256 nodeId) { + public synchronized void peerConnected(final UInt256 nodeId) { LOG.info( "[nyota] SimpleSidecarRetriever.peerConnected: {}", "0x..." + nodeId.toHexString().substring(58)); @@ -239,7 +244,7 @@ public synchronized void peerConnected(UInt256 nodeId) { } @Override - public synchronized void peerDisconnected(UInt256 nodeId) { + public synchronized void peerDisconnected(final UInt256 nodeId) { LOG.info( "[nyota] SimpleSidecarRetriever.peerDisconnected: {}", "0x..." + nodeId.toHexString().substring(58)); @@ -256,17 +261,17 @@ private static class RetrieveRequest { volatile ActiveRequest activeRpcRequest = null; private RetrieveRequest( - DataColumnSlotAndIdentifier columnId, - DataColumnPeerSearcher.PeerSearchRequest peerSearchRequest) { + final DataColumnSlotAndIdentifier columnId, + final DataColumnPeerSearcher.PeerSearchRequest peerSearchRequest) { this.columnId = columnId; this.peerSearchRequest = peerSearchRequest; } - public void onPeerRequest(UInt256 peerId) { + public void onPeerRequest(final UInt256 peerId) { peerRequestCount.compute(peerId, (__, curCount) -> curCount == null ? 1 : curCount + 1); } - public int getPeerRequestCount(UInt256 peerId) { + public int getPeerRequestCount(final UInt256 peerId) { return peerRequestCount.getOrDefault(peerId, 0); } } @@ -277,23 +282,23 @@ private class ConnectedPeer { private record CacheKey(SpecVersion specVersion, int custodyCount) {} - public ConnectedPeer(UInt256 nodeId) { + public ConnectedPeer(final UInt256 nodeId) { this.nodeId = nodeId; } - private Set calcNodeCustodyIndexes(CacheKey cacheKey) { + private Set calcNodeCustodyIndexes(final CacheKey cacheKey) { return new HashSet<>( MiscHelpersEip7594.required(cacheKey.specVersion().miscHelpers()) .computeCustodyColumnIndexes(nodeId, cacheKey.custodyCount())); } - private Set getNodeCustodyIndexes(SpecVersion specVersion) { + private Set getNodeCustodyIndexes(final SpecVersion specVersion) { return custodyIndexesCache.get( new CacheKey(specVersion, custodyCountSupplier.getCustodyCountForPeer(nodeId)), this::calcNodeCustodyIndexes); } - public boolean isCustodyFor(DataColumnSlotAndIdentifier columnId) { + public boolean isCustodyFor(final DataColumnSlotAndIdentifier columnId) { return getNodeCustodyIndexes(spec.atSlot(columnId.slot())).contains(columnId.columnIndex()); } } @@ -301,7 +306,7 @@ public boolean isCustodyFor(DataColumnSlotAndIdentifier columnId) { private record RequestMatch(ConnectedPeer peer, RetrieveRequest request) {} private RequestTracker createFromCurrentPendingRequests() { - Map pendingRequestsCount = + final Map pendingRequestsCount = pendingRequests.values().stream() .map(r -> r.activeRpcRequest) .filter(Objects::nonNull) @@ -313,20 +318,20 @@ private RequestTracker createFromCurrentPendingRequests() { private class RequestTracker { private final Map pendingRequestsCount; - private RequestTracker(Map pendingRequestsCount) { + private RequestTracker(final Map pendingRequestsCount) { this.pendingRequestsCount = pendingRequestsCount; } - int getAvailableRequestCount(UInt256 nodeId) { + int getAvailableRequestCount(final UInt256 nodeId) { return Integer.min(maxRequestCount, reqResp.getCurrentRequestLimit(nodeId)) - pendingRequestsCount.getOrDefault(nodeId, 0); } - boolean hasAvailableRequests(UInt256 nodeId) { + boolean hasAvailableRequests(final UInt256 nodeId) { return getAvailableRequestCount(nodeId) > 0; } - void decreaseAvailableRequests(UInt256 nodeId) { + void decreaseAvailableRequests(final UInt256 nodeId) { pendingRequestsCount.compute(nodeId, (__, cnt) -> cnt == null ? 1 : cnt + 1); } } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/util/StringifyUtil.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/util/StringifyUtil.java index b8404d580b1..be8ba43cc74 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/util/StringifyUtil.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/datacolumns/util/StringifyUtil.java @@ -29,14 +29,15 @@ public class StringifyUtil { - public static String columnIndexesToString(Collection indexes, int maxColumns) { - String lenStr = "(len: " + indexes.size() + ") "; + public static String columnIndexesToString( + final Collection indexes, final int maxColumns) { + final String lenStr = "(len: " + indexes.size() + ") "; if (indexes.isEmpty()) { return lenStr + "[]"; } else if (indexes.size() == maxColumns) { return lenStr + "[all]"; } else if (maxColumns - indexes.size() <= 16) { - Set exceptIndexes = + final Set exceptIndexes = IntStream.range(0, maxColumns).boxed().collect(Collectors.toSet()); exceptIndexes.removeAll(indexes); return lenStr + "[all except " + sortAndJoin(exceptIndexes) + "]"; @@ -55,22 +56,22 @@ public static String columnIndexesToString(Collection indexes, int maxC } } - public static String toIntRangeStringWithSize(Collection ints) { + public static String toIntRangeStringWithSize(final Collection ints) { return "(size: " + ints.size() + ") " + toIntRangeString(ints); } - public static String toIntRangeString(Collection ints) { + public static String toIntRangeString(final Collection ints) { List ranges = reduceToIntRanges(ints); return "[" + ranges.stream().map(Objects::toString).collect(Collectors.joining(",")) + "]"; } private record IntRange(int first, int last) { - static IntRange of(int i) { + static IntRange of(final int i) { return new IntRange(i, i); } - static List union(List left, List right) { + static List union(final List left, final List right) { if (left.isEmpty()) { return right; } else if (right.isEmpty()) { @@ -98,7 +99,7 @@ int size() { return Integer.max(0, last() - first() + 1); } - List union(IntRange other) { + List union(final IntRange other) { if (this.isEmpty()) { return List.of(other); } else if (other.isEmpty()) { @@ -124,7 +125,7 @@ public String toString() { } } - private static List reduceToIntRanges(Collection nums) { + private static List reduceToIntRanges(final Collection nums) { return nums.stream() .sorted() .map(i -> List.of(IntRange.of(i))) @@ -132,7 +133,7 @@ private static List reduceToIntRanges(Collection nums) { .orElse(Collections.emptyList()); } - private static String sortAndJoin(Collection nums) { + private static String sortAndJoin(final Collection nums) { return nums.stream().sorted().map(Objects::toString).collect(Collectors.joining(",")); } } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/events/attestation/ProcessedAggregateEvent.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/events/attestation/ProcessedAggregateEvent.java index 8cdd0380b88..bf313cb9f56 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/events/attestation/ProcessedAggregateEvent.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/events/attestation/ProcessedAggregateEvent.java @@ -21,7 +21,7 @@ public class ProcessedAggregateEvent { private final Attestation attestation; - public ProcessedAggregateEvent(Attestation attestation) { + public ProcessedAggregateEvent(final Attestation attestation) { this.attestation = attestation; } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/events/attestation/ProcessedAttestationEvent.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/events/attestation/ProcessedAttestationEvent.java index 51a73112be7..808cf51d066 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/events/attestation/ProcessedAttestationEvent.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/events/attestation/ProcessedAttestationEvent.java @@ -21,7 +21,7 @@ public class ProcessedAttestationEvent { private final Attestation attestation; - public ProcessedAttestationEvent(Attestation attestation) { + public ProcessedAttestationEvent(final Attestation attestation) { this.attestation = attestation; } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/DataColumnSidecarAvailabilityChecker.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/DataColumnSidecarAvailabilityChecker.java index 0ac57359176..0d7d33fe40e 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/DataColumnSidecarAvailabilityChecker.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/DataColumnSidecarAvailabilityChecker.java @@ -64,13 +64,14 @@ public boolean initiateDataAvailabilityCheck() { LOG.info( "Availability check for slot {} NOT_REQUIRED, kzg commitments empty", block.getSlot()); } - default -> dataAvailabilitySampler - .checkDataAvailability(block.getSlot(), block.getRoot(), block.getParentRoot()) - .finish( - sampleIndexes -> - validationResult.complete(DataAndValidationResult.validResult(sampleIndexes)), - throwable -> - validationResult.complete(DataAndValidationResult.notAvailable(throwable))); + default -> + dataAvailabilitySampler + .checkDataAvailability(block.getSlot(), block.getRoot(), block.getParentRoot()) + .finish( + sampleIndexes -> + validationResult.complete(DataAndValidationResult.validResult(sampleIndexes)), + throwable -> + validationResult.complete(DataAndValidationResult.notAvailable(throwable))); } return true; } @@ -81,7 +82,8 @@ public SafeFuture> getAvailabilityCheckResult() } @Override - public DataAndValidationResult validateImmediately(List dataColumnSidecars) { + public DataAndValidationResult validateImmediately( + final List dataColumnSidecars) { return DataAndValidationResult.validResult(dataColumnSidecars); } } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ExpiringInfo.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ExpiringInfo.java index 319eb33786d..e466299827c 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ExpiringInfo.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ExpiringInfo.java @@ -18,7 +18,7 @@ public abstract class ExpiringInfo { private final UInt64 expirySlot; - ExpiringInfo(UInt64 expirySlot) { + ExpiringInfo(final UInt64 expirySlot) { this.expirySlot = expirySlot; } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoice.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoice.java index 142f1c3e2ef..067973a2089 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoice.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoice.java @@ -43,7 +43,7 @@ import tech.pegasys.teku.infrastructure.subscribers.Subscribers; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.SpecFeature; import tech.pegasys.teku.spec.SpecVersion; import tech.pegasys.teku.spec.cache.CapturingIndexedAttestationCache; import tech.pegasys.teku.spec.cache.IndexedAttestationCache; @@ -77,6 +77,7 @@ import tech.pegasys.teku.statetransition.blobs.BlobSidecarManager; import tech.pegasys.teku.statetransition.block.BlockImportPerformance; import tech.pegasys.teku.statetransition.datacolumns.DasSamplerManager; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.statetransition.validation.AttestationStateSelector; import tech.pegasys.teku.statetransition.validation.BlockBroadcastValidator; import tech.pegasys.teku.statetransition.validation.InternalValidationResult; @@ -112,6 +113,8 @@ public class ForkChoice implements ForkChoiceUpdatedResultSubscriber { private final LabelledMetric getProposerHeadSelectedCounter; + private final DebugDataDumper debugDataDumper; + public ForkChoice( final Spec spec, final EventThread forkChoiceExecutor, @@ -123,6 +126,7 @@ public ForkChoice( final TickProcessor tickProcessor, final MergeTransitionBlockValidator transitionBlockValidator, final boolean forkChoiceLateBlockReorgEnabled, + final DebugDataDumper debugDataDumper, final MetricsSystem metricsSystem) { this.spec = spec; this.forkChoiceExecutor = forkChoiceExecutor; @@ -138,6 +142,7 @@ public ForkChoice( this.forkChoiceLateBlockReorgEnabled = forkChoiceLateBlockReorgEnabled; this.lastProcessHeadSlot.set(UInt64.ZERO); LOG.debug("forkChoiceLateBlockReorgEnabled is set to {}", forkChoiceLateBlockReorgEnabled); + this.debugDataDumper = debugDataDumper; getProposerHeadSelectedCounter = metricsSystem.createLabelledCounter( TekuMetricCategory.BEACON, @@ -168,6 +173,7 @@ public ForkChoice( new TickProcessor(spec, recentChainData), transitionBlockValidator, false, + DebugDataDumper.NOOP, metricsSystem); } @@ -282,8 +288,8 @@ public void applyIndexedAttestations(final List attestat public void onAttesterSlashing( final AttesterSlashing slashing, - InternalValidationResult validationStatus, - boolean fromNetwork) { + final InternalValidationResult validationStatus, + final boolean fromNetwork) { if (!validationStatus.isAccept()) { return; } @@ -296,7 +302,7 @@ public void onAttesterSlashing( .ifExceptionGetsHereRaiseABug(); } - public void subscribeToOptimisticHeadChangesAndUpdate(OptimisticHeadSubscriber subscriber) { + public void subscribeToOptimisticHeadChangesAndUpdate(final OptimisticHeadSubscriber subscriber) { optimisticSyncSubscribers.subscribe(subscriber); getOptimisticSyncing().ifPresent(subscriber::onOptimisticHeadChanged); } @@ -435,8 +441,9 @@ private SafeFuture onBlock( IndexedAttestationCache.capturing(); final AvailabilityChecker availabilityChecker; - if (spec.atSlot(block.getSlot()).getMilestone().isGreaterThanOrEqualTo(SpecMilestone.EIP7594)) { - LOG.info("Created availabilityChecker for slot {}", block.getSlot()); + if (spec.isFeatureActivatedAtEpoch( + SpecFeature.EIP7594, spec.computeEpochAtSlot(block.getSlot()))) { + LOG.info("Created DAS availabilityChecker for slot {}", block.getSlot()); availabilityChecker = dasSamplerManager.createAvailabilityChecker(block); } else { availabilityChecker = blobSidecarManager.createAvailabilityChecker(block); @@ -508,6 +515,7 @@ private SafeFuture onBlock( }); } + @SuppressWarnings("unchecked") private BlockImportResult importBlockAndState( final SignedBeaconBlock block, final BeaconState blockSlotState, @@ -551,18 +559,20 @@ private BlockImportResult importBlockAndState( } switch (dataAndValidationResult.validationResult()) { - case VALID, NOT_REQUIRED -> LOG.debug( - "sidecars validation result: {}", dataAndValidationResult::toLogString); + case VALID, NOT_REQUIRED -> + LOG.debug("sidecars validation result: {}", dataAndValidationResult::toLogString); case NOT_AVAILABLE -> { LOG.debug("sidecars validation result: {}", dataAndValidationResult::toLogString); return BlockImportResult.failedDataAvailabilityCheckNotAvailable( dataAndValidationResult.cause()); } case INVALID -> { - LOG.error("blobSidecars validation result: {}", dataAndValidationResult::toLogString); + LOG.error("sidecars validation result: {}", dataAndValidationResult::toLogString); + debugDataDumper.saveInvalidSidecars(dataAndValidationResult.data(), block); return BlockImportResult.failedDataAvailabilityCheckInvalid( dataAndValidationResult.cause()); } + default -> {} } final ForkChoiceStrategy forkChoiceStrategy = getForkChoiceStrategy(); @@ -702,7 +712,7 @@ private Optional computeEarliestBlobSidecarsSlot( earliestAvailabilityWindowSlotBeforeBlock.max(earliestAffectedSlot)); } - private UInt64 getMillisIntoSlot(StoreTransaction transaction, UInt64 millisPerSlot) { + private UInt64 getMillisIntoSlot(final StoreTransaction transaction, final UInt64 millisPerSlot) { return transaction .getTimeInMillis() .minus(secondsToMillis(transaction.getGenesisTime())) @@ -780,6 +790,8 @@ private void reportInvalidBlock(final SignedBeaconBlock block, final BlockImport if (result.getFailureReason() == FailureReason.BLOCK_IS_FROM_FUTURE) { return; } + debugDataDumper.saveInvalidBlock( + block, result.getFailureReason().name(), result.getFailureCause()); P2P_LOG.onInvalidBlock( block.getSlot(), block.getRoot(), @@ -912,7 +924,7 @@ private IndexedAttestation getIndexedAttestation(final ValidatableAttestation at .orElseThrow( () -> new UnsupportedOperationException( - "ValidateableAttestation does not have an IndexedAttestation.")); + "ValidatableAttestation does not have an IndexedAttestation.")); } private SafeFuture onForkChoiceThread(final ExceptionThrowingRunnable task) { diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoiceNotifierImpl.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoiceNotifierImpl.java index 717ab0e3e99..4a31423efa7 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoiceNotifierImpl.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoiceNotifierImpl.java @@ -66,7 +66,8 @@ public ForkChoiceNotifierImpl( } @Override - public void subscribeToForkChoiceUpdatedResult(ForkChoiceUpdatedResultSubscriber subscriber) { + public void subscribeToForkChoiceUpdatedResult( + final ForkChoiceUpdatedResultSubscriber subscriber) { forkChoiceUpdatedSubscribers.subscribe(subscriber); } @@ -96,16 +97,16 @@ public SafeFuture> getPayloadId( } @Override - public void onTerminalBlockReached(Bytes32 executionBlockHash) { + public void onTerminalBlockReached(final Bytes32 executionBlockHash) { eventThread.execute(() -> internalTerminalBlockReached(executionBlockHash)); } @Override - public boolean validatorIsConnected(UInt64 validatorIndex, UInt64 currentSlot) { + public boolean validatorIsConnected(final UInt64 validatorIndex, final UInt64 currentSlot) { return proposersDataManager.validatorIsConnected(validatorIndex, currentSlot); } - private void internalTerminalBlockReached(Bytes32 executionBlockHash) { + private void internalTerminalBlockReached(final Bytes32 executionBlockHash) { eventThread.checkOnEventThread(); LOG.debug("internalTerminalBlockReached executionBlockHash {}", executionBlockHash); forkChoiceUpdateData = forkChoiceUpdateData.withTerminalBlockHash(executionBlockHash); diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoicePayloadExecutor.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoicePayloadExecutor.java index 85fbb28a3e7..0aef2b68f04 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoicePayloadExecutor.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoicePayloadExecutor.java @@ -71,11 +71,10 @@ public boolean optimisticallyExecute( // because it checks the parentRoot matches return true; } - result = Optional.of( executionLayer - .engineNewPayload(payloadToExecute) + .engineNewPayload(payloadToExecute, block.getSlot()) .thenCompose( result -> { if (result.hasValidStatus()) { diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoiceStateProvider.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoiceStateProvider.java index 431c422fcc7..ab4b7b1e81d 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoiceStateProvider.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoiceStateProvider.java @@ -22,7 +22,8 @@ public class ForkChoiceStateProvider { private final EventThread forkChoiceExecutor; private final RecentChainData recentChainData; - public ForkChoiceStateProvider(EventThread forkChoiceExecutor, RecentChainData recentChainData) { + public ForkChoiceStateProvider( + final EventThread forkChoiceExecutor, final RecentChainData recentChainData) { this.forkChoiceExecutor = forkChoiceExecutor; this.recentChainData = recentChainData; } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoiceUpdateData.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoiceUpdateData.java index d25dd739c0e..e43afda6f19 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoiceUpdateData.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoiceUpdateData.java @@ -196,7 +196,7 @@ public Optional> send( return Optional.of(forkChoiceUpdatedResult); } - private void logSendForkChoiceUpdatedComplete(Optional payloadId) { + private void logSendForkChoiceUpdatedComplete(final Optional payloadId) { if (LOG.isDebugEnabled()) { LOG.debug( "send - forkChoiceUpdated returned payload id {} for {}, {}", diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/PreparedProposerInfo.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/PreparedProposerInfo.java index d34899dcddc..53a59203ed2 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/PreparedProposerInfo.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/PreparedProposerInfo.java @@ -19,7 +19,7 @@ public class PreparedProposerInfo extends ExpiringInfo { private final Eth1Address feeRecipient; - public PreparedProposerInfo(UInt64 expirySlot, Eth1Address feeRecipient) { + public PreparedProposerInfo(final UInt64 expirySlot, final Eth1Address feeRecipient) { super(expirySlot); this.feeRecipient = feeRecipient; } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ProposersDataManager.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ProposersDataManager.java index 9459df281a8..ed130f50c45 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ProposersDataManager.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/ProposersDataManager.java @@ -32,10 +32,11 @@ import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.config.SpecConfigDeneb; import tech.pegasys.teku.spec.datastructures.blocks.SlotAndBlockRoot; import tech.pegasys.teku.spec.datastructures.builder.SignedValidatorRegistration; -import tech.pegasys.teku.spec.datastructures.operations.versions.bellatrix.BeaconPreparableProposer; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.datastructures.validator.BeaconPreparableProposer; import tech.pegasys.teku.spec.executionlayer.ExecutionLayerChannel; import tech.pegasys.teku.spec.executionlayer.ForkChoiceState; import tech.pegasys.teku.spec.executionlayer.PayloadBuildingAttributes; @@ -85,7 +86,7 @@ public ProposersDataManager( } @Override - public void onSlot(UInt64 slot) { + public void onSlot(final UInt64 slot) { // do clean up in the middle of the epoch final int slotsPerEpoch = spec.getSlotsPerEpoch(slot); final UInt64 slotInCurrentEpoch = slot.mod(slotsPerEpoch).plus(UInt64.ONE); @@ -145,8 +146,8 @@ private void updatePreparedProposerCache( preparedProposers.forEach( proposer -> preparedProposerInfoByValidatorIndex.put( - proposer.getValidatorIndex(), - new PreparedProposerInfo(expirySlot, proposer.getFeeRecipient()))); + proposer.validatorIndex(), + new PreparedProposerInfo(expirySlot, proposer.feeRecipient()))); } private void updateValidatorRegistrationCache( @@ -237,6 +238,12 @@ private Optional calculatePayloadBuildingAttributes( .map(RegisteredValidatorInfo::getSignedValidatorRegistration); final Eth1Address feeRecipient = getFeeRecipient(proposerInfo, blockSlot); + final Optional maybeDenebConfig = + spec.atSlot(blockSlot).getConfig().toVersionDeneb(); + final Optional maxBlobsPerBlock = + maybeDenebConfig.map(SpecConfigDeneb::getMaxBlobsPerBlock).map(UInt64::valueOf); + final Optional targetBlobsPerBlock = + maybeDenebConfig.map(SpecConfigDeneb::getTargetBlobsPerBlock).map(UInt64::valueOf); return Optional.of( new PayloadBuildingAttributes( @@ -247,7 +254,9 @@ private Optional calculatePayloadBuildingAttributes( feeRecipient, validatorRegistration, spec.getExpectedWithdrawals(state), - currentHeadBlockRoot)); + currentHeadBlockRoot, + targetBlobsPerBlock, + maxBlobsPerBlock)); } // this function MUST return a fee recipient. diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/TerminalPowBlockMonitor.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/TerminalPowBlockMonitor.java index e7b81b8e170..952a1362cc5 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/TerminalPowBlockMonitor.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/forkchoice/TerminalPowBlockMonitor.java @@ -356,13 +356,13 @@ private synchronized void checkTtdEta(final PowBlock currentHead) { eventLogger.terminalPowBlockTtdEta(latestBlock.getTotalDifficulty(), eta, etaInstant); } - private void onTerminalPowBlockFound(Bytes32 blockHash) { + private void onTerminalPowBlockFound(final Bytes32 blockHash) { foundTerminalBlockHash = Optional.of(blockHash); forkChoiceNotifier.onTerminalBlockReached(blockHash); eventLogger.terminalPowBlockDetected(blockHash); } - private boolean notYetFound(Bytes32 blockHash) { + private boolean notYetFound(final Bytes32 blockHash) { return !foundTerminalBlockHash.map(blockHash::equals).orElse(false); } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/genesis/GenesisHandler.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/genesis/GenesisHandler.java index 115c58e61ff..e41715d47ad 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/genesis/GenesisHandler.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/genesis/GenesisHandler.java @@ -27,6 +27,7 @@ import tech.pegasys.teku.infrastructure.time.TimeProvider; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.datastructures.operations.Deposit; import tech.pegasys.teku.spec.datastructures.operations.DepositWithIndex; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.datastructures.util.DepositUtil; @@ -68,7 +69,7 @@ public void onDepositsFromBlock(final DepositsFromBlockEvent event) { } @Override - public void onMinGenesisTimeBlock(MinGenesisTimeBlockEvent event) { + public void onMinGenesisTimeBlock(final MinGenesisTimeBlockEvent event) { if (!recentChainData.isPreGenesis()) { return; } @@ -77,10 +78,14 @@ public void onMinGenesisTimeBlock(MinGenesisTimeBlockEvent event) { } private void processNewData( - Bytes32 blockHash, UInt64 timestamp, List deposits) { - validateDeposits(deposits); + final Bytes32 blockHash, + final UInt64 timestamp, + final List depositsWithIndex) { + validateDeposits(depositsWithIndex); final int previousValidatorRequirementPercent = roundPercent(genesisGenerator.getActiveValidatorCount()); + final List deposits = + depositsWithIndex.stream().map(DepositWithIndex::deposit).toList(); genesisGenerator.updateCandidateState(blockHash, timestamp, deposits); final int newActiveValidatorCount = genesisGenerator.getActiveValidatorCount(); @@ -101,21 +106,21 @@ private void validateDeposits(final List deposits) { final UInt64 expectedIndex = UInt64.valueOf(genesisGenerator.getDepositCount()); final DepositWithIndex firstDeposit = deposits.get(0); - if (!firstDeposit.getIndex().equals(expectedIndex)) { + if (!firstDeposit.index().equals(expectedIndex)) { throw InvalidDepositEventsException.expectedDepositAtIndex( - expectedIndex, firstDeposit.getIndex()); + expectedIndex, firstDeposit.index()); } } - private int roundPercent(int activeValidatorCount) { + private int roundPercent(final int activeValidatorCount) { return activeValidatorCount * 100 / spec.getGenesisSpecConfig().getMinGenesisActiveValidatorCount(); } - private void eth2Genesis(BeaconState genesisState) { + private void eth2Genesis(final BeaconState genesisState) { recentChainData.initializeFromGenesis(genesisState, timeProvider.getTimeInSeconds()); - Bytes32 genesisBlockRoot = recentChainData.getBestBlockRoot().orElseThrow(); + final Bytes32 genesisBlockRoot = recentChainData.getBestBlockRoot().orElseThrow(); EVENT_LOG.genesisEvent( genesisState.hashTreeRoot(), genesisBlockRoot, genesisState.getGenesisTime()); } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/synccommittee/SignedContributionAndProofValidator.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/synccommittee/SignedContributionAndProofValidator.java index 289be508adb..6864e2f8aa7 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/synccommittee/SignedContributionAndProofValidator.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/synccommittee/SignedContributionAndProofValidator.java @@ -153,7 +153,7 @@ public SafeFuture validate(final SignedContributionAnd @FormatMethod private SafeFuture futureFailureResult( - final String message, Object... args) { + final String message, final Object... args) { return SafeFuture.completedFuture(reject(message, args)); } @@ -311,7 +311,8 @@ private boolean isInSyncSubcommittee( } private SourceUniquenessKey getUniquenessKey( - final ContributionAndProof contributionAndProof, SyncCommitteeContribution contribution) { + final ContributionAndProof contributionAndProof, + final SyncCommitteeContribution contribution) { return new SourceUniquenessKey( contributionAndProof.getAggregatorIndex(), contribution.getSlot(), diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/synccommittee/SyncCommitteeContributionPool.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/synccommittee/SyncCommitteeContributionPool.java index 3e75d4ce48e..1e91d2e371d 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/synccommittee/SyncCommitteeContributionPool.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/synccommittee/SyncCommitteeContributionPool.java @@ -51,7 +51,7 @@ public SyncCommitteeContributionPool( } public void subscribeOperationAdded( - OperationAddedSubscriber subscriber) { + final OperationAddedSubscriber subscriber) { subscribers.subscribe(subscriber); } @@ -94,7 +94,7 @@ private synchronized void doAdd(final SyncCommitteeContribution contribution) { } private SyncCommitteeContribution betterContribution( - final SyncCommitteeContribution a, SyncCommitteeContribution b) { + final SyncCommitteeContribution a, final SyncCommitteeContribution b) { if (a == null) { return b; } else if (b == null) { diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/synccommittee/SyncCommitteeMessagePool.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/synccommittee/SyncCommitteeMessagePool.java index eb5970aeb6a..4bf91997c44 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/synccommittee/SyncCommitteeMessagePool.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/synccommittee/SyncCommitteeMessagePool.java @@ -64,7 +64,7 @@ public SyncCommitteeMessagePool(final Spec spec, final SyncCommitteeMessageValid } public void subscribeOperationAdded( - OperationAddedSubscriber subscriber) { + final OperationAddedSubscriber subscriber) { subscribers.subscribe(subscriber); } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/synccommittee/SyncCommitteeMessageValidator.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/synccommittee/SyncCommitteeMessageValidator.java index f09c22c0175..6a9e40a2d6a 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/synccommittee/SyncCommitteeMessageValidator.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/synccommittee/SyncCommitteeMessageValidator.java @@ -68,9 +68,9 @@ public SyncCommitteeMessageValidator( } public SafeFuture validate( - final ValidatableSyncCommitteeMessage validateableMessage) { + final ValidatableSyncCommitteeMessage validatableMessage) { - final SyncCommitteeMessage message = validateableMessage.getMessage(); + final SyncCommitteeMessage message = validatableMessage.getMessage(); final Optional maybeSyncCommitteeUtil = spec.getSyncCommitteeUtil(message.getSlot()); @@ -104,11 +104,11 @@ public SafeFuture validate( // Note this validation is _per topic_ so that for a given `slot`, multiple messages could be // forwarded with the same `validator_index` as long as the `subnet_id`s are distinct. final Optional uniquenessKey; - if (validateableMessage.getReceivedSubnetId().isPresent()) { + if (validatableMessage.getReceivedSubnetId().isPresent()) { final UniquenessKey key = getUniquenessKey( message, - validateableMessage.getReceivedSubnetId().getAsInt(), + validatableMessage.getReceivedSubnetId().getAsInt(), message.getBeaconBlockRoot()); final Optional maybeBestBlockRoot = recentChainData.getBestBlockRoot(); @@ -149,12 +149,12 @@ public SafeFuture validate( } final BeaconStateAltair state = maybeState.get(); return validateWithState( - validateableMessage, message, syncCommitteeUtil, state, uniquenessKey); + validatableMessage, message, syncCommitteeUtil, state, uniquenessKey); }); } private SafeFuture validateWithState( - final ValidatableSyncCommitteeMessage validateableMessage, + final ValidatableSyncCommitteeMessage validatableMessage, final SyncCommitteeMessage message, final SyncCommitteeUtil syncCommitteeUtil, final BeaconStateAltair state, @@ -164,7 +164,7 @@ private SafeFuture validateWithState( // Always calculate the applicable subcommittees to ensure they are cached and can be used to // send the gossip. final SyncSubcommitteeAssignments assignedSubcommittees = - validateableMessage.calculateAssignments(spec, state); + validatableMessage.calculateAssignments(spec, state); // [REJECT] The validator producing this sync_committee_message is in the current sync // committee, i.e. state.validators[sync_committee_message.validator_index].pubkey in @@ -198,10 +198,10 @@ private SafeFuture validateWithState( // [REJECT] The subnet_id is correct, i.e. subnet_id in // compute_subnets_for_sync_committee(state, sync_committee_message.validator_index). - if (validateableMessage.getReceivedSubnetId().isPresent() + if (validatableMessage.getReceivedSubnetId().isPresent() && !assignedSubcommittees .getAssignedSubcommittees() - .contains(validateableMessage.getReceivedSubnetId().getAsInt())) { + .contains(validatableMessage.getReceivedSubnetId().getAsInt())) { return completedFuture( reject("Rejecting sync committee message because subnet id is incorrect")); } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/util/BlockBlobSidecarsTrackersPoolImpl.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/util/BlockBlobSidecarsTrackersPoolImpl.java index 8e11729bf25..5a6014b5d9c 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/util/BlockBlobSidecarsTrackersPoolImpl.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/util/BlockBlobSidecarsTrackersPoolImpl.java @@ -13,7 +13,11 @@ package tech.pegasys.teku.statetransition.util; +import static com.google.common.base.Preconditions.checkArgument; +import static tech.pegasys.teku.infrastructure.exceptions.ExceptionUtil.getRootCauseMessage; import static tech.pegasys.teku.infrastructure.time.TimeUtilities.secondsToMillis; +import static tech.pegasys.teku.statetransition.blobs.BlobSidecarManager.RemoteOrigin.LOCAL_EL; +import static tech.pegasys.teku.statetransition.blobs.BlobSidecarManager.RemoteOrigin.LOCAL_PROPOSAL; import com.google.common.annotations.VisibleForTesting; import java.time.Duration; @@ -26,6 +30,8 @@ import java.util.Set; import java.util.TreeSet; import java.util.function.Consumer; +import java.util.function.Function; +import java.util.function.Supplier; import java.util.stream.Collectors; import java.util.stream.Stream; import org.apache.logging.log4j.LogManager; @@ -34,21 +40,34 @@ import org.hyperledger.besu.plugin.services.metrics.Counter; import org.hyperledger.besu.plugin.services.metrics.LabelledMetric; import tech.pegasys.teku.infrastructure.async.AsyncRunner; +import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.metrics.SettableLabelledGauge; +import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.subscribers.Subscribers; import tech.pegasys.teku.infrastructure.time.TimeProvider; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.SpecVersion; +import tech.pegasys.teku.spec.config.SpecConfigDeneb; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecarSchema; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; +import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockHeader; import tech.pegasys.teku.spec.datastructures.blocks.SlotAndBlockRoot; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.deneb.BeaconBlockBodyDeneb; +import tech.pegasys.teku.spec.datastructures.execution.BlobAndProof; import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.BlobIdentifier; +import tech.pegasys.teku.spec.datastructures.type.SszKZGCommitment; +import tech.pegasys.teku.spec.datastructures.type.SszKZGProof; +import tech.pegasys.teku.spec.executionlayer.ExecutionLayerChannel; +import tech.pegasys.teku.spec.logic.versions.deneb.helpers.MiscHelpersDeneb; +import tech.pegasys.teku.spec.logic.versions.deneb.types.VersionedHash; import tech.pegasys.teku.statetransition.blobs.BlobSidecarManager.RemoteOrigin; import tech.pegasys.teku.statetransition.blobs.BlockBlobSidecarsTracker; import tech.pegasys.teku.statetransition.blobs.BlockBlobSidecarsTrackerFactory; import tech.pegasys.teku.statetransition.blobs.BlockBlobSidecarsTrackersPool; import tech.pegasys.teku.statetransition.block.BlockImportChannel; +import tech.pegasys.teku.statetransition.validation.BlobSidecarGossipValidator; import tech.pegasys.teku.storage.client.RecentChainData; public class BlockBlobSidecarsTrackersPoolImpl extends AbstractIgnoringFutureHistoricalSlot @@ -59,11 +78,16 @@ public class BlockBlobSidecarsTrackersPoolImpl extends AbstractIgnoringFutureHis static final String COUNTER_SIDECAR_TYPE = "blob_sidecar"; static final String COUNTER_GOSSIP_SUBTYPE = "gossip"; + static final String COUNTER_LOCAL_EL_SUBTYPE = "local_el"; + static final String COUNTER_LOCAL_PROPOSAL_SUBTYPE = "local_proposal"; static final String COUNTER_RPC_SUBTYPE = "rpc"; static final String COUNTER_GOSSIP_DUPLICATE_SUBTYPE = "gossip_duplicate"; static final String COUNTER_RPC_DUPLICATE_SUBTYPE = "rpc_duplicate"; + static final String COUNTER_LOCAL_EL_DUPLICATE_SUBTYPE = "local_el_duplicate"; + static final String COUNTER_LOCAL_PROPOSAL_DUPLICATE_SUBTYPE = "local_proposal_duplicate"; static final String COUNTER_RPC_FETCH_SUBTYPE = "rpc_fetch"; + static final String COUNTER_LOCAL_EL_FETCH_SUBTYPE = "local_el_fetch"; static final String GAUGE_BLOB_SIDECARS_LABEL = "blob_sidecars"; static final String GAUGE_BLOB_SIDECARS_TRACKERS_LABEL = "blob_sidecars_trackers"; @@ -80,6 +104,9 @@ public class BlockBlobSidecarsTrackersPoolImpl extends AbstractIgnoringFutureHis private final TimeProvider timeProvider; private final AsyncRunner asyncRunner; private final RecentChainData recentChainData; + private final ExecutionLayerChannel executionLayer; + private final Supplier gossipValidatorSupplier; + private final Function> blobSidecarGossipPublisher; private final int maxTrackers; private final BlockBlobSidecarsTrackerFactory trackerFactory; @@ -109,6 +136,9 @@ public class BlockBlobSidecarsTrackersPoolImpl extends AbstractIgnoringFutureHis final TimeProvider timeProvider, final AsyncRunner asyncRunner, final RecentChainData recentChainData, + final ExecutionLayerChannel executionLayer, + final Supplier gossipValidatorSupplier, + final Function> blobSidecarGossipPublisher, final UInt64 historicalSlotTolerance, final UInt64 futureSlotTolerance, final int maxTrackers) { @@ -118,6 +148,9 @@ public class BlockBlobSidecarsTrackersPoolImpl extends AbstractIgnoringFutureHis this.timeProvider = timeProvider; this.asyncRunner = asyncRunner; this.recentChainData = recentChainData; + this.executionLayer = executionLayer; + this.gossipValidatorSupplier = gossipValidatorSupplier; + this.blobSidecarGossipPublisher = blobSidecarGossipPublisher; this.maxTrackers = maxTrackers; this.sizeGauge = sizeGauge; this.poolStatsCounters = poolStatsCounters; @@ -135,6 +168,9 @@ public class BlockBlobSidecarsTrackersPoolImpl extends AbstractIgnoringFutureHis final TimeProvider timeProvider, final AsyncRunner asyncRunner, final RecentChainData recentChainData, + final ExecutionLayerChannel executionLayer, + final Supplier gossipValidatorSupplier, + final Function> blobSidecarGossipPublisher, final UInt64 historicalSlotTolerance, final UInt64 futureSlotTolerance, final int maxTrackers, @@ -145,6 +181,9 @@ public class BlockBlobSidecarsTrackersPoolImpl extends AbstractIgnoringFutureHis this.timeProvider = timeProvider; this.asyncRunner = asyncRunner; this.recentChainData = recentChainData; + this.executionLayer = executionLayer; + this.gossipValidatorSupplier = gossipValidatorSupplier; + this.blobSidecarGossipPublisher = blobSidecarGossipPublisher; this.maxTrackers = maxTrackers; this.sizeGauge = sizeGauge; this.poolStatsCounters = poolStatsCounters; @@ -174,7 +213,9 @@ private static BlockBlobSidecarsTracker createTracker( final Spec spec, final SlotAndBlockRoot slotAndBlockRoot) { return new BlockBlobSidecarsTracker( slotAndBlockRoot, - UInt64.valueOf(spec.getMaxBlobsPerBlock(slotAndBlockRoot.getSlot()).orElseThrow())); + UInt64.valueOf( + SpecConfigDeneb.required(spec.atSlot(slotAndBlockRoot.getSlot()).getConfig()) + .getMaxBlobsPerBlock())); } @Override @@ -191,12 +232,17 @@ public synchronized void onNewBlobSidecar( final BlockBlobSidecarsTracker blobSidecarsTracker = getOrCreateBlobSidecarsTracker( - slotAndBlockRoot, newTracker -> onFirstSeen(slotAndBlockRoot), existingTracker -> {}); + slotAndBlockRoot, + newTracker -> onFirstSeen(slotAndBlockRoot, Optional.of(remoteOrigin)), + existingTracker -> {}); if (blobSidecarsTracker.add(blobSidecar)) { sizeGauge.set(++totalBlobSidecars, GAUGE_BLOB_SIDECARS_LABEL); countBlobSidecar(remoteOrigin); newBlobSidecarSubscribers.deliver(NewBlobSidecarSubscriber::onNewBlobSidecar, blobSidecar); + if (remoteOrigin.equals(LOCAL_EL) && slotAndBlockRoot.getSlot().equals(getCurrentSlot())) { + publishRecoveredBlobSidecar(blobSidecar); + } } else { countDuplicateBlobSidecar(remoteOrigin); } @@ -206,21 +252,35 @@ public synchronized void onNewBlobSidecar( } } + private void publishRecoveredBlobSidecar(final BlobSidecar blobSidecar) { + LOG.debug("Publishing recovered blob sidecar {}", blobSidecar::toLogString); + gossipValidatorSupplier.get().markForEquivocation(blobSidecar); + blobSidecarGossipPublisher.apply(blobSidecar).ifExceptionGetsHereRaiseABug(); + } + private void countBlobSidecar(final RemoteOrigin origin) { switch (origin) { case RPC -> poolStatsCounters.labels(COUNTER_SIDECAR_TYPE, COUNTER_RPC_SUBTYPE).inc(); case GOSSIP -> poolStatsCounters.labels(COUNTER_SIDECAR_TYPE, COUNTER_GOSSIP_SUBTYPE).inc(); + case LOCAL_EL -> + poolStatsCounters.labels(COUNTER_SIDECAR_TYPE, COUNTER_LOCAL_EL_SUBTYPE).inc(); + case LOCAL_PROPOSAL -> + poolStatsCounters.labels(COUNTER_SIDECAR_TYPE, COUNTER_LOCAL_PROPOSAL_SUBTYPE).inc(); } } private void countDuplicateBlobSidecar(final RemoteOrigin origin) { switch (origin) { - case RPC -> poolStatsCounters - .labels(COUNTER_SIDECAR_TYPE, COUNTER_RPC_DUPLICATE_SUBTYPE) - .inc(); - case GOSSIP -> poolStatsCounters - .labels(COUNTER_SIDECAR_TYPE, COUNTER_GOSSIP_DUPLICATE_SUBTYPE) - .inc(); + case RPC -> + poolStatsCounters.labels(COUNTER_SIDECAR_TYPE, COUNTER_RPC_DUPLICATE_SUBTYPE).inc(); + case GOSSIP -> + poolStatsCounters.labels(COUNTER_SIDECAR_TYPE, COUNTER_GOSSIP_DUPLICATE_SUBTYPE).inc(); + case LOCAL_EL -> + poolStatsCounters.labels(COUNTER_SIDECAR_TYPE, COUNTER_LOCAL_EL_DUPLICATE_SUBTYPE).inc(); + case LOCAL_PROPOSAL -> + poolStatsCounters + .labels(COUNTER_SIDECAR_TYPE, COUNTER_LOCAL_PROPOSAL_DUPLICATE_SUBTYPE) + .inc(); } } @@ -230,9 +290,6 @@ public synchronized void onNewBlock( if (block.getMessage().getBody().toVersionDeneb().isEmpty()) { return; } - if (spec.atSlot(block.getSlot()).getMilestone().isGreaterThanOrEqualTo(SpecMilestone.EIP7594)) { - return; - } if (recentChainData.containsBlock(block.getRoot())) { return; } @@ -426,7 +483,7 @@ private BlockBlobSidecarsTracker internalOnNewBlock( newTracker -> { newTracker.setBlock(block); countBlock(remoteOrigin); - onFirstSeen(slotAndBlockRoot); + onFirstSeen(slotAndBlockRoot, remoteOrigin); }, existingTracker -> { if (!existingTracker.setBlock(block)) { @@ -437,7 +494,7 @@ private BlockBlobSidecarsTracker internalOnNewBlock( countBlock(remoteOrigin); - if (existingTracker.isFetchTriggered()) { + if (existingTracker.isRpcFetchTriggered()) { // block has been set for the first time and we previously triggered fetching of // missing blobSidecars. So we may have requested to fetch more sidecars // than the block actually requires. Let's drop them. @@ -448,6 +505,14 @@ private BlockBlobSidecarsTracker internalOnNewBlock( requiredBlobSidecarDroppedSubscribers.deliver( RequiredBlobSidecarDroppedSubscriber::onRequiredBlobSidecarDropped, blobIdentifier)); + + // if we attempted to fetch via RPC, we missed the opportunity to complete the + // tracker via local EL (local El fetch requires the block to be known) + // Let's try now + if (!existingTracker.isLocalElFetchTriggered() && !existingTracker.isCompleted()) { + fetchMissingContentFromLocalEL(slotAndBlockRoot) + .finish(this::logLocalElBlobsLookupFailure); + } } }); @@ -463,9 +528,11 @@ private void countBlock(final Optional maybeRemoteOrigin) { remoteOrigin -> { switch (remoteOrigin) { case RPC -> poolStatsCounters.labels(COUNTER_BLOCK_TYPE, COUNTER_RPC_SUBTYPE).inc(); - case GOSSIP -> poolStatsCounters - .labels(COUNTER_BLOCK_TYPE, COUNTER_GOSSIP_SUBTYPE) - .inc(); + case GOSSIP -> + poolStatsCounters.labels(COUNTER_BLOCK_TYPE, COUNTER_GOSSIP_SUBTYPE).inc(); + case LOCAL_EL -> {} // only possible for blobs + case LOCAL_PROPOSAL -> + poolStatsCounters.labels(COUNTER_BLOCK_TYPE, COUNTER_LOCAL_PROPOSAL_SUBTYPE).inc(); } }); } @@ -474,12 +541,17 @@ private void countDuplicateBlock(final Optional maybeRemoteOrigin) maybeRemoteOrigin.ifPresent( remoteOrigin -> { switch (remoteOrigin) { - case RPC -> poolStatsCounters - .labels(COUNTER_BLOCK_TYPE, COUNTER_RPC_DUPLICATE_SUBTYPE) - .inc(); - case GOSSIP -> poolStatsCounters - .labels(COUNTER_BLOCK_TYPE, COUNTER_GOSSIP_DUPLICATE_SUBTYPE) - .inc(); + case RPC -> + poolStatsCounters.labels(COUNTER_BLOCK_TYPE, COUNTER_RPC_DUPLICATE_SUBTYPE).inc(); + case GOSSIP -> + poolStatsCounters + .labels(COUNTER_BLOCK_TYPE, COUNTER_GOSSIP_DUPLICATE_SUBTYPE) + .inc(); + case LOCAL_PROPOSAL -> + poolStatsCounters + .labels(COUNTER_BLOCK_TYPE, COUNTER_LOCAL_PROPOSAL_DUPLICATE_SUBTYPE) + .inc(); + case LOCAL_EL -> {} // only possible for blobs } }); } @@ -511,12 +583,30 @@ private void makeRoomForNewTracker() { } } - private void onFirstSeen(final SlotAndBlockRoot slotAndBlockRoot) { + private void onFirstSeen( + final SlotAndBlockRoot slotAndBlockRoot, final Optional remoteOrigin) { + final boolean isLocalBlockProduction = + remoteOrigin.map(ro -> ro.equals(LOCAL_PROPOSAL)).orElse(false); + if (isLocalBlockProduction) { + return; + } + final Duration fetchDelay = calculateFetchDelay(slotAndBlockRoot); asyncRunner - .runAfterDelay(() -> this.fetchMissingContent(slotAndBlockRoot), fetchDelay) - .ifExceptionGetsHereRaiseABug(); + .runAfterDelay( + () -> + this.fetchMissingContentFromLocalEL(slotAndBlockRoot) + .handleException(this::logLocalElBlobsLookupFailure) + .thenRun(() -> this.fetchMissingContentFromRemotePeers(slotAndBlockRoot)), + fetchDelay) + .finish( + error -> + LOG.error("An error occurred while attempting to fetch missing blobs.", error)); + } + + private void logLocalElBlobsLookupFailure(final Throwable error) { + LOG.warn("Local EL blobs lookup failed: {}", getRootCauseMessage(error)); } @VisibleForTesting @@ -550,7 +640,115 @@ Duration calculateFetchDelay(final SlotAndBlockRoot slotAndBlockRoot) { return Duration.ofMillis(finalTime.minus(nowMillis).intValue()); } - private synchronized void fetchMissingContent(final SlotAndBlockRoot slotAndBlockRoot) { + private synchronized SafeFuture fetchMissingContentFromLocalEL( + final SlotAndBlockRoot slotAndBlockRoot) { + final BlockBlobSidecarsTracker blockBlobSidecarsTracker = + blockBlobSidecarsTrackers.get(slotAndBlockRoot.getBlockRoot()); + + if (blockBlobSidecarsTracker == null) { + return SafeFuture.COMPLETE; + } + + if (blockBlobSidecarsTracker.isCompleted()) { + return SafeFuture.COMPLETE; + } + + if (blockBlobSidecarsTracker.getBlock().isEmpty()) { + return SafeFuture.COMPLETE; + } + + blockBlobSidecarsTracker.setLocalElFetchTriggered(); + + final SpecVersion specVersion = spec.atSlot(slotAndBlockRoot.getSlot()); + final BlobSidecarSchema blobSidecarSchema = + specVersion.getSchemaDefinitions().toVersionDeneb().orElseThrow().getBlobSidecarSchema(); + final MiscHelpersDeneb miscHelpersDeneb = + specVersion.miscHelpers().toVersionDeneb().orElseThrow(); + final SignedBeaconBlockHeader signedBeaconBlockHeader = + blockBlobSidecarsTracker.getBlock().get().asHeader(); + final BeaconBlockBodyDeneb beaconBlockBodyDeneb = + blockBlobSidecarsTracker + .getBlock() + .get() + .getMessage() + .getBody() + .toVersionDeneb() + .orElseThrow(); + + final SszList sszKZGCommitments = + beaconBlockBodyDeneb.getBlobKzgCommitments(); + + final List missingBlobsIdentifiers = + blockBlobSidecarsTracker.getMissingBlobSidecars().toList(); + + final List versionedHashes = + missingBlobsIdentifiers.stream() + .map( + blobIdentifier -> + miscHelpersDeneb.kzgCommitmentToVersionedHash( + sszKZGCommitments + .get(blobIdentifier.getIndex().intValue()) + .getKZGCommitment())) + .toList(); + + poolStatsCounters + .labels(COUNTER_SIDECAR_TYPE, COUNTER_LOCAL_EL_FETCH_SUBTYPE) + .inc(versionedHashes.size()); + + return executionLayer + .engineGetBlobs(versionedHashes, slotAndBlockRoot.getSlot()) + .thenAccept( + blobAndProofs -> { + checkArgument( + blobAndProofs.size() == versionedHashes.size(), + "Queried %s versionedHashed but got %s blobAndProofs", + versionedHashes.size(), + blobAndProofs.size()); + + for (int index = 0; index < blobAndProofs.size(); index++) { + final Optional blobAndProof = blobAndProofs.get(index); + if (blobAndProof.isEmpty()) { + LOG.trace("Blob not found on local EL: {}", missingBlobsIdentifiers.get(index)); + continue; + } + + final BlobSidecar blobSidecar = + createBlobSidecarFromBlobAndProof( + blobSidecarSchema, + miscHelpersDeneb, + missingBlobsIdentifiers.get(index), + blobAndProof.get(), + beaconBlockBodyDeneb, + signedBeaconBlockHeader); + + onNewBlobSidecar(blobSidecar, LOCAL_EL); + } + }); + } + + private BlobSidecar createBlobSidecarFromBlobAndProof( + final BlobSidecarSchema blobSidecarSchema, + final MiscHelpersDeneb miscHelpersDeneb, + final BlobIdentifier blobIdentifier, + final BlobAndProof blobAndProof, + final BeaconBlockBodyDeneb beaconBlockBodyDeneb, + final SignedBeaconBlockHeader signedBeaconBlockHeader) { + + final SszKZGCommitment sszKZGCommitment = + beaconBlockBodyDeneb.getBlobKzgCommitments().get(blobIdentifier.getIndex().intValue()); + + return blobSidecarSchema.create( + blobIdentifier.getIndex(), + blobAndProof.blob(), + sszKZGCommitment, + new SszKZGProof(blobAndProof.proof()), + signedBeaconBlockHeader, + miscHelpersDeneb.computeBlobKzgCommitmentInclusionProof( + blobIdentifier.getIndex(), beaconBlockBodyDeneb)); + } + + private synchronized void fetchMissingContentFromRemotePeers( + final SlotAndBlockRoot slotAndBlockRoot) { final BlockBlobSidecarsTracker blockBlobSidecarsTracker = blockBlobSidecarsTrackers.get(slotAndBlockRoot.getBlockRoot()); @@ -562,7 +760,7 @@ private synchronized void fetchMissingContent(final SlotAndBlockRoot slotAndBloc return; } - blockBlobSidecarsTracker.setFetchTriggered(); + blockBlobSidecarsTracker.setRpcFetchTriggered(); if (blockBlobSidecarsTracker.getBlock().isEmpty()) { poolStatsCounters.labels(COUNTER_BLOCK_TYPE, COUNTER_RPC_FETCH_SUBTYPE).inc(); @@ -583,7 +781,7 @@ private synchronized void fetchMissingContent(final SlotAndBlockRoot slotAndBloc private void dropMissingContent(final BlockBlobSidecarsTracker blockBlobSidecarsTracker) { - if (!blockBlobSidecarsTracker.isFetchTriggered()) { + if (!blockBlobSidecarsTracker.isRpcFetchTriggered()) { return; } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/util/DebugDataDumper.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/util/DebugDataDumper.java new file mode 100644 index 00000000000..696c7e9e619 --- /dev/null +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/util/DebugDataDumper.java @@ -0,0 +1,67 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.statetransition.util; + +import java.util.List; +import java.util.Optional; +import java.util.function.Supplier; +import org.apache.tuweni.bytes.Bytes; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; + +public interface DebugDataDumper { + + DebugDataDumper NOOP = + new DebugDataDumper() { + @Override + public void saveGossipMessageDecodingError( + final String topic, + final Optional arrivalTimestamp, + final Supplier originalMessage, + final Throwable error) {} + + @Override + public void saveGossipRejectedMessage( + final String topic, + final Optional arrivalTimestamp, + final Supplier decodedMessage, + final Optional reason) {} + + @Override + public void saveInvalidBlock( + final SignedBeaconBlock block, + final String failureReason, + final Optional failureCause) {} + + @Override + public void saveInvalidSidecars(final List sidecars, final SignedBeaconBlock block) {} + }; + + void saveGossipMessageDecodingError( + String topic, + Optional arrivalTimestamp, + Supplier originalMessage, + Throwable error); + + void saveGossipRejectedMessage( + String topic, + Optional arrivalTimestamp, + Supplier decodedMessage, + Optional reason); + + void saveInvalidBlock( + SignedBeaconBlock block, String failureReason, Optional failureCause); + + void saveInvalidSidecars(List sidecars, SignedBeaconBlock block); +} diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/util/DebugDataFileDumper.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/util/DebugDataFileDumper.java new file mode 100644 index 00000000000..4b34df8dbb2 --- /dev/null +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/util/DebugDataFileDumper.java @@ -0,0 +1,269 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.statetransition.util; + +import static tech.pegasys.teku.infrastructure.time.SystemTimeProvider.SYSTEM_TIME_PROVIDER; + +import com.google.common.annotations.VisibleForTesting; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.NoSuchFileException; +import java.nio.file.Path; +import java.sql.Date; +import java.text.DateFormat; +import java.text.SimpleDateFormat; +import java.util.List; +import java.util.Optional; +import java.util.function.Supplier; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.apache.tuweni.bytes.Bytes; +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.infrastructure.time.TimeProvider; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; +import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSidecar; +import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; + +public class DebugDataFileDumper implements DebugDataDumper { + + private static final Logger LOG = LogManager.getLogger(); + + private static final String GOSSIP_MESSAGES_DIR = "gossip_messages"; + private static final String DECODING_ERROR_SUB_DIR = "decoding_error"; + private static final String REJECTED_SUB_DIR = "rejected"; + private static final String INVALID_BLOCK_DIR = "invalid_blocks"; + private static final String INVALID_BLOB_SIDECARS_DIR = "invalid_blob_sidecars"; + // TODO: dump other + private static final String INVALID_DATA_COLUMN_SIDECARS_DIR = "invalid_blob_sidecars"; + + private boolean enabled; + private final Path directory; + + public DebugDataFileDumper(final Path directory) { + this.enabled = true; + this.directory = directory; + + final Path gossipMessagesPath = directory.resolve(GOSSIP_MESSAGES_DIR); + createDirectory(gossipMessagesPath, GOSSIP_MESSAGES_DIR, "gossip messages"); + createDirectory( + gossipMessagesPath.resolve(DECODING_ERROR_SUB_DIR), + DECODING_ERROR_SUB_DIR, + "gossip messages with decoding errors"); + createDirectory( + gossipMessagesPath.resolve(REJECTED_SUB_DIR), REJECTED_SUB_DIR, "rejected gossip messages"); + createDirectory(directory.resolve(INVALID_BLOCK_DIR), INVALID_BLOCK_DIR, "invalid blocks"); + createDirectory( + directory.resolve(INVALID_BLOB_SIDECARS_DIR), + INVALID_BLOB_SIDECARS_DIR, + "invalid blob sidecars"); + } + + @Override + public void saveGossipMessageDecodingError( + final String topic, + final Optional arrivalTimestamp, + final Supplier originalMessage, + final Throwable error) { + if (!enabled) { + return; + } + final String formattedTimestamp = formatOptionalTimestamp(arrivalTimestamp); + final String fileName = String.format("%s.ssz", formattedTimestamp); + final Path topicPath = + Path.of(GOSSIP_MESSAGES_DIR) + .resolve(DECODING_ERROR_SUB_DIR) + .resolve(topic.replaceAll("/", "_")); + final boolean success = + saveBytesToFile( + "gossip message with decoding error", + topicPath.resolve(fileName), + originalMessage.get()); + if (success) { + LOG.warn("Failed to decode gossip message on topic {}", topic, error); + } + } + + @Override + public void saveGossipRejectedMessage( + final String topic, + final Optional arrivalTimestamp, + final Supplier decodedMessage, + final Optional reason) { + if (!enabled) { + return; + } + final String formattedTimestamp = formatOptionalTimestamp(arrivalTimestamp); + final String fileName = String.format("%s.ssz", formattedTimestamp); + final Path topicPath = + Path.of(GOSSIP_MESSAGES_DIR).resolve(REJECTED_SUB_DIR).resolve(topic.replaceAll("/", "_")); + final boolean success = + saveBytesToFile( + "rejected gossip message", topicPath.resolve(fileName), decodedMessage.get()); + if (success) { + LOG.warn( + "Rejecting gossip message on topic {}, reason: {}", + topic, + reason.orElse("failed validation")); + } + } + + @Override + public void saveInvalidBlock( + final SignedBeaconBlock block, + final String failureReason, + final Optional failureCause) { + if (!enabled) { + return; + } + final UInt64 slot = block.getSlot(); + final Bytes32 blockRoot = block.getRoot(); + final String fileName = String.format("%s_%s.ssz", slot, blockRoot.toUnprefixedHexString()); + final boolean success = + saveBytesToFile( + "invalid block", Path.of(INVALID_BLOCK_DIR).resolve(fileName), block.sszSerialize()); + if (success) { + LOG.warn( + "Rejecting invalid block at slot {} with root {}, reason: {}, cause: {}", + slot, + blockRoot, + failureReason, + failureCause.orElse(null)); + } + } + + @Override + public void saveInvalidSidecars(final List sidecars, final SignedBeaconBlock block) { + if (!enabled || sidecars.isEmpty()) { + return; + } + final String kzgCommitmentsFileName = + String.format( + "%s_%s_kzg_commitments.ssz", block.getSlot(), block.getRoot().toUnprefixedHexString()); + saveBytesToFile( + "kzg commitments", + Path.of(INVALID_BLOB_SIDECARS_DIR).resolve(kzgCommitmentsFileName), + block.getMessage().getBody().getOptionalBlobKzgCommitments().orElseThrow().sszSerialize()); + switch (sidecars.getFirst()) { + case BlobSidecar __ -> { + sidecars.forEach( + sidecar -> { + final BlobSidecar blobSidecar = (BlobSidecar) sidecar; + final UInt64 slot = blobSidecar.getSlot(); + final Bytes32 blockRoot = blobSidecar.getBlockRoot(); + final UInt64 index = blobSidecar.getIndex(); + final String fileName = + String.format("%s_%s_%s.ssz", slot, blockRoot.toUnprefixedHexString(), index); + saveBytesToFile( + "blob sidecar", + Path.of(INVALID_BLOB_SIDECARS_DIR).resolve(fileName), + blobSidecar.sszSerialize()); + }); + } + case DataColumnSidecar __ -> { + sidecars.forEach( + sidecar -> { + final DataColumnSidecar blobSidecar = (DataColumnSidecar) sidecar; + final UInt64 slot = blobSidecar.getSlot(); + final Bytes32 blockRoot = blobSidecar.getBlockRoot(); + final UInt64 index = blobSidecar.getIndex(); + final String fileName = + String.format("%s_%s_%s.ssz", slot, blockRoot.toUnprefixedHexString(), index); + saveBytesToFile( + "data column sidecar", + Path.of(INVALID_DATA_COLUMN_SIDECARS_DIR).resolve(fileName), + blobSidecar.sszSerialize()); + }); + } + default -> throw new RuntimeException("Unknown sidecar type: " + sidecars.getFirst()); + } + } + + @VisibleForTesting + boolean saveBytesToFile( + final String description, final Path relativeFilePath, final Bytes bytes) { + final Path path = directory.resolve(relativeFilePath); + try { + Files.write(path, bytes.toArray()); + } catch (NoSuchFileException e) { + return saveAfterCreatingTopicDirectory(description, path, relativeFilePath, bytes); + } catch (IOException e) { + LOG.error("Failed to save {} bytes to file.", description, e); + return false; + } + return true; + } + + private boolean saveAfterCreatingTopicDirectory( + final String description, final Path path, final Path relativeFilePath, final Bytes bytes) { + if (!path.getParent().toFile().mkdirs()) { + LOG.error( + "Failed to save {} bytes to file. No such directory {} to save file.", + description, + relativeFilePath.getParent()); + return false; + } + try { + Files.write(path, bytes.toArray()); + } catch (IOException e) { + LOG.error("Failed to save {} bytes to file.", description, e); + if (!path.getParent().toFile().exists()) { + this.enabled = false; + LOG.error( + "{} directory does not exist. Disabling saving debug data to file.", + relativeFilePath.getParent()); + } + return false; + } + return true; + } + + private void createDirectory( + final Path path, final String directoryName, final String description) { + if (!enabled) { + return; + } + if (path.toFile().mkdirs()) { + LOG.debug("{} directory has been created to save {}.", directoryName, description); + } else { + if (!path.toFile().exists()) { + this.enabled = false; + LOG.error( + "Unable to create {} directory to save {}. Disabling saving debug data to file.", + directoryName, + description); + } + } + } + + private String formatOptionalTimestamp(final Optional maybeTimestamp) { + return formatOptionalTimestamp(maybeTimestamp, SYSTEM_TIME_PROVIDER); + } + + @VisibleForTesting + String formatOptionalTimestamp( + final Optional maybeTimestamp, final TimeProvider timeProvider) { + final DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH_mm_ss.SS"); + final Date date = + maybeTimestamp + .map(timestamp -> new Date(timestamp.longValue())) + .orElse(new Date(timeProvider.getTimeInMillis().longValue())); + return df.format(date); + } + + @VisibleForTesting + boolean isEnabled() { + return enabled; + } +} diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/util/PendingPool.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/util/PendingPool.java index b6dc6a8ac58..663238fac87 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/util/PendingPool.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/util/PendingPool.java @@ -80,7 +80,7 @@ public class PendingPool extends AbstractIgnoringFutureHistoricalSlot { sizeGauge.set(0, itemType); // Init the label so it appears in metrics immediately } - public synchronized void add(T item) { + public synchronized void add(final T item) { if (shouldIgnoreItemAtSlot(targetSlotFunction.apply(item))) { // Ignore items outside of the range we care about return; @@ -128,7 +128,7 @@ public synchronized void add(T item) { orderedPendingItems.add(toSlotAndRoot(item)); } - public synchronized void remove(T item) { + public synchronized void remove(final T item) { final SlotAndRoot itemSlotAndRoot = toSlotAndRoot(item); orderedPendingItems.remove(itemSlotAndRoot); pendingItems.remove(itemSlotAndRoot.getRoot()); @@ -183,7 +183,8 @@ public synchronized Set getAllRequiredBlockRoots() { * {@code includeIndirectDependents} is {@code false}, only item A is returned. * @return The list of items which depend on the given block root. */ - public List getItemsDependingOn(final Bytes32 blockRoot, boolean includeIndirectDependents) { + public List getItemsDependingOn( + final Bytes32 blockRoot, final boolean includeIndirectDependents) { if (includeIndirectDependents) { return getAllItemsDependingOn(blockRoot); } else { diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/util/PoolFactory.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/util/PoolFactory.java index baf75f2d03a..bd047c0c84f 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/util/PoolFactory.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/util/PoolFactory.java @@ -15,19 +15,25 @@ import com.google.common.annotations.VisibleForTesting; import java.util.Collections; +import java.util.function.Function; +import java.util.function.Supplier; import org.hyperledger.besu.plugin.services.MetricsSystem; import org.hyperledger.besu.plugin.services.metrics.Counter; import org.hyperledger.besu.plugin.services.metrics.LabelledMetric; import tech.pegasys.teku.infrastructure.async.AsyncRunner; +import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.metrics.SettableLabelledGauge; import tech.pegasys.teku.infrastructure.metrics.TekuMetricCategory; import tech.pegasys.teku.infrastructure.time.TimeProvider; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; +import tech.pegasys.teku.spec.executionlayer.ExecutionLayerChannel; import tech.pegasys.teku.statetransition.blobs.BlockBlobSidecarsTrackerFactory; import tech.pegasys.teku.statetransition.block.BlockImportChannel; +import tech.pegasys.teku.statetransition.validation.BlobSidecarGossipValidator; import tech.pegasys.teku.storage.client.RecentChainData; public class PoolFactory { @@ -63,7 +69,7 @@ public PoolFactory(final MetricsSystem metricsSystem) { this.blockBlobSidecarsTrackersPoolStats = metricsSystem.createLabelledCounter( TekuMetricCategory.BEACON, - "block_blobs_trackers_pool_stats", + "block_blobs_trackers_pool_stats_total", "Block-blobs trackers pool statistics", "type", "subtype"); @@ -112,13 +118,19 @@ public BlockBlobSidecarsTrackersPoolImpl createPoolForBlockBlobSidecarsTrackers( final Spec spec, final TimeProvider timeProvider, final AsyncRunner asyncRunner, - final RecentChainData recentChainData) { + final RecentChainData recentChainData, + final ExecutionLayerChannel executionLayer, + final Supplier gossipValidatorSupplier, + final Function> blobSidecarGossipPublisher) { return createPoolForBlockBlobSidecarsTrackers( blockImportChannel, spec, timeProvider, asyncRunner, recentChainData, + executionLayer, + gossipValidatorSupplier, + blobSidecarGossipPublisher, DEFAULT_HISTORICAL_SLOT_TOLERANCE, FutureItems.DEFAULT_FUTURE_SLOT_TOLERANCE, DEFAULT_MAX_BLOCKS); @@ -130,6 +142,9 @@ public BlockBlobSidecarsTrackersPoolImpl createPoolForBlockBlobSidecarsTrackers( final TimeProvider timeProvider, final AsyncRunner asyncRunner, final RecentChainData recentChainData, + final ExecutionLayerChannel executionLayer, + final Supplier gossipValidatorSupplier, + final Function> blobSidecarGossipPublisher, final UInt64 historicalBlockTolerance, final UInt64 futureBlockTolerance, final int maxTrackers) { @@ -141,6 +156,9 @@ public BlockBlobSidecarsTrackersPoolImpl createPoolForBlockBlobSidecarsTrackers( timeProvider, asyncRunner, recentChainData, + executionLayer, + gossipValidatorSupplier, + blobSidecarGossipPublisher, historicalBlockTolerance, futureBlockTolerance, maxTrackers); @@ -153,6 +171,9 @@ BlockBlobSidecarsTrackersPoolImpl createPoolForBlockBlobSidecarsTrackers( final TimeProvider timeProvider, final AsyncRunner asyncRunner, final RecentChainData recentChainData, + final ExecutionLayerChannel executionLayer, + final Supplier gossipValidatorSupplier, + final Function> blobSidecarGossipPublisher, final UInt64 historicalBlockTolerance, final UInt64 futureBlockTolerance, final int maxItems, @@ -165,6 +186,9 @@ BlockBlobSidecarsTrackersPoolImpl createPoolForBlockBlobSidecarsTrackers( timeProvider, asyncRunner, recentChainData, + executionLayer, + gossipValidatorSupplier, + blobSidecarGossipPublisher, historicalBlockTolerance, futureBlockTolerance, maxItems, diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/AggregateAttestationValidator.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/AggregateAttestationValidator.java index 282ac4474eb..502f597d9a5 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/AggregateAttestationValidator.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/AggregateAttestationValidator.java @@ -166,7 +166,7 @@ private SafeFuture verifyAggregate( } final IntList beaconCommittee = - spec.getBeaconCommittee(state, aggregateSlot, aggregate.getData().getIndex()); + spec.getBeaconCommittee(state, aggregateSlot, aggregate.getFirstCommitteeIndex()); final int aggregatorModulo = specVersion.getValidatorsUtil().getAggregatorModulo(beaconCommittee.size()); diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/AttestationStateSelector.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/AttestationStateSelector.java index 1304931c687..624c42bc142 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/AttestationStateSelector.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/AttestationStateSelector.java @@ -42,7 +42,7 @@ public class AttestationStateSelector { private final LabelledMetric appliedSelectorRule; public AttestationStateSelector( - final Spec spec, final RecentChainData recentChainData, MetricsSystem metricsSystem) { + final Spec spec, final RecentChainData recentChainData, final MetricsSystem metricsSystem) { this.spec = spec; this.recentChainData = recentChainData; diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/AttestationValidator.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/AttestationValidator.java index d5e50a1757e..f652f597585 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/AttestationValidator.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/AttestationValidator.java @@ -118,6 +118,23 @@ SafeFuture singleOrAggregateAttestationChecks return completedFuture(InternalValidationResultWithState.saveForFuture()); } + if (attestation.requiresCommitteeBits()) { + // [REJECT] len(committee_indices) == 1, where committee_indices = + // get_committee_indices(attestation) + if (attestation.getCommitteeBitsRequired().getBitCount() != 1) { + return SafeFuture.completedFuture( + InternalValidationResultWithState.reject( + "Rejecting attestation because committee bits count is not 1")); + } + + // [REJECT] attestation.data.index == 0 + if (!attestation.getData().getIndex().isZero()) { + return SafeFuture.completedFuture( + InternalValidationResultWithState.reject( + "Rejecting attestation because attestation data index must be 0")); + } + } + return stateSelector .getStateToValidate(attestation.getData()) .thenCompose( @@ -130,7 +147,8 @@ SafeFuture singleOrAggregateAttestationChecks final BeaconState state = maybeState.get(); // The committee index is within the expected range - if (data.getIndex() + if (attestation + .getFirstCommitteeIndex() .isGreaterThanOrEqualTo( spec.getCommitteeCountPerSlot(state, data.getTarget().getEpoch()))) { return completedFuture( @@ -146,12 +164,13 @@ SafeFuture singleOrAggregateAttestationChecks return completedFuture( InternalValidationResultWithState.reject( "Attestation received on incorrect subnet (%s) for specified committee index (%s)", - attestation.getData().getIndex(), receivedOnSubnetId.getAsInt())); + attestation.getFirstCommitteeIndex(), receivedOnSubnetId.getAsInt())); } // [REJECT] The number of aggregation bits matches the committee size final IntList committee = - spec.getBeaconCommittee(state, data.getSlot(), data.getIndex()); + spec.getBeaconCommittee( + state, data.getSlot(), attestation.getFirstCommitteeIndex()); if (committee.size() != attestation.getAggregationBits().size()) { return completedFuture( InternalValidationResultWithState.reject( @@ -190,7 +209,7 @@ SafeFuture singleOrAggregateAttestationChecks // Save committee shuffling seed since the state is available and // attestation is valid - validatableAttestation.saveCommitteeShufflingSeed(state); + validatableAttestation.saveCommitteeShufflingSeedAndCommitteesSize(state); return InternalValidationResultWithState.accept(state); }); }); diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/AttesterSlashingValidator.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/AttesterSlashingValidator.java index c61db084fd7..711c0340b7e 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/AttesterSlashingValidator.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/AttesterSlashingValidator.java @@ -36,13 +36,13 @@ public class AttesterSlashingValidator implements OperationValidator seenIndices = LimitedSet.createSynchronized(VALID_VALIDATOR_SET_SIZE); private final Spec spec; - public AttesterSlashingValidator(RecentChainData recentChainData, final Spec spec) { + public AttesterSlashingValidator(final RecentChainData recentChainData, final Spec spec) { this.recentChainData = recentChainData; this.spec = spec; } @Override - public SafeFuture validateForGossip(AttesterSlashing slashing) { + public SafeFuture validateForGossip(final AttesterSlashing slashing) { if (!includesUnseenIndexToSlash(slashing.getIntersectingValidatorIndices())) { LOG.trace("AttesterSlashingValidator: Slashing is not the first one for any validator."); return SafeFuture.completedFuture(InternalValidationResult.IGNORE); @@ -75,7 +75,7 @@ public Optional validateForBlockInclusion( return spec.validateAttesterSlashing(stateAtBlockSlot, slashing); } - private boolean includesUnseenIndexToSlash(Set intersectingIndices) { + private boolean includesUnseenIndexToSlash(final Set intersectingIndices) { return !seenIndices.containsAll(intersectingIndices); } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/BlobSidecarGossipValidator.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/BlobSidecarGossipValidator.java index e64df5a44f9..9baad8da958 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/BlobSidecarGossipValidator.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/BlobSidecarGossipValidator.java @@ -33,6 +33,7 @@ import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.kzg.KZG; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.config.SpecConfigDeneb; import tech.pegasys.teku.spec.constants.Domain; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlockHeader; @@ -63,7 +64,7 @@ public static BlobSidecarGossipValidator create( final MiscHelpersDeneb miscHelpersDeneb, final KZG kzg) { - final Optional maybeMaxBlobsPerBlock = spec.getMaxBlobsPerBlock(); + final Optional maybeMaxBlobsPerBlock = spec.getMaxBlobsPerBlockForHighestMilestone(); final int validInfoSize = VALID_BLOCK_SET_SIZE * maybeMaxBlobsPerBlock.orElse(1); // It's not fatal if we miss something and we don't need finalized data @@ -119,7 +120,10 @@ public SafeFuture validate(final BlobSidecar blobSidec * [REJECT] The sidecar's index is consistent with `MAX_BLOBS_PER_BLOCK` -- i.e. `blob_sidecar.index < MAX_BLOBS_PER_BLOCK`. */ final Optional maxBlobsPerBlockAtSlot = - spec.getMaxBlobsPerBlock(blobSidecar.getSlot()); + spec.atSlot(blobSidecar.getSlot()) + .getConfig() + .toVersionDeneb() + .map(SpecConfigDeneb::getMaxBlobsPerBlock); if (maxBlobsPerBlockAtSlot.isEmpty()) { return completedFuture(reject("BlobSidecar's slot is pre-Deneb")); } @@ -262,11 +266,7 @@ public SafeFuture validate(final BlobSidecar blobSidec * [IGNORE] The sidecar is the first sidecar for the tuple (block_header.slot, block_header.proposer_index, blob_sidecar.index) * with valid header signature, sidecar inclusion proof, and kzg proof. */ - if (!receivedValidBlobSidecarInfoSet.add( - new SlotProposerIndexAndBlobIndex( - blockHeader.getSlot(), - blockHeader.getProposerIndex(), - blobSidecar.getIndex()))) { + if (!markForEquivocation(blockHeader, blobSidecar.getIndex())) { return ignore( "BlobSidecar is not the first valid for its slot and index. It will be dropped."); } @@ -277,6 +277,17 @@ public SafeFuture validate(final BlobSidecar blobSidec }); } + private boolean markForEquivocation(final BeaconBlockHeader blockHeader, final UInt64 index) { + return receivedValidBlobSidecarInfoSet.add( + new SlotProposerIndexAndBlobIndex( + blockHeader.getSlot(), blockHeader.getProposerIndex(), index)); + } + + public boolean markForEquivocation(final BlobSidecar blobSidecar) { + return markForEquivocation( + blobSidecar.getSignedBeaconBlockHeader().getMessage(), blobSidecar.getIndex()); + } + private SafeFuture validateBlobSidecarWithKnownValidHeader( final BlobSidecar blobSidecar, final BeaconBlockHeader blockHeader) { @@ -310,9 +321,7 @@ private SafeFuture validateBlobSidecarWithKnownValidHe * [IGNORE] The sidecar is the first sidecar for the tuple (block_header.slot, block_header.proposer_index, blob_sidecar.index) * with valid header signature, sidecar inclusion proof, and kzg proof. */ - if (!receivedValidBlobSidecarInfoSet.add( - new SlotProposerIndexAndBlobIndex( - blockHeader.getSlot(), blockHeader.getProposerIndex(), blobSidecar.getIndex()))) { + if (!markForEquivocation(blockHeader, blobSidecar.getIndex())) { return SafeFuture.completedFuture( ignore("BlobSidecar is not the first valid for its slot and index. It will be dropped.")); } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/BlockBroadcastValidator.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/BlockBroadcastValidator.java index efb79326e34..f4ec4e7dfdc 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/BlockBroadcastValidator.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/BlockBroadcastValidator.java @@ -58,7 +58,7 @@ enum BroadcastValidationResult { SUCCESS, GOSSIP_FAILURE, CONSENSUS_FAILURE, - FINAL_EQUIVOCATION_FAILURE; + EQUIVOCATION_FAILURE; public boolean isFailure() { return this != SUCCESS; diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/BlockBroadcastValidatorImpl.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/BlockBroadcastValidatorImpl.java index 4b9c9b5ea1e..cc1f2d7bb2e 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/BlockBroadcastValidatorImpl.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/BlockBroadcastValidatorImpl.java @@ -13,10 +13,12 @@ package tech.pegasys.teku.statetransition.validation; +import static tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel.CONSENSUS_AND_EQUIVOCATION; +import static tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel.EQUIVOCATION; import static tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel.GOSSIP; import static tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel.NOT_REQUIRED; import static tech.pegasys.teku.statetransition.validation.BlockBroadcastValidator.BroadcastValidationResult.CONSENSUS_FAILURE; -import static tech.pegasys.teku.statetransition.validation.BlockBroadcastValidator.BroadcastValidationResult.FINAL_EQUIVOCATION_FAILURE; +import static tech.pegasys.teku.statetransition.validation.BlockBroadcastValidator.BroadcastValidationResult.EQUIVOCATION_FAILURE; import static tech.pegasys.teku.statetransition.validation.BlockBroadcastValidator.BroadcastValidationResult.GOSSIP_FAILURE; import static tech.pegasys.teku.statetransition.validation.BlockBroadcastValidator.BroadcastValidationResult.SUCCESS; @@ -26,7 +28,7 @@ import tech.pegasys.teku.spec.logic.common.statetransition.results.BlockImportResult; import tech.pegasys.teku.statetransition.validation.BlockGossipValidator.EquivocationCheckResult; -public class BlockBroadcastValidatorImpl implements BlockBroadcastValidator { +class BlockBroadcastValidatorImpl implements BlockBroadcastValidator { private final BlockGossipValidator blockGossipValidator; private final BroadcastValidationLevel broadcastValidationLevel; private final SafeFuture consensusValidationSuccessResult; @@ -41,7 +43,7 @@ private BlockBroadcastValidatorImpl( this.broadcastValidationResult = new SafeFuture<>(); } - public static BlockBroadcastValidatorImpl create( + static BlockBroadcastValidatorImpl create( final SignedBeaconBlock block, final BlockGossipValidator blockGossipValidator, final BroadcastValidationLevel broadcastValidationLevel) { @@ -59,10 +61,10 @@ public void onConsensusValidationSucceeded() { @Override public void attachToBlockImport(final SafeFuture blockImportResult) { switch (broadcastValidationLevel) { - case NOT_REQUIRED, GOSSIP: - // GOSSIP validation isn't dependent on block import result, + case NOT_REQUIRED, EQUIVOCATION, GOSSIP: + // EQUIVOCATION/GOSSIP validation isn't dependent on block import result, // so not propagating exceptions to consensusValidationSuccessResult allow blocks\blobs - // to be published even in case block import fails before gossip validation completes + // to be published even in case block import fails before the validation completes return; case CONSENSUS, CONSENSUS_AND_EQUIVOCATION: // Any successful block import will be considered as a consensus validation success, but @@ -80,17 +82,36 @@ public SafeFuture getResult() { } private void buildValidationPipeline(final SignedBeaconBlock block) { - // validateBroadcast should not be called at all but let's cover the case for safety + // NOT_REQUIRED should use the NOOP implementation but let's cover the case for safety if (broadcastValidationLevel == NOT_REQUIRED) { broadcastValidationResult.complete(SUCCESS); consensusValidationSuccessResult.cancel(true); return; } - // GOSSIP only validation + // EQUIVOCATION only validation + if (broadcastValidationLevel == EQUIVOCATION) { + final BroadcastValidationResult validationResult; + // marking the block as received because gossip validation won't be done + if (isEquivocatingBlock(block, true)) { + validationResult = EQUIVOCATION_FAILURE; + } else { + validationResult = SUCCESS; + } + broadcastValidationResult.complete(validationResult); + consensusValidationSuccessResult.cancel(true); + return; + } + + // We will skip marking the block as received when CONSENSUS_EQUIVOCATION level is chosen. This + // is because we will perform an additional equivocation check after the block import where it + // will be marked as received + final boolean markAsReceived = broadcastValidationLevel != CONSENSUS_AND_EQUIVOCATION; + + // GOSSIP only validation (includes EQUIVOCATION validation) SafeFuture validationPipeline = blockGossipValidator - .validate(block, true) + .validate(block, markAsReceived) .thenApply( gossipValidationResult -> { if (gossipValidationResult.isAccept() @@ -128,7 +149,7 @@ private void buildValidationPipeline(final SignedBeaconBlock block) { return; } - // GOSSIP, CONSENSUS and additional EQUIVOCATION validation + // GOSSIP, CONSENSUS and final EQUIVOCATION validation at the end validationPipeline .thenApply( broadcastValidationResult -> { @@ -136,16 +157,20 @@ private void buildValidationPipeline(final SignedBeaconBlock block) { // forward gossip or consensus validation failure return broadcastValidationResult; } - - // perform final equivocation validation - if (blockGossipValidator - .performBlockEquivocationCheck(block) - .equals(EquivocationCheckResult.EQUIVOCATING_BLOCK_FOR_SLOT_PROPOSER)) { - return FINAL_EQUIVOCATION_FAILURE; + // we didn't initially mark it as received, so doing it at this final equivocation + // check + if (isEquivocatingBlock(block, true)) { + return EQUIVOCATION_FAILURE; } return SUCCESS; }) .propagateTo(broadcastValidationResult); } + + private boolean isEquivocatingBlock(final SignedBeaconBlock block, final boolean markAsReceived) { + return blockGossipValidator + .performBlockEquivocationCheck(markAsReceived, block) + .equals(EquivocationCheckResult.EQUIVOCATING_BLOCK_FOR_SLOT_PROPOSER); + } } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/BlockGossipValidator.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/BlockGossipValidator.java index f6eda8e336e..1038dc57efa 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/BlockGossipValidator.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/BlockGossipValidator.java @@ -47,7 +47,7 @@ public class BlockGossipValidator { private final GossipValidationHelper gossipValidationHelper; private final ReceivedBlockEventsChannel receivedBlockEventsChannelPublisher; - private final Map receivedValidBlockInfoSet = + private final Map receivedValidBlockRoots = LimitedMap.createNonSynchronized(VALID_BLOCK_SET_SIZE); public BlockGossipValidator( @@ -63,12 +63,12 @@ public BlockGossipValidator( * Perform gossip validation on a block. * * @param block the block to validate - * @param isLocallyProduced whether the block was produced locally or received from gossip. The - * locally produced flow applies only during broadcast validation. + * @param markAsReceived whether to mark the block as received if it is valid (required for the + * equivocation check) */ public SafeFuture validate( - final SignedBeaconBlock block, final boolean isLocallyProduced) { - return internalValidate(block, isLocallyProduced) + final SignedBeaconBlock block, final boolean markAsReceived) { + return internalValidate(block, markAsReceived) .thenPeek( result -> { if (result.isAccept()) { @@ -78,7 +78,7 @@ public SafeFuture validate( } private SafeFuture internalValidate( - final SignedBeaconBlock block, final boolean isLocallyProduced) { + final SignedBeaconBlock block, final boolean markAsReceived) { if (gossipValidationHelper.isSlotFinalized(block.getSlot())) { LOG.trace("BlockValidator: Block is too old. It will be dropped"); @@ -86,7 +86,8 @@ private SafeFuture internalValidate( } final InternalValidationResult intermediateValidationResult = - equivocationCheckResultToInternalValidationResult(performBlockEquivocationCheck(block)); + equivocationCheckResultToInternalValidationResult( + performBlockEquivocationCheck(false, block)); if (!intermediateValidationResult.isAccept()) { return completedFuture(intermediateValidationResult); @@ -165,16 +166,8 @@ private SafeFuture internalValidate( return reject("Block signature is invalid"); } - // We want to add blocks in the infoSet only when they come from gossip. - // When dealing with locally produced block, we only want to check them against seen - // block coming from gossip because we may have to do two equivocation checks if - // BroadcastValidationLevel.CONSENSUS_EQUIVOCATION is used (one at the beginning of - // the blocks import, - // another after consensus validation) final EquivocationCheckResult secondEquivocationCheckResult = - isLocallyProduced - ? performBlockEquivocationCheck(false, block) - : performBlockEquivocationCheck(true, block); + performBlockEquivocationCheck(markAsReceived, block); return equivocationCheckResultToInternalValidationResult( secondEquivocationCheckResult); @@ -185,37 +178,34 @@ private InternalValidationResult equivocationCheckResultToInternalValidationResu final EquivocationCheckResult equivocationCheckResult) { return switch (equivocationCheckResult) { case FIRST_BLOCK_FOR_SLOT_PROPOSER -> InternalValidationResult.ACCEPT; - case EQUIVOCATING_BLOCK_FOR_SLOT_PROPOSER -> ignore( - IGNORE_EQUIVOCATION_DETECTED, "Equivocating block detected. It will be dropped."); - case BLOCK_ALREADY_SEEN_FOR_SLOT_PROPOSER -> ignore( - IGNORE_ALREADY_SEEN, - "Block is not the first with valid signature for its slot. It will be dropped."); + case EQUIVOCATING_BLOCK_FOR_SLOT_PROPOSER -> + ignore(IGNORE_EQUIVOCATION_DETECTED, "Equivocating block detected. It will be dropped."); + case BLOCK_ALREADY_SEEN_FOR_SLOT_PROPOSER -> + ignore( + IGNORE_ALREADY_SEEN, + "Block is not the first with valid signature for its slot. It will be dropped."); }; } - private synchronized EquivocationCheckResult performBlockEquivocationCheck( - final boolean add, final SignedBeaconBlock block) { + synchronized EquivocationCheckResult performBlockEquivocationCheck( + final boolean markAsReceived, final SignedBeaconBlock block) { final SlotAndProposer slotAndProposer = new SlotAndProposer(block); - - final Optional maybePreviouslySeenBlockRoot = - Optional.ofNullable(receivedValidBlockInfoSet.get(slotAndProposer)); - - if (maybePreviouslySeenBlockRoot.isEmpty()) { - if (add) { - receivedValidBlockInfoSet.put(slotAndProposer, block.getRoot()); - } - return FIRST_BLOCK_FOR_SLOT_PROPOSER; - } - - if (maybePreviouslySeenBlockRoot.get().equals(block.getRoot())) { - return BLOCK_ALREADY_SEEN_FOR_SLOT_PROPOSER; - } - - return EQUIVOCATING_BLOCK_FOR_SLOT_PROPOSER; - } - - EquivocationCheckResult performBlockEquivocationCheck(final SignedBeaconBlock block) { - return performBlockEquivocationCheck(false, block); + final Bytes32 blockRoot = block.getRoot(); + return Optional.ofNullable(receivedValidBlockRoots.get(slotAndProposer)) + .map( + previouslySeenBlockRoot -> { + if (previouslySeenBlockRoot.equals(blockRoot)) { + return BLOCK_ALREADY_SEEN_FOR_SLOT_PROPOSER; + } + return EQUIVOCATING_BLOCK_FOR_SLOT_PROPOSER; + }) + .orElseGet( + () -> { + if (markAsReceived) { + receivedValidBlockRoots.put(slotAndProposer, blockRoot); + } + return FIRST_BLOCK_FOR_SLOT_PROPOSER; + }); } public enum EquivocationCheckResult { diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/BlockValidator.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/BlockValidator.java index fca77880c42..1d22a2046f6 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/BlockValidator.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/BlockValidator.java @@ -26,7 +26,7 @@ public BlockValidator(final BlockGossipValidator blockGossipValidator) { } public SafeFuture validateGossip(final SignedBeaconBlock block) { - return blockGossipValidator.validate(block, false); + return blockGossipValidator.validate(block, true); } public BlockBroadcastValidator initiateBroadcastValidation( diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/DataColumnSidecarGossipValidator.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/DataColumnSidecarGossipValidator.java index 3e0f7434b8e..0c558941149 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/DataColumnSidecarGossipValidator.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/DataColumnSidecarGossipValidator.java @@ -42,7 +42,7 @@ import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockHeader; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.logic.common.statetransition.results.BlockImportResult; -import tech.pegasys.teku.spec.logic.versions.eip7594.helpers.MiscHelpersEip7594; +import tech.pegasys.teku.spec.logic.versions.feature.eip7594.helpers.MiscHelpersEip7594; /** * This class supposed to implement gossip validation rules as per receivedValidSlashingForProposerSet = LimitedSet.createSynchronized(VALID_VALIDATOR_SET_SIZE); - public ProposerSlashingValidator(final Spec spec, RecentChainData recentChainData) { + public ProposerSlashingValidator(final Spec spec, final RecentChainData recentChainData) { this.spec = spec; this.recentChainData = recentChainData; } @Override - public SafeFuture validateForGossip(ProposerSlashing slashing) { + public SafeFuture validateForGossip(final ProposerSlashing slashing) { if (!isFirstValidSlashingForValidator(slashing)) { LOG.trace( "ProposerSlashingValidator: Slashing is not the first one for the given validator."); @@ -83,7 +83,7 @@ public Optional validateForBlockInclusion( } private SafeFuture> passesProcessProposerSlashingConditions( - ProposerSlashing slashing) { + final ProposerSlashing slashing) { return getState() .thenApply( state -> { @@ -105,7 +105,7 @@ private Optional verifySignature( return Optional.empty(); } - private boolean isFirstValidSlashingForValidator(ProposerSlashing slashing) { + private boolean isFirstValidSlashingForValidator(final ProposerSlashing slashing) { return !receivedValidSlashingForProposerSet.contains( slashing.getHeader1().getMessage().getProposerIndex()); } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/SignedBlsToExecutionChangeValidator.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/SignedBlsToExecutionChangeValidator.java index 05b3e84837d..12c2065da58 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/SignedBlsToExecutionChangeValidator.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/SignedBlsToExecutionChangeValidator.java @@ -110,7 +110,7 @@ private InternalValidationResult processValidationResults( @SuppressWarnings("FormatStringAnnotation") private SafeFuture validateBlsMessage( - BeaconState state, BlsToExecutionChange operation) { + final BeaconState state, final BlsToExecutionChange operation) { return spec.validateBlsToExecutionChange(state, timeProvider.getTimeInSeconds(), operation) .map(reason -> reject(reason.describe())) .map(SafeFuture::completedFuture) @@ -118,7 +118,7 @@ private SafeFuture validateBlsMessage( } private SafeFuture validateBlsMessageSignature( - BeaconState state, SignedBlsToExecutionChange operation) { + final BeaconState state, final SignedBlsToExecutionChange operation) { return spec.atSlot(state.getSlot()) .operationSignatureVerifier() .verifyBlsToExecutionChangeSignatureAsync(state, operation, blsSignatureVerifier) diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/VoluntaryExitValidator.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/VoluntaryExitValidator.java index c5bb1fafb99..1119b32251b 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/VoluntaryExitValidator.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/VoluntaryExitValidator.java @@ -40,13 +40,13 @@ public class VoluntaryExitValidator implements OperationValidator receivedValidExitSet = LimitedSet.createSynchronized(VALID_VALIDATOR_SET_SIZE); - public VoluntaryExitValidator(final Spec spec, RecentChainData recentChainData) { + public VoluntaryExitValidator(final Spec spec, final RecentChainData recentChainData) { this.spec = spec; this.recentChainData = recentChainData; } @Override - public SafeFuture validateForGossip(SignedVoluntaryExit exit) { + public SafeFuture validateForGossip(final SignedVoluntaryExit exit) { if (!isFirstValidExitForValidator(exit)) { LOG.trace( "VoluntaryExitValidator: Exit is not the first one for validator {}.", @@ -89,7 +89,8 @@ public Optional validateForBlockInclusion( return getFailureReason(stateAtBlockSlot, exit); } - private SafeFuture> getFailureReason(SignedVoluntaryExit exit) { + private SafeFuture> getFailureReason( + final SignedVoluntaryExit exit) { return getState().thenApply(state -> getFailureReason(state, exit)); } @@ -106,7 +107,7 @@ private Optional getFailureReason( return Optional.empty(); } - private boolean isFirstValidExitForValidator(SignedVoluntaryExit exit) { + private boolean isFirstValidExitForValidator(final SignedVoluntaryExit exit) { return !receivedValidExitSet.contains(exit.getMessage().getValidatorIndex()); } diff --git a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/signatures/AggregatingSignatureVerificationService.java b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/signatures/AggregatingSignatureVerificationService.java index 03f12054483..27b0281fc0b 100644 --- a/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/signatures/AggregatingSignatureVerificationService.java +++ b/ethereum/statetransition/src/main/java/tech/pegasys/teku/statetransition/validation/signatures/AggregatingSignatureVerificationService.java @@ -81,12 +81,12 @@ public class AggregatingSignatureVerificationService extends SignatureVerificati batchCounter = metricsSystem.createCounter( TekuMetricCategory.EXECUTOR, - "signature_verifications_batch_count", + "signature_verifications_batch_count_total", "Reports the number of verification batches processed"); taskCounter = metricsSystem.createCounter( TekuMetricCategory.EXECUTOR, - "signature_verifications_task_count", + "signature_verifications_task_count_total", "Reports the number of individual verification tasks processed"); batchSizeHistogram = MetricsQuantileHistogram.create( diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/EpochCachePrimerTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/EpochCachePrimerTest.java index 66cb0278ecb..f5bbaa1c10b 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/EpochCachePrimerTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/EpochCachePrimerTest.java @@ -142,21 +142,15 @@ void shouldComputeCommitteesForMaxLookAheadEpoch() { final BeaconState state = getStateForEpoch(epoch); final UInt64 lookaheadEpoch = epoch.plus(1); forEachSlotInEpoch( - lookaheadEpoch, - slot -> - UInt64.range(UInt64.ZERO, realSpec.getCommitteeCountPerSlot(state, lookaheadEpoch)) - .forEach( - committeeIndex -> - verify(mockSpec).getBeaconCommittee(state, slot, committeeIndex))); + lookaheadEpoch, slot -> verify(mockSpec).getBeaconCommitteesSize(state, slot)); final UInt64 firstSlotAfterLookAheadPeriod = realSpec.computeStartSlotAtEpoch(lookaheadEpoch.plus(1)); // Should not precalculate beyond the end of the look ahead period verify(mockSpec, never()) - .getBeaconCommittee( + .getBeaconCommitteesSize( any(), - argThat(argument -> argument.isGreaterThanOrEqualTo(firstSlotAfterLookAheadPeriod)), - any()); + argThat(argument -> argument.isGreaterThanOrEqualTo(firstSlotAfterLookAheadPeriod))); } @Test diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/OperationPoolEntryTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/OperationPoolEntryTest.java index 9b0a9c5aba7..63f5529f246 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/OperationPoolEntryTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/OperationPoolEntryTest.java @@ -21,7 +21,6 @@ import org.junit.jupiter.api.Test; import tech.pegasys.teku.infrastructure.bytes.Bytes4; import tech.pegasys.teku.infrastructure.ssz.impl.AbstractSszPrimitive; -import tech.pegasys.teku.infrastructure.ssz.primitive.SszBytes4; import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; import tech.pegasys.teku.infrastructure.time.StubTimeProvider; import tech.pegasys.teku.infrastructure.time.TimeProvider; @@ -32,7 +31,7 @@ public class OperationPoolEntryTest { private final TestClass b1 = TestClass.of(Bytes4.fromHexString("0xFFFFFF11")); private final TestClass b2 = TestClass.of(Bytes4.fromHexString("0xFFFFFF22")); - private TimeProvider timeProvider = StubTimeProvider.withTimeInSeconds(1_000_000); + private final TimeProvider timeProvider = StubTimeProvider.withTimeInSeconds(1_000_000); @Test void shouldSortLocalFirst() { @@ -47,7 +46,7 @@ void shouldSortLocalFirst() { .containsExactly(b2, b1, b0); } - private static class TestClass extends AbstractSszPrimitive + private static class TestClass extends AbstractSszPrimitive implements MessageWithValidatorId { TestClass(final Bytes4 b) { diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/OperationsReOrgManagerTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/OperationsReOrgManagerTest.java index fa477c03760..921696f1cbb 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/OperationsReOrgManagerTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/OperationsReOrgManagerTest.java @@ -26,7 +26,6 @@ import java.util.NavigableMap; import java.util.Optional; import java.util.TreeMap; -import java.util.stream.Collectors; import org.apache.tuweni.bytes.Bytes32; import org.junit.jupiter.api.Test; import org.mockito.ArgumentCaptor; @@ -148,11 +147,11 @@ void shouldRequeueAndRemoveOperations() { attestationList.addAll( fork1Block1.getBody().getAttestations().stream() .map(attestation -> ValidatableAttestation.from(spec, attestation)) - .collect(Collectors.toList())); + .toList()); attestationList.addAll( fork1Block2.getBody().getAttestations().stream() .map(attestation -> ValidatableAttestation.from(spec, attestation)) - .collect(Collectors.toList())); + .toList()); assertThat(argument.getAllValues()) .containsExactlyInAnyOrderElementsOf(attestationList) .allMatch(ValidatableAttestation::isValidIndexedAttestation); diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/attestation/AggregateAttestationBuilderTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/attestation/AggregateAttestationBuilderTest.java index f62125988d4..3f4679dec83 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/attestation/AggregateAttestationBuilderTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/attestation/AggregateAttestationBuilderTest.java @@ -24,8 +24,8 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; import tech.pegasys.teku.spec.util.DataStructureUtil; class AggregateAttestationBuilderTest { @@ -33,7 +33,7 @@ class AggregateAttestationBuilderTest { public static final int BITLIST_SIZE = 10; private final Spec spec = TestSpecFactory.createDefault(); private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); - private final AttestationSchema attestationSchema = + private final AttestationSchema attestationSchema = spec.getGenesisSchemaDefinitions().getAttestationSchema(); private final AttestationData attestationData = dataStructureUtil.randomAttestationData(); @@ -42,19 +42,19 @@ class AggregateAttestationBuilderTest { @Test public void canAggregate_shouldBeTrueForFirstAttestation() { - assertThat(builder.canAggregate(createAttestation(1, 2, 3, 4, 5, 6, 7, 8, 9))).isTrue(); + assertThat(builder.aggregate(createAttestation(1, 2, 3, 4, 5, 6, 7, 8, 9))).isTrue(); } @Test public void canAggregate_shouldBeTrueWhenValidatorsDoNotOverlap() { builder.aggregate(createAttestation(1, 3, 5)); - assertThat(builder.canAggregate(createAttestation(0, 2, 4))).isTrue(); + assertThat(builder.aggregate(createAttestation(0, 2, 4))).isTrue(); } @Test public void canAggregate_shouldBeFalseWhenValidatorsDoOverlap() { builder.aggregate(createAttestation(1, 3, 5)); - assertThat(builder.canAggregate(createAttestation(1, 2, 4))).isFalse(); + assertThat(builder.aggregate(createAttestation(1, 2, 4))).isFalse(); } @Test diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/attestation/AggregatingAttestationPoolTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/attestation/AggregatingAttestationPoolTest.java index 51537cd041a..05d82c5c265 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/attestation/AggregatingAttestationPoolTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/attestation/AggregatingAttestationPoolTest.java @@ -14,53 +14,98 @@ package tech.pegasys.teku.statetransition.attestation; import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assumptions.assumeThat; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ONE; import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ZERO; +import static tech.pegasys.teku.spec.SpecMilestone.ELECTRA; +import static tech.pegasys.teku.spec.SpecMilestone.PHASE0; import static tech.pegasys.teku.statetransition.attestation.AggregatingAttestationPool.ATTESTATION_RETENTION_SLOTS; import static tech.pegasys.teku.statetransition.attestation.AggregatingAttestationPool.DEFAULT_MAXIMUM_ATTESTATION_COUNT; import static tech.pegasys.teku.statetransition.attestation.AggregatorUtil.aggregateAttestations; +import it.unimi.dsi.fastutil.ints.Int2IntMap; +import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap; import java.util.ArrayList; import java.util.List; import java.util.Optional; +import java.util.function.Supplier; +import java.util.stream.IntStream; import org.hyperledger.besu.metrics.noop.NoOpMetricsSystem; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestTemplate; import org.mockito.ArgumentMatchers; import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecContext; import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider; import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.logic.common.operations.validation.AttestationDataValidator.AttestationInvalidReason; import tech.pegasys.teku.spec.util.DataStructureUtil; +import tech.pegasys.teku.storage.client.RecentChainData; +import tech.pegasys.teku.storage.store.UpdatableStore; +@TestSpecContext(milestone = {PHASE0, ELECTRA}) class AggregatingAttestationPoolTest { public static final UInt64 SLOT = UInt64.valueOf(1234); + private static final int COMMITTEE_SIZE = 20; - private final Spec spec = TestSpecFactory.createMinimalPhase0(); - private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); - private final AttestationSchema attestationSchema = - spec.getGenesisSchemaDefinitions().getAttestationSchema(); + private Spec spec; + private SpecMilestone specMilestone; + private DataStructureUtil dataStructureUtil; + private Optional committeeIndex; private final Spec mockSpec = mock(Spec.class); + private final RecentChainData mockRecentChainData = mock(RecentChainData.class); private AggregatingAttestationPool aggregatingPool = new AggregatingAttestationPool( - mockSpec, new NoOpMetricsSystem(), DEFAULT_MAXIMUM_ATTESTATION_COUNT); + mockSpec, + mockRecentChainData, + new NoOpMetricsSystem(), + DEFAULT_MAXIMUM_ATTESTATION_COUNT); private final AttestationForkChecker forkChecker = mock(AttestationForkChecker.class); + private Int2IntMap committeeSizes; + @BeforeEach - public void setUp() { + public void setUp(final TestSpecInvocationContextProvider.SpecContext specContext) { + spec = specContext.getSpec(); + specMilestone = specContext.getSpecMilestone(); + dataStructureUtil = specContext.getDataStructureUtil(); + + committeeSizes = new Int2IntOpenHashMap(); + IntStream.range(0, spec.getGenesisSpec().getConfig().getMaxCommitteesPerSlot()) + .forEach(index -> committeeSizes.put(index, COMMITTEE_SIZE)); + + if (specMilestone.equals(PHASE0)) { + committeeIndex = Optional.empty(); + } else { + committeeIndex = + Optional.of( + dataStructureUtil.randomUInt64( + spec.getGenesisSpec().getConfig().getMaxCommitteesPerSlot())); + + final BeaconState state = dataStructureUtil.randomBeaconState(); + final UpdatableStore mockStore = mock(UpdatableStore.class); + when(mockRecentChainData.getStore()).thenReturn(mockStore); + when(mockStore.getBlockStateIfAvailable(any())).thenReturn(Optional.of(state)); + when(mockSpec.getBeaconCommitteesSize(any(), any())).thenReturn(committeeSizes); + } + when(forkChecker.areAttestationsFromCorrectFork(any())).thenReturn(true); when(mockSpec.getPreviousEpochAttestationCapacity(any())).thenReturn(Integer.MAX_VALUE); // Fwd some calls to the real spec @@ -70,29 +115,30 @@ public void setUp() { when(mockSpec.getCurrentEpoch(any(BeaconState.class))) .thenAnswer(i -> spec.getCurrentEpoch(i.getArgument(0))); when(mockSpec.atSlot(any())).thenAnswer(invocation -> spec.atSlot(invocation.getArgument(0))); + when(mockSpec.getGenesisSchemaDefinitions()).thenReturn(spec.getGenesisSchemaDefinitions()); } - @Test + @TestTemplate public void createAggregateFor_shouldReturnEmptyWhenNoAttestationsMatchGivenData() { final Optional result = aggregatingPool.createAggregateFor( - dataStructureUtil.randomAttestationData().hashTreeRoot()); + dataStructureUtil.randomAttestationData().hashTreeRoot(), committeeIndex); assertThat(result).isEmpty(); } - @Test + @TestTemplate public void createAggregateFor_shouldAggregateAttestationsWithMatchingData() { final AttestationData attestationData = dataStructureUtil.randomAttestationData(); final Attestation attestation1 = addAttestationFromValidators(attestationData, 1, 3, 5); final Attestation attestation2 = addAttestationFromValidators(attestationData, 2, 4, 6); final Optional result = - aggregatingPool.createAggregateFor(attestationData.hashTreeRoot()); + aggregatingPool.createAggregateFor(attestationData.hashTreeRoot(), committeeIndex); assertThat(result.map(ValidatableAttestation::getAttestation)) .contains(aggregateAttestations(attestation1, attestation2)); } - @Test + @TestTemplate public void createAggregateFor_shouldReturnBestAggregateForMatchingDataWhenSomeOverlap() { final AttestationData attestationData = dataStructureUtil.randomAttestationData(); final Attestation attestation1 = addAttestationFromValidators(attestationData, 1, 3, 5, 7); @@ -100,12 +146,12 @@ public void createAggregateFor_shouldReturnBestAggregateForMatchingDataWhenSomeO addAttestationFromValidators(attestationData, 2, 3, 9); final Optional result = - aggregatingPool.createAggregateFor(attestationData.hashTreeRoot()); + aggregatingPool.createAggregateFor(attestationData.hashTreeRoot(), committeeIndex); assertThat(result.map(ValidatableAttestation::getAttestation)) .contains(aggregateAttestations(attestation1, attestation2)); } - @Test + @TestTemplate public void getAttestationsForBlock_shouldReturnEmptyListWhenNoAttestationsAvailable() { when(mockSpec.validateAttestation(any(), any())).thenReturn(Optional.empty()); @@ -114,7 +160,7 @@ public void getAttestationsForBlock_shouldReturnEmptyListWhenNoAttestationsAvail assertThat(aggregatingPool.getAttestationsForBlock(stateAtBlockSlot, forkChecker)).isEmpty(); } - @Test + @TestTemplate public void getAttestationsForBlock_shouldNotIncludeAttestationsWhereDataDoesNotValidate() { addAttestationFromValidators(dataStructureUtil.randomAttestationData(), 1); addAttestationFromValidators(dataStructureUtil.randomAttestationData(), 2); @@ -128,9 +174,10 @@ public void getAttestationsForBlock_shouldNotIncludeAttestationsWhereDataDoesNot assertThat(aggregatingPool.getAttestationsForBlock(stateAtBlockSlot, forkChecker)).isEmpty(); } - @Test + @TestTemplate void getAttestationsForBlock_shouldNotThrowExceptionWhenShufflingSeedIsUnknown() { - final Attestation attestation = dataStructureUtil.randomAttestation(1); + final Attestation attestation = + createAttestation(dataStructureUtil.randomAttestationData(ONE), 1, 2, 3, 4); // Receive the attestation from a block, prior to receiving it via gossip aggregatingPool.onAttestationsIncludedInBlock(ONE, List.of(attestation)); // Attestation isn't added because it's already redundant @@ -146,7 +193,7 @@ void getAttestationsForBlock_shouldNotThrowExceptionWhenShufflingSeedIsUnknown() assertThat(result).isEmpty(); } - @Test + @TestTemplate public void getAttestationsForBlock_shouldIncludeAttestationsThatPassValidation() { final Attestation attestation1 = addAttestationFromValidators(dataStructureUtil.randomAttestationData(ZERO), 1); @@ -165,19 +212,19 @@ public void getAttestationsForBlock_shouldIncludeAttestationsThatPassValidation( .containsExactlyInAnyOrder(attestation2, attestation3); } - @Test + @TestTemplate public void getAttestationsForBlock_shouldAggregateAttestationsWhenPossible() { - final AttestationData attestationData = dataStructureUtil.randomAttestationData(); + final AttestationData attestationData = dataStructureUtil.randomAttestationData(SLOT); final Attestation attestation1 = addAttestationFromValidators(attestationData, 1, 2); final Attestation attestation2 = addAttestationFromValidators(attestationData, 3, 4); - final BeaconState stateAtBlockSlot = dataStructureUtil.randomBeaconState(); + final BeaconState stateAtBlockSlot = dataStructureUtil.randomBeaconState(SLOT.increment()); assertThat(aggregatingPool.getAttestationsForBlock(stateAtBlockSlot, forkChecker)) .containsExactly(aggregateAttestations(attestation1, attestation2)); } - @Test + @TestTemplate public void getAttestationsForBlock_shouldIncludeAttestationsWithDifferentData() { final AttestationData attestationData = dataStructureUtil.randomAttestationData(ZERO); final Attestation attestation1 = addAttestationFromValidators(attestationData, 1, 2); @@ -191,7 +238,7 @@ public void getAttestationsForBlock_shouldIncludeAttestationsWithDifferentData() .containsExactlyInAnyOrder(aggregateAttestations(attestation1, attestation2), attestation3); } - @Test + @TestTemplate void getAttestationsForBlock_shouldIncludeMoreRecentAttestationsFirst() { final AttestationData attestationData1 = dataStructureUtil.randomAttestationData(UInt64.valueOf(5)); @@ -209,7 +256,7 @@ void getAttestationsForBlock_shouldIncludeMoreRecentAttestationsFirst() { .containsExactly(attestation3, attestation2, attestation1); } - @Test + @TestTemplate public void getAttestationsForBlock_shouldNotAddMoreAttestationsThanAllowedInBlock() { final BeaconState state = dataStructureUtil.randomBeaconState(ONE); final AttestationData attestationData = dataStructureUtil.randomAttestationData(ZERO); @@ -222,17 +269,17 @@ public void getAttestationsForBlock_shouldNotAddMoreAttestationsThanAllowedInBlo .containsExactly(attestation1, attestation2); } - @Test + @TestTemplate void getAttestationsForBlock_shouldLimitPreviousEpochAttestations_capacityOf2() { testPrevEpochLimits(2); } - @Test + @TestTemplate void getAttestationsForBlock_shouldLimitPreviousEpochAttestations_capacityOf1() { testPrevEpochLimits(1); } - @Test + @TestTemplate void getAttestationsForBlock_shouldLimitPreviousEpochAttestations_capacityOf0() { testPrevEpochLimits(0); } @@ -241,7 +288,15 @@ void testPrevEpochLimits(final int prevEpochCapacity) { final UInt64 currentEpoch = UInt64.valueOf(5); final UInt64 startSlotAtCurrentEpoch = spec.computeStartSlotAtEpoch(currentEpoch); final BeaconState stateAtBlockSlot = - dataStructureUtil.stateBuilderPhase0(10, 20).slot(startSlotAtCurrentEpoch.plus(5)).build(); + specMilestone.isGreaterThanOrEqualTo(ELECTRA) + ? dataStructureUtil + .stateBuilderElectra(10, 20) + .slot(startSlotAtCurrentEpoch.plus(5)) + .build() + : dataStructureUtil + .stateBuilderPhase0(10, 20) + .slot(startSlotAtCurrentEpoch.plus(5)) + .build(); when(mockSpec.getPreviousEpochAttestationCapacity(stateAtBlockSlot)) .thenReturn(prevEpochCapacity); @@ -264,7 +319,7 @@ void testPrevEpochLimits(final int prevEpochCapacity) { .containsExactlyElementsOf(expectedAttestations); } - @Test + @TestTemplate public void onSlot_shouldPruneAttestationsMoreThanTwoEpochsBehindCurrentSlot() { final AttestationData pruneAttestationData = dataStructureUtil.randomAttestationData(SLOT); final AttestationData preserveAttestationData = @@ -284,7 +339,7 @@ public void onSlot_shouldPruneAttestationsMoreThanTwoEpochsBehindCurrentSlot() { assertThat(aggregatingPool.getSize()).isEqualTo(1); } - @Test + @TestTemplate public void getSize_shouldIncludeAttestationsAdded() { final AttestationData attestationData = dataStructureUtil.randomAttestationData(); @@ -293,7 +348,7 @@ public void getSize_shouldIncludeAttestationsAdded() { assertThat(aggregatingPool.getSize()).isEqualTo(2); } - @Test + @TestTemplate public void getSize_shouldDecreaseWhenAttestationsRemoved() { final AttestationData attestationData = dataStructureUtil.randomAttestationData(); addAttestationFromValidators(attestationData, 1, 2, 3, 4); @@ -302,7 +357,7 @@ public void getSize_shouldDecreaseWhenAttestationsRemoved() { assertThat(aggregatingPool.getSize()).isEqualTo(1); } - @Test + @TestTemplate public void getSize_shouldNotIncrementWhenAttestationAlreadyExists() { final AttestationData attestationData = dataStructureUtil.randomAttestationData(); @@ -311,7 +366,7 @@ public void getSize_shouldNotIncrementWhenAttestationAlreadyExists() { assertThat(aggregatingPool.getSize()).isEqualTo(1); } - @Test + @TestTemplate public void getSize_shouldDecrementForAllRemovedAttestations() { final AttestationData attestationData = dataStructureUtil.randomAttestationData(); addAttestationFromValidators(attestationData, 1, 2, 3); @@ -323,7 +378,7 @@ public void getSize_shouldDecrementForAllRemovedAttestations() { assertThat(aggregatingPool.getSize()).isEqualTo(0); } - @Test + @TestTemplate public void getSize_shouldAddTheRightData() { final AttestationData attestationData = dataStructureUtil.randomAttestationData(); addAttestationFromValidators(attestationData, 1, 2, 3, 4, 5); @@ -334,7 +389,7 @@ public void getSize_shouldAddTheRightData() { assertThat(aggregatingPool.getSize()).isEqualTo(5); } - @Test + @TestTemplate public void getSize_shouldDecrementForAllRemovedAttestationsWhileKeepingOthers() { final AttestationData attestationData = dataStructureUtil.randomAttestationData(); @@ -351,9 +406,10 @@ public void getSize_shouldDecrementForAllRemovedAttestationsWhileKeepingOthers() assertThat(aggregatingPool.getSize()).isEqualTo(2); } - @Test + @TestTemplate void shouldRemoveOldSlotsWhenMaximumNumberOfAttestationsReached() { - aggregatingPool = new AggregatingAttestationPool(mockSpec, new NoOpMetricsSystem(), 5); + aggregatingPool = + new AggregatingAttestationPool(mockSpec, mockRecentChainData, new NoOpMetricsSystem(), 5); final AttestationData attestationData0 = dataStructureUtil.randomAttestationData(ZERO); final AttestationData attestationData1 = dataStructureUtil.randomAttestationData(ONE); final AttestationData attestationData2 = @@ -375,9 +431,10 @@ void shouldRemoveOldSlotsWhenMaximumNumberOfAttestationsReached() { assertThat(aggregatingPool.getAttestationsForBlock(slot1State, forkChecker)).isEmpty(); } - @Test + @TestTemplate void shouldNotRemoveLastSlotEvenWhenMaximumNumberOfAttestationsReached() { - aggregatingPool = new AggregatingAttestationPool(mockSpec, new NoOpMetricsSystem(), 5); + aggregatingPool = + new AggregatingAttestationPool(mockSpec, mockRecentChainData, new NoOpMetricsSystem(), 5); final AttestationData attestationData = dataStructureUtil.randomAttestationData(ZERO); addAttestationFromValidators(attestationData, 1); addAttestationFromValidators(attestationData, 2); @@ -395,7 +452,7 @@ void shouldNotRemoveLastSlotEvenWhenMaximumNumberOfAttestationsReached() { assertThat(aggregatingPool.getSize()).isEqualTo(6); } - @Test + @TestTemplate public void getAttestationsForBlock_shouldNotAddAttestationsFromWrongFork() { final AttestationData attestationData1 = dataStructureUtil.randomAttestationData(ZERO); final AttestationData attestationData2 = dataStructureUtil.randomAttestationData(ZERO); @@ -413,16 +470,62 @@ public void getAttestationsForBlock_shouldNotAddAttestationsFromWrongFork() { .containsExactly(attestation2); } - @Test + @TestTemplate public void getAttestations_shouldReturnAllAttestations() { - final AttestationData attestationData = dataStructureUtil.randomAttestationData(); - Attestation attestation = addAttestationFromValidators(attestationData, 1, 2, 3); + final AttestationData firstAttestationData = dataStructureUtil.randomAttestationData(); + final Attestation firstAttestation = + addAttestationFromValidators(firstAttestationData, 1, 2, 3); + final AttestationData secondAttestationData = dataStructureUtil.randomAttestationData(); + final Attestation secondAttestation = + addAttestationFromValidators(secondAttestationData, 3, 4, 5); + assertThat(aggregatingPool.getAttestations(Optional.empty(), Optional.empty())) + .containsExactlyInAnyOrder(firstAttestation, secondAttestation); + } + + @TestTemplate + public void + getAttestations_shouldReturnElectraAttestationsOnly_whenElectraActivatesAndNoSlotProvided() { + // Genesis spec must be before Electra in order to be able to add phase0 attestations + assumeThat(specMilestone).isLessThan(ELECTRA); + final Spec mockedSpec = mock(Spec.class); + final AggregatingAttestationPool aggregatingPool = + new AggregatingAttestationPool( + mockedSpec, + mockRecentChainData, + new NoOpMetricsSystem(), + DEFAULT_MAXIMUM_ATTESTATION_COUNT); + // Adding a phase0 attestation to the aggregation pool + final Spec phase0Spec = TestSpecFactory.createMinimalPhase0(); + when(mockedSpec.atSlot(any())).thenReturn(phase0Spec.getGenesisSpec()); + final DataStructureUtil phase0DataStructureUtil = new DataStructureUtil(phase0Spec); + final AttestationData phase0AttestationData = + phase0DataStructureUtil.randomAttestationData(SLOT.minus(4)); + addAttestationFromValidators(aggregatingPool, phase0AttestationData, phase0Spec, 4, 5); + + // Adding an Electra attestation to the aggregation pool + final Spec electraSpec = TestSpecFactory.createMinimalElectra(); + // Electra activates from SLOT + when(mockedSpec.atSlot(argThat(slot -> slot.isGreaterThanOrEqualTo(SLOT)))) + .thenReturn(electraSpec.getGenesisSpec()); + final AttestationData electraAttestationData = dataStructureUtil.randomAttestationData(SLOT); + committeeIndex = + Optional.of( + dataStructureUtil.randomUInt64( + electraSpec.getGenesisSpec().getConfig().getMaxCommitteesPerSlot())); + final Attestation electraAttestation = + addAttestationFromValidators(aggregatingPool, electraAttestationData, electraSpec, 1, 2, 3); + + when(mockRecentChainData.getCurrentSlot()).thenReturn(Optional.of(SLOT)); + // Should get the Electra attestation only assertThat(aggregatingPool.getAttestations(Optional.empty(), Optional.empty())) - .containsExactly(attestation); + .containsExactly(electraAttestation); } - @Test - public void getAttestations_shouldReturnAttestationsForGivenCommitteeIndexOnly() { + @TestTemplate + public void getAttestations_shouldReturnAttestationsForGivenCommitteeIndexOnly_PreElectra() { + assumeThat(specMilestone).isLessThan(ELECTRA); + // Pre Electra the committee index filter is applied to the index set at the attestation data + // level final AttestationData attestationData1 = dataStructureUtil.randomAttestationData(); final AttestationData attestationData2 = new AttestationData( @@ -431,7 +534,7 @@ public void getAttestations_shouldReturnAttestationsForGivenCommitteeIndexOnly() attestationData1.getBeaconBlockRoot(), attestationData1.getSource(), attestationData1.getTarget()); - Attestation attestation1 = addAttestationFromValidators(attestationData1, 1, 2, 3); + final Attestation attestation1 = addAttestationFromValidators(attestationData1, 1, 2, 3); addAttestationFromValidators(attestationData2, 4, 5, 6); assertThat( aggregatingPool.getAttestations( @@ -439,7 +542,21 @@ public void getAttestations_shouldReturnAttestationsForGivenCommitteeIndexOnly() .containsExactly(attestation1); } - @Test + @TestTemplate + public void getAttestations_shouldReturnAttestationsForGivenCommitteeIndexOnly_PostElectra() { + assumeThat(specMilestone).isGreaterThanOrEqualTo(ELECTRA); + // Post Electra the committee index filter is applied to the committee bits + final AttestationData attestationData1 = dataStructureUtil.randomAttestationData(); + final AttestationData attestationData2 = dataStructureUtil.randomAttestationData(); + final Attestation attestation1 = addAttestationFromValidators(attestationData1, 1, 2, 3); + final Optional committeeIndexFilter = committeeIndex; + committeeIndex = Optional.of(committeeIndex.get().plus(1)); + addAttestationFromValidators(attestationData2, 4, 5, 6); + assertThat(aggregatingPool.getAttestations(Optional.empty(), committeeIndexFilter)) + .containsExactly(attestation1); + } + + @TestTemplate public void getAttestations_shouldReturnAttestationsForGivenSlotOnly() { final AttestationData attestationData1 = dataStructureUtil.randomAttestationData(); final AttestationData attestationData2 = @@ -457,7 +574,7 @@ public void getAttestations_shouldReturnAttestationsForGivenSlotOnly() { .containsExactly(attestation1); } - @Test + @TestTemplate void onAttestationsIncludedInBlock_shouldNotAddAttestationsAlreadySeenInABlock() { final AttestationData attestationData = dataStructureUtil.randomAttestationData(ZERO); // Included in block before we see any attestations with this data @@ -469,7 +586,7 @@ void onAttestationsIncludedInBlock_shouldNotAddAttestationsAlreadySeenInABlock() assertThat(aggregatingPool.getSize()).isZero(); } - @Test + @TestTemplate void onAttestationsIncludedInBlock_shouldRemoveAttestationsWhenSeenInABlock() { final AttestationData attestationData = dataStructureUtil.randomAttestationData(ZERO); addAttestationFromValidators(attestationData, 2, 3); @@ -480,7 +597,7 @@ void onAttestationsIncludedInBlock_shouldRemoveAttestationsWhenSeenInABlock() { assertThat(aggregatingPool.getSize()).isZero(); } - @Test + @TestTemplate void onReorg_shouldBeAbleToReadAttestations() { final AttestationData attestationData = dataStructureUtil.randomAttestationData(ZERO); // Included in block before we see any attestations with this data @@ -500,15 +617,55 @@ private Attestation addAttestationFromValidators(final UInt64 slot, final int... private Attestation addAttestationFromValidators( final AttestationData data, final int... validators) { - final Attestation attestation = createAttestation(data, validators); - ValidatableAttestation validatableAttestation = ValidatableAttestation.from(spec, attestation); - validatableAttestation.saveCommitteeShufflingSeed(dataStructureUtil.randomBeaconState(100, 15)); - aggregatingPool.add(validatableAttestation); + return addAttestationFromValidators(data, spec, validators); + } + + private Attestation addAttestationFromValidators( + final AttestationData data, final Spec spec, final int... validators) { + return addAttestationFromValidators(aggregatingPool, data, spec, validators); + } + + private Attestation addAttestationFromValidators( + final AggregatingAttestationPool aggregatingAttestationPool, + final AttestationData data, + final Spec spec, + final int... validators) { + final Attestation attestation = createAttestation(data, spec, validators); + ValidatableAttestation validatableAttestation = + ValidatableAttestation.from(spec, attestation, committeeSizes); + validatableAttestation.saveCommitteeShufflingSeedAndCommitteesSize( + dataStructureUtil.randomBeaconState(100, 15, data.getSlot())); + aggregatingAttestationPool.add(validatableAttestation); return attestation; } private Attestation createAttestation(final AttestationData data, final int... validators) { - final SszBitlist bitlist = attestationSchema.getAggregationBitsSchema().ofBits(20, validators); - return attestationSchema.create(bitlist, data, dataStructureUtil.randomSignature()); + return createAttestation(data, spec, validators); + } + + private Attestation createAttestation( + final AttestationData data, final Spec spec, final int... validators) { + final AttestationSchema attestationSchema = + spec.getGenesisSchemaDefinitions().getAttestationSchema(); + final SszBitlist bitlist = + spec.getGenesisSchemaDefinitions() + .getAttestationSchema() + .getAggregationBitsSchema() + .ofBits(COMMITTEE_SIZE, validators); + + final Supplier committeeBits; + + if (spec.atSlot(data.getSlot()).getMilestone().isGreaterThanOrEqualTo(ELECTRA)) { + committeeBits = + () -> + attestationSchema + .getCommitteeBitsSchema() + .orElseThrow() + .ofBits(committeeIndex.orElseThrow().intValue()); + } else { + committeeBits = () -> null; + } + return attestationSchema.create( + bitlist, data, dataStructureUtil.randomSignature(), committeeBits); } } diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/attestation/AttestationManagerTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/attestation/AttestationManagerTest.java index 5fe533aee2d..4dad9d93b26 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/attestation/AttestationManagerTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/attestation/AttestationManagerTest.java @@ -45,8 +45,8 @@ import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestation; import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof; import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof.SignedAggregateAndProofSchema; @@ -66,7 +66,7 @@ class AttestationManagerTest { private final Spec spec = TestSpecFactory.createDefault(); private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); - private final AttestationSchema attestationSchema = + private final AttestationSchema attestationSchema = spec.getGenesisSchemaDefinitions().getAttestationSchema(); private final SignedAggregateAndProofSchema aggregateSchema = spec.getGenesisSchemaDefinitions().getSignedAggregateAndProofSchema(); diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/attestation/MatchingDataAttestationGroupTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/attestation/MatchingDataAttestationGroupTest.java index 6828e91c31f..c19dd5af076 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/attestation/MatchingDataAttestationGroupTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/attestation/MatchingDataAttestationGroupTest.java @@ -14,42 +14,65 @@ package tech.pegasys.teku.statetransition.attestation; import static org.assertj.core.api.Assertions.assertThat; +import static tech.pegasys.teku.spec.SpecMilestone.ELECTRA; +import static tech.pegasys.teku.spec.SpecMilestone.PHASE0; import static tech.pegasys.teku.statetransition.attestation.AggregatorUtil.aggregateAttestations; -import org.junit.jupiter.api.Test; +import it.unimi.dsi.fastutil.ints.Int2IntMap; +import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap; +import java.util.Optional; +import java.util.function.Supplier; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider.SpecContext; import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; import tech.pegasys.teku.spec.util.DataStructureUtil; +@TestSpecContext(milestone = {PHASE0, ELECTRA}) class MatchingDataAttestationGroupTest { private static final UInt64 SLOT = UInt64.valueOf(1234); - private final Spec spec = TestSpecFactory.createDefault(); - private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); - private final AttestationSchema attestationSchema = - spec.getGenesisSchemaDefinitions().getAttestationSchema(); - private final AttestationData attestationData = dataStructureUtil.randomAttestationData(SLOT); - private final MatchingDataAttestationGroup group = - new MatchingDataAttestationGroup(spec, attestationData); + private Spec spec; + private DataStructureUtil dataStructureUtil; + private AttestationSchema attestationSchema; + + private AttestationData attestationData; + + private MatchingDataAttestationGroup group; + private Int2IntMap committeeSizes; + + @BeforeEach + public void setUp(final SpecContext specContext) { + spec = specContext.getSpec(); + attestationSchema = spec.getGenesisSchemaDefinitions().getAttestationSchema(); + dataStructureUtil = specContext.getDataStructureUtil(); + attestationData = dataStructureUtil.randomAttestationData(SLOT); + committeeSizes = new Int2IntOpenHashMap(); + committeeSizes.put(0, 10); + committeeSizes.put(1, 10); + group = new MatchingDataAttestationGroup(spec, attestationData, Optional.of(committeeSizes)); + } - @Test + @TestTemplate public void isEmpty_shouldBeEmptyInitially() { assertThat(group.isEmpty()).isTrue(); } - @Test + @TestTemplate public void isEmpty_shouldNotBeEmptyWhenAnAttestationIsAdded() { addAttestation(1); assertThat(group.isEmpty()).isFalse(); } - @Test + @TestTemplate public void isEmpty_shouldBeEmptyAfterAttestationRemoved() { final Attestation attestation = addAttestation(1).getAttestation(); int numRemoved = group.onAttestationIncludedInBlock(UInt64.ZERO, attestation); @@ -58,7 +81,7 @@ public void isEmpty_shouldBeEmptyAfterAttestationRemoved() { assertThat(numRemoved).isEqualTo(1); } - @Test + @TestTemplate public void remove_shouldRemoveAttestationEvenWhenInstanceIsDifferent() { final Attestation attestation = addAttestation(1).getAttestation(); final Attestation copy = attestationSchema.sszDeserialize(attestation.sszSerialize()); @@ -69,7 +92,7 @@ public void remove_shouldRemoveAttestationEvenWhenInstanceIsDifferent() { assertThat(numRemoved).isEqualTo(1); } - @Test + @TestTemplate public void remove_multipleCallsToRemoveShouldAggregate() { // Create attestations that will be removed final ValidatableAttestation attestation1 = createAttestation(1); @@ -86,7 +109,7 @@ public void remove_multipleCallsToRemoveShouldAggregate() { assertThat(group.stream()).containsExactly(attestation3); } - @Test + @TestTemplate public void remove_shouldRemoveAttestationsThatAreAggregatedIntoRemovedAttestation() { final ValidatableAttestation attestation1 = addAttestation(1); final ValidatableAttestation attestation2 = addAttestation(2); @@ -101,7 +124,7 @@ public void remove_shouldRemoveAttestationsThatAreAggregatedIntoRemovedAttestati assertThat(numRemoved).isEqualTo(2); // the one attestation is still there, and we've removed 2. } - @Test + @TestTemplate public void add_shouldIgnoreAttestationWhoseBitsHaveAllBeenRemoved() { // Create attestations that will be removed final ValidatableAttestation attestation1 = createAttestation(1); @@ -118,7 +141,23 @@ public void add_shouldIgnoreAttestationWhoseBitsHaveAllBeenRemoved() { assertThat(group.stream()).isEmpty(); } - @Test + @TestTemplate + public void add_shouldAggregateAttestationsFromSameCommittee(final SpecContext specContext) { + specContext.assumeElectraActive(); + final ValidatableAttestation attestation1 = addAttestation(Optional.of(0), 1); + final ValidatableAttestation attestation2 = addAttestation(Optional.of(1), 2); + final ValidatableAttestation attestation3 = addAttestation(Optional.of(1), 3); + + assertThat(group.stream(Optional.of(UInt64.ZERO))).containsExactly(attestation1); + + final Attestation expected = + aggregateAttestations(attestation2.getAttestation(), attestation3.getAttestation()); + + assertThat(group.stream(Optional.of(UInt64.ONE))) + .containsExactly(ValidatableAttestation.from(spec, expected)); + } + + @TestTemplate public void add_shouldIgnoreDuplicateAttestations() { final ValidatableAttestation attestation = addAttestation(1); final ValidatableAttestation copy = @@ -129,7 +168,7 @@ public void add_shouldIgnoreDuplicateAttestations() { assertThat(group.stream()).containsExactly(attestation); } - @Test + @TestTemplate public void iterator_shouldAggregateAttestationsWhereValidatorsDoNotOverlap() { final ValidatableAttestation attestation1 = addAttestation(1); final ValidatableAttestation attestation2 = addAttestation(2); @@ -139,7 +178,7 @@ public void iterator_shouldAggregateAttestationsWhereValidatorsDoNotOverlap() { assertThat(group).containsExactlyInAnyOrder(ValidatableAttestation.from(spec, expected)); } - @Test + @TestTemplate public void iterator_shouldAggregateAttestationsWithMoreValidatorsFirst() { final ValidatableAttestation bigAttestation = addAttestation(1, 3, 5, 7); final ValidatableAttestation mediumAttestation = addAttestation(3, 5, 9); @@ -154,7 +193,7 @@ public void iterator_shouldAggregateAttestationsWithMoreValidatorsFirst() { mediumAttestation); } - @Test + @TestTemplate public void iterator_shouldNotAggregateAttestationsWhenValidatorsOverlap() { final ValidatableAttestation attestation1 = addAttestation(1, 2, 5); final ValidatableAttestation attestation2 = addAttestation(1, 2, 3); @@ -162,7 +201,7 @@ public void iterator_shouldNotAggregateAttestationsWhenValidatorsOverlap() { assertThat(group).containsExactlyInAnyOrder(attestation1, attestation2); } - @Test + @TestTemplate public void iterator_shouldOmitAttestationsThatAreAlreadyIncludedInTheAggregate() { final ValidatableAttestation aggregate = addAttestation(1, 2, 3); addAttestation(2); @@ -170,7 +209,7 @@ public void iterator_shouldOmitAttestationsThatAreAlreadyIncludedInTheAggregate( assertThat(group).containsExactly(aggregate); } - @Test + @TestTemplate void iterator_shouldOmitAttestationsThatOverlapWithFirstAttestationAndAreRedundantWithCombined() { // First aggregate created will have validators 1,2,3,4 which makes the 2,4 attestation // redundant, but iteration will have already passed it before it becomes redundant @@ -184,7 +223,7 @@ void iterator_shouldOmitAttestationsThatOverlapWithFirstAttestationAndAreRedunda spec, aggregateAttestations(useful1.getAttestation(), useful2.getAttestation()))); } - @Test + @TestTemplate void onAttestationIncludedInBlock_shouldRemoveAttestationsMadeRedundant() { final ValidatableAttestation attestation1 = addAttestation(1, 2, 3, 4); final ValidatableAttestation attestation2 = addAttestation(1, 5, 7); @@ -200,7 +239,7 @@ void onAttestationIncludedInBlock_shouldRemoveAttestationsMadeRedundant() { assertThat(group).isEmpty(); } - @Test + @TestTemplate void onAttestationIncludedInBlock_shouldNotRemoveAttestationsWithAdditionalValidators() { final ValidatableAttestation attestation1 = addAttestation(1, 2, 3, 4); final ValidatableAttestation attestation2 = addAttestation(1, 5, 7); @@ -217,7 +256,7 @@ void onAttestationIncludedInBlock_shouldNotRemoveAttestationsWithAdditionalValid assertThat(group).containsExactly(attestation2); } - @Test + @TestTemplate void onAttestationIncludedInBlock_shouldNotAddAttestationsAlreadySeenInBlocks() { group.onAttestationIncludedInBlock( UInt64.valueOf(1), createAttestation(1, 2, 3, 4, 5, 6).getAttestation()); @@ -228,7 +267,7 @@ void onAttestationIncludedInBlock_shouldNotAddAttestationsAlreadySeenInBlocks() assertThat(group.add(createAttestation(2, 3))).isFalse(); } - @Test + @TestTemplate void onReorg_shouldAllowReadingAttestationsThatAreNoLongerRedundant() { final ValidatableAttestation attestation = createAttestation(3, 4); @@ -247,7 +286,7 @@ void onReorg_shouldAllowReadingAttestationsThatAreNoLongerRedundant() { assertThat(group).containsExactly(attestation); } - @Test + @TestTemplate void onReorg_shouldNotAllowReadingAttestationsThatAreStillRedundant() { final ValidatableAttestation attestation1 = createAttestation(3, 4); final ValidatableAttestation attestation2 = createAttestation(1, 2, 3, 4); @@ -273,7 +312,7 @@ void onReorg_shouldNotAllowReadingAttestationsThatAreStillRedundant() { assertThat(group).containsExactly(attestation2); } - @Test + @TestTemplate public void size() { assertThat(group.size()).isEqualTo(0); final ValidatableAttestation attestation1 = addAttestation(1); @@ -295,18 +334,41 @@ public void size() { } private ValidatableAttestation addAttestation(final int... validators) { - final ValidatableAttestation attestation = createAttestation(validators); + return addAttestation(Optional.empty(), validators); + } + + private ValidatableAttestation addAttestation( + final Optional committeeIndex, final int... validators) { + final ValidatableAttestation attestation = createAttestation(committeeIndex, validators); final boolean added = group.add(attestation); assertThat(added).isTrue(); return attestation; } private ValidatableAttestation createAttestation(final int... validators) { + return createAttestation(Optional.empty(), validators); + } + + private ValidatableAttestation createAttestation( + final Optional committeeIndex, final int... validators) { final SszBitlist aggregationBits = attestationSchema.getAggregationBitsSchema().ofBits(10, validators); + final Supplier committeeBits; + + if (spec.atSlot(SLOT).getMilestone().isGreaterThanOrEqualTo(ELECTRA)) { + committeeBits = + () -> + attestationSchema + .getCommitteeBitsSchema() + .orElseThrow() + .ofBits(committeeIndex.orElse(0)); + } else { + committeeBits = () -> null; + } return ValidatableAttestation.from( spec, attestationSchema.create( - aggregationBits, attestationData, dataStructureUtil.randomSignature())); + aggregationBits, attestationData, dataStructureUtil.randomSignature(), committeeBits), + committeeSizes); } } diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/attestation/utils/AttestationBitsAggregatorElectraTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/attestation/utils/AttestationBitsAggregatorElectraTest.java new file mode 100644 index 00000000000..cd0a102dcb7 --- /dev/null +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/attestation/utils/AttestationBitsAggregatorElectraTest.java @@ -0,0 +1,554 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.statetransition.attestation.utils; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import it.unimi.dsi.fastutil.ints.Int2IntMap; +import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap; +import java.util.List; +import java.util.Optional; +import java.util.function.Supplier; +import java.util.regex.Pattern; +import java.util.stream.IntStream; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; +import tech.pegasys.teku.spec.datastructures.operations.AttestationData; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +public class AttestationBitsAggregatorElectraTest { + private final Spec spec = TestSpecFactory.createMainnetElectra(); + private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); + private final AttestationSchema attestationSchema = + spec.getGenesisSchemaDefinitions().getAttestationSchema(); + private final AttestationData attestationData = dataStructureUtil.randomAttestationData(); + + private Int2IntMap committeeSizes; + + @BeforeEach + void setUp() { + committeeSizes = new Int2IntOpenHashMap(); + committeeSizes.put(0, 2); + committeeSizes.put(1, 3); + committeeSizes.put(2, 4); + } + + /* + full committee bits structure + 01|234|5678 + */ + + @Test + void aggregateFromEmpty() { + /* + 012 <- committee 1 indices + 011 <- bits + */ + final ValidatableAttestation initialAttestation = createAttestation(List.of(1), 1, 2); + + final AttestationBitsAggregator aggregator = + AttestationBitsAggregator.fromEmptyFromAttestationSchema( + attestationSchema, Optional.of(committeeSizes)); + + assertThat(aggregator.aggregateWith(initialAttestation.getAttestation())).isTrue(); + + assertThat(aggregator.getCommitteeBits().streamAllSetBits()).containsExactly(1); + + assertThat(aggregator.getAggregationBits().streamAllSetBits()).containsExactly(1, 2); + } + + @Test + void cannotAggregateSameCommitteesWithOverlappingAggregates() { + /* + 012 <- committee 1 indices + 011 <- bits + */ + final ValidatableAttestation initialAttestation = createAttestation(List.of(1), 1, 2); + + /* + 012 <- committee 1 indices + 110 <- bits + */ + final ValidatableAttestation otherAttestation = createAttestation(List.of(1), 0, 1); + + final AttestationBitsAggregator aggregator = AttestationBitsAggregator.of(initialAttestation); + + assertThat(aggregator.aggregateWith(otherAttestation.getAttestation())).isFalse(); + } + + @Test + void aggregateOnSameCommittee() { + /* + 012 <- committee 1 indices + 011 <- bits + */ + final ValidatableAttestation initialAttestation = createAttestation(List.of(1), 1, 2); + + /* + 012 <- committee 1 indices + 100 <- bits + */ + final ValidatableAttestation otherAttestation = createAttestation(List.of(1), 0); + + final AttestationBitsAggregator aggregator = AttestationBitsAggregator.of(initialAttestation); + + assertThat(aggregator.aggregateWith(otherAttestation.getAttestation())).isTrue(); + + /* + 012 <- committee 1 indices + 111 <- bits + */ + + assertThat(aggregator.getCommitteeBits().streamAllSetBits()).containsExactly(1); + assertThat(aggregator.getAggregationBits().streamAllSetBits()).containsExactly(0, 1, 2); + } + + @Test + void aggregateOnMultipleOverlappingCommitteeBits() { + /* + 01|234 <- committee 0 and 1 indices + 10|100 <- bits + */ + final ValidatableAttestation initialAttestation = createAttestation(List.of(0, 1), 0, 2); + + /* + 01|234 <- committee 0 and 1 indices + 01|010 <- bits + */ + final ValidatableAttestation otherAttestation = createAttestation(List.of(0, 1), 1, 3); + + final AttestationBitsAggregator aggregator = AttestationBitsAggregator.of(initialAttestation); + + assertThat(aggregator.aggregateWith(otherAttestation.getAttestation())).isTrue(); + + /* + 01|234 <- committee 0 and 1 indices + 11|110 <- bits + */ + + assertThat(aggregator.getCommitteeBits().streamAllSetBits()).containsExactly(0, 1); + assertThat(aggregator.getAggregationBits().streamAllSetBits()).containsExactly(0, 1, 2, 3); + } + + @Test + void aggregateOnMultipleOverlappingCommitteeBitsVariation() { + /* + 01|234 <- committee 0 and 1 indices + 10|100 <- bits + */ + final ValidatableAttestation initialAttestation = createAttestation(List.of(0, 1), 0, 2); + + /* + 01|234|5678 <- committee 0, 1 and 2 indices + 01|011|0001 <- bits + */ + final ValidatableAttestation otherAttestation = createAttestation(List.of(0, 1, 2), 1, 3, 4, 8); + + final AttestationBitsAggregator aggregator = AttestationBitsAggregator.of(initialAttestation); + + assertThat(aggregator.aggregateWith(otherAttestation.getAttestation())).isTrue(); + + /* + 01|234|5678 <- committee 0, 1 and 2 indices + 11|111|0001 <- bits + */ + + assertThat(aggregator.getCommitteeBits().streamAllSetBits()).containsExactly(0, 1, 2); + assertThat(aggregator.getAggregationBits().streamAllSetBits()) + .containsExactly(0, 1, 2, 3, 4, 8); + } + + @Test + void cannotAggregateOnMultipleOverlappingCommitteeBitsButWithSomeOfAggregationOverlapping() { + /* + 01|234 <- committee 0 and 1 indices + 10|100 <- bits + */ + final ValidatableAttestation initialAttestation = createAttestation(List.of(0, 1), 0, 2); + + /* + 01|234|5678 <- committee 0, 1 and 2 indices + 01|110|0001 <- bits + */ + final ValidatableAttestation otherAttestation = createAttestation(List.of(0, 1, 2), 1, 2, 3, 8); + + final AttestationBitsAggregator aggregator = AttestationBitsAggregator.of(initialAttestation); + + assertThat(aggregator.aggregateWith(otherAttestation.getAttestation())).isFalse(); + + // check remained untouched + + assertThat(aggregator.getCommitteeBits().streamAllSetBits()).containsExactly(0, 1); + assertThat(aggregator.getAggregationBits().streamAllSetBits()).containsExactly(0, 2); + } + + @Test + void aggregateOnMultipleOverlappingCommitteeBitsButWithSomeOfAggregationOverlappingWhenNoCheck() { + /* + 01|234 <- committee 0 and 1 indices + 10|100 <- bits + */ + final ValidatableAttestation initialAttestation = createAttestation(List.of(0, 1), 0, 2); + + /* + 01|234|5678 <- committee 0, 1 and 2 indices + 01|110|0001 <- bits + */ + final ValidatableAttestation otherAttestation = createAttestation(List.of(0, 1, 2), 1, 2, 3, 8); + + final AttestationBitsAggregator aggregator = AttestationBitsAggregator.of(initialAttestation); + + // cannot aggregate + assertThat(aggregator.aggregateWith(otherAttestation.getAttestation())).isFalse(); + + // calculate the or + aggregator.or(otherAttestation.getAttestation()); + + /* + 01|234|5678 <- committee 0, 1 and 2 indices + 11|110|0001 <- bits + */ + + assertThat(aggregator.getCommitteeBits().streamAllSetBits()).containsExactly(0, 1, 2); + assertThat(aggregator.getAggregationBits().streamAllSetBits()).containsExactly(0, 1, 2, 3, 8); + } + + @Test + void + aggregateOnMultipleOverlappingCommitteeBitsButWithSomeOfAggregationOverlappingWhenNoCheck2() { + /* + 0123 <- committee 2 indices + 0100 <- bits + */ + final ValidatableAttestation initialAttestation = createAttestation(List.of(2), 1); + + /* + 0123 <- committee 2 indices + 1101 <- bits + */ + final ValidatableAttestation otherAttestation = createAttestation(List.of(2), 0, 1, 3); + + AttestationBitsAggregator aggregator = AttestationBitsAggregator.of(initialAttestation); + + // cannot aggregate + assertThat(aggregator.aggregateWith(otherAttestation.getAttestation())).isFalse(); + + // calculate the or + aggregator.or(otherAttestation.getAttestation()); + + /* + 01|234|5678 <- committee 0, 1 and 2 indices + 11|110|0001 <- bits + */ + + assertThat(aggregator.getCommitteeBits().streamAllSetBits()).containsExactly(2); + assertThat(aggregator.getAggregationBits().streamAllSetBits()).containsExactly(0, 1, 3); + } + + @Test + void aggregateOnMultipleDisjointedCommitteeBits() { + /* + 01|234 <- committee 0 and 1 indices + 10|100 <- bits + */ + final ValidatableAttestation initialAttestation = createAttestation(List.of(0, 1), 0, 2); + + /* + 0123 <- committee 1 indices + 1101 <- bits + */ + final ValidatableAttestation otherAttestation = createAttestation(List.of(2), 0, 1, 3); + + final AttestationBitsAggregator aggregator = AttestationBitsAggregator.of(initialAttestation); + + assertThat(aggregator.aggregateWith(otherAttestation.getAttestation())).isTrue(); + + /* + 01|234|5678 <- committee 0, 1 and 2 indices + 10|100|1101 <- bits + */ + + assertThat(aggregator.getCommitteeBits().streamAllSetBits()).containsExactly(0, 1, 2); + assertThat(aggregator.getAggregationBits().streamAllSetBits()).containsExactly(0, 2, 5, 6, 8); + } + + @Test + void aggregateOnMultipleDisjointedCommitteeBitsVariation() { + /* + 0123 <- committee 2 indices + 0001 <- bits + */ + final ValidatableAttestation initialAttestation = createAttestation(List.of(2), 3); + + /* + 01 <- committee 0 indices + 01 <- bits + */ + final ValidatableAttestation otherAttestation = createAttestation(List.of(0), 1); + + final AttestationBitsAggregator aggregator = AttestationBitsAggregator.of(initialAttestation); + + assertThat(aggregator.aggregateWith(otherAttestation.getAttestation())).isTrue(); + + /* + 01|2345 <- committee 0 and 2 indices + 01|0001 <- bits + */ + + assertThat(aggregator.getCommitteeBits().streamAllSetBits()).containsExactly(0, 2); + assertThat(aggregator.getAggregationBits().streamAllSetBits()).containsExactly(1, 5); + } + + @Test + void bigAggregation() { + committeeSizes = new Int2IntOpenHashMap(); + committeeSizes.put(0, 50); + committeeSizes.put(1, 49); + committeeSizes.put(2, 50); + committeeSizes.put(3, 50); + committeeSizes.put(4, 50); + committeeSizes.put(5, 50); + committeeSizes.put(6, 50); + committeeSizes.put(7, 50); + committeeSizes.put(8, 50); + committeeSizes.put(9, 50); + committeeSizes.put(10, 50); + committeeSizes.put(11, 50); + committeeSizes.put(12, 50); + committeeSizes.put(13, 50); + committeeSizes.put(14, 50); + committeeSizes.put(15, 51); + + final ValidatableAttestation initialAttestation = + createAttestation( + "1111111111111111", + """ + 11111111111111111111111111111111111111111111111111\ + 0000000000000000000000000000000000000000000000010\ + 00000000000000000000100000000000000000000000000000\ + 00000000000010000000000000000000000000000000000000\ + 00000000000000000000000000000000000000000000000001\ + 00000000000000000000000000000000000010000000000000\ + 00000000000000000010000000000000000000000000000000\ + 00000000000000000001000000000000000000000000000000\ + 00000000000000010001000000000000000000000000000000\ + 00000000000000000000000001000000000000000000000000\ + 00000010000000000000000000000000000000000000000000\ + 00010000000000000000000000000000000000000000000000\ + 00000000000000100000000000000000000000000000000000\ + 00000000000010000000000000000000000000000000000000\ + 00100000000000000000000000000000000000000000000000\ + 000000000000001000000000000000000000000000000000001\ + """); + final ValidatableAttestation att = + createAttestation("0001000000000000", "00000000000000000000000100000000000000000000000000"); + + final AttestationBitsAggregator aggregator = AttestationBitsAggregator.of(initialAttestation); + assertThat(aggregator.aggregateWith(att.getAttestation())).isTrue(); + + final ValidatableAttestation result = + createAttestation( + "1111111111111111", + """ + 11111111111111111111111111111111111111111111111111\ + 0000000000000000000000000000000000000000000000010\ + 00000000000000000000100000000000000000000000000000\ + 00000000000010000000000100000000000000000000000000\ + 00000000000000000000000000000000000000000000000001\ + 00000000000000000000000000000000000010000000000000\ + 00000000000000000010000000000000000000000000000000\ + 00000000000000000001000000000000000000000000000000\ + 00000000000000010001000000000000000000000000000000\ + 00000000000000000000000001000000000000000000000000\ + 00000010000000000000000000000000000000000000000000\ + 00010000000000000000000000000000000000000000000000\ + 00000000000000100000000000000000000000000000000000\ + 00000000000010000000000000000000000000000000000000\ + 00100000000000000000000000000000000000000000000000\ + 000000000000001000000000000000000000000000000000001\ + """); + + assertThat(aggregator.getCommitteeBits()) + .isEqualTo(result.getAttestation().getCommitteeBitsRequired()); + assertThat(aggregator.getAggregationBits()) + .isEqualTo(result.getAttestation().getAggregationBits()); + } + + @Test + void isSuperSetOf1() { + + /* + 01|234 <- committee 0 and 1 indices + 10|101 <- bits + */ + final ValidatableAttestation initialAttestation = createAttestation(List.of(0, 1), 0, 2, 4); + + /* + 01|234 <- committee 0 and 1 indices + 10|100 <- bits + */ + final ValidatableAttestation otherAttestation = createAttestation(List.of(0, 1), 0, 2); + + AttestationBitsAggregator aggregator = AttestationBitsAggregator.of(initialAttestation); + + assertThat(aggregator.isSuperSetOf(otherAttestation.getAttestation())).isTrue(); + } + + @Test + void isSuperSetOf2() { + + /* + 01|234 <- committee 0 and 1 indices + 10|101 <- bits + */ + final ValidatableAttestation initialAttestation = createAttestation(List.of(0, 1), 0, 2, 4); + + /* + 01|234 <- committee 0 and 1 indices + 10|101 <- bits + */ + final ValidatableAttestation otherAttestation = createAttestation(List.of(0, 1), 0, 2, 4); + + final AttestationBitsAggregator aggregator = AttestationBitsAggregator.of(initialAttestation); + + assertThat(aggregator.isSuperSetOf(otherAttestation.getAttestation())).isTrue(); + } + + @Test + void isSuperSetOf3() { + + /* + 01|234 <- committee 0 and 1 indices + 10|101 <- bits + */ + final ValidatableAttestation initialAttestation = createAttestation(List.of(0, 1), 0, 2, 4); + + /* + 01|234 <- committee 0 and 1 indices + 10|111 <- bits + */ + final ValidatableAttestation otherAttestation = createAttestation(List.of(0, 1), 0, 2, 3, 4); + + final AttestationBitsAggregator aggregator = AttestationBitsAggregator.of(initialAttestation); + + assertThat(aggregator.isSuperSetOf(otherAttestation.getAttestation())).isFalse(); + } + + @Test + void isSuperSetOf4() { + + /* + 01|234 <- committee 0 and 1 indices + 10|101 <- bits + */ + final ValidatableAttestation initialAttestation = createAttestation(List.of(0, 1), 0, 2, 4); + + /* + 012 <- committee 1 indices + 111 <- bits + */ + final ValidatableAttestation otherAttestation = createAttestation(List.of(1), 0, 1, 2); + + AttestationBitsAggregator aggregator = AttestationBitsAggregator.of(initialAttestation); + + assertThat(aggregator.isSuperSetOf(otherAttestation.getAttestation())).isFalse(); + } + + @Test + void isSuperSetOf5() { + + /* + 01 <- committee 0 + 10 <- bits + */ + final ValidatableAttestation initialAttestation = createAttestation(List.of(0), 0); + + /* + 012 <- committee 1 indices + 100 <- bits + */ + final ValidatableAttestation otherAttestation = createAttestation(List.of(1), 0); + + final AttestationBitsAggregator aggregator = AttestationBitsAggregator.of(initialAttestation); + + assertThat(aggregator.isSuperSetOf(otherAttestation.getAttestation())).isFalse(); + } + + @Test + void isSuperSetOf6() { + + /* + 01|234|5678 <- committee 0, 1 and 2 indices + 11|111|1111 <- bits + */ + final ValidatableAttestation initialAttestation = + createAttestation(List.of(0, 1, 2), 0, 1, 2, 3, 4, 5, 6, 7, 8); + + /* + 012 <- committee 1 indices + 100 <- bits + */ + final ValidatableAttestation otherAttestation = createAttestation(List.of(1), 0); + + final AttestationBitsAggregator aggregator = AttestationBitsAggregator.of(initialAttestation); + + assertThat(aggregator.isSuperSetOf(otherAttestation.getAttestation())).isTrue(); + } + + private ValidatableAttestation createAttestation(final String commBits, final String aggBits) { + assertThat(commBits).matches(Pattern.compile("^[0-1]+$")); + assertThat(aggBits).matches(Pattern.compile("^[0-1]+$")); + final List commBitList = + IntStream.range(0, commBits.length()) + .mapToObj(index -> commBits.charAt(index) == '1' ? index : -1) + .filter(index -> index >= 0) + .toList(); + final int[] aggBitList = + IntStream.range(0, aggBits.length()) + .map(index -> aggBits.charAt(index) == '1' ? index : -1) + .filter(index -> index >= 0) + .toArray(); + return createAttestation(commBitList, aggBitList); + } + + private ValidatableAttestation createAttestation( + final List committeeIndices, final int... validators) { + final SszBitlist aggregationBits = + attestationSchema + .getAggregationBitsSchema() + .ofBits(committeeSizes.values().intStream().sum(), validators); + final Supplier committeeBits = + () -> attestationSchema.getCommitteeBitsSchema().orElseThrow().ofBits(committeeIndices); + + final ValidatableAttestation attestation = mock(ValidatableAttestation.class); + when(attestation.getAttestation()) + .thenReturn( + attestationSchema.create( + aggregationBits, + attestationData, + dataStructureUtil.randomSignature(), + committeeBits)); + when(attestation.getCommitteesSize()).thenReturn(Optional.of(committeeSizes)); + + return attestation; + } +} diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/blobs/BlockBlobSidecarsTrackerTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/blobs/BlockBlobSidecarsTrackerTest.java index 3748ad0daf0..d5d702acbc9 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/blobs/BlockBlobSidecarsTrackerTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/blobs/BlockBlobSidecarsTrackerTest.java @@ -36,18 +36,19 @@ import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.config.SpecConfigDeneb; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.blocks.SlotAndBlockRoot; import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.BlobIdentifier; -import tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel; import tech.pegasys.teku.spec.util.DataStructureUtil; import tech.pegasys.teku.statetransition.block.BlockImportChannel; import tech.pegasys.teku.statetransition.block.BlockImportChannel.BlockImportAndBroadcastValidationResults; public class BlockBlobSidecarsTrackerTest { private final Spec spec = TestSpecFactory.createMainnetDeneb(); - private final UInt64 maxBlobsPerBlock = UInt64.valueOf(spec.getMaxBlobsPerBlock().orElseThrow()); + private final UInt64 maxBlobsPerBlock = + UInt64.valueOf(SpecConfigDeneb.required(spec.getGenesisSpecConfig()).getMaxBlobsPerBlock()); private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); private final SignedBeaconBlock block = @@ -404,7 +405,7 @@ void enableBlockImportOnCompletion_shouldImportOnlyOnceWhenCalled() { blockBlobSidecarsTracker.setBlock(block); final BlockImportChannel blockImportChannel = mock(BlockImportChannel.class); - when(blockImportChannel.importBlock(block, BroadcastValidationLevel.NOT_REQUIRED)) + when(blockImportChannel.importBlock(block)) .thenReturn( SafeFuture.completedFuture(new BlockImportAndBroadcastValidationResults(null, null))); @@ -417,7 +418,7 @@ void enableBlockImportOnCompletion_shouldImportOnlyOnceWhenCalled() { assertThat(blockBlobSidecarsTracker.isCompleted()).isTrue(); - verify(blockImportChannel, times(1)).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockImportChannel, times(1)).importBlock(block); } private BlobSidecar createBlobSidecar(final UInt64 index) { diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/block/BlockImporterTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/block/BlockImporterTest.java index ecc8283c0dd..cc6e36ca465 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/block/BlockImporterTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/block/BlockImporterTest.java @@ -16,6 +16,7 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatCode; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.doAnswer; import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; @@ -38,6 +39,8 @@ import tech.pegasys.teku.bls.BLSSignatureVerifier; import tech.pegasys.teku.bls.BLSTestUtil; import tech.pegasys.teku.ethereum.execution.types.Eth1Address; +import tech.pegasys.teku.infrastructure.async.AsyncRunner; +import tech.pegasys.teku.infrastructure.async.ExceptionThrowingFutureSupplier; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.async.eventthread.InlineEventThread; import tech.pegasys.teku.infrastructure.metrics.StubMetricsSystem; @@ -52,7 +55,7 @@ import tech.pegasys.teku.spec.datastructures.blocks.StateAndBlockSummary; import tech.pegasys.teku.spec.datastructures.interop.MockStartValidatorKeyPairFactory; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChange; import tech.pegasys.teku.spec.datastructures.state.Checkpoint; import tech.pegasys.teku.spec.datastructures.state.CheckpointState; @@ -79,9 +82,10 @@ import tech.pegasys.teku.weaksubjectivity.config.WeakSubjectivityConfig; public class BlockImporterTest { + private final AsyncRunner asyncRunner = mock(AsyncRunner.class); private final Spec spec = TestSpecFactory.createMinimalPhase0(); private final SpecConfig genesisConfig = spec.getGenesisSpecConfig(); - private final AttestationSchema attestationSchema = + private final AttestationSchema attestationSchema = spec.getGenesisSchemaDefinitions().getAttestationSchema(); private final List validatorKeys = BLSKeyGenerator.generateKeyPairs(8); private final ReceivedBlockEventsChannel receivedBlockEventsChannelPublisher = @@ -113,6 +117,7 @@ public class BlockImporterTest { private final BlockImporter blockImporter = new BlockImporter( + asyncRunner, spec, receivedBlockEventsChannelPublisher, recentChainData, @@ -133,6 +138,15 @@ public static void dispose() { @BeforeEach public void setup() { + // prepare a synchronous async runner + doAnswer( + invocation -> { + final ExceptionThrowingFutureSupplier task = invocation.getArgument(0); + return SafeFuture.completedFuture(SafeFuture.of(task.get()).join()); + }) + .when(asyncRunner) + .runAsync((ExceptionThrowingFutureSupplier) any()); + otherChain.initializeStorage(); localChain.initializeStorage(); when(weakSubjectivityValidator.isBlockValid(any(), any())).thenReturn(true); @@ -252,7 +266,7 @@ public void importBlock_latestFinalizedBlock() throws Exception { tx.commit().join(); // Known blocks should report as successfully imported - final BlockImportResult result = blockImporter.importBlock(blocks.get(blocks.size() - 1)).get(); + final BlockImportResult result = blockImporter.importBlock(blocks.getLast()).get(); assertSuccessfulResult(result, false); } @@ -403,6 +417,7 @@ public void importBlock_weakSubjectivityFailure_wrongAncestor() throws Exception WeakSubjectivityValidator.lenient(wsConfig); final BlockImporter blockImporter = new BlockImporter( + asyncRunner, spec, receivedBlockEventsChannelPublisher, recentChainData, @@ -433,6 +448,7 @@ public void importBlock_weakSubjectivityChecksPass() throws Exception { WeakSubjectivityValidator.lenient(wsConfig); final BlockImporter blockImporter = new BlockImporter( + asyncRunner, spec, receivedBlockEventsChannelPublisher, recentChainData, @@ -463,6 +479,7 @@ public void importBlock_runWSPChecks() throws Exception { storageSystem.getMetricsSystem()); final BlockImporter blockImporter = new BlockImporter( + asyncRunner, spec, receivedBlockEventsChannelPublisher, storageSystem.recentChainData(), @@ -508,6 +525,7 @@ public void importBlock_nonFinalizingChain_runWSPChecks() throws Exception { storageSystem.getMetricsSystem()); final BlockImporter blockImporter = new BlockImporter( + asyncRunner, spec, receivedBlockEventsChannelPublisher, storageSystem.recentChainData(), @@ -561,6 +579,7 @@ public void importBlock_nonFinalizingChain_skipWSPChecks() throws Exception { storageSystem.getMetricsSystem()); final BlockImporter blockImporter = new BlockImporter( + asyncRunner, spec, receivedBlockEventsChannelPublisher, storageSystem.recentChainData(), @@ -606,6 +625,7 @@ public void getLatestCheckpointState_initialCall() { storageSystem.getMetricsSystem()); final BlockImporter blockImporter = new BlockImporter( + asyncRunner, spec, receivedBlockEventsChannelPublisher, storageSystem.recentChainData(), @@ -639,6 +659,7 @@ public void getLatestCheckpointState_shouldPullUpdatedFinalizedCheckpoint() { storageSystem.getMetricsSystem()); final BlockImporter blockImporter = new BlockImporter( + asyncRunner, spec, receivedBlockEventsChannelPublisher, storageSystem.recentChainData(), @@ -694,6 +715,7 @@ public void importBlock_validBlsToExecutionChanges() throws Exception { final BlockImporter blockImporter = new BlockImporter( + asyncRunner, spec, receivedBlockEventsChannelPublisher, storageSystem.recentChainData(), diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/block/BlockManagerTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/block/BlockManagerTest.java index ace05b89851..db58e22b601 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/block/BlockManagerTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/block/BlockManagerTest.java @@ -30,7 +30,6 @@ import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.async.FutureUtil.ignoreFuture; import static tech.pegasys.teku.infrastructure.async.SafeFutureAssert.assertThatSafeFuture; -import static tech.pegasys.teku.infrastructure.async.SafeFutureAssert.safeJoin; import static tech.pegasys.teku.spec.config.SpecConfig.GENESIS_SLOT; import static tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel.GOSSIP; import static tech.pegasys.teku.spec.logic.common.statetransition.results.BlockImportResult.FailureReason.FAILED_DATA_AVAILABILITY_CHECK_INVALID; @@ -53,6 +52,9 @@ import java.util.List; import java.util.Map; import java.util.Optional; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; import org.apache.tuweni.bytes.Bytes32; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.AfterEach; @@ -60,6 +62,8 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import tech.pegasys.teku.bls.BLSSignatureVerifier; +import tech.pegasys.teku.infrastructure.async.AsyncRunner; +import tech.pegasys.teku.infrastructure.async.ExceptionThrowingFutureSupplier; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.async.SafeFutureAssert; import tech.pegasys.teku.infrastructure.async.eventthread.InlineEventThread; @@ -109,6 +113,7 @@ @SuppressWarnings("FutureReturnValueIgnored") public class BlockManagerTest { + private final AsyncRunner asyncRunner = mock(AsyncRunner.class); private final StubTimeProvider timeProvider = StubTimeProvider.withTimeInSeconds(0); private final EventLogger eventLogger = mock(EventLogger.class); private Spec spec; @@ -157,6 +162,15 @@ public static void resetSession() { @BeforeEach public void setup() { + // prepare an async runner + doAnswer( + invocation -> { + final ExceptionThrowingFutureSupplier task = invocation.getArgument(0); + return SafeFuture.of(task.get()); + }) + .when(asyncRunner) + .runAsync((ExceptionThrowingFutureSupplier) any()); + setupWithSpec(TestSpecFactory.createMinimalDeneb()); } @@ -184,6 +198,7 @@ private void setupWithSpec(final Spec spec) { this.executionLayer = spy(new ExecutionLayerChannelStub(spec, false, Optional.empty())); this.blockImporter = new BlockImporter( + asyncRunner, spec, receivedBlockEventsChannelPublisher, localRecentChainData, @@ -446,9 +461,7 @@ public void onBlockImported_withPendingBlocks() { } // Gossip all blocks except the first - blocks - .subList(1, blockCount) - .forEach(block -> blockManager.importBlock(block, BroadcastValidationLevel.NOT_REQUIRED)); + blocks.subList(1, blockCount).forEach(block -> blockManager.importBlock(block)); assertThat(pendingBlocks.size()).isEqualTo(blockCount - 1); // Import next block, causing remaining blocks to be imported @@ -558,9 +571,7 @@ public void onBlockImported_withPendingFutureBlocks() { } // Gossip all blocks except the first - blocks - .subList(1, blockCount) - .forEach(block -> blockManager.importBlock(block, BroadcastValidationLevel.NOT_REQUIRED)); + blocks.subList(1, blockCount).forEach(block -> blockManager.importBlock(block)); assertThat(pendingBlocks.size()).isEqualTo(blockCount - 1); // Import next block, causing next block to be queued for import @@ -662,7 +673,7 @@ void onImportBlock_shouldImportWithBroadcastValidationCompletedWhileStillImporti // let's delay EL so importResult SafeFuture doesn't complete final SafeFuture payloadStatusSafeFuture = new SafeFuture<>(); - doReturn(payloadStatusSafeFuture).when(executionLayer).engineNewPayload(any()); + doReturn(payloadStatusSafeFuture).when(executionLayer).engineNewPayload(any(), any()); final Optional preImportHead = localRecentChainData.getChainHead(); @@ -1190,7 +1201,7 @@ private BlockManager setupBlockManagerWithMockRecentChainData( private SafeFutureAssert assertThatBlockImport(final SignedBeaconBlock block) { return assertThatSafeFuture( blockManager - .importBlock(block, BroadcastValidationLevel.NOT_REQUIRED) + .importBlock(block) .thenCompose(BlockImportAndBroadcastValidationResults::blockImportResult)); } @@ -1201,9 +1212,13 @@ private SafeFutureAssert assertThatBlockImport(final SignedBe } private void safeJoinBlockImport(final SignedBeaconBlock block) { - safeJoin( - blockManager - .importBlock(block, BroadcastValidationLevel.NOT_REQUIRED) - .thenCompose(BlockImportAndBroadcastValidationResults::blockImportResult)); + try { + blockManager + .importBlock(block) + .thenCompose(BlockImportAndBroadcastValidationResults::blockImportResult) + .get(5, TimeUnit.SECONDS); + } catch (final InterruptedException | ExecutionException | TimeoutException e) { + throw new RuntimeException(e); + } } } diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/block/FailedExecutionPoolTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/block/FailedExecutionPoolTest.java index 5cf7ca002ef..0dcfb806ded 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/block/FailedExecutionPoolTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/block/FailedExecutionPoolTest.java @@ -33,7 +33,6 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; -import tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel; import tech.pegasys.teku.spec.logic.common.statetransition.results.BlockImportResult; import tech.pegasys.teku.spec.util.DataStructureUtil; import tech.pegasys.teku.statetransition.block.BlockImportChannel.BlockImportAndBroadcastValidationResults; @@ -66,7 +65,7 @@ void shouldRetryExecutionAfterShortDelay() { timeProvider.advanceTimeBy(FailedExecutionPool.SHORT_DELAY); asyncRunner.executeDueActions(); - verify(blockManager).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager).importBlock(block); } @Test @@ -77,11 +76,11 @@ void shouldContinueRetryingWhenExecutionFailsAgain() { assertThat(asyncRunner.hasDelayedActions()).isTrue(); asyncRunner.executeQueuedActions(); - verify(blockManager).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager).importBlock(block); assertThat(asyncRunner.hasDelayedActions()).isTrue(); asyncRunner.executeQueuedActions(); - verify(blockManager, times(2)).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager, times(2)).importBlock(block); } @Test @@ -92,7 +91,7 @@ void shouldStopRetryingWhenBlockImports() { assertThat(asyncRunner.hasDelayedActions()).isTrue(); asyncRunner.executeQueuedActions(); - verify(blockManager).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager).importBlock(block); assertThat(asyncRunner.hasDelayedActions()).isFalse(); } @@ -106,7 +105,7 @@ void shouldStopRetryingWhenPayloadFoundToBeInvalid() { assertThat(asyncRunner.hasDelayedActions()).isTrue(); asyncRunner.executeQueuedActions(); - verify(blockManager).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager).importBlock(block); assertThat(asyncRunner.hasDelayedActions()).isFalse(); } @@ -119,7 +118,7 @@ void shouldStopRetryingWhenBlockCanBeOptimisticallyImported() { assertThat(asyncRunner.hasDelayedActions()).isTrue(); asyncRunner.executeQueuedActions(); - verify(blockManager).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager).importBlock(block); assertThat(asyncRunner.hasDelayedActions()).isFalse(); } @@ -133,7 +132,7 @@ void shouldNotRetrySameBlockTwice() { withImportResult(BlockImportResult.optimisticallySuccessful(block)); asyncRunner.executeQueuedActions(); - verify(blockManager).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager).importBlock(block); assertThat(asyncRunner.hasDelayedActions()).isFalse(); } @@ -146,17 +145,17 @@ void shouldWaitLongerBetweenEachRetry() { timeProvider.advanceTimeBy(FailedExecutionPool.SHORT_DELAY); asyncRunner.executeDueActions(); - verify(blockManager, times(1)).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager, times(1)).importBlock(block); // Not retried after the delay timeProvider.advanceTimeBy(FailedExecutionPool.SHORT_DELAY); asyncRunner.executeDueActions(); - verify(blockManager, times(1)).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager, times(1)).importBlock(block); // But retries after double the time timeProvider.advanceTimeBy(FailedExecutionPool.SHORT_DELAY); asyncRunner.executeDueActions(); - verify(blockManager, times(2)).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager, times(2)).importBlock(block); } @Test @@ -168,19 +167,19 @@ void shouldResetRetryTimeOnSuccessfulResponse() { timeProvider.advanceTimeBy(FailedExecutionPool.SHORT_DELAY); asyncRunner.executeDueActions(); - verify(blockManager, times(1)).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager, times(1)).importBlock(block); // Succeeds when retried the second time withImportResult(BlockImportResult.successful(block)); timeProvider.advanceTimeBy(FailedExecutionPool.SHORT_DELAY.multipliedBy(2)); asyncRunner.executeDueActions(); - verify(blockManager, times(2)).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager, times(2)).importBlock(block); // New block fails and should be retried with a short timeout again failurePool.addFailedBlock(block2); timeProvider.advanceTimeBy(FailedExecutionPool.SHORT_DELAY); asyncRunner.executeDueActions(); - verify(blockManager).importBlock(block2, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager).importBlock(block2); } @Test @@ -192,7 +191,7 @@ void shouldOnlyRetryOneBlockAtATime() { failurePool.addFailedBlock(block2); asyncRunner.executeQueuedActions(); - verify(blockManager, times(1)).importBlock(any(), any()); + verify(blockManager, times(1)).importBlock(any()); } @Test @@ -204,9 +203,9 @@ void shouldRetryNextBlockAfterFirstOneNoLongerNeedsRetrying() { failurePool.addFailedBlock(block2); asyncRunner.executeQueuedActions(); - verify(blockManager).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager).importBlock(block); // Should immediately try to execute next pending block - verify(blockManager).importBlock(block2, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager).importBlock(block2); } @Test @@ -218,14 +217,14 @@ void shouldLimitMaximumRetryDelayForSyncingResponses() { for (int i = 0; i < 5; i++) { timeProvider.advanceTimeBy(expectedDelay); asyncRunner.executeDueActions(); - verify(blockManager, times(i + 1)).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager, times(i + 1)).importBlock(block); expectedDelay = expectedDelay.multipliedBy(2); } // Should not increase delay beyond maximum timeProvider.advanceTimeBy(FailedExecutionPool.MAX_RETRY_DELAY); asyncRunner.executeDueActions(); - verify(blockManager, times(6)).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager, times(6)).importBlock(block); } @Test @@ -237,14 +236,14 @@ void shouldLimitMaximumRetryDelayForTimeoutResponses() { for (int i = 0; i < 5; i++) { timeProvider.advanceTimeBy(expectedDelay); asyncRunner.executeDueActions(); - verify(blockManager, times(i + 1)).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager, times(i + 1)).importBlock(block); expectedDelay = expectedDelay.multipliedBy(2); } // Should not increase delay beyond maximum timeProvider.advanceTimeBy(FailedExecutionPool.MAX_RETRY_DELAY); asyncRunner.executeDueActions(); - verify(blockManager, times(6)).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager, times(6)).importBlock(block); } @Test @@ -256,14 +255,14 @@ void shouldLimitMaximumRetryDelayForFailureResponses() { for (int i = 0; i < 5; i++) { timeProvider.advanceTimeBy(expectedDelay); asyncRunner.executeDueActions(); - verify(blockManager, times(i + 1)).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager, times(i + 1)).importBlock(block); expectedDelay = expectedDelay.multipliedBy(2); } // Should not increase delay beyond maximum timeProvider.advanceTimeBy(FailedExecutionPool.MAX_RETRY_DELAY); asyncRunner.executeDueActions(); - verify(blockManager, times(6)).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager, times(6)).importBlock(block); } @Test @@ -275,10 +274,10 @@ void shouldRetrySameBlockOnTimeoutResponse() { failurePool.addFailedBlock(block2); asyncRunner.executeQueuedActions(); - verify(blockManager).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager).importBlock(block); asyncRunner.executeQueuedActions(); - verify(blockManager, times(2)).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager, times(2)).importBlock(block); } @Test @@ -290,10 +289,10 @@ void shouldRetryDifferentBlockOnSyncingResponse() { failurePool.addFailedBlock(block2); asyncRunner.executeQueuedActions(); - verify(blockManager).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager).importBlock(block); asyncRunner.executeQueuedActions(); - verify(blockManager).importBlock(block2, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager).importBlock(block2); } @Test @@ -305,18 +304,17 @@ void shouldRetryDifferentBlockOnFailureResponse() { failurePool.addFailedBlock(block2); asyncRunner.executeQueuedActions(); - verify(blockManager).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager).importBlock(block); asyncRunner.executeQueuedActions(); - verify(blockManager).importBlock(block2, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager).importBlock(block2); } @Test void shouldStopRetryingBlockWhenImportThrowsExceptionInsteadOfReturningFailedFuture() { final SignedBeaconBlock block2 = dataStructureUtil.randomSignedBeaconBlock(2); - when(blockManager.importBlock(block, BroadcastValidationLevel.NOT_REQUIRED)) - .thenThrow(new RuntimeException("Whoops")); - when(blockManager.importBlock(block2, BroadcastValidationLevel.NOT_REQUIRED)) + when(blockManager.importBlock(block)).thenThrow(new RuntimeException("Whoops")); + when(blockManager.importBlock(block2)) .thenReturn( SafeFuture.completedFuture( new BlockImportAndBroadcastValidationResults( @@ -326,15 +324,15 @@ void shouldStopRetryingBlockWhenImportThrowsExceptionInsteadOfReturningFailedFut failurePool.addFailedBlock(block2); asyncRunner.executeQueuedActions(); - verify(blockManager).importBlock(block, BroadcastValidationLevel.NOT_REQUIRED); - verify(blockManager).importBlock(block2, BroadcastValidationLevel.NOT_REQUIRED); + verify(blockManager).importBlock(block); + verify(blockManager).importBlock(block2); verifyNoMoreInteractions(blockManager); assertThat(asyncRunner.hasDelayedActions()).isFalse(); } private void withImportResult(final BlockImportResult result) { - when(blockManager.importBlock(any(), any())) + when(blockManager.importBlock(any())) .thenReturn( SafeFuture.completedFuture( new BlockImportAndBroadcastValidationResults(SafeFuture.completedFuture(result)))); diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/DasCustodySyncTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/DasCustodySyncTest.java index c6f3f868d00..dfc79fcdca9 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/DasCustodySyncTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/DasCustodySyncTest.java @@ -43,7 +43,7 @@ public class DasCustodySyncTest { static final int MAX_AVERAGE_BLOCK_DB_READS_PER_SLOT = 30; final Spec spec = - TestSpecFactory.createMinimalEip7594( + TestSpecFactory.createMinimalElectraEip7594( builder -> builder.eip7594Builder( dasBuilder -> @@ -306,7 +306,7 @@ void shouldCancelRetrieverRequestWhenCanonicalBlockChanges() { assertThat(retrieverStub.requests).hasSize(retrieveRequests_1_0.size() * 2); } - private void addBlockAndSidecars(int slot) { + private void addBlockAndSidecars(final int slot) { SignedBeaconBlock block = custodyStand.createBlockWithBlobs(slot); custodyStand.blockResolver.addBlock(block.getMessage()); List columnSidecars = custodyStand.createCustodyColumnSidecars(block); @@ -318,7 +318,7 @@ private void assertAllCustodyColumnsPresent() { custodyStand.getMinCustodySlot().intValue(), custodyStand.getCurrentSlot().intValue()); } - private void assertCustodyColumnsPresent(int fromSlot, int tillSlot) { + private void assertCustodyColumnsPresent(final int fromSlot, final int tillSlot) { for (int slot = fromSlot; slot < tillSlot; slot++) { UInt64 uSlot = UInt64.valueOf(slot); Optional maybeBlock = custodyStand.blockResolver.getBlockAtSlot(uSlot).join(); @@ -351,11 +351,11 @@ private void advanceTimeGraduallyUntilAllDone() { custodyStand.advanceTimeGraduallyUntilAllDone(ofMinutes(1)); } - private T await(CompletableFuture future) { + private T await(final CompletableFuture future) { return await(future, ofMinutes(1)); } - private T await(CompletableFuture future, Duration maxWait) { + private T await(final CompletableFuture future, final Duration maxWait) { for (int i = 0; i < maxWait.toMillis(); i++) { if (future.isDone()) { try { diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/DasLongPollCustodyTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/DasLongPollCustodyTest.java index 93d2d10acb8..37f7b9fdd94 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/DasLongPollCustodyTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/DasLongPollCustodyTest.java @@ -28,7 +28,7 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.TestSpecFactory; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.features.Eip7594; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSidecar; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockHeader; @@ -43,7 +43,7 @@ public class DasLongPollCustodyTest { final StubTimeProvider stubTimeProvider = StubTimeProvider.withTimeInSeconds(0); final StubAsyncRunner stubAsyncRunner = new StubAsyncRunner(stubTimeProvider); - final Spec spec = TestSpecFactory.createMinimalEip7594(); + final Spec spec = TestSpecFactory.createMinimalElectraEip7594(); final DataColumnSidecarDB db = new DataColumnSidecarDBStub(); final Duration dbDelay = ofMillis(5); final DelayedDasDb delayedDb = new DelayedDasDb(db, stubAsyncRunner, dbDelay); @@ -52,8 +52,7 @@ public class DasLongPollCustodyTest { final CanonicalBlockResolverStub blockResolver = new CanonicalBlockResolverStub(spec); final UInt256 myNodeId = UInt256.ONE; - final SpecConfigEip7594 config = - SpecConfigEip7594.required(spec.forMilestone(SpecMilestone.EIP7594).getConfig()); + final Eip7594 config = Eip7594.required(spec.forMilestone(SpecMilestone.ELECTRA).getConfig()); final int subnetCount = config.getDataColumnSidecarSubnetCount(); final DataColumnSidecarCustodyImpl custodyImpl = @@ -78,15 +77,15 @@ public class DasLongPollCustodyTest { private final DataColumnSlotAndIdentifier columnId10_1 = DataColumnSlotAndIdentifier.fromDataColumn(sidecar10_1); - private DataColumnSidecar createSidecar(BeaconBlock block, int column) { + private DataColumnSidecar createSidecar(final BeaconBlock block, final int column) { return dataStructureUtil.randomDataColumnSidecar(createSigned(block), UInt64.valueOf(column)); } - private SignedBeaconBlockHeader createSigned(BeaconBlock block) { + private SignedBeaconBlockHeader createSigned(final BeaconBlock block) { return dataStructureUtil.signedBlock(block).asHeader(); } - private void advanceTimeGradually(Duration delta) { + private void advanceTimeGradually(final Duration delta) { for (int i = 0; i < delta.toMillis(); i++) { stubTimeProvider.advanceTimeBy(ofMillis(1)); stubAsyncRunner.executeDueActionsRepeatedly(); diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/DataColumnSidecarCustodyImplTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/DataColumnSidecarCustodyImplTest.java index f28fcb095e2..2e450f073e3 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/DataColumnSidecarCustodyImplTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/DataColumnSidecarCustodyImplTest.java @@ -24,7 +24,7 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.TestSpecFactory; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.features.Eip7594; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSidecar; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockHeader; @@ -36,25 +36,23 @@ @SuppressWarnings({"JavaCase", "FutureReturnValueIgnored"}) public class DataColumnSidecarCustodyImplTest { - final Spec spec = TestSpecFactory.createMinimalEip7594(); + final Spec spec = TestSpecFactory.createMinimalElectraEip7594(); final DataColumnSidecarDB db = new DataColumnSidecarDBStub(); final DataColumnSidecarDbAccessor dbAccessor = DataColumnSidecarDbAccessor.builder(db).spec(spec).build(); final CanonicalBlockResolverStub blockResolver = new CanonicalBlockResolverStub(spec); final UInt256 myNodeId = UInt256.ONE; - final SpecConfigEip7594 config = - SpecConfigEip7594.required(spec.forMilestone(SpecMilestone.EIP7594).getConfig()); + final Eip7594 config = Eip7594.required(spec.forMilestone(SpecMilestone.ELECTRA).getConfig()); final int subnetCount = config.getDataColumnSidecarSubnetCount(); - final int custodyCount = config.getCustodyRequirement(); private final DataStructureUtil dataStructureUtil = new DataStructureUtil(0, spec); - private DataColumnSidecar createSidecar(BeaconBlock block, int column) { + private DataColumnSidecar createSidecar(final BeaconBlock block, final int column) { return dataStructureUtil.randomDataColumnSidecar(createSigned(block), UInt64.valueOf(column)); } - private SignedBeaconBlockHeader createSigned(BeaconBlock block) { + private SignedBeaconBlockHeader createSigned(final BeaconBlock block) { return dataStructureUtil.signedBlock(block).asHeader(); } diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/LinkedObjectsDeliveryTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/LinkedObjectsDeliveryTest.java index 1c2bfb03817..d380edb0874 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/LinkedObjectsDeliveryTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/LinkedObjectsDeliveryTest.java @@ -31,7 +31,7 @@ public class LinkedObjectsDeliveryTest { private final DataStructureUtil dataStructureUtil = - new DataStructureUtil(TestSpecFactory.createMinimalEip7594()); + new DataStructureUtil(TestSpecFactory.createMinimalElectraEip7594()); private final ExecutorService executorService = Executors.newFixedThreadPool(4); private final AsyncRunnerFactory asyncRunnerFactory = AsyncRunnerFactory.createDefault(new MetricTrackingExecutorFactory(new StubMetricsSystem())); @@ -71,7 +71,7 @@ private synchronized void reqRespCompleted(final SafeFuture r static class Sync { final Retriever retriever; - public Sync(Retriever retriever) { + public Sync(final Retriever retriever) { this.retriever = retriever; } diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/db/AutoPruningDasDbTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/db/AutoPruningDasDbTest.java index a9b79599493..fa06b68d7bb 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/db/AutoPruningDasDbTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/db/AutoPruningDasDbTest.java @@ -28,7 +28,7 @@ @SuppressWarnings("FutureReturnValueIgnored") public class AutoPruningDasDbTest { - final Spec spec = TestSpecFactory.createMinimalEip7594(); + final Spec spec = TestSpecFactory.createMinimalElectraEip7594(); final DasCustodyStand das = DasCustodyStand.builder(spec).build(); final int custodyPeriodSlots = 10; final int custodyPeriodMarginSlots = 2; @@ -39,7 +39,7 @@ public class AutoPruningDasDbTest { new AutoPruningDasDb( das.db, minCustodyPeriodSlotCalculator, custodyPeriodMarginSlots, prunePeriodSlots); - private DataColumnSidecar createSidecar(int slot, int index) { + private DataColumnSidecar createSidecar(final int slot, final int index) { SignedBeaconBlock block = das.createBlockWithBlobs(slot); return das.createSidecar(block, index); } diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/db/ColumnIdCachingDasDbTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/db/ColumnIdCachingDasDbTest.java index 49359b4206f..e71c0f3def3 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/db/ColumnIdCachingDasDbTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/db/ColumnIdCachingDasDbTest.java @@ -36,7 +36,7 @@ @SuppressWarnings("FutureReturnValueIgnored") public class ColumnIdCachingDasDbTest { - final Spec spec = TestSpecFactory.createMinimalEip7594(); + final Spec spec = TestSpecFactory.createMinimalElectraEip7594(); final DataStructureUtil dataStructureUtil = new DataStructureUtil(0, spec); final Duration dbDelay = ofMillis(5); @@ -48,11 +48,12 @@ public class ColumnIdCachingDasDbTest { final int cacheSize = 2; ColumnIdCachingDasDb columnIdCachingDb = new ColumnIdCachingDasDb(asyncDb, __ -> 128, cacheSize); - private DataColumnSidecar createSidecar(int slot, int index) { - UInt64 slotU = UInt64.valueOf(slot); - BeaconBlockBody beaconBlockBody = dataStructureUtil.randomBeaconBlockBodyWithCommitments(1); - BeaconBlock block = dataStructureUtil.randomBeaconBlock(slotU, beaconBlockBody); - SignedBeaconBlock signedBlock = dataStructureUtil.signedBlock(block); + private DataColumnSidecar createSidecar(final int slot, final int index) { + final UInt64 slotU = UInt64.valueOf(slot); + final BeaconBlockBody beaconBlockBody = + dataStructureUtil.randomBeaconBlockBodyWithCommitments(1); + final BeaconBlock block = dataStructureUtil.randomBeaconBlock(slotU, beaconBlockBody); + final SignedBeaconBlock signedBlock = dataStructureUtil.signedBlock(block); return dataStructureUtil.randomDataColumnSidecar(signedBlock.asHeader(), UInt64.valueOf(index)); } diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/retriever/RecoveringSidecarRetrieverTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/retriever/RecoveringSidecarRetrieverTest.java index f0b4a7c6b65..e0647fa7699 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/retriever/RecoveringSidecarRetrieverTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/retriever/RecoveringSidecarRetrieverTest.java @@ -29,13 +29,13 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.TestSpecFactory; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.features.Eip7594; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.Blob; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSidecar; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.util.DataColumnSlotAndIdentifier; -import tech.pegasys.teku.spec.logic.versions.eip7594.helpers.MiscHelpersEip7594; +import tech.pegasys.teku.spec.logic.versions.feature.eip7594.helpers.MiscHelpersEip7594; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsEip7594; import tech.pegasys.teku.spec.util.DataStructureUtil; import tech.pegasys.teku.statetransition.datacolumns.CanonicalBlockResolverStub; @@ -47,19 +47,18 @@ public class RecoveringSidecarRetrieverTest { final StubAsyncRunner stubAsyncRunner = new StubAsyncRunner(); - final Spec spec = TestSpecFactory.createMinimalEip7594(); + final Spec spec = TestSpecFactory.createMinimalElectraEip7594(); final DataColumnSidecarDB db = new DataColumnSidecarDBStub(); final DataColumnSidecarDbAccessor dbAccessor = DataColumnSidecarDbAccessor.builder(db).spec(spec).build(); final CanonicalBlockResolverStub blockResolver = new CanonicalBlockResolverStub(spec); - final SpecConfigEip7594 config = - SpecConfigEip7594.required(spec.forMilestone(SpecMilestone.EIP7594).getConfig()); + final Eip7594 config = Eip7594.required(spec.forMilestone(SpecMilestone.ELECTRA).getConfig()); final MiscHelpersEip7594 miscHelpers = - MiscHelpersEip7594.required(spec.forMilestone(SpecMilestone.EIP7594).miscHelpers()); + MiscHelpersEip7594.required(spec.forMilestone(SpecMilestone.ELECTRA).miscHelpers()); final SchemaDefinitionsEip7594 schemaDefinitions = SchemaDefinitionsEip7594.required( - spec.forMilestone(SpecMilestone.EIP7594).getSchemaDefinitions()); + spec.forMilestone(SpecMilestone.ELECTRA).getSchemaDefinitions()); final int columnCount = config.getNumberOfColumns(); final KZG kzg = KZG.getInstance(false); @@ -69,11 +68,11 @@ public RecoveringSidecarRetrieverTest() { TrustedSetupLoader.loadTrustedSetupForTests(kzg); } - private SignedBeaconBlock createSigned(BeaconBlock block) { + private SignedBeaconBlock createSigned(final BeaconBlock block) { return dataStructureUtil.signedBlock(block); } - private DataColumnSlotAndIdentifier createId(BeaconBlock block, int colIdx) { + private DataColumnSlotAndIdentifier createId(final BeaconBlock block, final int colIdx) { return new DataColumnSlotAndIdentifier( block.getSlot(), block.getRoot(), UInt64.valueOf(colIdx)); } diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/retriever/SimpleSidecarRetrieverTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/retriever/SimpleSidecarRetrieverTest.java index 059513102e1..1f51deb1010 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/retriever/SimpleSidecarRetrieverTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/retriever/SimpleSidecarRetrieverTest.java @@ -34,13 +34,13 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.TestSpecFactory; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.features.Eip7594; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.Blob; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSidecar; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.util.DataColumnSlotAndIdentifier; -import tech.pegasys.teku.spec.logic.versions.eip7594.helpers.MiscHelpersEip7594; +import tech.pegasys.teku.spec.logic.versions.feature.eip7594.helpers.MiscHelpersEip7594; import tech.pegasys.teku.spec.util.DataStructureUtil; import tech.pegasys.teku.statetransition.datacolumns.CanonicalBlockResolverStub; @@ -51,11 +51,10 @@ public class SimpleSidecarRetrieverTest { final DataColumnPeerSearcherStub dataColumnPeerSearcherStub = new DataColumnPeerSearcherStub(); final TestPeerManager testPeerManager = new TestPeerManager(); - final Spec spec = TestSpecFactory.createMinimalEip7594(); - final SpecConfigEip7594 config = - SpecConfigEip7594.required(spec.forMilestone(SpecMilestone.EIP7594).getConfig()); + final Spec spec = TestSpecFactory.createMinimalElectraEip7594(); + final Eip7594 config = Eip7594.required(spec.forMilestone(SpecMilestone.ELECTRA).getConfig()); final MiscHelpersEip7594 miscHelpers = - MiscHelpersEip7594.required(spec.forMilestone(SpecMilestone.EIP7594).miscHelpers()); + MiscHelpersEip7594.required(spec.forMilestone(SpecMilestone.ELECTRA).miscHelpers()); final int columnCount = config.getNumberOfColumns(); final KZG kzg = KZG.getInstance(false); @@ -85,16 +84,16 @@ public SimpleSidecarRetrieverTest() { TrustedSetupLoader.loadTrustedSetupForTests(kzg); } - private SignedBeaconBlock createSigned(BeaconBlock block) { + private SignedBeaconBlock createSigned(final BeaconBlock block) { return dataStructureUtil.signedBlock(block); } - private DataColumnSlotAndIdentifier createId(BeaconBlock block, int colIdx) { + private DataColumnSlotAndIdentifier createId(final BeaconBlock block, final int colIdx) { return new DataColumnSlotAndIdentifier( block.getSlot(), block.getRoot(), UInt64.valueOf(colIdx)); } - List nodeCustodyColumns(UInt256 nodeId) { + List nodeCustodyColumns(final UInt256 nodeId) { return miscHelpers.computeCustodyColumnIndexes( nodeId, custodyCountSupplier.getCustodyCountForPeer(nodeId)); } @@ -103,15 +102,15 @@ Stream craftNodeIds() { return IntStream.iterate(0, i -> i + 1).mapToObj(UInt256::valueOf); } - Stream craftNodeIdsCustodyOf(UInt64 custodyColumn) { + Stream craftNodeIdsCustodyOf(final UInt64 custodyColumn) { return craftNodeIds().filter(nodeId -> nodeCustodyColumns(nodeId).contains(custodyColumn)); } - Stream craftNodeIdsNotCustodyOf(UInt64 custodyColumn) { + Stream craftNodeIdsNotCustodyOf(final UInt64 custodyColumn) { return craftNodeIds().filter(nodeId -> !nodeCustodyColumns(nodeId).contains(custodyColumn)); } - private void advanceTimeGradually(Duration delta) { + private void advanceTimeGradually(final Duration delta) { for (int i = 0; i < delta.toMillis(); i++) { stubTimeProvider.advanceTimeBy(Duration.ofMillis(1)); stubAsyncRunner.executeDueActionsRepeatedly(); diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/util/StringifyUtilTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/util/StringifyUtilTest.java index a84e8c2f31e..4118a2bce16 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/util/StringifyUtilTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/datacolumns/util/StringifyUtilTest.java @@ -33,9 +33,9 @@ public String toString() { } } - static int maxIndexesLen = 128; + static final int MAX_INDEXES_LEN = 128; - static List testCases = + static final List TEST_CASES = List.of( new TestCase(IntStream.empty(), "[]"), new TestCase(range(0, 128), "[all]"), @@ -57,14 +57,14 @@ public String toString() { "[10..13,15,17,19..97,99]")); private static Stream provideTestCaseParameters() { - return testCases.stream().map(Arguments::of); + return TEST_CASES.stream().map(Arguments::of); } @ParameterizedTest @MethodSource("provideTestCaseParameters") - void columnIndexesToString_test(TestCase testCase) { + void columnIndexesToString_test(final TestCase testCase) { List idxList = testCase.indexes.boxed().toList(); - String s = StringifyUtil.columnIndexesToString(idxList, maxIndexesLen); + String s = StringifyUtil.columnIndexesToString(idxList, MAX_INDEXES_LEN); System.out.println(s); assertThat(s).isEqualTo("(len: " + idxList.size() + ") " + testCase.expectedString); } diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/BlobSidecarsAvailabilityCheckerTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/BlobSidecarsAvailabilityCheckerTest.java index e60899f7255..e534111dc78 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/BlobSidecarsAvailabilityCheckerTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/BlobSidecarsAvailabilityCheckerTest.java @@ -216,8 +216,8 @@ void shouldReturnNotAvailableIfFirstBatchFails(final BatchFailure batchFailure) final Optional cause = switch (batchFailure) { - case BLOB_SIDECAR_VALIDATION_EXCEPTION, IS_DATA_AVAILABLE_EXCEPTION -> Optional.of( - new RuntimeException("oops")); + case BLOB_SIDECAR_VALIDATION_EXCEPTION, IS_DATA_AVAILABLE_EXCEPTION -> + Optional.of(new RuntimeException("oops")); default -> Optional.empty(); }; @@ -230,14 +230,14 @@ void shouldReturnNotAvailableIfFirstBatchFails(final BatchFailure batchFailure) assertThat(blobSidecarsAvailabilityChecker.initiateDataAvailabilityCheck()).isTrue(); switch (batchFailure) { - // blobsidecar validation check failure for the initial set - case BLOB_SIDECAR_VALIDATION_EXCEPTION -> throwWhenValidatingBlobSidecarsBatchAgainstBlock( - blobSidecarsInitial, cause.get()); - // mock kzg availability check failure for the initial set - case IS_DATA_AVAILABLE_EXCEPTION -> whenDataAvailability(blobSidecarsInitial) - .thenThrow(cause.get()); - case IS_DATA_AVAILABLE_RETURN_FALSE -> whenDataAvailability(blobSidecarsInitial) - .thenReturn(false); + // blobsidecar validation check failure for the initial set + case BLOB_SIDECAR_VALIDATION_EXCEPTION -> + throwWhenValidatingBlobSidecarsBatchAgainstBlock(blobSidecarsInitial, cause.get()); + // mock kzg availability check failure for the initial set + case IS_DATA_AVAILABLE_EXCEPTION -> + whenDataAvailability(blobSidecarsInitial).thenThrow(cause.get()); + case IS_DATA_AVAILABLE_RETURN_FALSE -> + whenDataAvailability(blobSidecarsInitial).thenReturn(false); } asyncRunner.executeDueActions(); @@ -252,8 +252,8 @@ void shouldReturnNotAvailableIfSecondBatchFails(final BatchFailure batchFailure) final Optional cause = switch (batchFailure) { - case BLOB_SIDECAR_VALIDATION_EXCEPTION, IS_DATA_AVAILABLE_EXCEPTION -> Optional.of( - new RuntimeException("oops")); + case BLOB_SIDECAR_VALIDATION_EXCEPTION, IS_DATA_AVAILABLE_EXCEPTION -> + Optional.of(new RuntimeException("oops")); default -> Optional.empty(); }; @@ -272,14 +272,14 @@ void shouldReturnNotAvailableIfSecondBatchFails(final BatchFailure batchFailure) asyncRunner.executeDueActions(); switch (batchFailure) { - // blobsidecar validation check failure for the additional set - case BLOB_SIDECAR_VALIDATION_EXCEPTION -> throwWhenValidatingBlobSidecarsBatchAgainstBlock( - blobSidecarsAdditional, cause.get()); - // mock kzg availability check failure for the additional set - case IS_DATA_AVAILABLE_EXCEPTION -> whenDataAvailability(blobSidecarsAdditional) - .thenThrow(cause.get()); - case IS_DATA_AVAILABLE_RETURN_FALSE -> whenDataAvailability(blobSidecarsAdditional) - .thenReturn(false); + // blobsidecar validation check failure for the additional set + case BLOB_SIDECAR_VALIDATION_EXCEPTION -> + throwWhenValidatingBlobSidecarsBatchAgainstBlock(blobSidecarsAdditional, cause.get()); + // mock kzg availability check failure for the additional set + case IS_DATA_AVAILABLE_EXCEPTION -> + whenDataAvailability(blobSidecarsAdditional).thenThrow(cause.get()); + case IS_DATA_AVAILABLE_RETURN_FALSE -> + whenDataAvailability(blobSidecarsAdditional).thenReturn(false); } // let the tracker complete with all blobSidecars @@ -455,7 +455,7 @@ private void assertNotAvailable( } private void assertAvailable( - SafeFuture> availabilityOrValidityCheck) { + final SafeFuture> availabilityOrValidityCheck) { assertThat(availabilityOrValidityCheck) .isCompletedWithValueMatching(result -> !result.isFailure(), "is not failure") .isCompletedWithValueMatching(DataAndValidationResult::isValid, "is valid") diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoiceNotifierTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoiceNotifierTest.java index ba3d39bbffa..334b5acb287 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoiceNotifierTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoiceNotifierTest.java @@ -54,8 +54,8 @@ import tech.pegasys.teku.spec.datastructures.builder.SignedValidatorRegistration; import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadContext; import tech.pegasys.teku.spec.datastructures.forkchoice.ReadOnlyForkChoiceStrategy; -import tech.pegasys.teku.spec.datastructures.operations.versions.bellatrix.BeaconPreparableProposer; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.datastructures.validator.BeaconPreparableProposer; import tech.pegasys.teku.spec.executionlayer.ExecutionLayerChannel; import tech.pegasys.teku.spec.executionlayer.ExecutionPayloadStatus; import tech.pegasys.teku.spec.executionlayer.ForkChoiceState; @@ -151,7 +151,7 @@ void setUp( when(executionLayerChannel.builderRegisterValidators(any(), any())) .thenReturn(SafeFuture.COMPLETE); - when(executionLayerChannel.engineNewPayload(any())) + when(executionLayerChannel.engineNewPayload(any(), any())) .thenReturn(SafeFuture.completedFuture(PayloadStatus.VALID)); when(executionLayerChannel.engineForkChoiceUpdated(any(), any())) .thenReturn( @@ -191,7 +191,7 @@ void reInitializePreMerge() { forkChoiceStrategy = recentChainData.getForkChoiceStrategy().orElseThrow(); } - private void doMerge(Bytes32 terminalBlockHash) { + private void doMerge(final Bytes32 terminalBlockHash) { // advance chain with the terminal block SignedBlockAndState newBlockWithExecutionPayloadAtopTerminalBlock = storageSystem @@ -1095,6 +1095,8 @@ private PayloadBuildingAttributes getExpectedPayloadBuildingAttributes( overrideFeeRecipient.orElse(dataStructureUtil.randomEth1Address()); final UInt64 timestamp = spec.computeTimeAtSlot(headState, blockSlot); final Bytes32 random = spec.getRandaoMix(headState, UInt64.ZERO); + final Optional maxBlobsPerBlock = + spec.getMaxBlobsPerBlockForHighestMilestone().map(UInt64::valueOf); return new PayloadBuildingAttributes( proposerIndex, blockSlot, @@ -1103,7 +1105,9 @@ private PayloadBuildingAttributes getExpectedPayloadBuildingAttributes( feeRecipient, validatorRegistration, dataStructureUtil.randomWithdrawalList(), - forkChoiceState.getHeadBlockRoot()); + forkChoiceState.getHeadBlockRoot(), + maxBlobsPerBlock.map(maxBlobs -> maxBlobs.dividedBy(2)), + maxBlobsPerBlock); } private ForkChoiceState getCurrentForkChoiceState() { @@ -1135,7 +1139,7 @@ private SignedValidatorRegistration createValidatorRegistration( } private ForkChoiceUpdatedResult createForkChoiceUpdatedResult( - ExecutionPayloadStatus status, Optional payloadId) { + final ExecutionPayloadStatus status, final Optional payloadId) { return new ForkChoiceUpdatedResult( PayloadStatus.create(status, Optional.empty(), Optional.empty()), payloadId); } diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoicePayloadExecutorTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoicePayloadExecutorTest.java index 32c4e6dc82a..13e4818e9ed 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoicePayloadExecutorTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoicePayloadExecutorTest.java @@ -28,6 +28,7 @@ import org.junit.jupiter.api.Test; import tech.pegasys.teku.bls.BLSSignatureVerifier; import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; @@ -74,14 +75,14 @@ public static void resetSession() { @BeforeEach void setUp() { - when(executionLayer.engineNewPayload(any())).thenReturn(executionResult); + when(executionLayer.engineNewPayload(any(), any())).thenReturn(executionResult); } @Test void optimisticallyExecute_shouldSendToExecutionEngineAndReturnTrue() { final ForkChoicePayloadExecutor payloadExecutor = createPayloadExecutor(); final boolean result = payloadExecutor.optimisticallyExecute(payloadHeader, payloadRequest); - verify(executionLayer).engineNewPayload(payloadRequest); + verify(executionLayer).engineNewPayload(payloadRequest, UInt64.ZERO); assertThat(result).isTrue(); } @@ -90,7 +91,7 @@ void optimisticallyExecute_shouldNotExecuteDefaultPayload() { final ForkChoicePayloadExecutor payloadExecutor = createPayloadExecutor(); final boolean result = payloadExecutor.optimisticallyExecute(payloadHeader, defaultPayloadRequest); - verify(executionLayer, never()).engineNewPayload(any()); + verify(executionLayer, never()).engineNewPayload(any(), any()); assertThat(result).isTrue(); assertThat(payloadExecutor.getExecutionResult()) .isCompletedWithValue(new PayloadValidationResult(PayloadStatus.VALID)); @@ -98,7 +99,7 @@ void optimisticallyExecute_shouldNotExecuteDefaultPayload() { @Test void optimisticallyExecute_shouldValidateMergeBlockWhenThisIsTheMergeBlock() { - when(executionLayer.engineNewPayload(payloadRequest)) + when(executionLayer.engineNewPayload(payloadRequest, UInt64.ZERO)) .thenReturn(SafeFuture.completedFuture(VALID)); when(executionLayer.eth1GetPowBlock(payload.getParentHash())).thenReturn(new SafeFuture<>()); final ForkChoicePayloadExecutor payloadExecutor = createPayloadExecutor(); @@ -106,14 +107,14 @@ void optimisticallyExecute_shouldValidateMergeBlockWhenThisIsTheMergeBlock() { payloadExecutor.optimisticallyExecute(defaultPayloadHeader, payloadRequest); // Should execute first and then begin validation of the transition block conditions. - verify(executionLayer).engineNewPayload(payloadRequest); + verify(executionLayer).engineNewPayload(payloadRequest, UInt64.ZERO); verify(transitionValidator).verifyTransitionBlock(defaultPayloadHeader, block); assertThat(result).isTrue(); } @Test void optimisticallyExecute_shouldReturnFailedExecutionOnMergeBlockWhenELOfflineAtExecution() { - when(executionLayer.engineNewPayload(payloadRequest)) + when(executionLayer.engineNewPayload(payloadRequest, UInt64.ZERO)) .thenReturn(SafeFuture.failedFuture(new Error())); final ForkChoicePayloadExecutor payloadExecutor = createPayloadExecutor(); final boolean execution = @@ -121,7 +122,7 @@ void optimisticallyExecute_shouldReturnFailedExecutionOnMergeBlockWhenELOfflineA // Should not attempt to validate transition conditions because execute payload failed verify(transitionValidator, never()).verifyTransitionBlock(defaultPayloadHeader, block); - verify(executionLayer).engineNewPayload(payloadRequest); + verify(executionLayer).engineNewPayload(payloadRequest, UInt64.ZERO); assertThat(execution).isTrue(); assertThat(payloadExecutor.getExecutionResult()) .isCompletedWithValueMatching(result -> result.getStatus().hasFailedExecution()); @@ -130,7 +131,7 @@ void optimisticallyExecute_shouldReturnFailedExecutionOnMergeBlockWhenELOfflineA @Test void optimisticallyExecute_shouldReturnFailedExecutionOnMergeBlockWhenELGoesOfflineAfterExecution() { - when(executionLayer.engineNewPayload(payloadRequest)) + when(executionLayer.engineNewPayload(payloadRequest, UInt64.ZERO)) .thenReturn(SafeFuture.completedFuture(VALID)); when(transitionValidator.verifyTransitionBlock(defaultPayloadHeader, block)) .thenReturn(SafeFuture.failedFuture(new Error())); @@ -139,7 +140,7 @@ void optimisticallyExecute_shouldReturnFailedExecutionOnMergeBlockWhenELOfflineA payloadExecutor.optimisticallyExecute(defaultPayloadHeader, payloadRequest); verify(transitionValidator).verifyTransitionBlock(defaultPayloadHeader, block); - verify(executionLayer).engineNewPayload(payloadRequest); + verify(executionLayer).engineNewPayload(payloadRequest, UInt64.ZERO); assertThat(execution).isTrue(); assertThat(payloadExecutor.getExecutionResult()) .isCompletedWithValueMatching(result -> result.getStatus().hasFailedExecution()); @@ -149,13 +150,13 @@ void optimisticallyExecute_shouldReturnFailedExecutionOnMergeBlockWhenELOfflineA void optimisticallyExecute_shouldNotVerifyTransitionIfExecutePayloadIsInvalid() { final PayloadStatus expectedResult = PayloadStatus.invalid(Optional.empty(), Optional.of("Nope")); - when(executionLayer.engineNewPayload(payloadRequest)) + when(executionLayer.engineNewPayload(payloadRequest, UInt64.ZERO)) .thenReturn(SafeFuture.completedFuture(expectedResult)); final ForkChoicePayloadExecutor payloadExecutor = createPayloadExecutor(); final boolean execution = payloadExecutor.optimisticallyExecute(defaultPayloadHeader, payloadRequest); - verify(executionLayer).engineNewPayload(payloadRequest); + verify(executionLayer).engineNewPayload(payloadRequest, UInt64.ZERO); verify(transitionValidator, never()).verifyTransitionBlock(defaultPayloadHeader, block); assertThat(execution).isTrue(); assertThat(payloadExecutor.getExecutionResult()) diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoiceTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoiceTest.java index 45181b2abc8..3e99a4f9409 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoiceTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/ForkChoiceTest.java @@ -73,9 +73,9 @@ import tech.pegasys.teku.spec.datastructures.execution.PowBlock; import tech.pegasys.teku.spec.datastructures.forkchoice.ReadOnlyForkChoiceStrategy; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; -import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestation.IndexedAttestationSchema; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; +import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestationSchema; import tech.pegasys.teku.spec.datastructures.state.Checkpoint; import tech.pegasys.teku.spec.datastructures.util.AttestationProcessingResult; import tech.pegasys.teku.spec.executionlayer.ExecutionLayerChannelStub; @@ -96,6 +96,7 @@ import tech.pegasys.teku.statetransition.datacolumns.DasSamplerManager; import tech.pegasys.teku.statetransition.forkchoice.ForkChoice.OptimisticHeadSubscriber; import tech.pegasys.teku.statetransition.forkchoice.ForkChoiceUpdatedResultSubscriber.ForkChoiceUpdatedResultNotification; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.statetransition.validation.BlockBroadcastValidator; import tech.pegasys.teku.statetransition.validation.BlockBroadcastValidator.BroadcastValidationResult; import tech.pegasys.teku.storage.api.TrackingChainHeadChannel.ReorgEvent; @@ -118,7 +119,7 @@ class ForkChoiceTest { private final AvailabilityChecker blobSidecarsAvailabilityChecker = mock(AvailabilityChecker.class); - private AttestationSchema attestationSchema; + private AttestationSchema attestationSchema; private StorageSystem storageSystem; private ChainBuilder chainBuilder; private SignedBlockAndState genesis; @@ -132,6 +133,7 @@ class ForkChoiceTest { mock(BlockBroadcastValidator.class); private final MergeTransitionBlockValidator transitionBlockValidator = mock(MergeTransitionBlockValidator.class); + private final DebugDataDumper debugDataDumper = mock(DebugDataDumper.class); private final InlineEventThread eventThread = new InlineEventThread(); @@ -169,6 +171,7 @@ private void setupWithSpec(final Spec unmockedSpec) { new TickProcessor(spec, recentChainData), transitionBlockValidator, DEFAULT_FORK_CHOICE_LATE_BLOCK_REORG_ENABLED, + debugDataDumper, metricsSystem); // Starting and mocks @@ -248,6 +251,30 @@ void onBlock_shouldFailIfBlobsAreNotAvailable() { verify(blobSidecarsAvailabilityChecker).getAvailabilityCheckResult(); } + @Test + void onBlock_shouldFailIfBlobsAreInvalid() { + setupWithSpec(TestSpecFactory.createMinimalDeneb()); + final SignedBlockAndState blockAndState = chainBuilder.generateBlockAtSlot(ONE); + storageSystem.chainUpdater().advanceCurrentSlotToAtLeast(blockAndState.getSlot()); + final List blobSidecars = + storageSystem + .chainStorage() + .getBlobSidecarsBySlotAndBlockRoot(blockAndState.getSlotAndBlockRoot()) + .join(); + + when(blobSidecarsAvailabilityChecker.getAvailabilityCheckResult()) + .thenReturn( + SafeFuture.completedFuture(DataAndValidationResult.invalidResult(blobSidecars))); + + importBlockAndAssertFailure( + blockAndState, FailureReason.FAILED_DATA_AVAILABILITY_CHECK_INVALID); + + verify(blobSidecarManager).createAvailabilityChecker(blockAndState.getBlock()); + verify(blobSidecarsAvailabilityChecker).initiateDataAvailabilityCheck(); + verify(blobSidecarsAvailabilityChecker).getAvailabilityCheckResult(); + verify(debugDataDumper).saveInvalidSidecars(blobSidecars, blockAndState.getBlock()); + } + @Test void onBlock_consensusValidationShouldNotResolveWhenDataAvailabilityFails() { setupWithSpec(TestSpecFactory.createMinimalDeneb()); @@ -289,8 +316,7 @@ void onBlock_shouldFailWhenBroadcastValidationFails() { void onBlock_consensusValidationShouldNotResolveWhenEarlyFails() { setupWithSpec(TestSpecFactory.createMinimalDeneb()); final List signedBlockAndStates = chainBuilder.generateBlocksUpToSlot(2); - final SignedBlockAndState wrongBlockAndState = - signedBlockAndStates.get(signedBlockAndStates.size() - 1); + final SignedBlockAndState wrongBlockAndState = signedBlockAndStates.getLast(); storageSystem.chainUpdater().advanceCurrentSlotToAtLeast(wrongBlockAndState.getSlot()); @@ -308,11 +334,17 @@ void onBlock_consensusValidationShouldNotResolveWhenStateTransitionFails() final BlockProcessor blockProcessor = mock(BlockProcessor.class); when(spec.getBlockProcessor(blockAndState.getSlot())).thenReturn(blockProcessor); + final Exception blockException = new StateTransitionException("error!"); when(blockProcessor.processAndValidateBlock(any(), any(), any(), any())) - .thenThrow(new StateTransitionException("error!")); + .thenThrow(blockException); importBlockAndAssertFailure(blockAndState, FailureReason.FAILED_STATE_TRANSITION); + verify(debugDataDumper) + .saveInvalidBlock( + eq(blockAndState.getBlock()), + eq(FailureReason.FAILED_STATE_TRANSITION.toString()), + eq(Optional.of(blockException))); verify(blockBroadcastValidator, never()).onConsensusValidationSucceeded(); } @@ -329,7 +361,7 @@ void onBlock_consensusValidationShouldReturnRegardlessExecutionPayloadValidation // let's prepare a mocked EL with lazy newPayload executionLayer = mock(ExecutionLayerChannelStub.class); final SafeFuture payloadStatusSafeFuture = new SafeFuture<>(); - when(executionLayer.engineNewPayload(any())).thenReturn(payloadStatusSafeFuture); + when(executionLayer.engineNewPayload(any(), any())).thenReturn(payloadStatusSafeFuture); // let's import a valid consensus block final SafeFuture importResult = @@ -342,8 +374,9 @@ void onBlock_consensusValidationShouldReturnRegardlessExecutionPayloadValidation // resolve with a failure payloadStatusSafeFuture.complete(PayloadStatus.invalid(Optional.empty(), Optional.empty())); - assertBlockImportFailure(importResult, FailureReason.FAILED_STATE_TRANSITION); + verify(debugDataDumper) + .saveInvalidBlock(any(), eq(FailureReason.FAILED_STATE_TRANSITION.toString()), any()); } @Test @@ -409,7 +442,7 @@ private static Stream provideArgumentsForShouldReorg() { @ParameterizedTest @MethodSource("provideArgumentsForShouldReorg") void onBlock_shouldReorgWhenProposerWeightingMakesForkBestChain( - long advanceTimeSlotMillis, boolean shouldReorg) { + final long advanceTimeSlotMillis, final boolean shouldReorg) { storageSystem.chainUpdater().setCurrentSlot(UInt64.valueOf(2)); final Spec spec = TestSpecFactory.createMinimalBellatrix(); forkChoice = @@ -424,6 +457,7 @@ void onBlock_shouldReorgWhenProposerWeightingMakesForkBestChain( new TickProcessor(spec, recentChainData), transitionBlockValidator, DEFAULT_FORK_CHOICE_LATE_BLOCK_REORG_ENABLED, + DebugDataDumper.NOOP, metricsSystem); final UInt64 currentSlot = recentChainData.getCurrentSlot().orElseThrow(); @@ -743,6 +777,11 @@ void onBlock_shouldNotOptimisticallyImportInvalidExecutionPayload() { storageSystem.chainUpdater().setCurrentSlot(slotToImport.increment()); importBlockAndAssertFailure( chainBuilder.generateNextBlock(), FailureReason.FAILED_STATE_TRANSITION); + verify(debugDataDumper) + .saveInvalidBlock( + eq(chainBuilder.getLatestBlockAndState().getBlock()), + eq(FailureReason.FAILED_STATE_TRANSITION.toString()), + any()); } @Test @@ -779,7 +818,11 @@ void onBlock_shouldChangeForkChoiceForLatestValidHashOnInvalidExecutionPayload() SignedBlockAndState invalidBlock = chainBuilder.generateNextBlock(); importBlockAndAssertFailure(invalidBlock, FailureReason.FAILED_STATE_TRANSITION); assertThat(forkChoice.processHead(invalidBlock.getSlot())).isCompleted(); - + verify(debugDataDumper) + .saveInvalidBlock( + eq(invalidBlock.getBlock()), + eq(FailureReason.FAILED_STATE_TRANSITION.toString()), + any()); assertHeadIsOptimistic(maybeValidBlock); assertThat(forkChoiceStrategy.getChainHeads().get(0).getRoot()) .isEqualTo(maybeValidBlock.getRoot()); @@ -1178,7 +1221,7 @@ private void prepEpochForJustification( importBlock(epoch2Block); } - private UInt64 prepFinalizeEpoch(long epoch) { + private UInt64 prepFinalizeEpoch(final long epoch) { final ChainUpdater chainUpdater = storageSystem.chainUpdater(); final UInt64 epochPlus2StartSlot = spec.computeStartSlotAtEpoch(UInt64.valueOf(epoch).plus(2)); @@ -1389,7 +1432,7 @@ private void setForkChoiceNotifierConsecutiveForkChoiceUpdatedResults( } private Answer getOnForkChoiceUpdatedResultAnswer( - Optional result) { + final Optional result) { return invocation -> { result.ifPresent( forkChoiceUpdatedResult -> diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/ProposerDataManagerTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/ProposerDataManagerTest.java index ec6b352c472..5130bd2bcd9 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/ProposerDataManagerTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/ProposerDataManagerTest.java @@ -34,8 +34,8 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.datastructures.builder.SignedValidatorRegistration; -import tech.pegasys.teku.spec.datastructures.operations.versions.bellatrix.BeaconPreparableProposer; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.datastructures.validator.BeaconPreparableProposer; import tech.pegasys.teku.spec.executionlayer.ExecutionLayerChannel; import tech.pegasys.teku.spec.util.DataStructureUtil; import tech.pegasys.teku.storage.client.RecentChainData; diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/ProposersDataManagerTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/ProposersDataManagerTest.java index fbae1010155..8327387efe5 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/ProposersDataManagerTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/ProposersDataManagerTest.java @@ -14,70 +14,156 @@ package tech.pegasys.teku.statetransition.forkchoice; import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; import java.util.List; import java.util.Optional; +import java.util.concurrent.ExecutionException; +import org.apache.tuweni.bytes.Bytes32; import org.hyperledger.besu.metrics.noop.NoOpMetricsSystem; import org.hyperledger.besu.plugin.services.MetricsSystem; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; import tech.pegasys.teku.ethereum.execution.types.Eth1Address; +import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.async.eventthread.EventThread; +import tech.pegasys.teku.infrastructure.async.eventthread.InlineEventThread; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.TestSpecContext; import tech.pegasys.teku.spec.TestSpecFactory; -import tech.pegasys.teku.spec.datastructures.operations.versions.bellatrix.BeaconPreparableProposer; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider; +import tech.pegasys.teku.spec.config.SpecConfigDeneb; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; +import tech.pegasys.teku.spec.datastructures.validator.BeaconPreparableProposer; import tech.pegasys.teku.spec.executionlayer.ExecutionLayerChannel; +import tech.pegasys.teku.spec.executionlayer.ForkChoiceState; +import tech.pegasys.teku.spec.executionlayer.PayloadBuildingAttributes; import tech.pegasys.teku.spec.util.DataStructureUtil; +import tech.pegasys.teku.storage.client.ChainHead; import tech.pegasys.teku.storage.client.RecentChainData; +@TestSpecContext(allMilestones = true) class ProposersDataManagerTest { - private final Spec spec = TestSpecFactory.createMinimalCapella(); - - private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); - + private final UInt64 currentForkEpoch = UInt64.valueOf(1); private final RecentChainData recentChainData = mock(RecentChainData.class); - private final ExecutionLayerChannel channel = ExecutionLayerChannel.NOOP; private final MetricsSystem metricsSystem = new NoOpMetricsSystem(); + private List proposers; - private final Eth1Address defaultAddress = dataStructureUtil.randomEth1Address(); - private final ProposersDataManager manager = - new ProposersDataManager( - mock(EventThread.class), - spec, - metricsSystem, - channel, - recentChainData, - Optional.of(defaultAddress), - false); + private Spec spec; + private DataStructureUtil dataStructureUtil; + private ProposersDataManager manager; + private Eth1Address defaultAddress; + private UInt64 currentForkFirstSlot; - final List proposers = - List.of( - new BeaconPreparableProposer(UInt64.ONE, dataStructureUtil.randomEth1Address()), - new BeaconPreparableProposer(UInt64.ZERO, defaultAddress)); + @BeforeEach + public void setUp(final TestSpecInvocationContextProvider.SpecContext specContext) { + spec = + switch (specContext.getSpecMilestone()) { + case PHASE0 -> TestSpecFactory.createMinimalPhase0(); + case ALTAIR -> TestSpecFactory.createMinimalWithAltairForkEpoch(currentForkEpoch); + case BELLATRIX -> TestSpecFactory.createMinimalWithBellatrixForkEpoch(currentForkEpoch); + case CAPELLA -> TestSpecFactory.createMinimalWithCapellaForkEpoch(currentForkEpoch); + case DENEB -> TestSpecFactory.createMinimalWithDenebForkEpoch(currentForkEpoch); + case ELECTRA -> TestSpecFactory.createMinimalWithElectraForkEpoch(currentForkEpoch); + case FULU -> TestSpecFactory.createMinimalWithFuluForkEpoch(currentForkEpoch); + }; + currentForkFirstSlot = spec.computeStartSlotAtEpoch(currentForkEpoch); + dataStructureUtil = specContext.getDataStructureUtil(); + defaultAddress = dataStructureUtil.randomEth1Address(); + manager = + new ProposersDataManager( + mock(EventThread.class), + spec, + metricsSystem, + channel, + recentChainData, + Optional.of(defaultAddress), + false); + proposers = + List.of( + new BeaconPreparableProposer(UInt64.ONE, dataStructureUtil.randomEth1Address()), + new BeaconPreparableProposer(UInt64.ZERO, defaultAddress)); + } - @Test + @TestTemplate void validatorIsConnected_notFound_withEmptyPreparedList() { assertThat(manager.validatorIsConnected(UInt64.ZERO, UInt64.ZERO)).isFalse(); } - @Test + @TestTemplate void validatorIsConnected_found_withPreparedProposer() { manager.updatePreparedProposers(proposers, UInt64.ONE); assertThat(manager.validatorIsConnected(UInt64.ONE, UInt64.valueOf(1))).isTrue(); } - @Test + @TestTemplate void validatorIsConnected_notFound_withDifferentPreparedProposer() { manager.updatePreparedProposers(proposers, UInt64.ONE); assertThat(manager.validatorIsConnected(UInt64.valueOf(2), UInt64.valueOf(2))).isFalse(); } - @Test + @TestTemplate void validatorIsConnected_notFound_withExpiredPreparedProposer() { manager.updatePreparedProposers(proposers, UInt64.ONE); assertThat(manager.validatorIsConnected(UInt64.ONE, UInt64.valueOf(26))).isFalse(); } + + @TestTemplate + void shouldSetMaxAndTargetBlobCount() throws ExecutionException, InterruptedException { + final Spec specMock = mock(Spec.class); + when(specMock.computeEpochAtSlot(any())).thenReturn(currentForkEpoch); + final UInt64 timestamp = dataStructureUtil.randomUInt64(); + when(specMock.computeTimeAtSlot(any(), any())).thenReturn(timestamp); + final Bytes32 random = dataStructureUtil.randomBytes32(); + when(specMock.getRandaoMix(any(), any())).thenReturn(random); + when(specMock.atSlot(currentForkFirstSlot)).thenReturn(spec.atSlot(currentForkFirstSlot)); + final InlineEventThread eventThread = new InlineEventThread(); + manager = + new ProposersDataManager( + eventThread, + specMock, + metricsSystem, + channel, + recentChainData, + Optional.of(defaultAddress), + true); + eventThread.markAsOnEventThread(); + final ForkChoiceUpdateData forkChoiceUpdateDataMock = mock(ForkChoiceUpdateData.class); + when(forkChoiceUpdateDataMock.hasHeadBlockHash()).thenReturn(true); + final ForkChoiceState forkChoiceStateMock = mock(ForkChoiceState.class); + when(forkChoiceStateMock.getHeadBlockRoot()).thenReturn(dataStructureUtil.randomBytes32()); + when(forkChoiceUpdateDataMock.getForkChoiceState()).thenReturn(forkChoiceStateMock); + when(recentChainData.isJustifiedCheckpointFullyValidated()).thenReturn(true); + final ChainHead chainHeadMock = mock(ChainHead.class); + when(chainHeadMock.getSlot()).thenReturn(UInt64.ZERO); + when(chainHeadMock.getRoot()).thenReturn(dataStructureUtil.randomBytes32()); + when(recentChainData.getChainHead()).thenReturn(Optional.of(chainHeadMock)); + final BeaconState beaconStateMock = mock(BeaconState.class); + when(chainHeadMock.getState()).thenReturn(SafeFuture.completedFuture(beaconStateMock)); + final SafeFuture> payloadBuildingAttributesFuture = + manager.calculatePayloadBuildingAttributes( + currentForkFirstSlot, true, forkChoiceUpdateDataMock, false); + final Optional maybePayloadBuildingAttributes = + payloadBuildingAttributesFuture.get(); + assertThat(maybePayloadBuildingAttributes).isPresent(); + assertThat(maybePayloadBuildingAttributes.get().getTargetBlobCount()) + .isEqualTo( + spec.atSlot(currentForkFirstSlot) + .getConfig() + .toVersionDeneb() + .map(SpecConfigDeneb::getTargetBlobsPerBlock) + .map(UInt64::valueOf)); + assertThat(maybePayloadBuildingAttributes.get().getMaximumBlobCount()) + .isEqualTo( + spec.atSlot(currentForkFirstSlot) + .getConfig() + .toVersionDeneb() + .map(SpecConfigDeneb::getMaxBlobsPerBlock) + .map(UInt64::valueOf)); + } } diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/TerminalPowBlockMonitorTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/TerminalPowBlockMonitorTest.java index 224363f8721..08f55709b27 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/TerminalPowBlockMonitorTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/forkchoice/TerminalPowBlockMonitorTest.java @@ -99,7 +99,7 @@ private void setUpTTDConfig() { bellatrixBuilder.bellatrixForkEpoch(BELLATRIX_FORK_EPOCH).terminalTotalDifficulty(TTD)); } - private void setUpCommon(Consumer bellatrixBuilder) { + private void setUpCommon(final Consumer bellatrixBuilder) { spec = TestSpecFactory.createBellatrix( SpecConfigLoader.loadConfig( @@ -126,13 +126,13 @@ private void setUpCommon(Consumer bellatrixBuilder) { terminalPowBlockMonitor.onNodeSyncStateChanged(true); } - private void goToSlot(UInt64 slot) { + private void goToSlot(final UInt64 slot) { storageSystem .chainUpdater() .updateBestBlock(storageSystem.chainUpdater().advanceChainUntil(slot)); } - private void doMerge(Bytes32 terminalBlockHash) { + private void doMerge(final Bytes32 terminalBlockHash) { SignedBlockAndState newBlockWithExecutionPayloadAtopTerminalBlock = storageSystem .chainUpdater() diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/genesis/GenesisHandlerTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/genesis/GenesisHandlerTest.java index 211826c2208..78512bb67c4 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/genesis/GenesisHandlerTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/genesis/GenesisHandlerTest.java @@ -13,7 +13,6 @@ package tech.pegasys.teku.statetransition.genesis; -import static java.util.stream.Collectors.toList; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.mockito.Mockito.mock; @@ -33,6 +32,7 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.config.SpecConfigAndParent; import tech.pegasys.teku.spec.config.SpecConfigLoader; import tech.pegasys.teku.spec.datastructures.interop.MockStartDepositGenerator; import tech.pegasys.teku.spec.datastructures.operations.DepositData; @@ -43,7 +43,7 @@ public class GenesisHandlerTest { private static final List VALIDATOR_KEYS = BLSKeyGenerator.generateKeyPairs(3); - private final SpecConfig specConfig = + private final SpecConfigAndParent specConfig = SpecConfigLoader.loadConfig( "minimal", b -> b.minGenesisActiveValidatorCount(VALIDATOR_KEYS.size())); private final Spec spec = TestSpecFactory.createPhase0(specConfig); @@ -63,7 +63,7 @@ public class GenesisHandlerTest { data.getAmount(), UInt64.valueOf(index)); }) - .collect(toList()); + .toList(); private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); @@ -79,7 +79,7 @@ public void setup() { @Test public void onDepositsFromBlock_shouldInitializeGenesis() { - final UInt64 genesisTime = specConfig.getMinGenesisTime(); + final UInt64 genesisTime = specConfig.specConfig().getMinGenesisTime(); final int batchSize = initialDepositData.size() / 2; final DepositsFromBlockEvent event1 = diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/synccommittee/SyncCommitteeContributionPoolTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/synccommittee/SyncCommitteeContributionPoolTest.java index 331f1717a0f..63f05d2c2bf 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/synccommittee/SyncCommitteeContributionPoolTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/synccommittee/SyncCommitteeContributionPoolTest.java @@ -32,6 +32,7 @@ import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.config.SpecConfigAltair; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.SyncAggregate; @@ -47,7 +48,8 @@ class SyncCommitteeContributionPoolTest { private final Spec spec = TestSpecFactory.createMinimalWithAltairForkEpoch(forkEpoch); private final UInt64 forkSlot = spec.computeStartSlotAtEpoch(forkEpoch); private final UInt64 altairSlot = forkSlot.plus(2); - private final SpecConfigAltair config = SpecConfigAltair.required(spec.getGenesisSpecConfig()); + private final SpecConfigAltair config = + SpecConfigAltair.required(spec.forMilestone(SpecMilestone.ALTAIR).getConfig()); private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); @SuppressWarnings("unchecked") diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/synccommittee/SyncCommitteeMessageValidatorTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/synccommittee/SyncCommitteeMessageValidatorTest.java index 4ef3e6126d1..876fe5edde7 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/synccommittee/SyncCommitteeMessageValidatorTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/synccommittee/SyncCommitteeMessageValidatorTest.java @@ -93,12 +93,12 @@ void shouldAcceptWhenValid() { chainBuilder.getLatestEpoch(), message.getValidatorIndex()); final int validSubnetId = assignments.getAssignedSubcommittees().iterator().nextInt(); - final ValidatableSyncCommitteeMessage validateableMessage = + final ValidatableSyncCommitteeMessage validatableMessage = ValidatableSyncCommitteeMessage.fromNetwork(message, validSubnetId); - assertThat(validator.validate(validateableMessage)).isCompletedWithValue(ACCEPT); + assertThat(validator.validate(validatableMessage)).isCompletedWithValue(ACCEPT); // Should store the computed subcommittee assignments for the validator. - assertThat(validateableMessage.getSubcommitteeAssignments()).contains(assignments); + assertThat(validatableMessage.getSubcommitteeAssignments()).contains(assignments); } @Test @@ -128,16 +128,16 @@ void shouldAcceptWhenValidInSlotLastSlotOfSyncCommitteePeriod() { syncCommitteeUtil.getEpochForDutiesAtSlot(lastSlotOfPeriod), message.getValidatorIndex()); final int validSubnetId = assignments.getAssignedSubcommittees().iterator().nextInt(); - final ValidatableSyncCommitteeMessage validateableMessage = + final ValidatableSyncCommitteeMessage validatableMessage = ValidatableSyncCommitteeMessage.fromNetwork(message, validSubnetId); timeProvider.advanceTimeByMillis( spec.getSlotStartTime(lastSlotOfPeriod, recentChainData.getGenesisTime()) .times(1000) .longValue()); - assertThat(validator.validate(validateableMessage)).isCompletedWithValue(ACCEPT); + assertThat(validator.validate(validatableMessage)).isCompletedWithValue(ACCEPT); // Should store the computed subcommittee assignments for the validator. - assertThat(validateableMessage.getSubcommitteeAssignments()).contains(assignments); + assertThat(validatableMessage.getSubcommitteeAssignments()).contains(assignments); } @Test @@ -354,9 +354,9 @@ void shouldUseCorrectForkForSignatureVerificationWhenHeadStateIsBeforeNewMilesto chainBuilder.getLatestEpoch(), message.getValidatorIndex()); final int validSubnetId = assignments.getAssignedSubcommittees().iterator().nextInt(); - final ValidatableSyncCommitteeMessage validateableMessage = + final ValidatableSyncCommitteeMessage validatableMessage = ValidatableSyncCommitteeMessage.fromNetwork(message, validSubnetId); - assertThat(validator.validate(validateableMessage)).isCompletedWithValue(ACCEPT); + assertThat(validator.validate(validatableMessage)).isCompletedWithValue(ACCEPT); } @Test @@ -380,40 +380,41 @@ void shouldUseCorrectForkForSignatureVerificationWhenSlotIsJustBeforeNewMileston chainBuilder.getLatestEpoch(), message.getValidatorIndex()); final int validSubnetId = assignments.getAssignedSubcommittees().iterator().nextInt(); - final ValidatableSyncCommitteeMessage validateableMessage = + final ValidatableSyncCommitteeMessage validatableMessage = ValidatableSyncCommitteeMessage.fromNetwork(message, validSubnetId); - assertThat(validator.validate(validateableMessage)).isCompletedWithValue(ACCEPT); + assertThat(validator.validate(validatableMessage)).isCompletedWithValue(ACCEPT); } private ValidatableSyncCommitteeMessage fromValidatorSpy( - SyncCommitteeMessage message, final IntSet subcommitteeIds) { - final ValidatableSyncCommitteeMessage validateableMessage = + final SyncCommitteeMessage message, final IntSet subcommitteeIds) { + final ValidatableSyncCommitteeMessage validatableMessage = ValidatableSyncCommitteeMessage.fromValidator(message); - return createSpy(validateableMessage, subcommitteeIds); + return createSpy(validatableMessage, subcommitteeIds); } private ValidatableSyncCommitteeMessage fromNetworkSpy( - SyncCommitteeMessage message, final int receivedSubnetId, final IntSet subcommitteeIds) { - final ValidatableSyncCommitteeMessage validateableMessage = + final SyncCommitteeMessage message, + final int receivedSubnetId, + final IntSet subcommitteeIds) { + final ValidatableSyncCommitteeMessage validatableMessage = ValidatableSyncCommitteeMessage.fromNetwork(message, receivedSubnetId); - return createSpy(validateableMessage, subcommitteeIds); + return createSpy(validatableMessage, subcommitteeIds); } private ValidatableSyncCommitteeMessage createSpy( - ValidatableSyncCommitteeMessage validateableMessage, final IntSet subcommitteeIds) { + final ValidatableSyncCommitteeMessage validatableMessage, final IntSet subcommitteeIds) { // Create spies - final ValidatableSyncCommitteeMessage validateableMessageSpy = spy(validateableMessage); - validateableMessage.calculateAssignments( - spec, chainBuilder.getLatestBlockAndState().getState()); + final ValidatableSyncCommitteeMessage validatableMessageSpy = spy(validatableMessage); + validatableMessage.calculateAssignments(spec, chainBuilder.getLatestBlockAndState().getState()); SyncSubcommitteeAssignments assignments = - validateableMessage.getSubcommitteeAssignments().orElseThrow(); + validatableMessage.getSubcommitteeAssignments().orElseThrow(); SyncSubcommitteeAssignments assignmentsSpy = spy(assignments); // Overwrite some functionality - doReturn(assignmentsSpy).when(validateableMessageSpy).calculateAssignments(any(), any()); - doReturn(Optional.of(assignmentsSpy)).when(validateableMessageSpy).getSubcommitteeAssignments(); + doReturn(assignmentsSpy).when(validatableMessageSpy).calculateAssignments(any(), any()); + doReturn(Optional.of(assignmentsSpy)).when(validatableMessageSpy).getSubcommitteeAssignments(); doReturn(subcommitteeIds).when(assignmentsSpy).getAssignedSubcommittees(); - return validateableMessageSpy; + return validatableMessageSpy; } } diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/util/BlockBlobSidecarsTrackersPoolImplTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/util/BlockBlobSidecarsTrackersPoolImplTest.java index eb3a65999c6..55faf66ecb9 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/util/BlockBlobSidecarsTrackersPoolImplTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/util/BlockBlobSidecarsTrackersPoolImplTest.java @@ -16,6 +16,8 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.async.SafeFutureAssert.assertThatSafeFuture; @@ -33,6 +35,7 @@ import java.util.Set; import java.util.function.Function; import java.util.stream.Collectors; +import java.util.stream.IntStream; import java.util.stream.Stream; import org.apache.tuweni.bytes.Bytes32; import org.hyperledger.besu.metrics.ObservableMetricsSystem; @@ -41,6 +44,7 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import tech.pegasys.infrastructure.logging.LogCaptor; +import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.async.StubAsyncRunner; import tech.pegasys.teku.infrastructure.metrics.TekuMetricCategory; import tech.pegasys.teku.infrastructure.time.StubTimeProvider; @@ -50,12 +54,17 @@ import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.blocks.SlotAndBlockRoot; +import tech.pegasys.teku.spec.datastructures.execution.BlobAndProof; import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.BlobIdentifier; import tech.pegasys.teku.spec.datastructures.state.Checkpoint; +import tech.pegasys.teku.spec.executionlayer.ExecutionLayerChannel; +import tech.pegasys.teku.spec.logic.versions.deneb.helpers.MiscHelpersDeneb; +import tech.pegasys.teku.spec.logic.versions.deneb.types.VersionedHash; import tech.pegasys.teku.spec.util.DataStructureUtil; import tech.pegasys.teku.statetransition.blobs.BlobSidecarManager.RemoteOrigin; import tech.pegasys.teku.statetransition.blobs.BlockBlobSidecarsTracker; import tech.pegasys.teku.statetransition.block.BlockImportChannel; +import tech.pegasys.teku.statetransition.validation.BlobSidecarGossipValidator; import tech.pegasys.teku.storage.client.RecentChainData; public class BlockBlobSidecarsTrackersPoolImplTest { @@ -68,6 +77,14 @@ public class BlockBlobSidecarsTrackersPoolImplTest { private final StubTimeProvider timeProvider = StubTimeProvider.withTimeInSeconds(0); private final StubAsyncRunner asyncRunner = new StubAsyncRunner(); private final RecentChainData recentChainData = mock(RecentChainData.class); + private final ExecutionLayerChannel executionLayer = mock(ExecutionLayerChannel.class); + + @SuppressWarnings("unchecked") + private final Function> blobSidecarPublisher = mock(Function.class); + + private final BlobSidecarGossipValidator blobSidecarGossipValidator = + mock(BlobSidecarGossipValidator.class); + private final BlockImportChannel blockImportChannel = mock(BlockImportChannel.class); private final int maxItems = 15; private final BlockBlobSidecarsTrackersPoolImpl blockBlobSidecarsTrackersPool = @@ -78,6 +95,9 @@ public class BlockBlobSidecarsTrackersPoolImplTest { timeProvider, asyncRunner, recentChainData, + executionLayer, + () -> blobSidecarGossipValidator, + blobSidecarPublisher, historicalTolerance, futureTolerance, maxItems, @@ -103,6 +123,7 @@ public void setup() { blockBlobSidecarsTrackersPool.subscribeRequiredBlobSidecarDropped( requiredBlobSidecarDroppedEvents::add); blockBlobSidecarsTrackersPool.subscribeNewBlobSidecar(newBlobSidecarEvents::add); + when(blobSidecarPublisher.apply(any())).thenReturn(SafeFuture.COMPLETE); setSlot(currentSlot); } @@ -186,6 +207,76 @@ public void onNewBlobSidecar_shouldIgnoreDuplicates() { assertBlobSidecarsTrackersCount(1); } + @Test + public void onNewBlobSidecar_shouldMarkForEquivocationAndPublishWhenOriginIsLocalEL() { + final BlobSidecar blobSidecar1 = + dataStructureUtil + .createRandomBlobSidecarBuilder() + .signedBeaconBlockHeader(dataStructureUtil.randomSignedBeaconBlockHeader(currentSlot)) + .build(); + final BlobSidecar blobSidecar2 = + dataStructureUtil + .createRandomBlobSidecarBuilder() + .signedBeaconBlockHeader(dataStructureUtil.randomSignedBeaconBlockHeader(currentSlot)) + .build(); + final BlobSidecar blobSidecar3 = + dataStructureUtil + .createRandomBlobSidecarBuilder() + .signedBeaconBlockHeader(dataStructureUtil.randomSignedBeaconBlockHeader(currentSlot)) + .build(); + + when(blobSidecarGossipValidator.markForEquivocation(blobSidecar1)).thenReturn(true); + + blockBlobSidecarsTrackersPool.onNewBlobSidecar(blobSidecar1, RemoteOrigin.LOCAL_EL); + blockBlobSidecarsTrackersPool.onNewBlobSidecar(blobSidecar2, RemoteOrigin.GOSSIP); + blockBlobSidecarsTrackersPool.onNewBlobSidecar(blobSidecar3, RemoteOrigin.RPC); + + assertBlobSidecarsCount(3); + assertBlobSidecarsTrackersCount(3); + + verify(blobSidecarGossipValidator).markForEquivocation(blobSidecar1); + verify(blobSidecarPublisher, times(1)).apply(blobSidecar1); + } + + @Test + public void onNewBlobSidecar_shouldPublishWhenOriginIsLocalELAndEquivocating() { + final BlobSidecar blobSidecar1 = + dataStructureUtil + .createRandomBlobSidecarBuilder() + .signedBeaconBlockHeader(dataStructureUtil.randomSignedBeaconBlockHeader(currentSlot)) + .build(); + + when(blobSidecarGossipValidator.markForEquivocation(blobSidecar1)).thenReturn(false); + + blockBlobSidecarsTrackersPool.onNewBlobSidecar(blobSidecar1, RemoteOrigin.LOCAL_EL); + + assertBlobSidecarsCount(1); + assertBlobSidecarsTrackersCount(1); + + verify(blobSidecarGossipValidator).markForEquivocation(blobSidecar1); + verify(blobSidecarPublisher, times(1)).apply(blobSidecar1); + } + + @Test + public void onNewBlobSidecar_shouldNotPublishWhenOriginIsLocalELIsNotCurrentSlot() { + final BlobSidecar blobSidecar1 = + dataStructureUtil + .createRandomBlobSidecarBuilder() + .signedBeaconBlockHeader(dataStructureUtil.randomSignedBeaconBlockHeader(currentSlot)) + .build(); + + when(blobSidecarGossipValidator.markForEquivocation(blobSidecar1)).thenReturn(false); + blockBlobSidecarsTrackersPool.onSlot(currentSlot.plus(1)); + + blockBlobSidecarsTrackersPool.onNewBlobSidecar(blobSidecar1, RemoteOrigin.LOCAL_EL); + + assertBlobSidecarsCount(1); + assertBlobSidecarsTrackersCount(1); + + verify(blobSidecarGossipValidator, never()).markForEquivocation(blobSidecar1); + verify(blobSidecarPublisher, never()).apply(blobSidecar1); + } + @Test public void onNewBlock_shouldIgnorePreDenebBlocks() { final Spec spec = TestSpecFactory.createMainnetCapella(); @@ -206,7 +297,7 @@ public void onNewBlock_shouldIgnorePreDenebBlocks() { @Test public void onNewBlock_shouldIgnoreEip7594Blocks() { - final Spec spec = TestSpecFactory.createMinimalEip7594(); + final Spec spec = TestSpecFactory.createMinimalElectraEip7594(); final BlockBlobSidecarsTrackersPoolImpl blockBlobSidecarsTrackersPoolEip7594 = new PoolFactory(metricsSystem) .createPoolForBlockBlobSidecarsTrackers( @@ -215,6 +306,9 @@ public void onNewBlock_shouldIgnoreEip7594Blocks() { timeProvider, asyncRunner, recentChainData, + executionLayer, + () -> blobSidecarGossipValidator, + blobSidecarPublisher, historicalTolerance, futureTolerance, maxItems, @@ -402,7 +496,7 @@ public void onCompletedBlockAndBlobSidecars_shouldCreateTrackerIgnoringHistorica assertThat(blockBlobSidecarsTracker.getBlobSidecars().values()) .containsExactlyInAnyOrderElementsOf(blobSidecars); assertThat(blockBlobSidecarsTracker.getBlock()).isPresent(); - assertThat(blockBlobSidecarsTracker.isFetchTriggered()).isFalse(); + assertThat(blockBlobSidecarsTracker.isRpcFetchTriggered()).isFalse(); assertThatSafeFuture(blockBlobSidecarsTracker.getCompletionFuture()).isCompleted(); assertBlobSidecarsCount(blobSidecars.size()); @@ -432,7 +526,7 @@ public void onCompletedBlockAndBlobSidecars_shouldNotTriggerFetch() { assertThat(blockBlobSidecarsTracker.getBlobSidecars().values()) .containsExactlyInAnyOrderElementsOf(blobSidecars); assertThat(blockBlobSidecarsTracker.getBlock()).isPresent(); - assertThat(blockBlobSidecarsTracker.isFetchTriggered()).isFalse(); + assertThat(blockBlobSidecarsTracker.isRpcFetchTriggered()).isFalse(); assertThatSafeFuture(blockBlobSidecarsTracker.getCompletionFuture()).isNotCompleted(); assertBlobSidecarsCount(0); @@ -450,7 +544,7 @@ public void onCompletedBlockAndBlobSidecars_shouldNotTriggerFetch() { blockBlobSidecarsTrackersPool.getOrCreateBlockBlobSidecarsTracker(block); assertThat(blockBlobSidecarsTracker.getBlock()).isPresent(); - assertThat(blockBlobSidecarsTracker.isFetchTriggered()).isFalse(); + assertThat(blockBlobSidecarsTracker.isRpcFetchTriggered()).isFalse(); assertThatSafeFuture(blockBlobSidecarsTracker.getCompletionFuture()).isNotCompleted(); assertBlobSidecarsCount(0); @@ -559,7 +653,109 @@ public void prune_finalizedBlocks() { } @Test - void shouldFetchMissingBlobSidecars() { + void shouldFetchMissingBlobSidecarsFromLocalELFirst() { + final SignedBeaconBlock block = + dataStructureUtil.randomSignedBeaconBlockWithCommitments(currentSlot, 4); + final MiscHelpersDeneb miscHelpersDeneb = + spec.getGenesisSpec().miscHelpers().toVersionDeneb().orElseThrow(); + + // lets prepare 3 missing blobs (blob index 0 present) + + final List missingBlobSidecars = + UInt64.range(UInt64.ONE, UInt64.valueOf(4)) + .map( + index -> + dataStructureUtil + .createRandomBlobSidecarBuilder() + .signedBeaconBlockHeader(block.asHeader()) + .index(index) + .kzgCommitment( + block + .getMessage() + .getBody() + .getOptionalBlobKzgCommitments() + .orElseThrow() + .get(index.intValue()) + .getKZGCommitment() + .getBytesCompressed()) + .kzgCommitmentInclusionProof( + miscHelpersDeneb.computeBlobKzgCommitmentInclusionProof( + index, block.getMessage().getBody())) + .build()) + .toList(); + + final Set missingBlobIdentifiers = + UInt64.range(UInt64.ONE, UInt64.valueOf(4)) + .map(index -> new BlobIdentifier(block.getRoot(), index)) + .collect(Collectors.toSet()); + + final List versionedHashes = + IntStream.range(1, 4) + .mapToObj( + index -> + miscHelpersDeneb.kzgCommitmentToVersionedHash( + missingBlobSidecars.get(index - 1).getKZGCommitment())) + .toList(); + + final BlockBlobSidecarsTracker tracker = mock(BlockBlobSidecarsTracker.class); + + mockedTrackersFactory = + Optional.of( + (slotAndRoot) -> { + when(tracker.add(any())).thenReturn(true); + when(tracker.getMissingBlobSidecars()) + .thenAnswer(__ -> missingBlobIdentifiers.stream()); + when(tracker.getBlock()).thenReturn(Optional.of(block)); + return tracker; + }); + + final SafeFuture>> engineGetBlobsResponse = new SafeFuture<>(); + + when(executionLayer.engineGetBlobs(versionedHashes, currentSlot)) + .thenReturn(engineGetBlobsResponse); + + blockBlobSidecarsTrackersPool.onNewBlock(block, Optional.empty()); + + assertThat(asyncRunner.hasDelayedActions()).isTrue(); + + asyncRunner.executeQueuedActions(); + + // no RPC requests, local el query is in flight + assertThat(requiredBlockRootEvents).isEmpty(); + assertThat(requiredBlockRootDroppedEvents).isEmpty(); + assertThat(requiredBlobSidecarEvents).isEmpty(); + assertThat(requiredBlobSidecarDroppedEvents).isEmpty(); + + // local el fetch triggered + verify(tracker).setLocalElFetchTriggered(); + + // prepare partial response of 3 blobAndProofs + final List> blobAndProofsFromEL = + IntStream.range(0, 3) + .>mapToObj( + index -> { + if (index == 1) { + // missing index 1 from EL (blob index 2) + return Optional.empty(); + } + return Optional.of( + new BlobAndProof( + missingBlobSidecars.get(index).getBlob(), + missingBlobSidecars.get(index).getKZGProof())); + }) + .toList(); + + engineGetBlobsResponse.complete(blobAndProofsFromEL); + + verify(tracker).add(missingBlobSidecars.getFirst()); // 0 + verify(tracker).add(missingBlobSidecars.getLast()); // 2 + verify(tracker, times(2)).add(any()); + + assertStats("blob_sidecar", "local_el_fetch", 3); + } + + @Test + void shouldFetchMissingBlobSidecarsViaRPCAfterLocalEL() { final SignedBeaconBlock block = dataStructureUtil.randomSignedBeaconBlock(currentSlot); final Set missingBlobs = @@ -571,17 +767,59 @@ void shouldFetchMissingBlobSidecars() { Optional.of( (slotAndRoot) -> { BlockBlobSidecarsTracker tracker = mock(BlockBlobSidecarsTracker.class); - when(tracker.getMissingBlobSidecars()).thenReturn(missingBlobs.stream()); + when(tracker.getMissingBlobSidecars()).thenAnswer(__ -> missingBlobs.stream()); + when(tracker.getBlock()).thenReturn(Optional.of(block)); + return tracker; + }); + + // prepare empty result from EL + when(executionLayer.engineGetBlobs(any(), any())) + .thenReturn(SafeFuture.completedFuture(List.of(Optional.empty(), Optional.empty()))); + + blockBlobSidecarsTrackersPool.onNewBlock(block, Optional.empty()); + + assertThat(asyncRunner.hasDelayedActions()).isTrue(); + + asyncRunner.executeQueuedActions(); + + verify(executionLayer).engineGetBlobs(any(), any()); + + assertThat(requiredBlockRootEvents).isEmpty(); + assertThat(requiredBlockRootDroppedEvents).isEmpty(); + assertThat(requiredBlobSidecarEvents).containsExactlyElementsOf(missingBlobs); + assertThat(requiredBlobSidecarDroppedEvents).isEmpty(); + } + + @Test + void shouldFetchMissingBlobSidecarsViaRPCWhenELLookupFails() { + final SignedBeaconBlock block = dataStructureUtil.randomSignedBeaconBlock(currentSlot); + + final Set missingBlobs = + Set.of( + new BlobIdentifier(block.getRoot(), UInt64.ONE), + new BlobIdentifier(block.getRoot(), UInt64.ZERO)); + + mockedTrackersFactory = + Optional.of( + (slotAndRoot) -> { + BlockBlobSidecarsTracker tracker = mock(BlockBlobSidecarsTracker.class); + when(tracker.getMissingBlobSidecars()).thenAnswer(__ -> missingBlobs.stream()); when(tracker.getBlock()).thenReturn(Optional.of(block)); return tracker; }); + // prepare failure from EL + when(executionLayer.engineGetBlobs(any(), any())) + .thenReturn(SafeFuture.failedFuture(new RuntimeException("oops"))); + blockBlobSidecarsTrackersPool.onNewBlock(block, Optional.empty()); assertThat(asyncRunner.hasDelayedActions()).isTrue(); asyncRunner.executeQueuedActions(); + verify(executionLayer).engineGetBlobs(any(), any()); + assertThat(requiredBlockRootEvents).isEmpty(); assertThat(requiredBlockRootDroppedEvents).isEmpty(); assertThat(requiredBlobSidecarEvents).containsExactlyElementsOf(missingBlobs); @@ -616,7 +854,8 @@ void shouldFetchMissingBlockAndBlobSidecars() { asyncRunner.executeQueuedActions(); - verify(mockedTracker).setFetchTriggered(); + verify(mockedTracker).setRpcFetchTriggered(); + verify(mockedTracker, never()).setLocalElFetchTriggered(); assertThat(requiredBlockRootEvents).containsExactly(block.getRoot()); assertThat(requiredBlobSidecarEvents).containsExactlyElementsOf(missingBlobs); @@ -640,7 +879,7 @@ void shouldDropBlobSidecarsThatHasBeenFetchedButNotPresentInBlock() { .index(UInt64.valueOf(2)) .build(); - final Set blobsNotUserInBlock = + final Set blobsNotPresentInBlock = Set.of( new BlobIdentifier(slotAndBlockRoot.getBlockRoot(), UInt64.valueOf(2)), new BlobIdentifier(slotAndBlockRoot.getBlockRoot(), UInt64.valueOf(3))); @@ -652,9 +891,9 @@ void shouldDropBlobSidecarsThatHasBeenFetchedButNotPresentInBlock() { when(tracker.getBlock()).thenReturn(Optional.empty()); when(tracker.getSlotAndBlockRoot()).thenReturn(slotAndBlockRoot); when(tracker.setBlock(block)).thenReturn(true); - when(tracker.isFetchTriggered()).thenReturn(true); + when(tracker.isRpcFetchTriggered()).thenReturn(true); when(tracker.getUnusedBlobSidecarsForBlock()) - .thenReturn(blobsNotUserInBlock.stream()); + .thenReturn(blobsNotPresentInBlock.stream()); return tracker; }); @@ -662,7 +901,7 @@ void shouldDropBlobSidecarsThatHasBeenFetchedButNotPresentInBlock() { blockBlobSidecarsTrackersPool.onNewBlock(block, Optional.empty()); - assertThat(requiredBlobSidecarDroppedEvents).containsExactlyElementsOf(blobsNotUserInBlock); + assertThat(requiredBlobSidecarDroppedEvents).containsExactlyElementsOf(blobsNotPresentInBlock); } @Test @@ -689,7 +928,7 @@ void shouldNotDropUnusedBlobSidecarsIfFetchingHasNotOccurred() { when(tracker.getBlock()).thenReturn(Optional.empty()); when(tracker.getSlotAndBlockRoot()).thenReturn(slotAndBlockRoot); when(tracker.setBlock(block)).thenReturn(true); - when(tracker.isFetchTriggered()).thenReturn(false); + when(tracker.isRpcFetchTriggered()).thenReturn(false); when(tracker.getUnusedBlobSidecarsForBlock()) .thenReturn(blobsNotUserInBlock.stream()); return tracker; @@ -742,7 +981,7 @@ void shouldDropPossiblyFetchedBlobSidecars() { when(tracker.getMissingBlobSidecars()).thenReturn(missingBlobs.stream()); when(tracker.getBlock()).thenReturn(Optional.of(block)); when(tracker.getSlotAndBlockRoot()).thenReturn(block.getSlotAndBlockRoot()); - when(tracker.isFetchTriggered()).thenReturn(true); + when(tracker.isRpcFetchTriggered()).thenReturn(true); return tracker; }); @@ -760,6 +999,55 @@ void shouldDropPossiblyFetchedBlobSidecars() { assertThat(requiredBlobSidecarEvents).isEmpty(); } + @Test + void shouldTryToFetchFromLocalELWhenBlockArrivesAfterRPCFetch() { + final SignedBeaconBlock block = dataStructureUtil.randomSignedBeaconBlock(currentSlot); + + final Set missingBlobs = + Set.of( + new BlobIdentifier(block.getRoot(), UInt64.ONE), + new BlobIdentifier(block.getRoot(), UInt64.ZERO)); + + final BlobSidecar blobSidecar = + dataStructureUtil + .createRandomBlobSidecarBuilder() + .signedBeaconBlockHeader(block.asHeader()) + .index(UInt64.valueOf(2)) + .build(); + + final BlockBlobSidecarsTracker tracker = mock(BlockBlobSidecarsTracker.class); + + mockedTrackersFactory = + Optional.of( + (slotAndRoot) -> { + when(tracker.getMissingBlobSidecars()).thenAnswer(__ -> missingBlobs.stream()); + when(tracker.getBlock()).thenReturn(Optional.empty()); + when(tracker.setBlock(any())).thenReturn(true); + when(tracker.getSlotAndBlockRoot()).thenReturn(block.getSlotAndBlockRoot()); + when(tracker.isRpcFetchTriggered()).thenReturn(true); + when(tracker.isLocalElFetchTriggered()).thenReturn(false); + return tracker; + }); + + blockBlobSidecarsTrackersPool.onNewBlobSidecar(blobSidecar, RemoteOrigin.RPC); + + assertThat(asyncRunner.hasDelayedActions()).isTrue(); + asyncRunner.executeQueuedActions(); + + verify(tracker, never()).setLocalElFetchTriggered(); + + when(tracker.getBlock()).thenReturn(Optional.of(block)); + + // prepare empty result from EL + when(executionLayer.engineGetBlobs(any(), any())) + .thenReturn(SafeFuture.completedFuture(List.of(Optional.empty(), Optional.empty()))); + + blockBlobSidecarsTrackersPool.onNewBlock(block, Optional.empty()); + + verify(tracker).setLocalElFetchTriggered(); + verify(executionLayer).engineGetBlobs(any(), any()); + } + @Test void shouldDropPossiblyFetchedBlock() { final SignedBeaconBlock signedBeaconBlock = @@ -777,7 +1065,7 @@ void shouldDropPossiblyFetchedBlock() { when(tracker.getBlock()).thenReturn(Optional.empty()); when(tracker.getSlotAndBlockRoot()) .thenReturn(signedBeaconBlock.getSlotAndBlockRoot()); - when(tracker.isFetchTriggered()).thenReturn(true); + when(tracker.isRpcFetchTriggered()).thenReturn(true); return tracker; }); @@ -812,7 +1100,7 @@ void shouldNotDropPossiblyFetchedBlockIfFetchHasNotOccurred() { when(tracker.getBlock()).thenReturn(Optional.empty()); when(tracker.getSlotAndBlockRoot()) .thenReturn(signedBeaconBlock.getSlotAndBlockRoot()); - when(tracker.isFetchTriggered()).thenReturn(false); + when(tracker.isRpcFetchTriggered()).thenReturn(false); return tracker; }); @@ -1022,6 +1310,23 @@ void stats_onNewBlobSidecar() { assertStats("blob_sidecar", "rpc", 1); assertStats("blob_sidecar", "gossip_duplicate", 1); assertStats("blob_sidecar", "rpc_duplicate", 1); + + final BlobSidecar blobSidecar3 = + dataStructureUtil + .createRandomBlobSidecarBuilder() + .signedBeaconBlockHeader( + dataStructureUtil.randomSignedBeaconBlockHeader(currentSlot.increment())) + .build(); + + // new from LOCAL_EL + blockBlobSidecarsTrackersPool.onNewBlobSidecar(blobSidecar3, RemoteOrigin.LOCAL_EL); + assertStats("blob_sidecar", "local_el", 1); + + // duplicate from LOCAL_EL + + blockBlobSidecarsTrackersPool.onNewBlobSidecar(blobSidecar3, RemoteOrigin.LOCAL_EL); + assertStats("blob_sidecar", "local_el", 1); + assertStats("blob_sidecar", "local_el_duplicate", 1); } @Test @@ -1084,7 +1389,7 @@ void stats_onNewBlock() { assertStats("block", "gossip", 2); } - private Checkpoint finalizedCheckpoint(SignedBeaconBlock block) { + private Checkpoint finalizedCheckpoint(final SignedBeaconBlock block) { final UInt64 epoch = spec.computeEpochAtSlot(block.getSlot()).plus(UInt64.ONE); final Bytes32 root = block.getMessage().hashTreeRoot(); @@ -1096,7 +1401,8 @@ private static BlobIdentifier blobIdentifierFromBlobSidecar(final BlobSidecar bl } private void assertStats(final String type, final String subType, final double count) { - assertThat(getMetricsValues("block_blobs_trackers_pool_stats").get(List.of(type, subType))) + assertThat( + getMetricsValues("block_blobs_trackers_pool_stats_total").get(List.of(type, subType))) .isEqualTo(count); } @@ -1128,6 +1434,7 @@ private BlockBlobSidecarsTracker trackerFactory(final SlotAndBlockRoot slotAndBl return mockedTrackersFactory.get().apply(slotAndBlockRoot); } return new BlockBlobSidecarsTracker( - slotAndBlockRoot, UInt64.valueOf(spec.getMaxBlobsPerBlock().orElseThrow())); + slotAndBlockRoot, + UInt64.valueOf(spec.getMaxBlobsPerBlockForHighestMilestone().orElseThrow())); } } diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/util/DebugDataFileDumperTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/util/DebugDataFileDumperTest.java new file mode 100644 index 00000000000..5fe99a7d248 --- /dev/null +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/util/DebugDataFileDumperTest.java @@ -0,0 +1,191 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.statetransition.util; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.fail; + +import java.io.File; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.sql.Date; +import java.text.DateFormat; +import java.text.SimpleDateFormat; +import java.util.List; +import java.util.Optional; +import org.apache.tuweni.bytes.Bytes; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.condition.DisabledOnOs; +import org.junit.jupiter.api.condition.OS; +import org.junit.jupiter.api.io.TempDir; +import tech.pegasys.teku.infrastructure.time.StubTimeProvider; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; +import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +class DebugDataFileDumperTest { + final DataStructureUtil dataStructureUtil = + new DataStructureUtil(TestSpecFactory.createMinimalDeneb()); + private final StubTimeProvider timeProvider = StubTimeProvider.withTimeInSeconds(10_000); + + @Test + void saveGossipMessageDecodingError_shouldSaveToFile(@TempDir final Path tempDir) { + final DebugDataFileDumper dumper = new DebugDataFileDumper(tempDir); + final Bytes messageBytes = dataStructureUtil.stateBuilderPhase0().build().sszSerialize(); + final Optional arrivalTimestamp = Optional.of(timeProvider.getTimeInMillis()); + dumper.saveGossipMessageDecodingError( + "/eth/test/topic", arrivalTimestamp, () -> messageBytes, new Throwable()); + + final String fileName = + String.format("%s.ssz", formatTimestamp(timeProvider.getTimeInMillis().longValue())); + final Path expectedFile = + tempDir + .resolve("gossip_messages") + .resolve("decoding_error") + .resolve("_eth_test_topic") + .resolve(fileName); + checkBytesSavedToFile(expectedFile, messageBytes); + } + + @Test + void saveGossipRejectedMessage_shouldSaveToFile(@TempDir final Path tempDir) { + final DebugDataFileDumper dumper = new DebugDataFileDumper(tempDir); + final Bytes messageBytes = dataStructureUtil.stateBuilderPhase0().build().sszSerialize(); + final Optional arrivalTimestamp = Optional.of(timeProvider.getTimeInMillis()); + dumper.saveGossipRejectedMessage( + "/eth/test/topic", arrivalTimestamp, () -> messageBytes, Optional.of("reason")); + + final String fileName = + String.format("%s.ssz", formatTimestamp(timeProvider.getTimeInMillis().longValue())); + final Path expectedFile = + tempDir + .resolve("gossip_messages") + .resolve("rejected") + .resolve("_eth_test_topic") + .resolve(fileName); + checkBytesSavedToFile(expectedFile, messageBytes); + } + + @Test + void saveInvalidBlockToFile_shouldSaveToFile(@TempDir final Path tempDir) { + final DebugDataFileDumper dumper = new DebugDataFileDumper(tempDir); + final SignedBeaconBlock block = dataStructureUtil.randomSignedBeaconBlock(); + dumper.saveInvalidBlock(block, "reason", Optional.of(new Throwable())); + + final String fileName = + String.format("%s_%s.ssz", block.getSlot(), block.getRoot().toUnprefixedHexString()); + final Path expectedFile = tempDir.resolve("invalid_blocks").resolve(fileName); + checkBytesSavedToFile(expectedFile, block.sszSerialize()); + } + + @Test + void saveInvalidBlobSidecars_shouldSaveToFiles(@TempDir final Path tempDir) { + final DebugDataFileDumper dumper = new DebugDataFileDumper(tempDir); + final SignedBeaconBlock block = dataStructureUtil.randomSignedBeaconBlock(); + final List blobSidecars = dataStructureUtil.randomBlobSidecarsForBlock(block); + dumper.saveInvalidSidecars(blobSidecars, block); + + final String kzgCommitmentsFileName = + String.format( + "%s_%s_kzg_commitments.ssz", block.getSlot(), block.getRoot().toUnprefixedHexString()); + final Path expectedKzgCommitmentsFileName = + tempDir.resolve("invalid_blob_sidecars").resolve(kzgCommitmentsFileName); + checkBytesSavedToFile( + expectedKzgCommitmentsFileName, + block.getMessage().getBody().getOptionalBlobKzgCommitments().orElseThrow().sszSerialize()); + + blobSidecars.forEach( + blobSidecar -> { + final String fileName = + String.format( + "%s_%s_%s.ssz", + blobSidecar.getSlot(), + blobSidecar.getBlockRoot().toUnprefixedHexString(), + blobSidecar.getIndex()); + final Path expectedFile = tempDir.resolve("invalid_blob_sidecars").resolve(fileName); + checkBytesSavedToFile(expectedFile, blobSidecar.sszSerialize()); + }); + } + + @Test + void saveBytesToFile_shouldNotThrowExceptionWhenNoDirectory(@TempDir final Path tempDir) { + final DebugDataFileDumper dumper = new DebugDataFileDumper(tempDir); + assertDoesNotThrow( + () -> { + final boolean success = + dumper.saveBytesToFile("object", Path.of("invalid").resolve("file.ssz"), Bytes.EMPTY); + assertThat(success).isTrue(); // creates directory + }); + } + + @Test + @DisabledOnOs(OS.WINDOWS) // Can't set permissions on Windows + void saveBytesToFile_shouldNotEscalateWhenIOException(@TempDir final Path tempDir) { + final DebugDataFileDumper dumper = new DebugDataFileDumper(tempDir); + final File invalidPath = tempDir.resolve("invalid").toFile(); + assertThat(invalidPath.mkdirs()).isTrue(); + assertThat(invalidPath.setWritable(false)).isTrue(); + assertDoesNotThrow( + () -> { + final boolean success = + dumper.saveBytesToFile("object", Path.of("invalid").resolve("file.ssz"), Bytes.EMPTY); + assertThat(success).isFalse(); + }); + } + + @Test + @DisabledOnOs(OS.WINDOWS) // Can't set permissions on Windows + void constructionOfDirectories_shouldDisableWhenFailedToCreate(@TempDir final Path tempDir) { + assertThat(tempDir.toFile().setWritable(false)).isTrue(); + final DebugDataFileDumper dumper = new DebugDataFileDumper(tempDir); + assertThat(dumper.isEnabled()).isFalse(); + } + + @Test + void formatOptionalTimestamp_shouldFormatTimestamp(@TempDir final Path tempDir) { + final DebugDataFileDumper dumper = new DebugDataFileDumper(tempDir); + final String formattedTimestamp = + dumper.formatOptionalTimestamp(Optional.of(timeProvider.getTimeInMillis()), timeProvider); + assertThat(formattedTimestamp) + .isEqualTo(formatTimestamp(timeProvider.getTimeInMillis().longValue())); + } + + @Test + void formatOptionalTimestamp_shouldGenerateTimestamp(@TempDir final Path tempDir) { + final DebugDataFileDumper dumper = new DebugDataFileDumper(tempDir); + final String formattedTimestamp = + dumper.formatOptionalTimestamp(Optional.empty(), timeProvider); + assertThat(formattedTimestamp) + .isEqualTo(formatTimestamp(timeProvider.getTimeInMillis().longValue())); + } + + private void checkBytesSavedToFile(final Path path, final Bytes expectedBytes) { + try { + final Bytes bytes = Bytes.wrap(Files.readAllBytes(path)); + assertThat(bytes).isEqualTo(expectedBytes); + } catch (IOException e) { + fail(); + } + } + + private String formatTimestamp(final long timeInMillis) { + final DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH_mm_ss.SS"); + final Date date = new Date(timeInMillis); + return df.format(date); + } +} diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/util/PendingPoolTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/util/PendingPoolTest.java index ce537947c8c..c6d054b5c57 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/util/PendingPoolTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/util/PendingPoolTest.java @@ -264,7 +264,7 @@ public void add_shouldDropOldestItemsWhenEnforcingLimits() { assertThat(pendingPool.size()).isEqualTo(maxItems); } - private Checkpoint finalizedCheckpoint(SignedBeaconBlock block) { + private Checkpoint finalizedCheckpoint(final SignedBeaconBlock block) { final UInt64 epoch = spec.computeEpochAtSlot(block.getSlot()).plus(UInt64.ONE); final Bytes32 root = block.getMessage().hashTreeRoot(); diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/AbstractAttestationValidatorTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/AbstractAttestationValidatorTest.java index a45152bf764..fe3e6fb3660 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/AbstractAttestationValidatorTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/AbstractAttestationValidatorTest.java @@ -30,7 +30,7 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.generator.AttestationGenerator; import tech.pegasys.teku.spec.generator.ChainBuilder; @@ -79,7 +79,7 @@ abstract class AbstractAttestationValidatorTest { private static final List VALIDATOR_KEYS = BLSKeyGenerator.generateKeyPairs(64); protected final Spec spec = createSpec(); - protected final AttestationSchema attestationSchema = + protected final AttestationSchema attestationSchema = spec.getGenesisSchemaDefinitions().getAttestationSchema(); protected final StorageSystem storageSystem = InMemoryStorageSystemBuilder.buildDefault(StateStorageMode.ARCHIVE); diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/AggregateAttestationValidatorTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/AggregateAttestationValidatorTest.java index 49d7fb166c9..e14769f17cd 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/AggregateAttestationValidatorTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/AggregateAttestationValidatorTest.java @@ -22,26 +22,31 @@ import static tech.pegasys.teku.infrastructure.async.SafeFutureAssert.safeJoin; import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ONE; import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ZERO; +import static tech.pegasys.teku.spec.SpecMilestone.ELECTRA; +import static tech.pegasys.teku.spec.SpecMilestone.PHASE0; import static tech.pegasys.teku.statetransition.validation.InternalValidationResult.reject; import java.util.List; import java.util.Optional; import java.util.OptionalInt; +import java.util.function.Supplier; import java.util.stream.IntStream; import org.apache.commons.lang3.ArrayUtils; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestTemplate; import tech.pegasys.teku.bls.BLSKeyPair; import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.bls.BLSSignatureVerifier; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecVersion; -import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider.SpecContext; import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlockAndState; import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockAndState; @@ -51,6 +56,7 @@ import tech.pegasys.teku.spec.datastructures.operations.AggregateAndProof.AggregateAndProofSchema; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof; import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof.SignedAggregateAndProofSchema; import tech.pegasys.teku.spec.datastructures.state.CommitteeAssignment; @@ -110,31 +116,22 @@ * *

The signature of aggregate is valid. */ +@TestSpecContext(milestone = {PHASE0, ELECTRA}) class AggregateAttestationValidatorTest { private static final List VALIDATOR_KEYS = new MockStartValidatorKeyPairFactory().generateKeyPairs(0, 1024); - private final Spec spec = TestSpecFactory.createMinimalPhase0(); - private final SpecVersion genesisSpec = spec.getGenesisSpec(); - private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); - private final SignedAggregateAndProofSchema signedAggregateAndProofSchema = - spec.getGenesisSchemaDefinitions().getSignedAggregateAndProofSchema(); - private final AggregateAndProofSchema aggregateAndProofSchema = - spec.getGenesisSchemaDefinitions().getAggregateAndProofSchema(); - private final StorageSystem storageSystem = - InMemoryStorageSystemBuilder.buildDefault(StateStorageMode.ARCHIVE); - private final ChainBuilder chainBuilder = ChainBuilder.create(spec, VALIDATOR_KEYS); - private final ChainUpdater chainUpdater = - new ChainUpdater(storageSystem.recentChainData(), chainBuilder); - - private final AggregateGenerator generator = - new AggregateGenerator(spec, chainBuilder.getValidatorKeys()); - private final AttestationValidator attestationValidator = mock(AttestationValidator.class); - - private final AsyncBLSSignatureVerifier signatureVerifier = - AsyncBLSSignatureVerifier.wrap(BLSSignatureVerifier.SIMPLE); - private AggregateAttestationValidator validator = - new AggregateAttestationValidator(spec, attestationValidator, signatureVerifier); + private Spec spec; + private SpecVersion genesisSpec; + private DataStructureUtil dataStructureUtil; + private SignedAggregateAndProofSchema signedAggregateAndProofSchema; + private AggregateAndProofSchema aggregateAndProofSchema; + private StorageSystem storageSystem; + private ChainUpdater chainUpdater; + private AttestationValidator attestationValidator; + private AggregateGenerator generator; + + private AggregateAttestationValidator validator; private SignedBlockAndState bestBlock; private SignedBlockAndState genesis; @@ -150,7 +147,25 @@ public static void reset() { } @BeforeEach - public void setUp() { + public void setUp(final SpecContext specContext) { + spec = specContext.getSpec(); + dataStructureUtil = specContext.getDataStructureUtil(); + genesisSpec = spec.getGenesisSpec(); + signedAggregateAndProofSchema = + specContext.getSchemaDefinitions().getSignedAggregateAndProofSchema(); + aggregateAndProofSchema = specContext.getSchemaDefinitions().getAggregateAndProofSchema(); + storageSystem = InMemoryStorageSystemBuilder.buildDefault(StateStorageMode.ARCHIVE); + + final ChainBuilder chainBuilder = ChainBuilder.create(spec, VALIDATOR_KEYS); + chainUpdater = new ChainUpdater(storageSystem.recentChainData(), chainBuilder); + generator = new AggregateGenerator(spec, chainBuilder.getValidatorKeys()); + + attestationValidator = mock(AttestationValidator.class); + final AsyncBLSSignatureVerifier signatureVerifier = + AsyncBLSSignatureVerifier.wrap(BLSSignatureVerifier.SIMPLE); + + validator = new AggregateAttestationValidator(spec, attestationValidator, signatureVerifier); + genesis = chainUpdater.initializeGenesis(false); bestBlock = chainUpdater.addNewBestBlock(); } @@ -161,7 +176,7 @@ private void disableSignatureVerification() { spec, attestationValidator, AsyncBLSSignatureVerifier.wrap(BLSSignatureVerifier.NO_OP)); } - @Test + @TestTemplate public void shouldReturnValidForValidAggregate() { final StateAndBlockSummary chainHead = storageSystem.getChainHead(); final SignedAggregateAndProof aggregate = generator.validAggregateAndProof(chainHead); @@ -170,7 +185,7 @@ public void shouldReturnValidForValidAggregate() { .isCompletedWithValue(InternalValidationResult.ACCEPT); } - @Test + @TestTemplate public void shouldRejectWhenAttestationValidatorRejects() { final SignedAggregateAndProof aggregate = generator.validAggregateAndProof(storageSystem.getChainHead()); @@ -184,7 +199,7 @@ public void shouldRejectWhenAttestationValidatorRejects() { assertThat(validator.validate(attestation)).isCompletedWithValue(reject("Nah mate")); } - @Test + @TestTemplate public void shouldIgnoreWhenAttestationValidatorIgnores() { final SignedAggregateAndProof aggregate = generator.validAggregateAndProof(storageSystem.getChainHead()); @@ -198,11 +213,11 @@ public void shouldIgnoreWhenAttestationValidatorIgnores() { .isCompletedWithValue(InternalValidationResult.IGNORE); } - @Test + @TestTemplate public void shouldSaveForFutureWhenAttestationValidatorSavesForFuture() { final SignedAggregateAndProof aggregate = generator.validAggregateAndProof(storageSystem.getChainHead()); - ValidatableAttestation attestation = + final ValidatableAttestation attestation = ValidatableAttestation.aggregateFromValidator(spec, aggregate); when(attestationValidator.singleOrAggregateAttestationChecks( any(), eq(attestation), eq(OptionalInt.empty()))) @@ -212,7 +227,7 @@ public void shouldSaveForFutureWhenAttestationValidatorSavesForFuture() { .isCompletedWithValue(InternalValidationResult.SAVE_FOR_FUTURE); } - @Test + @TestTemplate public void shouldSaveForFutureWhenStateIsNotAvailable() { final SignedBlockAndState target = bestBlock; final SignedAggregateAndProof aggregate = generator.validAggregateAndProof(target.toUnsigned()); @@ -226,7 +241,7 @@ public void shouldSaveForFutureWhenStateIsNotAvailable() { .isCompletedWithValue(InternalValidationResult.SAVE_FOR_FUTURE); } - @Test + @TestTemplate public void shouldOnlyAcceptFirstAggregateWithSameSlotAndAggregatorIndex() { final BeaconBlockAndState chainHead = bestBlock.toUnsigned(); final SignedAggregateAndProof aggregateAndProof1 = generator.validAggregateAndProof(chainHead); @@ -260,7 +275,7 @@ public void shouldOnlyAcceptFirstAggregateWithSameSlotAndAggregatorIndex() { .isCompletedWithValueMatching(InternalValidationResult::isIgnore); } - @Test + @TestTemplate public void shouldAcceptAggregateWithSameHashTreeRoot() { final StateAndBlockSummary chainHead = storageSystem.getChainHead(); final SignedAggregateAndProof aggregateAndProof1 = generator.validAggregateAndProof(chainHead); @@ -293,7 +308,7 @@ public void shouldAcceptAggregateWithSameHashTreeRoot() { .isCompletedWithValueMatching(InternalValidationResult::isIgnore); } - @Test + @TestTemplate public void shouldOnlyAcceptFirstAggregateWithSameHashTreeRootWhenPassedSeenAggregates() { final StateAndBlockSummary chainHead = storageSystem.getChainHead(); final SignedAggregateAndProof aggregateAndProof1 = generator.validAggregateAndProof(chainHead); @@ -323,15 +338,17 @@ public void shouldOnlyAcceptFirstAggregateWithSameHashTreeRootWhenPassedSeenAggr .isCompletedWithValueMatching(InternalValidationResult::isIgnore); } - @Test + @TestTemplate void shouldRejectAggregateAttestationWithNoParticipants() { disableSignatureVerification(); final StateAndBlockSummary chainHead = storageSystem.getChainHead(); final SignedAggregateAndProof validAggregate = generator.validAggregateAndProof(chainHead); final AttestationData attestationData = validAggregate.getMessage().getAggregate().getData(); + final UInt64 committeeIndex = + validAggregate.getMessage().getAggregate().getFirstCommitteeIndex(); // all aggregation bits are set to 0b0 (no participants) final ValidatableAttestation attestation = - createValidAggregate(ONE, attestationData, false, false, false); + createValidAggregate(ONE, attestationData, committeeIndex, false, false, false); final InternalValidationResult validationResult = safeJoin(validator.validate(attestation)); @@ -340,53 +357,64 @@ void shouldRejectAggregateAttestationWithNoParticipants() { .hasValue("Rejecting aggregate attestation because it does not have participants"); } - @Test + @TestTemplate void shouldIgnoreAggregateWhenAlreadySeenAllAttestingValidators() { disableSignatureVerification(); final StateAndBlockSummary chainHead = storageSystem.getChainHead(); final SignedAggregateAndProof validAggregate = generator.validAggregateAndProof(chainHead); final AttestationData attestationData = validAggregate.getMessage().getAggregate().getData(); + final UInt64 committeeIndex = + validAggregate.getMessage().getAggregate().getFirstCommitteeIndex(); final ValidatableAttestation smallAttestation = - createValidAggregate(ONE, attestationData, true, false, false); + createValidAggregate(ONE, attestationData, committeeIndex, true, false, false); final ValidatableAttestation largeAttestation = createValidAggregate( - validAggregate.getMessage().getIndex(), attestationData, true, true, true); + validAggregate.getMessage().getIndex(), + attestationData, + committeeIndex, + true, + true, + true); validator.addSeenAggregate(largeAttestation); assertThat(validator.validate(smallAttestation)) .isCompletedWithValueMatching(InternalValidationResult::isIgnore); } - @Test + @TestTemplate void shouldAcceptAggregateWhenNotAllAttestingValidatorsSeen() { disableSignatureVerification(); final StateAndBlockSummary chainHead = storageSystem.getChainHead(); final AggregateAndProof validAggregate = generator.validAggregateAndProof(chainHead).getMessage(); final AttestationData attestationData = validAggregate.getAggregate().getData(); + final UInt64 committeeIndex = validAggregate.getAggregate().getFirstCommitteeIndex(); final ValidatableAttestation smallAttestation = - createValidAggregate(ONE, attestationData, true, false, false); + createValidAggregate(ONE, attestationData, committeeIndex, true, false, false); final ValidatableAttestation largeAttestation = - createValidAggregate(validAggregate.getIndex(), attestationData, true, true, true); + createValidAggregate( + validAggregate.getIndex(), attestationData, committeeIndex, true, true, true); validator.addSeenAggregate(smallAttestation); assertThat(validator.validate(largeAttestation)) .isCompletedWithValueMatching(InternalValidationResult::isAccept); } - @Test + @TestTemplate void shouldAcceptAggregateWhenNoSupersetOfValidatorsSeen() { disableSignatureVerification(); final StateAndBlockSummary chainHead = storageSystem.getChainHead(); final AggregateAndProof validAggregate = generator.validAggregateAndProof(chainHead).getMessage(); final AttestationData attestationData = validAggregate.getAggregate().getData(); + final UInt64 committeeIndex = validAggregate.getAggregate().getFirstCommitteeIndex(); final ValidatableAttestation smallAttestation1 = - createValidAggregate(ONE, attestationData, true, false, true); + createValidAggregate(ONE, attestationData, committeeIndex, true, false, true); final ValidatableAttestation smallAttestation2 = - createValidAggregate(UInt64.valueOf(2), attestationData, false, true, true); + createValidAggregate(UInt64.valueOf(2), attestationData, committeeIndex, false, true, true); final ValidatableAttestation attestation = - createValidAggregate(validAggregate.getIndex(), attestationData, true, true, false); + createValidAggregate( + validAggregate.getIndex(), attestationData, committeeIndex, true, true, false); validator.addSeenAggregate(smallAttestation1); validator.addSeenAggregate(smallAttestation2); @@ -399,6 +427,7 @@ void shouldAcceptAggregateWhenNoSupersetOfValidatorsSeen() { private ValidatableAttestation createValidAggregate( final UInt64 validatorIndex, final AttestationData attestationData, + final UInt64 committeeIndex, final Boolean... aggregationBitsPrefix) { final BeaconState state = storageSystem.getChainHead().getState(); final int committeeSize = @@ -416,7 +445,12 @@ private ValidatableAttestation createValidAggregate( final Attestation attestation = aggregateAndProofSchema .getAttestationSchema() - .create(sszAggregationBits, attestationData, BLSSignature.empty()); + .create( + sszAggregationBits, + attestationData, + BLSSignature.empty(), + getCommitteeBitsSupplier( + aggregateAndProofSchema.getAttestationSchema(), committeeIndex)); final SignedAggregateAndProof signedAggregate = signedAggregateAndProofSchema.create( aggregateAndProofSchema.create(validatorIndex, attestation, BLSSignature.empty()), @@ -425,8 +459,12 @@ private ValidatableAttestation createValidAggregate( return ValidatableAttestation.aggregateFromValidator(spec, signedAggregate); } - @Test - public void shouldAcceptAggregateWithSameSlotAndDifferentAggregatorIndex() { + @TestTemplate + public void shouldAcceptAggregateWithSameSlotAndDifferentAggregatorIndex( + final SpecContext specContext) { + // can run only on phase 0, we should find magic combination for ELECTRA too + specContext.assumeIsNotOneOf(ELECTRA); + final StateAndBlockSummary chainHead = storageSystem.getChainHead(); final SignedAggregateAndProof aggregateAndProof1 = generator.validAggregateAndProof(chainHead); @@ -455,8 +493,12 @@ public void shouldAcceptAggregateWithSameSlotAndDifferentAggregatorIndex() { .isCompletedWithValue(InternalValidationResult.ACCEPT); } - @Test - public void shouldAcceptAggregateWithSameAggregatorIndexAndDifferentSlot() { + @TestTemplate + public void shouldAcceptAggregateWithSameAggregatorIndexAndDifferentSlot( + final SpecContext specContext) { + // can run only on phase 0, we should find magic combination for ELECTRA too + specContext.assumeIsNotOneOf(ELECTRA); + chainUpdater.setCurrentSlot(ONE); final BeaconBlockAndState chainHead = bestBlock.toUnsigned(); @@ -474,8 +516,8 @@ public void shouldAcceptAggregateWithSameAggregatorIndexAndDifferentSlot() { final SignedAggregateAndProof aggregateAndProof2 = generator .generator() - .blockAndState(chainHead, epochOneCommitteeAssignment.getSlot()) - .committeeIndex(epochOneCommitteeAssignment.getCommitteeIndex()) + .blockAndState(chainHead, epochOneCommitteeAssignment.slot()) + .committeeIndex(epochOneCommitteeAssignment.committeeIndex()) .aggregatorIndex(aggregatorIndex) .generate(); whenAttestationIsValid(aggregateAndProof1); @@ -497,7 +539,7 @@ public void shouldAcceptAggregateWithSameAggregatorIndexAndDifferentSlot() { .isCompletedWithValue(InternalValidationResult.ACCEPT); } - @Test + @TestTemplate public void shouldRejectAggregateWhenSelectionProofDoesNotSelectAsAggregator() { final StateAndBlockSummary chainHead = storageSystem.getChainHead(); int aggregatorIndex = 3; @@ -506,13 +548,13 @@ public void shouldRejectAggregateWhenSelectionProofDoesNotSelectAsAggregator() { final SignedAggregateAndProof aggregate = generator .generator() - .blockAndState(chainHead, committeeAssignment.getSlot()) + .blockAndState(chainHead, committeeAssignment.slot()) .aggregatorIndex(UInt64.valueOf(aggregatorIndex)) - .committeeIndex(committeeAssignment.getCommitteeIndex()) + .committeeIndex(committeeAssignment.committeeIndex()) .generate(); whenAttestationIsValid(aggregate); // Sanity check - final int committeeLength = committeeAssignment.getCommittee().size(); + final int committeeLength = committeeAssignment.committee().size(); final int aggregatorModulo = genesisSpec.getValidatorsUtil().getAggregatorModulo(committeeLength); assertThat(aggregatorModulo).isGreaterThan(1); @@ -526,7 +568,7 @@ public void shouldRejectAggregateWhenSelectionProofDoesNotSelectAsAggregator() { .isCompletedWithValueMatching(InternalValidationResult::isReject); } - @Test + @TestTemplate public void shouldRejectIfAggregatorIndexIsNotWithinTheCommittee() { final StateAndBlockSummary chainHead = storageSystem.getChainHead(); final int aggregatorIndex = 60; @@ -542,8 +584,8 @@ public void shouldRejectIfAggregatorIndexIsNotWithinTheCommittee() { final CommitteeAssignment committeeAssignment = getCommitteeAssignment( chainHead, aggregatorIndex, spec.computeEpochAtSlot(chainHead.getSlot())); - if (committeeAssignment.getCommitteeIndex().equals(attestationData.getIndex()) - && committeeAssignment.getSlot().equals(attestationData.getSlot())) { + if (committeeAssignment.committeeIndex().equals(attestationData.getIndex()) + && committeeAssignment.slot().equals(attestationData.getSlot())) { fail("Aggregator was in the committee"); } @@ -551,7 +593,7 @@ public void shouldRejectIfAggregatorIndexIsNotWithinTheCommittee() { .isCompletedWithValueMatching(InternalValidationResult::isReject); } - @Test + @TestTemplate public void shouldRejectIfSelectionProofIsNotAValidSignatureOfAggregatorIndex() { final SignedAggregateAndProof aggregate = generator @@ -566,7 +608,7 @@ public void shouldRejectIfSelectionProofIsNotAValidSignatureOfAggregatorIndex() .isCompletedWithValueMatching(InternalValidationResult::isReject); } - @Test + @TestTemplate public void shouldRejectIfAggregateAndProofSignatureIsNotValid() { final SignedAggregateAndProof validAggregate = generator.validAggregateAndProof(storageSystem.getChainHead()); @@ -588,19 +630,17 @@ public void shouldRejectIfAggregateAndProofSignatureIsNotValid() { private boolean hasSameCommitteeIndex( final SignedAggregateAndProof aggregateAndProof, final Attestation attestation) { return attestation - .getData() - .getIndex() - .equals(aggregateAndProof.getMessage().getAggregate().getData().getIndex()); + .getFirstCommitteeIndex() + .equals(aggregateAndProof.getMessage().getAggregate().getFirstCommitteeIndex()); } private void whenAttestationIsValid(final SignedAggregateAndProof aggregate) { - ValidatableAttestation attestation = + final ValidatableAttestation attestation = ValidatableAttestation.aggregateFromValidator(spec, aggregate); + final BeaconState state = getStateFor(aggregate).orElseThrow(); when(attestationValidator.singleOrAggregateAttestationChecks( any(), eq(attestation), eq(OptionalInt.empty()))) - .thenReturn( - SafeFuture.completedFuture( - InternalValidationResultWithState.accept(getStateFor(aggregate).orElseThrow()))); + .thenReturn(SafeFuture.completedFuture(InternalValidationResultWithState.accept(state))); } private Optional getStateFor(final SignedAggregateAndProof aggregate) { @@ -615,4 +655,10 @@ private CommitteeAssignment getCommitteeAssignment( final StateAndBlockSummary chainHead, final int aggregatorIndex, final UInt64 epoch) { return spec.getCommitteeAssignment(chainHead.getState(), epoch, aggregatorIndex).orElseThrow(); } + + private Supplier getCommitteeBitsSupplier( + final AttestationSchema attestationSchema, final UInt64 committeeIndex) { + return () -> + attestationSchema.getCommitteeBitsSchema().orElseThrow().ofBits(committeeIndex.intValue()); + } } diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/BlobSidecarGossipValidatorTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/BlobSidecarGossipValidatorTest.java index f2d909bed46..4abe8e6db2c 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/BlobSidecarGossipValidatorTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/BlobSidecarGossipValidatorTest.java @@ -13,6 +13,7 @@ package tech.pegasys.teku.statetransition.validation; +import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.clearInvocations; @@ -35,6 +36,7 @@ import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.SpecVersion; import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.TestSpecInvocationContextProvider.SpecContext; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlockHeader; @@ -44,7 +46,7 @@ import tech.pegasys.teku.spec.logic.versions.deneb.helpers.MiscHelpersDeneb; import tech.pegasys.teku.spec.util.DataStructureUtil; -@TestSpecContext(milestone = {SpecMilestone.DENEB, SpecMilestone.EIP7594}) +@TestSpecContext(milestone = {SpecMilestone.DENEB, SpecMilestone.ELECTRA}) public class BlobSidecarGossipValidatorTest { private final Map invalidBlocks = new HashMap<>(); private final GossipValidationHelper gossipValidationHelper = mock(GossipValidationHelper.class); @@ -129,7 +131,9 @@ void shouldRejectWhenIndexIsTooBig(final SpecContext specContext) { .createRandomBlobSidecarBuilder() .signedBeaconBlockHeader( new SignedBeaconBlockHeader(blockHeader, dataStructureUtil.randomSignature())) - .index(UInt64.valueOf(specContext.getSpec().getMaxBlobsPerBlock().orElseThrow())) + .index( + UInt64.valueOf( + specContext.getSpec().getMaxBlobsPerBlockForHighestMilestone().orElseThrow())) .build(); SafeFutureAssert.assertThatSafeFuture(blobSidecarValidator.validate(blobSidecar)) @@ -138,15 +142,11 @@ void shouldRejectWhenIndexIsTooBig(final SpecContext specContext) { @TestTemplate void shouldRejectWhenSlotIsNotDeneb() { - final Spec mockedSpec = mock(Spec.class); - when(mockedSpec.getMaxBlobsPerBlock(slot)).thenReturn(Optional.empty()); - final SpecVersion mockedSpecVersion = mock(SpecVersion.class); - when(mockedSpec.getGenesisSpec()).thenReturn(mockedSpecVersion); - when(mockedSpecVersion.getSlotsPerEpoch()).thenReturn(1); + final Spec spec = TestSpecFactory.createMinimalBellatrix(); blobSidecarValidator = BlobSidecarGossipValidator.create( - mockedSpec, invalidBlocks, gossipValidationHelper, miscHelpersDeneb, kzg); + spec, invalidBlocks, gossipValidationHelper, miscHelpersDeneb, kzg); SafeFutureAssert.assertThatSafeFuture(blobSidecarValidator.validate(blobSidecar)) .isCompletedWithValueMatching(InternalValidationResult::isReject); @@ -277,6 +277,16 @@ void shouldTrackValidInfoSet() { .isCompletedWithValueMatching(InternalValidationResult::isIgnore); } + @TestTemplate + void shouldMarkForEquivocation() { + assertThat(blobSidecarValidator.markForEquivocation(blobSidecar)).isTrue(); + + assertThat(blobSidecarValidator.markForEquivocation(blobSidecar)).isFalse(); + + SafeFutureAssert.assertThatSafeFuture(blobSidecarValidator.validate(blobSidecar)) + .isCompletedWithValueMatching(InternalValidationResult::isIgnore); + } + @TestTemplate void shouldIgnoreImmediatelyWhenBlobFromValidInfoSet() { SafeFutureAssert.assertThatSafeFuture(blobSidecarValidator.validate(blobSidecar)) @@ -361,11 +371,12 @@ void shouldNotVerifyKnownValidSignedHeader() { } @TestTemplate - void shouldVerifySignedHeaderAgainAfterItDroppedFromCache() { + void shouldVerifySignedHeaderAgainAfterItDroppedFromCache(final SpecContext specContext) { final Spec specMock = mock(Spec.class); final SpecVersion specVersion = mock(SpecVersion.class); - when(specMock.getMaxBlobsPerBlock(any())).thenReturn(Optional.of(6)); + when(specMock.atSlot(any())).thenReturn(specVersion); when(specMock.getGenesisSpec()).thenReturn(specVersion); + when(specVersion.getConfig()).thenReturn(specContext.getSpec().getGenesisSpecConfig()); // This will make cache of size 3 when(specVersion.getSlotsPerEpoch()).thenReturn(1); this.blobSidecarValidator = diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/BlockBroadcastValidatorTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/BlockBroadcastValidatorTest.java index 3d36ea16fcb..4b09d7f187a 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/BlockBroadcastValidatorTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/BlockBroadcastValidatorTest.java @@ -17,13 +17,15 @@ import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoInteractions; import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.when; import static tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel.CONSENSUS_AND_EQUIVOCATION; +import static tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel.EQUIVOCATION; import static tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel.GOSSIP; import static tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel.NOT_REQUIRED; import static tech.pegasys.teku.statetransition.validation.BlockBroadcastValidator.BroadcastValidationResult.CONSENSUS_FAILURE; -import static tech.pegasys.teku.statetransition.validation.BlockBroadcastValidator.BroadcastValidationResult.FINAL_EQUIVOCATION_FAILURE; +import static tech.pegasys.teku.statetransition.validation.BlockBroadcastValidator.BroadcastValidationResult.EQUIVOCATION_FAILURE; import static tech.pegasys.teku.statetransition.validation.BlockBroadcastValidator.BroadcastValidationResult.GOSSIP_FAILURE; import static tech.pegasys.teku.statetransition.validation.BlockBroadcastValidator.BroadcastValidationResult.SUCCESS; import static tech.pegasys.teku.statetransition.validation.ValidationResultCode.ValidationResultSubCode.IGNORE_ALREADY_SEEN; @@ -56,6 +58,32 @@ public class BlockBroadcastValidatorTest { final SafeFuture blockImportResult = new SafeFuture<>(); + @Test + public void shouldReturnSuccessWhenValidationIsEquivocationAndBlockIsNotEquivocating() { + when(blockGossipValidator.performBlockEquivocationCheck(true, block)) + .thenReturn(EquivocationCheckResult.FIRST_BLOCK_FOR_SLOT_PROPOSER); + + prepareBlockBroadcastValidator(EQUIVOCATION); + + assertThat(blockBroadcastValidator.getResult()) + .isCompletedWithValueMatching(result -> result.equals(SUCCESS)); + verify(blockGossipValidator).performBlockEquivocationCheck(true, block); + verifyNoMoreInteractions(blockGossipValidator); + } + + @Test + public void shouldReturnEquivocationFailureWhenValidationIsEquivocationAndBlockIsEquivocating() { + when(blockGossipValidator.performBlockEquivocationCheck(true, block)) + .thenReturn(EquivocationCheckResult.EQUIVOCATING_BLOCK_FOR_SLOT_PROPOSER); + + prepareBlockBroadcastValidator(EQUIVOCATION); + + assertThat(blockBroadcastValidator.getResult()) + .isCompletedWithValueMatching(result -> result.equals(EQUIVOCATION_FAILURE)); + verify(blockGossipValidator).performBlockEquivocationCheck(true, block); + verifyNoMoreInteractions(blockGossipValidator); + } + @Test public void shouldReturnSuccessWhenValidationIsGossipAndGossipValidationReturnsAccept() { when(blockGossipValidator.validate(eq(block), eq(true))) @@ -109,14 +137,23 @@ public void shouldReturnGossipFailureImmediatelyWhenGossipValidationIsNotAccept( if (broadcastValidation == NOT_REQUIRED) { prepareBlockBroadcastValidator(broadcastValidation); + assertThat(blockBroadcastValidator.getResult()) + .isCompletedWithValueMatching(result -> result.equals(SUCCESS)); + verifyNoInteractions(blockGossipValidator); + return; + } + if (broadcastValidation == EQUIVOCATION) { + when(blockGossipValidator.performBlockEquivocationCheck(true, block)) + .thenReturn(EquivocationCheckResult.FIRST_BLOCK_FOR_SLOT_PROPOSER); + prepareBlockBroadcastValidator(broadcastValidation); assertThat(blockBroadcastValidator.getResult()) .isCompletedWithValueMatching(result -> result.equals(SUCCESS)); - verifyNoMoreInteractions(blockGossipValidator); + verify(blockGossipValidator).performBlockEquivocationCheck(true, block); return; } - when(blockGossipValidator.validate(eq(block), eq(true))) + when(blockGossipValidator.validate(block, broadcastValidation != CONSENSUS_AND_EQUIVOCATION)) .thenReturn(SafeFuture.completedFuture(internalValidationResult)); prepareBlockBroadcastValidator(broadcastValidation); @@ -126,7 +163,7 @@ public void shouldReturnGossipFailureImmediatelyWhenGossipValidationIsNotAccept( assertThat(blockBroadcastValidator.getResult()) .isCompletedWithValueMatching(result -> result.equals(GOSSIP_FAILURE)); - verify(blockGossipValidator).validate(eq(block), eq(true)); + verify(blockGossipValidator).validate(block, broadcastValidation != CONSENSUS_AND_EQUIVOCATION); verifyNoMoreInteractions(blockGossipValidator); } @@ -137,7 +174,7 @@ public void shouldReturnGossipFailureImmediatelyWhenGossipValidationIsNotAccept( public void shouldReturnConsensusFailureImmediatelyWhenConsensusValidationIsNotSuccessful( final BroadcastValidationLevel broadcastValidation) { - when(blockGossipValidator.validate(eq(block), eq(true))) + when(blockGossipValidator.validate(block, broadcastValidation != CONSENSUS_AND_EQUIVOCATION)) .thenReturn(SafeFuture.completedFuture(InternalValidationResult.ACCEPT)); prepareBlockBroadcastValidator(broadcastValidation); @@ -147,7 +184,7 @@ public void shouldReturnConsensusFailureImmediatelyWhenConsensusValidationIsNotS assertThat(blockBroadcastValidator.getResult()) .isCompletedWithValueMatching(result -> result.equals(CONSENSUS_FAILURE)); - verify(blockGossipValidator).validate(eq(block), eq(true)); + verify(blockGossipValidator).validate(block, broadcastValidation != CONSENSUS_AND_EQUIVOCATION); verifyNoMoreInteractions(blockGossipValidator); } @@ -157,7 +194,7 @@ public void shouldReturnConsensusFailureImmediatelyWhenConsensusValidationIsNotS names = {"CONSENSUS", "CONSENSUS_AND_EQUIVOCATION"}) public void shouldReturnConsensusFailureImmediatelyWhenConsensusCompleteExceptionally( final BroadcastValidationLevel broadcastValidation) { - when(blockGossipValidator.validate(eq(block), eq(true))) + when(blockGossipValidator.validate(block, broadcastValidation != CONSENSUS_AND_EQUIVOCATION)) .thenReturn(SafeFuture.completedFuture(InternalValidationResult.ACCEPT)); prepareBlockBroadcastValidator(broadcastValidation); @@ -165,7 +202,7 @@ public void shouldReturnConsensusFailureImmediatelyWhenConsensusCompleteExceptio blockImportResult.completeExceptionally(new RuntimeException("error")); assertThat(blockBroadcastValidator.getResult()).isCompletedExceptionally(); - verify(blockGossipValidator).validate(eq(block), eq(true)); + verify(blockGossipValidator).validate(block, broadcastValidation != CONSENSUS_AND_EQUIVOCATION); verifyNoMoreInteractions(blockGossipValidator); } @@ -173,10 +210,10 @@ public void shouldReturnConsensusFailureImmediatelyWhenConsensusCompleteExceptio @EnumSource(value = EquivocationCheckResult.class) public void shouldReturnFinalEquivocationFailureOnlyForEquivocatingBlocks( final EquivocationCheckResult equivocationCheckResult) { - when(blockGossipValidator.validate(eq(block), eq(true))) + when(blockGossipValidator.validate(eq(block), eq(false))) .thenReturn(SafeFuture.completedFuture(InternalValidationResult.ACCEPT)); - when(blockGossipValidator.performBlockEquivocationCheck(eq(block))) + when(blockGossipValidator.performBlockEquivocationCheck(true, block)) .thenReturn(equivocationCheckResult); prepareBlockBroadcastValidator(CONSENSUS_AND_EQUIVOCATION); @@ -193,12 +230,12 @@ public void shouldReturnFinalEquivocationFailureOnlyForEquivocatingBlocks( result -> { if (equivocationCheckResult.equals( EquivocationCheckResult.EQUIVOCATING_BLOCK_FOR_SLOT_PROPOSER)) { - return result.equals(FINAL_EQUIVOCATION_FAILURE); + return result.equals(EQUIVOCATION_FAILURE); } return result.equals(SUCCESS); }); - verify(blockGossipValidator).validate(eq(block), eq(true)); - verify(blockGossipValidator).performBlockEquivocationCheck(eq(block)); + verify(blockGossipValidator).validate(eq(block), eq(false)); + verify(blockGossipValidator).performBlockEquivocationCheck(true, block); verifyNoMoreInteractions(blockGossipValidator); } diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/BlockGossipValidatorTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/BlockGossipValidatorTest.java index 1d1c62f71ca..3070fbb53a4 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/BlockGossipValidatorTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/BlockGossipValidatorTest.java @@ -53,7 +53,7 @@ SpecMilestone.ALTAIR, SpecMilestone.BELLATRIX, SpecMilestone.DENEB, - SpecMilestone.EIP7594 + SpecMilestone.ELECTRA }) public class BlockGossipValidatorTest { private Spec spec; @@ -96,14 +96,14 @@ void shouldReturnValidForValidBlock() { final SignedBeaconBlock block = signedBlockAndState.getBlock(); storageSystem.chainUpdater().setCurrentSlot(nextSlot); - assertResultIsAccept(block, blockGossipValidator.validate(block, false)); + assertResultIsAccept(block, blockGossipValidator.validate(block, true)); } @TestTemplate void shouldIgnoreAlreadyImportedBlock() { final SignedBeaconBlock block = storageSystem.chainUpdater().advanceChain().getBlock(); - assertThat(blockGossipValidator.validate(block, false)) + assertThat(blockGossipValidator.validate(block, true)) .isCompletedWithValueMatching(InternalValidationResult::isIgnore); } @@ -115,9 +115,9 @@ void shouldReturnInvalidForSecondValidBlockForSlotAndProposer() { final SignedBeaconBlock block = signedBlockAndState.getBlock(); storageSystem.chainUpdater().setCurrentSlot(nextSlot); - assertResultIsAccept(block, blockGossipValidator.validate(block, false)); + assertResultIsAccept(block, blockGossipValidator.validate(block, true)); - assertThat(blockGossipValidator.validate(block, false)) + assertThat(blockGossipValidator.validate(block, true)) .isCompletedWithValueMatching(InternalValidationResult::isIgnore); } @@ -127,7 +127,7 @@ void shouldReturnSavedForFutureForBlockFromFuture() { final SignedBeaconBlock block = storageSystem.chainBuilder().generateBlockAtSlot(nextSlot).getBlock(); - assertThat(blockGossipValidator.validate(block, false)) + assertThat(blockGossipValidator.validate(block, true)) .isCompletedWithValueMatching(InternalValidationResult::isSaveForFuture); } @@ -159,7 +159,7 @@ void shouldReturnSavedForFutureForBlockWithParentUnavailable() { final SignedBeaconBlock blockWithNoParent = SignedBeaconBlock.create(spec, block, blockSignature); - assertThat(blockGossipValidator.validate(blockWithNoParent, false)) + assertThat(blockGossipValidator.validate(blockWithNoParent, true)) .isCompletedWithValueMatching(InternalValidationResult::isSaveForFuture); } @@ -175,7 +175,7 @@ void shouldReturnInvalidForBlockOlderThanFinalizedSlot() { final SignedBeaconBlock block = storageSystem2.chainBuilder().generateBlockAtSlot(finalizedSlot.minus(ONE)).getBlock(); - assertThat(blockGossipValidator.validate(block, false)) + assertThat(blockGossipValidator.validate(block, true)) .isCompletedWithValueMatching(InternalValidationResult::isIgnore); } @@ -209,7 +209,7 @@ void shouldReturnInvalidForBlockWithWrongProposerIndex() { final SignedBeaconBlock invalidProposerSignedBlock = SignedBeaconBlock.create(spec, block, blockSignature); - assertThat(blockGossipValidator.validate(invalidProposerSignedBlock, false)) + assertThat(blockGossipValidator.validate(invalidProposerSignedBlock, true)) .isCompletedWithValueMatching(InternalValidationResult::isReject); } @@ -224,7 +224,7 @@ void shouldReturnInvalidForBlockWithWrongSignature() { storageSystem.chainBuilder().generateBlockAtSlot(nextSlot).getBlock().getMessage(), BLSTestUtil.randomSignature(0)); - assertThat(blockGossipValidator.validate(block, false)) + assertThat(blockGossipValidator.validate(block, true)) .isCompletedWithValueMatching(InternalValidationResult::isReject); } @@ -260,7 +260,7 @@ void shouldReturnInvalidForBlockThatDoesNotDescendFromFinalizedCheckpoint() { chainBuilderFork.generateBlockAtSlot(startSlotOfFinalizedEpoch.increment()); chainUpdater.saveBlockTime(blockAndState); final SafeFuture result = - blockValidator.validate(blockAndState.getBlock(), false); + blockValidator.validate(blockAndState.getBlock(), true); assertThat(result).isCompletedWithValueMatching(InternalValidationResult::isReject); } @@ -285,7 +285,7 @@ void shouldReturnAcceptOnCorrectExecutionPayloadTimestamp(final SpecContext spec SignedBeaconBlock block = storageSystem.chainBuilder().generateBlockAtSlot(nextSlot).getBlock(); - assertResultIsAccept(block, blockGossipValidator.validate(block, false)); + assertResultIsAccept(block, blockGossipValidator.validate(block, true)); } @TestTemplate @@ -317,32 +317,32 @@ void shouldReturnInvalidOnWrongExecutionPayloadTimestamp(final SpecContext specC .setExecutionPayload( specContext.getDataStructureUtil().randomExecutionPayload())); - assertThat(blockGossipValidator.validate(signedBlockAndState.getBlock(), false)) + assertThat(blockGossipValidator.validate(signedBlockAndState.getBlock(), true)) .isCompletedWithValueMatching(InternalValidationResult::isReject); } @TestTemplate - void shouldNotTrackLocallyProducedBlocks() { + void shouldNotTrackBlocksIfMarkAsReceivedIsFalse() { final UInt64 nextSlot = recentChainData.getHeadSlot().plus(ONE); final SignedBlockAndState signedBlockAndState = storageSystem.chainBuilder().generateBlockAtSlot(nextSlot); final SignedBeaconBlock block = signedBlockAndState.getBlock(); storageSystem.chainUpdater().setCurrentSlot(nextSlot); - assertResultIsAccept(block, blockGossipValidator.validate(block, true)); - assertThat(blockGossipValidator.performBlockEquivocationCheck(block)) + assertResultIsAccept(block, blockGossipValidator.validate(block, false)); + assertThat(blockGossipValidator.performBlockEquivocationCheck(true, block)) .isEqualByComparingTo(EquivocationCheckResult.FIRST_BLOCK_FOR_SLOT_PROPOSER); } @TestTemplate - void shouldIgnoreLocallyProducedBlocksIfAlreadySeen() { + void shouldIgnoreAlreadySeenBlocks() { final UInt64 nextSlot = recentChainData.getHeadSlot().plus(ONE); final SignedBlockAndState signedBlockAndState = storageSystem.chainBuilder().generateBlockAtSlot(nextSlot); final SignedBeaconBlock block = signedBlockAndState.getBlock(); storageSystem.chainUpdater().setCurrentSlot(nextSlot); - assertResultIsAccept(block, blockGossipValidator.validate(block, false)); + assertResultIsAccept(block, blockGossipValidator.validate(block, true)); assertThat(blockGossipValidator.validate(block, true)) .isCompletedWithValueMatching(InternalValidationResult::isIgnore); diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/BlockValidatorTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/BlockValidatorTest.java index a04297ea88d..1b0f123786f 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/BlockValidatorTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/BlockValidatorTest.java @@ -39,12 +39,12 @@ public class BlockValidatorTest { public void shouldExposeGossipValidation() { final SignedBeaconBlock block = dataStructureUtil.randomSignedBeaconBlock(); - when(blockGossipValidator.validate(eq(block), eq(false))) + when(blockGossipValidator.validate(eq(block), eq(true))) .thenReturn(SafeFuture.completedFuture(InternalValidationResult.ACCEPT)); assertThat(blockValidator.validateGossip(block)) .isCompletedWithValueMatching(InternalValidationResult::isAccept); - verify(blockGossipValidator).validate(eq(block), eq(false)); + verify(blockGossipValidator).validate(eq(block), eq(true)); verifyNoMoreInteractions(blockGossipValidator); } } diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/DataColumnSidecarGossipValidatorTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/DataColumnSidecarGossipValidatorTest.java index 87dd8609edc..b51e0436ebe 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/DataColumnSidecarGossipValidatorTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/DataColumnSidecarGossipValidatorTest.java @@ -44,10 +44,10 @@ import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockHeader; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.logic.common.statetransition.results.BlockImportResult; -import tech.pegasys.teku.spec.logic.versions.eip7594.helpers.MiscHelpersEip7594; +import tech.pegasys.teku.spec.logic.versions.feature.eip7594.helpers.MiscHelpersEip7594; import tech.pegasys.teku.spec.util.DataStructureUtil; -@TestSpecContext(milestone = {SpecMilestone.EIP7594}) +@TestSpecContext(milestone = {SpecMilestone.ELECTRA}) public class DataColumnSidecarGossipValidatorTest { private final Map invalidBlocks = new HashMap<>(); private final GossipValidationHelper gossipValidationHelper = mock(GossipValidationHelper.class); diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/ElectraAttestationValidatorTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/ElectraAttestationValidatorTest.java new file mode 100644 index 00000000000..b663e664092 --- /dev/null +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/ElectraAttestationValidatorTest.java @@ -0,0 +1,87 @@ +/* + * Copyright Consensys Software Inc., 2023 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.statetransition.validation; + +import static org.assertj.core.api.Assertions.assertThat; + +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.datastructures.operations.AttestationData; + +public class ElectraAttestationValidatorTest extends DenebAttestationValidatorTest { + + @Override + public Spec createSpec() { + return TestSpecFactory.createMinimalElectra(); + } + + @Test + public void shouldRejectAttestationForMultipleCommittees() { + final Attestation attestation = + attestationGenerator.validAttestation(storageSystem.getChainHead()); + + final Attestation wrongAttestation = + spec.getGenesisSchemaDefinitions() + .getAttestationSchema() + .create( + attestation.getAggregationBits(), + attestation.getData(), + attestation.getAggregateSignature(), + () -> attestation.getSchema().getCommitteeBitsSchema().orElseThrow().ofBits(1, 3)); + + // Sanity check + assertThat(wrongAttestation.getCommitteeBitsRequired().getBitCount()).isGreaterThan(1); + + assertThat(validate(wrongAttestation)) + .isEqualTo( + InternalValidationResult.reject( + "Rejecting attestation because committee bits count is not 1")); + } + + @Test + public void shouldRejectAggregateWithAttestationDataIndexNonZero() { + final Attestation attestation = + attestationGenerator.validAttestation(storageSystem.getChainHead()); + + final AttestationData correctAttestationData = attestation.getData(); + + final AttestationData nonZeroIndexData = + new AttestationData( + correctAttestationData.getSlot(), + UInt64.ONE, + correctAttestationData.getBeaconBlockRoot(), + correctAttestationData.getSource(), + correctAttestationData.getTarget()); + + final Attestation wrongAttestation = + spec.getGenesisSchemaDefinitions() + .getAttestationSchema() + .create( + attestation.getAggregationBits(), + nonZeroIndexData, + attestation.getAggregateSignature(), + attestation::getCommitteeBitsRequired); + + // Sanity check + assertThat(wrongAttestation.getData().getIndex()).isNotEqualTo(UInt64.ZERO); + + assertThat(validate(wrongAttestation)) + .isEqualTo( + InternalValidationResult.reject( + "Rejecting attestation because attestation data index must be 0")); + } +} diff --git a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/signatures/AggregatingSignatureVerificationServiceTest.java b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/signatures/AggregatingSignatureVerificationServiceTest.java index 6b90579a9a3..a76b5bda6b0 100644 --- a/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/signatures/AggregatingSignatureVerificationServiceTest.java +++ b/ethereum/statetransition/src/test/java/tech/pegasys/teku/statetransition/validation/signatures/AggregatingSignatureVerificationServiceTest.java @@ -44,7 +44,7 @@ import tech.pegasys.teku.statetransition.validation.signatures.AggregatingSignatureVerificationService.SignatureTask; public class AggregatingSignatureVerificationServiceTest { - private static List keys = BLSKeyGenerator.generateKeyPairs(50); + private static final List KEYS = BLSKeyGenerator.generateKeyPairs(50); private final int queueCapacity = 50; private final int batchSize = 25; @@ -366,7 +366,7 @@ private SafeFuture executeInvalidVerify(final int keypairIndex, final i private SafeFuture executeVerify( final int keypairIndex, final int data, final boolean useValidSignature) { - final BLSKeyPair keypair = keys.get(keypairIndex); + final BLSKeyPair keypair = KEYS.get(keypairIndex); final Bytes message = Bytes.of(data); final BLSSignature signature = useValidSignature ? BLS.sign(keypair.getSecretKey(), message) : BLSSignature.empty(); @@ -379,11 +379,11 @@ private SafeFuture executeListVerify( final List messages = new ArrayList<>(); final List signatures = new ArrayList<>(); for (int i = 0; i < keyIndices.size(); i++) { - publicKeys.add(List.of(keys.get(i).getPublicKey())); + publicKeys.add(List.of(KEYS.get(i).getPublicKey())); messages.add(Bytes.of(data.getInt(i))); signatures.add( useValidSignatures.getBoolean(i) - ? BLS.sign(keys.get(i).getSecretKey(), messages.get(i)) + ? BLS.sign(KEYS.get(i).getSecretKey(), messages.get(i)) : BLSSignature.empty()); } return service.verify(publicKeys, messages, signatures); diff --git a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/BeaconChainUtil.java b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/BeaconChainUtil.java index 078d36815dd..55cc8d459cc 100644 --- a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/BeaconChainUtil.java +++ b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/BeaconChainUtil.java @@ -74,7 +74,7 @@ private BeaconChainUtil( final List validatorKeys, final RecentChainData recentChainData, final ForkChoice forkChoice, - boolean signDeposits) { + final boolean signDeposits) { this.spec = spec; this.beaconBlockBodySchema = spec.getGenesisSpec().getSchemaDefinitions().getBeaconBlockBodySchema(); @@ -179,7 +179,7 @@ public SignedBeaconBlock createAndImportBlockAtSlot(final long slot) throws Exce } public SignedBeaconBlock createAndImportBlockAtSlotWithAttestations( - final UInt64 slot, List attestations) throws Exception { + final UInt64 slot, final List attestations) throws Exception { Optional> attestationsSSZList = attestations.isEmpty() ? Optional.empty() @@ -192,10 +192,10 @@ public SignedBeaconBlock createAndImportBlockAtSlotWithAttestations( private SignedBeaconBlock createAndImportBlockAtSlot( final UInt64 slot, - Optional> attestations, - Optional> deposits, - Optional> exits, - Optional eth1Data) + final Optional> attestations, + final Optional> deposits, + final Optional> exits, + final Optional eth1Data) throws Exception { final SignedBeaconBlock block = createBlockAndStateAtSlot(slot, true, attestations, deposits, exits, eth1Data).getBlock(); @@ -231,13 +231,13 @@ public SignedBeaconBlock createBlockAtSlotFromInvalidProposer(final UInt64 slot) return createBlockAtSlot(slot, false); } - public SignedBeaconBlock createBlockAtSlot(final UInt64 slot, boolean withValidProposer) + public SignedBeaconBlock createBlockAtSlot(final UInt64 slot, final boolean withValidProposer) throws Exception { return createBlockAndStateAtSlot(slot, withValidProposer).getBlock(); } - public SignedBlockAndState createBlockAndStateAtSlot(final UInt64 slot, boolean withValidProposer) - throws Exception { + public SignedBlockAndState createBlockAndStateAtSlot( + final UInt64 slot, final boolean withValidProposer) throws Exception { return createBlockAndStateAtSlot( slot, withValidProposer, @@ -249,11 +249,11 @@ public SignedBlockAndState createBlockAndStateAtSlot(final UInt64 slot, boolean private SignedBlockAndState createBlockAndStateAtSlot( final UInt64 slot, - boolean withValidProposer, - Optional> attestations, - Optional> deposits, - Optional> exits, - Optional eth1Data) + final boolean withValidProposer, + final Optional> attestations, + final Optional> deposits, + final Optional> exits, + final Optional eth1Data) throws Exception { checkState( withValidProposer || validatorKeys.size() > 1, diff --git a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/attestation/AggregatorUtil.java b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/attestation/AggregatorUtil.java index a3fd901239f..03f31a4a0db 100644 --- a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/attestation/AggregatorUtil.java +++ b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/attestation/AggregatorUtil.java @@ -13,11 +13,17 @@ package tech.pegasys.teku.statetransition.attestation; +import static com.google.common.base.Preconditions.checkState; + +import it.unimi.dsi.fastutil.ints.IntOpenHashSet; +import it.unimi.dsi.fastutil.ints.IntSet; import java.util.ArrayList; import java.util.List; +import java.util.function.Supplier; import tech.pegasys.teku.bls.BLS; import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; import tech.pegasys.teku.spec.datastructures.operations.Attestation; public class AggregatorUtil { @@ -27,12 +33,40 @@ public static Attestation aggregateAttestations( final List signatures = new ArrayList<>(); signatures.add(firstAttestation.getAggregateSignature()); + final Supplier committeeBitsSupplier; + final IntSet participationIndices = new IntOpenHashSet(); + for (Attestation attestation : attestations) { aggregateBits = aggregateBits.or(attestation.getAggregationBits()); signatures.add(attestation.getAggregateSignature()); + if (firstAttestation.getCommitteeBits().isPresent()) { + participationIndices.addAll(attestation.getCommitteeBitsRequired().getAllSetBits()); + checkState( + participationIndices.size() == 1, + "this test util doesn't support generating cross-committee aggregations"); + } } + + if (firstAttestation.getCommitteeBits().isPresent()) { + committeeBitsSupplier = + firstAttestation + .getSchema() + .getCommitteeBitsSchema() + .map( + committeeBitsSchema -> + (Supplier) + () -> committeeBitsSchema.ofBits(participationIndices)) + .orElse(() -> null); + } else { + committeeBitsSupplier = () -> null; + } + return firstAttestation .getSchema() - .create(aggregateBits, firstAttestation.getData(), BLS.aggregate(signatures)); + .create( + aggregateBits, + firstAttestation.getData(), + BLS.aggregate(signatures), + committeeBitsSupplier); } } diff --git a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/CanonicalBlockResolverStub.java b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/CanonicalBlockResolverStub.java index 941330e6079..2fc03ffb3db 100644 --- a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/CanonicalBlockResolverStub.java +++ b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/CanonicalBlockResolverStub.java @@ -29,31 +29,31 @@ public class CanonicalBlockResolverStub implements CanonicalBlockResolver { private final Map chain = new HashMap<>(); private final DataStructureUtil dataStructureUtil; - private AtomicLong blockAccessCounter = new AtomicLong(); + private final AtomicLong blockAccessCounter = new AtomicLong(); - public CanonicalBlockResolverStub(Spec spec) { - dataStructureUtil = new DataStructureUtil(0, spec); + public CanonicalBlockResolverStub(final Spec spec) { + this.dataStructureUtil = new DataStructureUtil(0, spec); } - public BeaconBlock addBlock(int slot, boolean hasBlobs) { + public BeaconBlock addBlock(final int slot, final boolean hasBlobs) { return addBlock(slot, hasBlobs ? 1 : 0); } - public BeaconBlock addBlock(int slot, int blobCount) { - UInt64 slotU = UInt64.valueOf(slot); - BeaconBlockBody beaconBlockBody = + public BeaconBlock addBlock(final int slot, final int blobCount) { + final UInt64 slotU = UInt64.valueOf(slot); + final BeaconBlockBody beaconBlockBody = dataStructureUtil.randomBeaconBlockBodyWithCommitments(blobCount); - BeaconBlock block = dataStructureUtil.randomBeaconBlock(slotU, beaconBlockBody); + final BeaconBlock block = dataStructureUtil.randomBeaconBlock(slotU, beaconBlockBody); addBlock(block); return block; } - public void addBlock(BeaconBlock block) { + public void addBlock(final BeaconBlock block) { chain.put(block.getSlot(), block); } @Override - public SafeFuture> getBlockAtSlot(UInt64 slot) { + public SafeFuture> getBlockAtSlot(final UInt64 slot) { blockAccessCounter.incrementAndGet(); return SafeFuture.completedFuture(Optional.ofNullable(chain.get(slot))); } diff --git a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/DasCustodyStand.java b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/DasCustodyStand.java index 47791bab081..586db0e871e 100644 --- a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/DasCustodyStand.java +++ b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/DasCustodyStand.java @@ -29,7 +29,7 @@ import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.features.Eip7594; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSidecar; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; @@ -45,7 +45,7 @@ @SuppressWarnings("unused") public class DasCustodyStand { - public static Builder builder(Spec spec) { + public static Builder builder(final Spec spec) { return new Builder().withSpec(spec); } @@ -60,7 +60,6 @@ public static Builder builder(Spec spec) { public final DataColumnSidecarDBStub db; public final DataColumnSidecarDbAccessor dbAccessor; - public final SpecConfigEip7594 config; public final DataColumnSidecarCustodyImpl custody; public final DataStructureUtil dataStructureUtil; @@ -72,16 +71,16 @@ public static Builder builder(Spec spec) { private UInt64 currentSlot = UInt64.ZERO; public DasCustodyStand( - Spec spec, - UInt64 currentSlot, - UInt256 myNodeId, - int totalCustodySubnetCount, - Optional asyncDbDelay, - Optional asyncBlockResolverDelay) { + final Spec spec, + final UInt64 currentSlot, + final UInt256 myNodeId, + final int totalCustodySubnetCount, + final Optional asyncDbDelay, + final Optional asyncBlockResolverDelay) { this.spec = spec; this.myNodeId = myNodeId; this.blockResolver = new CanonicalBlockResolverStub(spec); - CanonicalBlockResolver asyncBlockResolver = + final CanonicalBlockResolver asyncBlockResolver = asyncBlockResolverDelay .map( delay -> @@ -89,10 +88,9 @@ public DasCustodyStand( new DelayedCanonicalBlockResolver( this.blockResolver, stubAsync.getStubAsyncRunner(), delay)) .orElse(this.blockResolver); - this.config = SpecConfigEip7594.required(spec.forMilestone(SpecMilestone.EIP7594).getConfig()); this.minCustodyPeriodSlotCalculator = MinCustodyPeriodSlotCalculator.createFromSpec(spec); this.db = new DataColumnSidecarDBStub(); - DataColumnSidecarDB asyncDb = + final DataColumnSidecarDB asyncDb = asyncDbDelay .map( dbDelay -> @@ -113,55 +111,55 @@ public DasCustodyStand( subscribeToSlotEvents(this.custody); subscribeToFinalizedEvents(this.custody); - DataStructureUtil util = new DataStructureUtil(0, spec); - BLSSignature singleSignature = util.randomSignature(); - BLSPublicKey singlePubKey = util.randomPublicKey(); + final DataStructureUtil util = new DataStructureUtil(0, spec); + final BLSSignature singleSignature = util.randomSignature(); + final BLSPublicKey singlePubKey = util.randomPublicKey(); this.dataStructureUtil = util.withSignatureGenerator(__ -> singleSignature).withPubKeyGenerator(() -> singlePubKey); this.totalCustodySubnetCount = totalCustodySubnetCount; } - public void advanceTimeGradually(Duration delta) { + public void advanceTimeGradually(final Duration delta) { stubAsync.advanceTimeGradually(delta); } - public void advanceTimeGraduallyUntilAllDone(Duration maxAdvancePeriod) { + public void advanceTimeGraduallyUntilAllDone(final Duration maxAdvancePeriod) { stubAsync.advanceTimeGraduallyUntilAllDone(maxAdvancePeriod); } - public SignedBeaconBlock createBlockWithBlobs(int slot) { + public SignedBeaconBlock createBlockWithBlobs(final int slot) { return createBlock(slot, 3); } - public SignedBeaconBlock createBlockWithoutBlobs(int slot) { + public SignedBeaconBlock createBlockWithoutBlobs(final int slot) { return createBlock(slot, 0); } - public SignedBeaconBlock createBlock(int slot, int blobCount) { - UInt64 slotU = UInt64.valueOf(slot); - BeaconBlockBody beaconBlockBody = + public SignedBeaconBlock createBlock(final int slot, final int blobCount) { + final UInt64 slotU = UInt64.valueOf(slot); + final BeaconBlockBody beaconBlockBody = dataStructureUtil.randomBeaconBlockBodyWithCommitments(blobCount); - BeaconBlock block = dataStructureUtil.randomBeaconBlock(slotU, beaconBlockBody); + final BeaconBlock block = dataStructureUtil.randomBeaconBlock(slotU, beaconBlockBody); return dataStructureUtil.signedBlock(block); } - public DataColumnSidecar createSidecar(SignedBeaconBlock block, int column) { + public DataColumnSidecar createSidecar(final SignedBeaconBlock block, final int column) { return dataStructureUtil.randomDataColumnSidecar(block.asHeader(), UInt64.valueOf(column)); } - public boolean hasBlobs(BeaconBlock block) { + public boolean hasBlobs(final BeaconBlock block) { return block .getBody() - .toVersionEip7594() + .toVersionDeneb() .map(b -> !b.getBlobKzgCommitments().isEmpty()) .orElse(false); } - public Collection getCustodyColumnIndexes(UInt64 slot) { - UInt64 epoch = spec.computeEpochAtSlot(slot); + public Collection getCustodyColumnIndexes(final UInt64 slot) { + final UInt64 epoch = spec.computeEpochAtSlot(slot); return spec.atEpoch(epoch) .miscHelpers() - .toVersionEip7594() + .getEip7594Helpers() .map( miscHelpersEip7594 -> miscHelpersEip7594.computeCustodyColumnIndexes(myNodeId, totalCustodySubnetCount)) @@ -172,9 +170,9 @@ public UInt64 getMinCustodySlot() { return minCustodyPeriodSlotCalculator.getMinCustodyPeriodSlot(currentSlot); } - public List createCustodyColumnSidecars(SignedBeaconBlock block) { + public List createCustodyColumnSidecars(final SignedBeaconBlock block) { if (hasBlobs(block.getBeaconBlock().orElseThrow())) { - Collection custodyColumnIndexes = getCustodyColumnIndexes(block.getSlot()); + final Collection custodyColumnIndexes = getCustodyColumnIndexes(block.getSlot()); return custodyColumnIndexes.stream() .map(colIndex -> createSidecar(block, colIndex.intValue())) .toList(); @@ -183,15 +181,15 @@ public List createCustodyColumnSidecars(SignedBeaconBlock blo } } - public void subscribeToSlotEvents(SlotEventsChannel subscriber) { + public void subscribeToSlotEvents(final SlotEventsChannel subscriber) { slotListeners.add(subscriber); } - public void incCurrentSlot(int delta) { + public void incCurrentSlot(final int delta) { setCurrentSlot(getCurrentSlot().intValue() + delta); } - public void setCurrentSlot(int slot) { + public void setCurrentSlot(final int slot) { if (currentSlot.isGreaterThan(slot)) { throw new IllegalArgumentException("New slot " + slot + " < " + currentSlot); } @@ -203,12 +201,12 @@ public UInt64 getCurrentSlot() { return currentSlot; } - public void subscribeToFinalizedEvents(FinalizedCheckpointChannel subscriber) { + public void subscribeToFinalizedEvents(final FinalizedCheckpointChannel subscriber) { finalizedListeners.add(subscriber); } - public void setFinalizedEpoch(int epoch) { - Checkpoint finalizedCheckpoint = new Checkpoint(UInt64.valueOf(epoch), Bytes32.ZERO); + public void setFinalizedEpoch(final int epoch) { + final Checkpoint finalizedCheckpoint = new Checkpoint(UInt64.valueOf(epoch), Bytes32.ZERO); finalizedListeners.forEach(l -> l.onNewFinalizedCheckpoint(finalizedCheckpoint, false)); } @@ -220,32 +218,32 @@ public static class Builder { private Optional asyncDbDelay = Optional.empty(); private Optional asyncBlockResolverDelay = Optional.empty(); - public Builder withSpec(Spec spec) { + public Builder withSpec(final Spec spec) { this.spec = spec; return this; } - public Builder withCurrentSlot(UInt64 currentSlot) { + public Builder withCurrentSlot(final UInt64 currentSlot) { this.currentSlot = currentSlot; return this; } - public Builder withMyNodeId(UInt256 myNodeId) { + public Builder withMyNodeId(final UInt256 myNodeId) { this.myNodeId = myNodeId; return this; } - public Builder withTotalCustodySubnetCount(Integer totalCustodySubnetCount) { + public Builder withTotalCustodySubnetCount(final Integer totalCustodySubnetCount) { this.totalCustodySubnetCount = totalCustodySubnetCount; return this; } - public Builder withAsyncDb(Duration asyncDbDelay) { + public Builder withAsyncDb(final Duration asyncDbDelay) { this.asyncDbDelay = Optional.ofNullable(asyncDbDelay); return this; } - public Builder withAsyncBlockResolver(Duration asyncBlockResolverDelay) { + public Builder withAsyncBlockResolver(final Duration asyncBlockResolverDelay) { this.asyncBlockResolverDelay = Optional.ofNullable(asyncBlockResolverDelay); return this; } @@ -253,8 +251,8 @@ public Builder withAsyncBlockResolver(Duration asyncBlockResolverDelay) { public DasCustodyStand build() { if (totalCustodySubnetCount == null) { checkNotNull(spec); - SpecConfigEip7594 configEip7594 = - SpecConfigEip7594.required(spec.forMilestone(SpecMilestone.EIP7594).getConfig()); + final Eip7594 configEip7594 = + Eip7594.required(spec.forMilestone(SpecMilestone.ELECTRA).getConfig()); totalCustodySubnetCount = configEip7594.getCustodyRequirement(); } return new DasCustodyStand( diff --git a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/DataColumnSidecarDBStub.java b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/DataColumnSidecarDBStub.java index 75d7143664e..9123bb12e5b 100644 --- a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/DataColumnSidecarDBStub.java +++ b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/DataColumnSidecarDBStub.java @@ -35,7 +35,7 @@ public class DataColumnSidecarDBStub implements DataColumnSidecarDB { private final AtomicLong dbWriteCounter = new AtomicLong(); @Override - public SafeFuture setFirstCustodyIncompleteSlot(UInt64 slot) { + public SafeFuture setFirstCustodyIncompleteSlot(final UInt64 slot) { dbWriteCounter.incrementAndGet(); this.firstCustodyIncompleteSlot = Optional.of(slot); return SafeFuture.COMPLETE; @@ -48,7 +48,7 @@ public SafeFuture> getFirstCustodyIncompleteSlot() { } @Override - public SafeFuture setFirstSamplerIncompleteSlot(UInt64 slot) { + public SafeFuture setFirstSamplerIncompleteSlot(final UInt64 slot) { dbWriteCounter.incrementAndGet(); this.firstSamplerIncompleteSlot = Optional.of(slot); return SafeFuture.COMPLETE; @@ -61,22 +61,23 @@ public SafeFuture> getFirstSamplerIncompleteSlot() { } @Override - public SafeFuture addSidecar(DataColumnSidecar sidecar) { + public SafeFuture addSidecar(final DataColumnSidecar sidecar) { dbWriteCounter.incrementAndGet(); - DataColumnSlotAndIdentifier identifier = DataColumnSlotAndIdentifier.fromDataColumn(sidecar); + final DataColumnSlotAndIdentifier identifier = + DataColumnSlotAndIdentifier.fromDataColumn(sidecar); db.put(identifier, sidecar); return SafeFuture.COMPLETE; } @Override public SafeFuture> getSidecar( - DataColumnSlotAndIdentifier identifier) { + final DataColumnSlotAndIdentifier identifier) { dbReadCounter.incrementAndGet(); return SafeFuture.completedFuture(Optional.ofNullable(db.get(identifier))); } @Override - public SafeFuture> getColumnIdentifiers(UInt64 slot) { + public SafeFuture> getColumnIdentifiers(final UInt64 slot) { dbReadCounter.incrementAndGet(); return SafeFuture.completedFuture( db @@ -88,7 +89,7 @@ public SafeFuture> getColumnIdentifiers(UInt64 } @Override - public SafeFuture pruneAllSidecars(UInt64 tillSlot) { + public SafeFuture pruneAllSidecars(final UInt64 tillSlot) { dbWriteCounter.incrementAndGet(); db.headMap(minimalComparableForSlot(tillSlot)).clear(); return SafeFuture.COMPLETE; diff --git a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/DelayedCanonicalBlockResolver.java b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/DelayedCanonicalBlockResolver.java index 727354b0f18..1cabc7283fd 100644 --- a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/DelayedCanonicalBlockResolver.java +++ b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/DelayedCanonicalBlockResolver.java @@ -29,23 +29,23 @@ public class DelayedCanonicalBlockResolver implements CanonicalBlockResolver { private Duration delay; public DelayedCanonicalBlockResolver( - CanonicalBlockResolver delegate, AsyncRunner asyncRunner, Duration delay) { + final CanonicalBlockResolver delegate, final AsyncRunner asyncRunner, final Duration delay) { this.delegate = delegate; this.asyncRunner = asyncRunner; this.delay = delay; } - public void setDelay(Duration delay) { + public void setDelay(final Duration delay) { this.delay = delay; } - private SafeFuture delay(Supplier> futSupplier) { + private SafeFuture delay(final Supplier> futSupplier) { return CancelableFuture.of(asyncRunner.getDelayedFuture(delay)) .thenComposeCancelable(true, true, __ -> futSupplier.get()); } @Override - public SafeFuture> getBlockAtSlot(UInt64 slot) { + public SafeFuture> getBlockAtSlot(final UInt64 slot) { return delay(() -> delegate.getBlockAtSlot(slot)); } } diff --git a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/db/DelayedDasDb.java b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/db/DelayedDasDb.java index e19e4d3e846..2e491ebd932 100644 --- a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/db/DelayedDasDb.java +++ b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/db/DelayedDasDb.java @@ -28,17 +28,18 @@ public class DelayedDasDb implements DataColumnSidecarDB { private final AsyncRunner asyncRunner; private Duration delay; - public DelayedDasDb(DataColumnSidecarDB delegate, AsyncRunner asyncRunner, Duration delay) { + public DelayedDasDb( + final DataColumnSidecarDB delegate, final AsyncRunner asyncRunner, final Duration delay) { this.delegate = delegate; this.asyncRunner = asyncRunner; this.delay = delay; } - public void setDelay(Duration delay) { + public void setDelay(final Duration delay) { this.delay = delay; } - private SafeFuture delay(Supplier> futSupplier) { + private SafeFuture delay(final Supplier> futSupplier) { return asyncRunner.getDelayedFuture(delay).thenCompose(__ -> futSupplier.get()); } @@ -54,32 +55,32 @@ public SafeFuture> getFirstSamplerIncompleteSlot() { @Override public SafeFuture> getSidecar( - DataColumnSlotAndIdentifier identifier) { + final DataColumnSlotAndIdentifier identifier) { return delay(() -> delegate.getSidecar(identifier)); } @Override - public SafeFuture> getColumnIdentifiers(UInt64 slot) { + public SafeFuture> getColumnIdentifiers(final UInt64 slot) { return delay(() -> delegate.getColumnIdentifiers(slot)); } @Override - public SafeFuture setFirstCustodyIncompleteSlot(UInt64 slot) { + public SafeFuture setFirstCustodyIncompleteSlot(final UInt64 slot) { return delay(() -> delegate.setFirstCustodyIncompleteSlot(slot)); } @Override - public SafeFuture setFirstSamplerIncompleteSlot(UInt64 slot) { + public SafeFuture setFirstSamplerIncompleteSlot(final UInt64 slot) { return delay(() -> delegate.setFirstSamplerIncompleteSlot(slot)); } @Override - public SafeFuture addSidecar(DataColumnSidecar sidecar) { + public SafeFuture addSidecar(final DataColumnSidecar sidecar) { return delay(() -> delegate.addSidecar(sidecar)); } @Override - public SafeFuture pruneAllSidecars(UInt64 tillSlot) { + public SafeFuture pruneAllSidecars(final UInt64 tillSlot) { return delay(() -> delegate.pruneAllSidecars(tillSlot)); } } diff --git a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DasPeerCustodyCountSupplierStub.java b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DasPeerCustodyCountSupplierStub.java index 5eb43b12fd1..1cdc50841fa 100644 --- a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DasPeerCustodyCountSupplierStub.java +++ b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DasPeerCustodyCountSupplierStub.java @@ -21,16 +21,16 @@ public class DasPeerCustodyCountSupplierStub implements DasPeerCustodyCountSuppl private final int defaultCount; private final Map customCounts = new HashMap<>(); - public DasPeerCustodyCountSupplierStub(int defaultCount) { + public DasPeerCustodyCountSupplierStub(final int defaultCount) { this.defaultCount = defaultCount; } @Override - public int getCustodyCountForPeer(UInt256 nodeId) { + public int getCustodyCountForPeer(final UInt256 nodeId) { return customCounts.getOrDefault(nodeId, defaultCount); } - public void setCustomCount(UInt256 nodeId, int count) { + public void setCustomCount(final UInt256 nodeId, final int count) { customCounts.put(nodeId, count); } } diff --git a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DataColumnPeerManagerStub.java b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DataColumnPeerManagerStub.java index c1924987dc4..abd889b1f7a 100644 --- a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DataColumnPeerManagerStub.java +++ b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DataColumnPeerManagerStub.java @@ -25,12 +25,12 @@ public class DataColumnPeerManagerStub implements DataColumnPeerManager { private final List listeners = new ArrayList<>(); @Override - public void addPeerListener(PeerListener listener) { + public void addPeerListener(final PeerListener listener) { listeners.add(listener); } @Override - public void banNode(UInt256 node) { + public void banNode(final UInt256 node) { bannedNodes.add(node); } @@ -38,11 +38,11 @@ public Set getBannedNodes() { return bannedNodes; } - public void addNode(UInt256 nodeId) { + public void addNode(final UInt256 nodeId) { listeners.forEach(l -> l.peerConnected(nodeId)); } - public void removeNode(UInt256 nodeId) { + public void removeNode(final UInt256 nodeId) { listeners.forEach(l -> l.peerDisconnected(nodeId)); } } diff --git a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DataColumnPeerSearcherStub.java b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DataColumnPeerSearcherStub.java index 3597ea85069..f1cd427c1bf 100644 --- a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DataColumnPeerSearcherStub.java +++ b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DataColumnPeerSearcherStub.java @@ -24,7 +24,7 @@ public static class PeerSearchRequestStub implements PeerSearchRequest { private final UInt64 columnIndex; private boolean disposed; - public PeerSearchRequestStub(UInt64 slot, UInt64 columnIndex) { + public PeerSearchRequestStub(final UInt64 slot, final UInt64 columnIndex) { this.slot = slot; this.columnIndex = columnIndex; } @@ -50,7 +50,7 @@ public boolean isDisposed() { private final List requests = new ArrayList<>(); @Override - public PeerSearchRequest requestPeers(UInt64 slot, UInt64 columnIndex) { + public PeerSearchRequest requestPeers(final UInt64 slot, final UInt64 columnIndex) { PeerSearchRequestStub request = new PeerSearchRequestStub(slot, columnIndex); requests.add(request); return request; diff --git a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DataColumnSidecarRetrieverStub.java b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DataColumnSidecarRetrieverStub.java index b42a2619bc5..20f976c9643 100644 --- a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DataColumnSidecarRetrieverStub.java +++ b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DataColumnSidecarRetrieverStub.java @@ -29,8 +29,8 @@ public record RetrieveRequest( public List requests = new ArrayList<>(); private final Map readySidecars = new HashMap<>(); - public void addReadyColumnSidecar(DataColumnSidecar sidecar) { - DataColumnSlotAndIdentifier colId = DataColumnSlotAndIdentifier.fromDataColumn(sidecar); + public void addReadyColumnSidecar(final DataColumnSidecar sidecar) { + final DataColumnSlotAndIdentifier colId = DataColumnSlotAndIdentifier.fromDataColumn(sidecar); readySidecars.put(colId, sidecar); requests.stream() .filter(req -> req.columnId.equals(colId)) @@ -38,10 +38,10 @@ public void addReadyColumnSidecar(DataColumnSidecar sidecar) { } @Override - public SafeFuture retrieve(DataColumnSlotAndIdentifier columnId) { - RetrieveRequest request = new RetrieveRequest(columnId, new SafeFuture<>()); + public SafeFuture retrieve(final DataColumnSlotAndIdentifier columnId) { + final RetrieveRequest request = new RetrieveRequest(columnId, new SafeFuture<>()); requests.add(request); - DataColumnSidecar maybeSidecar = readySidecars.get(columnId); + final DataColumnSidecar maybeSidecar = readySidecars.get(columnId); if (maybeSidecar != null) { request.promise.complete(maybeSidecar); } diff --git a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DelayedDataColumnSidecarRetriever.java b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DelayedDataColumnSidecarRetriever.java index 5f0bb03e51c..ac5f50751c9 100644 --- a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DelayedDataColumnSidecarRetriever.java +++ b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/DelayedDataColumnSidecarRetriever.java @@ -27,23 +27,25 @@ public class DelayedDataColumnSidecarRetriever implements DataColumnSidecarRetri private Duration delay; public DelayedDataColumnSidecarRetriever( - DataColumnSidecarRetriever delegate, AsyncRunner asyncRunner, Duration delay) { + final DataColumnSidecarRetriever delegate, + final AsyncRunner asyncRunner, + final Duration delay) { this.delegate = delegate; this.asyncRunner = asyncRunner; this.delay = delay; } - public void setDelay(Duration delay) { + public void setDelay(final Duration delay) { this.delay = delay; } - private SafeFuture delay(Supplier> futSupplier) { + private SafeFuture delay(final Supplier> futSupplier) { return CancelableFuture.of(asyncRunner.getDelayedFuture(delay)) .thenComposeCancelable(true, true, __ -> futSupplier.get()); } @Override - public SafeFuture retrieve(DataColumnSlotAndIdentifier columnId) { + public SafeFuture retrieve(final DataColumnSlotAndIdentifier columnId) { return delay(() -> delegate.retrieve(columnId)); } } diff --git a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/TestPeer.java b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/TestPeer.java index d4a58eeed89..1bf07486c64 100644 --- a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/TestPeer.java +++ b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/TestPeer.java @@ -37,13 +37,13 @@ public record Request( private final List requests = new ArrayList<>(); private int currentRequestLimit = 1000; - public TestPeer(AsyncRunner asyncRunner, UInt256 nodeId, Duration latency) { + public TestPeer(final AsyncRunner asyncRunner, final UInt256 nodeId, final Duration latency) { this.asyncRunner = asyncRunner; this.nodeId = nodeId; this.latency = latency; } - public void addSidecar(DataColumnSidecar sidecar) { + public void addSidecar(final DataColumnSidecar sidecar) { availableSidecars.put(DataColumnIdentifier.createFromSidecar(sidecar), sidecar); } @@ -60,9 +60,10 @@ public void onDisconnect() { new DataColumnReqResp.DasPeerDisconnectedException())); } - public SafeFuture requestSidecar(DataColumnIdentifier dataColumnIdentifier) { - SafeFuture promise = new SafeFuture<>(); - Request request = new Request(dataColumnIdentifier, promise); + public SafeFuture requestSidecar( + final DataColumnIdentifier dataColumnIdentifier) { + final SafeFuture promise = new SafeFuture<>(); + final Request request = new Request(dataColumnIdentifier, promise); requests.add(request); asyncRunner .runAfterDelay( @@ -90,7 +91,7 @@ public int getCurrentRequestLimit() { return currentRequestLimit; } - public TestPeer currentRequestLimit(int currentRequestLimit) { + public TestPeer currentRequestLimit(final int currentRequestLimit) { this.currentRequestLimit = currentRequestLimit; return this; } diff --git a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/TestPeerManager.java b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/TestPeerManager.java index eac9a0940b5..c76a45ef910 100644 --- a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/TestPeerManager.java +++ b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/retriever/TestPeerManager.java @@ -26,12 +26,12 @@ public class TestPeerManager implements DataColumnPeerManager, DataColumnReqResp private final Map connectedPeers = new HashMap<>(); - public void connectPeer(TestPeer peer) { + public void connectPeer(final TestPeer peer) { dataColumnPeerManagerStub.addNode(peer.getNodeId()); connectedPeers.put(peer.getNodeId(), peer); } - public void disconnectPeer(TestPeer peer) { + public void disconnectPeer(final TestPeer peer) { dataColumnPeerManagerStub.removeNode(peer.getNodeId()); peer.onDisconnect(); connectedPeers.remove(peer.getNodeId()); @@ -39,7 +39,7 @@ public void disconnectPeer(TestPeer peer) { @Override public SafeFuture requestDataColumnSidecar( - UInt256 nodeId, DataColumnIdentifier columnIdentifier) { + final UInt256 nodeId, final DataColumnIdentifier columnIdentifier) { TestPeer peer = connectedPeers.get(nodeId); if (peer == null) { return SafeFuture.failedFuture(new DasPeerDisconnectedException()); @@ -52,7 +52,7 @@ public SafeFuture requestDataColumnSidecar( public void flush() {} @Override - public int getCurrentRequestLimit(UInt256 nodeId) { + public int getCurrentRequestLimit(final UInt256 nodeId) { TestPeer peer = connectedPeers.get(nodeId); if (peer == null) { return 0; @@ -62,12 +62,12 @@ public int getCurrentRequestLimit(UInt256 nodeId) { } @Override - public void addPeerListener(PeerListener listener) { + public void addPeerListener(final PeerListener listener) { dataColumnPeerManagerStub.addPeerListener(listener); } @Override - public void banNode(UInt256 node) { + public void banNode(final UInt256 node) { dataColumnPeerManagerStub.banNode(node); } } diff --git a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/util/CancelableFuture.java b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/util/CancelableFuture.java index 0a7fbedfa43..a8804597eb7 100644 --- a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/util/CancelableFuture.java +++ b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/util/CancelableFuture.java @@ -38,7 +38,7 @@ public CancelableFuture newIncompleteFuture() { return new CancelableFuture<>(); } - private void propagateCancelToThis(SafeFuture downstreamFuture) { + private void propagateCancelToThis(final SafeFuture downstreamFuture) { downstreamFuture.finish( __ -> { if (downstreamFuture.isCancelled()) { diff --git a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/util/StubAsync.java b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/util/StubAsync.java index 5ef9d1a28c2..137cd99aa9f 100644 --- a/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/util/StubAsync.java +++ b/ethereum/statetransition/src/testFixtures/java/tech/pegasys/teku/statetransition/datacolumns/util/StubAsync.java @@ -28,14 +28,14 @@ public AsyncRunner getStubAsyncRunner() { return stubAsyncRunner; } - public void advanceTimeGradually(Duration delta) { + public void advanceTimeGradually(final Duration delta) { for (int i = 0; i < delta.toMillis(); i++) { stubTimeProvider.advanceTimeBy(ofMillis(1)); stubAsyncRunner.executeDueActionsRepeatedly(); } } - public void advanceTimeGraduallyUntilAllDone(Duration maxAdvancePeriod) { + public void advanceTimeGraduallyUntilAllDone(final Duration maxAdvancePeriod) { for (int i = 0; i < maxAdvancePeriod.toMillis(); i++) { if (!stubAsyncRunner.hasDelayedActions()) { return; diff --git a/ethereum/weaksubjectivity/src/main/java/tech/pegasys/teku/weaksubjectivity/WeakSubjectivityValidator.java b/ethereum/weaksubjectivity/src/main/java/tech/pegasys/teku/weaksubjectivity/WeakSubjectivityValidator.java index 83e566abc6d..93387834aab 100644 --- a/ethereum/weaksubjectivity/src/main/java/tech/pegasys/teku/weaksubjectivity/WeakSubjectivityValidator.java +++ b/ethereum/weaksubjectivity/src/main/java/tech/pegasys/teku/weaksubjectivity/WeakSubjectivityValidator.java @@ -48,8 +48,8 @@ public class WeakSubjectivityValidator { WeakSubjectivityValidator( final WeakSubjectivityConfig config, - WeakSubjectivityCalculator calculator, - WeakSubjectivityViolationPolicy violationPolicy) { + final WeakSubjectivityCalculator calculator, + final WeakSubjectivityViolationPolicy violationPolicy) { this.spec = config.getSpec(); this.calculator = calculator; this.violationPolicy = violationPolicy; @@ -93,7 +93,7 @@ public Optional getWSCheckpoint() { /** Check whether the chain matches any configured weak subjectivity checkpoint or state */ public SafeFuture validateChainIsConsistentWithWSCheckpoint( - CombinedChainDataClient chainData) { + final CombinedChainDataClient chainData) { if (config.getWeakSubjectivityCheckpoint().isEmpty()) { // Nothing to validate against return SafeFuture.COMPLETE; @@ -175,7 +175,7 @@ public void validateLatestFinalizedCheckpoint( } public boolean isBlockValid( - final SignedBeaconBlock block, ReadOnlyForkChoiceStrategy forkChoiceStrategy) { + final SignedBeaconBlock block, final ReadOnlyForkChoiceStrategy forkChoiceStrategy) { if (config.getWeakSubjectivityCheckpoint().isEmpty()) { return true; } @@ -208,7 +208,7 @@ public boolean isBlockValid( * @param message An error message * @param error The error encountered */ - public void handleValidationFailure(final String message, Throwable error) { + public void handleValidationFailure(final String message, final Throwable error) { violationPolicy.onFailedToPerformValidation(message, error); } @@ -257,7 +257,7 @@ Optional getSuppressWSPeriodChecksUntilEpoch(final UInt64 currentSlot) { return suppressWSPeriodErrorsUntilEpoch; } - public boolean isWithinWSPeriod(CheckpointState checkpointState, UInt64 currentSlot) { + public boolean isWithinWSPeriod(final CheckpointState checkpointState, final UInt64 currentSlot) { return calculator.isWithinWeakSubjectivityPeriod(checkpointState, currentSlot); } diff --git a/ethereum/weaksubjectivity/src/main/java/tech/pegasys/teku/weaksubjectivity/config/WeakSubjectivityConfig.java b/ethereum/weaksubjectivity/src/main/java/tech/pegasys/teku/weaksubjectivity/config/WeakSubjectivityConfig.java index 8b23014a26d..9aae7f90eeb 100644 --- a/ethereum/weaksubjectivity/src/main/java/tech/pegasys/teku/weaksubjectivity/config/WeakSubjectivityConfig.java +++ b/ethereum/weaksubjectivity/src/main/java/tech/pegasys/teku/weaksubjectivity/config/WeakSubjectivityConfig.java @@ -32,8 +32,8 @@ public class WeakSubjectivityConfig { private final Optional suppressWSPeriodChecksUntilEpoch; private WeakSubjectivityConfig( - Spec spec, - UInt64 safetyDecay, + final Spec spec, + final UInt64 safetyDecay, final Optional weakSubjectivityCheckpoint, final Optional suppressWSPeriodChecksUntilEpoch) { this.spec = spec; @@ -135,11 +135,12 @@ public Builder specProvider(final Spec spec) { return this; } - public Builder weakSubjectivityCheckpoint(Checkpoint weakSubjectivityCheckpoint) { + public Builder weakSubjectivityCheckpoint(final Checkpoint weakSubjectivityCheckpoint) { return weakSubjectivityCheckpoint(Optional.of(weakSubjectivityCheckpoint)); } - public Builder weakSubjectivityCheckpoint(Optional weakSubjectivityCheckpoint) { + public Builder weakSubjectivityCheckpoint( + final Optional weakSubjectivityCheckpoint) { checkNotNull(weakSubjectivityCheckpoint); this.weakSubjectivityCheckpoint = weakSubjectivityCheckpoint; return this; @@ -157,7 +158,7 @@ public Builder suppressWSPeriodChecksUntilEpoch( return this; } - public Builder safetyDecay(UInt64 safetyDecay) { + public Builder safetyDecay(final UInt64 safetyDecay) { this.safetyDecay = safetyDecay; return this; } diff --git a/ethereum/weaksubjectivity/src/main/java/tech/pegasys/teku/weaksubjectivity/policies/ExitingWeakSubjectivityViolationPolicy.java b/ethereum/weaksubjectivity/src/main/java/tech/pegasys/teku/weaksubjectivity/policies/ExitingWeakSubjectivityViolationPolicy.java index fbd9b157ee4..8aa82b956c8 100644 --- a/ethereum/weaksubjectivity/src/main/java/tech/pegasys/teku/weaksubjectivity/policies/ExitingWeakSubjectivityViolationPolicy.java +++ b/ethereum/weaksubjectivity/src/main/java/tech/pegasys/teku/weaksubjectivity/policies/ExitingWeakSubjectivityViolationPolicy.java @@ -24,13 +24,15 @@ class ExitingWeakSubjectivityViolationPolicy implements WeakSubjectivityViolatio @Override public void onFinalizedCheckpointOutsideOfWeakSubjectivityPeriod( - UInt64 currentEpoch, CheckpointState latestFinalizedCheckpoint, final UInt64 wsPeriod) { + final UInt64 currentEpoch, + final CheckpointState latestFinalizedCheckpoint, + final UInt64 wsPeriod) { exitClient(); } @Override public void onChainInconsistentWithWeakSubjectivityCheckpoint( - Checkpoint wsCheckpoint, Bytes32 blockRoot, final UInt64 blockSlot) { + final Checkpoint wsCheckpoint, final Bytes32 blockRoot, final UInt64 blockSlot) { exitClient(); } diff --git a/ethereum/weaksubjectivity/src/main/java/tech/pegasys/teku/weaksubjectivity/policies/LoggingWeakSubjectivityViolationPolicy.java b/ethereum/weaksubjectivity/src/main/java/tech/pegasys/teku/weaksubjectivity/policies/LoggingWeakSubjectivityViolationPolicy.java index 88a52813f4a..24b0144a94d 100644 --- a/ethereum/weaksubjectivity/src/main/java/tech/pegasys/teku/weaksubjectivity/policies/LoggingWeakSubjectivityViolationPolicy.java +++ b/ethereum/weaksubjectivity/src/main/java/tech/pegasys/teku/weaksubjectivity/policies/LoggingWeakSubjectivityViolationPolicy.java @@ -29,7 +29,7 @@ class LoggingWeakSubjectivityViolationPolicy implements WeakSubjectivityViolatio private final WeakSubjectivityLogger wsLogger; public LoggingWeakSubjectivityViolationPolicy( - final WeakSubjectivityLogger wsLogger, Level level) { + final WeakSubjectivityLogger wsLogger, final Level level) { this.level = level; this.wsLogger = wsLogger; } @@ -51,7 +51,7 @@ public void onFinalizedCheckpointOutsideOfWeakSubjectivityPeriod( @Override public void onChainInconsistentWithWeakSubjectivityCheckpoint( - Checkpoint wsCheckpoint, Bytes32 blockRoot, final UInt64 blockSlot) { + final Checkpoint wsCheckpoint, final Bytes32 blockRoot, final UInt64 blockSlot) { wsLogger.chainInconsistentWithWeakSubjectivityCheckpoint( level, blockRoot, blockSlot, wsCheckpoint.getRoot(), wsCheckpoint.getEpoch()); } diff --git a/ethereum/weaksubjectivity/src/test/java/tech/pegasys/teku/weaksubjectivity/WeakSubjectivityValidatorTest.java b/ethereum/weaksubjectivity/src/test/java/tech/pegasys/teku/weaksubjectivity/WeakSubjectivityValidatorTest.java index 7ef07a5f424..95a4537e65d 100644 --- a/ethereum/weaksubjectivity/src/test/java/tech/pegasys/teku/weaksubjectivity/WeakSubjectivityValidatorTest.java +++ b/ethereum/weaksubjectivity/src/test/java/tech/pegasys/teku/weaksubjectivity/WeakSubjectivityValidatorTest.java @@ -559,11 +559,11 @@ private SignedBeaconBlock mockBlock( return block; } - private void mockForkChoice(SignedBeaconBlock... blocks) { + private void mockForkChoice(final SignedBeaconBlock... blocks) { mockForkChoice(Arrays.asList(blocks)); } - private void mockForkChoice(List blocks) { + private void mockForkChoice(final List blocks) { for (SignedBeaconBlock block : blocks) { when(forkChoiceStrategy.blockSlot(block.getRoot())).thenReturn(Optional.of(block.getSlot())); when(forkChoiceStrategy.blockParentRoot(block.getRoot())) diff --git a/ethereum/weaksubjectivity/src/test/java/tech/pegasys/teku/weaksubjectivity/config/WeakSubjectivityConfigTest.java b/ethereum/weaksubjectivity/src/test/java/tech/pegasys/teku/weaksubjectivity/config/WeakSubjectivityConfigTest.java index 00d7d4287fa..7c0c5fc1422 100644 --- a/ethereum/weaksubjectivity/src/test/java/tech/pegasys/teku/weaksubjectivity/config/WeakSubjectivityConfigTest.java +++ b/ethereum/weaksubjectivity/src/test/java/tech/pegasys/teku/weaksubjectivity/config/WeakSubjectivityConfigTest.java @@ -66,7 +66,7 @@ public void updated_shouldCloneAllProperties() { WeakSubjectivityConfig configB = configA.updated((__) -> {}); assertThat(configA).isEqualTo(configB); - assertThat(configA).isEqualToComparingFieldByField(configB); + assertThat(configA).isEqualTo(configB); } @Test diff --git a/fork-choice-tests/build.gradle b/fork-choice-tests/build.gradle index 0f948ea186c..0225812d304 100644 --- a/fork-choice-tests/build.gradle +++ b/fork-choice-tests/build.gradle @@ -18,6 +18,6 @@ dependencies { integrationTestImplementation 'com.fasterxml.jackson.core:jackson-databind' integrationTestImplementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-yaml' - integrationTestImplementation 'org.apache.tuweni:tuweni-bytes' - integrationTestImplementation 'org.apache.tuweni:tuweni-junit' + integrationTestImplementation 'io.tmio:tuweni-bytes' + integrationTestImplementation 'io.tmio:tuweni-junit' } diff --git a/fork-choice-tests/src/integration-test/java/tech/pegasys/teku/forkChoiceTests/ForkChoiceIntegrationTest.java b/fork-choice-tests/src/integration-test/java/tech/pegasys/teku/forkChoiceTests/ForkChoiceIntegrationTest.java index f81131cea02..ec9cb09f9ce 100644 --- a/fork-choice-tests/src/integration-test/java/tech/pegasys/teku/forkChoiceTests/ForkChoiceIntegrationTest.java +++ b/fork-choice-tests/src/integration-test/java/tech/pegasys/teku/forkChoiceTests/ForkChoiceIntegrationTest.java @@ -72,7 +72,7 @@ public static Stream loadForkChoiceTests() { } @SuppressWarnings("unchecked") - private static Optional parseForkChoiceFile(Path path) { + private static Optional parseForkChoiceFile(final Path path) { final File file = path.toFile(); final SchemaDefinitions schemaDefinitions = SPEC.getGenesisSchemaDefinitions(); final BeaconStateSchema beaconStateSchema = schemaDefinitions.getBeaconStateSchema(); @@ -97,7 +97,7 @@ private static Optional parseForkChoiceFile(Path path) { } } - private static List findForkChoiceTestsByPath(Path path) { + private static List findForkChoiceTestsByPath(final Path path) { try (Stream paths = Files.walk(path)) { return paths .filter(p -> Files.isRegularFile(p) && !p.getParent().endsWith("cache")) @@ -109,7 +109,8 @@ private static List findForkChoiceTestsByPath(Path path) { } } - private static Object extractTestStep(File file, Map stepDescription) { + private static Object extractTestStep( + final File file, final Map stepDescription) { ForkChoiceTestStep stepKind = getStepKind(stepDescription); Object value = stepDescription.get(stepKind.name()); @@ -172,7 +173,10 @@ private static T resolvePart( @ParameterizedTest(name = "{index}.{2} fork choice test") @MethodSource("loadForkChoiceTests") void runForkChoiceTests( - BeaconState genesis, List steps, String testName, boolean protoArrayFC) { + final BeaconState genesis, + final List steps, + final String testName, + final boolean protoArrayFC) { RecentChainData storageClient = MemoryOnlyRecentChainData.create(SPEC); storageClient.initializeFromGenesis(genesis, UInt64.ZERO); @@ -276,13 +280,13 @@ void runForkChoiceTests( } } - private boolean processAttestation(ForkChoice fc, Attestation step) { + private boolean processAttestation(final ForkChoice fc, final Attestation step) { AttestationProcessingResult attestationProcessingResult = fc.onAttestation(ValidatableAttestation.from(SPEC, step)).join(); return attestationProcessingResult.isSuccessful(); } - private boolean processBlock(ForkChoice fc, SignedBeaconBlock block) { + private boolean processBlock(final ForkChoice fc, final SignedBeaconBlock block) { BlockImportResult blockImportResult = fc.onBlock( block, diff --git a/fuzz/build.gradle b/fuzz/build.gradle index 4c3b69b3989..66e809ff2e8 100644 --- a/fuzz/build.gradle +++ b/fuzz/build.gradle @@ -5,7 +5,7 @@ dependencies { implementation project(':infrastructure:bls') implementation project(':infrastructure:ssz') - implementation 'org.apache.tuweni:tuweni-bytes' + implementation 'io.tmio:tuweni-bytes' implementation 'it.unimi.dsi:fastutil' testImplementation 'org.xerial.snappy:snappy-java' diff --git a/fuzz/src/main/java/tech/pegasys/teku/fuzz/FuzzUtil.java b/fuzz/src/main/java/tech/pegasys/teku/fuzz/FuzzUtil.java index 077fedf3e39..9aab8d8ef23 100644 --- a/fuzz/src/main/java/tech/pegasys/teku/fuzz/FuzzUtil.java +++ b/fuzz/src/main/java/tech/pegasys/teku/fuzz/FuzzUtil.java @@ -28,10 +28,13 @@ import tech.pegasys.teku.fuzz.input.BlockFuzzInput; import tech.pegasys.teku.fuzz.input.BlockHeaderFuzzInput; import tech.pegasys.teku.fuzz.input.BlsToExecutionChangeFuzzInput; +import tech.pegasys.teku.fuzz.input.ConsolidationRequestFuzzInput; import tech.pegasys.teku.fuzz.input.DepositFuzzInput; +import tech.pegasys.teku.fuzz.input.DepositRequestFuzzInput; import tech.pegasys.teku.fuzz.input.ProposerSlashingFuzzInput; import tech.pegasys.teku.fuzz.input.SyncAggregateFuzzInput; import tech.pegasys.teku.fuzz.input.VoluntaryExitFuzzInput; +import tech.pegasys.teku.fuzz.input.WithdrawalRequestFuzzInput; import tech.pegasys.teku.infrastructure.ssz.SszData; import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.ssz.schema.SszSchema; @@ -40,9 +43,13 @@ import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.SpecVersion; import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.config.SpecConfigElectra; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.SyncAggregate; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.capella.BeaconBlockBodyCapella; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.capella.BeaconBlockBodySchemaCapella; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra.BeaconBlockBodyElectra; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra.BeaconBlockBodySchemaElectra; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequest; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; import tech.pegasys.teku.spec.datastructures.operations.Deposit; @@ -52,14 +59,20 @@ import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.logic.common.statetransition.exceptions.BlockProcessingException; import tech.pegasys.teku.spec.logic.common.statetransition.exceptions.StateTransitionException; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.BeaconStateAccessorsElectra; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.BeaconStateMutatorsElectra; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.MiscHelpersElectra; +import tech.pegasys.teku.spec.logic.versions.electra.helpers.PredicatesElectra; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; public class FuzzUtil { // NOTE: alternatively could also have these all in separate classes, which implement a // "FuzzHarness" interface private final Spec spec; - private final BeaconBlockBodySchemaCapella beaconBlockBodySchema; + private final BeaconBlockBodySchemaElectra beaconBlockBodySchema; private final SpecVersion specVersion; + private final BeaconStateMutatorsElectra stateMutatorsElectra; // Size of ValidatorIndex returned by shuffle private static final int OUTPUT_INDEX_BYTES = Long.BYTES; @@ -70,14 +83,27 @@ public class FuzzUtil { public FuzzUtil(final boolean useMainnetConfig, final boolean disableBls) { spec = useMainnetConfig - ? TestSpecFactory.createMainnetCapella() - : TestSpecFactory.createMinimalCapella(); - specVersion = spec.forMilestone(SpecMilestone.CAPELLA); + ? TestSpecFactory.createMainnetElectra() + : TestSpecFactory.createMinimalElectra(); + specVersion = spec.forMilestone(SpecMilestone.ELECTRA); beaconBlockBodySchema = - (BeaconBlockBodySchemaCapella) + (BeaconBlockBodySchemaElectra) specVersion.getSchemaDefinitions().getBeaconBlockBodySchema(); initialize(disableBls); this.signatureVerifier = disableBls ? BLSSignatureVerifier.NO_OP : BLSSignatureVerifier.SIMPLE; + + final PredicatesElectra predicates = new PredicatesElectra(spec.getGenesisSpecConfig()); + final SchemaDefinitionsElectra schemaDefinitionsElectra = + SchemaDefinitionsElectra.required(spec.getGenesisSchemaDefinitions()); + final SpecConfigElectra specConfig = + spec.getGenesisSpecConfig().toVersionElectra().orElseThrow(); + final MiscHelpersElectra miscHelpersElectra = + new MiscHelpersElectra(specConfig, predicates, schemaDefinitionsElectra); + final BeaconStateAccessorsElectra stateAccessorsElectra = + new BeaconStateAccessorsElectra(specConfig, predicates, miscHelpersElectra); + stateMutatorsElectra = + new BeaconStateMutatorsElectra( + specConfig, miscHelpersElectra, stateAccessorsElectra, schemaDefinitionsElectra); } public static void initialize(final boolean disableBls) { @@ -146,7 +172,6 @@ public Optional fuzzBlock(final byte[] input) { Bytes output = postState.sszSerialize(); return Optional.of(output.toArrayUnsafe()); } catch (StateTransitionException e) { - e.printStackTrace(); // "expected error" return Optional.empty(); } @@ -293,7 +318,7 @@ public Optional fuzzExecutionPayload(final byte[] input) { BeaconBlockBodyFuzzInput structuredPayloadInput = deserialize(input, BeaconBlockBodyFuzzInput.createSchema(specVersion)); - final BeaconBlockBodyCapella beaconBlockBody = structuredPayloadInput.getBeaconBlockBody(); + final BeaconBlockBodyElectra beaconBlockBody = structuredPayloadInput.getBeaconBlockBody(); try { BeaconState postState = structuredPayloadInput @@ -334,7 +359,86 @@ public Optional fuzzBlsToExecutionChange(final byte[] input) { } } - private T deserialize(byte[] data, SszSchema type) { + public Optional fuzzDepositRequest(final byte[] input) { + DepositRequestFuzzInput structuredInput = + deserialize(input, DepositRequestFuzzInput.createSchema(specVersion)); + SszList depositRequests = + beaconBlockBodySchema + .getExecutionRequestsSchema() + .getDepositRequestsSchema() + .of(structuredInput.getDepositRequest()); + + try { + BeaconState postState = + structuredInput + .getState() + .updated( + state -> + spec.getBlockProcessor(state.getSlot()) + .processDepositRequests(state, depositRequests.asList())); + Bytes output = postState.sszSerialize(); + return Optional.of(output.toArrayUnsafe()); + } catch (BlockProcessingException e) { + // "expected error" + return Optional.empty(); + } + } + + public Optional fuzzWithdrawalRequest(final byte[] input) { + WithdrawalRequestFuzzInput structuredInput = + deserialize(input, WithdrawalRequestFuzzInput.createSchema(specVersion)); + SszList withdrawalRequests = + beaconBlockBodySchema + .getExecutionRequestsSchema() + .getWithdrawalRequestsSchema() + .of(structuredInput.getWithdrawalRequest()); + + try { + BeaconState postState = + structuredInput + .getState() + .updated( + state -> + spec.getBlockProcessor(state.getSlot()) + .processWithdrawalRequests( + state, + withdrawalRequests.asList(), + stateMutatorsElectra.createValidatorExitContextSupplier( + structuredInput.getState()))); + Bytes output = postState.sszSerialize(); + return Optional.of(output.toArrayUnsafe()); + } catch (BlockProcessingException e) { + // "expected error" + return Optional.empty(); + } + } + + public Optional fuzzConsolidationRequest(final byte[] input) { + ConsolidationRequestFuzzInput structuredInput = + deserialize(input, ConsolidationRequestFuzzInput.createSchema(specVersion)); + SszList consolidationRequests = + beaconBlockBodySchema + .getExecutionRequestsSchema() + .getConsolidationRequestsSchema() + .of(structuredInput.getConsolidationRequest()); + + try { + BeaconState postState = + structuredInput + .getState() + .updated( + state -> + spec.getBlockProcessor(state.getSlot()) + .processConsolidationRequests(state, consolidationRequests.asList())); + Bytes output = postState.sszSerialize(); + return Optional.of(output.toArrayUnsafe()); + } catch (BlockProcessingException e) { + // "expected error" + return Optional.empty(); + } + } + + private T deserialize(final byte[] data, final SszSchema type) { // allow exception to propagate on failure - indicates a preprocessing or deserializing error T structuredInput = type.sszDeserialize(Bytes.wrap(data)); if (structuredInput == null) { diff --git a/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/AttestationFuzzInput.java b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/AttestationFuzzInput.java index 407c2a86262..3d4e3d45dbd 100644 --- a/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/AttestationFuzzInput.java +++ b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/AttestationFuzzInput.java @@ -29,12 +29,13 @@ public static ContainerSchema2 c final SpecVersion spec) { return ContainerSchema2.create( SszSchema.as(BeaconState.class, spec.getSchemaDefinitions().getBeaconStateSchema()), - spec.getSchemaDefinitions().getAttestationSchema(), + spec.getSchemaDefinitions().getAttestationSchema().castTypeToAttestationSchema(), AttestationFuzzInput::new); } private AttestationFuzzInput( - ContainerSchema2 type, TreeNode backingNode) { + final ContainerSchema2 type, + final TreeNode backingNode) { super(type, backingNode); } diff --git a/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/AttesterSlashingFuzzInput.java b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/AttesterSlashingFuzzInput.java index 9cbd3504b79..88d52a86f01 100644 --- a/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/AttesterSlashingFuzzInput.java +++ b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/AttesterSlashingFuzzInput.java @@ -34,8 +34,8 @@ public class AttesterSlashingFuzzInput } private AttesterSlashingFuzzInput( - ContainerSchema2 type, - TreeNode backingNode) { + final ContainerSchema2 type, + final TreeNode backingNode) { super(type, backingNode); } diff --git a/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/BeaconBlockBodyFuzzInput.java b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/BeaconBlockBodyFuzzInput.java index b83007bb755..d7ab05cda4d 100644 --- a/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/BeaconBlockBodyFuzzInput.java +++ b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/BeaconBlockBodyFuzzInput.java @@ -19,35 +19,35 @@ import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecVersion; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.capella.BeaconBlockBodyCapella; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.capella.BeaconBlockBodySchemaCapella; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra.BeaconBlockBodyElectra; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra.BeaconBlockBodySchemaElectra; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; public class BeaconBlockBodyFuzzInput - extends Container2 { + extends Container2 { - public static ContainerSchema2 + public static ContainerSchema2 createSchema(final SpecVersion spec) { - BeaconBlockBodySchemaCapella beaconBlockBodySchema = - spec.getSchemaDefinitions().getBeaconBlockBodySchema().toVersionCapella().orElseThrow(); + BeaconBlockBodySchemaElectra beaconBlockBodySchema = + spec.getSchemaDefinitions().getBeaconBlockBodySchema().toVersionElectra().orElseThrow(); return ContainerSchema2.create( SszSchema.as(BeaconState.class, spec.getSchemaDefinitions().getBeaconStateSchema()), - SszSchema.as(BeaconBlockBodyCapella.class, beaconBlockBodySchema), + SszSchema.as(BeaconBlockBodyElectra.class, beaconBlockBodySchema), BeaconBlockBodyFuzzInput::new); } public BeaconBlockBodyFuzzInput( - ContainerSchema2 type, - TreeNode backingNode) { + final ContainerSchema2 type, + final TreeNode backingNode) { super(type, backingNode); } public BeaconBlockBodyFuzzInput( - final Spec spec, final BeaconState state, final BeaconBlockBodyCapella beaconBlockBody) { + final Spec spec, final BeaconState state, final BeaconBlockBodyElectra beaconBlockBody) { super(createSchema(spec.atSlot(state.getSlot())), state, beaconBlockBody); } - public BeaconBlockBodyCapella getBeaconBlockBody() { + public BeaconBlockBodyElectra getBeaconBlockBody() { return getField1(); } diff --git a/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/BlockFuzzInput.java b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/BlockFuzzInput.java index 43a7eaa77b0..04501329895 100644 --- a/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/BlockFuzzInput.java +++ b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/BlockFuzzInput.java @@ -35,7 +35,8 @@ public static ContainerSchema2 c } private BlockFuzzInput( - ContainerSchema2 type, TreeNode backingNode) { + final ContainerSchema2 type, + final TreeNode backingNode) { super(type, backingNode); } diff --git a/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/BlockHeaderFuzzInput.java b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/BlockHeaderFuzzInput.java index 3959f612e6b..a85911e2589 100644 --- a/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/BlockHeaderFuzzInput.java +++ b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/BlockHeaderFuzzInput.java @@ -40,7 +40,8 @@ public static ContainerSchema2 c } private BlockHeaderFuzzInput( - ContainerSchema2 type, TreeNode backingNode) { + final ContainerSchema2 type, + final TreeNode backingNode) { super(type, backingNode); } diff --git a/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/BlsToExecutionChangeFuzzInput.java b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/BlsToExecutionChangeFuzzInput.java index 062f470cd1f..a470ee7c15c 100644 --- a/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/BlsToExecutionChangeFuzzInput.java +++ b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/BlsToExecutionChangeFuzzInput.java @@ -31,15 +31,16 @@ public class BlsToExecutionChangeFuzzInput return ContainerSchema2.create( SszSchema.as(BeaconState.class, spec.getSchemaDefinitions().getBeaconStateSchema()), spec.getSchemaDefinitions() - .toVersionCapella() + .toVersionElectra() .orElseThrow() .getSignedBlsToExecutionChangeSchema(), BlsToExecutionChangeFuzzInput::new); } public BlsToExecutionChangeFuzzInput( - ContainerSchema2 type, - TreeNode backingNode) { + final ContainerSchema2 + type, + final TreeNode backingNode) { super(type, backingNode); } diff --git a/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/ConsolidationRequestFuzzInput.java b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/ConsolidationRequestFuzzInput.java new file mode 100644 index 00000000000..0446bbdc548 --- /dev/null +++ b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/ConsolidationRequestFuzzInput.java @@ -0,0 +1,59 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.fuzz.input; + +import tech.pegasys.teku.infrastructure.ssz.containers.Container2; +import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema2; +import tech.pegasys.teku.infrastructure.ssz.schema.SszSchema; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecVersion; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequest; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; + +public class ConsolidationRequestFuzzInput + extends Container2 { + + public static ContainerSchema2 + createSchema(final SpecVersion spec) { + return ContainerSchema2.create( + SszSchema.as(BeaconState.class, spec.getSchemaDefinitions().getBeaconStateSchema()), + spec.getSchemaDefinitions() + .toVersionElectra() + .orElseThrow() + .getExecutionRequestsSchema() + .getConsolidationRequestsSchema() + .getElementSchema(), + ConsolidationRequestFuzzInput::new); + } + + public ConsolidationRequestFuzzInput( + final ContainerSchema2 type, + final TreeNode backingNode) { + super(type, backingNode); + } + + public ConsolidationRequestFuzzInput( + final Spec spec, final BeaconState state, final ConsolidationRequest depositRequest) { + super(createSchema(spec.atSlot(state.getSlot())), state, depositRequest); + } + + public BeaconState getState() { + return getField0(); + } + + public ConsolidationRequest getConsolidationRequest() { + return getField1(); + } +} diff --git a/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/DepositFuzzInput.java b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/DepositFuzzInput.java index cb7d0594190..41c6961ec4e 100644 --- a/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/DepositFuzzInput.java +++ b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/DepositFuzzInput.java @@ -33,7 +33,8 @@ public static ContainerSchema2 createSch } public DepositFuzzInput( - ContainerSchema2 type, TreeNode backingNode) { + final ContainerSchema2 type, + final TreeNode backingNode) { super(type, backingNode); } diff --git a/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/DepositRequestFuzzInput.java b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/DepositRequestFuzzInput.java new file mode 100644 index 00000000000..935543cffe0 --- /dev/null +++ b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/DepositRequestFuzzInput.java @@ -0,0 +1,59 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.fuzz.input; + +import tech.pegasys.teku.infrastructure.ssz.containers.Container2; +import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema2; +import tech.pegasys.teku.infrastructure.ssz.schema.SszSchema; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecVersion; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequest; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; + +public class DepositRequestFuzzInput + extends Container2 { + + public static ContainerSchema2 createSchema( + final SpecVersion spec) { + return ContainerSchema2.create( + SszSchema.as(BeaconState.class, spec.getSchemaDefinitions().getBeaconStateSchema()), + spec.getSchemaDefinitions() + .toVersionElectra() + .orElseThrow() + .getExecutionRequestsSchema() + .getDepositRequestsSchema() + .getElementSchema(), + DepositRequestFuzzInput::new); + } + + public DepositRequestFuzzInput( + final ContainerSchema2 type, + final TreeNode backingNode) { + super(type, backingNode); + } + + public DepositRequestFuzzInput( + final Spec spec, final BeaconState state, final DepositRequest depositRequest) { + super(createSchema(spec.atSlot(state.getSlot())), state, depositRequest); + } + + public BeaconState getState() { + return getField0(); + } + + public DepositRequest getDepositRequest() { + return getField1(); + } +} diff --git a/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/ProposerSlashingFuzzInput.java b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/ProposerSlashingFuzzInput.java index ad7f60d84f9..cc414677efc 100644 --- a/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/ProposerSlashingFuzzInput.java +++ b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/ProposerSlashingFuzzInput.java @@ -34,8 +34,8 @@ public class ProposerSlashingFuzzInput } public ProposerSlashingFuzzInput( - ContainerSchema2 type, - TreeNode backingNode) { + final ContainerSchema2 type, + final TreeNode backingNode) { super(type, backingNode); } diff --git a/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/SyncAggregateFuzzInput.java b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/SyncAggregateFuzzInput.java index 58a600a7cdc..f8bcef0c51f 100644 --- a/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/SyncAggregateFuzzInput.java +++ b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/SyncAggregateFuzzInput.java @@ -37,8 +37,8 @@ public static ContainerSchema2 type, - TreeNode backingNode) { + final ContainerSchema2 type, + final TreeNode backingNode) { super(type, backingNode); } diff --git a/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/VoluntaryExitFuzzInput.java b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/VoluntaryExitFuzzInput.java index ae5a94e2da8..262142a6b9f 100644 --- a/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/VoluntaryExitFuzzInput.java +++ b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/VoluntaryExitFuzzInput.java @@ -34,8 +34,8 @@ public class VoluntaryExitFuzzInput } public VoluntaryExitFuzzInput( - ContainerSchema2 type, - TreeNode backingNode) { + final ContainerSchema2 type, + final TreeNode backingNode) { super(type, backingNode); } diff --git a/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/WithdrawalRequestFuzzInput.java b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/WithdrawalRequestFuzzInput.java new file mode 100644 index 00000000000..dd1d5265552 --- /dev/null +++ b/fuzz/src/main/java/tech/pegasys/teku/fuzz/input/WithdrawalRequestFuzzInput.java @@ -0,0 +1,59 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.fuzz.input; + +import tech.pegasys.teku.infrastructure.ssz.containers.Container2; +import tech.pegasys.teku.infrastructure.ssz.containers.ContainerSchema2; +import tech.pegasys.teku.infrastructure.ssz.schema.SszSchema; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecVersion; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequest; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; + +public class WithdrawalRequestFuzzInput + extends Container2 { + + public static ContainerSchema2 + createSchema(final SpecVersion spec) { + return ContainerSchema2.create( + SszSchema.as(BeaconState.class, spec.getSchemaDefinitions().getBeaconStateSchema()), + spec.getSchemaDefinitions() + .toVersionElectra() + .orElseThrow() + .getExecutionRequestsSchema() + .getWithdrawalRequestsSchema() + .getElementSchema(), + WithdrawalRequestFuzzInput::new); + } + + public WithdrawalRequestFuzzInput( + final ContainerSchema2 type, + final TreeNode backingNode) { + super(type, backingNode); + } + + public WithdrawalRequestFuzzInput( + final Spec spec, final BeaconState state, final WithdrawalRequest depositRequest) { + super(createSchema(spec.atSlot(state.getSlot())), state, depositRequest); + } + + public BeaconState getState() { + return getField0(); + } + + public WithdrawalRequest getWithdrawalRequest() { + return getField1(); + } +} diff --git a/fuzz/src/test/java/tech/pegasys/teku/fuzz/FuzzUtilTest.java b/fuzz/src/test/java/tech/pegasys/teku/fuzz/FuzzUtilTest.java index 800de9da4da..05811285b46 100644 --- a/fuzz/src/test/java/tech/pegasys/teku/fuzz/FuzzUtilTest.java +++ b/fuzz/src/test/java/tech/pegasys/teku/fuzz/FuzzUtilTest.java @@ -31,10 +31,13 @@ import tech.pegasys.teku.fuzz.input.BlockFuzzInput; import tech.pegasys.teku.fuzz.input.BlockHeaderFuzzInput; import tech.pegasys.teku.fuzz.input.BlsToExecutionChangeFuzzInput; +import tech.pegasys.teku.fuzz.input.ConsolidationRequestFuzzInput; import tech.pegasys.teku.fuzz.input.DepositFuzzInput; +import tech.pegasys.teku.fuzz.input.DepositRequestFuzzInput; import tech.pegasys.teku.fuzz.input.ProposerSlashingFuzzInput; import tech.pegasys.teku.fuzz.input.SyncAggregateFuzzInput; import tech.pegasys.teku.fuzz.input.VoluntaryExitFuzzInput; +import tech.pegasys.teku.fuzz.input.WithdrawalRequestFuzzInput; import tech.pegasys.teku.infrastructure.ssz.SszData; import tech.pegasys.teku.infrastructure.ssz.schema.SszSchema; import tech.pegasys.teku.spec.Spec; @@ -48,7 +51,10 @@ import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.BeaconBlockBodySchemaAltair; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.altair.SyncAggregate; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.capella.BeaconBlockBodySchemaCapella; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra.BeaconBlockBodySchemaElectra; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequest; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequest; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; import tech.pegasys.teku.spec.datastructures.operations.Deposit; @@ -56,19 +62,19 @@ import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChange; import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; -import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.capella.BeaconStateSchemaCapella; -import tech.pegasys.teku.spec.schemas.SchemaDefinitionsCapella; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.electra.BeaconStateSchemaElectra; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; @ExtendWith(BouncyCastleExtension.class) class FuzzUtilTest { - private final Spec spec = TestSpecFactory.createMinimalCapella(); - private final SpecVersion specVersion = spec.forMilestone(SpecMilestone.CAPELLA); - private final SchemaDefinitionsCapella schemaDefinitions = - SchemaDefinitionsCapella.required(specVersion.getSchemaDefinitions()); + private final Spec spec = TestSpecFactory.createMinimalElectra(); + private final SpecVersion specVersion = spec.forMilestone(SpecMilestone.ELECTRA); + private final SchemaDefinitionsElectra schemaDefinitions = + SchemaDefinitionsElectra.required(specVersion.getSchemaDefinitions()); private final BeaconBlockSchema beaconBlockSchema = schemaDefinitions.getBeaconBlockSchema(); - private final BeaconStateSchemaCapella beaconStateSchema = - BeaconStateSchemaCapella.required(schemaDefinitions.getBeaconStateSchema()); + private final BeaconStateSchemaElectra beaconStateSchema = + BeaconStateSchemaElectra.required(schemaDefinitions.getBeaconStateSchema()); private final SignedBeaconBlockSchema signedBeaconBlockSchema = schemaDefinitions.getSignedBeaconBlockSchema(); @@ -88,11 +94,12 @@ class FuzzUtilTest { public void fuzzAttestation_minimal() { final FuzzUtil fuzzUtil = new FuzzUtil(false, true); - final Path testCaseDir = Path.of("minimal/operations/attestation/pyspec_tests/success"); + final Path testCaseDir = + Path.of("minimal/operations/attestation/pyspec_tests/one_basic_attestation"); final Attestation data = loadSsz( testCaseDir.resolve("attestation.ssz_snappy"), - spec.forMilestone(SpecMilestone.CAPELLA).getSchemaDefinitions().getAttestationSchema()); + spec.forMilestone(SpecMilestone.ELECTRA).getSchemaDefinitions().getAttestationSchema()); final BeaconState preState = loadSsz(testCaseDir.resolve("pre.ssz_snappy"), beaconStateSchema); final BeaconState postState = loadSsz(testCaseDir.resolve("post.ssz_snappy"), beaconStateSchema); @@ -111,11 +118,11 @@ public void fuzzAttesterSlashing_minimal() { final FuzzUtil fuzzUtil = new FuzzUtil(false, true); final Path testCaseDir = - Path.of("minimal/operations/attester_slashing/pyspec_tests/success_surround"); + Path.of("minimal/operations/attester_slashing/pyspec_tests/basic_surround"); final AttesterSlashing data = loadSsz( testCaseDir.resolve("attester_slashing.ssz_snappy"), - spec.forMilestone(SpecMilestone.CAPELLA) + spec.forMilestone(SpecMilestone.ELECTRA) .getSchemaDefinitions() .getAttesterSlashingSchema()); final BeaconState preState = loadSsz(testCaseDir.resolve("pre.ssz_snappy"), beaconStateSchema); @@ -163,7 +170,7 @@ public void fuzzBlockHeader_minimal() { final FuzzUtil fuzzUtil = new FuzzUtil(false, true); final Path testCaseDir = - Path.of("minimal/operations/block_header/pyspec_tests/success_block_header"); + Path.of("minimal/operations/block_header/pyspec_tests/basic_block_header"); final BeaconBlock data = loadSsz(testCaseDir.resolve("block.ssz_snappy"), beaconBlockSchema); final BeaconState preState = loadSsz(testCaseDir.resolve("pre.ssz_snappy"), beaconStateSchema); final BeaconState postState = @@ -183,7 +190,7 @@ public void fuzzDeposit_minimal() { final FuzzUtil fuzzUtil = new FuzzUtil(false, true); final Path testCaseDir = - Path.of("minimal/operations/deposit/pyspec_tests/success_top_up__max_effective_balance"); + Path.of("minimal/operations/deposit/pyspec_tests/top_up__max_effective_balance"); final Deposit data = loadSsz(testCaseDir.resolve("deposit.ssz_snappy"), Deposit.SSZ_SCHEMA); final BeaconState preState = loadSsz(testCaseDir.resolve("pre.ssz_snappy"), beaconStateSchema); final BeaconState postState = @@ -202,7 +209,7 @@ public void fuzzDeposit_minimal() { public void fuzzProposerSlashing_minimal() { final FuzzUtil fuzzUtil = new FuzzUtil(false, true); - final Path testCaseDir = Path.of("minimal/operations/proposer_slashing/pyspec_tests/success"); + final Path testCaseDir = Path.of("minimal/operations/proposer_slashing/pyspec_tests/basic"); final ProposerSlashing data = loadSsz(testCaseDir.resolve("proposer_slashing.ssz_snappy"), ProposerSlashing.SSZ_SCHEMA); final BeaconState preState = loadSsz(testCaseDir.resolve("pre.ssz_snappy"), beaconStateSchema); @@ -222,7 +229,7 @@ public void fuzzProposerSlashing_minimal() { public void fuzzVoluntaryExit_minimal() { final FuzzUtil fuzzUtil = new FuzzUtil(false, true); - final Path testCaseDir = Path.of("minimal/operations/voluntary_exit/pyspec_tests/success"); + final Path testCaseDir = Path.of("minimal/operations/voluntary_exit/pyspec_tests/basic"); final SignedVoluntaryExit data = loadSsz(testCaseDir.resolve("voluntary_exit.ssz_snappy"), SignedVoluntaryExit.SSZ_SCHEMA); final BeaconState preState = loadSsz(testCaseDir.resolve("pre.ssz_snappy"), beaconStateSchema); @@ -270,8 +277,8 @@ public void fuzzSyncAggregate_minimal() { public void fuzzExecutionPayload_minimal() { final FuzzUtil fuzzUtil = new FuzzUtil(false, true); - BeaconBlockBodySchemaCapella beaconBlockBodySchema = - (BeaconBlockBodySchemaCapella) + BeaconBlockBodySchemaElectra beaconBlockBodySchema = + (BeaconBlockBodySchemaElectra) specVersion.getSchemaDefinitions().getBeaconBlockBodySchema(); final Path testCaseDir = @@ -283,7 +290,7 @@ public void fuzzExecutionPayload_minimal() { loadSsz(testCaseDir.resolve("post.ssz_snappy"), beaconStateSchema); BeaconBlockBodyFuzzInput input = - new BeaconBlockBodyFuzzInput(spec, preState, data.toVersionCapella().orElseThrow()); + new BeaconBlockBodyFuzzInput(spec, preState, data.toVersionElectra().orElseThrow()); byte[] rawInput = input.sszSerialize().toArrayUnsafe(); Optional result = fuzzUtil.fuzzExecutionPayload(rawInput).map(Bytes::wrap); @@ -301,7 +308,7 @@ public void fuzzBlsToExecutionChange_minimal() { final SignedBlsToExecutionChange data = loadSsz( testCaseDir.resolve("address_change.ssz_snappy"), - SchemaDefinitionsCapella.required(specVersion.getSchemaDefinitions()) + SchemaDefinitionsElectra.required(specVersion.getSchemaDefinitions()) .getSignedBlsToExecutionChangeSchema()); final BeaconState preState = loadSsz(testCaseDir.resolve("pre.ssz_snappy"), beaconStateSchema); final BeaconState postState = @@ -316,6 +323,86 @@ public void fuzzBlsToExecutionChange_minimal() { assertThat(result.get()).isEqualTo(expected); } + @Test + public void fuzzDepositRequest_minimal() { + final FuzzUtil fuzzUtil = new FuzzUtil(false, true); + + final Path testCaseDir = + Path.of( + "minimal/operations/deposit_request/pyspec_tests/process_deposit_request_max_effective_balance_compounding/"); + final DepositRequest data = + loadSsz( + testCaseDir.resolve("deposit_request.ssz_snappy"), + SchemaDefinitionsElectra.required(specVersion.getSchemaDefinitions()) + .getExecutionRequestsSchema() + .getDepositRequestsSchema() + .getElementSchema()); + final BeaconState preState = loadSsz(testCaseDir.resolve("pre.ssz_snappy"), beaconStateSchema); + final BeaconState postState = + loadSsz(testCaseDir.resolve("post.ssz_snappy"), beaconStateSchema); + + DepositRequestFuzzInput input = new DepositRequestFuzzInput(spec, preState, data); + byte[] rawInput = input.sszSerialize().toArrayUnsafe(); + Optional result = fuzzUtil.fuzzDepositRequest(rawInput).map(Bytes::wrap); + + Bytes expected = postState.sszSerialize(); + assertThat(result).isNotEmpty(); + assertThat(result.get()).isEqualTo(expected); + } + + @Test + public void fuzzWithdrawalRequest_minimal() { + final FuzzUtil fuzzUtil = new FuzzUtil(false, true); + + final Path testCaseDir = + Path.of("minimal/operations/withdrawal_request/pyspec_tests/basic_withdrawal_request/"); + final WithdrawalRequest data = + loadSsz( + testCaseDir.resolve("withdrawal_request.ssz_snappy"), + SchemaDefinitionsElectra.required(specVersion.getSchemaDefinitions()) + .getExecutionRequestsSchema() + .getWithdrawalRequestsSchema() + .getElementSchema()); + final BeaconState preState = loadSsz(testCaseDir.resolve("pre.ssz_snappy"), beaconStateSchema); + final BeaconState postState = + loadSsz(testCaseDir.resolve("post.ssz_snappy"), beaconStateSchema); + + WithdrawalRequestFuzzInput input = new WithdrawalRequestFuzzInput(spec, preState, data); + byte[] rawInput = input.sszSerialize().toArrayUnsafe(); + Optional result = fuzzUtil.fuzzWithdrawalRequest(rawInput).map(Bytes::wrap); + + Bytes expected = postState.sszSerialize(); + assertThat(result).isNotEmpty(); + assertThat(result.get()).isEqualTo(expected); + } + + @Test + public void fuzzConsolidationRequest_minimal() { + final FuzzUtil fuzzUtil = new FuzzUtil(false, true); + + final Path testCaseDir = + Path.of( + "minimal/operations/consolidation_request/pyspec_tests/basic_consolidation_in_current_consolidation_epoch/"); + final ConsolidationRequest data = + loadSsz( + testCaseDir.resolve("consolidation_request.ssz_snappy"), + SchemaDefinitionsElectra.required(specVersion.getSchemaDefinitions()) + .getExecutionRequestsSchema() + .getConsolidationRequestsSchema() + .getElementSchema()); + final BeaconState preState = loadSsz(testCaseDir.resolve("pre.ssz_snappy"), beaconStateSchema); + final BeaconState postState = + loadSsz(testCaseDir.resolve("post.ssz_snappy"), beaconStateSchema); + + ConsolidationRequestFuzzInput input = new ConsolidationRequestFuzzInput(spec, preState, data); + byte[] rawInput = input.sszSerialize().toArrayUnsafe(); + Optional result = fuzzUtil.fuzzConsolidationRequest(rawInput).map(Bytes::wrap); + + Bytes expected = postState.sszSerialize(); + assertThat(result).isNotEmpty(); + assertThat(result.get()).isEqualTo(expected); + } + @Test void fuzzShuffle_insufficientInput() { final FuzzUtil fuzzUtil = new FuzzUtil(true, true); diff --git a/fuzz/src/test/java/tech/pegasys/teku/fuzz/input/AbstractFuzzInputTest.java b/fuzz/src/test/java/tech/pegasys/teku/fuzz/input/AbstractFuzzInputTest.java index 90a2af8657e..c872edd993f 100644 --- a/fuzz/src/test/java/tech/pegasys/teku/fuzz/input/AbstractFuzzInputTest.java +++ b/fuzz/src/test/java/tech/pegasys/teku/fuzz/input/AbstractFuzzInputTest.java @@ -27,7 +27,7 @@ public abstract class AbstractFuzzInputTest { - protected final Spec spec = TestSpecFactory.createMinimalCapella(); + protected final Spec spec = TestSpecFactory.createMinimalElectra(); protected final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); @BeforeEach diff --git a/fuzz/src/test/java/tech/pegasys/teku/fuzz/input/ConsolidationRequestFuzzInputTest.java b/fuzz/src/test/java/tech/pegasys/teku/fuzz/input/ConsolidationRequestFuzzInputTest.java new file mode 100644 index 00000000000..6bcb244d031 --- /dev/null +++ b/fuzz/src/test/java/tech/pegasys/teku/fuzz/input/ConsolidationRequestFuzzInputTest.java @@ -0,0 +1,35 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.fuzz.input; + +import tech.pegasys.teku.infrastructure.ssz.schema.SszSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.ConsolidationRequest; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; + +public class ConsolidationRequestFuzzInputTest + extends AbstractFuzzInputTest { + + @Override + protected SszSchema getInputType() { + return ConsolidationRequestFuzzInput.createSchema(spec.getGenesisSpec()); + } + + @Override + protected ConsolidationRequestFuzzInput createInput() { + final BeaconState state = dataStructureUtil.randomBeaconState(); + final ConsolidationRequest consolidationRequest = + dataStructureUtil.randomConsolidationRequest(); + return new ConsolidationRequestFuzzInput(spec, state, consolidationRequest); + } +} diff --git a/fuzz/src/test/java/tech/pegasys/teku/fuzz/input/DepositRequestFuzzInputTest.java b/fuzz/src/test/java/tech/pegasys/teku/fuzz/input/DepositRequestFuzzInputTest.java new file mode 100644 index 00000000000..cb0ce476682 --- /dev/null +++ b/fuzz/src/test/java/tech/pegasys/teku/fuzz/input/DepositRequestFuzzInputTest.java @@ -0,0 +1,33 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.fuzz.input; + +import tech.pegasys.teku.infrastructure.ssz.schema.SszSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.DepositRequest; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; + +public class DepositRequestFuzzInputTest extends AbstractFuzzInputTest { + + @Override + protected SszSchema getInputType() { + return DepositRequestFuzzInput.createSchema(spec.getGenesisSpec()); + } + + @Override + protected DepositRequestFuzzInput createInput() { + final BeaconState state = dataStructureUtil.randomBeaconState(); + final DepositRequest depositRequest = dataStructureUtil.randomDepositRequest(); + return new DepositRequestFuzzInput(spec, state, depositRequest); + } +} diff --git a/fuzz/src/test/java/tech/pegasys/teku/fuzz/input/ExecutionPayloadFuzzInputTest.java b/fuzz/src/test/java/tech/pegasys/teku/fuzz/input/ExecutionPayloadFuzzInputTest.java index 8af3db41cca..2cb3d909a47 100644 --- a/fuzz/src/test/java/tech/pegasys/teku/fuzz/input/ExecutionPayloadFuzzInputTest.java +++ b/fuzz/src/test/java/tech/pegasys/teku/fuzz/input/ExecutionPayloadFuzzInputTest.java @@ -14,7 +14,7 @@ package tech.pegasys.teku.fuzz.input; import tech.pegasys.teku.infrastructure.ssz.schema.SszSchema; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.capella.BeaconBlockBodyCapella; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra.BeaconBlockBodyElectra; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; public class ExecutionPayloadFuzzInputTest extends AbstractFuzzInputTest { @@ -27,8 +27,8 @@ protected SszSchema getInputType() { @Override protected BeaconBlockBodyFuzzInput createInput() { final BeaconState state = dataStructureUtil.randomBeaconState(); - final BeaconBlockBodyCapella beaconBlockBody = - BeaconBlockBodyCapella.required(dataStructureUtil.randomBeaconBlockBody()); + final BeaconBlockBodyElectra beaconBlockBody = + BeaconBlockBodyElectra.required(dataStructureUtil.randomBeaconBlockBody()); return new BeaconBlockBodyFuzzInput(spec, state, beaconBlockBody); } } diff --git a/fuzz/src/test/java/tech/pegasys/teku/fuzz/input/WithdrawalRequestFuzzInputTest.java b/fuzz/src/test/java/tech/pegasys/teku/fuzz/input/WithdrawalRequestFuzzInputTest.java new file mode 100644 index 00000000000..1b5ee76da77 --- /dev/null +++ b/fuzz/src/test/java/tech/pegasys/teku/fuzz/input/WithdrawalRequestFuzzInputTest.java @@ -0,0 +1,34 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.fuzz.input; + +import tech.pegasys.teku.infrastructure.ssz.schema.SszSchema; +import tech.pegasys.teku.spec.datastructures.execution.versions.electra.WithdrawalRequest; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; + +public class WithdrawalRequestFuzzInputTest + extends AbstractFuzzInputTest { + + @Override + protected SszSchema getInputType() { + return WithdrawalRequestFuzzInput.createSchema(spec.getGenesisSpec()); + } + + @Override + protected WithdrawalRequestFuzzInput createInput() { + final BeaconState state = dataStructureUtil.randomBeaconState(); + final WithdrawalRequest withdrawalRequest = dataStructureUtil.randomWithdrawalRequest(); + return new WithdrawalRequestFuzzInput(spec, state, withdrawalRequest); + } +} diff --git a/fuzz/src/test/resources/minimal/operations/attestation/pyspec_tests/one_basic_attestation/attestation.ssz_snappy b/fuzz/src/test/resources/minimal/operations/attestation/pyspec_tests/one_basic_attestation/attestation.ssz_snappy new file mode 100644 index 00000000000..32c9853830a Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/attestation/pyspec_tests/one_basic_attestation/attestation.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/attestation/pyspec_tests/one_basic_attestation/post.ssz_snappy b/fuzz/src/test/resources/minimal/operations/attestation/pyspec_tests/one_basic_attestation/post.ssz_snappy new file mode 100644 index 00000000000..cbca65d2157 Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/attestation/pyspec_tests/one_basic_attestation/post.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/attestation/pyspec_tests/one_basic_attestation/pre.ssz_snappy b/fuzz/src/test/resources/minimal/operations/attestation/pyspec_tests/one_basic_attestation/pre.ssz_snappy new file mode 100644 index 00000000000..7e2480031de Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/attestation/pyspec_tests/one_basic_attestation/pre.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/attestation/pyspec_tests/success/attestation.ssz_snappy b/fuzz/src/test/resources/minimal/operations/attestation/pyspec_tests/success/attestation.ssz_snappy deleted file mode 100644 index 1c2d833e882..00000000000 Binary files a/fuzz/src/test/resources/minimal/operations/attestation/pyspec_tests/success/attestation.ssz_snappy and /dev/null differ diff --git a/fuzz/src/test/resources/minimal/operations/attestation/pyspec_tests/success/post.ssz_snappy b/fuzz/src/test/resources/minimal/operations/attestation/pyspec_tests/success/post.ssz_snappy deleted file mode 100644 index 7c671899701..00000000000 Binary files a/fuzz/src/test/resources/minimal/operations/attestation/pyspec_tests/success/post.ssz_snappy and /dev/null differ diff --git a/fuzz/src/test/resources/minimal/operations/attestation/pyspec_tests/success/pre.ssz_snappy b/fuzz/src/test/resources/minimal/operations/attestation/pyspec_tests/success/pre.ssz_snappy deleted file mode 100644 index fcda469205a..00000000000 Binary files a/fuzz/src/test/resources/minimal/operations/attestation/pyspec_tests/success/pre.ssz_snappy and /dev/null differ diff --git a/fuzz/src/test/resources/minimal/operations/attester_slashing/pyspec_tests/basic_surround/attester_slashing.ssz_snappy b/fuzz/src/test/resources/minimal/operations/attester_slashing/pyspec_tests/basic_surround/attester_slashing.ssz_snappy new file mode 100644 index 00000000000..2d0e562173b Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/attester_slashing/pyspec_tests/basic_surround/attester_slashing.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/attester_slashing/pyspec_tests/basic_surround/post.ssz_snappy b/fuzz/src/test/resources/minimal/operations/attester_slashing/pyspec_tests/basic_surround/post.ssz_snappy new file mode 100644 index 00000000000..e90e43dfab9 Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/attester_slashing/pyspec_tests/basic_surround/post.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/attester_slashing/pyspec_tests/basic_surround/pre.ssz_snappy b/fuzz/src/test/resources/minimal/operations/attester_slashing/pyspec_tests/basic_surround/pre.ssz_snappy new file mode 100644 index 00000000000..8c7b161c737 Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/attester_slashing/pyspec_tests/basic_surround/pre.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/attester_slashing/pyspec_tests/success_surround/attester_slashing.ssz_snappy b/fuzz/src/test/resources/minimal/operations/attester_slashing/pyspec_tests/success_surround/attester_slashing.ssz_snappy deleted file mode 100644 index 2c233c00c7b..00000000000 Binary files a/fuzz/src/test/resources/minimal/operations/attester_slashing/pyspec_tests/success_surround/attester_slashing.ssz_snappy and /dev/null differ diff --git a/fuzz/src/test/resources/minimal/operations/attester_slashing/pyspec_tests/success_surround/post.ssz_snappy b/fuzz/src/test/resources/minimal/operations/attester_slashing/pyspec_tests/success_surround/post.ssz_snappy deleted file mode 100644 index 2ba24b4de1a..00000000000 Binary files a/fuzz/src/test/resources/minimal/operations/attester_slashing/pyspec_tests/success_surround/post.ssz_snappy and /dev/null differ diff --git a/fuzz/src/test/resources/minimal/operations/attester_slashing/pyspec_tests/success_surround/pre.ssz_snappy b/fuzz/src/test/resources/minimal/operations/attester_slashing/pyspec_tests/success_surround/pre.ssz_snappy deleted file mode 100644 index 0c2cbc34295..00000000000 Binary files a/fuzz/src/test/resources/minimal/operations/attester_slashing/pyspec_tests/success_surround/pre.ssz_snappy and /dev/null differ diff --git a/fuzz/src/test/resources/minimal/operations/block_header/pyspec_tests/basic_block_header/block.ssz_snappy b/fuzz/src/test/resources/minimal/operations/block_header/pyspec_tests/basic_block_header/block.ssz_snappy new file mode 100644 index 00000000000..d0e5716d4a3 Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/block_header/pyspec_tests/basic_block_header/block.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/block_header/pyspec_tests/basic_block_header/post.ssz_snappy b/fuzz/src/test/resources/minimal/operations/block_header/pyspec_tests/basic_block_header/post.ssz_snappy new file mode 100644 index 00000000000..51f6d46123d Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/block_header/pyspec_tests/basic_block_header/post.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/block_header/pyspec_tests/basic_block_header/pre.ssz_snappy b/fuzz/src/test/resources/minimal/operations/block_header/pyspec_tests/basic_block_header/pre.ssz_snappy new file mode 100644 index 00000000000..7e2480031de Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/block_header/pyspec_tests/basic_block_header/pre.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/block_header/pyspec_tests/success_block_header/block.ssz_snappy b/fuzz/src/test/resources/minimal/operations/block_header/pyspec_tests/success_block_header/block.ssz_snappy deleted file mode 100644 index c3f7d4701ca..00000000000 Binary files a/fuzz/src/test/resources/minimal/operations/block_header/pyspec_tests/success_block_header/block.ssz_snappy and /dev/null differ diff --git a/fuzz/src/test/resources/minimal/operations/block_header/pyspec_tests/success_block_header/post.ssz_snappy b/fuzz/src/test/resources/minimal/operations/block_header/pyspec_tests/success_block_header/post.ssz_snappy deleted file mode 100644 index 9b877bdde63..00000000000 Binary files a/fuzz/src/test/resources/minimal/operations/block_header/pyspec_tests/success_block_header/post.ssz_snappy and /dev/null differ diff --git a/fuzz/src/test/resources/minimal/operations/block_header/pyspec_tests/success_block_header/pre.ssz_snappy b/fuzz/src/test/resources/minimal/operations/block_header/pyspec_tests/success_block_header/pre.ssz_snappy deleted file mode 100644 index fcda469205a..00000000000 Binary files a/fuzz/src/test/resources/minimal/operations/block_header/pyspec_tests/success_block_header/pre.ssz_snappy and /dev/null differ diff --git a/fuzz/src/test/resources/minimal/operations/bls_to_execution_change/pyspec_tests/success/address_change.ssz_snappy b/fuzz/src/test/resources/minimal/operations/bls_to_execution_change/pyspec_tests/success/address_change.ssz_snappy index 4eb60572b14..3a3946f6dfe 100644 Binary files a/fuzz/src/test/resources/minimal/operations/bls_to_execution_change/pyspec_tests/success/address_change.ssz_snappy and b/fuzz/src/test/resources/minimal/operations/bls_to_execution_change/pyspec_tests/success/address_change.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/bls_to_execution_change/pyspec_tests/success/post.ssz_snappy b/fuzz/src/test/resources/minimal/operations/bls_to_execution_change/pyspec_tests/success/post.ssz_snappy index 71d69c85ce6..82ea082b334 100644 Binary files a/fuzz/src/test/resources/minimal/operations/bls_to_execution_change/pyspec_tests/success/post.ssz_snappy and b/fuzz/src/test/resources/minimal/operations/bls_to_execution_change/pyspec_tests/success/post.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/bls_to_execution_change/pyspec_tests/success/pre.ssz_snappy b/fuzz/src/test/resources/minimal/operations/bls_to_execution_change/pyspec_tests/success/pre.ssz_snappy index 0434e693cc8..6a868873ae2 100644 Binary files a/fuzz/src/test/resources/minimal/operations/bls_to_execution_change/pyspec_tests/success/pre.ssz_snappy and b/fuzz/src/test/resources/minimal/operations/bls_to_execution_change/pyspec_tests/success/pre.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/consolidation_request/pyspec_tests/basic_consolidation_in_current_consolidation_epoch/consolidation_request.ssz_snappy b/fuzz/src/test/resources/minimal/operations/consolidation_request/pyspec_tests/basic_consolidation_in_current_consolidation_epoch/consolidation_request.ssz_snappy new file mode 100644 index 00000000000..12649b4364b Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/consolidation_request/pyspec_tests/basic_consolidation_in_current_consolidation_epoch/consolidation_request.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/consolidation_request/pyspec_tests/basic_consolidation_in_current_consolidation_epoch/post.ssz_snappy b/fuzz/src/test/resources/minimal/operations/consolidation_request/pyspec_tests/basic_consolidation_in_current_consolidation_epoch/post.ssz_snappy new file mode 100644 index 00000000000..950c4ff6c39 Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/consolidation_request/pyspec_tests/basic_consolidation_in_current_consolidation_epoch/post.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/consolidation_request/pyspec_tests/basic_consolidation_in_current_consolidation_epoch/pre.ssz_snappy b/fuzz/src/test/resources/minimal/operations/consolidation_request/pyspec_tests/basic_consolidation_in_current_consolidation_epoch/pre.ssz_snappy new file mode 100644 index 00000000000..485373fc120 Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/consolidation_request/pyspec_tests/basic_consolidation_in_current_consolidation_epoch/pre.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/deposit/pyspec_tests/success_top_up__max_effective_balance/post.ssz_snappy b/fuzz/src/test/resources/minimal/operations/deposit/pyspec_tests/success_top_up__max_effective_balance/post.ssz_snappy deleted file mode 100644 index a9abf24c1ff..00000000000 Binary files a/fuzz/src/test/resources/minimal/operations/deposit/pyspec_tests/success_top_up__max_effective_balance/post.ssz_snappy and /dev/null differ diff --git a/fuzz/src/test/resources/minimal/operations/deposit/pyspec_tests/success_top_up__max_effective_balance/pre.ssz_snappy b/fuzz/src/test/resources/minimal/operations/deposit/pyspec_tests/success_top_up__max_effective_balance/pre.ssz_snappy deleted file mode 100644 index 1415a8e2fba..00000000000 Binary files a/fuzz/src/test/resources/minimal/operations/deposit/pyspec_tests/success_top_up__max_effective_balance/pre.ssz_snappy and /dev/null differ diff --git a/fuzz/src/test/resources/minimal/operations/deposit/pyspec_tests/success_top_up__max_effective_balance/deposit.ssz_snappy b/fuzz/src/test/resources/minimal/operations/deposit/pyspec_tests/top_up__max_effective_balance/deposit.ssz_snappy similarity index 81% rename from fuzz/src/test/resources/minimal/operations/deposit/pyspec_tests/success_top_up__max_effective_balance/deposit.ssz_snappy rename to fuzz/src/test/resources/minimal/operations/deposit/pyspec_tests/top_up__max_effective_balance/deposit.ssz_snappy index a4066b1e8b5..2165a33393d 100644 Binary files a/fuzz/src/test/resources/minimal/operations/deposit/pyspec_tests/success_top_up__max_effective_balance/deposit.ssz_snappy and b/fuzz/src/test/resources/minimal/operations/deposit/pyspec_tests/top_up__max_effective_balance/deposit.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/deposit/pyspec_tests/top_up__max_effective_balance/post.ssz_snappy b/fuzz/src/test/resources/minimal/operations/deposit/pyspec_tests/top_up__max_effective_balance/post.ssz_snappy new file mode 100644 index 00000000000..a70ac58697f Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/deposit/pyspec_tests/top_up__max_effective_balance/post.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/deposit/pyspec_tests/top_up__max_effective_balance/pre.ssz_snappy b/fuzz/src/test/resources/minimal/operations/deposit/pyspec_tests/top_up__max_effective_balance/pre.ssz_snappy new file mode 100644 index 00000000000..c9dc283be03 Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/deposit/pyspec_tests/top_up__max_effective_balance/pre.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/deposit_request/pyspec_tests/process_deposit_request_max_effective_balance_compounding/deposit_request.ssz_snappy b/fuzz/src/test/resources/minimal/operations/deposit_request/pyspec_tests/process_deposit_request_max_effective_balance_compounding/deposit_request.ssz_snappy new file mode 100644 index 00000000000..f059778af71 Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/deposit_request/pyspec_tests/process_deposit_request_max_effective_balance_compounding/deposit_request.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/deposit_request/pyspec_tests/process_deposit_request_max_effective_balance_compounding/post.ssz_snappy b/fuzz/src/test/resources/minimal/operations/deposit_request/pyspec_tests/process_deposit_request_max_effective_balance_compounding/post.ssz_snappy new file mode 100644 index 00000000000..52ee00abf4f Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/deposit_request/pyspec_tests/process_deposit_request_max_effective_balance_compounding/post.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/deposit_request/pyspec_tests/process_deposit_request_max_effective_balance_compounding/pre.ssz_snappy b/fuzz/src/test/resources/minimal/operations/deposit_request/pyspec_tests/process_deposit_request_max_effective_balance_compounding/pre.ssz_snappy new file mode 100644 index 00000000000..6a868873ae2 Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/deposit_request/pyspec_tests/process_deposit_request_max_effective_balance_compounding/pre.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/execution_payload/pyspec_tests/success_regular_payload/body.ssz_snappy b/fuzz/src/test/resources/minimal/operations/execution_payload/pyspec_tests/success_regular_payload/body.ssz_snappy index 7e247a881b2..f4099d45607 100644 Binary files a/fuzz/src/test/resources/minimal/operations/execution_payload/pyspec_tests/success_regular_payload/body.ssz_snappy and b/fuzz/src/test/resources/minimal/operations/execution_payload/pyspec_tests/success_regular_payload/body.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/execution_payload/pyspec_tests/success_regular_payload/post.ssz_snappy b/fuzz/src/test/resources/minimal/operations/execution_payload/pyspec_tests/success_regular_payload/post.ssz_snappy index 59c917244bb..c40728596c2 100644 Binary files a/fuzz/src/test/resources/minimal/operations/execution_payload/pyspec_tests/success_regular_payload/post.ssz_snappy and b/fuzz/src/test/resources/minimal/operations/execution_payload/pyspec_tests/success_regular_payload/post.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/execution_payload/pyspec_tests/success_regular_payload/pre.ssz_snappy b/fuzz/src/test/resources/minimal/operations/execution_payload/pyspec_tests/success_regular_payload/pre.ssz_snappy index 0516cb4fe2e..d119a0fd689 100644 Binary files a/fuzz/src/test/resources/minimal/operations/execution_payload/pyspec_tests/success_regular_payload/pre.ssz_snappy and b/fuzz/src/test/resources/minimal/operations/execution_payload/pyspec_tests/success_regular_payload/pre.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/proposer_slashing/pyspec_tests/basic/post.ssz_snappy b/fuzz/src/test/resources/minimal/operations/proposer_slashing/pyspec_tests/basic/post.ssz_snappy new file mode 100644 index 00000000000..d2416e11414 Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/proposer_slashing/pyspec_tests/basic/post.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/proposer_slashing/pyspec_tests/basic/pre.ssz_snappy b/fuzz/src/test/resources/minimal/operations/proposer_slashing/pyspec_tests/basic/pre.ssz_snappy new file mode 100644 index 00000000000..6a868873ae2 Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/proposer_slashing/pyspec_tests/basic/pre.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/proposer_slashing/pyspec_tests/basic/proposer_slashing.ssz_snappy b/fuzz/src/test/resources/minimal/operations/proposer_slashing/pyspec_tests/basic/proposer_slashing.ssz_snappy new file mode 100644 index 00000000000..99eef29fe36 Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/proposer_slashing/pyspec_tests/basic/proposer_slashing.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/proposer_slashing/pyspec_tests/success/post.ssz_snappy b/fuzz/src/test/resources/minimal/operations/proposer_slashing/pyspec_tests/success/post.ssz_snappy deleted file mode 100644 index a35e166976c..00000000000 Binary files a/fuzz/src/test/resources/minimal/operations/proposer_slashing/pyspec_tests/success/post.ssz_snappy and /dev/null differ diff --git a/fuzz/src/test/resources/minimal/operations/proposer_slashing/pyspec_tests/success/pre.ssz_snappy b/fuzz/src/test/resources/minimal/operations/proposer_slashing/pyspec_tests/success/pre.ssz_snappy deleted file mode 100644 index 0434e693cc8..00000000000 Binary files a/fuzz/src/test/resources/minimal/operations/proposer_slashing/pyspec_tests/success/pre.ssz_snappy and /dev/null differ diff --git a/fuzz/src/test/resources/minimal/operations/proposer_slashing/pyspec_tests/success/proposer_slashing.ssz_snappy b/fuzz/src/test/resources/minimal/operations/proposer_slashing/pyspec_tests/success/proposer_slashing.ssz_snappy deleted file mode 100644 index e62513af4b9..00000000000 Binary files a/fuzz/src/test/resources/minimal/operations/proposer_slashing/pyspec_tests/success/proposer_slashing.ssz_snappy and /dev/null differ diff --git a/fuzz/src/test/resources/minimal/operations/sync_aggregate/pyspec_tests/sync_committee_rewards_nonduplicate_committee/post.ssz_snappy b/fuzz/src/test/resources/minimal/operations/sync_aggregate/pyspec_tests/sync_committee_rewards_nonduplicate_committee/post.ssz_snappy index 6e07372b95e..67f86ea145b 100644 Binary files a/fuzz/src/test/resources/minimal/operations/sync_aggregate/pyspec_tests/sync_committee_rewards_nonduplicate_committee/post.ssz_snappy and b/fuzz/src/test/resources/minimal/operations/sync_aggregate/pyspec_tests/sync_committee_rewards_nonduplicate_committee/post.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/sync_aggregate/pyspec_tests/sync_committee_rewards_nonduplicate_committee/pre.ssz_snappy b/fuzz/src/test/resources/minimal/operations/sync_aggregate/pyspec_tests/sync_committee_rewards_nonduplicate_committee/pre.ssz_snappy index 0740608e681..376f0ea30ce 100644 Binary files a/fuzz/src/test/resources/minimal/operations/sync_aggregate/pyspec_tests/sync_committee_rewards_nonduplicate_committee/pre.ssz_snappy and b/fuzz/src/test/resources/minimal/operations/sync_aggregate/pyspec_tests/sync_committee_rewards_nonduplicate_committee/pre.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/sync_aggregate/pyspec_tests/sync_committee_rewards_nonduplicate_committee/sync_aggregate.ssz_snappy b/fuzz/src/test/resources/minimal/operations/sync_aggregate/pyspec_tests/sync_committee_rewards_nonduplicate_committee/sync_aggregate.ssz_snappy index 65d1776ea21..746d9acf958 100644 Binary files a/fuzz/src/test/resources/minimal/operations/sync_aggregate/pyspec_tests/sync_committee_rewards_nonduplicate_committee/sync_aggregate.ssz_snappy and b/fuzz/src/test/resources/minimal/operations/sync_aggregate/pyspec_tests/sync_committee_rewards_nonduplicate_committee/sync_aggregate.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/voluntary_exit/pyspec_tests/basic/post.ssz_snappy b/fuzz/src/test/resources/minimal/operations/voluntary_exit/pyspec_tests/basic/post.ssz_snappy new file mode 100644 index 00000000000..431be21aeb0 Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/voluntary_exit/pyspec_tests/basic/post.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/voluntary_exit/pyspec_tests/basic/pre.ssz_snappy b/fuzz/src/test/resources/minimal/operations/voluntary_exit/pyspec_tests/basic/pre.ssz_snappy new file mode 100644 index 00000000000..93ce4f20df3 Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/voluntary_exit/pyspec_tests/basic/pre.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/voluntary_exit/pyspec_tests/success/voluntary_exit.ssz_snappy b/fuzz/src/test/resources/minimal/operations/voluntary_exit/pyspec_tests/basic/voluntary_exit.ssz_snappy similarity index 100% rename from fuzz/src/test/resources/minimal/operations/voluntary_exit/pyspec_tests/success/voluntary_exit.ssz_snappy rename to fuzz/src/test/resources/minimal/operations/voluntary_exit/pyspec_tests/basic/voluntary_exit.ssz_snappy diff --git a/fuzz/src/test/resources/minimal/operations/voluntary_exit/pyspec_tests/success/post.ssz_snappy b/fuzz/src/test/resources/minimal/operations/voluntary_exit/pyspec_tests/success/post.ssz_snappy deleted file mode 100644 index aa76dae98f0..00000000000 Binary files a/fuzz/src/test/resources/minimal/operations/voluntary_exit/pyspec_tests/success/post.ssz_snappy and /dev/null differ diff --git a/fuzz/src/test/resources/minimal/operations/voluntary_exit/pyspec_tests/success/pre.ssz_snappy b/fuzz/src/test/resources/minimal/operations/voluntary_exit/pyspec_tests/success/pre.ssz_snappy deleted file mode 100644 index 806b250d796..00000000000 Binary files a/fuzz/src/test/resources/minimal/operations/voluntary_exit/pyspec_tests/success/pre.ssz_snappy and /dev/null differ diff --git a/fuzz/src/test/resources/minimal/operations/withdrawal_request/pyspec_tests/basic_withdrawal_request/post.ssz_snappy b/fuzz/src/test/resources/minimal/operations/withdrawal_request/pyspec_tests/basic_withdrawal_request/post.ssz_snappy new file mode 100644 index 00000000000..e81c560db02 Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/withdrawal_request/pyspec_tests/basic_withdrawal_request/post.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/withdrawal_request/pyspec_tests/basic_withdrawal_request/pre.ssz_snappy b/fuzz/src/test/resources/minimal/operations/withdrawal_request/pyspec_tests/basic_withdrawal_request/pre.ssz_snappy new file mode 100644 index 00000000000..7dd45ff6800 Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/withdrawal_request/pyspec_tests/basic_withdrawal_request/pre.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/operations/withdrawal_request/pyspec_tests/basic_withdrawal_request/withdrawal_request.ssz_snappy b/fuzz/src/test/resources/minimal/operations/withdrawal_request/pyspec_tests/basic_withdrawal_request/withdrawal_request.ssz_snappy new file mode 100644 index 00000000000..7b71e6a4580 Binary files /dev/null and b/fuzz/src/test/resources/minimal/operations/withdrawal_request/pyspec_tests/basic_withdrawal_request/withdrawal_request.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/sanity/blocks/pyspec_tests/attestation/blocks_0.ssz_snappy b/fuzz/src/test/resources/minimal/sanity/blocks/pyspec_tests/attestation/blocks_0.ssz_snappy index ed05c44d4bb..352b66c1372 100644 Binary files a/fuzz/src/test/resources/minimal/sanity/blocks/pyspec_tests/attestation/blocks_0.ssz_snappy and b/fuzz/src/test/resources/minimal/sanity/blocks/pyspec_tests/attestation/blocks_0.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/sanity/blocks/pyspec_tests/attestation/blocks_1.ssz_snappy b/fuzz/src/test/resources/minimal/sanity/blocks/pyspec_tests/attestation/blocks_1.ssz_snappy index 1519fbd8677..5fc13845dfc 100644 Binary files a/fuzz/src/test/resources/minimal/sanity/blocks/pyspec_tests/attestation/blocks_1.ssz_snappy and b/fuzz/src/test/resources/minimal/sanity/blocks/pyspec_tests/attestation/blocks_1.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/sanity/blocks/pyspec_tests/attestation/post.ssz_snappy b/fuzz/src/test/resources/minimal/sanity/blocks/pyspec_tests/attestation/post.ssz_snappy index 885c3a2ff33..f7900a1bd9c 100644 Binary files a/fuzz/src/test/resources/minimal/sanity/blocks/pyspec_tests/attestation/post.ssz_snappy and b/fuzz/src/test/resources/minimal/sanity/blocks/pyspec_tests/attestation/post.ssz_snappy differ diff --git a/fuzz/src/test/resources/minimal/sanity/blocks/pyspec_tests/attestation/pre.ssz_snappy b/fuzz/src/test/resources/minimal/sanity/blocks/pyspec_tests/attestation/pre.ssz_snappy index aab2514d7c9..6b56511c838 100644 Binary files a/fuzz/src/test/resources/minimal/sanity/blocks/pyspec_tests/attestation/pre.ssz_snappy and b/fuzz/src/test/resources/minimal/sanity/blocks/pyspec_tests/attestation/pre.ssz_snappy differ diff --git a/gradle/trivyignore.txt b/gradle/trivyignore.txt index 8c2f2da5552..0bef3c1bb88 100644 --- a/gradle/trivyignore.txt +++ b/gradle/trivyignore.txt @@ -2,4 +2,4 @@ # The following comment is an example of how CVE entries should be used in this file: # CVE-2022-0123 -CVE-2023-39017 +CVE-2024-7254 \ No newline at end of file diff --git a/gradle/versions.gradle b/gradle/versions.gradle index a115f8ad4d2..439ee7ae90f 100644 --- a/gradle/versions.gradle +++ b/gradle/versions.gradle @@ -1,11 +1,11 @@ dependencyManagement { dependencies { - dependency 'com.fasterxml.jackson.core:jackson-databind:2.17.2' - dependency 'com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:2.17.2' - dependency 'com.fasterxml.jackson.dataformat:jackson-dataformat-toml:2.17.2' - dependency 'com.fasterxml.jackson.module:jackson-module-kotlin:2.17.2' + dependency 'com.fasterxml.jackson.core:jackson-databind:2.18.1' + dependency 'com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:2.18.1' + dependency 'com.fasterxml.jackson.dataformat:jackson-dataformat-toml:2.18.1' + dependency 'com.fasterxml.jackson.module:jackson-module-kotlin:2.18.1' - dependencySet(group: 'com.google.errorprone', version: '2.28.0') { + dependencySet(group: 'com.google.errorprone', version: '2.35.1') { entry 'error_prone_annotation' entry 'error_prone_check_api' entry 'error_prone_core' @@ -27,23 +27,23 @@ dependencyManagement { dependency 'info.picocli:picocli:4.7.6' - dependencySet(group: 'io.javalin', version: '6.1.6') { + dependencySet(group: 'io.javalin', version: '6.3.0') { entry 'javalin' entry 'javalin-rendering' } - dependency 'io.libp2p:jvm-libp2p:1.1.1-RELEASE' + dependency 'io.libp2p:jvm-libp2p:1.2.1-RELEASE' dependency 'tech.pegasys:jblst:0.3.12' dependency 'io.consensys.protocols:jc-kzg-4844:2.0.0' dependency 'io.github.crate-crypto:java-eth-kzg:0.5.2' dependency 'org.hdrhistogram:HdrHistogram:2.2.2' - dependency 'org.jetbrains.kotlin:kotlin-stdlib:2.0.0' + dependency 'org.jetbrains.kotlin:kotlin-stdlib:2.0.21' dependency 'org.mock-server:mockserver-junit-jupiter:5.15.0' - dependencySet(group: 'io.swagger.core.v3', version: '2.2.22') { + dependencySet(group: 'io.swagger.core.v3', version: '2.2.25') { entry 'swagger-parser' entry 'swagger-core' entry 'swagger-models' @@ -54,30 +54,30 @@ dependencyManagement { dependency 'org.webjars:swagger-ui:5.17.14' dependency 'org.thymeleaf:thymeleaf:3.1.2.RELEASE' - dependency 'io.github.classgraph:classgraph:4.8.174' - dependencySet(group: 'com.github.oshi', version: '6.6.1') { + dependency 'io.github.classgraph:classgraph:4.8.177' + dependencySet(group: 'com.github.oshi', version: '6.6.5') { entry 'oshi-core' entry 'oshi-core-java11' } - dependencySet(group: 'io.netty', version: '4.1.111.Final') { + dependencySet(group: 'io.netty', version: '4.1.115.Final') { entry 'netty-handler' entry 'netty-codec-http' } - dependencySet(group: 'io.vertx', version: '4.5.8') { + dependencySet(group: 'io.vertx', version: '4.5.10') { entry 'vertx-codegen' entry 'vertx-core' entry 'vertx-unit' entry 'vertx-web' } - dependency 'io.projectreactor:reactor-core:3.6.8' + dependency 'io.projectreactor:reactor-core:3.6.11' - dependency 'it.unimi.dsi:fastutil:8.5.12' + dependency 'it.unimi.dsi:fastutil:8.5.15' dependency 'javax.annotation:javax.annotation-api:1.3.2' - dependencySet(group: 'org.apache.tuweni', version: '2.3.1') { + dependencySet(group: 'io.tmio', version: '2.4.2') { entry 'tuweni-bytes' entry 'tuweni-crypto' entry 'tuweni-junit' @@ -86,11 +86,11 @@ dependencyManagement { } dependency 'org.apache.commons:commons-text:1.12.0' - dependency 'org.apache.commons:commons-lang3:3.14.0' - dependency 'commons-io:commons-io:2.16.1' + dependency 'org.apache.commons:commons-lang3:3.17.0' + dependency 'commons-io:commons-io:2.17.0' dependency 'org.commonjava.mimeparse:mimeparse:0.1.3.3' - dependencySet(group: 'org.apache.logging.log4j', version: '2.23.1') { + dependencySet(group: 'org.apache.logging.log4j', version: '2.24.1') { entry 'log4j-api' entry 'log4j-core' entry 'log4j-slf4j-impl' @@ -101,20 +101,22 @@ dependencyManagement { dependency 'org.assertj:assertj-core:3.26.3' - dependency 'org.awaitility:awaitility:4.2.1' + dependency 'org.awaitility:awaitility:4.2.2' - dependencySet(group: 'org.bouncycastle', version: '1.78.1') { + dependencySet(group: 'org.bouncycastle', version: '1.79') { entry 'bcprov-jdk18on' entry 'bcpkix-jdk18on' } - dependencySet(group: 'org.junit.jupiter', version: '5.10.3') { + dependencySet(group: 'org.junit.jupiter', version: '5.11.3') { entry 'junit-jupiter-api' entry 'junit-jupiter-engine' entry 'junit-jupiter-params' } - dependencySet(group: 'org.mockito', version: '5.12.0') { + dependency 'net.java.dev.jna:jna:5.15.0' + + dependencySet(group: 'org.mockito', version: '5.14.2') { entry 'mockito-core' entry 'mockito-junit-jupiter' } @@ -124,7 +126,7 @@ dependencyManagement { entry 'jmh-generator-annprocess' } dependency 'org.quartz-scheduler:quartz:2.3.2' - dependency 'org.rocksdb:rocksdbjni:7.7.3' + dependency 'org.rocksdb:rocksdbjni:9.5.2' dependency 'org.fusesource.leveldbjni:leveldbjni-win64:1.8' dependency 'org.fusesource.leveldbjni:leveldbjni-win32:1.8' dependency 'tech.pegasys:leveldb-native:0.3.1' @@ -136,22 +138,22 @@ dependencyManagement { entry 'utils' } - dependency 'org.xerial.snappy:snappy-java:1.1.10.5' + dependency 'org.xerial.snappy:snappy-java:1.1.10.7' dependency 'io.prometheus:simpleclient:0.16.0' - dependencySet(group: 'org.hyperledger.besu.internal', version: '24.9.1') { + dependencySet(group: 'org.hyperledger.besu.internal', version: '24.10.0') { entry('metrics-core') entry('core') entry('config') } - dependencySet(group: 'org.hyperledger.besu', version: '24.9.1') { + dependencySet(group: 'org.hyperledger.besu', version: '24.10.0') { entry('besu-datatypes') entry('evm') entry('plugin-api') } - dependencySet(group: 'org.testcontainers', version: '1.19.8') { + dependencySet(group: 'org.testcontainers', version: '1.20.3') { entry "testcontainers" entry "junit-jupiter" } @@ -175,6 +177,6 @@ dependencyManagement { entry 'jjwt-jackson' } - dependency 'net.jqwik:jqwik:1.9.0' + dependency 'net.jqwik:jqwik:1.9.1' } } diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar index 2c3521197d7..a4b76b9530d 100644 Binary files a/gradle/wrapper/gradle-wrapper.jar and b/gradle/wrapper/gradle-wrapper.jar differ diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index 68e8816d71c..fb602ee2af0 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,7 +1,7 @@ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists -distributionSha256Sum=d725d707bfabd4dfdc958c624003b3c80accc03f7037b5122c4b1d0ef15cecab -distributionUrl=https\://services.gradle.org/distributions/gradle-8.9-bin.zip +distributionSha256Sum=31c55713e40233a8303827ceb42ca48a47267a0ad4bab9177123121e71524c26 +distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-bin.zip networkTimeout=10000 validateDistributionUrl=true zipStoreBase=GRADLE_USER_HOME diff --git a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/AsyncRunnerFactory.java b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/AsyncRunnerFactory.java index 92de5fecfc5..34246f12bc6 100644 --- a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/AsyncRunnerFactory.java +++ b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/AsyncRunnerFactory.java @@ -18,15 +18,16 @@ public interface AsyncRunnerFactory { int DEFAULT_MAX_QUEUE_SIZE = 10_000; + int DEFAULT_MAX_QUEUE_SIZE_ALL_SUBNETS = 40_000; int DEFAULT_THREAD_PRIORITY = Thread.NORM_PRIORITY; Pattern ASYNC_RUNNER_NAME_PATTERN = Pattern.compile("[a-zA-Z][a-zA-Z0-9_]*"); - default AsyncRunner create(String name, int maxThreads) { + default AsyncRunner create(final String name, final int maxThreads) { validateAsyncRunnerName(name); return create(name, maxThreads, DEFAULT_MAX_QUEUE_SIZE); } - default void validateAsyncRunnerName(String asyncRunnerName) { + default void validateAsyncRunnerName(final String asyncRunnerName) { if (!ASYNC_RUNNER_NAME_PATTERN.matcher(asyncRunnerName).matches()) { throw new IllegalArgumentException( String.format( @@ -35,7 +36,7 @@ default void validateAsyncRunnerName(String asyncRunnerName) { } } - default AsyncRunner create(String name, int maxThreads, int maxQueueSize) { + default AsyncRunner create(final String name, final int maxThreads, final int maxQueueSize) { return create(name, maxThreads, maxQueueSize, DEFAULT_THREAD_PRIORITY); } diff --git a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/FutureUtil.java b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/FutureUtil.java index 3b5a5f2f454..d290f50bad3 100644 --- a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/FutureUtil.java +++ b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/FutureUtil.java @@ -25,12 +25,12 @@ public class FutureUtil { public static void ignoreFuture(final Future future) {} static void runWithFixedDelay( - AsyncRunner runner, - ExceptionThrowingRunnable runnable, - Cancellable task, + final AsyncRunner runner, + final ExceptionThrowingRunnable runnable, + final Cancellable task, final Duration initialDelay, final Duration duration, - Consumer exceptionHandler) { + final Consumer exceptionHandler) { runner .runAfterDelay( @@ -85,11 +85,11 @@ static void runWithFixedDelay( } static void runAfterDelay( - AsyncRunner runner, - ExceptionThrowingRunnable runnable, - Cancellable task, + final AsyncRunner runner, + final ExceptionThrowingRunnable runnable, + final Cancellable task, final Duration delay, - Consumer exceptionHandler) { + final Consumer exceptionHandler) { runner .runAfterDelay( () -> { diff --git a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/SafeFuture.java b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/SafeFuture.java index 2a26c234da0..30ef00b8c7c 100644 --- a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/SafeFuture.java +++ b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/SafeFuture.java @@ -50,13 +50,13 @@ public static > Consumer ifExceptionGetsHereR return value -> ifExceptionGetsHereRaiseABug(action.apply(value)); } - public static SafeFuture completedFuture(U value) { + public static SafeFuture completedFuture(final U value) { SafeFuture future = new SafeFuture<>(); future.complete(value); return future; } - public static SafeFuture failedFuture(Throwable ex) { + public static SafeFuture failedFuture(final Throwable ex) { SafeFuture future = new SafeFuture<>(); future.completeExceptionally(ex); return future; @@ -93,7 +93,7 @@ public static SafeFuture of(final ExceptionThrowingSupplier supplier) * * @see #orInterrupt(Interruptor...) */ - public static SafeFuture notInterrupted(Interruptor... interruptors) { + public static SafeFuture notInterrupted(final Interruptor... interruptors) { SafeFuture delayedFuture = new SafeFuture<>(); SafeFuture ret = delayedFuture.orInterrupt(interruptors); delayedFuture.complete(null); @@ -116,7 +116,7 @@ public static SafeFuture notInterrupted(Interruptor... interruptors) { * @see #orInterrupt(Interruptor...) */ public static Interruptor createInterruptor( - CompletableFuture interruptFuture, Supplier exceptionSupplier) { + final CompletableFuture interruptFuture, final Supplier exceptionSupplier) { return new Interruptor(interruptFuture, exceptionSupplier); } @@ -126,7 +126,8 @@ public static Interruptor createInterruptor( * @param loopBody A supplier for generating futures to be run in succession * @return A future that will complete when looping terminates */ - public static SafeFuture asyncDoWhile(ExceptionThrowingFutureSupplier loopBody) { + public static SafeFuture asyncDoWhile( + final ExceptionThrowingFutureSupplier loopBody) { // Loop while futures complete immediately in order to avoid stack overflow due to recursion SafeFuture loopFuture = SafeFuture.of(loopBody); while (loopFuture.isCompletedNormally()) { @@ -319,7 +320,7 @@ public SafeFuture ignoreCancelException() { } @SafeVarargs - public final SafeFuture ignoreExceptions(Class... errors) { + public final SafeFuture ignoreExceptions(final Class... errors) { return this.exceptionally( err -> { if (ExceptionUtil.hasCause(err, errors)) { @@ -334,11 +335,11 @@ public final SafeFuture ignoreExceptions(Class... err .thenApply(__ -> null); } - public void completeAsync(T value, AsyncRunner asyncRunner) { + public void completeAsync(final T value, final AsyncRunner asyncRunner) { asyncRunner.runAsync(() -> complete(value)).ifExceptionGetsHereRaiseABug(); } - public void completeExceptionallyAsync(Throwable exception, AsyncRunner asyncRunner) { + public void completeExceptionallyAsync(final Throwable exception, final AsyncRunner asyncRunner) { asyncRunner.runAsync(() -> completeExceptionally(exception)).ifExceptionGetsHereRaiseABug(); } @@ -513,7 +514,7 @@ public SafeFuture thenApplyChecked(final ExceptionThrowingFunction } /** Shortcut to process the value when complete and return the same future */ - public SafeFuture thenPeek(Consumer fn) { + public SafeFuture thenPeek(final Consumer fn) { return thenApply( v -> { fn.accept(v); @@ -662,12 +663,12 @@ public SafeFuture orTimeout(final long timeout, final TimeUnit unit) { } /** Schedules future timeout on the specified {@link AsyncRunner} */ - public SafeFuture orTimeout(AsyncRunner async, final long timeout, final TimeUnit unit) { + public SafeFuture orTimeout(final AsyncRunner async, final long timeout, final TimeUnit unit) { return orTimeout(async, Duration.of(timeout, unit.toChronoUnit())); } /** Schedules future timeout on the specified {@link AsyncRunner} */ - public SafeFuture orTimeout(AsyncRunner async, Duration timeout) { + public SafeFuture orTimeout(final AsyncRunner async, final Duration timeout) { if (!isDone()) { SafeFuture timeoutInterruptor = async.runAfterDelay( @@ -742,13 +743,13 @@ public SafeFuture handleException(final Consumer action) { * future becomes complete when `waitForStage` completes. If the `waitForStage` completes * exceptionally the resulting future also completes exceptionally with the same exception */ - public SafeFuture thenWaitFor(Function> waitForStage) { + public SafeFuture thenWaitFor(final Function> waitForStage) { return thenCompose(t -> waitForStage.apply(t).thenApply(__ -> t)); } @SafeVarargs @SuppressWarnings("unchecked") - public final SafeFuture or(SafeFuture... others) { + public final SafeFuture or(final SafeFuture... others) { SafeFuture[] futures = Arrays.copyOf(others, others.length + 1); futures[others.length] = this; return anyOf(futures).thenApply(o -> (T) o); @@ -773,7 +774,7 @@ public final SafeFuture or(SafeFuture... others) { // The result of anyOf() future is ignored since it is used just to handle completion // of any future. All possible outcomes are propagated to the returned future instance @SuppressWarnings("FutureReturnValueIgnored") - public SafeFuture orInterrupt(Interruptor... interruptors) { + public SafeFuture orInterrupt(final Interruptor... interruptors) { CompletableFuture[] allFuts = new CompletableFuture[interruptors.length + 1]; allFuts[0] = this; for (int i = 0; i < interruptors.length; i++) { @@ -827,7 +828,7 @@ public static class Interruptor { private final Supplier exceptionSupplier; private Interruptor( - CompletableFuture interruptFuture, Supplier exceptionSupplier) { + final CompletableFuture interruptFuture, final Supplier exceptionSupplier) { this.interruptFuture = interruptFuture; this.exceptionSupplier = exceptionSupplier; } diff --git a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/eventthread/AsyncRunnerEventThread.java b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/eventthread/AsyncRunnerEventThread.java index 515452679cb..3e855345c5d 100644 --- a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/eventthread/AsyncRunnerEventThread.java +++ b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/eventthread/AsyncRunnerEventThread.java @@ -43,7 +43,7 @@ public void checkOnEventThread() { } private boolean isEventThread() { - return Thread.currentThread().getId() == eventThreadId; + return Thread.currentThread().threadId() == eventThreadId; } @Override @@ -85,7 +85,7 @@ public SafeFuture execute(final ExceptionThrowingSupplier callable) { @Override @SuppressWarnings("FutureReturnValueIgnored") - public SafeFuture executeFuture(Supplier> task) { + public SafeFuture executeFuture(final Supplier> task) { // Note: started is only set to true after thread has been initialized so if it is true, thread // must be initialized. if (!started.get()) { @@ -125,7 +125,7 @@ private SafeFuture doExecute(final ExceptionThrowingSupplier callable) */ private T recordEventThreadIdAndExecute(final ExceptionThrowingSupplier task) throws Throwable { - eventThreadId = Thread.currentThread().getId(); + eventThreadId = Thread.currentThread().threadId(); try { return task.get(); } finally { diff --git a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/AbstractDelegatingStreamHandler.java b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/AbstractDelegatingStreamHandler.java index 42f90b6e131..c1593b577e1 100644 --- a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/AbstractDelegatingStreamHandler.java +++ b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/AbstractDelegatingStreamHandler.java @@ -17,7 +17,7 @@ abstract class AbstractDelegatingStreamHandler implements AsyncStreamHandl protected final AsyncStreamHandler delegate; - protected AbstractDelegatingStreamHandler(AsyncStreamHandler delegate) { + protected AbstractDelegatingStreamHandler(final AsyncStreamHandler delegate) { this.delegate = delegate; } @@ -27,7 +27,7 @@ public void onComplete() { } @Override - public void onError(Throwable t) { + public void onError(final Throwable t) { delegate.onError(t); } } diff --git a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/AsyncIterator.java b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/AsyncIterator.java index 207ee5aa987..20a8b6fe8ee 100644 --- a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/AsyncIterator.java +++ b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/AsyncIterator.java @@ -18,12 +18,12 @@ abstract class AsyncIterator implements AsyncStream { abstract void iterate(AsyncStreamHandler callback); @Override - public AsyncIterator transform(AsyncStreamTransformer transformer) { + public AsyncIterator transform(final AsyncStreamTransformer transformer) { return new TransformAsyncIterator<>(this, transformer); } @Override - public void consume(AsyncStreamHandler consumer) { + public void consume(final AsyncStreamHandler consumer) { iterate(consumer); } } diff --git a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/AsyncIteratorCollector.java b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/AsyncIteratorCollector.java index c7db0435bf6..f5615451c9a 100644 --- a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/AsyncIteratorCollector.java +++ b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/AsyncIteratorCollector.java @@ -22,25 +22,25 @@ class AsyncIteratorCollector implements AsyncStreamHandler { private final SafeFuture promise = new SafeFuture<>(); - public AsyncIteratorCollector(Collector collector) { + public AsyncIteratorCollector(final Collector collector) { this.collector = collector; this.accumulator = collector.supplier().get(); } @Override - public SafeFuture onNext(T t) { + public SafeFuture onNext(final T t) { collector.accumulator().accept(accumulator, t); return TRUE_FUTURE; } @Override public void onComplete() { - R result = collector.finisher().apply(accumulator); + final R result = collector.finisher().apply(accumulator); promise.complete(result); } @Override - public void onError(Throwable t) { + public void onError(final Throwable t) { promise.completeExceptionally(t); } diff --git a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/AsyncStream.java b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/AsyncStream.java index dee8681eba8..5faff005d4a 100644 --- a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/AsyncStream.java +++ b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/AsyncStream.java @@ -35,70 +35,70 @@ static AsyncStream empty() { return of(); } - static AsyncStream exceptional(Throwable error) { - AsyncStreamPublisher ret = createPublisher(1); + static AsyncStream exceptional(final Throwable error) { + final AsyncStreamPublisher ret = createPublisher(1); ret.onError(error); return ret; } @SafeVarargs - static AsyncStream of(T... elements) { + static AsyncStream of(final T... elements) { return create(List.of(elements).iterator()); } - static AsyncStream create(Stream stream) { + static AsyncStream create(final Stream stream) { return create(stream.iterator()); } - static AsyncStream create(Iterator iterator) { + static AsyncStream create(final Iterator iterator) { return new SyncToAsyncIteratorImpl<>(iterator); } - static AsyncStream create(CompletionStage future) { + static AsyncStream create(final CompletionStage future) { return new FutureAsyncIteratorImpl<>(future); } - static AsyncStreamPublisher createPublisher(int maxBufferSize) { + static AsyncStreamPublisher createPublisher(final int maxBufferSize) { return new BufferingStreamPublisher<>(maxBufferSize); } // transformation - default AsyncStream flatMap(Function> toStreamMapper) { + default AsyncStream flatMap(final Function> toStreamMapper) { return map(toStreamMapper).transform(FlattenStreamHandler::new); } - default AsyncStream map(Function mapper) { + default AsyncStream map(final Function mapper) { return transform(sourceCallback -> new MapStreamHandler<>(sourceCallback, mapper)); } - default AsyncStream filter(Predicate filter) { + default AsyncStream filter(final Predicate filter) { return transform(sourceCallback -> new FilteringStreamHandler<>(sourceCallback, filter)); } - default AsyncStream peek(AsyncStreamVisitor visitor) { + default AsyncStream peek(final AsyncStreamVisitor visitor) { return transform(src -> new VisitorHandler<>(src, visitor)); } - default AsyncStream mapAsync(Function> mapper) { + default AsyncStream mapAsync(final Function> mapper) { return flatMap(e -> AsyncStream.create(mapper.apply(e))); } // slicing - default AsyncStream slice(AsyncStreamSlicer slicer) { + default AsyncStream slice(final AsyncStreamSlicer slicer) { return transform(sourceCallback -> new SliceStreamHandler<>(sourceCallback, slicer)); } - default AsyncStream limit(long count) { + default AsyncStream limit(final long count) { return slice(AsyncStreamSlicer.limit(count)); } - default AsyncStream takeWhile(Predicate whileCondition) { + default AsyncStream takeWhile(final Predicate whileCondition) { return slice(AsyncStreamSlicer.takeWhile(whileCondition)); } - default AsyncStream takeUntil(Predicate untilCondition, boolean includeLast) { + default AsyncStream takeUntil(final Predicate untilCondition, final boolean includeLast) { AsyncStreamSlicer whileSlicer = AsyncStreamSlicer.takeWhile(untilCondition.negate()); AsyncStreamSlicer untilSlicer = includeLast ? whileSlicer.then(AsyncStreamSlicer.limit(1)) : whileSlicer; @@ -107,8 +107,8 @@ default AsyncStream takeUntil(Predicate untilCondition, boolean includeLas // consuming - default SafeFuture collect(Collector collector) { - AsyncIteratorCollector asyncIteratorCollector = + default SafeFuture collect(final Collector collector) { + final AsyncIteratorCollector asyncIteratorCollector = new AsyncIteratorCollector<>(collector); consume(asyncIteratorCollector); return asyncIteratorCollector.getPromise(); @@ -120,11 +120,11 @@ default SafeFuture> findFirst() { .thenApply(l -> l.isEmpty() ? Optional.empty() : Optional.of(l.getFirst())); } - default SafeFuture forEach(Consumer consumer) { + default SafeFuture forEach(final Consumer consumer) { return collect(Collector.of(() -> null, (a, t) -> consumer.accept(t), noCallBinaryOperator())); } - default > SafeFuture collect(C targetCollection) { + default > SafeFuture collect(final C targetCollection) { return collect(Collectors.toCollection(() -> targetCollection)); } @@ -137,7 +137,7 @@ default SafeFuture> findLast() { .thenApply(l -> l.isEmpty() ? Optional.empty() : Optional.of(l.getFirst())); } - default SafeFuture> collectLast(int count) { + default SafeFuture> collectLast(final int count) { return collect(CircularBuf.createCollector(count)); } } diff --git a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/AsyncStreamSlicer.java b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/AsyncStreamSlicer.java index b29249d3bd1..d0165a10e7f 100644 --- a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/AsyncStreamSlicer.java +++ b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/AsyncStreamSlicer.java @@ -28,33 +28,33 @@ enum SliceResult { SKIP_AND_STOP } - SliceResult slice(T element); + SliceResult slice(final T element); - static AsyncStreamSlicer limit(long count) { + static AsyncStreamSlicer limit(final long count) { return new AsyncStreamSlicer<>() { private final AtomicLong remainCount = new AtomicLong(count); @Override - public SliceResult slice(T element) { + public SliceResult slice(final T element) { return remainCount.decrementAndGet() > 0 ? CONTINUE : INCLUDE_AND_STOP; } }; } - static AsyncStreamSlicer takeWhile(Predicate condition) { + static AsyncStreamSlicer takeWhile(final Predicate condition) { return t -> condition.test(t) ? CONTINUE : SKIP_AND_STOP; } - default AsyncStreamSlicer then(AsyncStreamSlicer nextSlicer) { + default AsyncStreamSlicer then(final AsyncStreamSlicer nextSlicer) { return new AsyncStreamSlicer<>() { private boolean thisSlicerCompleted = false; @Override - public SliceResult slice(T element) { + public SliceResult slice(final T element) { if (thisSlicerCompleted) { return nextSlicer.slice(element); } else { - SliceResult result = AsyncStreamSlicer.this.slice(element); + final SliceResult result = AsyncStreamSlicer.this.slice(element); return switch (result) { case CONTINUE -> result; case SKIP_AND_STOP -> { diff --git a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/BufferingStreamPublisher.java b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/BufferingStreamPublisher.java index 93336b0484f..ede7d20600b 100644 --- a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/BufferingStreamPublisher.java +++ b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/BufferingStreamPublisher.java @@ -21,7 +21,7 @@ class BufferingStreamPublisher extends AsyncIterator implements AsyncStrea private boolean isDone = false; - BufferingStreamPublisher(int maxBufferSize) { + BufferingStreamPublisher(final int maxBufferSize) { this.eventQueue = new LimitedAsyncQueue<>(maxBufferSize); } @@ -50,7 +50,7 @@ public boolean isTerminal() { } } - private synchronized void putNext(Event event) { + private synchronized void putNext(final Event event) { if (isDone) { throw new IllegalStateException("Stream has been done already"); } @@ -63,7 +63,7 @@ private SafeFuture> takeNext() { } @Override - void iterate(AsyncStreamHandler delegate) { + void iterate(final AsyncStreamHandler delegate) { SafeFuture.asyncDoWhile( () -> takeNext() @@ -87,7 +87,7 @@ void iterate(AsyncStreamHandler delegate) { } @Override - public SafeFuture onNext(T t) { + public SafeFuture onNext(final T t) { SafeFuture ret = new SafeFuture<>(); try { putNext(new ItemEvent<>(t, ret)); @@ -103,7 +103,7 @@ public void onComplete() { } @Override - public synchronized void onError(Throwable t) { + public synchronized void onError(final Throwable t) { putNext(new ErrorEvent<>(t)); } } diff --git a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/CircularBuf.java b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/CircularBuf.java index 9d71a1d1b2c..7a36fbe77f8 100644 --- a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/CircularBuf.java +++ b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/CircularBuf.java @@ -23,19 +23,19 @@ class CircularBuf { final ArrayDeque buf; final int maxSize; - public CircularBuf(int maxSize) { + public CircularBuf(final int maxSize) { buf = new ArrayDeque<>(maxSize); this.maxSize = maxSize; } - public void add(C t) { + public void add(final C t) { if (buf.size() == maxSize) { buf.removeFirst(); } buf.add(t); } - public static Collector> createCollector(int count) { + public static Collector> createCollector(final int count) { return Collector., List>of( () -> new CircularBuf(count), CircularBuf::add, diff --git a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/FilteringStreamHandler.java b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/FilteringStreamHandler.java index dd6877f328e..f667f05cd3d 100644 --- a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/FilteringStreamHandler.java +++ b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/FilteringStreamHandler.java @@ -20,13 +20,14 @@ class FilteringStreamHandler extends AbstractDelegatingStreamHandler { private final Predicate filter; - protected FilteringStreamHandler(AsyncStreamHandler delegate, Predicate filter) { + protected FilteringStreamHandler( + final AsyncStreamHandler delegate, final Predicate filter) { super(delegate); this.filter = filter; } @Override - public SafeFuture onNext(T t) { + public SafeFuture onNext(final T t) { if (filter.test(t)) { return delegate.onNext(t); } else { diff --git a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/FlattenStreamHandler.java b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/FlattenStreamHandler.java index d3d31662f6e..77c4425645b 100644 --- a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/FlattenStreamHandler.java +++ b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/FlattenStreamHandler.java @@ -18,17 +18,17 @@ class FlattenStreamHandler, T> extends AbstractDelegatingStreamHandler { - protected FlattenStreamHandler(AsyncStreamHandler delegate) { + protected FlattenStreamHandler(final AsyncStreamHandler delegate) { super(delegate); } @Override - public SafeFuture onNext(TCol asyncIterator) { - SafeFuture ret = new SafeFuture<>(); + public SafeFuture onNext(final TCol asyncIterator) { + final SafeFuture ret = new SafeFuture<>(); asyncIterator.consume( new AsyncStreamHandler() { @Override - public SafeFuture onNext(T t) { + public SafeFuture onNext(final T t) { SafeFuture proceedFuture = delegate.onNext(t); return proceedFuture.thenPeek( @@ -45,7 +45,7 @@ public void onComplete() { } @Override - public void onError(Throwable t) { + public void onError(final Throwable t) { ret.complete(false); delegate.onError(t); } diff --git a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/FutureAsyncIteratorImpl.java b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/FutureAsyncIteratorImpl.java index c893e8c5360..cef99249154 100644 --- a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/FutureAsyncIteratorImpl.java +++ b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/FutureAsyncIteratorImpl.java @@ -20,12 +20,12 @@ class FutureAsyncIteratorImpl extends AsyncIterator { private final SafeFuture future; - FutureAsyncIteratorImpl(CompletionStage future) { + FutureAsyncIteratorImpl(final CompletionStage future) { this.future = SafeFuture.of(future); } @Override - public void iterate(AsyncStreamHandler callback) { + public void iterate(final AsyncStreamHandler callback) { future.finish( succ -> callback.onNext(succ).finish(__ -> callback.onComplete(), callback::onError), callback::onError); diff --git a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/LimitedAsyncQueue.java b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/LimitedAsyncQueue.java index 5f0499f0f38..b3a558bfae3 100644 --- a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/LimitedAsyncQueue.java +++ b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/LimitedAsyncQueue.java @@ -25,13 +25,13 @@ class LimitedAsyncQueue implements AsyncQueue { private final Queue items = new ArrayDeque<>(); private final Queue> takers = new ArrayDeque<>(); - public LimitedAsyncQueue(int maxSize) { + public LimitedAsyncQueue(final int maxSize) { this.maxSize = maxSize; } // Adds an item to the queue @Override - public void put(T item) { + public void put(final T item) { final CompletableFuture maybeTaker; synchronized (this) { if (!takers.isEmpty()) { @@ -56,11 +56,11 @@ public void put(T item) { public synchronized SafeFuture take() { if (!items.isEmpty()) { // If items are available, return a completed future - T item = items.poll(); + final T item = items.poll(); return SafeFuture.completedFuture(item); } else { // If no items, create a new CompletableFuture and add it to takers - SafeFuture future = new SafeFuture<>(); + final SafeFuture future = new SafeFuture<>(); takers.offer(future); return future; } diff --git a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/MapStreamHandler.java b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/MapStreamHandler.java index 3a88c771d5a..bc22ec0779d 100644 --- a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/MapStreamHandler.java +++ b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/MapStreamHandler.java @@ -20,13 +20,13 @@ class MapStreamHandler extends AbstractDelegatingStreamHandler { private final Function mapper; - protected MapStreamHandler(AsyncStreamHandler delegate, Function mapper) { + protected MapStreamHandler(final AsyncStreamHandler delegate, final Function mapper) { super(delegate); this.mapper = mapper; } @Override - public SafeFuture onNext(S s) { + public SafeFuture onNext(final S s) { try { return delegate.onNext(mapper.apply(s)); } catch (Exception e) { diff --git a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/SliceStreamHandler.java b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/SliceStreamHandler.java index 50bbf38253c..e8f39ca4f03 100644 --- a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/SliceStreamHandler.java +++ b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/SliceStreamHandler.java @@ -19,13 +19,14 @@ class SliceStreamHandler extends AbstractDelegatingStreamHandler { private final AsyncStreamSlicer slicer; - protected SliceStreamHandler(AsyncStreamHandler delegate, AsyncStreamSlicer slicer) { + protected SliceStreamHandler( + final AsyncStreamHandler delegate, final AsyncStreamSlicer slicer) { super(delegate); this.slicer = slicer; } @Override - public SafeFuture onNext(T t) { + public SafeFuture onNext(final T t) { AsyncStreamSlicer.SliceResult sliceResult = slicer.slice(t); return switch (sliceResult) { case CONTINUE -> delegate.onNext(t); diff --git a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/SyncToAsyncIteratorImpl.java b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/SyncToAsyncIteratorImpl.java index b139b1586f5..5abdb09cab5 100644 --- a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/SyncToAsyncIteratorImpl.java +++ b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/SyncToAsyncIteratorImpl.java @@ -21,12 +21,12 @@ class SyncToAsyncIteratorImpl extends AsyncIterator { private final Iterator iterator; private AsyncStreamHandler callback; - SyncToAsyncIteratorImpl(Iterator iterator) { + SyncToAsyncIteratorImpl(final Iterator iterator) { this.iterator = iterator; } @Override - public void iterate(AsyncStreamHandler callback) { + public void iterate(final AsyncStreamHandler callback) { synchronized (this) { if (this.callback != null) { throw new IllegalStateException("This one-shot iterator has been used already"); @@ -61,7 +61,7 @@ private void next() { } } - private void onNextComplete(boolean shouldContinue) { + private void onNextComplete(final boolean shouldContinue) { if (shouldContinue) { next(); } else { diff --git a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/TransformAsyncIterator.java b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/TransformAsyncIterator.java index d1d4ae75f0a..68bdcdcdfc0 100644 --- a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/TransformAsyncIterator.java +++ b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/TransformAsyncIterator.java @@ -18,13 +18,14 @@ class TransformAsyncIterator extends AsyncIterator { private final AsyncStreamTransformer streamTransformer; public TransformAsyncIterator( - AsyncIterator delegateIterator, AsyncStreamTransformer streamTransformer) { + final AsyncIterator delegateIterator, + final AsyncStreamTransformer streamTransformer) { this.delegateIterator = delegateIterator; this.streamTransformer = streamTransformer; } @Override - public void iterate(AsyncStreamHandler callback) { + public void iterate(final AsyncStreamHandler callback) { delegateIterator.iterate(streamTransformer.process(callback)); } } diff --git a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/VisitorHandler.java b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/VisitorHandler.java index 68d7af1b08c..6e9e9a89f2b 100644 --- a/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/VisitorHandler.java +++ b/infrastructure/async/src/main/java/tech/pegasys/teku/infrastructure/async/stream/VisitorHandler.java @@ -18,7 +18,7 @@ class VisitorHandler extends AbstractDelegatingStreamHandler { private final AsyncStreamVisitor visitor; - public VisitorHandler(AsyncStreamHandler delegate, AsyncStreamVisitor visitor) { + public VisitorHandler(final AsyncStreamHandler delegate, final AsyncStreamVisitor visitor) { super(delegate); this.visitor = visitor; } @@ -30,13 +30,13 @@ public void onComplete() { } @Override - public void onError(Throwable t) { + public void onError(final Throwable t) { visitor.onError(t); delegate.onError(t); } @Override - public SafeFuture onNext(T t) { + public SafeFuture onNext(final T t) { visitor.onNext(t); return delegate.onNext(t); } diff --git a/infrastructure/async/src/test/java/tech/pegasys/teku/infrastructure/async/AsyncRunnerFactoryTest.java b/infrastructure/async/src/test/java/tech/pegasys/teku/infrastructure/async/AsyncRunnerFactoryTest.java index bf113b1e656..2c558fef55b 100644 --- a/infrastructure/async/src/test/java/tech/pegasys/teku/infrastructure/async/AsyncRunnerFactoryTest.java +++ b/infrastructure/async/src/test/java/tech/pegasys/teku/infrastructure/async/AsyncRunnerFactoryTest.java @@ -19,11 +19,14 @@ class AsyncRunnerFactoryTest { - private AsyncRunnerFactory asyncRunnerFactory = + private final AsyncRunnerFactory asyncRunnerFactory = new AsyncRunnerFactory() { @Override public AsyncRunner create( - String name, int maxThreads, int maxQueueSize, int threadPriority) { + final String name, + final int maxThreads, + final int maxQueueSize, + final int threadPriority) { return null; } @@ -33,7 +36,7 @@ public void shutdown() {} @ParameterizedTest @ValueSource(strings = {"correctname", "correctNAME", "correct_name", "correct_name__"}) - public void mustAcceptValidMetricNames(String asyncRunnerName) { + public void mustAcceptValidMetricNames(final String asyncRunnerName) { asyncRunnerFactory.validateAsyncRunnerName(asyncRunnerName); } @@ -47,7 +50,7 @@ public void mustAcceptValidMetricNames(String asyncRunnerName) { "$incorrect_name", "incorrect-name" }) - public void mustRejectInvalidMetricNames(String asyncRunnerName) { + public void mustRejectInvalidMetricNames(final String asyncRunnerName) { Assertions.assertThrows( IllegalArgumentException.class, () -> asyncRunnerFactory.validateAsyncRunnerName(asyncRunnerName)); diff --git a/infrastructure/async/src/test/java/tech/pegasys/teku/infrastructure/async/OccurrenceCounterTest.java b/infrastructure/async/src/test/java/tech/pegasys/teku/infrastructure/async/OccurrenceCounterTest.java index fe19b7f2599..602a353de1b 100644 --- a/infrastructure/async/src/test/java/tech/pegasys/teku/infrastructure/async/OccurrenceCounterTest.java +++ b/infrastructure/async/src/test/java/tech/pegasys/teku/infrastructure/async/OccurrenceCounterTest.java @@ -71,7 +71,7 @@ void shouldCalculateNextSlot() { } } - void incrementAllSlots(int value) { + void incrementAllSlots(final int value) { for (int i = 0; i < 10; i++) { for (int j = 0; j < value; j++) { counter.increment(); diff --git a/infrastructure/async/src/test/java/tech/pegasys/teku/infrastructure/async/SafeFutureTest.java b/infrastructure/async/src/test/java/tech/pegasys/teku/infrastructure/async/SafeFutureTest.java index 31fc8ba8f68..196e66e9a74 100644 --- a/infrastructure/async/src/test/java/tech/pegasys/teku/infrastructure/async/SafeFutureTest.java +++ b/infrastructure/async/src/test/java/tech/pegasys/teku/infrastructure/async/SafeFutureTest.java @@ -41,7 +41,7 @@ public class SafeFutureTest { private static class TestAsyncExec { - SafeFuture fut = new SafeFuture<>(); + final SafeFuture fut = new SafeFuture<>(); boolean executed = false; SafeFuture exec() { @@ -51,17 +51,17 @@ SafeFuture exec() { } private static class InterruptTest { - SafeFuture interruptorFut1 = new SafeFuture<>(); - SafeFuture interruptorFut2 = new SafeFuture<>(); - Interruptor interruptor1 = + final SafeFuture interruptorFut1 = new SafeFuture<>(); + final SafeFuture interruptorFut2 = new SafeFuture<>(); + final Interruptor interruptor1 = SafeFuture.createInterruptor(interruptorFut1, IllegalStateException::new); - Interruptor interruptor2 = + final Interruptor interruptor2 = SafeFuture.createInterruptor(interruptorFut2, IllegalArgumentException::new); - SafeFuture fut0 = new SafeFuture<>(); - TestAsyncExec exec1 = new TestAsyncExec(); - TestAsyncExec exec2 = new TestAsyncExec(); + final SafeFuture fut0 = new SafeFuture<>(); + final TestAsyncExec exec1 = new TestAsyncExec(); + final TestAsyncExec exec2 = new TestAsyncExec(); - SafeFuture intFut = + final SafeFuture intFut = fut0.orInterrupt(interruptor1, interruptor2) .thenCompose(__ -> exec1.exec()) .orInterrupt(interruptor1, interruptor2) @@ -704,7 +704,7 @@ void collectAll_shouldFailWhenAnyFutureFails() { assertThatSafeFuture(result).isCompletedExceptionallyWith(exception); } - private static boolean hasDependents(CompletableFuture fut) { + private static boolean hasDependents(final CompletableFuture fut) { return fut.getNumberOfDependents() > 0; } diff --git a/infrastructure/async/src/test/java/tech/pegasys/teku/infrastructure/async/ThrottlingTaskQueueTest.java b/infrastructure/async/src/test/java/tech/pegasys/teku/infrastructure/async/ThrottlingTaskQueueTest.java index 984d715ec52..27805d52ce2 100644 --- a/infrastructure/async/src/test/java/tech/pegasys/teku/infrastructure/async/ThrottlingTaskQueueTest.java +++ b/infrastructure/async/src/test/java/tech/pegasys/teku/infrastructure/async/ThrottlingTaskQueueTest.java @@ -16,7 +16,6 @@ import static org.assertj.core.api.Assertions.assertThat; import java.util.List; -import java.util.stream.Collectors; import java.util.stream.IntStream; import org.junit.jupiter.api.Test; import tech.pegasys.teku.infrastructure.metrics.StubMetricsSystem; @@ -48,7 +47,7 @@ public void throttlesRequests() { }); return taskQueue.queueTask(() -> request); }) - .collect(Collectors.toList()); + .toList(); assertThat(getQueuedTasksGaugeValue()).isEqualTo(97); assertThat(taskQueue.getInflightTaskCount()).isEqualTo(3); diff --git a/infrastructure/async/src/test/java/tech/pegasys/teku/infrastructure/async/ThrottlingTaskQueueWithPriorityTest.java b/infrastructure/async/src/test/java/tech/pegasys/teku/infrastructure/async/ThrottlingTaskQueueWithPriorityTest.java index cbd42bcbdf2..fdea5eebc16 100644 --- a/infrastructure/async/src/test/java/tech/pegasys/teku/infrastructure/async/ThrottlingTaskQueueWithPriorityTest.java +++ b/infrastructure/async/src/test/java/tech/pegasys/teku/infrastructure/async/ThrottlingTaskQueueWithPriorityTest.java @@ -17,7 +17,6 @@ import java.util.List; import java.util.concurrent.atomic.AtomicBoolean; -import java.util.stream.Collectors; import java.util.stream.IntStream; import org.junit.jupiter.api.Test; import tech.pegasys.teku.infrastructure.metrics.StubMetricsSystem; @@ -53,7 +52,7 @@ public void throttlesRequests() { } return taskQueue.queueTask(() -> request); }) - .collect(Collectors.toList()); + .toList(); assertThat(getQueuedTasksGaugeValue(true)).isEqualTo(33); assertThat(getQueuedTasksGaugeValue(false)).isEqualTo(64); diff --git a/infrastructure/async/src/test/java/tech/pegasys/teku/infrastructure/async/timed/RepeatingTaskSchedulerTest.java b/infrastructure/async/src/test/java/tech/pegasys/teku/infrastructure/async/timed/RepeatingTaskSchedulerTest.java index 0a099db4b6f..e5538f18c52 100644 --- a/infrastructure/async/src/test/java/tech/pegasys/teku/infrastructure/async/timed/RepeatingTaskSchedulerTest.java +++ b/infrastructure/async/src/test/java/tech/pegasys/teku/infrastructure/async/timed/RepeatingTaskSchedulerTest.java @@ -40,7 +40,7 @@ private enum SchedulerType { @ParameterizedTest @EnumSource(SchedulerType.class) - void shouldExecuteEventImmediatelyWhenAlreadyDue(SchedulerType type) { + void shouldExecuteEventImmediatelyWhenAlreadyDue(final SchedulerType type) { scheduleRepeatingEvent(type, getTime(type), UInt64.valueOf(12), action); verify(action).execute(getTime(type), getTime(type)); } @@ -48,7 +48,7 @@ void shouldExecuteEventImmediatelyWhenAlreadyDue(SchedulerType type) { @ParameterizedTest @EnumSource(SchedulerType.class) void shouldExecuteEventImmediatelyMultipleTimesWhenMultipleRepeatsAreAlreadyDue( - SchedulerType type) { + final SchedulerType type) { scheduleRepeatingEvent(type, getTime(type).minus(24), UInt64.valueOf(12), action); verify(action).execute(getTime(type).minus(24), getTime(type)); verify(action).execute(getTime(type).minus(12), getTime(type)); @@ -57,7 +57,7 @@ void shouldExecuteEventImmediatelyMultipleTimesWhenMultipleRepeatsAreAlreadyDue( @ParameterizedTest @EnumSource(SchedulerType.class) - void shouldDelayExecutionUntilEventIsDue(SchedulerType type) { + void shouldDelayExecutionUntilEventIsDue(final SchedulerType type) { scheduleRepeatingEvent(type, getTime(type).plus(100), UInt64.valueOf(12), action); asyncRunner.executeDueActionsRepeatedly(); @@ -75,7 +75,7 @@ void shouldDelayExecutionUntilEventIsDue(SchedulerType type) { @ParameterizedTest @EnumSource(SchedulerType.class) - void shouldExecuteEventAgainAfterRepeatPeriod(SchedulerType type) { + void shouldExecuteEventAgainAfterRepeatPeriod(final SchedulerType type) { final UInt64 repeatPeriod = UInt64.valueOf(12); // Action executes immediately scheduleRepeatingEvent(type, getTime(type), repeatPeriod, action); @@ -89,7 +89,7 @@ void shouldExecuteEventAgainAfterRepeatPeriod(SchedulerType type) { @ParameterizedTest @EnumSource(SchedulerType.class) - void shouldInterleaveMultipleRepeatingEvents(SchedulerType type) { + void shouldInterleaveMultipleRepeatingEvents(final SchedulerType type) { final RepeatingTask secondAction = mock(RepeatingTask.class); scheduleRepeatingEvent(type, getTime(type), UInt64.valueOf(6), action); scheduleRepeatingEvent(type, getTime(type), UInt64.valueOf(5), secondAction); @@ -114,7 +114,7 @@ void shouldInterleaveMultipleRepeatingEvents(SchedulerType type) { @ParameterizedTest @EnumSource(SchedulerType.class) - void shouldReportScheduledAndActualExecutionTimeWhenTaskIsDelayed(SchedulerType type) { + void shouldReportScheduledAndActualExecutionTimeWhenTaskIsDelayed(final SchedulerType type) { final UInt64 scheduledTime = getTime(type).minus(5); scheduleRepeatingEvent(type, scheduledTime, UInt64.valueOf(10), action); @@ -123,10 +123,10 @@ void shouldReportScheduledAndActualExecutionTimeWhenTaskIsDelayed(SchedulerType } private void scheduleRepeatingEvent( - SchedulerType schedulerType, - UInt64 initialInvocationTime, - UInt64 repeatingPeriod, - RepeatingTask task) { + final SchedulerType schedulerType, + final UInt64 initialInvocationTime, + final UInt64 repeatingPeriod, + final RepeatingTask task) { if (schedulerType == SchedulerType.SECONDS) { eventQueue.scheduleRepeatingEvent(initialInvocationTime, repeatingPeriod, task); } else { @@ -134,13 +134,13 @@ private void scheduleRepeatingEvent( } } - private UInt64 getTime(SchedulerType schedulerType) { + private UInt64 getTime(final SchedulerType schedulerType) { return schedulerType == SchedulerType.SECONDS ? timeProvider.getTimeInSeconds() : timeProvider.getTimeInMillis(); } - private void advanceTimeBy(SchedulerType schedulerType, long time) { + private void advanceTimeBy(final SchedulerType schedulerType, final long time) { if (schedulerType == SchedulerType.SECONDS) { timeProvider.advanceTimeBySeconds(time); } else { diff --git a/infrastructure/async/src/testFixtures/java/tech/pegasys/teku/infrastructure/async/DelayedExecutorAsyncRunner.java b/infrastructure/async/src/testFixtures/java/tech/pegasys/teku/infrastructure/async/DelayedExecutorAsyncRunner.java index 365cef3798e..2e4c5ababb5 100644 --- a/infrastructure/async/src/testFixtures/java/tech/pegasys/teku/infrastructure/async/DelayedExecutorAsyncRunner.java +++ b/infrastructure/async/src/testFixtures/java/tech/pegasys/teku/infrastructure/async/DelayedExecutorAsyncRunner.java @@ -30,7 +30,7 @@ public class DelayedExecutorAsyncRunner implements AsyncRunner { private static final Logger LOG = LogManager.getLogger(); private final ExecutorFactory executorFactory; - private DelayedExecutorAsyncRunner(ExecutorFactory executorFactory) { + private DelayedExecutorAsyncRunner(final ExecutorFactory executorFactory) { this.executorFactory = executorFactory; } @@ -46,7 +46,7 @@ public SafeFuture runAsync(final ExceptionThrowingFutureSupplier actio @Override public SafeFuture runAfterDelay( - ExceptionThrowingFutureSupplier action, Duration delay) { + final ExceptionThrowingFutureSupplier action, final Duration delay) { final Executor executor = getDelayedExecutor(delay.toMillis(), TimeUnit.MILLISECONDS); return runAsync(action, executor); } @@ -72,7 +72,7 @@ private Executor getAsyncExecutor() { return getDelayedExecutor(-1, TimeUnit.SECONDS); } - private Executor getDelayedExecutor(long delayAmount, TimeUnit delayUnit) { + private Executor getDelayedExecutor(final long delayAmount, final TimeUnit delayUnit) { return executorFactory.create(delayAmount, delayUnit); } diff --git a/infrastructure/async/src/testFixtures/java/tech/pegasys/teku/infrastructure/async/StubAsyncRunner.java b/infrastructure/async/src/testFixtures/java/tech/pegasys/teku/infrastructure/async/StubAsyncRunner.java index 9ee9829c071..b13d321fe41 100644 --- a/infrastructure/async/src/testFixtures/java/tech/pegasys/teku/infrastructure/async/StubAsyncRunner.java +++ b/infrastructure/async/src/testFixtures/java/tech/pegasys/teku/infrastructure/async/StubAsyncRunner.java @@ -62,7 +62,7 @@ private SafeFuture schedule( @Override public SafeFuture runAfterDelay( - ExceptionThrowingFutureSupplier action, Duration delay) { + final ExceptionThrowingFutureSupplier action, final Duration delay) { return schedule(action, timeProvider.getTimeInMillis().longValue() + delay.toMillis()); } @@ -77,7 +77,7 @@ public void executeQueuedActions() { actionsToExecute.forEach(Task::run); } - public void executeQueuedActions(int limit) { + public void executeQueuedActions(final int limit) { final List actionsToExecute = new ArrayList<>(); for (int i = 0; i < limit && !queuedActions.isEmpty(); i++) { actionsToExecute.add(queuedActions.remove()); diff --git a/infrastructure/async/src/testFixtures/java/tech/pegasys/teku/infrastructure/async/Waiter.java b/infrastructure/async/src/testFixtures/java/tech/pegasys/teku/infrastructure/async/Waiter.java index a2ca25b7a17..0e06224a15e 100644 --- a/infrastructure/async/src/testFixtures/java/tech/pegasys/teku/infrastructure/async/Waiter.java +++ b/infrastructure/async/src/testFixtures/java/tech/pegasys/teku/infrastructure/async/Waiter.java @@ -77,7 +77,7 @@ public interface Condition { } public static void ensureConditionRemainsMet( - final Condition condition, int waitTimeInMilliseconds) throws InterruptedException { + final Condition condition, final int waitTimeInMilliseconds) throws InterruptedException { final long mustBeTrueUntil = System.currentTimeMillis() + waitTimeInMilliseconds; while (System.currentTimeMillis() < mustBeTrueUntil) { try { diff --git a/infrastructure/bls-keystore/build.gradle b/infrastructure/bls-keystore/build.gradle index 7507f4ea06e..23b7d8d4612 100644 --- a/infrastructure/bls-keystore/build.gradle +++ b/infrastructure/bls-keystore/build.gradle @@ -18,8 +18,8 @@ dependencies { implementation 'org.bouncycastle:bcprov-jdk18on' implementation 'com.google.guava:guava' implementation 'org.apache.logging.log4j:log4j-api' - implementation 'org.apache.tuweni:tuweni-bytes' - implementation 'org.apache.tuweni:tuweni-crypto' + implementation 'io.tmio:tuweni-bytes' + implementation 'io.tmio:tuweni-crypto' testImplementation 'org.assertj:assertj-core' testImplementation 'org.junit.jupiter:junit-jupiter-engine' diff --git a/infrastructure/bls-keystore/src/main/java/tech/pegasys/teku/bls/keystore/KeyStore.java b/infrastructure/bls-keystore/src/main/java/tech/pegasys/teku/bls/keystore/KeyStore.java index 02ef1c13b74..5a1dd5fe33b 100644 --- a/infrastructure/bls-keystore/src/main/java/tech/pegasys/teku/bls/keystore/KeyStore.java +++ b/infrastructure/bls-keystore/src/main/java/tech/pegasys/teku/bls/keystore/KeyStore.java @@ -146,7 +146,7 @@ private static Bytes calculateSHA256Checksum( private static Bytes applyCipherFunction( final Bytes decryptionKey, final Cipher cipher, - boolean encryptMode, + final boolean encryptMode, final byte[] inputMessage) { // aes-128-ctr needs first 16 bytes for its key. The 2nd 16 bytes are used to create checksum final SecretKeySpec secretKey = diff --git a/infrastructure/bls-keystore/src/main/java/tech/pegasys/teku/bls/keystore/KeyStoreBytesModule.java b/infrastructure/bls-keystore/src/main/java/tech/pegasys/teku/bls/keystore/KeyStoreBytesModule.java index 6ab17613e43..c8c05ec4f6a 100644 --- a/infrastructure/bls-keystore/src/main/java/tech/pegasys/teku/bls/keystore/KeyStoreBytesModule.java +++ b/infrastructure/bls-keystore/src/main/java/tech/pegasys/teku/bls/keystore/KeyStoreBytesModule.java @@ -45,7 +45,8 @@ public KeyStoreBytesModule() { private static class BytesSerializer extends JsonSerializer { @Override - public void serialize(Bytes bytes, JsonGenerator jGen, SerializerProvider serializerProvider) + public void serialize( + final Bytes bytes, final JsonGenerator jGen, final SerializerProvider serializerProvider) throws IOException { // write bytes in hex without 0x jGen.writeString(bytes.appendHexTo(new StringBuilder()).toString()); @@ -54,14 +55,16 @@ public void serialize(Bytes bytes, JsonGenerator jGen, SerializerProvider serial private static class BytesDeserializer extends JsonDeserializer { @Override - public Bytes deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { + public Bytes deserialize(final JsonParser p, final DeserializationContext ctxt) + throws IOException { return Bytes.fromHexString(p.getValueAsString()); } } private static class Bytes32Serializer extends JsonSerializer { @Override - public void serialize(Bytes32 bytes, JsonGenerator jGen, SerializerProvider serializerProvider) + public void serialize( + final Bytes32 bytes, final JsonGenerator jGen, final SerializerProvider serializerProvider) throws IOException { // write bytes in hex without 0x jGen.writeString(bytes.appendHexTo(new StringBuilder()).toString()); @@ -70,7 +73,8 @@ public void serialize(Bytes32 bytes, JsonGenerator jGen, SerializerProvider seri private static class Bytes32Deserializer extends JsonDeserializer { @Override - public Bytes32 deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { + public Bytes32 deserialize(final JsonParser p, final DeserializationContext ctxt) + throws IOException { return Bytes32.fromHexString(p.getValueAsString()); } } diff --git a/infrastructure/bls-keystore/src/main/java/tech/pegasys/teku/bls/keystore/model/SCryptParam.java b/infrastructure/bls-keystore/src/main/java/tech/pegasys/teku/bls/keystore/model/SCryptParam.java index 9296ec397b7..e64f50307a7 100644 --- a/infrastructure/bls-keystore/src/main/java/tech/pegasys/teku/bls/keystore/model/SCryptParam.java +++ b/infrastructure/bls-keystore/src/main/java/tech/pegasys/teku/bls/keystore/model/SCryptParam.java @@ -129,7 +129,7 @@ public String toString() { .toString(); } - private static boolean isPowerOf2(int x) { + private static boolean isPowerOf2(final int x) { return ((x & (x - 1)) == 0); } } diff --git a/infrastructure/bls/build.gradle b/infrastructure/bls/build.gradle index a4631dbbee4..25d40259232 100644 --- a/infrastructure/bls/build.gradle +++ b/infrastructure/bls/build.gradle @@ -1,12 +1,12 @@ dependencies { api 'org.bouncycastle:bcprov-jdk18on' - implementation 'org.apache.tuweni:tuweni-bytes' - implementation 'org.apache.tuweni:tuweni-ssz' + implementation 'io.tmio:tuweni-bytes' + implementation 'io.tmio:tuweni-ssz' implementation 'commons-io:commons-io' implementation 'tech.pegasys:jblst' implementation project(':infrastructure:crypto') implementation project(':infrastructure:logging') - testFixturesImplementation 'org.apache.tuweni:tuweni-bytes' + testFixturesImplementation 'io.tmio:tuweni-bytes' } diff --git a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLS.java b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLS.java index ccaece7ad00..94e6b32cfbc 100644 --- a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLS.java +++ b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLS.java @@ -41,13 +41,14 @@ public class BLS { private static final Logger LOG = LogManager.getLogger(); + @SuppressWarnings("NonFinalStaticField") private static BLS12381 blsImpl; static { resetBlsImplementation(); } - public static void setBlsImplementation(BLS12381 blsImpl) { + public static void setBlsImplementation(final BLS12381 blsImpl) { BLS.blsImpl = blsImpl; } @@ -73,7 +74,7 @@ public static void resetBlsImplementation() { * @param message The message to sign, not null * @return The Signature, not null */ - public static BLSSignature sign(BLSSecretKey secretKey, Bytes message) { + public static BLSSignature sign(final BLSSecretKey secretKey, final Bytes message) { return new BLSSignature(secretKey.getSecretKey().sign(message)); } @@ -87,7 +88,8 @@ public static BLSSignature sign(BLSSecretKey secretKey, Bytes message) { * @param signature The signature, not null * @return True if the verification is successful, false otherwise. */ - public static boolean verify(BLSPublicKey publicKey, Bytes message, BLSSignature signature) { + public static boolean verify( + final BLSPublicKey publicKey, final Bytes message, final BLSSignature signature) { if (BLSConstants.verificationDisabled) { LOG.warn("Skipping bls verification."); return true; @@ -112,7 +114,7 @@ public static boolean verify(BLSPublicKey publicKey, Bytes message, BLSSignature * @return the aggregated signature * @throws BlsException if any of supplied signatures is invalid */ - public static BLSSignature aggregate(List signatures) throws BlsException { + public static BLSSignature aggregate(final List signatures) throws BlsException { try { checkArgument(signatures.size() > 0, "Aggregating zero signatures is invalid."); return new BLSSignature( @@ -140,7 +142,9 @@ public static BLSSignature aggregate(List signatures) throws BlsEx * @return True if the verification is successful, false otherwise */ public static boolean aggregateVerify( - List publicKeys, List messages, BLSSignature signature) { + final List publicKeys, + final List messages, + final BLSSignature signature) { try { checkArgument( publicKeys.size() == messages.size(), @@ -179,7 +183,7 @@ public static boolean aggregateVerify( * @return True if the verification is successful, false otherwise */ public static boolean fastAggregateVerify( - List publicKeys, Bytes message, BLSSignature signature) { + final List publicKeys, final Bytes message, final BLSSignature signature) { if (BLSConstants.verificationDisabled) { LOG.warn("Skipping bls verification."); return true; @@ -224,7 +228,9 @@ public static boolean fastAggregateVerify( * @return True if the verification is successful, false otherwise */ public static boolean batchVerify( - List> publicKeys, List messages, List signatures) { + final List> publicKeys, + final List messages, + final List signatures) { try { checkArgument( publicKeys.size() == messages.size() && publicKeys.size() == signatures.size(), @@ -267,11 +273,11 @@ public static boolean batchVerify( * @return True if the verification is successful, false otherwise */ public static boolean batchVerify( - List> publicKeys, - List messages, - List signatures, - boolean doublePairing, - boolean parallel) { + final List> publicKeys, + final List messages, + final List signatures, + final boolean doublePairing, + final boolean parallel) { if (BLSConstants.verificationDisabled) { LOG.warn("Skipping bls verification."); return true; @@ -345,7 +351,10 @@ public static boolean batchVerify( * #completeBatchVerify(List)} */ public static BatchSemiAggregate prepareBatchVerify( - int index, List publicKeys, Bytes message, BLSSignature signature) { + final int index, + final List publicKeys, + final Bytes message, + final BLSSignature signature) { try { return getBlsImpl() .prepareBatchVerify( @@ -366,13 +375,13 @@ public static BatchSemiAggregate prepareBatchVerify( * #prepareBatchVerify(int, List, Bytes, BLSSignature)} */ private static BatchSemiAggregate prepareBatchVerify2( - int index, - List publicKeys1, - Bytes message1, - BLSSignature signature1, - List publicKeys2, - Bytes message2, - BLSSignature signature2) { + final int index, + final List publicKeys1, + final Bytes message1, + final BLSSignature signature1, + final List publicKeys2, + final Bytes message2, + final BLSSignature signature2) { try { return getBlsImpl() .prepareBatchVerify2( @@ -395,7 +404,7 @@ private static BatchSemiAggregate prepareBatchVerify2( * * @return True if the verification is successful, false otherwise */ - public static boolean completeBatchVerify(List preparedSignatures) { + public static boolean completeBatchVerify(final List preparedSignatures) { if (BLSConstants.verificationDisabled) { LOG.warn("Skipping bls verification."); return true; @@ -415,7 +424,8 @@ public static boolean completeBatchVerify(List preparedSigna * @param dst domain separation tag (DST), not null * @return The Signature, not null */ - public static BLSSignature sign(BLSSecretKey secretKey, Bytes message, String dst) { + public static BLSSignature sign( + final BLSSecretKey secretKey, final Bytes message, final String dst) { return new BLSSignature(secretKey.getSecretKey().sign(message, dst)); } @@ -429,7 +439,10 @@ public static BLSSignature sign(BLSSecretKey secretKey, Bytes message, String ds * @return True if the verification is successful, false otherwise. */ public static boolean verify( - BLSPublicKey publicKey, Bytes message, BLSSignature signature, String dst) { + final BLSPublicKey publicKey, + final Bytes message, + final BLSSignature signature, + final String dst) { if (BLSConstants.verificationDisabled) { LOG.warn("Skipping bls verification."); return true; diff --git a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLSConstants.java b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLSConstants.java index 352825f5e00..6bcce332e43 100644 --- a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLSConstants.java +++ b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLSConstants.java @@ -27,6 +27,7 @@ public class BLSConstants { static final BigInteger CURVE_ORDER_BI = CURVE_ORDER_BYTES.toUnsignedBigInteger(ByteOrder.BIG_ENDIAN); + @SuppressWarnings("NonFinalStaticField") public static boolean verificationDisabled = false; public static void disableBLSVerification() { diff --git a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLSKeyPair.java b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLSKeyPair.java index 30d21793981..6d146bdf26a 100644 --- a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLSKeyPair.java +++ b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLSKeyPair.java @@ -40,7 +40,7 @@ public static BLSKeyPair random(final SecureRandom srng) { * @param publicKey a BLS public key * @param secretKey a BLS secret key */ - public BLSKeyPair(BLSPublicKey publicKey, BLSSecretKey secretKey) { + public BLSKeyPair(final BLSPublicKey publicKey, final BLSSecretKey secretKey) { this.publicKey = publicKey; this.secretKey = secretKey; } @@ -50,7 +50,7 @@ public BLSKeyPair(BLSPublicKey publicKey, BLSSecretKey secretKey) { * * @param secretKey a BLS secret key */ - public BLSKeyPair(BLSSecretKey secretKey) { + public BLSKeyPair(final BLSSecretKey secretKey) { this(new BLSPublicKey(secretKey), secretKey); } @@ -59,7 +59,7 @@ public BLSKeyPair(BLSSecretKey secretKey) { * * @param keyPair an implementation-specific key pair */ - private BLSKeyPair(KeyPair keyPair) { + private BLSKeyPair(final KeyPair keyPair) { this(new BLSPublicKey(keyPair.getPublicKey()), new BLSSecretKey(keyPair.getSecretKey())); } diff --git a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLSPublicKey.java b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLSPublicKey.java index b2d6dd9eb09..d04c23b6c8b 100644 --- a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLSPublicKey.java +++ b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLSPublicKey.java @@ -48,13 +48,13 @@ public static BLSPublicKey fromHexString(final String hexString) { * @param publicKeys The list of public keys to aggregate * @return PublicKey The public key */ - public static BLSPublicKey aggregate(List publicKeys) { + public static BLSPublicKey aggregate(final List publicKeys) { return new BLSPublicKey( BLS.getBlsImpl() .aggregatePublicKeys(publicKeys.stream().map(BLSPublicKey::getPublicKey).toList())); } - public static BLSPublicKey fromSSZBytes(Bytes bytes) { + public static BLSPublicKey fromSSZBytes(final Bytes bytes) { checkArgument( bytes.size() == SSZ_BLS_PUBKEY_SIZE, "Expected " + SSZ_BLS_PUBKEY_SIZE + " bytes but received %s.", @@ -76,11 +76,12 @@ public static BLSPublicKey fromSSZBytes(Bytes bytes) { * but throw on later usage. Use {@link BLSPublicKey#fromBytesCompressedValidate(Bytes48)} if * need to immediately ensure input validity */ - public static BLSPublicKey fromBytesCompressed(Bytes48 bytes) throws IllegalArgumentException { + public static BLSPublicKey fromBytesCompressed(final Bytes48 bytes) + throws IllegalArgumentException { return new BLSPublicKey(bytes); } - public static BLSPublicKey fromBytesCompressedValidate(Bytes48 bytes) + public static BLSPublicKey fromBytesCompressedValidate(final Bytes48 bytes) throws IllegalArgumentException { BLSPublicKey ret = new BLSPublicKey(bytes); ret.getPublicKey().forceValidation(); @@ -99,7 +100,7 @@ public static BLSPublicKey fromBytesCompressedValidate(Bytes48 bytes) * * @param secretKey A BLSSecretKey */ - public BLSPublicKey(BLSSecretKey secretKey) { + public BLSPublicKey(final BLSSecretKey secretKey) { this(secretKey.getSecretKey().derivePublicKey()); } @@ -108,17 +109,18 @@ public BLSPublicKey(BLSSecretKey secretKey) { * * @param publicKey An implementation-specific PublicKey */ - BLSPublicKey(PublicKey publicKey) { + BLSPublicKey(final PublicKey publicKey) { this(() -> publicKey, Suppliers.memoize(publicKey::toBytesCompressed)); } - BLSPublicKey(Bytes48 bytesCompressed) { + BLSPublicKey(final Bytes48 bytesCompressed) { this( Suppliers.memoize(() -> BLS.getBlsImpl().publicKeyFromCompressed(bytesCompressed)), () -> bytesCompressed); } - private BLSPublicKey(Supplier publicKey, Supplier bytesCompressed) { + private BLSPublicKey( + final Supplier publicKey, final Supplier bytesCompressed) { this.publicKey = publicKey; this.bytesCompressed = bytesCompressed; } @@ -162,7 +164,7 @@ public String toString() { } @Override - public boolean equals(Object obj) { + public boolean equals(final Object obj) { if (Objects.isNull(obj)) { return false; } diff --git a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLSSecretKey.java b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLSSecretKey.java index f1f455c45ac..78f5f307321 100644 --- a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLSSecretKey.java +++ b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLSSecretKey.java @@ -27,7 +27,7 @@ public final class BLSSecretKey { * @param bytes Should be in range [0, ) * @throws IllegalArgumentException if bytes are not in the valid range */ - public static BLSSecretKey fromBytes(Bytes32 bytes) throws IllegalArgumentException { + public static BLSSecretKey fromBytes(final Bytes32 bytes) throws IllegalArgumentException { if (bytes.compareTo(BLSConstants.CURVE_ORDER_BYTES) >= 0) { throw new IllegalArgumentException( "Invalid bytes for secret key (0 <= SK < r, where r is " @@ -39,7 +39,7 @@ public static BLSSecretKey fromBytes(Bytes32 bytes) throws IllegalArgumentExcept } } - static BLSSecretKey fromBytesModR(Bytes32 secretKeyBytes) { + static BLSSecretKey fromBytesModR(final Bytes32 secretKeyBytes) { final Bytes32 keyBytes; if (secretKeyBytes.compareTo(BLSConstants.CURVE_ORDER_BYTES) >= 0) { BigInteger validSK = @@ -53,14 +53,14 @@ static BLSSecretKey fromBytesModR(Bytes32 secretKeyBytes) { return fromBytes(keyBytes); } - private SecretKey secretKey; + private final SecretKey secretKey; /** * Construct from an implementation-specific SecretKey object. * * @param secretKey An implementation-specific SecretKey */ - public BLSSecretKey(SecretKey secretKey) { + public BLSSecretKey(final SecretKey secretKey) { this.secretKey = secretKey; } diff --git a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLSSignature.java b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLSSignature.java index f4ba0d004a2..213068b8e81 100644 --- a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLSSignature.java +++ b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLSSignature.java @@ -51,11 +51,11 @@ public static BLSSignature infinity() { return BLSSignature.fromBytesCompressed(INFINITY_BYTES); } - public static BLSSignature fromBytesCompressed(Bytes bytes) { + public static BLSSignature fromBytesCompressed(final Bytes bytes) { return new BLSSignature(bytes); } - public static BLSSignature fromSSZBytes(Bytes bytes) { + public static BLSSignature fromSSZBytes(final Bytes bytes) { try { return SSZ.decode( bytes, reader -> new BLSSignature(reader.readFixedBytes(SSZ_BLS_SIGNATURE_SIZE))); @@ -76,17 +76,17 @@ public static BLSSignature fromSSZBytes(Bytes bytes) { * * @param signature An implementation-specific Signature */ - BLSSignature(Signature signature) { + BLSSignature(final Signature signature) { this(() -> signature, Suppliers.memoize(signature::toBytesCompressed)); } - BLSSignature(Bytes signatureBytes) { + BLSSignature(final Bytes signatureBytes) { this( Suppliers.memoize(() -> BLS.getBlsImpl().signatureFromCompressed(signatureBytes)), () -> signatureBytes); } - private BLSSignature(Supplier signature, Supplier bytesCompressed) { + private BLSSignature(final Supplier signature, final Supplier bytesCompressed) { this.signature = signature; this.bytesCompressed = bytesCompressed; } @@ -138,7 +138,7 @@ public int hashCode() { } @Override - public boolean equals(Object obj) { + public boolean equals(final Object obj) { if (isNull(obj)) { return false; } diff --git a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLSSignatureVerifier.java b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLSSignatureVerifier.java index 1281375b189..884f9402858 100644 --- a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLSSignatureVerifier.java +++ b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/BLSSignatureVerifier.java @@ -75,7 +75,8 @@ public boolean verify( boolean verify(List publicKeys, Bytes message, BLSSignature signature); /** Shortcut to {@link #verify(List, Bytes, BLSSignature)} for non-aggregate case */ - default boolean verify(BLSPublicKey publicKey, Bytes message, BLSSignature signature) { + default boolean verify( + final BLSPublicKey publicKey, final Bytes message, final BLSSignature signature) { return verify(Collections.singletonList(publicKey), message, signature); } diff --git a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/BLS12381.java b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/BLS12381.java index afa5869b609..7bde44b9e67 100644 --- a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/BLS12381.java +++ b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/BLS12381.java @@ -51,7 +51,7 @@ public interface BLS12381 { * @param seed to seed the key pair generation * @return a new random key pair */ - default KeyPair generateKeyPair(long seed) { + default KeyPair generateKeyPair(final long seed) { return generateKeyPair(new Random(seed)); } @@ -149,7 +149,7 @@ BatchSemiAggregate prepareBatchVerify2( */ boolean completeBatchVerify(List preparedList); - default Signature randomSignature(int seed) { + default Signature randomSignature(final int seed) { KeyPair keyPair = generateKeyPair(seed); byte[] message = "Hello, world!".getBytes(UTF_8); return keyPair.getSecretKey().sign(Bytes.wrap(message)); diff --git a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/BlsException.java b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/BlsException.java index c85be06a57b..2bfb8a311fe 100644 --- a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/BlsException.java +++ b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/BlsException.java @@ -15,11 +15,11 @@ public class BlsException extends IllegalArgumentException { - public BlsException(String message) { + public BlsException(final String message) { super(message); } - public BlsException(String message, Throwable cause) { + public BlsException(final String message, final Throwable cause) { super(message, cause); } } diff --git a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/KeyPair.java b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/KeyPair.java index b3243c2686b..b76512d9c4b 100644 --- a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/KeyPair.java +++ b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/KeyPair.java @@ -18,12 +18,12 @@ public class KeyPair { private final SecretKey secretKey; private final PublicKey publicKey; - public KeyPair(SecretKey secretKey, PublicKey publicKey) { + public KeyPair(final SecretKey secretKey, final PublicKey publicKey) { this.secretKey = secretKey; this.publicKey = publicKey; } - public KeyPair(SecretKey secretKey) { + public KeyPair(final SecretKey secretKey) { this(secretKey, secretKey.derivePublicKey()); } diff --git a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/PublicKey.java b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/PublicKey.java index 575466a9106..8414fa69064 100644 --- a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/PublicKey.java +++ b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/PublicKey.java @@ -33,7 +33,7 @@ public interface PublicKey { * @param signature The signature, not null * @return True if the verification is successful, false otherwise. */ - default boolean verifySignature(Signature signature, Bytes message) { + default boolean verifySignature(final Signature signature, final Bytes message) { return signature.verify(this, message); } @@ -45,7 +45,8 @@ default boolean verifySignature(Signature signature, Bytes message) { * @param dst The domain separation tag, not null * @return True if the verification is successful, false otherwise. */ - default boolean verifySignature(Signature signature, Bytes message, String dst) { + default boolean verifySignature( + final Signature signature, final Bytes message, final String dst) { return signature.verify(this, message, dst); } diff --git a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/PublicKeyMessagePair.java b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/PublicKeyMessagePair.java index 9aa1e202477..b62db8e2cdf 100644 --- a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/PublicKeyMessagePair.java +++ b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/PublicKeyMessagePair.java @@ -27,7 +27,7 @@ public class PublicKeyMessagePair { public static List fromLists( - List publicKeys, List messages) { + final List publicKeys, final List messages) { checkArgument(publicKeys.size() == messages.size()); return Streams.zip(publicKeys.stream(), messages.stream(), PublicKeyMessagePair::new).toList(); } @@ -35,7 +35,7 @@ public static List fromLists( private final PublicKey publicKey; private final Bytes message; - public PublicKeyMessagePair(PublicKey publicKey, Bytes message) { + public PublicKeyMessagePair(final PublicKey publicKey, final Bytes message) { this.publicKey = publicKey; this.message = message; } diff --git a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/Signature.java b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/Signature.java index 866df3f4082..2e99030a507 100644 --- a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/Signature.java +++ b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/Signature.java @@ -42,7 +42,7 @@ public interface Signature { * @param message The message data to verify, not null * @return True if the verification is successful, false otherwise */ - default boolean verify(List publicKeys, Bytes message) { + default boolean verify(final List publicKeys, final Bytes message) { return verify(publicKeys.stream().map(pk -> new PublicKeyMessagePair(pk, message)).toList()); } @@ -53,7 +53,7 @@ default boolean verify(List publicKeys, Bytes message) { * @param message the message data to verify, not null * @return True if the verification is successful, false otherwise */ - default boolean verify(PublicKey publicKey, Bytes message) { + default boolean verify(final PublicKey publicKey, final Bytes message) { return verify(Collections.singletonList(publicKey), message); } diff --git a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/BlstBLS12381.java b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/BlstBLS12381.java index 7d1b5b05880..af311417890 100644 --- a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/BlstBLS12381.java +++ b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/BlstBLS12381.java @@ -45,11 +45,12 @@ private static Random getRND() { return RANDOM; } - public static BlstSignature sign(BlstSecretKey secretKey, Bytes message) { + public static BlstSignature sign(final BlstSecretKey secretKey, final Bytes message) { return sign(secretKey, message, HashToCurve.ETH2_DST); } - public static BlstSignature sign(BlstSecretKey secretKey, Bytes message, String dst) { + public static BlstSignature sign( + final BlstSecretKey secretKey, final Bytes message, final String dst) { if (secretKey.isZero()) { throw new IllegalArgumentException("Signing with zero private key is prohibited"); } @@ -61,51 +62,58 @@ public static BlstSignature sign(BlstSecretKey secretKey, Bytes message, String return new BlstSignature(p2Affine); } - public static boolean verify(BlstPublicKey publicKey, Bytes message, BlstSignature signature) { + public static boolean verify( + final BlstPublicKey publicKey, final Bytes message, final BlstSignature signature) { return verify(publicKey, message, signature, HashToCurve.ETH2_DST); } public static boolean verify( - BlstPublicKey publicKey, Bytes message, BlstSignature signature, String dst) { + final BlstPublicKey publicKey, + final Bytes message, + final BlstSignature signature, + final String dst) { BLST_ERROR res = signature.ec2Point.core_verify(publicKey.ecPoint, true, message.toArrayUnsafe(), dst); return res == BLST_ERROR.BLST_SUCCESS; } @Override - public KeyPair generateKeyPair(Random random) { + public KeyPair generateKeyPair(final Random random) { BlstSecretKey secretKey = BlstSecretKey.generateNew(random); return new KeyPair(secretKey); } @Override - public BlstPublicKey publicKeyFromCompressed(Bytes48 compressedPublicKeyBytes) { + public BlstPublicKey publicKeyFromCompressed(final Bytes48 compressedPublicKeyBytes) { return BlstPublicKey.fromBytes(compressedPublicKeyBytes); } @Override - public BlstSignature signatureFromCompressed(Bytes compressedSignatureBytes) { + public BlstSignature signatureFromCompressed(final Bytes compressedSignatureBytes) { return BlstSignature.fromBytes(compressedSignatureBytes); } @Override - public BlstSecretKey secretKeyFromBytes(Bytes32 secretKeyBytes) { + public BlstSecretKey secretKeyFromBytes(final Bytes32 secretKeyBytes) { return BlstSecretKey.fromBytes(secretKeyBytes); } @Override - public BlstPublicKey aggregatePublicKeys(List publicKeys) { + public BlstPublicKey aggregatePublicKeys(final List publicKeys) { return BlstPublicKey.aggregate(publicKeys.stream().map(BlstPublicKey::fromPublicKey).toList()); } @Override - public BlstSignature aggregateSignatures(List signatures) { + public BlstSignature aggregateSignatures(final List signatures) { return BlstSignature.aggregate(signatures.stream().map(BlstSignature::fromSignature).toList()); } @Override public BlstSemiAggregate prepareBatchVerify( - int index, List publicKeys, Bytes message, Signature signature) { + final int index, + final List publicKeys, + final Bytes message, + final Signature signature) { BlstPublicKey aggrPubKey = aggregatePublicKeys(publicKeys); BlstSignature blstSignature = BlstSignature.fromSignature(signature); @@ -114,7 +122,7 @@ public BlstSemiAggregate prepareBatchVerify( } BlstSemiAggregate blstPrepareBatchVerify( - BlstPublicKey pubKey, Bytes message, BlstSignature blstSignature) { + final BlstPublicKey pubKey, final Bytes message, final BlstSignature blstSignature) { Pairing ctx = new Pairing(true, ETH2_DST); BLST_ERROR ret = @@ -136,13 +144,13 @@ BlstSemiAggregate blstPrepareBatchVerify( @Override public BatchSemiAggregate prepareBatchVerify2( - int index, - List publicKeys1, - Bytes message1, - Signature signature1, - List publicKeys2, - Bytes message2, - Signature signature2) { + final int index, + final List publicKeys1, + final Bytes message1, + final Signature signature1, + final List publicKeys2, + final Bytes message2, + final Signature signature2) { BlstSemiAggregate aggregate1 = prepareBatchVerify(index, publicKeys1, message1, signature1); BlstSemiAggregate aggregate2 = prepareBatchVerify(index + 1, publicKeys2, message2, signature2); @@ -151,7 +159,7 @@ public BatchSemiAggregate prepareBatchVerify2( } @Override - public boolean completeBatchVerify(List preparedList) { + public boolean completeBatchVerify(final List preparedList) { if (preparedList.isEmpty()) { return true; } diff --git a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/BlstInfiniteSemiAggregate.java b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/BlstInfiniteSemiAggregate.java index 3bf2d596cea..1bb35866549 100644 --- a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/BlstInfiniteSemiAggregate.java +++ b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/BlstInfiniteSemiAggregate.java @@ -18,7 +18,7 @@ final class BlstInfiniteSemiAggregate implements BatchSemiAggregate { private final boolean isValid; - public BlstInfiniteSemiAggregate(boolean isValid) { + public BlstInfiniteSemiAggregate(final boolean isValid) { this.isValid = isValid; } diff --git a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/BlstPublicKey.java b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/BlstPublicKey.java index afd5de3abde..51d18d28c52 100644 --- a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/BlstPublicKey.java +++ b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/BlstPublicKey.java @@ -35,7 +35,7 @@ class BlstPublicKey implements PublicKey { private static final BlstPublicKey INFINITE_PUBLIC_KEY = fromBytes(INFINITY_COMPRESSED_BYTES); - public static BlstPublicKey fromBytes(Bytes48 compressed) { + public static BlstPublicKey fromBytes(final Bytes48 compressed) { try { P1_Affine ecPoint = new P1_Affine(compressed.toArrayUnsafe()); return new BlstPublicKey(ecPoint); @@ -44,7 +44,7 @@ public static BlstPublicKey fromBytes(Bytes48 compressed) { } } - static BlstPublicKey fromPublicKey(PublicKey publicKey) { + static BlstPublicKey fromPublicKey(final PublicKey publicKey) { if (publicKey instanceof BlstPublicKey) { return (BlstPublicKey) publicKey; } else { @@ -52,7 +52,7 @@ static BlstPublicKey fromPublicKey(PublicKey publicKey) { } } - public static BlstPublicKey aggregate(List publicKeys) { + public static BlstPublicKey aggregate(final List publicKeys) { checkArgument(publicKeys.size() > 0); P1 sum = new P1(); @@ -74,7 +74,7 @@ public static BlstPublicKey aggregate(List publicKeys) { private final Supplier isInfinity = Suppliers.memoize(this::checkForInfinity); private final Supplier isInGroup = Suppliers.memoize(this::checkGroupMembership); - public BlstPublicKey(P1_Affine ecPoint) { + public BlstPublicKey(final P1_Affine ecPoint) { this.ecPoint = ecPoint; } @@ -118,7 +118,7 @@ public int hashCode() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/BlstSecretKey.java b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/BlstSecretKey.java index 7a6a2275f97..102a257b818 100644 --- a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/BlstSecretKey.java +++ b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/BlstSecretKey.java @@ -24,7 +24,7 @@ class BlstSecretKey implements SecretKey { static final BlstSecretKey ZERO_SK = BlstSecretKey.fromBytesRaw(Bytes32.ZERO); - public static BlstSecretKey fromBytes(Bytes32 bytes) { + public static BlstSecretKey fromBytes(final Bytes32 bytes) { if (bytes.isZero()) { return ZERO_SK; } else { @@ -32,13 +32,13 @@ public static BlstSecretKey fromBytes(Bytes32 bytes) { } } - private static BlstSecretKey fromBytesRaw(Bytes32 bytes) { + private static BlstSecretKey fromBytesRaw(final Bytes32 bytes) { supranational.blst.SecretKey secretKey = new supranational.blst.SecretKey(); secretKey.from_bendian(bytes.toArrayUnsafe()); return new BlstSecretKey(secretKey); } - public static BlstSecretKey generateNew(Random random) { + public static BlstSecretKey generateNew(final Random random) { byte[] ikm = new byte[128]; random.nextBytes(ikm); supranational.blst.SecretKey sk = new supranational.blst.SecretKey(); @@ -48,7 +48,7 @@ public static BlstSecretKey generateNew(Random random) { private final supranational.blst.SecretKey secretKey; - public BlstSecretKey(supranational.blst.SecretKey secretKey) { + public BlstSecretKey(final supranational.blst.SecretKey secretKey) { this.secretKey = secretKey; } @@ -62,12 +62,12 @@ public Bytes32 toBytes() { } @Override - public Signature sign(Bytes message) { + public Signature sign(final Bytes message) { return BlstBLS12381.sign(this, message); } @Override - public Signature sign(Bytes message, String dst) { + public Signature sign(final Bytes message, final String dst) { return BlstBLS12381.sign(this, message, dst); } @@ -93,7 +93,7 @@ public void destroy() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/BlstSemiAggregate.java b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/BlstSemiAggregate.java index 04db471d3b0..cf9cfdbeac6 100644 --- a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/BlstSemiAggregate.java +++ b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/BlstSemiAggregate.java @@ -31,7 +31,7 @@ private BlstSemiAggregate() { ctx = null; } - BlstSemiAggregate(Pairing ctx) { + BlstSemiAggregate(final Pairing ctx) { checkNotNull(ctx); this.ctx = ctx; } @@ -47,7 +47,7 @@ boolean isValid() { return ctx != null; } - void mergeWith(BlstSemiAggregate other) { + void mergeWith(final BlstSemiAggregate other) { if (other.isValid()) { BLST_ERROR ret = getCtx().merge(other.getCtx()); if (ret != BLST_ERROR.BLST_SUCCESS) { diff --git a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/BlstSignature.java b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/BlstSignature.java index 52cc74369fa..abf63a75cf1 100644 --- a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/BlstSignature.java +++ b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/BlstSignature.java @@ -32,7 +32,7 @@ public class BlstSignature implements Signature { static final BlstSignature INFINITY = new BlstSignature(new P2_Affine()); - public static BlstSignature fromBytes(Bytes compressed) { + public static BlstSignature fromBytes(final Bytes compressed) { try { checkArgument( compressed.size() == COMPRESSED_SIG_SIZE, @@ -46,7 +46,7 @@ public static BlstSignature fromBytes(Bytes compressed) { } } - static BlstSignature fromSignature(Signature signature) { + static BlstSignature fromSignature(final Signature signature) { if (signature instanceof BlstSignature) { return (BlstSignature) signature; } else { @@ -54,7 +54,7 @@ static BlstSignature fromSignature(Signature signature) { } } - public static BlstSignature aggregate(List signatures) { + public static BlstSignature aggregate(final List signatures) { try { P2 sum = new P2(); for (BlstSignature finiteSignature : signatures) { @@ -68,7 +68,10 @@ public static BlstSignature aggregate(List signatures) { } private static void blstPrepareVerifyAggregated( - BlstPublicKey pubKey, Bytes message, Pairing ctx, BlstSignature blstSignature) { + final BlstPublicKey pubKey, + final Bytes message, + final Pairing ctx, + final BlstSignature blstSignature) { BLST_ERROR ret = ctx.aggregate( @@ -81,14 +84,14 @@ private static void blstPrepareVerifyAggregated( } } - private static boolean blstCompleteVerifyAggregated(Pairing ctx) { + private static boolean blstCompleteVerifyAggregated(final Pairing ctx) { ctx.commit(); return ctx.finalverify(); } final P2_Affine ec2Point; - public BlstSignature(P2_Affine ec2Point) { + public BlstSignature(final P2_Affine ec2Point) { this.ec2Point = ec2Point; } @@ -98,7 +101,7 @@ public Bytes toBytesCompressed() { } @Override - public boolean verify(List keysToMessages) { + public boolean verify(final List keysToMessages) { boolean isAnyPublicKeyInfinity = keysToMessages.stream() @@ -119,19 +122,19 @@ public boolean verify(List keysToMessages) { } @Override - public boolean verify(List publicKeys, Bytes message) { + public boolean verify(final List publicKeys, final Bytes message) { return verify( BlstPublicKey.aggregate(publicKeys.stream().map(BlstPublicKey::fromPublicKey).toList()), message); } @Override - public boolean verify(PublicKey publicKey, Bytes message) { + public boolean verify(final PublicKey publicKey, final Bytes message) { return BlstBLS12381.verify(BlstPublicKey.fromPublicKey(publicKey), message, this); } @Override - public boolean verify(PublicKey publicKey, Bytes message, String dst) { + public boolean verify(final PublicKey publicKey, final Bytes message, final String dst) { return BlstBLS12381.verify(BlstPublicKey.fromPublicKey(publicKey), message, this, dst); } @@ -151,7 +154,7 @@ public int hashCode() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/HashToCurve.java b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/HashToCurve.java index 78a9e60c4e9..af6ac04fd3a 100644 --- a/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/HashToCurve.java +++ b/infrastructure/bls/src/main/java/tech/pegasys/teku/bls/impl/blst/HashToCurve.java @@ -21,11 +21,11 @@ class HashToCurve { // https://github.com/ethereum/consensus-specs/blob/v0.12.0/specs/phase0/beacon-chain.md#bls-signatures static final String ETH2_DST = "BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_POP_"; - static P2 hashToG2(Bytes message) { + static P2 hashToG2(final Bytes message) { return hashToG2(message, ETH2_DST); } - static P2 hashToG2(Bytes message, String dst) { + static P2 hashToG2(final Bytes message, final String dst) { P2 p2Hash = new P2(); return p2Hash.hash_to(message.toArray(), dst, new byte[0]); } diff --git a/infrastructure/bls/src/test/java/tech/pegasys/teku/bls/BLSPerformanceRunner.java b/infrastructure/bls/src/test/java/tech/pegasys/teku/bls/BLSPerformanceRunner.java index baecd64d606..3b4ec68c2a5 100644 --- a/infrastructure/bls/src/test/java/tech/pegasys/teku/bls/BLSPerformanceRunner.java +++ b/infrastructure/bls/src/test/java/tech/pegasys/teku/bls/BLSPerformanceRunner.java @@ -40,7 +40,7 @@ public BLSPerformanceRunner() { LoggingConfigurator.setAllLevels(Level.INFO); } - private Long executeRun(Runnable r, Integer count) { + private Long executeRun(final Runnable r, final Integer count) { long start = System.currentTimeMillis(); for (int j = 0; j < count; j++) { Thread t = new Thread(r); @@ -52,7 +52,7 @@ private Long executeRun(Runnable r, Integer count) { @ParameterizedTest() @MethodSource("singleAggregationCountOrder4") - void benchmarkVerifyAggregate128(Integer i) { + void benchmarkVerifyAggregate128(final Integer i) { Bytes message = Bytes.wrap("Hello, world!".getBytes(UTF_8)); final List keyPairs = BLSKeyGenerator.generateKeyPairs(128); @@ -82,14 +82,14 @@ void benchmarkVerifyAggregate128(Integer i) { @ParameterizedTest() @MethodSource("singleAggregationCountOrder4") - void generateRandomSignature(Integer i) { + void generateRandomSignature(final Integer i) { Long time = executeRun(BLSTestUtil::randomSignature, i); LOG.info("Time for i: {}, time: {}", i, time); } @ParameterizedTest() @MethodSource("singleAggregationCount") - void testAggregateManySignatures(Integer i) { + void testAggregateManySignatures(final Integer i) { final BLSSignature signature = BLSTestUtil.randomSignature(); final List sigs = Collections.nCopies(i, signature); @@ -109,7 +109,7 @@ void testAggregateManySignatures(Integer i) { @ParameterizedTest() @MethodSource("singleAggregationCountOrder4") - void testSigning(Integer i) { + void testSigning(final Integer i) { Bytes message = Bytes.wrap("Hello, world!".getBytes(UTF_8)); BLSKeyPair keyPair1 = BLSTestUtil.randomKeyPair(1); @@ -120,7 +120,7 @@ void testSigning(Integer i) { @ParameterizedTest() @MethodSource("singleAggregationCount") - void testAggregationTime(Integer i) { + void testAggregationTime(final Integer i) { BLSSignature signature = BLSTestUtil.randomSignature(); Long time = @@ -138,7 +138,7 @@ void testAggregationTime(Integer i) { @ParameterizedTest() @MethodSource("singleAggregationCountOrder4") - void testBLSPubKeyDeserialize(Integer i) { + void testBLSPubKeyDeserialize(final Integer i) { Bytes emptyBytesSsz = SSZ.encode(writer -> writer.writeFixedBytes(Bytes.wrap(new byte[48]))); Long time = executeRun(() -> BLSPublicKey.fromSSZBytes(emptyBytesSsz), i); @@ -147,7 +147,7 @@ void testBLSPubKeyDeserialize(Integer i) { @ParameterizedTest() @MethodSource("singleAggregationCountOrder4") - void testBLSPubKeySerialize(Integer i) { + void testBLSPubKeySerialize(final Integer i) { BLSPublicKey emptyPublicKey = BLSPublicKey.empty(); Long time = executeRun(() -> emptyPublicKey.toSSZBytes().toHexString(), i); @@ -156,7 +156,7 @@ void testBLSPubKeySerialize(Integer i) { @ParameterizedTest() @MethodSource("singleAggregationCountOrder4") - void testSignatureSerialize(Integer i) { + void testSignatureSerialize(final Integer i) { BLSSignature signature1 = BLSTestUtil.randomSignature(); Long time = executeRun(signature1::toSSZBytes, i); @@ -165,7 +165,7 @@ void testSignatureSerialize(Integer i) { @ParameterizedTest() @MethodSource("singleAggregationCountOrder4") - void testSignatureDeserialize(Integer i) { + void testSignatureDeserialize(final Integer i) { BLSSignature signature1 = BLSTestUtil.randomSignature(); Bytes bytes = signature1.toSSZBytes(); diff --git a/infrastructure/bls/src/test/java/tech/pegasys/teku/bls/BLSSecretKeyTest.java b/infrastructure/bls/src/test/java/tech/pegasys/teku/bls/BLSSecretKeyTest.java index 04a1476a335..5ee5bc27049 100644 --- a/infrastructure/bls/src/test/java/tech/pegasys/teku/bls/BLSSecretKeyTest.java +++ b/infrastructure/bls/src/test/java/tech/pegasys/teku/bls/BLSSecretKeyTest.java @@ -38,7 +38,7 @@ public abstract class BLSSecretKeyTest { "0xe7db4ea6533afa906673b0101343b00aa77b4805fffcb7fdfffffffe00000003", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" }) - void secretKeyFromBytes_shouldThrowWhenInvalidBytes(String skString) { + void secretKeyFromBytes_shouldThrowWhenInvalidBytes(final String skString) { Bytes32 sk1 = Bytes32.fromHexString(skString); Assertions.assertThatThrownBy(() -> BLSSecretKey.fromBytes(sk1)) .isInstanceOf(IllegalArgumentException.class); @@ -46,7 +46,8 @@ void secretKeyFromBytes_shouldThrowWhenInvalidBytes(String skString) { @ParameterizedTest @MethodSource("getSecretKeysToPubKeys") - void secretKeyFromBytes_shouldYieldCorrectPublicKey(String skString, String compressedPubKey) { + void secretKeyFromBytes_shouldYieldCorrectPublicKey( + final String skString, final String compressedPubKey) { BLSSecretKey sk = BLSSecretKey.fromBytes(Bytes32.fromHexString(skString)); Assertions.assertThat(sk.toPublicKey().toBytesCompressed()) .isEqualTo(Bytes48.fromHexString(compressedPubKey)); diff --git a/infrastructure/bls/src/test/java/tech/pegasys/teku/bls/impl/AbstractBLS12381Test.java b/infrastructure/bls/src/test/java/tech/pegasys/teku/bls/impl/AbstractBLS12381Test.java index 6fbf567d425..3fc57087765 100644 --- a/infrastructure/bls/src/test/java/tech/pegasys/teku/bls/impl/AbstractBLS12381Test.java +++ b/infrastructure/bls/src/test/java/tech/pegasys/teku/bls/impl/AbstractBLS12381Test.java @@ -32,7 +32,7 @@ public abstract class AbstractBLS12381Test { private final List keys = - IntStream.range(0, 8).mapToObj(getBls()::generateKeyPair).collect(Collectors.toList()); + IntStream.range(0, 8).mapToObj(getBls()::generateKeyPair).toList(); private final List> pubKeys = keys.stream() .map(k -> Collections.singletonList(k.getPublicKey())) diff --git a/infrastructure/bls/src/testFixtures/java/tech/pegasys/teku/bls/BLSTestUtil.java b/infrastructure/bls/src/testFixtures/java/tech/pegasys/teku/bls/BLSTestUtil.java index 498b73bfd6c..b9753fd144e 100644 --- a/infrastructure/bls/src/testFixtures/java/tech/pegasys/teku/bls/BLSTestUtil.java +++ b/infrastructure/bls/src/testFixtures/java/tech/pegasys/teku/bls/BLSTestUtil.java @@ -38,7 +38,7 @@ public static BLSSignature randomSignature() { * @param entropy to seed the key pair generation * @return the signature */ - public static BLSSignature randomSignature(int entropy) { + public static BLSSignature randomSignature(final int entropy) { BLSKeyPair keyPair = randomKeyPair(entropy); byte[] message = "Hello, world!".getBytes(UTF_8); return BLS.sign(keyPair.getSecretKey(), Bytes.wrap(message)); @@ -49,7 +49,7 @@ public static BLSSignature randomSignature(int entropy) { * * @return PublicKey The public key, not null */ - public static BLSPublicKey randomPublicKey(int seed) { + public static BLSPublicKey randomPublicKey(final int seed) { return randomKeyPair(seed).getPublicKey(); } @@ -60,7 +60,7 @@ public static BLSPublicKey randomPublicKey(int seed) { * * @return a keypair generated from a seed */ - public static BLSKeyPair randomKeyPair(int seed) { + public static BLSKeyPair randomKeyPair(final int seed) { BLSSecretKey pseudoRandomSecretBytes = BLSSecretKey.fromBytesModR(Bytes32.random(new Random(seed))); return new BLSKeyPair(pseudoRandomSecretBytes); diff --git a/infrastructure/bytes/build.gradle b/infrastructure/bytes/build.gradle index 37b84d355ca..721a4ec7ea8 100644 --- a/infrastructure/bytes/build.gradle +++ b/infrastructure/bytes/build.gradle @@ -1,3 +1,3 @@ dependencies { - implementation 'org.apache.tuweni:tuweni-bytes' + implementation 'io.tmio:tuweni-bytes' } \ No newline at end of file diff --git a/infrastructure/bytes/src/main/java/tech/pegasys/teku/infrastructure/bytes/Bytes20.java b/infrastructure/bytes/src/main/java/tech/pegasys/teku/infrastructure/bytes/Bytes20.java index b3cbc1bee2f..5d9d8f214e2 100644 --- a/infrastructure/bytes/src/main/java/tech/pegasys/teku/infrastructure/bytes/Bytes20.java +++ b/infrastructure/bytes/src/main/java/tech/pegasys/teku/infrastructure/bytes/Bytes20.java @@ -26,13 +26,13 @@ public class Bytes20 { private final Bytes bytes; - public Bytes20(Bytes bytes) { + public Bytes20(final Bytes bytes) { checkArgument( bytes.size() == SIZE, "Bytes20 should be 20 bytes, but was %s bytes.", bytes.size()); this.bytes = bytes; } - public static Bytes20 fromHexString(String value) { + public static Bytes20 fromHexString(final String value) { return new Bytes20(Bytes.fromHexString(value)); } @@ -47,7 +47,7 @@ public String toHexString() { * @return A {@link Bytes20} that exposes the left-padded bytes of {@code value}. * @throws IllegalArgumentException if {@code value.size() > 20}. */ - public static Bytes20 leftPad(Bytes value) { + public static Bytes20 leftPad(final Bytes value) { checkNotNull(value); if (value instanceof Bytes20) { return (Bytes20) value; @@ -65,7 +65,7 @@ public static Bytes20 leftPad(Bytes value) { * @return A {@link Bytes20} that exposes the right-padded bytes of {@code value}. * @throws IllegalArgumentException if {@code value.size() > 20}. */ - public static Bytes20 rightPad(Bytes value) { + public static Bytes20 rightPad(final Bytes value) { checkNotNull(value); if (value instanceof Bytes20) { return (Bytes20) value; diff --git a/infrastructure/bytes/src/main/java/tech/pegasys/teku/infrastructure/bytes/Bytes4.java b/infrastructure/bytes/src/main/java/tech/pegasys/teku/infrastructure/bytes/Bytes4.java index f5e0ef03b7d..15cf04da225 100644 --- a/infrastructure/bytes/src/main/java/tech/pegasys/teku/infrastructure/bytes/Bytes4.java +++ b/infrastructure/bytes/src/main/java/tech/pegasys/teku/infrastructure/bytes/Bytes4.java @@ -26,16 +26,16 @@ public class Bytes4 { private final Bytes bytes; - public Bytes4(Bytes bytes) { + public Bytes4(final Bytes bytes) { checkArgument(bytes.size() == 4, "Bytes4 should be 4 bytes, but was %s bytes.", bytes.size()); this.bytes = bytes; } - public static Bytes4 fromHexString(String value) { + public static Bytes4 fromHexString(final String value) { return new Bytes4(Bytes.fromHexString(value)); } - public static Bytes4 fromHexStringLenient(String value) { + public static Bytes4 fromHexStringLenient(final String value) { return new Bytes4(Bytes.fromHexStringLenient(value, 4)); } @@ -50,7 +50,7 @@ public String toHexString() { * @return A {@link Bytes4} that exposes the left-padded bytes of {@code value}. * @throws IllegalArgumentException if {@code value.size() > 4}. */ - public static Bytes4 leftPad(Bytes value) { + public static Bytes4 leftPad(final Bytes value) { checkNotNull(value); if (value instanceof Bytes4) { return (Bytes4) value; @@ -68,7 +68,7 @@ public static Bytes4 leftPad(Bytes value) { * @return A {@link Bytes4} that exposes the right-padded bytes of {@code value}. * @throws IllegalArgumentException if {@code value.size() > 4}. */ - public static Bytes4 rightPad(Bytes value) { + public static Bytes4 rightPad(final Bytes value) { checkNotNull(value); if (value instanceof Bytes4) { return (Bytes4) value; diff --git a/infrastructure/bytes/src/main/java/tech/pegasys/teku/infrastructure/bytes/Bytes8.java b/infrastructure/bytes/src/main/java/tech/pegasys/teku/infrastructure/bytes/Bytes8.java index 3827f42f193..98d7be9dd00 100644 --- a/infrastructure/bytes/src/main/java/tech/pegasys/teku/infrastructure/bytes/Bytes8.java +++ b/infrastructure/bytes/src/main/java/tech/pegasys/teku/infrastructure/bytes/Bytes8.java @@ -23,18 +23,18 @@ public class Bytes8 { public static final int SIZE = 8; - private Bytes bytes; + private final Bytes bytes; - public Bytes8(Bytes bytes) { + public Bytes8(final Bytes bytes) { checkArgument(bytes.size() == 8, "Bytes8 should be 8 bytes, but was %s bytes.", bytes.size()); this.bytes = bytes; } - public static Bytes8 fromHexString(String value) { + public static Bytes8 fromHexString(final String value) { return new Bytes8(Bytes.fromHexString(value)); } - public static Bytes8 fromHexStringLenient(String value) { + public static Bytes8 fromHexStringLenient(final String value) { return new Bytes8(Bytes.fromHexStringLenient(value, 8)); } @@ -49,7 +49,7 @@ public String toHexString() { * @return A {@link Bytes8} that exposes the left-padded bytes of {@code value}. * @throws IllegalArgumentException if {@code value.size() > 8}. */ - public static Bytes8 leftPad(Bytes value) { + public static Bytes8 leftPad(final Bytes value) { checkNotNull(value); if (value instanceof Bytes8) { return (Bytes8) value; @@ -67,7 +67,7 @@ public static Bytes8 leftPad(Bytes value) { * @return A {@link Bytes8} that exposes the right-padded bytes of {@code value}. * @throws IllegalArgumentException if {@code value.size() > 8}. */ - public static Bytes8 rightPad(Bytes value) { + public static Bytes8 rightPad(final Bytes value) { checkNotNull(value); if (value instanceof Bytes8) { return (Bytes8) value; diff --git a/infrastructure/collections/src/main/java/tech/pegasys/teku/infrastructure/collections/AbstractLimitedMap.java b/infrastructure/collections/src/main/java/tech/pegasys/teku/infrastructure/collections/AbstractLimitedMap.java index 2403ca7d76e..c13e96c48b2 100644 --- a/infrastructure/collections/src/main/java/tech/pegasys/teku/infrastructure/collections/AbstractLimitedMap.java +++ b/infrastructure/collections/src/main/java/tech/pegasys/teku/infrastructure/collections/AbstractLimitedMap.java @@ -35,7 +35,7 @@ protected boolean removeEldestEntry(final Map.Entry eldest) { protected final Map delegate; protected final int maxSize; - protected AbstractLimitedMap(Map delegate, int maxSize) { + protected AbstractLimitedMap(final Map delegate, final int maxSize) { this.delegate = delegate; this.maxSize = maxSize; } @@ -56,32 +56,32 @@ public boolean isEmpty() { } @Override - public boolean containsKey(Object key) { + public boolean containsKey(final Object key) { return delegate.containsKey(key); } @Override - public boolean containsValue(Object value) { + public boolean containsValue(final Object value) { return delegate.containsValue(value); } @Override - public V get(Object key) { + public V get(final Object key) { return delegate.get(key); } @Override - public V put(K key, V value) { + public V put(final K key, final V value) { return delegate.put(key, value); } @Override - public V remove(Object key) { + public V remove(final Object key) { return delegate.remove(key); } @Override - public void putAll(Map m) { + public void putAll(final Map m) { delegate.putAll(m); } @@ -106,7 +106,7 @@ public Set> entrySet() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { return delegate.equals(o); } @@ -116,58 +116,62 @@ public int hashCode() { } @Override - public V getOrDefault(Object key, V defaultValue) { + public V getOrDefault(final Object key, final V defaultValue) { return delegate.getOrDefault(key, defaultValue); } @Override - public void forEach(BiConsumer action) { + public void forEach(final BiConsumer action) { delegate.forEach(action); } @Override - public void replaceAll(BiFunction function) { + public void replaceAll(final BiFunction function) { delegate.replaceAll(function); } @Override - public V putIfAbsent(K key, V value) { + public V putIfAbsent(final K key, final V value) { return delegate.putIfAbsent(key, value); } @Override - public boolean remove(Object key, Object value) { + public boolean remove(final Object key, final Object value) { return delegate.remove(key, value); } @Override - public boolean replace(K key, V oldValue, V newValue) { + public boolean replace(final K key, final V oldValue, final V newValue) { return delegate.replace(key, oldValue, newValue); } @Override - public V replace(K key, V value) { + public V replace(final K key, final V value) { return delegate.replace(key, value); } @Override - public V computeIfAbsent(K key, Function mappingFunction) { + public V computeIfAbsent(final K key, final Function mappingFunction) { return delegate.computeIfAbsent(key, mappingFunction); } @Override public V computeIfPresent( - K key, BiFunction remappingFunction) { + final K key, final BiFunction remappingFunction) { return delegate.computeIfPresent(key, remappingFunction); } @Override - public V compute(K key, BiFunction remappingFunction) { + public V compute( + final K key, final BiFunction remappingFunction) { return delegate.compute(key, remappingFunction); } @Override - public V merge(K key, V value, BiFunction remappingFunction) { + public V merge( + final K key, + final V value, + final BiFunction remappingFunction) { return delegate.merge(key, value, remappingFunction); } } diff --git a/infrastructure/collections/src/main/java/tech/pegasys/teku/infrastructure/collections/TekuPair.java b/infrastructure/collections/src/main/java/tech/pegasys/teku/infrastructure/collections/TekuPair.java index 446ae520205..e73f7fbc6c5 100644 --- a/infrastructure/collections/src/main/java/tech/pegasys/teku/infrastructure/collections/TekuPair.java +++ b/infrastructure/collections/src/main/java/tech/pegasys/teku/infrastructure/collections/TekuPair.java @@ -23,14 +23,14 @@ */ public final class TekuPair { - public static TekuPair of(TLeft left, TRight right) { + public static TekuPair of(final TLeft left, final TRight right) { return new TekuPair<>(left, right); } private final TLeft left; private final TRight right; - private TekuPair(TLeft left, TRight right) { + private TekuPair(final TLeft left, final TRight right) { this.left = left; this.right = right; } @@ -44,14 +44,13 @@ public TRight getRight() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } - if (!(o instanceof TekuPair)) { + if (!(o instanceof TekuPair tekuPair)) { return false; } - TekuPair tekuPair = (TekuPair) o; return Objects.equal(getLeft(), tekuPair.getLeft()) && Objects.equal(getRight(), tekuPair.getRight()); } diff --git a/infrastructure/collections/src/main/java/tech/pegasys/teku/infrastructure/collections/cache/LRUCache.java b/infrastructure/collections/src/main/java/tech/pegasys/teku/infrastructure/collections/cache/LRUCache.java index 78ad599993c..2013c5cdcdf 100644 --- a/infrastructure/collections/src/main/java/tech/pegasys/teku/infrastructure/collections/cache/LRUCache.java +++ b/infrastructure/collections/src/main/java/tech/pegasys/teku/infrastructure/collections/cache/LRUCache.java @@ -26,13 +26,13 @@ */ public class LRUCache implements Cache { - public static LRUCache create(int capacity) { + public static LRUCache create(final int capacity) { return new LRUCache<>(LimitedMap.createNonSynchronized(capacity)); } private final LimitedMap cacheData; - private LRUCache(LimitedMap cacheData) { + private LRUCache(final LimitedMap cacheData) { this.cacheData = cacheData; } @@ -50,7 +50,7 @@ public synchronized Cache copy() { * @return expected value result for provided key */ @Override - public synchronized V get(K key, Function fallback) { + public synchronized V get(final K key, final Function fallback) { V result = cacheData.get(key); if (result == null) { @@ -64,17 +64,17 @@ public synchronized V get(K key, Function fallback) { } @Override - public synchronized Optional getCached(K key) { + public synchronized Optional getCached(final K key) { return Optional.ofNullable(cacheData.get(key)); } @Override - public synchronized void invalidate(K key) { + public synchronized void invalidate(final K key) { cacheData.remove(key); } @Override - public synchronized void invalidateWithNewValue(K key, V newValue) { + public synchronized void invalidateWithNewValue(final K key, final V newValue) { invalidate(key); get(key, k -> newValue); } diff --git a/infrastructure/collections/src/main/java/tech/pegasys/teku/infrastructure/collections/cache/NoOpCache.java b/infrastructure/collections/src/main/java/tech/pegasys/teku/infrastructure/collections/cache/NoOpCache.java index 4b50419b526..f63e721578e 100644 --- a/infrastructure/collections/src/main/java/tech/pegasys/teku/infrastructure/collections/cache/NoOpCache.java +++ b/infrastructure/collections/src/main/java/tech/pegasys/teku/infrastructure/collections/cache/NoOpCache.java @@ -43,12 +43,12 @@ private NoOpCache() {} * @return expected value result for provided key */ @Override - public V get(K key, Function fallback) { + public V get(final K key, final Function fallback) { return fallback.apply(key); } @Override - public Optional getCached(K key) { + public Optional getCached(final K key) { return Optional.empty(); } @@ -58,10 +58,10 @@ public Cache copy() { } @Override - public void invalidate(K key) {} + public void invalidate(final K key) {} @Override - public void invalidateWithNewValue(K key, V newValue) {} + public void invalidateWithNewValue(final K key, final V newValue) {} @Override public void clear() {} diff --git a/infrastructure/crypto/build.gradle b/infrastructure/crypto/build.gradle index 8e2596508c9..8a49605500f 100644 --- a/infrastructure/crypto/build.gradle +++ b/infrastructure/crypto/build.gradle @@ -1,6 +1,6 @@ dependencies { api 'org.bouncycastle:bcprov-jdk18on' - api 'org.apache.tuweni:tuweni-bytes' + api 'io.tmio:tuweni-bytes' jmhImplementation 'org.bouncycastle:bcprov-jdk18on' diff --git a/infrastructure/events/src/main/java/tech/pegasys/teku/infrastructure/events/DirectEventDeliverer.java b/infrastructure/events/src/main/java/tech/pegasys/teku/infrastructure/events/DirectEventDeliverer.java index b8a8e80fbf8..69bd0cbe152 100644 --- a/infrastructure/events/src/main/java/tech/pegasys/teku/infrastructure/events/DirectEventDeliverer.java +++ b/infrastructure/events/src/main/java/tech/pegasys/teku/infrastructure/events/DirectEventDeliverer.java @@ -35,14 +35,14 @@ class DirectEventDeliverer extends EventDeliverer { consumedEventCounter = metricsSystem.createLabelledCounter( EVENTBUS, - "event_consumed_count", + "event_consumed_count_total", "Total number of events consumed", "channel", "subscriber"); failedEventCounter = metricsSystem.createLabelledCounter( EVENTBUS, - "event_failed_count", + "event_failed_count_total", "Number of events which failed to be processed", "channel", "subscriber"); diff --git a/infrastructure/events/src/main/java/tech/pegasys/teku/infrastructure/events/EventDeliverer.java b/infrastructure/events/src/main/java/tech/pegasys/teku/infrastructure/events/EventDeliverer.java index f5167a8bcf3..3a1c0ee1976 100644 --- a/infrastructure/events/src/main/java/tech/pegasys/teku/infrastructure/events/EventDeliverer.java +++ b/infrastructure/events/src/main/java/tech/pegasys/teku/infrastructure/events/EventDeliverer.java @@ -32,7 +32,7 @@ protected EventDeliverer(final MetricsSystem metricsSystem) { publishedEventCounter = metricsSystem.createLabelledCounter( TekuMetricCategory.EVENTBUS, - "event_published_count", + "event_published_count_total", "Total number of events published", "channel"); } diff --git a/infrastructure/exceptions/src/main/java/tech/pegasys/teku/infrastructure/exceptions/ExceptionUtil.java b/infrastructure/exceptions/src/main/java/tech/pegasys/teku/infrastructure/exceptions/ExceptionUtil.java index 3a127287a60..8054a7d3319 100644 --- a/infrastructure/exceptions/src/main/java/tech/pegasys/teku/infrastructure/exceptions/ExceptionUtil.java +++ b/infrastructure/exceptions/src/main/java/tech/pegasys/teku/infrastructure/exceptions/ExceptionUtil.java @@ -20,7 +20,7 @@ public class ExceptionUtil { @SuppressWarnings("unchecked") public static Optional getCause( - final Throwable err, Class targetType) { + final Throwable err, final Class targetType) { return ExceptionUtils.getThrowableList(err).stream() .filter(targetType::isInstance) .map(e -> (T) e) @@ -28,7 +28,7 @@ public static Optional getCause( } public static boolean hasCause( - final Throwable err, Class targetType) { + final Throwable err, final Class targetType) { return getCause(err, targetType).isPresent(); } diff --git a/infrastructure/http/src/main/java/tech/pegasys/teku/infrastructure/http/ContentTypeNotSupportedException.java b/infrastructure/http/src/main/java/tech/pegasys/teku/infrastructure/http/ContentTypeNotSupportedException.java index 558aed089be..0d5019cd8a3 100644 --- a/infrastructure/http/src/main/java/tech/pegasys/teku/infrastructure/http/ContentTypeNotSupportedException.java +++ b/infrastructure/http/src/main/java/tech/pegasys/teku/infrastructure/http/ContentTypeNotSupportedException.java @@ -14,7 +14,7 @@ package tech.pegasys.teku.infrastructure.http; public class ContentTypeNotSupportedException extends RuntimeException { - public ContentTypeNotSupportedException(String message) { + public ContentTypeNotSupportedException(final String message) { super(message); } } diff --git a/infrastructure/http/src/main/java/tech/pegasys/teku/infrastructure/http/HostAllowlistUtils.java b/infrastructure/http/src/main/java/tech/pegasys/teku/infrastructure/http/HostAllowlistUtils.java index 6a00fd26a6e..d91c4aa987b 100644 --- a/infrastructure/http/src/main/java/tech/pegasys/teku/infrastructure/http/HostAllowlistUtils.java +++ b/infrastructure/http/src/main/java/tech/pegasys/teku/infrastructure/http/HostAllowlistUtils.java @@ -22,7 +22,7 @@ public class HostAllowlistUtils { - public static boolean isHostAuthorized(final List allowlist, String hostHeader) { + public static boolean isHostAuthorized(final List allowlist, final String hostHeader) { Optional optionalHost = getAndValidateHostHeader(hostHeader); return allowlist.contains("*") || (optionalHost.isPresent() && hostIsInAllowlist(allowlist, optionalHost.get())); diff --git a/infrastructure/http/src/main/java/tech/pegasys/teku/infrastructure/http/HttpErrorResponse.java b/infrastructure/http/src/main/java/tech/pegasys/teku/infrastructure/http/HttpErrorResponse.java index c658705c088..84a7b05dd9c 100644 --- a/infrastructure/http/src/main/java/tech/pegasys/teku/infrastructure/http/HttpErrorResponse.java +++ b/infrastructure/http/src/main/java/tech/pegasys/teku/infrastructure/http/HttpErrorResponse.java @@ -25,7 +25,7 @@ public class HttpErrorResponse { private final int code; private final String message; - public static HttpErrorResponse badRequest(String message) { + public static HttpErrorResponse badRequest(final String message) { return new HttpErrorResponse(SC_BAD_REQUEST, message); } diff --git a/infrastructure/http/src/main/java/tech/pegasys/teku/infrastructure/http/RestApiConstants.java b/infrastructure/http/src/main/java/tech/pegasys/teku/infrastructure/http/RestApiConstants.java index c07df153f1b..b0d2c235463 100644 --- a/infrastructure/http/src/main/java/tech/pegasys/teku/infrastructure/http/RestApiConstants.java +++ b/infrastructure/http/src/main/java/tech/pegasys/teku/infrastructure/http/RestApiConstants.java @@ -183,9 +183,7 @@ public class RestApiConstants { + SC_SERVICE_UNAVAILABLE + " status code if set to true and no validators have been registered with the builder"; public static final String SKIP_RANDAO_VERIFICATION_PARAM_DESCRIPTION = - "Skip verification of the `randao_reveal` value. If this flag is set then the\n" - + " `randao_reveal` must be set to the point at infinity (`0xc0..00`). This query parameter\n" - + " is a flag and does not take a value"; + "Skip verification of the `randao_reveal` value. Ignored in the Teku implementation."; public static final String BUILDER_BOOST_FACTOR = "builder_boost_factor"; public static final String BUILDER_BOOST_FACTOR_DESCRIPTION = diff --git a/infrastructure/http/src/main/java/tech/pegasys/teku/infrastructure/http/UrlSanitizer.java b/infrastructure/http/src/main/java/tech/pegasys/teku/infrastructure/http/UrlSanitizer.java index 4f1718d4455..b7cc9af134c 100644 --- a/infrastructure/http/src/main/java/tech/pegasys/teku/infrastructure/http/UrlSanitizer.java +++ b/infrastructure/http/src/main/java/tech/pegasys/teku/infrastructure/http/UrlSanitizer.java @@ -49,7 +49,7 @@ public static String appendPath(final String url, final String path) { final String sanitizedPath = path == null ? "" : path; final URL urlWithPath; try { - urlWithPath = new URL(new URL(url), sanitizedPath); + urlWithPath = URI.create(url).resolve(sanitizedPath).toURL(); } catch (MalformedURLException e) { throw new IllegalArgumentException("Invalid URL " + url, e); } diff --git a/infrastructure/io/build.gradle b/infrastructure/io/build.gradle index ae2daf506cc..7bfa324f856 100644 --- a/infrastructure/io/build.gradle +++ b/infrastructure/io/build.gradle @@ -1,5 +1,6 @@ dependencies { - implementation 'org.apache.tuweni:tuweni-bytes' + implementation 'io.tmio:tuweni-bytes' + implementation 'net.java.dev.jna:jna' implementation project(':infrastructure:exceptions') testFixturesImplementation 'commons-io:commons-io' diff --git a/infrastructure/io/src/main/java/tech/pegasys/teku/infrastructure/io/IPVersionResolver.java b/infrastructure/io/src/main/java/tech/pegasys/teku/infrastructure/io/IPVersionResolver.java new file mode 100644 index 00000000000..f4d4525f738 --- /dev/null +++ b/infrastructure/io/src/main/java/tech/pegasys/teku/infrastructure/io/IPVersionResolver.java @@ -0,0 +1,55 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.infrastructure.io; + +import java.io.UncheckedIOException; +import java.net.Inet6Address; +import java.net.InetAddress; +import java.net.InetSocketAddress; +import java.net.UnknownHostException; + +public class IPVersionResolver { + + public enum IPVersion { + IP_V4("IPv4"), + IP_V6("IPv6"); + + private final String name; + + IPVersion(final String name) { + this.name = name; + } + + public String getName() { + return name; + } + } + + public static IPVersion resolve(final String address) { + try { + final InetAddress inetAddress = InetAddress.getByName(address); + return resolve(inetAddress); + } catch (final UnknownHostException ex) { + throw new UncheckedIOException(ex); + } + } + + public static IPVersion resolve(final InetAddress inetAddress) { + return inetAddress instanceof Inet6Address ? IPVersion.IP_V6 : IPVersion.IP_V4; + } + + public static IPVersion resolve(final InetSocketAddress inetSocketAddress) { + return resolve(inetSocketAddress.getAddress()); + } +} diff --git a/infrastructure/io/src/main/java/tech/pegasys/teku/infrastructure/io/JemallocDetector.java b/infrastructure/io/src/main/java/tech/pegasys/teku/infrastructure/io/JemallocDetector.java new file mode 100644 index 00000000000..fc5a8241e1e --- /dev/null +++ b/infrastructure/io/src/main/java/tech/pegasys/teku/infrastructure/io/JemallocDetector.java @@ -0,0 +1,59 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.infrastructure.io; + +import com.sun.jna.Library; +import com.sun.jna.Native; +import com.sun.jna.ptr.IntByReference; +import com.sun.jna.ptr.PointerByReference; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +@SuppressWarnings("JavaCase") +public class JemallocDetector { + private static final Logger LOG = LogManager.getLogger(); + + @SuppressWarnings("NonFinalStaticField") + private static String _jemalloc; + + public static void logJemallocPresence() { + try { + getJemalloc(); + if (_jemalloc != null) { + LOG.info("jemalloc: " + _jemalloc); + } + } catch (final Throwable throwable) { + LOG.info("jemalloc library not found."); + } + } + + private static void getJemalloc() { + interface JemallocLib extends Library { + int mallctl( + String property, + PointerByReference value, + IntByReference len, + String newValue, + int newLen); + } + + final JemallocLib jemallocLib = Native.load("jemalloc", JemallocLib.class); + + PointerByReference pVersion = new PointerByReference(); + IntByReference pSize = new IntByReference(Native.POINTER_SIZE); + jemallocLib.mallctl("version", pVersion, pSize, null, 0); + + _jemalloc = pVersion.getValue().getString(0); + } +} diff --git a/infrastructure/io/src/main/java/tech/pegasys/teku/infrastructure/io/SyncDataAccessor.java b/infrastructure/io/src/main/java/tech/pegasys/teku/infrastructure/io/SyncDataAccessor.java index 5c04435b136..2a6c73bb63c 100644 --- a/infrastructure/io/src/main/java/tech/pegasys/teku/infrastructure/io/SyncDataAccessor.java +++ b/infrastructure/io/src/main/java/tech/pegasys/teku/infrastructure/io/SyncDataAccessor.java @@ -35,7 +35,7 @@ public class SyncDataAccessor { private static final Logger LOG = LogManager.getLogger(); - private boolean atomicFileMoveSupport; + private final boolean atomicFileMoveSupport; SyncDataAccessor(final boolean atomicFileMoveSupport) { this.atomicFileMoveSupport = atomicFileMoveSupport; @@ -43,7 +43,7 @@ public class SyncDataAccessor { public static SyncDataAccessor create(final Path path) { - boolean atomicFileMoveSupport = false; + boolean atomicFileMoveSupport; final Path tmpFile; if (Files.isDirectory(path.toAbsolutePath())) { tmpFile = path.toAbsolutePath().resolve("syncWriteTest.tmp"); @@ -54,8 +54,7 @@ public static SyncDataAccessor create(final Path path) { try { ensurePathExists(path); } catch (IOException e) { - throw new IllegalStateException( - "Could not create slashing protection path: " + e.getMessage()); + throw new IllegalStateException("Could not create file at: " + e.getMessage()); } try { diff --git a/infrastructure/io/src/main/java/tech/pegasys/teku/infrastructure/io/resource/ResourceLoader.java b/infrastructure/io/src/main/java/tech/pegasys/teku/infrastructure/io/resource/ResourceLoader.java index d7a16ee6479..76b5f47f00a 100644 --- a/infrastructure/io/src/main/java/tech/pegasys/teku/infrastructure/io/resource/ResourceLoader.java +++ b/infrastructure/io/src/main/java/tech/pegasys/teku/infrastructure/io/resource/ResourceLoader.java @@ -77,7 +77,7 @@ public Optional load(final String... sources) throws IOException { abstract Optional loadSource(String source) throws IOException; - public Optional loadBytes(String... sources) throws IOException { + public Optional loadBytes(final String... sources) throws IOException { final Optional maybeStream = load(sources); if (maybeStream.isEmpty()) { return Optional.empty(); diff --git a/infrastructure/io/src/main/java/tech/pegasys/teku/infrastructure/io/resource/URLResourceLoader.java b/infrastructure/io/src/main/java/tech/pegasys/teku/infrastructure/io/resource/URLResourceLoader.java index 5a765363330..5cfbaa074a0 100644 --- a/infrastructure/io/src/main/java/tech/pegasys/teku/infrastructure/io/resource/URLResourceLoader.java +++ b/infrastructure/io/src/main/java/tech/pegasys/teku/infrastructure/io/resource/URLResourceLoader.java @@ -19,6 +19,7 @@ import java.io.InputStream; import java.net.ConnectException; import java.net.SocketTimeoutException; +import java.net.URI; import java.net.URL; import java.net.URLConnection; import java.util.Base64; @@ -58,7 +59,7 @@ Optional loadSource(final String source) throws IOException { } try { - final URL url = new URL(source); + final URL url = new URI(source).toURL(); final URLConnection connection = url.openConnection(); connection.setConnectTimeout(timeoutMillis); connection.setReadTimeout(timeoutMillis); diff --git a/infrastructure/io/src/test/java/tech/pegasys/teku/infrastructure/io/IPVersionResolverTest.java b/infrastructure/io/src/test/java/tech/pegasys/teku/infrastructure/io/IPVersionResolverTest.java new file mode 100644 index 00000000000..4d31c52503b --- /dev/null +++ b/infrastructure/io/src/test/java/tech/pegasys/teku/infrastructure/io/IPVersionResolverTest.java @@ -0,0 +1,37 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.infrastructure.io; + +import static org.assertj.core.api.Assertions.assertThat; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import tech.pegasys.teku.infrastructure.io.IPVersionResolver.IPVersion; + +class IPVersionResolverTest { + + @ParameterizedTest + @CsvSource({ + "0.0.0.0,IP_V4", + "1.2.3.4,IP_V4", + "01.102.103.104,IP_V4", + "::,IP_V6", + "::0,IP_V6", + "2001:db8:3333:4444:5555:6666:7777:8888,IP_V6" + }) + void resolvesIPVersion(final String ip, final IPVersion expectedVersion) { + final IPVersion result = IPVersionResolver.resolve(ip); + assertThat(result).isEqualTo(expectedVersion); + } +} diff --git a/infrastructure/io/src/test/java/tech/pegasys/teku/infrastructure/io/SyncDataAccessorTest.java b/infrastructure/io/src/test/java/tech/pegasys/teku/infrastructure/io/SyncDataAccessorTest.java index 67b7e2c97f7..2c6e158da50 100644 --- a/infrastructure/io/src/test/java/tech/pegasys/teku/infrastructure/io/SyncDataAccessorTest.java +++ b/infrastructure/io/src/test/java/tech/pegasys/teku/infrastructure/io/SyncDataAccessorTest.java @@ -33,7 +33,7 @@ public class SyncDataAccessorTest { @Test public void shouldThrowInvalidConfigurationExceptionWhenDirectoryNotWritable( - @TempDir Path tempDir) throws IOException { + @TempDir final Path tempDir) throws IOException { OSUtils.makeNonWritable(tempDir); assumeThat(tempDir.toFile().canWrite()).describedAs("Directory %s writable").isFalse(); @@ -44,8 +44,8 @@ public void shouldThrowInvalidConfigurationExceptionWhenDirectoryNotWritable( @ParameterizedTest @ValueSource(booleans = {true, false}) - public void shouldWriteAndOverwriteFileContent(final boolean useAtomicMove, @TempDir Path tempDir) - throws IOException { + public void shouldWriteAndOverwriteFileContent( + final boolean useAtomicMove, @TempDir final Path tempDir) throws IOException { final Path filePath = Paths.get(tempDir.toString() + "/myfile.tmp"); assertThat(Files.exists(filePath)).isFalse(); final SyncDataAccessor syncDataAccessor = new SyncDataAccessor(useAtomicMove); diff --git a/infrastructure/io/src/test/java/tech/pegasys/teku/infrastructure/io/resource/FileResourceLoaderTest.java b/infrastructure/io/src/test/java/tech/pegasys/teku/infrastructure/io/resource/FileResourceLoaderTest.java index 9e4ea1cd9b5..e9d0cbaac43 100644 --- a/infrastructure/io/src/test/java/tech/pegasys/teku/infrastructure/io/resource/FileResourceLoaderTest.java +++ b/infrastructure/io/src/test/java/tech/pegasys/teku/infrastructure/io/resource/FileResourceLoaderTest.java @@ -32,7 +32,7 @@ class FileResourceLoaderTest { private final FileResourceLoader loader = new FileResourceLoader(__ -> true); @Test - public void shouldLoadFile(@TempDir Path tempDir) throws Exception { + public void shouldLoadFile(@TempDir final Path tempDir) throws Exception { final Path file = tempDir.resolve("test.txt"); Files.write(file, MESSAGE); @@ -40,12 +40,12 @@ public void shouldLoadFile(@TempDir Path tempDir) throws Exception { } @Test - public void shouldReturnEmptyWhenFileDoesNotExist(@TempDir Path tempDir) throws Exception { + public void shouldReturnEmptyWhenFileDoesNotExist(@TempDir final Path tempDir) throws Exception { assertThat(loader.load(tempDir.resolve("test.txt").toAbsolutePath().toString())).isEmpty(); } @Test - public void shouldThrowWhenPathIsADirectory(@TempDir Path tempDir) throws Exception { + public void shouldThrowWhenPathIsADirectory(@TempDir final Path tempDir) throws Exception { // should throw either on opening InputStream from directory or reading from created InputStream assertThatThrownBy( diff --git a/infrastructure/io/src/testFixtures/java/tech/pegasys/teku/cli/OSUtils.java b/infrastructure/io/src/testFixtures/java/tech/pegasys/teku/cli/OSUtils.java index da99a7e4285..20aa5ff5a15 100644 --- a/infrastructure/io/src/testFixtures/java/tech/pegasys/teku/cli/OSUtils.java +++ b/infrastructure/io/src/testFixtures/java/tech/pegasys/teku/cli/OSUtils.java @@ -33,7 +33,7 @@ public class OSUtils { public static final boolean IS_WIN = System.getProperty("os.name").toLowerCase(Locale.ROOT).contains("win"); - public static String toOSPath(String nixPath) { + public static String toOSPath(final String nixPath) { if (IS_WIN) { String ret = nixPath.replace('/', '\\'); if (nixPath.startsWith("/")) { @@ -45,7 +45,7 @@ public static String toOSPath(String nixPath) { } } - public static void makeNonReadable(Path path) throws IOException { + public static void makeNonReadable(final Path path) throws IOException { if (IS_WIN) { removeAslOwnerPermissions(path, Set.of(AclEntryPermission.READ_DATA)); } else { @@ -53,7 +53,7 @@ public static void makeNonReadable(Path path) throws IOException { } } - public static void makeNonWritable(Path path) throws IOException { + public static void makeNonWritable(final Path path) throws IOException { if (IS_WIN) { removeAslOwnerPermissions(path, Set.of(AclEntryPermission.WRITE_DATA)); } else { @@ -65,8 +65,8 @@ public static void makeNonWritable(Path path) throws IOException { } } - private static void removeAslOwnerPermissions(Path path, Set permissions) - throws IOException { + private static void removeAslOwnerPermissions( + final Path path, final Set permissions) throws IOException { AclFileAttributeView fileAttributeView = Files.getFileAttributeView(path, AclFileAttributeView.class); diff --git a/infrastructure/io/src/testFixtures/java/tech/pegasys/teku/cli/TempDirUtils.java b/infrastructure/io/src/testFixtures/java/tech/pegasys/teku/cli/TempDirUtils.java index 9defbc3a069..20c0ac82df9 100644 --- a/infrastructure/io/src/testFixtures/java/tech/pegasys/teku/cli/TempDirUtils.java +++ b/infrastructure/io/src/testFixtures/java/tech/pegasys/teku/cli/TempDirUtils.java @@ -28,7 +28,8 @@ public static Path createTempDir() { } } - public static boolean deleteDirLenient(Path dir, int maxDeleteAttempts, boolean throwIfFailed) { + public static boolean deleteDirLenient( + final Path dir, final int maxDeleteAttempts, final boolean throwIfFailed) { IOException lastException = null; for (int i = 0; i < maxDeleteAttempts; i++) { try { diff --git a/infrastructure/jackson/build.gradle b/infrastructure/jackson/build.gradle index 2cc47ef419e..3f1451d6923 100644 --- a/infrastructure/jackson/build.gradle +++ b/infrastructure/jackson/build.gradle @@ -4,5 +4,5 @@ dependencies { implementation project(':infrastructure:bytes') - implementation 'org.apache.tuweni:tuweni-units' + implementation 'io.tmio:tuweni-units' } \ No newline at end of file diff --git a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/Bytes20Deserializer.java b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/Bytes20Deserializer.java index ba0c12ebba5..e9d53b33024 100644 --- a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/Bytes20Deserializer.java +++ b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/Bytes20Deserializer.java @@ -22,7 +22,8 @@ public class Bytes20Deserializer extends JsonDeserializer { @Override - public Bytes20 deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { + public Bytes20 deserialize(final JsonParser p, final DeserializationContext ctxt) + throws IOException { return Bytes20.fromHexString(p.getValueAsString()); } } diff --git a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/Bytes20Serializer.java b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/Bytes20Serializer.java index 2738a37cca9..1ff0dc2e281 100644 --- a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/Bytes20Serializer.java +++ b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/Bytes20Serializer.java @@ -22,7 +22,8 @@ public class Bytes20Serializer extends JsonSerializer { @Override - public void serialize(Bytes20 value, JsonGenerator gen, SerializerProvider serializers) + public void serialize( + final Bytes20 value, final JsonGenerator gen, final SerializerProvider serializers) throws IOException { gen.writeString(value.toHexString().toLowerCase(Locale.ROOT)); } diff --git a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/Bytes32Deserializer.java b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/Bytes32Deserializer.java index 52a26e75626..5fcd75d8ef1 100644 --- a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/Bytes32Deserializer.java +++ b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/Bytes32Deserializer.java @@ -22,7 +22,8 @@ public class Bytes32Deserializer extends JsonDeserializer { @Override - public Bytes32 deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { + public Bytes32 deserialize(final JsonParser p, final DeserializationContext ctxt) + throws IOException { return Bytes32.fromHexString(p.getValueAsString()); } } diff --git a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/Bytes48KeyDeserializer.java b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/Bytes48KeyDeserializer.java index a5d38eccf25..f10eb2c028c 100644 --- a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/Bytes48KeyDeserializer.java +++ b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/Bytes48KeyDeserializer.java @@ -22,7 +22,8 @@ public class Bytes48KeyDeserializer extends KeyDeserializer { @Override - public Object deserializeKey(String key, DeserializationContext ctxt) throws JacksonException { + public Object deserializeKey(final String key, final DeserializationContext ctxt) + throws JacksonException { try { return Bytes48.fromHexStringStrict(key); } catch (RuntimeException ex) { diff --git a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/Bytes4Deserializer.java b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/Bytes4Deserializer.java index 6bd5b78d220..4aca1c976cb 100644 --- a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/Bytes4Deserializer.java +++ b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/Bytes4Deserializer.java @@ -22,7 +22,8 @@ public class Bytes4Deserializer extends JsonDeserializer { @Override - public Bytes4 deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { + public Bytes4 deserialize(final JsonParser p, final DeserializationContext ctxt) + throws IOException { return Bytes4.fromHexString(p.getValueAsString()); } } diff --git a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/Bytes4Serializer.java b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/Bytes4Serializer.java index f7e3f4a3685..996401c3d24 100644 --- a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/Bytes4Serializer.java +++ b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/Bytes4Serializer.java @@ -22,7 +22,8 @@ public class Bytes4Serializer extends JsonSerializer { @Override - public void serialize(Bytes4 value, JsonGenerator gen, SerializerProvider serializers) + public void serialize( + final Bytes4 value, final JsonGenerator gen, final SerializerProvider serializers) throws IOException { gen.writeString(value.toHexString().toLowerCase(Locale.ROOT)); } diff --git a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/BytesDeserializer.java b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/BytesDeserializer.java index 90c446f84ab..449f8654999 100644 --- a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/BytesDeserializer.java +++ b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/BytesDeserializer.java @@ -22,7 +22,8 @@ public class BytesDeserializer extends JsonDeserializer { @Override - public Bytes deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { + public Bytes deserialize(final JsonParser p, final DeserializationContext ctxt) + throws IOException { return Bytes.fromHexString(p.getValueAsString()); } } diff --git a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/BytesSerializer.java b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/BytesSerializer.java index 9cb90a938b9..2fafab35ae0 100644 --- a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/BytesSerializer.java +++ b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/BytesSerializer.java @@ -22,7 +22,8 @@ public class BytesSerializer extends JsonSerializer { @Override - public void serialize(Bytes value, JsonGenerator gen, SerializerProvider provider) + public void serialize( + final Bytes value, final JsonGenerator gen, final SerializerProvider provider) throws IOException { gen.writeString(value.toHexString().toLowerCase(Locale.ROOT)); } diff --git a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/DoubleDeserializer.java b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/DoubleDeserializer.java index 2811f5e85f2..ba8bce97e68 100644 --- a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/DoubleDeserializer.java +++ b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/DoubleDeserializer.java @@ -21,7 +21,8 @@ public class DoubleDeserializer extends JsonDeserializer { @Override - public Double deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { + public Double deserialize(final JsonParser p, final DeserializationContext ctxt) + throws IOException { return Double.valueOf(p.getValueAsString()); } } diff --git a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/DoubleSerializer.java b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/DoubleSerializer.java index 5ab5c69da1a..5da417213a0 100644 --- a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/DoubleSerializer.java +++ b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/bytes/DoubleSerializer.java @@ -26,12 +26,13 @@ public class DoubleSerializer extends JsonSerializer { private static final DecimalFormatSymbols US_SYMBOLS = new DecimalFormatSymbols(Locale.US); @Override - public void serialize(Double value, JsonGenerator gen, SerializerProvider serializers) + public void serialize( + final Double value, final JsonGenerator gen, final SerializerProvider serializers) throws IOException { gen.writeString(formatValue(value)); } - private String formatValue(Double value) { + private String formatValue(final Double value) { DecimalFormat df = new DecimalFormat("#.####", US_SYMBOLS); df.setRoundingMode(RoundingMode.HALF_UP); return df.format(value); diff --git a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/uints/UInt256Deserializer.java b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/uints/UInt256Deserializer.java index 3bb091b96c2..1370bc9b6d4 100644 --- a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/uints/UInt256Deserializer.java +++ b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/uints/UInt256Deserializer.java @@ -23,7 +23,8 @@ public class UInt256Deserializer extends JsonDeserializer { @Override - public UInt256 deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { + public UInt256 deserialize(final JsonParser p, final DeserializationContext ctxt) + throws IOException { String value = p.getValueAsString(); if (value.startsWith("0x")) { return UInt256.fromHexString(p.getValueAsString()); diff --git a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/uints/UInt256Serializer.java b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/uints/UInt256Serializer.java index f3029ac636a..899c2d4bc1c 100644 --- a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/uints/UInt256Serializer.java +++ b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/uints/UInt256Serializer.java @@ -21,7 +21,8 @@ public class UInt256Serializer extends JsonSerializer { @Override - public void serialize(UInt256 value, JsonGenerator gen, SerializerProvider serializers) + public void serialize( + final UInt256 value, final JsonGenerator gen, final SerializerProvider serializers) throws IOException { gen.writeString(value.toDecimalString()); } diff --git a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/uints/UInt64Deserializer.java b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/uints/UInt64Deserializer.java index b095fe0f08a..44cc016d84a 100644 --- a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/uints/UInt64Deserializer.java +++ b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/uints/UInt64Deserializer.java @@ -22,7 +22,8 @@ public class UInt64Deserializer extends JsonDeserializer { @Override - public UInt64 deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { + public UInt64 deserialize(final JsonParser p, final DeserializationContext ctxt) + throws IOException { return UInt64.valueOf(p.getValueAsString()); } } diff --git a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/uints/UInt64Serializer.java b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/uints/UInt64Serializer.java index 9ad4bf3658b..49ff1af4a30 100644 --- a/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/uints/UInt64Serializer.java +++ b/infrastructure/jackson/src/main/java/tech/pegasys/teku/infrastructure/jackson/deserializers/uints/UInt64Serializer.java @@ -21,7 +21,8 @@ public class UInt64Serializer extends JsonSerializer { @Override - public void serialize(UInt64 value, JsonGenerator gen, SerializerProvider serializers) + public void serialize( + final UInt64 value, final JsonGenerator gen, final SerializerProvider serializers) throws IOException { gen.writeString(value.toString()); } diff --git a/infrastructure/json/build.gradle b/infrastructure/json/build.gradle index e4497753d55..71fdb655df2 100644 --- a/infrastructure/json/build.gradle +++ b/infrastructure/json/build.gradle @@ -5,7 +5,7 @@ dependencies { implementation project(':infrastructure:logging') implementation 'com.fasterxml.jackson.core:jackson-databind' - implementation 'org.apache.tuweni:tuweni-units' + implementation 'io.tmio:tuweni-units' testFixturesImplementation 'com.fasterxml.jackson.core:jackson-databind' testFixturesImplementation 'commons-io:commons-io' diff --git a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/JsonUtil.java b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/JsonUtil.java index da74e68f02e..2e01f7ac4e3 100644 --- a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/JsonUtil.java +++ b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/JsonUtil.java @@ -18,6 +18,7 @@ import com.fasterxml.jackson.core.JsonParser; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.core.JsonToken; +import com.fasterxml.jackson.core.util.DefaultPrettyPrinter; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; @@ -37,10 +38,19 @@ public static String serialize(final T value, final SerializableTypeDefiniti return serialize(gen -> type.serialize(value, gen)); } + public static String prettySerialize(final T value, final SerializableTypeDefinition type) + throws JsonProcessingException { + return prettySerialize(gen -> type.serialize(value, gen)); + } + public static String serialize(final JsonWriter serializer) throws JsonProcessingException { return serialize(FACTORY, serializer); } + public static String prettySerialize(final JsonWriter serializer) throws JsonProcessingException { + return prettySerialize(FACTORY, serializer); + } + public static String serialize(final JsonFactory factory, final JsonWriter serializer) throws JsonProcessingException { final StringWriter writer = new StringWriter(); @@ -54,6 +64,20 @@ public static String serialize(final JsonFactory factory, final JsonWriter seria return writer.toString(); } + public static String prettySerialize(final JsonFactory factory, final JsonWriter serializer) + throws JsonProcessingException { + final StringWriter writer = new StringWriter(); + try (final JsonGenerator gen = factory.createGenerator(writer)) { + gen.setPrettyPrinter(new DefaultPrettyPrinter()); + serializer.accept(gen); + } catch (final JsonProcessingException e) { + throw e; + } catch (final IOException e) { + throw new UncheckedIOException(e); + } + return writer.toString(); + } + public static void serializeToBytes( final T value, final SerializableTypeDefinition type, final OutputStream out) throws JsonProcessingException { @@ -155,7 +179,7 @@ private static Optional getAttributeFromParser( while (!parser.isClosed()) { final JsonToken jsonToken = parser.nextToken(); if (JsonToken.FIELD_NAME.equals(jsonToken)) { - final String currentFieldName = parser.getCurrentName(); + final String currentFieldName = parser.currentName(); if (currentFieldName.equals(fieldName)) { if (path.length == i + 1) { parser.nextToken(); diff --git a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/exceptions/BadRequestException.java b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/exceptions/BadRequestException.java index cf142e8996b..d069f2538bf 100644 --- a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/exceptions/BadRequestException.java +++ b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/exceptions/BadRequestException.java @@ -16,11 +16,11 @@ import com.fasterxml.jackson.core.JsonProcessingException; public class BadRequestException extends JsonProcessingException { - public BadRequestException(String message, Throwable cause) { + public BadRequestException(final String message, final Throwable cause) { super(message, cause); } - public BadRequestException(String message) { + public BadRequestException(final String message) { super(message); } } diff --git a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/BooleanHeaderTypeDefinition.java b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/BooleanHeaderTypeDefinition.java new file mode 100644 index 00000000000..43f0aa26f95 --- /dev/null +++ b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/BooleanHeaderTypeDefinition.java @@ -0,0 +1,49 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.infrastructure.json.types; + +import com.fasterxml.jackson.core.JsonGenerator; +import java.io.IOException; +import java.util.Optional; + +public class BooleanHeaderTypeDefinition extends BooleanTypeDefinition { + private final String title; + private final Optional required; + + public BooleanHeaderTypeDefinition( + final String title, final Optional required, final String description) { + super(description); + this.title = title; + this.required = required; + } + + @Override + public void serializeOpenApiType(final JsonGenerator gen) throws IOException { + gen.writeFieldName(title); + gen.writeStartObject(); + + if (description.isPresent()) { + gen.writeStringField("description", description.get()); + } + if (required.isPresent()) { + gen.writeBooleanField("required", required.get()); + } + gen.writeFieldName("schema"); + gen.writeStartObject(); + gen.writeStringField("type", "boolean"); + gen.writeEndObject(); + + gen.writeEndObject(); + } +} diff --git a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/BooleanTypeDefinition.java b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/BooleanTypeDefinition.java index ead7dc69c2a..783e143c4e7 100644 --- a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/BooleanTypeDefinition.java +++ b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/BooleanTypeDefinition.java @@ -20,7 +20,7 @@ import java.util.Optional; public class BooleanTypeDefinition implements StringValueTypeDefinition { - private final Optional description; + final Optional description; public BooleanTypeDefinition() { this.description = Optional.empty(); diff --git a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/CoreTypes.java b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/CoreTypes.java index 179ac721a9f..f3837f07cd8 100644 --- a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/CoreTypes.java +++ b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/CoreTypes.java @@ -114,6 +114,10 @@ public static StringValueTypeDefinition string( return stringBuilder().description(description).example(example).build(); } + public static StringValueTypeDefinition flag(final String description) { + return stringBuilder().description(description).minLength(0).maxLength(0).build(); + } + private static StringTypeBuilder stringBuilder() { return DeserializableTypeDefinition.string(String.class) .formatter(Function.identity()) diff --git a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/DeserializableMapTypeDefinition.java b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/DeserializableMapTypeDefinition.java index 125fbd87537..d9899f79bb4 100644 --- a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/DeserializableMapTypeDefinition.java +++ b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/DeserializableMapTypeDefinition.java @@ -61,7 +61,7 @@ public Map deserialize(final JsonParser p) throws IOException { t = p.nextToken(); } for (; t == JsonToken.FIELD_NAME; t = p.nextToken()) { - final String fieldName = p.getCurrentName(); + final String fieldName = p.currentName(); p.nextToken(); final TValue fieldValue = valueType.deserialize(p); result.put(keyType.deserializeFromString(fieldName), fieldValue); diff --git a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/DeserializableObjectTypeDefinition.java b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/DeserializableObjectTypeDefinition.java index 0805cefba27..4c9f1e59986 100644 --- a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/DeserializableObjectTypeDefinition.java +++ b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/DeserializableObjectTypeDefinition.java @@ -66,7 +66,7 @@ public TObject deserialize(final JsonParser p) throws IOException { } final Set presentFields = new HashSet<>(); for (; t == JsonToken.FIELD_NAME; t = p.nextToken()) { - String fieldName = p.getCurrentName(); + String fieldName = p.currentName(); p.nextToken(); final DeserializableFieldDefinition fieldDefinition = deserializableFields.get(fieldName); diff --git a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/DeserializableObjectTypeDefinitionBuilder.java b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/DeserializableObjectTypeDefinitionBuilder.java index 4323d2e76c8..2b962cb9652 100644 --- a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/DeserializableObjectTypeDefinitionBuilder.java +++ b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/DeserializableObjectTypeDefinitionBuilder.java @@ -50,7 +50,7 @@ public DeserializableObjectTypeDefinitionBuilder description( } public DeserializableObjectTypeDefinitionBuilder initializer( - Supplier initializer) { + final Supplier initializer) { this.initializer = initializer; return this; } diff --git a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/DeserializableOneOfTypeDefinition.java b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/DeserializableOneOfTypeDefinition.java index 397abc3aaa8..7b623610c59 100644 --- a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/DeserializableOneOfTypeDefinition.java +++ b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/DeserializableOneOfTypeDefinition.java @@ -25,22 +25,21 @@ public class DeserializableOneOfTypeDefinition private final Map, DeserializableTypeDefinition> parserTypes; DeserializableOneOfTypeDefinition( - Optional name, - Optional title, - Optional description, - Map, DeserializableTypeDefinition> types, - Map, DeserializableTypeDefinition> parserTypes) { + final Optional name, + final Optional title, + final Optional description, + final Map, DeserializableTypeDefinition> types, + final Map, DeserializableTypeDefinition> parserTypes) { super(name, title, description, types); this.parserTypes = parserTypes; } - public static - DeserializableOneOfTypeDefinitionBuilder object( - @SuppressWarnings("unused") final Class type) { + public static DeserializableOneOfTypeDefinitionBuilder object( + @SuppressWarnings("unused") final Class type) { return object(); } - static DeserializableOneOfTypeDefinitionBuilder object() { + static DeserializableOneOfTypeDefinitionBuilder object() { return new DeserializableOneOfTypeDefinitionBuilder<>(); } diff --git a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/DeserializableOneOfTypeDefinitionBuilder.java b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/DeserializableOneOfTypeDefinitionBuilder.java index ccf26711241..8a1112633a8 100644 --- a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/DeserializableOneOfTypeDefinitionBuilder.java +++ b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/DeserializableOneOfTypeDefinitionBuilder.java @@ -18,7 +18,7 @@ import java.util.Optional; import java.util.function.Predicate; -public class DeserializableOneOfTypeDefinitionBuilder { +public class DeserializableOneOfTypeDefinitionBuilder { private final Map, DeserializableTypeDefinition> types = new LinkedHashMap<>(); @@ -31,23 +31,22 @@ public class DeserializableOneOfTypeDefinitionBuilder { DeserializableOneOfTypeDefinitionBuilder() {} - public DeserializableOneOfTypeDefinitionBuilder name(final String name) { + public DeserializableOneOfTypeDefinitionBuilder name(final String name) { this.name = Optional.of(name); return this; } - public DeserializableOneOfTypeDefinitionBuilder title(final String title) { + public DeserializableOneOfTypeDefinitionBuilder title(final String title) { this.title = Optional.of(title); return this; } - public DeserializableOneOfTypeDefinitionBuilder description( - final String description) { + public DeserializableOneOfTypeDefinitionBuilder description(final String description) { this.description = Optional.of(description); return this; } - public DeserializableOneOfTypeDefinitionBuilder withType( + public DeserializableOneOfTypeDefinitionBuilder withType( final Predicate predicate, final Predicate parserType, final DeserializableTypeDefinition typeDefinition) { diff --git a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/DeserializableTypeDefinition.java b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/DeserializableTypeDefinition.java index f86d0293ae5..79123ba9586 100644 --- a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/DeserializableTypeDefinition.java +++ b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/DeserializableTypeDefinition.java @@ -13,12 +13,13 @@ package tech.pegasys.teku.infrastructure.json.types; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.STRING_TYPE; + import com.fasterxml.jackson.core.JsonParser; import java.io.IOException; import java.util.List; import java.util.Map; import java.util.Optional; -import java.util.Set; import java.util.TreeMap; import java.util.function.Function; import java.util.function.Supplier; @@ -47,7 +48,7 @@ static DeserializableTypeDefinition> listOf( } static DeserializableTypeDefinition> mapOfStrings() { - return mapOf(CoreTypes.STRING_TYPE, CoreTypes.STRING_TYPE, TreeMap::new); + return mapOf(STRING_TYPE, STRING_TYPE, TreeMap::new); } static DeserializableTypeDefinition> mapOf( @@ -57,21 +58,14 @@ static DeserializableTypeDefinition> mapOf( return new DeserializableMapTypeDefinition<>(keyType, valueType, mapConstructor); } - static > DeserializableTypeDefinition enumOf( + static > EnumTypeDefinition enumOf( final Class itemType) { - return new EnumTypeDefinition<>(itemType); - } - - static > DeserializableTypeDefinition enumOf( - final Class itemType, final Function serializer) { - return new EnumTypeDefinition<>(itemType, serializer); + return new EnumTypeDefinition.EnumTypeBuilder<>(itemType, false).build(); } - static > DeserializableTypeDefinition enumOf( - final Class itemType, - final Function serializer, - final Set excludedEnumerations) { - return new EnumTypeDefinition<>(itemType, serializer, excludedEnumerations); + static > EnumTypeDefinition enumOf( + final Class itemType, final boolean forceLowercase) { + return new EnumTypeDefinition.EnumTypeBuilder<>(itemType, forceLowercase).build(); } static DeserializableObjectTypeDefinitionBuilder object( diff --git a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/EnumHeaderTypeDefinition.java b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/EnumHeaderTypeDefinition.java new file mode 100644 index 00000000000..b2a66f9dda4 --- /dev/null +++ b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/EnumHeaderTypeDefinition.java @@ -0,0 +1,203 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.infrastructure.json.types; + +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.core.JsonParser; +import java.io.IOException; +import java.util.Objects; +import java.util.Optional; +import java.util.function.Function; + +public class EnumHeaderTypeDefinition> implements StringValueTypeDefinition { + final Class itemType; + private final Function serializer; + private final Optional name; + private final String title; + private final Optional required; + private final Optional description; + private final Optional example; + + public EnumHeaderTypeDefinition( + final Class itemType, + final Function serializer, + final Optional name, + final String title, + final Optional required, + final Optional description, + final Optional example) { + this.itemType = itemType; + this.serializer = serializer; + this.name = name; + this.title = title; + this.required = required; + this.description = description; + this.example = example; + } + + @Override + public Optional getTypeName() { + return name; + } + + @Override + public T deserialize(final JsonParser parser) throws IOException { + return deserializeFromString(parser.getValueAsString()); + } + + @Override + public void serialize(final T value, final JsonGenerator gen) throws IOException { + gen.writeString(serializeToString(value)); + } + + @Override + public void serializeOpenApiType(final JsonGenerator gen) throws IOException { + gen.writeFieldName(title); + gen.writeStartObject(); + + if (description.isPresent()) { + gen.writeStringField("description", description.get()); + } + if (required.isPresent()) { + gen.writeBooleanField("required", required.get()); + } + gen.writeFieldName("schema"); + gen.writeStartObject(); + gen.writeStringField("type", "string"); + + gen.writeArrayFieldStart("enum"); + + for (T value : itemType.getEnumConstants()) { + gen.writeString(serializeToString(value)); + } + gen.writeEndArray(); + + if (example.isPresent()) { + gen.writeStringField("example", example.get()); + } + gen.writeEndObject(); + gen.writeEndObject(); + } + + @Override + public String serializeToString(final T value) { + return value != null ? serializer.apply(value) : null; + } + + @Override + public T deserializeFromString(final String value) { + for (T t : itemType.getEnumConstants()) { + if (t.toString().equalsIgnoreCase(value)) { + return t; + } + } + throw new IllegalArgumentException("Unknown enum value: " + value); + } + + @Override + public StringValueTypeDefinition withDescription(final String description) { + return new EnumHeaderTypeDefinition<>( + itemType, serializer, Optional.empty(), title, required, Optional.of(description), example); + } + + @Override + public String toString() { + return "EnumTypeHeaderDefinition{" + + "itemType=" + + itemType + + ", serializer=" + + serializer + + ", name=" + + name + + ", title='" + + title + + '\'' + + ", required=" + + required + + ", description=" + + description + + ", example=" + + example + + '}'; + } + + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + final EnumHeaderTypeDefinition that = (EnumHeaderTypeDefinition) o; + return Objects.equals(itemType, that.itemType) + && Objects.equals(serializer, that.serializer) + && Objects.equals(name, that.name) + && Objects.equals(title, that.title) + && Objects.equals(required, that.required) + && Objects.equals(description, that.description) + && Objects.equals(example, that.example); + } + + @Override + public int hashCode() { + return Objects.hash(itemType, serializer, name, title, required, description, example); + } + + public static class EnumTypeHeaderDefinitionBuilder> { + private final Class itemType; + private final Function serializer; + private Optional name = Optional.empty(); + private String title; + private Optional required = Optional.empty(); + private Optional description = Optional.empty(); + private Optional example = Optional.empty(); + + public EnumTypeHeaderDefinitionBuilder( + final Class itemType, final Function serializer) { + this.itemType = itemType; + this.serializer = serializer; + } + + public EnumTypeHeaderDefinitionBuilder name(final String name) { + this.name = Optional.of(name); + return this; + } + + public EnumTypeHeaderDefinitionBuilder title(final String title) { + this.title = title; + return this; + } + + public EnumTypeHeaderDefinitionBuilder required(final Boolean required) { + this.required = Optional.of(required); + return this; + } + + public EnumTypeHeaderDefinitionBuilder description(final String description) { + this.description = Optional.of(description); + return this; + } + + public EnumTypeHeaderDefinitionBuilder example(final String example) { + this.example = Optional.of(example); + return this; + } + + public EnumHeaderTypeDefinition build() { + return new EnumHeaderTypeDefinition<>( + itemType, serializer, name, title, required, description, example); + } + } +} diff --git a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/EnumTypeDefinition.java b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/EnumTypeDefinition.java index 70336e78152..b15f5071012 100644 --- a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/EnumTypeDefinition.java +++ b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/EnumTypeDefinition.java @@ -17,7 +17,9 @@ import com.fasterxml.jackson.core.JsonParser; import java.io.IOException; import java.util.HashSet; +import java.util.Locale; import java.util.Objects; +import java.util.Optional; import java.util.Set; import java.util.function.Function; @@ -26,6 +28,9 @@ public class EnumTypeDefinition> extends PrimitiveTypeDefiniti private final Function serializer; private final Set excludedEnumerations = new HashSet<>(); + private Optional example = Optional.empty(); + private Optional description = Optional.empty(); + private Optional format = Optional.empty(); public EnumTypeDefinition(final Class itemType) { this(itemType, Objects::toString); @@ -45,6 +50,21 @@ public EnumTypeDefinition( this.excludedEnumerations.addAll(excludedEnumerations); } + public EnumTypeDefinition( + final Class itemType, + final Function serializer, + final Optional example, + final Optional description, + final Optional format, + final Optional> excludedEnumerations) { + this.itemType = itemType; + this.serializer = serializer; + this.example = example; + this.description = description; + this.format = format; + excludedEnumerations.ifPresent(this.excludedEnumerations::addAll); + } + @Override public T deserialize(final JsonParser parser) throws IOException { return deserializeFromString(parser.getValueAsString()); @@ -53,6 +73,17 @@ public T deserialize(final JsonParser parser) throws IOException { @Override public void serializeOpenApiTypeFields(final JsonGenerator gen) throws IOException { gen.writeStringField("type", "string"); + + if (description.isPresent()) { + gen.writeStringField("description", description.get()); + } + if (example.isPresent()) { + gen.writeStringField("example", example.get()); + } + if (format.isPresent()) { + gen.writeStringField("format", format.get()); + } + gen.writeArrayFieldStart("enum"); for (T value : itemType.getEnumConstants()) { @@ -90,6 +121,66 @@ public T deserializeFromString(final String value) { throw new IllegalArgumentException("Unknown enum value: " + value); } + public static class EnumTypeBuilder> { + + private Class itemType; + private Function serializer; + private Optional example = Optional.empty(); + private Optional description = Optional.empty(); + private Optional format = Optional.empty(); + private Optional> excludedEnumerations = Optional.empty(); + + public EnumTypeBuilder(final Class itemType, final Function serializer) { + this.itemType = itemType; + this.serializer = serializer; + } + + public EnumTypeBuilder(final Class itemType) { + this(itemType, false); + } + + public EnumTypeBuilder(final Class itemType, final boolean forceLowercase) { + this( + itemType, + forceLowercase ? (val) -> val.toString().toLowerCase(Locale.ROOT) : Enum::toString); + } + + public EnumTypeBuilder parser(final Class itemType) { + this.itemType = itemType; + return this; + } + + public EnumTypeBuilder parser(final Function serializer) { + this.serializer = serializer; + return this; + } + + public EnumTypeBuilder example(final String example) { + this.example = Optional.of(example); + return this; + } + + public EnumTypeBuilder description(final String description) { + this.description = Optional.of(description); + return this; + } + + public EnumTypeBuilder format(final String format) { + this.format = Optional.of(format); + return this; + } + + public EnumTypeBuilder excludedEnumerations(final Set excludedEnumerations) { + this.excludedEnumerations = Optional.of(excludedEnumerations); + return this; + } + + public EnumTypeDefinition build() { + return new EnumTypeDefinition<>( + itemType, serializer, example, description, format, excludedEnumerations); + } + } + @Override public boolean equals(final Object o) { if (this == o) { @@ -99,11 +190,15 @@ public boolean equals(final Object o) { return false; } final EnumTypeDefinition that = (EnumTypeDefinition) o; - return Objects.equals(itemType, that.itemType); + return Objects.equals(itemType, that.itemType) + && Objects.equals(example, that.example) + && Objects.equals(description, that.description) + && Objects.equals(format, that.format) + && Objects.equals(excludedEnumerations, that.excludedEnumerations); } @Override public int hashCode() { - return Objects.hash(itemType); + return Objects.hash(itemType, example, description, format, excludedEnumerations); } } diff --git a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/OpenApiTypeDefinition.java b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/OpenApiTypeDefinition.java index 34551b80b2a..b61f6e79713 100644 --- a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/OpenApiTypeDefinition.java +++ b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/OpenApiTypeDefinition.java @@ -39,7 +39,7 @@ default Collection getSelfAndReferencedTypeDefinitions() return Stream.concat(Stream.of(this), getReferencedTypeDefinitions().stream()).collect(toSet()); } - default boolean isEquivalentToDeserializableType(DeserializableTypeDefinition type) { + default boolean isEquivalentToDeserializableType(final DeserializableTypeDefinition type) { return this == type; } diff --git a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/SerializableOneOfTypeDefinition.java b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/SerializableOneOfTypeDefinition.java index d86d1132007..53fda267e93 100644 --- a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/SerializableOneOfTypeDefinition.java +++ b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/SerializableOneOfTypeDefinition.java @@ -75,7 +75,8 @@ public void serializeOpenApiType(final JsonGenerator gen) throws IOException { } gen.writeStringField("type", "object"); gen.writeArrayFieldStart("oneOf"); - for (SerializableTypeDefinition t : types.values()) { + for (SerializableTypeDefinition t : + types.values().stream().distinct().toList()) { t.serializeOpenApiTypeOrReference(gen); } gen.writeEndArray(); @@ -84,7 +85,7 @@ public void serializeOpenApiType(final JsonGenerator gen) throws IOException { @SuppressWarnings({"rawtypes", "unchecked"}) @Override - public void serialize(TObject value, final JsonGenerator gen) throws IOException { + public void serialize(final TObject value, final JsonGenerator gen) throws IOException { SerializableTypeDefinition typeDefinition = null; // entryset for (Predicate predicate : types.keySet()) { diff --git a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/SerializableTypeDefinition.java b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/SerializableTypeDefinition.java index 182787436ff..427e7da0895 100644 --- a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/SerializableTypeDefinition.java +++ b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/SerializableTypeDefinition.java @@ -32,7 +32,8 @@ static SerializableObjectTypeDefinitionBuilder object() { return new SerializableObjectTypeDefinitionBuilder<>(); } - static SerializableTypeDefinition> listOf(SerializableTypeDefinition itemType) { + static SerializableTypeDefinition> listOf( + final SerializableTypeDefinition itemType) { return new SerializableArrayTypeDefinition<>(itemType); } } diff --git a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/StringBasedHeaderTypeDefinition.java b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/StringBasedHeaderTypeDefinition.java new file mode 100644 index 00000000000..caf8632793f --- /dev/null +++ b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/StringBasedHeaderTypeDefinition.java @@ -0,0 +1,172 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.infrastructure.json.types; + +import static com.google.common.base.Preconditions.checkNotNull; + +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.databind.exc.MismatchedInputException; +import java.io.IOException; +import java.util.Optional; +import java.util.function.Function; + +public class StringBasedHeaderTypeDefinition implements StringValueTypeDefinition { + private final Optional name; + private final Optional title; + private final Optional example; + private final Optional description; + private final Optional required; + final Function objectFromString; + final Function stringFromObject; + + public StringBasedHeaderTypeDefinition( + final Optional name, + final Optional title, + final Optional example, + final Optional description, + final Optional required, + final Function objectFromString, + final Function stringFromObject) { + this.name = name; + this.title = title; + this.example = example; + this.description = description; + this.required = required; + this.objectFromString = objectFromString; + this.stringFromObject = stringFromObject; + } + + @Override + public Optional getTypeName() { + return name; + } + + @Override + public void serializeOpenApiType(final JsonGenerator gen) throws IOException { + if (title.isPresent()) { + gen.writeFieldName(title.get()); + gen.writeStartObject(); + + if (description.isPresent()) { + gen.writeStringField("description", description.get()); + } + if (required.isPresent()) { + gen.writeBooleanField("required", required.get()); + } + gen.writeFieldName("schema"); + gen.writeStartObject(); + gen.writeStringField("type", "string"); + + if (example.isPresent()) { + gen.writeStringField("example", example.get()); + } + gen.writeEndObject(); + gen.writeEndObject(); + } + } + + @Override + public String serializeToString(final T value) { + return stringFromObject.apply(value); + } + + @Override + public T deserializeFromString(final String value) { + try { + return objectFromString.apply(value); + } catch (RuntimeException ex) { + throw new IllegalArgumentException(ex.getMessage(), ex); + } + } + + @Override + public T deserialize(final JsonParser parser) throws IOException { + if (!parser.getCurrentToken().isScalarValue()) { + throw MismatchedInputException.from( + parser, String.class, "Expected scalar value but got " + parser.getCurrentToken()); + } + return deserializeFromString(parser.getValueAsString()); + } + + @Override + public void serialize(final T value, final JsonGenerator gen) throws IOException { + gen.writeString(stringFromObject.apply(value)); + } + + @Override + public StringValueTypeDefinition withDescription(final String description) { + return new StringBasedHeaderTypeDefinition<>( + Optional.empty(), + title, + example, + Optional.of(description), + required, + objectFromString, + stringFromObject); + } + + public static class Builder { + private Optional name = Optional.empty(); + private Optional title = Optional.empty(); + private Optional example = Optional.empty(); + private Optional description = Optional.empty(); + private Optional required = Optional.empty(); + private Function parser; + private Function formatter; + + public Builder name(final String name) { + this.name = Optional.of(name); + return this; + } + + public Builder title(final String title) { + this.title = Optional.of(title); + return this; + } + + public Builder example(final String example) { + this.example = Optional.of(example); + return this; + } + + public Builder description(final String description) { + this.description = Optional.of(description); + return this; + } + + public Builder required(final Boolean required) { + this.required = Optional.of(required); + return this; + } + + public Builder parser(final Function parser) { + this.parser = parser; + return this; + } + + public Builder formatter(final Function formatter) { + this.formatter = formatter; + return this; + } + + public StringBasedHeaderTypeDefinition build() { + checkNotNull(parser, "Must specify parser"); + checkNotNull(formatter, "Must specify formatter"); + + return new StringBasedHeaderTypeDefinition<>( + name, title, example, description, required, parser, formatter); + } + } +} diff --git a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/StringBasedPrimitiveTypeDefinition.java b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/StringBasedPrimitiveTypeDefinition.java index f712a03490c..dace7aab911 100644 --- a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/StringBasedPrimitiveTypeDefinition.java +++ b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/StringBasedPrimitiveTypeDefinition.java @@ -34,6 +34,8 @@ public class StringBasedPrimitiveTypeDefinition implements StringValueTypeDef private final Optional example; private final Optional format; private final Optional pattern; + private final Optional minLength; + private final Optional maxLength; private StringBasedPrimitiveTypeDefinition( final Optional name, @@ -43,7 +45,9 @@ private StringBasedPrimitiveTypeDefinition( final Optional example, final Optional description, final Optional format, - final Optional pattern) { + final Optional pattern, + final Optional minLength, + final Optional maxLength) { this.name = name; this.title = title; this.objectFromString = objectFromString; @@ -52,6 +56,8 @@ private StringBasedPrimitiveTypeDefinition( this.description = description; this.format = format; this.pattern = pattern; + this.minLength = minLength; + this.maxLength = maxLength; } @Override @@ -78,7 +84,9 @@ public StringValueTypeDefinition withDescription(final String description) { example, Optional.of(description), format, - pattern); + pattern, + minLength, + maxLength); } @Override @@ -105,6 +113,12 @@ public void serializeOpenApiType(final JsonGenerator gen) throws IOException { if (format.isPresent()) { gen.writeStringField("format", format.get()); } + if (minLength.isPresent()) { + gen.writeNumberField("minLength", minLength.get()); + } + if (maxLength.isPresent()) { + gen.writeNumberField("maxLength", maxLength.get()); + } gen.writeEndObject(); } @@ -117,6 +131,8 @@ public String toString() { .add("example", example) .add("format", format) .add("pattern", pattern) + .add("minLength", minLength) + .add("maxLength", maxLength) .toString(); } @@ -144,6 +160,8 @@ public static class StringTypeBuilder { private Optional description = Optional.empty(); private Optional format = Optional.empty(); private Optional pattern = Optional.empty(); + private Optional minLength = Optional.empty(); + private Optional maxLength = Optional.empty(); public StringTypeBuilder name(final String name) { this.name = Optional.of(name); @@ -185,12 +203,31 @@ public StringTypeBuilder pattern(final String pattern) { return this; } + public StringTypeBuilder minLength(final int minLength) { + this.minLength = Optional.of(minLength); + return this; + } + + public StringTypeBuilder maxLength(final int maxLength) { + this.maxLength = Optional.of(maxLength); + return this; + } + public StringValueTypeDefinition build() { checkNotNull(parser, "Must specify parser"); checkNotNull(formatter, "Must specify formatter"); return new StringBasedPrimitiveTypeDefinition<>( - name, title.or(() -> name), parser, formatter, example, description, format, pattern); + name, + title.or(() -> name), + parser, + formatter, + example, + description, + format, + pattern, + minLength, + maxLength); } } @@ -208,11 +245,13 @@ public boolean equals(final Object o) { && Objects.equals(description, that.description) && Objects.equals(example, that.example) && Objects.equals(format, that.format) - && Objects.equals(pattern, that.pattern); + && Objects.equals(pattern, that.pattern) + && Objects.equals(minLength, that.minLength) + && Objects.equals(maxLength, that.maxLength); } @Override public int hashCode() { - return Objects.hash(name, title, description, example, format, pattern); + return Objects.hash(name, title, description, example, format, pattern, minLength, maxLength); } } diff --git a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/UInt8TypeDefinition.java b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/UInt8TypeDefinition.java index be35aa375a0..4f40a34bb3b 100644 --- a/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/UInt8TypeDefinition.java +++ b/infrastructure/json/src/main/java/tech/pegasys/teku/infrastructure/json/types/UInt8TypeDefinition.java @@ -63,7 +63,7 @@ public Byte deserializeFromString(final String valueAsString) { } @Override - public PrimitiveTypeDefinition withDescription(String description) { + public PrimitiveTypeDefinition withDescription(final String description) { return new UInt8TypeDefinition(description); } } diff --git a/infrastructure/json/src/property-test/java/tech/pegasys/teku/infrastructure/json/types/ByteTypeDefinitionPropertyTest.java b/infrastructure/json/src/property-test/java/tech/pegasys/teku/infrastructure/json/types/ByteTypeDefinitionPropertyTest.java index 00ff741644b..a122477d9dc 100644 --- a/infrastructure/json/src/property-test/java/tech/pegasys/teku/infrastructure/json/types/ByteTypeDefinitionPropertyTest.java +++ b/infrastructure/json/src/property-test/java/tech/pegasys/teku/infrastructure/json/types/ByteTypeDefinitionPropertyTest.java @@ -24,12 +24,12 @@ public class ByteTypeDefinitionPropertyTest { @Property - void roundTrip(@ForAll Byte value) throws JsonProcessingException { + void roundTrip(@ForAll final Byte value) throws JsonProcessingException { assertRoundTrip(value, CoreTypes.BYTE_TYPE); } @Property - void shouldRejectInvalidRange(@ForAll int value) throws JsonProcessingException { + void shouldRejectInvalidRange(@ForAll final int value) throws JsonProcessingException { final String serialized = "\"" + Integer.toHexString(value) + "\""; if (value >= 0 && value <= 255) { assertThat(JsonUtil.parse(serialized, CoreTypes.BYTE_TYPE)).isEqualTo((byte) value); diff --git a/infrastructure/json/src/property-test/java/tech/pegasys/teku/infrastructure/json/types/UInt8TypeDefinitionPropertyTest.java b/infrastructure/json/src/property-test/java/tech/pegasys/teku/infrastructure/json/types/UInt8TypeDefinitionPropertyTest.java index efa416ff67f..0cefb854190 100644 --- a/infrastructure/json/src/property-test/java/tech/pegasys/teku/infrastructure/json/types/UInt8TypeDefinitionPropertyTest.java +++ b/infrastructure/json/src/property-test/java/tech/pegasys/teku/infrastructure/json/types/UInt8TypeDefinitionPropertyTest.java @@ -24,12 +24,12 @@ public class UInt8TypeDefinitionPropertyTest { @Property - void roundTrip(@ForAll Byte value) throws JsonProcessingException { + void roundTrip(@ForAll final Byte value) throws JsonProcessingException { assertRoundTrip(value, CoreTypes.UINT8_TYPE); } @Property - void shouldRejectInvalidRange(@ForAll int value) throws JsonProcessingException { + void shouldRejectInvalidRange(@ForAll final int value) throws JsonProcessingException { final String serialized = "\"" + value + "\""; if (value >= 0 && value <= 255) { assertThat(JsonUtil.parse(serialized, CoreTypes.UINT8_TYPE)).isEqualTo((byte) value); diff --git a/infrastructure/json/src/test/java/tech/pegasys/teku/infrastructure/json/types/BooleanHeaderTypeDefinitionTest.java b/infrastructure/json/src/test/java/tech/pegasys/teku/infrastructure/json/types/BooleanHeaderTypeDefinitionTest.java new file mode 100644 index 00000000000..645d91d287e --- /dev/null +++ b/infrastructure/json/src/test/java/tech/pegasys/teku/infrastructure/json/types/BooleanHeaderTypeDefinitionTest.java @@ -0,0 +1,47 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.infrastructure.json.types; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.databind.ObjectMapper; +import java.io.IOException; +import java.io.StringWriter; +import java.util.Optional; +import org.junit.jupiter.api.Test; + +public class BooleanHeaderTypeDefinitionTest { + + @Test + public void serializeOpenApiType() throws IOException { + + final BooleanHeaderTypeDefinition definition = + new BooleanHeaderTypeDefinition("MyBoolean", Optional.of(true), "This is a boolean header"); + + final StringWriter writer = new StringWriter(); + final JsonGenerator gen = new ObjectMapper().getFactory().createGenerator(writer); + + gen.writeStartObject(); + definition.serializeOpenApiType(gen); + gen.writeEndObject(); + gen.close(); + + final String json = writer.toString(); + + final String expectedJson = + "{\"MyBoolean\":{\"description\":\"This is a boolean header\",\"required\":true,\"schema\":{\"type\":\"boolean\"}}}"; + assertEquals(expectedJson, json); + } +} diff --git a/infrastructure/json/src/test/java/tech/pegasys/teku/infrastructure/json/types/DeserializableOneOfTypeDefinitionBuilderTest.java b/infrastructure/json/src/test/java/tech/pegasys/teku/infrastructure/json/types/DeserializableOneOfTypeDefinitionBuilderTest.java index 3fd23cdaf81..fb6f1f7a88d 100644 --- a/infrastructure/json/src/test/java/tech/pegasys/teku/infrastructure/json/types/DeserializableOneOfTypeDefinitionBuilderTest.java +++ b/infrastructure/json/src/test/java/tech/pegasys/teku/infrastructure/json/types/DeserializableOneOfTypeDefinitionBuilderTest.java @@ -27,11 +27,11 @@ public class DeserializableOneOfTypeDefinitionBuilderTest { DeserializableOneOfTypeDefinition.object(OneOfTypeTestTypeDefinition.TestType.class) .description("meaningful description") .withType( - OneOfTypeTestTypeDefinition.TestObjA.isInstance, + OneOfTypeTestTypeDefinition.TestObjA.IS_INSTANCE, s -> s.contains("value1"), TYPE_A) .withType( - OneOfTypeTestTypeDefinition.TestObjB.isInstance, + OneOfTypeTestTypeDefinition.TestObjB.IS_INSTANCE, s -> s.contains("value2"), TYPE_B) .build(); diff --git a/infrastructure/json/src/test/java/tech/pegasys/teku/infrastructure/json/types/EnumHeaderTypeDefinitionTest.java b/infrastructure/json/src/test/java/tech/pegasys/teku/infrastructure/json/types/EnumHeaderTypeDefinitionTest.java new file mode 100644 index 00000000000..40e75e17584 --- /dev/null +++ b/infrastructure/json/src/test/java/tech/pegasys/teku/infrastructure/json/types/EnumHeaderTypeDefinitionTest.java @@ -0,0 +1,73 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.infrastructure.json.types; + +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.databind.ObjectMapper; +import java.io.IOException; +import java.io.StringWriter; +import java.util.Optional; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.infrastructure.json.JsonUtil; + +public class EnumHeaderTypeDefinitionTest { + final DeserializableTypeDefinition definition = + DeserializableTypeDefinition.enumOf(Color.class); + + enum Color { + RED, + GREEN, + BLUE + } + + @Test + void shouldSerializeEnum() throws Exception { + final String json = JsonUtil.serialize(Color.RED, definition); + assertThat(json).isEqualTo("\"RED\""); + } + + @Test + void shouldParseEnum() throws Exception { + assertThat(JsonUtil.parse("\"BLUE\"", definition)).isEqualTo(Color.BLUE); + } + + @Test + public void serializeOpenApiType() throws IOException { + + final EnumHeaderTypeDefinition definition = + new EnumHeaderTypeDefinition<>( + Color.class, + Color::name, + Optional.of("color"), + "Color", + Optional.of(true), + Optional.of("The color of the object"), + Optional.of("RED")); + + final StringWriter writer = new StringWriter(); + final JsonGenerator gen = new ObjectMapper().getFactory().createGenerator(writer); + gen.writeStartObject(); + definition.serializeOpenApiType(gen); + gen.writeEndObject(); + gen.close(); + final String json = writer.toString(); + + final String expectedJson = + "{\"Color\":{\"description\":\"The color of the object\",\"required\":true,\"schema\":{\"type\":\"string\",\"enum\":[\"RED\",\"GREEN\",\"BLUE\"],\"example\":\"RED\"}}}"; + assertEquals(expectedJson, json); + } +} diff --git a/infrastructure/json/src/test/java/tech/pegasys/teku/infrastructure/json/types/EnumTypeDefinitionTest.java b/infrastructure/json/src/test/java/tech/pegasys/teku/infrastructure/json/types/EnumTypeDefinitionTest.java index e4f1c6c9d0f..c241cb810ba 100644 --- a/infrastructure/json/src/test/java/tech/pegasys/teku/infrastructure/json/types/EnumTypeDefinitionTest.java +++ b/infrastructure/json/src/test/java/tech/pegasys/teku/infrastructure/json/types/EnumTypeDefinitionTest.java @@ -31,6 +31,18 @@ void shouldSerializeEnum() throws Exception { assertThat(json).isEqualTo("\"yes\""); } + @Test + void shouldSerializeEnumForceLowerCase() throws Exception { + DeserializableTypeDefinition definition = + DeserializableTypeDefinition.enumOf(YES_NO.class); + String json = JsonUtil.serialize(YES_NO.YES, definition); + assertThat(json).isEqualTo("\"YES\""); + + definition = DeserializableTypeDefinition.enumOf(YES_NO.class, true); + json = JsonUtil.serialize(YES_NO.YES, definition); + assertThat(json).isEqualTo("\"yes\""); + } + @Test void shouldParseEnum() throws Exception { assertThat(JsonUtil.parse("\"no\"", definition)).isEqualTo(YesNo.NO); @@ -39,7 +51,9 @@ void shouldParseEnum() throws Exception { @Test void excludedShouldThrowExceptionSerialize() throws JsonProcessingException { DeserializableTypeDefinition definition = - DeserializableTypeDefinition.enumOf(YesNo.class, Objects::toString, Set.of(YesNo.YES)); + new EnumTypeDefinition.EnumTypeBuilder<>(YesNo.class, Objects::toString) + .excludedEnumerations(Set.of(YesNo.YES)) + .build(); assertThatThrownBy(() -> JsonUtil.serialize(YesNo.YES, definition)) .isInstanceOf(IllegalArgumentException.class); assertThat(JsonUtil.serialize(YesNo.NO, definition)).isEqualTo("\"no\""); @@ -48,7 +62,9 @@ void excludedShouldThrowExceptionSerialize() throws JsonProcessingException { @Test void excludedShouldThrowExceptionDeserialize() throws JsonProcessingException { DeserializableTypeDefinition definition = - DeserializableTypeDefinition.enumOf(YesNo.class, Objects::toString, Set.of(YesNo.YES)); + new EnumTypeDefinition.EnumTypeBuilder<>(YesNo.class, Objects::toString) + .excludedEnumerations(Set.of(YesNo.YES)) + .build(); assertThatThrownBy(() -> JsonUtil.parse("\"yes\"", definition)) .isInstanceOf(IllegalArgumentException.class); assertThat(JsonUtil.parse("\"no\"", definition)).isEqualTo(YesNo.NO); @@ -69,4 +85,10 @@ public String toString() { return displayName; } } + + @SuppressWarnings("JavaCase") + private enum YES_NO { + YES, + NO + } } diff --git a/infrastructure/json/src/test/java/tech/pegasys/teku/infrastructure/json/types/StringBasedHeaderTypeDefinitionTest.java b/infrastructure/json/src/test/java/tech/pegasys/teku/infrastructure/json/types/StringBasedHeaderTypeDefinitionTest.java new file mode 100644 index 00000000000..62972c54c03 --- /dev/null +++ b/infrastructure/json/src/test/java/tech/pegasys/teku/infrastructure/json/types/StringBasedHeaderTypeDefinitionTest.java @@ -0,0 +1,60 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.infrastructure.json.types; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.databind.ObjectMapper; +import java.io.IOException; +import java.io.StringWriter; +import org.junit.jupiter.api.Test; + +public class StringBasedHeaderTypeDefinitionTest { + + @Test + public void serializeOpenApiType() throws IOException { + // Create a builder for StringBasedHeaderTypeDefinition + final StringBasedHeaderTypeDefinition.Builder builder = + new StringBasedHeaderTypeDefinition.Builder<>(); + + // Set the title, description, required, and example + builder.title("String-Header"); + builder.description("This is a string header"); + builder.required(true); + builder.example("test string"); + + // Set the parser and formatter functions + builder.parser(s -> s); + builder.formatter(s -> s); + + // Build the StringBasedHeaderTypeDefinition + final StringBasedHeaderTypeDefinition definition = builder.build(); + + // Create a StringWriter and a JsonGenerator + final StringWriter writer = new StringWriter(); + final JsonGenerator gen = new ObjectMapper().getFactory().createGenerator(writer); + + gen.writeStartObject(); + definition.serializeOpenApiType(gen); + gen.writeEndObject(); + gen.close(); + + final String json = writer.toString(); + + final String expectedJson = + "{\"String-Header\":{\"description\":\"This is a string header\",\"required\":true,\"schema\":{\"type\":\"string\",\"example\":\"test string\"}}}"; + assertEquals(expectedJson, json); + } +} diff --git a/infrastructure/json/src/testFixtures/java/tech/pegasys/teku/infrastructure/json/types/OneOfTypeTestTypeDefinition.java b/infrastructure/json/src/testFixtures/java/tech/pegasys/teku/infrastructure/json/types/OneOfTypeTestTypeDefinition.java index 83ded29ac48..d2222dd17c8 100644 --- a/infrastructure/json/src/testFixtures/java/tech/pegasys/teku/infrastructure/json/types/OneOfTypeTestTypeDefinition.java +++ b/infrastructure/json/src/testFixtures/java/tech/pegasys/teku/infrastructure/json/types/OneOfTypeTestTypeDefinition.java @@ -42,8 +42,8 @@ public interface TestType { SERIALIZABLE_ONE_OF_TYPE_DEFINITION = new SerializableOneOfTypeDefinitionBuilder() .description("meaningful description") - .withType(TestObjA.isInstance, TYPE_A) - .withType(TestObjB.isInstance, TYPE_B) + .withType(TestObjA.IS_INSTANCE, TYPE_A) + .withType(TestObjB.IS_INSTANCE, TYPE_B) .build(); public static class TestObjA implements TestType { @@ -82,7 +82,7 @@ public int hashCode() { return Objects.hash(name); } - static Predicate isInstance = testType -> testType instanceof TestObjA; + static final Predicate IS_INSTANCE = testType -> testType instanceof TestObjA; } public static class TestObjB implements TestType { @@ -104,6 +104,6 @@ public void setName(final String name) { this.name = name; } - static Predicate isInstance = testType -> testType instanceof TestObjB; + static final Predicate IS_INSTANCE = testType -> testType instanceof TestObjB; } } diff --git a/infrastructure/kzg/build.gradle b/infrastructure/kzg/build.gradle index 8e8a3b61114..e7466262278 100644 --- a/infrastructure/kzg/build.gradle +++ b/infrastructure/kzg/build.gradle @@ -2,8 +2,8 @@ dependencies { implementation project(':infrastructure:io') implementation project(':infrastructure:http') - implementation 'org.apache.tuweni:tuweni-bytes' - implementation 'org.apache.tuweni:tuweni-ssz' + implementation 'io.tmio:tuweni-bytes' + implementation 'io.tmio:tuweni-ssz' implementation 'io.consensys.protocols:jc-kzg-4844' implementation "io.github.crate-crypto:java-eth-kzg" implementation 'commons-io:commons-io' diff --git a/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/CKZG4844.java b/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/CKZG4844.java index 0cd167f38c6..3fd1c813f22 100644 --- a/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/CKZG4844.java +++ b/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/CKZG4844.java @@ -33,8 +33,10 @@ final class CKZG4844 implements KZG { private static final Logger LOG = LogManager.getLogger(); + // used for FK20 proof computations (PeerDAS) so can default to 0 for now private static final int PRECOMPUTE_DEFAULT = 0; + @SuppressWarnings("NonFinalStaticField") private static CKZG4844 instance; static synchronized CKZG4844 getInstance() { @@ -154,10 +156,11 @@ public KZGProof computeBlobKzgProof(final Bytes blob, final KZGCommitment kzgCom } @Override - public List computeCellsAndProofs(Bytes blob) { - CellsAndProofs cellsAndProofs = CKZG4844JNI.computeCellsAndKzgProofs(blob.toArrayUnsafe()); - List cells = KZGCell.splitBytes(Bytes.wrap(cellsAndProofs.getCells())); - List proofs = KZGProof.splitBytes(Bytes.wrap(cellsAndProofs.getProofs())); + public List computeCellsAndProofs(final Bytes blob) { + final CellsAndProofs cellsAndProofs = + CKZG4844JNI.computeCellsAndKzgProofs(blob.toArrayUnsafe()); + final List cells = KZGCell.splitBytes(Bytes.wrap(cellsAndProofs.getCells())); + final List proofs = KZGProof.splitBytes(Bytes.wrap(cellsAndProofs.getProofs())); if (cells.size() != proofs.size()) { throw new KZGException("Cells and proofs size differ"); } @@ -168,9 +171,9 @@ public List computeCellsAndProofs(Bytes blob) { @Override public boolean verifyCellProofBatch( - List commitments, - List cellWithIdList, - List proofs) { + final List commitments, + final List cellWithIdList, + final List proofs) { if (commitments.size() != cellWithIdList.size() || cellWithIdList.size() != proofs.size()) { throw new KZGException("Cells, proofs and commitments sizes should match"); } @@ -190,14 +193,14 @@ public boolean verifyCellProofBatch( } @Override - public List recoverCellsAndProofs(List cells) { - long[] cellIds = cells.stream().mapToLong(c -> c.columnId().id().longValue()).toArray(); - byte[] cellBytes = + public List recoverCellsAndProofs(final List cells) { + final long[] cellIds = cells.stream().mapToLong(c -> c.columnId().id().longValue()).toArray(); + final byte[] cellBytes = CKZG4844Utils.flattenBytes( cells.stream().map(c -> c.cell().bytes()).toList(), cells.size() * BYTES_PER_CELL); - CellsAndProofs cellsAndProofs = CKZG4844JNI.recoverCellsAndKzgProofs(cellIds, cellBytes); - List fullCells = KZGCell.splitBytes(Bytes.wrap(cellsAndProofs.getCells())); - List fullProofs = KZGProof.splitBytes(Bytes.wrap(cellsAndProofs.getProofs())); + final CellsAndProofs cellsAndProofs = CKZG4844JNI.recoverCellsAndKzgProofs(cellIds, cellBytes); + final List fullCells = KZGCell.splitBytes(Bytes.wrap(cellsAndProofs.getCells())); + final List fullProofs = KZGProof.splitBytes(Bytes.wrap(cellsAndProofs.getProofs())); if (fullCells.size() != fullProofs.size()) { throw new KZGException("Cells and proofs size differ"); } diff --git a/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/CKZG4844Utils.java b/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/CKZG4844Utils.java index b5b5371983d..c3cb012fd92 100644 --- a/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/CKZG4844Utils.java +++ b/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/CKZG4844Utils.java @@ -59,7 +59,7 @@ public static byte[] flattenG2Points(final List g2Points) { return flattenBytes(g2Points, BYTES_PER_G2 * g2Points.size()); } - static List bytesChunked(Bytes bytes, int chunkSize) { + static List bytesChunked(final Bytes bytes, final int chunkSize) { if (bytes.size() % chunkSize != 0) { throw new IllegalArgumentException("Invalid bytes size: " + bytes.size()); } diff --git a/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/KZGCell.java b/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/KZGCell.java index 48724e87c7d..fea47abab49 100644 --- a/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/KZGCell.java +++ b/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/KZGCell.java @@ -22,7 +22,7 @@ public record KZGCell(Bytes bytes) { static final KZGCell ZERO = new KZGCell(Bytes.wrap(new byte[BYTES_PER_CELL])); - static List splitBytes(Bytes bytes) { + static List splitBytes(final Bytes bytes) { return CKZG4844Utils.bytesChunked(bytes, BYTES_PER_CELL).stream().map(KZGCell::new).toList(); } } diff --git a/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/KZGCellID.java b/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/KZGCellID.java index 766434c9a7b..80269c77d36 100644 --- a/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/KZGCellID.java +++ b/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/KZGCellID.java @@ -17,7 +17,7 @@ public record KZGCellID(UInt64 id) { - public static KZGCellID fromCellColumnIndex(int idx) { + public static KZGCellID fromCellColumnIndex(final int idx) { return new KZGCellID(UInt64.valueOf(idx)); } diff --git a/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/KZGCellWithColumnId.java b/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/KZGCellWithColumnId.java index af5f9ccb3a0..14a7c3d9f65 100644 --- a/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/KZGCellWithColumnId.java +++ b/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/KZGCellWithColumnId.java @@ -15,7 +15,7 @@ public record KZGCellWithColumnId(KZGCell cell, KZGCellID columnId) { - public static KZGCellWithColumnId fromCellAndColumn(KZGCell cell, int columnIndex) { + public static KZGCellWithColumnId fromCellAndColumn(final KZGCell cell, final int columnIndex) { return new KZGCellWithColumnId(cell, KZGCellID.fromCellColumnIndex(columnIndex)); } } diff --git a/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/KZGProof.java b/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/KZGProof.java index 72de85a39b9..87faab1e0bb 100644 --- a/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/KZGProof.java +++ b/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/KZGProof.java @@ -45,7 +45,7 @@ public static KZGProof fromArray(final byte[] bytes) { return fromBytesCompressed(Bytes48.wrap(bytes)); } - static List splitBytes(Bytes bytes) { + static List splitBytes(final Bytes bytes) { return CKZG4844Utils.bytesChunked(bytes, BYTES_PER_PROOF).stream() .map(b -> new KZGProof(Bytes48.wrap(b))) .toList(); diff --git a/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/RustKZG.java b/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/RustKZG.java index 0b7e4dc844c..53489af8b81 100644 --- a/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/RustKZG.java +++ b/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/RustKZG.java @@ -34,7 +34,9 @@ final class RustKZG implements KZG { private static final Logger LOG = LogManager.getLogger(); private static final int NUMBER_OF_THREADS = 1; + @SuppressWarnings("NonFinalStaticField") private static RustKZG instance; + private LibEthKZG library; private boolean initialized; @@ -101,7 +103,7 @@ public KZGProof computeBlobKzgProof(final Bytes blob, final KZGCommitment kzgCom } @Override - public List computeCellsAndProofs(Bytes blob) { + public List computeCellsAndProofs(final Bytes blob) { final CellsAndProofs cellsAndProofs = library.computeCellsAndKZGProofs(blob.toArrayUnsafe()); final Stream kzgCellStream = Arrays.stream(cellsAndProofs.getCells()).map(Bytes::wrap).map(KZGCell::new); @@ -114,9 +116,9 @@ public List computeCellsAndProofs(Bytes blob) { @Override public boolean verifyCellProofBatch( - List commitments, - List cellWithIdList, - List proofs) { + final List commitments, + final List cellWithIdList, + final List proofs) { return library.verifyCellKZGProofBatch( commitments.stream().map(KZGCommitment::toArrayUnsafe).toArray(byte[][]::new), cellWithIdList.stream() @@ -129,9 +131,9 @@ public boolean verifyCellProofBatch( } @Override - public List recoverCellsAndProofs(List cells) { - long[] cellIds = cells.stream().mapToLong(c -> c.columnId().id().longValue()).toArray(); - byte[][] cellBytes = + public List recoverCellsAndProofs(final List cells) { + final long[] cellIds = cells.stream().mapToLong(c -> c.columnId().id().longValue()).toArray(); + final byte[][] cellBytes = cells.stream().map(c -> c.cell().bytes().toArrayUnsafe()).toArray(byte[][]::new); final CellsAndProofs cellsAndProofs = library.recoverCellsAndKZGProofs(cellIds, cellBytes); final byte[][] recoveredCells = cellsAndProofs.getCells(); diff --git a/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/RustWithCKZG.java b/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/RustWithCKZG.java index e56f589fe10..972a5e7693a 100644 --- a/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/RustWithCKZG.java +++ b/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/RustWithCKZG.java @@ -24,6 +24,7 @@ */ final class RustWithCKZG implements KZG { + @SuppressWarnings("NonFinalStaticField") private static RustWithCKZG instance; private final CKZG4844 ckzg4844Delegate; @@ -102,20 +103,20 @@ public KZGProof computeBlobKzgProof(final Bytes blob, final KZGCommitment kzgCom } @Override - public List computeCellsAndProofs(Bytes blob) { + public List computeCellsAndProofs(final Bytes blob) { return rustKzgDelegeate.computeCellsAndProofs(blob); } @Override public boolean verifyCellProofBatch( - List commitments, - List cellWithIds, - List proofs) { + final List commitments, + final List cellWithIds, + final List proofs) { return rustKzgDelegeate.verifyCellProofBatch(commitments, cellWithIds, proofs); } @Override - public List recoverCellsAndProofs(List cells) { + public List recoverCellsAndProofs(final List cells) { return rustKzgDelegeate.recoverCellsAndProofs(cells); } } diff --git a/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/TrustedSetup.java b/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/TrustedSetup.java index f75d3e4a087..fadc46d9ca7 100644 --- a/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/TrustedSetup.java +++ b/infrastructure/kzg/src/main/java/tech/pegasys/teku/kzg/TrustedSetup.java @@ -22,6 +22,7 @@ record TrustedSetup(List g1Lagrange, List g2Monomial, List g1Monomial) { + @SuppressWarnings("MethodInputParametersMustBeFinal") public TrustedSetup { g1Lagrange.forEach(this::validateG1Point); g2Monomial.forEach(this::validateG2Point); diff --git a/infrastructure/kzg/src/test/java/tech/pegasys/teku/kzg/RustKZGTest.java b/infrastructure/kzg/src/test/java/tech/pegasys/teku/kzg/RustKZGTest.java index a6c3d76bc2c..137aa6a8729 100644 --- a/infrastructure/kzg/src/test/java/tech/pegasys/teku/kzg/RustKZGTest.java +++ b/infrastructure/kzg/src/test/java/tech/pegasys/teku/kzg/RustKZGTest.java @@ -76,12 +76,12 @@ public void testVerifyingBatchProofsThrowsIfSizesDoesntMatch() { } @Override - public void testComputingProofWithIncorrectLengthBlobDoesNotCauseSegfault(String blobHex) { + public void testComputingProofWithIncorrectLengthBlobDoesNotCauseSegfault(final String blobHex) { // skip, not supported } @Override - public void incorrectTrustedSetupFilesShouldThrow(String filename) { + public void incorrectTrustedSetupFilesShouldThrow(final String filename) { // skip, not supported } diff --git a/infrastructure/kzg/src/testFixtures/java/tech/pegasys/teku/kzg/KZGAbstractBenchmark.java b/infrastructure/kzg/src/testFixtures/java/tech/pegasys/teku/kzg/KZGAbstractBenchmark.java index 0e9ae40a6fc..2a3f4cec5a1 100644 --- a/infrastructure/kzg/src/testFixtures/java/tech/pegasys/teku/kzg/KZGAbstractBenchmark.java +++ b/infrastructure/kzg/src/testFixtures/java/tech/pegasys/teku/kzg/KZGAbstractBenchmark.java @@ -28,9 +28,9 @@ protected KZG getKzg() { return kzg; } - protected void printStats(List validationTimes) { + protected void printStats(final List validationTimes) { int sum = 0; - int size = validationTimes.size(); + final int size = validationTimes.size(); // Sum of elements for (int time : validationTimes) { @@ -38,7 +38,7 @@ protected void printStats(List validationTimes) { } // Mean - double mean = (double) sum / size; + final double mean = (double) sum / size; System.out.printf("Mean, ms: %.2f%n", mean); // Standard Deviation @@ -46,12 +46,12 @@ protected void printStats(List validationTimes) { for (int time : validationTimes) { sumOfSquares += Math.pow(time - mean, 2); } - double standardDeviation = Math.sqrt(sumOfSquares / size); + final double standardDeviation = Math.sqrt(sumOfSquares / size); System.out.printf("Std, ms: %.2f%n", standardDeviation); // Min and Max - int min = Collections.min(validationTimes); - int max = Collections.max(validationTimes); + final int min = Collections.min(validationTimes); + final int max = Collections.max(validationTimes); System.out.println("Min, ms: " + min); System.out.println("Max, ms: " + max); } diff --git a/infrastructure/kzg/src/testFixtures/resources/tech/pegasys/teku/kzg/trusted_setups/broken/trusted_setup_g1_length.txt b/infrastructure/kzg/src/testFixtures/resources/tech/pegasys/teku/kzg/trusted_setups/broken/trusted_setup_g1_length.txt index ecaef3fd6d0..9917ea8aea6 100644 --- a/infrastructure/kzg/src/testFixtures/resources/tech/pegasys/teku/kzg/trusted_setups/broken/trusted_setup_g1_length.txt +++ b/infrastructure/kzg/src/testFixtures/resources/tech/pegasys/teku/kzg/trusted_setups/broken/trusted_setup_g1_length.txt @@ -1,4162 +1,8258 @@ 4096 65 -a0d2392f030681c61c2a867862917e10f7678d882034bb89af3db87e6ab3883a304034643dc9688a04e41a5b831582bc -94298073048d70c74f36685e547d04b7311479daa05912e18ead64b2099a194bf48ec344273d58daf0b86b1d8f1d318d -85c4063d13499013dc2ccaa98c1606763e6b1e8cca20922d4cec12ecbaf006ea81ffabe6596d1ac7ba1daf7e63e30898 -84c64bce36c6b5145c6880113366025ab9a8f88e3948d374e27be8b8f9f87402c70fec9b3c621a2d1d26764a84370d0c -8b206c823acf5294552ee54579fac0f45ea15bd273dbacd63b88cd7cddbcce23b56e52f8ea352e1e1d7dcd9b3991b413 -b70aaa4038ba3f5ff306c647b4392d004950c53ad8f6713b5c9c21ac99f5c56cf57323dac500a1f4e9507c4746b07a2f -895f6d1fc70b52f838d81b24f4840729cd5988b649e9d6e6f6dbac4281d8818f39ebdae7e6ea139d7f98a832bd6f29f1 -a71a2832bbaade974c9ef7505dfa24e1ba466a9951b7c2db56886be31c9c7b871f3ee76cb1fcc1aab4b906d6502bc9b5 -9530ba64a21e27834609c00616bc63e8fc2dc7800e478ad728ec39c624f65bbc62cb48f59decb7fbf605ce1920d02622 -8d0609affaf8619bb2f6c80699e5bc7783becbd5973630cdd227ae52d6d701c45f4270becca97701b40279fab588cf64 -8f5d5b4c3bb8dc9a19e5a0f84df6322a79a00c7783c86254197d313a5b35d3965a1f7c0b9c4e39ec1e8f5d02d3aa0862 -96aa47a3ba20b1cfe81eb26bef503225037fdf4c9df53bea1b520841875cd1db6aa8e0f34685da08b55a3ce7289e6de0 -b4c27ee3f4b8c0031837160f0a75632f5b51b5850d52b530096443f54c2b264aeccc5c61b4fcc8de7074475f354fa0d8 -acfd735cda20be1d6f425a7886629c91732fbb5a4e0350ca740a8fb5b39f2001071cec0b2a0f6ca35e1f35a5ea18d00f -ae44d87b1d16d59504c602cbacde2c2791f1520391ca50154e6036d3953ca466cf93d6537da2adb729e6f9f4ffa87853 -97b492872ce44941ea4668ffca83b82fac0f4021bd47e0a5ffeaaacb1b3fc924ee4d53b99f7bcafe0985caf0fbe5d1d3 -b3fbe2f9103d293f49c6c6016d5913f041c9113295397388111a0fdf4245d8edd6e63b9a1a1c9c8f868d6e1988116880 -805efa08fd2046c44c427b225c17bed8a1eb3320cdf94026fdc24c6d345a6cfebfd7475f85d2d1bf22018ca72d2761d3 -9888bae0d83077d1dfde82fdffb1195565c31c519b80cba1e21aba58ee9ccb5677f74bfde13fa5723026514a7d839661 -922e19d2646ba90c9f56278bddf74621cc4518ae2f042fb8245843e87cd82724c6d7c9a99907ac6de5f2187fd2e77cbe -a38f0e1faf97dd1e0804b44e4d150dbfa48318442d1c5255eb0c14ea56b50502f3c7cb216a0336e7c140398088dc01cf -93598ea391c8735799a1d4cd0456f34994ccdf4883fad57419f634f30fee595938bc66b066dade9ae52578818c00d899 -a528dc920734cfaee9feacbc0baa5b73befb1ec6fbd422fcad09a9c1f8f8c40b5ea332b2cf04dc1d6d921e9da9ddfeb4 -b38d45316bf78d11e796a34ee535814e6cde0e642f14108329c5b21f4fec18cd61f84a3025824bb8dc4cbd26b2ecc9bf -8eec35a7404c9a35dc6ad0260b7f0f7fd1bfe92a2e08bc72548b99ed9acdc378728a8ea9c6879a6e47e37edb0d28c193 -a68a4446274ccd947c61bf736c5219dad680b99c6085a26719793e0d9dab26d5f8a0b28e71be6e1b9ea4ae39139f7f57 -a0acb543f41ad12e3b2e096629ccdd719a001d0ff53bb151e9a37aa57852f7275a7bbd06dc2a06af9144524548164af5 -b271e74cdbcf8b9143f8472174bdb068c23308ea807c60a554c185f7be6f231aac13347139837514171a876dfac5baa5 -8195a460719000cd1df379ebbf7918f71301a50a2fa587505cc5b8c4534c3d2343f63d28e7ee991d7a1cebb15d380696 -96202b60426773e8731dcbedbf613477f65940a19fb4be0f4f742b0c76ae9d88ecdb6d36cd4f12bb404dd5d360c819e2 -b0a80fe60b71ca9e80157138de8787b8a786326179604b8a15a744e52662645987e5f859ef5c76492d560daf4624b9a7 -a331ea8adf87daa5e2d458d0113c307edae1a84927bca7d484aca5f8c1b6378ab42981c44b0d916d7249f4b475f926f1 -aa1a8f59ae0912abf191ea7e209ff401628278dfb2269db6d87cf33bd52af3dbffbe96513a8b210e965c853a554b787a -ac4f4a0e1b1a155e1f22a9085b0b047fe54c8437dbbb8e9720fd6b0cdd76557d19ca2e885a48890f0247b1a72be0e287 -a428465505eac7b9660eb0d495a7a00c8cc238de3a02ebbd2eb07e502e9868086e9584b59953cf1480c0b781295db339 -b7b77e21e08f6357cbd3dcd3035c3e8ec84cdfa13c7baef6c67e0ef43095e61fd549694263d7def8b8adc3a0fdcc7987 -abb991d17c5bdd264c592c55101e265cb3210c4157aee4079173fd51da1e0199eed1d6c890aab95817ec078561d771af -846a8e4f801faf5fbec078b09c362ee30a00b2b58a4871744d03cd118b913464233ff926e52b0c75fbfcf098ad25a1e6 -947e91ffa32f38c1ccb72cca4bfabaee9e63ab74a16f034cabba25e462f7331ebe5a7ba393f69e91830415fa75b1b52e -8dc5e26adc693f4e300cab7385edca1a2fe14c8ee6dc0cd6d013cb5aa154dc380e9e81e259cbc59c1f38f7c4a57f1c7d -9818ef6605d6ea3b7bf4da5c6d6d8ed540bb94df4d14c974e1b79ed2fd1a0b897b8cf1ff671a181a697effd66b1644a5 -b5eab6baf03af994fc32cc9dce388394c18c01cdafe7909fde948f3e00a72dc8f30d15977d0f114bd7c140f5f94cf005 -83b2e9858d3b929f9a2ad66a91a2c0c44d15d288c17c12a1614301a6f2d61d31eaa540ca7781520fe4420afae0ec0208 -ab338fbd38bce4d1b7a759f71e5e5673746c52846eff3d0b6825e390aeeca8f9f123ee88c78fe4d520cc415cbae32bf1 -81adb6322b8db95d1711304e5b59f37640ca88c03e6c7e15de932be5267dff7351fa17664113ecc528e8920f5bfdc0d1 -89e2e0c0d769e4107232df741678a6bacb041d0154385450aaca8be9c3c18c42f817373962e7569d33935c35666a8a6a -8f0756fea8b34a2b471ec39e4448a6a6935e5432ec2859d222964a4c82777a340e1d702777aeb946fa405afc0438221a -a2bf90c505a6f03b3dd09d04e1e7cf301fe3415b273e263f15fdfe5d0e40f619b95e8bf00916d3eaa7d7f8c0bae41c8e -91d5c76b5542637588cd47279d0bd74a25dbda0d8ec0ff68b62d7e01e34a63fc3e06d116ee75c803864b1cf330f6c360 -a9958c388d25315a979566174b0622446335cb559aff1992bd71910c47497536019c6854d31c0e22df07505963fc44ff -91d82b09d5726077eed6c19bcb398abe79d87ce16c413df6bf5932b8fd64b4c0fd19c9bf0fa8db657a4a4d4c0d8f5a2d -ac6e0a86e0ee416855c3e9eef2526c43835f5245527ed0038bc83b4fcadb4ea5beb91143cc674486681a9f0e63f856b1 -aaf00d6efd0c6efb9f7d6a42555abec05c5af8f324e2e579fc2ac83bdc937cc682d9bc2ffd250619c8bb098b8c84db80 -963f5fcd8476d0dbeb03a62cde40e3deee25f55e7ded7572d8884975f38eddc5406fc4b0adff602a1cca90f7205a7fdc -a3805ee01512f644d2679511bd8607890ee9721e75ac9a85ab9fd6fceb1308d5b9b0e9907686b4e683b34aed0f34cd81 -a483d7708465cd4e33b4407fe82c84ef6bc7fa21475d961fe2e99802d0c999b6474ef7a46dd615b219c9c7e9faec45ee -b6b5f9456f12d6781c41f17cdc9d259f9515994d5dee49bb701a33fa2e8dcbb2c8c13f822b51ad232fc5e05bff2f68ef -8766b721b0cf9b1a42614c7d29aad2d89da4996dc9e2a3baeba4b33ca74100ab0b83f55c546c963e3b6af1dcf9ca067c -ac5e8da1154cf4be8df2bbd2e212b7f8077099b2010c99e739441198f65337c6f7ef0d9136453a7668fde6e1389c32c7 -a9d6d2c8845e5f1fec183c5153f1f6e23421e28ce0c86b0ce993b30b87869065acad9e6d9927d9f03c590852821b2f9c -a320ca07c44f7ea3ff858fe18395a86f59559617f13ec96d1e8b4a3f01d9c066a45c8d8cf8f1f14a360bb774d55f5f18 -b3adb00e1312dce73b74fbd2ea16f0fb0085bd0db10772e9c260e9ed9f8829ff690e3dfffacaddc8233d484bb69778b3 -87b0c8d8a167d5199d0b0743c20fb83ec8a1c442f0204bcc53bf292ba382bef58a58a6d1e2467920e32c290fdc6dae7c -a74fa436a5adc280a68e0c56b28ac33647bdfc8c5326f4c99db6dbd1b98d91afb1f41f5fffd6bcc31c1f8789c148e2db -8a37349e4ba7558965077f7f9d839c61b7dcb857fcc7965c76a64a75e377bfea8cd09b7a269ce602cc4472affc483b69 -8af813f62c5962ff96bf73e33f47fd5a8e3e55651d429e77d2ce64a63c535ecc5cfc749bb120c489b7ea1d9b2a5d233c -833021445b7d9817caa33d6853fa25efc38e9d62494d209627d26799432ea7b87a96de4694967151abc1252dd2d04dfc -8f78a715107e0ace3a41bff0385fd75c13bf1250f9e5ddecf39e81bacc1244b978e3464892f7fb2596957855b8bf9fc7 -aed144134dc1cc6c671f70ebe71a3aadf7511eea382969bc5d499a678d2d8ce249ebf1a06b51183f61413eba0517012b -b39a53e82c5553943a5e45bc5116d8672ec44bed96b3541dead40344b287a7b02dbf7107372effb067edd946f47de500 -b383844c3b20a8bc06098046ec6b406df9419ad86fac4a000905c01325426903a5e369af856d71ccd52fea362ed29db5 -83815a7098283723eec6aa6451b5d99578bf28a02971375a1fe90c15a20963e129372ac4af7b306ee2e7316472c5d66d -b426b4e185806a31febd745fa8d26b6397832a04e33c9a7eb460cbf302b4c134a8a01d4e5e40bc9b73296c539e60b3ca -a6cabf8205711457e6363ef4379ebc1226001e1aaea3002b25bfd9e173f4368002f4461e79eeb9f4aa46f1b56c739ab9 -a6e88ab01282313269cd2d8c0df1a79dada5b565d6623900af9e7e15351de2b0105cc55d3e9080e1e41efe48be32a622 -b2b106db3d56d189ea57afa133ae4941b4eb1dc168357af488e46811c687713fc66bbd6f8500bbd13cdb45cb82c14d1d -b3a74780ff949d19e6438db280e53632c60dc544f41320d40297fe5bb7fcee7e7931111053c30fb1ed9019ab28965b44 -8c67f32b9fdc04ec291cc0d928841ab09b08e87356e43fbbf7ac3ff0f955642628f661b6f0c8e2192a887489fddf07bb -b3be58bd628383352e6473fe9a1a27cf17242df0b1273f5867e9119e908969b9e9e7e294a83b9ea14825003cb652d80c -a867acf6ab03e50936c19a21d4040bfd97eb5a89852bd9967da0e326d67ce839937cab4e910d1149ecef9d5f1b2d8f08 -8006b19126bd49cbb40d73a99a37c2e02d6d37065bbe0cfcee888280176184964bd8f222f85960667c5b36dfaee0ee35 -ac50967b8b7840bf9d51216d68a274f1d3431c7d4031fbac75a754befbbb707c2bb184867db6b9d957f3ba0fd0a26231 -b5a794c928aff0c4271674eb0a02143ed9b4d3bc950584c7cd97b7d3c3f2e323798fd5ccc6fcc0eb2e417d87f4c542a2 -a2ca3d6509f04b37091ce6697672ee6495b42d986d75bd2d2058faa100d09fd0a145350f2d280d2cb36516171bd97dbf -92cfa293469967a9207b37cd70392312faf81b52963bfbad5f9f3da00817d26e10faf469e0e720c3bb195f23dda8c696 -a0dd5135da0a0e33fa922c623263b29518d7fa000e5beefc66faa4d6201516d058f155475c4806917a3259db4377c38a -8fc3ae8ea6231aa9afb245a0af437e88ebca2c9ab76850c731981afba90d5add0ea254053449355eccf39df55bd912ed -9727afe1f0804297717cec9dc96d2d27024a6ae6d352fee5d25377ee858ee801593df6124b79cb62ddc9235ec1ade4ac -8bcb2c53fcaa38e8e2e0fd0929bc4d9ddce73c0282c8675676950ff806cb9f56ebd398b269f9a8c2a6265b15faf25fca -a8bd9007fbbdd4b8c049d0eb7d3649bd6a3e5097372fa8ea4b8821ba955c9ef3f39ac8b19f39d3af98640c74b9595005 -92c7e851c8bd6b09dfcbfdb644725c4f65e1c3dbd111df9d85d14a0bb2d7b657eb0c7db796b42bf447b3912ef1d3b8c3 -98c499b494d5b2b8bea97d00ac3a6d826ab3045bb35424575c87117fc2a1958f3829813e266630749caf0fa6eeb76819 -8df190d71e432fe8691d843f6eb563445805c372eb5b6b064ec4e939be3e07526b5b7f5a289ede44ae6116a91357b8b1 -b5010243f7c760fb52a935f6d8ed8fc12c0c2f57db3de8bb01fdeedf7e1c87b08f3dd3c649b65751f9fd27afa6be34c7 -889c8057402cc18649f5f943aed38d6ef609b66c583f75584f3b876c1f50c5dc7d738dc7642135742e1f13fa87be46c1 -996087337f69a19a4ebe8e764acf7af8170a7ad733cd201b0e4efde6ea11039a1853e115ad11387e0fb30ab655a666d8 -902732c429e767ab895f47b2e72f7facad5ef05a72c36a5f9762c2194eb559f22845bbb87c1acc985306ecb4b4fbbf79 -8519b62a150ea805cdfc05788b8d4e797d8396a7306b41777c438c2e8b5c38839cfec5e7dc5d546b42b7b76e062982a7 -862a53ba169e6842a72763f9082ff48fbfbb63129d5a26513917c2bca9ad6362c624ce6fc973cf464f2eb4892131eb04 -b86cd67c809d75fdb9f1c9453a39870f448b138f2b4058d07a707b88bb37f29d42e33ce444f4fbe50d6be13339cae8a6 -8cf5d8365dbbafc0af192feb4fc00c181e2c3babc5d253268ef5564934555fb1e9b1d85ec46f0ca4709b7d5b27169b89 -b48f11a1809ec780bf6181fae3b8d14f8d4dc7d1721128854354be691c7fc7695d60624f84016c1cea29a02aaf28bfbc -8b46b695a08cb9a2f29ab9dd79ab8a39ec7f0086995b8685568e007cd73aa2cd650d4fae6c3fb109c35612f751ba225e -8d2f9f0a5a7de894d6c50baceb8d75c96082df1dcf893ac95f420a93acbbf910204903d2eb6012b1b0495f08aaf9992f -b334db00a770394a84ec55c1bd5440b7d9f2521029030ef3411b0c2e0a34c75c827fd629c561ea76bd21cd6cf47027f4 -96e9ff76c42bcb36f2fb7819e9123420ed5608132f7c791f95cb657a61b13041e9ba2b36f798a0fdb484878cbe015905 -99f8d701e889abd7815d43ba99e0a85776ec48311fa7cb719d049f73b5d530fa950746ffbbb7beb9e30c39d864891dc2 -98169c20df7c15d7543991f9c68e40ac66607cbd43fc6195416e40009917039357e932d6e807f3a40bc4503ad01ae80a -84bd97dd9e4e2ba75d0dee7d4418c720d4746203d847ce2bdd6ed17d492023df48d7b1de27e3f5cb8660c4bb9519ae1b -a54319e06db7f5f826277a54734a875c5b3fd2fa09d36d8b73594137aa62774b7356560157bc9e3fdf1046dc57b6006a -90cfff7cd4e7c73b84f63455d31b0d428cb5eee53e378028591478511985bcc95eb94f79ad28af5b3bed864e422d7b06 -a11c23cc8dce26ac35aea9abe911905a32616a259fa7da3a20f42dc853ad31b2634007aa110c360d3771ff19851f4fb4 -9856fbee9095074ad0568498ff45f13fe81e84ea5edaf04127d9ee7e35e730c6d23fa7f8f49d092cf06b222f94ab7f36 -818862dec89f0dc314629fffbca9b96f24dfde2d835fa8bde21b30dc99fe46d837d8f745e41b39b8cf26bfe7f338f582 -831819d41524c50d19f7720bf48f65346b42fb7955ee6ecc192f7e9fed2e7010abccdfdeac2b0c7c599bc83ac70be371 -b367e588eb96aa8a908d8cc354706fee97e092d1bc7a836dbcc97c6ed4de349643a783fb4ddf0dec85a32060318efa85 -b7aaef729befd4ab2be5ec957d7d1dbe6178de1d05c2b230d8c4b0574a3363e2d51bc54ea0279a49cc7adffa15a5a43a -ae2891d848822794ecb641e12e30701f571431821d281ceecbccaaa69b8cd8242495dc5dbf38f7d8ed98f6c6919038aa -872cf2f230d3fffce17bf6f70739084876dc13596415644d151e477ce04170d6ab5a40773557eeb3600c1ad953a0bfce -b853d0a14cef7893ba1efb8f4c0fdb61342d30fa66f8e3d2ca5208826ce1db5c8a99aa5b64c97e9d90857d53beb93d67 -910b434536cec39a2c47ca396e279afdbc997a1c0192a7d8be2ba24126b4d762b4525a94cea593a7c1f707ba39f17c0c -b6511e9dea1fbccedd7b8bb0a790a71db3999bd4e3db91be2f1e25062fae9bb4e94e50d8ec0dcc67b7a0abce985200b2 -936885c90ebe5a231d9c2eb0dfd8d08a55ecaa8e0db31c28b7416869b3cc0371448168cbec968d4d26d1cb5a16ebe541 -b71c2ac873b27fe3da67036ca546d31ca7f7a3dc13070f1530fce566e7a707daeb22b80423d505f1835fe557173754f8 -85acb64140915c940b078478b7d4dadd4d8504cde595e64f60bd6c21e426b4e422608df1ed2dd94709c190e8592c22d7 -b5831c7d7c413278070a4ef1653cec9c4c029ee27a209a6ea0ad09b299309dea70a7aef4ff9c6bdeda87dcda8fa0c318 -aa0e56e3205751b4b8f8fa2b6d68b25121f2b2468df9f1bd4ef55f236b031805a7d9fd6f3bba876c69cdba8c5ea5e05f -b021f5ae4ed50f9b53f66dd326e3f49a96f4314fc7986ace23c1f4be9955ec61d8f7c74961b5fdeabcd0b9bccbf92ce8 -88df439f485c297469e04a1d407e738e4e6ac09a7a0e14e2df66681e562fdb637a996df4b9df4e185faab8914a5cef76 -8e7ae06baa69cb23ca3575205920cb74ac3cda9eb316f4eef7b46e2bff549175a751226d5b5c65fe631a35c3f8e34d61 -99b26ff174418d1efc07dfbed70be8e0cb86ac0cec84e7524677161f519977d9ca3e2bbe76face8fe9016f994dafc0ff -a5f17fe28992be57abd2d2dcaa6f7c085522795bfdf87ba9d762a0070ad4630a42aa1e809801bc9f2a5daf46a03e0c22 -8d673c7934d0e072b9d844994f30c384e55cec8d37ce88d3ad21f8bb1c90ecc770a0eaf2945851e5dab697c3fc2814a9 -a003ed4eb401cfe08d56405442ca572f29728cfff8f682ef4d0e56dd06557750f6a9f28a20c033bc6bbb792cc76cc1a8 -8010408f845cf1185b381fed0e03c53b33b86ea4912426819d431477bd61c534df25b6d3cf40042583543093e5f4bb44 -9021a1ae2eb501134e0f51093c9f9ac7d276d10b14471b14f4a9e386256e8c155bef59973a3d81c38bdab683cd5c10e0 -a5abf269ceabbb1cf0b75d5b9c720a3d230d38f284ed787b6a05145d697a01909662a5b095269996e6fa021849d0f41f -b4b260af0a005220deb2266518d11dbc36d17e59fc7b4780ab20a813f2412ebd568b1f8adc45bf045fcbe0e60c65fd24 -b8c4cb93bedbb75d058269dfccda44ae92fe37b3ab2ef3d95c4a907e1fadf77c3db0fa5869c19843e14b122e01e5c1f4 -ac818f7cdecc7b495779d8d0ff487f23ab36a61d0cf073e11000349747537b5b77044203585a55214bb34f67ef76f2d2 -86215799c25356904611e71271327ca4882f19a889938839c80a30d319ddbe6c0f1dfa9d5523813a096048c4aef338cd -a9204889b9388bf713ca59ea35d288cd692285a34e4aa47f3751453589eb3b03a9cc49a40d82ec2c913c736752d8674d -893aecf973c862c71602ffb9f5ac7bf9c256db36e909c95fe093d871aab2499e7a248f924f72dea604de14abfc00e21c -b8882ee51cfe4acba958fa6f19102aa5471b1fbaf3c00292e474e3e2ec0d5b79af3748b7eea7489b17920ce29efc4139 -8350813d2ec66ef35f1efa6c129e2ebaedc082c5160507bcf04018e170fc0731858ad417a017dadbd9ade78015312e7f -83f6829532be8cd92f3bf1fef264ee5b7466b96e2821d097f56cbb292d605a6fb26cd3a01d4037a3b1681d8143ae54d7 -87d6258777347e4c1428ba3dcbf87fdd5113d5c30cf329e89fa3c9c1d954d031e8acacb4eed9dca8d44507c65e47e7cd -a05669a1e561b1c131b0f70e3d9fc846dc320dc0872334d07347e260d40b2e51fdbabeb0d1ae1fb89fba70af51f25a1a -819925c23fd4d851ea0eecc8c581f4a0047f5449c821d34eccc59a2911f1bd4c319dab6ece19411d028b7fdedece366b -b831b762254afd35364a04966d07b3c97e0b883c27444ff939c2ab1b649dc21ac8915b99dc6903623ed7adaae44870ac -93ec0190f47deffe74179879d3df8113a720423f5ca211d56db9654db20afe10371f3f8ec491d4e166609b9b9a82d0d4 -8f4aa6313719bcfad7ca1ed0af2d2ee10424ea303177466915839f17d2c5df84cc28fcef192cbb91bb696dd383efd3b2 -8d9c9fdf4b8b6a0a702959cf784ad43d550834e5ab2cd3bebede7773c0c755417ad2de7d25b7ff579f377f0800234b44 -99d9427c20752f89049195a91cf85e7082f9150c3b5cb66b267be44c89d41e7cc269a66dacabacadab62f2fa00cc03be -b37709d1aca976cbbf3dc4f08d9c35924d1b8b0f1c465bd92e4c8ff9708e7d045c423183b04a0e0ab4c29efd99ef6f0e -a163f42fb371b138d59c683c2a4db4ca8cbc971ae13f9a9cc39d7f253b7ee46a207b804360e05e8938c73bf3193bab55 -87a037aa558508773fc9a0b9ba18e3d368ffe47dfaf1afacee4748f72e9d3decc2f7c44b7bf0b0268873a9c2ef5fe916 -a1f20cb535cc3aebd6e738491fe3446478f7609d210af56a4004d72500b3ec2236e93446783fe628c9337bcd89c1e8e1 -9757aa358dfbba4f7116da00fe9af97f7ac6d390792ea07682b984aa853379ac525222ac8a83de802859c6dec9182ef7 -815daca1eded189ec7cb7cbc8ad443f38e6ddb3fb1301d1e5a1b02586f1329035209b7c9232dc4dff3fc546cb5ac7835 -aed86dfaf9c4f0a4b2a183f70f9041172002a773482a8ebf3d9d5f97d37ee7c6767badfda15476b3b243931235c7831c -8d032e681e89e41b29f26be02f80030fa888f6967061d2204c1ebb2279a3211d759d187bce6408c6830affa1337fb4e0 -877bff5c2db06116f918a722b26422c920aeade1efa02fa61773fca77f0ea4a7e4ee0ecaaa5cfe98044c0ff91b627588 -b9ee5310d0996a10a242738d846565bdb343a4049a24cd4868db318ea6168a32548efaf4ab84edfbf27ce8aec1be2d1c -b59f6928167323037c6296dd7697846e80a7a4b81320cfae9073ebd2002a03bdf6933e887f33ad83eda8468876c2c4fb -8167686245149dc116a175331c25301e18bb48a6627e2835ae3dd80dd373d029129c50ab2aebeaf2c2ccddc58dcc72ec -82b7dcc29803f916effb67c5ba96a1c067ed8ca43ad0e8d61a510ab067baefd4d6b49e3886b863da2de1d8f2979a4baa -b43824cd6f6872a576d64372dde466fef6decdbb5ad5db55791249fde0a483e4e40c6e1c221e923e096a038fe47dab5e -ab1e9884cf5a8444140cf4a22b9a4311a266db11b392e06c89843ac9d027729fee410560bcd35626fd8de3aad19afc4a -a0dbd92a8d955eb1d24887ca739c639bdee8493506d7344aadb28c929f9eb3b4ebaae6bd7fd9ffe8abb83d0d29091e43 -8352a47a70e343f21b55da541b8c0e35cd88731276a1550d45792c738c4d4d7dc664f447c3933daabd4dbb29bb83be4a -8ce4a1e3c4370346d6f58528a5ef1a85360d964f89e54867ba09c985c1e6c07e710a32cdda8da9fa0e3b26622d866874 -b5e356d67dd70b6f01dd6181611d89f30ea00b179ae1fa42c7eadb0b077fb52b19212b0b9a075ebd6dc62c74050b2d2f -b68f2cd1db8e4ad5efdba3c6eaa60bfcc7b51c2b0ce8bb943a4bc6968995abe8a45fe7f12434e5b0076f148d942786be -b5c7b07f80cd05c0b0840a9f634845928210433b549fb0f84a36c87bf5f7d7eb854736c4083445c952348482a300226a -8cfd9ea5185ff9779dee35efe0252957d6a74693104fb7c2ea989252a1aa99d19abaab76b2d7416eb99145c6fdb89506 -8cc8e2c5c6ddee7ef720052a39cab1ecc5e1d4c5f00fb6989731a23f6d87ac4b055abb47da7202a98c674684d103152a -8c95394c9ed45e1bf1b7cfe93b2694f6a01ff5fed8f6064e673ba3e67551829949f6885963d11860d005e6fabd5ac32c -adf00b86f4a295b607df157f14195d6b51e18e2757778fde0006289fabba8c0a4ab8fad5e3e68ddbb16ccb196cc5973f -b1714b95c4885aac0ee978e6bbabbc9596f92b8858cb953df077511d178527c462cbe1d97fdc898938bae2cd560f7b66 -adf103f4344feb6b9c8104105d64475abc697e5f805e9b08aa874e4953d56605677ef7ff4b0b97987dc47257168ae94d -b0ce6ede9edb272d8769aed7c9c7a7c9df2fb83d31cc16771f13173bcdc209daf2f35887dcca85522d5fdae39f7b8e36 -ad698d1154f7eda04e2e65f66f7fcdb7b0391f248ba37d210a18db75dafd10aedc8a4d6f9299d5b6a77964c58b380126 -904856cd3ecdbb1742239441f92d579beb5616a6e46a953cf2f1dd4a83a147679fc45270dcac3e9e3d346b46ab061757 -b600b5b521af51cdfcb75581e1eccc666a7078d6a7f49f4fdb0d73c9b2dab4ce0ecafcbd71f6dd22636e135c634ee055 -a170c5d31f6657f85078c48c7bbf11687ce032ab2ff4b9b3aee5af742baecf41ea1c2db83bcba00bccc977af7d0c5c8e -a9ef1cbb6a7acb54faf1bcbd4676cdeba36013ca5d1ac1914c3ff353954f42e152b16da2bdf4a7d423b986d62b831974 -aa706d88d3bd2ce9e992547e285788295fd3e2bbf88e329fae91e772248aa68fdfdb52f0b766746a3d7991308c725f47 -911a837dfff2062bae6bcd1fe41032e889eb397e8206cedadf888c9a427a0afe8c88dcb24579be7bfa502a40f6a8c1cc -ae80382929b7a9b6f51fe0439528a7b1a78f97a8565ba8cddb9ee4ba488f2ab710e7923443f8759a10f670087e1292c4 -b8962de382aaa844d45a882ffb7cd0cd1ab2ef073bce510a0d18a119f7a3f9088a7e06d8864a69b13dc2f66840af35ae -954538ffff65191538dca17ec1df5876cb2cd63023ff2665cc3954143e318ece7d14d64548929e939b86038f6c323fc1 -89efa770de15201a41f298020d1d6880c032e3fb8de3690d482843eb859e286acabb1a6dc001c94185494759f47a0c83 -a7a22d95b97c7c07b555764069adaa31b00b6738d853a5da0fe7dc47297d4912a0add87b14fa7db0a087a9de402ea281 -9190d60740c0813ba2ae1a7a1400fa75d6db4d5ce88b4db0626922647f0c50796a4e724e9cc67d635b8a03c5f41978f7 -ab07c30b95477c65f35dc4c56d164e9346d393ad1c2f989326763a4cc04b2cb0386e263007cc5d0125631a09ad3b874c -9398d8e243147de3f70ce60f162c56c6c75f29feb7bc913512420ee3f992e3c3fb964d84ef8de70ef2c118db7d6d7fd5 -b161b15b38cbd581f51ca991d1d897e0710cd6fdf672b9467af612cd26ec30e770c2553469de587af44b17e3d7fea9f7 -8c5d0260b6eb71375c7ad2e243257065e4ea15501190371e9c33721a121c8111e68387db278e8f1a206c0cce478aaa2b -b54ac06a0fb7711d701c0cd25c01ef640e60e3cb669f76e530a97615680905b5c5eac3c653ce6f97ceca2b04f6248e46 -b5c7f76e3ed6dc6c5d45494f851fa1b5eaf3b89adac7c34ad66c730e10488928f6ef0c399c4c26cbeb231e6e0d3d5022 -b6cd90bdd011ac1370a7bbc9c111489da2968d7b50bf1c40330375d1a405c62a31e338e89842fe67982f8165b03480c7 -b0afcaf8d01f5b57cdeb54393f27b27dc81922aa9eaccc411de3b03d920ae7b45295b090ef65685457b1f8045c435587 -b2786c0460e5057f94d346c8ebe194f994f6556ab2904a1d1afd66c0ff36391b56f72ed769dcc58558ee5efaa2ed6785 -965dbb0cb671be339afcb2d6f56e3c386fb5d28536d61d6073b420ee15dee79c205af2f089fbb07514a03c71bf54b4e2 -90f2003e2286bba9cebff3a6791637ca83b6509201c6aed1d47f27097d383d5c2d8532bff9e3541d2c34259841cf26ab -902142d1224e1888ebbfef66aaf8d5b98c27927a00b950753a41d1d28a687a8286b51655da9a60db285b20dc81d5ea89 -a5d364448bf0d0849e5104bdaef9cb2cc8c555f5d6d34239c68671fbe1252f7c8c75b83cea10159dee4da73298f39a12 -b013a54c5b99e296d9419ad5c2aaf4545acd34405e57d13cb764e92132cc20d1a14b33e10caf22d898b608670c04f273 -b92976dceda373331804d48a7847f508cafde8d15949df53dbda09d03908678db1e61ee637baad5f05b2b03ea6f5a870 -968bcb308c7ad0813dc9b3170f23f419aecd7b42176f27fac698811795bf42659fea6b04dab4ef43595dcc990622041b -a9d0a20e9367ea831dccd37f4d97ea75e9aeec952947a7946d95e0d249c94024183ef79a624bdea782469824df0ee4e4 -8521b9667453c3658703e5db365b13f0e0d2331ce611ff1e708f8124d8a81bb5e82871de4a66d45c1a6b0a3901bd901e -b9c88e76e69b0722c0a2f97e57dbc4a6f7456434cd694e2ff67f4e24740cffa4db03e2b18f07f22954ae7db2286e1fa2 -8400e55aa9ab01d4cc0affd611127b5d8d9a9dbd897f3cb8e2050379983aa54249be17d7b7891977b2515bb44a483f65 -8cbb967b4ed31dc40ea06822a94d54cbfc8845c66fbafa3474c8f5fe1ada97299ed4ca955d9d7a39af8821eabf711854 -b4d266ee3fea264a6c563fd6bed46f958c2d7bd328225f6e47faf41a0916aef3b697574322f8b814dfb2f5c242022bf6 -8f7c72d69a919450215ead660ffa9637642c5306354888d549fd4a42e11c649b389f67cc802a0184d10fdb261351140c -a5f9e494ea9b2393ec32c48aac76c04158ccef436d4e70ad930cba20c55fbf61e8f239f70b9d75462405c4b6317c71a1 -b3befb259b52a44a6f44345859e315c20efa48c0c992b0b1621d903164a77667a93f13859790a5e4acb9f3ec6c5a3c6e -b9e4ca259b4ee490d0824207d4d05baf0910d3fe5561ff8b514d8aa5c646417ca76f36ab7c6a9d0fb04c279742f6167a -98fa8c32a39092edb3c2c65c811d2a553931010ccb18d2124d5b96debd8b637d42b8a80111289f2079d9ebca2131a6dc -a65e5aa4631ab168b0954e404006ce05ac088fd3d8692d48af2de5fd47edbf306c80e1c7529697754dbbba1b54164ba0 -b94b7d37e4d970b4bb67bf324ebf80961a1b5a1fa7d9531286ab81a71d6c5f79886f8ef59d38ae35b518a10ed8176dcc -b5ed2f4b0a9ae9ace2e8f6a7fd6560d17c90ae11a74fa8bef2c6c0e38bfd2b9dd2984480633bca276cb73137467e2ce3 -a18556fe291d87a2358e804ee62ddff2c1d53569858b8ae9b4949d117e3bfb4aefce1950be8b6545277f112bebeeb93d -a0d60b9def5d3c05856dff874b4b66ec6e6f0a55c7b33060cc26206c266017cdcf79b1d6f6be93ed7005a932f9c6a0b9 -801fced58a3537c69c232ce846b7517efd958e57c4d7cd262dbec9038d71246dafad124aa48e47fe84ecc786433747c7 -a5e9a8ea302524323aa64a7c26274f08d497df3d570676ecc86bd753c96a487a650389a85f0bc8f5ea94fe6819dc14e5 -a8a2963dc9238a268045d103db101adc3b2f3ab4651b7703b2fe40ece06f66bf60af91369c712aa176df6ed3d64a82fa -a4a8ff0a9a98442357bcdd9a44665919c5d9da6a7d7d21ccdbbd8f3079b1e01125af054b43b37fc303941d0a2e7baee0 -90ef893350f50d6f61ee13dfab6e3121f4a06a1908a707b5f0036cdc2fe483614de3b1445df663934036784342b0106f -84e74d5bc40aaab2cc1d52946b7e06781fbef9d8de6f8b50cd74955d6bdb724864c0e31d5ac57bf271a521db6a352bd6 -832cdf653bbbd128e2e36e7360354a9e82813737c8ab194303d76667a27aa95252756c1514b9e4257db1875f70f73eb4 -a0af8660ed32e6dbcc4d5d21b0a79a25ff49394224f14e6e47604cf3b00136de8f9ab92e82814a595bf65340271c16c3 -9040b5caf5e4dc4118572a2df6176716b5b79d510877bbb4a1211b046596899ea193be4d889e11e464ffb445ab71907b -b9bf8354c70238ab084b028f59e379b8a65c21604034d1b8c9b975f35a476e3c0ba09dd25bf95c5d8ffb25832537319b -a7b492cc1df2a8f62c935d49770d5078586bd0fefda262eb5622033e867e0b9dc0ffc2ce61cd678136a3878d4cbb2b56 -95a5ef06f38743bba187a7a977023b1d9d5ec9ef95ba4343ad149a7b8b0db0e8e528bfb268dc7e5c708bc614dc3d02c8 -99dcf7f123df6c55aeff0a20885a73e84d861ec95cf9208ba90494f37a2dcaacebc8344f392547d3046616d9753c7217 -b3e14f309281a3685ceb14f8921c1e021b7e93c9e9595596b9fb627e60d09ed9e5534733fcbdf2fbc8c981698f5e62ac -816a5e0463074f8c7fb2998e0f0cf89b55790bdbbb573715f6268afb0492453bd640dd07a9953d0400169d555fdf4ac8 -8356d68f3fe7e02a751f579813bd888c9f4edcc568142307d1c9259caef692800e1581d14225e3a3585dac667928fa94 -8d70ea3314c91bfc3f7c1dcf08328ae96f857d98c6aac12ad9eebc2f77e514afdbaf728dfcb192ed29e7ce9a0623ecbb -b68280e7f62ced834b55bc2fcc38d9ea0b1fbcd67cc1682622231894d707c51478ed5edf657d68e0b1b734d9f814b731 -b712dd539e1d79a6222328615d548612eab564ace9737d0249aa2eefed556bbcf3101eba35a8d429d4a5f9828c2ac1fe -8da42ca096419f267f0680fd3067a5dbb790bc815606800ae87fe0263cae47c29a9a1d8233b19fe89f8cc8df6f64697e -8cb2ffd647e07a6754b606bde29582c0665ac4dde30ebdda0144d3479998948dae9eb0f65f82a6c5630210449fbd59f7 -8064c3ef96c8e04398d49e665d6de714de6ee0fced836695baa2aa31139373fad63a7fc3d40600d69799c9df1374a791 -aec99bea8ab4e6d4b246c364b5edc27631c0acc619687941d83fa5ba087dd41f8eaec024c7e5c97cf83b141b6fb135da -8db6051f48901308b08bb1feb8fd2bceaedde560548e79223bd87e485ea45d28c6dcec58030537406ed2b7a9e94e60cc -a5b812c92d0081833dcf9e54f2e1979a919b01302535d10b03b779330c6d25d2de1f374b77fe357db65d24f9cbcd5572 -967d442485c44cf94971d035040e090c98264e3348f55deabd9b48366ec8fe0d5a52e4b2c9a96780a94fc1340338484e -a4b4110bef27f55d70f2765fc3f83c5ddcdfe7f8c341ea9d7c5bcee2f6341bcfbf7b170b52e51480e9b5509f3b52048f -a0d39e4eb013da967a6ac808625122a1c69bf589e3855482dedb6847bb78adc0c8366612c1886d485b31cda7304ec987 -a92f756b44d44b4e22ad265b688b13c9358114557489b8fb0d9720a35e1773b3f0fa7805ac59b35d119a57fe0f596692 -aa27e4b979af6742b49db8bf73c064afd83a9cfe9016131a10381f35a46169e8cfd1a466f295fcc432c217c7c9fa44a5 -845961319cc10bcfbb1f3cb414a5c6a6d008fb3aac42c7d5d74e892cc998af97bc9a9120c3f794e4078135e16a416e38 -a18dbe3015c26ae3e95034c01d7898e3c884d49cc82e71ddb2cf89d11cec34cc2a3dff0fafb464e8e59b82ce1a0a7a11 -a954aed6d7124fa5bd5074bd65be4d28547a665fb4fe5a31c75a5313b77d1c6fc3c978e24c9591a2774f97f76632bdde -8f983b2da584bdff598fcb83c4caa367b4542f4417cc9fa05265ff11d6e12143c384b4398d3745a2d826235c72186a79 -b2caa17d434982d8dd59a9427307dfe4416b0efc8df627dd5fc20d2c11046c93461d669cab2862c094eec6a9845990c6 -8c2baa5a97ee3154cce9fa24f6b54b23e9d073e222220fdd0e83e210c0058fb45ce844382828b0cb21438cf4cad76ee6 -b93437406e4755ccf1de89f5cbe89e939490a2a5cf1585d4363c21ae35b986cb0b981dec02be2940b4ec429cc7a64d4c -a90ac36c97b7ea2eddb65e98e0d08a61e5253019eeb138b9f68f82bb61cdbadf06245b9dfffe851dfa3aa0667c6ac4b8 -8bcdd7b92f43b721ddbfd7596e104bc30b8b43bdaee098aac11222903c37f860df29d888a44aa19f6041da8400ddd062 -98f62d96bdf4e93ed25b2184598081f77732795b06b3041515aa95ffda18eb2af5da1db0e7cfed3899143e4a5d5e7d6c -ad541e3d7f24e4546b4ae1160c1c359f531099dab4be3c077e446c82cb41b9e20b35fa7569798a9f72c1fae312b140b4 -8844a1471ff3f868c6465459a5e0f2fb4d93c65021641760f1bb84f792b151bc04b5a0421bbc72cf978e038edc046b8f -af895aebe27f8357ae6d991c2841572c2063b8d0b05a2a35e51d9b58944c425c764f45a3f3b13f50b1b1f3d9025e52ad -adf85265bb8ee7fead68d676a8301129a6b4984149f0eb4701eae82ec50120ddad657d8798af533e2295877309366e9c -962e157fe343d7296b45f88d9495d2e5481e05ea44ca7661c1fdf8cc0ac87c403753ca81101c1294f248e09089c090eb -a7c8959548c7ae2338b083172fee07543dc14b25860538b48c76ef98ab8f2f126ecb53f8576b8a2b5813ecb152867f18 -ae71680366e11471e1c9a0bc7ea3095bc4d6ceb6cf15b51f1b6061b043f6d5941c9f869be7cb5513e8450dca16df2547 -831290201f42ebf21f611ca769477b767cf0ee58d549fcd9e993fae39d07745813c5ce66afa61b55bb5b4664f400ece7 -af5879e992f86de4787f1bc6decbc4de7d340367b420a99a6c34ac4650d2a40cbe1cef5c6470fc6c72de8ee1fe6bcce4 -8d3c27e1b2ef88d76ac0b1441d327567c761962779c8b1f746e3c976acb63b21d03e5e76589ce9bb0d9ba6e849ed3d53 -ab23b09c9f4151e22654d43c1523f009623b01fe1953d343107cef38b95bd10afd898964946d3cb8521bcbe893e1c84d -8a6acade9520e7a8c07f33d60a87fd53faa6fbf7f018735bffcbbb757c3bafb26f547ceb68e7b8b6bca74819bfcd521a -94db50080d557440a46b6b45ee8083bc90e9267d40489040cbed6234bebf350c788ec51557b969f95194102fde8e9713 -8be8031f32504e0c44958d893649f76cec17af79efcd22bbedb78378f0a150845467e59f79a3f2a3b6a66bdf0d71d13c -a69a4ac47fd92e1926b5e14adcbebbef049848e8a00d4bb387340892e5a9333cae512f447201728d3b53c6cf980a5fdc -8fc713825277c5a8d9ef0a1f6219d141def6d8b30aff0d901026280a17d1265d563ff5192a0817e0e1a04ff447fb6643 -8bf0a85569c4f0770ff09db30b8b2ea6c687630c7801302c17986c69a57c30f0781d14b3f98a10b50c4ecebc16a5b5ec -896baa4135d5621fd6b6a19c6d20b47415923c6e10f76c03a8879fd8354e853b0b98993aa44e334623d60166ba3e3ca9 -b82cde1c2e75a519ef727b17f1e76f4a858857261be9d866a4429d9facf9ea71d16b8af53c26bde34739fe6ea99edc73 -b1a9e1f2e34895a7c5711b983220580589713306837c14073d952fe2aef0297135de0be4b25cbfaed5e2566727fb32ef -b42ed0e9eaf02312d1dba19a044702038cf72d02944d3018960077effc6da86c5753036a85d93cd7233671f03d78d49a -a402e34849e911dbf0981328b9fe6fff834c1b8683591efd3b85aa7d249811d6b460a534d95e7a96fdd7f821a201c2c4 -a774417470c1532f39923d499566af762fa176c9d533767efd457cc5e4a27f60e9217f4b84a9343ecb133d9a9aab96b7 -83dc340541b9ef2eb8394d957cd07b996d2b52ac6eb5562cbba8f1a3312f941c424c12d1341a6dc19d18d289c681ef40 -b2906c32d5756b5712e45dec53782494a81e80f887c6e1ef76e79c737625eccecb8fd17b20e6f84890d322b6ffde6eab -b89705c30cec4d50691bc9f4d461c902d6a4d147cf75ee2f1c542ad73e5f0dabe3d04cd41c6c04ab1422be4134cf1ad7 -8c3293651f4c4fac688bf5837c208b15e5a19ce51b20dd80ffc7fca12d3e615b2773cfc3ed62a1b39c66808a116bde06 -8fceb8ef481163527d1fc3abc7e1a5b3b6de2f654c3fe116d1367b177dcba2e0d2124a7216803513a3d53fc1e30435b9 -b2a42c827da630aaa3eb20ed07d136aa11ba01b4c8efc0a57ebab7d5b851a15daa6ba118bcffbc20703916e430e30a87 -a86340153abb3fe97414e2fde857e15aac27c9bb9b61258eea6766024f426ed0753f08f07f6b02b5375e1587ea3afcab -b006465e258e646f91ba889765113d3dc9bd657246c533cab6516d55ba054baa9d7276a3b0fa31730c3bd824845bf107 -a08aadc09428719cde0050d064c0f42c5b7c4f6c158227d7636f870957d6cfe821b4c62d39279a7c98f5a75fcb7bbfba -885e7d47ce9b50d21b95116be195be25f15223a6a189387575cc76740174c3e9044f1196986d82856b3fb25cdd562049 -b18c3780362d822cc06910743c4cbcef044823a22d12987fe2e56f3801e417f2e9cd31574ea1c5c6ee7673a14aa56e3e -a625570ef7d31c042d968018865aeeba34ee65a059ab1ec079c7a8ba1be9e24bce6afb7036c07d9d6c96ab014f95d661 -8fc9bd4764adc4c300b5bd49a06dce885d1d8aff9bae68a47976d0cd42110aa6afa2d7b90b64e81c0f14de729f2fb851 -91d88714cb669f5f00241aa5ab80dffb04109492ea9c72b59645eb1f85f3539c61db2ab418af986f42241df8b35445e9 -b98f14e664df2590dd2d00b5b5c817e388e5d9fb074f718637c33b3d4969c89e82fdd12db8997f5ff3bf5bb5ca5dd839 -86cb3d9f148cb2170317a4c22af7092155aa66ecff7ab1299b102fbbaa33ed2a284b97b08f529d2da9faea63fb98972c -92449f6b8a7c737ecef291c947cbd602c47d7fe47dc3426c2b413f3019169aa56e14c2a7216adce713e1c7bd5c08a83f -b08c1b9080bba88b44a65070948142d73c00730715fbdd01e13fc3415c5b4f3248ef514fa3ade4a918c9a820cccae97c -b0a05297da76e37c22be7383e60bba1cbc4f98ba650e12d4afcfcea569842003644a10ad73c9148958f7bf1ffa0a27d0 -839092c1f4e9fb1ec0dde8176f013b0d706ab275079f00f8e774287dd658d1b5638d5fe206f5f2a141911a74bb120f75 -a36bd669bdc055ece4b17ff6eac4c60a2f23324a5eb6d0d6c16a2fce44c39cfd52d1fa2b67f3f5e83504e36426fbfc40 -8aa428323512cf769645e2913a72976d32da4c0062ffe468a6062fd009340f0f23c6b63285848a0e7631a907adb032a0 -944800f7d43f41283eb56115ac39ccc5bf107ae5db6abcaba6936b896260cd09428a6b828c0bccebeb00541073dbf38e -8e700ca7c9e1538cf64e161dd8d16af56fc29d53c79648150d6d8c268b0c95c76acded723e29918690d66252bd75f5b3 -b9c4ce35b5b16b4c39b6e85800c76b26e8d0999500fabc1e5b6234a7f8da18c621266ac0d5ebc085354297ff21ac89a5 -a0c706d32063f1877f7e903048ce885f5d012008d4a8019dd00261a8bbc30834bffeba56cdeddc59167d54cc9e65f8fa -839813b736225087cbbcf24506ea7bf69138605036b764ec0514055ac174bbc67c786a405708eb39a6c14c8d7e0ec6ee -b1a5fef055a7e921c664f1a6d3cb8b21943c89b7e61524a307d8e45aa432e5765a27c32efdb32d88062cd80800a260de -b17f8202d9ed42f0f5cb1b1dbda60711de3b917a77f6069546fa3f86d21f372b8dd5cb86f1994b873ba9982404e08daf -b5211d54bd02d44d4d808ad57067606f3e9fa2cad244a5f2acef0edf82de3c496d2b800f7c05f175d01fa6ace28b44d1 -aa9c6f8f489b35fdb7544116fe5102a34ff542de29262f156df4db4ea6e064f5ea20c4bd877d40377ed5d58114b68f19 -826668b1f32e85844ff85dd7e2a8e7f4e0fd349162428bc9d91626b5ab21bdbacd1c9e30cf16f5809b8bf5da4f4fe364 -b30d14917b49437f9fdbae13d50aee3d8a18da3a7f247b39e5d3e975c60bd269da32da4e4cc8844666fca0d65f4e3640 -8c6918d8d94b36c6b9e772e9a432e66df16724e3b0660bde5ea397e6ef88028bb7d26184fbe266a1e86aef4a0dfe5faa -906d80ffd692c1dd03ab89be52e0a5a9e90a9cdbfc523d2b99c138ae81f45d24c34703f9cb5a666b67416e3bb6272bc4 -8b07e8ba22b436e64f011cacf5e89c55cd3bfb72ae8b32a3a8922c4fccb29de6f73662d6e330da6aa6e732a2187ef3c9 -9547466b4553a49adf59cc65d4c3c9401b2178947ebe3bd33c6e63cfb67d6be8729033158594f6f244b272c4487d6958 -aafcccea41e05cb47223fa8dfec0dd55964268bd4d05e24469614077668655ac8a51d2ac2bfb22862f8f4fa817048c2f -870f8c1173e8fd365b0a2e55c66eea3ab55355990c311f3042377803d37e68d712edcc5a0a2e2f5a46df0c1c8e6310c2 -b4288f792008f342935f18d8d9447fe4ddcfea350566e13dba451f58c68e27241af1367f2603a9dff6748e7fe0c53de4 -91c58c0e537d3afdcf7783601dd9cda2aa9956e11f711b15403760cf15fc6dffb40ed643886854571da8c0f84e17adfe -a43fec8ee92febed32e7cdd4e6314a62d9d3052c7a9504057dfba6c71fdfbeff1cef945d8f087bd106b5bec7478ad51f -99cf5e0e3593a92f2ec12eb71d00eccec3eec8662333471b2cb3a7826b7daca2c4d57ffba18299189cf7364e2af5df6d -af50f9ab890b7517ff1f1194c5b3b6f7f82eabc607687a8380be371a6a67b117aeb9b6f725556551b81f8117971706a2 -aa352430887053602a54403bd0d24d6b5181b44aa976dfa190e21851699a88127dcc904c90a48ec44610056b5dcd36c4 -964c821ea1902354736fa382a929c156bd67b9468d6920d47c27b9d0d304b6144118888d124c1f6785da596435ed2410 -b2284a67af26b5f5aff87b4d8e12c78ab37c5eb6e92718fca8549f86f4f001b660fc4520456aff72c9bcddd686603942 -83c54cbb997ea493dc75df4023071dce6da94268feaa2352373789616f012098270ba4fd60c791796a6f5062fb2cd35e -9143e8fee0b8f0f34c65c7750858093dcf165c6a83c026bfac2d5ffa746361eb4b6a14fdb43e403add901ac3735735a3 -97d7748a5b278ee47b18c9e60689b12a0a05be47e58e78bf8c04b9e8b34e2e2f2d3ac3c25c76ab2e0a75e8a54777b7c8 -b4e68f6f2d978a5411414c164c81ddb2a141b01ebe18c65a8626ca75d6432e5988310b50a888a78c3a0a242353525af5 -8976f4cc3eaf2684718cf584712c4adaf00a4d9c521f395f937e13233b30329658b3deacfe7e29fac84c496047f2d36b -a40bcdf4b6e95f1535c88dddcbf2074ef2e746b7fd232bdfd2b88f2f6d4bbf21c6b263cf5fd3e12a03476f2f5ffe00d2 -88c7b6337ee705acd8358ef6d2242d36b140afff0579a7784b3928a0c49698bd39c1f400e8a2e3eda5fbfb2e8f28fe51 -a98612ba8b450a71d2075d51617ebeb7ca401ad3cbd9b8554850c65ef4f093ba78defb00638428c9f1f6f850d619287f -b7e71d3ffa18b185c1a6bd75668ff65d985efc0a0c19f3812cafde9adbfb59ffd108abeb376e6a8877fdf5061562f82b -8a3e5fd776cc26908a108a22b1b122d60cb8c4f483cbedcd8af78a85217bb5a887df3efed2b8b4ec66e68eb02a56ca93 -b0d92b28b169d9422c75f9d5cb0a701e2e47b051e4eacd2fd1aa46e25581a711c16caf32f40de7c7721f5bf19f48b3f5 -88895739d5152282f23e5909cf4beebda0425116eb45fc5a6a162e19207686d164506c53b745fb2e051bb493f6dbad74 -adbccfed12085cd3930bd97534980888ee564dda49e510c4e3ca0c088894855ef6178d5b060bca8a8a1a427afdbec8a8 -87d00674abd3d2e7047a07ed82d887e1d8b8155635887f232dd50d6a0de3fb8e45b80b5a05bc2ec0dea9497b4aa783ac -806e1d3dfadd91cbf10e0d6a5e61738d0dbff83407b523720dce8f21f8468b8a3fc8102acf6ba3cf632ca1cb2af54675 -95a9dff67cf30e993071edede12623d60031fa684dfbe1654f278a1eb1eb7e1be47886d3f8a46c29b032da3176c0d857 -9721973288384c70a9b191436029e85be57970ad001717edc76d44cbfa0dff74f8af61d5279c5cd5c92c9d0f6c793f63 -95c22d1d9b51ef36ba30ee059dcd61d22be3c65f245d0a5179186874219c08e1a4266f687fc973e71f3e33df2b0f7fd3 -b53ec083dd12cc42ae2bae46883a71f2a35443c9ce4ed43aa341eb5f616a53b64211ed5aac717fe09ef1d50f551ed9f0 -a103dab6695c682400f60be8d5851ce07f12e4bd9f454d83b39c41ddcf1443bb14c719b00b4da477a03f341aa1e920cb -b522236988518e5363b1c4bb3f641ff91d3d4c4d64c5f065415b738160b4ce4b0c22e1e054a876aa6c6a52fa4a21dfa2 -a6a00562f0879702cdba5befd256a09f44bf48e61780e0677ff8c3fda81d8e6dc76ba1b05e3494ca9a4cef057eba6610 -b974a2ae631e0b348421f0cda5bd4ce7d73c22dd0fc30404c28852c33499818cab89fbf5c95436d56a0aab3bf2bbab51 -9148cf2a7b7e773245d4df5a9d34cf6d9d42b1a26a4ca6bc3013feca6f3941d6c44f29ba9328b7fe6ce6d7f6565f8e4a -a34035c4a63e98528a135cc53bbbcfcda75572bc4c765f212507f33ac1a4f55563c1a2991624f7133c77b748bbe1a6da -a0c45923cfb7bd272ee113aecb21ae8c94dda7ad1fe051ddb37ab13d3bb7da5d52d86fff9f807273476c24f606a21521 -81ec2ca57f4e7d47897d0c5b232c59d7b56fe9ce0a204be28256a7472808de93d99b43c824a0cd26391e6cac59171daa -8373852f14a3366d46c7a4fc470199f4eebe8ee40379bd5aae36e9dd3336decaead2a284975ba8c84d08236e6b87c369 -b47e878a93779f71773af471ba372cb998f43baca1ae85ea7ff1b93a4dee9327e2fb79691c468ec6e61ab0eae7ceb9f1 -8fc8f260f74303f26360464cfef5ee7eebcbb06073cef3b1b71dab806d7c22f6b3244ce21d0945b35c41f032f7929683 -87e3c4e1dab00596e051ce780b9a8dba02ecdc358f6ddaeb4ec03c326e4b7da248404745392658eb1defff75b1ba25c8 -aac95d8e3b7fe236a7ca347d12a13ec33073f2b2b5a220ecfd1986ca5c3889f0e6a9d9c377a721949aa8991c1821953a -91a483679437ae126a16f5dc3bba6e9bb199dfbba417f0dc479f22819b018c420edc79b602db6183c6591b1909df4488 -94a4b2c663aa87a2417cad4daf21a88b84983a7b212ffcd18048a297b98e07dd4c059617136976fac1d9e94c8c25b8d2 -83e2a690bfa93c79f878a63c0f69f57aabdd8bede16b5966ffba7903dc6ad76775df1fd5347e6f2825f6cd7640f45a45 -a316af7ac11b7780d15312dc729499a1a63b61c4283e103ecce43c3b0cbb0f4bce6ff04e403f5c7cb670dee80c75ab99 -8d0a911c54ee1f9f7e7794732ad87b434c3f356294d196a5e35eac871727fd32a49c27c2dfa10833f9e6f9c7ccbe0064 -8b8db09028298a1f6362b346c8bfeced7cb5d13165a67c0559a9798a95b7a4a9810c02bb852289d47c59f507bd24ce77 -962d57305c518f175ed5d0847fb52ddc4258ca0e4c9ddfc8c333a2ee9f8b4e48d25a3d7e644b785a5953e2e4063da224 -92e0799491898271769250fe88b0cb9dadec98ac92f79de58c418d23ef8c47fcf21ddc90e0cd68bb8f1deb5da82da183 -99855067125f6a6c3a3e58d3bd2700a73ef558926bd8320d2c805a68e94207b63eda6bdc5a925ec36556045900802d51 -a724ae105ab4364a17ddb43d93da1e3fc6b50213f99b7be60954b24dc375c4f93a0737f4a10b4499b6f52667d5f3a64e -82070fb43a63fb50869b118f8940108f0a3e4cc5e4618948417e5cc3801996f2c869d22f90ca4ca1fdbef83c4778421a -b25c04365d6f24d5d3296c10d85a5de87d52a139ddbcbf9e0142074bc18b63a8bc5f5d135bd1e06c111702a4db4cee28 -851093282dcda93e5c98d687a17a7ee828cf868f6c85d372d9ae87f55d0593d8f9f0c273d31f7afa031cf6aea6a7ef93 -93f04f086fa48578210ed207065d80a40abcc82d8bfc99386a4044561d35748ff6c3da6489933c23644ad4b60726da8a -84b1b50d1e876ca5fc341bbedab5b3cc0f6a3f43ea7dd72605f74d0d9c781297b2f12b7872dd600924f1659a4cdf8089 -81b0ba88c582d3956f6b49ca3e031c6400f2ec7e1cd73684f380f608101e9807f54866be0bb9a09c03953c4c74fbb3c8 -a641af6ac644c41a55dee2ef55d3c37abdb19d52bc1835d88e7adda6b6ccd13987c5fd9cba9d318cabb541aa6a0c652e -a7b75b0624d04ad0901070e691eb2d2645b60f87e9d6b26e77a5fb843f846c32fc26e76ae93fd33fe3b857f87bc25162 -a81ba3e2ed0f94c67cd02ba7360e134f8becf7ed2ed2db09b9f5ef0942f7073bfee74ca446067db6092f7b38f74ccc11 -ab80edcabab5830a24210420f880ebac4e41bf7650c11ba230f4889634dbf8e8e2309f36be892b071c67a3bab8fc7ed6 -94d69b64675076fecad40fae4887fb13a8b991b325fa84e9d2d66e3b57646de71a58ad8fd8700fefb46975b18289250b -b44fc0df480cd753a041620fa655be9df74963ae03d4625847d5bb025ceb37f48d19c8c9c444546fba5fe5abb2868506 -b56e2c51324d6200b3d9781b68b5b5e1617a68afccd28b3a12a4be498d2e3aafcd86514c373a9f3a001db733010c29cf -a359a0c172e5cd7ce25080dd2652d863d7c95a4a502ae277ac47f613be5991300f05978404a0acb3bcda93524dcf36e4 -b01427a3dfdf8888727c0c9b01590b8ae372b7b4080d61e17ccb581bac21e61c4a58c75db7a410d1b2a367304e1e4943 -95cb08be4a96c18fbf9d32a4bbf632242029d039a5fdea811488d3634cd86520d4f9806250a8c01855ee2481210f542a -b8594fe6c0717164058f08aedeed1853523f56cec5edbf0d2be271fa5e8bfd61f2974b0f3988d70f5baa2e7888c7ec1f -8f64ee89f59daf74fa1056803247c9d678783ee3917b12a201f30f7523957763e979ceaddb38bae20de40b9885728049 -b6093ee4bdb837bcc59172e236f4bdbd439c0a5a50e2aa16636cbff81b51e92989eb5f80a3f75c37ae7b5b942e55b3d2 -913b6fbb7b43e3e5c49e96cd8e82ed25c655e51c7b8ca82e8fbf92b01ac83c39d52f6f4efab5d39b0591a0538601a86f -81f42668479ca0bec589678dc0973bf716b632578690efe1a0f13de630f306fb4a189a98c2302572fd85d3877ee030b5 -90ff89c38a9a7189f28d35a088657f52283670e7fec842fa91c265660ea2e73b0ad6c46703d649f406f787490b7a7e4b -9077b8b5f1e083183f3152ceb9c5491b5d4b86525a08879f7fb6d5e27f9f1a6867cf0d81b669a4a2d1f1654b67fa8d9c -a7a0275cf5b894adbf2e54a972310cfe113e811872111d6ee497d03750d9f6ffa5517b6c13a99b111a4a91e8e4dfeeee -a08976bf8125b7538313a584bbe710741d630cab067a204ad4501cc4938874ce7aa6a1a826259c2e82ef10a66f1f36fa -8aa45385b5b97f1f3e45f2bbf7a4f3e8ef068e628608484971c97adeb610ebd5deec31317e03eb6536808921062c04db -945b106b8f3ae85e60dfd34ef3dcc079bc6f0aab6df279ed000856efd51321462038ac0a1ca5db3ebf6379bc341e7c55 -a4199c87a96f98cc9d8776fe6de131d2c706b481eb9e9a3bbc50a93d492d7fd724ea469f723fbcfb94920cb5b32c1d76 -a5347b1b2f6149805de67546c5ed72253311099bf1473dbc63edcf14a0a5e68d401f5341338623fbe2e2715b8257e386 -af5dcd03ddc3769e83351d6b958d47a06d4e5224bd5b0ec40ffe6b319763fab8572002f4da294a9673d47762fd0e6e1d -82ec1031b7430419d83b3eea10a4af4c7027f32b91c3ae723de043233b4a2e0c022c9e0f5a1ac49753800f119159112d -8a744d911b67d03b69811f72e9b40d77084547e4da5c05ff33893468b029a08266fc07303f7005fd6099683ca42b3db4 -93ab566bd62d3439b8fc620f3313ef0d4cb369f0f0c352cdaf8e5c9e50b9950ac3540b72f4bf5adcb9635f9f7ce74219 -b2a211d72e314799bc2ac7030b8bbb8ef4c38ebd0ebb09d6cbd43bd40c6c61d80a3aad02cc73f5775a08b9657da20a48 -98d60f0a98d28718e0c6dcccc35a53521ea7f2d8fe08ea474374a336b44cea4cd1c63b31f2ad10186822bfb54aca53e6 -831f89cb94627cfe554d46ae1aad8c1cde7ebe86c4bd8fac4ef73ac2d5b491f5efa5dc4198cb8ffbec563e0606b91d89 -8f8552583bc6cb3fb176b7202236ee4128faf0c8ec608f9150f8e011d8c80b42aab5242c434d622b6d43510eaef752c0 -897bf27baaee0f9a8445200c3d688ae04789c380d1b795557841606a2031092328eb4c47fef31c27fdd64ba841d9d691 -b57589a4af8184b4a8ceb6d8657a35522672229b91692c1cec3ac632951e707922a00086d55d7550d699c4828bcfaab1 -98c2fe98095e026aa34074bcff1215e5a8595076167b6023311176e1c314b92b5a6d5faa9599d28fca286fadd4e3b26c -a034992e563bd31ede3360efd9987ecddc289bc31046aa8680903bb82345724805e6f6cf30f7889b6b95cf7319c3aea1 -85c33d9f10cc7185f54d53c24095e621966065e0ff2689a9aa6bb3d63706796c37a95021738df990c2c19493c0d44b64 -a8c1247d6de2215f45b50dd2dc24945ff9b93184bcc2159b69703b0bba246adcd1a70a12659f34c4ca4ba27dea6e3df5 -83ebdad2834c97bf92aac8717bab2f5cb1f01026b964d78e2f3b44e99d7908e419165b345d2b2f125b903096584e6683 -b0af6f7f81780ceb6e70adfd98e7702ec930c8ca854b50704c4a0fc8b887b9df60a6fe9038b487f3ed0eb8eb457307ea -933ec7e53882453898617f842ab2efae4756eb6f6ea0161cced5b62a0cdde4c08c7700d52f7546d4dd11a4c9e25d624e -adf6e6d4706025f85eb734f506dde66459c9537a1abf6189199cf219ae583b461e11c6242fce5f0795e4d9025270fabf -89e4316319483098761b0b065df4cfb542963b7a2556ba5425b6442fb0e596eb2a4f03e2dc8c617eebe8f243a12e7d10 -90c5a147555759ebc4d0e15e957a548315f9994ef0c7a3f53f2d18da44fb93bf051d96ba8551597a6f3e701b926fd791 -a151a9a5199c72c697b771cd81e550fc6f9596c752ae686ad988b316a7548360cf9785ab4645164d96cfdf9069a94020 -80cba11a3977729d7948db5bcc186159f4cae7c0a835bb38bb781e287dd6c238508e748f23454405c9d5eed28e77df02 -ae4b92ea03cb8ad12ad3ec76869ad05acb09f9d07a3c9a87dec0e50d9a276fe5d3d515a8c446f3aa35cd7d340a22c369 -8630062709a1f180f952de9f1ca3f41acce5420677f43d9619097e905a6237f1908d66db7a4dfdf1b2b92fb087e9944f -81defc33dd383d984c902c014424bddd5e53b013f67f791a919446daa103b09b972fa5242aba1b1dbe4a93149373f6c3 -963891ecaea97e661bac2594642327a54f5a0beb38fcb1c642c44b0b61faab9c87b0c9f544a3369171b533d3ab22f8f1 -932fadbff5f922ddcd4da942d57fe3e6da45c3d230808d800a3ca55f39b0b62f159be31a5924b395d577a259f48c6400 -992ce13bd037723447f88aeb6c7722fd9510c7474192b174ea914ed57c195c44c298aec9a8cabac103f0a5b50051c70b -b032157b3e4fe69db6ce6bb10bdf706a853fbd0bee08c2ab89da51ad827425df5df498b90e7a30247a7f9e954ca986e5 -b2478d4874578da3d5000893736bb65712e6aafe96e6fa5cf5878ae59ba0ce640dbe5d76ec2b5baca75af57def471719 -a387c17b14dd54910fecf472f760e67cf71a95e9e965cc09484e19581ada65e79938b86136a93e287e615fbd4908e080 -98f02be271d0f8841d8d561163f9e55e99b57aff121a93fba7a4654bcf15a0899811f00f5bcbfbebd98e365a0e332e97 -a3c34f01d54cab52a8890391b8cf152cc9cdc16e7e53794ed11aa7b1a21e9a84d39ddcfbcb36c5df6891c12307efc2e0 -a940331f491ec7ad4a9236ca581b280688d7015eb839ee6a64415827693d82d01710dc4bbd5352396be22781fea7a900 -b10874ed88423731535094031c40c4b82af407160dfade4229ac8f4ef09d57b3db95c4a9d73c1a35704f6bd0d5f6c561 -a9c5a4a7680261c1b0596f8ab631d73d4a7881b01e6559c628b5cdafa6dd2b6db2db64f3f2ab5841413a8a52b966a0da -8fc154564a61d5e799badc98b43a3587f804385a850adce9a115cbd2ad911f3fd4072b8e6b22fc6c025a6b7e7ea5a49f -b9caf7c6dcce3d378aa62c182b50bc9c6f651eb791d20fffa37ef4c9925962335fe0b3bc90190539312aa9ccf596b3b9 -90c5b7acf5cb37596d1f64fc91dee90f625f4219fa05e03e29aebea416c8e13384f2996f8d56791bcf44ae67dc808945 -ab8d311fc78f8a1b98830555a447c230c03981f59089e3d8a73069d402a3c7485abe3db82faf6304aaca488a12dbe921 -8a74fda6100c1f8810a8cacc41b62875dd46d5c4a869e3db46202d45a8d9c733b9299dda17ce2ad3e159122412a29372 -8769dcacba90e6fc8cab8592f996c95a9991a3efecfb8646555f93c8e208af9b57cf15569e1d6e603edac0148a94eb87 -854fd65eea71247df6963499bafc7d0e4e9649f970716d5c02fbd8708346dcde878253febb5797a0690bd45a2779fa04 -83e12dc75ef79fd4cc0c89c99d2dace612956723fb2e888432ec15b858545f94c16fae6230561458ceee658738db55ba -8416ef9ac4e93deff8a571f10ed05588bef96a379a4bdcc1d4b31891a922951fa9580e032610ac1bb694f01cb78e099b -93aea6e5561c9470b69d6a3a1801c7eef59d792d2795a428970185c0d59b883ab12e5e30612d5b6cde60323d8b6a4619 -91d383035aa4ec3d71e84675be54f763f03427d26c83afb229f9a59e748fb1919a81aca9c049f2f2b69c17207b0fb410 -b1c438956f015aef0d89304beb1477a82aed7b01703c89372b0e6f114c1d6e02a1b90d961b4acbb411cd730e8cacc022 -a1ee864a62ca6007681d1f859d868e0bcd9e0d27d1da220a983106dc695cb440980cfdb286e31768b0324b39ae797f18 -b57881eba0712599d588258ceada1f9e59c246cc38959747d86e5a286d5780d72d09e77fd1284614122e73da30d5cf5c -a48f9ae05ba0e3a506ba2e8bbce0d04e10c9238fa3dffa273ef3ffe9ec2ed929198a46507c0c9d9b54653427f12160f9 -8db18da7426c7779756790c62daf32ae40d4b797073cd07d74e5a7a3858c73850a3060f5a3506aae904c3219a149e35d -a2bf815f1a18d7be8ce0c452dfc421da00dcd17e794300cdd536e4c195b8c5b7ccc9729f78936940a527672ac538c470 -a34c6f1f2398c5712acc84e2314f16d656055adcafad765575ae909f80ab706cf526d59e5a43074d671c55b3a4c3c718 -b19357c82069a51a856f74cbb848d99166ce37bd9aca993467d5c480a1b54e6122ebddb6aa86d798188ea9f3087f7534 -b440eac6f24d12c293d21f88e7c57c17be2bdb2a0569a593766ae90d43eccf813a884f09d45a0fb044ee0b74ff54146a -b585d42ef5c7f8d5a1f47aa1329f3b1a566c38bf812af522aa26553010a02bfd6e9cc78fdb940ef413e163c836396a5f -aca213b27f3718348e5496342c89fffc7335f6792283084458c4a1aa5fe0a1e534fcec8e7c002f36141308faae73ef2a -b24c07359769f8ffc33bb60c1f463ea2baad440687ef83d8b7c77931592d534b2c44953c405914ace5b90b65646c1913 -b53dfaf381205a87ca4347328ff14a27541fa6436538f697824071d02d4a737ceb76a38dcc6e8dadef3b5bc6442f5109 -b55972d8ed5197215c0a9144fc76f2cd562ca5f4e28c33a4df913363fd1388978b224c44814adb4c065c588a4ac1fe10 -a3303bc650e120c2e9b8e964ad550eb6ac65ffe6b520768b3e8735565ae37eafdc00e3c15fae766d812f66956a460733 -b11e53912ea0e40c3636d81d7637e10c94cc7ed9330a7e78171a66d02b7603f4cb9b3f6968104b158de254e65b81640f -b076bb9f6d396aa09c2f4706ea553b426fdfd87d7d69e438285b74d334e82f73973cb4dbd6cb1647493433dad65dbc41 -9415828b1632175f0b733541e32c26a9c88fe12c721c23e595f2efceaa7f867f359e32564b7c032185686587ac935cf4 -89579a112c306181c79aabdbf683e7806357febcb73bf5e8883862ae29618ef89498b62634404bb612d618fcd16da415 -8761bcd55d04297c4f24899e8fb9f7c1fcd7449ae86371ee985b6a262e228f561c2584980694d9bf354bdf01543edb6a -9100c88bf5f6f00305de0c9cf73555f16a2016d71c50cb77438e8062bd549fa5407793a8a6a7e06398756777680a2069 -9235dfef45aeff9c174898b0755881b7171ed86362854f0eabc3bc9256176c05a5dc27ca527c91c3fa70c0ec5fd5e160 -ac53b1d677cebab6a99381dd9072b8ac1abae9870ec04a1f8d2a59b6f1de797c1492b59af6948f5cf2b20599170f5bba -946542936b0c59156e8fd5c1623b41369bc2cbcc46ece80360dcb5e7cce718a3dd8a021f0b9c223062a4e43d910b634f -b1e9939b34e1fcc026e820fcfa9ce748b79499f8e81d24a3ef0457b3f507fe5fa37b975a47c143e92eb695623b4e253b -9382d9b5766f6ae960d8a8435e8b5666e57ef8e5f56219e7bfd02857afe5cb16f44d70a9e444cfb1008649ae9b863857 -91770ed1215ed97dca1282b60b960be69c78e1473edb17cd833e712632f4338ff74bf435c3b257439497c72d535ae31f -8eb2cbe8681bb289781bf5250e8fa332141548234c5c428ff648700103a7cd31fdc2f17230992516c674aa0ab211af02 -a823b71c82481bc6ac4f157d5c7f84b893a326bbb498c74222427ded463d231bc6e0240d572ab96266e60eb7c8486aea -a13ce4f482089d867e5babcd11c39fa9a9facd41a2c34ee2577de9ce9c249187e16f2b3a984cc55f9e45b9343462d6d2 -8d80e7bc706059cf5151f9f90e761b033db35d16b80b34dc8b538adc8709d305a0c06933dcd391e96629cf3888c8bf87 -abcd36cdd86c0fb57fb7c0d7a3b9af5fd9aed14e9f4e7e84b0796c5c0ad18c41585e8c46e511cef73dc486fe43f6a014 -a947a5b6916f416fa5a69c31aba94add48584791148b27d0b3ed32c02a05dfc06f7fdc5006e3b2503bdf6e410e30f2fb -b158e621580659f1fa061d976b8591ac03b53ecd23d9eb2b08c1a20353d78438287749664d196020d469ef44b3b8752e -90a5a9540281e481ac4b8d29968f477cb006b56bd145529da855d65d7db0cf610062418c41a1d80c4a5a880c0abe62a0 -b2c91808b6289d08a395204a5c416d4e50a8bb1a8d04a4117c596c4ad8f4dd9e3fb9ce5336d745fc6566086ae2b8e94f -af6767c9b4a444b90aeb69dfddae5ee05d73b5d96e307ce0f3c12bccca7bc16475b237ba3bc401d8dafb413865edf71e -8dcecf624419f6517ef038748ac50797623b771d6111aa29194f7d44cfb30097ced26879e24f1b12a1f6b4591af4639b -954437559d082a718b0d6d7cec090532104ab4e85088e1fc8ee781d42e1a7f4cdb99960429707d72f195ff5d00928793 -80f0b7d190baa6e6ab859dc5baab355e277b00ddcca32e5cebe192877ad1b90ead9e4e846ca0c94c26315465aeb21108 -b8c29f181ed0bb6ac5f6a8d9016980303bb9a6e3bd63ce7a1a03b73829ac306d4fab306ac21c4d285e0d9acb289c8f2a -a7685079fe73ecaeabf2a0ef56bad8b8afb6aeca50f550c97bf27e6b4a8b6866601427fcd741dc9cb4ce67a223d52990 -ada2ebf6f2a05708d3757fbf91365ec4d8747eb4c9d7a8728de3198ceac5694516ab6fd6235568aecd8d6d21fef5ef48 -846bc5da33d969c53ab98765396cab8dcdbb73b9836c9bda176470582a3427cb6de26d9732fab5395d042a66bdba704c -800a3a7ea83ce858b5ebc80820f4117efa5e3927a7350d9771cad9cb38b8299a5ad6d1593682bba281c23a48d8b2aa71 -a002b18595dec90b5b7103a5e3ec55bdd7a5602ee2d3e5bd4d635730483d42745d339521c824128423dfe7571e66cbaf -b6b4e2067ac00a32f74b71007d8ab058c2ef6b7f57249cb02301085e1a1e71d5de8f24f79b463376fd5c848f2ab1c5bc -a3e03036db1b6117efe995bf238b0353ad6f12809630dca51f7daaaf69f7db18702e6b265208944bfb1e8d3897878a51 -add16712f66d48aab0885bd8f0f1fb8230227b8e0ffca751951c97077888e496d6bfab678cb8f9ffba34cee7a8027634 -ad211af2dd0748f85a9701b68c19edd4a7c420e497cb2e20afdc9df0e79663841e03b3c52b66d4474736f50d66c713ce -8c8a899ce0f16d797b342dc03c2212dda9ee02244c73c7511626dba845d11a0feb138441da5459c42f97209bf758cd9b -a17efc75c7d34326564ec2fdc3b7450e08ad5d1de4eb353de9d1cd919d90f4be99f7d8e236908b1f29cf07ae1ffe0f84 -862d4a8b844e1b0dd9f4deff180456ebed5333b54290b84f23c0ddb2725ac20307e21cbb7343feac598756fe36d39053 -9187fbb19e728a95629deda66a59e178f3fcd6e9d7877465aa5a02cea3baba2b684bd247b4afbf4aa466b64cb6460485 -85ae5636688d06eab3be16e44fe148515d9448c6123af2365d2c997f511764f16830610a58d747adab6db5031bea3981 -8aa8a82891f4e041ce6df3d6d5d7e5c9aaaffe08e0a345ac0a34df218272664c1b7be2450abb9bc428bd4077e6e5dcc4 -8c3bcc85ea574dfe1b9ca8748565c88024e94374434612925b4e9a09fa9d49c0a56b8d0e44de7bd49a587ef71c4bff5f -9524f9dd866fe62faf8049a0a3f1572b024120d2e27d1be90ad8b8805b4e2c14a58614516281cc646c19460a6b75587c -84580d9c72cfa6726ff07e8d9628f0382dc84ce586d616c0c1bd1fd193d0a49305893eae97388de45ba79afe88052ee9 -b5573e7b9e5f0e423548f0583423a5db453790ab4869bd83d4d860167e13fd78f49f9a1ffe93ddddf5d7cd6ec1402bc4 -aff658033db3dad70170decb471aee2cf477cf4d7e03267a45f1af5fd18200f5505c7ce75516d70af0b0804ec5868a05 -84a0eab4e732a0484c6c9ed51431e80cea807702fa99c8209f4371e55551088a12e33a11a7ef69012202b0bc2b063159 -a68f8e730f8eb49420fe9d7d39bb986f0584c1775817e35bb3f7dae02fd860cddf44f1788dc9e10d5bf837886b51947f -946002dd6cf7a4fd3be4bf451440e3f3fd7e9b09f609fa4e64767180b43146095dfc4b6994287f8cfa6d1390d144be71 -b7f19777d0da06f2ab53d6382751dc5e415249d2c96fce94ef971401935c1d1f7d3b678501e785cf04b237efe2fe736e -81e5c66dd404fc8ffd3ac5fe5e69ead7b32a5a7bc8605a2c19185efcc65c5073e7817be41e1c49143e191c63f35239c1 -b5f49c523532dfa897034977b9151d753e8a0fc834fa326d0f3d6dacc7c7370a53fc6e80f6d5a90a3fbec9bbb61b4b7c -8fc8e78c07319877adfaa154a339e408a4ae7572c4fb33c8c5950376060667fbfc8ede31e1b067933d47e3fdbf8564d7 -859cfef032a1a044532e2346975679545fbb3993a34497ce81bdcc312e8d51b021f153090724e4b08214f38276ee1e0d -ae476722f456c79a9c9dfdc1c501efa37f2bff19ab33a049908409c7309d8dd2c2912aa138a57a8d5cb3790ca3c0ba2f -89acbbeffb37a19d89cfe8ed9aa8b6acf332767a4c54900428dd9ab3bf223b97315aca399c6971fe3b73a10a5e95a325 -90a4a00418fdf4420a4f48e920622aae6feb5bf41fd21a54e44039378e24f0d93ccc858d2d8a302200c199987d7cb5e4 -a3f316b0bd603143eba4c3d2f8efe51173c48afe3c25b4ca69d862c44922c441bd50d9a5040b7b42ba5685b44071c272 -a22f4dc96fedd62b9a9f51812349e04d42d81d0103465c09295a26544e394a34abdc6ded37902d913d7f99752dbfb627 -a49f51baf32d0b228f76796a0fef0fe48a0c43ec5d6af1aa437603d7332505be8b57b1c5e133bc5d413739f5ae2ce9d0 -a9e4fe133057a0cd991898e119b735b31a79811307625277c97491ff5d864c428cfa42ae843601d7bb05c0313472d086 -b987edfe0add1463a797ff3de10492b2b6b7ef0da67c221ab6f0f2b259445768a73fbe495de238c4abbe4d328e817c49 -b7f0e4532a379a4c306bbef98b45af3b82b17175dfe0f884222ed954c12f27d8a5bdd0cdeb1df27ff5832ba42a6dd521 -9471bc5ad5ec554acfd61b2eb97b752cb754536f95ae54ca2cbd1dc2b32eb618881f6d8a8b2802c1a4e58c927067d6cf -b4c84f09225cf963c7cc9d082efe51afbbbe33469dd90b072807438e6bde71db8352a31bb0efde6cd3529619812ef067 -8f08005a83e716062d6659c7e86c7d3b51e27b22be70371c125046de08f10ea51db12d616fbf43e47a52e546e7acaac7 -a8937e66a23f9d9b353224491f06e98750b04eca14a88021ee72caf41bdce17d128957c78127fba8ef3dc47598d768a7 -80ad991de9bd3ad543cddeaa1d69ca4e749aaefb461644de9fc4bd18c3b4376c6555fc73517a8b1268d0e1e1628d3c1f -b22f98bca8fe5a048ba0e155c03e7df3e3cee2bfe8d50e110159abdb16b316d6948f983c056991a737b646b4d1807866 -b0bb925c19ca875cf8cdbefa8879b950016cc98b1deb59df8b819018e8c0ad71ea7413733286f9a1db457066965ce452 -95a991e66d00dd99a1f4753f6171046a5ab4f4d5d4fe0adfe9842795348a772d5a4a714dba06b4264b30f22dafa1322f -ad91e781fa68527a37c7d43dd242455752da9c3f6065cd954c46ae23ce2db08f9df9fec3917e80912f391c7a7f2f7ffa -a202d3becbf28d899fe28f09a58a0a742617c1b9b03209eca1be7f072a8ada1f7eac2cc47e08788d85e1908eb9d3d8ee -a360ccb27e40d774d5a07b4ebed713e59a0d71b3ee3f02374e7582b59ec4a5ce22cc69c55e89742ba036dd9b4edd8f34 -a10b897a946882b7c9e28abbb512a603ffa18f9274369843eb3491524a321df1f572eea349099ac6e749ea253c901ea0 -b782a672cd344da368732ecd7e0a1476c2af04613d3eb6da0e322f80438af932bd6d49be7a6f69f7c877512731723d89 -aeccee8dfd764e1adcfc4bf669e0fa87a94e7c79324333e958df47888bff5cec358b8b5bbb48db54822b54d11bbb4bc6 -ad4953913662a9ee8753a354864339f43916f2c2390d0a3f847c712b42718ee00ee14158d730709971941e8680d54560 -92ccb31d6c9e8940c7e8a4873e7eb9de9fb2fa2bac344fa367062ea451fd49a6920a45218dca3ee968711397d2a01536 -9448d9b2b3d12dde9b702f53373db8b8595f9d1f9de2ebee76de292f966f375316953aadf6bfc0e4e853e1fa12d8f02c -8919230878a7219da8c80a4b7d00b9169fb503e72d79789dd53863c243b8d0fb0a819d46fa636d805d0b9b1d15d1f2d9 -b6581ab01215aac023f5e6f57419b6aa63c0743c07caf57d4e146b56b02d90ce1423f70489ac3a11e5c968cb924f937c -a793ec1b1fe56a76920296af06073caadfd6f1d7e30950f8ca13de3de45fe275ca4b361f5249d9405264c3a06ebb5502 -86385b4a4e1bfb5efe7bfef8fd0dfeba7f4400852237cab60febb1dfa409e497a649e81284b5a15fe680b78927256756 -85d10600de96103daa7c90657174b6cb4a1286df5379f1eda9f11c97f9df57043c290eb1ae83658530fe0fd264867b86 -ae01b2396d0f598c21659cd854c15edd4904a34d22278aef97c9260a14a8b250b52d972d304ac4b187c24d08795d5355 -b91b3e4b6fc06e88081fe023ef1b773d82c628eb0f73a2731a9aa05b0dc89b7aeef2eea60125d302e696f45c407aeac2 -986d0f478e33af7568eab6bb26a55c13ffd7cae27525b4abe2f3a994bdb11bbc73d59bdb9a2f6b6ba420a26f8f620ba6 -9746f4fdeef35feaff1def0ea5366b64f21ed29749ae6349f9cb75987e7f931952f913f446100f2a6b182561f382e8eb -a34a116cfde1acbce0d7de037f72a7ca30ab126d8f4815b2b8bcb88e0e6c89015a4daaf4d4ce8eae23eb5d059cf9a5cf -80c3ea37f6a44f07cc9c9c881990f2a5deb9f9489a382718b18a287aa3c50ee6ebe8fd1b3afb84a3cf87f06556f4ca15 -97cff3bc88cfc72ce5e561f7eeb95d4ffb32697e290190c7902e9570c56b3854753777fc417fd27536fc398c8fefb63b -b8807232455833e4072df9bffa388ae6e8099758c2a739194719af7d9ed4041974a6cd9605f089de8b43f0e12f181358 -96f79fca72f75dc182c71f2343f0c43b06d98563fd02d2e1fbc031b96601608d8a726c811a74bb51ab8b0a3ce3632dc4 -b5262761680a4235a8c1257de4735cdcadf08d5d12c6e9d4f628464d5c05dfff3884a9ef2af3b7724b5a8c97e6be74eb -b6ce0eada73433d98f8fae7d55e4ea2b9d9d7a0ae850d328dd06991f27b1f03e470868fb102800ff3efe4ee1698531b9 -a37b7d9fe9d3fdfbc72c59cf6cacc7e7a89d534dea3d73121f7483331aec8ab3fbff58ffabb943b75d6f86df0ba43262 -93fce9be8a27fcaa1283d90d3e87265a6221ee302ec708161a42bd00ffe8e726743d9e187e1bf4307c0e3f25afbb1d44 -a4ea919021346ae7ea69d5e8f46d860b24c35c676b62f4e577c90e0c05c5646fe73721b143b7c38835dd4b443e6c3676 -b79983a5948453f70dfa4c396ce1945204498fe79f40c0667291bd0fdd96ed0b9ea424571f7ade342275c854c9f03d9e -866f8e395ed730b614b70bf999cad6e87e9086c1f5aea8d69020b562ee285dd0fb93afaca0dd13a0713f74a3f9340f01 -a3fef158782292c6139f9a0d01711aa4ed6f5cac11d4c499e9e65c60469ae3afbde44fb059845973a4b3bbca627b7eb7 -b4a2c0321b68f056e7d8051beede396fa2f0704d8aa34224f79f7b7a62eb485fc81889cb617019622fd5b5fa604516f5 -8f0e3edddbaead9059df94de4139e3a70693c9ea9bc6baaa5695dddfd67263b33926670159846292801941b9a0c6545b -9804e850f961e091dadd985d43d526ba8054d1bf9c573ed38f24bbd87aeaad4dcba4c321480abc515a16b3b28f27bb2a -95f330da28af29e362da3776f153f391703a0595323585220712dae2b54362cc6222070edd2f0dd970acfbe2e3147d5c -82d03b771231179cc31b29fe1e53379d77b5273b5c0a68d973accd7a757c7584dbb37f0507cdfde8807313ec733a6393 -81b3c39a9f632086e97b7c1f0ec7e2eaf9dc3cb0d84dec18a4441dbdc9fe9878fde4bcfa686bca1a9522632a353a5566 -a2db124ab2b493d5f9a1e4ca6b3144593c2fc8bfac129fd79da11dfbb7ef410a234fda9273a50a5ca05d7b37cc2088a2 -aa8550633c9449228702690cc505c0fc4837ea40862058e8f9713622b34d49fdc3a979b9317993c5da53b5bb5b7f4974 -ae783bcf7a736fdc815d0205b4c2c2b2fee0a854765228f76c39638ba503e2d37f1e28f6bdf263923f96fead76b4187b -b5ec86092c1d250251e93bab2f24e321afd2cd24cf49adfcbed9e8bc5142343ae750206c556320551e50fc972142f0da -b3b5791b590a6e9b3f473d5148624014aa244495249322a5d75cde2c64117ff9d32f4b0698b0e4382e5e7f72933061f8 -876c6a9162c17b16d6b35e6ce1ba32e26aec7dd1368bceab261ab880ad845c91e54b96a52c7d3aafbfbafc0e37139dca -902ddb5774d20b0707a704486457c29048776a5b88c377b14af6616c8ddf6cd34f49807df9c9d8866d6b39685cfb0f19 -8b87f71f94bc96de927d77a5d7123fa9cdda8c76aff64a5e6112cbc2eca43b07f8376db3e330f8af6a1db9b948908a6a -a69a5922e572b13d6778218e3657f1e1eea9a9682f6eb1b731d676d03563e14a37ff69bc5e673c74090ecb0969a593f7 -aff3510d78ba72f3cf5e3101847b7c4a956815aa77148689c07864e8a12dd0ef33d5f6c8cb486e0ea55850161f6afed0 -aa9c459cb2a008d94cbee2c6b561d18b0d7c6ffa8a65cbf86ae2c14eec070ee9d5324f5d38f25a945ddcd70307e964c4 -8310e15b050b1e40ece7530b22964bde0fd04f48dfffdec5a0d1fb8af0799a7fdc1d878139fb7cb8d043d3a52c2d1605 -b8f0856ce2c4034ee4041d0383f25fb0eeefc00b82443311a466fc18608313683af2e70e333eb87e7c687e8498e8a1ce -a8200a75c158fbb78474cab8a543caecd430b5d8b9964fc45d2d494dd938021cd00c7c33413ad53aa437d508f460a42a -a310091472b5b42b02176b72d5f8120bdb173025de24b420e3ca3fb9a386c39092a1d1bb591c6f68ee97a268a7ff9e95 -b23f1bf8bcec9cb5232b407115eead855fd06f5bf86ba322ad61d45460c84f0f36911aba303de788c9a0878207eac288 -ae4c129ad6d08be44690bb84370e48bfd92c5d87940750ee2c98c9a2604456f7f42727ab211989657bb202f6d907df04 -95992057d654f3e189a859346aa9aa009f074cb193b7f5720fa70c2b7c9ce887d886f6cff93fa57c1f7c8eaa187603f6 -ad12d560273963da94151dd6be49c665d7624011c67d54ab41447452a866bc997e92a80bdd9ca56a03528e72c456dc76 -8e4eda72e9cfcaa07265bb6a66d88e9ce3390ae1a6b8831045b36ea4156b53d23724824d0f0bca250ce850c5926fa38f -980fe29c1a267c556532c46130fb54a811944bdfea263f1afcdab248fa85591c22ac26167f4133372b18d9f5cce83707 -a7da9f99ddde16c0eac63d534a6b6776ad89b48a5b9718a2f2331dce903a100a2b7855cf7b257565a326ddc76adc71a5 -8ca854c55e256efd790940cb01125f293e60a390b5bd3e7a60e13ac11a24f350a7eb5ebddfa0a2890905ca0f1980b315 -9440335818859b5e8f180893a8acedceabaaa44e320286506721c639a489b5bfb80b42b28902ee87237b0bd3dd49552a -b9da545a20a5e7d60fd0c376dcaf4b144f5c5a62c8ffa7b250c53ce44be69c4e0d5e4e11422ef90593ae58ae1df0e5d3 -b75852a850687f477849fc51e0479703cd44428671c71bfdd27fe3e7930b97d2fc55f20348ca4e5bc08db2fc16a4f23c -b515081d8d099e4b6253c991ca2d3e42633f5832c64aa8f9cde23cb42c097c2c3717c46c5f178f16c58295f97b2b3fe7 -9506c9902419243e73d3197e407985dd5113f16c6be492651bbbf9576621942710aea74522d6fb56d5b52c6ccdaa4307 -952673ae27462a0f6c9545eede245c2f8e2fd6077b72a71f5672f1a5a02c263bc2a66f24f0e30376feb7a8187b715f08 -a8f1e2085ed666a8f86b474d9589dc309d5c83bd53e745f8e09abe0dfbaf53e5384c68580672990344d4aa739438b4d8 -ad6e04d4a67a5a5529ceaf7de6e19416be5b4c436610aa576ac04aee3b73317da88f891121f966393a37f52b775a2dd8 -a35a884736f08c7f76923ae7adb17fdac04e6c505178bca9502eaa2ed16d4d93fa953fb6dcf99e9e9962a6eb3eeead00 -b8af72273360bab4b3ca302cf0659717cbfb335fbc9ad4ffdd3340113ece9e63b2bdbd611e5f6b740a4689286f9a452d -b1a1f4ba2640800c3ed3892e049f6e10f8a571efa3bbe21fe2d6cee8fded171c675a3bb8aa121e2d1d715de84bad2e2b -8102a6c3598b40da4d6e8eccfdd5dadc8d6262e38b69c5b211b0732f4c6e3045d79fba12770a0b2b66f1e9f4664b1510 -90979587d75bf12819f63832beea7dcbef101f6814bf88db4575bfcd9cf0ea8eceba76d4d6db17630b73b46c1acfe011 -8dd98f14d2beb5b5b79cc30f6825ec11ed76bd5a8864593ffc0c2baffab6872bad182e1c64b93aab8dd5adb465fa5cec -8083334dadc49c84f936c603a2857f174eda5659ab2b7214572f318aba3ebd7b1c50e7cbea57272b9edf106bd016df3b -a634d08d2e8641b852e89d7ccab1bab700c32fb143bcbea132f2a5fb2968d74ded2af4107f69818798f0128cc245a8cb -94fc2dccf746d5b3027f7cf4547edf97097cd11db8d6a304c1c2ca6b3aba28c1af17c08d2bbb66f88c14472e0196a45e -b257a6fb01424b35e414c1c002e60487abb3b889d74c60cbdbf591e222739c6f97b95f6962842401f5e2009e91b28c55 -81955bdbf25741f3b85d5044898dc76ae51b1b805a51f7c72a389d3b4d94b2e3e0aa1ec271685bbcf192ed80db7367ab -86eb229b66c542514e42b113b9de7d4f146861a60f2a253264873e7de7da2ac206e156ff11f2de88491b9897174fe2f4 -8b8db00533afbb56b3d7d7a9a4a6af3cebb523699ffcb974603e54f268b3ef739c41cd11850b9651d9640d72217c3402 -8b7cbb72a6c4408d5f1b61001e65de459790444530245d47d4ee8e2d17716695283f21540bd7ac4f5a793a0d00bdf1d4 -875920b9bab4bc1712e6af89ae2e58e9928c22095026070b07e338421b554d9f96e549ac3706c6c8d73f502913a27553 -9455d192db7b039b3e8f0bc186c25ff07dfbe90dab911e3c62e3bd636db8019ed712cbb0ecd5cbb9a36c11034e102aba -8cb0b28e5d3838d69f6c12274d6b1250f8843938065d0665b347977fa3c1c685caef6930bae9483ed0d0a67005baad76 -94df2e14aae1ae2882ab22a7baf3dc768c4a72b346c2d46bfd93d394458398f91315e85dc68be371f35d5720d6ca8e11 -aacd94b416bfbeb5334032701214dd453ad6be312f303b7bec16a9b7d46ab95432a14c0fbf21a90f26aafb50ec7bb887 -b43d26963665244633cbb9b3c000cacce068c688119e94cc0dac7df0e6ee30188e53befff255977788be888a74c60fc2 -b40d67c9ad0078f61e8744be175e19c659a12065fe4363b0e88482b098b2431612e7c2fa7e519a092965de09ceafe25c -82cd4a4e547c798f89ce8b59687614aa128877e6d38b761646d03dc78f6cdd28054649fb3441bcd95c59b65a6d0dd158 -a058e9700f05cef6e40c88b154d66a818298e71ae9c2cf23e2af99a0a7dc8f57fbe529d566cb4247432e3c1dee839b08 -95c6f84406466346c0b4a2a7331ac266177fb08c493d9febb284c5ca0b141ccc17aa32407f579666b208fb187c0227dd -905d1d47a26b154f44d7531c53efbc3743ff70bd7dba50c9b9d26636767b0ae80de3963c56d4604399126f4ad41a0574 -83dfa11c520b4abaefe1b2bc1ce117806e222f373cd4fb724f3c037c228e3379d27a364e68faa73984ba73a0845f1b9a -a16e54786ba308a9c0241aff8f1bf785dece387d93bd74aa31de0969e3431479e2c0abebff9939a6644d2b0af44f80bb -81ac565212365176f5be1c0217f4e7c9fdbc9fe90f16161367635d52edcf57af79290531d2e8b585e1223d33febd957d -a296f4b09915e5d80ff7274dc3ffc9b04f0427e049ea4ef83dca91095275e8a260ef0335c7b6585953b62682da8c8e99 -a9150626208168a21ae871192ca9f11c1f7f6e41e8e02de00732de2324d0d69fe52f8762155c9913ee408a034552e49a -a42a56008ca340c6e9ff5a68c8778bb899ba5de9e7508c0cac355c157979a7ff6a6bd64f98b182114d3831cfa97ee72b -a4f05adf22c051812279258eea9eb00956b04ef095f2ca175f775ff53c710fb0020266adabd1dacaee814c4f1d965299 -967492e78ac0bceb8ad726ea0d2292b760043d16d64a6b1bb896e32630a7bf405c2b20e4e00842ae519a21697ff8db2d -adbf05e9b5931ae3dd24d105b5c523c221a486a4123c727069b9e295a5bc94f3e647a3c2cde1f9f45dbd89df411453c9 -a1759c0ebebd146ee3be0e5461a642938a8e6d0cdd2253ebd61645b227624c10c711e12615cd1e7ea9de9b83d63d1a25 -a4c5945d635b9efc89ad51f5428862aefe3d868d8fb8661911338a6d9e12b6c4e5c15a25e8cb4a7edc889b9fa2b57592 -aff127675ea6ad99cb51c6e17c055c9f8fd6c40130c195a78afdf4f9f7bc9c21eed56230adb316d681fc5cacc97187da -9071294e8ff05b246ff4526105742c8bf2d97a7e7913f4541080838ecfd2dbc67c7be664a8521af48dbc417c1b466a85 -990880b0dd576b04f4b4ce6f0c5d9ff4606ec9d3f56743ac2f469ac6a78c33d25c3105cf54f675e300ac68073b61b97a -a8d1a62ce47a4648988633ed1f22b6dea50a31d11fdddf490c81de08599f6b665e785d9d2a56be05844bd27e6d2e0933 -8ea5a6c06f2096ded450c9538da7d9e402a27d070f43646533c69de8ea7993545673a469c0e59c31520e973de71db1b4 -99d3a098782520612b98a5b1862ae91bcb338ab97d1a75536e44b36a22885f1450a50af05c76da3dd5ca3c718e69fdd4 -b987451526e0389b5fe94c8be92f4e792405745b0a76acd6f777053d0809868657ba630aa5945f4bd7ce51319f8996f7 -afffccc5ddd41313888a4f9fee189f3d20d8b2918aa5ad0617009ea6d608e7968063c71bd5e6a1d7557880d9a639328d -8ac51a02505d5cadfd158dde44932ab33984c420aeceb032ed1ee3a72770d268f9e60ccf80ce8494dfc7434b440daafd -b6543e50bd9c6f8e0862850c3d89835ddd96231527681d4ab7ae039c4a3a5a0b133a6d40cdb35c8a6c8dbb8d421d3e2b -a2ba901f4fde2b62274d0c5b4dbbea8f89518571d8f95ec0705b303b91832f7027704790a30f7d9d2cdafde92f241b3e -a6974b09280591c86998a6854a7d790f2a6fbe544770e062845cfc8f25eb48c58f5dfb1b325b21f049d81998029ad221 -890baeb336bbf6c16a65c839ffaab7b13dd3e55a3e7189f7732dbcb281b2901b6d8ba896650a55caa71f0c2219d9b70e -b694211e0556aebbe4baf9940326e648c34fda17a34e16aa4cefd0133558c8513ffb3b35e4ee436d9d879e11a44ec193 -97cf9eb2611d467421a3e0bfe5c75382696b15346f781311e4c9192b7bca5eb8eaf24fa16156f91248053d44de8c7c6f -8247f88605bd576e97128d4115a53ab1f33a730dc646c40d76c172ca2aa8641c511dddad60ee3a6fbe1bb15cac94a36c -ae7ecd1c4a5e9e6b46b67366bc85b540915623a63ab67e401d42ca1d34ae210a0d5487f2eef96d0021ebecfd8d4cd9a8 -aec5123fff0e5d395babe3cb7c3813e2888eb8d9056ad4777097e4309fb9d0928f5c224c00260a006f0e881be6a3bf8f -8101724fa0ce7c40ea165e81f3c8d52aa55951cc49b4da0696d98c9fafd933e7b6c28119aa33f12928d9f2339a1075d1 -a8360843bab19590e6f20694cdd8c15717a8539616f2c41a3e1690f904b5575adb0849226502a305baefb2ead2024974 -ade5cad933e6ed26bba796c9997b057c68821e87645c4079e38e3048ea75d8372758f8819cde85a3ab3ab8e44a7d9742 -ab1fe373fb2454174bd2bd1fe15251c6140b4ac07bda1a15e5eabf74b6f9a5b47581ef5f0dbd99fdf4d1c8c56a072af7 -b425e1af8651e2be3891213ff47a4d92df7432b8d8ea045bb6670caf37800a4cd563931a4eb13bff77575cbcae8bc14f -b274799fe9dd410e7aed7436f0c562010b3da9106dc867405822b1e593f56478645492dbc101a871f1d20acf554c3be6 -b01a62a9d529cc3156bc3e07f70e7a5614b8d005646c0d193c4feb68be0b449d02b8f0000da3404e75dbdfa9ca655186 -878b95e692d938573cdb8c3a5841de0b05e5484a61e36ea14042f4eadb8b54a24038d2f09745455715d7562b38a8e0df -a89e998e979dba65c5b1a9000ad0fd9bb1b2e1c168970f2744982781306bbe338857e2fac49c8cafda23f7cc7c22f945 -85880fdf30faed6acce9973225e8fe160e680a55fc77a31daacf9df185453ad0c0552eb3fd874698ad8e33c224f7f615 -ac28d20d4bbb35ba77366272474f90f0ed1519a0e4d5de737adee2de774ccd5f115949e309e85c5883dbc63daaa6e27b -a1758ac86db859e323f5231ad82d78acbe11d53d3ebf7e644e581b646eede079d86f90dc23b54e5de55f5b75f7ea7758 -ae4c0b84903f89353bf9a462370f0bf22c04628c38bb0caae23d6e2d91699a58bd064e3c2b1cbda7f0a675d129f67930 -95f21a099ffc21a0f9064d9b94ce227b3ff0a8c5a2af06ff5ee6b7f3248a17a8ca2f78cd7929ef1d0784f81eddefcd48 -8d06fbc1b468f12b381fd1e6108c63c0d898ddf123ea4e2e1247af115043c4f90b52796076277b722dd2b92708f80c21 -a300f39039d8b2452e63b272c6d1f6d14a808b2cd646e04476545da65b71a6e29060f879409f6941c84bde9abe3c7d01 -adecce1ccc5373072ba73930e47b17298e16d19dbb512eed88ad58d3046bb7eec9d90b3e6c9ba6b51e9119cf27ce53f2 -941a7e03a64a2885d9e7bee604ddc186f93ff792877a04209bbee2361ab4cb2aed3291f51a39be10900a1a11479282ca -acbcb1ab19f3add61d4544c5e3c1f6022e5cc20672b5dc28586e0e653819bdae18cda221bb9017dfaa89c217f9394f63 -b8d92cea7766d3562772b0f287df4d2e486657b7ab743ed31ec48fdc15b271c2b41d6264697282b359f5cb4d91200195 -957360ecb5d242f06d13c1b6d4fcd19897fb50a9a27eb1bd4882b400dc3851d0871c0c52716c05c6c6cf3dee3d389002 -abd2a23abbc903fbb00454c44b9fb4a03554a5ef04101b2f66b259101125058346d44d315b903c6d8d678132f30b1393 -ae9572beff080dd51d3c132006107a99c4271210af8fbe78beb98d24a40b782537c89308c5a2bddfdfe770f01f482550 -82c7e5a5e723938eb698602dc84d629042c1999938ebd0a55411be894bccfb2c0206ac1644e11fddd7f7ab5ee3de9fdc -aba22f23c458757dc71adb1ce7ef158f50fdd1917b24d09cfc2fbbcbe430b2d60785ab141cf35ad9f3d0a2b3e2c7f058 -8eff41278e6c512c7552469b74abedf29efa4632f800f1a1058a0b7a9d23da55d21d07fdbb954acb99de3a3e56f12df6 -8abd591e99b7e0169459861a3c2429d1087b4f5c7b3814e8cee12ecc527a14a3bdda3472409f62f49a1eb4b473f92dbf -82dcbff4c49a9970893afc965f1264fcab9bae65e8fb057f883d4417b09e547924123493501c3d6c23a5160277d22a8e -b5a919fcb448a8203ad3a271c618e7824a33fd523ed638c9af7cfe2c23e3290e904d2cd217a7f1f7170a5545f7e49264 -96d6834b592ddb9cf999ad314c89c09bedc34545eeda4698507676674b62c06cc9b5256483f4f114cd1ed9aaec2fba5e -a4e878cf4976eb5ff3b0c8f19b87de0ef10cd8ec06fe3cd0677bd6be80ba052ff721a4b836841bdffb1df79639d0446c -8e15787a8075fd45ab92503120de67beb6d37c1cc0843c4d3774e1f939ac5ed0a85dad7090d92fa217bd9d831319021b -8506c7fea5a90cd12b68fdbbae4486a630372e6fd97a96eea83a31863905def661c5cdead3cf8819515afe258dbcd4d9 -952ef3bc16a93714d611072a6d54008b5e1bf138fd92e57f40a6efb1290d6a1ffcc0e55ff7e1a6f5d106702bd06807cd -a5f7761fa0be1e160470e3e9e6ab4715992587c0a81b028c9e2cf89d6f9531c2f83c31d42b71fca4cc873d85eba74f33 -b4811f0df11ff05bf4c2c108a48eece601109304f48cde358400d4d2fa5c1fdaaf3627f31cb3a1bdd3c98862b221720d -9207ad280b0832f8687def16ad8686f6ce19beb1ca20c01b40dd49b1313f486f2cb837cfbbf243be64d1c2ab9d497c3f -b18a8c1e6363fadd881efb638013e980e4edb68c1313f3744e781ce38730e7777f0cba70ea97440318d93a77059d4a2b -901faf777867995aac092f23c99c61f97eeadf4ac6bcb7791c67fa3c495947baef494b2aace77077c966c5d427abbf92 -a123281aca1c4f98f56cff7ff2ae36862449f234d1723b2f54ebfccd2740d83bd768f9f4008b4771e56c302d7bfc764f -8cffe1266468cad1075652d0765ff9b89f19b3d385e29b40f5395b5a3ad4b157eed62e94279ac3ec5090a6bad089d8b3 -8d39870719bc4ebbcecba2c54322111b949a6ed22bda28a6cea4b150272e98c9ded48cc58fc5c6e3a6002327856726ec -b3d482c00301f6e7667aaeaf261150b322164a5a19a2fa3d7e7c7bf77dc12fa74f5b5685228ab8bf0daf4b87d9092447 -801acb8e2204afb513187936d30eb7cab61f3fbb87bfd4cd69d7f3b3ddba8e232b93050616c5a2e6daa0e64cef6d106f -ac11e18adda82d2a65e1363eb21bda612414b20202ecc0e2e80cc95679a9efa73029034b38fd8745ce7f85172a9ab639 -b631d6990d0f975a3394f800f3df1174a850b60111567784f1c4d5bba709739d8af934acfa4efc784b8fc151e3e4e423 -aeda6279b136b043415479a18b3bbff83f50e4207b113e30a9ccfd16bd1756065fc3b97553a97998a66013c6ac28f3d8 -8840b305dc893f1cb7ad9dd288f40774ec29ea7545477573a6f1b23eaee11b20304939797fd4bcab8703567929ce93ad -963cc84505a28571b705166592bffa4ea5c4eeafe86be90b3e4ae7b699aaaca968a151fe3d1e89709fe0a3f0edf5d61a -8e1ec0d0e51f89afea325051fc2fa69ab77d6c7363cc762e470a9dfa28d4827de5e50f0b474c407b8c8713bad85c4acd -909f313420403cb36c11d392cf929a4c20514aa2cb2d9c80565f79029121efd5410ef74e51faba4e9ba6d06fcf9f1bd1 -b2992b45da467e9c327ac4d8815467cf4d47518fc2094870d4355eb941534d102354fbda5ab7f53fbf9defa7e767ca13 -9563b50feb99df160946da0b435ac26f9c8b26f4470c88a62755cdf57faebeefffff41c7bdc6711511b1f33e025f6870 -a2a364d9536cd5537a4add24867deec61e38d3f5eb3490b649f61c72b20205a17545e61403d1fb0d3a6f382c75da1eb3 -89b6d7c56251304b57b1d1a4255cb588bd7a851e33bf9070ee0b1d841d5c35870f359bc0fdc0c69afe4e0a99f3b16ec2 -a8ae1ee0484fe46b13a627741ddcdae6a71c863b78aafe3852b49775a0e44732eaf54d81715b1dca06bb0f51a604b7e2 -b814ecbfbc9645c46fc3d81c7917268e86314162d270aed649171db8c8603f2bd01370f181f77dbcbcc5caf263bedc6c -8e5d7cc8aad908f3b4e96af00e108754915fecebdb54f0d78d03153d63267b67682e72cd9b427839dca94902d2f3cda7 -8fc5ff6d61dd5b1de8c94053aef5861009cb6781efcca5050172ef9502e727d648838f43df567f2e777b7d3a47c235dd -8788eea19d09e42b0e3e35eb9bcd14f643751c80c6e69a6ff3a9f1711e8031bbe82ccd854a74a5cfcf25dda663a49a62 -95d441d8cd715596343182ddcecb8566d47eaa2d957d8aea1313bbed9d643a52b954443deb90a8037a7fa51c88eec942 -a15efd36ef72783ccdc6336ef22a68cc46b1ecec0f660cfe8a055952a974342bf30f08cb808214bce69e516ff94c14c5 -acc084d36907a16de09a5299f183391e597beaf9fa27d905f74dc227701a7678a0f5a5d1be83657de45c9270a287ec69 -b3fd385764356346061570beb760ccf3808619618fd7521eb0feadc55b8153ef4986ff0cbfcbd4153ad4ea566989d72a -91ec6b26725532e8edfda109daa7ce578235f33bd858238dfa2eb6f3cd214115b44cce262a0f2f46727a96b7311d32e1 -96b867ccddb73afe1049bda018c96cfe4083fff5bb499e6a4d9fd1a88a325144f9a08cb0aee310e1bb4f6a5793777e80 -ad10c18465910152676f1bc6a40986119607b5c272488e6422cfda2eb31da741af13a50f5de84037348014a869c8e686 -86ade2dbc4cceb52b84afe1c874d1e3644691284c189761febc4804b520adf60b25817e46f3f3c08d2ab227d00b93076 -998b949af82065c709fc8f63113a9fecdd1367fc84fc3b88857d92321ba795e630ce1396a39c2e056b5acd206ee011d8 -8dec440bbd17b47dfd04e566c2d1b46f9133023b982fdc5eaeae51404bc83a593f8d10c30b24e13aec709549137cae47 -89436ff47431b99f037cddaee08bb199be836587a7db6ed740317888638e5f4bebbb86b80549edff89678fc137dfb40a -a8e9960746769b3f76246c82cd722d46d66625e124d99a1f71a790c01cec842bcf6c23c19cc7011ec972cedf54dc8a4c -980979dafedfd75ff235b37e09e17361cfdda14a5ac3db0b90ed491abfd551916016b2254538da7f4b86ece3038b1b1c -8ec340ca7654720bb9d2f209985439ebbc3f9990ef27e7d7ae366e0c45b4ed973316943122119604ea9a87fc41ebd29f -ab24440a40ab238d8cd811edb3ef99948ae0f33bf3d257b22c445204016cce22b6f06a1ca979fa72a36c4ddedc2b3195 -a1bcd2473ac7cfebfa61c10e56cae5422c6b261a4a1be60b763fcbcdf2eae4ccf80695f09b062b6cf5654dfab0ee62a5 -9027a613ce7bd827110a3a0e63e83f652e9bc7f4ce8da26c38b28ee893fd0c38bdb20f63a33470a73cb77f776244ab4a -86911cc8aeb628197a22bf44d95a0b49afb8332c38857fba8e390c27c527b8b45335e22b0f2e0a3395c16ced3c1ed2e8 -8f0529a330a3e9967dce09357d774715fd305bd9e47b53b8b71a2a1303d390942a835aa02fb865a14cfed4f6f2f33fe6 -b71ec81a64c834e7e6ef75b7f321a308943b4bad55b92f4dbaf46658613cebf7e4b5b1bc7f1cdc5d50d1a2a0690e2766 -98d66aaed9fb92f4c7bb1b488ccbca5e570aa14433028867562a561d84f673ac72e971cbe2cb3cbbb0a702797dc45a7e -8380aa94d96c6b3efd178de39f92f12ca4edd49fe3fe098b2b7781e7f3e5f81ee71d196fb8e260d1d52f2e300e72e7bc -8c36296ff907893ac58cecadd957b29f5508ae75c6cc61b15ae147b789e38c0eace67963ae62eff556221b3d64a257a2 -97e17676cbc0f62a93555375e82422ee49bc7cf56ad6c3d69bb1989d1dc043f9f7113d0ed84616dde310441b795db843 -a952229615534c7e9a715409d68e33086cdaddf0aec51f4369c4017a94ec3d7113a045054d695fb9d7fd335527259012 -817b90958246f15cbd73a9679e10192ca7f5325b41af6388b666d8436706dea94eafffbc3b8d53057f67ad726dbcd528 -95776e378c8abd9223c55cd6a2608e42e851c827b6f71ad3d4dc255c400f9eccf4847c43155f2d56af0c881abef4acfa -8476c254f4b82858ecbe128ed7d4d69a6563fd9c5f7d4defc3c67e0bfa44e41cfd78b8e2a63b0773ce3076e01d3f6a7d -a64b0b189063d31bcae1d13931e92d5ab0cfc23bf40566ac34b5b8b711d0e7d941102e6beb140547512e1fe2d9342e6c -9678460acff1f6eae81a14d5c8049cdcd50779a8719b5c5861762a035b07f7fa1b1ada8b6173f9decf051fd5a55bebd8 -88398758ce86ed0388b13413a73062adb8a026d6b044cd1e7f52142758bed397befee46f161f8a99900ae6a2b8f6b89f -a7dfaf40637c81d8b28358b6135bd7ad9cc59177bd9bc8e42ba54d687d974cdf56be0457638c46b6a18ceaa02d3c53f3 -b0e885e5d48aa8d7af498c5e00b7862ed4be1dad52002f2135d98e8f2e89ca0b36cf95b3218aad71d5b4ada403b7045b -803b0e69a89e8de138123f8da76f6c3e433402d80d2baba98cde3b775a8eda4168530a49345962c4b25a57257ba9f0a7 -8ce6ef80dadb4b1790167fbc48be10ef24248536834ff2b74887b1716c75cb5480c30aa8439c20474477f1ac69734e61 -824764396e2b1e8dcc9f83827a665ef493faec007276f118b5a1f32526340b117c0df12bea630030a131bf389ec78fc3 -874edb379ce4cc8247d071ef86e6efbd8890ba6fcb41ea7427942c140347ebf93e8cf369d1c91bd5f486eb69b45bce70 -adadcb6eb4cafa1e2a9aef3efb5b09ffa2a5cf3ce21f886d96a136336be680dabc0a7c96ec327d172072f66d6dcdbb39 -b993591b280e1f3527f083d238a8f7cf516d3cf00c3690d384881911c1495192a419b8e37872a565ce8007eb04ebe1b6 -b125faaeca3f0b9af7cb51bb30a7c446adbb9a993b11600c8b533bff43c1278de5cdda8cb46a4df46f2e42adb995bce8 -a7efe1b57326b57c2c01720d4fdf348d6a84d35f229d32a8f2eb5d2be4e561ef8aea4d4d0bcfcbf17da10a8e49835031 -a6bd4f5a87574b90a37b44f778d5c7117d78eb38f3d7874bad15ae141b60eed4ab0a7281ed747297f92e0b3fe5f9cafa -94b5e3067ca1db3c4e82daf6189d7d00246b0360cb863940840358daa36cb33857fde4c01acd0457a90e15accee7d764 -a5ff3ab12197b8a07dd80222a709271ab3b07beba453aacbaf225cfb055d729e5a17a20f0ff9e08febf307823cba4383 -a76dd8aa2b6a957ed82ecec49b72085394af22843272f19360a5b5f700910c6ec65bf2a832e1d70aa53fd6baa43c24f6 -8dfcbe4143ae63c6515f151e78e6690078a349a69bb1602b79f59dc51dea7d00d808cf3e9a88b3f390f29aaae6e69834 -8c6134b95946a1dd54126952e805aeb682bc634c17fe642d5d3d8deffffd7693c90c4cd7d112890abfd874aa26736a93 -933531875561d327c181a2e89aaaac0b53e7f506d59ef2dfc930c166446565bd3df03bab8f7d0da7c65624949cfbae2f -ac6937c5e2193395e5bb69fd45aa6a9ae76b336ea7b6fd3e6aeac124365edcba7e918ec2c663fb5142df2f3ad03411a6 -a8f0f968f2a61d61d2cf01625e6ac423b447d3e48378ea70d6ff38bc98c42e222fe3cbcb04662b19973a160dc9f868a2 -94100a36f63d5c3a6cfb903c25a228389921684cc84f123390f38f90859f37ec9714942ffe6766f9b615101a3c009e43 -b5321b07f5b1eb2c1c20b0c8ab407f72f9705b55a761ec5176c5bcc6e585a01cae78546c54117ca3428b2b63793f2e65 -9922f61ed6763d1c4d12485c142b8ff02119066b5011c43e78da1ee51f10a1cf514329874061e67b55597ca01a7b92ab -a212eb2d72af0c45c9ef547d7c34ac5c4f81a4f5ec41459c4abd83d06ec6b09fdab52f801a2209b79612ae797fa4507b -8577d2d8f17c7d90a90bab477a432602d6918ca3d2af082fbb9e83644b93e21ca0bced7f90f6e9279eaa590f4e41dc4d -9002d424e3bebd908b95c5e6a47180b7e1d83e507bfb81d6ad7903aa106df4808c55f10aa34d1dccad3fab4d3f7a453e -b9050299bf9163f6ebeff57c748cb86f587aea153c2e06e334b709a7c48c4cbfba427babf6188786a0387b0c4f50b5ce -852ae1195cc657c4d4690d4b9a5dea8e0baaa59c8de363ba5fccd9e39ec50c6aa8d2087c8b7589b19248c84608f5d0a8 -a02ff5781417ca0c476d82cf55b35615f9995dc7a482124bc486e29b0b06a215fbe3e79228c04547c143d32cd3bac645 -8d7bc95e34bc914642e514a401448b23cf58bce767bab1277697327eb47c4a99214a78b04c92d2e3f99a654308b96e34 -adb28445d3b1cc7d4e4dd1f8b992a668f6b6f777810465fdab231fd42f06b5bada290ba9ae0472110366fad033da514e -a0c72b15a609f56ff71da17b5b744d8701af24b99fbc24a88588213864f511bfa592775e9ab4d11959f4c8538dc015b8 -933205a40379d5f5a7fb62cda17873fbbd99a0aaa8773ddf4cd2707966d8f3b93a107ebfe98b2bb222fe0de33ef68d03 -90690c1a4635e2e165773249477fc07bf48b1fd4d27c1b41a8f83a898c8d3763efb289867f8d6b0d354d7f4c3f5c7320 -99858d8c4f1be5a462e17a349b60991cb8ce9990895d6e42ae762ce144abc65b5a6f6e14df6592a4a07a680e0f103b2a -b354a7da06bd93fb5269e44925295b7c5049467b5cacce68cbb3cab60135b15e2010037a889cb927e6065053af9ccb77 -af01fc4ac396d9b15a4bbd8cc4fe7b30c32a9f544d39e88cdcb9b20c1c3056f56d92583a9781ddb039ec2eeda31fb653 -a8d889fb7155f7900982cf2a65eb2121eb1cc8525bbee48fae70e5f6275c5b554e923d29ebbd9772b62109ff48fb7c99 -b80edae6e26364c28749fd17c7c10eb96787053c7744a5cc6c44082ae96c5d3a4008c899a284f2747d25b72ecb9cb3d0 -b495b37503d77e7aafc226fca575e974b7bb6af2b7488372b32055feecc465a9f2909729e6114b52a69d8726e08739cb -a877f18b1144ff22e10a4879539968a01321cecde898894cbe0c34348b5e6faa85e1597105c49653faed631b1e913ec7 -8c235c558a065f64e06b4bb4f876fe549aab73302a25d8c06a60df9fad05843915ac91b507febca6fe78c69b51b597de -b4c31398b854ccc3847065e79329a3fdae960f200c1cce020234778d9c519a244ff1988c1fbc12eb3da2540a5fa33327 -b7bd134b3460cb05abf5aed0bc3f9d0ccbfac4647324bedbdf5011da18d8b85dc4178dd128f6ddbe9d56ea58f59d0b5d -92594c786c810cf3b5d24c433c8a947f9277fe6c669e51ceb359f0ae8a2c4e513a6dad1ae71b7ded3cdca823a51e849b -b178535e043f1efcce10fbec720c05458e459fdda727753e0e412ef0114db957dc9793e58ec2c031008e8fb994145d59 -b31da7189abf3e66042053f0261c248d4da142861bfd76a9aced19559be5284523d3e309ef69843772b05e03741a13fe -b190a8c1a477e4187fecff2a93033e77e02de20aae93dda1e154598814b78fdf8b9ff574c5f63047d97e736e69621462 -98234bd1d079c52f404bf5e7f68b349a948ec1f770c999c3c98888a55d370982bfa976e7e32848a1ebb4c7694acc1740 -99b9eeb33a6fb104bba5571a3822ebe612bf4b07d720d46bde17f0db0b8e8b52165f9b569be9356a302614e43df3e087 -a1e3915b0dd90625b424303860d78e243dda73eecd01cba7c33100b30471d0a1ec378c29da0f5a297008b115be366160 -975118bf6ca718671335a427b6f2946ee7ece2d09ccfb1df08aa1e98ff8863b6c8b174c608b6b2f4b1176fb3cbc1e30d -903cb1e469694b99360a5850e2ca4201cad23cfccce15de9441e9065eb3e6e87f51cba774ab9015852abd51194c25e57 -821f7ff4d0b133e3be4e91d7ff241fa46c649ff61fc25a9fdcf23d685fe74cf6fade5729763f206876764a3d1a8e9b24 -a1ee8db859439c17e737b4b789023d8b3ce15f3294ec39684f019e1ea94b234ec8a5402bc6e910c2ed1cd22ff3add4de -af27383148757bdf6631c0ea8a5c382f65fc6ab09f3d342a808ca7e18401e437cd1df3b4383190fdf437a3b35cbcc069 -8310551d240750cef8232cd935869bad092b81add09e2e638e41aa8a50042ce25742120b25fb54ebece0b9f9bdb3f255 -8b1954e0761a6397e8da47dc07133434ebe2f32c1c80cd1f7f941f9965acdf3d0c0b1eb57f7ff45a55697d8b804e1d03 -8c11612381c6be93df17851d9f516395a14a13c7816c8556d9510472b858184bf3cc5b9d14ded8d72e8fb4729f0b23ba -b413ac49121c7e8731e536b59d5f40d73a200c4e8300f8b9f2b01df95a3dc5fe85404027fc79b0e52946e8679b3a8e43 -8451e5c1c83df9b590ec53d1f1717d44229ed0f0b6e7011d01ea355d8b351f572866b88032030af372bd9104124df55a -8d0a5c848ec43299bc3ea106847ed418876bc3cd09b2280c2a9b798c469661505ed147a8f4ffba33af0e1167fdb17508 -a6aa97a1f10709582471000b54ec046925a6ad72f2b37c4435621c9f48026d3e332b8e205b6518f11b90b476405960a9 -97696635b5a2a6c51de823eea97d529f6c94846abb0bd4c322b108825589eba9af97762484efaac04ee4847fb2fb7439 -92fd142181fe6ca8d648736866fed8bc3a158af2a305084442155ba8ce85fa1dfb31af7610c1c52a1d38686ac1306b70 -ae3da824ecc863b5229a1a683145be51dd5b81c042b3910a5409ca5009ba63330e4983020271aa4a1304b63b2a2df69e -aecc0fe31432c577c3592110c2f4058c7681c1d15cd8ed8ffb137da4de53188a5f34ca3593160936119bdcf3502bff7c -821eac5545e7f345a865a65e54807e66de3b114a31ddeb716f38fe76fdd9d117bee0d870dd37f34b91d4c070a60d81f4 -91a02abb7923f37d9d8aa9e22ded576c558188c5f6093c891c04d98ab9886893f82b25b962e9b87f3bf93d2c37a53cb9 -99a96f5d6c612ee68e840d5f052bf6a90fecfd61891d8a973e64be2e2bdd5de555b1d8bffbd2d3c66621f6e8a5072106 -b1d5ec8f833d8fbb0e320ff03141868d4a8fff09d6a401c22dbefadbb64323e6d65932879291090daf25658844c91f2e -a06afd66ebc68af507c7cf5ab514947ca7d6ccc89fb2e2e8cb6e5ae0f471473e5fba40bb84d05f2c0f97c87f9a50cb73 -83de3ca182bcf1eac0cc1db6ad9b1c2a1ecd5e394e78add7faa36e039a1b13cb0d1d2639892489df080fbf43e5cef8d5 -adf77fc7b342ff67a2eddaa4be2f04b4e6ceaca8ea89a9fc45cc892fcce8ac3cf8646cfa5aab10ac9d9706ce4c48a636 -8509a430ef8dc9a0abc30ef8f8ccdb349d66d40390fb39f0d3281f3f44acb034625361270162822ef0743d458a82b836 -8350fc09e8617826f708e8154a3280d8753e7dbbcf87e852f9b789fdbeb10bf3fed84fb76edd7b8239a920c449e2f4b7 -a2e7a29da8391a5b2d762bf86cb6ae855cdfad49821175f83f4713dd0c342a0784beba98d4948356985a44d9b8b9d0f7 -a99c50a1a88b8efe540e0f246439db73263648546d199ef0d5bc941524a07d7e02b3ef6e5b08dc9e316b0b4c6966823e -b34ba55136c341f4ca2927080a07476915b86aa820066230903f1f503afebd79f2acf52a0bc8589b148d3a9a4a99f536 -af637be5a3e71c172af1f2644d3674e022bc49c393df565ea5b05ce6401a27718c38a9232049dd18cbd5bf4f2ce65b32 -a2972ba7bfa7f40c2e175bb35048a8ef9bc296d5e5a6c4ca7ab3728f4264d64f2d81d29dce518dc86849485ff9703d7d -8c9db203e8726299adeb331d6f4c235dc3873a8022138d35796fb7098887e95e06dcfad5d766ceaa2c4fb0f8857f37fa -a82bfbaa9a6379442109e89aad0c0cfc6a27d4a5db5480741a509d549c229cb847b46a974dde9f1398c6b3010530f612 -b2d8ef6e091a76dfc04ab85a24dbe8b5a611c85f0ed529a752c2e4c04500de5b305c539d807184e05f120be2c4a05fc3 -8c6ffc66a87d38cea485d16ee6c63ce79c56b64ae413b7593f99cc9c6d3cd78ef3fa2ab8a7943d2f0e182176642adadb -acbc92de68b2b04e3dc128109511a1cbe07518042f365d5634e8b651cb1ac435ea48eeeb2b921876239183096ef6edee -979c4e1165e0ecfa17ed59fb33f70797e000ddbb64acf5fc478cccde940451df051e51b6449c5b11a36afa7868af82e3 -a5a017c5a94952aeae473976027124231abe50460cec4db3ebeb8b1290525776be7c15d108b749c2a1e4b018de827915 -8b6922ab1db925eed24b2586e95f5c709b79d2408a8fa2a71057045ead3ebdd0cc72bee23d9064cd824166eda1e29318 -89a991087a0b5805fcc5c6c5f6ac27e100da0d3713645aa9c90114e68ca9f185f21155eb7645a2c6c0616a47291fe129 -ae6ef954c942cbfd37f8f2dc58a649e2584d6777e7eb09ae6992ccde283ac4f4ec39e3a5cda7f7c60f467fb308d37f08 -9335ca5ccac59b39eb2bcef09c54b778ebb690415ba13fe5c8e4b6091d9343a01cc9baa6228cefd8dba98f0710f714da -a0211c9328be2b46f90ff13614eeffb4c1285e55580db3874610653219926af1d83bda5b089fd37a7c7440a0f1d94984 -a82e097dfa782c40808fac5d8ed1c4fccf6b95ef92e22276fd8d285303fcf18c46d8f752595a658ee5294088b9dc6fc0 -ad108fcd0ead65f7f839a1337d520f5bd0cb665ee7100fc3f0563ff1d2959eb01617de8eb7a67c9b98b7b4892082acdb -b89e6aeabcb3ee3cbf12e3c836bab29e59d49676bcf17a922f861d63141076833f4149fe9e9c3beed24edfacdf1e248b -8477501bd91211e3b1f66c3bfd399ef785271511bc9366366ce95ec5ea95d9288ab0928a6b7887aba62de4da754d3eaf -aeec40c04b279096946b743ad8171bf27988405e1321c04894d9a34e2cbd71f444ff0d14da6cda47e93aa6fe9c780d50 -a703bd2d8a5c3521a8aad92afef5162aed64e9e6343d5b0096ca87b5b5d05e28ed31ba235ab1a626943533a57872dd01 -b52d9dfc12c359efb548d7e2b36ddedaefdec0ef78eda8ac49a990b3eb0ed7668690a98d4d3c7bec4748a43df73f0271 -af887c008bad761ee267b9c1600054c9f17f9fc71acfe0d26d3b9b55536bca5c8aebe403a80aa66a1e3748bb150b20ef -ad2f7a545ef2c2a2978f25cf2402813665c156bab52c9e436d962e54913c85d815f0ba1ce57f61e944f84d9835ce05ea -91a0a9b3cfd05baf9b7df8e1fb42577ec873f8a46bb69a777a6ac9f702735d6e75e66c9257822c781c47b9f78993a46b -939fdc380fb527f9a1ddecf9c9460f37e406cd06c59ce988e361404acbfcb6379f2664a078531705dbc0c375d724137b -8bbbe5d5a0d102b8e0c8a62e7542e13c8c8a6acb88859e78d8e1d01ec0ddff71d429fcb98099e09ff0aa673c8b399dc4 -b67a70e4ef138f48258f7d905af753c962c3cc21b7b8ae8b311a2356c4753f8cd42fdee09ac5ed6de31296ead88c351a -8d21539e7dca02a271ce7d16431773bbe30e6a03f5aff517132d34cdd215ad0da2f06aa4a2a595be489234b233e0852e -892ae11513f572cc5dc8b734b716bb38c0876e50e5e942631bb380b754e9114c34b0606740301e29b27d88439fb32071 -a8780dc9faa485f51b6f93a986bc4e15b166986b13d22ec2fefc6b25403b8b81c15cc9ac0025acc09d84932b15afa09b -b01af013360cd9f2bb9789a2b909c5e010fe6ff179f15997dee1a2ba9ef1ccec19545afdecfcb476f92fcdd482bb2b5a -b5202e5d5053d3af21375d50ad1ccd92538ef9916d17c60eb55c164767c3c74681886297b6f52e258c98d0304d195d3d -8f6adbcfbb0734bf3a4609d75cf2e10f74ed855a8b07cf04ac89a73d23b2e3e5cf270a1f2547b3d73e9da033a3c514b0 -8abe529cd31e4cb2bd75fa2a5e45bd92cbe3b281e90ffc7dea01ba0df17c9a3df97a3fde373cce5d25b5814cf1128fed -b8bbf51187bb3bb124da3870e2dfecb326f25a9383e5cc3323813487457010b9055811669c3da87105050825dc98a743 -a5c83875fe61ebbdd3fd478540d7e5a1ad0f8c790bad0b7dd3a44831e2c376c4fffbc6b988667afa1b67bfaa2dbbb256 -a0606b3062e4beba9031ba2a8e6e90aa5a43ba7321003976e721fd4eedb56486f2c5b10ba7a7f5383272f4022092eacb -b485cc5e001de6bd1bbc9cd8d777098e426d88275aaa659232f317352e1ddff3478262d06b46a573c45409bc461883e1 -916449580b64a9d8510e2f8c7aee0b467a0e93b11edc3d50725bcbc3ca53c2b8bb231fdc0fc0ed5270bf2df3f64750d9 -b2e687caa9f148c2b20a27a91bada01a88bff47faaf6ed87815db26bb6cdd93672199661654763a6b8b4b2012f59dcca -b6933f7f9dabc8fb69197571366ac61295160d25881adf2fcc8aaabc9c5ed7cf229a493fd9e2f1c2f84facd1f55fee84 -b01eb8b2cf88c75c3e31807cfc7a4d5cafded88b1974ba0a9d5aaeda95a788030898239e12843eda02873b0cabe30e2b -a3ca290fa6ce064514a3431b44ecdb390ef500629270202041f23bc2f74038147f338189c497949fb3126bae3a6e3524 -93b0f8d02bd08af74918b1c22131865aa82aba9429dc47f6b51354ba72e33a8b56684b335a44661aa87774931eb85974 -81eebeb9bd92546c37c98e0a5deba012c159f69331a89615cf40c5b95c73dcdbf3ceb46b8620d94ff44fcdad88020c1e -b350e497932382c453a27bb33d2a9e0dbadf4cd8a858b6b72d1f3a0921afc571371e22b051b97da3bb08694c4ca3a4e8 -8c7052f63ba16f14fa85d885aa857d52f04b3a899a4108493799c90c0410de7549be85bec1f539f1608924668df48e5a -b397574d1fb43de0faaea67d1d9348d67b712b1adce300d6dc497bca94e0994eef8707c285c5c9ac0a66022655a8420b -a934661d2168ae1bd95b1143c2e5c19261708aeb795abad8ec87f23dc1b352fa436de997ebb4903d97cb875adb40dc2b -acf535fa1b77255210e1b8975e0e195624c9e9ffd150286ccd531a276cadc12047a4ded6362977891e145a2bd765e6b9 -8cc32356015d7fd29738dcc13c8008cdbe487755dd87d449ab569c85d0556a1ec520dbce6c3698fc413d470c93cb0c92 -8787c7b3b890e0d3734ac1c196588cacf0a3bde65e2cf42e961e23dbf784eef14c07337d3300ed430f518b03037bd558 -99da90994030cbc2fb8a057350765acac66129a62514bbd3f4ec29d5aab8acdd5f4d69ca83efe7f62b96b36116181e79 -a306424f71e8b58dfa0a0564b2b249f0d02c795c30eee5b0ad276db60423210bba33380fb45dbe2c7fedd6ee83794819 -b207a35d31ce966282348792d53d354bbd29ac1f496f16f3d916e9adbf321dc8a14112ca44965eb67370a42f64ca1850 -89e62e208147a7f57e72290eefccb9d681baa505d615ca33325dfa7b91919214646ca9bdc7749d89c9a2ce78c1b55936 -ac2d0ec2b26552335c6c30f56925baa7f68886a0917e41cfbc6358a7c82c1cb1b536246f59638fb2de84b9e66d2e57eb -8f1487659ecc3b383cebc23a1dc417e5e1808e5c8ae77c7c9d86d5ab705e8041ce5a906a700d1e06921f899f9f0ee615 -a58f1d414f662f4b78b86cae7b0e85dfddae33c15431af47352b6e7168a96c1d307d8b93f9888871fc859f3ed61c6efc -94f3626a225ac8e38a592b9c894e3b9168f9cf7116d5e43e570368ee6ee4ab76e725a59029006a9b12d5c19ddce8f811 -b5986e2601ad9b3260e691c34f78e1a015c3286fdd55101dcef7921f6cbcc910c79025d5b2b336d2b2f6fd86ee4e041e -b6e6798ddd0255fbe5cb04a551a32d4c5d21bdfd8444ff2c879afe722af8878d0a3a2fe92d63936f1f63fea2d213febf -86bea9bfffef8bc11758f93928c9fdfae916703b110c61fa7d8fe65653f8c62c6fecd4ff66a1f1a7f3c5e349492e334c -9595a4606284569f4b41d88111320840159fd3b446e00ec8afd7ddaa53dd5268db523f011074a092f8e931fc301a8081 -83b540a6bc119bf604a7db5f6c0665c33b41c365c12c72ca4fa7b0724115bbb0ff1ae38532c3356e8bb3ac551285929f -92c6daf961ca4eb25293e1794cf85cda4333cf1c128207af8a434e7e0b45d365f0f5baaefc4ebd5cd9720c245139c6e2 -b71465f3d7dba67990afc321384a8bb17f6d59243098dbed5abd9a6ffc7a3133b301dd0c6ca3843abbaa51d0953abbed -b15d93482d2ee5b1fec7921fcc5e218c1f4a9105a554220a4fb1895c7b1d7a41f90bbf8463d195eecf919fcbe8738c51 -a79c98e70931ffd64f4dcf7157fbae601a358261e280fe607eb70cef7d87f03efa44cf6ba0f17fbb283a9c8a437d2fdb -9019d51a6873331f8fe04cb45e728a0c8724a93d904522a9915c748360ddf5cdbf426a47b24abf2005295ed2a676cbf0 -b34cc339fec9a903a0c92ce265e64626029497762ff4dcaaf9bb3994298400ce80f4fb7dbe9ec55fe0c4a522c495cb69 -8fda9be7abfe3b2033cad31661432300e2905aef45a6f9a884e97729224887a6ec13368075df88bd75c11d05247bef15 -9417d120e70d6d5ca4b9369cba255805b5083c84d62dc8afec1a716ead1f874c71a98ad102dac4224467178fe3228f62 -a0a06b64867eebb70d3ce8aaa62908a767fb55438a0af3edf9a8249cd115879cde9f7425778b66bb6778cb0afeb44512 -a44309d3e1624b62754a3a4de28b4421f1969870f005ac5dc7e15183fa5b3ad182bcd09cca44924e03fbdb22f92f8cf8 -aea80f1c3a8fc36cfb5c9357d59470915370b2bec05f51f1d0e1d4437657e2303ba2d1ac3f64cf88f2df412dff158160 -b3f1557883d91b24485123d2f3ae0fce65caa533c09345ae6b30d2ac49953acee61c880c57975be7b4f5558d3a081305 -b52cb1e56f0d147cfb58528b29c7a40bab7cfc9365f2409df7299bfc92614269ff9de3cb2500bbc4909f6a56cf4b9984 -aa4f8fd0f5f87c177ee7242f7da76d352db161846cd31523a2100c069d9e4464170eec0bffc6d4da4f9e87017b415dbd -b5b61f52242985c718461a34504f82495d73cbb4bc51f9554b7fe9799491f26826d773656225f52a1531cd5bd6103cde -ad12ba9697804ede96001181c048f95b24ba60761c93fb41f4b4a27e0f361e6b1434e9b61391bacaf0705fdaa4a3a90e -9319286cbda236f19192ae9eb8177e5a57a195c261082ba1385b20328fb83ed438f29d263dddae2f5278c09548830c4a -88b01ee88c3a7ae2c9f80317dddbaa2b7b0c3a3c23828f03ff196e244500410c9ac81c2e2d3e1f609d4b36ee1732738c -8e31f30600a9d629488d44a008c821c3c57f13734eaee5a19f0182a2de9e538fff7d982980d7fcc725c969f29f7c2572 -b215740eea98b4bb14197a803a8975700ad2f25a25ef3628eae10166d56c823301f6dd62ce3f9ebf2d42d1f33d535004 -8fb0fdb253d4bcc6693642779be13a5b816189532763dfd7da868cfacfdb87cb5ebe53b18b69dfd721f8d4baf3c1d22d -8cdd050a447f431ff792156d10381aaf83c6634a94b614dd5b428274538a9cc1f830073533b4fd0a734d6dd4f8d9c4ce -81b01ee8c72ac668ad9dd19ead2d69cac28c3525e613e036e87aa455c2da9651cc8fcc97c451a8c8a071a4eb69623cd1 -8d9e02dc9ac83f861b3745bd69216232144c47cb468a7dbc49083ed961f978e34265b3f42c400339120bdc4644fe5711 -89e9410455b34cba9db0a5ea738e150fae54dd000d61e614f3274a6c8102ba7cd05b0936f484a85711ad9da7946f51ea -91f9d4949678f8e6f4b8499899818bdd0f510da552b5d79d8e09bf3b69d706ab36524b5e86d3251318899b9223debf6b -8b3c38eec7e1926a4be5e6863038c2d38ab41057bcfa20f2b494e9a0c13bc74c3a44c653402eb62a98e934928d0ebccb -a5cfe465bfbf6e8bfbd19d5e2da2fc434bd71acd651371087450c041aa55e3c4f822361e113c6c3d58646ed3ba89d6da -918665b8810bcb8d573ca88b02a02c62eaa5a4a689efb5c564b0c9183f78144e75d91fd1603e17d2c77586cbe5932954 -997dace0b739aeb52ba786faae5bdf1d48630a90321f9ceebfa9e86d189a3d79d7b04e459ac8e4adcfe83a5ce964eb1c -a5a1ca9f0ccc88017a616d481d912aab3f0e154b673f1131c5d9c9c3f5f147d25b6392b2c31e49f7bb7eb2697d05dbec -a76e99bec509eff01bf6767a06ac97ebc6671cb58bc3d4acc2803580a874885453dbba2e1bba26e45f8d2bda5f688860 -956c1362c8123c5d9ebff7049e851235d69fa645f211ef98e2b6564f2871114a12224e0ec676738d77d23c709dd28a6c -885efede83b1a3e96417e9f2858ab0c7a576fc420e8f1f26cabf3b1abeec36bcaa63e535da177847f5e0afdb211bf347 -affca2257f292a2db52f8b1bab350093f16f27ef17e724728eeaec324e2513cd576f6d2e003cc1c6e881334cb2e8bf22 -8dac963d34dcc9d479207a586715e938c232612107bb2d0af534d8da57ad678555d7c1887fadca6551c4f736ffa61739 -b55e600a6bbde81f5a0384f17679d3facb93a7c62ca50c81a1d520cf6e8008ac0160e9763cb2ca6f2e65d93ca458783b -9485e6c5ab2ebfb51498017e3823547b6ab297d818521ceac85cd6c3aa2d85ae075a0a264ae748fc76ce96a601462ffa -b4d8abca786c0db304a6634fba9b2a40d055c737ed0f933e1739354befdae138dae3c8620a44138f50ebeaf13b91929f -8bde7ca39c7bda95b1677a206b16c3a752db76869ea23c4b445c2ff320f2ee01f7358d67a514982ee3d1fb92b7bd7229 -8f8cd0acc689b6403ee401383e36cae5db2ff36fc2311bbadf8ebb6c31cbcc2ca4ffac4c049da5ba387761ef5ec93b02 -a06f42d5f69a566ff959139c707355bbf7aa033c08d853dce43f74a9933e6d7b90e72010ef3fcb3d12e25852343d1d31 -b10ece7cf6b69a76dba453b41049db0cdf13d116cf09c625312b150ee7437abd71d921eda872403d7d7ce7af1e6dccb7 -a3d820318e0f3b54fba7a4567912a82d6e6adf22b67cfc39784683a8e75f77538e793d9708aae228fa48a71abb596195 -8758fad55b68a260bea3bd113e078fd58d64a92f7935ff877f9f77d8adc0994b27040cfc850126c7777cfdfb2428a3e5 -b504913ee96c10f00b848cd417c555a24bc549bf5c7306140eff0af2ada8cb5e76bed1adb188e494332b210fbf24e781 -a00e019a40acc7aab84c1cc27c69920ad7205c2a3dc9e908a7ef59383695c9cb7093c4bcbc2945aab2655119552e3810 -b1000b4c4f306672e39d634e5e2026886a99930d81b8670a5d4046db9621e44997c4b78f583374a09c60995f18a6fd4f -a6c5053c4e748540ad2b622c28896c9d4ca3978ca4784ac8f09da5314a245f5cdc5d6203c84e6e0bcb3081829720a56d -8e37e67a70205a5c7da95de94ac4d0ebd287c1c9922d60c18eec1705030dfcbf74ae179e377c008bf5a8bc29c7c07cce -a66bd7c0243319b553d5cb7013f17e3504216e8b51ba4f0947b008c53bcb6b4979286b614a4a828ee40d58b5ef83e527 -97e2110b0fb485508a2d82ecc2ce1fbe9e12e188f06c7ef2ac81caeeb3aca2c00e5e6c031243b5ca870a9692e1c4e69b -8734ce8bbc862e12bea5f18d8a8d941d7b16a56ef714792fed912ca9c087497e69b6481fdf14efe1f9d1af0a77dac9b1 -b441dddac94a6a6ae967e0e8d7ab9a52eb9525fb7039e42665e33d697e9a39c7dcef19c28932fb3736e5651d56944756 -918b8997f2d99a3a6150d738daed2ff9eb1f5ed4a1c432d18eab4a898297f7ffbffd1e4ae9037acf589b1cd9e1185ef6 -a0247b8ac4d708cf6b398dc2d5c127a291d98e8bef5f195f820c4fddb490574ba4f62647c2d725237a3e4856eec73af0 -b45636e7e0a823c2a32e8529bb06fcccfd88e9964f61201ee116279223ed77458811d1b23bcb6b70508d16d4570a7afb -a99c1188fa22b30b04fda180d2733586ea6ef414618f1f766d240c71f66b453900d3645541c019361027aebe0a0f305f -b4c2f758e27fe233f7e590e8e0c6de88441164da3fcd5211a228318d3066dfdafc1d40246dd194f2b597f6fe9600b3d7 -972530819445b11374c3043d7855d5f1d3c4922b3b205d0bf40162c51605375dd0b61f49cd7f3d39a533a86a13005989 -992b533a13e5d790259bfdfdf1074f84a5e5a0a0d7be9cd6568cdc1662524f1a6666a46da36cea3792ba6707850f4d86 -9875d130457e04dc6ea2607309bfbb900ad3cb5f3e0574f808d27b20cbf6f88389d87dca19998680c5bc30d1df30a41b -adea8494a69e83221edf360ab847272b5c47eba5404665fb743d98c0682732c30085ae3ec82bc1e8e4aba8454c9b1849 -887d4c624ce05e224216c5f6fa13c5741012ac33330bc291754782f0bfe668decdc98c0e43a1ce28323effe6b639f477 -ab6b167aeb5e93ab155990b94895e7e7ff6dea91384854a42cc8a3b9983495b4b3c33ab1b60b2b6450ccf0418fada158 -a7588d0b7c6a6bc32fc474aa0f4e51dfb8e6e010346ad32c59d6f99e6f0522424111a03a4f56ba4075da8009ee7a63e9 -94d645cc3936db1563568193639badfc064dd5bda8d0631804ee00b09e141b200619e07506b5a8225130541436327194 -8d695c03cc51530bdc01ee8afcd424e1460d2c009e1d7765c335368e5c563cf01a2373c32a36400c10e2bf23c185ed19 -ad824a0a7ed5528e1f9992cbb2050785e092b1ea73edd7fb92b174849794a5b04059e276f2941e945bc0f3e46172f2af -ad6ed2af077a495d84f8eeed7d340b75c0d1c8b7c5a854dfc63ab40a3d0c2b0d45016d30b3373a13f0caae549f657976 -82454126c666023c5028599a24be76d8776d49951dfe403ebf9a5739b8eb2480c6934a34010d32cd384c91c62a9aa251 -b57070006793eca9fa2f5237453ed853994ad22c21deb9b835e1fb3fbc5ac73aec265a4a08de7afae1610dc8c42b7745 -ad94667c791cf58875eb77eb17b6ad02de44e4ba2ddc2efe4d0ff22a5e1a090c670354437847349fd61edc4ba5606f07 -b2aac0c345ffc00badaab331c12a22019617b004d32c099c78fa406d683744d96d51d1237ad0842f9f54655186f8f95b -8fed51076cc939b354e3b69034a594e6c9c98425ccf546154ab087a195375128444732388d2eb28f82877de971ec2f58 -8e521c0093deb9dff37888893db8ffebc139984e7701e68b94d053c544c1be0d85f0f98d84b2657933647b17e10a474c -a2c6c9a307aff9b1dea85f90fa9e3b8057fd854835055edeb73842a7ef7c5ae63d97c51fec19dd8f15d696a18a0424a6 -a3390b25a9c11344ed1e8a0de44c848313026067a0f289481673c2c0e7883a8fc9f6cab6ccd9129729a6d8d0a2498dc2 -82770c42b1c67bbd8698c7fe84dd38cc5f2ad69a898097a33b5d7c5638928eb1520df2cb29853d1fa86a0f1bcc1187e8 -a6fdf7a4af67bc4708b1d589135df81607332a410741f6e1cc87b92362a4d7a1a791b191e145be915aa2d8531ee7a150 -aecac69574188afc5b6394f48ba39607fe5bb2aa1bd606bc0848128a3630d7d27101eb2cea1fb3e6f9380353a1bb2acc -a23fd0c52c95d0dffb7c17ec45b79bf48ed3f760a3a035626f00b6fe151af2e8b83561d0b9f042eaae99fde4cbd0788d -a5f98068525cdd9b9af60e0353beb3ac5ac61e6d3bac1322e55c94b3d29909d414f7f3a3f897d5ae61f86226219215c6 -b2a4d724faac0adf0637c303ff493a1d269b2cdbec5f514c027d2d81af0d740de04fb40c07344e224908f81f5e303c61 -adeadb3521e1f32ef7def50512854b5d99552e540ec0a58ea8e601008de377538c44e593e99060af76f6126d40477641 -a18b7fc2fcd78404fed664272e0fef08766a3e2bc2a46301451df158bd6c1c8aa8cf674dd4d5b3dedfaceb9dd8a68ae3 -83bcfb49313d6db08b58c6827486224115ceef01ca96c620e105f06954298e301399cdd657a5ff6df0b0c696feec1a08 -8c94391eba496e53428ec76dfe5fa38f773c55c0f34a567823316522a0664a3d92bff38ec21cf62ac061d7d1030650c5 -b1fa196ccfd7d5f1535b2e1c002b5cde01165c444757c606b9848bc5f11b7960973038fb7cc3da24300fc1848e34c9af -b139f6c6449449638de220c9d294e53fc09865a171756d63bbf28ec7916bf554f587c24bddf51dd44372d15260d8fe25 -b716242299d4ee72b5b218781b38ca5e005dcf52333364f85130615d1dbf56216af8ee2c9c652d82f7aab5345356538c -9909f24e4ad561aa31afd3a3b9456b2bd13a1d2e21e809a66af62fec5f95b504507ac50e81d2233da2b223f5443e7585 -ae863530a02cf3a757f72b945c8c0725d9f634d2ff26233478d1883595ff9a1eef69e8babffdbfa161452fc204f5b5a1 -8eb82bde283b6a6e692b30236cbf41433b03eda8dad121282772edd56f144b1ebf5fb489d18c6ce8776135771cbb91e2 -9296141fadf8dadc885fff4999c36efa25ec76c5637a8300a1a7dc9cf55bcedfe159e0ef33f90eee9be8c4f085734e10 -b6c07f2e6fcbd6c42a8b51e52fbcd5df3aa9f7c3f0b3c31021de1aec2111d0a1c36b5ab489ba126af44fd43cf31c2594 -a70ca669c357535b363d16b240fd9cb9c5ba1b648510afc21218ea034e9bf5f22717ae31ff43ef89dded95b7132fa58f -b350721f8f6b4d164fd08aca30cd4dece9b4a81aed0ac12119c9399bab691d5945814306f9a61f0106b76d4d96f7b9d6 -b6886076c9d8c344bf3fb6975173d00fa82866012894f31c17e6fc784fbc0dd2d24d6a1cddd17f7379c74566a23219aa -87636e4a83ceadc170a4b2517b19525c98e2163900401996b7a995b2f3da8d6ba2ab92f909eade65074fac07cf42f6fa -8ff61d87c4699a067a54b8540e8642f4c7be09d3783ec18318bcba903c6714fcd61be69165e07e1ca561fe98e07507de -85485d6b569ac20e6b81a9e97ef724e038f4fee482f0c294c755c7b6dad91293814f143bfcfc157f6cfa50b77b677f37 -a49256cb1970cc1011a7aed489128f9b6981f228c68d53b1214d28fbcfb921386cc7cf5059027e667a18073efa525a74 -87bc710444b0c3e6682d19307bedc99c22952af76e2d851465ee4f60e5e1146a69f9e0f0314f38a18342e04ece8e3ed3 -a671a6cabfd19121a421fdfe7732eccbb5105dfb68e8cbcf2b44ae8465c99e78c31b99730beca5bc47db6fc2f167203a -a2f3270c184629f6dfc5bf4bdd6e1b8a41e8840a1e4b152253c35c3d9e7ab4b8e3516dc999c31f567e246243e4a92141 -b9795a5a44f3f68a2460be69ecacdbb4664991ebbedffed5c95952147ad739e2874c099029412b9653d980a2d4307462 -959053faec9a966dd5a4a767a3154e4b8e4f56ca540ae53e373c565dda99fb626f725e5a5e3721c82918f8c5f2e9e0a3 -b3ef9d6a1b3cd44a3e5112819fa91cb8a7becc3f5b164c6f759f93171d568497b01c8e743f4727b341a1296a0dbadf4f -b852dfdfbe2b8c77d938fad45f00737e14eacf71d5fecbb3e4f60052ec9efb502c38c1fcecaf71da69eabe8b33852a67 -921c7007f26bdd4139e919dfe27d87b489a0bc5bd6fb341e949e4451f14c74add0489b108c9c9666a54c5455ac914a9f -86b63d73ba31c02e5337f4138e1684eccdc45ab5e4f30e952fb37d638b54ecec11010414d7a4b7aa91f7cc658f638845 -853c55e0720b66708a648933407795571fc11ad5c234e97f92faabce9e592983dfb97a1705047ee803648ecf9fbb2e5c -995fe7d1dc09bb0c3c3f9557c4146534778f5ea9c1d731c57440fdcf8094f82debf19090b5d23298da1ed71c283b3ae5 -b9c49c911a0c4d716b7baec130f9e615bfa7d504aa8766ed38878a93c22b1f6353503d4f7f425d4902239fb4689429df -80504d964246789a09dcd5c0298680afb6fe50bca3bb9c43d088f044df2424a1828de10e0dbdc5c0aac114fa6d9cf5d1 -90249351f109f6b23a49a610aaa3b2032189fd50e5e87cdc3b20f23ed4998af3a8b292bf9fbab9bd1cbe0a1371081878 -abb5f0148850f0d80b429c2b9e0038772432340ef0862ccb5dcb7347026ca95bf9a5857f538e295aebd3a6a5027adb4c -b92ac9c0f7e73150798348265e5f01f3c752480c72613c6894a95e9330bba1c642b21b9cbd8988442b5975476634b4fa -af3fbcc825abd92c6d7ea259467f27045e288f27a505e6a3c9ec864aa08fcaca0d4123034513dbd4c82d4814075708ab -a738232a66030e0e9c78e093a92fcc545b10e62fb0ecb832bbbc71471b28eb6ec422a498c2402e2c6d74983df801e947 -ae60194ce2035edd1af253b9eefbb4b1b7609c9678256c89c3cb076c332a9f4442c3441ad2ecc9d73265359bdadc926c -8b2fd55e686f16725fc0addb4065f696275852320b03221fd22889825d66fae5bb986b03c47452e32b3a32c1fdfc8dfd -8e2e1a36673b7729b07e7bc5014584e1c03e9552f7440fbfda0a6a7f41953947fcdf8d666f843bfc03dcca5b06a14318 -95a3df04368c069f3fd32a20b627c5f043e952167c9e80bf5914bbf2086879909c60e089bbd488725ab977c0e6051728 -9856403b2211d0152d4eec10db7ec34c16ac35170714b75af3ebc398a676c171b24b6f370361de0f9057ba444293db14 -a2cb484b758af5fd8e2baca7f0406f849c71255e58ef110d685cd0c1137893a25d85a4d8582e3ced7dd14287faa95476 -b0f697b6a42f37916b90ab91994ae4a92c96dc71e4da527af41b9d510bc2db5a9b4f29183a758074b6437a1e62b2d1d7 -b39c49266aae46f257b7ae57322972fb1483125298f9f04c30910a70fe5629dba0ec86b94cc6ba16df3537a55e06f189 -86cd5595b5b769dfd9ceb68b11b451f6c5b2e7a9f6f6958eac8037db1c616e8a9defb68a0d6c2287494d1f18076072c1 -b462e8fa9a372d4c1888fd20708c3bed1cb00c17f7d91a0481238d6584fbbf2d238e25931154f78a17296a12825d7053 -a5ef28286628ba509bac34c9f13158d0013239fdca96b5165161f90b89d6e46295822ebdf63f22d7739911363a0e0e86 -a629a95a24e2545862b41a97ecba61b1efa792fd5555dc0599c175947e9501bffc82b05a605fd5aabc06969ccf14fff4 -af83467e4b1f23a641630cc00c38d4225ff2b4277612b204d88de12a07d9de52fb4d54a2375a7fd91eb768623c255376 -a630f29fb2e9a9e2096d7f3b2f6814ee046ebc515f6911d4bc54ad8a5a821a41511ff9dcfbe3176f35c444338ecd0288 -950dedc11bd29e01ba9744bec681ad9462127c35e9fcadfacc9405ec86b985a1b1c4f9ac374c0f1fa248212e5e170503 -82e8e7be8011ee0fd9c682d26a0ef992d0191e621d07fd46a3a5640ef93a42e1b98a33cad1f8017341a671d28caebb03 -a075860554e712398dac2fb0375067a48d0e4ca655195cefc5ccb1feb8900d77124aa52a12e4f54f7dab2a8f1c905b5b -81d2183d868f08714046128df0525653a2dc2ff9e2c3b17900139c9e315b9f4f796e0fb9d1d8cbadbaa439931c0e0879 -81fb1456969579515a75fb66560f873302088cde2edc67659b99a29172165482ca1f563758c750f00086b362ae405322 -a13c15ab19203c89208c6af48d2734bb0873b70edb660d1d5953141f44db9012528d48fb05aa91d16638cbda2ca8f0cc -8ba46eef93e4ec8d7818124a0b9fcfe2bcf84a98db3545d2b3d0192cfadc81fc667dcc22ab833c3e71508d0f3c621fe4 -b9bd60d2266a7d01e1665631a6ed6d80ffc0cd7f088f115a5d4ea785c518a8f97d955e2115b13c4960302b9825526c92 -b26fa4e87142150250876083a70c229249099331410f0e09096077fdf97b31b88dc57a3e3568d2a66a39af161cf5dfec -b9d147564124728b813d8660ba15fa030c924f0e381ad51d4e0cf11cc92537c512499d3c2983dd15f2e24ca166070d70 -b6fb44e1a111efb3890306fa911fafda88324335da07f7de729b2239921ef15b481630a89c80e228bec7ab6444a0b719 -a6cd9c7acac052909ef0cf848b6012375486b59b7bac55b42c41f0255b332c1d45a801f6212d735be8341053bd5070b9 -864258d69234786af5de874c02856fc64df51eff16d43bfb351b410402ab28f66895aec4025e370a4864f19ff30fd683 -84370fa1243b64b3669dd62e1e041ff9bd62810752603486aac3cba69978bd5f525c93cbc5f120d6f2af24db31ec3638 -b983c2cdc1a310446de71a7380b916f9866d16837855b7d4a3a6c56c54dab3e373a6fc6563b8309dc3b984d4e09275d6 -914f8587f876470f7812fa11c6f67e2dd38bf3090e8928e91fe2fe5595bee96cbe5f93d26fdced6b4e7b94f75662b35d -8b47bcb111d91aa3d80e4ceef283824aa00d1faeb6fe4111aecd9819869c0e1f6f4b6fb2018aebb07a0f997412cda031 -95b2befa98f9992450ca7ff715ae4da8c36dd8adcfef3f0097de6e3a0b68674b05cbf98734f9665051bb4562692641e0 -8bcd1651a2bfce390873a958e5ff9ca62aac5edd1b2fd0f414d6bcf2f4cf5fa828e9004a9d0629621b5e80fbbd5edb90 -af79bed3c4d63239ac050e4fa1516c8ad990e2f3d5cb0930fc9d3ce36c81c1426e6b9fe26ac6a416d148bf5025d29f8b -881257e86b7ab5af385c567fde5badf67a8e7fff9b7521931b3ce3bac60485c0fe7497339194fb7d40e1fad727c5c558 -a1b40b63482cd5109990dfb5a1f1084b114696cbbf444bf3b4200ab78c51dad62c84731879ea9d5d8d1220e297d6e78a -b472212baa2a31480791828ca5538c3dcc92e23f561b0412f8cc9e58839d1625ddcaf09c8078d31ac93470436843cd74 -8f516d252b1863cd3608d852a2857052bb2a3570066d4332fa61cb684b10ac8d1a31c8d32f2a0d1c77eee2ad7a49643d -8d20b75c51daa56117eda2fd5d7a80a62226074b6a3ff201519f2054eecfeff0aa2b2f34b63bea3f53d7d0ce5c036db9 -8282f433229e7948a286ba7f4a25deb0e0a3c5da8870562c3646757bef90ca1e8d3390b0a25b3f2bf45bf259a4569b77 -8a2dbf4b55cc74f0a085d143a88ebc8c2a75a08eab2703d13a00b747eaddc259a3dd57f7330be938131835a6da9a6a68 -aa0bc51617a938ea6a7b0570e98b8a80862dd9e1cf87e572b51b2a973e027bcd444ef08e0d7b5dee642e0da894435e91 -aa7319ca1ac4fe3cc7835e255419eeb7d5b2d9680769cc0ca11283e6147295db75713b71a9312418a8f5505cd45b783d -ab3f9c465663dc90fae327a2ee9cb7b55361a9b6fbe713540a7edd3cff1c716802fb8ad4dd8fb0c945d96b3b44c5795b -913a2ae88acffab12541fc08920ee13ab949f985a117efe9a5b2c76f69f327f60c5b5ad3fa5afa748034ac14298fc45a -9008f044183d2237b723b235953e4d8b47bec6a7b300d98075555478da173b599ba9c7c547c2f111ce1fae5ac646e7a3 -a26b4cc42b353e1c18222d2e088d7f705c36be12e01179db440f10fcfa9691d31fc4fc7e7ee47876f1624e6d44be1021 -995e75824f322294336bfa2c5d1a319f0d77f6a0709beabaf1b43015d8a78d62447eab907349524734170f0294d1ca7a -8b96f04a19dbe4edc71d1f2c6d3475ae77962e070ec5797752453283c027c6b29b6e58e8b7eb5c3f9770557be7e80b67 -8621459865234734bcfaa492ca1b89899525198a7916ccc6f078fb24c8bf01154815bb5b12e1c3d0a10bd4f1e2ea2338 -ab52174541185b72650212e10a0fe2e18ccfd4b266a81233706e6988c4af751b89af87de0989875f7b5107d8d34c6108 -966819d637bdd36db686be5a85065071cf17e1b2c53b0e59594897afc29354ecba73bf5fc6fa8d332959607f8c0a9c27 -b7411209b5ab50b3292c3a30e16f50d46351b67b716b0efb7853f75dc4e59ec530a48c121b0b5410854cd830f6c4b3ea -a5dc04adbadce0af5dc1d6096bad47081110d4233c1bf59a5c48a8e8422858620f4be89bf1f770681be2f4684ee4cce7 -af77a8f83cffb5f8d17be0ab628dedcad63226c9b13ce4975fb047f44bfef7d85e7179aa485abb581624913eddbb27ec -82bf28dc58c893c93712ce297cc0d64f70acb73a641cb4954ccf9bf17597f6d85eecf5a77c8984ab9afbe588562a0ee9 -988a7cef9a178e8edb91f3ec12f878fd68af2ac0762fa0a48a2423e24f765ed8f7837429fd8bc0e547e82e6894e63008 -a5d5969311056d84b3ee87f49286fac0bd9a7220c196cea4f9dced3b858dcdba74718eab95b38bd5d38d2d1184679c98 -af4d51b3ded0aaad8f12bef66c0616e9398fc42618852ac958e6ab2984a720a6111ac55b249d7e4523051740e12b346f -ac635b4a49f6fbb94a5f663660f28431ba9f7c5c18c36ebc84fd51e16077de7753595f64619b10c16510ecbc94c2052d -ae25eb349735ced1fe8952c023a9b186a1f628a7ddf1a4b6f682354a88f98987ac35b80b33189b016182f3428a276936 -ae3ab269690fdd94134403691ba4f5ed291c837c1f5fdc56b63b44e716526e18abb54f68ca5d880e2fb7bea38e74c287 -a748b03b2bd3fbc862572bc4ddc0579fa268ee7089bcfd0d07d0c5776afcd721302dbb67cb94128e0b1b25c75f28e09a -8f09a2aaa9ba3dfe7271f06648aba9cc1ea149e500a7902d94bb9c941a4b01d1bb80226fd0fd2a59ad72c4f85a2a95d0 -853d55ad8446fd7034e67d79e55d73a0afcb5e473ed290e1c3c7aa5497e7f6e9bbf12d513fc29e394a3dc84158a6d630 -b1610417fb404336354f384d0bf9e0eb085073005d236a0b25c515d28235cea5733d6fbd0ac0483d23d4960064306745 -86de805b3d4f6fbb75233b2cf4d22fcc589faa2ac9688b26730cb5f487a3c6800c09bb041b2c6ab0807bfd61b255d4c9 -893b38c72cf2566282ee558d8928588dca01def9ba665fcb9a8d0164ee00dedafbf9d7c6c13bcc6b823294b2e8a6a32c -8e50de7a70ac9a25b0b5cf4abc188d88141605e60ce16d74a17913a2aff3862dec8fbbf7c242cf956f0caae5bcc4c6bf -b5cf09886a4fb4ce9ea07d1601d648f9f9d1a435b5e1e216826c75197cd6dafd6b2b07d0425a4397a38d859a13fdb6dc -859dc05daf98e7f778a7e96591cc344159c1cbe1a7d017d77111db95b491da0a9272866d2638a731923ca559b2345ebe -8ff1792f77ecdfbd9962f791a89521561c7b82031a4e53725f32fe7d99634a97b43af04cbf3e0b0fdff4afa84c49eb99 -81e2cd8a221b68ae46dd7ce97563bd58767dc4ce1192b50ff385423de92206ff585107865c693c707e9d4ed05f3149fb -8fce7da7574e915def0d1a3780aa47ef79b6d13c474192bd1f510539359494ddc07e5412f9aac4fc6c8725ade4529173 -ac02f5df60242734f5ead3b8a62f712fefdb33f434f019868a0b8ddf286770244e2ddfb35e04e5243ba1e42bcd98a6a5 -a8d69783349a442c4a21ecb3abd478a63e2c24312cb2d2b3e10ea37829eb2226a9b8d05a8c9b56db79ffaa10d1f582d1 -b25b5cca48bf01535aba6d435f0d999282845d07ac168f2ca7d5dba56ee556b37eab9221abdb1809767b2de7c01866c1 -8af7e1d1f4df21857d84e5767c3abe9a04de3256652b882672b056a3ab9528e404a8597b1ad87b6644243f8c4cd3799f -a6718308dfa6992ae84fcb5361e172dbbb24a1258a6bd108fd7fc78f44cc1d91be36e423204a219a259be4ab030f27ff -b99cbe3552c1a5259e354c008b58767c53451932162e92231b1bebfc6a962eb97535966a9bd1dfd39010dfcda622d62a -a8458f6b8b259581f894e4b5ce04d865f80c5a900736ca5b7c303c64eaf11fe9cb75e094eece0424ba871b2aee9f7a46 -914f763e646107b513c88f899335d0c93688ffa6e56c3d76bff6c7d35cb35a09f70dc9f2fe31673a364119c67cd21939 -9210f2d39e04374f39b7650debe4aceeb21508f6110ab6fc0ab105ec7b99b825e65753d4d40f35fad283eeff22a63db0 -98729cf927a4222c643b2aa45b3957b418bce3f20715dd9d07997a3c66daa48dd62355dbd95a73be9f1d1516d1910964 -a602c399f1217264325b82e5467a67afed333651c9f97230baf86aec0dd4edeae1e973cafef2ea2236d6d5b26719954d -ac9632921d45900bf3be122c229ba20b105b84d0f0cba208ccdce867d3e9addfb3ef6ece9955950d41e1b98e9191ef42 -a76ce1f53e1dc82245679077cb3bca622558f2269f2d1a1d76b053896eba1c3fc29d6c94d67523beb38a47998b8c0aa7 -b22b51fcc1b328caa67cc97fb4966cb27d0916488a43248309c745cd6e2225f55ad8736d049250fa0d647e5f8daa713c -b7645c1923a6243fa652494fe9033fa0da2d32a0fb3ab7fcb40a97d784282a1ffad3646c499961d4b16dadbc3cbb6fd6 -acab12b490da690db77c4efdc8b2fe6c97ac4ba5afb5165d6647fdd743b4edbad4e78d939fc512bebcf73019c73bae40 -ad7a0fcd4e4ccb937a20e46232a6938fccf66c48a858cf14c8e3035d63db9d1486e68a6bf113227406087b94a0ece6a0 -a78605beaa50c7db7f81ab5d77a8e64180feea00347c059b15dc44c7274f542dc4c6c3a9c3760240df5f196d40f3e78b -8763315981c8efa9b8ae531b5b21cfc1bbc3da3d6de8628a11dcc79dee8706bd8309f9524ec84915f234e685dd744b69 -b4a6c48531190219bf11be8336ec32593b58ff8c789ee0b1024414179814df20402c94f5bfd3157f40eb50e4ef30c520 -8dac8a3f152f608ce07b44aee9f0ed6030fa993fd902e3d12f5ac70bf19f9cde2168777d2683952a00b4b3027d7b45ea -8baf7dfae8a5840c5d94eabfe8960265f6287bb8bc9d0794a6d142266667a48bec99b11d91120907592950a0dddc97d9 -b8595e6ea6b8734d8ae02118da161d3d8d47298d43128a47e13557976032dad8c2ccbfff7080261c741d84d973f65961 -8b93979c51c8d49f4f3825826a5b9121c4351e0241b60434a3c94f2c84f0b46bbf8245f4d03068676166d0280cf4f90c -aceb0fdaf20bf3be6daebf53719604d3ab865807cc2523285f8fef6f3fc4f86f92a83ad65da39de5bd3d73718a9c4bd2 -814dd41764a7d0f1a14a9c92e585f154a26c8dbf2f9bff7c63ae47f1ac588cec94f601ccc12e8a63a7a7fce75a4287f2 -b47b711848e54fa5c73efc079d0a51a095fa6f176e1e4047e4dac4a1c609e72099df905958421aee0460a645cba14006 -aaf7bd7e1282e9449c0bc3a61a4fca3e8e1f55b1c65b29e9c642bb30a8381ce6451f60c5e0403abc8cee91c121fa001f -b8b0e16e93b47f7828826e550f68e71a578a567055c83e031033c1b7f854e7fc8359662a32cc5f857b6de4aff49e8828 -b3eb70b8c8743a64e1657be22a0d5aeb093070f85a5795f0c4cb35dc555958b857c6c6b7727f45bf5bedf6e6dc079f40 -ae68987acd1666f9d5fa8b51a6d760a7fb9f85bf9413a6c80e5a4837eb8e3651a12e4d1c5105bfb5cfa0d134d0d9cfc2 -acd8fa5742b0bac8bd2e68c037b9a940f62284ff74c717f0db0c033bf8637e4f50774a25eb57f17b2db46e5a05e1d13d -a98dac386e7b00397f623f5f4b6c742c48ab3c75d619f3eaf87b1a0692baf7cb7deac13f61e7035423e339c5f9ae8abf -99169bd4d1b4c72852245ebfbc08f18a68fb5bcce6208dd6d78b512b0bc7461f5caf70472b8babf3e6be2b0276e12296 -937d908967f12bf7f728fe7287988c9b3f06c1006d7cd082e079d9820d67080736910bc7e0e458df5bae77adb9a7cbc1 -8c50e90ce67c6b297fd9406c8f9174058c29e861597a0f4ed2126d854a5632fa408dfa62ad9bb8b6b9b6b67b895d5a4d -8f4840a91b0a198226631a28e7a2e893fc6fed4d5eb3cb87b585aac7f4e780855a353631ad56731803296f931e68a8d0 -96a4b8c64d3d29765e877345383bf0e59f4ac08798ac79dd530acd7f3e693256f85823ad3130fb373d21a546fe3ca883 -b0dce7a6ab5e6e98b362442d6e365f8063ba9fef4b2461809b756b5da6f310839ac19b01d3fd96e6d6b178db4ff90ee1 -8f012cb2be5f7cb842b1ffc5b9137cafef4bd807188c1791936248570138f59f646230a1876f45b38a396cbdd3d02e08 -94a87b5ce36253491739ca5325e84d84aaff9556d83dcb718e93f3ff5d1eecf9ae09d0800a20b9e5c54a95dfebfcecd3 -b993ec5f9e82cc9ceeb7c5755d768bc68af92cc84f109dfaf9cf5feb3aa54881e43c3f598ba74ed98e8d6163377440ca -92f845d4d06a5b27d16aef942f1e3bcbe479b10fef313f9ca995315983090511701b39ccbb86b62d0c7c90a2d1f0c071 -b6ec6da0f9e7881e57fa3385f712e77f798abc523609a5b23e017bb05acc6898825541aed7fe2416c4873de129feceea -86b181183655badfe222161d4adf92a59371624a358d0ec10e72ee9fa439d8418f03d635435ec431161b79fd3fa0d611 -b5e28eeed55fb5318b06a0f63dbf23e00128d3b70358f1c6549fd21c08ef34cb1372bc0d4b0906cc18005a2f4cd349bf -85c4d3fddda61dbfb802214aa0f7fc68e81230fb6a99f312848df76cddc7b6dfd02860e8a4feb085dad1c92d9c6c65e0 -80f7fdec119309b2ac575562854f6c2918f80fc51346de4523ec32154d278f95364fdef6f93c7d3537a298dd88df7be6 -9192c1949d058614c25f99d4db48f97d64e265a15254aa6ed429e1ef61d46aa12355769f1909a5545cd925d455a57dbe -a0b1e7d928efc4dcbd79db45df026ae59c20c1a4538d650c0415ab7cb0657bc1e9daeacc3053ee547e8f9c01bdbd59c4 -893e84c41d3a56bca35652983c53c906143b9ad8d37b7c57f9dacbeb7b8dd34defc6a841f5b9857ffb90062bbd8e9dee -a7f89a448349dbc79854cf888980327f92aedc383c7fadd34fdc0eaa4f63d751315b4f979e14f188854ef4d16c9e8107 -833f2774a96187805f8d6b139c22e7476bce93bc5507344d345008080fb01b36d702b96e4c045617a23a8ca1770b4901 -80e46e86d68bd0a48ac6fa0b376d5bb93a5d6b14f08b3a47efa02bb604c8828c2047695f1f88fc5080e5548e1a37130f -943f42b7b4ad930059a26ad06b62e639f06c1c425d66066c55134e97c49abe412358c7cb994fcc1cf517ea296bca1f68 -8b9d4fe835dc6a2cbf85738937bbfb03f0119ab8df04a7d68860716ce6ee757dbe388a1e8854ddb69fe0c9fa7ed51822 -909030c7fde2591f9ea41ae6b8fa6095e6e1a14180dda478e23f9c1a87b42c082a1ea5489c98702f6ccd2ba5812d1133 -a715ec1beb421b41c5155c7ef065bbb50b691d0fa76d7df7ee47683d9e4eb69b9ea3e62fc65196a405d6e5e29e6c2c60 -8c9e801cb7ef780a535be5c2a59b03e56912acbfdb00447bfa22e8fc4b11dceecc528f848d5fba0eec4237d6f81f4c79 -b96b6af857c3bc0344082bd08ec49a9bed478d4d35b85a2099b1849cd6997521c42225305f414cdd82aef94b9e1007d3 -8764db720b4e44a4d2527f7f9b535a494a46c60e28eac06bf1569d0703c4284aefa6cb81fbba9d967286f9202d4b59ea -a66fd2f9158e1ffcdd576cba1413081f43eed00c7eb8f5919226f7b423f34ac783c1c06247819b238de150eb5a48d977 -82c52e817ac3bb0833ea055dec58c276c86ca5181811cf7a483b3703a06ea1bee90ae3aeaa2cffeaeba0b15fe5bf99be -987d07cb276f7f03a492cfb82bba6d841981518286402d3e69e730a9a0e29689a3619298124030da494e2a91974e0258 -b34f2c5740236bc6d4ae940920c5bc2d89ff62a3dd3a3ec9a0d904d812b16f483073db1e53b07f2b62e23f381d7bdbe5 -a1c0679331ab779501516681b3db9eefb7e3c0affb689e33326306ada6d7115fafd2cc8c1c57b2fa6c2072552f90a86e -94805e30d7852fc746e0c105f36961cc62648e438e8b9182fc0140dbf566ec14a37ad6e7f61cacb82596fc82aed321e5 -a42fb00b29a760141ff0faaeb7aca50b44e7bbc0a3f00e9fb8842da7abfcaae6fae9450abe6ba11e8ecf11d449cbe792 -8fb36ce4cfa6187bfe8080ac86b0fa4994f20575fb853bd8ffa57c696179cc39f58ff3b4bd5a2542ff1c8b09015539df -a1c54e7aa64df7fb85ce26521ecfc319563b687ffecd7ca9b9da594bbef03f2d39f51f6aaff9a3b5872d59388c0511c6 -855e48fdb8f771d4e824dbedff79f372fd2d9b71aa3c3ecf39e25bf935e2d6e0429934817d7356429d26bf5fd9f3dd79 -8ae6157a8026352a564de5ee76b9abb292ae598694d0ea16c60f9379e3bb9838ce7fd21def755f331482dc1c880f2306 -a78de754e826989de56fe4f52047b3ffd683c6ceaf3e569a7926f51f0a4c4203354f7b5cfa10c4880ba2a034d55a9b0d -97609477d0a1af746455bbd8cb2216adacc42f22bfd21f0d6124588cd4fec0c74d5bde2cdba04cdbfbff4ac6041b61b1 -a03dc3173417381eb427a4949c2dbfa0835ef6032e038bf4f99297acf4f0ba34a5fc8ccf7e11f95d701f24ee45b70e27 -aad6283e85cd1b873aeb8b5a3759b43343fdadc9c814a5bf2e8cf3137d686b3270f1ec2fb20d155bbfd38c7091f82c44 -92ab94ed989203a283d9c190f84479c2b683615438d37018e9c8de29c2610bb8fccd97bb935dca000d97d91f11a98d65 -8c0444a0b9feb3acb65a53014742e764fa07105e1c1db016aec84f7a3011d9adc168dbba8034da8d0d5db177a244d655 -95a33d25e682f6c542d4e81716cc1c57ef19938409df38bf8f434bc03193b07cedd4e0563414ce00ab1eebbd3256f3e7 -8716c30e3e4b3778f25c021946c6fb5813db765fde55e7e9083a8985c7c815e1b3d3b74925ba108d9a733ddf93b056af -a186aabc10f1fff820376fa4cc254211c850c23a224f967d602324daec041bbe0996bf359ed26806a8c18e13633a18a8 -a1e8489f3db6487c81be0c93bade31e4d56ec89d1a1b00c7df847f5cd7b878671015f5eaa42ee02165087991936660b9 -8f688c969c1304dfa6c1a370119d1988604026a2ab8e059016c5d33393d149aae6e56f3ee2b5d25edc20d4c6c9666ad9 -91950b651fefd13d2fa383fd0fdc022138ce064ee3b0911157768ad67ed1fb862257c06211cf429fba0865e0b1d06fc8 -86cff4080870d3e94ed5c51226a64d0e30266641272666c2348671a02049ae2e8530f5fb1c866c89b28740a9110e8478 -88732c4d9e165d4bb40fb5f98c6d17744a91ff72ca344bc0623d4b215849a420f23338d571a03dd3e973877228334111 -afcc476ad92f09cf2ac7297c5f2eb24d27896d7648ba3e78e1f538c353ceeb1e569917a2447f03f3d4d7735b92687ba5 -b622aa475e70d9b47b56f8f5026e2304d207684726fb470a0f36da7cb17c30dd952813fab6c7eb9c14579aacca76f391 -802cf5630c0407ae0d3c5cf3bef84e223e9eb81e7c697ea10ec12e029fc4697ce7385b5efab7014976dacc4eb834a841 -a08596493f4cd1b8ac2ec8604496ee66aa77f79454bb8ab6fdf84208dc7607b81406c31845d386f6ac8326a9a90e7fc5 -a54652ca9e6b7515cb16e5e60e9eabbccbc40bb52423d56f0532d0bac068aec659a16103342971f2cc68178f29f695db -a3ab54875cb4914c3a75b35d47855df50694310c49eb567f12bbc5fa56296e11f4930162700e85ba2dbfdd94c7339f91 -94183a040285259c8f56bef0f03975a75d4def33222cc7f615f0463798f01b1c25756502385020750ac20ae247f649a1 -b0004261cc47b0dc0b554b7c6ebf7adf3a5ece004f06e6db3bbac880634cdf100523b952256a796998a5c25359f12665 -a25dfeb0e18ebe0eb47339190f6a16f8e116509ab2eef4920f0d3ff354e3ead5abe7f5050b2f74f00b0885ea75b4b590 -ab10ef2f5dc0ede54e20fa8b0bce4439543db8d8b31e7f8600f926b87ec5b8eea0ac2153685c7585e062ffac9e8633c3 -8386eac1d34d033df85690807251e47d0eaacb5fe219df410ab492e9004e8adabb91de7c3e162de5388f30e03336d922 -b6f44245a7d0cb6b1e1a68f5003a9461c3d950c60b2c802e904bc4bc976d79e051900168b17c5ac70a0aed531e442964 -ad12f06af4aa5030b506e6c6f3244f79f139f48aec9fc9e89bbfbd839674cfd5b74cea5b118fb8434ba035bda20180af -88511306dfe1e480a17dba764de9b11b9126b99f340ceb17598b1c1f1e5acbdd1932301806fe7e7e5e9aa487a35e85de -a17cdf656e1492e73321134a7678296a144c9c88c9a413932d1e4ca0983e63afc9cdc20fd34b5c6a545436b4db50f699 -b555b11598a76de00df0f83f0a6b8c866c5b07f7ac2325f64fb4a0c2db5b84e0e094d747186c3c698ee4d0af259dc4c7 -88014560587365e1138d5b95c2a69bdae5d64eb475838fee387b7eb4c41d8c11925c4402b33d6360f0da257907aa2650 -b220634e6adee56e250e211e0339701b09bf1ea21cd68a6bd6ee79b37750da4efe9402001ba0b5f5cbbfcb6a29b20b0c -ac5970adc08bc9acec46121b168af1b3f4697fb38a2f90a0fbc53416a2030da4c7e5864321225526662d26f162559230 -97667115b459b270e6e0f42475f5bce4f143188efc886e0e0977fb6a31aba831a8e8149f39bc8f61848e19bcd60ceb52 -b6c456b36c40a0914417dd7395da9ed608b1d09e228c4f0880719549367f6398116bf215db67efe2813aa2d8122048f2 -ab7aef0d6cda6b4e5b82d554bd8416a566d38ded953ffd61ef1fcca92df96cdcc75b99a266205ff84180ab1c3de852a4 -81d354c70ce31174888c94e6cf28b426e7d5c4f324dc005cd3b13e22d3080f3881d883ca009800f21b0bb32fa323a0cf -94f3440965f12bee4916fcc46723135b56773adba612f5ce5400f58e4d4c21435e70518bdef4f81e595fa89e76d08fc6 -a6683e7a1147f87cbeeb5601184cc10f81bca4c3c257fd7b796a2786c83381e7698fb5d1898eb5b5457571619e89e7d6 -8ca29539600f8040793b3e25d28808127f7dc20c191827a26b830fff284739fb3fc111453ff7333d63bce334653a0875 -98a69644048b63e92670e3e460f9587cf545a05882eb5cba0bcbd2d080636a0a48147048a26743509ab3729484b3cc12 -84d40302889c03c3578c93aca9d09a1b072aadd51873a19ef4a371ca4427267615050c320165abece7f37c13a73d4857 -87954271e3de3f0b061c6469d038108aac36f148c3c97aefb24bf1d3563f342ea6c1c1c44c703e1587a801708a5e03f8 -86b6f5367e04c5caa3ec95fd5678c0df650371edac68f8719910adf1c3b9df902cc709a2bddc4b6dde334568ca8f98ac -a95fed2895a035811a5fee66ca796fdecce1157481dd422f8427033ed50c559692908d05f39cb6bea5b17f78a924633c -8ba05bdadde08a6592a506ea438dbdc3211b97ea853d1ad995681a1065ececce80f954552b1685ef8def4d2d6a72e279 -90b6b7494687923e9c5eb350e4b4b2e2fa362764d9a9d2ebb60ee2ad15b761e0850c9a293123cf2ef74d087693e41015 -8819ea00c5ea7b960eb96ab56a18c10a41fd77e150ab6c409258bc7f88a8d718d053e8f6cb5879825b86563e8740808d -91e42031d866a6c7b4fd336a2ae25da28f8bde7ace6ff15dc509708b693327884e270d889fff725e6403914546055c28 -85763642052f21cf1d8bd15fd2dc0c2b91bba076751e4c4f7a31fbdb28787b4c6a74d434d6ef58b10f3ad5cde53ef56d -8b61c36c7342a1967a1e7b4c01cddf4dce0e2025bc4a4a827c64994825f53e45277550ceb73c34bb277323fb784aa3c6 -80b9634a45c8b3770e993257bd14df6a17709243d5429969ab8b9a4645bf2a94f9b3cd3d759169887b4aa0eb50f4f78c -b5c44db9439dd8aa4edd151d95e48a25c1154e1525c337f97109f40131db81a4898344c8c3144c270bdc835c269b3477 -863080fcbc227eea32d0dc844f42dc642fbda7efc398ab698be3a3c6f3bf8803dea6ba2b51fed6151f9522b4ab2a8722 -8481e871129e9cb9d2d109c513cbba264053e75192e967f89659dcfcc1499de9ae7a1ac4f88f02289150231c70b4da01 -834d8183698d3d2d1352c22c373222cb78d0f4c8cb15e0ad82073dde273b613515ebcd184aa020f48f8e6fc18f3e223c -a227e300f0c5bc1b8d9138411413d56c274cc014ae8747ec9713f3314d5fae48bb6f8cc896f232fd066182af12c924e4 -ab7242835e91ba273de1c21eb4fca8312bdda5b63b080888b96a67a819b50294a7f17a7dc0cd87fae5e7f34bc24c209a -86eb27c898a5d6c3618c3b8927acee195d45fe3f27b0991903520a26fb8021b279e2a8015fbbba5352223ae906c7c5d6 -a61b1c200b0af25da8ad8e29f78d000a98683d1508ae92ee7f4326a7c88e0edb645b6cb5dde393ac74d322895e77ba24 -887739318c710aae457b9fe709debff63bfbb3ffbbb48a582c758b45d6bf47a7d563f954b1f085c3bc633ffd68c93902 -aacfcb0e2b0a868b1c41680487dc6600577ce00aa2edeee8c6141f4dc407217ddb4d37b79e7c9182258c750d12a91508 -ad8cd2cf5ccd350cd675a17f31b86a0e47499c6c4c11df640a5391bb10989c9c70df0a3ddeba9c89c51e15fedaf67644 -8aba897d32c7ef615c4dfa9498436529c91c488a83efc07ba9600875c90c08b00f66a51469eb901451b6e18e7f38ffd7 -aab8a600609b80e36b4a6772308bac77929a0c5d8d92bbc38e9999186a1c2bfdbef4f7a2b1efba9c17a68dc15a9373ab -b95811d1454307a30c2ac8588c8104804b06c1aec783fed75a6f12c9df626be57865850100f1ad28073e3867aca941cf -8b119d3bd4ee644469457df5d8a0020fd99b8b20bd65ab121cf95a7f55e50dd8945fcf1dff9d269d9d0b74b4edbc7726 -a980b912df832ea09353fd755aa3eec9eb4cfd07ca04387f02a27feab26efa036fca54cc290bb0c04a8a42fdfd94ce2f -91288e84da1d4ee2a4dad2df712544da3a098fdb06a5470c981fb6d6f3dcc1c141b6f426d6196ff3df6f551287179820 -98b0473bcffcbd478fd1b49895c61dd2311dab3cdec84f8e3402f8add126c439ffcb09cae3b7f8523754090d8487b5a9 -abe76988cf3065801f62a1eb3cfe9f8185bd6ab6f126c1b4b4fde497ca9118d02a0db3fadccd4ca98826b30475fa67ef -94a316a0faa177273574e9e31989576a43e9feb4cc0f67aa14d5c1967c4e10fc99db3ef4fdca2e63800a0b75f4b84256 -975ad39adadc7e69e34981be2e5dc379b325dc24dddacc0bb22311ff4a551a0020a8bdecf8ab8ac5830ca651b7b630ce -8b3bc73b640dc80ac828541b723a968fb1b51a70fa05872b5db2c2f9b16242c5fe2e8d1d01a1dbeaac67262e0088b7b0 -aa8d892a6c23dbc028aae82c1534acb430a1e7891b2a9337cedb913ff286da5715209cffb4a11008eae2578f072836cb -8dee9747a3ae8ed43ce47d3b4db24905c651663e0f70e2d6d2ddb84841272848a1106c1aa6ba7800c5a9693c8ac2804e -81e2c651b8b448f7b2319173ecdc35005c2180a1263e685a7e3a8af05e27d57ec96d1b2af2cae4e16f6382b9f6ec917c -98a9a47635de61462943f4a9098747a9cf6a9072a6d71903d2173d17c073eff3fc59b2db4168515be31e6867210ecbcd -912b2398505c45b0bb4a749c3f690b1553b76f580b57007f82f7f6cce4fadd290d6df9048258978c8a95ef9c751a59a2 -8ac8f0893fe642111ef98ae4e7b6378313a12041bbca52141e94d23152f78c2e4747ae50521fc9c5874f5eb06976e5cf -946b4a8eb05b529aaed56ac05e7abeb307b186a7835623fa4e85ed9eb41a4910663c09ea1bd932a2c467d28776b67811 -a4be51abeddd40e1da6fdb395d1c741244988ff30e10705417b508574b32dce14d08b464486114709339549794df9254 -b33b6b7d66cb013e7afeabbd7ed1e0734eb0364afe4f0f4c3093938eec15f808985fb7f3976969bf059fa95f4d8e335b -a808adbcf0049f394914482483ee0f711d9a865615ff39b5313ed997f7a0d202ad9ed6e6de5be8a5c1aaafe61df84bca -8856268be15a78465ad00b495162dc14f28d4ef4dcf2b5cba4f383472363716f66dabc961a6dbdda396e900551411e41 -b16ba931e570e1bf124ea3bd3bdf79aed8aa556697ea333e6a7d3f11d41538f98dcde893d0d9ba7050442f1515fb83b1 -91ecde1864c1a9c950fd28fa4c160958246b6f0aa9dda2a442f7222641433f1592d38763c77d3f036a3dbb535b8c6d8f -92cda991f69fbf8e55c6bf281b07fff5dbbb79d1222b8c55686480669247b60212aac27aa7cccd12fcee94e7a759b8af -b1d9b5b4e996b375d505d7250a54c12d32372c004a9cabf1497899054cb8b5584b1cef1105f87b6e97603ccbf2035260 -86e98bde8b484fb809b100f150199f13a70c80813ad8b673bf38e291595e2e362ad1fa6470d07d6fbe2cf7aeac08effc -aa12f7c39ba0597a8b15405057822e083aca3cee6ed30c4e0861eeb22620823588d96c97bb1c3776b711041c4dc3d85d -b477b34f29334f3bae69c7781d574342b7c27326088f9a622559ab93075c7357953ae84eb40e3421f453e04e9b4d5877 -9625067cb2120ce8220a469900aa1d1bb10db8fe1609988786b07eb2b88e0ddb35a3eccd4b6741e1fa2365c0db6b1134 -997b92af7765f587d70ea9718e78a05498cd523fc675ad7b0e54a4aae75fbeac55d0c8d72471471439dacd5bfcfae78d -88b59eaea802e6a2cf0c0075bf3fd6891515adcb9adf480b793f87f1e38d2188c5ed61ac83d16268182771237047ec8a -a57d078b230b1532c706a81eaabfef190fb3eb2932f4764631e916a0f0d837d6014da84ede100abaf610519b01054976 -94ed5c5b96f6afa9f2d5e57e1c847ae711839126ab6efb4b0cf10c4564ff63c819d206fdc706178eb6a0301df2434c01 -980296511019c86cc32212bad6e4a77bc5668b82a2321a1ecabc759a8bbc516183a4787c7f75f9ee7f1338691dc426cc -b10ef97db257343474601fd95f9016c205e28bd22bf7b8f9e30c3b14aca1cc9a11e6404ff412ef269c55fb101fee5a37 -b670d5d9c77fc6aa14212dd3eae100620f3510031b11a9625aa40bf31835c9fd717753b555bd159b1aa64a2104929340 -862054fabf6d6d529a7584d1a48f72d2eb216caf959c782ec36c69c26aef4595415d19a28b041946811b34a629105241 -ae4bf2ccd7b0f3774653848b5b4d39e5517dcbcff30d8441d78bc387ff42b573f16b7b0a7366e6ca5cef1dd9f0816df9 -8f810527badcb49f1542a0ccd12e3541efa084243f7106eae003458c176f4c1f01daae9d4a073c2cb2aced747e8a4576 -8a32c2067aaf6baf32db67acd4974a22a6da33db5444028a7c8c4135f9c84e102dc3b2c635b15afa6dc907d0270daffb -b15fc057f306a60b20c8487125b6b334ab749cf70eb8a30c962f625bb203ebd0d2a315949ee3b7a99e3d91acec384806 -a37f145d321359b21cba7be8b64dfae7c67a20b7b324f27c9db172d58e77a49fa02ed3d06d09d7644bf1fd81f4aab44b -b338d2e39a485ee4297adcf5e58e16c3cc331c5dffeade0be190907c1c5bdfed38537a6d81dc39a2cdfc1bc45e677886 -b69d84d8511b3aedfdc7c7e66f68b24e12e5a2365dbbe014bddd2e99e54143428cf8b74cf12c0e71316038aa5300e87e -ab210cc38661667450561a1857337879633f5d5bf2c434a3df74ff67f5c3ba69a7880872f19ae4dcbbb426462cd7d0fb -94538ef487a58a5ff93a5e9616494c5f066715d02be5b249d881a00bd0edfe2fe19dd7a5daa27f043d1dbb5ac69cf58d -afb47a899c1b25fe800241635fa05de9687a69722802ad45434f551971df91d8ca9edda0d835d82eb8f36ff9378ed7e8 -827a10d7536230887283a9b1dedccc6b95ef89cb883c4ee7b9821058b0f559704d1636670c0ada2b253bf60b7cb8a820 -97cc07965065d64409f19fb2c833b89ca3a249694b16b58818a6f49d3800926627ce0f87e5c0853ae868b4699cfdee5e -ae0c93d44780ef48ea537cf4cb8713fd49227f4b233bc074e339d754b5953e637a7289c6f965162701e4b64e4eaec26d -80953053397c4c0ba9b8e434707f183f9ced2a4c00d5c83b7dc204e247ad7febc1855daeb906c53abfdf3fe3caca30c4 -80f017e87b471b5216ebe25d807be6c027614572337f59f0b19d2d1f3125537478cb58e148f3f29b94985eac526cd92f -8a8e1c0d49801a8dd97e9e7c6955fc8b2c163a63bd6a4be90bb13e7809bb0dddc7a5025cc7d289a165d24048eac4e496 -8530e5b5c551a2e513d04e046672902c29e3bb3436b54869c6dea21bab872d84c4b90465de25dff58669c87c4c7d2292 -ae3589d389766b94428e9bde35e937ed11aac7ead3ce1b8efe4916c9bfff231d83b7e904fe203884825b41022988897a -ac02e629a900438350dd0df7134dfa33e3624169a5386ea7411177b40aa7a638e8d8aef8a528535efdbe1ca549911c0b -b1ac60b7270e789422c3871db0fa6c52946d709087b3b82e6eba0d54f478520b1dc366bb8b7f00ff4cf76e065c4146eb -a7465e1f8e57de1a087144d3c735fee2b8213fcbf2b9e987bb33c2d4f811de237bf007402e8d7f895563e88b864f7933 -8ab0007ba8984dee8695ec831d3c07524c5d253e04ec074f4d9f8bd36e076b7160eb150d33d15de5dd6e6fb94f709006 -9605bbe98dadd29504ce13078c1891eca955f08f366e681d8b5c691eadb74d6b1f2620220b823f90ef72eb4ab7098e16 -942a083d07c9cb7f415fedef01e86af4019b14ef72d8ab39fe6bd474f61ba444b9aac7776bea7e975724adb737e6337a -b9a49a8c4e210022d013b42363ac3609f90ea94b111af014f2c5754fbc2270f6846fa6a8deb81b1513bb8a5d442ea8dc -99cd62b177d5d7ce922e980cc891b4f0a5a8fa5b96dfc3204673fbef2e7fb2d7553bbacd7b2e6eca4efb5e9a86096e2e -94e30b65b3edd7472111566dde7fab0e39a17e1f462686050f7134c7d3897e977550faf00174748cbeaec6c9c928baa8 -a32fbcb29f3391d62092f2720e92b6ef4d687d8a3eae39395e0464669a64a38fe21a887f60bc9519d831b9efde27f0f4 -8f1492c4890d8f9deecb4adada35656e078754dcf40b81291e7ef9666d11ba3747a478f9420a17409d7d242cecd2808f -8942960b319ef65812d74cb1d08a492334db58d41e8437e83ddf32e387d9f3ad36834f59e6a71d1afb31263773c3ec49 -88d692f4976c99e763b027df9c2d95744d224724041dfbe35afc78b1f12626db60b9d0056b3673af3a1741eaf5f61b43 -9920cd37eab256108249a34d3f1cc487829cc5f16d1bce3a2328fe48b4de735ebde56c8b5cf4e532a4d68792387257c5 -87d34c9f5a913b806504a458c843eda9f00ff02ad982142543aa85551208cab36ebf8b3409f1c566a09a60001891a921 -a2ee8339c96f790b3cf86435860219322428b03ea7909784f750fe222bc99128d1da2670ad0b1f45e71a6856c7744e09 -84bd257f755de6e729cc3798777c8e688da0251a2c66d7ba2e0ce5470414db607f94572f5559f55648373ce70e0b560e -8d0e170714ddf5dde98b670846307ab7346d623f7e504874bfd19fbf2a96c85e91351ba198d09caa63489552b708fbc8 -9484cc95d64f5a913ed15d380c2301a74da3d489b8689f92c03c6109a99f7431feb8a07d9f39905dcef25a8e04bcec9b -b14685f67dd781f8ef3f20b4370e8a77fef558aa212982f1014f14b1bdd8b375c8a782d1b8c79efc31b41eec5aa10731 -b22fb1541aa7d2b792aa25d335d66e364193fdbf51b24a90677191cae443f0ce40a52faf5983d2cb5f91f0b62a5f20e1 -b06fa9489123ab7209d85e8c34d7122eb0c35c88ee6c4c5e8ae03a5f1ae7c497c859b0d62e0e91f5e549952330aa95a4 -b5cd71617ff848178650e6f54836d83947714d2e074d8954cfb361d9a01e578e8537d4a42eb345031e3566c294813f73 -848d39ea2975d5de89125a5cbe421496d32414032c1e2fbc96af33501d3062745b94e27dfe1798acaf9626eabff66c79 -ad35955efd5a7b6d06b15d8738c32067ffa7dd21cf24afc8ea4772e11b79b657af706ce58a7adcc3947e026768d9cdaf -aff6d7c4861ff06da7cb9252e3bd447309ad553b2f529200df304953f76b712ac8b24925cf4d80a80b1adaa2396f259a -b4b88d35e03b7404fc14880b029c188feecb4d712057f7ba9dedb77a25d4023e5a2eb29c408fde2c0329718bdaf1ff63 -88e96720e2f7c63236cca923e017ca665b867ba363bc72e653830caf585d802fad485199055b5dba94a4af2c3130a6f6 -982675dc0299aeedba4b122b9b5f523ca06d54dc35da0f21b24f7c56c07f4280265fb64cec2f130993521272c3470504 -95c77d418490e7e28293169cf7a491a7dcc138362f444c65b75d245c1b986d67c9e979a43c6bd8634dae3052df975124 -8fd6c4dff54fb2edc0bdd44ccd1f18238c145859ccd40fbfbc1cf485264445b9d55ffd4089c31a9c7a0543cc411a0398 -b153eb30af9807b5fe05d99735c97471d369c8a1af06b2e2f0b903b991eb787ab5a88c6e406e86225582acf8186ad5ef -826b55de54496751b0134583b35c0c2049b38de82821177e893feeeeb76ceeb747c7a18312cb79a6fc52f2c18f62f33e -91650d7205b232c495f1386bea0c36e136a22b645ffd4f5207f5870b9ce329c44524781c983adf2769f4c05b28a8f385 -b8d51a39162ebb38625e341caacc030913f7971f178b3eee62dc96f979495a94763ea52152198919c6dd4733bc234f64 -a1fbd3673f2ae18a61e402fe3129b7506d9142f2baca78f461579a99183c596b17d65821f00d797519e9d3c44884d8a6 -b7c5f5407263398cf0ed3f0cf3e6fcebdd05c4b8fd4656a152cedcdbf9204315f265fd8a34a2206131585fad978a0d6c -94fa71804e90f0e530a3f2853164bc90929af242e8703671aa33d2baad57928f5336e67c9efdcbd92c5e32a220b4df07 -b75dcea5ad5e3ed9d49062713c158ebc244c2e4455e7a930239998b16836b737dd632a00664fded275abe4f40a286952 -a02f7b37fc30874898618bfcc5b8ff8d85ef19f455f2120c36f4014549d68a60a0473ddfd294530dfd47f87fbd5e992d -8b48e1626917b8ba70c945fe0d92d65cab0609f0a1371fd6614d262d49fe037f96991c697904d02031ec47aab4b32f48 -b368f02c21d4af59c4d11027e583ca03ef727f2b2b7918ef623f529ceac76753a05a4ce724ce2e018da6ecc5c1c1261b -a95cba06eeae3b846fc19a36d840cbcf8036c6b0dc8c2a090afcf3434aaf5f51ef5d14b1e9189b1d8f6e4961bf39bbf8 -b32ca4dfbeb1d3114163152361754e97d3300e0647d255c34ec3025d867ed99e36d67ebafe8255b8c29be41864c08edc -8e4eddefa27d4fe581f331314d203a6a0417c481085134d8376898f9260f133e2bf48576528d62adf29953ad303e63a7 -92b7d5505833f00d5901ae16c87af028de6921c2d1752a4d08a594eb15446756ea905b0036ae6ffe6b8374e85eb49348 -b50e9018d3c4e05ba9b28b74b6634043f622d06aa8123da7cd0bc482b3131912149214d51bdfd887484422e143c3c1c0 -ab980a2f5317dfcb92baa4e2b3eb64a9ac2a755da6c11094d57e781ae5cf43e351824f1dd3abb4c6df75065b3784210b -aaabb009dfcb0bae65a0aee26ed74872c226965c52a6ed0998209e020a9ee806297dba4b15845cf61e1a514de5d125db -a1fe78f67000ebb6e90fe33e1a9dd5489be6e15fedb93b2a37a961932b77137fe85d46e89a132ecf7bcfb7aa95e16757 -85bc6e7d660180de2803d87b19ed719d3f195ea0a92baf9bfff6113c743f4237f51355b048549913e95be8ddf237864d -87a167968c4973105710e6d24ad550302ee47fe1f5079d0f9f9d49f829b9f5c1cd65d832d10fe63533e9ad1fa0ad20f5 -b2ad1a7b95b8a89d58e0b05c8b04ae6b21b571d035ae56dc935f673d2813418e21a271cccaf9d03f0d6fa311f512d28c -8268e555319992d5ac50cb457516bd80c69888d4afa5795fcc693d48a297034f51e79f877487b6f7219cfdd34f373e14 -b235411f1f6d89de3898642f9f110811e82b04ad7e960d1dd66ec7a9bf21de60e00cfabcd3004f3b5c4f89f5d9c7422a -b6963effcfe883f7ed782a3df3c40edd70f54ceca551859bcccb5d3e28fd2c1fcbdd7acc7af24a104687fd02b53c704d -862645c944e1e2909b941578cc5071afd7353fed1c2c99517e2de7573037704ef5d35accf6ec79b8269da27564209d50 -90f585eeb1a053e2f18c1280c9d6a561c0bc510b5f43cd68370ed6daac4b3749852b66c371397b6a7c1ece05ee5906c9 -876d9a3686feb79ce781e87ac3e3fbeef747b6ab031285e808c8a73f73f55b44507850dcaa745c0791d2cae8ad61d74e -a7ecc3b8c10de41a7bd9527228a0d3b695a651a5b5cb552a3664a887077d39ee60e649aecd68ed630da6288d9c3074ad -83529f1f2b4dc731ea05c1ee602fa2e4c3eebe2f963f3625959ba47657be30716d64e05e8b7e645a98bf71c237d9c189 -834ca6b14428c30a4bc8d5a795596820af6f3606f85bee9f3008f3fb94b3adffa968d21a29e2588d7a473d8b5d3a8b42 -b8d08cd8b73430984fd16e8db0525ae2b76253c92cccd7b3470add4d12d082eafb55a72bde04870924d0bdaf61f76c5d -96ef32df669690c2391f82136fc720231e4a185c90ba79eef7beaadedf7fbeb56ed264825564bdc7da01829b47f4aa88 -93d637b2f04d71891a80a1ee93fd9c9046d671bc4c15c4e597cfcc36f4ae85a7efc111359628965fd10d36c39129b160 -89f28dd3f7bc43749d0e3750c136385d4ffaf2c40354d3be38341416d755de7886d8108d83721b36f99feb3bccd73c88 -ac6392e274659f4c293e5cb19859828f101959c4c0939920a8dfed0e2df24a0cbf89a7aa983e947318c58791c893928e -83b2d4ce42c2fa0f672cd911365d1f1a3e19f1c38f32bedc82820ad665d83ae5fac4068e4eca6907bd116898966fed92 -b5e0144d6e59a9d178d4ee9f8c5dba18d22747fcdf8dc4d96d4596a6e048e384cd1e211065f34109c9ed6b96010d37e5 -b1a65e6b38c9e84b3937404d5b86c803c2dac2b369a97cbf532cfdd9478ee7972cf42677296ad23a094da748d910bc48 -849d7f012df85c4c881b4d5c5859ab3fb12407b3258799cfc2cb0a48ae07305923d7c984ff168b3e7166698368a0653d -84d9b7ee22bf4e779c5b1dd5f2d378ef74878899e9dbb475dfdcd30c2d13460f97f71c2e142c4442160b467a84f1c57d -964e497ef289fac7e67673a6cb0e6f0462cd27fc417479ecb5eb882e83be594977fb0c15a360418886aece1aaf9f4828 -ae1226222098a38ce71f88ab72de6ededb2497e30580e7ae63d4829dcc9c093bdd486102b7a7441cb06253cf0df93772 -a72865b66d79009b759022e53b9eedbd647ff4b1aab5d98b188100d01fc6b5d8c02b80eb6f53dc686f1fdda47d4722b8 -93aa8d7d8400bdfa736521133c8485c973d6d989ec0a81db503074fe46957a3999880fd9e4e7f44de92adf6ac0abe99b -a75e5ab84399962ada1f9ebcfc29f64405a1b17cd0a983950d0595b17f66386393d95a5aa4c6c878408984141625141c -91b1e5e75f4b55ec2e8f922897537082a1414eedc2bc92608376a626d8752d5d94f22f0e78ea1970eb0e7969874ad203 -83bf9c308424ef4711bfa2324d722f550d95f37d7f7b4de0487ccf952b89d7219ca94e7fa25bee60309efefd9a0e4716 -a42060476c425ff7979456d3c5484bc205fb1ef2d7149554a4d483d48e2a19119f708c263e902943bcf20a47e6c7d605 -8170c45ea126e6367aa5f4a44b27f7489a5dd50202cb7c69f27a2bdf86d22cf6b00613b0080d75fca22439eeaaaa9707 -8e5a82da70617697e42c6b829e1889b550c9d481408fe4cf8dc9d01daccabdec01f9e1b8c27dc84902a615d539bf9bc6 -80606c51401d0bf5f2700ebce694c807ab1f7d668920bdcccef2775e0939472419a8f404567bd4f9355095517eb4d628 -a40314565d60d0ddf8995673e8c643b1baa77a143b3d29433263730a6871032260abc1320e95af8287b90aa316133da0 -a87e07e84435f9e8a51ce155cd3096aa4b20d18e493c9dcbc0ac997ac180f3a255bf68ccd8195f2564d35ec60551a628 -84d2ab98416643c457bf7ddd9f1aa82967ecea189db08f3558f56803fe7001693ed67ec6ca8574c81ec1293b84a7c542 -937c3b955889ceae77f28054ce53d75f33cfe3a04f28e049cea8b8ade2a0440d5e2e8c4f377e6c1ae2115d68cc95fc16 -885a911f16845fe587b15ce7cd18cc2a84295bf609732340f74e0f5275b698cffed3e9aa1440e19e6940a7fa8f24c89c -ad90059a50c399996aaa0a10a8f637b7bab0dd5d9100301f0159a2c816596da55c30b2568d1717705fd2826b117a42d6 -828de9ff1e095c189da1f1ee18009afe14613ac696025add6f4e330488e02d5f1a90be69edd9a17bfb3355a0ca77b525 -b7aedb8394064a58dd802be6457555c0cf7b94805ed00cc66f38449773f4b1865feaee3a6f166eb51b2123b89d853a4d -b09c564ff37ccea34e90f2d50a40919a94c2e10d4fa58ffeaed656f88f9f4ae712d51c751b1b8f443dc6c9506d442301 -b24882d66b2ebb0271ebb939c72308d81f653940e70d6f1bcaae352f829134aff7f37522cc42de9e7fe6243db2c4806f -8e6f8dd906e0d4eb8d883f527e926ad1d8156b500c4cfa27214450c8112267c319900de2443c87bed1e4bb4466297dd5 -ae42f4578e8d79b6aa2dca422ada767e63553a5ee913ff09cb18918116905b68f365720a1a8c54c62cce4475ba5cdd47 -ade639bcd5017ea83ec84689874175ed9835c91f4ec858039948010a50c2b62abc46b9aee66a26bf9387ab78f968b73e -8d310a57aeb123cc895ee2fd37edc3e36ce12743f1a794ad0e1a46d0f5e4c9a68b3f128719ed003e010f717ec8949f43 -8606c086fcf3e2f92c1b483f7e2a4d034f08aef1a9d5db9e8a598718e544b82544268a0a54dfed65b4d0e6027a901d47 -8ccd95dd673d8cfdfa5554c61bcdbe6bb5b026403a320856fe51571e7c59504fe1c035f2ad87d67827339d84c0e1a0c6 -955a7cb4afcf70f2eb78756fc3a82e85ab4330eb89a87117294809beb197d1d474001e25306e8ad71daab6928abf6d64 -ae6b44ec6294736ea853ddeb18fc00cce0ac63b38170ff0416a7825cd9a0450e2f2b340d27a7f2e9c5ac479b4cb8a5fe -a88ec3f12b7020dd593c54376597b056e70c772c0ec62c24c5bfd258b02f772161b66e5dcd95c0c0fceb23433df9ff23 -b4a83933b4de552dba45eedf3711f32714e58ae41d4dab8a6114daeb06e90a5a5732c70384150d04124ac6936ca9804b -b8b7c4fa549b0fa1dc9c1f0af0750d6573f1648767751882d41f0dd7e430e3934590757e1c8b436ac35381bdde808117 -ab598b911234a98cfde07234cfc0d2fddfc5cb9ea760212aa3e175a787ce012965c8fcfdf52d30347f5f1b79cf4a0f54 -a9d354f9dfbd1976e5921dd80cbb56b2e15df53ce099ecb4368eff416998130d7830209282aaf1d4354129845f47eb80 -8c889afff546c721969e4d8aae6e6716ad7c2e9c1914dd650e30419ee77d630efb54dfffb4ec4ff487687b1864bf5667 -94ed2fa79116c7c8c554dc306b1617834dd3eab58baf8f0d085132c4688ca4a6bd38420281283678b38970a3f02b9a94 -944fdc8f0516d22f1672193d183833d3e3b043e26807fb2123729a0216c299785b1c4e24b5aa56e9bbe74fa54d43e22a -a48521454a3e0c10a13d8e810fad9d0522c68eea841821a8e0e57811362f7064a8f9c50f79c780a02df7df8c277feaef -8f3d26670ab55e1bd63144e785203373b2b13b76cac305f0363e48a6339fac3364caa3fceb245527161fc2fac9890912 -b4d6fe71001cb4141f6d8174dd7586d617cfccb54471e1fbce30debc2b1dead62cab29565abb140b682811c6231acb03 -91dc8afc4934fcc53ef851462a055cc1c3c87d7d767e128806891738427606d2fbfa832664d2a7f95f8ffe2cf0c44dc6 -b297eb432c74071764272c1b1663547ba753e66bf026643bfc0e42a9c5cdfb05a88083ad67d6ddfe6ab290678c607b29 -b343d1df85be154faeb5b21741a5ac454ca93f70a0b83a98f5901d1be173a1b2969d43e646363c5d4975924e1912599e -b2d74a66e4dfc41128aee6a3f0ff1e5137a953ed7a2a0ab5a08d7ea75642f12bd150b965c8f786ad0caf55ef7c26be4f -a54141faa8dd9a567c3cd507e4fc9057535ffe352fa1e8a311538fe17e4a72df073fbf9371523e5390303db02321650e -8e229a58f1acc641202d2a7c7e120210b9924e048603b9f785a9787ad4688294140ef3f4508c8c332d2dedafff2485be -9523554c11d39b56e6a38b3b0fadb7a9a32a73c55e455efdcfda923aff1e9f457d1b7cbc859b5ecbb03094eae8b87d38 -a199ffdff1812aaea10cd21a02b3e7bf3d8e80e501aa20bb2105b5f4cb3d37265abcda4fd4c298d6c555e43fa34517f8 -97f1285229b07f6f9acd84559afef5daad4320de633c9898b8068c6cb3b19b4468b4445607559ddf719f97d2410e2872 -a1dfff82908c90fc38ec7108c484735f104e6ce7f06097e1e80f6545702b6a0bc2a2706203cd85162edb7e9294fdedba -b12a706311c617d6c19e964e296072afce520c2711086b827cff43a18e26577e103434c0086d9d880c709df53947b48c -88503a6f48cef2f5cd3efa96a5aacc85dc3712a3b9abbb720a2cff582a6ea3c2afc49288b6832c8599f894950843ac11 -83ed63e38dfbe062fe8c7e6bc2eeb5a116f1cc505c6b038990038de6051281f9062e761ea882906ccff69c9c5b8a4a25 -911090d5d0231dde1189408dca939daddcb69a812ac408d1326060f0220781bcc131c9229e6015540f529d9fb33d9b0a -8a8352f1d9e5c7e80276e4448f997d420d5a7e0e2d5be58ae4106f47f867d1caa478b2e714d9c3263e93e5cc4c7be08b -9362f1ea9995f9b3850ebb7c8d5bf95927ab5ea25ee00e85d7456b3bf54459798b1fffde049d445c0d0587b0ab0a1694 -8859502b391273f4a00b6c0e87e5cdae676b7baf6c402f12b3360db6a5dfb4931ece4da0e1e4d98c7a71c3d01a183a9b -a9a5edf474120f9bbec9485d8b1e6f83be68b10de3d765219b0bf3e5d2840e478f1fb2bf806d78a8b8ad22ec50cf7555 -82c75daf983b06e49f0d75a042dfaae8cc92af050293d9059d6e8b01ca3ab2597e7adfc1159ed805513488944e739fa5 -a5cf240f04a9bfa65b811702c923d209e01f9535e217fa55ae3e0d1eb3257d6749e5587e727091e860609d1df29a1305 -95608ab8ade1c9fb814bad78d9cc99a36ad3e9562d5319830e4611ceea508ef76be04639294be9062f938667e33bce6e -8e44181f35c38b02133473de15560ae6588ac744cfdaf5cdfc34f30ca8e5ff6c85eb67dddc1c7d764f96ed7717c89f06 -8007b6ddece0646b7e9b694931a6a59e65a5660c723ebdffb036cf3eb4564177725b1e858ed8bc8561220e9352f23166 -a2d9d10fa3879de69c2a5325f31d36e26a7fb789dc3058ee12e6ccdda3394b8b33f6287ba1699fce7989d81f51390465 -81993d0806f877ca59d7ffa97bd9b90c4ebf16455ea44b9fe894323c8de036c5cc64eacf3f53b51461f18fa701a5860d -a20030f457874d903b2940ec32fa482410efecb8a20e93f7406fc55ab444e6c93fa46561786e40e9bf1e3c7d5d130bc8 -80c72d4985346ac71a231e7bbbb3e4a91bf50142af0927e8eb86069303eb4ce7fca1aa5b919d5efc82f2f09b41949acb -91b857d2f47f1408494940281127ba4b9ac93525788e700889aa43402eedea002e70eded017f5f5263741ed3ee53a36c -97445d007f08e285ea7f4d25e34890e955dac97448f87d8baa408e826763c06cbd58dd26416ba038d6c28f55bcea2d3a -a409c89526c2886f6a6439e2cd477351fc7f886d1a48acc221d628e11895a4eedd426112a368a0dbd02440cd577880a8 -a2c6adc7866535f6ffc29e00be4a20fa301357e1b86dff6df5f8b395ad9fb1cdc981ff3f101a1d66672b9b22bd94ec0f -8887fc53ffc45e4335778325463b3242190f65ae5d086c294a1dd587f62dd0d6dc57ca0c784bf1acaa5bbba996af201c -9731d3261a7a0e8c7d2b11886cd7c0b6bb1f5c57816944cc146caa518565034cea250eeee44ddffaeb6e818c6b519f4d -afe91c706efb9ee9e9c871e46abde63573baa8b2ea2b61e426cd70d25de3cc8b46d94c142749094287a71f4dfadd3507 -ae7bdf6ecc4fc0d8d8a7fa7159aae063d035f96ca5a06b6438b6562a4eee2b48d9024dbe0a54cfd075eac39b7a517f2b -a382e5205bfa21a6259f42e9ebc11406b5da2aad47f7a722212fdd6fef39117dd158a9991ff95e82efa0826625168a1c -862760c80bf44c2d41c2a9a15c887889eaeea32acc894f92167fb6f72593377c228499f445ccb59794415597f038ac9e -b4e96595a91a611c4563d09f29a136a4c04f07be74dd71a6bbabc836617ecb95494e48971a8229f980b2189fd108d2e5 -b5e7200357317c36244c2e902de660d3c86774f7da348aca126e2fc2e2ba765fa0facd29eebcb3db3d306260e91a6739 -a64c7133156afee0613701189c37c1362e2b4414f7e99408e66370680c554de67832c30c211c2c678dab5cfcdcecb3f7 -88f4cb67b1db497a91a0823ee3541378133eb98777842d73e43ab99efe8aa52fa02dfb611c1691be23684618394988d6 -89a9382a147d7387d0ff9516ee0c75cd1f8ee23333f4a2c9693d1a8cbe03680bc5b10c43c238c2190db746cac409bf39 -ad510bcc067373d40b05a830bf96fac5487de1ad5b708a13f62484c09b00fba6c5b00b981004e5ab3f28e55c9a5bce26 -8384156d7117675547279ad40dc6bf81e8f9a57b2d8cfebeea6b9cd1d8534dc0cf704068bc3ba0815010cd8731d93932 -a818fb76e53165b2f86c7f2317d64cf5e45f48405a34560983cd88bfbd48369e258ce2952233a8ce09c464e07afcade6 -ab19a4ed90527e30796064634b66cdc023bc5966e2c282468f5abef7879fc52986d5bb873a796b077d10e7b374b60309 -a17dafe2484d633fe295f8533662631b0bb93cdb4e7cd6115271f20336f602f7f8b073983cd23115093c7f9891c4eef5 -804acbc149d0334c0b505a8b04f99c455a01592a12f64d1ec3b82b2f053ccc4107e47f418f813d6f400940c7c8700a4a -965e097a825d8511d095b247554ec736bcb3701ead3ba785bd425cbabd56f4b989764e0965a437fa63e7e16efd991fc0 -b6701675ca27d7a4084f06f89bd61a250b4a292ee0521b2a857c88c32b75f2a70b97f98abce563a25d57555b631844e0 -abbdf65fcbdf7d6551ccd8d6e5edc556f1ecd275ccd87ee2bda8ea577c74615f725aa66e0911e76661a77f5278e0c2b9 -ab715ae372c900239a0758a3524e42063afc605b8fb72f884dc82ab9b0ff16715f3fb2fd06f20f15f9e454f73a34e668 -b45f41ea1d25a90af80a8a67c45dea881775fed000538a15edc72e64c7aa435a5e4375dcdedc5c652397c02b0bc61b16 -86f7be9252f8ed9078e642c31a70a09639899f7ffcd7faaf1a039fec8f37e1fa318fba0ed1097f54fc55d79900265478 -a30e5ed4277dd94007d58d5a3dc2f8d3e729d14d33a83d23c44ddfc31c6eac3c6fe5eb13b5b4be81b6230cfd13517163 -87e723d916f5fcda13fab337af80354e8efe6b1c09ae5a8ceeb52df45bfca618eb4bec95fefef3404671fb21e80bf9db -a521b8a04dc3abd3e9e0454b9a395b3638e5394dc2d60e97fda61b0a1880d1d73a64a4633f3d7acbd379bde113240d03 -851686c79c5403d5f05fbaac4959fcbfdfb51151bec55e10481b3c16e3be019e449907ae782ca154f76a805543d5755d -8ec1929e746b6c62b0c3fdd8f4e255e5c707e6e0d8d57ff9e409ae2dd6e76fdb50af923749992cf92d1b5f2f770bafbc -9175f7b6820d47205c9e44f8c684833e1e81da46c1fdf918a4dcafbc3231173f68370d442a20e45f8902bcab76a4e259 -b4f66c698115333b5ac00c9fe09aa9e1e9c943fbb4cce09c7d8a6ed4f030e5d97b48e944fd6d3e69ac70f1ae49d35332 -b958878b875eead61a4416a4597b1c567ddbb1eaaa971033f4a656f01a277822c1f4ea3972045156c2a5a28d159f5ddf -8188de8ad5258024d0280137a40909d24748137ac7c045dddd2bc794eac8edd5850b9d38f568fa8174b2c0593bb57e96 -91152c7bafce7a0358152221081bc065796fa4736bfc7d78076a0a6845287cde2ee2a2c9b96f500297c0a00410634888 -a5328ab939a2d3bd4c21e5f3894c02986b6590ad551c7734be3f4e70380eb7bc19629e9031b886ce3b4074ee4edee63a -97c4d49db40e266bcedaacb55edca4e1ebf50294679b271f3a2332c841705089b5ba96ef2064040fa56c36bb1375a8d9 -85cf0514f340f9d865b32415710d7451b9d50342dbf2c99a91a502a9691c24cd3403cb20d84809101cd534408ddf74e8 -950c3d167f59f03f803dcba3f34fe841d40adc31e5be7eefff2103d84e77a7cbe4f14bd9c3dfa51cde71feb3468a9c00 -96a69624e29c0fde3b92caf75a63ac0f3921e483f52e398652f27a1ec4e3cc3202f17af1f66224731bc736a25638d3e4 -aeac4170cf4b967227f66212f25edc76157eb4fb44c84190b520ecc2946470c37da505790e225fd1b0682bef7fc12657 -a94146a04e3662c50c2580ae1dba969cbb3fb0f43a038729c9e8be6ed45860b2c7de74f248dfa50ccdbe2ecaf3f2b201 -917b8e2880e85b8db723631c539992ec42536146e7091d4a3f87d37f051b5da934d84393523814f19962c78e6cb12ef8 -931f140ff8f7de79e399f5cd8503558d566b5c2ab41671724dd38aed08dd378210f01ac8fa9911f3047993dbc10cf8c4 -859eb9b560bc36273694f8ae1a70d25e7f206013597c4855a11328162ba1254bb736f1ae41240c8ec8dea8db035e08f2 -b4ad2cb2c3a3e6ab1e174f2dbfb1787a8544f3c9109215aa6d33265ef269455e3cde9858738b4fe04711a9cf9050e7d4 -8a3b342b87b19c0cdb866afff60317e722013c02dee458ba71e7123edc8b5a9f308c533b9074c7dd0d684948467502d1 -89185ac5cc5ea8f10a1f2a3eb968bb5867376d3cff98ef7560b9a0060206c4046ff7001be10b9e4d7ad0836178eba7e4 -845f48301f25868f6d0f55b678eab1f8458e3321137dba02b4cfbb782cbc09f736a7585bf62f485e06a4e205b54a10b7 -931a6c523d4a66b51efadb7eefadba15bf639d52d1df5026d81fd1734e7f8d5b51b3f815f4370b618747e3e8eb19699c -8eb3a64fa83dcd8dd2258942aea3f11e9cf8207f2fdd7617507c6dae5ea603f9c89f19d1a75d56eaa74305a1284ce047 -912a5050ed6058221d780235fb0233207c546236316176a104a9761bc332323cf03786dbac196d80a9084790506e0a88 -945fe10ec8dc5e51aa6f8ba7dace6f489449810f664484e572bfe30c2fe6b64229f3c8801e2eb1a9cb92ff3c4428cdf7 -b62383bf99c7822efd659e3ef667efee67956c5150aea57e412cbd6cd470807dfaad65c857fada374c82fcfca2516ad1 -a727a31c45b2970d08a37e169ea578c21484dde15cb11f9c94eaaf3736652619ce9d3a44e7431d50b0e75b658ebbc1da -97bf54ea9b84b82e4616027bd903ef6152439f1c6a8e1bae6db1d10fdf016af2cac10ff539845833dfd1ddad1403aa8c -a08cf36437e010e59b2057aedb7192e04b16f1cc66382cdef3490b7ad1544ae51f03e87cba0fe43a275841c247a2a0cf -acafab9fa28c1a607df2246490b630ddda1ecf0885ad24c2ecb2c2c1b7b9c7de8066714bf5b9b25f61981d08576789ec -851f0375128d2782586223467d0a595f4c5baa79616622a32f7d6ce1f08af06f8a109bd6527f88d93367dba17be661e8 -a2f1187c2a7cbf776653ff834ed703dd32e68eaf36f0700709be929f4c0ce5fa1d9930d1e3ea2aa01c7a16239e66cb33 -b3721f4a5d24ca112f020cb3f849543bf0e7f84b470fb00126ae80aaaa6f2c208d8359cd82ad9fbafd3ef2ac70656fb2 -98773ac3ce9528c73cfd8e7b95976ce597f67e146357642ac4fb6cb35046f3f39cf6c4a7b5af5c7740dda358aa0d2d08 -92c883a5d820541692af75be1b25dd4a50a4b91f39f367a551a7d5ad6065a26b60d68221a01e4950559717b559c2626a -b82e46dd25fd1234dad26fbcd8bb5177d7b87d79d362ffb9c2f6a5c16eb2ff324d135996fcd6274d919634597869d772 -82a53ed356ced5e94d77ee2a7f6e63f2ad8240aff2d17c5012cf5d1f18512c88c24793339b565dfbb659bd7c48dcbcd2 -84d20c7859b35a1cae1ff2b486d50822f9e6858b6a1f089ce4c598970e63e7c0f7dfbcb3337845e897a9dedf9d449dd3 -974892e5cf5ee809e9353d00e9cd5253d04826a8989d30cf488528c5dcdcad7650e23b4d228c3eb81f6647d2035a9e02 -b2327854910dbf3d97fe668da5fc507e179c4bc941f39bdd62e8b6035f004449c467240f656417e501f32dee109f0365 -88888f73475613d45d0b441276b1dd55835b69adfb27e26c4186936dae047b85478cca56be8dc06107b89a28f3bbb707 -836ba22e40511feff81a5dace3df54e2c822b55e66874dd1a73929994ec29909ffc2a8e39bfc2d16e316b621eb4a5ec6 -a754cedcccf4165a8d998f326f3f37d2989f92ca36d9da066a153c4aab5a62bb0011896bcbf90f14c18e00488d4123bd -86c26fa9584314292c4b7d6fe315f65dadd0f811c699e6e45c95a7a4ea4886c57dc5417b67edd78e597d037c7689568e -b205589648aa49ef56637712490e6867aa3b85b2b31e91437a249fb51bdb31401bff57b865c9e27293b30014b4604246 -afab0843ede582e5a1898ee266235066b94ea378884eaf34919ceaacc0e2738e1074b6ed41e0a1dd9711563e24f0215d -996ed65fbcab7611eada5bd0fd592d3e44705098b8b1dfba6dcdbdcfa1382fe893fa55270a0df0be0e1938bd71ab997c -881bc448a5ef8c3756b67ecb1a378a5792525d0a5adb26cc22a36c5df69e14925f67c9cb747a2f7e5f86ba1435509d7c -b219303c02c9015c6a9a737b35fb38578ab6b85194950a0695f7d521206e1e12956cd010d4d6c3bc3fafd6415845d5d1 -91748829bbd005d2ec37fc36fee97adaccb015208b74d2f89faa2e4295679f7685298f6a94b42d93c75ca9d256487427 -a41d6fd33b9864ebc404d10a07b82ba9d733e904875f75526d9a1f1c1c08b27160dcdb9023c5d99b8ff8a3461d57281f -b68978d39c97d34f2b2fea61174e05e05e6e49cde587e818b584201cf59b7096cf1807b68f315119c6db8d6110b28a9f -b64e66cec798022d64ce52477475d27ea7340817fe7f570617f58c3a9c74071d7ea6b54743d4f520b62aecad9a3a6620 -87b2b9e1c1786b7824f239a857024780a1457e51c64599b858118885833fb87a17d408bc09dcc0607d15ec1e53683a74 -9814799bac07dab4f0c934cc3c051676ca13abd49cf8d4739864e5bb9f2a8474897695113f49239f28832a8658332846 -806931a1526a843a9c2045943d616a8102b02b1f219535a1f1fbda659a1244f1bfead52ca7f1851ff8a97169b91c9ec0 -b8678249595a9641c6404c35f89745b93d8e7b34d9d44da933a1b2f1606972624c5108f1c04eb42e454d0509f441ed9e -81426714851741045a4332eb32b6dfe6422a4a2e75b094fb7c3f37da85648c47ee8af1e54ba26f4e1b57ebe32d0e8392 -b7a1875ea3f119fe0429fd9068548f65cf2869f8519dbbce0b143e66127cb618c81d7578e8391d676b2f3963e9d87f43 -872220a803ea0c6294cdc55aceea42cfacfd7a482982bcb90c0361c351a900c46736a890609cd78f02fb5c8cc21fa04b -974f0380197b68205ff4bb2c9efe5626add52c0ad9441d7b83e6e59ddb2ed93ad4e9bbdbf33b3e0a206ed97e114ea0f2 -a840f2d9a74fca343aedb32ac970a30cbb38991f010d015dc76eb38c5bb0bfe97dd8951de925a692057262e28f2b4e9d -b0913c3ce61f12f9fdc4be3366ed514c3efc438f82fc58c4de60fe76098fbc033a580ec6e4531b9799611c89a8063a66 -a0180d533eee93b070dac618be1496f653a9a0e4e3455b58752bf1703ec68d0be33ec0b786f9431ef4208574b0ad316e -a4a6b871bc95d3aa57bed90e14a0a1dda6e7b92b7ae50e364593ce6773fbf736672b1f4c44e383af4c3cc33e017a545a -a3f44cf19fe52bacc4f911cab435a9accbe137bdbe05d34bdd8951531eb20b41d17e3540e8d81e6b3eea92c744562ee5 -ae6b6d0ff3b30ff0b7f9984ef741cba27ffb70d558de78b897199d586cf60622ec2d8a9d841712fe719cf0f97628842c -87abf72f98c81d6d3a57ab1e224fe4b502ab0d8090d8abc71791271550b721c220d4e2e7da3be94a20c0e63d98e39a50 -b2f73ebdfe7133af57353052f4599776e16862905e64d97e1020c4bb84132e476d1ab79a9fb71611410f3f9d56c95433 -ae1a928253af2b210d31e1b64c765fcbd20a96b8d53823a6b9b6e7fc62249abf4a66c6a6aedb0b687e7384af9a845e0d -99c54398627833ca1435718154de171a47c709e4d5c58589fdabe62e72f2a7a11ae561bc31d7cbe92df4aff23e08cd0e -8a1310bbf1a31fae18189479f470977d324dec6518a5d374ab2ffcc8f64412fb765df57d2ddf69b9a6efaeb2b4c723b8 -898312c6c0d3d3438229b19a8a233eca8f62f680c2897f4dd9bbcacde32c5996d56ac0e63e3e9360158761185491ce93 -81b3f965815b97bc6988d945496a51e4a4d8582679c22d138f3d3bd467ed1f59545da2d66e7b4c2e0373628ae2682686 -b9aca91c6e6f4199beb6976b28e0e35e36e8752618468d436b1cf00d8d23538d0747920e5b2c31f71e34dfe4d5c86a0d -b908f4aa18293295b8cacfda8f3ea731bc791074902c554764c603ab9a1de1bbc72654fd826bffc632d95ce9f79c27d9 -a7316ae1baf4b1196961d53be7fe36535499287aba9bc5f3bed4323039b4121b65bb0bd15a14c1b9cd8b65ede3566da2 -815e39208f205c5fac25ac9988c14a62ab01657c7737a24472d17b0e765644bc2cbb7ff1e8ea169b8b0b17b6996c4704 -89a451d2b740cdaa83ccaa9efb4d0ff5822140783979a4fee89eda68329a08c018a75d58bd9325bdc648b0d08340b944 -8cd08f768438c76bae6bee1809dd7be38ec42e49eb6a4d6862db7698f338bf6b4b409088e4f3d1c5bee430295b12a71f -a4bd8c312103a4bfeb25b0cfffec7a1c15e6e6513b35af685286333c1dce818ffeb52826f2f5bada6b67d109c4ab709e -93afbef5382d89fa539ca527f3e9b4a8e27ab69fd5d5023962cc6d8932b33cb4dfc5f14343e1a3749bfd5e100c9924e5 -8d8e69d046992ec9ff14f21840809166cae8e0e9e7c8f14fb29daf163b05abe6611daa4010960e1141c5ab24373fb58e -96f8e72e96ba673c9265e9cc312f6b9c3b931745fc62d2444d59404bb08e5fb02ddb60715181feb9971cbd954526a616 -8d444c2b8e4d0baadb79e3147a2ee20f1bfe30d72eb9a02f15d632185fb8f4e8c3116066f7de1ebfe38577aaccacb927 -971410c0b10e3698f4f64148b3d2148fc6a4a22217fcf4253583530a9d6fbec77e2cf6f7bb5e819120a29c44653de3fc -99e7e1857bd5ee57007b7b99494b1f1c6bf1b0abd70c054770427d59a3c48eda71b7de7a0d7fcf6084a454469a439b41 -8c8a4cd864894f7a870f35b242b01d17133cb5dfdf2e8007cd5f1753decc0d1fd41be04e1e724df89f1d727e760fdb15 -890a24328bdeaaadf901b120497d1efa17d798f6f4406661e46ecdc64951f9d123d724ab1b2b49e0e9a10d532dd6f06c -a7cbe1f42981c9518608569a133b0b449e9d67c742d62f0d3358112c97e65ee3f08ec0ff4894ce538b64e134d168e5c8 -87c976dea77b3b750c3a50847f25b851af95afbaad635f9bb9f7a6ba8f0c4faeb099dd777cf7eac41072a526474cb594 -9882aa5e9bcc4ea2dd3de4bb5a0878a672bea924b50c58ae077563b6df0268910a60e969d3da1694ae7394ad0d9acd3d -90d35ce677327c461fb5dcb032202e851af1d205e9d21a34ed2b95635f13f8fb8dfa470ea202ccfa4b08140d0cf1d636 -b3b4cbb521cce2b681e45e30a4d22078267e97ccdbdc611b2c9719705650dd87e0ca6e80cf2e174f8f8160be94232c36 -95892b00478e6b27ed09efe23a2092c08e691b4120336109d51e24efbf8aba31d59abf3cf55c0cdab1c210670b9743ba -8643018957fb8ef752673ad73102d0b928796c6496e22f47b6454c9ed5df784306f4908641ae23695db46ebfcfb0b62b -b166ce57669bf0543019ecf832d85164c551c3a3a66c05b17874bccd5d0ae87245925d6f8edc62ac13dbd5db265823a2 -89fb4800ce4b6c5900d58f1a216ad77a170ea186f3aa0e355840aeedcf374e92a15ae442800c9d60334544be020b17a4 -8c65e586215a97bf11ffc591bce5147b4e20750e82486cc868070c7736c3de697debc1f335674aef24b7afdd41922d93 -90f68ce0c97d2661d3df1040ce9c4fa106661a719e97c7b2d7c96f0a958930c57d6b78d823a2d41910261ae1f10e7b0e -adda85e1287371ccbe752aa2a3c1d5285595027ba4a47b67baf7b105a22fb8548fa2b5b3eb93ca6850ecc3995f76d3dd -b26535d218f48d6c846828f028c5b733594ce01186e22e412dd4f4a45b3d87d2ac1bfe5d54c987e4e8aaddeb86366d7d -a081bd86962ea3d4fd13df6481f3aeaabdd7ceae66f7bbb913e601131f95d016cf147d045253d28457a28b56f15643c8 -b3d852cef4c8b4c7a694edbf6f0e103f3ae7f046a45945c77a1a85ec8dad3423636a89058fafc6628aabff4dbb95c2ba -b424ffc94e06e6addc90a6324e0482814229b5902e2a266d0c2d716e40651b952bc9f00d7dad9b6050377a70a72c7f24 -b2cafd908cae0ca22eaa2d9a96175744897a20eb7b0a6d43b0098cb1c69e3cb55373888201e4ed32816655eb7d8a3dd7 -b61177ecf1ae9d7e7852d98cbf6080d9f1e33c90f2436720b4ea4690437e8c7850c3754768fc1312cb4e838d855c5ccc -81b486644e1ae22cf0ba3a37e1df34dc186c82a99ab35ad6f475c37babdea574ddfbe5811d4aa020581292a793d66bd2 -97ae848a823ea7a99f91834e537fb47208f616c08fe32c8f8fe06bd35c9b638698c513265d0b4de9e572a2f9692b98e2 -81b8fef4ea5d399c65e78f40e47c559ada86d890777c549ce362e7ab81b3bfb00d5ff4ae4ee30fd7bda7ee90d28f85d8 -aada6912cc748923ea40bf01922c06c84bc81b2ab0bb3664a0579b646f03d47ce88de733ac7f2cb9be4a8200584cdb71 -89b48b9c79332f8f58eac9100ada5bb7decdc4b1555c5d383e2c1ce447efb0ebdff9c50bb52bc3042107f33a61ab2520 -a32ecca8b870b2b6e9d10b5c1d8f925b3d629d271febad65abed316262bb283c60cade0e91047fbd0fac53ac6db372b9 -b829cd1f13409e3573a8e109c9541b0a9546e98b6c879a11152b5564477ada4d8cb4b3079040e05a5cb63d75ef11eaab -91f3b100baa19e960b170fe9e03b799faac5b9c6f305c56115940bf81f6e64dcb9cda77e8de70ed73a21c0e8a74acc58 -b25b5e872c84065aee04822bbcb4f3bdff57fbd7cea314c383765cc387786c17de3d5bb3de3ae3314bdede14542bfac6 -a89bea9eca1f5a17a3efccfa4987d8e5366b0dba70ef1fef43aaea83c528428d1498c8b056ac27f16e8946ee93f7028e -818a1f7b0b8b06ea0514d6b4a0296da4f69cb18ac8e48c5579e6ba2880b06215fcbe81672566b8b94fcc3c0cadecb191 -98dd6e6b4b4d63d9aa7464a2be08ae8babac4da7716a3f109340bc9187d59c6ca0c88e6877a67c65096f64a3ced22a4b -a2069c5bac4f6590042aefb37570cc20908b0df9d0130180f565ed8a53b4ea476a274de993561fb4d009f529fe7aa1cd -860b7ec2410f033a7b0c5ca08f88a0ad29f951a5ebd5383408a84367e92f1bd33bee3b87adef2466b7e33b47daabf30e -a408855a8414102c3cb49f47dda104edf0887e414723da59b6b6537ada7433529f6a4d1a4ad4fe311c279213cdd59356 -8ca0d81dcb43b89a4c6742747d29598ede83a185a8301d78c6e7f1c02c938441360a1ab62a5e571e3eb16fe17131cbc0 -af7875a495cb4201cdb26e23b7c76492f47f8dd4c81251de2397d73d4c8d5f419cdbad69ba88ef0dc3552e460dbcd22e -80e901e433dca34f3d386f39b975e97f7fc16c7f692808221fb2ee60c1aaa8db079cc48c7d72fd548aaf8dde8d0b8f05 -b6062319e13926416e57a0ffc65668bfa667e708a4e3f5cb26d8a6a32072f5b790d628052d5946c5068dd17cf4a81df8 -90094b569e8975f8799863798912dbf89b12d2c2d62b3e5fac7efc245436fcd33af23b8c509ae28c6591d3f020966e06 -a504f72d3d06a0c9b188a1035c7c6d80047451c378b6c5b2ffa1f8cecdb64871cb6440afb296974c0a528e5e563061a1 -959061c4924e133a419e76e000e7c62204093576ff733ce0b8ae656ec6045ef94c5a1f3c934fb76fa9188c5eb397a548 -a8b9d0b58de38cb86cb88fb039a7c4c0c79e9f07f03954af29013baa18fc2633883f8f9ca847209c61a8da378f9075d3 -b16d8341da4ff003ed6d1bbdb3be4e35654a77277341fe604b4c4e4a1cb95e61362094fb3d20ab8482ea14661c8b9852 -8ea4ca202e3aed58081a208a74b912d1a17f7b99a9aa836cfaa689a4a6aa9d9fbfe48425cad53b972000f23940db4c5c -96a372f55e9a25652db144ec077f17acc1be6aa8b4891e408f1909100cd62644a1c0296a3ddc38cd63ef46bef4e08462 -87df40018ab3a47c3782e053dbd020f199fda791f3109253334a71be4159f893a197a494de8f94d6f09efa5811a99977 -aff82d2ea6b3ad28d0ca1999a4b390641d727689dc2df6829a53e57d4f6418196f63a18495caf19d31fc23fdff26d5e2 -9091053c4a18a22d13ad309313b6d2133a96df10fe167f96ec367f9b8c789ecca7667f47d486fc5ba8531323b9f035ac -a4842090515a1faccc3d8cadbb234b7024254eba5fdfcef0d15265c7cec9dc8727c496ad4e46565d1f08504c77e511d2 -b1d8a37b1a97883d5804d0d2adaa8dbf0c2d334ef4b5095170b19613fb05e9c648484093d0c70d545cf9b043b449c707 -b1ea40f3dd1c3d437072f8adf02c32024f32488dd59389d1c3dfe78aca3df0bab7767f6ded5943cc10f50555da6092f5 -ad219c6a8149f10391452892b65a3268743baa7402736f810a35d56cdfed83d2172b03f15c205f0dc5446baf855907a5 -afe44c3e1373df9fc53a440807fa6af8ebc53f705e8ee44a162891684970b04fb55d60bc2595626b020532cb455ee868 -859ae154b017eae9be9da5c02d151de747cc23094d8f96d5db7d397e529b12fb55666f55e846e2bbe5e6f5b59c9d8b05 -8aa01354697de23e890fe54869cd3ec371f1be32064616ca3a556d3019541ba8e00d683f1396ca08e48988f7f7df5de4 -b8f682487460b9d825302c40a7d6dd0353ff43bf24cd8807cdfa46c043e3f5a7db182b27a8350b28e91888802a015af4 -b6d4d6c3ac40f8976b50be271cf64539eb66dc5d5b7cec06804dfe486d1e386037b01271cf81ef96dba5ea98a35a4b43 -9385a2fd1cd3549b0056af53f9e4a6c2dfcd229801ffda266610118ade9a568b33e75b6964e52fcc49c8e3b900e1e380 -98f4aa0e4ef039786cbd569536204e02b0b1338568d1d22bb5bc47b5e0633fb7ffe1da93eb9d825b40b9b7f291f84d51 -b7b3460cf706dc270a773c66d50b949dabad07075021d373c41fbb56228355324d120703e523ea3f345ef7249bfff99d -81b826255f95201987513d7987cdc0ca0529524d0e043b315a47583136dbada23a114d50d885bb3f855fa8313eff801a -afdc6c35161645a14b54f7b7a799910e2e07c8a5efe1827031a2eecd5d9263b3baa367fdd867360fabc41e85ab687e74 -817b361ce582153f2952f3042e235ee2d229e5a6b51c3d3da7bbe840b5c6ec2f01446125045848d15fd77dc46c8a8fe2 -aeb599265398af6e5613297d97d2b70222534590fcbd534d68b24a0289b6366ac8188b753f6fd1000ee73ef44f8fb7af -a5a9e528b606557be64460c1ad302a43e741357827b92ddc50766a7e6287740fc23bd528d9faf23345ce8bff527d5bc7 -a8d3b3b438d5f75efaae6ce7b67c2212899ece5b5bdc9bac655e271fd1846ea8560e646fdbded3d9363eefe29473d80d -984c7976d557e2f591e779c2885f5033da6f90d63a898d515b5da3adbffa526764cd8eb679b771573fdf7eed82c594ec -8ac748689cc3280e064807e68e27e234609e3cc87cb011f172204e1865ad7fdc78bec1672bd6e6fddcf4e7902b0f38bf -877bb392059540b1c8f45917254b8cc34fb7e423952bdc927e0a1622efec4113fa88988686b48134eb67ddebcb7c3ef4 -ac04b154ccd307ca20428091585e00121b61bae37b22d5d2a1565bc1134be3c81ccf3715fffebe90744164e5091b3d9a -90745c04278c3a47ceea491d9dc70a21a99d52648149b1ab623b5396b7d968fd3c4d1a2d08fc5638e8790463e0cf934e -80bf26ca7301e370f101cc69e7921e187cf5315b484fc80a872dec28bb65886569611a939958f4a3d2d3da4350011298 -87cbf4d6f0c06cc5f24e0f173a5f2f9bf2083a619dcce69a8347c1a6cd1d03325544610f2984eb87a13241e6ab9a22b7 -8909368817a515789ff4d19ed26afafa5729a24b303a368ea945a9287bc9facec9e1c8af19cbec8dab4acbb6a6ddf6c7 -ad8d2f82b08e0990dfd6b09fd54db3a30fd70aad218275550f173fd862347e1258a4716ca2bf4c40e4963850b2277eab -a9467ceacf9337cae4f2c7eeb3e03752ac7d77692b07d5e5d75c438fbe7dc2029ff84f7759372a0ddfa953b4ec7e9e38 -a5feb7669e84b977cb1a50ff3a39c28f7ad1ecc33a893fdf1ddae7a0d8a4c5f6fbaff25cc56631b708af038a961f3b55 -8f2e1fa07963ba18db890b44c3b9ae7f8992b702a5148679df69e4d9d4b1c082b2bd2ae53f96a4fe24b54f3dc1588f17 -896778f35cbecb43f001277c306e38a9c637275101f1a09546f87378b10ccc025644bc650b3b6c36e4fd0c09fbb3df35 -91dc702778176a4d089dc65502d703752dd9a766f125ffef26bdc38fe4abcae07cdea14102c3448d10f8dd6c852ee720 -a5df3004cec6b68b937cadded0dd2f48bd3203a903a3e1c22498c1193f4567659ecaaf3deb7ed7cf43796da9188f5dc6 -b18b4c8ffcb8599c24d9851abf8ee43047cbd4c9074c9cfbf88376a170da4554978988f550afde8a45306ca32713c204 -8370bc38c84da04d236e3c5a6c063e1db6613dcc4b47239d23efdcb0cf86846955b60da3e50f17b17cd3f7e0c29302d9 -ab7d6bb6be10aa52ef43abbe90945e78e488561afb959dc2fe768f8fd660d267c7203a2b7bdfa1b44cd07898f4849e06 -965c96047d82d76ec2cfe5035fd58d483cd2cb7f65c728ab3049562c5d1943096d6a5014c05babc697d79c07907cf284 -9614f7006aef6f0478ebd37fbf17276fe48db877394590e348c724059f07c3d1da80d357120d3063cd2b2bc56c58d9d6 -819c7b2a1a4bb4915b434b40a4e86dd7863ea85177b47a759bc8ecd8017f78d643982e8a091ee9a9e582f2b0208725a5 -8e159a185b5790a3ed444b6daab45f430f72f4ac4026750cbd5c7cd7947b5e00f2b10eaaf5aadf8d23054c5b29245546 -b48cb6f6c0aaea04833e10d735b67607846158b6663da380ef01c5bca3c9d537611716867dc2259883e5bc9daed57473 -8b48ce8b5ab76b7d662c29d0f874f5eec178baf3f14221bffd5d20e952f54f3ed053182a486da1d1f400e0acef58f673 -b6fd3cba177bfbcb5e7ebb1e3c1967cad5848c09c615ba2a6c277908f8b1f4f1ac5f184c33f2a401e8bdafcaed48bb88 -abd8f44c4a447de8fde1c119f4fd43c75b4cc99de9c817a019d219d4b2ad2a73b60606c27e36e9856a86bf03e7fc861f -af9f7e8b3e9e8599c7e355433c503a05171900a5754200520fd2afed072305be0e4aebb9764525d2c37a5a7eede72025 -a0960a58bd2681804edd7684793e3cbb0e20d1d4bd8721b192baf9aee97266be14c4ee8b3a3715845dca157ba2fb2c1d -949a37213209adfbfa4e67c7bad591c128352efd9b881c1202cf526bf4f657140ef213acf0efeb827a0c51a1f18809c4 -9192fae84a2a256f69a5e4a968d673bebf14ea9a2c3953f69fe0416f7b0fafa5166f3e4588d281f00d6deac1b6ec08bc -b1a249662f34a88d2798eae20c096268d19f1769d94879b8f1aa40a37b3764349b8e6ab970558436a88a5aa5c37e150d -aea87086dcd6de0b92886b3da0813ff271a7107ab1a3cb7021b85172c1e816a84dbb1a8fdb47e8a8eb5e6fcddd5b919a -a586b5078b3f113eec9f074430bcf9aabe4e82752e5b421c6e31d1c2a911512e34154bf8143b5197e820c5af42aa8ac7 -a6eda122e400a6600f025daa383685a10f72f62317a621698bd0106b331077b05ac1afc68ece7a2e285c54a366921a3c -8875e9ba654ad7b1d57ede84e2b702600416d40f7475fe2df25dd1b95c0178a227ee187547898e5b9d1ce8ce9ebd15c9 -af2cb289f8c75f4ddae9e3ef9c1977fe4d4d513e411777b03b996f5baa372eb995b5ca96255fad9ace776168806ecc42 -8d24c465d26bd93290f45ef035bb6dde4530d9d7d051baf583b1f8b98e9886de262c88b5709084710cffa7c767b4c27d -8cf35b1b28a7726645971805170392d522f5e7e6cb94157fe9c122a987051c1c90abe3c5bdb957ef97b1c45dd9bba05c -93e2bbd82a3cb872cea663f9248b21d4541d981f3f8d5af80a43920db5194857f69e2884753f6ed03b6d748dbfb33620 -8b774b97657db654ebdafce3654d645f849203452e876e49dad7af562491cb6531bd056f51cb5b2e8f0a99e69bd8566b -b5333c49d3e1c4c52f70f3a52f0ad77165bed6ad9dcbfaf1364e7a8a0f24570e85a218e4c2193f63d58a7dd975ceb7a5 -b4a34c443e4fdaab8e69fcda1fce5e72eaa50cf968f5d3d19084d049c5e005d63ab6e1d63dee038317da36f50ffb6b74 -824a224009c6848b92d6e1c96e77cb913fee098aaac810e2c39a0e64d5adb058e626d6a99be58593d921198edd48b19c -a86f1fdd2e1ba11ebda82411b75536fc0c7d2cdb99424e0896d7db6cae0743ee9349ffa5bff8a8995e011337fa735a9d -b406b5b89b8bed7221628b0b24eb23b91f548e9079a3abd18be2ed49baf38536a2c1ec61ab1ddc17928f14b006623e7b -8a7ea88d1f7420e2aaf06ee90efa4af798e2ec7cd297aacd44141471ed500107fdd93bd43b6de540314ef576646a7535 -a7a8c071e68bbae9aca110394cf56daad89404dff3e91ea3440670cd3d0423b67905e32b1ba7218fd4f24d2f8bd86ce7 -b959830f152e4d31c357be1ded5782aed5d6970e823cf8809434cf4fddd364963bc7cfda15c8f6b53eda16ab20ca3451 -b59232c8396c418238807ce07e0d248ad2045289e032678b811cc52730f99b480eb76f6adf985e6d5e38331d4bb2b9d5 -a14092fddecc1df18847ab659f6cf7c8603769a4e96fbe386d8303b225cebbbe8f61d6ab3dca08e3ed027e7e39f2641f -941cb0632acd395439f615c6b4b7da9ed5abf39700a8f6e6f3d3b87a58a1a7dbb2478a6c9ff1990637ada7f7d883f103 -951b8805ecb46c68101078847737e579206f2029e24b071bae6013e9dde8efa22bce28aa72c71708caf4e37f9789a803 -b2cbf22e53f6535fa950dd8de4aa6a85e72784dd1b800c7f31ec5030709d93595768748785ff2dd196fbedf3b53cd9d7 -8d84ea3a7eafb014b6bd6d57b02cab5ac3533aa7be4b86d2c5d53ce2d281304409071100d508ed276f09df81db9080ea -a2204b60836cba8bf29acd33709e6424226ae4d789ef6b280df8a62e30d940bc9f958ff44b5590d12fa99fcde2a4a7a9 -86692c58214f326c70eb2aaf2d8b26eae66fb624f143a3c144fd00f0249e30e0c832733a7822fac05c8fe74293768ace -b1cb3d64eb5b9ca0e01211128f990506fba602cd1417da02237205aa42879ae2a6457386da5f06434bcb757f745f701d -b3eb4290a53d5ff9b4596e4854516f05283f2c9f616ec928a0934b81c61afc351835f7eca66704a18a8b6695571adb30 -b0bfb1d44b039d067d7e0e2621e7c4444a648bce4231a6245179a58cd99758ec8c9e3f261d0adb22f9f1551fceb13e4a -a29320f71a9e23115672ea2b611764fe60df0374e0d3ff83237d78032e69c591a4bdec514e8b34f4b3aeb98181153081 -8a6abe9c8a048002b2ff34154a02c2f13fc6dbae928da47c77f3e5b553ea93d8f763821a6ead3c6069677870fdff7ff3 -b73ab66a62f427e1a5e315239a2e823e2a43550d245cff243c2799eb2e4701fabb7d5f9ce74a601b5ee65f6555dacf64 -b64858e98b9c10de8c9264b841b87e7396ba1da52f0f25029339ca1d13f7f9d97f4de008cfe12a1e27b0a6b0f2c9e1ab -807d2440d1f79a03f7163f5669021f3518094881f190cb02922eb4e9b17312da5e729316fe7ba9bfffc21ed247b033cb -a7f06458d47ebe932c2af053823433a8a06061c48f44314fad8c34846261c8c3f7f63d585a7930937327ad7d7ca31a6f -82ac2215eba9352b37eb8980f03374f5e0a2f439c0508daa7a32cdce398dde2a600e65a36795a4f5cc95bbcf49b01936 -a1882c83a2f946d54d74a008eac4aed70664db969e6799b142e0d0465e5662ba0d224a1cc33be339438d69bdad446ff6 -8009776f7a34a3c8779e21511fa409b0c5a38e172d1331acc29a16114e002f5f2f001381adb5fb3427a100752d775114 -b24441019af4a0df2dc68e3a736f358da0fd930c288398a18bb5a8d9a1e98ea376395f19d8e03a5f020b83fcb709f1af -ac72b4de3920c4f3c9b8ea90035cd7ed74d34b79e79aab392f057c3e992ebe79050cc1c6ccf87120e4162b29419147de -973e75577cd2a131a0bd568fd44e43554ac5a9ea3bf10f02d1ad3ac6ce9dc7a8a7ea93aacf3325f7d252d094a0de1376 -98a114de2a86f62c86862de37c328bf6a7fccff4d45a124addbe0eb64debe365409fcb72ce763f2a75030e1ff4060c64 -aff753e1dd4707f1a359eaec06ebef1903242889a2cb705d59dd78a79eb5b894731f5a91547479506145ca5768877dec -b856e4234858b5aa515de843e8bd4141c15a4cc02c51640e98a8aaa1e40344f1ff8ef7c3b913ea2ae7411713daa558d2 -863525eb2f8147a6d1d0d4304881795bfed348913cd7f38d815d929a426788b69e41f022dba5fdcaf56c85720e37fefe -a14ad76b145a6de2e0f8d4f615288c1512701a7b3010eb8a95941a2171bc23561e9c643764a08c4599040a3b4f5e936a -a18bfc66f6139dcb0485a193104fec2e7d52043837a4c0cadb95743e229712a05cf9ce4ccb482f36ff1ce021e04b574a -991c8e6678077d6e5f5733267c1819d8f7594e3b2c468b86a5c6346495a50701b1b05967e9590c15cef2f72bc10a38f9 -a034e7f9b547b047c99b99a0dd45509b0ac520d09130519174611de5bcdb9998259e1543470b74dcd112d0305c058bad -95ffe0d02317b5c6d5bfddbcec7f3fdfb257b26ad1783bb5634d983012e2ea1c6b9778009e1b6d10564198562f849ac0 -b3db442aa4adb33577583b2a4ad743f41efe0e1f87bfc66091d1d975333ffc00b4afc43057bcb88a7d68b0c9695d38dd -ad2e97d10d7c53d231619e3f2e8155a27ea4f2fb3c0cecf5c7f14f4cfcdd21f62ea46d843b21df748b2892131633fed2 -905d7aad6d3b56bad48694b6b20b27e370ebca8b91d0821e48e2f9cad39910c26cc11c77c266894db3d470485a63ed11 -99bfadefca796ce6af04ede65ba5ef5bf683ff7e2852bb9c406fda77b95ef382289853dfe4d933525071e4cab8ce3936 -94d9905ed4ef92107d0adb9ea38f085a2a24b8f792108bec702d747c215b1f14aafd486ea0c07ed42602b12d8f602b93 -a78dce23ca09dda2d5e7fe923290062546825286d624de35ac5756b6c8ae030e211f4f9c9c8d18a924f5880e3b383d1f -abce9e2128ff51fa17e73d93e63d7134859b2f328eedbcefb337c39e752d6750d9cffe6abfcd359c135dc5a12018827b -a9ea7d91e8a3524acb3182bedd7e1614d37b48f8eb2d8f677eb682d38408b8d512786d8bb65811f4d96788b9378e59b3 -912c9f804fb57dd1928f8274be58b42618f589fc72a7e5b6cb4d4b5d78c547f80737cdd77ebe5d2b71eaf60b8fd2b663 -b7227ec9a62d5538974547f717fdd554ab522d8782667fc3e9962e9c79a21134ef168371bf3b67e28d0964e92cf44028 -89440a781c812a19c758172bf722139598023ed0425374fbb0d91f33be7b7f62a36d7aa34696c4fb0da533bd5dd41532 -b31e4a9792d6e9c625c95aa3c0cd3519410dec07940afab820ef9f63017415d237a47f957d0b591b6de399ffc2a8a893 -a66ec47393df2693be161daaa88be0cf07b430c709ca97246d10a6080ae79db55c9e206b69a61f52512b868ba543e96b -90ca425dee74cc6a7e8eb1755cf9b7b76ba2a36ab851333b0fb7b35e8e6e189702456f2781ad87b4215993d62230ff4f -88b64741f93a2ae5d7b90b22a5e83c9d56bcee5c6bfcedb86f212acc776cc3ebd0b62cc025f596cd8db4f4b6a7aeebab -a1b6c7d2358bb201b42264f8fbebaa242ef105450bab21b4a2f16f368048c16ad1f3695841787eb33a0192f1f6b595eb -8a932f1cd227ceb18389791ed9ea1ff26571715ed1ab56601a994795713a8f7f031d1e8472ec3eb665b7bfbbca8ca623 -8bb2e34a2bf77f9f657dfc51ff296a6279a4d7d15860924f72b184fb7d5680320c7769954b9dac73c4bfe9c698e65e58 -af54e7367891c09f2cea44cc7d908d37d058162ec40059d32ded3983a4cabfe5057953878cf23bfad5292dbd0e03c0e1 -8a202532b9205385cf79f0299ddcb3156fd9fab09f9197bce762b5623f75c72ab1d74334ee6f0d289007befe222bf588 -83bd0f5896eaad58cfa7c88fc5ed505cd223f815dcfe93881b7b696cdd08b8b5ede03ea5b98e195c1a99c74ac5394c1b -b4a84d9940e58e3b4f804e4dd506f8c242579cfa19323c6e59047e5a1e35150699a2fab2f4862dba2f0ee4ed1d8970f8 -8c9ec477d057abebc2e2f6df5c4356a4f565bde09f499a131967d803d4bf36940ca2ed9d4a72adbe0a4a8b83fc686176 -8598f43c32623fd5b563d1ec8048ffc36db3d7f9b3a784299811687976f64b60585b2a2707050a3c36523b75d1e26716 -b55eb07014fe5ad3e5c9359259733945799e7429435d9bf5c72b2e0418776e329379433e17206f9f0a892d702a342917 -a5ed942eda7b36a3b0f516fafd43d9133986e4c623b14c0f6405db04e29c2d0f22f1c588150f670dbb501edda6e6dd4b -92b6abb28cefab2e332c41c98bfa53d065b7d262638389603a43f4431e6caf837b986254c71f7cdacf4d6cc4064b0195 -b01806178a28cc00d1561db03721eef6f6539676d93dd1fa76a13b42a31d38797e99b1848de92fd11821a342b04f3f72 -a2f10303437acfbb5912e186bbff1c15b27ed194c02cbc1c5b482b0b732c41fa809136e8e314e26b5bfe57690fe3b250 -9990207fcc711102e7e941b3ac105547a3e7301390e84f03086c99c6d3e14efff3a2e2b06e26227f496d88d5cdaa3af1 -b903cdb0c2fd578612398c30fe76d435cd1c2bab755478761244abb1e18ba8506fd9c95b326422affbcaf237309959d7 -99e0c12cae23f244f551d649302aac29bfdeb2c7b95578c591f512ad7ac562bd47e7c7317ac9bac52c9ea246617bdb48 -b996d267ab5149c1c06168ee41e403be83f99c385be118928d6e2c042a782de0659d4d837f0c58b26df0ce22049a5836 -989001b8414743765282f7e9517e4b8983a929341b8971d7dd8a87d246f6c8ba5e550c983566ddd932c22948f4fa5402 -a0b006a2c9124375364b8fc5ddb543a7468fa6d321ea046d0fd2bfdaef79e5e3600b3d56190733491ca499add1298c7f -80881d6f3ee507089b7dfb847fc53dd443d4384ef6fce878d07d9b4a1171eefea98242580e8a6a69664699f31e675cfb -adc48ef53d88b9d70409ed89cc3be592c4bd5eb65d9b1b28f2167dc4b12406889c00f2465c554f3aff673debc2997ccf -a62f5d9f167b9f4a4aab40d9cd8c8a48c519f64a1985823e20e233191b037c02e511b0280487112a9f8b1f1503b02db7 -b89aa2d4fb345a1d21133b0bd87f2326eb3285bd4da78b62174bf43d30a36340e4217dbe233afb925ab59e74c90fccf0 -932ba22acdd2f9d9494da90958bf39d8793af22417647d2082d2c3e6a5e17a2d14b0c096139fa8fa3f03967ca2f84963 -b67b107e71d96de1488b4154da83919d990502601c719e89feabe779049ddf7e4fb7e146eb05e754b70bbead4449efb1 -84509de1b8dc35aa2966d8a48501f725d59b4c65f3abf314b2009b9a573365ae3163c1f276708c66af17de180aae0868 -849153fe837a33fcb32c5fa6722c2db9753e984867c112a364eb880d87467782142d1c53a74b41df1dec7e900c877e1f -903d05c73ae043b69b18e980a058ce2254d008647a8d951175b9c47984164b34fc857108dcc29ad9df0806d7e90405f4 -a6b05917ac32c0b0eeea18f1ef3af5343778c543592078fdf6a1b47165013e2676bfe6a592a24efab9d49c4bd92b8fc0 -8648482f6947a5a8d892a39f098160aae1a648cb93e7724ea9e91b0d1a4f4150b91481f6e67d3bf29ff9d65ba4fa61a8 -a6ecaabc38895013297ae020686f04ea739c4512d2e3d6f2d9caf3f54000fb031f202e804ee615eb3357714a18657bcf -912f5935acc2dd20d5ef42b2ad5b307c925324a84a3c78ff66bc5885751934bd92f244e9636b60a744d750a2a7621198 -a0d6f261a776c5b114298f5de08d6e3372649b562051ea2470d3edfc376048793e18fc57ec84809b463dc72496d94329 -940744cd3118d1598c248b38503f6f1fbdbe7a147e683e5b3635140aa91679f8d6c1472600f8e9c36117a60203be6b4e -ab81737c839fe340f6f1fb7275811cb0c0d5fe8bbc265f6a56c6c68d0291bc7234eaa581ff26f8929d9a5bed4aac7002 -8df47341160f1c728c3e31be17a32e42b54faaa1286ef2c7946882ca4dd46443b8428f3654616c6e4053f1cda2e11994 -a721067e75c3c791f4d9f58d4810ac9621606e29c6badb593d6bb78c39968b45be1777ddb9bf03696d4d4be95b2dc1bf -a4e399213d3c4350c2d0cbe30757ba7e1f9680f58e214ff65433b36232323744c866a87d717851ba1dbd6769599f69a6 -b0be851d1e43dee27abe68f85e2330d94521b5f1c1a356ad83fcd09162c0ca9c2e88bccbcc5bacfa59661764361867a3 -86111bdd3dbfca232aa5802a6db41d639502e43a2e24cb06bb5d05c7f9b5ccac334d16b61d1c5eaac4fa0cab91113b46 -a4f805b11c174c34250748b9beebfb7c8c243198fb13463911906ee4effe7d331258a077e374b639a0c5cdcdff166b7f -87e4cf2c6f46d2dbac726a121127502921decf0195d7165e7bbeec6f976adb2d1c375eaa57f419895a2c70193215dc4c -8ff06de2c1c4d0744483bb4f7c5c80bf9c97b4df23e86c0bb17f1498ea70e0ee3af20827da5e8cb9d7f279dc50d7bd85 -ab112c0116471b4dc3fd1e6d918f99158eb7a08153e891ddbba2fe5bf0eeb188209e3019176e758231c3df937438136c -a67f89194e99e028a5da57747268e5ef66fefb881144043429920d222d37aaf268ebf73ca1da659fcdac3b4e7a65092a -b4da1dcc791566140d6abeaa2923cb6b21a6e6aaa30bb4cc70011e931eefa71f96b7e05358c0654bad7ce45191ab9fa8 -8283933231bca359db588c80e043ad6ea765fb0cba5ef233c5d514ba01ddd1b409efbadb368f26763402e4576dc4655f -97f568ce3edacd06f3e31a15462f5f9818a8c3fdbcf92b1ac5840b0b6e73166a154013dd52e85a18e8ead3fc9e54aca0 -a9cd1601c41e5ab2018f986443914fb703ddb6b06a36c06fb58065f2fee8e1751071ef924ea3ad76f0c19baccb1b5f8b -92aad71bb7e929cc35a48020d16a5822f4f106a7f59985005a5ae5ba8e8016ec33727610393498f56b4f353b3d5161b8 -89427780aa4e7ac894c681fbe2889153b94db883f17f109bc9caa93f0c259dda42aab502bbefaf572c56f70abbc42db8 -aa8cf76ff847dfe59534432ed8520bb48bf412c28497747dce04d2b2a54ba843c3be1564630cb49ec0217167847ba590 -a1570a6748a2303e74a31c2131d05ab372ec006ee92ef74c42f2e9a250663bebdfb3777e7ad91f50c954889a59c2d434 -a4c2b1bbc48199c31ea8d8196729eab00ce0200350d4aa9f23347a3289355e5828cb2f93036a14d2d9ec575fb3835239 -84819d0bedbaab5bf8afdf23f59a7ec5f50da3063cfdd1ef5fc4ca4c1fe68980b5c80e30a49f38e5816765e81dfc5a57 -a57cfb5e877b88202f589be777605deafbfc85ed1357af03a18709cfb4b668a271199899243cd3750f1cb77ebc40bba7 -8d95934bbb0efaf3339f27cb96de46e4486aa58a2c40dbc77c1c3ac7c27a228062824b9045c046631b2e286e8549603a -b99a8356abeee69f40cb3bd8c87e8039a1e076897dde430bfbf989dc495c48609a7122bc6c1d1c32ccac687b47d5558a -aac2edcf2fe5d3f1a84e8f1f27ece920eabe7793bf0ed5290cda380752e55d57a55a362c5253bebb71e4a55f2c437ff6 -af7c76876072c3b0091e22b9c5b27ce99bf1f0079ea1a7816ad9c06e9e5fc407595c7f4f9953e67d86fb2da656443dc3 -9175b64d104f78d3310c9c02f82e04c8e9878d2044ea5ee9c799846a3d23afa5fa2aa4af7350956136c69a0eed03cb2e -b3328e953317494a3d976e7f7c3d264258a5d4b2c88e12d06786a9e7b2affd41086762ef6124c6a6e5b6b028db933c14 -a49d166065e19d39299ee870229e4a04be81acd6af3a2201f3a291a025dd5f8bc3e676ee123cd4b9d8455f6a330b395b -85fa15bc8947ba03681d87b50bd2f8238b1c07849a7ed4e065053fad46aac9dd428186a6dd69dc61b5eba6ffec470831 -b6fcb2f694a47d3879b374b8b2967dcd59bd82a5d67ae6289a7326c18791b1b374e12571e8c8ea16a4bfc5525ced3ec4 -b6115f52566aa90ccac2aab6d2dbf46eca296d047db1eb29a1b8a2bc2eef7a24e90407f8dae528806aceb2a1e684d49e -9707e66220233f6a48a93e8dec7b253d19075eaa79238e519b82ce1ac5562cca184f8a1c14f708a96c34ad234673d646 -a0822903fb3825eae07ee9d3482277c0b8fc811856dfe4a51cf24b373f603924166fc5485185f99c4547cd6476b62270 -88dac6366c439daaeee2532b2ddbe206132cf6e12befbb8e99870ac684e04e62de150cba0e22e395a0b858948f40808b -a72dfba9caad3179f43fead0f75e33ba5342470d8c9cb7c86d30d2c7ce7244a8aafd1d558b0ec8e2a9436de2c2e95ccc -8d696046defcc32cc19954c559213100f0ba273ea12abb55ca7c42818071d853846bd4213af2c41ecd4442f6b4b511b1 -89d6f2d52cf65414da15a2fb1911c53afbfb50bb5f2638844abfc325ff2651cd9130be4beff05dc4046adfc44394a182 -afb91abd7c2a9cfe62855ede3c6960ad037fe8778364a2746ff7c214c55f84e19a474a9a0062b52a380d3170456ee9c6 -87f724a16ec8fdae8c05788fa3f823ecc3613df46581a63fc79b58f7c0dc2519b6b23e3dd441a0ca6946dfe4bc6cd0ce -86760f90f6bedfba404b234e90fbf981d26c29b87f2fa272c09540afa0f22e6682d08c21627b8a153c0feb27150458e2 -ad4d0342f255a232252450ce4209507ba619abfd1ffcb9c5707cfa45f89be41d88f1837acea993a1c47211b110250b4d -ace54b5889bccdf1d46c4ca21ed97cca57f7d12648381411d1b64afdfc64532a12d49655776ea24cf5eabe34145705ad -936dac693d0c1b1e5de1701f0bc46aef6e439e84bc368a23c0abe942eb539a2950e8929265786fcdb18d40a44bda14b9 -94fafbc544decec1d489b9ad6b23410b9de4779f9f44aabd093d7fab08340a4646a8cba31633e49c04d2690b8369a1d7 -98157e757f1a677c5d9d65c47759727a4dbc49fec2da4d9889c4ea90573fb42e2a8d72eaef92b782ac6f320970f09363 -8eaa0498c191c810c7e1ca7398f7c80dd0a7e7d7829ed07039490f60e7c2ae108843c06fe38fa36d45d63da46cba887c -a0ae116e5b0d2dccf83f056ad876037225687904e0290fe513fdc6b2dbe4cbf5fac1d828352e64734895895840b3c57c -b592b318dbbd7ec4872aae5e64bdf2305db2e5e8cfe0ad77b691f542ba5e066dd20b09b0b08ff0d798bd79ad946ddf7f -879e50c8c3e7f414ad2b38632bc482b71759cd561aeb2215550186ebb4559e4cf744cdf980512d8321954b3458d21e11 -aed5c6c7ce0407d7b2c04785fcb9deadb9b9413e37cef5b1d918f474cccc7de012fe1fa6f5fa93cb7ef9ac974d9fbc20 -892274a9f0afc68fa74be276c2a16de5cec674193f96b27a80bbb9f3add163f85716b531f3c920b98577a0225f84e8ca -938fb7a53266b997a7669596577af82f5289b160b7fcf06d76eee2a094696f6f12b28c2c65b833a52529a116c42e6c7e -892083929b6067f5045b1208f3dc8f0ee25bd0533a8831f5c23bb4ff46a82d48f0a34523359df5061d84a86b718d5060 -99159ae9574df6c16273eda66b6d8b79a327940e335b28c75d647f4744a009f4b5f0f385e2017bd3e7fbf59e629cd215 -a03e5757ef7738eba32d396923ff7ef82db2c15bb6adc8770fcb37260b7bda3be62473bc352a9a2ef7ec8ebe0d7688bc -ae3c24a85c9b1fa55158b2acd56d2016f70dca45a23f3ef7e0c6b096f4a7c54c14020d61bec7c7f87be4a595bf254209 -a920a6f9cc803fe31352fca39c13f8ac1e8d494fcf11b206092227c2af38469b1fbc068b8fe014800b70f137107aafc4 -b893853be57519ffa6410da605e7d3a746ebadec4788c7907f6e0dde9f20f5a6a01181148b874b3decf9b4814846a11a -b46f43918c5195729f6532439f815d1eb519e91005bc641a4a30ae88700982bf4ed07a342e77945780317c297c903755 -8e431bf4497d0ef6538c93c4bdda520179301a0104eebcfd104efa1edea876818d7d31079656f01a5ff76c4f5fcd71df -92e3dbcb580dfb9cc998f878052b0c3be1c5119e5249ae9bad3538ebb0f0c4ab5a959b04033b96d61836ef07784e6b64 -b712d9d63aa888156f4ec83e939c6bad53de18045f115f54fbf4261fb02f10a8a46a8d716ab43d4acbad3b02283c32fc -b2334e776988b4f772446a47c87416b4f19f9b44164a5f828424d3f35ef10baa56afe810d49b0b86b786b9c0227681a6 -a3f25ad18e435ef585fa90e6cef65a8ba327e5e33701979e27e64ef7d8e09e2591e52bff9c5749d35643456d18625685 -adcfa48ae43cac6fa9866b4cce10a243969965942c891d5e6c0e5b03bd4763f9b63779fbf40d26ac674534fe7cc478d7 -a0eb3448e045038740e2ee666e88aa0f8b8e24b1b55d7d4964f01bfc0c581f7e9d4c0e79f8cfbfecfa8b024b216c8ea6 -8110aa1d82f11965af4f4eedb4de09ee9c353481b2d7ee7a2bc2f302d2a5ae6c31ebc6451309ba7c305da41070b0f666 -b074fdad419d42783ebda17f19863aa499eec71fda5aab6cdcc389276b7bf08053795d15890175ca3dc89f6d8d17758c -a14665846d95d7d5f0b5381502080c822776ec0994ccb1ae1ffbb3f19205ce9c7c9bf9c2d2ca098807ce99f29e4f07a0 -b4884842670a333cb5548a842fa2971881e26b442dfab0b91d6bf3b4cbdf99adbbc9d14fe2bb46872cfcabedae85db30 -94549b01cb47ba16c0cf6f7522c833545397de0b3388c25d03e60132eddada6401682f9ffd8c50d1a61b4d2dde37461f -a790c9b4cec96e4c54777f3e03cea5769b20382cdcaf1de494bac2b9425eaf453eff643c62ab284cc1af33bbd36013be -b1b45fd298ed11609aa1ae6c5ac655e365bb451de1b9fc92aad40422ba85c6a454f33b8142acabe55171328c13d92edf -a74cea9e7096e38327064f058a3cdaa34e6eafaa9c7d58f753c40be67998152380fbd612b9dc0751bda7befcdffcc749 -b18978dfc5efb07b7ef992c7b0cf5d1b4ca551578b1dd13057b7aced8b1deb9f2036e1e3116248a803e922659d206545 -8153c07603cdff6622835a9853b795274390abf7197d7a192193bec44acb43e8cd50b56c11a03f4a2a27124c36974f3d -86b987f30bb9a37cc91d22dffffcd346ec5773e846a6c2b8f9e03b25ffcae859c470c901c4e29695d325dfe4eee927bd -af5e980b9507d10d5269c1a5d02bc16f4f009b663e413ea6a7c655250f3a21c608c12f4002269a05d3779907e7be7d69 -a6f737fab2af9f27bfb8ca87f5fdab6ad51e73ccf074e90576db57b309dfa0a95f9624526dfa4feaef39c388802f2ae9 -b7ed51f699f615f58a7ff4f99d52c4ce7a8d662843c1f4d91f1620fa119b80a0f6848f9fb6c4b9822dc019830e7dfd11 -b71f27f291aa6ef0723ed79c13a1c7a1c40198ffb780a129d9d20e250406bc91f459705b2b6674c9bb412a7b5dd9ff07 -9698cf8f638c3d2916fefa5f28c6050784479f84c2ee76a8aeda7e562630a6ae135b445ec4e29af8588ca5ad94a67f49 -9270aa5030966a9990d8bc71b00b9a7a1d7c1ad8f4c7f78a31b3d7f86467332f21407c74a89ba4f574d723acaf0d2042 -b1b82faceed8e2297cd49cc355471d15ff8dc2ccc78f6944c8f7a75d3ad1629a2e2f1d0a2ff7fa2b3c38cd19839aa5e9 -8a8c4ed49dc9bd961773edf8d41d04385b11bbd3577024639a39319cc7068380236bf73fce0b83e6535bd3f95cef0e65 -8d04ec1e7d148b7e66910ab45a0e6bf409612a3b560bfa784e26f2963152821c646a655cf17a0ce3d4ba4c4ebeeb4a1e -8e9d707f6186d93accb60813715ed1f6b3001ff6d2f87daf8b906bd0b988c1833b2ccd80dee9bdefb45901e81bb82971 -9762317ca6a5e6fe0b2991e0fa54b5fbf419dd0550d70074957d65cd7ebf79ceba607dd40d709ed635c822b3b4da2cac -82b53cd9a1eca2f5d3256723dc4b6531ca422bd87bab36243c727d1952db58d7288ab11467305d875d172ce165b1e4a5 -b4dbeafa05c87029ae257bee1ed7603645fab41f6ba7ac8b57ced5b4774a72ba3e671c2433a93acc3c498795b5cccc42 -a916d3ab7f0e7cef294e11c97c910a19c338ad8e615406e6d1c8995b4a19c3b2527100cc6b97a950ec5a4f3f6db7d01a -b9a785c7123609bdc96f8dd74500c6c77831d9d246f73244de964910b4045ce3242c881271bb1a4bc207d67de7b62e97 -b5f94084f695d0821c472e59c0b761e625b537c8ae3a09f11d9a57259e148cfadba1e43bf22c681b6b32390121cec208 -8f91b36d8570f19a90cf3ed6d5bb25f49a3315ddb566280c091fe2795c4e25ed2c6a1ef8d2669b83f2d7bb78fc8c40f5 -80f27359a73ed8fdd52762f0c7b9f676be2398b1f33c67877261480bf375f975f626c2ca3e7a9f59634db176ed672c98 -b96b91e3d5148ca793edefe4ca776b949c9305acb6f3a3cf87767a684014d2c8f2937c2c672eef8510f17d2da5d51385 -99c4e1ca2cabd4388ea2437dbdf809013d19be9bd09ff6088c8c0cfdb9ecf8fd514391a07b4288dd362434638b8834d9 -b6fdfb812e145f74853892c14f77c29b0c877d8b00055fd084b81360425b3660cd42236ecc853eadb25253e1cd8445c4 -a714af044ef500104576898b9409a9a326ef4286a45c3dae440bd9003fdf689c5f498f24a6f6d18502ce705c60a1cf14 -a9444e201be4a4d8c72119b3d3b13098afee6e5d13c5448fa2e9845cc9188239778f29b208749c960571dfa02b484f05 -91c826a6b8425f93ff395d9fdfa60dbfa655534c36c40a295906578540b9a0e6b94fd8d025b8b8611433022fbbc4fb0b -a355d76bc3cc48ba07026197130f25a593ec730d2ef0d5d2642bfcad745ecbe5c391324bc2485944060ff3100c952557 -b5f9b5a289a6f9a7252cc1f381c892bdb6836a5998f323ee21ae387936148ad1ad7cc6eca37ecece36404b958ae01e8e -a3c7ae04a6208851f6cc40ff270047283b95218905396c5dedc490e405061cbefd1251ecf77837d08c5ec1c77d2776ce -aa02ee387dd2cc7a23cf5cd582da0bc84bb33a7158d76545cbd6e06b26a6f30565dc712d7a8594c29f0529a892138802 -8aff025c841f167fadaf77a68284c355ace41d6df3a9f1e41a6e91454b336f0b69ea34cce495839b642a7c43997a8fd9 -82eccf0b6b4b6460f676d677266451d50f775446df313fc89bdf4c96e082340f6811939d215a54ba0fe30c69b3e43e25 -af324d871b038ff45a04366817c31d2c1e810359776fb57ac44907c6157004e3705476574e676b405d48a48bfb596f59 -9411dcca93ef5620ce375f379fea5c1017a2dd299e288e77b1ab126273631a299d7436f3bf3c860bf795e5faaaefa804 -934fca809e66f582c690c3778ea49de2e7940c0aeb8d7edad68f2edccdfda853d2c4844abd366fbc2215348935e4b2e2 -a1b1fa4c088418f2609d4dea0656b02a8ee664db25f40d53d8f4b1be89a55e5abecbf2c44c0499874abeb3d3a80acf71 -ae6ed7a0ba6280c679b0bf86111afad76fc5d930e9fb199df08134ba807f781d7e0b8b9b2c8c03b02d8cc20dbe949a28 -937d200a72fe4ab8d52f6cb849e322bc5959632b85a93c89744b33e832e8dcf1dddd6ffac0c049b03c105afb8930f7f5 -b4b4a46ebe0c5db16004933c08ad039d365db600a13d68be5346b1c840cce154f56c858874e866de8c3711e755c6e5dd -afcbcb7170c8caa2b77d2b3388dc2f640aeb9eff55798aeceb6eb6494438be05a2ae82f7034b2d439a45ad31d8c64b07 -a2c676273081b8761f58e0b11306ddb6a4cde3d90e7c47b434468700c5b749932819b01efd7637ca820e10fc28dfb427 -b445715162d834c9ee75ac2ff8932ace91c8242d67926b2a650217e4765e0531c2393c9438a52852d63dbbe2cceaafc5 -a0c0ebdc1480fb238a25fbfc77fae0db6e5e74b91809f0ff20a819e56b8c3141549615d1bd7b99829898f6028e8c86be -b3d11933e9d1db8ca617934261ed26c6f5ca06ba16369e7541482bf99c4f86520d43fbb10f4effb2fdf3cc70a189fdb5 -888ac610f8fd87a36b5646e1016eaf6dbca04aa0cc43f53a1046d74a658c4d2794606e79fb07fae57cf9d71ed339f4b6 -979818dab00c58435dc0d0d21185943f95819d2a13531abd2d798e1773c4bbd90047f4eebe117868743db75604a50227 -a6fbcd2656e475065fe44e995e8e2b5309b286b787a7597117e7acc3bb159e591a3e7304ef26f567b5720799d8ae1836 -a03f0ac08d2101ec4d99ca1443eea0efa767a65448a8ecd73a7818a99e863a04392bec8c5b8e5192834e8f98d4683f13 -b3c4ea8c6c3ee8aab2873d446ad702000b0e927e0991c9e30d83c6fe62a604efdc3ac92453313ff0d5e0ac6952922366 -ab25c857f26830631113d50145e961441b5e35d47b9e57f92466654dffebde43e4f78b0867d20929f97c2888c2f06509 -98950aa5a70ef41f274775f021a284d4d801a2efe2dea38460db8a3a8c08c243836d176e69127c2cd17497b0ca393e9e -a9698113febfb6d87fcb84bad82ce52d85a279d3a2933bdd179d53cfe8d6c6c68770e549a1e2947e7528a0e82c95d582 -832b504513266259db78478bd1b5a3b0f3bf2c6d25f1013e64bf0cfae9dc23da8ecd25f7f1047d2efb90e5f1d9b4b3cc -b588bba7bcc0d268ab260d5c1db2122cee7fd01583c7cc27a8ae6b48b29f34c6ea8a6acbb71b9b09c6156ec0a0766142 -a73d2223c7afadc381951a2e9e7bcb7b5c232369f27108c9f3c2ced2dc173e0f49531d0ca527eb142fbb70285307433f -9152cd6b97bd3278465348dde2095892f46342aed0e3d48675848c05b9aee6ef5ad7fe26e0dcd4ab176532289d40eedd -a7812a95a43b020721f688dd726356dda8ebe4de79b4f0fdef78615795e29681bff7c6ff710ff5b2d6ae3fd81bdb8507 -83724c16049e9eaae3269ea8e65caa212f0592e0190b47159bb3346208ccb9af3cfe8f6c3176fa566377da1046044ab8 -877634ec37c7dcd3b83705b103c31013697012795f11e8abf88d54bc84f2c060f665f0c3b14ef8087d3c6a8a7982d64f -b3e53aaacef7a20327bdbba8cd84513534d2e12fd5e1dcf2849f43146e098143b539ebd555623d0ecc46f5ebb4051fca -952d58ecafca9b7ffc25768ee4f05ce138f0289d72978eb5e5d3b23a0daedcb17478890afdce42e30d924d680e13c561 -a10dcc725f9a261de53dd3133858c126f6aa684cf26d92bce63a70e0ff5fff9610ad00d2b87e598b0a7548cfd1ffe713 -b7bc5d0c6b665d5e6f4d0af1c539d8a636550a327e50a0915c898ac494c42b3100e5fae0074c282d1c5073bf4a5456fb -8adc330d3b49ddf3ed210166afc944491aaedb28cb4e67472aeb496f66ce59184c842aa583bfb1a26d67d03b85065134 -b2df992a1310936394a1ebca94a7885b4c0a785638f92a7b567cfb4e68504ac5966a9e2b14891d0aa67d035a99e6583a -96f5da525d140739d19cebb706e2e1e0211edea1f518e040d361d5aca4c80f15be797f58cb4cd3908e4c360c18821243 -b2c0d9173a3d4867c8842e9b58feb1fb47f139f25d1e2332d6b70a85a58811ef99324bf8e52e144e839a4fe2d484e37b -ad95a7631ddb4846d9343d16533493524dfd22e8cbfc280a202343fccee86ab14446f6e7dad9bad9b4185c43fd5f862e -97f38ab82a51a7a792d459a90e7ea71c5a2f02d58e7d542eb3776d82413932737d9431bd6b74ec2a6a8b980d22d55887 -ad4e4c57ec3def5350c37659e8c15bd76d4c13d6de5453493123198dda2c2f40df349f20190e84d740a6b05e0b8f3deb -a691bc10810d11172a6662e46b6bbc48c351df32f325b319553377f525af44a50aaa02790c915b3a49824aa43f17fff0 -a80ccac79bb4014ee366dbf6e380beb61552bd30ef649d4ec39ab307e4139b7775e776fab30831517674ff3d673566f6 -b11e010b855d80e171705ab9e94364c45998e69d9120e4ca4127049b7a620c2eec1377356e7b877874e767f7c44afef4 -96bfab7777769a1e00ce16ada6667a0d21d709e71bd0371c03002427d138d9172640cdd5c529c710fea74bb9d19270c7 -a5bffd2c30e29633b4ecf637c1e792c0378252e2a99b385a093675940b48de2f262c275332ed4765f4a02467f98e3ddd -8d11929d67a6bd8a835b80660a89496250c766e713bddb2cd7052d67b92c39a38ce49005d38b4877856c4bef30fb9af4 -8e704597a0dba1dbd1ff8c9755ddac3f334eeeb513fd1c6b78366603ebc1778231deb8e18f2889421f0091e2c24d3668 -904fbb3f78a49e391a0544cf1faa96ba9402cba818359582258d00aff5319e3c214156cff8c603fbc53a45ede22443e9 -af12ac61eaa9c636481a46fd91903c8a16e7647534fc6fd9baa58ae2998c38ffbd9f03182062311c8adfef0a338aa075 -87f2e544b2993349ab305ab8c3bf050e7764f47d3f3031e26e084e907523d49e1d46c63d0c97b790394f25868e12b932 -a279a7bef6de9d4e183e2bedaf8c553fadfc623a9af8785fe7577cadced02b86e3dab1e97b492d4680c060ea0126abeb -8ece08667ed826f0a239cea72e11359f7e85d891826292b61d4edbdc672f8342e32c66bec3e6498016b8194168ba0e0d -90a15162586e991b302427bc0307790a957b53ab0e83c8b2216f6e6302bc496cb256f0f054ff2cccdfe042763de00976 -9966c0413b086a983f031a39080efde41a9fedcaf8e92897ce92e0c573b37981f5ea266b39dc4f4fb926a1bce5e95ad7 -9515be2f65a57e6960d71bfb1917d33f3f6d8b06f8f31df30fc76622949770fea90ff20be525ae3294c56bc91efb7654 -86e71c9b4059dc4fd1ce7e28883e4f579a51449cab5899e371118cdb6afe2758b1485961ca637c299896dea7c732151b -8695b4ff746d573f8d150f564e69fe51c0726c5d14aa1d72d944f4195e96165eca7eba8cac583fd19d26718b0ce3eb61 -813eecf402151c99c1a55b4c931716e95810fc4e6d117dfc44abbf5ef8dcdf3f971d90d7fa5e5def393681b9584637e0 -a9caf7219eed1db14b7b8f626f20294a3305ed1f6c22f6a26962772c2fa3e50b5234f6d9ba7fa5c3448824c2a15271b3 -b2b2ee20de9b334f2d82cbe0d2e426ca1f35f76218737d0069af9b727a1bfc12d40cf8b88d4afcbeaadf317b7f7ad418 -b853960749521a17ff45f16ac46813d249c4e26e3c08fd33d31ef1ed2b2e157c9cb18bd2454fb5c62690bdd090a48f60 -88772297d2972471b3db71f3ddbf5945a90154768ca49fa6729a5e2299f1795445fb3d4d969d1620e87dca618fbc8a6c -a2bb783fd13aee993e3efd3a963ebc8a8eacfc8450042f018f2040353de88c71ac784b0898bdff27f606c60a3d5ef2c6 -9210903ac619edca0cb8c288ed6dcc93c472f45182cd6614a8e2390801ddea41d48a4ac04a40e2f0adfd48f91aabe2ea -a621d00f83260c22db9fa28757ea81dabcc78b10eeaaf58b06b401db6cc7a7d9a6831a16f171ead4e8506d0c46a752ca -b25c525bf6761a18bbd156ac141df2595940c7b011ed849dbb8ac3a2cd2da6b63ba4755324d70dc14c959deb29fb9ad3 -a35111d0db3e862e1b06249d289e0fc6b110877d254f2ae1604fb21292c227a8b6d87dd17a7b31166038d6860b1bd249 -90bf057309867d95f27637bd10ef15ceb788f07d38aca7ad7920042293d7c4a1a13d4ca1d6db202864d86d20a93e16cf -a88510e110b268d15dcd163ba1e403e44b656771399ac3a049dcb672a1201e88bf60bdd1d303158888a3d30d616cc0bd -b33b7e1f765e9cbd5eeb925e69c39b0a9ea3348ab17f1dbb84b66f4a4b3233e28cbdeb0903d6cfe49ec4fc2f27378ff9 -b777da64fa64d9bc3d2d81b088933fce0e5fcc29c15536159c82af3622a2604c2b968991edea7b6882c9e6f76b544203 -8ea598e402a056fd8031fbf3b9e392347999adc1bd5b68c5797a791a787d006e96918c799467af9ac7f5f57eb30b4f94 -b6901a389bf3b3045e679d015c714d24f8bbe6183349b7f6b42f43409a09f0d5bd4b794012257d735c5fdf6d1812554b -b5866426336d1805447e6efc3f3deb629b945b2781f618df9a2cc48c96020846e9108f9d8507a42ba58d7617cb796c31 -a18ccc6ad1caa8462fa9bec79510689dd2a68d2e8b8e0ddbeb50be4d77728e1d6a18748a11e27edd8d3336c212689a4d -abbd48c48a271b6b7c95518a9352d01a84fb165f7963b87cdc95d5891119a219571a920f0d9ceedc8f9f0de4ab9deb65 -94a4e5f4d7e49229e435530b12a1ff0e9259a44a4f183fb1fe5b7b59970436e19cf932625f83f7b75702fd2456c3b801 -af0a6f2a0d0af7fc72e8cb690f0c4b4b57b82e1034cca3d627e8ef85415adec8eb5df359932c570b1ee077c1d7a5a335 -9728025e03114b9e37ed43e9dcba54a2d67f1c99c34c6139e03d4f9c57c9e28b6b27941d9fca4051d32f9b89bec6537b -941601742d1e1ec8426591733a4f1c13785b0a9b0a6b2275909301a6a3c6c1e2fb1ffa5fdcc08d7fb69f836ae641ced5 -b84b90480defd22f309e294379d1ca324a76b8f0ba13b8496b75a6657494e97d48b0ea5cfdb8e8ac7f2065360e4b1048 -95cc438ee8e370fc857fd36c3679c5660cf6a6c870f56ef8adf671e6bf4b25d1dbad78872cc3989fdfe39b29fc30486d -8aafba32e4a30cad79c5800c8709241b4041b0c13185ea1aa9bc510858709870b931d70b5d9a629f47579b161f1d8af7 -865b0155d9013e80cba57f204c21910edbd4d15e53ae4fee79992cb854dc8b8a73f0a9be92f74893e30eb70f270511bc -b9a49ce58d40b429ac7192cdbf76da31300efc88c827b1e441dd5bdb2f1c180d57808c48992492a2dc5231008629159f -8d1438b10f6cd996494d4c7b5a0841617ec7cf237c9e0956eac04fda3f9ded5110ec99776b816e3c78abd24eb4a9c635 -af2dd18211bb8a3e77c0a49d5773da6e29e4e6fa6632a6eeb56c4be233f6afe81655d977932548de2be16567c54ffbd7 -92b92443f44464f2b48002a966664a4267eae559fa24051983bcf09d81bed5bcc15cb6ff95139d991707697a5d0cc1ab -a1864a2bac0c0dd5b2fb1a79913dd675fe0a5ae08603a9f69d8ca33268239ac7f2fed4f6bf6182a4775683cb9ccd92a8 -948e8f1cf5bd594c5372845b940db4cb2cb5694f62f687952c73eb77532993de2e2d7d974a2ced58730d12c8255c30a2 -aa825c08284fa74a99fcfc473576e8a9788277f72f8c87f29be1dd41229c286c2753ff7444c753767bd8180226763dfc -8384d8d51415e1a4d6fe4324504e958c1b86374cc0513ddf5bcbffabb3edcf4b7d401421e5d1aa9da9010f07ef502677 -8b8223a42585409041d8a6e3326342df02b2fe0bcc1758ff950288e8e4677e3dc17b0641286eaf759a68e005791c249c -a98a98cc2fb14e71928da7f8ce53ab1fb339851c9f1f4bceb5f1d896c46906bd027ef5950ca53b3c8850407439efedd4 -866f44d2e35a4dbffe6cd539b6ef5901924061e37f9a0e7007696fb23526379c9b8d095b417effe1eecda698de744dcb -91774f44bf15edafdf43957fdf254682a97e493eb49d0779c745cb5dbe5d313bf30b372edd343f6d2220475084430a2e -ab52fc3766c499a5f5c838210aada2c3bcc1a2ec1a82f5227d4243df60809ee7be10026642010869cfbf53b335834608 -a0e613af98f92467339c1f3dc4450b7af396d30cefd35713388ccd600a3d7436620e433bf294285876a92f2e845b90d0 -8a1b5ca60a9ae7adc6999c2143c07a855042013d93b733595d7a78b2dc94a9daa8787e2e41b89197a0043343dbd7610f -ae7e4557bc47b1a9af81667583d30d0da0d4a9bb0c922450c04ec2a4ae796c3f6b0ede7596a7a3d4e8a64c1f9ee8ff36 -8d4e7368b542f9f028309c296b4f84d4bde4837350cf71cfe2fa9d4a71bce7b860f48e556db5e72bc21cf994ffdf8e13 -af6ed1fbff52dd7d67d6a0edfa193aa0aab1536979d27dba36e348759d3649779f74b559194b56e9378b41e896c4886f -a069ba90a349ac462cac0b44d02c52a4adf06f40428aef5a2ddff713de31f991f2247fc63426193a3ea1b1e50aa69ded -8750f5f4baf49a5987470f5022921108abe0ead3829ddef00e61aedd71f11b1cdd4be8c958e169440b6a8f8140f4fbf9 -a0c53cefc08a8d125abd6e9731bd351d3d05f078117ff9c47ae6b71c8b8d8257f0d830481f941f0c349fc469f01c9368 -94eea18c5ed056900c8285b05ba47c940dff0a4593b627fdd8f952c7d0122b2c26200861ef3e5c9688511857535be823 -8e1b7bd80d13460787e5060064c65fbcdac000c989886d43c7244ccb5f62dcc771defc6eb9e00bae91b47e23aeb9a21f -b4b23f9dd17d12e145e7c9d3c6c0b0665d1b180a7cfdf7f8d1ab40b501c4b103566570dca2d2f837431b4bf698984cad -847a47c6b225a8eb5325af43026fb9ef737eede996257e63601f80302092516013fde27b93b40ff8a631887e654f7a54 -9582d7afb77429461bd8ebb5781e6390a4dde12a9e710e183581031ccfacd9067686cfaf47584efaafeb1936eae495cc -8e4fd5dbd9002720202151608f49ef260b2af647bd618eb48ebeceeb903b5d855aa3e3f233632587a88dc4d12a482df9 -87b99fe6a9c1d8413a06a60d110d9e56bb06d9f0268dc12e4ab0f17dd6ca088a16ade8f4fb7f15d3322cbe7bfd319ae1 -b562d23002ed00386db1187f519018edd963a72fca7d2b9fcaab9a2213ac862803101b879d1d8ac28d1ccae3b4868a05 -b4cc8b2acacf2ce7219a17af5d42ce50530300029bc7e8e6e2a3c14ff02a5b33f0a7fecb0bb4a7900ea63befa854a840 -9789f0fe18d832ff72df45befa7cabf0a326b42ada3657d164c821c35ac7ed7b2e0eba3d67856e8c387626770059b0c3 -986c6fe6771418549fa3263fa8203e48552d5ecb4e619d35483cb4e348d849851f09692821c9233ae9f16f36979c30c2 -a9160182a9550c5756f35cea1fe752c647d1b64a12426a0b5b8d48af06a12896833ec5f5d9b90185764db0160905ca01 -82614dbd89d54c1e0af4f6ffe8710e6e871f57ef833cbcb3d3d7c617a75ec31e2a459a89ebb716b18fc77867ff8d5d47 -8fc298ffba280d903a7873d1b5232ce0d302201957226cddff120ffe8df9fee34e08420302c6b301d90e3d58f10beeb9 -898da9ac8494e31705bdf684545eee1c99b564b9601877d226d0def9ec67a20e06f8c8ba2a5202cc57a643487b94af19 -88218478d51c3ed2de35b310beedf2715e30208c18f046ee65e824f5e6fd9def921f6d5f75fd6dde47fa670c9520f91a -89703ae7dff9b3bc2a93b44cdbab12c3d8496063a3c658e21a7c2078e4c00be0eecae6379ee8c400c67c879748f1d909 -a44d463477dece0d45abb0ebb5f130bfb9c0a3bbcd3be62adf84a47bbd6938568a89bc92a53ca638ff1a2118c1744738 -95df2b4d392143ee4c39ad72f636d0ed72922de492769c6264015776a652f394a688f1d2b5cf46077d01fda8319ba265 -aa989867375710ed07ad6789bfb32f85bdc71d207f6f838bd3bde9da5a169325481ac326076b72358808bd5c763ba5bb -b859d97d0173920d16bc01eb7d3ddd47273daac72f86c4c30392f8de05fee643e8d6aa8bebdbc5c2d89037bc68a8a105 -b0249ec97411fa39aa06b3d9a6e04bbbcd5e99a7bc527273b6aa95e7ae5f437b495385adaefa4327231562d232c9f822 -8209e156fe525d67e1c83ec2340d50d45eba5363f617f2e5738117cdcc4a829c4cc37639afd7745cbe929c66754fd486 -99fd2728ceb4c62e5f0763337e6d28bf11fbe5df114217f002bc5cd3543c9f62a05a8a41b2e02295360d007eaab796a6 -902ebc68b8372feeaf2e0b40bd6998a0e17981db9cc9d23f932c34fbcc680292a0d8adcea2ad3fb2c9ed89e7019445c2 -8b5653f4770df67f87cb68970555b9131c3d01e597f514e0a399eec8056e4c5a7deed0371a27b3b2be426d8e860bf9f2 -8f5af27fdc98a29c647de60d01b9e9fd0039013003b44ba7aa75a4b9c42c91feb41c8ae06f39e22d3aed0932a137affa -81babb9c1f5bcc0fd3b97d11dd871b1bbd9a56947794ff70ab4758ae9850122c2e78d53cb30db69ece23538dc4ee033e -b8b65d972734f8ecae10dd4e072fa73c9a1bf37484abcfa87e0d2fcecac57294695765f63be87e1ba4ec0eb95688403a -b0fe17d0e53060aef1947d776b06ab5b461a8ef41235b619ca477e3182fadaf9574f12ffc76420f074f82ac4a9aa7071 -ae265c0b90bf064d7a938e224cb1cd3b7eca3e348fbc4f50a29ac0930a803b96e0640992354aa14b303ea313cb523697 -8bc10ffde3224e8668700a3450463ab460ec6f198e1deb016e2c9d1643cc2fe1b377319223f41ffeb0b85afd35400d40 -8d5113b43aea2e0cc6f8ec740d6254698aff7881d72a6d77affd6e6b182909b4de8eb5f524714b5971b418627f15d218 -ae2ef0a401278b7b5d333f0588773ec62ead58807cdee679f72b1af343c1689c5f314989d9e6c9369f8da9ce76979db6 -b9c1cb996a78d4f7793956daaa8d8825dd43c4c37877bc04026db4866144b1bf37aa804d2fe0a63c374cf89e55e9069f -a35f73851081f6540e536a24a28808d478a2bb1fd15ee7ff61b1562e44fbafc0004b9c92c9f96328d546b1287e523e48 -82007f34e3383c628c8f490654369744592aa95a63a72be6e90848ad54f8bc2d0434b62f92a7c802c93017214ecf326e -9127db515b1ed3644c64eaf17a6656e6663838fed4c6612a444a6761636eaaeb6a27b72d0e6d438c863f67b0d3ec25c5 -984c9fcc3deccf83df3bbbb9844204c68f6331f0f8742119ba30634c8c5d786cd708aa99555196cf6563c953816aec44 -a0f9daf900112029474c56ddd9eb3b84af3ed2f52cd83b4eb34531cf5218e7c58b3cab4027b9fc17831e1b6078f3bf4a -90adbcc921369023866a23f5cea7b0e587d129ad71cab0449e2e2137838cea759dec27b0b922c59ac4870ef6146ea283 -8c5650b6b9293c168af98cf60ad35c945a30f5545992a5a8c05d42e09f43b04d370c4d800f474b2323b4269281ca50f8 -868d95be8b34a337b5da5d886651e843c073f324f9f1b4fbd1db14f74aba6559449f94c599f387856c5f8a7bc83b52a1 -812df0401d299c9e95a8296f9c520ef12d9a3dd88749b51eab8c1b7cc97961608ab9fc241a7e2888a693141962c8fd6d -abda319119d8a4d089393846830eee19d5d6e65059bf78713b307d0b4aad245673608b0880aa31c27e96c8d02eff39c0 -887f11ae9e488b99cb647506dcaa5e2518b169ee70a55cd49e45882fe5bfb35ffaf11feb2bf460c17d5e0490b7c1c14d -b36b6e9f95ffff917ca472a38fa7028c38dc650e1e906e384c10fe38a6f55e9b84b56ffa3a429d3b0c3e2cf8169e66a9 -a0450514d20622b7c534f54be3260bab8309632ca21c6093aa0ccc975b8eed33a922cbcc30a730ccc506edf9b188a879 -87cfaf7bcd5d26875ca665ac45f9decd3854701b0443332da0f9b213e69d6f5521ae0217ec375489cd4fad7b4babf724 -842ad67c1baf7a9d4504c10c5c979ce0a4d1b86a263899e2b5757407c2adcdcf7ed58173ad9d156d84075ef8798cb1c4 -ac1a05755fe4d3fb2ab5b951bafe65cca7c7842022ca567b32cddf7741782cbf8c4990c1dd4ea05dc087a4712844aebb -a000c8cecc4fddeb926dc8dd619952bc51d00d7c662e025f973387a3fc8b1ef5c7c10b6a62e963eb785e0ec04cb1ffbe -8a573c9986dbeb469547dfd09f60078eab252d8ec17351fe373a38068af046b0037967f2b3722fa73ed73512afd038d2 -b8dff15dff931f58ba05b6010716c613631d7dd9562ae5138dbec966630bcdb0e72552e4eefc0351a6a6b7912d785094 -990e81fd459433522e8b475e67e847cb342c4742f0dbf71acc5754244ccd1d9ff75919168588d8f18b8aea17092dd2a4 -b012f8644da2113bef7dd6cdc622a55cfa0734bd267b847d11bba2e257a97a2a465c2bb616c240e197ff7b23e2ce8d8e -a659bd590fde467766e2091c34a0b070772f79380be069eef1afecc470368a95afd9eed6520d542c09c0d1a9dca23bd0 -b9239f318b849079477d1cf0a60a3d530391adacd95c449373da1c9f83f03c496c42097c3f9aca10c1b9b3dbe5d98923 -851e9a6add6e4a0ee9994962178d06f6d4fbc0def97feef1ba4c86d3bcf027a59bafa0cf25876ca33e515a1e1696e5cc -803b9c5276eed78092de2f340b2f0d0165349a24d546e495bd275fe16f89a291e4c74c22fdee5185f8fce0c7fbced201 -95915654ca4656d07575168fb7290f50dc5dcbbcdf55a44df9ec25a9754a6571ab8ca8a159bc27d9fa47c35ffd8f7ffd -88f865919764e8e765948780c4fdd76f79af556cd95e56105d603c257d3bfb28f11efca1dfb2ce77162f9a5b1700bac8 -b1233131f666579b4cc8b37cfa160fc10551b1ec33b784b82685251464d3c095cdde53d0407c73f862520aa8667b1981 -a91115a15cf4a83bda1b46f9b9719cfba14ffb8b6e77add8d5a0b61bea2e4ea8ce208e3d4ed8ca1aab50802b800e763a -93553b6c92b14546ae6011a34600a46021ce7d5b6fbfcda2a70335c232612205dbe6bfb1cc42db6d49bd4042c8919525 -8c2a498e5d102e80c93786f13ccf3c9cab7f4c538ccf0aee8d8191da0dbca5d07dff4448383e0cf5146f6d7e629d64f8 -a66ab92c0d2c07ea0c36787a86b63ee200499527c93b9048b4180fc77e0bb0aa919f4222c4bec46eeb3f93845ab2f657 -917e4fc34081a400fc413335fdf5a076495ae19705f8542c09db2f55fa913d6958fa6d711f49ad191aec107befc2f967 -940631a5118587291c48ac8576cdc7e4a904dd9272acb79407a7d3549c3742d9b3669338adbc1386724cc17ee0cc1ca3 -ae23ae3a531900550671fd10447a35d3653c5f03f65b0fdffe092844c1c95d0e67cab814d36e6388db5f8bd0667cd232 -ae545727fca94fd02f43e848f0fbbb1381fd0e568a1a082bf3929434cc73065bfbc9f2c840b270dda8cc2e08cd4d44b0 -8a9bc9b90e98f55007c3a830233c7e5dc3c4760e4e09091ff30ee484b54c5c269e1292ce4e05c303f6462a2a1bd5de33 -a5a2e7515ce5e5c1a05e5f4c42f99835f6fde14d47ecb4a4877b924246038f5bc1b91622e2ff97ed58737ed58319acfa -8fa9f5edf9153618b72b413586e10aaa6c4b6e5d2d9c3e8693ca6b87804c58dc4bf23a480c0f80cb821ebc3cf20ea4fc -925134501859a181913aadac9f07f73d82555058d55a7d5aaa305067fbd0c43017178702facc404e952ea5cfd39db59b -8b5ab1d9b5127cb590d6bddbf698ffe08770b6fc6527023d6c381f39754aecc43f985c47a46be23fe29f6ca170249b44 -aa39c6b9626354c967d93943f4ef09d637e13c505e36352c385b66e996c19c5603b9f0488ad4014bb5fc2e051b2876cc -8e77399c6e9cb8345002195feb7408eb571e6a81c0418590d2d775af7414fc17e61fe0cd37af8e737b59b89c849d3a28 -a0150aeca2ddc9627c7ea0af0dd4426726583389169bc8174fc1597cc8048299cc594b22d234a4e013dff7232b2d946c -98659422ef91f193e6104b09ff607d1ed856bb6baed2a6386c9457efbc748bd1bf436573d80465ebc54f8c340b697ea5 -8d6fb015898d3672eb580e1ffdf623fc4b23076664623b66bfb18f450d29522e8cb9c90f00d28ccf00af34f730bff7ac -996a8538efa9e2937c1caad58dc6564e5c185ada6cdcef07d5ec0056eb1259b0e4cef410252a1b5dbaee0da0b98dac91 -aa0ae2548149d462362a33f96c3ce9b5010ebf202602e81e0ef77e22cfc57ecf03946a3076b6171bea3d3dc9681187d7 -a5ce876b29f6b89050700df46d679bed85690daf7bad5c0df65e6f3bde5673e6055e6c29a4f4dcb82b93ccecf3bad9cc -81d824bb283c2f55554340c3514e15f7f1db8e9e95dd60a912826b1cccb1096f993a6440834dad3f2a5de70071b4b4b5 -914e7291da286a89dfc923749da8f0bf61a04faa3803d6d10633261a717184065dcc4980114ad852e359f79794877dd9 -ae49dc760db497c8e834510fe89419cc81f33fd2a2d33de3e5e680d9a95a0e6a3ccbdf7c0953beeb3d1caf0a08b3e131 -b24f527d83e624d71700a4b238016835a2d06f905f3740f0005105f4b2e49fc62f7e800e33cdc900d805429267e42fc0 -b03471ecaa7a3bf54503347f470a6c611e44a3cee8218ad3fcad61d286cfb7bb6a1113dad18475ec3354a71fcc4ec1e2 -881289b82b30aff4c8f467c2a25fced6064e1eece97c0de083e224b21735da61c51592a60f2913e8c8ba4437801f1a83 -b4ce59c0fc1e0ecad88e79b056c2fd09542d53c40f41dea0f094b7f354ad88db92c560b9aeb3c0ef48137b1a0b1c3f95 -a1ffb30eb8ef0e3ea749b5f300241ebe748ed7cf480e283dfcda7380aa1c15347491be97e65bc96bdf3fe62d8b74b3ae -b8954a826c59d18c6bfab24719f8730cc901868a95438838cd61dac468a2d79b1d42f77284e86e3382bf4f2a22044927 -818e7e7c59b6b5e22b3c2c19c163f2e787f2ff3758d395a4da02766948935eb44413c3ddd2bf45804a3c19744aa332f3 -a29556e49866e4e6f01d4f042eed803beeda781462884a603927791bd3750331a11bc013138f3270c216ab3aa5d39221 -b40885fa0287dc92859b8b030c7cca4497e96c387dcfe6ed13eb7f596b1eb18fb813e4ae139475d692f196431acb58fe -89cd634682fd99ee74843ae619832780cf7cd717f230ea30f0b1821caf2f312b41c91f459bdba723f780c7e3eed15676 -b48c550db835750d45a7f3f06c58f8f3bf8766a441265ca80089ead0346f2e17cbb1a5e843557216f5611978235e0f83 -90936ee810039783c09392857164ab732334be3a3b9c6776b8b19f5685379c623b1997fb0cdd43af5061d042247bc72f -a6258a6bae36525794432f058d4b3b7772ba6a37f74ef1c1106c80a380fc894cbeac4f340674b4e2f7a0f9213b001afd -8f26943a32cf239c4e2976314e97f2309a1c775777710393c672a4aab042a8c6ee8aa9ac168aed7c408a436965a47aeb -820f793573ca5cc3084fe5cef86894c5351b6078df9807d4e1b9341f9d5422dd29d19a73b0843a14ad63e8827a75d2da -a3c4fca786603cd28f2282ba02afe7cf9287529e0e924ca90d6cdfd1a3912478ebb3076b370ee72e00df5517134fe17f -8f3cdabd0b64a35b9ee9c6384d3a8426cc49ae6063632fb1a56a0ae94affa833955f458976ff309dafd0b2dd540786ae -945a0630cd8fa111cfd776471075e5d2bbe8eb7512408b5c79c8999bfaeca6c097f988fb1c38fa9c1048bac2bca19f2e -8a7f6c4e0ba1920c98d0b0235b4dda73b631f511e209b10c05c550f51e91b4ba3893996d1562f04ac7105a141464e0e9 -ab3c13d8b78203b4980412edc8a8f579e999bf79569e028993da9138058711d19417cf20b477ef7ed627fa4a234c727a -82b00d9a3e29ed8d14c366f7bb25b8cfe953b7be275db9590373a7d8a86ea927d56dc3070a09ef7f265f6dd99a7c896e -b6e48a282de57949821e0c06bc9ba686f79e76fb7cbf50ea8b4651ccd29bc4b6da67efea4662536ba9912d197b78d915 -a749e9edcba6b4f72880d3f84a493f4e8146c845637009f6ff227ff98521dbbe556a3446340483c705a87e40d07364bc -b9b93c94bd0603ce5922e9c4c29a60066b64a767b3aed81d8f046f48539469f5886f14c09d83b5c4742f1b03f84bb619 -afa70b349988f85ed438faafa982df35f242dd7869bda95ae630b7fd48b5674ef0f2b4d7a1ca8d3a2041eff9523e9333 -a8e7e09b93010982f50bd0930842898c0dcd30cdb9b123923e9d5ef662b31468222fc50f559edc57fcfdc597151ebb6e -8ce73be5ac29b0c2f5ab17cae32c715a91380288137d7f8474610d2f28d06d458495d42b9cb156fb1b2a7dfdcc437e1c -85596c1d81f722826d778e62b604eb0867337b0204c9fae636399fa25bb81204b501e5a5912654d215ec28ff48b2cb07 -96ff380229393ea94d9d07e96d15233f76467b43a3e245ca100cbecbdbb6ad8852046ea91b95bb03d8c91750b1dfe6e1 -b7417d9860b09f788eb95ef89deb8e528befcfa24efddbc18deaf0b8b9867b92361662db49db8121aeea85a9396f64fd -97b07705332a59cdba830cc8490da53624ab938e76869b2ce56452e696dcc18eb63c95da6dffa933fb5ffb7585070e2d -971f757d08504b154f9fc1c5fd88e01396175b36acf7f7abcfed4fff0e421b859879ed268e2ac13424c043b96fbe99fc -b9adb5d3605954943a7185bddf847d4dbe7bafe970e55dc0ec84d484967124c26dd60f57800d0a8d38833b91e4da476a -b4856741667bb45cae466379d9d6e1e4191f319b5001b4f963128b0c4f01819785732d990b2f5db7a3452722a61cd8cc -a81ec9f2ab890d099fb078a0c430d64e1d06cbbe00b1f140d75fc24c99fe35c13020af22de25bbe3acf6195869429ba5 -99dcea976c093a73c08e574d930d7b2ae49d7fe43064c3c52199307e54db9e048abe3a370b615798b05fe8425a260ba0 -a1f7437c0588f8958b06beb07498e55cd6553429a68cd807082aa4cc031ab2d998d16305a618b3d92221f446e6cd766d -806e4e0958e0b5217996d6763293f39c4f4f77016b3373b9a88f7b1221728d14227fce01b885a43b916ff6c7a8bc2e06 -8e210b7d1aff606a6fc9e02898168d48ec39bc687086a7fe4be79622dd12284a5991eb53c4adfe848251f20d5bfe9de0 -82810111e10c654a6c07cbfd1aff66727039ebc3226eef8883d570f25117acf259b1683742f916ac287097223afc6343 -92f0e28cca06fd543f2f620cc975303b6e9a3d7c96a760e1d65b740514ccd713dc7a27a356a4be733570ca199edd17ba -900810aa4f98a0d6e13baf5403761a0aeb6422249361380c52f98b2c79c651e3c72f7807b5b5e3a30d65d6ff7a2a9203 -b0740bfefea7470c4c94e85185dbe6e20685523d870ff3ef4eb2c97735cef41a6ab9d8f074a37a81c35f3f8a7d259f0e -af022e98f2f418efbbe2de6fefb2aa133c726174f0f36925a4eafd2c6fd6c744edb91386bafb205ce13561de4294f3a6 -95e4592e21ba97e950abb463e1bc7b0d65f726e84c06a98eb200b1d8bfc75d4b8cff3f55924837009e88272542fd25ec -b13bd6b18cd8a63f76c9831d547c39bbd553bda66562c3085999c4da5e95b26b74803d7847af86b613a2e80e2f08caae -a5625658b474a95aba3e4888c57d82fb61c356859a170bc5022077aa6c1245022e94d3a800bf7bd5f2b9ab1348a8834e -a097ee9e6f1d43e686df800c6ce8cfc1962e5a39bb6de3cf5222b220a41b3d608922dae499bce5c89675c286a98fdabd -94230ba8e9a5e9749cd476257b3f14a6bf9683e534fb5c33ca21330617533c773cb80e508e96150763699ad6ecd5aee7 -b5fea7e1f4448449c4bc5f9cc01ac32333d05f464d0ed222bf20e113bab0ee7b1b778cd083ceae03fdfd43d73f690728 -a18a41a78a80a7db8860a6352642cdeef8a305714543b857ca53a0ee6bed70a69eeba8cfcf617b11586a5cc66af4fc4f -85d7f4b3ff9054944ac80a51ef43c04189d491e61a58abed3f0283d041f0855612b714a8a0736d3d25c27239ab08f2ec -b1da94f1e2aedd357cb35d152e265ccfc43120825d86733fa007fc1e291192e8ff8342306bef0c28183d1df0ccec99d0 -852893687532527d0fbeea7543ac89a37195eadab2f8f0312a77c73bdeed4ad09d0520f008d7611539425f3e1b542cfd -99e3bd4d26df088fc9019a8c0b82611fd4769003b2a262be6b880651d687257ded4b4d18ccb102cba48c5e53891535e4 -98c407bc3bbc0e8f24bedf7a24510a5d16bce1df22940515a4fbdacd20d06d522ef9405f5f9b9b55964915dd474e2b5c -80de0a12f917717c6fc9dc3ccc9732c28bae36cff4a9f229d5eaf0d3e43f0581a635ba2e38386442c973f7cb3f0fdfa7 -94f9615f51466ae4bb9c8478200634b9a3d762d63f2a16366849096f9fc57f56b2e68fe0ca5d4d1327a4f737b3c30154 -a3dcbe16499be5ccb822dfcd7c2c8848ba574f73f9912e9aa93d08d7f030b5076ca412ad4bf6225b6c67235e0ab6a748 -98f137bf2e1aea18289750978feb2e379054021e5d574f66ca7b062410dcfe7abb521fab428f5b293bbe2268a9af3aa4 -8f5021c8254ba426f646e2a15b6d96b337a588f4dfb8cbae2d593a4d49652ca2ada438878de5e7c2dbbd69b299506070 -8cc3f67dd0edcdb51dfd0c390586622e4538c7a179512f3a4f84dd7368153a28b1cf343afd848ac167cb3fcaa6aee811 -863690f09ac98484d6189c95bc0d9e8f3b01c489cb3f9f25bf7a13a9b6c1deaf8275ad74a95f519932149d9c2a41db42 -8494e70d629543de6f937b62beca44d10a04875bd782c9a457d510f82c85c52e6d34b9c3d4415dd7a461abbcc916c3c4 -925b5e1e38fbc7f20371b126d76522c0ea1649eb6f8af8efb389764ddcf2653775ef99a58a2dcf1812ce882964909798 -94d0494dcc44893c65152e7d42f4fb0dc46af5dc5674d3c607227160447939a56d9f9ea2b3d3736074eef255f7ec7566 -b0484d33f0ef80ff9b9d693c0721c77e518d0238918498ddf71f14133eb484defb9f9f7b9083d52bc6d6ba2012c7b036 -8979e41e0bb3b501a7ebbd024567ce7f0171acfea8403a530fe9e791e6e859dfbd60b742b3186d7cf5ab264b14d34d04 -af93185677d39e94a2b5d08867b44be2ba0bb50642edca906066d80facde22df4e6a7a2bd8b2460a22bdf6a6e59c5fdd -90f0ef0d7e7ab878170a196da1b8523488d33e0fde7481f6351558b312d00fa2b6b725b38539063f035d2a56a0f5e8f1 -a9ca028ccb373f9886574c2d0ea5184bc5b94d519aa07978a4814d649e1b6c93168f77ae9c6aa3872dd0eea17968ec22 -82e7aa6e2b322f9f9c180af585b9213fb9d3ad153281f456a02056f2d31b20d0f1e8807ff0c85e71e7baca8283695403 -affce186f842c547e9db2dffc0f3567b175be754891f616214e8c341213cbf7345c9ecd2f704bb0f4b6eba8845c8d8a7 -ab119eb621fade27536e98c6d1bc596388bb8f5cad65194ea75c893edbe6b4d860006160f1a9053aea2946bd663e5653 -99cd2c1c38ead1676657059dc9b43d104e8bd00ae548600d5fc5094a4d875d5b2c529fac4af601a262045e1af3892b5e -b531a43b0714cc638123487ef2f03dfb5272ff399ff1aa67e8bc6a307130d996910fb27075cbe53050c0f2902fc32ffe -923b59ac752c77d16b64a2d0a5f824e718460ef78d732b70c4c776fecc43718ecfaf35f11afbb544016232f445ecab66 -a53439cd05e6e1633cdce4a14f01221efcd3f496ac1a38331365c3cadc30013e5a71600c097965927ee824b9983a79cb -8af976ffab688d2d3f9e537e2829323dda9abf7f805f973b7e0a01e25c88425b881466dee37b25fda4ea683a0e7b2c03 -92e5f40230a9bfbb078fa965f58912abb753b236f6a5c28676fb35be9b7f525e25428160caeaf0e3645f2be01f1a6599 -8c4e7b04e2f968be527feba16f98428508a157b7b4687399df87666a86583b4446a9f4b86358b153e1660bb80bd92e8b -97cd622d4d8e94dceb753c7a4d49ea7914f2eb7d70c9f56d1d9a6e5e5cc198a3e3e29809a1d07d563c67c1f8b8a5665a -967bfa8f411e98bec142c7e379c21f5561f6fd503aaf3af1a0699db04c716c2795d1cb909cccbcb917794916fdb849f1 -b3c18a6caa5ca2be52dd500f083b02a4745e3bcaed47b6a000ce7149cee4ed7a78d2d7012bf3731b1c15c6f04cbd0bd1 -b3f651f1f84026f1936872956a88f39fcfe3e5a767233349123f52af160f6c59f2c908c2b5691255561f0e70620c8998 -ae23b59dc2d81cec2aebcaaf607d7d29cf588f0cbf7fa768c422be911985ca1f532bb39405f3653cc5bf0dcba4194298 -a1f4da396f2eec8a9b3252ea0e2d4ca205f7e003695621ae5571f62f5708d51ca3494ac09c824fca4f4d287a18beea9a -a036fa15e929abed7aac95aa2718e9f912f31e3defd224e5ed379bf6e1b43a3ad75b4b41208c43d7b2c55e8a6fedca72 -80e8372d8a2979ee90afbdb842624ace72ab3803542365a9d1a778219d47f6b01531185f5a573db72213ab69e3ffa318 -af68b5cdc39e5c4587e491b2e858a728d79ae7e5817a93b1ea39d34aec23dea452687046c8feae4714def4d0ed71da16 -b36658dfb756e7e9eec175918d3fe1f45b398679f296119cd53be6c6792d765ef5c7d5afadc5f3886e3f165042f4667f -ad831da03b759716f51099d7c046c1a8e7bf8bb45a52d2f2bfd769e171c8c6871741ef8474f06e2aca6d2b141cf2971f -8bae1202dde053c2f59efc1b05cb8268ba9876e4bd3ff1140fa0cc5fa290b13529aede965f5efdff3f72e1a579efc9cc -86344afbc9fe077021558e43d2a032fcc83b328f72948dba1a074bb1058e8a8faec85b1c019fc9836f0d11d2585d69c8 -831d1fc7aa28f069585d84c46bdc030d6cb12440cfaae28098365577fc911c4b8f566d88f80f3a3381be2ec8088bf119 -899de139797ac1c8f0135f0656f04ad4f9b0fa2c83a264d320eb855a3c0b9a4907fc3dc01521d33c07b5531e6a997064 -855bc752146d3e5b8ba7f382b198d7dc65321b93cdfc76250eabc28dba5bbf0ad1be8ccda1adf2024125107cb52c6a6e -af0aeccab48eb35f8986cabf07253c5b876dd103933e1eee0d99dc0105936236b2a6c413228490ed3db4fa69aab51a80 -ae62e9d706fbf535319c909855909b3deba3e06eaf560803fa37bce3b5aab5ea6329f7609fea84298b9da48977c00c3b -823a8d222e8282d653082d55a9508d9eaf9703ce54d0ab7e2b3c661af745a8b6571647ec5bd3809ae6dddae96a220ea7 -a4c87e0ea142fc287092bc994e013c85e884bc7c2dde771df30ca887a07f955325c387b548de3caa9efa97106da8176a -b55d925e2f614f2495651502cf4c3f17f055041fa305bb20195146d896b7b542b1e45d37fa709ca4bfc6b0d49756af92 -b0ebe8947f8c68dc381d7bd460995340efcbb4a2b89f17077f5fde3a9e76aef4a9a430d1f85b2274993afc0f17fdbead -8baaa640d654e2652808afd68772f6489df7cad37b7455b9cd9456bdddae80555a3f84b68906cc04185b8462273dcfc9 -add9aa08f827e7dc292ac80e374c593cd40ac5e34ad4391708b3db2fe89550f293181ea11b5c0a341b5e3f7813512739 -909e31846576c6bdd2c162f0f29eea819b6125098452caad42451491a7cde9fd257689858f815131194200bca54511f4 -abc4b34098db10d71ce7297658ef03edfa7377bd7ed36b2ffbab437f8fd47a60e2bcfbc93ff74c85cfce74ca9f93106c -857dbecc5879c1b952f847139484ef207cecf80a3d879849080758ef7ac96acfe16a11afffb42daf160dc4b324279d9b -aab0b49beecbcf3af7c08fbf38a6601c21061bed7c8875d6e3c2b557ecb47fd93e2114a3b09b522a114562467fcd2f7d -94306dec35e7b93d43ed7f89468b15d3ce7d7723f5179cacc8781f0cf500f66f8c9f4e196607fd14d56257d7df7bf332 -9201784d571da4a96ef5b8764f776a0b86615500d74ec72bc89e49d1e63a3763b867deca07964e2f3914e576e2ca0ded -aabe1260a638112f4280d3bdea3c84ce3c158b81266d5df480be02942cecf3de1ac1284b9964c93d2db33f3555373dcc -8ef28607ca2e0075aa07de9af5a0f2d0a97f554897cab8827dfe3623a5e9d007d92755d114b7c390d29e988b40466db9 -87a9b1b097c3a7b5055cd9cb0c35ba6251c50e21c74f6a0bca1e87e6463efc38385d3acc9d839b4698dfa2eb4cb7a2ef -aee277e90d2ffce9c090295c575e7cd3bafc214d1b5794dd145e6d02d987a015cb807bd89fd6268cd4c59350e7907ee2 -836ad3c9324eaa5e022e9835ff1418c8644a8f4cd8e4378bd4b7be5632b616bb6f6c53399752b96d77472f99ece123cd -8ffffdb67faa5f56887c834f9d489bb5b4dab613b72eac8abf7e4bcb799ccd0dbd88a2e73077cadf7e761cb159fb5ec5 -9158f6cd4f5e88e6cdb700fddcbc5a99b2d31a7a1b37dce704bd9dd3385cca69607a615483350a2b1153345526c8e05d -a7ff0958e9f0ccff76742fc6b60d2dd91c552e408c84172c3a736f64acb133633540b2b7f33bc7970220b35ce787cd4e -8f196938892e2a79f23403e1b1fb4687a62e3a951f69a7874ec0081909eb4627973a7a983f741c65438aff004f03ba6f -97e3c1981c5cdb0a388f1e4d50b9b5b5f3b86d83417831c27b143698b432bb5dba3f2e590d6d211931ed0f3d80780e77 -903a53430b87a7280d37816946245db03a49e38a789f866fe00469b7613ee7a22d455fb271d42825957282c8a4e159d9 -b78955f686254c3994f610e49f1c089717f5fb030da4f9b66e9a7f82d72381ba77e230764ab593335ff29a1874848a09 -938b6d04356b9d7c8c56be93b0049d0d0c61745af7790edf4ef04e64de2b4740b038069c95be5c91a0ba6a1bb38512a9 -a769073b9648fe21bc66893a9ef3b8848d06f4068805a43f1c180fdd0d37c176b4546f8e5e450f7b09223c2f735b006f -863c30ebe92427cdd7e72d758f2c645ab422e51ecef6c402eb1a073fd7f715017cd58a2ad1afe7edccdf4ff01309e306 -a617b0213d161964eccfc68a7ad00a3ee4365223b479576e887c41ef658f846f69edf928bd8da8785b6e9887031f6a57 -a699834bf3b20d345082f13f360c5f8a86499e498e459b9e65b5a56ae8a65a9fcb5c1f93c949391b4795ef214c952e08 -9921f1da00130f22e38908dd2e44c5f662ead6c4526ebb50011bc2f2819e8e3fca64c9428b5106fa8924db76b7651f35 -98da928be52eb5b0287912fd1c648f8bbda00f5fd0289baf161b5a7dbda685db6ad6bdc121bc9ffa7ed6ae03a13dbee3 -927b91d95676ff3c99de1312c20f19251e21878bfb47ad9f19c9791bc7fb9d6f5c03e3e61575c0760180d3445be86125 -b8e4977a892100635310dfcb46d8b74931ac59ae687b06469b3cee060888a3b6b52d89de54e173d9e1641234754b32b1 -98f6fd5f81ca6e2184abd7a3a59b764d4953d408cec155b4e5cf87cd1f6245d8bdd58b52e1e024e22903e85ae15273f1 -909aaacbbfe30950cf7587faa190dc36c05e3c8131749cc21a0c92dc4afc4002275762ca7f66f91aa751b630ad3e324d -91712141592758f0e43398c075aaa7180f245189e5308e6605a6305d01886d2b22d144976b30460d8ce17312bb819e8f -947d85cb299b189f9116431f1c5449f0f8c3f1a70061aa9ebf962aa159ab76ee2e39b4706365d44a5dbf43120a0ac255 -b39eced3e9a2e293e04d236976e7ee11e2471fe59b43e7b6dd32ab74f51a3d372afee70be1d90af017452ec635574e0e -8a4ba456491911fc17e1cadcbb3020500587c5b42cf6b538d1cb907f04c65c168add71275fbf21d3875e731404f3f529 -8f6858752363e2a94c295e0448078e9144bf033ccd4d74f4f6b95d582f3a7638b6d3f921e2d89fcd6afd878b12977a9d -b7f349aa3e8feb844a56a42f82b6b00f2bfe42cab19f5a68579a6e8a57f5cf93e3cdb56cbbb9163ab4d6b599d6c0f6aa -a4a24dc618a6b4a0857fb96338ac3e10b19336efc26986e801434c8fdde42ca8777420722f45dfe7b67b9ed9d7ce8fb1 -aafe4d415f939e0730512fc2e61e37d65c32e435991fb95fb73017493014e3f8278cd0d213379d2330b06902f21fe4e1 -845cc6f0f0a41cc6a010d5cb938c0ef8183ff5ed623b70f7ea65a8bdbc7b512ea33c0ee8b8f31fdf5f39ec88953f0c1e -811173b4dd89d761c0bdffe224cd664ef303c4647e6cf5ef0ed665d843ed556b04882c2a4adfc77709e40af1cfdea40b -93ba1db7c20bfba22da123b6813cb38c12933b680902cef3037f01f03ab003f76260acc12e01e364c0d0cf8d45fca694 -b41694db978b2cf0f4d2aa06fcfc4182d65fb7c9b5e909650705f779b28e47672c47707d0e5308cd680c5746c37e1bc7 -a0e92c4c5be56a4ccf1f94d289e453a5f80e172fc90786e5b03c1c14ce2f3c392c349f76e48a7df02c8ae535326ea8fe -96cbeb1d0693f4f0b0b71ad30def5ccc7ad9ebe58dbe9d3b077f2ac16256cde10468875e4866d63e88ce82751aaf8ef6 -935b87fd336f0bf366046e10f7c2f7c2a2148fa6f53af5607ad66f91f850894527ecec7d23d81118d3b2ee23351ed6ed -b7c2c1fa6295735f6b31510777b597bc8a7bfb014e71b4d1b5859be0d8d64f62a1587caafc669dfe865b365eb27bd94f -b25d93af43d8704ffd53b1e5c16953fd45e57a9a4b7acfcfa6dd4bf30ee2a8e98d2a76f3c8eba8dc7d08d9012b9694c6 -b5a005cd9f891e33882f5884f6662479d5190b7e2aec1aa5a6d15a8cb60c9c983d1e7928e25e4cf43ec804eaea1d97b0 -93f9f0725a06e4a0fb83892102b7375cf5438b5ebc9e7be5a655f3478d18706cf7dbb1cd1adcee7444c575516378aa1b -900d7cbf43fd6ac64961287fe593c08446874bfc1eb09231fc93de858ac7a8bca496c9c457bced5881f7bf245b6789e0 -90c198526b8b265d75160ef3ed787988e7632d5f3330e8c322b8faf2ac51eef6f0ce5a45f3b3a890b90aecf1244a3436 -b499707399009f9fe7617d8e73939cb1560037ad59ac9f343041201d7cc25379df250219fd73fa012b9ade0b04e92efa -94415f6c3a0705a9be6a414be19d478181d82752b9af760dda0dbd24a8ff0f873c4d89e61ad2c13ebf01de55892d07fa -90a9f0b9f1edb87751c696d390e5f253586aae6ebfc31eb3b2125d23877a497b4aa778de8b11ec85efe49969021eaa5a -a9942c56506e5cd8f9289be8205823b403a2ea233ba211cf72c2b3827064fd34cd9b61ff698a4158e7379891ca4120d8 -83bb2ee8c07be1ab3a488ec06b0c85e10b83a531758a2a6741c17a3ccfa6774b34336926a50e11c8543d30b56a6ac570 -8a08a3e5ebe10353e0b7fff5f887e7e25d09bb65becf7c74a03c60c166132efaada27e5aea242c8b9f43b472561ae3ed -957c7a24cefaa631fe8a28446bc44b09a3d8274591ade53ba489757b854db54820d98df47c8a0fbee0e094f8ad7a5dc4 -b63556e1f47ed3ee283777ed46b69be8585d5930960d973f8a5a43508fc56000009605662224daec2de54ea52a8dcd82 -abed2b3d16641f0f459113b105f884886d171519b1229758f846a488c7a474a718857323c3e239faa222c1ab24513766 -882d36eed6756d86335de2f7b13d753f91c0a4d42ef50e30195cc3e5e4f1441afa5ff863022434acb66854eda5de8715 -a65ea7f8745bb8a623b44e43f19158fd96e7d6b0a5406290f2c1348fc8674fbfc27beb4f724cc2b217c6042cb82bc178 -a038116a0c76af090a069ca289eb2c3a615b96093efacfe68ea1610890b291a274e26b445d34f414cfec00c333906148 -90294f452f8b80b0a47c3bcb6e30bdd6854e3b01deaf93f5e82a1889a4a1036d17ecb59b48efa7dc41412168d7a523dd -88faf969c8978a756f48c6114f7f33a1ca3fd7b5865c688aa9cd32578b1f7ba7c06120502f8dc9aee174ecd41597f055 -8883763b2762dfff0d9be9ac19428d9fd00357ac8b805efda213993152b9b7eb7ba3b1b2623015d60778bffda07a724d -a30a1a5a9213636aa9b0f8623345dc7cf5c563b906e11cc4feb97d530a1480f23211073dcb81105b55193dcde5a381d2 -b45ee93c58139a5f6be82572d6e14e937ef9fcbb6154a2d77cb4bf2e4b63c5aabc3277527ecf4e531fe3c58f521cc5e3 -ac5a73e4f686978e06131a333f089932adda6c7614217fcaf0e9423b96e16fd73e913e5e40bf8d7800bed4318b48d4b1 -b6c1e6cdd14a48a7fe27cd370d2e3f7a52a91f3e8d80fb405f142391479f6c6f31aa5c59a4a0fdc9e88247c42688e0cf -ab1760530312380152d05c650826a16c26223960fc8e3bf813161d129c01bac77583eff04ce8678ff52987a69886526b -a4252dffae7429d4f81dfaeeecc48ab922e60d6a50986cf063964f282e47407b7e9c64cf819da6f93735de000a70f0b2 -94c19f96d5ecf4a15c9c5a24598802d2d21acbbd9ee8780b1bc234b794b8442437c36badc0a24e8d2cff410e892bb1d2 -89fafe1799cf7b48a9ea24f707d912fccb99a8700d7287c6438a8879f3a3ca3e60a0f66640e31744722624139ba30396 -b0108405df25cf421c2f1873b20b28552f4d5d1b4a0bf1c202307673927931cbd59f5781e6b8748ddb1206a5ec332c0b -aa0f0e7d09f12b48f1e44d55ec3904aa5707e263774126e0b30f912e2f83df9eb933ca073752e6b86876adaf822d14ba -b0cbe8abb58876d055c8150d9fdbde4fea881a517a2499e7c2ea4d55c518a3c2d00b3494f6a8fd1a660bfca102f86d2a -b1ef80ec903bac55f58b75933dc00f1751060690fd9dfb54cf448a7a4b779c2a80391f5fda65609274bd9e0d83f36141 -8b52e05b1845498c4879bb12816097be7fc268ce1cf747f83a479c8e08a44159fc7b244cf24d55aca06dccf0b97d11e1 -b632a2fc4fdb178687e983a2876ae23587fd5b7b5e0bb8c0eb4cfe6d921a2c99894762e2aaccdc5da6c48da3c3c72f6c -953ef80ab5f74274ae70667e41363ae6e2e98ccbd6b7d21f7283f0c1cafb120338b7a8b64e7c189d935a4e5b87651587 -b929cfd311017c9731eed9d08d073f6cf7e9d4cd560cddd3fdcb1149ab20c6610a7674a66a3616785b13500f8f43ee86 -870fb0d02704b6a328e68721fb6a4b0f8647681bfcb0d92ec3e241e94b7a53aecc365ed384e721c747b13fbf251002f1 -979501159833a8ba5422ed9b86f87b5961711f5b474d8b0e891373fe2d0b98ff41a3a7a74a8b154615bb412b662a48be -b20f9c13cdeceef67f877b3878839ef425f645b16a69c785fe38f687c87a03b9de9ae31ac2edb1e1dd3a9f2c0f09d35d -8c7705ed93290731b1cf6f3bf87fc4d7159bb2c039d1a9f2246cda462d9cdf2beef62d9f658cfeea2e6aef7869a6fc00 -aa439eb15705ad729b9163daee2598d98a32a8a412777c0d12fd48dc7796d422227a014705e445cc9d66f115c96bbc24 -a32307e16f89749fe98b5df1effef0429801c067e0d8067794e56b01c4fef742ad5e7ab42a1a4cc4741808f47a0b7cb8 -b31e65c549003c1207258a2912a72f5bad9844e18f16b0773ea7af8ff124390eb33b2f715910fc156c104572d4866b91 -85608d918ed7b08a0dc03aee60ea5589713304d85eee7b4c8c762b6b34c9355d9d2e192575af0fd523318ae36e19ae1c -a6497dbaf0e7035160b7a787150971b19cf5ba272c235b0113542288611ebecefa2b22f08008d3f17db6a70a542c258d -87862adb1ac0510614ab909457c49f9ec86dc8bdf0e4682f76d2739df11f6ffcfb59975527f279e890d22964a1fba9b6 -8717ac3b483b3094c3b642f3fafe4fbafc52a5d4f2f5d43c29d9cfe02a569daee34c178ee081144494f3a2ca6e67d7b1 -855100ac1ec85c8b437fdd844abaa0ca4ac9830a5bdd065b68dafb37046fcf8625dd482dc0253476926e80a4c438c9ec -ae74821bf265ca3c8702c557cf9ef0732ede7ef6ed658283af669d19c6f6b6055aca807cf2fa1a64785ec91c42b18ae5 -812a745b1419a306f7f20429103d6813cbdea68f82ff635ac59da08630cd61bda6e0fa9a3735bfd4378f58ad179c1332 -867dbbfe0d698f89451c37ca6d0585fd71ee07c3817e362ef6779b7b1d70b27c989cdd5f85ac33a0498db1c4d14521fe -84db735d3eb4ff7f16502dccc3b604338c3a4a301220ad495991d6f507659db4b9f81bba9c528c5a6114bcdba0160252 -aadc83d1c4e5e32bf786cfb26f2f12a78c8024f1f5271427b086370cdef7a71d8a5bf7cd7690bae40df56c38b1ad2411 -a27860eb0caaea37298095507f54f7729d8930ac1929de3b7a968df9737f4c6da3173bda9d64ff797ed4c6f3a1718092 -a3cdcaa74235c0440a34171506ed03d1f72b150d55904ce60ec7b90fcd9a6f46f0e45feab0f9166708b533836686d909 -b209a30bdac5c62e95924928f9d0d0b4113ebb8b346d7f3a572c024821af7f036222a3bd38bd8efd2ee1dbf9ac9556cd -83c93987eff8bc56506e7275b6bef0946672621ded641d09b28266657db08f75846dcbde80d8abc9470e1b24db4ca65b -800c09b3ee5d0251bdaef4a82a7fe8173de997cc1603a2e8df020dd688a0c368ad1ebef016b35136db63e774b266c74c -93fb52de00d9f799a9bce3e3e31aaf49e0a4fc865473feb728217bd70f1bc8a732ec37ac3582bf30ab60e8c7fdf3cb8d -a1aff6b4a50d02f079a8895c74443539231bfdf474600910febf52c9151da7b31127242334ac63f3093e83a047769146 -8c4532d8e3abb5f0da851138bfa97599039bcd240d87bbdf4fd6553b2329abb4781074b63caf09bc724ceb4d36cb3952 -8bd9b0ae3da5acda9eb3881172d308b03beec55014cd73b15026299541c42fd38bab4983a85c06894ebb7a2af2a23d4c -979441e7f5a0e6006812f21b0d236c5f505bb30f7d023cb4eb84ec2aa54a33ac91d87ece704b8069259d237f40901356 -a1c6d2d82e89957d6a3e9fef48deb112eb00519732d66d55aa0f8161e19a01e83b9f7c42ac2b94f337dcc9865f0da837 -97a0b8e04e889d18947d5bf77d06c25bbd62b19ce4be36aaa90ddbeafd93a07353308194199ba138efaadf1b928cd8d2 -822f7fbe9d966b8ec3db0fc8169ab39334e91bf027e35b8cc7e1fe3ead894d8982505c092f15ddfe5d8f726b360ac058 -a6e517eedd216949e3a10bf12c8c8ddbfde43cddcd2c0950565360a38444459191bdbc6c0af0e2e6e98bc6a813601c6d -858b5f15c46c074adb879b6ba5520966549420cb58721273119f1f8bc335605aeb4aa6dbe64aae9e573ca7cc1c705cdc -b5191bb105b60deb10466d8114d48fb95c4d72036164dd35939976e41406dff3ee3974c49f00391abfad51b695b3258c -b1b375353ed33c734f4a366d4afad77168c4809aff1b972a078fd2257036fd6b7a7edad569533abf71bc141144a14d62 -a94c502a9cdd38c0a0e0187de1637178ad4fa0763887f97cc5bdd55cb6a840cb68a60d7dbb7e4e0e51231f7d92addcff -8fe2082c1b410486a3e24481ae0630f28eb5b488e0bb2546af3492a3d9318c0d4c52db1407e8b9b1d1f23a7ffbaf260a -b73fe7aa2b73f9cae6001af589bf8a9e73ea2bb3bb01b46743e39390c08d8e1be5e85a3d562857a9c9b802b780c78e6d -8e347f51330ae62275441ccd60f5ac14e1a925a54ced8a51893d956acc26914df1bb8595385d240aa9b0e5ada7b520ea -8dc573d6357c0113b026a0191a5807dbe42dcd2e19772d14b2ca735e1e67c70e319ef571db1f2a20e62254ed7fb5bcd6 -a5dacbe51549fe412e64af100b8b5eba5ec2258cc2a7c27a34bc10177d1894baf8707886d2f2ef438f077596a07681e9 -8349153c64961d637a5ff56f49003cb24106de19a5bbcf674016a466bfbe0877f5d1e74ccb7c2920665ef90a437b1b7e -96ad35429d40a262fdc8f34b379f2e05a411057d7852c3d77b9c6c01359421c71ef8620f23854e0f5d231a1d037e3a0d -b52385e40af0ed16e31c2154d73d1517e10a01435489fc801fbea65b92b3866ab46dab38d2c25e5fb603b029ae727317 -8e801c7a3e8fa91d9c22ebd3e14a999023a7b5beea13ec0456f7845425d28c92452922ca35ec64012276acb3bbc93515 -a8630870297d415e9b709c7f42aa4a32210b602f03a3015410123f0988aea2688d8bcfc6d07dc3602884abbf6199b23f -8cd518392e09df2a3771a736f72c05af60efc030d62dbbb9cd68dc6cbbe1fb0854eb78b6ed38337010eb1bb44a5d5d30 -921aa4c66590f6c54bf2fa2b324f08cbe866329cc31f6e3477f97f73e1a1721d5eb50ed4eacc38051fe9eda76ba17632 -a37e595cb63524cb033c5540b6343c3a292569fc115e813979f63fe1a3c384b554cecc2cae76b510b640fe3a18800c81 -b0bb57e4e31ae3ce9f28cef158ed52dabfad5aa612f5fcc75b3f7f344b7cec56b989b5690dacd294e49c922d550ee36b -a3c618ce4d091e768c7295d37e3f9b11c44c37507ae1f89867441f564bf0108f67bf64b4cf45d73c2afc17a4dc8b2c68 -999e6650eda5455e474c22a8c7a3fd5b547ec2875dc3043077ad70c332f1ccd02135e7b524fcbf3621d386dec9e614fa -b018f080888dec3c2ca7fcfeb0d3d9984699b8435d8823079fc9e1af4ca44e257fbe8da2f6f641ee6152b5c7110e3e3c -a2bcd4bcd9b40c341e9bba76b86481842f408166c9a7159205726f0776dcb7f15a033079e7589699e9e94ce24b2a77fd -b03de48f024a520bb9c54985ca356fd087ca35ac1dd6e95168694d9dae653138c9755e18d5981946a080e32004e238fe -a6c1a54973c0c32a410092441e20594aa9aa3700513ed90c8854956e98894552944b0b7ee9edf6e62e487dc4565baa2f -845d7abf577c27c4c1fafc955dcad99a1f2b84b2c978cfe4bd3cd2a6185979491f3f3b0ec693818739ed9184aba52654 -9531bcfc0d3fcd4d7459484d15607d6e6181cee440ba6344b12a21daa62ff1153a4e9a0b5c3c33d373a0a56a7ad18025 -a0bbf49b2dd581be423a23e8939528ceaae7fb8c04b362066fe7d754ca2546304a2a90e6ac25cdf6396bf0096fae9781 -a1ec264c352e34ed2bf49681b4e294ffea7d763846be62b96b234d9a28905cdece4be310a56ec6a00fc0361d615b547c -87c575e85b5dfbfd215432cb355a86f69256fff5318e8fda457763ac513b53baa90499dc37574bdfad96b117f71cb45e -9972edfdeec56897bef4123385ee643a1b9dc24e522752b5a197ce6bd2e53d4b6b782b9d529ca50592ee65b60e4c9c3c -b8bcf8d4ab6ad37bdd6ad9913a1ba0aba160cb83d1d6f33a8524064a27ba74a33984cc64beeee9d834393c2636ff831a -83082b7ec5b224422d0ff036fbb89dc68918e6fde4077dfc0b8e2ee02595195ecadb60c9ab0ad69deb1bac9be75024fa -8b061fce6df6a0e5c486fd8d8809f6f3c93bd3378a537ff844970492384fb769d3845d0805edd7f0fcd19efabf32f197 -b9597e717bb53e6afae2278dbc45d98959c7a10c87c1001ed317414803b5f707f3c559be6784119d08f0c06547ec60b1 -b9d990fd7677dd80300714cfd09336e7748bbf26f4bb0597406fcb756d8828c33695743d7a3e3bd6ddf4f508149610ef -b45f7d2b00ceea3bf6131b230b5b401e13a6c63ba8d583a4795701226bf9eb5c88506f4a93219ac90ccbceef0bfd9d49 -a8ccaa13ca7986bc34e4a4f5e477b11ae91abb45c8f8bf44a1f5e839289681495aba3daa8fb987e321d439bbf00be789 -ae0f59f7a94288a0ead9a398fdd088c2f16cccb68624de4e77b70616a17ddf7406ca9dc88769dadeb5673ff9346d6006 -b28e965dcc08c07112ae3817e98f8d8b103a279ad7e1b7c3de59d9dbd14ab5a3e3266775a5b8bbf0868a14ae4ab110f1 -84751c1a945a6db3df997fcbde9d4fe824bc7ba51aa6cb572bb5a8f9561bef144c952198a783b0b5e06f9dd8aa421be8 -a83586db6d90ef7b4fa1cbda1de1df68ee0019f9328aded59b884329b616d888f300abb90e4964021334d6afdea058fd -8fcea1ce0abf212a56c145f0b8d47376730611e012b443b3d1563498299f55cbcbe8cbd02f10b78224818bb8cbbd9aaa -8d66c30a40c34f23bae0ea0999754d19c0eb84c6c0aa1b2cf7b0740a96f55dd44b8fee82b625e2dd6c3182c021340ac6 -92c9b35076e2998f1a0f720d5a507a602bd6bd9d44ffc29ede964044b17c710d24ce3c0b4a53c12195de93278f9ec83b -a37d213913aff0b792ee93da5d7e876f211e10a027883326d582ad7c41deebdfce52f86b57d07868918585908ebd070a -a03995b4c6863f80dd02ed0169b4f1609dc48174ec736de78be1cdff386648426d031f6d81d1d2a7f2c683b31e7628c0 -b08b628d481302aa68daf0fa31fd909064380d62d8ed23a49037cb38569058e4c16c80e600e84828d37a89a33c323d1f -a0ee2e2dd8e27661d7b607c61ac36f590909aa97f80bdfd5b42463ca147b610ac31a9f173cbecdd2260f0f9ea9e56033 -967162fba8b69ffce9679aac49214debb691c6d9f604effd6493ce551abacbe4c8cc2b0ccee6c9927c3d3cfbdcb0be11 -8deab0c5ed531ce99dadb98b8d37b3ff017f07438bc6d50840577f0f3b56be3e801181333b4e8a070135f9d82872b7f2 -b1bfa00ec8c9365b3d5b4d77a718cb3a66ed6b6cf1f5cf5c5565d3aa20f63d3c06bb13d47d2524e159debf81325ba623 -90109780e53aeacd540b9fe9fc9b88e83c73eaf3507e2b76edc67f97a656c06a8a9e1ec5bce58bfd98b59a6b9f81b89d -88a1009a39a40421fdcc0ffc3c78a4fbace96a4e53420b111218091223494e780a998ebecf5a0abd0243e1523df90b28 -90b77146711ee8d91b0346de40eca2823f4e4671a12dad486a8ec104c01ef5ee7ab9bd0398f35b02b8cb62917455f8b3 -b262c5e25f24ae7e0e321b66fdb73b3bf562ded566a2d6a0152cf8bafb56138d87b6a917a82f5ace65efc73cfc177d81 -ae65a438c7ea46c82925b5ec5f71314558ca5146f5d90311431d363cfeac0537223c02cbb50fa6535d72fc2d949f4482 -8984208bfc193a6ef4720cc9d40c17f4be2f14595ef887980f2e61fa6927f9d73c00220937013b46290963116cbe66ac -a8f33a580508f667fac866456dce5d9246562188ad0f568eb1a2f28cf9fd3452dd20dc613adb1d07a5542319a37ecf1a -aedadd705fc086d8d2b647c62e209e2d499624ab37c8b19af80229f85e64a6e608d9cd414cb95ae38cf147d80ec3f894 -ae28077a235cd959f37dc3daedc3706f7a7c2ffe324e695f2e65f454bf5a9fc27b10149a6268ebfaa961ad67bb9b75d7 -a234c7f5a5e0e30f2026d62657bd92d91a9907ec6a2177f91383f86abb919778121ff78afb8f52c473fe6fb731018b52 -816a2ea7826b778f559a815267b6c6eb588558391c0a675d61bb19470d87489ba6c1e2486ea81dd5420a42ee7c35a8de -9218b61948c14234f549c438105ae98367ef6b727ad185f17ad69a6965c044bb857c585b84d72ef4c5fb46962974eed7 -a628031217a0b1330b497351758cf72d90fb87d8bdf542ea32092e14ff32d5ef4ca700653794bb78514d4b0edfd7a8d7 -ab4e977141be639a78eb9ed17366f9642f9335873aca87cce2bae0dddc161621d0e23264a54a7395ae706d748c690ee9 -b1538c4edff59bcf5668557d994bac77d508c757e382512c4368c1ded4242a41f6200b73fe8809fb528a7a0c1fc96feb -965caabe5590e2ff8c9f1048bbdda2817e7a2847e287944bfab40d94cb48389441ac42ff3a7b559760bfab42ff82e1e0 -a64b7484d22c4b8047c7a8ef54dc88cb8d110c61ef28ba853821b61e87d318b2b4226f7f0d1f3cdf086a0e1666d0212c -8915ab7e41d974eef9a651b01c2521392e8899e6ab91c22aeee61605c78fb2b052399ba1d03473aa9cfb52d1a8ba4257 -8dd26875d4a1716db2f75a621d01e971983267770e2da92399aecf08f74af1f7e73643ac6f0a9b610eda54e5460f70ed -83dabcb84c9cbce67e1a24ecbfa4473766b9519588b22288edbaa29aca34cefd9884f7310e7771f8f7a7cbced2e7eea0 -956be00c67987fb4971afca261065a7f6fcef9fb6b1fcb1939f664bbc5b704223253ebfda48565624a68fb249742c2cf -a374824a24db1ab298bee759cee8d8260e0ac92cd1c196f896600fd57484a9f9be1912ded01203976ac4fab66c0e5091 -a225f2ed0de4e06c500876e68e0c58be49535885378584a1442aae2140c38d3ca35c1bc41936a3baf8a78e7ab516f790 -8e79c8de591a6c70e2ef2de35971888ab0ca6fd926fdb6e845fb4b63eb3831c5839f084201b951984f6d66a214b946b8 -91babc849a9e67ab40192342c3d0d6ce58798101cb85c9bd7fc0ac4509ffc17b5ea19e58045cf1ca09ec0dee0e18c8f9 -8b4897fc2aef5bbe0fa3c3015ca09fc9414fdb2315f54dbecc03b9ae3099be6c0767b636b007a804d8b248c56e670713 -8f63ba42e7459ea191a8ad18de0b90b151d5acbf4751e2c790e7d8328e82c20de518132d6290ff3c23d2601f21c1558e -a1a035dc9b936587a16665ea25646d0bb2322f81960d9b6468c3234c9137f7c2b1e4f0b9dbe59e290a418007b0e7a138 -81c4904c08f7bb2ac7b6d4ac4577f10dd98c318f35aac92fc31bab05eceb80a0556a7fc82614b8d95357af8a9c85a829 -8c40e44e5e8e65f61e0a01f79057e1cb29966cc5074de790ea9c60454b25d7ea2b04c3e5decb9f27f02a7f3d3cb7014f -ad8709e357094076eb1eb601539b7bcc37247a25fbc6ada5f74bb88b1b371917c2a733522190f076c44e9b8e2ae127fb -92d43cd82c943fd71b8700977244436c696df808c34d4633f0624700a3445f3ecc15b426c850f9fb60b9aa4708f2c7c0 -b2cb8080697d1524a6dcb640b25e7255ae2e560613dbd27beaa8c5fc5c8d2524b7e6edd6db7ad0bb8a4e2e2735d4a6f7 -971ca6393d9e312bfb5c33955f0325f34946d341ff7077151f0bcafd2e6cbd23e2ad62979454f107edc6a756a443e888 -b6a563f42866afcee0df6c6c2961c800c851aa962d04543541a3cedeb3a6a2a608c1d8391cf405428cd40254e59138f3 -986bd17bad9a8596f372a0185f7f9e0fb8de587cd078ae40f3cd1048305ba00954aff886b18d0d04640b718ea1f0d5a3 -ae32dbccfb7be8e9165f4e663b26f57c407f96750e0f3a5e8e27a7c0ca36bc89e925f64ddd116263be90ace4a27872c4 -83725445ec8916c7c2dd46899241a03cf23568ac63ae2d34de3bce6d2db0bc1cfd00055d850b644a059fb26c62ed3585 -a83f7e61c05b1c6797a36ad5ded01bf857a838147f088d33eb19a5f7652b88e55734e8e884d1d1103a50d4393dfcd7a8 -aa010b4ec76260d88855347df9eaf036911d5d178302063d6fd7ecad009e353162177f92240fe5a239acd1704d188a9d -a88f4ba3cf4aff68ec1e3ded24622d4f1b9812350f6670d2909ea59928eb1d2e8d66935634d218aeac6d1a0fc6cae893 -b819112b310b8372be40b2752c6f08426ef154b53ef2814ae7d67d58586d7023ffa29d6427a044a3b288e0c779866791 -b5d1e728de5daf68e63b0bb1dee5275edae203e53614edeeeefff0f2f7ac4281191a33b7811de83b7f68111361ef42e1 -953fb3ddc6f78045e53eaacfd83c5c769d32608b29391e05612e4e75725e54e82ad4960fbef96da8b2f35ba862968a3e -936471136fb2c1b3bb986a5207a225a8bf3b206a1a9db54dc3029e408e78c95bfb7539b67006d269c09df6354d7254ac -ac353364b413cae799b13d7dc6fa09c322b47e60b9333e06499155e22d913929b92a45a0ad04ba90b29358f7b792d864 -a0177419ead02ba3f0755a32eee3fd23ec81a13c01eab462f3b0af1e2dba42f81b47b2c8b1a90d8cec5a0afa371b7f11 -b009eeb5db80d4244c130e6e3280af120917bb6fcebac73255c09f3f0c9da3b2aa718cd92d3d40e6b50737dbd23461aa -b8a43426c3746c1a5445535338c6a10b65474b684a2c81cd2f4b8ebecc91a57e2e0687df4a40add015cd12e351bbb3eb -94ff3698a6ac6e7df222675a00279c0ea42925dc6b748e3e74a62ea5d1e3fd70d5ab2d0c20b83704d389dd3a6063cf1a -90e4142e7ce15266144153e21b9893d3e14b3b4d980e5c87ce615ecd27efac87d86fa90354307857f75d7ebaeffe79ef -a5fd82c3f509ec9a36d72ba204a16f905e1e329f75cfd18aaa14fb00a212d21f3fac17e1a8e3bc5691ab0d07f8ec3cd0 -962e6bfd75ea554f304a5fee1123e5bf2e048ccd3b401716b34c52740384579188ac98bc0d91269fc814de23f4b2dd34 -b50b4e45c180badf9cd842cd769f78f963e077a9a4c016098dc19b18210580ad271ae1ba86de7760dd2e1f299c13f6a0 -84cf08858d08eca6acc86158ffda3fbe920d1d5c04ac6f1fc677760e46e66599df697397373959acf319c31e47db115c -a697a38ba21caa66b7739ed0e74fe762a3da02144b67971fcad28c1132d7b83e0ac062cc71479f99e2219086d7d23374 -ad1f6d01dd7f0de814fe5fbb6f08c1190ff37f4a50754d7b6291fc547c0820506ea629aabacf749fec9c1bbfda22d2d0 -b11fd7f8c120d8a370a223a1adc053a31bef7454b5522b848dec82de5482308fc68fdaf479875b7a4bc3fc94e1ea30eb -93ecf90ebfc190f30086bcaeee18cda972073a8469cf42a3b19f8c1ec5419dff2d6a5cc8ef412ccd9725b0f0a5f38f88 -911f25aaa5260b56b3009fa5e1346a29f13a085cf8a61b36b2d851791f7bcf8456840eccbfc23797b63ecd312e2d5e12 -a52f17a8b2db66c98291020b1db44ab23827e1790e418e078d1316185df6aa9f78292f43a12cd47131bd4b521d134060 -9646fca10bf7401e91d9a49753c72f3ecb142f5ed13aba2c510a6c5ccb8d07b8e8d1581fc81321ad5e3996b6d81b5538 -aa1da4a5665b91b62dda7f71bb19c8e3f6f49cc079d94fcd07b3604a74547e8334efa5a202822d0078158056bbda2822 -a2432ae5feeaf38252c28aa491e92a68b47d5b4c6f44c1b3d7f3abc2f10b588f64a23c3357e742a0f5e4f216e7ca5827 -83c7b47735cd0ef80658a387f34f259940096ebb9464c67919b278db4109fea294d09ea01a371b79b332cff6777c116d -a740a2959e86e413c62d6bdd1bc27efe9596ee363c2460535eab89ba1715e808b658bd9581b894b5d5997132b0c9c85c -b76947237fa9d71c3bece0b4f7119d7f94d2162d0ced52f2eac4de92b41da5b72ad332db9f31ebb2df1c02f400a76481 -a20e1f2b7e9cc1443226d2b1a29696f627c83836116d64d2a5559d08b67e7e4efa9a849f5bb93a0dadb62450f5a9eaab -b44bff680fba52443a5b3bd25f69c5640006d544fca1d3dc11482ee8e03b4463aae59d1ec9d200aa6711ce72350580fb -a9490f5643bacec7e5adcda849ab3e7ff1f89026bf7597980b13a09887376f243158d0035e9d24fdee7cb6500e53ef29 -96081010b82c04ad0bfc3605df622db27c10a91494685ef2e6e1839c218b91cbb56e043e9a25c7b18c5ddee7c6769517 -a9522d59bcf887cbbbc130d8de3ff29a86df5d9343a918f5e52c65a28e4c33f6106ac4b48ecd849a33d39eeb2319d85b -aa5e0cea1a1db2283783788b4d77c09829563b75c503c154fdaa2247c9149918edac7737ef58c079e02dca7d8397b0eb -8c03f064e777d0c07c4f04c713a86bf581cc85155afe40e9065ead15139b47a50ead5c87ac032f01b142d63ff849758a -a34d672bf33def02ee7a63e6d6519676c052fa65ca91ed0fe5fdd785c231ba7af19f1e990fc33f5d1d17e75f6af270be -8680443393e8ac45a0b07c30a82ac18e67dcc8f20254bd5ede7bf99fc03e6123f2fcd64c0ca62f69d240f23acd777482 -a4e00ab43d8ae5b13a6190f8ef5395ec17fbac4aa7dfa25b33e81b7e7bf63a4c28910b3a7dc9204dbc4168b08575a75e -8249259066ee5672b422c1889ab5ed620bddd1297f70b4197c40bb736afba05d513b91d3a82ee030336c311d952cd60c -a0651d8cf34fa971bde1ec037158a229e8e9ad4b5ca6c4a41adedb6d306a7772634f703dcfac36f9daf17289f33c23fb -b02ff6e8abff19969e265395ceaf465f43e7f1c3c9cfc91f1748042d9c352b284e49515a58078c877a37ff6915ee8bf4 -927fb7351ac28254458a1a2ea7388e1fbd831fbc2feedb230818f73cc8c505b7ff61e150898ce1567fcb0d2c40881c7b -a9d3861f72090bc61382a81286bb71af93cdeefab9a83b3c59537ad21810104e0e054859eeafa13be10f8027b6fc33b8 -a523306656730b1a31b9a370c45224b08baf45773d62952a0bf7d6c4684898ae78914cfafbd3e21406407cc39e12afdc -947a090e7703a3ea303a4a09b3ab6b6d3fda72912c9f42cc37627557028b4667f5398a6d64b9281fa2efbe16f6c61ed6 -b41d24d40c10239c85d5b9bf1a3886d514a7a06b31ca982ea983e37162293350b12428eabc9f6a460473ad811e61ba40 -b0bb9805724f4ca860e687985c0dc6b8f9017fe71147e5383cfbbbdcb2a42c93c7062ba42acdead9d992b6f48fc1d5ac -aec775aa97a78851893d3c5c209a91267f1daf4205bfb719c44a9ed2614d71854b95bb523cd04a7f818a4a70aa27d8fc -b53e52e32ca90b38987610585ad5b77ecd584bd22c55af7d7c9edf5fbcae9c9241b55200b51eaed0fbdb6f7be356368f -a2c5ac7822c2529f0201717b4922fb30fb037540ab222c97f0cdac341d09ccb1415e7908288fabef60177c0643ed21bf -92162fda0cbd1dafbed9419ae0837e470451403231ee086b49a21d20de2e3eed7ce64382153272b02cf099106688af70 -8452d5df66682396718a76f219a9333a3559231e5f7f109a1f25c1970eb7c3408a5e32a479357f148af63b7a1d352451 -831ea95d4feb520994bc4904017a557797e7ad455a431d94de03b873a57b24b127fcc9ff5b97c255c6c8d8e18c5c7e12 -93d451d5e0885ccdbb113a267c31701e7c3d9e823d735dc9dfd6cfdcd82767012dc71396af53d3bedd2e0d9210acf57f -a2126f75a768dcc7ebddf2452aebf20ad790c844442b78e4027c0b511a054c27efb987550fcab877c46f2c7be4883ae0 -aa4d2dcba2ccfc11a002639c30af6beb35e33745ecbab0627cf0f200fdae580e42d5a8569a9c971044405dfdafed4887 -ab13616069ef71d308e8bf6724e13737dc98b06a8f2d2631284429787d25d43c04b584793256ed358234e7cd9ad37d1f -9115ee0edc9f96a10edcafeb9771c74321106e7f74e48652df96e7ca5592a2f448659939291ff613dd41f42170b600ad -97b10a37243dc897ccc143da8c27e53ccc31f68220bffd344835729942bb5905ae16f71ccaed29ca189432d1c2cc09b1 -875cf9c71ae29c3bde8cdcb9af5c7aca468fbb9243718f2b946e49314221a664959140c1ebc8622e4ed0ba81526302fd -86b193afbb7ff135ce5fc7eb0ee838a22e04806ceec7e02b3fb010e938fff733fc8e3a1d4b6cba970852d6307018b738 -b3403a94f1483edce5d688e5ed4ab67933430ede39cd57e2cddb4b469479018757d37dd2687f7182b202967da12a6c16 -83edfa0a6f77974c4047b03d7930e10251e939624afa2dcafbd35a9523c6bf684e1bb7915fc2e5b3ded3e6dc78daacf2 -88ff3375fe33942e6d534f76ed0f1dfa35ae1d62c97c84e85f884da76092a83ecd08454096c83c3c67fac4cd966673d7 -af0726a2a92ee12a9411db66333c347e1a634c0ab8709cc0eab5043a2f4afac08a7ae3a15ce37f5042548c6764ae4cf6 -81cfa33bb702e2f26169a006af0af0dcaa849cec2faf0f4784a06aa3c232d85a85b8123d49a1555cca7498d65e0317e4 -910a16526176b6e01eb8fb2033ffbb8c9b48be6e65f4c52c582909681805b3d9e1c28e3b421be9b9829b32175b8d4d80 -93d23befa411ca1adbdba726f762f2403e1cc740e44c9af3e895962e4047c2782ca7f2f9878512c37afd5a5a0abbd259 -82fcf316027fedfe235905588b7651b41e703836f96cb7ac313b23b4e6c134bff39cd10b3bddb7458d418d2b9b3c471b -8febc47c5752c513c4e5573428ad0bb40e15a5e12dbfa4c1ef29453f0588f0b75c3591075fef698e5abcf4d50c818a27 -83dab521d58b976dcea1576a8e2808dfaea9fa3e545902d0e0ce184d02dca8245d549134a238ab757950ad8bc11f56eb -898cfb9bf83c1c424eca817e8d0b99f5e482865070167adab0ecf04f3deeb3c71363b9f155c67b84d5e286c28238bef8 -b845e388cc1a8e8b72a24d48219ac4fd7868ee5e30960f7074b27dada842aa206889122acfce9e28512038547b428225 -b1ce4720e07e6eecc2a652f9edbad6bd5d787fbaff2a72a5ca33fa5a054dd3b4d5952563bc6db6d1ce1757a578bba480 -8db6990dd10741cf5de36e47726d76a12ebe2235fdcb8957ab26dba9466e6707d4a795d4e12ec7400d961bd564bdee7e -a3ca7afd20e16c2a45f73fc36357763847ed0be11cb05bfd9722f92c7ba3fa708cf10d4e0ae726c3eccae23cc55fd2be -8701b085c45b36f3afb589207bbf245ef4c5c82aa967ecd0c334daa1f5a54093c5e0fcacd09be540801920f49766aa0f -84e3736727ba76191d9a6a2a3796f55bb3c3a8bbb6e41f58e892ea282c90530b53ab5490bbf1a066723399bb132160fb -87c02a01917333c7b8866f6b717b1e727b279894108f70574d1b6e9e8dc978eda8778342baf3c6464d6e0dd507163e76 -b8da532dac81fafaed759e99c3ae011d75f3fda67a8c420c3b9747281fe32e31ac3c81e539940286440704c2c3e3b53e -a0cc63c3bef75a5c02942977a68a88cd3d103d829b6c0f070f64206da7e3638f10f42452788092de8fbbc626ce17b0d4 -b5c9317b3f6b1d7ee6871506c0430cdf73e28b02c001ba6ca11061c7e121c91152d2b80c4f80e1d8f51ff5653bc0db5b -b798fb572da977dd3ef2dce64042b012a470d6bd2cb61a16267abe2b8399f74540d7c70462a6b2278d73567447e31994 -b868eda58739effda68c834745cd2cf66a09f0f215607b65685bb5ca3eba71150f43a6e47b81a0c19fb58eeae3da56e8 -9041c93a7e8f2c34812fd6e9744b154e898e1ef69db72bf36242c71e2c251f3db7e86cbd802da603a92cd0b06b62ea63 -a834d648e974230582fc17b3a449f4f65b3297038a3a5401e975b9b60ff79b2006a33e1486d3428106580276993311e1 -a3ce874da6ade9f0f854d7ae7651fc3ff63cec748a847527539fe0d67e6c99eaa3011065a4627c2192af7f9569f7ab57 -ae78ad16de150cc0400d3b6b424c608cd2b2d01a7a38ea9c4e504d8463c0af09613774dbefdd5198415b29904e0fbb63 -b966db5a961067e743212d564595ef534e71dcd79b690a5a2c642d787059fc7959b9039b650372461a1f52910f7e857b -8069904f360af3edfd6cabd9b7f2adf5b61bd7feb0e9a040dc15c2a9d20052c3e5e0158f3065ec3200d19b91db603b71 -9600917dbcd80a47f81c02c3aafecfcef77f031bf612a0f1a8bdef09de9656f4bb0f8e3e95f72ece1c22bd2824f145b6 -834a0767b7b6199496c1faee0e3580c233cc0763e71eebc5d7c112a5a5e5bd95c0cf76a32ea5bb1b74f3cf00fbd2cfb4 -99469a893579ed5da7d34ec228854c4666c58115d3cae86d4fc2d03d38f10d8c5dc8fb693763a96ab6be2045cc8d518b -a52cc0aecda6594de57d8ca13b146e77212cc55854929c03f2a8a6cdfa46296791c336aebcc2610d98612d5b4c0452df -97864434d55aa8a7aad0415d36f9558ce6e6c00452923db68a1e738232d0cb2d47e3b0b8f340c709112838adeaee4695 -a4a7f2c45db3661b6af7ec759f9455ba043b0de6fd4787e3372cba215b9f7c641d5d817a0576e7aa28a46349d2fe0ae6 -864e857652d95e1d168c1b9c294777fc9251a4d5b4b00a346b1f1c9c898af9a9b5ec0ac1f3a66f18a370b721dbd77b23 -ab8eac458fa8e7eb5539da3964ccd297a216448c3af4e4af0dcfed0ce29e877a85e29b9601dc7508a060b97a05f37e15 -a6fd0782c5629c824fcd89ac80e81d95b97d8374c82010a1c69f30cef16ffc0f19e5da2d0648d2a36a636071cb4b69a7 -ad35a75fd8832643989d51d94ee6462d729e15f6444ffdf340dfb222af5d2b6b52e5df86082dbc7728fde7c1f28ac6b4 -8e06831cc8a0c34245732ea610ea6aae6d02950299aa071a1b3df43b474e5baee815648784718b63acfd02a6655e8ea7 -994ac097f913a4ce2a65236339fe523888ee43494499c5abf4ac3bce3e4b090f45d9abd750f4142a9f8f800a0115488c -a3e6a8e5e924f3a4f93e43f3f5aafb8b5831ce8169cddde7296c319d8964a0b6322a0aa69e1da1778fcc24b7de9d8b93 -81a9bd04f4c6e75517de4b5e2713f746bd7f3f78a81a2d95adc87ba0e266d1f5e89c9cfb04b5159c1ff813f7968a27a4 -b24de8f3a5b480981c6f29607b257ded665ecd8db73e2a69a32fcf44e926fdc7e6610598e10081cf270d2f879414b1ab -adc1b3f8ed1e7d5a26b0959ffe5afc19e235028b94cb7f364f6e57b6bf7f04742986f923fae9bf3802d163d4d0ebc519 -a9fa5092b6dd0b4e1a338a06900b790abbc25e2f867b9fb319fdcdfb58600315a45a49584c614f0f9f8b844aa59dd785 -b29c06b92b14215e7ef4120562893351ae8bf97cc5c3d64f4ecd0eb365b0e464cf27beec3f3ddac17ed5e725706b6343 -adc0d532ba4c1c033da92ba31aa83c64054de79508d06ee335dcab5cabae204a05e427f6f8c2a556870a8230b4115fd0 -9737150d439e6db2471d51e006891d9687593af4e38ee8e38bfa626abcefa768ca22d39133f865d0a25b8bbf7443d7db -a10d1e6a760f54d26c923c773b963534e5c2c0826c0a7462db2ea2c34d82890f9c58f0150db00aa2679aa0fdb1afcb08 -816947dc6c08ee779e9c2229d73dbfd42c2b3b6749b98ec76dbad017f4b4d4f77b5916600b576691978287208c025d6f -a2dc52b6056219d999f07b11869c254e8b3977113fd9ba1a7f322377a5d20e16c2adf46efb7d8149e94989b3f063334a -8153900aae9cf48ebc7438b75c16f5478960ef9170e251708f0c2457967b7b31521c889b5fe843d2694a07c0e804fa48 -a9e9d8d66c8774972cc1686809ce1fa5f0e16997ef2178b49bcd8654541b5b6e234cb55188f071477ba1cebcf770da45 -b1fa775f9b2a9b05b4b1f0d6ad5635c7d7f4d3af8abaa01e28d32b62684f9921197ba040777711836bc78429bf339977 -b1afbbd522b30e1ae2adf9a22993ab28b72a86a3d68d67b1833115e513632db075d047e21dfe442d6facc7b0a1b856bf -8779b7d22f42845a06ae31ac434e0044f5f9b4e704847fb93943e118e642a8b21265505ad9d6e418405d0cb529e00691 -ab2c6cef1c4e7c410e9e8deb74c84bedeb3c454ae98e3bc228eb13f6b7081b57977b3e849ba66346250e37c86842c10c -908d6c781d7d96aa2048c83e865896c720a66fdec7b06ab4b172192fe82f9ff6167815ffb66549d72bfb540bb35c36c6 -b790440f205ece489e2703d5d1d01ba8921dd237c8814afb5cb521515ed4c3b0a6df45fd4bd65ba63592c2fe1d008df3 -aec346251f9c78336b388c4e9069a1c6c3afbbb6bfaffdad050a9e70e92fb3cae3609067b4903552936f904c804b0ea6 -a0e528cc2cb84b04cc91b4084e53ead4188682a6050b3857c34280899c8233aa8c1a9c6fa4fd6a7087acf1b36d67734a -aa8d7632be3e4340712a1461a0ad0ae90ba6d76e2916511c263f484c6c426939fa93ffbb702cd0341eea404d6ddffebb -a4ea871d8a1d4b925d890aefb9897847599b92e15ce14886b27ce5c879daa9edead26e02ccc33fcf37f40ff0783d4d9e -ab63e4dc0dbdaf2ada03b3733aafe17e719d028b30dc9a7e5783c80933a39935dbe1ef0320bb03f9564cafdf7a4b029b -8219761bbaa39b96b835f9c2b4cec0bf53801f8e4f4a4498d19638be2fa0a193b2c1fbf94e26c1058d90a9ac145a7a12 -a609ee5561828b0f634640c68a98da47cb872b714df7302ef6b24d253211e770acd0aa888802cd378e7fa036d829cd36 -90793ff0736f3c80b5e0c5098b56cda8b0b2bca5032bb153d7b3aa3def277f2fc6cea60ac03edc82e3a9d06aff7d1c56 -8760085283a479d15a72429971a0a5b885609fd61787a40adb3d3d7c139b97497aa6bcb11b08979e2354f1bc4dbf7a0d -b168ede8b9a528c60666057f746530fc52327546872dd03c8903f827d02c8313e58c38791fb46e154d4247ea4b859473 -842c1149ca212736ebe7b6b2cb9a7c3b81ae893393c20a2f1a8c8bfef16d0a473ff865a1c130d90cc3626045f9088100 -b41d0e2c7d55108a8526aa0b951a5c8d7e3734e22fe0a6a2dd25361a5d6dea45c4ab4a71440b582a2f9337940238fe20 -8380bd49677e61123506dd482cdf76a8f1877ea54ed023d1deabfc05846103cfd213de2aef331cdf1baf69cfc6767be9 -a026f92030666b723d937f507e5a40e3f3cfd414ad4b2712db0a7a245a31a46002504974ed8ba9d8e714f37353926a4e -b492e9e9917b29eb04cde0b012df15cbd04f3963d120b63c55dc4369e04f5ac7682b2c7dff8c03410936c26ca73ad34c -81fd9271b4ee36be0ba8f560d191e1b6616dd53c56d1d8deac8c1be7bc67bbc53d434cf70d04e7fa9de3e63415389693 -835c3711abe85683d2344a3ee5f70e68342fd1aec025ad248efe66aab3e3d5790fad2f45bae0d7a53a80998fde45f0aa -b46599be80b8f7dbad0b17808dd5ca91d787929c0bef96fbbcf6c767727d07ed6785bad164d733ecb015eb6c8469a16d -b36bf5c17271d39f5ccb3d82a5e002957207a0cdf9ae7108a4946e6f3ed21a5d353fa940b6fe949c39422b452339bae9 -a12f5444e602d6fb8be51a08b8bc4ec105dfd759d2afe98d51ff4edd673c92e4fc91ff32417ae8070e12169004f8aad3 -892ce3ca0a2961a01f7f0149b8a98fdc0f8871c2d85e76daf7c8aed2a18624b978a4d0a84213f81f9d2a81f7ca4826d0 -b1e6229ebd5b3d85e62d0474d1fed34564f1b5b9c5856fae36164dd0eff378d67d6717dda77536379006fb462bced9da -ac852921dcb81e54e1e315fd6226219932f7b785c2ceb2035710e814899784d7001101f1515d68e3fb74cdbb4baf9e26 -989a42d851123d708a213f3a02cfc926df15af058ec9b5a9df968fe16decbd781b5e65a4c17fbfedd2ac17126084700f -b1d0fc2f7c948e466445f307da7b64b3070057c79c07c7ebbbe6f8ed300a642b3567aed2e5f28988ac566ba62e0d2a79 -83057263b41775bc29f1d59868a05b0f76d3bdf8a13c1014496feb4c0ee379bfd0d4079785252f51fbeb641e47a89b69 -ac9e6a208aa9c557155cf82b389bb4227db5ac4b22a0c7c8d1c3d98946df8b82b0c49d093ba55c8255e024a6d67c14b4 -8294a11cd3f5111b1f8bd135be23b4de337ac45711db9566ebf6e162cd58e7859b1309eba8149b0f0a43e07f62a92411 -8c15f3388b196603c05adec195c1d2cc589e3466da3169e9afd37157fa55cd34bfafbfc5ff10ac0e04aa6a0d0b2ce3db -b8faf8ba89c3115576ab6b340f6cc09edfea8f7331f5a5e8003960c584e839fcecf401113dfbb9a5c11a13721b35c263 -955c63b1166514c02847402d0e92dccfe3c0dee3bc70d2375669afb061594c85651e6569f471a6969759e5f373277da4 -963bd4f9ae7361d6936d209592a07d9a22cc9ef330cf0c5cb845cb4085d76e114aee66d7599bf5b9f11c6b1c05dade8d -85509b3c97e06e0db113b8b40022c8989a305cec39acab36ba3a73a4b4719573e5bdb82dc4795699c26d983465cd61b0 -b870cfd7f691f88db8d1dfbe809b7b402eabd3b3299606b7dfdb7ef49415411f01d2a7e4f7ebd919ac82c7094f628166 -a5533e7b58a6a9e5c25589134f501584163551247d36f50666eeb0a0745cf33e65bb8f7a9c2dc7fe7cb392414f1ece4a -b93d1ade01ff5678fcd5b5b4f06a32b706213748076cae3a375e20a97231133ec37c1c3202cbc4896b66c3410210f446 -86ed3a58000a46fe2c37d4de515430a57d8f54ab4300294685534372fed1d68e192dd43d43ea190accf3dc9b22e1548b -a8c7d8dc30057bb8ad66b9cfda5e223334407730aeb0f51705922c18e7a07d960c470d463d1781899203e1b1ed1df484 -8d86821d006e957e8544f95a98b110c89941bcc6985562e7a97285f5826b35b690963b2c141ff3f389d92ee18ec76d24 -a4e1108cd3cf01810e74dbbf94340487011b80013b9bfdc04f019188c0d4d077a54b71a3f97a036601aad42a268531e8 -a822cd61db07f64bea00de226102f5fc0adf8fa9f05a6c7478b0ff93e48f6cc3191302d22e1f369b571877d5eb96139c -b1ad4094d0bb4c325dfe072b17711962247dd7ff7e4bce4612e80a6f3c1bde04880ba1682f60d5f1451318afd4d3ba60 -88e7beb0cfd7361288ea27f6b2cb18870e621152ff47994440c18d45284d21bad80d9806ed7d9d392a5cd791d5150ce2 -aad3724a176cf4476595cdfb9e2c3261c37052324c0b5373a30b6cbeb481bccd303720840c49a84ddca916d470eb6929 -a57983370d159e7078a273746fb22468000a6448b1a31d277272e35c6f548f97928e9015f1daf577511bd9cfee165237 -a54136e9db381cdd6dfb3fff8bdec427d4dc1072f914f6fecfec13d7b8f95bb3b5f30ad7677288c008ce134edfb039a7 -a25dfc4019f165db552f769f9c8e94fa7dbbf5c54a9b7cde76629cc08808c1039ecbd916560c2b6307696dd9db87d030 -a917d25328b0754d70f36e795fe928e71ae77e93166c5e4788716c1ef431115c966f2aad0ce016f4bacc2649f7466647 -842ce5e4ad7d8d4b8c58430e97ff40a9fce1f1c65ecba75fed2e215e101d1b2d7ab32c18df38dab722c329ab724e8866 -a8eb2ed2986ff937a26a72699eb3b87ef88119179719ff1335f53094c690020123f27e44fc6b09f7a3874bf739b97629 -96753c1f9c226f626122dad6981e9810a3cf3bbee15cfc88e617cfd42753e34593610861be147a7b8966bcdec55bba8d -94119d31606098f5b129931b51b4b42c4e3513a128b9bfb03cfeee78b77b9909b1c2fcf0a292e49d63bc4e5fe823dfef -a869654f5880d9c21a0af1ff4cfa926e03ec1f2d80fe5524605e04f484e09dc80d6769249f31fd378ff3926ab4cebc69 -b2a539bdd8de4499c5f35cd8824974c2abb1933b3f50d0175dd044563ca829eaa0fc47bdac97eafa98434d1cd05d7c5d -85f53b2bfcde1986ce7279f3a2f5f841f87d75af5d197c897f261d4874bc6868c575ecf7556a32b7b33f7b2795454591 -964f087ed02228b30f401d8aea35c1a7f76698e4075e1bb343398be74c716884e9ca1a31b81566e1ff7513cf76a2f0cd -a1c9d9c9bfbc9c4e281a2953d5991e7b22ff1a32ddaace9e8d9a42e080efb802b853d3276973b5189a5745943c9b4389 -b0c45a9852663a427d7f50c608a6419fbd00f90e8452757a45269d25c0386ec29942f48a34aafc0187ef6020e581d290 -aa3ca7b01862d5d2aea714fa06724b7dda7062b6608605cb712588b2c49fc3c7d89a8799e6e7c31e7a9ef28b1ad4d1f7 -88f5e98ae8c5ae7add42f6d358a35667e590aa80e1869593cbf597d7ee466efa35b429f1836ba2199d8280fe7f60ce3a -8a3bff472e8008f7e50362acc1a0b53c09ac60430942544532722e938470376f0672662261992146765b7c75a380c318 -b9847be7f7aee7532282c279dde928698a892a183ca3047ceda521e9e0a50d96fd3ce59f8e58f31af49508ade6d4ba51 -98065dc23ea3df6d9f8459e81887d88d5752b7e7ba6050ec5c3f0dce93e463e0bf12be3c94ec74c16e2f7ba62e447845 -994aff677b97ee790894dbdb21b1f9210734e008cee2aa2200c8f2579ea650b872f39776a13a8c31e95cc817091bae1c -b292811674e18912ebe79df1af4a132b04ab702c125c039e0213f735f658fafd36c38e5bbd7cad35842576431f5f3630 -96520d750ec10bb10f75019f8f0e4a93ecbc6b678a710d76cd10aa27a6642ad1461bd58fc2aab8e0391b3f788339ed29 -80d478da7fe246ad0e81a00141229e9d91ffb7fd1b29975c8ec358ed5e864e481bf01b927a9ba002c5ec4aa226d0cb57 -ae58049d93a11ae845dc5be2505e95657f83b95d83ff3591a3c565d587157be795ff4481f42d59eda95e6d523444e199 -85f1f5ad988b9f8a7e24b6d6a22b9de9fb3fe408f95711389c444d7ba2243987225b04318aa97a4cde2cb4c30c05508f -922092d0cb828e764ce62f86cbc55c04dce07233cff041888fae48cfe93818780b4aec9b4ff4718275bb2bfa6bd9e9ba -a85ba97125feff0590a05fb78f19a7338639ad1748802918af4d59307bc994536c0ad638b97b9acd26a08b6b4370dfbf -8c46fcaa8d13266d650bd9366180e5ebbfa002c339e4424a030de19ed922e2daa9a353ae54921a42299607ae53feb075 -b8549832230eb1ec6ee3c33c078deb47f556a0907d2a85fde7720391c82d2ed63dd753cf544a6a0a46eed4b8d1ecd9b8 -b7b96f24504c7f8fbed9c1c654a2550feeee068407b809c43f1082c9558c8665806d911d5d244308169d8a531373bf56 -81c483fd9d9ad7af7869d617ac592e7e951e39738da041d8c4110637689108eb29c8acadfc85366c70885cdf77b353c3 -acf33bcfd9080dfdba828727fe36803327a94e8a3ee5b6e445274f0e8267ad3c943994a8dd6d09b8072912b57e1e25b8 -b3475e7456ff96861bc11068198d51b69b899f5ff13022694b501d3adc8bac58a16204b12011d61e880c8459f4badbbb -8ceb9562026aa96d6e786ec2e5cd49200b5b424349a2214cd3ff5c8f1c2bf1b9872480428f5428e45cc61106cbfbd953 -af56f7e482c24a1367fd798201a20c464848ece431f2d8a31a6ef4f9bdbaa50991e748dcb4ef0c08fdac0ef8ddda3b80 -896dae8b12549909d512fd5c02a2f72dde4086aef6c8007ddb26bb04dff51a707ae94ff87e45191fc10339967fa28958 -8ed1c606840e07a2ac6ff16ac6e81ed3e1c90872ababfe68d56ed2dc50d9294579b9c3546dc63292874299a3162d59f9 -b4d7a5c0836e419a46942281ce77d0aade8e39eb1bf1190dd274ca5070898a1c02ad9d165855629d6e1c96df1a6bd5f3 -aebad8939ac117deb28b789d9846c2c80359dc260920ac8408dbae0b6228dbf496dac0023a3b4302bb9a53e8ada18e61 -812d07c74a8650dc3f318c9b2dbf265f181041fb432fee989cedabd44b933dc6590e36c71dcf9dbe7b4bbf74ea0d7c50 -87b131dd3489889e090839c392231e0ee198acac65bb2e9e63e7d6da322391d1685cfc8ba60699308054c4b0fd89c90c -8b12110ece0b99b2e653b4bc840a12bce5b85abf6fb953a2b23483b15b732a0068824f25fcaa100900e742886c7b4a0d -8765fc9b526a98512e5264c877bdca567e32fdcde95cdbcf4f4c88ce8501e1c7fab755f80b87b9b32d86d18856f1d005 -ac806a32a14019337dfdb5f781ecba5cdea8fb69b23e0e57a0f885e0082a9c330ba808621a48e24316604f6c6c550991 -a711970fa40cf067c73e3edee9a111bf00cd927112205e9d36a21897529be9a051be45c336d6b56725dca3aeea0aed15 -908adbc17fc18821f217d46c25656de811d4473779a41eacd70d2a0d7dd3010de4268a562378814e619e13ac594bb0c3 -894251b79be5ae763f44853f6999289b3a9abda64d52797c6c7d6d31ff2a79e9b3906da72f9ebb95b61d6b29479e076f -aadcf11ea15bcb6d979c3ea320cff8dfcc23c5118ed075f35e77f71459b2141253060e3a90839adbcd3d040ad3bdc5e2 -b4e55d7d2eeaaffb0267448ecce0b75166e4805dc0e261eb5634d4a3f3c08964a597302fd8f6b45ec48178619291dadc -a8e2a02c93d6bec7f42f9265269660b4b404940c3e3de9515b4d826ea7e71f18c6f90a71ce3fbe452d0713de73cb391e -8e2467accfe207cb1ba37d60662920f95338ee212927edb706228c25345734217740159310edf17687f58b333754cb65 -90376b88f653381b3bab673c48c2b84fa82a091e18f710a732fef836e0d39043fcd5527aa97a3a385c0a77cf53746993 -b16530e289198c235ab680f86851bcc177f0c16a58483d83a89213077b06d6840600b03834b6b7af0e22b1914f72de43 -8c4fc3854f938ef1c2b5df065e4e75e9f299798afae8205706439491bdf9784c756134922e77af007e349a790afa52b7 -a68aaec4341d29b92b35322f89b1ae3612e7b440c89a86135a07c261dc5799217a651460c92113d099b486817226d8cd -a653f965feefd2df24156478f0cf3755274ca395afb79e8c72d3b6e1d1f5ba7f3e4f9a4c5ee85355de6f3c81935ff579 -aaf6c8d2717b57f6b14e06c742a11a3bc736bfc0327ca4b8a005b6e924f06871141d231737698a9a59286e44f244a168 -8de32e3c104b4278e27aac695d224f134001c3619f15186466c57c0c46f67e2efe537501d0d9f52f4cdbc724a170b92d -8e9b5858b6d4ffe811f6498bd80e454f0d6b345d4729c946626c7cdc196c803a349a14515296aadb7258bb7a5b37e930 -82fc711043aaf1d7a9c712d00eafd816a710f82eb10818ba6af09f591447f36814dbff6e6a1cb2b5c7f16c73930dbbca -b2f0205327fc8ff687f751e7b97788732afaef4fcf51bb17fd7579ed07501915790b70fc36624371fe4fb87a0179d850 -add87d5b1288d30f3449d3ccfa11cba4dc7756d85cee1cb6171b493680a625a01f273d0bb8e6332d0410250036b3acdd -a411f75ef7dd8de8062331ea40929db989e4d65ae8f33d3fa6cc19c98fa8a8ec2b7c7534a5c5eee9e5051626a6a2e47c -89d40a647781e7f2e8ab3a0f7dc7133669944c0cf627376433687a2ea15c137be26f582a6b07ff94b266ac0910009f7c -b2b5f808c26b40ed507922ed119b0fb95e0d6d8b084bbbba58ca456b4354d03110c99989b93207998334ea5d1b70fe49 -8c8db028671969a1e80e595283ce5e678ee955d785043bb5fd39fdb68a00e4c15b462600a7ab1f41486b6883e725894e -958087ce0c75fe77b71770c2f645ef3360c1a9c98637693b988c5f6ce731f72b24ab8b734e8eb6258ee8b23914451f0d -aad6c00df131c1eec6c556bae642e6dcc031e70f63eee18682f711c7b2fcd9afbf1f18cf8a4af562759130add67bd4a3 -b6d23c567291f019cd9008e727704e7e6679b274feb29abba0d92e036f349b1f0fa8c5271ec7384e8d70a2c3977b1f8a -a942c770e903d4150b5684e4b94bb72d0e171df2c7cae6f46e002c41c6b04d774ac6e2753ba8dccdbba3ad1e297a9ae5 -aa542d1849390f86d797408ed7f6a31504aa65d583481a00e475028af20f8b69248a87a8ffab1dace0377db77fe5f9b2 -a1ed3f9564a97f7cabe7c67e018eaeaa42db73a2f3d2332041ca9a7bea57436d848784d6dc402862c22a47f0692b1286 -925c757750c91db8b1b3c220fcbdd80742b4a060abfb0a402071d215c780ef6b420132ec5a43043b9fd7a06bf1b323db -94e575daa7fa0bbb35b4386f510fc3877c9df57bcf15349c5923f30ad6a8df95372835cc078216b41a7192921c1e8973 -9346a41174865d9ab31c7fb9a5329f322bfce06002386d3f5a2e2193de9bfff12bd0bd93307928f7b85e1097b2aaddff -a6e54c9324baa1bff7e9bf39c94fdd308ec6f210aad937112ec727565f8a6141375c04196831873bf506294854f6a20e -98d47b662504f400f1a0e14e24b43829490d022ade02a56288aaf148d466b45d89b5fc146cef67c9ba548cd37ad5e354 -ab690dd59a69904b6b3a4d5a42d17ea4898d9b00c6753aec216d5d4ea564f9a1642697df44d5a62f2c2ab19aaabf1532 -8d0aa8d3c5ec944af49beb99e403cc0d6d1adc6003b960075358a4ff1cbfa02a83d6cb4d848d9e83b34882446a330883 -af9334b7300780c752f32eaa68f3dcecd07dc50d265083f37f9800b02c2595ba24dab89f5fc27c1ecfdbf5291b4d77bc -81c4a6aaf7d4ccee9925c512dae5da6d916a6dd59f7a4cc79d216a91201b4d300114a309e3ddb3291bb95f85bec2a8ea -8c804e810c0785789de26e12b1beff56a163769733be7a31f34f81093782d6410293768a166c9191ef8636fc8724a31e -a91222b48de238f6dfe79c84080cee618611bd0bdca15cfe44474829e42481f8511a82589e69964e19f8cba04e3f5f3f -b26a8885aa594b0c8ad4a1711d80bcf687df996442075dd1497db1b446d16c74e28bc6f0e92b2ecea9c3e15c9c7e828a -85940f45d324ad1d335bd1d7d6f81758f52213e63d5770d9fe0c0c9507d5550795e538b6a2dd463f73d789b5ce377aed -931a277c78082f416880620df3aeb6d0bff2103d19679dd092ea981f5323e438c50a0d094908034ff8a2cb47b1a44108 -88dd85e4e2aa349a757b98661fc00d4538ec1d3f53daf44b16ffcf7f943dd4f2bba5b8ba3b05c529251dfeed73f6f1e9 -b7fd7182cd33639710b8216c54a11bb02e199bbc54fe33492a809dbe17771a685d6238ea3ebcfc75e3b0d4ea5369bc9f -85d77194d910f8cdad7330e1bca9087529a40fece17492f1d17cc4790833891b6d01d24f036b6422175c732b438faeb5 -9845265892d672d9517fbd22f88be4f225711b4abafa8327cc059f000656e4737188506051565d97912a0c19c3d063c0 -90a81987aa841c7f640c298b816643a0ae00cd3609c3a31d0b01245283cc785d9bb27763131b31a4f21aeda4e50073e8 -8b1256eb41a600bda8a06ac08b98a220ebfd52f89a0e4fdce32425db7a0481e9b7873ba3b7a24ad9fb782ee217dfdbf6 -870548998deed85c59507cec7e69cc001c279bb2a99c45a4d030a35c107e69feb76afecb9e435e67965051d6d7a88220 -b1504d194a0dd8df48d431ce991f89d7a0f72f573d21bd5bb46474c5005e43820877a44e62db555f194427ac8a4b9168 -a00d7423ec2cf0c9e9da07f3dae092d09e1ff4be852e07e531aa54d62ad937bfb52c8bf44683ac3a70f6dfc125575da1 -8019625ad3d218018803aacc2efcedba3a41c24aca8c5aab2005556e58fdf2ed614831277df7937aa594e97a2fc65e7d -8595596284f3add0155ecfee3fc0b66a6b6fc7923d82ca8302952e2ed906d119a1c053aed1123b51f73e1d30d93aba57 -a8ba033f5e7d06177e9ae2d99c40ed4e99e14e1c1b61795997f62e21ed8af1531c4720f23d6a39b0f75c6cd91c58c700 -a94f4167c0f6ae214bae75dd92c63299dd954b00b0d8b0416b8af929fe5aec6a259e44f83a183412d7ba4eb3a49728c0 -a73ee3c3a0fd2a369e0a279c3e214fb662d0378eea3c95cfb91412d7213a1f05958bd0de8f2a4f80f9f80d7eef943b41 -8ef6f3e241f6a761c9ab412629a49648c08b70b837c2cd8bea620bc93056ec73754e3e11f0df50f8e9fa67a9867501a9 -80b473ac4ba8cb82b4ae684206cde124d10fcf619f55a6c90d035981e1b08b9e141b4e5fa9a9af0b7f0c281b355dd593 -a566e2be0b41f01978dfffbb32f442b5e6706f5b9901110e645cf390f6a82869e3ca16887ffa35782a004d251d29c26e -a74e01eefa03546d00afdd24bf17015eee95d36de28c03c9b055e062cd5e8d8f20473c6d7ad21c94f9058fc5e84f9628 -acefc74de146911275dfd19bbe43d72729e89e96da04aff58e5fcb90962856c0b24eb13f43e30329f5477a1b65ae9400 -b5f113ef36e75de6d6d44130f38e460ad3ffc65cb9a5606828c4f7617981fecf76f5e862d7626ccb117aa757cc3c3e52 -96d3aeb1d3a66b136244062b891fc7f93ce745b776478d361a375ae57bdba9b4fcb257becbae228c1a3aff4a1c4fb5e2 -ab26c4a110877e5495b674569a32025dad599637b5dafedcfe32f205dfa68cd46f3ddf4f132a8e5765883b5c83214a07 -922a7a738066692193af32ccbab74edef067668ce3253e18a3275afcd5a6df7168deb2f5175c5fb413dc08fdaef63b17 -a47542f8e4a3a35ef6049280d1a9442c920887d5f1a1483149e143ca412318495a36decb804f81c9f5a7672a14965a4c -8fde57991e72a2aebd3376b4d9fdd795943ba3833431e52b136683567e6ee2cc1c1847dc49dc9534983060c54bf22f7e -addb041f01a99e7238ab2f9f2f94579861d0470b93b91cfb29f3a2e4c82386c868b2cfb6f3778b8a9cf908788acafe58 -a8c4e1df726431c43703739776e2cc51f5ebac57051244991baf53582538120133a44ca603d0722a4b5193e1be3c5ec0 -846379125968d1154376c5dc63100bdcd99b9403d182e3566fe48d79099099f51523cd81d21f0d1dcd622b715bdd851a -b828bf0d936d275abb40e3d73ef57fcd7ce97e9af35e194ae61463317bac6c1b0c3e4b40afe08a1061037bb7149108fc -abd07c71754973e698fa26c5019afd9551548f8369e2249b9902513f19a097057ee7065a1d88912e8f52e6e0fbfa6d82 -a9e36b6fcc9a3cc98e76d5751c76c50e1f92b7670f8076ab6ca8a30de4ec14c34669e049fd39bd293cde8789b1ca67f0 -8c060835496a04c7b51790790035862b20547e62fa8bb4e8857fb36891ec6309520af5c0f45d5ea46e3d228747d710a4 -8cc472ec62b8dce244373f40a821db585628989b6a7c4d394edffbc6346c8be455f4528d528fff41f91f2c875bd9fc0f -b4a75571f84f93451f15b3a86479063d7324d2789b6d2f2f4f8af68c66fac32743dc09b51df29608d62aaba78f6904af -916484984743b5ac16d40d0544faf9184819d92f779254b7fb892eb68cefbe59e75be8a6336a585e120f6ccae0a1eeac -b906ae585a73119764024e9eb87d92e53ee0c673474fec43fec4d344a3bbf471ce3976d25e37d197604689bbc944f1ab -8552708487305f16f95db3e01fbbfb969398f5b6d116844cbb000c9befd03f15c767584bf9541a42141949a4dc787a3a -a6025a2773f78c247f78c0d895ade8a6baa76e5499085f6175935d98a05fc41c1359f7843e0c6c323f1be256c45f45e6 -96dac695dd9288aeb6e32dce50e51ddf1fbd41de6146e3605c7a81f2253b17babf2bfda4f5a9d0c28352b9746c0dfa2c -a215b21f8eb2290f9d308278f2859a999eb3a31f4888f84a65f9ed05e1151c17777f91054d4d0de759ac5c3547d91929 -8fd7c9a279e9b619acf927d501b35dc551979731a89eab91d38b2356c0d73569baddacb9d1096d20a75c917ecaedadd6 -b985e8baa5195e2f1ea1091122d55aa321178d597f87b732b23eccb12b891638be1a992305a1ffcf5233af34339fa02c -ae1a9604b7f569aa48d2daa1889e76d3d103065fc8c3deb9ae127a6d94145695cab3bef640fa781612e8082c6d616c47 -a8fc67f9069f753360349eb874fa4dcadb2ec48d97c61abe568faee5f370ec3c87786c7faf0f73fc0ae7181a36eb89ca -a506d13acc3a9f80509fac936aef848cd30698631fff6130ed6217512ed9527d075f653cf6ef91f68e48a24c903eeb3a -a415093755cc012863043bf586b970bafdd87653ad14d1929672e04949bae4a753d16aa3eb5bd1afe3df3691b80f240f -ace3b792a1960580348b6fae8513149242378a18382741bbc2fb2f785cb8bf87550da4b5e0df2955970ab3a31f99f5d7 -a47d7fa7522664c8f9c404c18102f6f13a1db33ba8b0a56faa31a78a3decba3168c68f410115c5d9f240b3dc046dc9b4 -a9c930db3ea948cd2dd6ea9d0f9a465a5018bbaf6e9958013f151f89a3040cc03ae0b8eaf74b0ff96b4e7a6cd8aa5b4f -88abd235e3e760166cdedff4be82cf6ba02d68f51c6d53b1de326769f1f635215890f9a4c35b06dd16a9b93f30f3a471 -8f8d7b2fcdb70bfedde1ffd7f0b94108f0fa432f6ae81097988521dd2c4da928c10c5da3c7f33f11bd5331f2da8ec219 -b7abdbd48cece30d8f795a58a94913d76842cb006892485a9382a0502826538ca4ff951cc1ef4493e45de8571360d20d -b3e7b125f350c52695f7c5ec4a30916ea6c11744f1151a18ea0510e6cf6ed6f6dba4beaa4ca56988d306bd80ec360056 -9a004423c95e1f1714f98fb97ab798d6ab16cb5f6d6cad860635585d4d4b43ffcda63d8e931351189275e5a2cef28c2f -a8eab6ef917cacdc9b1932eb312309e1f85298d63e55ed9c89ab79da99d3eb60f1643d16be920e82d9285f60c7f7cab3 -934df955485113d10c4dde476ec14a98771145aadf3c8b61af26b09b9948757fa1abcc945ac91466a18c18c2fdce40d0 -99ed9146561597cff8add2196ff3a0f161dd5302685ceb846afca6efb5225f642e8f4a0970eecb01cdf18694fa697095 -b37062dd12a81267bbbf89bc9d6e30784c0e11e713cc49c6c96440f800f2a6a2a7e7f6c7f6c9eed4bc3c8890f2787342 -83a3d70055b6044e0207b3ece4da849755ab5798317b36b20c3555a392c27982f811e1c5007697554eeedc737b37f3ef -a85392c07ff8658935fbc52acec7221cd916c5fde8537a8444eefd507220e76f600350ae8f5dc3353911087b88b91045 -b1ea23558ad805dde9cc1eade995cd8e7f46d9afa230908b5fbaaa09f48547f49c2bd277bff8ab176f1c240beedd2b09 -8a16a48b9105d94700e8e5706b8d8a1ed14cffda5558a596974ea3191c5c3449da6e7efe2059e7baf4530a15f175ce16 -ac5fa54381fc565842417558e131df26e9505027759416165035357816a7e1859a7c14c228c79b4e5ba2ef6758e12ad8 -8475e290c399cc9322c05264a516cf766bf5fdb6b9dec7283961da0b99012d499b244b33fc0eaf94b461ab777f2a9537 -a7922f3c70e6857652805af7d435646c66d94eec174be997c4fe973d8f019990c4f757eeb730b2cfdf8154e6e97f7d5b -b90deb797fba3150cf265a23ea6bd49a382855cd4efe171cbcb1664683a9f1687cfcadfdca4e39cd971ec13aa5cdc296 -91ca761dd9659007d2fe8970bbd336c19ed0d2845d0d8aaab397116affcc793de2da73d89e6625cf4dae5983cceffa56 -9121ae9b60323ab1301e97555bcc74ddba0f5b1e62bfe9eaa2c239e1d685c4a614d397b32a59febed4db9968db44f38a -8477b07da4bbfe9087975f30d2c2333fccfcd7149f90e0e6fabecee627eee3ea324df31cf6a680393f5dedf68a35c9de -946a9c0f02fa6bf9f9d4933e7fc691749f4ac2f82a9b880666b5185189d4f3432da9096d0ea4d6baacbc079e19c887ce -b24663332914ea519435874d4c42d11842ea84dd3dc55292d5b0f27f64587848d095bacaec235a37003bdb5185daa6f2 -b980f46f84ac21dea75b4650f9412f6123325842758589a9b47caa68545905061f03fcad23cc102e2ce8ffeb1ae634a8 -90e9ebb060182d3043ea4210a2d934858559522a19eab9f0ff81a367484a05ec7cce78ee6a91dfff96145869db6a4e80 -b04228a009c91847693eab29c9ea71d1d6ba07060bc2b0b3bb81c46a125baecb3e1412f6ce4305076a97d316d14e4665 -8d3268370dbf38d378c7228c7b54e91f90f43cbfddc0d8468de11a4312616ca6372619209b89114152b16f334f4d2780 -964a63ffae653e0249685e227d937937b079ec3da9c977dad2b2e052af5eb560ce7d175941f2ae0df90e3d0a20b77e75 -855604c2910be885b14b27896e16d8dc339236b975398c771d29ac74e4278a2305fcf85203050a8faffddf64ea19cf78 -8e0b1d61a4349411eec77cf3490555843187a25a93e1f45bf66ad3982b9cc141b07805f8cb252b0fcc125e0052a7c450 -a03bc9588f971a1257cd0cfd2ca406c76aaeb634001864b0e4dda91e009d3361b33fc39f34922835031a423a13619a82 -b703fa855c2c4e1641d2687717fe8c5061acab71cd2dab55cdb069a6865464c3080f7936ddfd320516b6791b36c64b8c -aad1cfa7295e463fc3d5374ea4b952020010d67a77c7a86fe2c351a5959cd50df6a0045ad588257567a99bfd0e9400b3 -97906fb82abf5c1d9be8f72add8e6f175a6a5a4300b40295cb5ec8527cc7ec700fa03a7a494122d9605d212457452e41 -a83366cf93ad9a07f617e4002a10b624270f60083559b045ab5a805aaa592ac37b90c1e8b5437158f3bd942cf33bb633 -a585168e157e111bfa329d0ed6651a96509b20b30f6bb0691c6a5875d134d4a284867ab52511cdc19e360d10638e58a1 -b17d480a0b39f2487b7f3878714658fda82f2147c5ecbccd4004eb92d267c4663b42c93bafb95ce24e2f2f0a9ea14b8f -9362297a1a3951d92db4fd8ea6b48c403d6d8d2f7e7b6310b9cf9b4e4ba9e84cfe1ae025830aab9466c32fd659144474 -b1a62fbadfd4ea4909d8d0714c1e3ee9f95237fde20720f88d5ad25c274a6792158b99966d7b93151f769c832b6a132b -8d9af736949a33fe929548abe72384281365385862821a584f5198eed63bc5388f89fc574cda35a9eaabed0d336b86b6 -90ee2235f4ec2c6089b5cb7b8a41c9bc39e4a57935022ef28bed490e2ab12680922af7395bda4f708809e2bfc62192c9 -91f3a123d420bca34d3d751119bbebc435630c6605fb59a8d80d16a4895972e56cfe4cf1998e0a527c18ee38c2796617 -a2c4fbb20e7fbaae103b86ca9d8dbc2828e6bf33d1d7ce153bd98e8880fe7ac62abbf7059194b1eee64f4526a36c63a9 -91a7f93310ac74f385f11509f4bea9a4d74f2ce91cf2024fee32a4a44d5e636a73339c6b4027ee4d014a24b90de41ecb -914a6d405fee0a15e99704efb93fd240105572335f418d95e1f2de9afeb97f5f4b80aaf20bd5bf150b9da9abc2b6d6a5 -9462cf2c7e57e224389269b9fdddc593b31e1b72ab5389346aa9759fad5d218039a4a5bc496f4bf7982481bc0086292a -b7596132d972e15dc24f2cd0cf55ee4a6cc3f5a0e66dff33021a95e5a742889e811afd1dc0cd465cee6336ad96f25162 -99409bba2548f4ece04751308f815ecee71222869d8548fa142788fb19df5366d093a5131e57560237471bbd5279bbe5 -8e7560988a844b5b844ad460b19c452a5a04346d8c51ca20d3b144a3670ecc60c064b2415c2eeebf140d6ae4ba5c5360 -8cd9e18d311e178e00eb81ca839cfaa8e64e50a197de8461f07135fca28c1d895dd9c2401b923a4175ff711853497317 -91ebf99c95e8f653402b3079ecbd533ed7cd3b6c857a710142354ce8330cebdee7cf0fd0400417883b66055bec9d0552 -a9d0cf8cc6bbdc44426dcb716df667826426b4559056d73738bf3eaa6df373403861b6bbd6fa0454b1d2730e3b0015c4 -928320b452ef21d2443dee360110550f531d7a4275b2cb227814150f3e9e360e05a884d6e3bc4415f202120ea5ac333e -b9551f2b2e7bb984618f2e7467e33b5b5303b8707f503f2e696e49c2990ea760c31e0944d52257c7a38b553a67cf621c -b2ec34126fe61345e5c6361fe55b8fb3218cdcc9103bba5b200252d50b758153cd549226b7aabedd265906401e755190 -a8cf814926082a96a921d471036a9919a58e68d02ee671c215ea304759cd92a7c2c9ccebdd5e9ec5572164ad2abb22ad -8c0563c28c261bbe9a1ec4986f8b277324bf05b4fe5e2b79a862168e646bbea50ce7c4622b2aa7ca899c1a728c226d24 -b558cdc334ea894d3a13347ea9e30f78a0a20621903d6c009c54feceba3ba81d2445a43572e088ae691f65489702e963 -a62ba0b20f46c367cfd409beb300e39f1a6cd5be95e63457b6ad3cb66374aed754fd037b8e4215d651a7d8e1a442f762 -8543e2c6135df471bd7a5c09f1313674c7f6847cb88f15eabf40b2bc9535d0ec606725b97103334a0c162a20d9f5bb53 -8c0367d7058d63b425450f8ee9252e64234c0c2e61878c7c2d4b17bab22a72f40c75ac3bf8b64f264c00d9c5963af041 -acb7207445993d563f1b6e7b179bbd6e87044399f80e6d15980acf7aaccb9d85071fecb22250afb3aba850712fbda240 -b93725e66184bb03f0ab4078c737a7fb2b10294a3a09995958de3dcf5316b476ce9b5cd8d180017196d9482abdfcab88 -afcb52bb7b8f45a945299da6fc6a877ba9f69f7f23d5f94b5f5d9a04c3cf3089333bbd50fc305e3907825003da73b9f6 -961de781cb238cef52d43bc0dc7d8e3a75bca4c27ab37a2e9353137a9aa9403444a5841b595adeca75a3de5485ab97f6 -9408c828d3ed6df40cc167d72ca9882a9c9cf8e765d6f9125e02e0d66ee0ac94f449803afb50bf1b92176feae92473d6 -a85480591e7e033b9087fd0efe5cf3c88c10a75de4a5d7da4443df1cc1fa1aa59b6cde3ce7453fcabe555495e49ef6f7 -a2611bd82344bc5d70d7e6cf3f0d25866b9f709ac4bf6f75d1006da2a11e2cd07a4c0ac71505e5062a04f71db7a3063b -ac466aaa96febb5b810ba350c7a874797ce4bd6c9585f6b9d114d646894a67c9af9526ade4f7ec834d3a69e18ab643af -b73fc98a79fe77cdbc524c76a09cb9f2d5f8b0a5508846bed1ba5ea9ae3bb62120e01d3b8fb544d90ac9ae0c3d4ccefe -aed333c3403adc899a870082f70aadc770c9f880dc057f05a46d7400be9d893354121a0a31e5475898f437bf722eefcf -97f02133c72187178a8c48db26031f0b2c0317a6648d2be5f7450f00c37391cec935bea46b8144ec9fea5327ee959f27 -940b582b41f1d0f09f0c5f51bab471e4eb143e91b1e96dde83e94650421d51f9c9baec10cc802fb83cd63b56d0b907c0 -b1286a55a74a88a75da47671994916be428be1ca3f42783e497d6478eaa6aca69d50a421b210e9ed3283d578b651b8cf -97cd4e87e21c71d11f1df1c0b6518c00e1610661be4b13cdbdbb026d60fc3f4a2b8549326a648b3fdecb7de8f6aa9fb7 -8f36bbcccee986c35328633bf6ee8f70b5dbf42d0f677c0f4e009d2289976e512af6af91a6ddcd87dc0df93bc4ecd02d -9253ad44ad182e67ab574d718733a69c05cd5bcc43e6292ef0519a9430460aa6a233fe26269da7298ea88cf406e733c0 -b616b5ea74db0dcf8f10a2db79df6ec3566c06410f68a933eff150194608c591b2b175908d4b4ccaef1018b0fefc5693 -80a712ba89394381cbb83fedcaae914cc4f21ab024b8da8a7bbad7762a22f82940451427b1a3f5d84c246d5ba0c7ccc7 -a806909a5517a970879143ad789c6cb6256b82553b649f6865cdafbbc050b1f86528241b3cb600e784186e1a672b588f -b6ae801d1f0e4adf3ce57659d7c61f94abd3c8d1635ad28133a79eff0586fc48bdc195615335449e9bfee39e8a955eb2 -b8a000561211844bef72adf3413f3b438a8789fcddf6676402ca6a1c2c63b9deed322030de2ae3a0aeb3cedbb89406c3 -8bc3615b28e33fc24a7c989f8b4f719c914c4c65b35ad3d4cf15e2196e37c62e42ca34e8b1275e0f32589b969bdfc21b -b2f9637f370a79e7591e5056dac004f56b375f33645ae9f5a192cc6b7b6b3d8a1105cc00f10d8bc8ef250ecc2ac63c39 -b51899978b9c5b737999fee1935a5b0944261e7005bea411b5903d2c16ea045a3b0bcd69395b6733752caed43bc4e343 -873c71a01009dddb9885c48658f83aa6320e74bc152e09de8b631c763c2b4e2e8cbac921418a0d9085ff5c53a2b52d39 -96470f48efd7d2ac2daea8753ef097c09c6fc128a54cc7ef758ff07e32c0b0ac7d122f97b53e88a29cc26874dfee5e0d -8dd2decbd3504b7961d65edb8d51b96377f4edd2e0d2cd8a4d98333f373c79a8d7ca8f8408718d0e7b5e48255857c339 -b536ae387bdd0f6e40850c71fcaecb1051b2c8f7bf5cf92c6bda030de72a03e9212d00390c53a72a08e9fb2bff1249c0 -b1566076f59064e3545adef74fd1acadc1bee0ae23543c30caf9e1ad1fc20ebe84ee25004c612525b26857253f5345b7 -afd180e25444cb720342923b8897d38a6537bc33a0ca1fc9c6e4d524b280193618f19e2bcfbd07606b78b734fe6114ed -89b2a6c8811e5a6d07aa74c79dd854bdfc292cc104b525bc37e4c7c1f9485e19d759c8e27cd7cd73c46346f56ce3b189 -8234196e196898b2501b79d0dc016f6df3d5878952cdb8a93735e4ce2ecf77d07924c701e084533a20f0c50a7d1ee376 -adea7ce2efc77711f50138691ef1a2b946aaba08e7e3b21378708dd5a10bae933ed121e71834b43b14e2ea30a7b306e8 -a566d406a35fae703b3d1ea1791d9207116002e5ee008d01e053a1ea4fe5af2feb63605b011ae6a14414028aa054b861 -b83bbb063682386456719179b6f6bbc8cf6f791229600b7d402167737492f99437b45886695b26a28731e952e56f1ee1 -a8f5fffc2c335d3ad5c7593e81f0862351413cc348392afa86d50921dabb929a5a1de20d604666af9e17a13bbc30bc3b -8d5dcdc1335f01847f6ef650ff64b26e7c4cecb934a7bbce11254e8ced9fa9e4fc87eec55248f69bf499180101c63f5a -83fec30b8bc62f9fc28301a03ef18158d6364738f1c42de311bbfba2e62b25d4c9ea9d6097698b24c84fff956a6748b9 -96394fbe0c2d03cdaa56e13326aeb62344238ad3043ee2fb4f18ebf0a6f7f090f410032a2d15bfbeca9449202d59f2a0 -94880f5928fe71a797362a37d05849d23e118742697f75bc87173a777e7b9d4383b8796a8a2bbee27fb781f363301dfe -af229535896ab86fdf6d2ae676a0dbf44f868f6c7f17bd9a65567631c7aa2e29758f41de050ca5311bd1528bcc811532 -8d4fa4968575b483b3ac16345e7f1ea3f81e8dad72c945a48b7b982054fe1030584be2f89b2f53af84d2490cda551b84 -8052aeb115e4d242078c8726d376a13156cc832705243f14adaa3ef3889e1f2fcdfd46e087acab6fa85a74afde5f5eef -a1349c8a22788a1937a837fceecfaada9e93a63e582a09c56b53da52c9db1600254dc85f63f5eadfa30b89b31dcbdb30 -a10178cdb263ff1a5e0cc034b6deaa160d00c3c3fe1fd1ff0c55fdf1ecb83d771070c10930f88832b75fef39a10024ea -938b17e4405934ea5ef29c2187d6787c5ff5d8c9a02665efb453117d462dbc50ef2c202cbc884305cd807a70b5cc177b -84f01f0da6b58c71788616be71fb3c259ceea7f8bd131a5661c5c03d0205feaff6dac2915919347b0559c381477b3d89 -98787f0a2fac2b04bb7aa247ac77236bbe690aae64203e553be328a2c3bffb772e7a0244e585d27558cc64b089a5ee11 -a14501d8b6b3a84b13b9006d521667e8d168f642ebf154c4e90ec8c75d11985fd0c9d86fc2efa6c7077dafecfdf0ab13 -8215dee75eed04de83a3e910129bee8c48ce01cf1317ea477ff35c09a6f9e9771a8b05aa79e6b0f3e71b9874695e7a2a -85763c3072c7400a2c5668ef5cc53e6f4b8dff474146028a8be370ca9d8af9bf9ee10cd7d23d33eb6d6e257dd3af38d6 -91bf62245c5a59d514d39bfb74db7f72ca7160c1c5d5be3844fff37e53e99d451e18a6747c65e33f98f48a55f38962c6 -8c68817c6a6ea348d9aedce99929371c440fbad72718c2d239ffcaebb26ecc8a4e8c38c2819d945fdb7f02ffda70a5e0 -a96ce2745866a22267a49faa7ea00ebf009ea8d0b0ca2c233c62759b9d5514306b5822dd2eee0124c9e28380e2f97aa4 -8b18d5757c73843dcd55f0f0dc894bcd17e0ecf4c9fd901eacd38480844a15b4ce5e9598ccee039f9d93185137630cdb -a5b45c403b6735aaae14389bcee23ca10571f5437f1f5ab0c2b4e573dfd3341c638fff2cc780166af96b118d47ff2299 -ac849a0ccd354dd46bf55ea837d509b4ae3eefcbd5b8eb2582d301fd56c27b89950c6eefdd4e98e608ef4a6b75251311 -89f13ac14bb064e9c6b49a482831ecea6344faec490bd18bb44028b83a0f22e21145861558029bd172ba7c5247c2cba7 -aa57b057a2ac32c101e442c33831630c81b2e061a542e3e1d6897b2b7ca8a7241ef717a548b3f751d60d89be384ba5da -8a43db4e12682b98230364f25c75b49002f5002bd72a1674cf2a9d53197b5ef1b95e48429af98af503b0d5c3e0e017b2 -a10cd7b8e1574d78c4e917cf833d3d845b878e8e8b60312e6a994bd4f391a5e8c38dcd774087b93c9241238f43f80937 -8b61ccb949088286216cd628811df1a362a7f5c333654ce823e63ebd04b069d5b0f627fb6c96d54c7b853de8aab05472 -887b902020ad45f70f2d5bcfa7324fcbe7be09fd2b1bd40f9ae43a89d487986e89867aee0945ea6a0fe8dfd051ffec56 -822fcd260a7876cad31f54987053aab06108de336878b91b7a15d35013d6d4d6de2d4b30397bb6f1d5c1a7b48e9d1ced -80b89ff95d725858b50e84d825ea99fb6a8866f10b91a5d364671ccbb89cb292bada9537c30dbde56b989c8bdc355baa -b53cab156006c3a1766a57dd8013f4563a2e8250995dbeda99c5286a447618e8ac33ebf25704b9245266e009a0712dc5 -b6e2da9c1156e68c15861a05cd572976b21773e60fc5f2f58c93f3e19c73ad6c2ee3239e6cb4654040c8e15df75a505d -8b7e187d473a0bd0b493adcdb91ca07c9310fd915dec46c2c9f36a5144eb7425dd35dfa50feb0e9ef747caed9f199944 -9743ec3917e953e0a420406b53f4daa433adf4ad686207e9f296e7c83d1ffdbf81191b920ba635c85416e580178c16ff -98d1476fd4504a347c5261012298ca69c8593fec91919d37ddfdf84155b6f1c600cd8dbb92b93f3262da16cf40a0b3c6 -94f50d52982a3c81ac47a7b3032dad505b4e556804f8606d63d821f2c1a4830917614630d943642ba375b30409546385 -b5c0eb5f4cf3f719be1a9ad0103349269e8b798dbffe1b5b132370b9de1188a6d71dcbc3635dfdb4b888400f790b6ea4 -b47fb45ec73392598866d27994c2feb0b0f3d7fc54303a2090757a64b6426d183ae41af16794ced349ede98b9b3fd48c -b5f45fd0aee6194dd207e11881694191e7538b830bfe10a9666493ae8b971d65bc72214a4d483de17c2530d24687d666 -a50c149ea189387740d717290064a776e2af277deafcf5f0115bbbdc73c0840d630965a4e0214b738d1cb0d75737e822 -b941afc772043928c62e5dbe5aa563fa29882bff9b5811673f72286ac04fddf9a9ed0f9faf348268fa593a57bc00ba6b -839051a7838937270bdf2f8990fd9aa7d72bfc86cffe0b057aa8eca7393abf16b70d71a6470d877f8ec6771efa5a8f26 -835bc9d049418ab24dd1cbf76ed5811381e2f0b04035f15943327771f574f723b07c2b61a67a6f9ddc1a6a20b01f990d -8935cf5634d6ae7b21c797a7d56675e50f9d50240cb2461056632420f7f466fdcd944a777437dcb3342841ad4c3834bf -b5698fe3da1f9d1e176c9919fddd0d4d7376106774aa23a7a699f631566318d59b74ae8c033eba04d06f8cdcb4edbbed -ad11421ba75d74c600e220f4bce2ca7eacb28e082b993b4368d91218e7b96029acfbdf15a2ab0b8133b7c8027b3c785b -886ef813644599051dafdaa65363795cf34a3009933c469bd66a676fdd47fc0d590c401cc2686d1ba61fce0f693426d4 -8858fdf3e98e36d644257ab6076f7956f2e7eacc8530ec1da7f3e9001036cba7a0855fb5011925cdc95a69600de58b2d -b59eca7085a2f6dfeaa6a414b5216ff0160fbea28c0e2ad4f4ffd3d388e1cc2c23a32dbe517648221b75a92500af85e3 -abec62d259bcd65b31892badad4ac8d2088366d9591cd0dab408a9b70ad517db39c2ef5df52348ba4334dce06a4e3ba5 -a9acfe8f5a310779509621ed2946166ffb6168e68ecf6d5a3b2f6008df1728c8fceb811636c50d2e419b642a848a9ca9 -9929bb1a3537362848fac3f1bcb7cfb503dac0a0b1bebbfd6ddf14c9a73731e2248cbaf0fbb16c7d9c40cc6737c3a555 -981d06c7431e6f4654e32f1c5b27e7be89e7c38d59c4e2a872a0f0934cb852c6aeff2d2eaee8302131795590b8913f5e -a6ba9dd43354320f65fd5cdd5446cfa40080bcf3ef4a083a76ad4e6a609b0b088bcf26c4957bfab829dca6064410ca5f -9367ef28def311c79adfd87e617651fcc41ad8caf047d73ce9a1f327e8871e9b35d5b203fd0c0138e32e2ef91e20ba62 -855d1bb508a9036f42116c8bbb830c576189798baee27c7c3477ef1b1fc5d7b0c2c7203457f1eb48d4b029dd6f646be2 -8539a5d0528d3d601083e162b34cb33b5bf6736b4feeeab4941f10eea127c56b7e0b8d57f34b72f8f674d89c10bf302c -a3b71a9a9ac2dfcd681bfd8f6a5d9abf5df6950821705bdfb19db25f80d9b8a89fac7a922541cc681325679c629743d2 -8e95929dfd4e5b56e5a8882aad6b7e783337e39055a228b36022646a13a853d574603de5fed12b6c1f2585621ead7afd -8b05c885575d6894cb67ba737db5915639a6f281bf249480df444ff9f02724e28ed7371ee7ec26d50d25f3966010f763 -90f1a45de0cc0641181d54ee86630b5d182d24e7c30c2615803f16de90ec7c982a00b21f250ccebc2e94ef53a13e77e6 -90f0e97a132092e51a4521c2ecaaa47e4e4f319e67a3cdbd00ed85c2f10dfb69c339bc9498e2abbffcd54b1fdc509a20 -a9995234520cab9d1bdec1897b0b67571b718d5021c0fcf913140206b50ab515273b5f8a77e88fe96f718c80dd9be048 -aebc6495d54d0e45a3c74388891dbcfab767f574fed0581566415af872dc5b3bd5d808c44f6e1fbdde7aa9ffd260b035 -ae757f8f4b1000a623a7d8e337a50c3681544520683207e09d05e08a6f39384b7aaadf72018e88b401e4a7bb636f6483 -a626a28d5ce144cc0c6a30b90ec2c1412cbbc464ee96ac49035e5b3a37bb3e4ed74e8934c489b4563f2f7db1caf8b2ad -8c994e81dfd7a5c2f9d4425636611d5dd72d0b091a5862f8bec609d0cdd3c423eb95b0c999c48faa5dbb31e510c22b61 -a1c0e59e076b908de760d9becff24883c6eb9f968eac356e719c75cce481f2f7bcb1a41ed983a00c1a3b9369a7ff18f9 -8d7e199044fe2e552bc514668fe8171c3416515f7a5019f239c0384f0ade349e88df26cd30f6b67d02b83bf005d85de8 -80190f2255199be690fb502d02ed159aa568c390a684f7840512efc3d2a62f28a49d5d1928ad99a5f975ad81a245acd5 -889d84cefef33f5714e14d558f41d406072ba66b427bf27918b669c5be46261c3de0139610a2c2eadef8e6508e937bcb -a480a686d5085b854ccf9e261e7f1f2d40d978fc30b62b1a8fa9561127745529405820df21a680ee2258b8cefa5f0201 -ae6243400d416a8c13b80b6637726959ef07b8d9b6aff2bd3bb23aaaf97337c7a6b466c5db617bf2798e01d4ccc68e4d -85e0ff143657e465f3d934ee781de5cbd2bfd24f2fbbe6d65c698cdd93204a845f6ef1fa8941c2578463a06a8a418481 -8f4f8b45f1a9f6c2a711776db70f20149dd6d0e28d125906ba9893c5e74e31c195b0906f04c922c8b556ced7cd3d611d -877b852c33483b25c4cd8da74b6b589d8aa96e217c3c4d813466c77ef83af95a94a47364aa8421f0396ce631ad87d543 -852cb06bc4222ce125287a7a55a79ad0bf55596f26830dd6d79da3c60f80e3ba7b9a9b42b126dcb99d2cb9ce142783ef -810cd64c1dfce85d509eeb57a5c84efafe1d671454ef601a040de8d46fb33bc419577f6a6c404e28ffdfe315ffec558a -b60ff8bc804d101a32079b8ed52285fdbb47fd60c3c15cef17cfe7f6b0567de6b50128b9dbc49a1d9811b62b22c99143 -a9df7068b26a6a58f7a499e67b17d34f2a2e8e5029c6e51e2b4c0d19324fb5cd9734c4c4d5034e1bfc274cd0c74a82d0 -ad93c50802ded1e21217a58b874c074ea52322492d589820691572084d8edaede8c2ce8021c6df8c0060f395f3c25ee8 -a17b98e090f7ef5800477132b436c1fccc1802f34956711bfc176e36890c7df95a108e03f34659142434cbd8aee9dccd -acb14aea5575c293dc0a2b58c5350390801d57e9bcda876d87c56565043ddde1a544a88b48ad0d8ec3d41f690aef801e -88b8e26cbc83faa053fa247e26c95d1bbb77955b336e1b0e41d080633248238de8adc9b98688c98fdfc67e7286bc5be4 -899f69823cf1b2204c8da91bb4f943c04d943137b08b1c46e160919e3378bd22a666a079a66e63d81c05336c742efdd2 -8d7ffbc0b47a32408c9e88676ac4f87683cf37c37d214163ca630aec2d3cc014d88caff35022ff3b6d036eb8343d52a3 -b7760f27db0704a6742855998a0c31333bb34d60ddebc95588e25b72445ae2030427aab088ec023f94563118980f3b74 -ad06ecc0f3745861c266bf93f00b30d41ed89d41e99ab63fedd795c970d3ad40560e57ab7333883a72e5575a059df39c -8687d28b1cbc8aa34a0e5dbdb540a517da9bda36160daaa7801fce99754f5d16eda3bc8e1df6b0722cfb49e177e9bcb6 -a38332c3ebbd7f734c8e6ab23ae9756f47afbf7d1786fe45daebc8d7d005d6d8fd22f5dbd0fa8741e1bfb2014d3f9df7 -b86f84426dee88188be9c5cc10a41599e53b7733ba6f2402392b0ea985effc7525756ca1b7b92041ae323337618b238f -958731a6f1881f652d340832728bc7fadd1acebd8daebd772b5acea634e9f7b7254b76d38a7065ea1b2cdea83b18a54f -adb90bff1f0d7d45b8ba28b536c0e0f7f4dc4b9a0354692ecf29539631d7a57d308db3e438e0f907810234c490b42153 -a5188c775ad76617d3bb6e7f1f3b2449f48b7bb7a84035c316284396529564a227e3b9762a89c7114fa47b3ca7ba418a -a3826ef63c98793a5c8c5d5159e2e00cc85fb5e5124f06421b165de68c9495e93c2f23cd446adf6e6528967aa3ed3909 -80eab97de89f3824ace5565b540b229adcc6ef9d2940e90de185af309234cd8aa4ae9c7ce1b409b3898c8fd10c8c2896 -8824f5acd4c2330c459fdb9ece9313263a8b20419f50f8d49958dc21754c21a77bcf7fbf3e0041f78d8fb667a3342188 -95091cf06911a997a09b643326c2fadbbe302555ab2521db806a762a5f4492636507ca71d7a093840236ac3c096614f7 -a392c81a546196d7e78b61f3ceaadfb2771d09fe43f862c0af65f5e55ce490a0293b9ab754cb5ab03ff642a9a8213a23 -afd76cce1dfa2c9e4af4f840376674f090af37d8c6541824963373f97b9dd1f405c50b2ff56165e1d4dde760e590738a -8fc4f513d3b40c10872603e1c29a4b2cf4c99320962644ce89f69ffb57f844344e1d472b2d43559119bdfb5a2c21749a -9951ca8e13b9a2b4a789e851c04c4f030470772da62f101074ef304612e9653b43b37d2c081b5d0a09196b3a167f5871 -b4f16fc2a113403ab5fc1b6a9afddec77be7406413b70ee126f0e84796168a572940550d61e443e5635591d4b6c46ca9 -8d71452cf39e7345c7298d514b9638a5cbe78af7652f0286d42632c5c6d7953ed284551fb40c77569a7721413cdbf79c -953625b58d52a308cb00ad87c44a3fd936786ada44000d45bb609ea9db6b156a0d0f9475e13ee5e053eaded19a09990a -a0983a3baa278ad5f5de734eb1b65a04f668408994e396fb0b054991ad2e56e27ac522b04fe37c9583b754e344f795b3 -8eaa454257f77a6754b2c1c5ff0036fa5b03e214576fabc657902c737fcbf298b1795b43c5006e18894f951f5f7cd203 -90183fdeae2ce2a295a567fa61b997b1f975d1be7b03d0101728cd707bb2a7111c222588ab22e573518fa1ef03719f54 -8abec7f31f6b897a1d497368a42733a6bd14ffbb8b21d3e49fc4cd3c802da70e8886827c1aea0b18d1b44635f81ec461 -a6d1e6fd24b0878ff264b725662e489451c590b2aadaf357d64210a3701fe763f529826fa6e0555267c1f5ecc2c52c05 -8fe6d2a4ea0d91702cb2a8a1d802f5598f26d892f1a929ff056d2b928821e4b172c1c1c0505aa245813fe67074cf9834 -82a026a408003583036f16268113ca6067ce13e89c6e9af0a760f4b2481851c62fadeeef0d361f51dcd9fa5674ec5750 -a489a574b862d4056091ef630e089c163c16c2f104d95eb79a27ae1e898b26d6c1adc23edc1490f73bb545d3a6e3b348 -939d85148547fc7b9894497841bd4430bc670bb670f0efeac424b529a9aebf2c02ac18a9d1402a12e4e590d623de09f0 -a3ab52cf911a2ba7fb0cd242d7778ec0d4fa382960c9bd5b476bb1cd44ff1430a3871bbbcea0a0db2630c39ee639fd1e -b7629509d8c3a3b88b31f1af137a25c38f536284f11a5bbbe0d05b86a86bc92ebbf70f17c256dc8b0d48374e1985e6f3 -8a8647ff33e0747dd6c6ceddcf7938a542656174a08a31b08337ea49b08d814e75f8363fb51676a2cd2746569e3bc14e -a7a7f8d94d32b7cee00b3ff272d644b8dca86b8da38c726f632c2bcdfa0afb13fd0a9a5685ddaeb6073df4d9cfa3d878 -b7136eea8d05bfee2265b0e9addb4bdf060270894de30d593627891584b9446b363973de334b6105e0495cf8cb98e8f7 -a9fcd33ea59315ad7611a3e87e8d1fd6730c8cbeeaebd254e4d59ed7d92c97670303a2d22e881ab16c58779331837529 -965fd41741a0d898c2f2048945b2aefc49c735228c25deaf17fed82c4d52cf3f8e93b3fb8825ade632dc4940311b1542 -b9f400a2c7ca7da8b36470ee5d26c672b529b98e6582012cbfc2a3c24b72e73f5633de4265c417c0d47c474155a603c6 -85f333b0b1630a688a385f48bf0175cd13ecdd92fa5499494f4ad5aea0ef1b9d180fad8f936018538d842630ff72884c -8da95a735a1a98ed8e563099bd87d13a237dd7ec6880cfac56c6416b001e983a56f3d72dda7f68684bb33e4f64cadd30 -a29b66a2095e1acce751f6aec8dfeae1e5b24187dfedb5d1635ca8deae19b580ef09329a18b3385ebb117cd71671f4dd -b001deeeaf5eaf99ac558c60677b667b9f3d57cf43a2c4d57fd74b125a6da72ea6c9dc81b110655e0df01ca7b8a7a7ed -912e11dfff77c778969836d5029747b494dd81d9f965f8be2c9db9e8b08f53858eface81862c3ee6a9aa10993d0d23f3 -ac166a00e9793cf86753aa002ca274cb6f62328869fe920f5632a69a5d30d8d3ce3f0c5487cb354165763ca41d83495a -b74df519ae1a8faeff2ccd29892886b327c7434360ab5c5355752667069a77d466a48cb57b1950d10b6c47c88b2a8538 -8751679aeffa39da55f2c2a668f7b26fb8258f70c5454b13e2483e3ad452f3ac7cc4fa075783e72b4a121cd69936c176 -ae0cc16848b8bf8fffbb44047d6f1d32b52b19d3551d443a39fb25976a89d1a5d2909a4fc42ee81a98ad09d896bd90a9 -a0c8acd6a2f0d4ab0e0a680fa4a67b076bbbf42b9ec512eb04be05fb2625f6d2ed7b4349eebe61eb9f7bd4f85e9de7fa -85c629ce0deeb75c18a3b1b4e14577b5666cf25453a89d27f1029a2984133a2b8e7766597e2ff9ee26a65649b816b650 -938dbb477840d3ed27f903d09fd9959f6fec443fbc93324bc28300dd29e602bd3861fd29508da0dfdbb0fff7f09c5a6c -a7c76cd4a42ab7904d036fe6637471d9836ad15d0d26a07b1803b7fb8988b8c9edf522e0d337a1852131d0f658565ae7 -838a30260cf341ae0cd7a9df84cbc36354c6bc7b8f50c95d154453c9e8ec5435d5f9b23de2a5d91b55adde3dbdb755b9 -8f870b1f798c0516b679273c583c266c2020b8dea7e68be4b0628b85059d49e5a680709c3d6caabe767a0f03975c4626 -89bad0b6499d671b362ae898fee34ad285aa8c77d33ca1d66e8f85b5d637bbd7ae2145caae7d9f47e94c25e9d16b8c4f -af963d3dd3d983864c54b0ed1429c52b466383f07a1504215bbf998c071a099a3a1deb08d94b54630ac76d1d40cfc3da -b5686de207c3d60d4dcfe6a109c0b2f343ed1eb785941301b827b8c07a8f1311e481a56a4baab88edb3ddc4dace6a66a -95e5978739a3e875e76d927f7c68bdf7ab20966db9fa8859f46a837760dfe529afa9a371a184dfb89d2962c95d5fcf3b -96d2855e20c37ed7bd7f736e11cfba5f61bb78a68303a7ced418c4c29a889a4798c5680be721a46d548d63525637e6b0 -b134bceb776cd5866e911f8e96016704c9a3caeadcabd7c0f37204497d789bc949e41b93e4c2d597e4c924853f1b21e3 -a1949ff397013acde0303e5d64432bf6dd7f01caa03c5fc38e7c8ae705b9d5c2646b4b02d013004e5eb58e344703260c -8036a5f79d8aeb6df4810974cf8dbd0ac778906d2f82b969ac9dcfbe7ece832a7e8aad08a4dc520f7abeb24b1610ae84 -982b6b0af8602a992c389232b525d4239edc3ae6ceea77d7729d1fffc829664dd647ff91c4cb9c7f7c25cea507f03167 -b34c7d24fa56ab6acdb8af5b4fa694a1985a1741cc53a2b0c5833611e8ed6fb3b663a4d9a126bb4a1a469f2072199d66 -8166366fec4ee2b3eda097dc200cdfa0533a742dfbe7082dfa14c1c1ecafc9d9fa71f518476634f29d06430869bd5e02 -86c0251ac00b8200618c8b7ce696d1e88c587f91e38580b2d6ae48a3ef904e0ba1b20b7f432719ca40e7995f2281a696 -afd89f3bc7843a1e45ac961e49c1971114c5238d9e21647804b1852b8f476a89c12d1edfb97fff71445e879d6bfd3b70 -911d8bec4d4c3e73a2c35469b2167569f59705404425bd95440408fb788e122f96e9b1bd695f35c6b090f10135b20cd3 -b3f6350ff7afaa0660f9dddd9559db7f164e89351a743fc695d987c88f89fc29136e3c5eb81963edabf2b6f2057120be -a371229680d1468777862e9c0e864156f9cd7c12ce7313a8de67b7bd34e3d1b6fa45ce891a81f8316f4afcbdecf3b6ca -a6a9a875ef9efe8ba72523e645b5773aa62c4fb41efd23da3fa38105472308b8d293be766342ee0a2f00758825bd3b6a -a840d495a184f4499b944ee08f07193a1e1bb8ab21f8ce7aa51d03bd8643f2bc2616c17b68d3fe7c0fb364136926a166 -b55200ae7d6ebb0b04b748051c5907293184b126cf8a1c2f357e024f1a63220b573e2875df83d9b5e0c6e2ace9300c40 -b1e0870f2e3719f42a48256ee58cc27f613308680f2d3645c0f6db0187042dddcfed0cb545423a1a0b851b3a16146d70 -b43a22ff3f838ad43786dc120b7f89a399ed432c7d3aa4e2062ad4152021b6fa01d41b7698da596d6452570c49a62062 -88b1dc50873564560affaa277b1c9d955aebdcdd4117dab1973306893b0e3f090899210102e7e1eef6f7cdf2f4e0e5db -9223c6246aa320b1b36eb1e28b5f9ccc2977e847850964f9762c7559da9546e508503050e5566ccb67262d570162b7a3 -aeeed21b932752709f43dc0c2c7d27d20263b96a54175dd675677a40a093f02bba80e2e65afe3eb22732a7617bf4ff9d -b47cae580ae84f4e4303db8f684f559382f075ef6e95698b9a629e92b67bf004f64e7cf47e401768fa170c4259efbda1 -849821e1ead81fe2dc49cd59f2bba305578c4ea0e8f4b8ae8fc275a1c4a6192f8819d5b6d7da786c94dfc16aacf3e236 -8c60d9a8baefc72a3d3f9dd2e24cca40fb5ce36b19d075122391d9b371c904a0a15d2196c0f2ac9da3acf188d15b0fe8 -946edfe168bbe5ddb0fa6c2890bb227d8418bfbebe2bafab84909825484f799407b610d8aab6a900c5ff9eb796cdc4bf -ae7bf8ae71de5d7ea644d9541e49da1ec31eca6ff4c3fbec5480d30e07ef2c2046cc0a486af7b3615a6a908846341e99 -b4d31a6f578463c9a5ccde0ea526c95b1981eb79468665395c0e550829abfdfa86689699d57830856e324092a423f231 -93415ad3a732417cca9771b056ed42db7ce50879aca7c6f71883ad297eaf5a37fd4641d44a0b7e28b90c168834141340 -98960617a413a3ba86d8257a7386355a69258943aa71834166bd624ea93b0af06178e86538e237f88fd039eacf7cb04a -881335200a487545e38d5b1ffda3080caf5729e1b980603bcdf9ea652cea7848335b83aeeaa321d3476ae4a8d9073582 -b39e84c14666d51895b7a8341fd8319f9e0a58b2a50fc3d7925cce3037f7c75367b5fb5bf25ff4720c9992cab7b8b9f4 -8ea4bab42ee3f0772d6bd24dff3643d8b61147b46ada374414d8d35c0c340e458e449d31023d96e66decf9c58e30cc34 -a5198f6759a045b6a4ba28e4bc3bb638fad44c5a139064327580e285adf38ea82a7570acebf925e81a39d9025f3a6f2e -80267097e2d27c1b19ecf95d184dcff822d34e03326b9fc139a4f8b75b3f80777bb97a9dd284d9b755f14dd401d63c0e -946f346220bd3b6f733e94b61a1ad0b44e45c356fa6036dde5882d93b5613c98e23b20e91eddc6b3c5acea38085705af -a5f559e110cad99bbcae2d9362434aee7db0f3b6d72311291649dbda3f84c10e9760b66b988db3d30067bf18ae2e5238 -8433b38e5c7b293ef532f8c70cef1ed9be7f31f60d5b532e65df7d2885203be78b7ad78ab3011bc54cd9f64c789bf837 -a5a4c0a9b0e0b6bb912cf6ecd30738b0acc0146d77442449b486c3f32d7e60244f643a5cf9cc6da2de5408d0c5f17691 -a81feb329fb51b72464bddcfcf4e02149d995b548d88c64ba143144ce16b652c9913c8ee948ee837596ec97cc43d8cc9 -88e5a7e93a738d61330425bc21ade88d33d7160d124bf174eb3e12a00283654431036977c4f1a47a1bbbf2ef8449ac89 -ac75ad7c099383069e662bfd3624b92b64b5838246902e167fc31b9411efda89b2c6bbd1d61b9eb7d304faacf438d70b -8583bcd1c7cb9bb4bb6bcff803b0a991912b8403a63c0d997761ff77295ccc357d0292318601a8c61329ab28fed7bb83 -a1f9aa0523f1dff00023a44a6c3a9e4e123be0f6722a1c6682ac3c6047efe9e62f4773daf4767e854e1fcbf8ee7339e2 -85f65ebcf5c7e574174b7c4c4166a9a5368e7986b8c0ef846c2e13b75dea7311a87483503149ebfb3cb839b3ef35c82d -abc55eeb72699031a367b9675a2b91a8434e1f01467660903ced43a0b2a11a85ebdf48f95c13ff67e4e2958065a50ff3 -a4ff77c9b86939a15647499b9412417b984bfb051e5bf27b35392a258a5dac297bbdbcf753a4be6729ffb16be924a2ff -af0d41c15b5172efa801cc85ed101b76844dcd06712d0d21160893235a2dbedd15d187a9b31cf0d0ca6c14de6ab2b707 -92661339199f18e5dd9a210783c1d173a26dfa315bd99a33d6f04bf506c871a2b47745c1909faa209d5e6c5c645124a4 -b35813dafb52df709dfa47982bfb44e1bf704f9f46085b2a0e92511dff90e5597110f614f8915830821fc5ed69ae0083 -934a05aa713fa276a4d47f1a28ef06591e5a9a69293c1651c223174df0af4927fc9cd43d374d89c1b4f7c8dc91abe44b -8f83a0ef05202c0b7170ac96f880135e2256fdf8964dae5aed5dd0f6452a6d8e123321e8c182b3aa6f1f8ab767caa735 -b92db10c21c321cf1349fd34129d7180e5088daf2bbe570de6427299aab68992c011c2e2939a44247396f5427c1d914a -95ce1892d1ce25ef2bc88a23880055a4d829a3b31f3806635fd49bec32cca4e965b129b6dd3e90f7e3a2eb293ffc548d -970cf816ee7501ade36b0b59f87c7e352957f67f1f75bbacd8ed52893f9fc40572c76f49c23db44866af7e34a63cd3f9 -a2fcd08581d3569fff699fd7ed1ede5f98f2b95956ecdf975a29af053d9f4f42600b3616ad6161e958c3ce60139c20a4 -b032688b6cc8a7e63dcb82694f71f087b1ee74c4d5fa27323b1ead3ba21722d7fc49eda765725b5553db5260005049c3 -b0b79e4329f1ad25ef6a603390baf889757cab5af10bfa6953a61f89aaace0442b9ef08e57ba778f1e97bf22f16f0ace -a2e6ac06f8973266cd0df447f82cec16614df65174c756e07f513e2c19aa82c10d8670047860960cfba3c5e4c42768c8 -811e66df0f3721a1ae0293549a0e3cd789f93fb6be2cab8e16015a6d52482af9057b1b75e9456322a5a9e87235e024cd -8744a80b3d9e37da4c50c536007981a4958d7e531cb93916dbf985cdc22f4ff482a5cc4fe50915c049d2de66530f1881 -b20b6e8c7be654c23c8ca440be2c37cf9cc9f4e81feedfd0cd7c56f37eda8f295fe5d415e9bac93d5f0a237edd8bc465 -b33fd84377f31f7819150d464b5eb3ef66e06cb8712665cf0587d61e1b1c121d11cc647f3753bbc18604941c77edbc1f -83acb8a3ec5f477b6d44cd49f9e091bc2bf7c9dfee876cde12075a7db9262314cb66ad2e7557114e0c19373e31c6eff1 -acfe4172327832ee207eb07da9cd37da3b009c776f7a8290529f0249f58da213254baddc7c3074fbaa1d226ba1e52b7c -81911b4dea863424b9d77a981987732382702e0294d8c8e1ec48e89678ecb0e64836b45205a120885fa8f8a3a4b9d4b0 -b11f61b1302579a11077bb2f1f0db371ab943573b261be288dc76172eee8a5102b992a5b526092d160ffd20aac2d4856 -ab491f7f1e002a44944c02537f365e525ebb6d5614bba8e5e8e8bd12064c702a1759571ddbeee592a0ba8b73cfce8810 -89211da3d92aed6b111de001b8b5a9231a1c2d09fb1cd2618ec457b635a6c8590fe119acca42fce76dce791c35b889c7 -a5f076c8f7164bcab8af59021ef97a0afa93d0877e52241c3ff5a9a9f81227a55c119ed6a84d34b196e94ec851ca5ca0 -80d91417d0d6c1adb5a3708165da1d54a83caaff482a4f65abf3fb335cbbc738c74ed19a8c451ca98befdf9b2d8b5f90 -aecba33a67f66401614eec5fa945e763da284edb9dc713bad4ac03972630781a09a3e2a291aac0605a9560c5f3444de5 -8a0aa1320bf5217a049b02ad02a4f892bfd6a3f5b48f472041d12f3aaab8dd197307f144f9de5f9e762c6b4971a121b4 -a4120a569e446fe4129f998e51f09c1cc7b29dc2b353d6f6f05daad1a4ef99acfcbaa4950a58aacf7ee1b3fde0af33d0 -aff71370d58b145758a5f24cf3c0c6667d22a1f950b8137c369fa845a5265cd645b422f24fa95e1cd7db1d68686120b6 -a839f075a8a702809a51fbc94595eab4f269a2e7a027aa1f4fc472e77f586138bf5aa4e5570a560e139eb6cda4cca161 -9484f1caa3e35cda0e3d36e43aff3dd8cf45a5a51fc34aafa3a63ed3543047ba9d6af2a9bc7c201c028499e6b4c41b28 -84ddb374c5c9170903bb3e1054fad071b0a147a9ca2ebe2fdb491ebb2431d53b398872a39cc385f973e38579d8e60158 -acaad8babaeaeb52c5b5a16ae689fa5ae15846f2d1f3596a52371bd8681819603822ee8d32ab8cda1bd5290d601e483f -946b69ca5361b60c3dc31db13669b05e5c0452f3c80e7e185f9667a36f351e9ed83bcb5c6dd2439ecd4490e3a87d260a -99f457221ac40df86f9b4bef0bf8812720b2f7218273a0aab08c4d4d4fb18a0fb0ef6ba9bf7fa53c116cc6f16742e44f -8bc0e812d8b718dbe48ead74a6bc7bac68897d01d097422be04110a25589bacd50d336d2c8b70d0dfde6c1b8bc372dc3 -895d118dae2fb35a4b0de22be0d000ec0f0f317b9494db7c12f10d7db81b6f3eaf6d6f3fdfe952f86ec4143d7469368d -893bf3d7e579e800526bc317438a69590d33759931830daf965cec721baa793ea335e9624a86b84b8fed5effc3e2bbac -a112d30dda88c749ca15d6dc65bcbc7fe838b2d25329d44410a9a96db195c7ce6a6921196a61ba7c9d40efdb101a164d -b88b5340af052fc3b8e1a8cf7532206801e79d878f1fb02b32ac4f8e91b64e0ec9252d808b87c4579de15886a20aaef1 -865f76475bb5da18c6a078c720c7b718e55d310876c98017c30ac31882ae347258b508ec34001918324250241d2df5b7 -b6d8a15913eb1714061d5cacbd0bb05edd83ecdb848a89b864e7411598e9f7814d0c039ebe4735437c8370d2ff183751 -a95fedce8351ae9c24d7fa06ebc5cd4e3aef87afaf04a7150e561a6a7f2347bdcec1e56b82d6e5f597fe7124f6cc503b -8526004ca0c802b073d50b0902ea69975949e7567b2e59ca2cf420bc53d91951d26096f2abb07a2955a51506e86488dd -99ccecaab68b6e5adadb9c848cb577de7e7ff4afc48d3b6b73bc0872730245b8a1c68cebf467074af6756d6226f4f4a7 -b5497d5c0cd79b7e6022e295642e1f2161254379eb78ef45e47f02c84ef5a3f6b6297718e4fac8093bf017287e456917 -b6943f30012b2093c351413c2b1b648afc14a5c4c0c338179d497e908451d2779919fe806181452ed386c1e8f8e8c25c -afdb56ce89bcd3247876c918cad68aad8da65d03c7c73ccbee0c4c39f3ad615aab87ffa0db5b3b63b4cc915d0b66deb7 -a44659d7be2f11d4d4949571d7bf84a6f27f874d3281edc34ef1098d321a4dcad9a42632b39633f8f9d20a39f54a2464 -a3e489b4db5832280dd58c62120262471b6fb4355c2ad307bd17c5c246b3f1e1b00f925930f5f5f6987de234fcbb7d16 -87a4e3a190340ed4949597703083d338e9c17263ba8a39b67100589f0dddbc420d9557f9522c17c71ae04b76876f8db0 -a35a3978e928eaac8c182a0a613c611ae7b4827c5e999f938eed06921c0294befdc21d02e68d035a2fc8d03c82641126 -a6898d90265dcf0fb215629f04b07c7918e022667583efe0bfe02f258b446954876c6ca9e369ffe1bb079e2314ebda32 -922fc52e648b6b2b6768c079c67ab425da72907a46add801715f8a2537280869d7071d527b833aa63ef562ce059a392b -8acbb7c4297196d8d1c131040c34cc7064656a148c2110b19c672abb094b1d084fafe967f7122ba9dd1523a4eaec3b42 -82dbf2cdd581fe3b81b156792228eae2485710e6c21dd5fd14614dc341bb0afbebbc0f32340eda9f094b630afcfc17e8 -907a095dca885da219e4558e9251ec765cf616e995c61546bc010963bf26f2d8adbd9b2ef61f2036e1740a627c20fbed -a7a83f849691d04640137989a2d0c90a7ed42a42b0ad328435d7e1fba557a27a58eec9170ab3d0099ec97da0c950765a -b7d435a801c2a5652cb479027f2c172eafa3df8ca0d896bbb9d49a42c42660fb382a8439bfed09ddf7e0214cb6066761 -8bc6b5e79af5512589f90de8e69bc858277055cf7243f592cc4edd193f03f71d16c9300097ddafb79752c63f135c884c -913264fca800467bee58a429e1f245ef303f5dbeea90f0ce6bb3c7ae6d1bd0f99ea75d3d309634684d2178642c81b5d8 -83ba558f9c23b785a123027c52924a1d7334c853a6165d4f5afd093b0b41951a36860ba0a20fa68f73d7db9df0e3ef38 -875b2df7cb54ecdf7ba31181b9dc7dbe02761ab8ffb61757d42a735c8e20d44bad5b904e76dcec6bb44883fdb9f4ad84 -af3dc5d2dd29565de8f4c700d5f1ab71dadb4351f06e9ee2eb5ee7a9b5da827d0c6726c6dc780748a26aa3b4d10e6c2d -a113ff09296b25f550f6d0d3f37dd4517b14cf6d5517293bd3068aa3aea765a8640fcd4bf0ba96db5c00167267fbd574 -a138c5cca485b9180ef091c9e327982bea203c165cb83564f416c36e813bea1ef1f6345f57c8a591df360541b7b758f5 -85793441e917ed520d41dda6e762269fb9f9702e5ef83cee3e90652d324536bf4233425cd05b54a383609076ab84ea13 -b422ac9de53d329e6321a8544c264d63cffc37965d627d7e180a999c3332644e21fedf10cd2f43cf6ba4fc542db91155 -a85d31d4bfa583a493681e57bfccca677ec5b85870a53de37f7be7833b573f8c8dcf029cea4ae548d83048030d77d56d -ab8a0702a371db496715a4ee8fcb6d430641b0f666d7fe3ef80c09df0bf570293cec1aa1675381c6bbd9ecc1f7cdccf9 -b308ef2b87438d35957191294782e9f5014a3394fadad3e2ccaf6ebf20fd889a36dbb8ddb3634baa8e2e131618aa4e70 -919e972e5b67cd65f377e937d67c27b4dd6fd42cfe394a34a70e8c253a1922f62ff36b9dcc7fbbc29b0960ad6a7fde88 -a0e4d4be28301af38a910971c8391ef3ec822ce35757226a7fd96955cd79afa14accba484ef4e7073e46b4b240a5863f -9422f6d424c1736b4b9bb9762aa62944085e8662c4460319dac4877b1e705aa5cd8b6b3a91268363ec3857c185685f4b -b7cf9f2053119d284a37df4e4489b632594df64e5dc846652ee26b4715e352e6333118b125021481138e4ec3e9f9987b -aea983e81c823472df8652654be8a60a8bf40147d599f87e323397f06bf88c98e9c6db0f28414f6ea4091f3eb0f6a96d -aa20bf03cd8b6ffda09fe0ef693fc0aaa3bb372603e786700e52063a4f7ee742771c41cf5e67e6248f99b7fc73f68dbf -8748a4978198071d7d5ddc08f8c8f0675d895dc19df0889e70bd86d44c469c719b93f6526c7e7e916c7bfeb9a1379aaf -b8fcd863d55dab2f7b1c93844306e00056ba17338ddfa3f02689a0b58b30239beb687b64c79b8420ecea8d0d082d9ffa -abb1a35952dc8a74dd1cdbc8ae7294c6bfd1910edab6f05c879e9ed06c636a949fe0017ec67f8f6f73effcb5817cccae -8bef43422b1c59e354b7f46c08a8eb78e26c4d01c236a4fe781cefb7465293a4444f2bdc68c6a221cd585a2494d9a1d7 -93527258940feff61befa18fcd6626fcff019d34a3ac8c6886599cbef75b15c15d689e8c1bd2177cc93c4c1792dee8d7 -b7f114eea99c8278841180ec8886ad2bab1826554a1657b9eeb17aa815f31b59c3931913ddec40aa9923bc92f8975635 -91a96446158b194a0a6ada2e37c8a45f3017c34034f757245f6f3b98c65d39d084e74d2a9dc271e5918faa53990ec63f -aea4ada0a853753db03f9790e20bab80d106f9b09e950f09aeaba5d869f0173bed673b866a96d6b0dd8123a539caac9a -b8e3e98ff0d3e512441e008a4a6783233045a4639e0c215c81984846b43ff98de99d7925cf717b1ca644f6229b6d16a2 -8987ef81a75213894e11e0310e8ba60fe06e2b264cc61655e5b51bf41cc8c3d6c10696642ea3517770f93be360207621 -8d4eff7335252f74af4a619c78625fd245df640f2086338dbb6c26b059f83fe70f3e81f5b6c12d62c0f784e572d56865 -a56f6389b0bac338f20c615d7d11e16045a76cbea23ced0a9d9067f538421c378200bfd4523b7c96094ab67f47f98d42 -83f5ab0727fd6ce8b3370ce3fac1f3a9c1930ea7ebbd16be61cc26f34aa1291ba4b5f16729d7d4f5924eaa4a1e31a04e -8cc62366874bf8751067a526ea32927584cef41174e2ec5a53079ee557067bc282f372b831cb2547c5e21a2f178c91b4 -b609e141006dc8d8649457efc03f8710d49abb34bc26a33ed4e173e51b85d7acdf18d74aed161b074f679d88f5aa2bf3 -873c7aa784c17b678443320950e494250baff8766db42619b9fc7ec4c3afa4eee290cd1f822b925d5b9e55c9cdd1af2f -859ba787f052d3665481c3dd58159ec8c238d918fb6d2787ebe275ef9acd377cb7aaa03a69820c78247bf51afee3d5bf -8eb1e6d2b0f51a3275b4a8be96957cb2d518b32c815dc0dfd5f75340c7dee73e5edc45db7c7d375c4ffaf8c59767d0c1 -85f3876ff5edbb826a9592e68db3dcc975725bfdda4fcac197758a8b27e4f493e6c531b1342ba0f5a75f965273720345 -8a1272f2678d4ba57e76c8758818965e6849971e8296b60ff85a522feeaaa3d23d3696c040d8bdaf1b380db392e988aa -85002b31ce31be7cc8757141a59a7cf9228b83144993d325b2241f5bfac09a02aca0c336307257f1a978c0bbf79fa4fe -b96bd26a6bbbc705c640285fd561943ef659fca73f25e8bf28cfcd21195752b40359d0edca0adc252d6e1784da267197 -936cfe367b83a798ab495b220f19cfe2e5bde1b879c8a130f84516ac07e3e3addcc791dc0e83a69c3afc225bed008542 -b1302f36190e204efd9b1d720bfaec162fcbba1b30400669dbcdd6e302c8c28f8b58b8bbde10f4512467dd78ed70d5e0 -8291b49f56259c8d6b4fd71525725dd1f35b87858606fc3fe7e048ac48b8a23ba3f0b1907b7c0d0c5ef6fa76cddc23f0 -97aca69d8e88ed8d468d538f863e624f6aed86424c6b7a861e3f45c8bf47c03e7b15d35e01f7add0a4157af171d9360c -b590d896e6b6f2e4dcffebfa67fc087fa518a9c8cb0834a5668cabe44e5c2b6f248f309b9cd74779030e172dba5d9e29 -97e7099bff654bcb37b051a3e8a5a7672d6ab7e93747a97b062fc7ae00c95deef51f5ced2966499217147058e00da4be -83435b739426f1b57f54ebad423939a68ad3d520db8ca5b7e28d1142ebfb4df93f418b180a6c226c0ca28fa0651163a0 -946c9144d982837c4dbc0b59544bdbc9f57e7c9ef0c82a7ad8cfddea78dedc379dbc97af54ba3ac751d844842a2990a4 -90ba1eff9c25adba8c3e6ef5b0d46c13de304632fec0646ee3a7bee69da2bc29e162dd3fb98a37ed1184ae5da359cf0a -b17b7a5c0a48eb9784efb5ff8499230b45efeb801cf68e13fe16d0d308511af5aa60e3b9a5610f96d7c2242ae57d455b -9991245e5617c4ea71575e5b2efe444f09cbbed13b130da08f8e9809d62512e8298a88d41f6aa3dbf3bcbc90654ceb18 -a1190c4cbccf2898a7fe025afd03f8652973a11cef59775fb47d69a6b4dcb9a5a0c554070421a5e10a75e43b63d37b79 -857c0a5f291eb35a76be11543a8c3d798187bd0717e2cdee50d390b66322d0d9529520fd3377136cdc93cfee99b6403f -944d11e5f9a3493c67786df94f129352d892fbdc43e98206b8dbf83cce240f65305e1768b38e5576048a31dca5c18f31 -818f361c5dae709e067a82b81beffbd9674de8df2bc1bfc3a27ddf326260e124e46b1e36697fb8de539b7736db093e9e -b07f5b737735a0d628e7ac2d335080b769bdb3acea38ad121e247a6e4307916ba1d029da5d341f079ea61eeaf7d8554e -a69e338803f3ee0fbbddc7ee481a13f6b64d25d71bae0d76f4b5145b54923cf1616c77ba0fd9ca37a3ae47208f490423 -acaee66b94e226622e28a144f93f6b1b442b9c79d7a8a1740c4d53044d0675a661e7453509b9e716e469fe11ce45ee31 -9402ca799d2e1cce0317ed49453ee0b2669b05e68ff101b89306db215c3941b3786ad3402d00369cb1dee020b56d3142 -849440c539fc0df3c8d06e23e271e6faa50234d5c057b8561e9376415f4396e548351cc677b0abeafe4f51b855a3dc83 -865b99587eb3dbc17e412647673f22b2e89185d1df1ec8ea04515585ad2edfb731be458123118dcd7b41b475026477b9 -9390618833b5adbaf24bd38cf9fc6f25104717f314259bb4da5c7a1f6963ecdc04d07bed391d8cd765c3d53567b2b6b1 -95383e8b1d0a629cec238b5ae2bda236a027f4e3b5f99ceace05f1d5a781ec1e7a43058f44ef0a5aee6b0db5697a0d89 -91739b8946d90db3a5244f7485295cc58143ba0449c9e539df1ba3c166ecf85ff914c9941192963c32d35033ae2f0980 -b5d88848d856d882db5947b9182025f0abf2bc4335b650fa0a48a578e2c87f32cc86d42d3b665ee2eab46d072bf1eccd -91f4c754549f5a53b1902ef84274ce9acf0bfd2e824e62eb127d67e3214ce05fc2430c05ea51e94dc6e8978f5d076bab -91fff8c75f8ad86afe78ec301de05e4ca71421d731419a17c747a9a0bf81129422c9499e4749107b168d1695dc90292f -99fbd7bede9cc1e2974c2a21c70788960c2dbf45a89552da8d73bb1d398b8399590707f2f4ba4b43cb356e703eb01b5e -80a51cd83e3d748c07b9ac82de1a697b09031e3edc7bf585f06cd0ffa8ea319517fcc2b735614b656677b54b4910814e -886b27de1f93311d1a31b6d698aa28b54fbd800decd8e25243d89e352ee38cb252d5648b5134a3e1ed021bae46e9da48 -976e70c94db905f83b4ef72188d840874bf005814c0c772f3832aa65b1f21927403125eea7a07b6d3305b1a781b36ab7 -b4adb9d1c49eb31462583580e3ffa625bea4f8b2a7d4927e4ff925c1759d4b3c1e43283d635b54fb0eabfbe1f4c12992 -b66b466bd48485ebeedd47e749d86cbaa3deffbbee2e69cfaa5e9f3bd28b143d7c1c0255a7a1393a2cc1490b2c485571 -8bded5bc0794513947ddb00ff6b780c5cc63a74e2a0b0284153c346a31c82e1eff07c073939da39e6f87a06c14ff1a80 -aceea8c6f799589f6b7070abf69fec724e6679514e60f1eaf9a52c37e9cebb72abcc833a81d8da1a4f5194c1a7eeff63 -89a9f76d053379687fd221ebcaf02c15c2c241bb673ef5298e32640a115d9e0f2331c3e185572cd65946dd6c5bd42412 -a57b6f1e3fdd92eadc6220760f22d0685a82cada1c7a1bda96d36e48e2852f74f3a83c757dd8857e0aee59e978da4919 -9106cf0891bb39ce87433c5f06a5c97a071d08ad44a7cbcd6918c0729c66bb317fbbee8aa45591cee332ad1234c7257d -96c18cca4a0f0299e0027ff697798085f9f698a7237052c5f191b1dba914e5a015ae356b80c17f0fdd31d08c5a939ebb -a892103c93df126c024825c07d8769bdac5f1d26ea9509ee26530dc594384b2a5095cc34e0b41ab3db0392a29792c9e8 -b7c2dbc95edb6fc25802ea051803b7bea682f87a99f8a9fdcc3091c81d914b9493dfb18a8894c964805298a6c22b07f2 -8e40948927d560a6840d7fb99802989ce72b43693e9dc7ed9dcda4bca7daedf75271cf656bcc22b3f999a550faad8648 -b354de1c6f0603df3ed9036c610281e55b51a48950ee3ce57a00b4692232de7ca57d19722700e15cbe67a91fcec2f786 -adf987b90737b933436d8036c1d3f0c9104f26c540052e22e703964f72739ac1261e4289b8f27dec47281a0f3f51378a -8ed5248e9c836fffa7c924178db593e1aaeb54bcf2e93c1983c1f3899cad538deeb2b836430fddc9b2f283e0797ea11e -907e5410e3bd5d7f55340e2f497bd1ca10bfcb4abed2c66a3cdf94dc40bbd7c43ac98754e0b4b223ea4c61eebf2f27f5 -8e81b441ea0397db28840fb4b3c3bfe6d8e31418816f7bda36f9c1cfe4556daee30c43639d90a2dc9b02a3d65e5f4ab2 -897085c477f5030f9fed06e181b05953a8cd2001d959dd6139738d40f1d673b2c7120b5348f678547acfdc90ffc9fcc6 -b0bf2784c4b3808a04be5a00a0593035ce162b3886e1500247b48365eac8ec3d27c7e5e6372e030c779c75fb79772d0d -af3fe6c75f2a1241ac885d5091ff3882cf01695d957d882e940f0c31f7a5b5e269c1a2bae7336e9a7cda2b1d23c03bd1 -a6d94e065f85736d77080a4f775885ccb0dd5efdbe747e4595280bca0ebe12450257c1beadcbec77566ef57508c5d4df -a5c50fe56b5532bf391da639a2f2b6cbb2634fc6637416fea7c29a522dea024d4adaaa29b6d472b4d2cc3e3b85c72e2a -afc35f5a03b245a6286318ef489db05d397bbd16c17b4e92eeb56509f875246c0176c01804139eb67dc4247c2a36ff9e -99ba14ab5a9612c078f9bbaa0e68fd1d52ecceb2ed19bd9abf8f98dd4ed1f9c4fa6e4d41bcef69be2ff020b291749ca8 -8018cdd3d96f331b4c470a4c3904bed44cadecbeec2544ca10e4352cf4ae1a856cf55f6383d666bf997ad3e16816006e -a9964790c318bb07b8fe61d230dd2161dd3160e186004647a925cfec4c583b4e33530bf5d93d8a14338b090055085b05 -ab89d8401df722101c2785cb3ef833017f58376ee82cedd3e9405b2534f259bb76063434a247652c7615a6de5194de65 -a72c3d320a0d40936dee8edfb36703be633aefbb8f89530df04eb6aebe0305ef4f4b6709436f8036d417272a7e47e22a -b3457661ad62634cc25e2918921a97b0bf5c59ccc7063bc8eb53194783f07659f42f8978c589228af5b12696588d8b2f -926fa35cd3ed4c8ad78af6284b87ae53b2e25a1ff50398034142a2bbed5b989ba3181ff116838931742c0fbcd8b8a56c -ae57fe506626432f27ae4f8791421c2df9efd9aaabe4b840ccf65fc3d0dd2f83e19eb63ae87bfa6898d37b5da869ddb2 -99c0a26ac74211db77918156d7ae9bea6ecf48da3ce9e53829a9ad5ed41321227c94fbd7449ae2e44aae801811552b1b -abdd2635b61cb948e51b762a256cf9d159b9fcb39b2fb11ba2fed1cb53475a03fc6e024a6a824a67a689396119a36a7b -a5ca98b98da8bb8eb07b1e5e3c85a854db42addefacd141771a0c63a8e198421dccc55ef1d94662ca99a7d83b9173fc3 -a821bb5cf1eb3aeae6318c8d554e2ea3137d73bb29d2e4450c9a33f441355ea77bb0e0e0ce7c819abc3ed119110a3a92 -95cdfb19b3f7196c26d60586e2c1efaa93352a712f8c8ef6209f6f318cecd52d7bebdfbfee4be1f5903a1595f73bc985 -aef6e6a400106e217f9888afcef0a1e1299b59017e77dc5453317dec0c32ae96873608bef3f1b504a7e4f45b06edc9c6 -96399ad093299ba26dc09ae85dbec9a1801dea4a338dd5d578bcdcb91246db0059e54098ba8a56cbb24600a40095cf79 -ad8b018ac99857ad4b38bdf6d110bbef64029a4d9f08df85a278c6ddc362a5f64e1f3a919f798ccb2f85a7f4ca1260b4 -b211f3b5dd91941d119c4fe05e2b4c7bb0ce0a8d7ef05932a96e850f549a78cd20cded0b3adb3f9f8b7058889ae2cb4e -ab780dd363671765c9c9ab0f4e7096aacf5894e042b75f40a92df8eb272a6229078cd6eadcc500eead3650860aa82177 -a4d96b16ab3abe77ead9b4477c81957e66a028f95557e390352743da53d1a7ba0c81d928a7ea8bc03b9900135ac36a6a -b4d4e028099bf0f28ac32141cd8de4ee7c3d62d4f519fad6abbb4ba39592750812220a4167d1da4c4f46df965f7cf43d -aa929c5f0bd8cb44a861bfb3d18340a58c61d82afa642447b71b1470a7b99fe3d5796bdd016b121838cb3594f5a92967 -a038e66f0a28aba19d7079643788db3eed8e412fb9ab4c0f6cacf438af4657cc386a7c22ae97ccc8c33f19a572d6431c -89c1ff879faa80428910e00b632d31c0cebb0c67e8f5ded333d41f918032282fb59fbcbe26d3156592f9692213667560 -8d899072c9d30e27065d73c79ce3130a09b6a4a4c7d9c4e4488fda4d52ad72bd5f1fd80f3a8936ef79cf362a60817453 -8ffb84a897df9031f9a8e7af06855180562f7ca796489b51bb7cca8d0ca1d9766a4de197a3eb7e298b1dfb39bc6e9778 -836ebd0b37e7ef4ff7b4fc5af157b75fa07a2244045c3852702eaafa119ca1260c654a872f1b3708b65671a2ece66ad2 -9292dfd6d5bfc95f043f4eb9855c10cbcf90fbd03e7a256c163749b23a307b46a331bdbd202236dca0e8ea29e24906de -8bc37eaa720e293e32b7986061d2ffcbd654d8143e661aabe5602adc832ab535cffbe12a7b571d423675636a74b956e4 -887455f368515340eb6f9b535f16a1cf3e22f0ceda2ead08c5caefccef4087e9f4b5d61c5b110ff3e28e4ab2ad9e97c5 -a6e5ec36e7712056fec00de15b8696952b17891e48ebe2fa90c6f782c7d927b430917b36b4a25b3d8466da3ca2a4985d -895cae36ba786104ec45740c5dc4f2416b2adce6e806815e3994e98d9e1be372eaec50094fbb7089015684874631ab7e -9687444fe6250c246b1711a8f73992f15c3cac801e79c54ffd5e243ad539fdd98727043e4f62d36daf866750de1ba926 -b17f75044c8e9ce311bb421a5427006b6fa1428706d04613bd31328f4549decd133e62f4b1917016e36eb02ea316a0ca -8538a84d2f9079dd272a7383ff03b7674f50b9c220e0399c794a2bcb825d643d0fc8095d972d5186b6f0fe9db0f7084f -af07b37644cc216e7083bac1c4e6095fa898f3417699df172c1f6e55d6c13c11f5279edd4c7714d65360b5e4c3c6731e -87eed8fe7486c0794884c344c07d3964f8fc065aebb0bb3426506ab879b2e0dfaefa5cece213ec16c7b20e6f946c0bd2 -8a4bf42f141d8bc47c9702779d692a72752510ef38e290d36f529f545a2295082a936c8420f59d74b200a8fff55167c4 -a7170e5e00a504a3b37cb19facf399c227497a0b1e9c8a161d541cb553eb8211449c6ac26fe79a7ff7b1c17f33591d74 -a9a2cc7232f07ef9f6d451680648f6b4985ecab5db0125787ac37280e4c07c8210bab254d0b758fd5e8c6bcf2ee2b9ff -8908d82ebfa78a3de5c56e052d9b5d442af67a510e88a76ba89e4919ae1620c5d15655f663810cfc0ee56c256a420737 -a9d47f3d14047ca86c5db9b71f99568768eaa8a6eb327981203fdb594bdb0a8df2a4a307f22dcea19d74801f4648ea89 -a7c287e0e202ebfc5be261c1279af71f7a2096614ee6526cd8b70e38bb5b0b7aca21a17140d0eddea2f2b849c251656a -97807451e61557d122f638c3f736ab4dab603538396dca0fcdf99f434a6e1f9def0521816b819b1c57ecdfa93bd077eb -a8486d60742446396c9d8bc0d4bed868171de4127e9a5a227f24cbf4efbbe5689bbd38f2105498706a6179340b00aed5 -a03b97c2a543dfefa1deb316db9316191ab14e3dd58255ce1027b4e65060d02fb5cb0d6ac1a2bf45bfeac72537b26429 -a7d25060f6861873410c296a4959a058174e9a1681ac41770788191df67fc1391545dab09de06b56cd73a811b676aa1b -96bb9c9aa85d205e085434d44f5021d8bbafc52cd2727b44e2a66094a4e5467b6294d24146b54c0d964c711e74a258d4 -b07b17f11267e577191e920fa5966880f85ff7089ac59d5d550e46f3a5cdadd94f438a547cd1ec66f20a447e421f96c6 -964e33e1571c97088fe7c8ca3430db60a8119f743a47aa0827e6e2fb9bae5ff3bf6cecd17b11dd34628546b6eb938372 -82a0513a05870b96509a559164e6ff26988ea8a2227ac6da9adc96fe793485a9eb6bdcab09afac7be4aef9a5ae358199 -b1185bc679623e7a37a873d90a2a6393fb5ccc86e74ba4ba6f71277df3623cde632feae4414d6429db6b4babde16dee0 -b3d77504b7032b5593a674d3c0cd2efbf56b2b44ed7fe8669f752828045e4e68202a37bf441f674b9c134886d4cee1df -95ab31749ff1f7b3f165ce45af943c6ed1f1071448c37009643a5f0281875695c16c28fc8d8011a71a108a2d8758e57d -b234dee9c56c582084af6546d1853f58e158549b28670b6783b4b5d7d52f00e805e73044a8b8bd44f3d5e10816c57ecc -86da5d2343f652715c1df58a4581e4010cf4cbe27a8c72bb92e322152000d14e44cc36e37ff6a55db890b29096c599b9 -8b7be904c50f36453eff8c6267edcb4086a2f4803777d4414c5c70c45b97541753def16833e691d6b68d9ef19a15cb23 -b1f4e81b2cdb08bd73404a4095255fa5d28bcd1992a5fd7e5d929cfd5f35645793462805a092ec621946aaf5607ef471 -a7f2ca8dacb03825ef537669baff512baf1ea39a1a0333f6af93505f37ed2e4bbd56cb9c3b246810feee7bacdf4c2759 -996d0c6c0530c44c1599ffdf7042c42698e5e9efee4feb92f2674431bbddf8cf26d109f5d54208071079dfa801e01052 -b99647e7d428f3baa450841f10e2dc704ce8125634cc5e7e72a8aa149bf1b6035adce8979a116a97c58c93e5774f72b7 -95960a7f95ad47b4a917920f1a82fbbecd17a4050e443f7f85b325929c1e1f803cf3d812d2cedeab724d11b135dde7a3 -8f9cd1efdf176b80e961c54090e114324616b2764a147a0d7538efe6b0c406ec09fd6f04a011ff40e0fa0b774dd98888 -b99431d2e946ac4be383b38a49b26e92139b17e6e0f0b0dc0481b59f1ff029fb73a0fc7e6fff3e28d7c3678d6479f5a3 -a888887a4241ce156bedf74f5e72bfa2c6d580a438e206932aefc020678d3d0eb7df4c9fe8142a7c27191837f46a6af6 -ab62224ea33b9a66722eb73cfd1434b85b63c121d92e3eebb1dff8b80dd861238acf2003f80f9341bfea6bde0bfcd38c -9115df3026971dd3efe7e33618449ff94e8fd8c165de0b08d4a9593a906bbed67ec3ed925b921752700f9e54cd00b983 -95de78c37e354decd2b80f8f5a817d153309a6a8e2f0c82a9586a32051a9af03e437a1fb03d1b147f0be489ef76b578b -a7b8a6e383de7739063f24772460e36209be9e1d367fe42153ffe1bccb788a699e1c8b27336435cd7bf85d51ba6bfdd6 -937a8af7ed18d1a55bf3bbe21e24363ae2cb4c8f000418047bf696501aaeec41f2ddf952fd80ef3373f61566faa276a9 -ab5e4931771aeb41c10fa1796d6002b06e512620e9d1c1649c282f296853c913f44e06e377a02f57192b8f09937282eb -893d88009754c84ec1c523a381d2a443cb6d3879e98a1965e41759420a088a7582e4d0456067b2f90d9d56af4ea94bba -91b2388a4146ebaaa977fec28ffbfb88ac2a1089a8a258f0451c4152877065f50402a9397ba045b896997208b46f3ebf -8ce0523192e4cc8348cd0c79354a4930137f6f08063de4a940ea66c0b31d5ea315ce9d9c5c2ec4fa6ee79d4df83840dd -b72f75c4ab77aca8df1a1b691b6ef1a3ff1c343dd9ed48212542e447d2ed3af3017c9ad6826991e9ef472348c21b72a4 -af0fa5a960f185326877daf735ad96c6bd8f8f99ab0ab22e0119c22a0939976ece5c6a878c40380497570dc397844dba -adf9f41393e1196e59b39499623da81be9f76df047ae2472ce5a45f83871bb2a0233e00233b52c5c2fa97a6870fbab0a -8d9fc3aecd8b9a9fca8951753eea8b3e6b9eb8819a31cca8c85a9606ce1bd3885edb4d8cdbc6f0c54449c12927285996 -901969c1d6cac2adcdc83818d91b41dc29ef39c3d84a6f68740b262657ec9bd7871e09b0a9b156b39fa62065c61dacb1 -9536a48ccd2c98f2dcbff3d81578bbb8f828bf94d8d846d985f575059cd7fb28dfa138b481d305a07b42fcb92bacfa11 -8d336654833833558e01b7213dc0217d7943544d36d25b46ecc1e31a2992439679205b5b3ab36a8410311109daa5aa00 -95113547163e969240701e7414bf38212140db073f90a65708c5970a6aaf3aba029590a94839618fc3f7dd4f23306734 -a959d77a159b07b0d3d41a107c24a39f7514f8ce24efa046cfcf6ace852a1d948747f59c80eb06277dce1a2ba2ec8ea9 -8d2cb52dd7f5c56ef479c0937b83b8519fa49eb19b13ea2ec67266a7b3d227fb8d0c2454c4618d63da1c8e5d4171ac7b -9941698c5078936d2c402d7db6756cc60c542682977f7e0497906a45df6b8d0ffe540f09a023c9593188ba1b8ce6dfcb -9631d9b7ec0fc2de8051c0a7b68c831ba5271c17644b815e8428e81bad056abb51b9ca2424d41819e09125baf7aaf2d4 -a0f3d27b29a63f9626e1925eec38047c92c9ab3f72504bf1d45700a612682ad4bf4a4de41d2432e27b745b1613ff22f9 -80e3701acfd01fc5b16ecfa0c6c6fd4c50fe60643c77de513f0ad7a1a2201e49479aa59056fd6c331e44292f820a6a2c -a758c81743ab68b8895db3d75030c5dd4b2ccc9f4a26e69eb54635378a2abfc21cba6ca431afb3f00be66cffba6ab616 -a397acb2e119d667f1ab5f13796fd611e1813f98f554112c4c478956c6a0ebaceef3afae7ee71f279277df19e8e4543a -a95df7d52b535044a7c3cf3b95a03bafd4466bdb905f9b5f5290a6e5c2ac0f0e295136da2625df6161ab49abcdacb40f -8639fc0c48211135909d9e999459568dbdbbc7439933bab43d503e07e796a1f008930e8a8450e8346ab110ec558bcbb9 -a837bcc0524614af9e7b677532fabfb48a50d8bec662578ba22f72462caabda93c35750eed6d77b936636bf165c6f14e -97d51535c469c867666e0e0d9ed8c2472aa27916370e6c3de7d6b2351a022e2a5330de6d23c112880b0dc5a4e90f2438 -aadb093c06bd86bd450e3eb5aa20f542d450f9f62b4510e196f2659f2e3667b0fe026517c33e268af75a9c1b2bc45619 -860cef2e0310d1a49a9dd6bc18d1ca3841ed1121d96a4f51008799b6e99eb65f48838cd1e0c134f7358a3346332f3c73 -b11c4f9e7ef56db46636474a91d6416bcb4954e34b93abf509f8c3f790b98f04bd0853104ec4a1ff5401a66f27475fce -87cb52e90a96c5ee581dc8ab241e2fd5df976fe57cc08d9ffda3925a04398e7cffaf5a74c90a7319927f27c8a1f3cef5 -b03831449f658a418a27fd91da32024fdf2b904baf1ba3b17bbf9400eaddc16c3d09ad62cc18a92b780c10b0543c9013 -94e228af11cb38532e7256fa4a293a39ffa8f3920ed1c5ad6f39ce532e789bb262b354273af062add4ca04841f99d3aa -99eb3aeb61ec15f3719145cf80501f1336f357cc79fca6981ea14320faed1d04ebe0dbce91d710d25c4e4dc5b6461ebf -920a3c4b0d0fbe379a675e8938047ea3ec8d47b94430399b69dd4f46315ee44bd62089c9a25e7fa5a13a989612fe3d09 -b6414a9a9650100a4c0960c129fa67e765fe42489e50868dd94e315e68d5471e11bfbc86faffb90670e0bec6f4542869 -94b85e0b06580a85d45e57dae1cfd9d967d35bdfcd84169ef48b333c9321f2902278c2594c2e51fecd8dbcd221951e29 -b2c0a0dd75e04a85def2a886ee1fda51f530e33b56f3c2cf61d1605d40217aa549eef3361d05975d565519c6079cc2ac -abb0ea261116c3f395360d5ac731a7514a3c290f29346dc82bacb024d5455d61c442fefe99cc94dddcae47e30c0e031f -a32d95ae590baa7956497eddf4c56bff5dfdc08c5817168196c794516610fcc4dbcd82cf9061716d880e151b455b01e0 -8bd589fb6e3041f3ef9b8c50d29aed1a39e90719681f61b75a27489256a73c78c50c09dd9d994c83f0e75dfe40b4de84 -82d01cdaf949d2c7f4db7bfadbf47e80ff9d9374c91512b5a77762488308e013689416c684528a1b16423c6b48406baf -b23e20deb7e1bbbc328cbe6e11874d6bdbb675704a55af1039b630a2866b53d4b48419db834a89b31ebed2cfc41278dd -a371559d29262abd4b13df5a6a5c23adab5a483f9a33a8d043163fcb659263322ee94f872f55b67447b0a488f88672d6 -85b33ddf4a6472cacc0ed9b5ec75ed54b3157e73a2d88986c9afa8cb542e662a74797a9a4fec9111c67e5a81c54c82b3 -af1248bc47a6426c69011694f369dc0ec445f1810b3914a2ff7b830b69c7e4eaa4bafec8b10ed00b5372b0c78655a59b -94b261ed52d5637fd4c81187000bd0e5c5398ce25797b91c61b30d7b18d614ab9a2ca83d66a51faf4c3f98714e5b0ea5 -953d4571c1b83279f6c5958727aaf9285d8b8cbdbfbaff51527b4a8cfdd73d3439ba862cdb0e2356e74987ff66d2c4d9 -b765dae55d0651aca3b3eaef4ca477f0b0fda8d25c89dccd53a5573dd0c4be7faaadaa4e90029cdd7c09a76d4ce51b91 -b6d7b7c41556c85c3894d0d350510b512a0e22089d3d1dd240ad14c2c2b0ce1f003388100f3154ad80ec50892a033294 -a64561dc4b42289c2edf121f934bc6a6e283d7dce128a703f9a9555e0df7dda2825525dbd3679cd6ba7716de230a3142 -a46c574721e8be4a3b10d41c71057270cca42eec94ca2268ee4ab5426c7ce894efa9fa525623252a6a1b97bcf855a0a5 -a66d37f1999c9c6e071d2a961074c3d9fdcf9c94bf3e6c6ed82693095538dd445f45496e4c83b5333b9c8e0e64233adc -ab13814b227a0043e7d1ff6365360e292aca65d39602d8e0a574d22d25d99ccb94417c9b73095632ff302e3d9a09d067 -b2c445b69cff70d913143b722440d2564a05558d418c8ef847483b5196d7e581c094bae1dbb91c4499501cfa2c027759 -87cbde089962d5f093324b71e2976edbe6ad54fb8834dd6e73da9585b8935fca1c597b4d525949699fdfa79686721616 -a2c7e60966acb09c56cf9ad5bdcc820dcabf21ef7784970d10353048cf3b7df7790a40395561d1064e03109eaac0df98 -8ea7b8af208678178553946b2ee9e68c0e751b34f3652409a5e66c40d3aee3a40ba6ffe2175ce16c6a81b78ecc597d02 -960234239e1e3ea262e53d256ad41b2fe73f506b3d130732d0ee48819eb8a9c85bb5106a304874d8625afae682c34015 -858459694c4e8fdafa6cdaee1184e1305ca6e102222b99b8e283dd9bb3ebf80e55d6c4d8831a072b813c8eceb8124d95 -a30a8ce0f44aeb5590dc618c81c7cac441470ce79fd7881a8f2ea4ca5f9d848ebde762fcaee985cbd3d5990367403351 -a83867643672248b07d3705813b56489453e7bc546cdba570468152d9a1bd04f0656034e7d03736ea156fc97c88dc37f -a7bb52e0fc58b940dc47ea4d0a583012ee41fad285aba1a60a6c54fa32cfe819146888c5d63222c93f90de15745efb2b -8627bcc853bdeaad37f1d0f7d6b30ada9b481ccdf79b618803673de8a142e8a4ce3e7e16caed1170a7332119bcdc10a9 -8903d9dc3716b59e8e99e469bd9fde6f4bca857ce24f3a23db817012f1ea415c2b4656c7aeca31d810582bb3e1c08cc6 -875169863a325b16f892ad8a7385be94d35e398408138bd0a8468923c05123d53dba4ce0e572ea48fcdadd9bd9faa47a -b255b98d46d6cc44235e6ce794cc0c1d3bd074c51d58436a7796ce6dc0ae69f4edaa3771b35d3b8a2a9acd2f6736fab3 -9740c4d0ee40e79715a70890efda3455633ce3a715cbfc26a53e314ebbe61937b0346b4859df5b72eb20bcba96983870 -a44ce22ab5ddc23953b02ec187a0f419db134522306a9078e1e13d5bf45d536450d48016a5e1885a346997003d024db0 -90af81c08afdccd83a33f21d0dc0305898347f8bd77cc29385b9de9d2408434857044aec3b74cb72585338c122e83bb4 -80e162a7656c9ae38efa91ae93e5bd6cb903f921f9f50874694b9a9e0e2d2595411963d0e3f0c2d536b86f83b6e4d6ef -8b49fa6babe47291f9d290df35e94e83be1946784b9c7867efd8bc97a12be453013939667164b24aeb53d8950288a442 -a1df6435d718915df3da6dda61da1532a86e196dc7632703508679630f5f14d4cb44ce89eff489d7ff3fe599cc193940 -afd44c143dbb94c71acc2a309c9c88b8847ef45d98479fccce9920db9b268e8e36f8db9f02ff4ee3cff01e548f719627 -b2cf33d65d205e944b691292c2d9b0b124c9de546076dd80630742989f1ffd07102813c64d69ba2a902a928a08bce801 -b9f295e9f9eca432b2d5c77d6316186027caca40a6d6713f41356497a507b6e8716fb471faf973aaa4e856983183c269 -b3bd50c4b034473edce4b9be1171376a522899cb0c1a1ae7dc22dd2b52d20537cf4129797235084648ac4a3afc1fa854 -8ef37683d7ca37c950ba4df72564888bedaf681931d942d0ea88ead5cc90f4cbef07985a3c55686a225f76f7d90e137d -82107855b330bc9d644129cebecf2efbfab90f81792c3928279f110250e727ce12790fd5117501c895057fa76a484fc0 -816a5474c3b545fb0b58d3118cc3088a6d83aad790dbf93025ad8b94a2659cceba4fa6a6b994cb66603cc9aef683a5e3 -8f633f9b31f3bb9b0b01ea1a8830f897ecd79c28f257a6417af6a5f64e6c78b66c586cf8d26586830bd007fb6279cd35 -acb69d55a732b51693d4b11f7d14d21258d3a3af0936385a7ce61e9d7028a8fe0dd902bda09b33fb728bc8a1bc542035 -8d099582ac1f46768c17bf5a39c13015cfe145958d7fc6ddfd2876ad3b1a55a383fbe940e797db2b2b3dc8a232f545dc -97a4dd488b70bf772348ececaca4cf87bc2875d3846f29fe6ef01190c5b030219b9e4f8137d49ea0cc50ca418024c488 -b4d81148f93fa8ec0656bbfb5f9d96bbf5879fa533004a960faac9fd9f0fe541481935fdf1f9b5dd08dff38469ef81c5 -8e9b2ae4fc57b817f9465610a77966caaff013229018f6c90fa695bd734cb713b78a345b2e9254b1aff87df58c1cd512 -99eb7126e347c636e9a906e6bfdc7c8ca0c1d08580c08e6609889a5d515848c7ca0f32ab3a90c0e346f976a7883611f7 -8ca87944aa3e398492b268bda0d97917f598bc0b28584aa629dfec1c3f5729d2874db422727d82219880577267641baa -88ab0e290dc9a6878d6b4e98891ff6bfc090e8f621d966493fcbe1336cc6848fcbb958d15abcfa77091d337da4e70e74 -8956a2e1dc3ec5eb21f4f93a5e8f0600a06e409bb5ec54e062a1290dff9ce339b53fbbfc4d42b4eed21accea07b724d6 -8d22220da9dc477af2bddb85c7073c742c4d43b7afee4761eba9346cadbcd522106ed8294281a7ef2e69883c28da0685 -90dafd9a96db7e1d6bde424245305c94251d5d07e682198ae129cd77bd2907a86d34722cbde06683cc2ca67cebe54033 -b5202e62cf8ea8e145b12394bd52fd09bda9145a5f78285b52fda4628c4e2ccfc2c208ecde4951bd0a59ac03fa8bc202 -8959856793ba4acf680fb36438c9722da74d835a9fe25a08cf9e32d7800c890a8299c7d350141d2e6b9feceb2ebb636f -ab0aa23c1cd2d095825a3456861871d298043b615ae03fcd9283f388f0deef3cc76899e7fde15899e3edf362b4b4657f -9603b333cc48fe39bea8d9824cfee6ac6c4e21668c162c196ecd1ff08ef4052ace96a785c36b8f7906fdcb6bc8802ddd -93bfecbc3c7cc03c563240e109850a74948f9fa078eb903b322368cda0b50888663a17953579578ba060b14dbf053024 -b01f843b808cf7939a474de155a45462e159eb5044f00c6d77e0f7ec812720a3153209e971a971ccbf5ebee76ec4074f -b009e0567c3c75ed767247d06fa39049a4d95df3392d35a9808cb114accf934e78f765cd18a2290efef016f1918c7aeb -ad35631df8331da3a12f059813dfa343d831225a392f9c7e641c7d23a6c1ad8df8e021201c9f6afb27c1575948d6bf68 -a89c2a631d84128471c8ef3d24b6c35c97b4b9b5dad905c1a092fb9396ae0370e215a82308e13e90e7bb6ebcc455eb2a -b59c7f5fbfeb02f8f69e6cedef7ff104982551f842c890a14834f5e834b32de1148cf4b414a11809d53dd3f002b15d6a -aa6f267305b55fede2f3547bc751ba844ce189d0b4852022712b0aee474de54a257d4abcd95efe7854e33a912c774eba -afddd668f30cce70904577f49071432c49386ec27389f30a8223b5273b37e6de9db243aceb461a7dc8f1f231517463a9 -b902a09da9157b3efa1d98f644371904397019d0c84915880628a646a3ad464a9d130fdc651315098179e11da643ad2e -b05f31957364b016c6f299ae4c62eede54cab8ea3871d49534828c8bdc6adbc6a04a708df268f50107d81d1384d983ae -b4c3f7284802e614ddf1f51640f29e7139aae891467d5f62778310372071793e56fbd770837b97d501191edd0da06572 -b4eddb7c3775fb14fac7f63bb73b3cde0efa2f9a3b70e6a65d200765f6c4b466d3d76fcd4d329baee88e2aba183b8e69 -a83e7dbae5a279f0cfd1c94e9849c58a3d4cecc6d6d44bb9b17508576ca347fca52c2c81371d946b11a09d4ed76ec846 -8018ea17e2381c0233867670f9e04c8a47ace1207fdcf72dce61b6c280ba42d0a65f4b4e0b1070cc19c7bb00734974d9 -af90b541dfed22e181ff3ef4cf11f5e385fd215c1e99d988e4d247bc9dcee9f04f2182b961797c0bcc5f2aaa05c901a9 -a37046e44cf35944e8b66df80c985b8a1aa7004a2fd0b81ac251638977d2ff1465f23f93ac0ce56296f88fdc591bbdd7 -a735bd94d3be9d41fcd764ec0d8d7e732c9fc5038463f7728fd9d59321277e2c73a45990223bd571dab831545d46e7aa -94b32dcb86f5d7e83d70a5b48fe42c50f419be2f848f2d3d32ee78bf4181ab18077a7666eedb08607eece4de90f51a46 -a7f0804cafbf513293485afc1b53117f0cbfaea10919e96d9e4eb06f0c96535e87065d93f3def1bbc42044dbb00eb523 -aaaad1166d7f19f08583dd713275a71a856ab89312f84ca8078957664924bb31994b5c9a1210d0c41b085be4058ed52e -a1757aac9f64f953e68e680985a8d97c5aac8688b7d90f4db860166dd3d6119e8fca7d700a9530a2b9ba3932c5e74e33 -98cada5db4a1430c272bfc1065fb685872e664ed200d84060ee9f797d0a00864f23943e0fb84ba122a961996a73dfb14 -a5e609f716dc7729d1247f40f9368a2e4a15067e1dd6a231fece85eeefb7e7d4a5ac8918fb376debd79d95088750b2ca -b5365eb8caab8b1118619a626ff18ce6b2e717763f04f6fa8158cdca530c5779204efa440d088083f1a3685454aa0555 -a6e01b8da5f008b3d09e51a5375d3c87c1da82dff337a212223e4d0cdb2d02576d59f4eef0652d6b5f2fc806d8c8149c -ae310f613d81477d413d19084f117248ad756572c22a85b9e4c86b432e6c602c4a6db5edf2976e11f7353743d679e82a -a1f219c0b8e8bb8a9df2c6c030acbb9bbfa17ba3db0366f547da925a6abb74e1d7eb852bd5a34bae6ac61d033c37e9dc -a2087fa121c0cdd5ea495e911b4bc0e29f1d5c725aadfb497d84434d2291c350cdaa3dc8c85285f65a7d91b163789b7a -929c63c266da73d726435fa89d47041cfe39d4efa0edce7fc6eca43638740fbc82532fd44d24c7e7dd3a208536025027 -91c1051dcc5f52ad89720a368dddd2621f470e184e746f5985908ba34e1d3e8078a32e47ab7132be780bea5277afecb0 -ae089b90ba99894d5a21016b1ea0b72a6e303d87e59fb0223f12e4bb92262e4d7e64bfdbdb71055d23344bc76e7794b2 -8b69aa29a6970f9e66243494223bad07ac8f7a12845f60c19b1963e55a337171a67bdc27622153016fce9828473a3056 -95ca6b08680f951f6f05fd0d180d5805d25caf7e5bda21c218c1344e661d0c723a4dfc2493642be153793c1b3b2caaa4 -a4789dc0f2a07c794dab7708510d3c893d82ddbd1d7e7e4bbbeca7684d9e6f4520fb019b923a06c7efab0735f94aa471 -93c4f57a3cf75085f5656b08040f4cd49c40f1aab6384a1def4c5c48a9fe4c03514f8e61aabe2cfa399ff1ccac06f869 -b6c37f92c76a96b852cd41445aa46a9c371836dd40176cc92d06666f767695d2284a2780fdfd5efc34cf6b18bcfb5430 -9113e4575e4b363479daa7203be662c13d7de2debcda1c142137228aeead2c1c9bc2d06d93a226302fa63cc75b7353ec -b70addeb5b842ac78c70272137f6a1cef6b1d3a551d3dd906d9a0e023c8f49f9b6a13029010f3309d0b4c8623a329faf -b976a5132b7eb42d5b759c2d06f87927ef66ecd6c94b1a08e4c9e02a4ce7feca3ac91f9479daa1f18da3d4a168c2ba77 -8fdab795af64b16a7ddf3fad11ab7a85d10f4057cf7716784184960013baa54e7ba2050b0e036dc978ff8c9a25dc5832 -b2c982ad13be67d5cdc1b8fac555d4d1ec5d25f84e58b0553a9836f8f9e1c37582d69ad52c086a880a08b4efcccd552e -810661d9075ae6942735215f2ab46d60763412e1f6334e4e00564b6e5f479fc48cf37225512abbccf249c0ca225fc935 -a0c4bf00a20f19feff4004004f08231b4c6c86ac4ed57921eea28d7dea32034f3f4ab5b7ded7184f6c7ffbf5847232ad -b2bb5a9eea80bf067f3686a488529d9c2abd63fc9e1d4d921b1247ef86d40cd99e0a8b74f750e85c962af84e84e163a6 -887ee493c96d50f619ba190ce23acddc5f31913e7a8f1895e6339d03794ecefd29da5f177d1d25bc8df8337ae963fc7b -b7966fb07029d040f2228efa2cfcd04341e4666c4cf0b653e6e5708631aa2dd0e8c2ac1a62b50c5a1219a2737b82f4f7 -92234cfd6b07f210b82db868f585953aafbcbc9b07b02ded73ff57295104c6f44a16e2775ca7d7d8ee79babb20160626 -8d3cd7f09c6fd1072bc326ff329e19d856e552ac2a9f20274bc9752527cd3274142aa2e32b65f285fb84bc3adaaea3cc -8caed1cb90d8cd61e7f66edc132672172f4fa315e594273bb0a7f58a75c30647ec7d52eda0394c86e6477fbc352f4fe8 -ae192194b09e9e17f35d8537f947b56f905766c31224e41c632c11cd73764d22496827859c72f4c1ab5fd73e26175a5d -8b7be56aac76d053969e46882d80a254e89f55c5ab434883cbafc634a2c882375898074a57bc24be3c7b2c56401a7842 -98bc4a7a9b05ba19f6b85f3ee82b08bed0640fd7d24d4542eb7a7f7fde443e880bdb6f5499bd8cb64e1ddd7c5f529b19 -a5a41eaa5e9c1d52b00d64ab72bc9def6b9d41972d80703e9bfe080199d4e476e8833a51079c6b0155b78c3ab195a2a7 -a0823f6f66465fd9be3769c164183f8470c74e56af617f8afd99b742909d1a51f2e0f96a84397597afbd8eeaabb51996 -801da41d47207bdd280cc4c4c9753a0f0e9d655e09e0be5f89aeed4ce875a904f3da952464399bf8efc2398940d5fba2 -a719314085fd8c9beac4706c24875833d59a9a59b55bca5da339037c0a5fc03df46dbecb2b4efcfed67830942e3c4ea1 -a75dde0a56070bb7e9237b144ea79f578d413a1cbbd1821cee04f14f533638b24f46d88a7001e92831843b37ed7a709f -a6b4ef8847a4b980146e1849e1d8ab38695635e0394ca074589f900ce41fa1bb255938dc5f37027523bac6a291779bef -b26d84dfd0b7bd60bcfdbea667350462a93dca8ff5a53d6fc226214dcb765fada0f39e446a1a87f18e4e4f4a7133155f -ae7bd66cc0b72f14ac631ff329a5ca4958a80ba7597d6da049b4eb16ac3decde919ca5f6f9083e6e541b303fb336dc2f -a69306e6bfbbc10de0621cffb13c586e2fcfd1a80935e07c746c95651289aec99066126a6c33cb8eb93e87d843fc631f -a47e4815585865218d73c68ba47139568ea7ae23bfa863cb914a68454242dd79beaec760616b48eea74ceab6df2298dd -b2da3cfb07d0721cd226c9513e5f3ace98ed2bc0b198f6626b8d8582268e441fa839f5834f650e2db797655ca2afa013 -b615d0819554f1a301a704d3fc4742bd259d04ad75d50bccee3a949b6226655f7d623301703506253cca464208a56232 -85e06ed5797207f0e7ae85909e31776eb9dae8af2ec39cc7f6a42843d94ea1de8be2a3cdadfcbe779da59394d4ffeb45 -8c3529475b5fdbc636ee21d763f5ec11b8cb040a592116fb609f8e89ca9f032b4fa158dd6e9ceab9aceb28e067419544 -accddb9c341f32be82b6fa2ef258802c9ae77cd8085c16ec6a5a83db4ab88255231b73a0e100c75b7369a330bfc82e78 -93b8e4c6e7480948fa17444b59545a5b28538b8484a75ad6bc6044a1d2dbd76e7c44970757ca53188d951dc7347d6a37 -90111721d68b29209f4dc4cfb2f75ab31d15c55701922e50a5d786fb01707ab53fcec08567cd366362c898df2d6e0e93 -b60a349767df04bd15881c60be2e5cc5864d00075150d0be3ef8f6b778715bebca8be3be2aa9dbdc49f1a485aeb76cda -b8d5a967fdd3a9bcf89a774077db39ef72ca9316242f3e5f2a350202102d494b2952e4c22badecd56b72ba1eea25e64b -8499ebd860f31f44167183b29574447b37a7ee11efcc9e086d56e107b826b64646b1454f40f748ccac93883918c89a91 -99c35e529782db30f7ccab7f31c225858cf2393571690b229ece838ec421a628f678854a1ddbd83fa57103ccebd92c7f -99817660d8b00cbe03ec363bcdc5a77885586c9e8da9e01a862aca0fc69bf900c09b4e929171bc6681681eae10450541 -8055e130964c3c2ebd980d3dc327a40a416bcdbf29f480480a89a087677a1fb51c823b57392c1db72f4093597100b8d3 -877eaddef845215f8e6f9ed24060c87e3ab6b1b8fbb8037d1a57e6a1e8ed34d00e64abb98d4bf75edb5c9788cbdccbef -b5432bbff60aeae47f2438b68b123196dfb4a65cc875b8e080501a4a44f834b739e121bec58d39ac36f908881e4aa8ab -b3c3f859b7d03ff269228c0f9a023b12e1231c73aba71ad1e6d86700b92adc28dfa3757c052bbc0ba2a1d11b7fda4643 -ab8a29f7519a465f394ef4a5b3d4924d5419ca1489e4c89455b66a63ac430c8c9d121d9d2e2ed8aa1964e02cd4ebac8c -866ae1f5c2a6e159f2e9106221402d84c059f40d166fab355d970773189241cd5ee996540d7c6fc4faf6f7bcff967dce -973a63939e8f1142a82b95e699853c1e78d6e05536782b9bb178c799b884f1bc60177163a79a9d200b5ff4628beeb9e7 -a5fc84798d3e2d7632e91673e89e968f5a67b7c8bb557ea467650d6e05e7fe370e18d9f2bdd44c244978295cf312dc27 -b328fe036bcd0645b0e6a15e79d1dd8a4e2eda128401a4e0a213d9f92d07c88201416fc76193bb5b1fe4cb4203bab194 -99239606b3725695a570ae9b6fb0fb0a34ad2f468460031cfa87aa09a0d555ff606ff204be42c1596c4b3b9e124b8bd6 -af3432337ca9d6cce3574e23e5b7e4aa8eda11d306dc612918e970cc7e5c756836605a3391f090a630bac0e2c6c42e61 -8a545b3cb962ce5f494f2de3301de99286c4d551eaa93a9a1d6fef86647321834c95bf754c62ec6c77116a21494f380d -8f9b8ea4c25469c93556f1d91be583a5f0531ac828449b793ba03c0a841c9c73f251f49dd05cbb415f5d26e6f6802c99 -a87199e33628eeffd3aff114e81f53dd54fba61ba9a9a4d7efdbff64503f25bc418969ab76ef1cf9016dd344d556bb29 -a2fda05a566480602274d7ffcaefdd9e94171286e307581142974f57e1db1fa21c30be9e3c1ac4c9f2b167f92e7c7768 -a6235d6a23304b5c797efb2b476ed02cb0f93b6021a719ae5389eb1e1d032944ae4d69aec2f29fcd6cbc71a6d789a3ba -a7f4a73215f7e99e2182c6157dd0f22e71b288e696a8cff2450689a3998f540cfb82f16b143e90add01b386cb60d8a33 -922d8f9cd55423f5f6a60d26de2f8a396ac4070a6e2dc956e50c2a911906aa364d4718aea29c5b61c12603534e331e7e -96d7fdf5465f028fc28f21fbfe14c2db2061197baf26849e6a0989a4ea7d5e09ab49a15ba43a5377b9354d01e30ce860 -8f94c4255a0fc1bd0fa60e8178c17f2a8e927cac7941c5547d2f8f539e7c6ed0653cab07e9fb1f2c56cdd03bb876512a -95984c10a2917bfa6647ebce69bf5252d9e72d9d15921f79b2c6d7c15ee61342b4fb8a6d34838e07132b904f024ded04 -93e65e765a574277d3a4d1d08ca2f2ff46e9921a7806ca8ca3d8055f22d6507744a649db7c78117d9168a1cbdb3bbc61 -8d453b7364662dc6f36faf099aa7cbbe61151d79da7e432deba7c3ed8775cfe51eaf1ba7789779713829dde6828e189a -acffa3ee6c75160286090162df0a32a123afb1f9b21e17fd8b808c2c4d51a4270cab18fba06c91ef9d22e98a8dc26cdd -a5597cc458186efa1b3545a3926f6ecaaa6664784190e50eed1feac8de56631bee645c3bac1589fa9d0e85feb2be79d4 -87ba9a898df9dfa7dabc4ab7b28450e4daf6013340e329408d1a305de959415ab7315251bad40511f917dfc43974e5f0 -a598778cf01d6eef2c6aabc2678e1b5194ee8a284ebd18a2a51a3c28a64110d5117bcbf68869147934e600572a9e4c8a -84c69a4ad95861d48709f93ade5ac3800f811b177feb852ebcd056e35f5af5201f1d8a34ab318da8fe214812d0a7d964 -9638a237e4aed623d80980d91eda45e24ebf48c57a25e389c57bd5f62fa6ffa7ca3fb7ae9887faf46d3e1288af2c153b -800f975721a942a4b259d913f25404d5b7b4c5bf14d1d7e30eee106a49cb833b92058dab851a32ee41faf4ef9cb0dea4 -b9127a34a59fed9b5b56b6d912a29b0c7d3cb9581afc9bd174fc308b86fdb076f7d436f2abc8f61cef04c4e80cd47f59 -8004eda83f3263a1ccfc8617bc4f76305325c405160fb4f8efeff0662d605e98ba2510155c74840b6fe4323704e903c4 -aa857b771660d6799ff03ccad1ab8479e7f585a1624260418fc66dc3e2b8730cfa491d9e249505141103f9c52f935463 -98b21083942400f34cde9adbe1977dee45ba52743dc54d99404ad9da5d48691ddea4946f08470a2faad347e9535690c7 -a4b766b2faec600a6305d9b2f7317b46f425442da0dc407321fc5a63d4571c26336d2bccedf61097f0172ec90fb01f5f -b9736619578276f43583de1e4ed8632322ea8a351f3e1506c5977b5031d1c8ad0646fb464010e97c4ddb30499ddc3fb0 -973444ffaff75f84c17f9a4f294a13affd10e2bceed6b4b327e4a32c07595ff891b887a9f1af34d19766d8e6cb42bfd1 -b09ce4964278eff81a976fbc552488cb84fc4a102f004c87179cb912f49904d1e785ecaf5d184522a58e9035875440ef -b80c2aa3d0e52b4d8b02c0b706e54b70c3dbca80e5e5c6a354976721166ea0ca9f59c490b3e74272ef669179f53cb50d -8e52fa5096ff960c0d7da1aa4bce80e89527cdc3883eba0c21cb9a531088b9d027aa22e210d58cf7cbc82f1ec71eb44f -969f85db95f455b03114e4d3dc1f62a58996d19036513e56bee795d57bf4ed18da555722cd77a4f6e6c1a8e5efe2f5d7 -ab84b29b04a117e53caea394a9b452338364c45a0c4444e72c44132a71820b96a6754828e7c8b52282ad8dca612d7b6a -83e97e9ab3d9e453a139c9e856392f4cef3ec1c43bce0a879b49b27a0ce16f9c69063fd8e0debbe8fabafc0621bc200c -8c138ebdf3914a50be41be8aa8e2530088fb38af087fa5e873b58b4df8e8fd560e8090c7a337a5e36ef65566409ad8f3 -a56da9db2f053516a2141c1a8ed368ae278ab33a572122450249056857376d1dffc76d1b34daf89c86b6fe1ead812a0c -a3233ea249f07531f5bc6e94e08cea085fd2b2765636d75ff5851f224f41a63085510db26f3419b031eb6b5143735914 -b034bb6767ce818371c719b84066d3583087979ba405d8fbb2090b824633241e1c001b0cb0a7856b1af7a70e9a7b397e -8722803fe88877d14a4716e59b070dd2c5956bb66b7038f6b331b650e0c31230c8639c0d87ddc3c21efc005d74a4b5cc -8afe664cb202aacf3bd4810ebf820c2179c11c997f8c396692a93656aa249a0df01207c680157e851a30330a73e386b9 -a999e86319395351d2b73ff3820f49c6516285e459224f82174df57deb3c4d11822fd92cbbed4fc5a0a977d01d241b19 -9619408e1b58b6610d746b058d7b336d178e850065ba73906e08e748651e852f5e3aab17dcadcb47cc21ff61d1f02fcf -947cf9c2ed3417cd53ea498d3f8ae891efe1f1b5cd777e64cec05aba3d97526b8322b4558749f2d8a8f17836fb6e07aa -aec2fdae2009fda6852decb6f2ff24e4f8d8ca67c59f92f4b0cf7184be72602f23753ed781cf04495c3c72c5d1056ffe -8dba3d8c09df49fbfc9506f7a71579348c51c6024430121d1c181cad7c9f7e5e9313c1d151d46d4aa85fb0f68dd45573 -b6334cb2580ae33720ebf91bb616294532a1d1640568745dcda756a3a096786e004c6375728a9c2c0fb320441e7d297a -9429224c1205d5ecd115c052b701c84c390f4e3915275bb8ce6504e08c2e9b4dd67b764dd2ea99f317b4c714f345b6ff -abe421db293f0e425cfd1b806686bdfd8fdbac67a33f4490a2dc601e0ddbf69899aa9a119360dad75de78c8c688ca08b -95c78bffed9ae3fff0f12754e2bd66eb6a9b6d66a9b7faaeb7a1c112015347374c9fe6ce14bf588f8b06a78e9a98f44c -ac08f8b96b52c77d6b48999a32b337c5ad377adf197cda18dbdf6e2a50260b4ee23ca6b983f95e33f639363e11229ee4 -911a0e85815b3b9f3ba417da064f760e84af94712184faeb9957ddd2991dee71c3f17e82a1a8fbeec192b0d73f0ebce7 -aa640bd5cb9f050568a0ad37168f53b2f2b13a91e12b6980ca47ae40289cf14b5b89ddd0b4ca452ce9b1629da0ce4b5d -907486f31b4ecea0125c1827007ea0ecb1c55cadb638e65adc9810ca331e82bb2fd87e3064045f8d2c5d93dc6c2f5368 -8cbfaf4ce0bbbf89208c980ff8b7bc8f3cfef90f0fe910f463cb1c0f8e17cce18db120142d267045a00ba6b5368f0dd3 -9286f08f4e315df470d4759dec6c9f8eacef345fc0c0b533ad487bb6cfefa8c6c3821a22265c9e77d34170e0bc0d078b -94a3c088bc1a7301579a092b8ece2cefc9633671bc941904488115cd5cb01bd0e1d2deef7bdccb44553fd123201a7a53 -8f3d0114fbf85e4828f34abb6d6fddfa12789d7029d9f1bb5e28bc161c37509afdab16c32c90ec346bc6a64a0b75726f -a8ed2d774414e590ec49cb9a3a726fafd674e9595dd8a1678484f2897d6ea0eea1a2ee8525afac097b1f35e5f8b16077 -9878789ff33b11527355a317343f34f70c7c1aa9dc1eca16ca4a21e2e15960be8a050ec616ffb97c76d756ce4bce2e90 -854e47719dae1fe5673cacf583935122139cf71a1e7936cf23e4384fbf546d48e9a7f6b65c3b7bf60028e5aa1234ba85 -af74bdda2c6772fe9a02d1b95e437787effad834c91c8174720cc6e2ea1f1f6c32a9d73094fc494c0d03eef60b1a0f05 -80a3e22139029b8be32cb167d3bc9e62d16ca446a588b644e53b5846d9d8b7ab1ad921057d99179e41515df22470fb26 -86c393afd9bd3c7f42008bba5fe433ec66c790ebd7aa15d4aeaf9bb39a42af3cfaf8c677f3580932bbd7ada47f406c8c -90433c95c9bb86a2c2ddcf10adccb521532ebd93db9e072671a4220f00df014e20cd9ce70c4397567a439b24893808dc -95b2c170f08c51d187270ddc4f619300b5f079bbc89dbca0656eae23eecc6339bf27fa5bf5fd0f5565d4021105e967d2 -8e5eced897e2535199951d4cff8383be81703bca3818837333dd41a130aa8760156af60426ceadb436f5dea32af2814c -a254a460ebefbe91d6e32394e1c8f9075f3e7a2bb078430ac6922ab14d795b7f2df1397cb8062e667d809b506b0e28d4 -ac2062e8ca7b1c6afb68af0ebab31aebd56fc0a0f949ef4ea3e36baf148681619b7a908facf962441905782d26ecbdb5 -8b96af45b283b3d7ffeec0a7585fc6b077ea5fd9e208e18e9f8997221b303ab0ce3b5bafa516666591f412109ce71aa5 -afd73baada5a27e4fa3659f70083bf728d4dc5c882540638f85ea53bf2b1a45ddf50abc2458c79f91fb36d13998c7604 -a5d2fff226e80cb2e9f456099812293333d6be31dd1899546e3ad0cd72b2a8bcb45ec5986e20faa77c2564b93983210c -a8c9b8de303328fbdaccf60f4de439cf28f5360cf4104581dc2d126bc2e706f49b7281723487ff0eaf92b4cc684bc167 -a5d0d5849102bf1451f40e8261cb71fc57a49e032773cb6cd7b137f71ee32438d9e958077ffafce080a116ccc788a2d4 -80716596f502d1c727d5d2f1469ce35f15e2dbd048d2713aa4975ee757d09c38d20665326bd63303cfe7e820b6de393d -97baf29b20f3719323cc1d5de23eaa4899dc4f4e58f6c356ec4c3ad3896a89317c612d74e0d3ab623fe73370c5972e2f -b58bdc9aa5061bf6e5add99a7443d7a8c7ba8f6875b8667d1acbe96fc3ecafbdcc2b4010cb6970a3b849fff84660e588 -b6be68728776d30c8541d743b05a9affc191ad64918fdbd991d2ddd4b32b975c4d3377f9242defef3805c0bfb80fbac7 -b0cddace33333b8a358acad84b9c83382f0569d3854b4b34450fd6f757d63c5bdab090e330b0f86e578f22c934d09c36 -854bd205d6051b87f9914c8c2494075d7620e3d61421cc80f06b13cea64fd1e16c62c01f107a5987d10b8a95a8416ad9 -80351254a353132300ba73a3d23a966f4d10ce9bf6eae82aedb6cdc30d71f9d08a9dd73cb6441e02a7b2ad93ad43159c -937aae24fb1b636929453fc308f23326b74c810f5755d9a0290652c9c2932ad52cc272b1c83bd3d758ef7da257897eae -b84d51ef758058d5694ffeac6d8ce70cef8d680a7902f867269c33717f55dd2e57b25347841d3c0872ae5f0d64f64281 -a4b31bb7c878d5585193535b51f04135108134eff860f4eac941053155f053d8f85ff47f16268a986b2853480a6e75e6 -93543f0828835186a4af1c27bdf97b5dd72b6dfa91b4bf5e759ff5327eaf93b0cb55d9797149e465a6b842c02635ffe5 -afdac9e07652bf1668183664f1dd6818ef5109ee9b91827b3d7d5970f6a03e716adcc191e3e78b0c474442a18ad3fc65 -9314077b965aa2977636ae914d4a2d3ce192641a976ffa1624c116828668edbfbe5a09e3a81cb3eed0694566c62a9757 -b395ddcf5082de6e3536825a1c352802c557b3a5118b25c29f4c4e3565ecaaf4bdd543a3794d05156f91fc4ceadc0a11 -b71f774aad394c36609b8730e5be244aaebfff22e0e849acc7ee9d33bedc3ec2e787e0b8b2ffe535560fcd9e15a0897e -92e9409fa430f943a49bce3371b35ac2efb5bc09c88f70ff7120f5e7da3258a4387dfc45c8b127f2ef2668679aeb314e -8ef55bef7b71952f05e20864b10f62be45c46e2dca0ef880a092d11069b8a4aa05f2e0251726aca1d5933d7dea98f3f8 -aad3fba9e09fae885cdeef45dfafa901419f5156fb673818f92a4acc59d0e2e9870b025e711de590a63fd481164f3aa8 -b444d52af545dd3a2d3dd94e6613816b154afea0c42b96468aceb0c721395de89e53e81a25db857ca2e692dcb24ba971 -88b279fe173007e64fe58f2c4adba68a1f538dbd3d32d175aa0d026bbb05b72a0c9f5d02b8201a94adb75fe01f6aa8b2 -88494cea4260741c198640a079e584cabfea9fcfb8bcf2520c9becd2419cde469b79021e5578a00d0f7dbc25844d2683 -94f3cce58837c76584b26426b9abdb45f05fee34dd9e5914b6eae08e78b7262ed51c4317031dab1ad716f28b287f9fc2 -b8c7ed564f54df01c0fbd5a0c741beed8183ce0d7842dc3a862a1b335de518810077314aa9d6054bb939663362f496da -81c153320d85210394d48340619d5eb41304daea65e927266f0262c8a7598321aba82ad6c3f78e5104db2afd2823baca -ab6695a8d48a179e9cd32f205608359cf8f6a9aead016252a35b74287836aa395e76572f21a3839bec6a244aa49573e5 -920ed571539b3002a9cd358095b8360400e7304e9a0717cc8c85ab4a0514a8ad3b9bf5c30cb997647066f93a7e683da9 -a7ec7c194d1e5103bc976e072bf1732d9cb995984d9a8c70a8ee55ce23007f21b8549ad693f118aa974f693ed6da0291 -87a042d6e40c2951a68afc3ccf9646baf031286377f37f6ac47e37a0ec04d5ac69043757d7dff7959e7cd57742017a8d -b9f054dd8117dd41b6e5b9d3af32ee4a9eebef8e4a5c6daa9b99c30a9024eabeae850ab90dbdb188ca32fd31fd071445 -a8386da875799a84dc519af010eaf47cdbc4a511fe7e0808da844a95a3569ce94054efd32a4d3a371f6aba72c5993902 -8b3343a7cf4ffb261d5f2dbd217fb43590e00feac82510bdf73b34595b10ee51acae878a09efebc5a597465777ef4c05 -8312a5f1ea4f9e93578e0f50169286e97884a5ed17f1780275ab2b36f0a8aa1ab2e45c1de4c8bce87e99e3896af1fa45 -b461198cb7572ac04c484a9454954e157bdd4db457816698b7290f93a10268d75a7e1211e757c6190df6144bbb605d91 -9139764a099580d6f1d462c8bf7d339c537167be92c780e76acb6e638f94d3c54b40ed0892843f6532366861e85a515a -8bb70acb3c9e041b4fc20e92ba0f3f28f0d5c677bcb017af26f9171e07d28c3c0729bef72457231e3512f909455a13a2 -93301a18e5064c55fcfe8e860fab72da1b89a824ca77c8932023b7c79e4a51df93a89665d308a8d3aa145e46ebe6a0ad -ae3bca496fbd70ce44f916e2db875b2ce2e1ded84edd2cebc0503bdfdec40ec30e1d9afb4eb58c8fa23f7b44e71d88f8 -93cb3a918c95c5d973c0cb7621b66081ed81fba109b09a5e71e81ca01ec6a8bb5657410fdec453585309ef5bf10d6263 -95a50b9b85bb0fc8ff6d5f800d683f0f645e7c2404f7f63228a15b95ce85a1f8100e2e56c0acee19c36ed3346f190e87 -816cc4d9337461caca888809b746ab3713054f5b0eac823b795a1a9de9417c58e32a9f020fef807908fa530cbf35dee8 -a9c2890c2dd0d5d7aedc4cca7f92764086c50f92f0efd2642c59920d807086031bfe2d3ba574318db236c61a8f5f69c2 -ad0d5c8c80bddfe14bdaf507da96dc01dc9941aecc8ad3b64513d0a00d67c3f4b4659defb6839b8b18d8775e5344c107 -9047c9fad6ef452e0219e58e52c686b620e2eb769571021e3524bd7eac504f03b84834b16b849d42b3d75c601fd36bb7 -a04dd988fed91fb09cb747a3ac84efe639d7d355524cd7dee5477ecbcdec44d8ac1cec2c181755dcfdb77e9594fb3c5b -b0ea0c725debd1cec496ced9ce48f456f19af36e8b027094bf38fa37de9b9b2d10282363ea211a93a34a0a5387cace5d -b5fc46e2bb3e4653ea5e6884dcb3c14e401a6005685ee5a3983644b5b92300b7066289159923118df4332aac52045b8c -841fc5b26b23226e725e29802da86b35e4f5e3babc8b394f74e30fd5dec6d3840b19a9a096625ce79a4f1edae6369700 -8fd2bbbeea452451def3659bbe0ceb396120ebe8f81eee1ea848691614422c81d7c3e6a7a38032b4120b25c5ffa8f0c2 -9131ce3d25c3d418f50c0ab99e229d4190027ee162b8ba7c6670420ea821831dec1294ac00d66c50fac61c275a9e2c71 -99ec6eafe0eb869d128158cee97b984fb589e1af07699247946e4a85db772289dff3084d224a6f208005c342f32bbd73 -ac100fbbe7c2bf00cc56fcd5aa1f27181f82c150c53bbb1e15d2c18a51ed13dcfa7bccab85821b8ddddf493603e38809 -affd73a458d70c0d9d221e0c2da4348fed731f6b34c0b3e2d5711ba432e85a1ec92e40b83b246a9031b61f5bc824be47 -8ed30ed817816a817e9e07374ef1f94405a7e22dd0096aeaae54504382fc50e7d07b4f1186c1792fc25ea442cd7edc6b -a52370cfe99a35fa1405aeca9f922ad8d31905e41f390e514ea8d22ee66469637d6c2d4d3a7ee350d59af019ae5a10a4 -8d0b439741c57b82c8e4b994cf3956b5aeaee048b17e0a1edb98253a8d7256f436d8b2f36b7e12504132dbf91f3376b1 -8caac7e1a4486c35109cff63557a0f77d0e4ca94de0817e100678098a72b3787a1c5afc7244991cebcd1f468e18d91d4 -a729a8e64b7405db5ebfb478bb83b51741569331b88de80680e9e283cc8299ba0de07fcf252127750f507e273dc4c576 -a30545a050dad030db5583c768a6e593a7d832145b669ad6c01235813da749d38094a46ac3b965700230b8deacd91f82 -9207e059a9d696c46fa95bd0925983cd8e42aefd6b3fb9d5f05420a413cbc9e7c91213648554228f76f2dd757bde0492 -a83fa862ae3a8d98c1e854a8b17181c1025f4f445fbc3af265dc99e44bbd74cfa5cc25497fb63ee9a7e1f4a624c3202c -84cdfc490343b3f26b5ad9e1d4dcf2a2d373e05eb9e9c36b6b7b5de1ce29fda51383761a47dbd96deca593a441ccb28e -881a1aa0c60bb0284a58b0a44d3f9ca914d6d8fa1437315b9ad2a4351c4da3ee3e01068aa128284a8926787ea2a618d1 -aace78e497b32fbff4df81b1b2de69dbc650645e790953d543282cb8d004a59caf17d9d385673a146a9be70bf08a2279 -aa2da4760f1261615bffd1c3771c506965c17e6c8270c0f7c636d90428c0054e092247c3373eca2fb858211fdb17f143 -acb79f291b19e0aa8edb4c4476a172834009c57e0dcc544c7ce95084488c3ad0c63ffd51c2b48855e429b6e1a9555433 -814b58773a18d50a716c40317f8b80362b6c746a531776a9251c831d34fb63e9473197c899c0277838668babc4aa0ecb -b1f69522b0f7657d78bd1ee3020bcce3447116bf62c146d20684537d36cafb5a7a1531b86932b51a70e6d3ce0808a17e -8549712c251ef382f7abe5798534f8c8394aa8bcecdca9e7aa1a688dc19dc689dcd017a78b118f3bd585673514832fe4 -912a04463e3240e0293cfc5234842a88513ff930c47bd6b60f22d6bc2d8404e10270d46bf6900fee338d8ac873ebb771 -a327cb7c3fada842e5dd05c2eeedd6fcd8cf2bfb2f90c71c6a8819fb5783c97dd01bd2169018312d33078b2bc57e19f7 -b4794f71d3eceed331024a4cee246cc427a31859c257e0287f5a3507bfbd4d3486cb7781c5c9c5537af3488d389fe03e -82ffcb418d354ed01688e2e8373a8db07197a2de702272a9f589aed08468eab0c8f14e6d0b3146e2eb8908e40e8389c5 -910b73421298f1315257f19d0dfd47e79d7d2a98310fb293f704e387a4dc84909657f0f236b70b309910271b2f2b5d46 -a15466397302ea22f240eb7316e14d88376677b060c0b0ae9a1c936eb8c62af8530732fc2359cfd64a339a1c564f749b -a8091975a0d94cdc82fbaff8091d5230a70d6ea461532050abbdfee324c0743d14445cfe6efe6959c89a7c844feaa435 -a677d1af454c7b7731840326589a22c9e81efbbf2baf3fdeaf8ea3f263a522584fbca4405032c4cdf4a2a6109344dfc8 -894e6ffa897b6e0b37237e6587a42bbc7f2dd34fb09c2e8ac79e2b25b18180e158c6dc2dd26761dba0cfed1fb4eb4080 -928d31b87f4fe8fe599d2c9889b0ff837910427ba9132d2fba311685635458041321ae178a6331ed0c398efe9d7912f0 -afc1c4a31f0db24b53ee71946c3c1e1a0884bd46f66b063a238e6b65f4e8a675faa844e4270892035ef0dae1b1442aa0 -a294fcb23d87cf5b1e4237d478cac82ba570649d425b43b1e4feead6da1f031e3af0e4df115ca46689b9315268c92336 -85d12fd4a8fcfd0d61cbf09b22a9325f0b3f41fb5eb4285b327384c9056b05422d535f74d7dc804fb4bab8fb53d556bd -91b107d9b0ea65c48128e09072acd7c5949a02dd2a68a42ff1d63cf528666966f221005c2e5ca0a4f85df28459cdede6 -89aa5dc255c910f439732fcd4e21341707e8dd6689c67c60551a8b6685bd3547e3f47db4df9dfadd212405f644c4440b -8c307d6b827fa1adcf0843537f12121d68087d686e9cc283a3907b9f9f36b7b4d05625c33dab2b8e206c7f5aabd0c1e5 -843f48dadf8523d2b4b0db4e01f3c0ea721a54d821098b578fcaa6433e8557cadfea50d16e85133fa78f044a3e8c1e5b -9942eb8bd88a8afa9c0e3154b3c16554428309624169f66606bfb2814e8bac1c93825780cf68607f3e7cffe7bf9be737 -b7edb0c7637a5beb2332f2ae242ba4732837f9da0a83f00f9e9a77cf35516e6236eb013133ddc2f958ea09218fe260d3 -9655fe4910bc1e0208afbcf0ff977a2e23faded393671218fba0d9927a70d76514a0c45d473a97ecb00cf9031b9d527c -8434bc8b4c5839d9e4404ff17865ded8dd76af56ef2a24ea194c579d41b40ed3450c4e7d52219807db93e8e6f001f8da -b6c6d844860353dab49818bed2c80536dbc932425fdaa29915405324a6368277cf94d5f4ab45ea074072fc593318edff -b2887e04047660aa5c83aad3fa29b79c5555dd4d0628832c84ba7bf1f8619df4c9591fcde122c174de16ca7e5a95d5e3 -953ba5221360444b32911c8b24689078df3fbf58b53f3eec90923f53a22c0fc934db04dd9294e9ec724056076229cf42 -926917529157063e4aade647990577394c34075d1cb682da1acf600639d53a350b33df6a569d5ebb753687374b86b227 -b37894a918d6354dd28f850d723c1c5b839f2456e2a220f64ecadac88ae5c9e9cf9ab64b53aac7d77bf3c6dfa09632dc -b9d28148c2c15d50d1d13153071d1f6e83c7bb5cb5614adf3eb9edede6f707a36c0fa0eadb6a6135ead3c605dfb75bd1 -9738d73ea0b9154ed38da9e6bd3a741be789ea882d909af93e58aa097edf0df534849f3b1ba03099a61ceb6a11f34c4d -afabbecbbf73705851382902ec5f1da88b84a06b3abfb4df8d33df6a60993867f853d0d9bd324d49a808503615c7858a -a9e395ddd855b12c87ba8fdb0ea93c5bd045e4f6f57611b27a2ee1b8129efe111e484abc27cb256ed9dcace58975d311 -b501c2f3d8898934e45e456d36a8a5b0258aeea6ff7ac46f951f36da1ec01bd6d0914c4d83305eb517545f1f35e033cc -86f79688315241fe619b727b7f426dbd27bcc8f33aef043438c95c0751ada6f4cd0831b25ae3d53bcf61324d69ea01eb -83237e42fa773a4ccaa811489964f3fab100b9eea48c98bdef05fa119a61bde9efe7d0399369f87c775f4488120b4f2e -b89f437552cab77d0cd5f87aca52dd827fb6648c033351c00ab6d40ac0b1829b4fcdf8a7dad467d4408c691223987fbe -8e21061698cb1a233792976c2d8ab2eeb6e84925d59bb34434fff688be2b5b2973d737d9dda164bd407be852d48ef43f -b17a9e43aa4580f542e00c3212fbf974f1363f433c5502f034dfd5ed8c05ac88b901729d3b822bec391cca24cc9f5348 -aac6d6cda3e207006c042a4d0823770632fc677e312255b4aff5ad1598dc1022cab871234ad3aa40b61dc033a5b0930b -b25e69f17b36a30dada96a39bc75c0d5b79d63e5088da62be9fcbddfd1230d11654890caa8206711d59836d6abbc3e03 -af59fe667dd9e7e4a9863c994fc4212de4714d01149a2072e97197f311be1f39e7ad3d472e446dcc439786bf21359ede -957952988f8c777516527b63e0c717fc637d89b0fd590bcb8c72d0e8a40901598930c5b2506ff7fea371c73a1b12a9be -a46becd9b541fc37d0857811062ca1c42c96181c7d285291aa48dc2f6d115fcff5f3dfdf4490d8c619da9b5ce7878440 -87168fbd32c01a4e0be2b46fe58b74d6e6586e66bbb4a74ad94d5975ac09aa6fa48fd9d87f1919bd0d37b8ebe02c180c -895c4aa29de9601fc01298d54cfb62dd7b137e6f4f6c69b15dc3769778bfba5fc9cbd2fc57fd3fad78d6c5a3087f6576 -b9cf19416228230319265557285f8da5b3ca503de586180f68cf055407d1588ecec2e13fc38817064425134f1c92b4d5 -9302aaef005b22f7b41a0527b36d60801ff6e8aa26fe8be74685b5f3545f902012fcade71edca7aaa0560296dac5fca5 -a0ccda9883027f6b29da1aaa359d8f2890ce1063492c875d34ff6bf2e7efea917e7369d0a2b35716e5afd68278e1a93a -a086ac36beeba9c0e5921f5a8afea87167f59670e72f98e788f72f4546af1e1b581b29fbdd9a83f24f44bd3ec14aee91 -8be471bf799cab98edf179d0718c66bbc2507d3a4dac4b271c2799113ce65645082dc49b3a02a8c490e0ef69d7edbcb1 -8a7f5b50a18baf9e9121e952b65979bda5f1c32e779117e21238fb9e7f49e15008d5c878581ac9660f6f79c73358934a -b3520a194d42b45cbab66388bee79aad895a7c2503b8d65e6483867036497d3e2e905d4d51f76871d0114ec13280d82f -8e6ca8342ec64f6dbe6523dc6d87c48065cd044ea45fa74b05fff548539fd2868eb6dd038d38d19c09d81d5a96364053 -b126a0e8263a948ba8813bf5fb95d786ae7d1aa0069a63f3e847957822b5fe79a3a1afa0ce2318b9ba1025f229a92eb7 -8e4461d6708cac53441a3d23ac4b5ff2b9a835b05008c26d7d9c0562a29403847cf760b7e9d0bcb24a6f498d2a8a9dd2 -b280a761bab256dfe7a8d617863999e3b4255ddbdc11fe7fe5b3bb9633fc8f0cb4f28e594d3b5b0b649c8e7082c4666a -a3e3043bfd7461e38088ee6a165d2ca015de98350f1cb0efc8e39ed4fcdb12a717f0ede7fbf9dadb90496c47652cc0ce -a4c1f5b1b88ae3c397d171e64395afe0cd13c717677775a01dd0461d44a04ee30ec3da58a54c89a3ca77b19b5e51062c -a268638e0655b6d5a037061808619b9ae276bb883999d60c33a9f7f872c46d83d795d1f302b4820030c57604fa3686e7 -ac20176111c5c6db065668987227658c00a1572ce21fe15f25e62d816b56472c5d847dd9c781fb293c6d49cc33b1f98f -acc0e22d9b6b45c968c22fd16b4ece85e82a1b0ab72369bdd467857fee1a12b9635f5b339a9236cbd1acc791811d0e29 -b56066e522bee1f31480ff8450f4d469ace8eb32730c55b7c9e8fa160070bdec618454e665b8cbc5483bc30b6cebbfb9 -8c1772bdfacff85f174d35c36f2d2182ae7897ad5e06097511968bbb136b626c0c7e462b08a21aca70f8e456b0204bf8 -b4de3cf4a064bf589be92513b8727df58f2da4cd891580ef79635ac8c195f15a6199327bb41864e2f614c8589b24f67e -8f3c534125613f2d17bf3e5b667c203cb3eab0dbca0638e222fe552fddf24783965aa111de844e8c3595304bfc41c33b -8e445b2711987fe0bf260521cb21a5b71db41f19396822059912743bf6ca146100c755c8b6e0e74f1bf2e34c03b19db9 -87ff9adf319adb78c9393003b5bdda08421f95551d81b37520b413fe439e42acf82d47fa3b61476b53166bf4f8544f0e -83f3c00c55632e1937dcdc1857de4eccd072efa319b3953d737e1d37382b3cf8343d54a435588eb75aa05bf413b4caa0 -b4d8ee1004bac0307030b8605a2e949ca2f8d237e9c1dcf1553bd1eb9b4156e2deb8c79331e84d2936ec5f1224b8b655 -93b2812b6377622e67bf9a624898227b56ebe3c7a1d917487fc9e4941f735f83679f7ac137065eb4098ad1a4cfbc3892 -81943d9eab6dcea8a120dde5356a0a665b1466709ebb18d1cbfa5f213a31819cb3cf2634e6d293b5b13caa158a9bb30b -a9042aae02efd4535681119e67a60211fc46851319eb389b42ebadcab1229c94199091fb1652beba3434f7b98c90785f -91db52b27fd9b1715df202106b373c4e63ce8ec7db8c818c9016ace5b08ef5f8c27e67f093395937ba4ce2f16edf9aef -83cb9b7b94bd6ead3ff2a7d40394f54612c9cb80c4e0adadffea39e301d1052305eb1fe0f7467268b5aba3b423a87246 -8720fd6712a99d92dd3fdaae922743ab53fad50d183e119a59dae47cdac6fbea6064c732d02cb341eaea10723db048fa -8d40022c1254462a2ac2380a85381c370b1221e5a202d95c75bccba6d1e52972dd5585a1294a1e487bf6ae6651867167 -b7bc06e08d8c72daba143627582f4b4f34cc2234b5cb5cd83536f2ef2e058631a3920468ea4d550aea01cad221d6a8a6 -a6e1a6f70fba42d3b9ce5f04ffdcfca46fc94041840c0066a204030cf75ea9f9856113fea3a9f69ea0037d9a68e3a9d4 -8b064c350083fce9a52da2e2e17bf44c4c9643d2d83667cbd9ad650bbeba55e2c408e746ccf693e56d08826e8a6d57fc -8d304a5405a0c0696917fcddc6795dd654567ca427f007d9b16be5de98febbf8692374e93f40822f63cf6f143c4d9499 -b968db239efec353a44f20a7cf4c0d0fca4c4c2dc21e6cbb5d669e4fe624356a8341e1eec0955b70afb893f55e9a9e32 -98971f745ce4ce5f1f398b1cd25d1697ada0cc7b329cee11d34b2d171e384b07aeb06ac7896c8283664a06d6dd82ec6b -881f5a20a80f728354fad9d0a32a79ffe0ba9bed644ed9d6a2d85444cda9821018159a3fa3d3d6b4fadbf6ea97e6aff6 -b7c76cbb82919ec08cf0bd7430b868a74cb4021e43b5e291caa0495ca579798fab1b64855e2d301f3461dd4d153adeb6 -b44c8c69b3df9b4e933fe6550982a6f76e18046e050229bd2456337e02efb75efa0dfe1b297ed9f5d7fa37fec69c8374 -a5bd7781820ba857aee07e38406538b07ab5180317689a58676f77514747672dd525ea64512a0e4958896f8df85e9d4d -a8443d1dc91b4faa20a2626505b5b4ad49cc5c1fd7a240a0e65d12f52d31df1585ba52c21e604dcec65ec00b81ae21fe -a157ae42fc6302c54bcdd774e8b8bafc4f5d221717f7bf49668c620e47051b930dce262d55668e546272dd07ca7c8d3f -8732c10448b63e907ff95f53cd746f970c946fd84fcbfe4cf9ede63afbbfc66b293bbc7c470d691bbd149bb3c78bb351 -a82192f4fd9a0c33489a0486b79d0f6c797c7eccb45f91f7f1e8e1dd1924ca9944b983951025b99ab5861d31841451fe -839efc6d199ddd43f34f6729b6b63f9ee05f18859bf8fd3f181fa71f4399a48bff7dde89b36e9dc1c572f1b9b6127cca -992ef084abe57adfd5eb65f880b411d5f4ed34c1aeb0d2cfac84fff4f92a9a855c521a965ba81b5eef2268e9a9e73048 -a2518ab712fa652e6e0bd0840307ef3831094e9a18723fb8ec052adacbb87f488d33778c6ec3fd845003af62e75125d1 -b630ac3c9e71b85dd9e9f2984bb5b762e8491d8edb99cad82c541faf5a22dd96f0fddb49d9a837b1955dea2d91284f28 -8d886d1b7f818391b473deba4a9a01acce1fe2abe9152955e17ba39adc55400590c61582c4fef37a286e2151566576ed -884f100dc437639247f85e5d638fcc7583d21bf37a66ce11e05bfc12f5dbe78685b0e51b4594e10549c92bb980512e12 -806d7bac2d24cfff6090ba9513698292d411cdea02976daa3c91c352b09f5a80a092cfa31304dcfcd9356eaf5164c81b -934ed65f8579ee458b9959295f69e4c7333775eb77084db69ad7096f07ad50ad88f65e31818b1942380f5b89e8d12f1b -aaf50ca5df249f0a7caf493334b6dca1700f34bd0c33fe8844fadd4afedbb87a09673426741ac7cbbb3bf4ab73f2d0f3 -b2868642cfa0a4a8a2553691c2bef41dab9dff87a94d100eaa41645614ab4d0e839ec2f465cc998c50cd203f0c65df22 -a326513112e0b46600d52be9aa04d8e47fe84e57b3b7263e2f3cf1a2c0e73269acb9636a99eb84417f3ae374c56e99b0 -97b93efc047896ddf381e8a3003b9e1229c438cc93a6dbef174bb74be30fac47c2d7e7dc250830459bed61d950e9c924 -b45e4f0a9806e44db75dbb80edc369be45f6e305352293bcae086f2193e3f55e6a75068de08d751151fdf9ebc6094fa1 -87f2161c130e57e8b4bb15616e63fa1f20a1b44d3e1683967a285f0d4f0b810f9202e75af2efa9fc472687c007a163f7 -8f6400a45666142752580a2dce55ef974f59235a209d32d2036c229c33a6189d51435b7ea184db36f765b0db574a9c52 -a0ee079462805f91b2200417da4900227acde0d48c98e92c8011a05b01c9db78fc5c0157d15cb084b947a68588f146f4 -ab0612d9bb228b30366b48e8d6ae11026230695f6f0607c7fa7a6e427e520121ff0edea55d1f0880a7478c4a8060872d -ad65dfde48f914de69f255bb58fa095a75afe9624fc8b7b586d23eb6cf34a4905e61186bc978e71ccb2b26b0381778a6 -8c8a4847d138d221c0b6d3194879fd462fb42ed5bd99f34ebe5f5b1e1d7902903ec55e4b52c90217b8b6e65379f005a4 -a41dca4449584353337aef1496b70e751502aeed9d51202de6d9723e155ca13be2d0db059748704653685a98eaa72a07 -ae40e5450fd994d1be245a7cd176a98dd26332b78da080159295f38802a7e7c9c17cc95da78d56558d84948cf48242cd -863878fda80ad64244b7493e3578908d4a804887ad1ad2c26f84404dcad69ea2851846ad2c6f2080e1ed64fe93bbec31 -b262fb990535f162dc2b039057a1d744409a3f41dd4b70f93ff29ba41c264c11cb78a3579aad82f3fa2163b33a8ce0e1 -a7f6eb552b9a1bb7c9cb50bc93d0dda4c7ecf2d4805535f10de0b6f2b3316688c5e19199d5c9ec2968e2d9e2bd0c6205 -a50aa5869412dc7081c8d827299237910ecec3154587692548da73e71fa398ff035656972777950ba84e472f267ba475 -924c3af750afc5dfad99d5f3ed3d6bdd359492cff81abcb6505696bb4c2b4664926cb1078a55851809f630e199955eb3 -a1acffa31323ce6b9c2135fb9b5705664de8949f8235b4889803fbd1b27eb80eb3f6a81e5b7cc44e3a67b288b747cf2f -8dec9fd48db028c33c03d4d96c5eecea2b27201f2b33d22e08529e1ae06da89449fe260703ac7bb6d794be4c0c6ea432 -aa6642922ccf912d60d678612fffe22ef4f77368a3c53a206c072ed07c024aa9dcde2df068c9821b4c12e5606cfe9be2 -a16ddf02609038fcb9655031b1cb94afe30b801739e02a5743c6cd2f79b04b2524c2085ca32ec3a39df53de0280f555d -b067d48589e9d3428c6d6129e104c681e4af376a351f502840bbea6c3e11fcbfdf54dadf6f1729621720a75ff89786c3 -b14a24079de311c729750bb4dd318590df1cd7ffc544a0a4b79432c9a2903d36a0d50ecd452b923730ade6d76a75c02c -97437bac649f70464ace93e9bec49659a7f01651bba762c4e626b5b6aa5746a3f0a8c55b555b1d0dc356d1e81f84c503 -a6f4cb2ffc83564b1170e7a9a34460a58a4d6129bd514ff23371a9e38b7da6a214ac47f23181df104c1619c57dff8fe2 -896d0f31dfc440cc6c8fde8831a2181f7257ffb73e1057fd39f1b7583ea35edf942ad67502cd895a1ad6091991eabc5e -9838007f920559af0de9c07e348939dfd9afe661b3c42053b4d9f11d79768cba268a2ee83bb07a655f8c970c0ee6844b -b41b8a47e3a19cadec18bff250068e1b543434ce94a414750852709cd603fc2e57cd9e840609890c8ff69217ea1f7593 -a0fb4396646c0a2272059b5aeb95b513e84265b89e58c87d6103229f489e2e900f4414133ed2458ddf9528461cfa8342 -ae026cfa49babc1006a3e8905d6f237a56a3db9ddf7559b0e4de8d47d08c3f172bde117cdf28dfdfd7627bd47d6a3c85 -a6a3f3e7006bc67290c0c40c1680bf9367982eb8aaf17ecb484a58c8e9c2a7c24932e2caa9aacc9b4fbf4c0abd087a46 -9093e05bd814177a01a3b8d7b733db66294e1c688c56def6e1827c0f2d9a97cf202721641bf81fb837f8581ae68cb5ce -87feef4de24942044f47d193d4efc44e39a8c0f4042fba582f2491a063e3a4640cb81f69579b6f353b9208884a4f7ce6 -975f9b94e78aac55bd4755f475e171e04f6fbddb6fd3d20a89a64a6346754a3ff64ecff8c04b612a1250e1d8d8a9e048 -87cde4d0164922d654cf2dc08df009e923c62f1a2e3b905dfde30f958e9e4dd6070d9f889712acd6c658804f48f3edb1 -ae8e22e158dda90a185eec92602831b5d826e5a19aab8c6400dba38b024c7d31c4cf265eb7b206dd45834f020b3f53cd -a4475807adc28aa086e977b65bbd7c8512119318c89d2619ea03a6739a72c3fb90c9622451896c7113ad4d12a3004de6 -97f1ae1e0d258a94532c7b73fa8ebdbbd53349a4d2d0a217fe56dfdd084dd879960bc6ff45ebb61b5dbf2054642800a4 -b3c832bd3691332a658b0caaa7717db13f5b5df2b5776b38131ac334b5fd80d0b90b6993701e5d74d2b7f6b2fd1f6b9d -a4b6af590187eb1b2cb5ae2b8cffa45c5e76abdb37cec56fc9b07a457730f5af0706d9ce0a17da792bbece5056d05670 -97b99a73a0e3145bf91f9dd611a67f894d608c954e9b8f5a4c77e07574064b3db47353eba8038062cebaad06a2500bab -8e5ca5a675de6e6d3916bd9ce5898bb379372afe3f310e70ff031bc8cc8fabfb7f3bfb784f409bb7eb06fdb4511ee477 -aabbbee4da1f16b5bbe001c19debe04745932d36dfbbf023fbf1010a2b1d54eb92fa5e266ac1e9337e26e2ddba752f40 -b13447c77496825f48e35c14f9b501c5056e6d5519f397a2580cea9a383a56a96994d88926aa681142fe2f1589c03185 -b89c55db39ff0e73dde7435b61e8a4d3e10f51dd8096cbc7f678661962e6de3d16f2f17a0e729cc699234cb847f55378 -82c36b7de53698a1bafbb311fefc6007fcefa47a806ebe33a4e7e0fc1c7b6b92a40a1860702cf9295a16c6b1433e3323 -8daeec8c88543d09c494a15cc9a83c0b918d544311fd2a7d09e06cf39cdebfa0cfc0e8fc0e3b5954960b92332f98697c -b18e55a1a7ae16be3a453d2bfa7659a7ec2d283dd46bdc82decef6d3751eeafc4f86f2416a22955c7e750c0582d4f3eb -b50c743462e2915bf773848669e50a3bcdb5a9ac5f664e97eaccf568c7d64a6493d321be0225de16142ce82ce1e24f66 -af69c9643805fb860434424b1608aababc593aaebc6a75fc017f7f62bb2b1da932b0b9bd5e6dcbba328422dafc06efd8 -b5947db4f809fd0d27af838b82eef8ab4fe78687a23ebc61c09c67eb7e8d0e6a310ecb907fd257859d5a2759a07c21cc -92c7960e163ca5bdf9196c7215102f8e9d88efc718843321c6e2a6170137b8ecec4ea5d5a5ce4c28012b6cdbd777dd01 -b63f9509ed5e798add4db43b562e8f57df50d5844af6e5c7acf6c3b71637c0a2d2433f4a0627b944f0af584892208bb8 -8ef28304a9bfe5220af6a9a6a942d2589606f5dc970d708ef18bc7ed08e433161020d36fb327c525398cd8ecb57002f9 -b722e0410f896c4462d630a84a5a14e94289fc38ed6d513ca88a09005935cec334c480028efa1943c7a5e202ae8c8379 -b56b6672b488e64d4dde43571f9ceaa7e61e336b0fd55bb769a57cd894a6300e724e5f88bad39a68bc307eb7406cb832 -8bf493da411fd41502b61a47827731193652e6ce3810709e70869d9aae49e4b17a40437a7a0dcc0547dbac21f355c0da -9613b60a144c01f6a0e7d46ddde07402e2133a1fe005c049a56415ff90401765040b2fc55971d24b94c5fd69fec58941 -85e2f02b291563d8eea3768cf6a4602c0ca36568ffcf3d93795d642044196ca6b0b28991ea5898e7974ee02831a0ec70 -b08ef66703dd9ac46e0208487566fbf8d8654d08c00f03e46f112c204782ccc02a880a3f9dffd849088693cee33b7b6d -a0b19eeda6c71b0e83b1f95dffef4d370318bdea6ea31d0845695e6b48d5c428c3dbba1a0ded80964992c4a0695f12ee -b052642e5772d2ef6f49dd35c5e765c5f305006b2add3b4bee5909ca572161edf0e9c2bc3bc3bc7f56fd596360ef2201 -8261af164c768fec80d63fca6cd07d1c0449e9ca665fe60c29babdbd8a2b20cf1f556a4b24cd7341712468a731c21b32 -8a17016a1b2fc0fa0d9e3610ea80548fcf514e0a35e327f6b5f8069b425c0f0829af7e206013eab552be92b241be5ac5 -8eea25c680172696f5600271761d27ef4c8cec9ab22f01f72b2c7c313a142fafaec39e6920b96fcace858883e02eff7a -b8e0c590106e125c5bca7e7a071cc408b93629da0d8d6381f1b73fbdf17024a0cf13f679f5203a99bbbcb664b4a94e88 -b9943b29395258b7afdf1781cfaf131297a4f325540755df73401b2ec4a549f962952e9907413c39a95585c4aff38157 -8286eab4a04f8113fb3f738a9bc9c2deaf3a22bf247151515568703da4efe6450ab3970f5c74e978a2db7e8d795331b7 -a10cf383c8a7e3f0a0a5556b57532170ff46dabdcbb6a31c4617271634b99540aa575786c636d3809207cbf1d2f364d3 -a5af7eb998140d01ba24baa0e8c71625aee6bd37db4c5ff607518f907892219ba8c9a03c326b273bfd7068232809b73c -aed5f461e38fccc8b3936f1328a9747efcbceb66312f6d6eddce57c59570852767159f1a7d9998f63342515fef4ba9bf -aec3e94b029aa692bfe2b8dbc6c3b0d132b504242e5ebe0cad79c065085e2fc05550e5cdaa2353892a40ff1a062dd9eb -87c23703960129396018d0347f5dd034abdbd57232b74195b6a29af34b6197b3cd63c60ac774d525add96ae54d5c0fb4 -97964a7768216e1c84dece71ce9202cc64b6d483650aa6f6d67215f655f66cda14df0a0f251db55832c77bfd9b6316e2 -8167aaf24c8a023d0aea16b8c24d993618b9d0c63619e11a28feab8f14952bafcb0918ed322cbc0ae1b2e1786071819b -b58318bd62852ffb712fc58f368c21b641dde7b3fa7d7269974c7a7b5b3e1641569fc7b5f32ca49de22f4f993506d92d -b172e7911d5cd3f53af388af847b928947c711185aebd3328f8e6ed1106c161ae0c1b67d3d9eb237e9e66eb0672edec0 -a6834cf69b2c4433cf6e779bfbb736b12e73e71e149c38101d13dbacf6c5048db53994a6a039381df40bbd67de40fcd0 -882604aa3bb19fffd6db744b5cf4a2431b157dac06d0617e0703684a118ca90b2d22a7758a1de7732a7144e68b11b7f7 -addc128ba52bf7553b9ba49eff42004d388a02c6b6e9809abe1c0d88f467e5ff6cb0c82a8fd901b80dfc9a001f7b9997 -abf19604a3f0cffefa7a9ced81627f6aacb8d7267b52b825f25d813d9afa24af6d70da21450ed93eaff8b4d2a9b905a9 -a3c67e7bf02dbca183d86924611a7149556ee17cb3469793624da496b6c25617a9071925dd02aab9cb028739cb79043d -b1cea4284a3ac4d5b1c6f0947c6ec8365b3281ed15495bf328a907a9a02cdd186e7cb1ef080385b3399df786855985a9 -a6edb126314559e6129caf1111dc3c82ff914efce658b11f2c9b48081be1cf3f46bde482469d493379025a158d95ab1b -9843fd7dd424da1acc6f92f87fac364a8b0d4097d74b6b451386384966c85145d43fc6ecedf04271b0f963ac731fd93f -83852bedca03a97a2e63053cb102387866cbefe6707ebb6dae2d32a59c343079f1a863f299fd64d0ecbe024d0a1247d5 -a570e645a0679ebc6f0ca03cc8f7367b03c3886f3d9c787992de7f3e93360a170d3ac9ae7720999c727a887b1dc762bb -ad644c40555238f28844eed632c8972b63d2602098031d53b5599d1a874903e0d0c428e0ab12a209ea3fb31225578f1c -b64e9f92a14812ed31075f9fdd3324659a036ef2f293ef9ca6f6feb87d0c138e1ba74bc36a910afd22ff9b3c8ec7cfa5 -8f2d75a86d517dafac09b65596f4b89c4a9c0a7003632407504153fa297c9e3228e236948a5d5224b8df49a087c8e0e3 -b02d6ab9292ae336c8a74115f33765af2c9f62c331d70c087cf4c2979792bb3c2666f6699c017f8d4c6b378fd4bda86a -a923d660d2e55228b8bc74f87d966069bd77c34a776fa96f37b48539c85634482e514e2cb76cb8eb20efd85eb9c83fae -81d7ffb53090a6d512055ecfd582ca92805525a05654e39bb12653a6a8902a16e651ba7b687b36b8bea7186632c7e9e3 -83e9b33e29b57ae53d9f72bd4622ff388252333b4fa32ad360a5b00f3ffc8813b9cb8a1361454d3bb7156c01b94b6a08 -ad7d6bffe4d67eb53b58daa3fc8a5a60790c54fa42226ae12847e94c6de3b4365b3be39855a4f6a5f12e4803cdaed96b -a7709fed85abbee5a2fa49c5238582ec565da08c132d4912821491985bf83b681eb4823634bfe826abd63a6c41a64ea7 -b8fb6ed55741132a1053b6ca77bdf892e96b048488373ba4aa2f2225fae6d578724124eb6975e7518e2bf3d25d215763 -85e0c53089529a09b5bce50f5760af6aeafef9395388aa4b6144ca59953169101783347ee46264ec0163713a25fe7c63 -8f9e47a9c37b678e56c92b38d5b4dab05defc6b9c35b05e28431d54b1d69ac31878c82c1357d016f3e57ca07d82d9c16 -a81f508136ee6ec9122c48584df51637f768ccfe8a0b812af02b122a0fafa9abcc24778bf54143abb79eccebbdde2aac -931a96d2257a4714d1ef20ac0704438481632647b993467e806b1acc4a381cc5a9dec257e63239ba285deb79f92122dd -99fb0ff747bcd44b512bf8a963b3183ce3f0e825a7b92ddd179253e65942a79494a515c0c0bc9345db136b774b0a76b0 -a9dbb940b5f8ab92f2d85fc5999e982e3d990fe9df247cfc6f3a3f8934fb7b70e2d0362ba3a71edc5d0b039db2a5f705 -99011a1e2670b1b142ec68b276ff6b38c1687eed310a79e2b902065bc798618c0cdee7b2009ad49623ed7ae0aa2b5219 -9361e9f3aa859c07924c49f3d6e9b5d39a3df2fc1c10769202ec812955d7d3814c9e6982f4df3a8f3bdbfb4550cd1819 -a8aa23f177ddc1e7a7856da3eac559791d8b3f188c0b3ae7021bcb35dfb72b0f043c3699597a9188200408bc3daf6ab7 -a5a502ff673f6dab7ae4591a7b550c04ede22a45a960c6b5499644f721c62b12b9e08248e7f8b8a59a740b058d2a67e6 -ad374f80f0b52bc5a9491f79a547ce5e4a3ce4468a35d7dbca8a64083af35ab38eff9aa774ccba2e2e1e006e45cb0b85 -ab6851827125e3f869e2b7671a80e2dff3d2d01ce5bfbeb36cbaf30c3d974a2d36fd9f7c3d331bb96d24b33dbd21f307 -96658f6a2d225a82f7ccee7f7a7e476967e31a0cd6c62859d3b13ee89702bb821547f70ffd31cb46a6a0d26a93158883 -878f59ff2590bc3d44fdc674717589800748b78d543d3c0dbb50125b1d6011d6a083f10ab396e36b79f2d89b7cf51cdd -b8bdfb97829c5d973a15172bfe4cb39620af148d496900969bd7ca35de9b0e98eec87af4e20bef1022e5fb6c73952aa0 -a292a78b452743998aee099f5a0b075e88762222da7a10398761030ffcc01128138d0f32fccf3296fcbea4f07b398b5f -85da44fdd7b852a766f66ba8804ed53e1fc54d282f9a6410106c45626df5a4380cbea2b76677fdfde32446a4d313742a -84bebf036073d121e11abc6180cba440465c6eaadc9a0c0853a5f1418f534d21cccf0cfc62533eaeae4653c7b4988046 -923dec006a6af04ef675f5351afffffd2c62a17a98f4144221927c69f4553dd105e4fcc2227b5f493653d758cd7d0352 -a51eda64f4a4410a1cfa080d1f8598e23b59856436eb20a241e11106989fbbb48f14c2251f608cbf9531c7c442b30bf7 -ac6d26ae7bab22d49b7fba7fe4b8cf6d70617977008c8290787c9da1a4759c17c5e441efb3dee706d5d64d9d2ace1de5 -ab5138b94d23c1bf920b2fb54039e8a3c41960a0fe6173261a5503da11ff7b3afdb43204f84a99e99888618a017aac1b -8c85647a91e652190eee4e98a1eec13a09a33f6532926427bf09e038f487e483f7930fbe6ff7a2126ccde989690dc668 -a6026ab87cffec3e47b4c9673957d670cb48c9b968d2ad0e3d624d81c1082dcebbc70d0815cbd0325e0a900d703a6909 -ac4f6ff6baf8374a3c62bdd5a8d207d184ff993f6055bcee1e6dcc54173d756c37c24570d6462395add6f7871d60b1ae -a0dd6bc93930d0016557588f2598b7462ca48cbed637c8190be0fb4811e4576217ca9fc3c669c2a4db82e3f8bb24acaf -a67c1d79f7e7193a23e42928a5cc6a6e8e0c48b6b286607dbcfaaa0f10a7ba29ad62d1d57ca28c486794f0908bece29c -822f411bab4882202ed24e67c84e0c9a8da5b3389804ed9dfba0f672e3e1457ea76cad0cb935dbb3d7a39500fba5fe12 -8a1198572323689300a9d7db2e2bcb7c519392e5d3d33e83cd64bcf1517a7dde52318a98203727b186597702c0eed258 -8a84141b02f1d037c68d92567d71cda3a0b805d1e200b1d3fff3caf9902457cbfbaac33157b87ab0bb9e4fe3bac882c3 -8070ace16d9eef8658fdcf21bed0d6938f948f31ca9d40b8bdb97fc20432cd2a7ef78eeefc991a87eae7f8c81adf9b19 -9522e7123b733ce9ca58ab364509f308a1ead0915421ccede48071a983fd102e81e1634ffa07a9e03766f167f5c7cb5e -82cbdf97a755e952304f5a933fd4d74a3038009f242dac149595439130a815e9cc0065597c0b362130183a4c4a444173 -81e904f9b65cd7049c75f64c7261e0cbb0cc15961ffcac063d09399d0d2b0553b19e7c233aca0f209f90cf50c7f5e0b2 -8f5f6ea87429542ea04ad3eb5fc7eeb28fcf69c01c1a5d29b0de219524f6fba90c26069bfc9092379fe18cb46274393a -a4e5815481eb33b7990d2de1a3a591c1ab545b64fbeb4cff8c71b6bcb04d28940097899062bf43b27c5a8f899616703e -a7afe6066681e312882b3b181f462a1af2139d9bd2aefffae7976f3fc357bfd8fbd6ddd4e5e321412f107736e77f0cb6 -b8ab102d7ff8d46b055095d8fb0ec2f658c9e18eee523c295b148b37f8342c120798113553b8bfebf2a11f27bc704cc4 -862175ecc7e0e294c304a0352cd0f1d11b2603d326bb0e54e02b6cc8d04d01ac31c8864e9395aa1f3b90b76bc4397f5b -a4ea51ef3d82509f0e4eb6af705fa7530921cf9512cb5bf030571e69f4504a299297219a0a7e40db1b45165a5ea3a3f2 -a6fb8b573e2ba6db0e8aba53a489e99bebe533c0fcd947dbfa732e00594f03f4e8609ccc44d8215986d38bc3d4e55d48 -93fe8e0bdd5d66df2bd18be5963e864bddfcdcd3298590e7c3b11d99a070a4948fecef46453f19960bbfeada37979613 -acbc45bc55c7080b45c69a3db80cbfc0267006dcf49c47330975aeff2a8ac07b206e1b1c3a515e50866ff510739b92c0 -94a577df0983e4ee3d6b80c73d7e8e3bb78bd8390ff56fea350e51bdf5e0176b8494e7e81dc7b1d842ada961089cd1eb -81eb1fbe9e9c89f5818d0ef98e694da86e88625f0a37cfe88e6de69f90e58297e67f1d5c9d71263b523b63e42685975a -a81a2391ea4d0f65ab4325196559d67e2648b3f1e464509430b40d9948d5b0fc01c337d9b51048a93c4d62e6b73e1e8c -849a026e55ed77135138836c9df67883763e4602357d8566da2ee2505d135d44061de0c070cf333ffb9ac2e55a0894b2 -8e272cc5734374c003c7b2e6ba833eb99b6be608da04e576df471c24705b6b2a790549c53e7971df2d9f0b88d0f570c6 -b0f9e6d985064aa311d4a147f41007fdc576b7b9194aa4b8712bf59a76a71543fec2ee3db21bd3d30d4096f25babc543 -96331837f0d74e2ba6cb1bfaddf4b1fb359bf46cb6c3c664938eb030e56bc85a5ce17bcd60b7fa7b72cb0ba1f3af0b5b -a0eaab6de4b5a551896e7d26153fb5df4bc22a37833ec864090b57b5115b0f8f1279e855cea456bb844802b294b0dbb7 -955e87d3b966edff34f28137f871881c59bbbc6d69986b739867807680ca22b5e3272ced1d25854ed9700d87f133848b -9270a6db157a8ce78a1af6bfe2b5bbe7b621d56cc8f9940a03b5a5f600848b87b05d83595b2a3a315d4b7f4687c46085 -9043328f2dd4dd85e14c91237a3478dc1eed239164924b53d1de9364d76c81315afa9639b58eedb1ab2122e2ae2e7cfb -857fe9f7d00b03bce367de7f789d755911a5f85d78044f18311ecd9b955e821b4a50228347260ba1205aef61219001fe -a0f878050367a7103fddf380908da66058ef4430eae1758335c46c24f5c22fefb0753991b3a47dba5c7eaafa4d598178 -ab5959296b1af14d2878816c7da9926484cbf8896b7eeac8a99dc255013319a67a0209025e1f8266ffd8cd7d960bdc87 -abe53abc57ea46419dbe0ac1f39eee39a4feae265e58b50928eb0695e25938a16a8b00e65c1313837dc3367297e2c258 -93e3e42ed6ba9c45d4e7a4bf21c1e469efafded1f3be9931a683dbb780db2494742fd76c9ad29fd7d12da2b778ede543 -ab3e64035c488a6e63496ddb2de9648cc63a670c5d4b610c187d8ceb144fcc50b016046f50b10e93b82937ebe932ac08 -a3a8fa898f489b313d31838ad9f0c7ffe62ef7155de5da9ffe6ecd49a984fac3c6763e8cb64e675e1c4a0e45e7daf078 -8356b26aa7c9fc9734b511480dad07b164cfec1324ad98eec9839a7943f2889d37c188d465515ad4e47c23df641c18c3 -83c4476f829e0fe91da2353d5b58091e9335157941e89ca60ccab1d7fdd014bcf21bd55249805780ddc655c5c8c2536e -814f6e66505b2cb36de92c0de8004d6d094476522e66b9537787beff8f71a1381ed9f2b7d86778979ad016a7dae6cbac -b1cd7f6da4a625b82bea475442f65d1caa881b0f7ce0d37d4b12134d3f1beb3ad4c2f25f352811e618c446185486adb6 -a71b918481b9bda667de0533292d81396853a3b7e2504edd63904400511f1a29891564d0091409f1de61276d2aebc12a -a2cd3d4104ec5fb6d75f5f34762d5e7d2ff0b261bea5f40a00deec08fbdab730721231a214e4df9b47685d5bacfe37c6 -807f2d9de1399093bf284814bc4093f448f56a9bde0169407cdc0e7d2a34ff45052aef18bcb92f0ac7a0a5e54bd843e9 -abeb03010c3ac38587be2547890a8476dd166ac7b2a92c50d442f031eaf273ad97114c38e57fe76d662c3e615334ac0b -b90a688da4b0bf65ff01bcf8699f0cba995b3397fcbe472e876ae1091a294463e4b94350ae8bd5c63b8441089e0884fd -ad88db4afb177931788fb08eff187e15ad739edc7e1a14c8b777b6bf668aec69ca4749773f94250c1fdda3b59f705f7c -9886809f9ae952797c6527c6db297d2aa3d5209b360efe6a19970575a9f78aee3c21daadb8e8dfcbeeea5290238d16d9 -930f486e95d7c053c9742e6f0b31e6d4fa2187e41229e46a074b469aafb87880aa8e972719b363049fc9fe2db8f03ce2 -8d229af4fa08bd8aeb5fd9acfee47571eb03fcd2f19073b94cd27e2a6735029d31f123249d557f8d20c32ac881eae3aa -84576ed5aebe3a9c3449243a25247628993fdb2cc327072418ea2f1d11342756e56e9a82449bc3ea6e8eaecabc62e9b5 -b775cb86cbec9c46a4a93d426379c62872c85dd08bccda39b21cb471222b85b93afd34a53337b6d258f4891c6458e502 -8be1540e6b535b416b8d21e3ecf67dfb27a10fd4010f9f19426422edaeb0a4961d43ff3afd1db0994170056ce4d77aec -b9c7438e90a5501a4d05bbb8ab68d6db7e9baa8927231a5c58715ee2ab76ca1da0e94910a076958654869148d813d0e9 -aa9bed1c4d2e7cbc2e1a884c8998773f7cc6fa9d6493c8abe8b425114a48305c3a43a1abda2292177ffd39ef02db4163 -897b395356047cd86f576cfc050f7e4546ecd4df30b2c31ed8945797b81dd4ed9b9106cfbe6d7dd8bf91882e3cf1f42e -949a37e1037d9464b2ccd3ad23eda7089570d6b5ffa18025d2548a9df8829de8d62960f04a603f21eecbca5893d45284 -b8a0642f68ff169ffbcd8cd684fae75d96f9bd76949472775bf155edc55a3d9c3e6f0299ee73a6cfb96289361fdbe9ee -a1273141510fcddd89b9b92c19a268dadd1528ad85744b8174684c9b56668e6b35dabb05f2b4cc6ef5611eaea6052f27 -97c7415c82de83ecc066eb922268b8205ad7266c65b2b8f7e0aadac87f076c738cea72f9b0f069b8d28cf9d5438b8287 -b32c7005380c848f71092a74297555dc6022369fc2a4f285e586ac8f53f6bd354fbe4b1f8a4cfb406a101103bf87bb64 -91b48eeba52f02d04f536d32112038f8ba70bb34284fbb39e0f7bae2e08b3f45ad32e2f55d1beae94b949c15652d06a1 -99e24f5ea378cb816a4436af2ee7891ac78a2e37c72590be0abd619244a190fee51fc701b6c1c073611b412cb76332c9 -9465d1e73a1a0a5f7b1cd85f4fa4f5dee008b622b14d228d5cd5baeec174451e7ae93c5de688393d37cc24ce15df4139 -a6ac3986ee01debdacb5ddc1e2550cb4f039156df15c7d5752b79f333175b840bdca89c4959a523e58cf97bbd6b2039e -b7f7a5cc1b1b6145988170d619c170c130231abbe0b5143a9bccaaebeef9ceb1c16e26749bc9dc5650fe91f92fa1b79b -854cb04f1557457383a401d79a655adfd0a4b706ea2bbc6262949c8d657efcfdc9c7960cbe1a50b5eebb361c5e378f80 -8dd199dccbdc85aeca9ddcb5a78dd741a452f7a0d3ceb6546d76624bad2fce0e7e6c47ee30d60bf773f18d98503e7f9c -889e1ca9f0582be9bf5f1aede6a7312b30ea9bed45ab02d87182a013430f16007ae477ee6a823ae86c7fef7da016a0ec -892a60e63edfb3e7a6cf2d0be184413d214401fc1e6c004ca2902c3f1423728bf759a136e6e715d26d5bb229c75cc20a -a2287cd092261b39d22dcb1fa19512590b244771bb69fb62eda72f12be37d48e408b3e37a47608f68d743834edee7f15 -b3b6afb950bbec0ff631bdf18af433e68adc63d02cb479704f24329ca6b6edd9a3d1d606563dbdce6038b676b85130b9 -847da90f37b294509de51ab6521fdff12d5a1ec3cccaf730aa744da7e54b85fd9c70618787e87c0ba9947ce6c81387fb -ad872153c00bccac75bdb30d1ab7044d814f4f8655ff26421d48fea04fb21d4dc82c1900620a57d13adc45c1062a1817 -90fa5ee98fd7ec719f2a8543bbd0ff45ac69296c2416fc8666d05de3deea1017079a68aba55540a19585925803c8335d -962ba6d029e9176d0e8c80a21f2413f7322f22a9e9a32c933697a8b0e995ce25bea5264736a75718b3d330e215a58a05 -a446f9530db30c5e9c1b3844d635e5c2cd311cc4537ff277fe83dd1a0382bcfa73beb07aaa0cf5a97d24c67e688086a4 -8766b2053f16c72db387abe18b43d7b357a542916c9b8d530ee264e921c999494d6eb1e491352ecdf53758640c7a246d -83f32f511f7b0233662acfc14f30df345af99d2d6c777ce0b4bcdc4dd110533f30b45071df17230aaec392cc482355e1 -82e3521bc9519b36f0cc020225586b263e4feb57b533b38d8e89ccf8d03f301d94da90efb4902002732fbf3876697f38 -b5d1ea69c97ceaa34a720bb67af3fcf0c24293df37a5f6d06268b1eabe441531606954ac2598a1513f64231af722b3a3 -956842696b411e6221c5064e6f16739e731497e074326ef9517b095671f52a19e792d93fe1b99b5a99a5dc29782a5deb -b19b5658e55c279eb4b0c19a0807865858cbec1255acd621f6d60c7e9c50e5d3ee57da76b133580899a97c09f1dd8dac -89e6a8b916d3fcc8607790e5da7e391f6bc9eae44cc7665eb326a230b02bc4eb4ef66e608ccc6031048fc682529833d0 -b1a210bc8070ed68b79debd0ec8f24ec5241457b2d79fd651e5d12ceb7920e0136c3e0260bc75c7ff23a470da90d8de9 -85b1954278e2c69007ad3ab9be663ad23ae37c8e7fa9bc8bd64143184d51aea913a25b954471b8badc9e49078146f5ac -98bf63c7a4b200f3ce6bf99e98543925bc02659dc76dfedebe91ec5c8877d1271973a6e75dad1d56c54d5844617313e1 -b7404b6e0f320889e2a0a9c3c8238b918b5eb37bcdab6925c9c8865e22192ba9be2b7d408e1ea921a71af3f4d46806d0 -b73cbbebf1d89801aa838475be27c15b901f27d1052072d8317dcae630ab2af0986e56e755431f1c93f96cd249f2c564 -95b2027302f7f536e009f8a63018da6c91ec2b2733c07f526cc34cbcfa2f895ccfd3cc70be89f4e92c63c7ddc2a93370 -9201d9ff5d0b1222bfa2345394f88ddf4fe9282acf51bee9b18b96bb724fdf8e736d7101acc2795a34e72f9e0545c9a8 -acbff7eb160f427d8de6f29feeddfa8994674e033a0ccdc8e8c73f9243968f1a6379da670a7340f422892d50c97113c7 -97ae8d03352c3729e1623e680dd9664f303b3bcfb844ef80d21e9c773a247967d27b86c9326af29db5eefd0bd3d4fac8 -8e53ae5c22f5bfa5fe4c414dad6a10b28a3e5b82a22e24a94e50ce3b2bf41af31e7ba017d2968811c179017b78741ef0 -b5ac7dd150247eb63dfb7dd28f64b1bf14426dc3c95c941e8e92750c206c4c7f4ad1a6b89e777cfe26ecb680dbf0acb6 -99ae2e4652ea1c1c695e7ea2022fd35bd72b1a0d145c0b050da1be48ad781a413dc20fbda1b0b538881d4421e7609286 -b8abe1fb3a7443f19cd8b687a45e68364842fc8c23d5af5ec85da41d73afb6840ef4b160d022b2dad1a75456d809e80b -842619c3547e44db805127c462f5964551f296a270ed2b922e271f9dc1074fdf1c5e45bb31686cec55cb816d77853c01 -902dff769391de4e241a98c3ed759436e018e82b2c50b57147552bb94baddd1f66530915555e45404df9e7101b20e607 -82e4f2ee7c7ca1ee8f38afa295d884e0629a509c909a5464eb9ea6b2d089205478120eed7b6049b077b2df685ec8ba48 -aa21a68b0888e4a98b919002a7e71e6876b4eb42227858bf48c82daf664c3870df49e4d5f6363c05878a9a00a0bcf178 -a8420cd71b1d8edd11ebc6a52ba7fc82da87dd0a1af386d5471b8b5362c4f42718338bcbc302d53794204a0a06b0671d -98c686bd3a994668fbbd80c472eed8aedd3ab5aa730c8d3ce72e63fb70742e58525437be1f260b7ecc6d9d18a43356a0 -aca0b2df9ec8ede0b72f03b121cded5387d9f472b8c1f3a5f1badd5879fb2d5d0bbb6af1a2dd6bdebf758cfceadbe61d -93b1abd9cb41da1422d171b4dbf6fbcb5421189c48e85c9b8492d0597838f5845198494c13032e631c32456054598e1d -a246ab3a47f7dc5caedc26c6c2f0f3f303ed24188844ab67a3da1e793d64c7c7fe3e5cc46efafbd791b751e71de0614c -b9b52095ca98f1f07f3b0f568dd8462b4056c7350c449aa6ce10e5e8e313c2516ac4b303a4fc521fe51faf9bf7766ce9 -8e2e9d26036e847c2a2e4ba25706a465ac9fbb27804a243e3f1da15dd4084f184e37808661ec929479d3c735555085ee -8b8c4f4ad5c8e57e6a7c55d70ef643083d4b8dac02716ea476d02dbbb16c702a2f2d5dd5efe3aec7704d2b8cdafe3959 -a800afea30d0df333805d295bac25419b7049d70044be00c7c85a92a0503ca471001bc1e6552323f1a719eb96616fc20 -868bced4560e1495b8527058ebc82a538b7cf806f8d8fe8eeed6981aba771de4d5e9f03cbfc7157d38b9f99cdea87b96 -86b86258b0c1feb988cc79f6c4d4b458ff39428eda292f9608a5fc4c3765782c8c23c66f82d7538e78e092cd81d69a56 -9370eac15de2555824c7d48520a678316a7bb672e66f8115ad7dbc7c7b1f35a7718e8fa0c35f37e3ef2df32dfa7ca8d1 -ae200bc5be0c1c8c6ec8e9fd28b4d256c6f806c0f270766099e191e256d67b9cceda2cc2fed46dfa2d410971a7408993 -af2428c77b2b9887ecde1ea835ed53c04891547fb79fe92e92f9c6009cdfffa0cb14de390532ad0ef81348b91798bd47 -a9069eef0316a5d13d1aa4cef0cf9431518f99b916c8d734bd27b789828ae03e5870837163ea6ad0be67c69184b31e8d -b1b1ce6d529f5a8f80728173b2f873c8357f29644b00f619c15111224377ae31a2efb98f7e0c06f5f868030aab78ed52 -b89c98beef19ee7f300e1c332a91569618ef8bf2c1d3de284fc393d45f036e2335d54917c762f7c2874a03fe4f0f6926 -8264f993dceb202f8426339183157e9e0e026d4e935efe4cf957eb14cd53edcdc866305fb1334cdf0e819b69eafbaccf -aebd113f73210b11f5ac75b474f70a2005e5c349345003989175dffa19f168abd7f0e28125b18907502fff6fcc6f769b -9993ad061066ca6c2bb29fe258a645089184c5a5a2ef22c811352749a199be3a3af3a0d5ce963febf20b7d9e63508139 -97952105000c6fc6c2dcae1ebdb2feae64f578d26a5523807d88e6caf1fe944b8185e49222d06a4553b3bdb48c3267a2 -82dd955f208957d74693bed78d479c9663f7d911f68ff033929418eb4a5c5dc467589ca210c1ba3c2e37d18f04afe887 -b816fc4763d4c8a1d64a549c4ef22918e045ea25fa394272c7e8a46dcb0c84d843d323a68cc3b2ef47a5bbb11b3913bc -a7a87ba4d12a60ee459aad306309b66b935d0c6115a5d62a8738482f89e4f80d533c7bba8503e0d53e9e11a7fd5fe72b -92b36d8fa2fdee71b7eea62a5cc739be518d0ecf5056f93e30b8169c3729a6a7ed3aa44c329aa1990809142e0e5e2b15 -8835b6cf207b4499529a9034997d2d3bc2054e35937038deb9c3e2f729ebd97125f111c12816d30b716b397016133c52 -acf14cd6d978ba905cf33b9839b386958b7a262b41cbd15e0d3a9d4ef191fcc598c5ab5681cf63bc722fe8acfda25ce6 -b31302881969c5b283c6df90971f4fb2cc8b9a5da8073662da4029f7977fbb4aaa57dd95b003a9e509c817b739f964e7 -b74669e1c3fa7f435e15b5e81f40de6cfb4ad252fcdfb29862724b0a540f373d6e26c3d600471c7421b60a1d43dbeb0f -861d01615cba6ca4e4ef86b8b90f37fa9a4cc65cef25d12370f7e3313b33bb75de0953c8e69972b3c2a54fe110f2a520 -a58a56820efaf9572fd0f487542aaff37171d5db4a5d25bfb1a5c36ca975eb5df3cb3f427589e1101494abb96b5e4031 -af13d0a6869ef95cb8025367c0a12350800c6bc4ae5b5856dcb0a3ca495211d4139f30a8682d848cb7c05c14ae9f48cb -8c385767d49ba85b25a3a00026dd6a3052e09cd28809d5a1374edf4f02dc1beed367055b0dee09102c85985492b90333 -b5129fc2fec76711449f0fcb057f9cf65add01b254900c425e89b593b8d395fc53bb0a83ddbd3166acc6d2c17f7fc2a4 -86bd01b3417d192341518ad4abf1b59190d9c1829041e6f621068bce0bef77ec3b86875b7803cf84ff93c053c2e9aad1 -a74fc276f6af05348b5fabccb03179540858e55594eb8d42417788438c574784919fb6297460f698bd0da31ce84cebfc -967ed3ec9f1fc51f76f07b956e1568d597f59840ef899472a3138f8af4b4c90861e23690c56b7db536f4dd477f23add6 -b9e678206de4fc1437c62d63814d65f3496be25a7a452e53d719981d09c7e3cae75e6475f00474e7c8a589e2e0c6bfa3 -b028eaffaa4ff2b1b508886ff13c522d0b6881998e60e06b83abe2ac1b69f036eece3ded0f95e9ae721aea02efff17b6 -935f82de9be578c12de99707af6905c04c30a993a70e20c7e9dd2088c05660e361942fa3099db14f55a73097bfd32a44 -96a1cc133997d6420a45555611af8bcd09a4c7dbddf11dbe65aab7688cc5a397485596c21d67d1c60aae9d840f2d8e48 -80d117b25aa1a78e5d92ea50e8f1e932d632d8b37bebf444dcc76cc409322fb8eface74a5dddab101e793ff0a31f0a53 -893229136d5ab555dc3217fb4e8c6d785b5e97a306cdaa62f98c95bad7b5558ed43e9a62a87af39630a1563abd56ec54 -b7ec1973ec60bd61d34201a7f8f7d89d2bc468c8edc772a0ba4b886785f4dadc979e23d37b9f7ef3ff7d2101d3aa8947 -b6080ca201d99205a90953b50fc0d1bd5efd5eadbfe5014db2aeb2e1874d645ab152fb4b0ff836f691b013b98ce7c010 -b546e66ec0c39037bbaa66b2b3f4704a6a72cf1924a561550564b6fcf41fbc2930e708cd5cac1d05e12a4b8ec93ff7eb -8abeed90a01477260f4b09fff8fa00e93afe727e8eed6f111d225c872a67e6ab61d0472ab6add3fe987744e16f7c5268 -8e02342d5cc1836ed21834b9ef81686172cc730f0412479db5f590b0ff7a729a0e986ffed16d6ecafd6b83d65922ca5e -b05660605cf8e8a10c8d3c77cccbe4e7179fa27cc829571f6b722a58e65e4e44d7fe977446118e9da2d2f40af146cc2d -942a00e006baba6d025cbd99297bdb0cbf3d84cddf849b1b5a9fe9ef1745352fad81313cce5d7622d6652096a8fa065c -aace8212b3d8dbe44ac97460a5938a3b803aca9bd00d8a643a859351daf391b22d1fd2a6b3e0ff83cc9ee272a1ad7686 -965a9885a5259197a75a19707a2f040e0fd62505e00e35ebe5041d8467596752aedf0b7ec12111689eceb3e2e01ecfc8 -81d58270a4e7ee0137cb2bf559c78c4fd5b3a613468a8157b6a9c5c0b6ca20a071b87c127d59cecc3d0359237a66d890 -af92b6354fbf35674abf005cb109edc5d95845e3d84b968e6001c4b83d548715dffc6723ac754c45a5ace8cd7dd30a24 -b112caa707f9be48fdde27f1649149d9456857f928ea73e05b64bb62d597801daac0b89165fea76074f8b5770043f673 -b6e7380746da358fc429f676b3d800341e7ab3f9072c271310626ae7f67b62562ff76c63bc9f5a1dbc0e0af87752408a -a45e9e8d0931207ebc75199aa0c983134aa97f771ff546a94a3367bcedf14486f761e7f572cf112e8c412018995fdaf4 -854381128de5bfb79c67b3820f3005555f3ee6f1200046ebbfaee4b61b3b80a9cebf059c363a76b601ff574b8dbf0e6b -aa1b828a8b015d7c879669d5b729709f20a2614be6af6ff43b9c09b031f725f15b30cde63521edda6cd4cf9e4ab4b840 -8f28f6b62c744084eeddcb756eced786c33725f0f255e5999af32b81d6c6506a3f83b99a46c68fc822643339fe1b91c5 -ac584e76a74cafe4298ca4954c5189ccc0cc92840c42f557c40e65a173ea2a5cd4ae9d9f9b4211c9e3dfd6471fc03a1b -a413365df01db91e6a9933d52ab3e5ed22d7f36a5585ad6054e96753b832e363484fb388c82d808d1e4dfb77f836eab9 -8a68c51006d45bf1454a6c48a2923a6dbeb04bd78b720bb6921a3ca64c007043937498557f0a157262aac906f84f9bf8 -b93ff8b6c8c569cc90ee00cfe2fc3c23cccea2d69cbca98a4007554878311635cb3b6582f91636006c47b97e989fe53d -b9a8a44d54592511d74c92f6a64d4a8c539a1d8949916ef3773e544f6f72c19a79577de9878433bd35bb5f14d92f411d -94f066a7e49ae88d497893e4ce6d34edc2dc0b42fe03934da5d4ed264d1620d506fcc0661faa90a6cf5083e1720beaaf -b42b102adef8f42c1059b5ca90fe3524dcd633cf49893b04b4a97a1b932ca4c7f305cebd89f466d5c79e246bad9c5ced -86b560d78d3c5fb24a81317c32912b92f6ea644e9bedfdea224a2f0e069f87d59e6680b36c18b3b955c43c52f0a9d040 -a3829fa7e017c934fa999779c50618c6fb5eafb5e6dec0183f7254708a275c94ba6d2226c5ca0c0c357b2f2b053eea93 -9337dda730076da88798fd50faed1efa062f7936a8879ea4658c41d4fcf18cee7120366100d574536e71f2f11271b574 -853d09a30f4342f5a84c4758e4f55517a9c878b9b3f8f19e1362be9ae85ca0d79c2d4a1c0c14f5eff86010ad21476a7a -b0bc74cb69bdd8fdffca647979e693ad5cbf12a9f4ead139162fa3263bfebef3d085aab424ed8c6220b655228c63c6b1 -88d8dc8faf3aab12ba7180550e6a047f00d63798775b038e4a43a3b40a421a3f5f152a7e09f28ccd7198bb8cefc40c07 -88db2e3b8746415d0c3e9f5706eda69a29d0b9ee5135ad006060be7787f4f1f7069e2e2e693c5e10b7c3d5a949085ae0 -b5bd830d2f1c722188dba2690d21b7b84b92cbdd873a55aaa966f1d08d217bfc8cffe8caea68868f3850b90b4ab68439 -b5ad4be0c9626a33fce6c8501297bdde21b07b88531451912ed41971a4c48fdd1036d8a4994a99a7fbba4a5901a7095e -b0e1337a2a1772191faa91302f1e562e7cdc69ba5b25139e7728ce778a68a7fa9817f852ec8e04a159122cff62992ec6 -b4fd4a4c1be8bc7e4e2bfd45404c35d65b75f45fb19ce55c213a8035b41f1ccbce9766f3df687c0d7cd6cdfc1abb00a5 -814bf565ece6e9e2a094ffbd101f0b9fea7f315a2f4917abe2bf7d070ed8c64a2987bd288385a42fd336ed0a70a9d132 -af860af861dc80894ed69f29c8601d986917ec4add3d3f7c933a5e9d540bc8ff8e4e79d0bb01bbc08fa19ef062f2890c -b66d33fcf3cd28f15111960ffc6ed032c3b33d4bb53d035ab460cc5fa7ce78872f0476d0bb13f1d38f2672347d2d6c4d -89603ae1a5dd7c526936b86a3b69b7b1d0bdf79ba3cc9cc2e542ec801a6126d1514c075d6ad119fe6b6e95544ffe7fbe -8a1b097f46a62d85cff354d1e38df19a9619875aad055cc6313fdb17e2866d8f837a369a9ee56d4f57995e2b0a94310e -8dc165d86c7f80b0fcd4b6f90d96cd11dc62e61d4aae27594e661d5b08ef6c91156c749de8948adfaf3265b1d13e21cf -98e3173772c3b083b728040b8e0ee01dc717b74c48b79669dd9d2f7da207af64ccd7e9244bc21438a5d4ac79b88e9822 -924d168099b6952d6fe615355851f2b474f6edfcd6a4bd3ad2972e6e45c31bf0a7fb6f7fca5879a0de3ea99830cfb5bc -95452f0b7efda93c9e7a99348e13f356bad4350f60fcd246a8f2aa5f595a9505d05ec9f88b1fe01b90ecd781027b9856 -b95e8af516bb0941fc0767ecd651ada2bc64cc3e5c67a1f70048c634260c0f2c0e55ed22948e1870c54590b36683a977 -82f7feb71e746d5ca24455e3f3e57e4eade92669ab043e877b836612efd3de82009f0555e5d8811bff9f2b75fc57a01d -87623c02caf590ea84cf4a84d1be501f89262e26eb463f2f94a2d3042889c051b058823c3367a989498e46ff25edab16 -b88da847b1ef74c66f923773ce8c920ca89751335fde17b3a98c0603862069a2afbf35b1552b43ad64dccea69f040ff8 -96b734758c823e5ce5b44625c252957e16fa09f87f869baac195956052dc92f933f377b288c7f63b8028751cbbdca609 -a23cc5fbbe5cb7c1d33d433cec4e502f6548412e2374e285d307f75e98280b0c0af4f46bba18015be88cdf7db8b1239c -8bd5bbe04bc929ca8f546e673803ec79602f66ec24298d3e3b6bf6f2c25180fc0032ea6f86c38a6e0ec20ff4eaafc7a1 -b95768ca113e5d57ad887a1cb5ef84ce89007ce34c3156cd80b9aa891f3ebaa52b74c0cb42919cfbcf0cb8bafa8085f9 -a117f99045f65e88acc5a14fc944f8363f466e4a64057eb8fc64569da5dd022a01f2860c8e21b16aff98aebdf89461b7 -895cda6503907c98c43477eaf71dfd26759032523691659f13662ca3a967d93bbc5be342d168223cef7e8a333987d6a0 -a084d77d913d3ec0586ad5df2647610c7ed1f592e06a4993a5914f41994a29c4a8492d9dce2e14d8130c872d20722920 -84a328b73c64137bb97a0a289b56b12060fa186ce178f46fe96648402f1b6a97d1c6c7b75321e4b546046c726add5a08 -b7c35087b2c95127ce1470d97bceb8d873a7ad11a8034cc1cba7b60d56f7e882fc06796048435a9586eab25880787804 -ab05e3394375ee617c39c25c0ec76e8a7f2381954650c94fbcd11063ea6772c1823c693d2d9dd18bd540a130d7b92855 -82ba5907051d84b37fd9d28f8b9abebc41fc4aaa334570516ca2e848846644016356d40fa9314543017d4f710d193901 -9170517b6e23ee2b87ff7c930cb02b3e6bd8e2ae446107b5b19e269bf88f08de5ded3d81a2ff71b632ca8b8f933253a0 -93dc0e3f6234b756cdbb3fe473b9214e970972e6bf70803f4e2bf25b195b60075177a1a16382f1dee612a4758aa076ee -b4b49fac49cdfccda33db991994a8e26ab97366545166cc7140aef3d965529f96a5dac14d038191af4fb9beb020ff6d5 -b826537670acdf7a8a45ef4a422d5ae5a1b5416ad0b938307518d103cc7ba78e495ea200adc5941414a70158a366e8a2 -8ae3588b1fbecbc769c761f0390d888e34773cf521d976ee335f6c813bf06dad38850871ac8a8e16528684f1e093d0c1 -ad9c00b8dccdb545315fbf26849135699c6aa3735f89581244281154c906aba80d20c1e7f18f41acc61e0565f8015a33 -954ce68146c05fc1c9e536add3d4f702335d93c1650b8c1fad893722a81f915eee2d38275dad00ce87f3f5bc90ef7341 -8243feaeff9a12f5aeb782e3dd68609ce04ecde897c90fd8a19c9c5dace3cf43bd5bc0f1624bf7fd2607ca0d71adbba8 -a8a1be55259cd27898d9d60a61998d8da2bf2d439ba6eedb61d6d16dacc4a81ec706b9196dfa080ba20701d2cd9fa1f4 -b0eac6212c7a62ef6062c30875fbe24b8e1a9d88854c035686f849a9eed4d17fbc9af27429eb7c3fd60b47a5e29f6783 -878561a88412e95f19f1cb8894be9d0ea4a2cdd44f343387f87dd37445e5777bceb643cebc68c910acb5e588c509cd2e -a57b6c347955d8b0057a87494223148ff9ff12b88e79dbd9d0aae352fe55e15ea57fcfb9add3d5d269ee0001d8660f20 -a07fa66340d4082585e4d72c77510c59b272e7a3345f4b1de6be7ff4a11ea95d712d035a7355fc8d2e571fa65fe8236f -b9d84a627462438e8ede6c453e3367bfaf81cff199d3e5157ef2bc582d358b28b5ccc3bc27bb73af98ef45179ea79caf -b14f26ea7ca558761cb19508e5940fbf5dcf2ad8555c5a03e8ff92481994072f523b1ab6b7176f698e2cfd83d4f8caad -800cca1cbb14e1fc230c7b420ff06864a934b082321bbf5b71f37340383923f23183d4fdc8fa2913928722b8892db28e -94790c950b92e971ec39e9396c3f32dee32a8275d78e6ea28a47130651bddc86a189ef404c5e8c210bd291186dee0df4 -ad7b3b3e377df64023b8726d43a7b6ec81e5a5e8c0943c5bebe5ab5ddd6597255f434a205c14ba90e9e5e3c462a1fe0c -86ff8156cc857a416e735009cf656b89da59b766b4c4e5a0c0165282b530c10657cc28cf5cb847696725c37ac48b69d7 -89cb64cf9294f68f01533660a2af2aec0ec34cc0b4a0cc36a128f2e0efb3da244981f69aede962f50590faeeb9a5da01 -a2ea5a94a524bb8e6f767017246cd1af9d87c9abb9894e91c4e90c34c5161be6179b49dafcab9cff877a522c76beb145 -b5d9abf29ed6030a1e0f9dc19be416c45ba8cb5ed21aff5492233e114035715d77405d574cd62f2716285e49f79b9c99 -ac441cf6104473420babdfb74c76459cbea901f56938723de7ad3c2d3fadb0c47f19c8d9cb15a3ff374e01480b78a813 -abea34bd2d36c5c15f6f1cdd906eb887f0dd89726279925dbe20546609178afd7c37676c1db9687bc7c7ea794516af03 -8140abfd0ec5ca60ef21ad1f9aabbb41c4198bac0198cb4d220e8d26864eedb77af438349a89ca4c3ff0f732709d41a9 -a5a25abf69f3acd7745facb275d85df23e0f1f4104e7a3d2d533c0b98af80477a26ac3cf5a73117db8954d08f9c67222 -b45ac8d221a7e726ad2233ba66f46e83ed7d84dbe68182a00a0cf10020b6d4872f3707d90a6da85f6440c093914c4efa -80f586dfd0ceaa8844441c3337195ba5392c1c655403a1d6375f441e89d86ce678b207be5698c120166999576611b157 -b8ce52089e687d77408d69f2d1e4f160a640778466489d93b0ec4281db68564b544ec1228b5ab03e518a12a365915e49 -8990f80bae5f61542cc07cb625d988800954aa6d3b2af1997415f35bd12d3602071503b9483c27db4197f0f1f84a97ac -8329858a37285249d37225b44b68e4e70efeef45f889d2d62de4e60bd89dde32e98e40e2422f7908e244f5bd4ffc9fe2 -8d70c66ea780c68735283ed8832dc10b99d3daeb18329c8a44a99611a3f49542e215bf4066ff4232d36ad72f1a17ccc3 -a3b2676cc8cdf4cc9e38c6cb8482c088e5e422163357da3b7586a3768030f851ad2a138eeb31584845be9ffb8067fc00 -95b1fa74e9f429c26d84a8e3c500c943c585ad8df3ce3aea1f6ab3d6c5d0ed8bb8fa5c2e50dd395fa8d4d40e30f26947 -b1185f2ac7ada67b63a06d2aa42c4970ca8ef4233d4f87c8ffa14a712a211b1ffde0752916bfafdfa739be30e39af15d -8705a8f86db7c4ecd3fd8cc42dd8c9844eab06b27d66809dc1e893ece07186c57b615eab957a623a7cf3283ddc880107 -af6356b372f0280658744c355051f38ff086f5563491fc1b3b1c22cfec41d5c42b47762baeb9ee6c2d9be59efd21d2b7 -86bdd4527b6fe79872740d399bc2ebf6c92c423f629cdfcd5ece58e8ed86e797378a2485ead87cbb5e2f91ba7b3fbda1 -a900f0be1785b7f1fda90b8aedd17172d389c55907f01c2dfb9da07c4dc4743cb385e94f1b0fc907dd0fedb6c52e0979 -a9f59f79829a9e3d9a591e4408eaec68782c30bc148d16eb6ae2efccb0e5478830bbdaa4ae6eac1f1088e7de2a60f542 -99cf54a69ad5e8c8ec2c67880900e0202bcc90c9815531d66de8866c0a06489ea750745cc3e3aa1c4d5cb55dcd1e88f7 -8676246a4710d6d73066f23078e09b3fa19411af067258e0b8790456525c02081727b585d6f428c8be285da4aa775a4b -b596c7014fe9214529c8e6b7602f501f796b545b8c70dbf3d47acc88e2f5afd65dccef2ef01010df31f03653566b16df -a12205c6c1780fc8aebdd98611e12180005b57750d40210b9eff0396d06023bd4ff7e45f36777123ff8bed7c5f52e7a3 -ae7dbd435bba81685d5eab9abc806e620253da83e56b4170952852d442648a5d8743f494a4b0fc9d606574f87895b0d6 -9786257b1726b7cdc85219ca9eec415f98f5a11e78027c67c7b38f36f29fe7a56443570fdfedc1d9293a50e4c89d89f6 -aaf0515070d1ca92aacdf5fac84193d98473d8eb2592381f391b8599bcd7503dbf23055324399d84f75b4278a601c8b2 -b31654dbf62fbbe24db4055f750f43b47f199a2f03c4d5b7155645276b2e456a218ca133743fb29d6f1a711977323f6e -8f4d39106ecdca55c1122346bdaaac7f3589d0cf0897a6b4b69e14b4d60550fd017876399401ce7c5d35f27da95f50be -8a7bfdb48cd47afe94aff705fac65f260b3a3359223cff159b4135565c04b544dd889f6c9a6686f417e6081ad01e0685 -967ba91111e5e08f9befcbaad031c4fb193776320989f8ede4018254be0e94586254432d3dbae1455014f3a2f2549d01 -a9db52352feeb76715a35c8bed49fb3a8774c9c8e58838febf800285fd6c4938ec162eb8457029e6984d8397dc79ea19 -811794e6bfe2539e8f6d5397c6058876e9e30763ad20dad942bb5dbcab2f16d51718ce52bfb4de17889ba91da1b85bcd -a6db0f65a6dc8b8cc2312a3e0146d8daf520255bb12f74874c05693914e64e92be0cd53d479c72cb2591e7725dfaf8b0 -918d21bfa06d166e9eb5b7875c600663a0f19cc88c8e14412319d7aa982e3365f2dff79c09c915fc45013f6b3a21200d -9894852b7d5d7f8d335dd5f0f3d455b98f1525ad896fdd54c020eeaf52824cc0277ecbfa242001070dc83368e219b76d -ad00acc47080c31fcc17566b29b9f1f19ccaae9e85a312a8dcc0340965c4db17e6c8bd085b327eaf867f72966bf61452 -965e74649e35696744ecc8bed1589700bae9ca83978966f602cf4d9518074a9aa7c29bc81d36e868a0161293f5a96e95 -961e29a239c2e0e0999b834e430b8edfe481eb024cc54ffaffd14edaf4b8522e6350dc32039465badfff90dcb2ba31cc -943dda8fa8237418a07e311efde8353c56dd8ec0bfa04889ccdd7faa3dee527e316fdc60d433a3b75a3e36ca2aa9d441 -a0ed4c102e3f1d6ebf52e85a2bc863c1af2f55dc48eb94e40066f96964e4d37fff86db2cff55a8d43d517e47d49b5bd7 -9045770ad4e81345bc6d9a10853ee131232bf5634ef4931b0e4ba56161585b4286876bc8a49b7b1f458d768718cb8ebf -b0dd430295ff28f81895fde7e96809630d1360009bbe555e3ac10962de217d93ead55a99fd4f84d8cadd1e8d86d7b7ef -95ced48419b870ea4d478a2c8db699b94292f03303f1bf4560b5b1e49ca9b47e7008514fe0a9cf785717f3824567e1b2 -a7986e0e389e8aef6aac4a7a95e2440a9af877ae2bc5ad4c5f29d198ec66aa0db1d58c451e76ae70275a2e44c3d3fa68 -85a8490faf32d15de12d6794c47cc48e02428af1e32205e0742f8299ea96b64bcd6d3b4655272afa595eec74ecbb047c -b790d7fb1307aacc2d303d9b6753a9773252b66c6b67763cf8841c690cbccc4866ffb5fec1c068b97601a7953fe0f7e8 -afcc4011f8c53f10d63c29b74d9779cd75c861e01974c28a4ec2cbb909b67a1b2287ead175231343c936ad75dfa416ff -918058bffdecc1ae8779dccf1d874bb9e28edbe34c8b5954a8da64a848858d2f0776437b423baf4e731f3f5fa05a2841 -ab554db549aa36dfa9f966a5ed6be8267e3aa9ced348695f3dafc96333c6dbb48ef031693aafd59d1b746ecd11a89c51 -ac4ecf746b46b26a7af49cc9cc1d381e1e49b538dbd7fb773ce6b1df63ae31c916693cca8a90fb89f1e7ec5e0e8dd467 -a8de66d48f16b016f780a25ba25bd6338fd8895a1909aabcfb6e70f04ff66f9866e6e2a339bcbfa4bfba4070a6a8db26 -b4b49374eff6dac622e49b0e9c0e334ecbec513a96297f6369696ad39e5ec0de81a1417f6544be866c9f60957a9ba09a -b8023968549ebab6c1e7a8e82954a5b213bec50bbf35b36697a8d4fd75f9e12d510b365962aace4c9978c5b04da974a7 -8d4bc016026dd19e4059d1c5784897cefa47f7ae2ed6dfa2b3c14a852fff2b64abc09549d106584e0daed861a2d6d6c2 -85e26f433d0b657a53da4c1353485e0c2efa092484c5b8adb3f63dc72ee00be79197ebef7937b37a6a006571641cd6af -abb37a917301e68328032ff4715abc0fee32e5f5be68232ca8bf7ffb8732bc47504e75b40bcc0a7c7720b71496fa80af -9837c8d2660522c0357f5222777559d40321a1377f89ca1717215195bad4a348a14764bd87fa75f08e1f6263e9d08982 -97e06f971b4c56408ed5f1de621d233e6a91c797f96ec912737be29352760a58831aaf1f64e377c3ed9f2f4dc8ad1adb -a12d211304da7b91101513d57a557b2504069b4383db8ecb88aa91e9e66e46e8139dadc1270620c0982103bc89666215 -aab74ba48991c728ba65213e8c769e6824c594a31a9b73804e53d0fda9429403ff3d9f6ea5ef60884585d46356c87390 -92f19be2b7adf031f73611282ad33e462852f778c5e072f689dd0e9458fa6ebccfae02f2b2dc021802c9225035862468 -953bb843c48d722604576cef297123755cef8daa648c30c3a678eada8718dfdb16e71cc3e042a51fedc80577235c2563 -86f509e3c1b9ee9a3b95e6da8516b47feb8c8a83403984228f4903c7ee1ee4f03addcb8fe86283af1196a54b36b9470c -903d793a377e98e2562c49de33e3fbf84bf99211925e7002a4f688470db655884e1efe92782bf970ffa55d9c418ef3b5 -a41b65681ed7f10987a7bfdf9e56b010d53683819d845d880fc21b2d525540605c5823e75c434f17b5a0d08a091c1564 -971be802de51cfc0d10a96be7977c037873f19334ed4ed4904b7675aec8bfa1f8956cd0150b07064caf18229ffd1ccd9 -b253ebe4f82cdbefbc3ef816d40c497fe426a9f0f0f170e783fa4a05ae6dabdfa8c448817a24e723a314b43e76a7c422 -86f397c95025489929ce9230b1466b5c330ec7c58a3c7e3153d6d05bcb8348a13398908e192590b8812f5c5ff09c133a -a0713983a3dc9f10b3833687cd2575de2fc63c4ad8d2f54ff85c6db23dd308daefef1bd1e51eec26732f77c1f37ba793 -8249a1d53ec92f311f4fa77e777800d777f3e9d4d452df740fc767fa7b0f36c8dce603d6e6e25f464c0399b8d0b93c30 -a73d0a206a62922f07b928501940d415e5a95716ee23bf6625b01ff2cd303f777adfa373d70279ba8a30fbb4c99a6f1f -b1106b407ecf234e73b95ff58ac9fdf6709ad2e763b58f0aacc5d41790226d441b5d41405ac03a0641f577848a4f5e8e -b009963ccc7b2d42792f09ab7cb0e929503dd1438f33b953104b4de43274ca3ce051554d10d7b37041b6f47d7a2dab6f -b744512a1b3c7ef9180b095c6a0c5bc16086a50020cf20dc2216bbff24d91ca99b95cb73070444dafc3ab45c3598960d -a0209669ffeddc074d35cc6aa2dac53acac8e870f8a8a5118e734482245b70c3175f760652e792118fdddac028642259 -8ddd3e0d313da17292fdcc1bbc6e9d81189bb1d768411c6fe99801975eddb48dbf76699dcf785cac20ab2d48e392c8fd -8392aa285b8b734aa7a6e0f5a1850b631ddf6315922e39314916e627e7078065d705ff63adbc85e281d214ec7567863e -b655a1fff4dba544a068bf944e9de35eaaa6c9a0672d193c23926776c82bebed8aa6c07c074b352882136b17abdab04b -af5095f40d1e345b3d37bebee3eb48c5d7b0547f12c030d5bfe8c0285943e0a7a53a186f33f791decba6a416cba0c5c9 -8223527f9eb3c8ff52708613cd2ee47e64c0da039cea3a0189b211dc25e9bfa3d5367a137f024abe94f98722e5c14b67 -afdb106d279273edc1ee43b4eead697f73cb0d291388f7e3fc70f0dd06513e20cc88b32056567dcc9d05364cb9ca8c58 -9319eac79ff22a2d538dcd451d69bca8aa8e639979b0d1b60d494809dbd184a60e92ad03b889037a1ac29a5547423070 -b79191ce22dbd356044e1777b6373b2d9d55d02b2cc23167642bc26d5f29fd9e2fb67dce5bd5cf81a602c3243bedd55c -988e0da1e96188ffd7c5460ecdf2321f07bc539d61c74a3292c34cb8c56dbafbca23eb4471a61e8e64e9a771a49fd967 -b0792b6cf4b10f8af89d3401c91c9833736616bb9fe1367b5f561c09d8911fb5a43b7a4fd808927b33ab06e82dd37a28 -862f68ea55206023ca470dbd08b69f0f785fcbabb575a1306ff3453c98ffcad5fd6ead42e8a1f9edf14c6fd165ffd63a -815ff0898b1330ac70610180c0f909561877888ff10def749a1e65edf9f4f7cea710a757c85241dfb13d0031efb5e54b -aa6e6ce21776ea4507d452ccdaf43a161a63687aae1cb009d340c9200e5646e9c2de4104dfd66b8e55dfa6de6ee83e4a -8e8f3d3403e0256ecc254b9b1464edca199cad3f3348002d744721c345a1a3c7f257c3587d2229774cd395e26693d1ba -90483e28985e4a0f7a3cb4bc5e865b9d408b94cd2146c04aed00b48a7ab80a28deb05efec320817d63578d4f953bd137 -84fb2a762ba29193b07f1dd84b3f69153cedb679b66ad04f8a4adf01c14f115163a107e6db23aaf0f0c9687824ded197 -b4a23922bf4302cc9a6583f252a1afa026c87c132b9ae44cc1f75a972cb6ae473447c500827906f9b677617ddd6fb473 -809bb9edbbe3a2769165f029f2a48b6e10e833eb55d8f9107c4a09ca71f0986dc28f3bf4ead9cab498086eb54c626bbf -a0459dbb08db4155d16301933ec03df77c4f835db2aa3f9697eeb2bb6fcd03337fab45fa43372a469fecc9a8be2e3119 -a638eaace7f21854de49f4db6e4ea83d2983751645e0fb200c5e56561f599fd37dac70bdbd36566fdd10d4114fbb9c2f -a3a27bc2728390643a524521bf8ef3b6437cfba6febfd8bb54f2b6ecbafafb96196d3dea279ce782efd97b212f364ef5 -b86693b3ea23ea6b2c4d52554f61ef39c0ef57e514ff6da80c6e54395df8376e2e96b9d50e4ec301c59e022c5c5610db -af4d7cd678d79e67ae19789d43331dff99346cd18efff7bab68f6170c111598d32837372e3afe3e881fd1e984648483e -b8735a555ba7fe294e7adc471145276b6525de31cda8c75aae39182915129025fb572ed10c51392e93c114f3a71bd0be -b1dfb6dbda4e0faaa90fe0154f4ddaf68ee7da19b03daad1356a8550fca78a7354a58e00adeecb364e2fd475f8242c24 -9044b73c1bd19cd8bb46d778214d047f5dd89b99b42466431b661279220af5c50c0cffecebd2b64c3d0847a9c7a8b1ec -891f0d162651a0aa0d68fb1cc39fa8d77fd9f41ff98b5d6c056c969c4bac05ba8c52cbfa7fbb6ef9adfe44543a6ec416 -8920ae1d5ac05bf4be6aba843e9fc1bc5b109817381cdd9aa13df53cabea319a34ee122dcb32086d880b20900ff28239 -abb14023142876cbc9301336dced18c7878daa830070b5515ff4ac87b7bf358aa7ff129ebbf6fb78e827570a4142661f -a74b15e178cf91cde56eab0332e62d5ff84c05fcc849b86f45f94d7978bf9c0fc72a04f24d092a9d795ca3d976467f46 -806829621a908ca9b6433f04557a305814a95d91c13152dca221e4c56bfaa3473d8bb1bacd66e5095a53070f85954278 -b09a3c185e93869aa266a0593456a5d70587712bca81983dbc9eebbb0bd4b9108a38ae1643020ecf60c39c55bb3ac062 -b2bbe8f5361a3ecdb19598dd02e85a4c4c87e009f66fee980b4819a75d61f0a5c5e0bdc882830606cb89554ef1f90ead -825e16cb54fc2e378187aedae84a037e32903467ac022deb302cf4142da3eda3ead5b9f3e188d44f004824a3b5d94fbe -8b39d4a11d9b8ba885d36bcdb6446b41da12cfd66cb22705be05ab86936464716954360cc403f8a0fd3db6d8b301cb59 -ac19d453106c9121b856c4b327ddb3e3112b3af04793df13f02d760842b93d1b1fbdff5734edc38e53103a6e429a1d1f -b1cacbb965ec563f9e07d669ffc5e84d4149f1fb9fcfbc505788c073578c8f67956fb8f603e0b9a9d65e2d41803038ce -b7612d9e7dc930bff29191d1503feb2d6451b368b69fa8ecb06353c959967daccdc262a963f01c7fb95496f1bd50d92e -93f8fceb65ea9ef2052fa8113fb6720c94f0fed3432d89014ee5ad16260aeb428aadea0d1f1e002d2f670612ba565da3 -b3eb9213752156ed1fced3bca151fd0c630554215c808b9a0938b55fed42b6b89f9b76bc698f3e37c3c348d2395dbed1 -b46ab3553ef172ae40fc21c51d1d7eab8599a67f2f89a32a971aa52c2f031664e268b976dd2f7dc2195458fcf4bf3860 -8fb66f2c67ca5b6fb371c7d04592385a15df0c343857ba8037fe2aa9f2a5d4abc1058323ff9652653261b1c7db0edc24 -a7dfdbbf0b14e4af70fdb017875cdc36ad2108f90deb30bfca49301c92cbf821645a00ade1d1ee59a1a55a346675c904 -856199cad25ec80ee0327869077f272e33d59bf2af66c972e4a5839ec3b2a689e16f7fd0a03a3138bec458fcff8edbea -a2842ac5a715c2f48394988c6f84a6644c567673806feaa575838e906138c1b25d699e1b6ffdfc9be850b15da34077e4 -814b448ada88f769de33054c3c19f988226317797acacdbe55ed2485b52cd259ac5bcbee13f9de057eee33930a7fa0c0 -b49de8dd90da916ed374ca42665464b6abe89ff4453168921f5a7e5ddd3dcfa69422782e389e586e531fd78a1f236a8b -851f9d942b4c8ffc020c02c7fbee0f65ef42b1ab210ab4668a3db6aa0f8ab9eedb16f6fd739a542cc7e3cc03172b565b -a5128c155b8062d7fa0117412f43a6fdc2de98fa5628e1f5fc1175de0fa49fc52d015ec0aff228f060628268359e299c -b0765849127cc4ce1a1668011556367d22ce46027aa3056f741c7869287abcaccf0da726a5781a03964a9ded1febf67d -984562c64f3338ffe82f840c6a98a3dc958113f7ed28ee085af6890bbc0cd025723543a126df86f379e9c4771bb69c17 -8087fe60a9a22a4333f6fbe7d070b372c428d8c5df3804bb874b6035e5602c0693757fb30a9cd5a86684b5bca6737106 -a15e195b5850f7d45674cdc3bd74f972768b46fe9473182498263edc401745a8716fc532df8fc8c1375e39e391019226 -858ec10208c14a67c4156ea9c147f36d36c4fa0a232195b647e976ba82c8e16262b2b68d31e3b4702070c3dc701bccb5 -84bf3fb83c003380ee1158e2d6b1dca75cd14c7b2a32aec89d901f0d79e1475aa0827cb07cba1784a6bb0d37f6ca5cd4 -91e69f5392648e7f7c698059a0fc4b8478ab8af166d3842fb382ec5c396daa082ee3b2cb0192da3c9d90f6523c4c039d -8f7299f451c5e641d6fd961946b7a6ba4755685b2a40164e6276c25aefc66715b92492097a191813d39bb4405dc5da36 -ade2cf04ff6c94c1019bfa1e0e8f580696230fa6ee9695c4772e5a44501b2fffdd765ec7cc71ba14b83559ad62cc0fc5 -85fc98ecf469d6f98c8b3e441680816f764de39001a249bc7162f990c5a5354683e849164d4fc9287ee516780cdcd436 -928d118188120d038c37abdbe66c05adaa87f1cf9957dee2783b09fa91c4c43a7b0d0b2b6c5f4dea57e3ec8af230e84f -8025f71cf8d3085d6ea5104dddea8fa66cdb8527e40db01472469be021632daf22721f4acf1a8698a53439fe2f82596c -83266fffb12b3c795a6b551ac2aa7d9a29c183f861e78768c11286a04e22bd423bba05a68775bd77273e3ca316a4318e -95fd0c69c2d9df4e795c7ba71ed71a9d9f2878cd7e3a64be7b671d9611649fd41d29f8bdab642ba19cbd3db660d6a7e7 -92a912cb4d5ef4b639876daf4289500c4ebdbd80aff07fd93dc3eea645f084f910e5c02c10492a37f16acaa7e646d073 -b3d2622c987189a0873932aaea8b92ebb6e9e67ff46e91a96bf733c3b84175fffe950f8f4622cc4fa50f116321c5537f -a98f9a40054b31023a8f7549a44cae853b379bbfe673c815b8726e43ecd11a96db40b20369d712cbf72ffab064ecfac5 -b4e9a38e371fc21f4b8a3d7ad173c9ffad0554530dc053365d9555ddb60f5c9063c72ff4c65d78b091af631a9e1ee430 -875a31aee4ba19e09f8c2754fab0b5530ec283c7861a4858b239a12432f09ef155a35fedb0bc33eac2117c7e62f1c7ee -95edd0d1a6e94af718590756b5c5f5492f1c3441ecc7fa22f4e37f4ec256b9fffd2fda4c11fc1a7c220daee096eb1ff8 -b35fdc435adc73e15c5aaf4e2eea795f9e590d3e3ee4066cafa9c489ee5917466c2a4c897a186b2d27b848c8a65fa8a8 -94a5ce56f8d72ec4d0f480cb8f03e52b22f7d43f949a4b50d4a688a928ffd2c9074ecbab37733c0c30759204a54f9a6a -987562d78ef42228c56074193f80de1b5a9ed625dd7c4c7df3bf5096e7d7b08e2ee864bd12d2ea563e24fa20ad4d30ef -95a8218405038c991ace2f45980dbb1efa9e4ad0d8153486b0213a89e4d7e3cac6d607100660784627c74f90a8e55482 -b6a29d566f5a924355b7f7912f55140e1b5f99f983c614b8a92814ce261f2750e8db178866651ea3b461fb8f92890b14 -afdacc0a13da0446a92455f57a42b3ba27ba707f24171727aa974d05143fae219de9e2eb7c857235dd9c7568f43be5a8 -862a7dc25f7cfa4a09aeca0ed2c9c5ee66189e119e226720b19344e231981504e37bca179aa7cad238ee3ab1386aa722 -a336364e76635f188e544613a47a85978073f1686e4ee7a8987f54da91c4193540ac448b91d07d1fc5c7a8538b1f1688 -8f1ddca9638decd8247c1ce49c1e6cf494d03d91c4f33e48a84452d12b6736e8bd18c157068dfeff3a90977af19e5b1e -96ae91b9aaf00e437c18ddfc1aef2113ee278153ba090aedeb3f48f1e66feb8897bb1ac7f5ffeffc3be29376dd51e498 -8230b5bd9067efb6089e50213f1cc84da892e6faf0b79d5e4768c29303a80b1b754cb09d17a21933aba4c5f32070878a -a79dfe217faec7b4d3cf97d8363949efbc6f3d2c6bbc25df2c7bb8b7fd2521e6d3fa76672bfc06de6f426290d0b3cc45 -8290bd36552609d6b3ac9ccb57ff8668fc8290548eecdcee9a231f1125298c20bd8e60f033214dfbd42cd3c8642c699b -8945db9e8ec437c5145add028d25936ee8823ceb300a959402d262232ae0cbd9a64c1f0a1be6aed15ff152202ea9a70c -949e232b48adeaf57bd38eacb035267d3e78333c6b4524cab86651a428a730baf9c27ff42cb172526d925de863132e82 -98917e7a5073a9c93a526399bb74af71c76958a74619caccf47949f8fd25962810a19e399b4efcba0c550c371bea3676 -b5b144e0707aefc853ea5570bd78dedc4e690cf29edc9413080f28335ac78022139bfe7f7d6986eb1f76872bb91e82ad -949945072a08de6fd5838e9d2c3dc3200d048b5d21183020240fa13e71a1a8d30e6bfee4e6895e91d87b92f1444d0589 -b351a03c7c98506ee92d7fb9476065839baa8ed8ac1dc250f5a095c0d4c8abcfab62690d29d001f0862672da29721f16 -a82d81c136bc5e418d1fba614cb40a11f39dc526e66a8b1d7609f42fea4c02b63196315014400084f31f62c24b177cbd -87d51c907fdcdf528d01291b28adfee1e5b6221c6da68fd92ab66126247cd8086a6bcffff0ea17e7b57b0ba8d01bb95d -a2a9a1a91dfd918f36c1bfeeca705ea8e926ee012f8c18d633e50ec6e50f68f3380ef2ee839e5a43cf80fbb75bfb5304 -86f22616caed13c9e9cd5568175b6b0a6a463f9a15c301b8766feca593efa6e5ee4c7066e1cd61b407c0be12b3d8236a -b57e0a2c42790d2fd0207ef6476a433fca0cf213d70840c4af1ad45833f23fca082d21a484f78af447a19a0b068ea55c -8ae9bda5d85e6e3600dde26379b7270abd088678098506b72196ac8f9ce5b0173bc9c7ff245c95cbab5b5b967bcb043b -95c7d11f6c874f59ba632b63ce07a7a9d917a74d0b89cefa043f52aa1a7fe2e81c38dea0b20378264b5b4f64039932bc -ac7dee7479f50722526ea1c9d4e2f1a4578d1b5cce2092a07722069c96bb4da295de1c4f16e21005276e3b3f1624ac5a -89b8aaa49bd18b09f78fc5a1f3dd85d69b5dfcff28fc6d5a92b1520bc54107b8b71bb71fd6e0bde10e0a5809c633e5d2 -8982cb43fe4d3488c55e8c08b935e6c8d31bb57e4f2aeb76d6319470cce99ebf7dc2f116ac15b9d845ab1bc16aa6a583 -a12c63f48e27b1a1c83a32992642f37fb5b89851a35e80f6d1f9bc483cb25acd0e12b1dcf68781ae0cc861f002368bcb -aa6da92a4b4fa229afc8007abca257ce0ff5fad3b1ccfe5d836b9b52ff6b72575a0b915a759403b993733b16a47fdb15 -8bf706a92fe54f15d633b9463926b874dd43e28aaeca3fe2353fb58ad7753c8a293c56b0e94176070e8a9ec7401073a1 -b81e86de4bb5c1046e40cca79585c5b98c8673626fd3a28e563c5a3296256c2f7086522ae95cbabfaa8f1a8f7eae6272 -ad10f895b05d35cb251f78cc042d3f0969a8b6b3f289ddb4b016e0b8e06bfffc3a3e1afa9b0cc548f8c092832bb766bc -ad993aceb68d5217cfb07f862956cde83d05dec5060fc7a8fbfd37c6bfd5429ba69bdaf478b6cd01c323a06793dcd9fa -83da9c9a8fcb2775df0777aceabe90642a2df1c6abc646566e954f42d6e43455b00b101ec5ef58850c8d4b3100222ca1 -b55484f339fe7c7d107e70432601f4a34e1cc02ae4de5d18b99e5aa995f7b3710fc745769b85c1af803d457491dd8ce3 -8009d80593e82f3e751cec9e7e495fd29ad6f45f8d3ae513bec998b43c49fed74c44229c6f27c421e80c65413b897644 -9868081bbcc71192f7ff8dcf99a91dcd40f96556fbd6f285bdbfdfc785f604d8bf75c368c59db5ac8cdcc663087db53a -a04b1e91af025b4387ee0a2d790a1afb842e46f4c3717e355578efd1f84fea78782c6f7944b4961268de7f1ac71fb92b -a7b6301ddb9738b89b28a36d29d5323264a78d93d369f57ddab4cea399c36018a1fcc2cc1bfadf956a775124ae2925bd -a6cdb469014b33c590a07a728ce48f15f17c027eb92055e1858a1f9805c8deb58491a471aaa765de86a6bda62a18aef4 -828a23280ec67384a8846376378896037bd0cb5a6927ff9422fca266ee10a6fde5b95d963a4acfa92efbb0309cdb17b4 -b498ec16bcdb50091647ae02d199d70c783d7c91348a1354661b1c42bc1266e5a5309b542ef5fdf5281d426819a671cb -806533fb603e78b63598ff390375eebe5b68380640f5e020e89a5430037db2e519ab8ae5d0d0ad3fa041921c098448e1 -9104ad119681c54cdee19f0db92ebfe1da2fa6bef4177f5a383df84512d1b0af5cbe7baf6a93ad4b89138cd51c7c5838 -ac695cde30d021d9f4f295109890c4013f7e213d2150c9d5c85a36d4abfdca4cdc88faee9891e927a82fc204b988dcd9 -a311c244df546d5dc76eccb91fe4c47055fc9d222d310b974d4c067923a29e7a7f6d5a88bfef72fd6d317471f80d5c82 -89e4518335240479ad041a0915fc4f1afaab660bd4033c5d09c6707f0cc963eb2e6872cabc4a02169893943be7f847d4 -a8ad395b784c83aacf133de50d6b23bd63b4f245bb9e180c11f568faca4c897f8dbda73335ef0f80a8cb548a0c3c48fc +8b997fb25730d661918371bb41f2a6e899cac23f04fc5365800b75433c0a953250e15e7a98fb5ca5cc56a8cd34c20c57 +83302852db89424d5699f3f157e79e91dc1380f8d5895c5a772bb4ea3a5928e7c26c07db6775203ce33e62a114adaa99 +a759c48b7e4a685e735c01e5aa6ef9c248705001f470f9ad856cd87806983e917a8742a3bd5ee27db8d76080269b7c83 +967f8dc45ebc3be14c8705f43249a30ff48e96205fb02ae28daeab47b72eb3f45df0625928582aa1eb4368381c33e127 +a418eb1e9fb84cb32b370610f56f3cb470706a40ac5a47c411c464299c45c91f25b63ae3fcd623172aa0f273c0526c13 +8f44e3f0387293bc7931e978165abbaed08f53acd72a0a23ac85f6da0091196b886233bcee5b4a194db02f3d5a9b3f78 +97173434b336be73c89412a6d70d416e170ea355bf1956c32d464090b107c090ef2d4e1a467a5632fbc332eeb679bf2d +a24052ad8d55ad04bc5d951f78e14213435681594110fd18173482609d5019105b8045182d53ffce4fc29fc8810516c1 +b950768136b260277590b5bec3f56bbc2f7a8bc383d44ce8600e85bf8cf19f479898bcc999d96dfbd2001ede01d94949 +92ab8077871037bd3b57b95cbb9fb10eb11efde9191690dcac655356986fd02841d8fdb25396faa0feadfe3f50baf56d +a79b096dff98038ac30f91112dd14b78f8ad428268af36d20c292e2b3b6d9ed4fb28480bb04e465071cc67d05786b6d1 +b9ff71461328f370ce68bf591aa7fb13027044f42a575517f3319e2be4aa4843fa281e756d0aa5645428d6dfa857cef2 +8d765808c00b3543ff182e2d159c38ae174b12d1314da88ea08e13bd9d1c37184cb515e6bf6420531b5d41767987d7ce +b8c9a837d20c3b53e6f578e4a257bb7ef8fc43178614ec2a154915b267ad2be135981d01ed2ee1b5fbd9d9bb27f0800a +a9773d92cf23f65f98ef68f6cf95c72b53d0683af2f9bf886bb9036e4a38184b1131b26fd24397910b494fbef856f3aa +b41ebe38962d112da4a01bf101cb248d808fbd50aaf749fc7c151cf332032eb3e3bdbd716db899724b734d392f26c412 +90fbb030167fb47dcc13d604a726c0339418567c1d287d1d87423fa0cb92eec3455fbb46bcbe2e697144a2d3972142e4 +b11d298bd167464b35fb923520d14832bd9ed50ed841bf6d7618424fd6f3699190af21759e351b89142d355952149da1 +8bc36066f69dc89f7c4d1e58d67497675050c6aa002244cebd9fc957ec5e364c46bab4735ea3db02b73b3ca43c96e019 +ab7ab92c5d4d773068e485aa5831941ebd63db7118674ca38089635f3b4186833af2455a6fb9ed2b745df53b3ce96727 +af191ca3089892cb943cd97cf11a51f38e38bd9be50844a4e8da99f27e305e876f9ed4ab0628e8ae3939066b7d34a15f +a3204c1747feabc2c11339a542195e7cb6628fd3964f846e71e2e3f2d6bb379a5e51700682ea1844eba12756adb13216 +903a29883846b7c50c15968b20e30c471aeac07b872c40a4d19eb1a42da18b649d5bbfde4b4cf6225d215a461b0deb6d +8e6e9c15ffbf1e16e5865a5fef7ed751dc81957a9757b535cb38b649e1098cda25d42381dc4f776778573cdf90c3e6e0 +a8f6dd26100b512a8c96c52e00715c4b2cb9ac457f17aed8ffe1cf1ea524068fe5a1ddf218149845fc1417b789ecfc98 +a5b0ffc819451ea639cfd1c18cbc9365cc79368d3b2e736c0ae54eba2f0801e6eb0ee14a5f373f4a70ca463bdb696c09 +879f91ccd56a1b9736fbfd20d8747354da743fb121f0e308a0d298ff0d9344431890e41da66b5009af3f442c636b4f43 +81bf3a2d9755e206b515a508ac4d1109bf933c282a46a4ae4a1b4cb4a94e1d23642fad6bd452428845afa155742ade7e +8de778d4742f945df40004964e165592f9c6b1946263adcdd5a88b00244bda46c7bb49098c8eb6b3d97a0dd46148a8ca +b7a57b21d13121907ee28c5c1f80ee2e3e83a3135a8101e933cf57171209a96173ff5037f5af606e9fd6d066de6ed693 +b0877d1963fd9200414a38753dffd9f23a10eb3198912790d7eddbc9f6b477019d52ddd4ebdcb9f60818db076938a5a9 +88da2d7a6611bc16adc55fc1c377480c828aba4496c645e3efe0e1a67f333c05a0307f7f1d2df8ac013602c655c6e209 +95719eb02e8a9dede1a888c656a778b1c69b7716fbe3d1538fe8afd4a1bc972183c7d32aa7d6073376f7701df80116d8 +8e8a1ca971f2444b35af3376e85dccda3abb8e8e11d095d0a4c37628dfe5d3e043a377c3de68289ef142e4308e9941a0 +b720caaff02f6d798ac84c4f527203e823ff685869e3943c979e388e1c34c3f77f5c242c6daa7e3b30e511aab917b866 +86040d55809afeec10e315d1ad950d269d37cfee8c144cd8dd4126459e3b15a53b3e68df5981df3c2346d23c7b4baaf4 +82d8cabf13ab853db0377504f0aec00dba3a5cd3119787e8ad378ddf2c40b022ecfc67c642b7acc8c1e3dd03ab50993e +b8d873927936719d2484cd03a6687d65697e17dcf4f0d5aed6f5e4750f52ef2133d4645894e7ebfc4ef6ce6788d404c8 +b1235594dbb15b674a419ff2b2deb644ad2a93791ca05af402823f87114483d6aa1689b7a9bea0f547ad12fe270e4344 +a53fda86571b0651f5affb74312551a082fffc0385cfd24c1d779985b72a5b1cf7c78b42b4f7e51e77055f8e5e915b00 +b579adcfd9c6ef916a5a999e77a0cb21d378c4ea67e13b7c58709d5da23a56c2e54218691fc4ac39a4a3d74f88cc31f7 +ab79e584011713e8a2f583e483a91a0c2a40771b77d91475825b5acbea82db4262132901cb3e4a108c46d7c9ee217a4e +a0fe58ea9eb982d7654c8aaf9366230578fc1362f6faae0594f8b9e659bcb405dff4aac0c7888bbe07f614ecf0d800a6 +867e50e74281f28ecd4925560e2e7a6f8911b135557b688254623acce0dbc41e23ac3e706a184a45d54c586edc416eb0 +89f81b61adda20ea9d0b387a36d0ab073dc7c7cbff518501962038be19867042f11fcc7ff78096e5d3b68c6d8dc04d9b +a58ee91bb556d43cf01f1398c5811f76dc0f11efdd569eed9ef178b3b0715e122060ec8f945b4dbf6eebfa2b90af6fa6 +ac460be540f4c840def2eef19fc754a9af34608d107cbadb53334cf194cc91138d53b9538fcd0ec970b5d4aa455b224a +b09b91f929de52c09d48ca0893be6eb44e2f5210a6c394689dc1f7729d4be4e11d0474b178e80cea8c2ac0d081f0e811 +8d37a442a76b06a02a4e64c2504aea72c8b9b020ab7bcc94580fe2b9603c7c50d7b1e9d70d2a7daea19c68667e8f8c31 +a9838d4c4e3f3a0075a952cf7dd623307ec633fcc81a7cf9e52e66c31780de33dbb3d74c320dc7f0a4b72f7a49949515 +a44766b6251af458fe4f5f9ed1e02950f35703520b8656f09fc42d9a2d38a700c11a7c8a0436ac2e5e9f053d0bb8ff91 +ad78d9481c840f5202546bea0d13c776826feb8b1b7c72e83d99a947622f0bf38a4208551c4c41beb1270d7792075457 +b619ffa8733b470039451e224b777845021e8dc1125f247a4ff2476cc774657d0ff9c5279da841fc1236047de9d81c60 +af760b0a30a1d6af3bc5cd6686f396bd41779aeeb6e0d70a09349bd5da17ca2e7965afc5c8ec22744198fbe3f02fb331 +a0cc209abdb768b589fcb7b376b6e1cac07743288c95a1cf1a0354b47f0cf91fca78a75c1fcafa6f5926d6c379116608 +864add673c89c41c754eeb3cd8dcff5cdde1d739fce65c30e474a082bb5d813cba6412e61154ce88fdb6c12c5d9be35b +b091443b0ce279327dc37cb484e9a5b69b257a714ce21895d67539172f95ffa326903747b64a3649e99aea7bb10d03f7 +a8c452b8c4ca8e0a61942a8e08e28f17fb0ef4c5b018b4e6d1a64038280afa2bf1169202f05f14af24a06ca72f448ccd +a23c24721d18bc48d5dcf70effcbef89a7ae24e67158d70ae1d8169ee75d9a051d34b14e9cf06488bac324fe58549f26 +92a730e30eb5f3231feb85f6720489dbb1afd42c43f05a1610c6b3c67bb949ec8fde507e924498f4ffc646f7b07d9123 +8dbe5abf4031ec9ba6bb06d1a47dd1121fb9e03b652804069250967fd5e9577d0039e233441b7f837a7c9d67ba18c28e +aa456bcfef6a21bb88181482b279df260297b3778e84594ebddbdf337e85d9e3d46ca1d0b516622fb0b103df8ec519b7 +a3b31ae621bd210a2b767e0e6f22eb28fe3c4943498a7e91753225426168b9a26da0e02f1dc5264da53a5ad240d9f51b +aa8d66857127e6e71874ce2202923385a7d2818b84cb73a6c42d71afe70972a70c6bdd2aad1a6e8c5e4ca728382a8ea8 +ac7e8e7a82f439127a5e40558d90d17990f8229852d21c13d753c2e97facf077cf59582b603984c3dd3faebd80aff4f5 +93a8bcf4159f455d1baa73d2ef2450dcd4100420de84169bbe28b8b7a5d1746273f870091a87a057e834f754f34204b1 +89d0ebb287c3613cdcae7f5acc43f17f09c0213fc40c074660120b755d664109ffb9902ed981ede79e018ddb0c845698 +a87ccbfad431406aadbee878d9cf7d91b13649d5f7e19938b7dfd32645a43b114eef64ff3a13201398bd9b0337832e5a +833c51d0d0048f70c3eefb4e70e4ff66d0809c41838e8d2c21c288dd3ae9d9dfaf26d1742bf4976dab83a2b381677011 +8bcd6b1c3b02fffead432e8b1680bad0a1ac5a712d4225e220690ee18df3e7406e2769e1f309e2e803b850bc96f0e768 +b61e3dbd88aaf4ff1401521781e2eea9ef8b66d1fac5387c83b1da9e65c2aa2a56c262dea9eceeb4ad86c90211672db0 +866d3090db944ecf190dd0651abf67659caafd31ae861bab9992c1e3915cb0952da7c561cc7e203560a610f48fae633b +a5e8971543c14274a8dc892b0be188c1b4fbc75c692ed29f166e0ea80874bc5520c2791342b7c1d2fb5dd454b03b8a5b +8f2f9fc50471bae9ea87487ebd1bc8576ef844cc42d606af5c4c0969670fdf2189afd643e4de3145864e7773d215f37f +b1bb0f2527db6d51f42b9224383c0f96048bbc03d469bf01fe1383173ef8b1cc9455d9dd8ba04d46057f46949bfc92b5 +aa7c99d906b4d7922296cfe2520473fc50137c03d68b7865c5bfb8adbc316b1034310ec4b5670c47295f4a80fb8d61e9 +a5d1da4d6aba555919df44cbaa8ff79378a1c9e2cfdfbf9d39c63a4a00f284c5a5724e28ecbc2d9dba27fe4ee5018bd5 +a8db53224f70af4d991b9aae4ffe92d2aa5b618ad9137784b55843e9f16cefbfd25ada355d308e9bbf55f6d2f7976fb3 +b6536c4232bb20e22af1a8bb12de76d5fec2ad9a3b48af1f38fa67e0f8504ef60f305a73d19385095bb6a9603fe29889 +87f7e371a1817a63d6838a8cf4ab3a8473d19ce0d4f40fd013c03d5ddd5f4985df2956531cc9f187928ef54c68f4f9a9 +ae13530b1dbc5e4dced9d909ea61286ec09e25c12f37a1ed2f309b0eb99863d236c3b25ed3484acc8c076ad2fa8cd430 +98928d850247c6f7606190e687d5c94a627550198dbdbea0161ef9515eacdb1a0f195cae3bb293112179082daccf8b35 +918528bb8e6a055ad4db6230d3a405e9e55866da15c4721f5ddd1f1f37962d4904aad7a419218fe6d906fe191a991806 +b71e31a06afe065773dd3f4a6e9ef81c3292e27a3b7fdfdd452d03e05af3b6dd654c355f7516b2a93553360c6681a73a +8870b83ab78a98820866f91ac643af9f3ff792a2b7fda34185a9456a63abdce42bfe8ad4dc67f08a6392f250d4062df4 +91eea1b668e52f7a7a5087fabf1cab803b0316f78d9fff469fbfde2162f660c250e4336a9eea4cb0450bd30ac067bc8b +8b74990946de7b72a92147ceac1bd9d55999a8b576e8df68639e40ed5dc2062cfcd727903133de482b6dca19d0aaed82 +8ebad537fece090ebbab662bdf2618e21ca30cf6329c50935e8346d1217dcbe3c1fe1ea28efca369c6003ce0a94703c1 +a8640479556fb59ebd1c40c5f368fbd960932fdbb782665e4a0e24e2bdb598fc0164ce8c0726d7759cfc59e60a62e182 +a9a52a6bf98ee4d749f6d38be2c60a6d54b64d5cbe4e67266633dc096cf28c97fe998596707d31968cbe2064b72256bf +847953c48a4ce6032780e9b39d0ed4384e0be202c2bbe2dfda3910f5d87aa5cd3c2ffbfcfae4dddce16d6ab657599b95 +b6f6e1485d3ec2a06abaecd23028b200b2e4a0096c16144d07403e1720ff8f9ba9d919016b5eb8dc5103880a7a77a1d3 +98dfc2065b1622f596dbe27131ea60bef7a193b12922cecb27f8c571404f483014f8014572e86ae2e341ab738e4887ef +acb0d205566bacc87bbe2e25d10793f63f7a1f27fd9e58f4f653ceae3ffeba511eaf658e068fad289eeb28f9edbeb35b +ae4411ed5b263673cee894c11fe4abc72a4bf642d94022a5c0f3369380fcdfc1c21e277f2902972252503f91ada3029a +ac4a7a27ba390a75d0a247d93d4a8ef1f0485f8d373a4af4e1139369ec274b91b3464d9738eeaceb19cd6f509e2f8262 +87379c3bf231fdafcf6472a79e9e55a938d851d4dd662ab6e0d95fd47a478ed99e2ad1e6e39be3c0fc4f6d996a7dd833 +81316904b035a8bcc2041199a789a2e6879486ba9fddcba0a82c745cc8dd8374a39e523b91792170cd30be7aa3005b85 +b8206809c6cd027ed019f472581b45f7e12288f89047928ba32b4856b6560ad30395830d71e5e30c556f6f182b1fe690 +88d76c028f534a62e019b4a52967bb8642ede6becfa3807be68fdd36d366fc84a4ac8dc176e80a68bc59eb62caf5dff9 +8c3b8be685b0f8aad131ee7544d0e12f223f08a6f8edaf464b385ac644e0ddc9eff7cc7cb5c1b50ab5d71ea0f41d2213 +8d91410e004f76c50fdc05784157b4d839cb5090022c629c7c97a5e0c3536eeafee17a527b54b1165c3cd81774bb54ce +b25c2863bc28ec5281ce800ddf91a7e1a53f4c6d5da1e6c86ef4616e93bcf55ed49e297216d01379f5c6e7b3c1e46728 +865f7b09ac3ca03f20be90c48f6975dd2588838c2536c7a3532a6aa5187ed0b709cd03d91ff4048061c10d0aa72b69ce +b3f7477c90c11596eb4f8bbf34adbcb832638c4ff3cdd090d4d477ee50472ac9ddaf5be9ad7eca3f148960d362bbd098 +8db35fd53fca04faecd1c76a8227160b3ab46ac1af070f2492445a19d8ff7c25bbaef6c9fa0c8c088444561e9f7e4eb2 +a478b6e9d058a2e01d2fc053b739092e113c23a6a2770a16afbef044a3709a9e32f425ace9ba7981325f02667c3f9609 +98caa6bd38916c08cf221722a675a4f7577f33452623de801d2b3429595f988090907a7e99960fff7c076d6d8e877b31 +b79aaaacefc49c3038a14d2ac468cfec8c2161e88bdae91798d63552cdbe39e0e02f9225717436b9b8a40a022c633c6e +845a31006c680ee6a0cc41d3dc6c0c95d833fcf426f2e7c573fa15b2c4c641fbd6fe5ebb0e23720cc3467d6ee1d80dc4 +a1bc287e272cf8b74dbf6405b3a5190883195806aa351f1dc8e525aa342283f0a35ff687e3b434324dedee74946dd185 +a4fd2dc8db75d3783a020856e2b3aa266dc6926e84f5c491ef739a3bddd46dc8e9e0fc1177937839ef1b18d062ffbb9e +acbf0d3c697f57c202bb8c5dc4f3fc341b8fc509a455d44bd86acc67cad2a04495d5537bcd3e98680185e8aa286f2587 +a5caf423a917352e1b8e844f5968a6da4fdeae467d10c6f4bbd82b5eea46a660b82d2f5440d3641c717b2c3c9ed0be52 +8a39d763c08b926599ab1233219c49c825368fad14d9afc7c0c039224d37c00d8743293fd21645bf0b91eaf579a99867 +b2b53a496def0ba06e80b28f36530fbe0fb5d70a601a2f10722e59abee529369c1ae8fd0f2db9184dd4a2519bb832d94 +a73980fcef053f1b60ebbb5d78ba6332a475e0b96a0c724741a3abf3b59dd344772527f07203cf4c9cb5155ebed81fa0 +a070d20acce42518ece322c9db096f16aed620303a39d8d5735a0df6e70fbeceb940e8d9f5cc38f3314b2240394ec47b +a50cf591f522f19ca337b73089557f75929d9f645f3e57d4f241e14cdd1ea3fb48d84bcf05e4f0377afbb789fbdb5d20 +82a5ffce451096aca8eeb0cd2ae9d83db3ed76da3f531a80d9a70a346359bf05d74863ce6a7c848522b526156a5e20cd +88e0e84d358cbb93755a906f329db1537c3894845f32b9b0b691c29cbb455373d9452fadd1e77e20a623f6eaf624de6f +aa07ac7b84a6d6838826e0b9e350d8ec75e398a52e9824e6b0da6ae4010e5943fec4f00239e96433f291fef9d1d1e609 +ac8887bf39366034bc63f6cc5db0c26fd27307cbc3d6cce47894a8a019c22dd51322fb5096edc018227edfafc053a8f6 +b7d26c26c5b33f77422191dca94977588ab1d4b9ce7d0e19c4a3b4cd1c25211b78c328dbf81e755e78cd7d1d622ad23e +99a676d5af49f0ba44047009298d8474cabf2d5bca1a76ba21eff7ee3c4691a102fdefea27bc948ccad8894a658abd02 +b0d09a91909ab3620c183bdf1d53d43d39eb750dc7a722c661c3de3a1a5d383ad221f71bae374f8a71867505958a3f76 +84681a883de8e4b93d68ac10e91899c2bbb815ce2de74bb48a11a6113b2a3f4df8aceabda1f5f67bc5aacac8c9da7221 +9470259957780fa9b43521fab3644f555f5343281c72582b56d2efd11991d897b3b481cafa48681c5aeb80c9663b68f7 +ab1b29f7ece686e6fa968a4815da1d64f3579fed3bc92e1f3e51cd13a3c076b6cf695ed269d373300a62463dc98a4234 +8ab415bfcd5f1061f7687597024c96dd9c7cb4942b5989379a7a3b5742f7d394337886317659cbeacaf030234a24f972 +b9b524aad924f9acc63d002d617488f31b0016e0f0548f050cada285ce7491b74a125621638f19e9c96eabb091d945be +8c4c373e79415061837dd0def4f28a2d5d74d21cb13a76c9049ad678ca40228405ab0c3941df49249847ecdefc1a5b78 +a8edf4710b5ab2929d3db6c1c0e3e242261bbaa8bcec56908ddadd7d2dad2dca9d6eb9de630b960b122ebeea41040421 +8d66bb3b50b9df8f373163629f9221b3d4b6980a05ea81dc3741bfe9519cf3ebba7ab98e98390bae475e8ede5821bd5c +8d3c21bae7f0cfb97c56952bb22084b58e7bb718890935b73103f33adf5e4d99cd262f929c6eeab96209814f0dbae50a +a5c66cfab3d9ebf733c4af24bebc97070e7989fe3c73e79ac85fb0e4d40ae44fb571e0fad4ad72560e13ed453900d14f +9362e6b50b43dbefbc3254471372297b5dcce809cd3b60bf74a1268ab68bdb50e46e462cbd78f0d6c056330e982846af +854630d08e3f0243d570cc2e856234cb4c1a158d9c1883bf028a76525aaa34be897fe918d5f6da9764a3735fa9ebd24a +8c7d246985469ff252c3f4df6c7c9196fc79f05c1c66a609d84725c78001d0837c7a7049394ba5cf7e863e2d58af8417 +ae050271e01b528925302e71903f785b782f7bf4e4e7a7f537140219bc352dc7540c657ed03d3a297ad36798ecdb98cd +8d2ae9179fcf2b0c69850554580b52c1f4a5bd865af5f3028f222f4acad9c1ad69a8ef6c7dc7b03715ee5c506b74325e +b8ef8de6ce6369a8851cd36db0ccf00a85077e816c14c4e601f533330af9e3acf0743a95d28962ed8bfcfc2520ef3cfe +a6ecad6fdfb851b40356a8b1060f38235407a0f2706e7b8bb4a13465ca3f81d4f5b99466ac2565c60af15f022d26732e +819ff14cdea3ab89d98e133cd2d0379361e2e2c67ad94eeddcdb9232efd509f51d12f4f03ebd4dd953bd262a886281f7 +8561cd0f7a6dbcddd83fcd7f472d7dbcba95b2d4fb98276f48fccf69f76d284e626d7e41314b633352df8e6333fd52a1 +b42557ccce32d9a894d538c48712cb3e212d06ac05cd5e0527ccd2db1078ee6ae399bf6a601ffdab1f5913d35fc0b20c +89b4008d767aad3c6f93c349d3b956e28307311a5b1cec237e8d74bb0dee7e972c24f347fd56afd915a2342bd7bc32f0 +877487384b207e53f5492f4e36c832c2227f92d1bb60542cfeb35e025a4a7afc2b885fae2528b33b40ab09510398f83e +8c411050b63c9053dd0cd81dacb48753c3d7f162028098e024d17cd6348482703a69df31ad6256e3d25a8bbf7783de39 +a8506b54a88d17ac10fb1b0d1fe4aa40eae7553a064863d7f6b52ccc4236dd4b82d01dca6ba87da9a239e3069ba879fb +b1a24caef9df64750c1350789bb8d8a0db0f39474a1c74ea9ba064b1516db6923f00af8d57c632d58844fb8786c3d47a +959d6e255f212b0708c58a2f75cb1fe932248c9d93424612c1b8d1e640149656059737e4db2139afd5556bcdacf3eda2 +84525af21a8d78748680b6535bbc9dc2f0cf9a1d1740d12f382f6ecb2e73811d6c1da2ad9956070b1a617c61fcff9fe5 +b74417d84597a485d0a8e1be07bf78f17ebb2e7b3521b748f73935b9afbbd82f34b710fb7749e7d4ab55b0c7f9de127d +a4a9aecb19a6bab167af96d8b9d9aa5308eab19e6bfb78f5a580f9bf89bdf250a7b52a09b75f715d651cb73febd08e84 +9777b30be2c5ffe7d29cc2803a562a32fb43b59d8c3f05a707ab60ec05b28293716230a7d264d7cd9dd358fc031cc13e +95dce7a3d4f23ac0050c510999f5fbf8042f771e8f8f94192e17bcbfa213470802ebdbe33a876cb621cf42e275cbfc8b +b0b963ebcbbee847ab8ae740478544350b3ac7e86887e4dfb2299ee5096247cd2b03c1de74c774d9bde94ae2ee2dcd59 +a4ab20bafa316030264e13f7ef5891a2c3b29ab62e1668fcb5881f50a9acac6adbe3d706c07e62f2539715db768f6c43 +901478a297669d608e406fe4989be75264b6c8be12169aa9e0ad5234f459ca377f78484ffd2099a2fe2db5e457826427 +88c76e5c250810c057004a03408b85cd918e0c8903dc55a0dd8bb9b4fc2b25c87f9b8cf5943eb19fbbe99d36490050c5 +91607322bbad4a4f03fc0012d0821eff5f8c516fda45d1ec1133bface6f858bf04b25547be24159cab931a7aa08344d4 +843203e07fce3c6c81f84bc6dc5fb5e9d1c50c8811ace522dc66e8658433a0ef9784c947e6a62c11bf705307ef05212e +91dd8813a5d6dddcda7b0f87f672b83198cd0959d8311b2b26fb1fae745185c01f796fbd03aad9db9b58482483fdadd8 +8d15911aacf76c8bcd7136e958febd6963104addcd751ce5c06b6c37213f9c4fb0ffd4e0d12c8e40c36d658999724bfd +8a36c5732d3f1b497ebe9250610605ee62a78eaa9e1a45f329d09aaa1061131cf1d9df00f3a7d0fe8ad614a1ff9caaae +a407d06affae03660881ce20dab5e2d2d6cddc23cd09b95502a9181c465e57597841144cb34d22889902aff23a76d049 +b5fd856d0578620a7e25674d9503be7d97a2222900e1b4738c1d81ff6483b144e19e46802e91161e246271f90270e6cf +91b7708869cdb5a7317f88c0312d103f8ce90be14fb4f219c2e074045a2a83636fdc3e69e862049fc7c1ef000e832541 +b64719cc5480709d1dae958f1d3082b32a43376da446c8f9f64cb02a301effc9c34d9102051733315a8179aed94d53cc +94347a9542ff9d18f7d9eaa2f4d9b832d0e535fe49d52aa2de08aa8192400eddabdb6444a2a78883e27c779eed7fdf5a +840ef44a733ff1376466698cd26f82cf56bb44811e196340467f932efa3ae1ef9958a0701b3b032f50fd9c1d2aed9ab5 +90ab3f6f67688888a31ffc2a882bb37adab32d1a4b278951a21646f90d03385fc976715fc639a785d015751171016f10 +b56f35d164c24b557dbcbc8a4bfa681ec916f8741ffcb27fb389c164f4e3ed2be325210ef5bdaeae7a172ca9599ab442 +a7921a5a80d7cf6ae81ba9ee05e0579b18c20cd2852762c89d6496aa4c8ca9d1ca2434a67b2c16d333ea8e382cdab1e3 +a506bcfbd7e7e5a92f68a1bd87d07ad5fe3b97aeee40af2bf2cae4efcd77fff03f872732c5b7883aa6584bee65d6f8cb +a8c46cff58931a1ce9cbe1501e1da90b174cddd6d50f3dfdfb759d1d4ad4673c0a8feed6c1f24c7af32865a7d6c984e5 +b45686265a83bff69e312c5149db7bb70ac3ec790dc92e392b54d9c85a656e2bf58596ce269f014a906eafc97461aa5f +8d4009a75ccb2f29f54a5f16684b93202c570d7a56ec1a8b20173269c5f7115894f210c26b41e8d54d4072de2d1c75d0 +aef8810af4fc676bf84a0d57b189760ddc3375c64e982539107422e3de2580b89bd27aa6da44e827b56db1b5555e4ee8 +888f0e1e4a34f48eb9a18ef4de334c27564d72f2cf8073e3d46d881853ac1424d79e88d8ddb251914890588937c8f711 +b64b0aa7b3a8f6e0d4b3499fe54e751b8c3e946377c0d5a6dbb677be23736b86a7e8a6be022411601dd75012012c3555 +8d57776f519f0dd912ea14f79fbab53a30624e102f9575c0bad08d2dc754e6be54f39b11278c290977d9b9c7c0e1e0ad +a018fc00d532ceb2e4de908a15606db9b6e0665dd77190e2338da7c87a1713e6b9b61554e7c1462f0f6d4934b960b15c +8c932be83ace46f65c78e145b384f58e41546dc0395270c1397874d88626fdeda395c8a289d602b4c312fe98c1311856 +89174838e21639d6bdd91a0621f04dc056907b88e305dd66e46a08f6d65f731dea72ae87ca5e3042d609e8de8de9aa26 +b7b7f508bb74f7a827ac8189daa855598ff1d96fa3a02394891fd105d8f0816224cd50ac4bf2ed1cf469ace516c48184 +b31877ad682583283baadd68dc1bebd83f5748b165aadd7fe9ef61a343773b88bcd3a022f36d6c92f339b7bfd72820a9 +b79d77260b25daf9126dab7a193df2d7d30542786fa1733ffaf6261734770275d3ca8bae1d9915d1181a78510b3439db +91894fb94cd4c1dd2ceaf9c53a7020c5799ba1217cf2d251ea5bc91ed26e1159dd758e98282ebe35a0395ef9f1ed15a0 +ab59895cdafd33934ceedfc3f0d5d89880482cba6c99a6db93245f9e41987efd76e0640e80aef31782c9a8c7a83fccec +aa22ea63654315e033e09d4d4432331904a6fc5fb1732557987846e3c564668ca67c60a324b4af01663a23af11a9ce4b +b53ba3ef342601467e1f71aa280e100fbabbd38518fa0193e0099505036ee517c1ac78e96e9baeb549bb6879bb698fb0 +943fd69fd656f37487cca3605dc7e5a215fddd811caf228595ec428751fc1de484a0cb84c667fe4d7c35599bfa0e5e34 +9353128b5ebe0dddc555093cf3e5942754f938173541033e8788d7331fafc56f68d9f97b4131e37963ab7f1c8946f5f1 +a76cd3c566691f65cfb86453b5b31dbaf3cab8f84fe1f795dd1e570784b9b01bdd5f0b3c1e233942b1b5838290e00598 +983d84b2e53ffa4ae7f3ba29ef2345247ea2377686b74a10479a0ef105ecf90427bf53b74c96dfa346d0f842b6ffb25b +92e0fe9063306894a2c6970c001781cff416c87e87cb5fbac927a3192655c3da4063e6fa93539f6ff58efac6adcc5514 +b00a81f03c2b8703acd4e2e4c21e06973aba696415d0ea1a648ace2b0ea19b242fede10e4f9d7dcd61c546ab878bc8f9 +b0d08d880f3b456a10bf65cff983f754f545c840c413aea90ce7101a66eb0a0b9b1549d6c4d57725315828607963f15a +90cb64d03534f913b411375cce88a9e8b1329ce67a9f89ca5df8a22b8c1c97707fec727dbcbb9737f20c4cf751359277 +8327c2d42590dfcdb78477fc18dcf71608686ad66c49bce64d7ee874668be7e1c17cc1042a754bbc77c9daf50b2dae07 +8532171ea13aa7e37178e51a6c775da469d2e26ec854eb16e60f3307db4acec110d2155832c202e9ba525fc99174e3b0 +83ca44b15393d021de2a511fa5511c5bd4e0ac7d67259dce5a5328f38a3cce9c3a269405959a2486016bc27bb140f9ff +b1d36e8ca812be545505c8214943b36cabee48112cf0de369957afa796d37f86bf7249d9f36e8e990f26f1076f292b13 +9803abf45be5271e2f3164c328d449efc4b8fc92dfc1225d38e09630909fe92e90a5c77618daa5f592d23fc3ad667094 +b268ad68c7bf432a01039cd889afae815c3e120f57930d463aece10af4fd330b5bd7d8869ef1bcf6b2e78e4229922edc +a4c91a0d6f16b1553264592b4cbbbf3ca5da32ab053ffbdd3dbb1aed1afb650fb6e0dc5274f71a51d7160856477228db +ad89d043c2f0f17806277ffdf3ecf007448e93968663f8a0b674254f36170447b7527d5906035e5e56f4146b89b5af56 +8b6964f757a72a22a642e4d69102951897e20c21449184e44717bd0681d75f7c5bfa5ee5397f6e53febf85a1810d6ed1 +b08f5cdaabec910856920cd6e836c830b863eb578423edf0b32529488f71fe8257d90aed4a127448204df498b6815d79 +af26bb3358be9d280d39b21d831bb53145c4527a642446073fee5a86215c4c89ff49a3877a7a549486262f6f57a0f476 +b4010b37ec4d7c2af20800e272539200a6b623ae4636ecbd0e619484f4ab9240d02bc5541ace3a3fb955dc0a3d774212 +82752ab52bdcc3cc2fc405cb05a2e694d3df4a3a68f2179ec0652536d067b43660b96f85f573f26fbd664a9ef899f650 +96d392dde067473a81faf2d1fea55b6429126b88b160e39b4210d31d0a82833ffd3a80e07d24d495aea2d96be7251547 +a76d8236d6671204d440c33ac5b8deb71fa389f6563d80e73be8b043ec77d4c9b06f9a586117c7f957f4af0331cbc871 +b6c90961f68b5e385d85c9830ec765d22a425f506904c4d506b87d8944c2b2c09615e740ed351df0f9321a7b93979cae +a6ec5ea80c7558403485b3b1869cdc63bde239bafdf936d9b62a37031628402a36a2cfa5cfbb8e26ac922cb0a209b3ba +8c3195bbdbf9bc0fc95fa7e3d7f739353c947f7767d1e3cb24d8c8602d8ea0a1790ac30b815be2a2ba26caa5227891e2 +a7f8a63d809f1155722c57f375ea00412b00147776ae4444f342550279ef4415450d6f400000a326bf11fea6c77bf941 +97fa404df48433a00c85793440e89bb1af44c7267588ae937a1f5d53e01e1c4d4fc8e4a6d517f3978bfdd6c2dfde012f +a984a0a3836de3d8d909c4629a2636aacb85393f6f214a2ef68860081e9db05ad608024762db0dc35e895dc00e2d4cdd +9526cf088ab90335add1db4d3a4ac631b58cbfbe88fa0845a877d33247d1cfeb85994522e1eb8f8874651bfb1df03e2a +ac83443fd0afe99ad49de9bf8230158c118e2814c9c89db5ac951c240d6c2ce45e7677221279d9e97848ec466b99aafe +aeeefdbaba612e971697798ceaf63b247949dc823a0ad771ae5b988a5e882b338a98d3d0796230f49d533ec5ba411b39 +ae3f248b5a7b0f92b7820a6c5ae21e5bd8f4265d4f6e21a22512079b8ee9be06393fd3133ce8ebac0faf23f4f8517e36 +a64a831b908eee784b8388b45447d2885ec0551b26b0c2b15e5f417d0a12c79e867fb7bd3d008d0af98b44336f8ec1ad +b242238cd8362b6e440ba21806905714dd55172db25ec7195f3fc4937b2aba146d5cbf3cf691a1384b4752dc3b54d627 +819f97f337eea1ffb2a678cc25f556f1aab751c6b048993a1d430fe1a3ddd8bb411c152e12ca60ec6e057c190cd1db9a +b9d7d187407380df54ee9fef224c54eec1bfabf17dc8abf60765b7951f538f59aa26fffd5846cfe05546c35f59b573f4 +aa6e3c14efa6a5962812e3f94f8ce673a433f4a82d07a67577285ea0eaa07f8be7115853122d12d6d4e1fdf64c504be1 +82268bee9c1662d3ddb5fb785abfae6fb8b774190f30267f1d47091d2cd4b3874db4372625aa36c32f27b0eee986269b +b236459565b7b966166c4a35b2fa71030b40321821b8e96879d95f0e83a0baf33fa25721f30af4a631df209e25b96061 +8708d752632d2435d2d5b1db4ad1fa2558d776a013655f88e9a3556d86b71976e7dfe5b8834fdec97682cd94560d0d0d +ae1424a68ae2dbfb0f01211f11773732a50510b5585c1fb005cb892b2c6a58f4a55490b5c5b4483c6fce40e9d3236a52 +b3f5f722af9dddb07293c871ce97abbccba0093ca98c8d74b1318fa21396fc1b45b69c15084f63d728f9908442024506 +9606f3ce5e63886853ca476dc0949e7f1051889d529365c0cb0296fdc02abd088f0f0318ecd2cf36740a3634132d36f6 +b11a833a49fa138db46b25ff8cdda665295226595bc212c0931b4931d0a55c99da972c12b4ef753f7e37c6332356e350 +afede34e7dab0a9e074bc19a7daddb27df65735581ca24ad70c891c98b1349fcebbcf3ba6b32c2617fe06a5818dabc2d +97993d456e459e66322d01f8eb13918979761c3e8590910453944bdff90b24091bb018ac6499792515c9923be289f99f +977e3e967eff19290a192cd11df3667d511b398fb3ac9a5114a0f3707e25a0edcb56105648b1b85a8b7519fc529fc6f6 +b873a7c88bf58731fe1bf61ff6828bf114cf5228f254083304a4570e854e83748fc98683ddba62d978fff7909f2c5c47 +ad4b2691f6f19da1d123aaa23cca3e876247ed9a4ab23c599afdbc0d3aa49776442a7ceaa996ac550d0313d9b9a36cee +b9210713c78e19685608c6475bfa974b57ac276808a443f8b280945c5d5f9c39da43effa294bfb1a6c6f7b6b9f85bf6c +a65152f376113e61a0e468759de38d742caa260291b4753391ee408dea55927af08a4d4a9918600a3bdf1df462dffe76 +8bf8c27ad5140dde7f3d2280fd4cc6b29ab76537e8d7aa7011a9d2796ee3e56e9a60c27b5c2da6c5e14fc866301dc195 +92fde8effc9f61393a2771155812b863cff2a0c5423d7d40aa04d621d396b44af94ddd376c28e7d2f53c930aea947484 +97a01d1dd9ee30553ce676011aea97fa93d55038ada95f0057d2362ae9437f3ed13de8290e2ff21e3167dd7ba10b9c3f +89affffaa63cb2df3490f76f0d1e1d6ca35c221dd34057176ba739fa18d492355e6d2a5a5ad93a136d3b1fed0bb8aa19 +928b8e255a77e1f0495c86d3c63b83677b4561a5fcbbe5d3210f1e0fc947496e426d6bf3b49394a5df796c9f25673fc4 +842a0af91799c9b533e79ee081efe2a634cac6c584c2f054fb7d1db67dde90ae36de36cbf712ec9cd1a0c7ee79e151ea +a65b946cf637e090baf2107c9a42f354b390e7316beb8913638130dbc67c918926eb87bec3b1fe92ef72bc77a170fa3b +aafc0f19bfd71ab5ae4a8510c7861458b70ad062a44107b1b1dbacbfa44ba3217028c2824bd7058e2fa32455f624040b +95269dc787653814e0be899c95dba8cfa384f575a25e671c0806fd80816ad6797dc819d30ae06e1d0ed9cb01c3950d47 +a1e760f7fa5775a1b2964b719ff961a92083c5c617f637fc46e0c9c20ab233f8686f7f38c3cb27d825c54dd95e93a59b +ac3b8a7c2317ea967f229eddc3e23e279427f665c4705c7532ed33443f1243d33453c1088f57088d2ab1e3df690a9cc9 +b787beeddfbfe36dd51ec4efd9cf83e59e84d354c3353cc9c447be53ae53d366ed1c59b686e52a92f002142c8652bfe0 +b7a64198300cb6716aa7ac6b25621f8bdec46ad5c07a27e165b3f774cdf65bcfdbf31e9bae0c16b44de4b00ada7a4244 +b8ae9f1452909e0c412c7a7fe075027691ea8df1347f65a5507bc8848f1d2c833d69748076db1129e5b4fb912f65c86c +9682e41872456b9fa67def89e71f06d362d6c8ca85c9c48536615bc401442711e1c9803f10ab7f8ab5feaec0f9df20a6 +88889ff4e271dc1c7e21989cc39f73cde2f0475acd98078281591ff6c944fadeb9954e72334319050205d745d4df73df +8f79b5b8159e7fd0d93b0645f3c416464f39aec353b57d99ecf24f96272df8a068ad67a6c90c78d82c63b40bb73989bb +838c01a009a3d8558a3f0bdd5e22de21af71ca1aefc8423c91dc577d50920e9516880e87dce3e6d086e11cd45c9052d9 +b97f1c6eee8a78f137c840667cc288256e39294268a3009419298a04a1d0087c9c9077b33c917c65caf76637702dda8a +972284ce72f96a61c899260203dfa06fc3268981732bef74060641c1a5068ead723e3399431c247ca034b0dae861e8df +945a8d52d6d3db6663dbd3110c6587f9e9c44132045eeffba15621576d178315cb52870fa5861669f84f0bee646183fe +a0a547b5f0967b1c3e5ec6c6a9a99f0578521489180dfdfbb5561f4d166baac43a2f06f950f645ce991664e167537eed +a0592cda5cdddf1340033a745fd13a6eff2021f2e26587116c61c60edead067e0f217bc2bef4172a3c9839b0b978ab35 +b9c223b65a3281587fa44ec829e609154b32f801fd1de6950e01eafb07a8324243b960d5735288d0f89f0078b2c42b5b +99ebfc3b8f9f98249f4d37a0023149ed85edd7a5abe062c8fb30c8c84555258b998bdcdd1d400bc0fa2a4aaa8b224466 +955b68526e6cb3937b26843270f4e60f9c6c8ece2fa9308fe3e23afa433309c068c66a4bc16ee2cf04220f095e9afce4 +b766caeafcc00378135ae53397f8a67ed586f5e30795462c4a35853de6681b1f17401a1c40958de32b197c083b7279c1 +921bf87cad947c2c33fa596d819423c10337a76fe5a63813c0a9dc78a728207ae7b339407a402fc4d0f7cba3af6da6fc +a74ba1f3bc3e6c025db411308f49b347ec91da1c916bda9da61e510ec8d71d25e0ac0f124811b7860e5204f93099af27 +a29b4d144e0bf17a7e8353f2824cef0ce85621396babe8a0b873ca1e8a5f8d508b87866cf86da348470649fceefd735c +a8040e12ffc3480dd83a349d06741d1572ef91932c46f5cf03aee8454254156ee95786fd013d5654725e674c920cec32 +8c4cf34ca60afd33923f219ffed054f90cd3f253ffeb2204a3b61b0183417e366c16c07fae860e362b0f2bfe3e1a1d35 +8195eede4ddb1c950459df6c396b2e99d83059f282b420acc34220cadeed16ab65c856f2c52568d86d3c682818ed7b37 +91fff19e54c15932260aa990c7fcb3c3c3da94845cc5aa8740ef56cf9f58d19b4c3c55596f8d6c877f9f4d22921d93aa +a3e0bf7e5d02a80b75cf75f2db7e66cb625250c45436e3c136d86297d652590ec97c2311bafe407ad357c79ab29d107b +81917ff87e5ed2ae4656b481a63ced9e6e5ff653b8aa6b7986911b8bc1ee5b8ef4f4d7882c3f250f2238e141b227e510 +915fdbe5e7de09c66c0416ae14a8750db9412e11dc576cf6158755fdcaf67abdbf0fa79b554cac4fe91c4ec245be073f +8df27eafb5c3996ba4dc5773c1a45ca77e626b52e454dc1c4058aa94c2067c18332280630cc3d364821ee53bf2b8c130 +934f8a17c5cbb827d7868f5c8ca00cb027728a841000a16a3428ab16aa28733f16b52f58c9c4fbf75ccc45df72d9c4df +b83f4da811f9183c25de8958bc73b504cf790e0f357cbe74ef696efa7aca97ad3b7ead1faf76e9f982c65b6a4d888fc2 +87188213c8b5c268dc2b6da413f0501c95749e953791b727450af3e43714149c115b596b33b63a2f006a1a271b87efd0 +83e9e888ab9c3e30761de635d9aabd31248cdd92f7675fc43e4b21fd96a03ec1dc4ad2ec94fec857ffb52683ac98e360 +b4b9a1823fe2d983dc4ec4e3aaea297e581c3fc5ab4b4af5fa1370caa37af2d1cc7fc6bfc5e7da60ad8fdce27dfe4b24 +856388bc78aef465dbcdd1f559252e028c9e9a2225c37d645c138e78f008f764124522705822a61326a6d1c79781e189 +a6431b36db93c3b47353ba22e7c9592c9cdfb9cbdd052ecf2cc3793f5b60c1e89bc96e6bae117bfd047f2308da00dd2f +b619972d48e7e4291542dcde08f7a9cdc883c892986ded2f23ccb216e245cd8d9ad1d285347b0f9d7611d63bf4cee2bc +8845cca6ff8595955f37440232f8e61d5351500bd016dfadd182b9d39544db77a62f4e0102ff74dd4173ae2c181d24ef +b2f5f7fa26dcd3b6550879520172db2d64ee6aaa213cbef1a12befbce03f0973a22eb4e5d7b977f466ac2bf8323dcedd +858b7f7e2d44bdf5235841164aa8b4f3d33934e8cb122794d90e0c1cac726417b220529e4f896d7b77902ab0ccd35b3a +80b0408a092dae2b287a5e32ea1ad52b78b10e9c12f49282976cd738f5d834e03d1ad59b09c5ccaccc39818b87d06092 +b996b0a9c6a2d14d984edcd6ab56bc941674102980d65b3ad9733455f49473d3f587c8cbf661228a7e125ddbe07e3198 +90224fcebb36865293bd63af786e0c5ade6b67c4938d77eb0cbae730d514fdd0fe2d6632788e858afd29d46310cf86df +b71351fdfff7168b0a5ec48397ecc27ac36657a8033d9981e97002dcca0303e3715ce6dd3f39423bc8ef286fa2e9e669 +ae2a3f078b89fb753ce4ed87e0c1a58bb19b4f0cfb6586dedb9fcab99d097d659a489fb40e14651741e1375cfc4b6c5f +8ef476b118e0b868caed297c161f4231bbeb863cdfa5e2eaa0fc6b6669425ce7af50dc374abceac154c287de50c22307 +92e46ab472c56cfc6458955270d3c72b7bde563bb32f7d4ab4d959db6f885764a3d864e1aa19802fefaa5e16b0cb0b54 +96a3f68323d1c94e73d5938a18a377af31b782f56212de3f489d22bc289cf24793a95b37f1d6776edf88114b5c1fa695 +962cc068cfce6faaa27213c4e43e44eeff0dfbb6d25b814e82c7da981fb81d7d91868fa2344f05fb552362f98cfd4a72 +895d4e4c4ad670abf66d43d59675b1add7afad7438ada8f42a0360c704cee2060f9ac15b4d27e9b9d0996bb801276fe3 +b3ad18d7ece71f89f2ef749b853c45dc56bf1c796250024b39a1e91ed11ca32713864049c9aaaea60cde309b47486bbf +8f05404e0c0258fdbae50e97ccb9b72ee17e0bd2400d9102c0dad981dac8c4c71585f03e9b5d50086d0a2d3334cb55d1 +8bd877e9d4591d02c63c6f9fc9976c109de2d0d2df2bfa5f6a3232bab5b0b8b46e255679520480c2d7a318545efa1245 +8d4c16b5d98957c9da13d3f36c46f176e64e5be879f22be3179a2c0e624fe4758a82bf8c8027410002f973a3b84cd55a +86e2a8dea86427b424fa8eada881bdff896907084a495546e66556cbdf070b78ba312bf441eb1be6a80006d25d5097a3 +8608b0c117fd8652fdab0495b08fadbeba95d9c37068e570de6fddfef1ba4a1773b42ac2be212836141d1bdcdef11a17 +a13d6febf5fb993ae76cae08423ca28da8b818d6ef0fde32976a4db57839cd45b085026b28ee5795f10a9a8e3098c683 +8e261967fa6de96f00bc94a199d7f72896a6ad8a7bbb1d6187cca8fad824e522880e20f766620f4f7e191c53321d70f9 +8b8e8972ac0218d7e3d922c734302803878ad508ca19f5f012bc047babd8a5c5a53deb5fe7c15a4c00fd6d1cb9b1dbd0 +b5616b233fb3574a2717d125a434a2682ff68546dccf116dd8a3b750a096982f185614b9fb6c7678107ff40a451f56fa +aa6adf9b0c3334b0d0663f583a4914523b2ac2e7adffdb026ab9109295ff6af003ef8357026dbcf789896d2afded8d73 +acb72df56a0b65496cd534448ed4f62950bb1e11e50873b6ed349c088ee364441821294ce0f7c61bd7d38105bea3b442 +abae12df83e01ec947249fedd0115dc501d2b03ff7232092979eda531dbbca29ace1d46923427c7dde4c17bdf3fd7708 +820b4fc2b63a9fda7964acf5caf19a2fc4965007cb6d6b511fcafcb1f71c3f673a1c0791d3f86e3a9a1eb6955b191cc0 +af277259d78c6b0f4f030a10c53577555df5e83319ddbad91afbd7c30bc58e7671c56d00d66ec3ab5ef56470cd910cee +ad4a861c59f1f5ca1beedd488fb3d131dea924fffd8e038741a1a7371fad7370ca5cf80dc01f177fbb9576713bb9a5b3 +b67a5162982ce6a55ccfb2f177b1ec26b110043cf18abd6a6c451cf140b5af2d634591eb4f28ad92177d8c7e5cd0a5e8 +96176d0a83816330187798072d449cbfccff682561e668faf6b1220c9a6535b32a6e4f852e8abb00f79abb87493df16b +b0afe6e7cb672e18f0206e4423f51f8bd0017bf464c4b186d46332c5a5847647f89ff7fa4801a41c1b0b42f6135bcc92 +8fc5e7a95ef20c1278c645892811f6fe3f15c431ebc998a32ec0da44e7213ea934ed2be65239f3f49b8ec471e9914160 +b7793e41adda6c82ba1f2a31f656f6205f65bf8a3d50d836ee631bc7ce77c153345a2d0fc5c60edf8b37457c3729c4ec +a504dd7e4d6b2f4379f22cc867c65535079c75ccc575955f961677fa63ecb9f74026fa2f60c9fb6323c1699259e5e9c8 +ab899d00ae693649cc1afdf30fb80d728973d2177c006e428bf61c7be01e183866614e05410041bc82cb14a33330e69c +8a3bd8b0b1be570b65c4432a0f6dc42f48a2000e30ab089cf781d38f4090467b54f79c0d472fcbf18ef6a00df69cc6f3 +b4d7028f7f76a96a3d7803fca7f507ae11a77c5346e9cdfccb120a833a59bda1f4264e425aa588e7a16f8e7638061d84 +b9c7511a76ea5fb105de905d44b02edb17008335766ee357ed386b7b3cf19640a98b38785cb14603c1192bee5886c9b6 +8563afb12e53aed71ac7103ab8602bfa8371ae095207cb0d59e8fd389b6ad1aff0641147e53cb6a7ca16c7f37c9c5e6b +8e108be614604e09974a9ed90960c28c4ea330a3d9a0cb4af6dd6f193f84ab282b243ecdf549b3131036bebc8905690c +b794d127fbedb9c5b58e31822361706ffac55ce023fbfe55716c3c48c2fd2f2c7660a67346864dfe588812d369cb50b6 +b797a3442fc3b44f41baefd30346f9ac7f96e770d010d53c146ce74ce424c10fb62758b7e108b8abfdc5fafd89d745cb +993bb71e031e8096442e6205625e1bfddfe6dd6a83a81f3e2f84fafa9e5082ab4cad80a099f21eff2e81c83457c725c3 +8711ab833fc03e37acf2e1e74cfd9133b101ff4144fe30260654398ae48912ab46549d552eb9d15d2ea57760d35ac62e +b21321fd2a12083863a1576c5930e1aecb330391ef83326d9d92e1f6f0d066d1394519284ddab55b2cb77417d4b0292f +877d98f731ffe3ee94b0b5b72d127630fa8a96f6ca4f913d2aa581f67732df6709493693053b3e22b0181632ac6c1e3b +ae391c12e0eb8c145103c62ea64f41345973311c3bf7281fa6bf9b7faafac87bcf0998e5649b9ef81e288c369c827e07 +b83a2842f36998890492ab1cd5a088d9423d192681b9a3a90ec518d4c541bce63e6c5f4df0f734f31fbfdd87785a2463 +a21b6a790011396e1569ec5b2a423857b9bec16f543e63af28024e116c1ea24a3b96e8e4c75c6537c3e4611fd265e896 +b4251a9c4aab3a495da7a42e684ba4860dbcf940ad1da4b6d5ec46050cbe8dab0ab9ae6b63b5879de97b905723a41576 +8222f70aebfe6ac037f8543a08498f4cadb3edaac00336fc00437eb09f2cba758f6c38e887cc634b4d5b7112b6334836 +86f05038e060594c46b5d94621a1d9620aa8ba59a6995baf448734e21f58e23c1ea2993d3002ad5250d6edd5ba59b34f +a7c0c749baef811ab31b973c39ceb1d94750e2bc559c90dc5eeb20d8bb6b78586a2b363c599ba2107d6be65cd435f24e +861d46a5d70b38d6c1cd72817a2813803d9f34c00320c8b62f8b9deb67f5b5687bc0b37c16d28fd017367b92e05da9ca +b3365d3dab639bffbe38e35383686a435c8c88b397b717cd4aeced2772ea1053ceb670f811f883f4e02975e5f1c4ac58 +a5750285f61ab8f64cd771f6466e2c0395e01b692fd878f2ef2d5c78bdd8212a73a3b1dfa5e4c8d9e1afda7c84857d3b +835a10809ccf939bc46cf950a33b36d71be418774f51861f1cd98a016ade30f289114a88225a2c11e771b8b346cbe6ef +a4f59473a037077181a0a62f1856ec271028546ca9452b45cedfcb229d0f4d1aabfc13062b07e536cc8a0d4b113156a2 +95cd14802180b224d44a73cc1ed599d6c4ca62ddcaa503513ccdc80aaa8be050cc98bd4b4f3b639549beb4587ac6caf9 +973b731992a3e69996253d7f36dd7a0af1982b5ed21624b77a7965d69e9a377b010d6dabf88a8a97eec2a476259859cc +af8a1655d6f9c78c8eb9a95051aa3baaf9c811adf0ae8c944a8d3fcba87b15f61021f3baf6996fa0aa51c81b3cb69de1 +835aad5c56872d2a2d6c252507b85dd742bf9b8c211ccb6b25b52d15c07245b6d89b2a40f722aeb5083a47cca159c947 +abf4e970b02bef8a102df983e22e97e2541dd3650b46e26be9ee394a3ea8b577019331857241d3d12b41d4eacd29a3ac +a13c32449dbedf158721c13db9539ae076a6ce5aeaf68491e90e6ad4e20e20d1cdcc4a89ed9fd49cb8c0dd50c17633c1 +8c8f78f88b7e22dd7e9150ab1c000f10c28e696e21d85d6469a6fe315254740f32e73d81ab1f3c1cf8f544c86df506e8 +b4b77f2acfe945abf81f2605f906c10b88fb4d28628487fb4feb3a09f17f28e9780445dfcee4878349d4c6387a9d17d4 +8d255c235f3812c6ecc646f855fa3832be5cb4dbb9c9e544989fafdf3f69f05bfd370732eaf954012f0044aa013fc9c6 +b982efd3f34b47df37c910148ac56a84e8116647bea24145a49e34e0a6c0176e3284d838dae6230cb40d0be91c078b85 +983f365aa09bd85df2a6a2ad8e4318996b1e27d02090755391d4486144e40d80b1fbfe1c798d626db92f52e33aa634da +95fd1981271f3ea3a41d654cf497e6696730d9ff7369f26bc4d7d15c7adb4823dd0c42e4a005a810af12d234065e5390 +a9f5219bd4b913c186ef30c02f995a08f0f6f1462614ea5f236964e02bdaa33db9d9b816c4aee5829947840a9a07ba60 +9210e6ceb05c09b46fd09d036287ca33c45124ab86315e5d6911ff89054f1101faaa3e83d123b7805056d388bcec6664 +8ed9cbf69c6ff3a5c62dd9fe0d7264578c0f826a29e614bc2fb4d621d90c8c9992438accdd7a614b1dca5d1bb73dc315 +85cf2a8cca93e00da459e3cecd22c342d697eee13c74d5851634844fc215f60053cf84b0e03c327cb395f48d1c71a8a4 +8818a18e9a2ec90a271b784400c1903089ffb0e0b40bc5abbbe12fbebe0f731f91959d98c5519ef1694543e31e2016d4 +8dabc130f296fa7a82870bf9a8405aaf542b222ed9276bba9bd3c3555a0f473acb97d655ee7280baff766a827a8993f0 +ac7952b84b0dc60c4d858f034093b4d322c35959605a3dad2b806af9813a4680cb038c6d7f4485b4d6b2ff502aaeca25 +ad65cb6d57b48a2602568d2ec8010baed0eb440eec7638c5ec8f02687d764e9de5b5d42ad5582934e592b48471c22d26 +a02ab8bd4c3d114ea23aebdd880952f9495912817da8c0c08eabc4e6755439899d635034413d51134c72a6320f807f1c +8319567764b8295402ec1ebef4c2930a138480b37e6d7d01c8b4c9cd1f2fc3f6e9a44ae6e380a0c469b25b06db23305f +afec53b2301dc0caa8034cd9daef78c48905e6068d692ca23d589b84a6fa9ddc2ed24a39480597e19cb3e83eec213b3f +ac0b4ffdb5ae08e586a9cdb98f9fe56f4712af3a97065e89e274feacfb52b53c839565aee93c4cfaaccfe51432c4fab0 +8972cbf07a738549205b1094c5987818124144bf187bc0a85287c94fdb22ce038c0f11df1aa16ec5992e91b44d1af793 +b7267aa6f9e3de864179b7da30319f1d4cb2a3560f2ea980254775963f1523b44c680f917095879bebfa3dc2b603efcf +80f68f4bfc337952e29504ee5149f15093824ea7ab02507efd1317a670f6cbc3611201848560312e3e52e9d9af72eccf +8897fee93ce8fc1e1122e46b6d640bba309384dbd92e46e185e6364aa8210ebf5f9ee7e5e604b6ffba99aa80a10dd7d0 +b58ea6c02f2360be60595223d692e82ee64874fda41a9f75930f7d28586f89be34b1083e03bbc1575bbfdda2d30db1ea +85a523a33d903280d70ac5938770453a58293480170c84926457ac2df45c10d5ff34322ab130ef4a38c916e70d81af53 +a2cbf045e1bed38937492c1f2f93a5ba41875f1f262291914bc1fc40c60bd0740fb3fea428faf6da38b7c180fe8ac109 +8c09328770ed8eb17afc6ac7ddd87bb476de18ed63cab80027234a605806895959990c47bd10d259d7f3e2ecb50074c9 +b4b9e19edb4a33bde8b7289956568a5b6b6557404e0a34584b5721fe6f564821091013fbb158e2858c6d398293bb4b59 +8a47377df61733a2aa5a0e945fce00267f8e950f37e109d4487d92d878fb8b573317bb382d902de515b544e9e233458d +b5804c9d97efeff5ca94f3689b8088c62422d92a1506fd1d8d3b1b30e8a866ad0d6dad4abfa051dfc4471250cac4c5d9 +9084a6ee8ec22d4881e9dcc8a9eb3c2513523d8bc141942370fd191ad2601bf9537a0b1e84316f3209b3d8a54368051e +85447eea2fa26656a649f8519fa67279183044791d61cf8563d0783d46d747d96af31d0a93507bbb2242666aa87d3720 +97566a84481027b60116c751aec552adfff2d9038e68d48c4db9811fb0cbfdb3f1d91fc176a0b0d988a765f8a020bce1 +ae87e5c1b9e86c49a23dceda4ecfd1dcf08567f1db8e5b6ec752ebd45433c11e7da4988573cdaebbb6f4135814fc059e +abee05cf9abdbc52897ac1ce9ed157f5466ed6c383d6497de28616238d60409e5e92619e528af8b62cc552bf09970dc2 +ae6d31cd7bf9599e5ee0828bab00ceb4856d829bba967278a73706b5f388465367aa8a6c7da24b5e5f1fdd3256ef8e63 +ac33e7b1ee47e1ee4af472e37ab9e9175260e506a4e5ce449788075da1b53c44cb035f3792d1eea2aa24b1f688cc6ed3 +80f65b205666b0e089bb62152251c48c380a831e5f277f11f3ef4f0d52533f0851c1b612267042802f019ec900dc0e8f +858520ad7aa1c9fed738e3b583c84168f2927837ad0e1d326afe9935c26e9b473d7f8c382e82ef1fe37d2b39bb40a1ee +b842dd4af8befe00a97c2d0f0c33c93974761e2cb9e5ab8331b25170318ddd5e4bdbc02d8f90cbfdd5f348f4f371c1f7 +8bf2cb79bc783cb57088aae7363320cbeaabd078ffdec9d41bc74ff49e0043d0dad0086a30e5112b689fd2f5a606365d +982eb03bbe563e8850847cd37e6a3306d298ab08c4d63ab6334e6b8c1fa13fce80cf2693b09714c7621d74261a0ff306 +b143edb113dec9f1e5105d4a93fbe502b859e587640d3db2f628c09a17060e6aec9e900e2c8c411cda99bc301ff96625 +af472d9befa750dcebc5428fe1a024f18ec1c07bca0f95643ce6b5f4189892a910285afb03fd7ed7068fbe614e80d33c +a97e3bc57ede73ecd1bbf02de8f51b4e7c1a067da68a3cd719f4ba26a0156cbf1cef2169fd35a18c5a4cced50d475998 +a862253c937cf3d75d7183e5f5be6a4385d526aeda5171c1c60a8381fea79f88f5f52a4fab244ecc70765d5765e6dfd5 +90cb776f8e5a108f1719df4a355bebb04bf023349356382cae55991b31720f0fd03206b895fa10c56c98f52453be8778 +a7614e8d0769dccd520ea4b46f7646e12489951efaef5176bc889e9eb65f6e31758df136b5bf1e9107e68472fa9b46ec +ac3a9b80a3254c42e5ed3a090a0dd7aee2352f480de96ad187027a3bb6c791eddfc3074b6ffd74eea825188f107cda4d +82a01d0168238ef04180d4b6e0a0e39024c02c2d75b065017c2928039e154d093e1af4503f4d1f3d8a948917abb5d09f +8fab000a2b0eef851a483aec8d2dd85fe60504794411a2f73ed82e116960547ac58766cb73df71aea71079302630258d +872451a35c6db61c63e9b8bb9f16b217f985c20be4451c14282c814adb29d7fb13f201367c664435c7f1d4d9375d7a58 +887d9ff54cc96b35d562df4a537ff972d7c4b3fd91ab06354969a4cfede0b9fc68bbffb61d0dbf1a58948dc701e54f5a +8cb5c2a6bd956875d88f41ae24574434f1308514d44057b55c9c70f13a3366ed054150eed0955a38fda3f757be73d55f +89ad0163cad93e24129d63f8e38422b7674632a8d0a9016ee8636184cab177659a676c4ee7efba3abe1a68807c656d60 +b9ec01c7cab6d00359b5a0b4a1573467d09476e05ca51a9227cd16b589a9943d161eef62dcc73f0de2ec504d81f4d252 +8031d17635d39dfe9705c485d2c94830b6fc9bc67b91300d9d2591b51e36a782e77ab5904662effa9382d9cca201f525 +8be5a5f6bc8d680e5092d6f9a6585acbaaaa2ddc671da560dcf5cfa4472f4f184b9597b5b539438accd40dda885687cc +b1fc0f052fae038a2e3de3b3a96b0a1024b009de8457b8b3adb2d315ae68a89af905720108a30038e5ab8d0d97087785 +8b8bdc77bd3a6bc7ca5492b6f8c614852c39a70d6c8a74916eaca0aeb4533b11898b8820a4c2620a97bf35e275480029 +af35f4dc538d4ad5cdf710caa38fd1eb496c3fa890a047b6a659619c5ad3054158371d1e88e0894428282eed9f47f76b +8166454a7089cc07758ad78724654f4e7a1a13e305bbf88ddb86f1a4b2904c4fc8ab872d7da364cdd6a6c0365239e2ad +ab287c7d3addce74ce40491871c768abe01daaa0833481276ff2e56926b38a7c6d2681ffe837d2cc323045ad1a4414f9 +b90317f4505793094d89365beb35537f55a6b5618904236258dd04ca61f21476837624a2f45fef8168acf732cab65579 +98ae5ea27448e236b6657ab5ef7b1cccb5372f92ab25f5fa651fbac97d08353a1dae1b280b1cd42b17d2c6a70a63ab9d +adcf54e752d32cbaa6cb98fbca48d8cd087b1db1d131d465705a0d8042c8393c8f4d26b59006eb50129b21e6240f0c06 +b591a3e4db18a7345fa935a8dd7994bbac5cc270b8ebd84c8304c44484c7a74afb45471fdbe4ab22156a30fae1149b40 +806b53ac049a42f1dcc1d6335505371da0bf27c614f441b03bbf2e356be7b2fb4eed7117eabcce9e427a542eaa2bf7d8 +800482e7a772d49210b81c4a907f5ce97f270b959e745621ee293cf8c71e8989363d61f66a98f2d16914439544ca84c7 +99de9eafdad3617445312341644f2bb888680ff01ce95ca9276b1d2e5ef83fa02dab5e948ebf66c17df0752f1bd37b70 +961ee30810aa4c93ae157fbe9009b8e443c082192bd36a73a6764ff9b2ad8b0948fe9a73344556e01399dd77badb4257 +ae0a361067c52efbe56c8adf982c00432cd478929459fc7f74052c8ee9531cd031fe1335418fde53f7c2ef34254eb7ac +a3503d16b6b27eb20c1b177bcf90d13706169220523a6271b85b2ce35a9a2b9c5bed088540031c0a4ebfdae3a4c6ab04 +909420122c3e723289ca4e7b81c2df5aff312972a2203f4c45821b176e7c862bf9cac7f7df3adf1d59278f02694d06e7 +989f42380ae904b982f85d0c6186c1aef5d6bcba29bcfbb658e811b587eb2749c65c6e4a8cc6409c229a107499a4f5d7 +8037a6337195c8e26a27ea4ef218c6e7d79a9720aaab43932d343192abc2320fe72955f5e431c109093bda074103330a +b312e168663842099b88445e940249cc508f080ab0c94331f672e7760258dbd86be5267e4cf25ea25facb80bff82a7e9 +aaa3ff8639496864fcdbfdda1ac97edc4f08e3c9288b768f6c8073038c9fbbf7e1c4bea169b4d45c31935cdf0680d45e +97dbd3df37f0b481a311dfc5f40e59227720f367912200d71908ef6650f32cc985cb05b981e3eea38958f7e48d10a15d +a89d49d1e267bb452d6cb621b9a90826fe55e9b489c0427b94442d02a16f390eed758e209991687f73f6b5a032321f42 +9530dea4e0e19d6496f536f2e75cf7d814d65fde567055eb20db48fd8d20d501cd2a22fb506db566b94c9ee10f413d43 +81a7009b9e67f1965fa7da6a57591c307de91bf0cd35ab4348dc4a98a4961e096d004d7e7ad318000011dc4342c1b809 +83440a9402b766045d7aca61a58bba2aa29cac1cf718199e472ba086f5d48093d9dda4d135292ba51d049a23964eceae +a06c9ce5e802df14f6b064a3d1a0735d429b452f0e2e276042800b0a4f16df988fd94cf3945921d5dd3802ab2636f867 +b1359e358b89936dee9e678a187aad3e9ab14ac40e96a0a68f70ee2583cdcf467ae03bef4215e92893f4e12f902adec8 +835304f8619188b4d14674d803103d5a3fa594d48e96d9699e653115dd05fdc2dda6ba3641cf7ad53994d448da155f02 +8327cba5a9ff0d3f5cd0ae55e77167448926d5fcf76550c0ad978092a14122723090c51c415e88e42a2b62eb07cc3981 +b373dcdaea85f85ce9978b1426a7ef4945f65f2d3467a9f1cc551a99766aac95df4a09e2251d3f89ca8c9d1a7cfd7b0e +ab1422dc41af2a227b973a6fd124dfcb2367e2a11a21faa1d381d404f51b7257e5bc82e9cf20cd7fe37d7ae761a2ab37 +a93774a03519d2f20fdf2ef46547b0a5b77c137d6a3434b48d56a2cbef9e77120d1b85d0092cf8842909213826699477 +8eb967a495a38130ea28711580b7e61bcd1d051cd9e4f2dbf62f1380bd86e0d60e978d72f6f31e909eb97b3b9a2b867c +ae8213378da1287ba1fe4242e1acaec19b877b6fe872400013c6eac1084b8d03156792fa3020201725b08228a1e80f49 +b143daf6893d674d607772b3b02d8ac48f294237e2f2c87963c0d4e26d9227d94a2a13512457c3d5883544bbc259f0ef +b343bd2aca8973888e42542218924e2dda2e938fd1150d06878af76f777546213912b7c7a34a0f94186817d80ffa185c +b188ebc6a8c3007001aa347ae72cc0b15d09bc6c19a80e386ee4b334734ec0cc2fe8b493c2422f38d1e6d133cc3db6fe +b795f6a8b9b826aaeee18ccd6baf6c5adeeec85f95eb5b6d19450085ec7217e95a2d9e221d77f583b297d0872073ba0e +b1c7dbd998ad32ae57bfa95deafa147024afd57389e98992c36b6e52df915d3d5a39db585141ec2423173e85d212fed8 +812bcdeb9fe5f12d0e1df9964798056e1f1c3de3b17b6bd2919b6356c4b86d8e763c01933efbe0224c86a96d5198a4be +b19ebeda61c23d255cbf472ef0b8a441f4c55b70f0d8ed47078c248b1d3c7c62e076b43b95c00a958ec8b16d5a7cb0d7 +b02adc9aaa20e0368a989c2af14ff48b67233d28ebee44ff3418bb0473592e6b681af1cc45450bd4b175df9051df63d9 +8d87f0714acee522eb58cec00360e762adc411901dba46adc9227124fa70ee679f9a47e91a6306d6030dd4eb8de2f3c1 +8be54cec21e74bcc71de29dc621444263737db15f16d0bb13670f64e42f818154e04b484593d19ef95f2ee17e4b3fe21 +ab8e20546c1db38d31493b5d5f535758afb17e459645c1b70813b1cf7d242fd5d1f4354a7c929e8f7259f6a25302e351 +89f035a1ed8a1e302ac893349ba8ddf967580fcb6e73d44af09e3929cde445e97ff60c87dafe489e2c0ab9c9986cfa00 +8b2b0851a795c19191a692af55f7e72ad2474efdc5401bc3733cfdd910e34c918aaebe69d5ea951bdddf3c01cabbfc67 +a4edb52c2b51495ccd1ee6450fc14b7b3ede8b3d106808929d02fb31475bacb403e112ba9c818d2857651e508b3a7dd1 +9569341fded45d19f00bcf3cbf3f20eb2b4d82ef92aba3c8abd95866398438a2387437e580d8b646f17cf6fde8c5af23 +aa4b671c6d20f72f2f18a939a6ff21cc37e0084b44b4a717f1be859a80b39fb1be026b3205adec2a66a608ec2bcd578f +94902e980de23c4de394ad8aec91b46f888d18f045753541492bfbb92c59d3daa8de37ae755a6853744af8472ba7b72b +af651ef1b2a0d30a7884557edfad95b6b5d445a7561caebdc46a485aedd25932c62c0798465c340a76f6feaa196dd712 +b7b669b8e5a763452128846dd46b530dca4893ace5cc5881c7ddcd3d45969d7e73fbebdb0e78aa81686e5f7b22ec5759 +82507fd4ebe9fa656a7f2e084d64a1fa6777a2b0bc106d686e2d9d2edafc58997e58cb6bfd0453b2bf415704aa82ae62 +b40bce2b42b88678400ecd52955bbdadd15f8b9e1b3751a1a3375dc0efb5ca3ee258cf201e1140b3c09ad41217d1d49e +b0210d0cbb3fbf3b8cdb39e862f036b0ff941cd838e7aaf3a8354e24246e64778d22f3de34572e6b2a580614fb6425be +876693cba4301b251523c7d034108831df3ce133d8be5a514e7a2ca494c268ca0556fa2ad8310a1d92a16b55bcd99ea9 +8660281406d22a4950f5ef050bf71dd3090edb16eff27fa29ef600cdea628315e2054211ed2cc6eaf8f2a1771ef689fd +a610e7e41e41ab66955b809ba4ade0330b8e9057d8efc9144753caed81995edeb1a42a53f93ce93540feca1fae708dac +a49e2c176a350251daef1218efaccc07a1e06203386ede59c136699d25ca5cb2ac1b800c25b28dd05678f14e78e51891 +83e0915aa2b09359604566080d411874af8c993beba97d4547782fdbe1a68e59324b800ff1f07b8db30c71adcbd102a8 +a19e84e3541fb6498e9bb8a099c495cbfcad113330e0262a7e4c6544495bb8a754b2208d0c2d895c93463558013a5a32 +87f2bd49859a364912023aca7b19a592c60214b8d6239e2be887ae80b69ebdeb59742bdebcfa73a586ab23b2c945586c +b8e8fdddae934a14b57bc274b8dcd0d45ebb95ddbaabef4454e0f6ce7d3a5a61c86181929546b3d60c447a15134d08e1 +87e0c31dcb736ea4604727e92dc1d9a3cf00adcff79df3546e02108355260f3dd171531c3c0f57be78d8b28058fcc8c0 +9617d74e8f808a4165a8ac2e30878c349e1c3d40972006f0787b31ea62d248c2d9f3fc3da83181c6e57e95feedfd0e8c +8949e2cee582a2f8db86e89785a6e46bc1565c2d8627d5b6bf43ba71ffadfab7e3c5710f88dcb5fb2fc6edf6f4fae216 +ad3fa7b0edceb83118972a2935a09f409d09a8db3869f30be3a76f67aa9fb379cabb3a3aff805ba023a331cad7d7eb64 +8c95718a4112512c4efbd496be38bf3ca6cdcaad8a0d128f32a3f9aae57f3a57bdf295a3b372a8c549fda8f4707cffed +88f3261d1e28a58b2dee3fcc799777ad1c0eb68b3560f9b4410d134672d9533532a91ea7be28a041784872632d3c9d80 +b47472a41d72dd2e8b72f5c4f8ad626737dde3717f63d6bc776639ab299e564cbad0a2ad5452a07f02ff49a359c437e5 +9896d21dc2e8aad87b76d6df1654f10cd7bceed4884159d50a818bea391f8e473e01e14684814c7780235f28e69dca6e +82d47c332bbd31bbe83b5eb44a23da76d4a7a06c45d7f80f395035822bc27f62f59281d5174e6f8e77cc9b5c3193d6f0 +95c74cd46206e7f70c9766117c34c0ec45c2b0f927a15ea167901a160e1530d8522943c29b61e03568aa0f9c55926c53 +a89d7757825ae73a6e81829ff788ea7b3d7409857b378ebccd7df73fdbe62c8d9073741cf038314971b39af6c29c9030 +8c1cd212d0b010905d560688cfc036ae6535bc334fa8b812519d810b7e7dcf1bb7c5f43deaa40f097158358987324a7f +b86993c383c015ed8d847c6b795164114dd3e9efd25143f509da318bfba89389ea72a420699e339423afd68b6512fafb +8d06bd379c6d87c6ed841d8c6e9d2d0de21653a073725ff74be1934301cc3a79b81ef6dd0aad4e7a9dc6eac9b73019bc +81af4d2d87219985b9b1202d724fe39ef988f14fef07dfe3c3b11714e90ffba2a97250838e8535eb63f107abfe645e96 +8c5e0af6330a8becb787e4b502f34f528ef5756e298a77dc0c7467433454347f3a2e0bd2641fbc2a45b95e231c6e1c02 +8e2a8f0f04562820dc8e7da681d5cad9fe2e85dd11c785fb6fba6786c57a857e0b3bd838fb849b0376c34ce1665e4837 +a39be8269449bfdfc61b1f62077033649f18dae9bef7c6163b9314ca8923691fb832f42776f0160b9e8abd4d143aa4e1 +8c154e665706355e1cc98e0a4cabf294ab019545ba9c4c399d666e6ec5c869ca9e1faf8fb06cd9c0a5c2f51a7d51b70a +a046a7d4de879d3ebd4284f08f24398e9e3bf006cd4e25b5c67273ade248689c69affff92ae810c07941e4904296a563 +afd94c1cb48758e5917804df03fb38a6da0e48cd9b6262413ea13b26973f9e266690a1b7d9d24bbaf7e82718e0e594b0 +859e21080310c8d6a38e12e2ac9f90a156578cdeb4bb2e324700e97d9a5511cd6045dc39d1d0de3f94aeed043a24119d +a219fb0303c379d0ab50893264919f598e753aac9065e1f23ef2949abc992577ab43c636a1d2c089203ec9ddb941e27d +b0fdb639d449588a2ca730afcba59334e7c387342d56defdfb7ef79c493f7fd0e5277eff18e7203e756c7bdda5803047 +87f9c3b7ed01f54368aca6dbcf2f6e06bff96e183c4b2c65f8baa23b377988863a0a125d5cdd41a072da8462ced4c070 +99ef7a5d5ac2f1c567160e1f8c95f2f38d41881850f30c461a205f7b1b9fb181277311333839b13fb3ae203447e17727 +aeaca9b1c2afd24e443326cc68de67b4d9cedb22ad7b501a799d30d39c85bb2ea910d4672673e39e154d699e12d9b3dc +a11675a1721a4ba24dd3d0e4c3c33a6edf4cd1b9f6b471070b4386c61f77452266eae6e3f566a40cfc885eada9a29f23 +b228334445e37b9b49cb4f2cc56b454575e92173ddb01370a553bba665adadd52df353ad74470d512561c2c3473c7bb9 +a18177087c996572d76f81178d18ed1ceebc8362a396348ce289f1d8bd708b9e99539be6fccd4acb1112381cfc5749b4 +8e7b8bf460f0d3c99abb19803b9e43422e91507a1c0c22b29ee8b2c52d1a384da4b87c292e28eff040db5be7b1f8641f +b03d038d813e29688b6e6f444eb56fec3abba64c3d6f890a6bcf2e916507091cdb2b9d2c7484617be6b26552ed1c56cb +a1c88ccd30e934adfc5494b72655f8afe1865a84196abfb376968f22ddc07761210b6a9fb7638f1413d1b4073d430290 +961b714faebf172ad2dbc11902461e286e4f24a99a939152a53406117767682a571057044decbeb3d3feef81f4488497 +a03dc4059b46effdd786a0a03cc17cfee8585683faa35bb07936ded3fa3f3a097f518c0b8e2db92fd700149db1937789 +adf60180c99ca574191cbcc23e8d025b2f931f98ca7dfcebfc380226239b6329347100fcb8b0fcb12db108c6ad101c07 +805d4f5ef24d46911cbf942f62cb84b0346e5e712284f82b0db223db26d51aabf43204755eb19519b00e665c7719fcaa +8dea7243e9c139662a7fe3526c6c601eee72fd8847c54c8e1f2ad93ef7f9e1826b170afe58817dac212427164a88e87f +a2ba42356606d651b077983de1ad643650997bb2babb188c9a3b27245bb65d2036e46667c37d4ce02cb1be5ae8547abe +af2ae50b392bdc013db2d12ce2544883472d72424fc767d3f5cb0ca2d973fc7d1f425880101e61970e1a988d0670c81b +98e6bec0568d3939b31d00eb1040e9b8b2a35db46ddf4369bdaee41bbb63cc84423d29ee510a170fb5b0e2df434ba589 +822ff3cd12fbef4f508f3ca813c04a2e0b9b799c99848e5ad3563265979e753ee61a48f6adc2984a850f1b46c1a43d35 +891e8b8b92a394f36653d55725ef514bd2e2a46840a0a2975c76c2a935577f85289026aaa74384da0afe26775cbddfb9 +b2a3131a5d2fe7c8967047aa66e4524babae941d90552171cc109527f345f42aa0df06dcbb2fa01b33d0043917bbed69 +80c869469900431f3eeefafdbe07b8afd8cee7739e659e6d0109b397cacff85a88247698f87dc4e2fe39a592f250ac64 +9091594f488b38f9d2bb5df49fd8b4f8829d9c2f11a197dd1431ed5abbc5c954bbde3387088f9ee3a5a834beb7619bce +b472e241e6956146cca57b97a8a204668d050423b4e76f857bad5b47f43b203a04c8391ba9d9c3e95093c071f9d376a1 +b7dd2de0284844392f7dfb56fe7ca3ede41e27519753ffc579a0a8d2d65ceb8108d06b6b0d4c3c1a2588951297bd1a1e +902116ce70d0a079ac190321c1f48701318c05f8e69ee09694754885d33a835a849cafe56f499a2f49f6cda413ddf9a7 +b18105cc736787fafaf7c3c11c448bce9466e683159dff52723b7951dff429565e466e4841d982e3aaa9ee2066838666 +97ab9911f3f659691762d568ae0b7faa1047b0aed1009c319fa79d15d0db8db9f808fc385dc9a68fa388c10224985379 +b2a2cba65f5b927e64d2904ba412e2bac1cf18c9c3eda9c72fb70262497ecf505b640827e2afebecf10eebbcf48ccd3e +b36a3fd677baa0d3ef0dac4f1548ff50a1730286b8c99d276a0a45d576e17b39b3cbadd2fe55e003796d370d4be43ce3 +a5dfec96ca3c272566e89dc453a458909247e3895d3e44831528130bc47cc9d0a0dac78dd3cad680a4351d399d241967 +8029382113909af6340959c3e61db27392531d62d90f92370a432aec3eb1e4c36ae1d4ef2ba8ec6edb4d7320c7a453f6 +971d85121ea108e6769d54f9c51299b0381ece8b51d46d49c89f65bedc123bab4d5a8bc14d6f67f4f680077529cbae4c +98ff6afc01d0bec80a278f25912e1b1ebff80117adae72e31d5b9fa4d9624db4ba2065b444df49b489b0607c45e26c4c +8fa29be10fb3ab30ce25920fec0187e6e91e458947009dabb869aade7136c8ba23602682b71e390c251f3743164cbdaa +b3345c89eb1653418fe3940cf3e56a9a9c66526389b98f45ca02dd62bfb37baa69a4baaa7132d7320695f8ea6ad1fd94 +b72c7f5541c9ac6b60a7ec9f5415e7fb14da03f7164ea529952a29399f3a071576608dbbcc0d45994f21f92ddbeb1e19 +aa3450bb155a5f9043d0ef95f546a2e6ade167280bfb75c9f09c6f9cdb1fffb7ce8181436161a538433afa3681c7a141 +92a18fecaded7854b349f441e7102b638ababa75b1b0281dd0bded6541abe7aa37d96693595be0b01fe0a2e2133d50f9 +980756ddf9d2253cfe6c94960b516c94889d09e612810935150892627d2ecee9a2517e04968eea295d0106850c04ca44 +ae68c6ccc454318cdd92f32b11d89116a3b8350207a36d22a0f626718cad671d960090e054c0c77ac3162ae180ecfd4b +99f31f66eaaa551749ad91d48a0d4e3ff4d82ef0e8b28f3184c54e852422ba1bdafd53b1e753f3a070f3b55f3c23b6a2 +a44eaeaa6589206069e9c0a45ff9fc51c68da38d4edff1d15529b7932e6f403d12b9387019c44a1488a5d5f27782a51f +b80b5d54d4b344840e45b79e621bd77a3f83fb4ce6d8796b7d6915107b3f3c34d2e7d95bdafd120f285669e5acf2437a +b36c069ec085a612b5908314d6b84c00a83031780261d1c77a0384c406867c9847d5b0845deddfa512cc04a8df2046fb +b09dbe501583220f640d201acea7ee3e39bf9eda8b91aa07b5c50b7641d86d71acb619b38d27835ce97c3759787f08e9 +87403d46a2bf63170fff0b857acacf42ee801afe9ccba8e5b4aea967b68eac73a499a65ca46906c2eb4c8f27bc739faa +82b93669f42a0a2aa5e250ffe6097269da06a9c02fcd1801abbad415a7729a64f830754bafc702e64600ba47671c2208 +8e3a3029be7edb8dd3ab1f8216664c8dc50d395f603736061d802cef77627db7b859ef287ed850382c13b4d22d6a2d80 +968e9ec7194ff424409d182ce0259acd950c384c163c04463bc8700a40b79beba6146d22b7fa7016875a249b7b31c602 +8b42c984bbe4996e0c20862059167c6bdc5164b1ffcd928f29512664459212d263e89f0f0e30eed4e672ffa5ed0b01b5 +96bac54062110dada905363211133f1f15dc7e4fd80a4c6e4a83bc9a0bcbbaba11cd2c7a13debcf0985e1a954c1da66b +a16dc8a653d67a7cd7ae90b2fffac0bf1ca587005430fe5ba9403edd70ca33e38ba5661d2ed6e9d2864400d997626a62 +a68ab11a570a27853c8d67e491591dcba746bfbee08a2e75ae0790399130d027ed387f41ef1d7de8df38b472df309161 +92532b74886874447c0300d07eda9bbe4b41ed25349a3da2e072a93fe32c89d280f740d8ff70d5816793d7f2b97373cc +88e35711b471e89218fd5f4d0eadea8a29405af1cd81974427bc4a5fb26ed60798daaf94f726c96e779b403a2cd82820 +b5c72aa4147c19f8c4f3a0a62d32315b0f4606e0a7025edc5445571eaf4daff64f4b7a585464821574dd50dbe1b49d08 +9305d9b4095258e79744338683fd93f9e657367b3ab32d78080e51d54eec331edbc224fad5093ebf8ee4bd4286757eb8 +b2a17abb3f6a05bcb14dc7b98321fa8b46d299626c73d7c6eb12140bf4c3f8e1795250870947af817834f033c88a59d6 +b3477004837dbd8ba594e4296f960fc91ab3f13551458445e6c232eb04b326da803c4d93e2e8dcd268b4413305ff84da +924b4b2ebaafdcfdfedb2829a8bf46cd32e1407d8d725a5bd28bdc821f1bafb3614f030ea4352c671076a63494275a3f +8b81b9ef6125c82a9bece6fdcb9888a767ac16e70527753428cc87c56a1236e437da8be4f7ecfe57b9296dc3ae7ba807 +906e19ec8b8edd58bdf9ae05610a86e4ea2282b1bbc1e8b00b7021d093194e0837d74cf27ac9916bdb8ec308b00da3da +b41c5185869071760ac786078a57a2ab4e2af60a890037ac0c0c28d6826f15c2cf028fddd42a9b6de632c3d550bfbc14 +a646e5dec1b713ae9dfdf7bdc6cd474d5731a320403c7dfcfd666ffc9ae0cff4b5a79530e8df3f4aa9cb80568cb138e9 +b0efad22827e562bd3c3e925acbd0d9425d19057868608d78c2209a531cccd0f2c43dc5673acf9822247428ffa2bb821 +a94c19468d14b6f99002fc52ac06bbe59e5c472e4a0cdb225144a62f8870b3f10593749df7a2de0bd3c9476ce682e148 +803864a91162f0273d49271dafaab632d93d494d1af935aefa522768af058fce52165018512e8d6774976d52bd797e22 +a08711c2f7d45c68fb340ac23597332e1bcaec9198f72967b9921204b9d48a7843561ff318f87908c05a44fc35e3cc9d +91c3cad94a11a3197ae4f9461faab91a669e0dddb0371d3cab3ed9aeb1267badc797d8375181130e461eadd05099b2a2 +81bdaaf48aae4f7b480fc13f1e7f4dd3023a41439ba231760409ce9292c11128ab2b0bdbbf28b98af4f97b3551f363af +8d60f9df9fd303f625af90e8272c4ecb95bb94e6efc5da17b8ab663ee3b3f673e9f6420d890ccc94acf4d2cae7a860d8 +a7b75901520c06e9495ab983f70b61483504c7ff2a0980c51115d11e0744683ce022d76e3e09f4e99e698cbd21432a0d +82956072df0586562fda7e7738226f694e1c73518dd86e0799d2e820d7f79233667192c9236dcb27637e4c65ef19d493 +a586beb9b6ffd06ad200957490803a7cd8c9bf76e782734e0f55e04a3dc38949de75dc607822ec405736c576cf83bca3 +a179a30d00def9b34a7e85607a447eea0401e32ab5abeee1a281f2acd1cf6ec81a178020666f641d9492b1bdf66f05a3 +83e129705c538787ed8e0fdc1275e6466a3f4ee21a1e6abedd239393b1df72244723b92f9d9d9339a0cab6ebf28f5a16 +811bd8d1e3722b64cd2f5b431167e7f91456e8bba2cc669d3fbbce7d553e29c3c19f629fcedd2498bc26d33a24891d17 +a243c030c858f1f60cccd26b45b024698cc6d9d9e6198c1ed4964a235d9f8d0baf9cde10c8e63dfaa47f8e74e51a6e85 +ab839eb82e23ca52663281f863b55b0a3d6d4425c33ffb4eeb1d7979488ab068bf99e2a60e82cea4dc42c56c26cbfebe +8b896f9bb21d49343e67aec6ad175b58c0c81a3ca73d44d113ae4354a0065d98eb1a5cafedaf232a2bb9cdc62152f309 +af6230340cc0b66f5bf845540ed4fc3e7d6077f361d60762e488d57834c3e7eb7eacc1b0ed73a7d134f174a01410e50c +88975e1b1af678d1b5179f72300a30900736af580dd748fd9461ef7afccc91ccd9bed33f9da55c8711a7635b800e831f +a97486bb9047391661718a54b8dd5a5e363964e495eae6c692730264478c927cf3e66dd3602413189a3699fbeae26e15 +a5973c161ab38732885d1d2785fd74bf156ba34881980cba27fe239caef06b24a533ffe6dbbbeca5e6566682cc00300a +a24776e9a840afda0003fa73b415d5bd6ecd9b5c2cc842b643ee51b8c6087f4eead4d0bfbd987eb174c489a7b952ff2a +a8a6ee06e3af053b705a12b59777267c546f33ba8a0f49493af8e6df4e15cf8dd2d4fb4daf7e84c6b5d3a7363118ff03 +a28e59ce6ad02c2ce725067c0123117e12ac5a52c8f5af13eec75f4a9efc4f696777db18a374fa33bcae82e0734ebd16 +86dfc3b78e841c708aff677baa8ee654c808e5d257158715097c1025d46ece94993efe12c9d188252ad98a1e0e331fec +a88d0275510f242eab11fdb0410ff6e1b9d7a3cbd3658333539815f1b450a84816e6613d15aa8a8eb15d87cdad4b27a2 +8440acea2931118a5b481268ff9f180ee4ede85d14a52c026adc882410825b8275caa44aff0b50c2b88d39f21b1a0696 +a7c3182eab25bd6785bacf12079d0afb0a9b165d6ed327814e2177148539f249eb9b5b2554538f54f3c882d37c0a8abe +85291fbe10538d7da38efdd55a7acebf03b1848428a2f664c3ce55367aece60039f4f320b1771c9c89a35941797f717c +a2c6414eeb1234728ab0de94aa98fc06433a58efa646ca3fcbd97dbfb8d98ae59f7ce6d528f669c8149e1e13266f69c9 +840c8462785591ee93aee2538d9f1ec44ba2ca61a569ab51d335ac873f5d48099ae8d7a7efa0725d9ff8f9475bfa4f56 +a7065a9d02fb3673acf7702a488fbc01aa69580964932f6f40b6c2d1c386b19e50b0e104fcac24ea26c4e723611d0238 +b72db6d141267438279e032c95e6106c2ccb3164b842ba857a2018f3a35f4b040da92680881eb17cd61d0920d5b8f006 +a8005d6c5960e090374747307ef0be2871a7a43fa4e76a16c35d2baab808e9777b496e9f57a4218b23390887c33a0b55 +8e152cea1e00a451ca47c20a1e8875873419700af15a5f38ee2268d3fbc974d4bd5f4be38008fa6f404dbdedd6e6e710 +a3391aed1fcd68761f06a7d1008ec62a09b1cb3d0203cd04e300a0c91adfed1812d8bc1e4a3fd7976dc0aae0e99f52f1 +967eb57bf2aa503ee0c6e67438098149eac305089c155f1762cf5e84e31f0fbf27c34a9af05621e34645c1ec96afaec8 +88af97ddc4937a95ec0dcd25e4173127260f91c8db2f6eac84afb789b363705fb3196235af631c70cafd09411d233589 +a32df75b3f2c921b8767638fd289bcfc61e08597170186637a7128ffedd52c798c434485ac2c7de07014f9e895c2c3d8 +b0a783832153650aa0d766a3a73ec208b6ce5caeb40b87177ffc035ab03c7705ecdd1090b6456a29f5fb7e90e2fa8930 +b59c8e803b4c3486777d15fc2311b97f9ded1602fa570c7b0200bada36a49ee9ef4d4c1474265af8e1c38a93eb66b18b +982f2c85f83e852022998ff91bafbb6ff093ef22cf9d5063e083a48b29175ccbd51b9c6557151409e439096300981a6c +939e3b5989fefebb9d272a954659a4eb125b98c9da6953f5e628d26266bd0525ec38304b8d56f08d65abc4d6da4a8dbb +8898212fe05bc8de7d18503cb84a1c1337cc2c09d1eeef2b475aa79185b7322bf1f8e065f1bf871c0c927dd19faf1f6d +94b0393a41cd00f724aee2d4bc72103d626a5aecb4b5486dd1ef8ac27528398edf56df9db5c3d238d8579af368afeb09 +96ac564450d998e7445dd2ea8e3fc7974d575508fa19e1c60c308d83b645864c029f2f6b7396d4ff4c1b24e92e3bac37 +8adf6638e18aff3eb3b47617da696eb6c4bdfbecbbc3c45d3d0ab0b12cbad00e462fdfbe0c35780d21aa973fc150285e +b53f94612f818571b5565bbb295e74bada9b5f9794b3b91125915e44d6ddcc4da25510eab718e251a09c99534d6042d9 +8b96462508d77ee083c376cd90807aebad8de96bca43983c84a4a6f196d5faf6619a2351f43bfeec101864c3bf255519 +aeadf34657083fc71df33bd44af73bf5281c9ca6d906b9c745536e1819ea90b56107c55e2178ebad08f3ba75b3f81c86 +9784ba29b2f0057b5af1d3ab2796d439b8753f1f749c73e791037461bdfc3f7097394283105b8ab01788ea5255a96710 +8756241bda159d4a33bf74faba0d4594d963c370fb6a18431f279b4a865b070b0547a6d1613cf45b8cfb5f9236bbf831 +b03ebfd6b71421dfd49a30460f9f57063eebfe31b9ceaa2a05c37c61522b35bdc09d7db3ad75c76c253c00ba282d3cd2 +b34e7e6341fa9d854b2d3153bdda0c4ae2b2f442ab7af6f99a0975d45725aa48e36ae5f7011edd249862e91f499687d4 +b462ee09dc3963a14354244313e3444de5cc37ea5ccfbf14cd9aca8027b59c4cb2a949bc30474497cab8123e768460e6 +aea753290e51e2f6a21a9a0ee67d3a2713f95c2a5c17fe41116c87d3aa77b1683761264d704df1ac34f8b873bc88ef7b +98430592afd414394f98ddfff9f280fcb1c322dbe3510f45e1e9c4bb8ee306b3e0cf0282c0ee73ebb8ba087d4d9e0858 +b95d3b5aaf54ffca11f4be8d57f76e14afdb20afc859dc7c7471e0b42031e8f3d461b726ecb979bdb2f353498dfe95ea +984d17f9b11a683132e0b5a9ee5945e3ff7054c2d5c716be73b29078db1d36f54c6e652fd2f52a19da313112e97ade07 +ab232f756b3fff3262be418a1af61a7e0c95ceebbc775389622a8e10610508cd6784ab7960441917a83cc191c58829ea +a28f41678d6e60de76b0e36ab10e4516e53e02e9c77d2b5af3cfeee3ce94cfa30c5797bd1daab20c98e1cad83ad0f633 +b55395fca84dd3ccc05dd480cb9b430bf8631ff06e24cb51d54519703d667268c2f8afcde4ba4ed16bece8cc7bc8c6e0 +8a8a5392a0e2ea3c7a8c51328fab11156004e84a9c63483b64e8f8ebf18a58b6ffa8fe8b9d95af0a2f655f601d096396 +ab480000fe194d23f08a7a9ec1c392334e9c687e06851f083845121ce502c06b54dda8c43092bcc1035df45cc752fe9b +b265644c29f628d1c7e8e25a5e845cabb21799371814730a41a363e1bda8a7be50fee7c3996a365b7fcba4642add10db +b8a915a3c685c2d4728f6931c4d29487cad764c5ce23c25e64b1a3259ac27235e41b23bfe7ae982921b4cb84463097df +8efa7338442a4b6318145a5440fc213b97869647eeae41b9aa3c0a27ee51285b73e3ae3b4a9423df255e6add58864aa9 +9106d65444f74d217f4187dfc8fcf3810b916d1e4275f94f6a86d1c4f3565b131fd6cde1fa708bc05fe183c49f14941a +948252dac8026bbbdb0a06b3c9d66ec4cf9532163bab68076fda1bd2357b69e4b514729c15aaa83b5618b1977bbc60c4 +ae6596ccfdf5cbbc5782efe3bb0b101bb132dbe1d568854ca24cacc0b2e0e9fabcb2ca7ab42aecec412efd15cf8cb7a2 +84a0b6c198ff64fd7958dfd1b40eac9638e8e0b2c4cd8cf5d8cdf80419baee76a05184bce6c5b635f6bf2d30055476a7 +8893118be4a055c2b3da593dbca51b1ae2ea2469911acfb27ee42faf3e6c3ad0693d3914c508c0b05b36a88c8b312b76 +b097479e967504deb6734785db7e60d1d8034d6ca5ba9552887e937f5e17bb413fccac2c1d1082154ed76609127860ad +a0294e6b9958f244d29943debf24b00b538b3da1116269b6e452bb12dc742226712fd1a15b9c88195afeb5d2415f505c +b3cc15f635080bc038f61b615f62b5b5c6f2870586191f59476e8368a73641d6ac2f7d0c1f54621982defdb318020230 +99856f49b9fe1604d917c94d09cc0ed753d13d015d30587a94e6631ffd964b214e607deb8a69a8b5e349a7edf4309206 +a8571e113ea22b4b4fce41a094da8c70de37830ae32e62c65c2fa5ad06a9bc29e884b945e73d448c72b176d6ecebfb58 +a9e9c6e52beb0013273c29844956b3ce291023678107cdc785f7b44eff5003462841ad8780761b86aefc6b734adde7cf +80a784b0b27edb51ef2bad3aee80e51778dcaa0f3f5d3dcb5dc5d4f4b2cf7ae35b08de6680ea9dac53f8438b92eb09ef +827b543e609ea328e97e373f70ad72d4915a2d1daae0c60d44ac637231070e164c43a2a58db80a64df1c624a042b38f9 +b449c65e8195202efdcb9bdb4e869a437313b118fef8b510cbbf8b79a4e99376adb749b37e9c20b51b31ed3310169e27 +8ea3028f4548a79a94c717e1ed28ad4d8725b8d6ab18b021063ce46f665c79da3c49440c6577319dab2d036b7e08f387 +897798431cfb17fe39f08f5f854005dc37b1c1ec1edba6c24bc8acb3b88838d0534a75475325a5ea98b326ad47dbad75 +89cf232e6303b0751561960fd4dea5754a28c594daf930326b4541274ffb03c7dd75938e411eb9a375006a70ce38097f +9727c6ae7f0840f0b6c8bfb3a1a5582ceee705e0b5c59b97def7a7a2283edd4d3f47b7971e902a3a2079e40b53ff69b8 +b76ed72b122c48679d221072efc0eeea063cb205cbf5f9ef0101fd10cb1075b8628166c83577cced654e1c001c7882f7 +ae908c42d208759da5ee9b405df85a6532ea35c6f0f6a1288d22870f59d98edc896841b8ac890a538e6c8d1e8b02d359 +809d12fe4039a0ec80dc9be6a89acaab7797e5f7f9b163378f52f9a75a1d73b2e9ae6e3dd49e32ced439783c1cabbef5 +a4149530b7f85d1098ba534d69548c6c612c416e8d35992fc1f64f4deeb41e09e49c6cf7aadbed7e846b91299358fe2d +a49342eacd1ec1148b8df1e253b1c015f603c39de11fa0a364ccb86ea32d69c34fd7aa6980a1fadcd8e785a57fa46f60 +87d43eff5a006dc4dddcf76cc96c656a1f3a68f19f124181feab86c6cc9a52cb9189cdbb423414defdd9bb0ca8ff1ddc +861367e87a9aa2f0f68296ba50aa5dbc5713008d260cc2c7e62d407c2063064749324c4e8156dc21b749656cfebce26b +b5303c2f72e84e170e66ae1b0fbd51b8c7a6f27476eaf5694b64e8737d5c84b51fe90100b256465a4c4156dd873cddb0 +b62849a4f891415d74f434cdc1d23c4a69074487659ca96e1762466b2b7a5d8525b056b891d0feea6fe6845cba8bc7fb +923dd9e0d6590a9307e8c4c23f13bae3306b580e297a937711a8b13e8de85e41a61462f25b7d352b682e8437bf2b4ab3 +9147379860cd713cd46c94b8cdf75125d36c37517fbecf81ace9680b98ce6291cd1c3e472f84249cc3b2b445e314b1b6 +a808a4f17ac21e3fb5cfef404e61fae3693ca3e688d375f99b6116779696059a146c27b06de3ac36da349b0649befd56 +87787e9322e1b75e66c1f0d9ea0915722a232770930c2d2a95e9478c4b950d15ab767e30cea128f9ed65893bfc2d0743 +9036a6ee2577223be105defe1081c48ea7319e112fff9110eb9f61110c319da25a6cea0464ce65e858635b079691ef1f +af5548c7c24e1088c23b57ee14d26c12a83484c9fd9296edf1012d8dcf88243f20039b43c8c548c265ef9a1ffe9c1c88 +a0fff520045e14065965fb8accd17e878d3fcaf9e0af2962c8954e50be6683d31fa0bf4816ab68f08630dbac6bfce52a +b4c1b249e079f6ae1781af1d97a60b15855f49864c50496c09c91fe1946266915b799f0406084d7783f5b1039116dd8b +8b0ffa5e7c498cb3879dddca34743b41eee8e2dea3d4317a6e961b58adb699ef0c92400c068d5228881a2b08121226bf +852ae8b19a1d80aa8ae5382e7ee5c8e7670ceb16640871c56b20b96b66b3b60e00015a3dde039446972e57b49a999ddd +a49942f04234a7d8492169da232cfff8051df86e8e1ba3db46aede02422c689c87dc1d99699c25f96cb763f5ca0983e5 +b04b597b7760cf5dcf411ef896d1661e6d5b0db3257ac2cf64b20b60c6cc18fa10523bb958a48d010b55bac7b02ab3b1 +a494591b51ea8285daecc194b5e5bd45ae35767d0246ac94fae204d674ee180c8e97ff15f71f28b7aeb175b8aea59710 +97d2624919e78406e7460730680dea8e71c8571cf988e11441aeea54512b95bd820e78562c99372d535d96f7e200d20d +ac693ddb00e48f76e667243b9b6a7008424043fb779e4f2252330285232c3fccac4da25cbd6d95fe9ad959ff305a91f6 +8d20ca0a71a64a3f702a0825bb46bd810d03bebfb227683680d474a52f965716ff99e19a165ebaf6567987f4f9ee3c94 +a5c516a438f916d1d68ca76996404792e0a66e97b7f18fc54c917bf10cf3211b62387932756e39e67e47b0bd6e88385a +b089614d830abc0afa435034cec7f851f2f095d479cacf1a3fb57272da826c499a52e7dcbc0eb85f4166fb94778e18e9 +a8dacc943765d930848288192f4c69e2461c4b9bc6e79e30eeef9a543318cf9ae9569d6986c65c5668a89d49993f8e07 +ab5a9361fa339eec8c621bdad0a58078983abd8942d4282b22835d7a3a47e132d42414b7c359694986f7db39386c2e19 +94230517fb57bd8eb26c6f64129b8b2abd0282323bf7b94b8bac7fab27b4ecc2c4290c294275e1a759de19f2216134f3 +b8f158ea5006bc3b90b285246625faaa6ac9b5f5030dc69701b12f3b79a53ec7e92eeb5a63bbd1f9509a0a3469ff3ffc +8b6944fd8cb8540957a91a142fdcda827762aa777a31e8810ca6d026e50370ee1636fc351724767e817ca38804ebe005 +82d1ee40fe1569c29644f79fa6c4033b7ed45cd2c3b343881f6eb0de2e79548fded4787fae19bed6ee76ed76ff9f2f11 +a8924c7035e99eaed244ca165607e7e568b6c8085510dcdbaf6ebdbed405af2e6c14ee27d94ffef10d30aa52a60bf66d +956f82a6c2ae044635e85812581e4866c5fa2f427b01942047d81f6d79a14192f66fbbe77c9ffeaef4e6147097fdd2b5 +b1100255a1bcf5e05b6aff1dfeb6e1d55b5d68d43a7457ba10cc76b61885f67f4d0d5179abda786e037ae95deb8eea45 +99510799025e3e5e8fbf06dedb14c060c6548ba2bda824f687d3999dc395e794b1fb6514b9013f3892b6cf65cb0d65aa +8f9091cebf5e9c809aab415942172258f894e66e625d7388a05289183f01b8d994d52e05a8e69f784fba41db9ea357f0 +a13d2eeb0776bdee9820ecb6693536720232848c51936bb4ef4fe65588d3f920d08a21907e1fdb881c1ad70b3725e726 +a68b8f18922d550284c5e5dc2dda771f24c21965a6a4d5e7a71678178f46df4d8a421497aad8fcb4c7e241aba26378a0 +8b7601f0a3c6ad27f03f2d23e785c81c1460d60100f91ea9d1cab978aa03b523150206c6d52ce7c7769c71d2c8228e9e +a8e02926430813caa851bb2b46de7f0420f0a64eb5f6b805401c11c9091d3b6d67d841b5674fa2b1dce0867714124cd8 +b7968ecba568b8193b3058400af02c183f0a6df995a744450b3f7e0af7a772454677c3857f99c140bbdb2a09e832e8e0 +8f20b1e9ba87d0a3f35309b985f3c18d2e8800f1ca7f0c52cadef773f1496b6070c936eea48c4a1cae83fd2524e9d233 +88aef260042db0d641a51f40639dbeeefa9e9811df30bee695f3791f88a2f84d318f04e8926b7f47bf25956cb9e3754f +9725345893b647e9ba4e6a29e12f96751f1ae25fcaec2173e9a259921a1a7edb7a47159b3c8767e44d9e2689f5aa0f72 +8c281e6f72752cb11e239e4df9341c45106eb7993c160e54423c2bffe10bc39d42624b45a1f673936ef2e1a02fc92f1a +90aba2f68bddb2fcce6c51430dacdfeec43ea8dc379660c99095df11017691ccf5faa27665cf4b9f0eea7728ae53c327 +b7022695c16521c5704f49b7ddbdbec9b5f57ce0ceebe537bc0ebb0906d8196cc855a9afeb8950a1710f6a654464d93f +8fe1b9dd3c6a258116415d36e08374e094b22f0afb104385a5da48be17123e86fb8327baacc4f0d9ebae923d55d99bb5 +817e85d8e3d19a4cbc1dec31597142c2daa4871bda89c2177fa719c00eda3344eb08b82eb92d4aa91a9eaacb3fc09783 +b59053e1081d2603f1ca0ba553804d6fa696e1fd996631db8f62087b26a40dfef02098b0326bb75f99ec83b9267ca738 +990a173d857d3ba81ff3789b931bfc9f5609cde0169b7f055fa3cb56451748d593d62d46ba33f80f9cafffe02b68dd14 +b0c538dbba4954b809ab26f9f94a3cf1dcb77ce289eaec1d19f556c0ae4be1fa03af4a9b7057837541c3cc0a80538736 +ac3ba42f5f44f9e1fc453ce49c4ab79d0e1d5c42d3b30b1e098f3ab3f414c4c262fa12fb2be249f52d4aaf3c5224beb9 +af47467eb152e59870e21f0d4da2f43e093daf40180ab01438030684b114d025326928eaab12c41b81a066d94fce8436 +98d1b58ba22e7289b1c45c79a24624f19b1d89e00f778eef327ec4856a9a897278e6f1a9a7e673844b31dde949153000 +97ccb15dfadc7c59dca08cfe0d22df2e52c684cf97de1d94bc00d7ba24e020025130b0a39c0f4d46e4fc872771ee7875 +b699e4ed9a000ff96ca296b2f09dce278832bc8ac96851ff3cff99ed3f6f752cfc0fea8571be28cd9b5a7ec36f1a08ee +b9f49f0edb7941cc296435ff0a912e3ad16848ee8765ab5f60a050b280d6ea585e5b34051b15f6b8934ef01ceb85f648 +ac3893df7b4ceab23c6b9054e48e8ba40d6e5beda8fbe90b814f992f52494186969b35d8c4cdc3c99890a222c9c09008 +a41293ad22fae81dea94467bc1488c3707f3d4765059173980be93995fa4fcc3c9340796e3eed0beeb0ba0d9bb4fa3aa +a0543e77acd2aeecde13d18d258aeb2c7397b77f17c35a1992e8666ea7abcd8a38ec6c2741bd929abba2f766138618cc +92e79b22bc40e69f6527c969500ca543899105837b6b1075fa1796755c723462059b3d1b028e0b3df2559fa440e09175 +a1fa1eac8f41a5197a6fb4aa1eae1a031c89f9c13ff9448338b222780cf9022e0b0925d930c37501a0ef7b2b00fdaf83 +b3cb29ff73229f0637335f28a08ad8c5f166066f27c6c175164d0f26766a927f843b987ee9b309ed71cbf0a65d483831 +84d4ab787f0ac00f104f4a734dc693d62d48c2aeb03913153da62c2ae2c27d11b1110dcef8980368dd84682ea2c1a308 +ab6a8e4bbc78d4a7b291ad3e9a8fe2d65f640524ba3181123b09d2d18a9e300e2509ccf7000fe47e75b65f3e992a2e7e +b7805ebe4f1a4df414003dc10bca805f2ab86ca75820012653e8f9b79c405196b0e2cab099f2ab953d67f0d60d31a0f9 +b12c582454148338ea605d22bd00a754109063e22617f1f8ac8ddf5502c22a181c50c216c3617b9852aa5f26af56b323 +86333ad9f898947e31ce747728dc8c887479e18d36ff3013f69ebef807d82c6981543b5c3788af93c4d912ba084d3cba +b514efa310dc4ad1258add138891e540d8c87142a881b5f46563cc58ecd1488e6d3a2fca54c0b72a929f3364ca8c333e +aa0a30f92843cf2f484066a783a1d75a7aa6f41f00b421d4baf20a6ac7886c468d0eea7ca8b17dd22f4f74631b62b640 +b3b7dc63baec9a752e8433c0cdee4d0f9bc41f66f2b8d132faf925eef9cf89aae756fc132c45910f057122462605dc10 +b9b8190dac5bfdeb59fd44f4da41a57e7f1e7d2c21faba9da91fa45cbeca06dcf299c9ae22f0c89ece11ac46352d619f +89f8cf36501ad8bdfeab863752a9090e3bfda57cf8fdeca2944864dc05925f501e252c048221bcc57136ab09a64b64b2 +b0cbfaf317f05f97be47fc9d69eda2dd82500e00d42612f271a1fe24626408c28881f171e855bd5bd67409f9847502b4 +a7c21a8fcede581bfd9847b6835eda62ba250bea81f1bb17372c800a19c732abe03064e64a2f865d974fb636cab4b859 +95f9df524ba7a4667351696c4176b505d8ea3659f5ff2701173064acc624af69a0fad4970963736383b979830cb32260 +856a74fe8b37a2e3afeac858c8632200485d438422a16ae3b29f359e470e8244995c63ad79c7e007ed063f178d0306fd +b37faa4d78fdc0bb9d403674dbea0176c2014a171c7be8527b54f7d1a32a76883d3422a3e7a5f5fcc5e9b31b57822eeb +8d37234d8594ec3fe75670b5c9cc1ec3537564d4739b2682a75b18b08401869a4264c0f264354219d8d896cded715db4 +b5289ee5737f0e0bde485d32096d23387d68dab8f01f47821ab4f06cc79a967afe7355e72dc0c751d96b2747b26f6255 +9085e1fdf9f813e9c3b8232d3c8863cd84ab30d45e8e0d3d6a0abd9ebc6fd70cdf749ff4d04390000e14c7d8c6655fc7 +93a388c83630331eca4da37ea4a97b3b453238af474817cc0a0727fd3138dcb4a22de38c04783ec829c22cb459cb4e8e +a5377116027c5d061dbe24c240b891c08cdd8cd3f0899e848d682c873aff5b8132c1e7cfe76d2e5ed97ee0eb1d42cb68 +a274c84b04338ed28d74683e2a7519c2591a3ce37c294d6f6e678f7d628be2db8eff253ede21823e2df7183e6552f622 +8bc201147a842453a50bec3ac97671397bc086d6dfc9377fa38c2124cdc286abda69b7324f47d64da094ae011d98d9d9 +9842d0c066c524592b76fbec5132bc628e5e1d21c424bec4555efca8619cc1fd8ea3161febcb8b9e8ab54702f4e815e2 +a19191b713a07efe85c266f839d14e25660ee74452e6c691cd9997d85ae4f732052d802d3deb018bdd847caa298a894b +a24f71fc0db504da4e287dd118a4a74301cbcd16033937ba2abc8417956fcb4ae19b8e63b931795544a978137eff51cb +a90eec4a6a3a4b8f9a5b93d978b5026fcf812fe65585b008d7e08c4aaf21195a1d0699f12fc16f79b6a18a369af45771 +8b551cf89737d7d06d9b3b9c4c1c73b41f2ea0af4540999c70b82dabff8580797cf0a3caf34c86c59a7069eb2e38f087 +b8d312e6c635e7a216a1cda075ae77ba3e1d2fd501dc31e83496e6e81ed5d9c7799f8e578869c2e0e256fb29f5de10a7 +8d144bdb8cae0b2cdb5b33d44bbc96984a5925202506a8cc65eb67ac904b466f5a7fe3e1cbf04aa785bbb7348c4bb73c +a101b3d58b7a98659244b88de0b478b3fb87dc5fc6031f6e689b99edf498abd43e151fd32bd4bbd240e0b3e59c440359 +907453abca7d8e7151a05cc3d506c988007692fe7401395dc93177d0d07d114ab6cca0cc658eb94c0223fe8658295cad +825329ffbe2147ddb68f63a0a67f32d7f309657b8e5d9ab5bb34b3730bfa2c77a23eaaadb05def7d9f94a9e08fdc1e96 +88ee923c95c1dac99ae7ed6067906d734d793c5dc5d26339c1bb3314abe201c5dccb33b9007351885eb2754e9a8ea06c +98bc9798543f5f1adc9f2cfcfa72331989420e9c3f6598c45269f0dc9b7c8607bbeaf03faa0aea2ddde2b8f17fdceff5 +8ee87877702a79aef923ab970db6fa81561b3c07d5bf1a072af0a7bad765b4cbaec910afe1a91703feacc7822fa38a94 +8060b9584aa294fe8adc2b22f67e988bc6da768eae91e429dcc43ddc53cfcc5d6753fdc1b420b268c7eb2fb50736a970 +b344a5524d80a2f051870c7001f74fcf348a70fcf78dbd20c6ff9ca85d81567d2318c8b8089f2c4f195d6aec9fc15fa6 +8f5a5d893e1936ed062149d20eb73d98b62b7f50ab5d93a6429c03656b36688d1c80cb5010e4977491e51fa0d7dd35d5 +86fa32ebbf97328c5f5f15564e1238297e289ec3219b9a741724e9f3ae8d5c15277008f555863a478b247ba5dc601d44 +9557e55377e279f4b6b5e0ffe01eca037cc13aac242d67dfcd0374a1e775c5ed5cb30c25fe21143fee54e3302d34a3ea +8cb6bcbc39372d23464a416ea7039f57ba8413cf3f00d9a7a5b356ab20dcb8ed11b3561f7bce372b8534d2870c7ee270 +b5d59075cb5abde5391f64b6c3b8b50adc6e1f654e2a580b6d6d6eff3f4fbdd8fffc92e06809c393f5c8eab37f774c4b +afcfb6903ef13e493a1f7308675582f15af0403b6553e8c37afb8b2808ad21b88b347dc139464367dc260df075fea1ad +810fbbe808375735dd22d5bc7fc3828dc49fdd22cc2d7661604e7ac9c4535c1df578780affb3b895a0831640a945bcad +8056b0c678803b416f924e09a6299a33cf9ad7da6fe1ad7accefe95c179e0077da36815fde3716711c394e2c5ea7127f +8b67403702d06979be19f1d6dc3ec73cc2e81254d6b7d0cc49cd4fdda8cd51ab0835c1d2d26fc0ecab5df90585c2f351 +87f97f9e6d4be07e8db250e5dd2bffdf1390665bc5709f2b631a6fa69a7fca958f19bd7cc617183da1f50ee63e9352b5 +ae151310985940471e6803fcf37600d7fa98830613e381e00dab943aec32c14162d51c4598e8847148148000d6e5af5c +81eb537b35b7602c45441cfc61b27fa9a30d3998fad35a064e05bc9479e9f10b62eba2b234b348219eea3cadcaac64bb +8a441434934180ab6f5bc541f86ebd06eadbee01f438836d797e930fa803a51510e005c9248cecc231a775b74d12b5e9 +81f3c250a27ba14d8496a5092b145629eb2c2e6a5298438670375363f57e2798207832c8027c3e9238ad94ecdadfc4df +a6217c311f2f3db02ceaa5b6096849fe92b6f4b6f1491535ef8525f6ccee6130bed2809e625073ecbaddd4a3eb3df186 +82d1c396f0388b942cf22b119d7ef1ad03d3dad49a74d9d01649ee284f377c8daddd095d596871669e16160299a210db +a40ddf7043c5d72a7246bd727b07f7fff1549f0e443d611de6f9976c37448b21664c5089c57f20105102d935ab82f27b +b6c03c1c97adf0c4bf4447ec71366c6c1bff401ba46236cd4a33d39291e7a1f0bb34bd078ba3a18d15c98993b153a279 +8a94f5f632068399c359c4b3a3653cb6df2b207379b3d0cdace51afdf70d6d5cce6b89a2b0fee66744eba86c98fb21c2 +b2f19e78ee85073f680c3bba1f07fd31b057c00b97040357d97855b54a0b5accb0d3b05b2a294568fcd6a4be6f266950 +a74632d13bbe2d64b51d7a9c3ae0a5a971c19f51cf7596a807cea053e6a0f3719700976d4e394b356c0329a2dced9aa2 +afef616d341a9bc94393b8dfba68ff0581436aa3a3adb7c26a1bbf2cf19fa877066191681f71f17f3cd6f9cf6bf70b5a +8ce96d93ae217408acf7eb0f9cbb9563363e5c7002e19bbe1e80760bc9d449daee2118f3878b955163ed664516b97294 +8414f79b496176bc8b8e25f8e4cfee28f4f1c2ddab099d63d2aca1b6403d26a571152fc3edb97794767a7c4686ad557c +b6c61d01fd8ce087ef9f079bf25bf10090db483dd4f88c4a786d31c1bdf52065651c1f5523f20c21e75cea17df69ab73 +a5790fd629be70545093631efadddc136661f63b65ec682609c38ef7d3d7fa4e56bdf94f06e263bc055b90cb1c6bcefe +b515a767e95704fb7597bca9e46f1753abacdc0e56e867ee3c6f4cd382643c2a28e65312c05ad040eaa3a8cbe7217a65 +8135806a02ead6aa92e9adb6fefb91349837ab73105aaa7be488ef966aa8dfaafdfa64bbae30fcbfa55dd135a036a863 +8f22435702716d76b1369750694540742d909d5e72b54d0878245fab7c269953b1c6f2b29c66f08d5e0263ca3a731771 +8e0f8a8e8753e077dac95848212aeffd51c23d9b6d611df8b102f654089401954413ecbedc6367561ca599512ae5dda7 +815a9084e3e2345f24c5fa559deec21ee1352fb60f4025c0779be65057f2d528a3d91593bd30d3a185f5ec53a9950676 +967e6555ccba395b2cc1605f8484c5112c7b263f41ce8439a99fd1c71c5ed14ad02684d6f636364199ca48afbbde13be +8cd0ccf17682950b34c796a41e2ea7dd5367aba5e80a907e01f4cdc611e4a411918215e5aebf4292f8b24765d73314a6 +a58bf1bbb377e4b3915df6f058a0f53b8fb8130fdec8c391f6bc82065694d0be59bb67ffb540e6c42cc8b380c6e36359 +92af3151d9e6bfb3383d85433e953c0160859f759b0988431ec5893542ba40288f65db43c78a904325ef8d324988f09d +8011bbb05705167afb47d4425065630f54cb86cd462095e83b81dfebf348f846e4d8fbcf1c13208f5de1931f81da40b9 +81c743c104fc3cb047885c9fa0fb9705c3a83ee24f690f539f4985509c3dafd507af3f6a2128276f45d5939ef70c167f +a2c9679b151c041aaf5efeac5a737a8f70d1631d931609fca16be1905682f35e291292874cb3b03f14994f98573c6f44 +a4949b86c4e5b1d5c82a337e5ce6b2718b1f7c215148c8bfb7e7c44ec86c5c9476048fc5c01f57cb0920876478c41ad6 +86c2495088bd1772152e527a1da0ef473f924ea9ab0e5b8077df859c28078f73c4e22e3a906b507fdf217c3c80808b5c +892e0a910dcf162bcea379763c3e2349349e4cda9402949255ac4a78dd5a47e0bf42f5bd0913951576b1d206dc1e536a +a7009b2c6b396138afe4754b7cc10dee557c51c7f1a357a11486b3253818531f781ea8107360c8d4c3b1cd96282353c0 +911763ef439c086065cc7b4e57484ed6d693ea44acee4b18c9fd998116da55fbe7dcb8d2a0f0f9b32132fca82d73dff6 +a722000b95a4a2d40bed81870793f15ba2af633f9892df507f2842e52452e02b5ea8dea6a043c2b2611d82376e33742a +9387ac49477bd719c2f92240d0bdfcf9767aad247ca93dc51e56106463206bc343a8ec855eb803471629a66fffb565d6 +92819a1fa48ab4902939bb72a0a4e6143c058ea42b42f9bc6cea5df45f49724e2530daf3fc4f097cceefa2a8b9db0076 +98eac7b04537653bc0f4941aae732e4b1f84bd276c992c64a219b8715eb1fb829b5cbd997d57feb15c7694c468f95f70 +b275e7ba848ce21bf7996e12dbeb8dadb5d0e4f1cb5a0248a4f8f9c9fe6c74e3c93f4b61edbcb0a51af5a141e1c14bc7 +97243189285aba4d49c53770c242f2faf5fd3914451da4931472e3290164f7663c726cf86020f8f181e568c72fd172d1 +839b0b3c25dd412bee3dc24653b873cc65454f8f16186bb707bcd58259c0b6765fa4c195403209179192a4455c95f3b8 +8689d1a870514568a074a38232e2ceb4d7df30fabeb76cff0aed5b42bf7f02baea12c5fadf69f4713464dbd52aafa55f +8958ae7b290f0b00d17c3e9fdb4dbf168432b457c7676829299dd428984aba892de1966fc106cfc58a772862ecce3976 +a422bc6bd68b8870cfa5bc4ce71781fd7f4368b564d7f1e0917f6013c8bbb5b240a257f89ecfdbecb40fe0f3aa31d310 +aa61f78130cebe09bc9a2c0a37f0dd57ed2d702962e37d38b1df7f17dc554b1d4b7a39a44182a452ce4c5eb31fa4cfcc +b7918bd114f37869bf1a459023386825821bfadce545201929d13ac3256d92a431e34f690a55d944f77d0b652cefeffc +819bba35fb6ace1510920d4dcff30aa682a3c9af9022e287751a6a6649b00c5402f14b6309f0aeef8fce312a0402915e +8b7c9ad446c6f63c11e1c24e24014bd570862b65d53684e107ba9ad381e81a2eaa96731b4b33536efd55e0f055071274 +8fe79b53f06d33386c0ec7d6d521183c13199498594a46d44a8a716932c3ec480c60be398650bbfa044fa791c4e99b65 +9558e10fb81250b9844c99648cf38fa05ec1e65d0ccbb18aa17f2d1f503144baf59d802c25be8cc0879fff82ed5034ad +b538a7b97fbd702ba84645ca0a63725be1e2891c784b1d599e54e3480e4670d0025526674ef5cf2f87dddf2290ba09f0 +92eafe2e869a3dd8519bbbceb630585c6eb21712b2f31e1b63067c0acb5f9bdbbcbdb612db4ea7f9cc4e7be83d31973f +b40d21390bb813ab7b70a010dff64c57178418c62685761784e37d327ba3cb9ef62df87ecb84277c325a637fe3709732 +b349e6fbf778c4af35fbed33130bd8a7216ed3ba0a79163ebb556e8eb8e1a7dad3456ddd700dad9d08d202491c51b939 +a8fdaedecb251f892b66c669e34137f2650509ade5d38fbe8a05d9b9184bb3b2d416186a3640429bd1f3e4b903c159dd +ac6167ebfee1dbab338eff7642f5e785fc21ef0b4ddd6660333fe398068cbd6c42585f62e81e4edbb72161ce852a1a4f +874b1fbf2ebe140c683bd7e4e0ab017afa5d4ad38055aaa83ee6bbef77dbc88a6ce8eb0dcc48f0155244af6f86f34c2d +903c58e57ddd9c446afab8256a6bb6c911121e6ccfb4f9b4ed3e2ed922a0e500a5cb7fa379d5285bc16e11dac90d1fda +8dae7a0cffa2fd166859cd1bf10ff82dd1932e488af377366b7efc0d5dec85f85fe5e8150ff86a79a39cefc29631733a +aa047857a47cc4dfc08585f28640420fcf105b881fd59a6cf7890a36516af0644d143b73f3515ab48faaa621168f8c31 +864508f7077c266cc0cb3f7f001cb6e27125ebfe79ab57a123a8195f2e27d3799ff98413e8483c533b46a816a3557f1f +8bcd45ab1f9cbab36937a27e724af819838f66dfeb15923f8113654ff877bd8667c54f6307aaf0c35027ca11b6229bfd +b21aa34da9ab0a48fcfdd291df224697ce0c1ebc0e9b022fdee8750a1a4b5ba421c419541ed5c98b461eecf363047471 +a9a18a2ab2fae14542dc336269fe612e9c1af6cf0c9ac933679a2f2cb77d3c304114f4d219ca66fe288adde30716775b +b5205989b92c58bdda71817f9a897e84100b5c4e708de1fced5c286f7a6f01ae96b1c8d845f3a320d77c8e2703c0e8b1 +a364059412bbcc17b8907d43ac8e5df90bc87fd1724b5f99832d0d24559fae6fa76a74cff1d1eac8cbac6ec80b44af20 +ae709f2c339886b31450834cf29a38b26eb3b0779bd77c9ac269a8a925d1d78ea3837876c654b61a8fe834b3b6940808 +8802581bba66e1952ac4dab36af371f66778958f4612901d95e5cac17f59165e6064371d02de8fb6fccf89c6dc8bd118 +a313252df653e29c672cbcfd2d4f775089cb77be1077381cf4dc9533790e88af6cedc8a119158e7da5bf6806ad9b91a1 +992a065b4152c7ef11515cd54ba9d191fda44032a01aed954acff3443377ee16680c7248d530b746b8c6dee2d634e68c +b627b683ee2b32c1ab4ccd27b9f6cce2fe097d96386fa0e5c182ad997c4c422ab8dfc03870cd830b8c774feb66537282 +b823cf8a9aee03dadd013eb9efe40a201b4b57ef67efaae9f99683005f5d1bf55e950bf4af0774f50859d743642d3fea +b8a7449ffac0a3f206677097baf7ce00ca07a4d2bd9b5356fbcb83f3649b0fda07cfebad220c1066afba89e5a52abf4b +b2dd1a2f986395bb4e3e960fbbe823dbb154f823284ebc9068502c19a7609790ec0073d08bfa63f71e30c7161b6ef966 +98e5236de4281245234f5d40a25b503505af140b503a035fc25a26159a9074ec81512b28f324c56ea2c9a5aa7ce90805 +89070847dc8bbf5bc4ed073aa2e2a1f699cf0c2ca226f185a0671cecc54e7d3e14cd475c7752314a7a8e7476829da4bc +a9402dc9117fdb39c4734c0688254f23aed3dce94f5f53f5b7ef2b4bf1b71a67f85ab1a38ec224a59691f3bee050aeb3 +957288f9866a4bf56a4204218ccc583f717d7ce45c01ea27142a7e245ad04a07f289cc044f8cf1f21d35e67e39299e9c +b2fb31ccb4e69113763d7247d0fc8edaae69b550c5c56aecacfd780c7217dc672f9fb7496edf4aba65dacf3361268e5b +b44a4526b2f1d6eb2aa8dba23bfa385ff7634572ab2afddd0546c3beb630fbfe85a32f42dd287a7fec069041411537f7 +8db5a6660c3ac7fd7a093573940f068ee79a82bc17312af900b51c8c439336bc86ca646c6b7ab13aaaa008a24ca508ab +8f9899a6d7e8eb4367beb5c060a1f8e94d8a21099033ae582118477265155ba9e72176a67f7f25d7bad75a152b56e21a +a67de0e91ade8d69a0e00c9ff33ee2909b8a609357095fa12319e6158570c232e5b6f4647522efb7345ce0052aa9d489 +82eb2414898e9c3023d57907a2b17de8e7eea5269029d05a94bfd7bf5685ac4a799110fbb375eb5e0e2bd16acf6458ae +94451fc7fea3c5a89ba701004a9693bab555cb622caf0896b678faba040409fdfd14a978979038b2a81e8f0abc4994d2 +ac879a5bb433998e289809a4a966bd02b4bf6a9c1cc276454e39c886efcf4fc68baebed575826bde577ab5aa71d735a9 +880c0f8f49c875dfd62b4ddedde0f5c8b19f5687e693717f7e5c031bc580e58e13ab497d48b4874130a18743c59fdce3 +b582af8d8ff0bf76f0a3934775e0b54c0e8fed893245d7d89cae65b03c8125b7237edc29dc45b4fe1a3fe6db45d280ee +89f337882ed3ae060aaee98efa20d79b6822bde9708c1c5fcee365d0ec9297f694cae37d38fd8e3d49717c1e86f078e7 +826d2c1faea54061848b484e288a5f4de0d221258178cf87f72e14baaa4acc21322f8c9eab5dde612ef497f2d2e1d60b +a5333d4f227543e9cd741ccf3b81db79f2f03ca9e649e40d6a6e8ff9073e06da83683566d3b3c8d7b258c62970fb24d1 +a28f08c473db06aaf4c043a2fae82b3c8cfaa160bce793a4c208e4e168fb1c65115ff8139dea06453c5963d95e922b94 +8162546135cc5e124e9683bdfaa45833c18553ff06a0861c887dc84a5b12ae8cd4697f6794c7ef6230492c32faba7014 +b23f0d05b74c08d6a7df1760792be83a761b36e3f8ae360f3c363fb196e2a9dd2de2e492e49d36561366e14daa77155c +b6f70d6c546722d3907c708d630dbe289771d2c8bf059c2e32b77f224696d750b4dda9b3a014debda38e7d02c9a77585 +83bf4c4a9f3ca022c631017e7a30ea205ba97f7f5927cba8fc8489a4646eac6712cb821c5668c9ffe94d69d524374a27 +b0371475425a8076d0dd5f733f55aabbe42d20a7c8ea7da352e736d4d35a327b2beb370dfcb05284e22cfd69c5f6c4cc +a0031ba7522c79211416c2cca3aa5450f96f8fee711552a30889910970ba13608646538781a2c08b834b140aadd7166f +99d273c80c7f2dc6045d4ed355d9fc6f74e93549d961f4a3b73cd38683f905934d359058cd1fc4da8083c7d75070487f +b0e4b0efa3237793e9dcce86d75aafe9879c5fa23f0d628649aef2130454dcf72578f9bf227b9d2b9e05617468e82588 +a5ab076fa2e1c5c51f3ae101afdd596ad9d106bba7882b359c43d8548b64f528af19afa76cd6f40da1e6c5fca4def3fa +8ce2299e570331d60f6a6eff1b271097cd5f1c0e1113fc69b89c6a0f685dabea3e5bc2ac6bd789aa492ab189f89be494 +91b829068874d911a310a5f9dee001021f97471307b5a3de9ec336870ec597413e1d92010ce320b619f38bed7c4f7910 +b14fe91f4b07bf33b046e9285b66cb07927f3a8da0af548ac2569b4c4fb1309d3ced76d733051a20814e90dd5b75ffd1 +abaab92ea6152d40f82940277c725aa768a631ee0b37f5961667f82fb990fc11e6d3a6a2752b0c6f94563ed9bb28265c +b7fe28543eca2a716859a76ab9092f135337e28109544f6bd2727728d0a7650428af5713171ea60bfc273d1c821d992c +8a4917b2ab749fc7343fc64bdf51b6c0698ff15d740cc7baf248c030475c097097d5a473bcc00d8c25817563fe0447b4 +aa96156d1379553256350a0a3250166add75948fb9cde62aa555a0a9dc0a9cb7f2f7b8428aff66097bf6bfedaf14bbe2 +ae4ffeb9bdc76830d3eca2b705f30c1bdede6412fa064260a21562c8850c7fb611ec62bc68479fe48f692833e6f66d8d +b96543caaba9d051600a14997765d49e4ab10b07c7a92cccf0c90b309e6da334fdd6d18c96806cbb67a7801024fbd3c7 +97b2b9ad76f19f500fcc94ca8e434176249f542ac66e5881a3dccd07354bdab6a2157018b19f8459437a68d8b86ba8e0 +a8d206f6c5a14c80005849474fde44b1e7bcf0b2d52068f5f97504c3c035b09e65e56d1cf4b5322791ae2c2fdbd61859 +936bad397ad577a70cf99bf9056584a61bd7f02d2d5a6cf219c05d770ae30a5cd902ba38366ce636067fc1dd10108d31 +a77e30195ee402b84f3882e2286bf5380c0ed374a112dbd11e16cef6b6b61ab209d4635e6f35cdaaa72c1a1981d5dabe +a46ba4d3947188590a43c180757886a453a0503f79cc435322d92490446f37419c7b999fdf868a023601078070e03346 +80d8d4c5542f223d48240b445d4d8cf6a75d120b060bc08c45e99a13028b809d910b534d2ac47fb7068930c54efd8da9 +803be9c68c91b42b68e1f55e58917a477a9a6265e679ca44ee30d3eb92453f8c89c64eafc04c970d6831edd33d066902 +b14b2b3d0dfe2bb57cee4cd72765b60ac33c1056580950be005790176543826c1d4fbd737f6cfeada6c735543244ab57 +a9e480188bba1b8fb7105ff12215706665fd35bf1117bacfb6ab6985f4dbc181229873b82e5e18323c2b8f5de03258e0 +a66a0f0779436a9a3999996d1e6d3000f22c2cac8e0b29cddef9636393c7f1457fb188a293b6c875b05d68d138a7cc4a +848397366300ab40c52d0dbbdafbafef6cd3dadf1503bb14b430f52bb9724188928ac26f6292a2412bc7d7aa620763c8 +95466cc1a78c9f33a9aaa3829a4c8a690af074916b56f43ae46a67a12bb537a5ac6dbe61590344a25b44e8512355a4a7 +8b5f7a959f818e3baf0887f140f4575cac093d0aece27e23b823cf421f34d6e4ff4bb8384426e33e8ec7b5eed51f6b5c +8d5e1368ec7e3c65640d216bcc5d076f3d9845924c734a34f3558ac0f16e40597c1a775a25bf38b187213fbdba17c93b +b4647c1b823516880f60d20c5cc38c7f80b363c19d191e8992226799718ee26b522a12ecb66556ed3d483aa4824f3326 +ac3abaea9cd283eb347efda4ed9086ea3acf495043e08d0d19945876329e8675224b685612a6badf8fd72fb6274902b1 +8eae1ce292d317aaa71bcf6e77e654914edd5090e2e1ebab78b18bb41b9b1bc2e697439f54a44c0c8aa0d436ebe6e1a9 +94dc7d1aec2c28eb43d93b111fa59aaa0d77d5a09501220bd411768c3e52208806abf973c6a452fd8292ff6490e0c9e2 +8fd8967f8e506fef27d17b435d6b86b232ec71c1036351f12e6fb8a2e12daf01d0ee04451fb944d0f1bf7fd20e714d02 +824e6865be55d43032f0fec65b3480ea89b0a2bf860872237a19a54bc186a85d2f8f9989cc837fbb325b7c72d9babe2c +8bd361f5adb27fd6f4e3f5de866e2befda6a8454efeb704aacc606f528c03f0faae888f60310e49440496abd84083ce2 +b098a3c49f2aaa28b6b3e85bc40ce6a9cdd02134ee522ae73771e667ad7629c8d82c393fba9f27f5416986af4c261438 +b385f5ca285ff2cfe64dcaa32dcde869c28996ed091542600a0b46f65f3f5a38428cca46029ede72b6cf43e12279e3d3 +8196b03d011e5be5288196ef7d47137d6f9237a635ab913acdf9c595fa521d9e2df722090ec7eb0203544ee88178fc5f +8ed1270211ef928db18e502271b7edf24d0bbd11d97f2786aee772d70c2029e28095cf8f650b0328cc8a4c38d045316d +a52ab60e28d69b333d597a445884d44fd2a7e1923dd60f763951e1e45f83e27a4dac745f3b9eff75977b3280e132c15d +91e9fe78cdac578f4a4687f71b800b35da54b824b1886dafec073a3c977ce7a25038a2f3a5b1e35c2c8c9d1a7312417c +a42832173f9d9491c7bd93b21497fbfa4121687cd4d2ab572e80753d7edcbb42cfa49f460026fbde52f420786751a138 +97b947126d84dcc70c97be3c04b3de3f239b1c4914342fa643b1a4bb8c4fe45c0fcb585700d13a7ed50784790c54bef9 +860e407d353eac070e2418ef6cb80b96fc5f6661d6333e634f6f306779651588037be4c2419562c89c61f9aa2c4947f5 +b2c9d93c3ba4e511b0560b55d3501bf28a510745fd666b3cb532db051e6a8617841ea2f071dda6c9f15619c7bfd2737f +8596f4d239aeeac78311207904d1bd863ef68e769629cc379db60e019aaf05a9d5cd31dc8e630b31e106a3a93e47cbc5 +8b26e14e2e136b65c5e9e5c2022cee8c255834ea427552f780a6ca130a6446102f2a6f334c3f9a0308c53df09e3dba7e +b54724354eb515a3c8bed0d0677ff1db94ac0a07043459b4358cb90e3e1aa38ac23f2caa3072cf9647275d7cd61d0e80 +b7ce9fe0e515e7a6b2d7ddcb92bc0196416ff04199326aea57996eef8c5b1548bd8569012210da317f7c0074691d01b7 +a1a13549c82c877253ddefa36a29ea6a23695ee401fdd48e65f6f61e5ebd956d5e0edeff99484e9075cb35071fec41e2 +838ba0c1e5bd1a6da05611ff1822b8622457ebd019cb065ece36a2d176bd2d889511328120b8a357e44569e7f640c1e6 +b916eccff2a95519400bbf76b5f576cbe53cf200410370a19d77734dc04c05b585cfe382e8864e67142d548cd3c4c2f4 +a610447cb7ca6eea53a6ff1f5fe562377dcb7f4aaa7300f755a4f5e8eba61e863c51dc2aa9a29b35525b550fbc32a0fe +9620e8f0f0ee9a4719aa9685eeb1049c5c77659ba6149ec4c158f999cfd09514794b23388879931fe26fea03fa471fd3 +a9dcf8b679e276583cf5b9360702a185470d09aea463dc474ee9c8aee91ef089dacb073e334e47fbc78ec5417c90465c +8c9adee8410bdd99e5b285744cee61e2593b6300ff31a8a83b0ec28da59475a5c6fb9346fe43aadea2e6c3dad2a8e30a +97d5afe9b3897d7b8bb628b7220cf02d8ee4e9d0b78f5000d500aaf4c1df9251aaaabfd1601626519f9d66f00a821d4e +8a382418157b601ce4c3501d3b8409ca98136a4ef6abcbf62885e16e215b76b035c94d149cc41ff92e42ccd7c43b9b3d +b64b8d11fb3b01abb2646ac99fdb9c02b804ce15d98f9fe0fbf1c9df8440c71417487feb6cdf51e3e81d37104b19e012 +849d7d044f9d8f0aab346a9374f0b3a5d14a9d1faa83dbacccbdc629ad1ef903a990940255564770537f8567521d17f0 +829dbb0c76b996c2a91b4cbbe93ba455ca0d5729755e5f0c92aaee37dff7f36fcdc06f33aca41f1b609c784127b67d88 +85a7c0069047b978422d264d831ab816435f63938015d2e977222b6b5746066c0071b7f89267027f8a975206ed25c1b0 +84b9fbc1cfb302df1acdcf3dc5d66fd1edfe7839f7a3b2fb3a0d5548656249dd556104d7c32b73967bccf0f5bdcf9e3b +972220ac5b807f53eac37dccfc2ad355d8b21ea6a9c9b011c09fe440ddcdf7513e0b43d7692c09ded80d7040e26aa28f +855885ed0b21350baeca890811f344c553cf9c21024649c722453138ba29193c6b02c4b4994cd414035486f923472e28 +841874783ae6d9d0e59daea03e96a01cbbe4ecaced91ae4f2c8386e0d87b3128e6d893c98d17c59e4de1098e1ad519dd +827e50fc9ce56f97a4c3f2f4cbaf0b22f1c3ce6f844ff0ef93a9c57a09b8bf91ebfbd2ba9c7f83c442920bffdaf288cc +a441f9136c7aa4c08d5b3534921b730e41ee91ab506313e1ba5f7c6f19fd2d2e1594e88c219834e92e6fb95356385aa7 +97d75b144471bf580099dd6842b823ec0e6c1fb86dd0da0db195e65524129ea8b6fd4a7a9bbf37146269e938a6956596 +a4b6fa87f09d5a29252efb2b3aaab6b3b6ea9fab343132a651630206254a25378e3e9d6c96c3d14c150d01817d375a8e +a31a671876d5d1e95fe2b8858dc69967231190880529d57d3cab7f9f4a2b9b458ac9ee5bdaa3289158141bf18f559efb +90bee6fff4338ba825974021b3b2a84e36d617e53857321f13d2b3d4a28954e6de3b3c0e629d61823d18a9763313b3bf +96b622a63153f393bb419bfcf88272ea8b3560dbd46b0aa07ada3a6223990d0abdd6c2adb356ef4be5641688c8d83941 +84c202adeaff9293698022bc0381adba2cd959f9a35a4e8472288fd68f96f6de8be9da314c526d88e291c96b1f3d6db9 +8ca01a143b8d13809e5a8024d03e6bc9492e22226073ef6e327edf1328ef4aff82d0bcccee92cb8e212831fa35fe1204 +b2f970dbad15bfbefb38903c9bcc043d1367055c55dc1100a850f5eb816a4252c8c194b3132c929105511e14ea10a67d +a5e36556472a95ad57eb90c3b6623671b03eafd842238f01a081997ffc6e2401f76e781d049bb4aa94d899313577a9cf +8d1057071051772f7c8bedce53a862af6fd530dd56ae6321eaf2b9fc6a68beff5ed745e1c429ad09d5a118650bfd420a +8aadc4f70ace4fcb8d93a78610779748dcffc36182d45b932c226dc90e48238ea5daa91f137c65ed532352c4c4d57416 +a2ea05ae37e673b4343232ae685ee14e6b88b867aef6dfac35db3589cbcd76f99540fed5c2641d5bb5a4a9f808e9bf0d +947f1abad982d65648ae4978e094332b4ecb90f482c9be5741d5d1cf5a28acf4680f1977bf6e49dd2174c37f11e01296 +a27b144f1565e4047ba0e3f4840ef19b5095d1e281eaa463c5358f932114cbd018aa6dcf97546465cf2946d014d8e6d6 +8574e1fc3acade47cd4539df578ce9205e745e161b91e59e4d088711a7ab5aa3b410d517d7304b92109924d9e2af8895 +a48ee6b86b88015d6f0d282c1ae01d2a5b9e8c7aa3d0c18b35943dceb1af580d08a65f54dc6903cde82fd0d73ce94722 +8875650cec543a7bf02ea4f2848a61d167a66c91ffaefe31a9e38dc8511c6a25bde431007eefe27a62af3655aca208dc +999b0a6e040372e61937bf0d68374e230346b654b5a0f591a59d33a4f95bdb2f3581db7c7ccb420cd7699ed709c50713 +878c9e56c7100c5e47bbe77dc8da5c5fe706cec94d37fa729633bca63cace7c40102eee780fcdabb655f5fa47a99600e +865006fb5b475ada5e935f27b96f9425fc2d5449a3c106aa366e55ebed3b4ee42adc3c3f0ac19fd129b40bc7d6bc4f63 +b7a7da847f1202e7bc1672553e68904715e84fd897d529243e3ecda59faa4e17ba99c649a802d53f6b8dfdd51f01fb74 +8b2fb4432c05653303d8c8436473682933a5cb604da10c118ecfcd2c8a0e3132e125afef562bdbcc3df936164e5ce4f2 +808d95762d33ddfa5d0ee3d7d9f327de21a994d681a5f372e2e3632963ea974da7f1f9e5bac8ccce24293509d1f54d27 +932946532e3c397990a1df0e94c90e1e45133e347a39b6714c695be21aeb2d309504cb6b1dde7228ff6f6353f73e1ca2 +9705e7c93f0cdfaa3fa96821f830fe53402ad0806036cd1b48adc2f022d8e781c1fbdab60215ce85c653203d98426da3 +aa180819531c3ec1feb829d789cb2092964c069974ae4faad60e04a6afcce5c3a59aec9f11291e6d110a788d22532bc6 +88f755097f7e25cb7dd3c449520c89b83ae9e119778efabb54fbd5c5714b6f37c5f9e0346c58c6ab09c1aef2483f895d +99fc03ab7810e94104c494f7e40b900f475fde65bdec853e60807ffd3f531d74de43335c3b2646b5b8c26804a7448898 +af2dea9683086bed1a179110efb227c9c00e76cd00a2015b089ccbcee46d1134aa18bda5d6cab6f82ae4c5cd2461ac21 +a500f87ba9744787fdbb8e750702a3fd229de6b8817594348dec9a723b3c4240ddfa066262d002844b9e38240ce55658 +924d0e45c780f5bc1c1f35d15dfc3da28036bdb59e4c5440606750ecc991b85be18bc9a240b6c983bc5430baa4c68287 +865b11e0157b8bf4c5f336024b016a0162fc093069d44ac494723f56648bc4ded13dfb3896e924959ea11c96321afefc +93672d8607d4143a8f7894f1dcca83fb84906dc8d6dd7dd063bb0049cfc20c1efd933e06ca7bd03ea4cb5a5037990bfe +826891efbdff0360446825a61cd1fa04326dd90dae8c33dfb1ed97b045e165766dd070bd7105560994d0b2044bdea418 +93c4a4a8bcbc8b190485cc3bc04175b7c0ed002c28c98a540919effd6ed908e540e6594f6db95cd65823017258fb3b1c +aeb2a0af2d2239fda9aa6b8234b019708e8f792834ff0dd9c487fa09d29800ddceddd6d7929faa9a3edcb9e1b3aa0d6b +87f11de7236d387863ec660d2b04db9ac08143a9a2c4dfff87727c95b4b1477e3bc473a91e5797313c58754905079643 +80dc1db20067a844fe8baceca77f80db171a5ca967acb24e2d480eae9ceb91a3343c31ad1c95b721f390829084f0eae6 +9825c31f1c18da0de3fa84399c8b40f8002c3cae211fb6a0623c76b097b4d39f5c50058f57a16362f7a575909d0a44a2 +a99fc8de0c38dbf7b9e946de83943a6b46a762167bafe2a603fb9b86f094da30d6de7ed55d639aafc91936923ee414b3 +ad594678b407db5d6ea2e90528121f84f2b96a4113a252a30d359a721429857c204c1c1c4ff71d8bb5768c833f82e80e +b33d985e847b54510b9b007e31053732c8a495e43be158bd2ffcea25c6765bcbc7ca815f7c60b36ad088b955dd6e9350 +815f8dfc6f90b3342ca3fbd968c67f324dae8f74245cbf8bc3bef10e9440c65d3a2151f951e8d18959ba01c1b50b0ec1 +94c608a362dd732a1abc56e338637c900d59013db8668e49398b3c7a0cae3f7e2f1d1bf94c0299eeafe6af7f76c88618 +8ebd8446b23e5adfcc393adc5c52fe172f030a73e63cd2d515245ca0dd02782ceed5bcdd9ccd9c1b4c5953dfac9c340c +820437f3f6f9ad0f5d7502815b221b83755eb8dc56cd92c29e9535eb0b48fb8d08c9e4fcc26945f9c8cca60d89c44710 +8910e4e8a56bf4be9cc3bbf0bf6b1182a2f48837a2ed3c2aaec7099bfd7f0c83e14e608876b17893a98021ff4ab2f20d +9633918fde348573eec15ce0ad53ac7e1823aac86429710a376ad661002ae6d049ded879383faaa139435122f64047c6 +a1f5e3fa558a9e89318ca87978492f0fb4f6e54a9735c1b8d2ecfb1d1c57194ded6e0dd82d077b2d54251f3bee1279e1 +b208e22d04896abfd515a95c429ff318e87ff81a5d534c8ac2c33c052d6ffb73ef1dccd39c0bbe0734b596c384014766 +986d5d7d2b5bde6d16336f378bd13d0e671ad23a8ec8a10b3fc09036faeeb069f60662138d7a6df3dfb8e0d36180f770 +a2d4e6c5f5569e9cef1cddb569515d4b6ace38c8aed594f06da7434ba6b24477392cc67ba867c2b079545ca0c625c457 +b5ac32b1d231957d91c8b7fc43115ce3c5c0d8c13ca633374402fa8000b6d9fb19499f9181844f0c10b47357f3f757ce +96b8bf2504b4d28fa34a4ec378e0e0b684890c5f44b7a6bb6e19d7b3db2ab27b1e2686389d1de9fbd981962833a313ea +953bfd7f6c3a0469ad432072b9679a25486f5f4828092401eff494cfb46656c958641a4e6d0d97d400bc59d92dba0030 +876ab3cea7484bbfd0db621ec085b9ac885d94ab55c4bb671168d82b92e609754b86aaf472c55df3d81421d768fd108a +885ff4e67d9ece646d02dd425aa5a087e485c3f280c3471b77532b0db6145b69b0fbefb18aa2e3fa5b64928b43a94e57 +b91931d93f806d0b0e6cc62a53c718c099526140f50f45d94b8bbb57d71e78647e06ee7b42aa5714aed9a5c05ac8533f +a0313eeadd39c720c9c27b3d671215331ab8d0a794e71e7e690f06bcd87722b531d6525060c358f35f5705dbb7109ccb +874c0944b7fedc6701e53344100612ddcb495351e29305c00ec40a7276ea5455465ffb7bded898886c1853139dfb1fc7 +8dc31701a01ee8137059ca1874a015130d3024823c0576aa9243e6942ec99d377e7715ed1444cd9b750a64b85dcaa3e5 +836d2a757405e922ec9a2dfdcf489a58bd48b5f9683dd46bf6047688f778c8dee9bc456de806f70464df0b25f3f3d238 +b30b0a1e454a503ea3e2efdec7483eaf20b0a5c3cefc42069e891952b35d4b2c955cf615f3066285ed8fafd9fcfbb8f6 +8e6d4044b55ab747e83ec8762ea86845f1785cc7be0279c075dadf08aca3ccc5a096c015bb3c3f738f647a4eadea3ba5 +ad7735d16ab03cbe09c029610aa625133a6daecfc990b297205b6da98eda8c136a7c50db90f426d35069708510d5ae9c +8d62d858bbb59ec3c8cc9acda002e08addab4d3ad143b3812098f3d9087a1b4a1bb255dcb1635da2402487d8d0249161 +805beec33238b832e8530645a3254aeef957e8f7ea24bcfc1054f8b9c69421145ebb8f9d893237e8a001c857fedfc77e +b1005644be4b085e3f5775aa9bd3e09a283e87ddada3082c04e7a62d303dcef3b8cf8f92944c200c7ae6bb6bdf63f832 +b4ba0e0790dc29063e577474ffe3b61f5ea2508169f5adc1e394934ebb473e356239413a17962bc3e5d3762d72cce8c2 +a157ba9169c9e3e6748d9f1dd67fbe08b9114ade4c5d8fc475f87a764fb7e6f1d21f66d7905cd730f28a1c2d8378682a +913e52b5c93989b5d15e0d91aa0f19f78d592bc28bcfdfddc885a9980c732b1f4debb8166a7c4083c42aeda93a702898 +90fbfc1567e7cd4e096a38433704d3f96a2de2f6ed3371515ccc30bc4dd0721a704487d25a97f3c3d7e4344472702d8d +89646043028ffee4b69d346907586fd12c2c0730f024acb1481abea478e61031966e72072ff1d5e65cb8c64a69ad4eb1 +b125a45e86117ee11d2fb42f680ab4a7894edd67ff927ae2c808920c66c3e55f6a9d4588eee906f33a05d592e5ec3c04 +aad47f5b41eae9be55fb4f67674ff1e4ae2482897676f964a4d2dcb6982252ee4ff56aac49578b23f72d1fced707525e +b9ddff8986145e33851b4de54d3e81faa3352e8385895f357734085a1616ef61c692d925fe62a5ed3be8ca49f5d66306 +b3cb0963387ed28c0c0adf7fe645f02606e6e1780a24d6cecef5b7c642499109974c81a7c2a198b19862eedcea2c2d8c +ac9c53c885457aaf5cb36c717a6f4077af701e0098eebd7aa600f5e4b14e6c1067255b3a0bc40e4a552025231be7de60 +8e1a8d823c4603f6648ec21d064101094f2a762a4ed37dd2f0a2d9aa97b2d850ce1e76f4a4b8cae58819b058180f7031 +b268b73bf7a179b6d22bd37e5e8cb514e9f5f8968c78e14e4f6d5700ca0d0ca5081d0344bb73b028970eebde3cb4124e +a7f57d71940f0edbd29ed8473d0149cae71d921dd15d1ff589774003e816b54b24de2620871108cec1ab9fa956ad6ce6 +8053e6416c8b120e2b999cc2fc420a6a55094c61ac7f2a6c6f0a2c108a320890e389af96cbe378936132363c0d551277 +b3823f4511125e5aa0f4269e991b435a0d6ceb523ebd91c04d7add5534e3df5fc951c504b4fd412a309fd3726b7f940b +ae6eb04674d04e982ca9a6add30370ab90e303c71486f43ed3efbe431af1b0e43e9d06c11c3412651f304c473e7dbf39 +96ab55e641ed2e677591f7379a3cd126449614181fce403e93e89b1645d82c4af524381ff986cae7f9cebe676878646d +b52423b4a8c37d3c3e2eca8f0ddbf7abe0938855f33a0af50f117fab26415fb0a3da5405908ec5fdc22a2c1f2ca64892 +82a69ce1ee92a09cc709d0e3cd22116c9f69d28ea507fe5901f5676000b5179b9abe4c1875d052b0dd42d39925e186bb +a84c8cb84b9d5cfb69a5414f0a5283a5f2e90739e9362a1e8c784b96381b59ac6c18723a4aa45988ee8ef5c1f45cc97d +afd7efce6b36813082eb98257aae22a4c1ae97d51cac7ea9c852d4a66d05ef2732116137d8432e3f117119725a817d24 +a0f5fe25af3ce021b706fcff05f3d825384a272284d04735574ce5fb256bf27100fad0b1f1ba0e54ae9dcbb9570ecad3 +8751786cb80e2e1ff819fc7fa31c2833d25086534eb12b373d31f826382430acfd87023d2a688c65b5e983927e146336 +8cf5c4b17fa4f3d35c78ce41e1dc86988fd1135cd5e6b2bb0c108ee13538d0d09ae7102609c6070f39f937b439b31e33 +a9108967a2fedd7c322711eca8159c533dd561bedcb181b646de98bf5c3079449478eab579731bee8d215ae8852c7e21 +b54c5171704f42a6f0f4e70767cdb3d96ffc4888c842eece343a01557da405961d53ffdc34d2f902ea25d3e1ed867cad +ae8d4b764a7a25330ba205bf77e9f46182cd60f94a336bbd96773cf8064e3d39caf04c310680943dc89ed1fbad2c6e0d +aa5150e911a8e1346868e1b71c5a01e2a4bb8632c195861fb6c3038a0e9b85f0e09b3822e9283654a4d7bb17db2fc5f4 +9685d3756ce9069bf8bb716cf7d5063ebfafe37e15b137fc8c3159633c4e006ff4887ddd0ae90360767a25c3f90cba7f +82155fd70f107ab3c8e414eadf226c797e07b65911508c76c554445422325e71af8c9a8e77fd52d94412a6fc29417cd3 +abfae52f53a4b6e00760468d973a267f29321997c3dbb5aee36dc1f20619551229c0c45b9d9749f410e7f531b73378e8 +81a76d921f8ef88e774fd985e786a4a330d779b93fad7def718c014685ca0247379e2e2a007ad63ee7f729cd9ed6ce1b +81947c84bc5e28e26e2e533af5ae8fe10407a7b77436dbf8f1d5b0bbe86fc659eae10f974659dc7c826c6dabd03e3a4b +92b8c07050d635b8dd4fd09df9054efe4edae6b86a63c292e73cc819a12a21dd7d104ce51fa56af6539dedf6dbe6f7b6 +b44c579e3881f32b32d20c82c207307eca08e44995dd2aac3b2692d2c8eb2a325626c80ac81c26eeb38c4137ff95add5 +97efab8941c90c30860926dea69a841f2dcd02980bf5413b9fd78d85904588bf0c1021798dbc16c8bbb32cce66c82621 +913363012528b50698e904de0588bf55c8ec5cf6f0367cfd42095c4468fcc64954fbf784508073e542fee242d0743867 +8ed203cf215148296454012bd10fddaf119203db1919a7b3d2cdc9f80e66729464fdfae42f1f2fc5af1ed53a42b40024 +ab84312db7b87d711e9a60824f4fe50e7a6190bf92e1628688dfcb38930fe87b2d53f9e14dd4de509b2216856d8d9188 +880726def069c160278b12d2258eac8fa63f729cd351a710d28b7e601c6712903c3ac1e7bbd0d21e4a15f13ca49db5aa +980699cd51bac6283959765f5174e543ed1e5f5584b5127980cbc2ef18d984ecabba45042c6773b447b8e694db066028 +aeb019cb80dc4cb4207430d0f2cd24c9888998b6f21d9bf286cc638449668d2eec0018a4cf3fe6448673cd6729335e2b +b29852f6aa6c60effdffe96ae88590c88abae732561d35cc19e82d3a51e26cb35ea00986193e07f90060756240f5346e +a0fa855adc5ba469f35800c48414b8921455950a5c0a49945d1ef6e8f2a1881f2e2dfae47de6417270a6bf49deeb091d +b6c7332e3b14813641e7272d4f69ecc7e09081df0037d6dab97ce13a9e58510f5c930d300633f208181d9205c5534001 +85a6c050f42fce560b5a8d54a11c3bbb8407abbadd859647a7b0c21c4b579ec65671098b74f10a16245dc779dff7838e +8f3eb34bb68759d53c6677de4de78a6c24dd32c8962a7fb355ed362572ef8253733e6b52bc21c9f92ecd875020a9b8de +a17dd44181e5dab4dbc128e1af93ec22624b57a448ca65d2d9e246797e4af7d079e09c6e0dfb62db3a9957ce92f098d5 +a56a1b854c3183082543a8685bb34cae1289f86cfa8123a579049dbd059e77982886bfeb61bf6e05b4b1fe4e620932e7 +aedae3033cb2fb7628cb4803435bdd7757370a86f808ae4cecb9a268ad0e875f308c048c80cbcac523de16b609683887 +9344905376aa3982b1179497fac5a1d74b14b7038fd15e3b002db4c11c8bfc7c39430db492cdaf58b9c47996c9901f28 +a3bfafdae011a19f030c749c3b071f83580dee97dd6f949e790366f95618ca9f828f1daaeabad6dcd664fcef81b6556d +81c03d8429129e7e04434dee2c529194ddb01b414feda3adee2271eb680f6c85ec872a55c9fa9d2096f517e13ed5abcc +98205ef3a72dff54c5a9c82d293c3e45d908946fa74bb749c3aabe1ab994ea93c269bcce1a266d2fe67a8f02133c5985 +85a70aeed09fda24412fadbafbbbf5ba1e00ac92885df329e147bfafa97b57629a3582115b780d8549d07d19b7867715 +b0fbe81c719f89a57d9ea3397705f898175808c5f75f8eb81c2193a0b555869ba7bd2e6bc54ee8a60cea11735e21c68c +b03a0bd160495ee626ff3a5c7d95bc79d7da7e5a96f6d10116600c8fa20bedd1132f5170f25a22371a34a2d763f2d6d0 +a90ab04091fbca9f433b885e6c1d60ab45f6f1daf4b35ec22b09909d493a6aab65ce41a6f30c98239cbca27022f61a8b +b66f92aa3bf2549f9b60b86f99a0bd19cbdd97036d4ae71ca4b83d669607f275260a497208f6476cde1931d9712c2402 +b08e1fdf20e6a9b0b4942f14fa339551c3175c1ffc5d0ab5b226b6e6a322e9eb0ba96adc5c8d59ca4259e2bdd04a7eb0 +a2812231e92c1ce74d4f5ac3ab6698520288db6a38398bb38a914ac9326519580af17ae3e27cde26607e698294022c81 +abfcbbcf1d3b9e84c02499003e490a1d5d9a2841a9e50c7babbef0b2dd20d7483371d4dc629ba07faf46db659459d296 +b0fe9f98c3da70927c23f2975a9dc4789194d81932d2ad0f3b00843dd9cbd7fb60747a1da8fe5a79f136a601becf279d +b130a6dba7645165348cb90f023713bed0eefbd90a976b313521c60a36d34f02032e69a2bdcf5361e343ed46911297ec +862f0cffe3020cea7a5fd4703353aa1eb1be335e3b712b29d079ff9f7090d1d8b12013011e1bdcbaa80c44641fd37c9f +8c6f11123b26633e1abb9ed857e0bce845b2b3df91cc7b013b2fc77b477eee445da0285fc6fc793e29d5912977f40916 +91381846126ea819d40f84d3005e9fb233dc80071d1f9bb07f102bf015f813f61e5884ffffb4f5cd333c1b1e38a05a58 +8add7d908de6e1775adbd39c29a391f06692b936518db1f8fde74eb4f533fc510673a59afb86e3a9b52ade96e3004c57 +8780e086a244a092206edcde625cafb87c9ab1f89cc3e0d378bc9ee776313836160960a82ec397bc3800c0a0ec3da283 +a6cb4cd9481e22870fdd757fae0785edf4635e7aacb18072fe8dc5876d0bab53fb99ce40964a7d3e8bcfff6f0ab1332f +af30ff47ecc5b543efba1ba4706921066ca8bb625f40e530fb668aea0551c7647a9d126e8aba282fbcce168c3e7e0130 +91b0bcf408ce3c11555dcb80c4410b5bc2386d3c05caec0b653352377efdcb6bab4827f2018671fc8e4a0e90d772acc1 +a9430b975ef138b6b2944c7baded8fe102d31da4cfe3bd3d8778bda79189c99d38176a19c848a19e2d1ee0bddd9a13c1 +aa5a4eef849d7c9d2f4b018bd01271c1dd83f771de860c4261f385d3bdcc130218495860a1de298f14b703ec32fa235f +b0ce79e7f9ae57abe4ff366146c3b9bfb38b0dee09c28c28f5981a5d234c6810ad4d582751948affb480d6ae1c8c31c4 +b75122748560f73d15c01a8907d36d06dc068e82ce22b84b322ac1f727034493572f7907dec34ebc3ddcc976f2f89ed7 +b0fc7836369a3e4411d34792d6bd5617c14f61d9bba023dda64e89dc5fb0f423244e9b48ee64869258931daa9753a56f +8956d7455ae9009d70c6e4a0bcd7610e55f37494cf9897a8f9e1b904cc8febc3fd2d642ebd09025cfff4609ad7e3bc52 +ad741efe9e472026aa49ae3d9914cb9c1a6f37a54f1a6fe6419bebd8c7d68dca105a751c7859f4389505ede40a0de786 +b52f418797d719f0d0d0ffb0846788b5cba5d0454a69a2925de4b0b80fa4dd7e8c445e5eac40afd92897ed28ca650566 +a0ab65fb9d42dd966cd93b1de01d7c822694669dd2b7a0c04d99cd0f3c3de795f387b9c92da11353412f33af5c950e9a +a0052f44a31e5741a331f7cac515a08b3325666d388880162d9a7b97598fde8b61f9ff35ff220df224eb5c4e40ef0567 +a0101cfdc94e42b2b976c0d89612a720e55d145a5ef6ef6f1f78cf6de084a49973d9b5d45915349c34ce712512191e3c +a0dd99fcf3f5cead5aaf08e82212df3a8bb543c407a4d6fab88dc5130c1769df3f147e934a46f291d6c1a55d92b86917 +a5939153f0d1931bbda5cf6bdf20562519ea55fbfa978d6dbc6828d298260c0da7a50c37c34f386e59431301a96c2232 +9568269f3f5257200f9ca44afe1174a5d3cf92950a7f553e50e279c239e156a9faaa2a67f288e3d5100b4142efe64856 +b746b0832866c23288e07f24991bbf687cad794e7b794d3d3b79367566ca617d38af586cdc8d6f4a85a34835be41d54f +a871ce28e39ab467706e32fec1669fda5a4abba2f8c209c6745df9f7a0fa36bbf1919cf14cb89ea26fa214c4c907ae03 +a08dacdd758e523cb8484f6bd070642c0c20e184abdf8e2a601f61507e93952d5b8b0c723c34fcbdd70a8485eec29db2 +85bdb78d501382bb95f1166b8d032941005661aefd17a5ac32df9a3a18e9df2fc5dc2c1f07075f9641af10353cecc0c9 +98d730c28f6fa692a389e97e368b58f4d95382fad8f0baa58e71a3d7baaea1988ead47b13742ce587456f083636fa98e +a557198c6f3d5382be9fb363feb02e2e243b0c3c61337b3f1801c4a0943f18e38ce1a1c36b5c289c8fa2aa9d58742bab +89174f79201742220ac689c403fc7b243eed4f8e3f2f8aba0bf183e6f5d4907cb55ade3e238e3623d9885f03155c4d2b +b891d600132a86709e06f3381158db300975f73ea4c1f7c100358e14e98c5fbe792a9af666b85c4e402707c3f2db321e +b9e5b2529ef1043278c939373fc0dbafe446def52ddd0a8edecd3e4b736de87e63e187df853c54c28d865de18a358bb6 +8589b2e9770340c64679062c5badb7bbef68f55476289b19511a158a9a721f197da03ece3309e059fc4468b15ac33aa3 +aad8c6cd01d785a881b446f06f1e9cd71bca74ba98674c2dcddc8af01c40aa7a6d469037498b5602e76e9c91a58d3dbd +abaccb1bd918a8465f1bf8dbe2c9ad4775c620b055550b949a399f30cf0d9eb909f3851f5b55e38f9e461e762f88f499 +ae62339d26db46e85f157c0151bd29916d5cc619bd4b832814b3fd2f00af8f38e7f0f09932ffe5bba692005dab2d9a74 +93a6ff30a5c0edf8058c89aba8c3259e0f1b1be1b80e67682de651e5346f7e1b4b4ac3d87cbaebf198cf779524aff6bf +8980a2b1d8f574af45b459193c952400b10a86122b71fca2acb75ee0dbd492e7e1ef5b959baf609a5172115e371f3177 +8c2f49f3666faee6940c75e8c7f6f8edc3f704cca7a858bbb7ee5e96bba3b0cf0993996f781ba6be3b0821ef4cb75039 +b14b9e348215b278696018330f63c38db100b0542cfc5be11dc33046e3bca6a13034c4ae40d9cef9ea8b34fef0910c4e +b59bc3d0a30d66c16e6a411cb641f348cb1135186d5f69fda8b0a0934a5a2e7f6199095ba319ec87d3fe8f1ec4a06368 +8874aca2a3767aa198e4c3fec2d9c62d496bc41ff71ce242e9e082b7f38cdf356089295f80a301a3cf1182bde5308c97 +b1820ebd61376d91232423fc20bf008b2ba37e761199f4ef0648ea2bd70282766799b4de814846d2f4d516d525c8daa7 +a6b202e5dedc16a4073e04a11af3a8509b23dfe5a1952f899adeb240e75c3f5bde0c424f811a81ea48d343591faffe46 +a69becee9c93734805523b92150a59a62eed4934f66056b645728740d42223f2925a1ad38359ba644da24d9414f4cdda +ad72f0f1305e37c7e6b48c272323ee883320994cb2e0d850905d6655fafc9f361389bcb9c66b3ff8d2051dbb58c8aa96 +b563600bd56fad7c8853af21c6a02a16ed9d8a8bbeea2c31731d63b976d83cb05b9779372d898233e8fd597a75424797 +b0abb78ce465bf7051f563c62e8be9c57a2cc997f47c82819300f36e301fefd908894bb2053a9d27ce2d0f8c46d88b5b +a071a85fb8274bac2202e0cb8e0e2028a5e138a82d6e0374d39ca1884a549c7c401312f00071b91f455c3a2afcfe0cda +b931c271513a0f267b9f41444a5650b1918100b8f1a64959c552aff4e2193cc1b9927906c6fa7b8a8c68ef13d79aaa52 +a6a1bb9c7d32cb0ca44d8b75af7e40479fbce67d216b48a2bb680d3f3a772003a49d3cd675fc64e9e0f8fabeb86d6d61 +b98d609858671543e1c3b8564162ad828808bb50ded261a9f8690ded5b665ed8368c58f947365ed6e84e5a12e27b423d +b3dca58cd69ec855e2701a1d66cad86717ff103ef862c490399c771ad28f675680f9500cb97be48de34bcdc1e4503ffd +b34867c6735d3c49865e246ddf6c3b33baf8e6f164db3406a64ebce4768cb46b0309635e11be985fee09ab7a31d81402 +acb966c554188c5b266624208f31fab250b3aa197adbdd14aee5ab27d7fb886eb4350985c553b20fdf66d5d332bfd3fe +943c36a18223d6c870d54c3b051ef08d802b85e9dd6de37a51c932f90191890656c06adfa883c87b906557ae32d09da0 +81bca7954d0b9b6c3d4528aadf83e4bc2ef9ea143d6209bc45ae9e7ae9787dbcd8333c41f12c0b6deee8dcb6805e826a +aba176b92256efb68f574e543479e5cf0376889fb48e3db4ebfb7cba91e4d9bcf19dcfec444c6622d9398f06de29e2b9 +b9f743691448053216f6ece7cd699871fff4217a1409ceb8ab7bdf3312d11696d62c74b0664ba0a631b1e0237a8a0361 +a383c2b6276fa9af346b21609326b53fb14fdf6f61676683076e80f375b603645f2051985706d0401e6fbed7eb0666b6 +a9ef2f63ec6d9beb8f3d04e36807d84bda87bdd6b351a3e4a9bf7edcb5618c46c1f58cfbf89e64b40f550915c6988447 +a141b2d7a82f5005eaea7ae7d112c6788b9b95121e5b70b7168d971812f3381de8b0082ac1f0a82c7d365922ebd2d26a +b1b76ef8120e66e1535c17038b75255a07849935d3128e3e99e56567b842fb1e8d56ef932d508d2fb18b82f7868fe1a9 +8e2e234684c81f21099f5c54f6bbe2dd01e3b172623836c77668a0c49ce1fe218786c3827e4d9ae2ea25c50a8924fb3c +a5caf5ff948bfd3c4ca3ffbdfcd91eec83214a6c6017235f309a0bbf7061d3b0b466307c00b44a1009cf575163898b43 +986415a82ca16ebb107b4c50b0c023c28714281db0bcdab589f6cb13d80e473a3034b7081b3c358e725833f6d845cb14 +b94836bf406ac2cbacb10e6df5bcdfcc9d9124ae1062767ca4e322d287fd5e353fdcebd0e52407cb3cd68571258a8900 +83c6d70a640b33087454a4788dfd9ef3ed00272da084a8d36be817296f71c086b23b576f98178ab8ca6a74f04524b46b +ad4115182ad784cfe11bcfc5ce21fd56229cc2ce77ac82746e91a2f0aa53ca6593a22efd2dc4ed8d00f84542643d9c58 +ab1434c5e5065da826d10c2a2dba0facccab0e52b506ce0ce42fbe47ced5a741797151d9ecc99dc7d6373cfa1779bbf6 +8a8b591d82358d55e6938f67ea87a89097ab5f5496f7260adb9f649abb289da12b498c5b2539c2f9614fb4e21b1f66b0 +964f355d603264bc1f44c64d6d64debca66f37dff39c971d9fc924f2bc68e6c187b48564a6dc82660a98b035f8addb5d +b66235eaaf47456bc1dc4bde454a028e2ce494ece6b713a94cd6bf27cf18c717fd0c57a5681caaa2ad73a473593cdd7a +9103e3bb74304186fa4e3e355a02da77da4aca9b7e702982fc2082af67127ebb23a455098313c88465bc9b7d26820dd5 +b6a42ff407c9dd132670cdb83cbad4b20871716e44133b59a932cd1c3f97c7ac8ff7f61acfaf8628372508d8dc8cad7c +883a9c21c16a167a4171b0f084565c13b6f28ba7c4977a0de69f0a25911f64099e7bbb4da8858f2e93068f4155d04e18 +8dbb3220abc6a43220adf0331e3903d3bfd1d5213aadfbd8dfcdf4b2864ce2e96a71f35ecfb7a07c3bbabf0372b50271 +b4ad08aee48e176bda390b7d9acf2f8d5eb008f30d20994707b757dc6a3974b2902d29cd9b4d85e032810ad25ac49e97 +865bb0f33f7636ec501bb634e5b65751c8a230ae1fa807a961a8289bbf9c7fe8c59e01fbc4c04f8d59b7f539cf79ddd5 +86a54d4c12ad1e3605b9f93d4a37082fd26e888d2329847d89afa7802e815f33f38185c5b7292293d788ad7d7da1df97 +b26c8615c5e47691c9ff3deca3021714662d236c4d8401c5d27b50152ce7e566266b9d512d14eb63e65bc1d38a16f914 +827639d5ce7db43ba40152c8a0eaad443af21dc92636cc8cc2b35f10647da7d475a1e408901cd220552fddad79db74df +a2b79a582191a85dbe22dc384c9ca3de345e69f6aa370aa6d3ff1e1c3de513e30b72df9555b15a46586bd27ea2854d9d +ae0d74644aba9a49521d3e9553813bcb9e18f0b43515e4c74366e503c52f47236be92dfbd99c7285b3248c267b1de5a0 +80fb0c116e0fd6822a04b9c25f456bdca704e2be7bdc5d141dbf5d1c5eeb0a2c4f5d80db583b03ef3e47517e4f9a1b10 +ac3a1fa3b4a2f30ea7e0a114cdc479eb51773573804c2a158d603ad9902ae8e39ffe95df09c0d871725a5d7f9ba71a57 +b56b2b0d601cba7f817fa76102c68c2e518c6f20ff693aad3ff2e07d6c4c76203753f7f91686b1801e8c4659e4d45c48 +89d50c1fc56e656fb9d3915964ebce703cb723fe411ab3c9eaa88ccc5d2b155a9b2e515363d9c600d3c0cee782c43f41 +b24207e61462f6230f3cd8ccf6828357d03e725769f7d1de35099ef9ee4dca57dbce699bb49ed994462bee17059d25ce +b886f17fcbcbfcd08ac07f04bb9543ef58510189decaccea4b4158c9174a067cb67d14b6be3c934e6e2a18c77efa9c9c +b9c050ad9cafd41c6e2e192b70d080076eed59ed38ea19a12bd92fa17b5d8947d58d5546aaf5e8e27e1d3b5481a6ce51 +aaf7a34d3267e3b1ddbc54c641e3922e89303f7c86ebebc7347ebca4cffad5b76117dac0cbae1a133053492799cd936f +a9ee604ada50adef82e29e893070649d2d4b7136cc24fa20e281ce1a07bd736bf0de7c420369676bcbcecff26fb6e900 +9855315a12a4b4cf80ab90b8bd13003223ba25206e52fd4fe6a409232fbed938f30120a3db23eab9c53f308bd8b9db81 +8cd488dd7a24f548a3cf03c54dec7ff61d0685cb0f6e5c46c2d728e3500d8c7bd6bba0156f4bf600466fda53e5b20444 +890ad4942ebac8f5b16c777701ab80c68f56fa542002b0786f8fea0fb073154369920ac3dbfc07ea598b82f4985b8ced +8de0cf9ddc84c9b92c59b9b044387597799246b30b9f4d7626fc12c51f6e423e08ee4cbfe9289984983c1f9521c3e19d +b474dfb5b5f4231d7775b3c3a8744956b3f0c7a871d835d7e4fd9cc895222c7b868d6c6ce250de568a65851151fac860 +86433b6135d9ed9b5ee8cb7a6c40e5c9d30a68774cec04988117302b8a02a11a71a1e03fd8e0264ef6611d219f103007 +80b9ed4adbe9538fb1ef69dd44ec0ec5b57cbfea820054d8d445b4261962624b4c70ac330480594bc5168184378379c3 +8b2e83562ccd23b7ad2d17f55b1ab7ef5fbef64b3a284e6725b800f3222b8bdf49937f4a873917ada9c4ddfb090938c2 +abe78cebc0f5a45d754140d1f685e387489acbfa46d297a8592aaa0d676a470654f417a4f7d666fc0b2508fab37d908e +a9c5f8ff1f8568e252b06d10e1558326db9901840e6b3c26bbd0cd5e850cb5fb3af3f117dbb0f282740276f6fd84126f +975f8dc4fb55032a5df3b42b96c8c0ffecb75456f01d4aef66f973cb7270d4eff32c71520ceefc1adcf38d77b6b80c67 +b043306ed2c3d8a5b9a056565afd8b5e354c8c4569fda66b0d797a50a3ce2c08cffbae9bbe292da69f39e89d5dc7911e +8d2afc36b1e44386ba350c14a6c1bb31ff6ea77128a0c5287584ac3584282d18516901ce402b4644a53db1ed8e7fa581 +8c294058bed53d7290325c363fe243f6ec4f4ea2343692f4bac8f0cb86f115c069ccb8334b53d2e42c067691ad110dba +b92157b926751aaf7ef82c1aa8c654907dccab6376187ee8b3e8c0c82811eae01242832de953faa13ebaff7da8698b3e +a780c4bdd9e4ba57254b09d745075cecab87feda78c88ffee489625c5a3cf96aa6b3c9503a374a37927d9b78de9bd22b +811f548ef3a2e6a654f7dcb28ac9378de9515ed61e5a428515d9594a83e80b35c60f96a5cf743e6fab0d3cb526149f49 +85a4dccf6d90ee8e094731eec53bd00b3887aec6bd81a0740efddf812fd35e3e4fe4f983afb49a8588691c202dabf942 +b152c2da6f2e01c8913079ae2b40a09b1f361a80f5408a0237a8131b429677c3157295e11b365b1b1841924b9efb922e +849b9efee8742502ffd981c4517c88ed33e4dd518a330802caff168abae3cd09956a5ee5eda15900243bc2e829016b74 +955a933f3c18ec0f1c0e38fa931e4427a5372c46a3906ebe95082bcf878c35246523c23f0266644ace1fa590ffa6d119 +911989e9f43e580c886656377c6f856cdd4ff1bd001b6db3bbd86e590a821d34a5c6688a29b8d90f28680e9fdf03ba69 +b73b8b4f1fd6049fb68d47cd96a18fcba3f716e0a1061aa5a2596302795354e0c39dea04d91d232aec86b0bf2ba10522 +90f87456d9156e6a1f029a833bf3c7dbed98ca2f2f147a8564922c25ae197a55f7ea9b2ee1f81bf7383197c4bad2e20c +903cba8b1e088574cb04a05ca1899ab00d8960580c884bd3c8a4c98d680c2ad11410f2b75739d6050f91d7208cac33a5 +9329987d42529c261bd15ecedd360be0ea8966e7838f32896522c965adfc4febf187db392bd441fb43bbd10c38fdf68b +8178ee93acf5353baa349285067b20e9bb41aa32d77b5aeb7384fe5220c1fe64a2461bd7a83142694fe673e8bbf61b7c +a06a8e53abcff271b1394bcc647440f81fb1c1a5f29c27a226e08f961c3353f4891620f2d59b9d1902bf2f5cc07a4553 +aaf5fe493b337810889e777980e6bbea6cac39ac66bc0875c680c4208807ac866e9fda9b5952aa1d04539b9f4a4bec57 +aa058abb1953eceac14ccfa7c0cc482a146e1232905dcecc86dd27f75575285f06bbae16a8c9fe8e35d8713717f5f19f +8f15dd732799c879ca46d2763453b359ff483ca33adb1d0e0a57262352e0476c235987dc3a8a243c74bc768f93d3014c +a61cc8263e9bc03cce985f1663b8a72928a607121005a301b28a278e9654727fd1b22bc8a949af73929c56d9d3d4a273 +98d6dc78502d19eb9f921225475a6ebcc7b44f01a2df6f55ccf6908d65b27af1891be2a37735f0315b6e0f1576c1f8d8 +8bd258b883f3b3793ec5be9472ad1ff3dc4b51bc5a58e9f944acfb927349ead8231a523cc2175c1f98e7e1e2b9f363b8 +aeacc2ecb6e807ad09bedd99654b097a6f39840e932873ace02eabd64ccfbb475abdcb62939a698abf17572d2034c51e +b8ccf78c08ccd8df59fd6eda2e01de328bc6d8a65824d6f1fc0537654e9bc6bf6f89c422dd3a295cce628749da85c864 +8f91fd8cb253ba2e71cc6f13da5e05f62c2c3b485c24f5d68397d04665673167fce1fc1aec6085c69e87e66ec555d3fd +a254baa10cb26d04136886073bb4c159af8a8532e3fd36b1e9c3a2e41b5b2b6a86c4ebc14dbe624ee07b7ccdaf59f9ab +94e3286fe5cd68c4c7b9a7d33ae3d714a7f265cf77cd0e9bc19fc51015b1d1c34ad7e3a5221c459e89f5a043ee84e3a9 +a279da8878af8d449a9539bec4b17cea94f0242911f66fab275b5143ab040825f78c89cb32a793930609415cfa3a1078 +ac846ceb89c9e5d43a2991c8443079dc32298cd63e370e64149cec98cf48a6351c09c856f2632fd2f2b3d685a18bbf8b +a847b27995c8a2e2454aaeb983879fb5d3a23105c33175839f7300b7e1e8ec3efd6450e9fa3f10323609dee7b98c6fd5 +a2f432d147d904d185ff4b2de8c6b82fbea278a2956bc406855b44c18041854c4f0ecccd472d1d0dff1d8aa8e281cb1d +94a48ad40326f95bd63dff4755f863a1b79e1df771a1173b17937f9baba57b39e651e7695be9f66a472f098b339364fc +a12a0ccd8f96e96e1bc6494341f7ebce959899341b3a084aa1aa87d1c0d489ac908552b7770b887bb47e7b8cbc3d8e66 +81a1f1681bda923bd274bfe0fbb9181d6d164fe738e54e25e8d4849193d311e2c4253614ed673c98af2c798f19a93468 +abf71106a05d501e84cc54610d349d7d5eae21a70bd0250f1bebbf412a130414d1c8dbe673ffdb80208fd72f1defa4d4 +96266dc2e0df18d8136d79f5b59e489978eee0e6b04926687fe389d4293c14f36f055c550657a8e27be4118b64254901 +8df5dcbefbfb4810ae3a413ca6b4bf08619ca53cd50eb1dde2a1c035efffc7b7ac7dff18d403253fd80104bd83dc029e +9610b87ff02e391a43324a7122736876d5b3af2a137d749c52f75d07b17f19900b151b7f439d564f4529e77aa057ad12 +a90a5572198b40fe2fcf47c422274ff36c9624df7db7a89c0eb47eb48a73a03c985f4ac5016161c76ca317f64339bce1 +98e5e61a6ab6462ba692124dba7794b6c6bde4249ab4fcc98c9edd631592d5bc2fb5e38466691a0970a38e48d87c2e43 +918cefb8f292f78d4db81462c633daf73b395e772f47b3a7d2cea598025b1d8c3ec0cbff46cdb23597e74929981cde40 +a98918a5dc7cf610fe55f725e4fd24ce581d594cb957bb9b4e888672e9c0137003e1041f83e3f1d7b9caab06462c87d4 +b92b74ac015262ca66c33f2d950221e19d940ba3bf4cf17845f961dc1729ae227aa9e1f2017829f2135b489064565c29 +a053ee339f359665feb178b4e7ee30a85df37debd17cacc5a27d6b3369d170b0114e67ad1712ed26d828f1df641bcd99 +8c3c8bad510b35da5ce5bd84b35c958797fbea024ad1c97091d2ff71d9b962e9222f65a9b776e5b3cc29c36e1063d2ee +af99dc7330fe7c37e850283eb47cc3257888e7c197cb0d102edf94439e1e02267b6a56306d246c326c4c79f9dc8c6986 +afecb2dc34d57a725efbd7eb93d61eb29dbe8409b668ab9ea040791f5b796d9be6d4fc10d7f627bf693452f330cf0435 +93334fedf19a3727a81a6b6f2459db859186227b96fe7a391263f69f1a0884e4235de64d29edebc7b99c44d19e7c7d7a +89579c51ac405ad7e9df13c904061670ce4b38372492764170e4d3d667ed52e5d15c7cd5c5991bbfa3a5e4e3fa16363e +9778f3e8639030f7ef1c344014f124e375acb8045bd13d8e97a92c5265c52de9d1ffebaa5bc3e1ad2719da0083222991 +88f77f34ee92b3d36791bdf3326532524a67d544297dcf1a47ff00b47c1b8219ff11e34034eab7d23b507caa2fd3c6b9 +a699c1e654e7c484431d81d90657892efeb4adcf72c43618e71ca7bd7c7a7ebbb1db7e06e75b75dc4c74efd306b5df3f +81d13153baebb2ef672b5bdb069d3cd669ce0be96b742c94e04038f689ff92a61376341366b286eee6bf3ae85156f694 +81efb17de94400fdacc1deec2550cbe3eecb27c7af99d8207e2f9be397e26be24a40446d2a09536bb5172c28959318d9 +989b21ebe9ceab02488992673dc071d4d5edec24bff0e17a4306c8cb4b3c83df53a2063d1827edd8ed16d6e837f0d222 +8d6005d6536825661b13c5fdce177cb37c04e8b109b7eb2b6d82ea1cb70efecf6a0022b64f84d753d165edc2bba784a3 +a32607360a71d5e34af2271211652d73d7756d393161f4cf0da000c2d66a84c6826e09e759bd787d4fd0305e2439d342 +aaad8d6f6e260db45d51b2da723be6fa832e76f5fbcb77a9a31e7f090dd38446d3b631b96230d78208cae408c288ac4e +abcfe425255fd3c5cffd3a818af7650190c957b6b07b632443f9e33e970a8a4c3bf79ac9b71f4d45f238a04d1c049857 +aeabf026d4c783adc4414b5923dbd0be4b039cc7201219f7260d321f55e9a5b166d7b5875af6129c034d0108fdc5d666 +af49e740c752d7b6f17048014851f437ffd17413c59797e5078eaaa36f73f0017c3e7da020310cfe7d3c85f94a99f203 +8854ca600d842566e3090040cd66bb0b3c46dae6962a13946f0024c4a8aca447e2ccf6f240045f1ceee799a88cb9210c +b6c03b93b1ab1b88ded8edfa1b487a1ed8bdce8535244dddb558ffb78f89b1c74058f80f4db2320ad060d0c2a9c351cc +b5bd7d17372faff4898a7517009b61a7c8f6f0e7ed4192c555db264618e3f6e57fb30a472d169fea01bf2bf0362a19a8 +96eb1d38319dc74afe7e7eb076fcd230d19983f645abd14a71e6103545c01301b31c47ae931e025f3ecc01fb3d2f31fa +b55a8d30d4403067def9b65e16f867299f8f64c9b391d0846d4780bc196569622e7e5b64ce799b5aefac8f965b2a7a7b +8356d199a991e5cbbff608752b6291731b6b6771aed292f8948b1f41c6543e4ab1bedc82dd26d10206c907c03508df06 +97f4137445c2d98b0d1d478049de952610ad698c91c9d0f0e7227d2aae690e9935e914ec4a2ea1fbf3fc1dddfeeacebb +af5621707e0938320b15ddfc87584ab325fbdfd85c30efea36f8f9bd0707d7ec12c344eff3ec21761189518d192df035 +8ac7817e71ea0825b292687928e349da7140285d035e1e1abff0c3704fa8453faaae343a441b7143a74ec56539687cc4 +8a5e0a9e4758449489df10f3386029ada828d1762e4fb0a8ffe6b79e5b6d5d713cb64ed95960e126398b0cdb89002bc9 +81324be4a71208bbb9bca74b77177f8f1abb9d3d5d9db195d1854651f2cf333cd618d35400da0f060f3e1b025124e4b2 +849971d9d095ae067525b3cbc4a7dfae81f739537ade6d6cec1b42fb692d923176197a8770907c58069754b8882822d6 +89f830825416802477cc81fdf11084885865ee6607aa15aa4eb28e351c569c49b8a1b9b5e95ddc04fa0ebafe20071313 +9240aeeaff37a91af55f860b9badd466e8243af9e8c96a7aa8cf348cd270685ab6301bc135b246dca9eda696f8b0e350 +acf74db78cc33138273127599eba35b0fb4e7b9a69fe02dae18fc6692d748ca332bd00b22afa8e654ed587aab11833f3 +b091e6d37b157b50d76bd297ad752220cd5c9390fac16dc838f8557aed6d9833fc920b61519df21265406216315e883f +a6446c429ebf1c7793c622250e23594c836b2fbcaf6c5b3d0995e1595a37f50ea643f3e549b0be8bbdadd69044d72ab9 +93e675353bd60e996bf1c914d5267eeaa8a52fc3077987ccc796710ef9becc6b7a00e3d82671a6bdfb8145ee3c80245a +a2f731e43251d04ed3364aa2f072d05355f299626f2d71a8a38b6f76cf08c544133f7d72dd0ab4162814b674b9fc7fa6 +97a8b791a5a8f6e1d0de192d78615d73d0c38f1e557e4e15d15adc663d649e655bc8da3bcc499ef70112eafe7fb45c7a +98cd624cbbd6c53a94469be4643c13130916b91143425bcb7d7028adbbfede38eff7a21092af43b12d4fab703c116359 +995783ce38fd5f6f9433027f122d4cf1e1ff3caf2d196ce591877f4a544ce9113ead60de2de1827eaff4dd31a20d79a8 +8cf251d6f5229183b7f3fe2f607a90b4e4b6f020fb4ba2459d28eb8872426e7be8761a93d5413640a661d73e34a5b81f +b9232d99620652a3aa7880cad0876f153ff881c4ed4c0c2e7b4ea81d5d42b70daf1a56b869d752c3743c6d4c947e6641 +849716f938f9d37250cccb1bf77f5f9fde53096cdfc6f2a25536a6187029a8f1331cdbed08909184b201f8d9f04b792f +80c7c4de098cbf9c6d17b14eba1805e433b5bc905f6096f8f63d34b94734f2e4ebf4bce8a177efd1186842a61204a062 +b790f410cf06b9b8daadceeb4fd5ff40a2deda820c8df2537e0a7554613ae3948e149504e3e79aa84889df50c8678eeb +813aab8bd000299cd37485b73cd7cba06e205f8efb87f1efc0bae8b70f6db2bc7702eb39510ad734854fb65515fe9d0f +94f0ab7388ac71cdb67f6b85dfd5945748afb2e5abb622f0b5ad104be1d4d0062b651f134ba22385c9e32c2dfdcccce1 +ab6223dca8bd6a4f969e21ccd9f8106fc5251d321f9e90cc42cea2424b3a9c4e5060a47eeef6b23c7976109b548498e8 +859c56b71343fce4d5c5b87814c47bf55d581c50fd1871a17e77b5e1742f5af639d0e94d19d909ec7dfe27919e954e0c +aae0d632b6191b8ad71b027791735f1578e1b89890b6c22e37de0e4a6074886126988fe8319ae228ac9ef3b3bcccb730 +8ca9f32a27a024c3d595ecfaf96b0461de57befa3b331ab71dc110ec3be5824fed783d9516597537683e77a11d334338 +a061df379fb3f4b24816c9f6cd8a94ecb89b4c6dc6cd81e4b8096fa9784b7f97ab3540259d1de9c02eb91d9945af4823 +998603102ac63001d63eb7347a4bb2bf4cf33b28079bb48a169076a65c20d511ccd3ef696d159e54cc8e772fb5d65d50 +94444d96d39450872ac69e44088c252c71f46be8333a608a475147752dbb99db0e36acfc5198f158509401959c12b709 +ac1b51b6c09fe055c1d7c9176eea9adc33f710818c83a1fbfa073c8dc3a7eb3513cbdd3f5960b7845e31e3e83181e6ba +803d530523fc9e1e0f11040d2412d02baef3f07eeb9b177fa9bfa396af42eea898a4276d56e1db998dc96ae47b644cb2 +85a3c9fc7638f5bf2c3e15ba8c2fa1ae87eb1ceb44c6598c67a2948667a9dfa41e61f66d535b4e7fda62f013a5a8b885 +a961cf5654c46a1a22c29baf7a4e77837a26b7f138f410e9d1883480ed5fa42411d522aba32040b577046c11f007388e +ad1154142344f494e3061ef45a34fab1aaacf5fdf7d1b26adbb5fbc3d795655fa743444e39d9a4119b4a4f82a6f30441 +b1d6c30771130c77806e7ab893b73d4deb590b2ff8f2f8b5e54c2040c1f3e060e2bd99afc668cf706a2df666a508bbf6 +a00361fd440f9decabd98d96c575cd251dc94c60611025095d1201ef2dedde51cb4de7c2ece47732e5ed9b3526c2012c +a85c5ab4d17d328bda5e6d839a9a6adcc92ff844ec25f84981e4f44a0e8419247c081530f8d9aa629c7eb4ca21affba6 +a4ddd3eab4527a2672cf9463db38bc29f61460e2a162f426b7852b7a7645fbd62084fd39a8e4d60e1958cce436dd8f57 +811648140080fe55b8618f4cf17f3c5a250adb0cd53d885f2ddba835d2b4433188e41fc0661faac88e4ff910b16278c0 +b85c7f1cfb0ed29addccf7546023a79249e8f15ac2d14a20accbfef4dd9dc11355d599815fa09d2b6b4e966e6ea8cff1 +a10b5d8c260b159043b020d5dd62b3467df2671afea6d480ca9087b7e60ed170c82b121819d088315902842d66c8fb45 +917e191df1bcf3f5715419c1e2191da6b8680543b1ba41fe84ed07ef570376e072c081beb67b375fca3565a2565bcabb +881fd967407390bfd7badc9ab494e8a287559a01eb07861f527207c127eadea626e9bcc5aa9cca2c5112fbac3b3f0e9c +959fd71149af82cc733619e0e5bf71760ca2650448c82984b3db74030d0e10f8ab1ce1609a6de6f470fe8b5bd90df5b3 +a3370898a1c5f33d15adb4238df9a6c945f18b9ada4ce2624fc32a844f9ece4c916a64e9442225b6592afa06d2e015f2 +817efb8a791435e4236f7d7b278181a5fa34587578c629dbc14fbf9a5c26772290611395eecd20222a4c58649fc256d8 +a04c9876acf2cfdc8ef96de4879742709270fa1d03fe4c8511fbef2d59eb0aaf0336fa2c7dfe41a651157377fa217813 +81e15875d7ea7f123e418edf14099f2e109d4f3a6ce0eb65f67fe9fb10d2f809a864a29f60ad3fc949f89e2596b21783 +b49f529975c09e436e6bc202fdc16e3fdcbe056db45178016ad6fdece9faad4446343e83aed096209690b21a6910724f +879e8eda589e1a279f7f49f6dd0580788c040d973748ec4942dbe51ea8fbd05983cc919b78f0c6b92ef3292ae29db875 +81a2b74b2118923f34139a102f3d95e7eee11c4c2929c2576dee200a5abfd364606158535a6c9e4178a6a83dbb65f3c4 +8913f281d8927f2b45fc815d0f7104631cb7f5f7278a316f1327d670d15868daadd2a64e3eb98e1f53fe7e300338cc80 +a6f815fba7ef9af7fbf45f93bc952e8b351f5de6568a27c7c47a00cb39a254c6b31753794f67940fc7d2e9cc581529f4 +b3722a15c66a0014ce4d082de118def8d39190c15678a472b846225585f3a83756ae1b255b2e3f86a26168878e4773b2 +817ae61ab3d0dd5b6e24846b5a5364b1a7dc2e77432d9fed587727520ae2f307264ea0948c91ad29f0aea3a11ff38624 +b3db467464415fcad36dc1de2d6ba7686772a577cc2619242ac040d6734881a45d3b40ed4588db124e4289cfeec4bbf6 +ad66a14f5a54ac69603b16e5f1529851183da77d3cc60867f10aea41339dd5e06a5257982e9e90a352cdd32750f42ee4 +adafa3681ef45d685555601a25a55cf23358319a17f61e2179e704f63df83a73bdd298d12cf6cef86db89bd17119e11d +a379dc44cb6dd3b9d378c07b2ec654fec7ca2f272de6ba895e3d00d20c9e4c5550498a843c8ac67e4221db2115bedc1c +b7bf81c267a78efc6b9e5a904574445a6487678d7ef70054e3e93ea6a23f966c2b68787f9164918e3b16d2175459ed92 +b41d66a13a4afafd5760062b77f79de7e6ab8ccacde9c6c5116a6d886912fb491dc027af435b1b44aacc6af7b3c887f2 +9904d23a7c1c1d2e4bab85d69f283eb0a8e26d46e8b7b30224438015c936729b2f0af7c7c54c03509bb0500acb42d8a4 +ae30d65e9e20c3bfd603994ae2b175ff691d51f3e24b2d058b3b8556d12ca4c75087809062dddd4aaac81c94d15d8a17 +9245162fab42ac01527424f6013310c3eb462982518debef6c127f46ba8a06c705d7dc9f0a41e796ba8d35d60ae6cc64 +87fab853638d7a29a20f3ba2b1a7919d023e9415bfa78ebb27973d8cbc7626f584dc5665d2e7ad71f1d760eba9700d88 +85aac46ecd330608e5272430970e6081ff02a571e8ea444f1e11785ea798769634a22a142d0237f67b75369d3c484a8a +938c85ab14894cc5dfce3d80456f189a2e98eddbc8828f4ff6b1df1dcb7b42b17ca2ff40226a8a1390a95d63dca698dd +a18ce1f846e3e3c4d846822f60271eecf0f5d7d9f986385ac53c5ace9589dc7c0188910448c19b91341a1ef556652fa9 +8611608a9d844f0e9d7584ad6ccf62a5087a64f764caf108db648a776b5390feb51e5120f0ef0e9e11301af3987dd7dc +8106333ba4b4de8d1ae43bc9735d3fea047392e88efd6a2fa6f7b924a18a7a265ca6123c3edc0f36307dd7fb7fe89257 +a91426fa500951ff1b051a248c050b7139ca30dde8768690432d597d2b3c4357b11a577be6b455a1c5d145264dcf81fc +b7f9f90e0e450f37b081297f7f651bad0496a8b9afd2a4cf4120a2671aaaa8536dce1af301258bfbfdb122afa44c5048 +84126da6435699b0c09fa4032dec73d1fca21d2d19f5214e8b0bea43267e9a8dd1fc44f8132d8315e734c8e2e04d7291 +aff064708103884cb4f1a3c1718b3fc40a238d35cf0a7dc24bdf9823693b407c70da50df585bf5bc4e9c07d1c2d203e8 +a8b40fc6533752983a5329c31d376c7a5c13ce6879cc7faee648200075d9cd273537001fb4c86e8576350eaac6ba60c2 +a02db682bdc117a84dcb9312eb28fcbde12d49f4ce915cc92c610bb6965ec3cc38290f8c5b5ec70afe153956692cda95 +86decd22b25d300508472c9ce75d3e465b737e7ce13bc0fcce32835e54646fe12322ba5bc457be18bfd926a1a6ca4a38 +a18666ef65b8c2904fd598791f5627207165315a85ee01d5fb0e6b2e10bdd9b00babc447da5bd63445e3337de33b9b89 +89bb0c06effadefdaf34ffe4b123e1678a90d4451ee856c863df1e752eef41fd984689ded8f0f878bf8916d5dd8e8024 +97cfcba08ebec05d0073992a66b1d7d6fb9d95871f2cdc36db301f78bf8069294d1c259efef5c93d20dc937eedae3a1a +ac2643b14ece79dcb2e289c96776a47e2bebd40dd6dc74fd035df5bb727b5596f40e3dd2d2202141e69b0993717ede09 +a5e6fd88a2f9174d9bd4c6a55d9c30974be414992f22aa852f552c7648f722ed8077acf5aba030abd47939bb451b2c60 +8ad40a612824a7994487731a40b311b7349038c841145865539c6ada75c56de6ac547a1c23df190e0caaafecddd80ccc +953a7cea1d857e09202c438c6108060961f195f88c32f0e012236d7a4b39d840c61b162ec86436e8c38567328bea0246 +80d8b47a46dae1868a7b8ccfe7029445bbe1009dad4a6c31f9ef081be32e8e1ac1178c3c8fb68d3e536c84990cc035b1 +81ecd99f22b3766ce0aca08a0a9191793f68c754fdec78b82a4c3bdc2db122bbb9ebfd02fc2dcc6e1567a7d42d0cc16a +b1dd0446bccc25846fb95d08c1c9cc52fb51c72c4c5d169ffde56ecfe800f108dc1106d65d5c5bd1087c656de3940b63 +b87547f0931e164e96de5c550ca5aa81273648fe34f6e193cd9d69cf729cb432e17aa02e25b1c27a8a0d20a3b795e94e +820a94e69a927e077082aae66f6b292cfbe4589d932edf9e68e268c9bd3d71ef76cf7d169dd445b93967c25db11f58f1 +b0d07ddf2595270c39adfa0c8cf2ab1322979b0546aa4d918f641be53cd97f36c879bb75d205e457c011aca3bbd9f731 +8700b876b35b4b10a8a9372c5230acecd39539c1bb87515640293ad4464a9e02929d7d6a6a11112e8a29564815ac0de4 +a61a601c5bb27dcb97e37c8e2b9ce479c6b192a5e04d9ed5e065833c5a1017ee5f237b77d1a17be5d48f8e7cc0bcacf6 +92fb88fe774c1ba1d4a08cae3c0e05467ad610e7a3f1d2423fd47751759235fe0a3036db4095bd6404716aa03820f484 +b274f140d77a3ce0796f5e09094b516537ccaf27ae1907099bff172e6368ba85e7c3ef8ea2a07457cac48ae334da95b3 +b2292d9181f16581a9a9142490b2bdcdfb218ca6315d1effc8592100d792eb89d5356996c890441f04f2b4a95763503e +8897e73f576d86bc354baa3bd96e553107c48cf5889dcc23c5ba68ab8bcd4e81f27767be2233fdfa13d39f885087e668 +a29eac6f0829791c728d71abc49569df95a4446ecbfc534b39f24f56c88fe70301838dfc1c19751e7f3c5c1b8c6af6a0 +9346dc3720adc5df500a8df27fd9c75ef38dc5c8f4e8ed66983304750e66d502c3c59b8e955be781b670a0afc70a2167 +9566d534e0e30a5c5f1428665590617e95fd05d45f573715f58157854ad596ece3a3cfec61356aee342308d623e029d5 +a464fb8bffe6bd65f71938c1715c6e296cc6d0311a83858e4e7eb5873b7f2cf0c584d2101e3407b85b64ca78b2ac93ce +b54088f7217987c87e9498a747569ac5b2f8afd5348f9c45bf3fd9fbf713a20f495f49c8572d087efe778ac7313ad6d3 +91fa9f5f8000fe050f5b224d90b59fcce13c77e903cbf98ded752e5b3db16adb2bc1f8c94be48b69f65f1f1ad81d6264 +92d04a5b0ac5d8c8e313709b432c9434ecd3e73231f01e9b4e7952b87df60cbfa97b5dedd2200bd033b4b9ea8ba45cc1 +a94b90ad3c3d6c4bbe169f8661a790c40645b40f0a9d1c7220f01cf7fc176e04d80bab0ced9323fcafb93643f12b2760 +94d86149b9c8443b46196f7e5a3738206dd6f3be7762df488bcbb9f9ee285a64c997ed875b7b16b26604fa59020a8199 +82efe4ae2c50a2d7645240c173a047f238536598c04a2c0b69c96e96bd18e075a99110f1206bc213f39edca42ba00cc1 +ab8667685f831bc14d4610f84a5da27b4ea5b133b4d991741a9e64dceb22cb64a3ce8f1b6e101d52af6296df7127c9ad +83ba433661c05dcc5d562f4a9a261c8110dac44b8d833ae1514b1fc60d8b4ee395b18804baea04cb10adb428faf713c3 +b5748f6f660cc5277f1211d2b8649493ed8a11085b871cd33a5aea630abd960a740f08c08be5f9c21574600ac9bf5737 +a5c8dd12af48fb710642ad65ebb97ca489e8206741807f7acfc334f8035d3c80593b1ff2090c9bb7bd138f0c48714ca8 +a2b382fd5744e3babf454b1d806cc8783efeb4761bc42b6914ea48a46a2eae835efbe0a18262b6bc034379e03cf1262b +b3145ffaf603f69f15a64936d32e3219eea5ed49fdfd2f5bf40ea0dfd974b36fb6ff12164d4c2282d892db4cf3ff3ce1 +87a316fb213f4c5e30c5e3face049db66be4f28821bd96034714ec23d3e97849d7b301930f90a4323c7ccf53de23050c +b9de09a919455070fed6220fc179c8b7a4c753062bcd27acf28f5b9947a659c0b364298daf7c85c4ca6fca7f945add1f +806fbd98d411b76979464c40ad88bc07a151628a27fcc1012ba1dfbaf5b5cc9d962fb9b3386008978a12515edce934bc +a15268877fae0d21610ae6a31061ed7c20814723385955fac09fdc9693a94c33dea11db98bb89fdfe68f933490f5c381 +8d633fb0c4da86b2e0b37d8fad5972d62bff2ac663c5ec815d095cd4b7e1fe66ebef2a2590995b57eaf941983c7ad7a4 +8139e5dd9cf405e8ef65f11164f0440827d98389ce1b418b0c9628be983a9ddd6cf4863036ccb1483b40b8a527acd9ed +88b15fa94a08eac291d2b94a2b30eb851ff24addf2cc30b678e72e32cfcb3424cf4b33aa395d741803f3e578ddf524de +b5eaf0c8506e101f1646bcf049ee38d99ea1c60169730da893fd6020fd00a289eb2f415947e44677af49e43454a7b1be +8489822ad0647a7e06aa2aa5595960811858ddd4542acca419dd2308a8c5477648f4dd969a6740bb78aa26db9bfcc555 +b1e9a7b9f3423c220330d45f69e45fa03d7671897cf077f913c252e3e99c7b1b1cf6d30caad65e4228d5d7b80eb86e5e +b28fe9629592b9e6a55a1406903be76250b1c50c65296c10c5e48c64b539fb08fe11f68cf462a6edcbba71b0cee3feb2 +a41acf96a02c96cd8744ff6577c244fc923810d17ade133587e4c223beb7b4d99fa56eae311a500d7151979267d0895c +880798938fe4ba70721be90e666dfb62fcab4f3556fdb7b0dc8ec5bc34f6b4513df965eae78527136eb391889fe2caf9 +98d4d89d358e0fb7e212498c73447d94a83c1b66e98fc81427ab13acddb17a20f52308983f3a5a8e0aaacec432359604 +81430b6d2998fc78ba937a1639c6020199c52da499f68109da227882dc26d005b73d54c5bdcac1a04e8356a8ca0f7017 +a8d906a4786455eb74613aba4ce1c963c60095ffb8658d368df9266fdd01e30269ce10bf984e7465f34b4fd83beba26a +af54167ac1f954d10131d44a8e0045df00d581dd9e93596a28d157543fbe5fb25d213806ed7fb3cba6b8f5b5423562db +8511e373a978a12d81266b9afbd55035d7bc736835cfa921903a92969eeba3624437d1346b55382e61415726ab84a448 +8cf43eea93508ae586fa9a0f1354a1e16af659782479c2040874a46317f9e8d572a23238efa318fdfb87cc63932602b7 +b0bdd3bacff077173d302e3a9678d1d37936188c7ecc34950185af6b462b7c679815176f3cce5db19aac8b282f2d60ad +a355e9b87f2f2672052f5d4d65b8c1c827d24d89b0d8594641fccfb69aef1b94009105f3242058bb31c8bf51caae5a41 +b8baa9e4b950b72ff6b88a6509e8ed1304bc6fd955748b2e59a523a1e0c5e99f52aec3da7fa9ff407a7adf259652466c +840bc3dbb300ea6f27d1d6dd861f15680bd098be5174f45d6b75b094d0635aced539fa03ddbccb453879de77fb5d1fe9 +b4bc7e7e30686303856472bae07e581a0c0bfc815657c479f9f5931cff208d5c12930d2fd1ff413ebd8424bcd7a9b571 +89b5d514155d7999408334a50822508b9d689add55d44a240ff2bdde2eee419d117031f85e924e2a2c1ca77db9b91eea +a8604b6196f87a04e1350302e8aa745bba8dc162115d22657b37a1d1a98cb14876ddf7f65840b5dbd77e80cd22b4256c +83cb7acdb9e03247515bb2ce0227486ccf803426717a14510f0d59d45e998b245797d356f10abca94f7a14e1a2f0d552 +aeb3266a9f16649210ab2df0e1908ac259f34ce1f01162c22b56cf1019096ee4ea5854c36e30bb2feb06c21a71e8a45c +89e72e86edf2aa032a0fc9acf4d876a40865fbb2c8f87cb7e4d88856295c4ac14583e874142fd0c314a49aba68c0aa3c +8c3576eba0583c2a7884976b4ed11fe1fda4f6c32f6385d96c47b0e776afa287503b397fa516a455b4b8c3afeedc76db +a31e5b633bda9ffa174654fee98b5d5930a691c3c42fcf55673d927dbc8d91c58c4e42e615353145431baa646e8bbb30 +89f2f3f7a8da1544f24682f41c68114a8f78c86bd36b066e27da13acb70f18d9f548773a16bd8e24789420e17183f137 +ada27fa4e90a086240c9164544d2528621a415a5497badb79f8019dc3dce4d12eb6b599597e47ec6ac39c81efda43520 +90dc1eb21bf21c0187f359566fc4bf5386abea52799306a0e5a1151c0817c5f5bc60c86e76b1929c092c0f3ff48cedd2 +b702a53ebcc17ae35d2e735a347d2c700e9cbef8eadbece33cac83df483b2054c126593e1f462cfc00a3ce9d737e2af5 +9891b06455ec925a6f8eafffba05af6a38cc5e193acaaf74ffbf199df912c5197106c5e06d72942bbb032ce277b6417f +8c0ee71eb01197b019275bcf96cae94e81d2cdc3115dbf2d8e3080074260318bc9303597e8f72b18f965ad601d31ec43 +8aaf580aaf75c1b7a5f99ccf60503506e62058ef43b28b02f79b8536a96be3f019c9f71caf327b4e6730134730d1bef5 +ae6f9fc21dd7dfa672b25a87eb0a41644f7609fab5026d5cedb6e43a06dbbfd6d6e30322a2598c8dedde88c52eaed626 +8159b953ffece5693edadb2e906ebf76ff080ee1ad22698950d2d3bfc36ac5ea78f58284b2ca180664452d55bd54716c +ab7647c32ca5e9856ac283a2f86768d68de75ceeba9e58b74c5324f8298319e52183739aba4340be901699d66ac9eb3f +a4d85a5701d89bcfaf1572db83258d86a1a0717603d6f24ac2963ffcf80f1265e5ab376a4529ca504f4396498791253c +816080c0cdbfe61b4d726c305747a9eb58ac26d9a35f501dd32ba43c098082d20faf3ccd41aad24600aa73bfa453dfac +84f3afac024f576b0fd9acc6f2349c2fcefc3f77dbe5a2d4964d14b861b88e9b1810334b908cf3427d9b67a8aee74b18 +94b390655557b1a09110018e9b5a14490681ade275bdc83510b6465a1218465260d9a7e2a6e4ec700f58c31dc3659962 +a8c66826b1c04a2dd4c682543242e7a57acae37278bd09888a3d17747c5b5fec43548101e6f46d703638337e2fd3277b +86e6f4608a00007fa533c36a5b054c5768ccafe41ad52521d772dcae4c8a4bcaff8f7609be30d8fab62c5988cbbb6830 +837da4cf09ae8aa0bceb16f8b3bfcc3b3367aecac9eed6b4b56d7b65f55981ef066490764fb4c108792623ecf8cad383 +941ff3011462f9b5bf97d8cbdb0b6f5d37a1b1295b622f5485b7d69f2cb2bcabc83630dae427f0259d0d9539a77d8424 +b99e5d6d82aa9cf7d5970e7f710f4039ac32c2077530e4c2779250c6b9b373bc380adb0a03b892b652f649720672fc8c +a791c78464b2d65a15440b699e1e30ebd08501d6f2720adbc8255d989a82fcded2f79819b5f8f201bed84a255211b141 +84af7ad4a0e31fcbb3276ab1ad6171429cf39adcf78dc03750dc5deaa46536d15591e26d53e953dfb31e1622bc0743ab +a833e62fe97e1086fae1d4917fbaf09c345feb6bf1975b5cb863d8b66e8d621c7989ab3dbecda36bc9eaffc5eaa6fa66 +b4ef79a46a2126f53e2ebe62770feb57fd94600be29459d70a77c5e9cc260fa892be06cd60f886bf48459e48eb50d063 +b43b8f61919ea380bf151c294e54d3a3ff98e20d1ee5efbfe38aa2b66fafbc6a49739793bd5cb1c809f8b30466277c3a +ab37735af2412d2550e62df9d8b3b5e6f467f20de3890bf56faf1abf2bf3bd1d98dc3fa0ad5e7ab3fce0fa20409eb392 +82416b74b1551d484250d85bb151fabb67e29cce93d516125533df585bc80779ab057ea6992801a3d7d5c6dcff87a018 +8145d0787f0e3b5325190ae10c1d6bee713e6765fb6a0e9214132c6f78f4582bb2771aaeae40d3dad4bafb56bf7e36d8 +b6935886349ecbdd5774e12196f4275c97ec8279fdf28ccf940f6a022ebb6de8e97d6d2173c3fe402cbe9643bed3883b +87ef9b4d3dc71ac86369f8ed17e0dd3b91d16d14ae694bc21a35b5ae37211b043d0e36d8ff07dcc513fb9e6481a1f37f +ae1d0ded32f7e6f1dc8fef495879c1d9e01826f449f903c1e5034aeeabc5479a9e323b162b688317d46d35a42d570d86 +a40d16497004db4104c6794e2f4428d75bdf70352685944f3fbe17526df333e46a4ca6de55a4a48c02ecf0bde8ba03c0 +8d45121efba8cc308a498e8ee39ea6fa5cae9fb2e4aab1c2ff9d448aa8494ccbec9a078f978a86fcd97b5d5e7be7522a +a8173865c64634ba4ac2fa432740f5c05056a9deaf6427cb9b4b8da94ca5ddbc8c0c5d3185a89b8b28878194de9cdfcd +b6ec06a74d690f6545f0f0efba236e63d1fdfba54639ca2617408e185177ece28901c457d02b849fd00f1a53ae319d0a +b69a12df293c014a40070e3e760169b6f3c627caf9e50b35a93f11ecf8df98b2bc481b410eecb7ab210bf213bbe944de +97e7dc121795a533d4224803e591eef3e9008bab16f12472210b73aaf77890cf6e3877e0139403a0d3003c12c8f45636 +acdfa6fdd4a5acb7738cc8768f7cba84dbb95c639399b291ae8e4e63df37d2d4096900a84d2f0606bf534a9ccaa4993f +86ee253f3a9446a33e4d1169719b7d513c6b50730988415382faaf751988c10a421020609f7bcdef91be136704b906e2 +aac9438382a856caf84c5a8a234282f71b5fc5f65219103b147e7e6cf565522285fbfd7417b513bdad8277a00f652ca1 +83f3799d8e5772527930f5dc071a2e0a65471618993ec8990a96ccdeee65270e490bda9d26bb877612475268711ffd80 +93f28a81ac8c0ec9450b9d762fae9c7f8feaace87a6ee6bd141ef1d2d0697ef1bbd159fe6e1de640dbdab2b0361fca8a +a0825c95ba69999b90eac3a31a3fd830ea4f4b2b7409bde5f202b61d741d6326852ce790f41de5cb0eccec7af4db30c1 +83924b0e66233edd603c3b813d698daa05751fc34367120e3cf384ea7432e256ccee4d4daf13858950549d75a377107d +956fd9fa58345277e06ba2ec72f49ed230b8d3d4ff658555c52d6cddeb84dd4e36f1a614f5242d5ca0192e8daf0543c2 +944869912476baae0b114cced4ff65c0e4c90136f73ece5656460626599051b78802df67d7201c55d52725a97f5f29fe +865cb25b64b4531fb6fe4814d7c8cd26b017a6c6b72232ff53defc18a80fe3b39511b23f9e4c6c7249d06e03b2282ed2 +81e09ff55214960775e1e7f2758b9a6c4e4cd39edf7ec1adfaad51c52141182b79fe2176b23ddc7df9fd153e5f82d668 +b31006896f02bc90641121083f43c3172b1039334501fbaf1672f7bf5d174ddd185f945adf1a9c6cf77be34c5501483d +88b92f6f42ae45e9f05b16e52852826e933efd0c68b0f2418ac90957fd018df661bc47c8d43c2a7d7bfcf669dab98c3c +92fc68f595853ee8683930751789b799f397135d002eda244fe63ecef2754e15849edde3ba2f0cc8b865c9777230b712 +99ca06a49c5cd0bb097c447793fcdd809869b216a34c66c78c7e41e8c22f05d09168d46b8b1f3390db9452d91bc96dea +b48b9490a5d65296802431852d548d81047bbefc74fa7dc1d4e2a2878faacdfcb365ae59209cb0ade01901a283cbd15d +aff0fdbef7c188b120a02bc9085d7b808e88f73973773fef54707bf2cd772cd066740b1b6f4127b5c349f657bd97e738 +966fd4463b4f43dd8ccba7ad50baa42292f9f8b2e70da23bb6780e14155d9346e275ef03ddaf79e47020dcf43f3738bd +9330c3e1fadd9e08ac85f4839121ae20bbeb0a5103d84fa5aadbd1213805bdcda67bf2fb75fc301349cbc851b5559d20 +993bb99867bd9041a71a55ad5d397755cfa7ab6a4618fc526179bfc10b7dc8b26e4372fe9a9b4a15d64f2b63c1052dda +a29b59bcfab51f9b3c490a3b96f0bf1934265c315349b236012adbd64a56d7f6941b2c8cc272b412044bc7731f71e1dc +a65c9cefe1fc35d089fe8580c2e7671ebefdb43014ac291528ff4deefd4883fd4df274af83711dad610dad0d615f9d65 +944c78c56fb227ae632805d448ca3884cd3d2a89181cead3d2b7835e63297e6d740aa79a112edb1d4727824991636df5 +a73d782da1db7e4e65d7b26717a76e16dd9fab4df65063310b8e917dc0bc24e0d6755df5546c58504d04d9e68c3b474a +af80f0b87811ae3124f68108b4ca1937009403f87928bbc53480e7c5408d072053ace5eeaf5a5aba814dab8a45502085 +88aaf1acfc6e2e19b8387c97da707cb171c69812fefdd4650468e9b2c627bd5ccfb459f4d8e56bdfd84b09ddf87e128f +92c97276ff6f72bab6e9423d02ad6dc127962dbce15a0dd1e4a393b4510c555df6aa27be0f697c0d847033a9ca8b8dfd +a0e07d43d96e2d85b6276b3c60aadb48f0aedf2de8c415756dc597249ea64d2093731d8735231dadc961e5682ac59479 +adc9e6718a8f9298957d1da3842a7751c5399bbdf56f8de6c1c4bc39428f4aee6f1ba6613d37bf46b9403345e9d6fc81 +951da434da4b20d949b509ceeba02e24da7ed2da964c2fcdf426ec787779c696b385822c7dbea4df3e4a35921f1e912c +a04cbce0d2b2e87bbf038c798a12ec828423ca6aca08dc8d481cf6466e3c9c73d4d4a7fa47df9a7e2e15aae9e9f67208 +8f855cca2e440d248121c0469de1f94c2a71b8ee2682bbad3a78243a9e03da31d1925e6760dbc48a1957e040fae9abe8 +b642e5b17c1df4a4e101772d73851180b3a92e9e8b26c918050f51e6dd3592f102d20b0a1e96f0e25752c292f4c903ff +a92454c300781f8ae1766dbbb50a96192da7d48ef4cbdd72dd8cbb44c6eb5913c112cc38e9144615fdc03684deb99420 +8b74f7e6c2304f8e780df4649ef8221795dfe85fdbdaa477a1542d135b75c8be45bf89adbbb6f3ddf54ca40f02e733e9 +85cf66292cbb30cec5fd835ab10c9fcb3aea95e093aebf123e9a83c26f322d76ebc89c4e914524f6c5f6ee7d74fc917d +ae0bfe0cdc97c09542a7431820015f2d16067b30dca56288013876025e81daa8c519e5e347268e19aa1a85fa1dc28793 +921322fc6a47dc091afa0ad6df18ed14cde38e48c6e71550aa513918b056044983aee402de21051235eecf4ce8040fbe +96c030381e97050a45a318d307dcb3c8377b79b4dd5daf6337cded114de26eb725c14171b9b8e1b3c08fe1f5ea6b49e0 +90c23b86b6111818c8baaf53a13eaee1c89203b50e7f9a994bf0edf851919b48edbac7ceef14ac9414cf70c486174a77 +8bf6c301240d2d1c8d84c71d33a6dfc6d9e8f1cfae66d4d0f7a256d98ae12b0bcebfa94a667735ee89f810bcd7170cff +a41a4ffbbea0e36874d65c009ee4c3feffff322f6fc0e30d26ee4dbc1f46040d05e25d9d0ecb378cef0d24a7c2c4b850 +a8d4cdd423986bb392a0a92c12a8bd4da3437eec6ef6af34cf5310944899287452a2eb92eb5386086d5063381189d10e +a81dd26ec057c4032a4ed7ad54d926165273ed51d09a1267b2e477535cf6966835a257c209e4e92d165d74fa75695fa3 +8d7f708c3ee8449515d94fc26b547303b53d8dd55f177bc3b25d3da2768accd9bc8e9f09546090ebb7f15c66e6c9c723 +839ba65cffcd24cfffa7ab3b21faabe3c66d4c06324f07b2729c92f15cad34e474b0f0ddb16cd652870b26a756b731d3 +87f1a3968afec354d92d77e2726b702847c6afcabb8438634f9c6f7766de4c1504317dc4fa9a4a735acdbf985e119564 +91a8a7fd6542f3e0673f07f510d850864b34ac087eb7eef8845a1d14b2b1b651cbdc27fa4049bdbf3fea54221c5c8549 +aef3cf5f5e3a2385ead115728d7059e622146c3457d266c612e778324b6e06fbfb8f98e076624d2f3ce1035d65389a07 +819915d6232e95ccd7693fdd78d00492299b1983bc8f96a08dcb50f9c0a813ed93ae53c0238345d5bea0beda2855a913 +8e9ba68ded0e94935131b392b28218315a185f63bf5e3c1a9a9dd470944509ca0ba8f6122265f8da851b5cc2abce68f1 +b28468e9b04ee9d69003399a3cf4457c9bf9d59f36ab6ceeb8e964672433d06b58beeea198fedc7edbaa1948577e9fa2 +a633005e2c9f2fd94c8bce2dd5bb708fe946b25f1ec561ae65e54e15cdd88dc339f1a083e01f0d39610c8fe24151aaf0 +841d0031e22723f9328dd993805abd13e0c99b0f59435d2426246996b08d00ce73ab906f66c4eab423473b409e972ce0 +85758d1b084263992070ec8943f33073a2d9b86a8606672550c17545507a5b3c88d87382b41916a87ee96ff55a7aa535 +8581b06b0fc41466ef94a76a1d9fb8ae0edca6d018063acf6a8ca5f4b02d76021902feba58972415691b4bdbc33ae3b4 +83539597ff5e327357ee62bc6bf8c0bcaec2f227c55c7c385a4806f0d37fb461f1690bad5066b8a5370950af32fafbef +aee3557290d2dc10827e4791d00e0259006911f3f3fce4179ed3c514b779160613eca70f720bff7804752715a1266ffa +b48d2f0c4e90fc307d5995464e3f611a9b0ef5fe426a289071f4168ed5cc4f8770c9332960c2ca5c8c427f40e6bb389f +847af8973b4e300bb06be69b71b96183fd1a0b9d51b91701bef6fcfde465068f1eb2b1503b07afda380f18d69de5c9e1 +a70a6a80ce407f07804c0051ac21dc24d794b387be94eb24e1db94b58a78e1bcfb48cd0006db8fc1f9bedaece7a44fbe +b40e942b8fa5336910ff0098347df716bff9d1fa236a1950c16eeb966b3bc1a50b8f7b0980469d42e75ae13ced53cead +b208fabaa742d7db3148515330eb7a3577487845abdb7bd9ed169d0e081db0a5816595c33d375e56aeac5b51e60e49d3 +b7c8194b30d3d6ef5ab66ec88ad7ebbc732a3b8a41731b153e6f63759a93f3f4a537eab9ad369705bd730184bdbbdc34 +9280096445fe7394d04aa1bc4620c8f9296e991cc4d6c131bd703cb1cc317510e6e5855ac763f4d958c5edfe7eebeed7 +abc2aa4616a521400af1a12440dc544e3c821313d0ab936c86af28468ef8bbe534837e364598396a81cf8d06274ed5a6 +b18ca8a3325adb0c8c18a666d4859535397a1c3fe08f95eebfac916a7a99bbd40b3c37b919e8a8ae91da38bc00fa56c0 +8a40c33109ecea2a8b3558565877082f79121a432c45ec2c5a5e0ec4d1c203a6788e6b69cb37f1fd5b8c9a661bc5476d +88c47301dd30998e903c84e0b0f2c9af2e1ce6b9f187dab03528d44f834dc991e4c86d0c474a2c63468cf4020a1e24a0 +920c832853e6ab4c851eecfa9c11d3acc7da37c823be7aa1ab15e14dfd8beb5d0b91d62a30cec94763bd8e4594b66600 +98e1addbe2a6b8edc7f12ecb9be81c3250aeeca54a1c6a7225772ca66549827c15f3950d01b8eb44aecb56fe0fff901a +8cfb0fa1068be0ec088402f5950c4679a2eb9218c729da67050b0d1b2d7079f3ddf4bf0f57d95fe2a8db04bc6bcdb20c +b70f381aafe336b024120453813aeab70baac85b9c4c0f86918797b6aee206e6ed93244a49950f3d8ec9f81f4ac15808 +a4c8edf4aa33b709a91e1062939512419711c1757084e46f8f4b7ed64f8e682f4e78b7135920c12f0eb0422fe9f87a6a +b4817e85fd0752d7ebb662d3a51a03367a84bac74ebddfba0e5af5e636a979500f72b148052d333b3dedf9edd2b4031b +a87430169c6195f5d3e314ff2d1c2f050e766fd5d2de88f5207d72dba4a7745bb86d0baca6e9ae156582d0d89e5838c7 +991b00f8b104566b63a12af4826b61ce7aa40f4e5b8fff3085e7a99815bdb4471b6214da1e480214fac83f86a0b93cc5 +b39966e3076482079de0678477df98578377a094054960ee518ef99504d6851f8bcd3203e8da5e1d4f6f96776e1fe6eb +a448846d9dc2ab7a0995fa44b8527e27f6b3b74c6e03e95edb64e6baa4f1b866103f0addb97c84bef1d72487b2e21796 +894bec21a453ae84b592286e696c35bc30e820e9c2fd3e63dd4fbe629e07df16439c891056070faa490155f255bf7187 +a9ec652a491b11f6a692064e955f3f3287e7d2764527e58938571469a1e29b5225b9415bd602a45074dfbfe9c131d6ca +b39d37822e6cbe28244b5f42ce467c65a23765bd16eb6447c5b3e942278069793763483dafd8c4dd864f8917aad357fe +88dba51133f2019cb266641c56101e3e5987d3b77647a2e608b5ff9113dfc5f85e2b7c365118723131fbc0c9ca833c9c +b566579d904b54ecf798018efcb824dccbebfc6753a0fd2128ac3b4bd3b038c2284a7c782b5ca6f310eb7ea4d26a3f0a +a97a55c0a492e53c047e7d6f9d5f3e86fb96f3dddc68389c0561515343b66b4bc02a9c0d5722dff1e3445308240b27f7 +a044028ab4bcb9e1a2b9b4ca4efbf04c5da9e4bf2fff0e8bd57aa1fc12a71e897999c25d9117413faf2f45395dee0f13 +a78dc461decbeaeed8ebd0909369b491a5e764d6a5645a7dac61d3140d7dc0062526f777b0eb866bff27608429ebbdde +b2c2a8991f94c39ca35fea59f01a92cb3393e0eccb2476dfbf57261d406a68bd34a6cff33ed80209991688c183609ef4 +84189eefb521aff730a4fd3fd5b10ddfd29f0d365664caef63bb015d07e689989e54c33c2141dd64427805d37a7e546e +85ac80bd734a52235da288ff042dea9a62e085928954e8eacd2c751013f61904ed110e5b3afe1ab770a7e6485efb7b5e +9183a560393dcb22d0d5063e71182020d0fbabb39e32493eeffeb808df084aa243eb397027f150b55a247d1ed0c8513e +81c940944df7ecc58d3c43c34996852c3c7915ed185d7654627f7af62abae7e0048dd444a6c09961756455000bd96d09 +aa8c34e164019743fd8284b84f06c3b449aae7996e892f419ee55d82ad548cb300fd651de329da0384243954c0ef6a60 +89a7b7bdfc7e300d06a14d463e573d6296d8e66197491900cc9ae49504c4809ff6e61b758579e9091c61085ba1237b83 +878d21809ba540f50bd11f4c4d9590fb6f3ab9de5692606e6e2ef4ed9d18520119e385be5e1f4b3f2e2b09c319f0e8fc +8eb248390193189cf0355365e630b782cd15751e672dc478b39d75dc681234dcd9309df0d11f4610dbb249c1e6be7ef9 +a1d7fb3aecb896df3a52d6bd0943838b13f1bd039c936d76d03de2044c371d48865694b6f532393b27fd10a4cf642061 +a34bca58a24979be442238cbb5ece5bee51ae8c0794dd3efb3983d4db713bc6f28a96e976ac3bd9a551d3ed9ba6b3e22 +817c608fc8cacdd178665320b5a7587ca21df8bdd761833c3018b967575d25e3951cf3d498a63619a3cd2ad4406f5f28 +86c95707db0495689afd0c2e39e97f445f7ca0edffad5c8b4cacd1421f2f3cc55049dfd504f728f91534e20383955582 +99c3b0bb15942c301137765d4e19502f65806f3b126dc01a5b7820c87e8979bce6a37289a8f6a4c1e4637227ad5bf3bf +8aa1518a80ea8b074505a9b3f96829f5d4afa55a30efe7b4de4e5dbf666897fdd2cf31728ca45921e21a78a80f0e0f10 +8d74f46361c79e15128ac399e958a91067ef4cec8983408775a87eca1eed5b7dcbf0ddf30e66f51780457413496c7f07 +a41cde4a786b55387458a1db95171aca4fd146507b81c4da1e6d6e495527c3ec83fc42fad1dfe3d92744084a664fd431 +8c352852c906fae99413a84ad11701f93f292fbf7bd14738814f4c4ceab32db02feb5eb70bc73898b0bc724a39d5d017 +a5993046e8f23b71ba87b7caa7ace2d9023fb48ce4c51838813174880d918e9b4d2b0dc21a2b9c6f612338c31a289df8 +83576d3324bf2d8afbfb6eaecdc5d767c8e22e7d25160414924f0645491df60541948a05e1f4202e612368e78675de8a +b43749b8df4b15bc9a3697e0f1c518e6b04114171739ef1a0c9c65185d8ec18e40e6954d125cbc14ebc652cf41ad3109 +b4eebd5d80a7327a040cafb9ccdb12b2dfe1aa86e6bc6d3ac8a57fadfb95a5b1a7332c66318ff72ba459f525668af056 +9198be7f1d413c5029b0e1c617bcbc082d21abe2c60ec8ce9b54ca1a85d3dba637b72fda39dae0c0ae40d047eab9f55a +8d96a0232832e24d45092653e781e7a9c9520766c3989e67bbe86b3a820c4bf621ea911e7cd5270a4bfea78b618411f6 +8d7160d0ea98161a2d14d46ef01dff72d566c330cd4fabd27654d300e1bc7644c68dc8eabf2a20a59bfe7ba276545f9b +abb60fce29dec7ba37e3056e412e0ec3e05538a1fc0e2c68877378c867605966108bc5742585ab6a405ce0c962b285b6 +8fabffa3ed792f05e414f5839386f6449fd9f7b41a47595c5d71074bd1bb3784cc7a1a7e1ad6b041b455035957e5b2dc +90ff017b4804c2d0533b72461436b10603ab13a55f86fd4ec11b06a70ef8166f958c110519ca1b4cc7beba440729fe2d +b340cfd120f6a4623e3a74cf8c32bfd7cd61a280b59dfd17b15ca8fae4d82f64a6f15fbde4c02f424debc72b7db5fe67 +871311c9c7220c932e738d59f0ecc67a34356d1429fe570ca503d340c9996cb5ee2cd188fad0e3bd16e4c468ec1dbebd +a772470262186e7b94239ba921b29f2412c148d6f97c4412e96d21e55f3be73f992f1ad53c71008f0558ec3f84e2b5a7 +b2a897dcb7ffd6257f3f2947ec966f2077d57d5191a88840b1d4f67effebe8c436641be85524d0a21be734c63ab5965d +a044f6eacc48a4a061fa149500d96b48cbf14853469aa4d045faf3dca973be1bd4b4ce01646d83e2f24f7c486d03205d +981af5dc2daa73f7fa9eae35a93d81eb6edba4a7f673b55d41f6ecd87a37685d31bb40ef4f1c469b3d72f2f18b925a17 +912d2597a07864de9020ac77083eff2f15ceb07600f15755aba61251e8ce3c905a758453b417f04d9c38db040954eb65 +9642b7f6f09394ba5e0805734ef6702c3eddf9eea187ba98c676d5bbaec0e360e3e51dc58433aaa1e2da6060c8659cb7 +8ab3836e0a8ac492d5e707d056310c4c8e0489ca85eb771bff35ba1d658360084e836a6f51bb990f9e3d2d9aeb18fbb5 +879e058e72b73bb1f4642c21ffdb90544b846868139c6511f299aafe59c2d0f0b944dffc7990491b7c4edcd6a9889250 +b9e60b737023f61479a4a8fd253ed0d2a944ea6ba0439bbc0a0d3abf09b0ad1f18d75555e4a50405470ae4990626f390 +b9c2535d362796dcd673640a9fa2ebdaec274e6f8b850b023153b0a7a30fffc87f96e0b72696f647ebe7ab63099a6963 +94aeff145386a087b0e91e68a84a5ede01f978f9dd9fe7bebca78941938469495dc30a96bba9508c0d017873aeea9610 +98b179f8a3d9f0d0a983c30682dd425a2ddc7803be59bd626c623c8951a5179117d1d2a68254c95c9952989877d0ee55 +889ecf5f0ee56938273f74eb3e9ecfb5617f04fb58e83fe4c0e4aef51615cf345bc56f3f61b17f6eed3249d4afd54451 +a0f2b2c39bcea4b50883e2587d16559e246248a66ecb4a4b7d9ab3b51fb39fe98d83765e087eee37a0f86b0ba4144c02 +b2a61e247ed595e8a3830f7973b07079cbda510f28ad8c78c220b26cb6acde4fbb5ee90c14a665f329168ee951b08cf0 +95bd0fcfb42f0d6d8a8e73d7458498a85bcddd2fb132fd7989265648d82ac2707d6d203fac045504977af4f0a2aca4b7 +843e5a537c298666e6cf50fcc044f13506499ef83c802e719ff2c90e85003c132024e04711be7234c04d4b0125512d5d +a46d1797c5959dcd3a5cfc857488f4d96f74277c3d13b98b133620192f79944abcb3a361d939a100187f1b0856eae875 +a1c7786736d6707a48515c38660615fcec67eb8a2598f46657855215f804fd72ab122d17f94fcffad8893f3be658dca7 +b23dc9e610abc7d8bd21d147e22509a0fa49db5be6ea7057b51aae38e31654b3aa044df05b94b718153361371ba2f622 +b00cc8f257d659c22d30e6d641f79166b1e752ea8606f558e4cad6fc01532e8319ea4ee12265ba4140ac45aa4613c004 +ac7019af65221b0cc736287b32d7f1a3561405715ba9a6a122342e04e51637ba911c41573de53e4781f2230fdcb2475f +81a630bc41b3da8b3eb4bf56cba10cd9f93153c3667f009dc332287baeb707d505fb537e6233c8e53d299ec0f013290c +a6b7aea5c545bb76df0f230548539db92bc26642572cb7dd3d5a30edca2b4c386f44fc8466f056b42de2a452b81aff5b +8271624ff736b7b238e43943c81de80a1612207d32036d820c11fc830c737972ccc9c60d3c2359922b06652311e3c994 +8a684106458cb6f4db478170b9ad595d4b54c18bf63b9058f095a2fa1b928c15101472c70c648873d5887880059ed402 +a5cc3c35228122f410184e4326cf61a37637206e589fcd245cb5d0cec91031f8f7586b80503070840fdfd8ce75d3c88b +9443fc631aed8866a7ed220890911057a1f56b0afe0ba15f0a0e295ab97f604b134b1ed9a4245e46ee5f9a93aa74f731 +984b6f7d79835dffde9558c6bb912d992ca1180a2361757bdba4a7b69dc74b056e303adc69fe67414495dd9c2dd91e64 +b15a5c8cba5de080224c274d31c68ed72d2a7126d347796569aef0c4e97ed084afe3da4d4b590b9dda1a07f0c2ff3dfb +991708fe9650a1f9a4e43938b91d45dc68c230e05ee999c95dbff3bf79b1c1b2bb0e7977de454237c355a73b8438b1d9 +b4f7edc7468b176a4a7c0273700c444fa95c726af6697028bed4f77eee887e3400f9c42ee15b782c0ca861c4c3b8c98a +8c60dcc16c51087eb477c13e837031d6c6a3dc2b8bf8cb43c23f48006bc7173151807e866ead2234b460c2de93b31956 +83ad63e9c910d1fc44bc114accfb0d4d333b7ebe032f73f62d25d3e172c029d5e34a1c9d547273bf6c0fead5c8801007 +85de73213cc236f00777560756bdbf2b16841ba4b55902cf2cad9742ecaf5d28209b012ceb41f337456dfeca93010cd7 +a7561f8827ccd75b6686ba5398bb8fc3083351c55a589b18984e186820af7e275af04bcd4c28e1dc11be1e8617a0610b +88c0a4febd4068850557f497ea888035c7fc9f404f6cc7794e7cc8722f048ad2f249e7dc62743e7a339eb7473ad3b0cd +932b22b1d3e6d5a6409c34980d176feb85ada1bf94332ef5c9fc4d42b907dabea608ceef9b5595ef3feee195151f18d8 +a2867bb3f5ab88fbdae3a16c9143ab8a8f4f476a2643c505bb9f37e5b1fd34d216cab2204c9a017a5a67b7ad2dda10e8 +b573d5f38e4e9e8a3a6fd82f0880dc049efa492a946d00283019bf1d5e5516464cf87039e80aef667cb86fdea5075904 +b948f1b5ab755f3f5f36af27d94f503b070696d793b1240c1bdfd2e8e56890d69e6904688b5f8ff5a4bdf5a6abfe195f +917eae95ebc4109a2e99ddd8fec7881d2f7aaa0e25fda44dec7ce37458c2ee832f1829db7d2dcfa4ca0f06381c7fe91d +95751d17ed00a3030bce909333799bb7f4ab641acf585807f355b51d6976dceee410798026a1a004ef4dcdff7ec0f5b8 +b9b7bd266f449a79bbfe075e429613e76c5a42ac61f01c8f0bbbd34669650682efe01ff9dbbc400a1e995616af6aa278 +ac1722d097ce9cd7617161f8ec8c23d68f1fb1c9ca533e2a8b4f78516c2fd8fb38f23f834e2b9a03bb06a9d655693ca9 +a7ad9e96ffd98db2ecdb6340c5d592614f3c159abfd832fe27ee9293519d213a578e6246aae51672ee353e3296858873 +989b8814d5de7937c4acafd000eec2b4cd58ba395d7b25f98cafd021e8efa37029b29ad8303a1f6867923f5852a220eb +a5bfe6282c771bc9e453e964042d44eff4098decacb89aecd3be662ea5b74506e1357ab26f3527110ba377711f3c9f41 +8900a7470b656639721d2abbb7b06af0ac4222ab85a1976386e2a62eb4b88bfb5b72cf7921ddb3cf3a395d7eeb192a2e +95a71b55cd1f35a438cf5e75f8ff11c5ec6a2ebf2e4dba172f50bfad7d6d5dca5de1b1afc541662c81c858f7604c1163 +82b5d62fea8db8d85c5bc3a76d68dedd25794cf14d4a7bc368938ffca9e09f7e598fdad2a5aac614e0e52f8112ae62b9 +997173f07c729202afcde3028fa7f52cefc90fda2d0c8ac2b58154a5073140683e54c49ed1f254481070d119ce0ce02a +aeffb91ccc7a72bbd6ffe0f9b99c9e66e67d59cec2e02440465e9636a613ab3017278cfa72ea8bc4aba9a8dc728cb367 +952743b06e8645894aeb6440fc7a5f62dd3acf96dab70a51e20176762c9751ea5f2ba0b9497ccf0114dc4892dc606031 +874c63baeddc56fbbca2ff6031f8634b745f6e34ea6791d7c439201aee8f08ef5ee75f7778700a647f3b21068513fce6 +85128fec9c750c1071edfb15586435cc2f317e3e9a175bb8a9697bcda1eb9375478cf25d01e7fed113483b28f625122d +85522c9576fd9763e32af8495ae3928ed7116fb70d4378448926bc9790e8a8d08f98cf47648d7da1b6e40d6a210c7924 +97d0f37a13cfb723b848099ca1c14d83e9aaf2f7aeb71829180e664b7968632a08f6a85f557d74b55afe6242f2a36e7c +abaa472d6ad61a5fccd1a57c01aa1bc081253f95abbcba7f73923f1f11c4e79b904263890eeb66926de3e2652f5d1c70 +b3c04945ba727a141e5e8aec2bf9aa3772b64d8fd0e2a2b07f3a91106a95cbcb249adcd074cbe498caf76fffac20d4ef +82c46781a3d730d9931bcabd7434a9171372dde57171b6180e5516d4e68db8b23495c8ac3ab96994c17ddb1cf249b9fb +a202d8b65613c42d01738ccd68ed8c2dbc021631f602d53f751966e04182743ebc8e0747d600b8a8676b1da9ae7f11ab +ae73e7256e9459db04667a899e0d3ea5255211fb486d084e6550b6dd64ca44af6c6b2d59d7aa152de9f96ce9b58d940d +b67d87b176a9722945ec7593777ee461809861c6cfd1b945dde9ee4ff009ca4f19cf88f4bbb5c80c9cbab2fe25b23ac8 +8f0b7a317a076758b0dac79959ee4a06c08b07d0f10538a4b53d3da2eda16e2af26922feb32c090330dc4d969cf69bd3 +90b36bf56adbd8c4b6cb32febc3a8d5f714370c2ac3305c10fa6d168dffb2a026804517215f9a2d4ec8310cdb6bb459b +aa80c19b0682ead69934bf18cf476291a0beddd8ef4ed75975d0a472e2ab5c70f119722a8574ae4973aceb733d312e57 +a3fc9abb12574e5c28dcb51750b4339b794b8e558675eef7d26126edf1de920c35e992333bcbffcbf6a5f5c0d383ce62 +a1573ff23ab972acdcd08818853b111fc757fdd35aa070186d3e11e56b172fb49d840bf297ac0dd222e072fc09f26a81 +98306f2be4caa92c2b4392212d0cbf430b409b19ff7d5b899986613bd0e762c909fc01999aa94be3bd529d67f0113d7f +8c1fc42482a0819074241746d17dc89c0304a2acdae8ed91b5009e9e3e70ff725ba063b4a3e68fdce05b74f5180c545e +a6c6113ebf72d8cf3163b2b8d7f3fa24303b13f55752522c660a98cd834d85d8c79214d900fa649499365e2e7641f77a +ab95eea424f8a2cfd9fb1c78bb724e5b1d71a0d0d1e4217c5d0f98b0d8bbd3f8400a2002abc0a0e4576d1f93f46fefad +823c5a4fd8cf4a75fdc71d5f2dd511b6c0f189b82affeacd2b7cfcad8ad1a5551227dcc9bfdb2e34b2097eaa00efbb51 +b97314dfff36d80c46b53d87a61b0e124dc94018a0bb680c32765b9a2d457f833a7c42bbc90b3b1520c33a182580398d +b17566ee3dcc6bb3b004afe4c0136dfe7dd27df9045ae896dca49fb36987501ae069eb745af81ba3fc19ff037e7b1406 +b0bdc0f55cfd98d331e3a0c4fbb776a131936c3c47c6bffdc3aaf7d8c9fa6803fbc122c2fefbb532e634228687d52174 +aa5d9e60cc9f0598559c28bb9bdd52aa46605ab4ffe3d192ba982398e72cec9a2a44c0d0d938ce69935693cabc0887ea +802b6459d2354fa1d56c592ac1346c428dadea6b6c0a87bf7d309bab55c94e1cf31dd98a7a86bd92a840dd51f218b91b +a526914efdc190381bf1a73dd33f392ecf01350b9d3f4ae96b1b1c3d1d064721c7d6eec5788162c933245a3943f5ee51 +b3b8fcf637d8d6628620a1a99dbe619eabb3e5c7ce930d6efd2197e261bf394b74d4e5c26b96c4b8009c7e523ccfd082 +8f7510c732502a93e095aba744535f3928f893f188adc5b16008385fb9e80f695d0435bfc5b91cdad4537e87e9d2551c +97b90beaa56aa936c3ca45698f79273a68dd3ccd0076eab48d2a4db01782665e63f33c25751c1f2e070f4d1a8525bf96 +b9fb798324b1d1283fdc3e48288e3861a5449b2ab5e884b34ebb8f740225324af86e4711da6b5cc8361c1db15466602f +b6d52b53cea98f1d1d4c9a759c25bf9d8a50b604b144e4912acbdbdc32aab8b9dbb10d64a29aa33a4f502121a6fb481c +9174ffff0f2930fc228f0e539f5cfd82c9368d26b074467f39c07a774367ff6cccb5039ac63f107677d77706cd431680 +a33b6250d4ac9e66ec51c063d1a6a31f253eb29bbaed12a0d67e2eccfffb0f3a52750fbf52a1c2aaba8c7692346426e7 +a97025fd5cbcebe8ef865afc39cd3ea707b89d4e765ec817fd021d6438e02fa51e3544b1fd45470c58007a08efac6edd +b32a78480edd9ff6ba2f1eec4088db5d6ceb2d62d7e59e904ecaef7bb4a2e983a4588e51692b3be76e6ffbc0b5f911a5 +b5ab590ef0bb77191f00495b33d11c53c65a819f7d0c1f9dc4a2caa147a69c77a4fff7366a602d743ee1f395ce934c1e +b3fb0842f9441fb1d0ee0293b6efbc70a8f58d12d6f769b12872db726b19e16f0f65efbc891cf27a28a248b0ef9c7e75 +9372ad12856fefb928ccb0d34e198df99e2f8973b07e9d417a3134d5f69e12e79ff572c4e03ccd65415d70639bc7c73e +aa8d6e83d09ce216bfe2009a6b07d0110d98cf305364d5529c170a23e693aabb768b2016befb5ada8dabdd92b4d012bb +a954a75791eeb0ce41c85200c3763a508ed8214b5945a42c79bfdcfb1ec4f86ad1dd7b2862474a368d4ac31911a2b718 +8e2081cfd1d062fe3ab4dab01f68062bac802795545fede9a188f6c9f802cb5f884e60dbe866710baadbf55dc77c11a4 +a2f06003b9713e7dd5929501ed485436b49d43de80ea5b15170763fd6346badf8da6de8261828913ee0dacd8ff23c0e1 +98eecc34b838e6ffd1931ca65eec27bcdb2fdcb61f33e7e5673a93028c5865e0d1bf6d3bec040c5e96f9bd08089a53a4 +88cc16019741b341060b95498747db4377100d2a5bf0a5f516f7dec71b62bcb6e779de2c269c946d39040e03b3ae12b7 +ad1135ccbc3019d5b2faf59a688eef2500697642be8cfbdf211a1ab59abcc1f24483e50d653b55ff1834675ac7b4978f +a946f05ed9972f71dfde0020bbb086020fa35b482cce8a4cc36dd94355b2d10497d7f2580541bb3e81b71ac8bba3c49f +a83aeed488f9a19d8cfd743aa9aa1982ab3723560b1cd337fc2f91ad82f07afa412b3993afb845f68d47e91ba4869840 +95eebe006bfc316810cb71da919e5d62c2cebb4ac99d8e8ef67be420302320465f8b69873470982de13a7c2e23516be9 +a55f8961295a11e91d1e5deadc0c06c15dacbfc67f04ccba1d069cba89d72aa3b3d64045579c3ea8991b150ac29366ae +b321991d12f6ac07a5de3c492841d1a27b0d3446082fbce93e7e1f9e8d8fe3b45d41253556261c21b70f5e189e1a7a6f +a0b0822f15f652ce7962a4f130104b97bf9529797c13d6bd8e24701c213cc37f18157bd07f3d0f3eae6b7cd1cb40401f +96e2fa4da378aa782cc2d5e6e465fc9e49b5c805ed01d560e9b98abb5c0de8b74a2e7bec3aa5e2887d25cccb12c66f0c +97e4ab610d414f9210ed6f35300285eb3ccff5b0b6a95ed33425100d7725e159708ea78704497624ca0a2dcabce3a2f9 +960a375b17bdb325761e01e88a3ea57026b2393e1d887b34b8fa5d2532928079ce88dc9fd06a728b26d2bb41b12b9032 +8328a1647398e832aadc05bd717487a2b6fcdaa0d4850d2c4da230c6a2ed44c3e78ec4837b6094f3813f1ee99414713f +aa283834ebd18e6c99229ce4b401eda83f01d904f250fedd4e24f1006f8fa0712a6a89a7296a9bf2ce8de30e28d1408e +b29e097f2caadae3e0f0ae3473c072b0cd0206cf6d2e9b22c1a5ad3e07d433e32bd09ed1f4e4276a2da4268633357b7f +9539c5cbba14538b2fe077ecf67694ef240da5249950baaabea0340718b882a966f66d97f08556b08a4320ceb2cc2629 +b4529f25e9b42ae8cf8338d2eface6ba5cd4b4d8da73af502d081388135c654c0b3afb3aa779ffc80b8c4c8f4425dd2b +95be0739c4330619fbe7ee2249c133c91d6c07eab846c18c5d6c85fc21ac5528c5d56dcb0145af68ed0c6a79f68f2ccd +ac0c83ea802227bfc23814a24655c9ff13f729619bcffdb487ccbbf029b8eaee709f8bddb98232ef33cd70e30e45ca47 +b503becb90acc93b1901e939059f93e671900ca52c6f64ae701d11ac891d3a050b505d89324ce267bc43ab8275da6ffe +98e3811b55b1bacb70aa409100abb1b870f67e6d059475d9f278c751b6e1e2e2d6f2e586c81a9fb6597fda06e7923274 +b0b0f61a44053fa6c715dbb0731e35d48dba257d134f851ee1b81fd49a5c51a90ebf5459ec6e489fce25da4f184fbdb1 +b1d2117fe811720bb997c7c93fe9e4260dc50fca8881b245b5e34f724aaf37ed970cdad4e8fcb68e05ac8cf55a274a53 +a10f502051968f14b02895393271776dee7a06db9de14effa0b3471825ba94c3f805302bdddac4d397d08456f620999d +a3dbad2ef060ae0bb7b02eaa4a13594f3f900450faa1854fc09620b01ac94ab896321dfb1157cf2374c27e5718e8026a +b550fdec503195ecb9e079dcdf0cad559d64d3c30818ef369b4907e813e689da316a74ad2422e391b4a8c2a2bef25fc0 +a25ba865e2ac8f28186cea497294c8649a201732ecb4620c4e77b8e887403119910423df061117e5f03fc5ba39042db1 +b3f88174e03fdb443dd6addd01303cf88a4369352520187c739fc5ae6b22fa99629c63c985b4383219dab6acc5f6f532 +97a7503248e31e81b10eb621ba8f5210c537ad11b539c96dfb7cf72b846c7fe81bd7532c5136095652a9618000b7f8d3 +a8bcdc1ce5aa8bfa683a2fc65c1e79de8ff5446695dcb8620f7350c26d2972a23da22889f9e2b1cacb3f688c6a2953dc +8458c111df2a37f5dd91a9bee6c6f4b79f4f161c93fe78075b24a35f9817da8dde71763218d627917a9f1f0c4709c1ed +ac5f061a0541152b876cbc10640f26f1cc923c9d4ae1b6621e4bb3bf2cec59bbf87363a4eb72fb0e5b6d4e1c269b52d5 +a9a25ca87006e8a9203cbb78a93f50a36694aa4aad468b8d80d3feff9194455ca559fcc63838128a0ab75ad78c07c13a +a450b85f5dfffa8b34dfd8bc985f921318efacf8857cf7948f93884ba09fb831482ee90a44224b1a41e859e19b74962f +8ed91e7f92f5c6d7a71708b6132f157ac226ecaf8662af7d7468a4fa25627302efe31e4620ad28719318923e3a59bf82 +ab524165fd4c71b1fd395467a14272bd2b568592deafa039d8492e9ef36c6d3f96927c95c72d410a768dc0b6d1fbbc9b +b662144505aa8432c75ffb8d10318526b6d5777ac7af9ebfad87d9b0866c364f7905a6352743bd8fd79ffd9d5dd4f3e6 +a48f1677550a5cd40663bb3ba8f84caaf8454f332d0ceb1d94dbea52d0412fe69c94997f7749929712fd3995298572f7 +8391cd6e2f6b0c242de1117a612be99776c3dc95cb800b187685ea5bf7e2722275eddb79fd7dfc8be8e389c4524cdf70 +875d3acb9af47833b72900bc0a2448999d638f153c5e97e8a14ec02d0c76f6264353a7e275e1f1a5855daced523d243b +91f1823657d30b59b2f627880a9a9cb530f5aca28a9fd217fe6f2f5133690dfe7ad5a897872e400512db2e788b3f7628 +ad3564332aa56cea84123fc7ca79ea70bb4fef2009fa131cb44e4b15e8613bd11ca1d83b9d9bf456e4b7fee9f2e8b017 +8c530b84001936d5ab366c84c0b105241a26d1fb163669f17c8f2e94776895c2870edf3e1bc8ccd04d5e65531471f695 +932d01fa174fdb0c366f1230cffde2571cc47485f37f23ba5a1825532190cc3b722aeb1f15aed62cf83ccae9403ba713 +88b28c20585aca50d10752e84b901b5c2d58efef5131479fbbe53de7bce2029e1423a494c0298e1497669bd55be97a5d +b914148ca717721144ebb3d3bf3fcea2cd44c30c5f7051b89d8001502f3856fef30ec167174d5b76265b55d70f8716b5 +81d0173821c6ddd2a068d70766d9103d1ee961c475156e0cbd67d54e668a796310474ef698c7ab55abe6f2cf76c14679 +8f28e8d78e2fe7fa66340c53718e0db4b84823c8cfb159c76eac032a62fb53da0a5d7e24ca656cf9d2a890cb2a216542 +8a26360335c73d1ab51cec3166c3cf23b9ea51e44a0ad631b0b0329ef55aaae555420348a544e18d5760969281759b61 +94f326a32ed287545b0515be9e08149eb0a565025074796d72387cc3a237e87979776410d78339e23ef3172ca43b2544 +a785d2961a2fa5e70bffa137858a92c48fe749fee91b02599a252b0cd50d311991a08efd7fa5e96b78d07e6e66ffe746 +94af9030b5ac792dd1ce517eaadcec1482206848bea4e09e55cc7f40fd64d4c2b3e9197027c5636b70d6122c51d2235d +9722869f7d1a3992850fe7be405ec93aa17dc4d35e9e257d2e469f46d2c5a59dbd504056c85ab83d541ad8c13e8bcd54 +b13c4088b61a06e2c03ac9813a75ff1f68ffdfee9df6a8f65095179a475e29cc49119cad2ce05862c3b1ac217f3aace9 +8c64d51774753623666b10ca1b0fe63ae42f82ed6aa26b81dc1d48c86937c5772eb1402624c52a154b86031854e1fb9f +b47e4df18002b7dac3fee945bf9c0503159e1b8aafcce2138818e140753011b6d09ef1b20894e08ba3006b093559061b +93cb5970076522c5a0483693f6a35ffd4ea2aa7aaf3730c4eccd6af6d1bebfc1122fc4c67d53898ae13eb6db647be7e2 +a68873ef80986795ea5ed1a597d1cd99ed978ec25e0abb57fdcc96e89ef0f50aeb779ff46e3dce21dc83ada3157a8498 +8cab67f50949cc8eee6710e27358aea373aae3c92849f8f0b5531c080a6300cdf2c2094fe6fecfef6148de0d28446919 +993e932bcb616dbaa7ad18a4439e0565211d31071ef1b85a0627db74a05d978c60d507695eaeea5c7bd9868a21d06923 +acdadff26e3132d9478a818ef770e9fa0d2b56c6f5f48bd3bd674436ccce9bdfc34db884a73a30c04c5f5e9764cb2218 +a0d3e64c9c71f84c0eef9d7a9cb4fa184224b969db5514d678e93e00f98b41595588ca802643ea225512a4a272f5f534 +91c9140c9e1ba6e330cb08f6b2ce4809cd0d5a0f0516f70032bf30e912b0ed684d07b413b326ab531ee7e5b4668c799b +87bc2ee7a0c21ba8334cd098e35cb703f9af57f35e091b8151b9b63c3a5b0f89bd7701dbd44f644ea475901fa6d9ef08 +9325ccbf64bf5d71b303e31ee85d486298f9802c5e55b2c3d75427097bf8f60fa2ab4fcaffa9b60bf922c3e24fbd4b19 +95d0506e898318f3dc8d28d16dfd9f0038b54798838b3c9be2a2ae3c2bf204eb496166353fc042220b0bd4f6673b9285 +811de529416331fe9c416726d45df9434c29dcd7e949045eb15740f47e97dde8f31489242200e19922cac2a8b7c6fd1f +ade632d04a4c8bbab6ca7df370b2213cb9225023e7973f0e29f4f5e52e8aeaabc65171306bbdd12a67b195dfbb96d48f +88b7f029e079b6ae956042c0ea75d53088c5d0efd750dd018adaeacf46be21bf990897c58578c491f41afd3978d08073 +91f477802de507ffd2be3f4319903119225b277ad24f74eb50f28b66c14d32fae53c7edb8c7590704741af7f7f3e3654 +809838b32bb4f4d0237e98108320d4b079ee16ed80c567e7548bd37e4d7915b1192880f4812ac0e00476d246aec1dbc8 +84183b5fc4a7997a8ae5afedb4d21dce69c480d5966b5cbdafd6dd10d29a9a6377f3b90ce44da0eb8b176ac3af0253bb +8508abbf6d3739a16b9165caf0f95afb3b3ac1b8c38d6d374cf0c91296e2c1809a99772492b539cda184510bce8a0271 +8722054e59bab2062e6419a6e45fc803af77fde912ef2cd23055ad0484963de65a816a2debe1693d93c18218d2b8e81a +8e895f80e485a7c4f56827bf53d34b956281cdc74856c21eb3b51f6288c01cc3d08565a11cc6f3e2604775885490e8c5 +afc92714771b7aa6e60f3aee12efd9c2595e9659797452f0c1e99519f67c8bc3ac567119c1ddfe82a3e961ee9defea9a +818ff0fd9cefd32db87b259e5fa32967201016fc02ef44116cdca3c63ce5e637756f60477a408709928444a8ad69c471 +8251e29af4c61ae806fc5d032347fb332a94d472038149225298389495139ce5678fae739d02dfe53a231598a992e728 +a0ea39574b26643f6f1f48f99f276a8a64b5481989cfb2936f9432a3f8ef5075abfe5c067dc5512143ce8bf933984097 +af67a73911b372bf04e57e21f289fc6c3dfac366c6a01409b6e76fea4769bdb07a6940e52e8d7d3078f235c6d2f632c6 +b5291484ef336024dd2b9b4cf4d3a6b751133a40656d0a0825bcc6d41c21b1c79cb50b0e8f4693f90c29c8f4358641f9 +8bc0d9754d70f2cb9c63f991902165a87c6535a763d5eece43143b5064ae0bcdce7c7a8f398f2c1c29167b2d5a3e6867 +8d7faff53579ec8f6c92f661c399614cc35276971752ce0623270f88be937c414eddcb0997e14724a783905a026c8883 +9310b5f6e675fdf60796f814dbaa5a6e7e9029a61c395761e330d9348a7efab992e4e115c8be3a43d08e90d21290c892 +b5eb4f3eb646038ad2a020f0a42202532d4932e766da82b2c1002bf9c9c2e5336b54c8c0ffcc0e02d19dde2e6a35b6cc +91dabfd30a66710f1f37a891136c9be1e23af4abf8cb751f512a40c022a35f8e0a4fb05b17ec36d4208de02d56f0d53a +b3ded14e82d62ac7a5a036122a62f00ff8308498f3feae57d861babaff5a6628d43f0a0c5fc903f10936bcf4e2758ceb +a88e8348fed2b26acca6784d19ef27c75963450d99651d11a950ea81d4b93acd2c43e0ecce100eaf7e78508263d5baf3 +b1f5bbf7c4756877b87bb42163ac570e08c6667c4528bf68b5976680e19beeff7c5effd17009b0718797077e2955457a +ad2e7b516243f915d4d1415326e98b1a7390ae88897d0b03b66c2d9bd8c3fba283d7e8fe44ed3333296a736454cef6d8 +8f82eae096d5b11f995de6724a9af895f5e1c58d593845ad16ce8fcae8507e0d8e2b2348a0f50a1f66a17fd6fac51a5c +890e4404d0657c6c1ee14e1aac132ecf7a568bb3e04137b85ac0f84f1d333bd94993e8750f88eee033a33fb00f85dcc7 +82ac7d3385e035115f1d39a99fc73e5919de44f5e6424579776d118d711c8120b8e5916372c6f27bed4cc64cac170b6c +85ee16d8901c272cfbbe966e724b7a891c1bd5e68efd5d863043ad8520fc409080af61fd726adc680b3f1186fe0ac8b8 +86dc564c9b545567483b43a38f24c41c6551a49cabeebb58ce86404662a12dbfafd0778d30d26e1c93ce222e547e3898 +a29f5b4522db26d88f5f95f18d459f8feefab02e380c2edb65aa0617a82a3c1a89474727a951cef5f15050bcf7b380fb +a1ce039c8f6cac53352899edb0e3a72c76da143564ad1a44858bd7ee88552e2fe6858d1593bbd74aeee5a6f8034b9b9d +97f10d77983f088286bd7ef3e7fdd8fa275a56bec19919adf33cf939a90c8f2967d2b1b6fc51195cb45ad561202a3ed7 +a25e2772e8c911aaf8712bdac1dd40ee061c84d3d224c466cfaae8e5c99604053f940cde259bd1c3b8b69595781dbfec +b31bb95a0388595149409c48781174c340960d59032ab2b47689911d03c68f77a2273576fbe0c2bf4553e330656058c7 +b8b2e9287ad803fb185a13f0d7456b397d4e3c8ad5078f57f49e8beb2e85f661356a3392dbd7bcf6a900baa5582b86a1 +a3d0893923455eb6e96cc414341cac33d2dbc88fba821ac672708cce131761d85a0e08286663a32828244febfcae6451 +82310cb42f647d99a136014a9f881eb0b9791efd2e01fc1841907ad3fc8a9654d3d1dab6689c3607214b4dc2aca01cee +874022d99c16f60c22de1b094532a0bc6d4de700ad01a31798fac1d5088b9a42ad02bef8a7339af7ed9c0d4f16b186ee +94981369e120265aed40910eebc37eded481e90f4596b8d57c3bec790ab7f929784bd33ddd05b7870aad6c02e869603b +a4f1f50e1e2a73f07095e0dd31cb45154f24968dae967e38962341c1241bcd473102fff1ff668b20c6547e9732d11701 +ae2328f3b0ad79fcda807e69a1b5278145225083f150f67511dafc97e079f860c3392675f1752ae7e864c056e592205b +875d8c971e593ca79552c43d55c8c73b17cd20c81ff2c2fed1eb19b1b91e4a3a83d32df150dbfd5db1092d0aebde1e1f +add2e80aa46aae95da73a11f130f4bda339db028e24c9b11e5316e75ba5e63bc991d2a1da172c7c8e8fee038baae3433 +b46dbe1cb3424002aa7de51e82f600852248e251465c440695d52538d3f36828ff46c90ed77fc1d11534fe3c487df8ef +a5e5045d28b4e83d0055863c30c056628c58d4657e6176fd0536f5933f723d60e851bb726d5bf3c546b8ce4ac4a57ef8 +91fec01e86dd1537e498fff7536ea3ca012058b145f29d9ada49370cd7b7193ac380e116989515df1b94b74a55c45df3 +a7428176d6918cd916a310bdc75483c72de660df48cac4e6e7478eef03205f1827ea55afc0df5d5fa7567d14bbea7fc9 +851d89bef45d9761fe5fdb62972209335193610015e16a675149519f9911373bac0919add226ef118d9f3669cfdf4734 +b74acf5c149d0042021cb2422ea022be4c4f72a77855f42393e71ffd12ebb3eec16bdf16f812159b67b79a9706e7156d +99f35dce64ec99aa595e7894b55ce7b5a435851b396e79036ffb249c28206087db4c85379df666c4d95857db02e21ff9 +b6b9a384f70db9e298415b8ab394ee625dafff04be2886476e59df8d052ca832d11ac68a9b93fba7ab055b7bc36948a4 +898ee4aefa923ffec9e79f2219c7389663eb11eb5b49014e04ed4a336399f6ea1691051d86991f4c46ca65bcd4fdf359 +b0f948217b0d65df7599a0ba4654a5e43c84db477936276e6f11c8981efc6eaf14c90d3650107ed4c09af4cc8ec11137 +aa6286e27ac54f73e63dbf6f41865dd94d24bc0cf732262fcaff67319d162bb43af909f6f8ee27b1971939cfbba08141 +8bca7cdf730cf56c7b2c8a2c4879d61361a6e1dba5a3681a1a16c17a56e168ace0e99cf0d15826a1f5e67e6b8a8a049a +a746d876e8b1ce225fcafca603b099b36504846961526589af977a88c60d31ba2cc56e66a3dec8a77b3f3531bf7524c9 +a11e2e1927e6704cdb8874c75e4f1842cef84d7d43d7a38e339e61dc8ba90e61bbb20dd3c12e0b11d2471d58eed245be +a36395e22bc1d1ba8b0459a235203177737397da5643ce54ded3459d0869ff6d8d89f50c73cb62394bf66a959cde9b90 +8b49f12ba2fdf9aca7e5f81d45c07d47f9302a2655610e7634d1e4bd16048381a45ef2c95a8dd5b0715e4b7cf42273af +91cffa2a17e64eb7f76bccbe4e87280ee1dd244e04a3c9eac12e15d2d04845d876eb24fe2ec6d6d266cce9efb281077f +a6b8afabf65f2dee01788114e33a2f3ce25376fb47a50b74da7c3c25ff1fdc8aa9f41307534abbf48acb6f7466068f69 +8d13db896ccfea403bd6441191995c1a65365cab7d0b97fbe9526da3f45a877bd1f4ef2edef160e8a56838cd1586330e +98c717de9e01bef8842c162a5e757fe8552d53269c84862f4d451e7c656ae6f2ae473767b04290b134773f63be6fdb9d +8c2036ace1920bd13cf018e82848c49eb511fad65fd0ff51f4e4b50cf3bfc294afb63cba682c16f52fb595a98fa84970 +a3520fdff05dbad9e12551b0896922e375f9e5589368bcb2cc303bde252743b74460cb5caf99629325d3620f13adc796 +8d4f83a5bfec05caf5910e0ce538ee9816ee18d0bd44c1d0da2a87715a23cd2733ad4d47552c6dc0eb397687d611dd19 +a7b39a0a6a02823452d376533f39d35029867b3c9a6ad6bca181f18c54132d675613a700f9db2440fb1b4fa13c8bf18a +80bcb114b2544b80f404a200fc36860ed5e1ad31fe551acd4661d09730c452831751baa9b19d7d311600d267086a70bc +90dcce03c6f88fc2b08f2b42771eedde90cc5330fe0336e46c1a7d1b5a6c1641e5fcc4e7b3d5db00bd8afca9ec66ed81 +aec15f40805065c98e2965b1ae12a6c9020cfdb094c2d0549acfc7ea2401a5fb48d3ea7d41133cf37c4e096e7ff53eb9 +80e129b735dba49fa627a615d6c273119acec8e219b2f2c4373a332b5f98d66cbbdd688dfbe72a8f8bfefaccc02c50c1 +a9b596da3bdfe23e6799ece5f7975bf7a1979a75f4f546deeaf8b34dfe3e0d623217cb4cf4ccd504cfa3625b88cd53f1 +abcbbb70b16f6e517c0ab4363ab76b46e4ff58576b5f8340e5c0e8cc0e02621b6e23d742d73b015822a238b17cfd7665 +a046937cc6ea6a2e1adae543353a9fe929c1ae4ad655be1cc051378482cf88b041e28b1e9a577e6ccff2d3570f55e200 +831279437282f315e65a60184ef158f0a3dddc15a648dc552bdc88b3e6fe8288d3cfe9f0031846d81350f5e7874b4b33 +993d7916fa213c6d66e7c4cafafc1eaec9a2a86981f91c31eb8a69c5df076c789cbf498a24c84e0ee77af95b42145026 +823907a3b6719f8d49b3a4b7c181bd9bb29fcf842d7c70660c4f351852a1e197ca46cf5e879b47fa55f616fa2b87ce5e +8d228244e26132b234930ee14c75d88df0943cdb9c276a8faf167d259b7efc1beec2a87c112a6c608ad1600a239e9aae +ab6e55766e5bfb0cf0764ed909a8473ab5047d3388b4f46faeba2d1425c4754c55c6daf6ad4751e634c618b53e549529 +ab0cab6860e55a84c5ad2948a7e0989e2b4b1fd637605634b118361497332df32d9549cb854b2327ca54f2bcb85eed8f +b086b349ae03ef34f4b25a57bcaa5d1b29bd94f9ebf87e22be475adfe475c51a1230c1ebe13506cb72c4186192451658 +8a0b49d8a254ca6d91500f449cbbfbb69bb516c6948ac06808c65595e46773e346f97a5ce0ef7e5a5e0de278af22709c +ac49de11edaaf04302c73c578cc0824bdd165c0d6321be1c421c1950e68e4f3589aa3995448c9699e93c6ebae8803e27 +884f02d841cb5d8f4c60d1402469216b114ab4e93550b5bc1431756e365c4f870a9853449285384a6fa49e12ce6dc654 +b75f3a28fa2cc8d36b49130cb7448a23d73a7311d0185ba803ad55c8219741d451c110f48b786e96c728bc525903a54f +80ae04dbd41f4a35e33f9de413b6ad518af0919e5a30cb0fa1b061b260420780bb674f828d37fd3b52b5a31673cbd803 +b9a8011eb5fcea766907029bf743b45262db3e49d24f84503687e838651ed11cb64c66281e20a0ae9f6aa51acc552263 +90bfdd75e2dc9cf013e22a5d55d2d2b8a754c96103a17524488e01206e67f8b6d52b1be8c4e3d5307d4fe06d0e51f54c +b4af353a19b06203a815ec43e79a88578cc678c46f5a954b85bc5c53b84059dddba731f3d463c23bfd5273885c7c56a4 +aa125e96d4553b64f7140e5453ff5d2330318b69d74d37d283e84c26ad672fa00e3f71e530eb7e28be1e94afb9c4612e +a18e060aee3d49cde2389b10888696436bb7949a79ca7d728be6456a356ea5541b55492b2138da90108bd1ce0e6f5524 +93e55f92bdbccc2de655d14b1526836ea2e52dba65eb3f87823dd458a4cb5079bf22ce6ef625cb6d6bfdd0995ab9a874 +89f5a683526b90c1c3ceebbb8dc824b21cff851ce3531b164f6626e326d98b27d3e1d50982e507d84a99b1e04e86a915 +83d1c38800361633a3f742b1cb2bfc528129496e80232611682ddbe403e92c2ac5373aea0bca93ecb5128b0b2b7a719e +8ecba560ac94905e19ce8d9c7af217bf0a145d8c8bd38e2db82f5e94cc3f2f26f55819176376b51f154b4aab22056059 +a7e2a4a002b60291924850642e703232994acb4cfb90f07c94d1e0ecd2257bb583443283c20fc6017c37e6bfe85b7366 +93ed7316fa50b528f1636fc6507683a672f4f4403e55e94663f91221cc198199595bd02eef43d609f451acc9d9b36a24 +a1220a8ebc5c50ceed76a74bc3b7e0aa77f6884c71b64b67c4310ac29ce5526cb8992d6abc13ef6c8413ce62486a6795 +b2f6eac5c869ad7f4a25161d3347093e2f70e66cd925032747e901189355022fab3038bca4d610d2f68feb7e719c110b +b703fa11a4d511ca01c7462979a94acb40b5d933759199af42670eb48f83df202fa0c943f6ab3b4e1cc54673ea3aab1e +b5422912afbfcb901f84791b04f1ddb3c3fbdc76d961ee2a00c5c320e06d3cc5b5909c3bb805df66c5f10c47a292b13d +ad0934368da823302e1ac08e3ede74b05dfdbfffca203e97ffb0282c226814b65c142e6e15ec1e754518f221f01b30f7 +a1dd302a02e37df15bf2f1147efe0e3c06933a5a767d2d030e1132f5c3ce6b98e216b6145eb39e1e2f74e76a83165b8d +a346aab07564432f802ae44738049a36f7ca4056df2d8f110dbe7fef4a3e047684dea609b2d03dc6bf917c9c2a47608f +b96c5f682a5f5d02123568e50f5d0d186e4b2c4c9b956ec7aabac1b3e4a766d78d19bd111adb5176b898e916e49be2aa +8a96676d56876fc85538db2e806e1cba20fd01aeb9fa3cb43ca6ca94a2c102639f65660db330e5d74a029bb72d6a0b39 +ab0048336bd5c3def1a4064eadd49e66480c1f2abb4df46e03afbd8a3342c2c9d74ee35d79f08f4768c1646681440984 +888427bdf76caec90814c57ee1c3210a97d107dd88f7256f14f883ad0f392334b82be11e36dd8bfec2b37935177c7831 +b622b282becf0094a1916fa658429a5292ba30fb48a4c8066ce1ddcefb71037948262a01c95bab6929ed3a76ba5db9fe +b5b9e005c1f456b6a368a3097634fb455723abe95433a186e8278dceb79d4ca2fbe21f8002e80027b3c531e5bf494629 +a3c6707117a1e48697ed41062897f55d8119403eea6c2ee88f60180f6526f45172664bfee96bf61d6ec0b7fbae6aa058 +b02a9567386a4fbbdb772d8a27057b0be210447348efe6feb935ceec81f361ed2c0c211e54787dc617cdffed6b4a6652 +a9b8364e40ef15c3b5902e5534998997b8493064fa2bea99600def58279bb0f64574c09ba11e9f6f669a8354dd79dc85 +9998a2e553a9aa9a206518fae2bc8b90329ee59ab23005b10972712389f2ec0ee746033c733092ffe43d73d33abbb8ef +843a4b34d9039bf79df96d79f2d15e8d755affb4d83d61872daf540b68c0a3888cf8fc00d5b8b247b38524bcb3b5a856 +84f7128920c1b0bb40eee95701d30e6fc3a83b7bb3709f16d97e72acbb6057004ee7ac8e8f575936ca9dcb7866ab45f7 +918d3e2222e10e05edb34728162a899ad5ada0aaa491aeb7c81572a9c0d506e31d5390e1803a91ff3bd8e2bb15d47f31 +9442d18e2489613a7d47bb1cb803c8d6f3259d088cd079460976d87f7905ee07dea8f371b2537f6e1d792d36d7e42723 +b491976970fe091995b2ed86d629126523ccf3e9daf8145302faca71b5a71a5da92e0e05b62d7139d3efac5c4e367584 +aa628006235dc77c14cef4c04a308d66b07ac92d377df3de1a2e6ecfe3144f2219ad6d7795e671e1cb37a3641910b940 +99d386adaea5d4981d7306feecac9a555b74ffdc218c907c5aa7ac04abaead0ec2a8237300d42a3fbc464673e417ceed +8f78e8b1556f9d739648ea3cab9606f8328b52877fe72f9305545a73b74d49884044ba9c1f1c6db7d9b7c7b7c661caba +8fb357ae49932d0babdf74fc7aa7464a65d3b6a2b3acf4f550b99601d3c0215900cfd67f2b6651ef94cfc323bac79fae +9906f2fa25c0290775aa001fb6198113d53804262454ae8b83ef371b5271bde189c0460a645829cb6c59f9ee3a55ce4d +8f4379b3ebb50e052325b27655ca6a82e6f00b87bf0d2b680d205dd2c7afdc9ff32a9047ae71a1cdf0d0ce6b9474d878 +a85534e88c2bd43c043792eaa75e50914b21741a566635e0e107ae857aed0412035f7576cf04488ade16fd3f35fdbb87 +b4ce93199966d3c23251ca7f28ec5af7efea1763d376b0385352ffb2e0a462ef95c69940950278cf0e3dafd638b7bd36 +b10cb3d0317dd570aa73129f4acf63c256816f007607c19b423fb42f65133ce21f2f517e0afb41a5378cccf893ae14d0 +a9b231c9f739f7f914e5d943ed9bff7eba9e2c333fbd7c34eb1648a362ee01a01af6e2f7c35c9fe962b11152cddf35de +99ff6a899e156732937fb81c0cced80ae13d2d44c40ba99ac183aa246103b31ec084594b1b7feb96da58f4be2dd5c0ed +8748d15d18b75ff2596f50d6a9c4ce82f61ecbcee123a6ceae0e43cab3012a29b6f83cf67b48c22f6f9d757c6caf76b2 +b88ab05e4248b7fb634cf640a4e6a945d13e331237410f7217d3d17e3e384ddd48897e7a91e4516f1b9cbd30f35f238b +8d826deaeeb84a3b2d2c04c2300ca592501f992810582d6ae993e0d52f6283a839dba66c6c72278cff5871802b71173b +b36fed027c2f05a5ef625ca00b0364b930901e9e4420975b111858d0941f60e205546474bb25d6bfa6928d37305ae95f +af2fcfc6b87967567e8b8a13a4ed914478185705724e56ce68fb2df6d1576a0cf34a61e880997a0d35dc2c3276ff7501 +ac351b919cd1fbf106feb8af2c67692bfcddc84762d18cea681cfa7470a5644839caace27efee5f38c87d3df306f4211 +8d6665fb1d4d8d1fa23bd9b8a86e043b8555663519caac214d1e3e3effbc6bee7f2bcf21e645f77de0ced279d69a8a8b +a9fc1c2061756b2a1a169c1b149f212ff7f0d2488acd1c5a0197eba793cffa593fc6d1d1b40718aa75ca3ec77eff10e1 +aff64f0fa009c7a6cf0b8d7a22ddb2c8170c3cb3eec082e60d5aadb00b0040443be8936d728d99581e33c22178c41c87 +82e0b181adc5e3b1c87ff8598447260e839d53debfae941ebea38265575546c3a74a14b4325a030833a62ff6c52d9365 +b7ad43cbb22f6f892c2a1548a41dc120ab1f4e1b8dea0cb6272dd9cb02054c542ecabc582f7e16de709d48f5166cae86 +985e0c61094281532c4afb788ecb2dfcba998e974b5d4257a22040a161883908cdd068fe80f8eb49b8953cfd11acf43a +ae46895c6d67ea6d469b6c9c07b9e5d295d9ae73b22e30da4ba2c973ba83a130d7eef39717ec9d0f36e81d56bf742671 +8600177ea1f7e7ef90514b38b219a37dedfc39cb83297e4c7a5b479817ef56479d48cf6314820960c751183f6edf8b0e +b9208ec1c1d7a1e99b59c62d3e4e61dfb706b0e940d09d3abfc3454c19749083260614d89cfd7e822596c3cdbcc6bb95 +a1e94042c796c2b48bc724352d2e9f3a22291d9a34705993357ddb6adabd76da6fc25dac200a8cb0b5bbd99ecddb7af6 +b29c3adedd0bcad8a930625bc4dfdc3552a9afd5ca6dd9c0d758f978068c7982b50b711aa0eb5b97f2b84ee784637835 +af0632a238bb1f413c7ea8e9b4c3d68f2827bd2e38cd56024391fba6446ac5d19a780d0cfd4a78fe497d537b766a591a +aaf6e7f7d54f8ef5e2e45dd59774ecbeecf8683aa70483b2a75be6a6071b5981bbaf1627512a65d212817acdfab2e428 +8c751496065da2e927cf492aa5ca9013b24f861d5e6c24b30bbf52ec5aaf1905f40f9a28175faef283dd4ed4f2182a09 +8952377d8e80a85cf67d6b45499f3bad5fd452ea7bcd99efc1b066c4720d8e5bff1214cea90fd1f972a7f0baac3d29be +a1946ee543d1a6e21f380453be4d446e4130950c5fc3d075794eb8260f6f52d0a795c1ff91d028a648dc1ce7d9ab6b47 +89f3fefe37af31e0c17533d2ca1ce0884cc1dc97c15cbfab9c331b8debd94781c9396abef4bb2f163d09277a08d6adf0 +a2753f1e6e1a154fb117100a5bd9052137add85961f8158830ac20541ab12227d83887d10acf7fd36dcaf7c2596d8d23 +814955b4198933ee11c3883863b06ff98c7eceb21fc3e09df5f916107827ccf3323141983e74b025f46ae00284c9513b +8cc5c6bb429073bfef47cae7b3bfccb0ffa076514d91a1862c6bda4d581e0df87db53cc6c130bf8a7826304960f5a34e +909f22c1f1cdc87f7be7439c831a73484a49acbf8f23d47087d7cf867c64ef61da3bde85dc57d705682b4c3fc710d36e +8048fee7f276fcd504aed91284f28e73693615e0eb3858fa44bcf79d7285a9001c373b3ef71d9a3054817ba293ebe28c +94400e5cf5d2700ca608c5fe35ce14623f71cc24959f2bc27ca3684092850f76b67fb1f07ca9e5b2ca3062cf8ad17bd4 +81c2ae7d4d1b17f8b6de6a0430acc0d58260993980fe48dc2129c4948269cdc74f9dbfbf9c26b19360823fd913083d48 +8c41fe765128e63f6889d6a979f6a4342300327c8b245a8cfe3ecfbcac1e09c3da30e2a1045b24b78efc6d6d50c8c6ac +a5dd4ae51ae48c8be4b218c312ade226cffce671cf121cb77810f6c0990768d6dd767badecb5c69921d5574d5e8433d3 +b7642e325f4ba97ae2a39c1c9d97b35aafd49d53dba36aed3f3cb0ca816480b3394079f46a48252d46596559c90f4d58 +ae87375b40f35519e7bd4b1b2f73cd0b329b0c2cb9d616629342a71c6c304338445eda069b78ea0fbe44087f3de91e09 +b08918cb6f736855e11d3daca1ddfbdd61c9589b203b5493143227bf48e2c77c2e8c94b0d1aa2fab2226e0eae83f2681 +ac36b84a4ac2ebd4d6591923a449c564e3be8a664c46092c09e875c2998eba16b5d32bfd0882fd3851762868e669f0b1 +a44800a3bb192066fa17a3f29029a23697240467053b5aa49b9839fb9b9b8b12bcdcbfc557f024b61f4f51a9aacdefcb +9064c688fec23441a274cdf2075e5a449caf5c7363cc5e8a5dc9747183d2e00a0c69f2e6b3f6a7057079c46014c93b3b +aa367b021469af9f5b764a79bb3afbe2d87fe1e51862221672d1a66f954b165778b7c27a705e0f93841fab4c8468344d +a1a8bfc593d4ab71f91640bc824de5c1380ab2591cfdafcbc78a14b32de3c0e15f9d1b461d85c504baa3d4232c16bb53 +97df48da1799430f528184d30b6baa90c2a2f88f34cdfb342d715339c5ebd6d019aa693cea7c4993daafc9849063a3aa +abd923831fbb427e06e0dd335253178a9e5791395c84d0ab1433c07c53c1209161097e9582fb8736f8a60bde62d8693e +84cd1a43f1a438b43dc60ffc775f646937c4f6871438163905a3cebf1115f814ccd38a6ccb134130bff226306e412f32 +91426065996b0743c5f689eb3ca68a9f7b9e4d01f6c5a2652b57fa9a03d8dc7cd4bdbdab0ca5a891fee1e97a7f00cf02 +a4bee50249db3df7fd75162b28f04e57c678ba142ce4d3def2bc17bcb29e4670284a45f218dad3969af466c62a903757 +83141ebcc94d4681404e8b67a12a46374fded6df92b506aff3490d875919631408b369823a08b271d006d5b93136f317 +a0ea1c8883d58d5a784da3d8c8a880061adea796d7505c1f903d07c287c5467f71e4563fc0faafbc15b5a5538b0a7559 +89d9d480574f201a87269d26fb114278ed2c446328df431dc3556e3500e80e4cd01fcac196a2459d8646361ebda840df +8bf302978973632dd464bec819bdb91304712a3ec859be071e662040620422c6e75eba6f864f764cffa2799272efec39 +922f666bc0fd58b6d7d815c0ae4f66d193d32fc8382c631037f59eeaeae9a8ca6c72d08e72944cf9e800b8d639094e77 +81ad8714f491cdff7fe4399f2eb20e32650cff2999dd45b9b3d996d54a4aba24cc6c451212e78c9e5550368a1a38fb3f +b58fcf4659d73edb73175bd9139d18254e94c3e32031b5d4b026f2ed37aa19dca17ec2eb54c14340231615277a9d347e +b365ac9c2bfe409b710928c646ea2fb15b28557e0f089d39878e365589b9d1c34baf5566d20bb28b33bb60fa133f6eff +8fcae1d75b53ab470be805f39630d204853ca1629a14158bac2f52632277d77458dec204ff84b7b2d77e641c2045be65 +a03efa6bebe84f4f958a56e2d76b5ba4f95dd9ed7eb479edc7cc5e646c8d4792e5b0dfc66cc86aa4b4afe2f7a4850760 +af1c823930a3638975fb0cc5c59651771b2719119c3cd08404fbd4ce77a74d708cefbe3c56ea08c48f5f10e6907f338f +8260c8299b17898032c761c325ac9cabb4c5b7e735de81eacf244f647a45fb385012f4f8df743128888c29aefcaaad16 +ab2f37a573c82e96a8d46198691cd694dfa860615625f477e41f91b879bc58a745784fccd8ffa13065834ffd150d881d +986c746c9b4249352d8e5c629e8d7d05e716b3c7aab5e529ca969dd1e984a14b5be41528baef4c85d2369a42d7209216 +b25e32da1a8adddf2a6080725818b75bc67240728ad1853d90738485d8924ea1e202df0a3034a60ffae6f965ec55cf63 +a266e627afcebcefea6b6b44cbc50f5c508f7187e87d047b0450871c2a030042c9e376f3ede0afcf9d1952f089582f71 +86c3bbca4c0300606071c0a80dbdec21ce1dd4d8d4309648151c420854032dff1241a1677d1cd5de4e4de4385efda986 +b9a21a1fe2d1f3273a8e4a9185abf2ff86448cc98bfa435e3d68306a2b8b4a6a3ea33a155be3cb62a2170a86f77679a5 +b117b1ea381adce87d8b342cba3a15d492ff2d644afa28f22424cb9cbc820d4f7693dfc1a4d1b3697046c300e1c9b4c8 +9004c425a2e68870d6c69b658c344e3aa3a86a8914ee08d72b2f95c2e2d8a4c7bb0c6e7e271460c0e637cec11117bf8e +86a18aa4783b9ebd9131580c8b17994825f27f4ac427b0929a1e0236907732a1c8139e98112c605488ee95f48bbefbfc +84042243b955286482ab6f0b5df4c2d73571ada00716d2f737ca05a0d2e88c6349e8ee9e67934cfee4a1775dbf7f4800 +92c2153a4733a62e4e1d5b60369f3c26777c7d01cd3c8679212660d572bd3bac9b8a8a64e1f10f7dbf5eaa7579c4e423 +918454b6bb8e44a2afa144695ba8d48ae08d0cdfef4ad078f67709eddf3bb31191e8b006f04e82ea45a54715ef4d5817 +acf0b54f6bf34cf6ed6c2b39cf43194a40d68de6bcf1e4b82c34c15a1343e9ac3737885e1a30b78d01fa3a5125463db8 +a7d60dbe4b6a7b054f7afe9ee5cbbfeca0d05dc619e6041fa2296b549322529faddb8a11e949562309aecefb842ac380 +91ffb53e6d7e5f11159eaf13e783d6dbdfdb1698ed1e6dbf3413c6ea23492bbb9e0932230a9e2caac8fe899a17682795 +b6e8d7be5076ee3565d5765a710c5ecf17921dd3cf555c375d01e958a365ae087d4a88da492a5fb81838b7b92bf01143 +a8c6b763de2d4b2ed42102ef64eccfef31e2fb2a8a2776241c82912fa50fc9f77f175b6d109a97ede331307c016a4b1a +99839f86cb700c297c58bc33e28d46b92931961548deac29ba8df91d3e11721b10ea956c8e16984f9e4acf1298a79b37 +8c2e2c338f25ea5c25756b7131cde0d9a2b35abf5d90781180a00fe4b8e64e62590dc63fe10a57fba3a31c76d784eb01 +9687d7df2f41319ca5469d91978fed0565a5f11f829ebadaa83db92b221755f76c6eacd7700735e75c91e257087512e3 +8795fdfb7ff8439c58b9bf58ed53873d2780d3939b902b9ddaaa4c99447224ced9206c3039a23c2c44bcc461e2bb637f +a803697b744d2d087f4e2307218d48fa88620cf25529db9ce71e2e3bbcc65bac5e8bb9be04777ef7bfb5ed1a5b8e6170 +80f3d3efbbb9346ddd413f0a8e36b269eb5d7ff6809d5525ff9a47c4bcab2c01b70018b117f6fe05253775612ff70c6b +9050e0e45bcc83930d4c505af35e5e4d7ca01cd8681cba92eb55821aececcebe32bb692ebe1a4daac4e7472975671067 +8d206812aac42742dbaf233e0c080b3d1b30943b54b60283515da005de05ea5caa90f91fedcfcba72e922f64d7040189 +a2d44faaeb2eff7915c83f32b13ca6f31a6847b1c1ce114ea240bac3595eded89f09b2313b7915ad882292e2b586d5b4 +961776c8576030c39f214ea6e0a3e8b3d32f023d2600958c098c95c8a4e374deeb2b9dc522adfbd6bda5949bdc09e2a2 +993fa7d8447407af0fbcd9e6d77f815fa5233ab00674efbcf74a1f51c37481445ae291cc7b76db7c178f9cb0e570e0fc +abd5b1c78e05f9d7c8cc99bdaef8b0b6a57f2daf0f02bf492bec48ea4a27a8f1e38b5854da96efff11973326ff980f92 +8f15af4764bc275e6ccb892b3a4362cacb4e175b1526a9a99944e692fe6ccb1b4fc19abf312bb2a089cb1f344d91a779 +a09b27ccd71855512aba1d0c30a79ffbe7f6707a55978f3ced50e674b511a79a446dbc6d7946add421ce111135a460af +94b2f98ce86a9271fbd4153e1fc37de48421fe3490fb3840c00f2d5a4d0ba8810c6a32880b002f6374b59e0a7952518b +8650ac644f93bbcb88a6a0f49fee2663297fd4bc6fd47b6a89b9d8038d32370438ab3a4775ec9b58cb10aea8a95ef7b6 +95e5c2f2e84eed88c6980bbba5a1c0bb375d5a628bff006f7516d45bb7d723da676add4fdd45956f312e7bab0f052644 +b3278a3fa377ac93af7cfc9453f8cb594aae04269bbc99d2e0e45472ff4b6a2f97a26c4c57bf675b9d86f5e77a5d55d1 +b4bcbe6eb666a206e2ea2f877912c1d3b5bdbd08a989fc4490eb06013e1a69ad1ba08bcdac048bf29192312be399077b +a76d70b78c99fffcbf9bb9886eab40f1ea4f99a309710b660b64cbf86057cbcb644d243f6e341711bb7ef0fedf0435a7 +b2093c1ee945dca7ac76ad5aed08eae23af31dd5a77c903fd7b6f051f4ab84425d33a03c3d45bf2907bc93c02d1f3ad8 +904b1f7534e053a265b22d20be859912b9c9ccb303af9a8d6f1d8f6ccdc5c53eb4a45a1762b880d8444d9be0cd55e7f9 +8f664a965d65bc730c9ef1ec7467be984d4b8eb46bd9b0d64e38e48f94e6e55dda19aeac82cbcf4e1473440e64c4ca18 +8bcee65c4cc7a7799353d07b114c718a2aae0cd10a3f22b7eead5185d159dafd64852cb63924bf87627d176228878bce +8c78f2e3675096fef7ebaa898d2615cd50d39ca3d8f02b9bdfb07e67da648ae4be3da64838dffc5935fd72962c4b96c7 +8c40afd3701629421fec1df1aac4e849384ef2e80472c0e28d36cb1327acdf2826f99b357f3d7afdbc58a6347fc40b3c +a197813b1c65a8ea5754ef782522a57d63433ef752215ecda1e7da76b0412ee619f58d904abd2e07e0c097048b6ae1dd +a670542629e4333884ad7410f9ea3bd6f988df4a8f8a424ca74b9add2312586900cf9ae8bd50411f9146e82626b4af56 +a19875cc07ab84e569d98b8b67fb1dbbdfb59093c7b748fae008c8904a6fd931a63ca8d03ab5fea9bc8d263568125a9b +b57e7f68e4eb1bd04aafa917b1db1bdab759a02aa8a9cdb1cba34ba8852b5890f655645c9b4e15d5f19bf37e9f2ffe9f +8abe4e2a4f6462b6c64b3f10e45db2a53c2b0d3c5d5443d3f00a453e193df771eda635b098b6c8604ace3557514027af +8459e4fb378189b22b870a6ef20183deb816cefbf66eca1dc7e86d36a2e011537db893729f500dc154f14ce24633ba47 +930851df4bc7913c0d8c0f7bd3b071a83668987ed7c397d3d042fdc0d9765945a39a3bae83da9c88cb6b686ed8aeeb26 +8078c9e5cd05e1a8c932f8a1d835f61a248b6e7133fcbb3de406bf4ffc0e584f6f9f95062740ba6008d98348886cf76b +addff62bb29430983fe578e3709b0949cdc0d47a13a29bc3f50371a2cb5c822ce53e2448cfaa01bcb6e0aa850d5a380e +9433add687b5a1e12066721789b1db2edf9b6558c3bdc0f452ba33b1da67426abe326e9a34d207bfb1c491c18811bde1 +822beda3389963428cccc4a2918fa9a8a51cf0919640350293af70821967108cded5997adae86b33cb917780b097f1ca +a7a9f52bda45e4148ed56dd176df7bd672e9b5ed18888ccdb405f47920fdb0844355f8565cefb17010b38324edd8315f +b35c3a872e18e607b2555c51f9696a17fa18da1f924d503b163b4ec9fe22ed0c110925275cb6c93ce2d013e88f173d6a +adf34b002b2b26ab84fc1bf94e05bd8616a1d06664799ab149363c56a6e0c807fdc473327d25632416e952ea327fcd95 +ae4a6b9d22a4a3183fac29e2551e1124a8ce4a561a9a2afa9b23032b58d444e6155bb2b48f85c7b6d70393274e230db7 +a2ea3be4fc17e9b7ce3110284038d46a09e88a247b6971167a7878d9dcf36925d613c382b400cfa4f37a3ebea3699897 +8e5863786b641ce3140fbfe37124d7ad3925472e924f814ebfc45959aaf3f61dc554a597610b5defaecc85b59a99b50f +aefde3193d0f700d0f515ab2aaa43e2ef1d7831c4f7859f48e52693d57f97fa9e520090f3ed700e1c966f4b76048e57f +841a50f772956622798e5cd208dc7534d4e39eddee30d8ce133383d66e5f267e389254a0cdae01b770ecd0a9ca421929 +8fbc2bfd28238c7d47d4c03b1b910946c0d94274a199575e5b23242619b1de3497784e646a92aa03e3e24123ae4fcaba +926999579c8eec1cc47d7330112586bdca20b4149c8b2d066f527c8b9f609e61ce27feb69db67eea382649c6905efcf9 +b09f31f305efcc65589adf5d3690a76cf339efd67cd43a4e3ced7b839507466e4be72dd91f04e89e4bbef629d46e68c0 +b917361f6b95f759642638e0b1d2b3a29c3bdef0b94faa30de562e6078c7e2d25976159df3edbacbf43614635c2640b4 +8e7e8a1253bbda0e134d62bfe003a2669d471b47bd2b5cde0ff60d385d8e62279d54022f5ac12053b1e2d3aaa6910b4c +b69671a3c64e0a99d90b0ed108ce1912ff8ed983e4bddd75a370e9babde25ee1f5efb59ec707edddd46793207a8b1fe7 +910b2f4ebd37b7ae94108922b233d0920b4aba0bd94202c70f1314418b548d11d8e9caa91f2cd95aff51b9432d122b7f +82f645c90dfb52d195c1020346287c43a80233d3538954548604d09fbab7421241cde8593dbc4acc4986e0ea39a27dd9 +8fee895f0a140d88104ce442fed3966f58ff9d275e7373483f6b4249d64a25fb5374bbdc6bce6b5ab0270c2847066f83 +84f5bd7aab27b2509397aeb86510dd5ac0a53f2c8f73799bf720f2f87a52277f8d6b0f77f17bc80739c6a7119b7eb062 +9903ceced81099d7e146e661bcf01cbaccab5ba54366b85e2177f07e2d8621e19d9c9c3eee14b9266de6b3f9b6ea75ae +b9c16ea2a07afa32dd6c7c06df0dec39bca2067a9339e45475c98917f47e2320f6f235da353fd5e15b477de97ddc68dd +9820a9bbf8b826bec61ebf886de2c4f404c1ebdc8bab82ee1fea816d9de29127ce1852448ff717a3fe8bbfe9e92012e5 +817224d9359f5da6f2158c2c7bf9165501424f063e67ba9859a07ab72ee2ee62eb00ca6da821cfa19065c3282ca72c74 +94b95c465e6cb00da400558a3c60cfec4b79b27e602ca67cbc91aead08de4b6872d8ea096b0dc06dca4525c8992b8547 +a2b539a5bccd43fa347ba9c15f249b417997c6a38c63517ca38394976baa08e20be384a360969ff54e7e721db536b3e5 +96caf707e34f62811ee8d32ccf28d8d6ec579bc33e424d0473529af5315c456fd026aa910c1fed70c91982d51df7d3ca +8a77b73e890b644c6a142bdbac59b22d6a676f3b63ddafb52d914bb9d395b8bf5aedcbcc90429337df431ebd758a07a6 +8857830a7351025617a08bc44caec28d2fae07ebf5ffc9f01d979ce2a53839a670e61ae2783e138313929129790a51a1 +aa3e420321ed6f0aa326d28d1a10f13facec6f605b6218a6eb9cbc074801f3467bf013a456d1415a5536f12599efa3d3 +824aed0951957b00ea2f3d423e30328a3527bf6714cf9abbae84cf27e58e5c35452ba89ccc011de7c68c75d6e021d8f1 +a2e87cc06bf202e953fb1081933d8b4445527dde20e38ed1a4f440144fd8fa464a2b73e068b140562e9045e0f4bd3144 +ae3b8f06ad97d7ae3a5e5ca839efff3e4824dc238c0c03fc1a8d2fc8aa546cdfd165b784a31bb4dec7c77e9305b99a4b +b30c3e12395b1fb8b776f3ec9f87c70e35763a7b2ddc68f0f60a4982a84017f27c891a98561c830038deb033698ed7fc +874e507757cd1177d0dff0b0c62ce90130324442a33da3b2c8ee09dbca5d543e3ecfe707e9f1361e7c7db641c72794bb +b53012dd10b5e7460b57c092eaa06d6502720df9edbbe3e3f61a9998a272bf5baaac4a5a732ad4efe35d6fac6feca744 +85e6509d711515534d394e6cacbed6c81da710074d16ef3f4950bf2f578d662a494d835674f79c4d6315bced4defc5f0 +b6132b2a34b0905dcadc6119fd215419a7971fe545e52f48b768006944b4a9d7db1a74b149e2951ea48c083b752d0804 +989867da6415036d19b4bacc926ce6f4df7a556f50a1ba5f3c48eea9cefbb1c09da81481c8009331ee83f0859185e164 +960a6c36542876174d3fbc1505413e29f053ed87b8d38fef3af180491c7eff25200b45dd5fe5d4d8e63c7e8c9c00f4c8 +9040b59bd739d9cc2e8f6e894683429e4e876a8106238689ff4c22770ae5fdae1f32d962b30301fa0634ee163b524f35 +af3fcd0a45fe9e8fe256dc7eab242ef7f582dd832d147444483c62787ac820fafc6ca55d639a73f76bfa5e7f5462ab8f +b934c799d0736953a73d91e761767fdb78454355c4b15c680ce08accb57ccf941b13a1236980001f9e6195801cffd692 +8871e8e741157c2c326b22cf09551e78da3c1ec0fc0543136f581f1550f8bab03b0a7b80525c1e99812cdbf3a9698f96 +a8a977f51473a91d178ee8cfa45ffef8d6fd93ab1d6e428f96a3c79816d9c6a93cd70f94d4deda0125fd6816e30f3bea +a7688b3b0a4fc1dd16e8ba6dc758d3cfe1b7cf401c31739484c7fa253cce0967df1b290769bcefc9d23d3e0cb19e6218 +8ae84322662a57c6d729e6ff9d2737698cc2da2daeb1f39e506618750ed23442a6740955f299e4a15dda6db3e534d2c6 +a04a961cdccfa4b7ef83ced17ab221d6a043b2c718a0d6cc8e6f798507a31f10bf70361f70a049bc8058303fa7f96864 +b463e39732a7d9daec8a456fb58e54b30a6e160aa522a18b9a9e836488cce3342bcbb2e1deab0f5e6ec0a8796d77197d +b1434a11c6750f14018a2d3bcf94390e2948f4f187e93bb22070ca3e5393d339dc328cbfc3e48815f51929465ffe7d81 +84ff81d73f3828340623d7e3345553610aa22a5432217ef0ebd193cbf4a24234b190c65ca0873c22d10ea7b63bd1fbed +b6fe2723f0c47757932c2ddde7a4f8434f665612f7b87b4009c2635d56b6e16b200859a8ade49276de0ef27a2b6c970a +9742884ed7cd52b4a4a068a43d3faa02551a424136c85a9313f7cb58ea54c04aa83b0728fd741d1fe39621e931e88f8f +b7d2d65ea4d1ad07a5dee39e40d6c03a61264a56b1585b4d76fc5b2a68d80a93a42a0181d432528582bf08d144c2d6a9 +88c0f66bada89f8a43e5a6ead2915088173d106c76f724f4a97b0f6758aed6ae5c37c373c6b92cdd4aea8f6261f3a374 +81f9c43582cb42db3900747eb49ec94edb2284999a499d1527f03315fd330e5a509afa3bff659853570e9886aab5b28b +821f9d27d6beb416abf9aa5c79afb65a50ed276dbda6060103bc808bcd34426b82da5f23e38e88a55e172f5c294b4d40 +8ba307b9e7cb63a6c4f3851b321aebfdb6af34a5a4c3bd949ff7d96603e59b27ff4dc4970715d35f7758260ff942c9e9 +b142eb6c5f846de33227d0bda61d445a7c33c98f0a8365fe6ab4c1fabdc130849be597ef734305894a424ea715372d08 +a732730ae4512e86a741c8e4c87fee8a05ee840fec0e23b2e037d58dba8dde8d10a9bc5191d34d00598941becbbe467f +adce6f7c30fd221f6b10a0413cc76435c4bb36c2d60bca821e5c67409fe9dbb2f4c36ef85eb3d734695e4be4827e9fd3 +a74f00e0f9b23aff7b2527ce69852f8906dab9d6abe62ecd497498ab21e57542e12af9918d4fd610bb09e10b0929c510 +a593b6b0ef26448ce4eb3ab07e84238fc020b3cb10d542ff4b16d4e2be1bcde3797e45c9cf753b8dc3b0ffdb63984232 +aed3913afccf1aa1ac0eb4980eb8426d0baccebd836d44651fd72af00d09fac488a870223c42aca3ceb39752070405ae +b2c44c66a5ea7fde626548ba4cef8c8710191343d3dadfd3bb653ce715c0e03056a5303a581d47dde66e70ea5a2d2779 +8e5029b2ccf5128a12327b5103f7532db599846e422531869560ceaff392236434d87159f597937dbf4054f810c114f4 +82beed1a2c4477e5eb39fc5b0e773b30cfec77ef2b1bf17eadaf60eb35b6d0dd9d8cf06315c48d3546badb3f21cd0cca +90077bd6cc0e4be5fff08e5d07a5a158d36cebd1d1363125bc4fae0866ffe825b26f933d4ee5427ba5cd0c33c19a7b06 +a7ec0d8f079970e8e34f0ef3a53d3e0e45428ddcef9cc776ead5e542ef06f3c86981644f61c5a637e4faf001fb8c6b3e +ae6d4add6d1a6f90b22792bc9d40723ee6850c27d0b97eefafd5b7fd98e424aa97868b5287cc41b4fbd7023bca6a322c +831aa917533d077da07c01417feaa1408846363ba2b8d22c6116bb858a95801547dd88b7d7fa1d2e3f0a02bdeb2e103d +96511b860b07c8a5ed773f36d4aa9d02fb5e7882753bf56303595bcb57e37ccc60288887eb83bef08c657ec261a021a2 +921d2a3e7e9790f74068623de327443666b634c8443aba80120a45bba450df920b2374d96df1ce3fb1b06dd06f8cf6e3 +aa74451d51fe82b4581ead8e506ec6cd881010f7e7dd51fc388eb9a557db5d3c6721f81c151d08ebd9c2591689fbc13e +a972bfbcf4033d5742d08716c927c442119bdae336bf5dff914523b285ccf31953da2733759aacaa246a9af9f698342c +ad1fcd0cae0e76840194ce4150cb8a56ebed728ec9272035f52a799d480dfc85840a4d52d994a18b6edb31e79be6e8ad +a2c69fe1d36f235215432dad48d75887a44c99dfa0d78149acc74087da215a44bdb5f04e6eef88ff7eff80a5a7decc77 +a94ab2af2b6ee1bc6e0d4e689ca45380d9fbd3c5a65b9bd249d266a4d4c07bf5d5f7ef2ae6000623aee64027892bf8fe +881ec1fc514e926cdc66480ac59e139148ff8a2a7895a49f0dff45910c90cdda97b66441a25f357d6dd2471cddd99bb3 +884e6d3b894a914c8cef946a76d5a0c8351843b2bffa2d1e56c6b5b99c84104381dd1320c451d551c0b966f4086e60f9 +817c6c10ce2677b9fc5223500322e2b880583254d0bb0d247d728f8716f5e05c9ff39f135854342a1afecd9fbdcf7c46 +aaf4a9cb686a14619aa1fc1ac285dd3843ac3dd99f2b2331c711ec87b03491c02f49101046f3c5c538dc9f8dba2a0ac2 +97ecea5ce53ca720b5d845227ae61d70269a2f53540089305c86af35f0898bfd57356e74a8a5e083fa6e1ea70080bd31 +a22d811e1a20a75feac0157c418a4bfe745ccb5d29466ffa854dca03e395b6c3504a734341746b2846d76583a780b32e +940cbaa0d2b2db94ae96b6b9cf2deefbfd059e3e5745de9aec4a25f0991b9721e5cd37ef71c631575d1a0c280b01cd5b +ae33cb4951191258a11044682de861bf8d92d90ce751b354932dd9f3913f542b6a0f8a4dc228b3cd9244ac32c4582832 +a580df5e58c4274fe0f52ac2da1837e32f5c9db92be16c170187db4c358f43e5cfdda7c5911dcc79d77a5764e32325f5 +81798178cb9d8affa424f8d3be67576ba94d108a28ccc01d330c51d5a63ca45bb8ca63a2f569b5c5fe1303cecd2d777f +89975b91b94c25c9c3660e4af4047a8bacf964783010820dbc91ff8281509379cb3b24c25080d5a01174dd9a049118d5 +a7327fcb3710ed3273b048650bde40a32732ef40a7e58cf7f2f400979c177944c8bc54117ba6c80d5d4260801dddab79 +92b475dc8cb5be4b90c482f122a51bcb3b6c70593817e7e2459c28ea54a7845c50272af38119406eaadb9bcb993368d0 +9645173e9ecefc4f2eae8363504f7c0b81d85f8949a9f8a6c01f2d49e0a0764f4eacecf3e94016dd407fc14494fce9f9 +9215fd8983d7de6ae94d35e6698226fc1454977ae58d42d294be9aad13ac821562ad37d5e7ee5cdfe6e87031d45cd197 +810360a1c9b88a9e36f520ab5a1eb8bed93f52deefbe1312a69225c0a08edb10f87cc43b794aced9c74220cefcc57e7d +ad7e810efd61ed4684aeda9ed8bb02fb9ae4b4b63fda8217d37012b94ff1b91c0087043bfa4e376f961fff030c729f3b +8b07c95c6a06db8738d10bb03ec11b89375c08e77f0cab7e672ce70b2685667ca19c7e1c8b092821d31108ea18dfd4c7 +968825d025ded899ff7c57245250535c732836f7565eab1ae23ee7e513201d413c16e1ba3f5166e7ac6cf74de8ceef4f +908243370c5788200703ade8164943ad5f8c458219186432e74dbc9904a701ea307fd9b94976c866e6c58595fd891c4b +959969d16680bc535cdc6339e6186355d0d6c0d53d7bbfb411641b9bf4b770fd5f575beef5deec5c4fa4d192d455c350 +ad177f4f826a961adeac76da40e2d930748effff731756c797eddc4e5aa23c91f070fb69b19221748130b0961e68a6bb +82f8462bcc25448ef7e0739425378e9bb8a05e283ce54aae9dbebaf7a3469f57833c9171672ad43a79778366c72a5e37 +a28fb275b1845706c2814d9638573e9bc32ff552ebaed761fe96fdbce70395891ca41c400ae438369264e31a2713b15f +8a9c613996b5e51dadb587a787253d6081ea446bf5c71096980bf6bd3c4b69905062a8e8a3792de2d2ece3b177a71089 +8d5aefef9f60cb27c1db2c649221204dda48bb9bf8bf48f965741da051340e8e4cab88b9d15c69f3f84f4c854709f48a +93ebf2ca6ad85ab6deace6de1a458706285b31877b1b4d7dcb9d126b63047efaf8c06d580115ec9acee30c8a7212fa55 +b3ee46ce189956ca298057fa8223b7fd1128cf52f39159a58bca03c71dd25161ac13f1472301f72aef3e1993fe1ab269 +a24d7a8d066504fc3f5027ccb13120e2f22896860e02c45b5eba1dbd512d6a17c28f39155ea581619f9d33db43a96f92 +ae9ceacbfe12137db2c1a271e1b34b8f92e4816bad1b3b9b6feecc34df0f8b3b0f7ed0133acdf59c537d43d33fc8d429 +83967e69bf2b361f86361bd705dce0e1ad26df06da6c52b48176fe8dfcbeb03c462c1a4c9e649eff8c654b18c876fdef +9148e6b814a7d779c19c31e33a068e97b597de1f8100513db3c581190513edc4d544801ce3dd2cf6b19e0cd6daedd28a +94ccdafc84920d320ed22de1e754adea072935d3c5f8c2d1378ebe53d140ea29853f056fb3fb1e375846061a038cc9bc +afb43348498c38b0fa5f971b8cdd3a62c844f0eb52bc33daf2f67850af0880fce84ecfb96201b308d9e6168a0d443ae3 +86d5736520a83538d4cd058cc4b4e84213ed00ebd6e7af79ae787adc17a92ba5359e28ba6c91936d967b4b28d24c3070 +b5210c1ff212c5b1e9ef9126e08fe120a41e386bb12c22266f7538c6d69c7fd8774f11c02b81fd4e88f9137b020801fe +b78cfd19f94d24e529d0f52e18ce6185cb238edc6bd43086270fd51dd99f664f43dd4c7d2fe506762fbd859028e13fcf +a6e7220598c554abdcc3fdc587b988617b32c7bb0f82c06205467dbedb58276cc07cae317a190f19d19078773f4c2bbb +b88862809487ee430368dccd85a5d72fa4d163ca4aad15c78800e19c1a95be2192719801e315d86cff7795e0544a77e4 +87ecb13a03921296f8c42ceb252d04716f10e09c93962239fcaa0a7fef93f19ab3f2680bc406170108bc583e9ff2e721 +a810cd473832b6581c36ec4cb403f2849357ba2d0b54df98ef3004b8a530c078032922a81d40158f5fb0043d56477f6e +a247b45dd85ca7fbb718b328f30a03f03c84aef2c583fbdc9fcc9eb8b52b34529e8c8f535505c10598b1b4dac3d7c647 +96ee0b91313c68bac4aa9e065ce9e1d77e51ca4cff31d6a438718c58264dee87674bd97fc5c6b8008be709521e4fd008 +837567ad073e42266951a9a54750919280a2ac835a73c158407c3a2b1904cf0d17b7195a393c71a18ad029cbd9cf79ee +a6a469c44b67ebf02196213e7a63ad0423aab9a6e54acc6fcbdbb915bc043586993454dc3cd9e4be8f27d67c1050879b +8712d380a843b08b7b294f1f06e2f11f4ad6bcc655fdde86a4d8bc739c23916f6fad2b902fe47d6212f03607907e9f0e +920adfb644b534789943cdae1bdd6e42828dda1696a440af2f54e6b97f4f97470a1c6ea9fa6a2705d8f04911d055acd1 +a161c73adf584a0061e963b062f59d90faac65c9b3a936b837a10d817f02fcabfa748824607be45a183dd40f991fe83f +874f4ecd408c76e625ea50bc59c53c2d930ee25baf4b4eca2440bfbffb3b8bc294db579caa7c68629f4d9ec24187c1ba +8bff18087f112be7f4aa654e85c71fef70eee8ae480f61d0383ff6f5ab1a0508f966183bb3fc4d6f29cb7ca234aa50d3 +b03b46a3ca3bc743a173cbc008f92ab1aedd7466b35a6d1ca11e894b9482ea9dc75f8d6db2ddd1add99bfbe7657518b7 +8b4f3691403c3a8ad9e097f02d130769628feddfa8c2b3dfe8cff64e2bed7d6e5d192c1e2ba0ac348b8585e94acd5fa1 +a0d9ca4a212301f97591bf65d5ef2b2664766b427c9dd342e23cb468426e6a56be66b1cb41fea1889ac5d11a8e3c50a5 +8c93ed74188ca23b3df29e5396974b9cc135c91fdefdea6c0df694c8116410e93509559af55533a3776ac11b228d69b1 +82dd331fb3f9e344ebdeeb557769b86a2cc8cc38f6c298d7572a33aea87c261afa9dbd898989139b9fc16bc1e880a099 +a65faedf326bcfd8ef98a51410c78b021d39206704e8291cd1f09e096a66b9b0486be65ff185ca224c45918ac337ddeb +a188b37d363ac072a766fd5d6fa27df07363feff1342217b19e3c37385e42ffde55e4be8355aceaa2f267b6d66b4ac41 +810fa3ba3e96d843e3bafd3f2995727f223d3567c8ba77d684c993ba1773c66551eb5009897c51b3fe9b37196984f5ec +87631537541852da323b4353af45a164f68b304d24c01183bf271782e11687f3fcf528394e1566c2a26cb527b3148e64 +b721cb2b37b3c477a48e3cc0044167d51ff568a5fd2fb606e5aec7a267000f1ddc07d3db919926ae12761a8e017c767c +904dfad4ba2cc1f6e60d1b708438a70b1743b400164cd981f13c064b8328d5973987d4fb9cf894068f29d3deaf624dfb +a70491538893552c20939fae6be2f07bfa84d97e2534a6bbcc0f1729246b831103505e9f60e97a8fa7d2e6c1c2384579 +8726cf1b26b41f443ff7485adcfddc39ace2e62f4d65dd0bb927d933e262b66f1a9b367ded5fbdd6f3b0932553ac1735 +ae8a11cfdf7aa54c08f80cb645e3339187ab3886babe9fae5239ba507bb3dd1c0d161ca474a2df081dcd3d63e8fe445e +92328719e97ce60e56110f30a00ac5d9c7a2baaf5f8d22355d53c1c77941e3a1fec7d1405e6fbf8959665fe2ba7a8cad +8d9d6255b65798d0018a8cccb0b6343efd41dc14ff2058d3eed9451ceaad681e4a0fa6af67b0a04318aa628024e5553d +b70209090055459296006742d946a513f0cba6d83a05249ee8e7a51052b29c0ca9722dc4af5f9816a1b7938a5dac7f79 +aab7b766b9bf91786dfa801fcef6d575dc6f12b77ecc662eb4498f0312e54d0de9ea820e61508fc8aeee5ab5db529349 +a8104b462337748b7f086a135d0c3f87f8e51b7165ca6611264b8fb639d9a2f519926cb311fa2055b5fadf03da70c678 +b0d2460747d5d8b30fc6c6bd0a87cb343ddb05d90a51b465e8f67d499cfc5e3a9e365da05ae233bbee792cdf90ec67d5 +aa55f5bf3815266b4a149f85ed18e451c93de9163575e3ec75dd610381cc0805bb0a4d7c4af5b1f94d10231255436d2c +8d4c6a1944ff94426151909eb5b99cfd92167b967dabe2bf3aa66bb3c26c449c13097de881b2cfc1bf052862c1ef7b03 +8862296162451b9b6b77f03bf32e6df71325e8d7485cf3335d66fd48b74c2a8334c241db8263033724f26269ad95b395 +901aa96deb26cda5d9321190ae6624d357a41729d72ef1abfd71bebf6139af6d690798daba53b7bc5923462115ff748a +96c195ec4992728a1eb38cdde42d89a7bce150db43adbc9e61e279ea839e538deec71326b618dd39c50d589f78fc0614 +b6ff8b8aa0837b99a1a8b46fb37f20ad4aecc6a98381b1308697829a59b8442ffc748637a88cb30c9b1f0f28a926c4f6 +8d807e3dca9e7bef277db1d2cfb372408dd587364e8048b304eff00eacde2c723bfc84be9b98553f83cba5c7b3cba248 +8800c96adb0195c4fc5b24511450dee503c32bf47044f5e2e25bd6651f514d79a2dd9b01cd8c09f3c9d3859338490f57 +89fe366096097e38ec28dd1148887112efa5306cc0c3da09562aafa56f4eb000bf46ff79bf0bdd270cbde6bf0e1c8957 +af409a90c2776e1e7e3760b2042507b8709e943424606e31e791d42f17873a2710797f5baaab4cc4a19998ef648556b0 +8d761863c9b6edbd232d35ab853d944f5c950c2b643f84a1a1327ebb947290800710ff01dcfa26dc8e9828481240e8b1 +90b95e9be1e55c463ed857c4e0617d6dc3674e99b6aa62ed33c8e79d6dfcf7d122f4f4cc2ee3e7c5a49170cb617d2e2e +b3ff381efefabc4db38cc4727432e0301949ae4f16f8d1dea9b4f4de611cf5a36d84290a0bef160dac4e1955e516b3b0 +a8a84564b56a9003adcadb3565dc512239fc79572762cda7b5901a255bc82656bb9c01212ad33d6bef4fbbce18dacc87 +90a081890364b222eef54bf0075417f85e340d2fec8b7375995f598aeb33f26b44143ebf56fca7d8b4ebb36b5747b0eb +ade6ee49e1293224ddf2d8ab7f14bb5be6bc6284f60fd5b3a1e0cf147b73cff57cf19763b8a36c5083badc79c606b103 +b2fa99806dd2fa3de09320b615a2570c416c9bcdb052e592b0aead748bbe407ec9475a3d932ae48b71c2627eb81986a6 +91f3b7b73c8ccc9392542711c45fe6f236057e6efad587d661ad5cb4d6e88265f86b807bb1151736b1009ab74fd7acb4 +8800e2a46af96696dfbdcbf2ca2918b3dcf28ad970170d2d1783b52b8d945a9167d052beeb55f56c126da7ffa7059baa +9862267a1311c385956b977c9aa08548c28d758d7ba82d43dbc3d0a0fd1b7a221d39e8399997fea9014ac509ff510ac4 +b7d24f78886fd3e2d283e18d9ad5a25c1a904e7d9b9104bf47da469d74f34162e27e531380dbbe0a9d051e6ffd51d6e7 +b0f445f9d143e28b9df36b0f2c052da87ee2ca374d9d0fbe2eff66ca6fe5fe0d2c1951b428d58f7314b7e74e45d445ea +b63fc4083eabb8437dafeb6a904120691dcb53ce2938b820bb553da0e1eecd476f72495aacb72600cf9cad18698fd3db +b9ffd8108eaebd582d665f8690fe8bb207fd85185e6dd9f0b355a09bac1bbff26e0fdb172bc0498df025414e88fe2eda +967ed453e1f1a4c5b7b6834cc9f75c13f6889edc0cc91dc445727e9f408487bbf05c337103f61397a10011dfbe25d61d +98ceb673aff36e1987d5521a3984a07079c3c6155974bb8b413e8ae1ce84095fe4f7862fba7aefa14753eb26f2a5805f +85f01d28603a8fdf6ce6a50cb5c44f8a36b95b91302e3f4cd95c108ce8f4d212e73aec1b8d936520d9226802a2bd9136 +88118e9703200ca07910345fbb789e7a8f92bd80bbc79f0a9e040e8767d33df39f6eded403a9b636eabf9101e588482a +90833a51eef1b10ed74e8f9bbd6197e29c5292e469c854eed10b0da663e2bceb92539710b1858bbb21887bd538d28d89 +b513b905ec19191167c6193067b5cfdf5a3d3828375360df1c7e2ced5815437dfd37f0c4c8f009d7fb29ff3c8793f560 +b1b6d405d2d18f9554b8a358cc7e2d78a3b34269737d561992c8de83392ac9a2857be4bf15de5a6c74e0c9d0f31f393c +b828bd3e452b797323b798186607849f85d1fb20c616833c0619360dfd6b3e3aa000fd09dafe4b62d74abc41072ff1a9 +8efde67d0cca56bb2c464731879c9ac46a52e75bac702a63200a5e192b4f81c641f855ca6747752b84fe469cb7113b6c +b2762ba1c89ac3c9a983c242e4d1c2610ff0528585ed5c0dfc8a2c0253551142af9b59f43158e8915a1da7cc26b9df67 +8a3f1157fb820d1497ef6b25cd70b7e16bb8b961b0063ad340d82a79ee76eb2359ca9e15e6d42987ed7f154f5eeaa2da +a75e29f29d38f09c879f971c11beb5368affa084313474a5ecafa2896180b9e47ea1995c2733ec46f421e395a1d9cffe +8e8c3dd3e7196ef0b4996b531ec79e4a1f211db5d5635e48ceb80ff7568b2ff587e845f97ee703bb23a60945ad64314a +8e7f32f4a3e3c584af5e3d406924a0aa34024c42eca74ef6cc2a358fd3c9efaf25f1c03aa1e66bb94b023a2ee2a1cace +ab7dce05d59c10a84feb524fcb62478906b3fa045135b23afbede3bb32e0c678d8ebe59feabccb5c8f3550ea76cae44b +b38bb4b44d827f6fd3bd34e31f9186c59e312dbfadd4a7a88e588da10146a78b1f8716c91ad8b806beb8da65cab80c4c +9490ce9442bbbd05438c7f5c4dea789f74a7e92b1886a730544b55ba377840740a3ae4f2f146ee73f47c9278b0e233bc +83c003fab22a7178eed1a668e0f65d4fe38ef3900044e9ec63070c23f2827d36a1e73e5c2b883ec6a2afe2450171b3b3 +9982f02405978ddc4fca9063ebbdb152f524c84e79398955e66fe51bc7c1660ec1afc3a86ec49f58d7b7dde03505731c +ab337bd83ccdd2322088ffa8d005f450ced6b35790f37ab4534313315ee84312adc25e99cce052863a8bedee991729ed +8312ce4bec94366d88f16127a17419ef64285cd5bf9e5eda010319b48085966ed1252ed2f5a9fd3e0259b91bb65f1827 +a60d5a6327c4041b0c00a1aa2f0af056520f83c9ce9d9ccd03a0bd4d9e6a1511f26a422ea86bd858a1f77438adf07e6c +b84a0a0b030bdad83cf5202aa9afe58c9820e52483ab41f835f8c582c129ee3f34aa096d11c1cd922eda02ea1196a882 +8077d105317f4a8a8f1aadeb05e0722bb55f11abcb490c36c0904401107eb3372875b0ac233144829e734f0c538d8c1d +9202503bd29a6ec198823a1e4e098f9cfe359ed51eb5174d1ca41368821bfeebcbd49debfd02952c41359d1c7c06d2b1 +abc28c155e09365cb77ffead8dc8f602335ef93b2f44e4ef767ce8fc8ef9dd707400f3a722e92776c2e0b40192c06354 +b0f6d1442533ca45c9399e0a63a11f85ff288d242cea6cb3b68c02e77bd7d158047cae2d25b3bcd9606f8f66d9b32855 +b01c3d56a0db84dc94575f4b6ee2de4beca3230e86bed63e2066beb22768b0a8efb08ebaf8ac3dedb5fe46708b084807 +8c8634b0432159f66feaabb165842d1c8ac378f79565b1b90c381aa8450eb4231c3dad11ec9317b9fc2b155c3a771e32 +8e67f623d69ecd430c9ee0888520b6038f13a2b6140525b056dc0951f0cfed2822e62cf11d952a483107c5c5acac4826 +9590bb1cba816dd6acd5ac5fba5142c0a19d53573e422c74005e0bcf34993a8138c83124cad35a3df65879dba6134edd +801cd96cde0749021a253027118d3ea135f3fcdbe895db08a6c145641f95ebd368dd6a1568d995e1d0084146aebe224a +848b5d196427f6fc1f762ee3d36e832b64a76ec1033cfedc8b985dea93932a7892b8ef1035c653fb9dcd9ab2d9a44ac8 +a1017eb83d5c4e2477e7bd2241b2b98c4951a3b391081cae7d75965cadc1acaec755cf350f1f3d29741b0828e36fedea +8d6d2785e30f3c29aad17bd677914a752f831e96d46caf54446d967cb2432be2c849e26f0d193a60bee161ea5c6fe90a +935c0ba4290d4595428e034b5c8001cbd400040d89ab00861108e8f8f4af4258e41f34a7e6b93b04bc253d3b9ffc13bf +aac02257146246998477921cef2e9892228590d323b839f3e64ea893b991b463bc2f47e1e5092ddb47e70b2f5bce7622 +b921fde9412970a5d4c9a908ae8ce65861d06c7679af577cf0ad0d5344c421166986bee471fd6a6cecb7d591f06ec985 +8ef4c37487b139d6756003060600bb6ebac7ea810b9c4364fc978e842f13ac196d1264fbe5af60d76ff6d9203d8e7d3f +94b65e14022b5cf6a9b95f94be5ace2711957c96f4211c3f7bb36206bd39cfbd0ea82186cab5ad0577a23214a5c86e9e +a31c166d2a2ca1d5a75a5920fef7532681f62191a50d8555fdaa63ba4581c3391cc94a536fc09aac89f64eafceec3f90 +919a8cc128de01e9e10f5d83b08b52293fdd41bde2b5ae070f3d95842d4a16e5331cf2f3d61c765570c8022403610fa4 +b23d6f8331eef100152d60483cfa14232a85ee712c8538c9b6417a5a7c5b353c2ac401390c6c215cb101f5cee6b5f43e +ab357160c08a18319510a571eafff154298ce1020de8e1dc6138a09fcb0fcbcdd8359f7e9386bda00b7b9cdea745ffdc +ab55079aea34afa5c0bd1124b9cdfe01f325b402fdfa017301bf87812eaa811ea5798c3aaf818074d420d1c782b10ada +ade616010dc5009e7fc4f8d8b00dc716686a5fa0a7816ad9e503e15839d3b909b69d9dd929b7575376434ffec0d2bea8 +863997b97ed46898a8a014599508fa3079f414b1f4a0c4fdc6d74ae8b444afa350f327f8bfc2a85d27f9e2d049c50135 +8d602ff596334efd4925549ed95f2aa762b0629189f0df6dbb162581657cf3ea6863cd2287b4d9c8ad52813d87fcd235 +b70f68c596dcdeed92ad5c6c348578b26862a51eb5364237b1221e840c47a8702f0fbc56eb520a22c0eed99795d3903e +9628088f8e0853cefadee305a8bf47fa990c50fa96a82511bbe6e5dc81ef4b794e7918a109070f92fc8384d77ace226f +97e26a46e068b605ce96007197ecd943c9a23881862f4797a12a3e96ba2b8d07806ad9e2a0646796b1889c6b7d75188c +b1edf467c068cc163e2d6413cc22b16751e78b3312fe47b7ea82b08a1206d64415b2c8f2a677fa89171e82cc49797150 +a44d15ef18745b251429703e3cab188420e2d974de07251501799b016617f9630643fcd06f895634d8ecdd579e1bf000 +abd126df3917ba48c618ee4dbdf87df506193462f792874439043fa1b844466f6f4e0ff2e42516e63b5b23c0892b2695 +a2a67f57c4aa3c2aa1eeddbfd5009a89c26c2ce8fa3c96a64626aba19514beb125f27df8559506f737de3eae0f1fc18f +a633e0132197e6038197304b296ab171f1d8e0d0f34dcf66fe9146ac385b0239232a8470b9205a4802ab432389f4836d +a914b3a28509a906c3821463b936455d58ff45dcbe158922f9efb2037f2eb0ce8e92532d29b5d5a3fcd0d23fa773f272 +a0e1412ce4505daf1a2e59ce4f0fc0e0023e335b50d2b204422f57cd65744cc7a8ed35d5ef131a42c70b27111d3115b7 +a2339e2f2b6072e88816224fdd612c04d64e7967a492b9f8829db15367f565745325d361fd0607b0def1be384d010d9e +a7309fc41203cb99382e8193a1dcf03ac190a7ce04835304eb7e341d78634e83ea47cb15b885601956736d04cdfcaa01 +81f3ccd6c7f5b39e4e873365f8c37b214e8ab122d04a606fbb7339dc3298c427e922ec7418002561d4106505b5c399ee +92c121cf914ca549130e352eb297872a63200e99b148d88fbc9506ad882bec9d0203d65f280fb5b0ba92e336b7f932e8 +a4b330cf3f064f5b131578626ad7043ce2a433b6f175feb0b52d36134a454ca219373fd30d5e5796410e005b69082e47 +86fe5774112403ad83f9c55d58317eeb17ad8e1176d9f2f69c2afb7ed83bc718ed4e0245ceab4b377f5f062dcd4c00e7 +809d152a7e2654c7fd175b57f7928365a521be92e1ed06c05188a95864ddb25f7cab4c71db7d61bbf4cae46f3a1d96ce +b82d663e55c2a5ada7e169e9b1a87bc1c0177baf1ec1c96559b4cb1c5214ce1ddf2ab8d345014cab6402f3774235cf5a +86580af86df1bd2c385adb8f9a079e925981b7184db66fc5fe5b14cddb82e7d836b06eaeef14924ac529487b23dae111 +b5f5f4c5c94944ecc804df6ab8687d64e27d988cbfeae1ba7394e0f6adbf778c5881ead7cd8082dd7d68542b9bb4ecd5 +a6016916146c2685c46e8fdd24186394e2d5496e77e08c0c6a709d4cd7dfa97f1efcef94922b89196819076a91ad37b5 +b778e7367ded3b6eab53d5fc257f7a87e8faf74a593900f2f517220add2125be3f6142022660d8181df8d164ad9441ce +8581b2d36abe6f553add4d24be761bec1b8efaa2929519114346615380b3c55b59e6ad86990e312f7e234d0203bdf59b +9917e74fd45c3f71a829ff5498a7f6b5599b48c098dda2339bf04352bfc7f368ccf1a407f5835901240e76452ae807d7 +afd196ce6f9335069138fd2e3d133134da253978b4ce373152c0f26affe77a336505787594022e610f8feb722f7cc1fb +a477491a1562e329764645e8f24d8e228e5ef28c9f74c6b5b3abc4b6a562c15ffb0f680d372aed04d9e1bf944dece7be +9767440d58c57d3077319d3a330e5322b9ba16981ec74a5a14d53462eab59ae7fd2b14025bfc63b268862094acb444e6 +80986d921be3513ef69264423f351a61cb48390c1be8673aee0f089076086aaebea7ebe268fd0aa7182695606116f679 +a9554c5c921c07b450ee04e34ec58e054ac1541b26ce2ce5a393367a97348ba0089f53db6660ad76b60278b66fd12e3e +95097e7d2999b3e84bf052c775581cf361325325f4a50192521d8f4693c830bed667d88f482dc1e3f833aa2bd22d2cbf +9014c91d0f85aefd28436b5228c12f6353c055a9326c7efbf5e071e089e2ee7c070fcbc84c5fafc336cbb8fa6fec1ca1 +90f57ba36ee1066b55d37384942d8b57ae00f3cf9a3c1d6a3dfee1d1af42d4b5fa9baeb0cd7e46687d1d6d090ddb931d +8e4b1db12fd760a17214c9e47f1fce6e43c0dbb4589a827a13ac61aaae93759345697bb438a00edab92e0b7b62414683 +8022a959a513cdc0e9c705e0fc04eafd05ff37c867ae0f31f6d01cddd5df86138a426cab2ff0ac8ff03a62e20f7e8f51 +914e9a38829834c7360443b8ed86137e6f936389488eccf05b4b4db7c9425611705076ecb3f27105d24b85c852be7511 +957fb10783e2bd0db1ba66b18e794df710bc3b2b05776be146fa5863c15b1ebdd39747b1a95d9564e1772cdfc4f37b8a +b6307028444daed8ed785ac9d0de76bc3fe23ff2cc7e48102553613bbfb5afe0ebe45e4212a27021c8eb870721e62a1f +8f76143597777d940b15a01b39c5e1b045464d146d9a30a6abe8b5d3907250e6c7f858ff2308f8591e8b0a7b3f3c568a +96163138ac0ce5fd00ae9a289648fd9300a0ca0f63a88481d703ecd281c06a52a3b5178e849e331f9c85ca4ba398f4cc +a63ef47c3e18245b0482596a09f488a716df3cbd0f9e5cfabed0d742843e65db8961c556f45f49762f3a6ac8b627b3ef +8cb595466552e7c4d42909f232d4063e0a663a8ef6f6c9b7ce3a0542b2459cde04e0e54c7623d404acb5b82775ac04f6 +b47fe69960eb45f399368807cff16d941a5a4ebad1f5ec46e3dc8a2e4d598a7e6114d8f0ca791e9720fd786070524e2b +89eb5ff83eea9df490e5beca1a1fbbbbcf7184a37e2c8c91ede7a1e654c81e8cd41eceece4042ea7918a4f4646b67fd6 +a84f5d155ed08b9054eecb15f689ba81e44589e6e7207a99790c598962837ca99ec12344105b16641ca91165672f7153 +a6cc8f25c2d5b2d2f220ec359e6a37a52b95fa6af6e173c65e7cd55299eff4aa9e6d9e6f2769e6459313f1f2aecb0fab +afcde944411f017a9f7979755294981e941cc41f03df5e10522ef7c7505e5f1babdd67b3bf5258e8623150062eb41d9b +8fab39f39c0f40182fcd996ade2012643fe7731808afbc53f9b26900b4d4d1f0f5312d9d40b3df8baa4739970a49c732 +ae193af9726da0ebe7df1f9ee1c4846a5b2a7621403baf8e66c66b60f523e719c30c6b4f897bb14b27d3ff3da8392eeb +8ac5adb82d852eba255764029f42e6da92dcdd0e224d387d1ef94174038db9709ac558d90d7e7c57ad4ce7f89bbfc38c +a2066b3458fdf678ee487a55dd5bfb74fde03b54620cb0e25412a89ee28ad0d685e309a51e3e4694be2fa6f1593a344c +88d031745dd0ae07d61a15b594be5d4b2e2a29e715d081649ad63605e3404b0c3a5353f0fd9fad9c05c18e93ce674fa1 +8283cfb0ef743a043f2b77ecaeba3005e2ca50435585b5dd24777ee6bce12332f85e21b446b536da38508807f0f07563 +b376de22d5f6b0af0b59f7d9764561f4244cf8ffe22890ecd3dcf2ff1832130c9b821e068c9d8773136f4796721e5963 +ae3afc50c764f406353965363840bf28ee85e7064eb9d5f0bb3c31c64ab10f48c853e942ee2c9b51bae59651eaa08c2f +948b204d103917461a01a6c57a88f2d66b476eae5b00be20ec8c747650e864bc8a83aee0aff59cb7584b7a3387e0ee48 +81ab098a082b07f896c5ffd1e4446cb7fb44804cbbf38d125208b233fc82f8ec9a6a8d8dd1c9a1162dc28ffeec0dde50 +a149c6f1312821ced2969268789a3151bdda213451760b397139a028da609c4134ac083169feb0ee423a0acafd10eceb +b0ac9e27a5dadaf523010f730b28f0ebac01f460d3bbbe277dc9d44218abb5686f4fac89ae462682fef9edbba663520a +8d0e0073cca273daaaa61b6fc54bfe5a009bc3e20ae820f6c93ba77b19eca517d457e948a2de5e77678e4241807157cb +ad61d3a2edf7c7533a04964b97499503fd8374ca64286dba80465e68fe932e96749b476f458c6fc57cb1a7ca85764d11 +90eb5e121ae46bc01a30881eaa556f46bd8457a4e80787cf634aab355082de34ac57d7f497446468225f7721e68e2a47 +8cdac557de7c42d1f3780e33dec1b81889f6352279be81c65566cdd4952d4c15d79e656cbd46035ab090b385e90245ef +82b67e61b88b84f4f4d4f65df37b3e3dcf8ec91ea1b5c008fdccd52da643adbe6468a1cfdb999e87d195afe2883a3b46 +8503b467e8f5d6048a4a9b78496c58493a462852cab54a70594ae3fd064cfd0deb4b8f336a262155d9fedcaa67d2f6fd +8db56c5ac763a57b6ce6832930c57117058e3e5a81532b7d19346346205e2ec614eb1a2ee836ef621de50a7bc9b7f040 +ad344699198f3c6e8c0a3470f92aaffc805b76266734414c298e10b5b3797ca53578de7ccb2f458f5e0448203f55282b +80602032c43c9e2a09154cc88b83238343b7a139f566d64cb482d87436b288a98f1ea244fd3bff8da3c398686a900c14 +a6385bd50ecd548cfb37174cdbb89e10025b5cadaf3cff164c95d7aef5a33e3d6a9bf0c681b9e11db9ef54ebeee2a0c1 +abf2d95f4aa34b0581eb9257a0cc8462b2213941a5deb8ba014283293e8b36613951b61261cc67bbd09526a54cbbff76 +a3d5de52f48df72c289ff713e445991f142390798cd42bd9d9dbefaee4af4f5faf09042d126b975cf6b98711c3072553 +8e627302ff3d686cff8872a1b7c2a57b35f45bf2fc9aa42b049d8b4d6996a662b8e7cbac6597f0cb79b0cc4e29fbf133 +8510702e101b39a1efbf4e504e6123540c34b5689645e70d0bac1ecc1baf47d86c05cef6c4317a4e99b4edaeb53f2d00 +aa173f0ecbcc6088f878f8726d317748c81ebf501bba461f163b55d66099b191ec7c55f7702f351a9c8eb42cfa3280e2 +b560a697eafab695bcef1416648a0a664a71e311ecbe5823ae903bd0ed2057b9d7574b9a86d3fe22aa3e6ddce38ea513 +8df6304a3d9cf40100f3f687575419c998cd77e5cc27d579cf4f8e98642de3609af384a0337d145dd7c5635172d26a71 +8105c7f3e4d30a29151849673853b457c1885c186c132d0a98e63096c3774bc9deb956cf957367e633d0913680bda307 +95373fc22c0917c3c2044ac688c4f29a63ed858a45c0d6d2d0fe97afd6f532dcb648670594290c1c89010ecc69259bef +8c2fae9bcadab341f49b55230310df93cac46be42d4caa0d42e45104148a91e527af1b4209c0d972448162aed28fab64 +b05a77baab70683f76209626eaefdda2d36a0b66c780a20142d23c55bd479ddd4ad95b24579384b6cf62c8eb4c92d021 +8e6bc6a7ea2755b4aaa19c1c1dee93811fcde514f03485fdc3252f0ab7f032c315614f6336e57cea25dcfb8fb6084eeb +b656a27d06aade55eadae2ad2a1059198918ea6cc3fd22c0ed881294d34d5ac7b5e4700cc24350e27d76646263b223aa +a296469f24f6f56da92d713afcd4dd606e7da1f79dc4e434593c53695847eefc81c7c446486c4b3b8c8d00c90c166f14 +87a326f57713ac2c9dffeb3af44b9f3c613a8f952676fc46343299122b47ee0f8d792abaa4b5db6451ced5dd153aabd0 +b689e554ba9293b9c1f6344a3c8fcb6951d9f9eac4a2e2df13de021aade7c186be27500e81388e5b8bcab4c80f220a31 +87ae0aa0aa48eac53d1ca5a7b93917de12db9e40ceabf8fdb40884ae771cfdf095411deef7c9f821af0b7070454a2608 +a71ffa7eae8ace94e6c3581d4cb2ad25d48cbd27edc9ec45baa2c8eb932a4773c3272b2ffaf077b40f76942a1f3af7f2 +94c218c91a9b73da6b7a495b3728f3028df8ad9133312fc0c03e8c5253b7ccb83ed14688fd4602e2fd41f29a0bc698bd +ae1e77b90ca33728af07a4c03fb2ef71cd92e2618e7bf8ed4d785ce90097fc4866c29999eb84a6cf1819d75285a03af2 +b7a5945b277dab9993cf761e838b0ac6eaa903d7111fca79f9fde3d4285af7a89bf6634a71909d095d7619d913972c9c +8c43b37be02f39b22029b20aca31bff661abce4471dca88aa3bddefd9c92304a088b2dfc8c4795acc301ca3160656af2 +b32e5d0fba024554bd5fe8a793ebe8003335ddd7f585876df2048dcf759a01285fecb53daae4950ba57f3a282a4d8495 +85ea7fd5e10c7b659df5289b2978b2c89e244f269e061b9a15fcab7983fc1962b63546e82d5731c97ec74b6804be63ef +96b89f39181141a7e32986ac02d7586088c5a9662cec39843f397f3178714d02f929af70630c12cbaba0268f8ba2d4fa +929ab1a2a009b1eb37a2817c89696a06426529ebe3f306c586ab717bd34c35a53eca2d7ddcdef36117872db660024af9 +a696dccf439e9ca41511e16bf3042d7ec0e2f86c099e4fc8879d778a5ea79e33aa7ce96b23dc4332b7ba26859d8e674d +a8fe69a678f9a194b8670a41e941f0460f6e2dbc60470ab4d6ae2679cc9c6ce2c3a39df2303bee486dbfde6844e6b31a +95f58f5c82de2f2a927ca99bf63c9fc02e9030c7e46d0bf6b67fe83a448d0ae1c99541b59caf0e1ccab8326231af09a5 +a57badb2c56ca2c45953bd569caf22968f76ed46b9bac389163d6fe22a715c83d5e94ae8759b0e6e8c2f27bff7748f3f +868726fd49963b24acb5333364dffea147e98f33aa19c7919dc9aca0fd26661cfaded74ede7418a5fadbe7f5ae67b67b +a8d8550dcc64d9f1dd7bcdab236c4122f2b65ea404bb483256d712c7518f08bb028ff8801f1da6aed6cbfc5c7062e33b +97e25a87dae23155809476232178538d4bc05d4ff0882916eb29ae515f2a62bfce73083466cc0010ca956aca200aeacc +b4ea26be3f4bd04aa82d7c4b0913b97bcdf5e88b76c57eb1a336cbd0a3eb29de751e1bc47c0e8258adec3f17426d0c71 +99ee555a4d9b3cf2eb420b2af8e3bc99046880536116d0ce7193464ac40685ef14e0e3c442f604e32f8338cb0ef92558 +8c64efa1da63cd08f319103c5c7a761221080e74227bbc58b8fb35d08aa42078810d7af3e60446cbaff160c319535648 +8d9fd88040076c28420e3395cbdfea402e4077a3808a97b7939d49ecbcf1418fe50a0460e1c1b22ac3f6e7771d65169a +ae3c19882d7a9875d439265a0c7003c8d410367627d21575a864b9cb4918de7dbdb58a364af40c5e045f3df40f95d337 +b4f7bfacab7b2cafe393f1322d6dcc6f21ffe69cd31edc8db18c06f1a2b512c27bd0618091fd207ba8df1808e9d45914 +94f134acd0007c623fb7934bcb65ef853313eb283a889a3ffa79a37a5c8f3665f3d5b4876bc66223610c21dc9b919d37 +aa15f74051171daacdc1f1093d3f8e2d13da2833624b80a934afec86fc02208b8f55d24b7d66076444e7633f46375c6a +a32d6bb47ef9c836d9d2371807bafbbbbb1ae719530c19d6013f1d1f813c49a60e4fa51d83693586cba3a840b23c0404 +b61b3599145ea8680011aa2366dc511a358b7d67672d5b0c5be6db03b0efb8ca5a8294cf220ea7409621f1664e00e631 +859cafc3ee90b7ececa1ed8ef2b2fc17567126ff10ca712d5ffdd16aa411a5a7d8d32c9cab1fbf63e87dce1c6e2f5f53 +a2fef1b0b2874387010e9ae425f3a9676d01a095d017493648bcdf3b31304b087ccddb5cf76abc4e1548b88919663b6b +939e18c73befc1ba2932a65ede34c70e4b91e74cc2129d57ace43ed2b3af2a9cc22a40fbf50d79a63681b6d98852866d +b3b4259d37b1b14aee5b676c9a0dd2d7f679ab95c120cb5f09f9fbf10b0a920cb613655ddb7b9e2ba5af4a221f31303c +997255fe51aaca6e5a9cb3359bcbf25b2bb9e30649bbd53a8a7c556df07e441c4e27328b38934f09c09d9500b5fabf66 +abb91be2a2d860fd662ed4f1c6edeefd4da8dc10e79251cf87f06029906e7f0be9b486462718f0525d5e049472692cb7 +b2398e593bf340a15f7801e1d1fbda69d93f2a32a889ec7c6ae5e8a37567ac3e5227213c1392ee86cfb3b56ec2787839 +8ddf10ccdd72922bed36829a36073a460c2118fc7a56ff9c1ac72581c799b15c762cb56cb78e3d118bb9f6a7e56cb25e +93e6bc0a4708d16387cacd44cf59363b994dc67d7ada7b6d6dbd831c606d975247541b42b2a309f814c1bfe205681fc6 +b93fc35c05998cffda2978e12e75812122831523041f10d52f810d34ff71944979054b04de0117e81ddf5b0b4b3e13c0 +92221631c44d60d68c6bc7b287509f37ee44cbe5fdb6935cee36b58b17c7325098f98f7910d2c3ca5dc885ad1d6dabc7 +a230124424a57fad3b1671f404a94d7c05f4c67b7a8fbacfccea28887b78d7c1ed40b92a58348e4d61328891cd2f6cee +a6a230edb8518a0f49d7231bc3e0bceb5c2ac427f045819f8584ba6f3ae3d63ed107a9a62aad543d7e1fcf1f20605706 +845be1fe94223c7f1f97d74c49d682472585d8f772762baad8a9d341d9c3015534cc83d102113c51a9dea2ab10d8d27b +b44262515e34f2db597c8128c7614d33858740310a49cdbdf9c8677c5343884b42c1292759f55b8b4abc4c86e4728033 +805592e4a3cd07c1844bc23783408310accfdb769cca882ad4d07d608e590a288b7370c2cb327f5336e72b7083a0e30f +95153e8b1140df34ee864f4ca601cb873cdd3efa634af0c4093fbaede36f51b55571ab271e6a133020cd34db8411241f +82878c1285cfa5ea1d32175c9401f3cc99f6bb224d622d3fd98cc7b0a27372f13f7ab463ce3a33ec96f9be38dbe2dfe3 +b7588748f55783077c27fc47d33e20c5c0f5a53fc0ac10194c003aa09b9f055d08ec971effa4b7f760553997a56967b3 +b36b4de6d1883b6951f59cfae381581f9c6352fcfcf1524fccdab1571a20f80441d9152dc6b48bcbbf00371337ca0bd5 +89c5523f2574e1c340a955cbed9c2f7b5fbceb260cb1133160dabb7d41c2f613ec3f6e74bbfab3c4a0a6f0626dbe068f +a52f58cc39f968a9813b1a8ddc4e83f4219e4dd82c7aa1dd083bea7edf967151d635aa9597457f879771759b876774e4 +8300a67c2e2e123f89704abfde095463045dbd97e20d4c1157bab35e9e1d3d18f1f4aaba9cbe6aa2d544e92578eaa1b6 +ac6a7f2918768eb6a43df9d3a8a04f8f72ee52f2e91c064c1c7d75cad1a3e83e5aba9fe55bb94f818099ac91ccf2e961 +8d64a2b0991cf164e29835c8ddef6069993a71ec2a7de8157bbfa2e00f6367be646ed74cbaf524f0e9fe13fb09fa15fd +8b2ffe5a545f9f680b49d0a9797a4a11700a2e2e348c34a7a985fc278f0f12def6e06710f40f9d48e4b7fbb71e072229 +8ab8f71cd337fa19178924e961958653abf7a598e3f022138b55c228440a2bac4176cea3aea393549c03cd38a13eb3fc +8419d28318c19ea4a179b7abb43669fe96347426ef3ac06b158d79c0acf777a09e8e770c2fb10e14b3a0421705990b23 +8bacdac310e1e49660359d0a7a17fe3d334eb820e61ae25e84cb52f863a2f74cbe89c2e9fc3283745d93a99b79132354 +b57ace3fa2b9f6b2db60c0d861ace7d7e657c5d35d992588aeed588c6ce3a80b6f0d49f8a26607f0b17167ab21b675e4 +83e265cde477f2ecc164f49ddc7fb255bb05ff6adc347408353b7336dc3a14fdedc86d5a7fb23f36b8423248a7a67ed1 +a60ada971f9f2d79d436de5d3d045f5ab05308cae3098acaf5521115134b2a40d664828bb89895840db7f7fb499edbc5 +a63eea12efd89b62d3952bf0542a73890b104dd1d7ff360d4755ebfa148fd62de668edac9eeb20507967ea37fb220202 +a0275767a270289adc991cc4571eff205b58ad6d3e93778ddbf95b75146d82517e8921bd0d0564e5b75fa0ccdab8e624 +b9b03fd3bf07201ba3a039176a965d736b4ef7912dd9e9bf69fe1b57c330a6aa170e5521fe8be62505f3af81b41d7806 +a95f640e26fb1106ced1729d6053e41a16e4896acac54992279ff873e5a969aad1dcfa10311e28b8f409ac1dab7f03bb +b144778921742418053cb3c70516c63162c187f00db2062193bb2c14031075dbe055d020cde761b26e8c58d0ea6df2c1 +8432fbb799e0435ef428d4fefc309a05dd589bce74d7a87faf659823e8c9ed51d3e42603d878e80f439a38be4321c2fa +b08ddef14e42d4fd5d8bf39feb7485848f0060d43b51ed5bdda39c05fe154fb111d29719ee61a23c392141358c0cfcff +8ae3c5329a5e025b86b5370e06f5e61177df4bda075856fade20a17bfef79c92f54ed495f310130021ba94fb7c33632b +92b6d3c9444100b4d7391febfc1dddaa224651677c3695c47a289a40d7a96d200b83b64e6d9df51f534564f272a2c6c6 +b432bc2a3f93d28b5e506d68527f1efeb2e2570f6be0794576e2a6ef9138926fdad8dd2eabfa979b79ab7266370e86bc +8bc315eacedbcfc462ece66a29662ca3dcd451f83de5c7626ef8712c196208fb3d8a0faf80b2e80384f0dd9772f61a23 +a72375b797283f0f4266dec188678e2b2c060dfed5880fc6bb0c996b06e91a5343ea2b695adaab0a6fd183b040b46b56 +a43445036fbaa414621918d6a897d3692fdae7b2961d87e2a03741360e45ebb19fcb1703d23f1e15bb1e2babcafc56ac +b9636b2ffe305e63a1a84bd44fb402442b1799bd5272638287aa87ca548649b23ce8ce7f67be077caed6aa2dbc454b78 +99a30bf0921d854c282b83d438a79f615424f28c2f99d26a05201c93d10378ab2cd94a792b571ddae5d4e0c0013f4006 +8648e3c2f93d70b392443be116b48a863e4b75991bab5db656a4ef3c1e7f645e8d536771dfe4e8d1ceda3be8d32978b0 +ab50dc9e6924c1d2e9d2e335b2d679fc7d1a7632e84964d3bac0c9fe57e85aa5906ec2e7b0399d98ddd022e9b19b5904 +ab729328d98d295f8f3272afaf5d8345ff54d58ff9884da14f17ecbdb7371857fdf2f3ef58080054e9874cc919b46224 +83fa5da7592bd451cad3ad7702b4006332b3aae23beab4c4cb887fa6348317d234bf62a359e665b28818e5410c278a09 +8bdbff566ae9d368f114858ef1f009439b3e9f4649f73efa946e678d6c781d52c69af195df0a68170f5f191b2eac286b +91245e59b4425fd4edb2a61d0d47c1ccc83d3ced8180de34887b9655b5dcda033d48cde0bdc3b7de846d246c053a02e8 +a2cb00721e68f1cad8933947456f07144dc69653f96ceed845bd577d599521ba99cdc02421118971d56d7603ed118cbf +af8cd66d303e808b22ec57860dd909ca64c27ec2c60e26ffecfdc1179d8762ffd2739d87b43959496e9fee4108df71df +9954136812dffcd5d3f167a500e7ab339c15cfc9b3398d83f64b0daa3dd5b9a851204f424a3493b4e326d3de81e50a62 +93252254d12511955f1aa464883ad0da793f84d900fea83e1df8bca0f2f4cf5b5f9acbaec06a24160d33f908ab5fea38 +997cb55c26996586ba436a95566bd535e9c22452ca5d2a0ded2bd175376557fa895f9f4def4519241ff386a063f2e526 +a12c78ad451e0ac911260ade2927a768b50cb4125343025d43474e7f465cdc446e9f52a84609c5e7e87ae6c9b3f56cda +a789d4ca55cbba327086563831b34487d63d0980ba8cf55197c016702ed6da9b102b1f0709ce3da3c53ff925793a3d73 +a5d76acbb76741ce85be0e655b99baa04f7f587347947c0a30d27f8a49ae78cce06e1cde770a8b618d3db402be1c0c4b +873c0366668c8faddb0eb7c86f485718d65f8c4734020f1a18efd5fa123d3ea8a990977fe13592cd01d17e60809cb5ff +b659b71fe70f37573ff7c5970cc095a1dc0da3973979778f80a71a347ef25ad5746b2b9608bad4ab9a4a53a4d7df42d7 +a34cbe05888e5e5f024a2db14cb6dcdc401a9cbd13d73d3c37b348f68688f87c24ca790030b8f84fef9e74b4eab5e412 +94ce8010f85875c045b0f014db93ef5ab9f1f6842e9a5743dce9e4cb872c94affd9e77c1f1d1ab8b8660b52345d9acb9 +adefa9b27a62edc0c5b019ddd3ebf45e4de846165256cf6329331def2e088c5232456d3de470fdce3fa758bfdd387512 +a6b83821ba7c1f83cc9e4529cf4903adb93b26108e3d1f20a753070db072ad5a3689643144bdd9c5ea06bb9a7a515cd0 +a3a9ddedc2a1b183eb1d52de26718151744db6050f86f3580790c51d09226bf05f15111691926151ecdbef683baa992c +a64bac89e7686932cdc5670d07f0b50830e69bfb8c93791c87c7ffa4913f8da881a9d8a8ce8c1a9ce5b6079358c54136 +a77b5a63452cb1320b61ab6c7c2ef9cfbcade5fd4727583751fb2bf3ea330b5ca67757ec1f517bf4d503ec924fe32fbd +8746fd8d8eb99639d8cd0ca34c0d9c3230ed5a312aab1d3d925953a17973ee5aeb66e68667e93caf9cb817c868ea8f3d +88a2462a26558fc1fbd6e31aa8abdc706190a17c27fdc4217ffd2297d1b1f3321016e5c4b2384c5454d5717dc732ed03 +b78893a97e93d730c8201af2e0d3b31cb923d38dc594ffa98a714e627c473d42ea82e0c4d2eeb06862ee22a9b2c54588 +920cc8b5f1297cf215a43f6fc843e379146b4229411c44c0231f6749793d40f07b9af7699fd5d21fd69400b97febe027 +a0f0eafce1e098a6b58c7ad8945e297cd93aaf10bc55e32e2e32503f02e59fc1d5776936577d77c0b1162cb93b88518b +98480ba0064e97a2e7a6c4769b4d8c2a322cfc9a3b2ca2e67e9317e2ce04c6e1108169a20bd97692e1cb1f1423b14908 +83dbbb2fda7e287288011764a00b8357753a6a44794cc8245a2275237f11affdc38977214e463ad67aec032f3dfa37e9 +86442fff37598ce2b12015ff19b01bb8a780b40ad353d143a0f30a06f6d23afd5c2b0a1253716c855dbf445cc5dd6865 +b8a4c60c5171189414887847b9ed9501bff4e4c107240f063e2d254820d2906b69ef70406c585918c4d24f1dd052142b +919f33a98e84015b2034b57b5ffe9340220926b2c6e45f86fd79ec879dbe06a148ae68b77b73bf7d01bd638a81165617 +95c13e78d89474a47fbc0664f6f806744b75dede95a479bbf844db4a7f4c3ae410ec721cb6ffcd9fa9c323da5740d5ae +ab7151acc41fffd8ec6e90387700bcd7e1cde291ea669567295bea1b9dd3f1df2e0f31f3588cd1a1c08af8120aca4921 +80e74c5c47414bd6eeef24b6793fb1fa2d8fb397467045fcff887c52476741d5bc4ff8b6d3387cb53ad285485630537f +a296ad23995268276aa351a7764d36df3a5a3cffd7dbeddbcea6b1f77adc112629fdeffa0918b3242b3ccd5e7587e946 +813d2506a28a2b01cb60f49d6bd5e63c9b056aa56946faf2f33bd4f28a8d947569cfead3ae53166fc65285740b210f86 +924b265385e1646287d8c09f6c855b094daaee74b9e64a0dddcf9ad88c6979f8280ba30c8597b911ef58ddb6c67e9fe3 +8d531513c70c2d3566039f7ca47cd2352fd2d55b25675a65250bdb8b06c3843db7b2d29c626eed6391c238fc651cf350 +82b338181b62fdc81ceb558a6843df767b6a6e3ceedc5485664b4ea2f555904b1a45fbb35f6cf5d96f27da10df82a325 +92e62faaedea83a37f314e1d3cb4faaa200178371d917938e59ac35090be1db4b4f4e0edb78b9c991de202efe4f313d8 +99d645e1b642c2dc065bac9aaa0621bc648c9a8351efb6891559c3a41ba737bd155fb32d7731950514e3ecf4d75980e4 +b34a13968b9e414172fb5d5ece9a39cf2eb656128c3f2f6cc7a9f0c69c6bae34f555ecc8f8837dc34b5e470e29055c78 +a2a0bb7f3a0b23a2cbc6585d59f87cd7e56b2bbcb0ae48f828685edd9f7af0f5edb4c8e9718a0aaf6ef04553ba71f3b7 +8e1a94bec053ed378e524b6685152d2b52d428266f2b6eadd4bcb7c4e162ed21ab3e1364879673442ee2162635b7a4d8 +9944adaff14a85eab81c73f38f386701713b52513c4d4b838d58d4ffa1d17260a6d056b02334850ea9a31677c4b078bd +a450067c7eceb0854b3eca3db6cf38669d72cb7143c3a68787833cbca44f02c0be9bfbe082896f8a57debb13deb2afb1 +8be4ad3ac9ef02f7df09254d569939757101ee2eda8586fefcd8c847adc1efe5bdcb963a0cafa17651befaafb376a531 +90f6de91ea50255f148ac435e08cf2ac00c772a466e38155bd7e8acf9197af55662c7b5227f88589b71abe9dcf7ba343 +86e5a24f0748b106dee2d4d54e14a3b0af45a96cbee69cac811a4196403ebbee17fd24946d7e7e1b962ac7f66dbaf610 +afdd96fbcda7aa73bf9eeb2292e036c25753d249caee3b9c013009cc22e10d3ec29e2aa6ddbb21c4e949b0c0bccaa7f4 +b5a4e7436d5473647c002120a2cb436b9b28e27ad4ebdd7c5f122b91597c507d256d0cbd889d65b3a908531936e53053 +b632414c3da704d80ac2f3e5e0e9f18a3637cdc2ebeb613c29300745582427138819c4e7b0bec3099c1b8739dac1807b +a28df1464d3372ce9f37ef1db33cc010f752156afae6f76949d98cd799c0cf225c20228ae86a4da592d65f0cffe3951b +898b93d0a31f7d3f11f253cb7a102db54b669fd150da302d8354d8e02b1739a47cb9bd88015f3baf12b00b879442464e +96fb88d89a12049091070cb0048a381902965e67a8493e3991eaabe5d3b7ff7eecd5c94493a93b174df3d9b2c9511755 +b899cb2176f59a5cfba3e3d346813da7a82b03417cad6342f19cc8f12f28985b03bf031e856a4743fd7ebe16324805b0 +a60e2d31bc48e0c0579db15516718a03b73f5138f15037491f4dae336c904e312eda82d50862f4debd1622bb0e56d866 +979fc8b987b5cef7d4f4b58b53a2c278bd25a5c0ea6f41c715142ea5ff224c707de38451b0ad3aa5e749aa219256650a +b2a75bff18e1a6b9cf2a4079572e41205741979f57e7631654a3c0fcec57c876c6df44733c9da3d863db8dff392b44a3 +b7a0f0e811222c91e3df98ff7f286b750bc3b20d2083966d713a84a2281744199e664879401e77470d44e5a90f3e5181 +82b74ba21c9d147fbc338730e8f1f8a6e7fc847c3110944eb17a48bea5e06eecded84595d485506d15a3e675fd0e5e62 +a7f44eef817d5556f0d1abcf420301217d23c69dd2988f44d91ea1f1a16c322263cbacd0f190b9ba22b0f141b9267b4f +aadb68164ede84fc1cb3334b3194d84ba868d5a88e4c9a27519eef4923bc4abf81aab8114449496c073c2a6a0eb24114 +b5378605fabe9a8c12a5dc55ef2b1de7f51aedb61960735c08767a565793cea1922a603a6983dc25f7cea738d0f7c40d +a97a4a5cd8d51302e5e670aee78fe6b5723f6cc892902bbb4f131e82ca1dfd5de820731e7e3367fb0c4c1922a02196e3 +8bdfeb15c29244d4a28896f2b2cb211243cd6a1984a3f5e3b0ebe5341c419beeab3304b390a009ffb47588018034b0ea +a9af3022727f2aa2fca3b096968e97edad3f08edcbd0dbca107b892ae8f746a9c0485e0d6eb5f267999b23a845923ed0 +8e7594034feef412f055590fbb15b6322dc4c6ab7a4baef4685bd13d71a83f7d682b5781bdfa0d1c659489ce9c2b8000 +84977ca6c865ebee021c58106c1a4ad0c745949ecc5332948002fd09bd9b890524878d0c29da96fd11207621136421fe +8687551a79158e56b2375a271136756313122132a6670fa51f99a1b5c229ed8eea1655a734abae13228b3ebfd2a825dd +a0227d6708979d99edfc10f7d9d3719fd3fc68b0d815a7185b60307e4c9146ad2f9be2b8b4f242e320d4288ceeb9504c +89f75583a16735f9dd8b7782a130437805b34280ccea8dac6ecaee4b83fe96947e7b53598b06fecfffdf57ffc12cc445 +a0056c3353227f6dd9cfc8e3399aa5a8f1d71edf25d3d64c982910f50786b1e395c508d3e3727ac360e3e040c64b5298 +b070e61a6d813626144b312ded1788a6d0c7cec650a762b2f8df6e4743941dd82a2511cd956a3f141fc81e15f4e092da +b4e6db232e028a1f989bb5fc13416711f42d389f63564d60851f009dcffac01acfd54efa307aa6d4c0f932892d4e62b0 +89b5991a67db90024ddd844e5e1a03ef9b943ad54194ae0a97df775dde1addf31561874f4e40fbc37a896630f3bbda58 +ad0e8442cb8c77d891df49cdb9efcf2b0d15ac93ec9be1ad5c3b3cca1f4647b675e79c075335c1f681d56f14dc250d76 +b5d55a6ae65bb34dd8306806cb49b5ccb1c83a282ee47085cf26c4e648e19a52d9c422f65c1cd7e03ca63e926c5e92ea +b749501347e5ec07e13a79f0cb112f1b6534393458b3678a77f02ca89dca973fa7b30e55f0b25d8b92b97f6cb0120056 +94144b4a3ffc5eec6ba35ce9c245c148b39372d19a928e236a60e27d7bc227d18a8cac9983851071935d8ffb64b3a34f +92bb4f9f85bc8c028a3391306603151c6896673135f8a7aefedd27acb322c04ef5dac982fc47b455d6740023e0dd3ea3 +b9633a4a101461a782fc2aa092e9dbe4e2ad00987578f18cd7cf0021a909951d60fe79654eb7897806795f93c8ff4d1c +809f0196753024821b48a016eca5dbb449a7c55750f25981bb7a4b4c0e0846c09b8f6128137905055fc43a3f0deb4a74 +a27dc9cdd1e78737a443570194a03d89285576d3d7f3a3cf15cc55b3013e42635d4723e2e8fe1d0b274428604b630db9 +861f60f0462e04cd84924c36a28163def63e777318d00884ab8cb64c8df1df0bce5900342163edb60449296484a6c5bf +b7bc23fb4e14af4c4704a944253e760adefeca8caee0882b6bbd572c84434042236f39ae07a8f21a560f486b15d82819 +b9a6eb492d6dd448654214bd01d6dc5ff12067a11537ab82023fc16167507ee25eed2c91693912f4155d1c07ed9650b3 +97678af29c68f9a5e213bf0fb85c265303714482cfc4c2c00b4a1e8a76ed08834ee6af52357b143a1ca590fb0265ea5a +8a15b499e9eca5b6cac3070b5409e8296778222018ad8b53a5d1f6b70ad9bb10c68a015d105c941ed657bf3499299e33 +b487fefede2e8091f2c7bfe85770db2edff1db83d4effe7f7d87bff5ab1ace35e9b823a71adfec6737fede8d67b3c467 +8b51b916402aa2c437fce3bcad6dad3be8301a1a7eab9d163085b322ffb6c62abf28637636fe6114573950117fc92898 +b06a2106d031a45a494adec0881cb2f82275dff9dcdd2bc16807e76f3bec28a6734edd3d54f0be8199799a78cd6228ad +af0a185391bbe2315eb97feac98ad6dd2e5d931d012c621abd6e404a31cc188b286fef14871762190acf086482b2b5e2 +8e78ee8206506dd06eb7729e32fceda3bebd8924a64e4d8621c72e36758fda3d0001af42443851d6c0aea58562870b43 +a1ba52a569f0461aaf90b49b92be976c0e73ec4a2c884752ee52ffb62dd137770c985123d405dfb5de70692db454b54a +8d51b692fa1543c51f6b62b9acb8625ed94b746ef96c944ca02859a4133a5629da2e2ce84e111a7af8d9a5b836401c64 +a7a20d45044cf6492e0531d0b8b26ffbae6232fa05a96ed7f06bdb64c2b0f5ca7ec59d5477038096a02579e633c7a3ff +84df867b98c53c1fcd4620fef133ee18849c78d3809d6aca0fb6f50ff993a053a455993f216c42ab6090fa5356b8d564 +a7227c439f14c48e2577d5713c97a5205feb69acb0b449152842e278fa71e8046adfab468089c8b2288af1fc51fa945b +855189b3a105670779997690876dfaa512b4a25a24931a912c2f0f1936971d2882fb4d9f0b3d9daba77eaf660e9d05d5 +b5696bd6706de51c502f40385f87f43040a5abf99df705d6aac74d88c913b8ecf7a99a63d7a37d9bdf3a941b9e432ff5 +ab997beb0d6df9c98d5b49864ef0b41a2a2f407e1687dfd6089959757ba30ed02228940b0e841afe6911990c74d536c4 +b36b65f85546ebfdbe98823d5555144f96b4ab39279facd19c0de3b8919f105ba0315a0784dce4344b1bc62d8bb4a5a3 +b8371f0e4450788720ac5e0f6cd3ecc5413d33895083b2c168d961ec2b5c3de411a4cc0712481cbe8df8c2fa1a7af006 +98325d8026b810a8b7a114171ae59a57e8bbc9848e7c3df992efc523621729fd8c9f52114ce01d7730541a1ada6f1df1 +8d0e76dbd37806259486cd9a31bc8b2306c2b95452dc395546a1042d1d17863ef7a74c636b782e214d3aa0e8d717f94a +a4e15ead76da0214d702c859fb4a8accdcdad75ed08b865842bd203391ec4cba2dcc916455e685f662923b96ee0c023f +8618190972086ebb0c4c1b4a6c94421a13f378bc961cc8267a301de7390c5e73c3333864b3b7696d81148f9d4843fd02 +85369d6cc7342e1aa15b59141517d8db8baaaeb7ab9670f3ba3905353948d575923d283b7e5a05b13a30e7baf1208a86 +87c51ef42233c24a6da901f28c9a075d9ba3c625687c387ad6757b72ca6b5a8885e6902a3082da7281611728b1e45f26 +aa6348a4f71927a3106ad0ea8b02fc8d8c65531e4ab0bd0a17243e66f35afe252e40ab8eef9f13ae55a72566ffdaff5c +96a3bc976e9d03765cc3fee275fa05b4a84c94fed6b767e23ca689394501e96f56f7a97cffddc579a6abff632bf153be +97dbf96c6176379fdb2b888be4e757b2bca54e74124bd068d3fa1dbd82a011bbeb75079da38e0cd22a761fe208ecad9b +b70cf0a1d14089a4129ec4e295313863a59da8c7e26bf74cc0e704ed7f0ee4d7760090d0ddf7728180f1bf2c5ac64955 +882d664714cc0ffe53cbc9bef21f23f3649824f423c4dbad1f893d22c4687ab29583688699efc4d5101aa08b0c3e267a +80ecb7cc963e677ccaddbe3320831dd6ee41209acf4ed41b16dc4817121a3d86a1aac9c4db3d8c08a55d28257088af32 +a25ba667d832b145f9ce18c3f9b1bd00737aa36db020e1b99752c8ef7d27c6c448982bd8d352e1b6df266b8d8358a8d5 +83734841c13dee12759d40bdd209b277e743b0d08cc0dd1e0b7afd2d65bfa640400eefcf6be4a52e463e5b3d885eeac6 +848d16505b04804afc773aebabb51b36fd8aacfbb0e09b36c0d5d57df3c0a3b92f33e7d5ad0a7006ec46ebb91df42b8c +909a8d793f599e33bb9f1dc4792a507a97169c87cd5c087310bc05f30afcd247470b4b56dec59894c0fb1d48d39bb54e +8e558a8559df84a1ba8b244ece667f858095c50bb33a5381e60fcc6ba586b69693566d8819b4246a27287f16846c1dfa +84d6b69729f5aaa000cd710c2352087592cfbdf20d5e1166977e195818e593fa1a50d1e04566be23163a2523dc1612f1 +9536d262b7a42125d89f4f32b407d737ba8d9242acfc99d965913ab3e043dcac9f7072a43708553562cac4cba841df30 +9598548923ca119d6a15fd10861596601dd1dedbcccca97bb208cdc1153cf82991ea8cc17686fbaa867921065265970c +b87f2d4af6d026e4d2836bc3d390a4a18e98a6e386282ce96744603bab74974272e97ac2da281afa21885e2cbb3a8001 +991ece62bf07d1a348dd22191868372904b9f8cf065ae7aa4e44fd24a53faf6d851842e35fb472895963aa1992894918 +a8c53dea4c665b30e51d22ca6bc1bc78aaf172b0a48e64a1d4b93439b053877ec26cb5221c55efd64fa841bbf7d5aff4 +93487ec939ed8e740f15335b58617c3f917f72d07b7a369befd479ae2554d04deb240d4a14394b26192efae4d2f4f35d +a44793ab4035443f8f2968a40e043b4555960193ffa3358d22112093aadfe2c136587e4139ffd46d91ed4107f61ea5e0 +b13fe033da5f0d227c75927d3dacb06dbaf3e1322f9d5c7c009de75cdcba5e308232838785ab69a70f0bedea755e003f +970a29b075faccd0700fe60d1f726bdebf82d2cc8252f4a84543ebd3b16f91be42a75c9719a39c4096139f0f31393d58 +a4c3eb1f7160f8216fc176fb244df53008ff32f2892363d85254002e66e2de21ccfe1f3b1047589abee50f29b9d507e3 +8c552885eab04ba40922a8f0c3c38c96089c95ff1405258d3f1efe8d179e39e1295cbf67677894c607ae986e4e6b1fb0 +b3671746fa7f848c4e2ae6946894defadd815230b906b419143523cc0597bc1d6c0a4c1e09d49b66b4a2c11cde3a4de3 +937a249a95813a5e2ef428e355efd202e15a37d73e56cfb7e57ea9f943f2ce5ca8026f2f1fd25bf164ba89d07077d858 +83646bdf6053a04aa9e2f112499769e5bd5d0d10f2e13db3ca89bd45c0b3b7a2d752b7d137fb3909f9c62b78166c9339 +b4eac4b91e763666696811b7ed45e97fd78310377ebea1674b58a2250973f80492ac35110ed1240cd9bb2d17493d708c +82db43a99bc6573e9d92a3fd6635dbbb249ac66ba53099c3c0c8c8080b121dd8243cd5c6e36ba0a4d2525bae57f5c89c +a64d6a264a681b49d134c655d5fc7756127f1ee7c93d328820f32bca68869f53115c0d27fef35fe71f7bc4fdaed97348 +8739b7a9e2b4bc1831e7f04517771bc7cde683a5e74e052542517f8375a2f64e53e0d5ac925ef722327e7bb195b4d1d9 +8f337cdd29918a2493515ebb5cf702bbe8ecb23b53c6d18920cc22f519e276ca9b991d3313e2d38ae17ae8bdfa4f8b7e +b0edeab9850e193a61f138ef2739fc42ceec98f25e7e8403bfd5fa34a7bc956b9d0898250d18a69fa4625a9b3d6129da +a9920f26fe0a6d51044e623665d998745c9eca5bce12051198b88a77d728c8238f97d4196f26e43b24f8841500b998d0 +86e655d61502b979eeeeb6f9a7e1d0074f936451d0a1b0d2fa4fb3225b439a3770767b649256fe481361f481a8dbc276 +84d3b32fa62096831cc3bf013488a9f3f481dfe293ae209ed19585a03f7db8d961a7a9dd0db82bd7f62d612707575d9c +81c827826ec9346995ffccf62a241e3b2d32f7357acd1b1f8f7a7dbc97022d3eb51b8a1230e23ce0b401d2e535e8cd78 +94a1e40c151191c5b055b21e86f32e69cbc751dcbdf759a48580951834b96a1eed75914c0d19a38aefd21fb6c8d43d0c +ab890222b44bc21b71f7c75e15b6c6e16bb03371acce4f8d4353ff3b8fcd42a14026589c5ed19555a3e15e4d18bfc3a3 +accb0be851e93c6c8cc64724cdb86887eea284194b10e7a43c90528ed97e9ec71ca69c6fac13899530593756dd49eab2 +b630220aa9e1829c233331413ee28c5efe94ea8ea08d0c6bfd781955078b43a4f92915257187d8526873e6c919c6a1de +add389a4d358c585f1274b73f6c3c45b58ef8df11f9d11221f620e241bf3579fba07427b288c0c682885a700cc1fa28d +a9fe6ca8bf2961a3386e8b8dcecc29c0567b5c0b3bcf3b0f9169f88e372b80151af883871fc5229815f94f43a6f5b2b0 +ad839ae003b92b37ea431fa35998b46a0afc3f9c0dd54c3b3bf7a262467b13ff3c323ada1c1ae02ac7716528bdf39e3e +9356d3fd0edcbbb65713c0f2a214394f831b26f792124b08c5f26e7f734b8711a87b7c4623408da6a091c9aef1f6af3c +896b25b083c35ac67f0af3784a6a82435b0e27433d4d74cd6d1eafe11e6827827799490fb1c77c11de25f0d75f14e047 +8bfa019391c9627e8e5f05c213db625f0f1e51ec68816455f876c7e55b8f17a4f13e5aae9e3fb9e1cf920b1402ee2b40 +8ba3a6faa6a860a8f3ce1e884aa8769ceded86380a86520ab177ab83043d380a4f535fe13884346c5e51bee68da6ab41 +a8292d0844084e4e3bb7af92b1989f841a46640288c5b220fecfad063ee94e86e13d3d08038ec2ac82f41c96a3bfe14d +8229bb030b2fc566e11fd33c7eab7a1bb7b49fed872ea1f815004f7398cb03b85ea14e310ec19e1f23e0bdaf60f8f76c +8cfbf869ade3ec551562ff7f63c2745cc3a1f4d4dc853a0cd42dd5f6fe54228f86195ea8fe217643b32e9f513f34a545 +ac52a3c8d3270ddfe1b5630159da9290a5ccf9ccbdef43b58fc0a191a6c03b8a5974cf6e2bbc7bd98d4a40a3581482d7 +ab13decb9e2669e33a7049b8eca3ca327c40dea15ad6e0e7fa63ed506db1d258bc36ac88b35f65cae0984e937eb6575d +b5e748eb1a7a1e274ff0cc56311c198f2c076fe4b7e73e5f80396fe85358549df906584e6bb2c8195b3e2be7736850a5 +b5cb911325d8f963c41f691a60c37831c7d3bbd92736efa33d1f77a22b3fde7f283127256c2f47e197571e6fe0b46149 +8a01dc6ed1b55f26427a014faa347130738b191a06b800e32042a46c13f60b49534520214359d68eb2e170c31e2b8672 +a72fa874866e19b2efb8e069328362bf7921ec375e3bcd6b1619384c3f7ee980f6cf686f3544e9374ff54b4d17a1629c +8db21092f7c5f110fba63650b119e82f4b42a997095d65f08f8237b02dd66fdf959f788df2c35124db1dbd330a235671 +8c65d50433d9954fe28a09fa7ba91a70a590fe7ba6b3060f5e4be0f6cef860b9897fa935fb4ebc42133524eb071dd169 +b4614058e8fa21138fc5e4592623e78b8982ed72aa35ee4391b164f00c68d277fa9f9eba2eeefc890b4e86eba5124591 +ab2ad3a1bce2fbd55ca6b7c23786171fe1440a97d99d6df4d80d07dd56ac2d7203c294b32fc9e10a6c259381a73f24a1 +812ae3315fdc18774a8da3713a4679e8ed10b9405edc548c00cacbe25a587d32040566676f135e4723c5dc25df5a22e9 +a464b75f95d01e5655b54730334f443c8ff27c3cb79ec7af4b2f9da3c2039c609908cd128572e1fd0552eb597e8cef8d +a0db3172e93ca5138fe419e1c49a1925140999f6eff7c593e5681951ee0ec1c7e454c851782cbd2b8c9bc90d466e90e0 +806db23ba7d00b87d544eed926b3443f5f9c60da6b41b1c489fba8f73593b6e3b46ebfcab671ee009396cd77d5e68aa1 +8bfdf2c0044cc80260994e1c0374588b6653947b178e8b312be5c2a05e05767e98ea15077278506aee7df4fee1aaf89e +827f6558c16841b5592ff089c9c31e31eb03097623524394813a2e4093ad2d3f8f845504e2af92195aaa8a1679d8d692 +925c4f8eab2531135cd71a4ec88e7035b5eea34ba9d799c5898856080256b4a15ed1a746e002552e2a86c9c157e22e83 +a9f9a368f0e0b24d00a35b325964c85b69533013f9c2cfad9708be5fb87ff455210f8cb8d2ce3ba58ca3f27495552899 +8ac0d3bebc1cae534024187e7c71f8927ba8fcc6a1926cb61c2b6c8f26bb7831019e635a376146c29872a506784a4aaa +97c577be2cbbfdb37ad754fae9df2ada5fc5889869efc7e18a13f8e502fbf3f4067a509efbd46fd990ab47ce9a70f5a8 +935e7d82bca19f16614aa43b4a3474e4d20d064e4bfdf1cea2909e5c9ab72cfe3e54dc50030e41ee84f3588cebc524e9 +941aafc08f7c0d94cebfbb1f0aad5202c02e6e37f2c12614f57e727efa275f3926348f567107ee6d8914dd71e6060271 +af0fbc1ba05b4b5b63399686df3619968be5d40073de0313cbf5f913d3d4b518d4c249cdd2176468ccaa36040a484f58 +a0c414f23f46ca6d69ce74c6f8a00c036cb0edd098af0c1a7d39c802b52cfb2d5dbdf93fb0295453d4646e2af7954d45 +909cf39e11b3875bb63b39687ae1b5d1f5a15445e39bf164a0b14691b4ddb39a8e4363f584ef42213616abc4785b5d66 +a92bac085d1194fbd1c88299f07a061d0bdd3f980b663e81e6254dbb288bf11478c0ee880e28e01560f12c5ccb3c0103 +841705cd5cd76b943e2b7c5e845b9dd3c8defe8ef67e93078d6d5e67ade33ad4b0fd413bc196f93b0a4073c855cd97d4 +8e7eb8364f384a9161e81d3f1d52ceca9b65536ae49cc35b48c3e2236322ba4ae9973e0840802d9fa4f4d82ea833544f +aed3ab927548bc8bec31467ba80689c71a168e34f50dcb6892f19a33a099f5aa6b3f9cb79f5c0699e837b9a8c7f27efe +b8fbf7696210a36e20edabd77839f4dfdf50d6d015cdf81d587f90284a9bcef7d2a1ff520728d7cc69a4843d6c20dedd +a9d533769ce6830211c884ae50a82a7bf259b44ac71f9fb11f0296fdb3981e6b4c1753fe744647b247ebc433a5a61436 +8b4bdf90d33360b7f428c71cde0a49fb733badba8c726876945f58c620ce7768ae0e98fc8c31fa59d8955a4823336bb1 +808d42238e440e6571c59e52a35ae32547d502dc24fd1759d8ea70a7231a95859baf30b490a4ba55fa2f3aaa11204597 +85594701f1d2fee6dc1956bc44c7b31db93bdeec2f3a7d622c1a08b26994760773e3d57521a44cfd7e407ac3fd430429 +a66de045ce7173043a6825e9dc440ac957e2efb6df0a337f4f8003eb0c719d873a52e6eba3cb0d69d977ca37d9187674 +87a1c6a1fdff993fa51efa5c3ba034c079c0928a7d599b906336af7c2dcab9721ceaf3108c646490af9dff9a754f54b3 +926424223e462ceb75aed7c22ade8a7911a903b7e5dd4bc49746ddce8657f4616325cd12667d4393ac52cdd866396d0e +b5dc96106593b42b30f06f0b0a1e0c1aafc70432e31807252d3674f0b1ea5e58eac8424879d655c9488d85a879a3e572 +997ca0987735cc716507cb0124b1d266d218b40c9d8e0ecbf26a1d65719c82a637ce7e8be4b4815d307df717bde7c72a +92994d3f57a569b7760324bb5ae4e8e14e1633d175dab06aa57b8e391540e05f662fdc08b8830f489a063f59b689a688 +a8087fcc6aa4642cb998bea11facfe87eb33b90a9aa428ab86a4124ad032fc7d2e57795311a54ec9f55cc120ebe42df1 +a9bd7d1de6c0706052ca0b362e2e70e8c8f70f1f026ea189b4f87a08ce810297ebfe781cc8004430776c54c1a05ae90c +856d33282e8a8e33a3d237fb0a0cbabaf77ba9edf2fa35a831fdafcadf620561846aa6cbb6bdc5e681118e1245834165 +9524a7aa8e97a31a6958439c5f3339b19370f03e86b89b1d02d87e4887309dbbe9a3a8d2befd3b7ed5143c8da7e0a8ad +824fdf433e090f8acbd258ac7429b21f36f9f3b337c6d0b71d1416a5c88a767883e255b2888b7c906dd2e9560c4af24c +88c7fee662ca7844f42ed5527996b35723abffd0d22d4ca203b9452c639a5066031207a5ae763dbc0865b3299d19b1ec +919dca5c5595082c221d5ab3a5bc230f45da7f6dec4eb389371e142c1b9c6a2c919074842479c2844b72c0d806170c0c +b939be8175715e55a684578d8be3ceff3087f60fa875fff48e52a6e6e9979c955efef8ff67cfa2b79499ea23778e33b0 +873b6db725e7397d11bc9bed9ac4468e36619135be686790a79bc6ed4249058f1387c9a802ea86499f692cf635851066 +aeae06db3ec47e9e5647323fa02fac44e06e59b885ad8506bf71b184ab3895510c82f78b6b22a5d978e8218e7f761e9f +b99c0a8359c72ab88448bae45d4bf98797a26bca48b0d4460cd6cf65a4e8c3dd823970ac3eb774ae5d0cea4e7fadf33e +8f10c8ec41cdfb986a1647463076a533e6b0eec08520c1562401b36bb063ac972aa6b28a0b6ce717254e35940b900e3c +a106d9be199636d7add43b942290269351578500d8245d4aae4c083954e4f27f64740a3138a66230391f2d0e6043a8de +a469997908244578e8909ff57cffc070f1dbd86f0098df3cfeb46b7a085cfecc93dc69ee7cad90ff1dc5a34d50fe580c +a4ef087bea9c20eb0afc0ee4caba7a9d29dfa872137828c721391273e402fb6714afc80c40e98bbd8276d3836bffa080 +b07a013f73cd5b98dae0d0f9c1c0f35bff8a9f019975c4e1499e9bee736ca6fcd504f9bc32df1655ff333062382cff04 +b0a77188673e87cc83348c4cc5db1eecf6b5184e236220c8eeed7585e4b928db849944a76ec60ef7708ef6dac02d5592 +b1284b37e59b529f0084c0dacf0af6c0b91fc0f387bf649a8c74819debf606f7b07fc3e572500016fb145ec2b24e9f17 +97b20b5b4d6b9129da185adfbf0d3d0b0faeba5b9715f10299e48ea0521709a8296a9264ce77c275a59c012b50b6519a +b9d37e946fae5e4d65c1fbfacc8a62e445a1c9d0f882e60cca649125af303b3b23af53c81d7bac544fb7fcfc7a314665 +8e5acaac379f4bb0127efbef26180f91ff60e4c525bc9b798fc50dfaf4fe8a5aa84f18f3d3cfb8baead7d1e0499af753 +b0c0b8ab1235bf1cda43d4152e71efc1a06c548edb964eb4afceb201c8af24240bf8ab5cae30a08604e77432b0a5faf0 +8cc28d75d5c8d062d649cbc218e31c4d327e067e6dbd737ec0a35c91db44fbbd0d40ec424f5ed79814add16947417572 +95ae6219e9fd47efaa9cb088753df06bc101405ba50a179d7c9f7c85679e182d3033f35b00dbba71fdcd186cd775c52e +b5d28fa09f186ebc5aa37453c9b4d9474a7997b8ae92748ecb940c14868792292ac7d10ade01e2f8069242b308cf97e5 +8c922a0faa14cc6b7221f302df3342f38fc8521ec6c653f2587890192732c6da289777a6cd310747ea7b7d104af95995 +b9ad5f660b65230de54de535d4c0fcae5bc6b59db21dea5500fdc12eea4470fb8ea003690fdd16d052523418d5e01e8c +a39a9dd41a0ff78c82979483731f1cd68d3921c3e9965869662c22e02dde3877802e180ba93f06e7346f96d9fa9261d2 +8b32875977ec372c583b24234c27ed73aef00cdff61eb3c3776e073afbdeade548de9497c32ec6d703ff8ad0a5cb7fe4 +9644cbe755a5642fe9d26cfecf170d3164f1848c2c2e271d5b6574a01755f3980b3fc870b98cf8528fef6ecef4210c16 +81ea9d1fdd9dd66d60f40ce0712764b99da9448ae0b300f8324e1c52f154e472a086dda840cb2e0b9813dc8ce8afd4b5 +906aaa4a7a7cdf01909c5cfbc7ded2abc4b869213cbf7c922d4171a4f2e637e56f17020b852ad339d83b8ac92f111666 +939b5f11acbdeff998f2a080393033c9b9d8d5c70912ea651c53815c572d36ee822a98d6dfffb2e339f29201264f2cf4 +aba4898bf1ccea9b9e2df1ff19001e05891581659c1cbbde7ee76c349c7fc7857261d9785823c9463a8aea3f40e86b38 +83ca1a56b8a0be4820bdb5a9346357c68f9772e43f0b887729a50d2eb2a326bbcede676c8bf2e51d7c89bbd8fdb778a6 +94e86e9fe6addfe2c3ee3a547267ed921f4230d877a85bb4442c2d9350c2fa9a9c54e6fe662de82d1a2407e4ab1691c2 +a0cc3bdef671a59d77c6984338b023fa2b431b32e9ed2abe80484d73edc6540979d6f10812ecc06d4d0c5d4eaca7183c +b5343413c1b5776b55ea3c7cdd1f3af1f6bd802ea95effe3f2b91a523817719d2ecc3f8d5f3cc2623ace7e35f99ca967 +92085d1ed0ed28d8cabe3e7ff1905ed52c7ceb1eac5503760c52fb5ee3a726aba7c90b483c032acc3f166b083d7ec370 +8ec679520455275cd957fca8122724d287db5df7d29f1702a322879b127bff215e5b71d9c191901465d19c86c8d8d404 +b65eb2c63d8a30332eb24ee8a0c70156fc89325ebbb38bacac7cf3f8636ad8a472d81ccca80423772abc00192d886d8a +a9fe1c060b974bee4d590f2873b28635b61bfcf614e61ff88b1be3eee4320f4874e21e8d666d8ac8c9aba672efc6ecae +b3fe2a9a389c006a831dea7e777062df84b5c2803f9574d7fbe10b7e1c125817986af8b6454d6be9d931a5ac94cfe963 +95418ad13b734b6f0d33822d9912c4c49b558f68d08c1b34a0127fcfa666bcae8e6fda8832d2c75bb9170794a20e4d7c +a9a7df761e7f18b79494bf429572140c8c6e9d456c4d4e336184f3f51525a65eb9582bea1e601bdb6ef8150b7ca736a5 +a0de03b1e75edf7998c8c1ac69b4a1544a6fa675a1941950297917366682e5644a4bda9cdeedfaf9473d7fccd9080b0c +a61838af8d95c95edf32663a68f007d95167bf6e41b0c784a30b22d8300cfdd5703bd6d16e86396638f6db6ae7e42a85 +8866d62084d905c145ff2d41025299d8b702ac1814a7dec4e277412c161bc9a62fed735536789cb43c88693c6b423882 +91da22c378c81497fe363e7f695c0268443abee50f8a6625b8a41e865638a643f07b157ee566de09ba09846934b4e2d7 +941d21dd57c9496aa68f0c0c05507405fdd413acb59bc668ce7e92e1936c68ec4b065c3c30123319884149e88228f0b2 +a77af9b094bc26966ddf2bf9e1520c898194a5ccb694915950dadc204facbe3066d3d89f50972642d76b14884cfbaa21 +8e76162932346869f4618bde744647f7ab52ab498ad654bdf2a4feeb986ac6e51370841e5acbb589e38b6e7142bb3049 +b60979ace17d6937ece72e4f015da4657a443dd01cebc7143ef11c09e42d4aa8855999a65a79e2ea0067f31c9fc2ab0f +b3e2ffdd5ee6fd110b982fd4fad4b93d0fca65478f986d086eeccb0804960bfaa1919afa743c2239973ea65091fe57d2 +8ce0ce05e7d7160d44574011da687454dbd3c8b8290aa671731b066e2c82f8cf2d63cb8e932d78c6122ec610e44660e6 +ab005dd8d297045c39e2f72fb1c48edb501ccf3575d3d04b9817b3afee3f0bb0f3f53f64bda37d1d9cde545aae999bae +95bd7edb4c4cd60e3cb8a72558845a3cce6bb7032ccdf33d5a49ebb6ddf203bc3c79e7b7e550735d2d75b04c8b2441e8 +889953ee256206284094e4735dbbb17975bafc7c3cb94c9fbfee4c3e653857bfd49e818f64a47567f721b98411a3b454 +b188423e707640ab0e75a061e0b62830cde8afab8e1ad3dae30db69ffae4e2fc005bababbdcbd7213b918ed4f70e0c14 +a97e0fafe011abd70d4f99a0b36638b3d6e7354284588f17a88970ed48f348f88392779e9a038c6cbc9208d998485072 +87db11014a91cb9b63e8dfaa82cdebca98272d89eb445ee1e3ff9dbaf2b3fad1a03b888cffc128e4fe208ed0dddece0f +aad2e40364edd905d66ea4ac9d51f9640d6fda9a54957d26ba233809851529b32c85660fa401dbee3679ec54fa6dd966 +863e99336ca6edf03a5a259e59a2d0f308206e8a2fb320cfc0be06057366df8e0f94b33a28f574092736b3c5ada84270 +b34bcc56a057589f34939a1adc51de4ff6a9f4fee9c7fa9aa131e28d0cf0759a0c871b640162acdfbf91f3f1b59a3703 +935dd28f2896092995c5eff1618e5b6efe7a40178888d7826da9b0503c2d6e68a28e7fac1a334e166d0205f0695ef614 +b842cd5f8f5de5ca6c68cb4a5c1d7b451984930eb4cc18fd0934d52fdc9c3d2d451b1c395594d73bc3451432bfba653f +9014537885ce2debad736bc1926b25fdab9f69b216bf024f589c49dc7e6478c71d595c3647c9f65ff980b14f4bb2283b +8e827ccca1dd4cd21707140d10703177d722be0bbe5cac578db26f1ef8ad2909103af3c601a53795435b27bf95d0c9ed +8a0b8ad4d466c09d4f1e9167410dbe2edc6e0e6229d4b3036d30f85eb6a333a18b1c968f6ca6d6889bb08fecde017ef4 +9241ee66c0191b06266332dc9161dede384c4bb4e116dbd0890f3c3790ec5566da4568243665c4725b718ac0f6b5c179 +aeb4d5fad81d2b505d47958a08262b6f1b1de9373c2c9ba6362594194dea3e002ab03b8cbb43f867be83065d3d370f19 +8781bc83bb73f7760628629fe19e4714b494dbed444c4e4e4729b7f6a8d12ee347841a199888794c2234f51fa26fc2b9 +b58864f0acd1c2afa29367e637cbde1968d18589245d9936c9a489c6c495f54f0113ecdcbe4680ac085dd3c397c4d0c3 +94a24284afaeead61e70f3e30f87248d76e9726759445ca18cdb9360586c60cc9f0ec1c397f9675083e0b56459784e2e +aed358853f2b54dcbddf865e1816c2e89be12e940e1abfa661e2ee63ffc24a8c8096be2072fa83556482c0d89e975124 +b95374e6b4fc0765708e370bc881e271abf2e35c08b056a03b847e089831ef4fe3124b9c5849d9c276eb2e35b3daf264 +b834cdbcfb24c8f84bfa4c552e7fadc0028a140952fd69ed13a516e1314a4cd35d4b954a77d51a1b93e1f5d657d0315d +8fb6d09d23bfa90e7443753d45a918d91d75d8e12ec7d016c0dfe94e5c592ba6aaf483d2f16108d190822d955ad9cdc3 +aa315cd3c60247a6ad4b04f26c5404c2713b95972843e4b87b5a36a89f201667d70f0adf20757ebe1de1b29ae27dda50 +a116862dca409db8beff5b1ccd6301cdd0c92ca29a3d6d20eb8b87f25965f42699ca66974dd1a355200157476b998f3b +b4c2f5fe173c4dc8311b60d04a65ce1be87f070ac42e13cd19c6559a2931c6ee104859cc2520edebbc66a13dc7d30693 +8d4a02bf99b2260c334e7d81775c5cf582b00b0c982ce7745e5a90624919028278f5e9b098573bad5515ce7fa92a80c8 +8543493bf564ce6d97bd23be9bff1aba08bd5821ca834f311a26c9139c92a48f0c2d9dfe645afa95fec07d675d1fd53b +9344239d13fde08f98cb48f1f87d34cf6abe8faecd0b682955382a975e6eed64e863fa19043290c0736261622e00045c +aa49d0518f343005ca72b9e6c7dcaa97225ce6bb8b908ebbe7b1a22884ff8bfb090890364e325a0d414ad180b8f161d1 +907d7fd3e009355ab326847c4a2431f688627faa698c13c03ffdd476ecf988678407f029b8543a475dcb3dafdf2e7a9c +845f1f10c6c5dad2adc7935f5cd2e2b32f169a99091d4f1b05babe7317b9b1cdce29b5e62f947dc621b9acbfe517a258 +8f3be8e3b380ea6cdf9e9c237f5e88fd5a357e5ded80ea1fc2019810814de82501273b4da38916881125b6fa0cfd4459 +b9c7f487c089bf1d20c822e579628db91ed9c82d6ca652983aa16d98b4270c4da19757f216a71b9c13ddee3e6e43705f +8ba2d8c88ad2b872db104ea8ddbb006ec2f3749fd0e19298a804bb3a5d94de19285cc7fb19fee58a66f7851d1a66c39f +9375ecd3ed16786fe161af5d5c908f56eeb467a144d3bbddfc767e90065b7c94fc53431adebecba2b6c9b5821184d36e +a49e069bfadb1e2e8bff6a4286872e2a9765d62f0eaa4fcb0e5af4bbbed8be3510fb19849125a40a8a81d1e33e81c3eb +9522cc66757b386aa6b88619525c8ce47a5c346d590bb3647d12f991e6c65c3ab3c0cfc28f0726b6756c892eae1672be +a9a0f1f51ff877406fa83a807aeb17b92a283879f447b8a2159653db577848cc451cbadd01f70441e351e9ed433c18bc +8ff7533dcff6be8714df573e33f82cf8e9f2bcaaa43e939c4759d52b754e502717950de4b4252fb904560fc31dce94a4 +959724671e265a28d67c29d95210e97b894b360da55e4cf16e6682e7912491ed8ca14bfaa4dce9c25a25b16af580494f +92566730c3002f4046c737032487d0833c971e775de59fe02d9835c9858e2e3bc37f157424a69764596c625c482a2219 +a84b47ceff13ed9c3e5e9cdf6739a66d3e7c2bd8a6ba318fefb1a9aecf653bb2981da6733ddb33c4b0a4523acc429d23 +b4ddf571317e44f859386d6140828a42cf94994e2f1dcbcc9777f4eebbfc64fc1e160b49379acc27c4672b8e41835c5d +8ab95c94072b853d1603fdd0a43b30db617d13c1d1255b99075198e1947bfa5f59aed2b1147548a1b5e986cd9173d15c +89511f2eab33894fd4b3753d24249f410ff7263052c1fef6166fc63a79816656b0d24c529e45ccce6be28de6e375d916 +a0866160ca63d4f2be1b4ea050dac6b59db554e2ebb4e5b592859d8df339b46fd7cb89aaed0951c3ee540aee982c238a +8fcc5cbba1b94970f5ff2eb1922322f5b0aa7d918d4b380c9e7abfd57afd8b247c346bff7b87af82efbce3052511cd1b +99aeb2a5e846b0a2874cca02c66ed40d5569eb65ab2495bc3f964a092e91e1517941f2688e79f8cca49cd3674c4e06dc +b7a096dc3bad5ca49bee94efd884aa3ff5615cf3825cf95fbe0ce132e35f46581d6482fa82666c7ef5f1643eaee8f1ca +94393b1da6eaac2ffd186b7725eca582f1ddc8cdd916004657f8a564a7c588175cb443fc6943b39029f5bbe0add3fad8 +884b85fe012ccbcd849cb68c3ad832d83b3ef1c40c3954ffdc97f103b1ed582c801e1a41d9950f6bddc1d11f19d5ec76 +b00061c00131eded8305a7ce76362163deb33596569afb46fe499a7c9d7a0734c084d336b38d168024c2bb42b58e7660 +a439153ac8e6ca037381e3240e7ba08d056c83d7090f16ed538df25901835e09e27de2073646e7d7f3c65056af6e4ce7 +830fc9ca099097d1f38b90e6843dc86f702be9d20bdacc3e52cae659dc41df5b8d2c970effa6f83a5229b0244a86fe22 +b81ea2ffaaff2bb00dd59a9ab825ba5eed4db0d8ac9c8ed1a632ce8f086328a1cddd045fbe1ace289083c1325881b7e7 +b51ea03c58daf2db32c99b9c4789b183365168cb5019c72c4cc91ac30b5fb7311d3db76e6fa41b7cd4a8c81e2f6cdc94 +a4170b2c6d09ca5beb08318730419b6f19215ce6c631c854116f904be3bc30dd85a80c946a8ab054d3e307afaa3f8fbc +897cc42ff28971ff54d2a55dd6b35cfb8610ac902f3c06e3a5cea0e0a257e870c471236a8e84709211c742a09c5601a6 +a18f2e98d389dace36641621488664ecbb422088ab03b74e67009b8b8acacaaa24fdcf42093935f355207d934adc52a8 +92adcfb678cc2ba19c866f3f2b988fdcb4610567f3ab436cc0cb9acaf5a88414848d71133ebdbec1983e38e6190f1b5f +a86d43c2ce01b366330d3b36b3ca85f000c3548b8297e48478da1ee7d70d8576d4650cba7852ed125c0d7cb6109aa7f3 +8ed31ceed9445437d7732dce78a762d72ff32a7636bfb3fd7974b7ae15db414d8184a1766915244355deb354fbc5803b +9268f70032584f416e92225d65af9ea18c466ebc7ae30952d56a4e36fd9ea811dde0a126da9220ba3c596ec54d8a335e +9433b99ee94f2d3fbdd63b163a2bdf440379334c52308bd24537f7defd807145a062ff255a50d119a7f29f4b85d250e3 +90ce664f5e4628a02278f5cf5060d1a34f123854634b1870906e5723ac9afd044d48289be283b267d45fcbf3f4656aaf +aaf21c4d59378bb835d42ae5c5e5ab7a3c8c36a59e75997989313197752b79a472d866a23683b329ea69b048b87fa13e +b83c0589b304cec9ede549fde54f8a7c2a468c6657da8c02169a6351605261202610b2055c639b9ed2d5b8c401fb8f56 +9370f326ea0f170c2c05fe2c5a49189f20aec93b6b18a5572a818cd4c2a6adb359e68975557b349fb54f065d572f4c92 +ac3232fa5ce6f03fca238bef1ce902432a90b8afce1c85457a6bee5571c033d4bceefafc863af04d4e85ac72a4d94d51 +80d9ea168ff821b22c30e93e4c7960ce3ad3c1e6deeebedd342a36d01bd942419b187e2f382dbfd8caa34cca08d06a48 +a387a3c61676fb3381eefa2a45d82625635a666e999aba30e3b037ec9e040f414f9e1ad9652abd3bcad63f95d85038db +a1b229fe32121e0b391b0f6e0180670b9dc89d79f7337de4c77ea7ad0073e9593846f06797c20e923092a08263204416 +92164a9d841a2b828cedf2511213268b698520f8d1285852186644e9a0c97512cafa4bfbe29af892c929ebccd102e998 +82ee2fa56308a67c7db4fd7ef539b5a9f26a1c2cc36da8c3206ba4b08258fbb3cec6fe5cdbd111433fb1ba2a1e275927 +8c77bfe9e191f190a49d46f05600603fa42345592539b82923388d72392404e0b29a493a15e75e8b068dddcd444c2928 +80b927f93ccf79dcf5c5b20bcf5a7d91d7a17bc0401bb7cc9b53a6797feac31026eb114257621f5a64a52876e4474cc1 +b6b68b6501c37804d4833d5a063dd108a46310b1400549074e3cac84acc6d88f73948b7ad48d686de89c1ec043ae8c1a +ab3da00f9bdc13e3f77624f58a3a18fc3728956f84b5b549d62f1033ae4b300538e53896e2d943f160618e05af265117 +b6830e87233b8eace65327fdc764159645b75d2fd4024bf8f313b2dd5f45617d7ecfb4a0b53ccafb5429815a9a1adde6 +b9251cfe32a6dc0440615aadcd98b6b1b46e3f4e44324e8f5142912b597ee3526bea2431e2b0282bb58f71be5b63f65e +af8d70711e81cdddfb39e67a1b76643292652584c1ce7ce4feb1641431ad596e75c9120e85f1a341e7a4da920a9cdd94 +98cd4e996594e89495c078bfd52a4586b932c50a449a7c8dfdd16043ca4cda94dafbaa8ad1b44249c99bbcc52152506e +b9fc6d1c24f48404a4a64fbe3e43342738797905db46e4132aee5f086aaa4c704918ad508aaefa455cfe1b36572e6242 +a365e871d30ba9291cedaba1be7b04e968905d003e9e1af7e3b55c5eb048818ae5b913514fb08b24fb4fbdccbb35d0b8 +93bf99510971ea9af9f1e364f1234c898380677c8e8de9b0dd24432760164e46c787bc9ec42a7ad450500706cf247b2d +b872f825a5b6e7b9c7a9ddfeded3516f0b1449acc9b4fd29fc6eba162051c17416a31e5be6d3563f424d28e65bab8b8f +b06b780e5a5e8eb4f4c9dc040f749cf9709c8a4c9ef15e925f442b696e41e5095db0778a6c73bcd329b265f2c6955c8b +848f1a981f5fc6cd9180cdddb8d032ad32cdfa614fc750d690dbae36cc0cd355cbf1574af9b3ffc8b878f1b2fafb9544 +a03f48cbff3e9e8a3a655578051a5ae37567433093ac500ed0021c6250a51b767afac9bdb194ee1e3eac38a08c0eaf45 +b5be78ce638ff8c4aa84352b536628231d3f7558c5be3bf010b28feac3022e64691fa672f358c8b663904aebe24a54ed +a9d4da70ff676fa55d1728ba6ab03b471fa38b08854d99e985d88c2d050102d8ccffbe1c90249a5607fa7520b15fe791 +8fe9f7092ffb0b69862c8e972fb1ecf54308c96d41354ed0569638bb0364f1749838d6d32051fff1599112978c6e229c +ae6083e95f37770ecae0df1e010456f165d96cfe9a7278c85c15cffd61034081ce5723e25e2bede719dc9341ec8ed481 +a260891891103089a7afbd9081ea116cfd596fd1015f5b65e10b0961eb37fab7d09c69b7ce4be8bf35e4131848fb3fe4 +8d729fa32f6eb9fd2f6a140bef34e8299a2f3111bffd0fe463aa8622c9d98bfd31a1df3f3e87cd5abc52a595f96b970e +a30ec6047ae4bc7da4daa7f4c28c93aedb1112cfe240e681d07e1a183782c9ff6783ac077c155af23c69643b712a533f +ac830726544bfe7b5467339e5114c1a75f2a2a8d89453ce86115e6a789387e23551cd64620ead6283dfa4538eb313d86 +8445c135b7a48068d8ed3e011c6d818cfe462b445095e2fbf940301e50ded23f272d799eea47683fc027430ce14613ef +95785411715c9ae9d8293ce16a693a2aa83e3cb1b4aa9f76333d0da2bf00c55f65e21e42e50e6c5772ce213dd7b4f7a0 +b273b024fa18b7568c0d1c4d2f0c4e79ec509dafac8c5951f14192d63ddbcf2d8a7512c1c1b615cc38fa3e336618e0c5 +a78b9d3ea4b6a90572eb27956f411f1d105fdb577ee2ffeec9f221da9b45db84bfe866af1f29597220c75e0c37a628d8 +a4be2bf058c36699c41513c4d667681ce161a437c09d81383244fc55e1c44e8b1363439d0cce90a3e44581fb31d49493 +b6eef13040f17dd4eba22aaf284d2f988a4a0c4605db44b8d2f4bf9567ac794550b543cc513c5f3e2820242dd704152e +87eb00489071fa95d008c5244b88e317a3454652dcb1c441213aa16b28cd3ecaa9b22fec0bdd483c1df71c37119100b1 +92d388acdcb49793afca329cd06e645544d2269234e8b0b27d2818c809c21726bc9cf725651b951e358a63c83dedee24 +ae27e219277a73030da27ab5603c72c8bd81b6224b7e488d7193806a41343dff2456132274991a4722fdb0ef265d04cd +97583e08ecb82bbc27c0c8476d710389fa9ffbead5c43001bd36c1b018f29faa98de778644883e51870b69c5ffb558b5 +90a799a8ce73387599babf6b7da12767c0591cadd36c20a7990e7c05ea1aa2b9645654ec65308ee008816623a2757a6a +a1b47841a0a2b06efd9ab8c111309cc5fc9e1d5896b3e42ed531f6057e5ade8977c29831ce08dbda40348386b1dcc06d +b92b8ef59bbddb50c9457691bc023d63dfcc54e0fd88bd5d27a09e0d98ac290fc90e6a8f6b88492043bf7c87fac8f3e4 +a9d6240b07d62e22ec8ab9b1f6007c975a77b7320f02504fc7c468b4ee9cfcfd945456ff0128bc0ef2174d9e09333f8d +8e96534c94693226dc32bca79a595ca6de503af635f802e86442c67e77564829756961d9b701187fe91318da515bf0e6 +b6ba290623cd8dd5c2f50931c0045d1cfb0c30877bc8fe58cbc3ff61ee8da100045a39153916efa1936f4aee0892b473 +b43baa7717fac02d4294f5b3bb5e58a65b3557747e3188b482410388daac7a9c177f762d943fd5dcf871273921213da8 +b9cf00f8fb5e2ef2b836659fece15e735060b2ea39b8e901d3dcbdcf612be8bf82d013833718c04cd46ffaa70b85f42e +8017d0c57419e414cbba504368723e751ef990cc6f05dad7b3c2de6360adc774ad95512875ab8337d110bf39a42026fa +ae7401048b838c0dcd4b26bb6c56d79d51964a0daba780970b6c97daee4ea45854ea0ac0e4139b3fe60dac189f84df65 +887b237b0cd0f816b749b21db0b40072f9145f7896c36916296973f9e6990ede110f14e5976c906d08987c9836cca57f +a88c3d5770148aee59930561ca1223aceb2c832fb5417e188dca935905301fc4c6c2c9270bc1dff7add490a125eb81c6 +b6cf9b02c0cd91895ad209e38c54039523f137b5848b9d3ad33ae43af6c20c98434952db375fe378de7866f2d0e8b18a +84ef3d322ff580c8ad584b1fe4fe346c60866eb6a56e982ba2cf3b021ecb1fdb75ecc6c29747adda86d9264430b3f816 +a0561c27224baf0927ad144cb71e31e54a064c598373fcf0d66aebf98ab7af1d8e2f343f77baefff69a6da750a219e11 +aa5cc43f5b8162b016f5e1b61214c0c9d15b1078911c650b75e6cdfb49b85ee04c6739f5b1687d15908444f691f732de +ad4ac099b935589c7b8fdfdf3db332b7b82bb948e13a5beb121ebd7db81a87d278024a1434bcf0115c54ca5109585c3d +8a00466abf3f109a1dcd19e643b603d3af23d42794ef8ca2514dd507ecea44a031ac6dbc18bd02f99701168b25c1791e +b00b5900dfad79645f8bee4e5adc7b84eb22e5b1e67df77ccb505b7fc044a6c08a8ea5faca662414eb945f874f884cea +950e204e5f17112250b22ea6bb8423baf522fc0af494366f18fe0f949f51d6e6812074a80875cf1ed9c8e7420058d541 +91e5cbf8bb1a1d50c81608c9727b414d0dd2fb467ebc92f100882a3772e54f94979cfdf8e373fdef7c7fcdd60fec9e00 +a093f6a857b8caaff80599c2e89c962b415ecbaa70d8fd973155fa976a284c6b29a855f5f7a3521134d00d2972755188 +b4d55a3551b00da54cc010f80d99ddd2544bde9219a3173dfaadf3848edc7e4056ab532fb75ac26f5f7141e724267663 +a03ea050fc9b011d1b04041b5765d6f6453a93a1819cd9bd6328637d0b428f08526466912895dcc2e3008ee58822e9a7 +99b12b3665e473d01bc6985844f8994fb65cb15745024fb7af518398c4a37ff215da8f054e8fdf3286984ae36a73ca5e +9972c7e7a7fb12e15f78d55abcaf322c11249cd44a08f62c95288f34f66b51f146302bce750ff4d591707075d9123bd2 +a64b4a6d72354e596d87cda213c4fc2814009461570ccb27d455bbe131f8d948421a71925425b546d8cf63d5458cd64b +91c215c73b195795ede2228b7ed1f6e37892e0c6b0f4a0b5a16c57aa1100c84df9239054a173b6110d6c2b7f4bf1ce52 +88807198910ec1303480f76a3683870246a995e36adaeadc29c22f0bdba8152fe705bd070b75de657b04934f7d0ccf80 +b37c0026c7b32eb02cacac5b55cb5fe784b8e48b2945c64d3037af83ece556a117f0ff053a5968c2f5fa230e291c1238 +94c768384ce212bc2387e91ce8b45e4ff120987e42472888a317abc9dcdf3563b62e7a61c8e98d7cdcbe272167d91fc6 +a10c2564936e967a390cb14ef6e8f8b04ea9ece5214a38837eda09e79e0c7970b1f83adf017c10efd6faa8b7ffa2c567 +a5085eed3a95f9d4b1269182ea1e0d719b7809bf5009096557a0674bde4201b0ddc1f0f16a908fc468846b3721748ce3 +87468eb620b79a0a455a259a6b4dfbc297d0d53336537b771254dd956b145dc816b195b7002647ea218552e345818a3f +ace2b77ffb87366af0a9cb5d27d6fc4a14323dbbf1643f5f3c4559306330d86461bb008894054394cbfaefeaa0bc2745 +b27f56e840a54fbd793f0b7a7631aa4cee64b5947e4382b2dfb5eb1790270288884c2a19afebe5dc0c6ef335d4531c1c +876e438633931f7f895062ee16c4b9d10428875f7bc79a8e156a64d379a77a2c45bf5430c5ab94330f03da352f1e9006 +a2512a252587d200d2092b44c914df54e04ff8bcef36bf631f84bde0cf5a732e3dc7f00f662842cfd74b0b0f7f24180e +827f1bc8f54a35b7a4bd8154f79bcc055e45faed2e74adf7cf21cca95df44d96899e847bd70ead6bb27b9c0ed97bbd8b +a0c92cf5a9ed843714f3aea9fe7b880f622d0b4a3bf66de291d1b745279accf6ba35097849691370f41732ba64b5966b +a63f5c1e222775658421c487b1256b52626c6f79cb55a9b7deb2352622cedffb08502042d622eb3b02c97f9c09f9c957 +8cc093d52651e65fb390e186db6cc4de559176af4624d1c44cb9b0e836832419dacac7b8db0627b96288977b738d785d +aa7b6a17dfcec146134562d32a12f7bd7fe9522e300859202a02939e69dbd345ed7ff164a184296268f9984f9312e8fc +8ac76721f0d2b679f023d06cbd28c85ae5f4b43c614867ccee88651d4101d4fd352dbdb65bf36bfc3ebc0109e4b0c6f9 +8d350f7c05fc0dcd9a1170748846fb1f5d39453e4cb31e6d1457bed287d96fc393b2ecc53793ca729906a33e59c6834a +b9913510dfc5056d7ec5309f0b631d1ec53e3a776412ada9aefdaf033c90da9a49fdde6719e7c76340e86599b1f0eec2 +94955626bf4ce87612c5cfffcf73bf1c46a4c11a736602b9ba066328dc52ad6d51e6d4f53453d4ed55a51e0aad810271 +b0fcab384fd4016b2f1e53f1aafd160ae3b1a8865cd6c155d7073ecc1664e05b1d8bca1def39c158c7086c4e1103345e +827de3f03edfbde08570b72de6662c8bfa499b066a0a27ebad9b481c273097d17a5a0a67f01553da5392ec3f149b2a78 +ab7940384c25e9027c55c40df20bd2a0d479a165ced9b1046958353cd69015eeb1e44ed2fd64e407805ba42df10fc7bf +8ad456f6ff8cd58bd57567d931f923d0c99141978511b17e03cab7390a72b9f62498b2893e1b05c7c22dd274e9a31919 +ac75399e999effe564672db426faa17a839e57c5ef735985c70cd559a377adec23928382767b55ed5a52f7b11b54b756 +b17f975a00b817299ac7af5f2024ea820351805df58b43724393bfb3920a8cd747a3bbd4b8286e795521489db3657168 +a2bed800a6d95501674d9ee866e7314063407231491d794f8cf57d5be020452729c1c7cefd8c50dc1540181f5caab248 +9743f5473171271ffdd3cc59a3ae50545901a7b45cd4bc3570db487865f3b73c0595bebabbfe79268809ee1862e86e4a +b7eab77c2d4687b60d9d7b04e842b3880c7940140012583898d39fcc22d9b9b0a9be2c2e3788b3e6f30319b39c338f09 +8e2b8f797a436a1b661140e9569dcf3e1eea0a77c7ff2bc4ff0f3e49af04ed2de95e255df8765f1d0927fb456a9926b1 +8aefea201d4a1f4ff98ffce94e540bb313f2d4dfe7e9db484a41f13fc316ed02b282e1acc9bc6f56cad2dc2e393a44c9 +b950c17c0e5ca6607d182144aa7556bb0efe24c68f06d79d6413a973b493bfdf04fd147a4f1ab03033a32004cc3ea66f +b7b8dcbb179a07165f2dc6aa829fad09f582a71b05c3e3ea0396bf9e6fe73076f47035c031c2101e8e38e0d597eadd30 +a9d77ed89c77ec1bf8335d08d41c3c94dcca9fd1c54f22837b4e54506b212aa38d7440126c80648ab7723ff18e65ed72 +a819d6dfd4aef70e52b8402fe5d135f8082d40eb7d3bb5c4d7997395b621e2bb10682a1bad2c9caa33dd818550fc3ec6 +8f6ee34128fac8bbf13ce2d68b2bb363eb4fd65b297075f88e1446ddeac242500eeb4ef0735e105882ff5ba8c44c139b +b4440e48255c1644bcecf3a1e9958f1ec4901cb5b1122ee5b56ffd02cad1c29c4266999dbb85aa2605c1b125490074d4 +a43304a067bede5f347775d5811cf65a6380a8d552a652a0063580b5c5ef12a0867a39c7912fa219e184f4538eba1251 +a891ad67a790089ffc9f6d53e6a3d63d3556f5f693e0cd8a7d0131db06fd4520e719cfcc3934f0a8f62a95f90840f1d4 +aea6df8e9bb871081aa0fc5a9bafb00be7d54012c5baf653791907d5042a326aeee966fd9012a582cc16695f5baf7042 +8ffa2660dc52ed1cd4eff67d6a84a8404f358a5f713d04328922269bee1e75e9d49afeec0c8ad751620f22352a438e25 +87ec6108e2d63b06abed350f8b363b7489d642486f879a6c3aa90e5b0f335efc2ff2834eef9353951a42136f8e6a1b32 +865619436076c2760d9e87ddc905023c6de0a8d56eef12c98a98c87837f2ca3f27fd26a2ad752252dbcbe2b9f1d5a032 +980437dce55964293cb315c650c5586ffd97e7a944a83f6618af31c9d92c37b53ca7a21bb5bc557c151b9a9e217e7098 +95d128fc369df4ad8316b72aea0ca363cbc7b0620d6d7bb18f7076a8717a6a46956ff140948b0cc4f6d2ce33b5c10054 +8c7212d4a67b9ec70ebbca04358ad2d36494618d2859609163526d7b3acc2fc935ca98519380f55e6550f70a9bc76862 +893a2968819401bf355e85eee0f0ed0406a6d4a7d7f172d0017420f71e00bb0ba984f6020999a3cdf874d3cd8ebcd371 +9103c1af82dece25d87274e89ea0acd7e68c2921c4af3d8d7c82ab0ed9990a5811231b5b06113e7fa43a6bd492b4564f +99cfd87a94eab7d35466caa4ed7d7bb45e5c932b2ec094258fb14bf205659f83c209b83b2f2c9ccb175974b2a33e7746 +874b6b93e4ee61be3f00c32dd84c897ccd6855c4b6251eb0953b4023634490ed17753cd3223472873cbc6095b2945075 +84a32c0dc4ea60d33aac3e03e70d6d639cc9c4cc435c539eff915017be3b7bdaba33349562a87746291ebe9bc5671f24 +a7057b24208928ad67914e653f5ac1792c417f413d9176ba635502c3f9c688f7e2ee81800d7e3dc0a340c464da2fd9c5 +a03fb9ed8286aacfa69fbd5d953bec591c2ae4153400983d5dbb6cd9ea37fff46ca9e5cceb9d117f73e9992a6c055ad2 +863b2de04e89936c9a4a2b40380f42f20aefbae18d03750fd816c658aee9c4a03df7b12121f795c85d01f415baaeaa59 +8526eb9bd31790fe8292360d7a4c3eed23be23dd6b8b8f01d2309dbfdc0cfd33ad1568ddd7f8a610f3f85a9dfafc6a92 +b46ab8c5091a493d6d4d60490c40aa27950574a338ea5bbc045be3a114af87bdcb160a8c80435a9b7ad815f3cb56a3f3 +aeadc47b41a8d8b4176629557646202f868b1d728b2dda58a347d937e7ffc8303f20d26d6c00b34c851b8aeec547885d +aebb19fc424d72c1f1822aa7adc744cd0ef7e55727186f8df8771c784925058c248406ebeeaf3c1a9ee005a26e9a10c6 +8ff96e81c1a4a2ab1b4476c21018fae0a67e92129ee36120cae8699f2d7e57e891f5c624902cb1b845b944926a605cc3 +8251b8d2c43fadcaa049a9e7aff838dae4fb32884018d58d46403ac5f3beb5c518bfd45f03b8abb710369186075eb71c +a8b2a64f865f51a5e5e86a66455c093407933d9d255d6b61e1fd81ffafc9538d73caaf342338a66ba8ee166372a3d105 +aad915f31c6ba7fdc04e2aaac62e84ef434b7ee76a325f07dc430d12c84081999720181067b87d792efd0117d7ee1eab +a13db3bb60389883fd41d565c54fb5180d9c47ce2fe7a169ae96e01d17495f7f4fa928d7e556e7c74319c4c25d653eb2 +a4491b0198459b3f552855d680a59214eb74e6a4d6c5fa3b309887dc50ebea2ecf6d26c040550f7dc478b452481466fb +8f017f13d4b1e3f0c087843582b52d5f8d13240912254d826dd11f8703a99a2f3166dfbdfdffd9a3492979d77524276b +96c3d5dcd032660d50d7cd9db2914f117240a63439966162b10c8f1f3cf74bc83b0f15451a43b31dbd85e4a7ce0e4bb1 +b479ec4bb79573d32e0ec93b92bdd7ec8c26ddb5a2d3865e7d4209d119fd3499eaac527615ffac78c440e60ef3867ae0 +b2c49c4a33aa94b52b6410b599e81ff15490aafa7e43c8031c865a84e4676354a9c81eb4e7b8be6825fdcefd1e317d44 +906dc51d6a90c089b6704b47592805578a6eed106608eeb276832f127e1b8e858b72e448edcbefb497d152447e0e68ff +b0e81c63b764d7dfbe3f3fddc9905aef50f3633e5d6a4af6b340495124abedcff5700dfd1577bbbed7b6bf97d02719cb +9304c64701e3b4ed6d146e48a881f7d83a17f58357cca0c073b2bb593afd2d94f6e2a7a1ec511d0a67ad6ff4c3be5937 +b6fdbd12ba05aa598d80b83f70a15ef90e5cba7e6e75fa038540ee741b644cd1f408a6cecfd2a891ef8d902de586c6b5 +b80557871a6521b1b3c74a1ba083ae055b575df607f1f7b04c867ba8c8c181ea68f8d90be6031f4d25002cca27c44da2 +aa7285b8e9712e06b091f64163f1266926a36607f9d624af9996856ed2aaf03a580cb22ce407d1ade436c28b44ca173f +8148d72b975238b51e6ea389e5486940d22641b48637d7dfadfa603a605bfc6d74a016480023945d0b85935e396aea5d +8a014933a6aea2684b5762af43dcf4bdbb633cd0428d42d71167a2b6fc563ece5e618bff22f1db2ddb69b845b9a2db19 +990d91740041db770d0e0eb9d9d97d826f09fd354b91c41e0716c29f8420e0e8aac0d575231efba12fe831091ec38d5a +9454d0d32e7e308ddec57cf2522fb1b67a2706e33fb3895e9e1f18284129ab4f4c0b7e51af25681d248d7832c05eb698 +a5bd434e75bac105cb3e329665a35bce6a12f71dd90c15165777d64d4c13a82bceedb9b48e762bd24034e0fc9fbe45f4 +b09e3b95e41800d4dc29c6ffdaab2cd611a0050347f6414f154a47ee20ee59bf8cf7181454169d479ebce1eb5c777c46 +b193e341d6a047d15eea33766d656d807b89393665a783a316e9ba10518e5515c8e0ade3d6e15641d917a8a172a5a635 +ade435ec0671b3621dde69e07ead596014f6e1daa1152707a8c18877a8b067bde2895dd47444ffa69db2bbef1f1d8816 +a7fd3d6d87522dfc56fb47aef9ce781a1597c56a8bbfd796baba907afdc872f753d732bfda1d3402aee6c4e0c189f52d +a298cb4f4218d0464b2fab393e512bbc477c3225aa449743299b2c3572f065bc3a42d07e29546167ed9e1b6b3b3a3af3 +a9ee57540e1fd9c27f4f0430d194b91401d0c642456c18527127d1f95e2dba41c2c86d1990432eb38a692fda058fafde +81d6c1a5f93c04e6d8e5a7e0678c1fc89a1c47a5c920bcd36180125c49fcf7c114866b90e90a165823560b19898a7c16 +a4b7a1ec9e93c899b9fd9aaf264c50e42c36c0788d68296a471f7a3447af4dbc81e4fa96070139941564083ec5b5b5a1 +b3364e327d381f46940c0e11e29f9d994efc6978bf37a32586636c0070b03e4e23d00650c1440f448809e1018ef9f6d8 +8056e0913a60155348300e3a62e28b5e30629a90f7dd4fe11289097076708110a1d70f7855601782a3cdc5bdb1ca9626 +b4980fd3ea17bac0ba9ee1c470b17e575bb52e83ebdd7d40c93f4f87bebeaff1c8a679f9d3d09d635f068d37d5bd28bd +905a9299e7e1853648e398901dfcd437aa575c826551f83520df62984f5679cb5f0ea86aa45ed3e18b67ddc0dfafe809 +ab99553bf31a84f2e0264eb34a08e13d8d15e2484aa9352354becf9a15999c76cc568d68274b70a65e49703fc23540d0 +a43681597bc574d2dae8964c9a8dc1a07613d7a1272bdcb818d98c85d44e16d744250c33f3b5e4d552d97396b55e601f +a54e5a31716fccb50245898c99865644405b8dc920ded7a11f3d19bdc255996054b268e16f2e40273f11480e7145f41e +8134f3ad5ef2ad4ba12a8a4e4d8508d91394d2bcdc38b7c8c8c0b0a820357ac9f79d286c65220f471eb1adca1d98fc68 +94e2f755e60471578ab2c1adb9e9cea28d4eec9b0e92e0140770bca7002c365fcabfe1e5fb4fe6cfe79a0413712aa3ef +ad48f8d0ce7eb3cc6e2a3086ad96f562e5bed98a360721492ae2e74dc158586e77ec8c35d5fd5927376301b7741bad2b +8614f0630bdd7fbad3a31f55afd9789f1c605dc85e7dc67e2edfd77f5105f878bb79beded6e9f0b109e38ea7da67e8d5 +9804c284c4c5e77dabb73f655b12181534ca877c3e1e134aa3f47c23b7ec92277db34d2b0a5d38d2b69e5d1c3008a3e3 +a51b99c3088e473afdaa9e0a9f7e75a373530d3b04e44e1148da0726b95e9f5f0c7e571b2da000310817c36f84b19f7f +ac4ff909933b3b76c726b0a382157cdc74ab851a1ac6cef76953c6444441804cc43abb883363f416592e8f6cfbc4550b +ae7d915eb9fc928b65a29d6edbc75682d08584d0014f7bcf17d59118421ae07d26a02137d1e4de6938bcd1ab8ef48fad +852f7e453b1af89b754df6d11a40d5d41ea057376e8ecacd705aacd2f917457f4a093d6b9a8801837fa0f62986ad7149 +92c6bf5ada5d0c3d4dd8058483de36c215fa98edab9d75242f3eff9db07c734ad67337da6f0eefe23a487bf75a600dee +a2b42c09d0db615853763552a48d2e704542bbd786aae016eb58acbf6c0226c844f5fb31e428cb6450b9db855f8f2a6f +880cc07968266dbfdcfbc21815cd69e0eddfee239167ac693fb0413912d816f2578a74f7716eecd6deefa68c6eccd394 +b885b3ace736cd373e8098bf75ba66fa1c6943ca1bc4408cd98ac7074775c4478594f91154b8a743d9c697e1b29f5840 +a51ce78de512bd87bfa0835de819941dffbf18bec23221b61d8096fc9436af64e0693c335b54e7bfc763f287bdca2db6 +a3c76166a3bdb9b06ef696e57603b58871bc72883ee9d45171a30fe6e1d50e30bc9c51b4a0f5a7270e19a77b89733850 +acefc5c6f8a1e7c24d7b41e0fc7f6f3dc0ede6cf3115ffb9a6e54b1d954cbca9bda8ad7a084be9be245a1b8e9770d141 +b420ed079941842510e31cfad117fa11fb6b4f97dfbc6298cb840f27ebaceba23eeaf3f513bcffbf5e4aae946310182d +95c3bb5ef26c5ed2f035aa5d389c6b3c15a6705b9818a3fefaed28922158b35642b2e8e5a1a620fdad07e75ad4b43af4 +825149f9081ecf07a2a4e3e8b5d21bade86c1a882475d51c55ee909330b70c5a2ac63771c8600c6f38df716af61a3ea1 +873b935aae16d9f08adbc25353cee18af2f1b8d5f26dec6538d6bbddc515f2217ed7d235dcfea59ae61b428798b28637 +9294150843a2bedcedb3bb74c43eb28e759cf9499582c5430bccefb574a8ddd4f11f9929257ff4c153990f9970a2558f +b619563a811cc531da07f4f04e5c4c6423010ff9f8ed7e6ec9449162e3d501b269fb1c564c09c0429431879b0f45df02 +91b509b87eb09f007d839627514658c7341bc76d468920fe8a740a8cb96a7e7e631e0ea584a7e3dc1172266f641d0f5c +8b8aceace9a7b9b4317f1f01308c3904d7663856946afbcea141a1c615e21ccad06b71217413e832166e9dd915fbe098 +87b3b36e725833ea0b0f54753c3728c0dbc87c52d44d705ffc709f2d2394414c652d3283bab28dcce09799504996cee0 +b2670aad5691cbf308e4a6a77a075c4422e6cbe86fdba24e9f84a313e90b0696afb6a067eebb42ba2d10340d6a2f6e51 +876784a9aff3d54faa89b2bacd3ff5862f70195d0b2edc58e8d1068b3c9074c0da1cfa23671fe12f35e33b8a329c0ccd +8b48b9e758e8a8eae182f5cbec96f67d20cca6d3eee80a2d09208eb1d5d872e09ef23d0df8ebbb9b01c7449d0e3e3650 +b79303453100654c04a487bdcadc9e3578bc80930c489a7069a52e8ca1dba36c492c8c899ce025f8364599899baa287d +961b35a6111da54ece6494f24dacd5ea46181f55775b5f03df0e370c34a5046ac2b4082925855325bb42bc2a2c98381d +a31feb1be3f5a0247a1f7d487987eb622e34fca817832904c6ee3ee60277e5847945a6f6ea1ac24542c72e47bdf647df +a12a2aa3e7327e457e1aae30e9612715dd2cfed32892c1cd6dcda4e9a18203af8a44afb46d03b2eed89f6b9c5a2c0c23 +a08265a838e69a2ca2f80fead6ccf16f6366415b920c0b22ee359bcd8d4464ecf156f400a16a7918d52e6d733dd64211 +b723d6344e938d801cca1a00032af200e541d4471fd6cbd38fb9130daa83f6a1dffbbe7e67fc20f9577f884acd7594b2 +a6733d83ec78ba98e72ddd1e7ff79b7adb0e559e256760d0c590a986e742445e8cdf560d44b29439c26d87edd0b07c8c +a61c2c27d3f7b9ff4695a17afedf63818d4bfba390507e1f4d0d806ce8778d9418784430ce3d4199fd3bdbc2504d2af3 +8332f3b63a6dc985376e8b1b25eeae68be6160fbe40053ba7bcf6f073204f682da72321786e422d3482fd60c9e5aa034 +a280f44877583fbb6b860d500b1a3f572e3ee833ec8f06476b3d8002058e25964062feaa1e5bec1536d734a5cfa09145 +a4026a52d277fcea512440d2204f53047718ebfcae7b48ac57ea7f6bfbc5de9d7304db9a9a6cbb273612281049ddaec5 +95cdf69c831ab2fad6c2535ede9c07e663d2ddccc936b64e0843d2df2a7b1c31f1759c3c20f1e7a57b1c8f0dbb21b540 +95c96cec88806469c277ab567863c5209027cecc06c7012358e5f555689c0d9a5ffb219a464f086b45817e8536b86d2f +afe38d4684132a0f03d806a4c8df556bf589b25271fbc6fe2e1ed16de7962b341c5003755da758d0959d2e6499b06c68 +a9b77784fda64987f97c3a23c5e8f61b918be0f7c59ba285084116d60465c4a2aaafc8857eb16823282cc83143eb9126 +a830f05881ad3ce532a55685877f529d32a5dbe56cea57ffad52c4128ee0fad0eeaf0da4362b55075e77eda7babe70e5 +992b3ad190d6578033c13ed5abfee4ef49cbc492babb90061e3c51ee4b5790cdd4c8fc1abff1fa2c00183b6b64f0bbbe +b1015424d9364aeff75de191652dc66484fdbec3e98199a9eb9671ec57bec6a13ff4b38446e28e4d8aedb58dd619cd90 +a745304604075d60c9db36cada4063ac7558e7ec2835d7da8485e58d8422e817457b8da069f56511b02601289fbb8981 +a5ba4330bc5cb3dbe0486ddf995632a7260a46180a08f42ae51a2e47778142132463cc9f10021a9ad36986108fefa1a9 +b419e9fd4babcaf8180d5479db188bb3da232ae77a1c4ed65687c306e6262f8083070a9ac32220cddb3af2ec73114092 +a49e23dc5f3468f3bf3a0bb7e4a114a788b951ff6f23a3396ae9e12cbff0abd1240878a3d1892105413dbc38818e807c +b7ecc7b4831f650202987e85b86bc0053f40d983f252e9832ef503aea81c51221ce93279da4aa7466c026b2d2070e55d +96a8c35cb87f84fa84dcd6399cc2a0fd79cc9158ef4bdde4bae31a129616c8a9f2576cd19baa3f497ca34060979aed7d +8681b2c00aa62c2b519f664a95dcb8faef601a3b961bb4ce5d85a75030f40965e2983871d41ea394aee934e859581548 +85c229a07efa54a713d0790963a392400f55fbb1a43995a535dc6c929f20d6a65cf4efb434e0ad1cb61f689b8011a3bc +90856f7f3444e5ad44651c28e24cc085a5db4d2ffe79aa53228c26718cf53a6e44615f3c5cda5aa752d5f762c4623c66 +978999b7d8aa3f28a04076f74d11c41ef9c89fdfe514936c4238e0f13c38ec97e51a5c078ebc6409e517bfe7ccb42630 +a099914dd7ed934d8e0d363a648e9038eb7c1ec03fa04dbcaa40f7721c618c3ef947afef7a16b4d7ac8c12aa46637f03 +ab2a104fed3c83d16f2cda06878fa5f30c8c9411de71bfb67fd2fc9aa454dcbcf3d299d72f8cc12e919466a50fcf7426 +a4471d111db4418f56915689482f6144efc4664cfb0311727f36c864648d35734351becc48875df96f4abd3cfcf820f9 +83be11727cd30ea94ccc8fa31b09b81c9d6a9a5d3a4686af9da99587332fe78c1f94282f9755854bafd6033549afec91 +88020ff971dc1a01a9e993cd50a5d2131ffdcbb990c1a6aaa54b20d8f23f9546a70918ea57a21530dcc440c1509c24ad +ae24547623465e87905eaffa1fa5d52bb7c453a8dbd89614fa8819a2abcedaf455c2345099b7324ae36eb0ad7c8ef977 +b59b0c60997de1ee00b7c388bc7101d136c9803bf5437b1d589ba57c213f4f835a3e4125b54738e78abbc21b000f2016 +a584c434dfe194546526691b68fa968c831c31da42303a1d735d960901c74011d522246f37f299555416b8cf25c5a548 +80408ce3724f4837d4d52376d255e10f69eb8558399ae5ca6c11b78b98fe67d4b93157d2b9b639f1b5b64198bfe87713 +abb941e8d406c2606e0ddc35c113604fdd9d249eacc51cb64e2991e551b8639ce44d288cc92afa7a1e7fc599cfc84b22 +b223173f560cacb1c21dba0f1713839e348ad02cbfdef0626748604c86f89e0f4c919ed40b583343795bdd519ba952c8 +af1c70512ec3a19d98b8a1fc3ff7f7f5048a27d17d438d43f561974bbdd116fcd5d5c21040f3447af3f0266848d47a15 +8a44809568ebe50405bede19b4d2607199159b26a1b33e03d180e6840c5cf59d991a4fb150d111443235d75ecad085b7 +b06207cdca46b125a27b3221b5b50cf27af4c527dd7c80e2dbcebbb09778a96df3af67e50f07725239ce3583dad60660 +993352d9278814ec89b26a11c4a7c4941bf8f0e6781ae79559d14749ee5def672259792db4587f85f0100c7bb812f933 +9180b8a718b971fd27bc82c8582d19c4b4f012453e8c0ffeeeffe745581fc6c07875ab28be3af3fa3896d19f0c89ac5b +8b8e1263eb48d0fe304032dd5ea1f30e73f0121265f7458ba9054d3626894e8a5fef665340abd2ede9653045c2665938 +99a2beee4a10b7941c24b2092192faf52b819afd033e4a2de050fd6c7f56d364d0cf5f99764c3357cf32399e60fc5d74 +946a4aad7f8647ea60bee2c5fcdeb6f9a58fb2cfca70c4d10e458027a04846e13798c66506151be3df9454b1e417893f +a672a88847652d260b5472d6908d1d57e200f1e492d30dd1cecc441cdfc9b76e016d9bab560efd4d7f3c30801de884a9 +9414e1959c156cde1eb24e628395744db75fc24b9df4595350aaad0bc38e0246c9b4148f6443ef68b8e253a4a6bcf11c +9316e9e4ec5fab4f80d6540df0e3a4774db52f1d759d2e5b5bcd3d7b53597bb007eb1887cb7dc61f62497d51ffc8d996 +902d6d77bb49492c7a00bc4b70277bc28c8bf9888f4307bb017ac75a962decdedf3a4e2cf6c1ea9f9ba551f4610cbbd7 +b07025a18b0e32dd5e12ec6a85781aa3554329ea12c4cd0d3b2c22e43d777ef6f89876dd90a9c8fb097ddf61cf18adc5 +b355a849ad3227caa4476759137e813505ec523cbc2d4105bc7148a4630f9e81918d110479a2d5f5e4cd9ccec9d9d3e3 +b49532cfdf02ee760109881ad030b89c48ee3bb7f219ccafc13c93aead754d29bdafe345be54c482e9d5672bd4505080 +9477802410e263e4f938d57fa8f2a6cac7754c5d38505b73ee35ea3f057aad958cb9722ba6b7b3cfc4524e9ca93f9cdc +9148ea83b4436339580f3dbc9ba51509e9ab13c03063587a57e125432dd0915f5d2a8f456a68f8fff57d5f08c8f34d6e +b00b6b5392b1930b54352c02b1b3b4f6186d20bf21698689bbfc7d13e86538a4397b90e9d5c93fd2054640c4dbe52a4f +926a9702500441243cd446e7cbf15dde16400259726794694b1d9a40263a9fc9e12f7bcbf12a27cb9aaba9e2d5848ddc +a0c6155f42686cbe7684a1dc327100962e13bafcf3db97971fc116d9f5c0c8355377e3d70979cdbd58fd3ea52440901c +a277f899f99edb8791889d0817ea6a96c24a61acfda3ad8c3379e7c62b9d4facc4b965020b588651672fd261a77f1bfc +8f528cebb866b501f91afa50e995234bef5bf20bff13005de99cb51eaac7b4f0bf38580cfd0470de40f577ead5d9ba0f +963fc03a44e9d502cc1d23250efef44d299befd03b898d07ce63ca607bb474b5cf7c965a7b9b0f32198b04a8393821f7 +ab087438d0a51078c378bf4a93bd48ef933ff0f1fa68d02d4460820df564e6642a663b5e50a5fe509527d55cb510ae04 +b0592e1f2c54746bb076be0fa480e1c4bebc4225e1236bcda3b299aa3853e3afb401233bdbcfc4a007b0523a720fbf62 +851613517966de76c1c55a94dc4595f299398a9808f2d2f0a84330ba657ab1f357701d0895f658c18a44cb00547f6f57 +a2fe9a1dd251e72b0fe4db27be508bb55208f8f1616b13d8be288363ec722826b1a1fd729fc561c3369bf13950bf1fd6 +b896cb2bc2d0c77739853bc59b0f89b2e008ba1f701c9cbe3bef035f499e1baee8f0ff1e794854a48c320586a2dfc81a +a1b60f98e5e5106785a9b81a85423452ee9ef980fa7fa8464f4366e73f89c50435a0c37b2906052b8e58e212ebd366cf +a853b0ebd9609656636df2e6acd5d8839c0fda56f7bf9288a943b06f0b67901a32b95e016ca8bc99bd7b5eab31347e72 +b290fa4c1346963bd5225235e6bdf7c542174dab4c908ab483d1745b9b3a6015525e398e1761c90e4b49968d05e30eea +b0f65a33ad18f154f1351f07879a183ad62e5144ad9f3241c2d06533dad09cbb2253949daff1bb02d24d16a3569f7ef0 +a00db59b8d4218faf5aeafcd39231027324408f208ec1f54d55a1c41228b463b88304d909d16b718cfc784213917b71e +b8d695dd33dc2c3bc73d98248c535b2770ad7fa31aa726f0aa4b3299efb0295ba9b4a51c71d314a4a1bd5872307534d1 +b848057cca2ca837ee49c42b88422303e58ea7d2fc76535260eb5bd609255e430514e927cc188324faa8e657396d63ec +92677836061364685c2aaf0313fa32322746074ed5666fd5f142a7e8f87135f45cd10e78a17557a4067a51dfde890371 +a854b22c9056a3a24ab164a53e5c5cf388616c33e67d8ebb4590cb16b2e7d88b54b1393c93760d154208b5ca822dc68f +86fff174920388bfab841118fb076b2b0cdec3fdb6c3d9a476262f82689fb0ed3f1897f7be9dbf0932bb14d346815c63 +99661cf4c94a74e182752bcc4b98a8c2218a8f2765642025048e12e88ba776f14f7be73a2d79bd21a61def757f47f904 +8a8893144d771dca28760cba0f950a5d634195fd401ec8cf1145146286caffb0b1a6ba0c4c1828d0a5480ce49073c64c +938a59ae761359ee2688571e7b7d54692848eb5dde57ffc572b473001ea199786886f8c6346a226209484afb61d2e526 +923f68a6aa6616714cf077cf548aeb845bfdd78f2f6851d8148cba9e33a374017f2f3da186c39b82d14785a093313222 +ac923a93d7da7013e73ce8b4a2b14b8fd0cc93dc29d5de941a70285bdd19be4740fedfe0c56b046689252a3696e9c5bc +b49b32c76d4ec1a2c68d4989285a920a805993bc6fcce6dacd3d2ddae73373050a5c44ba8422a3781050682fa0ef6ba2 +8a367941c07c3bdca5712524a1411bad7945c7c48ffc7103b1d4dff2c25751b0624219d1ccde8c3f70c465f954be5445 +b838f029df455efb6c530d0e370bbbf7d87d61a9aea3d2fe5474c5fe0a39cf235ceecf9693c5c6c5820b1ba8f820bd31 +a8983b7c715eaac7f13a001d2abc462dfc1559dab4a6b554119c271aa8fe00ffcf6b6949a1121f324d6d26cb877bcbae +a2afb24ad95a6f14a6796315fbe0d8d7700d08f0cfaf7a2abe841f5f18d4fecf094406cbd54da7232a159f9c5b6e805e +87e8e95ad2d62f947b2766ff405a23f7a8afba14e7f718a691d95369c79955cdebe24c54662553c60a3f55e6322c0f6f +87c2cbcecb754e0cc96128e707e5c5005c9de07ffd899efa3437cadc23362f5a1d3fcdd30a1f5bdc72af3fb594398c2a +91afd6ee04f0496dc633db88b9370d41c428b04fd991002502da2e9a0ef051bcd7b760e860829a44fbe5539fa65f8525 +8c50e5d1a24515a9dd624fe08b12223a75ca55196f769f24748686315329b337efadca1c63f88bee0ac292dd0a587440 +8a07e8f912a38d94309f317c32068e87f68f51bdfa082d96026f5f5f8a2211621f8a3856dda8069386bf15fb2d28c18f +94ad1dbe341c44eeaf4dc133eed47d8dbfe752575e836c075745770a6679ff1f0e7883b6aa917462993a7f469d74cab5 +8745f8bd86c2bb30efa7efb7725489f2654f3e1ac4ea95bd7ad0f3cfa223055d06c187a16192d9d7bdaea7b050c6a324 +900d149c8d79418cda5955974c450a70845e02e5a4ecbcc584a3ca64d237df73987c303e3eeb79da1af83bf62d9e579f +8f652ab565f677fb1a7ba03b08004e3cda06b86c6f1b0b9ab932e0834acf1370abb2914c15b0d08327b5504e5990681c +9103097d088be1f75ab9d3da879106c2f597e2cc91ec31e73430647bdd5c33bcfd771530d5521e7e14df6acda44f38a6 +b0fec7791cfb0f96e60601e1aeced9a92446b61fedab832539d1d1037558612d78419efa87ff5f6b7aab8fd697d4d9de +b9d2945bdb188b98958854ba287eb0480ef614199c4235ce5f15fc670b8c5ffe8eeb120c09c53ea8a543a022e6a321ac +a9461bb7d5490973ebaa51afc0bb4a5e42acdccb80e2f939e88b77ac28a98870e103e1042899750f8667a8cc9123bae9 +a37fdf11d4bcb2aed74b9f460a30aa34afea93386fa4cdb690f0a71bc58f0b8df60bec56e7a24f225978b862626fa00e +a214420e183e03d531cf91661466ea2187d84b6e814b8b20b3730a9400a7d25cf23181bb85589ebc982cec414f5c2923 +ad09a45a698a6beb3e0915f540ef16e9af7087f53328972532d6b5dfe98ce4020555ece65c6cbad8bd6be8a4dfefe6fd +ab6742800b02728c92d806976764cb027413d6f86edd08ad8bb5922a2969ee9836878cd39db70db0bd9a2646862acc4f +974ca9305bd5ea1dc1755dff3b63e8bfe9f744321046c1395659bcea2a987b528e64d5aa96ac7b015650b2253b37888d +84eee9d6bce039c52c2ebc4fccc0ad70e20c82f47c558098da4be2f386a493cbc76adc795b5488c8d11b6518c2c4fab8 +875d7bda46efcb63944e1ccf760a20144df3b00d53282b781e95f12bfc8f8316dfe6492c2efbf796f1150e36e436e9df +b68a2208e0c587b5c31b5f6cb32d3e6058a9642e2d9855da4f85566e1412db528475892060bb932c55b3a80877ad7b4a +ba006368ecab5febb6ab348644d9b63de202293085ed468df8bc24d992ae8ce468470aa37f36a73630c789fb9c819b30 +90a196035150846cd2b482c7b17027471372a8ce7d914c4d82b6ea7fa705d8ed5817bd42d63886242585baf7d1397a1c +a223b4c85e0daa8434b015fd9170b5561fe676664b67064974a1e9325066ecf88fc81f97ab5011c59fad28cedd04b240 +82e8ec43139cf15c6bbeed484b62e06cded8a39b5ce0389e4cbe9c9e9c02f2f0275d8d8d4e8dfec8f69a191bef220408 +81a3fc07a7b68d92c6ee4b6d28f5653ee9ec85f7e2ee1c51c075c1b130a8c5097dc661cf10c5aff1c7114b1a6a19f11a +8ed2ef8331546d98819a5dd0e6c9f8cb2630d0847671314a28f277faf68da080b53891dd75c82cbcf7788b255490785d +acecabf84a6f9bbed6b2fc2e7e4b48f02ef2f15e597538a73aea8f98addc6badda15e4695a67ecdb505c1554e8f345ec +b8f51019b2aa575f8476e03dcadf86cc8391f007e5f922c2a36b2daa63f5a503646a468990cd5c65148d323942193051 +aaa595a84b403ec65729bc1c8055a94f874bf9adddc6c507b3e1f24f79d3ad359595a672b93aab3394db4e2d4a7d8970 +895144c55fcbd0f64d7dd69e6855cfb956e02b5658eadf0f026a70703f3643037268fdd673b0d21b288578a83c6338dd +a2e92ae6d0d237d1274259a8f99d4ea4912a299816350b876fba5ebc60b714490e198a916e1c38c6e020a792496fa23c +a45795fda3b5bb0ad1d3c628f6add5b2a4473a1414c1a232e80e70d1cfffd7f8a8d9861f8df2946999d7dbb56bf60113 +b6659bf7f6f2fef61c39923e8c23b8c70e9c903028d8f62516d16755cd3fba2fe41c285aa9432dc75ab08f8a1d8a81fc +a735609a6bc5bfd85e58234fc439ff1f58f1ff1dd966c5921d8b649e21f006bf2b8642ad8a75063c159aaf6935789293 +a3c622eb387c9d15e7bda2e3e84d007cb13a6d50d655c3f2f289758e49d3b37b9a35e4535d3cc53d8efd51f407281f19 +8afe147b53ad99220f5ef9d763bfc91f9c20caecbcf823564236fb0e6ede49414c57d71eec4772c8715cc65a81af0047 +b5f0203233cf71913951e9c9c4e10d9243e3e4a1f2cb235bf3f42009120ba96e04aa414c9938ea8873b63148478927e8 +93c52493361b458d196172d7ba982a90a4f79f03aa8008edc322950de3ce6acf4c3977807a2ffa9e924047e02072b229 +b9e72b805c8ac56503f4a86c82720afbd5c73654408a22a2ac0b2e5caccdfb0e20b59807433a6233bc97ae58cf14c70a +af0475779b5cee278cca14c82da2a9f9c8ef222eb885e8c50cca2315fea420de6e04146590ed0dd5a29c0e0812964df5 +b430ccab85690db02c2d0eb610f3197884ca12bc5f23c51e282bf3a6aa7e4a79222c3d8761454caf55d6c01a327595f9 +830032937418b26ee6da9b5206f3e24dc76acd98589e37937e963a8333e5430abd6ce3dd93ef4b8997bd41440eed75d6 +8820a6d73180f3fe255199f3f175c5eb770461ad5cfdde2fb11508041ed19b8c4ce66ad6ecebf7d7e836cc2318df47ca +aef1393e7d97278e77bbf52ef6e1c1d5db721ccf75fe753cf47a881fa034ca61eaa5098ee5a344c156d2b14ff9e284ad +8a4a26c07218948c1196c45d927ef4d2c42ade5e29fe7a91eaebe34a29900072ce5194cf28d51f746f4c4c649daf4396 +84011dc150b7177abdcb715efbd8c201f9cb39c36e6069af5c50a096021768ba40cef45b659c70915af209f904ede3b6 +b1bd90675411389bb66910b21a4bbb50edce5330850c5ab0b682393950124252766fc81f5ecfc72fb7184387238c402e +8dfdcd30583b696d2c7744655f79809f451a60c9ad5bf1226dc078b19f4585d7b3ef7fa9d54e1ac09520d95cbfd20928 +b351b4dc6d98f75b8e5a48eb7c6f6e4b78451991c9ba630e5a1b9874c15ac450cd409c1a024713bf2cf82dc400e025ef +a462b8bc97ac668b97b28b3ae24b9f5de60e098d7b23ecb600d2194cd35827fb79f77c3e50d358f5bd72ee83fef18fa0 +a183753265c5f7890270821880cce5f9b2965b115ba783c6dba9769536f57a04465d7da5049c7cf8b3fcf48146173c18 +a8a771b81ed0d09e0da4d79f990e58eabcd2be3a2680419502dd592783fe52f657fe55125b385c41d0ba3b9b9cf54a83 +a71ec577db46011689d073245e3b1c3222a9b1fe6aa5b83629adec5733dd48617ebea91346f0dd0e6cdaa86e4931b168 +a334b8b244f0d598a02da6ae0f918a7857a54dce928376c4c85df15f3b0f2ba3ac321296b8b7c9dd47d770daf16c8f8c +a29037f8ef925c417c90c4df4f9fb27fb977d04e2b3dd5e8547d33e92ab72e7a00f5461de21e28835319eae5db145eb7 +b91054108ae78b00e3298d667b913ebc44d8f26e531eae78a8fe26fdfb60271c97efb2dee5f47ef5a3c15c8228138927 +926c13efbe90604f6244be9315a34f72a1f8d1aab7572df431998949c378cddbf2fe393502c930fff614ff06ae98a0ce +995c758fd5600e6537089b1baa4fbe0376ab274ff3e82a17768b40df6f91c2e443411de9cafa1e65ea88fb8b87d504f4 +9245ba307a7a90847da75fca8d77ec03fdfc812c871e7a2529c56a0a79a6de16084258e7a9ac4ae8a3756f394336e21c +99e0cfa2bb57a7e624231317044c15e52196ecce020db567c8e8cb960354a0be9862ee0c128c60b44777e65ac315e59f +ad4f6b3d27bbbb744126601053c3dc98c07ff0eb0b38a898bd80dce778372846d67e5ab8fb34fb3ad0ef3f235d77ba7f +a0f12cae3722bbbca2e539eb9cc7614632a2aefe51410430070a12b5bc5314ecec5857b7ff8f41e9980cac23064f7c56 +b487f1bc59485848c98222fd3bc36c8c9bb3d2912e2911f4ceca32c840a7921477f9b1fe00877e05c96c75d3eecae061 +a6033db53925654e18ecb3ce715715c36165d7035db9397087ac3a0585e587998a53973d011ac6d48af439493029cee6 +a6b4d09cd01c70a3311fd131d3710ccf97bde3e7b80efd5a8c0eaeffeb48cca0f951ced905290267b115b06d46f2693b +a9dff1df0a8f4f218a98b6f818a693fb0d611fed0fc3143537cbd6578d479af13a653a8155e535548a2a0628ae24fa58 +a58e469f65d366b519f9a394cacb7edaddac214463b7b6d62c2dbc1316e11c6c5184ce45c16de2d77f990dcdd8b55430 +989e71734f8119103586dc9a3c5f5033ddc815a21018b34c1f876cdfc112efa868d5751bf6419323e4e59fa6a03ece1c +a2da00e05036c884369e04cf55f3de7d659cd5fa3f849092b2519dd263694efe0f051953d9d94b7e121f0aee8b6174d7 +968f3c029f57ee31c4e1adea89a7f92e28483af9a74f30fbdb995dc2d40e8e657dff8f8d340d4a92bf65f54440f2859f +932778df6f60ac1639c1453ef0cbd2bf67592759dcccb3e96dcc743ff01679e4c7dd0ef2b0833dda548d32cb4eba49e2 +a805a31139f8e0d6dae1ac87d454b23a3dc9fc653d4ca18d4f8ebab30fc189c16e73981c2cb7dd6f8c30454a5208109d +a9ba0991296caa2aaa4a1ceacfb205544c2a2ec97088eace1d84ee5e2767656a172f75d2f0c4e16a3640a0e0dec316e0 +b1e49055c968dced47ec95ae934cf45023836d180702e20e2df57e0f62fb85d7ac60d657ba3ae13b8560b67210449459 +a94e1da570a38809c71e37571066acabff7bf5632737c9ab6e4a32856924bf6211139ab3cedbf083850ff2d0e0c0fcfc +88ef1bb322000c5a5515b310c838c9af4c1cdbb32eab1c83ac3b2283191cd40e9573747d663763a28dad0d64adc13840 +a987ce205f923100df0fbd5a85f22c9b99b9b9cbe6ddfa8dfda1b8fe95b4f71ff01d6c5b64ca02eb24edb2b255a14ef0 +84fe8221a9e95d9178359918a108de4763ebfa7a6487facb9c963406882a08a9a93f492f8e77cf9e7ea41ae079c45993 +aa1cf3dc7c5dcfa15bbbc811a4bb6dbac4fba4f97fb1ed344ab60264d7051f6eef19ea9773441d89929ee942ed089319 +8f6a7d610d59d9f54689bbe6a41f92d9f6096cde919c1ab94c3c7fcecf0851423bc191e5612349e10f855121c0570f56 +b5af1fa7894428a53ea520f260f3dc3726da245026b6d5d240625380bfb9c7c186df0204bb604efac5e613a70af5106e +a5bce6055ff812e72ce105f147147c7d48d7a2313884dd1f488b1240ee320f13e8a33f5441953a8e7a3209f65b673ce1 +b9b55b4a1422677d95821e1d042ab81bbf0bf087496504021ec2e17e238c2ca6b44fb3b635a5c9eac0871a724b8d47c3 +941c38e533ce4a673a3830845b56786585e5fe49c427f2e5c279fc6db08530c8f91db3e6c7822ec6bb4f956940052d18 +a38e191d66c625f975313c7007bbe7431b5a06ed2da1290a7d5d0f2ec73770d476efd07b8e632de64597d47df175cbb0 +94ba76b667abf055621db4c4145d18743a368d951565632ed4e743dd50dd3333507c0c34f286a5c5fdbf38191a2255cd +a5ca38c60be5602f2bfa6e00c687ac96ac36d517145018ddbee6f12eb0faa63dd57909b9eeed26085fe5ac44e55d10ab +b00fea3b825e60c1ed1c5deb4b551aa65a340e5af36b17d5262c9cd2c508711e4dc50dc2521a2c16c7c901902266e64a +971b86fc4033485e235ccb0997a236206ba25c6859075edbcdf3c943116a5030b7f75ebca9753d863a522ba21a215a90 +b3b31f52370de246ee215400975b674f6da39b2f32514fe6bd54e747752eedca22bb840493b44a67df42a3639c5f901f +affbbfac9c1ba7cbfa1839d2ae271dd6149869b75790bf103230637da41857fc326ef3552ff31c15bda0694080198143 +a95d42aa7ef1962520845aa3688f2752d291926f7b0d73ea2ee24f0612c03b43f2b0fe3c9a9a99620ffc8d487b981bc2 +914a266065caf64985e8c5b1cb2e3f4e3fe94d7d085a1881b1fefa435afef4e1b39a98551d096a62e4f5cc1a7f0fdc2e +81a0b4a96e2b75bc1bf2dbd165d58d55cfd259000a35504d1ffb18bc346a3e6f07602c683723864ffb980f840836fd8d +91c1556631cddd4c00b65b67962b39e4a33429029d311c8acf73a18600e362304fb68bccb56fde40f49e95b7829e0b87 +8befbacc19e57f7c885d1b7a6028359eb3d80792fe13b92a8400df21ce48deb0bb60f2ddb50e3d74f39f85d7eab23adc +92f9458d674df6e990789690ec9ca73dacb67fc9255b58c417c555a8cc1208ace56e8e538f86ba0f3615573a0fbac00d +b4b1b3062512d6ae7417850c08c13f707d5838e43d48eb98dd4621baf62eee9e82348f80fe9b888a12874bfa538771f8 +a13c4a3ac642ede37d9c883f5319e748d2b938f708c9d779714108a449b343f7b71a6e3ef4080fee125b416762920273 +af44983d5fc8cceee0551ef934e6e653f2d3efa385e5c8a27a272463a6f333e290378cc307c2b664eb923c78994e706e +a389fd6c59fe2b4031cc244e22d3991e541bd203dd5b5e73a6159e72df1ab41d49994961500dcde7989e945213184778 +8d2141e4a17836c548de9598d7b298b03f0e6c73b7364979a411c464e0628e21cff6ac3d6decdba5d1c4909eff479761 +980b22ef53b7bdf188a3f14bc51b0dbfdf9c758826daa3cbc1e3986022406a8aa9a6a79e400567120b88c67faa35ce5f +a28882f0a055f96df3711de5d0aa69473e71245f4f3e9aa944e9d1fb166e02caa50832e46da6d3a03b4801735fd01b29 +8db106a37d7b88f5d995c126abb563934dd8de516af48e85695d02b1aea07f79217e3cdd03c6f5ca57421830186c772b +b5a7e50da0559a675c472f7dfaee456caab6695ab7870541b2be8c2b118c63752427184aad81f0e1afc61aef1f28c46f +9962118780e20fe291d10b64f28d09442a8e1b5cffd0f3dd68d980d0614050a626c616b44e9807fbee7accecae00686a +b38ddf33745e8d2ad6a991aefaf656a33c5f8cbe5d5b6b6fd03bd962153d8fd0e01b5f8f96d80ae53ab28d593ab1d4e7 +857dc12c0544ff2c0c703761d901aba636415dee45618aba2e3454ff9cbc634a85c8b05565e88520ff9be2d097c8b2b1 +a80d465c3f8cc63af6d74a6a5086b626c1cb4a8c0fee425964c3bd203d9d7094e299f81ce96d58afc20c8c9a029d9dae +89e1c8fbde8563763be483123a3ed702efac189c6d8ab4d16c85e74bbaf856048cc42d5d6e138633a38572ba5ec3f594 +893a594cf495535f6d216508f8d03c317dcf03446668cba688da90f52d0111ac83d76ad09bf5ea47056846585ee5c791 +aadbd8be0ae452f7f9450c7d2957598a20cbf10139a4023a78b4438172d62b18b0de39754dd2f8862dbd50a3a0815e53 +ae7d39670ecca3eb6db2095da2517a581b0e8853bdfef619b1fad9aacd443e7e6a40f18209fadd44038a55085c5fe8b2 +866ef241520eacb6331593cfcb206f7409d2f33d04542e6e52cba5447934e02d44c471f6c9a45963f9307e9809ab91d9 +b1a09911ad3864678f7be79a9c3c3eb5c84a0a45f8dcb52c67148f43439aeaaa9fd3ed3471276b7e588b49d6ebe3033a +add07b7f0dbb34049cd8feeb3c18da5944bf706871cfd9f14ff72f6c59ad217ebb1f0258b13b167851929387e4e34cfe +ae048892d5c328eefbdd4fba67d95901e3c14d974bfc0a1fc68155ca9f0d59e61d7ba17c6c9948b120cf35fd26e6fee9 +9185b4f3b7da0ddb4e0d0f09b8a9e0d6943a4611e43f13c3e2a767ed8592d31e0ba3ebe1914026a3627680274291f6e5 +a9c022d4e37b0802284ce3b7ee9258628ab4044f0db4de53d1c3efba9de19d15d65cc5e608dbe149c21c2af47d0b07b5 +b24dbd5852f8f24921a4e27013b6c3fa8885b973266cb839b9c388efad95821d5d746348179dcc07542bd0d0aefad1ce +b5fb4f279300876a539a27a441348764908bc0051ebd66dc51739807305e73db3d2f6f0f294ffb91b508ab150eaf8527 +ace50841e718265b290c3483ed4b0fdd1175338c5f1f7530ae9a0e75d5f80216f4de37536adcbc8d8c95982e88808cd0 +b19cadcde0f63bd1a9c24bd9c2806f53c14c0b9735bf351601498408ba503ddbd2037c891041cbba47f58b8c483f3b21 +b6061e63558d312eb891b97b39aa552fa218568d79ee26fe6dd5b864aea9e3216d8f2e2f3b093503be274766dac41426 +89730fdb2876ab6f0fe780d695f6e12090259027e789b819956d786e977518057e5d1d7f5ab24a3ae3d5d4c97773bd2b +b6fa841e81f9f2cad0163a02a63ae96dc341f7ae803b616efc6e1da2fbea551c1b96b11ad02c4afbdf6d0cc9f23da172 +8fb66187182629c861ddb6896d7ed3caf2ad050c3dba8ab8eb0d7a2c924c3d44c48d1a148f9e33fb1f061b86972f8d21 +86022ac339c1f84a7fa9e05358c1a5b316b4fc0b83dbe9c8c7225dc514f709d66490b539359b084ce776e301024345fa +b50b9c321468da950f01480bb62b6edafd42f83c0001d6e97f2bd523a1c49a0e8574fb66380ea28d23a7c4d54784f9f0 +a31c05f7032f30d1dac06678be64d0250a071fd655e557400e4a7f4c152be4d5c7aa32529baf3e5be7c4bd49820054f6 +b95ac0848cd322684772119f5b682d90a66bbf9dac411d9d86d2c34844bbd944dbaf8e47aa41380455abd51687931a78 +ae4a6a5ce9553b65a05f7935e61e496a4a0f6fd8203367a2c627394c9ce1e280750297b74cdc48fd1d9a31e93f97bef4 +a22daf35f6e9b05e52e0b07f7bd1dbbebd2c263033fb0e1b2c804e2d964e2f11bc0ece6aca6af079dd3a9939c9c80674 +902150e0cb1f16b9b59690db35281e28998ce275acb313900da8b2d8dfd29fa1795f8ca3ff820c31d0697de29df347c1 +b17b5104a5dc665cdd7d47e476153d715eb78c6e5199303e4b5445c21a7fa7cf85fe7cfd08d7570f4e84e579b005428c +a03f49b81c15433f121680aa02d734bb9e363af2156654a62bcb5b2ba2218398ccb0ff61104ea5d7df5b16ea18623b1e +802101abd5d3c88876e75a27ffc2f9ddcce75e6b24f23dba03e5201281a7bd5cc7530b6a003be92d225093ca17d3c3bb +a4d183f63c1b4521a6b52226fc19106158fc8ea402461a5cccdaa35fee93669df6a8661f45c1750cd01308149b7bf08e +8d17c22e0c8403b69736364d460b3014775c591032604413d20a5096a94d4030d7c50b9fe3240e31d0311efcf9816a47 +947225acfcce5992eab96276f668c3cbe5f298b90a59f2bb213be9997d8850919e8f496f182689b5cbd54084a7332482 +8df6f4ed216fc8d1905e06163ba1c90d336ab991a18564b0169623eb39b84e627fa267397da15d3ed754d1f3423bff07 +83480007a88f1a36dea464c32b849a3a999316044f12281e2e1c25f07d495f9b1710b4ba0d88e9560e72433addd50bc2 +b3019d6e591cf5b33eb972e49e06c6d0a82a73a75d78d383dd6f6a4269838289e6e07c245f54fed67f5c9bb0fd5e1c5f +92e8ce05e94927a9fb02debadb99cf30a26172b2705003a2c0c47b3d8002bf1060edb0f6a5750aad827c98a656b19199 +ac2aff801448dbbfc13cca7d603fd9c69e82100d997faf11f465323b97255504f10c0c77401e4d1890339d8b224f5803 +b0453d9903d08f508ee27e577445dc098baed6cde0ac984b42e0f0efed62760bd58d5816cf1e109d204607b7b175e30c +ae68dc4ba5067e825d46d2c7c67f1009ceb49d68e8d3e4c57f4bcd299eb2de3575d42ea45e8722f8f28497a6e14a1cfe +b22486c2f5b51d72335ce819bbafb7fa25eb1c28a378a658f13f9fc79cd20083a7e573248d911231b45a5cf23b561ca7 +89d1201d1dbd6921867341471488b4d2fd0fc773ae1d4d074c78ae2eb779a59b64c00452c2a0255826fca6b3d03be2b1 +a2998977c91c7a53dc6104f5bc0a5b675e5350f835e2f0af69825db8af4aeb68435bdbcc795f3dd1f55e1dd50bc0507f +b0be4937a925b3c05056ed621910d535ccabf5ab99fd3b9335080b0e51d9607d0fd36cb5781ff340018f6acfca4a9736 +aea145a0f6e0ba9df8e52e84bb9c9de2c2dc822f70d2724029b153eb68ee9c17de7d35063dcd6a39c37c59fdd12138f7 +91cb4545d7165ee8ffbc74c874baceca11fdebbc7387908d1a25877ca3c57f2c5def424dab24148826832f1e880bede0 +b3b579cb77573f19c571ad5eeeb21f65548d7dff9d298b8d7418c11f3e8cd3727c5b467f013cb87d6861cfaceee0d2e3 +b98a1eeec2b19fecc8378c876d73645aa52fb99e4819903735b2c7a885b242787a30d1269a04bfb8573d72d9bbc5f0f0 +940c1f01ed362bd588b950c27f8cc1d52276c71bb153d47f07ec85b038c11d9a8424b7904f424423e714454d5e80d1cd +aa343a8ecf09ce11599b8cf22f7279cf80f06dbf9f6d62cb05308dbbb39c46fd0a4a1240b032665fbb488a767379b91b +87c3ac72084aca5974599d3232e11d416348719e08443acaba2b328923af945031f86432e170dcdd103774ec92e988c9 +91d6486eb5e61d2b9a9e742c20ec974a47627c6096b3da56209c2b4e4757f007e793ebb63b2b246857c9839b64dc0233 +aebcd3257d295747dd6fc4ff910d839dd80c51c173ae59b8b2ec937747c2072fa85e3017f9060aa509af88dfc7529481 +b3075ba6668ca04eff19efbfa3356b92f0ab12632dcda99cf8c655f35b7928c304218e0f9799d68ef9f809a1492ff7db +93ba7468bb325639ec2abd4d55179c69fd04eaaf39fc5340709227bbaa4ad0a54ea8b480a1a3c8d44684e3be0f8d1980 +a6aef86c8c0d92839f38544d91b767c582568b391071228ff5a5a6b859c87bf4f81a7d926094a4ada1993ddbd677a920 +91dcd6d14207aa569194aa224d1e5037b999b69ade52843315ca61ba26abe9a76412c9e88259bc5cf5d7b95b97d9c3bc +b3b483d31c88f78d49bd065893bc1e3d2aa637e27dedb46d9a7d60be7660ce7a10aaaa7deead362284a52e6d14021178 +8e5730070acf8371461ef301cc4523e8e672aa0e3d945d438a0e0aa6bdf8cb9c685dcf38df429037b0c8aff3955c6f5b +b8c6d769890a8ee18dc4f9e917993315877c97549549b34785a92543cbeec96a08ae3a28d6e809c4aacd69de356c0012 +95ca86cd384eaceaa7c077c5615736ca31f36824bd6451a16142a1edc129fa42b50724aeed7c738f08d7b157f78b569e +94df609c6d71e8eee7ab74226e371ccc77e01738fe0ef1a6424435b4570fe1e5d15797b66ed0f64eb88d4a3a37631f0e +89057b9783212add6a0690d6bb99097b182738deff2bd9e147d7fd7d6c8eacb4c219923633e6309ad993c24572289901 +83a0f9f5f265c5a0e54defa87128240235e24498f20965009fef664f505a360b6fb4020f2742565dfc7746eb185bcec0 +91170da5306128931349bc3ed50d7df0e48a68b8cc8420975170723ac79d8773e4fa13c5f14dc6e3fafcad78379050b1 +b7178484d1b55f7e56a4cc250b6b2ec6040437d96bdfddfa7b35ed27435860f3855c2eb86c636f2911b012eb83b00db8 +ac0b00c4322d1e4208e09cd977b4e54d221133ff09551f75b32b0b55d0e2be80941dda26257b0e288c162e63c7e9cf68 +9690ed9e7e53ed37ff362930e4096b878b12234c332fd19d5d064824084245952eda9f979e0098110d6963e468cf513e +b6fa547bb0bb83e5c5be0ed462a8783fba119041c136a250045c09d0d2af330c604331e7de960df976ff76d67f8000cd +814603907c21463bcf4e59cfb43066dfe1a50344ae04ef03c87c0f61b30836c3f4dea0851d6fa358c620045b7f9214c8 +9495639e3939fad2a3df00a88603a5a180f3c3a0fe4d424c35060e2043e0921788003689887b1ed5be424d9a89bb18bb +aba4c02d8d57f2c92d5bc765885849e9ff8393d6554f5e5f3e907e5bfac041193a0d8716d7861104a4295d5a03c36b03 +8ead0b56c1ca49723f94a998ba113b9058059321da72d9e395a667e6a63d5a9dac0f5717cec343f021695e8ced1f72af +b43037f7e3852c34ed918c5854cd74e9d5799eeddfe457d4f93bb494801a064735e326a76e1f5e50a339844a2f4a8ec9 +99db8422bb7302199eb0ff3c3d08821f8c32f53a600c5b6fb43e41205d96adae72be5b460773d1280ad1acb806af9be8 +8a9be08eae0086c0f020838925984df345c5512ff32e37120b644512b1d9d4fecf0fd30639ca90fc6cf334a86770d536 +81b43614f1c28aa3713a309a88a782fb2bdfc4261dd52ddc204687791a40cf5fd6a263a8179388596582cccf0162efc2 +a9f3a8b76912deb61d966c75daf5ddb868702ebec91bd4033471c8e533183df548742a81a2671de5be63a502d827437d +902e2415077f063e638207dc7e14109652e42ab47caccd6204e2870115791c9defac5425fd360b37ac0f7bd8fe7011f8 +aa18e4fdc1381b59c18503ae6f6f2d6943445bd00dd7d4a2ad7e5adad7027f2263832690be30d456e6d772ad76f22350 +a348b40ba3ba7d81c5d4631f038186ebd5e5f314f1ea737259151b07c3cc8cf0c6ed4201e71bcc1c22fefda81a20cde6 +aa1306f7ac1acbfc47dc6f7a0cb6d03786cec8c8dc8060388ccda777bca24bdc634d03e53512c23dba79709ff64f8620 +818ccfe46e700567b7f3eb400e5a35f6a5e39b3db3aa8bc07f58ace35d9ae5a242faf8dbccd08d9a9175bbce15612155 +b7e3da2282b65dc8333592bb345a473f03bd6df69170055fec60222de9897184536bf22b9388b08160321144d0940279 +a4d976be0f0568f4e57de1460a1729129252b44c552a69fceec44e5b97c96c711763360d11f9e5bf6d86b4976bf40d69 +85d185f0397c24c2b875b09b6328a23b87982b84ee880f2677a22ff4c9a1ba9f0fea000bb3f7f66375a00d98ebafce17 +b4ccbb8c3a2606bd9b87ce022704663af71d418351575f3b350d294f4efc68c26f9a2ce49ff81e6ff29c3b63d746294e +93ffd3265fddb63724dfde261d1f9e22f15ecf39df28e4d89e9fea03221e8e88b5dd9b77628bacaa783c6f91802d47cc +b1fd0f8d7a01378e693da98d03a2d2fda6b099d03454b6f2b1fa6472ff6bb092751ce6290059826b74ac0361eab00e1e +a89f440c71c561641589796994dd2769616b9088766e983c873fae0716b95c386c8483ab8a4f367b6a68b72b7456dd32 +af4fe92b01d42d03dd5d1e7fa55e96d4bbcb7bf7d4c8c197acd16b3e0f3455807199f683dcd263d74547ef9c244b35cc +a8227f6e0a344dfe76bfbe7a1861be32c4f4bed587ccce09f9ce2cf481b2dda8ae4f566154bc663d15f962f2d41761bd +a7b361663f7495939ed7f518ba45ea9ff576c4e628995b7aea026480c17a71d63fc2c922319f0502eb7ef8f14a406882 +8ddcf382a9f39f75777160967c07012cfa89e67b19714a7191f0c68eaf263935e5504e1104aaabd0899348c972a8d3c6 +98c95b9f6f5c91f805fb185eedd06c6fc4457d37dd248d0be45a6a168a70031715165ea20606245cbdf8815dc0ac697f +805b44f96e001e5909834f70c09be3efcd3b43632bcac5b6b66b6d227a03a758e4b1768ce2a723045681a1d34562aaeb +b0e81b07cdc45b3dca60882676d9badb99f25c461b7efe56e3043b80100bb62d29e1873ae25eb83087273160ece72a55 +b0c53f0abe78ee86c7b78c82ae1f7c070bb0b9c45c563a8b3baa2c515d482d7507bb80771e60b38ac13f78b8af92b4a9 +a7838ef6696a9e4d2e5dfd581f6c8d6a700467e8fd4e85adabb5f7a56f514785dd4ab64f6f1b48366f7d94728359441b +88c76f7700a1d23c30366a1d8612a796da57b2500f97f88fdf2d76b045a9d24e7426a8ffa2f4e86d3046937a841dad58 +ad8964baf98c1f02e088d1d9fcb3af6b1dfa44cdfe0ed2eae684e7187c33d3a3c28c38e8f4e015f9c04d451ed6f85ff6 +90e9d00a098317ececaa9574da91fc149eda5b772dedb3e5a39636da6603aa007804fa86358550cfeff9be5a2cb7845e +a56ff4ddd73d9a6f5ab23bb77efa25977917df63571b269f6a999e1ad6681a88387fcc4ca3b26d57badf91b236503a29 +97ad839a6302c410a47e245df84c01fb9c4dfef86751af3f9340e86ff8fc3cd52fa5ff0b9a0bd1d9f453e02ca80658a6 +a4c8c44cbffa804129e123474854645107d1f0f463c45c30fd168848ebea94880f7c0c5a45183e9eb837f346270bdb35 +a72e53d0a1586d736e86427a93569f52edd2f42b01e78aee7e1961c2b63522423877ae3ac1227a2cf1e69f8e1ff15bc3 +8559f88a7ef13b4f09ac82ae458bbae6ab25671cfbf52dae7eac7280d6565dd3f0c3286aec1a56a8a16dc3b61d78ce47 +8221503f4cdbed550876c5dc118a3f2f17800c04e8be000266633c83777b039a432d576f3a36c8a01e8fd18289ebc10b +99bfbe5f3e46d4d898a578ba86ed26de7ed23914bd3bcdf3c791c0bcd49398a52419077354a5ab75cea63b6c871c6e96 +aa134416d8ff46f2acd866c1074af67566cfcf4e8be8d97329dfa0f603e1ff208488831ce5948ac8d75bfcba058ddcaa +b02609d65ebfe1fe8e52f21224a022ea4b5ea8c1bd6e7b9792eed8975fc387cdf9e3b419b8dd5bcce80703ab3a12a45f +a4f14798508698fa3852e5cac42a9db9797ecee7672a54988aa74037d334819aa7b2ac7b14efea6b81c509134a6b7ad2 +884f01afecbcb987cb3e7c489c43155c416ed41340f61ecb651d8cba884fb9274f6d9e7e4a46dd220253ae561614e44c +a05523c9e71dce1fe5307cc71bd721feb3e1a0f57a7d17c7d1c9fb080d44527b7dbaa1f817b1af1c0b4322e37bc4bb1e +8560aec176a4242b39f39433dd5a02d554248c9e49d3179530815f5031fee78ba9c71a35ceeb2b9d1f04c3617c13d8f0 +996aefd402748d8472477cae76d5a2b92e3f092fc834d5222ae50194dd884c9fb8b6ed8e5ccf8f6ed483ddbb4e80c747 +8fd09900320000cbabc40e16893e2fcf08815d288ec19345ad7b6bb22f7d78a52b6575a3ca1ca2f8bc252d2eafc928ec +939e51f73022bc5dc6862a0adf8fb8a3246b7bfb9943cbb4b27c73743926cc20f615a036c7e5b90c80840e7f1bfee0e7 +a0a6258700cadbb9e241f50766573bf9bdb7ad380b1079dc3afb4054363d838e177b869cad000314186936e40359b1f2 +972699a4131c8ed27a2d0e2104d54a65a7ff1c450ad9da3a325c662ab26869c21b0a84d0700b98c8b5f6ce3b746873d7 +a454c7fe870cb8aa6491eafbfb5f7872d6e696033f92e4991d057b59d70671f2acdabef533e229878b60c7fff8f748b1 +a167969477214201f09c79027b10221e4707662e0c0fde81a0f628249f2f8a859ce3d30a7dcc03b8ecca8f7828ad85c7 +8ff6b7265175beb8a63e1dbf18c9153fb2578c207c781282374f51b40d57a84fd2ef2ea2b9c6df4a54646788a62fd17f +a3d7ebeccde69d73d8b3e76af0da1a30884bb59729503ff0fb0c3bccf9221651b974a6e72ea33b7956fc3ae758226495 +b71ef144c9a98ce5935620cb86c1590bd4f48e5a2815d25c0cdb008fde628cf628c31450d3d4f67abbfeb16178a74cfd +b5e0a16d115134f4e2503990e3f2035ed66b9ccf767063fe6747870d97d73b10bc76ed668550cb82eedc9a2ca6f75524 +b30ffaaf94ee8cbc42aa2c413175b68afdb207dbf351fb20be3852cb7961b635c22838da97eaf43b103aff37e9e725cc +98aa7d52284f6c1f22e272fbddd8c8698cf8f5fbb702d5de96452141fafb559622815981e50b87a72c2b1190f59a7deb +81fbacda3905cfaf7780bb4850730c44166ed26a7c8d07197a5d4dcd969c09e94a0461638431476c16397dd7bdc449f9 +95e47021c1726eac2e5853f570d6225332c6e48e04c9738690d53e07c6b979283ebae31e2af1fc9c9b3e59f87e5195b1 +ac024a661ba568426bb8fce21780406537f518075c066276197300841e811860696f7588188bc01d90bace7bc73d56e3 +a4ebcaf668a888dd404988ab978594dee193dad2d0aec5cdc0ccaf4ec9a7a8228aa663db1da8ddc52ec8472178e40c32 +a20421b8eaf2199d93b083f2aff37fb662670bd18689d046ae976d1db1fedd2c2ff897985ecc6277b396db7da68bcb27 +8bc33d4b40197fd4d49d1de47489d10b90d9b346828f53a82256f3e9212b0cbc6930b895e879da9cec9fedf026aadb3e +aaafdd1bec8b757f55a0433eddc0a39f818591954fd4e982003437fcceb317423ad7ee74dbf17a2960380e7067a6b4e2 +aad34277ebaed81a6ec154d16736866f95832803af28aa5625bf0461a71d02b1faba02d9d9e002be51c8356425a56867 +976e9c8b150d08706079945bd0e84ab09a648ecc6f64ded9eb5329e57213149ae409ae93e8fbd8eda5b5c69f5212b883 +8097fae1653247d2aed4111533bc378171d6b2c6d09cbc7baa9b52f188d150d645941f46d19f7f5e27b7f073c1ebd079 +83905f93b250d3184eaba8ea7d727c4464b6bdb027e5cbe4f597d8b9dc741dcbea709630bd4fd59ce24023bec32fc0f3 +8095030b7045cff28f34271386e4752f9a9a0312f8df75de4f424366d78534be2b8e1720a19cb1f9a2d21105d790a225 +a7b7b73a6ae2ed1009c49960374b0790f93c74ee03b917642f33420498c188a169724945a975e5adec0a1e83e07fb1b2 +856a41c54df393b6660b7f6354572a4e71c8bfca9cabaffb3d4ef2632c015e7ee2bc10056f3eccb3dbed1ad17d939178 +a8f7a55cf04b38cd4e330394ee6589da3a07dc9673f74804fdf67b364e0b233f14aec42e783200a2e4666f7c5ff62490 +82c529f4e543c6bca60016dc93232c115b359eaee2798a9cf669a654b800aafe6ab4ba58ea8b9cdda2b371c8d62fa845 +8caab020c1baddce77a6794113ef1dfeafc5f5000f48e97f4351b588bf02f1f208101745463c480d37f588d5887e6d8c +8fa91b3cc400f48b77b6fd77f3b3fbfb3f10cdff408e1fd22d38f77e087b7683adad258804409ba099f1235b4b4d6fea +8aa02787663d6be9a35677d9d8188b725d5fcd770e61b11b64e3def8808ea5c71c0a9afd7f6630c48634546088fcd8e2 +b5635b7b972e195cab878b97dea62237c7f77eb57298538582a330b1082f6207a359f2923864630136d8b1f27c41b9aa +8257bb14583551a65975946980c714ecd6e5b629672bb950b9caacd886fbd22704bc9e3ba7d30778adab65dc74f0203a +ab5fe1cd12634bfa4e5c60d946e2005cbd38f1063ec9a5668994a2463c02449a0a185ef331bd86b68b6e23a8780cb3ba +a7d3487da56cda93570cc70215d438204f6a2709bfb5fda6c5df1e77e2efc80f4235c787e57fbf2c74aaff8cbb510a14 +b61cff7b4c49d010e133319fb828eb900f8a7e55114fc86b39c261a339c74f630e1a7d7e1350244ada566a0ff3d46c4b +8d4d1d55d321d278db7a85522ccceca09510374ca81d4d73e3bb5249ace7674b73900c35a531ec4fa6448fabf7ad00dc +966492248aee24f0f56c8cfca3c8ec6ba3b19abb69ae642041d4c3be8523d22c65c4dafcab4c58989ccc4e0bd2f77919 +b20c320a90cb220b86e1af651cdc1e21315cd215da69f6787e28157172f93fc8285dcd59b039c626ed8ca4633cba1a47 +aae9e6b22f018ceb5c0950210bb8182cb8cb61014b7e14581a09d36ebd1bbfebdb2b82afb7fdb0cf75e58a293d9c456d +875547fb67951ad37b02466b79f0c9b985ccbc500cfb431b17823457dc79fb9597ec42cd9f198e15523fcd88652e63a4 +92afce49773cb2e20fb21e4f86f18e0959ebb9c33361547ddb30454ee8e36b1e234019cbdca0e964cb292f7f77df6b90 +8af85343dfe1821464c76ba11c216cbef697b5afc69c4d821342e55afdac047081ec2e3f7b09fc14b518d9a23b78c003 +b7de4a1648fd63f3a918096ea669502af5357438e69dac77cb8102b6e6c15c76e033cfaa80dafc806e535ede5c1a20aa +ac80e9b545e8bd762951d96c9ce87f629d01ffcde07efc2ef7879ca011f1d0d8a745abf26c9d452541008871304fac00 +a4cf0f7ed724e481368016c38ea5816698a5f68eb21af4d3c422d2ba55f96a33e427c2aa40de1b56a7cfac7f7cf43ab0 +899b0a678bb2db2cae1b44e75a661284844ebcdd87abf308fedeb2e4dbe5c5920c07db4db7284a7af806a2382e8b111a +af0588a2a4afce2b1b13c1230816f59e8264177e774e4a341b289a101dcf6af813638fed14fb4d09cb45f35d5d032609 +a4b8df79e2be76e9f5fc5845f06fe745a724cf37c82fcdb72719b77bdebea3c0e763f37909373e3a94480cc5e875cba0 +83e42c46d88930c8f386b19fd999288f142d325e2ebc86a74907d6d77112cb0d449bc511c95422cc810574031a8cbba9 +b5e39534070de1e5f6e27efbdd3dc917d966c2a9b8cf2d893f964256e95e954330f2442027dc148c776d63a95bcde955 +958607569dc28c075e658cd4ae3927055c6bc456eef6212a6fea8205e48ed8777a8064f584cda38fe5639c371e2e7fba +812adf409fa63575113662966f5078a903212ffb65c9b0bbe62da0f13a133443a7062cb8fd70f5e5dd5559a32c26d2c8 +a679f673e5ce6a3cce7fa31f22ee3785e96bcb55e5a776e2dd3467bef7440e3555d1a9b87cb215e86ee9ed13a090344b +afedbb34508b159eb25eb2248d7fe328f86ef8c7d84c62d5b5607d74aae27cc2cc45ee148eb22153b09898a835c58df4 +b75505d4f6b67d31e665cfaf5e4acdb5838ae069166b7fbcd48937c0608a59e40a25302fcc1873d2e81c1782808c70f0 +b62515d539ec21a155d94fc00ea3c6b7e5f6636937bce18ed5b618c12257fb82571886287fd5d1da495296c663ebc512 +ab8e1a9446bbdd588d1690243b1549d230e6149c28f59662b66a8391a138d37ab594df38e7720fae53217e5c3573b5be +b31e8abf4212e03c3287bb2c0a153065a7290a16764a0bac8f112a72e632185a654bb4e88fdd6053e6c7515d9719fadb +b55165477fe15b6abd2d0f4fddaa9c411710dcc4dd712daba3d30e303c9a3ee5415c256f9dc917ecf18c725b4dbab059 +a0939d4f57cacaae549b78e87cc234de4ff6a35dc0d9cd5d7410abc30ebcd34c135e008651c756e5a9d2ca79c40ef42b +8cf10e50769f3443340844aad4d56ec790850fed5a41fcbd739abac4c3015f0a085a038fbe7fae9f5ad899cce5069f6b +924055e804d82a99ea4bb160041ea4dc14b568abf379010bc1922fde5d664718c31d103b8b807e3a1ae809390e708c73 +8ec0f9d26f71b0f2e60a179e4fd1778452e2ffb129d50815e5d7c7cb9415fa69ae5890578086e8ef6bfde35ad2a74661 +98c7f12b15ec4426b59f737f73bf5faea4572340f4550b7590dfb7f7ffedb2372e3e555977c63946d579544c53210ad0 +8a935f7a955c78f69d66f18eee0092e5e833fa621781c9581058e219af4d7ceee48b84e472e159dda6199715fb2f9acf +b78d4219f95a2dbfaa7d0c8a610c57c358754f4f43c2af312ab0fe8f10a5f0177e475332fb8fd23604e474fc2abeb051 +8d086a14803392b7318c28f1039a17e3cfdcece8abcaca3657ec3d0ac330842098a85c0212f889fabb296dfb133ce9aa +a53249f417aac82f2c2a50c244ce21d3e08a5e5a8bd33bec2a5ab0d6cd17793e34a17edfa3690899244ce201e2fb9986 +8619b0264f9182867a1425be514dc4f1ababc1093138a728a28bd7e4ecc99b9faaff68c23792264bc6e4dce5f52a5c52 +8c171edbbbde551ec19e31b2091eb6956107dd9b1f853e1df23bff3c10a3469ac77a58335eee2b79112502e8e163f3de +a9d19ec40f0ca07c238e9337c6d6a319190bdba2db76fb63902f3fb459aeeb50a1ac30db5b25ee1b4201f3ca7164a7f4 +b9c6ec14b1581a03520b8d2c1fbbc31fb8ceaef2c0f1a0d0080b6b96e18442f1734bea7ef7b635d787c691de4765d469 +8cb437beb4cfa013096f40ccc169a713dc17afee6daa229a398e45fd5c0645a9ad2795c3f0cd439531a7151945d7064d +a6e8740cc509126e146775157c2eb278003e5bb6c48465c160ed27888ca803fa12eee1f6a8dd7f444f571664ed87fdc1 +b75c1fecc85b2732e96b3f23aefb491dbd0206a21d682aee0225838dc057d7ed3b576176353e8e90ae55663f79e986e4 +ad8d249b0aea9597b08358bce6c77c1fd552ef3fbc197d6a1cfe44e5e6f89b628b12a6fb04d5dcfcbacc51f46e4ae7bb +b998b2269932cbd58d04b8e898d373ac4bb1a62e8567484f4f83e224061bc0f212459f1daae95abdbc63816ae6486a55 +827988ef6c1101cddc96b98f4a30365ff08eea2471dd949d2c0a9b35c3bbfa8c07054ad1f4c88c8fbf829b20bb5a9a4f +8692e638dd60babf7d9f2f2d2ce58e0ac689e1326d88311416357298c6a2bffbfebf55d5253563e7b3fbbf5072264146 +a685d75b91aea04dbc14ab3c1b1588e6de96dae414c8e37b8388766029631b28dd860688079b12d09cd27f2c5af11adf +b57eced93eec3371c56679c259b34ac0992286be4f4ff9489d81cf9712403509932e47404ddd86f89d7c1c3b6391b28c +a1c8b4e42ebcbd8927669a97f1b72e236fb19249325659e72be7ddaaa1d9e81ca2abb643295d41a8c04a2c01f9c0efd7 +877c33de20d4ed31674a671ba3e8f01a316581e32503136a70c9c15bf0b7cb7b1cba6cd4eb641fad165fb3c3c6c235fd +a2a469d84ec478da40838f775d11ad38f6596eb41caa139cc190d6a10b5108c09febae34ffdafac92271d2e73c143693 +972f817caedb254055d52e963ed28c206848b6c4cfdb69dbc961c891f8458eaf582a6d4403ce1177d87bc2ea410ef60a +accbd739e138007422f28536381decc54bb6bd71d93edf3890e54f9ef339f83d2821697d1a4ac1f5a98175f9a9ecb9b5 +8940f8772e05389f823b62b3adc3ed541f91647f0318d7a0d3f293aeeb421013de0d0a3664ea53dd24e5fbe02d7efef6 +8ecce20f3ef6212edef07ec4d6183fda8e0e8cad2c6ccd0b325e75c425ee1faba00b5c26b4d95204238931598d78f49d +97cc72c36335bd008afbed34a3b0c7225933faba87f7916d0a6d2161e6f82e0cdcda7959573a366f638ca75d30e9dab1 +9105f5de8699b5bdb6bd3bb6cc1992d1eac23929c29837985f83b22efdda92af64d9c574aa9640475087201bbbe5fd73 +8ffb33c4f6d05c413b9647eb6933526a350ed2e4278ca2ecc06b0e8026d8dbe829c476a40e45a6df63a633090a3f82ef +8bfc6421fdc9c2d2aaa68d2a69b1a2728c25b84944cc3e6a57ff0c94bfd210d1cbf4ff3f06702d2a8257024d8be7de63 +a80e1dc1dddfb41a70220939b96dc6935e00b32fb8be5dff4eed1f1c650002ff95e4af481c43292e3827363b7ec4768a +96f714ebd54617198bd636ba7f7a7f8995a61db20962f2165078d9ed8ee764d5946ef3cbdc7ebf8435bb8d5dd4c1deac +8cdb0890e33144d66391d2ae73f5c71f5a861f72bc93bff6cc399fc25dd1f9e17d8772592b44593429718784802ac377 +8ccf9a7f80800ee770b92add734ed45a73ecc31e2af0e04364eefc6056a8223834c7c0dc9dfc52495bdec6e74ce69994 +aa0875f423bd68b5f10ba978ddb79d3b96ec093bfbac9ff366323193e339ed7c4578760fb60f60e93598bdf1e5cc4995 +a9214f523957b59c7a4cb61a40251ad72aba0b57573163b0dc0f33e41d2df483fb9a1b85a5e7c080e9376c866790f8cb +b6224b605028c6673a536cc8ff9aeb94e7a22e686fda82cf16068d326469172f511219b68b2b3affb7933af0c1f80d07 +b6d58968d8a017c6a34e24c2c09852f736515a2c50f37232ac6b43a38f8faa7572cc31dade543b594b61b5761c4781d0 +8a97cefe5120020c38deeb861d394404e6c993c6cbd5989b6c9ebffe24f46ad11b4ba6348e2991cbf3949c28cfc3c99d +95bf046f8c3a9c0ce2634be4de3713024daec3fc4083e808903b25ce3ac971145af90686b451efcc72f6b22df0216667 +a6a4e2f71b8fa28801f553231eff2794c0f10d12e7e414276995e21195abc9c2983a8997e41af41e78d19ff6fbb2680b +8e5e62a7ca9c2f58ebaab63db2ff1fb1ff0877ae94b7f5e2897f273f684ae639dff44cc65718f78a9c894787602ab26a +8542784383eec4f565fcb8b9fc2ad8d7a644267d8d7612a0f476fc8df3aff458897a38003d506d24142ad18f93554f2b +b7db68ba4616ea072b37925ec4fb39096358c2832cc6d35169e032326b2d6614479f765ae98913c267105b84afcb9bf2 +8b31dbb9457d23d416c47542c786e07a489af35c4a87dadb8ee91bea5ac4a5315e65625d78dad2cf8f9561af31b45390 +a8545a1d91ac17257732033d89e6b7111db8242e9c6ebb0213a88906d5ef407a2c6fdb444e29504b06368b6efb4f4839 +b1bd85d29ebb28ccfb05779aad8674906b267c2bf8cdb1f9a0591dd621b53a4ee9f2942687ee3476740c0b4a7621a3ae +a2b54534e152e46c50d91fff03ae9cd019ff7cd9f4168b2fe7ac08ef8c3bbc134cadd3f9d6bd33d20ae476c2a8596c8a +b19b571ff4ae3e9f5d95acda133c455e72c9ea9973cae360732859836c0341c4c29ab039224dc5bc3deb824e031675d8 +940b5f80478648bac025a30f3efeb47023ce20ee98be833948a248bca6979f206bb28fc0f17b90acf3bb4abd3d14d731 +8f106b40588586ac11629b96d57808ad2808915d89539409c97414aded90b4ff23286a692608230a52bff696055ba5d6 +ae6bda03aa10da3d2abbc66d764ca6c8d0993e7304a1bdd413eb9622f3ca1913baa6da1e9f4f9e6cf847f14f44d6924d +a18e7796054a340ef826c4d6b5a117b80927afaf2ebd547794c400204ae2caf277692e2eabb55bc2f620763c9e9da66d +8d2d25180dc2c65a4844d3e66819ccfcf48858f0cc89e1c77553b463ec0f7feb9a4002ce26bc618d1142549b9850f232 +863f413a394de42cc8166c1c75d513b91d545fff1de6b359037a742c70b008d34bf8e587afa2d62c844d0c6f0ea753e7 +83cd0cf62d63475e7fcad18a2e74108499cdbf28af2113cfe005e3b5887794422da450b1944d0a986eb7e1f4c3b18f25 +b4f8b350a6d88fea5ab2e44715a292efb12eb52df738c9b2393da3f1ddee68d0a75b476733ccf93642154bceb208f2b8 +b3f52aaa4cd4221cb9fc45936cc67fd3864bf6d26bf3dd86aa85aa55ecfc05f5e392ecce5e7cf9406b4b1c4fce0398c8 +b33137084422fb643123f40a6df2b498065e65230fc65dc31791c330e898c51c3a65ff738930f32c63d78f3c9315f85b +91452bfa75019363976bb7337fe3a73f1c10f01637428c135536b0cdc7da5ce558dae3dfc792aa55022292600814a8ef +ad6ba94c787cd4361ca642c20793ea44f1f127d4de0bb4a77c7fbfebae0fcadbf28e2cb6f0c12c12a07324ec8c19761d +890aa6248b17f1501b0f869c556be7bf2b1d31a176f9978bb97ab7a6bd4138eed32467951c5ef1871944b7f620542f43 +82111db2052194ee7dd22ff1eafffac0443cf969d3762cceae046c9a11561c0fdce9c0711f88ac01d1bed165f8a7cee3 +b1527b71df2b42b55832f72e772a466e0fa05743aacc7814f4414e4bcc8d42a4010c9e0fd940e6f254cafedff3cd6543 +922370fa49903679fc565f09c16a5917f8125e72acfeb060fcdbadbd1644eb9f4016229756019c93c6d609cda5d5d174 +aa4c7d98a96cab138d2a53d4aee8ebff6ef903e3b629a92519608d88b3bbd94de5522291a1097e6acf830270e64c8ee1 +b3dc21608a389a72d3a752883a382baaafc61ecc44083b832610a237f6a2363f24195acce529eb4aed4ef0e27a12b66e +94619f5de05e07b32291e1d7ab1d8b7337a2235e49d4fb5f3055f090a65e932e829efa95db886b32b153bdd05a53ec8c +ade1e92722c2ffa85865d2426fb3d1654a16477d3abf580cfc45ea4b92d5668afc9d09275d3b79283e13e6b39e47424d +b7201589de7bed094911dd62fcd25c459a8e327ac447b69f541cdba30233063e5ddffad0b67e9c3e34adcffedfd0e13d +809d325310f862d6549e7cb40f7e5fc9b7544bd751dd28c4f363c724a0378c0e2adcb5e42ec8f912f5f49f18f3365c07 +a79c20aa533de7a5d671c99eb9eb454803ba54dd4f2efa3c8fec1a38f8308e9905c71e9282955225f686146388506ff6 +a85eeacb5e8fc9f3ed06a3fe2dc3108ab9f8c5877b148c73cf26e4e979bf5795edbe2e63a8d452565fd1176ed40402b2 +97ef55662f8a1ec0842b22ee21391227540adf7708f491436044f3a2eb18c471525e78e1e14fa292507c99d74d7437c6 +93110d64ed5886f3d16ce83b11425576a3a7a9bb831cd0de3f9a0b0f2270a730d68136b4ef7ff035ede004358f419b5c +ac9ed0a071517f0ae4f61ce95916a90ba9a77a3f84b0ec50ef7298acdcd44d1b94525d191c39d6bd1bb68f4471428760 +98abd6a02c7690f5a339adf292b8c9368dfc12e0f8069cf26a5e0ce54b4441638f5c66ea735142f3c28e00a0024267e6 +b51efb73ba6d44146f047d69b19c0722227a7748b0e8f644d0fc9551324cf034c041a2378c56ce8b58d06038fb8a78de +8f115af274ef75c1662b588b0896b97d71f8d67986ae846792702c4742ab855952865ce236b27e2321967ce36ff93357 +b3c4548f14d58b3ab03c222da09e4381a0afe47a72d18d50a94e0008797f78e39e99990e5b4757be62310d400746e35a +a9b1883bd5f31f909b8b1b6dcb48c1c60ed20aa7374b3ffa7f5b2ed036599b5bef33289d23c80a5e6420d191723b92f7 +85d38dffd99487ae5bb41ab4a44d80a46157bbbe8ef9497e68f061721f74e4da513ccc3422936b059575975f6787c936 +adf870fcb96e972c033ab7a35d28ae79ee795f82bc49c3bd69138f0e338103118d5529c53f2d72a9c0d947bf7d312af2 +ab4c7a44e2d9446c6ff303eb49aef0e367a58b22cc3bb27b4e69b55d1d9ee639c9234148d2ee95f9ca8079b1457d5a75 +a386420b738aba2d7145eb4cba6d643d96bda3f2ca55bb11980b318d43b289d55a108f4bc23a9606fb0bccdeb3b3bb30 +847020e0a440d9c4109773ecca5d8268b44d523389993b1f5e60e541187f7c597d79ebd6e318871815e26c96b4a4dbb1 +a530aa7e5ca86fcd1bec4b072b55cc793781f38a666c2033b510a69e110eeabb54c7d8cbcb9c61fee531a6f635ffa972 +87364a5ea1d270632a44269d686b2402da737948dac27f51b7a97af80b66728b0256547a5103d2227005541ca4b7ed04 +8816fc6e16ea277de93a6d793d0eb5c15e9e93eb958c5ef30adaf8241805adeb4da8ce19c3c2167f971f61e0b361077d +8836a72d301c42510367181bb091e4be377777aed57b73c29ef2ce1d475feedd7e0f31676284d9a94f6db01cc4de81a2 +b0d9d8b7116156d9dde138d28aa05a33e61f8a85839c1e9071ccd517b46a5b4b53acb32c2edd7150c15bc1b4bd8db9e3 +ae931b6eaeda790ba7f1cd674e53dc87f6306ff44951fa0df88d506316a5da240df9794ccbd7215a6470e6b31c5ea193 +8c6d5bdf87bd7f645419d7c6444e244fe054d437ed1ba0c122fde7800603a5fadc061e5b836cb22a6cfb2b466f20f013 +90d530c6d0cb654999fa771b8d11d723f54b8a8233d1052dc1e839ea6e314fbed3697084601f3e9bbb71d2b4eaa596df +b0d341a1422588c983f767b1ed36c18b141774f67ef6a43cff8e18b73a009da10fc12120938b8bba27f225bdfd3138f9 +a131b56f9537f460d304e9a1dd75702ace8abd68cb45419695cb8dee76998139058336c87b7afd6239dc20d7f8f940cc +aa6c51fa28975f709329adee1bbd35d49c6b878041841a94465e8218338e4371f5cb6c17f44a63ac93644bf28f15d20f +88440fb584a99ebd7f9ea04aaf622f6e44e2b43bbb49fb5de548d24a238dc8f26c8da2ccf03dd43102bda9f16623f609 +9777b8695b790e702159a4a750d5e7ff865425b95fa0a3c15495af385b91c90c00a6bd01d1b77bffe8c47d01baae846f +8b9d764ece7799079e63c7f01690c8eff00896a26a0d095773dea7a35967a8c40db7a6a74692f0118bf0460c26739af4 +85808c65c485520609c9e61fa1bb67b28f4611d3608a9f7a5030ee61c3aa3c7e7dc17fff48af76b4aecee2cb0dbd22ac +ad2783a76f5b3db008ef5f7e67391fda4e7e36abde6b3b089fc4835b5c339370287935af6bd53998bed4e399eda1136d +96f18ec03ae47c205cc4242ca58e2eff185c9dca86d5158817e2e5dc2207ab84aadda78725f8dc080a231efdc093b940 +97de1ab6c6cc646ae60cf7b86df73b9cf56cc0cd1f31b966951ebf79fc153531af55ca643b20b773daa7cab784b832f7 +870ba266a9bfa86ef644b1ef025a0f1b7609a60de170fe9508de8fd53170c0b48adb37f19397ee8019b041ce29a16576 +ad990e888d279ac4e8db90619d663d5ae027f994a3992c2fbc7d262b5990ae8a243e19157f3565671d1cb0de17fe6e55 +8d9d5adcdd94c5ba3be4d9a7428133b42e485f040a28d16ee2384758e87d35528f7f9868de9bd23d1a42a594ce50a567 +85a33ed75d514ece6ad78440e42f7fcdb59b6f4cff821188236d20edae9050b3a042ce9bc7d2054296e133d033e45022 +92afd2f49a124aaba90de59be85ff269457f982b54c91b06650c1b8055f9b4b0640fd378df02a00e4fc91f7d226ab980 +8c0ee09ec64bd831e544785e3d65418fe83ed9c920d9bb4d0bf6dd162c1264eb9d6652d2def0722e223915615931581c +8369bedfa17b24e9ad48ebd9c5afea4b66b3296d5770e09b00446c5b0a8a373d39d300780c01dcc1c6752792bccf5fd0 +8b9e960782576a59b2eb2250d346030daa50bbbec114e95cdb9e4b1ba18c3d34525ae388f859708131984976ca439d94 +b682bface862008fea2b5a07812ca6a28a58fd151a1d54c708fc2f8572916e0d678a9cb8dc1c10c0470025c8a605249e +a38d5e189bea540a824b36815fc41e3750760a52be0862c4cac68214febdc1a754fb194a7415a8fb7f96f6836196d82a +b9e7fbda650f18c7eb8b40e42cc42273a7298e65e8be524292369581861075c55299ce69309710e5b843cb884de171bd +b6657e5e31b3193874a1bace08f42faccbd3c502fb73ad87d15d18a1b6c2a146f1baa929e6f517db390a5a47b66c0acf +ae15487312f84ed6265e4c28327d24a8a0f4d2d17d4a5b7c29b974139cf93223435aaebe3af918f5b4bb20911799715f +8bb4608beb06bc394e1a70739b872ce5a2a3ffc98c7547bf2698c893ca399d6c13686f6663f483894bccaabc3b9c56ad +b58ac36bc6847077584308d952c5f3663e3001af5ecf2e19cb162e1c58bd6c49510205d453cffc876ca1dc6b8e04a578 +924f65ced61266a79a671ffb49b300f0ea44c50a0b4e3b02064faa99fcc3e4f6061ea8f38168ab118c5d47bd7804590e +8d67d43b8a06b0ff4fafd7f0483fa9ed1a9e3e658a03fb49d9d9b74e2e24858dc1bed065c12392037b467f255d4e5643 +b4d4f87813125a6b355e4519a81657fa97c43a6115817b819a6caf4823f1d6a1169683fd68f8d025cdfa40ebf3069acb +a7fd4d2c8e7b59b8eed3d4332ae94b77a89a2616347402f880bc81bde072220131e6dbec8a605be3a1c760b775375879 +8d4a7d8fa6f55a30df37bcf74952e2fa4fd6676a2e4606185cf154bdd84643fd01619f8fb8813a564f72e3f574f8ce30 +8086fb88e6260e9a9c42e9560fde76315ff5e5680ec7140f2a18438f15bc2cc7d7d43bfb5880b180b738c20a834e6134 +916c4c54721de03934fee6f43de50bb04c81f6f8dd4f6781e159e71c40c60408aa54251d457369d133d4ba3ed7c12cb4 +902e5bf468f11ed9954e2a4a595c27e34abe512f1d6dc08bbca1c2441063f9af3dc5a8075ab910a10ff6c05c1c644a35 +a1302953015e164bf4c15f7d4d35e3633425a78294406b861675667eec77765ff88472306531e5d3a4ec0a2ff0dd6a9e +87874461df3c9aa6c0fa91325576c0590f367075f2f0ecfeb34afe162c04c14f8ce9d608c37ac1adc8b9985bc036e366 +84b50a8a61d3cc609bfb0417348133e698fe09a6d37357ce3358de189efcf35773d78c57635c2d26c3542b13cc371752 +acaed2cff8633d12c1d12bb7270c54d65b0b0733ab084fd47f81d0a6e1e9b6f300e615e79538239e6160c566d8bb8d29 +889e6a0e136372ca4bac90d1ab220d4e1cad425a710e8cdd48b400b73bb8137291ceb36a39440fa84305783b1d42c72f +90952e5becec45b2b73719c228429a2c364991cf1d5a9d6845ae5b38018c2626f4308daa322cab1c72e0f6c621bb2b35 +8f5a97a801b6e9dcd66ccb80d337562c96f7914e7169e8ff0fda71534054c64bf2a9493bb830623d612cfe998789be65 +84f3df8b9847dcf1d63ca470dc623154898f83c25a6983e9b78c6d2d90a97bf5e622445be835f32c1e55e6a0a562ea78 +91d12095cd7a88e7f57f254f02fdb1a1ab18984871dead2f107404bcf8069fe68258c4e6f6ebd2477bddf738135400bb +b771a28bc04baef68604d4723791d3712f82b5e4fe316d7adc2fc01b935d8e644c06d59b83bcb542afc40ebafbee0683 +872f6341476e387604a7e93ae6d6117e72d164e38ebc2b825bc6df4fcce815004d7516423c190c1575946b5de438c08d +90d6b4aa7d40a020cdcd04e8b016d041795961a8e532a0e1f4041252131089114a251791bf57794cadb7d636342f5d1c +899023ba6096a181448d927fed7a0fe858be4eac4082a42e30b3050ee065278d72fa9b9d5ce3bc1372d4cbd30a2f2976 +a28f176571e1a9124f95973f414d5bdbf5794d41c3839d8b917100902ac4e2171eb940431236cec93928a60a77ede793 +838dbe5bcd29c4e465d02350270fa0036cd46f8730b13d91e77afb7f5ed16525d0021d3b2ae173a76c378516a903e0cb +8e105d012dd3f5d20f0f1c4a7e7f09f0fdd74ce554c3032e48da8cce0a77260d7d47a454851387770f5c256fa29bcb88 +8f4df0f9feeb7a487e1d138d13ea961459a6402fd8f8cabb226a92249a0d04ded5971f3242b9f90d08da5ff66da28af6 +ad1cfda4f2122a20935aa32fb17c536a3653a18617a65c6836700b5537122af5a8206befe9eaea781c1244c43778e7f1 +832c6f01d6571964ea383292efc8c8fa11e61c0634a25fa180737cc7ab57bc77f25e614aac9a2a03d98f27b3c1c29de2 +903f89cc13ec6685ac7728521898781fecb300e9094ef913d530bf875c18bcc3ceed7ed51e7b482d45619ab4b025c2e9 +a03c474bb915aad94f171e8d96f46abb2a19c9470601f4c915512ec8b9e743c3938450a2a5b077b4618b9df8809e1dc1 +83536c8456f306045a5f38ae4be2e350878fa7e164ea408d467f8c3bc4c2ee396bd5868008c089183868e4dfad7aa50b +88f26b4ea1b236cb326cd7ad7e2517ec8c4919598691474fe15d09cabcfc37a8d8b1b818f4d112432ee3a716b0f37871 +a44324e3fe96e9c12b40ded4f0f3397c8c7ee8ff5e96441118d8a6bfad712d3ac990b2a6a23231a8f691491ac1fd480f +b0de4693b4b9f932191a21ee88629964878680152a82996c0019ffc39f8d9369bbe2fe5844b68d6d9589ace54af947e4 +8e5d8ba948aea5fd26035351a960e87f0d23efddd8e13236cc8e4545a3dda2e9a85e6521efb8577e03772d3637d213d9 +93efc82d2017e9c57834a1246463e64774e56183bb247c8fc9dd98c56817e878d97b05f5c8d900acf1fbbbca6f146556 +8731176363ad7658a2862426ee47a5dce9434216cef60e6045fa57c40bb3ce1e78dac4510ae40f1f31db5967022ced32 +b10c9a96745722c85bdb1a693100104d560433d45b9ac4add54c7646a7310d8e9b3ca9abd1039d473ae768a18e489845 +a2ac374dfbb464bf850b4a2caf15b112634a6428e8395f9c9243baefd2452b4b4c61b0cb2836d8eae2d57d4900bf407e +b69fe3ded0c4f5d44a09a0e0f398221b6d1bf5dbb8bc4e338b93c64f1a3cac1e4b5f73c2b8117158030ec03787f4b452 +8852cdbaf7d0447a8c6f211b4830711b3b5c105c0f316e3a6a18dcfbb9be08bd6f4e5c8ae0c3692da08a2dfa532f9d5c +93bbf6d7432a7d98ade3f94b57bf9f4da9bc221a180a370b113066dd42601bb9e09edd79e2e6e04e00423399339eebda +a80941c391f1eeafc1451c59e4775d6a383946ff22997aeaadf806542ba451d3b0f0c6864eeba954174a296efe2c1550 +a045fe2bb011c2a2f71a0181a8f457a3078470fb74c628eab8b59aef69ffd0d649723bf74d6885af3f028bc5a104fb39 +b9d8c35911009c4c8cad64692139bf3fc16b78f5a19980790cb6a7aea650a25df4231a4437ae0c351676a7e42c16134f +94c79501ded0cfcbab99e1841abe4a00a0252b3870e20774c3da16c982d74c501916ec28304e71194845be6e3113c7ab +900a66418b082a24c6348d8644ddb1817df5b25cb33044a519ef47cc8e1f7f1e38d2465b7b96d32ed472d2d17f8414c6 +b26f45d393b8b2fcb29bdbb16323dc7f4b81c09618519ab3a39f8ee5bd148d0d9f3c0b5dfab55b5ce14a1cb9206d777b +aa1a87735fc493a80a96a9a57ca40a6d9c32702bfcaa9869ce1a116ae65d69cefe2f3e79a12454b4590353e96f8912b4 +a922b188d3d0b69b4e4ea2a2aa076566962844637da12c0832105d7b31dea4a309eee15d12b7a336be3ea36fcbd3e3b7 +8f3841fcf4105131d8c4d9885e6e11a46c448226401cf99356c291fadb864da9fa9d30f3a73c327f23f9fd99a11d633e +9791d1183fae270e226379af6c497e7da803ea854bb20afa74b253239b744c15f670ee808f708ede873e78d79a626c9a +a4cad52e3369491ada61bf28ada9e85de4516d21c882e5f1cd845bea9c06e0b2887b0c5527fcff6fc28acd3c04f0a796 +b9ac86a900899603452bd11a7892a9bfed8054970bfcbeaa8c9d1930db891169e38d6977f5258c25734f96c8462eee3b +a3a154c28e5580656a859f4efc2f5ebfa7eaa84ca40e3f134fa7865e8581586db74992dbfa4036aa252fba103773ddde +95cc2a0c1885a029e094f5d737e3ecf4d26b99036453a8773c77e360101f9f98676ee246f6f732a377a996702d55691f +842651bbe99720438d8d4b0218feb60481280c05beb17750e9ca0d8c0599a60f873b7fbdcc7d8835ba9a6d57b16eec03 +81ee54699da98f5620307893dcea8f64670609fa20e5622265d66283adeac122d458b3308c5898e6c57c298db2c8b24f +b97868b0b2bc98032d68352a535a1b341b9ff3c7af4e3a7f3ebc82d3419daa1b5859d6aedc39994939623c7cd878bd9b +b60325cd5d36461d07ef253d826f37f9ee6474a760f2fff80f9873d01fd2b57711543cdc8d7afa1c350aa753c2e33dea +8c205326c11d25a46717b780c639d89714c7736c974ae71287e3f4b02e6605ac2d9b4928967b1684f12be040b7bf2dd3 +95a392d82db51e26ade6c2ccd3396d7e40aff68fa570b5951466580d6e56dda51775dce5cf3a74a7f28c3cb2eb551c4d +8f2cc8071eb56dffb70bda6dd433b556221dc8bba21c53353c865f00e7d4d86c9e39f119ea9a8a12ef583e9a55d9a6b6 +9449a71af9672aaf8856896d7e3d788b22991a7103f75b08c0abbcc2bfe60fda4ed8ce502cea4511ff0ea52a93e81222 +857090ab9fdb7d59632d068f3cc8cf27e61f0d8322d30e6b38e780a1f05227199b4cd746aac1311c36c659ef20931f28 +98a891f4973e7d9aaf9ac70854608d4f7493dffc7e0987d7be9dd6029f6ea5636d24ef3a83205615ca1ff403750058e1 +a486e1365bbc278dd66a2a25d258dc82f46b911103cb16aab3945b9c95ae87b386313a12b566df5b22322ede0afe25ad +a9a1eb399ed95d396dccd8d1ac718043446f8b979ec62bdce51c617c97a312f01376ab7fb87d27034e5f5570797b3c33 +b7abc3858d7a74bb446218d2f5a037e0fae11871ed9caf44b29b69c500c1fa1dcfad64c9cdccc9d80d5e584f06213deb +8cfb09fe2e202faa4cebad932b1d35f5ca204e1c2a0c740a57812ac9a6792130d1312aabd9e9d4c58ca168bfebd4c177 +a90a305c2cd0f184787c6be596fa67f436afd1f9b93f30e875f817ac2aae8bdd2e6e656f6be809467e6b3ad84adb86b1 +80a9ef993c2b009ae172cc8f7ec036f5734cf4f4dfa06a7db4d54725e7fbfae5e3bc6f22687bdbb6961939d6f0c87537 +848ade1901931e72b955d7db1893f07003e1708ff5d93174bac5930b9a732640f0578839203e9b77eb27965c700032d3 +93fdf4697609c5ae9c33b9ca2f5f1af44abeb2b98dc4fdf732cf7388de086f410730dc384d9b7a7f447bb009653c8381 +89ce3fb805aea618b5715c0d22a9f46da696b6fa86794f56fdf1d44155a33d42daf1920bcbe36cbacf3cf4c92df9cbc7 +829ce2c342cf82aa469c65f724f308f7a750bd1494adc264609cd790c8718b8b25b5cab5858cf4ee2f8f651d569eea67 +af2f0cee7bf413204be8b9df59b9e4991bc9009e0d6dbe6815181df0ec2ca93ab8f4f3135b1c14d8f53d74bff0bd6f27 +b87998cecf7b88cde93d1779f10a521edd5574a2fbd240102978639ec57433ba08cdb53849038a329cebbe74657268d2 +a64542a1261a6ed3d720c2c3a802303aad8c4c110c95d0f12e05c1065e66f42da494792b6bfc5b9272363f3b1d457f58 +86a6fd042e4f282fadf07a4bfee03fc96a3aea49f7a00f52bf249a20f1ec892326855410e61f37fbb27d9305eb2fc713 +967ea5bc403b6db269682f7fd0df90659350d7e1aa66bc4fab4c9dfcd75ed0bba4b52f1cebc5f34dc8ba810793727629 +a52990f9f3b8616ce3cdc2c74cd195029e6a969753dcf2d1630438700e7d6ebde36538532b3525ac516f5f2ce9dd27a3 +a64f7ff870bab4a8bf0d4ef6f5c744e9bf1021ed08b4c80903c7ad318e80ba1817c3180cc45cb5a1cae1170f0241655f +b00f706fa4de1f663f021e8ad3d155e84ce6084a409374b6e6cd0f924a0a0b51bebaaaf1d228c77233a73b0a5a0df0e9 +8b882cc3bff3e42babdb96df95fb780faded84887a0a9bab896bef371cdcf169d909f5658649e93006aa3c6e1146d62e +9332663ef1d1dcf805c3d0e4ce7a07d9863fb1731172e766b3cde030bf81682cc011e26b773fb9c68e0477b4ae2cfb79 +a8aa8151348dbd4ef40aaeb699b71b4c4bfd3218560c120d85036d14f678f6736f0ec68e80ce1459d3d35feccc575164 +a16cd8b729768f51881c213434aa28301fa78fcb554ddd5f9012ee1e4eae7b5cb3dd88d269d53146dea92d10790faf0b +86844f0ef9d37142faf3b1e196e44fbe280a3ba4189aa05c356778cb9e3b388a2bff95eed305ada8769935c9974e4c57 +ae2eec6b328fccf3b47bcdac32901ac2744a51beb410b04c81dea34dee4912b619466a4f5e2780d87ecefaebbe77b46d +915df4c38d301c8a4eb2dc5b1ba0ffaad67cbb177e0a80095614e9c711f4ef24a4cef133f9d982a63d2a943ba6c8669d +ae6a2a4dedfc2d1811711a8946991fede972fdf2a389b282471280737536ffc0ac3a6d885b1f8bda0366eb0b229b9979 +a9b628c63d08b8aba6b1317f6e91c34b2382a6c85376e8ef2410a463c6796740ae936fc4e9e0737cb9455d1daa287bd8 +848e30bf7edf2546670b390d5cf9ab71f98fcb6add3c0b582cb34996c26a446dee5d1bde4fdcde4fc80c10936e117b29 +907d6096c7c8c087d1808dd995d5d2b9169b3768c3f433475b50c2e2bd4b082f4d543afd8b0b0ddffa9c66222a72d51d +a59970a2493b07339124d763ac9d793c60a03354539ecbcf6035bc43d1ea6e35718202ae6d7060b7d388f483d971573c +b9cfef2af9681b2318f119d8611ff6d9485a68d8044581b1959ab1840cbca576dbb53eec17863d2149966e9feb21122f +ad47271806161f61d3afa45cdfe2babceef5e90031a21779f83dc8562e6076680525b4970b2f11fe9b2b23c382768323 +8e425a99b71677b04fe044625d338811fbb8ee32368a424f6ab2381c52e86ee7a6cecedf777dc97181519d41c351bc22 +86b55b54d7adefc12954a9252ee23ae83efe8b5b4b9a7dc307904413e5d69868c7087a818b2833f9b004213d629be8ad +a14fda6b93923dd11e564ae4457a66f397741527166e0b16a8eb91c6701c244fd1c4b63f9dd3515193ec88fa6c266b35 +a9b17c36ae6cd85a0ed7f6cabc5b47dc8f80ced605db327c47826476dc1fb8f8669aa7a7dc679fbd4ee3d8e8b4bd6a6f +82a0829469c1458d959c821148f15dacae9ea94bf56c59a6ab2d4dd8b3d16d73e313b5a3912a6c1f131d73a8f06730c4 +b22d56d549a53eaef549595924bdb621ff807aa4513feedf3fdcbf7ba8b6b9cfa4481c2f67fc642db397a6b794a8b63a +974c59c24392e2cb9294006cbe3c52163e255f3bd0c2b457bdc68a6338e6d5b6f87f716854492f8d880a6b896ccf757c +b70d247ba7cad97c50b57f526c2ba915786e926a94e8f8c3eebc2e1be6f4255411b9670e382060049c8f4184302c40b2 +ad80201fe75ef21c3ddbd98cf23591e0d7a3ba1036dfe77785c32f44755a212c31f0ceb0a0b6f5ee9b6dc81f358d30c3 +8c656e841f9bb90b9a42d425251f3fdbc022a604d75f5845f479ed4be23e02aaf9e6e56cde351dd7449c50574818a199 +8b88dd3fa209d3063b7c5b058f7249ee9900fbc2287d16da61a0704a0a1d71e45d9c96e1cda7fdf9654534ec44558b22 +961da00cc8750bd84d253c08f011970ae1b1158ad6778e8ed943d547bceaf52d6d5a212a7de3bf2706688c4389b827d2 +a5dd379922549a956033e3d51a986a4b1508e575042b8eaa1df007aa77cf0b8c2ab23212f9c075702788fa9c53696133 +ac8fcfde3a349d1e93fc8cf450814e842005c545c4844c0401bc80e6b96cdb77f29285a14455e167c191d4f312e866cd +ac63d79c799783a8466617030c59dd5a8f92ee6c5204676fd8d881ce5f7f8663bdbeb0379e480ea9b6340ab0dc88e574 +805874fde19ce359041ae2bd52a39e2841acabfd31f965792f2737d7137f36d4e4722ede8340d8c95afa6af278af8acb +8d2f323a228aa8ba7b7dc1399138f9e6b41df1a16a7069003ab8104b8b68506a45141bc5fe66acf430e23e13a545190b +a1610c721a2d9af882bb6b39bea97cff1527a3aea041d25934de080214ae77c959e79957164440686d15ab301e897d4d +aba16d29a47fc36f12b654fde513896723e2c700c4190f11b26aa4011da57737ad717daa02794aa3246e4ae5f0b0cc3a +a406db2f15fdd135f346cc4846623c47edd195e80ba8c7cb447332095314d565e4040694ca924696bb5ee7f8996ea0ba +8b30e2cd9b47d75ba57b83630e40f832249af6c058d4f490416562af451993eec46f3e1f90bc4d389e4c06abd1b32a46 +aacf9eb7036e248e209adbfc3dd7ce386569ea9b312caa4b240726549db3c68c4f1c8cbf8ed5ea9ea60c7e57c9df3b8e +b20fcac63bf6f5ee638a42d7f89be847f348c085ddcbec3fa318f4323592d136c230495f188ef2022aa355cc2b0da6f9 +811eff750456a79ec1b1249d76d7c1547065b839d8d4aaad860f6d4528eb5b669473dcceeeea676cddbc3980b68461b7 +b52d14ae33f4ab422f953392ae76a19c618cc31afc96290bd3fe2fb44c954b5c92c4789f3f16e8793f2c0c1691ade444 +a7826dafeeba0db5b66c4dfcf2b17fd7b40507a5a53ac2e42942633a2cb30b95ba1739a6e9f3b7a0e0f1ec729bf274e2 +8acfd83ddf7c60dd7c8b20c706a3b972c65d336b8f9b3d907bdd8926ced271430479448100050b1ef17578a49c8fa616 +af0c69f65184bb06868029ad46f8465d75c36814c621ac20a5c0b06a900d59305584f5a6709683d9c0e4b6cd08d650a6 +b6cc8588191e00680ee6c3339bd0f0a17ad8fd7f4be57d5d7075bede0ea593a19e67f3d7c1a20114894ee5bfcab71063 +a82fd4f58635129dbb6cc3eb9391cf2d28400018b105fc41500fbbd12bd890b918f97d3d359c29dd3b4c4e34391dfab0 +92fc544ed65b4a3625cf03c41ddff7c039bc22d22c0d59dcc00efd5438401f2606adb125a1d5de294cca216ec8ac35a3 +906f67e4a32582b71f15940523c0c7ce370336935e2646bdaea16a06995256d25e99df57297e39d6c39535e180456407 +97510337ea5bbd5977287339197db55c60533b2ec35c94d0a460a416ae9f60e85cee39be82abeeacd5813cf54df05862 +87e6894643815c0ea48cb96c607266c5ee4f1f82ba5fe352fb77f9b6ed14bfc2b8e09e80a99ac9047dfcf62b2ae26795 +b6fd55dd156622ad7d5d51b7dde75e47bd052d4e542dd6449e72411f68275775c846dde301e84613312be8c7bce58b07 +b98461ac71f554b2f03a94e429b255af89eec917e208a8e60edf5fc43b65f1d17a20de3f31d2ce9f0cb573c25f2f4d98 +96f0dea40ca61cefbee41c4e1fe9a7d81fbe1f49bb153d083ab70f5d0488a1f717fd28cedcf6aa18d07cce2c62801898 +8d7c3ab310184f7dc34b6ce4684e4d29a31e77b09940448ea4daac730b7eb308063125d4dd229046cf11bfd521b771e0 +96f0564898fe96687918bbf0a6adead99cf72e3a35ea3347e124af9d006221f8e82e5a9d2fe80094d5e8d48e610f415e +ad50fcb92c2675a398cf07d4c40a579e44bf8d35f27cc330b57e54d5ea59f7d898af0f75dccfe3726e5471133d70f92b +828beed62020361689ae7481dd8f116902b522fb0c6c122678e7f949fdef70ead011e0e6bffd25678e388744e17cdb69 +8349decac1ca16599eee2efc95bcaabf67631107da1d34a2f917884bd70dfec9b4b08ab7bc4379d6c73b19c0b6e54fb8 +b2a6a2e50230c05613ace9e58bb2e98d94127f196f02d9dddc53c43fc68c184549ca12d713cb1b025d8260a41e947155 +94ff52181aadae832aed52fc3b7794536e2a31a21fc8be3ea312ca5c695750d37f08002f286b33f4023dba1e3253ecfa +a21d56153c7e5972ee9a319501be4faff199fdf09bb821ea9ce64aa815289676c00f105e6f00311b3a5b627091b0d0fc +a27a60d219f1f0c971db73a7f563b371b5c9fc3ed1f72883b2eac8a0df6698400c9954f4ca17d7e94e44bd4f95532afb +a2fc56fae99b1f18ba5e4fe838402164ce82f8a7f3193d0bbd360c2bac07c46f9330c4c7681ffb47074c6f81ee6e7ac6 +b748e530cd3afb96d879b83e89c9f1a444f54e55372ab1dcd46a0872f95ce8f49cf2363fc61be82259e04f555937ed16 +8bf8993e81080c7cbba1e14a798504af1e4950b2f186ab3335b771d6acaee4ffe92131ae9c53d74379d957cb6344d9cd +96774d0ef730d22d7ab6d9fb7f90b9ead44285219d076584a901960542756700a2a1603cdf72be4708b267200f6c36a9 +b47703c2ab17be1e823cc7bf3460db1d6760c0e33862c90ca058845b2ff234b0f9834ddba2efb2ee1770eb261e7d8ffd +84319e67c37a9581f8b09b5e4d4ae88d0a7fb4cbb6908971ab5be28070c3830f040b1de83ee663c573e0f2f6198640e4 +96811875fa83133e0b3c0e0290f9e0e28bca6178b77fdf5350eb19344d453dbd0d71e55a0ef749025a5a2ca0ad251e81 +81a423423e9438343879f2bfd7ee9f1c74ebebe7ce3cfffc8a11da6f040cc4145c3b527bd3cf63f9137e714dbcb474ef +b8c3535701ddbeec2db08e17a4fa99ba6752d32ece5331a0b8743676f421fcb14798afc7c783815484f14693d2f70db8 +81aee980c876949bf40782835eec8817d535f6f3f7e00bf402ddd61101fdcd60173961ae90a1cf7c5d060339a18c959d +87e67b928d97b62c49dac321ce6cb680233f3a394d4c9a899ac2e8db8ccd8e00418e66cdfd68691aa3cb8559723b580c +8eac204208d99a2b738648df96353bbb1b1065e33ee4f6bba174b540bbbd37d205855e1f1e69a6b7ff043ca377651126 +848e6e7a54ad64d18009300b93ea6f459ce855971dddb419b101f5ac4c159215626fadc20cc3b9ab1701d8f6dfaddd8b +88aa123d9e0cf309d46dddb6acf634b1ade3b090a2826d6e5e78669fa1220d6df9a6697d7778cd9b627db17eea846126 +9200c2a629b9144d88a61151b661b6c4256cc5dadfd1e59a8ce17a013c2d8f7e754aabe61663c3b30f1bc47784c1f8cf +b6e1a2827c3bdda91715b0e1b1f10dd363cef337e7c80cac1f34165fc0dea7c8b69747e310563db5818390146ce3e231 +92c333e694f89f0d306d54105b2a5dcc912dbe7654d9e733edab12e8537350815be472b063e56cfde5286df8922fdecb +a6fac04b6d86091158ebb286586ccfec2a95c9786e14d91a9c743f5f05546073e5e3cc717635a0c602cad8334e922346 +a581b4af77feebc1fb897d49b5b507c6ad513d8f09b273328efbb24ef0d91eb740d01b4d398f2738125dacfe550330cd +81c4860cccf76a34f8a2bc3f464b7bfd3e909e975cce0d28979f457738a56e60a4af8e68a3992cf273b5946e8d7f76e2 +8d1eaa09a3180d8af1cbaee673db5223363cc7229a69565f592fa38ba0f9d582cedf91e15dabd06ebbf2862fc0feba54 +9832f49b0147f4552402e54593cfa51f99540bffada12759b71fcb86734be8e500eea2d8b3d036710bdf04c901432de9 +8bdb0e8ec93b11e5718e8c13cb4f5de545d24829fd76161216340108098dfe5148ed25e3b57a89a516f09fa79043734d +ab96f06c4b9b0b2c0571740b24fca758e6976315053a7ecb20119150a9fa416db2d3a2e0f8168b390bb063f0c1caf785 +ab777f5c52acd62ecf4d1f168b9cc8e1a9b45d4ec6a8ff52c583e867c2239aba98d7d3af977289b367edce03d9c2dfb1 +a09d3ce5e748da84802436951acc3d3ea5d8ec1d6933505ed724d6b4b0d69973ab0930daec9c6606960f6e541e4a3ce2 +8ef94f7be4d85d5ad3d779a5cf4d7b2fc3e65c52fb8e1c3c112509a4af77a0b5be994f251e5e40fabeeb1f7d5615c22b +a7406a5bf5708d9e10922d3c5c45c03ef891b8d0d74ec9f28328a72be4cdc05b4f2703fa99366426659dfca25d007535 +b7f52709669bf92a2e070bfe740f422f0b7127392c5589c7f0af71bb5a8428697c762d3c0d74532899da24ea7d8695c2 +b9dfb0c8df84104dbf9239ccefa4672ef95ddabb8801b74997935d1b81a78a6a5669a3c553767ec19a1281f6e570f4ff +ae4d5c872156061ce9195ac640190d8d71dd406055ee43ffa6f9893eb24b870075b74c94d65bc1d5a07a6573282b5520 +afe6bd3eb72266d333f1807164900dcfa02a7eb5b1744bb3c86b34b3ee91e3f05e38fa52a50dc64eeb4bdb1dd62874b8 +948043cf1bc2ef3c01105f6a78dc06487f57548a3e6ef30e6ebc51c94b71e4bf3ff6d0058c72b6f3ecc37efd7c7fa8c0 +a22fd17c2f7ffe552bb0f23fa135584e8d2d8d75e3f742d94d04aded2a79e22a00dfe7acbb57d44e1cdb962fb22ae170 +8cd0f4e9e4fb4a37c02c1bde0f69359c43ab012eb662d346487be0c3758293f1ca560122b059b091fddce626383c3a8f +90499e45f5b9c81426f3d735a52a564cafbed72711d9279fdd88de8038e953bc48c57b58cba85c3b2e4ce56f1ddb0e11 +8c30e4c034c02958384564cac4f85022ef36ab5697a3d2feaf6bf105049675bbf23d01b4b6814711d3d9271abff04cac +81f7999e7eeea30f3e1075e6780bbf054f2fb6f27628a2afa4d41872a385b4216dd5f549da7ce6cf39049b2251f27fb7 +b36a7191f82fc39c283ffe53fc1f5a9a00b4c64eee7792a8443475da9a4d226cf257f226ea9d66e329af15d8f04984ec +aad4da528fdbb4db504f3041c747455baff5fcd459a2efd78f15bdf3aea0bdb808343e49df88fe7a7c8620009b7964a3 +99ebd8c6dd5dd299517fb6381cfc2a7f443e6e04a351440260dd7c2aee3f1d8ef06eb6c18820b394366ecdfd2a3ce264 +8873725b81871db72e4ec3643084b1cdce3cbf80b40b834b092767728605825c19b6847ad3dcf328438607e8f88b4410 +b008ee2f895daa6abd35bd39b6f7901ae4611a11a3271194e19da1cdcc7f1e1ea008fe5c5440e50d2c273784541ad9c5 +9036feafb4218d1f576ef89d0e99124e45dacaa6d816988e34d80f454d10e96809791d5b78f7fd65f569e90d4d7238c5 +92073c1d11b168e4fa50988b0288638b4868e48bbc668c5a6dddf5499875d53be23a285acb5e4bad60114f6cf6c556e9 +88c87dfcb8ba6cbfe7e1be081ccfadbd589301db2cb7c99f9ee5d7db90aa297ed1538d5a867678a763f2deede5fd219a +b42a562805c661a50f5dea63108002c0f27c0da113da6a9864c9feb5552225417c0356c4209e8e012d9bcc9d182c7611 +8e6317d00a504e3b79cd47feb4c60f9df186467fe9ca0f35b55c0364db30528f5ff071109dabb2fc80bb9cd4949f0c24 +b7b1ea6a88694f8d2f539e52a47466695e39e43a5eb9c6f23bca15305fe52939d8755cc3ac9d6725e60f82f994a3772f +a3cd55161befe795af93a38d33290fb642b8d80da8b786c6e6fb02d393ea308fbe87f486994039cbd7c7b390414594b6 +b416d2d45b44ead3b1424e92c73c2cf510801897b05d1724ff31cbd741920cd858282fb5d6040fe1f0aa97a65bc49424 +950ee01291754feace97c2e933e4681e7ddfbc4fcd079eb6ff830b0e481d929c93d0c7fb479c9939c28ca1945c40da09 +869bd916aee8d86efe362a49010382674825d49195b413b4b4018e88ce43fe091b475d0b863ff0ba2259400f280c2b23 +9782f38cd9c9d3385ec286ebbc7cba5b718d2e65a5890b0a5906b10a89dc8ed80d417d71d7c213bf52f2af1a1f513ea7 +91cd33bc2628d096269b23faf47ee15e14cb7fdc6a8e3a98b55e1031ea0b68d10ba30d97e660f7e967d24436d40fad73 +8becc978129cc96737034c577ae7225372dd855da8811ae4e46328e020c803833b5bdbc4a20a93270e2b8bd1a2feae52 +a36b1d8076783a9522476ce17f799d78008967728ce920531fdaf88303321bcaf97ecaa08e0c01f77bc32e53c5f09525 +b4720e744943f70467983aa34499e76de6d59aa6fadf86f6b787fdce32a2f5b535b55db38fe2da95825c51002cfe142d +91ad21fc502eda3945f6de874d1b6bf9a9a7711f4d61354f9e5634fc73f9c06ada848de15ab0a75811d3250be862827d +84f78e2ebf5fc077d78635f981712daf17e2475e14c2a96d187913006ad69e234746184a51a06ef510c9455b38acb0d7 +960aa7906e9a2f11db64a26b5892ac45f20d2ccb5480f4888d89973beb6fa0dfdc06d68d241ff5ffc7f1b82b1aac242d +a99365dcd1a00c66c9db6924b97c920f5c723380e823b250db85c07631b320ec4e92e586f7319e67a522a0578f7b6d6c +a25d92d7f70cf6a88ff317cfec071e13774516da664f5fac0d4ecaa65b8bf4eb87a64a4d5ef2bd97dfae98d388dbf5cc +a7af47cd0041295798f9779020a44653007444e8b4ef0712982b06d0dcdd434ec4e1f7c5f7a049326602cb605c9105b7 +aefe172eac5568369a05980931cc476bebd9dea573ba276d59b9d8c4420784299df5a910033b7e324a6c2dfc62e3ef05 +b69bc9d22ffa645baa55e3e02522e9892bb2daa7fff7c15846f13517d0799766883ee09ae0869df4139150c5b843ca8a +95a10856140e493354fdd12722c7fdded21b6a2ffbc78aa2697104af8ad0c8e2206f44b0bfee077ef3949d46bbf7c16b +891f2fcd2c47cbea36b7fa715968540c233313f05333f09d29aba23c193f462ed490dd4d00969656e89c53155fdfe710 +a6c33e18115e64e385c843dde34e8a228222795c7ca90bc2cc085705d609025f3351d9be61822c69035a49fb3e48f2d5 +b87fb12f12c0533b005adad0487f03393ff682e13575e3cb57280c3873b2c38ba96a63c49eef7a442753d26b7005230b +b905c02ba451bfd411c135036d92c27af3b0b1c9c2f1309d6948544a264b125f39dd41afeff4666b12146c545adc168a +8b29c513f43a78951cf742231cf5457a6d9d55edf45df5481a0f299a418d94effef561b15d2c1a01d1b8067e7153fda9 +b9941cccd51dc645920d2781c81a317e5a33cb7cf76427b60396735912cb6d2ca9292bb4d36b6392467d390d2c58d9f3 +a8546b627c76b6ef5c93c6a98538d8593dbe21cb7673fd383d5401b0c935eea0bdeeefeb1af6ad41bad8464fb87bbc48 +aa286b27de2812de63108a1aec29d171775b69538dc6198640ac1e96767c2b83a50391f49259195957d457b493b667c9 +a932fb229f641e9abbd8eb2bd874015d97b6658ab6d29769fc23b7db9e41dd4f850382d4c1f08af8f156c5937d524473 +a1412840fcc86e2aeec175526f2fb36e8b3b8d21a78412b7266daf81e51b3f68584ed8bd42a66a43afdd8c297b320520 +89c78be9efb624c97ebca4fe04c7704fa52311d183ffd87737f76b7dadc187c12c982bd8e9ed7cd8beb48cdaafd2fd01 +a3f5ddec412a5bec0ce15e3bcb41c6214c2b05d4e9135a0d33c8e50a78eaba71e0a5a6ea8b45854dec5c2ed300971fc2 +9721f9cec7a68b7758e3887548790de49fa6a442d0396739efa20c2f50352a7f91d300867556d11a703866def2d5f7b5 +a23764e140a87e5991573521af039630dd28128bf56eed2edbed130fd4278e090b60cf5a1dca9de2910603d44b9f6d45 +a1a6494a994215e48ab55c70efa8ffdddce6e92403c38ae7e8dd2f8288cad460c6c7db526bbdf578e96ca04d9fe12797 +b1705ea4cb7e074efe0405fc7b8ee2ec789af0426142f3ec81241cacd4f7edcd88e39435e4e4d8e7b1df64f3880d6613 +85595d061d677116089a6064418b93eb44ff79e68d12bd9625078d3bbc440a60d0b02944eff6054433ee34710ae6fbb4 +9978d5e30bedb7526734f9a1febd973a70bfa20890490e7cc6f2f9328feab1e24f991285dbc3711d892514e2d7d005ad +af30243c66ea43b9f87a061f947f7bce745f09194f6e95f379c7582b9fead920e5d6957eaf05c12ae1282ada4670652f +a1930efb473f88001e47aa0b2b2a7566848cccf295792e4544096ecd14ee5d7927c173a8576b405bfa2eec551cd67eb5 +b0446d1c590ee5a45f7e22d269c044f3848c97aec1d226b44bfd0e94d9729c28a38bccddc3a1006cc5fe4e3c24f001f2 +b8a8380172df3d84b06176df916cf557966d4f2f716d3e9437e415d75b646810f79f2b2b71d857181b7fc944018883a3 +a563afec25b7817bfa26e19dc9908bc00aa8fc3d19be7d6de23648701659009d10e3e4486c28e9c6b13d48231ae29ac5 +a5a8e80579de886fb7d6408f542791876885947b27ad6fa99a8a26e381f052598d7b4e647b0115d4b5c64297e00ce28e +8f87afcc7ad33c51ac719bade3cd92da671a37a82c14446b0a2073f4a0a23085e2c8d31913ed2d0be928f053297de8f6 +a43c455ce377e0bc434386c53c752880687e017b2f5ae7f8a15c044895b242dffde4c92fb8f8bb50b18470b17351b156 +8368f8b12a5bceb1dba25adb3a2e9c7dc9b1a77a1f328e5a693f5aec195cd1e06b0fe9476b554c1c25dac6c4a5b640a3 +919878b27f3671fc78396f11531c032f3e2bd132d04cc234fa4858676b15fb1db3051c0b1db9b4fc49038216f11321ce +b48cd67fb7f1242696c1f877da4bdf188eac676cd0e561fbac1a537f7b8229aff5a043922441d603a26aae56a15faee4 +a3e0fdfd4d29ea996517a16f0370b54787fefe543c2fe73bfc6f9e560c1fd30dad8409859e2d7fa2d44316f24746c712 +8bb156ade8faf149df7bea02c140c7e392a4742ae6d0394d880a849127943e6f26312033336d3b9fdc0092d71b5efe87 +8845e5d5cc555ca3e0523244300f2c8d7e4d02aaebcb5bd749d791208856c209a6f84dd99fd55968c9f0ab5f82916707 +a3e90bb5c97b07789c2f32dff1aec61d0a2220928202f5ad5355ae71f8249237799d6c8a22602e32e572cb12eabe0c17 +b150bcc391884c996149dc3779ce71f15dda63a759ee9cc05871f5a8379dcb62b047098922c0f26c7bd04deb394c33f9 +95cd4ad88d51f0f2efcfd0c2df802fe252bb9704d1afbf9c26a248df22d55da87bdfaf41d7bc6e5df38bd848f0b13f42 +a05a49a31e91dff6a52ac8b9c2cfdd646a43f0d488253f9e3cfbce52f26667166bbb9b608fc358763a65cbf066cd6d05 +a59c3c1227fdd7c2e81f5e11ef5c406da44662987bac33caed72314081e2eed66055d38137e01b2268e58ec85dd986c0 +b7020ec3bd73a99861f0f1d88cf5a19abab1cbe14b7de77c9868398c84bb8e18dbbe9831838a96b6d6ca06e82451c67b +98d1ff2525e9718ee59a21d8900621636fcd873d9a564b8dceb4be80a194a0148daf1232742730b3341514b2e5a5436c +886d97b635975fc638c1b6afc493e5998ca139edba131b75b65cfe5a8e814f11bb678e0eeee5e6e5cd913ad3f2fefdfc +8fb9fd928d38d5d813b671c924edd56601dd7163b686c13f158645c2f869d9250f3859aa5463a39258c90fef0f41190a +aac35e1cd655c94dec3580bb3800bd9c2946c4a9856f7d725af15fbea6a2d8ca51c8ad2772abed60ee0e3fb9cb24046b +b8d71fa0fa05ac9e443c9b4929df9e7f09a919be679692682e614d24227e04894bfc14a5c73a62fb927fedff4a0e4aa7 +a45a19f11fbbb531a704badbb813ed8088ab827c884ee4e4ebf363fa1132ff7cfa9d28be9c85b143e4f7cdbc94e7cf1a +82b54703a4f295f5471b255ab59dce00f0fe90c9fb6e06b9ee48b15c91d43f4e2ef4a96c3118aeb03b08767be58181bb +8283264c8e6d2a36558f0d145c18576b6600ff45ff99cc93eca54b6c6422993cf392668633e5df396b9331e873d457e5 +8c549c03131ead601bc30eb6b9537b5d3beb7472f5bb1bcbbfd1e9f3704477f7840ab3ab7f7dc13bbbbcdff886a462d4 +afbb0c520ac1b5486513587700ad53e314cb74bfbc12e0b5fbdcfdaac36d342e8b59856196a0d84a25cff6e6e1d17e76 +89e4c22ffb51f2829061b3c7c1983c5c750cad158e3a825d46f7cf875677da5d63f653d8a297022b5db5845c9271b32b +afb27a86c4c2373088c96b9adf4433f2ebfc78ac5c526e9f0510670b6e4e5e0057c0a4f75b185e1a30331b9e805c1c15 +a18e16b57445f88730fc5d3567bf5a176861dc14c7a08ed2996fe80eed27a0e7628501bcb78a1727c5e9ac55f29c12c4 +93d61bf88b192d6825cf4e1120af1c17aa0f994d158b405e25437eaeefae049f7b721a206e7cc8a04fdc29d3c42580a1 +a99f2995a2e3ed2fd1228d64166112038de2f516410aa439f4c507044e2017ea388604e2d0f7121256fadf7fbe7023d1 +914fd91cffc23c32f1c6d0e98bf660925090d873367d543034654389916f65f552e445b0300b71b61b721a72e9a5983c +b42a578a7787b71f924e7def425d849c1c777156b1d4170a8ee7709a4a914e816935131afd9a0412c4cb952957b20828 +82fb30590e84b9e45db1ec475a39971cf554dc01bcc7050bc89265740725c02e2be5a972168c5170c86ae83e5b0ad2c0 +b14f8d8e1e93a84976289e0cf0dfa6f3a1809e98da16ee5c4932d0e1ed6bf8a07697fdd4dd86a3df84fb0003353cdcc0 +85d7a2f4bda31aa2cb208b771fe03291a4ebdaf6f1dc944c27775af5caec412584c1f45bc741fca2a6a85acb3f26ad7d +af02e56ce886ff2253bc0a68faad76f25ead84b2144e5364f3fb9b648f03a50ee9dc0b2c33ebacf7c61e9e43201ef9ef +87e025558c8a0b0abd06dfc350016847ea5ced7af2d135a5c9eec9324a4858c4b21510fb0992ec52a73447f24945058e +80fff0bafcd058118f5e7a4d4f1ae0912efeb281d2cbe4d34ba8945cc3dbe5d8baf47fb077343b90b8d895c90b297aca +b6edcf3a40e7b1c3c0148f47a263cd819e585a51ef31c2e35a29ce6f04c53e413f743034c0d998d9c00a08ba00166f31 +abb87ed86098c0c70a76e557262a494ff51a30fb193f1c1a32f8e35eafa34a43fcc07aa93a3b7a077d9e35afa07b1a3d +a280214cd3bb0fb7ecd2d8bcf518cbd9078417f2b91d2533ec2717563f090fb84f2a5fcfdbbeb2a2a1f8a71cc5aa5941 +a63083ca7238ea2b57d15a475963cf1d4f550d8cd76db290014a0461b90351f1f26a67d674c837b0b773b330c7c3d534 +a8fa39064cb585ece5263e2f42f430206476bf261bd50f18d2b694889bd79d04d56410664cecad62690e5c5a20b3f6ff +85ba52ce9d700a5dcf6c5b00559acbe599d671ce5512467ff4b6179d7fad550567ce2a9c126a50964e3096458ea87920 +b913501e1008f076e5eac6d883105174f88b248e1c9801e568fefaffa1558e4909364fc6d9512aa4d125cbd7cc895f05 +8eb33b5266c8f2ed4725a6ad147a322e44c9264cf261c933cbbe230a43d47fca0f29ec39756b20561dabafadd5796494 +850ebc8b661a04318c9db5a0515066e6454fa73865aa4908767a837857ecd717387f614acb614a88e075d4edc53a2f5a +a08d6b92d866270f29f4ce23a3f5d99b36b1e241a01271ede02817c8ec3f552a5c562db400766c07b104a331835c0c64 +8131804c89bb3e74e9718bfc4afa547c1005ff676bd4db9604335032b203390cfa54478d45c6c78d1fe31a436ed4be9f +9106d94f23cc1eacec8316f16d6f0a1cc160967c886f51981fdb9f3f12ee1182407d2bb24e5b873de58cb1a3ee915a6b +a13806bfc3eae7a7000c9d9f1bd25e10218d4e67f59ae798b145b098bca3edad2b1040e3fc1e6310e612fb8818f459ac +8c69fbca502046cb5f6db99900a47b34117aef3f4b241690cdb3b84ca2a2fc7833e149361995dc41fa78892525bce746 +852c473150c91912d58ecb05769222fa18312800c3f56605ad29eec9e2d8667b0b81c379048d3d29100ed2773bb1f3c5 +b1767f6074426a00e01095dbb1795beb4e4050c6411792cbad6537bc444c3165d1058bafd1487451f9c5ddd209e0ae7e +80c600a5fe99354ce59ff0f84c760923dc8ff66a30bf47dc0a086181785ceb01f9b951c4e66df800ea6d705e8bc47055 +b5cf19002fbc88a0764865b82afcb4d64a50196ea361e5c71dff7de084f4dcbbc34ec94a45cc9e0247bd51da565981aa +93e67a254ea8ce25e112d93cc927fadaa814152a2c4ec7d9a56eaa1ed47aec99b7e9916b02e64452cc724a6641729bbb +ace70b32491bda18eee4a4d041c3bc9effae9340fe7e6c2f5ad975ee0874c17f1a7da7c96bd85fccff9312c518fac6e9 +ab4cfa02065017dd7f1aadc66f2c92f78f0f11b8597c03a5d69d82cb2eaf95a4476a836ac102908f137662472c8d914b +a40b8cd8deb8ae503d20364d64cab7c2801b7728a9646ed19c65edea6a842756a2f636283494299584ad57f4bb12cd0b +8594e11d5fc2396bcd9dbf5509ce4816dbb2b7305168021c426171fb444d111da5a152d6835ad8034542277011c26c0e +8024de98c26b4c994a66628dc304bb737f4b6859c86ded552c5abb81fd4c6c2e19d5a30beed398a694b9b2fdea1dd06a +8843f5872f33f54df8d0e06166c1857d733995f67bc54abb8dfa94ad92407cf0179bc91b0a50bbb56cdc2b350d950329 +b8bab44c7dd53ef9edf497dcb228e2a41282c90f00ba052fc52d57e87b5c8ab132d227af1fcdff9a12713d1f980bcaae +982b4d7b29aff22d527fd82d2a52601d95549bfb000429bb20789ed45e5abf1f4b7416c7b7c4b79431eb3574b29be658 +8eb1f571b6a1878e11e8c1c757e0bc084bab5e82e897ca9be9b7f4b47b91679a8190bf0fc8f799d9b487da5442415857 +a6e74b588e5af935c8b243e888582ef7718f8714569dd4992920740227518305eb35fab674d21a5551cca44b3e511ef2 +a30fc2f3a4cb4f50566e82307de73cd7bd8fe2c1184e9293c136a9b9e926a018d57c6e4f308c95b9eb8299e94d90a2a1 +a50c5869ca5d2b40722c056a32f918d47e0b65ca9d7863ca7d2fb4a7b64fe523fe9365cf0573733ceaadebf20b48fff8 +83bbdd32c04d17581418cf360749c7a169b55d54f2427390defd9f751f100897b2d800ce6636c5bbc046c47508d60c8c +a82904bdf614de5d8deaff688c8a5e7ac5b3431687acbcda8fa53960b7c417a39c8b2e462d7af91ce6d79260f412db8e +a4362e31ff4b05d278b033cf5eebea20de01714ae16d4115d04c1da4754269873afc8171a6f56c5104bfd7b0db93c3e7 +b5b8daa63a3735581e74a021b684a1038cea77168fdb7fdf83c670c2cfabcfc3ab2fc7359069b5f9048188351aef26b5 +b48d723894b7782d96ac8433c48faca1bdfa5238019c451a7f47d958097cce3ae599b876cf274269236b9d6ff8b6d7ca +98ffff6a61a3a6205c7820a91ca2e7176fab5dba02bc194c4d14942ac421cb254183c705506ab279e4f8db066f941c6c +ae7db24731da2eaa6efc4f7fcba2ecc26940ddd68038dce43acf2cee15b72dc4ef42a7bfdd32946d1ed78786dd7696b3 +a656db14f1de9a7eb84f6301b4acb2fbf78bfe867f48a270e416c974ab92821eb4df1cb881b2d600cfed0034ac784641 +aa315f8ecba85a5535e9a49e558b15f39520fce5d4bf43131bfbf2e2c9dfccc829074f9083e8d49f405fb221d0bc4c3c +90bffba5d9ff40a62f6c8e9fc402d5b95f6077ed58d030c93e321b8081b77d6b8dac3f63a92a7ddc01585cf2c127d66c +abdd733a36e0e0f05a570d0504e73801bf9b5a25ff2c78786f8b805704997acb2e6069af342538c581144d53149fa6d3 +b4a723bb19e8c18a01bd449b1bb3440ddb2017f10bb153da27deb7a6a60e9bb37619d6d5435fbb1ba617687838e01dd0 +870016b4678bab3375516db0187a2108b2e840bae4d264b9f4f27dbbc7cc9cac1d7dc582d7a04d6fd1ed588238e5e513 +80d33d2e20e8fc170aa3cb4f69fffb72aeafb3b5bb4ea0bc79ab55da14142ca19b2d8b617a6b24d537366e3b49cb67c3 +a7ee76aec273aaae03b3b87015789289551969fb175c11557da3ab77e39ab49d24634726f92affae9f4d24003050d974 +8415ea4ab69d779ebd42d0fe0c6aef531d6a465a5739e429b1fcf433ec45aa8296c527e965a20f0ec9f340c9273ea3cf +8c7662520794e8b4405d0b33b5cac839784bc86a5868766c06cbc1fa306dbe334978177417b31baf90ce7b0052a29c56 +902b2abecc053a3dbdea9897ee21e74821f3a1b98b2d560a514a35799f4680322550fd3a728d4f6d64e1de98033c32b8 +a05e84ed9ecab8d508d670c39f2db61ad6e08d2795ec32a3c9d0d3737ef3801618f4fc2a95f90ec2f068606131e076c5 +8b9208ff4d5af0c2e3f53c9375da666773ac57197dfabb0d25b1c8d0588ba7f3c15ee9661bb001297f322ea2fbf6928b +a3c827741b34a03254d4451b5ab74a96f2b9f7fb069e2f5adaf54fd97cc7a4d516d378db5ca07da87d8566d6eef13726 +8509d8a3f4a0ed378e0a1e28ea02f6bf1d7f6c819c6c2f5297c7df54c895b848f841653e32ba2a2c22c2ff739571acb8 +a0ce988b7d3c40b4e496aa83a09e4b5472a2d98679622f32bea23e6d607bc7de1a5374fb162bce0549a67dad948519be +aa8a3dd12bd60e3d2e05f9c683cdcb8eab17fc59134815f8d197681b1bcf65108cba63ac5c58ee632b1e5ed6bba5d474 +8b955f1d894b3aefd883fb4b65f14cd37fc2b9db77db79273f1700bef9973bf3fd123897ea2b7989f50003733f8f7f21 +ac79c00ddac47f5daf8d9418d798d8af89fc6f1682e7e451f71ea3a405b0d36af35388dd2a332af790bc83ca7b819328 +a0d44dd2a4438b809522b130d0938c3fe7c5c46379365dbd1810a170a9aa5818e1c783470dd5d0b6d4ac7edbb7330910 +a30b69e39ad43dd540a43c521f05b51b5f1b9c4eed54b8162374ae11eac25da4f5756e7b70ce9f3c92c2eeceee7431ed +ac43220b762c299c7951222ea19761ab938bf38e4972deef58ed84f4f9c68c230647cf7506d7cbfc08562fcca55f0485 +b28233b46a8fb424cfa386a845a3b5399d8489ceb83c8f3e05c22c934798d639c93718b7b68ab3ce24c5358339e41cbb +ac30d50ee8ce59a10d4b37a3a35e62cdb2273e5e52232e202ca7d7b8d09d28958ee667fae41a7bb6cdc6fe8f6e6c9c85 +b199842d9141ad169f35cc7ff782b274cbaa645fdb727761e0a89edbf0d781a15f8218b4bf4eead326f2903dd88a9cc1 +85e018c7ddcad34bb8285a737c578bf741ccd547e68c734bdb3808380e12c5d4ef60fc896b497a87d443ff9abd063b38 +8c856e6ba4a815bdb891e1276f93545b7072f6cb1a9aa6aa5cf240976f29f4dee01878638500a6bf1daf677b96b54343 +b8a47555fa8710534150e1a3f13eab33666017be6b41005397afa647ea49708565f2b86b77ad4964d140d9ced6b4d585 +8cd1f1db1b2f4c85a3f46211599caf512d5439e2d8e184663d7d50166fd3008f0e9253272f898d81007988435f715881 +b1f34b14612c973a3eceb716dc102b82ab18afef9de7630172c2780776679a7706a4874e1df3eaadf541fb009731807f +b25464af9cff883b55be2ff8daf610052c02df9a5e147a2cf4df6ce63edcdee6dc535c533590084cc177da85c5dc0baa +91c3c4b658b42d8d3448ae1415d4541d02379a40dc51e36a59bd6e7b9ba3ea51533f480c7c6e8405250ee9b96a466c29 +86dc027b95deb74c36a58a1333a03e63cb5ae22d3b29d114cfd2271badb05268c9d0c819a977f5e0c6014b00c1512e3a +ae0e6ff58eb5fa35da5107ebeacf222ab8f52a22bb1e13504247c1dfa65320f40d97b0e6b201cb6613476687cb2f0681 +8f13415d960b9d7a1d93ef28afc2223e926639b63bdefce0f85e945dfc81670a55df288893a0d8b3abe13c5708f82f91 +956f67ca49ad27c1e3a68c1faad5e7baf0160c459094bf6b7baf36b112de935fdfd79fa4a9ea87ea8de0ac07272969f4 +835e45e4a67df9fb51b645d37840b3a15c171d571a10b03a406dd69d3c2f22df3aa9c5cbe1e73f8d767ce01c4914ea9a +919b938e56d4b32e2667469d0bdccb95d9dda3341aa907683ee70a14bbbe623035014511c261f4f59b318b610ac90aa3 +96b48182121ccd9d689bf1dfdc228175564cd68dc904a99c808a7f0053a6f636c9d953e12198bdf2ea49ea92772f2e18 +ac5e5a941d567fa38fdbcfa8cf7f85bb304e3401c52d88752bcd516d1fa9bac4572534ea2205e38423c1df065990790f +ac0bd594fb85a8d4fc26d6df0fa81f11919401f1ecf9168b891ec7f061a2d9368af99f7fd8d9b43b2ce361e7b8482159 +83d92c69ca540d298fe80d8162a1c7af3fa9b49dfb69e85c1d136a3ec39fe419c9fa78e0bb6d96878771fbd37fe92e40 +b35443ae8aa66c763c2db9273f908552fe458e96696b90e41dd509c17a5c04ee178e3490d9c6ba2dc0b8f793c433c134 +923b2d25aa45b2e580ffd94cbb37dc8110f340f0f011217ee1bd81afb0714c0b1d5fb4db86006cdd2457563276f59c59 +96c9125d38fca1a61ac21257b696f8ac3dae78def50285e44d90ea293d591d1c58f703540a7e4e99e070afe4646bbe15 +b57946b2332077fbcdcb406b811779aefd54473b5559a163cd65cb8310679b7e2028aa55c12a1401fdcfcac0e6fae29a +845daedc5cf972883835d7e13c937b63753c2200324a3b8082a6c4abb4be06c5f7c629d4abe4bfaf1d80a1f073eb6ce6 +91a55dfd0efefcd03dc6dacc64ec93b8d296cb83c0ee72400a36f27246e7f2a60e73b7b70ba65819e9cfb73edb7bd297 +8874606b93266455fe8fdd25df9f8d2994e927460af06f2e97dd4d2d90db1e6b06d441b72c2e76504d753badca87fb37 +8ee99e6d231274ff9252c0f4e84549da173041299ad1230929c3e3d32399731c4f20a502b4a307642cac9306ccd49d3c +8836497714a525118e20849d6933bb8535fb6f72b96337d49e3133d936999c90a398a740f42e772353b5f1c63581df6d +a6916945e10628f7497a6cdc5e2de113d25f7ade3e41e74d3de48ccd4fce9f2fa9ab69645275002e6f49399b798c40af +9597706983107eb23883e0812e1a2c58af7f3499d50c6e29b455946cb9812fde1aa323d9ed30d1c0ffd455abe32303cd +a24ee89f7f515cc33bdbdb822e7d5c1877d337f3b2162303cfc2dae028011c3a267c5cb4194afa63a4856a6e1c213448 +8cd25315e4318801c2776824ae6e7d543cb85ed3bc2498ba5752df2e8142b37653cf9e60104d674be3aeb0a66912e97a +b5085ecbe793180b40dbeb879f4c976eaaccaca3a5246807dced5890e0ed24d35f3f86955e2460e14fb44ff5081c07ba +960188cc0b4f908633a6840963a6fa2205fc42c511c6c309685234911c5304ef4c304e3ae9c9c69daa2fb6a73560c256 +a32d0a70bf15d569b4cda5aebe3e41e03c28bf99cdd34ffa6c5d58a097f322772acca904b3a47addb6c7492a7126ebac +977f72d06ad72d4aa4765e0f1f9f4a3231d9f030501f320fe7714cc5d329d08112789fa918c60dd7fdb5837d56bb7fc6 +99fa038bb0470d45852bb871620d8d88520adb701712fcb1f278fed2882722b9e729e6cdce44c82caafad95e37d0e6f7 +b855e8f4fc7634ada07e83b6c719a1e37acb06394bc8c7dcab7747a8c54e5df3943915f021364bd019fdea103864e55f +88bc2cd7458532e98c596ef59ea2cf640d7cc31b4c33cef9ed065c078d1d4eb49677a67de8e6229cc17ea48bace8ee5a +aaa78a3feaa836d944d987d813f9b9741afb076e6aca1ffa42682ab06d46d66e0c07b8f40b9dbd63e75e81efa1ef7b08 +b7b080420cc4d808723b98b2a5b7b59c81e624ab568ecdfdeb8bf3aa151a581b6f56e983ef1b6f909661e25db40b0c69 +abee85c462ac9a2c58e54f06c91b3e5cd8c5f9ab5b5deb602b53763c54826ed6deb0d6db315a8d7ad88733407e8d35e2 +994d075c1527407547590df53e9d72dd31f037c763848d1662eebd4cefec93a24328c986802efa80e038cb760a5300f5 +ab8777640116dfb6678e8c7d5b36d01265dfb16321abbfc277da71556a34bb3be04bc4ae90124ed9c55386d2bfb3bda0 +967e3a828bc59409144463bcf883a3a276b5f24bf3cbfdd7a42343348cba91e00b46ac285835a9b91eef171202974204 +875a9f0c4ffe5bb1d8da5e3c8e41d0397aa6248422a628bd60bfae536a651417d4e8a7d2fb98e13f2dad3680f7bd86d3 +acaa330c3e8f95d46b1880126572b238dbb6d04484d2cd4f257ab9642d8c9fc7b212188b9c7ac9e0fd135c520d46b1bf +aceb762edbb0f0c43dfcdb01ea7a1ac5918ca3882b1e7ebc4373521742f1ed5250d8966b498c00b2b0f4d13212e6dd0b +81d072b4ad258b3646f52f399bced97c613b22e7ad76373453d80b1650c0ca87edb291a041f8253b649b6e5429bb4cff +980a47d27416ac39c7c3a0ebe50c492f8c776ea1de44d5159ac7d889b6d554357f0a77f0e5d9d0ff41aae4369eba1fc2 +8b4dfd5ef5573db1476d5e43aacfb5941e45d6297794508f29c454fe50ea622e6f068b28b3debe8635cf6036007de2e3 +a60831559d6305839515b68f8c3bc7abbd8212cc4083502e19dd682d56ca37c9780fc3ce4ec2eae81ab23b221452dc57 +951f6b2c1848ced9e8a2339c65918e00d3d22d3e59a0a660b1eca667d18f8430d737884e9805865ef3ed0fe1638a22d9 +b02e38fe790b492aa5e89257c4986c9033a8b67010fa2add9787de857d53759170fdd67715ca658220b4e14b0ca48124 +a51007e4346060746e6b0e4797fc08ef17f04a34fe24f307f6b6817edbb8ce2b176f40771d4ae8a60d6152cbebe62653 +a510005b05c0b305075b27b243c9d64bcdce85146b6ed0e75a3178b5ff9608213f08c8c9246f2ca6035a0c3e31619860 +aaff4ef27a7a23be3419d22197e13676d6e3810ceb06a9e920d38125745dc68a930f1741c9c2d9d5c875968e30f34ab5 +864522a9af9857de9814e61383bebad1ba9a881696925a0ea6bfc6eff520d42c506bbe5685a9946ed710e889765be4a0 +b63258c080d13f3b7d5b9f3ca9929f8982a6960bdb1b0f8676f4dca823971601672f15e653917bf5d3746bb220504913 +b51ce0cb10869121ae310c7159ee1f3e3a9f8ad498827f72c3d56864808c1f21fa2881788f19ece884d3f705cd7bd0c5 +95d9cecfc018c6ed510e441cf84c712d9909c778c16734706c93222257f64dcd2a9f1bd0b400ca271e22c9c487014274 +8beff4d7d0140b86380ff4842a9bda94c2d2be638e20ac68a4912cb47dbe01a261857536375208040c0554929ced1ddc +891ff49258749e2b57c1e9b8e04b12c77d79c3308b1fb615a081f2aacdfb4b39e32d53e069ed136fdbd43c53b87418fa +9625cad224e163d387738825982d1e40eeff35fe816d10d7541d15fdc4d3eee48009090f3faef4024b249205b0b28f72 +8f3947433d9bd01aa335895484b540a9025a19481a1c40b4f72dd676bfcf332713714fd4010bde936eaf9470fd239ed0 +a00ec2d67789a7054b53f0e858a8a232706ccc29a9f3e389df7455f1a51a2e75801fd78469a13dbc25d28399ae4c6182 +a3f65884506d4a62b8775a0ea0e3d78f5f46bc07910a93cd604022154eabdf1d73591e304d61edc869e91462951975e1 +a14eef4fd5dfac311713f0faa9a60415e3d30b95a4590cbf95f2033dffb4d16c02e7ceff3dcd42148a4e3bc49cce2dd4 +8afa11c0eef3c540e1e3460bc759bb2b6ea90743623f88e62950c94e370fe4fd01c22b6729beba4dcd4d581198d9358f +afb05548a69f0845ffcc5f5dc63e3cdb93cd270f5655173b9a950394b0583663f2b7164ba6df8d60c2e775c1d9f120af +97f179e01a947a906e1cbeafa083960bc9f1bade45742a3afee488dfb6011c1c6e2db09a355d77f5228a42ccaa7bdf8e +8447fca4d35f74b3efcbd96774f41874ca376bf85b79b6e66c92fa3f14bdd6e743a051f12a7fbfd87f319d1c6a5ce217 +a57ca39c23617cd2cf32ff93b02161bd7baf52c4effb4679d9d5166406e103bc8f3c6b5209e17c37dbb02deb8bc72ddd +9667c7300ff80f0140be002b0e36caab07aaee7cce72679197c64d355e20d96196acaf54e06e1382167d081fe6f739c1 +828126bb0559ce748809b622677267ca896fa2ee76360fd2c02990e6477e06a667241379ca7e65d61a5b64b96d7867de +8b8835dea6ba8cf61c91f01a4b3d2f8150b687a4ee09b45f2e5fc8f80f208ae5d142d8e3a18153f0722b90214e60c5a7 +a98e8ff02049b4da386e3ee93db23bbb13dfeb72f1cfde72587c7e6d962780b7671c63e8ac3fbaeb1a6605e8d79e2f29 +87a4892a0026d7e39ef3af632172b88337cb03669dea564bcdb70653b52d744730ebb5d642e20cb627acc9dbb547a26b +877352a22fc8052878a57effc159dac4d75fe08c84d3d5324c0bab6d564cdf868f33ceee515eee747e5856b62cfa0cc7 +8b801ba8e2ff019ee62f64b8cb8a5f601fc35423eb0f9494b401050103e1307dc584e4e4b21249cd2c686e32475e96c3 +a9e7338d6d4d9bfec91b2af28a8ed13b09415f57a3a00e5e777c93d768fdb3f8e4456ae48a2c6626b264226e911a0e28 +99c05fedf40ac4726ed585d7c1544c6e79619a0d3fb6bda75a08c7f3c0008e8d5e19ed4da48de3216135f34a15eba17c +a61cce8a1a8b13a4a650fdbec0eeea8297c352a8238fb7cac95a0df18ed16ee02a3daa2de108fa122aca733bd8ad7855 +b97f37da9005b440b4cb05870dd881bf8491fe735844f2d5c8281818583b38e02286e653d9f2e7fa5e74c3c3eb616540 +a72164a8554da8e103f692ac5ebb4aece55d5194302b9f74b6f2a05335b6e39beede0bf7bf8c5bfd4d324a784c5fb08c +b87e8221c5341cd9cc8bb99c10fe730bc105550f25ed4b96c0d45e6142193a1b2e72f1b3857373a659b8c09be17b3d91 +a41fb1f327ef91dcb7ac0787918376584890dd9a9675c297c45796e32d6e5985b12f9b80be47fc3a8596c245f419d395 +90dafa3592bdbb3465c92e2a54c2531822ba0459d45d3e7a7092fa6b823f55af28357cb51896d4ec2d66029c82f08e26 +a0a9adc872ebc396557f484f1dd21954d4f4a21c4aa5eec543f5fa386fe590839735c01f236574f7ff95407cd12de103 +b8c5c940d58be7538acf8672852b5da3af34f82405ef2ce8e4c923f1362f97fc50921568d0fd2fe846edfb0823e62979 +85aaf06a8b2d0dac89dafd00c28533f35dbd074978c2aaa5bef75db44a7b12aeb222e724f395513b9a535809a275e30b +81f3cbe82fbc7028c26a6c1808c604c63ba023a30c9f78a4c581340008dbda5ec07497ee849a2183fcd9124f7936af32 +a11ac738de75fd60f15a34209d3825d5e23385796a4c7fc5931822f3f380af977dd0f7b59fbd58eed7777a071e21b680 +85a279c493de03db6fa6c3e3c1b1b29adc9a8c4effc12400ae1128da8421954fa8b75ad19e5388fe4543b76fb0812813 +83a217b395d59ab20db6c4adb1e9713fc9267f5f31a6c936042fe051ce8b541f579442f3dcf0fa16b9e6de9fd3518191 +83a0b86e7d4ed8f9ccdc6dfc8ff1484509a6378fa6f09ed908e6ab9d1073f03011dc497e14304e4e3d181b57de06a5ab +a63ad69c9d25704ce1cc8e74f67818e5ed985f8f851afa8412248b2df5f833f83b95b27180e9e7273833ed0d07113d3b +99b1bc2021e63b561fe44ddd0af81fcc8627a91bfeecbbc989b642bc859abc0c8d636399701aad7bbaf6a385d5f27d61 +b53434adb66f4a807a6ad917c6e856321753e559b1add70824e5c1e88191bf6993fccb9b8b911fc0f473fb11743acacd +97ed3b9e6fb99bf5f945d4a41f198161294866aa23f2327818cdd55cb5dc4c1a8eff29dd8b8d04902d6cd43a71835c82 +b1e808260e368a18d9d10bdea5d60223ba1713b948c782285a27a99ae50cc5fc2c53d407de07155ecc16fb8a36d744a0 +a3eb4665f18f71833fec43802730e56b3ee5a357ea30a888ad482725b169d6f1f6ade6e208ee081b2e2633079b82ba7d +ab8beb2c8353fc9f571c18fdd02bdb977fc883313469e1277b0372fbbb33b80dcff354ca41de436d98d2ed710faa467e +aa9071cfa971e4a335a91ad634c98f2be51544cb21f040f2471d01bb97e1df2277ae1646e1ea8f55b7ba9f5c8c599b39 +80b7dbfdcaf40f0678012acc634eba44ea51181475180d9deb2050dc4f2de395289edd0223018c81057ec79b04b04c49 +89623d7f6cb17aa877af14de842c2d4ab7fd576d61ddd7518b5878620a01ded40b6010de0da3cdf31d837eecf30e9847 +a773bb024ae74dd24761f266d4fb27d6fd366a8634febe8235376b1ae9065c2fe12c769f1d0407867dfbe9f5272c352f +8455a561c3aaa6ba64c881a5e13921c592b3a02e968f4fb24a2243c36202795d0366d9cc1a24e916f84d6e158b7aeac7 +81d8bfc4b283cf702a40b87a2b96b275bdbf0def17e67d04842598610b67ea08c804d400c3e69fa09ea001eaf345b276 +b8f8f82cb11fea1c99467013d7e167ff03deb0c65a677fab76ded58826d1ba29aa7cf9fcd7763615735ea3ad38e28719 +89a6a04baf9cccc1db55179e1650b1a195dd91fb0aebc197a25143f0f393524d2589975e3fbfc2547126f0bced7fd6f2 +b81b2162df045390f04df07cbd0962e6b6ca94275a63edded58001a2f28b2ae2af2c7a6cba4ecd753869684e77e7e799 +a3757f722776e50de45c62d9c4a2ee0f5655a512344c4cbec542d8045332806568dd626a719ef21a4eb06792ca70f204 +8c5590df96ec22179a4e8786de41beb44f987a1dcc508eb341eecbc0b39236fdfad47f108f852e87179ccf4e10091e59 +87502f026ed4e10167419130b88c3737635c5b9074c364e1dd247cef5ef0fc064b4ae99b187e33301e438bbd2fe7d032 +af925a2165e980ced620ff12289129fe17670a90ae0f4db9d4b39bd887ccb1f5d2514ac9ecf910f6390a8fc66bd5be17 +857fca899828cf5c65d26e3e8a6e658542782fc72762b3b9c73514919f83259e0f849a9d4838b40dc905fe43024d0d23 +87ffebdbfb69a9e1007ebac4ffcb4090ff13705967b73937063719aa97908986effcb7262fdadc1ae0f95c3690e3245d +a9ff6c347ac6f4c6ab993b748802e96982eaf489dc69032269568412fc9a79e7c2850dfc991b28211b3522ee4454344b +a65b3159df4ec48bebb67cb3663cd744027ad98d970d620e05bf6c48f230fa45bf17527fe726fdf705419bb7a1bb913e +84b97b1e6408b6791831997b03cd91f027e7660fd492a93d95daafe61f02427371c0e237c75706412f442991dfdff989 +ab761c26527439b209af0ae6afccd9340bbed5fbe098734c3145b76c5d2cd7115d9227b2eb523882b7317fbb09180498 +a0479a8da06d7a69c0b0fee60df4e691c19c551f5e7da286dab430bfbcabf31726508e20d26ea48c53365a7f00a3ad34 +a732dfc9baa0f4f40b5756d2e8d8937742999623477458e0bc81431a7b633eefc6f53b3b7939fe0a020018549c954054 +901502436a1169ba51dc479a5abe7c8d84e0943b16bc3c6a627b49b92cd46263c0005bc324c67509edd693f28e612af1 +b627aee83474e7f84d1bab9b7f6b605e33b26297ac6bbf52d110d38ba10749032bd551641e73a383a303882367af429b +95108866745760baef4a46ef56f82da6de7e81c58b10126ebd2ba2cd13d339f91303bf2fb4dd104a6956aa3b13739503 +899ed2ade37236cec90056f3569bc50f984f2247792defafcceb49ad0ca5f6f8a2f06573705300e07f0de0c759289ff5 +a9f5eee196d608efe4bcef9bf71c646d27feb615e21252cf839a44a49fd89da8d26a758419e0085a05b1d59600e2dc42 +b36c6f68fed6e6c85f1f4a162485f24817f2843ec5cbee45a1ebfa367d44892e464949c6669f7972dc7167af08d55d25 +aaaede243a9a1b6162afbc8f571a52671a5a4519b4062e3f26777664e245ba873ed13b0492c5dbf0258c788c397a0e9e +972b4fb39c31cbe127bf9a32a5cc10d621ebdd9411df5e5da3d457f03b2ab2cd1f6372d8284a4a9400f0b06ecdbfd38e +8f6ca1e110e959a4b1d9a5ce5f212893cec21db40d64d5ac4d524f352d72198f923416a850bf845bc5a22a79c0ea2619 +a0f3c93b22134f66f04b2553a53b738644d1665ceb196b8494b315a4c28236fb492017e4a0de4224827c78e42f9908b7 +807fb5ee74f6c8735b0b5ca07e28506214fe4047dbeb00045d7c24f7849e98706aea79771241224939cb749cf1366c7d +915eb1ff034224c0b645442cdb7d669303fdc00ca464f91aaf0b6fde0b220a3a74ff0cb043c26c9f3a5667b3fdaa9420 +8fda6cef56ed33fefffa9e6ac8e6f76b1af379f89761945c63dd448801f7bb8ca970504a7105fac2f74f652ccff32327 +87380cffdcffb1d0820fa36b63cc081e72187f86d487315177d4d04da4533eb19a0e2ff6115ceab528887819c44a5164 +8cd89e03411a18e7f16f968b89fb500c36d47d229f6487b99e62403a980058db5925ce249206743333538adfad168330 +974451b1df33522ce7056de9f03e10c70bf302c44b0741a59df3d6877d53d61a7394dcee1dd46e013d7cb9d73419c092 +98c35ddf645940260c490f384a49496a7352bb8e3f686feed815b1d38f59ded17b1ad6e84a209e773ed08f7b8ff1e4c2 +963f386cf944bb9b2ddebb97171b64253ea0a2894ac40049bdd86cda392292315f3a3d490ca5d9628c890cfb669f0acb +8d507712152babd6d142ee682638da8495a6f3838136088df9424ef50d5ec28d815a198c9a4963610b22e49b4cdf95e9 +83d4bc6b0be87c8a4f1e9c53f257719de0c73d85b490a41f7420e777311640937320557ff2f1d9bafd1daaa54f932356 +82f5381c965b7a0718441131c4d13999f4cdce637698989a17ed97c8ea2e5bdb5d07719c5f7be8688edb081b23ede0f4 +a6ebecab0b72a49dfd01d69fa37a7f74d34fb1d4fef0aa10e3d6fceb9eccd671225c230af89f6eb514250e41a5f91f52 +846d185bdad6e11e604df7f753b7a08a28b643674221f0e750ebdb6b86ec584a29c869e131bca868972a507e61403f6a +85a98332292acb744bd1c0fd6fdcf1f889a78a2c9624d79413ffa194cc8dfa7821a4b60cde8081d4b5f71f51168dd67f +8f7d97c3b4597880d73200d074eb813d95432306e82dafc70b580b8e08cb8098b70f2d07b4b3ac6a4d77e92d57035031 +8185439c8751e595825d7053518cbe121f191846a38d4dbcb558c3f9d7a3104f3153401adaaaf27843bbe2edb504bfe3 +b3c00d8ece1518fca6b1215a139b0a0e26d9cba1b3a424f7ee59f30ce800a5db967279ed60958dd1f3ee69cf4dd1b204 +a2e6cb6978e883f9719c3c0d44cfe8de0cc6f644b98f98858433bea8bbe7b612c8aca5952fccce4f195f9d54f9722dc2 +99663087e3d5000abbec0fbda4e7342ec38846cc6a1505191fb3f1a337cb369455b7f8531a6eb8b0f7b2c4baf83cbe2b +ab0836c6377a4dbc7ca6a4d6cf021d4cd60013877314dd05f351706b128d4af6337711ed3443cb6ca976f40d74070a9a +87abfd5126152fd3bac3c56230579b489436755ea89e0566aa349490b36a5d7b85028e9fb0710907042bcde6a6f5d7e3 +974ba1033f75f60e0cf7c718a57ae1da3721cf9d0fb925714c46f027632bdd84cd9e6de4cf4d00bc55465b1c5ebb7384 +a607b49d73689ac64f25cec71221d30d53e781e1100d19a2114a21da6507a60166166369d860bd314acb226596525670 +a7c2b0b915d7beba94954f2aa7dd08ec075813661e2a3ecca5d28a0733e59583247fed9528eb28aba55b972cdbaf06eb +b8b3123e44128cc8efbe3270f2f94e50ca214a4294c71c3b851f8cbb70cb67fe9536cf07d04bf7fe380e5e3a29dd3c15 +a59a07e343b62ad6445a0859a32b58c21a593f9ddbfe52049650f59628c93715aa1f4e1f45b109321756d0eeec8a5429 +94f51f8a4ed18a6030d0aaa8899056744bd0e9dc9ac68f62b00355cddab11da5da16798db75f0bfbce0e5bdfe750c0b6 +97460a97ca1e1fa5ce243b81425edc0ec19b7448e93f0b55bc9785eedeeafe194a3c8b33a61a5c72990edf375f122777 +8fa859a089bc17d698a7ee381f37ce9beadf4e5b44fce5f6f29762bc04f96faff5d58c48c73631290325f05e9a1ecf49 +abdf38f3b20fc95eff31de5aa9ef1031abfa48f1305ee57e4d507594570401503476d3bcc493838fc24d6967a3082c7f +b8914bfb82815abb86da35c64d39ab838581bc0bf08967192697d9663877825f2b9d6fbdcf9b410463482b3731361aef +a8187f9d22b193a5f578999954d6ec9aa9b32338ccadb8a3e1ce5bad5ea361d69016e1cdfac44e9d6c54e49dd88561b9 +aac262cb7cba7fd62c14daa7b39677cabc1ef0947dd06dd89cac8570006a200f90d5f0353e84f5ff03179e3bebe14231 +a630ef5ece9733b8c46c0a2df14a0f37647a85e69c63148e79ffdcc145707053f9f9d305c3f1cf3c7915cb46d33abd07 +b102c237cb2e254588b6d53350dfda6901bd99493a3fbddb4121d45e0b475cf2663a40d7b9a75325eda83e4ba1e68cb3 +86a930dd1ddcc16d1dfa00aa292cb6c2607d42c367e470aa920964b7c17ab6232a7108d1c2c11fc40fb7496547d0bbf8 +a832fdc4500683e72a96cce61e62ac9ee812c37fe03527ad4cf893915ca1962cee80e72d4f82b20c8fc0b764376635a1 +88ad985f448dabb04f8808efd90f273f11f5e6d0468b5489a1a6a3d77de342992a73eb842d419034968d733f101ff683 +98a8538145f0d86f7fbf9a81c9140f6095c5bdd8960b1c6f3a1716428cd9cca1bf8322e6d0af24e6169abcf7df2b0ff6 +9048c6eba5e062519011e177e955a200b2c00b3a0b8615bdecdebc217559d41058d3315f6d05617be531ef0f6aef0e51 +833bf225ab6fc68cdcacf1ec1b50f9d05f5410e6cdcd8d56a3081dc2be8a8d07b81534d1ec93a25c2e270313dfb99e3b +a84bcd24c3da5e537e64a811b93c91bfc84d7729b9ead7f79078989a6eb76717d620c1fad17466a0519208651e92f5ff +b7cdd0a3fbd79aed93e1b5a44ca44a94e7af5ed911e4492f332e3a5ed146c7286bde01b52276a2fcc02780d2109874dd +8a19a09854e627cb95750d83c20c67442b66b35896a476358f993ba9ac114d32c59c1b3d0b8787ee3224cf3888b56c64 +a9abd5afb8659ee52ada8fa5d57e7dd355f0a7350276f6160bec5fbf70d5f99234dd179eb221c913e22a49ec6d267846 +8c13c4274c0d30d184e73eaf812200094bbbd57293780bdadbceb262e34dee5b453991e7f37c7333a654fc71c69d6445 +a4320d73296ff8176ce0127ca1921c450e2a9c06eff936681ebaffb5a0b05b17fded24e548454de89aca2dcf6d7a9de4 +b2b8b3e15c1f645f07783e5628aba614e60157889db41d8161d977606788842b67f83f361eae91815dc0abd84e09abd5 +ad26c3aa35ddfddc15719b8bb6c264aaec7065e88ac29ba820eb61f220fef451609a7bb037f3722d022e6c86e4f1dc88 +b8615bf43e13ae5d7b8dd903ce37190800cd490f441c09b22aa29d7a29ed2c0417b7a08ead417868f1de2589deaadd80 +8d3425e1482cd1e76750a76239d33c06b3554c3c3c87c15cb7ab58b1cee86a4c5c4178b44e23f36928365a1b484bde02 +806893a62e38c941a7dd6f249c83af16596f69877cc737d8f73f6b8cd93cbc01177a7a276b2b8c6b0e5f2ad864db5994 +86618f17fa4b0d65496b661bbb5ba3bc3a87129d30a4b7d4f515b904f4206ca5253a41f49fd52095861e5e065ec54f21 +9551915da1304051e55717f4c31db761dcdcf3a1366c89a4af800a9e99aca93a357bf928307f098e62b44a02cb689a46 +8f79c4ec0ec1146cb2a523b52fe33def90d7b5652a0cb9c2d1c8808a32293e00aec6969f5b1538e3a94cd1efa3937f86 +a0c03e329a707300081780f1e310671315b4c6a4cedcb29697aedfabb07a9d5df83f27b20e9c44cf6b16e39d9ded5b98 +86a7cfa7c8e7ce2c01dd0baec2139e97e8e090ad4e7b5f51518f83d564765003c65968f85481bbb97cb18f005ccc7d9f +a33811770c6dfda3f7f74e6ad0107a187fe622d61b444bbd84fd7ef6e03302e693b093df76f6ab39bb4e02afd84a575a +85480f5c10d4162a8e6702b5e04f801874d572a62a130be94b0c02b58c3c59bdcd48cd05f0a1c2839f88f06b6e3cd337 +8e181011564b17f7d787fe0e7f3c87f6b62da9083c54c74fd6c357a1f464c123c1d3d8ade3cf72475000b464b14e2be3 +8ee178937294b8c991337e0621ab37e9ffa4ca2bdb3284065c5e9c08aad6785d50cf156270ff9daf9a9127289710f55b +8bd1e8e2d37379d4b172f1aec96f2e41a6e1393158d7a3dbd9a95c8dd4f8e0b05336a42efc11a732e5f22b47fc5c271d +8f3da353cd487c13136a85677de8cedf306faae0edec733cf4f0046f82fa4639db4745b0095ff33a9766aba50de0cbcf +8d187c1e97638df0e4792b78e8c23967dac43d98ea268ca4aabea4e0fa06cb93183fd92d4c9df74118d7cc27bf54415e +a4c992f08c2f8bac0b74b3702fb0c75c9838d2ce90b28812019553d47613c14d8ce514d15443159d700b218c5a312c49 +a6fd1874034a34c3ea962a316c018d9493d2b3719bb0ec4edbc7c56b240802b2228ab49bee6f04c8a3e9f6f24a48c1c2 +b2efed8e799f8a15999020900dc2c58ece5a3641c90811b86a5198e593d7318b9d53b167818ccdfbe7df2414c9c34011 +995ff7de6181ddf95e3ead746089c6148da3508e4e7a2323c81785718b754d356789b902e7e78e2edc6b0cbd4ff22c78 +944073d24750a9068cbd020b834afc72d2dde87efac04482b3287b40678ad07588519a4176b10f2172a2c463d063a5cd +99db4b1bb76475a6fd75289986ef40367960279524378cc917525fb6ba02a145a218c1e9caeb99332332ab486a125ac0 +89fce4ecd420f8e477af4353b16faabb39e063f3f3c98fde2858b1f2d1ef6eed46f0975a7c08f233b97899bf60ccd60a +8c09a4f07a02b80654798bc63aada39fd638d3e3c4236ccd8a5ca280350c31e4a89e5f4c9aafb34116e71da18c1226b8 +85325cfa7ded346cc51a2894257eab56e7488dbff504f10f99f4cd2b630d913003761a50f175ed167e8073f1b6b63fb0 +b678b4fbec09a8cc794dcbca185f133578f29e354e99c05f6d07ac323be20aecb11f781d12898168e86f2e0f09aca15e +a249cfcbca4d9ba0a13b5f6aac72bf9b899adf582f9746bb2ad043742b28915607467eb794fca3704278f9136f7642be +9438e036c836a990c5e17af3d78367a75b23c37f807228362b4d13e3ddcb9e431348a7b552d09d11a2e9680704a4514f +925ab70450af28c21a488bfb5d38ac994f784cf249d7fd9ad251bb7fd897a23e23d2528308c03415074d43330dc37ef4 +a290563904d5a8c0058fc8330120365bdd2ba1fdbaef7a14bc65d4961bb4217acfaed11ab82669e359531f8bf589b8db +a7e07a7801b871fc9b981a71e195a3b4ba6b6313bc132b04796a125157e78fe5c11a3a46cf731a255ac2d78a4ae78cd0 +b26cd2501ee72718b0eebab6fb24d955a71f363f36e0f6dff0ab1d2d7836dab88474c0cef43a2cc32701fca7e82f7df3 +a1dc3b6c968f3de00f11275092290afab65b2200afbcfa8ddc70e751fa19dbbc300445d6d479a81bda3880729007e496 +a9bc213e28b630889476a095947d323b9ac6461dea726f2dc9084473ae8e196d66fb792a21905ad4ec52a6d757863e7d +b25d178df8c2df8051e7c888e9fa677fde5922e602a95e966db9e4a3d6b23ce043d7dc48a5b375c6b7c78e966893e8c3 +a1c8d88d72303692eaa7adf68ea41de4febec40cc14ae551bb4012afd786d7b6444a3196b5d9d5040655a3366d96b7cd +b22bd44f9235a47118a9bbe2ba5a2ba9ec62476061be2e8e57806c1a17a02f9a51403e849e2e589520b759abd0117683 +b8add766050c0d69fe81d8d9ea73e1ed05f0135d093ff01debd7247e42dbb86ad950aceb3b50b9af6cdc14ab443b238f +af2cf95f30ef478f018cf81d70d47d742120b09193d8bb77f0d41a5d2e1a80bfb467793d9e2471b4e0ad0cb2c3b42271 +8af5ef2107ad284e246bb56e20fef2a255954f72de791cbdfd3be09f825298d8466064f3c98a50496c7277af32b5c0bc +85dc19558572844c2849e729395a0c125096476388bd1b14fa7f54a7c38008fc93e578da3aac6a52ff1504d6ca82db05 +ae8c9b43c49572e2e166d704caf5b4b621a3b47827bb2a3bcd71cdc599bba90396fd9a405261b13e831bb5d44c0827d7 +a7ba7efede25f02e88f6f4cbf70643e76784a03d97e0fbd5d9437c2485283ad7ca3abb638a5f826cd9f6193e5dec0b6c +94a9d122f2f06ef709fd8016fd4b712d88052245a65a301f5f177ce22992f74ad05552b1f1af4e70d1eac62cef309752 +82d999b3e7cf563833b8bc028ff63a6b26eb357dfdb3fd5f10e33a1f80a9b2cfa7814d871b32a7ebfbaa09e753e37c02 +aec6edcde234df502a3268dd2c26f4a36a2e0db730afa83173f9c78fcb2b2f75510a02b80194327b792811caefda2725 +94c0bfa66c9f91d462e9194144fdd12d96f9bbe745737e73bab8130607ee6ea9d740e2cfcbbd00a195746edb6369ee61 +ab7573dab8c9d46d339e3f491cb2826cabe8b49f85f1ede78d845fc3995537d1b4ab85140b7d0238d9c24daf0e5e2a7e +87e8b16832843251fe952dadfd01d41890ed4bb4b8fa0254550d92c8cced44368225eca83a6c3ad47a7f81ff8a80c984 +9189d2d9a7c64791b19c0773ad4f0564ce6bea94aa275a917f78ad987f150fdb3e5e26e7fef9982ac184897ecc04683f +b3661bf19e2da41415396ae4dd051a9272e8a2580b06f1a1118f57b901fa237616a9f8075af1129af4eabfefedbe2f1c +af43c86661fb15daf5d910a4e06837225e100fb5680bd3e4b10f79a2144c6ec48b1f8d6e6b98e067d36609a5d038889a +82ac0c7acaa83ddc86c5b4249aae12f28155989c7c6b91e5137a4ce05113c6cbc16f6c44948b0efd8665362d3162f16a +8f268d1195ab465beeeb112cd7ffd5d5548559a8bc01261106d3555533fc1971081b25558d884d552df0db1cddda89d8 +8ef7caa5521f3e037586ce8ac872a4182ee20c7921c0065ed9986c047e3dda08294da1165f385d008b40d500f07d895f +8c2f98f6880550573fad46075d3eba26634b5b025ce25a0b4d6e0193352c8a1f0661064027a70fe8190b522405f9f4e3 +b7653f353564feb164f0f89ec7949da475b8dad4a4d396d252fc2a884f6932d027b7eb2dc4d280702c74569319ed701a +a026904f4066333befd9b87a8fad791d014096af60cdd668ef919c24dbe295ff31f7a790e1e721ba40cf5105abca67f4 +988f982004ada07a22dd345f2412a228d7a96b9cae2c487de42e392afe1e35c2655f829ce07a14629148ce7079a1f142 +9616add009067ed135295fb74d5b223b006b312bf14663e547a0d306694ff3a8a7bb9cfc466986707192a26c0bce599f +ad4c425de9855f6968a17ee9ae5b15e0a5b596411388cf976df62ecc6c847a6e2ddb2cea792a5f6e9113c2445dba3e5c +b698ac9d86afa3dc69ff8375061f88e3b0cff92ff6dfe747cebaf142e813c011851e7a2830c10993b715e7fd594604a9 +a386fa189847bb3b798efca917461e38ead61a08b101948def0f82cd258b945ed4d45b53774b400af500670149e601b7 +905c95abda2c68a6559d8a39b6db081c68cef1e1b4be63498004e1b2f408409be9350b5b5d86a30fd443e2b3e445640a +9116dade969e7ce8954afcdd43e5cab64dc15f6c1b8da9d2d69de3f02ba79e6c4f6c7f54d6bf586d30256ae405cd1e41 +a3084d173eacd08c9b5084a196719b57e47a0179826fda73466758235d7ecdb87cbcf097bd6b510517d163a85a7c7edd +85bb00415ad3c9be99ff9ba83672cc59fdd24356b661ab93713a3c8eab34e125d8867f628a3c3891b8dc056e69cd0e83 +8d58541f9f39ed2ee4478acce5d58d124031338ec11b0d55551f00a5a9a6351faa903a5d7c132dc5e4bb026e9cbd18e4 +a622adf72dc250e54f672e14e128c700166168dbe0474cecb340da175346e89917c400677b1bc1c11fcc4cc26591d9db +b3f865014754b688ca8372e8448114fff87bf3ca99856ab9168894d0c4679782c1ced703f5b74e851b370630f5e6ee86 +a7e490b2c40c2446fcd91861c020da9742c326a81180e38110558bb5d9f2341f1c1885e79b364e6419023d1cbdc47380 +b3748d472b1062e54572badbb8e87ac36534407f74932e7fc5b8392d008e8e89758f1671d1e4d30ab0fa40551b13bb5e +89898a5c5ec4313aabc607b0049fd1ebad0e0c074920cf503c9275b564d91916c2c446d3096491c950b7af3ac5e4b0ed +8eb8c83fef2c9dd30ea44e286e9599ec5c20aba983f702e5438afe2e5b921884327ad8d1566c72395587efac79ca7d56 +b92479599e806516ce21fb0bd422a1d1d925335ebe2b4a0a7e044dd275f30985a72b97292477053ac5f00e081430da80 +a34ae450a324fe8a3c25a4d653a654f9580ed56bbea213b8096987bbad0f5701d809a17076435e18017fea4d69f414bc +81381afe6433d62faf62ea488f39675e0091835892ecc238e02acf1662669c6d3962a71a3db652f6fe3bc5f42a0e5dc5 +a430d475bf8580c59111103316fe1aa79c523ea12f1d47a976bbfae76894717c20220e31cf259f08e84a693da6688d70 +b842814c359754ece614deb7d184d679d05d16f18a14b288a401cef5dad2cf0d5ee90bad487b80923fc5573779d4e4e8 +971d9a2627ff2a6d0dcf2af3d895dfbafca28b1c09610c466e4e2bff2746f8369de7f40d65b70aed135fe1d72564aa88 +8f4ce1c59e22b1ce7a0664caaa7e53735b154cfba8d2c5cc4159f2385843de82ab58ed901be876c6f7fce69cb4130950 +86cc9dc321b6264297987000d344fa297ef45bcc2a4df04e458fe2d907ad304c0ea2318e32c3179af639a9a56f3263cf +8229e0876dfe8f665c3fb19b250bd89d40f039bbf1b331468b403655be7be2e104c2fd07b9983580c742d5462ca39a43 +99299d73066e8eb128f698e56a9f8506dfe4bd014931e86b6b487d6195d2198c6c5bf15cccb40ccf1f8ddb57e9da44a2 +a3a3be37ac554c574b393b2f33d0a32a116c1a7cfeaf88c54299a4da2267149a5ecca71f94e6c0ef6e2f472b802f5189 +a91700d1a00387502cdba98c90f75fbc4066fefe7cc221c8f0e660994c936badd7d2695893fde2260c8c11d5bdcdd951 +8e03cae725b7f9562c5c5ab6361644b976a68bada3d7ca508abca8dfc80a469975689af1fba1abcf21bc2a190dab397d +b01461ad23b2a8fa8a6d241e1675855d23bc977dbf4714add8c4b4b7469ccf2375cec20e80cedfe49361d1a30414ac5b +a2673bf9bc621e3892c3d7dd4f1a9497f369add8cbaa3472409f4f86bd21ac67cfac357604828adfee6ada1835365029 +a042dff4bf0dfc33c178ba1b335e798e6308915128de91b12e5dbbab7c4ac8d60a01f6aea028c3a6d87b9b01e4e74c01 +86339e8a75293e4b3ae66b5630d375736b6e6b6b05c5cda5e73fbf7b2f2bd34c18a1d6cefede08625ce3046e77905cb8 +af2ebe1b7d073d03e3d98bc61af83bf26f7a8c130fd607aa92b75db22d14d016481b8aa231e2c9757695f55b7224a27f +a00ee882c9685e978041fd74a2c465f06e2a42ffd3db659053519925be5b454d6f401e3c12c746e49d910e4c5c9c5e8c +978a781c0e4e264e0dad57e438f1097d447d891a1e2aa0d5928f79a9d5c3faae6f258bc94fdc530b7b2fa6a9932bb193 +aa4b7ce2e0c2c9e9655bf21e3e5651c8503bce27483017b0bf476be743ba06db10228b3a4c721219c0779747f11ca282 +b003d1c459dacbcf1a715551311e45d7dbca83a185a65748ac74d1800bbeaba37765d9f5a1a221805c571910b34ebca8 +95b6e531b38648049f0d19de09b881baa1f7ea3b2130816b006ad5703901a05da57467d1a3d9d2e7c73fb3f2e409363c +a6cf9c06593432d8eba23a4f131bb7f72b9bd51ab6b4b772a749fe03ed72b5ced835a349c6d9920dba2a39669cb7c684 +aa3d59f6e2e96fbb66195bc58c8704e139fa76cd15e4d61035470bd6e305db9f98bcbf61ac1b95e95b69ba330454c1b3 +b57f97959c208361de6d7e86dff2b873068adb0f158066e646f42ae90e650079798f165b5cd713141cd3a2a90a961d9a +a76ee8ed9052f6a7a8c69774bb2597be182942f08115baba03bf8faaeaee526feba86120039fe8ca7b9354c3b6e0a8e6 +95689d78c867724823f564627d22d25010f278674c6d2d0cdb10329169a47580818995d1d727ce46c38a1e47943ebb89 +ab676d2256c6288a88e044b3d9ffd43eb9d5aaee00e8fc60ac921395fb835044c71a26ca948e557fed770f52d711e057 +96351c72785c32e5d004b6f4a1259fb8153d631f0c93fed172f18e8ba438fbc5585c1618deeabd0d6d0b82173c2e6170 +93dd8d3db576418e22536eba45ab7f56967c6c97c64260d6cddf38fb19c88f2ec5cd0e0156f50e70855eee8a2b879ffd +ad6ff16f40f6de3d7a737f8e6cebd8416920c4ff89dbdcd75eabab414af9a6087f83ceb9aff7680aa86bff98bd09c8cc +84de53b11671abc9c38710e19540c5c403817562aeb22a88404cdaff792c1180f717dbdfe8f54940c062c4d032897429 +872231b9efa1cdd447b312099a5c164c560440a9441d904e70f5abfc3b2a0d16be9a01aca5e0a2599a61e19407587e3d +88f44ac27094a2aa14e9dc40b099ee6d68f97385950f303969d889ee93d4635e34dff9239103bdf66a4b7cbba3e7eb7a +a59afebadf0260e832f6f44468443562f53fbaf7bcb5e46e1462d3f328ac437ce56edbca617659ac9883f9e13261fad7 +b1990e42743a88de4deeacfd55fafeab3bc380cb95de43ed623d021a4f2353530bcab9594389c1844b1c5ea6634c4555 +85051e841149a10e83f56764e042182208591396d0ce78c762c4a413e6836906df67f38c69793e158d64fef111407ba3 +9778172bbd9b1f2ec6bbdd61829d7b39a7df494a818e31c654bf7f6a30139899c4822c1bf418dd4f923243067759ce63 +9355005b4878c87804fc966e7d24f3e4b02bed35b4a77369d01f25a3dcbff7621b08306b1ac85b76fe7b4a3eb5f839b1 +8f9dc6a54fac052e236f8f0e1f571ac4b5308a43acbe4cc8183bce26262ddaf7994e41cf3034a4cbeca2c505a151e3b1 +8cc59c17307111723fe313046a09e0e32ea0cce62c13814ab7c6408c142d6a0311d801be4af53fc9240523f12045f9ef +8e6057975ed40a1932e47dd3ac778f72ee2a868d8540271301b1aa6858de1a5450f596466494a3e0488be4fbeb41c840 +812145efbd6559ae13325d56a15940ca4253b17e72a9728986b563bb5acc13ec86453796506ac1a8f12bd6f9e4a288c3 +911da0a6d6489eb3dab2ec4a16e36127e8a291ae68a6c2c9de33e97f3a9b1f00da57a94e270a0de79ecc5ecb45d19e83 +b72ea85973f4b2a7e6e71962b0502024e979a73c18a9111130e158541fa47bbaaf53940c8f846913a517dc69982ba9e1 +a7a56ad1dbdc55f177a7ad1d0af78447dc2673291e34e8ab74b26e2e2e7d8c5fe5dc89e7ef60f04a9508847b5b3a8188 +b52503f6e5411db5d1e70f5fb72ccd6463fa0f197b3e51ca79c7b5a8ab2e894f0030476ada72534fa4eb4e06c3880f90 +b51c7957a3d18c4e38f6358f2237b3904618d58b1de5dec53387d25a63772e675a5b714ad35a38185409931157d4b529 +b86b4266e719d29c043d7ec091547aa6f65bbf2d8d831d1515957c5c06513b72aa82113e9645ad38a7bc3f5383504fa6 +b95b547357e6601667b0f5f61f261800a44c2879cf94e879def6a105b1ad2bbf1795c3b98a90d588388e81789bd02681 +a58fd4c5ae4673fa350da6777e13313d5d37ed1dafeeb8f4f171549765b84c895875d9d3ae6a9741f3d51006ef81d962 +9398dc348d078a604aadc154e6eef2c0be1a93bb93ba7fe8976edc2840a3a318941338cc4d5f743310e539d9b46613d2 +902c9f0095014c4a2f0dccaaab543debba6f4cc82c345a10aaf4e72511725dbed7a34cd393a5f4e48a3e5142b7be84ed +a7c0447849bb44d04a0393a680f6cd390093484a79a147dd238f5d878030d1c26646d88211108e59fe08b58ad20c6fbd +80db045535d6e67a422519f5c89699e37098449d249698a7cc173a26ccd06f60238ae6cc7242eb780a340705c906790c +8e52b451a299f30124505de2e74d5341e1b5597bdd13301cc39b05536c96e4380e7f1b5c7ef076f5b3005a868657f17c +824499e89701036037571761e977654d2760b8ce21f184f2879fda55d3cda1e7a95306b8abacf1caa79d3cc075b9d27f +9049b956b77f8453d2070607610b79db795588c0cec12943a0f5fe76f358dea81e4f57a4692112afda0e2c05c142b26f +81911647d818a4b5f4990bfd4bc13bf7be7b0059afcf1b6839333e8569cdb0172fd2945410d88879349f677abaed5eb3 +ad4048f19b8194ed45b6317d9492b71a89a66928353072659f5ce6c816d8f21e69b9d1817d793effe49ca1874daa1096 +8d22f7b2ddb31458661abd34b65819a374a1f68c01fc6c9887edeba8b80c65bceadb8f57a3eb686374004b836261ef67 +92637280c259bc6842884db3d6e32602a62252811ae9b019b3c1df664e8809ffe86db88cfdeb8af9f46435c9ee790267 +a2f416379e52e3f5edc21641ea73dc76c99f7e29ea75b487e18bd233856f4c0183429f378d2bfc6cd736d29d6cadfa49 +882cb6b76dbdc188615dcf1a8439eba05ffca637dd25197508156e03c930b17b9fed2938506fdd7b77567cb488f96222 +b68b621bb198a763fb0634eddb93ed4b5156e59b96c88ca2246fd1aea3e6b77ed651e112ac41b30cd361fadc011d385e +a3cb22f6b675a29b2d1f827cacd30df14d463c93c3502ef965166f20d046af7f9ab7b2586a9c64f4eae4fad2d808a164 +8302d9ce4403f48ca217079762ce42cee8bc30168686bb8d3a945fbd5acd53b39f028dce757b825eb63af2d5ae41169d +b2eef1fbd1a176f1f4cd10f2988c7329abe4eb16c7405099fb92baa724ab397bc98734ef7d4b24c0f53dd90f57520d04 +a1bbef0bd684a3f0364a66bde9b29326bac7aa3dde4caed67f14fb84fed3de45c55e406702f1495a3e2864d4ee975030 +976acdb0efb73e3a3b65633197692dedc2adaed674291ae3df76b827fc866d214e9cac9ca46baefc4405ff13f953d936 +b9fbf71cc7b6690f601f0b1c74a19b7d14254183a2daaafec7dc3830cba5ae173d854bbfebeca985d1d908abe5ef0cda +90591d7b483598c94e38969c4dbb92710a1a894bcf147807f1bcbd8aa3ac210b9f2be65519aa829f8e1ccdc83ad9b8cf +a30568577c91866b9c40f0719d46b7b3b2e0b4a95e56196ac80898a2d89cc67880e1229933f2cd28ee3286f8d03414d7 +97589a88c3850556b359ec5e891f0937f922a751ac7c95949d3bbc7058c172c387611c0f4cb06351ef02e5178b3dd9e4 +98e7bbe27a1711f4545df742f17e3233fbcc63659d7419e1ca633f104cb02a32c84f2fac23ca2b84145c2672f68077ab +a7ddb91636e4506d8b7e92aa9f4720491bb71a72dadc47c7f4410e15f93e43d07d2b371951a0e6a18d1bd087aa96a5c4 +a7c006692227a06db40bceac3d5b1daae60b5692dd9b54772bedb5fea0bcc91cbcdb530cac31900ffc70c5b3ffadc969 +8d3ec6032778420dfa8be52066ba0e623467df33e4e1901dbadd586c5d750f4ccde499b5197e26b9ea43931214060f69 +8d9a8410518ea64f89df319bfd1fc97a0971cdb9ad9b11d1f8fe834042ea7f8dce4db56eeaf179ff8dda93b6db93e5ce +a3c533e9b3aa04df20b9ff635cb1154ce303e045278fcf3f10f609064a5445552a1f93989c52ce852fd0bbd6e2b6c22e +81934f3a7f8c1ae60ec6e4f212986bcc316118c760a74155d06ce0a8c00a9b9669ec4e143ca214e1b995e41271774fd9 +ab8e2d01a71192093ef8fafa7485e795567cc9db95a93fb7cc4cf63a391ef89af5e2bfad4b827fffe02b89271300407f +83064a1eaa937a84e392226f1a60b7cfad4efaa802f66de5df7498962f7b2649924f63cd9962d47906380b97b9fe80e1 +b4f5e64a15c6672e4b55417ee5dc292dcf93d7ea99965a888b1cc4f5474a11e5b6520eacbcf066840b343f4ceeb6bf33 +a63d278b842456ef15c278b37a6ea0f27c7b3ffffefca77c7a66d2ea06c33c4631eb242bbb064d730e70a8262a7b848a +83a41a83dbcdf0d22dc049de082296204e848c453c5ab1ba75aa4067984e053acf6f8b6909a2e1f0009ed051a828a73b +819485b036b7958508f15f3c19436da069cbe635b0318ebe8c014cf1ef9ab2df038c81161b7027475bcfa6fff8dd9faf +aa40e38172806e1e045e167f3d1677ef12d5dcdc89b43639a170f68054bd196c4fae34c675c1644d198907a03f76ba57 +969bae484883a9ed1fbed53b26b3d4ee4b0e39a6c93ece5b3a49daa01444a1c25727dabe62518546f36b047b311b177c +80a9e73a65da99664988b238096a090d313a0ee8e4235bc102fa79bb337b51bb08c4507814eb5baec22103ec512eaab0 +86604379aec5bddda6cbe3ef99c0ac3a3c285b0b1a15b50451c7242cd42ae6b6c8acb717dcca7917838432df93a28502 +a23407ee02a495bed06aa7e15f94cfb05c83e6d6fba64456a9bbabfa76b2b68c5c47de00ba169e710681f6a29bb41a22 +98cff5ecc73b366c6a01b34ac9066cb34f7eeaf4f38a5429bad2d07e84a237047e2a065c7e8a0a6581017dadb4695deb +8de9f68a938f441f3b7ab84bb1f473c5f9e5c9e139e42b7ccee1d254bd57d0e99c2ccda0f3198f1fc5737f6023dd204e +b0ce48d815c2768fb472a315cad86aa033d0e9ca506f146656e2941829e0acb735590b4fbc713c2d18d3676db0a954ac +82f485cdefd5642a6af58ac6817991c49fac9c10ace60f90b27f1788cc026c2fe8afc83cf499b3444118f9f0103598a8 +82c24550ed512a0d53fc56f64cc36b553823ae8766d75d772dacf038c460f16f108f87a39ceef7c66389790f799dbab3 +859ffcf1fe9166388316149b9acc35694c0ea534d43f09dae9b86f4aa00a23b27144dda6a352e74b9516e8c8d6fc809c +b8f7f353eec45da77fb27742405e5ad08d95ec0f5b6842025be9def3d9892f85eb5dd0921b41e6eff373618dba215bca +8ccca4436f9017e426229290f5cd05eac3f16571a4713141a7461acfe8ae99cd5a95bf5b6df129148693c533966145da +a2c67ecc19c0178b2994846fea4c34c327a5d786ac4b09d1d13549d5be5996d8a89021d63d65cb814923388f47cc3a03 +aa0ff87d676b418ec08f5cbf577ac7e744d1d0e9ebd14615b550eb86931eafd2a36d4732cc5d6fab1713fd7ab2f6f7c0 +8aef4730bb65e44efd6bb9441c0ae897363a2f3054867590a2c2ecf4f0224e578c7a67f10b40f8453d9f492ac15a9b2d +86a187e13d8fba5addcfdd5b0410cedd352016c930f913addd769ee09faa6be5ca3e4b1bdb417a965c643a99bd92be42 +a0a4e9632a7a094b14b29b78cd9c894218cdf6783e61671e0203865dc2a835350f465fbaf86168f28af7c478ca17bc89 +a8c7b02d8deff2cd657d8447689a9c5e2cd74ef57c1314ac4d69084ac24a7471954d9ff43fe0907d875dcb65fd0d3ce5 +97ded38760aa7be6b6960b5b50e83b618fe413cbf2bcc1da64c05140bcc32f5e0e709cd05bf8007949953fac5716bad9 +b0d293835a24d64c2ae48ce26e550b71a8c94a0883103757fb6b07e30747f1a871707d23389ba2b2065fa6bafe220095 +8f9e291bf849feaa575592e28e3c8d4b7283f733d41827262367ea1c40f298c7bcc16505255a906b62bf15d9f1ba85fb +998f4e2d12708b4fd85a61597ca2eddd750f73c9e0c9b3cf0825d8f8e01f1628fd19797dcaed3b16dc50331fc6b8b821 +b30d1f8c115d0e63bf48f595dd10908416774c78b3bbb3194192995154d80ea042d2e94d858de5f8aa0261b093c401fd +b5d9c75bb41f964cbff3f00e96d9f1480c91df8913f139f0d385d27a19f57a820f838eb728e46823cbff00e21c660996 +a6edec90b5d25350e2f5f0518777634f9e661ec9d30674cf5b156c4801746d62517751d90074830ac0f4b09911c262f1 +82f98da1264b6b75b8fbeb6a4d96d6a05b25c24db0d57ba3a38efe3a82d0d4e331b9fc4237d6494ccfe4727206457519 +b89511843453cf4ecd24669572d6371b1e529c8e284300c43e0d5bb6b3aaf35aeb634b3cb5c0a2868f0d5e959c1d0772 +a82bf065676583e5c1d3b81987aaae5542f522ba39538263a944bb33ea5b514c649344a96c0205a3b197a3f930fcda6c +a37b47ea527b7e06c460776aa662d9a49ff4149d3993f1a974b0dd165f7171770d189b0e2ea54fd5fccb6a14b116e68a +a1017677f97dda818274d47556d09d0e4ccacb23a252f82a6cfe78c630ad46fb9806307445a59fb61262182de3a2b29c +b01e9fcac239ba270e6877b79273ddd768bf8a51d2ed8a051b1c11e18eff3de5920e2fcbfbd26f06d381eddd3b1f1e1b +82fcd53d803b1c8e4ed76adc339b7f3a5962d37042b9683aabac7513ac68775d4a566a9460183926a6a95dbe7d551a1f +a763e78995d55cd21cdb7ef75d9642d6e1c72453945e346ab6690c20a4e1eeec61bb848ef830ae4b56182535e3c71d8f +b769f4db602251d4b0a1186782799bdcef66de33c110999a5775c50b349666ffd83d4c89714c4e376f2efe021a5cfdb2 +a59cbd1b785efcfa6e83fc3b1d8cf638820bc0c119726b5368f3fba9dce8e3414204fb1f1a88f6c1ff52e87961252f97 +95c8c458fd01aa23ecf120481a9c6332ebec2e8bb70a308d0576926a858457021c277958cf79017ddd86a56cacc2d7db +82eb41390800287ae56e77f2e87709de5b871c8bdb67c10a80fc65f3acb9f7c29e8fa43047436e8933f27449ea61d94d +b3ec25e3545eb83aed2a1f3558d1a31c7edde4be145ecc13b33802654b77dc049b4f0065069dd9047b051e52ab11dcdd +b78a0c715738f56f0dc459ab99e252e3b579b208142836b3c416b704ca1de640ca082f29ebbcee648c8c127df06f6b1e +a4083149432eaaf9520188ebf4607d09cf664acd1f471d4fb654476e77a9eaae2251424ffda78d09b6cb880df35c1219 +8c52857d68d6e9672df3db2df2dbf46b516a21a0e8a18eec09a6ae13c1ef8f369d03233320dd1c2c0bbe00abfc1ea18b +8c856089488803066bff3f8d8e09afb9baf20cecc33c8823c1c0836c3d45498c3de37e87c016b705207f60d2b00f8609 +831a3df39be959047b2aead06b4dcd3012d7b29417f642b83c9e8ce8de24a3dbbd29c6fdf55e2db3f7ea04636c94e403 +aed84d009f66544addabe404bf6d65af7779ce140dc561ff0c86a4078557b96b2053b7b8a43432ffb18cd814f143b9da +93282e4d72b0aa85212a77b336007d8ba071eea17492da19860f1ad16c1ea8867ccc27ef5c37c74b052465cc11ea4f52 +a7b78b8c8d057194e8d68767f1488363f77c77bddd56c3da2bc70b6354c7aa76247c86d51f7371aa38a4aa7f7e3c0bb7 +b1c77283d01dcd1bde649b5b044eac26befc98ff57cbee379fb5b8e420134a88f2fc7f0bf04d15e1fbd45d29e7590fe6 +a4aa8de70330a73b2c6458f20a1067eed4b3474829b36970a8df125d53bbdda4f4a2c60063b7cccb0c80fc155527652f +948a6c79ba1b8ad7e0bed2fae2f0481c4e41b4d9bbdd9b58164e28e9065700e83f210c8d5351d0212e0b0b68b345b3a5 +86a48c31dcbbf7b082c92d28e1f613a2378a910677d7db3a349dc089e4a1e24b12eee8e8206777a3a8c64748840b7387 +976adb1af21e0fc34148917cf43d933d7bfd3fd12ed6c37039dcd5a4520e3c6cf5868539ba5bf082326430deb8a4458d +b93e1a4476f2c51864bb4037e7145f0635eb2827ab91732b98d49b6c07f6ac443111aa1f1da76d1888665cb897c3834e +8afd46fb23bf869999fa19784b18a432a1f252d09506b8dbb756af900518d3f5f244989b3d7c823d9029218c655d3dc6 +83f1e59e3abeed18cdc632921672673f1cb6e330326e11c4e600e13e0d5bc11bdc970ae12952e15103a706fe720bf4d6 +90ce4cc660714b0b673d48010641c09c00fc92a2c596208f65c46073d7f349dd8e6e077ba7dcef9403084971c3295b76 +8b09b0f431a7c796561ecf1549b85048564de428dac0474522e9558b6065fede231886bc108539c104ce88ebd9b5d1b0 +85d6e742e2fb16a7b0ba0df64bc2c0dbff9549be691f46a6669bca05e89c884af16822b85faefefb604ec48c8705a309 +a87989ee231e468a712c66513746fcf03c14f103aadca0eac28e9732487deb56d7532e407953ab87a4bf8961588ef7b0 +b00da10efe1c29ee03c9d37d5918e391ae30e48304e294696b81b434f65cf8c8b95b9d1758c64c25e534d045ba28696f +91c0e1fb49afe46c7056400baa06dbb5f6e479db78ee37e2d76c1f4e88994357e257b83b78624c4ef6091a6c0eb8254d +883fb797c498297ccbf9411a3e727c3614af4eccde41619b773dc7f3259950835ee79453debf178e11dec4d3ada687a0 +a14703347e44eb5059070b2759297fcfcfc60e6893c0373eea069388eba3950aa06f1c57cd2c30984a2d6f9e9c92c79e +afebc7585b304ceba9a769634adff35940e89cd32682c78002822aab25eec3edc29342b7f5a42a56a1fec67821172ad5 +aea3ff3822d09dba1425084ca95fd359718d856f6c133c5fabe2b2eed8303b6e0ba0d8698b48b93136a673baac174fd9 +af2456a09aa777d9e67aa6c7c49a1845ea5cdda2e39f4c935c34a5f8280d69d4eec570446998cbbe31ede69a91e90b06 +82cada19fed16b891ef3442bafd49e1f07c00c2f57b2492dd4ee36af2bd6fd877d6cb41188a4d6ce9ec8d48e8133d697 +82a21034c832287f616619a37c122cee265cc34ae75e881fcaea4ea7f689f3c2bc8150bbf7dbcfd123522bfb7f7b1d68 +86877217105f5d0ec3eeff0289fc2a70d505c9fdf7862e8159553ef60908fb1a27bdaf899381356a4ef4649072a9796c +82b196e49c6e861089a427c0b4671d464e9d15555ffb90954cd0d630d7ae02eb3d98ceb529d00719c2526cd96481355a +a29b41d0d43d26ce76d4358e0db2b77df11f56e389f3b084d8af70a636218bd3ac86b36a9fe46ec9058c26a490f887f7 +a4311c4c20c4d7dd943765099c50f2fd423e203ccfe98ff00087d205467a7873762510cac5fdce7a308913ed07991ed7 +b1f040fc5cc51550cb2c25cf1fd418ecdd961635a11f365515f0cb4ffb31da71f48128c233e9cc7c0cf3978d757ec84e +a9ebae46f86d3bd543c5f207ed0d1aed94b8375dc991161d7a271f01592912072e083e2daf30c146430894e37325a1b9 +826418c8e17ad902b5fe88736323a47e0ca7a44bce4cbe27846ec8fe81de1e8942455dda6d30e192cdcc73e11df31256 +85199db563427c5edcbac21f3d39fec2357be91fb571982ddcdc4646b446ad5ced84410de008cb47b3477ee0d532daf8 +b7eed9cd400b2ca12bf1d9ae008214b8561fb09c8ad9ff959e626ffde00fee5ff2f5b6612e231f2a1a9b1646fcc575e3 +8b40bf12501dcbac78f5a314941326bfcddf7907c83d8d887d0bb149207f85d80cd4dfbd7935439ea7b14ea39a3fded7 +83e3041af302485399ba6cd5120e17af61043977083887e8d26b15feec4a6b11171ac5c06e6ad0971d4b58a81ff12af3 +8f5b9a0eecc589dbf8c35a65d5e996a659277ef6ea509739c0cb7b3e2da9895e8c8012de662e5b23c5fa85d4a8f48904 +835d71ed5e919d89d8e6455f234f3ff215462c4e3720c371ac8c75e83b19dfe3ae15a81547e4dc1138e5f5997f413cc9 +8b7d2e4614716b1db18e9370176ea483e6abe8acdcc3dcdf5fb1f4d22ca55d652feebdccc171c6de38398d9f7bfdec7a +93eace72036fe57d019676a02acf3d224cf376f166658c1bf705db4f24295881d477d6fdd7916efcfceff8c7a063deda +b1ac460b3d516879a84bc886c54f020a9d799e7c49af3e4d7de5bf0d2793c852254c5d8fe5616147e6659512e5ccb012 +acd0947a35cb167a48bcd9667620464b54ac0e78f9316b4aa92dcaab5422d7a732087e52e1c827faa847c6b2fe6e7766 +94ac33d21c3d12ff762d32557860e911cd94d666609ddcc42161b9c16f28d24a526e8b10bb03137257a92cec25ae637d +832e02058b6b994eadd8702921486241f9a19e68ed1406dad545e000a491ae510f525ccf9d10a4bba91c68f2c53a0f58 +9471035d14f78ff8f463b9901dd476b587bb07225c351161915c2e9c6114c3c78a501379ab6fb4eb03194c457cbd22bf +ab64593e034c6241d357fcbc32d8ea5593445a5e7c24cac81ad12bd2ef01843d477a36dc1ba21dbe63b440750d72096a +9850f3b30045e927ad3ec4123a32ed2eb4c911f572b6abb79121873f91016f0d80268de8b12e2093a4904f6e6cab7642 +987212c36b4722fe2e54fa30c52b1e54474439f9f35ca6ad33c5130cd305b8b54b532dd80ffd2c274105f20ce6d79f6e +8b4d0c6abcb239b5ed47bef63bc17efe558a27462c8208fa652b056e9eae9665787cd1aee34fbb55beb045c8bfdb882b +a9f3483c6fee2fe41312d89dd4355d5b2193ac413258993805c5cbbf0a59221f879386d3e7a28e73014f10e65dd503d9 +a2225da3119b9b7c83d514b9f3aeb9a6d9e32d9cbf9309cbb971fd53c4b2c001d10d880a8ad8a7c281b21d85ceca0b7c +a050be52e54e676c151f7a54453bbb707232f849beab4f3bf504b4d620f59ed214409d7c2bd3000f3ff13184ccda1c35 +adbccf681e15b3edb6455a68d292b0a1d0f5a4cb135613f5e6db9943f02181341d5755875db6ee474e19ace1c0634a28 +8b6eff675632a6fad0111ec72aacc61c7387380eb87933fd1d098856387d418bd38e77d897e65d6fe35951d0627c550b +aabe2328ddf90989b15e409b91ef055cb02757d34987849ae6d60bef2c902bf8251ed21ab30acf39e500d1d511e90845 +92ba4eb1f796bc3d8b03515f65c045b66e2734c2da3fc507fdd9d6b5d1e19ab3893726816a32141db7a31099ca817d96 +8a98b3cf353138a1810beb60e946183803ef1d39ac4ea92f5a1e03060d35a4774a6e52b14ead54f6794d5f4022b8685c +909f8a5c13ec4a59b649ed3bee9f5d13b21d7f3e2636fd2bb3413c0646573fdf9243d63083356f12f5147545339fcd55 +9359d914d1267633141328ed0790d81c695fea3ddd2d406c0df3d81d0c64931cf316fe4d92f4353c99ff63e2aefc4e34 +b88302031681b54415fe8fbfa161c032ea345c6af63d2fb8ad97615103fd4d4281c5a9cae5b0794c4657b97571a81d3b +992c80192a519038082446b1fb947323005b275e25f2c14c33cc7269e0ec038581cc43705894f94bad62ae33a8b7f965 +a78253e3e3eece124bef84a0a8807ce76573509f6861d0b6f70d0aa35a30a123a9da5e01e84969708c40b0669eb70aa6 +8d5724de45270ca91c94792e8584e676547d7ac1ac816a6bb9982ee854eb5df071d20545cdfd3771cd40f90e5ba04c8e +825a6f586726c68d45f00ad0f5a4436523317939a47713f78fd4fe81cd74236fdac1b04ecd97c2d0267d6f4981d7beb1 93e02b6052719f607dacd3a088274f65596bd0d09920b61ab5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7e024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02b4510b647ae3d1770bac0326a805bbefd48056c8c121bdb8 -99aca9fb2f7760cecb892bf7262c176b334824f5727f680bba701a33e322cb6667531410dfc7c8e4321a3f0ea8af48cb1436638a2093123f046f0f504cc2a864825542873edbbc5d7ed17af125a4f2cf6433c6f4f61b81173726981dd989761d -88e2e982982bf8231e747e9dfcd14c05bd02623d1332734d2af26246c6869fb56ee6c994843f593178a040495ba61f4a083b0e18110b1d9f5224783d8f9a895e8ee744e87929430e9ba96bd29251cbf61240b256d1525600f3d562894d93d659 -a2d33775e3d9e6af0d1b27d389e6c021a578e617a3d6627686db6288d4b3dffd7a847a00f7ef01828b7f42885b660e4204923402aca18fbae74ccd4e9c50dd8c2281b38dc09c022342ed1ac695d53f7081cb21f05fdfc0a3508c04759196fcd3 -af565445d2ad54c83a75c40e8895f5ad7219a8c728bce9d58d7a83716e095432993ebbd3f6911c66415a6f920d1a4d171478509b54a114308a020b33bf4487a7a8d0aa76ae4676a9b54e765a680f562d3a4fcb2e92c58b14b49b5b2917cc258f -8aa99cfaf514cef4801599cadd780d222194ca1ad69a34779c2bcfda93e5dbeb931e13914421b5809a6c81f12cf7038b04a35257cc9e94c33761e68565b1274aa6a6f9d66477229747a66b308b138f92aa4326a3bf23df65a1fe33b3b289bfe1 -99ba36d8b4f56bde026099278548b1afc0a987cbd7c9baa51fc8e6cbb8237a17636f1a44a385cec69b05a5802059956a11fe793cabb939c38800f9c239ca2518e898ade1ec2513c9ee492071a35aabd78182392a09123d28dbc233313c9120c4 -a7dc40c36afccb30a2eaff250860b28b227c195cf05674704c567d77d6655c446ae835f8fc8667e71147ab02afcb2dad0babe60cbfa37d7c2cddc68d2dec54f28a4142f8353590a3902d5ddaa22066ab563dd1435dda83f276387b9767d69120 -939e6cc97a8b88572852a5b7f25e4838556307f60aeafb5d2b6961edbcafd4b48cb6ac980ffbacf4be963f324ba81e3d12de4f1459d8c746d0762c66ae1b166027f7fbe641d9c48f3c7d97b06d956b0be51dcc9aab65f3e99e1388e63bdd79f9 -b391e156541dfd4003d1697cdb7ec815b309807320574906b2e652ef0175828b356d215cd374b1b34d9f470b3fa0e643113e67b2273268f922f04f072cfb89008358185b25cd631f82911a3f20f90f75758ffb99bebb8076458ae1e9d1ae898c -b9ac9c84934cc2a85c876eff65577e1dfce1935cd6392c877dd881a7d2f5c3e9344f28c04f90c62a6db4237ca00f9e0d00cb5f63e3f060fc7303916e19273b6fe455f331cabbe2fe5a22d584484f0d4176120fec9819fbb0a01e6d38695acfcd -88209eb030c5d78734bf2c2a5c539653fd3c24b4c08e624f9ddc4a6550efbdc1054a56eb0c807595aad6de56fda326aa196d032a8b4b48d40140a2d77df3c7243eda6507936389a321a5811eb38e32ee433c788deeae1eb928b00940e2944bcc -a8632ddc9cf7cbc1e8b74a05b7d4a89618c64afe30367ca0c9550ae7d320bf4e51c5a69e1501a1d8bee4240d13d7835501aa39fdc401a74f4d5734e268a7ce29a1fcfdb0a8bc64e0dd4a9e8578d6985bc2bc6a3764ce7a3703f6fb2e52557a2b -a037ac67e8bb6f4193ac967e05d080a489f58ef8d3d30a89798246f3e4936121ee445b03e410a09e8ebc0db2e2477d110aad0ade99b0887f1eb016e750f42135866907f150bd6f4f99a8cb94281474166874808ebe03b118c5daab16dafdc38b -a50d9143116bffa3b237da8e1805327e81e9cd25e658289bd727d5f9e0020172cc8690dcfe31a240e5cbc48353b88c4908baa1dd7320165556e0aa633f62fcbe7870222d345a3bbcdb7ab6c07f0fd86be559964afabf56f0a8cbc0b4b91d477e -afa988ea6fa4f40c5ad07d2d580d29025ddf56d6ef1171a8b8de3464203f70b97d6f5ace72747345204b35150e06154d1477516a989ce8eea7871cc0d0de00a077c0fb23ad4837e409d0b885bf3f2dde11a30fa6273d662e68e09f461e52932f -97fa1a943ed8b81574304a3d03f4f15907f6e6e0cd36a66bd2ad2c75afafc70a61d3ff69b77ebe4dae9ca0fcedef80081062705e60bbb6ea0f1f398c84d2f8e4a3ac142ac66426c21ad5e9994ebbcc406af474c4aec5e32fadcb21875af7c9f1 -b30a564614493886f14a5dd71c89457504f8c59a7ac01b665ed167e9a8f9ee5832198fd319ecd234196ee57031bdf3840bd5a923e203a1938bc795c704b5285389750e1fd10d7050061ba19db00a60a2c0384a7d661d7d48ebe6962272230859 -84c8dea942cfae71cb02e705ec496d967425793ce8812e7ee53c2f23713abeaff566a658cd1c73dfd18187d16253a6ee0a623e82cd18e31cd1a1875d19c078835dc9292e141686150a88065226ada264740143e87c03a0f6c4da8c187438ebf4 -8c3abae8aed60338f8c4ff80aab22f8a2ae56756a93566c906f490a97151d34a1c3318054e1c494c60cc53327ad86a2d02c6c76a406726ce4f88635bc32eff0db0b61762dc518b95fa8da82e87e4bf3de54f1d72180ef53ed7bc5413e6a9a510 -a328230c92a6b1cef6a444bcb64edb992f71e3d7b93f0b6b8b408ba7c908db746d92ddb2c7588bab438ef3bc61be1c2f0dfc86ba2ff514b42b35c80f89b2e780f813ea1dfb977fbded2cd9b553b747fa952e227ebd8f071163d421fc337f04c9 -b482cab423cd5f1c5df036070aade7aa016283d69619d664025c3feab866a0a5691d344b2ee2bedc5dedd1f9a73eae16003a3827c9e5bbe22ded32d848fba840ffad1141ad158f5c40bc8ae0d03781b9705d851a7f1391b096c576c0f4f2a6b0 -919ee1df27fabcb21237a1b7b98f53d41d849e1b6a8f9e28c3fae2841c6b5a250e4041c737e6725476e5cd715e34d3880f58d80f61efaabc261bdc703e8750f48a923e9bf8980931b9fd9e40014c66c54b3e7c98241d76d1aa47af43313a65a1 -ac94830145dbe9a8f7e6e0fc1f5fb454502d22abcafdc2dd96c6933c604461fa83b2b37385f4bc454875a02a6d4157841250956783515d11c7456e7f11b745f12856d89f5feedaf6a61a483a6c33a21cd2ba0c18eb41a1a2e7fc33bb53e4c570 -b209c699f1233735c5bb4bce848e4365fd76651ae2184d2279a90df0c2f69ffa2a24d84a9b9f274021072953c0d65e1a0202d490d6c37186af240114e445d87bff754b4824937e4f2c90a574061b1c4910fed88d90f698025a2a264e656cb8a4 -93320dc0576b0d069de63c40e5582b4486d9adf5e69e77e3ebaf3da26976fe42147a65051501bc8383f99e7ba75479c70a6726c2cd08bf98c7481f1f819712292d833a879f21a1221a9610bc748fb5e911055122fdb4055cdc84e8bfe0f4df9b -a4380b240e998cdf668591f71a0c88ed143b0185a920787627ce65095f8223dc606fa5bce93377af100de92d663e675c0736d7f1973603a84a5c4162fb5e01c88c7493503ae1d7e9fbe8ece9b418397d68c21eeb88dae226e09875d372c646dd -aab48517d69135a16b36b685adfe9b2544a709135a21ba3e75981a2cba4ec81d1fe28ac0f72fde0c0001c15300ed6a810f58d3117bdd58d0149751d6508cf8a1a1ff7b63dd02d2730a9d6fe96c77c502fe8ed46d50a181ec4bb35e37dfbd6af4 -8277265fe75ab89ce4ec65b33fb4084bec0a56d81faf2f7a9070d2ca3065678e03a790350eba56323a54e0285bc32fe8007d5259740fde226e16cbde8354eacd562294eb9b7f727ed72ffbdad86f467cf057c737b34b80a41deb92634ed866f5 -aa40a24cb2ebe606d969392c03020070f044c95088d80f57f771b837c048342d2cd3474600d7660441090ffb8d2ffb7f0eddd67eb378e3e1477a6ba0bc38096d5d2d3355bc8b60f605f57f0c1899da591457440352381d2b38c0aa9acc7fe419 -80815d10685808cb630820629bcd2fa9041c9b74433630c0b9c1b7f7e8edf1440b520217f76ec9a50c125cf4438aa66006a1928a9ed2321da7ea325c3d56b65462b72118ca2c99a0ea733aa11da9abbeda6cc71ffeed301ae70213a29e697dcd -ac235d079f91b00b1fead7523da8f73a5409fa8970907af0c5d5e4c6a0996dccfcdb0d822d08c7fbc0c24799457d011d04312d20831825f23cf988141056a6814c8a1cac9efe37bdcbfa272aed24cd92810fea7c49b0d07683a5c53643872179 -b8aa59534d75fa5ac1c2c3f963bf73899aff5210059dbde8a8635561c6249e5143affee3bd2fd57575213b52d9a73d5702525867a7dcbb1d0a49b98c2925556fc5463ff0209742046a24ab29e74257d6419401093cc4371944d811cc300b6a67 -80bbfc5b816eea29a6d84e2217dee4d547306994d39e5592515e1b0807b67fe960d1d5addb0ff1a20c158bdb294c04bf093d28996121845a2c9268e2c9ac0f4067e889c6aaca62f8535d35b45036954bd069e3afa84f04721538c26003304c20 -a535c17d0e151d0e03d42dd58ba8c715bee3fabca2890e0e016071d34184b6b34e770d2be29c8ec76b69bcc471d50f4d043c2c240e9b93a81cff7ee2724e02018dfd9b534e40be641fdb4884abcd83b76f517557ffba508f1ba2f56313f4de94 -b237eb7465df0d325a3aa58269be2627e4978f9863f4f100ed4c303cb1f6549e606f2e3c9180824d8049191965c8dacd0a0c76cc56cb22cf1bcfdb39372c8aa29b4f7b34582b1719e6bd59c930d87d5ccd838743b585d6e229d5ed42337315c0 -805c335a2a9d2de30809cf30808ef836d88e9453c510716f01696f14c72dd60505eca8f128970edc8e63a9aa1f8792ac0dd50dcc84fbf4cc8b32349c682a6a27bc7551c7aa273a94c1606d07710188d93579afe3be1781bded15a34ed6047922 -b25dadf385ddd3c39bcb0a014d3d4f66127946b1aceae8809e3a03d66cc25e27142ca108316391f857fe82fdea4db2520cc73793b695eafbf3ade00ef7ec747b0457e49303f5e1a370f5263b436566fe24a0876e5fe088238c7be37a0718d65f -b0f753081cabe2c8fce73aba82ff67dbc9842598b3e7fa3ce2a1f534536f8ac63c532fe66552ac6b7adb28c73ed4c8a4184849be7c1756a4681ce29ebf5e1c3aa806b667ee6bd68f6397aba3215dc1caec6742f21d681e32cd1160d6a3b1d7ee -b798771eeb3d7a17c62ba5916cc034bba870da6b1ac14c2e1cae71af3ad4e0c0d1ff983f691e0e55289d5a33b131f2ec12430c9566dd71f4d8be9c79155357a5c30c5efcfd75bbe1bb6d5ada4d50604ea49ed838d3641f268ca6e25c9c4b6b72 -b52554c017388b099804abbe565346591a086d9979e10140ddaccc0a3680e506db775d7cbeafde67563adf0f09f5c2420caf19629f4e8f03e6fe02e9416ecd5269989e482b90004a083967d1141387eb74865bac6bd17e7a6d5f58225e52d4b7 -b520ff694520919023d44d53f98a7de2f78ff37b2d9193dcaa35556a6a0febf767781a4c961dce7c804bfdf81935f8f0082865253da52e79dfa1c5ff74d61495b2da76e167d46114709e877a7791a3a95e33a42f56b83f5f5afe271c67ae997c -b721401983440797a03d5b99f2088a0b249aa911969c34dd6c615b0060325da555d2ad99d931170c0868b0488a2234a4114cc0013d5163b833f5c45c5eb536421c016cf85788390176bb2dc4c196d6be26bbbfceae048b82f0d8039222e71c94 -acd9d833ba0a8cbd8d1ba939a11ea0fa5607e1bc6e693ec318bdb097aedd042d76e695dcebebd142e2e4ac30b1905dff03ec36d9cc70577e4dbe5e9ed7c20c7afb13a7f0155f203c6b83b9f1ad3d20a0d4aef0fbbbcf466ffc1bcd482bc2f5e0 -8cc1795de015f2b0e72116f169f3b4624b7738ceebea354e0bd9051c27b86f647ea36cad57ea6884c1a8adf9b45cd83514fa687e68878bbd613d793aa10986d5a0411f081689229e0d72133b3667b9f3f1a02211d0e680564eb1ea43393e1f36 -aa9281c61113c343a108de1036570feefc72fb7a96ff11f73024de12b83f29631f5a8a5900e6f10b15227c6f7462881511271bf785ebdf95ce288100e5dab391f664f6ff76c72b65b34479a4f43e5e8eba292209d6654157286ad3242ac342db -aaf16866275082e59d415db317aa874267d048ee405a553e852e6d175711d31a1fee99912345915bce121f43bc3e00d81338e5fcd3c8a1012fb4f172a9fe15622dd368b4d9d5cb60d189f423b071791fe26cea7676aca8df07965cacf80b0cd0 -accc80b3d8a6ffa648487a3d3c0ce1aeeb5401edf3cf2e385ea4a6d5fc110054fcce38f01f1da7141bbed30eb7a0a6810c82212bbb9da75d6033082dbcf6bc6a5791f85aa0f045a10da5de015edbf369b4d23b32b0c058962d2ee88e6911f994 -83f1089395a16077738cc7c9a6d6a3dc9033aac4abc508af5a1f007ca92e1a80b2e6f2dbda7fdcf0d5646de790a6201d0a9cfbcb6620a1426600e3a6a425ec004384f49fb9dcd166691a47177d45dcbcb761a11d46220b0aa09fc946131f7aa5 -9246bb586d43cb817c2e15ed609156e9f1cd284ba2f4797bbfa51c0341e1ba382eaac059aa9f63fb88d228a1a932839a171e7c7d00199dc7c4d6c5ea038a02cbc3cc5297c70401520e70ebbcffacd6a703f62896f3c788f94dde3c33ab0ecbdb -a316cb7c74feb0563c56cc79015e2774fbeca458bf8e9fb07894f9d6bcd73f7fb9428e87c816e5629e4bf7f3ec567fbc091549471b75492dde08217cb334b716b4582b24384586e53388873a78a90ec01bd7c3bace9cfc52161467df16e27c33 -ade18c74bbe60d1d69f4a570f8e5fd8696c26cc9e02829040b6b14cb9c49a4b3263b5bd5e16ec0b29010b4be054c16ab09304e23442af7d7f5fcc60bc6c5634ab6e4aed7ef334b2785e4c7672d59a687278e42d310342db5e5975d716e6d1595 -b7728800bb2039acf228fa3d8028569c426cb85d28b2b5820bbef938d5ca8c4df981d3e01a309e26ca101e8295d0f6990c03b8c239798323575874a4ee5bfe46cfe99b9657189142aacd8f8d1f26cf4c0e73c6397c31ba8f18102b9ea315b638 -8fb14f2a9be193f54977ecd3021663108ea143627b9a9d9faff85d1a86b855f6c437eab435fad3304f245bd7732af07f1173494cdb802fb96e85d2db89e1643206e183f3b228ca8d3f586e71aa9308eaf0223100bf07942fc39e465016d1f775 -ac1e025e53d98fdb3380489dce82d9d4bd3a6c98f0a523b841cb09a6f26ddd4d22efd98776e78d10fd996995fd00e81e08d3c25dd14a54b25a9d483677a24bbb8d1cb41a443b2c71038e6893b1b30f70758424e0f2039a48060191389033ef55 -a4c017311b9e930868132527a9849072b91db04fd36c619ae39c98da9e2174e6201d3c2ff1246c06b1b6815bbf3ea4a1116564f55ee2fe4c4d655e2294c0ded842cba209c255ca3d7b7f82d162f97890dfdeed087aa2f87cbfc61d61815da39d -89516315a3956b455843c2555248bd94dcb19993060fe75fdd51f7aa9c9147ab13997d8a98036a8f04bee5c91d78d2990907e35a52537a8ab3ed15f1a71afdcd38044a5b6e93f662b9d36c16933a881927cacae668c4c06ee6f004c9e3989bad -a1e78a011e210400c68ca76045f7da74119bff3cbe382efd2bd2ac76567c52d68d75536a91999d084043e1ce2d07d02e0b69fb99924101d2543521747536fbc51b0454aa9a4cbbec101121f597863a5c0fee2ca5eab35dff9b9085bef8b2b0d0 -830fd8d083e39153ecab43cabb22e29d7b44a55fba467af4ddd3f069439d2972ef53c3518de788f96b3f4f64963987d0155ba27afc28643af3de8e476ff515a68285728167408f45d99e574680bda6bacdd4322e587e4aa99386e035c0e931ad -b89584da22237e3061d991b1a55a5e55dc637b8b671130d304587729348138ef87885180310efe9f9f6d3580b9d7fdcf0649e8a79d2dec8c25a9f53df0fac5d517db999029cbfdd7c2cbd3e9a5503e5d267d3d8ad752335915c92b850b14bafb -959b8030733799882c5e3735479924b013756e57b893f9792bab4043e2d362d77cf308166d782e3989caa771b8a0c0a01302cb7b5e8ca12e2d6cebd59d4cd173c9dc25f438bac597fab17b4ff44997a489c168e7204b7d7c21d0938f0a2e3b51 -a0a9e5503d9afe0027891dab890c687fd5f5fac5741418490c64d7c15f59533dd603a50163c79402afa61bd02de486761983c94501da17e6bbe78c497f2122210071602f578adc0ebe7a4679f87fe77e09c8c122de69105f13455fea25f08e6f -9811487283ad620cd7c9b303ae2f348d0e6f5ee17b504baaa817ae207adb912a00d3cc36dbf48745eb899e6b6e22f09f0f9ba29d949ecd7350fbbfe87a8c7cdd5d0e687fc807751d07634aaf7c38baf3b24a0670c38fa6ccd7431436fc95525f -8a13aa5071c526e560def7d8583393942f07d88c9d8d26c98738fd65f57af2e3326dbb1edff0f39fe98eda4a13ed4fd71844254b954690154c4804e1c4a53df9dc4643f4b7b09d0860070f6b2318d0d63d28fb56bf5b6ff456a18dfc72fdfbbe -b9c90ff6bff5dd97d90aee27ea1c61c1afe64b054c258b097709561fe00710e9e616773fc4bdedcbf91fbd1a6cf139bf14d20db07297418694c12c6c9b801638eeb537cb3741584a686d69532e3b6c12d8a376837f712032421987f1e770c258 +b5bfd7dd8cdeb128843bc287230af38926187075cbfbefa81009a2ce615ac53d2914e5870cb452d2afaaab24f3499f72185cbfee53492714734429b7b38608e23926c911cceceac9a36851477ba4c60b087041de621000edc98edada20c1def2 +b5337ba0ce5d37224290916e268e2060e5c14f3f9fc9e1ec3af5a958e7a0303122500ce18f1a4640bf66525bd10e763501fe986d86649d8d45143c08c3209db3411802c226e9fe9a55716ac4a0c14f9dcef9e70b2bb309553880dc5025eab3cc +b3c1dcdc1f62046c786f0b82242ef283e7ed8f5626f72542aa2c7a40f14d9094dd1ebdbd7457ffdcdac45fd7da7e16c51200b06d791e5e43e257e45efdf0bd5b06cd2333beca2a3a84354eb48662d83aef5ecf4e67658c851c10b13d8d87c874 +954d91c7688983382609fca9e211e461f488a5971fd4e40d7e2892037268eacdfd495cfa0a7ed6eb0eb11ac3ae6f651716757e7526abe1e06c64649d80996fd3105c20c4c94bc2b22d97045356fe9d791f21ea6428ac48db6f9e68e30d875280 +88a6b6bb26c51cf9812260795523973bb90ce80f6820b6c9048ab366f0fb96e48437a7f7cb62aedf64b11eb4dfefebb0147608793133d32003cb1f2dc47b13b5ff45f1bb1b2408ea45770a08dbfaec60961acb8119c47b139a13b8641e2c9487 +85cd7be9728bd925d12f47fb04b32d9fad7cab88788b559f053e69ca18e463113ecc8bbb6dbfb024835f901b3a957d3108d6770fb26d4c8be0a9a619f6e3a4bf15cbfd48e61593490885f6cee30e4300c5f9cf5e1c08e60a2d5b023ee94fcad0 +80477dba360f04399821a48ca388c0fa81102dd15687fea792ee8c1114e00d1bc4839ad37ac58900a118d863723acfbe08126ea883be87f50e4eabe3b5e72f5d9e041db8d9b186409fd4df4a7dde38c0e0a3b1ae29b098e5697e7f110b6b27e4 +b7a6aec08715a9f8672a2b8c367e407be37e59514ac19dd4f0942a68007bba3923df22da48702c63c0d6b3efd3c2d04e0fe042d8b5a54d562f9f33afc4865dcbcc16e99029e25925580e87920c399e710d438ac1ce3a6dc9b0d76c064a01f6f7 +ac1b001edcea02c8258aeffbf9203114c1c874ad88dae1184fadd7d94cd09053649efd0ca413400e6e9b5fa4eac33261000af88b6bd0d2abf877a4f0355d2fb4d6007adb181695201c5432e50b850b51b3969f893bddf82126c5a71b042b7686 +90043fda4de53fb364fab2c04be5296c215599105ecff0c12e4917c549257125775c29f2507124d15f56e30447f367db0596c33237242c02d83dfd058735f1e3c1ff99069af55773b6d51d32a68bf75763f59ec4ee7267932ae426522b8aaab6 +a8660ce853e9dc08271bf882e29cd53397d63b739584dda5263da4c7cc1878d0cf6f3e403557885f557e184700575fee016ee8542dec22c97befe1d10f414d22e84560741cdb3e74c30dda9b42eeaaf53e27822de2ee06e24e912bf764a9a533 +8fe3921a96d0d065e8aa8fce9aa42c8e1461ca0470688c137be89396dd05103606dab6cdd2a4591efd6addf72026c12e065da7be276dee27a7e30afa2bd81c18f1516e7f068f324d0bad9570b95f6bd02c727cd2343e26db0887c3e4e26dceda +8ae1ad97dcb9c192c9a3933541b40447d1dc4eebf380151440bbaae1e120cc5cdf1bcea55180b128d8e180e3af623815191d063cc0d7a47d55fb7687b9d87040bf7bc1a7546b07c61db5ccf1841372d7c2fe4a5431ffff829f3c2eb590b0b710 +8c2fa96870a88150f7876c931e2d3cc2adeaaaf5c73ef5fa1cf9dfa0991ae4819f9321af7e916e5057d87338e630a2f21242c29d76963cf26035b548d2a63d8ad7bd6efefa01c1df502cbdfdfe0334fb21ceb9f686887440f713bf17a89b8081 +b9aa98e2f02bb616e22ee5dd74c7d1049321ac9214d093a738159850a1dbcc7138cb8d26ce09d8296368fd5b291d74fa17ac7cc1b80840fdd4ee35e111501e3fa8485b508baecda7c1ab7bd703872b7d64a2a40b3210b6a70e8a6ffe0e5127e3 +9292db67f8771cdc86854a3f614a73805bf3012b48f1541e704ea4015d2b6b9c9aaed36419769c87c49f9e3165f03edb159c23b3a49c4390951f78e1d9b0ad997129b17cdb57ea1a6638794c0cca7d239f229e589c5ae4f9fe6979f7f8cba1d7 +91cd9e86550f230d128664f7312591fee6a84c34f5fc7aed557bcf986a409a6de722c4330453a305f06911d2728626e611acfdf81284f77f60a3a1595053a9479964fd713117e27c0222cc679674b03bc8001501aaf9b506196c56de29429b46 +a9516b73f605cc31b89c68b7675dc451e6364595243d235339437f556cf22d745d4250c1376182273be2d99e02c10eee047410a43eff634d051aeb784e76cb3605d8e079b9eb6ad1957dfdf77e1cd32ce4a573c9dfcc207ca65af6eb187f6c3d +a9667271f7d191935cc8ad59ef3ec50229945faea85bfdfb0d582090f524436b348aaa0183b16a6231c00332fdac2826125b8c857a2ed9ec66821cfe02b3a2279be2412441bc2e369b255eb98614e4be8490799c4df22f18d47d24ec70bba5f7 +a4371144d2aa44d70d3cb9789096d3aa411149a6f800cb46f506461ee8363c8724667974252f28aea61b6030c05930ac039c1ee64bb4bd56532a685cae182bf2ab935eee34718cffcb46cae214c77aaca11dbb1320faf23c47247db1da04d8dc +89a7eb441892260b7e81168c386899cd84ffc4a2c5cad2eae0d1ab9e8b5524662e6f660fe3f8bfe4c92f60b060811bc605b14c5631d16709266886d7885a5eb5930097127ec6fb2ebbaf2df65909cf48f253b3d5e22ae48d3e9a2fd2b01f447e +9648c42ca97665b5eccb49580d8532df05eb5a68db07f391a2340769b55119eaf4c52fe4f650c09250fa78a76c3a1e271799b8333cc2628e3d4b4a6a3e03da1f771ecf6516dd63236574a7864ff07e319a6f11f153406280d63af9e2b5713283 +9663bf6dd446ea7a90658ee458578d4196dc0b175ef7fcfa75f44d41670850774c2e46c5a6be132a2c072a3c0180a24f0305d1acac49d2d79878e5cda80c57feda3d01a6af12e78b5874e2a4b3717f11c97503b41a4474e2e95b179113726199 +b212aeb4814e0915b432711b317923ed2b09e076aaf558c3ae8ef83f9e15a83f9ea3f47805b2750ab9e8106cb4dc6ad003522c84b03dc02829978a097899c773f6fb31f7fe6b8f2d836d96580f216fec20158f1590c3e0d7850622e15194db05 +925f005059bf07e9ceccbe66c711b048e236ade775720d0fe479aebe6e23e8af281225ad18e62458dc1b03b42ad4ca290d4aa176260604a7aad0d9791337006fbdebe23746f8060d42876f45e4c83c3643931392fde1cd13ff8bddf8111ef974 +9553edb22b4330c568e156a59ef03b26f5c326424f830fe3e8c0b602f08c124730ffc40bc745bec1a22417adb22a1a960243a10565c2be3066bfdb841d1cd14c624cd06e0008f4beb83f972ce6182a303bee3fcbcabc6cfe48ec5ae4b7941bfc +935f5a404f0a78bdcce709899eda0631169b366a669e9b58eacbbd86d7b5016d044b8dfc59ce7ed8de743ae16c2343b50e2f925e88ba6319e33c3fc76b314043abad7813677b4615c8a97eb83cc79de4fedf6ccbcfa4d4cbf759a5a84e4d9742 +a5b014ab936eb4be113204490e8b61cd38d71da0dec7215125bcd131bf3ab22d0a32ce645bca93e7b3637cf0c2db3d6601a0ddd330dc46f9fae82abe864ffc12d656c88eb50c20782e5bb6f75d18760666f43943abb644b881639083e122f557 +935b7298ae52862fa22bf03bfc1795b34c70b181679ae27de08a9f5b4b884f824ef1b276b7600efa0d2f1d79e4a470d51692fd565c5cf8343dd80e5d3336968fc21c09ba9348590f6206d4424eb229e767547daefa98bc3aa9f421158dee3f2a +9830f92446e708a8f6b091cc3c38b653505414f8b6507504010a96ffda3bcf763d5331eb749301e2a1437f00e2415efb01b799ad4c03f4b02de077569626255ac1165f96ea408915d4cf7955047620da573e5c439671d1fa5c833fb11de7afe6 +840dcc44f673fff3e387af2bb41e89640f2a70bcd2b92544876daa92143f67c7512faf5f90a04b7191de01f3e2b1bde00622a20dc62ca23bbbfaa6ad220613deff43908382642d4d6a86999f662efd64b1df448b68c847cfa87630a3ffd2ec76 +92950c895ed54f7f876b2fda17ecc9c41b7accfbdd42c210cc5b475e0737a7279f558148531b5c916e310604a1de25a80940c94fe5389ae5d6a5e9c371be67bceea1877f5401725a6595bcf77ece60905151b6dfcb68b75ed2e708c73632f4fd +8010246bf8e94c25fd029b346b5fbadb404ef6f44a58fd9dd75acf62433d8cc6db66974f139a76e0c26dddc1f329a88214dbb63276516cf325c7869e855d07e0852d622c332ac55609ba1ec9258c45746a2aeb1af0800141ee011da80af175d4 +b0f1bad257ebd187bdc3f37b23f33c6a5d6a8e1f2de586080d6ada19087b0e2bf23b79c1b6da1ee82271323f5bdf3e1b018586b54a5b92ab6a1a16bb3315190a3584a05e6c37d5ca1e05d702b9869e27f513472bcdd00f4d0502a107773097da +9636d24f1ede773ce919f309448dd7ce023f424afd6b4b69cb98c2a988d849a283646dc3e469879daa1b1edae91ae41f009887518e7eb5578f88469321117303cd3ac2d7aee4d9cb5f82ab9ae3458e796dfe7c24284b05815acfcaa270ff22e2 +b373feb5d7012fd60578d7d00834c5c81df2a23d42794fed91aa9535a4771fde0341c4da882261785e0caca40bf83405143085e7f17e55b64f6c5c809680c20b050409bf3702c574769127c854d27388b144b05624a0e24a1cbcc4d08467005b +b15680648949ce69f82526e9b67d9b55ce5c537dc6ab7f3089091a9a19a6b90df7656794f6edc87fb387d21573ffc847062623685931c2790a508cbc8c6b231dd2c34f4d37d4706237b1407673605a604bcf6a50cc0b1a2db20485e22b02c17e +8817e46672d40c8f748081567b038a3165f87994788ec77ee8daea8587f5540df3422f9e120e94339be67f186f50952504cb44f61e30a5241f1827e501b2de53c4c64473bcc79ab887dd277f282fbfe47997a930dd140ac08b03efac88d81075 +a6e4ef6c1d1098f95aae119905f87eb49b909d17f9c41bcfe51127aa25fee20782ea884a7fdf7d5e9c245b5a5b32230b07e0dbf7c6743bf52ee20e2acc0b269422bd6cf3c07115df4aa85b11b2c16630a07c974492d9cdd0ec325a3fabd95044 +8634aa7c3d00e7f17150009698ce440d8e1b0f13042b624a722ace68ead870c3d2212fbee549a2c190e384d7d6ac37ce14ab962c299ea1218ef1b1489c98906c91323b94c587f1d205a6edd5e9d05b42d591c26494a6f6a029a2aadb5f8b6f67 +821a58092900bdb73decf48e13e7a5012a3f88b06288a97b855ef51306406e7d867d613d9ec738ebacfa6db344b677d21509d93f3b55c2ebf3a2f2a6356f875150554c6fff52e62e3e46f7859be971bf7dd9d5b3e1d799749c8a97c2e04325df +8dba356577a3a388f782e90edb1a7f3619759f4de314ad5d95c7cc6e197211446819c4955f99c5fc67f79450d2934e3c09adefc91b724887e005c5190362245eec48ce117d0a94d6fa6db12eda4ba8dde608fbbd0051f54dcf3bb057adfb2493 +a32a690dc95c23ed9fb46443d9b7d4c2e27053a7fcc216d2b0020a8cf279729c46114d2cda5772fd60a97016a07d6c5a0a7eb085a18307d34194596f5b541cdf01b2ceb31d62d6b55515acfd2b9eec92b27d082fbc4dc59fc63b551eccdb8468 +a040f7f4be67eaf0a1d658a3175d65df21a7dbde99bfa893469b9b43b9d150fc2e333148b1cb88cfd0447d88fa1a501d126987e9fdccb2852ecf1ba907c2ca3d6f97b055e354a9789854a64ecc8c2e928382cf09dda9abde42bbdf92280cdd96 +864baff97fa60164f91f334e0c9be00a152a416556b462f96d7c43b59fe1ebaff42f0471d0bf264976f8aa6431176eb905bd875024cf4f76c13a70bede51dc3e47e10b9d5652d30d2663b3af3f08d5d11b9709a0321aba371d2ef13174dcfcaf +95a46f32c994133ecc22db49bad2c36a281d6b574c83cfee6680b8c8100466ca034b815cfaedfbf54f4e75188e661df901abd089524e1e0eb0bf48d48caa9dd97482d2e8c1253e7e8ac250a32fd066d5b5cb08a8641bdd64ecfa48289dca83a3 +a2cce2be4d12144138cb91066e0cd0542c80b478bf467867ebef9ddaf3bd64e918294043500bf5a9f45ee089a8d6ace917108d9ce9e4f41e7e860cbce19ac52e791db3b6dde1c4b0367377b581f999f340e1d6814d724edc94cb07f9c4730774 +b145f203eee1ac0a1a1731113ffa7a8b0b694ef2312dabc4d431660f5e0645ef5838e3e624cfe1228cfa248d48b5760501f93e6ab13d3159fc241427116c4b90359599a4cb0a86d0bb9190aa7fabff482c812db966fd2ce0a1b48cb8ac8b3bca +adabe5d215c608696e03861cbd5f7401869c756b3a5aadc55f41745ad9478145d44393fec8bb6dfc4ad9236dc62b9ada0f7ca57fe2bae1b71565dbf9536d33a68b8e2090b233422313cc96afc7f1f7e0907dc7787806671541d6de8ce47c4cd0 +ae7845fa6b06db53201c1080e01e629781817f421f28956589c6df3091ec33754f8a4bd4647a6bb1c141ac22731e3c1014865d13f3ed538dcb0f7b7576435133d9d03be655f8fbb4c9f7d83e06d1210aedd45128c2b0c9bab45a9ddde1c862a5 +9159eaa826a24adfa7adf6e8d2832120ebb6eccbeb3d0459ffdc338548813a2d239d22b26451fda98cc0c204d8e1ac69150b5498e0be3045300e789bcb4e210d5cd431da4bdd915a21f407ea296c20c96608ded0b70d07188e96e6c1a7b9b86b +a9fc6281e2d54b46458ef564ffaed6944bff71e389d0acc11fa35d3fcd8e10c1066e0dde5b9b6516f691bb478e81c6b20865281104dcb640e29dc116daae2e884f1fe6730d639dbe0e19a532be4fb337bf52ae8408446deb393d224eee7cfa50 +84291a42f991bfb36358eedead3699d9176a38f6f63757742fdbb7f631f2c70178b1aedef4912fed7b6cf27e88ddc7eb0e2a6aa4b999f3eb4b662b93f386c8d78e9ac9929e21f4c5e63b12991fcde93aa64a735b75b535e730ff8dd2abb16e04 +a1b7fcacae181495d91765dfddf26581e8e39421579c9cbd0dd27a40ea4c54af3444a36bf85a11dda2114246eaddbdd619397424bb1eb41b5a15004b902a590ede5742cd850cf312555be24d2df8becf48f5afba5a8cd087cb7be0a521728386 +92feaaf540dbd84719a4889a87cdd125b7e995a6782911931fef26da9afcfbe6f86aaf5328fe1f77631491ce6239c5470f44c7791506c6ef1626803a5794e76d2be0af92f7052c29ac6264b7b9b51f267ad820afc6f881460521428496c6a5f1 +a525c925bfae1b89320a5054acc1fa11820f73d0cf28d273092b305467b2831fab53b6daf75fb926f332782d50e2522a19edcd85be5eb72f1497193c952d8cd0bcc5d43b39363b206eae4cb1e61668bde28a3fb2fc1e0d3d113f6dfadb799717 +98752bb6f5a44213f40eda6aa4ff124057c1b13b6529ab42fe575b9afa66e59b9c0ed563fb20dff62130c436c3e905ee17dd8433ba02c445b1d67182ab6504a90bbe12c26a754bbf734665c622f76c62fe2e11dd43ce04fd2b91a8463679058b +a9aa9a84729f7c44219ff9e00e651e50ddea3735ef2a73fdf8ed8cd271961d8ed7af5cd724b713a89a097a3fe65a3c0202f69458a8b4c157c62a85668b12fc0d3957774bc9b35f86c184dd03bfefd5c325da717d74192cc9751c2073fe9d170e +b221c1fd335a4362eff504cd95145f122bf93ea02ae162a3fb39c75583fc13a932d26050e164da97cff3e91f9a7f6ff80302c19dd1916f24acf6b93b62f36e9665a8785413b0c7d930c7f1668549910f849bca319b00e59dd01e5dec8d2edacc +a71e2b1e0b16d754b848f05eda90f67bedab37709550171551050c94efba0bfc282f72aeaaa1f0330041461f5e6aa4d11537237e955e1609a469d38ed17f5c2a35a1752f546db89bfeff9eab78ec944266f1cb94c1db3334ab48df716ce408ef +b990ae72768779ba0b2e66df4dd29b3dbd00f901c23b2b4a53419226ef9232acedeb498b0d0687c463e3f1eead58b20b09efcefa566fbfdfe1c6e48d32367936142d0a734143e5e63cdf86be7457723535b787a9cfcfa32fe1d61ad5a2617220 +8d27e7fbff77d5b9b9bbc864d5231fecf817238a6433db668d5a62a2c1ee1e5694fdd90c3293c06cc0cb15f7cbeab44d0d42be632cb9ff41fc3f6628b4b62897797d7b56126d65b694dcf3e298e3561ac8813fbd7296593ced33850426df42db +a92039a08b5502d5b211a7744099c9f93fa8c90cedcb1d05e92f01886219dd464eb5fb0337496ad96ed09c987da4e5f019035c5b01cc09b2a18b8a8dd419bc5895388a07e26958f6bd26751929c25f89b8eb4a299d822e2d26fec9ef350e0d3c +92dcc5a1c8c3e1b28b1524e3dd6dbecd63017c9201da9dbe077f1b82adc08c50169f56fc7b5a3b28ec6b89254de3e2fd12838a761053437883c3e01ba616670cea843754548ef84bcc397de2369adcca2ab54cd73c55dc68d87aec3fc2fe4f10 +97f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb +ad3eb50121139aa34db1d545093ac9374ab7bca2c0f3bf28e27c8dcd8fc7cb42d25926fc0c97b336e9f0fb35e5a04c81 +8029c8ce0d2dce761a7f29c2df2290850c85bdfaec2955626d7acc8864aeb01fe16c9e156863dc63b6c22553910e27c1 +b1386c995d3101d10639e49b9e5d39b9a280dcf0f135c2e6c6928bb3ab8309a9da7178f33925768c324f11c3762cfdd5 +9596d929610e6d2ed3502b1bb0f1ea010f6b6605c95d4859f5e53e09fa68dc71dfd5874905447b5ec6cd156a76d6b6e8 +851e3c3d4b5b7cdbba25d72abf9812cf3d7c5a9dbdec42b6635e2add706cbeea18f985afe5247459f6c908620322f434 +b10f4cf8ec6e02491bbe6d9084d88c16306fdaf399fef3cd1453f58a4f7633f80dc60b100f9236c3103eaf727468374f +ade11ec630127e04d17e70db0237d55f2ff2a2094881a483797e8cddb98b622245e1f608e5dcd1172b9870e733b4a32f +af58c8a2f58f904ce20db81005331bf2d251e227e7d1bef575d691bdca842e6233eb2e26c2e116a61a78594772b38d25 +b3c1313c31ec82da5a7a09e9cf6656ca598c243345fe8d4828e520ade91787ffb8b9867db789b34ad67cef47b26ff86d +a8ed8a235355948e0b04be080b7b3e145293accefb4704d1da9050796b2f6870516c1ebf77ae6a65359edcfd016c0f36 +80e792d5ba24b8058f6d7291a2ec5cb68aab1e16e96d793128e86815631baf42c56b6205c19e25ce9727bd1fd6f9defb +816288c5d726b094e3fdf95cb8882f442c4d9d1101b92c7938a7dfd49bc50636d73ea1b05f75eb731c908c8fd8dee717 +ae009128d128ba2e1519bfa7a0c01ed494a7d461c3aba60f8a301701fed61fe4e31d6c79ce189542ae51df91e73ce1b3 +96a866d60a9007d05825c332476a83e869e15b11d7257172a67690ea9bd3efea44bf9c8d42191454eb04fcf110b16396 +8b250a2a06419adb9b611e89f7f8f2990aa301949b533ad3bf17c4a61ab5f5be0b1d5e2b571864d13f1bb75805c7795d +8450f49facf2e620fa45ee90e1801178842d927a2a25fc6ed7ba99a4eec7ae40eebfee41028eaa84f107f4a777694976 +91049080cf659c0985a22d1366e59191bb89663f922e8168b9b7d85c8a73d74a6d9dceefd855d3d858b493670c750581 +a1e167aeb2008087f3195926f1985c0a459d6ec57237255b1473a96de4e2c1cf766127c862c7dc853a6909e67cb06cf7 +b667c0d4e26e20698b07567358625d5f003839c92de8088e12dbd74a6f6a3156b4ea8d252c9ad62af5f6c4fec1cf6cc7 +8e4b5e304c0b1b161ae3e4b68b5e3ac66c42acd7c1ee2458044f6527c508a93995e50894d72d57c1350f91afe72775ff +8c642640aa7915421cdc21fd639f88a42052b1cfa358ff7702e60793a92b7b5926dae15a0c8f8f59cd3013f01c159ba3 +a356f35e713cfc283056bf539de54a21731e61efb4c47319f20de4a4b723d76a33b65f4a67d298b9ec5c2a1579418657 +93ce204146ce95f484dc79c27919a16c9e3fc14a9111c6c63d44491158d5838117d20851cc3227a5e8ba6ccf79e77f39 +b585664cbb9a84b52f89114e1cf0cf1171bea78a136dc1404ac88a11210b2debc3b7a55e702da93ff629095c134a295e +b6dfd444ec7fdceb14c6328f26ca12c3f9fc4327d8d8c68948e92e7e61262b82d833a65a9e3af6353ffa832b6da25705 +b4d4b8eb9ecfffe3f0d48fb4149c7b31aec1da7041ec03bd0750c52a2a7cbc3a7cfbf09d5bfdc56e3860826a62d0bb91 +a4e248e3d61db52da9683fef188579c470d65e2df9064726847b1599fc774049ffdc6ef2ae578d5ed7874f1298ecdf69 +a68a0fffc2e37d3183feb01b42234c0f4e510f9dc29d09c571e6da00fecad9da224cd0f31550070148667e226c4ca413 +86adda2ffecb77236c18005051f31f9657a0d50fef2a1175dfda32e74d5d53df825c10f289eb0ad39df0c64fc9bc7729 +998266d5c9c3764ed97d66fa9ed176af043999652bae19f0657c8328629d30af453230e3681c5a38e2f01e389ed8d825 +a05261554d3c620af0c914cf27ab98f5d3593c33ab313c198e0c40d6c72022eb5943778cd4f73e9fe8383392a7004976 +ad243fb3631bf90fedb9d679fd71fc0cf06bda028591ded2bd4c634ea7b3c2bd22eca2ab318fcdaa6c2cda1e63e1c57b +89b9859a04f903c95e97fb2951f01cc6418a2505eee0b5bc7266b4d33e01b69b9fe7dc56fa9ebb5856095be0925a422d +a68d118343a5bbfbbab95ff9bfe53aeb7fdbaf16db983e6f4456366df2aa01fbdb6ee9901cb102fc7d2bd099be2f1f3e +b49301f25d5a9dd2ec60ddb0b4b477291958487efea9e54dc0e4ef388f03b8bbadd13259d191f7a0b7513876767d8282 +8b93df7fb4513f67749905fd43db78f7026589b704ebb9ea3255d0ad6415437799f40f02e07efccda1e6fd5e8cd0a721 +ad88769ace96455da37c3c9019a9f523c694643be3f6b37b1e9dcc5053d1fe8e463abebdb1b3ef2f2fb801528a01c47c +80f0eb5dcbfaaf421bf59a8b9bd5245c4823c94510093e23e0b0534647fb5525a25ea3aeea0a927a1ee20c057f2c9234 +b10ad82ea6a5aeabe345d00eb17910d6942b6862f7f3773c7d321194e67c9cced0b3310425662606634dcd7f8b976c04 +82f6fd91f87822f6cc977808eeac77889f4a32fb0d618e784b2331263d0ffa820b3f70b069d32e0319c9e033ab75d3b4 +9436d3dc6b5e25b1f695f8c6c1c553dab312ccace4dac3afddc141d3506467cd50cb04a49ea96ea7f5a8a7b0fc65ef37 +8e0a9491651d52be8ebf4315fbbb410272f9a74b965d33b79ff1b9e1be3be59e43d9566773560e43280549c348e48f01 +8809137e5d3a22400d6e645a9bd84e21c492371736c7e62c51cef50fee3aa7f2405724367a83fd051ff702d971167f67 +b536a24f31a346de7f9863fc351fa602158404d2f94747eebe43abf1f21bf8f95a64146c02a4bec27b503f546789a388 +b5cdf5a04fc12a0e0ef7545830061dff7fd8abea46e48fbe6235109e6c36ee6bffcb9529e2f3d0d701cf58bbfb6a4197 +ab15377525753467d042b7931f66f862cbbb77464212c9aa72d4e5c04375ef55f619b3a446091c1ba1a3b5d9f05e538f +905a75b943ad017ff78ea6ddd1d28a45c7273ee1c2e5e3353685813793ead3370c09cabd903fcab9d8b1c6961372d486 +8147df4324faddc02fb0896367a7647b719b6499a361aecfdd3a34296fa6768ad31c34f9e873fd1e683386c44651883e +ac91d08570dd91f89d2e01dca67cdc83b640e20f073ea9f0734759c92182bb66c5d645f15ebd91ed705b66486ed2088d +ac6295ef2513bbea7ef4cdcf37d280300c34e63c4b9704663d55891a61bf5c91b04cc1d202a3a0a7c4520c30edc277c7 +b604be776a012095c0d4ebc77797dd8dec62a54c0559fb2185d7bac6b50d4e5fd471ac2d7f4523206d5d8178eabd9a87 +80ead68def272ce3f57951145e71ed6dc26da98e5825ef439af577c0c5de766d4e39207f205d5d21db903d89f37bbb02 +9950b4a830388c897158c7fe3921e2fe24beedc7c84e2024e8b92b9775f8f99593b54a86b8870ec5087734295ba06032 +b89ba714adabf94e658a7d14ac8fc197376a416841c2a80e1a6dde4f438d5f747d1fb90b39e8ea435c59d6ecda13dea1 +b0c78e7cc60bd05be46d48fbb0421a678c7f14b8d93730deb66fbe1647613b2c62b5075126d917047820c57fc3509cb9 +a860c4acc5444e9ae987e8c93cb9a5f17d954d63c060cc616f724e26bc73d2c54cd36e0492d1fde173847278e55942ba +8fb8269c9d5c15428e8d45da1251e4c4a4b600d47da0caea29fef246854d8fb6acae86a8e6440d0c429d8dd9c2dfee0c +96c5d8eb6fd5c525b348ee4335d200139e437e4be83690af0f35b7f336a7cda8c6d2958647988b84da9f2dd7bbb7710b +a7f62141c4346cc14e9823dc38ac7d587b0427022afc1498d12ee2c43f6ac3a82167057e670dd524b74137f8c3ceb56d +956aac50d06b46a3e94397f163f593f5010d366aa2d816c2205c7d0f47f90cf0f36c169e964f9bcf698d49182d47d91f +b812899bcdc0e70d79ca729cb01104bf60e1357b9085a10f64f3ba9865d57e9abd0a505a502d4de07afb46f4d266be2f +abce02c7e1372e25d40944dc9ece2904a8f59c8854c5f2875fe63ace8ce37d97881f4f9ab4f7bad070ec8e0daee58d3f +8fb13c515b2d6abb4e14ed753fad5cc36c3631dfe21a23d0f603aad719423dd5423157eefcbd9a9c6074e155b79eb38d +a9ef67304dc297ab5af778cf8afa849eeac27db4b6978963e97b95ef7a8d3264d0d07775f728c298a2b6daed2ecf5053 +a9b975520adb066e2ff2a4cde53284c23bc84261a22dc43b1634d99eff8e7892e46bb6e6da7319c9e72788aa9ea7a1ea +a6eaea4ab4206294474d9b956d9d3188d558a5633de2bd05df0d3bac03dbcbe4ed85406349c1d2e660b77c6da1f5bf8c +af4a19f77290dddee762e1e0d4bc9945aacea3f75756ae46cd3e58a8f74d1b5db73e4834687946b0f39191e32f2fed0c +aafa6523f58f1a4cabc924c86d842816d606afeea21fa4b2b8b9573425810fdcc41c98888318e868f9c05e2be12178a3 +8ef38fba0a3fa4ebe985239c8b759c22aaef0c57e6f39050a651c869487803b0d1e389c3d958fb5a7f37740f050ac69e +b07dfc9f85913c608ca7596a2e361f05e4853fad00e796fd492d247de6414892ce160f627669b1ba933b6ad726415d4e +94da679ad1d78b2bff5283c938f17b2a7d6e9cbcdf59d340e6dfb652951c7a9e852ac0590f99cfee9631b9410f6f00ea +98a907c9c021a5b034d3720197c160a82c4b7146cb73d48efeed99b9d0c6b831812cf80ac7e19e85a676a8cd3ead72de +adb746595466a12929019d0048cea33236b05c1229d2eba73b259a18a786f2bc3f05fc0598d8ce253cecb80bdf679aaf +a2fbac016996d68f9027a157b0a3f6a336144a798d6113adfcda3a5d05b62c31f108f112aa915906aef22b7f83b9228b +81841dea1904406d1b6fa49b4b3f7f6cb40b7646cf44d36c9fa07e3dee29f8e47324b40d8356ddf653109673c3374e9b +a3edbb8aac5e60c775775cbdb19067341b2e2530de48738e84c2c07151241ee31f0d8333bf20c2bc9dcb7b2e638a6b5e +b8aa6890e22964828787ce86460d3a32f12a655bb5c28de500f2fcf6b61e3334640ec6ba96029a4912af0d18df4b4139 +8ca43169f04243ad0fdb0152de17c60d9e31ee0ab520970fccd98590e05508821a183b4b367967e60d53c2c826ec5dbd +b179fffd9df8c00486c5a8b9327d599f5a11745ef564f06e126849b06fe2f99273c81f65bc941efb0debaadfecbfec1c +acf068f1c2b1926279cc82750ce21b0d6b0bfd0406f0d8bbfa959bd83935932957c7f6b8de318315bf0b75f6ee41a0f2 +b97831da260919c856e9f71a41687f5979bc16f8a53b1037285b4a2f9ce93af5cfe70bf0ad484744827fb55c847b58eb +aff50b0bd907383b0c241727af364fe084d021221bfb1b09fb6c1a7752eeba45d662493d590f1f182764b90b25f17906 +aeeef044c14e3ad41e1235c9e816e1eb49087fd3abe877b89b3bade74459186126e160bb569bcd77779e701b19b5f71a +8483deb2b7001ca7c438fcdca8ca6aba96c9cbc4becfd9b16a6062705eae270011bcaedcae69bb54630d8c78129e57c7 +aeee8d24be4ac0d9784c029e239fb5e64316ce29b88f47394cfaaa8bb966a72061bff72f99d02dc51c9705854686e77f +90ae09525a16bb2422169e15d6831c87968a14ebc0d1d27e11a759839c73c655b9d33ee5b12f275d6f440688146fbd2f +a3a41fc7fefef101422465e506bea7f3ff23c26fe35f5732b86f5f2471fb93b37ebc339f84c6be1e8d22abc812c2e212 +86f4b5293e8aea4af1f1fb05dcf99714cb3aff1cfc849b1bb73524061c921c9da9ad92579a852e1889da29d952f02fe5 +8932ef39d4050a1e9dc0fd8afeaf159472d71c5c27f458c69d2730836606ea56e19c8c4febf2535f930d3260e9bc7637 +86307b9f3696bb21c20e4558e30310389e7367803c353d437e9b696039a0ff054d9a4953b75237ab1d1dd6f71118c189 +96e57730e683ef5b550c91de18b19ac73879f3e26234297db68d28747ed0953beb0f3913cfb720c602720bf9330685d8 +b04a19ee70123782e47b238abde55baf60ac0c66292a998af0d14afc8bbeb1134e557b94cd17a020084631c09a0d3c02 +829abc8718be8139569fcb2c398962f38f4201114d30e2b2fb23566f8a27a5c380f5605cec543415202a12ed859e33f6 +a0744fa488c8fa92a722c5fc4ef5a47dfe824eccd87d26c8bab9c174cbb151d44b1b29082c48652f03d3177e5ec86001 +81d4035ae9fd28bdcd78b135cb54955d3b685a527319df6ee7e904b8e6d796f5f5a5f5035ee1de750c4cb6050e452b9e +b205e8c2ec24d7104fa0106c09ad34b5a912c1adef553fb718838dd627355993c2ec01055c11d00b2c75b68e9516d44b +b12d09da7968fa7394e449624fc7174d1d76c069ccb03e140d4d87a2d3f6d1f7b9cfc930f0c80becc673406ebe63f08e +b23752c158695da85048fdf38b395681cc0e8998630af8a9ed41efbda08c9964c2dc8ae6e53377264be4467d702c0de4 +b0d84582fd73628d96b8c1ec96197697c41a963542451a2ade0890af0d33c7161d0f18e1a1ce2c168ca2dc1e9119d55e +8b877e618b469aa187632e410b125d2999d5738fd66d482000706b51fd904a0c7e7daa8c9b729fa33817bbc4154cba2a +b1cfc8a7551b601723b937d497d01dec3ee7614c2bf13d430b1058d5ebc1406045009ff02c2ac15bf8cf16f860193d1e +b6d9da84f97b21e13175bbb0b5cc8e79e88b470c87a3e115726c1bd98e0288526c58f3faaa8aa170ace0cd6a60852525 +ad2e773c2d527671ca5fab7085dde4da31cd35f45d4315dd95d8893ff5fb900494dca08eccfc1a2fc7bf7c7fd2fcab97 +8d5a79b34aeb761d4a0c73f09f02e9548e6d382c33ee6887a759ab05762b490b8a549ef2933c7e3a46415c154c0221c0 +b6f2cbe81bd0a7298403be392f8456bed30aed7ef30216959357698f789affd2942ae5fbaf3f48ecebeb7c273b20cb57 +b5b6c45d99cea7ce6a1dc134aff4a8f630f299b42bd59592a7592345f8cd35bcbee944e61b0723de732fcad6e4425b63 +8077d64dfcb2418974e956ea6dbf8a4c05b25d2a025333ad7e2a379f1976dc036771403383a51bfa3476c9c619ef8bef +ad2e0a9d479c77a5fb73b3613a177fdaad50dcb50fed50e756ba18164c153af30b07fb2565e80ff7469f1b0338b7b5de +81017d1d80a6b6df4e99d0d7f85a8180b5523e8fa2ea2672fddff604933f8a113cab27fce098dcb454d7d1f7ed266e04 +852355479d68e76c7febf6dfe2ef8e80d575c0d3bd52c983803592021cfa898c571c0b884412c21e66f0dbfe03167b53 +98e1bf8ad48421467c93b9f72b47dded7c41b4fcd36ea55ca43ab24b0d0b876f5a731f422579b7167c7138fad2121266 +803369314abd5422019ed4b0ef652b4dbe97ef5a87b0ea373eec9628b64a12120b2c3d4eb53db405131ff786d14c7ac6 +adf2613fc34f73e1160975c140e925ed84d254e03cc3bc7fc1d19957b499c9ba9d9e4c1639981b594a7095c0a52c6757 +a2f6a68efdff6e4173c00692abcfdfcdaf6f8b62369afad3dafaae4f2f38c4860780b4624d185e20e4f4498b75b5fe94 +8b1658aa0e119fb8401d486ed08d60240d26a8623ef9788e3b45ad09ae31259395b021bd16be395139cbb7149714e764 +a7dd8bf21121285e00672ee8bb84e0cb39b2496fb53a26e35dfbca7f2b04e9a9ff9db15f53fe63fcbeafeb2deeaf2ca4 +b6d8d709e44bc18f3b41d69608edce60c02bcba48d3b7e2fd420842657f0665a7343246dea149a25e8f3416284abae66 +aaf744ca5e9bcb63e3e2939b7a1e96e4a93c88c76bec0cf4294dd7db95cdd3f6a7d92196e352d08680e2328bc4592899 +84434b015a7c398d35f1ec71fce455d62ba4ed4f62da042ec31bb2b4db47073314354cd50bc322297a1cfe35138bf490 +8d70b3a3cd9d5dfefdacfa418c0b775a112a47ce538d33a560a519660009c3f141fd6221c18539129e9c0acdaceeeb80 +b8c6903412a800ec78a4c15f31c24385a267b0c0ece32fd31bbbb557fd70c3b2d60d8fc0f90fbd70f43baa1928ea30ba +8e391dd445ea06cabb433f057853f8159511b2f9bef41aed9ccd14e0a6fcd912bbaebd38fd5fb736cfde0fa34b7a4874 +a40cd988f70613df32babbd1bbc2f1b29ff1ab0147b01161555a81d56c9621657999bcdb1df38485f687afc51d5d0f23 +b6a008b4426b3d7b28ae04eee4698fc8ef6a35d89008ef5394da39ce582ce1a45dcfae9a33b90f6fa4237f3667803873 +8987280debfb175c3b44a2f152ea82548e4f680966f1fcbee9bf7d714e31bf8080c33f52705ef3aeee70544b22516aba +a78a51a2c11eea7680a5a0ae417a2981f8c69c396e06da621eadd7510a3664ade49d065617bec67b3de779548a4f4509 +a4d9163f0a1bc048385e94d5e0bcafeee1b18f28eb23505623b9e8ef16f3df76408254dfbe790e45f2884198060d388d +83dcae2568a0c518793c0f6e38b42f9ceb50673d100b556a17ec8bd9faeec84afe50b8d72422c6b2356959667bb8e2de +874731941be4474b4576226e5906b5dee89fc9b56a9870dcc7289c1a7d494d345ba6aba31f7546a16f9963283c05f744 +82c1cfab1f501189ac20147fc4631075dbf1abf9125b7d42fcb4f31cf73f3d6461b1bd08fdf6e45cc54bc08a7d5d51d1 +b978228286f5d4a10ce027b6bea3021affcaa805340ca4b5192c69e8c56db59f48e4a14a284ec015f53baf97389f62b2 +af125f4fdccd1c1b64fdffecb5ec7cf8c7392bbe476e1b89a5b5329c5ba4a526e58c11e72ab9de8a38d60af648d75adc +8411a41ec14295acab0d36389013535a80dfff6e024bffeb32fb3070762f61256419e8c51b2ad6de9dbe4f1e8e286912 +8ea67a91112a41f9c65515cd496f4b0cdefa1400fc06568eef000c9eae6dc250fb7622eb3f2deca10b37287cd96fa463 +8da99b6c55c31dee6a49aabb54da249d348a31d4416201a10c45a3b04b11e99d4ae9813632f0ee36c523b5cca62f6f49 +8b44656341e039e2bd83a19c3bb9a88f6209482e274f8cd4f8557b728e5948dd80b5745f621b96f4562928689314e8c2 +a02d424a615ba0dce8ed91f477e79852215a3a39d025059826fa278e7eebef19824b2a2844f5b3865a0f471b609a23f5 +a1f115cebc3fff3bcf233da27cef19eae791660f155d088003460f75567a550bef0722885010ddc384acdeac635939dc +b61a55ce9d143c17876776e064b58a10baf0ba13553c785c1e47f57b5f94c0cda8bc89d43d73386e57816c15b61a8ec8 +b4073f47041e20a8e548c7fb00e07ba3b9056c34eb4ab63bb0e7b48f8e338e8b56a17611a1b5f4c03b352450b86f1d69 +a7b1a07b213205b682fc5b6acb7e76fdf97b280c26621d8f3b76b7c1deb3511957da33a4e358c8e8f3d98b2a8855d67e +b797e67c2670fbd9844e8a68c585f404b035dc14bd4ec75c3f95f932c777f9db5d5f5df7629164af488fc1213035cc5f +99618200797b945f595794d6468e5c618649554ad9ba896330f1cc844090eb956ae9fc23132912f9047085c5f0c3bf7b +81194aa1319abf534cb3927af9adfb178a99d0e3e8c99ab1105f1d3b4fed40ec2971caf1d6647acb0c8d681eca53097b +80673f18e4978dbc226a6cd4b128a1259d9a7f833879c6e2fbe24d69fef2c3c23a51a4f3e8d88fa4533434bbb0723661 +8125bf6c7dbb2fb63aaa3f53283559f172c788223674adbeb6d5bd17cfe888e6b87a79aec774917f20ce911c1f85f8e7 +884bcdb1878b14fc38adc9fb8b4dd0b3afde404fbeb664f26ddfebc81736018551f23e75ce4cfe4865f610bcd454fbd7 +aec65c8d4be8316e98aa54888af01bc6703a0c5d04b69756ff39a0a947b66817ec59d76afe9f61a25749b5e890f03e02 +aa457aaa1b014a4c5a8992847a187a23321bb43452c98745987d038e3b04046102ae859b7a8e980eea978a39d76a88ef +a9832ee63b08e19123f719bfe2fe742125f32463efa966c7709a98ebfc65277670e9ea1fa2d2d78b96bdc7523b0c4c3e +a87b6b1b7858f96d55064274f29fbde56067064962cf3c3e2ba3110b22ea633bc037a74d23543ce3307a46208855d74f +897cbe4ab68a753020fec732dfcc052c7ed9905342b5a6fe0aa25c631f9ad9b659e0ee75d46f0df6507b6720675ee28c +97c3b5f0d54c1fc45e79445c3ff30458959e406a069f5bbf7979d684195b4fa0406b87c1c008f4075bc9e602ed863152 +921e65d582ea9322ddfad1c855331c3cac81f53c700b96db5305a643c084eb6793094e07944bfd41dc02c3b3cf671530 +8f23ef1aca02a260a3b65d25b110f28d3bafca44727448c8f2d03c5e77eda620c1721b06681bd816ee6027664d76352a +946a89b132ec0795aea9ff9dde7b77e7feafffe6e4a2f093042a7e6c71cd6ab87ce0ca914a1b5fabad4e1f96a795f163 +a01e2de9db33df6511172123ad6f7c64074237471df646b32dd9aff8c15278e2723108e4facaedca97e9f49503f8c792 +99dcdcde45b2ea3f15279936feede5f7d3b63ca4972f335b0559c2fa6f9faabd8127aa892a36deb114357ca906553ed8 +a3f8af37bfcf66b04d1896a4bd5d343f4733d4c3305369ac7e75a08f20f2004c10c642d2c7577f4e5c4d1f2cd851ac3b +b7294d15a3d674a56099f97a1adc9e82c15e90832eaf1722df110fc2abc8634c51515e5ad8522015498a3753b1fa8c49 +b4f27f5062ba7a04ea0048b3025b5e3d5b5d319a9e80310c808a5fb4e8e77b38c10a0f3172cb805cadbcc8bc66d36ec7 +aefe5decee0ae2dc372cc6cf4217daf97c4c908d145f100f0daf1ccdfdf641c78432c2e473e7e4b77dcdf2d4c2bb05f0 +acc84af7648a535ffd218c0cc95c8f7b092418c548815f1bafc286b1fe14f6ccb51b2044db3bff864d0bb70e88604084 +84d8e3dac0df6a22beb03742e1d4af684f139f07e2ea0f7fb27fc2d7d4f1e89b5e89f71af32ff115ed5e6092133535f0 +8ada001e1a03a823c4c056f636e77adc0f9dc08689d28de0d99e0feecab5db13abf37b41ec268dbdb42c75419a046c68 +87dac6c798d1744dff81d8bc3e0e04f3c9bf260e811685ddb9a9a8d6eda73927439b344f9a818d2103fad633de5a4a17 +ad9929a7d8a7d5d5954e48281a87e5c84f67e19110d73296b9989a09c76767a57a8115629239ffb4d99dfdf9c52ef6d9 +81ac7cbeef8ec35a5c3b61cc887080c29e6cd3e08af37e45830d17400dbacfb374dd07bf370b979828c3875b2027d5c6 +97f92c9182953b7e10f7a1bbb6b5b5c40b8275eb5a6eec1e29874c4712814749aa8c409651380216e1ff01d7b8511041 +a09794d0bbe7db013045d3fd857c1544fe6231d21afa3495fa300371f6301a3a0f4b8ea175b281503dd06078ff371ae4 +839bb58d320aa08116dd387a57a2b9bd9efc89c4cdfd82d0e47a00cabe644631d09be5436bd485df3b61b75ddf81a3ef +b1cdaa344f783757e8b9c1f84421da3c5be4c69f019a8fd4c1aa5bf1a63e8970c99e35c22cf3b48a0e6738bc6ba7ce8d +92af68e3216c78998208fb24b5ba0e645d0d3f5e28222b805668d7e9cdd6c033d3b22fd6df4c2d745d7f910d133cd226 +87640a4ea4e605e2204e5232b29a6c1c31152d83547eef14122cb76a0da52b8653801af48455a3ed713b9dcfee7b1ef1 +8147e5bf0c8f4731155ca0517ef3fae5a32b4d5d2d98ed0007b23893d8dbb7f8a1199c50c1750c2fa7c9cebe594b1bb0 +a76b4473c63c3ab6103c729afd2482822e4150f3155af39983b0ff0766c71cb622455ce6304e23853661eaa322219d18 +b3e2f05ca551bc3adec0067e4034aaffd72e0b64ac18ae25452c996927976c6727966e26d213b032521889be2170800d +a8414cd14cb3be658e9e0004ce511ef7063439b1cbc3166a11de030613fde4b59caad4e91d426927863c55382afbf476 +b2f0f8ab99f4d0ea785ac84fdbc00b20217b1df59b30b51d9d209d489d53b69dd5d82cdacc16fd1dd15c3a4001595f50 +8b2025d5fd658c9bbed619f3e3f6ac8efe7aeff8aa9401bd66a7ceb0062c44b353608ca073f95be99204f0a913bb77eb +94a46bc5a87291b42024b2137e623c70115b9c6b196604106bfbfa20f3f56ac7779763f56b580190d3cb2f1c648cada1 +aca9355545118d0769cacf69c4b23d6d68d229cd8f68f1bc0c847c05569c5af6bbbd8c4dceb637b4a6b3b5c83841bf5e +b0731992cab87c7116406b283a84707a34838bfa3284b0f6082dfabeaf41c5ac2b0ddc1b420547a1b0955aee92de2dc0 +b671f77588c0f69f6830a5b28e7d07ed161b81fa9791bb3a24aae6638e3aa5e186df74978a82549c370c18ebee04d4f0 +b5621ed841780f3e6681d880a76cf519cdd20d35197b112eeaa686764d57b5dfa78ffe1a294b6bc76b6e3949cd2a2369 +afeba2524659d00caecf089645611553187a6ed7102050f6dd20f5a19bed08ac7065912d88371ee06242897d58d652a4 +b78bfb83d44ced14a20135804aba3f00128c3ce1f302e95567ce4097b0d973414153fb305b9f156882a5a0554bf25973 +98510aede95d26b1adf214053eae051ffaf24894e2fa37961a91d0ff5392dd09388196648d95b73e90bd88f2587cc4bf +b35c682d49c295946b9f120fbc47b95abd9ee86d294abb003a92139fb825b509209562575015856a270eb3eea86397a7 +b9641bf685571dd9c478dd2033a1f1b11cd3a662b26502c78595863b8e536a189674a9a85f7a253453ebfd1b99fbd841 +b2ad37036a59b1c9b8457972665720a6868422ed8157b6810a9c0783006103be34ab732d7aeb8629653edd18fd0f1717 +af0920cff05179a3896ea6ea322c39adf91ada5bc40fe3f6fb1b1b4e121e907c904bbaa8ca00468b3749f3da144d71f3 +8e269672818ef1e2f9e0c8aa65c84442fcd9151d74bb8e870cee8c0e3fe24526e1a5388b430cef47b67f79b4e4056bcc +aa29a16fe00ea3d143b1032b1dd26b8ce638f37f95c085c7e777e8e2784bd724bd5c38b1583c61a6ec7c451dd78fd3fb +87452b7435911cc5f513b0c81b15aa04972ecbe3d7bbd0a5d676c96a8a311301c0e07fac925c53a350b46fbd3d4d0fc1 +869a81c351096f47748e41566ae7b77a454b1cdfaa41d34a5742f80df38fbf5cbb08924b6fdff58e3b18f05c62bbbbb1 +8b7bc1b0486300981147a40a449ada9a41afc06d735cce8bf0fab3ee94ba2e2ea57b1397e3cd31bc295352beb8334ef7 +93e93fc41adb2df279d95654921b4c2edf0d293dab58d0afefb221f777349ef88d0985b3447e3b935954a81f1580a92c +970fa7cdca8324faf3e62348bb50d78f580b4f43f2e1c11bd8382d48d0074a3c55c6407203a0c9cb1c5f2163ba421ef4 +924983929e608d27e4a36d4ed919297869e3c64de51aca794d32d6e90aea546bf898d98ceca28a0b2187734821b78504 +8d395332529c703d943d68415d443332b5c1342ca9d9a59bfa8bd4ab63e93358c4b0dde6ce1f2e8ea9dc8f52ad7ebd95 +80200dda853e588256599e7f905add5d5ee7c74272780317694fbae39318ae9be05d5bcd7b20cf460069743f3d4ef240 +a287d51d6359c9ef7c7ac1b20e479ce7d0146dba5606397bd04b7a622cec642508d5b45d51b31de71f9763595b6ac88e +a320396c075175d6599225cf2e1de8c7cab549f6316c07feb0f6eaa21f06b2dd29ab14fbdf2af4543b4890ec0fd08a4d +b1e9fe230418d20368691058adcbbe30011bab3000422f0371015ff8bd09c60fb5fa85d18550d35b1c900977ca48f58b +9718fc26a51783b971744933f20490e9b5cd9162f86b84788c4c5217f5409e37b5a39d628b18e5b35a757acf67596321 +a0cf81fdb161f4f1b419c5e4caa36d4bdca2325f0cd25b119a30178016f171bd6fb88403e4e3aec026c4089f180d540e +8ab1e36bd04625ee794ef04c4dcb8e004d61aceb2b62438377f49ad95dcf025ba25eb799280004941e555bf7172af6fe +9257b9e3d14d37fc7efae49b0c68d36eaac546035f4a2654d566b3ce1b2c4564cbb03dc8ec66efceb768559a8a507a18 +945d1123b839637ab5154a1972c3c83a0ff34a3b1a3465de6ef0416b1950f649869a3ef88d7f1036648ee385265ce2df +81449639d708860fc0229c94f754f7262e8a3c7f67960ff12dfd15df95f57a9ffcee2013e81978b7703dd42bd5d0816f +a865481deaae5a690fd53892791e5fa729db283b75a525a11cdfee1ce17e8e7f0b449d25f20b3c1b43da128dbdf98a8b +98766812a65fcd25b853546e3bba618a3edc9fd61510e4f8ab60c038a7fa50d197abeec8776109df0f2119be9445ad00 +b1b8dd5379d903dc41d74e999b1ab693607a0d2905692f4fb96adf08f738e5d31f9d00df28ccb8b5856145ca552c3e3c +99d20be7b511bec78a8ed03c207aa4aa9097ba39d85e18f1b8d52f65431ab7e9a773c7b9ac3e8d8b25458bc91bd00703 +b1b7c3563fe8cb33c7d3e0b89d00bdd13e86452ff507c2e69db7b3af06f247f139155396e9b0278753310dc63940a10b +b3dc9c08451b1de7c9969b1e47574bffff50490f4a16c51e12390195d9e9c72f794790caf7b0a835d64e01fec995d3ac +aaaa4761a00022ede0809d7063d3532b7bfae90ff16f45e17a340ad4ebaa2fbac40728ccc5fbe36a67ab0e707566c5dc +8319a1903314eab01f5442d2aee6ae9c3f6edfda0d9a88b416d0f874d7d1d05d08bb482102f8ca70a4fa34836d0840c1 +932949a6e9edfec344932a74d4f81eec3667ece1e8b8ca840ce07ffd4b5d6d8f01657c764d64ac1b9190f876b136490e +904db1568128487e312fe629dd8bb920cecafd3bb9cad8b63e269ae0129f2f5c80cd82f0d81e7feca9835c3945a72d28 +a17280693d30dcd43c85de8f6b02d5f30cb9097274ad680cede1ef105c903615b4c40f3c6aaca478642de324972514e0 +8d5f76e093aee71d0cdeb017fdfcb13bd068039746de90690ce150a0bfdbe7ddc4d539df0f82c2d2890a40b191900594 +96fa1f2196a3883cdd73c66d28403cbbb58f6a939a3697ee0d308d8a076393cbb4be86255af986869230ee410c01bcfa +a8b74438dc5cabd70a91bf25601af915c4418d074327a9b01e0190c27d3922c89bb9b41e0b366e82e313edda8f21983d +ac9fdc1a9b2e3ff379eb2370979372e13c4177bf4574f1490fadf05a7073e6d61e703e2d8eed9ce984aba317d411e219 +a45a6c9b958169f2f8df70143e6ac3e2f6f969a4eed6fd9f1c620711bc2454739bb69f0094079464790c5429c0d8aedd +8901cbdd1009864386577842c1e3d37835fddf834064d9613b4559ea9aef3084204e1f863c4306f874141f4374f449ff +b6c582161691e3635536686825be9c4d7399d668a7675738417e0363e064dfd28acdbd8dbc9e34c1dab8a1990f1f0eba +89e89ddaf3cacc78428f3168549c161283ca8337345750667c98212717b21e7d994eae4e45bbddacc832a18df1d79276 +84be275627eed8e1a73c7af8a20cee1ef5cc568cfeea7ec323d7f91b44e9653e9aeed47c1896a8240b99dde545f0e1fa +a779a54ab4f40228f6e2539595fb8d509b70aab7c19e1928c1be69ec1dc19285c3898cf15e5f8b8bc725e13af177fe17 +92e2a49d2b9b36349d442283b17d46f8f9bf5932c34223015ce62d2f285e7363b2c12232be4a838b5b6cf08e694c094c +8b4e28c6f3f36caa2cfb82ba88066c830f8017bd35608b077143dff236f3181230166f5a5c02fa0e5272297331726aed +85fd77d46162ffac4b8adb25baff0eb0512a53a3d01638b3a376ea34702279ce21c8e7d8884308c03e00c9bcc1a9fd29 +aad5e46916ff1be29009b595d1d8fa160cc7aa01c7fbf3a68f445c87615790dcab1fcdbdceda533d182b6541f09f2f73 +948df7654726250dae393325addd3c0a20431c81f00470962190335ea4b6d9f7463d6f308cda46b92084c1f24390b1da +8f577474dea132676504376c5542b730b6604fe3d965eaa194659fd11c52233bd0b11ab62e198c0f442327ff1c00e501 +ae2f1001546db3e0c19700adad997cd9f765fe7a51a502cbcd9a2a07a3a5db79c8f603e05cf96d80b688cb6c9b6cd3ae +953b68e5d9561088dd20406ea7fb6894cba33868a38ace38fc30b5813140cb15dd6dd2171befae5b4df2e4a9658889d8 +86c52901655ff11419b084a04da8fc3596eae59d81d3461601c0baff59ba59e3d1dd0b7ce719e741a3e97c013e898579 +b9a72dd5eff73f9912a28b55de073568efb3eb0241a10b77a2bfd4f30c2aa4fbfe0c89eb345c9f07fb725660873cb515 +8e7353f5f2932e4ffd95811caf46c9bd1a53643c27eb41a4ebd211f230955cd71a8b27e17cfe8aa708d8514c0de67a66 +a096b8e66312a92fb10839ebe60189a8d1bd34dff55f7dfae85e4d2f53a1a4a88211c19fc84494f066358ddce82be131 +931c5cd82719d76596832b007969b5f75d65cffabb41b9dac7910300db677c1309abe77eeb9837a68c760bb72013b73a +8ba10f5118d778085122065b55dd1918fddb650cce7854d15a8f0da747da44d7b12d44fc29ad7dc38f174be803db74c6 +8c971deec679372a328587d91fd24ab91043e936ca709c333453d7afd43ee256d08c71cb89f0ab0e89ae119831df6d86 +a2ac28a58034fbd8fd518f409221bad0efec52670880f202e09c0530e2aabc2171ed95e99891790596ffad163d86c110 +b3354e3dfa8068aba4f3741152b9204baa4e342c1cc77e6dd1419cbaf8da1d118be605846b8609e997d6a62a11f3423a +a12ab65a213c9d95c24865fddc2dffe0cf9fc527dd6bcdacc1bd7271e79929a4ab3427a231f4f49d0530474e6cbc88f9 +90afd65b7e6973f8aafbe74da0f42441840d3c93bd69bc1bec8fa56824e7ca97ad1b427c8a85da7d588469bd4ccc50c3 +a09175940c59489bac3d3da3a4091270d9118948cbbdd57f2bcc63fbf45b8010651c801d3e58dccf42733ce1d6b446a3 +a843bbf286e3cecc1fe370ff1bcf5f1001bc2e95b34246625ff50d48ee62343e82fba2d25b8a4bd5f7b5ffe90920efa2 +a3c4d1003219157fdbee2707ce07afa6c2a64ae8e450182c307ed7f070024071f30b12c4b0032960ff913c74e73a9976 +b24af3f68d66f825d06fc3ff94fcccebe28b1a0d4ba29c48d3a3c953b9bf7ae6707f193fef25e2dcbd2b74e483c774f0 +b0f657f7723184ef7d7e4381143f1ac8020d8c6c6f2dcbebb0eaf9870d61a81f2d452596503311e46d1b38f625d4756b +b90091004fc8f6205c51bec68547ac82dba0f5525631e7632cf6efe54eecd9020729fbee6105d1b8012402d3b79c54aa +8e3fa187713c60eb0a416d6900a894cdf81e6b6b69dae0bb64f6287f3c3f030cfa85c665f7aace1eab4937f380b8f728 +879bf0784ccf6725c9cd1ea8c49fde31c91c605de1ea664a33c2ce24c277ee45d20b66309f98d989acb2ff3b77e13101 +af3f3a3ddc4e11abd627d5aef8adffa91c25df5f0c68b4d2b5d51e7d9af3395ba4f6f7ae2325a6672847e1ecc6cad628 +973e667289e796d3a40f072e6fea575a9b371a9997cf8961677f8dd934619ddc47c1a3efe91bae9ef95acb11a8fe6d09 +afa81c5606de82f46b93f4bb6db3fc0670f4e0d1091388b138a66b3827322d95a56168c951c30831d59eeadc227500bd +b83eff77db5b4c18574662942eb36f6261c59f655f8a9c3d3731412d0f257c8e80aacc995c4b2303058a1ba32522a434 +912e5ac9234b9445be8260393ff08e4859a7a385e800b74d1534eeb971f58f74cfb518dfdb89f8705d89fbf721439129 +ab27c8ece4a51d23e22c2e22efa43487c941139b37ea1182e96efb54ca4809d8245eae0ebe8ba94f0ed4457896fe11b1 +a6630585d104a745bc79dba266d9292bbdad346449c8ee8140a5e6e8a6194411df9cdbf3d3ef83468a536d4f052e9335 +8b8c128244da48e7fec641a882d0005a2d05c7138d86a293e6a0a97c76bf632b44767d0ce44663c975e7f9f9679e25e3 +87dbcaca67351a4e7d2297d7cdba4796d12f58857e7ee4abd0645563577ff33544a44cd84e50b3a3b420d6998de9b57c +b859ba43df259d7f8e7fac70bfd7aae546d57a5dc90e107b174a95bf7fd3cf00f740c4434848e69b2a7e6061f66c1ef1 +99d6e20978fefc40c6d310187eb2ad3a39296f189ee122ed64d74f81033c3069d44f7a9d3988a1df635b609603a17272 +99a5ddf3420cc0c92b21f71a805245608d4995ead447d8f73a670d26d33e26920d5f07bfe1f6230bd5f15978055b4253 +b936ac0944d3c5e4b494f48f158000abb37b80b5c763f77fe856398c664b0f1ddbcc0a9a2a672db9278f08b4bafbe2ec +b4af85fbf4040e35a686dd016adec037c99b47cc2e4dfccaf7870ee9e8c97bff30f3035992def2a9d4af323c0b3af8ae +a5ee32b8bd5f8fa9000da4da0bf00565659a43285393d37080b555d0166bde64d87317b2eab2d48a0e7b287caa989be2 +894d4ad58ecb1c9ebc4f5a97407082e56cb7358d7a881ba7da72321c5027498454f2c7fa2bd5f67a4b11d38c7f14344a +965be9eeaa0d450dacc1b1cc2fbf0d5d4b0dd188f2c89aaa9260e7307a2a1eb22db6092fccb662269e9a1abfc547cabb +805893c424aec206260c1c2d2509d2cb9e67ee528bd5179a8417a667aa216a3f318ed118b50d28da18e36c01f0805e3f +972d7040d4963b35260ef0cc37cd01746f1a2a87cedc0dc7b0ee7e838c9e4573784ea743f563b5267eb3905d4fa961ba +8c7156991d4c2e561888feaecf501f721b4174e7d14109e9deeac5a9d748301c07e11fb2b04b09799f0d34ff42cb77d1 +894722ac35af3d507e81d737d21e16c5ba04686f8f004aa75934aae5e17acd3e065b96e229eb011c2f34096f4c62048b +81237937c247c88e8e31e2c72412189fe59c1daf65c5513489d86cf29ee922c0bb08e5f7890f09f4ada7e5262083d266 +8cf62cda2fe0d9a6b42aa2a1c483f4ad26378c7cc2c2d1510a76df7560b07dba8528b33aaacb15f7f20b9d4c7c9f61f6 +aaf0921fb3e1920eee5d0acb59dcc268b42f4b435d60d25d30357edd7dd758d035919691bd15311d85489dfa2e5ee696 +92cec07be2247ef42002ebcaf65ec855611b8e893a5675796f2225f55412201b0bf9f4761924d0c8377b9f131e09e39f +8e514a62ac1e91773d99588415426c97ad63e917c10d762fe06ace5277a5c3bf3730e4b9e5d116f8493b9ab8687b70e3 +83932df2d923a5052468a3ea87f7b55c6a80ede3594046ee4fe233046570921822bc16555b92ba6aeabaef9b1dc0805a +a2b5bfb249de3472113fd3f35bfabf3c21d5609da62a27ea6aab5f309c9068d94bc58ba03efb4ec11be06306d59e60e8 +8106cf3ebe6f0507be8c6e8d137987315fe3689ecb75bb27980f36ba5efac504baccea0e7603549b6d126beccc278804 +a73ee70b6fe8c082443972102c453fc0e386852476cf22224fc0bfe554735c12f96037fbf10922795f4502c4f052b5f4 +932b27e175440169958504f3ed6400e7d6dcd5e716c19dcd0f15c56c04503ed133d5a993e111c016f141e32d68b29886 +96f7ce4595318e0b4a6b368f788ff82226aac676aed4ace343867f751de414453a9aaaabef6e6224ce5aedc3d5cf77c4 +a950c1e3bc9a14484997013d44d876374b939af437ae7c821c131fb886063ee9fe7214a25a0c7084f0b07b99412eff75 +a9dba3886ed6855303106a1bdd26010f294218684e1c178afcfea3f37a2f04fd01724a31d82de3449046617e3507a115 +87a2f776b32a6b550cf3ceeaf78db02819be74968d228b1d14e0d74a1cdf994bb500b7abef6619455e98d728701fac5c +8cd887b07e335edc0b27e6a660cebb64d210741395be431d79d570139687b056557159407459799a8197b6079644f666 +b81a61fce00588909c13a90c1caa150f15788786af443ff60ce654b57147601f7e70b95659e01f470334a220b547611b +8aebc51141544c5f3d3b99422250424b9800031a8fdfbf22c430907a3a446fecaa2392105d66d64b1c8e847240da4a6a +90db7dc12baa02f3f86d3edadf9434e2b9318d4f6f0eca08276b765dbb38d8eb0d08be2fe70adf2bf16ceda5db08d3ca +aa1839894152d548cc6ad963de20fb6fcc843bc9af2a2bf967c63626b8ad19e900894d6106265f38f3afccca317c22f0 +848e27b741496988a582515c0c8847b2bfc6a001259396cdeea1e1b1d2828ca3a626693a1bf4adf3a3d7f8b1fa3d75fe +a0aa11754d4ee136ac3ca609b17bcae77758763b2016544ca7921dddedd8aafcc7ad5f2b337c8bf53084eb8e43ea41fb +b8713b7aa1c112178195fdcc9b7024f46e6bc04c4e76c41abe620aa265287809200d98eaed6c9703fa97e81d6964f0ec +8605b5b33309e9ea6823542b85383c496794b8481c577497aaf99ba90496e794dce405be615bf92c7b6361460e6b82e3 +826fa34faa7f83e063a7bf172addfc07badabada59cfc6604fdf481d29085251c0a67a1355b2cbd374e2975934b84cb6 +b45d131082dc16fa53af010d43eefb79200dc23d2f3ee26af95ac6a5cebc49c84a9ed293e534ed16ff3ef9a4a25456ec +91bd6ce3c5396a7a0de489e49f0cdf6dce1cd2d0be7a410326423c3185bd1125ce1e610768be7f15f4e44b62f8834fc3 +903ffbe3d33fbf106c01c727dc3a385201a67ded70d4df623934882f69a3a96c909b027a124f3d70cb072b0046a149e8 +b405359db9d9ef4821a181b440ef2918c240595141d861d19a85867a5afa74d2972d22c988775eab441e734700bae4a3 +8abb756d027233c83751910a832b0ef4d28d100077f1c5d656720c94906f91d85dd0ea94b1cc0ed95b692efee14c786e +a78ee77ab476a41a3454160ba7ca4085d8b1f7057c63e76db8b07cf20afdeddd2250cd00771a6329133bb4ad48ccc20a +a41810271d8c37197aa9b3dfcefe3498e42f5978d3f3d59defff4676d6402d8575b40683834f184f143b6cfbfc859b3a +90c24a0750242660bcc6d487358a3cc015730538a0a8beb00ad5ac2ef33cb8ca8a62121e50bec8f3d2f43900f8e3134a +8b96c39695d864ef5796941754978a1fd612b369f6b77fe5ae6587beac936ee28190af8f0a3822b63060af35e49a5c8b +acde2548883d0e63c0fc257bb9dadd919aba60a985b69ebcfa1bca78acca42fc1322ec30bcc8e7c188818f858d04ad33 +895c86ae9ff8d95f2707d4838a3bc8ddb05b2611f0476f014b9c150d0e8332bc73285037a747426f09ac8179ba4e19fc +821761fe406e18bd86fa9ca9db99d382cd3b5c70c456f471fa3706d57763d147706304c75d54f51ce8f3115aa26e59d9 +a803a80e3e8f47dc3c59ea23eafdec017458eac648b360cd42cbd075e0dde6f6f450b48c7646fb1e178c04f82ae51a12 +91f40e1b6f588bd592829ce937996452c40be0fd6c43793c607866701ac6a8c7227e0891d45c6e7b1599382b0a3fbdbb +9408246d996a634a58689337f2526dfb3ba9ffef1d3ff91c32aa8cbbed900861ef25d6477308b67d76491edfcc70d65e +a492325a427f3df1c9c690c5b553daa8ac41f62f5ae55f425539222bacf959e2f67afabbba1732e120d3e7a6dcdf7049 +8fd0c3e15477cae228613a171b6e9ec29ddc63ef74854d99b638adeffe39f89f34346a42851e8445e855a9f2bbef0f57 +b735ed01fafa051004dbaad5e8c9e2faca8f6049ef9b590f256ea4d75b04594af12764ad4e6031735eae36f83179db93 +a7d35f43fca06c86b3425dcb68a87186834ba9740664fd657915771beca4cdc0fa2fc9b4c2e9d9bdad8ec33543ddfa59 +a1156e71e2db1b17df5da28747c88e091bd687bfee59d89096437ab4dc9a543fe5c5272d5023d72adbaab397a6fc94d1 +ab06a58bd81b33a411bade8d8c5232d38fadc2e38507159edea6e2e104b8ebd65ca02b05335118f691d44197b847a4dd +848b67a10f1e6ff8f5c228f226ef2ffeb67fb8f50925fc94cbb588d61896d9dc79726959e649898fd3354fe3ff7b7ee3 +aa933397361f32b388edcf832f0db172a38e756b34d5f7a4a050fa7325058006c22cede26ee27917e8f1b0f301792bd7 +89e49e7f02cfaae4a4b9c4180c9f6559d76e3a45774955859d4147970b1470dac37bdc9aedca1c32a20b045049161590 +adc1825d5ab94fc719f25d8c9773f4d518134ed88eb13ac33cb910b2be3523ef9ef88d9e4aea2418b806e20108317bf6 +96c4b444c8a023da644f3a343ebeeed19a8392d2ce175992461451c318a54273b76c3574d8f2dceda2947ddd34d1a674 +8aa7e97e87c8c5b29bbd51a6d30396a6be1fb82b716ef83800f2c36d5b85467ade7e0f59d2db82c310fa92a9265f0b03 +9146c32d99f02c3a6f764dcd9b4807f1585f528ac69dc4f84e4380f6fda4f9d5057c375671d51e7aca2b2b4140e83da0 +a10760a533d9bc57536bcaf65f080302086aa50225437efd64e176841544711828c23a15c49c0dd1f357d3f10722ab72 +acb0811777e17f7ae7aaba5f6fce81b759c067a4908730916195a2505c7450d0e6e2194c2ef0f241090597d58e70de47 +b24f161e9bcdbad56665e2490b5e4c7768390d4668cd69a04ed74739062dbe832636dd33cda89e9b0afa8c77e93fc641 +96b4d01106b831868a88ef016500ef2fa42d0ce87a37ca8ca4194a92a22c113edfe04eb2ca037329f3c1acc635148f55 +aebbb95fb4f7adcc8e7a217aeb73f9e037cbb873d08c1cd9d68c6c6834511adf1af8b44567fee84327599bdcb734dedb +a9bd8b17300532fb94d028659bcafbe7bbdf32f8945baf5db4cfaa1bac09e57c94cad0ba046b4514044b8fe81ea8596d +a5557cbda599857c512533e7cadcf27bf8444daa0602aa7499cafc1cf1cf21f9d16429915db7485f0e9a1b5046cf01c5 +8810307c40bc661c478a9747ebf2a30e5a5ead942d1ac0418db36ba5db0709c476f7d19685cabe6959e33ec1f3bff914 +8829b741f41f2c32e10b252d9338deb486dba2f23996a44cf1dd888ad967a589d51329be34d764139f372a1043f6c2e5 +a6b4728d18857c5fa082fa67bfb3b1d801e76b251b1e211a19c87cea5fe7ce757f943c85071f7a03a718388cd5690e95 +86da7f397e2533cd487f962ae58e87bea2cd50af70ef2df9ea0f29f70b5843cde664d30ec207ab84fc817f3851277e02 +8085776ef4ac6d42ab85b9d9135ecc6380720efd274f966544eeedf4684028197de76ecab919fa5414302597e1962bca +b05a065c733033d223ba13d16baa7a97bd8c8b8b1f0e59a9bdd36ee17e9922d48eb39bd180c168b122088a77f0bf321a +a89343fe44a93023dcc7ef71bd3bcb6786f68e1885ad260edc56a52445d34757f476395ba7ad35437f89bc573c7618dc +a114a9cd6105b524f3969c69faa2e09afe21753a93361a296f9e0e3b4e3e63726ddf2e6bfd3ddc046043e50bd44e539e +8a5611fec539cf681c05636bb580f29acc06f628bb012649ffa41ea6c1521194a5643d5dd843f09b6eb2c3bdb4d41acd +ade247c4011ec73ec90b72f35afa59a999e64ba5a7e664a4b30874fea53ba6a14a76a41b58a5f891a20d019e5f091bdb +905b5d96df388160ade1ffe210d0c6d1979081bc3de3b8d93ac0d677cc2fc2dc1ef6dcd49d3947055514292a3fa2932e +a9520796ca9fccd11b7524d866507f731f0f88976f0de04286e68d7cf6dbd192d0d269f0cd60fd3d34011a9fe9e144c2 +989a1edf4d7dae811eb57a865c8e64297837ffeeaae6ee6ac3af0f1044f023f1ca552bf00f1642491f0f0f20e820632e +879c8e63713f4935ed6e020559e140ea3073ced79d3096c152c430141272117b4fd9a9fc3eef012e81262df02ea14bd7 +95074738ac1540c0312274333acd1ecad9c5509fee883c4d9295fa8d8200f6e637c363de395f9fa612f05c0dc58fae88 +a770e4fc595269eb806b113ab3187ea75c8f96b57bf9fcfaf535f3eedc1d4d7e6285a20990575de0ff09f62d06ed0692 +81283e5dfb6423439ff513eca1cc316941d196df8da2d1069d2d0b63f5289e630af2fd4119bc0144c002d33313372dab +abd1b108e743887b78f698f2aba9d5492f87a22868d1351d705d93a1084fd45be67170c68a6e18b07f400d9a01cda8c2 +8509c3f67b92908cea8144f4e2a71631a66a61ac3547601c788907e52e380e5fe8ae4110aed95d13c67d3bcdd5b55a61 +8fa5a790ec5cce6d4114128c295390120869aac5490a82feebd3c37a167120df2e7fdfaf2a4050a7dfebf48fb093212f +944753e1ea7d8bc727d46a7702077dc01dc0c6574e8263a16579b57ee155ca5901f71bb347a01a9a922b329d3ff75135 +b46bc1fd4590b7a6275e20036d247c5909fc549c78e95b64ae7ed96e3b05bb044840f19f7650ebfe7008ba09fa83c3c9 +b1e47e4d88e59a06c465348c6cc4181d40f45b91e5e883966d370c26622c328415c6144aa2f61ddb88ec752482c550ca +8bd4f8e293e3f1815c7e67167618fb3b0ea76424bc0985908957cfcede36109378e41b4d89555b8c2541b4c447e00461 +a70589a867b2bfb63d0106083d58475d506637148549ed35c83f14e5c8de996e1b1f3447ecc80cf5cd134ef4db9d2fb6 +8048b80ba6131d07370162724127b0f7cb17fa7f71855e55e5a75bd0a9e4fd71b0d0ea2d16ec98858e458528df8d06b5 +97326cb94bae7530f4ec3235770c5a7ba042759e789d91c31fedbd979e3c0e6a2c69e2af3c1979c6fe0094274dbd53ce +a18e9c1d3eabd62af4e31a4b8e08494f4167fd4598c95d0123f39c46c53f9e93f76615900246e81a286c782ac37c569f +80309c59d4522b15aba617cd3c6238663e8b1c7ad84456346082c8f281140fc0edf9caa19de411c7e7fb809ca4fa3f4d +8e450c0990e2f65923f252311623038899eeff7b5c2da85b3a224e0ef7132588b291b782d53c477ecb70f34501466178 +87843f96f41484e254e754c681a65681b9ae5c96c292140368743df9e60f7e2ada58ca2bb95fa39abe064b2ebf21eeba +858e8d5bf2a1cf26d8af5036b28b831d450a446026f58a1734b696c18f1f41482796b91cab0e5b443dd2f0b9cffa52b4 +99627dd6bad8c05c5904cd23aa667d664da846496dbbb8452705c4ec01e1480e9c7295504a5a8529e4a0c842306b038d +b64b33256c18b2c886a837a0c0730fdfe73befb0e2796207c4dc592c5a33cd51f8c2ef47c584dd5773abf9ce9c1b0082 +944f6da2a1546f0bfc4d98c3e73c79e935e33d208b6be26b0b5f8df6d0e3b74a5bda649853b99281bd3a3ec799a7dd04 +a266d165435784d4e884640155e35b2a911b3f89e1e715986de419b166a36a341ba724877d80583fa3da566f6a828971 +adff2698409d0756e78c534032ee926560c13d578cb178d5073172d049ebbce32a92692f7e2033ec781b9b0d894ddce0 +a91933f110756c699c28bf9e24fd405bf432002a28c4349e0ca995528e56a5a2d101b8d78afa90a178ff1a9bf2ba515c +8e77839c0eb4da2d01e4053912cd823eddffbdc6b9c42199fba707ca6ab49fc324288b57be959fbfb11d59085d49324a +aa124517c76692036c737e987f27c2660514e12a953e63ff4bcb269dd18fc44dae95e282de8444bed09639ef6577af88 +b285deae99688f1bd80f338772472fa2b35e68887c7eb52c4ef30fc733812444c5cd110050275ad999d5a9b57f782911 +8877b0fa85b44ef31f50bdb70b879fa6df5eb1940e2b304fd0c8f08abb65f3118fa3d97ff93919038c1e452fb1160334 +8a89f3b50dcbca655024542ca7d93df17deff5c7d01c7da2bdb69e76b3e0b4490d85c800fb3debb4b0b4d20c9527f7ad +b7e5dbe36e985354ac2f4ab7730fea01b850af00767a6c4d8ee72e884d0fe539bb81f2e34638fcf5d07b7c8d605f4c06 +a85a1d78f6d4f9d5d83ec0f2a426708342d4e4a5d15625554e8452f6a843d9aa4db0c7e68caebdaf767c5b3a6a6b2124 +a518078a9dac63c5bf511b21ed8e50d1ccede27ebfe9d240937be813f5ee56aef93dc3bf7c08606be1e6172f13f352ce +91144eedebda4d1ad801654ef4ecd46683489b177ba1de7259f7dd8242c8c1700e15938e06c5d29aa69f4660564209a0 +a16c4657bc29d1d3271f507847b5a4f6401cee4ad35583ad6b7a68e6c2b9b462d77b5dd359fd88ea91ce93bb99130173 +85b855778f4b506880a2833b8468871c700440a87112fa6a83fd3ddb7e294b3a232d045dc37dfc7100b36f910d93c2ae +8d86bb149d31bfbf1fabcae1b8183d19087fd601c3826a72a95d2f9cedb8bb0203d1136a754aa2dd61f84b7f515acfa9 +acfe7264eee24e14e9f95251cbcfdd7e7f7112955a1972058444df3c2d2a1070627baefada3574ebd39600f7f2ea7595 +906bd14ecca20ac4ae44bff77cc94eb5a4ecc61eba130de9838e066e8766ed3b58705f32c650e1e222b3100691b3806b +8f2cbc7b8593c4be941dd01b80dc406fe9dfdf813ef87df911763f644f6309d659ea9e3830ff9155e21b195fc3c01c57 +a68eb15ed78fae0060c6d20852db78f31bebb59d4ddc3c5bdd9a38dbe4efa99141b311473033ff8f8ea23af219bc8125 +a95cb76c9d23fc478c7e8a73161f2ff409c1e28a2624c7d5e026e3cee9e488f22225a0c5907264545a73e83260e3a4ec +b76f90e55fa37c9e2732fd6eba890dd9f1958c1a3e990bd0ce26055e22fe422d6f0bcc57a8a9890585717f0479180905 +b80cc95f365fabd9602ec370ca67aa4fb1219a46e44adf039d63c432e786835bb6b80756b38f80d0864ecb80e4acb453 +b753c86c82d98a5b04e89de8d005f513f5ea5ea5cf281a561d881ed9ad9d9a4be5febb6438e0dba3d377a7509d839df0 +a664733f3b902fac4d1a65ea0d479bb2b54a4f0e2140ed258570da2e5907746e2ac173ace9120d8de4a5e29657ae6e05 +9479722da1a53446e2559bb0e70c4e5bf3f86c0ce478eede6f686db23be97fcd496f00a9e174ceb89ab27f80621f9b80 +b707fd21b75a8d244d8d578f3302d1b32bb2d09f2bd5247dff638d8b8b678c87d4feab83fe275c5553720a059d403836 +93214c16831c6e1d6e5a1266f09f435bbed5030c3c4c96794b38d4a70871782002e558d960778e4465b1ff296ffedad8 +8648f84e18eb63dad624e5fa0e7a28af2ee6d47c28f191be0918c412bf24b5460c04bf2b7a127c472914a0741843f78b +b67f61e75d6b773a6b58b847d87084b94f3cdac3daa7bef75c2238903a84250355a986b158ff96ba276ca13a6035fdd6 +ae9b094b7b5359ee4239d0858d3755a51aba19fce8ad82b0936cca48017523319c3309409ea6e9883a41bece2077e4d8 +8d1d8e1fba8cebd7a0e1effea785a35e16b1a10842f43e2b161d75add11eccf8f942d2ae91c20eef6c1a0c813731ea9a +b82bd387458e3603782d5e2dec32ae03890a3fc156d7138d953f98eff4200de27c224f626e3648e80cd3dfc684c4790f +a6dd02a89ad1c84e25e91176c26355e21a01b126c1df4d22546159dab9d502dbc69bc0d793a017c1456516e4aa5fa53f +a9ab74a5c5459b8500beb0ad13e9cfe2656e966dc9b4f3f98bec7588023b4ddebf74e4fc722d30423f639f4ee1b2587f +b03e5f33ab7ecec12cbc547038d3fa4f7ea0437e571891c39660c38d148212d191be29e04eb2dc001b674219b7a15a9c +925df4fc6e898ca55090ad1a8f756cc5014167a042affda5b24896eeb6aac408545134920586a8e1a2b997de9758b78a +98c8580fb56ed329fad9665bdf5b1676934ddfb701a339cc52c2c051e006f8202e1b2b0f5de01127c2cacf3b84deb384 +afc3765d374c60fac209abd976fe2c6f03ce5cc5c392f664bb8fac01be6d5a6e6251ac5fb54cfcd73e3b2db6af587cbb +8e7e98fb5a0b5b50d1a64a411f216c6738baaca97e06d1eba1c561e5c52809b9dab1da9f378b5f7d56a01af077e4f8cf +b724bf90309651afb2c5babaa62dc6eac2b8a565701520fe0508cee937f4f7b6f483fc164b15d4be4e29414ce5d3c7d4 +9665160e7bf73c94f956ecb8ba8c46fe43ae55c354ce36da40ccc7594beae21d48d9c34d1af15228c42d062a84353a0c +8600ab3aa86b408ee6e477c55572573ed8cfb23689bbdadf9fccb00161b921ec66427d9988763a7009b823fa79f8a187 +b0d8d19fd1022e7bc628d456b9bd1a2584dce504eb0bf0802bdb1abd7a069abbeeccdb97ce688f3f84a229342dbc1c33 +8f447d5e5a65bb4b717d6939cbd06485b1d9870fe43d12f2da93ca3bb636133a96e49f46d2658b6c59f0436d4eede857 +b94e327d408d8553a54e263f6daa5f150f9067364ded7406dcb5c32db3c2dffd81d466ee65378db78d1c90bc20b08ab3 +b58c02781b74ef6f57f9d0714a96161d6bfa04aa758473fb4d67cc02094cd0c0f29d0527c37679a62b98771420cf638b +8cfa0a687ea51561713e928271c43324b938aa11bb90f7ffaa0e4a779b3e98899f2af59364ce67b73a46a88748c76efa +95d6d39c814c5362df69116558d81ce6f1c65fb400fc62de037f670d85f23f392c1451d43341c59bc342bc31842c8582 +af888b384c52d9e04e4db6c4e507c2037eb5857e9bcc33acf84fc3a02d93cbde8cce32141fce9f5fec715b5f24d56356 +a7822bbc3c236fd58bd978f0fc15fe0b60933a0c953db6436a233441219418090ae0c07c490a6548e319029771cdaba7 +8c53729f750922e5eb461774be8851a3f40fe42eed170881cc8024d590bf0a161d861f5c967144d15cdcdc3dc6b5cf88 +a052a25a4aeab0d5bb79bc92a6ae14b5ad07d1baca73f4f6684ccecfc7ea69bc21eadeb9510452fdba116c0502dd698f +923946b83d37f60555dbac99f141f5a232728c6eb819a37e568c8c6e4d9e97a4229fb75d1de7e9d81f3356f69e6d36f1 +8cab82cf7e415b64a63bd272fe514d8b1fa03ba29852ec8ef04e9c73d02a2b0d12092a8937756fdec02d27c8080fb125 +b1123314852495e8d2789260e7b3c6f3e38cb068a47bdf54ed05f963258d8bcabaa36ccbea095ba008e07a2678ec85a7 +a685b779514961e2652155af805996ceb15fb45c7af89c5896f161cac18e07b78c9776047c95b196362c9ad5430bcb22 +b734dd88f6cc6329c1cb0316c08ade03369a11dc33191086c6a177cf24540c7ceee8199b7afa86c344d78d513f828e81 +b0bf492fb136ecdb602c37636ed4deef44560ab752c0af5080a79c9f76a1f954eba60a0bf6ba8bd7b8cac21848c29741 +a5c74682323e85ac20f912ab9c1d6e1b9246c4c829dca40c8a7d58ec07ea0ad3524be30623f351269552f49b65a1245c +837403b9cf830fb33ecc11a7c8433e07745973c36acdeb3fc9ea8f7d8d690d462e1250b7410f79f2f4180fe8f3962a4f +b03d64b944d49c83608f2c5b9c14070c025f7568c4c33d4eeb1da31d07f0bc5897e498b35b50d557ee129f0c3c68e254 +827272aab8bf757e2483156e00fbebe1093a58070dd3af9855bbf946c7abfb9c8a850a6a8acda8c620902f391f968b8f +84c4eb863a865282d321302d06b362f8bd11c2bb0090f90ebffedd3eb3e7af704cff00d39a6d48cbea4262942e95200b +b044eb91653dc55dce75c8d636308a5a0dae1298de4382d318e934140a21ca90e8a210e06fdf93aadbbeab1c2ef3904a +a8c08955a4378522e09a351ecb21b54025a90f2936b974068e80862803e7da2b5380c4b83b4b4aad0409df8d6c8cc0cb +a763a5fb32bd6cb7d7c6199041f429782deacac22b6a8467077fab68824dd69343ebca63a11004c637b9cb3129dbf493 +8c44c8afa9a623f05c2e2aba12e381abdb6753bb494da81f238452f24c758c0a0d517982f3999d2537b7279d381625ed +8613f47fda577cd3bda7c99b80cf4b2dd40699edfd3df78acb5e456dd41fd0773bc8da6c5e8cbf726a519b9fb7646ccc +b21a30d49d7e1c52068482b837a4475568d0923d38e813cea429c1000b5f79b8905b08f6db237e2eccf7ef3e29848162 +b9bdf4915f3fbb8d84cdfd0deedf2c9dc5b14f52bf299ef5dca2f816988e66322df078da2c54b934b69728fd3bef40b5 +993b45f389f55eba8e5ba1042d9a87242c383a066cbf19bc871b090abe04de9ff6c1438cb091875d21b8c10fac51db58 +a85a95d14633d52d499727f3939979a498c154fd7ebb444b08f637b32c1caf5cca5e933a2f5d94f26851ae162707b77d +b9874c7c4be1c88a9646e0c2f467cd76bc21765b5ab85d551305f5ec0b4419e39d90703d4ac1bb01feb3b160517e97b7 +ad6771177fc78812904c90594712956357de1533a07fec3082ba707f19c5866596d624efc3e11773b3100547d8f6c202 +a79f31921134f7197f79c43a4b5d5b86736a8d3ad5af1bdf4ad8789c2bfe1c905199c5e9f21e9f446247224f82b334f8 +a7f1b6c45321222a350a86543162c6e4e3d2a7c2dce41aeb94c42c02418f0892dbd70c31700245d78c4d125163b2cd5e +92abafe3ec9dbe55c193fb69042500067eb8f776e9bf0f1cb5ab8eb12e3d34986d1204136856fb115c12784c3b8dea6e +89bc761238a4d989006ca5af5303c910c584fe7e6f22aa9f65f0718a1bc171e452c43695e9f5a591725e870770c0eceb +aa0e44c2b006a27d35e8087779411ba2f9f1966a0f5646ff6871bcf63a8b1a4a7638751b94c9b9798ccd491c940bc53f +8736fe82862b8106e7fdab7b5a964d87ec291a74b8eb1cb5a6c046a648c1b686064ef3d52297043b8940bfe870c712f8 +956a3def1942f05144d8e9c3a82fd2d3610064b53b9eefde3d5594a8f705bf8f6849eb2c22181796beffeba43cc74ee4 +af27416d00cf97d5a1f4a1b6b51c010884cceca294f1151c3b684a3f83c3c8a3c30771df1166d833cbddf6c873c400c3 +aac3b8dca2336fc4ffc63c362df461289e4bbd3418c621bde6c581d3ecedf66e2b3e523d4db39e3d8ba014577bf85efd +94c3a8167f62074e5b28c2bffe4b6ce645439a9a0c5da3ca1b3ee956590a465d6f84a8a4dbbe9070ffbd6bbc734e4d62 +95e23ba6986d25ed4451215da05bd72c5491528271726d79a94c8cb16aef1c85b190d6c5b8a3a1191c7cafbab1dccf0c +953e3dadb5ad68f7de31ac09692948655d174fe16d88b96930ef35b331da7f1dbc4c17863cd07b4ec3135b5205891a27 +915d018f18b5d63cb3301c2bb5c6e85e75a88ba80663c964d06575b6bacbbe59139d030b218ce0998271d5b28c00b26d +8c871ba3dd138a908b2f7effeea0e71df096b23e0dd47cab10b9762b250abfd1221da94a8ee884e05bdf02271fb85a04 +96bad5c6ebc3080ecbe337409ae398bbeada651221c42a43ea3b7c08c21841ddbcfde544c9b8d4772de6f2ce92c0b963 +b5dbcd0b1c44c62108841558ec0a48df4b327a741e208c38b1c052321eda6e6ad01af71d49dfcdd445ab6fa6f0c34e6d +97dba59219b69e8aef2659d1f10bbea98d74aefff1f6451de3f41be39acbac0122b8ff58b02e90554469e88911ec3547 +b7e5682ec306478be4858296f5d03364a61f3260636a4242f984d351a02e8723378496beb30c4ca22def9c9ca193ea70 +9656a7a3df4d11df3d8bc35930dff70a5e78a488ca57bba20bb06814fc390fc6c7cb3f39b22134992aad196cced577de +8b269695aa63eb56d0324ba984279dc4c88e565321f1d61d553622bd4f1910d5eff68393d3a830eb924472bd478c2aa3 +9177bcd04b28c87bc0440268b4c8995c6790cad6039594971b2c177f0e197055231e776927d3fa30d98fb897a2ba401f +ae0e943973482001c4f214b9da82e1c27e38aa254d0555e016095c537c835d3702bc2de5c67b234ab151e02b3b7a43a6 +82fc719a7d38bf4787fe1888019ad89fbf29beb951d2fece8686d2beb9119d0c8c6d13bc598748c72c70d73d488140ca +b716dc66f87eb16b95df8066877353962d91bf98cf7346a7f27056c2a4956fb65e55cb512af278783887ab269e91cd76 +81d58cd8bc6657362d724b966321cd29a1b5cdc4601a49fa06e07e1ad13b05e9f387ca4f053ed42396c508cd065c5219 +b32ad0280df6651c27bb6ddbdc61d5eb8246722140a2e29c02b8b52127de57a970e1ded5c2a67f9491ae9667349f4c46 +b68a2eb64cc43f423be8985b1a068e3814b0d6217837fb8fbfd9c786db9cca91885c86899c50a1242040b53bf304ced9 +85887515d4e371eabb81194cbc070e0c422179e01dbda050b359bd5870449c7950e6b3947b7a4a0eb68199341cc89fc3 +ac5fff3c27dfbab78eb8aad37ac31cc747a82401ebf3644a4f4f5aa98d37b8bf3b3f4bd8a3428b32a127c25c9e19d239 +86fceaa6fbf8913553a9e1e907fcb1f1986d5e401a7eafd353beefd1899d571454fea96ff5b2a21254d9fb693ec94951 +b6778bb296d3f0de2531b67d36fdbfa21475be0ca48b9dfcc38f396c41b557823735ed0b583e525a2bae1fe06e04058c +898088babeb5b9866537d6489f7514524c118704abd66b54210dc40a1c1ddb0a1edf7fe0b6e0db53b836f1828ecf939e +b27854364b97274765f0fb8d1f80d3660d469785d1b68da05e2bd1e4b8cbbe04304804d4c8aabb44cf030eba6c496510 +8c55bbf3603dc11cb78b6395ccbc01e08afcef13611f7c52956b7a65ccf9c70551bff3ae274367200be9fc2d5cb26506 +947726f73cd6281cd448d94f21d3b91b96de7ad3ff039f9153befbb5f172db9f53cacb4f88c80a3db26e6a0f7a846eb0 +a7b733a05e97528812d71cecb4f638a90d51acf6b8fcbc054787d6deb7e2595b7b8d1cbe1aa09d78375b5e684a2019bc +8d5ca6d161341461544c533314fe0a6655cde032c2d96f0e4ea7e41098b8b39fa075d38e2d8c74e2d0308f250d6cf353 +b960e9f081393e2260b41f988935285586a26657a3d00b0692ea85420373b9f279b2f1bb2da2caae72dd2e314045f1bd +852a49c7388c10821b387c6d51617add97ba72485f52be95d347bac44c638c92e9c6a44ba0d32afc4d59178a497d944a +8412162a65147e1334ad5af512982b2b48eef565682b3f3e0bbe93fbc5e1103db9375a0c486bdb1b2c57e4cb3a8e7851 +8f52c3eb5d4f1e1e82cfd2b291d4910195427603b796f6c311deb35ef14a01a57a9e6cad39619ad108f3e86f384f9e1c +88d221088f2bf0103c53e44d0d96cd7881ec2b0a965db9121a47481771a8b796edd5ac23c4f9c208a171dab301f7d3bb +b49c3235e8b3617ed08a1891b9e2bcb33dbdacceb94ca96330555b7e00904fe6a749ced9312b8634f88bcb4e76f91cb1 +a85834215e32f284d6dfb0cbfd97f6cffc7b9d354e8f8126d54598bb42d7f858a2b914cf84fa664069632db2ff89a332 +aa3d48eb483c6120c27d9b3e3d0178c1c942632ff54b69f5b3cfbc6ad4ff5b2b9ce6eb771fd1eea8edf4a74c97027265 +a446cfded353cdd9487783b45846402b973cdeddf87e2bf10cf4661610fff35743cc25e8d3b5771dcedfb46b018a5d18 +80998377b3b393ef3073f1a655ad9d1e34980750e9a5cfb95f53a221b053ddb4d6985747217e9c920735b0c851d7551f +a35ac469790fac6b8b07b486f36d0c02421a5f74ea2f0a20ffc5da8b622ac45dfccabfb737efa6e1689b4bd908234536 +8fb1f6d8e9c463b16ac1d0f36e04544320d5a482dd6ffaec90ea0f02b4611aaca984828bf67f84dcc3506b69af0a00a1 +b6e818d61aea62c5ed39c0a22ccbb327178feebdabda0c9927aa1549d2c5bb0637785c4aed2a6d9a7b4989fa8634c64a +b4e7208d16018bf67caafe996d436113eac619732e3f529a6efb7e6f094d8ebea55b7be0e122be075770f5957b6ea6f0 +b691d38b552befac61f6d367287c38d01fec73b7f2efdb6713ca30314a37fb7c177eb111fe6bee657f2681014e07630a +9817587e418e6e7e8e97ae27067f17b55d25dfb14e98f63f530620c855d9a348c9fa571c8508e2741f902f8b9fdc0c5c +b6a6e5ca779ba140bf1d84cd5394ede8262f7479637ec0087a4b152243a1774ba916d8115ce759a3bebd1b409de5f2fc +b53d1c84ad766ff794bf497db3228efd2cc8ed5fc1958d89c1126efdff361610ecb45ea8e329b39035ab00a66c1259c7 +adc31333c507c8e0f4aa2934fcdca57fd9c786722a50dbd5404e129541f7ac182cc7373bf14e1e4e06e6cf94b31b90eb +a82b7fde4642d982d95cec669efee140ad797a2442c7f6620580527d163accbf021b893446cbb8038ea82fe25b15d029 +91f7acf8a8903979afa281646fdecb54aa4d2ed905748e156e92f0910de268fa29d67107d40863935d677d1de8039be2 +86fea71c6d43a7d93216a92fc24dfce8521fd4534a9558b33762d002081247867a6eff54cad7116023277fb4049403ad +8ae5369a7f9f4c91f3be44b98089efd9c97c08f5bb4cd8b3150c115ecd86288fa0865a046a489c782973a111eb93966e +b6fb9e829aa2c81c2d9eac72bb2fd7f3a08e0cd763532c2ce3287444d33cf48b3621f205e9603ec58525934b61a795a9 +83e35ca808d84e41fc92115e9f6e283e928c3a614e6dfc48fe78c33b6411262e7bfa731eadb1e1937bc03cff60032e1d +832fca5196c95098ad47b7d24ba2f9d042e1c73ad2273edd1c2ce36386796ccc26e8567847697f3fcc2a0536a2a2087a +8fdb7038bc8f462ab2b76bf7053362f9c030019f1b6105cf42219a4e620ecc961e3eacb16a8e581a562a97f1418b0128 +8d3a5a404b51b1ad8ce3b23970e0d5cc57b573922341008e3a952a1dd24a135e19e55b79d86a70cfd82e1c0e9630f874 +ba00c025c1c21c57c03cdfc0bfd094b35422281ff0a64b68b240617aa58c6b18800af5f2047d3ff9068bbe987d6c7980 +b468f0dd51964b3806b0aa04f3fe28a035e8f5567fc7d27555be33d02701a838b8dbfe1348b6422c4eac46d2c75c40c7 +8a73a18c97da9958903c38584b08d0e7e26993a5d9b068a5e0e1ee0d8a873942745cf795f94f7a3d3ba88790a9fbb2f6 +953a0a40c2c8102723736854d13b228698c14a02d85c8d2e61db1a768019ac305faf0d5db62ac976430ce087a5b20f1e +8998219da6b34f657cb8a621c890a52cb98c2bc0f26f26e2af666eebeadadc5e8bdf4f830a91d04aca8ce186190152c8 +8941e08c3155ad432236ed05460420a05dd0aaab30477493ffb364b14c00ea5b9183d30d3442b6321d2d20c36e4f5c7e +93f293ff7fb56cf5b03aee6f3ad2ad78444398ed5b3be56d7bf5b56b5aa5a2b980d13895dd57a5726d1b067c20cc55e2 +84a16f313e3f75e31824f58d19ab24c6611fb4c75140a7cadc3c166f68819547c1d0ff7f7d13f5d8ae30dff1d80e2aa4 +b6e3e830b15039d3e28b08f5465bb089eade11ee3bd80afe39e010df7db1fcf0c56d698717677a41ddbc91eeaf6544d3 +95e928e6dfff51351281568ae72da7d1edeb6e9fe01f30af0499e7505ba35a22b5bb919d41bb809a432dce83f3977663 +aabeeb60ca46f9b0232ff82ea7766dcab8cc5aaf9d23539f30174f9486640bc9312868ca493b59b314519fc399973e47 +b393a11e957d0bbb3ecf617b075b5906a3450b348e62916c04791b366f0a7397cccd6648440ac544bc30526e1f95aad8 +abb5bfc3964a6d246da60bd809d0ea6daf4f8222efdc12ceb6730194e85f413ee7eb03bae300abf7ea900dbbc3d08971 +96c1bd1d1d216a4bfbcf000c123f296c0d31e1684e9e3884c14df23bf528c8d599f82bb98fcea491716b617216a8e0be +92d1e570a56f1741fd9f3d9f488cc336421c6256c14a08d340a63720be49b0029e3780e3e193a2e22bf66cc652fa22a3 +8769c08551e3a730e46f8e5d0db9cf38e565a001dfb50db3c30fa7fa0e98b19438edc23c6e03c8c144581b720d7b33a4 +b850bd67fdf5d77d9288680b2f6b3bc0f210580447fb6c404eb01139a43fccb7ed20051999ae2323ea5a58de9676bfb4 +80285da7a0aaf72c4528a137182d89a4db22a446e6c4a488cf3411937f4e83f7b00ec7549b0b4417682e283f91225dfe +80520368a80b97d80feb09dbc6908096c40ff7120f415702c1614d7112b0b57f6729581c71f4a3ce794ac959a46494ff +9817b4c27a490b1cd5a6337e7bc7e8005fa075dd980c6bf075ddfa46cd51cc307ad1d9f24e613b762a20fc6c877eab41 +ad66bda1a3034ec5e420b78107896ecf36126ce3ef9705163db259072dfa438c6107717a33572272062b9f60cb89557c +876114ef078c2915288e29c9abe6b0ad6a756b5ee2930ba1b8a17257f3f0557602d1225e8aa41ce8606af71ada2a971b +aa3d6cde4c3b9d3d5d0c77a33e67f182a3e1cf89b0921423b2024236171955b34afc52b1f25b1dad9da9b001371771d7 +984d3e3a72412d290e3459339757af7520d1739c7af0cbcf659c71999328db44f407d92e8a69fea11625612c49eac927 +ae890d0faf5bd3280dcad20a5f90e23a206661be8842375fea2ab22aadc500849ffbc52fe743b376d46bb926cedae6a6 +b1f231f3f4d710c3fe80099faeb56dac67c1baf53b8fe67a9920fe4f90e52cb9a4bf19211249a6456613b28efe337f18 +8caa54b418ba609d16520af3dff2e96d5f2eeb162c065a1763beb926547b2cfb3ae41d738db2c5681a9bc8bc9e6b9a1a +932157ff56c5ac29cf6cf44f450c882b3acfbb9f43d12d118da3d6256bde4e6eb3183aea304ab6967f37baa718ffec99 +9360bed8fc5b6aac36aa69473040689bfc30411d20ffb7275ef39b9ff5789f9055d149383ce9f0f7709a1f9d683adbfe +98b5b33209068335da72782179d0c7aeeabe94b5560a19d72088fe8323e56db7ce65debe37a97536b6b8a0ca3b840b61 +89a385c11be40064160b030a1bb28c3921fc8078522618a238c7ea0f86f34717ed9af9b4e2e20f5128e5f7fc66ad841e +b615703cbc64b4192990cc7e4903b74aed6a0076ce113b59ef7719197ffa46fb29eb78ca56b49873487432d0625c0faa +90f0d77abae9d3ad73a218e5ccec505ad108ea098451461567ae8ef9661606ca8e78df53b5d628b20b7037bd24622330 +92e0e7cc4dfadc5fa0ee6da0c8de0493030db6e54ba0317f52f232a6708b732068b6077bd13a17eb7eb40b88368085b5 +a24dad20094985bfccc6df1343506ed3bf9dcbdf4b2085a87627a5d71f7568db067304e465f8f380c5c88e8a27291a01 +8629a45a10619354c84bdc2f6c42f540eab5a46f53f2ae11970433d7a2aef007897590bf31dfba1c921614c6d6fe1687 +84ac64040d4206f82b08c771f375da4b7d752e41d2aa0da20ce845f6bc1b880a855d3ee966bca19b8ec327b4b43e7f0e +9608e6050c25996c052509f43f24a85cdf184135f46eaac520a9a6e78e0d44a6cee50ebc054048c708aefde8cd6651c2 +a32032b0e0d7cc35e480c328f315327f9385adb102a708c9ba637878deb74582ae26bb6d6e5f8c9e3a839b0e0154b82a +b7e3c78d63acc6564a49e9f00b0a820b56d4f37a2374af1f7f1d016268011df9e7af0670ed2b0eee961f15aa948328dd +8b88bfdd353acc91ad0d308a43e5fb40da22c228f2fe093c6d6904d70f69c6203f56636ed898b05df51d33f1095ef609 +b1d7a430c51fc857af55047683fc18c453b013527196c5e1bf776819a3dffca802217e9249ae03f084e2ea03ad67fcc2 +80558e28a819ddb5e72e97c54be0f57c173ccf78038d360d190b7f1350a19577b8e3f43fa2f7bf113a228cd3b965b2e4 +b4b2ec44e746c00dfc5661ba2514930934fc805cdc29adc531c02d28ce3cc754414b0485d4ee593232cd1175f357ad66 +b57cee5d32835f76572330f61ccd25a203f0e4a7e5053d32965db283aad92f287645533e8e615137208383ec51b1fd99 +930256086b419a8a6581c52590d0dbd9f8a3564c79424198fca3866b786df2f6098a18c50dc4abd20853a7184b1ce15d +8e75fd01181cffcd618a983492390f486e8c889972a46c1f34a4e1b38f384e8e4efc7e3c18533aa2057da9f9623e2238 +b375d927dd988429f9e2764e5943916131092c394fce13b311baa10f34b023dd3571da02553176091a0738cc23771b9a +b9e28e4c0d0477518034d000e32464852e6951c8db6f64ccdb1d2566f5094716213fbf2fc0e29ac88d0e79f725e3c926 +963981e99392afbd2b8318d5a6b2b0cc69c7f2f2f13f4b38dddbfedb2b0eaf0584aecfcbda20a4c60789c15d77970a58 +a7804e1977aa77c263c7c001afa6cf568032dea940e350d6a58ce4614f1a91c13ae1c78bfea740c229dce2444556976a +8787204177da3cde6d35cd3497fa8774d244f9faa9f4bd91b636a613a32ce2ea0326378cf9c4cf475e73ef751b355c4b +895aeef46a07152a04ec812f1aa1fd431389fa0ef6c6e96a5b833e70ea14073bc9984757a8ee456dbec9788e74e6f0ca +8d17f0e5826783440d1f0ec868003510a4d9952bfe4a638e44a36d94482ac18ba70ef7ff773bdf7a3b62d714dcf0fcba +810d5e36b31310b2e054a666d3b3f7ed16dfcb1765532d87ca2a3920316f0187303c27dd113db145d47e8961062a6c03 +b4e2fb48ae04cf8580bb6a28095076c9b95e5f13122b917328f334d4ac8a8648ce442919e28319a40148987350ab5303 +b85549a313544fa1eb3ceb78473b7d3d717fc85b808de7b79db7dbd0af838ebb020622a7503f1cbacab688dddb648f84 +80665adee057088eae827a5fe904ec3ad77d8843cdce0322d535e0659b4abc74a4d7ddd8a94c27f2def5c34ac2c038ee +ad72fc19c2ce99b5b717e35528fe7d3ac8add340b02ebeb4889d9a94c32f312a0b45ea84d21c54f84cc40ee4958b72e1 +99d530c843dff89a47a5ee8c87303ab18f8a82b0d5b808fca050354b35da5c5a5594d55921c6362d6cc917d75bdc18dc +99c7286c293e1be21c5b2a669dfdfcd5aa587105d2886fc5a8eaf8984da4e907f7d7b8c2362d64a4f1621b077a2a08a0 +b4a39e1a9ed5d80c9563c3ca3fadf76f5478c63a98f4346a61b930c9c733e002f3ff02bc16abfdb53d776184cc3f87ba +9378ea71b941979404c92d01fb70b33fa68d085bf15d60eb1c9fc2b5fcdee6379f5583389a3660a756a50019a2f19a69 +b68e17344a2bc45b8e2e19466b86dc139afefbf9bad2e2e28276a725099ebac7f5763f3cb52002261e3abe45ef51eb1a +819e64dc412b2d194d693b9b3157c1070a226af35c629837df145ea12ad52fa8eabd65b025a63c1fb0726207a58cdde8 +a5e8ff8748419466ff6df5d389125f3d46aedacf44eaf12cbfe2f68d218c7d5ab6de4a8279d13aecc25f3b1d98230894 +91560d54a9715cfda9cf7133ae51c432d0bf7fcbaeb468004994e6838bfc5ddcfa30e4e780667d0c4c0376780b083017 +ae8adb3309cc89d79a55ff74f129bb311fe4f5351a8b87600a87e0c3ba60825f71fccf67eadcf7e4b243c619417540fd +8d92cc1a6baa7bfa96fbce9940e7187b3d142f1888bdcb09bb5c8abf63355e9fb942ac4b4819d9be0e0e822d3e8e2e08 +a6e8b79fdd90c34735bb8fbef02165ccbe55ea726dc203b15e7a015bf311c9cac56efd84d221cc55eaa710ee749dbdfe +a409b151de37bddf39ce5f8aa3def60ee91d6f03ddd533fce9bf7bdbeac618cc982c4f1ffbf6e302b8353d8f28f8c479 +b9693975ef82171b3b9fc318ca296e4fe6110b26cbdfd653418f7754563fa7b6e22d64f8025ee4243483fa321572bfe4 +a039ebe0d9ee4a03ade08e2104ffd7169975b224061924cca2aae71464d250851e9f5f6f6cb288b5bf15df9e252712a6 +b27834db422395bd330e53736a001341ce02c9b148c277dabac67dc422741bfa983c28d47c27e8214cd861f2bad8c6f6 +a2bafaf4e2daf629fd27d7d5ac09fb5efc930ff2ae610f37519808683aa583fe1c6f37207daf73de1d8a164f79a0c981 +b856cee1cfcf5e50db9af4ab0aed3db2f43c936eaea369b5bba65582f61f383c285efbda97b1c068c5d230cbe94f7722 +a61ab205554c0550fa267e46a3d454cd1b0a631646b3df140623ff1bfffaa118e9abe6b62814968cc2a506e9c03ea9a0 +8c78edcd106377b9cbdfa2abd5278724aed0d9e4ae5869b5d2b568fdabb7804c953bae96294fcc70ef3cd52ba2cbe4ed +8570869a9bbf6cc84966545a36586a60be4d694839f367b73dfc40b5f623fc4e246b39b9a3090694aa2e17e652d07fd1 +a905b82c4da8d866a894da72315a95dc98faa3c7b3d809aef18f3b2be4801e736a1b79a406179e8cac8f74d27e71ac52 +a8eb8679ff1a64908515f6720ff69434cb33d63aeb22d565fde506618908b1d37585e3bd4d044fd0838b55787af06b42 +af4d86b2fbd1684a657dffe4210321a71e6ae560c144d44668d1f324dc9630e98348c3d444622a689327c1a59cc169dd +80359c6eab16954559ab0e6a1fee9a0526c45d3cae1a371159a2e3aa9b893afdc3a785c9559a5fd9cd8cd774234bf819 +8d4e5ff81eb5d17bbe8ae6416538ca51a9427ce142b311f5cbb14febbbbb9c1ffc6489fd625b9266264c366c12a9d997 +92e181c66489c5fa063ba2a1a354b6fd3439b8b4365a8c90e42e169bfaa1fb5766bf3e0fe804399d18bc8fbcafb5c3b1 +a9ddf229360a095393885083716cb69c819b2d7cfb100e459c2e6beb999ff04446d1e4a0534832ae3b178cbe29f4f1d3 +8e085ef7d919302a1cc797857b75cff194bdbc1c5216434fa808c3dea0cf666f39d9b00f6d12b409693d7a9bd50a912c +916dc4dc89e5e6acf69e4485a09fc66968f9b292eac61a146df1b750aa3da2425a0743d492179f90a543a0d4cd72c980 +b9cbf17e32c43d7863150d4811b974882da338cf0ed1313765b431b89457021dd1e421eeaa52840ef00551bb630962dc +a6fb875786daec1a91484481787093d8d691dd07e15c9c0c6ae0404bf9dc26083ed15d03c6d3fe03e29f28e20da21269 +a870fcb54b9a029e8086de9b08da8782c64ad2cc2e7fdf955b913d294038bb8136193256b85267e75a4ca205808a76b4 +99883f057e09b88bf0e316f9814c091837fd5c26eeb16fec108c9fed4b7a2bd1c783dac0e4242b5a906621ab606c1e50 +85d89069ca3190577dab39bbec43c16bf6dbca439ad3eebd8f5e9f507d84c3c43e77fd6323224582566a3aa2c8018951 +9363ba219e0003f6e8a9d8937b9e1449e4b2c5cd57194563b758bea39deab88778e8f8e4f7816970a617fb077e1e1d42 +820622f25553c035326145c1d2d537dc9cfd064c2f5bdf6d4ec97814de5fe9a0fbd443345fa2ea0a9d40d81d3936aa56 +87e31110aaf447e70c3316459250e4f7f8c24420c97828f9eb33b22107542c5535bdb48b0e58682dd842edea2886ff08 +95bf80cac6f42029d843d1246588acb40a74802f9e94b2bf69b1833936767e701ef7b0e099e22ab9f20f8c0c4a794b6c +a46ecf612b2763d099b27fb814bd8fdbaee51d6b9ac277ad6f28350b843ce91d701371adfaaf4509400dc11628089b58 +8604decf299fb17e073969708be5befeb1090ab688ad9f3f97a0847a40ea9a11bbcfc7a91e8dc27bc67a155123f3bd02 +8eb765c8dc509061825f3688cb2d78b6fef90cf44db33783d256f09be284bc7282205279725b78882688a514247c4976 +b5c30b2244fa109d66b3a5270b178960fdec47d31e63db0b374b80d2b626409eb76d2e8d1ebf47ef96c166743032fc5e +aab01e76290a7e936989530221646160bf8f64e61e79282e980c8c5dcaaa805ff096efd01d075a2c75917a3f4bf15041 +b9d79671debd0b83d0c7c7c3e64c0fb1274300564b262771f839b49218501e7f38ef80cae1f7e5a3c34acdc74c89dab6 +92c0eaceadf036b3b9dfd2712013aba3dd7c30b7760f501f52141618265baa31840fe77850a7014dc528f71f8cf39ce6 +b3cdd098059980455dd5b1c04182df1bd12fa844a866f02a9f8a86aab95b59945baa9af99f687410bffc5b07153cb23c +b361b73a62f71256b7f6ea8e0f6615e14fc5a06ee98b928ab3c9dd3eef9d9d30070e9855c82b7facb639cacb3401e01f +b9c85fc0f25a3271cf28b1ca900078eaaa66cbab0a3e677606e898ac32781a2dfce4d9cbd07404599e2c3c02fa161c9d +ac5b4fdac2a0b2e6430d9fc72bde4249d72183b197fc7347bb1546ae6f544426686bbe0caec3ee973b6836da5e831c44 +b675aebf24b92e398e166f171a6df442b3f5919b6bee192f31675a5e8eeb77d34c6590a6f0c0857417e0f78cfb085db8 +a9bef942044d8d62e6a40169f7dc7b49e40cd0d77f8678dd7c7bae6f46c46786f9b1e319a3fa408f22a54fd2a4d70804 +a20d19cd917d5102ae9ca0cf532127d2b953aa3303310e8a8c4b3da025dded993a47e3a28e6b02acfadb6d65dc2d41a3 +a47fdb04059b83b2afb86a47b2368bbd7247c337a36d3333b6e5ef2cc9476a92c4907e4c58a845c9ef9b497621e0b714 +94a9e9ffc14b411e11a4ffa59878d59460263589003dc7b6915247c549f67feede279bf3645fdd92379022fb21e3caeb +b92e1177dd9ecdaf1370c71b14954219cf0851f309bc216d5907a4e2e84e0df3457018224150c142cc6bf86644bb4b73 +8bc57fadd68a265b7df9b42227a9c0968db7b1bb50dc12f7d755505779f1ff2c408672b3091e903366acc9ce15d19fb6 +b6b5efbe1ac4e1bd2e8447c45000d09397b772ca5496acc447b881022608a41c4f60388814607a01890190105bee7be3 +95f7c85fd614df968f8ccf8d086579c9e1cec4644ecf06da26e3511cb39635a7326b3cec47bd51cf5646f1c660425e9c +b81765fb319bcdc74b4d608383ccb4af7dd84413b23af637be12e2827a75f7e4bcd14441cf979ed9038ae366fbb6f022 +a120ea76cda8c6c50c97035078f6648afe6537809bdba26e7c9e61de8f3070d2347160f9d34010effbf2ec7e94f5749f +92c1b8631953b40d3cc77eee2c72a064b999c09a9b92c11d8fa7b4072966273901c9dba25f9f79f384d9f11a56f3fc7a +a4b00dc0ab67b2300abc9c516e34daf444d6497b066a90cfe3381ed2812304ed37b14f3b948990443dc6c1cf1bed460c +a9e9f7e13c9f031bc7b9e6f1417c7abcc38894fe7d3f54869ee277afd2efa3e6fb50757dd36c8c94d591e0abdea322cc +84f3e98f831792b5ad14bcfe62a4c9f296476c6087c4c1ec7767fc642fbca141ff6a3deeb8b4d4106a9cda5a9937eea0 +8eb1a7931bbea9a714226fd74b0100ab88355287d9b0a349c095e9b5809b98f237ffd706bce7d67a770da355fb9cec7b +9738ef8739e1742c1f26b51a1621be0b89d37406a370c531e236f635c7064c661818817bb3858908986aa687b28b21be +a9cf3ce8501b003ccaf57552a4c4ec31081e44526d3aa3791d3dc4a7e438a357c0956f93c500356186d8fd4588ffac5e +a7af6a219cca59225839a9de5b19263cb23d75557d448bc7d677b62591a2e068c45e5f4457cceb3e9efa01d0601fc18a +972a24ece5eda7692cbb6fb727f92740451bc1281835e2a02931b2b05824a16b01dbe5edd03a0ed5b441ff25a5cc0188 +b21d1ec7597ce95a42f759c9a8d79c8275d7e29047a22e08150f0f65014702f10b7edce8c03f6e7ab578ce8c3b0ec665 +a13a1c7df341bd689e1f8116b7afc149c1ef39161e778aa7903e3df2569356ad31834fa58ceb191485585ce5ef6835c3 +a57bdb08119dc3bc089b5b2b5383455c4de0c2fcdac2dcfa21c7ac5071a61635ff83eceb7412f53fab42d1a01991de32 +b2968748fa4a6921ee752d97aa225d289f599a7db7a222450e69706533573ded450380c87f8cdd4a8b8c8db1b42b5c97 +8718ec04e0d5f38e3034ecd2f13dfde840add500f43a5e13457a1c73db0d18138f938690c8c315b5bcbeb51e8b9a2781 +82094789e26c4a04f2f30bdb97b9aecca9b756cbd28d22ab3c8bed8afc5b2963340ddfc5a5f505e679bf058cbc5dcbb8 +a35b8a566dd6ab67eddc2467906bffc76c345d508e52e9e4bb407b4f2b2c5f39b31d5a4bf5022f87bf7181dc6be2fe41 +a8c93b1e893d4777c0e3a1b4bef3be90c215781501407c4011457fc3240e13524b4d2bea64a6d0a3efe3f3b0dae9b8ab +877095ad18b1e5870818f7a606127ba1736a0b55b0dbcd281ec307c84b08afc0c9117e3a880fe48bfc225fbf37671a97 +84405ee0421ed2db1add3593df8426a9c1fcc8063e875f5311a917febc193748678dd63171d0c21665fb68b6d786c378 +a52cdc8209c3c310bed15a5db260c4f4d4857f19c10e4c4a4cfe9dfc324dfac851421bb801509cf8147f65068d21603c +8f8a028a70dda7285b664722387666274db92230b09b0672f1ead0d778cee79aae60688c3dfd3a8ed1efdeda5784c9d4 +a0be42fecc86f245a45a8ed132d6efc4a0c4e404e1880d14601f5dce3f1c087d8480bad850d18b61629cf0d7b98e0ae0 +83d157445fc45cb963b063f11085746e93ab40ece64648d3d05e33e686770c035022c14fdf3024b32b321abf498689ad +8a72bbf5a732e2d4f02e05f311027c509f228aef3561fc5edac3ef4f93313845d3a9f43c69f42e36f508efcc64a20be0 +b9ca29b0ec8e41c6a02f54d8c16aebf377982488cbe2ed1753090f2db4f804f6269af03e015d647a82ef06ffaa8cba6c +b4df3858d61bbb5ded1cf0be22a79df65ae956e961fbb56c883e1881c4c21fe642e3f5a0c108a882e553ac59595e3241 +86457d8890ac8858d7bab180ef66851247c2bf5e52bf69a4051d1d015252c389684fcc30bb4b664d42fbf670574ab3a3 +86d5576ea6dfa06d9ebce4cd885450f270c88a283e1e0d29cab27851c14ed2f00355e167b52e1539f1218ad11d8f13dd +883ad1364dc2a92388bfafaa9bc943c55b2f813525831e817a6208c666829a40455dde494eba054b2495a95f7ce69e8a +8942371e6925231c2c603b5f5a882d8404d39f0c7c4232557c2610b21c2c07f145466da798ea78b7932da2b774aa3128 +a799eb71496783cc7faf12c9d9804bf6180699a004b2f07fc5cc36840f63ce7eee7dde9275819a9aa3f8d92dc0d47557 +8eb3fb5c769548ee38c7882f51b959c5d5a42b5935269ccf987d6ddbb25a206e80c6000bcc328af149e0727c0b7c02c0 +8f3910d64e421a8f2d8db4c7b352ba5b3fc519d5663973fea5962efe4364fb74448770df944ef37ffe0382648fb56946 +b41413e0c26ff124cf334dab0dc8e538293d8d519d11cc2d10895a96b2064ac60c7da39f08589b38726cffa4c3f0bfef +b46ef2eb10abae0f35fa4c9c7ee2665e8044b8d9f91988a241da40fd5bbc63166925582151941b400006e28bbc5ba22a +b8baa8b4c420bb572a3b6b85479b67d994c49a7ebfe1274687d946a0d0b36dfed7630cfb897350fa166f5e2eff8f9809 +964b46d359c687e0dcfbdab0c2797fc2bd1042af79b7418795b43d32ffca4de89358cee97b9b30401392ff54c7834f9f +8410d0203d382ebf07f200fd02c89b80676957b31d561b76563e4412bebce42ca7cafe795039f46baf5e701171360a85 +b1a8d5d473c1a912ed88ea5cfa37c2aea5c459967546d8f2f5177e04e0813b8d875b525a79c29cb3009c20e7e7292626 +afaab9a1637429251d075e0ba883380043eaf668e001f16d36737028fded6faa6eeed6b5bb340f710961cee1f8801c41 +aef17650003b5185d28d1e2306b2f304279da50925f2704a6a3a68312f29fe5c2f2939f14e08b0ba9dee06ea950ad001 +97bcc442f370804aa4c48c2f8318d6f3452da8389af9335e187482d2e2b83b9382e5c297dce1a0f02935e227b74e09a3 +8a67a27b199f0bcd02d52a3e32f9b76a486b830ec481a49a4e11807e98408b7052b48581b5dd9f0b3e93052ec45dfb68 +b113bf15f430923c9805a5df2709082ab92dcdf686431bbad8c5888ca71cc749290fa4d4388a955c6d6ee3a3b9bc3c53 +8629ca24440740ce86c212afed406026f4ea077e7aa369c4151b6fa57bca7f33f9d026900e5e6e681ae669fd2bd6c186 +933a528371dcecc1ec6ded66b1c7b516bd691b3b8f127c13f948bfbcda3f2c774c7e4a8fbee72139c152064232103bdf +8568ddd01f81a4df34e5fa69c7f4bb8c3c04274147498156aec2e3bd98ea3e57c8a23503925de8fa3de4184563a2b79e +8160874ec030f30fda8f55bcf62613994ff7ed831e4901c7560eac647182b4a9b43bfaff74b916602b9d6ae3bfcaf929 +ae71c48d48cf9459800cdf9f8e96bc22e2d4e37259e5c92a2b24fbe2c6ca42675e312288603c81762f6ceb15400bc4c9 +b05f39bb83fda73e0559db1fd4a71423938a87ad9f060d616d4f4a6c64bf99472a2cbfb95f88b9257c9630fc21a0b81f +80c8479a640ed7a39e67f2db5ad8dfd28979f5443e8e6c23da8087fc24134d4b9e7c94320ffa4154163270f621188c27 +9969ba20ee29c64cb3285a3433a7e56a0fe4ddc6f3d93e147f49fe021bed4a9315266ebb2fb0eb3036bb02001ae015e6 +a198c89fef2ab88e498703b9021becc940a80e32eb897563d65db57cc714eaa0e79092b09dd3a84cfab199250186edcc +8df14a3db8fe558a54d6120bad87405ba9415a92b08c498812c20416c291b09fed33d1e2fcf698eb14471f451e396089 +81e245ef2649b8a5c8d4b27188dd7e985ef6639090bdc03462c081396cf7fc86ed7d01bfe7e649d2b399255e842bdc21 +8659f622c7ab7b40061bcf7a10144b51ad3ab5348567195924f2944e8c4ce137a37f1ba328e4716c10806f3fb7271689 +a575d610fc8fe09334ca619ecdadf02d468ca71dd158a5a913252ca55ea8d8f9ce4548937c239b9cb8ab752a4d5af24a +94744549cd9f29d99f4c8c663997bdfa90e975b31f1086214245de9c87b0c32209f515a0de64d72d5ef49c09b0a031fa +80a8677862b056df59e350c967a27436c671b65d58854e100115bac9824ba177e94c2a1bfcaa191a071b9cefdbee3989 +91be9a5504ec99922440f92a43fe97ddce2f21b9d94cd3a94c085a89b70c903696cec203bbab6d0a70693ba4e558fb01 +8c5a0087bcd370734d12d9b3ab7bc19e9a336d4b49fc42825b2bfedcd73bb85eb47bf8bb8552b9097cc0790e8134d08c +933aa9e6bd86df5d043e0577a48e17eea3352e23befdbb7d7dcac33b5703d5ace230443ac0a40e23bf95da4cc2313478 +984b7ee4bd081ee06c484db6114c2ce0ba356988efb90f4c46ff85ed2865fb37f56a730166c29ef0ae3345a39cdeae7a +ae830f908ea60276c6c949fb8813e2386cf8d1df26dcf8206aa8c849e4467243e074471380ed433465dc8925c138ea4c +874c1df98d45b510b4f22feff46a7e8ed22cfc3fad2ac4094b53b9e6477c8dfc604976ca3cee16c07906dece471aa6c6 +a603eb60d4c0fb90fa000d2913689126849c0261e6a8649218270e22a994902965a4e7f8c9462447259495fe17296093 +a7c73d759a8ad5e3a64c6d050740d444e8d6b6c9ade6fb31cb660fa93dc4a79091230baccb51c888da05c28cb26f6f3f +a4411b79b6a85c79ea173bd9c23d49d19e736475f3d7d53213c5349ebb94a266d510d12ba52b2ac7a62deaaaec7339b8 +943b84f8bbcee53b06266b5c4cd24d649d972593837fe82b0bf5d5e1bbc1a2bf148e1426c366d7c39ab566b10224cadc +8300012096a8b4cefecc080054bf3ceb0918162ba263c6848860423407796b5eb517170c0bad8e4905ac69a383055a21 +8244a1e3ad41908c6f037e2f8db052e81f281646141334829f36c707f307448b9ab79a7f382a1e8d86f877c90b59271c +8eca1b74687802ecc36a5d39e4516a9dee3de61a2047252d9ed737b49e0090c386e9d792ac004c96337681c7f29a16ad +b70fa47535f0524835039a20036c61e77f66146ad79d3d339214d8744742db41ceeb577c829d000011aeafbb12e09579 +84b3abbce48689f3adbb99889c7fd1f3e15ab455d477e34f5151c5c1c358ed77a5b6a581879f7e0f1f34106e0792e547 +ab45ecb58c0ef0dbce3d16afc6ac281e0d90ec48741ea96a141152647e98fcc87f3a3ff07ba81f3179118453ce123156 +90d231a145ba36a59087e259bbfc019fa369201fcfeaa4347d5fd0a22cd8a716e5a797f3cc357f2779edb08f3b666169 +a4f6074d23c6c97e00130bc05f25213ca4fa76c69ca1ace9dece904a2bdd9d987661f5d55023b50028c444af47ff7a08 +933af884939ad0241f3f1f8e8be65f91d77ac0fb234e1134d92713b7cfb927f1933f164aec39177daa13b39c1370fac8 +80d1db6933ce72091332ae47dc691acb2a9038f1239327b26d08ea9d40aa8f2e44410bbda64f2842a398cbe8f74f770f +a7a08605be2241ccc00151b00b3196d9c0717c4150909a2e9cd05538781231762b6cc6994bebbd4cddae7164d048e7b2 +96db0d839765a8fdbbac03430fa800519e11e06c9b402039e9ae8b6503840c7ecac44123df37e3d220ac03e77612f4e4 +96d70f8e9acd5a3151a8a9100ad94f16c289a31d61df681c23b17f21749c9062622d0a90f6d12c52397b609c6e997f76 +8cf8e22273f7459396ff674749ab7e24c94fe8ab36d45d8235e83be98d556f2b8668ba3a4ec1cb98fac3c0925335c295 +97b7e796a822262abc1a1f5a54cb72a1ea12c6c5824ac34cd1310be02d858a3c3aa56a80f340439b60d100e59c25097d +a48208328b08769737aa1a30482563a4a052aea736539eceab148fa6653a80cb6a80542e8b453f1f92a33d0480c20961 +b612184941413fd6c85ff6aa517b58303b9938958aa85a85911e53ed308778624d77eadb27ccf970573e25d3dfd83df7 +b3717068011648c7d03bbd1e2fc9521a86d2c3ae69113d732c2468880a3b932ebec93596957026477b02842ed71a331b +a0ad363e1352dcf035b03830fef4e27d5fd6481d29d5e8c9d51e851e3862d63cdcbaf8e330d61c1b90886921dac2c6fd +8db409fdacfa4bfdaf01cc87c8e97b53ca3a6e3a526d794eaad1c2023f3df4b888f1bf19fee9a990fe6d5c7c3063f30c +b34d6975310ab15938b75ef15020a165fc849949065d32d912554b51ffa1d3f428a6d1a396cb9329367670391de33842 +9117285e9e6762853fc074b8a92b3923864de2c88c13cea7bab574aaf8cdd324843455d2c3f83c00f91f27c7ecc5592a +b4b2e8f190ea0b60819894710c866bf8578dd1b231ae701d430797cc7ede6e216e8ca6a304f3af9484061563645bf2ab +8c493c6853ab135d96a464815dd06cad8b3e8b163849cdefc23d1f20211685753b3d3e147be43e61e92e35d35a0a0697 +9864d7880f778c42d33cf102c425e380d999d55a975a29c2774cad920dfddb80087a446c4f32ed9a6ab5f22ec6f82af0 +90f67fe26f11ca13e0c72b2c2798c0d0569ed6bc4ce5bbaf517c096e7296d5dd5685a25012f6c6d579af5b4f5d400b37 +a228872348966f26e28a962af32e8fa7388d04bc07cfc0224a12be10757ac7ab16a3387c0b8318fcb0c67384b0e8c1a4 +a9d9d64bba3c03b51acf70aeb746a2712ddafe3b3667ae3c25622df377c2b5504e7ab598263bec835ab972283c9a168b +932128971c9d333f32939a1b46c4f7cf7e9d8417bd08dc5bd4573ccbd6ec5b460ac8880fb7f142f7ef8a40eef76d0c6d +964115e7838f2f197d6f09c06fbb2301d6e27c0ecdf208350cf3b36c748436dac50f47f9f9ac651c09ab7ad7221c7e43 +a5941f619e5f55a9cf6e7f1499b1f1bcddcc7cf5e274efedaaad73a75bc71b1fc5c29cd903f6c69dc9a366a6933ca9d1 +a154bf5eaec096029e5fe7c8bf6c695ae51ace356bb1ad234747776c7e1b406dee2d58864c3f4af84ed69f310974125e +b504e6209d48b0338ab1e4bdab663bac343bb6e0433466b70e49dc4464c1ec05f4a98111fd4450393607510ae467c915 +813411918ea79bdde295393284dc378b9bdc6cfcb34678b9733ea8c041ac9a32c1e7906e814887469f2c1e39287e80f8 +8be0369f94e4d72c561e6edb891755368660208853988647c55a8eed60275f2dd6ee27db976de6ecf54ac5c66aaf0ae6 +a7e2701e55b1e7ea9294994c8ad1c080db06a6fc8710cd0c9f804195dce2a97661c566089c80652f27b39018f774f85e +956b537703133b6ddf620d873eac67af058805a8cc4beb70f9c16c6787bf3cc9765e430d57a84a4c3c9fbdd11a007257 +835ae5b3bb3ee5e52e048626e3ddaa49e28a65cb94b7ecdc2e272ff603b7058f1f90b4c75b4b9558f23851f1a5547a35 +85d67c371d1bf6dc72cca7887fa7c886ce988b5d77dc176d767be3205e80f6af2204d6530f7060b1f65d360a0eaeff30 +a84a6647a10fcef8353769ef5f55a701c53870054691a6e9d7e748cbe417b3b41dbb881bae67adc12cb6596c0d8be376 +87ffe271fc0964cb225551c7a61008d8bcb8b3d3942970dbcc2b9f4f9045a767971880368ea254e2038a3a0b94ecf236 +964bb721c51d43ee7dd67c1a2b7dd2cc672ce8fad78c22dcddb43e6aab48d9a4a7dc595d702aa54a6fb0ffabf01f2780 +a89b3f84bb7dcbe3741749776f5b78a269f6b1bebb8e95d3cc80b834fd2177c6be058d16cacfd0d5e1e35e85cde8b811 +b4314538e003a1587b5592ff07355ea03239f17e75c49d51f32babe8e048b90b046a73357bcb9ce382d3e8fbe2f8e68b +86daf4bf201ae5537b5d4f4d734ed2934b9cf74de30513e3280402078f1787871b6973aa60f75858bdf696f19935a0e2 +b1adf5d4f83f089dc4f5dae9dbd215322fa98c964e2eaa409bf8ca3fa5c627880a014ed209492c3894b3df1c117236c4 +b508d52382c5bac5749bc8c89f70c650bb2ed3ef9dc99619468c387c1b6c9ff530a906dfa393f78f34c4f2f31478508a +a8349a5865cb1f191bebb845dfbc25c747681d769dbffd40d8cedf9c9a62fa2cbc14b64bb6121120dab4e24bef8e6b37 +af0500d4af99c83db8890a25f0be1de267a382ec5e9835e2f3503e1bac9412acf9ff83a7b9385708ef8187a38a37bc77 +b76d57a1c1f85b8a8e1722a47057b4c572800957a6b48882d1fc21309c2e45f648a8db0fcff760d1dbc7732cf37c009b +b93c996cec0d3714667b5a5a5f7c05a7dc00bbc9f95ac8e310626b9e41ae4cc5707fac3e5bd86e1e1f2f6d9627b0da94 +93216fdb864217b4c761090a0921cf8d42649ab7c4da1e009ec5450432564cb5a06cb6e8678579202d3985bd9e941cef +8b8be41105186a339987ae3a5f075fbc91f34b9984d222dfed0f0f85d2f684b56a56ab5dc812a411570491743d6c8b18 +959b72782a6b2469e77fe4d492674cc51db148119b0671bd5d1765715f49fa8a87e907646671161586e84979ef16d631 +86b7fc72fb7e7904ea71d5e66ba0d5d898ace7850985c8cc4a1c4902c5bf94351d23ce62eed45e24321fb02adfa49fc8 +a2f244e7c9aa272cb0d067d81d25e5a3045b80b5a520b49fd5996ece267a7f1bea42e53147bbf153d9af215ea605fc9e +81aa2efa5520eebc894ce909ba5ce3250f2d96baa5f4f186a0637a1eea0080dd3a96c2f9fadf92262c1c5566ddb79bab +b607dd110cfe510d087bcff9a18480ba2912662256d0ab7b1d8120b22db4ad036b2266f46152754664c4e08d0fc583f6 +8f588d5f4837e41312744caac5eee9ddc3ad7085871041694f0b5813edf83dc13af7970f7c9b6d234a886e07fa676a04 +924921b903207783b31016cbec4e6c99e70f5244e775755c90d03a8b769738be3ba61577aca70f706a9c2b80040c9485 +ae0a42a222f1a71cd0d3c69ffb2f04c13e1940cce8efabe032629f650be3ceed6abb79651dbb81cb39a33286eb517639 +a07d7d76460f31f5f0e32e40a5ea908d9d2aebf111ac4fadee67ef6540b916733c35a777dcdc05f6417726ca1f2d57dd +88d7f8a31f8c99794291847d28745e5d0b5d3b9684ca4170b686ffbb5bb521a3ef6746c3c8db22e4250a0cdff7939d96 +849573071fd98c020dc9a8622a9eff221cb9f889bde259e7127a8886b73bef7ad430b87750915658918dcfb6b7b4d8d3 +b12d59f732fa47fad175d6263734da8db89230fd340a46ad1cdee51e577041a5c80bf24cd195593e637daf1a66ef5a98 +abbcfb8a4a6d5e269ee1ac5e277df84416c73ca55ec88317f73608201af25af0cb65b943c54684a5651df3a26e3daca2 +ab157f589bdbaf067a6a7ba7513df0492933855d39f3a081196cf2352e0ddc0162d476c433320366e3df601e0556278d +a86c0619b92e5ae4f7daa876a2abc5ba189156afc2fa05eef464dfa342ba37fc670d0dc308ad3822fcb461ab001bac30 +a3f292946476cfe8d5e544a5325439a00e0165a5f9bf3bb6a53f477baeac7697cc0377745536681aa116f326ce911390 +8aecbbfd442a6a0f01c1c09db5d9d50213eb6f1ff6fab674cde3da06a4edff3ed317e804f78300c22ef70c336123e05d +834ed4b58211fcd647d7bf7c0a3ba9085184c5c856b085e8a0fcd5215c661ef43d36f3f0f6329a9f1370501b4e73b6e4 +a114ea5ad2b402a0de6105e5730907f2f1e458d28ae35144cf49836e0ad21325fe3e755cfb67984ae0a32e65402aad1e +a005f12bed97d71cee288b59afe9affb4d256888727343944a99913980df2c963fe02f218e6ea992f88db693a4498066 +a010f286ab06b966e3b91ff8f1bdbe2fe9ab41a27bc392d5787aa02a46e5080e58c62c7d907818caae9f6a8b8123e381 +857bd6df2ddef04dbc7c4f923e0b1696d3016c8bfed07fdfa28a3a3bd62d89b0f9df49aae81cbb6883d5e7b4fadae280 +b3927030da445bc4756ac7230a5d87412a4f7510581fb422212ce2e8cf49689aca7ba71678743af06d4de4914c5aa4a0 +b86403182c98fcce558d995f86752af316b3b2d53ba32075f71c7da2596747b7284c34a1a87de604fcc71e7e117a8add +98dd19b5527733041689b2a4568edaf6aa0fe1a3dd800c290cda157b171e053648a5772c5d3d4c80e5a795bc49adf12e +88a3c227bb7c9bff383f9ad3f7762245939a718ab85ae6e5e13180b12bf724d42054d3852b421c1cd1b3670baddecb63 +b3cfd9ad66b52bbe57b5fff0fad723434d23761409b92c4893124a574acc1e6b1e14b4ec507661551cbbe05e16db362e +923e1bb482cf421dd77801f9780f49c3672b88508a389b94015fd907888dc647ee9ea8ec8d97131d235d066daf1f42b7 +8d5e16240f04f92aa948181d421006bdbc7b215648fb6554193224d00cf337ebbb958f7548cf01b4d828acffb9fbc452 +8b2b8f18ad0559746f6cda3acca294a1467fb1a3bc6b6371bc3a61a3bfe59418934fa8706f78b56005d85d9cb7f90454 +a9316e2a94d6e31426d2ae7312878ba6baaac40f43e2b8a2fa3ab5a774c6918551554b2dbb23dc82f70ba3e0f60b5b0d +9593116d92cf06b8cd6905a2ce569ee6e69a506c897911f43ae80fc66c4914da209fc9347962034eebbc6e3e0fe59517 +887d89d2b2d3c82b30e8f0acf15f0335532bd598b1861755498610cb2dd41ff5376b2a0bb757cb477add0ce8cfe7a9fc +b514cfe17875ecb790ad055271cc240ea4bda39b6cfa6a212908849c0875cb10c3a07826550b24c4b94ea68c6bb9e614 +a563d5187966d1257d2ed71d53c945308f709bcc98e3b13a2a07a1933dc17bcb34b30796bd68c156d91811fbd49da2cb +a7195ccc53b58e65d1088868aeeb9ee208103e8197ad4c317235bb2d0ad3dc56cb7d9a7186416e0b23c226078095d44c +a838e7a368e75b73b5c50fbfedde3481d82c977c3d5a95892ac1b1a3ea6234b3344ad9d9544b5a532ccdef166e861011 +9468ed6942e6b117d76d12d3a36138f5e5fb46e3b87cf6bb830c9b67d73e8176a1511780f55570f52d8cdb51dcf38e8c +8d2fc1899bc3483a77298de0e033085b195caf0e91c8be209fd4f27b60029cbe1f9a801fbd0458b4a686609762108560 +8f4e44f8ca752a56aa96f3602e9234ad905ad9582111daf96a8c4d6f203bf3948f7ce467c555360ad58376ee8effd2ba +8fb88640b656e8f1c7c966c729eb2ba5ccf780c49873f8b873c6971840db7d986bdf1332ba80f8a0bb4b4ee7401468fa +b72aa3235868186913fb5f1d324e748cd3ce1a17d3d6e6ea7639a5076430fe0b08841c95feb19bb94181fe59c483a9eb +b8b102690ebb94fc4148742e7e3fd00f807b745b02cbe92cd92992c9143b6db7bb23a70da64a8b2233e4a6e572fc2054 +8c9ae291f6cd744e2c6afe0719a7fc3e18d79307f781921fb848a0bf222e233879c1eca8236b4b1be217f9440859b6ce +a658ede47e14b3aad789e07f5374402f60e9cacb56b1b57a7c6044ca2418b82c98874e5c8c461898ebd69e38fecd5770 +89c0cb423580e333923eb66bda690f5aca6ec6cba2f92850e54afd882ba608465a7dbb5aa077cd0ca65d9d00909348ab +aed8e28d98d5508bd3818804cf20d296fe050b023db2ed32306f19a7a3f51c7aaafed9d0847a3d2cd5ba5b4dabbc5401 +96a0fcd6235f87568d24fb57269a94402c23d4aa5602572ad361f3f915a5f01be4e6945d576d51be0d37c24b8b0f3d72 +935d0c69edd5dfa8ed07c49661b3e725b50588f814eb38ea31bcc1d36b262fae40d038a90feff42329930f8310348a50 +900518288aa8ea824c7042f76710f2ea358c8bb7657f518a6e13de9123be891fa847c61569035df64605a459dad2ecc8 +947d743a570e84831b4fb5e786024bd752630429d0673bf12028eb4642beb452e133214aff1cfa578a8856c5ebcb1758 +a787266f34d48c13a01b44e02f34a0369c36f7ec0aae3ec92d27a5f4a15b3f7be9b30b8d9dd1217d4eeedff5fd71b2e5 +a24b797214707ccc9e7a7153e94521900c01a1acd7359d4c74b343bfa11ea2cdf96f149802f4669312cd58d5ab159c93 +97f5ee9c743b6845f15c7f0951221468b40e1edaef06328653a0882793f91e8146c26ac76dd613038c5fdcf5448e2948 +80abd843693aed1949b4ea93e0188e281334163a1de150c080e56ca1f655c53eb4e5d65a67bc3fc546ed4445a3c71d00 +908e499eb3d44836808dacff2f6815f883aeced9460913cf8f2fbbb8fe8f5428c6fc9875f60b9996445a032fd514c70f +ae1828ef674730066dc83da8d4dd5fa76fc6eb6fa2f9d91e3a6d03a9e61d7c3a74619f4483fe14cddf31941e5f65420a +a9f4dbe658cd213d77642e4d11385a8f432245b098fccd23587d7b168dbeebe1cca4f37ee8d1725adb0d60af85f8c12f +93e20ee8a314b7772b2439be9d15d0bf30cd612719b64aa2b4c3db48e6df46cea0a22db08ca65a36299a48d547e826a7 +a8746a3e24b08dffa57ae78e53825a9ddbbe12af6e675269d48bff4720babdc24f907fde5f1880a6b31c5d5a51fbb00e +b5e94dfab3c2f5d3aea74a098546aa6a465aa1e3f5989377d0759d1899babf543ad688bb84811d3e891c8713c45886c5 +a3929bada828bd0a72cda8417b0d057ecb2ddd8454086de235540a756e8032f2f47f52001eb1d7b1355339a128f0a53b +b684231711a1612866af1f0b7a9a185a3f8a9dac8bde75c101f3a1022947ceddc472beb95db9d9d42d9f6ccef315edbc +af7809309edbb8eb61ef9e4b62f02a474c04c7c1ffa89543d8c6bf2e4c3d3e5ecbd39ec2fc1a4943a3949b8a09d315a6 +b6f6e224247d9528ef0da4ad9700bee6e040bbf63e4d4c4b5989d0b29a0c17f7b003c60f74332fefa3c8ddbd83cd95c1 +adbcec190a6ac2ddd7c59c6933e5b4e8507ce5fd4e230effc0bd0892fc00e6ac1369a2115f3398dfc074987b3b005c77 +8a735b1bd7f2246d3fa1b729aecf2b1df8e8c3f86220a3a265c23444bdf540d9d6fe9b18ed8e6211fad2e1f25d23dd57 +96b1bf31f46766738c0c687af3893d098d4b798237524cb2c867ed3671775651d5852da6803d0ea7356a6546aa9b33f2 +8036e4c2b4576c9dcf98b810b5739051de4b5dde1e3e734a8e84ab52bc043e2e246a7f6046b07a9a95d8523ec5f7b851 +8a4f4c32ee2203618af3bb603bf10245be0f57f1cfec71037d327fa11c1283b833819cb83b6b522252c39de3ce599fa5 +ad06ed0742c9838e3abaaffdb0ac0a64bad85b058b5be150e4d97d0346ed64fd6e761018d51d4498599669e25a6e3148 +8d91cb427db262b6f912c693db3d0939b5df16bf7d2ab6a7e1bc47f5384371747db89c161b78ff9587259fdb3a49ad91 +ae0a3f84b5acb54729bcd7ef0fbfdcf9ed52da595636777897268d66db3de3f16a9cf237c9f8f6028412d37f73f2dfad +8f774109272dc387de0ca26f434e26bc5584754e71413e35fa4d517ee0f6e845b83d4f503f777fe31c9ec05796b3b4bc +a8670e0db2c537ad387cf8d75c6e42724fae0f16eca8b34018a59a6d539d3c0581e1066053a2ec8a5280ffabad2ca51f +ac4929ed4ecad8124f2a2a482ec72e0ef86d6a4c64ac330dab25d61d1a71e1ee1009d196586ce46293355146086cabba +845d222cb018207976cc2975a9aa3543e46c861486136d57952494eb18029a1ebb0d08b6d7c67c0f37ee82a5c754f26f +b99fa4a29090eac44299f0e4b5a1582eb89b26ed2d4988b36338b9f073851d024b4201cd39a2b176d324f12903c38bee +9138823bc45640b8f77a6464c171af2fe1700bdc2b7b88f4d66b1370b3eafe12f5fbb7b528a7e1d55d9a70ca2f9fc8e6 +8ac387dc4cf52bc48a240f2965ab2531ae3b518d4d1f99c0f520a3d6eb3d5123a35ef96bed8fa71ee2f46793fa5b33b3 +864adec6339d4c2ba2525621fceabd4c455902f6f690f31a26e55413e0722e5711c509dc47ce0bcc27bbdc7651768d2d +a0a52edb72268a15201a968dabc26a22909620bda824bd548fb8c26cc848f704166ed730d958f0173bd3b0a672f367bd +949e445b0459983abd399571a1a7150aab3dd79f4b52a1cd5d733e436c71c1d4b74287c6b0ce6cc90c6711ba4c541586 +858966355dac11369e3b6552f2b381665181693d5a32e596984da3314021710b25a37d8c548b08700eea13d86cb22f21 +974bcbb8d38c5e6518745cc03ad436e585b61f31d705e7e2e5085da9655d768ac4d800904f892c3dab65d6223e3f1fd6 +8092b6506b01308bf6187fde5ebd4fa7448c9a640961ba231be22ac5fa2c7635ef01e8b357722c7695d09b723101ea2a +a5b8ef360bf28533ee17d8cd131fff661d265f609db49599085c0c7d83b0af409a1b5c28e3a5e5d7f8459a368aa121e8 +b031b6d5e3ceab0f0c93314b3b675f55cf18cbc86f70444af266fe39cb22fd7dad75d8c84e07f1c1bfa2cb8283e1361a +93ad489e4f74658320c1cceed0137c023d3001a2c930ed87e6a21dbf02f2eb6ad1c1d8bcb3739c85dcfbecb040928707 +b15e4ec2cdab0d34aec8d6c50338812eb6ecd588cf123a3e9d22a7ca23b5a98662af18289f09e6cdd85a39a2863c945c +b304f71a9717cf40c22073f942618b44bf27cd5e2ed4a386ad45d75b0fcb5a8dafd35158211eaf639495c6f1a651cedb +b82d78d3eaaa7c5101b7a5aae02bd4f002cd5802d18c3abcda0dd53b036661c6d3c8b79e0abe591eab90b6fdc5fef5e3 +abbd1884243a35578b80914a5084449c237ee4e4660c279d1073a4d4217d1b55c6b7e9c087dfd08d94ac1416273d8d07 +92f4b61c62502745e3e198ec29bca2e18696c69dcb914d1f3a73f4998d012b90caf99df46e9bb59942e43cce377fe8fd +906e79df98185820c8208844e1ba6bd86cb96965814b01310bd62f22cbec9b5d379b2ef16772d6fc45a421b60cfd68fe +a0eae2784ef596e2eb270dd40c48d6c508e4394c7d6d08d4cc1b56fde42b604d10ba752b3a80f2c4a737e080ef51b44f +94c084985e276dc249b09029e49a4ef8a369cd1737b51c1772fbb458d61e3fe120d0f517976eba8ffa5711ba93e46976 +83619a0157eff3f480ab91d1d6225fead74c96a6fd685333f1e8e4d746f6273e226bad14232f1d1168a274e889f202f1 +a724fe6a83d05dbbf9bb3f626e96db2c10d6d5c650c0a909415fbda9b5711c8b26e377201fb9ce82e94fa2ab0bf99351 +a8a10c1b91a3a1fa2d7fd1f78a141191987270b13004600601d0f1f357042891010717319489f681aa8a1da79f7f00d5 +a398a2e95b944940b1f8a8e5d697c50e7aa03994a8a640dfad4ea65cfb199a4d97861a3ec62d1c7b2b8d6e26488ca909 +a2eedfe5452513b2a938fffd560798ef81379c5a5032d5b0da7b3bb812addbaad51f564c15d9acbbfc59bb7eddd0b798 +ab31c572f6f145a53e13b962f11320a1f4d411739c86c88989f8f21ab629639905b3eedb0628067942b0dc1814b678ca +ad032736dd0e25652d3566f6763b48b34ea1507922ed162890cd050b1125ec03b6d41d34fccba36ec90336f7cdf788ed +83028a558a5847293147c483b74173eca28578186137df220df747fccd7d769528d7277336ea03c5d9cdd0bc5ae3d666 +ab5d182cd1181de8e14d3ef615580217c165e470b7a094a276b78a3003089123db75c6e1650bf57d23e587c587cd7472 +a4793e089fbdb1597654f43b4f7e02d843d4ab99ee54099c3d9f0bd5c0c5657c90bb076379a055b00c01b12843415251 +98bdc52ee062035356fb2b5c3b41673198ddc60b2d1e546cb44e3bb36094ef3c9cf2e12bbc890feb7d9b15925439d1ea +a4f90cca6f48024a0341bd231797b03693b34e23d3e5b712eb24aba37a27827319b2c16188f97c0636a0c115381dc659 +8888e6c2e4a574d04ba5f4264e77abc24ccc195f1a7e3194169b8a2ceded493740c52db4f9833b3dbf4d67a3c5b252cb +83dc4e302b8b0a76dc0292366520b7d246d73c6aebe1bdd16a02f645c082197bcff24a4369deda60336172cefbcf09af +a4eb2741699febfeb793914da3054337cc05c6fa00d740e5f97cb749ae16802c6256c9d4f0f7297dcdbb8b9f22fc0afa +8b65557d5be273d1cb992a25cfce40d460c3f288d5cb0a54bdef25cbd17cdea5c32ec966e493addf5a74fd8e95b23e63 +97c6577e76c73837bcb398b947cb4d3323d511141e0ddd0b456f59fbb1e8f920a5c20d7827a24309145efddee786140f +abcc0849ffe2a6a72157de907907b0a52deece04cf8317bee6fe1d999444b96e461eac95b6afde3d4fe530344086a625 +9385c0115cb826a49df1917556efa47b5b5e4022b6a0d2082053d498ec9681da904ecf375368bb4e385833116ea61414 +8b868c1841f0cdc175c90a81e610b0652c181db06731f5c8e72f8fafa0191620742e61a00db8215a991d60567b6a81ca +a8df15406f31b8fcf81f8ff98c01f3df73bf9ec84544ddec396bdf7fafa6fe084b3237bf7ef08ad43b26517de8c3cd26 +a9943d21e35464ce54d4cc8b135731265a5d82f9ccf66133effa460ffdb443cdb694a25320506923eede88d972241bf2 +a1378ee107dd7a3abcf269fd828887c288363e9b9ca2711377f2e96d2ed5e7c5ec8d3f1da995a3dcbedf1752d9c088fc +8a230856f9227b834c75bdebc1a57c7298a8351874bf39805c3e0255d6fd0e846f7ad49709b65ec1fd1a309331a83935 +877bcf42549d42610e1780e721f5800972b51ba3b45c95c12b34cb35eeaf7eac8fa752edd7b342411820cf9093fea003 +84c7a0b63842e50905624f1d2662506b16d1f3ea201877dfc76c79181c338b498eceb7cad24c2142c08919120e62f915 +8e18b1bd04b1d65f6ed349b5d33a26fe349219043ead0e350b50ae7a65d6ff5f985dd9d318d3b807d29faa1a7de4fe42 +8ea7b5a7503e1f0b3c3cd01f8e50207044b0a9c50ed1697794048bbe8efd6659e65134d172fb22f95439e1644f662e23 +b1954a2818cad1dad6d343a7b23afa9aa8ad4463edc4eb51e26e087c2010927535020d045d97d44086d76acdb5818cbf +a5271ea85d0d21fa1ff59b027cf88847c0f999bbf578599083ff789a9b5228bc161e1c81deb97e74db1a82a0afd61c50 +aa2fa4c05af3387e2c799315781d1910f69977ec1cfea57a25f1a37c63c4daaa3f0ecd400884a1673e17dd5300853bcf +b1cd2a74ca0b8e6090da29787aef9b037b03b96607983a308b790133bd21297b21ca4e2edec890874096dbf54e9d04c3 +801931607ec66a81272feaa984f0b949ad12d75ecf324ba96627bd4dc5ddead8ebf088f78e836b6587c2b6c0b3366b6c +95d79504710bdf0ad9b9c3da79068c30665818c2f0cdbba02cc0a5e46e29d596032ac984441b429bd62e34535c8d55b0 +9857d41e25e67876510ff8dadf0162019590f902da1897da0ef6fc8556e3c98961edb1eb3a3a5c000f6c494413ded15e +8740c9ffe6bd179c19a400137c3bd3a593b85bd4c264e26b4dfb9e2e17ac73e5b52dfacc1dcb4033cfc0cd04785f4363 +977f98f29d948b4097a4abdf9345f4c1fb0aa94ba0c6bf6faa13b76f3a3efc8f688e1fe96099b71b3e1c05041118c8d1 +a364422b1239126e3e8d7b84953ce2181f9856319b0a29fcab81e17ac27d35798088859c1cfc9fc12b2dbbf54d4f70b3 +a0f6ba637f0db7a48e07439bb92ddb20d590ce9e2ed5bab08d73aa22d82c32a9a370fe934cbe9c08aeb84b11adcf2e0e +a2c548641bd5b677c7748327cca598a98a03a031945276be6d5c4357b6d04f8f40dd1c942ee6ec8499d56a1290ac134d +9863e9cc5fbcdbd105a41d9778d7c402686bfd2d81d9ed107b4fda15e728871c38647529693306855bee33a00d257a7e +a54173bf47b976290c88fd41f99300135de222f1f76293757a438450880e6f13dbde3d5fe7afc687bdfbcfc4fbc1fc47 +b8db413917c60907b73a997b5ab42939abd05552c56a13525e3253eb72b83f0d5cc52b695968a10005c2e2fe13290e61 +a1f8388ef21697c94ba90b1a1c157f0dc138e502379e6fc5dc47890d284563e5db7716266e1b91927e5adf3cde4c0a72 +9949013a59d890eb358eab12e623b2b5edb1acbee238dfad8b7253102abc6173922e188d5b89ec405aa377be8be5f16d +a00fdb7710db992041f6ddb3c00099e1ce311dea43c252c58f560c0d499983a89de67803a8e57baa01ee9d0ee6fa1e44 +a8b1bcbed1951c9cdb974b61078412881b830b48cd6b384db0c00fa68bcc3f4312f8e56c892ea99d3511857ef79d3db9 +8f3ee78404edc08af23b1a28c2012cee0bdf3599a6cb4ea689fc47df4a765ef519191819a72562b91a0fbcdb896a937e +8155bbb7fa8d386848b0a87caae4da3dec1f3dade95c750a64a8e3555166ccc8799f638bd80ed116c74e3a995541587a +abfe30adbc0a6f1fd95c630ed5dac891b85384fa9331e86b83217f29dff0bd7cad19d328485715a7e3df9a19069d4d2f +89d0783e496ee8dbb695764b87fb04cee14d4e96c4ba613a19736971c577d312079048142c12ce5b32b21e4d491d281b +856b8dbc9c5d8f56b6bb7d909f339ca6da9a8787bba91f09130a025ab6d29b64dbf728ba6ed26e160a23c1cdb9bc037b +8a30dd2ea24491141047a7dfe1a4af217661c693edf70b534d52ca547625c7397a0d721e568d5b8398595856e80e9730 +ae7e1412feb68c5721922ed9279fb05549b7ef6812a4fd33dbbbd7effab756ab74634f195d0c072143c9f1fd0e1ee483 +b7ce970e06fa9832b82eef572f2902c263fda29fdce9676f575860aae20863046243558ede2c92343616be5184944844 +85ed0531f0e5c1a5d0bfe819d1aa29d6d5ff7f64ad8a0555560f84b72dee78e66931a594c72e1c01b36a877d48e017ca +b8595be631dc5b7ea55b7eb8f2982c74544b1e5befc4984803b1c69727eac0079558182f109e755df3fd64bee00fcaa5 +99e15a66e5b32468ef8813e106271df4f8ba43a57629162832835b8b89402eb32169f3d2c8de1eb40201ce10e346a025 +844c6f5070a8c73fdfb3ed78d1eddca1be31192797ad53d47f98b10b74cc47a325d2bc07f6ee46f05e26cf46a6433efb +974059da7f13da3694ad33f95829eb1e95f3f3bfc35ef5ef0247547d3d8ee919926c3bd473ab8b877ff4faa07fcc8580 +b6f025aecc5698f6243cc531782b760f946efebe0c79b9a09fe99de1da9986d94fa0057003d0f3631c39783e6d84c7d5 +b0c5358bc9c6dfe181c5fdf853b16149536fbb70f82c3b00db8d854aefe4db26f87332c6117f017386af8b40288d08f9 +a3106be5e52b63119040b167ff9874e2670bd059b924b9817c78199317deb5905ae7bff24a8ff170de54a02c34ff40a4 +ad846eb8953a41c37bcd80ad543955942a47953cbc8fb4d766eac5307892d34e17e5549dc14467724205255bc14e9b39 +b16607e7f0f9d3636e659e907af4a086ad4731488f5703f0917c4ce71a696072a14a067db71a3d103530920e1ec50c16 +8ed820e27116e60c412c608582e9bb262eaaf197197c9b7df6d62b21a28b26d49ea6c8bb77dfde821869d9b58025f939 +97bc25201d98cde389dd5c0c223a6f844393b08f75d3b63326343073e467ac23aacef630ddc68545ea874299ba4a3b4f +b73c9695ad2eefd6cc989a251c433fab7d431f5e19f11d415a901762717d1004bb61e0cc4497af5a8abf2d567e59fef4 +adaabe331eea932533a7cc0cf642e2a5e9d60bbc92dd2924d9b429571cbf0d62d32c207b346607a40643c6909b8727e2 +a7b1bbfe2a5e9e8950c7cb4daab44a40c3ffab01dc012ed7fe445f4af47fa56d774a618fafe332ab99cac4dfb5cf4794 +b4a3c454dcd5af850212e8b9ba5fe5c0d958d6b1cabbf6c6cfe3ccbc4d4c943309c18b047256867daf359006a23f3667 +a5c0b32f6cef993834c1381ec57ad1b6f26ae7a8190dd26af0116e73dadc53bb0eeb1911419d609b79ce98b51fdc33bc +ac2f52de3ecf4c437c06c91f35f7ac7d171121d0b16d294a317897918679f3b9db1cef3dd0f43adb6b89fe3030728415 +94722ae6d328b1f8feaf6f0f78804e9b0219de85d6f14e8626c2845681841b2261d3e6a2c5b124086b7931bf89e26b46 +a841a0602385d17afabca3a1bb6039167d75e5ec870fea60cfcaec4863039b4d745f1a008b40ec07bca4e42cb73f0d21 +8c355f0a1886ffced584b4a002607e58ff3f130e9de827e36d38e57cb618c0cb0b2d2dea2966c461cb3a3887ede9aef1 +a6a9817b0fc2fd1786f5ba1a7b3d8595310987fb8d62f50a752c6bb0b2a95b67d03a4adfd13e10aa6190a280b7ee9a67 +a1d2e552581ecbafeaef08e389eaa0b600a139d446e7d0648ac5db8bbbf3c438d59497e3a2874fc692b4924b87ff2f83 +a1b271c55389f25639fe043e831e2c33a8ba045e07683d1468c6edd81fedb91684e4869becfb164330451cfe699c31a8 +8c263426e7f7e52f299d57d047a09b5eeb893644b86f4d149535a5046afd655a36d9e3fdb35f3201c2ccac2323a9582e +b41c242a7f7880c714241a97d56cce658ee6bcb795aec057a7b7c358d65f809eb901e0d51256826727dc0dc1d1887045 +93001b9445813c82f692f94c0dc1e55298f609936b743cf7aae5ebfa86204f38833d3a73f7b67314be67c06a1de5682d +82087536dc5e78422ad631af6c64c8d44f981c195ddea07d5af9bb0e014cdc949c6fa6e42fce823e0087fdb329d50a34 +8e071861ceba2737792741c031f57e0294c4892684506b7c4a0fc8b2f9a0a6b0a5635de3d1e8716c34df0194d789ae86 +b471c997e1e11774bd053f15609d58838a74073a6c089a7a32c37dd3f933badf98c7e5833263f3e77bc0d156a62dd750 +8d2d8686fb065b61714414bb6878fff3f9e1e303c8e02350fd79e2a7f0555ded05557628152c00166ce71c62c4d2feaa +ae4c75274d21c02380730e91de2056c0262ffcecf0cbdb519f0bdb0b5a10ae2d4996b3dc4b3e16dbaea7f0c63d497fef +97140d819e8ca6330e589c6debdee77041c5a9cedb9b8cbd9c541a49207eeb7f6e6b1c7e736ec8ba6b3ab10f7fcd443a +af6659f31f820291a160be452e64d1293aa68b5074b4c066dac169b8d01d0179139504df867dc56e2a6120354fc1f5be +a5e5d8088a368024617bfde6b731bf9eee35fc362bed3f5dfdd399e23a2495f97f17728fec99ca945b3282d1858aa338 +a59cfc79d15dbdde51ab8e5129c97d3baba5a0a09272e6d2f3862370fdbaf90994e522e8bd99d6b14b3bb2e9e5545c6f +a30499b068083b28d6c7ddcc22f6b39b5ec84c8ee31c5630822c50ea736bb9dca41c265cffc6239f1c9ef2fd21476286 +88ffe103eca84bbe7d1e39a1aa599a5c7c9d5533204d5c4e085402a51441bb8efb8971efe936efbbfa05e5cb0d4b8017 +b202356fbf95a4d699154639e8cb03d02112c3e0128aab54d604645d8510a9ba98936028349b661672c3a4b36b9cb45d +8b89bb6574bf3524473cff1ff743abcf1406bd11fb0a72070ccd7d8fce9493b0069fb0c6655252a5164aee9e446ea772 +93247b1038fa7e26667ee6446561d4882dc808d1015daafb705935ddc3598bb1433182c756465960480f7b2de391649e +b027f94d3358cbb8b6c8c227300293a0dee57bf2fee190a456ad82ecfb6c32f8090afa783e2ab16f8139805e1fb69534 +a18bb1849b2f06c1d2214371031d41c76ffa803ee3aa60920d29dbf3db5fbfac2b7383d5d0080ba29ce25c7baa7c306b +827bf9fd647e238d5ac961c661e5bbf694b4c80b3af8079f94a2484cb8fba2c8cf60e472ebcd0b0024d98ae80ad2ff5a +838e891218c626a7f39b8fd546b013587408e8e366ecc636b54f97fa76f0a758bc1effa1d0f9b6b3bc1a7fcc505970a0 +836523b5e8902d6e430c6a12cff01e417d2bd7b402e03904034e3b39755dee540d382778c1abe851d840d318ebedce7f +850a77dda9ac6c217e2ef00bf386a1adec18b7f462f52801c4f541215690502a77ef7519b690e22fdf54dc2109e0ca38 +a8265c6ae7b29fc2bda6a2f99ced0c1945dd514b1c6ca19da84b5269514f48a4f7b2ccbab65c9107cfd5b30b26e5462f +ab3d02ee1f1267e8d9d8f27cc388e218f3af728f1de811242b10e01de83471a1c8f623e282da5a284d77884d9b8cde0e +831edaf4397e22871ea5ddee1e7036bab9cc72f8d955c7d8a97f5e783f40532edbbb444d0520fefcffeab75677864644 +80484487977e4877738744d67b9a35b6c96be579a9faa4a263e692295bb6e01f6e5a059181f3dd0278e2c3c24d10a451 +aae65a18f28c8812617c11ecf30ad525421f31fb389b8b52d7892415e805a133f46d1feca89923f8f5b8234bd233486a +b3a36fd78979e94288b4cefed82f043a7e24a4a8025479cc7eb39591e34603048a41ee606ee03c0b5781ebe26a424399 +b748b3fc0d1e12e876d626a1ba8ad6ad0c1f41ea89c3948e9f7d2666e90173eb9438027fadcd741d3ae0696bd13840f1 +acdd252d7c216c470683a140a808e011c4d5f1b4e91aeb947f099c717b6a3bad6651142cde988330827eb7d19d5fb25c +b9a25556a6ca35db1ed59a1ec6f23343eab207a3146e4fc3324136e411c8dba77efd567938c63a39c2f1c676b07d8cdb +a8db6aef8f5680d2bdb415d7bcaae11de1458678dcb8c90c441d5986c44f83a9e5855662d0c1aace999172d8628d8fe1 +af58147108e9909c3a9710cc186eab598682dca4bfd22481e040b8c000593ecb22c4ede4253ac9504e964dfa95a9b150 +8dd8bb70f1c9aec0fcc9478f24dfc9c3c36c0bf5ff7a67c017fa4dab2ec633fbd7bc9d8aa41ea63e2696971ed7e375f5 +aa98d600b22aff993a4d7a3ccabd314e1825b200cb598f6b797d7e4d6a76d89e34a4d156c06bddfc62f2ef9b4c809d1d +8a8fc960d6c51294b8205d1dabe430bef59bda69824fa5c3c3105bef22ac77c36d2d0f38ffc95ce63731de5544ccbeff +b6d1020efe01dc8032bd1b35e622325d7b9af9dcd5c9c87c48d7d6ebc58644454294c59b7f4b209204b5b1f899f473bf +8a750dc9fe4891f2dfe5759fb985939810e4cdc0b4e243ff324b6143f87676d8cb4bcb9dfb01b550801cedcaaa5349e2 +98c13142d3a9c5f8d452245c40c6dae4327dd958e0fda85255ea0f87e0bcbaa42a3a0bd50407ed2b23f9f6317a8a4bc5 +99f2b83d9ec4fc46085a6d2a70fd0345df10f4a724c1ba4dee082a1fde9e642e3091992ebf5f90a731abcb6ec11f6d9b +b218546ab2db565b2489ea4205b79daa19ef2acbf772ccaaa5e40150e67ea466090d07198444b48e7109939aa2319148 +84f9d1d868e4b55e535f1016558f1789df0daa0ead2d13153e02f715fe8049b1ce79f5bc1b0bbbb0b7e4dd3c04783f3f +80d870d212fbddfdda943e90d35a5a8aa0509a7a1e7f8909f2fcb09c51c3026be47cc7a22620a3063406872105b4f81a +b5b15138ff6551fac535d4bbce2ea6adc516b6b7734b4601c66ec029da2615e3119dc9ad6a937344acfd7b50e4a1a2ae +95d2f97652086e7ceb54e1d32692b1c867ffba23c4325740c7f10d369283d1b389e8afa0df967831ade55696931e7934 +8a5b580403e1a99cd208f707e8ce0d3f658c8280417683f69008d09cc74d835a85f7380f391b36ead9ac66d9eedd1cbe +a8b0c90bff34c86720637b5a2081f0f144cfe2205c1176cacd87d348609bc67af68aed72414dc9aa6f44a82c92c2a890 +865abbdd96c496892c165a8de0f9e73348bf24fce361d7a9048710178a3625881afb0006e9f5ee39124866b87904c904 +ace67bb994adef4b6f841cdf349195608030044562780a7e9b00b58a4ff117268a03ff01e5a3a9d9d7eff1dd01f5f4bf +b9371d59185b3d2d320d3fefeadb06ba2aa7d164352fb8dc37571509509fa214d736d244ac625a09a033a10d51611e2e +a8ef992771422dcf2d6d84386fde9fe5dba88bfded3dfcd14074ca04331b4fd53a7f316615cdfaf10ed932cbb424a153 +868cbc75f8f789ea45eded2768a1dac0763347e0d8e8028d316a21005f17be179d26d5965903e51b037f2f57fe41765d +b607111bcdfd05fa144aa0281b13ee736079ebbbf384d938a60e5e3579639ed8ef8eb9ca184868cdb220a8e130d4a952 +aca55702af5cae4cae65576769effd98858307a71b011841c563b97c2aa5aeb5c4f8645d254f631ed1582df3dbbf17da +b9b5cbace76246e80c20dfcc6f1e2c757a22ab53f7fd9ff8a1d309538b55174e55e557a13bf68f095ff6a4fa637ef21a +8571b0a96871f254e2397c9be495c76379faf347801cb946b94e63212d6a0da61c80e5d7bebbabcd6eaa7f1029172fe5 +902540326281e6dc9c20d9c4deaaf6fbbbcc3d1869bd0cf7f081c0525bea33df5cfa24ead61430fda47fb964fcc7994b +841af09279d3536a666fa072278950fabf27c59fc15f79bd52acb078675f8087f657929c97b4bc761cbade0ecb955541 +a1f958b147ddf80ab2c0746ba11685c4bae37eb25bfa0442e7e1078a00d5311d25499da30f6d168cb9302ea1f2e35091 +863d939381db37d5a5866964be3392a70be460f0353af799d6b3ed6307176972686bd378f8ad457435a4094d27e8dfb7 +835cd4d7f36eff553d17483eb6c041b14280beb82c7c69bca115929658455a1931212976c619bafb8179aed9940a8cc6 +8d0770e3cb8225e39c454a1fc76954118491b59d97193c72c174ecc7613051e5aed48a534016a8cf0795c524f771a010 +91aa4edb82f6f40db2b7bd4789cc08786f6996ebed3cb6f06248e4884bc949793f04a4c5ea6eefe77984b1cc2a45d699 +8fb494ca2449f659ff4838833507a55500a016be9293e76598bbae0a7cb5687e4693757c2b6d76e62bd6c7f19ed080bb +b59b104449a880a282c1dd6a3d8debb1d8814ef35aab5673c1e500ee4cb0e840fb23e05fa5a0af92509c26b97f098f90 +aca908e3bad65e854ae6be6c5db441a06bcd47f5abafdfa8f5a83c8cd3c6e08c33cab139c45887887a478338e19ceb9f +806f5d802040313a31964fc3eb0ee18ac91b348685bed93c13440984ee46f3d2da7194af18c63dea4196549129660a4e +ae4b2dca75c28d8f23b3ab760b19d839f39ff5a3112e33cb44cff22492604a63c382b88ec67be4b0266924dd438c3183 +99d1c29c6bd8bf384e79cd46e30b8f79f9cbc7d3bf980e9d6ffba048f0fc487cac45c364a8a44bb6027ad90721475482 +a16e861c1af76d35528c25bf804bfc41c4e1e91b2927d07d8e96bffe3a781b4934e9d131ecf173be9399800b8269efac +a253303234fb74f5829060cdcef1d98652441ab6db7344b1e470d195a95722675988048d840201c3b98e794b1e8b037c +905ac8a0ea9ce0eb373fb0f83dd4cbe20afb45b9d21ae307846fd4757d4d891b26a6711924e081e2b8151e14a496da18 +b485315791e775b9856cc5a820b10f1fa5028d5b92c2f0e003ba55134e1eddb3eb25f985f2611a2257acf3e7cfdfab5e +b6189c0458b9a043ebc500abc4d88083a3487b7ac47ed5e13ab2a41e0a1bee50d54a406063f92bc96959f19e822a89a7 +a30e15f995fd099a223fc6dc30dad4b8d40bee00caa2bc3223ba6d53cd717c4968a3e90c4618c711ed37cc4cd4c56cf3 +a1b1ed07fcc350bb12a09cd343768d208fc51a6b3486f0ece8f5a52f8a5810b4bc7ab75582ec0bc2770aed52f68eace5 +88aa739fbae4bece147ba51a863e45d5f7203dbc3138975dc5aef1c32656feb35f014d626e0d5b3d8b1a2bda6f547509 +ab570f3c8eabfca325b3a2ea775ef6b0c6e6138c39d53c2310329e8fb162869fde22b0e55688de9eb63d65c37598fca3 +89d274762c02158e27cb37052e296a78f2b643eb7f9ae409f8dac5c587d8b4d82be4ef7c79344a08ebec16ac4a895714 +99c411d2ad531e64f06e604d44c71c7c384424498ecd0a567d31ec380727fb605af76643d0d5513dd0a8d018076dd087 +80d0777fa9f79f4a0f0f937d6de277eec22b3507e2e398f44b16e11e40edf5feff55b3b07a69e95e7e3a1621add5ed58 +b2430a460783f44feb6e4e342106571ef81ad36e3ddd908ec719febeb7acaf4b833de34998f83a1dab8f0137a3744c11 +b8f38ccfc7279e1e30ad7cefc3ea146b0e2dff62430c50a5c72649a4f38f2bac2996124b03af2079d942b47b078cc4f8 +a178a450a62f30ec2832ac13bbc48789549c64fc9d607b766f6d7998558a0e2fad007ae0148fc5747189b713f654e6ba +98c5ede296f3016f6597f7ccc5f82c88fd38ed6dc3d6da3e4a916bfd7c4c95928722a1d02534fe89387c201d70aa6fd2 +a8cc5e98573705d396576e022b2ba2c3e7c7ece45cd8605cb534b511763682582299e91b4bb4100c967019d9f15bbfaf +848480ea7b7d9536e469da721236d932870b7bbee31ccf7ae31b4d98d91413f59b94a1e0d1786ee7342295aa3734969c +b88ea38f9ee432f49e09e4e013b19dff5a50b65453e17caf612155fff6622198f3cba43b2ea493a87e160935aaaf20a9 +949376934a61e0ef8894339c8913b5f3b228fa0ae5c532ad99b8d783b9e4451e4588541f223d87273c0e96c0020d5372 +96f90bb65ca6b476527d32c415814b9e09061648d34993f72f28fae7dc9c197e04ef979f804076d107bb218dfd9cb299 +a4402da95d9942c8f26617e02a7cef0ebc4b757fac72f222a7958e554c82cc216444de93f659e4a1d643b3e55a95d526 +81179cbc26a33f6d339b05ea3e1d6b9e1190bd44e94161ae36357b9cdf1e37d745d45c61735feed64371fe5384102366 +ad4dc22bdbd60e147fdac57d98166de37c727f090059cfc33e5ee6cf85e23c2643996b75cf1b37c63f3dc9d3c57ffa18 +8a9b1b93dc56e078ce3bb61c2b0088fd6c3e303ba6b943231cc79d4a8e8572f4109bbde5f5aa7333aae3287909cb0fe2 +8876ef583bc1513322457a4807d03381ba1f4d13e179260eaa3bddfede8df677b02b176c6c9f74c8e6eab0e5edee6de6 +b6c67e228bf190fbaeb2b7ec34d4717ce710829c3e4964f56ebb7e64dc85058c30be08030fa87cc94f1734c5206aef5f +a00cb53b804ee9e85ce12c0103f12450d977bc54a41195819973c8a06dcb3f46f2bf83c3102db62c92c57ab4dd1e9218 +a7675a64772eefddf8e94636fb7d1d28f277074327c02eea8fae88989de0c5f2dc1efed010f4992d57b5f59a0ab40d69 +8d42bb915e0bf6a62bcdf2d9330eca9b64f9ec36c21ae14bf1d9b0805e5e0228b8a5872be61be8133ad06f11cb77c363 +a5b134de0d76df71af3001f70e65c6d78bed571bc06bfddf40d0baad7ea2767608b1777b7ef4c836a8445949877eeb34 +aeadbc771eaa5de3a353229d33ed8c66e85efbd498e5be467709cb7ff70d3f1a7640002568b0940e3abd7b2da81d2821 +8c28da8e57a388007bd2620106f6226b011ee716a795c5d9f041c810edf9cf7345b2e2e7d06d8a6b6afa1ee01a5badc1 +8ed070626a4d39ffd952ddb177bc68fd35b325312e7c11694c99b691f92a8ea7734aeb96cf9cc73e05b3c1b1dcad6978 +ada83e18e4842f3d8871881d5dbc81aed88a1328298bfdc9e28275094bd88d71b02e7b8501c380fa8d93096cbc62f4fb +8befc3bec82dcf000a94603b4a35c1950ba5d00d4bed12661e4237afa75062aa5dcef8eac0b9803136c76d2dd424a689 +97c6f36c91ca5ca9230bfcbf109d813728b965a29b62e5f54c8e602d14a52ac38fa1270de8bfe1ab365426f3fc3654c7 +b01d192af3d8dbce2fe2fece231449e70eb9ac194ec98e758da11ca53294a0fa8c29b1d23a5d9064b938b259ea3b4fb5 +819a2c20646178f2f02865340db1c3c6ebc18f4e6559dd93aa604388796a34bd9fed28ad3ccc8afc57a5b60bb5c4e4ec +a9ffc877470afc169fecf9ec2dc33253b677371938b0c4ffa10f77bb80089afa2b4488437be90bb1bcf7586a6f4286e3 +b533051c7ce7107176bcb34ad49fdb41fac32d145854d2fe0a561c200dcf242da484156177e2c8f411c3fdf1559ecf83 +8fe2caff2e4241d353110a3618832f1443f7afe171fd14607009a4a0aa18509a4f1367b67913e1235ac19de15e732eb1 +84705c6370619403b9f498059f9869fdf5f188d9d9231a0cb67b1da2e8c906ead51b934286497293698bba269c48aa59 +899dddf312a37e3b10bdaaacc1789d71d710994b6ee2928ac982ad3fd8a4f6167672bc8bf3419412711c591afe801c28 +b2f7916d946b903ded57b9d57025386143410a41a139b183b70aeca09cf43f5089ead1450fce4e6eb4fba2c8f5c5bbe5 +8d5f742fe27a41623b5820914c5ca59f82246010fa974304204839880e5d0db8bc45ebab2ad19287f0de4ac6af25c09e +b93d4a1f6f73ac34da5ffbd2a4199cf1d51888bc930dc3e481b78806f454fcb700b4021af7525b108d49ebbbaa936309 +8606f8d9121512e0217a70249937e5c7f35fbfe019f02248b035fa3a87d607bc23ae66d0443e26a4324f1f8e57fd6a25 +b21312cdec9c2c30dd7e06e9d3151f3c1aceeb0c2f47cf9800cce41521b9d835cb501f98b410dc1d49a310fdda9bc250 +a56420b64286bdddda1e212bba268e9d1ba6bdb7132484bf7f0b9e38099b94a540884079b07c501c519b0813c184f6b4 +80b2cf0e010118cb2260f9c793cef136f8fa7b5e2711703735524e71d43bce2d296c093be41f2f59118cac71f1c5a2ff +adcb12d65163804d2f66b53f313f97152841c3625dbbda765e889b9937195c6fcd55d45cc48ebffabb56a5e5fe041611 +8b8a42e50dc6b08ab2f69fc0f6d45e1ea3f11ba0c1008ee48448d79d1897356599e84f7f9d8a100329ed384d6787cfc4 +aaa9c74afa2dec7eccfbd8bb0fc6f24ed04e74c9e2566c0755a00afdfdf3c4c7c59e2a037ec89c2f20af3fae1dd83b46 +aa9f6e8fd59187171c6083ae433627d702eb78084f59010ff07aff8f821f7022ef5fbbe23d76814d811b720a8bfa6cc3 +a56a3ded501659ad006d679af3287080b7ee8449e579406c2cae9706ef8bf19c1fc2eb2a6f9eaf2d3c7582cded73e477 +81971e077c1da25845840222b4191e65f6d242b264af4e86800f80072d97d2a27a6adc87c3a1cb1b0dd63d233fbafa81 +a6fa5453c4aaad2947969ee856616bf6448224f7c5bf578f440bcfc85a55beb40bef79df8096c4db59d1bd8ef33293ea +87c545adbfaaf71e0ab4bac9ae4e1419718f52b0060e8bb16b33db6d71b7248ae259d8dd4795b36a4bbb17f8fae9fd86 +b4c7a9bc0910e905713291d549cec5309e2d6c9b5ea96954489b1dff2e490a6c8b1fa1e392232575f0a424ba94202f61 +802350b761bcaba21b7afe82c8c6d36ee892b4524ab67e2161a91bbfa1d8e92e7e771efb1f22c14126218dd2cb583957 +b4e7ddb9143d4d78ea8ea54f1c908879877d3c96ee8b5e1cb738949dcfceb3012a464506d8ae97aa99ea1de2abf34e3d +a49a214065c512ad5b7cc45154657a206ef3979aa753b352f8b334411f096d28fd42bca17e57d4baaafb014ac798fc10 +8a80c70a06792678a97fe307520c0bf8ed3669f2617308752a2ab3c76fdf3726b014335a9b4c9cbcfc1df3b9e983c56f +a34721d9e2a0e4d08995a9d986dc9c266c766296d8d85e7b954651ad2ca07e55abb1b215898ee300da9b67114b036e0d +8cfce4564a526d7dca31e013e0531a9510b63845bbbd868d5783875ed45f92c1c369ce4a01d9d541f55f83c2c0a94f03 +ab3f5f03a5afc727778eb3edf70e4249061810eba06dc3b96b718e194c89429c5bfbec4b06f8bce8a2118a2fdce67b59 +aa80c2529fc19d428342c894d4a30cb876169b1a2df81a723ab313a071cba28321de3511a4de7846207e916b395abcc9 +82b7828249bf535ef24547d6618164b3f72691c17ca1268a5ee9052dba0db2fdd9987c8e083307a54399eab11b0f76b1 +8fbcb56b687adad8655a6cf43364a18a434bf635e60512fad2c435cf046f914228fb314f7d8d24d7e5e774fb5ffb1735 +a3010a61a2642f5ebbce7b4bc5d6ecb3df98722a49eb1655fe43c1d4b08f11dfad4bcec3e3f162d4cc7af6a504f4d47c +b3dcc0fdf531478e7c9ef53190aa5607fd053a7d2af6c24a15d74c279dbb47e3c803a1c6517d7e45d6534bb59e3527f5 +8648f6316c898baaca534dff577c38e046b8dfa8f5a14ee7c7bc95d93ae42aa7794ba0f95688a13b554eeb58aeedf9ba +89fca6fc50407695e9315483b24f8b4e75936edf1475bcf609eed1c4370819abac0e6a7c3c44f669560367d805d9ba63 +a367a17db374f34cd50f66fb31ba5b7de9dbe040f23db2dcc1d6811c0e863606f6c51850af203956f3399000f284d05f +91030f9ca0fff3e2dbd5947dcf2eba95eb3dbca92ee2df0ed83a1f73dbf274611af7daf1bb0c5c2ee46893ab87013771 +84d56181f304ce94015ea575afeef1f84ea0c5dbb5d29fb41f25c7f26077b1a495aff74bd713b83bce48c62d7c36e42d +8fe2f84f178739c3e2a2f7dcac5351c52cbed5fa30255c29b9ae603ffd0c1a181da7fb5da40a4a39eec6ce971c328fcf +a6f9b77b2fdf0b9ee98cb6ff61073260b134eb7a428e14154b3aa34f57628e8980c03664c20f65becfe50d2bdd2751d4 +8c6760865445b9327c34d2a1247583694fbeb876055a6a0a9e5cb460e35d0b2c419e7b14768f1cc388a6468c94fd0a0f +af0350672488a96fe0089d633311ac308978a2b891b6dbb40a73882f1bda7381a1a24a03e115ead2937bf9dcd80572ad +a8e528ec2ee78389dd31d8280e07c3fdd84d49556a0969d9d5c134d9a55cd79e1d65463367b9512389f125ed956bc36a +942c66589b24f93e81fe3a3be3db0cd4d15a93fb75260b1f7419f58d66afaa57c8d2d8e6571536790e2b415eec348fd9 +83fe4184b4b277d8bf65fb747b3c944170824b5832751057e43465526560f60da6e5bbee2f183cb20b896a20197168c7 +88a71aada494e22c48db673d9e203eef7a4e551d25063b126017066c7c241ee82bedaa35741de4bd78a3dd8e21a8af44 +8c642a3186ca264aac16ee5e27bd8da7e40e9c67ae159b5d32daa87b7de394bf2d7e80e7efb1a5506c53bfd6edd8c2c3 +81855d6de9a59cef51bef12c72f07f1e0e8fe324fcc7ec3f850a532e96dcd434c247130610aaee413956f56b31cbb0dc +a01e61390dcd56a58ad2fcdb3275704ddfbedef3ba8b7c5fce4814a6cdd03d19d985dba6fd3383d4db089444ea9b9b4d +96494e89cbf3f9b69488a875434302000c2c49b5d07e5ff048a5b4a8147c98291ae222529b61bb66f1903b2e988e5425 +b9689b3e8dddc6ec9d5c42ba9877f02c1779b2c912bba5183778dc2f022b49aed21c61c8ec7e3c02d74fe3f020a15986 +a2a85e213b80b0511395da318cbb9935c87b82c305f717a264155a28a2ea204e9e726bae04ce6f012e331bd6730cbb9d +91b70f44c7d8c5980ce77e9033a34b05781cbe773854d3f49d2905cc711a3d87c20d5d496801ad6fd82438874ce732b8 +884596417ff741bb4d11925d73852ffeea7161c7f232be3bdce9e6bbe7884c3a784f8f1807356ae49d336b7b53a2b495 +ae2aed8ab6951d8d768789f5bc5d638838d290d33ccc152edfb123e88ba04c6272b44294b0c460880451ad7b3868cc6a +89d8ebfb9beebc77189d27de31c55f823da87798a50bca21622cbf871e5d9f1d3182cf32ee9b90f157e6ce298e9efccf +afd00a4db4c2ed93cf047378c9402914b6b3255779f3bb47ded4ab206acb7eaebba0fd7762928e681b1aebcfee994adc +a2e49b6cd32e95d141ebc29f8c0b398bb5e1a04945f09e7e30a4062142111cd7aa712ac0e3e6394cfb73dd854f41ad77 +ae8e714ab6e01812a4de5828d84060f626358bb2b955f6fb99ae887b0d5ce4f67ebc079ab9e27d189bf1d3f24f7c2014 +a3100c1eebf46d604e75ebf78569c25acf938d112b29ccbe1a91582f6bd8ef5548ae3961c808d3fb73936ac244e28dbc +a9a02dcff0e93d47ead9cdddc4759971c2d848580bf50e117eb100cafca6afeaa7b87208513d5f96b1e1440ffc1b0212 +894ab01462137e1b0db7b84920a3b677fbb46c52b6f4c15320ef64f985e0fc05cec84cd48f389ce039779d5376966ea3 +b1e40e8399ee793e5f501c9c43bde23538e3ce473c20a9f914f4a64f5b565748d13ab2406efe40a048965ee4476113e4 +a5a7d97a19e636238968670a916d007bf2ce6ae8e352345d274101d0bbe3ac9b898f5b85814a7e4c433dd22ac2e000ff +b6394c43b82923231d93fd0aa8124b757163ba62df369898b9481f0118cb85375d0caac979a198ece432dbb4eb7cc357 +82d522ae3ff4fe2c607b34b42af6f39c0cf96fcfe1f5b1812fca21c8d20cece78376da86dcbd6cdb140e23c93ae0bcb2 +b6e0d986383bc4955508d35af92f2993e7e89db745f4525948c5274cfd500880cb5a9d58a5b13d96f6368bb266a4433e +b0b4325772ec156571d740c404e1add233fb693579f653b0fae0042b03157d3b904838f05c321d2d30f2dbd27c4d08ad +ac41367250263a2099006ef80c30bac1d2f25731d4874be623b6e315c45b0dc9a65f530fce82fb3dc25bd0610008c760 +b6c0b1ed7df53da04a6f3e796d3bfa186f9551c523bc67898bc0ecfc6b4a4a22f8c4d3bfc740ebf7b9fa5b0ea9431808 +8e78fca17346601219d01e5cd6a4837161a7c8f86fe2a8d93574d8006da5f06ae7c48eea7d2b70992c2a69184619663c +a21f91f47e04fafbfafacf3185b6863766a2d0c324ccac2c3853a4748af5897dbbe31d91473b480f646121339c9bae2d +a464d68786ab1fc64bd8734fce0be6fbe8dc021d3e771ff492ada76eedff466577c25e282b7c8ab4c1fd95ef5ff3631e +829a24badc7714081e03509ccfb00818ce40430682c1c0e4a399cd10b690bda1f921aabcbf1edfb1d8a2e98e6c0cedd6 +87ccf7e4bbcb818ef525435e7a7f039ecbb9c6670b0af163173da38cbdb07f18bc0b40b7e0c771a74e5a4bc8f12dfe2c +94087bd2af9dbeb449eb7f014cfbf3ee4348c0f47cde7dc0ad401a3c18481a8a33b89322227dee0822244965ae5a2abb +896b83ed78724dac8a3d5a75a99de8e056a083690152c303326aa833618b93ef9ec19ab8c6ef0efe9da2dbcccac54431 +821e6a0d7ccf3c7bd6a6cc67cde6c5b92fb96542cb6b4e65a44bbc90bbc40c51ff9e04702cb69dd2452f39a2ff562898 +b35b2096cda729090663a49cb09656c019fef1fc69a88496028d3a258ad2b3fd6d91ab832163eaa0077989f647e85e7e +b7857ef62c56d8bce62476cdb2ab965eddff24d932e20fc992bd820598686defe6cc0a7232d2be342696c2990d80721a +b343d974dfda3f6589043acd25d53aecf7c34b1e980ae135a55cda554ff55e531bc7c2dfe89b0d2c30e523c7b065dad1 +8d139e16a73cd892b75f3f4e445a10d55d1118f8eeafc75b259d098338419e72e950df6ca49cb45677a3c4e16fb19cdc +817b8535bd759da392b2c5760c51b3952ecf663662a137c997f595c533cd561ed7e655673c11144242160e41d1f2dd71 +817ee0f0819b0ccb794df17982d5b4332abff5fec5e23b69579db2767855642156d9b9acccf6ceab43332ccc8d2744dc +9835d2b652aec9b0eba0c8e3b6169567e257a6a3f274ec705dbc250ee63f0f8e4b342e47b9e0c280c778208483d47af8 +b78c40177f54f0e6d03083a4f50d8e56b5aafdb90f1b047bb504777d6e27be5a58170330aee12fbaa5f1e9d4f944acfc +ab8eebacf3806fac7ab951f6a9f3695545e2e3b839ca399a4ef360a73e77f089bb53d3d31dbd84ddfde55e5f013626e0 +96c411fc6aecca39d07d2aff44d94b40814d8cfc4ee5a192fd23b54589b2801694d820a0dd217e44863ccff31dda891b +8249c424a0caf87d4f7ff255950bbc64064d4d1b093324bfe99583e8457c1f50e6996e3517bf281aa9b252c2a7c5a83a +acf6ed86121821a3dd63f3875b185c5ebe024bdb37878c8a8d558943d36db0616545a60db90789c0925295f45d021225 +a37f155621a789f774dd13e57016b8e91b3a2512b5c75377ec8871b22a66db99655d101f57acaecd93115297caabfc21 +92e60ee245bd4d349f1c656e034b1a7f0c6415a39ac4c54d383112734305488b3b90b0145024255735e0a32f38dba656 +acec614e562ccfc93366309cfdc78c7d7ee0a23e3a7782a4fc4807b8803e6ebfb894a489d03e9a3c817ff2ec14813eba +b912f9dd26ed552cb14b007b893e6ed2494d12517e5761dbeb88521270144f8c3eb9571a0ad444b30a8a65e80bd95996 +8375408dae79c547a29e9a9e5d4ec8241b36b82e45e4ca3b0c36d2227c02d17bb171528d3778eac3bbdc75d6c4e8a367 +8c2d0e6e4406836da112edbbb63996408bb3cda4a2712fd245e4bb29a0100fdc89a2746d859b84a94565bc1cfa681813 +a7431bf59e111c072d28c97626cd54fcdf018421d053a787d2aef454b91251ee8ff9d3702d06b088f92b9ad2bbebff15 +8f3659b0fbeb90b7f30b7a49233325e806551a32911a654dca86e290b314483bbb33fe6482387bc48c35d85c1dd0441c +8dca5ba23f0bb76f7dacabf12886053552ba829a72827b472a2f01e19a893155cdce65f1fb670000f43e8c75ba015a31 +8c1514c083c77624eeb5d995d60994a2866192e15c4474d0be4189fae0e9dbd62494ebb4c02fbc176b53be548abbc5a1 +80498d2ed153381baf3b0f81da839ed0eea6af5796c422b8e59be805dba48c4395bb97824ac308170bb4f14f319c5ddf +84f5ebc3bf96362457993e9fa31493c31c4283075e2403f63d581b6b0db8a3df294b2085643f2007f4de38cb5d627776 +958e6e38774da518193a98397978dbc73d1c3827b4996ec00b4183da2c305a187a0ada9aa306242814b229a395be83c9 +ab8b8fbf73845615e7fab3e09e96cc181159eab09f36b4c1239b3c03313c9aeb4bbb51e16316fe338b2319ed2571b810 +977e4e33b33bd53394e591eba4f9a183e13704c61e467d74b28f4ad0b69aa51501a5221cb1e0e42bcb548ca518caa619 +a9bb7ecb9846cc30d04aad56d253c3df7004cebb272f6adf7b40a84adef9f57291e0d08d64c961b9fc406cdb198aab9b +8d2b72dc36406a545a9da44e1fddfb953d4894710ca026d6421a4ac91e02d0373a599f2acfe41d8258bc9679cf6f43d3 +904192fc8fe250f61ecb8a36abbbccae85f592bbf00c10039c30b5a1c733d752a04e4fd8a1000c6578616f8a16aa83a3 +87f5fdfe20bbbf931b529ec9be77bbfcc398cad9d932d29f62c846e08a91d2f47ae56ad5345122d62a56f629f9a76c4d +84cc3a53b2e7b7e03015f796b6cb7c32d6ded95c5b49c233ac27fafa792994b43c93cda6e618b66fce381f3db69838ba +aab58da10d7bbe091788988d43d66a335644f3d0897bbc98df27dcc0c0fcee0ac72e24f1abdd77e25196a1d0d0728e98 +a10ea8677c2b7da563d84aa91a314a54cab27bb417c257826ebdd3b045d2a0f12729fe630bbbf785d04874f99f26bee8 +acc4970ef2a4435937a9b8a5a5a311226ca188d8f26af1adfcd6efb2376a59155b9a9ff1cff591bde4b684887d5da6e5 +8dc7cf6fcca483c44eb55e7fb924bf3f76cf79b411ae4b01c6c968910877ac9c166b71350f4d935f19bdffb056477961 +ac2dd1182ded2054c2f4dbf27b71a0b517fb57193733a4e4e56aca8a069cff5078ffd3fd033683d076c1c639a4de63c7 +932ec87c450cd0dc678daf8c63cd1bf46124fa472934e517fbbfb78199f288ff7f354b36e0cc6c8739d3f496cfe0913b +b0d631ced213e8492be60ea334dbe3b7799b86d85d5e8e70d02beef3ae87b1d76e1df3bdb5f7ba8a41904c96f6a64455 +929d7239ead7575867e26b536b8badf2e11ca37840034d0e5c77039f8cce122eff5a1bf6e0bcadde6b3858e9f483d475 +aaae5d372d02ee25b14de585af6fbc48f2c7cd2a6af4f08352951b45aa469599eff41e820df642ca1a0f881120e89dbe +b23c411741a6b059f04fa4f5fd9dd10e2a64915f2de6ea31e39c32f2f347a776a953320e5f7613fcb1167efe502f5c5c +a4581b0ae633fe29c6f09928e5efb16db019eeac57f79fef2fa1d3c9bee42ce0e852bc60b9d0133265373747e52a67a4 +81b33afffd7b2575d4a9a1c5dd6eee675c084f82e06b9b3a52a3c9f76e087f12dca6e0ffddc42fb81ce1adb559d47a38 +89cc890f06b424591556aabdfdbb36d7a23700425e90c9cfed7d3da226b4debe414ac5bdf175273828ce6c5355712514 +a4399438be75cfae2bf825496704da5ed9001bed8538d8ac346c8cf0d4407808e9ee67573eb95fe1c6872ac21f639aaa +ad537f7ce74a1ca9a46fc06f15c1c8a6c32363bd6ac78a3c579ed8f84252e38a914cac16709fe65360e822ef47896de4 +8e53b69f5e3e86b86299452e20ea8068b49565d0d0ab5d50ce00158a18403ae44e1b078a3cfd3f919aa81eb049a30c6e +a59f2542c67a430fd3526215c60c02353ee18af2ff87cb6231a2564fe59b8efec421f18d8b8cc7f084675ecf57b3fd05 +b8d9bac93ef56cb4026dd1c731d92260a608fd55b8321e39166678e1dab834d0efddb717685da87786caeb1aaf258089 +aa2df56f4c6fe9e0f899116c37302675f796a1608338700f05a13e779eb7cf278e01947864a8c2c74cc9d9a763804446 +b0108ff2e327dcb6982961232bf7a9a0356d4297902f4b38d380ff1b954bfbcae0093df0f133dd9e84d5966c7b1aada7 +b06b813b01fe7f8cf05b79dc95006f0c01d73101583d456278d71cd78638df2b1115897072b20947943fa263ddab0cd6 +aa41e6c4d50da8abf0ea3c3901412fe9c9dff885383e2c0c0c50ed2f770ada888a27ea08bbb5342b5ff402e7b1230f12 +a48635dbb7debac10cb93d422c2910e5358ba0c584b73f9845028af4a763fd20da8f928b54b27782b27ca47e631ebf38 +80a574c208e994799e4fa9ef895163f33153bc6487491d817c4049e376054c641c4717bda8efbeb09152fa421a7268a7 +b592bfd78ae228afc219c186589b9b0b5c571e314976d1ed5c1642db9159d577679a73c049cfc3dcfefcd5a4f174eeea +aa1f08af3918c61eadf567a5b1a3cdcdfb1b925f23f1f9e3c47889762f4d979d64686ce1ce990055ef8c1030d98daa3b +857df4cfd56d41c6d0c7fcc1c657e83c888253bae58d33b86e0803a37461be5a57140a77fb4b61108d1d8565091ada1c +8fae66a72361df509d253012a94160d84d0b2260822c788927d32fd3c89500500908c8f850ef70df68ddaeb077fd0820 +aa1dbefc9aef1e7b896ff7303837053c63cfb5c8a3d8204680d3228ac16c23636748fe59286468c99699ae668e769a0c +b64b1cb2ba28665ed10bad1dddc42f3f97383c39bad463c6615b527302e2aaf93eb6062946d2150bd41c329697d101be +b6d35e3b524186e9065cee73ea17c082feff1811b5ab5519dd7991cdff2f397e3a79655969755309bd08c7d5a66f5d78 +a4dae7f584270743bbba8bb633bdb8bc4dcc43580e53d3e9e509ff6c327e384f14104b5bdfe5c662dc6568806950da37 +aae84d3d9ad4e237b07c199813a42ed2af3bf641339c342d9abf7ebec29b5bd06249c4488ce5c9277d87f7b71b3ddd37 +b82a463cf643821618a058bddf9f2acb34ac86a8de42a0fa18c9626e51c20351d27a9575398a31227e21e291b0da183e +8b6c921e8707aded3ea693f490322971b1a7f64786ef071bc9826c73a06bd8ae6bf21bc980425769627b529d30b253ce +80724937b27fc50f033c11c50835c632369f0905f413b1713a2b0a2274bec5d7a30438e94193d479ba6679dbe09a65ef +a1d9b259a2ca9cff8af6678b3af0a290c2f51e9cf26d5fe3c6a4fa3d28cbf33cb709b7f78b4f61cb9419427983c61925 +96a3e69a5ed7a98ce59c4481f2ffb75be9542122ad0eb4952c84d4536760df217854d4ec561ce2f4a79d3793c22fa4f4 +990c4d9a4a22d63a8976d34833cafc35936b165f04aed3504e9b435f0de1be4c83b097bbaa062483cf3dee3833b4f5b6 +b9bf5e4b270aec4a0dc219457b5fed984b548892c4b700482525ba1a7df19284464f841dab94abfabcaa9a7b7a757484 +acaecf49cb4786d17cf867d7a93bd4ffee0781766e11b5c1b29089ae0024c859d11b45828fbff5330b888543264d74a9 +b0e1a0865b1e6f9e4a0e31d0c885526ac06678acc526fda5124742a2c303bd0e8871a0cb7951ec8ed9540fc247c8d844 +82b3d327b3d1a631758451e12870816956cd0cef91fcf313a90dd533d5291193a0ff3cc447054564ce68c9b027a7ffd7 +a2843602abb98f0f83e000f3415039788da1e9a096bfe8fed6b99bab96df948c814560424ffebe755cb72f40436fb590 +ab1c7b43cf838798d1e314bc26e04fc021e99a7bfbfc8ffde62fa8d7f92139de86a377289d5177021154229de01ede15 +95e5cf5dd87ae3aed41b03c6c55f9dfad38dc126b17e7e587c156f7745c8da0bd1d60acb718fc1a03b61344f01e3de4d +86f021a3762bb47167f80d4ef1b1c873a91fe83409f9704f192efeebbc3ece0729cd2f92f63419907ea38ae47bc907d2 +aaa1445dafbbcd645d4332d9806225e9346ee5ac6b22ad45e8922134fe12f3d433f567a6a4c19efdd9d5775a7de1e92f +8fd7e15688eef75df7b8bca3d61bc9fca4f56e047cdb6d0b864e7d1c4966eac27d6094b0c8482b49739f83ec51050198 +80aab8b4d394eb011d4ec6a4c2815617308c9b847c6fa6a3d7e6af1c79420ef6ff2a13934a398581c40ee4cf1cac02ac +8970b97ac076a1d8a321ce00eada0edf974a46bf3cc26f6854e4218cdfc8d2b0c32199d9658f254b4fbae5a2c5535f41 +a1aa2ec5b03df0a630e73dd048680ed6d3032c324941423f45cd1f16038789e5e75b876a13948732e9079a422f66a9fc +b5fe5f5e2f2ae2beeb8e95859a02fc45f01f9fb0ebb2bd8ec9ec976b3e806228821a9775096d341d662bc536c4d89452 +a2bc1f170b62d0d5788b02391337b2ab157c38e725694e80aeead7383e05599be0e2f0fa27ef05db007061809356e147 +a8a69701d4a8d0d972390e9f831fd8e9f424b2c2ef069e56bd763e9e835b3ce5f7cf5de5e5c297c06ace4aa74df1067c +b43d551af4ff3873557efe3f3fb98e5ede9008492f181f4796dd1a6bcda8b9445c155e8146966baa812afae1abe06b48 +b4b1dae44fd596813f30602ab20e9b1fb20cb1bd650daacc97b7e054e5c0178b8131d439a9e5b142ca483cc012a362b3 +b95b8a94c30a831eaaebea98c65cc5d0228c78afd6603d4aa426d8186aecc951f1a11c33951f51df04c7e6fa43ffb5ae +b100059624cf9db371bec80013a57a8f296d006c139a8766308f1ea821c7eccc26cad65bc640ab3f6cef9062653bf17d +8e5a2cb76716e0000d13bce5ef87acac307362a6096f090f5f64e5c5c71a10fddfdee8435e7166ba8c3ad8c3f540f3e4 +93d2c43e21588c1e83c4255c52604b4ac3f40e656352d1827e95dd5222a45aebff9674e34fbbe7ed21eca77bd9b8dcbc +8aeaed611546bb9073b07512a9a1f38a7f436ab45e11775a0f9754baaf63e9bcc7bb59b47546a5ded5e4ba2f698e3b5f +af9e6792e74a1163fe27612f999a2f3cfa9048914c5bef69e3b2a75162bb0ce6ece81af699ad7f0c5278a8df0ba000d2 +850bf2d5d34791c371a36404036ad6fdcd8fb62d1bb17a57e88bda7a78ea322397ce24d1abf4d0c89b9cf0b4cc42feb3 +87f7e2a1625e2b7861b11d593aaac933ed08a7c768aebd00a45d893ed295bbb6ed865037b152bb574d70be006ddc1791 +8dcce8f4ad163b29a2348ea15431c2c6ea1189ece88d2790e9f46b9125bd790b22503ec391bc2dee8f35419863b2c50c +b4bf5266c37f12421dd684b29517982d5e4b65dfdfba5fc7bd7479fd854aabf250627498f1e1188a51c0a88d848ec951 +8651623c690247f747af8fdffdc3e5f73d0662bc3279fa2423a3c654af9b6433b9e5e0155f1ce53857e67388e7e3401d +b155120f196d52760129dde2e2b1990039b99484cdc948fa98095cd23da87679850f522e5955eae34ac267d2144160d3 +aec8115e8d7b6601fbceeccf92e35845a06706d46acd188452c9f7d49abef14c6b3a9a9369a8bab2fd4eb9288e2aaca5 +998a8ca4dc0f145f67a8c456f1d6a7323c4836fe036dcbb0f27eb1c596d121eb97369638a9908cfaf218c7706f266245 +b235fbafac62802742ee3d26b1f4e887f7d2da4d711ba7f9bb6ca024de7beec1de66bb830ce96d69538f7dcb93c51b26 +9258d2ddc21ab4e3edcde7eb7f6a382a29f1b626003cc6fdd8858be90f4ad13240072d8a8d44ef8de51ca4f477fa6c45 +99d038487821c948142c678acd8c792960993dd8cb5e02cb229153a1ee9f88249f4ad9007f08e5d82e2a71fb96bb5f32 +a88ee9dbc73d3d8e0f447b76fdb3a27936bde479a58d5799176885583dc93830ac58bca9087075950ea75100cf51af23 +88b9b15816e5a0387153c1f4b90f613beb3ea4596037da01a81fdd2bcbd0baf5598db99f77e7694e5a0d35e822758108 +907ae4b637d06b15846ee27d08c9c9af42df261c5bdd10cf5bc71f8e5ca34b33ac2405307023c50bdb8dc7b98a2cd5fe +9393d6900e1d2d1a1e42412fefd99578d9ac1d855c90a3e7930a739085496448609d674ca9b34016ad91f22d1cac538e +a28ac56b216730b7dcdb5ab3fc22d424c21a677db99a9897a89ed253ea83acfd9d83125133f5be6d9cd92298df110af8 +b027590ee8766f1e352f831fda732adbaf77152485223ad5489ef3b0ce2d2e9f98d547c111fe133847ebb738987fb928 +a9cc08fbd5c3fee8f77cf6eb996a5cafa195df5134dab000e4d0312f970a5577942ee89794e618074f49841f1f933a42 +a8b3535c3df0b1a409d3fc740527ee7dd5ac21756115cde6f87f98cc7623f50cfcf16790689cab113ee7c35a5bd4879f +b61420227b97e5603ae8a716c6759b619f02b8fdc48acbf854352aa6519dad74b97bacc1723ca564cbf3ca48539ed773 +853762498de80eebf955a6c8ddd259af463e4e25f0b6ba7b6a27b19bdbf4c585de55760a16e2d9345cdba6b2a02610f3 +a711c1b13fc6c30745203c5d06390e6c82bd7c50f61734aa8d99c626faba30119bc910be63ec916c91ba53f8483c05a8 +b488c0a793f4481f46b5875d96eecd73e46209a91677769f0890c5e002ecd7d4b1c9f4ba68c47fbed40e3857b1d8717a +a651c5e812ae65b1c66d92c607e80be330737ea49c1dcfe019c0ecea0f41a320406935bb09206a4abff0d1c24599b9ad +85e34e7d96e4b97db98a43247b6c244383b11ca10bf4777364acf509a6faa618bc973e2136a4693fbc8ab597e308fd5a +99837214102b394fffa7f3883759554c6bb7a070f5c809303595a44195e02b9a169460dc6bbffb62bdc0e7ced5f0a5c1 +a952f89c0afb4bdae8c62b89cc3cfb60d0576ba4fe01a5d99534792f38d8848d919b3fc7577435d8443a044d2ee0bcfa +a1ac1f81acb29798acdfc493854663519e2d1b0e9d23d286ce33882c34b4c1c0bb43dd9638166d8026315a44d9ec92a8 +ac9c58aa38219ae659d23007cc7b97fd25b7b610b2d81a8f9f94ddb089efc49c049a8ea4c56e6eaf7b6498f422a97b3c +87e61d501c242b484fb9a937ef21d485f6678d75257fc8fe831b528979068cadbe7e12b49c34058ec96d70a9d179ab14 +aa45f6852f35cc8b65a4a8b5380641d2602a4fa4e3a035db9664df3ac2e170b1280c4a8b7b55161430063e54de4158a6 +a46975614ddde6d134753c8d82c381966f87203d6e5a5fb99a93b0d43aa461466b37f07b8d0973a1abd6ee2b40f24348 +8d35f97297773422351f4d99564c1359ef1a10cfb60aa0e6c8985a78f39b4268486312c8ebf9dd2ef50a771aa03158eb +8497c6242102d21e8b3ade9a9896c96308ab39171ab74cbd94e304c47598e2c2a7b0a0822492ac5c076ba91d4176481d +973f8fcb5f26915b3a3ef6fe58cc44bc7f4e115cd0ad9727d8d1b8113e126ae2e253a19922c5433be4ab2311a839c214 +ae3ee9f1d765a9baf54b4617a289c3b24930aa8d57658a6b0b113bbf9b000c4a78499296c6f428bbb64755dfd4f795d2 +a5be7a8e522ef3dcf9d2951220faf22bb865d050f4af2880b8483222ff7aad7c0866219fcc573df9d829c6efbb517f98 +a5f3c7fabd7853a57695c5ad6d5b99167d08b5414e35ed1068ae386e0cb1ee2afbbe4d2b9024379b6fc3b10c39024d36 +978d5592d4798c9e6baceff095413589461267d6a5b56cd558ec85011342da16f4365d879b905168256f61d36d891b1f +b7b6eaffa095ecbd76d6e1e88ceebabaf674d9ef7e331e875c6d9b9faa1762c800ff1ea597c214c28080f67a50a96c1e +8a1ab53ae5ceaa42e06e58dd8faf6c215fc09ba111ca9eeb800612334d30d5971448be90fec62ed194328aadd8c8eecc +a9ca532cac8ace9a9e845382f8a7840bf40cb426f2fcad8a2f40aadbb400b3a74021627cc9351b0966b841b30284962e +8dddeda8854c8e7ddc52676dd1d0fed1da610ed5415ddd7d25b835bd8420a6f83d7b67ec682270c9648b2e2186343591 +888906aac64fd41d5c518a832d4e044fdc430cfe142fd431caf4676cafc58853ce576f098910d729011be0a9d50d67b5 +96a3f886a2824e750b1e2ea5c587132f52a0c5e3ff192260d8783c666206bd8ebd539933816d7cdd97e4bc374e0b1edf +a150a29ffb2632cc7ec560983d9804cd6da3596c0c25956d27eb04776508eae809659fc883834269437871735de5f9ed +81f7ad4d2959d9d4009d1dfbc6fee38f930f163eb5eac11e98dc38bd2f7f224e3f5c767583f8e52d58d34f3417a6cf90 +97ccac905ea7d9c6349132dd0397b6a2de9e57fd2d70f55e50860e019de15c20171a50b28a5c00ef90d43b838253b3d1 +95694f00c21e8a205d6cbda09956b5b6ec9242ec8c799a91f515b07dcc7de3b6f573e2c0ba149f5a83700cda2d1df0f5 +82bbc3c4a3b3997584903db30fffd182a266c7d1df3e913f908d5a53122fa12cf5acd11d915d85d5bd110fcc43cee736 +8d3f24b4949aa1b4162c28dfbb9f813dd1d8b330f71325448dc45ea34d59b69ca95059402aae011e1b5aba6e536bc6ec +92c734c19752d24782331e74c9af97a8399ddfdd32954e91cda7363dba876aca4f730b451c50a8913950420682da8121 +8653d2c79f77b8c7dcdf7e8dee42433998aeedf1b583abfca686d47a854de1b75e9a4351580c96d1a2a9532659203361 +886f0e414cb558c1a534a1916d3531320a9b6024639712ffe18164ce6313993a553e2b9aafe9c0716318f81a5d0bb1da +b31b5efaba5a5020c3bcea0f54860e0688c2c3f27b9b0e44b45d745158f484e474d5d3b1a0044dd6753c7fb4bf8ace34 +b2d615bbdfdc042d6f67a6170127392d99f0e77ae17b0e1be6786ff2f281795f1bf11f83f2e0f8723b5cdd1db1856e09 +a6e014cca531e6ac2922239b5bee39d69d9ba6d0fa96a4b812217dd342657d35606f0b9c5a317efd423cdb1047815e3d +a8921736b69c9fbb29f443715174bac753e908251804620c542fad6cfbfda7bdfe287f2902f30b043a8a4b4818cfdeef +8d73a9949a042ec2dcefa476e454cd9877eee543b1a6b3b96a78ffcff87421e8b26dd54d5b3192ac32073cb36497acc3 +b936a71ee8df0e48867f3790adf55dc8efc6585024128de2495f8873bd00fd9fa0984472125e801ed9c3cdce6698f160 +82f69c06209c28f64874e850601dda56af44ffc864f42efa8f9c6a0758207bf0a00f583840982dec0a517ab899a98e5b +b7a0a14411101473406f30e82f14b13e6efc9699e7193c0be04bb43d1b49e8c54812ce0f9b39131a20379c4c39d3bbe3 +81159c969f38107af3b858d7582b22925a7ccced02fae3698482d7e9cdc6c568e959651991c6cf16c53a997442054b61 +8bf1116a206e0ce9199fcab6ed2b44a9e46e8143bff3ed3f1431f8d55508fe2728b8902670cfd8d9b316f575f288ed9d +a279b2149824b64144eb92f5a36b22036d34a52bd5a66e5da4b61fbc95af6eda8e485c7914f448abd8674fc14d268d9d +8b98279b5f3588d1a2f8589d2756458690a502728800f8d94b28e00df842a101c96ab9c5aee87c5bbe65552c0c383b80 +b4a27a351ec54420f94e0a0a79d7c7a7337940399646631baca93eeab5fd429d7fb39428be77dcbce64a13eaa3c8ca1d +90c08baa29ec8338ffce381eae3d23ce3f6ba54e5242dec21dc3caaed69cac13f2ab5e8d9d719bc95720fa182eee399c +85156d65bb4fef69ffd539ab918b3286105ca6f1c36a74351ab3310b339727483433e8f8784791f47b4ba35ca933c379 +923005013c27209d07c06a6b92b0cbb248a69c5e15c600bbcc643e8dcd2402adebd94dd4cafb44ec422a127e9780aaec +863b23eb5463a6ef5a12039edc2f8e18e3c97b244841bc50af02459b1bcc558367edf2f6e4fe69f45f37887469dd536d +87a4a7708a112724ff9b69ebb25d623b5cae362ae0946daed2ec80e917800dbfcd69f999c253542533242e7b9a5cc959 +8bf4347ceea7f94b53564f26b1a4749a16f13bf71a9e03a546f906f7c423089820ff217066159b0637d9d6824e9c101c +ab07eef925d264145971628a39e4dd93ff849767f68ed06065802cf22756fc6bf384cf6d9ab174bfc1a87bcc37b037aa +8e3f10a42fad43887d522dc76b1480063267991c2457c39f1e790e0c16c03e38a4c8e79a0b7622892464957bf517ebd8 +a8722fc7b1acf0be18f6ddf3ee97a5a9b02a98da5bc1126a8b7bf10d18ee415be9a85668eb604ef5a1f48659bc447eb5 +878d6b2a9c0aca8e2bc2a5eb7dd8d842aa839bbd7754860c396a641d5794eab88a55f8448de7dbddf9e201cbc54fe481 +ada881c167d39d368c1e9b283cf50491c6bfc66072815608ba23ab468cfbd31ca1bd7f140e158e0d9e4d7ebfa670bc2d +a2b48578fa899d77a7ee1b9cb1e228b40c20b303b3d403fd6612649c81e7db5a7313ba9702adc89627b5fd7439f8b754 +8e051280e10551558dcb5522120ac9216281c29071c0371aaa9bde52961fe26b21d78de3f98cb8cd63e65cff86d1b25c +a7c5022047930c958e499e8051056c5244ae03beb60d4ba9fe666ab77a913a067324dfb6debcb4da4694645145716c9d +95cff6ec03e38c5ab0f6f8dccde252d91856093d8429b7494efc7772996e7985d2d6965307c7fdfa484559c129cca9f9 +993eb550d5e8661791f63e2fa259ab1f78a0e3edad467eb419b076a70923fede2e00ddc48a961d20001aaae89fad11e8 +abb2826e4d4b381d64787a09934b9c4fe1d5f5742f90858228e484f3c546e16ee8a2a0b0a952d834a93154a8b18f3d16 +a922ca9f2061996e65ef38a7c5c7755e59d8d5ce27d577abcdd8165b23b4877398d735f9cb470a771335fc7d99ecb7fc +90f22862216f6bc1bbf5437740a47605d1ff5147b1f06f7b13fec446e4c5a4a4a84792cb244a1905f3478a36f8d7065b +87f3d9a86afef5b79ea1ca690ee1ee4bb9754b66f7c50a42ad6b99af7c222c853ca161f440a0a2a60b3b5a54e3493240 +80a9ca9a2d33b9cf61976b3860d79f5d00de89a06ef043d2a52931809018aeb4ce70423cbef375b29c2c750c2c8704c2 +b4e798ef1d615896108dae37ac50c1e859216ab6dbac11653e44d06ce5209057b4b0dd6d31dcfcda87664a23c8ef1cbd +aaed6d1e7c5b1db06f80dae6c24857daadfb0268f20e48a98fba4b76de1ebf65fb84c3be95fd6a418b498f8285ec63bd +aeceaa316c6369492c939f94809bc80e0857abac86c0d85be8066bbf61afbaaec67e28c572437a8d35c49dd596b3134f +b791c3d53ed34a7d1c8aa89b7953e3684c3cd529230824dc529739a5fbe74b58b87f01e56e7a169f61c508237ef67160 +9351f8c80634386c45c0050d2f813193f9d839173be941e2092d729be5403632a2f18dffdc323d69eb0dc31fa31c5866 +97693184d5c0056ae244dfb6709cafa23a795dc22d497a307a7f9cf442d7452024023c54a8d6bda5d90a355ba2c84f3a +85362daa003d23511ca174a8caafe83d52b6436dc4e43c4c049e5388d9211b5cbef3885896914d86d39be0dd1f910511 +a2511b5fa34b24eeb0e1bcbcf872a569d1ff5570fe7b0fb48f5542f7fe57bad808d34b50afa87580866a6cb0eba02f27 +b382e3327eb1401f2d378dbb56ac7250adde0961bd718575a64d264ffd44772c20752d4035c3ba60eb435e160b375e20 +afad8a5d40b536c0720556845a6b257ed42165c14fb4b4a874717d107752f49ed9380c5b048df3aca67287bb8fc411a8 +8fad0c98434ca5373c2d767868f679b76b4a8d04bca8240ea3f388558262c2d61b73b16fc1160932652b5688c25fffcf +83898008b5cbb6f08f8ef3ec179427869682bb4e8d38f6e6a687a214d4a307436afc64ee67d70a5a8ba9730bf839aecc +b85232e79913785fd82b06890706972b4ad7a309489930ae23390d51aa5189731f8a2df24800409a8c36b3dd6fc91275 +a24ff26ec792f3701da4c5638c1fca4fa4dae95b01827d6200d583c4caf17ea3171393ba2a8c23d1ee8b88402916f176 +adc5c7a7ff6b41d6cc386b7fc69d7bb04179bdf267864f9aa577f0f6a88438191fa81ebaf13055c2f2d7290be6421ace +a05e835abd502d31454d40a019010ff90b6b0b1f993075a35c9907aeab7a342ac0ba6144dc9379aada6119157970e9b2 +85ff07ba58463e7f153fc83f11302e9061e648a5cbd272bb0545030b20e11facd8b3ff90c9ac8c280a704fbda5c9d1b0 +a6c735ada8f4587da8cdad7ea3ada01650b5a3ecab8d81daa7a5f5de51ef4a6592b524692584306f06be3f6701f2870c +b138deee4e53ae8d677fae104f713ef1b8babfecec16b6a85785a66a72784eb09d44c3b63567222ade714e98f7d1604e +ae79c1a49dafcdd972acd95d8ad0a35c02adc7fd736d4c44c3cd13df5789d339b5ea16bddbbd43e486a061ab31baa5c0 +ab3cf2371a1d7dcd0ffe3869a0178230964b06694bf258b2073ea66a2afccd845b38485da83d02e1d607d4c5c36b78a8 +ab9609f28a325fd01cb39540e3a714506c44e52ef28ee640f361deb5760aadbb23e804663b0fa20a66e239c33f8d8bb8 +8ed95ea8e76e1b42823d7915a6aae77d93746f846bf602841dfce0e47543a36efb9ee7e5b42c73c3209d911225cc471b +a80b6162036d43811482323f0ce59eb18740e33a63d7c7bbbf3be206985919e5342d53a69df537d43e8b7d7f51e8892f +93c03d0a5083408ba00c125a8a9385213d4c860072f0297857b1235045819b904e07f2425c13a661d0a01d2e53347f4b +a6581200f00f96c461621e1d26b14a23687dd97eb9f7df4ba641a84340ee7306dc1796248fba4804f185947ad13b4385 +8be174018fa40f7e0cedc5ae68f38969eb7695f2205e9c573641e533d56f68c20abf38a23d2f0dcac371e60b21b18615 +857ad4ee3218c647c58f09b8ab22bcc8976f00a768ab1f708618e868e6143474be846422ce2710a0ed39b5155b6f13a1 +a490bec40f322d599f26bcefcdddd8f2ef6576aa737d5ce7e8d5d422741abe749e3e6a48489aed8c560633f72857e3c2 +a9c0ee339621f1c4a2410f9b4d2f03f1b558dae2973807b8bccd920e8feb7f65dfde3e79986b72ad21fcc4567240381d +8592251568e750a430f7d2c6ddbb3ec82a4dd9fd83efe389e69aa177fd97ac2c96c59a6e86db20d8e6f125d65b46c4d3 +a4e2f4aa6a682913b423b097c4069c4e46a1f3af9556b1bfd0580d0fc01e3991488458049e0735b2a629684a79271c8f +8c4f6a3e738cf74112b08b1680be08158013ef8a515a81215d8a36c9b756786d1b4cb4563923463f3329292f4b48bf6d +8bace547353c02ea00dd547eeda7259aa354d4772dd5e0c486c723cf88627b7112e196b879c3c92a9561b674d9fc486d +8d372f4901e25e8db64fa098148d4a4e709b0e9dcb756d0f90dad99dea393054193ae1a33d292a3dd772ff7ba05e4b71 +a8c7ea6a6a031ed23d65639f01f5423190775558f479700597df7ae7e338a6ae5e9b32f470aff20787ac8b7eec84df6c +b6e9dcba240fdbbf66033410a79a2dd3e9e1ffdf2eae949b3a9ed720e939d92339991dc3e70a5ac7d5253f317daf0b7d +974dec4cd61af75721071752c664d9c2a5121f06ff1515c56139a177a3ca825f763b69d431d4607e393fa74dcc91cc58 +958863e6ad583a9d370a6db3639066982e44766904e7afa849b132f6666b7d08ab931131b3bec7a506d6583e93d56767 +8b93a33b5da9b3300c20a96d80b894e3789c77041183c2cb21751579c8c96857f60cfc2f075201b64e95a78985c5b321 +b726cb9f7ef34ddbc2fad82b3b0af0b30cc913e26c5a614ae5c19cc9c55c8e6dae069db5315a8dcb6d987415bb550ca8 +a730f515398a71bddd66cab2ff996659d4e47dfbb08ce7958a41021f76d269b91c7498b708cd14b183a8ef469c772803 +a4eb3b18132eb0f5337f14e01d63ca0bec0db6a43870f800e5491db756c2f5fce519d8dba5528b4bcef550d06b33699c +b1ab6621eec1ee6784e632e214693f39a14f3715991996b883d66200963e065c86fa0667f7bc36b93b40b5d90ff708c2 +80486a26c3532ad6e19f76d8c9344e2626c07363fd495264927cb5935fa9565ece670dc98767afb04af6a9a5c9231075 +8ee20e0df3c84a1c6b0e21bcc325cf99235b747ffe47f17fdfba548a358ca75cbcc331dd50db2311b400ae882256a608 +aef4268959e5541e7ec69c921a1e81a8374d7e44bf1bb2debf4101cf3cd6b7d6ca7f441758b388de96b3e0edb5b97be9 +8793629bd29d689ec94b016de8886cac6e2ca6638911babb22db4a787661422da0639a4e4089ebeb689d173abfe75950 +b487b3551c20a29e9a5abbda8c50ff594826283e443c09e3ae09b914e46060b3f9abf70434444ce1487e2a74e562616b +8f11531cfc5997dd04b997cb87ba1831aa7041d5434fe72de66304e3f165d882fac891391fbb1eb955c65319e65293b6 +b195136875fd02a75676c33cb3e60504d5964f7a9e81f4c8c8fd38af62e2145c55f765b3158664566191188ac678f381 +b374174b0b3eb04fa49eb4ece45173f0db5d829eac370a20a62309566e0f98b18f72f3633626893c053b7be6bfbd2366 +b2a2f6b0cf652775679b2d677048f2ed8c31a3269e6cddcc7a10e3e6fee89e486b50d9d55fbe452b79c4157c0270fb77 +892177c364dc59032594e7a6fd032286ffdf4fa0b9e3baeb37ec839faebfd2fd46c57b2c9bfe9977b59c93a9cc0ead1d +8ab7c0038a7dbb2ef200dbbe9acbc875829ecad4883792d5c6ce283de67ccd9aa935a9cc7b30b2bd9de7fca7bf2a9a05 +83745cfc78ca709835aa6c6a233c2b86fb31e3f9f6a8becf63e501f2841c4366fb7d131b746c9d3291afda714ff05579 +a723dcb67925ef007e8339dc578d2622d9bb77cfda87cca0088854a59414c02338752c56116a6c1281917842e8467c38 +8a098142da0af2254c425fdbbd0d1b1a17b2bd781391ab37f181775524b8563c64ab8a1602aee2ac6c0a82ba11a8b1d1 +b13bd7529a9b351c5d395c794c28bcb0a3167f1c992e8c062eef47be9be27895945231d249c73a0b6949daa295e14944 +a20dcd2fc2222eaae467d9f5db861040f58bcb991a26e5663ac3aa5e1ff13d0010657c5af586cc4621757add2b905073 +b818f660c3cc4e9f273c25ceeabe562c8afa8ff88529c26f2cf45ae6b2813cca5f350e3cbd56f6257c4df41722dabd25 +b225d5987108b24411bc389276f12509a45e86d5ad6b6d929af5274df0be11109c0fed329669a0acafdf3b0beaa8f2ec +91fcb6d04576d3c6bae947bb7843b430e5fb0592ae49b0a65dfa5791f4eaa4bf2c7f436c8de7360f217001c2b4e5c67a +8821f7a1424ca3fdc5d4a5606ad10dfaba6094cf36669fa9f84cf7617e50425405d14980780e1e18a1ecea7913cda896 +990dcb7f38f56521a70cb71bf4522649fcd46ac052c7feabb0748dfcac9f9c0f95d29e070d32af3cd0adbf869535e17b +b0fac1029fe2c1100f24e2f4bf10c7672199fce53513c7dde2e8d9b00702edf0143e0e1dc7ceae7dcc6994edc2422b6f +a514ebb1a33451b4915c05114db0b10168393613744df848b24e43e09f0bda23baefd9d731075198aace586615ac7911 +8b77f7953c2e67049fdca3653b8d8cf3f799677f79b954da02bdad8cc4d6c855c1c7c16b4f6f9ba35f46426ec28b2d84 +875520cfbda16ec5b1d1d00f578a910d0fc052f17870ba093e22e310bb07648d34817cc2b8811b6f52de535f7046a0d0 +b8c77b4be0b430851c4ff69e91cb770db1935d848198601393810ef395efab52deb9d5c6525472bab720273d5e0e7a79 +b6d4d437146671bdea62fb6545395ea3df39f1cdef21b8476b68e7a25aa7354f847740576d6c9f187bbae9941f0ae450 +95c642f1bccdb62cd6a2212dcdd6ff8d49aee426ca08b7cf3a9d15249d24a9eed5533f92a70c84498c0797f8a57efa27 +b617978047ed0f748c305aa7f30c2dacd0db00baa67fe0c5ce346ef0e6991dc7e05f18dcb2702467421f8390f27aa815 +86411c7a00b3e8b43bf22fb061b1f54ad9bbf632cd74395a478218389c0f544668acf3dd7726532d080ca7da9a5f8608 +97bf684a8849626c4710a6992f6c11f6b5406fd4dfe9e6aa502425aaafe9827e2c435aaf9a5d3d2ba3a4c0e8aec79ba4 +8b178e2a125b461d3180906ffba0af3dce614c64058501fdd35243ababf892d6fcdea4834ce42c25d5569452b782a709 +8ebed2c8a25c61da6a6a8cb0d8f5ea179e28869753eacc728f2c076f7aed8598cd3aa0981f120f9e7ea55b3a689ae882 +a6f235b8e655ca3d634740b53d8c0a757ecc75d2b8838b7948997c1985473d01943d935f687b86cee56cd47c8e773443 +a7959c465a9646908b9d8032a589e41a7dd999f2ffc54bb42f22e5f8a4d8c493a31bcc7ea2cac6c8dbcc59acace7181b +96d0532df2e12da20a57cadb6cf5f6c4ee1aa4775629358c25f1d51677a3e96d1fe3b232532324b4f02f941952d4cc68 +90f493473d686b639a30d1ddc9c72eae6e983f1236e162e58e967a477c0654973ea2e1bdf4ba1a44d7247bc1befc2cab +8b2d87876d9c4085102a07ebb41c565ba69acab99ffc03efc18f20e48d3f3bbe4fc6ddab9c78fe479d9ada80504d85ba +829a0fb3200a28e09cacd6c5346000e7786116ddfd898f37dfd17bef454a8abc0fe939ed8735c00769f7f2f33cd4f906 +86194ec9e88ddb7150e8b03e7a535b6e99863fc6762835601efd03615aa97aaeb413cb210e86035086ed852b39c9d019 +b02efd116a7189cb317ceae392bc301ae55470f0489fa89934e182aeb8c67e280299b975786fe9a470bff46827defb9b +87d7c3903bd22b12d815506f150373f518d47dfc6e5fd74347d88b518124c9923d1e4c98defeb3a45d53d50b423e2175 +a1a430406b28254a7d6348bc98e697e9bab43839aa05d53faee97546f84541ea0b559162619b2045182938f69bf61cae +99d243c226c61c6697fb3d2594f3533fa5dfd7cfc87107908cacde337d7a077fa5a9dc702d26081b065edb1227498e65 +800ee5006ab6217161f42db0cfc552a81728bb4fbd7af6e4620ea099a65ef6664184af3f65a07fcec7e965529c5b49bf +91bfd307579cadc8f81009558605be3edbcb8dbba271475803484017f40130b2b216aef4f620d960193be681877d3a53 +96a060459dec458d19a6f8af6e49dc6c7c58c55dd18915c5fce5e0f4b4a422fce3b9632f6059388fe760289abf70f173 +9921a37f3e657222c7fda3588418a9071409711d9f1fccede7494429f02a45fbc52d79fbb64e9ccd518f60d06d0520d3 +81052b0d15773cb75975ca9230ebb2579700e489c7e3f07cd9cde206fef38b8139bd4976d2b4a7840495fc645f96df03 +88ac37ba66d1de5e23878c992e4d54023729e97e77351f50dc5918d738b5a73faf1dc6feec7e85784761836ba1c6f778 +ae1e6072c13060775f6086d1ae1f88b627ffcb810fc0e0e97deea1f3a15ef0aaa52a6dce2563e4beedadc131af2a8281 +8b60a340f5e4f90badf83001b495ac9f13974c3d2054ddcb3e6b8ca99dec5cd63a263e05c282454191ab2e087d5a2911 +832e2d56ba69dbf817b2b9dbd25c1538d5b8dbf5d9bc05e6be85054a423ebb66a71b157e166e0b9444ac171b34b7ccc9 +8586036fc7dde1e7e3ecb61663130c4529866ae9f5f5095b9fccd24a4c70eea899aae5f10ea1ba66d1665b2d83be35b0 +a77969453b5c083a207913272b5b69d4ccbd8718bdf54be8fbe11b4bd0a2168aae3ba8f9362afa69c0ffa28d7e5a2340 +b7fe9568c214baad0ac5f83745611b481f744ec1c4fa78a549b180dcf79633e5ba75dc20055012a13d849eb7a9be57d3 +b01cad1d2a6c51c0ce88243d1f52f95fb5ee315a905079688027511f0c4ecd0563a3a81846709d272fa5ccb9665e8043 +8eae0a21adfc569aa57237654021c2bdb2c6f0f52ccc90a126682c21a1f9413c63d285f92b2b2f8649150a9284bf70b7 +942acc947192b5f3cf60e92383e5d35f79e7a5904e8e9fd1c8a351676c83ad29b0afb6578d555457cf909f8f4d27adfd +a74e092f8628fba9abcabc27e2e9f3d5a9a941dfe50a2dfde2ad179aabc73afd196676925c2d98643ab8b3d02bdb66ad +896159daa2afd757cf3f9d34af248ad68bb3c62e4c9ac49919422727479cf669098f270b9e645607a7d11adad4c889b2 +a428d8370813d78e7a2a24eebd36e9da2f8bb3605e5a39b5fcda939b531c35a8ebaaa642ba556250a37bddeec90326fb +a5fa04eb60a1d5ee9820e78f42f7be15e1c02757b539aead995768c6209684d6c183c71d282e0c12a4c15c03f9a89d4d +93c77d5d220e40affa7269a6915c076c9aef4db552c643ae5d560a79c955b491c6346ca4cf11cbb7fe1894e28d47b065 +802e605d2de745eef6981d88e7a57ef4046a2062725e8080995374cea2b3273c27f35b7774d0dcba014710d8d6c501f2 +82f7169e6ec9b3e2bd450f35ea2e66d06bcf900acf5b73139677b48e078ce2e16599103027b2326770c99c0a690f2015 +b0c8581879439f9b997551233fe2de71aa03604f9cec37a7b18c5854342d9b67be468f3cac4bf6f64fe8a0066248c498 +a3f626848a4db6e9fb01cac90d3362ec521e969ebd5228af694ea3671061476149f13d652942ac1e39f65591fed740f9 +88a8e759b9cbe16a7c16e43f4afa2de6100d2eafa4dee75ccd653ec38c919013d0a6b35c1ee1eaee7c1985b58bcc9e92 +a3d5fc7aaea072798490616552d947e95f49cf02a420314307aafb555287ec607d75589ba24b009cd68299dc6f7942fa +a809cceeb84f9bcf3c3ddafde3041e7bc3b1d14df8830ab849002176a0725e6f16f70774d8962cb0b8ac0dc43c4ac66f +b8f2e46c031cc8fa160a08c2ebdfa85345ed14771b06daa9636b0e7792b7fddbc501dfc85cc626a01104a43a7d3230c3 +b5367e2a521c318b802ce16ceac80c4b8139f73ddb10ddf38433397cda70a86ea1f051cc55626a4e99d27f30f3975ff5 +96d963660121c1441cd13141279cd371a6a0aa18b6a20761b18df60aa9c14e13489afd83695a0921d5232efe72045f07 +80818d492fd85d666bd91aaf6257b86527fdd796773c793407df1d4a0f91d74649a6bab4d15155c36ed4c6e0a32c5636 +931e22918905fd6c230d3d867ea42861f3074d320d14e1929031924c8ac209a5c552b679b24563bb12f9749b4ee983bd +a4de2c333e74ed9bfa3c0bf6a0beb90427abd9aa4221294cda74331646b58ef46ed57cccc8798ba2b9309894b17cfd69 +883881554c1d88c0ed8d3b6dec3d200f6fea69a77ace3e4d6f86b41506a23724b4394ec8384075f9c75c3868ba8a8e8e +aa0539ecf6ec9bf06f24443027f8f24b6b3d8c5b2084248eecd4bcad3c9a69716e1a0d01057f09a65bff1006ac5e157a +856d74d44c943c9e809b42dc493dff20eca03cb0cf5ed45108c69b1f90d8592a53ae8100e99380a274fafad23e74cdfc +9188257446661c88da093b7c5ce998135913f63842d7c1586065377b169ee35b062d925367fb9b909ca971f1188667b1 +8d3aa57cdafbe998938787479f5d590c1484c6dbe94e6c487e57a746ef5252be0eaa5976d6270de7db64b6b92e57a0f7 +b8f4d6997240f9eda5aca0c43323a828d1563c491b3db2087f60ac4120a3fcd06075fb42bb19d0339ab5ee3fb7db25d2 +ad247ea94b8ae1e81eae4c9fd7b39e6601b53cff47b2547ff90a3cca87192eae28408082774a1fd14bf9ab459b7a4f1f +9598598070f8bdbcc49056c40971e673726cd8c1bc4baa0b5124dfb5fb750e7baa7a7df18eae2bd91955ddcb1ec67955 +b874131ab1608667fa60ea29092d090859eed1812e90c609afff96d79e82c5ba546f617f4c96fc32c9bba97431c1e9af +b00750a9cdc75c2a54f0d3cc99b0fe02300754f25166f7ac85ff41ab5e9cfcca33a29be76a480f12a2d410c7cd5032e5 +84b5bd1c90bb6c66755b28ba4af493ca1b0c3a4df9f436aac67d2e07289053f925cf6a149a84e74e1027dc8758150179 +99caf64bd9d193ff306e8ab5da3f1bb2a190a60c3a82099b8d03d17fa810dc53d176c21379f479e828f60d25beb3ffd0 +a8fd9de502f1c261d5733430e5a18d8b7892a98c9529a016fc2ee53892ae965dcd9c75850bcda4c7edb980b8d88e60ea +848c02cac636e047028a3fe8c1bf4066fb7591b96b0340f8fbd476ff01b35fa3e37d309333771a134f24800e5f3f9289 +a1eab1a06dcca3439f0166441e7e7f2f5b56f5f8aa9f45e411c561f556e0fb71c514c06c26ac53b49a576caca5faac3d +aa603f970dcbe953e700e61c151182c8d32cbbb53ceef572ac93383db33a4b098b5c7b267e42d514ca66b740c0925efe +b55fd5301bd700ddb0b4f72fabe9a91ad49759506101fa802ed1677e9553595aa4d2c66f7574e78d21ce882ce0120ae7 +829137bc4da7b4886d3d04d2c39cbf4b1dc40c813ac1adb425c7b9abf9142b516314cab79c68454df5d71994ce416144 +b83a3a22735001f783dd48a01c4fb3598a51ff3987e842b8045c71c035b9e43645a55254ca5911a5676ef4a8af12d056 +8ca8d463deb13f9eef5e533bc39efaeb0c15631282c5c0deee1673b0053a7cccd514af09801dd6c158caa159fe9351ac +a9ffb1427828f3c456b9c8cc50782de1ab0029b9233a0fd998bad0fd014d27e15c4a32d1e16ad41bff748378b5abdf49 +9627e29f725ddd86456aff813976bbc4a836f4deabf5ad9f73d1a260ceb30948824df9c8841e6b3c529652202be181b3 +b52c988647fe3d9276eed3c262e1044f57fbb116c64cf4f207235c205b3fda0f3d789bf90f5217401b468d85fdfda404 +833bbd6e2924f5c4446cb76b881d1434a5badce9eb9b003f85d076e297ad7ef45b822069fe54d17427a348c3263fb838 +a067a36352db6f82a116cb87d3db5f60b18576852409e2076cbbfc7843af78866313a4969385a40271051dd195d51116 +902b99545971f9a103f99d7399acc347ac46fe156166e51deefc0e92aebf5893460c69aeeae11f5af9f49418e289ce6c +9206a0e9ce9b9880f29ef0417c96931985f5d83bb17cebdbba4ff2af81a3d37155b04649426f698aed372e4f669599e6 +b54a5d7c976e45c0b1d44433595eae9d1ae9aeabfd58cd5ecb0c5804756a7b01c9a517754423b4714a3695533a3114c8 +91b612131e84580ece228b81ace83da0269b53f94d3c02a1a0879ebbd81bdc252064b3d03a7e140b43a90f237d9a45a0 +a6cead3b8607eaeafe37135bd6de8fbd16f806c131eb71c8d36bfbe295d45b070255e50dabf076e2c3f6b8699be71d6a +931da21e67b11ba6ce438546a24d063bcd51aebe39b4220a78d9c0aab88b2d37969b5ef3502d835507f9c8d6d006714c +8fda408caa9daf01122a2308b7b9d328f52e1e2f138a8bec30492488f4d710e5e52524a6455a3a2ae2818ec8a610b650 +ad8ad5c189644352d90c462731c46145410e5adf38682bb80f95495dd64d9d13782537d68690847bbb06c6be7175dbc7 +87bb5cc466ade60feb0961421c3fabdc8a7e20f11df8437bfff63d3f8bd25305002a396c9d0fa4fb9a9986d4717f12c4 +827cff72870ba00c29064a7d2b4973f322d6b6de7924c93d8bf8825e7a0e8478c7748f90f5c716bf83c55b2795d315d8 +a225895a8e94229776ceb51b05356291f2dce748be17a60d5aeb33ef8507c368bafe5d1d6eea927f28b9d1422b661b9a +8e011323ce670ff51c964241a6b72e0e0ffbb3ff9bb2762492323fc3a4abf4718091be0945287c7329850e4f74462cde +a2c03c2e5f4e9d3ef361f68b188451994ad1b24de9f323370559c8abfcdc7bffd289d92e78a5f6b104b0a12c84dab2ef +a22b4771116ce22276fab1fec6826610707ce8a342f9f60b079c4e0259dac3cc41c96c560dfd0ada6edd2828f7c0e8d6 +97c17441d0af9be83b42097aa8b7cec84a253b9a2b957214b8fa93c26d2add46144faffa7b8a55312059b10690f711f1 +94bdf348849f31a2737cbae5e5848aee711067bac85c11c2e68b44c398cfafbf3493a3226cd1ddf7a916e7613fc7b6f6 +838f59c6e8469a8ec6fd40b978a3607439aaebe1e50ff707eec72c0b8278af05b477bf12a384b56d03e3d4eb91e56f67 +a1940f0db58185e2b3aedd2b0bc2b73b4a65c68e09b046f38e9dcd4e13c94f5406bea92635190bf315e48ec64eceef2f +b2f4e0ae44e1f1210a91d8f280f17091fa994034ba8c991583f8182a323e9b3001a712e3584fc2d64ecbf2d319d076b2 +9342b89c721338d02c7854cd7466fb24d93d7313b6114ea591e6607439c8ddb911d1cf35f01898e9c557982bdff8f9b6 +8583fcab15be1dd14d5a415f4b14d706c8c62f058500f1344b37730c8be6741779691f87ded3cbcf6516468b373cafb0 +8fa9587c7989646571ad9032f34cedd353caee14f5be5cde1e9e0a1710f90c08faf6fa96a60e1f150f761c9c8ae7417d +8d9ff904cc08141f5a9879f5f77dc600e6edbe859082231a4d819953890199bcc5f940b730ea688332f07e5279d49e1c +b5f82b46e5ef9a2df8d144202d6e2e4f3bdae8e2048d2af5ea7deb3f722fbe6d370401954e74ff0d8cb1010ffb1f38d5 +a3b5b57d435b06ed70530e060002a8fea71746ad07d969ca23f22b5e52624527595b6a6d54b4e953fb7b7596bac378f0 +b90f89390df6d4b7879b915aa3c29b8d779d035033f8873bb7ac54a14ec98f0d08c0e3bf696e2ffa7b5730d736f571f8 +8e81e371b92887e43d95c0dbdcc9575282b26ccebdc8cbf46587e4f2a83b61e9bc0c6d7d1f114b9d21e04fd6c180b12a +8d682947c51dffc6e0fe0a486293c9ed121f441805168236393087cf62f2a429cca60bf0e472564844347d32c6bea27e +a8341ec7dd189fa7168759240224192c58209b53fc961c18082deba217928c399bde08ceae42bffd37c1135b4d14a845 +a94bb076dcc5ee5ec82fac57c5b384c690df12631882bd1b960e1eb8c04f787bc22b7bac315b9dc5a8a098f17f051a0b +ab64e1c6f01b87706c88a3bd974454a438722768de7340b834ccf93ea9880c14ee7c2181432acf51f980d56de73832ee +b7b0058bb724d879e5ad7aed6230297c54cb599ef659e86bf2cc84c38225899fb388391df9b2e6fdf063171937fd8c72 +ae856f4fb74c27cc98b67429186e7df4feb01278cd57bfd3170af6e52e0a23b9e926bf9565a890cfb4ae8f2d590b2cd5 +804b9c6702f0596d328f92fc1ed5a30a7ba17b9204524135001b569233fc4937035031d079f52fd04968f37c24013898 +84274ed1af6bd6a968583995622b4d18c6a2bc703ce0d0edce45bb736529b4836343dcd11911a94a134dca7877e6cab8 +88808098463f7505034c3b6328c8a08186b33f7a981c08376e429dd64b79b97753170531ed078dd265ded4ec0a1ed8d5 +92823bfb23a4eb84d3759e7d717f0c8641ece0927cd2ba8c728c26bb35df2629a838002f353c8d3d75eb19520aab5f25 +8db36bae4d960cdb9c51f419d7ddc81f372e56be605bc96a9d4072b829f05527c37c8f255cc6115300a2a0d2e6568d89 +a8fcdbd7f3b4d7ff04149a209feb75e97149e7efceaa42d66a6b8e432590fe7bd01f1a77fa8b47108f670b612e33fee9 +a9f4c53c62db7e5dbdea6918862d3c6d24b5bd8732a218edf0ba61e9d1861182323d8ecd7bef8f895b42970b492f6e40 +8b95bc7f07818f4d7b409aff8da0b2c2ae136cde386f53a71565cae9fd14c73c13cc1cfd79c0f97cd77839fb738c5b9a +adbd1d11adc756b51a571ddbcbf4392415231ddad93da09acfafee03a9e4f9e1ce3826110619e5271feadfaffce3e793 +95d327c8bb195cdf25fd79c98f9406a6b0316214b1630ebcce95bdaeffafa36fc1accc6882e0e5d13a8db5c0f3c0e61c +8cb2f1e2fb25558869afdacc7bb866544cfdd566cefcd048b48d458a886130bd086ecb7600a960a7f2563c61cb326510 +b3aa8c4bf5b933d89cd74ca7f7176d6624d562d7d58b041328b49d7562a30b489cb606abb3c49e85baf04c28e9cd1f44 +97f9053a85250c420599827297453c2cfde087065b823d9e43139e6a9cac3a2ec40a1b6e2f0726bdc870fff215462f0b +878d5dbe6b881389c2ca126ff66d87127c9aaa3f62f0d2c1ec0ea2b279ac95f8a06710dce166415db227655e2345a04d +b2c33a6b4203e3ca5247f0890e475518317ffc44cfbb1da9a1ba02114e8b752bea618050b876de5cf3b1906140a64471 +a56170c8313d2b5541a795bea9934d4425b185b5c409f0484df6f44f0e4bcbf50b860ff46b7245cd99c1cfa8fc1965b7 +96e2b658e2876a14147385fc423d2702a3cb76962b6b437222cf9cea39ebf4bdc03bbf434b747866d4bf72b4ceefa639 +89c4a74fa2f067e7ae49c84ef782c331bcc9245db7e941804e2e99d12e987b4d25cb827778ad4c3566c4fc68018650b6 +a01d30cea7d01c80ff26650020fab02e78fc3842e2398a81b44b21d58d4e9816166ff4ed2418831fa995a28ff35cb6f1 +b960c80b55a8845bbf24bc3f23b0110ca701f9544ab6a5bb7929330213cb471321e55c390ceca3e24bff69bdb0d331c0 +802c5b13f22be7be0e5db11eb3be0f0ea7f9182c932265060ba05fba20ea093dd2810d3b969ee3e387e60fe6ee834e8d +92478f88ef7435d15e39a97916c736abb28ea318394b88678fddbbaab3eaf31776110936abad116a8ff6ca632dd12043 +a6d3da0370c303001d5ed99d1db8bce1f26b0e442f0f042e36db9674e92dcd6e80465e772f1e669f99221caee3392fe9 +938f04f70a8f947d6df2f0c0e9af3cce0c06edbb3c131970dd60884fc0b0a0959c504a2a36c3ff76dfe919905671626a +a7117e55224230822e9983df2132347eb7208cb6798f291df926ab51e04b1a1f78d5568c9a8924ee6f57426134360f20 +b91074c77ad93fe48dc2b10c0c5a62ca3ab7d98345b919c52d84a9dc419b59fc1b267e1c2d4b2e120016ef84bbdb0cbe +aa175c6b6edf02fe8778762c9575581c0ee6efc9dbf99c291a41444a23a056b893be6c45333d907d0bbe9fb0eef84d08 +ad36dcb4e2ab425aa339ae464b038d550cb11186741dcf257f1b8b80ed4f32ffabbece45e2dc1525d4c3eeed819ea04f +91cb35c1ffa9cd5aebef523edb8325078da3eb5cf9e95c675a76446fc7692aaee6f949de064ca2f3e0f082cc3fa93e20 +82622f9410c143a86bc4d756b3c7b324dc295231ce865de020d61cc0868f2c150a473cea3a5b756b36771ce1032415a5 +a5c29996ad3a53468ece9356a5b4ccb68971ea1c89cf39644f1da2d4a477c2ea99bf791ef902b87c225d8c53d67c4c92 +92893eceed1af34fa92b23dcbab175b6a0188a27dbac9ad3317c4e39955a763cb383ab13fb1c519cde311d8a4d12e8b3 +8a093cb191b94b0200e38d31955f9d240e2be1edcd6810a2396a061f17c3ddc9c4f4d56766ddff4e121be7110e03b869 +93981473df0cb1f4b47c7d9b64e3123dcf1593845b401e619f5d7c70b5dbea375d1ca43fca65845fcf0a6b2e0af43791 +a6beb6b0697070f9562910add88d9ba91992f8da127b27be81868b1596d1012f09ea7ed601b4a6474c921a1a1a6d866c +92026b1ee30f2ed61c9f30337c3356844217926aabdff383c19ca3c21e0bc49811ca5b308012bee4ef250cfae1615800 +ac0ebaea6d35f84dac4ce648af096305ba68a7a0aea0a11ab2fbe3162075444a158433c98141bc92ef3b3400d6deb46a +83046f482dee24ac3ca83373f0d1b82ac1c4beda0f229a9011a81ec659ff5fc1fb105e219975b5c744308c77a24f71e4 +aa5a312c47ff7248dcb9c6ffbe5a0628ccd565c07365c4413734d415cd4fb35772622ed833862dddff520a67c509c6a5 +a02fb88805c34018ac33582e19ed0a7e4616acc3dd0867e5f21914c2031c05c6dca30b8b35b57c2b137750f3878a6f8c +a60528f1f14bf0c496491d46a0fbbd6c343e4eb3f1631e92f96a3c5e5c684091aabe5801df7a67f7c6dfd1b0d35269d4 +a1fd8e7fad8ca05a340c05a051bb0eb4197eed345f4104629a9e38e234b09d789cc5537024615feb4a6177d32d39e39e +8e70e36c1aa070815440e19443f1f04aae23b1b59fdbcba43b47b94a026c82c8f66c5dfe54f826f4d95ee1930cdb8008 +8234c1969fa7e9079661e4ca309b71b1aaa10f4372be0b963205c23a81f5a3d52ec08ba9ff65b37f832b52d631580d61 +a18cb4134127fb37c4abca328cd0047378a2e1423490af2bd3eba9ffcc99ca81a3c22404c0886f21f65c7b93c41d7981 +b46fa45fe538816de776eec086e040005706cb3eca097e290abfb6864e745c879868aac8361894f3c3564373ef9ad55c +b96ca43b96c59e95439f75d1e726a35a9362f0dbd34963b156e103e080a8126a8dc3501f9fd541ff3bcf4677f5c4a86b +a8e8c87c7301613818d57387009e601a7ab5cbdc2890f63d985c30c74f9cea2d0584c116baf0d9cd5594386ee93fc661 +b47e4f1b9153ef0981f813948150f283b47a7346fd9921d51fe8e4daedaef78ddeb4fd467c2ccb7cebd9816243da1c6e +a370c202a99c8441ffe96fad0f801086d4d7cc7b960f6e98cca29ceedf492afddfd0f351c9c4d29ac008bc255ec1a2a8 +8f5e6ce1655d1c059b006174e3f5a55c88e1821c97f9702ad8e8455d46c2a83ae4482f2d43edda74a835686ec45a8a15 +a30421e694930a3b65d397b2720d5f8e1eec2b6e2bb5a28d3f9b0a84db9aabd83850268bae64c2b10e313cccf120151b +8abe87163046f7a9b18e2a3c0b66e258facc1b31431420e0b70354b7a60ebd250a784634a76692e7d6f4330b62114945 +894f033cf077d4eb312e3258d9dca414356271abce1d6094ecce6d018c5fadb1c15d8d69451574ad0701a2876db191c5 +b0923d64f88ffc872654e1a294bb1af8681689c21cf08f39afe51448a68e60a9a0a74ccce9969276a932a52c07d095a3 +b9ca23b5be8725fae7fa710eefd45522889c50c29c26384e00b78a962384f0aeff9d15cb5910e9565da12a577eb7e5ba +b242ccf292757197a9f470f2d80ccddc48c7f1235ba026bc68a93be2738bc968e8a200aff3e2f4807216442eb3fc50dc +adc2c3b375b308524b79a024ff87d122055440643fea6fc0a651bdb312c7cbe6a456afa9d342bc76446d77d8daf08bc2 +ab645955356c2ebf2f3df9da275e01daf0b44a52afc309277d6d9ad1b05484e5ae0d9d41ad485fe481e5e362826a86ae +8de96ac587a4449fcc8b7fd0a51b4b5185d9c2eb3434f94cbadd092de1e26b0f6b3f7b15a37e8424b1429121ddca0ecd +94c70ad4e9b871566f3da98170b665a09788d421818299857cde0853789fb943cbcf7d4b2c95246ea7b72edc56a8e36c +b2574be63497843340700b701d5cc8be6d23125bd62058802ee67cce1f3b5f5602b27c93fea5611f27dc695ac563f042 +869ec89da7850cedd88bcb3a50a15cece233119b31b64a61bf6b2310892ce42d8b473b584b11e61db29ed24ce8033f83 +8fbaa269da8e28e9adf4c1b08f109da786dbe9cba871c32eecbfb10619b7a5d65a26f9bb33e201a8ed20b3de94003fbb +8bf7a059c37242caf7f821a6314e4e4adf799e0dd86b37892a7172598892c07272acebd05b534755c57b51556b2d610f +b4e72645fca459898cdd9214892ed08b5c99f82049c0a30d72bac0b9717caa9c6cc16c3dc7aa6ea4d42dcd2a6c175df6 +a39170da87a3495da55bbb9701c5461f3403447174ed6a4af75712f7ba4ac35f51a4234bc4b94da888a0959ee109c0c7 +b45675b2774ea7696089dbf7a0afe6c22e85fd0e4ef3db508fbaf96c9d07f700c991789206da9309fd291be696357c5f +b52899e3e3f6341eefcbe1291db6664bf3b6e8021d32fb9c3e37b6258a35c1da927747b2ce990937d6f4c6c3e7d020d2 +84e5bdb3dfe19700d79dd3fabb0159ccfa084f7288db836c855b827613ce8071067c8d7ac5cc2b4e88ed7f84b690f6e1 +801477d200b6d12fc6e0a9bab1c8211193ab06e44551e037a9b4c36fc2d4f67760b9ff4eba9a3bc7b6e177e891f64ff6 +b6b71a5116d3c22af26a7530f535e9b7851f25a84e562a8f17a125d55b9b3fc1bd8cfe65bdcbeeb328409521e802051c +8687e21c34d7804c12489d30680d131ce2133e2981bfa993afd8a8eeda958ebd5e6881d342d725338659882d9f21cf98 +a024e97a7c4de32b6383c34431994abc533ecdbd6be9bff836ec1af022f5a86773bf345c6f33273797a61fb70a8fd5d6 +83f784f095da20ce5b31f54d6cb14b32a8a12675f0029289c9cd036b7c87a8077be2d04a62618685720e6ee69c875e97 +b4e9dfe7cb9d9efd3fe00d99ae5e48769d4af4bf43d4e05c0b54c9cfd8bc854de96b8d3ebf4dcc06b9dac66b7471a0de +a08b79f9d4673afcf7f38b57f484f88feb7c908f597663a2417f92c348150c2be6b5603f914eba0d9d5bdd4e5c5572c1 +b0eaf919589988798cb01ba0610cd1b7fa3c08715675ece8ecd5f9ef6d5d7b2c4c8ae1ea7dfd202237171aa3e6f9de74 +abff99a98baae4dd0954052503ce81827781694a5ea8c1149f96a3adde75dc2d630e138598cd2ae7fdc7a654aa17df8f +83e369b8680d8b9d995222b033b4f4f3e3b20e782113c941325c7fa9c742feef8747e4a212d9aa23285a259cc4faef8d +b16d5855dd2716613697eba36e2fae0872aaea6999e91cf6552f93f9a0b85ed4f6ff922a91b50816bd6cf8e7a4513fc9 +848373db600e32e741aa1d37726bbb28956783f89ce2d781e95fb1ee1adf4359968a141678af268077eae4c25503204e +93a0dd0fdac18a31875564505b4e28f9e8bb2915faae666538597731ac56cd77f23f2456461e2f672983fb24ad91f6e0 +ab1ebbe49fa56524b564bc2e43784147073e6ea5d27a9540fbf2e04d0f87c645ed2fd28b3e4982cc4c0af1734ee47a6f +b3ee30b733839edab6f61f0738e3f4afaeccf700d8dc7415684f193b36d70d07acd5780cf539f12e0fbf8d4683be773a +88388f2cbdec47a6b3ae460b69eb0d2130ac14de950c22fd86de03e40d02292bb93cebe62432da39d509c1289f785fef +9370c41a54b68ff486b4cc6329c3a851716ebf1d088d77a6c56dec93a18b8a77b596cde74cc17d2adb2b2f411a2e4bbb +b9083b60dc16531f77b05a955b51a237a8f8c0173d72c352c5ca441b55abbc890b14937e457aaec4be5cbbf80cae0099 +aafff8f6c6ebaad952c65054dfc7c829453ec735331bf8135e06406b7a9f740c9a200dc48bb2175516b41f77dc160121 +b43d31fbbaf10526809e9e5bd8bb47a76e0fabd7852ee7744404559ab89f0f215ff518f3271a6aa972a459cab82ac558 +b581ede48c6ef34e678f91dc4b89507413e00e70712e3e8c32a80eed770ec8d8b98caee9702d068aeaca6f704be57bd8 +8cb0a137e68b001a5ccac61de27cac9fb78d4af7b2f5a00b8d95d33ac19cc50c69e760c5e0330a85c0ded1edce0fe6f9 +b947fca07c7aa6c2bf13048275402b00b77b28f1d0ba4b589fbcede13f93b5b931c588560ab8ceba23bb8e748031b55d +81753cced5ff819901740a9a584334e355b497cb699f0be5a52cd555a4c9f149535c7bb355b54407f7f0ec27de6c2e19 +b3d59273951ce97838c4853ec329782a255b5fc7c848e7992ded1be28a5ada7fa3254123afe32607b9991ec6e0659b08 +86b253de246f82be1cb0cef01e87c3d022ca1829d2cc7e6a160a5afbd3ca6b94d75739b122e3bb16f8bde28a8f3223ba +b728b659fa2d8487e061a37f7d14a4c2d70cc37497a8715695d8d332cb274deee2ce23b9b5f6a7408516c02c3d526a49 +81277b46d98848a45abfbe39842495659dcbb80dee985a4fc91d77d52b815487aa8bb455f411fcce4c3879c7a075a93f +b05b6f1fb4a6e654f0ee6b83e08b58b57059bb0b7c490405bc8d963c4a2d6be39c558917977e554e1e9e3169961cbf3e +88f75fa7d016fb6442551ec071cc1e2beeb3ccd213d16d744f573a82f5d70f41dd1b18af71d5f9e73d87f2f6b7dbe889 +81a46434f1bbd65a661a0ff45a0295b8fd8a42a7969c5953721bc98698b64bddee3f806876d1e9983063fdd0c11f99df +8b4f6d33c510a4c9c7d623d9ae0c9aa631fcb987704726b2a4d8519372123bce3c439202f25b5b47045ec14ce39a21a8 +8d5112b330fb63cf6ef3d2164b404c14ff9907d685015701399a260951912b19b8f270f869df317e9050a127763d7980 +aadab394e84dfb82db15ecd2427f39b62352c3e1647c3bcd14fb24ae830ad0116f0fed87ddb63963b424a4741961386e +81ca4e5600d00a3bda24cbdea7a532a4cbbd893c10e7ff10667c15ffa8138b91667abe5466b31a3dcdd60155c48538c1 +ad943af1b8a5fcfcf309ed8f2f916339f254cd555c71a407a47365a139306286a05a8314e1c70e20a65fccd75d36fa12 +b16597a0b437060a390467bbfab94c0bdd695ae898894f4689f939e30cc2119cc08ecb594546304adf876f4e275ebcd9 +a44a4e0a6693be356065891c27eefa040a1a79475be53d54d5fdcea7e0668ff9b35f850974000ed119f6865aa6faa721 +adef27d1b6e6921f4eaf69c79e2e01f5174f7033eaafdd33edcfa5119af23f3a834ffe1bdf19576581b797abd1865b34 +90c1e9202f3ffe28f8e1f58e9650dc4ff4dbc158005b6f2296ec36147e524b4f2f87f8aafc39db5b006fe0c491c92f45 +ac817cd54288b6f7fe6338415344fc9e7b669414051631ab2f27851c052c044be06bf7235d668e194bef695923256368 +ab14944ef653a14456d4ebc12e3196df3f1b4707c4e50b317b5ccc8ca3a0720f0330609f0e7e71793f6ca01583f38c70 +ad5353f2f380837e5ffdf079350b3d42935a0517861d03af98db5ed3ea8501abd68885c8c65f5a66e944b1874826a450 +8b5583863f84af8443ce8970b02e26cc5d959e47efbf8a66a54106ab165f1f76b36423aee74c7b5402fd1c4d7c1adfe6 +b3b46037eed9fc30e4f8f0da8bdbdcc40a38e22e876ce9fde981883017854aba82c18eb00887d92ad847d30082fe7271 +98a2b6fc90b7ad172e4368c1e54675b75c8bf2096d91c9f2b60b3397d3be3b705aed5389845dbd68f0f84438cd0f7687 +b155e800852a5f90a2eac69cc4483428da1dc2c31588a13c924e60a7616ce9baeb7d4b829c772b260277cadd8ed84719 +b8b92c520a1302b0cf7d993a52e1dacd7f27bda9868d59c55687d995ae676b7070af4c0792a9bc1c2635d44a4fee01bb +96dfe9bde526b8fc829eda825f55168b88e8f4e43d4d708cc3060df03437b46e12a8ac70d7788aa75760f6294d3e84d8 +a3fa66c54e2fa084ced3bd838614c6c33042f492a5745d167a723c60d5e7d6020ffd1747981a23f8b68df21ad8f0fa77 +b573ca10cc41fc04a642f6f62c355a4fda69b94b8e95dbb02fd1ccce4bce1191356e1fd66d372159944eb36a7071f005 +acd0a1c9abddfd0ea223eda1722aaada362d34234455bd1c6be115d41e535b16f12ca428da7820a757fa4c98884a385d +96f242eee99c4db383b8754fa7987c0c159652e1866faec905a8d3f010e0a1ad05bd77b9ea8dfd653738959180f58430 +9215a9b672a5d6e435e0e0a45156e0e20f75cbbdf1d14940fed3ddb63d433bef643796c7a4fff881829ebb2b2eba9460 +b8ad9bfceaf08dc5a874387219ddd1170bc3a5e25ed72d321d59ae713be5ddf9fdfbd3aa7ab163be28dfa0dd14614e19 +a19a1050590bc500b32c502f393e407abc3d8e683d6f6b978873aff3e3299b18b1f6b59e2b0fe237d819dbdfcfdc98ca +a6870fb11d4429686e52e1f44c8dcfc7ea24a020df9570c021578dbc1f9bdc8cf797cb3a72d7fc52805dba35d59f2cd0 +a7be733b64d5c06c127bd1c87250e42bfe30ca91ed8ce51e0b6e377f454e8f6fef7f99bff650695df2fd10c375da349b +a1b97145dab30330eea2cdc8739b2446a3704b64505fcea3dd8a9b4a72edf222e98d967d6fd7f76794acfd97aa091065 +b2127049907d2a3b654d1c940b740bfba3dbaf660f86ea79c2f909af7c9fe2a07a1caeb1be12370aeffaf8faa50f1582 +8a207701214bb28e99b0784e9228b1c34afa701966267fe7110f6f29f5bb41eaae6cdb98844d0400787978fabd224de8 +9925147a383b6f5f814520220ffdbf20b214225882c3ef49b1a1ca677709176ec82466fb9c4be2dfbe5640afb63b014a +8416ad93871623fb555b5390b80de99edaaf317350cc0c1ae9d54d59517074d40061f315cce8ba2026d9c1e6f6a1009f +a315f943deebbf0a2cdbcf3f8323e215a406e9cbfbcc3f6288714cb3a6befb1bf71b2a21ff7a2ec4731c65044c45b6b5 +8213e0c2539c24efd186ffa8b6dd401ad2233bc19166a0623b26dd1e93614bbf792823f5599ac116231e2efde9885709 +8e5cafd2f34a127a4a896f05e4d929eef06972a1826b3566446942198df26d62f7679b987db2b3765d9d8058b1cd85c2 +b5302b399c9cdf912fd59007ad4737255552663b1e56dbe64a7b2ddd88d2093c73ea319b45db2dd49d1e03f5bef1a0ae +a0c2bcfbed4b008e1a56e5d2f2419aa59d7dd0ebd990f1c18588de702ad0fa79f445d69965fa9381e700eda13b309378 +80a44eea1ffe24c26b16b8e2e70ee519258b9ad4b3e83cc4e5cca88ebc48d0160066f8b91d0581095b0de2428390c8b3 +84a90cb9c7d2f799f1c4ed060387a4b793ab41c5c3eaffd3b60face9b9c3bae93cd2017283bf3de1e3dac63d0d84dd42 +81d22febca276a05ba9bbc5591ee087b0491beb35b4d9f8fc0d041d642a574667ddc57660b20f5c568f7d61fdcb41bda +a3ac965ac27a28e102a439b74fbfc157e75fd57620e4c0750a466165f8aeecb2191dcf8e656f7525aa50d9c7c69b0b5c +913c17434ff0d9fc52e2ece4fec71b37d4474a18f3ea26925c1be2b250434d49759f58033ba0fce1c6862c6197930dc4 +ac430559c151a5e461f67b49c7786c97e1653fa8698e9759ddbdd99f5daf17fc5a012ae6330739440880728f24eba7c9 +b10d8e9f8aed9361b042d1398ec74364f7c7c1cc5c7f917060572761138bdbe89bf409389ee3879f93bc8032dd67b308 +937271005a4cc6a6ec134870c1b56471aa84ed4f4af1b3d5f334bc0c42762fae0c9a6a2828d3de6151a76dad7b72781c +a10e4dcf51889f69e6bd4c052f8d4036b9571ced98a3d7d779cbcb9fa5c3a82228566ea7cc1d012bf56dea0a40c5a64c +a0ed026528d9a8bb3201bc9dcd20598933e8c72fd315deea8da63d06e97392aa729d98a55a8a60fa4d5573513ba5c9fe +b723fcd04cddbd4c36feae827a03746ffef251c4f4c55a88beedaeeee194430a99f566f483668a0d88b13e7a4a37f1de +84a2cdceed44828c7c05a6a762edec0165e434e7029df617d6646aba48776e6c3b823f40689cee136536f8c93e08a629 +b786264e3a237ac3a1d56c9f4e87438dfed620c867100fd38b01287f5b755c7820937403bfb86644e082094d3e410a00 +92cc35b2065fca157c7bba54410f8bd85907a01c9f760aa0ddb7a82cb55811d24cb4dc6b725367a6a1c293b809a48ead +a12bbf22b117f00164a42515bc57cc9e6c43cc77fb737ee3d0c0cad94cb50cd3847d61cab469cf8ca76f7958bdcfc771 +85985b00de533bde2a757eddf53be79ea39091d16af3fc92327bcd1cd59bf2bf4411a334da29ad775e8ffaf3cea7d7b8 +af9eb24185b0d330d0ea1d0b0fa78af0dcf42ced81cb0128f16cafdea687a9c5582bb6d7c5744117b271cd0b3303f0b5 +8c8aaa1d85ed6327f85d579767c7a9158d209171b3efcb3e8a9d9e534c078e821b6aade255101d2c9ef6d67ba66f10be +a450518a03ffb40e1df89e0f88fd55b5b06f4872cdfb7ec55f40dc40d9424b3b289866336c195bdd54597d95569e0096 +81e61cc69f93c435bd77f155e80626a9c764dd92b6c76af15c41346527948d8a6ca87d6351a0fe7987e2ee3aa66a9625 +b615e0cebf4fdff4cb23a20c8389c370915ba26aa703b28efe4ab070b1603d1c5b6541684acf46b52a915f6aee447539 +a7f51885c7a71885cc84ef734ecd107e8bf5f7a25131415f671d143cc1de92859e65001125323c7985799993af6c410d +abfbf7a46f32066989c32f774edcc68163f085ca81e94fe8c9fb32f8d451bbb2c20ac45cd8d97f9e618ab40186933b1a +8cf35a522b5cac1934004aa9dd236bc77198d43272888afa860cfc79b4b28dabf7a3c74098f84510897566fdd609aa45 +86aa927df78f7a06a4985eb0a4f0b93529cef14f9fd2812d46abffbf25e618ead14d99c70e3c3bb2e17f3f7fabc9c264 +860f1b4f4a398e9a8bb4739587cf96979cfbbe1687b7e91e5bd1198db726391b09b1a261bf12e96698818f60b5bd3537 +8e7c4ee19ff115881051e8637dce1f5d6c65e865d0c757e8ce41b6d7bcd86c7070cce60649692bbf28c868c7e2e1e2f4 +acf7ba01b0220419f09169ac8d16e5cc13dce08e88c90b8fdfaa33aab417f011a20b79a178d8a9f7211589d2e0affd7d +b404bde8e715aefbb9f20a353b911b79173ef3e2cf0aba98b5ae6190b90597d65043b0b4e014ad9ea6c77da2d213ea12 +97e3615d1c77a402253bb55da2d1cdf82de316cefffe42b1022c94b4818d6dc4a313731db85321c537914bdf716a875c +940e950b96a4096a578c6874d747515936652b9b113a5f27f5a834a610867b05f9881e2679b0b289b8527baa0009b6dd +8de15a13ca236a3a285ce6e6826c502ae7365bbe468b6e8ac67b15b0bb49be0e996f1eec81ef69e4b7f54f8e4779a054 +a12244777eacb08ecd42b5676b3a51153022ab97e9353ace0f47c6054c22de9ba60d2a60f59a36841c2a791cb1b7c288 +94f7580203e39a2642ee2e7c969b9911f011d7f3a90c398e1302d26edb3df03df1d0c43baa1c6cf90dde95296d49e742 +82ead33144aaecab965faf63af384565992f38fc1066e71e33d53f43ac93892e27fe78c4eaca1cccbc53364e26ff31e9 +a0c129e9706d354249a7f8aa664ccd7ede89aa1445c5547410814b56d10dc086720953363ab1da8ff5f1ed5d8e575104 +93b3057bf3f74edc95237781ae012cc4b1d3fd0455565ceaac7110290aa518ac32478ba4eb9851555fa87270fcc84f1f +949c2fd0b94f31f7cbf00c679bd3f6ec1a2f4056654708d39edf1a450b4e19a6e251d0bb24eb765087e698f61d3fca2c +99fd2e50e211ccb66b895eb2fc42f260f3ad5767f04c2fe238b81dae98aa6e3977443a51f4fe7b43f499caabe45699a5 +84fe19626503218f327b5325bfd7c0c3d2614b47d34964aa0259d564e769c6c81502132cc1765b0b31fbe39852706927 +b43287ec29d9010bec4284de58fed48dd1e129bac79f09d45153c9949131782f77b11b0c9f8ee06a39e5e9bbaa8e2c6d +908902f3ed45482df2f94415fc8e5a308057a40c8905d7cbbd58ec4848e19276577b7f7e69e5e684a8b981738e10f7ef +85cc7d9c1eae372b4f88758cd6e21604b4bc9f0794e1e74b6d9de96347f81944d01331385fae7a38e5f6096c1dc23465 +af60288c702082fc258b3dbd6952c6b75c1641a623905f491b1e72f49b9d39b33d150a336450abd3911a4c128166acdf +a7d8ac7e589558c4014369ab6f4c1f2196205b03e4278152ec0dbbd7ba54e803c3369a71d364a773aac8dbbd117e4a13 +9833aed34e48c206e9328073597aee1123f5bec085339b4e6839a389a429bf3042798a31fac1464ce963204adface76b +84631a4f012bbb62133030224b57deb32dcf464cacc8ffde7775adbe68707263ab5527a1c75e597e03aa703ba658b889 +a686a61f6467858a2a4c13e70ad81b1901290d3e51bbc0c6e366f9e652f575e91b11c75f640ccef8b0c6c1b05a43c9a0 +b585f0ffd5144907703b41539bfad7f9f058f5985f63db911064ba6b07af8da2796b84b16db42b8d11135c3f846cd9e2 +b525539516c7bb25f1d7e165f269dc8c9eedbba74df44887e178ab8fd798e2a31f39812ca922d6b64d91564f14012a64 +91e480d7568fd2fae39c35b0a8d623e66a3160fee1dd4e9097255004938b11ac1cd3918dc6a1e5fbcb700c95a547e5e8 +936ef55c69b842b6177de71fa48dc5442bf5132116b214302f8f242ca36a273a6bbfbfaf373777104dadbe8e7da5e970 +8e950c0f6688abdff8a3b8bd77be6da6f2565c7b55711f5860ea62a3ab1d51aac31821c602bc11a45e33c69e7dde3ea4 +90eed4595104a0527f8db1e028ff622ff70db4eae99cf47f6c2a0246ec7b103570a6a9a877e32e9647cc74969006743d +b756344f6c4ea05b792e416d9bd9ce9dd4bd904e7622761f28a85628506bfc9d88a25e5f04db62fad30a92fb1d8d8556 +ad79ba76534c1a02ac3e9b7308d390792984cd75b7e1d0e5e4ff123642d99d4ea1825643091aa8117336333c40d5bd94 +832b08144887de0c0341d84f6945450af8d7a4eb32367d7703118186c1be525df9382ce61fed5f3b65a0bb3449185f7f +a322fb944e46d8e47994820890c94af423674716da810ea1da71e0a7733ad72c22114ca39a4b59c98ce4291a5684c154 +b982851a65140dbea79bd3b5487e236feccee051deddcc17c2853032efca289ddb6eaf64be3dd85a73012fdbe9d2d4f3 +8eed5e230e201830b44b9fadca4e156fe1a16bf840cf29da0f381ea0587b20c226de2465c67e6268973e776809af68e1 +81c8f1c04490f36e41a53ee1b5185cb8adbb37c258fd6c3be8c56835bf574c37183a94d55b6554fca35d6e6dd9af0133 +8c4928724107cc16d36f2976677eac0b852fc4c3c0bb2f9cd4d59cd24a113faf33b2faf405c3fcce25be51d41e42c2c4 +8e4ba842636fdfc4d71f0983538ea5037d420acd26abd12efca48c252eea85544b2fa9fccdfec4e7c2a6359baffa112d +b4315b84700e26dec26f3488d308430fdff4809c10d4c24309627911cbb769ffaad0d1ecccd622dd02194eaf5ba59f91 +ab888308f757faef32648c1db01650dbc9aea248b09d06e6efcc996d395f48ec96f2d54a02de441d753fe8737862d991 +805094cfd77e207d5c75f3cad99f41f763ec15443052cfd758c6a82ba422d831a1103a7f9b100da49c28198279c3d3dc +ad857f33243e4a2cd2a773700def21fc7f94939d1a6d2c2125ecd58fc206ccafb07a2c02a1cfce19857d3654aca2c70c +a4d12d40149953daa70b89a329e918e9d93efb4e8004a9357fe76682dab9662c8507e16db83e849340f05cdb4933a373 +a0dbac2ed4b5d03606524245e8a31080eb5bd3e9a0c51dad88c3b18e3e6bc5d64953a81c8e60425b80107ee6b62b1fb4 +86da05355900f327164a78901f6e3db857531b33b1e855df1a67a9ba222c6b05fdb6b0ffbacaeb1ba5b45ff8979b6b68 +932c9873aa3e226dd922b5a616c75153bd0390ce8f332a414b9c8cb6606c2501a37a2aa88097bc7d8e2c4261706eb38c +accd9cdf07ccdd42033ce3b105e00bfd39e2304b1e3d66f8b1128645634452c20f759ec45adcef2fdf04408f62c4cc04 +b75cfdfc1cb48918752eab17eb579820ee6e71e6667abdb64df834ffc8c1362fbbc23ca2c80dee248fe1fbb72d87dfc8 +88b998c73b00638fde7d3dd650a08c5ab996dac6ac34251337fbff3fb5ae4a25dd20c1a16c987ad7ded19eca23cea891 +8afef0956c942571a27f504553fb312cca9e50ce41b44e0466d0516c5abe4d8acf4594cdb03b1ccdbe3f2e6a9093b713 +9042cd83c5ff261e9ebda26398caa16cac2cb840d19062fa8ae50e044c27104972948318f4c866dc4d578798272d3e49 +ad536719a64570a2cd1d72b6590ea1d02c8c49f259a7867be26c8191445165954bcfad50ea12688ace3fdfb0e98143bd +97c86328d63d297b6bc9718dc1ad5a05b908a750d1c455c700d84315589128ce4eea958aef2bcf0fcf4adbd8e3ce58d1 +8e592cf0802e6a9541eeb654dc55055e11f3d757847285197132935ca35bbb1a9156829a39384dfa6f645ff89eb36738 +ac16c614998944f77590bf3913a010e13f2d3bbf6a172293baf5983506c1a2d89989fb72e598f5bba1ea10a691377c93 +ab8e6f5b46baa6632de3621497bcbdd584decb999fe7d8a3364843a1e0b76497600630b6a24dd30119d8bcbfca29f335 +abe1d3af5279e60122d9cea8cc6581c819d7a0e20e3715da0f6da7e02d13a7653db643bd946e2fa9ba338eca81fbe140 +8c33bd831ecfb18d1d0713e16beba768e9c42df62170c1f8a16764912be77f2ac5915623d1d25e8c462aa9c2f6669ca4 +903692becae4a6409f7bdb127d9b11de57a5739fe24218dcbaa0092648d5332dfeef29a908ee9e43e5e0a51a4c3639bc +92591e90347ae286acd365eba32cd9ad8f20f4c9cad2dc579b195147ff290adf0d776bcb3d4b04a25d68a941fc0c781b +b64bbccf860299aec16e1f95c768a1f337c740bde612e6ba260e393edb8b04540127194761c42597abb9bcb771c576c3 +9194f056ccfdfeb78a11c5347e2255d7a7ebd1251f9aebc0b58feb68d3e03a7dbbb74e3ef7309455853adfb4694bd01a +aa4f15f6d6a53ae65b7f6f91e8981d07a5919d2138679a561f7bb608dc4596e45ca06c9441d51fb678b2ad89ae7a17ae +90e3d18507beb30bde08c5001faf489a19ab545c177efb3f73fbf5605f9a0abcdc8bfbc44f832d6028e3e0a834bea98f +8f31dc0118c8c88a6e79e502d10e57652b7aba8409a5bf572ca63fed6b7cbad7f28bbc92ac2264f649792fc1d0715085 +a307d1067ea4c56437b6f8913aa8fcbf4a24580fc1e3336e7f6518f0f3adb9c4733090e459a3f737414ec0048179c30a +b7cc41fdf89595cd81a821669be712cd75f3a6c7a18f95da7d7a73de4f51bb0b44771c1f7cd3cd949e6f711313308716 +a9dc74e197fe60e8c0db06b18f8fe536381946edecdf31e9bd90e1ebfcad7f361544884e2fe83c23b5632912ec284faf +8b3e1e81326d611567e26ed29108f33ddb838c45bbd1355b3ae7e5d463612af64b63fff9fa8e6f2c14c8806021a5a080 +92f6537bca12778866335acc1eb4c3dfc2c8e7e5cf03399743dcea46aa66cac92ac2963b0892784263ad0ebe26ffdbf6 +b5cc0061f7a3e41513199c7dd91ac60d727366482a4c7328527f7bd4fc3509412f711bb722b4413b3736a219b843d15d +b3e9711d68d2c6f6e2cc27e385d5f603d9a1c9a96edeefa1ffdf390439954d19504d6aadc566b47e229ad4940ef020d2 +a09d0d3f0e5dc73a4a0827b72710b514bbfce4a7fcd5141d498a5aad6c38071077f50d3f91af897d9ab677b7041dedda +b177fe260f3b86e9ac21f1bfbe2682ae5dd8c9aecebb84f37054bdab6e39094e611ce582210ceeddde66adf759dadb6d +b0ac6595eba9f5dc4b2fd21856267cfbcfb5b12aa34ec69ca32b80071c5b652e85c25a224d80443d503bf25fbbfe07e9 +81f3c0e11b196bd4a2e8f07f8c037002566dc9037da81f3988add458a520c24dd1be3d43d851e28c0c6a85de4b57a542 +a44308c95615f7fedb2d2127012924468c015df9f48359cc2e36ab4223870b0bfc1e9040baabefdf5266f93afaad896b +8493ec4c32d5a13b81039f1b436eb83f259945dc950e3c6c2ccf5087ec56dd2f60890ed4edf01728b6a54950e19b35c6 +a1a439ec2a6a95bdac9aaa925ff337ba956c0d236ab5318354270e73ed6b73b4ae2d27b4c1686cf97b6526d04e65be81 +b4659b7b53c55a4b2bbe210b53520b392f893500e18990d843b72d7379d45fb44dd1dd2184348d6fd853d6b9ecc6b7c6 +afb2c68d75d00130b0e1b4f250001920213121791698ec04262db714cf7b1408d39f6cc10421f954845aad5b8250b77e +b22b843b40a97210f94043b552f348f66743055a3f274856a738e7d90a625b80e9bbb80cbbb450e1666eb56b8bd5c60f +800895ced82fe13d5fff65a93b0051c3df698bf1221b682accfdb63e3970f669ca37025750697f4e8ff2a3322ad57be4 +b21f598c50d7b9f4a584d548f85e42055ef8e24991906d973749090261584c7f4f5e984b528926f7e75375dd84d51af8 +849b1c68192d18274598dd6d0bf48fb5ee3b1ba25b331cff2d06f345bef3bed49760ca5690848cf33388f6a9a32cd646 +aeb6fd9478b10ef456f6bbb1e6dd19b14475e65497772d12cfc097948383d3fbd191bf95f046b8bf1989954118e483d0 +b1b5e0ea2835f7fc8b66e7731e392b43d16cbce04b52906b6751ab1b91978899db5fecbdabc23a19dabb253005468136 +91b6b1284770cf6f7ef35bc0b872b76c7763ffcfa68f9c8cfabcb2f264a66d47598bb9293f6a40f4c3dd33c265f45176 +b9ffed029846487c2cfb8a4bb61782bd8a878f3afdb73c377a0ebe63139fa070e3fcdc583eec3a53fdc5a421ff1fa877 +998007249d041b0b40ff546131cfc86d0b3598dcedf9a8778a223f7ed68ba4833b97324cbb1de91292b8ff51beab44b3 +8eb77ce9e0e406bf6f002870fb2fd1447646dd240df9bd485f8e0869298a1fc799d8a41b130c04370e9a9cc5c7540ca5 +853db8157462c46f2af7e8f94f2ed1c9b9a7ba2896b4973296898ff3d523d6e29e0b63a5d26cecd5e490b33c87a4cecf +b1436b6f3278768f0979ee852944258f2599977d255bea6fc912ba17c5dff5bdc850cf3e1fc52be9d6d188e868670f4f +a76acbc5832019b3b35667ab027feff49f01199a80016620f5c463dfcbfb51bf276ed17b7b683158ba450660cc7973eb +94540cdb051faf3ae8b8c52662868c2dab66bd02505c4f5f8eb4d6b2e2e5fd9a610890c5dcf8fd887eee796d2b5753a8 +aa35099666bceccf4eb3b65b13bba88e30a8be93693ab6761d8e5523343e8d6dd42d977e66499352fe4e9e9784a1dd0d +894471aad17be54319083c4b5e40adcfacf7c36c4aab0b671030b7ef321c53590a25eccd836efd20f32a93185fd315bb +8f52a9f705bb0dea958fcfbd52e2b6c08ad0f89a07a6b2942c1b4c37eead0d97a38a9e9aeb08d5d59b7fa2a9347f738b +9031c16b4f936c9cab55585dc5064739f696c3347ee2c0792320c9f749e760d120e396e8485ffc79d81c9f3337ad3d1c +82090a0d0d9b05459ec1c328ecd4707c333b784e3aaa0ef0072cee1eac83f9a653a75d83b9f63512a8c41200494826b4 +92c3a9553001f9ea4d67236b8ad1a33275378202cc1babc03f313895458f4b2549bfbbbdd37bfb8fbff0decb6b9f820a +88651868f4da37338a22bc553388df5dd1dd0cb78c4d7d07c637d8f6faef4bed72476fdcd4304d5bedf3514011135f08 +83fa0141bfebd88063f1d787719721b4c6b19ecf565b866de9d7d5d1a890e0e3d859b364bb65f8f8e688654456a40263 +90a7fab753e5d56dfc0e53a6b4e6ab14508220f3a62b3f3f30570c4c9ad225e74122635826c92e8e3227ec45e551432a +8fa375b0345bf6e5e062d108f9feaec91029345ecac67ccf1264eac77b8654cbfdda1f10579f481889c0e210254eadde +b83f06116da9daebdb013b26724523f077debaf6bc618b48a7a68858a98d275f7899c4ec73a0a827219b9248dd81c8c9 +8be1cada55e0c5ebb4fd460b2d209ae5326285a20c8bdd54ed9d1a87302f4063c8730bfda52d9d40e0d6fe43a0628465 +a68ad6f813743ec13a811f2ef3982c82d9d9ac1f7733936aa1e122f8dc7f4a305cc221579ab8fc170c3f123a1576f9ab +8878f1128214fdbbb8a0edd85223741e021508ab6d36c50d38680f2951ee713ea056ed03f62b9461897963d50ceefe0b +acc0d43d1b0260528b7425b260a5dea445b232b37240759fc65fe26f7c9d8e51569c5722bc33e94de6492f4ba1783504 +ad80b1dd717b076910ee5ceabcb762e75e4d094dc83b93b65c16de1f75bc712cef223c05d5579c1561829406c07a97d9 +a6fc9803f9c09d95fc326cc284f42ea5566255eb215dba8a9afb0be155ea11bcc55938b2d16f01cd2f2eda218c715efb +83ad733dbdfbaae8095a403dbf09130513f4ed4f08dcf8dd76ce83d1ea72999b7eea3a7b731da0d2bc80a83c6ee0e3e0 +8748912fbd08cb34a85416b0937d9c4327e9eed20d6e30aeb024a7253f14f1e0d774f3326e54738d71aae080e28da0fe +8997e78d8acf23051428af67183ae9b2c4aa42b503745ffe33df35a35103c589987e1473ab14dcd28ee78ebcb10d8e95 +a2f340502a7eb3c4a36412e6f028321372c4fa18a4743945607424e932af1271fa3e6598a162c872072529576eba6283 +868ccf19b5044ab93b45c9ed3ae34fcb504fe1453d6c4a1d12c325032cf01eb90356de82080ed897e97dba13cae33a02 +ac8867005fe4354d67aa37b866a7e581d2f94f7bd0b9f4efb5c2d1370ec13147a60692051b02fd00ae60b512bce9b1ff +8fd01886b046819c83c12bb779e432b25ba13713f9227be702074ec3abb2bba6be37220a0a26a4bd4171b99b14e32bc4 +a128981ed199f92b5959975c150a93a62fec50b61c80a3fa0634d90fc8058f76f5cbee77aae6889af12d296b30e613cd +81fe618552ff7a36c9235c6d4066cf2f930b5b38de4089e18166e4a06ca5723eadd1976d25e34b74b3ce942300b23e5b +ab1223ea049e6e0fbf9b611de7fd7c15e5e9637cbd73aa0e36aea08a7503ba6804f2aa807186fdc9aa7f4f9195f72e24 +b97285286981b2665f898abc13f3243b63005bef8db4cab3f658bf6167036b61af400f08db0fc3c640a9c623b760690d +ae3ddff7c1f0fbb6a13dbbc667a61e863c2c7c51c2051e33cd61620142e7e30a7e0c4c1f8fbb512aa3a8640267c6ac26 +99c2a89d5bef236060e51c4f952664094c20fbfca647e5d24a55c1fb8df2f3df58244fbbf3635db07b1c29ee3234fa6f +a5010764d4b9cd3b410638334d1f70c5f4843f45b4f4a9316aaea5fbb2c510a97449dd7a07b49f47334a69d37d9955d3 +86706d011dcdc9e9d165d01fea1df68dd74bedaf15a39f92893c030cafe96f4498c4c1fec2d2136354341b3f440a1462 +88fd57eb62bd7dc35722f3a0576c2138403a2f663a2603482e8974a895cf56ddbb02657dc6b89eb2cf5c1f9d1aff6426 +b0dfd4c68e3acb6bb8a776adaa421fc5e268ed4d5964bb90a727091e5113b55b3f9c6d33cedb3ee47ff7acc5df8b1749 +93b92bc942e1a636fc5c2dc1840de5faf158a113d640d5a475b48e2c56ccccaf9db0e37e90ce74c4b3f5c9ac3b2eb523 +b29a16fa1ea95cbfc1873c435ad40dc8495ba6341801b72bd95d908147dcffb1b4bb426dd635f3af4c88984f56594dd8 +b8f367105e1a2d554ac30200c66aeb579d3d30a8953d20fb6ebba2d876ec39c52ea5d654f1bb89b8ddf3d9d651f31cdf +b5fbc228c983d08adf8612eba5b3db3acff604439226f86aa133b02cce4ffde2f977c8dbb8b446b4375673f71634c89d +a399bea37d3056e0559f6644faa0af93063b4b545d504d7e228d3dbbc294af83d3c4cf37fe026b63899b4e7d50fd08f5 +928ef411a36414b24aea26fdbed4bdb1bb6bdc2d967e2553ce54c7c4e077e76869cea590257645c9129dd55ce025295c +9684a4adeed416a9ce82ad79b55c4a3adcfbd43950bc442ed8a340381caedb70f4baaaf821e3a152f483f965d8f56162 +92558a37f214d6f4cb6d72cd2f4ad24dff9d17611b9e4a41ee5c741a5d1ca9e4053b0584533ef4da206110b5dc3e2a35 +973bf0724d1785cc5e85d2a8ee8c354ad4cf557217ced0b7940f6f064024c20b2bfc5b144c820b5083da4bf70690de4d +adaf1389dfa528210ca9c2657c5ff10d51f7e3b18e93a59c37211be0506c3576cb2c04ec80cd0f82605e53c5a3556620 +85b58b223b09fda6f3ab674d75e780c49eb2167837243df049281e8f4fed653811138b398db9cdfe7405fdb8485602fe +849504d3db408d80745a07e850b0a804607b91a59922a5d3bc40da2748c029c029419cda38d2a4485cc0824c6b2504f0 +a3f4afcb353bc2582a02be758ebf0cd18752410ca2e64231176bfa23828423e0a450a65f241a9ed8eab36cae8d9c567b +ae362786cdf121206537af9590d330abbc6dc328b53cdd145dbed0e5df1364c816aae757c4c81f9d619e3698dd32bcdf +9024cfa5b0101eb02ab97866d5a3832944e5aa6888484cfba3d856576b920787b364fba5956bd7c68a305afedc958201 +8a116df09fed923acefb2aecf38a4fbc4b973ee964d67f03791d70bee6356af43ffca117d4e9463ffaf0e0d5d5e5a69f +9163016175c73f1bbc912ddfe03bd4e1db19c64951c8909ee6befe71a1249d838e0db49f03670bb4c5c9b2ab0fb4fef3 +8f6357318d8d16e7240a02b05ce5a4976b6079d49daa258789c6dbf4a47950ebe9de6411780fab06c7c1f35651433380 +8e63cbae8be7341892dbedee3111adf0307c4ee9e375181aa53478f5ba9cdce164d6ae890e5f480119a3a51c6e989165 +a9782f30674a4874d91bfba7eda63aeb5dbe66b040c768d6a925d8ee135f0655ea56276b105239cc0668fc91ddb68cd1 +8d9d94b61ab84ec08665cbe0244ea41756785df019e453ef078c19380bd44c39d2958e8465c72eacf41eed5696037805 +b1470e6f5d2e314474937cb5a3bc30c8bf5fc3f79014945f6ee895fe20028ffc272f9d3a7320aac93e36c96d8a5454e3 +a444911bbafc71179766594f3606b6eaff041826607fd3192f62dec05cd0f01b78598609a530f6930e8440db66f76713 +a9823d44e2638fca7bcc8796cc91c3eb17f46ad6db9f7f6510e093727614aa3a4f9b2c4011ef91dc1c2d224d08d8d05b +ab86020972c359ab98294212558b4b14862040139876c67fc494184b5c9bcea1dbe32fe0c8dd9e60be9daa304acd599a +b7e5cb685bbdcfdb1e48259a5d68d047846c8a35c5b3f90172fb183d1df40d22eaf0edaca2761a07c29c577000ccfed0 +8c88319dae4b28989817e79e6667fd891181e8d2ed91b9c6b614985bca14b12982462ec58b17be0463c24bbb79dd62a1 +8c1c6867e7107fb2178157c991b9c8b0f90c8d57a51220bf3650438ccabccf62da4db8a9916491e730ff3d0c106496e3 +a00a79bd58da6528b9af033087260f9f3d00519eafb4746b355204ee994e89481591b508eaa5402821083e250d38467b +8785abd7c37690f6aa870ee5c799eef72e398a7898b6767f698515be277b9c2fc1af12ea89b0620a848221343a3b5ec3 +8aadae68543db65cef71d0e230a09508d72061398ef2fabec0f856aacff2125b79c70e620744aaf331faf3dfc8afb9bc +8ff0cd437fcad9630b8a2333176a55e178db4142ec841581590594d74d5b53baeac5fb903fdf7bcf83e245b95b58285e +af274e8fad6b190be4e5dc92d2705ba6ac0d7e1ea29e958a5cdd4cb764de46a56d9eef62c999a16e7c50a50b2d9fe3a8 +865e6ec7d1aa848786d6a7a4e87a24d442311f0810b01ef5a74928ab59fdfd651e48880b49680047e5b0df6b3c7c2ecc +800706baaeb35bf3bc33bdea9a8b5cb00d82df407b3b7e1b781a9359cf44fb410ed311591080181b768aae223d9246aa +a9496389d0780b309c6998374ae159f58a8d0fe9a1c24c36cebcb45b27d818e653b51a8ee1f01e30a9b2c46a548126ef +b5fccf4fc3186661939fbee2e89c2aa0e3a6ad4907bcc98c7750520540c4c183b1bbfcdf47f2f1c5e75c3a30cdf30c75 +a90028e39081b736e628c2230cc1338f9210ed01309a40fdf08d39c10cced2cdf71271013bea6dba3a0444fe47963106 +a0815cbb325a8fecf2e1bcc5046644be32d43a8001bd5d8cf0022e4572cd0d481b3e717002f7ab21e16da5f5d16886d6 +b2024787fcda52abc4138150f15e81f4a5be442929b1651ddccbfd558029912be4d61c3c9b467605fff640edf7392494 +ab5aa60032304a584cc9245a33f528eae7157808dedd1ad83ebae00aadc25dbe1cd5917eb8b6b2c800df15e67bdd4c4d +866643847ef512c5119f2f6e4e3b8d3f4abb885f530bb16fcef0edb698a5b0768905e51536283925b6795a5e68b60ddc +806aa99c9a46ee11cc3ebf0db2344b7515db8c45b09a46a85f8b2082940a6f7263f3c9b12214116c88310e706f8e973a +a6eada8b9ff3cd010f3174f3d894eb8bb19efdbff4c6d88976514a5b9968b0f1827d8ac4fe510fb0ba92b64583734a1e +98480db817c3abbc8b7baedf9bf5674ec4afcfd0cd0fd670363510a426dad1bcf1b1cb3bf0f1860e54530deb99460291 +81ab480187af4a3dfbc87be29eca39b342a7e8e1d1df3fc61985e0e43d8d116b8eac2f1021bde4ae4e5e3606c1b67a21 +8a37df12dc997bf9b800f8fd581a614a1d5e32b843f067d63d1ca7fde2e229d24413d3a8308ec1e8389bf88154adb517 +b045a55ca0bb505bd5e8fcc4cfdd5e9af1a7d5fe7a797c7ede3f0b09712b37f493d3fcf6ef0e759d7e0157db1f583c95 +ad502e53a50691238323642e1d8b519b3c2c2f0fd6a0dd29de231f453be730cf1adc672887d97df42af0a300f7631087 +80597648f10c6d8fcd7421caf4e7f126179633078a1724817d2adc41b783723f302eabc947a7ba7767166dacf4ce8fa1 +aefb56427966c81081999dffbe89f8a0c402041929cd4e83d6612866cfbb97744f4ab802578349fbecc641fa9955e81b +a340e493fb3fb604eab864d4b18a6e40ba657003f1f88787e88e48b995da3d0ab4926ce438bdc8d100a41912a47dace0 +a6d777bfc0895eac541a092e14499ff8bf7156689d916a678b50a1460583b38e68158984bea113a0a8e970d8a6799a85 +90ce469410f0e8cfff40472817eb445770833cdcf2895a69bc32bcf959854d41712599ceb2b0422008d7300b05e62e02 +815c51be91d8516d5adc2fd61b6600957ed07cf5fdc809aa652b059bea8ed179638a19077a3f040334032f0e7900ac8b +b3ec6c0c3c007c49c6b7f7fc2ffd3d3a41cdff5ad3ac40831f53bfc0c799ffeed5f440a27acc5f64432e847cc17dd82e +823637abeab5fb19e4810b045254558d98828126e9a2d5895a34b9e4b4f49ab0a5b3ee2422f1f378995ea05df5516057 +ac05412bcf46c254f6548d8107a63928bba19ab6889de5d331eb68cf4d8ce206055b83af4cb7c6c23b50188391e93f84 +88514163c587068178302bc56e9a8b3ad2fa62afd405db92f2478bb730101358c99c0fe40020eeed818c4e251007de9c +b1e657d0f7772795b3f5a84317b889e8ded7a08ea5beb2ab437bebf56bcb508ae7215742819ed1e4ae3969995fe3b35d +a727d4f03027fe858656ca5c51240a65924915bd8bd7ffa3cfc8314a03594738234df717e78bb55a7add61a0a4501836 +b601682830fc4d48ece2bdc9f1a1d5b9a2879c40c46135f00c2c3ae1187c821412f0f0cfbc83d4e144ddd7b702ca8e78 +b5cfea436aa1f29c4446979272a8637cb277f282825674ddb3acac2c280662fb119e6b2bdd52c4b8dbf2c39b1d2070d6 +85c211645ff746669f60aa314093703b9045966604c6aa75aae28422621b256c0c2be835b87e87a00d3f144e8ab7b5f0 +867628d25bab4cb85d448fd50fdd117be1decdd57292e194a8baa0655978fae551912851660a1d5b9de7a2afbb88ef5c +a4e79c55d1b13c959ff93ddcf1747722c6312a7941a3b49f79006b3165334bab369e5469f1bddebadb12bfaff53806d5 +ac61f0973e84546487c5da7991209526c380e3731925b93228d93a93bce1283a3e0807152354f5fe7f3ea44fc447f8fe +a1aa676735a73a671a4e10de2078fd2725660052aa344ca2eb4d56ee0fd04552fe9873ee14a85b09c55708443182183a +8e2f13269f0a264ef2b772d24425bef5b9aa7ea5bbfbefbcc5fd2a5efd4927641c3d2374d0548439a9f6302d7e4ba149 +b0aacdaf27548d4f9de6e1ec3ad80e196761e3fb07c440909524a83880d78c93465aea13040e99de0e60340e5a5503cd +a41b25ae64f66de4726013538411d0ac10fdb974420352f2adb6ce2dcad7b762fd7982c8062a9bac85cdfcc4b577fd18 +b32d87d5d551f93a16ec983fd4ef9c0efcdae4f5e242ce558e77bcde8e472a0df666875af0aeec1a7c10daebebab76ea +b8515795775856e25899e487bf4e5c2b49e04b7fbe40cb3b5c25378bcccde11971da280e8b7ba44d72b8436e2066e20f +91769a608c9a32f39ca9d14d5451e10071de2fd6b0baec9a541c8fad22da75ed4946e7f8b081f79cc2a67bd2452066a9 +87b1e6dbca2b9dbc8ce67fd2f54ffe96dfcce9609210a674a4cb47dd71a8d95a5a24191d87ba4effa4a84d7db51f9ba0 +a95accf3dbcbf3798bab280cabe46e3e3688c5db29944dbe8f9bd8559d70352b0cfac023852adc67c73ce203cbb00a81 +a835f8ce7a8aa772c3d7cfe35971c33fc36aa3333b8fae5225787533a1e4839a36c84c0949410bb6aace6d4085588b1e +8ef7faa2cf93889e7a291713ab39b3a20875576a34a8072a133fed01046f8093ace6b858463e1e8a7f923d57e4e1bc38 +969ecd85643a16d937f148e15fb56c9550aefd68a638425de5058333e8c0f94b1df338eaab1bd683190bfde68460622b +8982f4c76b782b9b47a9c5aeb135278e5c991b1558e47b79328c4fae4b30b2b20c01204ff1afb62b7797879d9dee48e2 +b5098b7ba813178ced68f873c8c223e23a3283d9f1a061c95b68f37310bca4b2934a3a725fff1de1341c79bb3ba6007e +97b160787009f7b9649ed63db9387d48a669e17b2aba8656792eb4f5685bb8e6386f275476b4dfbb1b4cb0c2a69bc752 +88b69369c71daad6b84fa51a0f64a6962d8c77e555b13c035ad6fa1038e7190af455b1bd61ae328b65d6a14cf3d5f0d5 +af88b87801361f0de26bd2533554ee6f4d8067e3122b54161c313c52cc9eafea00661c5c43e2d533485d1f26da4e5510 +98ab18e3bbcb23ac1e34439849e56009bb765ab2f2558ebfd0a57cbe742169f114bceb930533fb911b22cb5a8fe172bc +9027507f1725d81e5ac0f0854c89ab627df3020fe928cb8745f887bf3310086c58fca1119fd5cd18a7d3561c042d58de +a676583f8a26e6f8991a0791916ce785b596ce372812f5eb7b4243ba9367ea95c797170fdac5b0c5e6b7f6519cc2b026 +b91b0ab32638aef3365035a41c6068e36d2303bfee8640565e16c9a56c21703270fd45946ce663238a72c053eb3f2230 +aaf4cd1ac0a30906dcd2b66b37848c6cc443da511e0b0367fd792887fdaf1500551590440e61d837dbee9d24c9801108 +a06f20a02d3cd76029baad5a12592f181738378a83a95e90470fa7cc82a5ae9d2ed824a20eeb1e96e6edc0619f298688 +a465d379c3481b294efc3f2f940b651c45579607cf72d143b99705eae42103a0279eb3595966453130e18935265e35d6 +892a8af7816a806295278027a956663ea1297118ede0f2a7e670483b81fb14dccacc7a652e12f160e531d806ca5f2861 +b480917c0e8b6e00de11b4416a20af6c48a343450a32ee43224559d30e1fecdece52cc699493e1754c0571b84f6c02c2 +b3182da84c81e5a52e22cebed985b0efc3056350ec59e8646e7fd984cdb32e6ac14e76609d0ffaca204a7a3c20e9f95d +a04ea6392f3b5a176fa797ddec3214946962b84a8f729ffbd01ca65767ff6237da8147fc9dc7dd88662ad0faefdb538c +95c0d10a9ba2b0eb1fd7aa60c743b6cf333bb7f3d7adedce055d6cd35b755d326bf9102afabb1634f209d8dacfd47f1a +a1a583d28b07601541fa666767f4f45c954431f8f3cc3f96380364c5044ff9f64114160e5002fb2bbc20812b8cbd36cb +a1a0708af5034545e8fcc771f41e14dff421eed08b4606f6d051f2d7799efd00d3a59a1b9a811fa4eddf5682e63102ea +ab27c7f54096483dd85c866cfb347166abe179dc5ffaca0c29cf3bfe5166864c7fa5f954c919b3ba00bdbab38e03407d +ac8c82271c8ca71125b380ed6c61b326c1cfe5664ccd7f52820e11f2bea334b6f60b1cf1d31599ed94d8218aa6fbf546 +a015ea84237d6aa2adb677ce1ff8a137ef48b460afaca20ae826a53d7e731320ebdd9ee836de7d812178bec010dd6799 +925418cda78a56c5b15d0f2dc66f720bda2885f15ffafb02ce9c9eed7167e68c04ad6ae5aa09c8c1c2f387aa39ad6d1b +87c00bba80a965b3742deacafb269ca94ead4eb57fdb3ed28e776b1d0989e1b1dba289019cfb1a0f849e58668a4f1552 +948d492db131ca194f4e6f9ae1ea6ebc46ebbed5d11f1f305d3d90d6b4995b1218b9606d114f48282a15661a8a8051ca +8179617d64306417d6865add8b7be8452f1759721f97d737ef8a3c90da6551034049af781b6686b2ea99f87d376bce64 +918e3da425b7c41e195ed7b726fa26b15a64299fe12a3c22f51a2a257e847611ac6cfcc99294317523fc491e1cbe60c4 +a339682a37844d15ca37f753599d0a71eedfbbf7b241f231dd93e5d349c6f7130e0d0b97e6abd2d894f8b701da37cb11 +8fc284f37bee79067f473bc8b6de4258930a21c28ac54aaf00b36f5ac28230474250f3aa6a703b6057f7fb79a203c2c1 +a2c474e3a52a48cd1928e755f610fefa52d557eb67974d02287dbb935c4b9aab7227a325424fed65f8f6d556d8a46812 +99b88390fa856aa1b8e615a53f19c83e083f9b50705d8a15922e7c3e8216f808a4cc80744ca12506b1661d31d8d962e4 +a1cbd03e4d4f58fc4d48fa165d824b77838c224765f35d976d3107d44a6cf41e13f661f0e86f87589292721f4de703fb +b3a5dde8a40e55d8d5532beaa5f734ee8e91eafad3696df92399ae10793a8a10319b6dc53495edcc9b5cfd50a389a086 +996e25e1df5c2203647b9a1744bd1b1811857f742aee0801508457a3575666fcc8fc0c047c2b4341d4b507008cd674c2 +93e0a66039e74e324ee6c38809b3608507c492ef752202fff0b2c0e1261ca28f1790b3af4fdb236f0ed7e963e05c1ec0 +b6084e5818d2d860ac1606d3858329fbad4708f79d51a6f072dc370a21fdb1e1b207b74bc265a8547658bfb6a9569bb3 +a5336126a99c0ecfc890584b2a167922a26cae652dfc96a96ab2faf0bf9842f166b39ceaf396cd3d300d0ebb2e6e0ebf +b8b6f13ce9201decaba76d4eca9b9fa2e7445f9bc7dc9f82c262f49b15a40d45d5335819b71ff2ee40465da47d015c47 +b45df257b40c68b7916b768092e91c72b37d3ed2a44b09bf23102a4f33348849026cb3f9fbb484adfea149e2d2a180ff +a50d38ee017e28021229c4bb7d83dd9cdad27ab3aa38980b2423b96aa3f7dc618e3b23895b0e1379ca20299ff1919bbf +97542cf600d34e4fdc07d074e8054e950708284ed99c96c7f15496937242365c66e323b0e09c49c9c38113096640a1b6 +822d198629697dcd663be9c95ff1b39419eae2463fa7e6d996b2c009d746bedc8333be241850153d16c5276749c10b20 +9217bc14974766ebdfbf6b434dd84b32b04658c8d8d3c31b5ff04199795d1cfad583782fd0c7438df865b81b2f116f9c +93477879fa28a89471a2c65ef6e253f30911da44260833dd51030b7a2130a923770ebd60b9120f551ab373f7d9ed80aa +87d89ff7373f795a3a798f03e58a0f0f0e7deab8db2802863fab84a7be64ae4dcf82ece18c4ddbefccd356262c2e8176 +a3ba26bd31d3cc53ceeced422eb9a63c0383cde9476b5f1902b7fe2b19e0bbf420a2172ac5c8c24f1f5c466eecc615d4 +a0fe061c76c90d84bd4353e52e1ef4b0561919769dbabe1679b08ef6c98dcfb6258f122bb440993d976c0ab38854386b +b3070aa470185cb574b3af6c94b4069068b89bb9f7ea7db0a668df0b5e6aabdfe784581f13f0cf35cd4c67726f139a8c +9365e4cdf25e116cbc4a55de89d609bba0eaf0df2a078e624765509f8f5a862e5da41b81883df086a0e5005ce1576223 +a9036081945e3072fa3b5f022df698a8f78e62ab1e9559c88f9c54e00bc091a547467d5e2c7cbf6bc7396acb96dd2c46 +8309890959fcc2a4b3d7232f9062ee51ece20c7e631a00ec151d6b4d5dfccf14c805ce5f9aa569d74fb13ae25f9a6bbe +b1dc43f07303634157f78e213c2fae99435661cc56a24be536ccbd345ef666798b3ac53c438209b47eb62b91d6fea90a +84eb451e0a74ef14a2c2266ff01bd33d9a91163c71f89d0a9c0b8edfcfe918fc549565509cd96eed5720a438ff55f7f2 +9863b85a10db32c4317b19cc9245492b9389b318cf128d9bbc7ec80a694fcbbd3c0d3189a8cad00cc9290e67e5b361ee +8a150ee474ebe48bdfcac1b29e46ac90dcded8abbe4807a165214e66f780f424be367df5ef1e94b09acf4a00cd2e614d +a6677a373130b83e30849af12475e192f817ba4f3226529a9cca8baaefb8811db376e4a044b42bf1481268c249b1a66e +b969cbf444c1297aa50d1dfa0894de4565161cb1fc59ba03af9655c5bf94775006fe8659d3445b546538a22a43be6b93 +8383167e5275e0707e391645dc9dea9e8a19640ecfa23387f7f6fcaddff5cde0b4090dfad7af3c36f8d5c7705568e8d8 +a353ddbc6b6837773e49bb1e33a3e00ca2fb5f7e1dba3a004b0de75f94a4e90860d082a455968851ef050ae5904452e0 +adeccf320d7d2831b495479b4db4aa0e25c5f3574f65a978c112e9981b2663f59de4c2fa88974fdcabb2eedb7adab452 +afa0eacc9fdbe27fb5e640ecad7ecc785df0daf00fc1325af716af61786719dd7f2d9e085a71d8dc059e54fd68a41f24 +a5b803a5bbe0ca77c8b95e1e7bacfd22feae9f053270a191b4fd9bca850ef21a2d4bd9bcd50ecfb971bb458ff2354840 +b023c9c95613d9692a301ef33176b655ba11769a364b787f02b42ceb72338642655ea7a3a55a3eec6e1e3b652c3a179e +8fa616aa7196fc2402f23a19e54620d4cf4cf48e1adfb7ea1f3711c69705481ddcc4c97236d47a92e974984d124589e5 +a49e11e30cb81cb7617935e8a30110b8d241b67df2d603e5acc66af53702cf1e9c3ef4a9b777be49a9f0f576c65dcc30 +8df70b0f19381752fe327c81cce15192389e695586050f26344f56e451df2be0b1cdf7ec0cba7ce5b911dcff2b9325ae +8fbbc21a59d5f5a14ff455ca78a9a393cab91deb61cf1c25117db2714d752e0054ed3e7e13dd36ad423815344140f443 +a9a03285488668ab97836a713c6e608986c571d6a6c21e1adbd99ae4009b3dde43721a705d751f1bd4ebf1ea7511dfed +b2f32b8e19e296e8402251df67bae6066aeefd89047586d887ffa2eacdf38e83d4f9dc32e553799024c7a41818945755 +942cf596b2278ad478be5c0ab6a2ad0ceafe110263cc93d15b9a3f420932104e462cf37586c374f10b1040cb83b862e0 +aaa077a55f501c875ceae0a27ef2b180be9de660ef3d6b2132eb17256771ce609d9bc8aaf687f2b56ae46af34ad12b30 +90ac74885be1448101cf3b957d4486e379673328a006ea42715c39916e9334ea77117ff4a60d858e2ccce9694547a14f +9256cdfc2339e89db56fd04bd9b0611be0eefc5ee30711bcece4aadf2efcc5a6dcc0cfd5f733e0e307e3a58055dff612 +a4c7384e208a0863f4c056248f595473dcde70f019ddaede45b8caf0752575c241bac6e436439f380ac88eee23a858e9 +a3aa67391781e0736dddc389f86b430b2fc293b7bd56bfd5a8ec01d1dd52ed940593c3ad4ce25905061936da062b0af6 +80299275ec322fbb66cc7dce4482ddd846534e92121186b6906c9a5d5834346b7de75909b22b98d73120caec964e7012 +aa3a6cd88e5f98a12738b6688f54478815e26778357bcc2bc9f2648db408d6076ef73cced92a0a6b8b486453c9379f18 +b07c444681dc87b08a7d7c86708b82e82f8f2dbd4001986027b82cfbed17b9043e1104ade612e8e7993a00a4f8128c93 +af40e01b68d908ac2a55dca9b07bb46378c969839c6c822d298a01bc91540ea7a0c07720a098be9a3cfe9c27918e80e8 +abd8947c3bbc3883c80d8c873f8e2dc9b878cbbb4fc4a753a68f5027de6d8c26aa8fbbafeb85519ac94e2db660f31f26 +a234f9d1a8f0cb5d017ccca30b591c95ec416c1cb906bd3e71b13627f27960f61f41ed603ffbcf043fd79974ec3169a8 +835aaf52a6af2bc7da4cf1586c1a27c72ad9de03c88922ad172dce7550d70f6f3efcc3820d38cd56ae3f7fc2f901f7a0 +ae75db982a45ad01f4aa7bc50d642ff188219652bb8d521d13a9877049425d57852f3c9e4d340ffec12a4d0c639e7062 +b88884aa9187c33dc784a96832c86a44d24e9ffe6315544d47fc25428f11337b9ffd56eb0a03ad709d1bf86175059096 +8492ca5afcc6c0187b06453f01ed45fd57eb56facbeea30c93686b9e1dab8eaabd89e0ccb24b5f35d3d19cd7a58b5338 +9350623b6e1592b7ea31b1349724114512c3cce1e5459cd5bddd3d0a9b2accc64ab2bf67a71382d81190c3ab7466ba08 +98e8bf9bed6ae33b7c7e0e49fc43de135bffdba12b5dcb9ff38cb2d2a5368bb570fe7ee8e7fbe68220084d1d3505d5be +ab56144393f55f4c6f80c67e0ab68f445568d68b5aa0118c0c666664a43ba6307ee6508ba0bb5eb17664817bc9749af0 +827d5717a41b8592cfd1b796a30d6b2c3ca2cdc92455f9f4294b051c4c97b7ad6373f692ddafda67884102e6c2a16113 +8445ce2bb81598067edaa2a9e356eda42fb6dc5dd936ccf3d1ff847139e6020310d43d0fec1fe70296e8f9e41a40eb20 +9405178d965ee51e8d76d29101933837a85710961bb61f743d563ef17263f3c2e161d57e133afac209cdb5c46b105e31 +b209f9ed324c0daa68f79800c0a1338bbaf6d37b539871cb7570f2c235caca238a2c4407961fcb7471a103545495ef2c +92ae6437af6bbd97e729b82f5b0d8fb081ca822f340e20fae1875bdc65694cd9b8c037a5a1d49aa9cae3d33f5bad414e +9445bdb666eae03449a38e00851629e29a7415c8274e93343dc0020f439a5df0009cd3c4f5b9ce5c0f79aefa53ceac99 +93fdab5f9f792eada28f75e9ac6042a2c7f3142ba416bfdb1f90aa8461dbe4af524eee6db4f421cb70c7bc204684d043 +a7f4dc949af4c3163953320898104a2b17161f7be5a5615da684f881633174fb0b712d0b7584b76302e811f3fac3c12f +a8ac84da817b3066ba9789bf2a566ccf84ab0a374210b8a215a9dcf493656a3fa0ecf07c4178920245fee0e46de7c3ec +8e6a0ae1273acda3aa50d07d293d580414110a63bc3fb6330bb2ee6f824aff0d8f42b7375a1a5ba85c05bfbe9da88cb5 +a5dea98852bd6f51a84fa06e331ea73a08d9d220cda437f694ad9ad02cf10657882242e20bdf21acbbaa545047da4ce5 +b13f410bf4cfce0827a5dfd1d6b5d8eabc60203b26f4c88238b8000f5b3aaf03242cdeadc2973b33109751da367069e1 +a334315a9d61b692ad919b616df0aa75a9f73e4ea6fc27d216f48964e7daebd84b796418580cf97d4f08d4a4b51037cd +8901ba9e963fcd2f7e08179b6d19c7a3b8193b78ca0e5cf0175916de873ca0d000cd7ac678c0473be371e0ac132f35a2 +b11a445433745f6cb14c9a65314bbf78b852f7b00786501b05d66092b871111cd7bee25f702d9e550d7dd91601620abb +8c2f7b8e7b906c71f2f154cc9f053e8394509c37c07b9d4f21b4495e80484fc5fc8ab4bdc525bd6cfa9518680ba0d1a2 +b9733cebe92b43b899d3d1bfbf4b71d12f40d1853b2c98e36e635fdd8a0603ab03119890a67127e6bc79afae35b0bef2 +a560f6692e88510d9ba940371e1ada344caf0c36440f492a3067ba38e9b7011caac37ba096a8a4accb1c8656d3c019b3 +ac18624339c1487b2626eef00d66b302bdb1526b6340d6847befe2fdfb2b410be5555f82939f8707f756db0e021ed398 +afd9a3b8866a7fe4f7bc13470c0169b9705fcd3073685f5a6dcff3bdbbc2be50ac6d9908f9a10c5104b0bffc2bc14dad +97f15c92fe1f10949ed9def5dd238bc1429706e5037a0e0afb71c2d0e5845e2fed95a171c393e372077a7c7059f8c0e0 +9453a1d4d09c309b70968ea527007d34df9c4cfd3048e5391aac5f9b64ca0c05dde5b8c949c481cfc83ef2e57b687595 +b80e4b7c379ad435c91b20b3706253b763cbc980db78f782f955d2516af44c07bbfa5888cbf3a8439dc3907320feb25a +8939f458d28fefe45320b95d75b006e98330254056d063e4a2f20f04bcb25936024efe8d436d491ed34b482f9b9ae49c +a9ead2e833f71f7e574c766440c4b3c9c3363698c7ade14499a56003a272832ee6d99440887fa43ccdf80265b9d56b97 +b6547a36934f05ce7b779e68049d61351cf229ae72dc211cc96a2a471b2724782f9355fdb415ea6f0ea1eb84fe00e785 +828bfb3099b7b650b29b0f21279f829391f64520a6ab916d1056f647088f1e50fac9253ef7464eceab5380035c5a59c4 +8d714b9ea650be4342ff06c0256189e85c5c125adf6c7aeca3dba9b21d5e01a28b688fc2116ce285a0714a8f1425c0b8 +8a82eda041b2e72a3d73d70d85a568e035fbd6dc32559b6c6cfdf6f4edcb59a6ba85b6294a721aa0a71b07714e0b99ae +af5665ebc83d027173b14ffb0e05af0a192b719177889fadc9ac8c082fda721e9a75d9ce3f5602dbfd516600ee3b6405 +a68fdddf03d77bebdb676e40d93e59bd854408793df2935d0a5600601f7691b879981a398d02658c2da39dbbf61ef96c +8c001ebc84fcf0470b837a08a7b6125126b73a2762db47bbdc38c0e7992b1c66bac7a64faa1bf1020d1c63b40adc3082 +8553889b49f9491109792db0a69347880a9cf2911b4f16f59f7f424e5e6b553687d51282e8f95be6a543635247e2e2c2 +a2c269d6370b541daf1f23cc6b5d2b03a5fa0c7538d53ae500ef875952fe215e74a5010329ff41461f4c58b32ad97b3d +a5dae097285392b4eba83a9fd24baa03d42d0a157a37fae4b6efc3f45be86024b1182e4a6b6eadcf5efe37704c0a1ae5 +89871a77d2032387d19369933cd50a26bda643e40cfd0ce73febe717a51b39fae981406fd41e50f4a837c02a99524ef9 +8a76d495e90093ec2ac22f53759dc1cf36fbb8370fb586acbd3895c56a90bbf3796bcc4fc422ca4058adf337ead1402e +ad4eb7576c4954d20623c1336c63662c2a6fb46ec6ef99b7f8e946aa47488dcb136eab60b35600f98c78c16c10c99013 +894c2b120cec539feb1d281baaadde1e44beafedeeec29b804473fe024e25c1db652f151c956e88d9081fb39d27e0b19 +9196bd5c100878792444c573d02b380a69e1b4b30cb59a48114852085058a5fd952df4afee3ecceb5c4ede21e1ed4a1a +a996fffc910764ea87a1eedc3a3d600e6e0ff70e6a999cb435c9b713a89600fc130d1850174efe9fc18244bb7c6c5936 +8591bb8826befa8bee9663230d9a864a5068589f059e37b450e8c85e15ce9a1992f0ce1ead1d9829b452997727edcf9d +9465e20bb22c41bf1fa728be8e069e25cda3f7c243381ca9973cbedad0c7b07d3dd3e85719d77cf80b1058ce60e16d68 +926b5ce39b6e60b94878ffeae9ff20178656c375fb9cfe160b82318ca500eb3e2e3144608b6c3f8d6c856b8fe1e2fbcf +a1ef29cbc83c45eb28ad468d0ce5d0fdd6b9d8191ba5ffa1a781c2b232ed23db6b7b04de06ef31763a6bfe377fa2f408 +9328e63a3c8acf457c9f1f28b32d90d0eeadb0f650b5d43486a61d7374757a7ada5fc1def2a1e600fa255d8b3f48036f +a9c64880fcb7654f4dd08f4c90baac95712dd6dd407e17ea60606e9a97dc8e54dd25cb72a9bf3fc61f8d0ad569fe369d +a908eb7b940c1963f73046d6b35d40e09013bfbfbeb2ccd64df441867e202b0f3b625fa32dd04987c3d7851360abdffc +b3947b5ed6d59e59e4472cdb1c3261de1b5278fb7cb9b5fca553f328b3b3e094596861ea526eca02395f7b7358155b7b +99da7f190d37bc58945f981cf484d40fcf0855cf8178e2ce8d057c7f0a9d9f77425fdbce9ef8366f44f671b20fd27d0b +913976d77d80e3657977df39571577fdf0be68ba846883705b454f8493578baa741cfaede53783e2c97cc08964395d83 +8d754a61e5164a80b5090c13f3e936056812d4ae8dc5cc649e6c7f37464777249bc4ae760a9806939131f39d92cca5bf +82ffd098480828a90cb221a8c28584e15904bad477c13b2e2d6ef0b96a861ce4a309a328fe44342365349456ad7c654f +89ae3ce4b0357044579ca17be85d8361bb1ce3941f87e82077dd67e43ec0f95edd4bd3426225c90994a81a99e79490b7 +a170892074016d57c9d8e5a529379d7e08d2c1158b9ac4487ac9b95266c4fd51cb18ae768a2f74840137eec05000dd5a +aafd8acd1071103c7af8828a7a08076324d41ea530df90f7d98fafb19735fc27ead91b50c2ca45851545b41d589d0f77 +8623c849e61d8f1696dc9752116a26c8503fd36e2cbbc9650feffdd3a083d8cdbb3b2a4e9743a84b9b2ad91ac33083f2 +ac7166ddd253bb22cdbd8f15b0933c001d1e8bc295e7c38dc1d2be30220e88e2155ecd2274e79848087c05e137e64d01 +a5276b216d3df3273bbfa46210b63b84cfe1e599e9e5d87c4e2e9d58666ecf1af66cb7ae65caebbe74b6806677215bd0 +88792f4aa3597bb0aebadb70f52ee8e9db0f7a9d74f398908024ddda4431221a7783e060e0a93bf1f6338af3d9b18f68 +8f5fafff3ecb3aad94787d1b358ab7d232ded49b15b3636b585aa54212f97dc1d6d567c180682cca895d9876cacb7833 +ab7cb1337290842b33e936162c781aa1093565e1a5b618d1c4d87dd866daea5cebbcc486aaa93d8b8542a27d2f8694c7 +88480a6827699da98642152ebc89941d54b4791fbc66110b7632fb57a5b7d7e79943c19a4b579177c6cf901769563f2f +a725ee6d201b3a610ede3459660658ee391803f770acc639cfc402d1667721089fb24e7598f00e49e81e50d9fd8c2423 +98924372da8aca0f67c8c5cad30fa5324519b014fae7849001dcd51b6286118f12b6c49061219c37714e11142b4d46de +a62c27360221b1a7c99697010dfe1fb31ceb17d3291cf2172624ebeff090cbaa3c3b01ec89fe106dace61d934711d42d +825173c3080be62cfdc50256c3f06fe190bc5f190d0eb827d0af5b99d80936e284a4155b46c0d462ee574fe31d60983d +a28980b97023f9595fadf404ed4aa36898d404fe611c32fd66b70252f01618896f5f3fda71aea5595591176aabf0c619 +a50f5f9def2114f6424ff298f3b128068438f40860c2b44e9a6666f43c438f1780be73cf3de884846f1ba67f9bef0802 +b1eee2d730da715543aeb87f104aff6122cb2bf11de15d2519ff082671330a746445777924521ec98568635f26988d0c +862f6994a1ff4adfd9fb021925cccf542fca4d4b0b80fb794f97e1eb2964ef355608a98eec6e07aadd4b45ee625b2a21 +8ce69a18df2f9b9f6e94a456a7d94842c61dea9b00892da7cf5c08144de9be39b8c304aeca8b2e4222f87ba367e61006 +b5f325b1cecd435f5346b6bc562d92f264f1a6d91be41d612df012684fdd69e86063db077bc11ea4e22c5f2a13ae7bee +85526870a911127835446cb83db8986b12d5637d59e0f139ad6501ac949a397a6c73bd2e7fba731b1bb357efe068242c +8552247d3f7778697f77389717def5a149fc20f677914048e1ed41553b039b5427badc930491c0bae663e67668038fd1 +a545640ee5e51f3fe5de7050e914cfe216202056cd9d642c90e89a166566f909ee575353cb43a331fde17f1c9021414e +8b51229b53cff887d4cab573ba32ec52668d197c084414a9ee5589b285481cea0c3604a50ec133105f661321c3ca50f5 +8cdc0b960522bed284d5c88b1532142863d97bbb7dc344a846dc120397570f7bd507ceb15ed97964d6a80eccfef0f28e +a40683961b0812d9d53906e795e6470addc1f30d09affebf5d4fbbd21ddfa88ce441ca5ea99c33fd121405be3f7a3757 +a527875eb2b99b4185998b5d4cf97dd0d4a937724b6ad170411fc8e2ec80f6cee2050f0dd2e6fee9a2b77252d98b9e64 +84f3a75f477c4bc4574f16ebc21aaa32924c41ced435703c4bf07c9119dd2b6e066e0c276ff902069887793378f779e0 +a3544bc22d1d0cab2d22d44ced8f7484bfe391b36991b87010394bfd5012f75d580596ffd4f42b00886749457bb6334b +b81f6eb26934b920285acc20ceef0220dd23081ba1b26e22b365d3165ce2fbae733bbc896bd0932f63dcc84f56428c68 +95e94d40a4f41090185a77bf760915a90b6a3e3ace5e53f0cb08386d438d3aa3479f0cd81081b47a9b718698817265cd +b69bd1625b3d6c17fd1f87ac6e86efa0d0d8abb69f8355a08739109831baeec03fd3cd4c765b5ff8b1e449d33d050504 +8448f4e4c043519d98552c2573b76eebf2483b82d32abb3e2bfc64a538e79e4f59c6ca92adff1e78b2f9d0a91f19e619 +8f11c42d6a221d1fda50887fb68b15acdb46979ab21d909ed529bcad6ae10a66228ff521a54a42aca0dad6547a528233 +a3adb18d7e4a882b13a067784cf80ea96a1d90f5edc61227d1f6e4da560c627688bdf6555d33fe54cab1bca242986871 +a24d333d807a48dc851932ed21cbdd7e255bad2699909234f1706ba55dea4bb6b6f8812ffc0be206755868ba8a4af3f9 +a322de66c22a606e189f7734dbb7fda5d75766d5e69ec04b4e1671d4477f5bcb9ff139ccc18879980ebc3b64ab4a2c49 +88f54b6b410a1edbf125db738d46ee1a507e69bc5a8f2f443eb787b9aa7dbd6e55014ec1e946aabeb3e27a788914fb04 +b32ee6da1dcd8d0a7fd7c1821bb1f1fe919c8922b4c1eeed56e5b068a5a6e68457c42b192cbaef5dc6d49b17fa45bc0f +8a44402da0b3a15c97b0f15db63e460506cb8bef56c457166aea5e8881087d8202724c539ef0feb97131919a73aefca8 +b967e3fead6171fa1d19fd976535d428b501baff59e118050f9901a54b12cc8e4606348454c8f0fc25bd6644e0a5532e +b7a0c9e9371c3efbbb2c6783ce2cc5f149135175f25b6d79b09c808bce74139020e77f0c616fa6dcb3d87a378532529d +a54207782ffc909cd1bb685a3aafabbc4407cda362d7b3c1b14608b6427e1696817aeb4f3f85304ac36e86d3d8caa65b +98c1da056813a7bfebc81d8db7206e3ef9b51f147d9948c088976755826cc5123c239ca5e3fe59bed18b5d0a982f3c3f +ae1c86174dfafa9c9546b17b8201719aecd359f5bbeb1900475041f2d5b8a9600d54d0000c43dd061cfda390585726ff +a8ee5a8be0bd1372a35675c87bfd64221c6696dc16e2d5e0996e481fec5cdbcb222df466c24740331d60f0521285f7d3 +8ddadbe3cf13af50d556ce8fc0dd77971ac83fad9985c3d089b1b02d1e3afc330628635a31707b32595626798ea22d45 +a5c80254baf8a1628dc77c2445ebe21fbda0de09dd458f603e6a9851071b2b7438fe74214df293dfa242c715d4375c95 +b9d83227ed2600a55cb74a7052003a317a85ca4bea50aa3e0570f4982b6fe678e464cc5156be1bd5e7bba722f95e92c5 +b56085f9f3a72bea9aa3a8dc143a96dd78513fa327b4b9ba26d475c088116cab13843c2bff80996bf3b43d3e2bddb1d6 +8fa9b39558c69a9757f1e7bc3f07295e4a433da3e6dd8c0282397d26f64c1ecd8eb3ba9824a7cacfb87496ebbb45d962 +879c6d0cb675812ed9dee68c3479a499f088068501e2677caeae035e6f538da91a49e245f5fcce135066169649872bee +91aa9fd3fed0c2a23d1edda8a6542188aeb8abee8772818769bdee4b512d431e4625a343af5d59767c468779222cf234 +a6be0bb2348c35c4143482c7ef6da9a93a5356f8545e8e9d791d6c08ed55f14d790d21ee61d3a56a2ae7f888a8fd46ca +808ee396a94e1b8755f2b13a6ffbedef9e0369e6c2e53627c9f60130c137299d0e4924d8ef367e0a7fad7f68a8c9193c +ad1086028fcdac94d5f1e7629071e7e47e30ad0190ae59aaebfb7a7ef6202ab91323a503c527e3226a23d7937af41a52 +9102bdaf79b907d1b25b2ec6b497e2d301c8eac305e848c6276b392f0ad734131a39cc02ed42989a53ca8da3d6839172 +8c976c48a45b6bc7cd7a7acea3c2d7c5f43042863b0661d5cd8763e8b50730552187a8eecf6b3d17be89110208808e77 +a2624c7e917e8297faa3af89b701953006bf02b7c95dfba00c9f3de77748bc0b13d6e15bb8d01377f4d98fb189538142 +a405f1e66783cdcfe20081bce34623ec3660950222d50b7255f8b3cc5d4369aeb366e265e5224c0204911539f0fa165e +8d69bdcaa5d883b5636ac8f8842026fcc58c5e2b71b7349844a3f5d6fbecf44443ef4f768eac376f57fb763606e92c9f +82fce0643017d16ec1c3543db95fb57bfa4855cc325f186d109539fcacf8ea15539be7c4855594d4f6dc628f5ad8a7b0 +8860e6ff58b3e8f9ae294ff2487f0d3ffae4cf54fd3e69931662dabc8efd5b237b26b3def3bcd4042869d5087d22afcf +88c80c442251e11c558771f0484f56dc0ed1b7340757893a49acbf96006aa73dfc3668208abea6f65375611278afb02a +8be3d18c6b4aa8e56fcd74a2aacb76f80b518a360814f71edb9ccf3d144bfd247c03f77500f728a62fca7a2e45e504c5 +8b8ebf0df95c3f9b1c9b80469dc0d323784fd4a53f5c5357bb3f250a135f4619498af5700fe54ad08744576588b3dfff +a8d88abdaadd9c2a66bc8db3072032f63ed8f928d64fdb5f810a65074efc7e830d56e0e738175579f6660738b92d0c65 +a0a10b5d1a525eb846b36357983c6b816b8c387d3890af62efb20f50b1cb6dd69549bbef14dab939f1213118a1ae8ec2 +8aadf9b895aeb8fdc9987daa937e25d6964cbd5ec5d176f5cdf2f0c73f6f145f0f9759e7560ab740bf623a3279736c37 +99aeda8a495031cc5bdf9b842a4d7647c55004576a0edc0bd9b985d60182608361ed5459a9d4b21aa8e2bd353d10a086 +832c8b3bfcd6e68eee4b100d58014522de9d4cefa99498bc06c6dca83741e4572e20778e0d846884b33439f160932bca +841f56ebefc0823ab484fc445d62f914e13957e47904419e42771aa605e33ab16c44f781f6f9aa42e3a1baf377f54b42 +a6e40271d419e295a182725d3a9b541ffd343f23e37549c51ecaa20d13cf0c8d282d6d15b24def5702bfee8ba10b12ac +8ac00925ac6187a4c5cde48ea2a4eaf99a607e58b2c617ee6f01df30d03fafada2f0469178dd960d9d64cbd33a0087d8 +b6b80916b540f8a0fe4f23b1a06e2b830008ad138271d5ba3cd16d6619e521fe2a7623c16c41cba48950793386eea942 +8412c0857b96a650e73af9d93087d4109dd092ddf82188e514f18fcac644f44d4d62550bfa63947f2d574a2e9d995bbb +b871395baa28b857e992a28ac7f6d95ec461934b120a688a387e78498eb26a15913b0228488c3e2360391c6b7260b504 +926e2d25c58c679be77d0e27ec3b580645956ba6f13adcbc2ea548ee1b7925c61fcf74c582337a3b999e5427b3f752f2 +a165fa43fecae9b913d5dcfc232568e3e7b8b320ce96b13800035d52844c38fd5dbf7c4d564241d860c023049de4bcbc +b4976d7572fd9cc0ee3f24888634433f725230a7a2159405946a79315bc19e2fc371448c1c9d52bf91539fd1fe39574b +a6b461eb72e07a9e859b9e16dfa5907f4ac92a5a7ca4368b518e4a508dc43f9b4be59db6849739f3ef4c44967b63b103 +b976606d3089345d0bc501a43525d9dca59cf0b25b50dfc8a61c5bd30fac2467331f0638fab2dc68838aa6ee8d2b6bc9 +b16ea61c855da96e180abf7647fa4d9dd6fd90adebadb4c5ed4d7cd24737e500212628fca69615d89cb40e9826e5a214 +95a3e3162eb5ea27a613f8c188f2e0dcc5cbd5b68c239858b989b004d87113e6aa3209fa9fad0ee6ecef42814ba9db1a +b6a026ab56d3224220e5bce8275d023c8d39d1bdf7eec3b0923429b7d5ef18cf613a3591d364be8727bb1fa0ba11eabb +949f117e2e141e25972ee9ccdd0b7a21150de7bbf92bbd89624a0c5f5a88da7b2b172ba2e9e94e1768081f260c2a2f8d +b7c5e9e6630287d2a20a2dfb783ffe6a6ff104ff627c6e4e4342acc2f3eb6e60e9c22f465f8a8dc58c42f49840eca435 +872be5a75c3b85de21447bb06ac9eb610f3a80759f516a2f99304930ddf921f34cbffc7727989cdd7181d5fc62483954 +a50976ea5297d797d220932856afdd214d1248230c9dcd840469ecc28ea9f305b6d7b38339fedb0c00b5251d77af8c95 +80b360f8b44914ff6f0ffbd8b5360e3cabe08639f6fe06d0c1526b1fe9fe9f18c497f1752580b30e950abd3e538ad416 +a2f98f9bf7fac78c9da6bb41de267742a9d31cf5a04b2fb74f551084ec329b376f651a59e1ae919b2928286fb566e495 +8b9d218a8a6c150631548e7f24bbd43f132431ae275c2b72676abbea752f554789c5ff4aac5c0eeee5529af7f2b509ef +aa21a243b07e9c7b169598bf0b102c3c280861780f83121b2ef543b780d47aaa4b1850430ee7927f33ece9847c4e0e1a +8a6f90f4ce58c8aa5d3656fe4e05acccf07a6ec188a5f3cde7bf59a8ae468e66f055ac6dfc50b6e8e98f2490d8deedc5 +8e39f77ca4b5149ffe9945ceac35d068760ba338d469d57c14f626dd8c96dbe993dd7011beff727c32117298c95ee854 +83bd641c76504222880183edd42267e0582642c4993fe2c7a20ce7168e4c3cbf7586e1d2d4b08c84d9b0bf2f6b8800b8 +a9d332993cf0c1c55130e5cf3a478eb5e0bfb49c25c07538accc692ef03d82b458750a7b991cc0b41b813d361a5d31e3 +a0fc60e6a6015df9bee04cea8f20f01d02b14b6f7aa03123ab8d65da071b2d0df5012c2a69e7290baae6ed6dd29ebe07 +a2949dde2e48788ceaac7ec7243f287ffe7c3e788cdba97a4ab0772202aeef2d50382bed8bf7eff5478243f7eabe0bda +a7879373ea18572dba6cf29868ca955ffa55b8af627f29862f6487ee398b81fe3771d8721ca8e06716c5d91b9ac587cb +b3c7081e2c5306303524fbe9fe5645111a57dffd4ec25b7384da12e56376a0150ab52f9d9cc6ca7bdd950695e39b766d +a634a6a19d52dcb9f823352b36c345d2de54b75197bcd90528d27830bd6606d1a9971170de0849ed5010afa9f031d5be +88f2062f405fa181cfdb8475eaf52906587382c666ca09a9522537cfebbc7de8337be12a7fd0db6d6f2f7ab5aefab892 +b1f0058c1f273191247b98783b2a6f5aa716cf799a8370627fc3456683f03a624d0523b63a154fe9243c0dfd5b37c460 +ae39a227cc05852437d87be6a446782c3d7fbe6282e25cf57b6b6e12b189bdc0d4a6e2c3a60b3979256b6b5baf8f1c5f +802a1af228ab0c053b940e695e7ef3338f5be7acf4e5ed01ac8498e55b492d3a9f07996b1700a84e22f0b589638909cd +a36490832f20e4b2f9e79ee358b66d413f034d6a387534b264cdeac2bca96e8b5bcbdd28d1e98c44498032a8e63d94d2 +8728c9a87db2d006855cb304bba54c3c704bf8f1228ae53a8da66ca93b2dac7e980a2a74f402f22b9bc40cd726e9c438 +a08f08ab0c0a1340e53b3592635e256d0025c4700559939aeb9010ed63f7047c8021b4210088f3605f5c14fb51d1c613 +9670fd7e2d90f241e8e05f9f0b475aa260a5fb99aa1c9e61cd023cbad8ed1270ae912f168e1170e62a0f6d319cf45f49 +a35e60f2dd04f098bf274d2999c3447730fe3e54a8aff703bc5a3c274d22f97db4104d61a37417d93d52276b27ef8f31 +859df7a21bc35daec5695201bd69333dc4f0f9e4328f2b75a223e6615b22b29d63b44d338413ca97eb74f15563628cb7 +b2b44ad3e93bc076548acdf2477803203108b89ecc1d0a19c3fb9814d6b342afc420c20f75e9c2188ad75fdb0d34bb2d +941173ee2c87765d10758746d103b667b1227301e1bcfecef2f38f9ab612496a9abd3050cef5537bf28cfecd2aacc449 +92b0bea30ebed20ac30648efb37bac2b865daaa514316e6f5470e1de6cb84651ff77c127aa7beed4521bda5e8fc81122 +af17bf813bb238cf8bb437433f816786612209180a6c0a1d5141292dc2d2c37164ef13bfc50c718bfcc6ce26369298a2 +8461fd951bdfda099318e05cc6f75698784b033f15a71bce26165f0ce421fd632d50df9eeced474838c0050b596e672c +83281aa18ae4b01e8201e1f64248cc6444c92ee846ae72adb178cef356531558597d84ff93a05abf76bfe313eb7dbe86 +b62b150f73999c341daa4d2f7328d2f6ca1ef3b549e01df58182e42927537fc7971c360fe8264af724f4c0247850ef12 +a7022a201f79c012f982b574c714d813064838a04f56964d1186691413757befeeaada063e7884297606e0eea1b1ed43 +a42ac9e8be88e143853fd8e6a9ff21a0461801f0ac76b69cca669597f9af17ecb62cccdcdcbe7f19b62ab93d7f838406 +80f1ca73b6ba3a2fbae6b79b39c0be8c39df81862d46c4990c87cbf45b87996db7859d833abc20af2fcb4faf059c436a +b355943e04132d5521d7bbe49aea26f6aa1c32f5d0853e77cc2400595325e923a82e0ff7601d1aee79f45fd8a254f6ae +87142c891d93e539b31d0b5ead9ea600b9c84db9be9369ff150a8312fe3d10513f4c5b4d483a82b42bc65c45dd9dd3bd +823c3d7f6dda98a9d8c42b3fee28d3154a95451402accadb6cf75fc45d2653c46a569be75a433094fa9e09c0d5cf1c90 +b3c3497fe7356525c1336435976e79ec59c5624c2fb6185ee09ca0510d58b1e392965e25df8a74d90d464c4e8bb1422b +88c48d83e8ddc0d7eea051f3d0e21bc0d3a0bb2b6a39ece76750c1c90c382a538c9a35dc9478b8ceb8157dcccbbf187a +93da81a8939f5f58b668fefdc6f5f7eca6dc1133054de4910b651f8b4a3267af1e44d5a1c9e5964dc7ab741eb146894b +8b396e64985451ac337f16be61105106e262e381ea04660add0b032409b986e1ac64da3bc2feae788e24e9cb431d8668 +9472068b6e331ea67e9b5fbf8057672da93c209d7ded51e2914dbb98dccd8c72b7079b51fd97a7190f8fc8712c431538 +ac47e1446cb92b0a7406f45c708567f520900dfa0070d5e91783139d1bfc946d6e242e2c7b3bf4020500b9f867139709 +896053706869fb26bb6f7933b3d9c7dd6db5c6bd1269c7a0e222b73039e2327d44bda7d7ae82bf5988808b9831d78bcd +a55e397fa7a02321a9fe686654c86083ecedb5757586d7c0250ec813ca6d37151a12061d5feca4691a0fd59d2f0fdd81 +ae23f08ac2b370d845036518f1bddb7fea8dc59371c288a6af310486effeb61963f2eef031ca90f9bdbcf0e475b67068 +b5462921597a79f66c0fec8d4c7cfd89f427692a7ce30d787e6fd6acd2377f238ec74689a0fdbe8ef3c9c9bd24b908dc +ae67e8ea7c46e29e6aae6005131c29472768326819aa294aaf5a280d877de377b44959adb1348fa3e929dcbc3ae1f2c0 +84962b4c66500a20c4424191bdfb619a46cda35bdb34c2d61edcb0b0494f7f61dd5bf8f743302842026b7b7d49edd4b5 +846f76286dc3cc59cb15e5dabb72a54a27c78190631df832d3649b2952fa0408ecde7d4dfdae7046c728efa29879fb51 +8f76c854eaee8b699547e07ad286f7dadfa6974c1328d12502bd7630ae619f6129272fdd15e2137ffef0143c42730977 +8007b163d4ea4ec6d79e7a2aa19d06f388da0b3a56f3ee121441584e22a246c0e792431655632bf6e5e02cb86914eebf +ac4d2cecc1f33e6fb73892980b61e62095ddff5fd6167f53ca93d507328b3c05440729a277dc3649302045b734398af1 +92d2a88f2e9c9875abaff0d42624ccb6d65401de7127b5d42c25e6adccd7a664504c5861618f9031ced8aeb08b779f06 +a832c1821c1b220eb003fc532af02c81196e98df058cdcc9c9748832558362915ea77526937f30a2f74f25073cb89afb +b6f947ab4cc2baec100ed8ec7739a2fd2f9504c982b39ab84a4516015ca56aea8eef5545cfc057dd44c69b42125fb718 +b24afacf2e90da067e5c050d2a63878ee17aaf8fd446536f2462da4f162de87b7544e92c410d35bf2172465940c19349 +b7a0aa92deac71eaab07be8fa43086e071e5580f5dbf9b624427bdd7764605d27303ae86e5165bed30229c0c11958c38 +b0d1d5bfa1823392c5cf6ed927c1b9e84a09a24b284c2cd8fcb5fda8e392c7c59412d8f74eb7c48c6851dff23ae66f58 +a24125ef03a92d2279fb384186ca0274373509cfec90b34a575490486098438932ee1be0334262d22d5f7d3db91efe67 +83e08e5fba9e8e11c164373794f4067b9b472d54f57f4dbe3c241cf7b5b7374102de9d458018a8c51ab3aed1dddf146f +9453101b77bb915ed40990e1e1d2c08ea8ec5deb5b571b0c50d45d1c55c2e2512ec0ceca616ff0376a65678a961d344d +92a0516e9eb6ad233d6b165a8d64a062ce189b25f95d1b3264d6b58da9c8d17da2cd1f534800c43efcf2be73556cd2ff +958d0b5d7d8faf25d2816aa6a2c5770592ad448db778dd9b374085baa66c755b129822632eaabcb65ee35f0bf4b73634 +90a749de8728b301ad2a6b044e8c5fd646ccd8d20220e125cba97667e0bb1d0a62f6e3143b28f3d93f69cdc6aa04122a +84bd34c8d8f74dec07595812058db24d62133c11afed5eb2a8320d3bfc28e442c7f0cfd51011b7b0bb3e5409cb7b6290 +aecc250b556115d97b553ad7b2153f1d69e543e087890000eaa60f4368b736921d0342ce5563124f129096f5d5e2ca9d +977f17ac82ed1fbf422f9b95feb3047a182a27b00960296d804fd74d54bb39ad2c055e665c1240d2ad2e06a3d7501b00 +af5be9846bd4879ebe0af5e7ad253a632f05aedfe306d31fe6debe701ba5aa4e33b65efc05043bc73aadb199f94baed4 +9199e12ec5f2aaaeed6db5561d2dcc1a8fe9c0854f1a069cba090d2dff5e5ba52b10c841ccbd49006a91d881f206150d +8f4a96a96ed8ceaf3beba026c89848c9ca4e6452ce23b7cf34d12f9cc532984a498e051de77745bdc17c7c44c31b7c30 +af3f2a3dbe8652c4bfca0d37fb723f0e66aab4f91b91a625114af1377ad923da8d36da83f75deb7a3219cd63135a3118 +a6d46963195df8962f7aa791d104c709c38caa438ddd192f7647a884282e81f748c94cdf0bb25d38a7b0dc1b1d7bbcf7 +86f3de4b22c42d3e4b24b16e6e8033e60120af341781ab70ae390cb7b5c5216f6e7945313c2e04261a51814a8cb5db92 +b9f86792e3922896cfd847d8ff123ff8d69ecf34968fb3de3f54532f6cd1112b5d34eeabdca46ae64ad9f6e7e5b55edc +83edfbcbc4968381d1e91ab813b3c74ab940eaf6358c226f79182f8b21148ec130685fd91b0ea65916b0a50bccf524ea +93b61daca7a8880b7926398760f50016f2558b0bab74c21181280a1baf3414fc539911bb0b79c4288d29d3c4ad0f4417 +ad541aeb83a47526d38f2e47a5ce7e23a9adabe5efeae03541026881e6d5ef07da3ac1a6ed466ca924fa8e7a91fcff88 +ac4bba31723875025640ed6426003ed8529215a44c9ffd44f37e928feef9fc4dfa889088131c9be3da87e8f3fdf55975 +88fa4d49096586bc9d29592909c38ea3def24629feacd378cc5335b70d13814d6dac415f8c699ee1bf4fe8b85eb89b38 +b67d0b76cbd0d79b71f4673b96e77b6cda516b8faa1510cfe58ff38cc19000bb5d73ff8418b3dab8c1c7960cb9c81e36 +98b4f8766810f0cfecf67bd59f8c58989eb66c07d3dfeee4f4bbce8fd1fce7cc4f69468372eaec7d690748543bd9691d +8445891af3c298b588dec443beacdf41536adb84c812c413a2b843fd398e484eb379075c64066b460839b5fe8f80177c +b603635c3ed6fdc013e2a091fc5164e09acf5f6a00347d87c6ebadb1f44e52ff1a5f0466b91f3f7ffc47d25753e44b75 +87ec2fc928174599a9dafe7538fec7dcf72e6873b17d953ed50708afff0da37653758b52b7cafa0bf50dfcf1eafbb46c +b9dbd0e704d047a457d60efe6822dc679e79846e4cbcb11fa6c02079d65673ee19bbf0d14e8b7b200b9205f4738df7c7 +9591ec7080f3f5ba11197a41f476f9ba17880f414d74f821a072ec5061eab040a2acba3d9856ff8555dfe5eaeb14ca19 +b34c9d1805b5f1ce38a42b800dec4e7f3eb8c38e7d2b0a525378e048426fed150dbfe9cc61f5db82b406d1b9ff2d10bf +a36fdc649dc08f059dfa361e3969d96b4cc4a1ebf10b0cd01a7dd708430979e8d870961fef85878f8779b8e23caafb18 +88dfc739a80c16c95d9d6f73c3357a92d82fa8c3c670c72bee0f1e4bac9ec338e1751eb786eda3e10f747dd7a686900f +84a535ad04f0961756c61c70001903a9adf13126983c11709430a18133c4b4040d17a33765b4a06968f5d536f4bfb5c5 +8c86d695052a2d2571c5ace744f2239840ef21bb88e742f050c7fa737cd925418ecef0971333eb89daa6b3ddfede268c +8e9a700157069dc91e08ddcbdde3a9ad570272ad225844238f1015004239c542fceb0acce6d116c292a55f0d55b6175e +84d659e7f94e4c1d15526f47bc5877a4ef761c2a5f76ec8b09c3a9a30992d41b0e2e38ed0c0106a6b6c86d670c4235f3 +a99253d45d7863db1d27c0ab561fb85da8c025ba578b4b165528d0f20c511a9ca9aff722f4ff7004843f618eb8fced95 +89a3cacb15b84b20e95cd6135550146bbe6c47632cc6d6e14d825a0c79b1e02b66f05d57d1260cb947dc4ae5b0283882 +8385b1555e794801226c44bd5e878cbe68aeac0a19315625a8e5ea0c3526b58cdd4f53f9a14a167a5e8a293b530d615a +b68c729e9df66c5cd22af4909fb3b0057b6a231c4a31cd6bf0fa0e53c5809419d15feb483de6e9408b052458e819b097 +924f56eda269ec7ec2fc20c5731bf7f521546ddf573ccbe145592f1c9fee5134747eb648d9335119a8066ca50a1f7e50 +b2100a26b9c3bec7ec5a53f0febbf56303f199be2f26b2d564cfee2adc65483b84192354f2865c2f4c035fa16252ae55 +8f64dbed62e638563967ec1605a83216aed17eb99aa618c0543d74771ea8f60bbb850c88608d4f8584f922e30a8a0a72 +b31b9e1ffe8d7260479c9413f8e680f3fe391ae8fcf44fcca3000d9b2473a40c1d32299f8f63865a57579a2d6c7e9f08 +a5b1d136142eb23e322c6c07cb838a3f58ab6925472352ebd0bb47041a0d8729e1074ca223922f3a7a672ced7a1e562d +8d9470a5a15d833a447b5f108333d50f30aa7659e331c3f8080b1e928a99922edc650466a2f54f3d48afdb34bff42142 +866368f5891564e5b2de37ad21ff0345c01129a14ea5667f9b64aad12d13ec034622872e414743af0bf20adb2041b497 +88ef9c2ebf25fd0c04b7cfa35fbac2e4156d2f1043fa9f98998b2aa402c8f9a4f1039e782451a46840f3e0e4b3fa47d3 +94ba04a4859273697e264a2d238dc5c9ff573ebc91e4796ea58eebe4080c1bf991255ab2ad8fb1e0301ce7b79cc6e69b +86b6bd0953309a086e526211bf1a99327269304aa74d8cdc994cee63c3a2d4b883e832b0635888dff2a13f1b02eb8df4 +843ea6ea5f2c7a1fd50be56a5765dcce3ea61c99b77c1a729ee0cd8ec706385ac7062e603479d4c8d3527f030762d049 +8d3675195a3b06f2d935d45becc59f9fa8fa440c8df80c029775e47fe9c90e20f7c8e4cc9a2542dd6bfe87536c428f0d +8978580b0c9b0aa3ab2d47e3cfd92fa891d3ddee57829ee4f9780e8e651900457d8e759d1a9b3e8f6ae366e4b57f2865 +890112ec81d0f24b0dfbb4d228e418eff02ae63dc691caf59c1d103e1d194e6e2550e1bec41c0bfdb74fed454f621d0c +97da00bd4b19d1e88caff7f95b8b9a7d29bc0afe85d0c6a163b4b9ef336f0e90e2c49ce6777024bb08df908cc04ea1ca +b458268d275a5211106ccaa8333ce796ef2939b1c4517e502b6462e1f904b41184a89c3954e7c4f933d68b87427a7bfd +aac9c043ba8ba9283e8428044e6459f982413380ee7005a996dc3cc468f6a21001ecaa3b845ce2e73644c2e721940033 +82145013c2155a1200246a1e8720adf8a1d1436b10d0854369d5b1b6208353e484dd16ce59280c6be84a223f2d45e5e2 +b301bafa041f9b203a46beab5f16160d463aa92117c77a3dc6a9261a35645991b9bafcc186c8891ca95021bd35f7f971 +a531b8d2ac3de09b92080a8d8857efa48fb6a048595279110e5104fee7db1dd7f3cfb8a9c45c0ed981cbad101082e335 +a22ac1d627d08a32a8abd41504b5222047c87d558ffae4232cefdeb6a3dc2a8671a4d8ddfba2ff9068a9a3ffb0fe99b1 +b8d9f0e383c35afb6d69be7ff04f31e25c74dd5751f0e51290c18814fbb49ee1486649e64355c80e93a3d9278bd21229 +8165babccd13033a3614c878be749dfa1087ecbeee8e95abcfffe3aa06695711122cb94477a4d55cffd2febf0c1173de +a4c1bc84ecb9d995d1d21c2804adf25621676d60334bd359dac3a2ec5dc8de567aa2831c10147034025fb3e3afb33c4b +b77307cab8e7cb21e4038493058fb6db9e2ec91dda9d7f96f25acbc90309daf7b6d8a205682143ee35d675e9800c3b08 +aaf7466083cd1f325ba860efe3faf4cebe6a5eecf52c3e8375d72043a5cfc8e6cb4b40f8e48f97266e84f0d488e8badf +9264a05a3abc2a5b4958f957f3a486a5eb3ddd10ff57aa6943c9430d0cfa01d63b72695b1ade50ac1b302d312175e702 +b3f9e4c589ad28b1eceed99dc9980fac832524cfcbe4a486dfeedb4b97c080e24bdb3967e9ca63d2240e77f9addfaefd +b2c1e253a78e7179e5d67204422e0debfa09c231970b1bfb70f31a8d77c7f5059a095ca79d2e9830f12c4a8f88881516 +81865a8a25913d1072cb5fd9505c73e0fde45e4c781ddd20fb0a7560d8b1cd5e1f63881c6efc05360e9204dfa6c3ce16 +ab71c2ea7fa7853469a2236dedb344a19a6130dc96d5fd6d87d42d3fffda172557d203b7688ce0f86acd913ce362e6cd +8aa2051bc3926c7bd63565f3782e6f77da824cb3b22bb056aa1c5bccfa274c0d9e49a91df62d0e88876e2bd7776e44b9 +b94e7074167745323d1d353efe7cfb71f40a390e0232354d5dfd041ef523ac8f118fb6dcc42bf16c796e3f61258f36f8 +8210fcf01267300cb1ccf650679cf6e1ee46df24ae4be5364c5ff715332746c113d680c9a8be3f17cacaeb3a7ba226ce +905ac223568eedc5acd8b54e892be05a21abbb4083c5dbec919129f9d9ffa2c4661d78d43bf5656d8d7aafa06f89d647 +a6e93da7e0c998e6ce2592d1aa87d12bf44e71bec12b825139d56682cdce8f0ba6dbfe9441a9989e10578479351a3d9d +acde928a5e2df0d65de595288f2b81838155d5673013100a49b0cb0eb3d633237af1378148539e33ccd1b9a897f0fec3 +a6e1a47e77f0114be6ae7acd2a51e6a9e38415cce7726373988153cdd5d4f86ef58f3309adc5681af4a159300ed4e5b5 +ad2b6a0d72f454054cb0c2ebc42cd59ff2da7990526bd4c9886003ba63b1302a8343628b8fe3295d3a15aa85150e0969 +b0bc3aea89428d7918c2ee0cc57f159fba134dad224d0e72d21a359ca75b08fbb4373542f57a6408352033e1769f72c6 +aad0497525163b572f135fad23fdd8763631f11deeaf61dea5c423f784fe1449c866040f303555920dc25e39cdb2e9b4 +8ce5d8310d2e17342bf881d517c9afc484d12e1f4b4b08ad026b023d98cba410cd9a7cc8e2c3c63456652a19278b6960 +8d9d57dbb24d68b6152337872bd5d422198da773174ade94b633f7c7f27670ff91969579583532ae7d8fe662c6d8a3b0 +855a1c2d83becb3f02a8f9a83519d1cb112102b61d4cdd396844b5206e606b3fefdbcc5aa8751da2b256d987d74d9506 +90eb7e6f938651f733cf81fcd2e7e8f611b627f8d94d4ac17ac00de6c2b841e4f80cada07f4063a13ae87b4a7736ca28 +8161459a21d55e7f5f1cecfc1595c7f468406a82080bfa46d7fb1af4b5ec0cd2064c2c851949483db2aa376e9df418e6 +8344ccd322b2072479f8db2ab3e46df89f536408cba0596f1e4ec6c1957ff0c73f3840990f9028ae0f21c1e9a729d7df +929be2190ddd54a5afe98c3b77591d1eae0ab2c9816dc6fe47508d9863d58f1ea029d503938c8d9e387c5e80047d6f1e +856e3d1f701688c650c258fecd78139ce68e19de5198cf1cd7bb11eba9d0f1c5af958884f58df10e3f9a08d8843f3406 +8490ae5221e27a45a37ca97d99a19a8867bcc026a94f08bdccfbb4b6fa09b83c96b37ec7e0fd6ee05f4ae6141b6b64a8 +b02dbd4d647a05ac248fda13708bba0d6a9cd00cae5634c1938b4c0abbb3a1e4f00f47aa416dcd00ffcdf166330bff9a +9076164bb99ca7b1a98d1e11cb2f965f5c22866658e8259445589b80e3cb3119c8710ede18f396ba902696785619079c +aacf016920936dae63778ad171386f996f65fe98e83cfcdd75e23774f189303e65cc8ad334a7a62f9230ed2c6b7f6fa4 +a8031d46c7f2474789123469ef42e81c9c35eb245d38d8f4796bba406c02b57053f5ec554d45373ab437869a0b1af3f0 +a4b76cd82dc1f305a0ee053e9a4212b67f5acc5e69962a8640d190a176b73fbc2b0644f896ff3927cd708d524668ed09 +b00b029c74e6fdf7fb94df95ef1ccad025c452c19cddb5dccfb91efdcb8a9a1c17847cfa4486eae4f510e8a6c1f0791a +9455e5235f29a73e9f1a707a97ddb104c55b9d6a92cc9952600d49f0447d38ea073ee5cf0d13f7f55f12b4a5132f4b10 +ae118847542ed1084d269e8f3b503d0b6571a2c077def116ad685dcca2fca3dcb3f86e3f244284bdcd5ae7ac968d08a5 +8dcb4965cd57e8b89cd71d6fc700d66caa805bfd29ab71357961527a7894e082d49145c2614b670dcb231ab9050d0663 +add6ed14f3183f4acc73feea19b22c9a330e431c674e5034924da31b69e8c02d79b570d12ef771a04215c4809e0f8a80 +96ae7e110412ee87d0478fdbdbaab290eb0b6edd741bb864961845e87fd44bcbe630371060b8104d8bf17c41f2e3fca0 +a20db17f384e9573ca0928af61affab6ff9dd244296b69b026d737f0c6cd28568846eca8dadf903ee0eecbb47368351d +937bfdf5feb0797863bc7c1be4dcc4f2423787952a3c77dfa3bfe7356f5dbcc4daebde976b84fc6bd97d5124fb8f85c9 +a7050cc780445c124e46bba1acc0347ddcfa09a85b35a52cc5808bf412c859c0c680c0a82218f15a6daeefe73f0d0309 +a9d9b93450e7630f1c018ea4e6a5ca4c19baa4b662eadfbe5c798fe798d8a3775ed1eb12bd96a458806b37ab82bdc10a +a52a4d5639e718380915daaefad7de60764d2d795443a3db7aeab5e16a1b8faa9441a4ccc6e809d8f78b0ac13eef3409 +8e6f72b6664a8433b032849b03af68f9376b3c16c0bc86842c43fc7bf31e40bc9fc105952d5c5780c4afa19d7b802caa +a107ae72f037000c6ee14093de8e9f2c92aa5f89a0a20007f4126419e5cb982469c32187e51a820f94805c9fccd51365 +9708218f9a984fe03abc4e699a4f3378a06530414a2e95e12ca657f031ef2e839c23fd83f96a4ba72f8203d54a1a1e82 +b9129770f4c5fcac999e98c171d67e148abd145e0bf2a36848eb18783bb98dff2c5cef8b7407f2af188de1fae9571b1c +88cc9db8ff27eb583871eeeb517db83039b85404d735517c0c850bdfa99ae1b57fd24cf661ab60b4726878c17e047f37 +a358c9aadc705a11722df49f90b17a2a6ba057b2e652246dc6131aaf23af66c1ca4ac0d5f11073a304f1a1b006bc0aa5 +ac79f25af6364a013ba9b82175ccee143309832df8f9c3f62c193660253679284624e38196733fb2af733488ab1a556e +82338e3ed162274d41a1783f44ae53329610134e6c62565353fbcc81131e88ce9f8a729d01e59e6d73695a378315111b +aa5ddcabf580fd43b6b0c3c8be45ffd26c9de8fa8d4546bb92d34f05469642b92a237d0806a1ad354f3046a4fcf14a92 +b308d2c292052a8e17862c52710140ffafa0b3dbedd6a1b6334934b059fe03e49883529d6baf8b361c6e67b3fbf70100 +96d870a15c833dddd8545b695139733d4a4c07d6206771a1524500c12607048731c49ec4ac26f5acc92dd9b974b2172c +8e99ee9ed51956d05faaf5038bffd48a2957917a76d9974a78df6c1ff3c5423c5d346778f55de07098b578ad623a390e +a19052d0b4b89b26172c292bbf6fd73e7486e7fd3a63c7a501bbd5cf7244e8e8ce3c1113624086b7cdf1a7693fdad8b5 +958957caf99dc4bb6d3c0bc4821be10e3a816bd0ba18094603b56d9d2d1383ccc3ee8bc36d2d0aea90c8a119d4457eb4 +8482589af6c3fc4aa0a07db201d8c0d750dd21ae5446ff7a2f44decf5bff50965fd6338745d179c67ea54095ecd3add4 +8a088cc12cf618761eaa93da12c9158b050c86f10cd9f865b451c69e076c7e5b5a023e2f91c2e1eed2b40746ca06a643 +85e81101590597d7671f606bd1d7d6220c80d3c62e9f20423e734482c94547714a6ac0307e86847cce91de46503c6a8a +b1bd39b481fc452d9abf0fcb73b48c501aaae1414c1c073499e079f719c4e034da1118da4ff5e0ce1c5a71d8af3f4279 +942ae5f64ac7a5353e1deb2213f68aa39daa16bff63eb5c69fc8d9260e59178c0452227b982005f720a3c858542246c8 +99fea18230e39df925f98e26ff03ab959cae7044d773de84647d105dfa75fd602b4f519c8e9d9f226ec0e0de0140e168 +97b9841af4efd2bfd56b9e7cd2275bc1b4ff5606728f1f2b6e24630dbe44bc96f4f2132f7103bca6c37057fc792aeaab +94cdad044a6ab29e646ed30022c6f9a30d259f38043afcea0feceef0edc5f45297770a30718cbfec5ae7d6137f55fe08 +a533a5efa74e67e429b736bb60f2ccab74d3919214351fe01f40a191e3ec321c61f54dd236f2d606c623ad556d9a8b63 +b7bd0bb72cd537660e081f420545f50a6751bb4dd25fde25e8218cab2885dd81ffe3b888d608a396dfcb78d75ba03f3f +b1479e7aa34594ec8a45a97611d377206597149ece991a8cef1399738e99c3fa124a40396a356ab2ea135550a9f6a89f +b75570fc94b491aef11f70ef82aeb00b351c17d216770f9f3bd87f3b5ac90893d70f319b8e0d2450dc8e21b57e26df94 +a5e3f3ab112530fe5c3b41167f7db5708e65479b765b941ce137d647adb4f03781f7821bb4de80c5dc282c6d2680a13d +b9b9c81b4cac7aca7e7c7baac2369d763dd9846c9821536d7467b1a7ec2e2a87b22637ab8bbeddb61879a64d111aa345 +b1e3ee2c4dd03a60b2991d116c372de18f18fe279f712829b61c904103a2bd66202083925bc816d07884982e52a03212 +a13f0593791dbbd360b4f34af42d5cc275816a8db4b82503fe7c2ff6acc22ae4bd9581a1c8c236f682d5c4c02cc274cc +86ba8238d3ed490abcc3f9ecc541305876315fb71bca8aaf87538012daab019992753bf1e10f8670e33bff0d36db0bf0 +b65fbb89fafb0e2a66fe547a60246d00b98fe2cb65db4922d9cef6668de7b2f4bb6c25970f1e112df06b4d1d953d3f34 +abb2d413e6f9e3c5f582e6020f879104473a829380b96a28123eb2bdd41a7a195f769b6ac70b35ba52a9fee9d6a289c3 +88ec764573e501c9d69098a11ea1ad20cdc171362f76eb215129cfcca43460140741ea06cee65a1f21b708afb6f9d5b0 +a7aaec27246a3337911b0201f4c5b746e45780598004dac15d9d15e5682b4c688158adffdef7179abb654f686e4c6adc +a1128589258f1fbfa33341604c3cb07f2a30c651086f90dce63ae48b4f01782e27c3829de5102f847cde140374567c58 +aaf2b149c1ca9352c94cc201125452b1ed7ca7c361ed022d626899426cb2d4cc915d76c58fa58b3ad4a6284a9ae1bc45 +aaf5c71b18b27cd8fe1a9028027f2293f0753d400481655c0d88b081f150d0292fb9bd3e6acabb343a6afb4afdb103b5 +947c0257d1fb29ecc26c4dc5eab977ebb47d698b48f9357ce8ff2d2ed461c5725228cc354a285d2331a60d20de09ff67 +b73e996fa30f581699052ed06054c474ebdf3ae662c4dc6f889e827b8b6263df67aeff7f2c7f2919df319a99bdfdceb1 +b696355d3f742dd1bf5f6fbb8eee234e74653131278861bf5a76db85768f0988a73084e1ae03c2100644a1fa86a49688 +b0abca296a8898ac5897f61c50402bd96b59a7932de61b6e3c073d880d39fc8e109998c9dba666b774415edddcff1997 +b7abe07643a82a7cb409ee4177616e4f91ec1cf733699bf24dec90da0617fe3b52622edec6e12f54897c4b288278e4f3 +8a3fae76993edbc81d7b47f049279f4dd5c408133436605d934dee0eadde187d03e6483409713db122a2a412cd631647 +82eb8e48becfdf06b2d1b93bf072c35df210cf64ed6086267033ad219bf130c55ee60718f28a0e1cad7bc0a39d940260 +a88f783e32944a82ea1ea4206e52c4bcf9962b4232e3c3b45bd72932ee1082527bf80864ce82497e5a8e40f2a60962d0 +830cf6b1e99430ae93a3f26fbfb92c741c895b017924dcd9e418c3dc4a5b21105850a8dd2536fa052667e508b90738f2 +990dce4c2c6f44bb6870328fba6aa2a26b0b8b2d57bfb24acf398b1edc0f3790665275f650884bd438d5403973469fa2 +a2e5b6232d81c94bcb7fed782e2d00ff70fc86a3abddbe4332cb0544b4e109ae9639a180ae4c1f416752ed668d918420 +b4cdf7c2b3753c8d96d92eb3d5fa984fef5d346a76dc5016552069e3f110356b82e9585b9c2f5313c76ffaecef3d6fd8 +83b23b87f91d8d602bff3a4aa1ead39fcc04b26cf113a9da6d2bd08ba7ea827f10b69a699c16911605b0126a9132140f +8aae7a2d9daa8a2b14f9168fe82933b35587a3e9ebf0f9c37bf1f8aa015f18fb116b7fba85a25c0b5e9f4b91ba1d350b +80d1163675145cc1fab9203d5581e4cd2bed26ad49f077a7927dec88814e0bed7912e6bbe6507613b8e393d5ee3be9be +93ddeb77b6a4c62f69b11cf36646ed089dcaa491590450456a525faf5659d810323b3effa0b908000887c20ac6b12c80 +9406360a2b105c44c45ba440055e40da5c41f64057e6b35a3786526869b853472e615e6beb957b62698a2e8a93608e13 +93bfc435ab9183d11e9ad17dac977a5b7e518db720e79a99072ce7e1b8fcb13a738806f414df5a3caa3e0b8a6ce38625 +8a12402c2509053500e8456d8b77470f1bbb9785dd7995ebbbe32fd7171406c7ce7bd89a96d0f41dbc6194e8f7442f42 +aab901e35bf17e6422722c52a9da8b7062d065169bf446ef0cbf8d68167a8b92dab57320c1470fee1f4fc6100269c6e2 +8cad277d9e2ba086378190d33f1116ba40071d2cb78d41012ec605c23f13009e187d094d785012b9c55038ec96324001 +85511c72e2894e75075436a163418279f660c417e1d7792edce5f95f2a52024d1b5677e2e150bf4339ad064f70420c60 +85549ca8dcbe49d16d4b3e2b8a30495f16c0de35711978ada1e2d88ad28e80872fca3fb02deb951b8bcb01b6555492e4 +8d379ab35194fe5edf98045a088db240a643509ddc2794c9900aa6b50535476daa92fd2b0a3d3d638c2069e535cd783b +b45cfebe529556b110392cb64059f4eb4d88aaf10f1000fdd986f7f140fdd878ce529c3c69dfd2c9d06f7b1e426e38f3 +ac009efd11f0c4cdd07dd4283a8181420a2ba6a4155b32c2fed6b9f913d98e057d0f5f85e6af82efc19eb4e2a97a82df +b2c2cdffa82f614e9cb5769b7c33c7d555e264e604e9b6138e19bcfc49284721180b0781ecbf321d7e60259174da9c3c +95789960f848797abbe1c66ef05d01d920228ca1f698130c7b1e6ca73bfda82cee672d30a9787688620554e8886554ee +98444018fa01b7273d3370eeb01adc8db902d5a69b9afc0aa9eadfeb43c4356863f19078d3c0d74e80f06ecf5a5223f4 +87d20b058050542f497c6645de59b8310f6eeec53acbc084e38b85414c3ea3016da3da690853498bde1c14de1db6f391 +a5c12b3a40e54bee82a315c503c1ce431309a862458030dde02376745ec1d6b9c1dbeea481ae6883425e9dae608e444e +b9daa3bf33f0a2979785067dcece83250e7bf6deb75bb1dbbab4af9e95ddfb3d38c288cbef3f80519a8916a77a43b56c +b682ec3118f71bde6c08f06ea53378ea404f8a1c4c273dd08989f2df39d6634f6463be1d172ac0e06f0fa19ac4a62366 +a4f94fd51ecf9d2065177593970854d3dce745eebb2a6d49c573cbf64a586ae949ddfa60466aaef0c0afb22bd92e0b57 +86cd5609efd570c51adbc606c1c63759c5f4f025fcbefab6bc3045b6ad2423628c68f5931ff56fdda985168ce993cc24 +981192e31e62e45572f933e86cdd5b1d28b1790b255c491c79bd9bb4964359b0e5f94f2ae0e00ef7fe7891b5c3904932 +9898f52b57472ebc7053f7bf7ab6695ce8df6213fc7f2d6f6ea68b5baad86ec1371a29304cae1baadf15083296958d27 +b676c4a8a791ae00a2405a0c88b9544878749a7235d3a5a9f53a3f822e0c5c1b147a7f3f0fc228049dc46e87aa6b6368 +9976e10beff544e5c1645c81a807739eff90449df58ffdd8d1aa45dd50b4c62f9370538b9855a00dd596480f38ebe7a5 +a0e91404894187ec23c16d39d647ada912a2c4febfd050a1ea433c4bfdc1568b4e97a78a89ba643aca3e2782033c3c58 +91a6ea9a80476ed137eb81558ff1d55b8581663cccd41db4fc286876226b6515fd38661557419e1e46b6a3bc9cda3741 +b9e8a1e23c60335a37a16f8085f80178a17d5e055d87ffe8cf63c532af923e5a5a2d76cf078164fb577996683796caa6 +ad8e151d87a37e8df438d0a6a7c02c3f511143efb93fde8aef334d218cb25932baf9e97c2f36c633620a024a5626af3d +978f942f210e8a482015e6fdc35a4c967c67b66e6e2a17a05cc7a0f2163aed227b775d4352b0c3cca6cbf4bd5bafaf75 +b5e2e3d8b2e871c07f5899e108e133f87479959b80cb8a103fbecde00ccdbfbd997540eef33079c5cc14b1c00c009fd1 +88a164b3fefd36857f429ab10002243b053f5d386466dbb9e5135ed3c72dd369a5a25e5e2aaa11f25488535e044e2f12 +a66091c0db4e7cf05a089ec2b9ff74744354d0196968201f5e201699144b52bb13b4e68e12502727163e6db96e3565f2 +8e65aff8e37240461b7374c20bfd1d58b73a525c28994a98f723daed9486130b3189f8efe5c5efcd7f5390cc366038da +8b37c21dd7304c3aa366959ba8c77ea8b22164a67e136808b6f8e48604297f7429a6c6ecf67b1d09b8b7ec083eacd7e0 +b689b1277ad050f53da91a702516a06d7406ff33a4714ea859b3b2b69f8d0aa8f983c7e039b19c0759a3815d841fa409 +b17f7a0a182ed4937f88489e4c4e6163dcf49fd2ea4d9efbba8126c743bea951cd769752acd02e921774dc8ebcfae33b +8b7fab4f90be825ac5d782a438e55c0a86be1c314a5dbc3cc6ed60760a8a94ef296391f1f6363652200cce4c188dae67 +ab8410c4eaa2bb43b0dd271aa2836061bc95cb600b0be331dada76ddb46711ff7a4ad8c466cc1078b9f9131f0dc9d879 +9194bd7b3cc218624459d51c4d6dbc13da5d3de313448f8175650fa4cfab7cc4afcda5427b6676c3c13897dc638b401e +980f61a0f01349acd8fc9fdc88fc2c5813610c07eecb6ab14af0845a980792a60dadf13bb4437b0169ae3eff8f5984ce +b783bee24acea9c99d16434195c6940cf01fc2db135e21f16acae45a509eca3af6b9232a8aa3a86f9715c5f6a85cb1c3 +a3079931c4b90966d1faa948db847741878b5828bc60325f5ebe554dcab4adcc19ee8bce645e48a8f4a9413bb3c6a093 +801f61ac9318f6e033a99071a46ae06ed249394638c19720831fff850226363a4ae8486dd00967746298ee9f1d65462f +b34dbbed4f3bb91f28285c40f64ce60c691737cc2b2d2be5c7d0210611cd58341bb5bda51bb642d3ee2d80882e642a13 +8750af19abfb915e63c81542b13d84526a0c809179bbcc1cd8a52b29f3aba3ae0f7cf6f4f01790bf64ef7db01d8ee887 +a6ea10000eb2dd4efc242ac95bc3b3873cdd882fbeb7c9538c87e3143a263ca3a2e192b2159316a625cfb5fb0b6cdcb3 +aa40ca54bc758a6c64cb932924917581062e088b3ad43976b28f2e11d8a7dea73f1fb50aeaa0e70182bb2dc07d805bb9 +a4779dfd25b5ec9d75dfb54a4bb030364899a5e75c1492403acb19f2adc782c7ac4daeb66d2f5aeb74135afe9f318e3f +b4551e2805d63ca453f4f38b1921ac87ff687e1d70575ad38f3469d6f0608ef76b7b1b98ae1e6b1e7d928773aaab6e3b +99490ee722f96aad2743b08dd37bfeb75a8c59efaee4c9b694eaa05eb8a6bb23861a4480544c7617d04d23fd5e2543b4 +8a7050d964d295fff98ae30d77ce730a055719313457e773fcce94c4d71a9b7cf63db67e54a8aab20fb1335b0130b5d5 +903144e6bbee0a4fec17ff80fef0d2103981140c3d41776cfb184ced17f480a687dd093f6b538584327e6142812e3cd5 +a5b30f7c6939bdc24a84ae784add927fec798b5a5ee3dd156c652df020728dd6d43898be364cf5ee181725fbcffc0964 +b43d97ec2bc66af92d921a5c5c20a03ef2be2bc2c9b345f46d8287409fcbfd88ebc49d4509d64468222cd1d2021bf236 +82dc23c7f5086c9ac6b4566359bfb830d203544b0d8332a210775670f899cd9ff48b94bfeba40040c25664ebdd5cfad8 +9294cd017fea581dabb73dcc8c619904d7e022b664b0a8502c9d30f3807668af279948e7e41030ae296d492225297e95 +8d6c9dc636c8e884f9a4299e5cff06d044ebc94ad783a4b71788347ea4a336d4d048b8a9ecabae789e8fcdc459723dfb +801a80bc49e882ec81b04e37407713f033f7bdac79252dfa3dc8c5bd0229fcbd4019890e402cf843b9378df08f72ab84 +b4313ca32569d973900f6196363c0b280ddfa1b47c88d019e5f399b805b444a777950fc21ae198fc23ece52674b94abf +96f06056fd255fdabf78986e315e7c4fdf5495cf850536b7976baa97a994cc6a99c34609c33a0f2facba5e6f1026dce6 +983ed80220a5545ffd70ef5e6ac10217d82ec9cd8f9a27ee77a5ff4074092308c0e6396fc4e9932a77ddd474e61f8b55 +872a059aa630af73c4abbd076e8b333a973ffc5bdecf5dcc0600b00162184213cb19d4f601795030033beb808d5810ce +b040f318d9d3b8833da854014a44296dbd6762dd17cab13f91987256c54353b7f0800547cb645a7cc231997454209fdd +a8c4731a555308e8ce0b8325eb7a4cbf6113d07e9f41932df04480b72628d313b941c7055f1cc2ac45c7353b56e96ca9 +8c24031440b77637e045a52e5ea3f488926ab0b426148975edf066c40a4581beecc1bfb18fc4cf5f9f96dc6681b4bd28 +b39254b475abf342f301298feaa17a4b3051f30ea23a18acf59e003e2704ac96fe40691f1da387913bdf7aee6389f9a8 +a1dbf938b604ccc6d60881cc71f38df568aa02752aa44d123514154017503f6c1c335ae43e359f1487bc8934073cd9c1 +8d52aa1be9f429ece0580498d8fe9fef46d4a11f49436a82b8927f9503dacc41245907f126594c1cd30701286f8c092c +b826f396486942c0326d16f30a01b00a682c30a75553dc6ac34fd5b3e96b13c33b94738f522eebaffb59ff8c571c76e9 +aa89f51cbf6e6c3e2aa2806187b69ab3361c84e89f393f3ed284fe84db46fc3944aa44f8928e3964f9c1a1ec27048f68 +a254df0efa4203fb92b42a1cd81ca955922e14bf408262c8f7cb7dc703da0ca2c71556bd2d05b22ce9a90ad77309833d +93263c507e4d5f4e5df88e85b3d85c46ea729fb542a718b196333e2d9fb8a2e62dc1347cf146466a54ba12d200ef09d9 +922e3c4a84246d89a07aa3e90f02e04b2cea9bebc0e68b742156f702aed31b28c6dfa7ac936ea2fc2e029adf68361f98 +9a00628eeeda4ccbed3ef7834149aec4c77aac1a14bc2491ba5d1a4a2c5d29afb82ceaa5aac1c5ce1e42cdcaf53e30ba +ab3a88df36d703920f6648a295a70ffa5316c96044f39ff132937bfda768937cb6a479e9ba4a4e66b377f3a9996a88c4 +966b11526ab099d550ab33c6a9667e5cfdedf255da17a80a519d09acd78d2ea24ec18bd1ea7d8d63cf0a408f1c1fe0b3 +b5c21b9817dc32f3df9d9988aa3560e1e840d586d01cd596bc0f850ab416b6013cbf7dbfd05ac981f26014c74bd2d2b2 +9040abef5e2523e7f139c9f744a64b98fea3a57952059ffe4d5ed77fa87068203c090ef4e7f52c88fb82ea8a6fdca33e +a0dcdaeb7d3f5d30d49c004c5f478818c470187f4b0b4856812dcd1b3a86de58a99acb8ceb44c6b80c3060cf967c43a4 +b5f4be9a69e4a6719ea91104820df8623b6d1073e8ee4168de10a7e49c8babea772bcbc6b0908185e98d607e49cd3609 +8634020a5a78650015763c06121c606d2dd7b324aa17387910513dd6480fb797df541fc15b70d269b2794ad190595084 +9504d1d0fb31ff1926c89040c04d51fd1f5cddf9d7ca3d036e7fd17e7a0f767ef33cee1d8bf7e17e2bc40949e7630417 +812c72846ef6d692cf11d8f8c3de8fa78cc287303315114492667b19c702cd24d462020f1276895df26e937c38f361f8 +8c97aa5e9ef2aa9a1435ef9ddfe62e850f0360864ed5fb82bf9fef4ef04d8fb4f827dc078bc911ee275e4501edd6617c +ac5f7af5e23c8e429aaa6b6825129922b59d25b4608f07b65f21388a9ac3aa89096712f320afe6d56e44e1f0d51a4eb9 +a8c84d9a8593a0cb5be1e450960f59878a4e6b70da54a7613dfc25911b7cc9e6d789d39401b0a0d6471ab9dcdc707976 +8c9d5fd89611392c0f085ffa4fa642a181f0b9b23593deb5e10fdd1642722ca75ef34a037e88a8d03f2888fe7461f27c +8c74b05f91fb95c85e7bd41f6d9a1e41e667e68f3d19b325c1f25df1767019919edab89b92af237896cbc4e6d6dc1854 +a3caecb91640821f0b2c4981b23f2069df8d2b98ce026c1538bc096b292f5f956a5d52c1c8d6a8165a1608083ba6494b +8ae8e0c36f8b79a69176ff29855df45d0fcd9e4d1dbaed8899f8fcdece676e418ec034a6c161e2a894f0c834aaecbfd1 +b88d18c67dc3b1b6ed60ee437c441c1ed14ecddebccf43683605716f30058b1aa4ba05ff10cd8171ee97d8f58d70c094 +94f43d84dcdfd9cd19115c7d8e9c1e856828eafbfdec93b876cf0007e317e30b2ad951dbabc186aa6ef90fdee4d91990 +b44e4723f41fc1d5b0057f371e3381ae02566590b3f964b6eb07b2104f66ff78410c407235fa98d04f635694f3baca09 +addd8390173d29ca0811534d389253831fed75fed135398617836b6e70767269eacb1560b39a58f02042ca3b97fe59c4 +80bdbdacc0c358c7ea52aeacdc5f9ceb6928bcf6e7dee7c17d8ae3bf7c2372aa7a0372363888968fc0921aaf4776d5d0 +a486e2b6f04f403f9e609d69dfb3cfb992af56ecad1683271df3e3faa3b86638b81e73b39978fb829ee7133d72901f2d +a19472da57457e10c6a6307895393ddaec8f523760d66937fe26a025817319e234eaf69756ffdf1b84c81733424a96d7 +ad6a195397cbc2d75171f5e82090441eed60bd1ba42c39ef565b8b5a8281b04400678625b1dc46d617f694a7652a8e5d +8f98e721c06cec432e2221f2e1b06bb1469d916a8d88d6973acf68d1e003441d00390dafcead8ecdbf9eae4509baf5aa +91d62a0f9d13c59adfe1376ed6d057eae244d13c6b3d99be49a49e0075cf20f4085cf127774644ac93615be9ac9e5db6 +af45dec199245e2b326a0d79c4899ed44b1c0219db42602a4a6184ace0ff831a3276297af28f92e8b008ba412318e33e +8754bde54e8d2d169e6a7d6f0eae6097bc0461c395192bd00dd6f105677ea56ab384c02553ea5eeac0a65adcb0df77ee +b676afd2f5afc37a314c943d496e31b4885efcbcc2061036e370a74cfde5642bb035622d78d693bfc3136fc036c7edb4 +aab6ffe6cc234397cf1822e02912bc282dfb314e92fb5a9e10d0c34ee9b5856d4b76e166bc2bb6fcdd66aabea35ec4ef +ada6e62f90ee6b852ec4b72b22367acac2896f0df2c105beda27096583ddbedddc710d171330569f111c6e44a5b57ae7 +802139dd15241a6de663d9b810121bdd9cf11f7f8c8ca6de63f4f8e731409e40d1fd3558b4f619ed42ee54929dff1c7e +ad8e70531cec21b4e6f55be1751c2d025bd2d7d8158269b054cfe57fa29252d052ce4478ec7db6ec705789e2118d63b3 +a8e4a4271769480e1b33a28c87a150ecc0b48bfe8a15ae04152197881de4ce4b03453aefe574842424edbbe4173e1a3a +b98c65726296610cef16c5b58da5491acd33bd5c5c5af4d934a9840649ef85730fbce8018dee09ded14e278009ed094a +8e213a7861223287b860f040e5caaa563daa0b681e4e09ec79ad00cc459238e70bbeaf7486bbe182fc12650700034ec5 +a2879f9e1a556cf89b9b5b3bd8646a8cce6b60bcbc8095df44637f66a2da5858eee2dc9091475a8f64bb5aff849389cd +8a17cdb4077b9b0bcf28b93294ac5ae4c8bba8839fce0f1012b53187ac008f9858b02925fbfc421f1123afcdbd8b7753 +86fd9c11528aa43946e4415ff64a3ca6409ee6f807368c68997b18605da65e415ccd85ad913820d450cb386593de666d +8ed55923b963c3d85a91aca11c40ff9c6c7f1e2b9bc199d1a270e5fb16aa62dec0136e97866145ae9d58a493e8b1cbbb +ae32af5b5d418668ae123c639b149e5eed602404e8516da4a61db944b537a3620545e8e3d38cf10cdaea980ab2f80973 +95cb8d9e9d6762d78dde0ad73869ffaca904a7d763a378b8cc11a7933d3e7d1c8aec4271a079b1b00f8887ee5b1ea21f +b5ea20b42a3ca247f00ab5328c05f0cf194973d5f7271c66c41c5055b1ffdca136be179709e0c1de209fbe07b9820bf3 +98682f7cce471c92a8d6d15fee4ddf4d43dd97c3e3811d2913618ecacc6440b737717c07736ae4558c910e11ee98104e +a67da2c7cbba48e929ca4e4b9a6299fe01ef79eff8cc5cd3fdbdc0721a68130e4079f30ae151a573a7dcca8ecf2e684e +a9981c9f9dcbb3b0f6996f664fb2acd7573189f203be37b2b714662aa273551396abfb1f612ccde4e4c8127a050dbe4b +92d55eff8da600f886da9bf68e8eecf482faa4b268f3f286b3b3e5cc91b19604081498d4905b201bb4ec68e32b5591d9 +963e3f1728de9d719c86d390f3eb9c3f99d1928347fab0abf10dbb37d76b59ddb64d4734c977863a6cd03ffece5ca895 +93480e2de83c921056b6d8628ac37cd5ef7555ba43b0308fc13386cb0515d42c12ecd06057137aa71a7931beaf90b9ce +8feae57ff0e6a162cc81c99f45c6187d268fc0bee8c2bffc92142ef76c253d201f0e932943cf2fa312982b281ce1066b +8f8f4bd4200fb87afcd743274480220d77571928000d4197410dbb75439d368df6a06d941a6152206371d2ca9cac99e4 +8ee7f11e79af4478e0a70eb424fe8078237ad99ba6d7e6bf1a8d5e44e40abd22d404bd39b718ad6fdf4c6601f2a47665 +a98acfcec612b574943195b9ba95bebcc9c0b945c9f6b3e8760b2a4635909246a9d73b0b095c27b4ecb3339704e389b7 +b520efd19f65e81dc285031ea3593f8c5dad793e4426beb9196ab46e45346f265fd71e50adb0da657977c60ed5724128 +a3d9d0b7415280ce4dfa2429d47b2b8e37604a5157280a72cc81d541ffe44612dbb3ef7d03693fc42a569169d5842dc3 +8c29e2d0b33801f6d9a9c065a76c5cad1fb0a001506b970307e21765ee97c732a4cbf1d7c1b72d95e0ad340b3b075224 +839e21f292892a6eb596b9b1e9c4bd7c22a6fe71d3d04487c77840028d48392c5cbe73140a4e742338e0c8475cd0c1ad +8bea5c68e7743998619185bb662e958f1b4d3ca81019d84ac43c88911aab3abe4ee9bcc73cb95aa3ae87c0138801bde3 +b8f262d21a94604049e008ce03dc857848168e1efca4522acb0ccc827ffb37f545e1947843a356563a76bc6489605b66 +a7bd0842b0bb38d9943b82aa883f36f4eb8a6e8a7790d4f87faf306608f51d250a19b73984f1156cef5dd2581664614b +a993e649bd953627a88a2539dac3a12ec7f37a4c65b01425d9d34edf7ee10a71aa98f65c9e013107f824faf8aee041a9 +8e07eced75c67cb4d2ec01857f6ac1408482e6b31cb2faa249e8cf99f180575587df530c7782a7539b5221121ef48aa0 +b2f4578f26c05ecb9e2669ca744eb19d4f737321ac7d04fafd18beb7866e0fec9dd063953ae1f077b44b9c6f54db1279 +b6b3788a6c7bcaf467d19daf6ab884d549aa866970c05a9181f544ff190d043192c84fe437a75a30b78b425461cca062 +a270684903c61544b85a7041e81f65e787e1c1e23e57538fa8a69836bed0ca1673861dd29f743a1280f2f38eddd3aa83 +a9c2397c4773dcad2821266dadfd2401d013d9f35de6744f2ec201f3507700adb1e6ec4f5a453be4764da8bf68543f26 +83a3025ed6fd5df9d98be32a74e10a0d9728b560942d33ba028536fb148fc34ae87e92be2df3e420a8dfec08da495982 +90dc70c183a90bab988b4a85b7b921c8070af0e5f220364fe11afa0722990b2c971e1e98eef62d3287fedfd9411f1df7 +82d940937a6c636224d04f8e2536f93dcf20dc97a5f188875ad76c21b804aef9af10839419b61143c1f88a695959a6b4 +8017f9473ce49d498d6f168137e77e62fe553e5a51e75b519cf2cbd1ab9afdafad80fd5e6fd0860e640b0d78ca8ed947 +80573a0ec049fe1f7b3013b2839e145cd87e07c0e43826a29ef8c92516f9a30896c2ffcf3ed77ed22a6cf3101b1789d5 +953349abd2559f9824db07cec857ad54f1a05018f3076425f8dbae37f8d92a46af2c04ab7c8ec0250449541187696e98 +ab7bd2c4f05ee9a9f252c4e16a20993a12c535c3809d124bae24642616521a9768d3f19eceaf8524583f47ae1f527684 +9883b77ee834ee0112ca2f366d2a6fc213e0cf454e061438c2901a5ba35b7378f64da8adf6a476eb1562991ef5b4a5bc +89291811db308637356dbf7ed22cf07bfce33eb977734ee346e8c15a231b35d8b4443574f3fa97a40867b3e23b0bbfa4 +93d753849d7d9588d39e38217500b123a6b628a873876612d9f98b5d611f52c89c573432d2176752b5d1cc2d94899b8b +a45add3c4844db3b7a237295fc85fddc788ac1ec395a0524d2fc90a539571a247146aea4aa10eec30a95e9617c85b98d +90f94578842db7a4de672da1e483858ece5e466c73c12f725a0fc71f42ff880c9447a33fa9096839bee817536f2591e2 +b2c1b6fb031bb30460f157356562b44b4de096a0a112eab4fb3cc500aad38bc770da1fc2e73caf687a0da5e8537049c0 +afb15e15fd930929c0e3c66482068a5afe0c7b7f82e216a76c5eb1113625bfa0b045a52259d472284cfbaf4796c71456 +ad222a9a3d907713418c151b8793d5e37634354322068f8206b9d0da1a3f53b0004193713d23ec35990639a1b6c2e075 +b44a128dce97e8c4b178cdbca0a5c1b3f6e164490fac0fd68dbfe0aafa89920bb4ea420a8527e06c80dd19c2f135e3ef +8596e993ef18b8d94e9c42a90cb7060affc586b8e9b526820d25124285de5590134e2e86592e9dc4dd45ccf5d578fa60 +b71bb0ad138141ed506b2253e84110d2db97cc2d24a3fd0d096b0022d9f38f87aa74e2f505074632d64e90bcc491aa30 +84841eafd357309de47b92ca5ec163dec094a2e5271bc65898c31932e0160bee165e4decb23af339cfe09c83e1cc5441 +8a2915ee39a6fd4a240b98533d7690ef1773ce578ed1fb05ed414ebe36f7ef289fa46f41768df57190438c356331e329 +90bb337165386f1990cbd8ed2e8321ef21bc18125b015b4da0c37e5fcc446b26005379ee4fad8ce9348ceb4ab49e82e2 +b707b50ea2ab05c6d183671587f25fe29eef23fe569d731459a1ac111a0b83a2cd65b88242876b34aeead3b05a15d745 +ae1f159f79b7996315c4f9acce7e21a6ed59d4ef76331196fc86911fda3035edd5c11d568b105175a36c948d0263b382 +922bc525bace05e5dff6b5cabde5469ddd2c1c601f7131abc04ecefdd35095e6ac015b1aec3c3b25c5dee8d139baf60d +a7b060405b2740f82db64683187b1bb89e5f40c8438663c7cbc8ef2513929fe5f92625667a7f2f599a72a96b1fc8f08a +b9dfe94a08651db5efefbb813269bce80d814e3089b80c0654491e438d820bf521f8a4a4477909344ba88f7683eebb43 +841817a9729465743576950b6e8eea32ebf39cca99ace86c4792f9f35926e2d6830c52854a3b2eaeb61694e6845008bd +934128034bde8fc7b93b952aa56e0ed28b36cfa04cfa1f0d5b38266dd40beedff5e0bab86e4717b0fb56c56be2eae26b +aee9d64caf28596308782cd8f3cf819506daf3378f86157ff775e618596411adf94efd0e9542787ca942066f02cbd332 +85871184db314411a49575fee088c52ed5dba4e916ee001ec24d90898a0154d9790a06aa8a707ca7a8b986c0293b8d89 +8d3d87edcc0187a099c97b581a598d357a41ac152303bb27c849eb78e72e15cb97cf9a0468fc36f245c3e152c76bb7dd +900475d165dec18b99eb7b5f9e9ad1d2d4f632e55fdcc4c5ecd7775fed462990e6aaafe9c669f40508f9b15f00bda31f +a25b5954edd57e7811a0d18532043d975c7b44b80f65cd630935d7b16ada05f30fe2b7be7ae8a2f54c25957faf3f1950 +a089019afa3a7a15f7e7874e73b6773c0a824e6d3379b4c928e173321fb165ad979a6be004d394c28d19d410b2655d3e +b28f46797dee0c538bd3de815df641a0ef718ad3e52b2764aec380d6905b38b50ad6f60d0f68e096ca39960ba7734355 +b0ac155d3d05851b04104e6b459f1a68e9e155437c92421a7c0e4dd511ef89cf71dfa3cc920769492ee283a65ebf029e +813c69a810745580d43d5b5480f0ba81000fbef0071e6b655c7346bef5ed774e9214a7816d40eb1774a5bd033767a046 +b176345ca75c64f10ec33daa0dcf1f282b66a862fcd3d8d66c913f9a02db4c9d283dadc02eff13aaab94bc932a42234e +92560f67e5b995db4a489bb86ee78b4aee0800143b3535ad557a53e9e08716bd0202d9f5714722c2a5e8310046e3f5b3 +8adb427bad9cc15fc6c457a96a6750dda8c46d859c5f69bf0e7ab8fc0964430b33967fd47cf0675b6ba1757f91255e6e +b120f723b80389a025b2daa891b140b3d7b8d520ae2a6a313f6e3d365a217af73292dcb249dca1f414ec05e865e3cdc7 +a61a5d261a8dfe5996c42ea0a5ae703a2adcfda80e86837074d868eee16f87d38da19596c48b55dbd7a7cbec1a9b4996 +99dc921eacc6bb867c5825ad4c83bc4af9dd78a18b3d0e1a60ad493e3805b8fb9b7922b577da1adb3d805edfc128d51d +85455fa165a07282aaab4a5bfb88027f47b9532e4af8195c048515f88b0db7e80f42e7a385fd4944faaa7f2a6544ad17 +96dff2d1c8a879d443fe576d46bcceaf5f4551d2e8aad9c1a30883637c91090de99ad5eec228eb5febf93911502d3cbb +a87eb7f439377fb26c6bfe779701f4aea78dd7980b452a386afec62905e75217a1996c5234853432a62ef8bab21c31c3 +b598278293823e9ccb638232a799211173b906444376337fdf044d0227d28fcc4c5867e6ecb3200e59ca0b139e71cac9 +aa6fe147edc95027654d68140f428ec53cede3552c5f49c09d18bc6f6ae8c739a63042eb7291d14d717a4e1f0778abcb +ae8ee18913d328b2fba71efe65526d3ee9c81beda53cf776baec4019ea30212010758cbb5dc85ed6620ce04b189f01f2 +ae9fb686777e88dffdd42805fe4114aa0da1b350d92a27ff3f8a817fb25af1fcfc9a06155affe0273bf13caad16a5351 +95d372ba3a2ee38371538f34aae91b4844488e273f70c02f1992370f89fc2343eff95692d52ce9f21206abbee4959958 +b15260376f0a34ca2827ff53acd7eaaef94c9acc2f244b36500423069cb1cdaa57ac8dd74adb5b53d0fd4265fcbb28ea +b0ffce6a8059537ef6affdbbc300547ef86e00109289239b0c6930456c562b4ed97f2e523963af17736dd71b46c44ac7 +b5499a1277d34f9892f7579731ff53f423f2ffffa9ea43a6e929df8c525e301396249a2324818a6a03daa0e71fcd47b3 +98dbfb8e97a377a25605a7665d4d53e66146204d8953afda661ae506858c5cd77ff7f21f5f10232e06dbc37378638948 +84177e27e6da0e900c51f17077f5991e0e61bff00ca62c1623e627c5aea1b743f86eef6d55b13219a1947515150bade6 +b50407bb5c61b057ab8935df94fd43ca04870015705b4f30ceac85c1035db0eb8293babc3d40e513b6fb6792ecbc27a9 +988699a16917514e37f41ab5c24f4835ed8a2ca85d99972646fcc47c7e2a83c2816011144a8968a119657c4cda78d517 +920c43fdcb738239ad542cb6504ab34498bce892311c781971d7db4dec70e288676de4d8697024b108cfa8757fa74035 +aaa106329aac882e8d46b523f126a86d3cee2d888035ce65c0be4eaae3e92fd862f6ac2da458a835539cccafaba9e626 +96e4c1562d14b7556f3d3e8a1b34ea4addc5a8170e1df541dc344728bcb74cd1630eb7ba4c70e9c68fd23c5c5d5a729b +a616ac5016d4e68e03074273cd3df9693ee0ce3458e8758b117a5c1bc6306dd2c7fad96b1bb37219c57ac62c78ad7a3e +8db7d9b20abfb1445babd484ae9e38ff9153ac8492230d7591e14e3fca7388a5ca6ef7d92ed445c8943cf5263e4a6ad7 +88464134221aa7134878eb10928f31c8bd752ab68c27c9061c1de3f145c85731a4b76acdc7e939b399b6e497f9e6c136 +a5f7c794f70b7c191c835dded21d442b6514bab5e4d19b56f630b6a2f1a84a1d69102d7a0dcca256aab5882d3f30f3ca +b96b6f98b6817b5fa6b1b1044e2411bdf08bf3ffaa9f38915d59e1d2b9bed8b3d645eee322ee611102ce308be19dbc15 +92c26ade2e57257f498ac4ff0672d60b7ea26dad3eb39ed9a265162ccd205c36b882dba3689758c675f29e20836b62d9 +8379a0299e75774930577071d258e89e471951642b98e5e664c148af584d80df4caa4bd370174dae258848c306f44be5 +a0e53beda02bd82bf3d24bd1b65b656238128e734b6c7a65e3e45d3658d934f909c86ca4c3f2d19e0ac3c7aae58b342e +8ca5ceaeaf139188afd48f9bf034d8baf77bbf9669791c7e56ebf783394d7fcdf2a25fa4bdfcddfde649aa0dc67ccccd +a8060e6448844e9db4e9fb4da1c04bcf88fda4542def5d223f62c161490cf1408a85b7c484341929c0f9ce2a1d63e84b +af6e1a5ecf50b754bb9eb2723096c9e9a8e82c29e9dcaa8856ab70074430534c5395534e1c0ed9ce98f4b84d4082fa67 +81c8dbbef98f1b561e531683d5ae0f9b27b7f45dc6b2f6d61119ca0d559bf4ceb676d320afc5aba1811eeef7547a59d8 +85b46cd64d605c7090a2faf1a2aadf22403b3692b3de1d83e38b2de0108d90ac56be35b0dca92c7a41c4b179a3567268 +8dd3cc3062ddbe17fd962c2452c2968c73739608f007ad81fa1788931c0e0dda65032f344a12249d743852eb1a6d52a9 +8630f1707aea9c90937b915f1f3d9d7ba6bda6d7fdef7a40877a40c1ee52471fd888f84c2b2c30b125451b2834f90d3b +b4a747e0bd4e1e0357861184dacec6714b2b7e4ee52fa227724369334cf54861d2f61724a4666dae249aa967d8e3972f +a72de682e6f9490b808d58f34a0d67f25db393c6941f9342a375de9ca560e4c5825c83797d7df6ed812b71a25e582fff +8d5ea7d5c01f1f41fffe282a334262cc4c31b5dcf31f42cc31d6c8e37c9bd2f1620a45519dab71e108fe21211c275b6c +8ccdc7e3642c2894acbf9367f3e99c85963cea46dc5473d175339a2391be57dd8815feacadec766e13645971213b9eb8 +858e9b5fc8c13b651ff8eb92324bdda281db4cf39f7e7bd0472908b3e50b761fa06687f3d46f4047643029dc3e0ceeaa +ae20d36c70cd754128c07cbc18dcb8d58b17d7e83416e84964b71ccff9701f63d93b2b44ec3fddc13bbe42ebdd66221e +860dbf7013da7709e24b491de198cb2fa2ffd49a392a7714ad2ab69a656ca23f6eafa90d6fdc2aa04a70f2c056af2703 +8f809e5119429840cb464ed0a1428762ba5e177a16c92581679d7a63f59e510fdc651c6cc84d11e3f663834fcafeafdd +8d8a8dce82c3c8ea7d1cb771865c618d1e3da2348e5d216c4cbbd0ac541107e19b8f8c826220ca631d6f0a329215a8d6 +86e3115c895ae965b819e9161511540445e887815502562930cedc040b162ecb1e8bdc1b6705f74d52bf3e927bc6b057 +b9833b81a14115865ca48c9c6a3855f985228e04cbc285f59bf163dca5e966d69579ea4dba530b1e53f20bd4dccdc919 +a71f5801838a6dbb162aa6f0be7beea56fadac1a4bcd8113a0a74ab14fc470a03775908c76822d64eb52a79b35530c05 +a77ab73ae94b6d3378884f57eee400eff4a2969aa26e76281f577a61257347de704794761ea1465dd22a6cc6304fbc4a +acd1c5df3c487c04cf27f002e81f2348a0119349b3691012526a7b0d3bf911cdd3accbc9883112ed2ba852145e57fe68 +8a28515a48832ac9eaf8a3fb3ad0829c46c944b4cb28acbcdbca1d0d4c3c623a36cda53a29291b8f2e0ea8ee056b1dee +846bafca11a7f45b674237359b2966b7bf5161916a18cf69f3ec42c855792d967d3bf3f3799b72d008766206bb7a1aa3 +b24b341675b1db9a72c3405bbe4a95ccdfd18fa96f876ec946ccb5108f73e8816019998218a036b005ef9a458e75aeb3 +b99c267b4a09193f3448bc8c323e91ef5b97e23aeff227033fe5f00e19bab5583f6e5fcb472ec84f12b13a54d5c0e286 +a088aa478dbe45973b04ecafbcbd7ee85c9a77f594046545cdb83697a0c2b01b22b1af0b97dd75d387bb889e17f17aa7 +a0c6b0cdff2d69964134a014e36c3709d9e63f6463c5cd7b01b6f0be673731b202d577539d89dd57a888326da1df95af +b4e6dc4ef11b2b41794ece70a8968e56705199d183366759568b6fa845d2cae127486e926b5b27ae9118bb21d1682c1d +a007804353f174098f02540a57e96227232444d5ae0a24232c244647148b6c049848cbd2b50d0a25af3ca9164bfff8ee +873fb034cc39c9cee553ece908fbf315f62efbc412b9afdde6a1889326b7f6f813e050b0601ba9921688e958cb75942e +b5676c90f0106c40d8683299e59d564f505ec990230cb076caef3ae33f2021e6aa5c9b27bb8fead05fc076df034c28f5 +b5a67fc4c5539ad1ddf946a063110f824f7f08d2e4d30762c9d437748c96c9147a88efc22260573803ab545c18b108f2 +817ff2b748a949973a91b69b0ec38efbd945aeb26a176d19f0fb76e261c7526c759e6f5516f9ed34de6eb1ac7838c9cb +99b76bda3526a5d841e059010fdb14eb2fa035a7d10463373a062a98c3c1a123e2da0848421dd7546d776438fd05e304 +aa0d363270f90d56bbee7ea577b0c358532bda36d9247af6c57d000044a97ba41e35bb0db438f4c94551c6350e4e0674 +acdae205d05f54b9544be96c9032350511895ccf413dbbc56d1f03053185df22a6d5b7ffcc3fbe96c3e2ce898ccfa73e +b091c220a1de18d384f50dd071dca4648ca4e708162c52a60e2cedc0188e77c54639f75bce9a468a64b2549119c07ded +878676133e5c700b1d4844564fa92a9930badb5293d882aa25ee6721a9f2cfab02088c31d62cf1342ae3edaea99a1ea0 +9756d0793e6aba3b4dff48100bb49a5ec08ec733f966cb438379b91caf52fc2a5930830ec3f49aa15a02c82c1914dc7a +9722f760184d3b2d67cb2cea7fa41b1ff920a63446006bd98c6347c03d224d2d8328fa20ccd057690093d284b9a80360 +b5a68489de4f253715a67f0879437bfe8f4dfc4e655ca344848980e6153b1d728acde028bb66fd626fa72eedd46ff683 +a8cfc900b34835d9fd3add08044636f69614eff9ae929eac616c39bd760fd275ee89bf24b0f275dd77a66e54fd6b94e5 +89967479bebf70b2893cad993bf7236a9efe4042d4408022fdbb47788fabedcec27d3bba99db778fcde41e43887e45af +889235938fcec60275c2cf0f19d73a44d03877d817b60bb26f4cbce09db0afae86d42d6847b21f07b650af9b9381fa82 +b7fc321fa94557d8fbdd9fff55ab5c8788764614c1300d5ef1024290b2dbb9216bce15cb125da541f47b411a2e7e3c2d +b11b0c4dc9477176b3cda6b17858dbd8c35a933ed31364801093f310af082cb5a61700f36851e94835c5d4625bf89e32 +9874e54d2939ee0600f4194f183877c30da26d7515e9e268fea8d24a675dd2945d1565d9016b62b1baab875ac892f4d2 +90df3a77280d6f1fa25a986309bba9d5b89c3cf13656c933069bc78e6c314058716b62eacfa7ab4aff43518b8b815698 +962b08299a287d77f28d3609f39fd31bc0069f7d478de17539e61fcc517045050644b0307c917208b300ce5d32affcca +b30eedca41afb6f083442aaa00f2e4d5dc0fda58e66aaf0f44e93d4af5c4bf8ea22afec888cacbf3fae26d88e8d344cc +847747a22fab3fe3c8cd67f3f1d54440f0b34ce7b513225dc8eb4fa789d7d9f3577631c0890a3d251e782a78418fecfa +8d1ef3cb5836e4039b34ee4e1b4820128eb1e8540e350309e4b8fea80f3ae803d1f25f4b9c115482b324adf7c8178bc7 +8f8a2b0b0f24f09920b58c76f7d99ec2eb2e780b5a66f2f30a9ed267dcaea0ec63b472282076c7bf8548211376c72f6e +831ee6dc8889bbf4d345eaeb2f425959c112d2190764abbbe33bc44e1d9698af87ff5a54d01fac00cfee5878dee7c0f6 +a7eb2479ac80d0ee23f2648fd46c5e819ad3a1f4752b613607ae712961b300e37f98704880ac0a75f700f87d67853c7a +aa4d1b9cec62db549833000d51e83b930db21af1d37c250fdc15d97bc98de7a5af60dbf7268c8ec9c194d5d5ccda3c1d +87396fd7e78c4bcf270369c23bc533b7fb363ca50d67262937dab40c7f15bd8448a8ba42e93cf35fb8b22af76740d5e1 +a958b2a9ffccbca13c0c408f41afcfc14d3c7a4d30ea496ce786927399baaf3514ff70970ef4b2a72740105b8a304509 +a5963a9dd3fe5507e3453b3b8ed4b593a4d2ced75293aee21bfed7280283348d9e08bf8244c1fce459aa2470211d41ea +8b06ddc3359827558b2bb57caf78b3e5a319504f8047735fcc8ec0becf099c0104a60d4d86773e7b841eb5b6b3c0cc03 +9437e7278283f6d4d1a53d976c3c2c85c5fe9b5aec7e29d54a5423e425b4be15400ed314f72e22e7c44ee4bacf0e681c +b56067ee26a485ed532c16ec622bb09135a36c29b0451949aa36fee0b0954d4bf012e30d7e3fc56e9f153616b19349bc +a5c72f7f5d9f5b35e789830a064a59c10175093a0ce17654da7048827d0b9709b443a947346b0e5d96b5ea89b8d7c575 +a8318d01182d4c9af2847a29a6b947feef5795fc12e487a30001cc1ec482b48450c77af4837edfa1aedf69f0642c7e5e +82ea421c091552d3dafa7da161420cb5601b819e861dd2ba1a788c3d1b5e8fa75cc3f2b0db125dde8742eb45b335efa2 +8679fd1c7771ea3b12006d4a972f4f2892e61f108107d4586f58ee7f2533d95d89b9695d369cdace665f19c6bc3bc85e +b5ab3e8adee4c950fce4d33a0e2f85d3d886e60a6e2f4454b57bc68725f0cf246372d863167482cce1ea10a7c67c3af2 +a85696927075ec188979180326c689016a0dc7a2f14ae02ea27c39ef91418cd44177d3fca5752cf6b298fd75fa012e26 +a44f87b7232f102cd092f86c952a88afb635484a984da90a41a57a3d883c9469064bf105b9026024090486b6c6baa939 +866ac91a437db945bbfdc11fcee583f3669fa0a78a7cecf50fbfa6ed1026d63ad6125deba8291452bf0c04f2a50e5981 +b780d5a1e278fd4eef6139982e093ceafea16cb71d930768dea07c9689369ff589d0c7f47d5821d75fe93b28c5f41575 +b025d0046e643506e66642c2c6a5397a8117bbfe086cee4175ff8b7120e4f1e6794e1e3f6ec11390993cca26d207ae43 +a04a22b6e28c959ab265c7f48cde42bb6a00832c6beb2595b5df2879080a9424890960417d7d7ceb013d697d0ebf7267 +81de9c656ac27f54d60d0252e33aff4e9e9e9c3363a50740baf15a2b9061f730a51ae1704e8c4a626153cf66d47f19b1 +a15fab90599df889df11fa60c752948b68fba54005491180dafb66c5775547976d0eef33945e55d4818653e0818c6f92 +b06f9be44ddb103a72fa4ebc242c8ee1975fe9bf9ef7124afeda9967ff3db644dbf31440151b824869406851a90984a2 +99abdfe6806ae5efa2d11577da17bd874d847c5f810460148bc045bcf38c4fd564917eacb6ed61bb9164ed58055cd684 +ac53231077f83f0ae5f25e52b70bb6105d561c0ba178040c11c3df8450c508ed5df34f067fdaacf716f90b4926f36df5 +99e3f509af44fc8d4ebc693d3682db45fd282971659f142c1b9c61592573a008fc00502c6af296c59c2e3e43ed31ec7a +98f2f5819670aff9a344e1c401f9faf5db83f5c0953d3244cfa760762560e1c3a3c7692bb7107ea6eaf5247ac6fd7cc8 +b5b9f90391cec935db8d2b142571650fcbb6f6eb65b89c9329e84b10bfa1c656026674d70280ade4ba87eeaf9333714d +b0696b77ca8a0cdbe86cad12f358880926906fb50e14f55b1afc1e08478ae6376215cbb79bc9035de2808c7cd2b13b85 +a51d746833062a65fd458a48a390631d5d59e98e2230b80d8f852cfc57d77f05eefcfd3c395ade1e86d4a39c2141365c +812d67654319f4ef3c9e4a2d4f027a4cb7768f1ea3f5fdde8d1b79187a4b874ff9a5c70f15b7efa079c2dc69d1b9b1fe +968978b653c6416bf810f6c2ffa3d1abbefbd06f66b6686e9a4fdce3f869e0ab1e43cce14dc83786596761c100ae17e1 +98e1e6ab562ca7743783b802faeb0a24f1341abfb9655f106920aef08964a3c0e8083e1acda7ae28fed7cdd5478decb6 +a91c0b982a0a7085a103600edf99e9d0bee4c4e7db6d9f8f376c215c7d42476218462a3765f2928e12c3dd49d688e4fd +8a43395b3124fab9e2438635bf88952e8e3084dad7ecb3a9927f9af0e0887bce4707084043671fc98ad03621e40a149e +b0b37626143d4a8c6f5693d5f1fe871525b4dd946c4239cde032b91f60a4d7a930d7ba28959737550d71c4a870a3a3be +b01c74acae1715c19df08d5f4a10e0c19d1356264eb17938d97127bf57e09ced05ba30d0fc1a9f32d6cff8b0d5f91c9a +b4c2328eb8a5a673406faed8f0aebb8540d2791646e37ce46e0e382506570ca276eb6f8e166dbbf9e0a84064873473b9 +85cb9f769a185e3538e4a4beda9a008694e1bf8dfeea9dc07c5c40a9ceb1d31fcb13cacfaa52849ba1894b5027cb8c30 +8742f91cddc9a115ddc73982f980f750d82d3760f2d46ee4490d5b17c6c3bb57c7d4c7b8d6311b7b41e59464c009b6a5 +948ef86d17128a061e1bdd3ea7fcc7348e3ec87ec35dc20a58dd757d5d18037fe5e052bb359e27ab4c2320d9a52a6a0b +a70f6a214097c271e0d2d95e30fce72d38c30a2f186271fdff0e38e005aff5baed53739b8c4f9501aa7f529c5cb2da59 +892a7574cf6704ad75b346c95ae6f2668904f1218c35b89b07a0c2dbf3c62173c348f6fd9473926eef56a37c0f635c04 +837e85a41f39b4ded1420aa8fc3be46a7adb99305e0928c6d7643b7c44434b72984cea08eb68f5f803661df0db78c87d +94e495329f2aab3eeb68f347961d1006e69d990095877a4dcc376546233adf29a14bf6b16a0c39aa477e15368e87014c +851860a8fdf76a97048396553262637dade27f1f63f926997e74c7c72b14b10293eae7824e8dedffad1aead57c124f79 +90481017a250972055ab1cf45ff17d2469517f10f18c9d4ef79a9bdc97a49093289bbacfefa8a1e491bbb75388b34ac0 +983db15f7463df28091c691608ca9c51095530fa6b1b7b5b099c612e673d29e16787cc9ae1c64370ba6560582ce623c0 +a477dab41014c778a1b78a7ce5936b7b842124509424e3bfc02cc58878c841c45f9e04ccc58b4f2ff8231488fff0b627 +868ebba1c85d1f2a3bf34c0ab18721ea725378b24f6b6785637ee4019e65d4850e051c8408fe94a995cc918c7b193089 +93cbf4238a37ccd4c8654f01a96af809a7d5b81b9e1eab04be2f861d9d2470996fb67367e5bf9dcd602dc11a3e4cf185 +83113f4e696030cca9fdc2efc96ba179cf26887c677f76cde13820940ad6891cb106bb5b436d6b0f8867f2fd03933f7d +90c709f4e3359a6d215d03f45ad5cf8067aedd4aab03512dd62229696485a41dcd64e2acce327fda390e0352152fce13 +9945cfced107a36f3cf028ba04c653360afc5013858b9a12fac48802efcbc198c9baf3a7f9b23dfdd5036e88bc7274c8 +832ae60192b47fc735a8ddeaf68314b16256c90ab68099f58e43073e249c6939895c544a02fa34e40805bc6b5db33461 +8b12c335818b643c1d22cbc2869606cf64e7ae54a7713617fc4dd3b2f052ebd6b920ca59ba2e9c7aa8cf71bb4f40f9e8 +a2033eb7a373931c65d66989644aa0892ac3778b9a811b2f413d8bf534e282c339717979f9aa742162abb3468c195f87 +aba2b4c37dea36bed6d39323e5f628ab607699c66767f9bf24ef5df1bfcad00c2664123c0d8d5bd782f1e14a06f4c769 +b71963777535b4d407286d08f6f55da8f50418486392a0018ee10f9ae007a377b8b8336f33386b0eb01c45695c3ed2da +88dc87826941340913b564a4f9b74985a311371c8e7b47881235d81c081f1682bef313c2f86561a038757fb7d6a1a8dc +869e13e3fcf91396750150f9dc9307460494c1d365f57893fd06fb8acf87ac7dddc24e4320d9cad0414119013ea739b8 +92194e292303d32b91ae9cecb8d6367c8799c2d928b2e2846dab1b901371a4e522fc4089aad8f4ee676f0614ff8b19d7 +aa589a3e512cb4f8589bc61e826a06d9f9cb9fdfd57cf5c8a5a63841435b0548e30a424ca3d9ef52bf82cc83c6cb1134 +81802e0194bc351b9a5e7a0a47911d3a0a331b280cf1936c6cf86b839d3a4ab64e800a3fe80ea6c72c3751356005a38b +88e5e9e3c802314ddd21cb86f2014948b7618502a70321c1caf72401654e361aac6990a674239afa1f46698545614c93 +abac1e0f85d5c3ff6d54ed94930c81716d0ac92be49e3d393bed858833f4796c2b80bf7c943e7110de7b2d148463bfbf +b7eb416004febd574aef281745464f93ef835fd65b77d460b6ad5d5a85a24b536b4dec800cfe80ae98489e54447e8bb6 +b3fd8ed1c30e7c15b0bc0baf0d9d1ecad266bafb281cd4e37c55edc76c202fb1e4ea315a91a2848f40f481793ae35058 +86ef674ddf4b7d303c68bbfb53db00b925ccbf11d7d775ca09e458f4ecd868ca828103e8e7cd9d99672a193e81b83923 +95ef414e9f7e93f0aaaeb63cd84eb37fc059eb8b6eced2f01b24835b043b1afb3458069c45218da790c44de7246860c9 +93ec8f84c20b7752bfc84bb88c11d5f76456136377272b9ac95d46c34fce6dcfc54c0e4f45186dd8df6e2f924f7726ab +95df5f3f677c03a238a76582d7cb22ed998b9f89aecf701475467616335c18e435283764fb733fb7099810fec35932ae +8cda640695c6bc1497d19b9edc5ff4ea94c1c135d86f573d744358758f6066c1458901f9367190dcd24432ae41684cf0 +b19aedf5569435ff62019d71baa5e0a970c6d95fe4758081604f16b8e6120e6b557209cdea0ccd2efec6ff9e902d6ce6 +b3041f21f07d52e6bd723068df610aa894dfdde88094897593e50c5694c23025e412ef87a9d16cadd1adbb1c6e89ced4 +a7f8d6ab0a7beb4f8d1cfef6960ebdaa364239eca949b535607dee5caeff8e5dfc2a9cfb880cc4466780c696cff2c3a6 +99a565b4796e2b990bfcb234772d93c5ffdbe10453b5aa94662272009a606ba6ea30cc0c3c26aa22982c1e90738418a5 +90c54b55ff19157c1e679d8d4f7f0687a70a27d88f123179a973c62565adfcc9347cfe31f54539038cf2f34556c86870 +8612f34bcd018d742202d77d7ce26cf9bc4e0d78e50ddf75250b9944583b2c6648f992b635ea13fdaae119764e7c28d5 +a04fb38e5529bf9c76ec2b5e3a1ef3c6f9effb6246c7f67301cfed707356ba1bf774f2867c77a5805933f0c8ad0ec644 +b4800e7b503da0164885d253135c3b989690794d145182572181995e6fa1989f3d0324993e871bbd5f48fadd869d8a18 +9981cd4f28ae7b7dadf454fb3aec29746dc2e0ca3bd371b2a57cd2135a7d93559e02132528ccd2d305b639d7ac51613d +a3ceec012dd1fbad3ef9f9f1d6fe7618e13d4d59e3f50540d2a57010d651092979c75442ec8b38a1ab678505e30b710d +8b97b8654d067fb4319a6e4ee439fb8de0f22fd9db5569ba0935a02235cb4edd40a4740836c303ec2394c59a0b96308b +b3d1bf4410fec669a269622c3ce63282c9ac864620d7b46c9dfcec52d8e79b90c4c90a69c32763136a7f2d148493524e +93174eba1e03f879e44921084aa0ee3562e48c2be49085de96ed7621c768ff52324d14c8cc81f17d7ed50c38ffb2c964 +aa2194cd0fb7aec3dac9a1bd8ea08be785926ed6812538be6d3c54218ea4b563646af1f5c5f95cb914f37edfae55137d +93f2c0dd59364f6061d3da189e04d6c64389a3563b062e8f969a982cd68cc55b4f38b21546c8a67c8df466ff4f61f9c5 +aa7dd497cc949c10209c7010ba4ce8a1efd3cd806a849971e3e01716ea06a62e9d5e122ad1d2b8e5a535fae0a01a7761 +ad402424b2a32bca775a66aa087580d7a81f0867f293f1c35580b9e87ccc5a2bab00c29a50fd0d7bd711085ae2248965 +96237843d8e29ac77fc6ebf4acc12946ad11697de8e5f152fe5776f2475b790226a7d156ac48968dd68b89512dc55943 +a45c25cdbb9fc327cc49a1666988af9ab4c5f79cea751437d576793a01c3eeea4c962c05c0947852fe0e4c63e1c84771 +93dcf834a614a6f5484cc4ba059e733ab5dcc54253229df65ff5ad57b447353ebbc930736a4c96322e264e65736948dc +b9a94f82a82c0c5a26f2c1d5381afec3645e8ee04c947dc3b7ad59a73018db1e9965ab3642f2bbf60f32c430b074fb22 +94eab29b3524ccbe0c4b928e5fa5dd8f684074b332fcf301c634d11083653ffee4f7e92ddbcb87ed038024954ad1747b +b8dca5f679931d6abef0674bad0639aefad64c2b80572d646aaab17adf5ca1ab2ebeecd5a526cadc230bec92ed933fc2 +944d394958e539251b475c4304f103a09f62448b7d8a8eaef2f58e7de4f6e2e657d58d5b38e8513474115f323f6ec601 +8a5ae1f13d433962d05df79d049b28e63fe72688fc3e6660aa28e0876a860c3dbc5fc889d79f5c4dec4b3a34cdf89277 +afa5278724998eced338bb5932ecf1043d2be5dd93f4d231d05d2ea05b4455f2ffdc0eadcb335dcace96dd8b2b4926fb +b91153a2f4647ae82fc4ee7396d2ca23270ec7f8884ce9eead7e9376270678edd42dd3d4d6c003dfc2dde9fd88cc6e7c +adc932f1c679bf7889cb1ff4a2d2897d7973483fa283979a0ea3640c80ed106ea0934c1961dd42d74b22504be49851f2 +a82e90761fae684d1415cee0649bb031bcb325ae0b28f128ab8e3650bccedd302a70de1a341ca8decfdda76f3349cad0 +8ae353188b4b98835f4ef0333cccb9e29e1ac3ec11d554bc96f5880c101cb3c84b8eefe72f2287b0812735339fe66cfa +b8b41135bb1a1ffb64afbd83e2189e755f2c350e1273cf47c38ae9b8c4800d831436a69458b8ef9fa8b95a148d8ec9fd +96f75a04d8752fa93dc1eaf85ad333cff4eeec902a345576139e16de3a88eeb71b6726224349bb9844065cc454d959e9 +ab82b05e3923ad4c26f5727c60dc0d23063c03f5a4fd8077da66aa87042cad1bd99586d4ab35aa5e4ce6f4da6fecf3c1 +a50c83db91c26ef7bf1720d8815b41bd056b49fd99710943679a162ccf46097a7a24585750ece886e38eb4fdb866fa37 +a719f667914a84f62350dcc6f4f30b9ab428eac6837b70318c3ac491c1e69d48af5e1656c021818f377d911fe947c113 +a148807aafddfa0a5624c7cb9e42468219e4bdb9994ec36bc19b6e6d7c4a54d3a0763d13ca80624af48bbd96d73afca5 +aa012f205daf22a03e9fb13a63783dda7666f788a237232598d02a4d4becec7a699ab493f78d722ce68519262924c708 +97fc15fab5952c5a2d698fd6f7ad48aff1c8aa589f7d3b14285fea5e858c471cf72f09a892e814104fa2b27eb9771e73 +8da8840236812667c4c51c8fc8ab96d20dae8e2025290b9cde0147570a03384370b0fcbe20339c6aff09cca5d63e726f +b477d85359a8e423fed73409f61417a806cb89c9a401967622aba32bf85b569e82bca1b3394c79e180114a0d60b97316 +b3d6ee2ed1e4c5cf8ba2c3a4f329832e41c7fdcbcda8a3fcbe8f60967fdb1717665610b7c1ac65582534d269d762aa09 +a0b3b30b1b830b8331ee19f96b4a4321a6b93a3395b95d3a895682c65ec6ea64774b878b93514eaf353f2e4be28617b8 +a2b88e9617f4d30ef4e686d1932ad43cd555fadcb5102e51bea19e6fca649284ccf4debb37b5cb2090ef386fa5bf5327 +8a4446f7e8463ea977a68d6217a9046ad4356d6fc1c18d46c5d2ab681ea977b8faff136d65abea6bbf8936369cb33117 +91e7464bc56e03f436228104939ddd50caace5a38f68817bb2991e193b57adf6835152bbf3dbcdebf0382ac9823f60c9 +961a441e6cdf8106c4f45e5b47190d35644faec701c9cfc41ced40cfdd1fa83752fd56c1ac49131a47f1970a8f825904 +94b7b165cc71c2ae82976b8f03c035fb70e90028992b853aa902c0467b384c7bcf01d56166bec5def4453e4d0c907e52 +a5d32cffabbf547f900026b34ef46f08075b7a244565f615370d2f04edf50b094c95088a4a139ce07caf55bcd99afa07 +b4e06e73660745f75ab2f34d9f6d2675b58f80f911ab6dd4c5a6ce1095f9a2b50d86f6ff9a05394190bdf96af0827920 +ad3fd8f83c0103b29d41319209dffca201d2b98094362da08da3fd6ff0ba96796b49d6bed525c9adb96c2954858e7f48 +b0c27430695f0fd20ae31e1ec621da090094f2203e17411db9384695ffcf5c7c6badf461ba49ba70164aacebd6f278ee +b9bc6e972fc3b532fd2b1eeafc4bceb77604885f32132af6a9a842fa2440df452f49ec0cd9d86da1180e8deb0723b260 +9729e22d6104b0174c136a854920f542b384d375040adcebe36acc253bdb55845eb43e34dc5a7cc27d22c417973c24d0 +a8b420b36d48786c9231d454468a6e855dd7f71dcfd095efc9855ee70dbece0f06ad277f7829c5813fc30524c3e40308 +8757dff5499668c93fc5d9cea0a8db61817b8ed407200d623030b5849a913d12f8371b667cfde8d8082026eda7407e8c +b859ad747ca5af661fbd03a1a282df6e84c224ecea645bc2d4ba5e35fa06cbf047387319fca0cbc76b712398c0798968 +8e3173c27875f1460297af0fa736c945dc842ec3e476a973d3d5f790bf183ad3ffe96ac13868c5101d8e299890791864 +a9d725e2b92c878be42b5eecc2c3081c63c7231ccc7e2dee17ca6a4caaeae22788fab1f1465fcbd7fc236613fc2bae4c +86f6c4f04a354cb2470ef91914816fd740f8d5795ce7ff981f55a2634695fde5951bbae7a4bbc4c63747040f8644170a +851773cb26f320f0c3f252d95ea7e058ffcc795dd0dc35e459aa1b6b448238909230d809e82022e64b7fca5d40b8324c +8962641e0306220d9892fe2d452caa286301a3c465185757be7bce2d9b2c9beb3040280099606cc86773e43941fd3439 +8beb6e08c440b0de5fb85251d39d9e72db4e556a2dfe3dae59efd8b359d08492064cebd8d8993254b43bde8bd67d969a +a7e047894466ffe3dec4ab8d5462f2b1d8ac0df006b1d2dd26caf499ea857d93a811cf42233f9e948c9cb903beec004c +92eedd95557a91691a5e2835170390ce2401e223da43b78615a804c49566f9d31cbb7f10c8a8390c4bdcf691544fdba9 +a5e5b5d8fa65824e958bbae98d146b4b332f97ed50e0bc2c58851dc2c174ab71bcbb1ae015cd2955c26b368487dd862f +853a494eafb308175629d581ed04bed71bbc3af9ca4c0dc483d03d27c993a2bbd88cea47c2085a6928d166fe6938fb77 +83f06b88d29afbfbe8f61811690322ac4fdd6abb9a23612162e7a2dd6bcbb5f14cee298ebebc1a382484f7346dc51e60 +8c9cf05735ea5a0e563490bdc7ed29a4426643711c651e35c8551ca6f855c8458ae8f0933a022d0bb9a952edfed411f6 +b906b48d807748a26cc2a8848455a76ce502261afe31f61777b71917bdf7de2fece419db636439478c7582058f626c29 +97efe1fa7c9b25d8bea79d74b6cdcf88f63f1e865f54b58512a2e60428630b0b40b8b6af1b5f71df47520507548c3cad +8ef5ca6e753818906bb3fc71405928d8e4108854ef0ef01c1009071b353bc2852e771fcb619d5fea45590e8f61003d7f +8e4d901661e2913740d70ba4d0745df5e8c9c0a260149d9362beadc7e669630ba909ff0e8a6cc85c54d6b7435d0d351e +b7c6ba3bebbd9592967954e3a480ee8df1d9f5965f04e7d78a5415b645128deae7ddaf6ed507c8877bfca91ce078e529 +840bedb0ad4e25acf6cd25dee4f98fea495b2312dc5cb7a8388c5ab00b2acb9cd25da08e9fbead145a3107972b1ccd5d +a8d4578dbafdb27f3911af59962d89e75dea74db55346720357790da677312c203107d9c7911535aa563446fde7d4c47 +86d3b77f231bfa09251b7fd2ce09c27ac520ec35d783e912476f9a4863f83d269eb175790d6e735da9260293d707f8ee +b34909f1cc033232652da0c34051a769dc76adb1aee00674a59dc1b860f6e610974c3b4bb69a69ccc73e01f042431242 +90799854d0cf34e1d91ff8e101bc7c5007423d34d2f3bd9adea2ecac57e83f3a65a506bb93d4caea49b29f6d18149957 +8ef94cde29b037e19a1ce7bf4418ad3c95cd9457412796ea385750c19a6690f13a3bb5bb6a9ee81e7a40face1e0a8bca +97053d21ae8d75972fb37f6fe516c38c32ab162fb56b9f510f954858f4e3ef6ac8c3a9557ed3f41b7b6aef05fe97f931 +90a9f9f0f40991f3bddc58b92d40382147db22cce50d092d4a05aad251b46b94e71ec9f7107a180243288059fcc5ce29 +a14265b1344ac2921b0f890d13bcfc432e4f648ce403e261fce4d3bb32ffee9e2794c02830346054f998e82784c77040 +91928402ae121e56a3e64cd6f390127e6e92fbfb1967ec6efa4f52f3e8058f1f41a0f4fe96b5bcc11641c1139e790b2b +921c8c92b6d40da6c5a7b592acc74fc0f577d93767b9aa4a1cd302a72dbf503a1ea5b2c29fa0d0359bff3b8f252246d1 +93ae0ebe0e8e133fd80cf67a499047e30ec4c4660ccec9d49098717ef57721a030f423e00c5e74af4ff4acf014a10497 +82c865e21905aebfe0496af1c6ac7e342b5f446a9edb4f7da0f2fb0340abfd8e6fc545da874459d9aabe6bce0dd9bfcb +aee3961d8d2687c0f134b9c28b920bdc4021d925fbe14323c84224a9fe161248789249fb85436a5891d0bbff42c2a3e9 +91aee420b98b6949482b8ff4be996b97245b4e8f583a6e085226539074f42aa89818395efd1a6699735a569bfe19d623 +a48eec22c192e495b01722d0016a54acc45ff837e2a95c4294ce81d5a4e43e0053a6f0ead8a4fb3ddd35faf6607275b0 +a26e15937c11faa30ffa64817f035e294cab0e839f73d29de8a244ad039be4e221eb47ea08d9a4658b0152fc3caf6110 +b84450f948aa7c8682fccb9cae84d8e3558adf2d0ca5fb81eb200415291158720f8f3470542ab5b88c6873ad08e7fa9a +a8e8ec27d0608d020169a85d6ecdb40eb402f006a3b97afe32cc01987721b3a68a92ec693aeb4d357e189e05fadf699e +ac87cd535ef5699312cc26f86adb71baa0be42e858bd5a2d94ac05737dac63430691e29b9a30d2559ad581a172519b2c +a4481e67b524f8cddf2046625efd3d75efee6aab87ddd2c1b22835647e918157e5e924ac760db2195c86d326f3db1615 +891f29ded231486ee826840c8895cb325f7e84a5a6d2eac246cb3573612cde274720233b1978318a57ed337a046330a6 +906b6e750e6178289012769807d2598925d7e51c260c14497d8af978b1695990e3352e6e809a752f376597a68083870c +b7a056898ee1e46f7f29702fb39232f678ec173eccd170303b3b0a30c8d8cf1a5321384e3513e3b03bb742c238deaa54 +8f2f035fd96c3a336354c89ec9b8222803bf42e95fb2412c28d4e75eec99c1d4d402501ccae17357b757db8bdb0bfeab +81228625ffcedf977fba9cfa13f6edead3985e2651d5974789c394a69401cd7face9e20ae6694be4c0d4bab5e99c61a8 +885a83eae25e61439ad809567a2ab148583402e01cfdd77b0e37ab4038935425c64b4e0886949bf06438c35e80aa13f4 +8926387f48752f6933899c48e038cf14e7941ec6a58bcc0a436614b396296a17aa53e6873803dd3041dae470bd493fcb +95d0d3fa061f4d856eca78a569aa132db14cede7646f97e2aceb6da0c8ea53195d3b7a566fe5ec8c41b95ecdd89a1c6b +a3c817f4062ed6aa94064ea695d76c1825f3bf77b310fe1db28b8bedc9aaacbf1019dbd128adfd53042fb943d863a2b7 +af1208417aa584052da309169854149ede38a3ad63c76cad6e43afb6f1a7b854edf8310a0b00088c039259cedf0f859b +8b713fc3196bad35dbf364089049ada5477e540d78d76a5f0a9df98f7ba4a0e65dd0644509c149f9b07887298bf74b04 +89c09c43c5b733c4a417cd9ebc0795cc3348b72778d31828a9171427779a82ef023c1a4fcfcdc919ae25056f9c826fde +a0759c850ed320c8c874435e90ace6edfb8e7b3f2a09d942b8ad8339c508044ee2ee26c70f1b626ec49a77971433b6a8 +b85cbc58d4fd52286e714ac4eaaa0b2743a1de06fa03ddf8f6668ec6f1d204acccce93b10620272afb8c0b49bc4b0a43 +814e0a87384e159892a8d23036985fa3f489c53bce192e107bd2d64f57b1bf5ea0acc1ef46c7a42bbc5cd0924d92b4a0 +aa6821da96ad89d7881b878e141076522f104ea9a5bbdd1fce9f641898f7d6232c518a87a0f666871d7e3165c26081e4 +a9041d714bfc067b5427252186fa3557bad598fc0067dc8521aa9bc1ae298f6e96113db5ac9f6bade9a85d5a950c9755 +b8669340f3064692625e1bf682d34fbe69a61689e3aa6d6a3e822c781d406b0300dba9c3f7b8152a8c2513f1310d4291 +a78c53316ce768a1dc5968030bf4fc885f4029b1ddb6a5d84a61c85af686c73727f62823891edfcb6ccf4545de366cff +ad1d3aa29ea28292ddd438c865e2b5d93f32cdf009e6d5f5dc726de996583925727e6348bf1c28c22dec0bd86aaf867f +ae1447a2062e9e28af5f38aecc60fe150cd10c2edeaf2110034aa144f6235ed7fbce432a58805d4fe1f6b12652d6e1cd +a32146634332d3303934550705353c6d4fae5fa5985105bba35041e74cd71e2aad67b45da171221f6ed80f36bf6dffa3 +a232e8286184196ea77427b53d8b52c44d758ecc42d22556529db3136379b4989dec61cff610cc6cf6700a450a847a94 +8a72c7255125a736da52dff5f77e44c3de29f88fc05f5ff9227c69df296930caaa11446595e6bea3bd946baac5ef957c +9688a981a9457678067f629f8efa6b522e7318b529f88d37ef56c5bf8f1c34fb9bb3a918ab73caab82bf5abb0c03518b +88286f3eabd71115fc3b17a6bf6981340a81cf7e5f96b0a1a016d4ec8c18fb486d46c70919123d0c189a6f5d6ff29a1e +b535e701b40d793c02ac0d625ca91620d3f4a512aa9741f71389e58381008b2f93d597586d06213c4e103d67d0ddf6c5 +80d0c9dd941e8d8d3700cc51a434a5aaa3308cf8ebfd14128ccfd258f826b27cc3cf5c3ad7851340393abb1eeab3a157 +87049225fa2380d93f18d3d90cb0697a56b373b66d7f24ab209966aed8b55a2790194d5885399db29dd5b1f189eda64f +a52df158ce8670e0290551e8878d63dd33b4759d6f50e448e63fc7fe6ea99dddb6f180be5fc0fc3918ce54c05f80b356 +8b2a728b39c465fb0f60b0c486e5dc8d5845ccec03d3dd93b393cedeeb3fe1b44518359f1ed55fc770a8f74bfeb9923d +91fc05419dba718fa4a910dcf256ebea356bbea00522d8d5ec3e7ba4271a26035aac15e8d9f707969df1d655d92dac55 +97c8779ae80c24c1f82d5a714762d6ee81069224e39515e41d8a71c9310dc5d1c55cc92bc5c6a4bd391ae4c321d1d4d2 +b5e5aedba378c4484e3a7a4ed41b75b0844f674261c2501497de6f91f7274b5a4c1be0e055f2e0c0cab843d891169fbf +8a26212f27211b295beea500abc8e9d430a8500d3a350cc62f895d39e8b4668aa638c17633804ba353010000165637ae +864a95118e5d394e00e99efebd505df0125525c9ebe165764c453b80ad3edc730feebde3d93850745dfd88a27bb8f20b +a092e0b78290e826cc1ae56afffdd08f7c10954f549a3ea6666f3db1b6cdaeb7df53db28dd2a92446342930fe60a27ce +a1720224c0626a081b6c637b2a6d37da85d9a82241e5efef3bc15699b02a69f6304e43d8ff3144d60c16e00225d6b39e +a7b3d098cebea9cf32e19c5195608182b6afe9d4af6b9df532c047eb7a941a971279b2ae6a4b80f2f9d9313a6d788ce3 +a3d2451e6788944802c5077a778d7b7299dbb9d1612676bb6baae78f39976e0fd879493cc4a4d737b8174b472a456850 +930121b73da844571b1411d56760e80923a4ee09917b3e9cff4d3dcb0bc27026ff2c4e2c44e7aca7d3f8383f129c7f9b +b4b0119d163ee00a2b74bdf188a5cdcf054daaa48c483b94bbb4d09ff615afb4a91347db6363bc7535e2af9054ec2214 +a5846decee706780201095a8cdd48fbf3d3a2eac8d089a818e5e22c29457494bbfb4399323b067f3d2be2197c33dbd98 +96ba600df10ee7af5a9df29c0ca31dbed275d647faf9c66c7342de927ceb25b5bdd852dd7aae0228b27897f90fdd5d62 +b6ac51ddc98edd9fb9f54ef84bf372a041d58dfdf0dfdbdc4b08ddc1a7ba93ddbb1413dda3c1545a3fd7386c6b85975c +b35f3efd91a0723e0d486188ea9675a3462106470455118392d7610470b623caca2fa33829721c05fbeb0fabcf570bfc +87f49e85df5f8055714a8ce7adf37f6a278e64e76ed74c60abe3edfc3611ef5b0426d4c6da45e5f3b74d30be1dc6f539 +8ff8bb06902a71b1e9177a77367318b2e3e0a88f5d74d6907ca9943f4f9f1ceb5f297132c2a025259d17a67e880d1bad +85eb6de6c70fe5c53ab0ab27aa0fec439f136c979c557d317337cafa6e6c5cb3169679c9169567dec5f6c72b3c057d83 +ac18715ed1080771d760cb7066c6328faf65d9b30517903f8a5cad8d66d5c6381156b521107d7cd75ebb8c30e250706c +b95b9eae4703727e4ac9ddf2ae675906487bb78905a5f9cba74a4cbfd118d96b7afb6ef3ed5edf14fd963b830d71338c +a3b47b52fda16b62b11c8aa4daa56b0b669c4d5c56a3059b7d063284d8a91f6fff9ccccab23d6ceb9650483b2d353039 +96a95b3f327df94c85e92f2e406f1649ac621533c256b062738f3c3ee137059a735a3e6072247acf57b1b0d8c219bd7f +b19b33cc04570be94eae8e943d5bb17bb0c96e9de4ca84f9f41b37320a1a03d397d53747dc13275fef1b356de557214f +a1faa3dcb931dd91507f3f12a17c43f6627fa2bc5c71fbdd27548e091eaaaba262477949cd51290e81196bffb954a492 +b060a16079dca1d28a1fb33cbc26f368630ee042d980ce305230005d5b9ab533a7a695281ab76e9214458303932d8bbc +b303783196a858fe45d67e0520c30576da605fd69964449c20009fbd5099cf1de52a32d326d7c3b864de07440195ef40 +aa550a4c20d1003d137ffd8fbdc1196d09ad53cfa0e202302093a80fa3bbc4c9aff83f34f2151785cc1ce5f30255693b +a7f8585f45566a351058e10c6f1ff4a7ba24811f1482a47202f581525615ca770da93f2f58878788b45b92cb446ef4ec +8206f63a9a5b59bd68e64a843e68fcdf706f4c13bbfcdfa9928298e5b9251006ae0bbd80c715aa3c9957d2c0148b5059 +ac9490abe1241319658f1c2c645cfa01296f5d4106020c7894b7ba4a65cdd52f6c5401bd3b3cf1c9863e088cd8c9a16f +85dd6d9c80a1b58c24c4d2cb7590d33d2454f381f58e820979948e5831972360cde67bbd56e1860077ef5192fcacb904 +8b0285944c676fe2519cb68da0973275fa29c0718d838d363ce46651b068d29f867cf9fe579ff8da0bb8b37d202bb23c +95147275da658d43a758b203b9ca1f1c1478853e9bf77b5218593142e2bd9c0bf46d2206ab64cef99295de6e9a268edc +b8efa187fdd3e1f46c15cd596e9567690c10e253b5beaa5be8074b6ea4e6d3d06e0f2b05323453239e419ae1e7128521 +8340464f52c92e31806fd3e8e65f56e27194d1f6daa4a0f0b3831e8102aba16f88bb5a621633ddb7dd0342e1d2d12343 +8615d87dcab85a78dc052f05a01e751176b756b5dc9985014347454ce5752f459dd6464e1c5aff36cb6c51b783fa2692 +80c6e35c0d3defbe4d3968792724a23f0b8830dd2fac58663583a49339ea20f1812cc4140e3ee867c7e716177319bbbe +a7aa63dbfc201dde8f29bb6e23d7aa5020dd35bd18a0cc93c8a10c35d695913fe25b9e8cf9b5fd1899e9657b22bc8863 +97c2a4ba80c4caba2e729a603d2faa0120915e3fe64cbb065f7ff33de5f877f1ec9461cf455e88ec9e9ded9393939dba +a54bd1419f0e2d2d87757870f37c476c7e3a13502f1ada82fd7394fd29f8a00c4986473d753034d0954a2550badbac0b +8d3e2bf900d0d2b9b46e6e2f37620f0cc90526dbbcfaad4e4a37ed53f39fdd23bd3a6f21aa7e800eaec937d9710dd6e3 +a88d2b1c7802b2dc216c2b6532406c091bfb12f29121b9a82c1154470e250188413ddd3e79f7e009ea987a4c45b332e5 +8c552c2101dfdc3f99c2da436115452e4d364eefe029b12946f05673c5ce1cfb48d39a579625849236dc6c8e7277dd30 +8415c252d52a26a6400c3189c928a98559bf24162ecf3eef1d10e439269c31d854b0b4f6ec7a2430e3f11b5d77de78d6 +8b38905bad93a8d42339dbdb5e510003c51fcaf05e04f88fd7083753353bc1c4c00a5dd4a67431cd4456d0669c7040e2 +b1d0ed8862250d0f0d9ef9dcf0cd16d84313d1a795dc0c08e0b150dadf9ce73d32d735e04632b289cafa69a6ee75dc89 +9434e18a5fb631b10edb02057f2d1fe16000ee55ada3c26a079c9fc3943e29d6de99e52829fe7b333e962270c712e51e +b1b9f3914007e6fca8ad3e7e848a1108988cb2318da36df24767d804e95d1272943fda948451135cc1b5052a3953b081 +8c02947a76d7b6c0a700a83dfb971dc105bfe996e18c521445f036310914b349ab28e57571e36ae08d13a46fb01c2f43 +893472fbc225f973a0ac6a0a0130b9cfb7ab6869dff80df71a62b1f6beb4afd069bbf35b4f327165bc31dff39e4fcaa4 +a7c176c0903175f3540d62f9afee994d5d9bf37081e094644b22f017e94c515afefde7bb07f638342abef7de657f8848 +860186c2b1d3b1e657729bc804275fb5f5ee89eaa60848fcabd3871289665ea9f0efc8a95792d884972bcfa2de96223b +865b38aea6386d0ac8f501a7d934e23d01dc50105324e354d4c4fa3cb1d4c29c26f4566df7b1a728e10cfaa9d24552e6 +b4eea5548de6969dada658df604b5d9c49002e2258352838003e0fdf7b299d81fb025807a7f37cf5b547cebd7f2c1f93 +8982de11ba68d63a649a3b296d4d56c71e3c3eec016db250d733ab7c3b9a620c09c5a5d0b64fd30d3bc03037ca4b17c9 +84d8b8a10d67eda4716673167c360fc9b95717cf36ef1d5bc6f2ef5b9d2624f0e76c2a704d016adf03e775ea8e28d83a +834d03ebd51aff4d777714783e750b84c16cb6627f8311bd8ff17c3b97fc4a5bba57d6c8f6d74f195d3030bcb5f07612 +aaf49e0def0c4d5f2c1e9c17b51e931d2f754b19e80070954980b6c160178349f6d3c8d4808801d362e77f41a0008918 +8ef4115edec841854e89f2bbd11498dac7396bca35dda554290d3db1c459ffc17be671f4a46d29fa78cbd6064cc2da20 +9641dc8a64f4acd38e343a3062787c48c312f1382f7e310ccea3e95e066ab6dc980f6ed90a633236a435e68bf6b3c625 +8a84cfc2cbeb18a11dd6c2a0aebb3f6fd58a33bb4b26101e826add03748595022e816afac79a4e7c20b3805252839dca +9770782d729017659844421e1639ffcda66a2044df9e19769b90292df87dcb146b20c6b9141bb2302029d84a5310665d +98c7ec9696454868ac52799d1c098c15ec4e08b34884dda186ebfe87d32840b81fd3282295df141c91137faf4cc02da8 +a3f6eb921247617292162dfc8eec5b830ddc294a0fb92f5b4828a541091ffdaff34c392c1d7168259d6204405d90ec72 +b185f77a468f07a54222d968a95635234e74fc942485604909308a9028ed2753b15902b9134749f381f7cd6b89cc8c3d +867608a682d53bd691dbc92eeb460d1c300b362ca49c11a280f6768ccec217f1145f9d59fe50d994f715ce89d38a74e1 +afaad630ad8827cd71aade80edf3d7aeb65a344878db12fa848759e6233f6fceca563aa437e506ea9e0f1e47b126d45b +a12afbc84e3441594aecf85d089423dd3bb8bb33a1a384ddf7cc14caa72284caaa56aa179c15e3140fd56bb532491a67 +98757b0b5e5837ddc156a4a01ce78f33bb1fce51e0c1254ee9b6d3942268d0feb50b93edbf6aa88f9ea7b3c0309830d8 +89573f4a4ae752e9f964e42bec77d28a41840c28e4bcdf86a98a131d0b85367b885077823a6f916972de6ac110821bd2 +a17f2745052de5de9c059307308fc49f56cb5230e7a41cb7e14a61c9efa742ee14c41023ce90c7f2261adc71e31045f8 +914b07c53a41c0d480083f41a61c10429ea42dafea9a0db93862d2269ff69c41db8b110b4768687b88089b5e095523cf +b380cc3e0d26370976fe891d24ea4eeb1b6be8cfce01f47fd68838a27190e644fd57b049d3aa0a9589370de20e276944 +906385fdfad60feec79eb1c303e750c659ceb22d9c16a95faaae093daadd53e7aa039a45d57e20951d6e1ca0dc899ef2 +b5211ceee31b194dba60b616bfd91536e71b9213a3aaaf5aaf9b2f4cbdeb05191861d78b97eec58e3c81abe4f0488c04 +97878e9e38c2f69d697800e7a2f132fc4babaacf471c79c26a757f771606e55fe696ece68a3163a0ffeb2f72274cf214 +959431c1f54c46500c05aaa9a2bc4230531dad97ae768fa92bb85436c0ecc6374cf20fb0ef82d122db116820a943b401 +b69e5a1c6798f30d33e42cb8d124f025d2c77c993c4c7107a539aacddf44d8d4d2239e802ece32e60ee4dbfdce201bdb +a8b09e5e9f802ad273b2efa02bcbc3d4a65ac68510510b9400a08d75b47b31c6f61ffdb3704abf535a3d6d9362fc6244 +a41ace7f1efa930564544af9aa7d42a9f50f8ba834badcaf64b0801aaed0f1616b295284e74ca00c29a1e10c3de68996 +a8f2aa0bbbc19420a7c7cec3e8d4229129b4eb08fff814d959300cd7a017ddb6548c9a6efebad567d5a6fde679a6ac6a +9683da74490a2161252d671d0bc16eb07110f7af171a1080dc4d9e4684854336a44c022efe3074eb29958ae8a1a14ace +8ef44d78d10795050c161b36afa9ab2f2f004ccf50fdeef42fe9cdc72ebb15a09389ca72a00001cd6d9b1d7b3bb766c3 +adca54f3b14fb18298098970b0267301b7312afb75894deea1b2afa3e85b7a3b4efac9971ab54c5cbecba2da9f18507e +ac5d4528f06fdccfc1370d5c3d03ed982fed0861a93a3f6453aa64e99360b124926d1892faaf72d89459e663721dfa99 +98aa1c801bd615b8cba728fa993021e181e0ad717ba01c0290e7355694155407083eb53cb70819c4775da39d33224db7 +8b3aea4c7c2bfe1020de3261ec085d79c7bf8a7903b825d2c70ebbb84af197bcc54e3653c5373a2045c3021526b63b66 +a29f3de4cb3d99afff1daf7d431b38a33a9804fedc41626618928ed059df6f6fe9f298a046b594ffee951ed4d4e1400f +803fd346be540c5242667c18ee41b26bc812456ab13ff117196ed69b90ee608c8cb6554396b64066a546ec87a71ed6a9 +a9c18d81ffd029c0339c72c499bb51685392253b996b6eabd8b76f05c6191ed8444a1397d63b9923743661a319517f7e +a048d5c390d08f07161faac71c5994baf152c883b205f3bb10d3501709d6516ae54d491b486303a11b751857a31f0052 +9156fb4803e40e28d8d57d928481a8de4373687288da44fe88c5676a8ae013ed1fcc09d56a31140bf74e7f767253810e +98e289c725b18e0085afdfaf2acbc674dae7b0a2ecc2537a7d0b87e20eb785404ab05973a787f0495d2adb3e5565c09b +8a7237b249325bd67cdc1f9fb278710069033c304afbf270b7ea24dbc10c8eabe559a484d3edc733c77b4384932deb41 +9056f2e5b02e5c2e04a69fa1323bbf1859d143761268d18e74632e43800a2a9c76fd681e924a19bc141de0e128d3e462 +b9f2bf9e4e7263014296a82b9ecbb05d3f1efa4b2e675e3b38d3eace59da06a89c859256e1b77847886d6aa15f98f649 +83b22949cca19030289bbf7cd2a0d8b84e1d468e78bc85271a6753241b89122627632723bc293cf904a5eb2b5dc6c3ae +a919aaf35dd0116168d2ee845122026416bec9633df113fbd913d8db5996221e234f98470d029a8ff182825b59fda20a +91726901f49d32b41afa15219073842278f60dcee223640903d871e318a1c2b541136b7b38a7b2ab7d31e4242fc29674 +942b77666545bc9a858d36cfe857ab1a787c9528f4a0b87918a06bf510793264dcafd12ae6bd3ee300179dab7f40aed0 +80adc1f2f9c47a96d416e44fcba41628abc0fae1f88f6a26aea4648419ab726f7fcc2187c7d5145e3d8f5a75c03937f4 +8041e0f66ba9dcee01e336dd4d16ae5e4e1618512fc147cc8230003aa2940848162dc2187d4130bf550dc1f3559849d4 +999e8adc51bab54386af1c5e8822986ad1b7ecaf1f8a4c2baa5bb2fe9d10710e49545c5a8bd89ed0e61a3d73a908e5ef +89272ffd39b6e9f99fafdd58bd9dc00f66f26a1d36b38a1ac6215e3546d966739eecda7fc236335479207cef95cce484 +b8e0b7532af13f15dc04a0eb4ea8abd67e58f1b1c6ad2e70c0ffa04a5c18ec2018b5d7f4be2f9f86db5e0b3986f639d9 +b96bd11b0f6ead4abd5fe1e4c6e995da7583b901afd01cc05e87d04663fb997997d6d39dd9fb067c62cb1b1cbb67516f +94ab08914088b973e8dbd5685decb95f3bf9e7e4700d50a05dbf5aaac9aea4be2c10c83096c02252e9238ceea1351d05 +a188de419b062af21275d976494c131ba18d2b2ead8bdbfa38a777832448e64d4d9725c6a1d530ffb6513f18d5b68d9d +8f73c8c118fa25c76a4ec5611351953c491452743056a819c8c82ba4737a37d88da0b55f837e7239a5f46d2c05a1bbba +894a44769e0be1c26648b0d89c4c9f46dbdeb3a71b90c493093bee372bb9f2d3f319850fd886d51f4f58db0de5641742 +87d239923b0db024a8d9b0281111d47b0761d81c50652268b074efa3ea70d793e30f874a91ce33a4acecd0cf38c01951 +b1b48b75a97f9fc2dc9530dc69f6268829dd0ddd574516e7eb1b9f5c3a90058889a7bcf3d378738e6d4b02f5fbfa44db +83e3ee9526ffcb60c6e75b75550fc017912ec0daf96d0a0d5f58c1b229cce90c684ac7c3e17fb998def8e7e2e155d750 +b9b7bba579e474b0abdc7775ff5f84c9f117c6ca17788cf5a5f01b2c35a14aa39036031c8d799fec2cfb371d9f7471fd +90d7faf4891fbc368a32f575dfb69f13e37161ab4f63a7139be103285a49490c2851a907f8d36e09e7d1a190dddbc6cd +968c8b9affe18fc34a4e21f0d8c5518341c566099e6b45b8721c9912bab3693c9cc343406fe90279692a1eef2a3f7311 +8735baaf4704207550f77df73fb701d9a63329993a8cb355ccc0d80daf950145f37e9b4b22be2aba29898e974f9fd552 +90f52b2dccf525b9191d836b205ffe966d9a94f6c5800f8f51f51f6c822619e5abdf1257ee523597858032d2e21014ec +831209f8f5257bb3eb452d3ee643d5f063299f8e4bfea91b47fc27453ac49fd0ba3cf9d493c24f2ca10d3c06d7c51cd6 +a5a4db4571f69b0f60fb3e63af37c3c2f99b2add4fc0e5baf1a22de24f456e6146c8dc66a2ecaafeb71dce970083cd68 +b63da69108fad437e48bd5c4fc6f7a06c4274afc904b77e3993db4575d3275fce6cffa1246de1346c10a617074b57c07 +a449448d4156b6b701b1fa6e0fe334d7d5dd758432a0f91d785b4d45fb8a78e29d42631bc22aaa4ea26f8669e531fed7 +aabe43de1350b6831ef03b0eef52c49ffb0ccd6189cce6f87f97c57a510ac0440806700ce2902e2e0b7a57b851405845 +91015f144fe12d5d0b0808c61fa03efe0249058e1829bb18770242f5fb3811e4c8b57ff9cb43deccfc70552e4993892f +8e9c570811ce44133ce3e0a208053acb2493ef18aade57c319276ad532578a60d939ed0bde92f98b0e6a8d8aabd60111 +8b21839b5dc1c9a38515c1076b45cedec245d1c185c0faac1d3d317f71f1bfebba57c2559bcdb413d9d7f0a2b07f3563 +90413bbd162be1b711e9355d83769e6aac52fdfa74802d628ff009325aa174c68f5329ddd552ef93e8fdcb9b03b34af3 +8b6b02e3f9dd1031ebd3df9a30432a3c86e64306062ef00a6d1243620d0cb66dc76f8d0d412eceff877ff8768c2696ce +9894b41d9fc715f8f6addace65451f41dc5ce7b983dd8cb33757b4d7259bef12f144e0077d0b662aa847d5a45f33c563 +a353a9740f6188d73aa4175a6c5f97898a05ed7aae9d2a365f15b91dfa7c28b921fdef0a32d90b6fb82718b33d3ddb8d +984eab8faed87c403c9979f2d2340fb090cc26d00cb4092aeb187c3f4ee1df3f57cb8363f7764073188790b16dfc464b +a5c5ae0ba435fb7f3ddd5ad962358da326239ff236fc3b51bd22e88296236b109951cee1b98f444302badc58d1b5bfbe +880be1006b0156f2788813432f450f613d235f41aba52a6000d2ad310408ad73d86b79f6081aef1e8c51010d404ba670 +937da751aae68f865c7a33fa38d718f20e2a1c65cb18c8e08f8441f0cdc77662789d2793794dd0a427cad30cd0b33f42 +9496fde66c834ff86f205897db12bbf9a9bb78d9ba8b5fb539cd0a2c927cc6b4120c017b0a652750b45edbe5f650e5dd +97a6f409ffeb593e149307a14bc47befb632412d70565c5f13d6b7d032acd2e3ed0f7b6af701b387f11d69ee4a8094d7 +97ed94934263dc0260f4f7513745ed3483cdddb9adb85dc33193c3a8b4d52affaf1ded23b59c34651afbffe80d40dc36 +b2b26378d44f916bcf999db218b9892e06de8075f205c7dafd6d37a252185c2d1b58e2e809c717963d25627e31f068e4 +b8f9fa1fb45fb19a45223f7be06c37d3a3501dd227c3e15999d1c34b605f888123026590697d0ae24d6c421df8112520 +997aa71e3b2e8c780f6855e94453c682bee1356b5ce804619ef14834475511105b1e4d01470fe4e2215dc72182d9909c +ac2cb2a7cf55aaf990cfada0218453853047e813d3f51f5a623d09f4714da79de6592671358a5edf938a67f905b6cb5b +8d8340d0c3081cd30d34f3ff6191e1ff6ad7994b4ebac19e5936f1157ca84e1813228b7605ee226366d6bab1e2bf62a2 +9693b17669086003cb46c75fed26ea83914a54901a145e18c799a777db1df9c9ca6b2ea3ee91e7b0ab848dc89cf77f19 +a6b6b2a6cd8c4922d78c8ba379373b375d66ac6ea04b830a23d5a496cf714a9439d81c865da92d52600aa4e2e43afcf1 +89cb665020abc3f5e11a03c7ba5ec9d890fa9ed2630f1443a8e45a28c32786ed980b5343ffffaea60eeff5b313bc0d66 +b37b989106594221bc6cf33a1a83c3e65ecdef279e90333a9e105b8139dc28384bb2277edd4b77c9e59d15e6afe074c5 +98ce5aee5918d18b2326b30c1ba41669cce20bc7a1d1b585363305fbdea66055164a7ac398ca0f0e670291a3061022eb +b57f472d5f34beb4cf430d7c0f8ac5bd1c0621a284633ed36e6f7804bc2b7847f54b469c7ea163a436510d9e3b32f97e +ae673a6579dbf0504c8fd0c8fc0252d2f7ae8da615a06f4d215c2f8a8f516201f24e5cc42967630c252905e5dbbd6377 +97c1501835a31091a5a83f0546e01c85ee847a0ca52fb3cc0653f6a826e13d25ddc623a5dea139108f7270a1fd7043ea +9376ee667f3834f6c0da4324fdcca5c04712e0649877ee19da79a2d23be24640c38758fce562470ce2134ca34148ffe3 +818af89c40379a10074cfaba6d5968ecf667f1a68a7edaa18e8977ccb34e0829f237c5634fbd079e7f22928b277f1096 +b8e0af0be0a252b28df25d4a509f31878bcddf702af0e5553393c3dfd4a1f1247ad8dc2668bc8dedc9b41f6ad8e71b15 +811667ffb60bc4316e44bd04573503f5b4dc44d1ec824393a699c950e5fa085b146537ddd6a08a3fede7700396a0df7d +ad834cbf850b2f61ce799c4a0f8ab0c57039d4e1113933c50b0c00175171aadee84894d1376cf325bfd434c3deb44315 +a8b7dfcdb40373ba4d55e751ccfb9070554434df9e359fc165284ee3dc35db6fb6055657ecf5a9e9b7b8e2e1abea4375 +b56a5b9fd41c9d3f65532aa58bf71a38fcf07782e1ae0084dc537862fa02e6d66658b19d6f71c39cd5dbfac418da1837 +a935af5ed224b9533b41a7e79f872f6851591da9e9d906050ccd1b2c772a1d6d010c5fc7160c4f8cd7d3aa14c3bcdc26 +a81e580fc98692567b28323fc746f70c3139d989fb6aabf3529504d42d0620f05327e3385c2bd5faea010d60dd5c8bdf +a8b352054cdcde8ddb24989329a249b71498a5593a13edad1e913c795dcad3d24789abca9c7ed1d57efcc9e3156da479 +b0de8a2bd7f93284b2bc700e442f52ada16a22ad8d86329591547411c23fff0333b2ab0c9edf82bf7903ebf69916eed1 +843e9781b653d1a427f3534b2e86add49d308ca247546f9fcf565f9e08df921e4d969e1b8ed83f3f849e98c0f63e39be +84a4098c5dca9f73e827d44025473096101affd7193c40a0307e3215e850e753e9a08e6e74a442d57626ff26df77faac +b463eaaa2f3315b511c22a97fad353014d840a6a95fe0d457d0677e63e571407d7f5268f8775381a5e7adc3b4163eb88 +ad0417edaa16cfddc288eef4173aa7057ca4f81e815541ac588ef5f24b98d56fed6845deb6ae1a9740a28bb1cd8780a7 +9271963b8fb2288a96e07eac13c0543ec41abdc6d978bd7c44ae08251ea49994412b542c77c8208cd71fd8e7852d4a70 +8b68b6db9044d8bafc155d69e0daba95cd59d6afebb085791e999afed4f33a2479c633d31d534ff767b8cd433d591a23 +a6a06a0e433e385437d9996ce823abda9848754aa9cdd25ec8701af35c9ec15df999825669bbc2e17cedb597a96e8eeb +94d414bff8b6b8597634b77a77d1060db8e1af0d0ddfb737a9bf1c66c8430e93a425510af2464bce4a7b29bc66cf325b +b6514049562af1c6fb7d0e8df6987b020f0b7a6e721f4862e36b1ba0e19af19414ede04b346be22d348b50875803d1bf +a42c7fb34f2fbee8aaccd1d86672d0acdf4e6bb083ff0456512d7e1e43be041cc0924322fcd986e6e1bce5d5ecce6f92 +867cbdd169a52440ae0a75d33a28c7d00aa92b4b65aaac5e62aa53a8fc367c08ab8828cc8fa18b6e7d1f908d158e3382 +a6fe0b768fff3e4a6153e59a7b7508eb2ee8165eaf5274d41ac2812bd4563c4ca2b132f0e27ea2f1c98759cc3589b61c +b3eb1dba43d10b9e17ffec8def053fc96f9883bacb49330a089a0ca5b9ab0182e8b5111ad4aa55c1ce1b6f4afa5c70a3 +a1531351098bdfcda566ff4d811301c0305626c77f954a38420c490e7c684f517eb1a4e4bd2c3904a10bac889cba314a +92278d106ad2f27eacdb86bdb1faa0a07a93765bb79dcff191873c52253af83480114b2299ffe5324f9c31d0abbdbbd1 +8900ba95a90c447fb6fa1f528af3d7a378aec25feb0620516b6b97e54b328fc31af42e46a8ad5e6e3029d83a6f2bbe5f +86053d481179c1ac910d5e7b9a5de82794b442f20e854583512ce1f9c3f09e71d1bf97d6700fe776debfe1527ab97a82 +a32a60de492fc4340336416bccbd2591b5e414fca0aead82281212e24490acc01747537b3da783684e27aeb987245cc8 +9820fe8e0338f21797143f368177e3669a1f3894b40ae9fa3b353125f7c8e85cc424dcf89878f2c7667f65db3b1e4165 +934d64711b4348ac5e1395cc6a3215e5643b540f591380d254165486b0ec2a1d0d21c7d2c6310f9e0eed3d08ecf4b57c +b9fd32d589432eddcb66dc30ad78981360915854cc44b2afeb826b5d48a08e377dc91be66f5bf1e783d1a8bb320f7ccb +98c972cf01efff4fc2e485b47572e2d8dde22461d127ef401b71a111b0603203971e3cde40912643affd7341cd27e57a +8db6c1620760063edabd376f4399b6e1355462e04f5c81cdcb3989fdc00f9a466bc85ed899e886c89c149adad69edbad +ad7b7fda0aa6e2aa66a27235ac5cc680aa04b85dce329fc4be84f75c9c961120a3d9e446aa44539aaac8ea203eecb4eb +8ccb01eaf41d816ce69ebd57754859e263530915e775c4e7d9dac37b2457a9099b9ae9b4c6cb09eb5ff246e3c9320c59 +b895b83b5f7ca46e02697dbaa6157df6c7571864c83e504a8c77d965bc2ba97bf9353a71c56a020df64498bd40e30b21 +8018c07a81c522fbc25f2cb14f2321c61b98bd8962ed8eb7d5823dbe5d1958a5ec2fb5622fd0868e991bcb6cae016ea1 +95b16364e94d01b3664812264d7185032722a4afc23bdd33bc16ae87ee61816c741657c37138d9312cebfb5fcfbb3b2d +94a709209990a8b09bfb4b9581ab471aae3a29526eae861108b28edb84aab6d28f1d7a25dddd8150b70af34bee4ca2e4 +ae06c80839c5a13269b984ff4d8a5938c6f4d8d647b1b1daa8cf7f6145340b76a286cd615ec251a65501e6290162da50 +875cbd0694eeb90d3567da9dc7f570d97b02bd9cf17bfa011efdd48f1d580608a3213bff4006603b8b4079fa66bded10 +b27f88c455f025e1cd902097d6a224d76bdf9c9195adee30bef4a0b0411fff980787285896e1943a62271d0aca531446 +8024880cde783cdb2b863e3dd856be92bacc5b2a1347e96e039fe34279ce528560d2df7d4d1624a4595dbafb40529697 +8883d02c2a5c0e026d941c785128d4ac6f7a9de625ea735b7d6ff27a5ba10fa4d6370d450d99a855d919f40d64f86afc +a1beb985c45fdc30ac536f1c385b40b6113ef6fabc2f76d255490fe529468847a776efa674ba8fed72180f07d3f701f1 +ab83bd9b007561695210e3276fde72e507456ba277ad4c348a2aec7a6e9ebdc2277cb4bd0bca73bd79bd2240a1fc4456 +8db27f516153812149854fd6bb1250e843a3ae1c9637df818b08bd016a769d0497ab6087fe3b2fd4080882713607bf46 +b3891dde4e00d60386aeff161b4a0fbc30bb31ee7918ce5fc0b49aac3238a000ced192c9c4c08d90de3a0ba973d7cfd6 +90a2049a15c02e59024a7a1cb0adea97501c60b1c7442fbbe560054c3d69264e69627ac57b7d9be01bef498bb2a60198 +87df67a4bd72444b5faa4f3b067204c4927c869dd3b29ad192d859589a9b2c1d6d35ed68310081e140add254a9463092 +8f80986a8dc8a0d6408ebbcb4f234e76413c11cb0d66067f9436bb232373100f20a4fded60f08dec3525315abfaa8523 +b061e10beb12ba3683688a4ae3a91600d14878ef78a308d01b93e4918efc666450e3f7b0e56283468e218934231df98c +86b9e55f3783d62e381659d3e06699d788b88aab1ff99848db328a83c97d223f602201bf2127c5ecf419752fed0a224d +858d878e29925c87243e010020007f96fa33264e89c8693af12857b362aee3fac2244057e159651c476ebe1dfbd67bcb +8fd47cdef87d7a569ffce806d2c2dad100692d6c53e5f5dfc6e274f897dccadcee30fc6c6e61373961bbc1f3ecbfa698 +892f2822daf3df3a759bef03168c1cb07408df62e024747a788e94d2da325f880bb9c6e136c7f6643f45b021c6ccb654 +8714e37ac24f5a198f219e7c88a92172fc3db129e044e914663ac708d8101851e7c53fce79d32d0e6da74f2ccd1d30ff +ae95e1dbba8b9e2c8dfbe1c202e9ccfd04fa396470035a699b902fbd86d5e6a31732a7c8cae00b9a4f6e51c8d560c7c3 +b0cd058e77498e860fa20c5f8d9bd09bb249add1badf84ba8d1bd49e704b9b4bcd67a5c3d211840a2c8fefab3fea639b +b78e468d3a7da0dd481f333ae56534e2ef97587be2e259a458e25aa37952aed1cc5f835640f812d8052f5bada8f57b12 +835de7965c6b26e7ad1b92eb6f0261d1f376fa12d61eb618d9b342b597c9c117a5a8f6a36269aeea88072b4641e6b5bf +b4d0eb99136b3643468c9c48a20fad62785a60fbdd3c054efac4bd1fa7979b4c9ca6c2c0b18069c0912bea2f19832790 +a00c47315dc0700a850966836a95f3cebfde04dd094bde0742dee77b89a05b5ad655921f86fafd1e902938ff34d4c58d +ab13fa0afaa92229a71ee91efae6d1b15f14b6eacefffb7401d41d0d6db24e24a8dbe8ee19b4680ecb69d2a0cb4e84e7 +aa56c0fb18401210062dbc653df8e3732aa8921a1280e9737e99b26a0100a13a9cba8ad0317a69bba16193362ee0f030 +8b410324a6406b345df0fa25f541ac20b7313fa55832752f70cf4c79f43b0bd3d5b4cdc447e6ba7bca08d0edffa8e29c +893362241ae412d9e5df46506407595c58ffbd7fb1fdaf0694c3432470599291238997abe118bf7737e56a4f5c9dc292 +921618194a756be81cb49d6357cb392b32cc62d96c8ffb7e16d9659a0f226a0436bd378da7b835054dbe0de2c6372ef2 +94a2904f10994928ff5367b777e1430047736fbece33442cf452018bfdeae62e84cd75cf80f8468285e347d504c94111 +b4b81545b767f380bfe10e0fea9c3cc62ca8db40b43c83ffb245259378731298e3eb6c3bdc3a16932f88f5d8a86edc4d +936203c2453ff01c6fc635e4d54320d69e60047d805daae3b75633c2259108497b778f011e5a057249f11b2b888ea76c +b90bf6378d29339443c3f2008b1e2b5f0345f86e393027f14a295e583bf6e6c2b10f54b6dcc42079ff0d356c405b03bb +916913f550d327de2d8d6c7723dcef2e3869efaf95fd963d95c8980b97748c61ad8e2e629cead8577266d93fe39203bd +a033c6f3d5ecbabeb83eb363e54e5faa7ed2d7f4fb771b161762c4f003eac4e1afb236806b784baf2222cad54e2d3cd9 +ab289d4a5771147e6c29ff9ac2bf65d70081ea6c6af2d9b728c3c144574a31b5fd8632af57c18c389aa2cd994938bb0b +9488da2019ff13e290eeac132b491df58b5b7b23c2898ff1a67bffd7e9c9464c39bc8177a57950fd28589e3d9ff9c6c4 +a5abe42b2e0891851440fb2aa6c1d8a86b571bce8b80c8e9e2692e5cb6d45a1b2f055c9fc4c74a7cd292871604129ea9 +90bfef698e83c2ba4dc9304aa01edd274169a978b7154bca518daef394f55857d0d1922ebef3d91fc5ecb3b895d9e0ec +92328f1372b6406ec80786041b6d57018b8507e3881a08727aadfecfdfcfb0824394cbb1150117ac5da5d71b89e895ae +9719751c5f7a65ae2bed8aff7b4b8c34539ff011b259b7ff54f63f9d987b3fbdce5c99534ed561aadaf07bb6e939e208 +a151816774aa9379fccec21cf212429a1c68cf91b055cbb9d931f461a8d5616c693331a11ac5c6fcfbd17d84ee0b44e4 +a72977b1285618a45943ad00f33f37102e2885eccd2f76785254eeca495068fb1d8d49865343e9e8313c6c2c3b2024da +a6f5ad2e023a1585d90625c9f7094f0e8851c79f0eede8ec582ee8e063407cc5b8298e5fdc4c786e4fbbcecaf33e787e +82901e008febcea0c0a14ae21d985a397630e18ee6e346f4a449f23be228e8f338df567d30211a11180b94fbc5204bec +b9b57fdb8d14d1be87a25f89553b3966eb7869e0519ffdf4cc4d51f4cec90d68f7b81cdc0450e04207276e9c63ace721 +a06eabcf43585a001448f3dc30411f3d5b74fd0a695c81eda9981842ba2bb0081d3f5a8360aa18b6d43ef13ea78b293d +926fe48a7e8f07559b7237beff9504476dd97b5b4d67acd01a3633358a6ba4c7abed5c87683a11209aa2ee759888e00e +a716cd3a84a963e2a5a46145b6ef4ebce705de52bf2945c374152a1e41c228a9c4eae0b6d1e222c1eea8b9c13c002177 +8a9b5985df6fb32cdb06ba1591a977545444478f2fe985ed1b10de61c630f0a4693c2185d63f0dc0256b208072c43b17 +a8eab26ae0ebcdf96a59fad1dc2d5e83b94abb2ea1774b607023f9d9e0fe065853b1e2242e794f989a80a47f550c0bd9 +84adbf38164cd04f3d770a7f4b8eae7a5d25b4a803fb63c02b95b71b33e454319c44e07a760d22bf5f58e7e372d09a16 +90f443a3ba1b9129a0bee400b5b29d42e50bb2aa56b0022bbfc3c6f8d69db40299871ec7c1b68421cc89e1af6b13a39a +81c5a94b379eb98c494a8d0067c748ba47e87a2ada0105202ed7651eb4e5111a0cd8569b06ae68d392c4fd74a37833d2 +8f92324b14a1549ee0b186073a26691088e41556d33b54258fc6e0b000e9624156db4e97861a0ec22960e6c47ca8a1dd +8b021cd0fffe055068cc460aec3cc455952e2ac32be5fa060e0d1b6cf30ed15381618f801249e893b1b9f10dd82077b0 +b3e9f0dcb3d6f0b138f589fa54dfb01f849890ab97016372d004aac55103f363a64bc0e606ddf75430f1534a30fc522d +8fdfe64af891db89b25daa859864d479cb7599486bd6f36e593f8f2f839f942261ffc3eed5001a93fde44cbcdc24c583 +a9e4554373c5073e135874e2bacbee69c65308eb0785532fec6a37834e8d0b437b77a2f11cc63c87d7183b82cd9b6bc9 +b4c47daca723ad7193ac5098cad4dcab654186ec5ea5c0fd014a3ac39726be954565a901694ba211820c011fa1c59e18 +8835427e86cdceb4c11cbea331ed724e4e78af15e3bab5be54f6b926bf66b5d99bcc40dbc456d86342c9fa83a033c2d5 +8ea84590a400cedba047c2661378921a42f5ca0421da58c1bcb37bc686a2aed98afab3fa5e6ba3a51029390ef3cdf4d4 +b48551170fc479d69fffb00fae4fba301e92e37cae08f596db6f6489c3b7020edc074f9e8d7465b84e9dcef1b6b3aecc +a6f318b1eaab00836a330710e88bfe400395b3081485f6a212e3cba9463f6fe7864ba4f71e57a411ecdf2bcb4d189f96 +848d5137a39999141a79f4bdf91150796ba36352d8525821bf3bd6e070b352792d79147341b8254dd60fa8c36e9e2618 +a8526f8904b1eac4ae2a25534aa91e8031e9aac7b8f58d8f49897e920c36c0232f4a30aa6eed305deb0f7793c115b267 +b8b6a727c44c37a8388383e959d195d1d0e51a657d4ba360633d219d43c5df645383e2406c25f1d418e72b862c3a6e9b +92e64adf65b42c978f36dd03ab22ba983bfbb61944efccdb45b337ceb486beda99818bf20d32a545503c4572bb0a4983 +9653bb83df66260a0bd059cd4244ef7c661b089e403d26ba777d2090783ff31f963f5d3a9c125b1ad1a1d19134f3fc8d +a74e72355e71ae5eb36dc75191643500ca3e67f18833ee981010e7e7e60a68e1b01b05901eff05014b9ef29aa4829f45 +8b2139a5da14524cf6acc593144db23db424b95b8c7041d8f6c7a14a6725dda1cd09c42bb3ae26a5a3650affaa742800 +a60ddff4300ca44a7c7a00a1f98441ad1438e07c30275bc46551cee1b681926d2c825cc8f90399ee5f36bb9fbd07d3dd +a04e5e9958867a5acc15fdea0d88951cfebd37c657102f6ba1dcdaa5e46cf1c823ad0d98718e88e436f260b770599102 +95e977abeb70d46fe8d7584204770f14c856a77680607304ce58077550152733758e7a8b98b11b378540542b1175fecd +8c9ec93ed35a25ce00d61609e92d567459a45e39922ccd1c64ab512e292787125bd4164c00af4cf89fd3cf9deddcd8bb +819819ad0338250d9c89aceda9e217df12ac54e940c77fb8420575caa3fa78930689d0377ba88f16d38179a807135dc6 +8baafb379d4150ac382b14a64788d819146480d7a1dccd3deef6889686ded375900f5df069843ef14d754ad3d7540401 +ab827236996bb79b447714c6993af941c5ae66248df4d9a6f3650d44b853badb5c0cb67804210e07a7b9d66ca43092f6 +927656c3eac8d2eb575e3daeb77f9605771170c325bee6aeade10c083d42bd8dcbf3bcc3d929ea437001c7cf9a95e2da +af22b212d5ee44fd4197966b9690487c38a119cd6536cfb8c181f38a94610dd9e057f95774047a446504dd96dd11e326 +a44bd94b9e01e3ba36340f2ac2201ecb477495d4f1fb6726a6b439302deabb5a35d237c6a6aeb7e3b0a65649f8656716 +af367aeeae3bba14fbdb05bcc1a521000dd9d37f5c34ae56fb306d3dfda201d0329a8b6e89d98e15825cb3c6bfdb1194 +abcc4fbdea43e50ded9e2fb01464f4e87fb136e960141e8d39214f92794cfab5634f22cd40b18d8c0e501f2307aad23e +920786cbd674348b9853689915dfcab02cce2a4596d117962bce36aadddf4bdd143891e22f2c8015517039a64e8aede3 +8cde63b9bd57cb3ef743f1f3e8250669eed739e5fbd68c500a3cc0c12f93862a69aebcdbc69dd8f476c2eb307f572a53 +b967e65a5f1cd8d5d570f5e87e7e186fba51b9504f8e466392a76d8a971fb91fd9b7565bcc1647f50d7d15e48b93bc95 +8d5a87b25fedf5edd57d870304bfd9081dc78c3e3e3b38b997260a92edac7feccdaf24feb51822d2edc223b70bb4ed5f +b6cd5d340a57f8ec73723c4f3ecd6601620dc8137a3e75a5d3c578bc79a9cae86b379950c644dee2ff99dad780d025c1 +b6f0a8e754b7f52a85a2a2e6512cfd017f7fb0418d19bb318308951c4e242d3c65bbcb9748da9cbc91a738f9ca577332 +a89dcf7d410bccec385400dd96b1cc6af89026a431d0f531aa992cbd7bc8bfd7c5f360bcb665bda1d72efa17bb982551 +97788e7522427a46c4b6258d15623ef7a565712812fa80d001e1de8dc1791392702f3fa3cce5a8cd1c5755625a0ad10a +b5338fb5e137ff625b27c5148298f27ce8f493e2527c5d0facaa49f29cae34580d0d6c3c1074a2e46cd8db3f56004ea9 +8962f006d7b1095dd0dd132ffe7e87e328510c95ad893cf3b2ab21c177c5cf2c27f47d8856f87e9762c547be009d25c0 +87fee9ce9c26aa476e67e0791a809e0a06a8a98facf3faea730d438d3e516cdf75d645fa75c906e4e44ab9237a22c016 +b75ab972e1a1214bab0b38cc3e973d44bb233acda5b4291f5e110b6fb78fdcab93dc63f01168debd898e165f615be1f7 +b5a0fb52bca279d3853761a94b206acaf313df33ae6303d9b71edae90b66fc507adbc60fb11e758888736c81d5d80c0a +849b8f0005010e684701cd3a4e59e8c89e5fec59af6d2de5b6332cde03b865ea84f07f0b80ec3404380b0e148fbd2c24 +96e2b0b6fe78408f9208f809f5c40398100b2dac202c8c5c33c2189560dea868270a598c419871a5a2b67783354f6014 +b234b81f996142d0df2c719760bf996544820a03195a6dc0ff6a72543692f5a369bf63d1f0b477ef2fe7b3234e41f685 +b85e39bcf40da1a12a535740176f4de749a93824079deb5fdaa004f3282fdefaf5275e3418c88c419bd42a3dd2ed2b3b +a27279304b89a18a4e2b443246f2368fb8b15f46a34533179b6bd2ef683f6e98e222b7a32880b39b8fac1afa90133803 +8923c22cf15c9c1964213d725b337ece9ea854775a06f75f232c4859c7142a3942f418354e33066298aedfba3cb27e62 +b109f714311fb9bc431ef57911e2cad6a3949455b9f23255cd7edea35be629e07f845fe53e2b12a32305ee2f4f264f27 +b51e82ae5c7d48050e405897d0053e9ea4b2714d002e88f78c9a307cd50b9c6b3ee7cb86f86527be9d964b01895fab20 +90db256931c7f98bcf3bffff4d496739185e7a20f329ee7bffd4e0850a37739948ec745285703967f4ca50ec370cf68b +a0485ac0445d88dafac56bfba2563b020cfc370f54c1606c89d12cfd8a4d1336d2ba50306e476155a6f5b0e0a1f2d092 +a00754c3462e74bda928da855bbf90f9077db395e32f03cce9b2955546d900b72330d247b7d607b65e130f5b0d883de0 +8547d56727c3ad8b5c8ce622ed9ad86fe8cd78e6e4848c9845914b5063b17330bd10b46d8d3f18f83ca09ecb28d1afb2 +95b937b2a979bce0e159ac75c7d5d659be8599c92305e73e942aab414793364a3ec28c7c1c8491a5750ba84a29828d8d +b011e150f0294e45a0f4c69409999d0c2e602449dbd67ab95e8258466687cd733a0329083a31b03722f4e2580ddc95e9 +924651a733ad5e5d9adadad3ea6a6babb8e455c8d5f2cb5bdc83fa422e7752592190ccedaa827b866861e73506a6968e +a4d5180122f8e31503ae027e54da50f72f5cfb910a6f7309bd882b5cd666f454672591f1f20e461e182a47d03b47052a +ab19ae659c4f73ea3d21895269dbec583c7029955a36469124ebe295027010faab56c4a475973497f28e9a77c03b8fd0 +ae7ea1a803d0f439e91494f8f35fc1167dae23834c0c699ffe65d3da8b09f8df5a53195a99ca7b8558242279e69578fa +b9d63cf0e30f9800101b43b980bcd2f229758e74b21ad5354866b4e684791c08a184330dc316228a0d67fe0210f2bc4d +8c41629744391ddb96dcbbf9cd99b13d36e57d65962e0aeb92ebccf1c4cc769626feb3ec0363def08eceb102b3dd4ad6 +b2848ff24faf9e667a8c19d050a93896e9e75b86595f7b762c7c74ccdfb9db126ae094961fee7f5d1192776c1ac1a524 +af013bc29206743ce934d5887b8d0fb3667c89bda465d2321835a3618513fba6a459dd7566268220ffce7e0c97e22b2c +8bb799e36db1132da8e8b028ea8487dd3266b4628c56dfae4ea275f3c47c78e3d7445ab8d0aaee4cbf42148b3a148175 +ae2b81fd47c038b5195a52ab8431f0d3cab4cf24c4237252d955aad2156adc16dda9d3270157e0bfe5a44022e5c051ef +8e0129213b1698d2ec6df132356805a8633ba79e672e586dfef664ffccca71834253ba14f296da962651fcba2c002622 +a1ae30b500ae77cd9bbb803d737b4a5991cc780618ac22b5cc179efd8fe10afb8c135457f2e7b86ded485ea12eae70e5 +8a39723077b7c0df6e3bf6548afa3910c214ee275951fbe5155a39473be98099626ea14d844630a6fa90292b9594665d +a628386c79b61aa7314b01d9814aeec20c2a66e3deda322a39957e7135c2e52b1da486d1b9cd61c87afb22c1d10f6462 +97867f469b01249820aadd9a54e12d4fdadd4555f2d530450e1f8f6d2dae57360578e2c2c8ba41e3b5950df596537a98 +97f192d0457c217affa5a24267dd16cb4c01de8fefde9df4884e1906d2f22e73382dcee6c7d910bf6430bb03f4a4f1e1 +86d5b5739de8442dc74d0d8dc78e49210fe11bf8c6ff0f0faecbc47b64812d6b28c8afddf6d9c0212f1988451d6ccb1c +8ff3312ce9693cd4a9f4b8e75bd805f65b0790ee43fd9e075fe4cebc87185bdf161335049819f22530f54fed2779a5b9 +8dc41d85548bee5d51941d55752a500bde3c5a8f3b362da4eec307a963968e26605048a111c9166d448b8dddf6f53892 +996bdfd004b534151e309ac925fa5ee7801c9da4f6b4c43e156d1158b134535a2a3956e1255e0dd72ac2af6bddaebcaf +aead652704b788bf4983c8f725c644c327a6e9f6683215f5c826c09f82fd2e40631791f51d14e6aded91fdc018d45501 +991ffab58a82b98ed8fc7b00c3faca153589fe09cebf6a137ad506387a1ca4dba475b0e4a1b9bdad829f1422facaec39 +9652e6c4ae084221d6bad855ec0bc11b5f855c6efba67f644e0902ab790a98861cecc6ce047c68273c3aa7eeb2f4c7d9 +b88b816507aaeea6dc92b861eabdc96988b74d7883f20a4b30ba249158acaff3c50d261742fc9ad2e9eba888a8d59065 +acd028a51e16c07a10d2073b9d03070457ac5f1246365295a1359d015c460b92b4861125fabe6f114de8197045df408d +806d3cd9d02d41c49179fe7dac5b05dcfc9a205a283135d4f008d0771c58e6f963d7ad0f6798606edda718eb5c7ff3ed +b9b71f1657a6b206fc40159a941e127f252a7b324dea864ecd804f48c0ed86da9778a925fb65491204a92bc2a26fef32 +80ed67bd0e74350c875abedc0e07fd42ce7cb926f0f3fb1949c6ac73f2300b5a14a5c6f6ff8aed99d5ea5029bb8e7ae6 +9875f67a7a473714e4dd75ee0c763ddf88101532d9680724b3848fef69e218b04a96b90f88e0f4409aa40b9a21507ecc +b4a2bb1b421e5243e5e7576a0672dc19f9f70315a03f6411c19f76616ffbb70fc5dc0e57fd4ab85e24ea2261b7ce38ab +879723002ce43e6c75ba2246f51436efe3376242beff987d025c3c4476495af32d52a54fad5d9ec329a442b93bcff1ce +a4121efbefd9c3eb143619afa52a916f199c75024908047763b29466cdfc837c2fcc894aca63044c33c41c777e529b5b +895f637b497a9766714a3d9e3c275a1f0c9ddab105bf4c8b7e663f36cd79492022415bb4938c1a4849bda73106ace77c +b119acb8b161ce4384a924645a248a656a831af526cd337d97e08405415b9dd22060849c76b88a4785eb5e7214961759 +802e712f4c0a17009c4be6c1e5ba2ca3b82adcb68793ec81f4489b7985babd8a3873d544de63d5e5de0cb4dc5048c030 +ab111051e4651b910c68ecfdc33f2d99e7bf4182df68cedbdbbcac219a543e04d93ecb2763fe32b40c095c7ca193c331 +855c73ef6afc6bcaab4c1e6388519fd5cbb682f91995bebd558167715db454f38012291beccea8186a3fb7045c685b67 +a29d02ec6d9baf84c19dfd0eb378307703bfafc0744b73335550f3cd1b647275e70215f02d1f4ab82a5df4d4e12dd938 +91510a45b8a50cac982d2db8faf8318352418c3f1c59bc6bc95eab0089d5d3a3a215533c415380e50b7928b9d388ff89 +8286e7a2751ca4e23ea7a15851ad96d2cadf5b47f39f43165dde40d38ddb33f63a07bc00600c22e41d68a66fd8a0fa51 +a413d4e619b63799dd0f42ac57e99628d338b676d52aec2bb0d1bb39155ad9344b50cdfe1fe643ff041f1bc9e2cec833 +85524e5bb43ae58784d7e0966a664717289e541c8fcaff651541718d79a718f040a70aa8daf735f6635dabfc85c00663 +97f0d48a4028ff4266faf1c6997b6ad27404daa50ca4420c00b90f0b3e2d82ef8134d0a04108a74955e61e8dfeac082c +8df6145c6cc39034c2f7331d488b8a411931c8faa25d99c5432831292637fd983d4f6b1a6f55522b4a42a462d63c6845 +98c2060f67a916991b391e67fcf23e5f305112807fe95bdddb8ce6c4084126557e4c5f003afb32e30bc6808b30d4b526 +8964246b3c2b8f7312f0a99647c38ef41daf70d2b99b112412356e680185da6810ab8ee0855ad7409d334173bcc4438f +b56c2c416a7069c14bdb3f2e208c5a6ad5aac1cbe5b1faf99dc89c7141d0259d1c6250be9d9195500c4a41182ad2ec3d +b7864583a4cae3b1083dcdcff7f123d24a69920a57d6594d0b7219e31bf0e236682442b6499a1f6795cfeb4f5f236695 +a064f94139bf1b70d476bde97099631b1284aa6b4d87f16bfc65c075e58b2f1b3c2d057605259f806e545674a1169881 +80d1bc4acf14c0f487cd57c5d6157b7f38917e93cb660f1c25e474fcdcac3c3dfda50f6bcccfd6676bae25c4b6b5014e +8ad9a4976c4e3e282843518149fcf5d454240740f4b91466f6310b7216d23d70b9b47c42870293252f29f092f330967a +914197593d2d99d784c704cad7ecd3f0b9f55dce03fc928d13e1a1034566c4de754f1c2a5ade047b0956415fe40399ec +8d77f5e29c572ec3c0ca39cbae2072ba4102403265b3d8c347a00386da9c0b8688d6e3280c96037c300d57b3545f3773 +abfdf79d935fd4f06a04938d6580a8cbf9735f0d498f49677f26e73d3b34b7075d525afcb4f14ef1632cb375bef7dd55 +a97a8c446e3edc86efac7bda5e2e5d0158c909552a3bf86151df20ece63b8d18b608f477286fb1c7f05605ab7e6a7c2c +8618d946c7fd62486551c35486fa466bdfcdc63c941e4cff5a01fbbe566b7ea9dc763cbe73e2acae063060b619a212a9 +8d03ee468070936004b06acf64b868963f721f37faa09887f8a82c155ad5c5732572a6855b531db58af03b1afe034a18 +8d3247f75966ea63935ef6049f7c889c1651374adb446f49499fc9191dbcde7ea33cbc1f1e2d3d1756b6e69870404643 +afc853c3a3facb4ba0267512b8242327cd88007cef3bf549184ee891b5ddc8c27267bae7700758ad5bc32753ebf55dae +80df863eaea289de5a2101f2288046fdbfaa64f2cf1d6419a0e0eb8c93e3880d3a3fdf4940f7524ea1514eef77fb514e +8434b5888c2b51d12d57da6fb7392fff29393c2e3bfee8e3f9d395e23ddc016f10ebe3e3182d9584fddbd93a6effcefc +b78cbb4c9e80e3808c8f006dc3148a59a9cace55bcbb20dd27597557f931e5df7eb3efd18d880fe63466636701a8925e +acb140e44098414ae513b6ef38480e4f6180c6d5f9d1ca40ae7fbadb8b046829f79c97fe2cc663cbccd5ccf3994180c6 +936cb8dc959e1fc574f6bb31f28b756499532ebb79b2c97ff58b720d1cd50dc24b1c17d3beb853ba76cb8334106ce807 +adda2116d9fab2c214ec10c0b75f7f1d75e0dd01e9c3e295a0a126af0ea2c66373d977f0aefdda2e569c0a25f4921d0e +89a5cefb80c92dcad7653b1545f11701d6312aef392986835d048f39d5bc062cabc8a9501c5439c2b922efc5f04954d0 +b9acb52747ce7f759b9cdc781f54938968c7eeacb27c1a080474e59394a55ae1d5734caf22d80289d3392aab76441e89 +8564f72ce60f15a4225f1a223d757ebd19300e341fd9c1fe5a8ece8776c69c601938fa2d5c21b0935bd2bb593293272b +a5567d7b277c4ebf80e09c7e200c20d6cb27acbaa118c66ef71cbccb33ee3ddce0e0f57b77277ae1db9c66ed6e2d8f30 +b82e9c2d8df1cdd3b2417bf316d53e9f3cb58473c4cb5383f521ef53e0af961ef916e4f6557a6d8b4655ec01415231cd +aa816dfd2814c8a25bd2cbaf66303ee49784df471bac4b3188074ea30816f00f425234454d40d8ad8035aa925d74da36 +9919f384df20faaa2d226b521cab207dd2b62420d25ebbda28c9b2ca76a2a52203b2ad7844c1a25f5c75f005c5a83149 +b24a6aa35c2d0f87e36598b36224c64427cd69642b6f9c1bd478a62c70f8ee69f85028648f6603b4f04fb21355f2afb1 +892e044bdb1276b455eac2204be105e1821f987c2570494b1f32aa09506caba7ed343cd09b1bc126fed5e0fda3d0eaad +af0e01a3ad954dc048de18bc46bb1c4971db2467e839698e4dd05cd1adcb9261013fe9fd0cafb946c0b586f6aad86d4e +ac152f0a9ace425378daf02510eb7923ff1ed2c0f8d1deb918e4efb63655de1ba58c96438e9aa23abdf2431dc771370d +ad8c7419c097709347e2394195924e09617b47ac5c7a84aeb9deab8975f22155de0f70cf20d8a976551b14e3a2683a2b +808f14f67ae801536fb70a5898ab86e50ad35340cffd0648daed2f2c4564c9ad538034b2a179a6a8bfa27e9d93b4cbe0 +80a74ab7ce4769db93cfa695a166db95f0a9c47885ff826ad5d93310f36d6b18b5351c67c858b9837b925e85a1995b63 +95b88c3cdd64401c345828f4e4754b1a88b4875a14c08a668b90acd499b3b858842669ecd73a46c5d9f1de32ec1a0120 +8ddbd770b7b18a5917eb43926fa05004e819f1d1ead05b915269e4a86b53e0633a90559007e59f6705a3769e2126ac56 +ab6db5fc220754f19948bef98844e6e38dd623565d1695e1198040c228ac4fd863c1f168cac1d036bbfb718d9d8dd036 +97bef628e977c069e60c395a17740e0e1bc1828f5607ae7f30ce5a0c95f02b53af2ad062700a75212e462aa22c3c5465 +b68d465e04fd17ca98501e61eccb0ce30401855e98046e0c1debba71c2153d6a7a704aa36a6f12454696e78e87181cdc +a79cfdd048f4181e005bd0fbac0a8424495474956b58ce858d2b700fb0f931c406282bd33bfa25c8991bc528d12a69c1 +843f55fa0a6a0969daf2b48080738f30b269b2e7ec123a799e5b203c0b3b4b956dc95d095bc6550b0013918cdff8a225 +b683cdf2823036827e5b454bfe04af9bec1850d25a7a7a44aee7696b6ff0468b7ed6885a41dde2b8f3ecc4aec880c3d2 +8b500796e82acdc89778e0c0f230f744fb05f762000fee877bcf57e8fb703d212dbc2374887bdc2e7b7a273d83a85798 +ac35a8ee87bafecb1a87f15abc7ccf4109aab4ac91d357821e417f9b1474d196c38cc41cd13667f68d1ffab5e79a6e92 +b6e517739390cfed5b395d33b14bce7cd7aaece57fe79a7eb3cbf150dc10765c3ea9fef7976a21a2243687e6eea38ef6 +b53901eeee26692273365b789f2a60afc9b5f0df229c6d21b07016cf4c0e7985beec748aeca52262f68084393ab038e1 +ac4804f33d8ba2b4854ca3537bd8bf2dda72d4e94ff7ecaaf9bd3b7f098343d74d765471ef80072ae34f860b052cbfb1 +8c6a30a93f1dde18039bbdd1ef294552bf79856e20bce863e4b8dd72d906be3ff22468ff3610e06b5a7d1745dde7ead9 +88f0607fa3b7cefe20a02115572b16fc3222be86bb19e592c86c48afbe7e0dd523492b0c29a3bceb9a20f5538bc3134c +a660b801bbddad725975ddf9a8f606f76ecef831f954be224d6178c368e1c72d346f00c4a4c95c289b62d36f2af323cf +a75b9a6aea9542b698938dcd6cc2f6fe0c43e29f64b2f54aeb05d35fac73d41aa7fd750af4fa9333644aab8db90775b9 +83e1b7129d963d1cd076c3baa5fe422148e939273db173e4d59d1858a7d841eacac7fe817d15ab8f8a493bf46c2045e6 +9060a2e9c24de11f9c70e039b5ffe9e6d32f1ae39f3dda263610df2265d917679e689898e4a8bd84ad34613dca5e3761 +b42fc8b863a2af15e04d1fe6693c09b46007c0b8298973fb4762b45b4590ad7fe0aa758918b2fe5ed1ed0359754fd955 +83e6de7860fb256ecf7b47506a5e557d0fb0aefe57fb513c7dee2bd9604712d08ca26adca7ba9a54b712372a7c585a26 +90586e9cbbf71475ecd3e7b5753b286804dcce61e165502a82b960099e79272de8b7494b8877b54ae838eb5d0f71af2f +b2e4b0d21208f73b7b75e08df80cde20c4578e117d37092a490af82354e2afd3a7dbab46fa2d12fcb731cdaece69c2ba +a010961239bb8809fc7fb4aa08fa30d33a130f9f417ee9ea60f587dcc5ef4e1b7abcdcbf8e848ecdcb7972ef6af46e78 +8f511fd58d1e3403a5eefdc0a4ba6b8af848c7efddbf9575ee84449facde05ae9a24aa41a5725416467f6fbd11369c52 +b24ebbd2d4482eb618cea1ac4fbfd9ed8c46c0988a27259300a7ce5ce1bb256aeca0357828cbbc4cf0dfafbf586040e1 +b3ea29e9cca55250e9b7b9bd854edae40f0f0cc65fe478cd468795d1288cc20d7b34ced33bd1356f1f54a4291faa877d +8a8b20f222d9e65bbde33638033972e7d44c6a310b92a9d9c5273b324c4ad1a94f2a10cbce8300c34dbd9beb618c877d +b2436a9a647dc3f12c550e4ddc5b010e6f9cb3f3504742d377384b625fc38f5b71710a49fb73ffaf95b9856047c98201 +a13f8b77c70621e421be94c7412454adc1937b9e09845c2853ef72cdbe500e5c1bf08e3c8b8d6b8eff4bce5b8dec9213 +b25de8780c80d779e6c2e3c4e839a5a107d55b9cccc3ad7c575f9fe37ef44b35db4c1b58f6114a5f2f9ca11e1eb9c5fa +96ba6ad4358c7a645e5edb07d23836cbd35c47d9a66937d09486570e68da3c8f72a578bd2e14188d3acc17e563a652d7 +a7f55989814051fda73f83b5f1a3d5385cd31dc34baf94b37c208b3eaca008ff696fd7f41e2ecffc2dd586de905bf613 +882d0c7c81e58eb9560349f35c35e4498dcde7af7be8d7974b79d262304c26ab67ffa5ed287bb193d5f0ab46b4096015 +a607158f0c1fd0377a8ee5e9715ac230abf97406c19b233d22f5911ebe716967cc10425546dc44e40c38bd6c2b4bca2e +87e8cde50e5d852d3f073a43d652f7186bac7354612517cfaecd4a1b942f06fef6f14546279c0dc0262e2997b835b2a4 +a1c93acc6db9d5ee426fb4a0b846bb7a7b8d5915bec777a9fe6907246b0beafb8938941c8c79ed6082155f75dbc1e332 +b1e4f61457b86f76cd93eafd7536f72baf239ce5a62bd5a8085a34e90576b1e118e25002d2de49b01d6e9a245ee7d3a2 +a0435fe9a4bd1031ec5973a103ec9396b2ce9fd982f6d9ed780fa80ac06a6e47a0a6eb2daf52df1dc9292db622ee9fa3 +b66d8e8a1717e4bfa42083b6ef4490e090a73168b2912f2111743e089027be0a4945a229ecf5d0b5eec11b23f0e11303 +8eb764f26904eea4f4169be6e75beaa6a39e4eb524625a15a78befe3d8e3cc82692d9b135590c20ed460d6e4ba630ef7 +b7e4aea6bb09829e53fe83e53f49a7a331a6d7bf76e0073d758577e6d6fbe63dab642b23657355cad48896ad8715119c +8f94207982373a99ffa282673f192aa98d0c4461fb77c31dc4549628bd9687a249f1b3c66b1840929341e42516c5c64a +a9c673cb247b13e17fa5e616f0399b7f5c7ad043e143e44ae68855a840870ab3d2aad737ebcf74c2cc9688d17ef3a794 +b02635104dd28c02068985256975c0af783899eb996e37d021d9a35238deeea9e836760db21869be7b6c82aa687ded29 +b33bc0966389710812b5f6698afa3e9c84839a1b85492ba11e6ded26695260abf66be6fb355d12d3a8524966f0f89e0f +a79c0dd09506951c33da3cbc23843fd02d641fc24c640a205e6e8150240372847312b9381fb03c5d301fe4dbee8d0da2 +b74de6f3a2c502b5b658ebe8a9b7edd78afd036f5a2736aa06502863b6865d131b9e3542e72a86fa2e1d2db4927661ed +99e365def1452ff9fb4b9eccd36ff4154d128469ba5bd73e83ae457ab53977cf6fc04a5d05bdcde357ab539e34bd9fe0 +b4f2bfb95abb47c67870aa6ca38ac8f3ae1b1a2bed064b1be7ff90865ea12e4930fcf66429c7ecd1183fae4a01539386 +ae4bde87f36b912e92398bf72e11d5389e93b2de1b277d7ed4b6fb5a9ab9f71a959ec3bcb734c11079440fe42b86fafd +b826459e568efdeeb66688482b67ef5020787275123fd3192f979b6175e3b0ed59e17cb734a0a052bf13f0afc7bd237c +a99dd735f4a7c85cb23dcc7f4835f9ab32026886909aaa95876b98029c37dc4d621726c872d3a9e50403443c958f4029 +99083545034768010988bf8a9f34486c2cd9da27a1d10db3ab86eb69a1dd9c8ee723e7da4ef2aced63c1dbd53ccc52cb +8ac3209349f0142546c714ef7e9d1b094aab5469b8f080c0a37cb0362da5349e108760f272fbba770aa468e48d9a34c4 +af5f48ed74b21e3f2c1430192adb4b804dc873cd7e8f07130c556c30e7b78df0ef5a14b205368848fa9185e5a68dee0d +b8b741b65d68df89443523ba74203226f1e0d13bab073d183662d124e83e76cd318b2bfff09879c04d81b577ac895638 +914abe4282d11176d4f2f08c6f15e6c2d0cde1ab4de00bbe888015c205f51929d97296a0a8d3ca5641f085a29ea89505 +83ec306b2a9a6780efafe799df90b1aebdbff7d47921a136ea8a5648b9708a97231245a1082fea38e47ecafbbe000528 +95d6b58d70b388dfcee4eda0c9805362ccfb60a87603add565b175b2c14ed92999dfdb0d3724ee3e5d30535f282641e9 +97eeb4de607c8306e1d4e494f0d5db126d53fd04983ab5674ec5996b971899e734fa4011f2c889da21154ea1e76dbd2f +84ff21977fbd873ea06bec444d4ec9ff0e3902edc29dfa25f3bed269b3709e3116e99dc06cc3e77f53c53b736bf8fc29 +8ecf483874a040a4a1c293af145094fedf203a5eb37c3e165857e108cce3e1210e0bfc0f26f4ae5e2194024929ba034d +97d9b92b2ef34609d69402167f81bce225ed3a95718a3b403f702b93e96a121a8f7f072d0ff47e8b25164e204d1576bf +ab87c39cca1803b4e84b32e40ff30289e3cbbcfbe16a70f9e025643824752359be1f10c3e5398df402b6fec64d5a3537 +af84ca57e6944332884b5c84750afe0d5950015e127acec161853d55d48fd864c7da8d59cc5aba4ceceac650b813fcc0 +b1d23d98edbe7089ce0a8432e0eb3b427c350fb4bb39eb2aca3c2bef68c432078cb9b4b2c4966255e00e734fa616638b +8e2b5252e0ea96d40835ebfb5693af49946509975682d68651396d6bb1463f09e75fd0afa04ccea49893b5b9c3e77e40 +8db25e762f1d4a89a9a1cbc61c01698e775906bc88a921b2905735457a35df9ab84bae12e1b1b8dafadd50212f1acda1 +b5f7cd163a801770a4034e2b837e00191b0ac63a2b91032ae9a99ec182d748798df48a14644935fabdbac9a43a26749a +998e7232e5906843d6272d4e04f3f00ca41a57e6dcc393c68b5b5899e6d3f23001913a24383ed00955d5ec823dbd3844 +ab2110a5174ae55ebb0a788f753597bd060ee8d6beafc5f7ce25046ea036dba939d67104bba91103d7838b50e36703d1 +a211972a4f6a0303bec6c86f5c23c0d25ab4df0ba25876cbaad66ae010b5a00aa0c5daded85e4326261a17a563508a25 +a49f53496a4041a01e07f2c2cf1e84e2ee726917bb103fd267451b9b7bb1331c0afde85a79a55409bfde27328b2a4745 +934e915c67c7fc47adeabdde49f63f04644fe234672003be2aa0a2454dc8d9288f94293478936a450f2e3f249d395b5b +b6e69e9d6808ff7f60a01b7aea6781495d7a20f5b547852d3f0af727a7434209d3015a9dd04cbe3e272918e32e345508 +b348d3462092b5c6fead7e515e09611438db8d69650876dd3b56226e303252bbeb9e9f3b888fb911445b0c87132a1d0e +8d6510334a905efe5a32001e167f1ba06f9bc4af7ffbf11b7f7bf3c0076b5cca373d8c47e98c1ba8755bb22632bfe0e7 +a2d5200f20985dcd473d119ee97e1c0fafafa0f191185bfed9cac429cef8198d17665dac4f70342eea66e6e4a7370d58 +8dd7eb6b1841b3f33425a158d33a172b79b2dc8a01378e4174e67a1a4c8f4b887f02c7c3a8f354ed9eac718155bcdf37 +b16ca19388642f71afcd9f7007b490d82f83210ac1a989da9d4bf4c419de07af8c048cd301ec7e01b9d06abda7c169d5 +93cb2d847d1a88de8c1c9d5b3c83efd0b7afb3682942bd2c8ab5ef35b33dc31a097a3e181daab8630d4e840b677216dc +a8b648c769e77a7b41c0c689fe2fba9bc585067e004bcb1732cb7b1618e97b317781c36c23a00680fc780b58c301a789 +918c321100d57712866bdae84edf7e42df30a32853af257e0cb4da028842a43b49e775f3cecb85cd817269c728de7319 +a7b0f6ce42e00c519e69b2c78fd9b75a2e7103e5892d3c1afd70c9b5b9e706180a4bf73dbb2d3eed52bfd521103ec5b3 +90041994af3322b010891356afd8115340bd7fd7ba328716fbc4fe458236c8cad8c7564ae473d6091ec3a54bdab524c0 +acb1ac83809573846231f9be2dc5f3e986cc36dd9574a620b1cced45bad0b11ea957ce8c6cbf964a0af916781c574f05 +ac54677dc002698fc4d454c7beb862ad085d0514f92576f3485a44c0cb47afb9db2c085058918a3508f9b3de0137d97c +8dea56e1bfa150e442f8484b2952b116781d08cfa3072d08657cc09b0217276efc4ab6f5fd726bfd826f6976ced8da29 +a2b09e25baf01d4364b5205fa0c4dea84ef8fe03709113b034f88a0f0a502a81bf92c1d4641e2ac9f3a6f4203d3645ee +b95fe37aa351b4292691a9c2e547224c37ec2751a31ecce59810cb2ae0993da6fbe5efe0ab82f164462fa3764b6eb20f +a3498947e91a3a540e86940be664fc82f1e83ff41a0d95eb84b925e820602a41b7393c8b458bd4ebbe574a754586787a +aa2516d3620c832e5728fefdb1af0be30c871cbad4b166a7a4565af676e73bddc2f2f51acc603b3a022056daad2b330e +a9251b56467fb55f64c70729e2ec77a59d7eac79cc0b4b25ee405ac02aea46bf1cbc858bc773934a6d9bea57cb528185 +ae8c0a4ca7ba6bdca8764bac98df0581f00358db904e57867e6ffdf15542e55f7bad2dedac152ef88038b466ed901934 +b0881e27e52cc6a57c4f3f278dffc7f63a9174b68bc867c16d8a151d9cc4d0aeb703d1074d1927faa9ffb43e10912c9a +b67138465d6654ded486d18e682f11a238d6a65d90f23d6b13eb6a1b7471efbac9ada6345dfb13e5432196d2a256829a +944c69a6f1126edd38f6eef60b8a5bd17147ab511e44e8e0a442e87244d8f35236ee0b8d3dac0631f8598f16486a5f74 +995679dbe03dec775da26708cb9200dabcad983825f1ba601eb9395f9da350ca71e8af61dbff4c668fd0eebac7e4e356 +89de362f02dc14de6995d43cdea3c854a0986c605ba5eb5dacf24e3a85983229bc99a2fcf50aba3df59f0fb20daffe29 +84607f0e2d078df22d0866285614f5d78cf7697c94a7d1b5e02b770101ceecbfd53806b377b124a7320d9fed65000b97 +93e3faab60050dac76ab44a29bcd521813e76ec8e4ae22712d77bb489bb49f98f9087acfd6a77016a09a42ddedab2d73 +b7d64a7a35f21747b8e6a874be31ba770c0d13cbd41448411994e8cebb59591295a26bacbf74ee91e248a5b111aacca0 +8dcad429a2b0d66b9eb8c1c3924d7a72979727db6a535526a3518bed2a9532d12aad1c5a778824ca4cb98e3e513f85f8 +980882895faa347bd2fd1dda7b8ee7ed49e69843afe646f677b371eecc7a10e0f4e40bb55f28995a40080df471876816 +89e8e7fb51df79971e2f7bf65783614abbb0d7f3f1b4a15d3f0d160deafa7ed1c446d9a5ae1a77160d4dd94ceed8af13 +93fda8d350392e9c4d4ffe6534f7e7be53f32483d9319093e8436fbb8166a3c01085dc858373e65c7f4d014e0dc2bab7 +897521a87b7ebf7152de5260c0875e3c7df1c53e734c672569219ee6f9bd196c5ecef159b6a1d3b7cd95e91b9b8803ff +b59affa408a0f7bd7930fa3b88750fd043ce672c10a3adeba95a12f23f0dda1793f761a86f7409ce1e6fd3b3b7195381 +b4422ccc12f4fe99c530cda610053af9ffe635b633d52492fd81271d1f6f91b87171d572d5bd0e46ff63e221fb2fc4a5 +a4542cdf3346ee0867c08d630c2aefc57442f1c05c0eba52d223bfdca5e9d0bb80775cff6ce2e28aa2730231fd7b1bb1 +a7d297bb09118b914d286e5d1e87bdf13f7d174b988e38fb5427902e8e8c674072f36b19055a1070abcf357f8668f35b +9213b0ae24b7cb43ae95e25c09fead8bdbac55141694137d67eb5eab5e90a348a13d4d4d2cbc6436fc4f4f9f7334ced2 +8aed71a0d116d832a372b42a0bb92a1980f3edf8189bdbaed7cde89fc0418b3ab21a04f5c6e1d3b8edf73f1f62bd6b15 +a6c47d77d714c285c84c6b9458cbec5e3b191c0502dffd10ce049cf1ea27ddf868ef0cff13a2377289fa6c932b8e4f28 +92f45622ec02483f2c1e07075a6695416d3768c8984856f284f40734346d56cb5b3322f20c2c9f0ef8e58ddc294a309a +af6450d02b79ac9fc79f35655b58fd3619cd5d38c5317564b453f5f2d79d7a030bf767e399fe01b658a72fbd2cac2356 +a3c01fed5240eb8a61ffa8ff4a120dbcebb53b8e19845949c77fb4f9b2c3dd52c7001df6219ad2f76c785a4ee0f64a2a +af3136bfe8f774187bdf87555a1ac505322a956229a285d28bab1c88d4f4d12245af8dff35914a62e90e49f3dce6acb0 +b20e21d28444fc96737958cd951858fda324b924b4d3d08932540fd4b87150f053db6985b96903906ce83dde0578cbb2 +b7978101071268d1f485134b4dfd1e35f89b82c7d99ae91f58b6745f5e0273b7e06f3b23009033ecc3e41b2e9e85219b +9104b7d75245b784187175912cc0ad869e12f1983b98e052710fb33663224362bffd69ceed43e7d4ad7f998c0a699eb7 +a7624cd71b92699ce3fde0e747976ee04ee820032ac45dd27d769edf3b3379a4b8db358e50c9d057c63b5a9b13d76bcd +9354a76f294005de8c59db10e638ae6e8c6d6b86a699d8da93143da8478d36116211c788d8285d8e01ea6647dfcaa1aa +b85935c04cae14af9848db5339ab6420122c041075ec1549314e3c9c5a610d9b794ea3617c50ca7af6b4aec8b06bc7dd +ad6835a62311c84b30ce90e86c91c0f31c4a44bf0a1db65bf331b7cf530cca0488efaac009ab9ed14c1d487da9e88feb +80339f0245cc37a42bd14cd58d2a8d50c554364d3a8485d0520ea6d2c83db3597bf51a858b10c838bfc8b6bc35619638 +b370420ac1a011f6d8f930511b788708ccf2fe23ca7b775b65faa5f5a15c112a4667ed6496ae452baf2204e9ce0dbf09 +8ceab3dadca807a1c8de58ac5788313419c37bc89603692c7a4d96e2311b7fe9e813cc691a7e25a242828cdf98f8bbcd +ac1526ebc6bd4ac92ee1b239f915e494d0279fbd065e4cab1f1b8a1663f67daa89560f6c99bbc3e63fa845520316d2e6 +8240ab0bc36a29d43ec3059c7e6355ff39567e135f93b243145d3ada97fd1c970743819e0d58bd5171967daec144e7a1 +a99743192a6f1967511b2d3038cc73edacb7e85f84b2926d8880d932d2fa12f5215592311a7548494b68a87ec70c93eb +8ffffc31c235997e59ab33c2f79f468399eb52b776fd7968f37a73e41949111957434f2c0a27645ab34c741eb627cd1f +8949d955309415d6d2cf6ee682ccd0427565142c1bfe43b17c38de05cd7185c48549a35b67665a0380f51aef10b62a8e +9614f727a9dac8ecd22b5b81b6e14d34f516db23a1a7d81771ddaa11f516ed04d4e78b78fda5dc9c276a55372f44c4d4 +aa85d3ef157407bd8aa74032f66bc375fddaff90c612470b5ff5d93659f8c3523b2d1b6937b3cc4201c2aa339621180e +86f8fe8bf4c262dc6a04620a848e3844f5e39a2e1700c960f20ee66d4a559a90141ef4e5091d0f32acb1e915af1e0472 +b3af2eb785b00588371beb3b49536b7919a3f2175d4817de5dcbf7fcc20c512852ef0f313327fd0589b10173f77b92e0 +8388703c512eea59190351f3bd2cce83ff8bcb3c5aefc114cccf9e9b3f78200d8034c3ebe60448aaf6c912f0ff8f0cc4 +95d0dbbbf08ec1ed3975fe7dd542be0a05156a2b3db5092825d918a849411ee536ed958201f74a5513e9743674d6658d +8d1a48802f1a2db247e633ddf61d3ef7a2c062c48dda59bf858916e04f56651a7d51e367d6535964ebf3ae6d2b21b421 +971436871bfe868f25247145a55802945409b3150008535b372c949760d7949dd2fdb40d9b96ae7473bc8f6e9b83ecdb +8ca431728ac0f156763090828a7b6d860bf591e5b9dd3bb3b7f3ba0ca74191f9710ee55efd32db7d18eab5b479cee8a4 +81e28f1a506e84c2b9aba1df720cb50e0b597b2c22f98acc34e710c934cc6f97dcaf33d589e845c2c1f6d8716d05ccac +8f43b11d3f00c41d16c9bc9bc0c44227c056bd77de4f1ca9a799418c5601e744f99066bef47da2d9088ae88eb259327c +8d330aa52744c08ef98cc5599eec8b9b4dd18aa01b803f1d1ca0e29b74f1aa2886ed0224390fc377af25852851fbee03 +a06f5b203b67134c685039ec2bdbcc787353e2575ce73a415db24a517c0c31b59d1de89f12b97cbef0219fb6a1e90a20 +9269a5f49bbb8fec1a387b5d105df88a027de615d5ca6afae20fe89b11746f8d23880db78dac238c955fc8bb3de18046 +af5074b3bc0656421c314547b45b5abd3045ca1b17f5e34ba39d8c1f7928a55d4ca5ea9c2ab59a55909b25255233e04e +8e7ee5d733c8e08f3fb7d85f0628de3de6835121672c65374905dc6d19e02fa2df14c13d5e9835dacd609a4df09abd26 +a9b9aaf83d31e879dfb8e73a0708801b4dbdb5d7c8654b27d2c0f5797ebcacc8d00a82143e2060f0917c9d41f1a03de6 +904872aa1c093cb00e1c8e369a3bdae6931c5b1ed705dd3bffba243dc4f42df3e7d7cf70303d513b34d2245743d765cf +8a4d6b3b1d6afe67383c66693f70b397e510be28e3d97dbc8ec543d699b6cbb0e72eb90a7f65e83cf9f7ef50fb18b128 +a914de13916e6a0dc0e0fefecb3a443cca80d83276513b70c22c6e566a2d41acbd33a0e2836ee09abeffd3a4894e437e +b9c408f5f05934b0aefab301ba22f8254c5ebbf5405b6aa788f76e4b328c150b395f441e3566015a0deb3eca89afe9ff +8d32aa2c81b2a8b89f347c2e0b6567b2117ddbb778fda8a3f19004b7f5aa9dd814b9b3ad35f9223715d2447b2d12f159 +8230e8b9c84cada1bf14ea6aa9ecdadd978d893cf5962fee6c7167ed21239210ea491987f2c8f2e8cfea8c140704ca28 +a5d7b6285fea51c6f21d0976a7c3a97baa3d733a201bfaac0994db6c65611d91c5fc0ebc2a7724ee02b371e575573649 +a54f00a9530f6930069f5e3a8b8b1d52ee1def0aad1763e3c609ec07f25410969b43d5943a94c235ed5eb207b33a402e +a8dc6e96399b81397734c61c3a8154e55a670fa25fa5854b3c66734cbb4ec0d8f6ba650ee3c71da3773ffc9e37abf8bd +8841fbfae1af4d400d49f74495f864804f043416c09c64705251d021b3ab7881f134a00b0241e61010617d04979d747d +95acea7ff4861cc969c1d8cc8775c5eae014ad6e2e0e2d0a911dd916c34ae69f53eef779cc24ff1eac18c2b478d3ba2b +a5dce74abcfb8c68031b47364bd9baf71a91db01e45514ab6216f5eb582ef8fe9b06aaa02f17be8b93392d9b19ab9c06 +89e111169e4ae2f4016c07c574a3bdacd8d2f359561fbbdaa3474de9bc24ef8936784dfe6fe0e29a13cac85a3e622b61 +a4c511af6bdf3892939aab651828259e4ef6ebecfdd503ecc14e61001575b313a89e209cb55a77ec19a64d29ada066ef +923c62156fbf3a44926ffb5dc71f7cef602dbe941a98c61f019a27a18a50c16b6135b6099fe04a2e1dc88a6cad989fb7 +afb9191c541b61afa0ef14652e563cc5a557842ce2afea13e21507dde0ebbe6da5233af949c998c00865c79bb3d45ec8 +8a1f0ad65cb2b225931f41dc53547d756111ecbf5bc57c5ee2cc1ffd61b126d0389d311ffe26cf06eaead95af09c5ca3 +9040b20b5ac2e1a9d30abf7a4eea1ec2db8f3077cb2cfc8736b37222d8d3937f5d9f421167086dc5551e9f0bd2522d07 +b6d888b8c6bd448dccaf99c3f690d47f802e134709ce102fb6f6fc68156943c0762be6f386338163e01eed2d1dd5f734 +b94f0e27bbcda793e4a272603b3dcc739d3bf3207798df7319f8dc9d37cbd850e3724bdd30498c929debad971950223c +9769827767be9d7bacba1b687289e0794c6fe630d33c9b607da1f6a65e3f34cb8bd65327d9287c8c5f3c8b5f6d3d133e +aaac72c993aa2356c9a6a030950441de42b2d746bace29865382f0ef54835bc96958b2f00237d805ee6a69ca82117c1b +a2b1f027d80c1b0e79bfc7dd252e095b436fba23a97a1b2b16cdd39fd39a49e06a1ca9a1345c4dbb3d601ffa99f42bdc +b3fa0ad1478ca571e8aa230921f95d81aed7eca00275a51b33aadabd5cb9c530030691d1242a6ff24e2d4cfd72a47203 +a43ed4368e78daad51b9bf1a685b1e1bfe05bed7340d4a00df718133f686690c99198b60031513328fc353c6825a5f2f +965e145711ecf998b01a18843cbb8db6b91ff46f668229281d4ca52236c4d40804ebc54276e9c168d2a2bfc299bcf397 +ae18e6efc6f54c1d9230210ac859c2f19180f31d2e37a94da2983a4264dbb58ad328ab3cbc6884ce4637c8c2390f7fc1 +83a9200486d4d85f5671643b6daf3d0290b2e41520fb7ea7030e7e342d7789023da6a293a3984308b27eb55f879ad99d +b925fb6ca83479355a44abbcdf182bfac8a3c7cce6cfc7962be277ce34460eb837c561257569be3cb28023208dea80dd +9583dd991b62ae4bd5f379ccd3cec72cfae1c08137ddfbacc659a9641e7d5a82083de60005f74fc807bd2acd218d0789 +ae73bc32e9ff5926e1e06c07a3963080881b976c9875777f8e4cf96af91bf41bdbed4bd77e91253b8ec3c15b4a6d3977 +b2a3ea90aa398717ba7d8c46743e4c487b63c5abb140555d8d20e5115df2f70d3c84a2cb9a5e0536b2d93d24f271b38d +91d119d3bf1d34cd839eb69c6de998b78482ab66bc93fa97e31fb9592f36cdfcd673f52366f8c8e8877e313b92d4a2ad +a1907e20120902cf68912cc3046f8806cabbd7673e80218814cb088e080dd93b5dccba395b13e0025f5755c183276c3a +b2e2011df72504065ec4c12cbc2137b95cfcd1355509671feb7b00dbf7f8d500476a49754cb7fb9219cb5cba7c8afe01 +a48589fb7a74a3dfd782cb3503e6294a81dbb6adb412887569f9408e9079371edbd9822388e0b7ec8d3297ba270f53ef +a203909bfe196ac65ed3e6800d577b6ca5c8fe1d40f7f925a43852951e38883f2ffd250a9e16fab3ed3dc1249650247b +997ac293722a8b98f7e819f8e6c2d4c5bd1103b82d489d8b8aabeb905e95450b9b75bd61442cf68cc957212ec1c55617 +9895a3de62395c33509b153b7820bd94fd2b011f0cac135fcf916482f1eda272ecc79f83a61837e99c3a3c4ab2c5c2a2 +98c2ece4d49a64ec8e06407a0585081003bcef88af35210e22eab91169f8f0c044d611494b755e5bd915804b1d857747 +8bc6dd083b36d076ddf0e0bb1bb87cfd059283ddabb3886f02eb7e27f1f0539b2819527b56b5c13436523c4603ac1d12 +85ab8b7a696333c82dd5e179e12b2e127e67d911de609ff9a03cab95cbeedb1f364aa1f2b5e59353e4ba0d177f996151 +a9478e214afa68c395aa2c7daf8ba1627feb71ad6d8bc7339734cdcdd5a42838e032736c28e6251c808d5a4875ef0d06 +8c53f62cf06a35321c8af3871ee4459768d0745ebf48942b9f464206309f42fc7b2c50f196ae1e43b664f0e2e718a23a +8ba80662f6642d8866e832ec8082a4204ebc993fc304c4b794666856de0407620131a18dc053597bb40a3de0bf8aca22 +8c8fac6b911785d1561a985580c03fb2ebc613ae33e486a92638aa7d4493374118d9a6d9d99121e29c68c3d67ee4e3f3 +90f2c793eee07ad90157040b30558bb3b0164e8ddf856389d6742cf5bd1c712e4c6a8e5678da70a8e9e242ec7864117e +954abed8f6d58896b7f6438c9780236c1c83b02d60a29fa7361559e619e5bc9d67b3646ee39ffafe2b3019bb3357fb50 +b79874f757a33085e1e751544de8fe3afbea92e0234f9c00254c2b36115a16ee46f085f22aa66e0c9177e5106f51b03b +aa148b287cf4f60c64f774282b421aae075f0eaa93a45aab4927750f47e2ef0b811d1846bbb15eeb2f293c80a7612e83 +a588d8825e7b0168d45499dcff6faf0dfe1ba4f090fdc7c06d50344960c0121f10ad109b0b9d13b06ef22de5a04eef87 +8f61ec93d14ebfa9c31731f9ef0fb8907505fedc79378e9a3f65c27bed4d74b41e129c97672ce5f567d897befbceec8c +a008218633f1da10efd01c155f7ed739faec902da6dc48e9f19ccbc8d32bb318d71806285cf2003de2c907bbdd4f8b22 +88ad82c66f7085632d7e348d69da84200c53594553acf5432b50dd1e87f410c802dfea91be3cf804e3117ce13103f23e +8498dba17de0318af227a3f9ed86df37a5c33f9a538be9823f8dce4efc3579e8296cb3b7200cee7c5e0bfd9da23a4b69 +b3c0342231dffe4c9bc7d9265597bc8cc4a82e2980ac6d1407108db5b00349dc91d5116fab51cf2802d58f05f653861d +b3f2730455f9bf5a058598bc60f47740117ba51f6a767e1134516a4e42338b513f377027acf8825da5c4d047a62984fd +816360914fbc9d8b865157bfab07aeb7b90bb5a7c5cd64847b1c3184a52266cd3f8f8f3ef99309ba2edc4622304bacc0 +8fd21b2315b44a52d60b39ebc45970a47b9495f42b88217ae057bebcd3ea0e2476c0c3d13de7f72016ae12ae966a008d +b62014485bc217a0fe892ef1aef0e59604ad5a868face7a93f77a70ba3d7413443fbe7a44552a784d8eae1acb1d1c52b +a905822507e431b35f56724f6c8d2e93b0607ed7a4533073a99cce2b7c1c35367382447073a53036dfdb0d04978ccf2a +81672e39c2b31845142963351de3d9cd04c67c806fdfe77467867463dbbd8a9b0e2400ccc55016e57cbedb02d83a0544 +90919c970ec668de8ec48a2a73bb75cb94f0f8380c79a7909fd8084df61ecd631476ddd474b27103c6817c8f3f260db9 +8fbe37dfb04bf1d3029f8070fd988fc5e4b585e61eab6a8b66caf0ffef979d3ed6a662cd99468ce98ec802e985da5fad +950939aabb90b57a3d667f9820880eb0c4fee5c27fe211ce8ecd34663c21b5543c810b3676111d079ac98644c75ee0ae +b06201ec3c3cfdaf864a66af128effee8ec42d25f1e173c1edf9207979fa52c871757000c591d71a9b6cde40f5001a06 +a79054e8febd0450c96ac7a5fd6bf419c4b17a5926f3bc23a8616f0cfbc2849d97470174cd1baa7c739b12615334b6b7 +81c7391b2a1844ed26a84f054b5f03865b442b7a8d614cd44805b5705fe6a356ac182b66a3c8d415132e389efac5f6b2 +825af1563d0fe53925ec9ac0df65d8211b333474e59359bf1bde8861eecd03f2ac74534d34b7e61031227c2fa7a74e1e +b60dd9bf036f1825295cd2014ef1f6d520cf729b4d6cee0b42cb871b60ae539b27c83aa3f96ee3d490ec27ce7e915115 +89ca43d5b7f3622b42df7887572297a7f52d5204d85e2e1ac6e5d7aa7f8aaea5e3a07280477d910db025d17cd2e7373b +b93a2bc9b1b597f0e514fde76ce5bfb6e61eee39cbf1971ea6db38c3ecb055e7913ec8cd07fb0b0ffae3ca345883101c +8d45546bc30266b20c6c59fc4339eb633155aa58f115a8f976d13789eaae20a95b064fedead247c46665cc13ba856663 +aa8eacfe00e8a4d9815de3f7619d9c420629ada6489933ca66a571bf6c044d08b391e0d9eec7d1cbebe8def1e7523f1e +b32fefc59a0d0319ccb1946b351ed70445d78d9fbb536fa710d3162b9659f10288f12d82b32ecc026d55f16cbad55441 +99c7c45c34044c056b24e8f57123ba5e2c2c039e9f038a66899362840cffe021733e078866a8708504cdc35816cb335d +80def162c134540d5ec071b25ccc3eef4efe158be453af41a310b7916c49ec0ce06bb43dfee96b6d77339e11587de448 +b5f2fa4f68f6a26bcb70d8eab62ad73509c08ee7aa622a14b3d16973ffff508ce6f1aff9ced77b8dcfef7319245cf2de +b4d0436019e779c789464716e1741c189e8945dab7f3072720bd9aa89882fa5b085a1755c48da21541f3cd70a41b0a71 +931e798ef672e1472f4f84c727a101e70d77b3a9f0c0803a5220958d6bbeb8aeeb56c769ab472a3d6451249a13a3f56e +918c10a84de268aa8f1ba24b38fe55ff907be07b1e86b4a4adbf305c0d705c1cf5f65ce99e03e11676cedc89f1a4f331 +8e55a8413b823715ccd92daee357cedd797e69a0e78b6fcdacb7318646b9903dfe05e5501f47b3c52e74055b9eb619a4 +8b329bb63e6c985d7d072dff4680b3f8b1217ed20543277386bd30ec25240d9dc378837dcd5cf4fd9548658635f4c537 +8c2be5386052b22986b33dbc63c5afacb6d0095495564ba4aa28fc8c880a3c78242fb083248d788ed928deb1e30a82c2 +83a2b7bdfcbd25d6b059f27218e009ecb5ecc4da68ead885e00216411d8222062ca42f21c4d9cfa19c31522080af677b +9620334d2633e85646b2e2fc48dc6c3f09c64ef1706ed78a3bb6ce1f6b274a727364df71e97531dfdcb392f70f27f536 +b6c84970ec04545121ec3b79376f4e45053c97e8bf2b11922cc2490a429c38735466097ecb81cc9d9692c74d2fb8abc8 +8e55d707dcf265c5ae29a32c27ce66f200fddb724faa5bbf145ef42280ef645fa2f0cc3cfe2db8599b26c83b91e077df +b910b96b763966402bbebd68a32c15a225ec21e1357fa298478c5981a4310e556103fef0c73bd8903e11c4ed2c065647 +a8fd933a0e9fe8c459809bd93b8ce153e2af55df94b61a1490736b19c89469954da8b72dbd072d798fc06fc3d7a3d60a +811b279c113828e114fd82c2070caa7eb089a46c8cabf865f9c77354a77ebebe0c4c6400dda0e66dd017cfc44d76851d +8ed03e91c331afb3ad6e42767e1b3e8d3a35fb831805ff1b5fd3e91878e04027ff5af1165a3ac295f1578faf2c83b581 +95bf53683d64a0621bf1ca6ee17446783f6c535b7a54d6ea57723487a215759a54f886597a55dfdd560424e368ab2759 +a9bea378768fb1d7ba365a16531c51fc1975f1c73caf2a0891da28509805fa84e2a8db7c6ccfbc620e9002317abf174c +b8308250891015deaf851c4e5a4cf4704d104f94064418488d7e3076d49f36240dcf6fdcf83f45fe8a1d97fb02e3db59 +adcda6b63da21f4074f142f8e7f3a2274f624c733e3a4001054a1809711529c61356aa087f73aed877a58ccb41d38d12 +b80e7869239ae26d1da2e6683f064d1dc93cf4a2b66e9439b3ad9b25324e969bf98014760d29e6b8de7ff152ef498d0f +8e9bf968911df3bb5e3a7655e9d8143e91ee87f14464d7ba9c86e1e31b03ab31b91eda121281b79cd974d9ed2657e33e +9007277e8335a43e6bc3c2f5f98c0ba7024a679b7156aeefe964f1a962e5ac82154ac39d1ffbad85a8f2440f3c1e354b +9422b9d670e997b7c919a429499f38e863c69c6a4d2bb28d85e36ae0895c620f68b71e39eba785e3d39a45be91507757 +926094e01132938000d82dd9a571fef5ef104cd25b4015a25e3442af0329e585aaad5472f0e7a69899ba2d6f734b40aa +95552d8057f7e32c24d69e4d6c51c98403f198a20c5be8826254d19cab2f84d5758e2220cea7e38b7c8a7a23178fd564 +8abcf8dcc8488bcc9ab23c51b9e7a0d91dfc7bebe88b7ed370ee68eceba643e939c5eae66a4aa5fe85120751780e351c +a91bf8198f029e6a4cf6f0cc39b629e9aeff1c77b8739e1d5c73d8c1d3fb5c8f6f23e27b435bf10b5b4ec1cf6a7249ed +b932d87ee3a4b81341511f90fe5aa36c571e8b914f25abcc33dd40ca67a3f6444fe9362c1434744e4af18d6e045c54a3 +a8e960c2be9b1d805d387b3ebe2134d421a65f1fd4c1b4cccdce78f9926f139eea78e3afb449b3d6dd19b5d16ace48fe +a7e2f57cce509fe66707eaba9b4c042c1be93fd6034a9b51d1d30c45c4363eac79d54663d525c9873ab0eec0b1cc4ed3 +aa162a31c2078f4b080199debf24494a8dfdfb9d8fc85b198a861b12a629c73128c55a883e4c2de3dfed6e0e1b83eeab +b5a4d075433eaf4115717a84b4dc37f843d44bba0bf820c92ecdedd5afb61be60f7708c8a151a678d9d5c0ae531bffb7 +b56ab96f7a463c0079e05dc766f3a6a31cae5c5044947734ebe0a26e01367c6763cc8de6c2ee2f3b8218f05bef217474 +b60792ac506b901065a8bc0180a86e028fe34b62ceae1ad640c759538ebf3a2ad9c8c927d662deed6f489ff3ff7813c4 +8c8c2cdf075504d12d441a58542e1f8e4bdf92b3ee4775e836b2734c5ec1e3df919b931386417d04489a1dca806c87d2 +8ed78e91e5c4a68894cefc2f7fa71f02e5e12d40f1bb74332139bc7be4d92c24e07d5ece0e82150ed474aa1337af4c18 +87119c22ff8aa31150bde537d863cad661cc5159b12f084cc319224c533f0deb28526ed8568d00a1441e7d8bb4f05673 +83a60ba5a9cccf22cebadf7318b706c9f29abd25db0e2fc1c802965351b53cbf316df72ee3e9b2d3ae7f3c4494cfdff1 +b73b6a9fdd3e7463fbdaabc9a885b7c82201ad867d1bced1c2484300a01cbbb3f1e21afa95d4c7cbb6cb983416b63b90 +b1d89ad16981ff9217708090d4017662d8838f21f3a3296cffe14590b533905fa06a20e40dd497bd291fa4dfd1bfc511 +8abde560083e071a402e3c7bf31930f537f67d2a7bbc734a7480b1b760aa712ebd1cbcb65b00e11e384e980222fe14a9 +89c731d8f31afea8bdc9c32527bdca257f2a840764d40f6e49403b8e75ae51017d505ea4fff91bf28b6f3a1bc65b8bbc +80e9ac8e077e86ad050ee73dfce268a69564ff1b8419e9c236d981fe7a5f0c2bc756e8603ec604b3b9e36da8fe10a49c +b4f1eea0f304898b1323c6382732e6f40e556bfc68af9ce73f6d54e92f5f23cc4f78eb3f43d578d81e7627fb40f092b3 +a0e3a8d1348f8f153e08ac4839232d75d1d6e81b5de184ec4724f8213baf98d3fe739a96f6b39d79a053b628c3a09981 +a6915ba0b52ffe4a381bbb8ff3791d9d3b848bf89b3bacbb2a7d2e5ae21f1353cdc304b3cb6e82416f7e604035c27d7e +b2c4c9cdfdd2fc9a340ba3ade9423344b9f429e8c7e20a8abbf26400376e312f3ae35d1c456be99dfb5c02fc8a36cbfa +9657d57ca0641825a0aa5687f3f87659d893f33aee819bafa5b1ca1db554811c1c844f971e278606e3a2f096defdc67c +a4ad24d0a557704ada24d8e27a15604bca28679e260b2c69ccc8e6cae5499866724b700605a90df7dfb35130756939b9 +b18d9ea6682f73a1f99a9a4fc98c38fcda02c1a18e8c5fc080cf935a2ac877dc5223fca273dcde190b906178d0fd05bc +8ea5fefad0799c885f50ff10d94bd0af5b99b0a446cd1f367ae5ff529cc47e09f3018115f3c0ccac2fa05bb65b84945e +92450d52e6c7d13ebfcdf5674d6761bbae2fc5aabc865d35d031b588c383e0a64cf69a73dc93948632e2b98f74a5ed86 +a356f171a98df4ec5a96d556eaccc6ad34b4238aafcf0e94ece27cdbb491749fc9692e78b84dfe80bdef2914079d34b5 +b918703a4d3507d266414712ba8eb7ad17da07cc5f952b5c62ef130cc6ed1ae3bf01237fc8848c179725bdddd465b301 +ad2b0554570bfc9d97510cf59bc38e10ca54a93649c30ac9919bd0255e43bf525ab11b74f78a51ac0973cd0c5a5dcb54 +a7ecaf4b631d179d32ac1632390d95196a0035e00da6c0e6e13b5c09ae44b15ae6c21538b5a31b73bc5f650ecd979b59 +a37704eb4d728df2a367e59fcb6c26023136230e37f3b8a2f3ceeb1467f5cd30186fc0116f98b64a8146fd2c5903e8d9 +b09373ce92314678299ae10ec1f93c702911beb4115c6b5ba6efbcab9c7afb599f59793912df70a98868bce6545a33dd +b52a878a1393094fd2b93f2d1eccabf2830ab10800ba4cc24dcc7849cd0978733263aef2fcb766a7cb575a7a99383db8 +8dac097e006fda4fb9d6d7ae52adabd9448ebc8d5bd5b38ac0c4ed38ceb510763174f7adfb0b473c38e52147ccab4239 +86b19c41efb949937d74a7875549ee5e997f9fdac7f7198085afda233cf74341a38d0ca3767c76cd35f875b89a35f78c +99f0d927e5ad25cd134f1c70b72631cc6b5cb4ddb86c0642b900464e33d971213a5239dddaf71f7a42f2d6d02a12dcc6 +8355c38806c335d747d4e97f0083fb96585677da18b409a85175ec35dc3f74671817b34203eb18c2f729717ce083ede8 +abb3603adb061a036eae0afa5f23d79c3b62442e0e3bcdeef896f88995585c1105cd3065410368456a4d36b5b0485a83 +9051c5c0011784885187d04749f774b9b4f6bc594b0e4e18226de79dedc4d7aefa3529c3d2c728e180f96f3e204d578b +91888213e7d321d0bfac884edbd5cb756b280753bb5f8bc6acfc208f525757beca24bdf86fc68d3d8736ef176a960b49 +91258bd7ce6e3b7516fe2f5391a368d826da299e0e99b1f82eaa44b62b110ab696adc92debab8ba098a52f38dfb3c5d8 +96e3907340dffa9da3602d3b94bacff7e1bb8649edd3b9bbd06e1bc6781e78f91ababab12c0b9be7c66dfedc7001b66e +9513555688fcfb12ba63952ab36a67b36affdd71f7b843e8eb99ccbd45421698024608233efbdc905eaeb26b334b33af +9913ca9bcf11eeb408da02e4317c5ca0010fb2f4490b282ddb758001c08b438c3b35351a8cbe10b7fffc1293ccd22d4b +85dc2471860ebca88e5a2766161fdd77f926d2a34825d1134a30418f91a741759668e32fd1e37c415d07ab5824338e8a +8b128917e828a0b5eb6fa8ed72b52fae2dfaf74febee69a2e2f87e8df702f0c5bc0fb620c8d1d2a07f35a15ec9c0f5a8 +964c39e7840c130b01bb481ae7bfc92682b0f124c9c383f9dbf3027f2249151925f4faf36905af476a54778d69da3f48 +80671ece658cf850e522d46d25678f934ce6df043f25f8707235125765d40c2eaaf39eda6092f75039b22cb58bf2c29d +ad4bb0e79fdaa340b1347a46b0f64e801c72a89770dda0a6e4bfd35f2df5146fce9934e4baecb1c2671077c771eb8089 +80b3bd3adc6cf198fcd997f8867d2839a2eb28f57390352ec423b8a14cc1f2ab21c6e286505d6a21fb134dcd8d8f11cf +a26d46a6b8a75748895a1d599e7fd120d896340e79813167a400b2fe463452532a4cab419074663fe1d29fa716b76a33 +82b1f3a8a1df29207d7ff020809113ab06080a7f0c631f76ad33f47cdfb6a567143144df97b4ed7f676d929195b04bba +ad96633a3744648ff0a2e4491e8219c9c6ba6e655cb058c36320a8f72cd5f72c00bddf97083d07650ea9ddc005fc1ff4 +91d0783788626c91662359dc3ff36a8bcc6831e3f4114f85c99910256b1d8f88a8612f53c7c417d55581dea486f38926 +84edd9e87ff3d193ebb25f43474c33fe502a1e2100fd3f93fda6520f5e42214cc12e9f8045f99aa2423a0ee35e671854 +b55e06a4b1fc3ff9a5520e0b7c8b5ac11b28385cce78d91ce93b82f1bd7f7afdd4195d0c13a76e80d0ed5a4f12325fa7 +b0b15c7ddede2b81d9c835ecaa887650622e75d0d85f81b8bbec7ef24e9a31a9c9e3de1f382d8c76d878d1b01373f6c8 +b1adb47c20f29784116b80f3670182d01b17612d5d91bd6502b0dcecdcf072541f582aafc5e7dd9a765cad52151684f4 +8efd1018df9c9e9814a9c48f68c168551b999914a6719229f0c5bf0f20a288a2f5ba4a48ba966c5bffb0fbd346a4fcc6 +b34ea2bd3269a4ddb2fbf2514401d2712fc46c22642f3557e3b9c7acbce9b454dcf789573ede9aa14f39605fdd03f8c4 +a9e1428ce24eacfc460aec2e787c053327ba612f50d93510d58b2cb0f13291ca3d16358325ab3e86693fe686e4f526f7 +91eac7361af4c66f725c153da665a3c55aca9ae73ead84ca2662cf736fe6a348a301be1954723206dda4a2120202954b +a6f02db89739c686407825fa7e84000ceedb9bd943e8a0908fef6f0d35dbc33c336072ba65e33e15ecfcd5714d01c2f0 +a25666faa12e843a80365c0fef7d328a480c6e3cb7f224763c11d8cbabd0e7e91a5b647585ee905cc036afca14842bae +b4348576439cd2e48c01cb9cded7cc4a0ea364ab936dd679ddc7d58b48807e7fab070f2f1ea88595b11af4500849026a +a8c6c731e0d0464ef7e4fc1b049065eb4ce100c01e1a376365c636a0b23851022bf55805963bc15eb57434a837e81167 +b0952937b154e3a4c206f96cd96c76ba37624956b0e4d43470bdd97b4af878326b589e3eaee82fc192437123096799a2 +97d07ec31ecc9923192e48d37df2cf08750050fb452dcfbdb350fbc43e146bae3590c5b732b31ebfa1ce5d884ad5ad57 +a69359aebbfe4cbc4d39d178150039fbf284cbc0edc68a6bd635ee3a1c76569a4a575c907fff691b2a4d82a384c2945f +b321c2c0f6b5902ee9056cce7404d858da9a573d27348c1a6bfea29b2746f2aee7abcb6192504e5a583b0caeaba117d7 +a74e738aa6eb4eea58855ae6f422af22812fb388c83aacca5bd5fa4a88d4c01463174a229aea2830c348dd9ab9307854 +94306a3b106bc1644346bc45c05cdc8287811d5c86cad691bde0c65d6a686eb9c0ce79ad91baa4547e5d058ae8bf7310 +b64140fd77a07633e4ca8d60786452311dcdb8ce7095ba51dad8486f57c3bf4e69bced92603f71da992a48ad817ab275 +affe7f4310f1dc68e5e3cd640bedf864f51bfb46bb752063bfc18e95930021f784e509261ff9c560f53000c361b142d1 +b0d2fee222c6f963ba3385547f921a48964da031d737892604f8f2677d4905dbf615046db57eae6c6dd756709ae6932a +81700c66aad7c2e51168e028b0fe086dea75d3b17d93a4dc1f47a6a0f025df0bae1c8c997901837ad859a84197e7bb00 +aa4ac5fdd602f8b79cace18690e67bad557a93d00c0e295074185e8c6b4059a65495d9971685de2fc01d2171ac8b706a +a8becb3a64fdf35d65d2857898dcf8053b5057a73ab8c5bb5324af1a8015cff47efb85dc3eae7364cd5c850b7962bedf +b72ea09bd0b72f8cde3466f359ea69b194ede93dced534efba1b9ebc6f3bd53942fe2965e992e82edb6050cac4ed88dd +85bb8dd7eef023a251fb6f220af54687747f4c91983ff728163c4618ffac40ee6edc29a0aa6d455276bbe017f63757c2 +85a485254a11b4c4a943d9ec509c0dd1cbfc0ff5273a00cf5c9f0babec973efb15348e5d9451b548293d778e3a2b62a5 +b109f3ac809391e772b589c196b013db69a9b2b10ac3898feb70b986973731f30722b573cd0c9324158ec20416825385 +8a4eb579a840d438bed008644f373ea9ba2f28470d50cf1d70af38ba0e17326c948527b1719dd1bd9ac656ebd5aedd10 +a52e9d66ead5ee1e02ce6108e4ded790d8ec83164a0fa275ab1f89a32200726c8e988d66df131df9e62dd80203c13dce +b541cee9febf15d252475507e11d65c4b7819c26cf6d90352f5e8a8f5c63e254eddf22df0c35a7be5b244233e8e4ee5e +8153c297772adf4603c39349142f98cc15baeccaeae10c3230ee87d62255f6814d88d6ed208c368d2c02332426589748 +970dc9782f1828474e9fab7dcdec19aa106725465a5844caed948eef5c9e48199c1b6bc1a637ed7864116927e84bc65a +a975a920624967f4ecc77ea5d9869c434caa64c330024194615a8d0640c5d4d4fb139ea11a0c73a5c6ae6dd3fbf0ab5d +811f0f9e0c12acfb4b9dca359eaef3bed18083bad96188befc036ad3143b121fff4777ca6dc70a835bbc4921bd25f5ff +82341c6ebdb97c8b72910da95c7eebccd1308b6a92999886aab552f0642882d5c7cc60931577d200efd6066530c998dd +860f7162c2f5fd1c0953c6ce75bd8c52eaa48032b914410681b8cc05e00b64130d1f96ec5a52df66a04c78a9f9f42981 +8a578e674875571fe1a0459843495a5ee1d9fb6cd684b244feb9488f999a46f43363938cd0542879ea18ed14fba10a6e +8df217aba4da6781f0f5139aced472025523ed6e17e504511c04b677ca8197488e237d8bb5dff7b6b3898cd5a6393dd5 +b2c9230ad35d7b471d3aee6f771517cf3145ad26200bd6fe9c7cf28120e2945fed402e212d2330a692f97bb9ac4dcf12 +b78b89e29e8b782603b222cc8724eeb83b2d9d56bc02f59a3c899ab76429dc721358b07dcdaf422f59520b7e7ab4fb55 +82682a5617843c4ac8d4efb4c3ce715c76c1da2c3bab1ede387db503f3489c1bfdfc07d9231d96f955df84fd225bc81b +b0f53725cc610e78b8e8a4e6823a2ffe44dd15a9a5bc8151ab7a3787ddd97e1d7f2f0e6efd2876e5f96417157143e3bf +92c5a93233085e2b244519078770c7192af62f3562113abc8902f9d72591eacf52bd15ce78653ab9170d5067606287f8 +a43ef97dcd9b6ad288846bf31fccf78df72f94bc7ad768baf5bf0d5dfa27bd74ffcc6b6c6ed1d1f09e09be3afa5eaedf +817d43bd684a261fb30f709f7926cc4e1a31fd3a1a5e7e53ba4d664856827b340d7867e23d55617ab3514c8a26a7040d +a599e22d3286b32fafaaf79bd5b0c5b72f6bf266ec68948478f055391336d756b58f9afea0167b961fd94234989f0f02 +b70db7d8e8356df2e2070f8d658e560081442f3f3b95e20f4bf30106835d76161101163659d5d12cc0f335fb042dc66e +b8f725b70c957aa3cd6b4bef0d9647393f7c9e0b7343e92439372f0e9aa3ceddd0cb9c30be331742b87c53f2eb030593 +b2fb5e7762f26036e7e966f4454f886758804d1f4c2da17f3d13b0b67ca337f1fd89fd3cc798b07da6e05e8582c9537b +a377f944dccc300921e238ed67989872338137fe57f04cb5a913c787842e08b8a1adcfb4d2200abdc911fc1c766a7092 +b82e98a606071c2a33f2ad44e7ace6d9471d5434500de8307b5d4e0083e3a5cbc67f0609ca8055f0ea0ee7501b9ed916 +8e58f9a04d33a41ace4944615041662dc35057e645f63e127cf0d70f96ac307d33a62ce98f164d6eed8536c1a747dcbe +b5b11388071ffbf57ac47fc195736613b964ebb91cc8e2c17b32646f91d64ea506282b881897fca96c317364d3290de2 +a40ee9b7551133856cfb3904837f9949a9558e59a418898affb78adf1500fd6ef6328fc4422161909aea2c79ad08c14b +81f9eb4ef28aacdb43e11dfc9aa92ba990be4d3c14b484fa677edad3a3fbfeaa859a7f9322b5e95818240d7326215abf +84939b2b6bc859437d1a7a8d6ec9a357c6b716c4b4cc22abc274af872655940cfc72c99f5d0283d90e05191fcdb1c232 +b78a5b74a90a805410b6225fb9576d6d73752520f25cc3fd1edf8ea9f6559d3080f9acaa2246809b6a66879cd2ae446b +8d0a92baa88bf38dce5385ccf15d345b28e2e5d0a2d469e689353d80eaed8e8408933816d70ad752f226c59a0d5b5f0c +a7e15f8a8c1655b7b346c9488cff278c793505379b781b31b273b4bf09b3bdfca1c8ab2334746075d636b2e05859f215 +b70daf14f2adce03c7b92d6aa181f0c507a80a37493d8dd12419d5ed5f943a98099fefb46ac827d6e4efb9b8233c99d6 +8c2480814661744d116fba7355bc6b1914975e44cf0e976d50b6a20092bb1c636b7b44ed3fe8d63b5555ffc89fa759d6 +a6059528a4fed36abb74ab992b22a4f9bf1d05c5de2bfe6837b9af1adfed98bc37ed7481b5a99675d432743021fcfdb3 +b7e19f1b25bc159e5a769811e773c3a8ffe8be8ac77ed0b711540915e5c6e7bafdb407cf9b85c551f67fd621ce8142a5 +a2f66d4f7d16ed3e7ef5fc90b42676c61a98ff18bd26ccce91de03b6a0130c1db17a6bc57be135e410a76d2255b15813 +a139c916927dc3d3fb83598da9217ca64f0ae127215332e9a7ed82be923b89a801c44580d5617297175f9dafb1c4eaf3 +af08e1e1b04ec95366a12d99c80a9a9ac40ac984a575dd0230cdf4eb346a7686da55ef0a276f3356f814af31f9cbf1aa +98840aefe287369221c0721cd7c1b15b1d670c3cbbfda191cdb5434bcad757e59c30ec82b2d8c75947405888d44da435 +b7c61c8d42daf2e278a12d8f6eed76090b71c82275f8b33504aba75d95103840e8acd083e97a5a5aa79897876a68940d +a0264048d2a2061d32eee4f661957ff351e78436bf49ef973c059612874ce9c91970869d011dc13a5b7c754476880a68 +897199a4d8db8aa2db5d9be3d4f4312e41fa0739eb06c62e2e046c4b9be829a447e5d47227e2d96195d3b7b66eb59da6 +b512a9082881f5dc90b02f8bc4f38b133348c2e933813852f6a8e7d8c270c9ce68a5524af7d1d3123e53b2d02a53d465 +80b332469254a96f53c95ec79bb5a8bb1c387d40e58b73d72f84384c696ba0d3c81d6ac90be2979c364c44294e90432e +ab680c2e547ea5cbf95bf813020beb461d50ee4341dea944eb48f6a8584d35682d20186e3b190b849a1ba25625a7f499 +9070581993a0531d6be372d370c2e4ab2ee53f30e04a75ae61ea0fc2c320914506c4d2d4b4487c1f8fa88356fc45c895 +8424303dad6b4051ab633ad27ee51783b2ead61c5a6dae1eb3ed72fc1f36e2a9b1f315504a4bd90f9664091f2f403d4c +82225611eee626556553b9316dab4043aff241a81826a33aebd9864a91e299b765ba1fb43eea2c2047e6b75b6d7fe3de +8a3fb221c616ad55c352dd5e0c09ee892022013d6965aef40d4f277a42e9fa01226fe973cb99aaf6ffe4f4f348fb54d1 +b07c07679aa51713e8a7d7bc304dc15ed5664b66bd371877023f3b110b3927e09e259ef22895c4001421a69c6c013cc6 +83556c76bdac0dd8db6da231b863c335be076e7299802eebc259e0818c369f933a4a4b18e2df8ca07e82f60767b462e0 +a516f659b7915d2f7cd0f0f5ea2491b15f0c84dcb191e7671b28adf7cf14a56d42cfc0da94b3c269b45c535f6eeded49 +80d7cc6f26066f753041b17ff1bd27f6d4b5603a43729d33d596e21a67356db84ca9710158089def425f6afaf3207f9e +b802a47f9009dbd48851209ea1e2739020e717f0ae80671d9f97a0e43de923273f66b7fcc136a064c8467372a5b02d28 +ac92fec1864a8a911633f377df87aab56713876316d48240fefeee49ab97f7406c22e70f4938b5912c5c4e766146b7a5 +89224225b9835d04428b0a74edbff53dee2be285ddd1e5a3a8c37307c0500578155f0c4052e4bc8be04c56862fac099d +b1d3c8492fbf22ea60732745edd3b0163ba5a20d1a3315e3773f2540ee38cf308d42ec72cbb3e3dcea457d1d132c3904 +8bd00e38ec30ee6c44a0e5b222f1f737c9ed2a4bb9225f1741d6334df966318c8a0fd2fbb109557fe8c9479694b8d8dc +a930ce5454efc0b247dc148aff869963fc5c240241d5590415cbd36634801a04d3873d93635911bb9c0c42ecb005cc63 +b83d4f80e9e0fa47b42175df74935ba8aad2e559b80e84478ab1685bc3eb65d51b93e5738d5ca968cc055ca0c552a03c +b3ae21258f98051f13af3878b8103bc541fe6f20b1c3f8fb4689ddb8800b3c25cca9b55f0a4104bdf15dc4d5844abb8c +831ef8684c1cd446c58c59d0152aeade5cc305bca6aa296b92162615f052ba280fe289edd62fda6d9f0667c186445f52 +97bf9659b14f133885916733b7d4ac7e215495953caba970fa259f7bf6b79e661090ec8d79e1c9ce8dfb17e8552f93af +84d5a89cc2332baaaf3d19627a65f4b107f8dd9228a1434b327732f59883bb54fb8ce60d6acd026ed4b0e94e545d1c33 +8e66cb743f95ca5486400b0d89d02e20b98044be1e3a12983ff9fe086179e5a0ebf4dcd5098703191552e9aa660a6de5 +87b4cfb35bacec805f8148786788db84eb8f4bcecdd0570ecb592c705450ce1a90b6d183d37ef58780ede3995be67497 +a72a4fece5478011973afa543f6d8a8ea06a64b241cf7d8bd81fa3740ac2a4cf10e5120abcc1c1101f94da89507a40ca +89dc6001a96adcd2679916f43dd19ea00508c8d5dd6b0090eab7982fd2f3571b62f3029588a0649e73f49124525407ea +8ca75edf1259599e873530eff6151c822a4018e71a340534219ef8641cb6683215891df41d4e3c0ca2560e57a7aa913e +9282d32f868e5ee6f7fc229dda5b94b603476de30cec0a44a30edf396b52dc0ebd472b8f726d4b67d76179fecc1666a1 +afa24704223707db89690bcf9761f07a093f6009ca9fc945e0a8801fc29f9f51292bf95243e466fe736088af36c55ca6 +b51332508ddd9a2610edd2b0ad120272ca342e96c28baae37a2c4f07e689303a46c237712d07e446b1d67c75aa8ce32f +9219249f3799dfa4eb4770ee323f821e559e7406bb11b1f1889286221b22c8b40ccacbd9ac50ea3fa9ed754860bc24f0 +993515270c128ede64fe6f06755259105d0ec74947b7eb05924a375fa5c6d14822f3d7d41dd04fa5df8aa2aa205a1dec +a83be4c2511bae430034ab15b194ac719d7b7041f9c0e321317f513a97db39e97b9ee1df92a1962f265b7a3e98cdd753 +8ac7feaecd26f7b99fda3ed0b8a08bd6dd33ed5ba687c913ec0ffc64bbbefcda6f265072add4d944f2005634601ce68b +b4e3ac6b09299db9e1a469f3a0b2d8d724ee47a417a517bebc4c2ac3efc5cde086b57b9aa4efccdef2bcf8f456d973f6 +9262a24a84fb7b2a84d700f98dcf3fefab8b47293778c20bfc356860cb84e0bf102bae9facd9986d92d1762e0a955836 +97be2041c42bd25e5eb519279163b0857f8bef627492c27b1182f8bf0033769246be5886422cbd2409c08a2615352465 +b0b87d059a00e3effa2e5e4925da913b245785f2932ac3ed364ad19a064d3561b8aa6afea22c951316074f0df179af36 +891644b7b3321b06a2a40cd96c2b8b29d81cde5b48546483fdda439000982a9cbf1f6333fb6c089d39da6492cdfaefe9 +8da9149b7f4783a24240b7b9c7e6df4abf8d699d3834e31ee591489bf4744141ab199c173db64397c1f9bd5f9c862ca1 +8ad7f9fb2742654aa2964fd468e7645436cefd1308b064fd63fdf0d3adb4caf6cfe5426354f6cc284f208b03d6b2d918 +8435e4668f7aeb027100d21e4e0b6ee22b401d21966a3736b95610de86c7e2f2c9ee5d0f901353675eee5ff458dad69e +9010895f045538bd11b47bb8996f27198c8d6cffd3220569e6b7407f68f35c47d1efdbcecbf9b5e241c3c2879a4f6936 +92a9aa443b5ee7bf13b6f43f2d8d8db7f6f33fd4073a606ec5772421a55f464831419726130dd97829a7d4bfeb1ab078 +843f3266560be6dcbe0258c3c7d7e332330e10630c069892954290288eda301e247f479505a8a1bf7e59c99ccafd104f +915bd1dad808f8a568725bd243f80b5476a2999d0ef60ea3ef6e754155bc4121b2b879d01570725b510c5a3f09cd83ef +97250d781815b1825be192714884630e9f564b9bd737d55b8ac79ab48d0fb3ca53bd21ead7b2fa82a05f24083f25645d +81e2d52333391ff2faab39611689a62d6ead77039e8703f4e012d53eea17a4d46f2e3342e44b6edbe73a542b461bda45 +89c9f9fd5f638156b018831c1bb70c91215f4a2f5a73c84b1208bdf6ad652a55df7213336ce12bd910a0e1a726474f95 +92bd02984d090ea7e2f3eb7d36d1e7b9d731b6b047e3cdd4af7cc4ee177415fea7a145205e484b366d84191f06af85c9 +85a86fc61d5d916ccbb219db52953e1495230aaaca63237e9165276405f07ad9644e253ae394f1ccdd231944e7143313 +a2ca5b3fbc9f3530f88c0ed7071ec3d89b272174c366eedb5d15d2b648c65d23c0faa4e92c776357e7c6883a0084d03c +ad171f5badcc99c8ffc9d8b707d792046f86cd0aa478e0e2fbb32fe095f96cd134ca548d1f7713057694dc6b26465315 +96bd15d57da9980870fbadc98c68db76824407dff2700c45b859bb70d98374d4a4ba99e3ed0b0c17f480fe08f16c6b8a +8300bac69ca088c3ff35749b437215e9e35a16393e9dc094f520516ba57a485def7029d30adfc72bca36eeb285c19301 +8a09e20be64f346668fcc7b07fee9c0ea8094c935cbf4f3a4cdbb613d4b936c1edb9256b7c884efb72393d97c0da00e1 +b1f85827ee6f041f93ab174d847a55710824fa131c9ade9561168c3962a25c617475ebc4105eba6e738961a754442bc8 +a131558f92e215969f41b6a57d1e2f424149eea531723821dd4cf8c54325cbe66b002de2c8287de6b41ab4b5c35f060a +81ba492b8956f73557f361a856c6c884ebb300d828287d5699e22e0cfa75c8e77a61616551d0be5178263898c461d6f7 +b2608f44d3c22fac8e13cb59e4ade8b9a98c4eb1ec0959ea400c97eb937ae3f66837e91917057148befade8389af2f6a +a6ff0323b5a18a4becb2cc6b376086b47cb2baffbfd1b0f2229ef2286fb4a34c5cd83a5faed5def7bbad519fcab8a856 +857d879cb9eff22501d883071382832730704bfcc5cd5b07cdce7ab8dc41c565a1eb0e7e4befce8e0e03a4975d3f11ef +a2879a20c0360c516811c490289be7dfbf7dbd41d2f172c9239f99e3d091957e0446854f9d0f753d90384a80feb6fa56 +83518624f33f19f87096a47d7b8e5f2d019b927e935a9021823fac6564c4f2328dcb172e25bb052748191e75ac682bd0 +817ec79132faa4e2950665712b2c503d7fb542aa57b7b36e324f77cda79f8b77bde12314e2df65c5b5296a6bca9bb0b4 +b2abf8fb7c3690816fa133d5b4aa509cd5a6e3257cfeb7513d1408b12371c4d58c44d123ac07360be0d0dd378e5bcf99 +a9fe1e4fb1574c1affac5560939face1af6657f5d6abce08d32fc9d98ef03186dbb2dbb9fd1decd6d8f4e4687afecce9 +89b2f41e51f33c3ca3e44b692e8a6681eb42a7f90b81c9e0a0bc538341df9e2039ee61f26d2ebe9e68df5ed1bccf8cdf +8b35aa7b1d9e2135b35a1d801f6c9f47c08a80e48603f3850b425f64e7fb9860d1adda04f92a1ba22d00dd0a26e781ca +960574978cadedbd4cd9f764bee92f94e08b7af65403de36b21bffc9424bcee845b3b028af2e9e545dd77cf1e69a6a7d +840aa0f34b5b6c39471f54d9e85f1eb946468c4fc01963a9027cd7864df01f73c2e864f1f07aeed4b1b1af72808dfa07 +834464a84a11200e3c60f816044c254a7d9baed64aed45a17325cef7fd62338e0a26da78d199d30ac3411714dc813223 +b4ac6fe2f5059546f4ad9a361426ead33237b6b9030b129bf0122085c85fe4ccb33cf90f5a7f23c5b708a5ac64b487f6 +a12aa9035464795f2a67f3eaba478d5ebc838ed9e997c7dfa241e1ed60a94b367d3f969ccf0ef02028c35215698b309f +ac8d926492ec2bb68c6d8aa9bce49085d3d266f3d5f1f924032b87c42b44e41da7c047eeb01e4618f9d0f123dcaa537d +a5142425825d813ed8ce1849d81aa40b11f1cc3daa89a9f798dd83065c74820b4da6122b3308f528b074531df66e1a5e +87ff55c9f5aae079e7bf24084dd9c6b3bc260727d942d79cbe8dc13341d98525b4ece3ed8169994b56a387642f09134a +88e680f148ef2ecdcfed33b61f9e0224790fddc9069bd6999e9bede1791e761637c0fd60b52990b6c93e6e5429e483ce +94bc20bf5aac6e9f1060d02eacd06c42aeac9a1c5635b15a83985dfb03938ddb4999a822e865635201489c7f75601b29 +849221cab7599f25f0b114df092bd5e8c2430503ae959bef1543a101de0790a78245db6a145e26f40b5f9bcf533219a3 +88b6f2c2e7a7954fad11009d839ce50780921f80292320868d481e38d26aecd80fa607e82219a99532d88cf33b39f562 +b0d82947dc23c0b88b86c321b582c15decdb825ed909a731b42d46bc895009515a3dc646c98dbec7d71b0722df82392e +a2cfb9f7c1a76c8073363c1c3bebe5dc29fa76533caea41046c51ea9bbdc693a121b957cd96be5b6da18704d1865cff7 +8f0ffab9a83355a22683a9d998d1c1089449eb308711eaad4265f05927ec6d0d1ca39217082a0b372e02234e78dbaaad +ab024661e2b2937ad374c8cf2e3669f1dc55558a3a881e9ec4d461f27e0fa92e2bc88230f038bfb051cf2145ca747a07 +b98d9b9ec9eefa56d38cca959ce1aee7b6d4b41a8dbbd34b3f50c0a5f97f84ed2502ded1ce8cdb5895872360d4ba6d61 +851244158b3184a62d2c98d148e2b1102cf0d5500906bbc2deda95acc5e3bc4b4a3344febbb31ce05a56dfee86a74913 +860d9e2cb886bd3620b5d7499d14b415532482569bd45fd76e3e8052d78a73ae4b2b41f139f9cfb136564108cd93c0f3 +8305a052a0fb2bcd41f3aca075c5f7f233bd8f861451d03f3a6e6e31f7d08dd89fe1eb4dd7b238a78b12ddceaad9768c +adb703e4778c7e14fb83541ab00b5fc344108243ec6827c5d9b302ee68321aa569da1718424e6a57979ab7536d5eb43b +b1a754b87b9e21aeb86217ec5b4fadb7535344567f1bd15e88ec12a833fed68e26bfbe03b7709ce24ba6c925ea0a0e07 +8c1e2f6bf820e1653f3b8213e9d959d8649196223c2aab57b7ebda094f4919f88d883bcc6a0cd0be335f26f5a2a9c962 +a082deb9865fe8668e91db0e4fd7fb50fb3fdae3e7bf1217ce0aa6f286a624624cf936d762bb2b6c3fead6826694f846 +a10540ca05fbcccdd0a2a66aabab3b36e9bb525794cbae68bc3dace6116f58942218e9d5e9af10d67b5f6fb6c774fdd4 +b81d22c4ab0ccaf447cc5fc2ff3bd21746617e6773bf43257c0d80331be2e8437b88c9c45309ee46402b38d3d4911caf +84c7c6e924713cab3b149f641dabf63ad5abbc17c1d8ee7802a6630507aa1137f7e034ba1d12ec13f1e31efbab79bf13 +8773b9d236e5fcfa8c32e471b555264692006bf9a869a3c327aed33da22dfbf5780ecea7158904d4d6ac4acfe9789388 +a4c2c1bb7290eb7af2013f7dde78282148593f066b09faf42e61a3fcf81297caa5a00fdbf6b93609c8c5782a0f25341a +a7bfa6e3f273da3dcfac7cb9906bbe9fa4fc2872b184d79813ee273e6cc4d7f37f46164362707a1976f5b6a2c5d7ed1a +8b71502019e4263fcda354a0fd10aaa7da47f4abb7a0c715c7b017e9eea14f2b64009b29b467394668c7ca995adedf82 +ad7460fba7deccc3f9a7d204233de47ce30ffa55e1e164975cdf06480a6108720bc397b93ca8c959df77d44a1e1f05f4 +a5b8df96ccb7b078a3918e74b1b10da21df982538d2c9313f5129b2797c8a6db9ff8707241ff72d3e9d5983397321736 +aa6cfa6386660c01879656da6c4e72497690708bae6c5cd1d088f443cb5bbbe75561d6eec256a72b9728377eb83ef973 +b9699ce7c5c878e44114ab7a598646c6c7616b8e08a9ef8ec291189ef9945c1a538d2abf1ce3b0da0f8eecb303b81b43 +b8d0fd1d278f53c455de92ec4357885fc6648dc5f276930263da7dc885b4a9628a2113e28b66b1e64fd08189427c614f +84ad8d262f6ef5d93e82ff6f4af995148eedf6d8e079124daee9b99f506e2968922eac2c7d4aea741fceb7733f20b2d2 +ab5e30ab54641e3a44450118b8235554e0fcfffdfbe1430ceb3f7ef33325725741995fbbbb0c16f0875aef0f1e0c98ec +80e2cf8bf386ebda46045852751611f2af80eca2e910d9ec5f6e2c7376611534604ceafa639272b3d503b02bd66525a6 +aaac69af8fbb87da1c1b7c1b9e59942887ae839a91f0c1d191c40fe8163d7f1dbe984e4fd33619c73e63abfa7058f1e3 +a6194224ad838ab86e84dc80e9b8abb121ae6c3c7fddc476463d81f14168131e429a9757e18219b3896a667edda2c751 +b68f36aa57aedc7d65752b74761e49127afa65466005a42556230dd608ecc8f5efdb2ce90bb445a8466e1fc780eea8c3 +886c3fa235d6977822846b3d6eccb77f1e2cd8ba3dc04780666cf070cae208b7513dc4525d19a3fb6385cb55f5048e2a +a9801273ef850b99eb28f3dee84ba4c4017c95398730c447efe8c1146b0719f252709d3397ce60509e05da74ed0f373f +a58c2a5dd13e08ffa26a6c5e5eb18bd8f761ab64a711e928e6101512401ef2b1c41f67ba6d0823e16e89395d6b03ebb7 +91318b564ec8b2d8c347ca827d4d3a060272aec585e1acd693b2bafa750565c72fec6a52c73bb3ae964fdaa479700532 +a058db5d76f329c7e6873e80c7b6a088974522390ccaf171896066f0476742fd87a12fe9606c20d80920786a88d42cec +9838e07f9ed8b3fbca701be0ef32a3f90752bbe325aca4eaea5150d99eb2243332745c9e544fd1bb17e7e917202edab9 +85a9ae7dd354f36e73baa5ecf8465d03f0c53b24caf510036b3e796e4764a2bc17f0373013af5b9f1b8973226eb58cd1 +896a4ff4508d069a7da6ef7bed66e1080991daee8b227f3c959b4f47feaf75fd1b9e03d0917b247c2db11e105395d685 +a36d9a6a037bf498dfc0e535f2034e6cd433c7b52e520469811eb2e9f04499a6ce40257d2905300df7d81f38d1bba075 +97aac3c5492aca879b4c06db1834b30b8850a244d29296046a84c637d9580c8521ab4752ef814c96f255a139660d7639 +8552bf592a84ab4b356d01643c90347377ebf1f2b38a8c2e55a3f34537b8c7dcbd62e6776d6c2114f2bc2d4344d1567c +84474ad163db8e590943ccd1dc50b4f444beb8275919b33f53d42cba89831e9d42ce2de52b26f4412e2a0676ce913277 +900799dfaf5eafeb297c7b4f892438bf2a65ce04034d66f8e5cc3836e4eaffe782fba4f4455a0fcab49102a240d1780e +817176415e35ad4a204b9fd5771bae6cc270f6ff050996cec89efbe461b2940ae5dd3c6c7d7e31b1da5285b207efed27 +965e5791c927d47569bc54ec9b4c5305788aecd87a26e402aabeaeccc03480df46f0586ca2e2a9918885cd03332af166 +b96d9ada4b5a04a94807d71726bd557de94fbd44042d7dba40560eebe8658d1da49eba54499360619f3b2c38e8b5ed6a +a07b6d641a43e02e7868f30db4dd5069a2f221b4f122ce9b11eac04abadc4f25f3207f1d2d86c7935b1a3d9992ea9814 +8250d4d8ccac846a4b1a9fa392d9279b5bf2283c8b95d8164c3c0d199fec8849eab85755f2a2a99d584a0407742e3200 +8324cf49f56fc14162f9a9ebda1ebda0388d09d8688f1938aef7dbf9505fc119069efc552f68cc7cd9213f96fda2c6de +a98e6f1e85268dccbe3bf4e92c9f455c58dcb53de1dba3b78589adf2e50e79f8e245f956e0d098eb46f5d3746826c6dd +b103ec12f266b4153d67b54d8fc079357ee342cbe5008adc3e0689a7f788534c4601e60e939731f49e4a1e24fd589f82 +b2d7681e866420413cc98eae67614d383943e3762d5742cb3c57e26157633c20880eea1209feaf68402d5d33dd699708 +99fed0ae4112ec9ed74baac70d202a885aa51cb555a3886b49016744dd4017640dd5dd564998c4d842a9f38f3e004e68 +95c35401314467219c8bfb1ccd1f1eae6ef4fa9e48fbea14f70d5315e67b16c46cd03554471840e4a5030b077d2a3856 +8d029380e0c294400d6b8673a23aed43697cb6460fc1bcf217aca3b47cf240886644ed09521d6a05f6abf56f99722d84 +8ef54d1dc0b84575d3a01ecba8a249739edfd25513714dd4d1941fbde99dbbc392f7eb9fb96690d7052609af23aa57f7 +b8ad2b7af4812417aa8de8f33a26547f84bb84f39501d4b7c484cc8bb54c7e166c849b95240fbe459a4719a6e3bf1651 +9858545de898721d19930d8b360cacc5ce262c8e004867a050f849f7a2f2aba968c28d51f24a9af56aaba23a9ded4349 +94ea5043b70df1db63f9b66b4f9d8082776f721b559f27d37b45e0a84faf47f948d7c4532dfd854a4bac49fb2ec8e69e +a2fd88d7b15e3c2778f6c74470d0f9e1a1f979a4d58bd205361eacadab9973d585a6508e685e640b272d6f8a448eae05 +88defd6bccd55db8ca84e3c8d0fc55a3456b41788f1e209d0aec19c9c70febebf3ae32cacaa1dbbf796d7ddea4b17995 +88b8cde2449d5ee7de2ee2f32e845d27e171a51ef64f1d3d8a5fd7dbb9f898ea70eb7f6410cddfd7b7ae70ea8073cc2e +8e044fff6ec557824866ac76301b6d93ed19b7177aa6baa95046330f5d69b572b59200e3653cf2f2b559455e782e8960 +b5446b4d6741c824885790d2d26258729dc0ba2f469c85a47d38886d933b785a4f38a951d37f3ef4bd5091c03fa3a071 +956c8afa8056e9a71ab2e8be5241ddbb3a8b3cff2110cb0e7389493d9fa45e6c4b769ebef540a952db6dcd8bd55baf64 +925950cae25615246e29d594ebf34fa7d52f78a9867338648158f2131e6eb4dc17e18f9db8a5fdd76d017b3a9798b3a7 +a17ea4b43211ba990270c21562690b3ef154a46c3d669c4674c80bd424cdfa95d8850c8e882b8d06504f929cba3d93af +b315ec723973a138508afc387ef651fd8a8804f93975fc36c2eeb796a304eeb1508518d8703e666a74d14318253f526f +a995742d7433b3f230e622de23cb2d81cac76de54831491cc29768eb4a56da60a5cbd573e1da81fddc359b489a98f85c +adb2e89f0d15294d7118fc06d4fdbd9c51d3ecbcc23c69797e5b8197eea0d6cd1240910cf22fcab4ef1e2dc2dd99da91 +b5ec9f9fcd0b5d176b643df989bb4c4c1c167112373d662fb414875662d1a93160dc0b5cdf540e8a30e5fcbe6cfbbd49 +b1291b53f90aed275df8b540c74a1f9c6f582e16c5df9f5393a453a3e95624ab7552e93d6e2999784e164046e92ef219 +8bc7b7b1a584a12d5ae63d0bbe4dc1b63c9df9c89bdd1095ff4b8e7c822bf8c1994c92310a3644033c7c9689f4b7d2b0 +ad7fc45506a10ca48f991714ecc055cea376c0cbe667f3b40ee8dad8446218835439ae59bccc474cf47b053748ceba6d +b134756828a5f5725c0b95109e09ca450e3834b127163a0aeeb544e63cc0cdcdf66f8ed98c331c7c98758f46af369a84 +94535bf1636be0974b112fcec480ed8eafc529933f3065c40e417e608e43a392206cfde8bb5a87b720263446c90de663 +a4df4f6efbc3701000fb072e5cbed2754b9ef5618386c51ff12f95d281d1b700fea81fc1365f4afc66a7c83bd0228fbf +b0336b3552b721087c7e2194976a9119aee13ebed9f1c3c494353707fffde52d004a712965f460062ec9443620716302 +99a39d1d1ee4283b75fa8c1fa42b6a3836b734be48bdd48050f9b05e48db6354fef509623c6ec8d447d630a9b3352b77 +8e3dc3583d40956f9e784e8bbd0b5e65671d2ff2a7c387b20fcb7da9b969f2d122aaf7f054d450dc611737604548c03a +b5068ec5b7bcb5d8583d51cb25345990f50d1f7b82fe535a6a6b17756355885047916f466ea3ab09eef5516bbf2dda90 +a8284ec1eb1d21e693f31a6c074199ee85d8a8da2167bffab5fe240defa2773971c8437e358a18f7e58d1e2954f57f6f +aa7415639d29081acbaac3e9c6b059d68e8702db3f430b86bb6e220d476fa74841c875e9d471c8a5423c58b6fee3cb54 +8afcfe6f65fa6e07c2cb3e1756c0ef2c589830be96edd50c3c248e3b17f51a4b08ba92ef7eed7991d81667ddfbf2bf7f +83b9c8dec8ca8f9b85f0e36c08c5523cfeafb15a544398e6f93b48b5fc4b15a0bd05c0f176a9c2469664acab8dffb0a8 +82a128a89ea46b9debe5c903b950c0ab30cd7570b979ca911500b5c2cca5c4ee6b2c2fa414b5f28e367f4671ffce60f4 +b79fd0ccd2629a361cd6f9307c02ecd4d1f07e4ee03ce4b542997e055b07a026cbc0ba05fe3da309efc58db2e401a8fe +b190751141093823b4b5324cc26c4f3258552f7893241201f2fca1ae9b1a1d4d4964a9abdde8642cf308ded61ce5ef09 +935fd48b95aa6f9eada0cf9a25a573f0ffe039888b3410788c41d173747bf384c0ec40371bb4383ddcc7d9f2db3d386b +b9affe100d878491ff345636ffd874ce1f27852a92417694afce4163e6a80c78b2f28d78102fd06c3283ef273ad37642 +a877670276d49ec1d16c9f1671e43ade11c0c1a1413755f6b92be9ad56bc283e4bd2ad860367c675d5b32ff567301fc4 +8c660d16464878590761bd1990fd0fc30766e7e49e97b82ec24346937856f43990e45aa8ad37283cb83fa16080d4a818 +ae1412087da5a88f3ccc45b1483096aeb4dcf4f519ff3dbe613f63712f484bdd8b2c98a152a9db54cf1a239ae808f075 +ad83cead97a9c3d26a141604268f8a627a100c3db7e5eefaf55a1787ddc1dd5ffc7544e4947784cb73b90d1729003c8f +97c3140ce435512a509e6ff3150da385fdf9e0883a5dc7cb83d616ec8d0a0014e4e0fa57a4d12c7997cd84e07d49a303 +a353773ff68f1615454555bf658eabdcca40a9c7bced8537ea6fa8d54764fd1f032889e910d2a2a342835513352e2d2e +89e8df0c17a36ffe08149c2ef8b27306d04cdf437135aaeba697abc65e3c8e91bcf1817919a8a826acdbbe7dce79a18a +9928c2da15ac6cb20b15859c22508cfcd452c5643cd22eb84abf5f0a1a694fdefcd8fc329c9b40babc52630743d6b65a +99d837b556f8d13108eef6c26333a183f59383b39958dd807b10590c3d37f62ade6c4a320ca2e70567e0218b0ad5807d +9272da080e4aa18720b634640b01bf1fe506c7c8a89dee8759a53e2ca5cdbbd4a4f3aca54924c46b935362cf1eca066e +b4d39752c882de1c1daf3854202c1d58c2bcf35c882006eb640fe54a97be2655281cdb91c30d1a41c698617c2cf64b01 +8bf827f4a7d47e07374d338a3d8b5c2cc3183015b5a474b64b6086fcf0cdcf4852046c9e34d7917d69caa65a9f80346c +901bffc7db9c9416e06f593a76d14f6d9e5dea1c5f9557bd8c93b9e70aa4782bab3518775c2a5b285739323579f7cf0a +af7e204388568627ca23e517bcf95112ca8afd4c6056b7f2c77c4da4b838c48791191565fd38398587761c8047d11c47 +ab2576b5366e6bd88b347703f9549da7947520d4e9de95d7e49966d98249406ed9270fe69347c7752dad47e42c4ea2f4 +b12e3b228b761dedd99d02928105494ded6d4fea3026d73d65ebffa2e85e2cd75b6d091135d418dd95ac102c22b5ee31 +a20b4a752685d5e31ee7e2353c8a1b9a5265f12bb775004d282a3ecd9deda44831bac1ac5151646428b66909b2a423f5 +91a1d4bc0062a86cc6786a96fd3eb4436d8a4a187b7cbba02190d1cd6ed3c3797d9ae7d6ddc413f1c94a21f62bd04ef5 +977f18da1a5df5cfdd0276f583cfba2b2a0fc6139520664e20068f8dfdde33e29d179abfd722f142448f4677aa47be6c +abc3ece90f0f7b1d80fd917de27ab0d88cca584ef959da520825e54cb5a71336b15f8b348532d08d47a6fa600527ef25 +888d36a2c7cc13a1c1aa338a183a74a1f57713e76cb825f9837f43279ce4741999b76a16928147537bcc20f2e0195b0f +af3f5dfdc2dcfe19de893f385f39f550cb1dab67c2e97f1d5fa735e5ec96d6680066803e8a0eb010dd4399f654195513 +a0fb4e08ff56530a940a86c28830956eb6dec2f020f7faaea7566faf0a4fafe0cffe01480e87763ec22f201be51a6451 +92343c5b107910b203c64a79c93d354f7ee5b7d1e62e56732386776e275285561cb887019cc00d3fdbe3b5d54460bec1 +acfe7df83c4624188a1011ad88c1e1490d31a8a8c8016b40aebcdd7590d9c0793e80d2d7ce6a7048876621c252a06a5e +a7da001dc1e33e0e129c192d469d2bd6e5d2982eb38f3ba78bae0670690c8e70f40e8114a57bd0718c870ca5dd25b648 +a903de5ff97dc83628290d781e206ef9d7c6b6d00cadc5bacffb31dc8935623ab96ade616413cb196a50f533e63641d6 +8f9658d42ad14a60bbf7263f6bd516cfee6b37b91a8f53715d69f718a090ad92484061c2cef999816760a78552fae45b +8c15b72b3d5fcb9ffd377fd67d9dfbdd706593fba9629002639973db12aac987bd1db70250ded31c88e19efff612cdb8 +88a2a4034decd854fb557960194ff3404e239953818a8a891bf72a0b26a8e570a65c4a630884de991ae7452b3234f31a +a09cae5c4c190537bf1dd75bd7bce56f7b799762af865bb9d1ee970f6a133c27cce0dd0f14a0e0516ceac41054e6998f +9760ebb1b40f9a97530c3b940d4ef772a225e5b63bf18283f8e302b9436c5209f6294980fd37058060e429fb7fdc3a56 +adaa9400eb86d857dc591b25dbe3bc8f207b69e77b03cb5ee01f7e4b006b5c8f6ba2b51b5a45687479885708509363de +949efe6b00b3248846747a9ad4a934d6e4255994c2b540a59fbbde395fe96d69bb67908441cfadd8c8bbb561fe52da03 +a19a45504b6b1dc3a0fe0e6a1384734a3dcd5a7cb8fb59eb70e49426c4fc44946547443d558e5719a04884ab3a2811ca +8934c9ee21e8d1435426fd0f64232a0670a7946ec524c054cd4f2cc8b1be9f89cc11002ca8aebae646a2050d91716b10 +b1150ff8ffb34ffdcf7d603348c0aed61e5f90ee0a1b814079fc2a41325c75f2f9ee81542797ede3f947884266a772e0 +86ce8cc7c1f92af68de2bca96ccb732f9b3374dad6657dfd523a95e8a931a0af2a80df74098514a06174406a40c16ba5 +90faabb9ace9e13fd9584932846ab28a618f50958d2ce0d50310a50c3bc6b0da4338288e06e5fcbaa499f24a42c000d5 +af4a935c2d8df73332a16dc6da490075cf93365bd0e53e2374ef397514c30c250bcac569b6df443985cf3720a4534889 +b7f948ee90f394789eb0644d9f5ad0b700c8e44e5e9ed0e49da4cc18483676d25740710b1c15a557965da635f425b62e +a917913091245beed6a997ff7043ecf60c4d655c4db0b1ef1c704fd9b0e1ea1335ce8b9f45d6e120f81805ce31555e30 +a48099da8406399bfb1ba834f6f7d864111d0036969a5cb64089947a63dd9467d3857b605e9f57f5ad5f4ec915088d9b +9784c3f9be42eed354542b1446d734521f8e3f01cd9d495ae98f2e4a3a16767fe2ad909e0def5d9a6267f3fc6a172cd2 +8d9afaa323847a3226ad7d7b60d87322ffcda2e4a8df89f58a076f7972d896588de685a2e155e243bcf9456b0a0d6d1f +994413faf0b843f4ec1842c706c45ea5f24351c68674a27887bc8b182eda756856e507a4e8bbfd937e2c4c581b629ee6 +b3e72d9d1ddaa00c7d22f25462d6e9f2faf55e30d138dce8bb1517eb0b67132db758668aac26164fd934d732633bdea5 +8e95875e338f714e9e293df104f0ad66833bbd7a49d53a4f7f5fd5b18a66a61aa0a0f65cc31d55e0c075e0d3e412cb90 +b980091862b1a9f9334b428eae14bbf1cecb4849e3a5809773b0d071d609727270f6ad97f329eca896c178ce65883db9 +915d7ae5ae780bdba27ba51a9788a8852a15355b569581d1f18f0d94bcdfed2c1ed5a4f58e049e9825cda11f92b2c2d4 +83e581058edf9259d0b06128282327cacbb6afc939578223cbf93544599f799a8dce1fb21d52464f990a877086f42506 +803612a38b6f6efb97941997e101ac1878e192456f8fbddb3359aa7f3023434ed8fa92e60ec8e7b4473b1948850e4311 +864a1bf4ac046161617dde282e44ab3cc1843da01a09ca58aa00ed00eaea9351a07a9ec16d910819e7dcc28b8d2c8ada +922eb142845975d5f6f7dcfee6cac8c299b3730400e6bf82cc0bdd9888de21de9d9f1530640f702c003e1ed63b140cc7 +a7db03c5be647dce1385ebc02f4825a654447fa8c4c8d4b22e635dbdd2b3ccdf219384e49a80cfb1e9e6182b6e4227ed +a167289ff0f0967bbab6479e4a8a6f508b001bbe0d16cad36ab4c105ad44f3f180e39a6694e6cd53bc300fe64dac1e8c +b7766431f6379ce62cba22ab938cdbb1b0c7903dfb43980a417e0ee96c10b86b447241e9dd4722fa716283061b847fb3 +90cda18c5d66f5945c07c8c7dc453dee1370217ccb851bbea32578599aa669b4dd245dd8a9711b27c5df918eadf9746c +ac690cd2af39932874385fbf73c22b5d0162f371c2d818ec8a83761e0a57d2db2fca1d757343e141e1a0348016d5fc44 +abac820f170ae9daa820661f32a603ed81013c6130d1ca1659137d94835e1546c39a2be898b187108662cdcbb99d24fe +b2ea5a5950096772f2b210d9f562f1a4cfacc021c2e3801ac3a935f2120d537471307d27b13d538dcbf877a35ff79a2e +ad94af4d0699cd49ba8ca3f15945bd09f3f7d20c3aa282a3113cdf89f943d7793e59468386b067e3c1d53425dfe84db4 +83788367ec97cc4bbc18241cbed465b19baa76fab51759355d5618067009298c79d0a62a22e2a1e6dc63c7b90f21a4a5 +a3e142d879096d90b1e0a778e726351fa71996466c39ee58a964e6b5a29855123d4a8af47e159027e8e6be0ca93d9955 +860831f8d3edaabd41be5d4d79c94921625252aaec806251fb508e364e39fde8808d38b10d557e487603a1b274c9bc3a +88da39f334bd656a73c414ec17dda532059183664bbbac44eb4686c2601629ef8ff9da992c337a842e3885b684dd0032 +b50addbdf7164e8303f33de5ce854d6f023d39c1c1984b214d9e5fb6f6001cd5bdda816f048a438ff3d696872672f805 +999e58c4c69a912b84561cb09610e415b43832beeb95897eca8c403ef4754f4277754d492eef3673afd4362f50060fc9 +b88ea0f60f8119c5a1fd9294796d387472dfad22442b29659713d1d88e7d854cb7cf5c9ef773627781188626bb2fb573 +a068b3844e9dbcf74b54fd55904d56af754d8ce4c619fead7a07f9bfb9d02118db7c512ccec2489d2a84374ec1d1fb6d +871dee023768636003c799e6f6fd8d31315a4c0da7286345cd64264a016693b3485e0732be1bbd34dd5fa04dfa58a983 +8021e8f508680df12e4a5a1bd49f2d7142df65158b0a7198ffa83abd16053a542fb93ffc33e5279020ba8c6a26feacf2 +b5d3cd64df5bc965228b0bd4ce9e5797c409f7b64a172ba165e44a8e4b38e3d5fabc3e0b9a19afbfe427f887c40a315d +a54fdebbb594bafcefb1a03697711e0091c072e1cc24fb441fefd4e0a0518675a1d7b0966cb8294051d7ec0ac175d0cd +93922202337f72969d6d6e14a29c9c75e0420dfba712029941d1504b9f6f9761d706cbc0652cd09a1aa5d22aec766af1 +9711ebf1c7c7426190d4afd5dd03b014a456bbd9d90ed101623866a280550df26a629dde400c03ee3699f7d827dc0bb9 +b4d686d8bc5c1e822a50124c1cc23c6bc3a1577a3d0b8d4b70d1797418aaa763283c09e8a0d31ae6d4e6115f39e713c4 +a533ea2ac683e4ba07e320501a5d82a1cfc4fa1d65451000c3043f0fdac0a765cc1125d6cc14fe69975f3b346be0fdde +94ee563134fe233a4a48cf1380df55ead2a8ec3bf58313c208659003fb615a71477e5c994dc4dcfb2a8c6f2d0cb27594 +93e97d3f3f70664d0925be7aee3a358e95ae7da394220928ae48da7251e287a6dfbd3e04003a31fab771c874328ae005 +b57440d34615e2e7b1f676f2a8e379e1d961209fe00a0cf6798f42b7c28dbd03172fce689305e5b83e54424bc3f4a47c +97644084c6f7b4162bc098bed781dd3af6e49e7661db510975528f1dea8154f3d87e979bcae90c3df3a7752eb0752889 +a923b27b225b2a6dd5bdc2e3d295b101cac5b629a86c483577e073cea1c7d942c457d7ff66b42fcf33e26c510b180bc2 +86698d3b3873ed3f8ab3269556f03ac8d53c6e2c47e5174ec5d14b3ed5c939750245441c00e2e9bb4d6f604179f255ef +87946826d3aa6c7d53435c78005509b178fdb9befc191c107aee0b48fbe4c88a54cebf1aae08c32c3df103c678bad0ca +860864896c32b5d4cb075176f4755ea87fea6b9cb541c255a83d56c0a4092f92396a3e2b357c71833979b23508865457 +b78fa75d687349e28b4ddfe9e2d32bb6a3be13220b8f3ff1ded712088bd0643da9b72778bcca9e3b103b80097f48bdd0 +8a188b940446598d1f0e8c6d81d3cada34c4c1ae0118ec7e0eacc70d1bced28ae34b99667d5793d9d315a414601c3b22 +842ac6f7dc14191ab6dddffcbc7cb9effba42700a77584aa6a8e17a855cd444c5d138f9d61bf55f43c6ffbcc83f92bc9 +b6742902c3d145a6af9738c01cf9880dd05c85f0d0ef7dbe93c06fdd6493333d218339ebc2a02be1895436a2f734a866 +98bf18488483c627b7181b049d3e6f849fce1f15794de59dcde6e5a9b0d76fd484a46e48822a6a93001d3aa12f48bc6d +8769cac10bda8c53a1c19419ef073a5998f73dcf2ba1b849561615a17cbc0a49bfe3eb4ff8801dd36a22fa34b9a3a7e2 +b45c084d58028fdfae792210fcd183abc4ffddeb4cf52ebf3f8a50e4c4eec2a2758f1241b0920bebcb24b757c778577c +85c1216eec8e1fbc1af9b36b93c5d073a81d5fba86a6daae38748ec1573eacc6bef209e76c87a6efbd7a3f80e11d4c3c +b8007e34bb3f927ec06a050b51e633d7eb9e9a44715d5b39712e69c36177a03cd68391090cc3293098e54f6cf65f6caf +8e85527b27c9152b1ba3fdd532a76a79064ab097570508f233e09978761dfe3012d537411b47d0e4b65265eb32cea2ae +899779f3c31a20b76068ec8d59d97a64d2249588ddfd69dcbaac6bfaee8ce0ff3c5afc4e17c934ae7cd041b760eb555d +a5dac3d8f5fbef018509612e25d179f60d2a62451c76426bf546e9666fcdc73263d34aa6fa7e2bfd4c9947bbf5095eff +896900eeef9be2b2e755128e7b1c436af6fb3984f1e66c444bc15fcf3959013b4902c381f0eab1247f878a6ebd1f4ee0 +8cb17f4b0af2e9b2cbb56f46e6a5d6874ea0daf147aae77303020b4e592ddc92e0dd058def7da96258b3a68b223bf22d +a1b6d3f09a9fa7ecc021ab7c5396541895da6e9bf1f9a156c08fc6f2b815a57f18c337ccfe540b62d79e0d261facb2be +ae70888811434ef93da60aeee44f113510069fd21161e5bb787295492eb8df85103794663fc9305f04adcbcf11ff0c5e +a84bbc8624100acfae080ba8cfb48fd4d0229a60b62d070bd08fade709efc6914dc232d3f7bed76a59204f9252321aad +aea47d54652abd8ca213cfc623c8e30780f37b095b59ac4795252a29c2b6bc703a5203acff8831314478b8ee8771d4d7 +8dd438eb8be14935f759aa93021c2b24e1d588f7a162c42c90ec3a647b0ff857f60e24c0a8953eb7bb04e04be70f11ce +922b07b5469680a10e7532766e099896f4dc3d70c522d8add18f5f7765d4ddb840df109146607b51ceddd2189fa7b9c0 +83ef6ebd0ae6c569d580093e8b0b78daa964760556272d202d343e824c38eccb424262e5b7809d3c586f9e2e9c5c5f22 +97f98bd357db6e093e967fe180cf67ed09fa711580a5ad48f07cf095b2e8fabbe6319f97d1f15d62c0ec2227569d8dbf +a1953a4a22fe6c2beaf2a5e39666b0eb53018af6976e3a7aab5515550ff2efa89400605a43fb2c4ac1e51961dbd271d8 +a5cbd67f4c0bc98e20aa74c09e6f5fb6f42c08e59aaa477b4b4e61434c8884bc14f17cf11faecf46dc4b6c055affbad2 +87d96818f2c4f12fd7705cf4060a97bd28037c5ac0f0cc38f71189ec49361e438ce863e6617651977708094d5336d1da +85e7c2daae5fe59f8a1541c94df50402a671a17dbb8838113fa4b7aaff6114cf2bb5969410cf21e6a162857f2f7a83a8 +a19575083e1731bb04bb4a49414e97aaadb36d883aa993d1f6847db50007315444814740e67e10177a14e0e074fd4c7d +a00ebfb5bcc3a6da835078189038a1e56b7dab6be74332b5ff7440e53b0f9e1eb9973effecbbf37000021fcf50c7c1ff +8969d7943abd3b1375fdfc7d6124dde82b0f7193068ed6ec83bcf908734daf3487a6a30f7b322e54a4818ae5f86d91c0 +b959c8d210fa43af9b20d1fe0ea8c4921280eb4544ef6ea913309ff9d61c9327096707e84dc1662960519be8e7d080a4 +9011d8ac651c42e0cb03931a9e960f58e02524c6b666047525e3b9097e9f35fb2b4b278efcce2bd5ad463c6d7fd56694 +937e3b22ed0fcdbd9ea5a1b97b84bbe86b7f5b2de3866a930611112f2217f4ee7d9822c4ab1253823f77bceeae0c8e10 +828997e5d121f4c305e018a0a0ba338bd6a34a7b4dc3c5ceab098ee57490311c130e2c045b9238a83908d07098d9fc32 +8d114808eac0f2e1a942d80dad16756ec24f0276763cd6771acb6049472e05a9bb1d3bbd5957f092936b415d25c746b0 +a063c5c26267ae12887387cbebbe51fd31bc604630b3a6e8e177e71d4f26263be89112cd12d139dd4c39f55f0e496be0 +ab1e1582c8d67196d10f969eeb44e6e16214f1316aa4a2a821f65ba5834326da6cba04373eabfd3b3072e79e5c9717e6 +a17b1dbaa11d41457e71a9d45d032448091df7a006c1a7836557923ab1a8d7290ec92a7a02b7e2a29fcea8f8e374c096 +a1ed7198da3591771c7c6802a1d547cf4fcd055ca9010756d2a89a49a3581dfe9886e02ee08c4a2f00b2688d0600509a +af09aa60c0a185e19b3d99ffdc8c6196d8806169086c8ff577bf3801c8ab371e74165ba0f7329981e9252bfe965be617 +98c04cc8bb26ffce187fa0051d068977c8f09303a08a575175072744e0a5fb61191b1769f663a426c30d405515329986 +a542bf1c9c3262d488ea896f973d62923be982e572172e2461e0146190f2a531f62acd44a5e955a9f1e242b3e46d63ae +aef7b7f30efd50e4a66c87482386f39f095bff6108e68f74fd3bb92156c71c75757912b111060cdee46a6b3452eed657 +8afe1e0ccd00079702f16ab364a23bbbd3da1889d07c4f8cb04fd994bf9353216360dbd364492932bfe20b8b69ae8028 +9896c690999db3c08cd7b25efb1b912c3e0f976db98a3e830f086aef93222d06ce570a7b2babcd7c81d8f9955169669c +ac7bcab6a281468907ef1ea8a6c1cd624159c88839131bef6aa0c22f331fc87ec6128a2c2a333fb79df549e4587e1a12 +987935c08a30b099d19f96901315a2e60591baf898581c40bf5eddcda806ff24a4536e30ed1e6c0b128a83fc77b6e81d +a0a6945bbede3bb09a4a09ef27baa20619d3e15af5673b9350601bcebe952597c989870746cf75767ffb73b32c6c9c6f +b0f5590079f0a0302b08a0cc1b7a5f39cc6900c2a5cdc7baa333d8328a731b2df5dbb67e27a154d3c44ed1a795fc4adb +a7294bdeea210e528f277f3d50e89e6d79950494478998181ecb38de675020130256f2f2a075899170be964d478458b0 +8ab3041b895a631869b439d5599a66facba919226ca9b39d915f19d59f9fc82393ea781377e9bd3bcc5a310e41376914 +8da399b59151fd48b2579948bb82698e3c9804d70ec7d6f3cc7e82901f9f2de5ee850349a7d6f43e5e9ebd47bd78620f +80e8c32de83d1083916d768b11a982955614a345d26d85b457f2280ff6c52bb776958add7c1c8878f7d520d815b8e014 +81bbec7bd99d2917d2dcd8a288722fb33ad5a4bf5416fba8609fa215fb80e0f873535349e7dc287f892aa56eb9e39c4a +9665796fe04c8519206fba58496bc84a8b9113e7ea8e152b65f7f732e88beea271dc97b1ea420dbc8257cc4b18a77463 +a97e342aaaf693ddc87e02790278e4bb50117af4413cd703bdf3b7cad2d1facf31fde1303b43ab2e0265467474f97a8a +925549ebebed348886e37773b05cd8ad04906eca4536bfed951d1ee41b3d362ddc6e1a302c21ff3a2d1e70e95117922c +818fdf74d7903502101551bbf48d3c7819786b04b192d9e94362d2fcb85760d8b6f45165a5443aa5221bef400525ddb4 +a9d29de7e8fd31b59f4a087168d062a478b1329cd3c81c31e56de4fb40de7a5be9a5269ef0be452c487443a0b097dd50 +a85286ad573db4c9aa56221135da1e31d742e0f6ff01d6b159086d7258f78b08dad55ec8eb5c91ee9d3404b2eeb67e1e +92a79b37db5e777f9ebbebde24a95430a199e866e56597c7d0b0e7fb54c7b092c2f6cf61fb24470ddf250cf609898281 +8d79f5ca67ed67d52c82949af342a9fc60fb793c47c76d84b4863c550796fcae2dd59e285897c6fb96fe31cee1efa62c +8ad2e0bda03415ab86324992bb62dfa3612d2d003765bcad1468087c27971d08bdbae5252681f0115a184f4885d444e4 +a08815af979286538c31b4aa5ec805053790af1ca58a8c4341be51136d094a8a05e569d876a079033298ad355ccb7ca8 +b96c2978d0165d619d08281d295e90df78bc2375d0afbc3142ebff9c2cd4b0f0aa97a9a0e3740bc4dce0ff8a9fac8252 +b7752cd0e582f35ab0d0036ca9c0a9fe893a6ad325164d78d865a604a85d3d23729e0362553e8b8a3d51816beeaa30cf +99cef1fafc29e7adfe247c753c475ad4bda7a5f9558b79c86e8a65968ede67adb38dc30071925c9d66a13860027a6735 +b9f6c65af178c791b6137d71980651fb09cb5b42f268999c728c6e129985a9c7d77b3dc3b50751bd29ec9ee0b3111dfc +8d73ae61fff5be883a281782698075c5650083f00399992688738856d76d159803be0059fbd9dec48f4f0432f0590bbb +a8a4a2865226de9bbf19e12c7e75318439fa6cf1cbf344d5e79a8f363439d3bc5bcf4df91b54581e7866e46db04eaf0d +894582aeff222e145f092ba15c60d3207340c38f2c6792ee2ab4d82d50fb544ae366c2985cc2b6c2f970bcc5f4b46385 +956014ba2d20a056fd86cb8c7ceeab9a2c6f905dae24fc1c5278fa5b84335148ebdefec5dcde8eb9b084700724fc93d7 +af217fe2b654eff6d11a2a79fe0339a1d4cb3708b7be9f09d852158b5a44b4f9b04406d6d67c4f144fb6b69a41ae9d0f +a90752a784bc00df94d960e523f5596695d16a534fc806179e0f878fc0e82a91b25e758e91a165debd815dd1af5f1028 +a697606fb32979549ad822b31df8eaaf50de4ead984439a0a33e955937d326519bb9f62c8243ad37f764655f8d32cc80 +a3ad4a30922e45a3e665551e5611384f1c2d414f6fa806184b0c826af05f014dc872585e255543794ee41e43cdadd856 +b29c255843a82ea74a013bac6c36a694646e61e6b9cefc4c130e2ee261e3bb5da3e0fe3ee7e6fbb009deed0530bc1c82 +87e1cc7febefa829cf050aa2aea59385d1048f8617abba691f7ea9ef58eb90ad12eeb9c439af228b0e34897ba1cf1b47 +994d3222f89e9c8c154362190be7167c8c2662f0cfa9d50eb4d8175b255ff0de09dc548ee312fc8226963c8c16f43e8b +8f1a980be640820f2d1e953264ca4c30330878971669852be3d5d6b41c488be1628b935388bfa2bd4de484acb0fe661d +854d90d0721579c8c88e147a4aa83553c960617b18075f8224b975562dccb30b0e02e81fa9df7070f356a0eeffc3b14f +8e156da9d4330a03e32a25a2f0b861fd3ea5c719fa4f834119baab6e5fa5236a9baaf0d44147bf0841418900037f6eac +96586fc49e53a6799242ddf617000db5a0ad20c6cb1686af2102623d64a71aaddb8e468b15fa6d100d0384e448548db4 +b44d8d85c8df95d504f82d597f8c515866d4d4a326fa1b816dcc5bb0cc4ef1a52647aa5d2e84c62e194c01cae0885d21 +b75c43e676a7efd199f8b32ae31f176ec667e714df355e9eecee97246f72af5bef9c5b04c11e7e90fc37bb9163f957ec +a49835ac0565a79f6a9078cf0443c5be20561a68b448289589721fded55188583f1d301925a34eea647f90a6e66c6774 +b47c17ff6824a00b8f29df0adb7f06223208d062bd703b0f763c6eee4ae62d4217eef2da4f4dde33f0b469c2f2db9e42 +957cf039cea6f6d41e368e2bd0cf77315938a0738f15ed9ca342f0a28658b763659ac1d1a85ecb362f13de12b77bb582 +903a52f8d2439fa63f59e1e9aba864d87b0464ded63814474947112375236a6f84e8fa003cc4433c8208d80e05fbd1b0 +8afd524209ff08d1eb6312b078f7afeb8e1155af649e930ab711dedda226dc2db6b0354aab9652eea7f433f90015bf7b +a95c3c9277b11bc8fe191773bf567641be57c0549913b973fb18740ff9cd7b3f7ce198fa4dc1086b2b8a446012459193 +9455ce8163fce04aeff61e7808ef3aac4725e51404f0858fe5d39d7344f55dcc7871ca332aa5cb1a63a4399529e48907 +809fa35b6958f94e781f2c584438b33f5ed528a6b492d08960cf22ecf63ea3aa1e2d29bc879e17296e0a6cc495439cb6 +b0f50774de212dd33e5837f6b496556215c665437e657f674fc5117e5c07dadbd0d057e6ac4c42d50a8eb81edfebf315 +844c65e263891d0b2fea7db6934cc4b7fb6bee2c1d0b9ab4c47f2eb3e9c5d7197dad828d38c54139123740151420280b +b13c78c9efcbb3b28eb3fe0b971380b7d5151c80948a99cd93c78b4c3ab0e86df6226a64d91e0a2ea4a1c0a46bc0404e +90300a541decad460c348b8f4257f7a29687b2362ebee8d92fd03cc0e85b285ccb0ab1cb2ff5e29c5cc5295e351017cd +ac49b409ded770c6d74f6e70104c2cdc95b7b90609da0743c9923179e8e5201ead03becc0ab10d65b3d91a5be0d52371 +a257b815bd8289dfdfc21af218aaba12ccfd84ebf77642cc4cf744d9b0174ca0b0d7ab2a545c2a314fd5f63c140f41ab +a34778d8446e4d74d8fe33de64b2694ef1e50bc140e252af6eff3ce7b57acf8b6577a02ba94b74a8ae32e5113cf0a29b +ab9e935bcf0d8607e3d66f013d9bce7909962cb7a81174923db02dc89e485c2b1c33d6065bdc7bbbe0450b5c49fbe640 +94d2c5c5c309c9eac04be4636f61bc47fd9579b47aded57cc6c736fefb8dfd8f8a5de32210f7baf2052d04c0219d3b4b +b8dda9046ae265214086355101be3460421f7cd0ed01bde9c1621da510941d42bc93cd8060fd73f374fb1b0a5f38d45e +a6674649dab5f92ab9fa811d9da1d342cf89ff6eff13ad49f4d81de45438e81a384098d3ae5ccce4c67bda5dbe246d95 +8d619f7564677bacba29c346c4ef67c211f7a3a14c73433dd1a7692e16a7e2562f1d0532454af62fc04c2fd2bb1789b0 +a2b93d2fd4c707f5908f624a0fc889e20164d3c61850af9125f47a1719757a6ce6375aa1910eafa4c1e8b6e20c312775 +a07d5585447654d82817ef4d199984542328b238157976eb9a267f0bdb2229acc25aee510be68f65a312b68fdd9e0447 +8ef55cf95e2b24d8ec88e4136399a7763bd1b73d5e90ea45e9845123e9d39a625cc336e9b67988374b8ebcbc75f2ed21 +b62c1fc32e27c767c461411b02fe9aa44a86586e1427406f4ef0b346d077db91952abce79318b382ec75b7be23058cac +b252900345f5fa15a4b77fb6af6a2d04db16e878b7bd98005333f7f6e3c8e6e46cf38fc5d1b2bc399c5c2ff4af730dc6 +a4ab5ac0cc15d3d17b1747c6e3133d586870eae0a0d9c8fa7fd990ebd4fbb62e9090557ca2792a6bc6271856aa3c9a05 +8e706b3f2e902faee10b22742c6c33bea6f670a8937c243db96885143c1db5c979e33ab73a38359b52b8d668ccd092a9 +8a6792190ee6c959d79f60c22980ca140c638d88d75660adaf9bcbe6dc4692ab5f01e0c460170f09f74d5e582e85ff1f +97ffeedfc94c98ec85ea937e064d7b290a326838e62cebd407facd1ab4f08d9c0c109d79af7cb6170fccfa6c8243c127 +b79970b67c09453614ffd83a0c923c17f857c6ce3c87a356298f8351cab0def7ed83efd4f6638f48df67e07bef4ad9d8 +b90f1931c7cf1822cc0a97401119910cdfd0482daf09a4d7612e4e05046295cfb4cc50d5214b31676bb1a1c9d15f9c7f +922921ad813c01fb5d12fa7fb7ed8e0b0abbf7b19affa190b36013c55b88fe3c7df0ae663c970eec7725ba37b95a7cb7 +a124f33e7f28feabb4089a063a08d52b7395d24eecd06857a720439dd9414b7073bb86fbd0b04e7bfac62d3dc0fdb2f2 +b252fe50bc6677c004550f240fe670974a33ffe7191ed7675da6ac36c780c2f8d02be7da5d92cbe2d0ce90147847f8b1 +ae5f8c9c56070f919f3df2d2284348fa4b2e39881f7bc42c9b2f5b7cb1ebeef8ecac000f37329bbe04cc1680cefc7f4e +b432a4575caf7337f11eecfcbd34a6705d0f82c216301725ceae2b3c9df20fa53d1ebef65513e305013d1e0c2df522b6 +b7c016fbbc4614cdbb12db1c9ac41f9a45d5e5ce82594d568a30cd2c66c3cc9d91a2c959697b67c582a0913de661505d +8f6f3e5e0347dddc1b2a34ec0dbbbb7cafbf976f19c9c902efb5c1427d1bbd4b71abd9f3fba20dda75c35a39393c989f +b0042a1d33a1ee9fdf3fad2299b8d70c4f1862d8393b5ebe3ac2189a2c5a58bb826128cd7a39b70d524a6dd976097e26 +85297c4e8ae8d9b44c3fe51aa926c77d55db766c2a9f91b659040de36e34c9a4fc6f44380f8d61704498f6fd52395a49 +8c61a988b6a00fe5a277450f30bf6daa932e42a2eae844568e3babf8815e09311f3c352dae6eb2d57a98d16b7beb2d22 +990be28aaecd932e7edb2a97b9be2789a3905cb88737b1c79881302585801c69a3dd5fb230808b39db1352fc06e0b4a8 +82fd14bdb335aa46f022dfe0ed4d631911e6b6f5eefb10d11e9e2e02a7df55012ed8162249d10b58eb76ced5a7b06cda +ac39cb058df764e161db9c39b185f09aa210bddbd66f681f1697ddbe6b305735612d5dd321d3ffbb4876771bdb321e2f +858a3f7e57ccb81387caf8e89f9b6039e9aadeab06886d8688fe6427151a59ab2e77e85ba850c67d099965426c97779a +b57fb9ea623cec432946819937c6bded0b5d03c8c67b52b44a4b67d34adfb055e6cabca67a48e4d859b4be45162c5083 +b84d2990b563d6d7fe1f4c1894989db25b81745090b94b1fe2ef708ac3b2110ef93d647820b2a51fcf78e3f00fef5412 +817d85b9f5e1521733d2b1fa6d4f4957ac445dc803f97fc495e20b819b14e651332f9e0573d684b854fd47824c53f0e8 +b09e18e97e93a8523101af594422fb71afc5b8826002314269016fcc1b44002d91bcb7c90d923d460f0cc03bddfe9af1 +b867cbede82102de7cf6cd0dae68506869576eaa66c3fc806e73585310602682fc912dc37adf5ff6f0f34a07831735b1 +b1126255798368b692f2796a3470ed16e5ffdee2d8c9e0f7ee3d2e92950c3e6365c32895171c3494aff2a6d6356f7e25 +b05f0a0996dec16335c770a5df3f0b08e20020c838c2caaa1d3a4a2490ede98552f5de349de2ce6e4c4a839731d80919 +98c512bb91c8fa191120ddf5d63c88076581cf41e15eec3c168822f12b3dd0ce4d6df74a7e3093d3e35cad1cb3135421 +84ce38fd97f7f90012c2c1e59a67bf9f465a7ccfb6f308bdd0446cc82b8a26ff7c30e5c7cc375011718cad1b31adaa9f +93139db52c9fb96dee97a0825f21e34c5d6d36838e1e42f4d12d01eacbe94426c85a811fe16ca78e89e08f1c27383d28 +81454037b1e7a1765f67e4288b8742eebf6d864d9b0f508ab44fa3243168ce0ed30cb5f33dfcdb995cd2c2710ff97a6d +828deb2a26efb2ff1842f735e2cc27162360f619b6e3e27a85bedf384912d4726bb2759a3016937973092ece1bf90540 +87e5a7d4e7bd301078f625d9a99b99e6e8e1207c9f8a679f8ebbbfb467bfa0b5f7ef4a4d577c7d2670efa88221153012 +b9dc9d0ea48deee201e34379447bec789c8924aecd030eeb93db159af77eff230976ef60ea9f4b4a9e9e95c1f9f4284e +aa6528268d46bf0627d87d58e243d3ac34b863513c725908a2617e4c6a46ccb1d8c8334bd6dd0eea7ffebec44259dae5 +8d26c9ce07293f6a32a664d31e6df9a7ace47e6c38001635918efd9872aceab62de7757b13b783d422eb67bd28ce7bbb +b0d3ca88d9829a7459b89b0dcbdb8bbb5180b00d750bd959bd110f53c2dd5d4db554b6005c4765fbe7ec5903669e5ebc +a94d1c72bf3b2dc6bfebc9dee40f6a89a516b252bd9f4fad96f156e3dbfc151a9b8a02324d764c7656d59230a18eb61f +88996e79171e30b16505638d8ecb25afd875e5f3cc3e29860937f2b5e751c66e78dc77f744a0cc454a8a655142a93ffb +af4d94f342665fe7ecda318de6cf1bc1c40c37dd83d060fedaf827459728152b5f0e280286ff5e6a0012036f6715f53f +96beaa7a2d565ec14a4e5cb895d33624c69da56b75c8d06ac729cb6d0cb64470ed4f9b0387083cd827b1609c8cabde8c +96b773fa2fcb7377bf71a7e286f37f1f24ee42cba5b4f33903c4566e5e5bcc501ea360e3c8435749107c3de84e272d8e +a69ac6218454c3f40ad0beb48821a218fb0a4f33ebade986d2fffd9a3900d8cfa613bc71676c46cfeaa5f644d1f239a9 +857f139c08fcc45370f448ce3e4915bcb30f23daa4134407fc6d78efac7d718b2cd89e9a743eec7bf2cc0eccf55eb907 +adeeba36af137fd3c371a2adbefea614c3ae3a69f8755ce892d0dd7102fb60717f5245d30119c69c582804e7e56f1626 +afa97ca3548b35aeda6bfed7fbb39af907ed82a09348004d5705b4bb000173270ce44eb5d181819088aa5a2f20a547a2 +8423bd2d07073b0e87819b4e81997e4d3188b0a5592621a30981dc0a5a9d0578fde1638a364f015078a001afb00891c2 +b92e9d4ec3966981ee574695d6e4865810b8e75313e48c1e4bc5eebae77eb28740e97ecc3e5c42040f9eb1ee4b13b0ea +b07b218321d54cecfcd2ed54a5fd588a6be8d7a5b6a66dff7facfe061222c40553e076e57cbdfa0bdb08e0a009c94ba5 +a71e1ae4d6096eac9ea4c21f621c875423de7c620544e520fb6ec3cb41a78554aedd79493cbd2c2ba4f0387f902ddd2a +807cdac291246a02f60c8937532c8969e689b1cfe811f239bfdee0791e7aa0545e9686cfb9ed0c1df84748e5efa5e3da +a1faeb4504c057304d27d54fb3ec681462384a354a4f0b6c759d4fa313253a789250c6b0f44f751b0718592637438a19 +996bcd3215182d49f1cd15a05e1e0a4bf57e264400bf14f7253c6611d2571de7130cce81fd28e0411e0a80e9054f4f98 +89d15b38f14bcd46f4b2dcae82b0e7bf9a35e40bf57aa947e9c4a8f87a440b5cea95229708de08ca596762062c34aaa0 +8d8ddcaf79374c750b8b0b3d196acb6bb921e51b4619876a29d09161ba82a42271066187211ef746f9f40a5ca17b75f7 +a3dc7f70f3a6c7edc483e712770abbaa94bfa3174cfee872b2cc011b267e0ef9baa1ab49e4a6c6c30dbba0e0a1237117 +aa9e958bbdcb192b19c43fc6fd34afcd754949fdada98e9f4848e8db0e23acb27d19dd073c951a8819000f2356aa22e1 +a4714e45ec853eadfe5c3bee7f683b81f97857bbd7833192a48936dd1460aee68f700a21658658b74b737c4fecf90c7f +a1ecab4215c1892e4a8ff3405d710163875e5dfef8a8cb84f5cac4e317d89c7696e3f496ed1747ca6f52b304190f4ba1 +b9b48943eca3686219575026d395b969e6ff8159dc5317005df090e79d26901984e40ae4b1af060ed3ff6f42e0417d76 +9644b9f90a66edb0396abd8c00066886f978ebf56fc22081031fbc9ce371bf9b04aa5a4ef59e59319b3a05bb7fb88b43 +b2bb14f1c055a78596488e4e2d4135a6470c1ee43961952160b8498f674a4d23040606e937c02c1fc23dbd47e9bd4633 +8c61f2fce9a42b94a389c7e52d7d093fc011099d0f4914f6d6f05b631df7b88182826edf9bbb1225971a080ca5c0d15a +aa6a7b8499cc7d256043eacad18528d38bf3be970bea4c6d4cb886690280bdb373688ceba3e506471e1d9493dc76f3f4 +8127703363b3b35b06762c2353d4de82b7b85bb860db1028d3640f46bdb78f2d104fa77ee3e0d9db83833d2b12a966f8 +b7b01f5909f2c66ae0fab156be5d79954e3a304615e1fe55945049dd4bd95f973bb3821117eb54db7e9ed1ee9a527652 +8be47ba5dfe212420649193490838670c40540e0ea24adbab18c4a66e7ac3dcf94f068dec2533b60e08c1f64e7533e54 +905a6c7e24b86aa54a05c329a6b4616d335bb0b1f1e9987562eee0acf82ad302c7c44981a1dd6b24c6121ca12fb92996 +86969ccfd91deed93b355a2c21319e3bb08cc652b741463bf68c626b7ba2afce3f7cc397f2fb74588c2893477c948ae2 +b5a9d20eb12c331d0d300fd4b85b0ac0bb74573178a5fac8ec9dce5e95acba07fab444260355ece442a846737a2dcd1c +a13497c11df21b11fc1a63b0ffdcf7f432da4dc2c98f8d07d36da4fa68aceb57af2158088e5b05e334fe0f264aeb7a97 +882e4597cc66498a45e86a2ed9ee24652da4699af00ad35f73b5e74fde6ac3cee70630962d5ddd86162d4aaf11bbc11c +b748858c2bafa4a14ce44af35195e9c52aa75e109719243bbe278095acbfd6a7ae7e084caf8dae6939039b5a4e8fd675 +83a2e0524507e74f51fe976441108f8226ba1b3a33f4e16ec45c5661ce80cb1840a93d17122cb8ca9e0f80d14f69877d +846cd2946c93ee5f24243d9ebc69936b3a1a6d59f45fec6c79b1eddf15ce30a8e73ad03cf606ee66baea3d8ff115f70f +8d98d0a3a94f6efe158f8423c041b546416145c5c2254bfa157efea0d1c99fe58acc7df6424ef29f75960b18d664ea4e +a39fa47e4b79f54dbf59d0b1726f1e78bc219fcfc56ad238c84b4b610e7892ff1e65d537baf5118a32f5e2eb80d5ee0c +8c30969a4519131de5e30121c84c04f67b98c8ad109fa4710dd3149cae303d51778add3f258f0482f1c89c169824dffc +af7f80d141ceb78b4762015de17fef49d7ff6202d292e9604deb508272ee7569f7fd5be3b2438da1dfecf0c26533ef86 +97cf82f70128251944d79b8845506975405bd720e150d836205b048ff36ba8801eb74cdcc6425f28f6bc0acec0a81463 +8c276c876eb88688957d1868bf3a1462375e608ff72b49870a5dac82cbf6584e00e3f36f236f732348a47502ccf9539d +964765f1a5c8a41d8025ddf56dc01b78424703d8a64a4e5539e477cb2445cb541c70127c561e717256d13f91a830ba83 +a2aacd9e21b8c8efaf2319611addea1b9f41430aee42e7f2a640cc693aa395287cc8fdc2806b76b577d84fbd05378ead +ab11eabbf5be4345a77323a3b75f9ee93b011fd2a9d0154e88183cafe47f82a7888666af16b40d3cb677c94bcc755ff7 +a0bfe715a7af5a29b1b6148b8cbee585d2b49fa6ce59bcd173ea3bbc60d71a62f9da27ffcbbd5a6da75502112fe44d70 +902e6cc38ee42245103d90b65028a471bc7a48b825599d361aa81d8c56e0fcf9fbe8d4c13802040d2cfb85b7e022eea1 +8832e2b5014fdef4003bdbb87e3298fdbdbbe49673f6b66e2373f1cb2605f9c4af2cdf9bfd45d1993208681d29ee1c9d +a7d39d3fa1ec1e0c87730fa43d4900e91932d1cafb36c76b2934907becf7d15a1d84d7234591ad4c322b5a24673bba8d +836ed5f09d99624204aa3aa7ac601980fda223f3b4b96b4a8fb235c574a3545d518787c12f81bd5851987f2860d41886 +94235e94445e6086f6e9331923262070a4c2ed930ec519eabb8a30133bd4fc6debb99185f4b668431fae1b485c5c81b7 +9828ffe20b9405f117dac044159be2d3c6e2b50ecdd1651d6a73f7633e6e2a7ba3d783ae939973604446d3a1ef0fb20f +92f03dc365dfe9154743ca70e6dd2758f064e3286fc543cf8c50f68effdf7c554bd17b3507c6ff4127046d9bbb5522ef +91ed07df479d8eb3d31292a0e987672a7f3d45ecafe72935b7abbc3f23493605134ce573f309e226c9efe830b6868220 +93bee582661e6d6cefeff29002afc2f36dd2c13dbf33f0574c35b290ddc426170a5f7f196369ad592efcd72cfb6f8fc0 +89a51467d966f48fed15dea5a12dda54d0015f69e2169b5e34f44c7b5a5d4c282d6f138116a0cd06a8476980e420f8d8 +b8ccebc14b6679ba2399370848864f15f63512fd6139df7359b7b93e82c1007fd85137ecb0597294b46643e1a9e7ab5e +841fa301567fc57b2cd09508ce75326684e12bfb8add671dc208f579b2500b93d5b641e9f59bba798ed4ed1259757f7d +b3cb45c15eb00b4ccb7013299f761cb8fefc17adf6db50e9ecb8abe927a3bc7f28e359e64693813e078e1dac800ad55b +96e55d3b9f445f5679e34fa5425b3e87cb221cfbdd07f8353868c7f7f4ba388ee3841cb9a1d638583bc20d03a9d071f2 +a7dee9377de740270c5b57cf86699004ba8dc2766af56b388b5cb0814ec71bb99ecf43ee3d82a552733854ecc7def0fe +b129dfff23b3c1c95ddb214c4711961fcb129efe2b6557ec9e116ada909593d0d2eec2c628434493393c58c52aa86847 +aed2670e201cb3e38a8be3c86735a4d76255e1e5a4c67b91df6ed262d09c8d10b0a3891da3e6ab934058cc9a7178931b +b20b8921ae52e5b3c94fa3a8b46489044174f7b897779e7763d6eb419e808d76705b7e7ba5131576f425aa81b6b0de53 +a7e45bbc3ba1bc36617291ba7663806e247f1b57a89e31520c64a90cbf8d426cac2e2f381338baf78c8f92fdbbcb7026 +a99e651e73a507e9e663e2364fcc193ec77e8afdc08c2bed6ad864e49b537ec31e9114ee72291a7657899f2033a849e2 +af966033636c2e9e8280d173f556fe07f8b6940bbcf6b2df7e2165c30bea66cced2596f6c17ca7c1aa0e614174953ba9 +b69ca7a79e3d55ef21e0ebdc6f0c4bd17182d30cf6290cccca7d2551c91c12b966020d8e40e4ee4179488c9809c03ae4 +b981cd36244e035fef043f70b1d7188d7cd045b4de0581c459fc5730e10eb7f3d5893b54cc4243849c0855e4e621167a +b20fea858a36921b35a3051ce787b73f70fdecd3fef283c15a2eb1bffb1dcba5991eee4a047ce4e87802da923fd9457b +b040e6f2e56dc1860274c263d4045837456f74b354a679f6b5ea70919835ebe5d32bf1f519e218730096c98ff396dc9d +8d2dd60e702c923a7204b530e7d6c193c6f93ca648c4f7bb38f4edbeb0aaed84184213afafb8db6aeb9197c24364276c +95dfa7348709e43d71285b28a0bfad3ca805b6ed4ae99753e9f736c79d58a35a3a50b42760ccdd03eda50f6e59494968 +b8585632a13f18c139a411bb2f02df809591834d127cd1ff081e26d0abfe0e3fbb54abea26538b25a0dcb4d7e969590e +b46ba47858a29c6d523c9982660949567666daf2582b93393a4802a9e077eedbc0d49d454731696bc8e46ca50c7caa40 +84b756b901b98a4404e58d70f39f6ccac877146c866732ae65e7e82727448d1550343bf7cdff1bfd4ee1ed73793db255 +83e5be888eaf877a2c755897410865f64a6d1169a8ccf0336092f3932abab915e542ab75a35ffe016042340d581ee987 +8cb274fc39285aed451a7def72cfbf73168ee10be02affe355a2bf87cf361a81ad284e9334cf00c5bf99a13d9f75e116 +91ff6220924b94ae13f50eeac16a159232e4f16a73fbd5c22c0e185cd1998403904d36bad203baa82b85819ee4a8ac10 +87f46e08e09aea2ab37b55fc300689d9b58ff3e72f1cffe023386035888f714fac4673c7c5193d3f3f3c568c640694f0 +835d7d84ca7641e1b15095830114aa6072fe12260d2202456cafe2308c22651af9ffbcf6b7e56af97167dd0c4e2a4cf2 +91202183f79794f114fd9e3b9bd05553c0e8985919965101a57d97ef666b028863e6cea9735af016dc1864f1542dee51 +81ab2b02a9b0a490a74ae615ddd4fe560734c1bfdde6b8dd13303c1481ba0e8ab14473535a93cfe4e824a0ab29445f8c +8a32d73f4fc006551d4e2c61eec6130355ec9b8c39a65c24ec1edc00e80155ca83a8ef2455e892521a3d47634d82a987 +af70d7b8f13bc90193cc1cfb0c400c4224cf10f1887848aa93e6380f7087782fc41a159926ab53c53eb95c2383b1a849 +989bf42f9d357c51774f1c7c0f7c0c46a8cb7398a74497141c32685be098e38b4230ffe833a6d880ec391a35b1a747b6 +94cb6715ee95700020c630b8c19e35f231de970219bd7e6ba7ced01899197da473b6c45cacfab0d652ddaf547b4ea58c +b12e3331f1f7d7458393a785e22e9a5e1d1daea521b4e78c0ee8ca59b41ade1735a29820e18f6afb2f2c3c56fecc16b6 +ad4b7cf654349d136fb41fb0dd65b588199f68b462b05f5c4e5c2b468bfaa6c26329033e3c3f7873dc8ace89cf873ea5 +a3279969e1ab596df0559ffc5ac7a6dc849680354e01c3f4fd34c6413a3f9f046f89c1e1be0b315d8b6dfab3d23d5c14 +ac74cc5562836ed89d09a9ae6a3644c936d64bdda9e77659d9982f1be29541b03ef2723236d5465e398373ea19a4ccc6 +98138ebce1af531dd8b631b3e74c84f0c700355a2a9bde31e5e51bb10c8bbd766559c63f6041f4002568803fe08438e0 +9006445da131349fe5714e0777a4f82a82da343612589a0c1596393e8b6894ce1cf42784f95ff67a8384ffe1f1a4ad76 +88502a84a85e4ce54cfed297b5d355867cc770a8ffd0714a6f23b1ab320a9903c6e42809e034bb67dbf94c4fc0d9c790 +aa8b4bf123d1a6ccaa44b86be8f980005f2a0a388a76cb111b0e85cd072ef64167fb0c097c7b23c4bca64c0260f6cce0 +ad49eb35dfea9feabb513a78dd1152ad7eba22fbb02a80cefc494a7037699c8df81202dfec12acc1b9e33ad680cb72d2 +8694da730231b29afd5196371ddcb15b4dcc499574bdd063f4864ab80749833ea38ab8b0ca1629a367fe378e87a60a86 +8eca7b488e810c479e7e32e24b8afcd837f7df183fe4f621a0336b53a9ed77603c84bdc365d8be68179a32b71a1deb7e +8875cd3e23c7e1af55af1b091025a08255743984186770bcd43f30b4a58d175cfdf1984bad97a15e08dac2da27198c3d +abdafcf58ec72997e494d4714645f40d09dcd0fbd0733e640eca44eeea67c25bb0c270299c459991f2fae59d13b4f4d5 +8f040970141e61489284f3efd907705eae6ec757fe8e1d284eac123d313e9ac1e8dc14ae3f04d281e1effc49d5d2f51d +a7ff115f0d2dbf66c0e8770b3d05157b37357b9e33e9a447f0f3fa9da69ad04e371fd1e4848cfb9e8d05e3165bd969d8 +a39b1a8c39d317fcc97bf6c396e6ed4a85640aeeadbf45166bd02bc3bdfb6266509159c03afd492e642384c635b824c0 +a2e1b90f3dd2d0038eaa5be52127844ccf35d997143179d95ffd3749c0896398b130094d01eb1bb31ffe80ef34b42b48 +a2bbe31f89b0c3c375ffaf63c8b7831860a921d5e388eb7907dbf61f2601ea40db86bb3952ecaa26a5eca4317a848ff9 +87d885bb0f2ce04b40ce94d2557c15f1698dc652e938f9a2d69a73ccf4899e08eafa1a59a20cae92823795f5b94f04b9 +8f7746370f8a24a2889d351f3e36b8a7d60e75e50e8f5abeea7dafc75441e95915721654e61ceac51bb6f112780d352c +a7272847526ed3d9e0d0fea1d8685b07b5b908971490bf8a46748c8b1783c629b8644feb5bac772ae615daae383d5e72 +978c9aa2996d8bd6fda7e0393fa8b38747f8f99712427705c00f6e9a12c36f8d8b4cedb03fcb9867155cbddb5200e6e1 +a4dec4a2354b2b32434c5bcdc380bf84580c6f9940f94dc0498a5bfe89c675a0921e66b807a3d859a6059a464cb2a9ac +99459ddecc7abce437f68722dae556d8ffaf8ed974f459e52e6d4a64f176caa4d42c2f2ec57e8a5b5f2034638e8acb0a +928c68c0c9213fe6258ab5bb0c693d97203d15da359784de7824dec143212da57d062a1fc70a79172cee31adc7aff382 +aad3f318f1622ea87e12541dfd982d71629b8f1ded4c301f9f6b6af9432716ad057773c33bdaa6f15dc151b0ee4505ea +8eb8e978f149a983fd6ad01773f9aacf57bd0cc622d8a301e404184b37e610123dd081faeda571a0ab1f149a3960af10 +851e7191d7b94bd422bcece5b92609fc1b1c8556229bc53e32963b2d2fd1cacd8ce5da9040b599eca6e610540f8a7987 +9414157fe9d50e5a0b5a7397417681bcb3a651eec1cab63f2a88d5df68ab1fef6e4c1d7ba657cbaf241a7cb790297633 +b5cb2dafdc5408959780754a58b2da55b2a9136672ebca42f34da4e329ddc89360e7218cde3efdbf784ddb390deacc57 +ac6b70f65503a8e94b773fda3e72615745824930114fe72b6d833484285462392617c1b2eea4a250fedbee88f503f3ba +b0829a5312f9ac6c06fddee2f835a3452fe994f6d42c9edfc390d7d5b3240ca544433b544cbbddd6516b38a6d5d7c21d +95f8e2c59905957e34d53be3d6fb85732f834e2cb9ab4c333fea2f502452a87ccd035fc9075d7c0bd8530bb0a0c96527 +b93f279b7045f2d97c674495f6e69a3e352f32f43cc60300193b936c2850b2805c15457251f7e3f633f435cb2b60405c +915abf16cba1a0b655b92a8a70c03e7fb306b86f3bbfb66967ca63e64c003b59c7a5953675efa4fa0bce9bed536b6700 +ac2047f50a319d09df1ec44d71afdcec5ac3bd2765dc98aba347734aa780863545df9f6d71214d443e3f37edc0dae45a +ad49c74ddb24c8a26b14ec08bc807313c77c5967fbb36237f55994d7511bbac8d7e7b9b8ec53eb1b3b066989f078dbd9 +961483105f605e959213fe9e8a52b76dac62d7efd2319ec71fc4e92d68fbe44cd2f65d7adefb2eb64d591b91648b8085 +b67fcafc97d8df2b3075bbff7b3d7471dbf1f3048f309e55d5e2c5bcbc7a73aebcb0697859be9f387cbc7ce98041e154 +8da70ac16468cab6066992389cb37c79ff5e0babbe67d76878aef9408b9597a3dc2eb5de87428bc761a0d78957b0eb28 +aec0ce89770d299b631f15ae12f94b1e1014ac57d38fcf037c2c7712d770d074affa06e97c60691bad8733874b6ad2ed +8b702c85fa4c915a09fc86507f44d7aeda0993b77af87780d70cc98d580c6e996b64b7c16cdb4dd4562cb0f75da36ee7 +aaeb43aa472aac2253e211fd1066c3a5422ea041cef20168702d0618a1a742a44f7fb30a76677640fea1a24e7fae1996 +a8820e92825d6e02b9b4ad5ebc86161d3244cddd3d244333ba1576b6ae10948145b68d9e926bf6b7a2c25dab4cf43f3e +8ffdae28a1f1d15d7ffa473628a66ee9a739073f59ba781248286b39cb8f7255f66d62337064246713cbb5017e615174 +adfc5dd142b7911326d8424881d5d92006f3b17de4cce91674d6ea37f00fbb266c791ac13f6c7a0f61d04f2a952e6a04 +87f98982444bf661f539bec73a10256f079a4baa88a1cea0351ae3de929e1c500485b2d1b5d933063cd7d9123d5050e4 +8f217ba4dd404c5ee384f0c9a126686db001ff0344c01c82174c5e5ef89d1a241b146008c534b13a0da6c8afe7450fbb +afc85476dddaf1cbb4ba8b22186789f3818c7964f9f613e55010278800cd95422702248bdf9c73760702ef24854795ec +a59e0f6ac2ccdfbd01f002008034390c0ea78716f5e0de4e474e3558755705c9c7afb6e3c5c4370e7bbc85958a9c7a63 +97c0695c58d792ec31d9b86d3b2fc1382f0855057b24d5f6a54c41f76f9e2f52882cadc89a8b2f121530e7f1393faa95 +8e49112de0b2649c08a96cf737af68fa8055f1af594846a2d0534c94df6f926f200405edaa6e6ac9db7e380707a2571d +99a1bd83a7ac5f8d77ddf044c80ebfc5745b998714696d67b94d185c97e9d6db989bacac646d9def463127a8b2febc00 +aba80725f9f9f7abe10760eca73ba427ca8df864a157122eb9af828a05b0199de3add02019a297750bdab5380e505c58 +ae18f62573275c1eb268f74c5e54e8958547f9e7d1d36a05b084eb53e5704fafe2200b8aff95cc7e9af5be2391c42b7c +908b8031d09d22b2aefeaa876a998e0a97c7a1070aad9e9c97836cc5aa6d2d5ef94230e1222074837b5e21b4e6490f01 +b3132282e8b41ca6789ec5c43c1fecf3a65b8eefbc2f3d10f746a843b9ba4ce6db664678e75e424f7b11a00c1440de15 +a1eb49440cc106ebc09cf198c93e8070271eb5a936d31c04858a2b311a037350100c7957d5545c9653f396aa968b91f4 +81df6ad1bdd5eee4cc2f94318467b8602d15cc1be2b48b09ade12cc46ee05cbaaf77a20397e5015030b1f1db5dd9dac0 +87236c68a2a93c8442d15d7f1d1dc01d1fd123439c183e1d843f4ddd2bcf638c128f66f1ef9b710e5d1f64a52726007a +84f2e7f85563bb2f61b10a712c7605d63f79af5be0dba056814fd3efebc20e9c53227c56577b72c68d185571b775eff6 +a36d4ae06688ece2927aeb2c7f058a3cd2aa1de1601282d4e688e1d76ef20728b892928deda2314eba41675eba3912f1 +b8326dcbcdcfce017b263c456c47692fb476c4225c95981666fff0b7d4522fc23b7f12273f0f47cf0442662124e6648f +84c66463ab277cda2cc7007d0509269e89cdd41c5e0d3773a92615f0fc5da63811186b05d7a11088048a5d4834a7e0df +b20d3571d970712ef4699b0e7034fd269c361f53e1572e2ea2676b4245e992d43b8b5931a801439a44d977a988cc360b +94dba6007e6d4998ca1eb84aa8e2a7e9f5c164b9d80df2825f2208ce5640a05aacac2e4f08918268990f43ae1ccab69a +a1c25f0b3ef9d1982153207570d9ce8d692e1b6963b509958dc4d9bcd80074bb221c46804a6d9a29e76149cc7787c282 +8857748fcdab1199fc96084323a81d3bd8b5a7f0b1abc5bc3b5252a19268344e2e7d2d086c90fc9b5fa4b92feedb93a4 +8b9c1d841447354b6c086549e4d1d435ab64c13933488c34bc30f0f6eb36c5c5b838b7b6bb018542247edd1ada091045 +8f5b655416da0e719a204fc567e93792c301acb4374cf7bbabc6ce51dbeaaadfd75c2db0e16ce073ab8e91fd3d7ea9d4 +90f2846b19be46a75c5cd0cafefcf9192e6fd80c479e8d6320c4b8d8d7d96703c9e77ff31a67afa9858e6b7bde1f7cce +a53e383947fd98aa1a55ac956214b46b20a52758461e8ba41341a23a835ebb713038bf048edb1202bbfd0b56a96bf292 +9542d7debbcfb9cda6fa279c699a7b655c03b9a9b456a5d3cfc41a826c94eafa43e01155a29e39ff0bcd965f4c0c512d +a43792864ec5fc549f7afc02622454afc0e425c310c4039ba615067243ebb26a4c7ebfd19bd4d57ff412a4bb2a7958a0 +b85123950e30c048465bf32365d24a5d4b21fffc6183cdbf71643a07b87463989b72dd9a6a47f134856f704909a6b38f +944ea689aec1376f855c0bc9c51378ad06ff758a2c075b95a60b535b88b36eca0be11e4edb5152e98cb2137d6e749f27 +a6bef52cda22325e4c62d323e2a0e3fa91c5552fcfce951edfd52ad6f652bfdcc2341f1cd349e6b5d447924dc569bfe2 +b56bff8ffe981bfcb30791836da10b87f2ccbe17ed969e7f7a650af07d27ae0223805b1264d985148208483be50578a6 +8b209cac898dd580c82d854a553e2517497ad1a4cd198e1360b8b50639b380aee70ee4b87625d9b2278228ff644cd25c +877cce233fec74c7158b3c5bf108365e98238418b8a71f058f1aca44a0fd3a1021e3e9025bd11fe244d9fe0f5034ce7f +b1b871aeedb03d6f6accc99816b89f5958178738d8d8cd9717527d04363c80fdb5f6848122ae19fdbc450cfa11e753c8 +858aca51b9e5b0a724e88688d5124eb24c9faf01a3d465e74d31de6da315f311143f22f60201ea09f62c92f61f09d889 +8521d409615dfc8c8289e00f6aaa6297c2c4e1439b25952afd76aac641b81c70b9cef07cd58c1c0198382bddd2bd8544 +88647c3e41666b88acca42505f1f5da226937e0522b538fe0cebb724e9a99730ca2522989e94a96cac94109aef675c0f +b417fdaf719caf38854e89ce52031b30ce61a632e6c3135adec9002280e022d82ab0ea4ac5ebdb21f1f0169e4c37bcda +9367a6feb5e23ea2eab8ddd5e7bdf32b4d2419fad1c71a1ed327b77362d8942dad971a1c2e6f7073885149cdf0a0c339 +a71c5c08d50c57d094d6a4f02e97d3799bada92f238ffc07bd223bbe8379507b7310d20b28f5bbbf331e5e153515e491 +9630a9a3bcb044b51299c4d3d3388a4ff47308dd27be3229601985478c0f6b55faa7e20815d8694f910611396a9d0d45 +b0bfaf56a5aa59b48960aa7c1617e832e65c823523fb2a5cd44ba606800501cf873e8db1d0dda64065285743dc40786e \ No newline at end of file diff --git a/infrastructure/kzg/src/testFixtures/resources/tech/pegasys/teku/kzg/trusted_setups/broken/trusted_setup_g2_bytesize.txt b/infrastructure/kzg/src/testFixtures/resources/tech/pegasys/teku/kzg/trusted_setups/broken/trusted_setup_g2_bytesize.txt index e6cb9fe06a4..690eb25f31e 100644 --- a/infrastructure/kzg/src/testFixtures/resources/tech/pegasys/teku/kzg/trusted_setups/broken/trusted_setup_g2_bytesize.txt +++ b/infrastructure/kzg/src/testFixtures/resources/tech/pegasys/teku/kzg/trusted_setups/broken/trusted_setup_g2_bytesize.txt @@ -1,4163 +1,8259 @@ 4096 65 -8d0c6eeadd3f8529d67246f77404a4ac2d9d7fd7d50cf103d3e6abb9003e5e36d8f322663ebced6707a7f46d97b7566d -a0d2392f030681c61c2a867862917e10f7678d882034bb89af3db87e6ab3883a304034643dc9688a04e41a5b831582bc -94298073048d70c74f36685e547d04b7311479daa05912e18ead64b2099a194bf48ec344273d58daf0b86b1d8f1d318d -85c4063d13499013dc2ccaa98c1606763e6b1e8cca20922d4cec12ecbaf006ea81ffabe6596d1ac7ba1daf7e63e30898 -84c64bce36c6b5145c6880113366025ab9a8f88e3948d374e27be8b8f9f87402c70fec9b3c621a2d1d26764a84370d0c -8b206c823acf5294552ee54579fac0f45ea15bd273dbacd63b88cd7cddbcce23b56e52f8ea352e1e1d7dcd9b3991b413 -b70aaa4038ba3f5ff306c647b4392d004950c53ad8f6713b5c9c21ac99f5c56cf57323dac500a1f4e9507c4746b07a2f -895f6d1fc70b52f838d81b24f4840729cd5988b649e9d6e6f6dbac4281d8818f39ebdae7e6ea139d7f98a832bd6f29f1 -a71a2832bbaade974c9ef7505dfa24e1ba466a9951b7c2db56886be31c9c7b871f3ee76cb1fcc1aab4b906d6502bc9b5 -9530ba64a21e27834609c00616bc63e8fc2dc7800e478ad728ec39c624f65bbc62cb48f59decb7fbf605ce1920d02622 -8d0609affaf8619bb2f6c80699e5bc7783becbd5973630cdd227ae52d6d701c45f4270becca97701b40279fab588cf64 -8f5d5b4c3bb8dc9a19e5a0f84df6322a79a00c7783c86254197d313a5b35d3965a1f7c0b9c4e39ec1e8f5d02d3aa0862 -96aa47a3ba20b1cfe81eb26bef503225037fdf4c9df53bea1b520841875cd1db6aa8e0f34685da08b55a3ce7289e6de0 -b4c27ee3f4b8c0031837160f0a75632f5b51b5850d52b530096443f54c2b264aeccc5c61b4fcc8de7074475f354fa0d8 -acfd735cda20be1d6f425a7886629c91732fbb5a4e0350ca740a8fb5b39f2001071cec0b2a0f6ca35e1f35a5ea18d00f -ae44d87b1d16d59504c602cbacde2c2791f1520391ca50154e6036d3953ca466cf93d6537da2adb729e6f9f4ffa87853 -97b492872ce44941ea4668ffca83b82fac0f4021bd47e0a5ffeaaacb1b3fc924ee4d53b99f7bcafe0985caf0fbe5d1d3 -b3fbe2f9103d293f49c6c6016d5913f041c9113295397388111a0fdf4245d8edd6e63b9a1a1c9c8f868d6e1988116880 -805efa08fd2046c44c427b225c17bed8a1eb3320cdf94026fdc24c6d345a6cfebfd7475f85d2d1bf22018ca72d2761d3 -9888bae0d83077d1dfde82fdffb1195565c31c519b80cba1e21aba58ee9ccb5677f74bfde13fa5723026514a7d839661 -922e19d2646ba90c9f56278bddf74621cc4518ae2f042fb8245843e87cd82724c6d7c9a99907ac6de5f2187fd2e77cbe -a38f0e1faf97dd1e0804b44e4d150dbfa48318442d1c5255eb0c14ea56b50502f3c7cb216a0336e7c140398088dc01cf -93598ea391c8735799a1d4cd0456f34994ccdf4883fad57419f634f30fee595938bc66b066dade9ae52578818c00d899 -a528dc920734cfaee9feacbc0baa5b73befb1ec6fbd422fcad09a9c1f8f8c40b5ea332b2cf04dc1d6d921e9da9ddfeb4 -b38d45316bf78d11e796a34ee535814e6cde0e642f14108329c5b21f4fec18cd61f84a3025824bb8dc4cbd26b2ecc9bf -8eec35a7404c9a35dc6ad0260b7f0f7fd1bfe92a2e08bc72548b99ed9acdc378728a8ea9c6879a6e47e37edb0d28c193 -a68a4446274ccd947c61bf736c5219dad680b99c6085a26719793e0d9dab26d5f8a0b28e71be6e1b9ea4ae39139f7f57 -a0acb543f41ad12e3b2e096629ccdd719a001d0ff53bb151e9a37aa57852f7275a7bbd06dc2a06af9144524548164af5 -b271e74cdbcf8b9143f8472174bdb068c23308ea807c60a554c185f7be6f231aac13347139837514171a876dfac5baa5 -8195a460719000cd1df379ebbf7918f71301a50a2fa587505cc5b8c4534c3d2343f63d28e7ee991d7a1cebb15d380696 -96202b60426773e8731dcbedbf613477f65940a19fb4be0f4f742b0c76ae9d88ecdb6d36cd4f12bb404dd5d360c819e2 -b0a80fe60b71ca9e80157138de8787b8a786326179604b8a15a744e52662645987e5f859ef5c76492d560daf4624b9a7 -a331ea8adf87daa5e2d458d0113c307edae1a84927bca7d484aca5f8c1b6378ab42981c44b0d916d7249f4b475f926f1 -aa1a8f59ae0912abf191ea7e209ff401628278dfb2269db6d87cf33bd52af3dbffbe96513a8b210e965c853a554b787a -ac4f4a0e1b1a155e1f22a9085b0b047fe54c8437dbbb8e9720fd6b0cdd76557d19ca2e885a48890f0247b1a72be0e287 -a428465505eac7b9660eb0d495a7a00c8cc238de3a02ebbd2eb07e502e9868086e9584b59953cf1480c0b781295db339 -b7b77e21e08f6357cbd3dcd3035c3e8ec84cdfa13c7baef6c67e0ef43095e61fd549694263d7def8b8adc3a0fdcc7987 -abb991d17c5bdd264c592c55101e265cb3210c4157aee4079173fd51da1e0199eed1d6c890aab95817ec078561d771af -846a8e4f801faf5fbec078b09c362ee30a00b2b58a4871744d03cd118b913464233ff926e52b0c75fbfcf098ad25a1e6 -947e91ffa32f38c1ccb72cca4bfabaee9e63ab74a16f034cabba25e462f7331ebe5a7ba393f69e91830415fa75b1b52e -8dc5e26adc693f4e300cab7385edca1a2fe14c8ee6dc0cd6d013cb5aa154dc380e9e81e259cbc59c1f38f7c4a57f1c7d -9818ef6605d6ea3b7bf4da5c6d6d8ed540bb94df4d14c974e1b79ed2fd1a0b897b8cf1ff671a181a697effd66b1644a5 -b5eab6baf03af994fc32cc9dce388394c18c01cdafe7909fde948f3e00a72dc8f30d15977d0f114bd7c140f5f94cf005 -83b2e9858d3b929f9a2ad66a91a2c0c44d15d288c17c12a1614301a6f2d61d31eaa540ca7781520fe4420afae0ec0208 -ab338fbd38bce4d1b7a759f71e5e5673746c52846eff3d0b6825e390aeeca8f9f123ee88c78fe4d520cc415cbae32bf1 -81adb6322b8db95d1711304e5b59f37640ca88c03e6c7e15de932be5267dff7351fa17664113ecc528e8920f5bfdc0d1 -89e2e0c0d769e4107232df741678a6bacb041d0154385450aaca8be9c3c18c42f817373962e7569d33935c35666a8a6a -8f0756fea8b34a2b471ec39e4448a6a6935e5432ec2859d222964a4c82777a340e1d702777aeb946fa405afc0438221a -a2bf90c505a6f03b3dd09d04e1e7cf301fe3415b273e263f15fdfe5d0e40f619b95e8bf00916d3eaa7d7f8c0bae41c8e -91d5c76b5542637588cd47279d0bd74a25dbda0d8ec0ff68b62d7e01e34a63fc3e06d116ee75c803864b1cf330f6c360 -a9958c388d25315a979566174b0622446335cb559aff1992bd71910c47497536019c6854d31c0e22df07505963fc44ff -91d82b09d5726077eed6c19bcb398abe79d87ce16c413df6bf5932b8fd64b4c0fd19c9bf0fa8db657a4a4d4c0d8f5a2d -ac6e0a86e0ee416855c3e9eef2526c43835f5245527ed0038bc83b4fcadb4ea5beb91143cc674486681a9f0e63f856b1 -aaf00d6efd0c6efb9f7d6a42555abec05c5af8f324e2e579fc2ac83bdc937cc682d9bc2ffd250619c8bb098b8c84db80 -963f5fcd8476d0dbeb03a62cde40e3deee25f55e7ded7572d8884975f38eddc5406fc4b0adff602a1cca90f7205a7fdc -a3805ee01512f644d2679511bd8607890ee9721e75ac9a85ab9fd6fceb1308d5b9b0e9907686b4e683b34aed0f34cd81 -a483d7708465cd4e33b4407fe82c84ef6bc7fa21475d961fe2e99802d0c999b6474ef7a46dd615b219c9c7e9faec45ee -b6b5f9456f12d6781c41f17cdc9d259f9515994d5dee49bb701a33fa2e8dcbb2c8c13f822b51ad232fc5e05bff2f68ef -8766b721b0cf9b1a42614c7d29aad2d89da4996dc9e2a3baeba4b33ca74100ab0b83f55c546c963e3b6af1dcf9ca067c -ac5e8da1154cf4be8df2bbd2e212b7f8077099b2010c99e739441198f65337c6f7ef0d9136453a7668fde6e1389c32c7 -a9d6d2c8845e5f1fec183c5153f1f6e23421e28ce0c86b0ce993b30b87869065acad9e6d9927d9f03c590852821b2f9c -a320ca07c44f7ea3ff858fe18395a86f59559617f13ec96d1e8b4a3f01d9c066a45c8d8cf8f1f14a360bb774d55f5f18 -b3adb00e1312dce73b74fbd2ea16f0fb0085bd0db10772e9c260e9ed9f8829ff690e3dfffacaddc8233d484bb69778b3 -87b0c8d8a167d5199d0b0743c20fb83ec8a1c442f0204bcc53bf292ba382bef58a58a6d1e2467920e32c290fdc6dae7c -a74fa436a5adc280a68e0c56b28ac33647bdfc8c5326f4c99db6dbd1b98d91afb1f41f5fffd6bcc31c1f8789c148e2db -8a37349e4ba7558965077f7f9d839c61b7dcb857fcc7965c76a64a75e377bfea8cd09b7a269ce602cc4472affc483b69 -8af813f62c5962ff96bf73e33f47fd5a8e3e55651d429e77d2ce64a63c535ecc5cfc749bb120c489b7ea1d9b2a5d233c -833021445b7d9817caa33d6853fa25efc38e9d62494d209627d26799432ea7b87a96de4694967151abc1252dd2d04dfc -8f78a715107e0ace3a41bff0385fd75c13bf1250f9e5ddecf39e81bacc1244b978e3464892f7fb2596957855b8bf9fc7 -aed144134dc1cc6c671f70ebe71a3aadf7511eea382969bc5d499a678d2d8ce249ebf1a06b51183f61413eba0517012b -b39a53e82c5553943a5e45bc5116d8672ec44bed96b3541dead40344b287a7b02dbf7107372effb067edd946f47de500 -b383844c3b20a8bc06098046ec6b406df9419ad86fac4a000905c01325426903a5e369af856d71ccd52fea362ed29db5 -83815a7098283723eec6aa6451b5d99578bf28a02971375a1fe90c15a20963e129372ac4af7b306ee2e7316472c5d66d -b426b4e185806a31febd745fa8d26b6397832a04e33c9a7eb460cbf302b4c134a8a01d4e5e40bc9b73296c539e60b3ca -a6cabf8205711457e6363ef4379ebc1226001e1aaea3002b25bfd9e173f4368002f4461e79eeb9f4aa46f1b56c739ab9 -a6e88ab01282313269cd2d8c0df1a79dada5b565d6623900af9e7e15351de2b0105cc55d3e9080e1e41efe48be32a622 -b2b106db3d56d189ea57afa133ae4941b4eb1dc168357af488e46811c687713fc66bbd6f8500bbd13cdb45cb82c14d1d -b3a74780ff949d19e6438db280e53632c60dc544f41320d40297fe5bb7fcee7e7931111053c30fb1ed9019ab28965b44 -8c67f32b9fdc04ec291cc0d928841ab09b08e87356e43fbbf7ac3ff0f955642628f661b6f0c8e2192a887489fddf07bb -b3be58bd628383352e6473fe9a1a27cf17242df0b1273f5867e9119e908969b9e9e7e294a83b9ea14825003cb652d80c -a867acf6ab03e50936c19a21d4040bfd97eb5a89852bd9967da0e326d67ce839937cab4e910d1149ecef9d5f1b2d8f08 -8006b19126bd49cbb40d73a99a37c2e02d6d37065bbe0cfcee888280176184964bd8f222f85960667c5b36dfaee0ee35 -ac50967b8b7840bf9d51216d68a274f1d3431c7d4031fbac75a754befbbb707c2bb184867db6b9d957f3ba0fd0a26231 -b5a794c928aff0c4271674eb0a02143ed9b4d3bc950584c7cd97b7d3c3f2e323798fd5ccc6fcc0eb2e417d87f4c542a2 -a2ca3d6509f04b37091ce6697672ee6495b42d986d75bd2d2058faa100d09fd0a145350f2d280d2cb36516171bd97dbf -92cfa293469967a9207b37cd70392312faf81b52963bfbad5f9f3da00817d26e10faf469e0e720c3bb195f23dda8c696 -a0dd5135da0a0e33fa922c623263b29518d7fa000e5beefc66faa4d6201516d058f155475c4806917a3259db4377c38a -8fc3ae8ea6231aa9afb245a0af437e88ebca2c9ab76850c731981afba90d5add0ea254053449355eccf39df55bd912ed -9727afe1f0804297717cec9dc96d2d27024a6ae6d352fee5d25377ee858ee801593df6124b79cb62ddc9235ec1ade4ac -8bcb2c53fcaa38e8e2e0fd0929bc4d9ddce73c0282c8675676950ff806cb9f56ebd398b269f9a8c2a6265b15faf25fca -a8bd9007fbbdd4b8c049d0eb7d3649bd6a3e5097372fa8ea4b8821ba955c9ef3f39ac8b19f39d3af98640c74b9595005 -92c7e851c8bd6b09dfcbfdb644725c4f65e1c3dbd111df9d85d14a0bb2d7b657eb0c7db796b42bf447b3912ef1d3b8c3 -98c499b494d5b2b8bea97d00ac3a6d826ab3045bb35424575c87117fc2a1958f3829813e266630749caf0fa6eeb76819 -8df190d71e432fe8691d843f6eb563445805c372eb5b6b064ec4e939be3e07526b5b7f5a289ede44ae6116a91357b8b1 -b5010243f7c760fb52a935f6d8ed8fc12c0c2f57db3de8bb01fdeedf7e1c87b08f3dd3c649b65751f9fd27afa6be34c7 -889c8057402cc18649f5f943aed38d6ef609b66c583f75584f3b876c1f50c5dc7d738dc7642135742e1f13fa87be46c1 -996087337f69a19a4ebe8e764acf7af8170a7ad733cd201b0e4efde6ea11039a1853e115ad11387e0fb30ab655a666d8 -902732c429e767ab895f47b2e72f7facad5ef05a72c36a5f9762c2194eb559f22845bbb87c1acc985306ecb4b4fbbf79 -8519b62a150ea805cdfc05788b8d4e797d8396a7306b41777c438c2e8b5c38839cfec5e7dc5d546b42b7b76e062982a7 -862a53ba169e6842a72763f9082ff48fbfbb63129d5a26513917c2bca9ad6362c624ce6fc973cf464f2eb4892131eb04 -b86cd67c809d75fdb9f1c9453a39870f448b138f2b4058d07a707b88bb37f29d42e33ce444f4fbe50d6be13339cae8a6 -8cf5d8365dbbafc0af192feb4fc00c181e2c3babc5d253268ef5564934555fb1e9b1d85ec46f0ca4709b7d5b27169b89 -b48f11a1809ec780bf6181fae3b8d14f8d4dc7d1721128854354be691c7fc7695d60624f84016c1cea29a02aaf28bfbc -8b46b695a08cb9a2f29ab9dd79ab8a39ec7f0086995b8685568e007cd73aa2cd650d4fae6c3fb109c35612f751ba225e -8d2f9f0a5a7de894d6c50baceb8d75c96082df1dcf893ac95f420a93acbbf910204903d2eb6012b1b0495f08aaf9992f -b334db00a770394a84ec55c1bd5440b7d9f2521029030ef3411b0c2e0a34c75c827fd629c561ea76bd21cd6cf47027f4 -96e9ff76c42bcb36f2fb7819e9123420ed5608132f7c791f95cb657a61b13041e9ba2b36f798a0fdb484878cbe015905 -99f8d701e889abd7815d43ba99e0a85776ec48311fa7cb719d049f73b5d530fa950746ffbbb7beb9e30c39d864891dc2 -98169c20df7c15d7543991f9c68e40ac66607cbd43fc6195416e40009917039357e932d6e807f3a40bc4503ad01ae80a -84bd97dd9e4e2ba75d0dee7d4418c720d4746203d847ce2bdd6ed17d492023df48d7b1de27e3f5cb8660c4bb9519ae1b -a54319e06db7f5f826277a54734a875c5b3fd2fa09d36d8b73594137aa62774b7356560157bc9e3fdf1046dc57b6006a -90cfff7cd4e7c73b84f63455d31b0d428cb5eee53e378028591478511985bcc95eb94f79ad28af5b3bed864e422d7b06 -a11c23cc8dce26ac35aea9abe911905a32616a259fa7da3a20f42dc853ad31b2634007aa110c360d3771ff19851f4fb4 -9856fbee9095074ad0568498ff45f13fe81e84ea5edaf04127d9ee7e35e730c6d23fa7f8f49d092cf06b222f94ab7f36 -818862dec89f0dc314629fffbca9b96f24dfde2d835fa8bde21b30dc99fe46d837d8f745e41b39b8cf26bfe7f338f582 -831819d41524c50d19f7720bf48f65346b42fb7955ee6ecc192f7e9fed2e7010abccdfdeac2b0c7c599bc83ac70be371 -b367e588eb96aa8a908d8cc354706fee97e092d1bc7a836dbcc97c6ed4de349643a783fb4ddf0dec85a32060318efa85 -b7aaef729befd4ab2be5ec957d7d1dbe6178de1d05c2b230d8c4b0574a3363e2d51bc54ea0279a49cc7adffa15a5a43a -ae2891d848822794ecb641e12e30701f571431821d281ceecbccaaa69b8cd8242495dc5dbf38f7d8ed98f6c6919038aa -872cf2f230d3fffce17bf6f70739084876dc13596415644d151e477ce04170d6ab5a40773557eeb3600c1ad953a0bfce -b853d0a14cef7893ba1efb8f4c0fdb61342d30fa66f8e3d2ca5208826ce1db5c8a99aa5b64c97e9d90857d53beb93d67 -910b434536cec39a2c47ca396e279afdbc997a1c0192a7d8be2ba24126b4d762b4525a94cea593a7c1f707ba39f17c0c -b6511e9dea1fbccedd7b8bb0a790a71db3999bd4e3db91be2f1e25062fae9bb4e94e50d8ec0dcc67b7a0abce985200b2 -936885c90ebe5a231d9c2eb0dfd8d08a55ecaa8e0db31c28b7416869b3cc0371448168cbec968d4d26d1cb5a16ebe541 -b71c2ac873b27fe3da67036ca546d31ca7f7a3dc13070f1530fce566e7a707daeb22b80423d505f1835fe557173754f8 -85acb64140915c940b078478b7d4dadd4d8504cde595e64f60bd6c21e426b4e422608df1ed2dd94709c190e8592c22d7 -b5831c7d7c413278070a4ef1653cec9c4c029ee27a209a6ea0ad09b299309dea70a7aef4ff9c6bdeda87dcda8fa0c318 -aa0e56e3205751b4b8f8fa2b6d68b25121f2b2468df9f1bd4ef55f236b031805a7d9fd6f3bba876c69cdba8c5ea5e05f -b021f5ae4ed50f9b53f66dd326e3f49a96f4314fc7986ace23c1f4be9955ec61d8f7c74961b5fdeabcd0b9bccbf92ce8 -88df439f485c297469e04a1d407e738e4e6ac09a7a0e14e2df66681e562fdb637a996df4b9df4e185faab8914a5cef76 -8e7ae06baa69cb23ca3575205920cb74ac3cda9eb316f4eef7b46e2bff549175a751226d5b5c65fe631a35c3f8e34d61 -99b26ff174418d1efc07dfbed70be8e0cb86ac0cec84e7524677161f519977d9ca3e2bbe76face8fe9016f994dafc0ff -a5f17fe28992be57abd2d2dcaa6f7c085522795bfdf87ba9d762a0070ad4630a42aa1e809801bc9f2a5daf46a03e0c22 -8d673c7934d0e072b9d844994f30c384e55cec8d37ce88d3ad21f8bb1c90ecc770a0eaf2945851e5dab697c3fc2814a9 -a003ed4eb401cfe08d56405442ca572f29728cfff8f682ef4d0e56dd06557750f6a9f28a20c033bc6bbb792cc76cc1a8 -8010408f845cf1185b381fed0e03c53b33b86ea4912426819d431477bd61c534df25b6d3cf40042583543093e5f4bb44 -9021a1ae2eb501134e0f51093c9f9ac7d276d10b14471b14f4a9e386256e8c155bef59973a3d81c38bdab683cd5c10e0 -a5abf269ceabbb1cf0b75d5b9c720a3d230d38f284ed787b6a05145d697a01909662a5b095269996e6fa021849d0f41f -b4b260af0a005220deb2266518d11dbc36d17e59fc7b4780ab20a813f2412ebd568b1f8adc45bf045fcbe0e60c65fd24 -b8c4cb93bedbb75d058269dfccda44ae92fe37b3ab2ef3d95c4a907e1fadf77c3db0fa5869c19843e14b122e01e5c1f4 -ac818f7cdecc7b495779d8d0ff487f23ab36a61d0cf073e11000349747537b5b77044203585a55214bb34f67ef76f2d2 -86215799c25356904611e71271327ca4882f19a889938839c80a30d319ddbe6c0f1dfa9d5523813a096048c4aef338cd -a9204889b9388bf713ca59ea35d288cd692285a34e4aa47f3751453589eb3b03a9cc49a40d82ec2c913c736752d8674d -893aecf973c862c71602ffb9f5ac7bf9c256db36e909c95fe093d871aab2499e7a248f924f72dea604de14abfc00e21c -b8882ee51cfe4acba958fa6f19102aa5471b1fbaf3c00292e474e3e2ec0d5b79af3748b7eea7489b17920ce29efc4139 -8350813d2ec66ef35f1efa6c129e2ebaedc082c5160507bcf04018e170fc0731858ad417a017dadbd9ade78015312e7f -83f6829532be8cd92f3bf1fef264ee5b7466b96e2821d097f56cbb292d605a6fb26cd3a01d4037a3b1681d8143ae54d7 -87d6258777347e4c1428ba3dcbf87fdd5113d5c30cf329e89fa3c9c1d954d031e8acacb4eed9dca8d44507c65e47e7cd -a05669a1e561b1c131b0f70e3d9fc846dc320dc0872334d07347e260d40b2e51fdbabeb0d1ae1fb89fba70af51f25a1a -819925c23fd4d851ea0eecc8c581f4a0047f5449c821d34eccc59a2911f1bd4c319dab6ece19411d028b7fdedece366b -b831b762254afd35364a04966d07b3c97e0b883c27444ff939c2ab1b649dc21ac8915b99dc6903623ed7adaae44870ac -93ec0190f47deffe74179879d3df8113a720423f5ca211d56db9654db20afe10371f3f8ec491d4e166609b9b9a82d0d4 -8f4aa6313719bcfad7ca1ed0af2d2ee10424ea303177466915839f17d2c5df84cc28fcef192cbb91bb696dd383efd3b2 -8d9c9fdf4b8b6a0a702959cf784ad43d550834e5ab2cd3bebede7773c0c755417ad2de7d25b7ff579f377f0800234b44 -99d9427c20752f89049195a91cf85e7082f9150c3b5cb66b267be44c89d41e7cc269a66dacabacadab62f2fa00cc03be -b37709d1aca976cbbf3dc4f08d9c35924d1b8b0f1c465bd92e4c8ff9708e7d045c423183b04a0e0ab4c29efd99ef6f0e -a163f42fb371b138d59c683c2a4db4ca8cbc971ae13f9a9cc39d7f253b7ee46a207b804360e05e8938c73bf3193bab55 -87a037aa558508773fc9a0b9ba18e3d368ffe47dfaf1afacee4748f72e9d3decc2f7c44b7bf0b0268873a9c2ef5fe916 -a1f20cb535cc3aebd6e738491fe3446478f7609d210af56a4004d72500b3ec2236e93446783fe628c9337bcd89c1e8e1 -9757aa358dfbba4f7116da00fe9af97f7ac6d390792ea07682b984aa853379ac525222ac8a83de802859c6dec9182ef7 -815daca1eded189ec7cb7cbc8ad443f38e6ddb3fb1301d1e5a1b02586f1329035209b7c9232dc4dff3fc546cb5ac7835 -aed86dfaf9c4f0a4b2a183f70f9041172002a773482a8ebf3d9d5f97d37ee7c6767badfda15476b3b243931235c7831c -8d032e681e89e41b29f26be02f80030fa888f6967061d2204c1ebb2279a3211d759d187bce6408c6830affa1337fb4e0 -877bff5c2db06116f918a722b26422c920aeade1efa02fa61773fca77f0ea4a7e4ee0ecaaa5cfe98044c0ff91b627588 -b9ee5310d0996a10a242738d846565bdb343a4049a24cd4868db318ea6168a32548efaf4ab84edfbf27ce8aec1be2d1c -b59f6928167323037c6296dd7697846e80a7a4b81320cfae9073ebd2002a03bdf6933e887f33ad83eda8468876c2c4fb -8167686245149dc116a175331c25301e18bb48a6627e2835ae3dd80dd373d029129c50ab2aebeaf2c2ccddc58dcc72ec -82b7dcc29803f916effb67c5ba96a1c067ed8ca43ad0e8d61a510ab067baefd4d6b49e3886b863da2de1d8f2979a4baa -b43824cd6f6872a576d64372dde466fef6decdbb5ad5db55791249fde0a483e4e40c6e1c221e923e096a038fe47dab5e -ab1e9884cf5a8444140cf4a22b9a4311a266db11b392e06c89843ac9d027729fee410560bcd35626fd8de3aad19afc4a -a0dbd92a8d955eb1d24887ca739c639bdee8493506d7344aadb28c929f9eb3b4ebaae6bd7fd9ffe8abb83d0d29091e43 -8352a47a70e343f21b55da541b8c0e35cd88731276a1550d45792c738c4d4d7dc664f447c3933daabd4dbb29bb83be4a -8ce4a1e3c4370346d6f58528a5ef1a85360d964f89e54867ba09c985c1e6c07e710a32cdda8da9fa0e3b26622d866874 -b5e356d67dd70b6f01dd6181611d89f30ea00b179ae1fa42c7eadb0b077fb52b19212b0b9a075ebd6dc62c74050b2d2f -b68f2cd1db8e4ad5efdba3c6eaa60bfcc7b51c2b0ce8bb943a4bc6968995abe8a45fe7f12434e5b0076f148d942786be -b5c7b07f80cd05c0b0840a9f634845928210433b549fb0f84a36c87bf5f7d7eb854736c4083445c952348482a300226a -8cfd9ea5185ff9779dee35efe0252957d6a74693104fb7c2ea989252a1aa99d19abaab76b2d7416eb99145c6fdb89506 -8cc8e2c5c6ddee7ef720052a39cab1ecc5e1d4c5f00fb6989731a23f6d87ac4b055abb47da7202a98c674684d103152a -8c95394c9ed45e1bf1b7cfe93b2694f6a01ff5fed8f6064e673ba3e67551829949f6885963d11860d005e6fabd5ac32c -adf00b86f4a295b607df157f14195d6b51e18e2757778fde0006289fabba8c0a4ab8fad5e3e68ddbb16ccb196cc5973f -b1714b95c4885aac0ee978e6bbabbc9596f92b8858cb953df077511d178527c462cbe1d97fdc898938bae2cd560f7b66 -adf103f4344feb6b9c8104105d64475abc697e5f805e9b08aa874e4953d56605677ef7ff4b0b97987dc47257168ae94d -b0ce6ede9edb272d8769aed7c9c7a7c9df2fb83d31cc16771f13173bcdc209daf2f35887dcca85522d5fdae39f7b8e36 -ad698d1154f7eda04e2e65f66f7fcdb7b0391f248ba37d210a18db75dafd10aedc8a4d6f9299d5b6a77964c58b380126 -904856cd3ecdbb1742239441f92d579beb5616a6e46a953cf2f1dd4a83a147679fc45270dcac3e9e3d346b46ab061757 -b600b5b521af51cdfcb75581e1eccc666a7078d6a7f49f4fdb0d73c9b2dab4ce0ecafcbd71f6dd22636e135c634ee055 -a170c5d31f6657f85078c48c7bbf11687ce032ab2ff4b9b3aee5af742baecf41ea1c2db83bcba00bccc977af7d0c5c8e -a9ef1cbb6a7acb54faf1bcbd4676cdeba36013ca5d1ac1914c3ff353954f42e152b16da2bdf4a7d423b986d62b831974 -aa706d88d3bd2ce9e992547e285788295fd3e2bbf88e329fae91e772248aa68fdfdb52f0b766746a3d7991308c725f47 -911a837dfff2062bae6bcd1fe41032e889eb397e8206cedadf888c9a427a0afe8c88dcb24579be7bfa502a40f6a8c1cc -ae80382929b7a9b6f51fe0439528a7b1a78f97a8565ba8cddb9ee4ba488f2ab710e7923443f8759a10f670087e1292c4 -b8962de382aaa844d45a882ffb7cd0cd1ab2ef073bce510a0d18a119f7a3f9088a7e06d8864a69b13dc2f66840af35ae -954538ffff65191538dca17ec1df5876cb2cd63023ff2665cc3954143e318ece7d14d64548929e939b86038f6c323fc1 -89efa770de15201a41f298020d1d6880c032e3fb8de3690d482843eb859e286acabb1a6dc001c94185494759f47a0c83 -a7a22d95b97c7c07b555764069adaa31b00b6738d853a5da0fe7dc47297d4912a0add87b14fa7db0a087a9de402ea281 -9190d60740c0813ba2ae1a7a1400fa75d6db4d5ce88b4db0626922647f0c50796a4e724e9cc67d635b8a03c5f41978f7 -ab07c30b95477c65f35dc4c56d164e9346d393ad1c2f989326763a4cc04b2cb0386e263007cc5d0125631a09ad3b874c -9398d8e243147de3f70ce60f162c56c6c75f29feb7bc913512420ee3f992e3c3fb964d84ef8de70ef2c118db7d6d7fd5 -b161b15b38cbd581f51ca991d1d897e0710cd6fdf672b9467af612cd26ec30e770c2553469de587af44b17e3d7fea9f7 -8c5d0260b6eb71375c7ad2e243257065e4ea15501190371e9c33721a121c8111e68387db278e8f1a206c0cce478aaa2b -b54ac06a0fb7711d701c0cd25c01ef640e60e3cb669f76e530a97615680905b5c5eac3c653ce6f97ceca2b04f6248e46 -b5c7f76e3ed6dc6c5d45494f851fa1b5eaf3b89adac7c34ad66c730e10488928f6ef0c399c4c26cbeb231e6e0d3d5022 -b6cd90bdd011ac1370a7bbc9c111489da2968d7b50bf1c40330375d1a405c62a31e338e89842fe67982f8165b03480c7 -b0afcaf8d01f5b57cdeb54393f27b27dc81922aa9eaccc411de3b03d920ae7b45295b090ef65685457b1f8045c435587 -b2786c0460e5057f94d346c8ebe194f994f6556ab2904a1d1afd66c0ff36391b56f72ed769dcc58558ee5efaa2ed6785 -965dbb0cb671be339afcb2d6f56e3c386fb5d28536d61d6073b420ee15dee79c205af2f089fbb07514a03c71bf54b4e2 -90f2003e2286bba9cebff3a6791637ca83b6509201c6aed1d47f27097d383d5c2d8532bff9e3541d2c34259841cf26ab -902142d1224e1888ebbfef66aaf8d5b98c27927a00b950753a41d1d28a687a8286b51655da9a60db285b20dc81d5ea89 -a5d364448bf0d0849e5104bdaef9cb2cc8c555f5d6d34239c68671fbe1252f7c8c75b83cea10159dee4da73298f39a12 -b013a54c5b99e296d9419ad5c2aaf4545acd34405e57d13cb764e92132cc20d1a14b33e10caf22d898b608670c04f273 -b92976dceda373331804d48a7847f508cafde8d15949df53dbda09d03908678db1e61ee637baad5f05b2b03ea6f5a870 -968bcb308c7ad0813dc9b3170f23f419aecd7b42176f27fac698811795bf42659fea6b04dab4ef43595dcc990622041b -a9d0a20e9367ea831dccd37f4d97ea75e9aeec952947a7946d95e0d249c94024183ef79a624bdea782469824df0ee4e4 -8521b9667453c3658703e5db365b13f0e0d2331ce611ff1e708f8124d8a81bb5e82871de4a66d45c1a6b0a3901bd901e -b9c88e76e69b0722c0a2f97e57dbc4a6f7456434cd694e2ff67f4e24740cffa4db03e2b18f07f22954ae7db2286e1fa2 -8400e55aa9ab01d4cc0affd611127b5d8d9a9dbd897f3cb8e2050379983aa54249be17d7b7891977b2515bb44a483f65 -8cbb967b4ed31dc40ea06822a94d54cbfc8845c66fbafa3474c8f5fe1ada97299ed4ca955d9d7a39af8821eabf711854 -b4d266ee3fea264a6c563fd6bed46f958c2d7bd328225f6e47faf41a0916aef3b697574322f8b814dfb2f5c242022bf6 -8f7c72d69a919450215ead660ffa9637642c5306354888d549fd4a42e11c649b389f67cc802a0184d10fdb261351140c -a5f9e494ea9b2393ec32c48aac76c04158ccef436d4e70ad930cba20c55fbf61e8f239f70b9d75462405c4b6317c71a1 -b3befb259b52a44a6f44345859e315c20efa48c0c992b0b1621d903164a77667a93f13859790a5e4acb9f3ec6c5a3c6e -b9e4ca259b4ee490d0824207d4d05baf0910d3fe5561ff8b514d8aa5c646417ca76f36ab7c6a9d0fb04c279742f6167a -98fa8c32a39092edb3c2c65c811d2a553931010ccb18d2124d5b96debd8b637d42b8a80111289f2079d9ebca2131a6dc -a65e5aa4631ab168b0954e404006ce05ac088fd3d8692d48af2de5fd47edbf306c80e1c7529697754dbbba1b54164ba0 -b94b7d37e4d970b4bb67bf324ebf80961a1b5a1fa7d9531286ab81a71d6c5f79886f8ef59d38ae35b518a10ed8176dcc -b5ed2f4b0a9ae9ace2e8f6a7fd6560d17c90ae11a74fa8bef2c6c0e38bfd2b9dd2984480633bca276cb73137467e2ce3 -a18556fe291d87a2358e804ee62ddff2c1d53569858b8ae9b4949d117e3bfb4aefce1950be8b6545277f112bebeeb93d -a0d60b9def5d3c05856dff874b4b66ec6e6f0a55c7b33060cc26206c266017cdcf79b1d6f6be93ed7005a932f9c6a0b9 -801fced58a3537c69c232ce846b7517efd958e57c4d7cd262dbec9038d71246dafad124aa48e47fe84ecc786433747c7 -a5e9a8ea302524323aa64a7c26274f08d497df3d570676ecc86bd753c96a487a650389a85f0bc8f5ea94fe6819dc14e5 -a8a2963dc9238a268045d103db101adc3b2f3ab4651b7703b2fe40ece06f66bf60af91369c712aa176df6ed3d64a82fa -a4a8ff0a9a98442357bcdd9a44665919c5d9da6a7d7d21ccdbbd8f3079b1e01125af054b43b37fc303941d0a2e7baee0 -90ef893350f50d6f61ee13dfab6e3121f4a06a1908a707b5f0036cdc2fe483614de3b1445df663934036784342b0106f -84e74d5bc40aaab2cc1d52946b7e06781fbef9d8de6f8b50cd74955d6bdb724864c0e31d5ac57bf271a521db6a352bd6 -832cdf653bbbd128e2e36e7360354a9e82813737c8ab194303d76667a27aa95252756c1514b9e4257db1875f70f73eb4 -a0af8660ed32e6dbcc4d5d21b0a79a25ff49394224f14e6e47604cf3b00136de8f9ab92e82814a595bf65340271c16c3 -9040b5caf5e4dc4118572a2df6176716b5b79d510877bbb4a1211b046596899ea193be4d889e11e464ffb445ab71907b -b9bf8354c70238ab084b028f59e379b8a65c21604034d1b8c9b975f35a476e3c0ba09dd25bf95c5d8ffb25832537319b -a7b492cc1df2a8f62c935d49770d5078586bd0fefda262eb5622033e867e0b9dc0ffc2ce61cd678136a3878d4cbb2b56 -95a5ef06f38743bba187a7a977023b1d9d5ec9ef95ba4343ad149a7b8b0db0e8e528bfb268dc7e5c708bc614dc3d02c8 -99dcf7f123df6c55aeff0a20885a73e84d861ec95cf9208ba90494f37a2dcaacebc8344f392547d3046616d9753c7217 -b3e14f309281a3685ceb14f8921c1e021b7e93c9e9595596b9fb627e60d09ed9e5534733fcbdf2fbc8c981698f5e62ac -816a5e0463074f8c7fb2998e0f0cf89b55790bdbbb573715f6268afb0492453bd640dd07a9953d0400169d555fdf4ac8 -8356d68f3fe7e02a751f579813bd888c9f4edcc568142307d1c9259caef692800e1581d14225e3a3585dac667928fa94 -8d70ea3314c91bfc3f7c1dcf08328ae96f857d98c6aac12ad9eebc2f77e514afdbaf728dfcb192ed29e7ce9a0623ecbb -b68280e7f62ced834b55bc2fcc38d9ea0b1fbcd67cc1682622231894d707c51478ed5edf657d68e0b1b734d9f814b731 -b712dd539e1d79a6222328615d548612eab564ace9737d0249aa2eefed556bbcf3101eba35a8d429d4a5f9828c2ac1fe -8da42ca096419f267f0680fd3067a5dbb790bc815606800ae87fe0263cae47c29a9a1d8233b19fe89f8cc8df6f64697e -8cb2ffd647e07a6754b606bde29582c0665ac4dde30ebdda0144d3479998948dae9eb0f65f82a6c5630210449fbd59f7 -8064c3ef96c8e04398d49e665d6de714de6ee0fced836695baa2aa31139373fad63a7fc3d40600d69799c9df1374a791 -aec99bea8ab4e6d4b246c364b5edc27631c0acc619687941d83fa5ba087dd41f8eaec024c7e5c97cf83b141b6fb135da -8db6051f48901308b08bb1feb8fd2bceaedde560548e79223bd87e485ea45d28c6dcec58030537406ed2b7a9e94e60cc -a5b812c92d0081833dcf9e54f2e1979a919b01302535d10b03b779330c6d25d2de1f374b77fe357db65d24f9cbcd5572 -967d442485c44cf94971d035040e090c98264e3348f55deabd9b48366ec8fe0d5a52e4b2c9a96780a94fc1340338484e -a4b4110bef27f55d70f2765fc3f83c5ddcdfe7f8c341ea9d7c5bcee2f6341bcfbf7b170b52e51480e9b5509f3b52048f -a0d39e4eb013da967a6ac808625122a1c69bf589e3855482dedb6847bb78adc0c8366612c1886d485b31cda7304ec987 -a92f756b44d44b4e22ad265b688b13c9358114557489b8fb0d9720a35e1773b3f0fa7805ac59b35d119a57fe0f596692 -aa27e4b979af6742b49db8bf73c064afd83a9cfe9016131a10381f35a46169e8cfd1a466f295fcc432c217c7c9fa44a5 -845961319cc10bcfbb1f3cb414a5c6a6d008fb3aac42c7d5d74e892cc998af97bc9a9120c3f794e4078135e16a416e38 -a18dbe3015c26ae3e95034c01d7898e3c884d49cc82e71ddb2cf89d11cec34cc2a3dff0fafb464e8e59b82ce1a0a7a11 -a954aed6d7124fa5bd5074bd65be4d28547a665fb4fe5a31c75a5313b77d1c6fc3c978e24c9591a2774f97f76632bdde -8f983b2da584bdff598fcb83c4caa367b4542f4417cc9fa05265ff11d6e12143c384b4398d3745a2d826235c72186a79 -b2caa17d434982d8dd59a9427307dfe4416b0efc8df627dd5fc20d2c11046c93461d669cab2862c094eec6a9845990c6 -8c2baa5a97ee3154cce9fa24f6b54b23e9d073e222220fdd0e83e210c0058fb45ce844382828b0cb21438cf4cad76ee6 -b93437406e4755ccf1de89f5cbe89e939490a2a5cf1585d4363c21ae35b986cb0b981dec02be2940b4ec429cc7a64d4c -a90ac36c97b7ea2eddb65e98e0d08a61e5253019eeb138b9f68f82bb61cdbadf06245b9dfffe851dfa3aa0667c6ac4b8 -8bcdd7b92f43b721ddbfd7596e104bc30b8b43bdaee098aac11222903c37f860df29d888a44aa19f6041da8400ddd062 -98f62d96bdf4e93ed25b2184598081f77732795b06b3041515aa95ffda18eb2af5da1db0e7cfed3899143e4a5d5e7d6c -ad541e3d7f24e4546b4ae1160c1c359f531099dab4be3c077e446c82cb41b9e20b35fa7569798a9f72c1fae312b140b4 -8844a1471ff3f868c6465459a5e0f2fb4d93c65021641760f1bb84f792b151bc04b5a0421bbc72cf978e038edc046b8f -af895aebe27f8357ae6d991c2841572c2063b8d0b05a2a35e51d9b58944c425c764f45a3f3b13f50b1b1f3d9025e52ad -adf85265bb8ee7fead68d676a8301129a6b4984149f0eb4701eae82ec50120ddad657d8798af533e2295877309366e9c -962e157fe343d7296b45f88d9495d2e5481e05ea44ca7661c1fdf8cc0ac87c403753ca81101c1294f248e09089c090eb -a7c8959548c7ae2338b083172fee07543dc14b25860538b48c76ef98ab8f2f126ecb53f8576b8a2b5813ecb152867f18 -ae71680366e11471e1c9a0bc7ea3095bc4d6ceb6cf15b51f1b6061b043f6d5941c9f869be7cb5513e8450dca16df2547 -831290201f42ebf21f611ca769477b767cf0ee58d549fcd9e993fae39d07745813c5ce66afa61b55bb5b4664f400ece7 -af5879e992f86de4787f1bc6decbc4de7d340367b420a99a6c34ac4650d2a40cbe1cef5c6470fc6c72de8ee1fe6bcce4 -8d3c27e1b2ef88d76ac0b1441d327567c761962779c8b1f746e3c976acb63b21d03e5e76589ce9bb0d9ba6e849ed3d53 -ab23b09c9f4151e22654d43c1523f009623b01fe1953d343107cef38b95bd10afd898964946d3cb8521bcbe893e1c84d -8a6acade9520e7a8c07f33d60a87fd53faa6fbf7f018735bffcbbb757c3bafb26f547ceb68e7b8b6bca74819bfcd521a -94db50080d557440a46b6b45ee8083bc90e9267d40489040cbed6234bebf350c788ec51557b969f95194102fde8e9713 -8be8031f32504e0c44958d893649f76cec17af79efcd22bbedb78378f0a150845467e59f79a3f2a3b6a66bdf0d71d13c -a69a4ac47fd92e1926b5e14adcbebbef049848e8a00d4bb387340892e5a9333cae512f447201728d3b53c6cf980a5fdc -8fc713825277c5a8d9ef0a1f6219d141def6d8b30aff0d901026280a17d1265d563ff5192a0817e0e1a04ff447fb6643 -8bf0a85569c4f0770ff09db30b8b2ea6c687630c7801302c17986c69a57c30f0781d14b3f98a10b50c4ecebc16a5b5ec -896baa4135d5621fd6b6a19c6d20b47415923c6e10f76c03a8879fd8354e853b0b98993aa44e334623d60166ba3e3ca9 -b82cde1c2e75a519ef727b17f1e76f4a858857261be9d866a4429d9facf9ea71d16b8af53c26bde34739fe6ea99edc73 -b1a9e1f2e34895a7c5711b983220580589713306837c14073d952fe2aef0297135de0be4b25cbfaed5e2566727fb32ef -b42ed0e9eaf02312d1dba19a044702038cf72d02944d3018960077effc6da86c5753036a85d93cd7233671f03d78d49a -a402e34849e911dbf0981328b9fe6fff834c1b8683591efd3b85aa7d249811d6b460a534d95e7a96fdd7f821a201c2c4 -a774417470c1532f39923d499566af762fa176c9d533767efd457cc5e4a27f60e9217f4b84a9343ecb133d9a9aab96b7 -83dc340541b9ef2eb8394d957cd07b996d2b52ac6eb5562cbba8f1a3312f941c424c12d1341a6dc19d18d289c681ef40 -b2906c32d5756b5712e45dec53782494a81e80f887c6e1ef76e79c737625eccecb8fd17b20e6f84890d322b6ffde6eab -b89705c30cec4d50691bc9f4d461c902d6a4d147cf75ee2f1c542ad73e5f0dabe3d04cd41c6c04ab1422be4134cf1ad7 -8c3293651f4c4fac688bf5837c208b15e5a19ce51b20dd80ffc7fca12d3e615b2773cfc3ed62a1b39c66808a116bde06 -8fceb8ef481163527d1fc3abc7e1a5b3b6de2f654c3fe116d1367b177dcba2e0d2124a7216803513a3d53fc1e30435b9 -b2a42c827da630aaa3eb20ed07d136aa11ba01b4c8efc0a57ebab7d5b851a15daa6ba118bcffbc20703916e430e30a87 -a86340153abb3fe97414e2fde857e15aac27c9bb9b61258eea6766024f426ed0753f08f07f6b02b5375e1587ea3afcab -b006465e258e646f91ba889765113d3dc9bd657246c533cab6516d55ba054baa9d7276a3b0fa31730c3bd824845bf107 -a08aadc09428719cde0050d064c0f42c5b7c4f6c158227d7636f870957d6cfe821b4c62d39279a7c98f5a75fcb7bbfba -885e7d47ce9b50d21b95116be195be25f15223a6a189387575cc76740174c3e9044f1196986d82856b3fb25cdd562049 -b18c3780362d822cc06910743c4cbcef044823a22d12987fe2e56f3801e417f2e9cd31574ea1c5c6ee7673a14aa56e3e -a625570ef7d31c042d968018865aeeba34ee65a059ab1ec079c7a8ba1be9e24bce6afb7036c07d9d6c96ab014f95d661 -8fc9bd4764adc4c300b5bd49a06dce885d1d8aff9bae68a47976d0cd42110aa6afa2d7b90b64e81c0f14de729f2fb851 -91d88714cb669f5f00241aa5ab80dffb04109492ea9c72b59645eb1f85f3539c61db2ab418af986f42241df8b35445e9 -b98f14e664df2590dd2d00b5b5c817e388e5d9fb074f718637c33b3d4969c89e82fdd12db8997f5ff3bf5bb5ca5dd839 -86cb3d9f148cb2170317a4c22af7092155aa66ecff7ab1299b102fbbaa33ed2a284b97b08f529d2da9faea63fb98972c -92449f6b8a7c737ecef291c947cbd602c47d7fe47dc3426c2b413f3019169aa56e14c2a7216adce713e1c7bd5c08a83f -b08c1b9080bba88b44a65070948142d73c00730715fbdd01e13fc3415c5b4f3248ef514fa3ade4a918c9a820cccae97c -b0a05297da76e37c22be7383e60bba1cbc4f98ba650e12d4afcfcea569842003644a10ad73c9148958f7bf1ffa0a27d0 -839092c1f4e9fb1ec0dde8176f013b0d706ab275079f00f8e774287dd658d1b5638d5fe206f5f2a141911a74bb120f75 -a36bd669bdc055ece4b17ff6eac4c60a2f23324a5eb6d0d6c16a2fce44c39cfd52d1fa2b67f3f5e83504e36426fbfc40 -8aa428323512cf769645e2913a72976d32da4c0062ffe468a6062fd009340f0f23c6b63285848a0e7631a907adb032a0 -944800f7d43f41283eb56115ac39ccc5bf107ae5db6abcaba6936b896260cd09428a6b828c0bccebeb00541073dbf38e -8e700ca7c9e1538cf64e161dd8d16af56fc29d53c79648150d6d8c268b0c95c76acded723e29918690d66252bd75f5b3 -b9c4ce35b5b16b4c39b6e85800c76b26e8d0999500fabc1e5b6234a7f8da18c621266ac0d5ebc085354297ff21ac89a5 -a0c706d32063f1877f7e903048ce885f5d012008d4a8019dd00261a8bbc30834bffeba56cdeddc59167d54cc9e65f8fa -839813b736225087cbbcf24506ea7bf69138605036b764ec0514055ac174bbc67c786a405708eb39a6c14c8d7e0ec6ee -b1a5fef055a7e921c664f1a6d3cb8b21943c89b7e61524a307d8e45aa432e5765a27c32efdb32d88062cd80800a260de -b17f8202d9ed42f0f5cb1b1dbda60711de3b917a77f6069546fa3f86d21f372b8dd5cb86f1994b873ba9982404e08daf -b5211d54bd02d44d4d808ad57067606f3e9fa2cad244a5f2acef0edf82de3c496d2b800f7c05f175d01fa6ace28b44d1 -aa9c6f8f489b35fdb7544116fe5102a34ff542de29262f156df4db4ea6e064f5ea20c4bd877d40377ed5d58114b68f19 -826668b1f32e85844ff85dd7e2a8e7f4e0fd349162428bc9d91626b5ab21bdbacd1c9e30cf16f5809b8bf5da4f4fe364 -b30d14917b49437f9fdbae13d50aee3d8a18da3a7f247b39e5d3e975c60bd269da32da4e4cc8844666fca0d65f4e3640 -8c6918d8d94b36c6b9e772e9a432e66df16724e3b0660bde5ea397e6ef88028bb7d26184fbe266a1e86aef4a0dfe5faa -906d80ffd692c1dd03ab89be52e0a5a9e90a9cdbfc523d2b99c138ae81f45d24c34703f9cb5a666b67416e3bb6272bc4 -8b07e8ba22b436e64f011cacf5e89c55cd3bfb72ae8b32a3a8922c4fccb29de6f73662d6e330da6aa6e732a2187ef3c9 -9547466b4553a49adf59cc65d4c3c9401b2178947ebe3bd33c6e63cfb67d6be8729033158594f6f244b272c4487d6958 -aafcccea41e05cb47223fa8dfec0dd55964268bd4d05e24469614077668655ac8a51d2ac2bfb22862f8f4fa817048c2f -870f8c1173e8fd365b0a2e55c66eea3ab55355990c311f3042377803d37e68d712edcc5a0a2e2f5a46df0c1c8e6310c2 -b4288f792008f342935f18d8d9447fe4ddcfea350566e13dba451f58c68e27241af1367f2603a9dff6748e7fe0c53de4 -91c58c0e537d3afdcf7783601dd9cda2aa9956e11f711b15403760cf15fc6dffb40ed643886854571da8c0f84e17adfe -a43fec8ee92febed32e7cdd4e6314a62d9d3052c7a9504057dfba6c71fdfbeff1cef945d8f087bd106b5bec7478ad51f -99cf5e0e3593a92f2ec12eb71d00eccec3eec8662333471b2cb3a7826b7daca2c4d57ffba18299189cf7364e2af5df6d -af50f9ab890b7517ff1f1194c5b3b6f7f82eabc607687a8380be371a6a67b117aeb9b6f725556551b81f8117971706a2 -aa352430887053602a54403bd0d24d6b5181b44aa976dfa190e21851699a88127dcc904c90a48ec44610056b5dcd36c4 -964c821ea1902354736fa382a929c156bd67b9468d6920d47c27b9d0d304b6144118888d124c1f6785da596435ed2410 -b2284a67af26b5f5aff87b4d8e12c78ab37c5eb6e92718fca8549f86f4f001b660fc4520456aff72c9bcddd686603942 -83c54cbb997ea493dc75df4023071dce6da94268feaa2352373789616f012098270ba4fd60c791796a6f5062fb2cd35e -9143e8fee0b8f0f34c65c7750858093dcf165c6a83c026bfac2d5ffa746361eb4b6a14fdb43e403add901ac3735735a3 -97d7748a5b278ee47b18c9e60689b12a0a05be47e58e78bf8c04b9e8b34e2e2f2d3ac3c25c76ab2e0a75e8a54777b7c8 -b4e68f6f2d978a5411414c164c81ddb2a141b01ebe18c65a8626ca75d6432e5988310b50a888a78c3a0a242353525af5 -8976f4cc3eaf2684718cf584712c4adaf00a4d9c521f395f937e13233b30329658b3deacfe7e29fac84c496047f2d36b -a40bcdf4b6e95f1535c88dddcbf2074ef2e746b7fd232bdfd2b88f2f6d4bbf21c6b263cf5fd3e12a03476f2f5ffe00d2 -88c7b6337ee705acd8358ef6d2242d36b140afff0579a7784b3928a0c49698bd39c1f400e8a2e3eda5fbfb2e8f28fe51 -a98612ba8b450a71d2075d51617ebeb7ca401ad3cbd9b8554850c65ef4f093ba78defb00638428c9f1f6f850d619287f -b7e71d3ffa18b185c1a6bd75668ff65d985efc0a0c19f3812cafde9adbfb59ffd108abeb376e6a8877fdf5061562f82b -8a3e5fd776cc26908a108a22b1b122d60cb8c4f483cbedcd8af78a85217bb5a887df3efed2b8b4ec66e68eb02a56ca93 -b0d92b28b169d9422c75f9d5cb0a701e2e47b051e4eacd2fd1aa46e25581a711c16caf32f40de7c7721f5bf19f48b3f5 -88895739d5152282f23e5909cf4beebda0425116eb45fc5a6a162e19207686d164506c53b745fb2e051bb493f6dbad74 -adbccfed12085cd3930bd97534980888ee564dda49e510c4e3ca0c088894855ef6178d5b060bca8a8a1a427afdbec8a8 -87d00674abd3d2e7047a07ed82d887e1d8b8155635887f232dd50d6a0de3fb8e45b80b5a05bc2ec0dea9497b4aa783ac -806e1d3dfadd91cbf10e0d6a5e61738d0dbff83407b523720dce8f21f8468b8a3fc8102acf6ba3cf632ca1cb2af54675 -95a9dff67cf30e993071edede12623d60031fa684dfbe1654f278a1eb1eb7e1be47886d3f8a46c29b032da3176c0d857 -9721973288384c70a9b191436029e85be57970ad001717edc76d44cbfa0dff74f8af61d5279c5cd5c92c9d0f6c793f63 -95c22d1d9b51ef36ba30ee059dcd61d22be3c65f245d0a5179186874219c08e1a4266f687fc973e71f3e33df2b0f7fd3 -b53ec083dd12cc42ae2bae46883a71f2a35443c9ce4ed43aa341eb5f616a53b64211ed5aac717fe09ef1d50f551ed9f0 -a103dab6695c682400f60be8d5851ce07f12e4bd9f454d83b39c41ddcf1443bb14c719b00b4da477a03f341aa1e920cb -b522236988518e5363b1c4bb3f641ff91d3d4c4d64c5f065415b738160b4ce4b0c22e1e054a876aa6c6a52fa4a21dfa2 -a6a00562f0879702cdba5befd256a09f44bf48e61780e0677ff8c3fda81d8e6dc76ba1b05e3494ca9a4cef057eba6610 -b974a2ae631e0b348421f0cda5bd4ce7d73c22dd0fc30404c28852c33499818cab89fbf5c95436d56a0aab3bf2bbab51 -9148cf2a7b7e773245d4df5a9d34cf6d9d42b1a26a4ca6bc3013feca6f3941d6c44f29ba9328b7fe6ce6d7f6565f8e4a -a34035c4a63e98528a135cc53bbbcfcda75572bc4c765f212507f33ac1a4f55563c1a2991624f7133c77b748bbe1a6da -a0c45923cfb7bd272ee113aecb21ae8c94dda7ad1fe051ddb37ab13d3bb7da5d52d86fff9f807273476c24f606a21521 -81ec2ca57f4e7d47897d0c5b232c59d7b56fe9ce0a204be28256a7472808de93d99b43c824a0cd26391e6cac59171daa -8373852f14a3366d46c7a4fc470199f4eebe8ee40379bd5aae36e9dd3336decaead2a284975ba8c84d08236e6b87c369 -b47e878a93779f71773af471ba372cb998f43baca1ae85ea7ff1b93a4dee9327e2fb79691c468ec6e61ab0eae7ceb9f1 -8fc8f260f74303f26360464cfef5ee7eebcbb06073cef3b1b71dab806d7c22f6b3244ce21d0945b35c41f032f7929683 -87e3c4e1dab00596e051ce780b9a8dba02ecdc358f6ddaeb4ec03c326e4b7da248404745392658eb1defff75b1ba25c8 -aac95d8e3b7fe236a7ca347d12a13ec33073f2b2b5a220ecfd1986ca5c3889f0e6a9d9c377a721949aa8991c1821953a -91a483679437ae126a16f5dc3bba6e9bb199dfbba417f0dc479f22819b018c420edc79b602db6183c6591b1909df4488 -94a4b2c663aa87a2417cad4daf21a88b84983a7b212ffcd18048a297b98e07dd4c059617136976fac1d9e94c8c25b8d2 -83e2a690bfa93c79f878a63c0f69f57aabdd8bede16b5966ffba7903dc6ad76775df1fd5347e6f2825f6cd7640f45a45 -a316af7ac11b7780d15312dc729499a1a63b61c4283e103ecce43c3b0cbb0f4bce6ff04e403f5c7cb670dee80c75ab99 -8d0a911c54ee1f9f7e7794732ad87b434c3f356294d196a5e35eac871727fd32a49c27c2dfa10833f9e6f9c7ccbe0064 -8b8db09028298a1f6362b346c8bfeced7cb5d13165a67c0559a9798a95b7a4a9810c02bb852289d47c59f507bd24ce77 -962d57305c518f175ed5d0847fb52ddc4258ca0e4c9ddfc8c333a2ee9f8b4e48d25a3d7e644b785a5953e2e4063da224 -92e0799491898271769250fe88b0cb9dadec98ac92f79de58c418d23ef8c47fcf21ddc90e0cd68bb8f1deb5da82da183 -99855067125f6a6c3a3e58d3bd2700a73ef558926bd8320d2c805a68e94207b63eda6bdc5a925ec36556045900802d51 -a724ae105ab4364a17ddb43d93da1e3fc6b50213f99b7be60954b24dc375c4f93a0737f4a10b4499b6f52667d5f3a64e -82070fb43a63fb50869b118f8940108f0a3e4cc5e4618948417e5cc3801996f2c869d22f90ca4ca1fdbef83c4778421a -b25c04365d6f24d5d3296c10d85a5de87d52a139ddbcbf9e0142074bc18b63a8bc5f5d135bd1e06c111702a4db4cee28 -851093282dcda93e5c98d687a17a7ee828cf868f6c85d372d9ae87f55d0593d8f9f0c273d31f7afa031cf6aea6a7ef93 -93f04f086fa48578210ed207065d80a40abcc82d8bfc99386a4044561d35748ff6c3da6489933c23644ad4b60726da8a -84b1b50d1e876ca5fc341bbedab5b3cc0f6a3f43ea7dd72605f74d0d9c781297b2f12b7872dd600924f1659a4cdf8089 -81b0ba88c582d3956f6b49ca3e031c6400f2ec7e1cd73684f380f608101e9807f54866be0bb9a09c03953c4c74fbb3c8 -a641af6ac644c41a55dee2ef55d3c37abdb19d52bc1835d88e7adda6b6ccd13987c5fd9cba9d318cabb541aa6a0c652e -a7b75b0624d04ad0901070e691eb2d2645b60f87e9d6b26e77a5fb843f846c32fc26e76ae93fd33fe3b857f87bc25162 -a81ba3e2ed0f94c67cd02ba7360e134f8becf7ed2ed2db09b9f5ef0942f7073bfee74ca446067db6092f7b38f74ccc11 -ab80edcabab5830a24210420f880ebac4e41bf7650c11ba230f4889634dbf8e8e2309f36be892b071c67a3bab8fc7ed6 -94d69b64675076fecad40fae4887fb13a8b991b325fa84e9d2d66e3b57646de71a58ad8fd8700fefb46975b18289250b -b44fc0df480cd753a041620fa655be9df74963ae03d4625847d5bb025ceb37f48d19c8c9c444546fba5fe5abb2868506 -b56e2c51324d6200b3d9781b68b5b5e1617a68afccd28b3a12a4be498d2e3aafcd86514c373a9f3a001db733010c29cf -a359a0c172e5cd7ce25080dd2652d863d7c95a4a502ae277ac47f613be5991300f05978404a0acb3bcda93524dcf36e4 -b01427a3dfdf8888727c0c9b01590b8ae372b7b4080d61e17ccb581bac21e61c4a58c75db7a410d1b2a367304e1e4943 -95cb08be4a96c18fbf9d32a4bbf632242029d039a5fdea811488d3634cd86520d4f9806250a8c01855ee2481210f542a -b8594fe6c0717164058f08aedeed1853523f56cec5edbf0d2be271fa5e8bfd61f2974b0f3988d70f5baa2e7888c7ec1f -8f64ee89f59daf74fa1056803247c9d678783ee3917b12a201f30f7523957763e979ceaddb38bae20de40b9885728049 -b6093ee4bdb837bcc59172e236f4bdbd439c0a5a50e2aa16636cbff81b51e92989eb5f80a3f75c37ae7b5b942e55b3d2 -913b6fbb7b43e3e5c49e96cd8e82ed25c655e51c7b8ca82e8fbf92b01ac83c39d52f6f4efab5d39b0591a0538601a86f -81f42668479ca0bec589678dc0973bf716b632578690efe1a0f13de630f306fb4a189a98c2302572fd85d3877ee030b5 -90ff89c38a9a7189f28d35a088657f52283670e7fec842fa91c265660ea2e73b0ad6c46703d649f406f787490b7a7e4b -9077b8b5f1e083183f3152ceb9c5491b5d4b86525a08879f7fb6d5e27f9f1a6867cf0d81b669a4a2d1f1654b67fa8d9c -a7a0275cf5b894adbf2e54a972310cfe113e811872111d6ee497d03750d9f6ffa5517b6c13a99b111a4a91e8e4dfeeee -a08976bf8125b7538313a584bbe710741d630cab067a204ad4501cc4938874ce7aa6a1a826259c2e82ef10a66f1f36fa -8aa45385b5b97f1f3e45f2bbf7a4f3e8ef068e628608484971c97adeb610ebd5deec31317e03eb6536808921062c04db -945b106b8f3ae85e60dfd34ef3dcc079bc6f0aab6df279ed000856efd51321462038ac0a1ca5db3ebf6379bc341e7c55 -a4199c87a96f98cc9d8776fe6de131d2c706b481eb9e9a3bbc50a93d492d7fd724ea469f723fbcfb94920cb5b32c1d76 -a5347b1b2f6149805de67546c5ed72253311099bf1473dbc63edcf14a0a5e68d401f5341338623fbe2e2715b8257e386 -af5dcd03ddc3769e83351d6b958d47a06d4e5224bd5b0ec40ffe6b319763fab8572002f4da294a9673d47762fd0e6e1d -82ec1031b7430419d83b3eea10a4af4c7027f32b91c3ae723de043233b4a2e0c022c9e0f5a1ac49753800f119159112d -8a744d911b67d03b69811f72e9b40d77084547e4da5c05ff33893468b029a08266fc07303f7005fd6099683ca42b3db4 -93ab566bd62d3439b8fc620f3313ef0d4cb369f0f0c352cdaf8e5c9e50b9950ac3540b72f4bf5adcb9635f9f7ce74219 -b2a211d72e314799bc2ac7030b8bbb8ef4c38ebd0ebb09d6cbd43bd40c6c61d80a3aad02cc73f5775a08b9657da20a48 -98d60f0a98d28718e0c6dcccc35a53521ea7f2d8fe08ea474374a336b44cea4cd1c63b31f2ad10186822bfb54aca53e6 -831f89cb94627cfe554d46ae1aad8c1cde7ebe86c4bd8fac4ef73ac2d5b491f5efa5dc4198cb8ffbec563e0606b91d89 -8f8552583bc6cb3fb176b7202236ee4128faf0c8ec608f9150f8e011d8c80b42aab5242c434d622b6d43510eaef752c0 -897bf27baaee0f9a8445200c3d688ae04789c380d1b795557841606a2031092328eb4c47fef31c27fdd64ba841d9d691 -b57589a4af8184b4a8ceb6d8657a35522672229b91692c1cec3ac632951e707922a00086d55d7550d699c4828bcfaab1 -98c2fe98095e026aa34074bcff1215e5a8595076167b6023311176e1c314b92b5a6d5faa9599d28fca286fadd4e3b26c -a034992e563bd31ede3360efd9987ecddc289bc31046aa8680903bb82345724805e6f6cf30f7889b6b95cf7319c3aea1 -85c33d9f10cc7185f54d53c24095e621966065e0ff2689a9aa6bb3d63706796c37a95021738df990c2c19493c0d44b64 -a8c1247d6de2215f45b50dd2dc24945ff9b93184bcc2159b69703b0bba246adcd1a70a12659f34c4ca4ba27dea6e3df5 -83ebdad2834c97bf92aac8717bab2f5cb1f01026b964d78e2f3b44e99d7908e419165b345d2b2f125b903096584e6683 -b0af6f7f81780ceb6e70adfd98e7702ec930c8ca854b50704c4a0fc8b887b9df60a6fe9038b487f3ed0eb8eb457307ea -933ec7e53882453898617f842ab2efae4756eb6f6ea0161cced5b62a0cdde4c08c7700d52f7546d4dd11a4c9e25d624e -adf6e6d4706025f85eb734f506dde66459c9537a1abf6189199cf219ae583b461e11c6242fce5f0795e4d9025270fabf -89e4316319483098761b0b065df4cfb542963b7a2556ba5425b6442fb0e596eb2a4f03e2dc8c617eebe8f243a12e7d10 -90c5a147555759ebc4d0e15e957a548315f9994ef0c7a3f53f2d18da44fb93bf051d96ba8551597a6f3e701b926fd791 -a151a9a5199c72c697b771cd81e550fc6f9596c752ae686ad988b316a7548360cf9785ab4645164d96cfdf9069a94020 -80cba11a3977729d7948db5bcc186159f4cae7c0a835bb38bb781e287dd6c238508e748f23454405c9d5eed28e77df02 -ae4b92ea03cb8ad12ad3ec76869ad05acb09f9d07a3c9a87dec0e50d9a276fe5d3d515a8c446f3aa35cd7d340a22c369 -8630062709a1f180f952de9f1ca3f41acce5420677f43d9619097e905a6237f1908d66db7a4dfdf1b2b92fb087e9944f -81defc33dd383d984c902c014424bddd5e53b013f67f791a919446daa103b09b972fa5242aba1b1dbe4a93149373f6c3 -963891ecaea97e661bac2594642327a54f5a0beb38fcb1c642c44b0b61faab9c87b0c9f544a3369171b533d3ab22f8f1 -932fadbff5f922ddcd4da942d57fe3e6da45c3d230808d800a3ca55f39b0b62f159be31a5924b395d577a259f48c6400 -992ce13bd037723447f88aeb6c7722fd9510c7474192b174ea914ed57c195c44c298aec9a8cabac103f0a5b50051c70b -b032157b3e4fe69db6ce6bb10bdf706a853fbd0bee08c2ab89da51ad827425df5df498b90e7a30247a7f9e954ca986e5 -b2478d4874578da3d5000893736bb65712e6aafe96e6fa5cf5878ae59ba0ce640dbe5d76ec2b5baca75af57def471719 -a387c17b14dd54910fecf472f760e67cf71a95e9e965cc09484e19581ada65e79938b86136a93e287e615fbd4908e080 -98f02be271d0f8841d8d561163f9e55e99b57aff121a93fba7a4654bcf15a0899811f00f5bcbfbebd98e365a0e332e97 -a3c34f01d54cab52a8890391b8cf152cc9cdc16e7e53794ed11aa7b1a21e9a84d39ddcfbcb36c5df6891c12307efc2e0 -a940331f491ec7ad4a9236ca581b280688d7015eb839ee6a64415827693d82d01710dc4bbd5352396be22781fea7a900 -b10874ed88423731535094031c40c4b82af407160dfade4229ac8f4ef09d57b3db95c4a9d73c1a35704f6bd0d5f6c561 -a9c5a4a7680261c1b0596f8ab631d73d4a7881b01e6559c628b5cdafa6dd2b6db2db64f3f2ab5841413a8a52b966a0da -8fc154564a61d5e799badc98b43a3587f804385a850adce9a115cbd2ad911f3fd4072b8e6b22fc6c025a6b7e7ea5a49f -b9caf7c6dcce3d378aa62c182b50bc9c6f651eb791d20fffa37ef4c9925962335fe0b3bc90190539312aa9ccf596b3b9 -90c5b7acf5cb37596d1f64fc91dee90f625f4219fa05e03e29aebea416c8e13384f2996f8d56791bcf44ae67dc808945 -ab8d311fc78f8a1b98830555a447c230c03981f59089e3d8a73069d402a3c7485abe3db82faf6304aaca488a12dbe921 -8a74fda6100c1f8810a8cacc41b62875dd46d5c4a869e3db46202d45a8d9c733b9299dda17ce2ad3e159122412a29372 -8769dcacba90e6fc8cab8592f996c95a9991a3efecfb8646555f93c8e208af9b57cf15569e1d6e603edac0148a94eb87 -854fd65eea71247df6963499bafc7d0e4e9649f970716d5c02fbd8708346dcde878253febb5797a0690bd45a2779fa04 -83e12dc75ef79fd4cc0c89c99d2dace612956723fb2e888432ec15b858545f94c16fae6230561458ceee658738db55ba -8416ef9ac4e93deff8a571f10ed05588bef96a379a4bdcc1d4b31891a922951fa9580e032610ac1bb694f01cb78e099b -93aea6e5561c9470b69d6a3a1801c7eef59d792d2795a428970185c0d59b883ab12e5e30612d5b6cde60323d8b6a4619 -91d383035aa4ec3d71e84675be54f763f03427d26c83afb229f9a59e748fb1919a81aca9c049f2f2b69c17207b0fb410 -b1c438956f015aef0d89304beb1477a82aed7b01703c89372b0e6f114c1d6e02a1b90d961b4acbb411cd730e8cacc022 -a1ee864a62ca6007681d1f859d868e0bcd9e0d27d1da220a983106dc695cb440980cfdb286e31768b0324b39ae797f18 -b57881eba0712599d588258ceada1f9e59c246cc38959747d86e5a286d5780d72d09e77fd1284614122e73da30d5cf5c -a48f9ae05ba0e3a506ba2e8bbce0d04e10c9238fa3dffa273ef3ffe9ec2ed929198a46507c0c9d9b54653427f12160f9 -8db18da7426c7779756790c62daf32ae40d4b797073cd07d74e5a7a3858c73850a3060f5a3506aae904c3219a149e35d -a2bf815f1a18d7be8ce0c452dfc421da00dcd17e794300cdd536e4c195b8c5b7ccc9729f78936940a527672ac538c470 -a34c6f1f2398c5712acc84e2314f16d656055adcafad765575ae909f80ab706cf526d59e5a43074d671c55b3a4c3c718 -b19357c82069a51a856f74cbb848d99166ce37bd9aca993467d5c480a1b54e6122ebddb6aa86d798188ea9f3087f7534 -b440eac6f24d12c293d21f88e7c57c17be2bdb2a0569a593766ae90d43eccf813a884f09d45a0fb044ee0b74ff54146a -b585d42ef5c7f8d5a1f47aa1329f3b1a566c38bf812af522aa26553010a02bfd6e9cc78fdb940ef413e163c836396a5f -aca213b27f3718348e5496342c89fffc7335f6792283084458c4a1aa5fe0a1e534fcec8e7c002f36141308faae73ef2a -b24c07359769f8ffc33bb60c1f463ea2baad440687ef83d8b7c77931592d534b2c44953c405914ace5b90b65646c1913 -b53dfaf381205a87ca4347328ff14a27541fa6436538f697824071d02d4a737ceb76a38dcc6e8dadef3b5bc6442f5109 -b55972d8ed5197215c0a9144fc76f2cd562ca5f4e28c33a4df913363fd1388978b224c44814adb4c065c588a4ac1fe10 -a3303bc650e120c2e9b8e964ad550eb6ac65ffe6b520768b3e8735565ae37eafdc00e3c15fae766d812f66956a460733 -b11e53912ea0e40c3636d81d7637e10c94cc7ed9330a7e78171a66d02b7603f4cb9b3f6968104b158de254e65b81640f -b076bb9f6d396aa09c2f4706ea553b426fdfd87d7d69e438285b74d334e82f73973cb4dbd6cb1647493433dad65dbc41 -9415828b1632175f0b733541e32c26a9c88fe12c721c23e595f2efceaa7f867f359e32564b7c032185686587ac935cf4 -89579a112c306181c79aabdbf683e7806357febcb73bf5e8883862ae29618ef89498b62634404bb612d618fcd16da415 -8761bcd55d04297c4f24899e8fb9f7c1fcd7449ae86371ee985b6a262e228f561c2584980694d9bf354bdf01543edb6a -9100c88bf5f6f00305de0c9cf73555f16a2016d71c50cb77438e8062bd549fa5407793a8a6a7e06398756777680a2069 -9235dfef45aeff9c174898b0755881b7171ed86362854f0eabc3bc9256176c05a5dc27ca527c91c3fa70c0ec5fd5e160 -ac53b1d677cebab6a99381dd9072b8ac1abae9870ec04a1f8d2a59b6f1de797c1492b59af6948f5cf2b20599170f5bba -946542936b0c59156e8fd5c1623b41369bc2cbcc46ece80360dcb5e7cce718a3dd8a021f0b9c223062a4e43d910b634f -b1e9939b34e1fcc026e820fcfa9ce748b79499f8e81d24a3ef0457b3f507fe5fa37b975a47c143e92eb695623b4e253b -9382d9b5766f6ae960d8a8435e8b5666e57ef8e5f56219e7bfd02857afe5cb16f44d70a9e444cfb1008649ae9b863857 -91770ed1215ed97dca1282b60b960be69c78e1473edb17cd833e712632f4338ff74bf435c3b257439497c72d535ae31f -8eb2cbe8681bb289781bf5250e8fa332141548234c5c428ff648700103a7cd31fdc2f17230992516c674aa0ab211af02 -a823b71c82481bc6ac4f157d5c7f84b893a326bbb498c74222427ded463d231bc6e0240d572ab96266e60eb7c8486aea -a13ce4f482089d867e5babcd11c39fa9a9facd41a2c34ee2577de9ce9c249187e16f2b3a984cc55f9e45b9343462d6d2 -8d80e7bc706059cf5151f9f90e761b033db35d16b80b34dc8b538adc8709d305a0c06933dcd391e96629cf3888c8bf87 -abcd36cdd86c0fb57fb7c0d7a3b9af5fd9aed14e9f4e7e84b0796c5c0ad18c41585e8c46e511cef73dc486fe43f6a014 -a947a5b6916f416fa5a69c31aba94add48584791148b27d0b3ed32c02a05dfc06f7fdc5006e3b2503bdf6e410e30f2fb -b158e621580659f1fa061d976b8591ac03b53ecd23d9eb2b08c1a20353d78438287749664d196020d469ef44b3b8752e -90a5a9540281e481ac4b8d29968f477cb006b56bd145529da855d65d7db0cf610062418c41a1d80c4a5a880c0abe62a0 -b2c91808b6289d08a395204a5c416d4e50a8bb1a8d04a4117c596c4ad8f4dd9e3fb9ce5336d745fc6566086ae2b8e94f -af6767c9b4a444b90aeb69dfddae5ee05d73b5d96e307ce0f3c12bccca7bc16475b237ba3bc401d8dafb413865edf71e -8dcecf624419f6517ef038748ac50797623b771d6111aa29194f7d44cfb30097ced26879e24f1b12a1f6b4591af4639b -954437559d082a718b0d6d7cec090532104ab4e85088e1fc8ee781d42e1a7f4cdb99960429707d72f195ff5d00928793 -80f0b7d190baa6e6ab859dc5baab355e277b00ddcca32e5cebe192877ad1b90ead9e4e846ca0c94c26315465aeb21108 -b8c29f181ed0bb6ac5f6a8d9016980303bb9a6e3bd63ce7a1a03b73829ac306d4fab306ac21c4d285e0d9acb289c8f2a -a7685079fe73ecaeabf2a0ef56bad8b8afb6aeca50f550c97bf27e6b4a8b6866601427fcd741dc9cb4ce67a223d52990 -ada2ebf6f2a05708d3757fbf91365ec4d8747eb4c9d7a8728de3198ceac5694516ab6fd6235568aecd8d6d21fef5ef48 -846bc5da33d969c53ab98765396cab8dcdbb73b9836c9bda176470582a3427cb6de26d9732fab5395d042a66bdba704c -800a3a7ea83ce858b5ebc80820f4117efa5e3927a7350d9771cad9cb38b8299a5ad6d1593682bba281c23a48d8b2aa71 -a002b18595dec90b5b7103a5e3ec55bdd7a5602ee2d3e5bd4d635730483d42745d339521c824128423dfe7571e66cbaf -b6b4e2067ac00a32f74b71007d8ab058c2ef6b7f57249cb02301085e1a1e71d5de8f24f79b463376fd5c848f2ab1c5bc -a3e03036db1b6117efe995bf238b0353ad6f12809630dca51f7daaaf69f7db18702e6b265208944bfb1e8d3897878a51 -add16712f66d48aab0885bd8f0f1fb8230227b8e0ffca751951c97077888e496d6bfab678cb8f9ffba34cee7a8027634 -ad211af2dd0748f85a9701b68c19edd4a7c420e497cb2e20afdc9df0e79663841e03b3c52b66d4474736f50d66c713ce -8c8a899ce0f16d797b342dc03c2212dda9ee02244c73c7511626dba845d11a0feb138441da5459c42f97209bf758cd9b -a17efc75c7d34326564ec2fdc3b7450e08ad5d1de4eb353de9d1cd919d90f4be99f7d8e236908b1f29cf07ae1ffe0f84 -862d4a8b844e1b0dd9f4deff180456ebed5333b54290b84f23c0ddb2725ac20307e21cbb7343feac598756fe36d39053 -9187fbb19e728a95629deda66a59e178f3fcd6e9d7877465aa5a02cea3baba2b684bd247b4afbf4aa466b64cb6460485 -85ae5636688d06eab3be16e44fe148515d9448c6123af2365d2c997f511764f16830610a58d747adab6db5031bea3981 -8aa8a82891f4e041ce6df3d6d5d7e5c9aaaffe08e0a345ac0a34df218272664c1b7be2450abb9bc428bd4077e6e5dcc4 -8c3bcc85ea574dfe1b9ca8748565c88024e94374434612925b4e9a09fa9d49c0a56b8d0e44de7bd49a587ef71c4bff5f -9524f9dd866fe62faf8049a0a3f1572b024120d2e27d1be90ad8b8805b4e2c14a58614516281cc646c19460a6b75587c -84580d9c72cfa6726ff07e8d9628f0382dc84ce586d616c0c1bd1fd193d0a49305893eae97388de45ba79afe88052ee9 -b5573e7b9e5f0e423548f0583423a5db453790ab4869bd83d4d860167e13fd78f49f9a1ffe93ddddf5d7cd6ec1402bc4 -aff658033db3dad70170decb471aee2cf477cf4d7e03267a45f1af5fd18200f5505c7ce75516d70af0b0804ec5868a05 -84a0eab4e732a0484c6c9ed51431e80cea807702fa99c8209f4371e55551088a12e33a11a7ef69012202b0bc2b063159 -a68f8e730f8eb49420fe9d7d39bb986f0584c1775817e35bb3f7dae02fd860cddf44f1788dc9e10d5bf837886b51947f -946002dd6cf7a4fd3be4bf451440e3f3fd7e9b09f609fa4e64767180b43146095dfc4b6994287f8cfa6d1390d144be71 -b7f19777d0da06f2ab53d6382751dc5e415249d2c96fce94ef971401935c1d1f7d3b678501e785cf04b237efe2fe736e -81e5c66dd404fc8ffd3ac5fe5e69ead7b32a5a7bc8605a2c19185efcc65c5073e7817be41e1c49143e191c63f35239c1 -b5f49c523532dfa897034977b9151d753e8a0fc834fa326d0f3d6dacc7c7370a53fc6e80f6d5a90a3fbec9bbb61b4b7c -8fc8e78c07319877adfaa154a339e408a4ae7572c4fb33c8c5950376060667fbfc8ede31e1b067933d47e3fdbf8564d7 -859cfef032a1a044532e2346975679545fbb3993a34497ce81bdcc312e8d51b021f153090724e4b08214f38276ee1e0d -ae476722f456c79a9c9dfdc1c501efa37f2bff19ab33a049908409c7309d8dd2c2912aa138a57a8d5cb3790ca3c0ba2f -89acbbeffb37a19d89cfe8ed9aa8b6acf332767a4c54900428dd9ab3bf223b97315aca399c6971fe3b73a10a5e95a325 -90a4a00418fdf4420a4f48e920622aae6feb5bf41fd21a54e44039378e24f0d93ccc858d2d8a302200c199987d7cb5e4 -a3f316b0bd603143eba4c3d2f8efe51173c48afe3c25b4ca69d862c44922c441bd50d9a5040b7b42ba5685b44071c272 -a22f4dc96fedd62b9a9f51812349e04d42d81d0103465c09295a26544e394a34abdc6ded37902d913d7f99752dbfb627 -a49f51baf32d0b228f76796a0fef0fe48a0c43ec5d6af1aa437603d7332505be8b57b1c5e133bc5d413739f5ae2ce9d0 -a9e4fe133057a0cd991898e119b735b31a79811307625277c97491ff5d864c428cfa42ae843601d7bb05c0313472d086 -b987edfe0add1463a797ff3de10492b2b6b7ef0da67c221ab6f0f2b259445768a73fbe495de238c4abbe4d328e817c49 -b7f0e4532a379a4c306bbef98b45af3b82b17175dfe0f884222ed954c12f27d8a5bdd0cdeb1df27ff5832ba42a6dd521 -9471bc5ad5ec554acfd61b2eb97b752cb754536f95ae54ca2cbd1dc2b32eb618881f6d8a8b2802c1a4e58c927067d6cf -b4c84f09225cf963c7cc9d082efe51afbbbe33469dd90b072807438e6bde71db8352a31bb0efde6cd3529619812ef067 -8f08005a83e716062d6659c7e86c7d3b51e27b22be70371c125046de08f10ea51db12d616fbf43e47a52e546e7acaac7 -a8937e66a23f9d9b353224491f06e98750b04eca14a88021ee72caf41bdce17d128957c78127fba8ef3dc47598d768a7 -80ad991de9bd3ad543cddeaa1d69ca4e749aaefb461644de9fc4bd18c3b4376c6555fc73517a8b1268d0e1e1628d3c1f -b22f98bca8fe5a048ba0e155c03e7df3e3cee2bfe8d50e110159abdb16b316d6948f983c056991a737b646b4d1807866 -b0bb925c19ca875cf8cdbefa8879b950016cc98b1deb59df8b819018e8c0ad71ea7413733286f9a1db457066965ce452 -95a991e66d00dd99a1f4753f6171046a5ab4f4d5d4fe0adfe9842795348a772d5a4a714dba06b4264b30f22dafa1322f -ad91e781fa68527a37c7d43dd242455752da9c3f6065cd954c46ae23ce2db08f9df9fec3917e80912f391c7a7f2f7ffa -a202d3becbf28d899fe28f09a58a0a742617c1b9b03209eca1be7f072a8ada1f7eac2cc47e08788d85e1908eb9d3d8ee -a360ccb27e40d774d5a07b4ebed713e59a0d71b3ee3f02374e7582b59ec4a5ce22cc69c55e89742ba036dd9b4edd8f34 -a10b897a946882b7c9e28abbb512a603ffa18f9274369843eb3491524a321df1f572eea349099ac6e749ea253c901ea0 -b782a672cd344da368732ecd7e0a1476c2af04613d3eb6da0e322f80438af932bd6d49be7a6f69f7c877512731723d89 -aeccee8dfd764e1adcfc4bf669e0fa87a94e7c79324333e958df47888bff5cec358b8b5bbb48db54822b54d11bbb4bc6 -ad4953913662a9ee8753a354864339f43916f2c2390d0a3f847c712b42718ee00ee14158d730709971941e8680d54560 -92ccb31d6c9e8940c7e8a4873e7eb9de9fb2fa2bac344fa367062ea451fd49a6920a45218dca3ee968711397d2a01536 -9448d9b2b3d12dde9b702f53373db8b8595f9d1f9de2ebee76de292f966f375316953aadf6bfc0e4e853e1fa12d8f02c -8919230878a7219da8c80a4b7d00b9169fb503e72d79789dd53863c243b8d0fb0a819d46fa636d805d0b9b1d15d1f2d9 -b6581ab01215aac023f5e6f57419b6aa63c0743c07caf57d4e146b56b02d90ce1423f70489ac3a11e5c968cb924f937c -a793ec1b1fe56a76920296af06073caadfd6f1d7e30950f8ca13de3de45fe275ca4b361f5249d9405264c3a06ebb5502 -86385b4a4e1bfb5efe7bfef8fd0dfeba7f4400852237cab60febb1dfa409e497a649e81284b5a15fe680b78927256756 -85d10600de96103daa7c90657174b6cb4a1286df5379f1eda9f11c97f9df57043c290eb1ae83658530fe0fd264867b86 -ae01b2396d0f598c21659cd854c15edd4904a34d22278aef97c9260a14a8b250b52d972d304ac4b187c24d08795d5355 -b91b3e4b6fc06e88081fe023ef1b773d82c628eb0f73a2731a9aa05b0dc89b7aeef2eea60125d302e696f45c407aeac2 -986d0f478e33af7568eab6bb26a55c13ffd7cae27525b4abe2f3a994bdb11bbc73d59bdb9a2f6b6ba420a26f8f620ba6 -9746f4fdeef35feaff1def0ea5366b64f21ed29749ae6349f9cb75987e7f931952f913f446100f2a6b182561f382e8eb -a34a116cfde1acbce0d7de037f72a7ca30ab126d8f4815b2b8bcb88e0e6c89015a4daaf4d4ce8eae23eb5d059cf9a5cf -80c3ea37f6a44f07cc9c9c881990f2a5deb9f9489a382718b18a287aa3c50ee6ebe8fd1b3afb84a3cf87f06556f4ca15 -97cff3bc88cfc72ce5e561f7eeb95d4ffb32697e290190c7902e9570c56b3854753777fc417fd27536fc398c8fefb63b -b8807232455833e4072df9bffa388ae6e8099758c2a739194719af7d9ed4041974a6cd9605f089de8b43f0e12f181358 -96f79fca72f75dc182c71f2343f0c43b06d98563fd02d2e1fbc031b96601608d8a726c811a74bb51ab8b0a3ce3632dc4 -b5262761680a4235a8c1257de4735cdcadf08d5d12c6e9d4f628464d5c05dfff3884a9ef2af3b7724b5a8c97e6be74eb -b6ce0eada73433d98f8fae7d55e4ea2b9d9d7a0ae850d328dd06991f27b1f03e470868fb102800ff3efe4ee1698531b9 -a37b7d9fe9d3fdfbc72c59cf6cacc7e7a89d534dea3d73121f7483331aec8ab3fbff58ffabb943b75d6f86df0ba43262 -93fce9be8a27fcaa1283d90d3e87265a6221ee302ec708161a42bd00ffe8e726743d9e187e1bf4307c0e3f25afbb1d44 -a4ea919021346ae7ea69d5e8f46d860b24c35c676b62f4e577c90e0c05c5646fe73721b143b7c38835dd4b443e6c3676 -b79983a5948453f70dfa4c396ce1945204498fe79f40c0667291bd0fdd96ed0b9ea424571f7ade342275c854c9f03d9e -866f8e395ed730b614b70bf999cad6e87e9086c1f5aea8d69020b562ee285dd0fb93afaca0dd13a0713f74a3f9340f01 -a3fef158782292c6139f9a0d01711aa4ed6f5cac11d4c499e9e65c60469ae3afbde44fb059845973a4b3bbca627b7eb7 -b4a2c0321b68f056e7d8051beede396fa2f0704d8aa34224f79f7b7a62eb485fc81889cb617019622fd5b5fa604516f5 -8f0e3edddbaead9059df94de4139e3a70693c9ea9bc6baaa5695dddfd67263b33926670159846292801941b9a0c6545b -9804e850f961e091dadd985d43d526ba8054d1bf9c573ed38f24bbd87aeaad4dcba4c321480abc515a16b3b28f27bb2a -95f330da28af29e362da3776f153f391703a0595323585220712dae2b54362cc6222070edd2f0dd970acfbe2e3147d5c -82d03b771231179cc31b29fe1e53379d77b5273b5c0a68d973accd7a757c7584dbb37f0507cdfde8807313ec733a6393 -81b3c39a9f632086e97b7c1f0ec7e2eaf9dc3cb0d84dec18a4441dbdc9fe9878fde4bcfa686bca1a9522632a353a5566 -a2db124ab2b493d5f9a1e4ca6b3144593c2fc8bfac129fd79da11dfbb7ef410a234fda9273a50a5ca05d7b37cc2088a2 -aa8550633c9449228702690cc505c0fc4837ea40862058e8f9713622b34d49fdc3a979b9317993c5da53b5bb5b7f4974 -ae783bcf7a736fdc815d0205b4c2c2b2fee0a854765228f76c39638ba503e2d37f1e28f6bdf263923f96fead76b4187b -b5ec86092c1d250251e93bab2f24e321afd2cd24cf49adfcbed9e8bc5142343ae750206c556320551e50fc972142f0da -b3b5791b590a6e9b3f473d5148624014aa244495249322a5d75cde2c64117ff9d32f4b0698b0e4382e5e7f72933061f8 -876c6a9162c17b16d6b35e6ce1ba32e26aec7dd1368bceab261ab880ad845c91e54b96a52c7d3aafbfbafc0e37139dca -902ddb5774d20b0707a704486457c29048776a5b88c377b14af6616c8ddf6cd34f49807df9c9d8866d6b39685cfb0f19 -8b87f71f94bc96de927d77a5d7123fa9cdda8c76aff64a5e6112cbc2eca43b07f8376db3e330f8af6a1db9b948908a6a -a69a5922e572b13d6778218e3657f1e1eea9a9682f6eb1b731d676d03563e14a37ff69bc5e673c74090ecb0969a593f7 -aff3510d78ba72f3cf5e3101847b7c4a956815aa77148689c07864e8a12dd0ef33d5f6c8cb486e0ea55850161f6afed0 -aa9c459cb2a008d94cbee2c6b561d18b0d7c6ffa8a65cbf86ae2c14eec070ee9d5324f5d38f25a945ddcd70307e964c4 -8310e15b050b1e40ece7530b22964bde0fd04f48dfffdec5a0d1fb8af0799a7fdc1d878139fb7cb8d043d3a52c2d1605 -b8f0856ce2c4034ee4041d0383f25fb0eeefc00b82443311a466fc18608313683af2e70e333eb87e7c687e8498e8a1ce -a8200a75c158fbb78474cab8a543caecd430b5d8b9964fc45d2d494dd938021cd00c7c33413ad53aa437d508f460a42a -a310091472b5b42b02176b72d5f8120bdb173025de24b420e3ca3fb9a386c39092a1d1bb591c6f68ee97a268a7ff9e95 -b23f1bf8bcec9cb5232b407115eead855fd06f5bf86ba322ad61d45460c84f0f36911aba303de788c9a0878207eac288 -ae4c129ad6d08be44690bb84370e48bfd92c5d87940750ee2c98c9a2604456f7f42727ab211989657bb202f6d907df04 -95992057d654f3e189a859346aa9aa009f074cb193b7f5720fa70c2b7c9ce887d886f6cff93fa57c1f7c8eaa187603f6 -ad12d560273963da94151dd6be49c665d7624011c67d54ab41447452a866bc997e92a80bdd9ca56a03528e72c456dc76 -8e4eda72e9cfcaa07265bb6a66d88e9ce3390ae1a6b8831045b36ea4156b53d23724824d0f0bca250ce850c5926fa38f -980fe29c1a267c556532c46130fb54a811944bdfea263f1afcdab248fa85591c22ac26167f4133372b18d9f5cce83707 -a7da9f99ddde16c0eac63d534a6b6776ad89b48a5b9718a2f2331dce903a100a2b7855cf7b257565a326ddc76adc71a5 -8ca854c55e256efd790940cb01125f293e60a390b5bd3e7a60e13ac11a24f350a7eb5ebddfa0a2890905ca0f1980b315 -9440335818859b5e8f180893a8acedceabaaa44e320286506721c639a489b5bfb80b42b28902ee87237b0bd3dd49552a -b9da545a20a5e7d60fd0c376dcaf4b144f5c5a62c8ffa7b250c53ce44be69c4e0d5e4e11422ef90593ae58ae1df0e5d3 -b75852a850687f477849fc51e0479703cd44428671c71bfdd27fe3e7930b97d2fc55f20348ca4e5bc08db2fc16a4f23c -b515081d8d099e4b6253c991ca2d3e42633f5832c64aa8f9cde23cb42c097c2c3717c46c5f178f16c58295f97b2b3fe7 -9506c9902419243e73d3197e407985dd5113f16c6be492651bbbf9576621942710aea74522d6fb56d5b52c6ccdaa4307 -952673ae27462a0f6c9545eede245c2f8e2fd6077b72a71f5672f1a5a02c263bc2a66f24f0e30376feb7a8187b715f08 -a8f1e2085ed666a8f86b474d9589dc309d5c83bd53e745f8e09abe0dfbaf53e5384c68580672990344d4aa739438b4d8 -ad6e04d4a67a5a5529ceaf7de6e19416be5b4c436610aa576ac04aee3b73317da88f891121f966393a37f52b775a2dd8 -a35a884736f08c7f76923ae7adb17fdac04e6c505178bca9502eaa2ed16d4d93fa953fb6dcf99e9e9962a6eb3eeead00 -b8af72273360bab4b3ca302cf0659717cbfb335fbc9ad4ffdd3340113ece9e63b2bdbd611e5f6b740a4689286f9a452d -b1a1f4ba2640800c3ed3892e049f6e10f8a571efa3bbe21fe2d6cee8fded171c675a3bb8aa121e2d1d715de84bad2e2b -8102a6c3598b40da4d6e8eccfdd5dadc8d6262e38b69c5b211b0732f4c6e3045d79fba12770a0b2b66f1e9f4664b1510 -90979587d75bf12819f63832beea7dcbef101f6814bf88db4575bfcd9cf0ea8eceba76d4d6db17630b73b46c1acfe011 -8dd98f14d2beb5b5b79cc30f6825ec11ed76bd5a8864593ffc0c2baffab6872bad182e1c64b93aab8dd5adb465fa5cec -8083334dadc49c84f936c603a2857f174eda5659ab2b7214572f318aba3ebd7b1c50e7cbea57272b9edf106bd016df3b -a634d08d2e8641b852e89d7ccab1bab700c32fb143bcbea132f2a5fb2968d74ded2af4107f69818798f0128cc245a8cb -94fc2dccf746d5b3027f7cf4547edf97097cd11db8d6a304c1c2ca6b3aba28c1af17c08d2bbb66f88c14472e0196a45e -b257a6fb01424b35e414c1c002e60487abb3b889d74c60cbdbf591e222739c6f97b95f6962842401f5e2009e91b28c55 -81955bdbf25741f3b85d5044898dc76ae51b1b805a51f7c72a389d3b4d94b2e3e0aa1ec271685bbcf192ed80db7367ab -86eb229b66c542514e42b113b9de7d4f146861a60f2a253264873e7de7da2ac206e156ff11f2de88491b9897174fe2f4 -8b8db00533afbb56b3d7d7a9a4a6af3cebb523699ffcb974603e54f268b3ef739c41cd11850b9651d9640d72217c3402 -8b7cbb72a6c4408d5f1b61001e65de459790444530245d47d4ee8e2d17716695283f21540bd7ac4f5a793a0d00bdf1d4 -875920b9bab4bc1712e6af89ae2e58e9928c22095026070b07e338421b554d9f96e549ac3706c6c8d73f502913a27553 -9455d192db7b039b3e8f0bc186c25ff07dfbe90dab911e3c62e3bd636db8019ed712cbb0ecd5cbb9a36c11034e102aba -8cb0b28e5d3838d69f6c12274d6b1250f8843938065d0665b347977fa3c1c685caef6930bae9483ed0d0a67005baad76 -94df2e14aae1ae2882ab22a7baf3dc768c4a72b346c2d46bfd93d394458398f91315e85dc68be371f35d5720d6ca8e11 -aacd94b416bfbeb5334032701214dd453ad6be312f303b7bec16a9b7d46ab95432a14c0fbf21a90f26aafb50ec7bb887 -b43d26963665244633cbb9b3c000cacce068c688119e94cc0dac7df0e6ee30188e53befff255977788be888a74c60fc2 -b40d67c9ad0078f61e8744be175e19c659a12065fe4363b0e88482b098b2431612e7c2fa7e519a092965de09ceafe25c -82cd4a4e547c798f89ce8b59687614aa128877e6d38b761646d03dc78f6cdd28054649fb3441bcd95c59b65a6d0dd158 -a058e9700f05cef6e40c88b154d66a818298e71ae9c2cf23e2af99a0a7dc8f57fbe529d566cb4247432e3c1dee839b08 -95c6f84406466346c0b4a2a7331ac266177fb08c493d9febb284c5ca0b141ccc17aa32407f579666b208fb187c0227dd -905d1d47a26b154f44d7531c53efbc3743ff70bd7dba50c9b9d26636767b0ae80de3963c56d4604399126f4ad41a0574 -83dfa11c520b4abaefe1b2bc1ce117806e222f373cd4fb724f3c037c228e3379d27a364e68faa73984ba73a0845f1b9a -a16e54786ba308a9c0241aff8f1bf785dece387d93bd74aa31de0969e3431479e2c0abebff9939a6644d2b0af44f80bb -81ac565212365176f5be1c0217f4e7c9fdbc9fe90f16161367635d52edcf57af79290531d2e8b585e1223d33febd957d -a296f4b09915e5d80ff7274dc3ffc9b04f0427e049ea4ef83dca91095275e8a260ef0335c7b6585953b62682da8c8e99 -a9150626208168a21ae871192ca9f11c1f7f6e41e8e02de00732de2324d0d69fe52f8762155c9913ee408a034552e49a -a42a56008ca340c6e9ff5a68c8778bb899ba5de9e7508c0cac355c157979a7ff6a6bd64f98b182114d3831cfa97ee72b -a4f05adf22c051812279258eea9eb00956b04ef095f2ca175f775ff53c710fb0020266adabd1dacaee814c4f1d965299 -967492e78ac0bceb8ad726ea0d2292b760043d16d64a6b1bb896e32630a7bf405c2b20e4e00842ae519a21697ff8db2d -adbf05e9b5931ae3dd24d105b5c523c221a486a4123c727069b9e295a5bc94f3e647a3c2cde1f9f45dbd89df411453c9 -a1759c0ebebd146ee3be0e5461a642938a8e6d0cdd2253ebd61645b227624c10c711e12615cd1e7ea9de9b83d63d1a25 -a4c5945d635b9efc89ad51f5428862aefe3d868d8fb8661911338a6d9e12b6c4e5c15a25e8cb4a7edc889b9fa2b57592 -aff127675ea6ad99cb51c6e17c055c9f8fd6c40130c195a78afdf4f9f7bc9c21eed56230adb316d681fc5cacc97187da -9071294e8ff05b246ff4526105742c8bf2d97a7e7913f4541080838ecfd2dbc67c7be664a8521af48dbc417c1b466a85 -990880b0dd576b04f4b4ce6f0c5d9ff4606ec9d3f56743ac2f469ac6a78c33d25c3105cf54f675e300ac68073b61b97a -a8d1a62ce47a4648988633ed1f22b6dea50a31d11fdddf490c81de08599f6b665e785d9d2a56be05844bd27e6d2e0933 -8ea5a6c06f2096ded450c9538da7d9e402a27d070f43646533c69de8ea7993545673a469c0e59c31520e973de71db1b4 -99d3a098782520612b98a5b1862ae91bcb338ab97d1a75536e44b36a22885f1450a50af05c76da3dd5ca3c718e69fdd4 -b987451526e0389b5fe94c8be92f4e792405745b0a76acd6f777053d0809868657ba630aa5945f4bd7ce51319f8996f7 -afffccc5ddd41313888a4f9fee189f3d20d8b2918aa5ad0617009ea6d608e7968063c71bd5e6a1d7557880d9a639328d -8ac51a02505d5cadfd158dde44932ab33984c420aeceb032ed1ee3a72770d268f9e60ccf80ce8494dfc7434b440daafd -b6543e50bd9c6f8e0862850c3d89835ddd96231527681d4ab7ae039c4a3a5a0b133a6d40cdb35c8a6c8dbb8d421d3e2b -a2ba901f4fde2b62274d0c5b4dbbea8f89518571d8f95ec0705b303b91832f7027704790a30f7d9d2cdafde92f241b3e -a6974b09280591c86998a6854a7d790f2a6fbe544770e062845cfc8f25eb48c58f5dfb1b325b21f049d81998029ad221 -890baeb336bbf6c16a65c839ffaab7b13dd3e55a3e7189f7732dbcb281b2901b6d8ba896650a55caa71f0c2219d9b70e -b694211e0556aebbe4baf9940326e648c34fda17a34e16aa4cefd0133558c8513ffb3b35e4ee436d9d879e11a44ec193 -97cf9eb2611d467421a3e0bfe5c75382696b15346f781311e4c9192b7bca5eb8eaf24fa16156f91248053d44de8c7c6f -8247f88605bd576e97128d4115a53ab1f33a730dc646c40d76c172ca2aa8641c511dddad60ee3a6fbe1bb15cac94a36c -ae7ecd1c4a5e9e6b46b67366bc85b540915623a63ab67e401d42ca1d34ae210a0d5487f2eef96d0021ebecfd8d4cd9a8 -aec5123fff0e5d395babe3cb7c3813e2888eb8d9056ad4777097e4309fb9d0928f5c224c00260a006f0e881be6a3bf8f -8101724fa0ce7c40ea165e81f3c8d52aa55951cc49b4da0696d98c9fafd933e7b6c28119aa33f12928d9f2339a1075d1 -a8360843bab19590e6f20694cdd8c15717a8539616f2c41a3e1690f904b5575adb0849226502a305baefb2ead2024974 -ade5cad933e6ed26bba796c9997b057c68821e87645c4079e38e3048ea75d8372758f8819cde85a3ab3ab8e44a7d9742 -ab1fe373fb2454174bd2bd1fe15251c6140b4ac07bda1a15e5eabf74b6f9a5b47581ef5f0dbd99fdf4d1c8c56a072af7 -b425e1af8651e2be3891213ff47a4d92df7432b8d8ea045bb6670caf37800a4cd563931a4eb13bff77575cbcae8bc14f -b274799fe9dd410e7aed7436f0c562010b3da9106dc867405822b1e593f56478645492dbc101a871f1d20acf554c3be6 -b01a62a9d529cc3156bc3e07f70e7a5614b8d005646c0d193c4feb68be0b449d02b8f0000da3404e75dbdfa9ca655186 -878b95e692d938573cdb8c3a5841de0b05e5484a61e36ea14042f4eadb8b54a24038d2f09745455715d7562b38a8e0df -a89e998e979dba65c5b1a9000ad0fd9bb1b2e1c168970f2744982781306bbe338857e2fac49c8cafda23f7cc7c22f945 -85880fdf30faed6acce9973225e8fe160e680a55fc77a31daacf9df185453ad0c0552eb3fd874698ad8e33c224f7f615 -ac28d20d4bbb35ba77366272474f90f0ed1519a0e4d5de737adee2de774ccd5f115949e309e85c5883dbc63daaa6e27b -a1758ac86db859e323f5231ad82d78acbe11d53d3ebf7e644e581b646eede079d86f90dc23b54e5de55f5b75f7ea7758 -ae4c0b84903f89353bf9a462370f0bf22c04628c38bb0caae23d6e2d91699a58bd064e3c2b1cbda7f0a675d129f67930 -95f21a099ffc21a0f9064d9b94ce227b3ff0a8c5a2af06ff5ee6b7f3248a17a8ca2f78cd7929ef1d0784f81eddefcd48 -8d06fbc1b468f12b381fd1e6108c63c0d898ddf123ea4e2e1247af115043c4f90b52796076277b722dd2b92708f80c21 -a300f39039d8b2452e63b272c6d1f6d14a808b2cd646e04476545da65b71a6e29060f879409f6941c84bde9abe3c7d01 -adecce1ccc5373072ba73930e47b17298e16d19dbb512eed88ad58d3046bb7eec9d90b3e6c9ba6b51e9119cf27ce53f2 -941a7e03a64a2885d9e7bee604ddc186f93ff792877a04209bbee2361ab4cb2aed3291f51a39be10900a1a11479282ca -acbcb1ab19f3add61d4544c5e3c1f6022e5cc20672b5dc28586e0e653819bdae18cda221bb9017dfaa89c217f9394f63 -b8d92cea7766d3562772b0f287df4d2e486657b7ab743ed31ec48fdc15b271c2b41d6264697282b359f5cb4d91200195 -957360ecb5d242f06d13c1b6d4fcd19897fb50a9a27eb1bd4882b400dc3851d0871c0c52716c05c6c6cf3dee3d389002 -abd2a23abbc903fbb00454c44b9fb4a03554a5ef04101b2f66b259101125058346d44d315b903c6d8d678132f30b1393 -ae9572beff080dd51d3c132006107a99c4271210af8fbe78beb98d24a40b782537c89308c5a2bddfdfe770f01f482550 -82c7e5a5e723938eb698602dc84d629042c1999938ebd0a55411be894bccfb2c0206ac1644e11fddd7f7ab5ee3de9fdc -aba22f23c458757dc71adb1ce7ef158f50fdd1917b24d09cfc2fbbcbe430b2d60785ab141cf35ad9f3d0a2b3e2c7f058 -8eff41278e6c512c7552469b74abedf29efa4632f800f1a1058a0b7a9d23da55d21d07fdbb954acb99de3a3e56f12df6 -8abd591e99b7e0169459861a3c2429d1087b4f5c7b3814e8cee12ecc527a14a3bdda3472409f62f49a1eb4b473f92dbf -82dcbff4c49a9970893afc965f1264fcab9bae65e8fb057f883d4417b09e547924123493501c3d6c23a5160277d22a8e -b5a919fcb448a8203ad3a271c618e7824a33fd523ed638c9af7cfe2c23e3290e904d2cd217a7f1f7170a5545f7e49264 -96d6834b592ddb9cf999ad314c89c09bedc34545eeda4698507676674b62c06cc9b5256483f4f114cd1ed9aaec2fba5e -a4e878cf4976eb5ff3b0c8f19b87de0ef10cd8ec06fe3cd0677bd6be80ba052ff721a4b836841bdffb1df79639d0446c -8e15787a8075fd45ab92503120de67beb6d37c1cc0843c4d3774e1f939ac5ed0a85dad7090d92fa217bd9d831319021b -8506c7fea5a90cd12b68fdbbae4486a630372e6fd97a96eea83a31863905def661c5cdead3cf8819515afe258dbcd4d9 -952ef3bc16a93714d611072a6d54008b5e1bf138fd92e57f40a6efb1290d6a1ffcc0e55ff7e1a6f5d106702bd06807cd -a5f7761fa0be1e160470e3e9e6ab4715992587c0a81b028c9e2cf89d6f9531c2f83c31d42b71fca4cc873d85eba74f33 -b4811f0df11ff05bf4c2c108a48eece601109304f48cde358400d4d2fa5c1fdaaf3627f31cb3a1bdd3c98862b221720d -9207ad280b0832f8687def16ad8686f6ce19beb1ca20c01b40dd49b1313f486f2cb837cfbbf243be64d1c2ab9d497c3f -b18a8c1e6363fadd881efb638013e980e4edb68c1313f3744e781ce38730e7777f0cba70ea97440318d93a77059d4a2b -901faf777867995aac092f23c99c61f97eeadf4ac6bcb7791c67fa3c495947baef494b2aace77077c966c5d427abbf92 -a123281aca1c4f98f56cff7ff2ae36862449f234d1723b2f54ebfccd2740d83bd768f9f4008b4771e56c302d7bfc764f -8cffe1266468cad1075652d0765ff9b89f19b3d385e29b40f5395b5a3ad4b157eed62e94279ac3ec5090a6bad089d8b3 -8d39870719bc4ebbcecba2c54322111b949a6ed22bda28a6cea4b150272e98c9ded48cc58fc5c6e3a6002327856726ec -b3d482c00301f6e7667aaeaf261150b322164a5a19a2fa3d7e7c7bf77dc12fa74f5b5685228ab8bf0daf4b87d9092447 -801acb8e2204afb513187936d30eb7cab61f3fbb87bfd4cd69d7f3b3ddba8e232b93050616c5a2e6daa0e64cef6d106f -ac11e18adda82d2a65e1363eb21bda612414b20202ecc0e2e80cc95679a9efa73029034b38fd8745ce7f85172a9ab639 -b631d6990d0f975a3394f800f3df1174a850b60111567784f1c4d5bba709739d8af934acfa4efc784b8fc151e3e4e423 -aeda6279b136b043415479a18b3bbff83f50e4207b113e30a9ccfd16bd1756065fc3b97553a97998a66013c6ac28f3d8 -8840b305dc893f1cb7ad9dd288f40774ec29ea7545477573a6f1b23eaee11b20304939797fd4bcab8703567929ce93ad -963cc84505a28571b705166592bffa4ea5c4eeafe86be90b3e4ae7b699aaaca968a151fe3d1e89709fe0a3f0edf5d61a -8e1ec0d0e51f89afea325051fc2fa69ab77d6c7363cc762e470a9dfa28d4827de5e50f0b474c407b8c8713bad85c4acd -909f313420403cb36c11d392cf929a4c20514aa2cb2d9c80565f79029121efd5410ef74e51faba4e9ba6d06fcf9f1bd1 -b2992b45da467e9c327ac4d8815467cf4d47518fc2094870d4355eb941534d102354fbda5ab7f53fbf9defa7e767ca13 -9563b50feb99df160946da0b435ac26f9c8b26f4470c88a62755cdf57faebeefffff41c7bdc6711511b1f33e025f6870 -a2a364d9536cd5537a4add24867deec61e38d3f5eb3490b649f61c72b20205a17545e61403d1fb0d3a6f382c75da1eb3 -89b6d7c56251304b57b1d1a4255cb588bd7a851e33bf9070ee0b1d841d5c35870f359bc0fdc0c69afe4e0a99f3b16ec2 -a8ae1ee0484fe46b13a627741ddcdae6a71c863b78aafe3852b49775a0e44732eaf54d81715b1dca06bb0f51a604b7e2 -b814ecbfbc9645c46fc3d81c7917268e86314162d270aed649171db8c8603f2bd01370f181f77dbcbcc5caf263bedc6c -8e5d7cc8aad908f3b4e96af00e108754915fecebdb54f0d78d03153d63267b67682e72cd9b427839dca94902d2f3cda7 -8fc5ff6d61dd5b1de8c94053aef5861009cb6781efcca5050172ef9502e727d648838f43df567f2e777b7d3a47c235dd -8788eea19d09e42b0e3e35eb9bcd14f643751c80c6e69a6ff3a9f1711e8031bbe82ccd854a74a5cfcf25dda663a49a62 -95d441d8cd715596343182ddcecb8566d47eaa2d957d8aea1313bbed9d643a52b954443deb90a8037a7fa51c88eec942 -a15efd36ef72783ccdc6336ef22a68cc46b1ecec0f660cfe8a055952a974342bf30f08cb808214bce69e516ff94c14c5 -acc084d36907a16de09a5299f183391e597beaf9fa27d905f74dc227701a7678a0f5a5d1be83657de45c9270a287ec69 -b3fd385764356346061570beb760ccf3808619618fd7521eb0feadc55b8153ef4986ff0cbfcbd4153ad4ea566989d72a -91ec6b26725532e8edfda109daa7ce578235f33bd858238dfa2eb6f3cd214115b44cce262a0f2f46727a96b7311d32e1 -96b867ccddb73afe1049bda018c96cfe4083fff5bb499e6a4d9fd1a88a325144f9a08cb0aee310e1bb4f6a5793777e80 -ad10c18465910152676f1bc6a40986119607b5c272488e6422cfda2eb31da741af13a50f5de84037348014a869c8e686 -86ade2dbc4cceb52b84afe1c874d1e3644691284c189761febc4804b520adf60b25817e46f3f3c08d2ab227d00b93076 -998b949af82065c709fc8f63113a9fecdd1367fc84fc3b88857d92321ba795e630ce1396a39c2e056b5acd206ee011d8 -8dec440bbd17b47dfd04e566c2d1b46f9133023b982fdc5eaeae51404bc83a593f8d10c30b24e13aec709549137cae47 -89436ff47431b99f037cddaee08bb199be836587a7db6ed740317888638e5f4bebbb86b80549edff89678fc137dfb40a -a8e9960746769b3f76246c82cd722d46d66625e124d99a1f71a790c01cec842bcf6c23c19cc7011ec972cedf54dc8a4c -980979dafedfd75ff235b37e09e17361cfdda14a5ac3db0b90ed491abfd551916016b2254538da7f4b86ece3038b1b1c -8ec340ca7654720bb9d2f209985439ebbc3f9990ef27e7d7ae366e0c45b4ed973316943122119604ea9a87fc41ebd29f -ab24440a40ab238d8cd811edb3ef99948ae0f33bf3d257b22c445204016cce22b6f06a1ca979fa72a36c4ddedc2b3195 -a1bcd2473ac7cfebfa61c10e56cae5422c6b261a4a1be60b763fcbcdf2eae4ccf80695f09b062b6cf5654dfab0ee62a5 -9027a613ce7bd827110a3a0e63e83f652e9bc7f4ce8da26c38b28ee893fd0c38bdb20f63a33470a73cb77f776244ab4a -86911cc8aeb628197a22bf44d95a0b49afb8332c38857fba8e390c27c527b8b45335e22b0f2e0a3395c16ced3c1ed2e8 -8f0529a330a3e9967dce09357d774715fd305bd9e47b53b8b71a2a1303d390942a835aa02fb865a14cfed4f6f2f33fe6 -b71ec81a64c834e7e6ef75b7f321a308943b4bad55b92f4dbaf46658613cebf7e4b5b1bc7f1cdc5d50d1a2a0690e2766 -98d66aaed9fb92f4c7bb1b488ccbca5e570aa14433028867562a561d84f673ac72e971cbe2cb3cbbb0a702797dc45a7e -8380aa94d96c6b3efd178de39f92f12ca4edd49fe3fe098b2b7781e7f3e5f81ee71d196fb8e260d1d52f2e300e72e7bc -8c36296ff907893ac58cecadd957b29f5508ae75c6cc61b15ae147b789e38c0eace67963ae62eff556221b3d64a257a2 -97e17676cbc0f62a93555375e82422ee49bc7cf56ad6c3d69bb1989d1dc043f9f7113d0ed84616dde310441b795db843 -a952229615534c7e9a715409d68e33086cdaddf0aec51f4369c4017a94ec3d7113a045054d695fb9d7fd335527259012 -817b90958246f15cbd73a9679e10192ca7f5325b41af6388b666d8436706dea94eafffbc3b8d53057f67ad726dbcd528 -95776e378c8abd9223c55cd6a2608e42e851c827b6f71ad3d4dc255c400f9eccf4847c43155f2d56af0c881abef4acfa -8476c254f4b82858ecbe128ed7d4d69a6563fd9c5f7d4defc3c67e0bfa44e41cfd78b8e2a63b0773ce3076e01d3f6a7d -a64b0b189063d31bcae1d13931e92d5ab0cfc23bf40566ac34b5b8b711d0e7d941102e6beb140547512e1fe2d9342e6c -9678460acff1f6eae81a14d5c8049cdcd50779a8719b5c5861762a035b07f7fa1b1ada8b6173f9decf051fd5a55bebd8 -88398758ce86ed0388b13413a73062adb8a026d6b044cd1e7f52142758bed397befee46f161f8a99900ae6a2b8f6b89f -a7dfaf40637c81d8b28358b6135bd7ad9cc59177bd9bc8e42ba54d687d974cdf56be0457638c46b6a18ceaa02d3c53f3 -b0e885e5d48aa8d7af498c5e00b7862ed4be1dad52002f2135d98e8f2e89ca0b36cf95b3218aad71d5b4ada403b7045b -803b0e69a89e8de138123f8da76f6c3e433402d80d2baba98cde3b775a8eda4168530a49345962c4b25a57257ba9f0a7 -8ce6ef80dadb4b1790167fbc48be10ef24248536834ff2b74887b1716c75cb5480c30aa8439c20474477f1ac69734e61 -824764396e2b1e8dcc9f83827a665ef493faec007276f118b5a1f32526340b117c0df12bea630030a131bf389ec78fc3 -874edb379ce4cc8247d071ef86e6efbd8890ba6fcb41ea7427942c140347ebf93e8cf369d1c91bd5f486eb69b45bce70 -adadcb6eb4cafa1e2a9aef3efb5b09ffa2a5cf3ce21f886d96a136336be680dabc0a7c96ec327d172072f66d6dcdbb39 -b993591b280e1f3527f083d238a8f7cf516d3cf00c3690d384881911c1495192a419b8e37872a565ce8007eb04ebe1b6 -b125faaeca3f0b9af7cb51bb30a7c446adbb9a993b11600c8b533bff43c1278de5cdda8cb46a4df46f2e42adb995bce8 -a7efe1b57326b57c2c01720d4fdf348d6a84d35f229d32a8f2eb5d2be4e561ef8aea4d4d0bcfcbf17da10a8e49835031 -a6bd4f5a87574b90a37b44f778d5c7117d78eb38f3d7874bad15ae141b60eed4ab0a7281ed747297f92e0b3fe5f9cafa -94b5e3067ca1db3c4e82daf6189d7d00246b0360cb863940840358daa36cb33857fde4c01acd0457a90e15accee7d764 -a5ff3ab12197b8a07dd80222a709271ab3b07beba453aacbaf225cfb055d729e5a17a20f0ff9e08febf307823cba4383 -a76dd8aa2b6a957ed82ecec49b72085394af22843272f19360a5b5f700910c6ec65bf2a832e1d70aa53fd6baa43c24f6 -8dfcbe4143ae63c6515f151e78e6690078a349a69bb1602b79f59dc51dea7d00d808cf3e9a88b3f390f29aaae6e69834 -8c6134b95946a1dd54126952e805aeb682bc634c17fe642d5d3d8deffffd7693c90c4cd7d112890abfd874aa26736a93 -933531875561d327c181a2e89aaaac0b53e7f506d59ef2dfc930c166446565bd3df03bab8f7d0da7c65624949cfbae2f -ac6937c5e2193395e5bb69fd45aa6a9ae76b336ea7b6fd3e6aeac124365edcba7e918ec2c663fb5142df2f3ad03411a6 -a8f0f968f2a61d61d2cf01625e6ac423b447d3e48378ea70d6ff38bc98c42e222fe3cbcb04662b19973a160dc9f868a2 -94100a36f63d5c3a6cfb903c25a228389921684cc84f123390f38f90859f37ec9714942ffe6766f9b615101a3c009e43 -b5321b07f5b1eb2c1c20b0c8ab407f72f9705b55a761ec5176c5bcc6e585a01cae78546c54117ca3428b2b63793f2e65 -9922f61ed6763d1c4d12485c142b8ff02119066b5011c43e78da1ee51f10a1cf514329874061e67b55597ca01a7b92ab -a212eb2d72af0c45c9ef547d7c34ac5c4f81a4f5ec41459c4abd83d06ec6b09fdab52f801a2209b79612ae797fa4507b -8577d2d8f17c7d90a90bab477a432602d6918ca3d2af082fbb9e83644b93e21ca0bced7f90f6e9279eaa590f4e41dc4d -9002d424e3bebd908b95c5e6a47180b7e1d83e507bfb81d6ad7903aa106df4808c55f10aa34d1dccad3fab4d3f7a453e -b9050299bf9163f6ebeff57c748cb86f587aea153c2e06e334b709a7c48c4cbfba427babf6188786a0387b0c4f50b5ce -852ae1195cc657c4d4690d4b9a5dea8e0baaa59c8de363ba5fccd9e39ec50c6aa8d2087c8b7589b19248c84608f5d0a8 -a02ff5781417ca0c476d82cf55b35615f9995dc7a482124bc486e29b0b06a215fbe3e79228c04547c143d32cd3bac645 -8d7bc95e34bc914642e514a401448b23cf58bce767bab1277697327eb47c4a99214a78b04c92d2e3f99a654308b96e34 -adb28445d3b1cc7d4e4dd1f8b992a668f6b6f777810465fdab231fd42f06b5bada290ba9ae0472110366fad033da514e -a0c72b15a609f56ff71da17b5b744d8701af24b99fbc24a88588213864f511bfa592775e9ab4d11959f4c8538dc015b8 -933205a40379d5f5a7fb62cda17873fbbd99a0aaa8773ddf4cd2707966d8f3b93a107ebfe98b2bb222fe0de33ef68d03 -90690c1a4635e2e165773249477fc07bf48b1fd4d27c1b41a8f83a898c8d3763efb289867f8d6b0d354d7f4c3f5c7320 -99858d8c4f1be5a462e17a349b60991cb8ce9990895d6e42ae762ce144abc65b5a6f6e14df6592a4a07a680e0f103b2a -b354a7da06bd93fb5269e44925295b7c5049467b5cacce68cbb3cab60135b15e2010037a889cb927e6065053af9ccb77 -af01fc4ac396d9b15a4bbd8cc4fe7b30c32a9f544d39e88cdcb9b20c1c3056f56d92583a9781ddb039ec2eeda31fb653 -a8d889fb7155f7900982cf2a65eb2121eb1cc8525bbee48fae70e5f6275c5b554e923d29ebbd9772b62109ff48fb7c99 -b80edae6e26364c28749fd17c7c10eb96787053c7744a5cc6c44082ae96c5d3a4008c899a284f2747d25b72ecb9cb3d0 -b495b37503d77e7aafc226fca575e974b7bb6af2b7488372b32055feecc465a9f2909729e6114b52a69d8726e08739cb -a877f18b1144ff22e10a4879539968a01321cecde898894cbe0c34348b5e6faa85e1597105c49653faed631b1e913ec7 -8c235c558a065f64e06b4bb4f876fe549aab73302a25d8c06a60df9fad05843915ac91b507febca6fe78c69b51b597de -b4c31398b854ccc3847065e79329a3fdae960f200c1cce020234778d9c519a244ff1988c1fbc12eb3da2540a5fa33327 -b7bd134b3460cb05abf5aed0bc3f9d0ccbfac4647324bedbdf5011da18d8b85dc4178dd128f6ddbe9d56ea58f59d0b5d -92594c786c810cf3b5d24c433c8a947f9277fe6c669e51ceb359f0ae8a2c4e513a6dad1ae71b7ded3cdca823a51e849b -b178535e043f1efcce10fbec720c05458e459fdda727753e0e412ef0114db957dc9793e58ec2c031008e8fb994145d59 -b31da7189abf3e66042053f0261c248d4da142861bfd76a9aced19559be5284523d3e309ef69843772b05e03741a13fe -b190a8c1a477e4187fecff2a93033e77e02de20aae93dda1e154598814b78fdf8b9ff574c5f63047d97e736e69621462 -98234bd1d079c52f404bf5e7f68b349a948ec1f770c999c3c98888a55d370982bfa976e7e32848a1ebb4c7694acc1740 -99b9eeb33a6fb104bba5571a3822ebe612bf4b07d720d46bde17f0db0b8e8b52165f9b569be9356a302614e43df3e087 -a1e3915b0dd90625b424303860d78e243dda73eecd01cba7c33100b30471d0a1ec378c29da0f5a297008b115be366160 -975118bf6ca718671335a427b6f2946ee7ece2d09ccfb1df08aa1e98ff8863b6c8b174c608b6b2f4b1176fb3cbc1e30d -903cb1e469694b99360a5850e2ca4201cad23cfccce15de9441e9065eb3e6e87f51cba774ab9015852abd51194c25e57 -821f7ff4d0b133e3be4e91d7ff241fa46c649ff61fc25a9fdcf23d685fe74cf6fade5729763f206876764a3d1a8e9b24 -a1ee8db859439c17e737b4b789023d8b3ce15f3294ec39684f019e1ea94b234ec8a5402bc6e910c2ed1cd22ff3add4de -af27383148757bdf6631c0ea8a5c382f65fc6ab09f3d342a808ca7e18401e437cd1df3b4383190fdf437a3b35cbcc069 -8310551d240750cef8232cd935869bad092b81add09e2e638e41aa8a50042ce25742120b25fb54ebece0b9f9bdb3f255 -8b1954e0761a6397e8da47dc07133434ebe2f32c1c80cd1f7f941f9965acdf3d0c0b1eb57f7ff45a55697d8b804e1d03 -8c11612381c6be93df17851d9f516395a14a13c7816c8556d9510472b858184bf3cc5b9d14ded8d72e8fb4729f0b23ba -b413ac49121c7e8731e536b59d5f40d73a200c4e8300f8b9f2b01df95a3dc5fe85404027fc79b0e52946e8679b3a8e43 -8451e5c1c83df9b590ec53d1f1717d44229ed0f0b6e7011d01ea355d8b351f572866b88032030af372bd9104124df55a -8d0a5c848ec43299bc3ea106847ed418876bc3cd09b2280c2a9b798c469661505ed147a8f4ffba33af0e1167fdb17508 -a6aa97a1f10709582471000b54ec046925a6ad72f2b37c4435621c9f48026d3e332b8e205b6518f11b90b476405960a9 -97696635b5a2a6c51de823eea97d529f6c94846abb0bd4c322b108825589eba9af97762484efaac04ee4847fb2fb7439 -92fd142181fe6ca8d648736866fed8bc3a158af2a305084442155ba8ce85fa1dfb31af7610c1c52a1d38686ac1306b70 -ae3da824ecc863b5229a1a683145be51dd5b81c042b3910a5409ca5009ba63330e4983020271aa4a1304b63b2a2df69e -aecc0fe31432c577c3592110c2f4058c7681c1d15cd8ed8ffb137da4de53188a5f34ca3593160936119bdcf3502bff7c -821eac5545e7f345a865a65e54807e66de3b114a31ddeb716f38fe76fdd9d117bee0d870dd37f34b91d4c070a60d81f4 -91a02abb7923f37d9d8aa9e22ded576c558188c5f6093c891c04d98ab9886893f82b25b962e9b87f3bf93d2c37a53cb9 -99a96f5d6c612ee68e840d5f052bf6a90fecfd61891d8a973e64be2e2bdd5de555b1d8bffbd2d3c66621f6e8a5072106 -b1d5ec8f833d8fbb0e320ff03141868d4a8fff09d6a401c22dbefadbb64323e6d65932879291090daf25658844c91f2e -a06afd66ebc68af507c7cf5ab514947ca7d6ccc89fb2e2e8cb6e5ae0f471473e5fba40bb84d05f2c0f97c87f9a50cb73 -83de3ca182bcf1eac0cc1db6ad9b1c2a1ecd5e394e78add7faa36e039a1b13cb0d1d2639892489df080fbf43e5cef8d5 -adf77fc7b342ff67a2eddaa4be2f04b4e6ceaca8ea89a9fc45cc892fcce8ac3cf8646cfa5aab10ac9d9706ce4c48a636 -8509a430ef8dc9a0abc30ef8f8ccdb349d66d40390fb39f0d3281f3f44acb034625361270162822ef0743d458a82b836 -8350fc09e8617826f708e8154a3280d8753e7dbbcf87e852f9b789fdbeb10bf3fed84fb76edd7b8239a920c449e2f4b7 -a2e7a29da8391a5b2d762bf86cb6ae855cdfad49821175f83f4713dd0c342a0784beba98d4948356985a44d9b8b9d0f7 -a99c50a1a88b8efe540e0f246439db73263648546d199ef0d5bc941524a07d7e02b3ef6e5b08dc9e316b0b4c6966823e -b34ba55136c341f4ca2927080a07476915b86aa820066230903f1f503afebd79f2acf52a0bc8589b148d3a9a4a99f536 -af637be5a3e71c172af1f2644d3674e022bc49c393df565ea5b05ce6401a27718c38a9232049dd18cbd5bf4f2ce65b32 -a2972ba7bfa7f40c2e175bb35048a8ef9bc296d5e5a6c4ca7ab3728f4264d64f2d81d29dce518dc86849485ff9703d7d -8c9db203e8726299adeb331d6f4c235dc3873a8022138d35796fb7098887e95e06dcfad5d766ceaa2c4fb0f8857f37fa -a82bfbaa9a6379442109e89aad0c0cfc6a27d4a5db5480741a509d549c229cb847b46a974dde9f1398c6b3010530f612 -b2d8ef6e091a76dfc04ab85a24dbe8b5a611c85f0ed529a752c2e4c04500de5b305c539d807184e05f120be2c4a05fc3 -8c6ffc66a87d38cea485d16ee6c63ce79c56b64ae413b7593f99cc9c6d3cd78ef3fa2ab8a7943d2f0e182176642adadb -acbc92de68b2b04e3dc128109511a1cbe07518042f365d5634e8b651cb1ac435ea48eeeb2b921876239183096ef6edee -979c4e1165e0ecfa17ed59fb33f70797e000ddbb64acf5fc478cccde940451df051e51b6449c5b11a36afa7868af82e3 -a5a017c5a94952aeae473976027124231abe50460cec4db3ebeb8b1290525776be7c15d108b749c2a1e4b018de827915 -8b6922ab1db925eed24b2586e95f5c709b79d2408a8fa2a71057045ead3ebdd0cc72bee23d9064cd824166eda1e29318 -89a991087a0b5805fcc5c6c5f6ac27e100da0d3713645aa9c90114e68ca9f185f21155eb7645a2c6c0616a47291fe129 -ae6ef954c942cbfd37f8f2dc58a649e2584d6777e7eb09ae6992ccde283ac4f4ec39e3a5cda7f7c60f467fb308d37f08 -9335ca5ccac59b39eb2bcef09c54b778ebb690415ba13fe5c8e4b6091d9343a01cc9baa6228cefd8dba98f0710f714da -a0211c9328be2b46f90ff13614eeffb4c1285e55580db3874610653219926af1d83bda5b089fd37a7c7440a0f1d94984 -a82e097dfa782c40808fac5d8ed1c4fccf6b95ef92e22276fd8d285303fcf18c46d8f752595a658ee5294088b9dc6fc0 -ad108fcd0ead65f7f839a1337d520f5bd0cb665ee7100fc3f0563ff1d2959eb01617de8eb7a67c9b98b7b4892082acdb -b89e6aeabcb3ee3cbf12e3c836bab29e59d49676bcf17a922f861d63141076833f4149fe9e9c3beed24edfacdf1e248b -8477501bd91211e3b1f66c3bfd399ef785271511bc9366366ce95ec5ea95d9288ab0928a6b7887aba62de4da754d3eaf -aeec40c04b279096946b743ad8171bf27988405e1321c04894d9a34e2cbd71f444ff0d14da6cda47e93aa6fe9c780d50 -a703bd2d8a5c3521a8aad92afef5162aed64e9e6343d5b0096ca87b5b5d05e28ed31ba235ab1a626943533a57872dd01 -b52d9dfc12c359efb548d7e2b36ddedaefdec0ef78eda8ac49a990b3eb0ed7668690a98d4d3c7bec4748a43df73f0271 -af887c008bad761ee267b9c1600054c9f17f9fc71acfe0d26d3b9b55536bca5c8aebe403a80aa66a1e3748bb150b20ef -ad2f7a545ef2c2a2978f25cf2402813665c156bab52c9e436d962e54913c85d815f0ba1ce57f61e944f84d9835ce05ea -91a0a9b3cfd05baf9b7df8e1fb42577ec873f8a46bb69a777a6ac9f702735d6e75e66c9257822c781c47b9f78993a46b -939fdc380fb527f9a1ddecf9c9460f37e406cd06c59ce988e361404acbfcb6379f2664a078531705dbc0c375d724137b -8bbbe5d5a0d102b8e0c8a62e7542e13c8c8a6acb88859e78d8e1d01ec0ddff71d429fcb98099e09ff0aa673c8b399dc4 -b67a70e4ef138f48258f7d905af753c962c3cc21b7b8ae8b311a2356c4753f8cd42fdee09ac5ed6de31296ead88c351a -8d21539e7dca02a271ce7d16431773bbe30e6a03f5aff517132d34cdd215ad0da2f06aa4a2a595be489234b233e0852e -892ae11513f572cc5dc8b734b716bb38c0876e50e5e942631bb380b754e9114c34b0606740301e29b27d88439fb32071 -a8780dc9faa485f51b6f93a986bc4e15b166986b13d22ec2fefc6b25403b8b81c15cc9ac0025acc09d84932b15afa09b -b01af013360cd9f2bb9789a2b909c5e010fe6ff179f15997dee1a2ba9ef1ccec19545afdecfcb476f92fcdd482bb2b5a -b5202e5d5053d3af21375d50ad1ccd92538ef9916d17c60eb55c164767c3c74681886297b6f52e258c98d0304d195d3d -8f6adbcfbb0734bf3a4609d75cf2e10f74ed855a8b07cf04ac89a73d23b2e3e5cf270a1f2547b3d73e9da033a3c514b0 -8abe529cd31e4cb2bd75fa2a5e45bd92cbe3b281e90ffc7dea01ba0df17c9a3df97a3fde373cce5d25b5814cf1128fed -b8bbf51187bb3bb124da3870e2dfecb326f25a9383e5cc3323813487457010b9055811669c3da87105050825dc98a743 -a5c83875fe61ebbdd3fd478540d7e5a1ad0f8c790bad0b7dd3a44831e2c376c4fffbc6b988667afa1b67bfaa2dbbb256 -a0606b3062e4beba9031ba2a8e6e90aa5a43ba7321003976e721fd4eedb56486f2c5b10ba7a7f5383272f4022092eacb -b485cc5e001de6bd1bbc9cd8d777098e426d88275aaa659232f317352e1ddff3478262d06b46a573c45409bc461883e1 -916449580b64a9d8510e2f8c7aee0b467a0e93b11edc3d50725bcbc3ca53c2b8bb231fdc0fc0ed5270bf2df3f64750d9 -b2e687caa9f148c2b20a27a91bada01a88bff47faaf6ed87815db26bb6cdd93672199661654763a6b8b4b2012f59dcca -b6933f7f9dabc8fb69197571366ac61295160d25881adf2fcc8aaabc9c5ed7cf229a493fd9e2f1c2f84facd1f55fee84 -b01eb8b2cf88c75c3e31807cfc7a4d5cafded88b1974ba0a9d5aaeda95a788030898239e12843eda02873b0cabe30e2b -a3ca290fa6ce064514a3431b44ecdb390ef500629270202041f23bc2f74038147f338189c497949fb3126bae3a6e3524 -93b0f8d02bd08af74918b1c22131865aa82aba9429dc47f6b51354ba72e33a8b56684b335a44661aa87774931eb85974 -81eebeb9bd92546c37c98e0a5deba012c159f69331a89615cf40c5b95c73dcdbf3ceb46b8620d94ff44fcdad88020c1e -b350e497932382c453a27bb33d2a9e0dbadf4cd8a858b6b72d1f3a0921afc571371e22b051b97da3bb08694c4ca3a4e8 -8c7052f63ba16f14fa85d885aa857d52f04b3a899a4108493799c90c0410de7549be85bec1f539f1608924668df48e5a -b397574d1fb43de0faaea67d1d9348d67b712b1adce300d6dc497bca94e0994eef8707c285c5c9ac0a66022655a8420b -a934661d2168ae1bd95b1143c2e5c19261708aeb795abad8ec87f23dc1b352fa436de997ebb4903d97cb875adb40dc2b -acf535fa1b77255210e1b8975e0e195624c9e9ffd150286ccd531a276cadc12047a4ded6362977891e145a2bd765e6b9 -8cc32356015d7fd29738dcc13c8008cdbe487755dd87d449ab569c85d0556a1ec520dbce6c3698fc413d470c93cb0c92 -8787c7b3b890e0d3734ac1c196588cacf0a3bde65e2cf42e961e23dbf784eef14c07337d3300ed430f518b03037bd558 -99da90994030cbc2fb8a057350765acac66129a62514bbd3f4ec29d5aab8acdd5f4d69ca83efe7f62b96b36116181e79 -a306424f71e8b58dfa0a0564b2b249f0d02c795c30eee5b0ad276db60423210bba33380fb45dbe2c7fedd6ee83794819 -b207a35d31ce966282348792d53d354bbd29ac1f496f16f3d916e9adbf321dc8a14112ca44965eb67370a42f64ca1850 -89e62e208147a7f57e72290eefccb9d681baa505d615ca33325dfa7b91919214646ca9bdc7749d89c9a2ce78c1b55936 -ac2d0ec2b26552335c6c30f56925baa7f68886a0917e41cfbc6358a7c82c1cb1b536246f59638fb2de84b9e66d2e57eb -8f1487659ecc3b383cebc23a1dc417e5e1808e5c8ae77c7c9d86d5ab705e8041ce5a906a700d1e06921f899f9f0ee615 -a58f1d414f662f4b78b86cae7b0e85dfddae33c15431af47352b6e7168a96c1d307d8b93f9888871fc859f3ed61c6efc -94f3626a225ac8e38a592b9c894e3b9168f9cf7116d5e43e570368ee6ee4ab76e725a59029006a9b12d5c19ddce8f811 -b5986e2601ad9b3260e691c34f78e1a015c3286fdd55101dcef7921f6cbcc910c79025d5b2b336d2b2f6fd86ee4e041e -b6e6798ddd0255fbe5cb04a551a32d4c5d21bdfd8444ff2c879afe722af8878d0a3a2fe92d63936f1f63fea2d213febf -86bea9bfffef8bc11758f93928c9fdfae916703b110c61fa7d8fe65653f8c62c6fecd4ff66a1f1a7f3c5e349492e334c -9595a4606284569f4b41d88111320840159fd3b446e00ec8afd7ddaa53dd5268db523f011074a092f8e931fc301a8081 -83b540a6bc119bf604a7db5f6c0665c33b41c365c12c72ca4fa7b0724115bbb0ff1ae38532c3356e8bb3ac551285929f -92c6daf961ca4eb25293e1794cf85cda4333cf1c128207af8a434e7e0b45d365f0f5baaefc4ebd5cd9720c245139c6e2 -b71465f3d7dba67990afc321384a8bb17f6d59243098dbed5abd9a6ffc7a3133b301dd0c6ca3843abbaa51d0953abbed -b15d93482d2ee5b1fec7921fcc5e218c1f4a9105a554220a4fb1895c7b1d7a41f90bbf8463d195eecf919fcbe8738c51 -a79c98e70931ffd64f4dcf7157fbae601a358261e280fe607eb70cef7d87f03efa44cf6ba0f17fbb283a9c8a437d2fdb -9019d51a6873331f8fe04cb45e728a0c8724a93d904522a9915c748360ddf5cdbf426a47b24abf2005295ed2a676cbf0 -b34cc339fec9a903a0c92ce265e64626029497762ff4dcaaf9bb3994298400ce80f4fb7dbe9ec55fe0c4a522c495cb69 -8fda9be7abfe3b2033cad31661432300e2905aef45a6f9a884e97729224887a6ec13368075df88bd75c11d05247bef15 -9417d120e70d6d5ca4b9369cba255805b5083c84d62dc8afec1a716ead1f874c71a98ad102dac4224467178fe3228f62 -a0a06b64867eebb70d3ce8aaa62908a767fb55438a0af3edf9a8249cd115879cde9f7425778b66bb6778cb0afeb44512 -a44309d3e1624b62754a3a4de28b4421f1969870f005ac5dc7e15183fa5b3ad182bcd09cca44924e03fbdb22f92f8cf8 -aea80f1c3a8fc36cfb5c9357d59470915370b2bec05f51f1d0e1d4437657e2303ba2d1ac3f64cf88f2df412dff158160 -b3f1557883d91b24485123d2f3ae0fce65caa533c09345ae6b30d2ac49953acee61c880c57975be7b4f5558d3a081305 -b52cb1e56f0d147cfb58528b29c7a40bab7cfc9365f2409df7299bfc92614269ff9de3cb2500bbc4909f6a56cf4b9984 -aa4f8fd0f5f87c177ee7242f7da76d352db161846cd31523a2100c069d9e4464170eec0bffc6d4da4f9e87017b415dbd -b5b61f52242985c718461a34504f82495d73cbb4bc51f9554b7fe9799491f26826d773656225f52a1531cd5bd6103cde -ad12ba9697804ede96001181c048f95b24ba60761c93fb41f4b4a27e0f361e6b1434e9b61391bacaf0705fdaa4a3a90e -9319286cbda236f19192ae9eb8177e5a57a195c261082ba1385b20328fb83ed438f29d263dddae2f5278c09548830c4a -88b01ee88c3a7ae2c9f80317dddbaa2b7b0c3a3c23828f03ff196e244500410c9ac81c2e2d3e1f609d4b36ee1732738c -8e31f30600a9d629488d44a008c821c3c57f13734eaee5a19f0182a2de9e538fff7d982980d7fcc725c969f29f7c2572 -b215740eea98b4bb14197a803a8975700ad2f25a25ef3628eae10166d56c823301f6dd62ce3f9ebf2d42d1f33d535004 -8fb0fdb253d4bcc6693642779be13a5b816189532763dfd7da868cfacfdb87cb5ebe53b18b69dfd721f8d4baf3c1d22d -8cdd050a447f431ff792156d10381aaf83c6634a94b614dd5b428274538a9cc1f830073533b4fd0a734d6dd4f8d9c4ce -81b01ee8c72ac668ad9dd19ead2d69cac28c3525e613e036e87aa455c2da9651cc8fcc97c451a8c8a071a4eb69623cd1 -8d9e02dc9ac83f861b3745bd69216232144c47cb468a7dbc49083ed961f978e34265b3f42c400339120bdc4644fe5711 -89e9410455b34cba9db0a5ea738e150fae54dd000d61e614f3274a6c8102ba7cd05b0936f484a85711ad9da7946f51ea -91f9d4949678f8e6f4b8499899818bdd0f510da552b5d79d8e09bf3b69d706ab36524b5e86d3251318899b9223debf6b -8b3c38eec7e1926a4be5e6863038c2d38ab41057bcfa20f2b494e9a0c13bc74c3a44c653402eb62a98e934928d0ebccb -a5cfe465bfbf6e8bfbd19d5e2da2fc434bd71acd651371087450c041aa55e3c4f822361e113c6c3d58646ed3ba89d6da -918665b8810bcb8d573ca88b02a02c62eaa5a4a689efb5c564b0c9183f78144e75d91fd1603e17d2c77586cbe5932954 -997dace0b739aeb52ba786faae5bdf1d48630a90321f9ceebfa9e86d189a3d79d7b04e459ac8e4adcfe83a5ce964eb1c -a5a1ca9f0ccc88017a616d481d912aab3f0e154b673f1131c5d9c9c3f5f147d25b6392b2c31e49f7bb7eb2697d05dbec -a76e99bec509eff01bf6767a06ac97ebc6671cb58bc3d4acc2803580a874885453dbba2e1bba26e45f8d2bda5f688860 -956c1362c8123c5d9ebff7049e851235d69fa645f211ef98e2b6564f2871114a12224e0ec676738d77d23c709dd28a6c -885efede83b1a3e96417e9f2858ab0c7a576fc420e8f1f26cabf3b1abeec36bcaa63e535da177847f5e0afdb211bf347 -affca2257f292a2db52f8b1bab350093f16f27ef17e724728eeaec324e2513cd576f6d2e003cc1c6e881334cb2e8bf22 -8dac963d34dcc9d479207a586715e938c232612107bb2d0af534d8da57ad678555d7c1887fadca6551c4f736ffa61739 -b55e600a6bbde81f5a0384f17679d3facb93a7c62ca50c81a1d520cf6e8008ac0160e9763cb2ca6f2e65d93ca458783b -9485e6c5ab2ebfb51498017e3823547b6ab297d818521ceac85cd6c3aa2d85ae075a0a264ae748fc76ce96a601462ffa -b4d8abca786c0db304a6634fba9b2a40d055c737ed0f933e1739354befdae138dae3c8620a44138f50ebeaf13b91929f -8bde7ca39c7bda95b1677a206b16c3a752db76869ea23c4b445c2ff320f2ee01f7358d67a514982ee3d1fb92b7bd7229 -8f8cd0acc689b6403ee401383e36cae5db2ff36fc2311bbadf8ebb6c31cbcc2ca4ffac4c049da5ba387761ef5ec93b02 -a06f42d5f69a566ff959139c707355bbf7aa033c08d853dce43f74a9933e6d7b90e72010ef3fcb3d12e25852343d1d31 -b10ece7cf6b69a76dba453b41049db0cdf13d116cf09c625312b150ee7437abd71d921eda872403d7d7ce7af1e6dccb7 -a3d820318e0f3b54fba7a4567912a82d6e6adf22b67cfc39784683a8e75f77538e793d9708aae228fa48a71abb596195 -8758fad55b68a260bea3bd113e078fd58d64a92f7935ff877f9f77d8adc0994b27040cfc850126c7777cfdfb2428a3e5 -b504913ee96c10f00b848cd417c555a24bc549bf5c7306140eff0af2ada8cb5e76bed1adb188e494332b210fbf24e781 -a00e019a40acc7aab84c1cc27c69920ad7205c2a3dc9e908a7ef59383695c9cb7093c4bcbc2945aab2655119552e3810 -b1000b4c4f306672e39d634e5e2026886a99930d81b8670a5d4046db9621e44997c4b78f583374a09c60995f18a6fd4f -a6c5053c4e748540ad2b622c28896c9d4ca3978ca4784ac8f09da5314a245f5cdc5d6203c84e6e0bcb3081829720a56d -8e37e67a70205a5c7da95de94ac4d0ebd287c1c9922d60c18eec1705030dfcbf74ae179e377c008bf5a8bc29c7c07cce -a66bd7c0243319b553d5cb7013f17e3504216e8b51ba4f0947b008c53bcb6b4979286b614a4a828ee40d58b5ef83e527 -97e2110b0fb485508a2d82ecc2ce1fbe9e12e188f06c7ef2ac81caeeb3aca2c00e5e6c031243b5ca870a9692e1c4e69b -8734ce8bbc862e12bea5f18d8a8d941d7b16a56ef714792fed912ca9c087497e69b6481fdf14efe1f9d1af0a77dac9b1 -b441dddac94a6a6ae967e0e8d7ab9a52eb9525fb7039e42665e33d697e9a39c7dcef19c28932fb3736e5651d56944756 -918b8997f2d99a3a6150d738daed2ff9eb1f5ed4a1c432d18eab4a898297f7ffbffd1e4ae9037acf589b1cd9e1185ef6 -a0247b8ac4d708cf6b398dc2d5c127a291d98e8bef5f195f820c4fddb490574ba4f62647c2d725237a3e4856eec73af0 -b45636e7e0a823c2a32e8529bb06fcccfd88e9964f61201ee116279223ed77458811d1b23bcb6b70508d16d4570a7afb -a99c1188fa22b30b04fda180d2733586ea6ef414618f1f766d240c71f66b453900d3645541c019361027aebe0a0f305f -b4c2f758e27fe233f7e590e8e0c6de88441164da3fcd5211a228318d3066dfdafc1d40246dd194f2b597f6fe9600b3d7 -972530819445b11374c3043d7855d5f1d3c4922b3b205d0bf40162c51605375dd0b61f49cd7f3d39a533a86a13005989 -992b533a13e5d790259bfdfdf1074f84a5e5a0a0d7be9cd6568cdc1662524f1a6666a46da36cea3792ba6707850f4d86 -9875d130457e04dc6ea2607309bfbb900ad3cb5f3e0574f808d27b20cbf6f88389d87dca19998680c5bc30d1df30a41b -adea8494a69e83221edf360ab847272b5c47eba5404665fb743d98c0682732c30085ae3ec82bc1e8e4aba8454c9b1849 -887d4c624ce05e224216c5f6fa13c5741012ac33330bc291754782f0bfe668decdc98c0e43a1ce28323effe6b639f477 -ab6b167aeb5e93ab155990b94895e7e7ff6dea91384854a42cc8a3b9983495b4b3c33ab1b60b2b6450ccf0418fada158 -a7588d0b7c6a6bc32fc474aa0f4e51dfb8e6e010346ad32c59d6f99e6f0522424111a03a4f56ba4075da8009ee7a63e9 -94d645cc3936db1563568193639badfc064dd5bda8d0631804ee00b09e141b200619e07506b5a8225130541436327194 -8d695c03cc51530bdc01ee8afcd424e1460d2c009e1d7765c335368e5c563cf01a2373c32a36400c10e2bf23c185ed19 -ad824a0a7ed5528e1f9992cbb2050785e092b1ea73edd7fb92b174849794a5b04059e276f2941e945bc0f3e46172f2af -ad6ed2af077a495d84f8eeed7d340b75c0d1c8b7c5a854dfc63ab40a3d0c2b0d45016d30b3373a13f0caae549f657976 -82454126c666023c5028599a24be76d8776d49951dfe403ebf9a5739b8eb2480c6934a34010d32cd384c91c62a9aa251 -b57070006793eca9fa2f5237453ed853994ad22c21deb9b835e1fb3fbc5ac73aec265a4a08de7afae1610dc8c42b7745 -ad94667c791cf58875eb77eb17b6ad02de44e4ba2ddc2efe4d0ff22a5e1a090c670354437847349fd61edc4ba5606f07 -b2aac0c345ffc00badaab331c12a22019617b004d32c099c78fa406d683744d96d51d1237ad0842f9f54655186f8f95b -8fed51076cc939b354e3b69034a594e6c9c98425ccf546154ab087a195375128444732388d2eb28f82877de971ec2f58 -8e521c0093deb9dff37888893db8ffebc139984e7701e68b94d053c544c1be0d85f0f98d84b2657933647b17e10a474c -a2c6c9a307aff9b1dea85f90fa9e3b8057fd854835055edeb73842a7ef7c5ae63d97c51fec19dd8f15d696a18a0424a6 -a3390b25a9c11344ed1e8a0de44c848313026067a0f289481673c2c0e7883a8fc9f6cab6ccd9129729a6d8d0a2498dc2 -82770c42b1c67bbd8698c7fe84dd38cc5f2ad69a898097a33b5d7c5638928eb1520df2cb29853d1fa86a0f1bcc1187e8 -a6fdf7a4af67bc4708b1d589135df81607332a410741f6e1cc87b92362a4d7a1a791b191e145be915aa2d8531ee7a150 -aecac69574188afc5b6394f48ba39607fe5bb2aa1bd606bc0848128a3630d7d27101eb2cea1fb3e6f9380353a1bb2acc -a23fd0c52c95d0dffb7c17ec45b79bf48ed3f760a3a035626f00b6fe151af2e8b83561d0b9f042eaae99fde4cbd0788d -a5f98068525cdd9b9af60e0353beb3ac5ac61e6d3bac1322e55c94b3d29909d414f7f3a3f897d5ae61f86226219215c6 -b2a4d724faac0adf0637c303ff493a1d269b2cdbec5f514c027d2d81af0d740de04fb40c07344e224908f81f5e303c61 -adeadb3521e1f32ef7def50512854b5d99552e540ec0a58ea8e601008de377538c44e593e99060af76f6126d40477641 -a18b7fc2fcd78404fed664272e0fef08766a3e2bc2a46301451df158bd6c1c8aa8cf674dd4d5b3dedfaceb9dd8a68ae3 -83bcfb49313d6db08b58c6827486224115ceef01ca96c620e105f06954298e301399cdd657a5ff6df0b0c696feec1a08 -8c94391eba496e53428ec76dfe5fa38f773c55c0f34a567823316522a0664a3d92bff38ec21cf62ac061d7d1030650c5 -b1fa196ccfd7d5f1535b2e1c002b5cde01165c444757c606b9848bc5f11b7960973038fb7cc3da24300fc1848e34c9af -b139f6c6449449638de220c9d294e53fc09865a171756d63bbf28ec7916bf554f587c24bddf51dd44372d15260d8fe25 -b716242299d4ee72b5b218781b38ca5e005dcf52333364f85130615d1dbf56216af8ee2c9c652d82f7aab5345356538c -9909f24e4ad561aa31afd3a3b9456b2bd13a1d2e21e809a66af62fec5f95b504507ac50e81d2233da2b223f5443e7585 -ae863530a02cf3a757f72b945c8c0725d9f634d2ff26233478d1883595ff9a1eef69e8babffdbfa161452fc204f5b5a1 -8eb82bde283b6a6e692b30236cbf41433b03eda8dad121282772edd56f144b1ebf5fb489d18c6ce8776135771cbb91e2 -9296141fadf8dadc885fff4999c36efa25ec76c5637a8300a1a7dc9cf55bcedfe159e0ef33f90eee9be8c4f085734e10 -b6c07f2e6fcbd6c42a8b51e52fbcd5df3aa9f7c3f0b3c31021de1aec2111d0a1c36b5ab489ba126af44fd43cf31c2594 -a70ca669c357535b363d16b240fd9cb9c5ba1b648510afc21218ea034e9bf5f22717ae31ff43ef89dded95b7132fa58f -b350721f8f6b4d164fd08aca30cd4dece9b4a81aed0ac12119c9399bab691d5945814306f9a61f0106b76d4d96f7b9d6 -b6886076c9d8c344bf3fb6975173d00fa82866012894f31c17e6fc784fbc0dd2d24d6a1cddd17f7379c74566a23219aa -87636e4a83ceadc170a4b2517b19525c98e2163900401996b7a995b2f3da8d6ba2ab92f909eade65074fac07cf42f6fa -8ff61d87c4699a067a54b8540e8642f4c7be09d3783ec18318bcba903c6714fcd61be69165e07e1ca561fe98e07507de -85485d6b569ac20e6b81a9e97ef724e038f4fee482f0c294c755c7b6dad91293814f143bfcfc157f6cfa50b77b677f37 -a49256cb1970cc1011a7aed489128f9b6981f228c68d53b1214d28fbcfb921386cc7cf5059027e667a18073efa525a74 -87bc710444b0c3e6682d19307bedc99c22952af76e2d851465ee4f60e5e1146a69f9e0f0314f38a18342e04ece8e3ed3 -a671a6cabfd19121a421fdfe7732eccbb5105dfb68e8cbcf2b44ae8465c99e78c31b99730beca5bc47db6fc2f167203a -a2f3270c184629f6dfc5bf4bdd6e1b8a41e8840a1e4b152253c35c3d9e7ab4b8e3516dc999c31f567e246243e4a92141 -b9795a5a44f3f68a2460be69ecacdbb4664991ebbedffed5c95952147ad739e2874c099029412b9653d980a2d4307462 -959053faec9a966dd5a4a767a3154e4b8e4f56ca540ae53e373c565dda99fb626f725e5a5e3721c82918f8c5f2e9e0a3 -b3ef9d6a1b3cd44a3e5112819fa91cb8a7becc3f5b164c6f759f93171d568497b01c8e743f4727b341a1296a0dbadf4f -b852dfdfbe2b8c77d938fad45f00737e14eacf71d5fecbb3e4f60052ec9efb502c38c1fcecaf71da69eabe8b33852a67 -921c7007f26bdd4139e919dfe27d87b489a0bc5bd6fb341e949e4451f14c74add0489b108c9c9666a54c5455ac914a9f -86b63d73ba31c02e5337f4138e1684eccdc45ab5e4f30e952fb37d638b54ecec11010414d7a4b7aa91f7cc658f638845 -853c55e0720b66708a648933407795571fc11ad5c234e97f92faabce9e592983dfb97a1705047ee803648ecf9fbb2e5c -995fe7d1dc09bb0c3c3f9557c4146534778f5ea9c1d731c57440fdcf8094f82debf19090b5d23298da1ed71c283b3ae5 -b9c49c911a0c4d716b7baec130f9e615bfa7d504aa8766ed38878a93c22b1f6353503d4f7f425d4902239fb4689429df -80504d964246789a09dcd5c0298680afb6fe50bca3bb9c43d088f044df2424a1828de10e0dbdc5c0aac114fa6d9cf5d1 -90249351f109f6b23a49a610aaa3b2032189fd50e5e87cdc3b20f23ed4998af3a8b292bf9fbab9bd1cbe0a1371081878 -abb5f0148850f0d80b429c2b9e0038772432340ef0862ccb5dcb7347026ca95bf9a5857f538e295aebd3a6a5027adb4c -b92ac9c0f7e73150798348265e5f01f3c752480c72613c6894a95e9330bba1c642b21b9cbd8988442b5975476634b4fa -af3fbcc825abd92c6d7ea259467f27045e288f27a505e6a3c9ec864aa08fcaca0d4123034513dbd4c82d4814075708ab -a738232a66030e0e9c78e093a92fcc545b10e62fb0ecb832bbbc71471b28eb6ec422a498c2402e2c6d74983df801e947 -ae60194ce2035edd1af253b9eefbb4b1b7609c9678256c89c3cb076c332a9f4442c3441ad2ecc9d73265359bdadc926c -8b2fd55e686f16725fc0addb4065f696275852320b03221fd22889825d66fae5bb986b03c47452e32b3a32c1fdfc8dfd -8e2e1a36673b7729b07e7bc5014584e1c03e9552f7440fbfda0a6a7f41953947fcdf8d666f843bfc03dcca5b06a14318 -95a3df04368c069f3fd32a20b627c5f043e952167c9e80bf5914bbf2086879909c60e089bbd488725ab977c0e6051728 -9856403b2211d0152d4eec10db7ec34c16ac35170714b75af3ebc398a676c171b24b6f370361de0f9057ba444293db14 -a2cb484b758af5fd8e2baca7f0406f849c71255e58ef110d685cd0c1137893a25d85a4d8582e3ced7dd14287faa95476 -b0f697b6a42f37916b90ab91994ae4a92c96dc71e4da527af41b9d510bc2db5a9b4f29183a758074b6437a1e62b2d1d7 -b39c49266aae46f257b7ae57322972fb1483125298f9f04c30910a70fe5629dba0ec86b94cc6ba16df3537a55e06f189 -86cd5595b5b769dfd9ceb68b11b451f6c5b2e7a9f6f6958eac8037db1c616e8a9defb68a0d6c2287494d1f18076072c1 -b462e8fa9a372d4c1888fd20708c3bed1cb00c17f7d91a0481238d6584fbbf2d238e25931154f78a17296a12825d7053 -a5ef28286628ba509bac34c9f13158d0013239fdca96b5165161f90b89d6e46295822ebdf63f22d7739911363a0e0e86 -a629a95a24e2545862b41a97ecba61b1efa792fd5555dc0599c175947e9501bffc82b05a605fd5aabc06969ccf14fff4 -af83467e4b1f23a641630cc00c38d4225ff2b4277612b204d88de12a07d9de52fb4d54a2375a7fd91eb768623c255376 -a630f29fb2e9a9e2096d7f3b2f6814ee046ebc515f6911d4bc54ad8a5a821a41511ff9dcfbe3176f35c444338ecd0288 -950dedc11bd29e01ba9744bec681ad9462127c35e9fcadfacc9405ec86b985a1b1c4f9ac374c0f1fa248212e5e170503 -82e8e7be8011ee0fd9c682d26a0ef992d0191e621d07fd46a3a5640ef93a42e1b98a33cad1f8017341a671d28caebb03 -a075860554e712398dac2fb0375067a48d0e4ca655195cefc5ccb1feb8900d77124aa52a12e4f54f7dab2a8f1c905b5b -81d2183d868f08714046128df0525653a2dc2ff9e2c3b17900139c9e315b9f4f796e0fb9d1d8cbadbaa439931c0e0879 -81fb1456969579515a75fb66560f873302088cde2edc67659b99a29172165482ca1f563758c750f00086b362ae405322 -a13c15ab19203c89208c6af48d2734bb0873b70edb660d1d5953141f44db9012528d48fb05aa91d16638cbda2ca8f0cc -8ba46eef93e4ec8d7818124a0b9fcfe2bcf84a98db3545d2b3d0192cfadc81fc667dcc22ab833c3e71508d0f3c621fe4 -b9bd60d2266a7d01e1665631a6ed6d80ffc0cd7f088f115a5d4ea785c518a8f97d955e2115b13c4960302b9825526c92 -b26fa4e87142150250876083a70c229249099331410f0e09096077fdf97b31b88dc57a3e3568d2a66a39af161cf5dfec -b9d147564124728b813d8660ba15fa030c924f0e381ad51d4e0cf11cc92537c512499d3c2983dd15f2e24ca166070d70 -b6fb44e1a111efb3890306fa911fafda88324335da07f7de729b2239921ef15b481630a89c80e228bec7ab6444a0b719 -a6cd9c7acac052909ef0cf848b6012375486b59b7bac55b42c41f0255b332c1d45a801f6212d735be8341053bd5070b9 -864258d69234786af5de874c02856fc64df51eff16d43bfb351b410402ab28f66895aec4025e370a4864f19ff30fd683 -84370fa1243b64b3669dd62e1e041ff9bd62810752603486aac3cba69978bd5f525c93cbc5f120d6f2af24db31ec3638 -b983c2cdc1a310446de71a7380b916f9866d16837855b7d4a3a6c56c54dab3e373a6fc6563b8309dc3b984d4e09275d6 -914f8587f876470f7812fa11c6f67e2dd38bf3090e8928e91fe2fe5595bee96cbe5f93d26fdced6b4e7b94f75662b35d -8b47bcb111d91aa3d80e4ceef283824aa00d1faeb6fe4111aecd9819869c0e1f6f4b6fb2018aebb07a0f997412cda031 -95b2befa98f9992450ca7ff715ae4da8c36dd8adcfef3f0097de6e3a0b68674b05cbf98734f9665051bb4562692641e0 -8bcd1651a2bfce390873a958e5ff9ca62aac5edd1b2fd0f414d6bcf2f4cf5fa828e9004a9d0629621b5e80fbbd5edb90 -af79bed3c4d63239ac050e4fa1516c8ad990e2f3d5cb0930fc9d3ce36c81c1426e6b9fe26ac6a416d148bf5025d29f8b -881257e86b7ab5af385c567fde5badf67a8e7fff9b7521931b3ce3bac60485c0fe7497339194fb7d40e1fad727c5c558 -a1b40b63482cd5109990dfb5a1f1084b114696cbbf444bf3b4200ab78c51dad62c84731879ea9d5d8d1220e297d6e78a -b472212baa2a31480791828ca5538c3dcc92e23f561b0412f8cc9e58839d1625ddcaf09c8078d31ac93470436843cd74 -8f516d252b1863cd3608d852a2857052bb2a3570066d4332fa61cb684b10ac8d1a31c8d32f2a0d1c77eee2ad7a49643d -8d20b75c51daa56117eda2fd5d7a80a62226074b6a3ff201519f2054eecfeff0aa2b2f34b63bea3f53d7d0ce5c036db9 -8282f433229e7948a286ba7f4a25deb0e0a3c5da8870562c3646757bef90ca1e8d3390b0a25b3f2bf45bf259a4569b77 -8a2dbf4b55cc74f0a085d143a88ebc8c2a75a08eab2703d13a00b747eaddc259a3dd57f7330be938131835a6da9a6a68 -aa0bc51617a938ea6a7b0570e98b8a80862dd9e1cf87e572b51b2a973e027bcd444ef08e0d7b5dee642e0da894435e91 -aa7319ca1ac4fe3cc7835e255419eeb7d5b2d9680769cc0ca11283e6147295db75713b71a9312418a8f5505cd45b783d -ab3f9c465663dc90fae327a2ee9cb7b55361a9b6fbe713540a7edd3cff1c716802fb8ad4dd8fb0c945d96b3b44c5795b -913a2ae88acffab12541fc08920ee13ab949f985a117efe9a5b2c76f69f327f60c5b5ad3fa5afa748034ac14298fc45a -9008f044183d2237b723b235953e4d8b47bec6a7b300d98075555478da173b599ba9c7c547c2f111ce1fae5ac646e7a3 -a26b4cc42b353e1c18222d2e088d7f705c36be12e01179db440f10fcfa9691d31fc4fc7e7ee47876f1624e6d44be1021 -995e75824f322294336bfa2c5d1a319f0d77f6a0709beabaf1b43015d8a78d62447eab907349524734170f0294d1ca7a -8b96f04a19dbe4edc71d1f2c6d3475ae77962e070ec5797752453283c027c6b29b6e58e8b7eb5c3f9770557be7e80b67 -8621459865234734bcfaa492ca1b89899525198a7916ccc6f078fb24c8bf01154815bb5b12e1c3d0a10bd4f1e2ea2338 -ab52174541185b72650212e10a0fe2e18ccfd4b266a81233706e6988c4af751b89af87de0989875f7b5107d8d34c6108 -966819d637bdd36db686be5a85065071cf17e1b2c53b0e59594897afc29354ecba73bf5fc6fa8d332959607f8c0a9c27 -b7411209b5ab50b3292c3a30e16f50d46351b67b716b0efb7853f75dc4e59ec530a48c121b0b5410854cd830f6c4b3ea -a5dc04adbadce0af5dc1d6096bad47081110d4233c1bf59a5c48a8e8422858620f4be89bf1f770681be2f4684ee4cce7 -af77a8f83cffb5f8d17be0ab628dedcad63226c9b13ce4975fb047f44bfef7d85e7179aa485abb581624913eddbb27ec -82bf28dc58c893c93712ce297cc0d64f70acb73a641cb4954ccf9bf17597f6d85eecf5a77c8984ab9afbe588562a0ee9 -988a7cef9a178e8edb91f3ec12f878fd68af2ac0762fa0a48a2423e24f765ed8f7837429fd8bc0e547e82e6894e63008 -a5d5969311056d84b3ee87f49286fac0bd9a7220c196cea4f9dced3b858dcdba74718eab95b38bd5d38d2d1184679c98 -af4d51b3ded0aaad8f12bef66c0616e9398fc42618852ac958e6ab2984a720a6111ac55b249d7e4523051740e12b346f -ac635b4a49f6fbb94a5f663660f28431ba9f7c5c18c36ebc84fd51e16077de7753595f64619b10c16510ecbc94c2052d -ae25eb349735ced1fe8952c023a9b186a1f628a7ddf1a4b6f682354a88f98987ac35b80b33189b016182f3428a276936 -ae3ab269690fdd94134403691ba4f5ed291c837c1f5fdc56b63b44e716526e18abb54f68ca5d880e2fb7bea38e74c287 -a748b03b2bd3fbc862572bc4ddc0579fa268ee7089bcfd0d07d0c5776afcd721302dbb67cb94128e0b1b25c75f28e09a -8f09a2aaa9ba3dfe7271f06648aba9cc1ea149e500a7902d94bb9c941a4b01d1bb80226fd0fd2a59ad72c4f85a2a95d0 -853d55ad8446fd7034e67d79e55d73a0afcb5e473ed290e1c3c7aa5497e7f6e9bbf12d513fc29e394a3dc84158a6d630 -b1610417fb404336354f384d0bf9e0eb085073005d236a0b25c515d28235cea5733d6fbd0ac0483d23d4960064306745 -86de805b3d4f6fbb75233b2cf4d22fcc589faa2ac9688b26730cb5f487a3c6800c09bb041b2c6ab0807bfd61b255d4c9 -893b38c72cf2566282ee558d8928588dca01def9ba665fcb9a8d0164ee00dedafbf9d7c6c13bcc6b823294b2e8a6a32c -8e50de7a70ac9a25b0b5cf4abc188d88141605e60ce16d74a17913a2aff3862dec8fbbf7c242cf956f0caae5bcc4c6bf -b5cf09886a4fb4ce9ea07d1601d648f9f9d1a435b5e1e216826c75197cd6dafd6b2b07d0425a4397a38d859a13fdb6dc -859dc05daf98e7f778a7e96591cc344159c1cbe1a7d017d77111db95b491da0a9272866d2638a731923ca559b2345ebe -8ff1792f77ecdfbd9962f791a89521561c7b82031a4e53725f32fe7d99634a97b43af04cbf3e0b0fdff4afa84c49eb99 -81e2cd8a221b68ae46dd7ce97563bd58767dc4ce1192b50ff385423de92206ff585107865c693c707e9d4ed05f3149fb -8fce7da7574e915def0d1a3780aa47ef79b6d13c474192bd1f510539359494ddc07e5412f9aac4fc6c8725ade4529173 -ac02f5df60242734f5ead3b8a62f712fefdb33f434f019868a0b8ddf286770244e2ddfb35e04e5243ba1e42bcd98a6a5 -a8d69783349a442c4a21ecb3abd478a63e2c24312cb2d2b3e10ea37829eb2226a9b8d05a8c9b56db79ffaa10d1f582d1 -b25b5cca48bf01535aba6d435f0d999282845d07ac168f2ca7d5dba56ee556b37eab9221abdb1809767b2de7c01866c1 -8af7e1d1f4df21857d84e5767c3abe9a04de3256652b882672b056a3ab9528e404a8597b1ad87b6644243f8c4cd3799f -a6718308dfa6992ae84fcb5361e172dbbb24a1258a6bd108fd7fc78f44cc1d91be36e423204a219a259be4ab030f27ff -b99cbe3552c1a5259e354c008b58767c53451932162e92231b1bebfc6a962eb97535966a9bd1dfd39010dfcda622d62a -a8458f6b8b259581f894e4b5ce04d865f80c5a900736ca5b7c303c64eaf11fe9cb75e094eece0424ba871b2aee9f7a46 -914f763e646107b513c88f899335d0c93688ffa6e56c3d76bff6c7d35cb35a09f70dc9f2fe31673a364119c67cd21939 -9210f2d39e04374f39b7650debe4aceeb21508f6110ab6fc0ab105ec7b99b825e65753d4d40f35fad283eeff22a63db0 -98729cf927a4222c643b2aa45b3957b418bce3f20715dd9d07997a3c66daa48dd62355dbd95a73be9f1d1516d1910964 -a602c399f1217264325b82e5467a67afed333651c9f97230baf86aec0dd4edeae1e973cafef2ea2236d6d5b26719954d -ac9632921d45900bf3be122c229ba20b105b84d0f0cba208ccdce867d3e9addfb3ef6ece9955950d41e1b98e9191ef42 -a76ce1f53e1dc82245679077cb3bca622558f2269f2d1a1d76b053896eba1c3fc29d6c94d67523beb38a47998b8c0aa7 -b22b51fcc1b328caa67cc97fb4966cb27d0916488a43248309c745cd6e2225f55ad8736d049250fa0d647e5f8daa713c -b7645c1923a6243fa652494fe9033fa0da2d32a0fb3ab7fcb40a97d784282a1ffad3646c499961d4b16dadbc3cbb6fd6 -acab12b490da690db77c4efdc8b2fe6c97ac4ba5afb5165d6647fdd743b4edbad4e78d939fc512bebcf73019c73bae40 -ad7a0fcd4e4ccb937a20e46232a6938fccf66c48a858cf14c8e3035d63db9d1486e68a6bf113227406087b94a0ece6a0 -a78605beaa50c7db7f81ab5d77a8e64180feea00347c059b15dc44c7274f542dc4c6c3a9c3760240df5f196d40f3e78b -8763315981c8efa9b8ae531b5b21cfc1bbc3da3d6de8628a11dcc79dee8706bd8309f9524ec84915f234e685dd744b69 -b4a6c48531190219bf11be8336ec32593b58ff8c789ee0b1024414179814df20402c94f5bfd3157f40eb50e4ef30c520 -8dac8a3f152f608ce07b44aee9f0ed6030fa993fd902e3d12f5ac70bf19f9cde2168777d2683952a00b4b3027d7b45ea -8baf7dfae8a5840c5d94eabfe8960265f6287bb8bc9d0794a6d142266667a48bec99b11d91120907592950a0dddc97d9 -b8595e6ea6b8734d8ae02118da161d3d8d47298d43128a47e13557976032dad8c2ccbfff7080261c741d84d973f65961 -8b93979c51c8d49f4f3825826a5b9121c4351e0241b60434a3c94f2c84f0b46bbf8245f4d03068676166d0280cf4f90c -aceb0fdaf20bf3be6daebf53719604d3ab865807cc2523285f8fef6f3fc4f86f92a83ad65da39de5bd3d73718a9c4bd2 -814dd41764a7d0f1a14a9c92e585f154a26c8dbf2f9bff7c63ae47f1ac588cec94f601ccc12e8a63a7a7fce75a4287f2 -b47b711848e54fa5c73efc079d0a51a095fa6f176e1e4047e4dac4a1c609e72099df905958421aee0460a645cba14006 -aaf7bd7e1282e9449c0bc3a61a4fca3e8e1f55b1c65b29e9c642bb30a8381ce6451f60c5e0403abc8cee91c121fa001f -b8b0e16e93b47f7828826e550f68e71a578a567055c83e031033c1b7f854e7fc8359662a32cc5f857b6de4aff49e8828 -b3eb70b8c8743a64e1657be22a0d5aeb093070f85a5795f0c4cb35dc555958b857c6c6b7727f45bf5bedf6e6dc079f40 -ae68987acd1666f9d5fa8b51a6d760a7fb9f85bf9413a6c80e5a4837eb8e3651a12e4d1c5105bfb5cfa0d134d0d9cfc2 -acd8fa5742b0bac8bd2e68c037b9a940f62284ff74c717f0db0c033bf8637e4f50774a25eb57f17b2db46e5a05e1d13d -a98dac386e7b00397f623f5f4b6c742c48ab3c75d619f3eaf87b1a0692baf7cb7deac13f61e7035423e339c5f9ae8abf -99169bd4d1b4c72852245ebfbc08f18a68fb5bcce6208dd6d78b512b0bc7461f5caf70472b8babf3e6be2b0276e12296 -937d908967f12bf7f728fe7287988c9b3f06c1006d7cd082e079d9820d67080736910bc7e0e458df5bae77adb9a7cbc1 -8c50e90ce67c6b297fd9406c8f9174058c29e861597a0f4ed2126d854a5632fa408dfa62ad9bb8b6b9b6b67b895d5a4d -8f4840a91b0a198226631a28e7a2e893fc6fed4d5eb3cb87b585aac7f4e780855a353631ad56731803296f931e68a8d0 -96a4b8c64d3d29765e877345383bf0e59f4ac08798ac79dd530acd7f3e693256f85823ad3130fb373d21a546fe3ca883 -b0dce7a6ab5e6e98b362442d6e365f8063ba9fef4b2461809b756b5da6f310839ac19b01d3fd96e6d6b178db4ff90ee1 -8f012cb2be5f7cb842b1ffc5b9137cafef4bd807188c1791936248570138f59f646230a1876f45b38a396cbdd3d02e08 -94a87b5ce36253491739ca5325e84d84aaff9556d83dcb718e93f3ff5d1eecf9ae09d0800a20b9e5c54a95dfebfcecd3 -b993ec5f9e82cc9ceeb7c5755d768bc68af92cc84f109dfaf9cf5feb3aa54881e43c3f598ba74ed98e8d6163377440ca -92f845d4d06a5b27d16aef942f1e3bcbe479b10fef313f9ca995315983090511701b39ccbb86b62d0c7c90a2d1f0c071 -b6ec6da0f9e7881e57fa3385f712e77f798abc523609a5b23e017bb05acc6898825541aed7fe2416c4873de129feceea -86b181183655badfe222161d4adf92a59371624a358d0ec10e72ee9fa439d8418f03d635435ec431161b79fd3fa0d611 -b5e28eeed55fb5318b06a0f63dbf23e00128d3b70358f1c6549fd21c08ef34cb1372bc0d4b0906cc18005a2f4cd349bf -85c4d3fddda61dbfb802214aa0f7fc68e81230fb6a99f312848df76cddc7b6dfd02860e8a4feb085dad1c92d9c6c65e0 -80f7fdec119309b2ac575562854f6c2918f80fc51346de4523ec32154d278f95364fdef6f93c7d3537a298dd88df7be6 -9192c1949d058614c25f99d4db48f97d64e265a15254aa6ed429e1ef61d46aa12355769f1909a5545cd925d455a57dbe -a0b1e7d928efc4dcbd79db45df026ae59c20c1a4538d650c0415ab7cb0657bc1e9daeacc3053ee547e8f9c01bdbd59c4 -893e84c41d3a56bca35652983c53c906143b9ad8d37b7c57f9dacbeb7b8dd34defc6a841f5b9857ffb90062bbd8e9dee -a7f89a448349dbc79854cf888980327f92aedc383c7fadd34fdc0eaa4f63d751315b4f979e14f188854ef4d16c9e8107 -833f2774a96187805f8d6b139c22e7476bce93bc5507344d345008080fb01b36d702b96e4c045617a23a8ca1770b4901 -80e46e86d68bd0a48ac6fa0b376d5bb93a5d6b14f08b3a47efa02bb604c8828c2047695f1f88fc5080e5548e1a37130f -943f42b7b4ad930059a26ad06b62e639f06c1c425d66066c55134e97c49abe412358c7cb994fcc1cf517ea296bca1f68 -8b9d4fe835dc6a2cbf85738937bbfb03f0119ab8df04a7d68860716ce6ee757dbe388a1e8854ddb69fe0c9fa7ed51822 -909030c7fde2591f9ea41ae6b8fa6095e6e1a14180dda478e23f9c1a87b42c082a1ea5489c98702f6ccd2ba5812d1133 -a715ec1beb421b41c5155c7ef065bbb50b691d0fa76d7df7ee47683d9e4eb69b9ea3e62fc65196a405d6e5e29e6c2c60 -8c9e801cb7ef780a535be5c2a59b03e56912acbfdb00447bfa22e8fc4b11dceecc528f848d5fba0eec4237d6f81f4c79 -b96b6af857c3bc0344082bd08ec49a9bed478d4d35b85a2099b1849cd6997521c42225305f414cdd82aef94b9e1007d3 -8764db720b4e44a4d2527f7f9b535a494a46c60e28eac06bf1569d0703c4284aefa6cb81fbba9d967286f9202d4b59ea -a66fd2f9158e1ffcdd576cba1413081f43eed00c7eb8f5919226f7b423f34ac783c1c06247819b238de150eb5a48d977 -82c52e817ac3bb0833ea055dec58c276c86ca5181811cf7a483b3703a06ea1bee90ae3aeaa2cffeaeba0b15fe5bf99be -987d07cb276f7f03a492cfb82bba6d841981518286402d3e69e730a9a0e29689a3619298124030da494e2a91974e0258 -b34f2c5740236bc6d4ae940920c5bc2d89ff62a3dd3a3ec9a0d904d812b16f483073db1e53b07f2b62e23f381d7bdbe5 -a1c0679331ab779501516681b3db9eefb7e3c0affb689e33326306ada6d7115fafd2cc8c1c57b2fa6c2072552f90a86e -94805e30d7852fc746e0c105f36961cc62648e438e8b9182fc0140dbf566ec14a37ad6e7f61cacb82596fc82aed321e5 -a42fb00b29a760141ff0faaeb7aca50b44e7bbc0a3f00e9fb8842da7abfcaae6fae9450abe6ba11e8ecf11d449cbe792 -8fb36ce4cfa6187bfe8080ac86b0fa4994f20575fb853bd8ffa57c696179cc39f58ff3b4bd5a2542ff1c8b09015539df -a1c54e7aa64df7fb85ce26521ecfc319563b687ffecd7ca9b9da594bbef03f2d39f51f6aaff9a3b5872d59388c0511c6 -855e48fdb8f771d4e824dbedff79f372fd2d9b71aa3c3ecf39e25bf935e2d6e0429934817d7356429d26bf5fd9f3dd79 -8ae6157a8026352a564de5ee76b9abb292ae598694d0ea16c60f9379e3bb9838ce7fd21def755f331482dc1c880f2306 -a78de754e826989de56fe4f52047b3ffd683c6ceaf3e569a7926f51f0a4c4203354f7b5cfa10c4880ba2a034d55a9b0d -97609477d0a1af746455bbd8cb2216adacc42f22bfd21f0d6124588cd4fec0c74d5bde2cdba04cdbfbff4ac6041b61b1 -a03dc3173417381eb427a4949c2dbfa0835ef6032e038bf4f99297acf4f0ba34a5fc8ccf7e11f95d701f24ee45b70e27 -aad6283e85cd1b873aeb8b5a3759b43343fdadc9c814a5bf2e8cf3137d686b3270f1ec2fb20d155bbfd38c7091f82c44 -92ab94ed989203a283d9c190f84479c2b683615438d37018e9c8de29c2610bb8fccd97bb935dca000d97d91f11a98d65 -8c0444a0b9feb3acb65a53014742e764fa07105e1c1db016aec84f7a3011d9adc168dbba8034da8d0d5db177a244d655 -95a33d25e682f6c542d4e81716cc1c57ef19938409df38bf8f434bc03193b07cedd4e0563414ce00ab1eebbd3256f3e7 -8716c30e3e4b3778f25c021946c6fb5813db765fde55e7e9083a8985c7c815e1b3d3b74925ba108d9a733ddf93b056af -a186aabc10f1fff820376fa4cc254211c850c23a224f967d602324daec041bbe0996bf359ed26806a8c18e13633a18a8 -a1e8489f3db6487c81be0c93bade31e4d56ec89d1a1b00c7df847f5cd7b878671015f5eaa42ee02165087991936660b9 -8f688c969c1304dfa6c1a370119d1988604026a2ab8e059016c5d33393d149aae6e56f3ee2b5d25edc20d4c6c9666ad9 -91950b651fefd13d2fa383fd0fdc022138ce064ee3b0911157768ad67ed1fb862257c06211cf429fba0865e0b1d06fc8 -86cff4080870d3e94ed5c51226a64d0e30266641272666c2348671a02049ae2e8530f5fb1c866c89b28740a9110e8478 -88732c4d9e165d4bb40fb5f98c6d17744a91ff72ca344bc0623d4b215849a420f23338d571a03dd3e973877228334111 -afcc476ad92f09cf2ac7297c5f2eb24d27896d7648ba3e78e1f538c353ceeb1e569917a2447f03f3d4d7735b92687ba5 -b622aa475e70d9b47b56f8f5026e2304d207684726fb470a0f36da7cb17c30dd952813fab6c7eb9c14579aacca76f391 -802cf5630c0407ae0d3c5cf3bef84e223e9eb81e7c697ea10ec12e029fc4697ce7385b5efab7014976dacc4eb834a841 -a08596493f4cd1b8ac2ec8604496ee66aa77f79454bb8ab6fdf84208dc7607b81406c31845d386f6ac8326a9a90e7fc5 -a54652ca9e6b7515cb16e5e60e9eabbccbc40bb52423d56f0532d0bac068aec659a16103342971f2cc68178f29f695db -a3ab54875cb4914c3a75b35d47855df50694310c49eb567f12bbc5fa56296e11f4930162700e85ba2dbfdd94c7339f91 -94183a040285259c8f56bef0f03975a75d4def33222cc7f615f0463798f01b1c25756502385020750ac20ae247f649a1 -b0004261cc47b0dc0b554b7c6ebf7adf3a5ece004f06e6db3bbac880634cdf100523b952256a796998a5c25359f12665 -a25dfeb0e18ebe0eb47339190f6a16f8e116509ab2eef4920f0d3ff354e3ead5abe7f5050b2f74f00b0885ea75b4b590 -ab10ef2f5dc0ede54e20fa8b0bce4439543db8d8b31e7f8600f926b87ec5b8eea0ac2153685c7585e062ffac9e8633c3 -8386eac1d34d033df85690807251e47d0eaacb5fe219df410ab492e9004e8adabb91de7c3e162de5388f30e03336d922 -b6f44245a7d0cb6b1e1a68f5003a9461c3d950c60b2c802e904bc4bc976d79e051900168b17c5ac70a0aed531e442964 -ad12f06af4aa5030b506e6c6f3244f79f139f48aec9fc9e89bbfbd839674cfd5b74cea5b118fb8434ba035bda20180af -88511306dfe1e480a17dba764de9b11b9126b99f340ceb17598b1c1f1e5acbdd1932301806fe7e7e5e9aa487a35e85de -a17cdf656e1492e73321134a7678296a144c9c88c9a413932d1e4ca0983e63afc9cdc20fd34b5c6a545436b4db50f699 -b555b11598a76de00df0f83f0a6b8c866c5b07f7ac2325f64fb4a0c2db5b84e0e094d747186c3c698ee4d0af259dc4c7 -88014560587365e1138d5b95c2a69bdae5d64eb475838fee387b7eb4c41d8c11925c4402b33d6360f0da257907aa2650 -b220634e6adee56e250e211e0339701b09bf1ea21cd68a6bd6ee79b37750da4efe9402001ba0b5f5cbbfcb6a29b20b0c -ac5970adc08bc9acec46121b168af1b3f4697fb38a2f90a0fbc53416a2030da4c7e5864321225526662d26f162559230 -97667115b459b270e6e0f42475f5bce4f143188efc886e0e0977fb6a31aba831a8e8149f39bc8f61848e19bcd60ceb52 -b6c456b36c40a0914417dd7395da9ed608b1d09e228c4f0880719549367f6398116bf215db67efe2813aa2d8122048f2 -ab7aef0d6cda6b4e5b82d554bd8416a566d38ded953ffd61ef1fcca92df96cdcc75b99a266205ff84180ab1c3de852a4 -81d354c70ce31174888c94e6cf28b426e7d5c4f324dc005cd3b13e22d3080f3881d883ca009800f21b0bb32fa323a0cf -94f3440965f12bee4916fcc46723135b56773adba612f5ce5400f58e4d4c21435e70518bdef4f81e595fa89e76d08fc6 -a6683e7a1147f87cbeeb5601184cc10f81bca4c3c257fd7b796a2786c83381e7698fb5d1898eb5b5457571619e89e7d6 -8ca29539600f8040793b3e25d28808127f7dc20c191827a26b830fff284739fb3fc111453ff7333d63bce334653a0875 -98a69644048b63e92670e3e460f9587cf545a05882eb5cba0bcbd2d080636a0a48147048a26743509ab3729484b3cc12 -84d40302889c03c3578c93aca9d09a1b072aadd51873a19ef4a371ca4427267615050c320165abece7f37c13a73d4857 -87954271e3de3f0b061c6469d038108aac36f148c3c97aefb24bf1d3563f342ea6c1c1c44c703e1587a801708a5e03f8 -86b6f5367e04c5caa3ec95fd5678c0df650371edac68f8719910adf1c3b9df902cc709a2bddc4b6dde334568ca8f98ac -a95fed2895a035811a5fee66ca796fdecce1157481dd422f8427033ed50c559692908d05f39cb6bea5b17f78a924633c -8ba05bdadde08a6592a506ea438dbdc3211b97ea853d1ad995681a1065ececce80f954552b1685ef8def4d2d6a72e279 -90b6b7494687923e9c5eb350e4b4b2e2fa362764d9a9d2ebb60ee2ad15b761e0850c9a293123cf2ef74d087693e41015 -8819ea00c5ea7b960eb96ab56a18c10a41fd77e150ab6c409258bc7f88a8d718d053e8f6cb5879825b86563e8740808d -91e42031d866a6c7b4fd336a2ae25da28f8bde7ace6ff15dc509708b693327884e270d889fff725e6403914546055c28 -85763642052f21cf1d8bd15fd2dc0c2b91bba076751e4c4f7a31fbdb28787b4c6a74d434d6ef58b10f3ad5cde53ef56d -8b61c36c7342a1967a1e7b4c01cddf4dce0e2025bc4a4a827c64994825f53e45277550ceb73c34bb277323fb784aa3c6 -80b9634a45c8b3770e993257bd14df6a17709243d5429969ab8b9a4645bf2a94f9b3cd3d759169887b4aa0eb50f4f78c -b5c44db9439dd8aa4edd151d95e48a25c1154e1525c337f97109f40131db81a4898344c8c3144c270bdc835c269b3477 -863080fcbc227eea32d0dc844f42dc642fbda7efc398ab698be3a3c6f3bf8803dea6ba2b51fed6151f9522b4ab2a8722 -8481e871129e9cb9d2d109c513cbba264053e75192e967f89659dcfcc1499de9ae7a1ac4f88f02289150231c70b4da01 -834d8183698d3d2d1352c22c373222cb78d0f4c8cb15e0ad82073dde273b613515ebcd184aa020f48f8e6fc18f3e223c -a227e300f0c5bc1b8d9138411413d56c274cc014ae8747ec9713f3314d5fae48bb6f8cc896f232fd066182af12c924e4 -ab7242835e91ba273de1c21eb4fca8312bdda5b63b080888b96a67a819b50294a7f17a7dc0cd87fae5e7f34bc24c209a -86eb27c898a5d6c3618c3b8927acee195d45fe3f27b0991903520a26fb8021b279e2a8015fbbba5352223ae906c7c5d6 -a61b1c200b0af25da8ad8e29f78d000a98683d1508ae92ee7f4326a7c88e0edb645b6cb5dde393ac74d322895e77ba24 -887739318c710aae457b9fe709debff63bfbb3ffbbb48a582c758b45d6bf47a7d563f954b1f085c3bc633ffd68c93902 -aacfcb0e2b0a868b1c41680487dc6600577ce00aa2edeee8c6141f4dc407217ddb4d37b79e7c9182258c750d12a91508 -ad8cd2cf5ccd350cd675a17f31b86a0e47499c6c4c11df640a5391bb10989c9c70df0a3ddeba9c89c51e15fedaf67644 -8aba897d32c7ef615c4dfa9498436529c91c488a83efc07ba9600875c90c08b00f66a51469eb901451b6e18e7f38ffd7 -aab8a600609b80e36b4a6772308bac77929a0c5d8d92bbc38e9999186a1c2bfdbef4f7a2b1efba9c17a68dc15a9373ab -b95811d1454307a30c2ac8588c8104804b06c1aec783fed75a6f12c9df626be57865850100f1ad28073e3867aca941cf -8b119d3bd4ee644469457df5d8a0020fd99b8b20bd65ab121cf95a7f55e50dd8945fcf1dff9d269d9d0b74b4edbc7726 -a980b912df832ea09353fd755aa3eec9eb4cfd07ca04387f02a27feab26efa036fca54cc290bb0c04a8a42fdfd94ce2f -91288e84da1d4ee2a4dad2df712544da3a098fdb06a5470c981fb6d6f3dcc1c141b6f426d6196ff3df6f551287179820 -98b0473bcffcbd478fd1b49895c61dd2311dab3cdec84f8e3402f8add126c439ffcb09cae3b7f8523754090d8487b5a9 -abe76988cf3065801f62a1eb3cfe9f8185bd6ab6f126c1b4b4fde497ca9118d02a0db3fadccd4ca98826b30475fa67ef -94a316a0faa177273574e9e31989576a43e9feb4cc0f67aa14d5c1967c4e10fc99db3ef4fdca2e63800a0b75f4b84256 -975ad39adadc7e69e34981be2e5dc379b325dc24dddacc0bb22311ff4a551a0020a8bdecf8ab8ac5830ca651b7b630ce -8b3bc73b640dc80ac828541b723a968fb1b51a70fa05872b5db2c2f9b16242c5fe2e8d1d01a1dbeaac67262e0088b7b0 -aa8d892a6c23dbc028aae82c1534acb430a1e7891b2a9337cedb913ff286da5715209cffb4a11008eae2578f072836cb -8dee9747a3ae8ed43ce47d3b4db24905c651663e0f70e2d6d2ddb84841272848a1106c1aa6ba7800c5a9693c8ac2804e -81e2c651b8b448f7b2319173ecdc35005c2180a1263e685a7e3a8af05e27d57ec96d1b2af2cae4e16f6382b9f6ec917c -98a9a47635de61462943f4a9098747a9cf6a9072a6d71903d2173d17c073eff3fc59b2db4168515be31e6867210ecbcd -912b2398505c45b0bb4a749c3f690b1553b76f580b57007f82f7f6cce4fadd290d6df9048258978c8a95ef9c751a59a2 -8ac8f0893fe642111ef98ae4e7b6378313a12041bbca52141e94d23152f78c2e4747ae50521fc9c5874f5eb06976e5cf -946b4a8eb05b529aaed56ac05e7abeb307b186a7835623fa4e85ed9eb41a4910663c09ea1bd932a2c467d28776b67811 -a4be51abeddd40e1da6fdb395d1c741244988ff30e10705417b508574b32dce14d08b464486114709339549794df9254 -b33b6b7d66cb013e7afeabbd7ed1e0734eb0364afe4f0f4c3093938eec15f808985fb7f3976969bf059fa95f4d8e335b -a808adbcf0049f394914482483ee0f711d9a865615ff39b5313ed997f7a0d202ad9ed6e6de5be8a5c1aaafe61df84bca -8856268be15a78465ad00b495162dc14f28d4ef4dcf2b5cba4f383472363716f66dabc961a6dbdda396e900551411e41 -b16ba931e570e1bf124ea3bd3bdf79aed8aa556697ea333e6a7d3f11d41538f98dcde893d0d9ba7050442f1515fb83b1 -91ecde1864c1a9c950fd28fa4c160958246b6f0aa9dda2a442f7222641433f1592d38763c77d3f036a3dbb535b8c6d8f -92cda991f69fbf8e55c6bf281b07fff5dbbb79d1222b8c55686480669247b60212aac27aa7cccd12fcee94e7a759b8af -b1d9b5b4e996b375d505d7250a54c12d32372c004a9cabf1497899054cb8b5584b1cef1105f87b6e97603ccbf2035260 -86e98bde8b484fb809b100f150199f13a70c80813ad8b673bf38e291595e2e362ad1fa6470d07d6fbe2cf7aeac08effc -aa12f7c39ba0597a8b15405057822e083aca3cee6ed30c4e0861eeb22620823588d96c97bb1c3776b711041c4dc3d85d -b477b34f29334f3bae69c7781d574342b7c27326088f9a622559ab93075c7357953ae84eb40e3421f453e04e9b4d5877 -9625067cb2120ce8220a469900aa1d1bb10db8fe1609988786b07eb2b88e0ddb35a3eccd4b6741e1fa2365c0db6b1134 -997b92af7765f587d70ea9718e78a05498cd523fc675ad7b0e54a4aae75fbeac55d0c8d72471471439dacd5bfcfae78d -88b59eaea802e6a2cf0c0075bf3fd6891515adcb9adf480b793f87f1e38d2188c5ed61ac83d16268182771237047ec8a -a57d078b230b1532c706a81eaabfef190fb3eb2932f4764631e916a0f0d837d6014da84ede100abaf610519b01054976 -94ed5c5b96f6afa9f2d5e57e1c847ae711839126ab6efb4b0cf10c4564ff63c819d206fdc706178eb6a0301df2434c01 -980296511019c86cc32212bad6e4a77bc5668b82a2321a1ecabc759a8bbc516183a4787c7f75f9ee7f1338691dc426cc -b10ef97db257343474601fd95f9016c205e28bd22bf7b8f9e30c3b14aca1cc9a11e6404ff412ef269c55fb101fee5a37 -b670d5d9c77fc6aa14212dd3eae100620f3510031b11a9625aa40bf31835c9fd717753b555bd159b1aa64a2104929340 -862054fabf6d6d529a7584d1a48f72d2eb216caf959c782ec36c69c26aef4595415d19a28b041946811b34a629105241 -ae4bf2ccd7b0f3774653848b5b4d39e5517dcbcff30d8441d78bc387ff42b573f16b7b0a7366e6ca5cef1dd9f0816df9 -8f810527badcb49f1542a0ccd12e3541efa084243f7106eae003458c176f4c1f01daae9d4a073c2cb2aced747e8a4576 -8a32c2067aaf6baf32db67acd4974a22a6da33db5444028a7c8c4135f9c84e102dc3b2c635b15afa6dc907d0270daffb -b15fc057f306a60b20c8487125b6b334ab749cf70eb8a30c962f625bb203ebd0d2a315949ee3b7a99e3d91acec384806 -a37f145d321359b21cba7be8b64dfae7c67a20b7b324f27c9db172d58e77a49fa02ed3d06d09d7644bf1fd81f4aab44b -b338d2e39a485ee4297adcf5e58e16c3cc331c5dffeade0be190907c1c5bdfed38537a6d81dc39a2cdfc1bc45e677886 -b69d84d8511b3aedfdc7c7e66f68b24e12e5a2365dbbe014bddd2e99e54143428cf8b74cf12c0e71316038aa5300e87e -ab210cc38661667450561a1857337879633f5d5bf2c434a3df74ff67f5c3ba69a7880872f19ae4dcbbb426462cd7d0fb -94538ef487a58a5ff93a5e9616494c5f066715d02be5b249d881a00bd0edfe2fe19dd7a5daa27f043d1dbb5ac69cf58d -afb47a899c1b25fe800241635fa05de9687a69722802ad45434f551971df91d8ca9edda0d835d82eb8f36ff9378ed7e8 -827a10d7536230887283a9b1dedccc6b95ef89cb883c4ee7b9821058b0f559704d1636670c0ada2b253bf60b7cb8a820 -97cc07965065d64409f19fb2c833b89ca3a249694b16b58818a6f49d3800926627ce0f87e5c0853ae868b4699cfdee5e -ae0c93d44780ef48ea537cf4cb8713fd49227f4b233bc074e339d754b5953e637a7289c6f965162701e4b64e4eaec26d -80953053397c4c0ba9b8e434707f183f9ced2a4c00d5c83b7dc204e247ad7febc1855daeb906c53abfdf3fe3caca30c4 -80f017e87b471b5216ebe25d807be6c027614572337f59f0b19d2d1f3125537478cb58e148f3f29b94985eac526cd92f -8a8e1c0d49801a8dd97e9e7c6955fc8b2c163a63bd6a4be90bb13e7809bb0dddc7a5025cc7d289a165d24048eac4e496 -8530e5b5c551a2e513d04e046672902c29e3bb3436b54869c6dea21bab872d84c4b90465de25dff58669c87c4c7d2292 -ae3589d389766b94428e9bde35e937ed11aac7ead3ce1b8efe4916c9bfff231d83b7e904fe203884825b41022988897a -ac02e629a900438350dd0df7134dfa33e3624169a5386ea7411177b40aa7a638e8d8aef8a528535efdbe1ca549911c0b -b1ac60b7270e789422c3871db0fa6c52946d709087b3b82e6eba0d54f478520b1dc366bb8b7f00ff4cf76e065c4146eb -a7465e1f8e57de1a087144d3c735fee2b8213fcbf2b9e987bb33c2d4f811de237bf007402e8d7f895563e88b864f7933 -8ab0007ba8984dee8695ec831d3c07524c5d253e04ec074f4d9f8bd36e076b7160eb150d33d15de5dd6e6fb94f709006 -9605bbe98dadd29504ce13078c1891eca955f08f366e681d8b5c691eadb74d6b1f2620220b823f90ef72eb4ab7098e16 -942a083d07c9cb7f415fedef01e86af4019b14ef72d8ab39fe6bd474f61ba444b9aac7776bea7e975724adb737e6337a -b9a49a8c4e210022d013b42363ac3609f90ea94b111af014f2c5754fbc2270f6846fa6a8deb81b1513bb8a5d442ea8dc -99cd62b177d5d7ce922e980cc891b4f0a5a8fa5b96dfc3204673fbef2e7fb2d7553bbacd7b2e6eca4efb5e9a86096e2e -94e30b65b3edd7472111566dde7fab0e39a17e1f462686050f7134c7d3897e977550faf00174748cbeaec6c9c928baa8 -a32fbcb29f3391d62092f2720e92b6ef4d687d8a3eae39395e0464669a64a38fe21a887f60bc9519d831b9efde27f0f4 -8f1492c4890d8f9deecb4adada35656e078754dcf40b81291e7ef9666d11ba3747a478f9420a17409d7d242cecd2808f -8942960b319ef65812d74cb1d08a492334db58d41e8437e83ddf32e387d9f3ad36834f59e6a71d1afb31263773c3ec49 -88d692f4976c99e763b027df9c2d95744d224724041dfbe35afc78b1f12626db60b9d0056b3673af3a1741eaf5f61b43 -9920cd37eab256108249a34d3f1cc487829cc5f16d1bce3a2328fe48b4de735ebde56c8b5cf4e532a4d68792387257c5 -87d34c9f5a913b806504a458c843eda9f00ff02ad982142543aa85551208cab36ebf8b3409f1c566a09a60001891a921 -a2ee8339c96f790b3cf86435860219322428b03ea7909784f750fe222bc99128d1da2670ad0b1f45e71a6856c7744e09 -84bd257f755de6e729cc3798777c8e688da0251a2c66d7ba2e0ce5470414db607f94572f5559f55648373ce70e0b560e -8d0e170714ddf5dde98b670846307ab7346d623f7e504874bfd19fbf2a96c85e91351ba198d09caa63489552b708fbc8 -9484cc95d64f5a913ed15d380c2301a74da3d489b8689f92c03c6109a99f7431feb8a07d9f39905dcef25a8e04bcec9b -b14685f67dd781f8ef3f20b4370e8a77fef558aa212982f1014f14b1bdd8b375c8a782d1b8c79efc31b41eec5aa10731 -b22fb1541aa7d2b792aa25d335d66e364193fdbf51b24a90677191cae443f0ce40a52faf5983d2cb5f91f0b62a5f20e1 -b06fa9489123ab7209d85e8c34d7122eb0c35c88ee6c4c5e8ae03a5f1ae7c497c859b0d62e0e91f5e549952330aa95a4 -b5cd71617ff848178650e6f54836d83947714d2e074d8954cfb361d9a01e578e8537d4a42eb345031e3566c294813f73 -848d39ea2975d5de89125a5cbe421496d32414032c1e2fbc96af33501d3062745b94e27dfe1798acaf9626eabff66c79 -ad35955efd5a7b6d06b15d8738c32067ffa7dd21cf24afc8ea4772e11b79b657af706ce58a7adcc3947e026768d9cdaf -aff6d7c4861ff06da7cb9252e3bd447309ad553b2f529200df304953f76b712ac8b24925cf4d80a80b1adaa2396f259a -b4b88d35e03b7404fc14880b029c188feecb4d712057f7ba9dedb77a25d4023e5a2eb29c408fde2c0329718bdaf1ff63 -88e96720e2f7c63236cca923e017ca665b867ba363bc72e653830caf585d802fad485199055b5dba94a4af2c3130a6f6 -982675dc0299aeedba4b122b9b5f523ca06d54dc35da0f21b24f7c56c07f4280265fb64cec2f130993521272c3470504 -95c77d418490e7e28293169cf7a491a7dcc138362f444c65b75d245c1b986d67c9e979a43c6bd8634dae3052df975124 -8fd6c4dff54fb2edc0bdd44ccd1f18238c145859ccd40fbfbc1cf485264445b9d55ffd4089c31a9c7a0543cc411a0398 -b153eb30af9807b5fe05d99735c97471d369c8a1af06b2e2f0b903b991eb787ab5a88c6e406e86225582acf8186ad5ef -826b55de54496751b0134583b35c0c2049b38de82821177e893feeeeb76ceeb747c7a18312cb79a6fc52f2c18f62f33e -91650d7205b232c495f1386bea0c36e136a22b645ffd4f5207f5870b9ce329c44524781c983adf2769f4c05b28a8f385 -b8d51a39162ebb38625e341caacc030913f7971f178b3eee62dc96f979495a94763ea52152198919c6dd4733bc234f64 -a1fbd3673f2ae18a61e402fe3129b7506d9142f2baca78f461579a99183c596b17d65821f00d797519e9d3c44884d8a6 -b7c5f5407263398cf0ed3f0cf3e6fcebdd05c4b8fd4656a152cedcdbf9204315f265fd8a34a2206131585fad978a0d6c -94fa71804e90f0e530a3f2853164bc90929af242e8703671aa33d2baad57928f5336e67c9efdcbd92c5e32a220b4df07 -b75dcea5ad5e3ed9d49062713c158ebc244c2e4455e7a930239998b16836b737dd632a00664fded275abe4f40a286952 -a02f7b37fc30874898618bfcc5b8ff8d85ef19f455f2120c36f4014549d68a60a0473ddfd294530dfd47f87fbd5e992d -8b48e1626917b8ba70c945fe0d92d65cab0609f0a1371fd6614d262d49fe037f96991c697904d02031ec47aab4b32f48 -b368f02c21d4af59c4d11027e583ca03ef727f2b2b7918ef623f529ceac76753a05a4ce724ce2e018da6ecc5c1c1261b -a95cba06eeae3b846fc19a36d840cbcf8036c6b0dc8c2a090afcf3434aaf5f51ef5d14b1e9189b1d8f6e4961bf39bbf8 -b32ca4dfbeb1d3114163152361754e97d3300e0647d255c34ec3025d867ed99e36d67ebafe8255b8c29be41864c08edc -8e4eddefa27d4fe581f331314d203a6a0417c481085134d8376898f9260f133e2bf48576528d62adf29953ad303e63a7 -92b7d5505833f00d5901ae16c87af028de6921c2d1752a4d08a594eb15446756ea905b0036ae6ffe6b8374e85eb49348 -b50e9018d3c4e05ba9b28b74b6634043f622d06aa8123da7cd0bc482b3131912149214d51bdfd887484422e143c3c1c0 -ab980a2f5317dfcb92baa4e2b3eb64a9ac2a755da6c11094d57e781ae5cf43e351824f1dd3abb4c6df75065b3784210b -aaabb009dfcb0bae65a0aee26ed74872c226965c52a6ed0998209e020a9ee806297dba4b15845cf61e1a514de5d125db -a1fe78f67000ebb6e90fe33e1a9dd5489be6e15fedb93b2a37a961932b77137fe85d46e89a132ecf7bcfb7aa95e16757 -85bc6e7d660180de2803d87b19ed719d3f195ea0a92baf9bfff6113c743f4237f51355b048549913e95be8ddf237864d -87a167968c4973105710e6d24ad550302ee47fe1f5079d0f9f9d49f829b9f5c1cd65d832d10fe63533e9ad1fa0ad20f5 -b2ad1a7b95b8a89d58e0b05c8b04ae6b21b571d035ae56dc935f673d2813418e21a271cccaf9d03f0d6fa311f512d28c -8268e555319992d5ac50cb457516bd80c69888d4afa5795fcc693d48a297034f51e79f877487b6f7219cfdd34f373e14 -b235411f1f6d89de3898642f9f110811e82b04ad7e960d1dd66ec7a9bf21de60e00cfabcd3004f3b5c4f89f5d9c7422a -b6963effcfe883f7ed782a3df3c40edd70f54ceca551859bcccb5d3e28fd2c1fcbdd7acc7af24a104687fd02b53c704d -862645c944e1e2909b941578cc5071afd7353fed1c2c99517e2de7573037704ef5d35accf6ec79b8269da27564209d50 -90f585eeb1a053e2f18c1280c9d6a561c0bc510b5f43cd68370ed6daac4b3749852b66c371397b6a7c1ece05ee5906c9 -876d9a3686feb79ce781e87ac3e3fbeef747b6ab031285e808c8a73f73f55b44507850dcaa745c0791d2cae8ad61d74e -a7ecc3b8c10de41a7bd9527228a0d3b695a651a5b5cb552a3664a887077d39ee60e649aecd68ed630da6288d9c3074ad -83529f1f2b4dc731ea05c1ee602fa2e4c3eebe2f963f3625959ba47657be30716d64e05e8b7e645a98bf71c237d9c189 -834ca6b14428c30a4bc8d5a795596820af6f3606f85bee9f3008f3fb94b3adffa968d21a29e2588d7a473d8b5d3a8b42 -b8d08cd8b73430984fd16e8db0525ae2b76253c92cccd7b3470add4d12d082eafb55a72bde04870924d0bdaf61f76c5d -96ef32df669690c2391f82136fc720231e4a185c90ba79eef7beaadedf7fbeb56ed264825564bdc7da01829b47f4aa88 -93d637b2f04d71891a80a1ee93fd9c9046d671bc4c15c4e597cfcc36f4ae85a7efc111359628965fd10d36c39129b160 -89f28dd3f7bc43749d0e3750c136385d4ffaf2c40354d3be38341416d755de7886d8108d83721b36f99feb3bccd73c88 -ac6392e274659f4c293e5cb19859828f101959c4c0939920a8dfed0e2df24a0cbf89a7aa983e947318c58791c893928e -83b2d4ce42c2fa0f672cd911365d1f1a3e19f1c38f32bedc82820ad665d83ae5fac4068e4eca6907bd116898966fed92 -b5e0144d6e59a9d178d4ee9f8c5dba18d22747fcdf8dc4d96d4596a6e048e384cd1e211065f34109c9ed6b96010d37e5 -b1a65e6b38c9e84b3937404d5b86c803c2dac2b369a97cbf532cfdd9478ee7972cf42677296ad23a094da748d910bc48 -849d7f012df85c4c881b4d5c5859ab3fb12407b3258799cfc2cb0a48ae07305923d7c984ff168b3e7166698368a0653d -84d9b7ee22bf4e779c5b1dd5f2d378ef74878899e9dbb475dfdcd30c2d13460f97f71c2e142c4442160b467a84f1c57d -964e497ef289fac7e67673a6cb0e6f0462cd27fc417479ecb5eb882e83be594977fb0c15a360418886aece1aaf9f4828 -ae1226222098a38ce71f88ab72de6ededb2497e30580e7ae63d4829dcc9c093bdd486102b7a7441cb06253cf0df93772 -a72865b66d79009b759022e53b9eedbd647ff4b1aab5d98b188100d01fc6b5d8c02b80eb6f53dc686f1fdda47d4722b8 -93aa8d7d8400bdfa736521133c8485c973d6d989ec0a81db503074fe46957a3999880fd9e4e7f44de92adf6ac0abe99b -a75e5ab84399962ada1f9ebcfc29f64405a1b17cd0a983950d0595b17f66386393d95a5aa4c6c878408984141625141c -91b1e5e75f4b55ec2e8f922897537082a1414eedc2bc92608376a626d8752d5d94f22f0e78ea1970eb0e7969874ad203 -83bf9c308424ef4711bfa2324d722f550d95f37d7f7b4de0487ccf952b89d7219ca94e7fa25bee60309efefd9a0e4716 -a42060476c425ff7979456d3c5484bc205fb1ef2d7149554a4d483d48e2a19119f708c263e902943bcf20a47e6c7d605 -8170c45ea126e6367aa5f4a44b27f7489a5dd50202cb7c69f27a2bdf86d22cf6b00613b0080d75fca22439eeaaaa9707 -8e5a82da70617697e42c6b829e1889b550c9d481408fe4cf8dc9d01daccabdec01f9e1b8c27dc84902a615d539bf9bc6 -80606c51401d0bf5f2700ebce694c807ab1f7d668920bdcccef2775e0939472419a8f404567bd4f9355095517eb4d628 -a40314565d60d0ddf8995673e8c643b1baa77a143b3d29433263730a6871032260abc1320e95af8287b90aa316133da0 -a87e07e84435f9e8a51ce155cd3096aa4b20d18e493c9dcbc0ac997ac180f3a255bf68ccd8195f2564d35ec60551a628 -84d2ab98416643c457bf7ddd9f1aa82967ecea189db08f3558f56803fe7001693ed67ec6ca8574c81ec1293b84a7c542 -937c3b955889ceae77f28054ce53d75f33cfe3a04f28e049cea8b8ade2a0440d5e2e8c4f377e6c1ae2115d68cc95fc16 -885a911f16845fe587b15ce7cd18cc2a84295bf609732340f74e0f5275b698cffed3e9aa1440e19e6940a7fa8f24c89c -ad90059a50c399996aaa0a10a8f637b7bab0dd5d9100301f0159a2c816596da55c30b2568d1717705fd2826b117a42d6 -828de9ff1e095c189da1f1ee18009afe14613ac696025add6f4e330488e02d5f1a90be69edd9a17bfb3355a0ca77b525 -b7aedb8394064a58dd802be6457555c0cf7b94805ed00cc66f38449773f4b1865feaee3a6f166eb51b2123b89d853a4d -b09c564ff37ccea34e90f2d50a40919a94c2e10d4fa58ffeaed656f88f9f4ae712d51c751b1b8f443dc6c9506d442301 -b24882d66b2ebb0271ebb939c72308d81f653940e70d6f1bcaae352f829134aff7f37522cc42de9e7fe6243db2c4806f -8e6f8dd906e0d4eb8d883f527e926ad1d8156b500c4cfa27214450c8112267c319900de2443c87bed1e4bb4466297dd5 -ae42f4578e8d79b6aa2dca422ada767e63553a5ee913ff09cb18918116905b68f365720a1a8c54c62cce4475ba5cdd47 -ade639bcd5017ea83ec84689874175ed9835c91f4ec858039948010a50c2b62abc46b9aee66a26bf9387ab78f968b73e -8d310a57aeb123cc895ee2fd37edc3e36ce12743f1a794ad0e1a46d0f5e4c9a68b3f128719ed003e010f717ec8949f43 -8606c086fcf3e2f92c1b483f7e2a4d034f08aef1a9d5db9e8a598718e544b82544268a0a54dfed65b4d0e6027a901d47 -8ccd95dd673d8cfdfa5554c61bcdbe6bb5b026403a320856fe51571e7c59504fe1c035f2ad87d67827339d84c0e1a0c6 -955a7cb4afcf70f2eb78756fc3a82e85ab4330eb89a87117294809beb197d1d474001e25306e8ad71daab6928abf6d64 -ae6b44ec6294736ea853ddeb18fc00cce0ac63b38170ff0416a7825cd9a0450e2f2b340d27a7f2e9c5ac479b4cb8a5fe -a88ec3f12b7020dd593c54376597b056e70c772c0ec62c24c5bfd258b02f772161b66e5dcd95c0c0fceb23433df9ff23 -b4a83933b4de552dba45eedf3711f32714e58ae41d4dab8a6114daeb06e90a5a5732c70384150d04124ac6936ca9804b -b8b7c4fa549b0fa1dc9c1f0af0750d6573f1648767751882d41f0dd7e430e3934590757e1c8b436ac35381bdde808117 -ab598b911234a98cfde07234cfc0d2fddfc5cb9ea760212aa3e175a787ce012965c8fcfdf52d30347f5f1b79cf4a0f54 -a9d354f9dfbd1976e5921dd80cbb56b2e15df53ce099ecb4368eff416998130d7830209282aaf1d4354129845f47eb80 -8c889afff546c721969e4d8aae6e6716ad7c2e9c1914dd650e30419ee77d630efb54dfffb4ec4ff487687b1864bf5667 -94ed2fa79116c7c8c554dc306b1617834dd3eab58baf8f0d085132c4688ca4a6bd38420281283678b38970a3f02b9a94 -944fdc8f0516d22f1672193d183833d3e3b043e26807fb2123729a0216c299785b1c4e24b5aa56e9bbe74fa54d43e22a -a48521454a3e0c10a13d8e810fad9d0522c68eea841821a8e0e57811362f7064a8f9c50f79c780a02df7df8c277feaef -8f3d26670ab55e1bd63144e785203373b2b13b76cac305f0363e48a6339fac3364caa3fceb245527161fc2fac9890912 -b4d6fe71001cb4141f6d8174dd7586d617cfccb54471e1fbce30debc2b1dead62cab29565abb140b682811c6231acb03 -91dc8afc4934fcc53ef851462a055cc1c3c87d7d767e128806891738427606d2fbfa832664d2a7f95f8ffe2cf0c44dc6 -b297eb432c74071764272c1b1663547ba753e66bf026643bfc0e42a9c5cdfb05a88083ad67d6ddfe6ab290678c607b29 -b343d1df85be154faeb5b21741a5ac454ca93f70a0b83a98f5901d1be173a1b2969d43e646363c5d4975924e1912599e -b2d74a66e4dfc41128aee6a3f0ff1e5137a953ed7a2a0ab5a08d7ea75642f12bd150b965c8f786ad0caf55ef7c26be4f -a54141faa8dd9a567c3cd507e4fc9057535ffe352fa1e8a311538fe17e4a72df073fbf9371523e5390303db02321650e -8e229a58f1acc641202d2a7c7e120210b9924e048603b9f785a9787ad4688294140ef3f4508c8c332d2dedafff2485be -9523554c11d39b56e6a38b3b0fadb7a9a32a73c55e455efdcfda923aff1e9f457d1b7cbc859b5ecbb03094eae8b87d38 -a199ffdff1812aaea10cd21a02b3e7bf3d8e80e501aa20bb2105b5f4cb3d37265abcda4fd4c298d6c555e43fa34517f8 -97f1285229b07f6f9acd84559afef5daad4320de633c9898b8068c6cb3b19b4468b4445607559ddf719f97d2410e2872 -a1dfff82908c90fc38ec7108c484735f104e6ce7f06097e1e80f6545702b6a0bc2a2706203cd85162edb7e9294fdedba -b12a706311c617d6c19e964e296072afce520c2711086b827cff43a18e26577e103434c0086d9d880c709df53947b48c -88503a6f48cef2f5cd3efa96a5aacc85dc3712a3b9abbb720a2cff582a6ea3c2afc49288b6832c8599f894950843ac11 -83ed63e38dfbe062fe8c7e6bc2eeb5a116f1cc505c6b038990038de6051281f9062e761ea882906ccff69c9c5b8a4a25 -911090d5d0231dde1189408dca939daddcb69a812ac408d1326060f0220781bcc131c9229e6015540f529d9fb33d9b0a -8a8352f1d9e5c7e80276e4448f997d420d5a7e0e2d5be58ae4106f47f867d1caa478b2e714d9c3263e93e5cc4c7be08b -9362f1ea9995f9b3850ebb7c8d5bf95927ab5ea25ee00e85d7456b3bf54459798b1fffde049d445c0d0587b0ab0a1694 -8859502b391273f4a00b6c0e87e5cdae676b7baf6c402f12b3360db6a5dfb4931ece4da0e1e4d98c7a71c3d01a183a9b -a9a5edf474120f9bbec9485d8b1e6f83be68b10de3d765219b0bf3e5d2840e478f1fb2bf806d78a8b8ad22ec50cf7555 -82c75daf983b06e49f0d75a042dfaae8cc92af050293d9059d6e8b01ca3ab2597e7adfc1159ed805513488944e739fa5 -a5cf240f04a9bfa65b811702c923d209e01f9535e217fa55ae3e0d1eb3257d6749e5587e727091e860609d1df29a1305 -95608ab8ade1c9fb814bad78d9cc99a36ad3e9562d5319830e4611ceea508ef76be04639294be9062f938667e33bce6e -8e44181f35c38b02133473de15560ae6588ac744cfdaf5cdfc34f30ca8e5ff6c85eb67dddc1c7d764f96ed7717c89f06 -8007b6ddece0646b7e9b694931a6a59e65a5660c723ebdffb036cf3eb4564177725b1e858ed8bc8561220e9352f23166 -a2d9d10fa3879de69c2a5325f31d36e26a7fb789dc3058ee12e6ccdda3394b8b33f6287ba1699fce7989d81f51390465 -81993d0806f877ca59d7ffa97bd9b90c4ebf16455ea44b9fe894323c8de036c5cc64eacf3f53b51461f18fa701a5860d -a20030f457874d903b2940ec32fa482410efecb8a20e93f7406fc55ab444e6c93fa46561786e40e9bf1e3c7d5d130bc8 -80c72d4985346ac71a231e7bbbb3e4a91bf50142af0927e8eb86069303eb4ce7fca1aa5b919d5efc82f2f09b41949acb -91b857d2f47f1408494940281127ba4b9ac93525788e700889aa43402eedea002e70eded017f5f5263741ed3ee53a36c -97445d007f08e285ea7f4d25e34890e955dac97448f87d8baa408e826763c06cbd58dd26416ba038d6c28f55bcea2d3a -a409c89526c2886f6a6439e2cd477351fc7f886d1a48acc221d628e11895a4eedd426112a368a0dbd02440cd577880a8 -a2c6adc7866535f6ffc29e00be4a20fa301357e1b86dff6df5f8b395ad9fb1cdc981ff3f101a1d66672b9b22bd94ec0f -8887fc53ffc45e4335778325463b3242190f65ae5d086c294a1dd587f62dd0d6dc57ca0c784bf1acaa5bbba996af201c -9731d3261a7a0e8c7d2b11886cd7c0b6bb1f5c57816944cc146caa518565034cea250eeee44ddffaeb6e818c6b519f4d -afe91c706efb9ee9e9c871e46abde63573baa8b2ea2b61e426cd70d25de3cc8b46d94c142749094287a71f4dfadd3507 -ae7bdf6ecc4fc0d8d8a7fa7159aae063d035f96ca5a06b6438b6562a4eee2b48d9024dbe0a54cfd075eac39b7a517f2b -a382e5205bfa21a6259f42e9ebc11406b5da2aad47f7a722212fdd6fef39117dd158a9991ff95e82efa0826625168a1c -862760c80bf44c2d41c2a9a15c887889eaeea32acc894f92167fb6f72593377c228499f445ccb59794415597f038ac9e -b4e96595a91a611c4563d09f29a136a4c04f07be74dd71a6bbabc836617ecb95494e48971a8229f980b2189fd108d2e5 -b5e7200357317c36244c2e902de660d3c86774f7da348aca126e2fc2e2ba765fa0facd29eebcb3db3d306260e91a6739 -a64c7133156afee0613701189c37c1362e2b4414f7e99408e66370680c554de67832c30c211c2c678dab5cfcdcecb3f7 -88f4cb67b1db497a91a0823ee3541378133eb98777842d73e43ab99efe8aa52fa02dfb611c1691be23684618394988d6 -89a9382a147d7387d0ff9516ee0c75cd1f8ee23333f4a2c9693d1a8cbe03680bc5b10c43c238c2190db746cac409bf39 -ad510bcc067373d40b05a830bf96fac5487de1ad5b708a13f62484c09b00fba6c5b00b981004e5ab3f28e55c9a5bce26 -8384156d7117675547279ad40dc6bf81e8f9a57b2d8cfebeea6b9cd1d8534dc0cf704068bc3ba0815010cd8731d93932 -a818fb76e53165b2f86c7f2317d64cf5e45f48405a34560983cd88bfbd48369e258ce2952233a8ce09c464e07afcade6 -ab19a4ed90527e30796064634b66cdc023bc5966e2c282468f5abef7879fc52986d5bb873a796b077d10e7b374b60309 -a17dafe2484d633fe295f8533662631b0bb93cdb4e7cd6115271f20336f602f7f8b073983cd23115093c7f9891c4eef5 -804acbc149d0334c0b505a8b04f99c455a01592a12f64d1ec3b82b2f053ccc4107e47f418f813d6f400940c7c8700a4a -965e097a825d8511d095b247554ec736bcb3701ead3ba785bd425cbabd56f4b989764e0965a437fa63e7e16efd991fc0 -b6701675ca27d7a4084f06f89bd61a250b4a292ee0521b2a857c88c32b75f2a70b97f98abce563a25d57555b631844e0 -abbdf65fcbdf7d6551ccd8d6e5edc556f1ecd275ccd87ee2bda8ea577c74615f725aa66e0911e76661a77f5278e0c2b9 -ab715ae372c900239a0758a3524e42063afc605b8fb72f884dc82ab9b0ff16715f3fb2fd06f20f15f9e454f73a34e668 -b45f41ea1d25a90af80a8a67c45dea881775fed000538a15edc72e64c7aa435a5e4375dcdedc5c652397c02b0bc61b16 -86f7be9252f8ed9078e642c31a70a09639899f7ffcd7faaf1a039fec8f37e1fa318fba0ed1097f54fc55d79900265478 -a30e5ed4277dd94007d58d5a3dc2f8d3e729d14d33a83d23c44ddfc31c6eac3c6fe5eb13b5b4be81b6230cfd13517163 -87e723d916f5fcda13fab337af80354e8efe6b1c09ae5a8ceeb52df45bfca618eb4bec95fefef3404671fb21e80bf9db -a521b8a04dc3abd3e9e0454b9a395b3638e5394dc2d60e97fda61b0a1880d1d73a64a4633f3d7acbd379bde113240d03 -851686c79c5403d5f05fbaac4959fcbfdfb51151bec55e10481b3c16e3be019e449907ae782ca154f76a805543d5755d -8ec1929e746b6c62b0c3fdd8f4e255e5c707e6e0d8d57ff9e409ae2dd6e76fdb50af923749992cf92d1b5f2f770bafbc -9175f7b6820d47205c9e44f8c684833e1e81da46c1fdf918a4dcafbc3231173f68370d442a20e45f8902bcab76a4e259 -b4f66c698115333b5ac00c9fe09aa9e1e9c943fbb4cce09c7d8a6ed4f030e5d97b48e944fd6d3e69ac70f1ae49d35332 -b958878b875eead61a4416a4597b1c567ddbb1eaaa971033f4a656f01a277822c1f4ea3972045156c2a5a28d159f5ddf -8188de8ad5258024d0280137a40909d24748137ac7c045dddd2bc794eac8edd5850b9d38f568fa8174b2c0593bb57e96 -91152c7bafce7a0358152221081bc065796fa4736bfc7d78076a0a6845287cde2ee2a2c9b96f500297c0a00410634888 -a5328ab939a2d3bd4c21e5f3894c02986b6590ad551c7734be3f4e70380eb7bc19629e9031b886ce3b4074ee4edee63a -97c4d49db40e266bcedaacb55edca4e1ebf50294679b271f3a2332c841705089b5ba96ef2064040fa56c36bb1375a8d9 -85cf0514f340f9d865b32415710d7451b9d50342dbf2c99a91a502a9691c24cd3403cb20d84809101cd534408ddf74e8 -950c3d167f59f03f803dcba3f34fe841d40adc31e5be7eefff2103d84e77a7cbe4f14bd9c3dfa51cde71feb3468a9c00 -96a69624e29c0fde3b92caf75a63ac0f3921e483f52e398652f27a1ec4e3cc3202f17af1f66224731bc736a25638d3e4 -aeac4170cf4b967227f66212f25edc76157eb4fb44c84190b520ecc2946470c37da505790e225fd1b0682bef7fc12657 -a94146a04e3662c50c2580ae1dba969cbb3fb0f43a038729c9e8be6ed45860b2c7de74f248dfa50ccdbe2ecaf3f2b201 -917b8e2880e85b8db723631c539992ec42536146e7091d4a3f87d37f051b5da934d84393523814f19962c78e6cb12ef8 -931f140ff8f7de79e399f5cd8503558d566b5c2ab41671724dd38aed08dd378210f01ac8fa9911f3047993dbc10cf8c4 -859eb9b560bc36273694f8ae1a70d25e7f206013597c4855a11328162ba1254bb736f1ae41240c8ec8dea8db035e08f2 -b4ad2cb2c3a3e6ab1e174f2dbfb1787a8544f3c9109215aa6d33265ef269455e3cde9858738b4fe04711a9cf9050e7d4 -8a3b342b87b19c0cdb866afff60317e722013c02dee458ba71e7123edc8b5a9f308c533b9074c7dd0d684948467502d1 -89185ac5cc5ea8f10a1f2a3eb968bb5867376d3cff98ef7560b9a0060206c4046ff7001be10b9e4d7ad0836178eba7e4 -845f48301f25868f6d0f55b678eab1f8458e3321137dba02b4cfbb782cbc09f736a7585bf62f485e06a4e205b54a10b7 -931a6c523d4a66b51efadb7eefadba15bf639d52d1df5026d81fd1734e7f8d5b51b3f815f4370b618747e3e8eb19699c -8eb3a64fa83dcd8dd2258942aea3f11e9cf8207f2fdd7617507c6dae5ea603f9c89f19d1a75d56eaa74305a1284ce047 -912a5050ed6058221d780235fb0233207c546236316176a104a9761bc332323cf03786dbac196d80a9084790506e0a88 -945fe10ec8dc5e51aa6f8ba7dace6f489449810f664484e572bfe30c2fe6b64229f3c8801e2eb1a9cb92ff3c4428cdf7 -b62383bf99c7822efd659e3ef667efee67956c5150aea57e412cbd6cd470807dfaad65c857fada374c82fcfca2516ad1 -a727a31c45b2970d08a37e169ea578c21484dde15cb11f9c94eaaf3736652619ce9d3a44e7431d50b0e75b658ebbc1da -97bf54ea9b84b82e4616027bd903ef6152439f1c6a8e1bae6db1d10fdf016af2cac10ff539845833dfd1ddad1403aa8c -a08cf36437e010e59b2057aedb7192e04b16f1cc66382cdef3490b7ad1544ae51f03e87cba0fe43a275841c247a2a0cf -acafab9fa28c1a607df2246490b630ddda1ecf0885ad24c2ecb2c2c1b7b9c7de8066714bf5b9b25f61981d08576789ec -851f0375128d2782586223467d0a595f4c5baa79616622a32f7d6ce1f08af06f8a109bd6527f88d93367dba17be661e8 -a2f1187c2a7cbf776653ff834ed703dd32e68eaf36f0700709be929f4c0ce5fa1d9930d1e3ea2aa01c7a16239e66cb33 -b3721f4a5d24ca112f020cb3f849543bf0e7f84b470fb00126ae80aaaa6f2c208d8359cd82ad9fbafd3ef2ac70656fb2 -98773ac3ce9528c73cfd8e7b95976ce597f67e146357642ac4fb6cb35046f3f39cf6c4a7b5af5c7740dda358aa0d2d08 -92c883a5d820541692af75be1b25dd4a50a4b91f39f367a551a7d5ad6065a26b60d68221a01e4950559717b559c2626a -b82e46dd25fd1234dad26fbcd8bb5177d7b87d79d362ffb9c2f6a5c16eb2ff324d135996fcd6274d919634597869d772 -82a53ed356ced5e94d77ee2a7f6e63f2ad8240aff2d17c5012cf5d1f18512c88c24793339b565dfbb659bd7c48dcbcd2 -84d20c7859b35a1cae1ff2b486d50822f9e6858b6a1f089ce4c598970e63e7c0f7dfbcb3337845e897a9dedf9d449dd3 -974892e5cf5ee809e9353d00e9cd5253d04826a8989d30cf488528c5dcdcad7650e23b4d228c3eb81f6647d2035a9e02 -b2327854910dbf3d97fe668da5fc507e179c4bc941f39bdd62e8b6035f004449c467240f656417e501f32dee109f0365 -88888f73475613d45d0b441276b1dd55835b69adfb27e26c4186936dae047b85478cca56be8dc06107b89a28f3bbb707 -836ba22e40511feff81a5dace3df54e2c822b55e66874dd1a73929994ec29909ffc2a8e39bfc2d16e316b621eb4a5ec6 -a754cedcccf4165a8d998f326f3f37d2989f92ca36d9da066a153c4aab5a62bb0011896bcbf90f14c18e00488d4123bd -86c26fa9584314292c4b7d6fe315f65dadd0f811c699e6e45c95a7a4ea4886c57dc5417b67edd78e597d037c7689568e -b205589648aa49ef56637712490e6867aa3b85b2b31e91437a249fb51bdb31401bff57b865c9e27293b30014b4604246 -afab0843ede582e5a1898ee266235066b94ea378884eaf34919ceaacc0e2738e1074b6ed41e0a1dd9711563e24f0215d -996ed65fbcab7611eada5bd0fd592d3e44705098b8b1dfba6dcdbdcfa1382fe893fa55270a0df0be0e1938bd71ab997c -881bc448a5ef8c3756b67ecb1a378a5792525d0a5adb26cc22a36c5df69e14925f67c9cb747a2f7e5f86ba1435509d7c -b219303c02c9015c6a9a737b35fb38578ab6b85194950a0695f7d521206e1e12956cd010d4d6c3bc3fafd6415845d5d1 -91748829bbd005d2ec37fc36fee97adaccb015208b74d2f89faa2e4295679f7685298f6a94b42d93c75ca9d256487427 -a41d6fd33b9864ebc404d10a07b82ba9d733e904875f75526d9a1f1c1c08b27160dcdb9023c5d99b8ff8a3461d57281f -b68978d39c97d34f2b2fea61174e05e05e6e49cde587e818b584201cf59b7096cf1807b68f315119c6db8d6110b28a9f -b64e66cec798022d64ce52477475d27ea7340817fe7f570617f58c3a9c74071d7ea6b54743d4f520b62aecad9a3a6620 -87b2b9e1c1786b7824f239a857024780a1457e51c64599b858118885833fb87a17d408bc09dcc0607d15ec1e53683a74 -9814799bac07dab4f0c934cc3c051676ca13abd49cf8d4739864e5bb9f2a8474897695113f49239f28832a8658332846 -806931a1526a843a9c2045943d616a8102b02b1f219535a1f1fbda659a1244f1bfead52ca7f1851ff8a97169b91c9ec0 -b8678249595a9641c6404c35f89745b93d8e7b34d9d44da933a1b2f1606972624c5108f1c04eb42e454d0509f441ed9e -81426714851741045a4332eb32b6dfe6422a4a2e75b094fb7c3f37da85648c47ee8af1e54ba26f4e1b57ebe32d0e8392 -b7a1875ea3f119fe0429fd9068548f65cf2869f8519dbbce0b143e66127cb618c81d7578e8391d676b2f3963e9d87f43 -872220a803ea0c6294cdc55aceea42cfacfd7a482982bcb90c0361c351a900c46736a890609cd78f02fb5c8cc21fa04b -974f0380197b68205ff4bb2c9efe5626add52c0ad9441d7b83e6e59ddb2ed93ad4e9bbdbf33b3e0a206ed97e114ea0f2 -a840f2d9a74fca343aedb32ac970a30cbb38991f010d015dc76eb38c5bb0bfe97dd8951de925a692057262e28f2b4e9d -b0913c3ce61f12f9fdc4be3366ed514c3efc438f82fc58c4de60fe76098fbc033a580ec6e4531b9799611c89a8063a66 -a0180d533eee93b070dac618be1496f653a9a0e4e3455b58752bf1703ec68d0be33ec0b786f9431ef4208574b0ad316e -a4a6b871bc95d3aa57bed90e14a0a1dda6e7b92b7ae50e364593ce6773fbf736672b1f4c44e383af4c3cc33e017a545a -a3f44cf19fe52bacc4f911cab435a9accbe137bdbe05d34bdd8951531eb20b41d17e3540e8d81e6b3eea92c744562ee5 -ae6b6d0ff3b30ff0b7f9984ef741cba27ffb70d558de78b897199d586cf60622ec2d8a9d841712fe719cf0f97628842c -87abf72f98c81d6d3a57ab1e224fe4b502ab0d8090d8abc71791271550b721c220d4e2e7da3be94a20c0e63d98e39a50 -b2f73ebdfe7133af57353052f4599776e16862905e64d97e1020c4bb84132e476d1ab79a9fb71611410f3f9d56c95433 -ae1a928253af2b210d31e1b64c765fcbd20a96b8d53823a6b9b6e7fc62249abf4a66c6a6aedb0b687e7384af9a845e0d -99c54398627833ca1435718154de171a47c709e4d5c58589fdabe62e72f2a7a11ae561bc31d7cbe92df4aff23e08cd0e -8a1310bbf1a31fae18189479f470977d324dec6518a5d374ab2ffcc8f64412fb765df57d2ddf69b9a6efaeb2b4c723b8 -898312c6c0d3d3438229b19a8a233eca8f62f680c2897f4dd9bbcacde32c5996d56ac0e63e3e9360158761185491ce93 -81b3f965815b97bc6988d945496a51e4a4d8582679c22d138f3d3bd467ed1f59545da2d66e7b4c2e0373628ae2682686 -b9aca91c6e6f4199beb6976b28e0e35e36e8752618468d436b1cf00d8d23538d0747920e5b2c31f71e34dfe4d5c86a0d -b908f4aa18293295b8cacfda8f3ea731bc791074902c554764c603ab9a1de1bbc72654fd826bffc632d95ce9f79c27d9 -a7316ae1baf4b1196961d53be7fe36535499287aba9bc5f3bed4323039b4121b65bb0bd15a14c1b9cd8b65ede3566da2 -815e39208f205c5fac25ac9988c14a62ab01657c7737a24472d17b0e765644bc2cbb7ff1e8ea169b8b0b17b6996c4704 -89a451d2b740cdaa83ccaa9efb4d0ff5822140783979a4fee89eda68329a08c018a75d58bd9325bdc648b0d08340b944 -8cd08f768438c76bae6bee1809dd7be38ec42e49eb6a4d6862db7698f338bf6b4b409088e4f3d1c5bee430295b12a71f -a4bd8c312103a4bfeb25b0cfffec7a1c15e6e6513b35af685286333c1dce818ffeb52826f2f5bada6b67d109c4ab709e -93afbef5382d89fa539ca527f3e9b4a8e27ab69fd5d5023962cc6d8932b33cb4dfc5f14343e1a3749bfd5e100c9924e5 -8d8e69d046992ec9ff14f21840809166cae8e0e9e7c8f14fb29daf163b05abe6611daa4010960e1141c5ab24373fb58e -96f8e72e96ba673c9265e9cc312f6b9c3b931745fc62d2444d59404bb08e5fb02ddb60715181feb9971cbd954526a616 -8d444c2b8e4d0baadb79e3147a2ee20f1bfe30d72eb9a02f15d632185fb8f4e8c3116066f7de1ebfe38577aaccacb927 -971410c0b10e3698f4f64148b3d2148fc6a4a22217fcf4253583530a9d6fbec77e2cf6f7bb5e819120a29c44653de3fc -99e7e1857bd5ee57007b7b99494b1f1c6bf1b0abd70c054770427d59a3c48eda71b7de7a0d7fcf6084a454469a439b41 -8c8a4cd864894f7a870f35b242b01d17133cb5dfdf2e8007cd5f1753decc0d1fd41be04e1e724df89f1d727e760fdb15 -890a24328bdeaaadf901b120497d1efa17d798f6f4406661e46ecdc64951f9d123d724ab1b2b49e0e9a10d532dd6f06c -a7cbe1f42981c9518608569a133b0b449e9d67c742d62f0d3358112c97e65ee3f08ec0ff4894ce538b64e134d168e5c8 -87c976dea77b3b750c3a50847f25b851af95afbaad635f9bb9f7a6ba8f0c4faeb099dd777cf7eac41072a526474cb594 -9882aa5e9bcc4ea2dd3de4bb5a0878a672bea924b50c58ae077563b6df0268910a60e969d3da1694ae7394ad0d9acd3d -90d35ce677327c461fb5dcb032202e851af1d205e9d21a34ed2b95635f13f8fb8dfa470ea202ccfa4b08140d0cf1d636 -b3b4cbb521cce2b681e45e30a4d22078267e97ccdbdc611b2c9719705650dd87e0ca6e80cf2e174f8f8160be94232c36 -95892b00478e6b27ed09efe23a2092c08e691b4120336109d51e24efbf8aba31d59abf3cf55c0cdab1c210670b9743ba -8643018957fb8ef752673ad73102d0b928796c6496e22f47b6454c9ed5df784306f4908641ae23695db46ebfcfb0b62b -b166ce57669bf0543019ecf832d85164c551c3a3a66c05b17874bccd5d0ae87245925d6f8edc62ac13dbd5db265823a2 -89fb4800ce4b6c5900d58f1a216ad77a170ea186f3aa0e355840aeedcf374e92a15ae442800c9d60334544be020b17a4 -8c65e586215a97bf11ffc591bce5147b4e20750e82486cc868070c7736c3de697debc1f335674aef24b7afdd41922d93 -90f68ce0c97d2661d3df1040ce9c4fa106661a719e97c7b2d7c96f0a958930c57d6b78d823a2d41910261ae1f10e7b0e -adda85e1287371ccbe752aa2a3c1d5285595027ba4a47b67baf7b105a22fb8548fa2b5b3eb93ca6850ecc3995f76d3dd -b26535d218f48d6c846828f028c5b733594ce01186e22e412dd4f4a45b3d87d2ac1bfe5d54c987e4e8aaddeb86366d7d -a081bd86962ea3d4fd13df6481f3aeaabdd7ceae66f7bbb913e601131f95d016cf147d045253d28457a28b56f15643c8 -b3d852cef4c8b4c7a694edbf6f0e103f3ae7f046a45945c77a1a85ec8dad3423636a89058fafc6628aabff4dbb95c2ba -b424ffc94e06e6addc90a6324e0482814229b5902e2a266d0c2d716e40651b952bc9f00d7dad9b6050377a70a72c7f24 -b2cafd908cae0ca22eaa2d9a96175744897a20eb7b0a6d43b0098cb1c69e3cb55373888201e4ed32816655eb7d8a3dd7 -b61177ecf1ae9d7e7852d98cbf6080d9f1e33c90f2436720b4ea4690437e8c7850c3754768fc1312cb4e838d855c5ccc -81b486644e1ae22cf0ba3a37e1df34dc186c82a99ab35ad6f475c37babdea574ddfbe5811d4aa020581292a793d66bd2 -97ae848a823ea7a99f91834e537fb47208f616c08fe32c8f8fe06bd35c9b638698c513265d0b4de9e572a2f9692b98e2 -81b8fef4ea5d399c65e78f40e47c559ada86d890777c549ce362e7ab81b3bfb00d5ff4ae4ee30fd7bda7ee90d28f85d8 -aada6912cc748923ea40bf01922c06c84bc81b2ab0bb3664a0579b646f03d47ce88de733ac7f2cb9be4a8200584cdb71 -89b48b9c79332f8f58eac9100ada5bb7decdc4b1555c5d383e2c1ce447efb0ebdff9c50bb52bc3042107f33a61ab2520 -a32ecca8b870b2b6e9d10b5c1d8f925b3d629d271febad65abed316262bb283c60cade0e91047fbd0fac53ac6db372b9 -b829cd1f13409e3573a8e109c9541b0a9546e98b6c879a11152b5564477ada4d8cb4b3079040e05a5cb63d75ef11eaab -91f3b100baa19e960b170fe9e03b799faac5b9c6f305c56115940bf81f6e64dcb9cda77e8de70ed73a21c0e8a74acc58 -b25b5e872c84065aee04822bbcb4f3bdff57fbd7cea314c383765cc387786c17de3d5bb3de3ae3314bdede14542bfac6 -a89bea9eca1f5a17a3efccfa4987d8e5366b0dba70ef1fef43aaea83c528428d1498c8b056ac27f16e8946ee93f7028e -818a1f7b0b8b06ea0514d6b4a0296da4f69cb18ac8e48c5579e6ba2880b06215fcbe81672566b8b94fcc3c0cadecb191 -98dd6e6b4b4d63d9aa7464a2be08ae8babac4da7716a3f109340bc9187d59c6ca0c88e6877a67c65096f64a3ced22a4b -a2069c5bac4f6590042aefb37570cc20908b0df9d0130180f565ed8a53b4ea476a274de993561fb4d009f529fe7aa1cd -860b7ec2410f033a7b0c5ca08f88a0ad29f951a5ebd5383408a84367e92f1bd33bee3b87adef2466b7e33b47daabf30e -a408855a8414102c3cb49f47dda104edf0887e414723da59b6b6537ada7433529f6a4d1a4ad4fe311c279213cdd59356 -8ca0d81dcb43b89a4c6742747d29598ede83a185a8301d78c6e7f1c02c938441360a1ab62a5e571e3eb16fe17131cbc0 -af7875a495cb4201cdb26e23b7c76492f47f8dd4c81251de2397d73d4c8d5f419cdbad69ba88ef0dc3552e460dbcd22e -80e901e433dca34f3d386f39b975e97f7fc16c7f692808221fb2ee60c1aaa8db079cc48c7d72fd548aaf8dde8d0b8f05 -b6062319e13926416e57a0ffc65668bfa667e708a4e3f5cb26d8a6a32072f5b790d628052d5946c5068dd17cf4a81df8 -90094b569e8975f8799863798912dbf89b12d2c2d62b3e5fac7efc245436fcd33af23b8c509ae28c6591d3f020966e06 -a504f72d3d06a0c9b188a1035c7c6d80047451c378b6c5b2ffa1f8cecdb64871cb6440afb296974c0a528e5e563061a1 -959061c4924e133a419e76e000e7c62204093576ff733ce0b8ae656ec6045ef94c5a1f3c934fb76fa9188c5eb397a548 -a8b9d0b58de38cb86cb88fb039a7c4c0c79e9f07f03954af29013baa18fc2633883f8f9ca847209c61a8da378f9075d3 -b16d8341da4ff003ed6d1bbdb3be4e35654a77277341fe604b4c4e4a1cb95e61362094fb3d20ab8482ea14661c8b9852 -8ea4ca202e3aed58081a208a74b912d1a17f7b99a9aa836cfaa689a4a6aa9d9fbfe48425cad53b972000f23940db4c5c -96a372f55e9a25652db144ec077f17acc1be6aa8b4891e408f1909100cd62644a1c0296a3ddc38cd63ef46bef4e08462 -87df40018ab3a47c3782e053dbd020f199fda791f3109253334a71be4159f893a197a494de8f94d6f09efa5811a99977 -aff82d2ea6b3ad28d0ca1999a4b390641d727689dc2df6829a53e57d4f6418196f63a18495caf19d31fc23fdff26d5e2 -9091053c4a18a22d13ad309313b6d2133a96df10fe167f96ec367f9b8c789ecca7667f47d486fc5ba8531323b9f035ac -a4842090515a1faccc3d8cadbb234b7024254eba5fdfcef0d15265c7cec9dc8727c496ad4e46565d1f08504c77e511d2 -b1d8a37b1a97883d5804d0d2adaa8dbf0c2d334ef4b5095170b19613fb05e9c648484093d0c70d545cf9b043b449c707 -b1ea40f3dd1c3d437072f8adf02c32024f32488dd59389d1c3dfe78aca3df0bab7767f6ded5943cc10f50555da6092f5 -ad219c6a8149f10391452892b65a3268743baa7402736f810a35d56cdfed83d2172b03f15c205f0dc5446baf855907a5 -afe44c3e1373df9fc53a440807fa6af8ebc53f705e8ee44a162891684970b04fb55d60bc2595626b020532cb455ee868 -859ae154b017eae9be9da5c02d151de747cc23094d8f96d5db7d397e529b12fb55666f55e846e2bbe5e6f5b59c9d8b05 -8aa01354697de23e890fe54869cd3ec371f1be32064616ca3a556d3019541ba8e00d683f1396ca08e48988f7f7df5de4 -b8f682487460b9d825302c40a7d6dd0353ff43bf24cd8807cdfa46c043e3f5a7db182b27a8350b28e91888802a015af4 -b6d4d6c3ac40f8976b50be271cf64539eb66dc5d5b7cec06804dfe486d1e386037b01271cf81ef96dba5ea98a35a4b43 -9385a2fd1cd3549b0056af53f9e4a6c2dfcd229801ffda266610118ade9a568b33e75b6964e52fcc49c8e3b900e1e380 -98f4aa0e4ef039786cbd569536204e02b0b1338568d1d22bb5bc47b5e0633fb7ffe1da93eb9d825b40b9b7f291f84d51 -b7b3460cf706dc270a773c66d50b949dabad07075021d373c41fbb56228355324d120703e523ea3f345ef7249bfff99d -81b826255f95201987513d7987cdc0ca0529524d0e043b315a47583136dbada23a114d50d885bb3f855fa8313eff801a -afdc6c35161645a14b54f7b7a799910e2e07c8a5efe1827031a2eecd5d9263b3baa367fdd867360fabc41e85ab687e74 -817b361ce582153f2952f3042e235ee2d229e5a6b51c3d3da7bbe840b5c6ec2f01446125045848d15fd77dc46c8a8fe2 -aeb599265398af6e5613297d97d2b70222534590fcbd534d68b24a0289b6366ac8188b753f6fd1000ee73ef44f8fb7af -a5a9e528b606557be64460c1ad302a43e741357827b92ddc50766a7e6287740fc23bd528d9faf23345ce8bff527d5bc7 -a8d3b3b438d5f75efaae6ce7b67c2212899ece5b5bdc9bac655e271fd1846ea8560e646fdbded3d9363eefe29473d80d -984c7976d557e2f591e779c2885f5033da6f90d63a898d515b5da3adbffa526764cd8eb679b771573fdf7eed82c594ec -8ac748689cc3280e064807e68e27e234609e3cc87cb011f172204e1865ad7fdc78bec1672bd6e6fddcf4e7902b0f38bf -877bb392059540b1c8f45917254b8cc34fb7e423952bdc927e0a1622efec4113fa88988686b48134eb67ddebcb7c3ef4 -ac04b154ccd307ca20428091585e00121b61bae37b22d5d2a1565bc1134be3c81ccf3715fffebe90744164e5091b3d9a -90745c04278c3a47ceea491d9dc70a21a99d52648149b1ab623b5396b7d968fd3c4d1a2d08fc5638e8790463e0cf934e -80bf26ca7301e370f101cc69e7921e187cf5315b484fc80a872dec28bb65886569611a939958f4a3d2d3da4350011298 -87cbf4d6f0c06cc5f24e0f173a5f2f9bf2083a619dcce69a8347c1a6cd1d03325544610f2984eb87a13241e6ab9a22b7 -8909368817a515789ff4d19ed26afafa5729a24b303a368ea945a9287bc9facec9e1c8af19cbec8dab4acbb6a6ddf6c7 -ad8d2f82b08e0990dfd6b09fd54db3a30fd70aad218275550f173fd862347e1258a4716ca2bf4c40e4963850b2277eab -a9467ceacf9337cae4f2c7eeb3e03752ac7d77692b07d5e5d75c438fbe7dc2029ff84f7759372a0ddfa953b4ec7e9e38 -a5feb7669e84b977cb1a50ff3a39c28f7ad1ecc33a893fdf1ddae7a0d8a4c5f6fbaff25cc56631b708af038a961f3b55 -8f2e1fa07963ba18db890b44c3b9ae7f8992b702a5148679df69e4d9d4b1c082b2bd2ae53f96a4fe24b54f3dc1588f17 -896778f35cbecb43f001277c306e38a9c637275101f1a09546f87378b10ccc025644bc650b3b6c36e4fd0c09fbb3df35 -91dc702778176a4d089dc65502d703752dd9a766f125ffef26bdc38fe4abcae07cdea14102c3448d10f8dd6c852ee720 -a5df3004cec6b68b937cadded0dd2f48bd3203a903a3e1c22498c1193f4567659ecaaf3deb7ed7cf43796da9188f5dc6 -b18b4c8ffcb8599c24d9851abf8ee43047cbd4c9074c9cfbf88376a170da4554978988f550afde8a45306ca32713c204 -8370bc38c84da04d236e3c5a6c063e1db6613dcc4b47239d23efdcb0cf86846955b60da3e50f17b17cd3f7e0c29302d9 -ab7d6bb6be10aa52ef43abbe90945e78e488561afb959dc2fe768f8fd660d267c7203a2b7bdfa1b44cd07898f4849e06 -965c96047d82d76ec2cfe5035fd58d483cd2cb7f65c728ab3049562c5d1943096d6a5014c05babc697d79c07907cf284 -9614f7006aef6f0478ebd37fbf17276fe48db877394590e348c724059f07c3d1da80d357120d3063cd2b2bc56c58d9d6 -819c7b2a1a4bb4915b434b40a4e86dd7863ea85177b47a759bc8ecd8017f78d643982e8a091ee9a9e582f2b0208725a5 -8e159a185b5790a3ed444b6daab45f430f72f4ac4026750cbd5c7cd7947b5e00f2b10eaaf5aadf8d23054c5b29245546 -b48cb6f6c0aaea04833e10d735b67607846158b6663da380ef01c5bca3c9d537611716867dc2259883e5bc9daed57473 -8b48ce8b5ab76b7d662c29d0f874f5eec178baf3f14221bffd5d20e952f54f3ed053182a486da1d1f400e0acef58f673 -b6fd3cba177bfbcb5e7ebb1e3c1967cad5848c09c615ba2a6c277908f8b1f4f1ac5f184c33f2a401e8bdafcaed48bb88 -abd8f44c4a447de8fde1c119f4fd43c75b4cc99de9c817a019d219d4b2ad2a73b60606c27e36e9856a86bf03e7fc861f -af9f7e8b3e9e8599c7e355433c503a05171900a5754200520fd2afed072305be0e4aebb9764525d2c37a5a7eede72025 -a0960a58bd2681804edd7684793e3cbb0e20d1d4bd8721b192baf9aee97266be14c4ee8b3a3715845dca157ba2fb2c1d -949a37213209adfbfa4e67c7bad591c128352efd9b881c1202cf526bf4f657140ef213acf0efeb827a0c51a1f18809c4 -9192fae84a2a256f69a5e4a968d673bebf14ea9a2c3953f69fe0416f7b0fafa5166f3e4588d281f00d6deac1b6ec08bc -b1a249662f34a88d2798eae20c096268d19f1769d94879b8f1aa40a37b3764349b8e6ab970558436a88a5aa5c37e150d -aea87086dcd6de0b92886b3da0813ff271a7107ab1a3cb7021b85172c1e816a84dbb1a8fdb47e8a8eb5e6fcddd5b919a -a586b5078b3f113eec9f074430bcf9aabe4e82752e5b421c6e31d1c2a911512e34154bf8143b5197e820c5af42aa8ac7 -a6eda122e400a6600f025daa383685a10f72f62317a621698bd0106b331077b05ac1afc68ece7a2e285c54a366921a3c -8875e9ba654ad7b1d57ede84e2b702600416d40f7475fe2df25dd1b95c0178a227ee187547898e5b9d1ce8ce9ebd15c9 -af2cb289f8c75f4ddae9e3ef9c1977fe4d4d513e411777b03b996f5baa372eb995b5ca96255fad9ace776168806ecc42 -8d24c465d26bd93290f45ef035bb6dde4530d9d7d051baf583b1f8b98e9886de262c88b5709084710cffa7c767b4c27d -8cf35b1b28a7726645971805170392d522f5e7e6cb94157fe9c122a987051c1c90abe3c5bdb957ef97b1c45dd9bba05c -93e2bbd82a3cb872cea663f9248b21d4541d981f3f8d5af80a43920db5194857f69e2884753f6ed03b6d748dbfb33620 -8b774b97657db654ebdafce3654d645f849203452e876e49dad7af562491cb6531bd056f51cb5b2e8f0a99e69bd8566b -b5333c49d3e1c4c52f70f3a52f0ad77165bed6ad9dcbfaf1364e7a8a0f24570e85a218e4c2193f63d58a7dd975ceb7a5 -b4a34c443e4fdaab8e69fcda1fce5e72eaa50cf968f5d3d19084d049c5e005d63ab6e1d63dee038317da36f50ffb6b74 -824a224009c6848b92d6e1c96e77cb913fee098aaac810e2c39a0e64d5adb058e626d6a99be58593d921198edd48b19c -a86f1fdd2e1ba11ebda82411b75536fc0c7d2cdb99424e0896d7db6cae0743ee9349ffa5bff8a8995e011337fa735a9d -b406b5b89b8bed7221628b0b24eb23b91f548e9079a3abd18be2ed49baf38536a2c1ec61ab1ddc17928f14b006623e7b -8a7ea88d1f7420e2aaf06ee90efa4af798e2ec7cd297aacd44141471ed500107fdd93bd43b6de540314ef576646a7535 -a7a8c071e68bbae9aca110394cf56daad89404dff3e91ea3440670cd3d0423b67905e32b1ba7218fd4f24d2f8bd86ce7 -b959830f152e4d31c357be1ded5782aed5d6970e823cf8809434cf4fddd364963bc7cfda15c8f6b53eda16ab20ca3451 -b59232c8396c418238807ce07e0d248ad2045289e032678b811cc52730f99b480eb76f6adf985e6d5e38331d4bb2b9d5 -a14092fddecc1df18847ab659f6cf7c8603769a4e96fbe386d8303b225cebbbe8f61d6ab3dca08e3ed027e7e39f2641f -941cb0632acd395439f615c6b4b7da9ed5abf39700a8f6e6f3d3b87a58a1a7dbb2478a6c9ff1990637ada7f7d883f103 -951b8805ecb46c68101078847737e579206f2029e24b071bae6013e9dde8efa22bce28aa72c71708caf4e37f9789a803 -b2cbf22e53f6535fa950dd8de4aa6a85e72784dd1b800c7f31ec5030709d93595768748785ff2dd196fbedf3b53cd9d7 -8d84ea3a7eafb014b6bd6d57b02cab5ac3533aa7be4b86d2c5d53ce2d281304409071100d508ed276f09df81db9080ea -a2204b60836cba8bf29acd33709e6424226ae4d789ef6b280df8a62e30d940bc9f958ff44b5590d12fa99fcde2a4a7a9 -86692c58214f326c70eb2aaf2d8b26eae66fb624f143a3c144fd00f0249e30e0c832733a7822fac05c8fe74293768ace -b1cb3d64eb5b9ca0e01211128f990506fba602cd1417da02237205aa42879ae2a6457386da5f06434bcb757f745f701d -b3eb4290a53d5ff9b4596e4854516f05283f2c9f616ec928a0934b81c61afc351835f7eca66704a18a8b6695571adb30 -b0bfb1d44b039d067d7e0e2621e7c4444a648bce4231a6245179a58cd99758ec8c9e3f261d0adb22f9f1551fceb13e4a -a29320f71a9e23115672ea2b611764fe60df0374e0d3ff83237d78032e69c591a4bdec514e8b34f4b3aeb98181153081 -8a6abe9c8a048002b2ff34154a02c2f13fc6dbae928da47c77f3e5b553ea93d8f763821a6ead3c6069677870fdff7ff3 -b73ab66a62f427e1a5e315239a2e823e2a43550d245cff243c2799eb2e4701fabb7d5f9ce74a601b5ee65f6555dacf64 -b64858e98b9c10de8c9264b841b87e7396ba1da52f0f25029339ca1d13f7f9d97f4de008cfe12a1e27b0a6b0f2c9e1ab -807d2440d1f79a03f7163f5669021f3518094881f190cb02922eb4e9b17312da5e729316fe7ba9bfffc21ed247b033cb -a7f06458d47ebe932c2af053823433a8a06061c48f44314fad8c34846261c8c3f7f63d585a7930937327ad7d7ca31a6f -82ac2215eba9352b37eb8980f03374f5e0a2f439c0508daa7a32cdce398dde2a600e65a36795a4f5cc95bbcf49b01936 -a1882c83a2f946d54d74a008eac4aed70664db969e6799b142e0d0465e5662ba0d224a1cc33be339438d69bdad446ff6 -8009776f7a34a3c8779e21511fa409b0c5a38e172d1331acc29a16114e002f5f2f001381adb5fb3427a100752d775114 -b24441019af4a0df2dc68e3a736f358da0fd930c288398a18bb5a8d9a1e98ea376395f19d8e03a5f020b83fcb709f1af -ac72b4de3920c4f3c9b8ea90035cd7ed74d34b79e79aab392f057c3e992ebe79050cc1c6ccf87120e4162b29419147de -973e75577cd2a131a0bd568fd44e43554ac5a9ea3bf10f02d1ad3ac6ce9dc7a8a7ea93aacf3325f7d252d094a0de1376 -98a114de2a86f62c86862de37c328bf6a7fccff4d45a124addbe0eb64debe365409fcb72ce763f2a75030e1ff4060c64 -aff753e1dd4707f1a359eaec06ebef1903242889a2cb705d59dd78a79eb5b894731f5a91547479506145ca5768877dec -b856e4234858b5aa515de843e8bd4141c15a4cc02c51640e98a8aaa1e40344f1ff8ef7c3b913ea2ae7411713daa558d2 -863525eb2f8147a6d1d0d4304881795bfed348913cd7f38d815d929a426788b69e41f022dba5fdcaf56c85720e37fefe -a14ad76b145a6de2e0f8d4f615288c1512701a7b3010eb8a95941a2171bc23561e9c643764a08c4599040a3b4f5e936a -a18bfc66f6139dcb0485a193104fec2e7d52043837a4c0cadb95743e229712a05cf9ce4ccb482f36ff1ce021e04b574a -991c8e6678077d6e5f5733267c1819d8f7594e3b2c468b86a5c6346495a50701b1b05967e9590c15cef2f72bc10a38f9 -a034e7f9b547b047c99b99a0dd45509b0ac520d09130519174611de5bcdb9998259e1543470b74dcd112d0305c058bad -95ffe0d02317b5c6d5bfddbcec7f3fdfb257b26ad1783bb5634d983012e2ea1c6b9778009e1b6d10564198562f849ac0 -b3db442aa4adb33577583b2a4ad743f41efe0e1f87bfc66091d1d975333ffc00b4afc43057bcb88a7d68b0c9695d38dd -ad2e97d10d7c53d231619e3f2e8155a27ea4f2fb3c0cecf5c7f14f4cfcdd21f62ea46d843b21df748b2892131633fed2 -905d7aad6d3b56bad48694b6b20b27e370ebca8b91d0821e48e2f9cad39910c26cc11c77c266894db3d470485a63ed11 -99bfadefca796ce6af04ede65ba5ef5bf683ff7e2852bb9c406fda77b95ef382289853dfe4d933525071e4cab8ce3936 -94d9905ed4ef92107d0adb9ea38f085a2a24b8f792108bec702d747c215b1f14aafd486ea0c07ed42602b12d8f602b93 -a78dce23ca09dda2d5e7fe923290062546825286d624de35ac5756b6c8ae030e211f4f9c9c8d18a924f5880e3b383d1f -abce9e2128ff51fa17e73d93e63d7134859b2f328eedbcefb337c39e752d6750d9cffe6abfcd359c135dc5a12018827b -a9ea7d91e8a3524acb3182bedd7e1614d37b48f8eb2d8f677eb682d38408b8d512786d8bb65811f4d96788b9378e59b3 -912c9f804fb57dd1928f8274be58b42618f589fc72a7e5b6cb4d4b5d78c547f80737cdd77ebe5d2b71eaf60b8fd2b663 -b7227ec9a62d5538974547f717fdd554ab522d8782667fc3e9962e9c79a21134ef168371bf3b67e28d0964e92cf44028 -89440a781c812a19c758172bf722139598023ed0425374fbb0d91f33be7b7f62a36d7aa34696c4fb0da533bd5dd41532 -b31e4a9792d6e9c625c95aa3c0cd3519410dec07940afab820ef9f63017415d237a47f957d0b591b6de399ffc2a8a893 -a66ec47393df2693be161daaa88be0cf07b430c709ca97246d10a6080ae79db55c9e206b69a61f52512b868ba543e96b -90ca425dee74cc6a7e8eb1755cf9b7b76ba2a36ab851333b0fb7b35e8e6e189702456f2781ad87b4215993d62230ff4f -88b64741f93a2ae5d7b90b22a5e83c9d56bcee5c6bfcedb86f212acc776cc3ebd0b62cc025f596cd8db4f4b6a7aeebab -a1b6c7d2358bb201b42264f8fbebaa242ef105450bab21b4a2f16f368048c16ad1f3695841787eb33a0192f1f6b595eb -8a932f1cd227ceb18389791ed9ea1ff26571715ed1ab56601a994795713a8f7f031d1e8472ec3eb665b7bfbbca8ca623 -8bb2e34a2bf77f9f657dfc51ff296a6279a4d7d15860924f72b184fb7d5680320c7769954b9dac73c4bfe9c698e65e58 -af54e7367891c09f2cea44cc7d908d37d058162ec40059d32ded3983a4cabfe5057953878cf23bfad5292dbd0e03c0e1 -8a202532b9205385cf79f0299ddcb3156fd9fab09f9197bce762b5623f75c72ab1d74334ee6f0d289007befe222bf588 -83bd0f5896eaad58cfa7c88fc5ed505cd223f815dcfe93881b7b696cdd08b8b5ede03ea5b98e195c1a99c74ac5394c1b -b4a84d9940e58e3b4f804e4dd506f8c242579cfa19323c6e59047e5a1e35150699a2fab2f4862dba2f0ee4ed1d8970f8 -8c9ec477d057abebc2e2f6df5c4356a4f565bde09f499a131967d803d4bf36940ca2ed9d4a72adbe0a4a8b83fc686176 -8598f43c32623fd5b563d1ec8048ffc36db3d7f9b3a784299811687976f64b60585b2a2707050a3c36523b75d1e26716 -b55eb07014fe5ad3e5c9359259733945799e7429435d9bf5c72b2e0418776e329379433e17206f9f0a892d702a342917 -a5ed942eda7b36a3b0f516fafd43d9133986e4c623b14c0f6405db04e29c2d0f22f1c588150f670dbb501edda6e6dd4b -92b6abb28cefab2e332c41c98bfa53d065b7d262638389603a43f4431e6caf837b986254c71f7cdacf4d6cc4064b0195 -b01806178a28cc00d1561db03721eef6f6539676d93dd1fa76a13b42a31d38797e99b1848de92fd11821a342b04f3f72 -a2f10303437acfbb5912e186bbff1c15b27ed194c02cbc1c5b482b0b732c41fa809136e8e314e26b5bfe57690fe3b250 -9990207fcc711102e7e941b3ac105547a3e7301390e84f03086c99c6d3e14efff3a2e2b06e26227f496d88d5cdaa3af1 -b903cdb0c2fd578612398c30fe76d435cd1c2bab755478761244abb1e18ba8506fd9c95b326422affbcaf237309959d7 -99e0c12cae23f244f551d649302aac29bfdeb2c7b95578c591f512ad7ac562bd47e7c7317ac9bac52c9ea246617bdb48 -b996d267ab5149c1c06168ee41e403be83f99c385be118928d6e2c042a782de0659d4d837f0c58b26df0ce22049a5836 -989001b8414743765282f7e9517e4b8983a929341b8971d7dd8a87d246f6c8ba5e550c983566ddd932c22948f4fa5402 -a0b006a2c9124375364b8fc5ddb543a7468fa6d321ea046d0fd2bfdaef79e5e3600b3d56190733491ca499add1298c7f -80881d6f3ee507089b7dfb847fc53dd443d4384ef6fce878d07d9b4a1171eefea98242580e8a6a69664699f31e675cfb -adc48ef53d88b9d70409ed89cc3be592c4bd5eb65d9b1b28f2167dc4b12406889c00f2465c554f3aff673debc2997ccf -a62f5d9f167b9f4a4aab40d9cd8c8a48c519f64a1985823e20e233191b037c02e511b0280487112a9f8b1f1503b02db7 -b89aa2d4fb345a1d21133b0bd87f2326eb3285bd4da78b62174bf43d30a36340e4217dbe233afb925ab59e74c90fccf0 -932ba22acdd2f9d9494da90958bf39d8793af22417647d2082d2c3e6a5e17a2d14b0c096139fa8fa3f03967ca2f84963 -b67b107e71d96de1488b4154da83919d990502601c719e89feabe779049ddf7e4fb7e146eb05e754b70bbead4449efb1 -84509de1b8dc35aa2966d8a48501f725d59b4c65f3abf314b2009b9a573365ae3163c1f276708c66af17de180aae0868 -849153fe837a33fcb32c5fa6722c2db9753e984867c112a364eb880d87467782142d1c53a74b41df1dec7e900c877e1f -903d05c73ae043b69b18e980a058ce2254d008647a8d951175b9c47984164b34fc857108dcc29ad9df0806d7e90405f4 -a6b05917ac32c0b0eeea18f1ef3af5343778c543592078fdf6a1b47165013e2676bfe6a592a24efab9d49c4bd92b8fc0 -8648482f6947a5a8d892a39f098160aae1a648cb93e7724ea9e91b0d1a4f4150b91481f6e67d3bf29ff9d65ba4fa61a8 -a6ecaabc38895013297ae020686f04ea739c4512d2e3d6f2d9caf3f54000fb031f202e804ee615eb3357714a18657bcf -912f5935acc2dd20d5ef42b2ad5b307c925324a84a3c78ff66bc5885751934bd92f244e9636b60a744d750a2a7621198 -a0d6f261a776c5b114298f5de08d6e3372649b562051ea2470d3edfc376048793e18fc57ec84809b463dc72496d94329 -940744cd3118d1598c248b38503f6f1fbdbe7a147e683e5b3635140aa91679f8d6c1472600f8e9c36117a60203be6b4e -ab81737c839fe340f6f1fb7275811cb0c0d5fe8bbc265f6a56c6c68d0291bc7234eaa581ff26f8929d9a5bed4aac7002 -8df47341160f1c728c3e31be17a32e42b54faaa1286ef2c7946882ca4dd46443b8428f3654616c6e4053f1cda2e11994 -a721067e75c3c791f4d9f58d4810ac9621606e29c6badb593d6bb78c39968b45be1777ddb9bf03696d4d4be95b2dc1bf -a4e399213d3c4350c2d0cbe30757ba7e1f9680f58e214ff65433b36232323744c866a87d717851ba1dbd6769599f69a6 -b0be851d1e43dee27abe68f85e2330d94521b5f1c1a356ad83fcd09162c0ca9c2e88bccbcc5bacfa59661764361867a3 -86111bdd3dbfca232aa5802a6db41d639502e43a2e24cb06bb5d05c7f9b5ccac334d16b61d1c5eaac4fa0cab91113b46 -a4f805b11c174c34250748b9beebfb7c8c243198fb13463911906ee4effe7d331258a077e374b639a0c5cdcdff166b7f -87e4cf2c6f46d2dbac726a121127502921decf0195d7165e7bbeec6f976adb2d1c375eaa57f419895a2c70193215dc4c -8ff06de2c1c4d0744483bb4f7c5c80bf9c97b4df23e86c0bb17f1498ea70e0ee3af20827da5e8cb9d7f279dc50d7bd85 -ab112c0116471b4dc3fd1e6d918f99158eb7a08153e891ddbba2fe5bf0eeb188209e3019176e758231c3df937438136c -a67f89194e99e028a5da57747268e5ef66fefb881144043429920d222d37aaf268ebf73ca1da659fcdac3b4e7a65092a -b4da1dcc791566140d6abeaa2923cb6b21a6e6aaa30bb4cc70011e931eefa71f96b7e05358c0654bad7ce45191ab9fa8 -8283933231bca359db588c80e043ad6ea765fb0cba5ef233c5d514ba01ddd1b409efbadb368f26763402e4576dc4655f -97f568ce3edacd06f3e31a15462f5f9818a8c3fdbcf92b1ac5840b0b6e73166a154013dd52e85a18e8ead3fc9e54aca0 -a9cd1601c41e5ab2018f986443914fb703ddb6b06a36c06fb58065f2fee8e1751071ef924ea3ad76f0c19baccb1b5f8b -92aad71bb7e929cc35a48020d16a5822f4f106a7f59985005a5ae5ba8e8016ec33727610393498f56b4f353b3d5161b8 -89427780aa4e7ac894c681fbe2889153b94db883f17f109bc9caa93f0c259dda42aab502bbefaf572c56f70abbc42db8 -aa8cf76ff847dfe59534432ed8520bb48bf412c28497747dce04d2b2a54ba843c3be1564630cb49ec0217167847ba590 -a1570a6748a2303e74a31c2131d05ab372ec006ee92ef74c42f2e9a250663bebdfb3777e7ad91f50c954889a59c2d434 -a4c2b1bbc48199c31ea8d8196729eab00ce0200350d4aa9f23347a3289355e5828cb2f93036a14d2d9ec575fb3835239 -84819d0bedbaab5bf8afdf23f59a7ec5f50da3063cfdd1ef5fc4ca4c1fe68980b5c80e30a49f38e5816765e81dfc5a57 -a57cfb5e877b88202f589be777605deafbfc85ed1357af03a18709cfb4b668a271199899243cd3750f1cb77ebc40bba7 -8d95934bbb0efaf3339f27cb96de46e4486aa58a2c40dbc77c1c3ac7c27a228062824b9045c046631b2e286e8549603a -b99a8356abeee69f40cb3bd8c87e8039a1e076897dde430bfbf989dc495c48609a7122bc6c1d1c32ccac687b47d5558a -aac2edcf2fe5d3f1a84e8f1f27ece920eabe7793bf0ed5290cda380752e55d57a55a362c5253bebb71e4a55f2c437ff6 -af7c76876072c3b0091e22b9c5b27ce99bf1f0079ea1a7816ad9c06e9e5fc407595c7f4f9953e67d86fb2da656443dc3 -9175b64d104f78d3310c9c02f82e04c8e9878d2044ea5ee9c799846a3d23afa5fa2aa4af7350956136c69a0eed03cb2e -b3328e953317494a3d976e7f7c3d264258a5d4b2c88e12d06786a9e7b2affd41086762ef6124c6a6e5b6b028db933c14 -a49d166065e19d39299ee870229e4a04be81acd6af3a2201f3a291a025dd5f8bc3e676ee123cd4b9d8455f6a330b395b -85fa15bc8947ba03681d87b50bd2f8238b1c07849a7ed4e065053fad46aac9dd428186a6dd69dc61b5eba6ffec470831 -b6fcb2f694a47d3879b374b8b2967dcd59bd82a5d67ae6289a7326c18791b1b374e12571e8c8ea16a4bfc5525ced3ec4 -b6115f52566aa90ccac2aab6d2dbf46eca296d047db1eb29a1b8a2bc2eef7a24e90407f8dae528806aceb2a1e684d49e -9707e66220233f6a48a93e8dec7b253d19075eaa79238e519b82ce1ac5562cca184f8a1c14f708a96c34ad234673d646 -a0822903fb3825eae07ee9d3482277c0b8fc811856dfe4a51cf24b373f603924166fc5485185f99c4547cd6476b62270 -88dac6366c439daaeee2532b2ddbe206132cf6e12befbb8e99870ac684e04e62de150cba0e22e395a0b858948f40808b -a72dfba9caad3179f43fead0f75e33ba5342470d8c9cb7c86d30d2c7ce7244a8aafd1d558b0ec8e2a9436de2c2e95ccc -8d696046defcc32cc19954c559213100f0ba273ea12abb55ca7c42818071d853846bd4213af2c41ecd4442f6b4b511b1 -89d6f2d52cf65414da15a2fb1911c53afbfb50bb5f2638844abfc325ff2651cd9130be4beff05dc4046adfc44394a182 -afb91abd7c2a9cfe62855ede3c6960ad037fe8778364a2746ff7c214c55f84e19a474a9a0062b52a380d3170456ee9c6 -87f724a16ec8fdae8c05788fa3f823ecc3613df46581a63fc79b58f7c0dc2519b6b23e3dd441a0ca6946dfe4bc6cd0ce -86760f90f6bedfba404b234e90fbf981d26c29b87f2fa272c09540afa0f22e6682d08c21627b8a153c0feb27150458e2 -ad4d0342f255a232252450ce4209507ba619abfd1ffcb9c5707cfa45f89be41d88f1837acea993a1c47211b110250b4d -ace54b5889bccdf1d46c4ca21ed97cca57f7d12648381411d1b64afdfc64532a12d49655776ea24cf5eabe34145705ad -936dac693d0c1b1e5de1701f0bc46aef6e439e84bc368a23c0abe942eb539a2950e8929265786fcdb18d40a44bda14b9 -94fafbc544decec1d489b9ad6b23410b9de4779f9f44aabd093d7fab08340a4646a8cba31633e49c04d2690b8369a1d7 -98157e757f1a677c5d9d65c47759727a4dbc49fec2da4d9889c4ea90573fb42e2a8d72eaef92b782ac6f320970f09363 -8eaa0498c191c810c7e1ca7398f7c80dd0a7e7d7829ed07039490f60e7c2ae108843c06fe38fa36d45d63da46cba887c -a0ae116e5b0d2dccf83f056ad876037225687904e0290fe513fdc6b2dbe4cbf5fac1d828352e64734895895840b3c57c -b592b318dbbd7ec4872aae5e64bdf2305db2e5e8cfe0ad77b691f542ba5e066dd20b09b0b08ff0d798bd79ad946ddf7f -879e50c8c3e7f414ad2b38632bc482b71759cd561aeb2215550186ebb4559e4cf744cdf980512d8321954b3458d21e11 -aed5c6c7ce0407d7b2c04785fcb9deadb9b9413e37cef5b1d918f474cccc7de012fe1fa6f5fa93cb7ef9ac974d9fbc20 -892274a9f0afc68fa74be276c2a16de5cec674193f96b27a80bbb9f3add163f85716b531f3c920b98577a0225f84e8ca -938fb7a53266b997a7669596577af82f5289b160b7fcf06d76eee2a094696f6f12b28c2c65b833a52529a116c42e6c7e -892083929b6067f5045b1208f3dc8f0ee25bd0533a8831f5c23bb4ff46a82d48f0a34523359df5061d84a86b718d5060 -99159ae9574df6c16273eda66b6d8b79a327940e335b28c75d647f4744a009f4b5f0f385e2017bd3e7fbf59e629cd215 -a03e5757ef7738eba32d396923ff7ef82db2c15bb6adc8770fcb37260b7bda3be62473bc352a9a2ef7ec8ebe0d7688bc -ae3c24a85c9b1fa55158b2acd56d2016f70dca45a23f3ef7e0c6b096f4a7c54c14020d61bec7c7f87be4a595bf254209 -a920a6f9cc803fe31352fca39c13f8ac1e8d494fcf11b206092227c2af38469b1fbc068b8fe014800b70f137107aafc4 -b893853be57519ffa6410da605e7d3a746ebadec4788c7907f6e0dde9f20f5a6a01181148b874b3decf9b4814846a11a -b46f43918c5195729f6532439f815d1eb519e91005bc641a4a30ae88700982bf4ed07a342e77945780317c297c903755 -8e431bf4497d0ef6538c93c4bdda520179301a0104eebcfd104efa1edea876818d7d31079656f01a5ff76c4f5fcd71df -92e3dbcb580dfb9cc998f878052b0c3be1c5119e5249ae9bad3538ebb0f0c4ab5a959b04033b96d61836ef07784e6b64 -b712d9d63aa888156f4ec83e939c6bad53de18045f115f54fbf4261fb02f10a8a46a8d716ab43d4acbad3b02283c32fc -b2334e776988b4f772446a47c87416b4f19f9b44164a5f828424d3f35ef10baa56afe810d49b0b86b786b9c0227681a6 -a3f25ad18e435ef585fa90e6cef65a8ba327e5e33701979e27e64ef7d8e09e2591e52bff9c5749d35643456d18625685 -adcfa48ae43cac6fa9866b4cce10a243969965942c891d5e6c0e5b03bd4763f9b63779fbf40d26ac674534fe7cc478d7 -a0eb3448e045038740e2ee666e88aa0f8b8e24b1b55d7d4964f01bfc0c581f7e9d4c0e79f8cfbfecfa8b024b216c8ea6 -8110aa1d82f11965af4f4eedb4de09ee9c353481b2d7ee7a2bc2f302d2a5ae6c31ebc6451309ba7c305da41070b0f666 -b074fdad419d42783ebda17f19863aa499eec71fda5aab6cdcc389276b7bf08053795d15890175ca3dc89f6d8d17758c -a14665846d95d7d5f0b5381502080c822776ec0994ccb1ae1ffbb3f19205ce9c7c9bf9c2d2ca098807ce99f29e4f07a0 -b4884842670a333cb5548a842fa2971881e26b442dfab0b91d6bf3b4cbdf99adbbc9d14fe2bb46872cfcabedae85db30 -94549b01cb47ba16c0cf6f7522c833545397de0b3388c25d03e60132eddada6401682f9ffd8c50d1a61b4d2dde37461f -a790c9b4cec96e4c54777f3e03cea5769b20382cdcaf1de494bac2b9425eaf453eff643c62ab284cc1af33bbd36013be -b1b45fd298ed11609aa1ae6c5ac655e365bb451de1b9fc92aad40422ba85c6a454f33b8142acabe55171328c13d92edf -a74cea9e7096e38327064f058a3cdaa34e6eafaa9c7d58f753c40be67998152380fbd612b9dc0751bda7befcdffcc749 -b18978dfc5efb07b7ef992c7b0cf5d1b4ca551578b1dd13057b7aced8b1deb9f2036e1e3116248a803e922659d206545 -8153c07603cdff6622835a9853b795274390abf7197d7a192193bec44acb43e8cd50b56c11a03f4a2a27124c36974f3d -86b987f30bb9a37cc91d22dffffcd346ec5773e846a6c2b8f9e03b25ffcae859c470c901c4e29695d325dfe4eee927bd -af5e980b9507d10d5269c1a5d02bc16f4f009b663e413ea6a7c655250f3a21c608c12f4002269a05d3779907e7be7d69 -a6f737fab2af9f27bfb8ca87f5fdab6ad51e73ccf074e90576db57b309dfa0a95f9624526dfa4feaef39c388802f2ae9 -b7ed51f699f615f58a7ff4f99d52c4ce7a8d662843c1f4d91f1620fa119b80a0f6848f9fb6c4b9822dc019830e7dfd11 -b71f27f291aa6ef0723ed79c13a1c7a1c40198ffb780a129d9d20e250406bc91f459705b2b6674c9bb412a7b5dd9ff07 -9698cf8f638c3d2916fefa5f28c6050784479f84c2ee76a8aeda7e562630a6ae135b445ec4e29af8588ca5ad94a67f49 -9270aa5030966a9990d8bc71b00b9a7a1d7c1ad8f4c7f78a31b3d7f86467332f21407c74a89ba4f574d723acaf0d2042 -b1b82faceed8e2297cd49cc355471d15ff8dc2ccc78f6944c8f7a75d3ad1629a2e2f1d0a2ff7fa2b3c38cd19839aa5e9 -8a8c4ed49dc9bd961773edf8d41d04385b11bbd3577024639a39319cc7068380236bf73fce0b83e6535bd3f95cef0e65 -8d04ec1e7d148b7e66910ab45a0e6bf409612a3b560bfa784e26f2963152821c646a655cf17a0ce3d4ba4c4ebeeb4a1e -8e9d707f6186d93accb60813715ed1f6b3001ff6d2f87daf8b906bd0b988c1833b2ccd80dee9bdefb45901e81bb82971 -9762317ca6a5e6fe0b2991e0fa54b5fbf419dd0550d70074957d65cd7ebf79ceba607dd40d709ed635c822b3b4da2cac -82b53cd9a1eca2f5d3256723dc4b6531ca422bd87bab36243c727d1952db58d7288ab11467305d875d172ce165b1e4a5 -b4dbeafa05c87029ae257bee1ed7603645fab41f6ba7ac8b57ced5b4774a72ba3e671c2433a93acc3c498795b5cccc42 -a916d3ab7f0e7cef294e11c97c910a19c338ad8e615406e6d1c8995b4a19c3b2527100cc6b97a950ec5a4f3f6db7d01a -b9a785c7123609bdc96f8dd74500c6c77831d9d246f73244de964910b4045ce3242c881271bb1a4bc207d67de7b62e97 -b5f94084f695d0821c472e59c0b761e625b537c8ae3a09f11d9a57259e148cfadba1e43bf22c681b6b32390121cec208 -8f91b36d8570f19a90cf3ed6d5bb25f49a3315ddb566280c091fe2795c4e25ed2c6a1ef8d2669b83f2d7bb78fc8c40f5 -80f27359a73ed8fdd52762f0c7b9f676be2398b1f33c67877261480bf375f975f626c2ca3e7a9f59634db176ed672c98 -b96b91e3d5148ca793edefe4ca776b949c9305acb6f3a3cf87767a684014d2c8f2937c2c672eef8510f17d2da5d51385 -99c4e1ca2cabd4388ea2437dbdf809013d19be9bd09ff6088c8c0cfdb9ecf8fd514391a07b4288dd362434638b8834d9 -b6fdfb812e145f74853892c14f77c29b0c877d8b00055fd084b81360425b3660cd42236ecc853eadb25253e1cd8445c4 -a714af044ef500104576898b9409a9a326ef4286a45c3dae440bd9003fdf689c5f498f24a6f6d18502ce705c60a1cf14 -a9444e201be4a4d8c72119b3d3b13098afee6e5d13c5448fa2e9845cc9188239778f29b208749c960571dfa02b484f05 -91c826a6b8425f93ff395d9fdfa60dbfa655534c36c40a295906578540b9a0e6b94fd8d025b8b8611433022fbbc4fb0b -a355d76bc3cc48ba07026197130f25a593ec730d2ef0d5d2642bfcad745ecbe5c391324bc2485944060ff3100c952557 -b5f9b5a289a6f9a7252cc1f381c892bdb6836a5998f323ee21ae387936148ad1ad7cc6eca37ecece36404b958ae01e8e -a3c7ae04a6208851f6cc40ff270047283b95218905396c5dedc490e405061cbefd1251ecf77837d08c5ec1c77d2776ce -aa02ee387dd2cc7a23cf5cd582da0bc84bb33a7158d76545cbd6e06b26a6f30565dc712d7a8594c29f0529a892138802 -8aff025c841f167fadaf77a68284c355ace41d6df3a9f1e41a6e91454b336f0b69ea34cce495839b642a7c43997a8fd9 -82eccf0b6b4b6460f676d677266451d50f775446df313fc89bdf4c96e082340f6811939d215a54ba0fe30c69b3e43e25 -af324d871b038ff45a04366817c31d2c1e810359776fb57ac44907c6157004e3705476574e676b405d48a48bfb596f59 -9411dcca93ef5620ce375f379fea5c1017a2dd299e288e77b1ab126273631a299d7436f3bf3c860bf795e5faaaefa804 -934fca809e66f582c690c3778ea49de2e7940c0aeb8d7edad68f2edccdfda853d2c4844abd366fbc2215348935e4b2e2 -a1b1fa4c088418f2609d4dea0656b02a8ee664db25f40d53d8f4b1be89a55e5abecbf2c44c0499874abeb3d3a80acf71 -ae6ed7a0ba6280c679b0bf86111afad76fc5d930e9fb199df08134ba807f781d7e0b8b9b2c8c03b02d8cc20dbe949a28 -937d200a72fe4ab8d52f6cb849e322bc5959632b85a93c89744b33e832e8dcf1dddd6ffac0c049b03c105afb8930f7f5 -b4b4a46ebe0c5db16004933c08ad039d365db600a13d68be5346b1c840cce154f56c858874e866de8c3711e755c6e5dd -afcbcb7170c8caa2b77d2b3388dc2f640aeb9eff55798aeceb6eb6494438be05a2ae82f7034b2d439a45ad31d8c64b07 -a2c676273081b8761f58e0b11306ddb6a4cde3d90e7c47b434468700c5b749932819b01efd7637ca820e10fc28dfb427 -b445715162d834c9ee75ac2ff8932ace91c8242d67926b2a650217e4765e0531c2393c9438a52852d63dbbe2cceaafc5 -a0c0ebdc1480fb238a25fbfc77fae0db6e5e74b91809f0ff20a819e56b8c3141549615d1bd7b99829898f6028e8c86be -b3d11933e9d1db8ca617934261ed26c6f5ca06ba16369e7541482bf99c4f86520d43fbb10f4effb2fdf3cc70a189fdb5 -888ac610f8fd87a36b5646e1016eaf6dbca04aa0cc43f53a1046d74a658c4d2794606e79fb07fae57cf9d71ed339f4b6 -979818dab00c58435dc0d0d21185943f95819d2a13531abd2d798e1773c4bbd90047f4eebe117868743db75604a50227 -a6fbcd2656e475065fe44e995e8e2b5309b286b787a7597117e7acc3bb159e591a3e7304ef26f567b5720799d8ae1836 -a03f0ac08d2101ec4d99ca1443eea0efa767a65448a8ecd73a7818a99e863a04392bec8c5b8e5192834e8f98d4683f13 -b3c4ea8c6c3ee8aab2873d446ad702000b0e927e0991c9e30d83c6fe62a604efdc3ac92453313ff0d5e0ac6952922366 -ab25c857f26830631113d50145e961441b5e35d47b9e57f92466654dffebde43e4f78b0867d20929f97c2888c2f06509 -98950aa5a70ef41f274775f021a284d4d801a2efe2dea38460db8a3a8c08c243836d176e69127c2cd17497b0ca393e9e -a9698113febfb6d87fcb84bad82ce52d85a279d3a2933bdd179d53cfe8d6c6c68770e549a1e2947e7528a0e82c95d582 -832b504513266259db78478bd1b5a3b0f3bf2c6d25f1013e64bf0cfae9dc23da8ecd25f7f1047d2efb90e5f1d9b4b3cc -b588bba7bcc0d268ab260d5c1db2122cee7fd01583c7cc27a8ae6b48b29f34c6ea8a6acbb71b9b09c6156ec0a0766142 -a73d2223c7afadc381951a2e9e7bcb7b5c232369f27108c9f3c2ced2dc173e0f49531d0ca527eb142fbb70285307433f -9152cd6b97bd3278465348dde2095892f46342aed0e3d48675848c05b9aee6ef5ad7fe26e0dcd4ab176532289d40eedd -a7812a95a43b020721f688dd726356dda8ebe4de79b4f0fdef78615795e29681bff7c6ff710ff5b2d6ae3fd81bdb8507 -83724c16049e9eaae3269ea8e65caa212f0592e0190b47159bb3346208ccb9af3cfe8f6c3176fa566377da1046044ab8 -877634ec37c7dcd3b83705b103c31013697012795f11e8abf88d54bc84f2c060f665f0c3b14ef8087d3c6a8a7982d64f -b3e53aaacef7a20327bdbba8cd84513534d2e12fd5e1dcf2849f43146e098143b539ebd555623d0ecc46f5ebb4051fca -952d58ecafca9b7ffc25768ee4f05ce138f0289d72978eb5e5d3b23a0daedcb17478890afdce42e30d924d680e13c561 -a10dcc725f9a261de53dd3133858c126f6aa684cf26d92bce63a70e0ff5fff9610ad00d2b87e598b0a7548cfd1ffe713 -b7bc5d0c6b665d5e6f4d0af1c539d8a636550a327e50a0915c898ac494c42b3100e5fae0074c282d1c5073bf4a5456fb -8adc330d3b49ddf3ed210166afc944491aaedb28cb4e67472aeb496f66ce59184c842aa583bfb1a26d67d03b85065134 -b2df992a1310936394a1ebca94a7885b4c0a785638f92a7b567cfb4e68504ac5966a9e2b14891d0aa67d035a99e6583a -96f5da525d140739d19cebb706e2e1e0211edea1f518e040d361d5aca4c80f15be797f58cb4cd3908e4c360c18821243 -b2c0d9173a3d4867c8842e9b58feb1fb47f139f25d1e2332d6b70a85a58811ef99324bf8e52e144e839a4fe2d484e37b -ad95a7631ddb4846d9343d16533493524dfd22e8cbfc280a202343fccee86ab14446f6e7dad9bad9b4185c43fd5f862e -97f38ab82a51a7a792d459a90e7ea71c5a2f02d58e7d542eb3776d82413932737d9431bd6b74ec2a6a8b980d22d55887 -ad4e4c57ec3def5350c37659e8c15bd76d4c13d6de5453493123198dda2c2f40df349f20190e84d740a6b05e0b8f3deb -a691bc10810d11172a6662e46b6bbc48c351df32f325b319553377f525af44a50aaa02790c915b3a49824aa43f17fff0 -a80ccac79bb4014ee366dbf6e380beb61552bd30ef649d4ec39ab307e4139b7775e776fab30831517674ff3d673566f6 -b11e010b855d80e171705ab9e94364c45998e69d9120e4ca4127049b7a620c2eec1377356e7b877874e767f7c44afef4 -96bfab7777769a1e00ce16ada6667a0d21d709e71bd0371c03002427d138d9172640cdd5c529c710fea74bb9d19270c7 -a5bffd2c30e29633b4ecf637c1e792c0378252e2a99b385a093675940b48de2f262c275332ed4765f4a02467f98e3ddd -8d11929d67a6bd8a835b80660a89496250c766e713bddb2cd7052d67b92c39a38ce49005d38b4877856c4bef30fb9af4 -8e704597a0dba1dbd1ff8c9755ddac3f334eeeb513fd1c6b78366603ebc1778231deb8e18f2889421f0091e2c24d3668 -904fbb3f78a49e391a0544cf1faa96ba9402cba818359582258d00aff5319e3c214156cff8c603fbc53a45ede22443e9 -af12ac61eaa9c636481a46fd91903c8a16e7647534fc6fd9baa58ae2998c38ffbd9f03182062311c8adfef0a338aa075 -87f2e544b2993349ab305ab8c3bf050e7764f47d3f3031e26e084e907523d49e1d46c63d0c97b790394f25868e12b932 -a279a7bef6de9d4e183e2bedaf8c553fadfc623a9af8785fe7577cadced02b86e3dab1e97b492d4680c060ea0126abeb -8ece08667ed826f0a239cea72e11359f7e85d891826292b61d4edbdc672f8342e32c66bec3e6498016b8194168ba0e0d -90a15162586e991b302427bc0307790a957b53ab0e83c8b2216f6e6302bc496cb256f0f054ff2cccdfe042763de00976 -9966c0413b086a983f031a39080efde41a9fedcaf8e92897ce92e0c573b37981f5ea266b39dc4f4fb926a1bce5e95ad7 -9515be2f65a57e6960d71bfb1917d33f3f6d8b06f8f31df30fc76622949770fea90ff20be525ae3294c56bc91efb7654 -86e71c9b4059dc4fd1ce7e28883e4f579a51449cab5899e371118cdb6afe2758b1485961ca637c299896dea7c732151b -8695b4ff746d573f8d150f564e69fe51c0726c5d14aa1d72d944f4195e96165eca7eba8cac583fd19d26718b0ce3eb61 -813eecf402151c99c1a55b4c931716e95810fc4e6d117dfc44abbf5ef8dcdf3f971d90d7fa5e5def393681b9584637e0 -a9caf7219eed1db14b7b8f626f20294a3305ed1f6c22f6a26962772c2fa3e50b5234f6d9ba7fa5c3448824c2a15271b3 -b2b2ee20de9b334f2d82cbe0d2e426ca1f35f76218737d0069af9b727a1bfc12d40cf8b88d4afcbeaadf317b7f7ad418 -b853960749521a17ff45f16ac46813d249c4e26e3c08fd33d31ef1ed2b2e157c9cb18bd2454fb5c62690bdd090a48f60 -88772297d2972471b3db71f3ddbf5945a90154768ca49fa6729a5e2299f1795445fb3d4d969d1620e87dca618fbc8a6c -a2bb783fd13aee993e3efd3a963ebc8a8eacfc8450042f018f2040353de88c71ac784b0898bdff27f606c60a3d5ef2c6 -9210903ac619edca0cb8c288ed6dcc93c472f45182cd6614a8e2390801ddea41d48a4ac04a40e2f0adfd48f91aabe2ea -a621d00f83260c22db9fa28757ea81dabcc78b10eeaaf58b06b401db6cc7a7d9a6831a16f171ead4e8506d0c46a752ca -b25c525bf6761a18bbd156ac141df2595940c7b011ed849dbb8ac3a2cd2da6b63ba4755324d70dc14c959deb29fb9ad3 -a35111d0db3e862e1b06249d289e0fc6b110877d254f2ae1604fb21292c227a8b6d87dd17a7b31166038d6860b1bd249 -90bf057309867d95f27637bd10ef15ceb788f07d38aca7ad7920042293d7c4a1a13d4ca1d6db202864d86d20a93e16cf -a88510e110b268d15dcd163ba1e403e44b656771399ac3a049dcb672a1201e88bf60bdd1d303158888a3d30d616cc0bd -b33b7e1f765e9cbd5eeb925e69c39b0a9ea3348ab17f1dbb84b66f4a4b3233e28cbdeb0903d6cfe49ec4fc2f27378ff9 -b777da64fa64d9bc3d2d81b088933fce0e5fcc29c15536159c82af3622a2604c2b968991edea7b6882c9e6f76b544203 -8ea598e402a056fd8031fbf3b9e392347999adc1bd5b68c5797a791a787d006e96918c799467af9ac7f5f57eb30b4f94 -b6901a389bf3b3045e679d015c714d24f8bbe6183349b7f6b42f43409a09f0d5bd4b794012257d735c5fdf6d1812554b -b5866426336d1805447e6efc3f3deb629b945b2781f618df9a2cc48c96020846e9108f9d8507a42ba58d7617cb796c31 -a18ccc6ad1caa8462fa9bec79510689dd2a68d2e8b8e0ddbeb50be4d77728e1d6a18748a11e27edd8d3336c212689a4d -abbd48c48a271b6b7c95518a9352d01a84fb165f7963b87cdc95d5891119a219571a920f0d9ceedc8f9f0de4ab9deb65 -94a4e5f4d7e49229e435530b12a1ff0e9259a44a4f183fb1fe5b7b59970436e19cf932625f83f7b75702fd2456c3b801 -af0a6f2a0d0af7fc72e8cb690f0c4b4b57b82e1034cca3d627e8ef85415adec8eb5df359932c570b1ee077c1d7a5a335 -9728025e03114b9e37ed43e9dcba54a2d67f1c99c34c6139e03d4f9c57c9e28b6b27941d9fca4051d32f9b89bec6537b -941601742d1e1ec8426591733a4f1c13785b0a9b0a6b2275909301a6a3c6c1e2fb1ffa5fdcc08d7fb69f836ae641ced5 -b84b90480defd22f309e294379d1ca324a76b8f0ba13b8496b75a6657494e97d48b0ea5cfdb8e8ac7f2065360e4b1048 -95cc438ee8e370fc857fd36c3679c5660cf6a6c870f56ef8adf671e6bf4b25d1dbad78872cc3989fdfe39b29fc30486d -8aafba32e4a30cad79c5800c8709241b4041b0c13185ea1aa9bc510858709870b931d70b5d9a629f47579b161f1d8af7 -865b0155d9013e80cba57f204c21910edbd4d15e53ae4fee79992cb854dc8b8a73f0a9be92f74893e30eb70f270511bc -b9a49ce58d40b429ac7192cdbf76da31300efc88c827b1e441dd5bdb2f1c180d57808c48992492a2dc5231008629159f -8d1438b10f6cd996494d4c7b5a0841617ec7cf237c9e0956eac04fda3f9ded5110ec99776b816e3c78abd24eb4a9c635 -af2dd18211bb8a3e77c0a49d5773da6e29e4e6fa6632a6eeb56c4be233f6afe81655d977932548de2be16567c54ffbd7 -92b92443f44464f2b48002a966664a4267eae559fa24051983bcf09d81bed5bcc15cb6ff95139d991707697a5d0cc1ab -a1864a2bac0c0dd5b2fb1a79913dd675fe0a5ae08603a9f69d8ca33268239ac7f2fed4f6bf6182a4775683cb9ccd92a8 -948e8f1cf5bd594c5372845b940db4cb2cb5694f62f687952c73eb77532993de2e2d7d974a2ced58730d12c8255c30a2 -aa825c08284fa74a99fcfc473576e8a9788277f72f8c87f29be1dd41229c286c2753ff7444c753767bd8180226763dfc -8384d8d51415e1a4d6fe4324504e958c1b86374cc0513ddf5bcbffabb3edcf4b7d401421e5d1aa9da9010f07ef502677 -8b8223a42585409041d8a6e3326342df02b2fe0bcc1758ff950288e8e4677e3dc17b0641286eaf759a68e005791c249c -a98a98cc2fb14e71928da7f8ce53ab1fb339851c9f1f4bceb5f1d896c46906bd027ef5950ca53b3c8850407439efedd4 -866f44d2e35a4dbffe6cd539b6ef5901924061e37f9a0e7007696fb23526379c9b8d095b417effe1eecda698de744dcb -91774f44bf15edafdf43957fdf254682a97e493eb49d0779c745cb5dbe5d313bf30b372edd343f6d2220475084430a2e -ab52fc3766c499a5f5c838210aada2c3bcc1a2ec1a82f5227d4243df60809ee7be10026642010869cfbf53b335834608 -a0e613af98f92467339c1f3dc4450b7af396d30cefd35713388ccd600a3d7436620e433bf294285876a92f2e845b90d0 -8a1b5ca60a9ae7adc6999c2143c07a855042013d93b733595d7a78b2dc94a9daa8787e2e41b89197a0043343dbd7610f -ae7e4557bc47b1a9af81667583d30d0da0d4a9bb0c922450c04ec2a4ae796c3f6b0ede7596a7a3d4e8a64c1f9ee8ff36 -8d4e7368b542f9f028309c296b4f84d4bde4837350cf71cfe2fa9d4a71bce7b860f48e556db5e72bc21cf994ffdf8e13 -af6ed1fbff52dd7d67d6a0edfa193aa0aab1536979d27dba36e348759d3649779f74b559194b56e9378b41e896c4886f -a069ba90a349ac462cac0b44d02c52a4adf06f40428aef5a2ddff713de31f991f2247fc63426193a3ea1b1e50aa69ded -8750f5f4baf49a5987470f5022921108abe0ead3829ddef00e61aedd71f11b1cdd4be8c958e169440b6a8f8140f4fbf9 -a0c53cefc08a8d125abd6e9731bd351d3d05f078117ff9c47ae6b71c8b8d8257f0d830481f941f0c349fc469f01c9368 -94eea18c5ed056900c8285b05ba47c940dff0a4593b627fdd8f952c7d0122b2c26200861ef3e5c9688511857535be823 -8e1b7bd80d13460787e5060064c65fbcdac000c989886d43c7244ccb5f62dcc771defc6eb9e00bae91b47e23aeb9a21f -b4b23f9dd17d12e145e7c9d3c6c0b0665d1b180a7cfdf7f8d1ab40b501c4b103566570dca2d2f837431b4bf698984cad -847a47c6b225a8eb5325af43026fb9ef737eede996257e63601f80302092516013fde27b93b40ff8a631887e654f7a54 -9582d7afb77429461bd8ebb5781e6390a4dde12a9e710e183581031ccfacd9067686cfaf47584efaafeb1936eae495cc -8e4fd5dbd9002720202151608f49ef260b2af647bd618eb48ebeceeb903b5d855aa3e3f233632587a88dc4d12a482df9 -87b99fe6a9c1d8413a06a60d110d9e56bb06d9f0268dc12e4ab0f17dd6ca088a16ade8f4fb7f15d3322cbe7bfd319ae1 -b562d23002ed00386db1187f519018edd963a72fca7d2b9fcaab9a2213ac862803101b879d1d8ac28d1ccae3b4868a05 -b4cc8b2acacf2ce7219a17af5d42ce50530300029bc7e8e6e2a3c14ff02a5b33f0a7fecb0bb4a7900ea63befa854a840 -9789f0fe18d832ff72df45befa7cabf0a326b42ada3657d164c821c35ac7ed7b2e0eba3d67856e8c387626770059b0c3 -986c6fe6771418549fa3263fa8203e48552d5ecb4e619d35483cb4e348d849851f09692821c9233ae9f16f36979c30c2 -a9160182a9550c5756f35cea1fe752c647d1b64a12426a0b5b8d48af06a12896833ec5f5d9b90185764db0160905ca01 -82614dbd89d54c1e0af4f6ffe8710e6e871f57ef833cbcb3d3d7c617a75ec31e2a459a89ebb716b18fc77867ff8d5d47 -8fc298ffba280d903a7873d1b5232ce0d302201957226cddff120ffe8df9fee34e08420302c6b301d90e3d58f10beeb9 -898da9ac8494e31705bdf684545eee1c99b564b9601877d226d0def9ec67a20e06f8c8ba2a5202cc57a643487b94af19 -88218478d51c3ed2de35b310beedf2715e30208c18f046ee65e824f5e6fd9def921f6d5f75fd6dde47fa670c9520f91a -89703ae7dff9b3bc2a93b44cdbab12c3d8496063a3c658e21a7c2078e4c00be0eecae6379ee8c400c67c879748f1d909 -a44d463477dece0d45abb0ebb5f130bfb9c0a3bbcd3be62adf84a47bbd6938568a89bc92a53ca638ff1a2118c1744738 -95df2b4d392143ee4c39ad72f636d0ed72922de492769c6264015776a652f394a688f1d2b5cf46077d01fda8319ba265 -aa989867375710ed07ad6789bfb32f85bdc71d207f6f838bd3bde9da5a169325481ac326076b72358808bd5c763ba5bb -b859d97d0173920d16bc01eb7d3ddd47273daac72f86c4c30392f8de05fee643e8d6aa8bebdbc5c2d89037bc68a8a105 -b0249ec97411fa39aa06b3d9a6e04bbbcd5e99a7bc527273b6aa95e7ae5f437b495385adaefa4327231562d232c9f822 -8209e156fe525d67e1c83ec2340d50d45eba5363f617f2e5738117cdcc4a829c4cc37639afd7745cbe929c66754fd486 -99fd2728ceb4c62e5f0763337e6d28bf11fbe5df114217f002bc5cd3543c9f62a05a8a41b2e02295360d007eaab796a6 -902ebc68b8372feeaf2e0b40bd6998a0e17981db9cc9d23f932c34fbcc680292a0d8adcea2ad3fb2c9ed89e7019445c2 -8b5653f4770df67f87cb68970555b9131c3d01e597f514e0a399eec8056e4c5a7deed0371a27b3b2be426d8e860bf9f2 -8f5af27fdc98a29c647de60d01b9e9fd0039013003b44ba7aa75a4b9c42c91feb41c8ae06f39e22d3aed0932a137affa -81babb9c1f5bcc0fd3b97d11dd871b1bbd9a56947794ff70ab4758ae9850122c2e78d53cb30db69ece23538dc4ee033e -b8b65d972734f8ecae10dd4e072fa73c9a1bf37484abcfa87e0d2fcecac57294695765f63be87e1ba4ec0eb95688403a -b0fe17d0e53060aef1947d776b06ab5b461a8ef41235b619ca477e3182fadaf9574f12ffc76420f074f82ac4a9aa7071 -ae265c0b90bf064d7a938e224cb1cd3b7eca3e348fbc4f50a29ac0930a803b96e0640992354aa14b303ea313cb523697 -8bc10ffde3224e8668700a3450463ab460ec6f198e1deb016e2c9d1643cc2fe1b377319223f41ffeb0b85afd35400d40 -8d5113b43aea2e0cc6f8ec740d6254698aff7881d72a6d77affd6e6b182909b4de8eb5f524714b5971b418627f15d218 -ae2ef0a401278b7b5d333f0588773ec62ead58807cdee679f72b1af343c1689c5f314989d9e6c9369f8da9ce76979db6 -b9c1cb996a78d4f7793956daaa8d8825dd43c4c37877bc04026db4866144b1bf37aa804d2fe0a63c374cf89e55e9069f -a35f73851081f6540e536a24a28808d478a2bb1fd15ee7ff61b1562e44fbafc0004b9c92c9f96328d546b1287e523e48 -82007f34e3383c628c8f490654369744592aa95a63a72be6e90848ad54f8bc2d0434b62f92a7c802c93017214ecf326e -9127db515b1ed3644c64eaf17a6656e6663838fed4c6612a444a6761636eaaeb6a27b72d0e6d438c863f67b0d3ec25c5 -984c9fcc3deccf83df3bbbb9844204c68f6331f0f8742119ba30634c8c5d786cd708aa99555196cf6563c953816aec44 -a0f9daf900112029474c56ddd9eb3b84af3ed2f52cd83b4eb34531cf5218e7c58b3cab4027b9fc17831e1b6078f3bf4a -90adbcc921369023866a23f5cea7b0e587d129ad71cab0449e2e2137838cea759dec27b0b922c59ac4870ef6146ea283 -8c5650b6b9293c168af98cf60ad35c945a30f5545992a5a8c05d42e09f43b04d370c4d800f474b2323b4269281ca50f8 -868d95be8b34a337b5da5d886651e843c073f324f9f1b4fbd1db14f74aba6559449f94c599f387856c5f8a7bc83b52a1 -812df0401d299c9e95a8296f9c520ef12d9a3dd88749b51eab8c1b7cc97961608ab9fc241a7e2888a693141962c8fd6d -abda319119d8a4d089393846830eee19d5d6e65059bf78713b307d0b4aad245673608b0880aa31c27e96c8d02eff39c0 -887f11ae9e488b99cb647506dcaa5e2518b169ee70a55cd49e45882fe5bfb35ffaf11feb2bf460c17d5e0490b7c1c14d -b36b6e9f95ffff917ca472a38fa7028c38dc650e1e906e384c10fe38a6f55e9b84b56ffa3a429d3b0c3e2cf8169e66a9 -a0450514d20622b7c534f54be3260bab8309632ca21c6093aa0ccc975b8eed33a922cbcc30a730ccc506edf9b188a879 -87cfaf7bcd5d26875ca665ac45f9decd3854701b0443332da0f9b213e69d6f5521ae0217ec375489cd4fad7b4babf724 -842ad67c1baf7a9d4504c10c5c979ce0a4d1b86a263899e2b5757407c2adcdcf7ed58173ad9d156d84075ef8798cb1c4 -ac1a05755fe4d3fb2ab5b951bafe65cca7c7842022ca567b32cddf7741782cbf8c4990c1dd4ea05dc087a4712844aebb -a000c8cecc4fddeb926dc8dd619952bc51d00d7c662e025f973387a3fc8b1ef5c7c10b6a62e963eb785e0ec04cb1ffbe -8a573c9986dbeb469547dfd09f60078eab252d8ec17351fe373a38068af046b0037967f2b3722fa73ed73512afd038d2 -b8dff15dff931f58ba05b6010716c613631d7dd9562ae5138dbec966630bcdb0e72552e4eefc0351a6a6b7912d785094 -990e81fd459433522e8b475e67e847cb342c4742f0dbf71acc5754244ccd1d9ff75919168588d8f18b8aea17092dd2a4 -b012f8644da2113bef7dd6cdc622a55cfa0734bd267b847d11bba2e257a97a2a465c2bb616c240e197ff7b23e2ce8d8e -a659bd590fde467766e2091c34a0b070772f79380be069eef1afecc470368a95afd9eed6520d542c09c0d1a9dca23bd0 -b9239f318b849079477d1cf0a60a3d530391adacd95c449373da1c9f83f03c496c42097c3f9aca10c1b9b3dbe5d98923 -851e9a6add6e4a0ee9994962178d06f6d4fbc0def97feef1ba4c86d3bcf027a59bafa0cf25876ca33e515a1e1696e5cc -803b9c5276eed78092de2f340b2f0d0165349a24d546e495bd275fe16f89a291e4c74c22fdee5185f8fce0c7fbced201 -95915654ca4656d07575168fb7290f50dc5dcbbcdf55a44df9ec25a9754a6571ab8ca8a159bc27d9fa47c35ffd8f7ffd -88f865919764e8e765948780c4fdd76f79af556cd95e56105d603c257d3bfb28f11efca1dfb2ce77162f9a5b1700bac8 -b1233131f666579b4cc8b37cfa160fc10551b1ec33b784b82685251464d3c095cdde53d0407c73f862520aa8667b1981 -a91115a15cf4a83bda1b46f9b9719cfba14ffb8b6e77add8d5a0b61bea2e4ea8ce208e3d4ed8ca1aab50802b800e763a -93553b6c92b14546ae6011a34600a46021ce7d5b6fbfcda2a70335c232612205dbe6bfb1cc42db6d49bd4042c8919525 -8c2a498e5d102e80c93786f13ccf3c9cab7f4c538ccf0aee8d8191da0dbca5d07dff4448383e0cf5146f6d7e629d64f8 -a66ab92c0d2c07ea0c36787a86b63ee200499527c93b9048b4180fc77e0bb0aa919f4222c4bec46eeb3f93845ab2f657 -917e4fc34081a400fc413335fdf5a076495ae19705f8542c09db2f55fa913d6958fa6d711f49ad191aec107befc2f967 -940631a5118587291c48ac8576cdc7e4a904dd9272acb79407a7d3549c3742d9b3669338adbc1386724cc17ee0cc1ca3 -ae23ae3a531900550671fd10447a35d3653c5f03f65b0fdffe092844c1c95d0e67cab814d36e6388db5f8bd0667cd232 -ae545727fca94fd02f43e848f0fbbb1381fd0e568a1a082bf3929434cc73065bfbc9f2c840b270dda8cc2e08cd4d44b0 -8a9bc9b90e98f55007c3a830233c7e5dc3c4760e4e09091ff30ee484b54c5c269e1292ce4e05c303f6462a2a1bd5de33 -a5a2e7515ce5e5c1a05e5f4c42f99835f6fde14d47ecb4a4877b924246038f5bc1b91622e2ff97ed58737ed58319acfa -8fa9f5edf9153618b72b413586e10aaa6c4b6e5d2d9c3e8693ca6b87804c58dc4bf23a480c0f80cb821ebc3cf20ea4fc -925134501859a181913aadac9f07f73d82555058d55a7d5aaa305067fbd0c43017178702facc404e952ea5cfd39db59b -8b5ab1d9b5127cb590d6bddbf698ffe08770b6fc6527023d6c381f39754aecc43f985c47a46be23fe29f6ca170249b44 -aa39c6b9626354c967d93943f4ef09d637e13c505e36352c385b66e996c19c5603b9f0488ad4014bb5fc2e051b2876cc -8e77399c6e9cb8345002195feb7408eb571e6a81c0418590d2d775af7414fc17e61fe0cd37af8e737b59b89c849d3a28 -a0150aeca2ddc9627c7ea0af0dd4426726583389169bc8174fc1597cc8048299cc594b22d234a4e013dff7232b2d946c -98659422ef91f193e6104b09ff607d1ed856bb6baed2a6386c9457efbc748bd1bf436573d80465ebc54f8c340b697ea5 -8d6fb015898d3672eb580e1ffdf623fc4b23076664623b66bfb18f450d29522e8cb9c90f00d28ccf00af34f730bff7ac -996a8538efa9e2937c1caad58dc6564e5c185ada6cdcef07d5ec0056eb1259b0e4cef410252a1b5dbaee0da0b98dac91 -aa0ae2548149d462362a33f96c3ce9b5010ebf202602e81e0ef77e22cfc57ecf03946a3076b6171bea3d3dc9681187d7 -a5ce876b29f6b89050700df46d679bed85690daf7bad5c0df65e6f3bde5673e6055e6c29a4f4dcb82b93ccecf3bad9cc -81d824bb283c2f55554340c3514e15f7f1db8e9e95dd60a912826b1cccb1096f993a6440834dad3f2a5de70071b4b4b5 -914e7291da286a89dfc923749da8f0bf61a04faa3803d6d10633261a717184065dcc4980114ad852e359f79794877dd9 -ae49dc760db497c8e834510fe89419cc81f33fd2a2d33de3e5e680d9a95a0e6a3ccbdf7c0953beeb3d1caf0a08b3e131 -b24f527d83e624d71700a4b238016835a2d06f905f3740f0005105f4b2e49fc62f7e800e33cdc900d805429267e42fc0 -b03471ecaa7a3bf54503347f470a6c611e44a3cee8218ad3fcad61d286cfb7bb6a1113dad18475ec3354a71fcc4ec1e2 -881289b82b30aff4c8f467c2a25fced6064e1eece97c0de083e224b21735da61c51592a60f2913e8c8ba4437801f1a83 -b4ce59c0fc1e0ecad88e79b056c2fd09542d53c40f41dea0f094b7f354ad88db92c560b9aeb3c0ef48137b1a0b1c3f95 -a1ffb30eb8ef0e3ea749b5f300241ebe748ed7cf480e283dfcda7380aa1c15347491be97e65bc96bdf3fe62d8b74b3ae -b8954a826c59d18c6bfab24719f8730cc901868a95438838cd61dac468a2d79b1d42f77284e86e3382bf4f2a22044927 -818e7e7c59b6b5e22b3c2c19c163f2e787f2ff3758d395a4da02766948935eb44413c3ddd2bf45804a3c19744aa332f3 -a29556e49866e4e6f01d4f042eed803beeda781462884a603927791bd3750331a11bc013138f3270c216ab3aa5d39221 -b40885fa0287dc92859b8b030c7cca4497e96c387dcfe6ed13eb7f596b1eb18fb813e4ae139475d692f196431acb58fe -89cd634682fd99ee74843ae619832780cf7cd717f230ea30f0b1821caf2f312b41c91f459bdba723f780c7e3eed15676 -b48c550db835750d45a7f3f06c58f8f3bf8766a441265ca80089ead0346f2e17cbb1a5e843557216f5611978235e0f83 -90936ee810039783c09392857164ab732334be3a3b9c6776b8b19f5685379c623b1997fb0cdd43af5061d042247bc72f -a6258a6bae36525794432f058d4b3b7772ba6a37f74ef1c1106c80a380fc894cbeac4f340674b4e2f7a0f9213b001afd -8f26943a32cf239c4e2976314e97f2309a1c775777710393c672a4aab042a8c6ee8aa9ac168aed7c408a436965a47aeb -820f793573ca5cc3084fe5cef86894c5351b6078df9807d4e1b9341f9d5422dd29d19a73b0843a14ad63e8827a75d2da -a3c4fca786603cd28f2282ba02afe7cf9287529e0e924ca90d6cdfd1a3912478ebb3076b370ee72e00df5517134fe17f -8f3cdabd0b64a35b9ee9c6384d3a8426cc49ae6063632fb1a56a0ae94affa833955f458976ff309dafd0b2dd540786ae -945a0630cd8fa111cfd776471075e5d2bbe8eb7512408b5c79c8999bfaeca6c097f988fb1c38fa9c1048bac2bca19f2e -8a7f6c4e0ba1920c98d0b0235b4dda73b631f511e209b10c05c550f51e91b4ba3893996d1562f04ac7105a141464e0e9 -ab3c13d8b78203b4980412edc8a8f579e999bf79569e028993da9138058711d19417cf20b477ef7ed627fa4a234c727a -82b00d9a3e29ed8d14c366f7bb25b8cfe953b7be275db9590373a7d8a86ea927d56dc3070a09ef7f265f6dd99a7c896e -b6e48a282de57949821e0c06bc9ba686f79e76fb7cbf50ea8b4651ccd29bc4b6da67efea4662536ba9912d197b78d915 -a749e9edcba6b4f72880d3f84a493f4e8146c845637009f6ff227ff98521dbbe556a3446340483c705a87e40d07364bc -b9b93c94bd0603ce5922e9c4c29a60066b64a767b3aed81d8f046f48539469f5886f14c09d83b5c4742f1b03f84bb619 -afa70b349988f85ed438faafa982df35f242dd7869bda95ae630b7fd48b5674ef0f2b4d7a1ca8d3a2041eff9523e9333 -a8e7e09b93010982f50bd0930842898c0dcd30cdb9b123923e9d5ef662b31468222fc50f559edc57fcfdc597151ebb6e -8ce73be5ac29b0c2f5ab17cae32c715a91380288137d7f8474610d2f28d06d458495d42b9cb156fb1b2a7dfdcc437e1c -85596c1d81f722826d778e62b604eb0867337b0204c9fae636399fa25bb81204b501e5a5912654d215ec28ff48b2cb07 -96ff380229393ea94d9d07e96d15233f76467b43a3e245ca100cbecbdbb6ad8852046ea91b95bb03d8c91750b1dfe6e1 -b7417d9860b09f788eb95ef89deb8e528befcfa24efddbc18deaf0b8b9867b92361662db49db8121aeea85a9396f64fd -97b07705332a59cdba830cc8490da53624ab938e76869b2ce56452e696dcc18eb63c95da6dffa933fb5ffb7585070e2d -971f757d08504b154f9fc1c5fd88e01396175b36acf7f7abcfed4fff0e421b859879ed268e2ac13424c043b96fbe99fc -b9adb5d3605954943a7185bddf847d4dbe7bafe970e55dc0ec84d484967124c26dd60f57800d0a8d38833b91e4da476a -b4856741667bb45cae466379d9d6e1e4191f319b5001b4f963128b0c4f01819785732d990b2f5db7a3452722a61cd8cc -a81ec9f2ab890d099fb078a0c430d64e1d06cbbe00b1f140d75fc24c99fe35c13020af22de25bbe3acf6195869429ba5 -99dcea976c093a73c08e574d930d7b2ae49d7fe43064c3c52199307e54db9e048abe3a370b615798b05fe8425a260ba0 -a1f7437c0588f8958b06beb07498e55cd6553429a68cd807082aa4cc031ab2d998d16305a618b3d92221f446e6cd766d -806e4e0958e0b5217996d6763293f39c4f4f77016b3373b9a88f7b1221728d14227fce01b885a43b916ff6c7a8bc2e06 -8e210b7d1aff606a6fc9e02898168d48ec39bc687086a7fe4be79622dd12284a5991eb53c4adfe848251f20d5bfe9de0 -82810111e10c654a6c07cbfd1aff66727039ebc3226eef8883d570f25117acf259b1683742f916ac287097223afc6343 -92f0e28cca06fd543f2f620cc975303b6e9a3d7c96a760e1d65b740514ccd713dc7a27a356a4be733570ca199edd17ba -900810aa4f98a0d6e13baf5403761a0aeb6422249361380c52f98b2c79c651e3c72f7807b5b5e3a30d65d6ff7a2a9203 -b0740bfefea7470c4c94e85185dbe6e20685523d870ff3ef4eb2c97735cef41a6ab9d8f074a37a81c35f3f8a7d259f0e -af022e98f2f418efbbe2de6fefb2aa133c726174f0f36925a4eafd2c6fd6c744edb91386bafb205ce13561de4294f3a6 -95e4592e21ba97e950abb463e1bc7b0d65f726e84c06a98eb200b1d8bfc75d4b8cff3f55924837009e88272542fd25ec -b13bd6b18cd8a63f76c9831d547c39bbd553bda66562c3085999c4da5e95b26b74803d7847af86b613a2e80e2f08caae -a5625658b474a95aba3e4888c57d82fb61c356859a170bc5022077aa6c1245022e94d3a800bf7bd5f2b9ab1348a8834e -a097ee9e6f1d43e686df800c6ce8cfc1962e5a39bb6de3cf5222b220a41b3d608922dae499bce5c89675c286a98fdabd -94230ba8e9a5e9749cd476257b3f14a6bf9683e534fb5c33ca21330617533c773cb80e508e96150763699ad6ecd5aee7 -b5fea7e1f4448449c4bc5f9cc01ac32333d05f464d0ed222bf20e113bab0ee7b1b778cd083ceae03fdfd43d73f690728 -a18a41a78a80a7db8860a6352642cdeef8a305714543b857ca53a0ee6bed70a69eeba8cfcf617b11586a5cc66af4fc4f -85d7f4b3ff9054944ac80a51ef43c04189d491e61a58abed3f0283d041f0855612b714a8a0736d3d25c27239ab08f2ec -b1da94f1e2aedd357cb35d152e265ccfc43120825d86733fa007fc1e291192e8ff8342306bef0c28183d1df0ccec99d0 -852893687532527d0fbeea7543ac89a37195eadab2f8f0312a77c73bdeed4ad09d0520f008d7611539425f3e1b542cfd -99e3bd4d26df088fc9019a8c0b82611fd4769003b2a262be6b880651d687257ded4b4d18ccb102cba48c5e53891535e4 -98c407bc3bbc0e8f24bedf7a24510a5d16bce1df22940515a4fbdacd20d06d522ef9405f5f9b9b55964915dd474e2b5c -80de0a12f917717c6fc9dc3ccc9732c28bae36cff4a9f229d5eaf0d3e43f0581a635ba2e38386442c973f7cb3f0fdfa7 -94f9615f51466ae4bb9c8478200634b9a3d762d63f2a16366849096f9fc57f56b2e68fe0ca5d4d1327a4f737b3c30154 -a3dcbe16499be5ccb822dfcd7c2c8848ba574f73f9912e9aa93d08d7f030b5076ca412ad4bf6225b6c67235e0ab6a748 -98f137bf2e1aea18289750978feb2e379054021e5d574f66ca7b062410dcfe7abb521fab428f5b293bbe2268a9af3aa4 -8f5021c8254ba426f646e2a15b6d96b337a588f4dfb8cbae2d593a4d49652ca2ada438878de5e7c2dbbd69b299506070 -8cc3f67dd0edcdb51dfd0c390586622e4538c7a179512f3a4f84dd7368153a28b1cf343afd848ac167cb3fcaa6aee811 -863690f09ac98484d6189c95bc0d9e8f3b01c489cb3f9f25bf7a13a9b6c1deaf8275ad74a95f519932149d9c2a41db42 -8494e70d629543de6f937b62beca44d10a04875bd782c9a457d510f82c85c52e6d34b9c3d4415dd7a461abbcc916c3c4 -925b5e1e38fbc7f20371b126d76522c0ea1649eb6f8af8efb389764ddcf2653775ef99a58a2dcf1812ce882964909798 -94d0494dcc44893c65152e7d42f4fb0dc46af5dc5674d3c607227160447939a56d9f9ea2b3d3736074eef255f7ec7566 -b0484d33f0ef80ff9b9d693c0721c77e518d0238918498ddf71f14133eb484defb9f9f7b9083d52bc6d6ba2012c7b036 -8979e41e0bb3b501a7ebbd024567ce7f0171acfea8403a530fe9e791e6e859dfbd60b742b3186d7cf5ab264b14d34d04 -af93185677d39e94a2b5d08867b44be2ba0bb50642edca906066d80facde22df4e6a7a2bd8b2460a22bdf6a6e59c5fdd -90f0ef0d7e7ab878170a196da1b8523488d33e0fde7481f6351558b312d00fa2b6b725b38539063f035d2a56a0f5e8f1 -a9ca028ccb373f9886574c2d0ea5184bc5b94d519aa07978a4814d649e1b6c93168f77ae9c6aa3872dd0eea17968ec22 -82e7aa6e2b322f9f9c180af585b9213fb9d3ad153281f456a02056f2d31b20d0f1e8807ff0c85e71e7baca8283695403 -affce186f842c547e9db2dffc0f3567b175be754891f616214e8c341213cbf7345c9ecd2f704bb0f4b6eba8845c8d8a7 -ab119eb621fade27536e98c6d1bc596388bb8f5cad65194ea75c893edbe6b4d860006160f1a9053aea2946bd663e5653 -99cd2c1c38ead1676657059dc9b43d104e8bd00ae548600d5fc5094a4d875d5b2c529fac4af601a262045e1af3892b5e -b531a43b0714cc638123487ef2f03dfb5272ff399ff1aa67e8bc6a307130d996910fb27075cbe53050c0f2902fc32ffe -923b59ac752c77d16b64a2d0a5f824e718460ef78d732b70c4c776fecc43718ecfaf35f11afbb544016232f445ecab66 -a53439cd05e6e1633cdce4a14f01221efcd3f496ac1a38331365c3cadc30013e5a71600c097965927ee824b9983a79cb -8af976ffab688d2d3f9e537e2829323dda9abf7f805f973b7e0a01e25c88425b881466dee37b25fda4ea683a0e7b2c03 -92e5f40230a9bfbb078fa965f58912abb753b236f6a5c28676fb35be9b7f525e25428160caeaf0e3645f2be01f1a6599 -8c4e7b04e2f968be527feba16f98428508a157b7b4687399df87666a86583b4446a9f4b86358b153e1660bb80bd92e8b -97cd622d4d8e94dceb753c7a4d49ea7914f2eb7d70c9f56d1d9a6e5e5cc198a3e3e29809a1d07d563c67c1f8b8a5665a -967bfa8f411e98bec142c7e379c21f5561f6fd503aaf3af1a0699db04c716c2795d1cb909cccbcb917794916fdb849f1 -b3c18a6caa5ca2be52dd500f083b02a4745e3bcaed47b6a000ce7149cee4ed7a78d2d7012bf3731b1c15c6f04cbd0bd1 -b3f651f1f84026f1936872956a88f39fcfe3e5a767233349123f52af160f6c59f2c908c2b5691255561f0e70620c8998 -ae23b59dc2d81cec2aebcaaf607d7d29cf588f0cbf7fa768c422be911985ca1f532bb39405f3653cc5bf0dcba4194298 -a1f4da396f2eec8a9b3252ea0e2d4ca205f7e003695621ae5571f62f5708d51ca3494ac09c824fca4f4d287a18beea9a -a036fa15e929abed7aac95aa2718e9f912f31e3defd224e5ed379bf6e1b43a3ad75b4b41208c43d7b2c55e8a6fedca72 -80e8372d8a2979ee90afbdb842624ace72ab3803542365a9d1a778219d47f6b01531185f5a573db72213ab69e3ffa318 -af68b5cdc39e5c4587e491b2e858a728d79ae7e5817a93b1ea39d34aec23dea452687046c8feae4714def4d0ed71da16 -b36658dfb756e7e9eec175918d3fe1f45b398679f296119cd53be6c6792d765ef5c7d5afadc5f3886e3f165042f4667f -ad831da03b759716f51099d7c046c1a8e7bf8bb45a52d2f2bfd769e171c8c6871741ef8474f06e2aca6d2b141cf2971f -8bae1202dde053c2f59efc1b05cb8268ba9876e4bd3ff1140fa0cc5fa290b13529aede965f5efdff3f72e1a579efc9cc -86344afbc9fe077021558e43d2a032fcc83b328f72948dba1a074bb1058e8a8faec85b1c019fc9836f0d11d2585d69c8 -831d1fc7aa28f069585d84c46bdc030d6cb12440cfaae28098365577fc911c4b8f566d88f80f3a3381be2ec8088bf119 -899de139797ac1c8f0135f0656f04ad4f9b0fa2c83a264d320eb855a3c0b9a4907fc3dc01521d33c07b5531e6a997064 -855bc752146d3e5b8ba7f382b198d7dc65321b93cdfc76250eabc28dba5bbf0ad1be8ccda1adf2024125107cb52c6a6e -af0aeccab48eb35f8986cabf07253c5b876dd103933e1eee0d99dc0105936236b2a6c413228490ed3db4fa69aab51a80 -ae62e9d706fbf535319c909855909b3deba3e06eaf560803fa37bce3b5aab5ea6329f7609fea84298b9da48977c00c3b -823a8d222e8282d653082d55a9508d9eaf9703ce54d0ab7e2b3c661af745a8b6571647ec5bd3809ae6dddae96a220ea7 -a4c87e0ea142fc287092bc994e013c85e884bc7c2dde771df30ca887a07f955325c387b548de3caa9efa97106da8176a -b55d925e2f614f2495651502cf4c3f17f055041fa305bb20195146d896b7b542b1e45d37fa709ca4bfc6b0d49756af92 -b0ebe8947f8c68dc381d7bd460995340efcbb4a2b89f17077f5fde3a9e76aef4a9a430d1f85b2274993afc0f17fdbead -8baaa640d654e2652808afd68772f6489df7cad37b7455b9cd9456bdddae80555a3f84b68906cc04185b8462273dcfc9 -add9aa08f827e7dc292ac80e374c593cd40ac5e34ad4391708b3db2fe89550f293181ea11b5c0a341b5e3f7813512739 -909e31846576c6bdd2c162f0f29eea819b6125098452caad42451491a7cde9fd257689858f815131194200bca54511f4 -abc4b34098db10d71ce7297658ef03edfa7377bd7ed36b2ffbab437f8fd47a60e2bcfbc93ff74c85cfce74ca9f93106c -857dbecc5879c1b952f847139484ef207cecf80a3d879849080758ef7ac96acfe16a11afffb42daf160dc4b324279d9b -aab0b49beecbcf3af7c08fbf38a6601c21061bed7c8875d6e3c2b557ecb47fd93e2114a3b09b522a114562467fcd2f7d -94306dec35e7b93d43ed7f89468b15d3ce7d7723f5179cacc8781f0cf500f66f8c9f4e196607fd14d56257d7df7bf332 -9201784d571da4a96ef5b8764f776a0b86615500d74ec72bc89e49d1e63a3763b867deca07964e2f3914e576e2ca0ded -aabe1260a638112f4280d3bdea3c84ce3c158b81266d5df480be02942cecf3de1ac1284b9964c93d2db33f3555373dcc -8ef28607ca2e0075aa07de9af5a0f2d0a97f554897cab8827dfe3623a5e9d007d92755d114b7c390d29e988b40466db9 -87a9b1b097c3a7b5055cd9cb0c35ba6251c50e21c74f6a0bca1e87e6463efc38385d3acc9d839b4698dfa2eb4cb7a2ef -aee277e90d2ffce9c090295c575e7cd3bafc214d1b5794dd145e6d02d987a015cb807bd89fd6268cd4c59350e7907ee2 -836ad3c9324eaa5e022e9835ff1418c8644a8f4cd8e4378bd4b7be5632b616bb6f6c53399752b96d77472f99ece123cd -8ffffdb67faa5f56887c834f9d489bb5b4dab613b72eac8abf7e4bcb799ccd0dbd88a2e73077cadf7e761cb159fb5ec5 -9158f6cd4f5e88e6cdb700fddcbc5a99b2d31a7a1b37dce704bd9dd3385cca69607a615483350a2b1153345526c8e05d -a7ff0958e9f0ccff76742fc6b60d2dd91c552e408c84172c3a736f64acb133633540b2b7f33bc7970220b35ce787cd4e -8f196938892e2a79f23403e1b1fb4687a62e3a951f69a7874ec0081909eb4627973a7a983f741c65438aff004f03ba6f -97e3c1981c5cdb0a388f1e4d50b9b5b5f3b86d83417831c27b143698b432bb5dba3f2e590d6d211931ed0f3d80780e77 -903a53430b87a7280d37816946245db03a49e38a789f866fe00469b7613ee7a22d455fb271d42825957282c8a4e159d9 -b78955f686254c3994f610e49f1c089717f5fb030da4f9b66e9a7f82d72381ba77e230764ab593335ff29a1874848a09 -938b6d04356b9d7c8c56be93b0049d0d0c61745af7790edf4ef04e64de2b4740b038069c95be5c91a0ba6a1bb38512a9 -a769073b9648fe21bc66893a9ef3b8848d06f4068805a43f1c180fdd0d37c176b4546f8e5e450f7b09223c2f735b006f -863c30ebe92427cdd7e72d758f2c645ab422e51ecef6c402eb1a073fd7f715017cd58a2ad1afe7edccdf4ff01309e306 -a617b0213d161964eccfc68a7ad00a3ee4365223b479576e887c41ef658f846f69edf928bd8da8785b6e9887031f6a57 -a699834bf3b20d345082f13f360c5f8a86499e498e459b9e65b5a56ae8a65a9fcb5c1f93c949391b4795ef214c952e08 -9921f1da00130f22e38908dd2e44c5f662ead6c4526ebb50011bc2f2819e8e3fca64c9428b5106fa8924db76b7651f35 -98da928be52eb5b0287912fd1c648f8bbda00f5fd0289baf161b5a7dbda685db6ad6bdc121bc9ffa7ed6ae03a13dbee3 -927b91d95676ff3c99de1312c20f19251e21878bfb47ad9f19c9791bc7fb9d6f5c03e3e61575c0760180d3445be86125 -b8e4977a892100635310dfcb46d8b74931ac59ae687b06469b3cee060888a3b6b52d89de54e173d9e1641234754b32b1 -98f6fd5f81ca6e2184abd7a3a59b764d4953d408cec155b4e5cf87cd1f6245d8bdd58b52e1e024e22903e85ae15273f1 -909aaacbbfe30950cf7587faa190dc36c05e3c8131749cc21a0c92dc4afc4002275762ca7f66f91aa751b630ad3e324d -91712141592758f0e43398c075aaa7180f245189e5308e6605a6305d01886d2b22d144976b30460d8ce17312bb819e8f -947d85cb299b189f9116431f1c5449f0f8c3f1a70061aa9ebf962aa159ab76ee2e39b4706365d44a5dbf43120a0ac255 -b39eced3e9a2e293e04d236976e7ee11e2471fe59b43e7b6dd32ab74f51a3d372afee70be1d90af017452ec635574e0e -8a4ba456491911fc17e1cadcbb3020500587c5b42cf6b538d1cb907f04c65c168add71275fbf21d3875e731404f3f529 -8f6858752363e2a94c295e0448078e9144bf033ccd4d74f4f6b95d582f3a7638b6d3f921e2d89fcd6afd878b12977a9d -b7f349aa3e8feb844a56a42f82b6b00f2bfe42cab19f5a68579a6e8a57f5cf93e3cdb56cbbb9163ab4d6b599d6c0f6aa -a4a24dc618a6b4a0857fb96338ac3e10b19336efc26986e801434c8fdde42ca8777420722f45dfe7b67b9ed9d7ce8fb1 -aafe4d415f939e0730512fc2e61e37d65c32e435991fb95fb73017493014e3f8278cd0d213379d2330b06902f21fe4e1 -845cc6f0f0a41cc6a010d5cb938c0ef8183ff5ed623b70f7ea65a8bdbc7b512ea33c0ee8b8f31fdf5f39ec88953f0c1e -811173b4dd89d761c0bdffe224cd664ef303c4647e6cf5ef0ed665d843ed556b04882c2a4adfc77709e40af1cfdea40b -93ba1db7c20bfba22da123b6813cb38c12933b680902cef3037f01f03ab003f76260acc12e01e364c0d0cf8d45fca694 -b41694db978b2cf0f4d2aa06fcfc4182d65fb7c9b5e909650705f779b28e47672c47707d0e5308cd680c5746c37e1bc7 -a0e92c4c5be56a4ccf1f94d289e453a5f80e172fc90786e5b03c1c14ce2f3c392c349f76e48a7df02c8ae535326ea8fe -96cbeb1d0693f4f0b0b71ad30def5ccc7ad9ebe58dbe9d3b077f2ac16256cde10468875e4866d63e88ce82751aaf8ef6 -935b87fd336f0bf366046e10f7c2f7c2a2148fa6f53af5607ad66f91f850894527ecec7d23d81118d3b2ee23351ed6ed -b7c2c1fa6295735f6b31510777b597bc8a7bfb014e71b4d1b5859be0d8d64f62a1587caafc669dfe865b365eb27bd94f -b25d93af43d8704ffd53b1e5c16953fd45e57a9a4b7acfcfa6dd4bf30ee2a8e98d2a76f3c8eba8dc7d08d9012b9694c6 -b5a005cd9f891e33882f5884f6662479d5190b7e2aec1aa5a6d15a8cb60c9c983d1e7928e25e4cf43ec804eaea1d97b0 -93f9f0725a06e4a0fb83892102b7375cf5438b5ebc9e7be5a655f3478d18706cf7dbb1cd1adcee7444c575516378aa1b -900d7cbf43fd6ac64961287fe593c08446874bfc1eb09231fc93de858ac7a8bca496c9c457bced5881f7bf245b6789e0 -90c198526b8b265d75160ef3ed787988e7632d5f3330e8c322b8faf2ac51eef6f0ce5a45f3b3a890b90aecf1244a3436 -b499707399009f9fe7617d8e73939cb1560037ad59ac9f343041201d7cc25379df250219fd73fa012b9ade0b04e92efa -94415f6c3a0705a9be6a414be19d478181d82752b9af760dda0dbd24a8ff0f873c4d89e61ad2c13ebf01de55892d07fa -90a9f0b9f1edb87751c696d390e5f253586aae6ebfc31eb3b2125d23877a497b4aa778de8b11ec85efe49969021eaa5a -a9942c56506e5cd8f9289be8205823b403a2ea233ba211cf72c2b3827064fd34cd9b61ff698a4158e7379891ca4120d8 -83bb2ee8c07be1ab3a488ec06b0c85e10b83a531758a2a6741c17a3ccfa6774b34336926a50e11c8543d30b56a6ac570 -8a08a3e5ebe10353e0b7fff5f887e7e25d09bb65becf7c74a03c60c166132efaada27e5aea242c8b9f43b472561ae3ed -957c7a24cefaa631fe8a28446bc44b09a3d8274591ade53ba489757b854db54820d98df47c8a0fbee0e094f8ad7a5dc4 -b63556e1f47ed3ee283777ed46b69be8585d5930960d973f8a5a43508fc56000009605662224daec2de54ea52a8dcd82 -abed2b3d16641f0f459113b105f884886d171519b1229758f846a488c7a474a718857323c3e239faa222c1ab24513766 -882d36eed6756d86335de2f7b13d753f91c0a4d42ef50e30195cc3e5e4f1441afa5ff863022434acb66854eda5de8715 -a65ea7f8745bb8a623b44e43f19158fd96e7d6b0a5406290f2c1348fc8674fbfc27beb4f724cc2b217c6042cb82bc178 -a038116a0c76af090a069ca289eb2c3a615b96093efacfe68ea1610890b291a274e26b445d34f414cfec00c333906148 -90294f452f8b80b0a47c3bcb6e30bdd6854e3b01deaf93f5e82a1889a4a1036d17ecb59b48efa7dc41412168d7a523dd -88faf969c8978a756f48c6114f7f33a1ca3fd7b5865c688aa9cd32578b1f7ba7c06120502f8dc9aee174ecd41597f055 -8883763b2762dfff0d9be9ac19428d9fd00357ac8b805efda213993152b9b7eb7ba3b1b2623015d60778bffda07a724d -a30a1a5a9213636aa9b0f8623345dc7cf5c563b906e11cc4feb97d530a1480f23211073dcb81105b55193dcde5a381d2 -b45ee93c58139a5f6be82572d6e14e937ef9fcbb6154a2d77cb4bf2e4b63c5aabc3277527ecf4e531fe3c58f521cc5e3 -ac5a73e4f686978e06131a333f089932adda6c7614217fcaf0e9423b96e16fd73e913e5e40bf8d7800bed4318b48d4b1 -b6c1e6cdd14a48a7fe27cd370d2e3f7a52a91f3e8d80fb405f142391479f6c6f31aa5c59a4a0fdc9e88247c42688e0cf -ab1760530312380152d05c650826a16c26223960fc8e3bf813161d129c01bac77583eff04ce8678ff52987a69886526b -a4252dffae7429d4f81dfaeeecc48ab922e60d6a50986cf063964f282e47407b7e9c64cf819da6f93735de000a70f0b2 -94c19f96d5ecf4a15c9c5a24598802d2d21acbbd9ee8780b1bc234b794b8442437c36badc0a24e8d2cff410e892bb1d2 -89fafe1799cf7b48a9ea24f707d912fccb99a8700d7287c6438a8879f3a3ca3e60a0f66640e31744722624139ba30396 -b0108405df25cf421c2f1873b20b28552f4d5d1b4a0bf1c202307673927931cbd59f5781e6b8748ddb1206a5ec332c0b -aa0f0e7d09f12b48f1e44d55ec3904aa5707e263774126e0b30f912e2f83df9eb933ca073752e6b86876adaf822d14ba -b0cbe8abb58876d055c8150d9fdbde4fea881a517a2499e7c2ea4d55c518a3c2d00b3494f6a8fd1a660bfca102f86d2a -b1ef80ec903bac55f58b75933dc00f1751060690fd9dfb54cf448a7a4b779c2a80391f5fda65609274bd9e0d83f36141 -8b52e05b1845498c4879bb12816097be7fc268ce1cf747f83a479c8e08a44159fc7b244cf24d55aca06dccf0b97d11e1 -b632a2fc4fdb178687e983a2876ae23587fd5b7b5e0bb8c0eb4cfe6d921a2c99894762e2aaccdc5da6c48da3c3c72f6c -953ef80ab5f74274ae70667e41363ae6e2e98ccbd6b7d21f7283f0c1cafb120338b7a8b64e7c189d935a4e5b87651587 -b929cfd311017c9731eed9d08d073f6cf7e9d4cd560cddd3fdcb1149ab20c6610a7674a66a3616785b13500f8f43ee86 -870fb0d02704b6a328e68721fb6a4b0f8647681bfcb0d92ec3e241e94b7a53aecc365ed384e721c747b13fbf251002f1 -979501159833a8ba5422ed9b86f87b5961711f5b474d8b0e891373fe2d0b98ff41a3a7a74a8b154615bb412b662a48be -b20f9c13cdeceef67f877b3878839ef425f645b16a69c785fe38f687c87a03b9de9ae31ac2edb1e1dd3a9f2c0f09d35d -8c7705ed93290731b1cf6f3bf87fc4d7159bb2c039d1a9f2246cda462d9cdf2beef62d9f658cfeea2e6aef7869a6fc00 -aa439eb15705ad729b9163daee2598d98a32a8a412777c0d12fd48dc7796d422227a014705e445cc9d66f115c96bbc24 -a32307e16f89749fe98b5df1effef0429801c067e0d8067794e56b01c4fef742ad5e7ab42a1a4cc4741808f47a0b7cb8 -b31e65c549003c1207258a2912a72f5bad9844e18f16b0773ea7af8ff124390eb33b2f715910fc156c104572d4866b91 -85608d918ed7b08a0dc03aee60ea5589713304d85eee7b4c8c762b6b34c9355d9d2e192575af0fd523318ae36e19ae1c -a6497dbaf0e7035160b7a787150971b19cf5ba272c235b0113542288611ebecefa2b22f08008d3f17db6a70a542c258d -87862adb1ac0510614ab909457c49f9ec86dc8bdf0e4682f76d2739df11f6ffcfb59975527f279e890d22964a1fba9b6 -8717ac3b483b3094c3b642f3fafe4fbafc52a5d4f2f5d43c29d9cfe02a569daee34c178ee081144494f3a2ca6e67d7b1 -855100ac1ec85c8b437fdd844abaa0ca4ac9830a5bdd065b68dafb37046fcf8625dd482dc0253476926e80a4c438c9ec -ae74821bf265ca3c8702c557cf9ef0732ede7ef6ed658283af669d19c6f6b6055aca807cf2fa1a64785ec91c42b18ae5 -812a745b1419a306f7f20429103d6813cbdea68f82ff635ac59da08630cd61bda6e0fa9a3735bfd4378f58ad179c1332 -867dbbfe0d698f89451c37ca6d0585fd71ee07c3817e362ef6779b7b1d70b27c989cdd5f85ac33a0498db1c4d14521fe -84db735d3eb4ff7f16502dccc3b604338c3a4a301220ad495991d6f507659db4b9f81bba9c528c5a6114bcdba0160252 -aadc83d1c4e5e32bf786cfb26f2f12a78c8024f1f5271427b086370cdef7a71d8a5bf7cd7690bae40df56c38b1ad2411 -a27860eb0caaea37298095507f54f7729d8930ac1929de3b7a968df9737f4c6da3173bda9d64ff797ed4c6f3a1718092 -a3cdcaa74235c0440a34171506ed03d1f72b150d55904ce60ec7b90fcd9a6f46f0e45feab0f9166708b533836686d909 -b209a30bdac5c62e95924928f9d0d0b4113ebb8b346d7f3a572c024821af7f036222a3bd38bd8efd2ee1dbf9ac9556cd -83c93987eff8bc56506e7275b6bef0946672621ded641d09b28266657db08f75846dcbde80d8abc9470e1b24db4ca65b -800c09b3ee5d0251bdaef4a82a7fe8173de997cc1603a2e8df020dd688a0c368ad1ebef016b35136db63e774b266c74c -93fb52de00d9f799a9bce3e3e31aaf49e0a4fc865473feb728217bd70f1bc8a732ec37ac3582bf30ab60e8c7fdf3cb8d -a1aff6b4a50d02f079a8895c74443539231bfdf474600910febf52c9151da7b31127242334ac63f3093e83a047769146 -8c4532d8e3abb5f0da851138bfa97599039bcd240d87bbdf4fd6553b2329abb4781074b63caf09bc724ceb4d36cb3952 -8bd9b0ae3da5acda9eb3881172d308b03beec55014cd73b15026299541c42fd38bab4983a85c06894ebb7a2af2a23d4c -979441e7f5a0e6006812f21b0d236c5f505bb30f7d023cb4eb84ec2aa54a33ac91d87ece704b8069259d237f40901356 -a1c6d2d82e89957d6a3e9fef48deb112eb00519732d66d55aa0f8161e19a01e83b9f7c42ac2b94f337dcc9865f0da837 -97a0b8e04e889d18947d5bf77d06c25bbd62b19ce4be36aaa90ddbeafd93a07353308194199ba138efaadf1b928cd8d2 -822f7fbe9d966b8ec3db0fc8169ab39334e91bf027e35b8cc7e1fe3ead894d8982505c092f15ddfe5d8f726b360ac058 -a6e517eedd216949e3a10bf12c8c8ddbfde43cddcd2c0950565360a38444459191bdbc6c0af0e2e6e98bc6a813601c6d -858b5f15c46c074adb879b6ba5520966549420cb58721273119f1f8bc335605aeb4aa6dbe64aae9e573ca7cc1c705cdc -b5191bb105b60deb10466d8114d48fb95c4d72036164dd35939976e41406dff3ee3974c49f00391abfad51b695b3258c -b1b375353ed33c734f4a366d4afad77168c4809aff1b972a078fd2257036fd6b7a7edad569533abf71bc141144a14d62 -a94c502a9cdd38c0a0e0187de1637178ad4fa0763887f97cc5bdd55cb6a840cb68a60d7dbb7e4e0e51231f7d92addcff -8fe2082c1b410486a3e24481ae0630f28eb5b488e0bb2546af3492a3d9318c0d4c52db1407e8b9b1d1f23a7ffbaf260a -b73fe7aa2b73f9cae6001af589bf8a9e73ea2bb3bb01b46743e39390c08d8e1be5e85a3d562857a9c9b802b780c78e6d -8e347f51330ae62275441ccd60f5ac14e1a925a54ced8a51893d956acc26914df1bb8595385d240aa9b0e5ada7b520ea -8dc573d6357c0113b026a0191a5807dbe42dcd2e19772d14b2ca735e1e67c70e319ef571db1f2a20e62254ed7fb5bcd6 -a5dacbe51549fe412e64af100b8b5eba5ec2258cc2a7c27a34bc10177d1894baf8707886d2f2ef438f077596a07681e9 -8349153c64961d637a5ff56f49003cb24106de19a5bbcf674016a466bfbe0877f5d1e74ccb7c2920665ef90a437b1b7e -96ad35429d40a262fdc8f34b379f2e05a411057d7852c3d77b9c6c01359421c71ef8620f23854e0f5d231a1d037e3a0d -b52385e40af0ed16e31c2154d73d1517e10a01435489fc801fbea65b92b3866ab46dab38d2c25e5fb603b029ae727317 -8e801c7a3e8fa91d9c22ebd3e14a999023a7b5beea13ec0456f7845425d28c92452922ca35ec64012276acb3bbc93515 -a8630870297d415e9b709c7f42aa4a32210b602f03a3015410123f0988aea2688d8bcfc6d07dc3602884abbf6199b23f -8cd518392e09df2a3771a736f72c05af60efc030d62dbbb9cd68dc6cbbe1fb0854eb78b6ed38337010eb1bb44a5d5d30 -921aa4c66590f6c54bf2fa2b324f08cbe866329cc31f6e3477f97f73e1a1721d5eb50ed4eacc38051fe9eda76ba17632 -a37e595cb63524cb033c5540b6343c3a292569fc115e813979f63fe1a3c384b554cecc2cae76b510b640fe3a18800c81 -b0bb57e4e31ae3ce9f28cef158ed52dabfad5aa612f5fcc75b3f7f344b7cec56b989b5690dacd294e49c922d550ee36b -a3c618ce4d091e768c7295d37e3f9b11c44c37507ae1f89867441f564bf0108f67bf64b4cf45d73c2afc17a4dc8b2c68 -999e6650eda5455e474c22a8c7a3fd5b547ec2875dc3043077ad70c332f1ccd02135e7b524fcbf3621d386dec9e614fa -b018f080888dec3c2ca7fcfeb0d3d9984699b8435d8823079fc9e1af4ca44e257fbe8da2f6f641ee6152b5c7110e3e3c -a2bcd4bcd9b40c341e9bba76b86481842f408166c9a7159205726f0776dcb7f15a033079e7589699e9e94ce24b2a77fd -b03de48f024a520bb9c54985ca356fd087ca35ac1dd6e95168694d9dae653138c9755e18d5981946a080e32004e238fe -a6c1a54973c0c32a410092441e20594aa9aa3700513ed90c8854956e98894552944b0b7ee9edf6e62e487dc4565baa2f -845d7abf577c27c4c1fafc955dcad99a1f2b84b2c978cfe4bd3cd2a6185979491f3f3b0ec693818739ed9184aba52654 -9531bcfc0d3fcd4d7459484d15607d6e6181cee440ba6344b12a21daa62ff1153a4e9a0b5c3c33d373a0a56a7ad18025 -a0bbf49b2dd581be423a23e8939528ceaae7fb8c04b362066fe7d754ca2546304a2a90e6ac25cdf6396bf0096fae9781 -a1ec264c352e34ed2bf49681b4e294ffea7d763846be62b96b234d9a28905cdece4be310a56ec6a00fc0361d615b547c -87c575e85b5dfbfd215432cb355a86f69256fff5318e8fda457763ac513b53baa90499dc37574bdfad96b117f71cb45e -9972edfdeec56897bef4123385ee643a1b9dc24e522752b5a197ce6bd2e53d4b6b782b9d529ca50592ee65b60e4c9c3c -b8bcf8d4ab6ad37bdd6ad9913a1ba0aba160cb83d1d6f33a8524064a27ba74a33984cc64beeee9d834393c2636ff831a -83082b7ec5b224422d0ff036fbb89dc68918e6fde4077dfc0b8e2ee02595195ecadb60c9ab0ad69deb1bac9be75024fa -8b061fce6df6a0e5c486fd8d8809f6f3c93bd3378a537ff844970492384fb769d3845d0805edd7f0fcd19efabf32f197 -b9597e717bb53e6afae2278dbc45d98959c7a10c87c1001ed317414803b5f707f3c559be6784119d08f0c06547ec60b1 -b9d990fd7677dd80300714cfd09336e7748bbf26f4bb0597406fcb756d8828c33695743d7a3e3bd6ddf4f508149610ef -b45f7d2b00ceea3bf6131b230b5b401e13a6c63ba8d583a4795701226bf9eb5c88506f4a93219ac90ccbceef0bfd9d49 -a8ccaa13ca7986bc34e4a4f5e477b11ae91abb45c8f8bf44a1f5e839289681495aba3daa8fb987e321d439bbf00be789 -ae0f59f7a94288a0ead9a398fdd088c2f16cccb68624de4e77b70616a17ddf7406ca9dc88769dadeb5673ff9346d6006 -b28e965dcc08c07112ae3817e98f8d8b103a279ad7e1b7c3de59d9dbd14ab5a3e3266775a5b8bbf0868a14ae4ab110f1 -84751c1a945a6db3df997fcbde9d4fe824bc7ba51aa6cb572bb5a8f9561bef144c952198a783b0b5e06f9dd8aa421be8 -a83586db6d90ef7b4fa1cbda1de1df68ee0019f9328aded59b884329b616d888f300abb90e4964021334d6afdea058fd -8fcea1ce0abf212a56c145f0b8d47376730611e012b443b3d1563498299f55cbcbe8cbd02f10b78224818bb8cbbd9aaa -8d66c30a40c34f23bae0ea0999754d19c0eb84c6c0aa1b2cf7b0740a96f55dd44b8fee82b625e2dd6c3182c021340ac6 -92c9b35076e2998f1a0f720d5a507a602bd6bd9d44ffc29ede964044b17c710d24ce3c0b4a53c12195de93278f9ec83b -a37d213913aff0b792ee93da5d7e876f211e10a027883326d582ad7c41deebdfce52f86b57d07868918585908ebd070a -a03995b4c6863f80dd02ed0169b4f1609dc48174ec736de78be1cdff386648426d031f6d81d1d2a7f2c683b31e7628c0 -b08b628d481302aa68daf0fa31fd909064380d62d8ed23a49037cb38569058e4c16c80e600e84828d37a89a33c323d1f -a0ee2e2dd8e27661d7b607c61ac36f590909aa97f80bdfd5b42463ca147b610ac31a9f173cbecdd2260f0f9ea9e56033 -967162fba8b69ffce9679aac49214debb691c6d9f604effd6493ce551abacbe4c8cc2b0ccee6c9927c3d3cfbdcb0be11 -8deab0c5ed531ce99dadb98b8d37b3ff017f07438bc6d50840577f0f3b56be3e801181333b4e8a070135f9d82872b7f2 -b1bfa00ec8c9365b3d5b4d77a718cb3a66ed6b6cf1f5cf5c5565d3aa20f63d3c06bb13d47d2524e159debf81325ba623 -90109780e53aeacd540b9fe9fc9b88e83c73eaf3507e2b76edc67f97a656c06a8a9e1ec5bce58bfd98b59a6b9f81b89d -88a1009a39a40421fdcc0ffc3c78a4fbace96a4e53420b111218091223494e780a998ebecf5a0abd0243e1523df90b28 -90b77146711ee8d91b0346de40eca2823f4e4671a12dad486a8ec104c01ef5ee7ab9bd0398f35b02b8cb62917455f8b3 -b262c5e25f24ae7e0e321b66fdb73b3bf562ded566a2d6a0152cf8bafb56138d87b6a917a82f5ace65efc73cfc177d81 -ae65a438c7ea46c82925b5ec5f71314558ca5146f5d90311431d363cfeac0537223c02cbb50fa6535d72fc2d949f4482 -8984208bfc193a6ef4720cc9d40c17f4be2f14595ef887980f2e61fa6927f9d73c00220937013b46290963116cbe66ac -a8f33a580508f667fac866456dce5d9246562188ad0f568eb1a2f28cf9fd3452dd20dc613adb1d07a5542319a37ecf1a -aedadd705fc086d8d2b647c62e209e2d499624ab37c8b19af80229f85e64a6e608d9cd414cb95ae38cf147d80ec3f894 -ae28077a235cd959f37dc3daedc3706f7a7c2ffe324e695f2e65f454bf5a9fc27b10149a6268ebfaa961ad67bb9b75d7 -a234c7f5a5e0e30f2026d62657bd92d91a9907ec6a2177f91383f86abb919778121ff78afb8f52c473fe6fb731018b52 -816a2ea7826b778f559a815267b6c6eb588558391c0a675d61bb19470d87489ba6c1e2486ea81dd5420a42ee7c35a8de -9218b61948c14234f549c438105ae98367ef6b727ad185f17ad69a6965c044bb857c585b84d72ef4c5fb46962974eed7 -a628031217a0b1330b497351758cf72d90fb87d8bdf542ea32092e14ff32d5ef4ca700653794bb78514d4b0edfd7a8d7 -ab4e977141be639a78eb9ed17366f9642f9335873aca87cce2bae0dddc161621d0e23264a54a7395ae706d748c690ee9 -b1538c4edff59bcf5668557d994bac77d508c757e382512c4368c1ded4242a41f6200b73fe8809fb528a7a0c1fc96feb -965caabe5590e2ff8c9f1048bbdda2817e7a2847e287944bfab40d94cb48389441ac42ff3a7b559760bfab42ff82e1e0 -a64b7484d22c4b8047c7a8ef54dc88cb8d110c61ef28ba853821b61e87d318b2b4226f7f0d1f3cdf086a0e1666d0212c -8915ab7e41d974eef9a651b01c2521392e8899e6ab91c22aeee61605c78fb2b052399ba1d03473aa9cfb52d1a8ba4257 -8dd26875d4a1716db2f75a621d01e971983267770e2da92399aecf08f74af1f7e73643ac6f0a9b610eda54e5460f70ed -83dabcb84c9cbce67e1a24ecbfa4473766b9519588b22288edbaa29aca34cefd9884f7310e7771f8f7a7cbced2e7eea0 -956be00c67987fb4971afca261065a7f6fcef9fb6b1fcb1939f664bbc5b704223253ebfda48565624a68fb249742c2cf -a374824a24db1ab298bee759cee8d8260e0ac92cd1c196f896600fd57484a9f9be1912ded01203976ac4fab66c0e5091 -a225f2ed0de4e06c500876e68e0c58be49535885378584a1442aae2140c38d3ca35c1bc41936a3baf8a78e7ab516f790 -8e79c8de591a6c70e2ef2de35971888ab0ca6fd926fdb6e845fb4b63eb3831c5839f084201b951984f6d66a214b946b8 -91babc849a9e67ab40192342c3d0d6ce58798101cb85c9bd7fc0ac4509ffc17b5ea19e58045cf1ca09ec0dee0e18c8f9 -8b4897fc2aef5bbe0fa3c3015ca09fc9414fdb2315f54dbecc03b9ae3099be6c0767b636b007a804d8b248c56e670713 -8f63ba42e7459ea191a8ad18de0b90b151d5acbf4751e2c790e7d8328e82c20de518132d6290ff3c23d2601f21c1558e -a1a035dc9b936587a16665ea25646d0bb2322f81960d9b6468c3234c9137f7c2b1e4f0b9dbe59e290a418007b0e7a138 -81c4904c08f7bb2ac7b6d4ac4577f10dd98c318f35aac92fc31bab05eceb80a0556a7fc82614b8d95357af8a9c85a829 -8c40e44e5e8e65f61e0a01f79057e1cb29966cc5074de790ea9c60454b25d7ea2b04c3e5decb9f27f02a7f3d3cb7014f -ad8709e357094076eb1eb601539b7bcc37247a25fbc6ada5f74bb88b1b371917c2a733522190f076c44e9b8e2ae127fb -92d43cd82c943fd71b8700977244436c696df808c34d4633f0624700a3445f3ecc15b426c850f9fb60b9aa4708f2c7c0 -b2cb8080697d1524a6dcb640b25e7255ae2e560613dbd27beaa8c5fc5c8d2524b7e6edd6db7ad0bb8a4e2e2735d4a6f7 -971ca6393d9e312bfb5c33955f0325f34946d341ff7077151f0bcafd2e6cbd23e2ad62979454f107edc6a756a443e888 -b6a563f42866afcee0df6c6c2961c800c851aa962d04543541a3cedeb3a6a2a608c1d8391cf405428cd40254e59138f3 -986bd17bad9a8596f372a0185f7f9e0fb8de587cd078ae40f3cd1048305ba00954aff886b18d0d04640b718ea1f0d5a3 -ae32dbccfb7be8e9165f4e663b26f57c407f96750e0f3a5e8e27a7c0ca36bc89e925f64ddd116263be90ace4a27872c4 -83725445ec8916c7c2dd46899241a03cf23568ac63ae2d34de3bce6d2db0bc1cfd00055d850b644a059fb26c62ed3585 -a83f7e61c05b1c6797a36ad5ded01bf857a838147f088d33eb19a5f7652b88e55734e8e884d1d1103a50d4393dfcd7a8 -aa010b4ec76260d88855347df9eaf036911d5d178302063d6fd7ecad009e353162177f92240fe5a239acd1704d188a9d -a88f4ba3cf4aff68ec1e3ded24622d4f1b9812350f6670d2909ea59928eb1d2e8d66935634d218aeac6d1a0fc6cae893 -b819112b310b8372be40b2752c6f08426ef154b53ef2814ae7d67d58586d7023ffa29d6427a044a3b288e0c779866791 -b5d1e728de5daf68e63b0bb1dee5275edae203e53614edeeeefff0f2f7ac4281191a33b7811de83b7f68111361ef42e1 -953fb3ddc6f78045e53eaacfd83c5c769d32608b29391e05612e4e75725e54e82ad4960fbef96da8b2f35ba862968a3e -936471136fb2c1b3bb986a5207a225a8bf3b206a1a9db54dc3029e408e78c95bfb7539b67006d269c09df6354d7254ac -ac353364b413cae799b13d7dc6fa09c322b47e60b9333e06499155e22d913929b92a45a0ad04ba90b29358f7b792d864 -a0177419ead02ba3f0755a32eee3fd23ec81a13c01eab462f3b0af1e2dba42f81b47b2c8b1a90d8cec5a0afa371b7f11 -b009eeb5db80d4244c130e6e3280af120917bb6fcebac73255c09f3f0c9da3b2aa718cd92d3d40e6b50737dbd23461aa -b8a43426c3746c1a5445535338c6a10b65474b684a2c81cd2f4b8ebecc91a57e2e0687df4a40add015cd12e351bbb3eb -94ff3698a6ac6e7df222675a00279c0ea42925dc6b748e3e74a62ea5d1e3fd70d5ab2d0c20b83704d389dd3a6063cf1a -90e4142e7ce15266144153e21b9893d3e14b3b4d980e5c87ce615ecd27efac87d86fa90354307857f75d7ebaeffe79ef -a5fd82c3f509ec9a36d72ba204a16f905e1e329f75cfd18aaa14fb00a212d21f3fac17e1a8e3bc5691ab0d07f8ec3cd0 -962e6bfd75ea554f304a5fee1123e5bf2e048ccd3b401716b34c52740384579188ac98bc0d91269fc814de23f4b2dd34 -b50b4e45c180badf9cd842cd769f78f963e077a9a4c016098dc19b18210580ad271ae1ba86de7760dd2e1f299c13f6a0 -84cf08858d08eca6acc86158ffda3fbe920d1d5c04ac6f1fc677760e46e66599df697397373959acf319c31e47db115c -a697a38ba21caa66b7739ed0e74fe762a3da02144b67971fcad28c1132d7b83e0ac062cc71479f99e2219086d7d23374 -ad1f6d01dd7f0de814fe5fbb6f08c1190ff37f4a50754d7b6291fc547c0820506ea629aabacf749fec9c1bbfda22d2d0 -b11fd7f8c120d8a370a223a1adc053a31bef7454b5522b848dec82de5482308fc68fdaf479875b7a4bc3fc94e1ea30eb -93ecf90ebfc190f30086bcaeee18cda972073a8469cf42a3b19f8c1ec5419dff2d6a5cc8ef412ccd9725b0f0a5f38f88 -911f25aaa5260b56b3009fa5e1346a29f13a085cf8a61b36b2d851791f7bcf8456840eccbfc23797b63ecd312e2d5e12 -a52f17a8b2db66c98291020b1db44ab23827e1790e418e078d1316185df6aa9f78292f43a12cd47131bd4b521d134060 -9646fca10bf7401e91d9a49753c72f3ecb142f5ed13aba2c510a6c5ccb8d07b8e8d1581fc81321ad5e3996b6d81b5538 -aa1da4a5665b91b62dda7f71bb19c8e3f6f49cc079d94fcd07b3604a74547e8334efa5a202822d0078158056bbda2822 -a2432ae5feeaf38252c28aa491e92a68b47d5b4c6f44c1b3d7f3abc2f10b588f64a23c3357e742a0f5e4f216e7ca5827 -83c7b47735cd0ef80658a387f34f259940096ebb9464c67919b278db4109fea294d09ea01a371b79b332cff6777c116d -a740a2959e86e413c62d6bdd1bc27efe9596ee363c2460535eab89ba1715e808b658bd9581b894b5d5997132b0c9c85c -b76947237fa9d71c3bece0b4f7119d7f94d2162d0ced52f2eac4de92b41da5b72ad332db9f31ebb2df1c02f400a76481 -a20e1f2b7e9cc1443226d2b1a29696f627c83836116d64d2a5559d08b67e7e4efa9a849f5bb93a0dadb62450f5a9eaab -b44bff680fba52443a5b3bd25f69c5640006d544fca1d3dc11482ee8e03b4463aae59d1ec9d200aa6711ce72350580fb -a9490f5643bacec7e5adcda849ab3e7ff1f89026bf7597980b13a09887376f243158d0035e9d24fdee7cb6500e53ef29 -96081010b82c04ad0bfc3605df622db27c10a91494685ef2e6e1839c218b91cbb56e043e9a25c7b18c5ddee7c6769517 -a9522d59bcf887cbbbc130d8de3ff29a86df5d9343a918f5e52c65a28e4c33f6106ac4b48ecd849a33d39eeb2319d85b -aa5e0cea1a1db2283783788b4d77c09829563b75c503c154fdaa2247c9149918edac7737ef58c079e02dca7d8397b0eb -8c03f064e777d0c07c4f04c713a86bf581cc85155afe40e9065ead15139b47a50ead5c87ac032f01b142d63ff849758a -a34d672bf33def02ee7a63e6d6519676c052fa65ca91ed0fe5fdd785c231ba7af19f1e990fc33f5d1d17e75f6af270be -8680443393e8ac45a0b07c30a82ac18e67dcc8f20254bd5ede7bf99fc03e6123f2fcd64c0ca62f69d240f23acd777482 -a4e00ab43d8ae5b13a6190f8ef5395ec17fbac4aa7dfa25b33e81b7e7bf63a4c28910b3a7dc9204dbc4168b08575a75e -8249259066ee5672b422c1889ab5ed620bddd1297f70b4197c40bb736afba05d513b91d3a82ee030336c311d952cd60c -a0651d8cf34fa971bde1ec037158a229e8e9ad4b5ca6c4a41adedb6d306a7772634f703dcfac36f9daf17289f33c23fb -b02ff6e8abff19969e265395ceaf465f43e7f1c3c9cfc91f1748042d9c352b284e49515a58078c877a37ff6915ee8bf4 -927fb7351ac28254458a1a2ea7388e1fbd831fbc2feedb230818f73cc8c505b7ff61e150898ce1567fcb0d2c40881c7b -a9d3861f72090bc61382a81286bb71af93cdeefab9a83b3c59537ad21810104e0e054859eeafa13be10f8027b6fc33b8 -a523306656730b1a31b9a370c45224b08baf45773d62952a0bf7d6c4684898ae78914cfafbd3e21406407cc39e12afdc -947a090e7703a3ea303a4a09b3ab6b6d3fda72912c9f42cc37627557028b4667f5398a6d64b9281fa2efbe16f6c61ed6 -b41d24d40c10239c85d5b9bf1a3886d514a7a06b31ca982ea983e37162293350b12428eabc9f6a460473ad811e61ba40 -b0bb9805724f4ca860e687985c0dc6b8f9017fe71147e5383cfbbbdcb2a42c93c7062ba42acdead9d992b6f48fc1d5ac -aec775aa97a78851893d3c5c209a91267f1daf4205bfb719c44a9ed2614d71854b95bb523cd04a7f818a4a70aa27d8fc -b53e52e32ca90b38987610585ad5b77ecd584bd22c55af7d7c9edf5fbcae9c9241b55200b51eaed0fbdb6f7be356368f -a2c5ac7822c2529f0201717b4922fb30fb037540ab222c97f0cdac341d09ccb1415e7908288fabef60177c0643ed21bf -92162fda0cbd1dafbed9419ae0837e470451403231ee086b49a21d20de2e3eed7ce64382153272b02cf099106688af70 -8452d5df66682396718a76f219a9333a3559231e5f7f109a1f25c1970eb7c3408a5e32a479357f148af63b7a1d352451 -831ea95d4feb520994bc4904017a557797e7ad455a431d94de03b873a57b24b127fcc9ff5b97c255c6c8d8e18c5c7e12 -93d451d5e0885ccdbb113a267c31701e7c3d9e823d735dc9dfd6cfdcd82767012dc71396af53d3bedd2e0d9210acf57f -a2126f75a768dcc7ebddf2452aebf20ad790c844442b78e4027c0b511a054c27efb987550fcab877c46f2c7be4883ae0 -aa4d2dcba2ccfc11a002639c30af6beb35e33745ecbab0627cf0f200fdae580e42d5a8569a9c971044405dfdafed4887 -ab13616069ef71d308e8bf6724e13737dc98b06a8f2d2631284429787d25d43c04b584793256ed358234e7cd9ad37d1f -9115ee0edc9f96a10edcafeb9771c74321106e7f74e48652df96e7ca5592a2f448659939291ff613dd41f42170b600ad -97b10a37243dc897ccc143da8c27e53ccc31f68220bffd344835729942bb5905ae16f71ccaed29ca189432d1c2cc09b1 -875cf9c71ae29c3bde8cdcb9af5c7aca468fbb9243718f2b946e49314221a664959140c1ebc8622e4ed0ba81526302fd -86b193afbb7ff135ce5fc7eb0ee838a22e04806ceec7e02b3fb010e938fff733fc8e3a1d4b6cba970852d6307018b738 -b3403a94f1483edce5d688e5ed4ab67933430ede39cd57e2cddb4b469479018757d37dd2687f7182b202967da12a6c16 -83edfa0a6f77974c4047b03d7930e10251e939624afa2dcafbd35a9523c6bf684e1bb7915fc2e5b3ded3e6dc78daacf2 -88ff3375fe33942e6d534f76ed0f1dfa35ae1d62c97c84e85f884da76092a83ecd08454096c83c3c67fac4cd966673d7 -af0726a2a92ee12a9411db66333c347e1a634c0ab8709cc0eab5043a2f4afac08a7ae3a15ce37f5042548c6764ae4cf6 -81cfa33bb702e2f26169a006af0af0dcaa849cec2faf0f4784a06aa3c232d85a85b8123d49a1555cca7498d65e0317e4 -910a16526176b6e01eb8fb2033ffbb8c9b48be6e65f4c52c582909681805b3d9e1c28e3b421be9b9829b32175b8d4d80 -93d23befa411ca1adbdba726f762f2403e1cc740e44c9af3e895962e4047c2782ca7f2f9878512c37afd5a5a0abbd259 -82fcf316027fedfe235905588b7651b41e703836f96cb7ac313b23b4e6c134bff39cd10b3bddb7458d418d2b9b3c471b -8febc47c5752c513c4e5573428ad0bb40e15a5e12dbfa4c1ef29453f0588f0b75c3591075fef698e5abcf4d50c818a27 -83dab521d58b976dcea1576a8e2808dfaea9fa3e545902d0e0ce184d02dca8245d549134a238ab757950ad8bc11f56eb -898cfb9bf83c1c424eca817e8d0b99f5e482865070167adab0ecf04f3deeb3c71363b9f155c67b84d5e286c28238bef8 -b845e388cc1a8e8b72a24d48219ac4fd7868ee5e30960f7074b27dada842aa206889122acfce9e28512038547b428225 -b1ce4720e07e6eecc2a652f9edbad6bd5d787fbaff2a72a5ca33fa5a054dd3b4d5952563bc6db6d1ce1757a578bba480 -8db6990dd10741cf5de36e47726d76a12ebe2235fdcb8957ab26dba9466e6707d4a795d4e12ec7400d961bd564bdee7e -a3ca7afd20e16c2a45f73fc36357763847ed0be11cb05bfd9722f92c7ba3fa708cf10d4e0ae726c3eccae23cc55fd2be -8701b085c45b36f3afb589207bbf245ef4c5c82aa967ecd0c334daa1f5a54093c5e0fcacd09be540801920f49766aa0f -84e3736727ba76191d9a6a2a3796f55bb3c3a8bbb6e41f58e892ea282c90530b53ab5490bbf1a066723399bb132160fb -87c02a01917333c7b8866f6b717b1e727b279894108f70574d1b6e9e8dc978eda8778342baf3c6464d6e0dd507163e76 -b8da532dac81fafaed759e99c3ae011d75f3fda67a8c420c3b9747281fe32e31ac3c81e539940286440704c2c3e3b53e -a0cc63c3bef75a5c02942977a68a88cd3d103d829b6c0f070f64206da7e3638f10f42452788092de8fbbc626ce17b0d4 -b5c9317b3f6b1d7ee6871506c0430cdf73e28b02c001ba6ca11061c7e121c91152d2b80c4f80e1d8f51ff5653bc0db5b -b798fb572da977dd3ef2dce64042b012a470d6bd2cb61a16267abe2b8399f74540d7c70462a6b2278d73567447e31994 -b868eda58739effda68c834745cd2cf66a09f0f215607b65685bb5ca3eba71150f43a6e47b81a0c19fb58eeae3da56e8 -9041c93a7e8f2c34812fd6e9744b154e898e1ef69db72bf36242c71e2c251f3db7e86cbd802da603a92cd0b06b62ea63 -a834d648e974230582fc17b3a449f4f65b3297038a3a5401e975b9b60ff79b2006a33e1486d3428106580276993311e1 -a3ce874da6ade9f0f854d7ae7651fc3ff63cec748a847527539fe0d67e6c99eaa3011065a4627c2192af7f9569f7ab57 -ae78ad16de150cc0400d3b6b424c608cd2b2d01a7a38ea9c4e504d8463c0af09613774dbefdd5198415b29904e0fbb63 -b966db5a961067e743212d564595ef534e71dcd79b690a5a2c642d787059fc7959b9039b650372461a1f52910f7e857b -8069904f360af3edfd6cabd9b7f2adf5b61bd7feb0e9a040dc15c2a9d20052c3e5e0158f3065ec3200d19b91db603b71 -9600917dbcd80a47f81c02c3aafecfcef77f031bf612a0f1a8bdef09de9656f4bb0f8e3e95f72ece1c22bd2824f145b6 -834a0767b7b6199496c1faee0e3580c233cc0763e71eebc5d7c112a5a5e5bd95c0cf76a32ea5bb1b74f3cf00fbd2cfb4 -99469a893579ed5da7d34ec228854c4666c58115d3cae86d4fc2d03d38f10d8c5dc8fb693763a96ab6be2045cc8d518b -a52cc0aecda6594de57d8ca13b146e77212cc55854929c03f2a8a6cdfa46296791c336aebcc2610d98612d5b4c0452df -97864434d55aa8a7aad0415d36f9558ce6e6c00452923db68a1e738232d0cb2d47e3b0b8f340c709112838adeaee4695 -a4a7f2c45db3661b6af7ec759f9455ba043b0de6fd4787e3372cba215b9f7c641d5d817a0576e7aa28a46349d2fe0ae6 -864e857652d95e1d168c1b9c294777fc9251a4d5b4b00a346b1f1c9c898af9a9b5ec0ac1f3a66f18a370b721dbd77b23 -ab8eac458fa8e7eb5539da3964ccd297a216448c3af4e4af0dcfed0ce29e877a85e29b9601dc7508a060b97a05f37e15 -a6fd0782c5629c824fcd89ac80e81d95b97d8374c82010a1c69f30cef16ffc0f19e5da2d0648d2a36a636071cb4b69a7 -ad35a75fd8832643989d51d94ee6462d729e15f6444ffdf340dfb222af5d2b6b52e5df86082dbc7728fde7c1f28ac6b4 -8e06831cc8a0c34245732ea610ea6aae6d02950299aa071a1b3df43b474e5baee815648784718b63acfd02a6655e8ea7 -994ac097f913a4ce2a65236339fe523888ee43494499c5abf4ac3bce3e4b090f45d9abd750f4142a9f8f800a0115488c -a3e6a8e5e924f3a4f93e43f3f5aafb8b5831ce8169cddde7296c319d8964a0b6322a0aa69e1da1778fcc24b7de9d8b93 -81a9bd04f4c6e75517de4b5e2713f746bd7f3f78a81a2d95adc87ba0e266d1f5e89c9cfb04b5159c1ff813f7968a27a4 -b24de8f3a5b480981c6f29607b257ded665ecd8db73e2a69a32fcf44e926fdc7e6610598e10081cf270d2f879414b1ab -adc1b3f8ed1e7d5a26b0959ffe5afc19e235028b94cb7f364f6e57b6bf7f04742986f923fae9bf3802d163d4d0ebc519 -a9fa5092b6dd0b4e1a338a06900b790abbc25e2f867b9fb319fdcdfb58600315a45a49584c614f0f9f8b844aa59dd785 -b29c06b92b14215e7ef4120562893351ae8bf97cc5c3d64f4ecd0eb365b0e464cf27beec3f3ddac17ed5e725706b6343 -adc0d532ba4c1c033da92ba31aa83c64054de79508d06ee335dcab5cabae204a05e427f6f8c2a556870a8230b4115fd0 -9737150d439e6db2471d51e006891d9687593af4e38ee8e38bfa626abcefa768ca22d39133f865d0a25b8bbf7443d7db -a10d1e6a760f54d26c923c773b963534e5c2c0826c0a7462db2ea2c34d82890f9c58f0150db00aa2679aa0fdb1afcb08 -816947dc6c08ee779e9c2229d73dbfd42c2b3b6749b98ec76dbad017f4b4d4f77b5916600b576691978287208c025d6f -a2dc52b6056219d999f07b11869c254e8b3977113fd9ba1a7f322377a5d20e16c2adf46efb7d8149e94989b3f063334a -8153900aae9cf48ebc7438b75c16f5478960ef9170e251708f0c2457967b7b31521c889b5fe843d2694a07c0e804fa48 -a9e9d8d66c8774972cc1686809ce1fa5f0e16997ef2178b49bcd8654541b5b6e234cb55188f071477ba1cebcf770da45 -b1fa775f9b2a9b05b4b1f0d6ad5635c7d7f4d3af8abaa01e28d32b62684f9921197ba040777711836bc78429bf339977 -b1afbbd522b30e1ae2adf9a22993ab28b72a86a3d68d67b1833115e513632db075d047e21dfe442d6facc7b0a1b856bf -8779b7d22f42845a06ae31ac434e0044f5f9b4e704847fb93943e118e642a8b21265505ad9d6e418405d0cb529e00691 -ab2c6cef1c4e7c410e9e8deb74c84bedeb3c454ae98e3bc228eb13f6b7081b57977b3e849ba66346250e37c86842c10c -908d6c781d7d96aa2048c83e865896c720a66fdec7b06ab4b172192fe82f9ff6167815ffb66549d72bfb540bb35c36c6 -b790440f205ece489e2703d5d1d01ba8921dd237c8814afb5cb521515ed4c3b0a6df45fd4bd65ba63592c2fe1d008df3 -aec346251f9c78336b388c4e9069a1c6c3afbbb6bfaffdad050a9e70e92fb3cae3609067b4903552936f904c804b0ea6 -a0e528cc2cb84b04cc91b4084e53ead4188682a6050b3857c34280899c8233aa8c1a9c6fa4fd6a7087acf1b36d67734a -aa8d7632be3e4340712a1461a0ad0ae90ba6d76e2916511c263f484c6c426939fa93ffbb702cd0341eea404d6ddffebb -a4ea871d8a1d4b925d890aefb9897847599b92e15ce14886b27ce5c879daa9edead26e02ccc33fcf37f40ff0783d4d9e -ab63e4dc0dbdaf2ada03b3733aafe17e719d028b30dc9a7e5783c80933a39935dbe1ef0320bb03f9564cafdf7a4b029b -8219761bbaa39b96b835f9c2b4cec0bf53801f8e4f4a4498d19638be2fa0a193b2c1fbf94e26c1058d90a9ac145a7a12 -a609ee5561828b0f634640c68a98da47cb872b714df7302ef6b24d253211e770acd0aa888802cd378e7fa036d829cd36 -90793ff0736f3c80b5e0c5098b56cda8b0b2bca5032bb153d7b3aa3def277f2fc6cea60ac03edc82e3a9d06aff7d1c56 -8760085283a479d15a72429971a0a5b885609fd61787a40adb3d3d7c139b97497aa6bcb11b08979e2354f1bc4dbf7a0d -b168ede8b9a528c60666057f746530fc52327546872dd03c8903f827d02c8313e58c38791fb46e154d4247ea4b859473 -842c1149ca212736ebe7b6b2cb9a7c3b81ae893393c20a2f1a8c8bfef16d0a473ff865a1c130d90cc3626045f9088100 -b41d0e2c7d55108a8526aa0b951a5c8d7e3734e22fe0a6a2dd25361a5d6dea45c4ab4a71440b582a2f9337940238fe20 -8380bd49677e61123506dd482cdf76a8f1877ea54ed023d1deabfc05846103cfd213de2aef331cdf1baf69cfc6767be9 -a026f92030666b723d937f507e5a40e3f3cfd414ad4b2712db0a7a245a31a46002504974ed8ba9d8e714f37353926a4e -b492e9e9917b29eb04cde0b012df15cbd04f3963d120b63c55dc4369e04f5ac7682b2c7dff8c03410936c26ca73ad34c -81fd9271b4ee36be0ba8f560d191e1b6616dd53c56d1d8deac8c1be7bc67bbc53d434cf70d04e7fa9de3e63415389693 -835c3711abe85683d2344a3ee5f70e68342fd1aec025ad248efe66aab3e3d5790fad2f45bae0d7a53a80998fde45f0aa -b46599be80b8f7dbad0b17808dd5ca91d787929c0bef96fbbcf6c767727d07ed6785bad164d733ecb015eb6c8469a16d -b36bf5c17271d39f5ccb3d82a5e002957207a0cdf9ae7108a4946e6f3ed21a5d353fa940b6fe949c39422b452339bae9 -a12f5444e602d6fb8be51a08b8bc4ec105dfd759d2afe98d51ff4edd673c92e4fc91ff32417ae8070e12169004f8aad3 -892ce3ca0a2961a01f7f0149b8a98fdc0f8871c2d85e76daf7c8aed2a18624b978a4d0a84213f81f9d2a81f7ca4826d0 -b1e6229ebd5b3d85e62d0474d1fed34564f1b5b9c5856fae36164dd0eff378d67d6717dda77536379006fb462bced9da -ac852921dcb81e54e1e315fd6226219932f7b785c2ceb2035710e814899784d7001101f1515d68e3fb74cdbb4baf9e26 -989a42d851123d708a213f3a02cfc926df15af058ec9b5a9df968fe16decbd781b5e65a4c17fbfedd2ac17126084700f -b1d0fc2f7c948e466445f307da7b64b3070057c79c07c7ebbbe6f8ed300a642b3567aed2e5f28988ac566ba62e0d2a79 -83057263b41775bc29f1d59868a05b0f76d3bdf8a13c1014496feb4c0ee379bfd0d4079785252f51fbeb641e47a89b69 -ac9e6a208aa9c557155cf82b389bb4227db5ac4b22a0c7c8d1c3d98946df8b82b0c49d093ba55c8255e024a6d67c14b4 -8294a11cd3f5111b1f8bd135be23b4de337ac45711db9566ebf6e162cd58e7859b1309eba8149b0f0a43e07f62a92411 -8c15f3388b196603c05adec195c1d2cc589e3466da3169e9afd37157fa55cd34bfafbfc5ff10ac0e04aa6a0d0b2ce3db -b8faf8ba89c3115576ab6b340f6cc09edfea8f7331f5a5e8003960c584e839fcecf401113dfbb9a5c11a13721b35c263 -955c63b1166514c02847402d0e92dccfe3c0dee3bc70d2375669afb061594c85651e6569f471a6969759e5f373277da4 -963bd4f9ae7361d6936d209592a07d9a22cc9ef330cf0c5cb845cb4085d76e114aee66d7599bf5b9f11c6b1c05dade8d -85509b3c97e06e0db113b8b40022c8989a305cec39acab36ba3a73a4b4719573e5bdb82dc4795699c26d983465cd61b0 -b870cfd7f691f88db8d1dfbe809b7b402eabd3b3299606b7dfdb7ef49415411f01d2a7e4f7ebd919ac82c7094f628166 -a5533e7b58a6a9e5c25589134f501584163551247d36f50666eeb0a0745cf33e65bb8f7a9c2dc7fe7cb392414f1ece4a -b93d1ade01ff5678fcd5b5b4f06a32b706213748076cae3a375e20a97231133ec37c1c3202cbc4896b66c3410210f446 -86ed3a58000a46fe2c37d4de515430a57d8f54ab4300294685534372fed1d68e192dd43d43ea190accf3dc9b22e1548b -a8c7d8dc30057bb8ad66b9cfda5e223334407730aeb0f51705922c18e7a07d960c470d463d1781899203e1b1ed1df484 -8d86821d006e957e8544f95a98b110c89941bcc6985562e7a97285f5826b35b690963b2c141ff3f389d92ee18ec76d24 -a4e1108cd3cf01810e74dbbf94340487011b80013b9bfdc04f019188c0d4d077a54b71a3f97a036601aad42a268531e8 -a822cd61db07f64bea00de226102f5fc0adf8fa9f05a6c7478b0ff93e48f6cc3191302d22e1f369b571877d5eb96139c -b1ad4094d0bb4c325dfe072b17711962247dd7ff7e4bce4612e80a6f3c1bde04880ba1682f60d5f1451318afd4d3ba60 -88e7beb0cfd7361288ea27f6b2cb18870e621152ff47994440c18d45284d21bad80d9806ed7d9d392a5cd791d5150ce2 -aad3724a176cf4476595cdfb9e2c3261c37052324c0b5373a30b6cbeb481bccd303720840c49a84ddca916d470eb6929 -a57983370d159e7078a273746fb22468000a6448b1a31d277272e35c6f548f97928e9015f1daf577511bd9cfee165237 -a54136e9db381cdd6dfb3fff8bdec427d4dc1072f914f6fecfec13d7b8f95bb3b5f30ad7677288c008ce134edfb039a7 -a25dfc4019f165db552f769f9c8e94fa7dbbf5c54a9b7cde76629cc08808c1039ecbd916560c2b6307696dd9db87d030 -a917d25328b0754d70f36e795fe928e71ae77e93166c5e4788716c1ef431115c966f2aad0ce016f4bacc2649f7466647 -842ce5e4ad7d8d4b8c58430e97ff40a9fce1f1c65ecba75fed2e215e101d1b2d7ab32c18df38dab722c329ab724e8866 -a8eb2ed2986ff937a26a72699eb3b87ef88119179719ff1335f53094c690020123f27e44fc6b09f7a3874bf739b97629 -96753c1f9c226f626122dad6981e9810a3cf3bbee15cfc88e617cfd42753e34593610861be147a7b8966bcdec55bba8d -94119d31606098f5b129931b51b4b42c4e3513a128b9bfb03cfeee78b77b9909b1c2fcf0a292e49d63bc4e5fe823dfef -a869654f5880d9c21a0af1ff4cfa926e03ec1f2d80fe5524605e04f484e09dc80d6769249f31fd378ff3926ab4cebc69 -b2a539bdd8de4499c5f35cd8824974c2abb1933b3f50d0175dd044563ca829eaa0fc47bdac97eafa98434d1cd05d7c5d -85f53b2bfcde1986ce7279f3a2f5f841f87d75af5d197c897f261d4874bc6868c575ecf7556a32b7b33f7b2795454591 -964f087ed02228b30f401d8aea35c1a7f76698e4075e1bb343398be74c716884e9ca1a31b81566e1ff7513cf76a2f0cd -a1c9d9c9bfbc9c4e281a2953d5991e7b22ff1a32ddaace9e8d9a42e080efb802b853d3276973b5189a5745943c9b4389 -b0c45a9852663a427d7f50c608a6419fbd00f90e8452757a45269d25c0386ec29942f48a34aafc0187ef6020e581d290 -aa3ca7b01862d5d2aea714fa06724b7dda7062b6608605cb712588b2c49fc3c7d89a8799e6e7c31e7a9ef28b1ad4d1f7 -88f5e98ae8c5ae7add42f6d358a35667e590aa80e1869593cbf597d7ee466efa35b429f1836ba2199d8280fe7f60ce3a -8a3bff472e8008f7e50362acc1a0b53c09ac60430942544532722e938470376f0672662261992146765b7c75a380c318 -b9847be7f7aee7532282c279dde928698a892a183ca3047ceda521e9e0a50d96fd3ce59f8e58f31af49508ade6d4ba51 -98065dc23ea3df6d9f8459e81887d88d5752b7e7ba6050ec5c3f0dce93e463e0bf12be3c94ec74c16e2f7ba62e447845 -994aff677b97ee790894dbdb21b1f9210734e008cee2aa2200c8f2579ea650b872f39776a13a8c31e95cc817091bae1c -b292811674e18912ebe79df1af4a132b04ab702c125c039e0213f735f658fafd36c38e5bbd7cad35842576431f5f3630 -96520d750ec10bb10f75019f8f0e4a93ecbc6b678a710d76cd10aa27a6642ad1461bd58fc2aab8e0391b3f788339ed29 -80d478da7fe246ad0e81a00141229e9d91ffb7fd1b29975c8ec358ed5e864e481bf01b927a9ba002c5ec4aa226d0cb57 -ae58049d93a11ae845dc5be2505e95657f83b95d83ff3591a3c565d587157be795ff4481f42d59eda95e6d523444e199 -85f1f5ad988b9f8a7e24b6d6a22b9de9fb3fe408f95711389c444d7ba2243987225b04318aa97a4cde2cb4c30c05508f -922092d0cb828e764ce62f86cbc55c04dce07233cff041888fae48cfe93818780b4aec9b4ff4718275bb2bfa6bd9e9ba -a85ba97125feff0590a05fb78f19a7338639ad1748802918af4d59307bc994536c0ad638b97b9acd26a08b6b4370dfbf -8c46fcaa8d13266d650bd9366180e5ebbfa002c339e4424a030de19ed922e2daa9a353ae54921a42299607ae53feb075 -b8549832230eb1ec6ee3c33c078deb47f556a0907d2a85fde7720391c82d2ed63dd753cf544a6a0a46eed4b8d1ecd9b8 -b7b96f24504c7f8fbed9c1c654a2550feeee068407b809c43f1082c9558c8665806d911d5d244308169d8a531373bf56 -81c483fd9d9ad7af7869d617ac592e7e951e39738da041d8c4110637689108eb29c8acadfc85366c70885cdf77b353c3 -acf33bcfd9080dfdba828727fe36803327a94e8a3ee5b6e445274f0e8267ad3c943994a8dd6d09b8072912b57e1e25b8 -b3475e7456ff96861bc11068198d51b69b899f5ff13022694b501d3adc8bac58a16204b12011d61e880c8459f4badbbb -8ceb9562026aa96d6e786ec2e5cd49200b5b424349a2214cd3ff5c8f1c2bf1b9872480428f5428e45cc61106cbfbd953 -af56f7e482c24a1367fd798201a20c464848ece431f2d8a31a6ef4f9bdbaa50991e748dcb4ef0c08fdac0ef8ddda3b80 -896dae8b12549909d512fd5c02a2f72dde4086aef6c8007ddb26bb04dff51a707ae94ff87e45191fc10339967fa28958 -8ed1c606840e07a2ac6ff16ac6e81ed3e1c90872ababfe68d56ed2dc50d9294579b9c3546dc63292874299a3162d59f9 -b4d7a5c0836e419a46942281ce77d0aade8e39eb1bf1190dd274ca5070898a1c02ad9d165855629d6e1c96df1a6bd5f3 -aebad8939ac117deb28b789d9846c2c80359dc260920ac8408dbae0b6228dbf496dac0023a3b4302bb9a53e8ada18e61 -812d07c74a8650dc3f318c9b2dbf265f181041fb432fee989cedabd44b933dc6590e36c71dcf9dbe7b4bbf74ea0d7c50 -87b131dd3489889e090839c392231e0ee198acac65bb2e9e63e7d6da322391d1685cfc8ba60699308054c4b0fd89c90c -8b12110ece0b99b2e653b4bc840a12bce5b85abf6fb953a2b23483b15b732a0068824f25fcaa100900e742886c7b4a0d -8765fc9b526a98512e5264c877bdca567e32fdcde95cdbcf4f4c88ce8501e1c7fab755f80b87b9b32d86d18856f1d005 -ac806a32a14019337dfdb5f781ecba5cdea8fb69b23e0e57a0f885e0082a9c330ba808621a48e24316604f6c6c550991 -a711970fa40cf067c73e3edee9a111bf00cd927112205e9d36a21897529be9a051be45c336d6b56725dca3aeea0aed15 -908adbc17fc18821f217d46c25656de811d4473779a41eacd70d2a0d7dd3010de4268a562378814e619e13ac594bb0c3 -894251b79be5ae763f44853f6999289b3a9abda64d52797c6c7d6d31ff2a79e9b3906da72f9ebb95b61d6b29479e076f -aadcf11ea15bcb6d979c3ea320cff8dfcc23c5118ed075f35e77f71459b2141253060e3a90839adbcd3d040ad3bdc5e2 -b4e55d7d2eeaaffb0267448ecce0b75166e4805dc0e261eb5634d4a3f3c08964a597302fd8f6b45ec48178619291dadc -a8e2a02c93d6bec7f42f9265269660b4b404940c3e3de9515b4d826ea7e71f18c6f90a71ce3fbe452d0713de73cb391e -8e2467accfe207cb1ba37d60662920f95338ee212927edb706228c25345734217740159310edf17687f58b333754cb65 -90376b88f653381b3bab673c48c2b84fa82a091e18f710a732fef836e0d39043fcd5527aa97a3a385c0a77cf53746993 -b16530e289198c235ab680f86851bcc177f0c16a58483d83a89213077b06d6840600b03834b6b7af0e22b1914f72de43 -8c4fc3854f938ef1c2b5df065e4e75e9f299798afae8205706439491bdf9784c756134922e77af007e349a790afa52b7 -a68aaec4341d29b92b35322f89b1ae3612e7b440c89a86135a07c261dc5799217a651460c92113d099b486817226d8cd -a653f965feefd2df24156478f0cf3755274ca395afb79e8c72d3b6e1d1f5ba7f3e4f9a4c5ee85355de6f3c81935ff579 -aaf6c8d2717b57f6b14e06c742a11a3bc736bfc0327ca4b8a005b6e924f06871141d231737698a9a59286e44f244a168 -8de32e3c104b4278e27aac695d224f134001c3619f15186466c57c0c46f67e2efe537501d0d9f52f4cdbc724a170b92d -8e9b5858b6d4ffe811f6498bd80e454f0d6b345d4729c946626c7cdc196c803a349a14515296aadb7258bb7a5b37e930 -82fc711043aaf1d7a9c712d00eafd816a710f82eb10818ba6af09f591447f36814dbff6e6a1cb2b5c7f16c73930dbbca -b2f0205327fc8ff687f751e7b97788732afaef4fcf51bb17fd7579ed07501915790b70fc36624371fe4fb87a0179d850 -add87d5b1288d30f3449d3ccfa11cba4dc7756d85cee1cb6171b493680a625a01f273d0bb8e6332d0410250036b3acdd -a411f75ef7dd8de8062331ea40929db989e4d65ae8f33d3fa6cc19c98fa8a8ec2b7c7534a5c5eee9e5051626a6a2e47c -89d40a647781e7f2e8ab3a0f7dc7133669944c0cf627376433687a2ea15c137be26f582a6b07ff94b266ac0910009f7c -b2b5f808c26b40ed507922ed119b0fb95e0d6d8b084bbbba58ca456b4354d03110c99989b93207998334ea5d1b70fe49 -8c8db028671969a1e80e595283ce5e678ee955d785043bb5fd39fdb68a00e4c15b462600a7ab1f41486b6883e725894e -958087ce0c75fe77b71770c2f645ef3360c1a9c98637693b988c5f6ce731f72b24ab8b734e8eb6258ee8b23914451f0d -aad6c00df131c1eec6c556bae642e6dcc031e70f63eee18682f711c7b2fcd9afbf1f18cf8a4af562759130add67bd4a3 -b6d23c567291f019cd9008e727704e7e6679b274feb29abba0d92e036f349b1f0fa8c5271ec7384e8d70a2c3977b1f8a -a942c770e903d4150b5684e4b94bb72d0e171df2c7cae6f46e002c41c6b04d774ac6e2753ba8dccdbba3ad1e297a9ae5 -aa542d1849390f86d797408ed7f6a31504aa65d583481a00e475028af20f8b69248a87a8ffab1dace0377db77fe5f9b2 -a1ed3f9564a97f7cabe7c67e018eaeaa42db73a2f3d2332041ca9a7bea57436d848784d6dc402862c22a47f0692b1286 -925c757750c91db8b1b3c220fcbdd80742b4a060abfb0a402071d215c780ef6b420132ec5a43043b9fd7a06bf1b323db -94e575daa7fa0bbb35b4386f510fc3877c9df57bcf15349c5923f30ad6a8df95372835cc078216b41a7192921c1e8973 -9346a41174865d9ab31c7fb9a5329f322bfce06002386d3f5a2e2193de9bfff12bd0bd93307928f7b85e1097b2aaddff -a6e54c9324baa1bff7e9bf39c94fdd308ec6f210aad937112ec727565f8a6141375c04196831873bf506294854f6a20e -98d47b662504f400f1a0e14e24b43829490d022ade02a56288aaf148d466b45d89b5fc146cef67c9ba548cd37ad5e354 -ab690dd59a69904b6b3a4d5a42d17ea4898d9b00c6753aec216d5d4ea564f9a1642697df44d5a62f2c2ab19aaabf1532 -8d0aa8d3c5ec944af49beb99e403cc0d6d1adc6003b960075358a4ff1cbfa02a83d6cb4d848d9e83b34882446a330883 -af9334b7300780c752f32eaa68f3dcecd07dc50d265083f37f9800b02c2595ba24dab89f5fc27c1ecfdbf5291b4d77bc -81c4a6aaf7d4ccee9925c512dae5da6d916a6dd59f7a4cc79d216a91201b4d300114a309e3ddb3291bb95f85bec2a8ea -8c804e810c0785789de26e12b1beff56a163769733be7a31f34f81093782d6410293768a166c9191ef8636fc8724a31e -a91222b48de238f6dfe79c84080cee618611bd0bdca15cfe44474829e42481f8511a82589e69964e19f8cba04e3f5f3f -b26a8885aa594b0c8ad4a1711d80bcf687df996442075dd1497db1b446d16c74e28bc6f0e92b2ecea9c3e15c9c7e828a -85940f45d324ad1d335bd1d7d6f81758f52213e63d5770d9fe0c0c9507d5550795e538b6a2dd463f73d789b5ce377aed -931a277c78082f416880620df3aeb6d0bff2103d19679dd092ea981f5323e438c50a0d094908034ff8a2cb47b1a44108 -88dd85e4e2aa349a757b98661fc00d4538ec1d3f53daf44b16ffcf7f943dd4f2bba5b8ba3b05c529251dfeed73f6f1e9 -b7fd7182cd33639710b8216c54a11bb02e199bbc54fe33492a809dbe17771a685d6238ea3ebcfc75e3b0d4ea5369bc9f -85d77194d910f8cdad7330e1bca9087529a40fece17492f1d17cc4790833891b6d01d24f036b6422175c732b438faeb5 -9845265892d672d9517fbd22f88be4f225711b4abafa8327cc059f000656e4737188506051565d97912a0c19c3d063c0 -90a81987aa841c7f640c298b816643a0ae00cd3609c3a31d0b01245283cc785d9bb27763131b31a4f21aeda4e50073e8 -8b1256eb41a600bda8a06ac08b98a220ebfd52f89a0e4fdce32425db7a0481e9b7873ba3b7a24ad9fb782ee217dfdbf6 -870548998deed85c59507cec7e69cc001c279bb2a99c45a4d030a35c107e69feb76afecb9e435e67965051d6d7a88220 -b1504d194a0dd8df48d431ce991f89d7a0f72f573d21bd5bb46474c5005e43820877a44e62db555f194427ac8a4b9168 -a00d7423ec2cf0c9e9da07f3dae092d09e1ff4be852e07e531aa54d62ad937bfb52c8bf44683ac3a70f6dfc125575da1 -8019625ad3d218018803aacc2efcedba3a41c24aca8c5aab2005556e58fdf2ed614831277df7937aa594e97a2fc65e7d -8595596284f3add0155ecfee3fc0b66a6b6fc7923d82ca8302952e2ed906d119a1c053aed1123b51f73e1d30d93aba57 -a8ba033f5e7d06177e9ae2d99c40ed4e99e14e1c1b61795997f62e21ed8af1531c4720f23d6a39b0f75c6cd91c58c700 -a94f4167c0f6ae214bae75dd92c63299dd954b00b0d8b0416b8af929fe5aec6a259e44f83a183412d7ba4eb3a49728c0 -a73ee3c3a0fd2a369e0a279c3e214fb662d0378eea3c95cfb91412d7213a1f05958bd0de8f2a4f80f9f80d7eef943b41 -8ef6f3e241f6a761c9ab412629a49648c08b70b837c2cd8bea620bc93056ec73754e3e11f0df50f8e9fa67a9867501a9 -80b473ac4ba8cb82b4ae684206cde124d10fcf619f55a6c90d035981e1b08b9e141b4e5fa9a9af0b7f0c281b355dd593 -a566e2be0b41f01978dfffbb32f442b5e6706f5b9901110e645cf390f6a82869e3ca16887ffa35782a004d251d29c26e -a74e01eefa03546d00afdd24bf17015eee95d36de28c03c9b055e062cd5e8d8f20473c6d7ad21c94f9058fc5e84f9628 -acefc74de146911275dfd19bbe43d72729e89e96da04aff58e5fcb90962856c0b24eb13f43e30329f5477a1b65ae9400 -b5f113ef36e75de6d6d44130f38e460ad3ffc65cb9a5606828c4f7617981fecf76f5e862d7626ccb117aa757cc3c3e52 -96d3aeb1d3a66b136244062b891fc7f93ce745b776478d361a375ae57bdba9b4fcb257becbae228c1a3aff4a1c4fb5e2 -ab26c4a110877e5495b674569a32025dad599637b5dafedcfe32f205dfa68cd46f3ddf4f132a8e5765883b5c83214a07 -922a7a738066692193af32ccbab74edef067668ce3253e18a3275afcd5a6df7168deb2f5175c5fb413dc08fdaef63b17 -a47542f8e4a3a35ef6049280d1a9442c920887d5f1a1483149e143ca412318495a36decb804f81c9f5a7672a14965a4c -8fde57991e72a2aebd3376b4d9fdd795943ba3833431e52b136683567e6ee2cc1c1847dc49dc9534983060c54bf22f7e -addb041f01a99e7238ab2f9f2f94579861d0470b93b91cfb29f3a2e4c82386c868b2cfb6f3778b8a9cf908788acafe58 -a8c4e1df726431c43703739776e2cc51f5ebac57051244991baf53582538120133a44ca603d0722a4b5193e1be3c5ec0 -846379125968d1154376c5dc63100bdcd99b9403d182e3566fe48d79099099f51523cd81d21f0d1dcd622b715bdd851a -b828bf0d936d275abb40e3d73ef57fcd7ce97e9af35e194ae61463317bac6c1b0c3e4b40afe08a1061037bb7149108fc -abd07c71754973e698fa26c5019afd9551548f8369e2249b9902513f19a097057ee7065a1d88912e8f52e6e0fbfa6d82 -a9e36b6fcc9a3cc98e76d5751c76c50e1f92b7670f8076ab6ca8a30de4ec14c34669e049fd39bd293cde8789b1ca67f0 -8c060835496a04c7b51790790035862b20547e62fa8bb4e8857fb36891ec6309520af5c0f45d5ea46e3d228747d710a4 -8cc472ec62b8dce244373f40a821db585628989b6a7c4d394edffbc6346c8be455f4528d528fff41f91f2c875bd9fc0f -b4a75571f84f93451f15b3a86479063d7324d2789b6d2f2f4f8af68c66fac32743dc09b51df29608d62aaba78f6904af -916484984743b5ac16d40d0544faf9184819d92f779254b7fb892eb68cefbe59e75be8a6336a585e120f6ccae0a1eeac -b906ae585a73119764024e9eb87d92e53ee0c673474fec43fec4d344a3bbf471ce3976d25e37d197604689bbc944f1ab -8552708487305f16f95db3e01fbbfb969398f5b6d116844cbb000c9befd03f15c767584bf9541a42141949a4dc787a3a -a6025a2773f78c247f78c0d895ade8a6baa76e5499085f6175935d98a05fc41c1359f7843e0c6c323f1be256c45f45e6 -96dac695dd9288aeb6e32dce50e51ddf1fbd41de6146e3605c7a81f2253b17babf2bfda4f5a9d0c28352b9746c0dfa2c -a215b21f8eb2290f9d308278f2859a999eb3a31f4888f84a65f9ed05e1151c17777f91054d4d0de759ac5c3547d91929 -8fd7c9a279e9b619acf927d501b35dc551979731a89eab91d38b2356c0d73569baddacb9d1096d20a75c917ecaedadd6 -b985e8baa5195e2f1ea1091122d55aa321178d597f87b732b23eccb12b891638be1a992305a1ffcf5233af34339fa02c -ae1a9604b7f569aa48d2daa1889e76d3d103065fc8c3deb9ae127a6d94145695cab3bef640fa781612e8082c6d616c47 -a8fc67f9069f753360349eb874fa4dcadb2ec48d97c61abe568faee5f370ec3c87786c7faf0f73fc0ae7181a36eb89ca -a506d13acc3a9f80509fac936aef848cd30698631fff6130ed6217512ed9527d075f653cf6ef91f68e48a24c903eeb3a -a415093755cc012863043bf586b970bafdd87653ad14d1929672e04949bae4a753d16aa3eb5bd1afe3df3691b80f240f -ace3b792a1960580348b6fae8513149242378a18382741bbc2fb2f785cb8bf87550da4b5e0df2955970ab3a31f99f5d7 -a47d7fa7522664c8f9c404c18102f6f13a1db33ba8b0a56faa31a78a3decba3168c68f410115c5d9f240b3dc046dc9b4 -a9c930db3ea948cd2dd6ea9d0f9a465a5018bbaf6e9958013f151f89a3040cc03ae0b8eaf74b0ff96b4e7a6cd8aa5b4f -88abd235e3e760166cdedff4be82cf6ba02d68f51c6d53b1de326769f1f635215890f9a4c35b06dd16a9b93f30f3a471 -8f8d7b2fcdb70bfedde1ffd7f0b94108f0fa432f6ae81097988521dd2c4da928c10c5da3c7f33f11bd5331f2da8ec219 -b7abdbd48cece30d8f795a58a94913d76842cb006892485a9382a0502826538ca4ff951cc1ef4493e45de8571360d20d -b3e7b125f350c52695f7c5ec4a30916ea6c11744f1151a18ea0510e6cf6ed6f6dba4beaa4ca56988d306bd80ec360056 -9a004423c95e1f1714f98fb97ab798d6ab16cb5f6d6cad860635585d4d4b43ffcda63d8e931351189275e5a2cef28c2f -a8eab6ef917cacdc9b1932eb312309e1f85298d63e55ed9c89ab79da99d3eb60f1643d16be920e82d9285f60c7f7cab3 -934df955485113d10c4dde476ec14a98771145aadf3c8b61af26b09b9948757fa1abcc945ac91466a18c18c2fdce40d0 -99ed9146561597cff8add2196ff3a0f161dd5302685ceb846afca6efb5225f642e8f4a0970eecb01cdf18694fa697095 -b37062dd12a81267bbbf89bc9d6e30784c0e11e713cc49c6c96440f800f2a6a2a7e7f6c7f6c9eed4bc3c8890f2787342 -83a3d70055b6044e0207b3ece4da849755ab5798317b36b20c3555a392c27982f811e1c5007697554eeedc737b37f3ef -a85392c07ff8658935fbc52acec7221cd916c5fde8537a8444eefd507220e76f600350ae8f5dc3353911087b88b91045 -b1ea23558ad805dde9cc1eade995cd8e7f46d9afa230908b5fbaaa09f48547f49c2bd277bff8ab176f1c240beedd2b09 -8a16a48b9105d94700e8e5706b8d8a1ed14cffda5558a596974ea3191c5c3449da6e7efe2059e7baf4530a15f175ce16 -ac5fa54381fc565842417558e131df26e9505027759416165035357816a7e1859a7c14c228c79b4e5ba2ef6758e12ad8 -8475e290c399cc9322c05264a516cf766bf5fdb6b9dec7283961da0b99012d499b244b33fc0eaf94b461ab777f2a9537 -a7922f3c70e6857652805af7d435646c66d94eec174be997c4fe973d8f019990c4f757eeb730b2cfdf8154e6e97f7d5b -b90deb797fba3150cf265a23ea6bd49a382855cd4efe171cbcb1664683a9f1687cfcadfdca4e39cd971ec13aa5cdc296 -91ca761dd9659007d2fe8970bbd336c19ed0d2845d0d8aaab397116affcc793de2da73d89e6625cf4dae5983cceffa56 -9121ae9b60323ab1301e97555bcc74ddba0f5b1e62bfe9eaa2c239e1d685c4a614d397b32a59febed4db9968db44f38a -8477b07da4bbfe9087975f30d2c2333fccfcd7149f90e0e6fabecee627eee3ea324df31cf6a680393f5dedf68a35c9de -946a9c0f02fa6bf9f9d4933e7fc691749f4ac2f82a9b880666b5185189d4f3432da9096d0ea4d6baacbc079e19c887ce -b24663332914ea519435874d4c42d11842ea84dd3dc55292d5b0f27f64587848d095bacaec235a37003bdb5185daa6f2 -b980f46f84ac21dea75b4650f9412f6123325842758589a9b47caa68545905061f03fcad23cc102e2ce8ffeb1ae634a8 -90e9ebb060182d3043ea4210a2d934858559522a19eab9f0ff81a367484a05ec7cce78ee6a91dfff96145869db6a4e80 -b04228a009c91847693eab29c9ea71d1d6ba07060bc2b0b3bb81c46a125baecb3e1412f6ce4305076a97d316d14e4665 -8d3268370dbf38d378c7228c7b54e91f90f43cbfddc0d8468de11a4312616ca6372619209b89114152b16f334f4d2780 -964a63ffae653e0249685e227d937937b079ec3da9c977dad2b2e052af5eb560ce7d175941f2ae0df90e3d0a20b77e75 -855604c2910be885b14b27896e16d8dc339236b975398c771d29ac74e4278a2305fcf85203050a8faffddf64ea19cf78 -8e0b1d61a4349411eec77cf3490555843187a25a93e1f45bf66ad3982b9cc141b07805f8cb252b0fcc125e0052a7c450 -a03bc9588f971a1257cd0cfd2ca406c76aaeb634001864b0e4dda91e009d3361b33fc39f34922835031a423a13619a82 -b703fa855c2c4e1641d2687717fe8c5061acab71cd2dab55cdb069a6865464c3080f7936ddfd320516b6791b36c64b8c -aad1cfa7295e463fc3d5374ea4b952020010d67a77c7a86fe2c351a5959cd50df6a0045ad588257567a99bfd0e9400b3 -97906fb82abf5c1d9be8f72add8e6f175a6a5a4300b40295cb5ec8527cc7ec700fa03a7a494122d9605d212457452e41 -a83366cf93ad9a07f617e4002a10b624270f60083559b045ab5a805aaa592ac37b90c1e8b5437158f3bd942cf33bb633 -a585168e157e111bfa329d0ed6651a96509b20b30f6bb0691c6a5875d134d4a284867ab52511cdc19e360d10638e58a1 -b17d480a0b39f2487b7f3878714658fda82f2147c5ecbccd4004eb92d267c4663b42c93bafb95ce24e2f2f0a9ea14b8f -9362297a1a3951d92db4fd8ea6b48c403d6d8d2f7e7b6310b9cf9b4e4ba9e84cfe1ae025830aab9466c32fd659144474 -b1a62fbadfd4ea4909d8d0714c1e3ee9f95237fde20720f88d5ad25c274a6792158b99966d7b93151f769c832b6a132b -8d9af736949a33fe929548abe72384281365385862821a584f5198eed63bc5388f89fc574cda35a9eaabed0d336b86b6 -90ee2235f4ec2c6089b5cb7b8a41c9bc39e4a57935022ef28bed490e2ab12680922af7395bda4f708809e2bfc62192c9 -91f3a123d420bca34d3d751119bbebc435630c6605fb59a8d80d16a4895972e56cfe4cf1998e0a527c18ee38c2796617 -a2c4fbb20e7fbaae103b86ca9d8dbc2828e6bf33d1d7ce153bd98e8880fe7ac62abbf7059194b1eee64f4526a36c63a9 -91a7f93310ac74f385f11509f4bea9a4d74f2ce91cf2024fee32a4a44d5e636a73339c6b4027ee4d014a24b90de41ecb -914a6d405fee0a15e99704efb93fd240105572335f418d95e1f2de9afeb97f5f4b80aaf20bd5bf150b9da9abc2b6d6a5 -9462cf2c7e57e224389269b9fdddc593b31e1b72ab5389346aa9759fad5d218039a4a5bc496f4bf7982481bc0086292a -b7596132d972e15dc24f2cd0cf55ee4a6cc3f5a0e66dff33021a95e5a742889e811afd1dc0cd465cee6336ad96f25162 -99409bba2548f4ece04751308f815ecee71222869d8548fa142788fb19df5366d093a5131e57560237471bbd5279bbe5 -8e7560988a844b5b844ad460b19c452a5a04346d8c51ca20d3b144a3670ecc60c064b2415c2eeebf140d6ae4ba5c5360 -8cd9e18d311e178e00eb81ca839cfaa8e64e50a197de8461f07135fca28c1d895dd9c2401b923a4175ff711853497317 -91ebf99c95e8f653402b3079ecbd533ed7cd3b6c857a710142354ce8330cebdee7cf0fd0400417883b66055bec9d0552 -a9d0cf8cc6bbdc44426dcb716df667826426b4559056d73738bf3eaa6df373403861b6bbd6fa0454b1d2730e3b0015c4 -928320b452ef21d2443dee360110550f531d7a4275b2cb227814150f3e9e360e05a884d6e3bc4415f202120ea5ac333e -b9551f2b2e7bb984618f2e7467e33b5b5303b8707f503f2e696e49c2990ea760c31e0944d52257c7a38b553a67cf621c -b2ec34126fe61345e5c6361fe55b8fb3218cdcc9103bba5b200252d50b758153cd549226b7aabedd265906401e755190 -a8cf814926082a96a921d471036a9919a58e68d02ee671c215ea304759cd92a7c2c9ccebdd5e9ec5572164ad2abb22ad -8c0563c28c261bbe9a1ec4986f8b277324bf05b4fe5e2b79a862168e646bbea50ce7c4622b2aa7ca899c1a728c226d24 -b558cdc334ea894d3a13347ea9e30f78a0a20621903d6c009c54feceba3ba81d2445a43572e088ae691f65489702e963 -a62ba0b20f46c367cfd409beb300e39f1a6cd5be95e63457b6ad3cb66374aed754fd037b8e4215d651a7d8e1a442f762 -8543e2c6135df471bd7a5c09f1313674c7f6847cb88f15eabf40b2bc9535d0ec606725b97103334a0c162a20d9f5bb53 -8c0367d7058d63b425450f8ee9252e64234c0c2e61878c7c2d4b17bab22a72f40c75ac3bf8b64f264c00d9c5963af041 -acb7207445993d563f1b6e7b179bbd6e87044399f80e6d15980acf7aaccb9d85071fecb22250afb3aba850712fbda240 -b93725e66184bb03f0ab4078c737a7fb2b10294a3a09995958de3dcf5316b476ce9b5cd8d180017196d9482abdfcab88 -afcb52bb7b8f45a945299da6fc6a877ba9f69f7f23d5f94b5f5d9a04c3cf3089333bbd50fc305e3907825003da73b9f6 -961de781cb238cef52d43bc0dc7d8e3a75bca4c27ab37a2e9353137a9aa9403444a5841b595adeca75a3de5485ab97f6 -9408c828d3ed6df40cc167d72ca9882a9c9cf8e765d6f9125e02e0d66ee0ac94f449803afb50bf1b92176feae92473d6 -a85480591e7e033b9087fd0efe5cf3c88c10a75de4a5d7da4443df1cc1fa1aa59b6cde3ce7453fcabe555495e49ef6f7 -a2611bd82344bc5d70d7e6cf3f0d25866b9f709ac4bf6f75d1006da2a11e2cd07a4c0ac71505e5062a04f71db7a3063b -ac466aaa96febb5b810ba350c7a874797ce4bd6c9585f6b9d114d646894a67c9af9526ade4f7ec834d3a69e18ab643af -b73fc98a79fe77cdbc524c76a09cb9f2d5f8b0a5508846bed1ba5ea9ae3bb62120e01d3b8fb544d90ac9ae0c3d4ccefe -aed333c3403adc899a870082f70aadc770c9f880dc057f05a46d7400be9d893354121a0a31e5475898f437bf722eefcf -97f02133c72187178a8c48db26031f0b2c0317a6648d2be5f7450f00c37391cec935bea46b8144ec9fea5327ee959f27 -940b582b41f1d0f09f0c5f51bab471e4eb143e91b1e96dde83e94650421d51f9c9baec10cc802fb83cd63b56d0b907c0 -b1286a55a74a88a75da47671994916be428be1ca3f42783e497d6478eaa6aca69d50a421b210e9ed3283d578b651b8cf -97cd4e87e21c71d11f1df1c0b6518c00e1610661be4b13cdbdbb026d60fc3f4a2b8549326a648b3fdecb7de8f6aa9fb7 -8f36bbcccee986c35328633bf6ee8f70b5dbf42d0f677c0f4e009d2289976e512af6af91a6ddcd87dc0df93bc4ecd02d -9253ad44ad182e67ab574d718733a69c05cd5bcc43e6292ef0519a9430460aa6a233fe26269da7298ea88cf406e733c0 -b616b5ea74db0dcf8f10a2db79df6ec3566c06410f68a933eff150194608c591b2b175908d4b4ccaef1018b0fefc5693 -80a712ba89394381cbb83fedcaae914cc4f21ab024b8da8a7bbad7762a22f82940451427b1a3f5d84c246d5ba0c7ccc7 -a806909a5517a970879143ad789c6cb6256b82553b649f6865cdafbbc050b1f86528241b3cb600e784186e1a672b588f -b6ae801d1f0e4adf3ce57659d7c61f94abd3c8d1635ad28133a79eff0586fc48bdc195615335449e9bfee39e8a955eb2 -b8a000561211844bef72adf3413f3b438a8789fcddf6676402ca6a1c2c63b9deed322030de2ae3a0aeb3cedbb89406c3 -8bc3615b28e33fc24a7c989f8b4f719c914c4c65b35ad3d4cf15e2196e37c62e42ca34e8b1275e0f32589b969bdfc21b -b2f9637f370a79e7591e5056dac004f56b375f33645ae9f5a192cc6b7b6b3d8a1105cc00f10d8bc8ef250ecc2ac63c39 -b51899978b9c5b737999fee1935a5b0944261e7005bea411b5903d2c16ea045a3b0bcd69395b6733752caed43bc4e343 -873c71a01009dddb9885c48658f83aa6320e74bc152e09de8b631c763c2b4e2e8cbac921418a0d9085ff5c53a2b52d39 -96470f48efd7d2ac2daea8753ef097c09c6fc128a54cc7ef758ff07e32c0b0ac7d122f97b53e88a29cc26874dfee5e0d -8dd2decbd3504b7961d65edb8d51b96377f4edd2e0d2cd8a4d98333f373c79a8d7ca8f8408718d0e7b5e48255857c339 -b536ae387bdd0f6e40850c71fcaecb1051b2c8f7bf5cf92c6bda030de72a03e9212d00390c53a72a08e9fb2bff1249c0 -b1566076f59064e3545adef74fd1acadc1bee0ae23543c30caf9e1ad1fc20ebe84ee25004c612525b26857253f5345b7 -afd180e25444cb720342923b8897d38a6537bc33a0ca1fc9c6e4d524b280193618f19e2bcfbd07606b78b734fe6114ed -89b2a6c8811e5a6d07aa74c79dd854bdfc292cc104b525bc37e4c7c1f9485e19d759c8e27cd7cd73c46346f56ce3b189 -8234196e196898b2501b79d0dc016f6df3d5878952cdb8a93735e4ce2ecf77d07924c701e084533a20f0c50a7d1ee376 -adea7ce2efc77711f50138691ef1a2b946aaba08e7e3b21378708dd5a10bae933ed121e71834b43b14e2ea30a7b306e8 -a566d406a35fae703b3d1ea1791d9207116002e5ee008d01e053a1ea4fe5af2feb63605b011ae6a14414028aa054b861 -b83bbb063682386456719179b6f6bbc8cf6f791229600b7d402167737492f99437b45886695b26a28731e952e56f1ee1 -a8f5fffc2c335d3ad5c7593e81f0862351413cc348392afa86d50921dabb929a5a1de20d604666af9e17a13bbc30bc3b -8d5dcdc1335f01847f6ef650ff64b26e7c4cecb934a7bbce11254e8ced9fa9e4fc87eec55248f69bf499180101c63f5a -83fec30b8bc62f9fc28301a03ef18158d6364738f1c42de311bbfba2e62b25d4c9ea9d6097698b24c84fff956a6748b9 -96394fbe0c2d03cdaa56e13326aeb62344238ad3043ee2fb4f18ebf0a6f7f090f410032a2d15bfbeca9449202d59f2a0 -94880f5928fe71a797362a37d05849d23e118742697f75bc87173a777e7b9d4383b8796a8a2bbee27fb781f363301dfe -af229535896ab86fdf6d2ae676a0dbf44f868f6c7f17bd9a65567631c7aa2e29758f41de050ca5311bd1528bcc811532 -8d4fa4968575b483b3ac16345e7f1ea3f81e8dad72c945a48b7b982054fe1030584be2f89b2f53af84d2490cda551b84 -8052aeb115e4d242078c8726d376a13156cc832705243f14adaa3ef3889e1f2fcdfd46e087acab6fa85a74afde5f5eef -a1349c8a22788a1937a837fceecfaada9e93a63e582a09c56b53da52c9db1600254dc85f63f5eadfa30b89b31dcbdb30 -a10178cdb263ff1a5e0cc034b6deaa160d00c3c3fe1fd1ff0c55fdf1ecb83d771070c10930f88832b75fef39a10024ea -938b17e4405934ea5ef29c2187d6787c5ff5d8c9a02665efb453117d462dbc50ef2c202cbc884305cd807a70b5cc177b -84f01f0da6b58c71788616be71fb3c259ceea7f8bd131a5661c5c03d0205feaff6dac2915919347b0559c381477b3d89 -98787f0a2fac2b04bb7aa247ac77236bbe690aae64203e553be328a2c3bffb772e7a0244e585d27558cc64b089a5ee11 -a14501d8b6b3a84b13b9006d521667e8d168f642ebf154c4e90ec8c75d11985fd0c9d86fc2efa6c7077dafecfdf0ab13 -8215dee75eed04de83a3e910129bee8c48ce01cf1317ea477ff35c09a6f9e9771a8b05aa79e6b0f3e71b9874695e7a2a -85763c3072c7400a2c5668ef5cc53e6f4b8dff474146028a8be370ca9d8af9bf9ee10cd7d23d33eb6d6e257dd3af38d6 -91bf62245c5a59d514d39bfb74db7f72ca7160c1c5d5be3844fff37e53e99d451e18a6747c65e33f98f48a55f38962c6 -8c68817c6a6ea348d9aedce99929371c440fbad72718c2d239ffcaebb26ecc8a4e8c38c2819d945fdb7f02ffda70a5e0 -a96ce2745866a22267a49faa7ea00ebf009ea8d0b0ca2c233c62759b9d5514306b5822dd2eee0124c9e28380e2f97aa4 -8b18d5757c73843dcd55f0f0dc894bcd17e0ecf4c9fd901eacd38480844a15b4ce5e9598ccee039f9d93185137630cdb -a5b45c403b6735aaae14389bcee23ca10571f5437f1f5ab0c2b4e573dfd3341c638fff2cc780166af96b118d47ff2299 -ac849a0ccd354dd46bf55ea837d509b4ae3eefcbd5b8eb2582d301fd56c27b89950c6eefdd4e98e608ef4a6b75251311 -89f13ac14bb064e9c6b49a482831ecea6344faec490bd18bb44028b83a0f22e21145861558029bd172ba7c5247c2cba7 -aa57b057a2ac32c101e442c33831630c81b2e061a542e3e1d6897b2b7ca8a7241ef717a548b3f751d60d89be384ba5da -8a43db4e12682b98230364f25c75b49002f5002bd72a1674cf2a9d53197b5ef1b95e48429af98af503b0d5c3e0e017b2 -a10cd7b8e1574d78c4e917cf833d3d845b878e8e8b60312e6a994bd4f391a5e8c38dcd774087b93c9241238f43f80937 -8b61ccb949088286216cd628811df1a362a7f5c333654ce823e63ebd04b069d5b0f627fb6c96d54c7b853de8aab05472 -887b902020ad45f70f2d5bcfa7324fcbe7be09fd2b1bd40f9ae43a89d487986e89867aee0945ea6a0fe8dfd051ffec56 -822fcd260a7876cad31f54987053aab06108de336878b91b7a15d35013d6d4d6de2d4b30397bb6f1d5c1a7b48e9d1ced -80b89ff95d725858b50e84d825ea99fb6a8866f10b91a5d364671ccbb89cb292bada9537c30dbde56b989c8bdc355baa -b53cab156006c3a1766a57dd8013f4563a2e8250995dbeda99c5286a447618e8ac33ebf25704b9245266e009a0712dc5 -b6e2da9c1156e68c15861a05cd572976b21773e60fc5f2f58c93f3e19c73ad6c2ee3239e6cb4654040c8e15df75a505d -8b7e187d473a0bd0b493adcdb91ca07c9310fd915dec46c2c9f36a5144eb7425dd35dfa50feb0e9ef747caed9f199944 -9743ec3917e953e0a420406b53f4daa433adf4ad686207e9f296e7c83d1ffdbf81191b920ba635c85416e580178c16ff -98d1476fd4504a347c5261012298ca69c8593fec91919d37ddfdf84155b6f1c600cd8dbb92b93f3262da16cf40a0b3c6 -94f50d52982a3c81ac47a7b3032dad505b4e556804f8606d63d821f2c1a4830917614630d943642ba375b30409546385 -b5c0eb5f4cf3f719be1a9ad0103349269e8b798dbffe1b5b132370b9de1188a6d71dcbc3635dfdb4b888400f790b6ea4 -b47fb45ec73392598866d27994c2feb0b0f3d7fc54303a2090757a64b6426d183ae41af16794ced349ede98b9b3fd48c -b5f45fd0aee6194dd207e11881694191e7538b830bfe10a9666493ae8b971d65bc72214a4d483de17c2530d24687d666 -a50c149ea189387740d717290064a776e2af277deafcf5f0115bbbdc73c0840d630965a4e0214b738d1cb0d75737e822 -b941afc772043928c62e5dbe5aa563fa29882bff9b5811673f72286ac04fddf9a9ed0f9faf348268fa593a57bc00ba6b -839051a7838937270bdf2f8990fd9aa7d72bfc86cffe0b057aa8eca7393abf16b70d71a6470d877f8ec6771efa5a8f26 -835bc9d049418ab24dd1cbf76ed5811381e2f0b04035f15943327771f574f723b07c2b61a67a6f9ddc1a6a20b01f990d -8935cf5634d6ae7b21c797a7d56675e50f9d50240cb2461056632420f7f466fdcd944a777437dcb3342841ad4c3834bf -b5698fe3da1f9d1e176c9919fddd0d4d7376106774aa23a7a699f631566318d59b74ae8c033eba04d06f8cdcb4edbbed -ad11421ba75d74c600e220f4bce2ca7eacb28e082b993b4368d91218e7b96029acfbdf15a2ab0b8133b7c8027b3c785b -886ef813644599051dafdaa65363795cf34a3009933c469bd66a676fdd47fc0d590c401cc2686d1ba61fce0f693426d4 -8858fdf3e98e36d644257ab6076f7956f2e7eacc8530ec1da7f3e9001036cba7a0855fb5011925cdc95a69600de58b2d -b59eca7085a2f6dfeaa6a414b5216ff0160fbea28c0e2ad4f4ffd3d388e1cc2c23a32dbe517648221b75a92500af85e3 -abec62d259bcd65b31892badad4ac8d2088366d9591cd0dab408a9b70ad517db39c2ef5df52348ba4334dce06a4e3ba5 -a9acfe8f5a310779509621ed2946166ffb6168e68ecf6d5a3b2f6008df1728c8fceb811636c50d2e419b642a848a9ca9 -9929bb1a3537362848fac3f1bcb7cfb503dac0a0b1bebbfd6ddf14c9a73731e2248cbaf0fbb16c7d9c40cc6737c3a555 -981d06c7431e6f4654e32f1c5b27e7be89e7c38d59c4e2a872a0f0934cb852c6aeff2d2eaee8302131795590b8913f5e -a6ba9dd43354320f65fd5cdd5446cfa40080bcf3ef4a083a76ad4e6a609b0b088bcf26c4957bfab829dca6064410ca5f -9367ef28def311c79adfd87e617651fcc41ad8caf047d73ce9a1f327e8871e9b35d5b203fd0c0138e32e2ef91e20ba62 -855d1bb508a9036f42116c8bbb830c576189798baee27c7c3477ef1b1fc5d7b0c2c7203457f1eb48d4b029dd6f646be2 -8539a5d0528d3d601083e162b34cb33b5bf6736b4feeeab4941f10eea127c56b7e0b8d57f34b72f8f674d89c10bf302c -a3b71a9a9ac2dfcd681bfd8f6a5d9abf5df6950821705bdfb19db25f80d9b8a89fac7a922541cc681325679c629743d2 -8e95929dfd4e5b56e5a8882aad6b7e783337e39055a228b36022646a13a853d574603de5fed12b6c1f2585621ead7afd -8b05c885575d6894cb67ba737db5915639a6f281bf249480df444ff9f02724e28ed7371ee7ec26d50d25f3966010f763 -90f1a45de0cc0641181d54ee86630b5d182d24e7c30c2615803f16de90ec7c982a00b21f250ccebc2e94ef53a13e77e6 -90f0e97a132092e51a4521c2ecaaa47e4e4f319e67a3cdbd00ed85c2f10dfb69c339bc9498e2abbffcd54b1fdc509a20 -a9995234520cab9d1bdec1897b0b67571b718d5021c0fcf913140206b50ab515273b5f8a77e88fe96f718c80dd9be048 -aebc6495d54d0e45a3c74388891dbcfab767f574fed0581566415af872dc5b3bd5d808c44f6e1fbdde7aa9ffd260b035 -ae757f8f4b1000a623a7d8e337a50c3681544520683207e09d05e08a6f39384b7aaadf72018e88b401e4a7bb636f6483 -a626a28d5ce144cc0c6a30b90ec2c1412cbbc464ee96ac49035e5b3a37bb3e4ed74e8934c489b4563f2f7db1caf8b2ad -8c994e81dfd7a5c2f9d4425636611d5dd72d0b091a5862f8bec609d0cdd3c423eb95b0c999c48faa5dbb31e510c22b61 -a1c0e59e076b908de760d9becff24883c6eb9f968eac356e719c75cce481f2f7bcb1a41ed983a00c1a3b9369a7ff18f9 -8d7e199044fe2e552bc514668fe8171c3416515f7a5019f239c0384f0ade349e88df26cd30f6b67d02b83bf005d85de8 -80190f2255199be690fb502d02ed159aa568c390a684f7840512efc3d2a62f28a49d5d1928ad99a5f975ad81a245acd5 -889d84cefef33f5714e14d558f41d406072ba66b427bf27918b669c5be46261c3de0139610a2c2eadef8e6508e937bcb -a480a686d5085b854ccf9e261e7f1f2d40d978fc30b62b1a8fa9561127745529405820df21a680ee2258b8cefa5f0201 -ae6243400d416a8c13b80b6637726959ef07b8d9b6aff2bd3bb23aaaf97337c7a6b466c5db617bf2798e01d4ccc68e4d -85e0ff143657e465f3d934ee781de5cbd2bfd24f2fbbe6d65c698cdd93204a845f6ef1fa8941c2578463a06a8a418481 -8f4f8b45f1a9f6c2a711776db70f20149dd6d0e28d125906ba9893c5e74e31c195b0906f04c922c8b556ced7cd3d611d -877b852c33483b25c4cd8da74b6b589d8aa96e217c3c4d813466c77ef83af95a94a47364aa8421f0396ce631ad87d543 -852cb06bc4222ce125287a7a55a79ad0bf55596f26830dd6d79da3c60f80e3ba7b9a9b42b126dcb99d2cb9ce142783ef -810cd64c1dfce85d509eeb57a5c84efafe1d671454ef601a040de8d46fb33bc419577f6a6c404e28ffdfe315ffec558a -b60ff8bc804d101a32079b8ed52285fdbb47fd60c3c15cef17cfe7f6b0567de6b50128b9dbc49a1d9811b62b22c99143 -a9df7068b26a6a58f7a499e67b17d34f2a2e8e5029c6e51e2b4c0d19324fb5cd9734c4c4d5034e1bfc274cd0c74a82d0 -ad93c50802ded1e21217a58b874c074ea52322492d589820691572084d8edaede8c2ce8021c6df8c0060f395f3c25ee8 -a17b98e090f7ef5800477132b436c1fccc1802f34956711bfc176e36890c7df95a108e03f34659142434cbd8aee9dccd -acb14aea5575c293dc0a2b58c5350390801d57e9bcda876d87c56565043ddde1a544a88b48ad0d8ec3d41f690aef801e -88b8e26cbc83faa053fa247e26c95d1bbb77955b336e1b0e41d080633248238de8adc9b98688c98fdfc67e7286bc5be4 -899f69823cf1b2204c8da91bb4f943c04d943137b08b1c46e160919e3378bd22a666a079a66e63d81c05336c742efdd2 -8d7ffbc0b47a32408c9e88676ac4f87683cf37c37d214163ca630aec2d3cc014d88caff35022ff3b6d036eb8343d52a3 -b7760f27db0704a6742855998a0c31333bb34d60ddebc95588e25b72445ae2030427aab088ec023f94563118980f3b74 -ad06ecc0f3745861c266bf93f00b30d41ed89d41e99ab63fedd795c970d3ad40560e57ab7333883a72e5575a059df39c -8687d28b1cbc8aa34a0e5dbdb540a517da9bda36160daaa7801fce99754f5d16eda3bc8e1df6b0722cfb49e177e9bcb6 -a38332c3ebbd7f734c8e6ab23ae9756f47afbf7d1786fe45daebc8d7d005d6d8fd22f5dbd0fa8741e1bfb2014d3f9df7 -b86f84426dee88188be9c5cc10a41599e53b7733ba6f2402392b0ea985effc7525756ca1b7b92041ae323337618b238f -958731a6f1881f652d340832728bc7fadd1acebd8daebd772b5acea634e9f7b7254b76d38a7065ea1b2cdea83b18a54f -adb90bff1f0d7d45b8ba28b536c0e0f7f4dc4b9a0354692ecf29539631d7a57d308db3e438e0f907810234c490b42153 -a5188c775ad76617d3bb6e7f1f3b2449f48b7bb7a84035c316284396529564a227e3b9762a89c7114fa47b3ca7ba418a -a3826ef63c98793a5c8c5d5159e2e00cc85fb5e5124f06421b165de68c9495e93c2f23cd446adf6e6528967aa3ed3909 -80eab97de89f3824ace5565b540b229adcc6ef9d2940e90de185af309234cd8aa4ae9c7ce1b409b3898c8fd10c8c2896 -8824f5acd4c2330c459fdb9ece9313263a8b20419f50f8d49958dc21754c21a77bcf7fbf3e0041f78d8fb667a3342188 -95091cf06911a997a09b643326c2fadbbe302555ab2521db806a762a5f4492636507ca71d7a093840236ac3c096614f7 -a392c81a546196d7e78b61f3ceaadfb2771d09fe43f862c0af65f5e55ce490a0293b9ab754cb5ab03ff642a9a8213a23 -afd76cce1dfa2c9e4af4f840376674f090af37d8c6541824963373f97b9dd1f405c50b2ff56165e1d4dde760e590738a -8fc4f513d3b40c10872603e1c29a4b2cf4c99320962644ce89f69ffb57f844344e1d472b2d43559119bdfb5a2c21749a -9951ca8e13b9a2b4a789e851c04c4f030470772da62f101074ef304612e9653b43b37d2c081b5d0a09196b3a167f5871 -b4f16fc2a113403ab5fc1b6a9afddec77be7406413b70ee126f0e84796168a572940550d61e443e5635591d4b6c46ca9 -8d71452cf39e7345c7298d514b9638a5cbe78af7652f0286d42632c5c6d7953ed284551fb40c77569a7721413cdbf79c -953625b58d52a308cb00ad87c44a3fd936786ada44000d45bb609ea9db6b156a0d0f9475e13ee5e053eaded19a09990a -a0983a3baa278ad5f5de734eb1b65a04f668408994e396fb0b054991ad2e56e27ac522b04fe37c9583b754e344f795b3 -8eaa454257f77a6754b2c1c5ff0036fa5b03e214576fabc657902c737fcbf298b1795b43c5006e18894f951f5f7cd203 -90183fdeae2ce2a295a567fa61b997b1f975d1be7b03d0101728cd707bb2a7111c222588ab22e573518fa1ef03719f54 -8abec7f31f6b897a1d497368a42733a6bd14ffbb8b21d3e49fc4cd3c802da70e8886827c1aea0b18d1b44635f81ec461 -a6d1e6fd24b0878ff264b725662e489451c590b2aadaf357d64210a3701fe763f529826fa6e0555267c1f5ecc2c52c05 -8fe6d2a4ea0d91702cb2a8a1d802f5598f26d892f1a929ff056d2b928821e4b172c1c1c0505aa245813fe67074cf9834 -82a026a408003583036f16268113ca6067ce13e89c6e9af0a760f4b2481851c62fadeeef0d361f51dcd9fa5674ec5750 -a489a574b862d4056091ef630e089c163c16c2f104d95eb79a27ae1e898b26d6c1adc23edc1490f73bb545d3a6e3b348 -939d85148547fc7b9894497841bd4430bc670bb670f0efeac424b529a9aebf2c02ac18a9d1402a12e4e590d623de09f0 -a3ab52cf911a2ba7fb0cd242d7778ec0d4fa382960c9bd5b476bb1cd44ff1430a3871bbbcea0a0db2630c39ee639fd1e -b7629509d8c3a3b88b31f1af137a25c38f536284f11a5bbbe0d05b86a86bc92ebbf70f17c256dc8b0d48374e1985e6f3 -8a8647ff33e0747dd6c6ceddcf7938a542656174a08a31b08337ea49b08d814e75f8363fb51676a2cd2746569e3bc14e -a7a7f8d94d32b7cee00b3ff272d644b8dca86b8da38c726f632c2bcdfa0afb13fd0a9a5685ddaeb6073df4d9cfa3d878 -b7136eea8d05bfee2265b0e9addb4bdf060270894de30d593627891584b9446b363973de334b6105e0495cf8cb98e8f7 -a9fcd33ea59315ad7611a3e87e8d1fd6730c8cbeeaebd254e4d59ed7d92c97670303a2d22e881ab16c58779331837529 -965fd41741a0d898c2f2048945b2aefc49c735228c25deaf17fed82c4d52cf3f8e93b3fb8825ade632dc4940311b1542 -b9f400a2c7ca7da8b36470ee5d26c672b529b98e6582012cbfc2a3c24b72e73f5633de4265c417c0d47c474155a603c6 -85f333b0b1630a688a385f48bf0175cd13ecdd92fa5499494f4ad5aea0ef1b9d180fad8f936018538d842630ff72884c -8da95a735a1a98ed8e563099bd87d13a237dd7ec6880cfac56c6416b001e983a56f3d72dda7f68684bb33e4f64cadd30 -a29b66a2095e1acce751f6aec8dfeae1e5b24187dfedb5d1635ca8deae19b580ef09329a18b3385ebb117cd71671f4dd -b001deeeaf5eaf99ac558c60677b667b9f3d57cf43a2c4d57fd74b125a6da72ea6c9dc81b110655e0df01ca7b8a7a7ed -912e11dfff77c778969836d5029747b494dd81d9f965f8be2c9db9e8b08f53858eface81862c3ee6a9aa10993d0d23f3 -ac166a00e9793cf86753aa002ca274cb6f62328869fe920f5632a69a5d30d8d3ce3f0c5487cb354165763ca41d83495a -b74df519ae1a8faeff2ccd29892886b327c7434360ab5c5355752667069a77d466a48cb57b1950d10b6c47c88b2a8538 -8751679aeffa39da55f2c2a668f7b26fb8258f70c5454b13e2483e3ad452f3ac7cc4fa075783e72b4a121cd69936c176 -ae0cc16848b8bf8fffbb44047d6f1d32b52b19d3551d443a39fb25976a89d1a5d2909a4fc42ee81a98ad09d896bd90a9 -a0c8acd6a2f0d4ab0e0a680fa4a67b076bbbf42b9ec512eb04be05fb2625f6d2ed7b4349eebe61eb9f7bd4f85e9de7fa -85c629ce0deeb75c18a3b1b4e14577b5666cf25453a89d27f1029a2984133a2b8e7766597e2ff9ee26a65649b816b650 -938dbb477840d3ed27f903d09fd9959f6fec443fbc93324bc28300dd29e602bd3861fd29508da0dfdbb0fff7f09c5a6c -a7c76cd4a42ab7904d036fe6637471d9836ad15d0d26a07b1803b7fb8988b8c9edf522e0d337a1852131d0f658565ae7 -838a30260cf341ae0cd7a9df84cbc36354c6bc7b8f50c95d154453c9e8ec5435d5f9b23de2a5d91b55adde3dbdb755b9 -8f870b1f798c0516b679273c583c266c2020b8dea7e68be4b0628b85059d49e5a680709c3d6caabe767a0f03975c4626 -89bad0b6499d671b362ae898fee34ad285aa8c77d33ca1d66e8f85b5d637bbd7ae2145caae7d9f47e94c25e9d16b8c4f -af963d3dd3d983864c54b0ed1429c52b466383f07a1504215bbf998c071a099a3a1deb08d94b54630ac76d1d40cfc3da -b5686de207c3d60d4dcfe6a109c0b2f343ed1eb785941301b827b8c07a8f1311e481a56a4baab88edb3ddc4dace6a66a -95e5978739a3e875e76d927f7c68bdf7ab20966db9fa8859f46a837760dfe529afa9a371a184dfb89d2962c95d5fcf3b -96d2855e20c37ed7bd7f736e11cfba5f61bb78a68303a7ced418c4c29a889a4798c5680be721a46d548d63525637e6b0 -b134bceb776cd5866e911f8e96016704c9a3caeadcabd7c0f37204497d789bc949e41b93e4c2d597e4c924853f1b21e3 -a1949ff397013acde0303e5d64432bf6dd7f01caa03c5fc38e7c8ae705b9d5c2646b4b02d013004e5eb58e344703260c -8036a5f79d8aeb6df4810974cf8dbd0ac778906d2f82b969ac9dcfbe7ece832a7e8aad08a4dc520f7abeb24b1610ae84 -982b6b0af8602a992c389232b525d4239edc3ae6ceea77d7729d1fffc829664dd647ff91c4cb9c7f7c25cea507f03167 -b34c7d24fa56ab6acdb8af5b4fa694a1985a1741cc53a2b0c5833611e8ed6fb3b663a4d9a126bb4a1a469f2072199d66 -8166366fec4ee2b3eda097dc200cdfa0533a742dfbe7082dfa14c1c1ecafc9d9fa71f518476634f29d06430869bd5e02 -86c0251ac00b8200618c8b7ce696d1e88c587f91e38580b2d6ae48a3ef904e0ba1b20b7f432719ca40e7995f2281a696 -afd89f3bc7843a1e45ac961e49c1971114c5238d9e21647804b1852b8f476a89c12d1edfb97fff71445e879d6bfd3b70 -911d8bec4d4c3e73a2c35469b2167569f59705404425bd95440408fb788e122f96e9b1bd695f35c6b090f10135b20cd3 -b3f6350ff7afaa0660f9dddd9559db7f164e89351a743fc695d987c88f89fc29136e3c5eb81963edabf2b6f2057120be -a371229680d1468777862e9c0e864156f9cd7c12ce7313a8de67b7bd34e3d1b6fa45ce891a81f8316f4afcbdecf3b6ca -a6a9a875ef9efe8ba72523e645b5773aa62c4fb41efd23da3fa38105472308b8d293be766342ee0a2f00758825bd3b6a -a840d495a184f4499b944ee08f07193a1e1bb8ab21f8ce7aa51d03bd8643f2bc2616c17b68d3fe7c0fb364136926a166 -b55200ae7d6ebb0b04b748051c5907293184b126cf8a1c2f357e024f1a63220b573e2875df83d9b5e0c6e2ace9300c40 -b1e0870f2e3719f42a48256ee58cc27f613308680f2d3645c0f6db0187042dddcfed0cb545423a1a0b851b3a16146d70 -b43a22ff3f838ad43786dc120b7f89a399ed432c7d3aa4e2062ad4152021b6fa01d41b7698da596d6452570c49a62062 -88b1dc50873564560affaa277b1c9d955aebdcdd4117dab1973306893b0e3f090899210102e7e1eef6f7cdf2f4e0e5db -9223c6246aa320b1b36eb1e28b5f9ccc2977e847850964f9762c7559da9546e508503050e5566ccb67262d570162b7a3 -aeeed21b932752709f43dc0c2c7d27d20263b96a54175dd675677a40a093f02bba80e2e65afe3eb22732a7617bf4ff9d -b47cae580ae84f4e4303db8f684f559382f075ef6e95698b9a629e92b67bf004f64e7cf47e401768fa170c4259efbda1 -849821e1ead81fe2dc49cd59f2bba305578c4ea0e8f4b8ae8fc275a1c4a6192f8819d5b6d7da786c94dfc16aacf3e236 -8c60d9a8baefc72a3d3f9dd2e24cca40fb5ce36b19d075122391d9b371c904a0a15d2196c0f2ac9da3acf188d15b0fe8 -946edfe168bbe5ddb0fa6c2890bb227d8418bfbebe2bafab84909825484f799407b610d8aab6a900c5ff9eb796cdc4bf -ae7bf8ae71de5d7ea644d9541e49da1ec31eca6ff4c3fbec5480d30e07ef2c2046cc0a486af7b3615a6a908846341e99 -b4d31a6f578463c9a5ccde0ea526c95b1981eb79468665395c0e550829abfdfa86689699d57830856e324092a423f231 -93415ad3a732417cca9771b056ed42db7ce50879aca7c6f71883ad297eaf5a37fd4641d44a0b7e28b90c168834141340 -98960617a413a3ba86d8257a7386355a69258943aa71834166bd624ea93b0af06178e86538e237f88fd039eacf7cb04a -881335200a487545e38d5b1ffda3080caf5729e1b980603bcdf9ea652cea7848335b83aeeaa321d3476ae4a8d9073582 -b39e84c14666d51895b7a8341fd8319f9e0a58b2a50fc3d7925cce3037f7c75367b5fb5bf25ff4720c9992cab7b8b9f4 -8ea4bab42ee3f0772d6bd24dff3643d8b61147b46ada374414d8d35c0c340e458e449d31023d96e66decf9c58e30cc34 -a5198f6759a045b6a4ba28e4bc3bb638fad44c5a139064327580e285adf38ea82a7570acebf925e81a39d9025f3a6f2e -80267097e2d27c1b19ecf95d184dcff822d34e03326b9fc139a4f8b75b3f80777bb97a9dd284d9b755f14dd401d63c0e -946f346220bd3b6f733e94b61a1ad0b44e45c356fa6036dde5882d93b5613c98e23b20e91eddc6b3c5acea38085705af -a5f559e110cad99bbcae2d9362434aee7db0f3b6d72311291649dbda3f84c10e9760b66b988db3d30067bf18ae2e5238 -8433b38e5c7b293ef532f8c70cef1ed9be7f31f60d5b532e65df7d2885203be78b7ad78ab3011bc54cd9f64c789bf837 -a5a4c0a9b0e0b6bb912cf6ecd30738b0acc0146d77442449b486c3f32d7e60244f643a5cf9cc6da2de5408d0c5f17691 -a81feb329fb51b72464bddcfcf4e02149d995b548d88c64ba143144ce16b652c9913c8ee948ee837596ec97cc43d8cc9 -88e5a7e93a738d61330425bc21ade88d33d7160d124bf174eb3e12a00283654431036977c4f1a47a1bbbf2ef8449ac89 -ac75ad7c099383069e662bfd3624b92b64b5838246902e167fc31b9411efda89b2c6bbd1d61b9eb7d304faacf438d70b -8583bcd1c7cb9bb4bb6bcff803b0a991912b8403a63c0d997761ff77295ccc357d0292318601a8c61329ab28fed7bb83 -a1f9aa0523f1dff00023a44a6c3a9e4e123be0f6722a1c6682ac3c6047efe9e62f4773daf4767e854e1fcbf8ee7339e2 -85f65ebcf5c7e574174b7c4c4166a9a5368e7986b8c0ef846c2e13b75dea7311a87483503149ebfb3cb839b3ef35c82d -abc55eeb72699031a367b9675a2b91a8434e1f01467660903ced43a0b2a11a85ebdf48f95c13ff67e4e2958065a50ff3 -a4ff77c9b86939a15647499b9412417b984bfb051e5bf27b35392a258a5dac297bbdbcf753a4be6729ffb16be924a2ff -af0d41c15b5172efa801cc85ed101b76844dcd06712d0d21160893235a2dbedd15d187a9b31cf0d0ca6c14de6ab2b707 -92661339199f18e5dd9a210783c1d173a26dfa315bd99a33d6f04bf506c871a2b47745c1909faa209d5e6c5c645124a4 -b35813dafb52df709dfa47982bfb44e1bf704f9f46085b2a0e92511dff90e5597110f614f8915830821fc5ed69ae0083 -934a05aa713fa276a4d47f1a28ef06591e5a9a69293c1651c223174df0af4927fc9cd43d374d89c1b4f7c8dc91abe44b -8f83a0ef05202c0b7170ac96f880135e2256fdf8964dae5aed5dd0f6452a6d8e123321e8c182b3aa6f1f8ab767caa735 -b92db10c21c321cf1349fd34129d7180e5088daf2bbe570de6427299aab68992c011c2e2939a44247396f5427c1d914a -95ce1892d1ce25ef2bc88a23880055a4d829a3b31f3806635fd49bec32cca4e965b129b6dd3e90f7e3a2eb293ffc548d -970cf816ee7501ade36b0b59f87c7e352957f67f1f75bbacd8ed52893f9fc40572c76f49c23db44866af7e34a63cd3f9 -a2fcd08581d3569fff699fd7ed1ede5f98f2b95956ecdf975a29af053d9f4f42600b3616ad6161e958c3ce60139c20a4 -b032688b6cc8a7e63dcb82694f71f087b1ee74c4d5fa27323b1ead3ba21722d7fc49eda765725b5553db5260005049c3 -b0b79e4329f1ad25ef6a603390baf889757cab5af10bfa6953a61f89aaace0442b9ef08e57ba778f1e97bf22f16f0ace -a2e6ac06f8973266cd0df447f82cec16614df65174c756e07f513e2c19aa82c10d8670047860960cfba3c5e4c42768c8 -811e66df0f3721a1ae0293549a0e3cd789f93fb6be2cab8e16015a6d52482af9057b1b75e9456322a5a9e87235e024cd -8744a80b3d9e37da4c50c536007981a4958d7e531cb93916dbf985cdc22f4ff482a5cc4fe50915c049d2de66530f1881 -b20b6e8c7be654c23c8ca440be2c37cf9cc9f4e81feedfd0cd7c56f37eda8f295fe5d415e9bac93d5f0a237edd8bc465 -b33fd84377f31f7819150d464b5eb3ef66e06cb8712665cf0587d61e1b1c121d11cc647f3753bbc18604941c77edbc1f -83acb8a3ec5f477b6d44cd49f9e091bc2bf7c9dfee876cde12075a7db9262314cb66ad2e7557114e0c19373e31c6eff1 -acfe4172327832ee207eb07da9cd37da3b009c776f7a8290529f0249f58da213254baddc7c3074fbaa1d226ba1e52b7c -81911b4dea863424b9d77a981987732382702e0294d8c8e1ec48e89678ecb0e64836b45205a120885fa8f8a3a4b9d4b0 -b11f61b1302579a11077bb2f1f0db371ab943573b261be288dc76172eee8a5102b992a5b526092d160ffd20aac2d4856 -ab491f7f1e002a44944c02537f365e525ebb6d5614bba8e5e8e8bd12064c702a1759571ddbeee592a0ba8b73cfce8810 -89211da3d92aed6b111de001b8b5a9231a1c2d09fb1cd2618ec457b635a6c8590fe119acca42fce76dce791c35b889c7 -a5f076c8f7164bcab8af59021ef97a0afa93d0877e52241c3ff5a9a9f81227a55c119ed6a84d34b196e94ec851ca5ca0 -80d91417d0d6c1adb5a3708165da1d54a83caaff482a4f65abf3fb335cbbc738c74ed19a8c451ca98befdf9b2d8b5f90 -aecba33a67f66401614eec5fa945e763da284edb9dc713bad4ac03972630781a09a3e2a291aac0605a9560c5f3444de5 -8a0aa1320bf5217a049b02ad02a4f892bfd6a3f5b48f472041d12f3aaab8dd197307f144f9de5f9e762c6b4971a121b4 -a4120a569e446fe4129f998e51f09c1cc7b29dc2b353d6f6f05daad1a4ef99acfcbaa4950a58aacf7ee1b3fde0af33d0 -aff71370d58b145758a5f24cf3c0c6667d22a1f950b8137c369fa845a5265cd645b422f24fa95e1cd7db1d68686120b6 -a839f075a8a702809a51fbc94595eab4f269a2e7a027aa1f4fc472e77f586138bf5aa4e5570a560e139eb6cda4cca161 -9484f1caa3e35cda0e3d36e43aff3dd8cf45a5a51fc34aafa3a63ed3543047ba9d6af2a9bc7c201c028499e6b4c41b28 -84ddb374c5c9170903bb3e1054fad071b0a147a9ca2ebe2fdb491ebb2431d53b398872a39cc385f973e38579d8e60158 -acaad8babaeaeb52c5b5a16ae689fa5ae15846f2d1f3596a52371bd8681819603822ee8d32ab8cda1bd5290d601e483f -946b69ca5361b60c3dc31db13669b05e5c0452f3c80e7e185f9667a36f351e9ed83bcb5c6dd2439ecd4490e3a87d260a -99f457221ac40df86f9b4bef0bf8812720b2f7218273a0aab08c4d4d4fb18a0fb0ef6ba9bf7fa53c116cc6f16742e44f -8bc0e812d8b718dbe48ead74a6bc7bac68897d01d097422be04110a25589bacd50d336d2c8b70d0dfde6c1b8bc372dc3 -895d118dae2fb35a4b0de22be0d000ec0f0f317b9494db7c12f10d7db81b6f3eaf6d6f3fdfe952f86ec4143d7469368d -893bf3d7e579e800526bc317438a69590d33759931830daf965cec721baa793ea335e9624a86b84b8fed5effc3e2bbac -a112d30dda88c749ca15d6dc65bcbc7fe838b2d25329d44410a9a96db195c7ce6a6921196a61ba7c9d40efdb101a164d -b88b5340af052fc3b8e1a8cf7532206801e79d878f1fb02b32ac4f8e91b64e0ec9252d808b87c4579de15886a20aaef1 -865f76475bb5da18c6a078c720c7b718e55d310876c98017c30ac31882ae347258b508ec34001918324250241d2df5b7 -b6d8a15913eb1714061d5cacbd0bb05edd83ecdb848a89b864e7411598e9f7814d0c039ebe4735437c8370d2ff183751 -a95fedce8351ae9c24d7fa06ebc5cd4e3aef87afaf04a7150e561a6a7f2347bdcec1e56b82d6e5f597fe7124f6cc503b -8526004ca0c802b073d50b0902ea69975949e7567b2e59ca2cf420bc53d91951d26096f2abb07a2955a51506e86488dd -99ccecaab68b6e5adadb9c848cb577de7e7ff4afc48d3b6b73bc0872730245b8a1c68cebf467074af6756d6226f4f4a7 -b5497d5c0cd79b7e6022e295642e1f2161254379eb78ef45e47f02c84ef5a3f6b6297718e4fac8093bf017287e456917 -b6943f30012b2093c351413c2b1b648afc14a5c4c0c338179d497e908451d2779919fe806181452ed386c1e8f8e8c25c -afdb56ce89bcd3247876c918cad68aad8da65d03c7c73ccbee0c4c39f3ad615aab87ffa0db5b3b63b4cc915d0b66deb7 -a44659d7be2f11d4d4949571d7bf84a6f27f874d3281edc34ef1098d321a4dcad9a42632b39633f8f9d20a39f54a2464 -a3e489b4db5832280dd58c62120262471b6fb4355c2ad307bd17c5c246b3f1e1b00f925930f5f5f6987de234fcbb7d16 -87a4e3a190340ed4949597703083d338e9c17263ba8a39b67100589f0dddbc420d9557f9522c17c71ae04b76876f8db0 -a35a3978e928eaac8c182a0a613c611ae7b4827c5e999f938eed06921c0294befdc21d02e68d035a2fc8d03c82641126 -a6898d90265dcf0fb215629f04b07c7918e022667583efe0bfe02f258b446954876c6ca9e369ffe1bb079e2314ebda32 -922fc52e648b6b2b6768c079c67ab425da72907a46add801715f8a2537280869d7071d527b833aa63ef562ce059a392b -8acbb7c4297196d8d1c131040c34cc7064656a148c2110b19c672abb094b1d084fafe967f7122ba9dd1523a4eaec3b42 -82dbf2cdd581fe3b81b156792228eae2485710e6c21dd5fd14614dc341bb0afbebbc0f32340eda9f094b630afcfc17e8 -907a095dca885da219e4558e9251ec765cf616e995c61546bc010963bf26f2d8adbd9b2ef61f2036e1740a627c20fbed -a7a83f849691d04640137989a2d0c90a7ed42a42b0ad328435d7e1fba557a27a58eec9170ab3d0099ec97da0c950765a -b7d435a801c2a5652cb479027f2c172eafa3df8ca0d896bbb9d49a42c42660fb382a8439bfed09ddf7e0214cb6066761 -8bc6b5e79af5512589f90de8e69bc858277055cf7243f592cc4edd193f03f71d16c9300097ddafb79752c63f135c884c -913264fca800467bee58a429e1f245ef303f5dbeea90f0ce6bb3c7ae6d1bd0f99ea75d3d309634684d2178642c81b5d8 -83ba558f9c23b785a123027c52924a1d7334c853a6165d4f5afd093b0b41951a36860ba0a20fa68f73d7db9df0e3ef38 -875b2df7cb54ecdf7ba31181b9dc7dbe02761ab8ffb61757d42a735c8e20d44bad5b904e76dcec6bb44883fdb9f4ad84 -af3dc5d2dd29565de8f4c700d5f1ab71dadb4351f06e9ee2eb5ee7a9b5da827d0c6726c6dc780748a26aa3b4d10e6c2d -a113ff09296b25f550f6d0d3f37dd4517b14cf6d5517293bd3068aa3aea765a8640fcd4bf0ba96db5c00167267fbd574 -a138c5cca485b9180ef091c9e327982bea203c165cb83564f416c36e813bea1ef1f6345f57c8a591df360541b7b758f5 -85793441e917ed520d41dda6e762269fb9f9702e5ef83cee3e90652d324536bf4233425cd05b54a383609076ab84ea13 -b422ac9de53d329e6321a8544c264d63cffc37965d627d7e180a999c3332644e21fedf10cd2f43cf6ba4fc542db91155 -a85d31d4bfa583a493681e57bfccca677ec5b85870a53de37f7be7833b573f8c8dcf029cea4ae548d83048030d77d56d -ab8a0702a371db496715a4ee8fcb6d430641b0f666d7fe3ef80c09df0bf570293cec1aa1675381c6bbd9ecc1f7cdccf9 -b308ef2b87438d35957191294782e9f5014a3394fadad3e2ccaf6ebf20fd889a36dbb8ddb3634baa8e2e131618aa4e70 -919e972e5b67cd65f377e937d67c27b4dd6fd42cfe394a34a70e8c253a1922f62ff36b9dcc7fbbc29b0960ad6a7fde88 -a0e4d4be28301af38a910971c8391ef3ec822ce35757226a7fd96955cd79afa14accba484ef4e7073e46b4b240a5863f -9422f6d424c1736b4b9bb9762aa62944085e8662c4460319dac4877b1e705aa5cd8b6b3a91268363ec3857c185685f4b -b7cf9f2053119d284a37df4e4489b632594df64e5dc846652ee26b4715e352e6333118b125021481138e4ec3e9f9987b -aea983e81c823472df8652654be8a60a8bf40147d599f87e323397f06bf88c98e9c6db0f28414f6ea4091f3eb0f6a96d -aa20bf03cd8b6ffda09fe0ef693fc0aaa3bb372603e786700e52063a4f7ee742771c41cf5e67e6248f99b7fc73f68dbf -8748a4978198071d7d5ddc08f8c8f0675d895dc19df0889e70bd86d44c469c719b93f6526c7e7e916c7bfeb9a1379aaf -b8fcd863d55dab2f7b1c93844306e00056ba17338ddfa3f02689a0b58b30239beb687b64c79b8420ecea8d0d082d9ffa -abb1a35952dc8a74dd1cdbc8ae7294c6bfd1910edab6f05c879e9ed06c636a949fe0017ec67f8f6f73effcb5817cccae -8bef43422b1c59e354b7f46c08a8eb78e26c4d01c236a4fe781cefb7465293a4444f2bdc68c6a221cd585a2494d9a1d7 -93527258940feff61befa18fcd6626fcff019d34a3ac8c6886599cbef75b15c15d689e8c1bd2177cc93c4c1792dee8d7 -b7f114eea99c8278841180ec8886ad2bab1826554a1657b9eeb17aa815f31b59c3931913ddec40aa9923bc92f8975635 -91a96446158b194a0a6ada2e37c8a45f3017c34034f757245f6f3b98c65d39d084e74d2a9dc271e5918faa53990ec63f -aea4ada0a853753db03f9790e20bab80d106f9b09e950f09aeaba5d869f0173bed673b866a96d6b0dd8123a539caac9a -b8e3e98ff0d3e512441e008a4a6783233045a4639e0c215c81984846b43ff98de99d7925cf717b1ca644f6229b6d16a2 -8987ef81a75213894e11e0310e8ba60fe06e2b264cc61655e5b51bf41cc8c3d6c10696642ea3517770f93be360207621 -8d4eff7335252f74af4a619c78625fd245df640f2086338dbb6c26b059f83fe70f3e81f5b6c12d62c0f784e572d56865 -a56f6389b0bac338f20c615d7d11e16045a76cbea23ced0a9d9067f538421c378200bfd4523b7c96094ab67f47f98d42 -83f5ab0727fd6ce8b3370ce3fac1f3a9c1930ea7ebbd16be61cc26f34aa1291ba4b5f16729d7d4f5924eaa4a1e31a04e -8cc62366874bf8751067a526ea32927584cef41174e2ec5a53079ee557067bc282f372b831cb2547c5e21a2f178c91b4 -b609e141006dc8d8649457efc03f8710d49abb34bc26a33ed4e173e51b85d7acdf18d74aed161b074f679d88f5aa2bf3 -873c7aa784c17b678443320950e494250baff8766db42619b9fc7ec4c3afa4eee290cd1f822b925d5b9e55c9cdd1af2f -859ba787f052d3665481c3dd58159ec8c238d918fb6d2787ebe275ef9acd377cb7aaa03a69820c78247bf51afee3d5bf -8eb1e6d2b0f51a3275b4a8be96957cb2d518b32c815dc0dfd5f75340c7dee73e5edc45db7c7d375c4ffaf8c59767d0c1 -85f3876ff5edbb826a9592e68db3dcc975725bfdda4fcac197758a8b27e4f493e6c531b1342ba0f5a75f965273720345 -8a1272f2678d4ba57e76c8758818965e6849971e8296b60ff85a522feeaaa3d23d3696c040d8bdaf1b380db392e988aa -85002b31ce31be7cc8757141a59a7cf9228b83144993d325b2241f5bfac09a02aca0c336307257f1a978c0bbf79fa4fe -b96bd26a6bbbc705c640285fd561943ef659fca73f25e8bf28cfcd21195752b40359d0edca0adc252d6e1784da267197 -936cfe367b83a798ab495b220f19cfe2e5bde1b879c8a130f84516ac07e3e3addcc791dc0e83a69c3afc225bed008542 -b1302f36190e204efd9b1d720bfaec162fcbba1b30400669dbcdd6e302c8c28f8b58b8bbde10f4512467dd78ed70d5e0 -8291b49f56259c8d6b4fd71525725dd1f35b87858606fc3fe7e048ac48b8a23ba3f0b1907b7c0d0c5ef6fa76cddc23f0 -97aca69d8e88ed8d468d538f863e624f6aed86424c6b7a861e3f45c8bf47c03e7b15d35e01f7add0a4157af171d9360c -b590d896e6b6f2e4dcffebfa67fc087fa518a9c8cb0834a5668cabe44e5c2b6f248f309b9cd74779030e172dba5d9e29 -97e7099bff654bcb37b051a3e8a5a7672d6ab7e93747a97b062fc7ae00c95deef51f5ced2966499217147058e00da4be -83435b739426f1b57f54ebad423939a68ad3d520db8ca5b7e28d1142ebfb4df93f418b180a6c226c0ca28fa0651163a0 -946c9144d982837c4dbc0b59544bdbc9f57e7c9ef0c82a7ad8cfddea78dedc379dbc97af54ba3ac751d844842a2990a4 -90ba1eff9c25adba8c3e6ef5b0d46c13de304632fec0646ee3a7bee69da2bc29e162dd3fb98a37ed1184ae5da359cf0a -b17b7a5c0a48eb9784efb5ff8499230b45efeb801cf68e13fe16d0d308511af5aa60e3b9a5610f96d7c2242ae57d455b -9991245e5617c4ea71575e5b2efe444f09cbbed13b130da08f8e9809d62512e8298a88d41f6aa3dbf3bcbc90654ceb18 -a1190c4cbccf2898a7fe025afd03f8652973a11cef59775fb47d69a6b4dcb9a5a0c554070421a5e10a75e43b63d37b79 -857c0a5f291eb35a76be11543a8c3d798187bd0717e2cdee50d390b66322d0d9529520fd3377136cdc93cfee99b6403f -944d11e5f9a3493c67786df94f129352d892fbdc43e98206b8dbf83cce240f65305e1768b38e5576048a31dca5c18f31 -818f361c5dae709e067a82b81beffbd9674de8df2bc1bfc3a27ddf326260e124e46b1e36697fb8de539b7736db093e9e -b07f5b737735a0d628e7ac2d335080b769bdb3acea38ad121e247a6e4307916ba1d029da5d341f079ea61eeaf7d8554e -a69e338803f3ee0fbbddc7ee481a13f6b64d25d71bae0d76f4b5145b54923cf1616c77ba0fd9ca37a3ae47208f490423 -acaee66b94e226622e28a144f93f6b1b442b9c79d7a8a1740c4d53044d0675a661e7453509b9e716e469fe11ce45ee31 -9402ca799d2e1cce0317ed49453ee0b2669b05e68ff101b89306db215c3941b3786ad3402d00369cb1dee020b56d3142 -849440c539fc0df3c8d06e23e271e6faa50234d5c057b8561e9376415f4396e548351cc677b0abeafe4f51b855a3dc83 -865b99587eb3dbc17e412647673f22b2e89185d1df1ec8ea04515585ad2edfb731be458123118dcd7b41b475026477b9 -9390618833b5adbaf24bd38cf9fc6f25104717f314259bb4da5c7a1f6963ecdc04d07bed391d8cd765c3d53567b2b6b1 -95383e8b1d0a629cec238b5ae2bda236a027f4e3b5f99ceace05f1d5a781ec1e7a43058f44ef0a5aee6b0db5697a0d89 -91739b8946d90db3a5244f7485295cc58143ba0449c9e539df1ba3c166ecf85ff914c9941192963c32d35033ae2f0980 -b5d88848d856d882db5947b9182025f0abf2bc4335b650fa0a48a578e2c87f32cc86d42d3b665ee2eab46d072bf1eccd -91f4c754549f5a53b1902ef84274ce9acf0bfd2e824e62eb127d67e3214ce05fc2430c05ea51e94dc6e8978f5d076bab -91fff8c75f8ad86afe78ec301de05e4ca71421d731419a17c747a9a0bf81129422c9499e4749107b168d1695dc90292f -99fbd7bede9cc1e2974c2a21c70788960c2dbf45a89552da8d73bb1d398b8399590707f2f4ba4b43cb356e703eb01b5e -80a51cd83e3d748c07b9ac82de1a697b09031e3edc7bf585f06cd0ffa8ea319517fcc2b735614b656677b54b4910814e -886b27de1f93311d1a31b6d698aa28b54fbd800decd8e25243d89e352ee38cb252d5648b5134a3e1ed021bae46e9da48 -976e70c94db905f83b4ef72188d840874bf005814c0c772f3832aa65b1f21927403125eea7a07b6d3305b1a781b36ab7 -b4adb9d1c49eb31462583580e3ffa625bea4f8b2a7d4927e4ff925c1759d4b3c1e43283d635b54fb0eabfbe1f4c12992 -b66b466bd48485ebeedd47e749d86cbaa3deffbbee2e69cfaa5e9f3bd28b143d7c1c0255a7a1393a2cc1490b2c485571 -8bded5bc0794513947ddb00ff6b780c5cc63a74e2a0b0284153c346a31c82e1eff07c073939da39e6f87a06c14ff1a80 -aceea8c6f799589f6b7070abf69fec724e6679514e60f1eaf9a52c37e9cebb72abcc833a81d8da1a4f5194c1a7eeff63 -89a9f76d053379687fd221ebcaf02c15c2c241bb673ef5298e32640a115d9e0f2331c3e185572cd65946dd6c5bd42412 -a57b6f1e3fdd92eadc6220760f22d0685a82cada1c7a1bda96d36e48e2852f74f3a83c757dd8857e0aee59e978da4919 -9106cf0891bb39ce87433c5f06a5c97a071d08ad44a7cbcd6918c0729c66bb317fbbee8aa45591cee332ad1234c7257d -96c18cca4a0f0299e0027ff697798085f9f698a7237052c5f191b1dba914e5a015ae356b80c17f0fdd31d08c5a939ebb -a892103c93df126c024825c07d8769bdac5f1d26ea9509ee26530dc594384b2a5095cc34e0b41ab3db0392a29792c9e8 -b7c2dbc95edb6fc25802ea051803b7bea682f87a99f8a9fdcc3091c81d914b9493dfb18a8894c964805298a6c22b07f2 -8e40948927d560a6840d7fb99802989ce72b43693e9dc7ed9dcda4bca7daedf75271cf656bcc22b3f999a550faad8648 -b354de1c6f0603df3ed9036c610281e55b51a48950ee3ce57a00b4692232de7ca57d19722700e15cbe67a91fcec2f786 -adf987b90737b933436d8036c1d3f0c9104f26c540052e22e703964f72739ac1261e4289b8f27dec47281a0f3f51378a -8ed5248e9c836fffa7c924178db593e1aaeb54bcf2e93c1983c1f3899cad538deeb2b836430fddc9b2f283e0797ea11e -907e5410e3bd5d7f55340e2f497bd1ca10bfcb4abed2c66a3cdf94dc40bbd7c43ac98754e0b4b223ea4c61eebf2f27f5 -8e81b441ea0397db28840fb4b3c3bfe6d8e31418816f7bda36f9c1cfe4556daee30c43639d90a2dc9b02a3d65e5f4ab2 -897085c477f5030f9fed06e181b05953a8cd2001d959dd6139738d40f1d673b2c7120b5348f678547acfdc90ffc9fcc6 -b0bf2784c4b3808a04be5a00a0593035ce162b3886e1500247b48365eac8ec3d27c7e5e6372e030c779c75fb79772d0d -af3fe6c75f2a1241ac885d5091ff3882cf01695d957d882e940f0c31f7a5b5e269c1a2bae7336e9a7cda2b1d23c03bd1 -a6d94e065f85736d77080a4f775885ccb0dd5efdbe747e4595280bca0ebe12450257c1beadcbec77566ef57508c5d4df -a5c50fe56b5532bf391da639a2f2b6cbb2634fc6637416fea7c29a522dea024d4adaaa29b6d472b4d2cc3e3b85c72e2a -afc35f5a03b245a6286318ef489db05d397bbd16c17b4e92eeb56509f875246c0176c01804139eb67dc4247c2a36ff9e -99ba14ab5a9612c078f9bbaa0e68fd1d52ecceb2ed19bd9abf8f98dd4ed1f9c4fa6e4d41bcef69be2ff020b291749ca8 -8018cdd3d96f331b4c470a4c3904bed44cadecbeec2544ca10e4352cf4ae1a856cf55f6383d666bf997ad3e16816006e -a9964790c318bb07b8fe61d230dd2161dd3160e186004647a925cfec4c583b4e33530bf5d93d8a14338b090055085b05 -ab89d8401df722101c2785cb3ef833017f58376ee82cedd3e9405b2534f259bb76063434a247652c7615a6de5194de65 -a72c3d320a0d40936dee8edfb36703be633aefbb8f89530df04eb6aebe0305ef4f4b6709436f8036d417272a7e47e22a -b3457661ad62634cc25e2918921a97b0bf5c59ccc7063bc8eb53194783f07659f42f8978c589228af5b12696588d8b2f -926fa35cd3ed4c8ad78af6284b87ae53b2e25a1ff50398034142a2bbed5b989ba3181ff116838931742c0fbcd8b8a56c -ae57fe506626432f27ae4f8791421c2df9efd9aaabe4b840ccf65fc3d0dd2f83e19eb63ae87bfa6898d37b5da869ddb2 -99c0a26ac74211db77918156d7ae9bea6ecf48da3ce9e53829a9ad5ed41321227c94fbd7449ae2e44aae801811552b1b -abdd2635b61cb948e51b762a256cf9d159b9fcb39b2fb11ba2fed1cb53475a03fc6e024a6a824a67a689396119a36a7b -a5ca98b98da8bb8eb07b1e5e3c85a854db42addefacd141771a0c63a8e198421dccc55ef1d94662ca99a7d83b9173fc3 -a821bb5cf1eb3aeae6318c8d554e2ea3137d73bb29d2e4450c9a33f441355ea77bb0e0e0ce7c819abc3ed119110a3a92 -95cdfb19b3f7196c26d60586e2c1efaa93352a712f8c8ef6209f6f318cecd52d7bebdfbfee4be1f5903a1595f73bc985 -aef6e6a400106e217f9888afcef0a1e1299b59017e77dc5453317dec0c32ae96873608bef3f1b504a7e4f45b06edc9c6 -96399ad093299ba26dc09ae85dbec9a1801dea4a338dd5d578bcdcb91246db0059e54098ba8a56cbb24600a40095cf79 -ad8b018ac99857ad4b38bdf6d110bbef64029a4d9f08df85a278c6ddc362a5f64e1f3a919f798ccb2f85a7f4ca1260b4 -b211f3b5dd91941d119c4fe05e2b4c7bb0ce0a8d7ef05932a96e850f549a78cd20cded0b3adb3f9f8b7058889ae2cb4e -ab780dd363671765c9c9ab0f4e7096aacf5894e042b75f40a92df8eb272a6229078cd6eadcc500eead3650860aa82177 -a4d96b16ab3abe77ead9b4477c81957e66a028f95557e390352743da53d1a7ba0c81d928a7ea8bc03b9900135ac36a6a -b4d4e028099bf0f28ac32141cd8de4ee7c3d62d4f519fad6abbb4ba39592750812220a4167d1da4c4f46df965f7cf43d -aa929c5f0bd8cb44a861bfb3d18340a58c61d82afa642447b71b1470a7b99fe3d5796bdd016b121838cb3594f5a92967 -a038e66f0a28aba19d7079643788db3eed8e412fb9ab4c0f6cacf438af4657cc386a7c22ae97ccc8c33f19a572d6431c -89c1ff879faa80428910e00b632d31c0cebb0c67e8f5ded333d41f918032282fb59fbcbe26d3156592f9692213667560 -8d899072c9d30e27065d73c79ce3130a09b6a4a4c7d9c4e4488fda4d52ad72bd5f1fd80f3a8936ef79cf362a60817453 -8ffb84a897df9031f9a8e7af06855180562f7ca796489b51bb7cca8d0ca1d9766a4de197a3eb7e298b1dfb39bc6e9778 -836ebd0b37e7ef4ff7b4fc5af157b75fa07a2244045c3852702eaafa119ca1260c654a872f1b3708b65671a2ece66ad2 -9292dfd6d5bfc95f043f4eb9855c10cbcf90fbd03e7a256c163749b23a307b46a331bdbd202236dca0e8ea29e24906de -8bc37eaa720e293e32b7986061d2ffcbd654d8143e661aabe5602adc832ab535cffbe12a7b571d423675636a74b956e4 -887455f368515340eb6f9b535f16a1cf3e22f0ceda2ead08c5caefccef4087e9f4b5d61c5b110ff3e28e4ab2ad9e97c5 -a6e5ec36e7712056fec00de15b8696952b17891e48ebe2fa90c6f782c7d927b430917b36b4a25b3d8466da3ca2a4985d -895cae36ba786104ec45740c5dc4f2416b2adce6e806815e3994e98d9e1be372eaec50094fbb7089015684874631ab7e -9687444fe6250c246b1711a8f73992f15c3cac801e79c54ffd5e243ad539fdd98727043e4f62d36daf866750de1ba926 -b17f75044c8e9ce311bb421a5427006b6fa1428706d04613bd31328f4549decd133e62f4b1917016e36eb02ea316a0ca -8538a84d2f9079dd272a7383ff03b7674f50b9c220e0399c794a2bcb825d643d0fc8095d972d5186b6f0fe9db0f7084f -af07b37644cc216e7083bac1c4e6095fa898f3417699df172c1f6e55d6c13c11f5279edd4c7714d65360b5e4c3c6731e -87eed8fe7486c0794884c344c07d3964f8fc065aebb0bb3426506ab879b2e0dfaefa5cece213ec16c7b20e6f946c0bd2 -8a4bf42f141d8bc47c9702779d692a72752510ef38e290d36f529f545a2295082a936c8420f59d74b200a8fff55167c4 -a7170e5e00a504a3b37cb19facf399c227497a0b1e9c8a161d541cb553eb8211449c6ac26fe79a7ff7b1c17f33591d74 -a9a2cc7232f07ef9f6d451680648f6b4985ecab5db0125787ac37280e4c07c8210bab254d0b758fd5e8c6bcf2ee2b9ff -8908d82ebfa78a3de5c56e052d9b5d442af67a510e88a76ba89e4919ae1620c5d15655f663810cfc0ee56c256a420737 -a9d47f3d14047ca86c5db9b71f99568768eaa8a6eb327981203fdb594bdb0a8df2a4a307f22dcea19d74801f4648ea89 -a7c287e0e202ebfc5be261c1279af71f7a2096614ee6526cd8b70e38bb5b0b7aca21a17140d0eddea2f2b849c251656a -97807451e61557d122f638c3f736ab4dab603538396dca0fcdf99f434a6e1f9def0521816b819b1c57ecdfa93bd077eb -a8486d60742446396c9d8bc0d4bed868171de4127e9a5a227f24cbf4efbbe5689bbd38f2105498706a6179340b00aed5 -a03b97c2a543dfefa1deb316db9316191ab14e3dd58255ce1027b4e65060d02fb5cb0d6ac1a2bf45bfeac72537b26429 -a7d25060f6861873410c296a4959a058174e9a1681ac41770788191df67fc1391545dab09de06b56cd73a811b676aa1b -96bb9c9aa85d205e085434d44f5021d8bbafc52cd2727b44e2a66094a4e5467b6294d24146b54c0d964c711e74a258d4 -b07b17f11267e577191e920fa5966880f85ff7089ac59d5d550e46f3a5cdadd94f438a547cd1ec66f20a447e421f96c6 -964e33e1571c97088fe7c8ca3430db60a8119f743a47aa0827e6e2fb9bae5ff3bf6cecd17b11dd34628546b6eb938372 -82a0513a05870b96509a559164e6ff26988ea8a2227ac6da9adc96fe793485a9eb6bdcab09afac7be4aef9a5ae358199 -b1185bc679623e7a37a873d90a2a6393fb5ccc86e74ba4ba6f71277df3623cde632feae4414d6429db6b4babde16dee0 -b3d77504b7032b5593a674d3c0cd2efbf56b2b44ed7fe8669f752828045e4e68202a37bf441f674b9c134886d4cee1df -95ab31749ff1f7b3f165ce45af943c6ed1f1071448c37009643a5f0281875695c16c28fc8d8011a71a108a2d8758e57d -b234dee9c56c582084af6546d1853f58e158549b28670b6783b4b5d7d52f00e805e73044a8b8bd44f3d5e10816c57ecc -86da5d2343f652715c1df58a4581e4010cf4cbe27a8c72bb92e322152000d14e44cc36e37ff6a55db890b29096c599b9 -8b7be904c50f36453eff8c6267edcb4086a2f4803777d4414c5c70c45b97541753def16833e691d6b68d9ef19a15cb23 -b1f4e81b2cdb08bd73404a4095255fa5d28bcd1992a5fd7e5d929cfd5f35645793462805a092ec621946aaf5607ef471 -a7f2ca8dacb03825ef537669baff512baf1ea39a1a0333f6af93505f37ed2e4bbd56cb9c3b246810feee7bacdf4c2759 -996d0c6c0530c44c1599ffdf7042c42698e5e9efee4feb92f2674431bbddf8cf26d109f5d54208071079dfa801e01052 -b99647e7d428f3baa450841f10e2dc704ce8125634cc5e7e72a8aa149bf1b6035adce8979a116a97c58c93e5774f72b7 -95960a7f95ad47b4a917920f1a82fbbecd17a4050e443f7f85b325929c1e1f803cf3d812d2cedeab724d11b135dde7a3 -8f9cd1efdf176b80e961c54090e114324616b2764a147a0d7538efe6b0c406ec09fd6f04a011ff40e0fa0b774dd98888 -b99431d2e946ac4be383b38a49b26e92139b17e6e0f0b0dc0481b59f1ff029fb73a0fc7e6fff3e28d7c3678d6479f5a3 -a888887a4241ce156bedf74f5e72bfa2c6d580a438e206932aefc020678d3d0eb7df4c9fe8142a7c27191837f46a6af6 -ab62224ea33b9a66722eb73cfd1434b85b63c121d92e3eebb1dff8b80dd861238acf2003f80f9341bfea6bde0bfcd38c -9115df3026971dd3efe7e33618449ff94e8fd8c165de0b08d4a9593a906bbed67ec3ed925b921752700f9e54cd00b983 -95de78c37e354decd2b80f8f5a817d153309a6a8e2f0c82a9586a32051a9af03e437a1fb03d1b147f0be489ef76b578b -a7b8a6e383de7739063f24772460e36209be9e1d367fe42153ffe1bccb788a699e1c8b27336435cd7bf85d51ba6bfdd6 -937a8af7ed18d1a55bf3bbe21e24363ae2cb4c8f000418047bf696501aaeec41f2ddf952fd80ef3373f61566faa276a9 -ab5e4931771aeb41c10fa1796d6002b06e512620e9d1c1649c282f296853c913f44e06e377a02f57192b8f09937282eb -893d88009754c84ec1c523a381d2a443cb6d3879e98a1965e41759420a088a7582e4d0456067b2f90d9d56af4ea94bba -91b2388a4146ebaaa977fec28ffbfb88ac2a1089a8a258f0451c4152877065f50402a9397ba045b896997208b46f3ebf -8ce0523192e4cc8348cd0c79354a4930137f6f08063de4a940ea66c0b31d5ea315ce9d9c5c2ec4fa6ee79d4df83840dd -b72f75c4ab77aca8df1a1b691b6ef1a3ff1c343dd9ed48212542e447d2ed3af3017c9ad6826991e9ef472348c21b72a4 -af0fa5a960f185326877daf735ad96c6bd8f8f99ab0ab22e0119c22a0939976ece5c6a878c40380497570dc397844dba -adf9f41393e1196e59b39499623da81be9f76df047ae2472ce5a45f83871bb2a0233e00233b52c5c2fa97a6870fbab0a -8d9fc3aecd8b9a9fca8951753eea8b3e6b9eb8819a31cca8c85a9606ce1bd3885edb4d8cdbc6f0c54449c12927285996 -901969c1d6cac2adcdc83818d91b41dc29ef39c3d84a6f68740b262657ec9bd7871e09b0a9b156b39fa62065c61dacb1 -9536a48ccd2c98f2dcbff3d81578bbb8f828bf94d8d846d985f575059cd7fb28dfa138b481d305a07b42fcb92bacfa11 -8d336654833833558e01b7213dc0217d7943544d36d25b46ecc1e31a2992439679205b5b3ab36a8410311109daa5aa00 -95113547163e969240701e7414bf38212140db073f90a65708c5970a6aaf3aba029590a94839618fc3f7dd4f23306734 -a959d77a159b07b0d3d41a107c24a39f7514f8ce24efa046cfcf6ace852a1d948747f59c80eb06277dce1a2ba2ec8ea9 -8d2cb52dd7f5c56ef479c0937b83b8519fa49eb19b13ea2ec67266a7b3d227fb8d0c2454c4618d63da1c8e5d4171ac7b -9941698c5078936d2c402d7db6756cc60c542682977f7e0497906a45df6b8d0ffe540f09a023c9593188ba1b8ce6dfcb -9631d9b7ec0fc2de8051c0a7b68c831ba5271c17644b815e8428e81bad056abb51b9ca2424d41819e09125baf7aaf2d4 -a0f3d27b29a63f9626e1925eec38047c92c9ab3f72504bf1d45700a612682ad4bf4a4de41d2432e27b745b1613ff22f9 -80e3701acfd01fc5b16ecfa0c6c6fd4c50fe60643c77de513f0ad7a1a2201e49479aa59056fd6c331e44292f820a6a2c -a758c81743ab68b8895db3d75030c5dd4b2ccc9f4a26e69eb54635378a2abfc21cba6ca431afb3f00be66cffba6ab616 -a397acb2e119d667f1ab5f13796fd611e1813f98f554112c4c478956c6a0ebaceef3afae7ee71f279277df19e8e4543a -a95df7d52b535044a7c3cf3b95a03bafd4466bdb905f9b5f5290a6e5c2ac0f0e295136da2625df6161ab49abcdacb40f -8639fc0c48211135909d9e999459568dbdbbc7439933bab43d503e07e796a1f008930e8a8450e8346ab110ec558bcbb9 -a837bcc0524614af9e7b677532fabfb48a50d8bec662578ba22f72462caabda93c35750eed6d77b936636bf165c6f14e -97d51535c469c867666e0e0d9ed8c2472aa27916370e6c3de7d6b2351a022e2a5330de6d23c112880b0dc5a4e90f2438 -aadb093c06bd86bd450e3eb5aa20f542d450f9f62b4510e196f2659f2e3667b0fe026517c33e268af75a9c1b2bc45619 -860cef2e0310d1a49a9dd6bc18d1ca3841ed1121d96a4f51008799b6e99eb65f48838cd1e0c134f7358a3346332f3c73 -b11c4f9e7ef56db46636474a91d6416bcb4954e34b93abf509f8c3f790b98f04bd0853104ec4a1ff5401a66f27475fce -87cb52e90a96c5ee581dc8ab241e2fd5df976fe57cc08d9ffda3925a04398e7cffaf5a74c90a7319927f27c8a1f3cef5 -b03831449f658a418a27fd91da32024fdf2b904baf1ba3b17bbf9400eaddc16c3d09ad62cc18a92b780c10b0543c9013 -94e228af11cb38532e7256fa4a293a39ffa8f3920ed1c5ad6f39ce532e789bb262b354273af062add4ca04841f99d3aa -99eb3aeb61ec15f3719145cf80501f1336f357cc79fca6981ea14320faed1d04ebe0dbce91d710d25c4e4dc5b6461ebf -920a3c4b0d0fbe379a675e8938047ea3ec8d47b94430399b69dd4f46315ee44bd62089c9a25e7fa5a13a989612fe3d09 -b6414a9a9650100a4c0960c129fa67e765fe42489e50868dd94e315e68d5471e11bfbc86faffb90670e0bec6f4542869 -94b85e0b06580a85d45e57dae1cfd9d967d35bdfcd84169ef48b333c9321f2902278c2594c2e51fecd8dbcd221951e29 -b2c0a0dd75e04a85def2a886ee1fda51f530e33b56f3c2cf61d1605d40217aa549eef3361d05975d565519c6079cc2ac -abb0ea261116c3f395360d5ac731a7514a3c290f29346dc82bacb024d5455d61c442fefe99cc94dddcae47e30c0e031f -a32d95ae590baa7956497eddf4c56bff5dfdc08c5817168196c794516610fcc4dbcd82cf9061716d880e151b455b01e0 -8bd589fb6e3041f3ef9b8c50d29aed1a39e90719681f61b75a27489256a73c78c50c09dd9d994c83f0e75dfe40b4de84 -82d01cdaf949d2c7f4db7bfadbf47e80ff9d9374c91512b5a77762488308e013689416c684528a1b16423c6b48406baf -b23e20deb7e1bbbc328cbe6e11874d6bdbb675704a55af1039b630a2866b53d4b48419db834a89b31ebed2cfc41278dd -a371559d29262abd4b13df5a6a5c23adab5a483f9a33a8d043163fcb659263322ee94f872f55b67447b0a488f88672d6 -85b33ddf4a6472cacc0ed9b5ec75ed54b3157e73a2d88986c9afa8cb542e662a74797a9a4fec9111c67e5a81c54c82b3 -af1248bc47a6426c69011694f369dc0ec445f1810b3914a2ff7b830b69c7e4eaa4bafec8b10ed00b5372b0c78655a59b -94b261ed52d5637fd4c81187000bd0e5c5398ce25797b91c61b30d7b18d614ab9a2ca83d66a51faf4c3f98714e5b0ea5 -953d4571c1b83279f6c5958727aaf9285d8b8cbdbfbaff51527b4a8cfdd73d3439ba862cdb0e2356e74987ff66d2c4d9 -b765dae55d0651aca3b3eaef4ca477f0b0fda8d25c89dccd53a5573dd0c4be7faaadaa4e90029cdd7c09a76d4ce51b91 -b6d7b7c41556c85c3894d0d350510b512a0e22089d3d1dd240ad14c2c2b0ce1f003388100f3154ad80ec50892a033294 -a64561dc4b42289c2edf121f934bc6a6e283d7dce128a703f9a9555e0df7dda2825525dbd3679cd6ba7716de230a3142 -a46c574721e8be4a3b10d41c71057270cca42eec94ca2268ee4ab5426c7ce894efa9fa525623252a6a1b97bcf855a0a5 -a66d37f1999c9c6e071d2a961074c3d9fdcf9c94bf3e6c6ed82693095538dd445f45496e4c83b5333b9c8e0e64233adc -ab13814b227a0043e7d1ff6365360e292aca65d39602d8e0a574d22d25d99ccb94417c9b73095632ff302e3d9a09d067 -b2c445b69cff70d913143b722440d2564a05558d418c8ef847483b5196d7e581c094bae1dbb91c4499501cfa2c027759 -87cbde089962d5f093324b71e2976edbe6ad54fb8834dd6e73da9585b8935fca1c597b4d525949699fdfa79686721616 -a2c7e60966acb09c56cf9ad5bdcc820dcabf21ef7784970d10353048cf3b7df7790a40395561d1064e03109eaac0df98 -8ea7b8af208678178553946b2ee9e68c0e751b34f3652409a5e66c40d3aee3a40ba6ffe2175ce16c6a81b78ecc597d02 -960234239e1e3ea262e53d256ad41b2fe73f506b3d130732d0ee48819eb8a9c85bb5106a304874d8625afae682c34015 -858459694c4e8fdafa6cdaee1184e1305ca6e102222b99b8e283dd9bb3ebf80e55d6c4d8831a072b813c8eceb8124d95 -a30a8ce0f44aeb5590dc618c81c7cac441470ce79fd7881a8f2ea4ca5f9d848ebde762fcaee985cbd3d5990367403351 -a83867643672248b07d3705813b56489453e7bc546cdba570468152d9a1bd04f0656034e7d03736ea156fc97c88dc37f -a7bb52e0fc58b940dc47ea4d0a583012ee41fad285aba1a60a6c54fa32cfe819146888c5d63222c93f90de15745efb2b -8627bcc853bdeaad37f1d0f7d6b30ada9b481ccdf79b618803673de8a142e8a4ce3e7e16caed1170a7332119bcdc10a9 -8903d9dc3716b59e8e99e469bd9fde6f4bca857ce24f3a23db817012f1ea415c2b4656c7aeca31d810582bb3e1c08cc6 -875169863a325b16f892ad8a7385be94d35e398408138bd0a8468923c05123d53dba4ce0e572ea48fcdadd9bd9faa47a -b255b98d46d6cc44235e6ce794cc0c1d3bd074c51d58436a7796ce6dc0ae69f4edaa3771b35d3b8a2a9acd2f6736fab3 -9740c4d0ee40e79715a70890efda3455633ce3a715cbfc26a53e314ebbe61937b0346b4859df5b72eb20bcba96983870 -a44ce22ab5ddc23953b02ec187a0f419db134522306a9078e1e13d5bf45d536450d48016a5e1885a346997003d024db0 -90af81c08afdccd83a33f21d0dc0305898347f8bd77cc29385b9de9d2408434857044aec3b74cb72585338c122e83bb4 -80e162a7656c9ae38efa91ae93e5bd6cb903f921f9f50874694b9a9e0e2d2595411963d0e3f0c2d536b86f83b6e4d6ef -8b49fa6babe47291f9d290df35e94e83be1946784b9c7867efd8bc97a12be453013939667164b24aeb53d8950288a442 -a1df6435d718915df3da6dda61da1532a86e196dc7632703508679630f5f14d4cb44ce89eff489d7ff3fe599cc193940 -afd44c143dbb94c71acc2a309c9c88b8847ef45d98479fccce9920db9b268e8e36f8db9f02ff4ee3cff01e548f719627 -b2cf33d65d205e944b691292c2d9b0b124c9de546076dd80630742989f1ffd07102813c64d69ba2a902a928a08bce801 -b9f295e9f9eca432b2d5c77d6316186027caca40a6d6713f41356497a507b6e8716fb471faf973aaa4e856983183c269 -b3bd50c4b034473edce4b9be1171376a522899cb0c1a1ae7dc22dd2b52d20537cf4129797235084648ac4a3afc1fa854 -8ef37683d7ca37c950ba4df72564888bedaf681931d942d0ea88ead5cc90f4cbef07985a3c55686a225f76f7d90e137d -82107855b330bc9d644129cebecf2efbfab90f81792c3928279f110250e727ce12790fd5117501c895057fa76a484fc0 -816a5474c3b545fb0b58d3118cc3088a6d83aad790dbf93025ad8b94a2659cceba4fa6a6b994cb66603cc9aef683a5e3 -8f633f9b31f3bb9b0b01ea1a8830f897ecd79c28f257a6417af6a5f64e6c78b66c586cf8d26586830bd007fb6279cd35 -acb69d55a732b51693d4b11f7d14d21258d3a3af0936385a7ce61e9d7028a8fe0dd902bda09b33fb728bc8a1bc542035 -8d099582ac1f46768c17bf5a39c13015cfe145958d7fc6ddfd2876ad3b1a55a383fbe940e797db2b2b3dc8a232f545dc -97a4dd488b70bf772348ececaca4cf87bc2875d3846f29fe6ef01190c5b030219b9e4f8137d49ea0cc50ca418024c488 -b4d81148f93fa8ec0656bbfb5f9d96bbf5879fa533004a960faac9fd9f0fe541481935fdf1f9b5dd08dff38469ef81c5 -8e9b2ae4fc57b817f9465610a77966caaff013229018f6c90fa695bd734cb713b78a345b2e9254b1aff87df58c1cd512 -99eb7126e347c636e9a906e6bfdc7c8ca0c1d08580c08e6609889a5d515848c7ca0f32ab3a90c0e346f976a7883611f7 -8ca87944aa3e398492b268bda0d97917f598bc0b28584aa629dfec1c3f5729d2874db422727d82219880577267641baa -88ab0e290dc9a6878d6b4e98891ff6bfc090e8f621d966493fcbe1336cc6848fcbb958d15abcfa77091d337da4e70e74 -8956a2e1dc3ec5eb21f4f93a5e8f0600a06e409bb5ec54e062a1290dff9ce339b53fbbfc4d42b4eed21accea07b724d6 -8d22220da9dc477af2bddb85c7073c742c4d43b7afee4761eba9346cadbcd522106ed8294281a7ef2e69883c28da0685 -90dafd9a96db7e1d6bde424245305c94251d5d07e682198ae129cd77bd2907a86d34722cbde06683cc2ca67cebe54033 -b5202e62cf8ea8e145b12394bd52fd09bda9145a5f78285b52fda4628c4e2ccfc2c208ecde4951bd0a59ac03fa8bc202 -8959856793ba4acf680fb36438c9722da74d835a9fe25a08cf9e32d7800c890a8299c7d350141d2e6b9feceb2ebb636f -ab0aa23c1cd2d095825a3456861871d298043b615ae03fcd9283f388f0deef3cc76899e7fde15899e3edf362b4b4657f -9603b333cc48fe39bea8d9824cfee6ac6c4e21668c162c196ecd1ff08ef4052ace96a785c36b8f7906fdcb6bc8802ddd -93bfecbc3c7cc03c563240e109850a74948f9fa078eb903b322368cda0b50888663a17953579578ba060b14dbf053024 -b01f843b808cf7939a474de155a45462e159eb5044f00c6d77e0f7ec812720a3153209e971a971ccbf5ebee76ec4074f -b009e0567c3c75ed767247d06fa39049a4d95df3392d35a9808cb114accf934e78f765cd18a2290efef016f1918c7aeb -ad35631df8331da3a12f059813dfa343d831225a392f9c7e641c7d23a6c1ad8df8e021201c9f6afb27c1575948d6bf68 -a89c2a631d84128471c8ef3d24b6c35c97b4b9b5dad905c1a092fb9396ae0370e215a82308e13e90e7bb6ebcc455eb2a -b59c7f5fbfeb02f8f69e6cedef7ff104982551f842c890a14834f5e834b32de1148cf4b414a11809d53dd3f002b15d6a -aa6f267305b55fede2f3547bc751ba844ce189d0b4852022712b0aee474de54a257d4abcd95efe7854e33a912c774eba -afddd668f30cce70904577f49071432c49386ec27389f30a8223b5273b37e6de9db243aceb461a7dc8f1f231517463a9 -b902a09da9157b3efa1d98f644371904397019d0c84915880628a646a3ad464a9d130fdc651315098179e11da643ad2e -b05f31957364b016c6f299ae4c62eede54cab8ea3871d49534828c8bdc6adbc6a04a708df268f50107d81d1384d983ae -b4c3f7284802e614ddf1f51640f29e7139aae891467d5f62778310372071793e56fbd770837b97d501191edd0da06572 -b4eddb7c3775fb14fac7f63bb73b3cde0efa2f9a3b70e6a65d200765f6c4b466d3d76fcd4d329baee88e2aba183b8e69 -a83e7dbae5a279f0cfd1c94e9849c58a3d4cecc6d6d44bb9b17508576ca347fca52c2c81371d946b11a09d4ed76ec846 -8018ea17e2381c0233867670f9e04c8a47ace1207fdcf72dce61b6c280ba42d0a65f4b4e0b1070cc19c7bb00734974d9 -af90b541dfed22e181ff3ef4cf11f5e385fd215c1e99d988e4d247bc9dcee9f04f2182b961797c0bcc5f2aaa05c901a9 -a37046e44cf35944e8b66df80c985b8a1aa7004a2fd0b81ac251638977d2ff1465f23f93ac0ce56296f88fdc591bbdd7 -a735bd94d3be9d41fcd764ec0d8d7e732c9fc5038463f7728fd9d59321277e2c73a45990223bd571dab831545d46e7aa -94b32dcb86f5d7e83d70a5b48fe42c50f419be2f848f2d3d32ee78bf4181ab18077a7666eedb08607eece4de90f51a46 -a7f0804cafbf513293485afc1b53117f0cbfaea10919e96d9e4eb06f0c96535e87065d93f3def1bbc42044dbb00eb523 -aaaad1166d7f19f08583dd713275a71a856ab89312f84ca8078957664924bb31994b5c9a1210d0c41b085be4058ed52e -a1757aac9f64f953e68e680985a8d97c5aac8688b7d90f4db860166dd3d6119e8fca7d700a9530a2b9ba3932c5e74e33 -98cada5db4a1430c272bfc1065fb685872e664ed200d84060ee9f797d0a00864f23943e0fb84ba122a961996a73dfb14 -a5e609f716dc7729d1247f40f9368a2e4a15067e1dd6a231fece85eeefb7e7d4a5ac8918fb376debd79d95088750b2ca -b5365eb8caab8b1118619a626ff18ce6b2e717763f04f6fa8158cdca530c5779204efa440d088083f1a3685454aa0555 -a6e01b8da5f008b3d09e51a5375d3c87c1da82dff337a212223e4d0cdb2d02576d59f4eef0652d6b5f2fc806d8c8149c -ae310f613d81477d413d19084f117248ad756572c22a85b9e4c86b432e6c602c4a6db5edf2976e11f7353743d679e82a -a1f219c0b8e8bb8a9df2c6c030acbb9bbfa17ba3db0366f547da925a6abb74e1d7eb852bd5a34bae6ac61d033c37e9dc -a2087fa121c0cdd5ea495e911b4bc0e29f1d5c725aadfb497d84434d2291c350cdaa3dc8c85285f65a7d91b163789b7a -929c63c266da73d726435fa89d47041cfe39d4efa0edce7fc6eca43638740fbc82532fd44d24c7e7dd3a208536025027 -91c1051dcc5f52ad89720a368dddd2621f470e184e746f5985908ba34e1d3e8078a32e47ab7132be780bea5277afecb0 -ae089b90ba99894d5a21016b1ea0b72a6e303d87e59fb0223f12e4bb92262e4d7e64bfdbdb71055d23344bc76e7794b2 -8b69aa29a6970f9e66243494223bad07ac8f7a12845f60c19b1963e55a337171a67bdc27622153016fce9828473a3056 -95ca6b08680f951f6f05fd0d180d5805d25caf7e5bda21c218c1344e661d0c723a4dfc2493642be153793c1b3b2caaa4 -a4789dc0f2a07c794dab7708510d3c893d82ddbd1d7e7e4bbbeca7684d9e6f4520fb019b923a06c7efab0735f94aa471 -93c4f57a3cf75085f5656b08040f4cd49c40f1aab6384a1def4c5c48a9fe4c03514f8e61aabe2cfa399ff1ccac06f869 -b6c37f92c76a96b852cd41445aa46a9c371836dd40176cc92d06666f767695d2284a2780fdfd5efc34cf6b18bcfb5430 -9113e4575e4b363479daa7203be662c13d7de2debcda1c142137228aeead2c1c9bc2d06d93a226302fa63cc75b7353ec -b70addeb5b842ac78c70272137f6a1cef6b1d3a551d3dd906d9a0e023c8f49f9b6a13029010f3309d0b4c8623a329faf -b976a5132b7eb42d5b759c2d06f87927ef66ecd6c94b1a08e4c9e02a4ce7feca3ac91f9479daa1f18da3d4a168c2ba77 -8fdab795af64b16a7ddf3fad11ab7a85d10f4057cf7716784184960013baa54e7ba2050b0e036dc978ff8c9a25dc5832 -b2c982ad13be67d5cdc1b8fac555d4d1ec5d25f84e58b0553a9836f8f9e1c37582d69ad52c086a880a08b4efcccd552e -810661d9075ae6942735215f2ab46d60763412e1f6334e4e00564b6e5f479fc48cf37225512abbccf249c0ca225fc935 -a0c4bf00a20f19feff4004004f08231b4c6c86ac4ed57921eea28d7dea32034f3f4ab5b7ded7184f6c7ffbf5847232ad -b2bb5a9eea80bf067f3686a488529d9c2abd63fc9e1d4d921b1247ef86d40cd99e0a8b74f750e85c962af84e84e163a6 -887ee493c96d50f619ba190ce23acddc5f31913e7a8f1895e6339d03794ecefd29da5f177d1d25bc8df8337ae963fc7b -b7966fb07029d040f2228efa2cfcd04341e4666c4cf0b653e6e5708631aa2dd0e8c2ac1a62b50c5a1219a2737b82f4f7 -92234cfd6b07f210b82db868f585953aafbcbc9b07b02ded73ff57295104c6f44a16e2775ca7d7d8ee79babb20160626 -8d3cd7f09c6fd1072bc326ff329e19d856e552ac2a9f20274bc9752527cd3274142aa2e32b65f285fb84bc3adaaea3cc -8caed1cb90d8cd61e7f66edc132672172f4fa315e594273bb0a7f58a75c30647ec7d52eda0394c86e6477fbc352f4fe8 -ae192194b09e9e17f35d8537f947b56f905766c31224e41c632c11cd73764d22496827859c72f4c1ab5fd73e26175a5d -8b7be56aac76d053969e46882d80a254e89f55c5ab434883cbafc634a2c882375898074a57bc24be3c7b2c56401a7842 -98bc4a7a9b05ba19f6b85f3ee82b08bed0640fd7d24d4542eb7a7f7fde443e880bdb6f5499bd8cb64e1ddd7c5f529b19 -a5a41eaa5e9c1d52b00d64ab72bc9def6b9d41972d80703e9bfe080199d4e476e8833a51079c6b0155b78c3ab195a2a7 -a0823f6f66465fd9be3769c164183f8470c74e56af617f8afd99b742909d1a51f2e0f96a84397597afbd8eeaabb51996 -801da41d47207bdd280cc4c4c9753a0f0e9d655e09e0be5f89aeed4ce875a904f3da952464399bf8efc2398940d5fba2 -a719314085fd8c9beac4706c24875833d59a9a59b55bca5da339037c0a5fc03df46dbecb2b4efcfed67830942e3c4ea1 -a75dde0a56070bb7e9237b144ea79f578d413a1cbbd1821cee04f14f533638b24f46d88a7001e92831843b37ed7a709f -a6b4ef8847a4b980146e1849e1d8ab38695635e0394ca074589f900ce41fa1bb255938dc5f37027523bac6a291779bef -b26d84dfd0b7bd60bcfdbea667350462a93dca8ff5a53d6fc226214dcb765fada0f39e446a1a87f18e4e4f4a7133155f -ae7bd66cc0b72f14ac631ff329a5ca4958a80ba7597d6da049b4eb16ac3decde919ca5f6f9083e6e541b303fb336dc2f -a69306e6bfbbc10de0621cffb13c586e2fcfd1a80935e07c746c95651289aec99066126a6c33cb8eb93e87d843fc631f -a47e4815585865218d73c68ba47139568ea7ae23bfa863cb914a68454242dd79beaec760616b48eea74ceab6df2298dd -b2da3cfb07d0721cd226c9513e5f3ace98ed2bc0b198f6626b8d8582268e441fa839f5834f650e2db797655ca2afa013 -b615d0819554f1a301a704d3fc4742bd259d04ad75d50bccee3a949b6226655f7d623301703506253cca464208a56232 -85e06ed5797207f0e7ae85909e31776eb9dae8af2ec39cc7f6a42843d94ea1de8be2a3cdadfcbe779da59394d4ffeb45 -8c3529475b5fdbc636ee21d763f5ec11b8cb040a592116fb609f8e89ca9f032b4fa158dd6e9ceab9aceb28e067419544 -accddb9c341f32be82b6fa2ef258802c9ae77cd8085c16ec6a5a83db4ab88255231b73a0e100c75b7369a330bfc82e78 -93b8e4c6e7480948fa17444b59545a5b28538b8484a75ad6bc6044a1d2dbd76e7c44970757ca53188d951dc7347d6a37 -90111721d68b29209f4dc4cfb2f75ab31d15c55701922e50a5d786fb01707ab53fcec08567cd366362c898df2d6e0e93 -b60a349767df04bd15881c60be2e5cc5864d00075150d0be3ef8f6b778715bebca8be3be2aa9dbdc49f1a485aeb76cda -b8d5a967fdd3a9bcf89a774077db39ef72ca9316242f3e5f2a350202102d494b2952e4c22badecd56b72ba1eea25e64b -8499ebd860f31f44167183b29574447b37a7ee11efcc9e086d56e107b826b64646b1454f40f748ccac93883918c89a91 -99c35e529782db30f7ccab7f31c225858cf2393571690b229ece838ec421a628f678854a1ddbd83fa57103ccebd92c7f -99817660d8b00cbe03ec363bcdc5a77885586c9e8da9e01a862aca0fc69bf900c09b4e929171bc6681681eae10450541 -8055e130964c3c2ebd980d3dc327a40a416bcdbf29f480480a89a087677a1fb51c823b57392c1db72f4093597100b8d3 -877eaddef845215f8e6f9ed24060c87e3ab6b1b8fbb8037d1a57e6a1e8ed34d00e64abb98d4bf75edb5c9788cbdccbef -b5432bbff60aeae47f2438b68b123196dfb4a65cc875b8e080501a4a44f834b739e121bec58d39ac36f908881e4aa8ab -b3c3f859b7d03ff269228c0f9a023b12e1231c73aba71ad1e6d86700b92adc28dfa3757c052bbc0ba2a1d11b7fda4643 -ab8a29f7519a465f394ef4a5b3d4924d5419ca1489e4c89455b66a63ac430c8c9d121d9d2e2ed8aa1964e02cd4ebac8c -866ae1f5c2a6e159f2e9106221402d84c059f40d166fab355d970773189241cd5ee996540d7c6fc4faf6f7bcff967dce -973a63939e8f1142a82b95e699853c1e78d6e05536782b9bb178c799b884f1bc60177163a79a9d200b5ff4628beeb9e7 -a5fc84798d3e2d7632e91673e89e968f5a67b7c8bb557ea467650d6e05e7fe370e18d9f2bdd44c244978295cf312dc27 -b328fe036bcd0645b0e6a15e79d1dd8a4e2eda128401a4e0a213d9f92d07c88201416fc76193bb5b1fe4cb4203bab194 -99239606b3725695a570ae9b6fb0fb0a34ad2f468460031cfa87aa09a0d555ff606ff204be42c1596c4b3b9e124b8bd6 -af3432337ca9d6cce3574e23e5b7e4aa8eda11d306dc612918e970cc7e5c756836605a3391f090a630bac0e2c6c42e61 -8a545b3cb962ce5f494f2de3301de99286c4d551eaa93a9a1d6fef86647321834c95bf754c62ec6c77116a21494f380d -8f9b8ea4c25469c93556f1d91be583a5f0531ac828449b793ba03c0a841c9c73f251f49dd05cbb415f5d26e6f6802c99 -a87199e33628eeffd3aff114e81f53dd54fba61ba9a9a4d7efdbff64503f25bc418969ab76ef1cf9016dd344d556bb29 -a2fda05a566480602274d7ffcaefdd9e94171286e307581142974f57e1db1fa21c30be9e3c1ac4c9f2b167f92e7c7768 -a6235d6a23304b5c797efb2b476ed02cb0f93b6021a719ae5389eb1e1d032944ae4d69aec2f29fcd6cbc71a6d789a3ba -a7f4a73215f7e99e2182c6157dd0f22e71b288e696a8cff2450689a3998f540cfb82f16b143e90add01b386cb60d8a33 -922d8f9cd55423f5f6a60d26de2f8a396ac4070a6e2dc956e50c2a911906aa364d4718aea29c5b61c12603534e331e7e -96d7fdf5465f028fc28f21fbfe14c2db2061197baf26849e6a0989a4ea7d5e09ab49a15ba43a5377b9354d01e30ce860 -8f94c4255a0fc1bd0fa60e8178c17f2a8e927cac7941c5547d2f8f539e7c6ed0653cab07e9fb1f2c56cdd03bb876512a -95984c10a2917bfa6647ebce69bf5252d9e72d9d15921f79b2c6d7c15ee61342b4fb8a6d34838e07132b904f024ded04 -93e65e765a574277d3a4d1d08ca2f2ff46e9921a7806ca8ca3d8055f22d6507744a649db7c78117d9168a1cbdb3bbc61 -8d453b7364662dc6f36faf099aa7cbbe61151d79da7e432deba7c3ed8775cfe51eaf1ba7789779713829dde6828e189a -acffa3ee6c75160286090162df0a32a123afb1f9b21e17fd8b808c2c4d51a4270cab18fba06c91ef9d22e98a8dc26cdd -a5597cc458186efa1b3545a3926f6ecaaa6664784190e50eed1feac8de56631bee645c3bac1589fa9d0e85feb2be79d4 -87ba9a898df9dfa7dabc4ab7b28450e4daf6013340e329408d1a305de959415ab7315251bad40511f917dfc43974e5f0 -a598778cf01d6eef2c6aabc2678e1b5194ee8a284ebd18a2a51a3c28a64110d5117bcbf68869147934e600572a9e4c8a -84c69a4ad95861d48709f93ade5ac3800f811b177feb852ebcd056e35f5af5201f1d8a34ab318da8fe214812d0a7d964 -9638a237e4aed623d80980d91eda45e24ebf48c57a25e389c57bd5f62fa6ffa7ca3fb7ae9887faf46d3e1288af2c153b -800f975721a942a4b259d913f25404d5b7b4c5bf14d1d7e30eee106a49cb833b92058dab851a32ee41faf4ef9cb0dea4 -b9127a34a59fed9b5b56b6d912a29b0c7d3cb9581afc9bd174fc308b86fdb076f7d436f2abc8f61cef04c4e80cd47f59 -8004eda83f3263a1ccfc8617bc4f76305325c405160fb4f8efeff0662d605e98ba2510155c74840b6fe4323704e903c4 -aa857b771660d6799ff03ccad1ab8479e7f585a1624260418fc66dc3e2b8730cfa491d9e249505141103f9c52f935463 -98b21083942400f34cde9adbe1977dee45ba52743dc54d99404ad9da5d48691ddea4946f08470a2faad347e9535690c7 -a4b766b2faec600a6305d9b2f7317b46f425442da0dc407321fc5a63d4571c26336d2bccedf61097f0172ec90fb01f5f -b9736619578276f43583de1e4ed8632322ea8a351f3e1506c5977b5031d1c8ad0646fb464010e97c4ddb30499ddc3fb0 -973444ffaff75f84c17f9a4f294a13affd10e2bceed6b4b327e4a32c07595ff891b887a9f1af34d19766d8e6cb42bfd1 -b09ce4964278eff81a976fbc552488cb84fc4a102f004c87179cb912f49904d1e785ecaf5d184522a58e9035875440ef -b80c2aa3d0e52b4d8b02c0b706e54b70c3dbca80e5e5c6a354976721166ea0ca9f59c490b3e74272ef669179f53cb50d -8e52fa5096ff960c0d7da1aa4bce80e89527cdc3883eba0c21cb9a531088b9d027aa22e210d58cf7cbc82f1ec71eb44f -969f85db95f455b03114e4d3dc1f62a58996d19036513e56bee795d57bf4ed18da555722cd77a4f6e6c1a8e5efe2f5d7 -ab84b29b04a117e53caea394a9b452338364c45a0c4444e72c44132a71820b96a6754828e7c8b52282ad8dca612d7b6a -83e97e9ab3d9e453a139c9e856392f4cef3ec1c43bce0a879b49b27a0ce16f9c69063fd8e0debbe8fabafc0621bc200c -8c138ebdf3914a50be41be8aa8e2530088fb38af087fa5e873b58b4df8e8fd560e8090c7a337a5e36ef65566409ad8f3 -a56da9db2f053516a2141c1a8ed368ae278ab33a572122450249056857376d1dffc76d1b34daf89c86b6fe1ead812a0c -a3233ea249f07531f5bc6e94e08cea085fd2b2765636d75ff5851f224f41a63085510db26f3419b031eb6b5143735914 -b034bb6767ce818371c719b84066d3583087979ba405d8fbb2090b824633241e1c001b0cb0a7856b1af7a70e9a7b397e -8722803fe88877d14a4716e59b070dd2c5956bb66b7038f6b331b650e0c31230c8639c0d87ddc3c21efc005d74a4b5cc -8afe664cb202aacf3bd4810ebf820c2179c11c997f8c396692a93656aa249a0df01207c680157e851a30330a73e386b9 -a999e86319395351d2b73ff3820f49c6516285e459224f82174df57deb3c4d11822fd92cbbed4fc5a0a977d01d241b19 -9619408e1b58b6610d746b058d7b336d178e850065ba73906e08e748651e852f5e3aab17dcadcb47cc21ff61d1f02fcf -947cf9c2ed3417cd53ea498d3f8ae891efe1f1b5cd777e64cec05aba3d97526b8322b4558749f2d8a8f17836fb6e07aa -aec2fdae2009fda6852decb6f2ff24e4f8d8ca67c59f92f4b0cf7184be72602f23753ed781cf04495c3c72c5d1056ffe -8dba3d8c09df49fbfc9506f7a71579348c51c6024430121d1c181cad7c9f7e5e9313c1d151d46d4aa85fb0f68dd45573 -b6334cb2580ae33720ebf91bb616294532a1d1640568745dcda756a3a096786e004c6375728a9c2c0fb320441e7d297a -9429224c1205d5ecd115c052b701c84c390f4e3915275bb8ce6504e08c2e9b4dd67b764dd2ea99f317b4c714f345b6ff -abe421db293f0e425cfd1b806686bdfd8fdbac67a33f4490a2dc601e0ddbf69899aa9a119360dad75de78c8c688ca08b -95c78bffed9ae3fff0f12754e2bd66eb6a9b6d66a9b7faaeb7a1c112015347374c9fe6ce14bf588f8b06a78e9a98f44c -ac08f8b96b52c77d6b48999a32b337c5ad377adf197cda18dbdf6e2a50260b4ee23ca6b983f95e33f639363e11229ee4 -911a0e85815b3b9f3ba417da064f760e84af94712184faeb9957ddd2991dee71c3f17e82a1a8fbeec192b0d73f0ebce7 -aa640bd5cb9f050568a0ad37168f53b2f2b13a91e12b6980ca47ae40289cf14b5b89ddd0b4ca452ce9b1629da0ce4b5d -907486f31b4ecea0125c1827007ea0ecb1c55cadb638e65adc9810ca331e82bb2fd87e3064045f8d2c5d93dc6c2f5368 -8cbfaf4ce0bbbf89208c980ff8b7bc8f3cfef90f0fe910f463cb1c0f8e17cce18db120142d267045a00ba6b5368f0dd3 -9286f08f4e315df470d4759dec6c9f8eacef345fc0c0b533ad487bb6cfefa8c6c3821a22265c9e77d34170e0bc0d078b -94a3c088bc1a7301579a092b8ece2cefc9633671bc941904488115cd5cb01bd0e1d2deef7bdccb44553fd123201a7a53 -8f3d0114fbf85e4828f34abb6d6fddfa12789d7029d9f1bb5e28bc161c37509afdab16c32c90ec346bc6a64a0b75726f -a8ed2d774414e590ec49cb9a3a726fafd674e9595dd8a1678484f2897d6ea0eea1a2ee8525afac097b1f35e5f8b16077 -9878789ff33b11527355a317343f34f70c7c1aa9dc1eca16ca4a21e2e15960be8a050ec616ffb97c76d756ce4bce2e90 -854e47719dae1fe5673cacf583935122139cf71a1e7936cf23e4384fbf546d48e9a7f6b65c3b7bf60028e5aa1234ba85 -af74bdda2c6772fe9a02d1b95e437787effad834c91c8174720cc6e2ea1f1f6c32a9d73094fc494c0d03eef60b1a0f05 -80a3e22139029b8be32cb167d3bc9e62d16ca446a588b644e53b5846d9d8b7ab1ad921057d99179e41515df22470fb26 -86c393afd9bd3c7f42008bba5fe433ec66c790ebd7aa15d4aeaf9bb39a42af3cfaf8c677f3580932bbd7ada47f406c8c -90433c95c9bb86a2c2ddcf10adccb521532ebd93db9e072671a4220f00df014e20cd9ce70c4397567a439b24893808dc -95b2c170f08c51d187270ddc4f619300b5f079bbc89dbca0656eae23eecc6339bf27fa5bf5fd0f5565d4021105e967d2 -8e5eced897e2535199951d4cff8383be81703bca3818837333dd41a130aa8760156af60426ceadb436f5dea32af2814c -a254a460ebefbe91d6e32394e1c8f9075f3e7a2bb078430ac6922ab14d795b7f2df1397cb8062e667d809b506b0e28d4 -ac2062e8ca7b1c6afb68af0ebab31aebd56fc0a0f949ef4ea3e36baf148681619b7a908facf962441905782d26ecbdb5 -8b96af45b283b3d7ffeec0a7585fc6b077ea5fd9e208e18e9f8997221b303ab0ce3b5bafa516666591f412109ce71aa5 -afd73baada5a27e4fa3659f70083bf728d4dc5c882540638f85ea53bf2b1a45ddf50abc2458c79f91fb36d13998c7604 -a5d2fff226e80cb2e9f456099812293333d6be31dd1899546e3ad0cd72b2a8bcb45ec5986e20faa77c2564b93983210c -a8c9b8de303328fbdaccf60f4de439cf28f5360cf4104581dc2d126bc2e706f49b7281723487ff0eaf92b4cc684bc167 -a5d0d5849102bf1451f40e8261cb71fc57a49e032773cb6cd7b137f71ee32438d9e958077ffafce080a116ccc788a2d4 -80716596f502d1c727d5d2f1469ce35f15e2dbd048d2713aa4975ee757d09c38d20665326bd63303cfe7e820b6de393d -97baf29b20f3719323cc1d5de23eaa4899dc4f4e58f6c356ec4c3ad3896a89317c612d74e0d3ab623fe73370c5972e2f -b58bdc9aa5061bf6e5add99a7443d7a8c7ba8f6875b8667d1acbe96fc3ecafbdcc2b4010cb6970a3b849fff84660e588 -b6be68728776d30c8541d743b05a9affc191ad64918fdbd991d2ddd4b32b975c4d3377f9242defef3805c0bfb80fbac7 -b0cddace33333b8a358acad84b9c83382f0569d3854b4b34450fd6f757d63c5bdab090e330b0f86e578f22c934d09c36 -854bd205d6051b87f9914c8c2494075d7620e3d61421cc80f06b13cea64fd1e16c62c01f107a5987d10b8a95a8416ad9 -80351254a353132300ba73a3d23a966f4d10ce9bf6eae82aedb6cdc30d71f9d08a9dd73cb6441e02a7b2ad93ad43159c -937aae24fb1b636929453fc308f23326b74c810f5755d9a0290652c9c2932ad52cc272b1c83bd3d758ef7da257897eae -b84d51ef758058d5694ffeac6d8ce70cef8d680a7902f867269c33717f55dd2e57b25347841d3c0872ae5f0d64f64281 -a4b31bb7c878d5585193535b51f04135108134eff860f4eac941053155f053d8f85ff47f16268a986b2853480a6e75e6 -93543f0828835186a4af1c27bdf97b5dd72b6dfa91b4bf5e759ff5327eaf93b0cb55d9797149e465a6b842c02635ffe5 -afdac9e07652bf1668183664f1dd6818ef5109ee9b91827b3d7d5970f6a03e716adcc191e3e78b0c474442a18ad3fc65 -9314077b965aa2977636ae914d4a2d3ce192641a976ffa1624c116828668edbfbe5a09e3a81cb3eed0694566c62a9757 -b395ddcf5082de6e3536825a1c352802c557b3a5118b25c29f4c4e3565ecaaf4bdd543a3794d05156f91fc4ceadc0a11 -b71f774aad394c36609b8730e5be244aaebfff22e0e849acc7ee9d33bedc3ec2e787e0b8b2ffe535560fcd9e15a0897e -92e9409fa430f943a49bce3371b35ac2efb5bc09c88f70ff7120f5e7da3258a4387dfc45c8b127f2ef2668679aeb314e -8ef55bef7b71952f05e20864b10f62be45c46e2dca0ef880a092d11069b8a4aa05f2e0251726aca1d5933d7dea98f3f8 -aad3fba9e09fae885cdeef45dfafa901419f5156fb673818f92a4acc59d0e2e9870b025e711de590a63fd481164f3aa8 -b444d52af545dd3a2d3dd94e6613816b154afea0c42b96468aceb0c721395de89e53e81a25db857ca2e692dcb24ba971 -88b279fe173007e64fe58f2c4adba68a1f538dbd3d32d175aa0d026bbb05b72a0c9f5d02b8201a94adb75fe01f6aa8b2 -88494cea4260741c198640a079e584cabfea9fcfb8bcf2520c9becd2419cde469b79021e5578a00d0f7dbc25844d2683 -94f3cce58837c76584b26426b9abdb45f05fee34dd9e5914b6eae08e78b7262ed51c4317031dab1ad716f28b287f9fc2 -b8c7ed564f54df01c0fbd5a0c741beed8183ce0d7842dc3a862a1b335de518810077314aa9d6054bb939663362f496da -81c153320d85210394d48340619d5eb41304daea65e927266f0262c8a7598321aba82ad6c3f78e5104db2afd2823baca -ab6695a8d48a179e9cd32f205608359cf8f6a9aead016252a35b74287836aa395e76572f21a3839bec6a244aa49573e5 -920ed571539b3002a9cd358095b8360400e7304e9a0717cc8c85ab4a0514a8ad3b9bf5c30cb997647066f93a7e683da9 -a7ec7c194d1e5103bc976e072bf1732d9cb995984d9a8c70a8ee55ce23007f21b8549ad693f118aa974f693ed6da0291 -87a042d6e40c2951a68afc3ccf9646baf031286377f37f6ac47e37a0ec04d5ac69043757d7dff7959e7cd57742017a8d -b9f054dd8117dd41b6e5b9d3af32ee4a9eebef8e4a5c6daa9b99c30a9024eabeae850ab90dbdb188ca32fd31fd071445 -a8386da875799a84dc519af010eaf47cdbc4a511fe7e0808da844a95a3569ce94054efd32a4d3a371f6aba72c5993902 -8b3343a7cf4ffb261d5f2dbd217fb43590e00feac82510bdf73b34595b10ee51acae878a09efebc5a597465777ef4c05 -8312a5f1ea4f9e93578e0f50169286e97884a5ed17f1780275ab2b36f0a8aa1ab2e45c1de4c8bce87e99e3896af1fa45 -b461198cb7572ac04c484a9454954e157bdd4db457816698b7290f93a10268d75a7e1211e757c6190df6144bbb605d91 -9139764a099580d6f1d462c8bf7d339c537167be92c780e76acb6e638f94d3c54b40ed0892843f6532366861e85a515a -8bb70acb3c9e041b4fc20e92ba0f3f28f0d5c677bcb017af26f9171e07d28c3c0729bef72457231e3512f909455a13a2 -93301a18e5064c55fcfe8e860fab72da1b89a824ca77c8932023b7c79e4a51df93a89665d308a8d3aa145e46ebe6a0ad -ae3bca496fbd70ce44f916e2db875b2ce2e1ded84edd2cebc0503bdfdec40ec30e1d9afb4eb58c8fa23f7b44e71d88f8 -93cb3a918c95c5d973c0cb7621b66081ed81fba109b09a5e71e81ca01ec6a8bb5657410fdec453585309ef5bf10d6263 -95a50b9b85bb0fc8ff6d5f800d683f0f645e7c2404f7f63228a15b95ce85a1f8100e2e56c0acee19c36ed3346f190e87 -816cc4d9337461caca888809b746ab3713054f5b0eac823b795a1a9de9417c58e32a9f020fef807908fa530cbf35dee8 -a9c2890c2dd0d5d7aedc4cca7f92764086c50f92f0efd2642c59920d807086031bfe2d3ba574318db236c61a8f5f69c2 -ad0d5c8c80bddfe14bdaf507da96dc01dc9941aecc8ad3b64513d0a00d67c3f4b4659defb6839b8b18d8775e5344c107 -9047c9fad6ef452e0219e58e52c686b620e2eb769571021e3524bd7eac504f03b84834b16b849d42b3d75c601fd36bb7 -a04dd988fed91fb09cb747a3ac84efe639d7d355524cd7dee5477ecbcdec44d8ac1cec2c181755dcfdb77e9594fb3c5b -b0ea0c725debd1cec496ced9ce48f456f19af36e8b027094bf38fa37de9b9b2d10282363ea211a93a34a0a5387cace5d -b5fc46e2bb3e4653ea5e6884dcb3c14e401a6005685ee5a3983644b5b92300b7066289159923118df4332aac52045b8c -841fc5b26b23226e725e29802da86b35e4f5e3babc8b394f74e30fd5dec6d3840b19a9a096625ce79a4f1edae6369700 -8fd2bbbeea452451def3659bbe0ceb396120ebe8f81eee1ea848691614422c81d7c3e6a7a38032b4120b25c5ffa8f0c2 -9131ce3d25c3d418f50c0ab99e229d4190027ee162b8ba7c6670420ea821831dec1294ac00d66c50fac61c275a9e2c71 -99ec6eafe0eb869d128158cee97b984fb589e1af07699247946e4a85db772289dff3084d224a6f208005c342f32bbd73 -ac100fbbe7c2bf00cc56fcd5aa1f27181f82c150c53bbb1e15d2c18a51ed13dcfa7bccab85821b8ddddf493603e38809 -affd73a458d70c0d9d221e0c2da4348fed731f6b34c0b3e2d5711ba432e85a1ec92e40b83b246a9031b61f5bc824be47 -8ed30ed817816a817e9e07374ef1f94405a7e22dd0096aeaae54504382fc50e7d07b4f1186c1792fc25ea442cd7edc6b -a52370cfe99a35fa1405aeca9f922ad8d31905e41f390e514ea8d22ee66469637d6c2d4d3a7ee350d59af019ae5a10a4 -8d0b439741c57b82c8e4b994cf3956b5aeaee048b17e0a1edb98253a8d7256f436d8b2f36b7e12504132dbf91f3376b1 -8caac7e1a4486c35109cff63557a0f77d0e4ca94de0817e100678098a72b3787a1c5afc7244991cebcd1f468e18d91d4 -a729a8e64b7405db5ebfb478bb83b51741569331b88de80680e9e283cc8299ba0de07fcf252127750f507e273dc4c576 -a30545a050dad030db5583c768a6e593a7d832145b669ad6c01235813da749d38094a46ac3b965700230b8deacd91f82 -9207e059a9d696c46fa95bd0925983cd8e42aefd6b3fb9d5f05420a413cbc9e7c91213648554228f76f2dd757bde0492 -a83fa862ae3a8d98c1e854a8b17181c1025f4f445fbc3af265dc99e44bbd74cfa5cc25497fb63ee9a7e1f4a624c3202c -84cdfc490343b3f26b5ad9e1d4dcf2a2d373e05eb9e9c36b6b7b5de1ce29fda51383761a47dbd96deca593a441ccb28e -881a1aa0c60bb0284a58b0a44d3f9ca914d6d8fa1437315b9ad2a4351c4da3ee3e01068aa128284a8926787ea2a618d1 -aace78e497b32fbff4df81b1b2de69dbc650645e790953d543282cb8d004a59caf17d9d385673a146a9be70bf08a2279 -aa2da4760f1261615bffd1c3771c506965c17e6c8270c0f7c636d90428c0054e092247c3373eca2fb858211fdb17f143 -acb79f291b19e0aa8edb4c4476a172834009c57e0dcc544c7ce95084488c3ad0c63ffd51c2b48855e429b6e1a9555433 -814b58773a18d50a716c40317f8b80362b6c746a531776a9251c831d34fb63e9473197c899c0277838668babc4aa0ecb -b1f69522b0f7657d78bd1ee3020bcce3447116bf62c146d20684537d36cafb5a7a1531b86932b51a70e6d3ce0808a17e -8549712c251ef382f7abe5798534f8c8394aa8bcecdca9e7aa1a688dc19dc689dcd017a78b118f3bd585673514832fe4 -912a04463e3240e0293cfc5234842a88513ff930c47bd6b60f22d6bc2d8404e10270d46bf6900fee338d8ac873ebb771 -a327cb7c3fada842e5dd05c2eeedd6fcd8cf2bfb2f90c71c6a8819fb5783c97dd01bd2169018312d33078b2bc57e19f7 -b4794f71d3eceed331024a4cee246cc427a31859c257e0287f5a3507bfbd4d3486cb7781c5c9c5537af3488d389fe03e -82ffcb418d354ed01688e2e8373a8db07197a2de702272a9f589aed08468eab0c8f14e6d0b3146e2eb8908e40e8389c5 -910b73421298f1315257f19d0dfd47e79d7d2a98310fb293f704e387a4dc84909657f0f236b70b309910271b2f2b5d46 -a15466397302ea22f240eb7316e14d88376677b060c0b0ae9a1c936eb8c62af8530732fc2359cfd64a339a1c564f749b -a8091975a0d94cdc82fbaff8091d5230a70d6ea461532050abbdfee324c0743d14445cfe6efe6959c89a7c844feaa435 -a677d1af454c7b7731840326589a22c9e81efbbf2baf3fdeaf8ea3f263a522584fbca4405032c4cdf4a2a6109344dfc8 -894e6ffa897b6e0b37237e6587a42bbc7f2dd34fb09c2e8ac79e2b25b18180e158c6dc2dd26761dba0cfed1fb4eb4080 -928d31b87f4fe8fe599d2c9889b0ff837910427ba9132d2fba311685635458041321ae178a6331ed0c398efe9d7912f0 -afc1c4a31f0db24b53ee71946c3c1e1a0884bd46f66b063a238e6b65f4e8a675faa844e4270892035ef0dae1b1442aa0 -a294fcb23d87cf5b1e4237d478cac82ba570649d425b43b1e4feead6da1f031e3af0e4df115ca46689b9315268c92336 -85d12fd4a8fcfd0d61cbf09b22a9325f0b3f41fb5eb4285b327384c9056b05422d535f74d7dc804fb4bab8fb53d556bd -91b107d9b0ea65c48128e09072acd7c5949a02dd2a68a42ff1d63cf528666966f221005c2e5ca0a4f85df28459cdede6 -89aa5dc255c910f439732fcd4e21341707e8dd6689c67c60551a8b6685bd3547e3f47db4df9dfadd212405f644c4440b -8c307d6b827fa1adcf0843537f12121d68087d686e9cc283a3907b9f9f36b7b4d05625c33dab2b8e206c7f5aabd0c1e5 -843f48dadf8523d2b4b0db4e01f3c0ea721a54d821098b578fcaa6433e8557cadfea50d16e85133fa78f044a3e8c1e5b -9942eb8bd88a8afa9c0e3154b3c16554428309624169f66606bfb2814e8bac1c93825780cf68607f3e7cffe7bf9be737 -b7edb0c7637a5beb2332f2ae242ba4732837f9da0a83f00f9e9a77cf35516e6236eb013133ddc2f958ea09218fe260d3 -9655fe4910bc1e0208afbcf0ff977a2e23faded393671218fba0d9927a70d76514a0c45d473a97ecb00cf9031b9d527c -8434bc8b4c5839d9e4404ff17865ded8dd76af56ef2a24ea194c579d41b40ed3450c4e7d52219807db93e8e6f001f8da -b6c6d844860353dab49818bed2c80536dbc932425fdaa29915405324a6368277cf94d5f4ab45ea074072fc593318edff -b2887e04047660aa5c83aad3fa29b79c5555dd4d0628832c84ba7bf1f8619df4c9591fcde122c174de16ca7e5a95d5e3 -953ba5221360444b32911c8b24689078df3fbf58b53f3eec90923f53a22c0fc934db04dd9294e9ec724056076229cf42 -926917529157063e4aade647990577394c34075d1cb682da1acf600639d53a350b33df6a569d5ebb753687374b86b227 -b37894a918d6354dd28f850d723c1c5b839f2456e2a220f64ecadac88ae5c9e9cf9ab64b53aac7d77bf3c6dfa09632dc -b9d28148c2c15d50d1d13153071d1f6e83c7bb5cb5614adf3eb9edede6f707a36c0fa0eadb6a6135ead3c605dfb75bd1 -9738d73ea0b9154ed38da9e6bd3a741be789ea882d909af93e58aa097edf0df534849f3b1ba03099a61ceb6a11f34c4d -afabbecbbf73705851382902ec5f1da88b84a06b3abfb4df8d33df6a60993867f853d0d9bd324d49a808503615c7858a -a9e395ddd855b12c87ba8fdb0ea93c5bd045e4f6f57611b27a2ee1b8129efe111e484abc27cb256ed9dcace58975d311 -b501c2f3d8898934e45e456d36a8a5b0258aeea6ff7ac46f951f36da1ec01bd6d0914c4d83305eb517545f1f35e033cc -86f79688315241fe619b727b7f426dbd27bcc8f33aef043438c95c0751ada6f4cd0831b25ae3d53bcf61324d69ea01eb -83237e42fa773a4ccaa811489964f3fab100b9eea48c98bdef05fa119a61bde9efe7d0399369f87c775f4488120b4f2e -b89f437552cab77d0cd5f87aca52dd827fb6648c033351c00ab6d40ac0b1829b4fcdf8a7dad467d4408c691223987fbe -8e21061698cb1a233792976c2d8ab2eeb6e84925d59bb34434fff688be2b5b2973d737d9dda164bd407be852d48ef43f -b17a9e43aa4580f542e00c3212fbf974f1363f433c5502f034dfd5ed8c05ac88b901729d3b822bec391cca24cc9f5348 -aac6d6cda3e207006c042a4d0823770632fc677e312255b4aff5ad1598dc1022cab871234ad3aa40b61dc033a5b0930b -b25e69f17b36a30dada96a39bc75c0d5b79d63e5088da62be9fcbddfd1230d11654890caa8206711d59836d6abbc3e03 -af59fe667dd9e7e4a9863c994fc4212de4714d01149a2072e97197f311be1f39e7ad3d472e446dcc439786bf21359ede -957952988f8c777516527b63e0c717fc637d89b0fd590bcb8c72d0e8a40901598930c5b2506ff7fea371c73a1b12a9be -a46becd9b541fc37d0857811062ca1c42c96181c7d285291aa48dc2f6d115fcff5f3dfdf4490d8c619da9b5ce7878440 -87168fbd32c01a4e0be2b46fe58b74d6e6586e66bbb4a74ad94d5975ac09aa6fa48fd9d87f1919bd0d37b8ebe02c180c -895c4aa29de9601fc01298d54cfb62dd7b137e6f4f6c69b15dc3769778bfba5fc9cbd2fc57fd3fad78d6c5a3087f6576 -b9cf19416228230319265557285f8da5b3ca503de586180f68cf055407d1588ecec2e13fc38817064425134f1c92b4d5 -9302aaef005b22f7b41a0527b36d60801ff6e8aa26fe8be74685b5f3545f902012fcade71edca7aaa0560296dac5fca5 -a0ccda9883027f6b29da1aaa359d8f2890ce1063492c875d34ff6bf2e7efea917e7369d0a2b35716e5afd68278e1a93a -a086ac36beeba9c0e5921f5a8afea87167f59670e72f98e788f72f4546af1e1b581b29fbdd9a83f24f44bd3ec14aee91 -8be471bf799cab98edf179d0718c66bbc2507d3a4dac4b271c2799113ce65645082dc49b3a02a8c490e0ef69d7edbcb1 -8a7f5b50a18baf9e9121e952b65979bda5f1c32e779117e21238fb9e7f49e15008d5c878581ac9660f6f79c73358934a -b3520a194d42b45cbab66388bee79aad895a7c2503b8d65e6483867036497d3e2e905d4d51f76871d0114ec13280d82f -8e6ca8342ec64f6dbe6523dc6d87c48065cd044ea45fa74b05fff548539fd2868eb6dd038d38d19c09d81d5a96364053 -b126a0e8263a948ba8813bf5fb95d786ae7d1aa0069a63f3e847957822b5fe79a3a1afa0ce2318b9ba1025f229a92eb7 -8e4461d6708cac53441a3d23ac4b5ff2b9a835b05008c26d7d9c0562a29403847cf760b7e9d0bcb24a6f498d2a8a9dd2 -b280a761bab256dfe7a8d617863999e3b4255ddbdc11fe7fe5b3bb9633fc8f0cb4f28e594d3b5b0b649c8e7082c4666a -a3e3043bfd7461e38088ee6a165d2ca015de98350f1cb0efc8e39ed4fcdb12a717f0ede7fbf9dadb90496c47652cc0ce -a4c1f5b1b88ae3c397d171e64395afe0cd13c717677775a01dd0461d44a04ee30ec3da58a54c89a3ca77b19b5e51062c -a268638e0655b6d5a037061808619b9ae276bb883999d60c33a9f7f872c46d83d795d1f302b4820030c57604fa3686e7 -ac20176111c5c6db065668987227658c00a1572ce21fe15f25e62d816b56472c5d847dd9c781fb293c6d49cc33b1f98f -acc0e22d9b6b45c968c22fd16b4ece85e82a1b0ab72369bdd467857fee1a12b9635f5b339a9236cbd1acc791811d0e29 -b56066e522bee1f31480ff8450f4d469ace8eb32730c55b7c9e8fa160070bdec618454e665b8cbc5483bc30b6cebbfb9 -8c1772bdfacff85f174d35c36f2d2182ae7897ad5e06097511968bbb136b626c0c7e462b08a21aca70f8e456b0204bf8 -b4de3cf4a064bf589be92513b8727df58f2da4cd891580ef79635ac8c195f15a6199327bb41864e2f614c8589b24f67e -8f3c534125613f2d17bf3e5b667c203cb3eab0dbca0638e222fe552fddf24783965aa111de844e8c3595304bfc41c33b -8e445b2711987fe0bf260521cb21a5b71db41f19396822059912743bf6ca146100c755c8b6e0e74f1bf2e34c03b19db9 -87ff9adf319adb78c9393003b5bdda08421f95551d81b37520b413fe439e42acf82d47fa3b61476b53166bf4f8544f0e -83f3c00c55632e1937dcdc1857de4eccd072efa319b3953d737e1d37382b3cf8343d54a435588eb75aa05bf413b4caa0 -b4d8ee1004bac0307030b8605a2e949ca2f8d237e9c1dcf1553bd1eb9b4156e2deb8c79331e84d2936ec5f1224b8b655 -93b2812b6377622e67bf9a624898227b56ebe3c7a1d917487fc9e4941f735f83679f7ac137065eb4098ad1a4cfbc3892 -81943d9eab6dcea8a120dde5356a0a665b1466709ebb18d1cbfa5f213a31819cb3cf2634e6d293b5b13caa158a9bb30b -a9042aae02efd4535681119e67a60211fc46851319eb389b42ebadcab1229c94199091fb1652beba3434f7b98c90785f -91db52b27fd9b1715df202106b373c4e63ce8ec7db8c818c9016ace5b08ef5f8c27e67f093395937ba4ce2f16edf9aef -83cb9b7b94bd6ead3ff2a7d40394f54612c9cb80c4e0adadffea39e301d1052305eb1fe0f7467268b5aba3b423a87246 -8720fd6712a99d92dd3fdaae922743ab53fad50d183e119a59dae47cdac6fbea6064c732d02cb341eaea10723db048fa -8d40022c1254462a2ac2380a85381c370b1221e5a202d95c75bccba6d1e52972dd5585a1294a1e487bf6ae6651867167 -b7bc06e08d8c72daba143627582f4b4f34cc2234b5cb5cd83536f2ef2e058631a3920468ea4d550aea01cad221d6a8a6 -a6e1a6f70fba42d3b9ce5f04ffdcfca46fc94041840c0066a204030cf75ea9f9856113fea3a9f69ea0037d9a68e3a9d4 -8b064c350083fce9a52da2e2e17bf44c4c9643d2d83667cbd9ad650bbeba55e2c408e746ccf693e56d08826e8a6d57fc -8d304a5405a0c0696917fcddc6795dd654567ca427f007d9b16be5de98febbf8692374e93f40822f63cf6f143c4d9499 -b968db239efec353a44f20a7cf4c0d0fca4c4c2dc21e6cbb5d669e4fe624356a8341e1eec0955b70afb893f55e9a9e32 -98971f745ce4ce5f1f398b1cd25d1697ada0cc7b329cee11d34b2d171e384b07aeb06ac7896c8283664a06d6dd82ec6b -881f5a20a80f728354fad9d0a32a79ffe0ba9bed644ed9d6a2d85444cda9821018159a3fa3d3d6b4fadbf6ea97e6aff6 -b7c76cbb82919ec08cf0bd7430b868a74cb4021e43b5e291caa0495ca579798fab1b64855e2d301f3461dd4d153adeb6 -b44c8c69b3df9b4e933fe6550982a6f76e18046e050229bd2456337e02efb75efa0dfe1b297ed9f5d7fa37fec69c8374 -a5bd7781820ba857aee07e38406538b07ab5180317689a58676f77514747672dd525ea64512a0e4958896f8df85e9d4d -a8443d1dc91b4faa20a2626505b5b4ad49cc5c1fd7a240a0e65d12f52d31df1585ba52c21e604dcec65ec00b81ae21fe -a157ae42fc6302c54bcdd774e8b8bafc4f5d221717f7bf49668c620e47051b930dce262d55668e546272dd07ca7c8d3f -8732c10448b63e907ff95f53cd746f970c946fd84fcbfe4cf9ede63afbbfc66b293bbc7c470d691bbd149bb3c78bb351 -a82192f4fd9a0c33489a0486b79d0f6c797c7eccb45f91f7f1e8e1dd1924ca9944b983951025b99ab5861d31841451fe -839efc6d199ddd43f34f6729b6b63f9ee05f18859bf8fd3f181fa71f4399a48bff7dde89b36e9dc1c572f1b9b6127cca -992ef084abe57adfd5eb65f880b411d5f4ed34c1aeb0d2cfac84fff4f92a9a855c521a965ba81b5eef2268e9a9e73048 -a2518ab712fa652e6e0bd0840307ef3831094e9a18723fb8ec052adacbb87f488d33778c6ec3fd845003af62e75125d1 -b630ac3c9e71b85dd9e9f2984bb5b762e8491d8edb99cad82c541faf5a22dd96f0fddb49d9a837b1955dea2d91284f28 -8d886d1b7f818391b473deba4a9a01acce1fe2abe9152955e17ba39adc55400590c61582c4fef37a286e2151566576ed -884f100dc437639247f85e5d638fcc7583d21bf37a66ce11e05bfc12f5dbe78685b0e51b4594e10549c92bb980512e12 -806d7bac2d24cfff6090ba9513698292d411cdea02976daa3c91c352b09f5a80a092cfa31304dcfcd9356eaf5164c81b -934ed65f8579ee458b9959295f69e4c7333775eb77084db69ad7096f07ad50ad88f65e31818b1942380f5b89e8d12f1b -aaf50ca5df249f0a7caf493334b6dca1700f34bd0c33fe8844fadd4afedbb87a09673426741ac7cbbb3bf4ab73f2d0f3 -b2868642cfa0a4a8a2553691c2bef41dab9dff87a94d100eaa41645614ab4d0e839ec2f465cc998c50cd203f0c65df22 -a326513112e0b46600d52be9aa04d8e47fe84e57b3b7263e2f3cf1a2c0e73269acb9636a99eb84417f3ae374c56e99b0 -97b93efc047896ddf381e8a3003b9e1229c438cc93a6dbef174bb74be30fac47c2d7e7dc250830459bed61d950e9c924 -b45e4f0a9806e44db75dbb80edc369be45f6e305352293bcae086f2193e3f55e6a75068de08d751151fdf9ebc6094fa1 -87f2161c130e57e8b4bb15616e63fa1f20a1b44d3e1683967a285f0d4f0b810f9202e75af2efa9fc472687c007a163f7 -8f6400a45666142752580a2dce55ef974f59235a209d32d2036c229c33a6189d51435b7ea184db36f765b0db574a9c52 -a0ee079462805f91b2200417da4900227acde0d48c98e92c8011a05b01c9db78fc5c0157d15cb084b947a68588f146f4 -ab0612d9bb228b30366b48e8d6ae11026230695f6f0607c7fa7a6e427e520121ff0edea55d1f0880a7478c4a8060872d -ad65dfde48f914de69f255bb58fa095a75afe9624fc8b7b586d23eb6cf34a4905e61186bc978e71ccb2b26b0381778a6 -8c8a4847d138d221c0b6d3194879fd462fb42ed5bd99f34ebe5f5b1e1d7902903ec55e4b52c90217b8b6e65379f005a4 -a41dca4449584353337aef1496b70e751502aeed9d51202de6d9723e155ca13be2d0db059748704653685a98eaa72a07 -ae40e5450fd994d1be245a7cd176a98dd26332b78da080159295f38802a7e7c9c17cc95da78d56558d84948cf48242cd -863878fda80ad64244b7493e3578908d4a804887ad1ad2c26f84404dcad69ea2851846ad2c6f2080e1ed64fe93bbec31 -b262fb990535f162dc2b039057a1d744409a3f41dd4b70f93ff29ba41c264c11cb78a3579aad82f3fa2163b33a8ce0e1 -a7f6eb552b9a1bb7c9cb50bc93d0dda4c7ecf2d4805535f10de0b6f2b3316688c5e19199d5c9ec2968e2d9e2bd0c6205 -a50aa5869412dc7081c8d827299237910ecec3154587692548da73e71fa398ff035656972777950ba84e472f267ba475 -924c3af750afc5dfad99d5f3ed3d6bdd359492cff81abcb6505696bb4c2b4664926cb1078a55851809f630e199955eb3 -a1acffa31323ce6b9c2135fb9b5705664de8949f8235b4889803fbd1b27eb80eb3f6a81e5b7cc44e3a67b288b747cf2f -8dec9fd48db028c33c03d4d96c5eecea2b27201f2b33d22e08529e1ae06da89449fe260703ac7bb6d794be4c0c6ea432 -aa6642922ccf912d60d678612fffe22ef4f77368a3c53a206c072ed07c024aa9dcde2df068c9821b4c12e5606cfe9be2 -a16ddf02609038fcb9655031b1cb94afe30b801739e02a5743c6cd2f79b04b2524c2085ca32ec3a39df53de0280f555d -b067d48589e9d3428c6d6129e104c681e4af376a351f502840bbea6c3e11fcbfdf54dadf6f1729621720a75ff89786c3 -b14a24079de311c729750bb4dd318590df1cd7ffc544a0a4b79432c9a2903d36a0d50ecd452b923730ade6d76a75c02c -97437bac649f70464ace93e9bec49659a7f01651bba762c4e626b5b6aa5746a3f0a8c55b555b1d0dc356d1e81f84c503 -a6f4cb2ffc83564b1170e7a9a34460a58a4d6129bd514ff23371a9e38b7da6a214ac47f23181df104c1619c57dff8fe2 -896d0f31dfc440cc6c8fde8831a2181f7257ffb73e1057fd39f1b7583ea35edf942ad67502cd895a1ad6091991eabc5e -9838007f920559af0de9c07e348939dfd9afe661b3c42053b4d9f11d79768cba268a2ee83bb07a655f8c970c0ee6844b -b41b8a47e3a19cadec18bff250068e1b543434ce94a414750852709cd603fc2e57cd9e840609890c8ff69217ea1f7593 -a0fb4396646c0a2272059b5aeb95b513e84265b89e58c87d6103229f489e2e900f4414133ed2458ddf9528461cfa8342 -ae026cfa49babc1006a3e8905d6f237a56a3db9ddf7559b0e4de8d47d08c3f172bde117cdf28dfdfd7627bd47d6a3c85 -a6a3f3e7006bc67290c0c40c1680bf9367982eb8aaf17ecb484a58c8e9c2a7c24932e2caa9aacc9b4fbf4c0abd087a46 -9093e05bd814177a01a3b8d7b733db66294e1c688c56def6e1827c0f2d9a97cf202721641bf81fb837f8581ae68cb5ce -87feef4de24942044f47d193d4efc44e39a8c0f4042fba582f2491a063e3a4640cb81f69579b6f353b9208884a4f7ce6 -975f9b94e78aac55bd4755f475e171e04f6fbddb6fd3d20a89a64a6346754a3ff64ecff8c04b612a1250e1d8d8a9e048 -87cde4d0164922d654cf2dc08df009e923c62f1a2e3b905dfde30f958e9e4dd6070d9f889712acd6c658804f48f3edb1 -ae8e22e158dda90a185eec92602831b5d826e5a19aab8c6400dba38b024c7d31c4cf265eb7b206dd45834f020b3f53cd -a4475807adc28aa086e977b65bbd7c8512119318c89d2619ea03a6739a72c3fb90c9622451896c7113ad4d12a3004de6 -97f1ae1e0d258a94532c7b73fa8ebdbbd53349a4d2d0a217fe56dfdd084dd879960bc6ff45ebb61b5dbf2054642800a4 -b3c832bd3691332a658b0caaa7717db13f5b5df2b5776b38131ac334b5fd80d0b90b6993701e5d74d2b7f6b2fd1f6b9d -a4b6af590187eb1b2cb5ae2b8cffa45c5e76abdb37cec56fc9b07a457730f5af0706d9ce0a17da792bbece5056d05670 -97b99a73a0e3145bf91f9dd611a67f894d608c954e9b8f5a4c77e07574064b3db47353eba8038062cebaad06a2500bab -8e5ca5a675de6e6d3916bd9ce5898bb379372afe3f310e70ff031bc8cc8fabfb7f3bfb784f409bb7eb06fdb4511ee477 -aabbbee4da1f16b5bbe001c19debe04745932d36dfbbf023fbf1010a2b1d54eb92fa5e266ac1e9337e26e2ddba752f40 -b13447c77496825f48e35c14f9b501c5056e6d5519f397a2580cea9a383a56a96994d88926aa681142fe2f1589c03185 -b89c55db39ff0e73dde7435b61e8a4d3e10f51dd8096cbc7f678661962e6de3d16f2f17a0e729cc699234cb847f55378 -82c36b7de53698a1bafbb311fefc6007fcefa47a806ebe33a4e7e0fc1c7b6b92a40a1860702cf9295a16c6b1433e3323 -8daeec8c88543d09c494a15cc9a83c0b918d544311fd2a7d09e06cf39cdebfa0cfc0e8fc0e3b5954960b92332f98697c -b18e55a1a7ae16be3a453d2bfa7659a7ec2d283dd46bdc82decef6d3751eeafc4f86f2416a22955c7e750c0582d4f3eb -b50c743462e2915bf773848669e50a3bcdb5a9ac5f664e97eaccf568c7d64a6493d321be0225de16142ce82ce1e24f66 -af69c9643805fb860434424b1608aababc593aaebc6a75fc017f7f62bb2b1da932b0b9bd5e6dcbba328422dafc06efd8 -b5947db4f809fd0d27af838b82eef8ab4fe78687a23ebc61c09c67eb7e8d0e6a310ecb907fd257859d5a2759a07c21cc -92c7960e163ca5bdf9196c7215102f8e9d88efc718843321c6e2a6170137b8ecec4ea5d5a5ce4c28012b6cdbd777dd01 -b63f9509ed5e798add4db43b562e8f57df50d5844af6e5c7acf6c3b71637c0a2d2433f4a0627b944f0af584892208bb8 -8ef28304a9bfe5220af6a9a6a942d2589606f5dc970d708ef18bc7ed08e433161020d36fb327c525398cd8ecb57002f9 -b722e0410f896c4462d630a84a5a14e94289fc38ed6d513ca88a09005935cec334c480028efa1943c7a5e202ae8c8379 -b56b6672b488e64d4dde43571f9ceaa7e61e336b0fd55bb769a57cd894a6300e724e5f88bad39a68bc307eb7406cb832 -8bf493da411fd41502b61a47827731193652e6ce3810709e70869d9aae49e4b17a40437a7a0dcc0547dbac21f355c0da -9613b60a144c01f6a0e7d46ddde07402e2133a1fe005c049a56415ff90401765040b2fc55971d24b94c5fd69fec58941 -85e2f02b291563d8eea3768cf6a4602c0ca36568ffcf3d93795d642044196ca6b0b28991ea5898e7974ee02831a0ec70 -b08ef66703dd9ac46e0208487566fbf8d8654d08c00f03e46f112c204782ccc02a880a3f9dffd849088693cee33b7b6d -a0b19eeda6c71b0e83b1f95dffef4d370318bdea6ea31d0845695e6b48d5c428c3dbba1a0ded80964992c4a0695f12ee -b052642e5772d2ef6f49dd35c5e765c5f305006b2add3b4bee5909ca572161edf0e9c2bc3bc3bc7f56fd596360ef2201 -8261af164c768fec80d63fca6cd07d1c0449e9ca665fe60c29babdbd8a2b20cf1f556a4b24cd7341712468a731c21b32 -8a17016a1b2fc0fa0d9e3610ea80548fcf514e0a35e327f6b5f8069b425c0f0829af7e206013eab552be92b241be5ac5 -8eea25c680172696f5600271761d27ef4c8cec9ab22f01f72b2c7c313a142fafaec39e6920b96fcace858883e02eff7a -b8e0c590106e125c5bca7e7a071cc408b93629da0d8d6381f1b73fbdf17024a0cf13f679f5203a99bbbcb664b4a94e88 -b9943b29395258b7afdf1781cfaf131297a4f325540755df73401b2ec4a549f962952e9907413c39a95585c4aff38157 -8286eab4a04f8113fb3f738a9bc9c2deaf3a22bf247151515568703da4efe6450ab3970f5c74e978a2db7e8d795331b7 -a10cf383c8a7e3f0a0a5556b57532170ff46dabdcbb6a31c4617271634b99540aa575786c636d3809207cbf1d2f364d3 -a5af7eb998140d01ba24baa0e8c71625aee6bd37db4c5ff607518f907892219ba8c9a03c326b273bfd7068232809b73c -aed5f461e38fccc8b3936f1328a9747efcbceb66312f6d6eddce57c59570852767159f1a7d9998f63342515fef4ba9bf -aec3e94b029aa692bfe2b8dbc6c3b0d132b504242e5ebe0cad79c065085e2fc05550e5cdaa2353892a40ff1a062dd9eb -87c23703960129396018d0347f5dd034abdbd57232b74195b6a29af34b6197b3cd63c60ac774d525add96ae54d5c0fb4 -97964a7768216e1c84dece71ce9202cc64b6d483650aa6f6d67215f655f66cda14df0a0f251db55832c77bfd9b6316e2 -8167aaf24c8a023d0aea16b8c24d993618b9d0c63619e11a28feab8f14952bafcb0918ed322cbc0ae1b2e1786071819b -b58318bd62852ffb712fc58f368c21b641dde7b3fa7d7269974c7a7b5b3e1641569fc7b5f32ca49de22f4f993506d92d -b172e7911d5cd3f53af388af847b928947c711185aebd3328f8e6ed1106c161ae0c1b67d3d9eb237e9e66eb0672edec0 -a6834cf69b2c4433cf6e779bfbb736b12e73e71e149c38101d13dbacf6c5048db53994a6a039381df40bbd67de40fcd0 -882604aa3bb19fffd6db744b5cf4a2431b157dac06d0617e0703684a118ca90b2d22a7758a1de7732a7144e68b11b7f7 -addc128ba52bf7553b9ba49eff42004d388a02c6b6e9809abe1c0d88f467e5ff6cb0c82a8fd901b80dfc9a001f7b9997 -abf19604a3f0cffefa7a9ced81627f6aacb8d7267b52b825f25d813d9afa24af6d70da21450ed93eaff8b4d2a9b905a9 -a3c67e7bf02dbca183d86924611a7149556ee17cb3469793624da496b6c25617a9071925dd02aab9cb028739cb79043d -b1cea4284a3ac4d5b1c6f0947c6ec8365b3281ed15495bf328a907a9a02cdd186e7cb1ef080385b3399df786855985a9 -a6edb126314559e6129caf1111dc3c82ff914efce658b11f2c9b48081be1cf3f46bde482469d493379025a158d95ab1b -9843fd7dd424da1acc6f92f87fac364a8b0d4097d74b6b451386384966c85145d43fc6ecedf04271b0f963ac731fd93f -83852bedca03a97a2e63053cb102387866cbefe6707ebb6dae2d32a59c343079f1a863f299fd64d0ecbe024d0a1247d5 -a570e645a0679ebc6f0ca03cc8f7367b03c3886f3d9c787992de7f3e93360a170d3ac9ae7720999c727a887b1dc762bb -ad644c40555238f28844eed632c8972b63d2602098031d53b5599d1a874903e0d0c428e0ab12a209ea3fb31225578f1c -b64e9f92a14812ed31075f9fdd3324659a036ef2f293ef9ca6f6feb87d0c138e1ba74bc36a910afd22ff9b3c8ec7cfa5 -8f2d75a86d517dafac09b65596f4b89c4a9c0a7003632407504153fa297c9e3228e236948a5d5224b8df49a087c8e0e3 -b02d6ab9292ae336c8a74115f33765af2c9f62c331d70c087cf4c2979792bb3c2666f6699c017f8d4c6b378fd4bda86a -a923d660d2e55228b8bc74f87d966069bd77c34a776fa96f37b48539c85634482e514e2cb76cb8eb20efd85eb9c83fae -81d7ffb53090a6d512055ecfd582ca92805525a05654e39bb12653a6a8902a16e651ba7b687b36b8bea7186632c7e9e3 -83e9b33e29b57ae53d9f72bd4622ff388252333b4fa32ad360a5b00f3ffc8813b9cb8a1361454d3bb7156c01b94b6a08 -ad7d6bffe4d67eb53b58daa3fc8a5a60790c54fa42226ae12847e94c6de3b4365b3be39855a4f6a5f12e4803cdaed96b -a7709fed85abbee5a2fa49c5238582ec565da08c132d4912821491985bf83b681eb4823634bfe826abd63a6c41a64ea7 -b8fb6ed55741132a1053b6ca77bdf892e96b048488373ba4aa2f2225fae6d578724124eb6975e7518e2bf3d25d215763 -85e0c53089529a09b5bce50f5760af6aeafef9395388aa4b6144ca59953169101783347ee46264ec0163713a25fe7c63 -8f9e47a9c37b678e56c92b38d5b4dab05defc6b9c35b05e28431d54b1d69ac31878c82c1357d016f3e57ca07d82d9c16 -a81f508136ee6ec9122c48584df51637f768ccfe8a0b812af02b122a0fafa9abcc24778bf54143abb79eccebbdde2aac -931a96d2257a4714d1ef20ac0704438481632647b993467e806b1acc4a381cc5a9dec257e63239ba285deb79f92122dd -99fb0ff747bcd44b512bf8a963b3183ce3f0e825a7b92ddd179253e65942a79494a515c0c0bc9345db136b774b0a76b0 -a9dbb940b5f8ab92f2d85fc5999e982e3d990fe9df247cfc6f3a3f8934fb7b70e2d0362ba3a71edc5d0b039db2a5f705 -99011a1e2670b1b142ec68b276ff6b38c1687eed310a79e2b902065bc798618c0cdee7b2009ad49623ed7ae0aa2b5219 -9361e9f3aa859c07924c49f3d6e9b5d39a3df2fc1c10769202ec812955d7d3814c9e6982f4df3a8f3bdbfb4550cd1819 -a8aa23f177ddc1e7a7856da3eac559791d8b3f188c0b3ae7021bcb35dfb72b0f043c3699597a9188200408bc3daf6ab7 -a5a502ff673f6dab7ae4591a7b550c04ede22a45a960c6b5499644f721c62b12b9e08248e7f8b8a59a740b058d2a67e6 -ad374f80f0b52bc5a9491f79a547ce5e4a3ce4468a35d7dbca8a64083af35ab38eff9aa774ccba2e2e1e006e45cb0b85 -ab6851827125e3f869e2b7671a80e2dff3d2d01ce5bfbeb36cbaf30c3d974a2d36fd9f7c3d331bb96d24b33dbd21f307 -96658f6a2d225a82f7ccee7f7a7e476967e31a0cd6c62859d3b13ee89702bb821547f70ffd31cb46a6a0d26a93158883 -878f59ff2590bc3d44fdc674717589800748b78d543d3c0dbb50125b1d6011d6a083f10ab396e36b79f2d89b7cf51cdd -b8bdfb97829c5d973a15172bfe4cb39620af148d496900969bd7ca35de9b0e98eec87af4e20bef1022e5fb6c73952aa0 -a292a78b452743998aee099f5a0b075e88762222da7a10398761030ffcc01128138d0f32fccf3296fcbea4f07b398b5f -85da44fdd7b852a766f66ba8804ed53e1fc54d282f9a6410106c45626df5a4380cbea2b76677fdfde32446a4d313742a -84bebf036073d121e11abc6180cba440465c6eaadc9a0c0853a5f1418f534d21cccf0cfc62533eaeae4653c7b4988046 -923dec006a6af04ef675f5351afffffd2c62a17a98f4144221927c69f4553dd105e4fcc2227b5f493653d758cd7d0352 -a51eda64f4a4410a1cfa080d1f8598e23b59856436eb20a241e11106989fbbb48f14c2251f608cbf9531c7c442b30bf7 -ac6d26ae7bab22d49b7fba7fe4b8cf6d70617977008c8290787c9da1a4759c17c5e441efb3dee706d5d64d9d2ace1de5 -ab5138b94d23c1bf920b2fb54039e8a3c41960a0fe6173261a5503da11ff7b3afdb43204f84a99e99888618a017aac1b -8c85647a91e652190eee4e98a1eec13a09a33f6532926427bf09e038f487e483f7930fbe6ff7a2126ccde989690dc668 -a6026ab87cffec3e47b4c9673957d670cb48c9b968d2ad0e3d624d81c1082dcebbc70d0815cbd0325e0a900d703a6909 -ac4f6ff6baf8374a3c62bdd5a8d207d184ff993f6055bcee1e6dcc54173d756c37c24570d6462395add6f7871d60b1ae -a0dd6bc93930d0016557588f2598b7462ca48cbed637c8190be0fb4811e4576217ca9fc3c669c2a4db82e3f8bb24acaf -a67c1d79f7e7193a23e42928a5cc6a6e8e0c48b6b286607dbcfaaa0f10a7ba29ad62d1d57ca28c486794f0908bece29c -822f411bab4882202ed24e67c84e0c9a8da5b3389804ed9dfba0f672e3e1457ea76cad0cb935dbb3d7a39500fba5fe12 -8a1198572323689300a9d7db2e2bcb7c519392e5d3d33e83cd64bcf1517a7dde52318a98203727b186597702c0eed258 -8a84141b02f1d037c68d92567d71cda3a0b805d1e200b1d3fff3caf9902457cbfbaac33157b87ab0bb9e4fe3bac882c3 -8070ace16d9eef8658fdcf21bed0d6938f948f31ca9d40b8bdb97fc20432cd2a7ef78eeefc991a87eae7f8c81adf9b19 -9522e7123b733ce9ca58ab364509f308a1ead0915421ccede48071a983fd102e81e1634ffa07a9e03766f167f5c7cb5e -82cbdf97a755e952304f5a933fd4d74a3038009f242dac149595439130a815e9cc0065597c0b362130183a4c4a444173 -81e904f9b65cd7049c75f64c7261e0cbb0cc15961ffcac063d09399d0d2b0553b19e7c233aca0f209f90cf50c7f5e0b2 -8f5f6ea87429542ea04ad3eb5fc7eeb28fcf69c01c1a5d29b0de219524f6fba90c26069bfc9092379fe18cb46274393a -a4e5815481eb33b7990d2de1a3a591c1ab545b64fbeb4cff8c71b6bcb04d28940097899062bf43b27c5a8f899616703e -a7afe6066681e312882b3b181f462a1af2139d9bd2aefffae7976f3fc357bfd8fbd6ddd4e5e321412f107736e77f0cb6 -b8ab102d7ff8d46b055095d8fb0ec2f658c9e18eee523c295b148b37f8342c120798113553b8bfebf2a11f27bc704cc4 -862175ecc7e0e294c304a0352cd0f1d11b2603d326bb0e54e02b6cc8d04d01ac31c8864e9395aa1f3b90b76bc4397f5b -a4ea51ef3d82509f0e4eb6af705fa7530921cf9512cb5bf030571e69f4504a299297219a0a7e40db1b45165a5ea3a3f2 -a6fb8b573e2ba6db0e8aba53a489e99bebe533c0fcd947dbfa732e00594f03f4e8609ccc44d8215986d38bc3d4e55d48 -93fe8e0bdd5d66df2bd18be5963e864bddfcdcd3298590e7c3b11d99a070a4948fecef46453f19960bbfeada37979613 -acbc45bc55c7080b45c69a3db80cbfc0267006dcf49c47330975aeff2a8ac07b206e1b1c3a515e50866ff510739b92c0 -94a577df0983e4ee3d6b80c73d7e8e3bb78bd8390ff56fea350e51bdf5e0176b8494e7e81dc7b1d842ada961089cd1eb -81eb1fbe9e9c89f5818d0ef98e694da86e88625f0a37cfe88e6de69f90e58297e67f1d5c9d71263b523b63e42685975a -a81a2391ea4d0f65ab4325196559d67e2648b3f1e464509430b40d9948d5b0fc01c337d9b51048a93c4d62e6b73e1e8c -849a026e55ed77135138836c9df67883763e4602357d8566da2ee2505d135d44061de0c070cf333ffb9ac2e55a0894b2 -8e272cc5734374c003c7b2e6ba833eb99b6be608da04e576df471c24705b6b2a790549c53e7971df2d9f0b88d0f570c6 -b0f9e6d985064aa311d4a147f41007fdc576b7b9194aa4b8712bf59a76a71543fec2ee3db21bd3d30d4096f25babc543 -96331837f0d74e2ba6cb1bfaddf4b1fb359bf46cb6c3c664938eb030e56bc85a5ce17bcd60b7fa7b72cb0ba1f3af0b5b -a0eaab6de4b5a551896e7d26153fb5df4bc22a37833ec864090b57b5115b0f8f1279e855cea456bb844802b294b0dbb7 -955e87d3b966edff34f28137f871881c59bbbc6d69986b739867807680ca22b5e3272ced1d25854ed9700d87f133848b -9270a6db157a8ce78a1af6bfe2b5bbe7b621d56cc8f9940a03b5a5f600848b87b05d83595b2a3a315d4b7f4687c46085 -9043328f2dd4dd85e14c91237a3478dc1eed239164924b53d1de9364d76c81315afa9639b58eedb1ab2122e2ae2e7cfb -857fe9f7d00b03bce367de7f789d755911a5f85d78044f18311ecd9b955e821b4a50228347260ba1205aef61219001fe -a0f878050367a7103fddf380908da66058ef4430eae1758335c46c24f5c22fefb0753991b3a47dba5c7eaafa4d598178 -ab5959296b1af14d2878816c7da9926484cbf8896b7eeac8a99dc255013319a67a0209025e1f8266ffd8cd7d960bdc87 -abe53abc57ea46419dbe0ac1f39eee39a4feae265e58b50928eb0695e25938a16a8b00e65c1313837dc3367297e2c258 -93e3e42ed6ba9c45d4e7a4bf21c1e469efafded1f3be9931a683dbb780db2494742fd76c9ad29fd7d12da2b778ede543 -ab3e64035c488a6e63496ddb2de9648cc63a670c5d4b610c187d8ceb144fcc50b016046f50b10e93b82937ebe932ac08 -a3a8fa898f489b313d31838ad9f0c7ffe62ef7155de5da9ffe6ecd49a984fac3c6763e8cb64e675e1c4a0e45e7daf078 -8356b26aa7c9fc9734b511480dad07b164cfec1324ad98eec9839a7943f2889d37c188d465515ad4e47c23df641c18c3 -83c4476f829e0fe91da2353d5b58091e9335157941e89ca60ccab1d7fdd014bcf21bd55249805780ddc655c5c8c2536e -814f6e66505b2cb36de92c0de8004d6d094476522e66b9537787beff8f71a1381ed9f2b7d86778979ad016a7dae6cbac -b1cd7f6da4a625b82bea475442f65d1caa881b0f7ce0d37d4b12134d3f1beb3ad4c2f25f352811e618c446185486adb6 -a71b918481b9bda667de0533292d81396853a3b7e2504edd63904400511f1a29891564d0091409f1de61276d2aebc12a -a2cd3d4104ec5fb6d75f5f34762d5e7d2ff0b261bea5f40a00deec08fbdab730721231a214e4df9b47685d5bacfe37c6 -807f2d9de1399093bf284814bc4093f448f56a9bde0169407cdc0e7d2a34ff45052aef18bcb92f0ac7a0a5e54bd843e9 -abeb03010c3ac38587be2547890a8476dd166ac7b2a92c50d442f031eaf273ad97114c38e57fe76d662c3e615334ac0b -b90a688da4b0bf65ff01bcf8699f0cba995b3397fcbe472e876ae1091a294463e4b94350ae8bd5c63b8441089e0884fd -ad88db4afb177931788fb08eff187e15ad739edc7e1a14c8b777b6bf668aec69ca4749773f94250c1fdda3b59f705f7c -9886809f9ae952797c6527c6db297d2aa3d5209b360efe6a19970575a9f78aee3c21daadb8e8dfcbeeea5290238d16d9 -930f486e95d7c053c9742e6f0b31e6d4fa2187e41229e46a074b469aafb87880aa8e972719b363049fc9fe2db8f03ce2 -8d229af4fa08bd8aeb5fd9acfee47571eb03fcd2f19073b94cd27e2a6735029d31f123249d557f8d20c32ac881eae3aa -84576ed5aebe3a9c3449243a25247628993fdb2cc327072418ea2f1d11342756e56e9a82449bc3ea6e8eaecabc62e9b5 -b775cb86cbec9c46a4a93d426379c62872c85dd08bccda39b21cb471222b85b93afd34a53337b6d258f4891c6458e502 -8be1540e6b535b416b8d21e3ecf67dfb27a10fd4010f9f19426422edaeb0a4961d43ff3afd1db0994170056ce4d77aec -b9c7438e90a5501a4d05bbb8ab68d6db7e9baa8927231a5c58715ee2ab76ca1da0e94910a076958654869148d813d0e9 -aa9bed1c4d2e7cbc2e1a884c8998773f7cc6fa9d6493c8abe8b425114a48305c3a43a1abda2292177ffd39ef02db4163 -897b395356047cd86f576cfc050f7e4546ecd4df30b2c31ed8945797b81dd4ed9b9106cfbe6d7dd8bf91882e3cf1f42e -949a37e1037d9464b2ccd3ad23eda7089570d6b5ffa18025d2548a9df8829de8d62960f04a603f21eecbca5893d45284 -b8a0642f68ff169ffbcd8cd684fae75d96f9bd76949472775bf155edc55a3d9c3e6f0299ee73a6cfb96289361fdbe9ee -a1273141510fcddd89b9b92c19a268dadd1528ad85744b8174684c9b56668e6b35dabb05f2b4cc6ef5611eaea6052f27 -97c7415c82de83ecc066eb922268b8205ad7266c65b2b8f7e0aadac87f076c738cea72f9b0f069b8d28cf9d5438b8287 -b32c7005380c848f71092a74297555dc6022369fc2a4f285e586ac8f53f6bd354fbe4b1f8a4cfb406a101103bf87bb64 -91b48eeba52f02d04f536d32112038f8ba70bb34284fbb39e0f7bae2e08b3f45ad32e2f55d1beae94b949c15652d06a1 -99e24f5ea378cb816a4436af2ee7891ac78a2e37c72590be0abd619244a190fee51fc701b6c1c073611b412cb76332c9 -9465d1e73a1a0a5f7b1cd85f4fa4f5dee008b622b14d228d5cd5baeec174451e7ae93c5de688393d37cc24ce15df4139 -a6ac3986ee01debdacb5ddc1e2550cb4f039156df15c7d5752b79f333175b840bdca89c4959a523e58cf97bbd6b2039e -b7f7a5cc1b1b6145988170d619c170c130231abbe0b5143a9bccaaebeef9ceb1c16e26749bc9dc5650fe91f92fa1b79b -854cb04f1557457383a401d79a655adfd0a4b706ea2bbc6262949c8d657efcfdc9c7960cbe1a50b5eebb361c5e378f80 -8dd199dccbdc85aeca9ddcb5a78dd741a452f7a0d3ceb6546d76624bad2fce0e7e6c47ee30d60bf773f18d98503e7f9c -889e1ca9f0582be9bf5f1aede6a7312b30ea9bed45ab02d87182a013430f16007ae477ee6a823ae86c7fef7da016a0ec -892a60e63edfb3e7a6cf2d0be184413d214401fc1e6c004ca2902c3f1423728bf759a136e6e715d26d5bb229c75cc20a -a2287cd092261b39d22dcb1fa19512590b244771bb69fb62eda72f12be37d48e408b3e37a47608f68d743834edee7f15 -b3b6afb950bbec0ff631bdf18af433e68adc63d02cb479704f24329ca6b6edd9a3d1d606563dbdce6038b676b85130b9 -847da90f37b294509de51ab6521fdff12d5a1ec3cccaf730aa744da7e54b85fd9c70618787e87c0ba9947ce6c81387fb -ad872153c00bccac75bdb30d1ab7044d814f4f8655ff26421d48fea04fb21d4dc82c1900620a57d13adc45c1062a1817 -90fa5ee98fd7ec719f2a8543bbd0ff45ac69296c2416fc8666d05de3deea1017079a68aba55540a19585925803c8335d -962ba6d029e9176d0e8c80a21f2413f7322f22a9e9a32c933697a8b0e995ce25bea5264736a75718b3d330e215a58a05 -a446f9530db30c5e9c1b3844d635e5c2cd311cc4537ff277fe83dd1a0382bcfa73beb07aaa0cf5a97d24c67e688086a4 -8766b2053f16c72db387abe18b43d7b357a542916c9b8d530ee264e921c999494d6eb1e491352ecdf53758640c7a246d -83f32f511f7b0233662acfc14f30df345af99d2d6c777ce0b4bcdc4dd110533f30b45071df17230aaec392cc482355e1 -82e3521bc9519b36f0cc020225586b263e4feb57b533b38d8e89ccf8d03f301d94da90efb4902002732fbf3876697f38 -b5d1ea69c97ceaa34a720bb67af3fcf0c24293df37a5f6d06268b1eabe441531606954ac2598a1513f64231af722b3a3 -956842696b411e6221c5064e6f16739e731497e074326ef9517b095671f52a19e792d93fe1b99b5a99a5dc29782a5deb -b19b5658e55c279eb4b0c19a0807865858cbec1255acd621f6d60c7e9c50e5d3ee57da76b133580899a97c09f1dd8dac -89e6a8b916d3fcc8607790e5da7e391f6bc9eae44cc7665eb326a230b02bc4eb4ef66e608ccc6031048fc682529833d0 -b1a210bc8070ed68b79debd0ec8f24ec5241457b2d79fd651e5d12ceb7920e0136c3e0260bc75c7ff23a470da90d8de9 -85b1954278e2c69007ad3ab9be663ad23ae37c8e7fa9bc8bd64143184d51aea913a25b954471b8badc9e49078146f5ac -98bf63c7a4b200f3ce6bf99e98543925bc02659dc76dfedebe91ec5c8877d1271973a6e75dad1d56c54d5844617313e1 -b7404b6e0f320889e2a0a9c3c8238b918b5eb37bcdab6925c9c8865e22192ba9be2b7d408e1ea921a71af3f4d46806d0 -b73cbbebf1d89801aa838475be27c15b901f27d1052072d8317dcae630ab2af0986e56e755431f1c93f96cd249f2c564 -95b2027302f7f536e009f8a63018da6c91ec2b2733c07f526cc34cbcfa2f895ccfd3cc70be89f4e92c63c7ddc2a93370 -9201d9ff5d0b1222bfa2345394f88ddf4fe9282acf51bee9b18b96bb724fdf8e736d7101acc2795a34e72f9e0545c9a8 -acbff7eb160f427d8de6f29feeddfa8994674e033a0ccdc8e8c73f9243968f1a6379da670a7340f422892d50c97113c7 -97ae8d03352c3729e1623e680dd9664f303b3bcfb844ef80d21e9c773a247967d27b86c9326af29db5eefd0bd3d4fac8 -8e53ae5c22f5bfa5fe4c414dad6a10b28a3e5b82a22e24a94e50ce3b2bf41af31e7ba017d2968811c179017b78741ef0 -b5ac7dd150247eb63dfb7dd28f64b1bf14426dc3c95c941e8e92750c206c4c7f4ad1a6b89e777cfe26ecb680dbf0acb6 -99ae2e4652ea1c1c695e7ea2022fd35bd72b1a0d145c0b050da1be48ad781a413dc20fbda1b0b538881d4421e7609286 -b8abe1fb3a7443f19cd8b687a45e68364842fc8c23d5af5ec85da41d73afb6840ef4b160d022b2dad1a75456d809e80b -842619c3547e44db805127c462f5964551f296a270ed2b922e271f9dc1074fdf1c5e45bb31686cec55cb816d77853c01 -902dff769391de4e241a98c3ed759436e018e82b2c50b57147552bb94baddd1f66530915555e45404df9e7101b20e607 -82e4f2ee7c7ca1ee8f38afa295d884e0629a509c909a5464eb9ea6b2d089205478120eed7b6049b077b2df685ec8ba48 -aa21a68b0888e4a98b919002a7e71e6876b4eb42227858bf48c82daf664c3870df49e4d5f6363c05878a9a00a0bcf178 -a8420cd71b1d8edd11ebc6a52ba7fc82da87dd0a1af386d5471b8b5362c4f42718338bcbc302d53794204a0a06b0671d -98c686bd3a994668fbbd80c472eed8aedd3ab5aa730c8d3ce72e63fb70742e58525437be1f260b7ecc6d9d18a43356a0 -aca0b2df9ec8ede0b72f03b121cded5387d9f472b8c1f3a5f1badd5879fb2d5d0bbb6af1a2dd6bdebf758cfceadbe61d -93b1abd9cb41da1422d171b4dbf6fbcb5421189c48e85c9b8492d0597838f5845198494c13032e631c32456054598e1d -a246ab3a47f7dc5caedc26c6c2f0f3f303ed24188844ab67a3da1e793d64c7c7fe3e5cc46efafbd791b751e71de0614c -b9b52095ca98f1f07f3b0f568dd8462b4056c7350c449aa6ce10e5e8e313c2516ac4b303a4fc521fe51faf9bf7766ce9 -8e2e9d26036e847c2a2e4ba25706a465ac9fbb27804a243e3f1da15dd4084f184e37808661ec929479d3c735555085ee -8b8c4f4ad5c8e57e6a7c55d70ef643083d4b8dac02716ea476d02dbbb16c702a2f2d5dd5efe3aec7704d2b8cdafe3959 -a800afea30d0df333805d295bac25419b7049d70044be00c7c85a92a0503ca471001bc1e6552323f1a719eb96616fc20 -868bced4560e1495b8527058ebc82a538b7cf806f8d8fe8eeed6981aba771de4d5e9f03cbfc7157d38b9f99cdea87b96 -86b86258b0c1feb988cc79f6c4d4b458ff39428eda292f9608a5fc4c3765782c8c23c66f82d7538e78e092cd81d69a56 -9370eac15de2555824c7d48520a678316a7bb672e66f8115ad7dbc7c7b1f35a7718e8fa0c35f37e3ef2df32dfa7ca8d1 -ae200bc5be0c1c8c6ec8e9fd28b4d256c6f806c0f270766099e191e256d67b9cceda2cc2fed46dfa2d410971a7408993 -af2428c77b2b9887ecde1ea835ed53c04891547fb79fe92e92f9c6009cdfffa0cb14de390532ad0ef81348b91798bd47 -a9069eef0316a5d13d1aa4cef0cf9431518f99b916c8d734bd27b789828ae03e5870837163ea6ad0be67c69184b31e8d -b1b1ce6d529f5a8f80728173b2f873c8357f29644b00f619c15111224377ae31a2efb98f7e0c06f5f868030aab78ed52 -b89c98beef19ee7f300e1c332a91569618ef8bf2c1d3de284fc393d45f036e2335d54917c762f7c2874a03fe4f0f6926 -8264f993dceb202f8426339183157e9e0e026d4e935efe4cf957eb14cd53edcdc866305fb1334cdf0e819b69eafbaccf -aebd113f73210b11f5ac75b474f70a2005e5c349345003989175dffa19f168abd7f0e28125b18907502fff6fcc6f769b -9993ad061066ca6c2bb29fe258a645089184c5a5a2ef22c811352749a199be3a3af3a0d5ce963febf20b7d9e63508139 -97952105000c6fc6c2dcae1ebdb2feae64f578d26a5523807d88e6caf1fe944b8185e49222d06a4553b3bdb48c3267a2 -82dd955f208957d74693bed78d479c9663f7d911f68ff033929418eb4a5c5dc467589ca210c1ba3c2e37d18f04afe887 -b816fc4763d4c8a1d64a549c4ef22918e045ea25fa394272c7e8a46dcb0c84d843d323a68cc3b2ef47a5bbb11b3913bc -a7a87ba4d12a60ee459aad306309b66b935d0c6115a5d62a8738482f89e4f80d533c7bba8503e0d53e9e11a7fd5fe72b -92b36d8fa2fdee71b7eea62a5cc739be518d0ecf5056f93e30b8169c3729a6a7ed3aa44c329aa1990809142e0e5e2b15 -8835b6cf207b4499529a9034997d2d3bc2054e35937038deb9c3e2f729ebd97125f111c12816d30b716b397016133c52 -acf14cd6d978ba905cf33b9839b386958b7a262b41cbd15e0d3a9d4ef191fcc598c5ab5681cf63bc722fe8acfda25ce6 -b31302881969c5b283c6df90971f4fb2cc8b9a5da8073662da4029f7977fbb4aaa57dd95b003a9e509c817b739f964e7 -b74669e1c3fa7f435e15b5e81f40de6cfb4ad252fcdfb29862724b0a540f373d6e26c3d600471c7421b60a1d43dbeb0f -861d01615cba6ca4e4ef86b8b90f37fa9a4cc65cef25d12370f7e3313b33bb75de0953c8e69972b3c2a54fe110f2a520 -a58a56820efaf9572fd0f487542aaff37171d5db4a5d25bfb1a5c36ca975eb5df3cb3f427589e1101494abb96b5e4031 -af13d0a6869ef95cb8025367c0a12350800c6bc4ae5b5856dcb0a3ca495211d4139f30a8682d848cb7c05c14ae9f48cb -8c385767d49ba85b25a3a00026dd6a3052e09cd28809d5a1374edf4f02dc1beed367055b0dee09102c85985492b90333 -b5129fc2fec76711449f0fcb057f9cf65add01b254900c425e89b593b8d395fc53bb0a83ddbd3166acc6d2c17f7fc2a4 -86bd01b3417d192341518ad4abf1b59190d9c1829041e6f621068bce0bef77ec3b86875b7803cf84ff93c053c2e9aad1 -a74fc276f6af05348b5fabccb03179540858e55594eb8d42417788438c574784919fb6297460f698bd0da31ce84cebfc -967ed3ec9f1fc51f76f07b956e1568d597f59840ef899472a3138f8af4b4c90861e23690c56b7db536f4dd477f23add6 -b9e678206de4fc1437c62d63814d65f3496be25a7a452e53d719981d09c7e3cae75e6475f00474e7c8a589e2e0c6bfa3 -b028eaffaa4ff2b1b508886ff13c522d0b6881998e60e06b83abe2ac1b69f036eece3ded0f95e9ae721aea02efff17b6 -935f82de9be578c12de99707af6905c04c30a993a70e20c7e9dd2088c05660e361942fa3099db14f55a73097bfd32a44 -96a1cc133997d6420a45555611af8bcd09a4c7dbddf11dbe65aab7688cc5a397485596c21d67d1c60aae9d840f2d8e48 -80d117b25aa1a78e5d92ea50e8f1e932d632d8b37bebf444dcc76cc409322fb8eface74a5dddab101e793ff0a31f0a53 -893229136d5ab555dc3217fb4e8c6d785b5e97a306cdaa62f98c95bad7b5558ed43e9a62a87af39630a1563abd56ec54 -b7ec1973ec60bd61d34201a7f8f7d89d2bc468c8edc772a0ba4b886785f4dadc979e23d37b9f7ef3ff7d2101d3aa8947 -b6080ca201d99205a90953b50fc0d1bd5efd5eadbfe5014db2aeb2e1874d645ab152fb4b0ff836f691b013b98ce7c010 -b546e66ec0c39037bbaa66b2b3f4704a6a72cf1924a561550564b6fcf41fbc2930e708cd5cac1d05e12a4b8ec93ff7eb -8abeed90a01477260f4b09fff8fa00e93afe727e8eed6f111d225c872a67e6ab61d0472ab6add3fe987744e16f7c5268 -8e02342d5cc1836ed21834b9ef81686172cc730f0412479db5f590b0ff7a729a0e986ffed16d6ecafd6b83d65922ca5e -b05660605cf8e8a10c8d3c77cccbe4e7179fa27cc829571f6b722a58e65e4e44d7fe977446118e9da2d2f40af146cc2d -942a00e006baba6d025cbd99297bdb0cbf3d84cddf849b1b5a9fe9ef1745352fad81313cce5d7622d6652096a8fa065c -aace8212b3d8dbe44ac97460a5938a3b803aca9bd00d8a643a859351daf391b22d1fd2a6b3e0ff83cc9ee272a1ad7686 -965a9885a5259197a75a19707a2f040e0fd62505e00e35ebe5041d8467596752aedf0b7ec12111689eceb3e2e01ecfc8 -81d58270a4e7ee0137cb2bf559c78c4fd5b3a613468a8157b6a9c5c0b6ca20a071b87c127d59cecc3d0359237a66d890 -af92b6354fbf35674abf005cb109edc5d95845e3d84b968e6001c4b83d548715dffc6723ac754c45a5ace8cd7dd30a24 -b112caa707f9be48fdde27f1649149d9456857f928ea73e05b64bb62d597801daac0b89165fea76074f8b5770043f673 -b6e7380746da358fc429f676b3d800341e7ab3f9072c271310626ae7f67b62562ff76c63bc9f5a1dbc0e0af87752408a -a45e9e8d0931207ebc75199aa0c983134aa97f771ff546a94a3367bcedf14486f761e7f572cf112e8c412018995fdaf4 -854381128de5bfb79c67b3820f3005555f3ee6f1200046ebbfaee4b61b3b80a9cebf059c363a76b601ff574b8dbf0e6b -aa1b828a8b015d7c879669d5b729709f20a2614be6af6ff43b9c09b031f725f15b30cde63521edda6cd4cf9e4ab4b840 -8f28f6b62c744084eeddcb756eced786c33725f0f255e5999af32b81d6c6506a3f83b99a46c68fc822643339fe1b91c5 -ac584e76a74cafe4298ca4954c5189ccc0cc92840c42f557c40e65a173ea2a5cd4ae9d9f9b4211c9e3dfd6471fc03a1b -a413365df01db91e6a9933d52ab3e5ed22d7f36a5585ad6054e96753b832e363484fb388c82d808d1e4dfb77f836eab9 -8a68c51006d45bf1454a6c48a2923a6dbeb04bd78b720bb6921a3ca64c007043937498557f0a157262aac906f84f9bf8 -b93ff8b6c8c569cc90ee00cfe2fc3c23cccea2d69cbca98a4007554878311635cb3b6582f91636006c47b97e989fe53d -b9a8a44d54592511d74c92f6a64d4a8c539a1d8949916ef3773e544f6f72c19a79577de9878433bd35bb5f14d92f411d -94f066a7e49ae88d497893e4ce6d34edc2dc0b42fe03934da5d4ed264d1620d506fcc0661faa90a6cf5083e1720beaaf -b42b102adef8f42c1059b5ca90fe3524dcd633cf49893b04b4a97a1b932ca4c7f305cebd89f466d5c79e246bad9c5ced -86b560d78d3c5fb24a81317c32912b92f6ea644e9bedfdea224a2f0e069f87d59e6680b36c18b3b955c43c52f0a9d040 -a3829fa7e017c934fa999779c50618c6fb5eafb5e6dec0183f7254708a275c94ba6d2226c5ca0c0c357b2f2b053eea93 -9337dda730076da88798fd50faed1efa062f7936a8879ea4658c41d4fcf18cee7120366100d574536e71f2f11271b574 -853d09a30f4342f5a84c4758e4f55517a9c878b9b3f8f19e1362be9ae85ca0d79c2d4a1c0c14f5eff86010ad21476a7a -b0bc74cb69bdd8fdffca647979e693ad5cbf12a9f4ead139162fa3263bfebef3d085aab424ed8c6220b655228c63c6b1 -88d8dc8faf3aab12ba7180550e6a047f00d63798775b038e4a43a3b40a421a3f5f152a7e09f28ccd7198bb8cefc40c07 -88db2e3b8746415d0c3e9f5706eda69a29d0b9ee5135ad006060be7787f4f1f7069e2e2e693c5e10b7c3d5a949085ae0 -b5bd830d2f1c722188dba2690d21b7b84b92cbdd873a55aaa966f1d08d217bfc8cffe8caea68868f3850b90b4ab68439 -b5ad4be0c9626a33fce6c8501297bdde21b07b88531451912ed41971a4c48fdd1036d8a4994a99a7fbba4a5901a7095e -b0e1337a2a1772191faa91302f1e562e7cdc69ba5b25139e7728ce778a68a7fa9817f852ec8e04a159122cff62992ec6 -b4fd4a4c1be8bc7e4e2bfd45404c35d65b75f45fb19ce55c213a8035b41f1ccbce9766f3df687c0d7cd6cdfc1abb00a5 -814bf565ece6e9e2a094ffbd101f0b9fea7f315a2f4917abe2bf7d070ed8c64a2987bd288385a42fd336ed0a70a9d132 -af860af861dc80894ed69f29c8601d986917ec4add3d3f7c933a5e9d540bc8ff8e4e79d0bb01bbc08fa19ef062f2890c -b66d33fcf3cd28f15111960ffc6ed032c3b33d4bb53d035ab460cc5fa7ce78872f0476d0bb13f1d38f2672347d2d6c4d -89603ae1a5dd7c526936b86a3b69b7b1d0bdf79ba3cc9cc2e542ec801a6126d1514c075d6ad119fe6b6e95544ffe7fbe -8a1b097f46a62d85cff354d1e38df19a9619875aad055cc6313fdb17e2866d8f837a369a9ee56d4f57995e2b0a94310e -8dc165d86c7f80b0fcd4b6f90d96cd11dc62e61d4aae27594e661d5b08ef6c91156c749de8948adfaf3265b1d13e21cf -98e3173772c3b083b728040b8e0ee01dc717b74c48b79669dd9d2f7da207af64ccd7e9244bc21438a5d4ac79b88e9822 -924d168099b6952d6fe615355851f2b474f6edfcd6a4bd3ad2972e6e45c31bf0a7fb6f7fca5879a0de3ea99830cfb5bc -95452f0b7efda93c9e7a99348e13f356bad4350f60fcd246a8f2aa5f595a9505d05ec9f88b1fe01b90ecd781027b9856 -b95e8af516bb0941fc0767ecd651ada2bc64cc3e5c67a1f70048c634260c0f2c0e55ed22948e1870c54590b36683a977 -82f7feb71e746d5ca24455e3f3e57e4eade92669ab043e877b836612efd3de82009f0555e5d8811bff9f2b75fc57a01d -87623c02caf590ea84cf4a84d1be501f89262e26eb463f2f94a2d3042889c051b058823c3367a989498e46ff25edab16 -b88da847b1ef74c66f923773ce8c920ca89751335fde17b3a98c0603862069a2afbf35b1552b43ad64dccea69f040ff8 -96b734758c823e5ce5b44625c252957e16fa09f87f869baac195956052dc92f933f377b288c7f63b8028751cbbdca609 -a23cc5fbbe5cb7c1d33d433cec4e502f6548412e2374e285d307f75e98280b0c0af4f46bba18015be88cdf7db8b1239c -8bd5bbe04bc929ca8f546e673803ec79602f66ec24298d3e3b6bf6f2c25180fc0032ea6f86c38a6e0ec20ff4eaafc7a1 -b95768ca113e5d57ad887a1cb5ef84ce89007ce34c3156cd80b9aa891f3ebaa52b74c0cb42919cfbcf0cb8bafa8085f9 -a117f99045f65e88acc5a14fc944f8363f466e4a64057eb8fc64569da5dd022a01f2860c8e21b16aff98aebdf89461b7 -895cda6503907c98c43477eaf71dfd26759032523691659f13662ca3a967d93bbc5be342d168223cef7e8a333987d6a0 -a084d77d913d3ec0586ad5df2647610c7ed1f592e06a4993a5914f41994a29c4a8492d9dce2e14d8130c872d20722920 -84a328b73c64137bb97a0a289b56b12060fa186ce178f46fe96648402f1b6a97d1c6c7b75321e4b546046c726add5a08 -b7c35087b2c95127ce1470d97bceb8d873a7ad11a8034cc1cba7b60d56f7e882fc06796048435a9586eab25880787804 -ab05e3394375ee617c39c25c0ec76e8a7f2381954650c94fbcd11063ea6772c1823c693d2d9dd18bd540a130d7b92855 -82ba5907051d84b37fd9d28f8b9abebc41fc4aaa334570516ca2e848846644016356d40fa9314543017d4f710d193901 -9170517b6e23ee2b87ff7c930cb02b3e6bd8e2ae446107b5b19e269bf88f08de5ded3d81a2ff71b632ca8b8f933253a0 -93dc0e3f6234b756cdbb3fe473b9214e970972e6bf70803f4e2bf25b195b60075177a1a16382f1dee612a4758aa076ee -b4b49fac49cdfccda33db991994a8e26ab97366545166cc7140aef3d965529f96a5dac14d038191af4fb9beb020ff6d5 -b826537670acdf7a8a45ef4a422d5ae5a1b5416ad0b938307518d103cc7ba78e495ea200adc5941414a70158a366e8a2 -8ae3588b1fbecbc769c761f0390d888e34773cf521d976ee335f6c813bf06dad38850871ac8a8e16528684f1e093d0c1 -ad9c00b8dccdb545315fbf26849135699c6aa3735f89581244281154c906aba80d20c1e7f18f41acc61e0565f8015a33 -954ce68146c05fc1c9e536add3d4f702335d93c1650b8c1fad893722a81f915eee2d38275dad00ce87f3f5bc90ef7341 -8243feaeff9a12f5aeb782e3dd68609ce04ecde897c90fd8a19c9c5dace3cf43bd5bc0f1624bf7fd2607ca0d71adbba8 -a8a1be55259cd27898d9d60a61998d8da2bf2d439ba6eedb61d6d16dacc4a81ec706b9196dfa080ba20701d2cd9fa1f4 -b0eac6212c7a62ef6062c30875fbe24b8e1a9d88854c035686f849a9eed4d17fbc9af27429eb7c3fd60b47a5e29f6783 -878561a88412e95f19f1cb8894be9d0ea4a2cdd44f343387f87dd37445e5777bceb643cebc68c910acb5e588c509cd2e -a57b6c347955d8b0057a87494223148ff9ff12b88e79dbd9d0aae352fe55e15ea57fcfb9add3d5d269ee0001d8660f20 -a07fa66340d4082585e4d72c77510c59b272e7a3345f4b1de6be7ff4a11ea95d712d035a7355fc8d2e571fa65fe8236f -b9d84a627462438e8ede6c453e3367bfaf81cff199d3e5157ef2bc582d358b28b5ccc3bc27bb73af98ef45179ea79caf -b14f26ea7ca558761cb19508e5940fbf5dcf2ad8555c5a03e8ff92481994072f523b1ab6b7176f698e2cfd83d4f8caad -800cca1cbb14e1fc230c7b420ff06864a934b082321bbf5b71f37340383923f23183d4fdc8fa2913928722b8892db28e -94790c950b92e971ec39e9396c3f32dee32a8275d78e6ea28a47130651bddc86a189ef404c5e8c210bd291186dee0df4 -ad7b3b3e377df64023b8726d43a7b6ec81e5a5e8c0943c5bebe5ab5ddd6597255f434a205c14ba90e9e5e3c462a1fe0c -86ff8156cc857a416e735009cf656b89da59b766b4c4e5a0c0165282b530c10657cc28cf5cb847696725c37ac48b69d7 -89cb64cf9294f68f01533660a2af2aec0ec34cc0b4a0cc36a128f2e0efb3da244981f69aede962f50590faeeb9a5da01 -a2ea5a94a524bb8e6f767017246cd1af9d87c9abb9894e91c4e90c34c5161be6179b49dafcab9cff877a522c76beb145 -b5d9abf29ed6030a1e0f9dc19be416c45ba8cb5ed21aff5492233e114035715d77405d574cd62f2716285e49f79b9c99 -ac441cf6104473420babdfb74c76459cbea901f56938723de7ad3c2d3fadb0c47f19c8d9cb15a3ff374e01480b78a813 -abea34bd2d36c5c15f6f1cdd906eb887f0dd89726279925dbe20546609178afd7c37676c1db9687bc7c7ea794516af03 -8140abfd0ec5ca60ef21ad1f9aabbb41c4198bac0198cb4d220e8d26864eedb77af438349a89ca4c3ff0f732709d41a9 -a5a25abf69f3acd7745facb275d85df23e0f1f4104e7a3d2d533c0b98af80477a26ac3cf5a73117db8954d08f9c67222 -b45ac8d221a7e726ad2233ba66f46e83ed7d84dbe68182a00a0cf10020b6d4872f3707d90a6da85f6440c093914c4efa -80f586dfd0ceaa8844441c3337195ba5392c1c655403a1d6375f441e89d86ce678b207be5698c120166999576611b157 -b8ce52089e687d77408d69f2d1e4f160a640778466489d93b0ec4281db68564b544ec1228b5ab03e518a12a365915e49 -8990f80bae5f61542cc07cb625d988800954aa6d3b2af1997415f35bd12d3602071503b9483c27db4197f0f1f84a97ac -8329858a37285249d37225b44b68e4e70efeef45f889d2d62de4e60bd89dde32e98e40e2422f7908e244f5bd4ffc9fe2 -8d70c66ea780c68735283ed8832dc10b99d3daeb18329c8a44a99611a3f49542e215bf4066ff4232d36ad72f1a17ccc3 -a3b2676cc8cdf4cc9e38c6cb8482c088e5e422163357da3b7586a3768030f851ad2a138eeb31584845be9ffb8067fc00 -95b1fa74e9f429c26d84a8e3c500c943c585ad8df3ce3aea1f6ab3d6c5d0ed8bb8fa5c2e50dd395fa8d4d40e30f26947 -b1185f2ac7ada67b63a06d2aa42c4970ca8ef4233d4f87c8ffa14a712a211b1ffde0752916bfafdfa739be30e39af15d -8705a8f86db7c4ecd3fd8cc42dd8c9844eab06b27d66809dc1e893ece07186c57b615eab957a623a7cf3283ddc880107 -af6356b372f0280658744c355051f38ff086f5563491fc1b3b1c22cfec41d5c42b47762baeb9ee6c2d9be59efd21d2b7 -86bdd4527b6fe79872740d399bc2ebf6c92c423f629cdfcd5ece58e8ed86e797378a2485ead87cbb5e2f91ba7b3fbda1 -a900f0be1785b7f1fda90b8aedd17172d389c55907f01c2dfb9da07c4dc4743cb385e94f1b0fc907dd0fedb6c52e0979 -a9f59f79829a9e3d9a591e4408eaec68782c30bc148d16eb6ae2efccb0e5478830bbdaa4ae6eac1f1088e7de2a60f542 -99cf54a69ad5e8c8ec2c67880900e0202bcc90c9815531d66de8866c0a06489ea750745cc3e3aa1c4d5cb55dcd1e88f7 -8676246a4710d6d73066f23078e09b3fa19411af067258e0b8790456525c02081727b585d6f428c8be285da4aa775a4b -b596c7014fe9214529c8e6b7602f501f796b545b8c70dbf3d47acc88e2f5afd65dccef2ef01010df31f03653566b16df -a12205c6c1780fc8aebdd98611e12180005b57750d40210b9eff0396d06023bd4ff7e45f36777123ff8bed7c5f52e7a3 -ae7dbd435bba81685d5eab9abc806e620253da83e56b4170952852d442648a5d8743f494a4b0fc9d606574f87895b0d6 -9786257b1726b7cdc85219ca9eec415f98f5a11e78027c67c7b38f36f29fe7a56443570fdfedc1d9293a50e4c89d89f6 -aaf0515070d1ca92aacdf5fac84193d98473d8eb2592381f391b8599bcd7503dbf23055324399d84f75b4278a601c8b2 -b31654dbf62fbbe24db4055f750f43b47f199a2f03c4d5b7155645276b2e456a218ca133743fb29d6f1a711977323f6e -8f4d39106ecdca55c1122346bdaaac7f3589d0cf0897a6b4b69e14b4d60550fd017876399401ce7c5d35f27da95f50be -8a7bfdb48cd47afe94aff705fac65f260b3a3359223cff159b4135565c04b544dd889f6c9a6686f417e6081ad01e0685 -967ba91111e5e08f9befcbaad031c4fb193776320989f8ede4018254be0e94586254432d3dbae1455014f3a2f2549d01 -a9db52352feeb76715a35c8bed49fb3a8774c9c8e58838febf800285fd6c4938ec162eb8457029e6984d8397dc79ea19 -811794e6bfe2539e8f6d5397c6058876e9e30763ad20dad942bb5dbcab2f16d51718ce52bfb4de17889ba91da1b85bcd -a6db0f65a6dc8b8cc2312a3e0146d8daf520255bb12f74874c05693914e64e92be0cd53d479c72cb2591e7725dfaf8b0 -918d21bfa06d166e9eb5b7875c600663a0f19cc88c8e14412319d7aa982e3365f2dff79c09c915fc45013f6b3a21200d -9894852b7d5d7f8d335dd5f0f3d455b98f1525ad896fdd54c020eeaf52824cc0277ecbfa242001070dc83368e219b76d -ad00acc47080c31fcc17566b29b9f1f19ccaae9e85a312a8dcc0340965c4db17e6c8bd085b327eaf867f72966bf61452 -965e74649e35696744ecc8bed1589700bae9ca83978966f602cf4d9518074a9aa7c29bc81d36e868a0161293f5a96e95 -961e29a239c2e0e0999b834e430b8edfe481eb024cc54ffaffd14edaf4b8522e6350dc32039465badfff90dcb2ba31cc -943dda8fa8237418a07e311efde8353c56dd8ec0bfa04889ccdd7faa3dee527e316fdc60d433a3b75a3e36ca2aa9d441 -a0ed4c102e3f1d6ebf52e85a2bc863c1af2f55dc48eb94e40066f96964e4d37fff86db2cff55a8d43d517e47d49b5bd7 -9045770ad4e81345bc6d9a10853ee131232bf5634ef4931b0e4ba56161585b4286876bc8a49b7b1f458d768718cb8ebf -b0dd430295ff28f81895fde7e96809630d1360009bbe555e3ac10962de217d93ead55a99fd4f84d8cadd1e8d86d7b7ef -95ced48419b870ea4d478a2c8db699b94292f03303f1bf4560b5b1e49ca9b47e7008514fe0a9cf785717f3824567e1b2 -a7986e0e389e8aef6aac4a7a95e2440a9af877ae2bc5ad4c5f29d198ec66aa0db1d58c451e76ae70275a2e44c3d3fa68 -85a8490faf32d15de12d6794c47cc48e02428af1e32205e0742f8299ea96b64bcd6d3b4655272afa595eec74ecbb047c -b790d7fb1307aacc2d303d9b6753a9773252b66c6b67763cf8841c690cbccc4866ffb5fec1c068b97601a7953fe0f7e8 -afcc4011f8c53f10d63c29b74d9779cd75c861e01974c28a4ec2cbb909b67a1b2287ead175231343c936ad75dfa416ff -918058bffdecc1ae8779dccf1d874bb9e28edbe34c8b5954a8da64a848858d2f0776437b423baf4e731f3f5fa05a2841 -ab554db549aa36dfa9f966a5ed6be8267e3aa9ced348695f3dafc96333c6dbb48ef031693aafd59d1b746ecd11a89c51 -ac4ecf746b46b26a7af49cc9cc1d381e1e49b538dbd7fb773ce6b1df63ae31c916693cca8a90fb89f1e7ec5e0e8dd467 -a8de66d48f16b016f780a25ba25bd6338fd8895a1909aabcfb6e70f04ff66f9866e6e2a339bcbfa4bfba4070a6a8db26 -b4b49374eff6dac622e49b0e9c0e334ecbec513a96297f6369696ad39e5ec0de81a1417f6544be866c9f60957a9ba09a -b8023968549ebab6c1e7a8e82954a5b213bec50bbf35b36697a8d4fd75f9e12d510b365962aace4c9978c5b04da974a7 -8d4bc016026dd19e4059d1c5784897cefa47f7ae2ed6dfa2b3c14a852fff2b64abc09549d106584e0daed861a2d6d6c2 -85e26f433d0b657a53da4c1353485e0c2efa092484c5b8adb3f63dc72ee00be79197ebef7937b37a6a006571641cd6af -abb37a917301e68328032ff4715abc0fee32e5f5be68232ca8bf7ffb8732bc47504e75b40bcc0a7c7720b71496fa80af -9837c8d2660522c0357f5222777559d40321a1377f89ca1717215195bad4a348a14764bd87fa75f08e1f6263e9d08982 -97e06f971b4c56408ed5f1de621d233e6a91c797f96ec912737be29352760a58831aaf1f64e377c3ed9f2f4dc8ad1adb -a12d211304da7b91101513d57a557b2504069b4383db8ecb88aa91e9e66e46e8139dadc1270620c0982103bc89666215 -aab74ba48991c728ba65213e8c769e6824c594a31a9b73804e53d0fda9429403ff3d9f6ea5ef60884585d46356c87390 -92f19be2b7adf031f73611282ad33e462852f778c5e072f689dd0e9458fa6ebccfae02f2b2dc021802c9225035862468 -953bb843c48d722604576cef297123755cef8daa648c30c3a678eada8718dfdb16e71cc3e042a51fedc80577235c2563 -86f509e3c1b9ee9a3b95e6da8516b47feb8c8a83403984228f4903c7ee1ee4f03addcb8fe86283af1196a54b36b9470c -903d793a377e98e2562c49de33e3fbf84bf99211925e7002a4f688470db655884e1efe92782bf970ffa55d9c418ef3b5 -a41b65681ed7f10987a7bfdf9e56b010d53683819d845d880fc21b2d525540605c5823e75c434f17b5a0d08a091c1564 -971be802de51cfc0d10a96be7977c037873f19334ed4ed4904b7675aec8bfa1f8956cd0150b07064caf18229ffd1ccd9 -b253ebe4f82cdbefbc3ef816d40c497fe426a9f0f0f170e783fa4a05ae6dabdfa8c448817a24e723a314b43e76a7c422 -86f397c95025489929ce9230b1466b5c330ec7c58a3c7e3153d6d05bcb8348a13398908e192590b8812f5c5ff09c133a -a0713983a3dc9f10b3833687cd2575de2fc63c4ad8d2f54ff85c6db23dd308daefef1bd1e51eec26732f77c1f37ba793 -8249a1d53ec92f311f4fa77e777800d777f3e9d4d452df740fc767fa7b0f36c8dce603d6e6e25f464c0399b8d0b93c30 -a73d0a206a62922f07b928501940d415e5a95716ee23bf6625b01ff2cd303f777adfa373d70279ba8a30fbb4c99a6f1f -b1106b407ecf234e73b95ff58ac9fdf6709ad2e763b58f0aacc5d41790226d441b5d41405ac03a0641f577848a4f5e8e -b009963ccc7b2d42792f09ab7cb0e929503dd1438f33b953104b4de43274ca3ce051554d10d7b37041b6f47d7a2dab6f -b744512a1b3c7ef9180b095c6a0c5bc16086a50020cf20dc2216bbff24d91ca99b95cb73070444dafc3ab45c3598960d -a0209669ffeddc074d35cc6aa2dac53acac8e870f8a8a5118e734482245b70c3175f760652e792118fdddac028642259 -8ddd3e0d313da17292fdcc1bbc6e9d81189bb1d768411c6fe99801975eddb48dbf76699dcf785cac20ab2d48e392c8fd -8392aa285b8b734aa7a6e0f5a1850b631ddf6315922e39314916e627e7078065d705ff63adbc85e281d214ec7567863e -b655a1fff4dba544a068bf944e9de35eaaa6c9a0672d193c23926776c82bebed8aa6c07c074b352882136b17abdab04b -af5095f40d1e345b3d37bebee3eb48c5d7b0547f12c030d5bfe8c0285943e0a7a53a186f33f791decba6a416cba0c5c9 -8223527f9eb3c8ff52708613cd2ee47e64c0da039cea3a0189b211dc25e9bfa3d5367a137f024abe94f98722e5c14b67 -afdb106d279273edc1ee43b4eead697f73cb0d291388f7e3fc70f0dd06513e20cc88b32056567dcc9d05364cb9ca8c58 -9319eac79ff22a2d538dcd451d69bca8aa8e639979b0d1b60d494809dbd184a60e92ad03b889037a1ac29a5547423070 -b79191ce22dbd356044e1777b6373b2d9d55d02b2cc23167642bc26d5f29fd9e2fb67dce5bd5cf81a602c3243bedd55c -988e0da1e96188ffd7c5460ecdf2321f07bc539d61c74a3292c34cb8c56dbafbca23eb4471a61e8e64e9a771a49fd967 -b0792b6cf4b10f8af89d3401c91c9833736616bb9fe1367b5f561c09d8911fb5a43b7a4fd808927b33ab06e82dd37a28 -862f68ea55206023ca470dbd08b69f0f785fcbabb575a1306ff3453c98ffcad5fd6ead42e8a1f9edf14c6fd165ffd63a -815ff0898b1330ac70610180c0f909561877888ff10def749a1e65edf9f4f7cea710a757c85241dfb13d0031efb5e54b -aa6e6ce21776ea4507d452ccdaf43a161a63687aae1cb009d340c9200e5646e9c2de4104dfd66b8e55dfa6de6ee83e4a -8e8f3d3403e0256ecc254b9b1464edca199cad3f3348002d744721c345a1a3c7f257c3587d2229774cd395e26693d1ba -90483e28985e4a0f7a3cb4bc5e865b9d408b94cd2146c04aed00b48a7ab80a28deb05efec320817d63578d4f953bd137 -84fb2a762ba29193b07f1dd84b3f69153cedb679b66ad04f8a4adf01c14f115163a107e6db23aaf0f0c9687824ded197 -b4a23922bf4302cc9a6583f252a1afa026c87c132b9ae44cc1f75a972cb6ae473447c500827906f9b677617ddd6fb473 -809bb9edbbe3a2769165f029f2a48b6e10e833eb55d8f9107c4a09ca71f0986dc28f3bf4ead9cab498086eb54c626bbf -a0459dbb08db4155d16301933ec03df77c4f835db2aa3f9697eeb2bb6fcd03337fab45fa43372a469fecc9a8be2e3119 -a638eaace7f21854de49f4db6e4ea83d2983751645e0fb200c5e56561f599fd37dac70bdbd36566fdd10d4114fbb9c2f -a3a27bc2728390643a524521bf8ef3b6437cfba6febfd8bb54f2b6ecbafafb96196d3dea279ce782efd97b212f364ef5 -b86693b3ea23ea6b2c4d52554f61ef39c0ef57e514ff6da80c6e54395df8376e2e96b9d50e4ec301c59e022c5c5610db -af4d7cd678d79e67ae19789d43331dff99346cd18efff7bab68f6170c111598d32837372e3afe3e881fd1e984648483e -b8735a555ba7fe294e7adc471145276b6525de31cda8c75aae39182915129025fb572ed10c51392e93c114f3a71bd0be -b1dfb6dbda4e0faaa90fe0154f4ddaf68ee7da19b03daad1356a8550fca78a7354a58e00adeecb364e2fd475f8242c24 -9044b73c1bd19cd8bb46d778214d047f5dd89b99b42466431b661279220af5c50c0cffecebd2b64c3d0847a9c7a8b1ec -891f0d162651a0aa0d68fb1cc39fa8d77fd9f41ff98b5d6c056c969c4bac05ba8c52cbfa7fbb6ef9adfe44543a6ec416 -8920ae1d5ac05bf4be6aba843e9fc1bc5b109817381cdd9aa13df53cabea319a34ee122dcb32086d880b20900ff28239 -abb14023142876cbc9301336dced18c7878daa830070b5515ff4ac87b7bf358aa7ff129ebbf6fb78e827570a4142661f -a74b15e178cf91cde56eab0332e62d5ff84c05fcc849b86f45f94d7978bf9c0fc72a04f24d092a9d795ca3d976467f46 -806829621a908ca9b6433f04557a305814a95d91c13152dca221e4c56bfaa3473d8bb1bacd66e5095a53070f85954278 -b09a3c185e93869aa266a0593456a5d70587712bca81983dbc9eebbb0bd4b9108a38ae1643020ecf60c39c55bb3ac062 -b2bbe8f5361a3ecdb19598dd02e85a4c4c87e009f66fee980b4819a75d61f0a5c5e0bdc882830606cb89554ef1f90ead -825e16cb54fc2e378187aedae84a037e32903467ac022deb302cf4142da3eda3ead5b9f3e188d44f004824a3b5d94fbe -8b39d4a11d9b8ba885d36bcdb6446b41da12cfd66cb22705be05ab86936464716954360cc403f8a0fd3db6d8b301cb59 -ac19d453106c9121b856c4b327ddb3e3112b3af04793df13f02d760842b93d1b1fbdff5734edc38e53103a6e429a1d1f -b1cacbb965ec563f9e07d669ffc5e84d4149f1fb9fcfbc505788c073578c8f67956fb8f603e0b9a9d65e2d41803038ce -b7612d9e7dc930bff29191d1503feb2d6451b368b69fa8ecb06353c959967daccdc262a963f01c7fb95496f1bd50d92e -93f8fceb65ea9ef2052fa8113fb6720c94f0fed3432d89014ee5ad16260aeb428aadea0d1f1e002d2f670612ba565da3 -b3eb9213752156ed1fced3bca151fd0c630554215c808b9a0938b55fed42b6b89f9b76bc698f3e37c3c348d2395dbed1 -b46ab3553ef172ae40fc21c51d1d7eab8599a67f2f89a32a971aa52c2f031664e268b976dd2f7dc2195458fcf4bf3860 -8fb66f2c67ca5b6fb371c7d04592385a15df0c343857ba8037fe2aa9f2a5d4abc1058323ff9652653261b1c7db0edc24 -a7dfdbbf0b14e4af70fdb017875cdc36ad2108f90deb30bfca49301c92cbf821645a00ade1d1ee59a1a55a346675c904 -856199cad25ec80ee0327869077f272e33d59bf2af66c972e4a5839ec3b2a689e16f7fd0a03a3138bec458fcff8edbea -a2842ac5a715c2f48394988c6f84a6644c567673806feaa575838e906138c1b25d699e1b6ffdfc9be850b15da34077e4 -814b448ada88f769de33054c3c19f988226317797acacdbe55ed2485b52cd259ac5bcbee13f9de057eee33930a7fa0c0 -b49de8dd90da916ed374ca42665464b6abe89ff4453168921f5a7e5ddd3dcfa69422782e389e586e531fd78a1f236a8b -851f9d942b4c8ffc020c02c7fbee0f65ef42b1ab210ab4668a3db6aa0f8ab9eedb16f6fd739a542cc7e3cc03172b565b -a5128c155b8062d7fa0117412f43a6fdc2de98fa5628e1f5fc1175de0fa49fc52d015ec0aff228f060628268359e299c -b0765849127cc4ce1a1668011556367d22ce46027aa3056f741c7869287abcaccf0da726a5781a03964a9ded1febf67d -984562c64f3338ffe82f840c6a98a3dc958113f7ed28ee085af6890bbc0cd025723543a126df86f379e9c4771bb69c17 -8087fe60a9a22a4333f6fbe7d070b372c428d8c5df3804bb874b6035e5602c0693757fb30a9cd5a86684b5bca6737106 -a15e195b5850f7d45674cdc3bd74f972768b46fe9473182498263edc401745a8716fc532df8fc8c1375e39e391019226 -858ec10208c14a67c4156ea9c147f36d36c4fa0a232195b647e976ba82c8e16262b2b68d31e3b4702070c3dc701bccb5 -84bf3fb83c003380ee1158e2d6b1dca75cd14c7b2a32aec89d901f0d79e1475aa0827cb07cba1784a6bb0d37f6ca5cd4 -91e69f5392648e7f7c698059a0fc4b8478ab8af166d3842fb382ec5c396daa082ee3b2cb0192da3c9d90f6523c4c039d -8f7299f451c5e641d6fd961946b7a6ba4755685b2a40164e6276c25aefc66715b92492097a191813d39bb4405dc5da36 -ade2cf04ff6c94c1019bfa1e0e8f580696230fa6ee9695c4772e5a44501b2fffdd765ec7cc71ba14b83559ad62cc0fc5 -85fc98ecf469d6f98c8b3e441680816f764de39001a249bc7162f990c5a5354683e849164d4fc9287ee516780cdcd436 -928d118188120d038c37abdbe66c05adaa87f1cf9957dee2783b09fa91c4c43a7b0d0b2b6c5f4dea57e3ec8af230e84f -8025f71cf8d3085d6ea5104dddea8fa66cdb8527e40db01472469be021632daf22721f4acf1a8698a53439fe2f82596c -83266fffb12b3c795a6b551ac2aa7d9a29c183f861e78768c11286a04e22bd423bba05a68775bd77273e3ca316a4318e -95fd0c69c2d9df4e795c7ba71ed71a9d9f2878cd7e3a64be7b671d9611649fd41d29f8bdab642ba19cbd3db660d6a7e7 -92a912cb4d5ef4b639876daf4289500c4ebdbd80aff07fd93dc3eea645f084f910e5c02c10492a37f16acaa7e646d073 -b3d2622c987189a0873932aaea8b92ebb6e9e67ff46e91a96bf733c3b84175fffe950f8f4622cc4fa50f116321c5537f -a98f9a40054b31023a8f7549a44cae853b379bbfe673c815b8726e43ecd11a96db40b20369d712cbf72ffab064ecfac5 -b4e9a38e371fc21f4b8a3d7ad173c9ffad0554530dc053365d9555ddb60f5c9063c72ff4c65d78b091af631a9e1ee430 -875a31aee4ba19e09f8c2754fab0b5530ec283c7861a4858b239a12432f09ef155a35fedb0bc33eac2117c7e62f1c7ee -95edd0d1a6e94af718590756b5c5f5492f1c3441ecc7fa22f4e37f4ec256b9fffd2fda4c11fc1a7c220daee096eb1ff8 -b35fdc435adc73e15c5aaf4e2eea795f9e590d3e3ee4066cafa9c489ee5917466c2a4c897a186b2d27b848c8a65fa8a8 -94a5ce56f8d72ec4d0f480cb8f03e52b22f7d43f949a4b50d4a688a928ffd2c9074ecbab37733c0c30759204a54f9a6a -987562d78ef42228c56074193f80de1b5a9ed625dd7c4c7df3bf5096e7d7b08e2ee864bd12d2ea563e24fa20ad4d30ef -95a8218405038c991ace2f45980dbb1efa9e4ad0d8153486b0213a89e4d7e3cac6d607100660784627c74f90a8e55482 -b6a29d566f5a924355b7f7912f55140e1b5f99f983c614b8a92814ce261f2750e8db178866651ea3b461fb8f92890b14 -afdacc0a13da0446a92455f57a42b3ba27ba707f24171727aa974d05143fae219de9e2eb7c857235dd9c7568f43be5a8 -862a7dc25f7cfa4a09aeca0ed2c9c5ee66189e119e226720b19344e231981504e37bca179aa7cad238ee3ab1386aa722 -a336364e76635f188e544613a47a85978073f1686e4ee7a8987f54da91c4193540ac448b91d07d1fc5c7a8538b1f1688 -8f1ddca9638decd8247c1ce49c1e6cf494d03d91c4f33e48a84452d12b6736e8bd18c157068dfeff3a90977af19e5b1e -96ae91b9aaf00e437c18ddfc1aef2113ee278153ba090aedeb3f48f1e66feb8897bb1ac7f5ffeffc3be29376dd51e498 -8230b5bd9067efb6089e50213f1cc84da892e6faf0b79d5e4768c29303a80b1b754cb09d17a21933aba4c5f32070878a -a79dfe217faec7b4d3cf97d8363949efbc6f3d2c6bbc25df2c7bb8b7fd2521e6d3fa76672bfc06de6f426290d0b3cc45 -8290bd36552609d6b3ac9ccb57ff8668fc8290548eecdcee9a231f1125298c20bd8e60f033214dfbd42cd3c8642c699b -8945db9e8ec437c5145add028d25936ee8823ceb300a959402d262232ae0cbd9a64c1f0a1be6aed15ff152202ea9a70c -949e232b48adeaf57bd38eacb035267d3e78333c6b4524cab86651a428a730baf9c27ff42cb172526d925de863132e82 -98917e7a5073a9c93a526399bb74af71c76958a74619caccf47949f8fd25962810a19e399b4efcba0c550c371bea3676 -b5b144e0707aefc853ea5570bd78dedc4e690cf29edc9413080f28335ac78022139bfe7f7d6986eb1f76872bb91e82ad -949945072a08de6fd5838e9d2c3dc3200d048b5d21183020240fa13e71a1a8d30e6bfee4e6895e91d87b92f1444d0589 -b351a03c7c98506ee92d7fb9476065839baa8ed8ac1dc250f5a095c0d4c8abcfab62690d29d001f0862672da29721f16 -a82d81c136bc5e418d1fba614cb40a11f39dc526e66a8b1d7609f42fea4c02b63196315014400084f31f62c24b177cbd -87d51c907fdcdf528d01291b28adfee1e5b6221c6da68fd92ab66126247cd8086a6bcffff0ea17e7b57b0ba8d01bb95d -a2a9a1a91dfd918f36c1bfeeca705ea8e926ee012f8c18d633e50ec6e50f68f3380ef2ee839e5a43cf80fbb75bfb5304 -86f22616caed13c9e9cd5568175b6b0a6a463f9a15c301b8766feca593efa6e5ee4c7066e1cd61b407c0be12b3d8236a -b57e0a2c42790d2fd0207ef6476a433fca0cf213d70840c4af1ad45833f23fca082d21a484f78af447a19a0b068ea55c -8ae9bda5d85e6e3600dde26379b7270abd088678098506b72196ac8f9ce5b0173bc9c7ff245c95cbab5b5b967bcb043b -95c7d11f6c874f59ba632b63ce07a7a9d917a74d0b89cefa043f52aa1a7fe2e81c38dea0b20378264b5b4f64039932bc -ac7dee7479f50722526ea1c9d4e2f1a4578d1b5cce2092a07722069c96bb4da295de1c4f16e21005276e3b3f1624ac5a -89b8aaa49bd18b09f78fc5a1f3dd85d69b5dfcff28fc6d5a92b1520bc54107b8b71bb71fd6e0bde10e0a5809c633e5d2 -8982cb43fe4d3488c55e8c08b935e6c8d31bb57e4f2aeb76d6319470cce99ebf7dc2f116ac15b9d845ab1bc16aa6a583 -a12c63f48e27b1a1c83a32992642f37fb5b89851a35e80f6d1f9bc483cb25acd0e12b1dcf68781ae0cc861f002368bcb -aa6da92a4b4fa229afc8007abca257ce0ff5fad3b1ccfe5d836b9b52ff6b72575a0b915a759403b993733b16a47fdb15 -8bf706a92fe54f15d633b9463926b874dd43e28aaeca3fe2353fb58ad7753c8a293c56b0e94176070e8a9ec7401073a1 -b81e86de4bb5c1046e40cca79585c5b98c8673626fd3a28e563c5a3296256c2f7086522ae95cbabfaa8f1a8f7eae6272 -ad10f895b05d35cb251f78cc042d3f0969a8b6b3f289ddb4b016e0b8e06bfffc3a3e1afa9b0cc548f8c092832bb766bc -ad993aceb68d5217cfb07f862956cde83d05dec5060fc7a8fbfd37c6bfd5429ba69bdaf478b6cd01c323a06793dcd9fa -83da9c9a8fcb2775df0777aceabe90642a2df1c6abc646566e954f42d6e43455b00b101ec5ef58850c8d4b3100222ca1 -b55484f339fe7c7d107e70432601f4a34e1cc02ae4de5d18b99e5aa995f7b3710fc745769b85c1af803d457491dd8ce3 -8009d80593e82f3e751cec9e7e495fd29ad6f45f8d3ae513bec998b43c49fed74c44229c6f27c421e80c65413b897644 -9868081bbcc71192f7ff8dcf99a91dcd40f96556fbd6f285bdbfdfc785f604d8bf75c368c59db5ac8cdcc663087db53a -a04b1e91af025b4387ee0a2d790a1afb842e46f4c3717e355578efd1f84fea78782c6f7944b4961268de7f1ac71fb92b -a7b6301ddb9738b89b28a36d29d5323264a78d93d369f57ddab4cea399c36018a1fcc2cc1bfadf956a775124ae2925bd -a6cdb469014b33c590a07a728ce48f15f17c027eb92055e1858a1f9805c8deb58491a471aaa765de86a6bda62a18aef4 -828a23280ec67384a8846376378896037bd0cb5a6927ff9422fca266ee10a6fde5b95d963a4acfa92efbb0309cdb17b4 -b498ec16bcdb50091647ae02d199d70c783d7c91348a1354661b1c42bc1266e5a5309b542ef5fdf5281d426819a671cb -806533fb603e78b63598ff390375eebe5b68380640f5e020e89a5430037db2e519ab8ae5d0d0ad3fa041921c098448e1 -9104ad119681c54cdee19f0db92ebfe1da2fa6bef4177f5a383df84512d1b0af5cbe7baf6a93ad4b89138cd51c7c5838 -ac695cde30d021d9f4f295109890c4013f7e213d2150c9d5c85a36d4abfdca4cdc88faee9891e927a82fc204b988dcd9 -a311c244df546d5dc76eccb91fe4c47055fc9d222d310b974d4c067923a29e7a7f6d5a88bfef72fd6d317471f80d5c82 -89e4518335240479ad041a0915fc4f1afaab660bd4033c5d09c6707f0cc963eb2e6872cabc4a02169893943be7f847d4 -a8ad395b784c83aacf133de50d6b23bd63b4f245bb9e180c11f568faca4c897f8dbda73335ef0f80a8cb548a0c3c48fc +a0413c0dcafec6dbc9f47d66785cf1e8c981044f7d13cfe3e4fcbb71b5408dfde6312493cb3c1d30516cb3ca88c03654 +8b997fb25730d661918371bb41f2a6e899cac23f04fc5365800b75433c0a953250e15e7a98fb5ca5cc56a8cd34c20c57 +83302852db89424d5699f3f157e79e91dc1380f8d5895c5a772bb4ea3a5928e7c26c07db6775203ce33e62a114adaa99 +a759c48b7e4a685e735c01e5aa6ef9c248705001f470f9ad856cd87806983e917a8742a3bd5ee27db8d76080269b7c83 +967f8dc45ebc3be14c8705f43249a30ff48e96205fb02ae28daeab47b72eb3f45df0625928582aa1eb4368381c33e127 +a418eb1e9fb84cb32b370610f56f3cb470706a40ac5a47c411c464299c45c91f25b63ae3fcd623172aa0f273c0526c13 +8f44e3f0387293bc7931e978165abbaed08f53acd72a0a23ac85f6da0091196b886233bcee5b4a194db02f3d5a9b3f78 +97173434b336be73c89412a6d70d416e170ea355bf1956c32d464090b107c090ef2d4e1a467a5632fbc332eeb679bf2d +a24052ad8d55ad04bc5d951f78e14213435681594110fd18173482609d5019105b8045182d53ffce4fc29fc8810516c1 +b950768136b260277590b5bec3f56bbc2f7a8bc383d44ce8600e85bf8cf19f479898bcc999d96dfbd2001ede01d94949 +92ab8077871037bd3b57b95cbb9fb10eb11efde9191690dcac655356986fd02841d8fdb25396faa0feadfe3f50baf56d +a79b096dff98038ac30f91112dd14b78f8ad428268af36d20c292e2b3b6d9ed4fb28480bb04e465071cc67d05786b6d1 +b9ff71461328f370ce68bf591aa7fb13027044f42a575517f3319e2be4aa4843fa281e756d0aa5645428d6dfa857cef2 +8d765808c00b3543ff182e2d159c38ae174b12d1314da88ea08e13bd9d1c37184cb515e6bf6420531b5d41767987d7ce +b8c9a837d20c3b53e6f578e4a257bb7ef8fc43178614ec2a154915b267ad2be135981d01ed2ee1b5fbd9d9bb27f0800a +a9773d92cf23f65f98ef68f6cf95c72b53d0683af2f9bf886bb9036e4a38184b1131b26fd24397910b494fbef856f3aa +b41ebe38962d112da4a01bf101cb248d808fbd50aaf749fc7c151cf332032eb3e3bdbd716db899724b734d392f26c412 +90fbb030167fb47dcc13d604a726c0339418567c1d287d1d87423fa0cb92eec3455fbb46bcbe2e697144a2d3972142e4 +b11d298bd167464b35fb923520d14832bd9ed50ed841bf6d7618424fd6f3699190af21759e351b89142d355952149da1 +8bc36066f69dc89f7c4d1e58d67497675050c6aa002244cebd9fc957ec5e364c46bab4735ea3db02b73b3ca43c96e019 +ab7ab92c5d4d773068e485aa5831941ebd63db7118674ca38089635f3b4186833af2455a6fb9ed2b745df53b3ce96727 +af191ca3089892cb943cd97cf11a51f38e38bd9be50844a4e8da99f27e305e876f9ed4ab0628e8ae3939066b7d34a15f +a3204c1747feabc2c11339a542195e7cb6628fd3964f846e71e2e3f2d6bb379a5e51700682ea1844eba12756adb13216 +903a29883846b7c50c15968b20e30c471aeac07b872c40a4d19eb1a42da18b649d5bbfde4b4cf6225d215a461b0deb6d +8e6e9c15ffbf1e16e5865a5fef7ed751dc81957a9757b535cb38b649e1098cda25d42381dc4f776778573cdf90c3e6e0 +a8f6dd26100b512a8c96c52e00715c4b2cb9ac457f17aed8ffe1cf1ea524068fe5a1ddf218149845fc1417b789ecfc98 +a5b0ffc819451ea639cfd1c18cbc9365cc79368d3b2e736c0ae54eba2f0801e6eb0ee14a5f373f4a70ca463bdb696c09 +879f91ccd56a1b9736fbfd20d8747354da743fb121f0e308a0d298ff0d9344431890e41da66b5009af3f442c636b4f43 +81bf3a2d9755e206b515a508ac4d1109bf933c282a46a4ae4a1b4cb4a94e1d23642fad6bd452428845afa155742ade7e +8de778d4742f945df40004964e165592f9c6b1946263adcdd5a88b00244bda46c7bb49098c8eb6b3d97a0dd46148a8ca +b7a57b21d13121907ee28c5c1f80ee2e3e83a3135a8101e933cf57171209a96173ff5037f5af606e9fd6d066de6ed693 +b0877d1963fd9200414a38753dffd9f23a10eb3198912790d7eddbc9f6b477019d52ddd4ebdcb9f60818db076938a5a9 +88da2d7a6611bc16adc55fc1c377480c828aba4496c645e3efe0e1a67f333c05a0307f7f1d2df8ac013602c655c6e209 +95719eb02e8a9dede1a888c656a778b1c69b7716fbe3d1538fe8afd4a1bc972183c7d32aa7d6073376f7701df80116d8 +8e8a1ca971f2444b35af3376e85dccda3abb8e8e11d095d0a4c37628dfe5d3e043a377c3de68289ef142e4308e9941a0 +b720caaff02f6d798ac84c4f527203e823ff685869e3943c979e388e1c34c3f77f5c242c6daa7e3b30e511aab917b866 +86040d55809afeec10e315d1ad950d269d37cfee8c144cd8dd4126459e3b15a53b3e68df5981df3c2346d23c7b4baaf4 +82d8cabf13ab853db0377504f0aec00dba3a5cd3119787e8ad378ddf2c40b022ecfc67c642b7acc8c1e3dd03ab50993e +b8d873927936719d2484cd03a6687d65697e17dcf4f0d5aed6f5e4750f52ef2133d4645894e7ebfc4ef6ce6788d404c8 +b1235594dbb15b674a419ff2b2deb644ad2a93791ca05af402823f87114483d6aa1689b7a9bea0f547ad12fe270e4344 +a53fda86571b0651f5affb74312551a082fffc0385cfd24c1d779985b72a5b1cf7c78b42b4f7e51e77055f8e5e915b00 +b579adcfd9c6ef916a5a999e77a0cb21d378c4ea67e13b7c58709d5da23a56c2e54218691fc4ac39a4a3d74f88cc31f7 +ab79e584011713e8a2f583e483a91a0c2a40771b77d91475825b5acbea82db4262132901cb3e4a108c46d7c9ee217a4e +a0fe58ea9eb982d7654c8aaf9366230578fc1362f6faae0594f8b9e659bcb405dff4aac0c7888bbe07f614ecf0d800a6 +867e50e74281f28ecd4925560e2e7a6f8911b135557b688254623acce0dbc41e23ac3e706a184a45d54c586edc416eb0 +89f81b61adda20ea9d0b387a36d0ab073dc7c7cbff518501962038be19867042f11fcc7ff78096e5d3b68c6d8dc04d9b +a58ee91bb556d43cf01f1398c5811f76dc0f11efdd569eed9ef178b3b0715e122060ec8f945b4dbf6eebfa2b90af6fa6 +ac460be540f4c840def2eef19fc754a9af34608d107cbadb53334cf194cc91138d53b9538fcd0ec970b5d4aa455b224a +b09b91f929de52c09d48ca0893be6eb44e2f5210a6c394689dc1f7729d4be4e11d0474b178e80cea8c2ac0d081f0e811 +8d37a442a76b06a02a4e64c2504aea72c8b9b020ab7bcc94580fe2b9603c7c50d7b1e9d70d2a7daea19c68667e8f8c31 +a9838d4c4e3f3a0075a952cf7dd623307ec633fcc81a7cf9e52e66c31780de33dbb3d74c320dc7f0a4b72f7a49949515 +a44766b6251af458fe4f5f9ed1e02950f35703520b8656f09fc42d9a2d38a700c11a7c8a0436ac2e5e9f053d0bb8ff91 +ad78d9481c840f5202546bea0d13c776826feb8b1b7c72e83d99a947622f0bf38a4208551c4c41beb1270d7792075457 +b619ffa8733b470039451e224b777845021e8dc1125f247a4ff2476cc774657d0ff9c5279da841fc1236047de9d81c60 +af760b0a30a1d6af3bc5cd6686f396bd41779aeeb6e0d70a09349bd5da17ca2e7965afc5c8ec22744198fbe3f02fb331 +a0cc209abdb768b589fcb7b376b6e1cac07743288c95a1cf1a0354b47f0cf91fca78a75c1fcafa6f5926d6c379116608 +864add673c89c41c754eeb3cd8dcff5cdde1d739fce65c30e474a082bb5d813cba6412e61154ce88fdb6c12c5d9be35b +b091443b0ce279327dc37cb484e9a5b69b257a714ce21895d67539172f95ffa326903747b64a3649e99aea7bb10d03f7 +a8c452b8c4ca8e0a61942a8e08e28f17fb0ef4c5b018b4e6d1a64038280afa2bf1169202f05f14af24a06ca72f448ccd +a23c24721d18bc48d5dcf70effcbef89a7ae24e67158d70ae1d8169ee75d9a051d34b14e9cf06488bac324fe58549f26 +92a730e30eb5f3231feb85f6720489dbb1afd42c43f05a1610c6b3c67bb949ec8fde507e924498f4ffc646f7b07d9123 +8dbe5abf4031ec9ba6bb06d1a47dd1121fb9e03b652804069250967fd5e9577d0039e233441b7f837a7c9d67ba18c28e +aa456bcfef6a21bb88181482b279df260297b3778e84594ebddbdf337e85d9e3d46ca1d0b516622fb0b103df8ec519b7 +a3b31ae621bd210a2b767e0e6f22eb28fe3c4943498a7e91753225426168b9a26da0e02f1dc5264da53a5ad240d9f51b +aa8d66857127e6e71874ce2202923385a7d2818b84cb73a6c42d71afe70972a70c6bdd2aad1a6e8c5e4ca728382a8ea8 +ac7e8e7a82f439127a5e40558d90d17990f8229852d21c13d753c2e97facf077cf59582b603984c3dd3faebd80aff4f5 +93a8bcf4159f455d1baa73d2ef2450dcd4100420de84169bbe28b8b7a5d1746273f870091a87a057e834f754f34204b1 +89d0ebb287c3613cdcae7f5acc43f17f09c0213fc40c074660120b755d664109ffb9902ed981ede79e018ddb0c845698 +a87ccbfad431406aadbee878d9cf7d91b13649d5f7e19938b7dfd32645a43b114eef64ff3a13201398bd9b0337832e5a +833c51d0d0048f70c3eefb4e70e4ff66d0809c41838e8d2c21c288dd3ae9d9dfaf26d1742bf4976dab83a2b381677011 +8bcd6b1c3b02fffead432e8b1680bad0a1ac5a712d4225e220690ee18df3e7406e2769e1f309e2e803b850bc96f0e768 +b61e3dbd88aaf4ff1401521781e2eea9ef8b66d1fac5387c83b1da9e65c2aa2a56c262dea9eceeb4ad86c90211672db0 +866d3090db944ecf190dd0651abf67659caafd31ae861bab9992c1e3915cb0952da7c561cc7e203560a610f48fae633b +a5e8971543c14274a8dc892b0be188c1b4fbc75c692ed29f166e0ea80874bc5520c2791342b7c1d2fb5dd454b03b8a5b +8f2f9fc50471bae9ea87487ebd1bc8576ef844cc42d606af5c4c0969670fdf2189afd643e4de3145864e7773d215f37f +b1bb0f2527db6d51f42b9224383c0f96048bbc03d469bf01fe1383173ef8b1cc9455d9dd8ba04d46057f46949bfc92b5 +aa7c99d906b4d7922296cfe2520473fc50137c03d68b7865c5bfb8adbc316b1034310ec4b5670c47295f4a80fb8d61e9 +a5d1da4d6aba555919df44cbaa8ff79378a1c9e2cfdfbf9d39c63a4a00f284c5a5724e28ecbc2d9dba27fe4ee5018bd5 +a8db53224f70af4d991b9aae4ffe92d2aa5b618ad9137784b55843e9f16cefbfd25ada355d308e9bbf55f6d2f7976fb3 +b6536c4232bb20e22af1a8bb12de76d5fec2ad9a3b48af1f38fa67e0f8504ef60f305a73d19385095bb6a9603fe29889 +87f7e371a1817a63d6838a8cf4ab3a8473d19ce0d4f40fd013c03d5ddd5f4985df2956531cc9f187928ef54c68f4f9a9 +ae13530b1dbc5e4dced9d909ea61286ec09e25c12f37a1ed2f309b0eb99863d236c3b25ed3484acc8c076ad2fa8cd430 +98928d850247c6f7606190e687d5c94a627550198dbdbea0161ef9515eacdb1a0f195cae3bb293112179082daccf8b35 +918528bb8e6a055ad4db6230d3a405e9e55866da15c4721f5ddd1f1f37962d4904aad7a419218fe6d906fe191a991806 +b71e31a06afe065773dd3f4a6e9ef81c3292e27a3b7fdfdd452d03e05af3b6dd654c355f7516b2a93553360c6681a73a +8870b83ab78a98820866f91ac643af9f3ff792a2b7fda34185a9456a63abdce42bfe8ad4dc67f08a6392f250d4062df4 +91eea1b668e52f7a7a5087fabf1cab803b0316f78d9fff469fbfde2162f660c250e4336a9eea4cb0450bd30ac067bc8b +8b74990946de7b72a92147ceac1bd9d55999a8b576e8df68639e40ed5dc2062cfcd727903133de482b6dca19d0aaed82 +8ebad537fece090ebbab662bdf2618e21ca30cf6329c50935e8346d1217dcbe3c1fe1ea28efca369c6003ce0a94703c1 +a8640479556fb59ebd1c40c5f368fbd960932fdbb782665e4a0e24e2bdb598fc0164ce8c0726d7759cfc59e60a62e182 +a9a52a6bf98ee4d749f6d38be2c60a6d54b64d5cbe4e67266633dc096cf28c97fe998596707d31968cbe2064b72256bf +847953c48a4ce6032780e9b39d0ed4384e0be202c2bbe2dfda3910f5d87aa5cd3c2ffbfcfae4dddce16d6ab657599b95 +b6f6e1485d3ec2a06abaecd23028b200b2e4a0096c16144d07403e1720ff8f9ba9d919016b5eb8dc5103880a7a77a1d3 +98dfc2065b1622f596dbe27131ea60bef7a193b12922cecb27f8c571404f483014f8014572e86ae2e341ab738e4887ef +acb0d205566bacc87bbe2e25d10793f63f7a1f27fd9e58f4f653ceae3ffeba511eaf658e068fad289eeb28f9edbeb35b +ae4411ed5b263673cee894c11fe4abc72a4bf642d94022a5c0f3369380fcdfc1c21e277f2902972252503f91ada3029a +ac4a7a27ba390a75d0a247d93d4a8ef1f0485f8d373a4af4e1139369ec274b91b3464d9738eeaceb19cd6f509e2f8262 +87379c3bf231fdafcf6472a79e9e55a938d851d4dd662ab6e0d95fd47a478ed99e2ad1e6e39be3c0fc4f6d996a7dd833 +81316904b035a8bcc2041199a789a2e6879486ba9fddcba0a82c745cc8dd8374a39e523b91792170cd30be7aa3005b85 +b8206809c6cd027ed019f472581b45f7e12288f89047928ba32b4856b6560ad30395830d71e5e30c556f6f182b1fe690 +88d76c028f534a62e019b4a52967bb8642ede6becfa3807be68fdd36d366fc84a4ac8dc176e80a68bc59eb62caf5dff9 +8c3b8be685b0f8aad131ee7544d0e12f223f08a6f8edaf464b385ac644e0ddc9eff7cc7cb5c1b50ab5d71ea0f41d2213 +8d91410e004f76c50fdc05784157b4d839cb5090022c629c7c97a5e0c3536eeafee17a527b54b1165c3cd81774bb54ce +b25c2863bc28ec5281ce800ddf91a7e1a53f4c6d5da1e6c86ef4616e93bcf55ed49e297216d01379f5c6e7b3c1e46728 +865f7b09ac3ca03f20be90c48f6975dd2588838c2536c7a3532a6aa5187ed0b709cd03d91ff4048061c10d0aa72b69ce +b3f7477c90c11596eb4f8bbf34adbcb832638c4ff3cdd090d4d477ee50472ac9ddaf5be9ad7eca3f148960d362bbd098 +8db35fd53fca04faecd1c76a8227160b3ab46ac1af070f2492445a19d8ff7c25bbaef6c9fa0c8c088444561e9f7e4eb2 +a478b6e9d058a2e01d2fc053b739092e113c23a6a2770a16afbef044a3709a9e32f425ace9ba7981325f02667c3f9609 +98caa6bd38916c08cf221722a675a4f7577f33452623de801d2b3429595f988090907a7e99960fff7c076d6d8e877b31 +b79aaaacefc49c3038a14d2ac468cfec8c2161e88bdae91798d63552cdbe39e0e02f9225717436b9b8a40a022c633c6e +845a31006c680ee6a0cc41d3dc6c0c95d833fcf426f2e7c573fa15b2c4c641fbd6fe5ebb0e23720cc3467d6ee1d80dc4 +a1bc287e272cf8b74dbf6405b3a5190883195806aa351f1dc8e525aa342283f0a35ff687e3b434324dedee74946dd185 +a4fd2dc8db75d3783a020856e2b3aa266dc6926e84f5c491ef739a3bddd46dc8e9e0fc1177937839ef1b18d062ffbb9e +acbf0d3c697f57c202bb8c5dc4f3fc341b8fc509a455d44bd86acc67cad2a04495d5537bcd3e98680185e8aa286f2587 +a5caf423a917352e1b8e844f5968a6da4fdeae467d10c6f4bbd82b5eea46a660b82d2f5440d3641c717b2c3c9ed0be52 +8a39d763c08b926599ab1233219c49c825368fad14d9afc7c0c039224d37c00d8743293fd21645bf0b91eaf579a99867 +b2b53a496def0ba06e80b28f36530fbe0fb5d70a601a2f10722e59abee529369c1ae8fd0f2db9184dd4a2519bb832d94 +a73980fcef053f1b60ebbb5d78ba6332a475e0b96a0c724741a3abf3b59dd344772527f07203cf4c9cb5155ebed81fa0 +a070d20acce42518ece322c9db096f16aed620303a39d8d5735a0df6e70fbeceb940e8d9f5cc38f3314b2240394ec47b +a50cf591f522f19ca337b73089557f75929d9f645f3e57d4f241e14cdd1ea3fb48d84bcf05e4f0377afbb789fbdb5d20 +82a5ffce451096aca8eeb0cd2ae9d83db3ed76da3f531a80d9a70a346359bf05d74863ce6a7c848522b526156a5e20cd +88e0e84d358cbb93755a906f329db1537c3894845f32b9b0b691c29cbb455373d9452fadd1e77e20a623f6eaf624de6f +aa07ac7b84a6d6838826e0b9e350d8ec75e398a52e9824e6b0da6ae4010e5943fec4f00239e96433f291fef9d1d1e609 +ac8887bf39366034bc63f6cc5db0c26fd27307cbc3d6cce47894a8a019c22dd51322fb5096edc018227edfafc053a8f6 +b7d26c26c5b33f77422191dca94977588ab1d4b9ce7d0e19c4a3b4cd1c25211b78c328dbf81e755e78cd7d1d622ad23e +99a676d5af49f0ba44047009298d8474cabf2d5bca1a76ba21eff7ee3c4691a102fdefea27bc948ccad8894a658abd02 +b0d09a91909ab3620c183bdf1d53d43d39eb750dc7a722c661c3de3a1a5d383ad221f71bae374f8a71867505958a3f76 +84681a883de8e4b93d68ac10e91899c2bbb815ce2de74bb48a11a6113b2a3f4df8aceabda1f5f67bc5aacac8c9da7221 +9470259957780fa9b43521fab3644f555f5343281c72582b56d2efd11991d897b3b481cafa48681c5aeb80c9663b68f7 +ab1b29f7ece686e6fa968a4815da1d64f3579fed3bc92e1f3e51cd13a3c076b6cf695ed269d373300a62463dc98a4234 +8ab415bfcd5f1061f7687597024c96dd9c7cb4942b5989379a7a3b5742f7d394337886317659cbeacaf030234a24f972 +b9b524aad924f9acc63d002d617488f31b0016e0f0548f050cada285ce7491b74a125621638f19e9c96eabb091d945be +8c4c373e79415061837dd0def4f28a2d5d74d21cb13a76c9049ad678ca40228405ab0c3941df49249847ecdefc1a5b78 +a8edf4710b5ab2929d3db6c1c0e3e242261bbaa8bcec56908ddadd7d2dad2dca9d6eb9de630b960b122ebeea41040421 +8d66bb3b50b9df8f373163629f9221b3d4b6980a05ea81dc3741bfe9519cf3ebba7ab98e98390bae475e8ede5821bd5c +8d3c21bae7f0cfb97c56952bb22084b58e7bb718890935b73103f33adf5e4d99cd262f929c6eeab96209814f0dbae50a +a5c66cfab3d9ebf733c4af24bebc97070e7989fe3c73e79ac85fb0e4d40ae44fb571e0fad4ad72560e13ed453900d14f +9362e6b50b43dbefbc3254471372297b5dcce809cd3b60bf74a1268ab68bdb50e46e462cbd78f0d6c056330e982846af +854630d08e3f0243d570cc2e856234cb4c1a158d9c1883bf028a76525aaa34be897fe918d5f6da9764a3735fa9ebd24a +8c7d246985469ff252c3f4df6c7c9196fc79f05c1c66a609d84725c78001d0837c7a7049394ba5cf7e863e2d58af8417 +ae050271e01b528925302e71903f785b782f7bf4e4e7a7f537140219bc352dc7540c657ed03d3a297ad36798ecdb98cd +8d2ae9179fcf2b0c69850554580b52c1f4a5bd865af5f3028f222f4acad9c1ad69a8ef6c7dc7b03715ee5c506b74325e +b8ef8de6ce6369a8851cd36db0ccf00a85077e816c14c4e601f533330af9e3acf0743a95d28962ed8bfcfc2520ef3cfe +a6ecad6fdfb851b40356a8b1060f38235407a0f2706e7b8bb4a13465ca3f81d4f5b99466ac2565c60af15f022d26732e +819ff14cdea3ab89d98e133cd2d0379361e2e2c67ad94eeddcdb9232efd509f51d12f4f03ebd4dd953bd262a886281f7 +8561cd0f7a6dbcddd83fcd7f472d7dbcba95b2d4fb98276f48fccf69f76d284e626d7e41314b633352df8e6333fd52a1 +b42557ccce32d9a894d538c48712cb3e212d06ac05cd5e0527ccd2db1078ee6ae399bf6a601ffdab1f5913d35fc0b20c +89b4008d767aad3c6f93c349d3b956e28307311a5b1cec237e8d74bb0dee7e972c24f347fd56afd915a2342bd7bc32f0 +877487384b207e53f5492f4e36c832c2227f92d1bb60542cfeb35e025a4a7afc2b885fae2528b33b40ab09510398f83e +8c411050b63c9053dd0cd81dacb48753c3d7f162028098e024d17cd6348482703a69df31ad6256e3d25a8bbf7783de39 +a8506b54a88d17ac10fb1b0d1fe4aa40eae7553a064863d7f6b52ccc4236dd4b82d01dca6ba87da9a239e3069ba879fb +b1a24caef9df64750c1350789bb8d8a0db0f39474a1c74ea9ba064b1516db6923f00af8d57c632d58844fb8786c3d47a +959d6e255f212b0708c58a2f75cb1fe932248c9d93424612c1b8d1e640149656059737e4db2139afd5556bcdacf3eda2 +84525af21a8d78748680b6535bbc9dc2f0cf9a1d1740d12f382f6ecb2e73811d6c1da2ad9956070b1a617c61fcff9fe5 +b74417d84597a485d0a8e1be07bf78f17ebb2e7b3521b748f73935b9afbbd82f34b710fb7749e7d4ab55b0c7f9de127d +a4a9aecb19a6bab167af96d8b9d9aa5308eab19e6bfb78f5a580f9bf89bdf250a7b52a09b75f715d651cb73febd08e84 +9777b30be2c5ffe7d29cc2803a562a32fb43b59d8c3f05a707ab60ec05b28293716230a7d264d7cd9dd358fc031cc13e +95dce7a3d4f23ac0050c510999f5fbf8042f771e8f8f94192e17bcbfa213470802ebdbe33a876cb621cf42e275cbfc8b +b0b963ebcbbee847ab8ae740478544350b3ac7e86887e4dfb2299ee5096247cd2b03c1de74c774d9bde94ae2ee2dcd59 +a4ab20bafa316030264e13f7ef5891a2c3b29ab62e1668fcb5881f50a9acac6adbe3d706c07e62f2539715db768f6c43 +901478a297669d608e406fe4989be75264b6c8be12169aa9e0ad5234f459ca377f78484ffd2099a2fe2db5e457826427 +88c76e5c250810c057004a03408b85cd918e0c8903dc55a0dd8bb9b4fc2b25c87f9b8cf5943eb19fbbe99d36490050c5 +91607322bbad4a4f03fc0012d0821eff5f8c516fda45d1ec1133bface6f858bf04b25547be24159cab931a7aa08344d4 +843203e07fce3c6c81f84bc6dc5fb5e9d1c50c8811ace522dc66e8658433a0ef9784c947e6a62c11bf705307ef05212e +91dd8813a5d6dddcda7b0f87f672b83198cd0959d8311b2b26fb1fae745185c01f796fbd03aad9db9b58482483fdadd8 +8d15911aacf76c8bcd7136e958febd6963104addcd751ce5c06b6c37213f9c4fb0ffd4e0d12c8e40c36d658999724bfd +8a36c5732d3f1b497ebe9250610605ee62a78eaa9e1a45f329d09aaa1061131cf1d9df00f3a7d0fe8ad614a1ff9caaae +a407d06affae03660881ce20dab5e2d2d6cddc23cd09b95502a9181c465e57597841144cb34d22889902aff23a76d049 +b5fd856d0578620a7e25674d9503be7d97a2222900e1b4738c1d81ff6483b144e19e46802e91161e246271f90270e6cf +91b7708869cdb5a7317f88c0312d103f8ce90be14fb4f219c2e074045a2a83636fdc3e69e862049fc7c1ef000e832541 +b64719cc5480709d1dae958f1d3082b32a43376da446c8f9f64cb02a301effc9c34d9102051733315a8179aed94d53cc +94347a9542ff9d18f7d9eaa2f4d9b832d0e535fe49d52aa2de08aa8192400eddabdb6444a2a78883e27c779eed7fdf5a +840ef44a733ff1376466698cd26f82cf56bb44811e196340467f932efa3ae1ef9958a0701b3b032f50fd9c1d2aed9ab5 +90ab3f6f67688888a31ffc2a882bb37adab32d1a4b278951a21646f90d03385fc976715fc639a785d015751171016f10 +b56f35d164c24b557dbcbc8a4bfa681ec916f8741ffcb27fb389c164f4e3ed2be325210ef5bdaeae7a172ca9599ab442 +a7921a5a80d7cf6ae81ba9ee05e0579b18c20cd2852762c89d6496aa4c8ca9d1ca2434a67b2c16d333ea8e382cdab1e3 +a506bcfbd7e7e5a92f68a1bd87d07ad5fe3b97aeee40af2bf2cae4efcd77fff03f872732c5b7883aa6584bee65d6f8cb +a8c46cff58931a1ce9cbe1501e1da90b174cddd6d50f3dfdfb759d1d4ad4673c0a8feed6c1f24c7af32865a7d6c984e5 +b45686265a83bff69e312c5149db7bb70ac3ec790dc92e392b54d9c85a656e2bf58596ce269f014a906eafc97461aa5f +8d4009a75ccb2f29f54a5f16684b93202c570d7a56ec1a8b20173269c5f7115894f210c26b41e8d54d4072de2d1c75d0 +aef8810af4fc676bf84a0d57b189760ddc3375c64e982539107422e3de2580b89bd27aa6da44e827b56db1b5555e4ee8 +888f0e1e4a34f48eb9a18ef4de334c27564d72f2cf8073e3d46d881853ac1424d79e88d8ddb251914890588937c8f711 +b64b0aa7b3a8f6e0d4b3499fe54e751b8c3e946377c0d5a6dbb677be23736b86a7e8a6be022411601dd75012012c3555 +8d57776f519f0dd912ea14f79fbab53a30624e102f9575c0bad08d2dc754e6be54f39b11278c290977d9b9c7c0e1e0ad +a018fc00d532ceb2e4de908a15606db9b6e0665dd77190e2338da7c87a1713e6b9b61554e7c1462f0f6d4934b960b15c +8c932be83ace46f65c78e145b384f58e41546dc0395270c1397874d88626fdeda395c8a289d602b4c312fe98c1311856 +89174838e21639d6bdd91a0621f04dc056907b88e305dd66e46a08f6d65f731dea72ae87ca5e3042d609e8de8de9aa26 +b7b7f508bb74f7a827ac8189daa855598ff1d96fa3a02394891fd105d8f0816224cd50ac4bf2ed1cf469ace516c48184 +b31877ad682583283baadd68dc1bebd83f5748b165aadd7fe9ef61a343773b88bcd3a022f36d6c92f339b7bfd72820a9 +b79d77260b25daf9126dab7a193df2d7d30542786fa1733ffaf6261734770275d3ca8bae1d9915d1181a78510b3439db +91894fb94cd4c1dd2ceaf9c53a7020c5799ba1217cf2d251ea5bc91ed26e1159dd758e98282ebe35a0395ef9f1ed15a0 +ab59895cdafd33934ceedfc3f0d5d89880482cba6c99a6db93245f9e41987efd76e0640e80aef31782c9a8c7a83fccec +aa22ea63654315e033e09d4d4432331904a6fc5fb1732557987846e3c564668ca67c60a324b4af01663a23af11a9ce4b +b53ba3ef342601467e1f71aa280e100fbabbd38518fa0193e0099505036ee517c1ac78e96e9baeb549bb6879bb698fb0 +943fd69fd656f37487cca3605dc7e5a215fddd811caf228595ec428751fc1de484a0cb84c667fe4d7c35599bfa0e5e34 +9353128b5ebe0dddc555093cf3e5942754f938173541033e8788d7331fafc56f68d9f97b4131e37963ab7f1c8946f5f1 +a76cd3c566691f65cfb86453b5b31dbaf3cab8f84fe1f795dd1e570784b9b01bdd5f0b3c1e233942b1b5838290e00598 +983d84b2e53ffa4ae7f3ba29ef2345247ea2377686b74a10479a0ef105ecf90427bf53b74c96dfa346d0f842b6ffb25b +92e0fe9063306894a2c6970c001781cff416c87e87cb5fbac927a3192655c3da4063e6fa93539f6ff58efac6adcc5514 +b00a81f03c2b8703acd4e2e4c21e06973aba696415d0ea1a648ace2b0ea19b242fede10e4f9d7dcd61c546ab878bc8f9 +b0d08d880f3b456a10bf65cff983f754f545c840c413aea90ce7101a66eb0a0b9b1549d6c4d57725315828607963f15a +90cb64d03534f913b411375cce88a9e8b1329ce67a9f89ca5df8a22b8c1c97707fec727dbcbb9737f20c4cf751359277 +8327c2d42590dfcdb78477fc18dcf71608686ad66c49bce64d7ee874668be7e1c17cc1042a754bbc77c9daf50b2dae07 +8532171ea13aa7e37178e51a6c775da469d2e26ec854eb16e60f3307db4acec110d2155832c202e9ba525fc99174e3b0 +83ca44b15393d021de2a511fa5511c5bd4e0ac7d67259dce5a5328f38a3cce9c3a269405959a2486016bc27bb140f9ff +b1d36e8ca812be545505c8214943b36cabee48112cf0de369957afa796d37f86bf7249d9f36e8e990f26f1076f292b13 +9803abf45be5271e2f3164c328d449efc4b8fc92dfc1225d38e09630909fe92e90a5c77618daa5f592d23fc3ad667094 +b268ad68c7bf432a01039cd889afae815c3e120f57930d463aece10af4fd330b5bd7d8869ef1bcf6b2e78e4229922edc +a4c91a0d6f16b1553264592b4cbbbf3ca5da32ab053ffbdd3dbb1aed1afb650fb6e0dc5274f71a51d7160856477228db +ad89d043c2f0f17806277ffdf3ecf007448e93968663f8a0b674254f36170447b7527d5906035e5e56f4146b89b5af56 +8b6964f757a72a22a642e4d69102951897e20c21449184e44717bd0681d75f7c5bfa5ee5397f6e53febf85a1810d6ed1 +b08f5cdaabec910856920cd6e836c830b863eb578423edf0b32529488f71fe8257d90aed4a127448204df498b6815d79 +af26bb3358be9d280d39b21d831bb53145c4527a642446073fee5a86215c4c89ff49a3877a7a549486262f6f57a0f476 +b4010b37ec4d7c2af20800e272539200a6b623ae4636ecbd0e619484f4ab9240d02bc5541ace3a3fb955dc0a3d774212 +82752ab52bdcc3cc2fc405cb05a2e694d3df4a3a68f2179ec0652536d067b43660b96f85f573f26fbd664a9ef899f650 +96d392dde067473a81faf2d1fea55b6429126b88b160e39b4210d31d0a82833ffd3a80e07d24d495aea2d96be7251547 +a76d8236d6671204d440c33ac5b8deb71fa389f6563d80e73be8b043ec77d4c9b06f9a586117c7f957f4af0331cbc871 +b6c90961f68b5e385d85c9830ec765d22a425f506904c4d506b87d8944c2b2c09615e740ed351df0f9321a7b93979cae +a6ec5ea80c7558403485b3b1869cdc63bde239bafdf936d9b62a37031628402a36a2cfa5cfbb8e26ac922cb0a209b3ba +8c3195bbdbf9bc0fc95fa7e3d7f739353c947f7767d1e3cb24d8c8602d8ea0a1790ac30b815be2a2ba26caa5227891e2 +a7f8a63d809f1155722c57f375ea00412b00147776ae4444f342550279ef4415450d6f400000a326bf11fea6c77bf941 +97fa404df48433a00c85793440e89bb1af44c7267588ae937a1f5d53e01e1c4d4fc8e4a6d517f3978bfdd6c2dfde012f +a984a0a3836de3d8d909c4629a2636aacb85393f6f214a2ef68860081e9db05ad608024762db0dc35e895dc00e2d4cdd +9526cf088ab90335add1db4d3a4ac631b58cbfbe88fa0845a877d33247d1cfeb85994522e1eb8f8874651bfb1df03e2a +ac83443fd0afe99ad49de9bf8230158c118e2814c9c89db5ac951c240d6c2ce45e7677221279d9e97848ec466b99aafe +aeeefdbaba612e971697798ceaf63b247949dc823a0ad771ae5b988a5e882b338a98d3d0796230f49d533ec5ba411b39 +ae3f248b5a7b0f92b7820a6c5ae21e5bd8f4265d4f6e21a22512079b8ee9be06393fd3133ce8ebac0faf23f4f8517e36 +a64a831b908eee784b8388b45447d2885ec0551b26b0c2b15e5f417d0a12c79e867fb7bd3d008d0af98b44336f8ec1ad +b242238cd8362b6e440ba21806905714dd55172db25ec7195f3fc4937b2aba146d5cbf3cf691a1384b4752dc3b54d627 +819f97f337eea1ffb2a678cc25f556f1aab751c6b048993a1d430fe1a3ddd8bb411c152e12ca60ec6e057c190cd1db9a +b9d7d187407380df54ee9fef224c54eec1bfabf17dc8abf60765b7951f538f59aa26fffd5846cfe05546c35f59b573f4 +aa6e3c14efa6a5962812e3f94f8ce673a433f4a82d07a67577285ea0eaa07f8be7115853122d12d6d4e1fdf64c504be1 +82268bee9c1662d3ddb5fb785abfae6fb8b774190f30267f1d47091d2cd4b3874db4372625aa36c32f27b0eee986269b +b236459565b7b966166c4a35b2fa71030b40321821b8e96879d95f0e83a0baf33fa25721f30af4a631df209e25b96061 +8708d752632d2435d2d5b1db4ad1fa2558d776a013655f88e9a3556d86b71976e7dfe5b8834fdec97682cd94560d0d0d +ae1424a68ae2dbfb0f01211f11773732a50510b5585c1fb005cb892b2c6a58f4a55490b5c5b4483c6fce40e9d3236a52 +b3f5f722af9dddb07293c871ce97abbccba0093ca98c8d74b1318fa21396fc1b45b69c15084f63d728f9908442024506 +9606f3ce5e63886853ca476dc0949e7f1051889d529365c0cb0296fdc02abd088f0f0318ecd2cf36740a3634132d36f6 +b11a833a49fa138db46b25ff8cdda665295226595bc212c0931b4931d0a55c99da972c12b4ef753f7e37c6332356e350 +afede34e7dab0a9e074bc19a7daddb27df65735581ca24ad70c891c98b1349fcebbcf3ba6b32c2617fe06a5818dabc2d +97993d456e459e66322d01f8eb13918979761c3e8590910453944bdff90b24091bb018ac6499792515c9923be289f99f +977e3e967eff19290a192cd11df3667d511b398fb3ac9a5114a0f3707e25a0edcb56105648b1b85a8b7519fc529fc6f6 +b873a7c88bf58731fe1bf61ff6828bf114cf5228f254083304a4570e854e83748fc98683ddba62d978fff7909f2c5c47 +ad4b2691f6f19da1d123aaa23cca3e876247ed9a4ab23c599afdbc0d3aa49776442a7ceaa996ac550d0313d9b9a36cee +b9210713c78e19685608c6475bfa974b57ac276808a443f8b280945c5d5f9c39da43effa294bfb1a6c6f7b6b9f85bf6c +a65152f376113e61a0e468759de38d742caa260291b4753391ee408dea55927af08a4d4a9918600a3bdf1df462dffe76 +8bf8c27ad5140dde7f3d2280fd4cc6b29ab76537e8d7aa7011a9d2796ee3e56e9a60c27b5c2da6c5e14fc866301dc195 +92fde8effc9f61393a2771155812b863cff2a0c5423d7d40aa04d621d396b44af94ddd376c28e7d2f53c930aea947484 +97a01d1dd9ee30553ce676011aea97fa93d55038ada95f0057d2362ae9437f3ed13de8290e2ff21e3167dd7ba10b9c3f +89affffaa63cb2df3490f76f0d1e1d6ca35c221dd34057176ba739fa18d492355e6d2a5a5ad93a136d3b1fed0bb8aa19 +928b8e255a77e1f0495c86d3c63b83677b4561a5fcbbe5d3210f1e0fc947496e426d6bf3b49394a5df796c9f25673fc4 +842a0af91799c9b533e79ee081efe2a634cac6c584c2f054fb7d1db67dde90ae36de36cbf712ec9cd1a0c7ee79e151ea +a65b946cf637e090baf2107c9a42f354b390e7316beb8913638130dbc67c918926eb87bec3b1fe92ef72bc77a170fa3b +aafc0f19bfd71ab5ae4a8510c7861458b70ad062a44107b1b1dbacbfa44ba3217028c2824bd7058e2fa32455f624040b +95269dc787653814e0be899c95dba8cfa384f575a25e671c0806fd80816ad6797dc819d30ae06e1d0ed9cb01c3950d47 +a1e760f7fa5775a1b2964b719ff961a92083c5c617f637fc46e0c9c20ab233f8686f7f38c3cb27d825c54dd95e93a59b +ac3b8a7c2317ea967f229eddc3e23e279427f665c4705c7532ed33443f1243d33453c1088f57088d2ab1e3df690a9cc9 +b787beeddfbfe36dd51ec4efd9cf83e59e84d354c3353cc9c447be53ae53d366ed1c59b686e52a92f002142c8652bfe0 +b7a64198300cb6716aa7ac6b25621f8bdec46ad5c07a27e165b3f774cdf65bcfdbf31e9bae0c16b44de4b00ada7a4244 +b8ae9f1452909e0c412c7a7fe075027691ea8df1347f65a5507bc8848f1d2c833d69748076db1129e5b4fb912f65c86c +9682e41872456b9fa67def89e71f06d362d6c8ca85c9c48536615bc401442711e1c9803f10ab7f8ab5feaec0f9df20a6 +88889ff4e271dc1c7e21989cc39f73cde2f0475acd98078281591ff6c944fadeb9954e72334319050205d745d4df73df +8f79b5b8159e7fd0d93b0645f3c416464f39aec353b57d99ecf24f96272df8a068ad67a6c90c78d82c63b40bb73989bb +838c01a009a3d8558a3f0bdd5e22de21af71ca1aefc8423c91dc577d50920e9516880e87dce3e6d086e11cd45c9052d9 +b97f1c6eee8a78f137c840667cc288256e39294268a3009419298a04a1d0087c9c9077b33c917c65caf76637702dda8a +972284ce72f96a61c899260203dfa06fc3268981732bef74060641c1a5068ead723e3399431c247ca034b0dae861e8df +945a8d52d6d3db6663dbd3110c6587f9e9c44132045eeffba15621576d178315cb52870fa5861669f84f0bee646183fe +a0a547b5f0967b1c3e5ec6c6a9a99f0578521489180dfdfbb5561f4d166baac43a2f06f950f645ce991664e167537eed +a0592cda5cdddf1340033a745fd13a6eff2021f2e26587116c61c60edead067e0f217bc2bef4172a3c9839b0b978ab35 +b9c223b65a3281587fa44ec829e609154b32f801fd1de6950e01eafb07a8324243b960d5735288d0f89f0078b2c42b5b +99ebfc3b8f9f98249f4d37a0023149ed85edd7a5abe062c8fb30c8c84555258b998bdcdd1d400bc0fa2a4aaa8b224466 +955b68526e6cb3937b26843270f4e60f9c6c8ece2fa9308fe3e23afa433309c068c66a4bc16ee2cf04220f095e9afce4 +b766caeafcc00378135ae53397f8a67ed586f5e30795462c4a35853de6681b1f17401a1c40958de32b197c083b7279c1 +921bf87cad947c2c33fa596d819423c10337a76fe5a63813c0a9dc78a728207ae7b339407a402fc4d0f7cba3af6da6fc +a74ba1f3bc3e6c025db411308f49b347ec91da1c916bda9da61e510ec8d71d25e0ac0f124811b7860e5204f93099af27 +a29b4d144e0bf17a7e8353f2824cef0ce85621396babe8a0b873ca1e8a5f8d508b87866cf86da348470649fceefd735c +a8040e12ffc3480dd83a349d06741d1572ef91932c46f5cf03aee8454254156ee95786fd013d5654725e674c920cec32 +8c4cf34ca60afd33923f219ffed054f90cd3f253ffeb2204a3b61b0183417e366c16c07fae860e362b0f2bfe3e1a1d35 +8195eede4ddb1c950459df6c396b2e99d83059f282b420acc34220cadeed16ab65c856f2c52568d86d3c682818ed7b37 +91fff19e54c15932260aa990c7fcb3c3c3da94845cc5aa8740ef56cf9f58d19b4c3c55596f8d6c877f9f4d22921d93aa +a3e0bf7e5d02a80b75cf75f2db7e66cb625250c45436e3c136d86297d652590ec97c2311bafe407ad357c79ab29d107b +81917ff87e5ed2ae4656b481a63ced9e6e5ff653b8aa6b7986911b8bc1ee5b8ef4f4d7882c3f250f2238e141b227e510 +915fdbe5e7de09c66c0416ae14a8750db9412e11dc576cf6158755fdcaf67abdbf0fa79b554cac4fe91c4ec245be073f +8df27eafb5c3996ba4dc5773c1a45ca77e626b52e454dc1c4058aa94c2067c18332280630cc3d364821ee53bf2b8c130 +934f8a17c5cbb827d7868f5c8ca00cb027728a841000a16a3428ab16aa28733f16b52f58c9c4fbf75ccc45df72d9c4df +b83f4da811f9183c25de8958bc73b504cf790e0f357cbe74ef696efa7aca97ad3b7ead1faf76e9f982c65b6a4d888fc2 +87188213c8b5c268dc2b6da413f0501c95749e953791b727450af3e43714149c115b596b33b63a2f006a1a271b87efd0 +83e9e888ab9c3e30761de635d9aabd31248cdd92f7675fc43e4b21fd96a03ec1dc4ad2ec94fec857ffb52683ac98e360 +b4b9a1823fe2d983dc4ec4e3aaea297e581c3fc5ab4b4af5fa1370caa37af2d1cc7fc6bfc5e7da60ad8fdce27dfe4b24 +856388bc78aef465dbcdd1f559252e028c9e9a2225c37d645c138e78f008f764124522705822a61326a6d1c79781e189 +a6431b36db93c3b47353ba22e7c9592c9cdfb9cbdd052ecf2cc3793f5b60c1e89bc96e6bae117bfd047f2308da00dd2f +b619972d48e7e4291542dcde08f7a9cdc883c892986ded2f23ccb216e245cd8d9ad1d285347b0f9d7611d63bf4cee2bc +8845cca6ff8595955f37440232f8e61d5351500bd016dfadd182b9d39544db77a62f4e0102ff74dd4173ae2c181d24ef +b2f5f7fa26dcd3b6550879520172db2d64ee6aaa213cbef1a12befbce03f0973a22eb4e5d7b977f466ac2bf8323dcedd +858b7f7e2d44bdf5235841164aa8b4f3d33934e8cb122794d90e0c1cac726417b220529e4f896d7b77902ab0ccd35b3a +80b0408a092dae2b287a5e32ea1ad52b78b10e9c12f49282976cd738f5d834e03d1ad59b09c5ccaccc39818b87d06092 +b996b0a9c6a2d14d984edcd6ab56bc941674102980d65b3ad9733455f49473d3f587c8cbf661228a7e125ddbe07e3198 +90224fcebb36865293bd63af786e0c5ade6b67c4938d77eb0cbae730d514fdd0fe2d6632788e858afd29d46310cf86df +b71351fdfff7168b0a5ec48397ecc27ac36657a8033d9981e97002dcca0303e3715ce6dd3f39423bc8ef286fa2e9e669 +ae2a3f078b89fb753ce4ed87e0c1a58bb19b4f0cfb6586dedb9fcab99d097d659a489fb40e14651741e1375cfc4b6c5f +8ef476b118e0b868caed297c161f4231bbeb863cdfa5e2eaa0fc6b6669425ce7af50dc374abceac154c287de50c22307 +92e46ab472c56cfc6458955270d3c72b7bde563bb32f7d4ab4d959db6f885764a3d864e1aa19802fefaa5e16b0cb0b54 +96a3f68323d1c94e73d5938a18a377af31b782f56212de3f489d22bc289cf24793a95b37f1d6776edf88114b5c1fa695 +962cc068cfce6faaa27213c4e43e44eeff0dfbb6d25b814e82c7da981fb81d7d91868fa2344f05fb552362f98cfd4a72 +895d4e4c4ad670abf66d43d59675b1add7afad7438ada8f42a0360c704cee2060f9ac15b4d27e9b9d0996bb801276fe3 +b3ad18d7ece71f89f2ef749b853c45dc56bf1c796250024b39a1e91ed11ca32713864049c9aaaea60cde309b47486bbf +8f05404e0c0258fdbae50e97ccb9b72ee17e0bd2400d9102c0dad981dac8c4c71585f03e9b5d50086d0a2d3334cb55d1 +8bd877e9d4591d02c63c6f9fc9976c109de2d0d2df2bfa5f6a3232bab5b0b8b46e255679520480c2d7a318545efa1245 +8d4c16b5d98957c9da13d3f36c46f176e64e5be879f22be3179a2c0e624fe4758a82bf8c8027410002f973a3b84cd55a +86e2a8dea86427b424fa8eada881bdff896907084a495546e66556cbdf070b78ba312bf441eb1be6a80006d25d5097a3 +8608b0c117fd8652fdab0495b08fadbeba95d9c37068e570de6fddfef1ba4a1773b42ac2be212836141d1bdcdef11a17 +a13d6febf5fb993ae76cae08423ca28da8b818d6ef0fde32976a4db57839cd45b085026b28ee5795f10a9a8e3098c683 +8e261967fa6de96f00bc94a199d7f72896a6ad8a7bbb1d6187cca8fad824e522880e20f766620f4f7e191c53321d70f9 +8b8e8972ac0218d7e3d922c734302803878ad508ca19f5f012bc047babd8a5c5a53deb5fe7c15a4c00fd6d1cb9b1dbd0 +b5616b233fb3574a2717d125a434a2682ff68546dccf116dd8a3b750a096982f185614b9fb6c7678107ff40a451f56fa +aa6adf9b0c3334b0d0663f583a4914523b2ac2e7adffdb026ab9109295ff6af003ef8357026dbcf789896d2afded8d73 +acb72df56a0b65496cd534448ed4f62950bb1e11e50873b6ed349c088ee364441821294ce0f7c61bd7d38105bea3b442 +abae12df83e01ec947249fedd0115dc501d2b03ff7232092979eda531dbbca29ace1d46923427c7dde4c17bdf3fd7708 +820b4fc2b63a9fda7964acf5caf19a2fc4965007cb6d6b511fcafcb1f71c3f673a1c0791d3f86e3a9a1eb6955b191cc0 +af277259d78c6b0f4f030a10c53577555df5e83319ddbad91afbd7c30bc58e7671c56d00d66ec3ab5ef56470cd910cee +ad4a861c59f1f5ca1beedd488fb3d131dea924fffd8e038741a1a7371fad7370ca5cf80dc01f177fbb9576713bb9a5b3 +b67a5162982ce6a55ccfb2f177b1ec26b110043cf18abd6a6c451cf140b5af2d634591eb4f28ad92177d8c7e5cd0a5e8 +96176d0a83816330187798072d449cbfccff682561e668faf6b1220c9a6535b32a6e4f852e8abb00f79abb87493df16b +b0afe6e7cb672e18f0206e4423f51f8bd0017bf464c4b186d46332c5a5847647f89ff7fa4801a41c1b0b42f6135bcc92 +8fc5e7a95ef20c1278c645892811f6fe3f15c431ebc998a32ec0da44e7213ea934ed2be65239f3f49b8ec471e9914160 +b7793e41adda6c82ba1f2a31f656f6205f65bf8a3d50d836ee631bc7ce77c153345a2d0fc5c60edf8b37457c3729c4ec +a504dd7e4d6b2f4379f22cc867c65535079c75ccc575955f961677fa63ecb9f74026fa2f60c9fb6323c1699259e5e9c8 +ab899d00ae693649cc1afdf30fb80d728973d2177c006e428bf61c7be01e183866614e05410041bc82cb14a33330e69c +8a3bd8b0b1be570b65c4432a0f6dc42f48a2000e30ab089cf781d38f4090467b54f79c0d472fcbf18ef6a00df69cc6f3 +b4d7028f7f76a96a3d7803fca7f507ae11a77c5346e9cdfccb120a833a59bda1f4264e425aa588e7a16f8e7638061d84 +b9c7511a76ea5fb105de905d44b02edb17008335766ee357ed386b7b3cf19640a98b38785cb14603c1192bee5886c9b6 +8563afb12e53aed71ac7103ab8602bfa8371ae095207cb0d59e8fd389b6ad1aff0641147e53cb6a7ca16c7f37c9c5e6b +8e108be614604e09974a9ed90960c28c4ea330a3d9a0cb4af6dd6f193f84ab282b243ecdf549b3131036bebc8905690c +b794d127fbedb9c5b58e31822361706ffac55ce023fbfe55716c3c48c2fd2f2c7660a67346864dfe588812d369cb50b6 +b797a3442fc3b44f41baefd30346f9ac7f96e770d010d53c146ce74ce424c10fb62758b7e108b8abfdc5fafd89d745cb +993bb71e031e8096442e6205625e1bfddfe6dd6a83a81f3e2f84fafa9e5082ab4cad80a099f21eff2e81c83457c725c3 +8711ab833fc03e37acf2e1e74cfd9133b101ff4144fe30260654398ae48912ab46549d552eb9d15d2ea57760d35ac62e +b21321fd2a12083863a1576c5930e1aecb330391ef83326d9d92e1f6f0d066d1394519284ddab55b2cb77417d4b0292f +877d98f731ffe3ee94b0b5b72d127630fa8a96f6ca4f913d2aa581f67732df6709493693053b3e22b0181632ac6c1e3b +ae391c12e0eb8c145103c62ea64f41345973311c3bf7281fa6bf9b7faafac87bcf0998e5649b9ef81e288c369c827e07 +b83a2842f36998890492ab1cd5a088d9423d192681b9a3a90ec518d4c541bce63e6c5f4df0f734f31fbfdd87785a2463 +a21b6a790011396e1569ec5b2a423857b9bec16f543e63af28024e116c1ea24a3b96e8e4c75c6537c3e4611fd265e896 +b4251a9c4aab3a495da7a42e684ba4860dbcf940ad1da4b6d5ec46050cbe8dab0ab9ae6b63b5879de97b905723a41576 +8222f70aebfe6ac037f8543a08498f4cadb3edaac00336fc00437eb09f2cba758f6c38e887cc634b4d5b7112b6334836 +86f05038e060594c46b5d94621a1d9620aa8ba59a6995baf448734e21f58e23c1ea2993d3002ad5250d6edd5ba59b34f +a7c0c749baef811ab31b973c39ceb1d94750e2bc559c90dc5eeb20d8bb6b78586a2b363c599ba2107d6be65cd435f24e +861d46a5d70b38d6c1cd72817a2813803d9f34c00320c8b62f8b9deb67f5b5687bc0b37c16d28fd017367b92e05da9ca +b3365d3dab639bffbe38e35383686a435c8c88b397b717cd4aeced2772ea1053ceb670f811f883f4e02975e5f1c4ac58 +a5750285f61ab8f64cd771f6466e2c0395e01b692fd878f2ef2d5c78bdd8212a73a3b1dfa5e4c8d9e1afda7c84857d3b +835a10809ccf939bc46cf950a33b36d71be418774f51861f1cd98a016ade30f289114a88225a2c11e771b8b346cbe6ef +a4f59473a037077181a0a62f1856ec271028546ca9452b45cedfcb229d0f4d1aabfc13062b07e536cc8a0d4b113156a2 +95cd14802180b224d44a73cc1ed599d6c4ca62ddcaa503513ccdc80aaa8be050cc98bd4b4f3b639549beb4587ac6caf9 +973b731992a3e69996253d7f36dd7a0af1982b5ed21624b77a7965d69e9a377b010d6dabf88a8a97eec2a476259859cc +af8a1655d6f9c78c8eb9a95051aa3baaf9c811adf0ae8c944a8d3fcba87b15f61021f3baf6996fa0aa51c81b3cb69de1 +835aad5c56872d2a2d6c252507b85dd742bf9b8c211ccb6b25b52d15c07245b6d89b2a40f722aeb5083a47cca159c947 +abf4e970b02bef8a102df983e22e97e2541dd3650b46e26be9ee394a3ea8b577019331857241d3d12b41d4eacd29a3ac +a13c32449dbedf158721c13db9539ae076a6ce5aeaf68491e90e6ad4e20e20d1cdcc4a89ed9fd49cb8c0dd50c17633c1 +8c8f78f88b7e22dd7e9150ab1c000f10c28e696e21d85d6469a6fe315254740f32e73d81ab1f3c1cf8f544c86df506e8 +b4b77f2acfe945abf81f2605f906c10b88fb4d28628487fb4feb3a09f17f28e9780445dfcee4878349d4c6387a9d17d4 +8d255c235f3812c6ecc646f855fa3832be5cb4dbb9c9e544989fafdf3f69f05bfd370732eaf954012f0044aa013fc9c6 +b982efd3f34b47df37c910148ac56a84e8116647bea24145a49e34e0a6c0176e3284d838dae6230cb40d0be91c078b85 +983f365aa09bd85df2a6a2ad8e4318996b1e27d02090755391d4486144e40d80b1fbfe1c798d626db92f52e33aa634da +95fd1981271f3ea3a41d654cf497e6696730d9ff7369f26bc4d7d15c7adb4823dd0c42e4a005a810af12d234065e5390 +a9f5219bd4b913c186ef30c02f995a08f0f6f1462614ea5f236964e02bdaa33db9d9b816c4aee5829947840a9a07ba60 +9210e6ceb05c09b46fd09d036287ca33c45124ab86315e5d6911ff89054f1101faaa3e83d123b7805056d388bcec6664 +8ed9cbf69c6ff3a5c62dd9fe0d7264578c0f826a29e614bc2fb4d621d90c8c9992438accdd7a614b1dca5d1bb73dc315 +85cf2a8cca93e00da459e3cecd22c342d697eee13c74d5851634844fc215f60053cf84b0e03c327cb395f48d1c71a8a4 +8818a18e9a2ec90a271b784400c1903089ffb0e0b40bc5abbbe12fbebe0f731f91959d98c5519ef1694543e31e2016d4 +8dabc130f296fa7a82870bf9a8405aaf542b222ed9276bba9bd3c3555a0f473acb97d655ee7280baff766a827a8993f0 +ac7952b84b0dc60c4d858f034093b4d322c35959605a3dad2b806af9813a4680cb038c6d7f4485b4d6b2ff502aaeca25 +ad65cb6d57b48a2602568d2ec8010baed0eb440eec7638c5ec8f02687d764e9de5b5d42ad5582934e592b48471c22d26 +a02ab8bd4c3d114ea23aebdd880952f9495912817da8c0c08eabc4e6755439899d635034413d51134c72a6320f807f1c +8319567764b8295402ec1ebef4c2930a138480b37e6d7d01c8b4c9cd1f2fc3f6e9a44ae6e380a0c469b25b06db23305f +afec53b2301dc0caa8034cd9daef78c48905e6068d692ca23d589b84a6fa9ddc2ed24a39480597e19cb3e83eec213b3f +ac0b4ffdb5ae08e586a9cdb98f9fe56f4712af3a97065e89e274feacfb52b53c839565aee93c4cfaaccfe51432c4fab0 +8972cbf07a738549205b1094c5987818124144bf187bc0a85287c94fdb22ce038c0f11df1aa16ec5992e91b44d1af793 +b7267aa6f9e3de864179b7da30319f1d4cb2a3560f2ea980254775963f1523b44c680f917095879bebfa3dc2b603efcf +80f68f4bfc337952e29504ee5149f15093824ea7ab02507efd1317a670f6cbc3611201848560312e3e52e9d9af72eccf +8897fee93ce8fc1e1122e46b6d640bba309384dbd92e46e185e6364aa8210ebf5f9ee7e5e604b6ffba99aa80a10dd7d0 +b58ea6c02f2360be60595223d692e82ee64874fda41a9f75930f7d28586f89be34b1083e03bbc1575bbfdda2d30db1ea +85a523a33d903280d70ac5938770453a58293480170c84926457ac2df45c10d5ff34322ab130ef4a38c916e70d81af53 +a2cbf045e1bed38937492c1f2f93a5ba41875f1f262291914bc1fc40c60bd0740fb3fea428faf6da38b7c180fe8ac109 +8c09328770ed8eb17afc6ac7ddd87bb476de18ed63cab80027234a605806895959990c47bd10d259d7f3e2ecb50074c9 +b4b9e19edb4a33bde8b7289956568a5b6b6557404e0a34584b5721fe6f564821091013fbb158e2858c6d398293bb4b59 +8a47377df61733a2aa5a0e945fce00267f8e950f37e109d4487d92d878fb8b573317bb382d902de515b544e9e233458d +b5804c9d97efeff5ca94f3689b8088c62422d92a1506fd1d8d3b1b30e8a866ad0d6dad4abfa051dfc4471250cac4c5d9 +9084a6ee8ec22d4881e9dcc8a9eb3c2513523d8bc141942370fd191ad2601bf9537a0b1e84316f3209b3d8a54368051e +85447eea2fa26656a649f8519fa67279183044791d61cf8563d0783d46d747d96af31d0a93507bbb2242666aa87d3720 +97566a84481027b60116c751aec552adfff2d9038e68d48c4db9811fb0cbfdb3f1d91fc176a0b0d988a765f8a020bce1 +ae87e5c1b9e86c49a23dceda4ecfd1dcf08567f1db8e5b6ec752ebd45433c11e7da4988573cdaebbb6f4135814fc059e +abee05cf9abdbc52897ac1ce9ed157f5466ed6c383d6497de28616238d60409e5e92619e528af8b62cc552bf09970dc2 +ae6d31cd7bf9599e5ee0828bab00ceb4856d829bba967278a73706b5f388465367aa8a6c7da24b5e5f1fdd3256ef8e63 +ac33e7b1ee47e1ee4af472e37ab9e9175260e506a4e5ce449788075da1b53c44cb035f3792d1eea2aa24b1f688cc6ed3 +80f65b205666b0e089bb62152251c48c380a831e5f277f11f3ef4f0d52533f0851c1b612267042802f019ec900dc0e8f +858520ad7aa1c9fed738e3b583c84168f2927837ad0e1d326afe9935c26e9b473d7f8c382e82ef1fe37d2b39bb40a1ee +b842dd4af8befe00a97c2d0f0c33c93974761e2cb9e5ab8331b25170318ddd5e4bdbc02d8f90cbfdd5f348f4f371c1f7 +8bf2cb79bc783cb57088aae7363320cbeaabd078ffdec9d41bc74ff49e0043d0dad0086a30e5112b689fd2f5a606365d +982eb03bbe563e8850847cd37e6a3306d298ab08c4d63ab6334e6b8c1fa13fce80cf2693b09714c7621d74261a0ff306 +b143edb113dec9f1e5105d4a93fbe502b859e587640d3db2f628c09a17060e6aec9e900e2c8c411cda99bc301ff96625 +af472d9befa750dcebc5428fe1a024f18ec1c07bca0f95643ce6b5f4189892a910285afb03fd7ed7068fbe614e80d33c +a97e3bc57ede73ecd1bbf02de8f51b4e7c1a067da68a3cd719f4ba26a0156cbf1cef2169fd35a18c5a4cced50d475998 +a862253c937cf3d75d7183e5f5be6a4385d526aeda5171c1c60a8381fea79f88f5f52a4fab244ecc70765d5765e6dfd5 +90cb776f8e5a108f1719df4a355bebb04bf023349356382cae55991b31720f0fd03206b895fa10c56c98f52453be8778 +a7614e8d0769dccd520ea4b46f7646e12489951efaef5176bc889e9eb65f6e31758df136b5bf1e9107e68472fa9b46ec +ac3a9b80a3254c42e5ed3a090a0dd7aee2352f480de96ad187027a3bb6c791eddfc3074b6ffd74eea825188f107cda4d +82a01d0168238ef04180d4b6e0a0e39024c02c2d75b065017c2928039e154d093e1af4503f4d1f3d8a948917abb5d09f +8fab000a2b0eef851a483aec8d2dd85fe60504794411a2f73ed82e116960547ac58766cb73df71aea71079302630258d +872451a35c6db61c63e9b8bb9f16b217f985c20be4451c14282c814adb29d7fb13f201367c664435c7f1d4d9375d7a58 +887d9ff54cc96b35d562df4a537ff972d7c4b3fd91ab06354969a4cfede0b9fc68bbffb61d0dbf1a58948dc701e54f5a +8cb5c2a6bd956875d88f41ae24574434f1308514d44057b55c9c70f13a3366ed054150eed0955a38fda3f757be73d55f +89ad0163cad93e24129d63f8e38422b7674632a8d0a9016ee8636184cab177659a676c4ee7efba3abe1a68807c656d60 +b9ec01c7cab6d00359b5a0b4a1573467d09476e05ca51a9227cd16b589a9943d161eef62dcc73f0de2ec504d81f4d252 +8031d17635d39dfe9705c485d2c94830b6fc9bc67b91300d9d2591b51e36a782e77ab5904662effa9382d9cca201f525 +8be5a5f6bc8d680e5092d6f9a6585acbaaaa2ddc671da560dcf5cfa4472f4f184b9597b5b539438accd40dda885687cc +b1fc0f052fae038a2e3de3b3a96b0a1024b009de8457b8b3adb2d315ae68a89af905720108a30038e5ab8d0d97087785 +8b8bdc77bd3a6bc7ca5492b6f8c614852c39a70d6c8a74916eaca0aeb4533b11898b8820a4c2620a97bf35e275480029 +af35f4dc538d4ad5cdf710caa38fd1eb496c3fa890a047b6a659619c5ad3054158371d1e88e0894428282eed9f47f76b +8166454a7089cc07758ad78724654f4e7a1a13e305bbf88ddb86f1a4b2904c4fc8ab872d7da364cdd6a6c0365239e2ad +ab287c7d3addce74ce40491871c768abe01daaa0833481276ff2e56926b38a7c6d2681ffe837d2cc323045ad1a4414f9 +b90317f4505793094d89365beb35537f55a6b5618904236258dd04ca61f21476837624a2f45fef8168acf732cab65579 +98ae5ea27448e236b6657ab5ef7b1cccb5372f92ab25f5fa651fbac97d08353a1dae1b280b1cd42b17d2c6a70a63ab9d +adcf54e752d32cbaa6cb98fbca48d8cd087b1db1d131d465705a0d8042c8393c8f4d26b59006eb50129b21e6240f0c06 +b591a3e4db18a7345fa935a8dd7994bbac5cc270b8ebd84c8304c44484c7a74afb45471fdbe4ab22156a30fae1149b40 +806b53ac049a42f1dcc1d6335505371da0bf27c614f441b03bbf2e356be7b2fb4eed7117eabcce9e427a542eaa2bf7d8 +800482e7a772d49210b81c4a907f5ce97f270b959e745621ee293cf8c71e8989363d61f66a98f2d16914439544ca84c7 +99de9eafdad3617445312341644f2bb888680ff01ce95ca9276b1d2e5ef83fa02dab5e948ebf66c17df0752f1bd37b70 +961ee30810aa4c93ae157fbe9009b8e443c082192bd36a73a6764ff9b2ad8b0948fe9a73344556e01399dd77badb4257 +ae0a361067c52efbe56c8adf982c00432cd478929459fc7f74052c8ee9531cd031fe1335418fde53f7c2ef34254eb7ac +a3503d16b6b27eb20c1b177bcf90d13706169220523a6271b85b2ce35a9a2b9c5bed088540031c0a4ebfdae3a4c6ab04 +909420122c3e723289ca4e7b81c2df5aff312972a2203f4c45821b176e7c862bf9cac7f7df3adf1d59278f02694d06e7 +989f42380ae904b982f85d0c6186c1aef5d6bcba29bcfbb658e811b587eb2749c65c6e4a8cc6409c229a107499a4f5d7 +8037a6337195c8e26a27ea4ef218c6e7d79a9720aaab43932d343192abc2320fe72955f5e431c109093bda074103330a +b312e168663842099b88445e940249cc508f080ab0c94331f672e7760258dbd86be5267e4cf25ea25facb80bff82a7e9 +aaa3ff8639496864fcdbfdda1ac97edc4f08e3c9288b768f6c8073038c9fbbf7e1c4bea169b4d45c31935cdf0680d45e +97dbd3df37f0b481a311dfc5f40e59227720f367912200d71908ef6650f32cc985cb05b981e3eea38958f7e48d10a15d +a89d49d1e267bb452d6cb621b9a90826fe55e9b489c0427b94442d02a16f390eed758e209991687f73f6b5a032321f42 +9530dea4e0e19d6496f536f2e75cf7d814d65fde567055eb20db48fd8d20d501cd2a22fb506db566b94c9ee10f413d43 +81a7009b9e67f1965fa7da6a57591c307de91bf0cd35ab4348dc4a98a4961e096d004d7e7ad318000011dc4342c1b809 +83440a9402b766045d7aca61a58bba2aa29cac1cf718199e472ba086f5d48093d9dda4d135292ba51d049a23964eceae +a06c9ce5e802df14f6b064a3d1a0735d429b452f0e2e276042800b0a4f16df988fd94cf3945921d5dd3802ab2636f867 +b1359e358b89936dee9e678a187aad3e9ab14ac40e96a0a68f70ee2583cdcf467ae03bef4215e92893f4e12f902adec8 +835304f8619188b4d14674d803103d5a3fa594d48e96d9699e653115dd05fdc2dda6ba3641cf7ad53994d448da155f02 +8327cba5a9ff0d3f5cd0ae55e77167448926d5fcf76550c0ad978092a14122723090c51c415e88e42a2b62eb07cc3981 +b373dcdaea85f85ce9978b1426a7ef4945f65f2d3467a9f1cc551a99766aac95df4a09e2251d3f89ca8c9d1a7cfd7b0e +ab1422dc41af2a227b973a6fd124dfcb2367e2a11a21faa1d381d404f51b7257e5bc82e9cf20cd7fe37d7ae761a2ab37 +a93774a03519d2f20fdf2ef46547b0a5b77c137d6a3434b48d56a2cbef9e77120d1b85d0092cf8842909213826699477 +8eb967a495a38130ea28711580b7e61bcd1d051cd9e4f2dbf62f1380bd86e0d60e978d72f6f31e909eb97b3b9a2b867c +ae8213378da1287ba1fe4242e1acaec19b877b6fe872400013c6eac1084b8d03156792fa3020201725b08228a1e80f49 +b143daf6893d674d607772b3b02d8ac48f294237e2f2c87963c0d4e26d9227d94a2a13512457c3d5883544bbc259f0ef +b343bd2aca8973888e42542218924e2dda2e938fd1150d06878af76f777546213912b7c7a34a0f94186817d80ffa185c +b188ebc6a8c3007001aa347ae72cc0b15d09bc6c19a80e386ee4b334734ec0cc2fe8b493c2422f38d1e6d133cc3db6fe +b795f6a8b9b826aaeee18ccd6baf6c5adeeec85f95eb5b6d19450085ec7217e95a2d9e221d77f583b297d0872073ba0e +b1c7dbd998ad32ae57bfa95deafa147024afd57389e98992c36b6e52df915d3d5a39db585141ec2423173e85d212fed8 +812bcdeb9fe5f12d0e1df9964798056e1f1c3de3b17b6bd2919b6356c4b86d8e763c01933efbe0224c86a96d5198a4be +b19ebeda61c23d255cbf472ef0b8a441f4c55b70f0d8ed47078c248b1d3c7c62e076b43b95c00a958ec8b16d5a7cb0d7 +b02adc9aaa20e0368a989c2af14ff48b67233d28ebee44ff3418bb0473592e6b681af1cc45450bd4b175df9051df63d9 +8d87f0714acee522eb58cec00360e762adc411901dba46adc9227124fa70ee679f9a47e91a6306d6030dd4eb8de2f3c1 +8be54cec21e74bcc71de29dc621444263737db15f16d0bb13670f64e42f818154e04b484593d19ef95f2ee17e4b3fe21 +ab8e20546c1db38d31493b5d5f535758afb17e459645c1b70813b1cf7d242fd5d1f4354a7c929e8f7259f6a25302e351 +89f035a1ed8a1e302ac893349ba8ddf967580fcb6e73d44af09e3929cde445e97ff60c87dafe489e2c0ab9c9986cfa00 +8b2b0851a795c19191a692af55f7e72ad2474efdc5401bc3733cfdd910e34c918aaebe69d5ea951bdddf3c01cabbfc67 +a4edb52c2b51495ccd1ee6450fc14b7b3ede8b3d106808929d02fb31475bacb403e112ba9c818d2857651e508b3a7dd1 +9569341fded45d19f00bcf3cbf3f20eb2b4d82ef92aba3c8abd95866398438a2387437e580d8b646f17cf6fde8c5af23 +aa4b671c6d20f72f2f18a939a6ff21cc37e0084b44b4a717f1be859a80b39fb1be026b3205adec2a66a608ec2bcd578f +94902e980de23c4de394ad8aec91b46f888d18f045753541492bfbb92c59d3daa8de37ae755a6853744af8472ba7b72b +af651ef1b2a0d30a7884557edfad95b6b5d445a7561caebdc46a485aedd25932c62c0798465c340a76f6feaa196dd712 +b7b669b8e5a763452128846dd46b530dca4893ace5cc5881c7ddcd3d45969d7e73fbebdb0e78aa81686e5f7b22ec5759 +82507fd4ebe9fa656a7f2e084d64a1fa6777a2b0bc106d686e2d9d2edafc58997e58cb6bfd0453b2bf415704aa82ae62 +b40bce2b42b88678400ecd52955bbdadd15f8b9e1b3751a1a3375dc0efb5ca3ee258cf201e1140b3c09ad41217d1d49e +b0210d0cbb3fbf3b8cdb39e862f036b0ff941cd838e7aaf3a8354e24246e64778d22f3de34572e6b2a580614fb6425be +876693cba4301b251523c7d034108831df3ce133d8be5a514e7a2ca494c268ca0556fa2ad8310a1d92a16b55bcd99ea9 +8660281406d22a4950f5ef050bf71dd3090edb16eff27fa29ef600cdea628315e2054211ed2cc6eaf8f2a1771ef689fd +a610e7e41e41ab66955b809ba4ade0330b8e9057d8efc9144753caed81995edeb1a42a53f93ce93540feca1fae708dac +a49e2c176a350251daef1218efaccc07a1e06203386ede59c136699d25ca5cb2ac1b800c25b28dd05678f14e78e51891 +83e0915aa2b09359604566080d411874af8c993beba97d4547782fdbe1a68e59324b800ff1f07b8db30c71adcbd102a8 +a19e84e3541fb6498e9bb8a099c495cbfcad113330e0262a7e4c6544495bb8a754b2208d0c2d895c93463558013a5a32 +87f2bd49859a364912023aca7b19a592c60214b8d6239e2be887ae80b69ebdeb59742bdebcfa73a586ab23b2c945586c +b8e8fdddae934a14b57bc274b8dcd0d45ebb95ddbaabef4454e0f6ce7d3a5a61c86181929546b3d60c447a15134d08e1 +87e0c31dcb736ea4604727e92dc1d9a3cf00adcff79df3546e02108355260f3dd171531c3c0f57be78d8b28058fcc8c0 +9617d74e8f808a4165a8ac2e30878c349e1c3d40972006f0787b31ea62d248c2d9f3fc3da83181c6e57e95feedfd0e8c +8949e2cee582a2f8db86e89785a6e46bc1565c2d8627d5b6bf43ba71ffadfab7e3c5710f88dcb5fb2fc6edf6f4fae216 +ad3fa7b0edceb83118972a2935a09f409d09a8db3869f30be3a76f67aa9fb379cabb3a3aff805ba023a331cad7d7eb64 +8c95718a4112512c4efbd496be38bf3ca6cdcaad8a0d128f32a3f9aae57f3a57bdf295a3b372a8c549fda8f4707cffed +88f3261d1e28a58b2dee3fcc799777ad1c0eb68b3560f9b4410d134672d9533532a91ea7be28a041784872632d3c9d80 +b47472a41d72dd2e8b72f5c4f8ad626737dde3717f63d6bc776639ab299e564cbad0a2ad5452a07f02ff49a359c437e5 +9896d21dc2e8aad87b76d6df1654f10cd7bceed4884159d50a818bea391f8e473e01e14684814c7780235f28e69dca6e +82d47c332bbd31bbe83b5eb44a23da76d4a7a06c45d7f80f395035822bc27f62f59281d5174e6f8e77cc9b5c3193d6f0 +95c74cd46206e7f70c9766117c34c0ec45c2b0f927a15ea167901a160e1530d8522943c29b61e03568aa0f9c55926c53 +a89d7757825ae73a6e81829ff788ea7b3d7409857b378ebccd7df73fdbe62c8d9073741cf038314971b39af6c29c9030 +8c1cd212d0b010905d560688cfc036ae6535bc334fa8b812519d810b7e7dcf1bb7c5f43deaa40f097158358987324a7f +b86993c383c015ed8d847c6b795164114dd3e9efd25143f509da318bfba89389ea72a420699e339423afd68b6512fafb +8d06bd379c6d87c6ed841d8c6e9d2d0de21653a073725ff74be1934301cc3a79b81ef6dd0aad4e7a9dc6eac9b73019bc +81af4d2d87219985b9b1202d724fe39ef988f14fef07dfe3c3b11714e90ffba2a97250838e8535eb63f107abfe645e96 +8c5e0af6330a8becb787e4b502f34f528ef5756e298a77dc0c7467433454347f3a2e0bd2641fbc2a45b95e231c6e1c02 +8e2a8f0f04562820dc8e7da681d5cad9fe2e85dd11c785fb6fba6786c57a857e0b3bd838fb849b0376c34ce1665e4837 +a39be8269449bfdfc61b1f62077033649f18dae9bef7c6163b9314ca8923691fb832f42776f0160b9e8abd4d143aa4e1 +8c154e665706355e1cc98e0a4cabf294ab019545ba9c4c399d666e6ec5c869ca9e1faf8fb06cd9c0a5c2f51a7d51b70a +a046a7d4de879d3ebd4284f08f24398e9e3bf006cd4e25b5c67273ade248689c69affff92ae810c07941e4904296a563 +afd94c1cb48758e5917804df03fb38a6da0e48cd9b6262413ea13b26973f9e266690a1b7d9d24bbaf7e82718e0e594b0 +859e21080310c8d6a38e12e2ac9f90a156578cdeb4bb2e324700e97d9a5511cd6045dc39d1d0de3f94aeed043a24119d +a219fb0303c379d0ab50893264919f598e753aac9065e1f23ef2949abc992577ab43c636a1d2c089203ec9ddb941e27d +b0fdb639d449588a2ca730afcba59334e7c387342d56defdfb7ef79c493f7fd0e5277eff18e7203e756c7bdda5803047 +87f9c3b7ed01f54368aca6dbcf2f6e06bff96e183c4b2c65f8baa23b377988863a0a125d5cdd41a072da8462ced4c070 +99ef7a5d5ac2f1c567160e1f8c95f2f38d41881850f30c461a205f7b1b9fb181277311333839b13fb3ae203447e17727 +aeaca9b1c2afd24e443326cc68de67b4d9cedb22ad7b501a799d30d39c85bb2ea910d4672673e39e154d699e12d9b3dc +a11675a1721a4ba24dd3d0e4c3c33a6edf4cd1b9f6b471070b4386c61f77452266eae6e3f566a40cfc885eada9a29f23 +b228334445e37b9b49cb4f2cc56b454575e92173ddb01370a553bba665adadd52df353ad74470d512561c2c3473c7bb9 +a18177087c996572d76f81178d18ed1ceebc8362a396348ce289f1d8bd708b9e99539be6fccd4acb1112381cfc5749b4 +8e7b8bf460f0d3c99abb19803b9e43422e91507a1c0c22b29ee8b2c52d1a384da4b87c292e28eff040db5be7b1f8641f +b03d038d813e29688b6e6f444eb56fec3abba64c3d6f890a6bcf2e916507091cdb2b9d2c7484617be6b26552ed1c56cb +a1c88ccd30e934adfc5494b72655f8afe1865a84196abfb376968f22ddc07761210b6a9fb7638f1413d1b4073d430290 +961b714faebf172ad2dbc11902461e286e4f24a99a939152a53406117767682a571057044decbeb3d3feef81f4488497 +a03dc4059b46effdd786a0a03cc17cfee8585683faa35bb07936ded3fa3f3a097f518c0b8e2db92fd700149db1937789 +adf60180c99ca574191cbcc23e8d025b2f931f98ca7dfcebfc380226239b6329347100fcb8b0fcb12db108c6ad101c07 +805d4f5ef24d46911cbf942f62cb84b0346e5e712284f82b0db223db26d51aabf43204755eb19519b00e665c7719fcaa +8dea7243e9c139662a7fe3526c6c601eee72fd8847c54c8e1f2ad93ef7f9e1826b170afe58817dac212427164a88e87f +a2ba42356606d651b077983de1ad643650997bb2babb188c9a3b27245bb65d2036e46667c37d4ce02cb1be5ae8547abe +af2ae50b392bdc013db2d12ce2544883472d72424fc767d3f5cb0ca2d973fc7d1f425880101e61970e1a988d0670c81b +98e6bec0568d3939b31d00eb1040e9b8b2a35db46ddf4369bdaee41bbb63cc84423d29ee510a170fb5b0e2df434ba589 +822ff3cd12fbef4f508f3ca813c04a2e0b9b799c99848e5ad3563265979e753ee61a48f6adc2984a850f1b46c1a43d35 +891e8b8b92a394f36653d55725ef514bd2e2a46840a0a2975c76c2a935577f85289026aaa74384da0afe26775cbddfb9 +b2a3131a5d2fe7c8967047aa66e4524babae941d90552171cc109527f345f42aa0df06dcbb2fa01b33d0043917bbed69 +80c869469900431f3eeefafdbe07b8afd8cee7739e659e6d0109b397cacff85a88247698f87dc4e2fe39a592f250ac64 +9091594f488b38f9d2bb5df49fd8b4f8829d9c2f11a197dd1431ed5abbc5c954bbde3387088f9ee3a5a834beb7619bce +b472e241e6956146cca57b97a8a204668d050423b4e76f857bad5b47f43b203a04c8391ba9d9c3e95093c071f9d376a1 +b7dd2de0284844392f7dfb56fe7ca3ede41e27519753ffc579a0a8d2d65ceb8108d06b6b0d4c3c1a2588951297bd1a1e +902116ce70d0a079ac190321c1f48701318c05f8e69ee09694754885d33a835a849cafe56f499a2f49f6cda413ddf9a7 +b18105cc736787fafaf7c3c11c448bce9466e683159dff52723b7951dff429565e466e4841d982e3aaa9ee2066838666 +97ab9911f3f659691762d568ae0b7faa1047b0aed1009c319fa79d15d0db8db9f808fc385dc9a68fa388c10224985379 +b2a2cba65f5b927e64d2904ba412e2bac1cf18c9c3eda9c72fb70262497ecf505b640827e2afebecf10eebbcf48ccd3e +b36a3fd677baa0d3ef0dac4f1548ff50a1730286b8c99d276a0a45d576e17b39b3cbadd2fe55e003796d370d4be43ce3 +a5dfec96ca3c272566e89dc453a458909247e3895d3e44831528130bc47cc9d0a0dac78dd3cad680a4351d399d241967 +8029382113909af6340959c3e61db27392531d62d90f92370a432aec3eb1e4c36ae1d4ef2ba8ec6edb4d7320c7a453f6 +971d85121ea108e6769d54f9c51299b0381ece8b51d46d49c89f65bedc123bab4d5a8bc14d6f67f4f680077529cbae4c +98ff6afc01d0bec80a278f25912e1b1ebff80117adae72e31d5b9fa4d9624db4ba2065b444df49b489b0607c45e26c4c +8fa29be10fb3ab30ce25920fec0187e6e91e458947009dabb869aade7136c8ba23602682b71e390c251f3743164cbdaa +b3345c89eb1653418fe3940cf3e56a9a9c66526389b98f45ca02dd62bfb37baa69a4baaa7132d7320695f8ea6ad1fd94 +b72c7f5541c9ac6b60a7ec9f5415e7fb14da03f7164ea529952a29399f3a071576608dbbcc0d45994f21f92ddbeb1e19 +aa3450bb155a5f9043d0ef95f546a2e6ade167280bfb75c9f09c6f9cdb1fffb7ce8181436161a538433afa3681c7a141 +92a18fecaded7854b349f441e7102b638ababa75b1b0281dd0bded6541abe7aa37d96693595be0b01fe0a2e2133d50f9 +980756ddf9d2253cfe6c94960b516c94889d09e612810935150892627d2ecee9a2517e04968eea295d0106850c04ca44 +ae68c6ccc454318cdd92f32b11d89116a3b8350207a36d22a0f626718cad671d960090e054c0c77ac3162ae180ecfd4b +99f31f66eaaa551749ad91d48a0d4e3ff4d82ef0e8b28f3184c54e852422ba1bdafd53b1e753f3a070f3b55f3c23b6a2 +a44eaeaa6589206069e9c0a45ff9fc51c68da38d4edff1d15529b7932e6f403d12b9387019c44a1488a5d5f27782a51f +b80b5d54d4b344840e45b79e621bd77a3f83fb4ce6d8796b7d6915107b3f3c34d2e7d95bdafd120f285669e5acf2437a +b36c069ec085a612b5908314d6b84c00a83031780261d1c77a0384c406867c9847d5b0845deddfa512cc04a8df2046fb +b09dbe501583220f640d201acea7ee3e39bf9eda8b91aa07b5c50b7641d86d71acb619b38d27835ce97c3759787f08e9 +87403d46a2bf63170fff0b857acacf42ee801afe9ccba8e5b4aea967b68eac73a499a65ca46906c2eb4c8f27bc739faa +82b93669f42a0a2aa5e250ffe6097269da06a9c02fcd1801abbad415a7729a64f830754bafc702e64600ba47671c2208 +8e3a3029be7edb8dd3ab1f8216664c8dc50d395f603736061d802cef77627db7b859ef287ed850382c13b4d22d6a2d80 +968e9ec7194ff424409d182ce0259acd950c384c163c04463bc8700a40b79beba6146d22b7fa7016875a249b7b31c602 +8b42c984bbe4996e0c20862059167c6bdc5164b1ffcd928f29512664459212d263e89f0f0e30eed4e672ffa5ed0b01b5 +96bac54062110dada905363211133f1f15dc7e4fd80a4c6e4a83bc9a0bcbbaba11cd2c7a13debcf0985e1a954c1da66b +a16dc8a653d67a7cd7ae90b2fffac0bf1ca587005430fe5ba9403edd70ca33e38ba5661d2ed6e9d2864400d997626a62 +a68ab11a570a27853c8d67e491591dcba746bfbee08a2e75ae0790399130d027ed387f41ef1d7de8df38b472df309161 +92532b74886874447c0300d07eda9bbe4b41ed25349a3da2e072a93fe32c89d280f740d8ff70d5816793d7f2b97373cc +88e35711b471e89218fd5f4d0eadea8a29405af1cd81974427bc4a5fb26ed60798daaf94f726c96e779b403a2cd82820 +b5c72aa4147c19f8c4f3a0a62d32315b0f4606e0a7025edc5445571eaf4daff64f4b7a585464821574dd50dbe1b49d08 +9305d9b4095258e79744338683fd93f9e657367b3ab32d78080e51d54eec331edbc224fad5093ebf8ee4bd4286757eb8 +b2a17abb3f6a05bcb14dc7b98321fa8b46d299626c73d7c6eb12140bf4c3f8e1795250870947af817834f033c88a59d6 +b3477004837dbd8ba594e4296f960fc91ab3f13551458445e6c232eb04b326da803c4d93e2e8dcd268b4413305ff84da +924b4b2ebaafdcfdfedb2829a8bf46cd32e1407d8d725a5bd28bdc821f1bafb3614f030ea4352c671076a63494275a3f +8b81b9ef6125c82a9bece6fdcb9888a767ac16e70527753428cc87c56a1236e437da8be4f7ecfe57b9296dc3ae7ba807 +906e19ec8b8edd58bdf9ae05610a86e4ea2282b1bbc1e8b00b7021d093194e0837d74cf27ac9916bdb8ec308b00da3da +b41c5185869071760ac786078a57a2ab4e2af60a890037ac0c0c28d6826f15c2cf028fddd42a9b6de632c3d550bfbc14 +a646e5dec1b713ae9dfdf7bdc6cd474d5731a320403c7dfcfd666ffc9ae0cff4b5a79530e8df3f4aa9cb80568cb138e9 +b0efad22827e562bd3c3e925acbd0d9425d19057868608d78c2209a531cccd0f2c43dc5673acf9822247428ffa2bb821 +a94c19468d14b6f99002fc52ac06bbe59e5c472e4a0cdb225144a62f8870b3f10593749df7a2de0bd3c9476ce682e148 +803864a91162f0273d49271dafaab632d93d494d1af935aefa522768af058fce52165018512e8d6774976d52bd797e22 +a08711c2f7d45c68fb340ac23597332e1bcaec9198f72967b9921204b9d48a7843561ff318f87908c05a44fc35e3cc9d +91c3cad94a11a3197ae4f9461faab91a669e0dddb0371d3cab3ed9aeb1267badc797d8375181130e461eadd05099b2a2 +81bdaaf48aae4f7b480fc13f1e7f4dd3023a41439ba231760409ce9292c11128ab2b0bdbbf28b98af4f97b3551f363af +8d60f9df9fd303f625af90e8272c4ecb95bb94e6efc5da17b8ab663ee3b3f673e9f6420d890ccc94acf4d2cae7a860d8 +a7b75901520c06e9495ab983f70b61483504c7ff2a0980c51115d11e0744683ce022d76e3e09f4e99e698cbd21432a0d +82956072df0586562fda7e7738226f694e1c73518dd86e0799d2e820d7f79233667192c9236dcb27637e4c65ef19d493 +a586beb9b6ffd06ad200957490803a7cd8c9bf76e782734e0f55e04a3dc38949de75dc607822ec405736c576cf83bca3 +a179a30d00def9b34a7e85607a447eea0401e32ab5abeee1a281f2acd1cf6ec81a178020666f641d9492b1bdf66f05a3 +83e129705c538787ed8e0fdc1275e6466a3f4ee21a1e6abedd239393b1df72244723b92f9d9d9339a0cab6ebf28f5a16 +811bd8d1e3722b64cd2f5b431167e7f91456e8bba2cc669d3fbbce7d553e29c3c19f629fcedd2498bc26d33a24891d17 +a243c030c858f1f60cccd26b45b024698cc6d9d9e6198c1ed4964a235d9f8d0baf9cde10c8e63dfaa47f8e74e51a6e85 +ab839eb82e23ca52663281f863b55b0a3d6d4425c33ffb4eeb1d7979488ab068bf99e2a60e82cea4dc42c56c26cbfebe +8b896f9bb21d49343e67aec6ad175b58c0c81a3ca73d44d113ae4354a0065d98eb1a5cafedaf232a2bb9cdc62152f309 +af6230340cc0b66f5bf845540ed4fc3e7d6077f361d60762e488d57834c3e7eb7eacc1b0ed73a7d134f174a01410e50c +88975e1b1af678d1b5179f72300a30900736af580dd748fd9461ef7afccc91ccd9bed33f9da55c8711a7635b800e831f +a97486bb9047391661718a54b8dd5a5e363964e495eae6c692730264478c927cf3e66dd3602413189a3699fbeae26e15 +a5973c161ab38732885d1d2785fd74bf156ba34881980cba27fe239caef06b24a533ffe6dbbbeca5e6566682cc00300a +a24776e9a840afda0003fa73b415d5bd6ecd9b5c2cc842b643ee51b8c6087f4eead4d0bfbd987eb174c489a7b952ff2a +a8a6ee06e3af053b705a12b59777267c546f33ba8a0f49493af8e6df4e15cf8dd2d4fb4daf7e84c6b5d3a7363118ff03 +a28e59ce6ad02c2ce725067c0123117e12ac5a52c8f5af13eec75f4a9efc4f696777db18a374fa33bcae82e0734ebd16 +86dfc3b78e841c708aff677baa8ee654c808e5d257158715097c1025d46ece94993efe12c9d188252ad98a1e0e331fec +a88d0275510f242eab11fdb0410ff6e1b9d7a3cbd3658333539815f1b450a84816e6613d15aa8a8eb15d87cdad4b27a2 +8440acea2931118a5b481268ff9f180ee4ede85d14a52c026adc882410825b8275caa44aff0b50c2b88d39f21b1a0696 +a7c3182eab25bd6785bacf12079d0afb0a9b165d6ed327814e2177148539f249eb9b5b2554538f54f3c882d37c0a8abe +85291fbe10538d7da38efdd55a7acebf03b1848428a2f664c3ce55367aece60039f4f320b1771c9c89a35941797f717c +a2c6414eeb1234728ab0de94aa98fc06433a58efa646ca3fcbd97dbfb8d98ae59f7ce6d528f669c8149e1e13266f69c9 +840c8462785591ee93aee2538d9f1ec44ba2ca61a569ab51d335ac873f5d48099ae8d7a7efa0725d9ff8f9475bfa4f56 +a7065a9d02fb3673acf7702a488fbc01aa69580964932f6f40b6c2d1c386b19e50b0e104fcac24ea26c4e723611d0238 +b72db6d141267438279e032c95e6106c2ccb3164b842ba857a2018f3a35f4b040da92680881eb17cd61d0920d5b8f006 +a8005d6c5960e090374747307ef0be2871a7a43fa4e76a16c35d2baab808e9777b496e9f57a4218b23390887c33a0b55 +8e152cea1e00a451ca47c20a1e8875873419700af15a5f38ee2268d3fbc974d4bd5f4be38008fa6f404dbdedd6e6e710 +a3391aed1fcd68761f06a7d1008ec62a09b1cb3d0203cd04e300a0c91adfed1812d8bc1e4a3fd7976dc0aae0e99f52f1 +967eb57bf2aa503ee0c6e67438098149eac305089c155f1762cf5e84e31f0fbf27c34a9af05621e34645c1ec96afaec8 +88af97ddc4937a95ec0dcd25e4173127260f91c8db2f6eac84afb789b363705fb3196235af631c70cafd09411d233589 +a32df75b3f2c921b8767638fd289bcfc61e08597170186637a7128ffedd52c798c434485ac2c7de07014f9e895c2c3d8 +b0a783832153650aa0d766a3a73ec208b6ce5caeb40b87177ffc035ab03c7705ecdd1090b6456a29f5fb7e90e2fa8930 +b59c8e803b4c3486777d15fc2311b97f9ded1602fa570c7b0200bada36a49ee9ef4d4c1474265af8e1c38a93eb66b18b +982f2c85f83e852022998ff91bafbb6ff093ef22cf9d5063e083a48b29175ccbd51b9c6557151409e439096300981a6c +939e3b5989fefebb9d272a954659a4eb125b98c9da6953f5e628d26266bd0525ec38304b8d56f08d65abc4d6da4a8dbb +8898212fe05bc8de7d18503cb84a1c1337cc2c09d1eeef2b475aa79185b7322bf1f8e065f1bf871c0c927dd19faf1f6d +94b0393a41cd00f724aee2d4bc72103d626a5aecb4b5486dd1ef8ac27528398edf56df9db5c3d238d8579af368afeb09 +96ac564450d998e7445dd2ea8e3fc7974d575508fa19e1c60c308d83b645864c029f2f6b7396d4ff4c1b24e92e3bac37 +8adf6638e18aff3eb3b47617da696eb6c4bdfbecbbc3c45d3d0ab0b12cbad00e462fdfbe0c35780d21aa973fc150285e +b53f94612f818571b5565bbb295e74bada9b5f9794b3b91125915e44d6ddcc4da25510eab718e251a09c99534d6042d9 +8b96462508d77ee083c376cd90807aebad8de96bca43983c84a4a6f196d5faf6619a2351f43bfeec101864c3bf255519 +aeadf34657083fc71df33bd44af73bf5281c9ca6d906b9c745536e1819ea90b56107c55e2178ebad08f3ba75b3f81c86 +9784ba29b2f0057b5af1d3ab2796d439b8753f1f749c73e791037461bdfc3f7097394283105b8ab01788ea5255a96710 +8756241bda159d4a33bf74faba0d4594d963c370fb6a18431f279b4a865b070b0547a6d1613cf45b8cfb5f9236bbf831 +b03ebfd6b71421dfd49a30460f9f57063eebfe31b9ceaa2a05c37c61522b35bdc09d7db3ad75c76c253c00ba282d3cd2 +b34e7e6341fa9d854b2d3153bdda0c4ae2b2f442ab7af6f99a0975d45725aa48e36ae5f7011edd249862e91f499687d4 +b462ee09dc3963a14354244313e3444de5cc37ea5ccfbf14cd9aca8027b59c4cb2a949bc30474497cab8123e768460e6 +aea753290e51e2f6a21a9a0ee67d3a2713f95c2a5c17fe41116c87d3aa77b1683761264d704df1ac34f8b873bc88ef7b +98430592afd414394f98ddfff9f280fcb1c322dbe3510f45e1e9c4bb8ee306b3e0cf0282c0ee73ebb8ba087d4d9e0858 +b95d3b5aaf54ffca11f4be8d57f76e14afdb20afc859dc7c7471e0b42031e8f3d461b726ecb979bdb2f353498dfe95ea +984d17f9b11a683132e0b5a9ee5945e3ff7054c2d5c716be73b29078db1d36f54c6e652fd2f52a19da313112e97ade07 +ab232f756b3fff3262be418a1af61a7e0c95ceebbc775389622a8e10610508cd6784ab7960441917a83cc191c58829ea +a28f41678d6e60de76b0e36ab10e4516e53e02e9c77d2b5af3cfeee3ce94cfa30c5797bd1daab20c98e1cad83ad0f633 +b55395fca84dd3ccc05dd480cb9b430bf8631ff06e24cb51d54519703d667268c2f8afcde4ba4ed16bece8cc7bc8c6e0 +8a8a5392a0e2ea3c7a8c51328fab11156004e84a9c63483b64e8f8ebf18a58b6ffa8fe8b9d95af0a2f655f601d096396 +ab480000fe194d23f08a7a9ec1c392334e9c687e06851f083845121ce502c06b54dda8c43092bcc1035df45cc752fe9b +b265644c29f628d1c7e8e25a5e845cabb21799371814730a41a363e1bda8a7be50fee7c3996a365b7fcba4642add10db +b8a915a3c685c2d4728f6931c4d29487cad764c5ce23c25e64b1a3259ac27235e41b23bfe7ae982921b4cb84463097df +8efa7338442a4b6318145a5440fc213b97869647eeae41b9aa3c0a27ee51285b73e3ae3b4a9423df255e6add58864aa9 +9106d65444f74d217f4187dfc8fcf3810b916d1e4275f94f6a86d1c4f3565b131fd6cde1fa708bc05fe183c49f14941a +948252dac8026bbbdb0a06b3c9d66ec4cf9532163bab68076fda1bd2357b69e4b514729c15aaa83b5618b1977bbc60c4 +ae6596ccfdf5cbbc5782efe3bb0b101bb132dbe1d568854ca24cacc0b2e0e9fabcb2ca7ab42aecec412efd15cf8cb7a2 +84a0b6c198ff64fd7958dfd1b40eac9638e8e0b2c4cd8cf5d8cdf80419baee76a05184bce6c5b635f6bf2d30055476a7 +8893118be4a055c2b3da593dbca51b1ae2ea2469911acfb27ee42faf3e6c3ad0693d3914c508c0b05b36a88c8b312b76 +b097479e967504deb6734785db7e60d1d8034d6ca5ba9552887e937f5e17bb413fccac2c1d1082154ed76609127860ad +a0294e6b9958f244d29943debf24b00b538b3da1116269b6e452bb12dc742226712fd1a15b9c88195afeb5d2415f505c +b3cc15f635080bc038f61b615f62b5b5c6f2870586191f59476e8368a73641d6ac2f7d0c1f54621982defdb318020230 +99856f49b9fe1604d917c94d09cc0ed753d13d015d30587a94e6631ffd964b214e607deb8a69a8b5e349a7edf4309206 +a8571e113ea22b4b4fce41a094da8c70de37830ae32e62c65c2fa5ad06a9bc29e884b945e73d448c72b176d6ecebfb58 +a9e9c6e52beb0013273c29844956b3ce291023678107cdc785f7b44eff5003462841ad8780761b86aefc6b734adde7cf +80a784b0b27edb51ef2bad3aee80e51778dcaa0f3f5d3dcb5dc5d4f4b2cf7ae35b08de6680ea9dac53f8438b92eb09ef +827b543e609ea328e97e373f70ad72d4915a2d1daae0c60d44ac637231070e164c43a2a58db80a64df1c624a042b38f9 +b449c65e8195202efdcb9bdb4e869a437313b118fef8b510cbbf8b79a4e99376adb749b37e9c20b51b31ed3310169e27 +8ea3028f4548a79a94c717e1ed28ad4d8725b8d6ab18b021063ce46f665c79da3c49440c6577319dab2d036b7e08f387 +897798431cfb17fe39f08f5f854005dc37b1c1ec1edba6c24bc8acb3b88838d0534a75475325a5ea98b326ad47dbad75 +89cf232e6303b0751561960fd4dea5754a28c594daf930326b4541274ffb03c7dd75938e411eb9a375006a70ce38097f +9727c6ae7f0840f0b6c8bfb3a1a5582ceee705e0b5c59b97def7a7a2283edd4d3f47b7971e902a3a2079e40b53ff69b8 +b76ed72b122c48679d221072efc0eeea063cb205cbf5f9ef0101fd10cb1075b8628166c83577cced654e1c001c7882f7 +ae908c42d208759da5ee9b405df85a6532ea35c6f0f6a1288d22870f59d98edc896841b8ac890a538e6c8d1e8b02d359 +809d12fe4039a0ec80dc9be6a89acaab7797e5f7f9b163378f52f9a75a1d73b2e9ae6e3dd49e32ced439783c1cabbef5 +a4149530b7f85d1098ba534d69548c6c612c416e8d35992fc1f64f4deeb41e09e49c6cf7aadbed7e846b91299358fe2d +a49342eacd1ec1148b8df1e253b1c015f603c39de11fa0a364ccb86ea32d69c34fd7aa6980a1fadcd8e785a57fa46f60 +87d43eff5a006dc4dddcf76cc96c656a1f3a68f19f124181feab86c6cc9a52cb9189cdbb423414defdd9bb0ca8ff1ddc +861367e87a9aa2f0f68296ba50aa5dbc5713008d260cc2c7e62d407c2063064749324c4e8156dc21b749656cfebce26b +b5303c2f72e84e170e66ae1b0fbd51b8c7a6f27476eaf5694b64e8737d5c84b51fe90100b256465a4c4156dd873cddb0 +b62849a4f891415d74f434cdc1d23c4a69074487659ca96e1762466b2b7a5d8525b056b891d0feea6fe6845cba8bc7fb +923dd9e0d6590a9307e8c4c23f13bae3306b580e297a937711a8b13e8de85e41a61462f25b7d352b682e8437bf2b4ab3 +9147379860cd713cd46c94b8cdf75125d36c37517fbecf81ace9680b98ce6291cd1c3e472f84249cc3b2b445e314b1b6 +a808a4f17ac21e3fb5cfef404e61fae3693ca3e688d375f99b6116779696059a146c27b06de3ac36da349b0649befd56 +87787e9322e1b75e66c1f0d9ea0915722a232770930c2d2a95e9478c4b950d15ab767e30cea128f9ed65893bfc2d0743 +9036a6ee2577223be105defe1081c48ea7319e112fff9110eb9f61110c319da25a6cea0464ce65e858635b079691ef1f +af5548c7c24e1088c23b57ee14d26c12a83484c9fd9296edf1012d8dcf88243f20039b43c8c548c265ef9a1ffe9c1c88 +a0fff520045e14065965fb8accd17e878d3fcaf9e0af2962c8954e50be6683d31fa0bf4816ab68f08630dbac6bfce52a +b4c1b249e079f6ae1781af1d97a60b15855f49864c50496c09c91fe1946266915b799f0406084d7783f5b1039116dd8b +8b0ffa5e7c498cb3879dddca34743b41eee8e2dea3d4317a6e961b58adb699ef0c92400c068d5228881a2b08121226bf +852ae8b19a1d80aa8ae5382e7ee5c8e7670ceb16640871c56b20b96b66b3b60e00015a3dde039446972e57b49a999ddd +a49942f04234a7d8492169da232cfff8051df86e8e1ba3db46aede02422c689c87dc1d99699c25f96cb763f5ca0983e5 +b04b597b7760cf5dcf411ef896d1661e6d5b0db3257ac2cf64b20b60c6cc18fa10523bb958a48d010b55bac7b02ab3b1 +a494591b51ea8285daecc194b5e5bd45ae35767d0246ac94fae204d674ee180c8e97ff15f71f28b7aeb175b8aea59710 +97d2624919e78406e7460730680dea8e71c8571cf988e11441aeea54512b95bd820e78562c99372d535d96f7e200d20d +ac693ddb00e48f76e667243b9b6a7008424043fb779e4f2252330285232c3fccac4da25cbd6d95fe9ad959ff305a91f6 +8d20ca0a71a64a3f702a0825bb46bd810d03bebfb227683680d474a52f965716ff99e19a165ebaf6567987f4f9ee3c94 +a5c516a438f916d1d68ca76996404792e0a66e97b7f18fc54c917bf10cf3211b62387932756e39e67e47b0bd6e88385a +b089614d830abc0afa435034cec7f851f2f095d479cacf1a3fb57272da826c499a52e7dcbc0eb85f4166fb94778e18e9 +a8dacc943765d930848288192f4c69e2461c4b9bc6e79e30eeef9a543318cf9ae9569d6986c65c5668a89d49993f8e07 +ab5a9361fa339eec8c621bdad0a58078983abd8942d4282b22835d7a3a47e132d42414b7c359694986f7db39386c2e19 +94230517fb57bd8eb26c6f64129b8b2abd0282323bf7b94b8bac7fab27b4ecc2c4290c294275e1a759de19f2216134f3 +b8f158ea5006bc3b90b285246625faaa6ac9b5f5030dc69701b12f3b79a53ec7e92eeb5a63bbd1f9509a0a3469ff3ffc +8b6944fd8cb8540957a91a142fdcda827762aa777a31e8810ca6d026e50370ee1636fc351724767e817ca38804ebe005 +82d1ee40fe1569c29644f79fa6c4033b7ed45cd2c3b343881f6eb0de2e79548fded4787fae19bed6ee76ed76ff9f2f11 +a8924c7035e99eaed244ca165607e7e568b6c8085510dcdbaf6ebdbed405af2e6c14ee27d94ffef10d30aa52a60bf66d +956f82a6c2ae044635e85812581e4866c5fa2f427b01942047d81f6d79a14192f66fbbe77c9ffeaef4e6147097fdd2b5 +b1100255a1bcf5e05b6aff1dfeb6e1d55b5d68d43a7457ba10cc76b61885f67f4d0d5179abda786e037ae95deb8eea45 +99510799025e3e5e8fbf06dedb14c060c6548ba2bda824f687d3999dc395e794b1fb6514b9013f3892b6cf65cb0d65aa +8f9091cebf5e9c809aab415942172258f894e66e625d7388a05289183f01b8d994d52e05a8e69f784fba41db9ea357f0 +a13d2eeb0776bdee9820ecb6693536720232848c51936bb4ef4fe65588d3f920d08a21907e1fdb881c1ad70b3725e726 +a68b8f18922d550284c5e5dc2dda771f24c21965a6a4d5e7a71678178f46df4d8a421497aad8fcb4c7e241aba26378a0 +8b7601f0a3c6ad27f03f2d23e785c81c1460d60100f91ea9d1cab978aa03b523150206c6d52ce7c7769c71d2c8228e9e +a8e02926430813caa851bb2b46de7f0420f0a64eb5f6b805401c11c9091d3b6d67d841b5674fa2b1dce0867714124cd8 +b7968ecba568b8193b3058400af02c183f0a6df995a744450b3f7e0af7a772454677c3857f99c140bbdb2a09e832e8e0 +8f20b1e9ba87d0a3f35309b985f3c18d2e8800f1ca7f0c52cadef773f1496b6070c936eea48c4a1cae83fd2524e9d233 +88aef260042db0d641a51f40639dbeeefa9e9811df30bee695f3791f88a2f84d318f04e8926b7f47bf25956cb9e3754f +9725345893b647e9ba4e6a29e12f96751f1ae25fcaec2173e9a259921a1a7edb7a47159b3c8767e44d9e2689f5aa0f72 +8c281e6f72752cb11e239e4df9341c45106eb7993c160e54423c2bffe10bc39d42624b45a1f673936ef2e1a02fc92f1a +90aba2f68bddb2fcce6c51430dacdfeec43ea8dc379660c99095df11017691ccf5faa27665cf4b9f0eea7728ae53c327 +b7022695c16521c5704f49b7ddbdbec9b5f57ce0ceebe537bc0ebb0906d8196cc855a9afeb8950a1710f6a654464d93f +8fe1b9dd3c6a258116415d36e08374e094b22f0afb104385a5da48be17123e86fb8327baacc4f0d9ebae923d55d99bb5 +817e85d8e3d19a4cbc1dec31597142c2daa4871bda89c2177fa719c00eda3344eb08b82eb92d4aa91a9eaacb3fc09783 +b59053e1081d2603f1ca0ba553804d6fa696e1fd996631db8f62087b26a40dfef02098b0326bb75f99ec83b9267ca738 +990a173d857d3ba81ff3789b931bfc9f5609cde0169b7f055fa3cb56451748d593d62d46ba33f80f9cafffe02b68dd14 +b0c538dbba4954b809ab26f9f94a3cf1dcb77ce289eaec1d19f556c0ae4be1fa03af4a9b7057837541c3cc0a80538736 +ac3ba42f5f44f9e1fc453ce49c4ab79d0e1d5c42d3b30b1e098f3ab3f414c4c262fa12fb2be249f52d4aaf3c5224beb9 +af47467eb152e59870e21f0d4da2f43e093daf40180ab01438030684b114d025326928eaab12c41b81a066d94fce8436 +98d1b58ba22e7289b1c45c79a24624f19b1d89e00f778eef327ec4856a9a897278e6f1a9a7e673844b31dde949153000 +97ccb15dfadc7c59dca08cfe0d22df2e52c684cf97de1d94bc00d7ba24e020025130b0a39c0f4d46e4fc872771ee7875 +b699e4ed9a000ff96ca296b2f09dce278832bc8ac96851ff3cff99ed3f6f752cfc0fea8571be28cd9b5a7ec36f1a08ee +b9f49f0edb7941cc296435ff0a912e3ad16848ee8765ab5f60a050b280d6ea585e5b34051b15f6b8934ef01ceb85f648 +ac3893df7b4ceab23c6b9054e48e8ba40d6e5beda8fbe90b814f992f52494186969b35d8c4cdc3c99890a222c9c09008 +a41293ad22fae81dea94467bc1488c3707f3d4765059173980be93995fa4fcc3c9340796e3eed0beeb0ba0d9bb4fa3aa +a0543e77acd2aeecde13d18d258aeb2c7397b77f17c35a1992e8666ea7abcd8a38ec6c2741bd929abba2f766138618cc +92e79b22bc40e69f6527c969500ca543899105837b6b1075fa1796755c723462059b3d1b028e0b3df2559fa440e09175 +a1fa1eac8f41a5197a6fb4aa1eae1a031c89f9c13ff9448338b222780cf9022e0b0925d930c37501a0ef7b2b00fdaf83 +b3cb29ff73229f0637335f28a08ad8c5f166066f27c6c175164d0f26766a927f843b987ee9b309ed71cbf0a65d483831 +84d4ab787f0ac00f104f4a734dc693d62d48c2aeb03913153da62c2ae2c27d11b1110dcef8980368dd84682ea2c1a308 +ab6a8e4bbc78d4a7b291ad3e9a8fe2d65f640524ba3181123b09d2d18a9e300e2509ccf7000fe47e75b65f3e992a2e7e +b7805ebe4f1a4df414003dc10bca805f2ab86ca75820012653e8f9b79c405196b0e2cab099f2ab953d67f0d60d31a0f9 +b12c582454148338ea605d22bd00a754109063e22617f1f8ac8ddf5502c22a181c50c216c3617b9852aa5f26af56b323 +86333ad9f898947e31ce747728dc8c887479e18d36ff3013f69ebef807d82c6981543b5c3788af93c4d912ba084d3cba +b514efa310dc4ad1258add138891e540d8c87142a881b5f46563cc58ecd1488e6d3a2fca54c0b72a929f3364ca8c333e +aa0a30f92843cf2f484066a783a1d75a7aa6f41f00b421d4baf20a6ac7886c468d0eea7ca8b17dd22f4f74631b62b640 +b3b7dc63baec9a752e8433c0cdee4d0f9bc41f66f2b8d132faf925eef9cf89aae756fc132c45910f057122462605dc10 +b9b8190dac5bfdeb59fd44f4da41a57e7f1e7d2c21faba9da91fa45cbeca06dcf299c9ae22f0c89ece11ac46352d619f +89f8cf36501ad8bdfeab863752a9090e3bfda57cf8fdeca2944864dc05925f501e252c048221bcc57136ab09a64b64b2 +b0cbfaf317f05f97be47fc9d69eda2dd82500e00d42612f271a1fe24626408c28881f171e855bd5bd67409f9847502b4 +a7c21a8fcede581bfd9847b6835eda62ba250bea81f1bb17372c800a19c732abe03064e64a2f865d974fb636cab4b859 +95f9df524ba7a4667351696c4176b505d8ea3659f5ff2701173064acc624af69a0fad4970963736383b979830cb32260 +856a74fe8b37a2e3afeac858c8632200485d438422a16ae3b29f359e470e8244995c63ad79c7e007ed063f178d0306fd +b37faa4d78fdc0bb9d403674dbea0176c2014a171c7be8527b54f7d1a32a76883d3422a3e7a5f5fcc5e9b31b57822eeb +8d37234d8594ec3fe75670b5c9cc1ec3537564d4739b2682a75b18b08401869a4264c0f264354219d8d896cded715db4 +b5289ee5737f0e0bde485d32096d23387d68dab8f01f47821ab4f06cc79a967afe7355e72dc0c751d96b2747b26f6255 +9085e1fdf9f813e9c3b8232d3c8863cd84ab30d45e8e0d3d6a0abd9ebc6fd70cdf749ff4d04390000e14c7d8c6655fc7 +93a388c83630331eca4da37ea4a97b3b453238af474817cc0a0727fd3138dcb4a22de38c04783ec829c22cb459cb4e8e +a5377116027c5d061dbe24c240b891c08cdd8cd3f0899e848d682c873aff5b8132c1e7cfe76d2e5ed97ee0eb1d42cb68 +a274c84b04338ed28d74683e2a7519c2591a3ce37c294d6f6e678f7d628be2db8eff253ede21823e2df7183e6552f622 +8bc201147a842453a50bec3ac97671397bc086d6dfc9377fa38c2124cdc286abda69b7324f47d64da094ae011d98d9d9 +9842d0c066c524592b76fbec5132bc628e5e1d21c424bec4555efca8619cc1fd8ea3161febcb8b9e8ab54702f4e815e2 +a19191b713a07efe85c266f839d14e25660ee74452e6c691cd9997d85ae4f732052d802d3deb018bdd847caa298a894b +a24f71fc0db504da4e287dd118a4a74301cbcd16033937ba2abc8417956fcb4ae19b8e63b931795544a978137eff51cb +a90eec4a6a3a4b8f9a5b93d978b5026fcf812fe65585b008d7e08c4aaf21195a1d0699f12fc16f79b6a18a369af45771 +8b551cf89737d7d06d9b3b9c4c1c73b41f2ea0af4540999c70b82dabff8580797cf0a3caf34c86c59a7069eb2e38f087 +b8d312e6c635e7a216a1cda075ae77ba3e1d2fd501dc31e83496e6e81ed5d9c7799f8e578869c2e0e256fb29f5de10a7 +8d144bdb8cae0b2cdb5b33d44bbc96984a5925202506a8cc65eb67ac904b466f5a7fe3e1cbf04aa785bbb7348c4bb73c +a101b3d58b7a98659244b88de0b478b3fb87dc5fc6031f6e689b99edf498abd43e151fd32bd4bbd240e0b3e59c440359 +907453abca7d8e7151a05cc3d506c988007692fe7401395dc93177d0d07d114ab6cca0cc658eb94c0223fe8658295cad +825329ffbe2147ddb68f63a0a67f32d7f309657b8e5d9ab5bb34b3730bfa2c77a23eaaadb05def7d9f94a9e08fdc1e96 +88ee923c95c1dac99ae7ed6067906d734d793c5dc5d26339c1bb3314abe201c5dccb33b9007351885eb2754e9a8ea06c +98bc9798543f5f1adc9f2cfcfa72331989420e9c3f6598c45269f0dc9b7c8607bbeaf03faa0aea2ddde2b8f17fdceff5 +8ee87877702a79aef923ab970db6fa81561b3c07d5bf1a072af0a7bad765b4cbaec910afe1a91703feacc7822fa38a94 +8060b9584aa294fe8adc2b22f67e988bc6da768eae91e429dcc43ddc53cfcc5d6753fdc1b420b268c7eb2fb50736a970 +b344a5524d80a2f051870c7001f74fcf348a70fcf78dbd20c6ff9ca85d81567d2318c8b8089f2c4f195d6aec9fc15fa6 +8f5a5d893e1936ed062149d20eb73d98b62b7f50ab5d93a6429c03656b36688d1c80cb5010e4977491e51fa0d7dd35d5 +86fa32ebbf97328c5f5f15564e1238297e289ec3219b9a741724e9f3ae8d5c15277008f555863a478b247ba5dc601d44 +9557e55377e279f4b6b5e0ffe01eca037cc13aac242d67dfcd0374a1e775c5ed5cb30c25fe21143fee54e3302d34a3ea +8cb6bcbc39372d23464a416ea7039f57ba8413cf3f00d9a7a5b356ab20dcb8ed11b3561f7bce372b8534d2870c7ee270 +b5d59075cb5abde5391f64b6c3b8b50adc6e1f654e2a580b6d6d6eff3f4fbdd8fffc92e06809c393f5c8eab37f774c4b +afcfb6903ef13e493a1f7308675582f15af0403b6553e8c37afb8b2808ad21b88b347dc139464367dc260df075fea1ad +810fbbe808375735dd22d5bc7fc3828dc49fdd22cc2d7661604e7ac9c4535c1df578780affb3b895a0831640a945bcad +8056b0c678803b416f924e09a6299a33cf9ad7da6fe1ad7accefe95c179e0077da36815fde3716711c394e2c5ea7127f +8b67403702d06979be19f1d6dc3ec73cc2e81254d6b7d0cc49cd4fdda8cd51ab0835c1d2d26fc0ecab5df90585c2f351 +87f97f9e6d4be07e8db250e5dd2bffdf1390665bc5709f2b631a6fa69a7fca958f19bd7cc617183da1f50ee63e9352b5 +ae151310985940471e6803fcf37600d7fa98830613e381e00dab943aec32c14162d51c4598e8847148148000d6e5af5c +81eb537b35b7602c45441cfc61b27fa9a30d3998fad35a064e05bc9479e9f10b62eba2b234b348219eea3cadcaac64bb +8a441434934180ab6f5bc541f86ebd06eadbee01f438836d797e930fa803a51510e005c9248cecc231a775b74d12b5e9 +81f3c250a27ba14d8496a5092b145629eb2c2e6a5298438670375363f57e2798207832c8027c3e9238ad94ecdadfc4df +a6217c311f2f3db02ceaa5b6096849fe92b6f4b6f1491535ef8525f6ccee6130bed2809e625073ecbaddd4a3eb3df186 +82d1c396f0388b942cf22b119d7ef1ad03d3dad49a74d9d01649ee284f377c8daddd095d596871669e16160299a210db +a40ddf7043c5d72a7246bd727b07f7fff1549f0e443d611de6f9976c37448b21664c5089c57f20105102d935ab82f27b +b6c03c1c97adf0c4bf4447ec71366c6c1bff401ba46236cd4a33d39291e7a1f0bb34bd078ba3a18d15c98993b153a279 +8a94f5f632068399c359c4b3a3653cb6df2b207379b3d0cdace51afdf70d6d5cce6b89a2b0fee66744eba86c98fb21c2 +b2f19e78ee85073f680c3bba1f07fd31b057c00b97040357d97855b54a0b5accb0d3b05b2a294568fcd6a4be6f266950 +a74632d13bbe2d64b51d7a9c3ae0a5a971c19f51cf7596a807cea053e6a0f3719700976d4e394b356c0329a2dced9aa2 +afef616d341a9bc94393b8dfba68ff0581436aa3a3adb7c26a1bbf2cf19fa877066191681f71f17f3cd6f9cf6bf70b5a +8ce96d93ae217408acf7eb0f9cbb9563363e5c7002e19bbe1e80760bc9d449daee2118f3878b955163ed664516b97294 +8414f79b496176bc8b8e25f8e4cfee28f4f1c2ddab099d63d2aca1b6403d26a571152fc3edb97794767a7c4686ad557c +b6c61d01fd8ce087ef9f079bf25bf10090db483dd4f88c4a786d31c1bdf52065651c1f5523f20c21e75cea17df69ab73 +a5790fd629be70545093631efadddc136661f63b65ec682609c38ef7d3d7fa4e56bdf94f06e263bc055b90cb1c6bcefe +b515a767e95704fb7597bca9e46f1753abacdc0e56e867ee3c6f4cd382643c2a28e65312c05ad040eaa3a8cbe7217a65 +8135806a02ead6aa92e9adb6fefb91349837ab73105aaa7be488ef966aa8dfaafdfa64bbae30fcbfa55dd135a036a863 +8f22435702716d76b1369750694540742d909d5e72b54d0878245fab7c269953b1c6f2b29c66f08d5e0263ca3a731771 +8e0f8a8e8753e077dac95848212aeffd51c23d9b6d611df8b102f654089401954413ecbedc6367561ca599512ae5dda7 +815a9084e3e2345f24c5fa559deec21ee1352fb60f4025c0779be65057f2d528a3d91593bd30d3a185f5ec53a9950676 +967e6555ccba395b2cc1605f8484c5112c7b263f41ce8439a99fd1c71c5ed14ad02684d6f636364199ca48afbbde13be +8cd0ccf17682950b34c796a41e2ea7dd5367aba5e80a907e01f4cdc611e4a411918215e5aebf4292f8b24765d73314a6 +a58bf1bbb377e4b3915df6f058a0f53b8fb8130fdec8c391f6bc82065694d0be59bb67ffb540e6c42cc8b380c6e36359 +92af3151d9e6bfb3383d85433e953c0160859f759b0988431ec5893542ba40288f65db43c78a904325ef8d324988f09d +8011bbb05705167afb47d4425065630f54cb86cd462095e83b81dfebf348f846e4d8fbcf1c13208f5de1931f81da40b9 +81c743c104fc3cb047885c9fa0fb9705c3a83ee24f690f539f4985509c3dafd507af3f6a2128276f45d5939ef70c167f +a2c9679b151c041aaf5efeac5a737a8f70d1631d931609fca16be1905682f35e291292874cb3b03f14994f98573c6f44 +a4949b86c4e5b1d5c82a337e5ce6b2718b1f7c215148c8bfb7e7c44ec86c5c9476048fc5c01f57cb0920876478c41ad6 +86c2495088bd1772152e527a1da0ef473f924ea9ab0e5b8077df859c28078f73c4e22e3a906b507fdf217c3c80808b5c +892e0a910dcf162bcea379763c3e2349349e4cda9402949255ac4a78dd5a47e0bf42f5bd0913951576b1d206dc1e536a +a7009b2c6b396138afe4754b7cc10dee557c51c7f1a357a11486b3253818531f781ea8107360c8d4c3b1cd96282353c0 +911763ef439c086065cc7b4e57484ed6d693ea44acee4b18c9fd998116da55fbe7dcb8d2a0f0f9b32132fca82d73dff6 +a722000b95a4a2d40bed81870793f15ba2af633f9892df507f2842e52452e02b5ea8dea6a043c2b2611d82376e33742a +9387ac49477bd719c2f92240d0bdfcf9767aad247ca93dc51e56106463206bc343a8ec855eb803471629a66fffb565d6 +92819a1fa48ab4902939bb72a0a4e6143c058ea42b42f9bc6cea5df45f49724e2530daf3fc4f097cceefa2a8b9db0076 +98eac7b04537653bc0f4941aae732e4b1f84bd276c992c64a219b8715eb1fb829b5cbd997d57feb15c7694c468f95f70 +b275e7ba848ce21bf7996e12dbeb8dadb5d0e4f1cb5a0248a4f8f9c9fe6c74e3c93f4b61edbcb0a51af5a141e1c14bc7 +97243189285aba4d49c53770c242f2faf5fd3914451da4931472e3290164f7663c726cf86020f8f181e568c72fd172d1 +839b0b3c25dd412bee3dc24653b873cc65454f8f16186bb707bcd58259c0b6765fa4c195403209179192a4455c95f3b8 +8689d1a870514568a074a38232e2ceb4d7df30fabeb76cff0aed5b42bf7f02baea12c5fadf69f4713464dbd52aafa55f +8958ae7b290f0b00d17c3e9fdb4dbf168432b457c7676829299dd428984aba892de1966fc106cfc58a772862ecce3976 +a422bc6bd68b8870cfa5bc4ce71781fd7f4368b564d7f1e0917f6013c8bbb5b240a257f89ecfdbecb40fe0f3aa31d310 +aa61f78130cebe09bc9a2c0a37f0dd57ed2d702962e37d38b1df7f17dc554b1d4b7a39a44182a452ce4c5eb31fa4cfcc +b7918bd114f37869bf1a459023386825821bfadce545201929d13ac3256d92a431e34f690a55d944f77d0b652cefeffc +819bba35fb6ace1510920d4dcff30aa682a3c9af9022e287751a6a6649b00c5402f14b6309f0aeef8fce312a0402915e +8b7c9ad446c6f63c11e1c24e24014bd570862b65d53684e107ba9ad381e81a2eaa96731b4b33536efd55e0f055071274 +8fe79b53f06d33386c0ec7d6d521183c13199498594a46d44a8a716932c3ec480c60be398650bbfa044fa791c4e99b65 +9558e10fb81250b9844c99648cf38fa05ec1e65d0ccbb18aa17f2d1f503144baf59d802c25be8cc0879fff82ed5034ad +b538a7b97fbd702ba84645ca0a63725be1e2891c784b1d599e54e3480e4670d0025526674ef5cf2f87dddf2290ba09f0 +92eafe2e869a3dd8519bbbceb630585c6eb21712b2f31e1b63067c0acb5f9bdbbcbdb612db4ea7f9cc4e7be83d31973f +b40d21390bb813ab7b70a010dff64c57178418c62685761784e37d327ba3cb9ef62df87ecb84277c325a637fe3709732 +b349e6fbf778c4af35fbed33130bd8a7216ed3ba0a79163ebb556e8eb8e1a7dad3456ddd700dad9d08d202491c51b939 +a8fdaedecb251f892b66c669e34137f2650509ade5d38fbe8a05d9b9184bb3b2d416186a3640429bd1f3e4b903c159dd +ac6167ebfee1dbab338eff7642f5e785fc21ef0b4ddd6660333fe398068cbd6c42585f62e81e4edbb72161ce852a1a4f +874b1fbf2ebe140c683bd7e4e0ab017afa5d4ad38055aaa83ee6bbef77dbc88a6ce8eb0dcc48f0155244af6f86f34c2d +903c58e57ddd9c446afab8256a6bb6c911121e6ccfb4f9b4ed3e2ed922a0e500a5cb7fa379d5285bc16e11dac90d1fda +8dae7a0cffa2fd166859cd1bf10ff82dd1932e488af377366b7efc0d5dec85f85fe5e8150ff86a79a39cefc29631733a +aa047857a47cc4dfc08585f28640420fcf105b881fd59a6cf7890a36516af0644d143b73f3515ab48faaa621168f8c31 +864508f7077c266cc0cb3f7f001cb6e27125ebfe79ab57a123a8195f2e27d3799ff98413e8483c533b46a816a3557f1f +8bcd45ab1f9cbab36937a27e724af819838f66dfeb15923f8113654ff877bd8667c54f6307aaf0c35027ca11b6229bfd +b21aa34da9ab0a48fcfdd291df224697ce0c1ebc0e9b022fdee8750a1a4b5ba421c419541ed5c98b461eecf363047471 +a9a18a2ab2fae14542dc336269fe612e9c1af6cf0c9ac933679a2f2cb77d3c304114f4d219ca66fe288adde30716775b +b5205989b92c58bdda71817f9a897e84100b5c4e708de1fced5c286f7a6f01ae96b1c8d845f3a320d77c8e2703c0e8b1 +a364059412bbcc17b8907d43ac8e5df90bc87fd1724b5f99832d0d24559fae6fa76a74cff1d1eac8cbac6ec80b44af20 +ae709f2c339886b31450834cf29a38b26eb3b0779bd77c9ac269a8a925d1d78ea3837876c654b61a8fe834b3b6940808 +8802581bba66e1952ac4dab36af371f66778958f4612901d95e5cac17f59165e6064371d02de8fb6fccf89c6dc8bd118 +a313252df653e29c672cbcfd2d4f775089cb77be1077381cf4dc9533790e88af6cedc8a119158e7da5bf6806ad9b91a1 +992a065b4152c7ef11515cd54ba9d191fda44032a01aed954acff3443377ee16680c7248d530b746b8c6dee2d634e68c +b627b683ee2b32c1ab4ccd27b9f6cce2fe097d96386fa0e5c182ad997c4c422ab8dfc03870cd830b8c774feb66537282 +b823cf8a9aee03dadd013eb9efe40a201b4b57ef67efaae9f99683005f5d1bf55e950bf4af0774f50859d743642d3fea +b8a7449ffac0a3f206677097baf7ce00ca07a4d2bd9b5356fbcb83f3649b0fda07cfebad220c1066afba89e5a52abf4b +b2dd1a2f986395bb4e3e960fbbe823dbb154f823284ebc9068502c19a7609790ec0073d08bfa63f71e30c7161b6ef966 +98e5236de4281245234f5d40a25b503505af140b503a035fc25a26159a9074ec81512b28f324c56ea2c9a5aa7ce90805 +89070847dc8bbf5bc4ed073aa2e2a1f699cf0c2ca226f185a0671cecc54e7d3e14cd475c7752314a7a8e7476829da4bc +a9402dc9117fdb39c4734c0688254f23aed3dce94f5f53f5b7ef2b4bf1b71a67f85ab1a38ec224a59691f3bee050aeb3 +957288f9866a4bf56a4204218ccc583f717d7ce45c01ea27142a7e245ad04a07f289cc044f8cf1f21d35e67e39299e9c +b2fb31ccb4e69113763d7247d0fc8edaae69b550c5c56aecacfd780c7217dc672f9fb7496edf4aba65dacf3361268e5b +b44a4526b2f1d6eb2aa8dba23bfa385ff7634572ab2afddd0546c3beb630fbfe85a32f42dd287a7fec069041411537f7 +8db5a6660c3ac7fd7a093573940f068ee79a82bc17312af900b51c8c439336bc86ca646c6b7ab13aaaa008a24ca508ab +8f9899a6d7e8eb4367beb5c060a1f8e94d8a21099033ae582118477265155ba9e72176a67f7f25d7bad75a152b56e21a +a67de0e91ade8d69a0e00c9ff33ee2909b8a609357095fa12319e6158570c232e5b6f4647522efb7345ce0052aa9d489 +82eb2414898e9c3023d57907a2b17de8e7eea5269029d05a94bfd7bf5685ac4a799110fbb375eb5e0e2bd16acf6458ae +94451fc7fea3c5a89ba701004a9693bab555cb622caf0896b678faba040409fdfd14a978979038b2a81e8f0abc4994d2 +ac879a5bb433998e289809a4a966bd02b4bf6a9c1cc276454e39c886efcf4fc68baebed575826bde577ab5aa71d735a9 +880c0f8f49c875dfd62b4ddedde0f5c8b19f5687e693717f7e5c031bc580e58e13ab497d48b4874130a18743c59fdce3 +b582af8d8ff0bf76f0a3934775e0b54c0e8fed893245d7d89cae65b03c8125b7237edc29dc45b4fe1a3fe6db45d280ee +89f337882ed3ae060aaee98efa20d79b6822bde9708c1c5fcee365d0ec9297f694cae37d38fd8e3d49717c1e86f078e7 +826d2c1faea54061848b484e288a5f4de0d221258178cf87f72e14baaa4acc21322f8c9eab5dde612ef497f2d2e1d60b +a5333d4f227543e9cd741ccf3b81db79f2f03ca9e649e40d6a6e8ff9073e06da83683566d3b3c8d7b258c62970fb24d1 +a28f08c473db06aaf4c043a2fae82b3c8cfaa160bce793a4c208e4e168fb1c65115ff8139dea06453c5963d95e922b94 +8162546135cc5e124e9683bdfaa45833c18553ff06a0861c887dc84a5b12ae8cd4697f6794c7ef6230492c32faba7014 +b23f0d05b74c08d6a7df1760792be83a761b36e3f8ae360f3c363fb196e2a9dd2de2e492e49d36561366e14daa77155c +b6f70d6c546722d3907c708d630dbe289771d2c8bf059c2e32b77f224696d750b4dda9b3a014debda38e7d02c9a77585 +83bf4c4a9f3ca022c631017e7a30ea205ba97f7f5927cba8fc8489a4646eac6712cb821c5668c9ffe94d69d524374a27 +b0371475425a8076d0dd5f733f55aabbe42d20a7c8ea7da352e736d4d35a327b2beb370dfcb05284e22cfd69c5f6c4cc +a0031ba7522c79211416c2cca3aa5450f96f8fee711552a30889910970ba13608646538781a2c08b834b140aadd7166f +99d273c80c7f2dc6045d4ed355d9fc6f74e93549d961f4a3b73cd38683f905934d359058cd1fc4da8083c7d75070487f +b0e4b0efa3237793e9dcce86d75aafe9879c5fa23f0d628649aef2130454dcf72578f9bf227b9d2b9e05617468e82588 +a5ab076fa2e1c5c51f3ae101afdd596ad9d106bba7882b359c43d8548b64f528af19afa76cd6f40da1e6c5fca4def3fa +8ce2299e570331d60f6a6eff1b271097cd5f1c0e1113fc69b89c6a0f685dabea3e5bc2ac6bd789aa492ab189f89be494 +91b829068874d911a310a5f9dee001021f97471307b5a3de9ec336870ec597413e1d92010ce320b619f38bed7c4f7910 +b14fe91f4b07bf33b046e9285b66cb07927f3a8da0af548ac2569b4c4fb1309d3ced76d733051a20814e90dd5b75ffd1 +abaab92ea6152d40f82940277c725aa768a631ee0b37f5961667f82fb990fc11e6d3a6a2752b0c6f94563ed9bb28265c +b7fe28543eca2a716859a76ab9092f135337e28109544f6bd2727728d0a7650428af5713171ea60bfc273d1c821d992c +8a4917b2ab749fc7343fc64bdf51b6c0698ff15d740cc7baf248c030475c097097d5a473bcc00d8c25817563fe0447b4 +aa96156d1379553256350a0a3250166add75948fb9cde62aa555a0a9dc0a9cb7f2f7b8428aff66097bf6bfedaf14bbe2 +ae4ffeb9bdc76830d3eca2b705f30c1bdede6412fa064260a21562c8850c7fb611ec62bc68479fe48f692833e6f66d8d +b96543caaba9d051600a14997765d49e4ab10b07c7a92cccf0c90b309e6da334fdd6d18c96806cbb67a7801024fbd3c7 +97b2b9ad76f19f500fcc94ca8e434176249f542ac66e5881a3dccd07354bdab6a2157018b19f8459437a68d8b86ba8e0 +a8d206f6c5a14c80005849474fde44b1e7bcf0b2d52068f5f97504c3c035b09e65e56d1cf4b5322791ae2c2fdbd61859 +936bad397ad577a70cf99bf9056584a61bd7f02d2d5a6cf219c05d770ae30a5cd902ba38366ce636067fc1dd10108d31 +a77e30195ee402b84f3882e2286bf5380c0ed374a112dbd11e16cef6b6b61ab209d4635e6f35cdaaa72c1a1981d5dabe +a46ba4d3947188590a43c180757886a453a0503f79cc435322d92490446f37419c7b999fdf868a023601078070e03346 +80d8d4c5542f223d48240b445d4d8cf6a75d120b060bc08c45e99a13028b809d910b534d2ac47fb7068930c54efd8da9 +803be9c68c91b42b68e1f55e58917a477a9a6265e679ca44ee30d3eb92453f8c89c64eafc04c970d6831edd33d066902 +b14b2b3d0dfe2bb57cee4cd72765b60ac33c1056580950be005790176543826c1d4fbd737f6cfeada6c735543244ab57 +a9e480188bba1b8fb7105ff12215706665fd35bf1117bacfb6ab6985f4dbc181229873b82e5e18323c2b8f5de03258e0 +a66a0f0779436a9a3999996d1e6d3000f22c2cac8e0b29cddef9636393c7f1457fb188a293b6c875b05d68d138a7cc4a +848397366300ab40c52d0dbbdafbafef6cd3dadf1503bb14b430f52bb9724188928ac26f6292a2412bc7d7aa620763c8 +95466cc1a78c9f33a9aaa3829a4c8a690af074916b56f43ae46a67a12bb537a5ac6dbe61590344a25b44e8512355a4a7 +8b5f7a959f818e3baf0887f140f4575cac093d0aece27e23b823cf421f34d6e4ff4bb8384426e33e8ec7b5eed51f6b5c +8d5e1368ec7e3c65640d216bcc5d076f3d9845924c734a34f3558ac0f16e40597c1a775a25bf38b187213fbdba17c93b +b4647c1b823516880f60d20c5cc38c7f80b363c19d191e8992226799718ee26b522a12ecb66556ed3d483aa4824f3326 +ac3abaea9cd283eb347efda4ed9086ea3acf495043e08d0d19945876329e8675224b685612a6badf8fd72fb6274902b1 +8eae1ce292d317aaa71bcf6e77e654914edd5090e2e1ebab78b18bb41b9b1bc2e697439f54a44c0c8aa0d436ebe6e1a9 +94dc7d1aec2c28eb43d93b111fa59aaa0d77d5a09501220bd411768c3e52208806abf973c6a452fd8292ff6490e0c9e2 +8fd8967f8e506fef27d17b435d6b86b232ec71c1036351f12e6fb8a2e12daf01d0ee04451fb944d0f1bf7fd20e714d02 +824e6865be55d43032f0fec65b3480ea89b0a2bf860872237a19a54bc186a85d2f8f9989cc837fbb325b7c72d9babe2c +8bd361f5adb27fd6f4e3f5de866e2befda6a8454efeb704aacc606f528c03f0faae888f60310e49440496abd84083ce2 +b098a3c49f2aaa28b6b3e85bc40ce6a9cdd02134ee522ae73771e667ad7629c8d82c393fba9f27f5416986af4c261438 +b385f5ca285ff2cfe64dcaa32dcde869c28996ed091542600a0b46f65f3f5a38428cca46029ede72b6cf43e12279e3d3 +8196b03d011e5be5288196ef7d47137d6f9237a635ab913acdf9c595fa521d9e2df722090ec7eb0203544ee88178fc5f +8ed1270211ef928db18e502271b7edf24d0bbd11d97f2786aee772d70c2029e28095cf8f650b0328cc8a4c38d045316d +a52ab60e28d69b333d597a445884d44fd2a7e1923dd60f763951e1e45f83e27a4dac745f3b9eff75977b3280e132c15d +91e9fe78cdac578f4a4687f71b800b35da54b824b1886dafec073a3c977ce7a25038a2f3a5b1e35c2c8c9d1a7312417c +a42832173f9d9491c7bd93b21497fbfa4121687cd4d2ab572e80753d7edcbb42cfa49f460026fbde52f420786751a138 +97b947126d84dcc70c97be3c04b3de3f239b1c4914342fa643b1a4bb8c4fe45c0fcb585700d13a7ed50784790c54bef9 +860e407d353eac070e2418ef6cb80b96fc5f6661d6333e634f6f306779651588037be4c2419562c89c61f9aa2c4947f5 +b2c9d93c3ba4e511b0560b55d3501bf28a510745fd666b3cb532db051e6a8617841ea2f071dda6c9f15619c7bfd2737f +8596f4d239aeeac78311207904d1bd863ef68e769629cc379db60e019aaf05a9d5cd31dc8e630b31e106a3a93e47cbc5 +8b26e14e2e136b65c5e9e5c2022cee8c255834ea427552f780a6ca130a6446102f2a6f334c3f9a0308c53df09e3dba7e +b54724354eb515a3c8bed0d0677ff1db94ac0a07043459b4358cb90e3e1aa38ac23f2caa3072cf9647275d7cd61d0e80 +b7ce9fe0e515e7a6b2d7ddcb92bc0196416ff04199326aea57996eef8c5b1548bd8569012210da317f7c0074691d01b7 +a1a13549c82c877253ddefa36a29ea6a23695ee401fdd48e65f6f61e5ebd956d5e0edeff99484e9075cb35071fec41e2 +838ba0c1e5bd1a6da05611ff1822b8622457ebd019cb065ece36a2d176bd2d889511328120b8a357e44569e7f640c1e6 +b916eccff2a95519400bbf76b5f576cbe53cf200410370a19d77734dc04c05b585cfe382e8864e67142d548cd3c4c2f4 +a610447cb7ca6eea53a6ff1f5fe562377dcb7f4aaa7300f755a4f5e8eba61e863c51dc2aa9a29b35525b550fbc32a0fe +9620e8f0f0ee9a4719aa9685eeb1049c5c77659ba6149ec4c158f999cfd09514794b23388879931fe26fea03fa471fd3 +a9dcf8b679e276583cf5b9360702a185470d09aea463dc474ee9c8aee91ef089dacb073e334e47fbc78ec5417c90465c +8c9adee8410bdd99e5b285744cee61e2593b6300ff31a8a83b0ec28da59475a5c6fb9346fe43aadea2e6c3dad2a8e30a +97d5afe9b3897d7b8bb628b7220cf02d8ee4e9d0b78f5000d500aaf4c1df9251aaaabfd1601626519f9d66f00a821d4e +8a382418157b601ce4c3501d3b8409ca98136a4ef6abcbf62885e16e215b76b035c94d149cc41ff92e42ccd7c43b9b3d +b64b8d11fb3b01abb2646ac99fdb9c02b804ce15d98f9fe0fbf1c9df8440c71417487feb6cdf51e3e81d37104b19e012 +849d7d044f9d8f0aab346a9374f0b3a5d14a9d1faa83dbacccbdc629ad1ef903a990940255564770537f8567521d17f0 +829dbb0c76b996c2a91b4cbbe93ba455ca0d5729755e5f0c92aaee37dff7f36fcdc06f33aca41f1b609c784127b67d88 +85a7c0069047b978422d264d831ab816435f63938015d2e977222b6b5746066c0071b7f89267027f8a975206ed25c1b0 +84b9fbc1cfb302df1acdcf3dc5d66fd1edfe7839f7a3b2fb3a0d5548656249dd556104d7c32b73967bccf0f5bdcf9e3b +972220ac5b807f53eac37dccfc2ad355d8b21ea6a9c9b011c09fe440ddcdf7513e0b43d7692c09ded80d7040e26aa28f +855885ed0b21350baeca890811f344c553cf9c21024649c722453138ba29193c6b02c4b4994cd414035486f923472e28 +841874783ae6d9d0e59daea03e96a01cbbe4ecaced91ae4f2c8386e0d87b3128e6d893c98d17c59e4de1098e1ad519dd +827e50fc9ce56f97a4c3f2f4cbaf0b22f1c3ce6f844ff0ef93a9c57a09b8bf91ebfbd2ba9c7f83c442920bffdaf288cc +a441f9136c7aa4c08d5b3534921b730e41ee91ab506313e1ba5f7c6f19fd2d2e1594e88c219834e92e6fb95356385aa7 +97d75b144471bf580099dd6842b823ec0e6c1fb86dd0da0db195e65524129ea8b6fd4a7a9bbf37146269e938a6956596 +a4b6fa87f09d5a29252efb2b3aaab6b3b6ea9fab343132a651630206254a25378e3e9d6c96c3d14c150d01817d375a8e +a31a671876d5d1e95fe2b8858dc69967231190880529d57d3cab7f9f4a2b9b458ac9ee5bdaa3289158141bf18f559efb +90bee6fff4338ba825974021b3b2a84e36d617e53857321f13d2b3d4a28954e6de3b3c0e629d61823d18a9763313b3bf +96b622a63153f393bb419bfcf88272ea8b3560dbd46b0aa07ada3a6223990d0abdd6c2adb356ef4be5641688c8d83941 +84c202adeaff9293698022bc0381adba2cd959f9a35a4e8472288fd68f96f6de8be9da314c526d88e291c96b1f3d6db9 +8ca01a143b8d13809e5a8024d03e6bc9492e22226073ef6e327edf1328ef4aff82d0bcccee92cb8e212831fa35fe1204 +b2f970dbad15bfbefb38903c9bcc043d1367055c55dc1100a850f5eb816a4252c8c194b3132c929105511e14ea10a67d +a5e36556472a95ad57eb90c3b6623671b03eafd842238f01a081997ffc6e2401f76e781d049bb4aa94d899313577a9cf +8d1057071051772f7c8bedce53a862af6fd530dd56ae6321eaf2b9fc6a68beff5ed745e1c429ad09d5a118650bfd420a +8aadc4f70ace4fcb8d93a78610779748dcffc36182d45b932c226dc90e48238ea5daa91f137c65ed532352c4c4d57416 +a2ea05ae37e673b4343232ae685ee14e6b88b867aef6dfac35db3589cbcd76f99540fed5c2641d5bb5a4a9f808e9bf0d +947f1abad982d65648ae4978e094332b4ecb90f482c9be5741d5d1cf5a28acf4680f1977bf6e49dd2174c37f11e01296 +a27b144f1565e4047ba0e3f4840ef19b5095d1e281eaa463c5358f932114cbd018aa6dcf97546465cf2946d014d8e6d6 +8574e1fc3acade47cd4539df578ce9205e745e161b91e59e4d088711a7ab5aa3b410d517d7304b92109924d9e2af8895 +a48ee6b86b88015d6f0d282c1ae01d2a5b9e8c7aa3d0c18b35943dceb1af580d08a65f54dc6903cde82fd0d73ce94722 +8875650cec543a7bf02ea4f2848a61d167a66c91ffaefe31a9e38dc8511c6a25bde431007eefe27a62af3655aca208dc +999b0a6e040372e61937bf0d68374e230346b654b5a0f591a59d33a4f95bdb2f3581db7c7ccb420cd7699ed709c50713 +878c9e56c7100c5e47bbe77dc8da5c5fe706cec94d37fa729633bca63cace7c40102eee780fcdabb655f5fa47a99600e +865006fb5b475ada5e935f27b96f9425fc2d5449a3c106aa366e55ebed3b4ee42adc3c3f0ac19fd129b40bc7d6bc4f63 +b7a7da847f1202e7bc1672553e68904715e84fd897d529243e3ecda59faa4e17ba99c649a802d53f6b8dfdd51f01fb74 +8b2fb4432c05653303d8c8436473682933a5cb604da10c118ecfcd2c8a0e3132e125afef562bdbcc3df936164e5ce4f2 +808d95762d33ddfa5d0ee3d7d9f327de21a994d681a5f372e2e3632963ea974da7f1f9e5bac8ccce24293509d1f54d27 +932946532e3c397990a1df0e94c90e1e45133e347a39b6714c695be21aeb2d309504cb6b1dde7228ff6f6353f73e1ca2 +9705e7c93f0cdfaa3fa96821f830fe53402ad0806036cd1b48adc2f022d8e781c1fbdab60215ce85c653203d98426da3 +aa180819531c3ec1feb829d789cb2092964c069974ae4faad60e04a6afcce5c3a59aec9f11291e6d110a788d22532bc6 +88f755097f7e25cb7dd3c449520c89b83ae9e119778efabb54fbd5c5714b6f37c5f9e0346c58c6ab09c1aef2483f895d +99fc03ab7810e94104c494f7e40b900f475fde65bdec853e60807ffd3f531d74de43335c3b2646b5b8c26804a7448898 +af2dea9683086bed1a179110efb227c9c00e76cd00a2015b089ccbcee46d1134aa18bda5d6cab6f82ae4c5cd2461ac21 +a500f87ba9744787fdbb8e750702a3fd229de6b8817594348dec9a723b3c4240ddfa066262d002844b9e38240ce55658 +924d0e45c780f5bc1c1f35d15dfc3da28036bdb59e4c5440606750ecc991b85be18bc9a240b6c983bc5430baa4c68287 +865b11e0157b8bf4c5f336024b016a0162fc093069d44ac494723f56648bc4ded13dfb3896e924959ea11c96321afefc +93672d8607d4143a8f7894f1dcca83fb84906dc8d6dd7dd063bb0049cfc20c1efd933e06ca7bd03ea4cb5a5037990bfe +826891efbdff0360446825a61cd1fa04326dd90dae8c33dfb1ed97b045e165766dd070bd7105560994d0b2044bdea418 +93c4a4a8bcbc8b190485cc3bc04175b7c0ed002c28c98a540919effd6ed908e540e6594f6db95cd65823017258fb3b1c +aeb2a0af2d2239fda9aa6b8234b019708e8f792834ff0dd9c487fa09d29800ddceddd6d7929faa9a3edcb9e1b3aa0d6b +87f11de7236d387863ec660d2b04db9ac08143a9a2c4dfff87727c95b4b1477e3bc473a91e5797313c58754905079643 +80dc1db20067a844fe8baceca77f80db171a5ca967acb24e2d480eae9ceb91a3343c31ad1c95b721f390829084f0eae6 +9825c31f1c18da0de3fa84399c8b40f8002c3cae211fb6a0623c76b097b4d39f5c50058f57a16362f7a575909d0a44a2 +a99fc8de0c38dbf7b9e946de83943a6b46a762167bafe2a603fb9b86f094da30d6de7ed55d639aafc91936923ee414b3 +ad594678b407db5d6ea2e90528121f84f2b96a4113a252a30d359a721429857c204c1c1c4ff71d8bb5768c833f82e80e +b33d985e847b54510b9b007e31053732c8a495e43be158bd2ffcea25c6765bcbc7ca815f7c60b36ad088b955dd6e9350 +815f8dfc6f90b3342ca3fbd968c67f324dae8f74245cbf8bc3bef10e9440c65d3a2151f951e8d18959ba01c1b50b0ec1 +94c608a362dd732a1abc56e338637c900d59013db8668e49398b3c7a0cae3f7e2f1d1bf94c0299eeafe6af7f76c88618 +8ebd8446b23e5adfcc393adc5c52fe172f030a73e63cd2d515245ca0dd02782ceed5bcdd9ccd9c1b4c5953dfac9c340c +820437f3f6f9ad0f5d7502815b221b83755eb8dc56cd92c29e9535eb0b48fb8d08c9e4fcc26945f9c8cca60d89c44710 +8910e4e8a56bf4be9cc3bbf0bf6b1182a2f48837a2ed3c2aaec7099bfd7f0c83e14e608876b17893a98021ff4ab2f20d +9633918fde348573eec15ce0ad53ac7e1823aac86429710a376ad661002ae6d049ded879383faaa139435122f64047c6 +a1f5e3fa558a9e89318ca87978492f0fb4f6e54a9735c1b8d2ecfb1d1c57194ded6e0dd82d077b2d54251f3bee1279e1 +b208e22d04896abfd515a95c429ff318e87ff81a5d534c8ac2c33c052d6ffb73ef1dccd39c0bbe0734b596c384014766 +986d5d7d2b5bde6d16336f378bd13d0e671ad23a8ec8a10b3fc09036faeeb069f60662138d7a6df3dfb8e0d36180f770 +a2d4e6c5f5569e9cef1cddb569515d4b6ace38c8aed594f06da7434ba6b24477392cc67ba867c2b079545ca0c625c457 +b5ac32b1d231957d91c8b7fc43115ce3c5c0d8c13ca633374402fa8000b6d9fb19499f9181844f0c10b47357f3f757ce +96b8bf2504b4d28fa34a4ec378e0e0b684890c5f44b7a6bb6e19d7b3db2ab27b1e2686389d1de9fbd981962833a313ea +953bfd7f6c3a0469ad432072b9679a25486f5f4828092401eff494cfb46656c958641a4e6d0d97d400bc59d92dba0030 +876ab3cea7484bbfd0db621ec085b9ac885d94ab55c4bb671168d82b92e609754b86aaf472c55df3d81421d768fd108a +885ff4e67d9ece646d02dd425aa5a087e485c3f280c3471b77532b0db6145b69b0fbefb18aa2e3fa5b64928b43a94e57 +b91931d93f806d0b0e6cc62a53c718c099526140f50f45d94b8bbb57d71e78647e06ee7b42aa5714aed9a5c05ac8533f +a0313eeadd39c720c9c27b3d671215331ab8d0a794e71e7e690f06bcd87722b531d6525060c358f35f5705dbb7109ccb +874c0944b7fedc6701e53344100612ddcb495351e29305c00ec40a7276ea5455465ffb7bded898886c1853139dfb1fc7 +8dc31701a01ee8137059ca1874a015130d3024823c0576aa9243e6942ec99d377e7715ed1444cd9b750a64b85dcaa3e5 +836d2a757405e922ec9a2dfdcf489a58bd48b5f9683dd46bf6047688f778c8dee9bc456de806f70464df0b25f3f3d238 +b30b0a1e454a503ea3e2efdec7483eaf20b0a5c3cefc42069e891952b35d4b2c955cf615f3066285ed8fafd9fcfbb8f6 +8e6d4044b55ab747e83ec8762ea86845f1785cc7be0279c075dadf08aca3ccc5a096c015bb3c3f738f647a4eadea3ba5 +ad7735d16ab03cbe09c029610aa625133a6daecfc990b297205b6da98eda8c136a7c50db90f426d35069708510d5ae9c +8d62d858bbb59ec3c8cc9acda002e08addab4d3ad143b3812098f3d9087a1b4a1bb255dcb1635da2402487d8d0249161 +805beec33238b832e8530645a3254aeef957e8f7ea24bcfc1054f8b9c69421145ebb8f9d893237e8a001c857fedfc77e +b1005644be4b085e3f5775aa9bd3e09a283e87ddada3082c04e7a62d303dcef3b8cf8f92944c200c7ae6bb6bdf63f832 +b4ba0e0790dc29063e577474ffe3b61f5ea2508169f5adc1e394934ebb473e356239413a17962bc3e5d3762d72cce8c2 +a157ba9169c9e3e6748d9f1dd67fbe08b9114ade4c5d8fc475f87a764fb7e6f1d21f66d7905cd730f28a1c2d8378682a +913e52b5c93989b5d15e0d91aa0f19f78d592bc28bcfdfddc885a9980c732b1f4debb8166a7c4083c42aeda93a702898 +90fbfc1567e7cd4e096a38433704d3f96a2de2f6ed3371515ccc30bc4dd0721a704487d25a97f3c3d7e4344472702d8d +89646043028ffee4b69d346907586fd12c2c0730f024acb1481abea478e61031966e72072ff1d5e65cb8c64a69ad4eb1 +b125a45e86117ee11d2fb42f680ab4a7894edd67ff927ae2c808920c66c3e55f6a9d4588eee906f33a05d592e5ec3c04 +aad47f5b41eae9be55fb4f67674ff1e4ae2482897676f964a4d2dcb6982252ee4ff56aac49578b23f72d1fced707525e +b9ddff8986145e33851b4de54d3e81faa3352e8385895f357734085a1616ef61c692d925fe62a5ed3be8ca49f5d66306 +b3cb0963387ed28c0c0adf7fe645f02606e6e1780a24d6cecef5b7c642499109974c81a7c2a198b19862eedcea2c2d8c +ac9c53c885457aaf5cb36c717a6f4077af701e0098eebd7aa600f5e4b14e6c1067255b3a0bc40e4a552025231be7de60 +8e1a8d823c4603f6648ec21d064101094f2a762a4ed37dd2f0a2d9aa97b2d850ce1e76f4a4b8cae58819b058180f7031 +b268b73bf7a179b6d22bd37e5e8cb514e9f5f8968c78e14e4f6d5700ca0d0ca5081d0344bb73b028970eebde3cb4124e +a7f57d71940f0edbd29ed8473d0149cae71d921dd15d1ff589774003e816b54b24de2620871108cec1ab9fa956ad6ce6 +8053e6416c8b120e2b999cc2fc420a6a55094c61ac7f2a6c6f0a2c108a320890e389af96cbe378936132363c0d551277 +b3823f4511125e5aa0f4269e991b435a0d6ceb523ebd91c04d7add5534e3df5fc951c504b4fd412a309fd3726b7f940b +ae6eb04674d04e982ca9a6add30370ab90e303c71486f43ed3efbe431af1b0e43e9d06c11c3412651f304c473e7dbf39 +96ab55e641ed2e677591f7379a3cd126449614181fce403e93e89b1645d82c4af524381ff986cae7f9cebe676878646d +b52423b4a8c37d3c3e2eca8f0ddbf7abe0938855f33a0af50f117fab26415fb0a3da5405908ec5fdc22a2c1f2ca64892 +82a69ce1ee92a09cc709d0e3cd22116c9f69d28ea507fe5901f5676000b5179b9abe4c1875d052b0dd42d39925e186bb +a84c8cb84b9d5cfb69a5414f0a5283a5f2e90739e9362a1e8c784b96381b59ac6c18723a4aa45988ee8ef5c1f45cc97d +afd7efce6b36813082eb98257aae22a4c1ae97d51cac7ea9c852d4a66d05ef2732116137d8432e3f117119725a817d24 +a0f5fe25af3ce021b706fcff05f3d825384a272284d04735574ce5fb256bf27100fad0b1f1ba0e54ae9dcbb9570ecad3 +8751786cb80e2e1ff819fc7fa31c2833d25086534eb12b373d31f826382430acfd87023d2a688c65b5e983927e146336 +8cf5c4b17fa4f3d35c78ce41e1dc86988fd1135cd5e6b2bb0c108ee13538d0d09ae7102609c6070f39f937b439b31e33 +a9108967a2fedd7c322711eca8159c533dd561bedcb181b646de98bf5c3079449478eab579731bee8d215ae8852c7e21 +b54c5171704f42a6f0f4e70767cdb3d96ffc4888c842eece343a01557da405961d53ffdc34d2f902ea25d3e1ed867cad +ae8d4b764a7a25330ba205bf77e9f46182cd60f94a336bbd96773cf8064e3d39caf04c310680943dc89ed1fbad2c6e0d +aa5150e911a8e1346868e1b71c5a01e2a4bb8632c195861fb6c3038a0e9b85f0e09b3822e9283654a4d7bb17db2fc5f4 +9685d3756ce9069bf8bb716cf7d5063ebfafe37e15b137fc8c3159633c4e006ff4887ddd0ae90360767a25c3f90cba7f +82155fd70f107ab3c8e414eadf226c797e07b65911508c76c554445422325e71af8c9a8e77fd52d94412a6fc29417cd3 +abfae52f53a4b6e00760468d973a267f29321997c3dbb5aee36dc1f20619551229c0c45b9d9749f410e7f531b73378e8 +81a76d921f8ef88e774fd985e786a4a330d779b93fad7def718c014685ca0247379e2e2a007ad63ee7f729cd9ed6ce1b +81947c84bc5e28e26e2e533af5ae8fe10407a7b77436dbf8f1d5b0bbe86fc659eae10f974659dc7c826c6dabd03e3a4b +92b8c07050d635b8dd4fd09df9054efe4edae6b86a63c292e73cc819a12a21dd7d104ce51fa56af6539dedf6dbe6f7b6 +b44c579e3881f32b32d20c82c207307eca08e44995dd2aac3b2692d2c8eb2a325626c80ac81c26eeb38c4137ff95add5 +97efab8941c90c30860926dea69a841f2dcd02980bf5413b9fd78d85904588bf0c1021798dbc16c8bbb32cce66c82621 +913363012528b50698e904de0588bf55c8ec5cf6f0367cfd42095c4468fcc64954fbf784508073e542fee242d0743867 +8ed203cf215148296454012bd10fddaf119203db1919a7b3d2cdc9f80e66729464fdfae42f1f2fc5af1ed53a42b40024 +ab84312db7b87d711e9a60824f4fe50e7a6190bf92e1628688dfcb38930fe87b2d53f9e14dd4de509b2216856d8d9188 +880726def069c160278b12d2258eac8fa63f729cd351a710d28b7e601c6712903c3ac1e7bbd0d21e4a15f13ca49db5aa +980699cd51bac6283959765f5174e543ed1e5f5584b5127980cbc2ef18d984ecabba45042c6773b447b8e694db066028 +aeb019cb80dc4cb4207430d0f2cd24c9888998b6f21d9bf286cc638449668d2eec0018a4cf3fe6448673cd6729335e2b +b29852f6aa6c60effdffe96ae88590c88abae732561d35cc19e82d3a51e26cb35ea00986193e07f90060756240f5346e +a0fa855adc5ba469f35800c48414b8921455950a5c0a49945d1ef6e8f2a1881f2e2dfae47de6417270a6bf49deeb091d +b6c7332e3b14813641e7272d4f69ecc7e09081df0037d6dab97ce13a9e58510f5c930d300633f208181d9205c5534001 +85a6c050f42fce560b5a8d54a11c3bbb8407abbadd859647a7b0c21c4b579ec65671098b74f10a16245dc779dff7838e +8f3eb34bb68759d53c6677de4de78a6c24dd32c8962a7fb355ed362572ef8253733e6b52bc21c9f92ecd875020a9b8de +a17dd44181e5dab4dbc128e1af93ec22624b57a448ca65d2d9e246797e4af7d079e09c6e0dfb62db3a9957ce92f098d5 +a56a1b854c3183082543a8685bb34cae1289f86cfa8123a579049dbd059e77982886bfeb61bf6e05b4b1fe4e620932e7 +aedae3033cb2fb7628cb4803435bdd7757370a86f808ae4cecb9a268ad0e875f308c048c80cbcac523de16b609683887 +9344905376aa3982b1179497fac5a1d74b14b7038fd15e3b002db4c11c8bfc7c39430db492cdaf58b9c47996c9901f28 +a3bfafdae011a19f030c749c3b071f83580dee97dd6f949e790366f95618ca9f828f1daaeabad6dcd664fcef81b6556d +81c03d8429129e7e04434dee2c529194ddb01b414feda3adee2271eb680f6c85ec872a55c9fa9d2096f517e13ed5abcc +98205ef3a72dff54c5a9c82d293c3e45d908946fa74bb749c3aabe1ab994ea93c269bcce1a266d2fe67a8f02133c5985 +85a70aeed09fda24412fadbafbbbf5ba1e00ac92885df329e147bfafa97b57629a3582115b780d8549d07d19b7867715 +b0fbe81c719f89a57d9ea3397705f898175808c5f75f8eb81c2193a0b555869ba7bd2e6bc54ee8a60cea11735e21c68c +b03a0bd160495ee626ff3a5c7d95bc79d7da7e5a96f6d10116600c8fa20bedd1132f5170f25a22371a34a2d763f2d6d0 +a90ab04091fbca9f433b885e6c1d60ab45f6f1daf4b35ec22b09909d493a6aab65ce41a6f30c98239cbca27022f61a8b +b66f92aa3bf2549f9b60b86f99a0bd19cbdd97036d4ae71ca4b83d669607f275260a497208f6476cde1931d9712c2402 +b08e1fdf20e6a9b0b4942f14fa339551c3175c1ffc5d0ab5b226b6e6a322e9eb0ba96adc5c8d59ca4259e2bdd04a7eb0 +a2812231e92c1ce74d4f5ac3ab6698520288db6a38398bb38a914ac9326519580af17ae3e27cde26607e698294022c81 +abfcbbcf1d3b9e84c02499003e490a1d5d9a2841a9e50c7babbef0b2dd20d7483371d4dc629ba07faf46db659459d296 +b0fe9f98c3da70927c23f2975a9dc4789194d81932d2ad0f3b00843dd9cbd7fb60747a1da8fe5a79f136a601becf279d +b130a6dba7645165348cb90f023713bed0eefbd90a976b313521c60a36d34f02032e69a2bdcf5361e343ed46911297ec +862f0cffe3020cea7a5fd4703353aa1eb1be335e3b712b29d079ff9f7090d1d8b12013011e1bdcbaa80c44641fd37c9f +8c6f11123b26633e1abb9ed857e0bce845b2b3df91cc7b013b2fc77b477eee445da0285fc6fc793e29d5912977f40916 +91381846126ea819d40f84d3005e9fb233dc80071d1f9bb07f102bf015f813f61e5884ffffb4f5cd333c1b1e38a05a58 +8add7d908de6e1775adbd39c29a391f06692b936518db1f8fde74eb4f533fc510673a59afb86e3a9b52ade96e3004c57 +8780e086a244a092206edcde625cafb87c9ab1f89cc3e0d378bc9ee776313836160960a82ec397bc3800c0a0ec3da283 +a6cb4cd9481e22870fdd757fae0785edf4635e7aacb18072fe8dc5876d0bab53fb99ce40964a7d3e8bcfff6f0ab1332f +af30ff47ecc5b543efba1ba4706921066ca8bb625f40e530fb668aea0551c7647a9d126e8aba282fbcce168c3e7e0130 +91b0bcf408ce3c11555dcb80c4410b5bc2386d3c05caec0b653352377efdcb6bab4827f2018671fc8e4a0e90d772acc1 +a9430b975ef138b6b2944c7baded8fe102d31da4cfe3bd3d8778bda79189c99d38176a19c848a19e2d1ee0bddd9a13c1 +aa5a4eef849d7c9d2f4b018bd01271c1dd83f771de860c4261f385d3bdcc130218495860a1de298f14b703ec32fa235f +b0ce79e7f9ae57abe4ff366146c3b9bfb38b0dee09c28c28f5981a5d234c6810ad4d582751948affb480d6ae1c8c31c4 +b75122748560f73d15c01a8907d36d06dc068e82ce22b84b322ac1f727034493572f7907dec34ebc3ddcc976f2f89ed7 +b0fc7836369a3e4411d34792d6bd5617c14f61d9bba023dda64e89dc5fb0f423244e9b48ee64869258931daa9753a56f +8956d7455ae9009d70c6e4a0bcd7610e55f37494cf9897a8f9e1b904cc8febc3fd2d642ebd09025cfff4609ad7e3bc52 +ad741efe9e472026aa49ae3d9914cb9c1a6f37a54f1a6fe6419bebd8c7d68dca105a751c7859f4389505ede40a0de786 +b52f418797d719f0d0d0ffb0846788b5cba5d0454a69a2925de4b0b80fa4dd7e8c445e5eac40afd92897ed28ca650566 +a0ab65fb9d42dd966cd93b1de01d7c822694669dd2b7a0c04d99cd0f3c3de795f387b9c92da11353412f33af5c950e9a +a0052f44a31e5741a331f7cac515a08b3325666d388880162d9a7b97598fde8b61f9ff35ff220df224eb5c4e40ef0567 +a0101cfdc94e42b2b976c0d89612a720e55d145a5ef6ef6f1f78cf6de084a49973d9b5d45915349c34ce712512191e3c +a0dd99fcf3f5cead5aaf08e82212df3a8bb543c407a4d6fab88dc5130c1769df3f147e934a46f291d6c1a55d92b86917 +a5939153f0d1931bbda5cf6bdf20562519ea55fbfa978d6dbc6828d298260c0da7a50c37c34f386e59431301a96c2232 +9568269f3f5257200f9ca44afe1174a5d3cf92950a7f553e50e279c239e156a9faaa2a67f288e3d5100b4142efe64856 +b746b0832866c23288e07f24991bbf687cad794e7b794d3d3b79367566ca617d38af586cdc8d6f4a85a34835be41d54f +a871ce28e39ab467706e32fec1669fda5a4abba2f8c209c6745df9f7a0fa36bbf1919cf14cb89ea26fa214c4c907ae03 +a08dacdd758e523cb8484f6bd070642c0c20e184abdf8e2a601f61507e93952d5b8b0c723c34fcbdd70a8485eec29db2 +85bdb78d501382bb95f1166b8d032941005661aefd17a5ac32df9a3a18e9df2fc5dc2c1f07075f9641af10353cecc0c9 +98d730c28f6fa692a389e97e368b58f4d95382fad8f0baa58e71a3d7baaea1988ead47b13742ce587456f083636fa98e +a557198c6f3d5382be9fb363feb02e2e243b0c3c61337b3f1801c4a0943f18e38ce1a1c36b5c289c8fa2aa9d58742bab +89174f79201742220ac689c403fc7b243eed4f8e3f2f8aba0bf183e6f5d4907cb55ade3e238e3623d9885f03155c4d2b +b891d600132a86709e06f3381158db300975f73ea4c1f7c100358e14e98c5fbe792a9af666b85c4e402707c3f2db321e +b9e5b2529ef1043278c939373fc0dbafe446def52ddd0a8edecd3e4b736de87e63e187df853c54c28d865de18a358bb6 +8589b2e9770340c64679062c5badb7bbef68f55476289b19511a158a9a721f197da03ece3309e059fc4468b15ac33aa3 +aad8c6cd01d785a881b446f06f1e9cd71bca74ba98674c2dcddc8af01c40aa7a6d469037498b5602e76e9c91a58d3dbd +abaccb1bd918a8465f1bf8dbe2c9ad4775c620b055550b949a399f30cf0d9eb909f3851f5b55e38f9e461e762f88f499 +ae62339d26db46e85f157c0151bd29916d5cc619bd4b832814b3fd2f00af8f38e7f0f09932ffe5bba692005dab2d9a74 +93a6ff30a5c0edf8058c89aba8c3259e0f1b1be1b80e67682de651e5346f7e1b4b4ac3d87cbaebf198cf779524aff6bf +8980a2b1d8f574af45b459193c952400b10a86122b71fca2acb75ee0dbd492e7e1ef5b959baf609a5172115e371f3177 +8c2f49f3666faee6940c75e8c7f6f8edc3f704cca7a858bbb7ee5e96bba3b0cf0993996f781ba6be3b0821ef4cb75039 +b14b9e348215b278696018330f63c38db100b0542cfc5be11dc33046e3bca6a13034c4ae40d9cef9ea8b34fef0910c4e +b59bc3d0a30d66c16e6a411cb641f348cb1135186d5f69fda8b0a0934a5a2e7f6199095ba319ec87d3fe8f1ec4a06368 +8874aca2a3767aa198e4c3fec2d9c62d496bc41ff71ce242e9e082b7f38cdf356089295f80a301a3cf1182bde5308c97 +b1820ebd61376d91232423fc20bf008b2ba37e761199f4ef0648ea2bd70282766799b4de814846d2f4d516d525c8daa7 +a6b202e5dedc16a4073e04a11af3a8509b23dfe5a1952f899adeb240e75c3f5bde0c424f811a81ea48d343591faffe46 +a69becee9c93734805523b92150a59a62eed4934f66056b645728740d42223f2925a1ad38359ba644da24d9414f4cdda +ad72f0f1305e37c7e6b48c272323ee883320994cb2e0d850905d6655fafc9f361389bcb9c66b3ff8d2051dbb58c8aa96 +b563600bd56fad7c8853af21c6a02a16ed9d8a8bbeea2c31731d63b976d83cb05b9779372d898233e8fd597a75424797 +b0abb78ce465bf7051f563c62e8be9c57a2cc997f47c82819300f36e301fefd908894bb2053a9d27ce2d0f8c46d88b5b +a071a85fb8274bac2202e0cb8e0e2028a5e138a82d6e0374d39ca1884a549c7c401312f00071b91f455c3a2afcfe0cda +b931c271513a0f267b9f41444a5650b1918100b8f1a64959c552aff4e2193cc1b9927906c6fa7b8a8c68ef13d79aaa52 +a6a1bb9c7d32cb0ca44d8b75af7e40479fbce67d216b48a2bb680d3f3a772003a49d3cd675fc64e9e0f8fabeb86d6d61 +b98d609858671543e1c3b8564162ad828808bb50ded261a9f8690ded5b665ed8368c58f947365ed6e84e5a12e27b423d +b3dca58cd69ec855e2701a1d66cad86717ff103ef862c490399c771ad28f675680f9500cb97be48de34bcdc1e4503ffd +b34867c6735d3c49865e246ddf6c3b33baf8e6f164db3406a64ebce4768cb46b0309635e11be985fee09ab7a31d81402 +acb966c554188c5b266624208f31fab250b3aa197adbdd14aee5ab27d7fb886eb4350985c553b20fdf66d5d332bfd3fe +943c36a18223d6c870d54c3b051ef08d802b85e9dd6de37a51c932f90191890656c06adfa883c87b906557ae32d09da0 +81bca7954d0b9b6c3d4528aadf83e4bc2ef9ea143d6209bc45ae9e7ae9787dbcd8333c41f12c0b6deee8dcb6805e826a +aba176b92256efb68f574e543479e5cf0376889fb48e3db4ebfb7cba91e4d9bcf19dcfec444c6622d9398f06de29e2b9 +b9f743691448053216f6ece7cd699871fff4217a1409ceb8ab7bdf3312d11696d62c74b0664ba0a631b1e0237a8a0361 +a383c2b6276fa9af346b21609326b53fb14fdf6f61676683076e80f375b603645f2051985706d0401e6fbed7eb0666b6 +a9ef2f63ec6d9beb8f3d04e36807d84bda87bdd6b351a3e4a9bf7edcb5618c46c1f58cfbf89e64b40f550915c6988447 +a141b2d7a82f5005eaea7ae7d112c6788b9b95121e5b70b7168d971812f3381de8b0082ac1f0a82c7d365922ebd2d26a +b1b76ef8120e66e1535c17038b75255a07849935d3128e3e99e56567b842fb1e8d56ef932d508d2fb18b82f7868fe1a9 +8e2e234684c81f21099f5c54f6bbe2dd01e3b172623836c77668a0c49ce1fe218786c3827e4d9ae2ea25c50a8924fb3c +a5caf5ff948bfd3c4ca3ffbdfcd91eec83214a6c6017235f309a0bbf7061d3b0b466307c00b44a1009cf575163898b43 +986415a82ca16ebb107b4c50b0c023c28714281db0bcdab589f6cb13d80e473a3034b7081b3c358e725833f6d845cb14 +b94836bf406ac2cbacb10e6df5bcdfcc9d9124ae1062767ca4e322d287fd5e353fdcebd0e52407cb3cd68571258a8900 +83c6d70a640b33087454a4788dfd9ef3ed00272da084a8d36be817296f71c086b23b576f98178ab8ca6a74f04524b46b +ad4115182ad784cfe11bcfc5ce21fd56229cc2ce77ac82746e91a2f0aa53ca6593a22efd2dc4ed8d00f84542643d9c58 +ab1434c5e5065da826d10c2a2dba0facccab0e52b506ce0ce42fbe47ced5a741797151d9ecc99dc7d6373cfa1779bbf6 +8a8b591d82358d55e6938f67ea87a89097ab5f5496f7260adb9f649abb289da12b498c5b2539c2f9614fb4e21b1f66b0 +964f355d603264bc1f44c64d6d64debca66f37dff39c971d9fc924f2bc68e6c187b48564a6dc82660a98b035f8addb5d +b66235eaaf47456bc1dc4bde454a028e2ce494ece6b713a94cd6bf27cf18c717fd0c57a5681caaa2ad73a473593cdd7a +9103e3bb74304186fa4e3e355a02da77da4aca9b7e702982fc2082af67127ebb23a455098313c88465bc9b7d26820dd5 +b6a42ff407c9dd132670cdb83cbad4b20871716e44133b59a932cd1c3f97c7ac8ff7f61acfaf8628372508d8dc8cad7c +883a9c21c16a167a4171b0f084565c13b6f28ba7c4977a0de69f0a25911f64099e7bbb4da8858f2e93068f4155d04e18 +8dbb3220abc6a43220adf0331e3903d3bfd1d5213aadfbd8dfcdf4b2864ce2e96a71f35ecfb7a07c3bbabf0372b50271 +b4ad08aee48e176bda390b7d9acf2f8d5eb008f30d20994707b757dc6a3974b2902d29cd9b4d85e032810ad25ac49e97 +865bb0f33f7636ec501bb634e5b65751c8a230ae1fa807a961a8289bbf9c7fe8c59e01fbc4c04f8d59b7f539cf79ddd5 +86a54d4c12ad1e3605b9f93d4a37082fd26e888d2329847d89afa7802e815f33f38185c5b7292293d788ad7d7da1df97 +b26c8615c5e47691c9ff3deca3021714662d236c4d8401c5d27b50152ce7e566266b9d512d14eb63e65bc1d38a16f914 +827639d5ce7db43ba40152c8a0eaad443af21dc92636cc8cc2b35f10647da7d475a1e408901cd220552fddad79db74df +a2b79a582191a85dbe22dc384c9ca3de345e69f6aa370aa6d3ff1e1c3de513e30b72df9555b15a46586bd27ea2854d9d +ae0d74644aba9a49521d3e9553813bcb9e18f0b43515e4c74366e503c52f47236be92dfbd99c7285b3248c267b1de5a0 +80fb0c116e0fd6822a04b9c25f456bdca704e2be7bdc5d141dbf5d1c5eeb0a2c4f5d80db583b03ef3e47517e4f9a1b10 +ac3a1fa3b4a2f30ea7e0a114cdc479eb51773573804c2a158d603ad9902ae8e39ffe95df09c0d871725a5d7f9ba71a57 +b56b2b0d601cba7f817fa76102c68c2e518c6f20ff693aad3ff2e07d6c4c76203753f7f91686b1801e8c4659e4d45c48 +89d50c1fc56e656fb9d3915964ebce703cb723fe411ab3c9eaa88ccc5d2b155a9b2e515363d9c600d3c0cee782c43f41 +b24207e61462f6230f3cd8ccf6828357d03e725769f7d1de35099ef9ee4dca57dbce699bb49ed994462bee17059d25ce +b886f17fcbcbfcd08ac07f04bb9543ef58510189decaccea4b4158c9174a067cb67d14b6be3c934e6e2a18c77efa9c9c +b9c050ad9cafd41c6e2e192b70d080076eed59ed38ea19a12bd92fa17b5d8947d58d5546aaf5e8e27e1d3b5481a6ce51 +aaf7a34d3267e3b1ddbc54c641e3922e89303f7c86ebebc7347ebca4cffad5b76117dac0cbae1a133053492799cd936f +a9ee604ada50adef82e29e893070649d2d4b7136cc24fa20e281ce1a07bd736bf0de7c420369676bcbcecff26fb6e900 +9855315a12a4b4cf80ab90b8bd13003223ba25206e52fd4fe6a409232fbed938f30120a3db23eab9c53f308bd8b9db81 +8cd488dd7a24f548a3cf03c54dec7ff61d0685cb0f6e5c46c2d728e3500d8c7bd6bba0156f4bf600466fda53e5b20444 +890ad4942ebac8f5b16c777701ab80c68f56fa542002b0786f8fea0fb073154369920ac3dbfc07ea598b82f4985b8ced +8de0cf9ddc84c9b92c59b9b044387597799246b30b9f4d7626fc12c51f6e423e08ee4cbfe9289984983c1f9521c3e19d +b474dfb5b5f4231d7775b3c3a8744956b3f0c7a871d835d7e4fd9cc895222c7b868d6c6ce250de568a65851151fac860 +86433b6135d9ed9b5ee8cb7a6c40e5c9d30a68774cec04988117302b8a02a11a71a1e03fd8e0264ef6611d219f103007 +80b9ed4adbe9538fb1ef69dd44ec0ec5b57cbfea820054d8d445b4261962624b4c70ac330480594bc5168184378379c3 +8b2e83562ccd23b7ad2d17f55b1ab7ef5fbef64b3a284e6725b800f3222b8bdf49937f4a873917ada9c4ddfb090938c2 +abe78cebc0f5a45d754140d1f685e387489acbfa46d297a8592aaa0d676a470654f417a4f7d666fc0b2508fab37d908e +a9c5f8ff1f8568e252b06d10e1558326db9901840e6b3c26bbd0cd5e850cb5fb3af3f117dbb0f282740276f6fd84126f +975f8dc4fb55032a5df3b42b96c8c0ffecb75456f01d4aef66f973cb7270d4eff32c71520ceefc1adcf38d77b6b80c67 +b043306ed2c3d8a5b9a056565afd8b5e354c8c4569fda66b0d797a50a3ce2c08cffbae9bbe292da69f39e89d5dc7911e +8d2afc36b1e44386ba350c14a6c1bb31ff6ea77128a0c5287584ac3584282d18516901ce402b4644a53db1ed8e7fa581 +8c294058bed53d7290325c363fe243f6ec4f4ea2343692f4bac8f0cb86f115c069ccb8334b53d2e42c067691ad110dba +b92157b926751aaf7ef82c1aa8c654907dccab6376187ee8b3e8c0c82811eae01242832de953faa13ebaff7da8698b3e +a780c4bdd9e4ba57254b09d745075cecab87feda78c88ffee489625c5a3cf96aa6b3c9503a374a37927d9b78de9bd22b +811f548ef3a2e6a654f7dcb28ac9378de9515ed61e5a428515d9594a83e80b35c60f96a5cf743e6fab0d3cb526149f49 +85a4dccf6d90ee8e094731eec53bd00b3887aec6bd81a0740efddf812fd35e3e4fe4f983afb49a8588691c202dabf942 +b152c2da6f2e01c8913079ae2b40a09b1f361a80f5408a0237a8131b429677c3157295e11b365b1b1841924b9efb922e +849b9efee8742502ffd981c4517c88ed33e4dd518a330802caff168abae3cd09956a5ee5eda15900243bc2e829016b74 +955a933f3c18ec0f1c0e38fa931e4427a5372c46a3906ebe95082bcf878c35246523c23f0266644ace1fa590ffa6d119 +911989e9f43e580c886656377c6f856cdd4ff1bd001b6db3bbd86e590a821d34a5c6688a29b8d90f28680e9fdf03ba69 +b73b8b4f1fd6049fb68d47cd96a18fcba3f716e0a1061aa5a2596302795354e0c39dea04d91d232aec86b0bf2ba10522 +90f87456d9156e6a1f029a833bf3c7dbed98ca2f2f147a8564922c25ae197a55f7ea9b2ee1f81bf7383197c4bad2e20c +903cba8b1e088574cb04a05ca1899ab00d8960580c884bd3c8a4c98d680c2ad11410f2b75739d6050f91d7208cac33a5 +9329987d42529c261bd15ecedd360be0ea8966e7838f32896522c965adfc4febf187db392bd441fb43bbd10c38fdf68b +8178ee93acf5353baa349285067b20e9bb41aa32d77b5aeb7384fe5220c1fe64a2461bd7a83142694fe673e8bbf61b7c +a06a8e53abcff271b1394bcc647440f81fb1c1a5f29c27a226e08f961c3353f4891620f2d59b9d1902bf2f5cc07a4553 +aaf5fe493b337810889e777980e6bbea6cac39ac66bc0875c680c4208807ac866e9fda9b5952aa1d04539b9f4a4bec57 +aa058abb1953eceac14ccfa7c0cc482a146e1232905dcecc86dd27f75575285f06bbae16a8c9fe8e35d8713717f5f19f +8f15dd732799c879ca46d2763453b359ff483ca33adb1d0e0a57262352e0476c235987dc3a8a243c74bc768f93d3014c +a61cc8263e9bc03cce985f1663b8a72928a607121005a301b28a278e9654727fd1b22bc8a949af73929c56d9d3d4a273 +98d6dc78502d19eb9f921225475a6ebcc7b44f01a2df6f55ccf6908d65b27af1891be2a37735f0315b6e0f1576c1f8d8 +8bd258b883f3b3793ec5be9472ad1ff3dc4b51bc5a58e9f944acfb927349ead8231a523cc2175c1f98e7e1e2b9f363b8 +aeacc2ecb6e807ad09bedd99654b097a6f39840e932873ace02eabd64ccfbb475abdcb62939a698abf17572d2034c51e +b8ccf78c08ccd8df59fd6eda2e01de328bc6d8a65824d6f1fc0537654e9bc6bf6f89c422dd3a295cce628749da85c864 +8f91fd8cb253ba2e71cc6f13da5e05f62c2c3b485c24f5d68397d04665673167fce1fc1aec6085c69e87e66ec555d3fd +a254baa10cb26d04136886073bb4c159af8a8532e3fd36b1e9c3a2e41b5b2b6a86c4ebc14dbe624ee07b7ccdaf59f9ab +94e3286fe5cd68c4c7b9a7d33ae3d714a7f265cf77cd0e9bc19fc51015b1d1c34ad7e3a5221c459e89f5a043ee84e3a9 +a279da8878af8d449a9539bec4b17cea94f0242911f66fab275b5143ab040825f78c89cb32a793930609415cfa3a1078 +ac846ceb89c9e5d43a2991c8443079dc32298cd63e370e64149cec98cf48a6351c09c856f2632fd2f2b3d685a18bbf8b +a847b27995c8a2e2454aaeb983879fb5d3a23105c33175839f7300b7e1e8ec3efd6450e9fa3f10323609dee7b98c6fd5 +a2f432d147d904d185ff4b2de8c6b82fbea278a2956bc406855b44c18041854c4f0ecccd472d1d0dff1d8aa8e281cb1d +94a48ad40326f95bd63dff4755f863a1b79e1df771a1173b17937f9baba57b39e651e7695be9f66a472f098b339364fc +a12a0ccd8f96e96e1bc6494341f7ebce959899341b3a084aa1aa87d1c0d489ac908552b7770b887bb47e7b8cbc3d8e66 +81a1f1681bda923bd274bfe0fbb9181d6d164fe738e54e25e8d4849193d311e2c4253614ed673c98af2c798f19a93468 +abf71106a05d501e84cc54610d349d7d5eae21a70bd0250f1bebbf412a130414d1c8dbe673ffdb80208fd72f1defa4d4 +96266dc2e0df18d8136d79f5b59e489978eee0e6b04926687fe389d4293c14f36f055c550657a8e27be4118b64254901 +8df5dcbefbfb4810ae3a413ca6b4bf08619ca53cd50eb1dde2a1c035efffc7b7ac7dff18d403253fd80104bd83dc029e +9610b87ff02e391a43324a7122736876d5b3af2a137d749c52f75d07b17f19900b151b7f439d564f4529e77aa057ad12 +a90a5572198b40fe2fcf47c422274ff36c9624df7db7a89c0eb47eb48a73a03c985f4ac5016161c76ca317f64339bce1 +98e5e61a6ab6462ba692124dba7794b6c6bde4249ab4fcc98c9edd631592d5bc2fb5e38466691a0970a38e48d87c2e43 +918cefb8f292f78d4db81462c633daf73b395e772f47b3a7d2cea598025b1d8c3ec0cbff46cdb23597e74929981cde40 +a98918a5dc7cf610fe55f725e4fd24ce581d594cb957bb9b4e888672e9c0137003e1041f83e3f1d7b9caab06462c87d4 +b92b74ac015262ca66c33f2d950221e19d940ba3bf4cf17845f961dc1729ae227aa9e1f2017829f2135b489064565c29 +a053ee339f359665feb178b4e7ee30a85df37debd17cacc5a27d6b3369d170b0114e67ad1712ed26d828f1df641bcd99 +8c3c8bad510b35da5ce5bd84b35c958797fbea024ad1c97091d2ff71d9b962e9222f65a9b776e5b3cc29c36e1063d2ee +af99dc7330fe7c37e850283eb47cc3257888e7c197cb0d102edf94439e1e02267b6a56306d246c326c4c79f9dc8c6986 +afecb2dc34d57a725efbd7eb93d61eb29dbe8409b668ab9ea040791f5b796d9be6d4fc10d7f627bf693452f330cf0435 +93334fedf19a3727a81a6b6f2459db859186227b96fe7a391263f69f1a0884e4235de64d29edebc7b99c44d19e7c7d7a +89579c51ac405ad7e9df13c904061670ce4b38372492764170e4d3d667ed52e5d15c7cd5c5991bbfa3a5e4e3fa16363e +9778f3e8639030f7ef1c344014f124e375acb8045bd13d8e97a92c5265c52de9d1ffebaa5bc3e1ad2719da0083222991 +88f77f34ee92b3d36791bdf3326532524a67d544297dcf1a47ff00b47c1b8219ff11e34034eab7d23b507caa2fd3c6b9 +a699c1e654e7c484431d81d90657892efeb4adcf72c43618e71ca7bd7c7a7ebbb1db7e06e75b75dc4c74efd306b5df3f +81d13153baebb2ef672b5bdb069d3cd669ce0be96b742c94e04038f689ff92a61376341366b286eee6bf3ae85156f694 +81efb17de94400fdacc1deec2550cbe3eecb27c7af99d8207e2f9be397e26be24a40446d2a09536bb5172c28959318d9 +989b21ebe9ceab02488992673dc071d4d5edec24bff0e17a4306c8cb4b3c83df53a2063d1827edd8ed16d6e837f0d222 +8d6005d6536825661b13c5fdce177cb37c04e8b109b7eb2b6d82ea1cb70efecf6a0022b64f84d753d165edc2bba784a3 +a32607360a71d5e34af2271211652d73d7756d393161f4cf0da000c2d66a84c6826e09e759bd787d4fd0305e2439d342 +aaad8d6f6e260db45d51b2da723be6fa832e76f5fbcb77a9a31e7f090dd38446d3b631b96230d78208cae408c288ac4e +abcfe425255fd3c5cffd3a818af7650190c957b6b07b632443f9e33e970a8a4c3bf79ac9b71f4d45f238a04d1c049857 +aeabf026d4c783adc4414b5923dbd0be4b039cc7201219f7260d321f55e9a5b166d7b5875af6129c034d0108fdc5d666 +af49e740c752d7b6f17048014851f437ffd17413c59797e5078eaaa36f73f0017c3e7da020310cfe7d3c85f94a99f203 +8854ca600d842566e3090040cd66bb0b3c46dae6962a13946f0024c4a8aca447e2ccf6f240045f1ceee799a88cb9210c +b6c03b93b1ab1b88ded8edfa1b487a1ed8bdce8535244dddb558ffb78f89b1c74058f80f4db2320ad060d0c2a9c351cc +b5bd7d17372faff4898a7517009b61a7c8f6f0e7ed4192c555db264618e3f6e57fb30a472d169fea01bf2bf0362a19a8 +96eb1d38319dc74afe7e7eb076fcd230d19983f645abd14a71e6103545c01301b31c47ae931e025f3ecc01fb3d2f31fa +b55a8d30d4403067def9b65e16f867299f8f64c9b391d0846d4780bc196569622e7e5b64ce799b5aefac8f965b2a7a7b +8356d199a991e5cbbff608752b6291731b6b6771aed292f8948b1f41c6543e4ab1bedc82dd26d10206c907c03508df06 +97f4137445c2d98b0d1d478049de952610ad698c91c9d0f0e7227d2aae690e9935e914ec4a2ea1fbf3fc1dddfeeacebb +af5621707e0938320b15ddfc87584ab325fbdfd85c30efea36f8f9bd0707d7ec12c344eff3ec21761189518d192df035 +8ac7817e71ea0825b292687928e349da7140285d035e1e1abff0c3704fa8453faaae343a441b7143a74ec56539687cc4 +8a5e0a9e4758449489df10f3386029ada828d1762e4fb0a8ffe6b79e5b6d5d713cb64ed95960e126398b0cdb89002bc9 +81324be4a71208bbb9bca74b77177f8f1abb9d3d5d9db195d1854651f2cf333cd618d35400da0f060f3e1b025124e4b2 +849971d9d095ae067525b3cbc4a7dfae81f739537ade6d6cec1b42fb692d923176197a8770907c58069754b8882822d6 +89f830825416802477cc81fdf11084885865ee6607aa15aa4eb28e351c569c49b8a1b9b5e95ddc04fa0ebafe20071313 +9240aeeaff37a91af55f860b9badd466e8243af9e8c96a7aa8cf348cd270685ab6301bc135b246dca9eda696f8b0e350 +acf74db78cc33138273127599eba35b0fb4e7b9a69fe02dae18fc6692d748ca332bd00b22afa8e654ed587aab11833f3 +b091e6d37b157b50d76bd297ad752220cd5c9390fac16dc838f8557aed6d9833fc920b61519df21265406216315e883f +a6446c429ebf1c7793c622250e23594c836b2fbcaf6c5b3d0995e1595a37f50ea643f3e549b0be8bbdadd69044d72ab9 +93e675353bd60e996bf1c914d5267eeaa8a52fc3077987ccc796710ef9becc6b7a00e3d82671a6bdfb8145ee3c80245a +a2f731e43251d04ed3364aa2f072d05355f299626f2d71a8a38b6f76cf08c544133f7d72dd0ab4162814b674b9fc7fa6 +97a8b791a5a8f6e1d0de192d78615d73d0c38f1e557e4e15d15adc663d649e655bc8da3bcc499ef70112eafe7fb45c7a +98cd624cbbd6c53a94469be4643c13130916b91143425bcb7d7028adbbfede38eff7a21092af43b12d4fab703c116359 +995783ce38fd5f6f9433027f122d4cf1e1ff3caf2d196ce591877f4a544ce9113ead60de2de1827eaff4dd31a20d79a8 +8cf251d6f5229183b7f3fe2f607a90b4e4b6f020fb4ba2459d28eb8872426e7be8761a93d5413640a661d73e34a5b81f +b9232d99620652a3aa7880cad0876f153ff881c4ed4c0c2e7b4ea81d5d42b70daf1a56b869d752c3743c6d4c947e6641 +849716f938f9d37250cccb1bf77f5f9fde53096cdfc6f2a25536a6187029a8f1331cdbed08909184b201f8d9f04b792f +80c7c4de098cbf9c6d17b14eba1805e433b5bc905f6096f8f63d34b94734f2e4ebf4bce8a177efd1186842a61204a062 +b790f410cf06b9b8daadceeb4fd5ff40a2deda820c8df2537e0a7554613ae3948e149504e3e79aa84889df50c8678eeb +813aab8bd000299cd37485b73cd7cba06e205f8efb87f1efc0bae8b70f6db2bc7702eb39510ad734854fb65515fe9d0f +94f0ab7388ac71cdb67f6b85dfd5945748afb2e5abb622f0b5ad104be1d4d0062b651f134ba22385c9e32c2dfdcccce1 +ab6223dca8bd6a4f969e21ccd9f8106fc5251d321f9e90cc42cea2424b3a9c4e5060a47eeef6b23c7976109b548498e8 +859c56b71343fce4d5c5b87814c47bf55d581c50fd1871a17e77b5e1742f5af639d0e94d19d909ec7dfe27919e954e0c +aae0d632b6191b8ad71b027791735f1578e1b89890b6c22e37de0e4a6074886126988fe8319ae228ac9ef3b3bcccb730 +8ca9f32a27a024c3d595ecfaf96b0461de57befa3b331ab71dc110ec3be5824fed783d9516597537683e77a11d334338 +a061df379fb3f4b24816c9f6cd8a94ecb89b4c6dc6cd81e4b8096fa9784b7f97ab3540259d1de9c02eb91d9945af4823 +998603102ac63001d63eb7347a4bb2bf4cf33b28079bb48a169076a65c20d511ccd3ef696d159e54cc8e772fb5d65d50 +94444d96d39450872ac69e44088c252c71f46be8333a608a475147752dbb99db0e36acfc5198f158509401959c12b709 +ac1b51b6c09fe055c1d7c9176eea9adc33f710818c83a1fbfa073c8dc3a7eb3513cbdd3f5960b7845e31e3e83181e6ba +803d530523fc9e1e0f11040d2412d02baef3f07eeb9b177fa9bfa396af42eea898a4276d56e1db998dc96ae47b644cb2 +85a3c9fc7638f5bf2c3e15ba8c2fa1ae87eb1ceb44c6598c67a2948667a9dfa41e61f66d535b4e7fda62f013a5a8b885 +a961cf5654c46a1a22c29baf7a4e77837a26b7f138f410e9d1883480ed5fa42411d522aba32040b577046c11f007388e +ad1154142344f494e3061ef45a34fab1aaacf5fdf7d1b26adbb5fbc3d795655fa743444e39d9a4119b4a4f82a6f30441 +b1d6c30771130c77806e7ab893b73d4deb590b2ff8f2f8b5e54c2040c1f3e060e2bd99afc668cf706a2df666a508bbf6 +a00361fd440f9decabd98d96c575cd251dc94c60611025095d1201ef2dedde51cb4de7c2ece47732e5ed9b3526c2012c +a85c5ab4d17d328bda5e6d839a9a6adcc92ff844ec25f84981e4f44a0e8419247c081530f8d9aa629c7eb4ca21affba6 +a4ddd3eab4527a2672cf9463db38bc29f61460e2a162f426b7852b7a7645fbd62084fd39a8e4d60e1958cce436dd8f57 +811648140080fe55b8618f4cf17f3c5a250adb0cd53d885f2ddba835d2b4433188e41fc0661faac88e4ff910b16278c0 +b85c7f1cfb0ed29addccf7546023a79249e8f15ac2d14a20accbfef4dd9dc11355d599815fa09d2b6b4e966e6ea8cff1 +a10b5d8c260b159043b020d5dd62b3467df2671afea6d480ca9087b7e60ed170c82b121819d088315902842d66c8fb45 +917e191df1bcf3f5715419c1e2191da6b8680543b1ba41fe84ed07ef570376e072c081beb67b375fca3565a2565bcabb +881fd967407390bfd7badc9ab494e8a287559a01eb07861f527207c127eadea626e9bcc5aa9cca2c5112fbac3b3f0e9c +959fd71149af82cc733619e0e5bf71760ca2650448c82984b3db74030d0e10f8ab1ce1609a6de6f470fe8b5bd90df5b3 +a3370898a1c5f33d15adb4238df9a6c945f18b9ada4ce2624fc32a844f9ece4c916a64e9442225b6592afa06d2e015f2 +817efb8a791435e4236f7d7b278181a5fa34587578c629dbc14fbf9a5c26772290611395eecd20222a4c58649fc256d8 +a04c9876acf2cfdc8ef96de4879742709270fa1d03fe4c8511fbef2d59eb0aaf0336fa2c7dfe41a651157377fa217813 +81e15875d7ea7f123e418edf14099f2e109d4f3a6ce0eb65f67fe9fb10d2f809a864a29f60ad3fc949f89e2596b21783 +b49f529975c09e436e6bc202fdc16e3fdcbe056db45178016ad6fdece9faad4446343e83aed096209690b21a6910724f +879e8eda589e1a279f7f49f6dd0580788c040d973748ec4942dbe51ea8fbd05983cc919b78f0c6b92ef3292ae29db875 +81a2b74b2118923f34139a102f3d95e7eee11c4c2929c2576dee200a5abfd364606158535a6c9e4178a6a83dbb65f3c4 +8913f281d8927f2b45fc815d0f7104631cb7f5f7278a316f1327d670d15868daadd2a64e3eb98e1f53fe7e300338cc80 +a6f815fba7ef9af7fbf45f93bc952e8b351f5de6568a27c7c47a00cb39a254c6b31753794f67940fc7d2e9cc581529f4 +b3722a15c66a0014ce4d082de118def8d39190c15678a472b846225585f3a83756ae1b255b2e3f86a26168878e4773b2 +817ae61ab3d0dd5b6e24846b5a5364b1a7dc2e77432d9fed587727520ae2f307264ea0948c91ad29f0aea3a11ff38624 +b3db467464415fcad36dc1de2d6ba7686772a577cc2619242ac040d6734881a45d3b40ed4588db124e4289cfeec4bbf6 +ad66a14f5a54ac69603b16e5f1529851183da77d3cc60867f10aea41339dd5e06a5257982e9e90a352cdd32750f42ee4 +adafa3681ef45d685555601a25a55cf23358319a17f61e2179e704f63df83a73bdd298d12cf6cef86db89bd17119e11d +a379dc44cb6dd3b9d378c07b2ec654fec7ca2f272de6ba895e3d00d20c9e4c5550498a843c8ac67e4221db2115bedc1c +b7bf81c267a78efc6b9e5a904574445a6487678d7ef70054e3e93ea6a23f966c2b68787f9164918e3b16d2175459ed92 +b41d66a13a4afafd5760062b77f79de7e6ab8ccacde9c6c5116a6d886912fb491dc027af435b1b44aacc6af7b3c887f2 +9904d23a7c1c1d2e4bab85d69f283eb0a8e26d46e8b7b30224438015c936729b2f0af7c7c54c03509bb0500acb42d8a4 +ae30d65e9e20c3bfd603994ae2b175ff691d51f3e24b2d058b3b8556d12ca4c75087809062dddd4aaac81c94d15d8a17 +9245162fab42ac01527424f6013310c3eb462982518debef6c127f46ba8a06c705d7dc9f0a41e796ba8d35d60ae6cc64 +87fab853638d7a29a20f3ba2b1a7919d023e9415bfa78ebb27973d8cbc7626f584dc5665d2e7ad71f1d760eba9700d88 +85aac46ecd330608e5272430970e6081ff02a571e8ea444f1e11785ea798769634a22a142d0237f67b75369d3c484a8a +938c85ab14894cc5dfce3d80456f189a2e98eddbc8828f4ff6b1df1dcb7b42b17ca2ff40226a8a1390a95d63dca698dd +a18ce1f846e3e3c4d846822f60271eecf0f5d7d9f986385ac53c5ace9589dc7c0188910448c19b91341a1ef556652fa9 +8611608a9d844f0e9d7584ad6ccf62a5087a64f764caf108db648a776b5390feb51e5120f0ef0e9e11301af3987dd7dc +8106333ba4b4de8d1ae43bc9735d3fea047392e88efd6a2fa6f7b924a18a7a265ca6123c3edc0f36307dd7fb7fe89257 +a91426fa500951ff1b051a248c050b7139ca30dde8768690432d597d2b3c4357b11a577be6b455a1c5d145264dcf81fc +b7f9f90e0e450f37b081297f7f651bad0496a8b9afd2a4cf4120a2671aaaa8536dce1af301258bfbfdb122afa44c5048 +84126da6435699b0c09fa4032dec73d1fca21d2d19f5214e8b0bea43267e9a8dd1fc44f8132d8315e734c8e2e04d7291 +aff064708103884cb4f1a3c1718b3fc40a238d35cf0a7dc24bdf9823693b407c70da50df585bf5bc4e9c07d1c2d203e8 +a8b40fc6533752983a5329c31d376c7a5c13ce6879cc7faee648200075d9cd273537001fb4c86e8576350eaac6ba60c2 +a02db682bdc117a84dcb9312eb28fcbde12d49f4ce915cc92c610bb6965ec3cc38290f8c5b5ec70afe153956692cda95 +86decd22b25d300508472c9ce75d3e465b737e7ce13bc0fcce32835e54646fe12322ba5bc457be18bfd926a1a6ca4a38 +a18666ef65b8c2904fd598791f5627207165315a85ee01d5fb0e6b2e10bdd9b00babc447da5bd63445e3337de33b9b89 +89bb0c06effadefdaf34ffe4b123e1678a90d4451ee856c863df1e752eef41fd984689ded8f0f878bf8916d5dd8e8024 +97cfcba08ebec05d0073992a66b1d7d6fb9d95871f2cdc36db301f78bf8069294d1c259efef5c93d20dc937eedae3a1a +ac2643b14ece79dcb2e289c96776a47e2bebd40dd6dc74fd035df5bb727b5596f40e3dd2d2202141e69b0993717ede09 +a5e6fd88a2f9174d9bd4c6a55d9c30974be414992f22aa852f552c7648f722ed8077acf5aba030abd47939bb451b2c60 +8ad40a612824a7994487731a40b311b7349038c841145865539c6ada75c56de6ac547a1c23df190e0caaafecddd80ccc +953a7cea1d857e09202c438c6108060961f195f88c32f0e012236d7a4b39d840c61b162ec86436e8c38567328bea0246 +80d8b47a46dae1868a7b8ccfe7029445bbe1009dad4a6c31f9ef081be32e8e1ac1178c3c8fb68d3e536c84990cc035b1 +81ecd99f22b3766ce0aca08a0a9191793f68c754fdec78b82a4c3bdc2db122bbb9ebfd02fc2dcc6e1567a7d42d0cc16a +b1dd0446bccc25846fb95d08c1c9cc52fb51c72c4c5d169ffde56ecfe800f108dc1106d65d5c5bd1087c656de3940b63 +b87547f0931e164e96de5c550ca5aa81273648fe34f6e193cd9d69cf729cb432e17aa02e25b1c27a8a0d20a3b795e94e +820a94e69a927e077082aae66f6b292cfbe4589d932edf9e68e268c9bd3d71ef76cf7d169dd445b93967c25db11f58f1 +b0d07ddf2595270c39adfa0c8cf2ab1322979b0546aa4d918f641be53cd97f36c879bb75d205e457c011aca3bbd9f731 +8700b876b35b4b10a8a9372c5230acecd39539c1bb87515640293ad4464a9e02929d7d6a6a11112e8a29564815ac0de4 +a61a601c5bb27dcb97e37c8e2b9ce479c6b192a5e04d9ed5e065833c5a1017ee5f237b77d1a17be5d48f8e7cc0bcacf6 +92fb88fe774c1ba1d4a08cae3c0e05467ad610e7a3f1d2423fd47751759235fe0a3036db4095bd6404716aa03820f484 +b274f140d77a3ce0796f5e09094b516537ccaf27ae1907099bff172e6368ba85e7c3ef8ea2a07457cac48ae334da95b3 +b2292d9181f16581a9a9142490b2bdcdfb218ca6315d1effc8592100d792eb89d5356996c890441f04f2b4a95763503e +8897e73f576d86bc354baa3bd96e553107c48cf5889dcc23c5ba68ab8bcd4e81f27767be2233fdfa13d39f885087e668 +a29eac6f0829791c728d71abc49569df95a4446ecbfc534b39f24f56c88fe70301838dfc1c19751e7f3c5c1b8c6af6a0 +9346dc3720adc5df500a8df27fd9c75ef38dc5c8f4e8ed66983304750e66d502c3c59b8e955be781b670a0afc70a2167 +9566d534e0e30a5c5f1428665590617e95fd05d45f573715f58157854ad596ece3a3cfec61356aee342308d623e029d5 +a464fb8bffe6bd65f71938c1715c6e296cc6d0311a83858e4e7eb5873b7f2cf0c584d2101e3407b85b64ca78b2ac93ce +b54088f7217987c87e9498a747569ac5b2f8afd5348f9c45bf3fd9fbf713a20f495f49c8572d087efe778ac7313ad6d3 +91fa9f5f8000fe050f5b224d90b59fcce13c77e903cbf98ded752e5b3db16adb2bc1f8c94be48b69f65f1f1ad81d6264 +92d04a5b0ac5d8c8e313709b432c9434ecd3e73231f01e9b4e7952b87df60cbfa97b5dedd2200bd033b4b9ea8ba45cc1 +a94b90ad3c3d6c4bbe169f8661a790c40645b40f0a9d1c7220f01cf7fc176e04d80bab0ced9323fcafb93643f12b2760 +94d86149b9c8443b46196f7e5a3738206dd6f3be7762df488bcbb9f9ee285a64c997ed875b7b16b26604fa59020a8199 +82efe4ae2c50a2d7645240c173a047f238536598c04a2c0b69c96e96bd18e075a99110f1206bc213f39edca42ba00cc1 +ab8667685f831bc14d4610f84a5da27b4ea5b133b4d991741a9e64dceb22cb64a3ce8f1b6e101d52af6296df7127c9ad +83ba433661c05dcc5d562f4a9a261c8110dac44b8d833ae1514b1fc60d8b4ee395b18804baea04cb10adb428faf713c3 +b5748f6f660cc5277f1211d2b8649493ed8a11085b871cd33a5aea630abd960a740f08c08be5f9c21574600ac9bf5737 +a5c8dd12af48fb710642ad65ebb97ca489e8206741807f7acfc334f8035d3c80593b1ff2090c9bb7bd138f0c48714ca8 +a2b382fd5744e3babf454b1d806cc8783efeb4761bc42b6914ea48a46a2eae835efbe0a18262b6bc034379e03cf1262b +b3145ffaf603f69f15a64936d32e3219eea5ed49fdfd2f5bf40ea0dfd974b36fb6ff12164d4c2282d892db4cf3ff3ce1 +87a316fb213f4c5e30c5e3face049db66be4f28821bd96034714ec23d3e97849d7b301930f90a4323c7ccf53de23050c +b9de09a919455070fed6220fc179c8b7a4c753062bcd27acf28f5b9947a659c0b364298daf7c85c4ca6fca7f945add1f +806fbd98d411b76979464c40ad88bc07a151628a27fcc1012ba1dfbaf5b5cc9d962fb9b3386008978a12515edce934bc +a15268877fae0d21610ae6a31061ed7c20814723385955fac09fdc9693a94c33dea11db98bb89fdfe68f933490f5c381 +8d633fb0c4da86b2e0b37d8fad5972d62bff2ac663c5ec815d095cd4b7e1fe66ebef2a2590995b57eaf941983c7ad7a4 +8139e5dd9cf405e8ef65f11164f0440827d98389ce1b418b0c9628be983a9ddd6cf4863036ccb1483b40b8a527acd9ed +88b15fa94a08eac291d2b94a2b30eb851ff24addf2cc30b678e72e32cfcb3424cf4b33aa395d741803f3e578ddf524de +b5eaf0c8506e101f1646bcf049ee38d99ea1c60169730da893fd6020fd00a289eb2f415947e44677af49e43454a7b1be +8489822ad0647a7e06aa2aa5595960811858ddd4542acca419dd2308a8c5477648f4dd969a6740bb78aa26db9bfcc555 +b1e9a7b9f3423c220330d45f69e45fa03d7671897cf077f913c252e3e99c7b1b1cf6d30caad65e4228d5d7b80eb86e5e +b28fe9629592b9e6a55a1406903be76250b1c50c65296c10c5e48c64b539fb08fe11f68cf462a6edcbba71b0cee3feb2 +a41acf96a02c96cd8744ff6577c244fc923810d17ade133587e4c223beb7b4d99fa56eae311a500d7151979267d0895c +880798938fe4ba70721be90e666dfb62fcab4f3556fdb7b0dc8ec5bc34f6b4513df965eae78527136eb391889fe2caf9 +98d4d89d358e0fb7e212498c73447d94a83c1b66e98fc81427ab13acddb17a20f52308983f3a5a8e0aaacec432359604 +81430b6d2998fc78ba937a1639c6020199c52da499f68109da227882dc26d005b73d54c5bdcac1a04e8356a8ca0f7017 +a8d906a4786455eb74613aba4ce1c963c60095ffb8658d368df9266fdd01e30269ce10bf984e7465f34b4fd83beba26a +af54167ac1f954d10131d44a8e0045df00d581dd9e93596a28d157543fbe5fb25d213806ed7fb3cba6b8f5b5423562db +8511e373a978a12d81266b9afbd55035d7bc736835cfa921903a92969eeba3624437d1346b55382e61415726ab84a448 +8cf43eea93508ae586fa9a0f1354a1e16af659782479c2040874a46317f9e8d572a23238efa318fdfb87cc63932602b7 +b0bdd3bacff077173d302e3a9678d1d37936188c7ecc34950185af6b462b7c679815176f3cce5db19aac8b282f2d60ad +a355e9b87f2f2672052f5d4d65b8c1c827d24d89b0d8594641fccfb69aef1b94009105f3242058bb31c8bf51caae5a41 +b8baa9e4b950b72ff6b88a6509e8ed1304bc6fd955748b2e59a523a1e0c5e99f52aec3da7fa9ff407a7adf259652466c +840bc3dbb300ea6f27d1d6dd861f15680bd098be5174f45d6b75b094d0635aced539fa03ddbccb453879de77fb5d1fe9 +b4bc7e7e30686303856472bae07e581a0c0bfc815657c479f9f5931cff208d5c12930d2fd1ff413ebd8424bcd7a9b571 +89b5d514155d7999408334a50822508b9d689add55d44a240ff2bdde2eee419d117031f85e924e2a2c1ca77db9b91eea +a8604b6196f87a04e1350302e8aa745bba8dc162115d22657b37a1d1a98cb14876ddf7f65840b5dbd77e80cd22b4256c +83cb7acdb9e03247515bb2ce0227486ccf803426717a14510f0d59d45e998b245797d356f10abca94f7a14e1a2f0d552 +aeb3266a9f16649210ab2df0e1908ac259f34ce1f01162c22b56cf1019096ee4ea5854c36e30bb2feb06c21a71e8a45c +89e72e86edf2aa032a0fc9acf4d876a40865fbb2c8f87cb7e4d88856295c4ac14583e874142fd0c314a49aba68c0aa3c +8c3576eba0583c2a7884976b4ed11fe1fda4f6c32f6385d96c47b0e776afa287503b397fa516a455b4b8c3afeedc76db +a31e5b633bda9ffa174654fee98b5d5930a691c3c42fcf55673d927dbc8d91c58c4e42e615353145431baa646e8bbb30 +89f2f3f7a8da1544f24682f41c68114a8f78c86bd36b066e27da13acb70f18d9f548773a16bd8e24789420e17183f137 +ada27fa4e90a086240c9164544d2528621a415a5497badb79f8019dc3dce4d12eb6b599597e47ec6ac39c81efda43520 +90dc1eb21bf21c0187f359566fc4bf5386abea52799306a0e5a1151c0817c5f5bc60c86e76b1929c092c0f3ff48cedd2 +b702a53ebcc17ae35d2e735a347d2c700e9cbef8eadbece33cac83df483b2054c126593e1f462cfc00a3ce9d737e2af5 +9891b06455ec925a6f8eafffba05af6a38cc5e193acaaf74ffbf199df912c5197106c5e06d72942bbb032ce277b6417f +8c0ee71eb01197b019275bcf96cae94e81d2cdc3115dbf2d8e3080074260318bc9303597e8f72b18f965ad601d31ec43 +8aaf580aaf75c1b7a5f99ccf60503506e62058ef43b28b02f79b8536a96be3f019c9f71caf327b4e6730134730d1bef5 +ae6f9fc21dd7dfa672b25a87eb0a41644f7609fab5026d5cedb6e43a06dbbfd6d6e30322a2598c8dedde88c52eaed626 +8159b953ffece5693edadb2e906ebf76ff080ee1ad22698950d2d3bfc36ac5ea78f58284b2ca180664452d55bd54716c +ab7647c32ca5e9856ac283a2f86768d68de75ceeba9e58b74c5324f8298319e52183739aba4340be901699d66ac9eb3f +a4d85a5701d89bcfaf1572db83258d86a1a0717603d6f24ac2963ffcf80f1265e5ab376a4529ca504f4396498791253c +816080c0cdbfe61b4d726c305747a9eb58ac26d9a35f501dd32ba43c098082d20faf3ccd41aad24600aa73bfa453dfac +84f3afac024f576b0fd9acc6f2349c2fcefc3f77dbe5a2d4964d14b861b88e9b1810334b908cf3427d9b67a8aee74b18 +94b390655557b1a09110018e9b5a14490681ade275bdc83510b6465a1218465260d9a7e2a6e4ec700f58c31dc3659962 +a8c66826b1c04a2dd4c682543242e7a57acae37278bd09888a3d17747c5b5fec43548101e6f46d703638337e2fd3277b +86e6f4608a00007fa533c36a5b054c5768ccafe41ad52521d772dcae4c8a4bcaff8f7609be30d8fab62c5988cbbb6830 +837da4cf09ae8aa0bceb16f8b3bfcc3b3367aecac9eed6b4b56d7b65f55981ef066490764fb4c108792623ecf8cad383 +941ff3011462f9b5bf97d8cbdb0b6f5d37a1b1295b622f5485b7d69f2cb2bcabc83630dae427f0259d0d9539a77d8424 +b99e5d6d82aa9cf7d5970e7f710f4039ac32c2077530e4c2779250c6b9b373bc380adb0a03b892b652f649720672fc8c +a791c78464b2d65a15440b699e1e30ebd08501d6f2720adbc8255d989a82fcded2f79819b5f8f201bed84a255211b141 +84af7ad4a0e31fcbb3276ab1ad6171429cf39adcf78dc03750dc5deaa46536d15591e26d53e953dfb31e1622bc0743ab +a833e62fe97e1086fae1d4917fbaf09c345feb6bf1975b5cb863d8b66e8d621c7989ab3dbecda36bc9eaffc5eaa6fa66 +b4ef79a46a2126f53e2ebe62770feb57fd94600be29459d70a77c5e9cc260fa892be06cd60f886bf48459e48eb50d063 +b43b8f61919ea380bf151c294e54d3a3ff98e20d1ee5efbfe38aa2b66fafbc6a49739793bd5cb1c809f8b30466277c3a +ab37735af2412d2550e62df9d8b3b5e6f467f20de3890bf56faf1abf2bf3bd1d98dc3fa0ad5e7ab3fce0fa20409eb392 +82416b74b1551d484250d85bb151fabb67e29cce93d516125533df585bc80779ab057ea6992801a3d7d5c6dcff87a018 +8145d0787f0e3b5325190ae10c1d6bee713e6765fb6a0e9214132c6f78f4582bb2771aaeae40d3dad4bafb56bf7e36d8 +b6935886349ecbdd5774e12196f4275c97ec8279fdf28ccf940f6a022ebb6de8e97d6d2173c3fe402cbe9643bed3883b +87ef9b4d3dc71ac86369f8ed17e0dd3b91d16d14ae694bc21a35b5ae37211b043d0e36d8ff07dcc513fb9e6481a1f37f +ae1d0ded32f7e6f1dc8fef495879c1d9e01826f449f903c1e5034aeeabc5479a9e323b162b688317d46d35a42d570d86 +a40d16497004db4104c6794e2f4428d75bdf70352685944f3fbe17526df333e46a4ca6de55a4a48c02ecf0bde8ba03c0 +8d45121efba8cc308a498e8ee39ea6fa5cae9fb2e4aab1c2ff9d448aa8494ccbec9a078f978a86fcd97b5d5e7be7522a +a8173865c64634ba4ac2fa432740f5c05056a9deaf6427cb9b4b8da94ca5ddbc8c0c5d3185a89b8b28878194de9cdfcd +b6ec06a74d690f6545f0f0efba236e63d1fdfba54639ca2617408e185177ece28901c457d02b849fd00f1a53ae319d0a +b69a12df293c014a40070e3e760169b6f3c627caf9e50b35a93f11ecf8df98b2bc481b410eecb7ab210bf213bbe944de +97e7dc121795a533d4224803e591eef3e9008bab16f12472210b73aaf77890cf6e3877e0139403a0d3003c12c8f45636 +acdfa6fdd4a5acb7738cc8768f7cba84dbb95c639399b291ae8e4e63df37d2d4096900a84d2f0606bf534a9ccaa4993f +86ee253f3a9446a33e4d1169719b7d513c6b50730988415382faaf751988c10a421020609f7bcdef91be136704b906e2 +aac9438382a856caf84c5a8a234282f71b5fc5f65219103b147e7e6cf565522285fbfd7417b513bdad8277a00f652ca1 +83f3799d8e5772527930f5dc071a2e0a65471618993ec8990a96ccdeee65270e490bda9d26bb877612475268711ffd80 +93f28a81ac8c0ec9450b9d762fae9c7f8feaace87a6ee6bd141ef1d2d0697ef1bbd159fe6e1de640dbdab2b0361fca8a +a0825c95ba69999b90eac3a31a3fd830ea4f4b2b7409bde5f202b61d741d6326852ce790f41de5cb0eccec7af4db30c1 +83924b0e66233edd603c3b813d698daa05751fc34367120e3cf384ea7432e256ccee4d4daf13858950549d75a377107d +956fd9fa58345277e06ba2ec72f49ed230b8d3d4ff658555c52d6cddeb84dd4e36f1a614f5242d5ca0192e8daf0543c2 +944869912476baae0b114cced4ff65c0e4c90136f73ece5656460626599051b78802df67d7201c55d52725a97f5f29fe +865cb25b64b4531fb6fe4814d7c8cd26b017a6c6b72232ff53defc18a80fe3b39511b23f9e4c6c7249d06e03b2282ed2 +81e09ff55214960775e1e7f2758b9a6c4e4cd39edf7ec1adfaad51c52141182b79fe2176b23ddc7df9fd153e5f82d668 +b31006896f02bc90641121083f43c3172b1039334501fbaf1672f7bf5d174ddd185f945adf1a9c6cf77be34c5501483d +88b92f6f42ae45e9f05b16e52852826e933efd0c68b0f2418ac90957fd018df661bc47c8d43c2a7d7bfcf669dab98c3c +92fc68f595853ee8683930751789b799f397135d002eda244fe63ecef2754e15849edde3ba2f0cc8b865c9777230b712 +99ca06a49c5cd0bb097c447793fcdd809869b216a34c66c78c7e41e8c22f05d09168d46b8b1f3390db9452d91bc96dea +b48b9490a5d65296802431852d548d81047bbefc74fa7dc1d4e2a2878faacdfcb365ae59209cb0ade01901a283cbd15d +aff0fdbef7c188b120a02bc9085d7b808e88f73973773fef54707bf2cd772cd066740b1b6f4127b5c349f657bd97e738 +966fd4463b4f43dd8ccba7ad50baa42292f9f8b2e70da23bb6780e14155d9346e275ef03ddaf79e47020dcf43f3738bd +9330c3e1fadd9e08ac85f4839121ae20bbeb0a5103d84fa5aadbd1213805bdcda67bf2fb75fc301349cbc851b5559d20 +993bb99867bd9041a71a55ad5d397755cfa7ab6a4618fc526179bfc10b7dc8b26e4372fe9a9b4a15d64f2b63c1052dda +a29b59bcfab51f9b3c490a3b96f0bf1934265c315349b236012adbd64a56d7f6941b2c8cc272b412044bc7731f71e1dc +a65c9cefe1fc35d089fe8580c2e7671ebefdb43014ac291528ff4deefd4883fd4df274af83711dad610dad0d615f9d65 +944c78c56fb227ae632805d448ca3884cd3d2a89181cead3d2b7835e63297e6d740aa79a112edb1d4727824991636df5 +a73d782da1db7e4e65d7b26717a76e16dd9fab4df65063310b8e917dc0bc24e0d6755df5546c58504d04d9e68c3b474a +af80f0b87811ae3124f68108b4ca1937009403f87928bbc53480e7c5408d072053ace5eeaf5a5aba814dab8a45502085 +88aaf1acfc6e2e19b8387c97da707cb171c69812fefdd4650468e9b2c627bd5ccfb459f4d8e56bdfd84b09ddf87e128f +92c97276ff6f72bab6e9423d02ad6dc127962dbce15a0dd1e4a393b4510c555df6aa27be0f697c0d847033a9ca8b8dfd +a0e07d43d96e2d85b6276b3c60aadb48f0aedf2de8c415756dc597249ea64d2093731d8735231dadc961e5682ac59479 +adc9e6718a8f9298957d1da3842a7751c5399bbdf56f8de6c1c4bc39428f4aee6f1ba6613d37bf46b9403345e9d6fc81 +951da434da4b20d949b509ceeba02e24da7ed2da964c2fcdf426ec787779c696b385822c7dbea4df3e4a35921f1e912c +a04cbce0d2b2e87bbf038c798a12ec828423ca6aca08dc8d481cf6466e3c9c73d4d4a7fa47df9a7e2e15aae9e9f67208 +8f855cca2e440d248121c0469de1f94c2a71b8ee2682bbad3a78243a9e03da31d1925e6760dbc48a1957e040fae9abe8 +b642e5b17c1df4a4e101772d73851180b3a92e9e8b26c918050f51e6dd3592f102d20b0a1e96f0e25752c292f4c903ff +a92454c300781f8ae1766dbbb50a96192da7d48ef4cbdd72dd8cbb44c6eb5913c112cc38e9144615fdc03684deb99420 +8b74f7e6c2304f8e780df4649ef8221795dfe85fdbdaa477a1542d135b75c8be45bf89adbbb6f3ddf54ca40f02e733e9 +85cf66292cbb30cec5fd835ab10c9fcb3aea95e093aebf123e9a83c26f322d76ebc89c4e914524f6c5f6ee7d74fc917d +ae0bfe0cdc97c09542a7431820015f2d16067b30dca56288013876025e81daa8c519e5e347268e19aa1a85fa1dc28793 +921322fc6a47dc091afa0ad6df18ed14cde38e48c6e71550aa513918b056044983aee402de21051235eecf4ce8040fbe +96c030381e97050a45a318d307dcb3c8377b79b4dd5daf6337cded114de26eb725c14171b9b8e1b3c08fe1f5ea6b49e0 +90c23b86b6111818c8baaf53a13eaee1c89203b50e7f9a994bf0edf851919b48edbac7ceef14ac9414cf70c486174a77 +8bf6c301240d2d1c8d84c71d33a6dfc6d9e8f1cfae66d4d0f7a256d98ae12b0bcebfa94a667735ee89f810bcd7170cff +a41a4ffbbea0e36874d65c009ee4c3feffff322f6fc0e30d26ee4dbc1f46040d05e25d9d0ecb378cef0d24a7c2c4b850 +a8d4cdd423986bb392a0a92c12a8bd4da3437eec6ef6af34cf5310944899287452a2eb92eb5386086d5063381189d10e +a81dd26ec057c4032a4ed7ad54d926165273ed51d09a1267b2e477535cf6966835a257c209e4e92d165d74fa75695fa3 +8d7f708c3ee8449515d94fc26b547303b53d8dd55f177bc3b25d3da2768accd9bc8e9f09546090ebb7f15c66e6c9c723 +839ba65cffcd24cfffa7ab3b21faabe3c66d4c06324f07b2729c92f15cad34e474b0f0ddb16cd652870b26a756b731d3 +87f1a3968afec354d92d77e2726b702847c6afcabb8438634f9c6f7766de4c1504317dc4fa9a4a735acdbf985e119564 +91a8a7fd6542f3e0673f07f510d850864b34ac087eb7eef8845a1d14b2b1b651cbdc27fa4049bdbf3fea54221c5c8549 +aef3cf5f5e3a2385ead115728d7059e622146c3457d266c612e778324b6e06fbfb8f98e076624d2f3ce1035d65389a07 +819915d6232e95ccd7693fdd78d00492299b1983bc8f96a08dcb50f9c0a813ed93ae53c0238345d5bea0beda2855a913 +8e9ba68ded0e94935131b392b28218315a185f63bf5e3c1a9a9dd470944509ca0ba8f6122265f8da851b5cc2abce68f1 +b28468e9b04ee9d69003399a3cf4457c9bf9d59f36ab6ceeb8e964672433d06b58beeea198fedc7edbaa1948577e9fa2 +a633005e2c9f2fd94c8bce2dd5bb708fe946b25f1ec561ae65e54e15cdd88dc339f1a083e01f0d39610c8fe24151aaf0 +841d0031e22723f9328dd993805abd13e0c99b0f59435d2426246996b08d00ce73ab906f66c4eab423473b409e972ce0 +85758d1b084263992070ec8943f33073a2d9b86a8606672550c17545507a5b3c88d87382b41916a87ee96ff55a7aa535 +8581b06b0fc41466ef94a76a1d9fb8ae0edca6d018063acf6a8ca5f4b02d76021902feba58972415691b4bdbc33ae3b4 +83539597ff5e327357ee62bc6bf8c0bcaec2f227c55c7c385a4806f0d37fb461f1690bad5066b8a5370950af32fafbef +aee3557290d2dc10827e4791d00e0259006911f3f3fce4179ed3c514b779160613eca70f720bff7804752715a1266ffa +b48d2f0c4e90fc307d5995464e3f611a9b0ef5fe426a289071f4168ed5cc4f8770c9332960c2ca5c8c427f40e6bb389f +847af8973b4e300bb06be69b71b96183fd1a0b9d51b91701bef6fcfde465068f1eb2b1503b07afda380f18d69de5c9e1 +a70a6a80ce407f07804c0051ac21dc24d794b387be94eb24e1db94b58a78e1bcfb48cd0006db8fc1f9bedaece7a44fbe +b40e942b8fa5336910ff0098347df716bff9d1fa236a1950c16eeb966b3bc1a50b8f7b0980469d42e75ae13ced53cead +b208fabaa742d7db3148515330eb7a3577487845abdb7bd9ed169d0e081db0a5816595c33d375e56aeac5b51e60e49d3 +b7c8194b30d3d6ef5ab66ec88ad7ebbc732a3b8a41731b153e6f63759a93f3f4a537eab9ad369705bd730184bdbbdc34 +9280096445fe7394d04aa1bc4620c8f9296e991cc4d6c131bd703cb1cc317510e6e5855ac763f4d958c5edfe7eebeed7 +abc2aa4616a521400af1a12440dc544e3c821313d0ab936c86af28468ef8bbe534837e364598396a81cf8d06274ed5a6 +b18ca8a3325adb0c8c18a666d4859535397a1c3fe08f95eebfac916a7a99bbd40b3c37b919e8a8ae91da38bc00fa56c0 +8a40c33109ecea2a8b3558565877082f79121a432c45ec2c5a5e0ec4d1c203a6788e6b69cb37f1fd5b8c9a661bc5476d +88c47301dd30998e903c84e0b0f2c9af2e1ce6b9f187dab03528d44f834dc991e4c86d0c474a2c63468cf4020a1e24a0 +920c832853e6ab4c851eecfa9c11d3acc7da37c823be7aa1ab15e14dfd8beb5d0b91d62a30cec94763bd8e4594b66600 +98e1addbe2a6b8edc7f12ecb9be81c3250aeeca54a1c6a7225772ca66549827c15f3950d01b8eb44aecb56fe0fff901a +8cfb0fa1068be0ec088402f5950c4679a2eb9218c729da67050b0d1b2d7079f3ddf4bf0f57d95fe2a8db04bc6bcdb20c +b70f381aafe336b024120453813aeab70baac85b9c4c0f86918797b6aee206e6ed93244a49950f3d8ec9f81f4ac15808 +a4c8edf4aa33b709a91e1062939512419711c1757084e46f8f4b7ed64f8e682f4e78b7135920c12f0eb0422fe9f87a6a +b4817e85fd0752d7ebb662d3a51a03367a84bac74ebddfba0e5af5e636a979500f72b148052d333b3dedf9edd2b4031b +a87430169c6195f5d3e314ff2d1c2f050e766fd5d2de88f5207d72dba4a7745bb86d0baca6e9ae156582d0d89e5838c7 +991b00f8b104566b63a12af4826b61ce7aa40f4e5b8fff3085e7a99815bdb4471b6214da1e480214fac83f86a0b93cc5 +b39966e3076482079de0678477df98578377a094054960ee518ef99504d6851f8bcd3203e8da5e1d4f6f96776e1fe6eb +a448846d9dc2ab7a0995fa44b8527e27f6b3b74c6e03e95edb64e6baa4f1b866103f0addb97c84bef1d72487b2e21796 +894bec21a453ae84b592286e696c35bc30e820e9c2fd3e63dd4fbe629e07df16439c891056070faa490155f255bf7187 +a9ec652a491b11f6a692064e955f3f3287e7d2764527e58938571469a1e29b5225b9415bd602a45074dfbfe9c131d6ca +b39d37822e6cbe28244b5f42ce467c65a23765bd16eb6447c5b3e942278069793763483dafd8c4dd864f8917aad357fe +88dba51133f2019cb266641c56101e3e5987d3b77647a2e608b5ff9113dfc5f85e2b7c365118723131fbc0c9ca833c9c +b566579d904b54ecf798018efcb824dccbebfc6753a0fd2128ac3b4bd3b038c2284a7c782b5ca6f310eb7ea4d26a3f0a +a97a55c0a492e53c047e7d6f9d5f3e86fb96f3dddc68389c0561515343b66b4bc02a9c0d5722dff1e3445308240b27f7 +a044028ab4bcb9e1a2b9b4ca4efbf04c5da9e4bf2fff0e8bd57aa1fc12a71e897999c25d9117413faf2f45395dee0f13 +a78dc461decbeaeed8ebd0909369b491a5e764d6a5645a7dac61d3140d7dc0062526f777b0eb866bff27608429ebbdde +b2c2a8991f94c39ca35fea59f01a92cb3393e0eccb2476dfbf57261d406a68bd34a6cff33ed80209991688c183609ef4 +84189eefb521aff730a4fd3fd5b10ddfd29f0d365664caef63bb015d07e689989e54c33c2141dd64427805d37a7e546e +85ac80bd734a52235da288ff042dea9a62e085928954e8eacd2c751013f61904ed110e5b3afe1ab770a7e6485efb7b5e +9183a560393dcb22d0d5063e71182020d0fbabb39e32493eeffeb808df084aa243eb397027f150b55a247d1ed0c8513e +81c940944df7ecc58d3c43c34996852c3c7915ed185d7654627f7af62abae7e0048dd444a6c09961756455000bd96d09 +aa8c34e164019743fd8284b84f06c3b449aae7996e892f419ee55d82ad548cb300fd651de329da0384243954c0ef6a60 +89a7b7bdfc7e300d06a14d463e573d6296d8e66197491900cc9ae49504c4809ff6e61b758579e9091c61085ba1237b83 +878d21809ba540f50bd11f4c4d9590fb6f3ab9de5692606e6e2ef4ed9d18520119e385be5e1f4b3f2e2b09c319f0e8fc +8eb248390193189cf0355365e630b782cd15751e672dc478b39d75dc681234dcd9309df0d11f4610dbb249c1e6be7ef9 +a1d7fb3aecb896df3a52d6bd0943838b13f1bd039c936d76d03de2044c371d48865694b6f532393b27fd10a4cf642061 +a34bca58a24979be442238cbb5ece5bee51ae8c0794dd3efb3983d4db713bc6f28a96e976ac3bd9a551d3ed9ba6b3e22 +817c608fc8cacdd178665320b5a7587ca21df8bdd761833c3018b967575d25e3951cf3d498a63619a3cd2ad4406f5f28 +86c95707db0495689afd0c2e39e97f445f7ca0edffad5c8b4cacd1421f2f3cc55049dfd504f728f91534e20383955582 +99c3b0bb15942c301137765d4e19502f65806f3b126dc01a5b7820c87e8979bce6a37289a8f6a4c1e4637227ad5bf3bf +8aa1518a80ea8b074505a9b3f96829f5d4afa55a30efe7b4de4e5dbf666897fdd2cf31728ca45921e21a78a80f0e0f10 +8d74f46361c79e15128ac399e958a91067ef4cec8983408775a87eca1eed5b7dcbf0ddf30e66f51780457413496c7f07 +a41cde4a786b55387458a1db95171aca4fd146507b81c4da1e6d6e495527c3ec83fc42fad1dfe3d92744084a664fd431 +8c352852c906fae99413a84ad11701f93f292fbf7bd14738814f4c4ceab32db02feb5eb70bc73898b0bc724a39d5d017 +a5993046e8f23b71ba87b7caa7ace2d9023fb48ce4c51838813174880d918e9b4d2b0dc21a2b9c6f612338c31a289df8 +83576d3324bf2d8afbfb6eaecdc5d767c8e22e7d25160414924f0645491df60541948a05e1f4202e612368e78675de8a +b43749b8df4b15bc9a3697e0f1c518e6b04114171739ef1a0c9c65185d8ec18e40e6954d125cbc14ebc652cf41ad3109 +b4eebd5d80a7327a040cafb9ccdb12b2dfe1aa86e6bc6d3ac8a57fadfb95a5b1a7332c66318ff72ba459f525668af056 +9198be7f1d413c5029b0e1c617bcbc082d21abe2c60ec8ce9b54ca1a85d3dba637b72fda39dae0c0ae40d047eab9f55a +8d96a0232832e24d45092653e781e7a9c9520766c3989e67bbe86b3a820c4bf621ea911e7cd5270a4bfea78b618411f6 +8d7160d0ea98161a2d14d46ef01dff72d566c330cd4fabd27654d300e1bc7644c68dc8eabf2a20a59bfe7ba276545f9b +abb60fce29dec7ba37e3056e412e0ec3e05538a1fc0e2c68877378c867605966108bc5742585ab6a405ce0c962b285b6 +8fabffa3ed792f05e414f5839386f6449fd9f7b41a47595c5d71074bd1bb3784cc7a1a7e1ad6b041b455035957e5b2dc +90ff017b4804c2d0533b72461436b10603ab13a55f86fd4ec11b06a70ef8166f958c110519ca1b4cc7beba440729fe2d +b340cfd120f6a4623e3a74cf8c32bfd7cd61a280b59dfd17b15ca8fae4d82f64a6f15fbde4c02f424debc72b7db5fe67 +871311c9c7220c932e738d59f0ecc67a34356d1429fe570ca503d340c9996cb5ee2cd188fad0e3bd16e4c468ec1dbebd +a772470262186e7b94239ba921b29f2412c148d6f97c4412e96d21e55f3be73f992f1ad53c71008f0558ec3f84e2b5a7 +b2a897dcb7ffd6257f3f2947ec966f2077d57d5191a88840b1d4f67effebe8c436641be85524d0a21be734c63ab5965d +a044f6eacc48a4a061fa149500d96b48cbf14853469aa4d045faf3dca973be1bd4b4ce01646d83e2f24f7c486d03205d +981af5dc2daa73f7fa9eae35a93d81eb6edba4a7f673b55d41f6ecd87a37685d31bb40ef4f1c469b3d72f2f18b925a17 +912d2597a07864de9020ac77083eff2f15ceb07600f15755aba61251e8ce3c905a758453b417f04d9c38db040954eb65 +9642b7f6f09394ba5e0805734ef6702c3eddf9eea187ba98c676d5bbaec0e360e3e51dc58433aaa1e2da6060c8659cb7 +8ab3836e0a8ac492d5e707d056310c4c8e0489ca85eb771bff35ba1d658360084e836a6f51bb990f9e3d2d9aeb18fbb5 +879e058e72b73bb1f4642c21ffdb90544b846868139c6511f299aafe59c2d0f0b944dffc7990491b7c4edcd6a9889250 +b9e60b737023f61479a4a8fd253ed0d2a944ea6ba0439bbc0a0d3abf09b0ad1f18d75555e4a50405470ae4990626f390 +b9c2535d362796dcd673640a9fa2ebdaec274e6f8b850b023153b0a7a30fffc87f96e0b72696f647ebe7ab63099a6963 +94aeff145386a087b0e91e68a84a5ede01f978f9dd9fe7bebca78941938469495dc30a96bba9508c0d017873aeea9610 +98b179f8a3d9f0d0a983c30682dd425a2ddc7803be59bd626c623c8951a5179117d1d2a68254c95c9952989877d0ee55 +889ecf5f0ee56938273f74eb3e9ecfb5617f04fb58e83fe4c0e4aef51615cf345bc56f3f61b17f6eed3249d4afd54451 +a0f2b2c39bcea4b50883e2587d16559e246248a66ecb4a4b7d9ab3b51fb39fe98d83765e087eee37a0f86b0ba4144c02 +b2a61e247ed595e8a3830f7973b07079cbda510f28ad8c78c220b26cb6acde4fbb5ee90c14a665f329168ee951b08cf0 +95bd0fcfb42f0d6d8a8e73d7458498a85bcddd2fb132fd7989265648d82ac2707d6d203fac045504977af4f0a2aca4b7 +843e5a537c298666e6cf50fcc044f13506499ef83c802e719ff2c90e85003c132024e04711be7234c04d4b0125512d5d +a46d1797c5959dcd3a5cfc857488f4d96f74277c3d13b98b133620192f79944abcb3a361d939a100187f1b0856eae875 +a1c7786736d6707a48515c38660615fcec67eb8a2598f46657855215f804fd72ab122d17f94fcffad8893f3be658dca7 +b23dc9e610abc7d8bd21d147e22509a0fa49db5be6ea7057b51aae38e31654b3aa044df05b94b718153361371ba2f622 +b00cc8f257d659c22d30e6d641f79166b1e752ea8606f558e4cad6fc01532e8319ea4ee12265ba4140ac45aa4613c004 +ac7019af65221b0cc736287b32d7f1a3561405715ba9a6a122342e04e51637ba911c41573de53e4781f2230fdcb2475f +81a630bc41b3da8b3eb4bf56cba10cd9f93153c3667f009dc332287baeb707d505fb537e6233c8e53d299ec0f013290c +a6b7aea5c545bb76df0f230548539db92bc26642572cb7dd3d5a30edca2b4c386f44fc8466f056b42de2a452b81aff5b +8271624ff736b7b238e43943c81de80a1612207d32036d820c11fc830c737972ccc9c60d3c2359922b06652311e3c994 +8a684106458cb6f4db478170b9ad595d4b54c18bf63b9058f095a2fa1b928c15101472c70c648873d5887880059ed402 +a5cc3c35228122f410184e4326cf61a37637206e589fcd245cb5d0cec91031f8f7586b80503070840fdfd8ce75d3c88b +9443fc631aed8866a7ed220890911057a1f56b0afe0ba15f0a0e295ab97f604b134b1ed9a4245e46ee5f9a93aa74f731 +984b6f7d79835dffde9558c6bb912d992ca1180a2361757bdba4a7b69dc74b056e303adc69fe67414495dd9c2dd91e64 +b15a5c8cba5de080224c274d31c68ed72d2a7126d347796569aef0c4e97ed084afe3da4d4b590b9dda1a07f0c2ff3dfb +991708fe9650a1f9a4e43938b91d45dc68c230e05ee999c95dbff3bf79b1c1b2bb0e7977de454237c355a73b8438b1d9 +b4f7edc7468b176a4a7c0273700c444fa95c726af6697028bed4f77eee887e3400f9c42ee15b782c0ca861c4c3b8c98a +8c60dcc16c51087eb477c13e837031d6c6a3dc2b8bf8cb43c23f48006bc7173151807e866ead2234b460c2de93b31956 +83ad63e9c910d1fc44bc114accfb0d4d333b7ebe032f73f62d25d3e172c029d5e34a1c9d547273bf6c0fead5c8801007 +85de73213cc236f00777560756bdbf2b16841ba4b55902cf2cad9742ecaf5d28209b012ceb41f337456dfeca93010cd7 +a7561f8827ccd75b6686ba5398bb8fc3083351c55a589b18984e186820af7e275af04bcd4c28e1dc11be1e8617a0610b +88c0a4febd4068850557f497ea888035c7fc9f404f6cc7794e7cc8722f048ad2f249e7dc62743e7a339eb7473ad3b0cd +932b22b1d3e6d5a6409c34980d176feb85ada1bf94332ef5c9fc4d42b907dabea608ceef9b5595ef3feee195151f18d8 +a2867bb3f5ab88fbdae3a16c9143ab8a8f4f476a2643c505bb9f37e5b1fd34d216cab2204c9a017a5a67b7ad2dda10e8 +b573d5f38e4e9e8a3a6fd82f0880dc049efa492a946d00283019bf1d5e5516464cf87039e80aef667cb86fdea5075904 +b948f1b5ab755f3f5f36af27d94f503b070696d793b1240c1bdfd2e8e56890d69e6904688b5f8ff5a4bdf5a6abfe195f +917eae95ebc4109a2e99ddd8fec7881d2f7aaa0e25fda44dec7ce37458c2ee832f1829db7d2dcfa4ca0f06381c7fe91d +95751d17ed00a3030bce909333799bb7f4ab641acf585807f355b51d6976dceee410798026a1a004ef4dcdff7ec0f5b8 +b9b7bd266f449a79bbfe075e429613e76c5a42ac61f01c8f0bbbd34669650682efe01ff9dbbc400a1e995616af6aa278 +ac1722d097ce9cd7617161f8ec8c23d68f1fb1c9ca533e2a8b4f78516c2fd8fb38f23f834e2b9a03bb06a9d655693ca9 +a7ad9e96ffd98db2ecdb6340c5d592614f3c159abfd832fe27ee9293519d213a578e6246aae51672ee353e3296858873 +989b8814d5de7937c4acafd000eec2b4cd58ba395d7b25f98cafd021e8efa37029b29ad8303a1f6867923f5852a220eb +a5bfe6282c771bc9e453e964042d44eff4098decacb89aecd3be662ea5b74506e1357ab26f3527110ba377711f3c9f41 +8900a7470b656639721d2abbb7b06af0ac4222ab85a1976386e2a62eb4b88bfb5b72cf7921ddb3cf3a395d7eeb192a2e +95a71b55cd1f35a438cf5e75f8ff11c5ec6a2ebf2e4dba172f50bfad7d6d5dca5de1b1afc541662c81c858f7604c1163 +82b5d62fea8db8d85c5bc3a76d68dedd25794cf14d4a7bc368938ffca9e09f7e598fdad2a5aac614e0e52f8112ae62b9 +997173f07c729202afcde3028fa7f52cefc90fda2d0c8ac2b58154a5073140683e54c49ed1f254481070d119ce0ce02a +aeffb91ccc7a72bbd6ffe0f9b99c9e66e67d59cec2e02440465e9636a613ab3017278cfa72ea8bc4aba9a8dc728cb367 +952743b06e8645894aeb6440fc7a5f62dd3acf96dab70a51e20176762c9751ea5f2ba0b9497ccf0114dc4892dc606031 +874c63baeddc56fbbca2ff6031f8634b745f6e34ea6791d7c439201aee8f08ef5ee75f7778700a647f3b21068513fce6 +85128fec9c750c1071edfb15586435cc2f317e3e9a175bb8a9697bcda1eb9375478cf25d01e7fed113483b28f625122d +85522c9576fd9763e32af8495ae3928ed7116fb70d4378448926bc9790e8a8d08f98cf47648d7da1b6e40d6a210c7924 +97d0f37a13cfb723b848099ca1c14d83e9aaf2f7aeb71829180e664b7968632a08f6a85f557d74b55afe6242f2a36e7c +abaa472d6ad61a5fccd1a57c01aa1bc081253f95abbcba7f73923f1f11c4e79b904263890eeb66926de3e2652f5d1c70 +b3c04945ba727a141e5e8aec2bf9aa3772b64d8fd0e2a2b07f3a91106a95cbcb249adcd074cbe498caf76fffac20d4ef +82c46781a3d730d9931bcabd7434a9171372dde57171b6180e5516d4e68db8b23495c8ac3ab96994c17ddb1cf249b9fb +a202d8b65613c42d01738ccd68ed8c2dbc021631f602d53f751966e04182743ebc8e0747d600b8a8676b1da9ae7f11ab +ae73e7256e9459db04667a899e0d3ea5255211fb486d084e6550b6dd64ca44af6c6b2d59d7aa152de9f96ce9b58d940d +b67d87b176a9722945ec7593777ee461809861c6cfd1b945dde9ee4ff009ca4f19cf88f4bbb5c80c9cbab2fe25b23ac8 +8f0b7a317a076758b0dac79959ee4a06c08b07d0f10538a4b53d3da2eda16e2af26922feb32c090330dc4d969cf69bd3 +90b36bf56adbd8c4b6cb32febc3a8d5f714370c2ac3305c10fa6d168dffb2a026804517215f9a2d4ec8310cdb6bb459b +aa80c19b0682ead69934bf18cf476291a0beddd8ef4ed75975d0a472e2ab5c70f119722a8574ae4973aceb733d312e57 +a3fc9abb12574e5c28dcb51750b4339b794b8e558675eef7d26126edf1de920c35e992333bcbffcbf6a5f5c0d383ce62 +a1573ff23ab972acdcd08818853b111fc757fdd35aa070186d3e11e56b172fb49d840bf297ac0dd222e072fc09f26a81 +98306f2be4caa92c2b4392212d0cbf430b409b19ff7d5b899986613bd0e762c909fc01999aa94be3bd529d67f0113d7f +8c1fc42482a0819074241746d17dc89c0304a2acdae8ed91b5009e9e3e70ff725ba063b4a3e68fdce05b74f5180c545e +a6c6113ebf72d8cf3163b2b8d7f3fa24303b13f55752522c660a98cd834d85d8c79214d900fa649499365e2e7641f77a +ab95eea424f8a2cfd9fb1c78bb724e5b1d71a0d0d1e4217c5d0f98b0d8bbd3f8400a2002abc0a0e4576d1f93f46fefad +823c5a4fd8cf4a75fdc71d5f2dd511b6c0f189b82affeacd2b7cfcad8ad1a5551227dcc9bfdb2e34b2097eaa00efbb51 +b97314dfff36d80c46b53d87a61b0e124dc94018a0bb680c32765b9a2d457f833a7c42bbc90b3b1520c33a182580398d +b17566ee3dcc6bb3b004afe4c0136dfe7dd27df9045ae896dca49fb36987501ae069eb745af81ba3fc19ff037e7b1406 +b0bdc0f55cfd98d331e3a0c4fbb776a131936c3c47c6bffdc3aaf7d8c9fa6803fbc122c2fefbb532e634228687d52174 +aa5d9e60cc9f0598559c28bb9bdd52aa46605ab4ffe3d192ba982398e72cec9a2a44c0d0d938ce69935693cabc0887ea +802b6459d2354fa1d56c592ac1346c428dadea6b6c0a87bf7d309bab55c94e1cf31dd98a7a86bd92a840dd51f218b91b +a526914efdc190381bf1a73dd33f392ecf01350b9d3f4ae96b1b1c3d1d064721c7d6eec5788162c933245a3943f5ee51 +b3b8fcf637d8d6628620a1a99dbe619eabb3e5c7ce930d6efd2197e261bf394b74d4e5c26b96c4b8009c7e523ccfd082 +8f7510c732502a93e095aba744535f3928f893f188adc5b16008385fb9e80f695d0435bfc5b91cdad4537e87e9d2551c +97b90beaa56aa936c3ca45698f79273a68dd3ccd0076eab48d2a4db01782665e63f33c25751c1f2e070f4d1a8525bf96 +b9fb798324b1d1283fdc3e48288e3861a5449b2ab5e884b34ebb8f740225324af86e4711da6b5cc8361c1db15466602f +b6d52b53cea98f1d1d4c9a759c25bf9d8a50b604b144e4912acbdbdc32aab8b9dbb10d64a29aa33a4f502121a6fb481c +9174ffff0f2930fc228f0e539f5cfd82c9368d26b074467f39c07a774367ff6cccb5039ac63f107677d77706cd431680 +a33b6250d4ac9e66ec51c063d1a6a31f253eb29bbaed12a0d67e2eccfffb0f3a52750fbf52a1c2aaba8c7692346426e7 +a97025fd5cbcebe8ef865afc39cd3ea707b89d4e765ec817fd021d6438e02fa51e3544b1fd45470c58007a08efac6edd +b32a78480edd9ff6ba2f1eec4088db5d6ceb2d62d7e59e904ecaef7bb4a2e983a4588e51692b3be76e6ffbc0b5f911a5 +b5ab590ef0bb77191f00495b33d11c53c65a819f7d0c1f9dc4a2caa147a69c77a4fff7366a602d743ee1f395ce934c1e +b3fb0842f9441fb1d0ee0293b6efbc70a8f58d12d6f769b12872db726b19e16f0f65efbc891cf27a28a248b0ef9c7e75 +9372ad12856fefb928ccb0d34e198df99e2f8973b07e9d417a3134d5f69e12e79ff572c4e03ccd65415d70639bc7c73e +aa8d6e83d09ce216bfe2009a6b07d0110d98cf305364d5529c170a23e693aabb768b2016befb5ada8dabdd92b4d012bb +a954a75791eeb0ce41c85200c3763a508ed8214b5945a42c79bfdcfb1ec4f86ad1dd7b2862474a368d4ac31911a2b718 +8e2081cfd1d062fe3ab4dab01f68062bac802795545fede9a188f6c9f802cb5f884e60dbe866710baadbf55dc77c11a4 +a2f06003b9713e7dd5929501ed485436b49d43de80ea5b15170763fd6346badf8da6de8261828913ee0dacd8ff23c0e1 +98eecc34b838e6ffd1931ca65eec27bcdb2fdcb61f33e7e5673a93028c5865e0d1bf6d3bec040c5e96f9bd08089a53a4 +88cc16019741b341060b95498747db4377100d2a5bf0a5f516f7dec71b62bcb6e779de2c269c946d39040e03b3ae12b7 +ad1135ccbc3019d5b2faf59a688eef2500697642be8cfbdf211a1ab59abcc1f24483e50d653b55ff1834675ac7b4978f +a946f05ed9972f71dfde0020bbb086020fa35b482cce8a4cc36dd94355b2d10497d7f2580541bb3e81b71ac8bba3c49f +a83aeed488f9a19d8cfd743aa9aa1982ab3723560b1cd337fc2f91ad82f07afa412b3993afb845f68d47e91ba4869840 +95eebe006bfc316810cb71da919e5d62c2cebb4ac99d8e8ef67be420302320465f8b69873470982de13a7c2e23516be9 +a55f8961295a11e91d1e5deadc0c06c15dacbfc67f04ccba1d069cba89d72aa3b3d64045579c3ea8991b150ac29366ae +b321991d12f6ac07a5de3c492841d1a27b0d3446082fbce93e7e1f9e8d8fe3b45d41253556261c21b70f5e189e1a7a6f +a0b0822f15f652ce7962a4f130104b97bf9529797c13d6bd8e24701c213cc37f18157bd07f3d0f3eae6b7cd1cb40401f +96e2fa4da378aa782cc2d5e6e465fc9e49b5c805ed01d560e9b98abb5c0de8b74a2e7bec3aa5e2887d25cccb12c66f0c +97e4ab610d414f9210ed6f35300285eb3ccff5b0b6a95ed33425100d7725e159708ea78704497624ca0a2dcabce3a2f9 +960a375b17bdb325761e01e88a3ea57026b2393e1d887b34b8fa5d2532928079ce88dc9fd06a728b26d2bb41b12b9032 +8328a1647398e832aadc05bd717487a2b6fcdaa0d4850d2c4da230c6a2ed44c3e78ec4837b6094f3813f1ee99414713f +aa283834ebd18e6c99229ce4b401eda83f01d904f250fedd4e24f1006f8fa0712a6a89a7296a9bf2ce8de30e28d1408e +b29e097f2caadae3e0f0ae3473c072b0cd0206cf6d2e9b22c1a5ad3e07d433e32bd09ed1f4e4276a2da4268633357b7f +9539c5cbba14538b2fe077ecf67694ef240da5249950baaabea0340718b882a966f66d97f08556b08a4320ceb2cc2629 +b4529f25e9b42ae8cf8338d2eface6ba5cd4b4d8da73af502d081388135c654c0b3afb3aa779ffc80b8c4c8f4425dd2b +95be0739c4330619fbe7ee2249c133c91d6c07eab846c18c5d6c85fc21ac5528c5d56dcb0145af68ed0c6a79f68f2ccd +ac0c83ea802227bfc23814a24655c9ff13f729619bcffdb487ccbbf029b8eaee709f8bddb98232ef33cd70e30e45ca47 +b503becb90acc93b1901e939059f93e671900ca52c6f64ae701d11ac891d3a050b505d89324ce267bc43ab8275da6ffe +98e3811b55b1bacb70aa409100abb1b870f67e6d059475d9f278c751b6e1e2e2d6f2e586c81a9fb6597fda06e7923274 +b0b0f61a44053fa6c715dbb0731e35d48dba257d134f851ee1b81fd49a5c51a90ebf5459ec6e489fce25da4f184fbdb1 +b1d2117fe811720bb997c7c93fe9e4260dc50fca8881b245b5e34f724aaf37ed970cdad4e8fcb68e05ac8cf55a274a53 +a10f502051968f14b02895393271776dee7a06db9de14effa0b3471825ba94c3f805302bdddac4d397d08456f620999d +a3dbad2ef060ae0bb7b02eaa4a13594f3f900450faa1854fc09620b01ac94ab896321dfb1157cf2374c27e5718e8026a +b550fdec503195ecb9e079dcdf0cad559d64d3c30818ef369b4907e813e689da316a74ad2422e391b4a8c2a2bef25fc0 +a25ba865e2ac8f28186cea497294c8649a201732ecb4620c4e77b8e887403119910423df061117e5f03fc5ba39042db1 +b3f88174e03fdb443dd6addd01303cf88a4369352520187c739fc5ae6b22fa99629c63c985b4383219dab6acc5f6f532 +97a7503248e31e81b10eb621ba8f5210c537ad11b539c96dfb7cf72b846c7fe81bd7532c5136095652a9618000b7f8d3 +a8bcdc1ce5aa8bfa683a2fc65c1e79de8ff5446695dcb8620f7350c26d2972a23da22889f9e2b1cacb3f688c6a2953dc +8458c111df2a37f5dd91a9bee6c6f4b79f4f161c93fe78075b24a35f9817da8dde71763218d627917a9f1f0c4709c1ed +ac5f061a0541152b876cbc10640f26f1cc923c9d4ae1b6621e4bb3bf2cec59bbf87363a4eb72fb0e5b6d4e1c269b52d5 +a9a25ca87006e8a9203cbb78a93f50a36694aa4aad468b8d80d3feff9194455ca559fcc63838128a0ab75ad78c07c13a +a450b85f5dfffa8b34dfd8bc985f921318efacf8857cf7948f93884ba09fb831482ee90a44224b1a41e859e19b74962f +8ed91e7f92f5c6d7a71708b6132f157ac226ecaf8662af7d7468a4fa25627302efe31e4620ad28719318923e3a59bf82 +ab524165fd4c71b1fd395467a14272bd2b568592deafa039d8492e9ef36c6d3f96927c95c72d410a768dc0b6d1fbbc9b +b662144505aa8432c75ffb8d10318526b6d5777ac7af9ebfad87d9b0866c364f7905a6352743bd8fd79ffd9d5dd4f3e6 +a48f1677550a5cd40663bb3ba8f84caaf8454f332d0ceb1d94dbea52d0412fe69c94997f7749929712fd3995298572f7 +8391cd6e2f6b0c242de1117a612be99776c3dc95cb800b187685ea5bf7e2722275eddb79fd7dfc8be8e389c4524cdf70 +875d3acb9af47833b72900bc0a2448999d638f153c5e97e8a14ec02d0c76f6264353a7e275e1f1a5855daced523d243b +91f1823657d30b59b2f627880a9a9cb530f5aca28a9fd217fe6f2f5133690dfe7ad5a897872e400512db2e788b3f7628 +ad3564332aa56cea84123fc7ca79ea70bb4fef2009fa131cb44e4b15e8613bd11ca1d83b9d9bf456e4b7fee9f2e8b017 +8c530b84001936d5ab366c84c0b105241a26d1fb163669f17c8f2e94776895c2870edf3e1bc8ccd04d5e65531471f695 +932d01fa174fdb0c366f1230cffde2571cc47485f37f23ba5a1825532190cc3b722aeb1f15aed62cf83ccae9403ba713 +88b28c20585aca50d10752e84b901b5c2d58efef5131479fbbe53de7bce2029e1423a494c0298e1497669bd55be97a5d +b914148ca717721144ebb3d3bf3fcea2cd44c30c5f7051b89d8001502f3856fef30ec167174d5b76265b55d70f8716b5 +81d0173821c6ddd2a068d70766d9103d1ee961c475156e0cbd67d54e668a796310474ef698c7ab55abe6f2cf76c14679 +8f28e8d78e2fe7fa66340c53718e0db4b84823c8cfb159c76eac032a62fb53da0a5d7e24ca656cf9d2a890cb2a216542 +8a26360335c73d1ab51cec3166c3cf23b9ea51e44a0ad631b0b0329ef55aaae555420348a544e18d5760969281759b61 +94f326a32ed287545b0515be9e08149eb0a565025074796d72387cc3a237e87979776410d78339e23ef3172ca43b2544 +a785d2961a2fa5e70bffa137858a92c48fe749fee91b02599a252b0cd50d311991a08efd7fa5e96b78d07e6e66ffe746 +94af9030b5ac792dd1ce517eaadcec1482206848bea4e09e55cc7f40fd64d4c2b3e9197027c5636b70d6122c51d2235d +9722869f7d1a3992850fe7be405ec93aa17dc4d35e9e257d2e469f46d2c5a59dbd504056c85ab83d541ad8c13e8bcd54 +b13c4088b61a06e2c03ac9813a75ff1f68ffdfee9df6a8f65095179a475e29cc49119cad2ce05862c3b1ac217f3aace9 +8c64d51774753623666b10ca1b0fe63ae42f82ed6aa26b81dc1d48c86937c5772eb1402624c52a154b86031854e1fb9f +b47e4df18002b7dac3fee945bf9c0503159e1b8aafcce2138818e140753011b6d09ef1b20894e08ba3006b093559061b +93cb5970076522c5a0483693f6a35ffd4ea2aa7aaf3730c4eccd6af6d1bebfc1122fc4c67d53898ae13eb6db647be7e2 +a68873ef80986795ea5ed1a597d1cd99ed978ec25e0abb57fdcc96e89ef0f50aeb779ff46e3dce21dc83ada3157a8498 +8cab67f50949cc8eee6710e27358aea373aae3c92849f8f0b5531c080a6300cdf2c2094fe6fecfef6148de0d28446919 +993e932bcb616dbaa7ad18a4439e0565211d31071ef1b85a0627db74a05d978c60d507695eaeea5c7bd9868a21d06923 +acdadff26e3132d9478a818ef770e9fa0d2b56c6f5f48bd3bd674436ccce9bdfc34db884a73a30c04c5f5e9764cb2218 +a0d3e64c9c71f84c0eef9d7a9cb4fa184224b969db5514d678e93e00f98b41595588ca802643ea225512a4a272f5f534 +91c9140c9e1ba6e330cb08f6b2ce4809cd0d5a0f0516f70032bf30e912b0ed684d07b413b326ab531ee7e5b4668c799b +87bc2ee7a0c21ba8334cd098e35cb703f9af57f35e091b8151b9b63c3a5b0f89bd7701dbd44f644ea475901fa6d9ef08 +9325ccbf64bf5d71b303e31ee85d486298f9802c5e55b2c3d75427097bf8f60fa2ab4fcaffa9b60bf922c3e24fbd4b19 +95d0506e898318f3dc8d28d16dfd9f0038b54798838b3c9be2a2ae3c2bf204eb496166353fc042220b0bd4f6673b9285 +811de529416331fe9c416726d45df9434c29dcd7e949045eb15740f47e97dde8f31489242200e19922cac2a8b7c6fd1f +ade632d04a4c8bbab6ca7df370b2213cb9225023e7973f0e29f4f5e52e8aeaabc65171306bbdd12a67b195dfbb96d48f +88b7f029e079b6ae956042c0ea75d53088c5d0efd750dd018adaeacf46be21bf990897c58578c491f41afd3978d08073 +91f477802de507ffd2be3f4319903119225b277ad24f74eb50f28b66c14d32fae53c7edb8c7590704741af7f7f3e3654 +809838b32bb4f4d0237e98108320d4b079ee16ed80c567e7548bd37e4d7915b1192880f4812ac0e00476d246aec1dbc8 +84183b5fc4a7997a8ae5afedb4d21dce69c480d5966b5cbdafd6dd10d29a9a6377f3b90ce44da0eb8b176ac3af0253bb +8508abbf6d3739a16b9165caf0f95afb3b3ac1b8c38d6d374cf0c91296e2c1809a99772492b539cda184510bce8a0271 +8722054e59bab2062e6419a6e45fc803af77fde912ef2cd23055ad0484963de65a816a2debe1693d93c18218d2b8e81a +8e895f80e485a7c4f56827bf53d34b956281cdc74856c21eb3b51f6288c01cc3d08565a11cc6f3e2604775885490e8c5 +afc92714771b7aa6e60f3aee12efd9c2595e9659797452f0c1e99519f67c8bc3ac567119c1ddfe82a3e961ee9defea9a +818ff0fd9cefd32db87b259e5fa32967201016fc02ef44116cdca3c63ce5e637756f60477a408709928444a8ad69c471 +8251e29af4c61ae806fc5d032347fb332a94d472038149225298389495139ce5678fae739d02dfe53a231598a992e728 +a0ea39574b26643f6f1f48f99f276a8a64b5481989cfb2936f9432a3f8ef5075abfe5c067dc5512143ce8bf933984097 +af67a73911b372bf04e57e21f289fc6c3dfac366c6a01409b6e76fea4769bdb07a6940e52e8d7d3078f235c6d2f632c6 +b5291484ef336024dd2b9b4cf4d3a6b751133a40656d0a0825bcc6d41c21b1c79cb50b0e8f4693f90c29c8f4358641f9 +8bc0d9754d70f2cb9c63f991902165a87c6535a763d5eece43143b5064ae0bcdce7c7a8f398f2c1c29167b2d5a3e6867 +8d7faff53579ec8f6c92f661c399614cc35276971752ce0623270f88be937c414eddcb0997e14724a783905a026c8883 +9310b5f6e675fdf60796f814dbaa5a6e7e9029a61c395761e330d9348a7efab992e4e115c8be3a43d08e90d21290c892 +b5eb4f3eb646038ad2a020f0a42202532d4932e766da82b2c1002bf9c9c2e5336b54c8c0ffcc0e02d19dde2e6a35b6cc +91dabfd30a66710f1f37a891136c9be1e23af4abf8cb751f512a40c022a35f8e0a4fb05b17ec36d4208de02d56f0d53a +b3ded14e82d62ac7a5a036122a62f00ff8308498f3feae57d861babaff5a6628d43f0a0c5fc903f10936bcf4e2758ceb +a88e8348fed2b26acca6784d19ef27c75963450d99651d11a950ea81d4b93acd2c43e0ecce100eaf7e78508263d5baf3 +b1f5bbf7c4756877b87bb42163ac570e08c6667c4528bf68b5976680e19beeff7c5effd17009b0718797077e2955457a +ad2e7b516243f915d4d1415326e98b1a7390ae88897d0b03b66c2d9bd8c3fba283d7e8fe44ed3333296a736454cef6d8 +8f82eae096d5b11f995de6724a9af895f5e1c58d593845ad16ce8fcae8507e0d8e2b2348a0f50a1f66a17fd6fac51a5c +890e4404d0657c6c1ee14e1aac132ecf7a568bb3e04137b85ac0f84f1d333bd94993e8750f88eee033a33fb00f85dcc7 +82ac7d3385e035115f1d39a99fc73e5919de44f5e6424579776d118d711c8120b8e5916372c6f27bed4cc64cac170b6c +85ee16d8901c272cfbbe966e724b7a891c1bd5e68efd5d863043ad8520fc409080af61fd726adc680b3f1186fe0ac8b8 +86dc564c9b545567483b43a38f24c41c6551a49cabeebb58ce86404662a12dbfafd0778d30d26e1c93ce222e547e3898 +a29f5b4522db26d88f5f95f18d459f8feefab02e380c2edb65aa0617a82a3c1a89474727a951cef5f15050bcf7b380fb +a1ce039c8f6cac53352899edb0e3a72c76da143564ad1a44858bd7ee88552e2fe6858d1593bbd74aeee5a6f8034b9b9d +97f10d77983f088286bd7ef3e7fdd8fa275a56bec19919adf33cf939a90c8f2967d2b1b6fc51195cb45ad561202a3ed7 +a25e2772e8c911aaf8712bdac1dd40ee061c84d3d224c466cfaae8e5c99604053f940cde259bd1c3b8b69595781dbfec +b31bb95a0388595149409c48781174c340960d59032ab2b47689911d03c68f77a2273576fbe0c2bf4553e330656058c7 +b8b2e9287ad803fb185a13f0d7456b397d4e3c8ad5078f57f49e8beb2e85f661356a3392dbd7bcf6a900baa5582b86a1 +a3d0893923455eb6e96cc414341cac33d2dbc88fba821ac672708cce131761d85a0e08286663a32828244febfcae6451 +82310cb42f647d99a136014a9f881eb0b9791efd2e01fc1841907ad3fc8a9654d3d1dab6689c3607214b4dc2aca01cee +874022d99c16f60c22de1b094532a0bc6d4de700ad01a31798fac1d5088b9a42ad02bef8a7339af7ed9c0d4f16b186ee +94981369e120265aed40910eebc37eded481e90f4596b8d57c3bec790ab7f929784bd33ddd05b7870aad6c02e869603b +a4f1f50e1e2a73f07095e0dd31cb45154f24968dae967e38962341c1241bcd473102fff1ff668b20c6547e9732d11701 +ae2328f3b0ad79fcda807e69a1b5278145225083f150f67511dafc97e079f860c3392675f1752ae7e864c056e592205b +875d8c971e593ca79552c43d55c8c73b17cd20c81ff2c2fed1eb19b1b91e4a3a83d32df150dbfd5db1092d0aebde1e1f +add2e80aa46aae95da73a11f130f4bda339db028e24c9b11e5316e75ba5e63bc991d2a1da172c7c8e8fee038baae3433 +b46dbe1cb3424002aa7de51e82f600852248e251465c440695d52538d3f36828ff46c90ed77fc1d11534fe3c487df8ef +a5e5045d28b4e83d0055863c30c056628c58d4657e6176fd0536f5933f723d60e851bb726d5bf3c546b8ce4ac4a57ef8 +91fec01e86dd1537e498fff7536ea3ca012058b145f29d9ada49370cd7b7193ac380e116989515df1b94b74a55c45df3 +a7428176d6918cd916a310bdc75483c72de660df48cac4e6e7478eef03205f1827ea55afc0df5d5fa7567d14bbea7fc9 +851d89bef45d9761fe5fdb62972209335193610015e16a675149519f9911373bac0919add226ef118d9f3669cfdf4734 +b74acf5c149d0042021cb2422ea022be4c4f72a77855f42393e71ffd12ebb3eec16bdf16f812159b67b79a9706e7156d +99f35dce64ec99aa595e7894b55ce7b5a435851b396e79036ffb249c28206087db4c85379df666c4d95857db02e21ff9 +b6b9a384f70db9e298415b8ab394ee625dafff04be2886476e59df8d052ca832d11ac68a9b93fba7ab055b7bc36948a4 +898ee4aefa923ffec9e79f2219c7389663eb11eb5b49014e04ed4a336399f6ea1691051d86991f4c46ca65bcd4fdf359 +b0f948217b0d65df7599a0ba4654a5e43c84db477936276e6f11c8981efc6eaf14c90d3650107ed4c09af4cc8ec11137 +aa6286e27ac54f73e63dbf6f41865dd94d24bc0cf732262fcaff67319d162bb43af909f6f8ee27b1971939cfbba08141 +8bca7cdf730cf56c7b2c8a2c4879d61361a6e1dba5a3681a1a16c17a56e168ace0e99cf0d15826a1f5e67e6b8a8a049a +a746d876e8b1ce225fcafca603b099b36504846961526589af977a88c60d31ba2cc56e66a3dec8a77b3f3531bf7524c9 +a11e2e1927e6704cdb8874c75e4f1842cef84d7d43d7a38e339e61dc8ba90e61bbb20dd3c12e0b11d2471d58eed245be +a36395e22bc1d1ba8b0459a235203177737397da5643ce54ded3459d0869ff6d8d89f50c73cb62394bf66a959cde9b90 +8b49f12ba2fdf9aca7e5f81d45c07d47f9302a2655610e7634d1e4bd16048381a45ef2c95a8dd5b0715e4b7cf42273af +91cffa2a17e64eb7f76bccbe4e87280ee1dd244e04a3c9eac12e15d2d04845d876eb24fe2ec6d6d266cce9efb281077f +a6b8afabf65f2dee01788114e33a2f3ce25376fb47a50b74da7c3c25ff1fdc8aa9f41307534abbf48acb6f7466068f69 +8d13db896ccfea403bd6441191995c1a65365cab7d0b97fbe9526da3f45a877bd1f4ef2edef160e8a56838cd1586330e +98c717de9e01bef8842c162a5e757fe8552d53269c84862f4d451e7c656ae6f2ae473767b04290b134773f63be6fdb9d +8c2036ace1920bd13cf018e82848c49eb511fad65fd0ff51f4e4b50cf3bfc294afb63cba682c16f52fb595a98fa84970 +a3520fdff05dbad9e12551b0896922e375f9e5589368bcb2cc303bde252743b74460cb5caf99629325d3620f13adc796 +8d4f83a5bfec05caf5910e0ce538ee9816ee18d0bd44c1d0da2a87715a23cd2733ad4d47552c6dc0eb397687d611dd19 +a7b39a0a6a02823452d376533f39d35029867b3c9a6ad6bca181f18c54132d675613a700f9db2440fb1b4fa13c8bf18a +80bcb114b2544b80f404a200fc36860ed5e1ad31fe551acd4661d09730c452831751baa9b19d7d311600d267086a70bc +90dcce03c6f88fc2b08f2b42771eedde90cc5330fe0336e46c1a7d1b5a6c1641e5fcc4e7b3d5db00bd8afca9ec66ed81 +aec15f40805065c98e2965b1ae12a6c9020cfdb094c2d0549acfc7ea2401a5fb48d3ea7d41133cf37c4e096e7ff53eb9 +80e129b735dba49fa627a615d6c273119acec8e219b2f2c4373a332b5f98d66cbbdd688dfbe72a8f8bfefaccc02c50c1 +a9b596da3bdfe23e6799ece5f7975bf7a1979a75f4f546deeaf8b34dfe3e0d623217cb4cf4ccd504cfa3625b88cd53f1 +abcbbb70b16f6e517c0ab4363ab76b46e4ff58576b5f8340e5c0e8cc0e02621b6e23d742d73b015822a238b17cfd7665 +a046937cc6ea6a2e1adae543353a9fe929c1ae4ad655be1cc051378482cf88b041e28b1e9a577e6ccff2d3570f55e200 +831279437282f315e65a60184ef158f0a3dddc15a648dc552bdc88b3e6fe8288d3cfe9f0031846d81350f5e7874b4b33 +993d7916fa213c6d66e7c4cafafc1eaec9a2a86981f91c31eb8a69c5df076c789cbf498a24c84e0ee77af95b42145026 +823907a3b6719f8d49b3a4b7c181bd9bb29fcf842d7c70660c4f351852a1e197ca46cf5e879b47fa55f616fa2b87ce5e +8d228244e26132b234930ee14c75d88df0943cdb9c276a8faf167d259b7efc1beec2a87c112a6c608ad1600a239e9aae +ab6e55766e5bfb0cf0764ed909a8473ab5047d3388b4f46faeba2d1425c4754c55c6daf6ad4751e634c618b53e549529 +ab0cab6860e55a84c5ad2948a7e0989e2b4b1fd637605634b118361497332df32d9549cb854b2327ca54f2bcb85eed8f +b086b349ae03ef34f4b25a57bcaa5d1b29bd94f9ebf87e22be475adfe475c51a1230c1ebe13506cb72c4186192451658 +8a0b49d8a254ca6d91500f449cbbfbb69bb516c6948ac06808c65595e46773e346f97a5ce0ef7e5a5e0de278af22709c +ac49de11edaaf04302c73c578cc0824bdd165c0d6321be1c421c1950e68e4f3589aa3995448c9699e93c6ebae8803e27 +884f02d841cb5d8f4c60d1402469216b114ab4e93550b5bc1431756e365c4f870a9853449285384a6fa49e12ce6dc654 +b75f3a28fa2cc8d36b49130cb7448a23d73a7311d0185ba803ad55c8219741d451c110f48b786e96c728bc525903a54f +80ae04dbd41f4a35e33f9de413b6ad518af0919e5a30cb0fa1b061b260420780bb674f828d37fd3b52b5a31673cbd803 +b9a8011eb5fcea766907029bf743b45262db3e49d24f84503687e838651ed11cb64c66281e20a0ae9f6aa51acc552263 +90bfdd75e2dc9cf013e22a5d55d2d2b8a754c96103a17524488e01206e67f8b6d52b1be8c4e3d5307d4fe06d0e51f54c +b4af353a19b06203a815ec43e79a88578cc678c46f5a954b85bc5c53b84059dddba731f3d463c23bfd5273885c7c56a4 +aa125e96d4553b64f7140e5453ff5d2330318b69d74d37d283e84c26ad672fa00e3f71e530eb7e28be1e94afb9c4612e +a18e060aee3d49cde2389b10888696436bb7949a79ca7d728be6456a356ea5541b55492b2138da90108bd1ce0e6f5524 +93e55f92bdbccc2de655d14b1526836ea2e52dba65eb3f87823dd458a4cb5079bf22ce6ef625cb6d6bfdd0995ab9a874 +89f5a683526b90c1c3ceebbb8dc824b21cff851ce3531b164f6626e326d98b27d3e1d50982e507d84a99b1e04e86a915 +83d1c38800361633a3f742b1cb2bfc528129496e80232611682ddbe403e92c2ac5373aea0bca93ecb5128b0b2b7a719e +8ecba560ac94905e19ce8d9c7af217bf0a145d8c8bd38e2db82f5e94cc3f2f26f55819176376b51f154b4aab22056059 +a7e2a4a002b60291924850642e703232994acb4cfb90f07c94d1e0ecd2257bb583443283c20fc6017c37e6bfe85b7366 +93ed7316fa50b528f1636fc6507683a672f4f4403e55e94663f91221cc198199595bd02eef43d609f451acc9d9b36a24 +a1220a8ebc5c50ceed76a74bc3b7e0aa77f6884c71b64b67c4310ac29ce5526cb8992d6abc13ef6c8413ce62486a6795 +b2f6eac5c869ad7f4a25161d3347093e2f70e66cd925032747e901189355022fab3038bca4d610d2f68feb7e719c110b +b703fa11a4d511ca01c7462979a94acb40b5d933759199af42670eb48f83df202fa0c943f6ab3b4e1cc54673ea3aab1e +b5422912afbfcb901f84791b04f1ddb3c3fbdc76d961ee2a00c5c320e06d3cc5b5909c3bb805df66c5f10c47a292b13d +ad0934368da823302e1ac08e3ede74b05dfdbfffca203e97ffb0282c226814b65c142e6e15ec1e754518f221f01b30f7 +a1dd302a02e37df15bf2f1147efe0e3c06933a5a767d2d030e1132f5c3ce6b98e216b6145eb39e1e2f74e76a83165b8d +a346aab07564432f802ae44738049a36f7ca4056df2d8f110dbe7fef4a3e047684dea609b2d03dc6bf917c9c2a47608f +b96c5f682a5f5d02123568e50f5d0d186e4b2c4c9b956ec7aabac1b3e4a766d78d19bd111adb5176b898e916e49be2aa +8a96676d56876fc85538db2e806e1cba20fd01aeb9fa3cb43ca6ca94a2c102639f65660db330e5d74a029bb72d6a0b39 +ab0048336bd5c3def1a4064eadd49e66480c1f2abb4df46e03afbd8a3342c2c9d74ee35d79f08f4768c1646681440984 +888427bdf76caec90814c57ee1c3210a97d107dd88f7256f14f883ad0f392334b82be11e36dd8bfec2b37935177c7831 +b622b282becf0094a1916fa658429a5292ba30fb48a4c8066ce1ddcefb71037948262a01c95bab6929ed3a76ba5db9fe +b5b9e005c1f456b6a368a3097634fb455723abe95433a186e8278dceb79d4ca2fbe21f8002e80027b3c531e5bf494629 +a3c6707117a1e48697ed41062897f55d8119403eea6c2ee88f60180f6526f45172664bfee96bf61d6ec0b7fbae6aa058 +b02a9567386a4fbbdb772d8a27057b0be210447348efe6feb935ceec81f361ed2c0c211e54787dc617cdffed6b4a6652 +a9b8364e40ef15c3b5902e5534998997b8493064fa2bea99600def58279bb0f64574c09ba11e9f6f669a8354dd79dc85 +9998a2e553a9aa9a206518fae2bc8b90329ee59ab23005b10972712389f2ec0ee746033c733092ffe43d73d33abbb8ef +843a4b34d9039bf79df96d79f2d15e8d755affb4d83d61872daf540b68c0a3888cf8fc00d5b8b247b38524bcb3b5a856 +84f7128920c1b0bb40eee95701d30e6fc3a83b7bb3709f16d97e72acbb6057004ee7ac8e8f575936ca9dcb7866ab45f7 +918d3e2222e10e05edb34728162a899ad5ada0aaa491aeb7c81572a9c0d506e31d5390e1803a91ff3bd8e2bb15d47f31 +9442d18e2489613a7d47bb1cb803c8d6f3259d088cd079460976d87f7905ee07dea8f371b2537f6e1d792d36d7e42723 +b491976970fe091995b2ed86d629126523ccf3e9daf8145302faca71b5a71a5da92e0e05b62d7139d3efac5c4e367584 +aa628006235dc77c14cef4c04a308d66b07ac92d377df3de1a2e6ecfe3144f2219ad6d7795e671e1cb37a3641910b940 +99d386adaea5d4981d7306feecac9a555b74ffdc218c907c5aa7ac04abaead0ec2a8237300d42a3fbc464673e417ceed +8f78e8b1556f9d739648ea3cab9606f8328b52877fe72f9305545a73b74d49884044ba9c1f1c6db7d9b7c7b7c661caba +8fb357ae49932d0babdf74fc7aa7464a65d3b6a2b3acf4f550b99601d3c0215900cfd67f2b6651ef94cfc323bac79fae +9906f2fa25c0290775aa001fb6198113d53804262454ae8b83ef371b5271bde189c0460a645829cb6c59f9ee3a55ce4d +8f4379b3ebb50e052325b27655ca6a82e6f00b87bf0d2b680d205dd2c7afdc9ff32a9047ae71a1cdf0d0ce6b9474d878 +a85534e88c2bd43c043792eaa75e50914b21741a566635e0e107ae857aed0412035f7576cf04488ade16fd3f35fdbb87 +b4ce93199966d3c23251ca7f28ec5af7efea1763d376b0385352ffb2e0a462ef95c69940950278cf0e3dafd638b7bd36 +b10cb3d0317dd570aa73129f4acf63c256816f007607c19b423fb42f65133ce21f2f517e0afb41a5378cccf893ae14d0 +a9b231c9f739f7f914e5d943ed9bff7eba9e2c333fbd7c34eb1648a362ee01a01af6e2f7c35c9fe962b11152cddf35de +99ff6a899e156732937fb81c0cced80ae13d2d44c40ba99ac183aa246103b31ec084594b1b7feb96da58f4be2dd5c0ed +8748d15d18b75ff2596f50d6a9c4ce82f61ecbcee123a6ceae0e43cab3012a29b6f83cf67b48c22f6f9d757c6caf76b2 +b88ab05e4248b7fb634cf640a4e6a945d13e331237410f7217d3d17e3e384ddd48897e7a91e4516f1b9cbd30f35f238b +8d826deaeeb84a3b2d2c04c2300ca592501f992810582d6ae993e0d52f6283a839dba66c6c72278cff5871802b71173b +b36fed027c2f05a5ef625ca00b0364b930901e9e4420975b111858d0941f60e205546474bb25d6bfa6928d37305ae95f +af2fcfc6b87967567e8b8a13a4ed914478185705724e56ce68fb2df6d1576a0cf34a61e880997a0d35dc2c3276ff7501 +ac351b919cd1fbf106feb8af2c67692bfcddc84762d18cea681cfa7470a5644839caace27efee5f38c87d3df306f4211 +8d6665fb1d4d8d1fa23bd9b8a86e043b8555663519caac214d1e3e3effbc6bee7f2bcf21e645f77de0ced279d69a8a8b +a9fc1c2061756b2a1a169c1b149f212ff7f0d2488acd1c5a0197eba793cffa593fc6d1d1b40718aa75ca3ec77eff10e1 +aff64f0fa009c7a6cf0b8d7a22ddb2c8170c3cb3eec082e60d5aadb00b0040443be8936d728d99581e33c22178c41c87 +82e0b181adc5e3b1c87ff8598447260e839d53debfae941ebea38265575546c3a74a14b4325a030833a62ff6c52d9365 +b7ad43cbb22f6f892c2a1548a41dc120ab1f4e1b8dea0cb6272dd9cb02054c542ecabc582f7e16de709d48f5166cae86 +985e0c61094281532c4afb788ecb2dfcba998e974b5d4257a22040a161883908cdd068fe80f8eb49b8953cfd11acf43a +ae46895c6d67ea6d469b6c9c07b9e5d295d9ae73b22e30da4ba2c973ba83a130d7eef39717ec9d0f36e81d56bf742671 +8600177ea1f7e7ef90514b38b219a37dedfc39cb83297e4c7a5b479817ef56479d48cf6314820960c751183f6edf8b0e +b9208ec1c1d7a1e99b59c62d3e4e61dfb706b0e940d09d3abfc3454c19749083260614d89cfd7e822596c3cdbcc6bb95 +a1e94042c796c2b48bc724352d2e9f3a22291d9a34705993357ddb6adabd76da6fc25dac200a8cb0b5bbd99ecddb7af6 +b29c3adedd0bcad8a930625bc4dfdc3552a9afd5ca6dd9c0d758f978068c7982b50b711aa0eb5b97f2b84ee784637835 +af0632a238bb1f413c7ea8e9b4c3d68f2827bd2e38cd56024391fba6446ac5d19a780d0cfd4a78fe497d537b766a591a +aaf6e7f7d54f8ef5e2e45dd59774ecbeecf8683aa70483b2a75be6a6071b5981bbaf1627512a65d212817acdfab2e428 +8c751496065da2e927cf492aa5ca9013b24f861d5e6c24b30bbf52ec5aaf1905f40f9a28175faef283dd4ed4f2182a09 +8952377d8e80a85cf67d6b45499f3bad5fd452ea7bcd99efc1b066c4720d8e5bff1214cea90fd1f972a7f0baac3d29be +a1946ee543d1a6e21f380453be4d446e4130950c5fc3d075794eb8260f6f52d0a795c1ff91d028a648dc1ce7d9ab6b47 +89f3fefe37af31e0c17533d2ca1ce0884cc1dc97c15cbfab9c331b8debd94781c9396abef4bb2f163d09277a08d6adf0 +a2753f1e6e1a154fb117100a5bd9052137add85961f8158830ac20541ab12227d83887d10acf7fd36dcaf7c2596d8d23 +814955b4198933ee11c3883863b06ff98c7eceb21fc3e09df5f916107827ccf3323141983e74b025f46ae00284c9513b +8cc5c6bb429073bfef47cae7b3bfccb0ffa076514d91a1862c6bda4d581e0df87db53cc6c130bf8a7826304960f5a34e +909f22c1f1cdc87f7be7439c831a73484a49acbf8f23d47087d7cf867c64ef61da3bde85dc57d705682b4c3fc710d36e +8048fee7f276fcd504aed91284f28e73693615e0eb3858fa44bcf79d7285a9001c373b3ef71d9a3054817ba293ebe28c +94400e5cf5d2700ca608c5fe35ce14623f71cc24959f2bc27ca3684092850f76b67fb1f07ca9e5b2ca3062cf8ad17bd4 +81c2ae7d4d1b17f8b6de6a0430acc0d58260993980fe48dc2129c4948269cdc74f9dbfbf9c26b19360823fd913083d48 +8c41fe765128e63f6889d6a979f6a4342300327c8b245a8cfe3ecfbcac1e09c3da30e2a1045b24b78efc6d6d50c8c6ac +a5dd4ae51ae48c8be4b218c312ade226cffce671cf121cb77810f6c0990768d6dd767badecb5c69921d5574d5e8433d3 +b7642e325f4ba97ae2a39c1c9d97b35aafd49d53dba36aed3f3cb0ca816480b3394079f46a48252d46596559c90f4d58 +ae87375b40f35519e7bd4b1b2f73cd0b329b0c2cb9d616629342a71c6c304338445eda069b78ea0fbe44087f3de91e09 +b08918cb6f736855e11d3daca1ddfbdd61c9589b203b5493143227bf48e2c77c2e8c94b0d1aa2fab2226e0eae83f2681 +ac36b84a4ac2ebd4d6591923a449c564e3be8a664c46092c09e875c2998eba16b5d32bfd0882fd3851762868e669f0b1 +a44800a3bb192066fa17a3f29029a23697240467053b5aa49b9839fb9b9b8b12bcdcbfc557f024b61f4f51a9aacdefcb +9064c688fec23441a274cdf2075e5a449caf5c7363cc5e8a5dc9747183d2e00a0c69f2e6b3f6a7057079c46014c93b3b +aa367b021469af9f5b764a79bb3afbe2d87fe1e51862221672d1a66f954b165778b7c27a705e0f93841fab4c8468344d +a1a8bfc593d4ab71f91640bc824de5c1380ab2591cfdafcbc78a14b32de3c0e15f9d1b461d85c504baa3d4232c16bb53 +97df48da1799430f528184d30b6baa90c2a2f88f34cdfb342d715339c5ebd6d019aa693cea7c4993daafc9849063a3aa +abd923831fbb427e06e0dd335253178a9e5791395c84d0ab1433c07c53c1209161097e9582fb8736f8a60bde62d8693e +84cd1a43f1a438b43dc60ffc775f646937c4f6871438163905a3cebf1115f814ccd38a6ccb134130bff226306e412f32 +91426065996b0743c5f689eb3ca68a9f7b9e4d01f6c5a2652b57fa9a03d8dc7cd4bdbdab0ca5a891fee1e97a7f00cf02 +a4bee50249db3df7fd75162b28f04e57c678ba142ce4d3def2bc17bcb29e4670284a45f218dad3969af466c62a903757 +83141ebcc94d4681404e8b67a12a46374fded6df92b506aff3490d875919631408b369823a08b271d006d5b93136f317 +a0ea1c8883d58d5a784da3d8c8a880061adea796d7505c1f903d07c287c5467f71e4563fc0faafbc15b5a5538b0a7559 +89d9d480574f201a87269d26fb114278ed2c446328df431dc3556e3500e80e4cd01fcac196a2459d8646361ebda840df +8bf302978973632dd464bec819bdb91304712a3ec859be071e662040620422c6e75eba6f864f764cffa2799272efec39 +922f666bc0fd58b6d7d815c0ae4f66d193d32fc8382c631037f59eeaeae9a8ca6c72d08e72944cf9e800b8d639094e77 +81ad8714f491cdff7fe4399f2eb20e32650cff2999dd45b9b3d996d54a4aba24cc6c451212e78c9e5550368a1a38fb3f +b58fcf4659d73edb73175bd9139d18254e94c3e32031b5d4b026f2ed37aa19dca17ec2eb54c14340231615277a9d347e +b365ac9c2bfe409b710928c646ea2fb15b28557e0f089d39878e365589b9d1c34baf5566d20bb28b33bb60fa133f6eff +8fcae1d75b53ab470be805f39630d204853ca1629a14158bac2f52632277d77458dec204ff84b7b2d77e641c2045be65 +a03efa6bebe84f4f958a56e2d76b5ba4f95dd9ed7eb479edc7cc5e646c8d4792e5b0dfc66cc86aa4b4afe2f7a4850760 +af1c823930a3638975fb0cc5c59651771b2719119c3cd08404fbd4ce77a74d708cefbe3c56ea08c48f5f10e6907f338f +8260c8299b17898032c761c325ac9cabb4c5b7e735de81eacf244f647a45fb385012f4f8df743128888c29aefcaaad16 +ab2f37a573c82e96a8d46198691cd694dfa860615625f477e41f91b879bc58a745784fccd8ffa13065834ffd150d881d +986c746c9b4249352d8e5c629e8d7d05e716b3c7aab5e529ca969dd1e984a14b5be41528baef4c85d2369a42d7209216 +b25e32da1a8adddf2a6080725818b75bc67240728ad1853d90738485d8924ea1e202df0a3034a60ffae6f965ec55cf63 +a266e627afcebcefea6b6b44cbc50f5c508f7187e87d047b0450871c2a030042c9e376f3ede0afcf9d1952f089582f71 +86c3bbca4c0300606071c0a80dbdec21ce1dd4d8d4309648151c420854032dff1241a1677d1cd5de4e4de4385efda986 +b9a21a1fe2d1f3273a8e4a9185abf2ff86448cc98bfa435e3d68306a2b8b4a6a3ea33a155be3cb62a2170a86f77679a5 +b117b1ea381adce87d8b342cba3a15d492ff2d644afa28f22424cb9cbc820d4f7693dfc1a4d1b3697046c300e1c9b4c8 +9004c425a2e68870d6c69b658c344e3aa3a86a8914ee08d72b2f95c2e2d8a4c7bb0c6e7e271460c0e637cec11117bf8e +86a18aa4783b9ebd9131580c8b17994825f27f4ac427b0929a1e0236907732a1c8139e98112c605488ee95f48bbefbfc +84042243b955286482ab6f0b5df4c2d73571ada00716d2f737ca05a0d2e88c6349e8ee9e67934cfee4a1775dbf7f4800 +92c2153a4733a62e4e1d5b60369f3c26777c7d01cd3c8679212660d572bd3bac9b8a8a64e1f10f7dbf5eaa7579c4e423 +918454b6bb8e44a2afa144695ba8d48ae08d0cdfef4ad078f67709eddf3bb31191e8b006f04e82ea45a54715ef4d5817 +acf0b54f6bf34cf6ed6c2b39cf43194a40d68de6bcf1e4b82c34c15a1343e9ac3737885e1a30b78d01fa3a5125463db8 +a7d60dbe4b6a7b054f7afe9ee5cbbfeca0d05dc619e6041fa2296b549322529faddb8a11e949562309aecefb842ac380 +91ffb53e6d7e5f11159eaf13e783d6dbdfdb1698ed1e6dbf3413c6ea23492bbb9e0932230a9e2caac8fe899a17682795 +b6e8d7be5076ee3565d5765a710c5ecf17921dd3cf555c375d01e958a365ae087d4a88da492a5fb81838b7b92bf01143 +a8c6b763de2d4b2ed42102ef64eccfef31e2fb2a8a2776241c82912fa50fc9f77f175b6d109a97ede331307c016a4b1a +99839f86cb700c297c58bc33e28d46b92931961548deac29ba8df91d3e11721b10ea956c8e16984f9e4acf1298a79b37 +8c2e2c338f25ea5c25756b7131cde0d9a2b35abf5d90781180a00fe4b8e64e62590dc63fe10a57fba3a31c76d784eb01 +9687d7df2f41319ca5469d91978fed0565a5f11f829ebadaa83db92b221755f76c6eacd7700735e75c91e257087512e3 +8795fdfb7ff8439c58b9bf58ed53873d2780d3939b902b9ddaaa4c99447224ced9206c3039a23c2c44bcc461e2bb637f +a803697b744d2d087f4e2307218d48fa88620cf25529db9ce71e2e3bbcc65bac5e8bb9be04777ef7bfb5ed1a5b8e6170 +80f3d3efbbb9346ddd413f0a8e36b269eb5d7ff6809d5525ff9a47c4bcab2c01b70018b117f6fe05253775612ff70c6b +9050e0e45bcc83930d4c505af35e5e4d7ca01cd8681cba92eb55821aececcebe32bb692ebe1a4daac4e7472975671067 +8d206812aac42742dbaf233e0c080b3d1b30943b54b60283515da005de05ea5caa90f91fedcfcba72e922f64d7040189 +a2d44faaeb2eff7915c83f32b13ca6f31a6847b1c1ce114ea240bac3595eded89f09b2313b7915ad882292e2b586d5b4 +961776c8576030c39f214ea6e0a3e8b3d32f023d2600958c098c95c8a4e374deeb2b9dc522adfbd6bda5949bdc09e2a2 +993fa7d8447407af0fbcd9e6d77f815fa5233ab00674efbcf74a1f51c37481445ae291cc7b76db7c178f9cb0e570e0fc +abd5b1c78e05f9d7c8cc99bdaef8b0b6a57f2daf0f02bf492bec48ea4a27a8f1e38b5854da96efff11973326ff980f92 +8f15af4764bc275e6ccb892b3a4362cacb4e175b1526a9a99944e692fe6ccb1b4fc19abf312bb2a089cb1f344d91a779 +a09b27ccd71855512aba1d0c30a79ffbe7f6707a55978f3ced50e674b511a79a446dbc6d7946add421ce111135a460af +94b2f98ce86a9271fbd4153e1fc37de48421fe3490fb3840c00f2d5a4d0ba8810c6a32880b002f6374b59e0a7952518b +8650ac644f93bbcb88a6a0f49fee2663297fd4bc6fd47b6a89b9d8038d32370438ab3a4775ec9b58cb10aea8a95ef7b6 +95e5c2f2e84eed88c6980bbba5a1c0bb375d5a628bff006f7516d45bb7d723da676add4fdd45956f312e7bab0f052644 +b3278a3fa377ac93af7cfc9453f8cb594aae04269bbc99d2e0e45472ff4b6a2f97a26c4c57bf675b9d86f5e77a5d55d1 +b4bcbe6eb666a206e2ea2f877912c1d3b5bdbd08a989fc4490eb06013e1a69ad1ba08bcdac048bf29192312be399077b +a76d70b78c99fffcbf9bb9886eab40f1ea4f99a309710b660b64cbf86057cbcb644d243f6e341711bb7ef0fedf0435a7 +b2093c1ee945dca7ac76ad5aed08eae23af31dd5a77c903fd7b6f051f4ab84425d33a03c3d45bf2907bc93c02d1f3ad8 +904b1f7534e053a265b22d20be859912b9c9ccb303af9a8d6f1d8f6ccdc5c53eb4a45a1762b880d8444d9be0cd55e7f9 +8f664a965d65bc730c9ef1ec7467be984d4b8eb46bd9b0d64e38e48f94e6e55dda19aeac82cbcf4e1473440e64c4ca18 +8bcee65c4cc7a7799353d07b114c718a2aae0cd10a3f22b7eead5185d159dafd64852cb63924bf87627d176228878bce +8c78f2e3675096fef7ebaa898d2615cd50d39ca3d8f02b9bdfb07e67da648ae4be3da64838dffc5935fd72962c4b96c7 +8c40afd3701629421fec1df1aac4e849384ef2e80472c0e28d36cb1327acdf2826f99b357f3d7afdbc58a6347fc40b3c +a197813b1c65a8ea5754ef782522a57d63433ef752215ecda1e7da76b0412ee619f58d904abd2e07e0c097048b6ae1dd +a670542629e4333884ad7410f9ea3bd6f988df4a8f8a424ca74b9add2312586900cf9ae8bd50411f9146e82626b4af56 +a19875cc07ab84e569d98b8b67fb1dbbdfb59093c7b748fae008c8904a6fd931a63ca8d03ab5fea9bc8d263568125a9b +b57e7f68e4eb1bd04aafa917b1db1bdab759a02aa8a9cdb1cba34ba8852b5890f655645c9b4e15d5f19bf37e9f2ffe9f +8abe4e2a4f6462b6c64b3f10e45db2a53c2b0d3c5d5443d3f00a453e193df771eda635b098b6c8604ace3557514027af +8459e4fb378189b22b870a6ef20183deb816cefbf66eca1dc7e86d36a2e011537db893729f500dc154f14ce24633ba47 +930851df4bc7913c0d8c0f7bd3b071a83668987ed7c397d3d042fdc0d9765945a39a3bae83da9c88cb6b686ed8aeeb26 +8078c9e5cd05e1a8c932f8a1d835f61a248b6e7133fcbb3de406bf4ffc0e584f6f9f95062740ba6008d98348886cf76b +addff62bb29430983fe578e3709b0949cdc0d47a13a29bc3f50371a2cb5c822ce53e2448cfaa01bcb6e0aa850d5a380e +9433add687b5a1e12066721789b1db2edf9b6558c3bdc0f452ba33b1da67426abe326e9a34d207bfb1c491c18811bde1 +822beda3389963428cccc4a2918fa9a8a51cf0919640350293af70821967108cded5997adae86b33cb917780b097f1ca +a7a9f52bda45e4148ed56dd176df7bd672e9b5ed18888ccdb405f47920fdb0844355f8565cefb17010b38324edd8315f +b35c3a872e18e607b2555c51f9696a17fa18da1f924d503b163b4ec9fe22ed0c110925275cb6c93ce2d013e88f173d6a +adf34b002b2b26ab84fc1bf94e05bd8616a1d06664799ab149363c56a6e0c807fdc473327d25632416e952ea327fcd95 +ae4a6b9d22a4a3183fac29e2551e1124a8ce4a561a9a2afa9b23032b58d444e6155bb2b48f85c7b6d70393274e230db7 +a2ea3be4fc17e9b7ce3110284038d46a09e88a247b6971167a7878d9dcf36925d613c382b400cfa4f37a3ebea3699897 +8e5863786b641ce3140fbfe37124d7ad3925472e924f814ebfc45959aaf3f61dc554a597610b5defaecc85b59a99b50f +aefde3193d0f700d0f515ab2aaa43e2ef1d7831c4f7859f48e52693d57f97fa9e520090f3ed700e1c966f4b76048e57f +841a50f772956622798e5cd208dc7534d4e39eddee30d8ce133383d66e5f267e389254a0cdae01b770ecd0a9ca421929 +8fbc2bfd28238c7d47d4c03b1b910946c0d94274a199575e5b23242619b1de3497784e646a92aa03e3e24123ae4fcaba +926999579c8eec1cc47d7330112586bdca20b4149c8b2d066f527c8b9f609e61ce27feb69db67eea382649c6905efcf9 +b09f31f305efcc65589adf5d3690a76cf339efd67cd43a4e3ced7b839507466e4be72dd91f04e89e4bbef629d46e68c0 +b917361f6b95f759642638e0b1d2b3a29c3bdef0b94faa30de562e6078c7e2d25976159df3edbacbf43614635c2640b4 +8e7e8a1253bbda0e134d62bfe003a2669d471b47bd2b5cde0ff60d385d8e62279d54022f5ac12053b1e2d3aaa6910b4c +b69671a3c64e0a99d90b0ed108ce1912ff8ed983e4bddd75a370e9babde25ee1f5efb59ec707edddd46793207a8b1fe7 +910b2f4ebd37b7ae94108922b233d0920b4aba0bd94202c70f1314418b548d11d8e9caa91f2cd95aff51b9432d122b7f +82f645c90dfb52d195c1020346287c43a80233d3538954548604d09fbab7421241cde8593dbc4acc4986e0ea39a27dd9 +8fee895f0a140d88104ce442fed3966f58ff9d275e7373483f6b4249d64a25fb5374bbdc6bce6b5ab0270c2847066f83 +84f5bd7aab27b2509397aeb86510dd5ac0a53f2c8f73799bf720f2f87a52277f8d6b0f77f17bc80739c6a7119b7eb062 +9903ceced81099d7e146e661bcf01cbaccab5ba54366b85e2177f07e2d8621e19d9c9c3eee14b9266de6b3f9b6ea75ae +b9c16ea2a07afa32dd6c7c06df0dec39bca2067a9339e45475c98917f47e2320f6f235da353fd5e15b477de97ddc68dd +9820a9bbf8b826bec61ebf886de2c4f404c1ebdc8bab82ee1fea816d9de29127ce1852448ff717a3fe8bbfe9e92012e5 +817224d9359f5da6f2158c2c7bf9165501424f063e67ba9859a07ab72ee2ee62eb00ca6da821cfa19065c3282ca72c74 +94b95c465e6cb00da400558a3c60cfec4b79b27e602ca67cbc91aead08de4b6872d8ea096b0dc06dca4525c8992b8547 +a2b539a5bccd43fa347ba9c15f249b417997c6a38c63517ca38394976baa08e20be384a360969ff54e7e721db536b3e5 +96caf707e34f62811ee8d32ccf28d8d6ec579bc33e424d0473529af5315c456fd026aa910c1fed70c91982d51df7d3ca +8a77b73e890b644c6a142bdbac59b22d6a676f3b63ddafb52d914bb9d395b8bf5aedcbcc90429337df431ebd758a07a6 +8857830a7351025617a08bc44caec28d2fae07ebf5ffc9f01d979ce2a53839a670e61ae2783e138313929129790a51a1 +aa3e420321ed6f0aa326d28d1a10f13facec6f605b6218a6eb9cbc074801f3467bf013a456d1415a5536f12599efa3d3 +824aed0951957b00ea2f3d423e30328a3527bf6714cf9abbae84cf27e58e5c35452ba89ccc011de7c68c75d6e021d8f1 +a2e87cc06bf202e953fb1081933d8b4445527dde20e38ed1a4f440144fd8fa464a2b73e068b140562e9045e0f4bd3144 +ae3b8f06ad97d7ae3a5e5ca839efff3e4824dc238c0c03fc1a8d2fc8aa546cdfd165b784a31bb4dec7c77e9305b99a4b +b30c3e12395b1fb8b776f3ec9f87c70e35763a7b2ddc68f0f60a4982a84017f27c891a98561c830038deb033698ed7fc +874e507757cd1177d0dff0b0c62ce90130324442a33da3b2c8ee09dbca5d543e3ecfe707e9f1361e7c7db641c72794bb +b53012dd10b5e7460b57c092eaa06d6502720df9edbbe3e3f61a9998a272bf5baaac4a5a732ad4efe35d6fac6feca744 +85e6509d711515534d394e6cacbed6c81da710074d16ef3f4950bf2f578d662a494d835674f79c4d6315bced4defc5f0 +b6132b2a34b0905dcadc6119fd215419a7971fe545e52f48b768006944b4a9d7db1a74b149e2951ea48c083b752d0804 +989867da6415036d19b4bacc926ce6f4df7a556f50a1ba5f3c48eea9cefbb1c09da81481c8009331ee83f0859185e164 +960a6c36542876174d3fbc1505413e29f053ed87b8d38fef3af180491c7eff25200b45dd5fe5d4d8e63c7e8c9c00f4c8 +9040b59bd739d9cc2e8f6e894683429e4e876a8106238689ff4c22770ae5fdae1f32d962b30301fa0634ee163b524f35 +af3fcd0a45fe9e8fe256dc7eab242ef7f582dd832d147444483c62787ac820fafc6ca55d639a73f76bfa5e7f5462ab8f +b934c799d0736953a73d91e761767fdb78454355c4b15c680ce08accb57ccf941b13a1236980001f9e6195801cffd692 +8871e8e741157c2c326b22cf09551e78da3c1ec0fc0543136f581f1550f8bab03b0a7b80525c1e99812cdbf3a9698f96 +a8a977f51473a91d178ee8cfa45ffef8d6fd93ab1d6e428f96a3c79816d9c6a93cd70f94d4deda0125fd6816e30f3bea +a7688b3b0a4fc1dd16e8ba6dc758d3cfe1b7cf401c31739484c7fa253cce0967df1b290769bcefc9d23d3e0cb19e6218 +8ae84322662a57c6d729e6ff9d2737698cc2da2daeb1f39e506618750ed23442a6740955f299e4a15dda6db3e534d2c6 +a04a961cdccfa4b7ef83ced17ab221d6a043b2c718a0d6cc8e6f798507a31f10bf70361f70a049bc8058303fa7f96864 +b463e39732a7d9daec8a456fb58e54b30a6e160aa522a18b9a9e836488cce3342bcbb2e1deab0f5e6ec0a8796d77197d +b1434a11c6750f14018a2d3bcf94390e2948f4f187e93bb22070ca3e5393d339dc328cbfc3e48815f51929465ffe7d81 +84ff81d73f3828340623d7e3345553610aa22a5432217ef0ebd193cbf4a24234b190c65ca0873c22d10ea7b63bd1fbed +b6fe2723f0c47757932c2ddde7a4f8434f665612f7b87b4009c2635d56b6e16b200859a8ade49276de0ef27a2b6c970a +9742884ed7cd52b4a4a068a43d3faa02551a424136c85a9313f7cb58ea54c04aa83b0728fd741d1fe39621e931e88f8f +b7d2d65ea4d1ad07a5dee39e40d6c03a61264a56b1585b4d76fc5b2a68d80a93a42a0181d432528582bf08d144c2d6a9 +88c0f66bada89f8a43e5a6ead2915088173d106c76f724f4a97b0f6758aed6ae5c37c373c6b92cdd4aea8f6261f3a374 +81f9c43582cb42db3900747eb49ec94edb2284999a499d1527f03315fd330e5a509afa3bff659853570e9886aab5b28b +821f9d27d6beb416abf9aa5c79afb65a50ed276dbda6060103bc808bcd34426b82da5f23e38e88a55e172f5c294b4d40 +8ba307b9e7cb63a6c4f3851b321aebfdb6af34a5a4c3bd949ff7d96603e59b27ff4dc4970715d35f7758260ff942c9e9 +b142eb6c5f846de33227d0bda61d445a7c33c98f0a8365fe6ab4c1fabdc130849be597ef734305894a424ea715372d08 +a732730ae4512e86a741c8e4c87fee8a05ee840fec0e23b2e037d58dba8dde8d10a9bc5191d34d00598941becbbe467f +adce6f7c30fd221f6b10a0413cc76435c4bb36c2d60bca821e5c67409fe9dbb2f4c36ef85eb3d734695e4be4827e9fd3 +a74f00e0f9b23aff7b2527ce69852f8906dab9d6abe62ecd497498ab21e57542e12af9918d4fd610bb09e10b0929c510 +a593b6b0ef26448ce4eb3ab07e84238fc020b3cb10d542ff4b16d4e2be1bcde3797e45c9cf753b8dc3b0ffdb63984232 +aed3913afccf1aa1ac0eb4980eb8426d0baccebd836d44651fd72af00d09fac488a870223c42aca3ceb39752070405ae +b2c44c66a5ea7fde626548ba4cef8c8710191343d3dadfd3bb653ce715c0e03056a5303a581d47dde66e70ea5a2d2779 +8e5029b2ccf5128a12327b5103f7532db599846e422531869560ceaff392236434d87159f597937dbf4054f810c114f4 +82beed1a2c4477e5eb39fc5b0e773b30cfec77ef2b1bf17eadaf60eb35b6d0dd9d8cf06315c48d3546badb3f21cd0cca +90077bd6cc0e4be5fff08e5d07a5a158d36cebd1d1363125bc4fae0866ffe825b26f933d4ee5427ba5cd0c33c19a7b06 +a7ec0d8f079970e8e34f0ef3a53d3e0e45428ddcef9cc776ead5e542ef06f3c86981644f61c5a637e4faf001fb8c6b3e +ae6d4add6d1a6f90b22792bc9d40723ee6850c27d0b97eefafd5b7fd98e424aa97868b5287cc41b4fbd7023bca6a322c +831aa917533d077da07c01417feaa1408846363ba2b8d22c6116bb858a95801547dd88b7d7fa1d2e3f0a02bdeb2e103d +96511b860b07c8a5ed773f36d4aa9d02fb5e7882753bf56303595bcb57e37ccc60288887eb83bef08c657ec261a021a2 +921d2a3e7e9790f74068623de327443666b634c8443aba80120a45bba450df920b2374d96df1ce3fb1b06dd06f8cf6e3 +aa74451d51fe82b4581ead8e506ec6cd881010f7e7dd51fc388eb9a557db5d3c6721f81c151d08ebd9c2591689fbc13e +a972bfbcf4033d5742d08716c927c442119bdae336bf5dff914523b285ccf31953da2733759aacaa246a9af9f698342c +ad1fcd0cae0e76840194ce4150cb8a56ebed728ec9272035f52a799d480dfc85840a4d52d994a18b6edb31e79be6e8ad +a2c69fe1d36f235215432dad48d75887a44c99dfa0d78149acc74087da215a44bdb5f04e6eef88ff7eff80a5a7decc77 +a94ab2af2b6ee1bc6e0d4e689ca45380d9fbd3c5a65b9bd249d266a4d4c07bf5d5f7ef2ae6000623aee64027892bf8fe +881ec1fc514e926cdc66480ac59e139148ff8a2a7895a49f0dff45910c90cdda97b66441a25f357d6dd2471cddd99bb3 +884e6d3b894a914c8cef946a76d5a0c8351843b2bffa2d1e56c6b5b99c84104381dd1320c451d551c0b966f4086e60f9 +817c6c10ce2677b9fc5223500322e2b880583254d0bb0d247d728f8716f5e05c9ff39f135854342a1afecd9fbdcf7c46 +aaf4a9cb686a14619aa1fc1ac285dd3843ac3dd99f2b2331c711ec87b03491c02f49101046f3c5c538dc9f8dba2a0ac2 +97ecea5ce53ca720b5d845227ae61d70269a2f53540089305c86af35f0898bfd57356e74a8a5e083fa6e1ea70080bd31 +a22d811e1a20a75feac0157c418a4bfe745ccb5d29466ffa854dca03e395b6c3504a734341746b2846d76583a780b32e +940cbaa0d2b2db94ae96b6b9cf2deefbfd059e3e5745de9aec4a25f0991b9721e5cd37ef71c631575d1a0c280b01cd5b +ae33cb4951191258a11044682de861bf8d92d90ce751b354932dd9f3913f542b6a0f8a4dc228b3cd9244ac32c4582832 +a580df5e58c4274fe0f52ac2da1837e32f5c9db92be16c170187db4c358f43e5cfdda7c5911dcc79d77a5764e32325f5 +81798178cb9d8affa424f8d3be67576ba94d108a28ccc01d330c51d5a63ca45bb8ca63a2f569b5c5fe1303cecd2d777f +89975b91b94c25c9c3660e4af4047a8bacf964783010820dbc91ff8281509379cb3b24c25080d5a01174dd9a049118d5 +a7327fcb3710ed3273b048650bde40a32732ef40a7e58cf7f2f400979c177944c8bc54117ba6c80d5d4260801dddab79 +92b475dc8cb5be4b90c482f122a51bcb3b6c70593817e7e2459c28ea54a7845c50272af38119406eaadb9bcb993368d0 +9645173e9ecefc4f2eae8363504f7c0b81d85f8949a9f8a6c01f2d49e0a0764f4eacecf3e94016dd407fc14494fce9f9 +9215fd8983d7de6ae94d35e6698226fc1454977ae58d42d294be9aad13ac821562ad37d5e7ee5cdfe6e87031d45cd197 +810360a1c9b88a9e36f520ab5a1eb8bed93f52deefbe1312a69225c0a08edb10f87cc43b794aced9c74220cefcc57e7d +ad7e810efd61ed4684aeda9ed8bb02fb9ae4b4b63fda8217d37012b94ff1b91c0087043bfa4e376f961fff030c729f3b +8b07c95c6a06db8738d10bb03ec11b89375c08e77f0cab7e672ce70b2685667ca19c7e1c8b092821d31108ea18dfd4c7 +968825d025ded899ff7c57245250535c732836f7565eab1ae23ee7e513201d413c16e1ba3f5166e7ac6cf74de8ceef4f +908243370c5788200703ade8164943ad5f8c458219186432e74dbc9904a701ea307fd9b94976c866e6c58595fd891c4b +959969d16680bc535cdc6339e6186355d0d6c0d53d7bbfb411641b9bf4b770fd5f575beef5deec5c4fa4d192d455c350 +ad177f4f826a961adeac76da40e2d930748effff731756c797eddc4e5aa23c91f070fb69b19221748130b0961e68a6bb +82f8462bcc25448ef7e0739425378e9bb8a05e283ce54aae9dbebaf7a3469f57833c9171672ad43a79778366c72a5e37 +a28fb275b1845706c2814d9638573e9bc32ff552ebaed761fe96fdbce70395891ca41c400ae438369264e31a2713b15f +8a9c613996b5e51dadb587a787253d6081ea446bf5c71096980bf6bd3c4b69905062a8e8a3792de2d2ece3b177a71089 +8d5aefef9f60cb27c1db2c649221204dda48bb9bf8bf48f965741da051340e8e4cab88b9d15c69f3f84f4c854709f48a +93ebf2ca6ad85ab6deace6de1a458706285b31877b1b4d7dcb9d126b63047efaf8c06d580115ec9acee30c8a7212fa55 +b3ee46ce189956ca298057fa8223b7fd1128cf52f39159a58bca03c71dd25161ac13f1472301f72aef3e1993fe1ab269 +a24d7a8d066504fc3f5027ccb13120e2f22896860e02c45b5eba1dbd512d6a17c28f39155ea581619f9d33db43a96f92 +ae9ceacbfe12137db2c1a271e1b34b8f92e4816bad1b3b9b6feecc34df0f8b3b0f7ed0133acdf59c537d43d33fc8d429 +83967e69bf2b361f86361bd705dce0e1ad26df06da6c52b48176fe8dfcbeb03c462c1a4c9e649eff8c654b18c876fdef +9148e6b814a7d779c19c31e33a068e97b597de1f8100513db3c581190513edc4d544801ce3dd2cf6b19e0cd6daedd28a +94ccdafc84920d320ed22de1e754adea072935d3c5f8c2d1378ebe53d140ea29853f056fb3fb1e375846061a038cc9bc +afb43348498c38b0fa5f971b8cdd3a62c844f0eb52bc33daf2f67850af0880fce84ecfb96201b308d9e6168a0d443ae3 +86d5736520a83538d4cd058cc4b4e84213ed00ebd6e7af79ae787adc17a92ba5359e28ba6c91936d967b4b28d24c3070 +b5210c1ff212c5b1e9ef9126e08fe120a41e386bb12c22266f7538c6d69c7fd8774f11c02b81fd4e88f9137b020801fe +b78cfd19f94d24e529d0f52e18ce6185cb238edc6bd43086270fd51dd99f664f43dd4c7d2fe506762fbd859028e13fcf +a6e7220598c554abdcc3fdc587b988617b32c7bb0f82c06205467dbedb58276cc07cae317a190f19d19078773f4c2bbb +b88862809487ee430368dccd85a5d72fa4d163ca4aad15c78800e19c1a95be2192719801e315d86cff7795e0544a77e4 +87ecb13a03921296f8c42ceb252d04716f10e09c93962239fcaa0a7fef93f19ab3f2680bc406170108bc583e9ff2e721 +a810cd473832b6581c36ec4cb403f2849357ba2d0b54df98ef3004b8a530c078032922a81d40158f5fb0043d56477f6e +a247b45dd85ca7fbb718b328f30a03f03c84aef2c583fbdc9fcc9eb8b52b34529e8c8f535505c10598b1b4dac3d7c647 +96ee0b91313c68bac4aa9e065ce9e1d77e51ca4cff31d6a438718c58264dee87674bd97fc5c6b8008be709521e4fd008 +837567ad073e42266951a9a54750919280a2ac835a73c158407c3a2b1904cf0d17b7195a393c71a18ad029cbd9cf79ee +a6a469c44b67ebf02196213e7a63ad0423aab9a6e54acc6fcbdbb915bc043586993454dc3cd9e4be8f27d67c1050879b +8712d380a843b08b7b294f1f06e2f11f4ad6bcc655fdde86a4d8bc739c23916f6fad2b902fe47d6212f03607907e9f0e +920adfb644b534789943cdae1bdd6e42828dda1696a440af2f54e6b97f4f97470a1c6ea9fa6a2705d8f04911d055acd1 +a161c73adf584a0061e963b062f59d90faac65c9b3a936b837a10d817f02fcabfa748824607be45a183dd40f991fe83f +874f4ecd408c76e625ea50bc59c53c2d930ee25baf4b4eca2440bfbffb3b8bc294db579caa7c68629f4d9ec24187c1ba +8bff18087f112be7f4aa654e85c71fef70eee8ae480f61d0383ff6f5ab1a0508f966183bb3fc4d6f29cb7ca234aa50d3 +b03b46a3ca3bc743a173cbc008f92ab1aedd7466b35a6d1ca11e894b9482ea9dc75f8d6db2ddd1add99bfbe7657518b7 +8b4f3691403c3a8ad9e097f02d130769628feddfa8c2b3dfe8cff64e2bed7d6e5d192c1e2ba0ac348b8585e94acd5fa1 +a0d9ca4a212301f97591bf65d5ef2b2664766b427c9dd342e23cb468426e6a56be66b1cb41fea1889ac5d11a8e3c50a5 +8c93ed74188ca23b3df29e5396974b9cc135c91fdefdea6c0df694c8116410e93509559af55533a3776ac11b228d69b1 +82dd331fb3f9e344ebdeeb557769b86a2cc8cc38f6c298d7572a33aea87c261afa9dbd898989139b9fc16bc1e880a099 +a65faedf326bcfd8ef98a51410c78b021d39206704e8291cd1f09e096a66b9b0486be65ff185ca224c45918ac337ddeb +a188b37d363ac072a766fd5d6fa27df07363feff1342217b19e3c37385e42ffde55e4be8355aceaa2f267b6d66b4ac41 +810fa3ba3e96d843e3bafd3f2995727f223d3567c8ba77d684c993ba1773c66551eb5009897c51b3fe9b37196984f5ec +87631537541852da323b4353af45a164f68b304d24c01183bf271782e11687f3fcf528394e1566c2a26cb527b3148e64 +b721cb2b37b3c477a48e3cc0044167d51ff568a5fd2fb606e5aec7a267000f1ddc07d3db919926ae12761a8e017c767c +904dfad4ba2cc1f6e60d1b708438a70b1743b400164cd981f13c064b8328d5973987d4fb9cf894068f29d3deaf624dfb +a70491538893552c20939fae6be2f07bfa84d97e2534a6bbcc0f1729246b831103505e9f60e97a8fa7d2e6c1c2384579 +8726cf1b26b41f443ff7485adcfddc39ace2e62f4d65dd0bb927d933e262b66f1a9b367ded5fbdd6f3b0932553ac1735 +ae8a11cfdf7aa54c08f80cb645e3339187ab3886babe9fae5239ba507bb3dd1c0d161ca474a2df081dcd3d63e8fe445e +92328719e97ce60e56110f30a00ac5d9c7a2baaf5f8d22355d53c1c77941e3a1fec7d1405e6fbf8959665fe2ba7a8cad +8d9d6255b65798d0018a8cccb0b6343efd41dc14ff2058d3eed9451ceaad681e4a0fa6af67b0a04318aa628024e5553d +b70209090055459296006742d946a513f0cba6d83a05249ee8e7a51052b29c0ca9722dc4af5f9816a1b7938a5dac7f79 +aab7b766b9bf91786dfa801fcef6d575dc6f12b77ecc662eb4498f0312e54d0de9ea820e61508fc8aeee5ab5db529349 +a8104b462337748b7f086a135d0c3f87f8e51b7165ca6611264b8fb639d9a2f519926cb311fa2055b5fadf03da70c678 +b0d2460747d5d8b30fc6c6bd0a87cb343ddb05d90a51b465e8f67d499cfc5e3a9e365da05ae233bbee792cdf90ec67d5 +aa55f5bf3815266b4a149f85ed18e451c93de9163575e3ec75dd610381cc0805bb0a4d7c4af5b1f94d10231255436d2c +8d4c6a1944ff94426151909eb5b99cfd92167b967dabe2bf3aa66bb3c26c449c13097de881b2cfc1bf052862c1ef7b03 +8862296162451b9b6b77f03bf32e6df71325e8d7485cf3335d66fd48b74c2a8334c241db8263033724f26269ad95b395 +901aa96deb26cda5d9321190ae6624d357a41729d72ef1abfd71bebf6139af6d690798daba53b7bc5923462115ff748a +96c195ec4992728a1eb38cdde42d89a7bce150db43adbc9e61e279ea839e538deec71326b618dd39c50d589f78fc0614 +b6ff8b8aa0837b99a1a8b46fb37f20ad4aecc6a98381b1308697829a59b8442ffc748637a88cb30c9b1f0f28a926c4f6 +8d807e3dca9e7bef277db1d2cfb372408dd587364e8048b304eff00eacde2c723bfc84be9b98553f83cba5c7b3cba248 +8800c96adb0195c4fc5b24511450dee503c32bf47044f5e2e25bd6651f514d79a2dd9b01cd8c09f3c9d3859338490f57 +89fe366096097e38ec28dd1148887112efa5306cc0c3da09562aafa56f4eb000bf46ff79bf0bdd270cbde6bf0e1c8957 +af409a90c2776e1e7e3760b2042507b8709e943424606e31e791d42f17873a2710797f5baaab4cc4a19998ef648556b0 +8d761863c9b6edbd232d35ab853d944f5c950c2b643f84a1a1327ebb947290800710ff01dcfa26dc8e9828481240e8b1 +90b95e9be1e55c463ed857c4e0617d6dc3674e99b6aa62ed33c8e79d6dfcf7d122f4f4cc2ee3e7c5a49170cb617d2e2e +b3ff381efefabc4db38cc4727432e0301949ae4f16f8d1dea9b4f4de611cf5a36d84290a0bef160dac4e1955e516b3b0 +a8a84564b56a9003adcadb3565dc512239fc79572762cda7b5901a255bc82656bb9c01212ad33d6bef4fbbce18dacc87 +90a081890364b222eef54bf0075417f85e340d2fec8b7375995f598aeb33f26b44143ebf56fca7d8b4ebb36b5747b0eb +ade6ee49e1293224ddf2d8ab7f14bb5be6bc6284f60fd5b3a1e0cf147b73cff57cf19763b8a36c5083badc79c606b103 +b2fa99806dd2fa3de09320b615a2570c416c9bcdb052e592b0aead748bbe407ec9475a3d932ae48b71c2627eb81986a6 +91f3b7b73c8ccc9392542711c45fe6f236057e6efad587d661ad5cb4d6e88265f86b807bb1151736b1009ab74fd7acb4 +8800e2a46af96696dfbdcbf2ca2918b3dcf28ad970170d2d1783b52b8d945a9167d052beeb55f56c126da7ffa7059baa +9862267a1311c385956b977c9aa08548c28d758d7ba82d43dbc3d0a0fd1b7a221d39e8399997fea9014ac509ff510ac4 +b7d24f78886fd3e2d283e18d9ad5a25c1a904e7d9b9104bf47da469d74f34162e27e531380dbbe0a9d051e6ffd51d6e7 +b0f445f9d143e28b9df36b0f2c052da87ee2ca374d9d0fbe2eff66ca6fe5fe0d2c1951b428d58f7314b7e74e45d445ea +b63fc4083eabb8437dafeb6a904120691dcb53ce2938b820bb553da0e1eecd476f72495aacb72600cf9cad18698fd3db +b9ffd8108eaebd582d665f8690fe8bb207fd85185e6dd9f0b355a09bac1bbff26e0fdb172bc0498df025414e88fe2eda +967ed453e1f1a4c5b7b6834cc9f75c13f6889edc0cc91dc445727e9f408487bbf05c337103f61397a10011dfbe25d61d +98ceb673aff36e1987d5521a3984a07079c3c6155974bb8b413e8ae1ce84095fe4f7862fba7aefa14753eb26f2a5805f +85f01d28603a8fdf6ce6a50cb5c44f8a36b95b91302e3f4cd95c108ce8f4d212e73aec1b8d936520d9226802a2bd9136 +88118e9703200ca07910345fbb789e7a8f92bd80bbc79f0a9e040e8767d33df39f6eded403a9b636eabf9101e588482a +90833a51eef1b10ed74e8f9bbd6197e29c5292e469c854eed10b0da663e2bceb92539710b1858bbb21887bd538d28d89 +b513b905ec19191167c6193067b5cfdf5a3d3828375360df1c7e2ced5815437dfd37f0c4c8f009d7fb29ff3c8793f560 +b1b6d405d2d18f9554b8a358cc7e2d78a3b34269737d561992c8de83392ac9a2857be4bf15de5a6c74e0c9d0f31f393c +b828bd3e452b797323b798186607849f85d1fb20c616833c0619360dfd6b3e3aa000fd09dafe4b62d74abc41072ff1a9 +8efde67d0cca56bb2c464731879c9ac46a52e75bac702a63200a5e192b4f81c641f855ca6747752b84fe469cb7113b6c +b2762ba1c89ac3c9a983c242e4d1c2610ff0528585ed5c0dfc8a2c0253551142af9b59f43158e8915a1da7cc26b9df67 +8a3f1157fb820d1497ef6b25cd70b7e16bb8b961b0063ad340d82a79ee76eb2359ca9e15e6d42987ed7f154f5eeaa2da +a75e29f29d38f09c879f971c11beb5368affa084313474a5ecafa2896180b9e47ea1995c2733ec46f421e395a1d9cffe +8e8c3dd3e7196ef0b4996b531ec79e4a1f211db5d5635e48ceb80ff7568b2ff587e845f97ee703bb23a60945ad64314a +8e7f32f4a3e3c584af5e3d406924a0aa34024c42eca74ef6cc2a358fd3c9efaf25f1c03aa1e66bb94b023a2ee2a1cace +ab7dce05d59c10a84feb524fcb62478906b3fa045135b23afbede3bb32e0c678d8ebe59feabccb5c8f3550ea76cae44b +b38bb4b44d827f6fd3bd34e31f9186c59e312dbfadd4a7a88e588da10146a78b1f8716c91ad8b806beb8da65cab80c4c +9490ce9442bbbd05438c7f5c4dea789f74a7e92b1886a730544b55ba377840740a3ae4f2f146ee73f47c9278b0e233bc +83c003fab22a7178eed1a668e0f65d4fe38ef3900044e9ec63070c23f2827d36a1e73e5c2b883ec6a2afe2450171b3b3 +9982f02405978ddc4fca9063ebbdb152f524c84e79398955e66fe51bc7c1660ec1afc3a86ec49f58d7b7dde03505731c +ab337bd83ccdd2322088ffa8d005f450ced6b35790f37ab4534313315ee84312adc25e99cce052863a8bedee991729ed +8312ce4bec94366d88f16127a17419ef64285cd5bf9e5eda010319b48085966ed1252ed2f5a9fd3e0259b91bb65f1827 +a60d5a6327c4041b0c00a1aa2f0af056520f83c9ce9d9ccd03a0bd4d9e6a1511f26a422ea86bd858a1f77438adf07e6c +b84a0a0b030bdad83cf5202aa9afe58c9820e52483ab41f835f8c582c129ee3f34aa096d11c1cd922eda02ea1196a882 +8077d105317f4a8a8f1aadeb05e0722bb55f11abcb490c36c0904401107eb3372875b0ac233144829e734f0c538d8c1d +9202503bd29a6ec198823a1e4e098f9cfe359ed51eb5174d1ca41368821bfeebcbd49debfd02952c41359d1c7c06d2b1 +abc28c155e09365cb77ffead8dc8f602335ef93b2f44e4ef767ce8fc8ef9dd707400f3a722e92776c2e0b40192c06354 +b0f6d1442533ca45c9399e0a63a11f85ff288d242cea6cb3b68c02e77bd7d158047cae2d25b3bcd9606f8f66d9b32855 +b01c3d56a0db84dc94575f4b6ee2de4beca3230e86bed63e2066beb22768b0a8efb08ebaf8ac3dedb5fe46708b084807 +8c8634b0432159f66feaabb165842d1c8ac378f79565b1b90c381aa8450eb4231c3dad11ec9317b9fc2b155c3a771e32 +8e67f623d69ecd430c9ee0888520b6038f13a2b6140525b056dc0951f0cfed2822e62cf11d952a483107c5c5acac4826 +9590bb1cba816dd6acd5ac5fba5142c0a19d53573e422c74005e0bcf34993a8138c83124cad35a3df65879dba6134edd +801cd96cde0749021a253027118d3ea135f3fcdbe895db08a6c145641f95ebd368dd6a1568d995e1d0084146aebe224a +848b5d196427f6fc1f762ee3d36e832b64a76ec1033cfedc8b985dea93932a7892b8ef1035c653fb9dcd9ab2d9a44ac8 +a1017eb83d5c4e2477e7bd2241b2b98c4951a3b391081cae7d75965cadc1acaec755cf350f1f3d29741b0828e36fedea +8d6d2785e30f3c29aad17bd677914a752f831e96d46caf54446d967cb2432be2c849e26f0d193a60bee161ea5c6fe90a +935c0ba4290d4595428e034b5c8001cbd400040d89ab00861108e8f8f4af4258e41f34a7e6b93b04bc253d3b9ffc13bf +aac02257146246998477921cef2e9892228590d323b839f3e64ea893b991b463bc2f47e1e5092ddb47e70b2f5bce7622 +b921fde9412970a5d4c9a908ae8ce65861d06c7679af577cf0ad0d5344c421166986bee471fd6a6cecb7d591f06ec985 +8ef4c37487b139d6756003060600bb6ebac7ea810b9c4364fc978e842f13ac196d1264fbe5af60d76ff6d9203d8e7d3f +94b65e14022b5cf6a9b95f94be5ace2711957c96f4211c3f7bb36206bd39cfbd0ea82186cab5ad0577a23214a5c86e9e +a31c166d2a2ca1d5a75a5920fef7532681f62191a50d8555fdaa63ba4581c3391cc94a536fc09aac89f64eafceec3f90 +919a8cc128de01e9e10f5d83b08b52293fdd41bde2b5ae070f3d95842d4a16e5331cf2f3d61c765570c8022403610fa4 +b23d6f8331eef100152d60483cfa14232a85ee712c8538c9b6417a5a7c5b353c2ac401390c6c215cb101f5cee6b5f43e +ab357160c08a18319510a571eafff154298ce1020de8e1dc6138a09fcb0fcbcdd8359f7e9386bda00b7b9cdea745ffdc +ab55079aea34afa5c0bd1124b9cdfe01f325b402fdfa017301bf87812eaa811ea5798c3aaf818074d420d1c782b10ada +ade616010dc5009e7fc4f8d8b00dc716686a5fa0a7816ad9e503e15839d3b909b69d9dd929b7575376434ffec0d2bea8 +863997b97ed46898a8a014599508fa3079f414b1f4a0c4fdc6d74ae8b444afa350f327f8bfc2a85d27f9e2d049c50135 +8d602ff596334efd4925549ed95f2aa762b0629189f0df6dbb162581657cf3ea6863cd2287b4d9c8ad52813d87fcd235 +b70f68c596dcdeed92ad5c6c348578b26862a51eb5364237b1221e840c47a8702f0fbc56eb520a22c0eed99795d3903e +9628088f8e0853cefadee305a8bf47fa990c50fa96a82511bbe6e5dc81ef4b794e7918a109070f92fc8384d77ace226f +97e26a46e068b605ce96007197ecd943c9a23881862f4797a12a3e96ba2b8d07806ad9e2a0646796b1889c6b7d75188c +b1edf467c068cc163e2d6413cc22b16751e78b3312fe47b7ea82b08a1206d64415b2c8f2a677fa89171e82cc49797150 +a44d15ef18745b251429703e3cab188420e2d974de07251501799b016617f9630643fcd06f895634d8ecdd579e1bf000 +abd126df3917ba48c618ee4dbdf87df506193462f792874439043fa1b844466f6f4e0ff2e42516e63b5b23c0892b2695 +a2a67f57c4aa3c2aa1eeddbfd5009a89c26c2ce8fa3c96a64626aba19514beb125f27df8559506f737de3eae0f1fc18f +a633e0132197e6038197304b296ab171f1d8e0d0f34dcf66fe9146ac385b0239232a8470b9205a4802ab432389f4836d +a914b3a28509a906c3821463b936455d58ff45dcbe158922f9efb2037f2eb0ce8e92532d29b5d5a3fcd0d23fa773f272 +a0e1412ce4505daf1a2e59ce4f0fc0e0023e335b50d2b204422f57cd65744cc7a8ed35d5ef131a42c70b27111d3115b7 +a2339e2f2b6072e88816224fdd612c04d64e7967a492b9f8829db15367f565745325d361fd0607b0def1be384d010d9e +a7309fc41203cb99382e8193a1dcf03ac190a7ce04835304eb7e341d78634e83ea47cb15b885601956736d04cdfcaa01 +81f3ccd6c7f5b39e4e873365f8c37b214e8ab122d04a606fbb7339dc3298c427e922ec7418002561d4106505b5c399ee +92c121cf914ca549130e352eb297872a63200e99b148d88fbc9506ad882bec9d0203d65f280fb5b0ba92e336b7f932e8 +a4b330cf3f064f5b131578626ad7043ce2a433b6f175feb0b52d36134a454ca219373fd30d5e5796410e005b69082e47 +86fe5774112403ad83f9c55d58317eeb17ad8e1176d9f2f69c2afb7ed83bc718ed4e0245ceab4b377f5f062dcd4c00e7 +809d152a7e2654c7fd175b57f7928365a521be92e1ed06c05188a95864ddb25f7cab4c71db7d61bbf4cae46f3a1d96ce +b82d663e55c2a5ada7e169e9b1a87bc1c0177baf1ec1c96559b4cb1c5214ce1ddf2ab8d345014cab6402f3774235cf5a +86580af86df1bd2c385adb8f9a079e925981b7184db66fc5fe5b14cddb82e7d836b06eaeef14924ac529487b23dae111 +b5f5f4c5c94944ecc804df6ab8687d64e27d988cbfeae1ba7394e0f6adbf778c5881ead7cd8082dd7d68542b9bb4ecd5 +a6016916146c2685c46e8fdd24186394e2d5496e77e08c0c6a709d4cd7dfa97f1efcef94922b89196819076a91ad37b5 +b778e7367ded3b6eab53d5fc257f7a87e8faf74a593900f2f517220add2125be3f6142022660d8181df8d164ad9441ce +8581b2d36abe6f553add4d24be761bec1b8efaa2929519114346615380b3c55b59e6ad86990e312f7e234d0203bdf59b +9917e74fd45c3f71a829ff5498a7f6b5599b48c098dda2339bf04352bfc7f368ccf1a407f5835901240e76452ae807d7 +afd196ce6f9335069138fd2e3d133134da253978b4ce373152c0f26affe77a336505787594022e610f8feb722f7cc1fb +a477491a1562e329764645e8f24d8e228e5ef28c9f74c6b5b3abc4b6a562c15ffb0f680d372aed04d9e1bf944dece7be +9767440d58c57d3077319d3a330e5322b9ba16981ec74a5a14d53462eab59ae7fd2b14025bfc63b268862094acb444e6 +80986d921be3513ef69264423f351a61cb48390c1be8673aee0f089076086aaebea7ebe268fd0aa7182695606116f679 +a9554c5c921c07b450ee04e34ec58e054ac1541b26ce2ce5a393367a97348ba0089f53db6660ad76b60278b66fd12e3e +95097e7d2999b3e84bf052c775581cf361325325f4a50192521d8f4693c830bed667d88f482dc1e3f833aa2bd22d2cbf +9014c91d0f85aefd28436b5228c12f6353c055a9326c7efbf5e071e089e2ee7c070fcbc84c5fafc336cbb8fa6fec1ca1 +90f57ba36ee1066b55d37384942d8b57ae00f3cf9a3c1d6a3dfee1d1af42d4b5fa9baeb0cd7e46687d1d6d090ddb931d +8e4b1db12fd760a17214c9e47f1fce6e43c0dbb4589a827a13ac61aaae93759345697bb438a00edab92e0b7b62414683 +8022a959a513cdc0e9c705e0fc04eafd05ff37c867ae0f31f6d01cddd5df86138a426cab2ff0ac8ff03a62e20f7e8f51 +914e9a38829834c7360443b8ed86137e6f936389488eccf05b4b4db7c9425611705076ecb3f27105d24b85c852be7511 +957fb10783e2bd0db1ba66b18e794df710bc3b2b05776be146fa5863c15b1ebdd39747b1a95d9564e1772cdfc4f37b8a +b6307028444daed8ed785ac9d0de76bc3fe23ff2cc7e48102553613bbfb5afe0ebe45e4212a27021c8eb870721e62a1f +8f76143597777d940b15a01b39c5e1b045464d146d9a30a6abe8b5d3907250e6c7f858ff2308f8591e8b0a7b3f3c568a +96163138ac0ce5fd00ae9a289648fd9300a0ca0f63a88481d703ecd281c06a52a3b5178e849e331f9c85ca4ba398f4cc +a63ef47c3e18245b0482596a09f488a716df3cbd0f9e5cfabed0d742843e65db8961c556f45f49762f3a6ac8b627b3ef +8cb595466552e7c4d42909f232d4063e0a663a8ef6f6c9b7ce3a0542b2459cde04e0e54c7623d404acb5b82775ac04f6 +b47fe69960eb45f399368807cff16d941a5a4ebad1f5ec46e3dc8a2e4d598a7e6114d8f0ca791e9720fd786070524e2b +89eb5ff83eea9df490e5beca1a1fbbbbcf7184a37e2c8c91ede7a1e654c81e8cd41eceece4042ea7918a4f4646b67fd6 +a84f5d155ed08b9054eecb15f689ba81e44589e6e7207a99790c598962837ca99ec12344105b16641ca91165672f7153 +a6cc8f25c2d5b2d2f220ec359e6a37a52b95fa6af6e173c65e7cd55299eff4aa9e6d9e6f2769e6459313f1f2aecb0fab +afcde944411f017a9f7979755294981e941cc41f03df5e10522ef7c7505e5f1babdd67b3bf5258e8623150062eb41d9b +8fab39f39c0f40182fcd996ade2012643fe7731808afbc53f9b26900b4d4d1f0f5312d9d40b3df8baa4739970a49c732 +ae193af9726da0ebe7df1f9ee1c4846a5b2a7621403baf8e66c66b60f523e719c30c6b4f897bb14b27d3ff3da8392eeb +8ac5adb82d852eba255764029f42e6da92dcdd0e224d387d1ef94174038db9709ac558d90d7e7c57ad4ce7f89bbfc38c +a2066b3458fdf678ee487a55dd5bfb74fde03b54620cb0e25412a89ee28ad0d685e309a51e3e4694be2fa6f1593a344c +88d031745dd0ae07d61a15b594be5d4b2e2a29e715d081649ad63605e3404b0c3a5353f0fd9fad9c05c18e93ce674fa1 +8283cfb0ef743a043f2b77ecaeba3005e2ca50435585b5dd24777ee6bce12332f85e21b446b536da38508807f0f07563 +b376de22d5f6b0af0b59f7d9764561f4244cf8ffe22890ecd3dcf2ff1832130c9b821e068c9d8773136f4796721e5963 +ae3afc50c764f406353965363840bf28ee85e7064eb9d5f0bb3c31c64ab10f48c853e942ee2c9b51bae59651eaa08c2f +948b204d103917461a01a6c57a88f2d66b476eae5b00be20ec8c747650e864bc8a83aee0aff59cb7584b7a3387e0ee48 +81ab098a082b07f896c5ffd1e4446cb7fb44804cbbf38d125208b233fc82f8ec9a6a8d8dd1c9a1162dc28ffeec0dde50 +a149c6f1312821ced2969268789a3151bdda213451760b397139a028da609c4134ac083169feb0ee423a0acafd10eceb +b0ac9e27a5dadaf523010f730b28f0ebac01f460d3bbbe277dc9d44218abb5686f4fac89ae462682fef9edbba663520a +8d0e0073cca273daaaa61b6fc54bfe5a009bc3e20ae820f6c93ba77b19eca517d457e948a2de5e77678e4241807157cb +ad61d3a2edf7c7533a04964b97499503fd8374ca64286dba80465e68fe932e96749b476f458c6fc57cb1a7ca85764d11 +90eb5e121ae46bc01a30881eaa556f46bd8457a4e80787cf634aab355082de34ac57d7f497446468225f7721e68e2a47 +8cdac557de7c42d1f3780e33dec1b81889f6352279be81c65566cdd4952d4c15d79e656cbd46035ab090b385e90245ef +82b67e61b88b84f4f4d4f65df37b3e3dcf8ec91ea1b5c008fdccd52da643adbe6468a1cfdb999e87d195afe2883a3b46 +8503b467e8f5d6048a4a9b78496c58493a462852cab54a70594ae3fd064cfd0deb4b8f336a262155d9fedcaa67d2f6fd +8db56c5ac763a57b6ce6832930c57117058e3e5a81532b7d19346346205e2ec614eb1a2ee836ef621de50a7bc9b7f040 +ad344699198f3c6e8c0a3470f92aaffc805b76266734414c298e10b5b3797ca53578de7ccb2f458f5e0448203f55282b +80602032c43c9e2a09154cc88b83238343b7a139f566d64cb482d87436b288a98f1ea244fd3bff8da3c398686a900c14 +a6385bd50ecd548cfb37174cdbb89e10025b5cadaf3cff164c95d7aef5a33e3d6a9bf0c681b9e11db9ef54ebeee2a0c1 +abf2d95f4aa34b0581eb9257a0cc8462b2213941a5deb8ba014283293e8b36613951b61261cc67bbd09526a54cbbff76 +a3d5de52f48df72c289ff713e445991f142390798cd42bd9d9dbefaee4af4f5faf09042d126b975cf6b98711c3072553 +8e627302ff3d686cff8872a1b7c2a57b35f45bf2fc9aa42b049d8b4d6996a662b8e7cbac6597f0cb79b0cc4e29fbf133 +8510702e101b39a1efbf4e504e6123540c34b5689645e70d0bac1ecc1baf47d86c05cef6c4317a4e99b4edaeb53f2d00 +aa173f0ecbcc6088f878f8726d317748c81ebf501bba461f163b55d66099b191ec7c55f7702f351a9c8eb42cfa3280e2 +b560a697eafab695bcef1416648a0a664a71e311ecbe5823ae903bd0ed2057b9d7574b9a86d3fe22aa3e6ddce38ea513 +8df6304a3d9cf40100f3f687575419c998cd77e5cc27d579cf4f8e98642de3609af384a0337d145dd7c5635172d26a71 +8105c7f3e4d30a29151849673853b457c1885c186c132d0a98e63096c3774bc9deb956cf957367e633d0913680bda307 +95373fc22c0917c3c2044ac688c4f29a63ed858a45c0d6d2d0fe97afd6f532dcb648670594290c1c89010ecc69259bef +8c2fae9bcadab341f49b55230310df93cac46be42d4caa0d42e45104148a91e527af1b4209c0d972448162aed28fab64 +b05a77baab70683f76209626eaefdda2d36a0b66c780a20142d23c55bd479ddd4ad95b24579384b6cf62c8eb4c92d021 +8e6bc6a7ea2755b4aaa19c1c1dee93811fcde514f03485fdc3252f0ab7f032c315614f6336e57cea25dcfb8fb6084eeb +b656a27d06aade55eadae2ad2a1059198918ea6cc3fd22c0ed881294d34d5ac7b5e4700cc24350e27d76646263b223aa +a296469f24f6f56da92d713afcd4dd606e7da1f79dc4e434593c53695847eefc81c7c446486c4b3b8c8d00c90c166f14 +87a326f57713ac2c9dffeb3af44b9f3c613a8f952676fc46343299122b47ee0f8d792abaa4b5db6451ced5dd153aabd0 +b689e554ba9293b9c1f6344a3c8fcb6951d9f9eac4a2e2df13de021aade7c186be27500e81388e5b8bcab4c80f220a31 +87ae0aa0aa48eac53d1ca5a7b93917de12db9e40ceabf8fdb40884ae771cfdf095411deef7c9f821af0b7070454a2608 +a71ffa7eae8ace94e6c3581d4cb2ad25d48cbd27edc9ec45baa2c8eb932a4773c3272b2ffaf077b40f76942a1f3af7f2 +94c218c91a9b73da6b7a495b3728f3028df8ad9133312fc0c03e8c5253b7ccb83ed14688fd4602e2fd41f29a0bc698bd +ae1e77b90ca33728af07a4c03fb2ef71cd92e2618e7bf8ed4d785ce90097fc4866c29999eb84a6cf1819d75285a03af2 +b7a5945b277dab9993cf761e838b0ac6eaa903d7111fca79f9fde3d4285af7a89bf6634a71909d095d7619d913972c9c +8c43b37be02f39b22029b20aca31bff661abce4471dca88aa3bddefd9c92304a088b2dfc8c4795acc301ca3160656af2 +b32e5d0fba024554bd5fe8a793ebe8003335ddd7f585876df2048dcf759a01285fecb53daae4950ba57f3a282a4d8495 +85ea7fd5e10c7b659df5289b2978b2c89e244f269e061b9a15fcab7983fc1962b63546e82d5731c97ec74b6804be63ef +96b89f39181141a7e32986ac02d7586088c5a9662cec39843f397f3178714d02f929af70630c12cbaba0268f8ba2d4fa +929ab1a2a009b1eb37a2817c89696a06426529ebe3f306c586ab717bd34c35a53eca2d7ddcdef36117872db660024af9 +a696dccf439e9ca41511e16bf3042d7ec0e2f86c099e4fc8879d778a5ea79e33aa7ce96b23dc4332b7ba26859d8e674d +a8fe69a678f9a194b8670a41e941f0460f6e2dbc60470ab4d6ae2679cc9c6ce2c3a39df2303bee486dbfde6844e6b31a +95f58f5c82de2f2a927ca99bf63c9fc02e9030c7e46d0bf6b67fe83a448d0ae1c99541b59caf0e1ccab8326231af09a5 +a57badb2c56ca2c45953bd569caf22968f76ed46b9bac389163d6fe22a715c83d5e94ae8759b0e6e8c2f27bff7748f3f +868726fd49963b24acb5333364dffea147e98f33aa19c7919dc9aca0fd26661cfaded74ede7418a5fadbe7f5ae67b67b +a8d8550dcc64d9f1dd7bcdab236c4122f2b65ea404bb483256d712c7518f08bb028ff8801f1da6aed6cbfc5c7062e33b +97e25a87dae23155809476232178538d4bc05d4ff0882916eb29ae515f2a62bfce73083466cc0010ca956aca200aeacc +b4ea26be3f4bd04aa82d7c4b0913b97bcdf5e88b76c57eb1a336cbd0a3eb29de751e1bc47c0e8258adec3f17426d0c71 +99ee555a4d9b3cf2eb420b2af8e3bc99046880536116d0ce7193464ac40685ef14e0e3c442f604e32f8338cb0ef92558 +8c64efa1da63cd08f319103c5c7a761221080e74227bbc58b8fb35d08aa42078810d7af3e60446cbaff160c319535648 +8d9fd88040076c28420e3395cbdfea402e4077a3808a97b7939d49ecbcf1418fe50a0460e1c1b22ac3f6e7771d65169a +ae3c19882d7a9875d439265a0c7003c8d410367627d21575a864b9cb4918de7dbdb58a364af40c5e045f3df40f95d337 +b4f7bfacab7b2cafe393f1322d6dcc6f21ffe69cd31edc8db18c06f1a2b512c27bd0618091fd207ba8df1808e9d45914 +94f134acd0007c623fb7934bcb65ef853313eb283a889a3ffa79a37a5c8f3665f3d5b4876bc66223610c21dc9b919d37 +aa15f74051171daacdc1f1093d3f8e2d13da2833624b80a934afec86fc02208b8f55d24b7d66076444e7633f46375c6a +a32d6bb47ef9c836d9d2371807bafbbbbb1ae719530c19d6013f1d1f813c49a60e4fa51d83693586cba3a840b23c0404 +b61b3599145ea8680011aa2366dc511a358b7d67672d5b0c5be6db03b0efb8ca5a8294cf220ea7409621f1664e00e631 +859cafc3ee90b7ececa1ed8ef2b2fc17567126ff10ca712d5ffdd16aa411a5a7d8d32c9cab1fbf63e87dce1c6e2f5f53 +a2fef1b0b2874387010e9ae425f3a9676d01a095d017493648bcdf3b31304b087ccddb5cf76abc4e1548b88919663b6b +939e18c73befc1ba2932a65ede34c70e4b91e74cc2129d57ace43ed2b3af2a9cc22a40fbf50d79a63681b6d98852866d +b3b4259d37b1b14aee5b676c9a0dd2d7f679ab95c120cb5f09f9fbf10b0a920cb613655ddb7b9e2ba5af4a221f31303c +997255fe51aaca6e5a9cb3359bcbf25b2bb9e30649bbd53a8a7c556df07e441c4e27328b38934f09c09d9500b5fabf66 +abb91be2a2d860fd662ed4f1c6edeefd4da8dc10e79251cf87f06029906e7f0be9b486462718f0525d5e049472692cb7 +b2398e593bf340a15f7801e1d1fbda69d93f2a32a889ec7c6ae5e8a37567ac3e5227213c1392ee86cfb3b56ec2787839 +8ddf10ccdd72922bed36829a36073a460c2118fc7a56ff9c1ac72581c799b15c762cb56cb78e3d118bb9f6a7e56cb25e +93e6bc0a4708d16387cacd44cf59363b994dc67d7ada7b6d6dbd831c606d975247541b42b2a309f814c1bfe205681fc6 +b93fc35c05998cffda2978e12e75812122831523041f10d52f810d34ff71944979054b04de0117e81ddf5b0b4b3e13c0 +92221631c44d60d68c6bc7b287509f37ee44cbe5fdb6935cee36b58b17c7325098f98f7910d2c3ca5dc885ad1d6dabc7 +a230124424a57fad3b1671f404a94d7c05f4c67b7a8fbacfccea28887b78d7c1ed40b92a58348e4d61328891cd2f6cee +a6a230edb8518a0f49d7231bc3e0bceb5c2ac427f045819f8584ba6f3ae3d63ed107a9a62aad543d7e1fcf1f20605706 +845be1fe94223c7f1f97d74c49d682472585d8f772762baad8a9d341d9c3015534cc83d102113c51a9dea2ab10d8d27b +b44262515e34f2db597c8128c7614d33858740310a49cdbdf9c8677c5343884b42c1292759f55b8b4abc4c86e4728033 +805592e4a3cd07c1844bc23783408310accfdb769cca882ad4d07d608e590a288b7370c2cb327f5336e72b7083a0e30f +95153e8b1140df34ee864f4ca601cb873cdd3efa634af0c4093fbaede36f51b55571ab271e6a133020cd34db8411241f +82878c1285cfa5ea1d32175c9401f3cc99f6bb224d622d3fd98cc7b0a27372f13f7ab463ce3a33ec96f9be38dbe2dfe3 +b7588748f55783077c27fc47d33e20c5c0f5a53fc0ac10194c003aa09b9f055d08ec971effa4b7f760553997a56967b3 +b36b4de6d1883b6951f59cfae381581f9c6352fcfcf1524fccdab1571a20f80441d9152dc6b48bcbbf00371337ca0bd5 +89c5523f2574e1c340a955cbed9c2f7b5fbceb260cb1133160dabb7d41c2f613ec3f6e74bbfab3c4a0a6f0626dbe068f +a52f58cc39f968a9813b1a8ddc4e83f4219e4dd82c7aa1dd083bea7edf967151d635aa9597457f879771759b876774e4 +8300a67c2e2e123f89704abfde095463045dbd97e20d4c1157bab35e9e1d3d18f1f4aaba9cbe6aa2d544e92578eaa1b6 +ac6a7f2918768eb6a43df9d3a8a04f8f72ee52f2e91c064c1c7d75cad1a3e83e5aba9fe55bb94f818099ac91ccf2e961 +8d64a2b0991cf164e29835c8ddef6069993a71ec2a7de8157bbfa2e00f6367be646ed74cbaf524f0e9fe13fb09fa15fd +8b2ffe5a545f9f680b49d0a9797a4a11700a2e2e348c34a7a985fc278f0f12def6e06710f40f9d48e4b7fbb71e072229 +8ab8f71cd337fa19178924e961958653abf7a598e3f022138b55c228440a2bac4176cea3aea393549c03cd38a13eb3fc +8419d28318c19ea4a179b7abb43669fe96347426ef3ac06b158d79c0acf777a09e8e770c2fb10e14b3a0421705990b23 +8bacdac310e1e49660359d0a7a17fe3d334eb820e61ae25e84cb52f863a2f74cbe89c2e9fc3283745d93a99b79132354 +b57ace3fa2b9f6b2db60c0d861ace7d7e657c5d35d992588aeed588c6ce3a80b6f0d49f8a26607f0b17167ab21b675e4 +83e265cde477f2ecc164f49ddc7fb255bb05ff6adc347408353b7336dc3a14fdedc86d5a7fb23f36b8423248a7a67ed1 +a60ada971f9f2d79d436de5d3d045f5ab05308cae3098acaf5521115134b2a40d664828bb89895840db7f7fb499edbc5 +a63eea12efd89b62d3952bf0542a73890b104dd1d7ff360d4755ebfa148fd62de668edac9eeb20507967ea37fb220202 +a0275767a270289adc991cc4571eff205b58ad6d3e93778ddbf95b75146d82517e8921bd0d0564e5b75fa0ccdab8e624 +b9b03fd3bf07201ba3a039176a965d736b4ef7912dd9e9bf69fe1b57c330a6aa170e5521fe8be62505f3af81b41d7806 +a95f640e26fb1106ced1729d6053e41a16e4896acac54992279ff873e5a969aad1dcfa10311e28b8f409ac1dab7f03bb +b144778921742418053cb3c70516c63162c187f00db2062193bb2c14031075dbe055d020cde761b26e8c58d0ea6df2c1 +8432fbb799e0435ef428d4fefc309a05dd589bce74d7a87faf659823e8c9ed51d3e42603d878e80f439a38be4321c2fa +b08ddef14e42d4fd5d8bf39feb7485848f0060d43b51ed5bdda39c05fe154fb111d29719ee61a23c392141358c0cfcff +8ae3c5329a5e025b86b5370e06f5e61177df4bda075856fade20a17bfef79c92f54ed495f310130021ba94fb7c33632b +92b6d3c9444100b4d7391febfc1dddaa224651677c3695c47a289a40d7a96d200b83b64e6d9df51f534564f272a2c6c6 +b432bc2a3f93d28b5e506d68527f1efeb2e2570f6be0794576e2a6ef9138926fdad8dd2eabfa979b79ab7266370e86bc +8bc315eacedbcfc462ece66a29662ca3dcd451f83de5c7626ef8712c196208fb3d8a0faf80b2e80384f0dd9772f61a23 +a72375b797283f0f4266dec188678e2b2c060dfed5880fc6bb0c996b06e91a5343ea2b695adaab0a6fd183b040b46b56 +a43445036fbaa414621918d6a897d3692fdae7b2961d87e2a03741360e45ebb19fcb1703d23f1e15bb1e2babcafc56ac +b9636b2ffe305e63a1a84bd44fb402442b1799bd5272638287aa87ca548649b23ce8ce7f67be077caed6aa2dbc454b78 +99a30bf0921d854c282b83d438a79f615424f28c2f99d26a05201c93d10378ab2cd94a792b571ddae5d4e0c0013f4006 +8648e3c2f93d70b392443be116b48a863e4b75991bab5db656a4ef3c1e7f645e8d536771dfe4e8d1ceda3be8d32978b0 +ab50dc9e6924c1d2e9d2e335b2d679fc7d1a7632e84964d3bac0c9fe57e85aa5906ec2e7b0399d98ddd022e9b19b5904 +ab729328d98d295f8f3272afaf5d8345ff54d58ff9884da14f17ecbdb7371857fdf2f3ef58080054e9874cc919b46224 +83fa5da7592bd451cad3ad7702b4006332b3aae23beab4c4cb887fa6348317d234bf62a359e665b28818e5410c278a09 +8bdbff566ae9d368f114858ef1f009439b3e9f4649f73efa946e678d6c781d52c69af195df0a68170f5f191b2eac286b +91245e59b4425fd4edb2a61d0d47c1ccc83d3ced8180de34887b9655b5dcda033d48cde0bdc3b7de846d246c053a02e8 +a2cb00721e68f1cad8933947456f07144dc69653f96ceed845bd577d599521ba99cdc02421118971d56d7603ed118cbf +af8cd66d303e808b22ec57860dd909ca64c27ec2c60e26ffecfdc1179d8762ffd2739d87b43959496e9fee4108df71df +9954136812dffcd5d3f167a500e7ab339c15cfc9b3398d83f64b0daa3dd5b9a851204f424a3493b4e326d3de81e50a62 +93252254d12511955f1aa464883ad0da793f84d900fea83e1df8bca0f2f4cf5b5f9acbaec06a24160d33f908ab5fea38 +997cb55c26996586ba436a95566bd535e9c22452ca5d2a0ded2bd175376557fa895f9f4def4519241ff386a063f2e526 +a12c78ad451e0ac911260ade2927a768b50cb4125343025d43474e7f465cdc446e9f52a84609c5e7e87ae6c9b3f56cda +a789d4ca55cbba327086563831b34487d63d0980ba8cf55197c016702ed6da9b102b1f0709ce3da3c53ff925793a3d73 +a5d76acbb76741ce85be0e655b99baa04f7f587347947c0a30d27f8a49ae78cce06e1cde770a8b618d3db402be1c0c4b +873c0366668c8faddb0eb7c86f485718d65f8c4734020f1a18efd5fa123d3ea8a990977fe13592cd01d17e60809cb5ff +b659b71fe70f37573ff7c5970cc095a1dc0da3973979778f80a71a347ef25ad5746b2b9608bad4ab9a4a53a4d7df42d7 +a34cbe05888e5e5f024a2db14cb6dcdc401a9cbd13d73d3c37b348f68688f87c24ca790030b8f84fef9e74b4eab5e412 +94ce8010f85875c045b0f014db93ef5ab9f1f6842e9a5743dce9e4cb872c94affd9e77c1f1d1ab8b8660b52345d9acb9 +adefa9b27a62edc0c5b019ddd3ebf45e4de846165256cf6329331def2e088c5232456d3de470fdce3fa758bfdd387512 +a6b83821ba7c1f83cc9e4529cf4903adb93b26108e3d1f20a753070db072ad5a3689643144bdd9c5ea06bb9a7a515cd0 +a3a9ddedc2a1b183eb1d52de26718151744db6050f86f3580790c51d09226bf05f15111691926151ecdbef683baa992c +a64bac89e7686932cdc5670d07f0b50830e69bfb8c93791c87c7ffa4913f8da881a9d8a8ce8c1a9ce5b6079358c54136 +a77b5a63452cb1320b61ab6c7c2ef9cfbcade5fd4727583751fb2bf3ea330b5ca67757ec1f517bf4d503ec924fe32fbd +8746fd8d8eb99639d8cd0ca34c0d9c3230ed5a312aab1d3d925953a17973ee5aeb66e68667e93caf9cb817c868ea8f3d +88a2462a26558fc1fbd6e31aa8abdc706190a17c27fdc4217ffd2297d1b1f3321016e5c4b2384c5454d5717dc732ed03 +b78893a97e93d730c8201af2e0d3b31cb923d38dc594ffa98a714e627c473d42ea82e0c4d2eeb06862ee22a9b2c54588 +920cc8b5f1297cf215a43f6fc843e379146b4229411c44c0231f6749793d40f07b9af7699fd5d21fd69400b97febe027 +a0f0eafce1e098a6b58c7ad8945e297cd93aaf10bc55e32e2e32503f02e59fc1d5776936577d77c0b1162cb93b88518b +98480ba0064e97a2e7a6c4769b4d8c2a322cfc9a3b2ca2e67e9317e2ce04c6e1108169a20bd97692e1cb1f1423b14908 +83dbbb2fda7e287288011764a00b8357753a6a44794cc8245a2275237f11affdc38977214e463ad67aec032f3dfa37e9 +86442fff37598ce2b12015ff19b01bb8a780b40ad353d143a0f30a06f6d23afd5c2b0a1253716c855dbf445cc5dd6865 +b8a4c60c5171189414887847b9ed9501bff4e4c107240f063e2d254820d2906b69ef70406c585918c4d24f1dd052142b +919f33a98e84015b2034b57b5ffe9340220926b2c6e45f86fd79ec879dbe06a148ae68b77b73bf7d01bd638a81165617 +95c13e78d89474a47fbc0664f6f806744b75dede95a479bbf844db4a7f4c3ae410ec721cb6ffcd9fa9c323da5740d5ae +ab7151acc41fffd8ec6e90387700bcd7e1cde291ea669567295bea1b9dd3f1df2e0f31f3588cd1a1c08af8120aca4921 +80e74c5c47414bd6eeef24b6793fb1fa2d8fb397467045fcff887c52476741d5bc4ff8b6d3387cb53ad285485630537f +a296ad23995268276aa351a7764d36df3a5a3cffd7dbeddbcea6b1f77adc112629fdeffa0918b3242b3ccd5e7587e946 +813d2506a28a2b01cb60f49d6bd5e63c9b056aa56946faf2f33bd4f28a8d947569cfead3ae53166fc65285740b210f86 +924b265385e1646287d8c09f6c855b094daaee74b9e64a0dddcf9ad88c6979f8280ba30c8597b911ef58ddb6c67e9fe3 +8d531513c70c2d3566039f7ca47cd2352fd2d55b25675a65250bdb8b06c3843db7b2d29c626eed6391c238fc651cf350 +82b338181b62fdc81ceb558a6843df767b6a6e3ceedc5485664b4ea2f555904b1a45fbb35f6cf5d96f27da10df82a325 +92e62faaedea83a37f314e1d3cb4faaa200178371d917938e59ac35090be1db4b4f4e0edb78b9c991de202efe4f313d8 +99d645e1b642c2dc065bac9aaa0621bc648c9a8351efb6891559c3a41ba737bd155fb32d7731950514e3ecf4d75980e4 +b34a13968b9e414172fb5d5ece9a39cf2eb656128c3f2f6cc7a9f0c69c6bae34f555ecc8f8837dc34b5e470e29055c78 +a2a0bb7f3a0b23a2cbc6585d59f87cd7e56b2bbcb0ae48f828685edd9f7af0f5edb4c8e9718a0aaf6ef04553ba71f3b7 +8e1a94bec053ed378e524b6685152d2b52d428266f2b6eadd4bcb7c4e162ed21ab3e1364879673442ee2162635b7a4d8 +9944adaff14a85eab81c73f38f386701713b52513c4d4b838d58d4ffa1d17260a6d056b02334850ea9a31677c4b078bd +a450067c7eceb0854b3eca3db6cf38669d72cb7143c3a68787833cbca44f02c0be9bfbe082896f8a57debb13deb2afb1 +8be4ad3ac9ef02f7df09254d569939757101ee2eda8586fefcd8c847adc1efe5bdcb963a0cafa17651befaafb376a531 +90f6de91ea50255f148ac435e08cf2ac00c772a466e38155bd7e8acf9197af55662c7b5227f88589b71abe9dcf7ba343 +86e5a24f0748b106dee2d4d54e14a3b0af45a96cbee69cac811a4196403ebbee17fd24946d7e7e1b962ac7f66dbaf610 +afdd96fbcda7aa73bf9eeb2292e036c25753d249caee3b9c013009cc22e10d3ec29e2aa6ddbb21c4e949b0c0bccaa7f4 +b5a4e7436d5473647c002120a2cb436b9b28e27ad4ebdd7c5f122b91597c507d256d0cbd889d65b3a908531936e53053 +b632414c3da704d80ac2f3e5e0e9f18a3637cdc2ebeb613c29300745582427138819c4e7b0bec3099c1b8739dac1807b +a28df1464d3372ce9f37ef1db33cc010f752156afae6f76949d98cd799c0cf225c20228ae86a4da592d65f0cffe3951b +898b93d0a31f7d3f11f253cb7a102db54b669fd150da302d8354d8e02b1739a47cb9bd88015f3baf12b00b879442464e +96fb88d89a12049091070cb0048a381902965e67a8493e3991eaabe5d3b7ff7eecd5c94493a93b174df3d9b2c9511755 +b899cb2176f59a5cfba3e3d346813da7a82b03417cad6342f19cc8f12f28985b03bf031e856a4743fd7ebe16324805b0 +a60e2d31bc48e0c0579db15516718a03b73f5138f15037491f4dae336c904e312eda82d50862f4debd1622bb0e56d866 +979fc8b987b5cef7d4f4b58b53a2c278bd25a5c0ea6f41c715142ea5ff224c707de38451b0ad3aa5e749aa219256650a +b2a75bff18e1a6b9cf2a4079572e41205741979f57e7631654a3c0fcec57c876c6df44733c9da3d863db8dff392b44a3 +b7a0f0e811222c91e3df98ff7f286b750bc3b20d2083966d713a84a2281744199e664879401e77470d44e5a90f3e5181 +82b74ba21c9d147fbc338730e8f1f8a6e7fc847c3110944eb17a48bea5e06eecded84595d485506d15a3e675fd0e5e62 +a7f44eef817d5556f0d1abcf420301217d23c69dd2988f44d91ea1f1a16c322263cbacd0f190b9ba22b0f141b9267b4f +aadb68164ede84fc1cb3334b3194d84ba868d5a88e4c9a27519eef4923bc4abf81aab8114449496c073c2a6a0eb24114 +b5378605fabe9a8c12a5dc55ef2b1de7f51aedb61960735c08767a565793cea1922a603a6983dc25f7cea738d0f7c40d +a97a4a5cd8d51302e5e670aee78fe6b5723f6cc892902bbb4f131e82ca1dfd5de820731e7e3367fb0c4c1922a02196e3 +8bdfeb15c29244d4a28896f2b2cb211243cd6a1984a3f5e3b0ebe5341c419beeab3304b390a009ffb47588018034b0ea +a9af3022727f2aa2fca3b096968e97edad3f08edcbd0dbca107b892ae8f746a9c0485e0d6eb5f267999b23a845923ed0 +8e7594034feef412f055590fbb15b6322dc4c6ab7a4baef4685bd13d71a83f7d682b5781bdfa0d1c659489ce9c2b8000 +84977ca6c865ebee021c58106c1a4ad0c745949ecc5332948002fd09bd9b890524878d0c29da96fd11207621136421fe +8687551a79158e56b2375a271136756313122132a6670fa51f99a1b5c229ed8eea1655a734abae13228b3ebfd2a825dd +a0227d6708979d99edfc10f7d9d3719fd3fc68b0d815a7185b60307e4c9146ad2f9be2b8b4f242e320d4288ceeb9504c +89f75583a16735f9dd8b7782a130437805b34280ccea8dac6ecaee4b83fe96947e7b53598b06fecfffdf57ffc12cc445 +a0056c3353227f6dd9cfc8e3399aa5a8f1d71edf25d3d64c982910f50786b1e395c508d3e3727ac360e3e040c64b5298 +b070e61a6d813626144b312ded1788a6d0c7cec650a762b2f8df6e4743941dd82a2511cd956a3f141fc81e15f4e092da +b4e6db232e028a1f989bb5fc13416711f42d389f63564d60851f009dcffac01acfd54efa307aa6d4c0f932892d4e62b0 +89b5991a67db90024ddd844e5e1a03ef9b943ad54194ae0a97df775dde1addf31561874f4e40fbc37a896630f3bbda58 +ad0e8442cb8c77d891df49cdb9efcf2b0d15ac93ec9be1ad5c3b3cca1f4647b675e79c075335c1f681d56f14dc250d76 +b5d55a6ae65bb34dd8306806cb49b5ccb1c83a282ee47085cf26c4e648e19a52d9c422f65c1cd7e03ca63e926c5e92ea +b749501347e5ec07e13a79f0cb112f1b6534393458b3678a77f02ca89dca973fa7b30e55f0b25d8b92b97f6cb0120056 +94144b4a3ffc5eec6ba35ce9c245c148b39372d19a928e236a60e27d7bc227d18a8cac9983851071935d8ffb64b3a34f +92bb4f9f85bc8c028a3391306603151c6896673135f8a7aefedd27acb322c04ef5dac982fc47b455d6740023e0dd3ea3 +b9633a4a101461a782fc2aa092e9dbe4e2ad00987578f18cd7cf0021a909951d60fe79654eb7897806795f93c8ff4d1c +809f0196753024821b48a016eca5dbb449a7c55750f25981bb7a4b4c0e0846c09b8f6128137905055fc43a3f0deb4a74 +a27dc9cdd1e78737a443570194a03d89285576d3d7f3a3cf15cc55b3013e42635d4723e2e8fe1d0b274428604b630db9 +861f60f0462e04cd84924c36a28163def63e777318d00884ab8cb64c8df1df0bce5900342163edb60449296484a6c5bf +b7bc23fb4e14af4c4704a944253e760adefeca8caee0882b6bbd572c84434042236f39ae07a8f21a560f486b15d82819 +b9a6eb492d6dd448654214bd01d6dc5ff12067a11537ab82023fc16167507ee25eed2c91693912f4155d1c07ed9650b3 +97678af29c68f9a5e213bf0fb85c265303714482cfc4c2c00b4a1e8a76ed08834ee6af52357b143a1ca590fb0265ea5a +8a15b499e9eca5b6cac3070b5409e8296778222018ad8b53a5d1f6b70ad9bb10c68a015d105c941ed657bf3499299e33 +b487fefede2e8091f2c7bfe85770db2edff1db83d4effe7f7d87bff5ab1ace35e9b823a71adfec6737fede8d67b3c467 +8b51b916402aa2c437fce3bcad6dad3be8301a1a7eab9d163085b322ffb6c62abf28637636fe6114573950117fc92898 +b06a2106d031a45a494adec0881cb2f82275dff9dcdd2bc16807e76f3bec28a6734edd3d54f0be8199799a78cd6228ad +af0a185391bbe2315eb97feac98ad6dd2e5d931d012c621abd6e404a31cc188b286fef14871762190acf086482b2b5e2 +8e78ee8206506dd06eb7729e32fceda3bebd8924a64e4d8621c72e36758fda3d0001af42443851d6c0aea58562870b43 +a1ba52a569f0461aaf90b49b92be976c0e73ec4a2c884752ee52ffb62dd137770c985123d405dfb5de70692db454b54a +8d51b692fa1543c51f6b62b9acb8625ed94b746ef96c944ca02859a4133a5629da2e2ce84e111a7af8d9a5b836401c64 +a7a20d45044cf6492e0531d0b8b26ffbae6232fa05a96ed7f06bdb64c2b0f5ca7ec59d5477038096a02579e633c7a3ff +84df867b98c53c1fcd4620fef133ee18849c78d3809d6aca0fb6f50ff993a053a455993f216c42ab6090fa5356b8d564 +a7227c439f14c48e2577d5713c97a5205feb69acb0b449152842e278fa71e8046adfab468089c8b2288af1fc51fa945b +855189b3a105670779997690876dfaa512b4a25a24931a912c2f0f1936971d2882fb4d9f0b3d9daba77eaf660e9d05d5 +b5696bd6706de51c502f40385f87f43040a5abf99df705d6aac74d88c913b8ecf7a99a63d7a37d9bdf3a941b9e432ff5 +ab997beb0d6df9c98d5b49864ef0b41a2a2f407e1687dfd6089959757ba30ed02228940b0e841afe6911990c74d536c4 +b36b65f85546ebfdbe98823d5555144f96b4ab39279facd19c0de3b8919f105ba0315a0784dce4344b1bc62d8bb4a5a3 +b8371f0e4450788720ac5e0f6cd3ecc5413d33895083b2c168d961ec2b5c3de411a4cc0712481cbe8df8c2fa1a7af006 +98325d8026b810a8b7a114171ae59a57e8bbc9848e7c3df992efc523621729fd8c9f52114ce01d7730541a1ada6f1df1 +8d0e76dbd37806259486cd9a31bc8b2306c2b95452dc395546a1042d1d17863ef7a74c636b782e214d3aa0e8d717f94a +a4e15ead76da0214d702c859fb4a8accdcdad75ed08b865842bd203391ec4cba2dcc916455e685f662923b96ee0c023f +8618190972086ebb0c4c1b4a6c94421a13f378bc961cc8267a301de7390c5e73c3333864b3b7696d81148f9d4843fd02 +85369d6cc7342e1aa15b59141517d8db8baaaeb7ab9670f3ba3905353948d575923d283b7e5a05b13a30e7baf1208a86 +87c51ef42233c24a6da901f28c9a075d9ba3c625687c387ad6757b72ca6b5a8885e6902a3082da7281611728b1e45f26 +aa6348a4f71927a3106ad0ea8b02fc8d8c65531e4ab0bd0a17243e66f35afe252e40ab8eef9f13ae55a72566ffdaff5c +96a3bc976e9d03765cc3fee275fa05b4a84c94fed6b767e23ca689394501e96f56f7a97cffddc579a6abff632bf153be +97dbf96c6176379fdb2b888be4e757b2bca54e74124bd068d3fa1dbd82a011bbeb75079da38e0cd22a761fe208ecad9b +b70cf0a1d14089a4129ec4e295313863a59da8c7e26bf74cc0e704ed7f0ee4d7760090d0ddf7728180f1bf2c5ac64955 +882d664714cc0ffe53cbc9bef21f23f3649824f423c4dbad1f893d22c4687ab29583688699efc4d5101aa08b0c3e267a +80ecb7cc963e677ccaddbe3320831dd6ee41209acf4ed41b16dc4817121a3d86a1aac9c4db3d8c08a55d28257088af32 +a25ba667d832b145f9ce18c3f9b1bd00737aa36db020e1b99752c8ef7d27c6c448982bd8d352e1b6df266b8d8358a8d5 +83734841c13dee12759d40bdd209b277e743b0d08cc0dd1e0b7afd2d65bfa640400eefcf6be4a52e463e5b3d885eeac6 +848d16505b04804afc773aebabb51b36fd8aacfbb0e09b36c0d5d57df3c0a3b92f33e7d5ad0a7006ec46ebb91df42b8c +909a8d793f599e33bb9f1dc4792a507a97169c87cd5c087310bc05f30afcd247470b4b56dec59894c0fb1d48d39bb54e +8e558a8559df84a1ba8b244ece667f858095c50bb33a5381e60fcc6ba586b69693566d8819b4246a27287f16846c1dfa +84d6b69729f5aaa000cd710c2352087592cfbdf20d5e1166977e195818e593fa1a50d1e04566be23163a2523dc1612f1 +9536d262b7a42125d89f4f32b407d737ba8d9242acfc99d965913ab3e043dcac9f7072a43708553562cac4cba841df30 +9598548923ca119d6a15fd10861596601dd1dedbcccca97bb208cdc1153cf82991ea8cc17686fbaa867921065265970c +b87f2d4af6d026e4d2836bc3d390a4a18e98a6e386282ce96744603bab74974272e97ac2da281afa21885e2cbb3a8001 +991ece62bf07d1a348dd22191868372904b9f8cf065ae7aa4e44fd24a53faf6d851842e35fb472895963aa1992894918 +a8c53dea4c665b30e51d22ca6bc1bc78aaf172b0a48e64a1d4b93439b053877ec26cb5221c55efd64fa841bbf7d5aff4 +93487ec939ed8e740f15335b58617c3f917f72d07b7a369befd479ae2554d04deb240d4a14394b26192efae4d2f4f35d +a44793ab4035443f8f2968a40e043b4555960193ffa3358d22112093aadfe2c136587e4139ffd46d91ed4107f61ea5e0 +b13fe033da5f0d227c75927d3dacb06dbaf3e1322f9d5c7c009de75cdcba5e308232838785ab69a70f0bedea755e003f +970a29b075faccd0700fe60d1f726bdebf82d2cc8252f4a84543ebd3b16f91be42a75c9719a39c4096139f0f31393d58 +a4c3eb1f7160f8216fc176fb244df53008ff32f2892363d85254002e66e2de21ccfe1f3b1047589abee50f29b9d507e3 +8c552885eab04ba40922a8f0c3c38c96089c95ff1405258d3f1efe8d179e39e1295cbf67677894c607ae986e4e6b1fb0 +b3671746fa7f848c4e2ae6946894defadd815230b906b419143523cc0597bc1d6c0a4c1e09d49b66b4a2c11cde3a4de3 +937a249a95813a5e2ef428e355efd202e15a37d73e56cfb7e57ea9f943f2ce5ca8026f2f1fd25bf164ba89d07077d858 +83646bdf6053a04aa9e2f112499769e5bd5d0d10f2e13db3ca89bd45c0b3b7a2d752b7d137fb3909f9c62b78166c9339 +b4eac4b91e763666696811b7ed45e97fd78310377ebea1674b58a2250973f80492ac35110ed1240cd9bb2d17493d708c +82db43a99bc6573e9d92a3fd6635dbbb249ac66ba53099c3c0c8c8080b121dd8243cd5c6e36ba0a4d2525bae57f5c89c +a64d6a264a681b49d134c655d5fc7756127f1ee7c93d328820f32bca68869f53115c0d27fef35fe71f7bc4fdaed97348 +8739b7a9e2b4bc1831e7f04517771bc7cde683a5e74e052542517f8375a2f64e53e0d5ac925ef722327e7bb195b4d1d9 +8f337cdd29918a2493515ebb5cf702bbe8ecb23b53c6d18920cc22f519e276ca9b991d3313e2d38ae17ae8bdfa4f8b7e +b0edeab9850e193a61f138ef2739fc42ceec98f25e7e8403bfd5fa34a7bc956b9d0898250d18a69fa4625a9b3d6129da +a9920f26fe0a6d51044e623665d998745c9eca5bce12051198b88a77d728c8238f97d4196f26e43b24f8841500b998d0 +86e655d61502b979eeeeb6f9a7e1d0074f936451d0a1b0d2fa4fb3225b439a3770767b649256fe481361f481a8dbc276 +84d3b32fa62096831cc3bf013488a9f3f481dfe293ae209ed19585a03f7db8d961a7a9dd0db82bd7f62d612707575d9c +81c827826ec9346995ffccf62a241e3b2d32f7357acd1b1f8f7a7dbc97022d3eb51b8a1230e23ce0b401d2e535e8cd78 +94a1e40c151191c5b055b21e86f32e69cbc751dcbdf759a48580951834b96a1eed75914c0d19a38aefd21fb6c8d43d0c +ab890222b44bc21b71f7c75e15b6c6e16bb03371acce4f8d4353ff3b8fcd42a14026589c5ed19555a3e15e4d18bfc3a3 +accb0be851e93c6c8cc64724cdb86887eea284194b10e7a43c90528ed97e9ec71ca69c6fac13899530593756dd49eab2 +b630220aa9e1829c233331413ee28c5efe94ea8ea08d0c6bfd781955078b43a4f92915257187d8526873e6c919c6a1de +add389a4d358c585f1274b73f6c3c45b58ef8df11f9d11221f620e241bf3579fba07427b288c0c682885a700cc1fa28d +a9fe6ca8bf2961a3386e8b8dcecc29c0567b5c0b3bcf3b0f9169f88e372b80151af883871fc5229815f94f43a6f5b2b0 +ad839ae003b92b37ea431fa35998b46a0afc3f9c0dd54c3b3bf7a262467b13ff3c323ada1c1ae02ac7716528bdf39e3e +9356d3fd0edcbbb65713c0f2a214394f831b26f792124b08c5f26e7f734b8711a87b7c4623408da6a091c9aef1f6af3c +896b25b083c35ac67f0af3784a6a82435b0e27433d4d74cd6d1eafe11e6827827799490fb1c77c11de25f0d75f14e047 +8bfa019391c9627e8e5f05c213db625f0f1e51ec68816455f876c7e55b8f17a4f13e5aae9e3fb9e1cf920b1402ee2b40 +8ba3a6faa6a860a8f3ce1e884aa8769ceded86380a86520ab177ab83043d380a4f535fe13884346c5e51bee68da6ab41 +a8292d0844084e4e3bb7af92b1989f841a46640288c5b220fecfad063ee94e86e13d3d08038ec2ac82f41c96a3bfe14d +8229bb030b2fc566e11fd33c7eab7a1bb7b49fed872ea1f815004f7398cb03b85ea14e310ec19e1f23e0bdaf60f8f76c +8cfbf869ade3ec551562ff7f63c2745cc3a1f4d4dc853a0cd42dd5f6fe54228f86195ea8fe217643b32e9f513f34a545 +ac52a3c8d3270ddfe1b5630159da9290a5ccf9ccbdef43b58fc0a191a6c03b8a5974cf6e2bbc7bd98d4a40a3581482d7 +ab13decb9e2669e33a7049b8eca3ca327c40dea15ad6e0e7fa63ed506db1d258bc36ac88b35f65cae0984e937eb6575d +b5e748eb1a7a1e274ff0cc56311c198f2c076fe4b7e73e5f80396fe85358549df906584e6bb2c8195b3e2be7736850a5 +b5cb911325d8f963c41f691a60c37831c7d3bbd92736efa33d1f77a22b3fde7f283127256c2f47e197571e6fe0b46149 +8a01dc6ed1b55f26427a014faa347130738b191a06b800e32042a46c13f60b49534520214359d68eb2e170c31e2b8672 +a72fa874866e19b2efb8e069328362bf7921ec375e3bcd6b1619384c3f7ee980f6cf686f3544e9374ff54b4d17a1629c +8db21092f7c5f110fba63650b119e82f4b42a997095d65f08f8237b02dd66fdf959f788df2c35124db1dbd330a235671 +8c65d50433d9954fe28a09fa7ba91a70a590fe7ba6b3060f5e4be0f6cef860b9897fa935fb4ebc42133524eb071dd169 +b4614058e8fa21138fc5e4592623e78b8982ed72aa35ee4391b164f00c68d277fa9f9eba2eeefc890b4e86eba5124591 +ab2ad3a1bce2fbd55ca6b7c23786171fe1440a97d99d6df4d80d07dd56ac2d7203c294b32fc9e10a6c259381a73f24a1 +812ae3315fdc18774a8da3713a4679e8ed10b9405edc548c00cacbe25a587d32040566676f135e4723c5dc25df5a22e9 +a464b75f95d01e5655b54730334f443c8ff27c3cb79ec7af4b2f9da3c2039c609908cd128572e1fd0552eb597e8cef8d +a0db3172e93ca5138fe419e1c49a1925140999f6eff7c593e5681951ee0ec1c7e454c851782cbd2b8c9bc90d466e90e0 +806db23ba7d00b87d544eed926b3443f5f9c60da6b41b1c489fba8f73593b6e3b46ebfcab671ee009396cd77d5e68aa1 +8bfdf2c0044cc80260994e1c0374588b6653947b178e8b312be5c2a05e05767e98ea15077278506aee7df4fee1aaf89e +827f6558c16841b5592ff089c9c31e31eb03097623524394813a2e4093ad2d3f8f845504e2af92195aaa8a1679d8d692 +925c4f8eab2531135cd71a4ec88e7035b5eea34ba9d799c5898856080256b4a15ed1a746e002552e2a86c9c157e22e83 +a9f9a368f0e0b24d00a35b325964c85b69533013f9c2cfad9708be5fb87ff455210f8cb8d2ce3ba58ca3f27495552899 +8ac0d3bebc1cae534024187e7c71f8927ba8fcc6a1926cb61c2b6c8f26bb7831019e635a376146c29872a506784a4aaa +97c577be2cbbfdb37ad754fae9df2ada5fc5889869efc7e18a13f8e502fbf3f4067a509efbd46fd990ab47ce9a70f5a8 +935e7d82bca19f16614aa43b4a3474e4d20d064e4bfdf1cea2909e5c9ab72cfe3e54dc50030e41ee84f3588cebc524e9 +941aafc08f7c0d94cebfbb1f0aad5202c02e6e37f2c12614f57e727efa275f3926348f567107ee6d8914dd71e6060271 +af0fbc1ba05b4b5b63399686df3619968be5d40073de0313cbf5f913d3d4b518d4c249cdd2176468ccaa36040a484f58 +a0c414f23f46ca6d69ce74c6f8a00c036cb0edd098af0c1a7d39c802b52cfb2d5dbdf93fb0295453d4646e2af7954d45 +909cf39e11b3875bb63b39687ae1b5d1f5a15445e39bf164a0b14691b4ddb39a8e4363f584ef42213616abc4785b5d66 +a92bac085d1194fbd1c88299f07a061d0bdd3f980b663e81e6254dbb288bf11478c0ee880e28e01560f12c5ccb3c0103 +841705cd5cd76b943e2b7c5e845b9dd3c8defe8ef67e93078d6d5e67ade33ad4b0fd413bc196f93b0a4073c855cd97d4 +8e7eb8364f384a9161e81d3f1d52ceca9b65536ae49cc35b48c3e2236322ba4ae9973e0840802d9fa4f4d82ea833544f +aed3ab927548bc8bec31467ba80689c71a168e34f50dcb6892f19a33a099f5aa6b3f9cb79f5c0699e837b9a8c7f27efe +b8fbf7696210a36e20edabd77839f4dfdf50d6d015cdf81d587f90284a9bcef7d2a1ff520728d7cc69a4843d6c20dedd +a9d533769ce6830211c884ae50a82a7bf259b44ac71f9fb11f0296fdb3981e6b4c1753fe744647b247ebc433a5a61436 +8b4bdf90d33360b7f428c71cde0a49fb733badba8c726876945f58c620ce7768ae0e98fc8c31fa59d8955a4823336bb1 +808d42238e440e6571c59e52a35ae32547d502dc24fd1759d8ea70a7231a95859baf30b490a4ba55fa2f3aaa11204597 +85594701f1d2fee6dc1956bc44c7b31db93bdeec2f3a7d622c1a08b26994760773e3d57521a44cfd7e407ac3fd430429 +a66de045ce7173043a6825e9dc440ac957e2efb6df0a337f4f8003eb0c719d873a52e6eba3cb0d69d977ca37d9187674 +87a1c6a1fdff993fa51efa5c3ba034c079c0928a7d599b906336af7c2dcab9721ceaf3108c646490af9dff9a754f54b3 +926424223e462ceb75aed7c22ade8a7911a903b7e5dd4bc49746ddce8657f4616325cd12667d4393ac52cdd866396d0e +b5dc96106593b42b30f06f0b0a1e0c1aafc70432e31807252d3674f0b1ea5e58eac8424879d655c9488d85a879a3e572 +997ca0987735cc716507cb0124b1d266d218b40c9d8e0ecbf26a1d65719c82a637ce7e8be4b4815d307df717bde7c72a +92994d3f57a569b7760324bb5ae4e8e14e1633d175dab06aa57b8e391540e05f662fdc08b8830f489a063f59b689a688 +a8087fcc6aa4642cb998bea11facfe87eb33b90a9aa428ab86a4124ad032fc7d2e57795311a54ec9f55cc120ebe42df1 +a9bd7d1de6c0706052ca0b362e2e70e8c8f70f1f026ea189b4f87a08ce810297ebfe781cc8004430776c54c1a05ae90c +856d33282e8a8e33a3d237fb0a0cbabaf77ba9edf2fa35a831fdafcadf620561846aa6cbb6bdc5e681118e1245834165 +9524a7aa8e97a31a6958439c5f3339b19370f03e86b89b1d02d87e4887309dbbe9a3a8d2befd3b7ed5143c8da7e0a8ad +824fdf433e090f8acbd258ac7429b21f36f9f3b337c6d0b71d1416a5c88a767883e255b2888b7c906dd2e9560c4af24c +88c7fee662ca7844f42ed5527996b35723abffd0d22d4ca203b9452c639a5066031207a5ae763dbc0865b3299d19b1ec +919dca5c5595082c221d5ab3a5bc230f45da7f6dec4eb389371e142c1b9c6a2c919074842479c2844b72c0d806170c0c +b939be8175715e55a684578d8be3ceff3087f60fa875fff48e52a6e6e9979c955efef8ff67cfa2b79499ea23778e33b0 +873b6db725e7397d11bc9bed9ac4468e36619135be686790a79bc6ed4249058f1387c9a802ea86499f692cf635851066 +aeae06db3ec47e9e5647323fa02fac44e06e59b885ad8506bf71b184ab3895510c82f78b6b22a5d978e8218e7f761e9f +b99c0a8359c72ab88448bae45d4bf98797a26bca48b0d4460cd6cf65a4e8c3dd823970ac3eb774ae5d0cea4e7fadf33e +8f10c8ec41cdfb986a1647463076a533e6b0eec08520c1562401b36bb063ac972aa6b28a0b6ce717254e35940b900e3c +a106d9be199636d7add43b942290269351578500d8245d4aae4c083954e4f27f64740a3138a66230391f2d0e6043a8de +a469997908244578e8909ff57cffc070f1dbd86f0098df3cfeb46b7a085cfecc93dc69ee7cad90ff1dc5a34d50fe580c +a4ef087bea9c20eb0afc0ee4caba7a9d29dfa872137828c721391273e402fb6714afc80c40e98bbd8276d3836bffa080 +b07a013f73cd5b98dae0d0f9c1c0f35bff8a9f019975c4e1499e9bee736ca6fcd504f9bc32df1655ff333062382cff04 +b0a77188673e87cc83348c4cc5db1eecf6b5184e236220c8eeed7585e4b928db849944a76ec60ef7708ef6dac02d5592 +b1284b37e59b529f0084c0dacf0af6c0b91fc0f387bf649a8c74819debf606f7b07fc3e572500016fb145ec2b24e9f17 +97b20b5b4d6b9129da185adfbf0d3d0b0faeba5b9715f10299e48ea0521709a8296a9264ce77c275a59c012b50b6519a +b9d37e946fae5e4d65c1fbfacc8a62e445a1c9d0f882e60cca649125af303b3b23af53c81d7bac544fb7fcfc7a314665 +8e5acaac379f4bb0127efbef26180f91ff60e4c525bc9b798fc50dfaf4fe8a5aa84f18f3d3cfb8baead7d1e0499af753 +b0c0b8ab1235bf1cda43d4152e71efc1a06c548edb964eb4afceb201c8af24240bf8ab5cae30a08604e77432b0a5faf0 +8cc28d75d5c8d062d649cbc218e31c4d327e067e6dbd737ec0a35c91db44fbbd0d40ec424f5ed79814add16947417572 +95ae6219e9fd47efaa9cb088753df06bc101405ba50a179d7c9f7c85679e182d3033f35b00dbba71fdcd186cd775c52e +b5d28fa09f186ebc5aa37453c9b4d9474a7997b8ae92748ecb940c14868792292ac7d10ade01e2f8069242b308cf97e5 +8c922a0faa14cc6b7221f302df3342f38fc8521ec6c653f2587890192732c6da289777a6cd310747ea7b7d104af95995 +b9ad5f660b65230de54de535d4c0fcae5bc6b59db21dea5500fdc12eea4470fb8ea003690fdd16d052523418d5e01e8c +a39a9dd41a0ff78c82979483731f1cd68d3921c3e9965869662c22e02dde3877802e180ba93f06e7346f96d9fa9261d2 +8b32875977ec372c583b24234c27ed73aef00cdff61eb3c3776e073afbdeade548de9497c32ec6d703ff8ad0a5cb7fe4 +9644cbe755a5642fe9d26cfecf170d3164f1848c2c2e271d5b6574a01755f3980b3fc870b98cf8528fef6ecef4210c16 +81ea9d1fdd9dd66d60f40ce0712764b99da9448ae0b300f8324e1c52f154e472a086dda840cb2e0b9813dc8ce8afd4b5 +906aaa4a7a7cdf01909c5cfbc7ded2abc4b869213cbf7c922d4171a4f2e637e56f17020b852ad339d83b8ac92f111666 +939b5f11acbdeff998f2a080393033c9b9d8d5c70912ea651c53815c572d36ee822a98d6dfffb2e339f29201264f2cf4 +aba4898bf1ccea9b9e2df1ff19001e05891581659c1cbbde7ee76c349c7fc7857261d9785823c9463a8aea3f40e86b38 +83ca1a56b8a0be4820bdb5a9346357c68f9772e43f0b887729a50d2eb2a326bbcede676c8bf2e51d7c89bbd8fdb778a6 +94e86e9fe6addfe2c3ee3a547267ed921f4230d877a85bb4442c2d9350c2fa9a9c54e6fe662de82d1a2407e4ab1691c2 +a0cc3bdef671a59d77c6984338b023fa2b431b32e9ed2abe80484d73edc6540979d6f10812ecc06d4d0c5d4eaca7183c +b5343413c1b5776b55ea3c7cdd1f3af1f6bd802ea95effe3f2b91a523817719d2ecc3f8d5f3cc2623ace7e35f99ca967 +92085d1ed0ed28d8cabe3e7ff1905ed52c7ceb1eac5503760c52fb5ee3a726aba7c90b483c032acc3f166b083d7ec370 +8ec679520455275cd957fca8122724d287db5df7d29f1702a322879b127bff215e5b71d9c191901465d19c86c8d8d404 +b65eb2c63d8a30332eb24ee8a0c70156fc89325ebbb38bacac7cf3f8636ad8a472d81ccca80423772abc00192d886d8a +a9fe1c060b974bee4d590f2873b28635b61bfcf614e61ff88b1be3eee4320f4874e21e8d666d8ac8c9aba672efc6ecae +b3fe2a9a389c006a831dea7e777062df84b5c2803f9574d7fbe10b7e1c125817986af8b6454d6be9d931a5ac94cfe963 +95418ad13b734b6f0d33822d9912c4c49b558f68d08c1b34a0127fcfa666bcae8e6fda8832d2c75bb9170794a20e4d7c +a9a7df761e7f18b79494bf429572140c8c6e9d456c4d4e336184f3f51525a65eb9582bea1e601bdb6ef8150b7ca736a5 +a0de03b1e75edf7998c8c1ac69b4a1544a6fa675a1941950297917366682e5644a4bda9cdeedfaf9473d7fccd9080b0c +a61838af8d95c95edf32663a68f007d95167bf6e41b0c784a30b22d8300cfdd5703bd6d16e86396638f6db6ae7e42a85 +8866d62084d905c145ff2d41025299d8b702ac1814a7dec4e277412c161bc9a62fed735536789cb43c88693c6b423882 +91da22c378c81497fe363e7f695c0268443abee50f8a6625b8a41e865638a643f07b157ee566de09ba09846934b4e2d7 +941d21dd57c9496aa68f0c0c05507405fdd413acb59bc668ce7e92e1936c68ec4b065c3c30123319884149e88228f0b2 +a77af9b094bc26966ddf2bf9e1520c898194a5ccb694915950dadc204facbe3066d3d89f50972642d76b14884cfbaa21 +8e76162932346869f4618bde744647f7ab52ab498ad654bdf2a4feeb986ac6e51370841e5acbb589e38b6e7142bb3049 +b60979ace17d6937ece72e4f015da4657a443dd01cebc7143ef11c09e42d4aa8855999a65a79e2ea0067f31c9fc2ab0f +b3e2ffdd5ee6fd110b982fd4fad4b93d0fca65478f986d086eeccb0804960bfaa1919afa743c2239973ea65091fe57d2 +8ce0ce05e7d7160d44574011da687454dbd3c8b8290aa671731b066e2c82f8cf2d63cb8e932d78c6122ec610e44660e6 +ab005dd8d297045c39e2f72fb1c48edb501ccf3575d3d04b9817b3afee3f0bb0f3f53f64bda37d1d9cde545aae999bae +95bd7edb4c4cd60e3cb8a72558845a3cce6bb7032ccdf33d5a49ebb6ddf203bc3c79e7b7e550735d2d75b04c8b2441e8 +889953ee256206284094e4735dbbb17975bafc7c3cb94c9fbfee4c3e653857bfd49e818f64a47567f721b98411a3b454 +b188423e707640ab0e75a061e0b62830cde8afab8e1ad3dae30db69ffae4e2fc005bababbdcbd7213b918ed4f70e0c14 +a97e0fafe011abd70d4f99a0b36638b3d6e7354284588f17a88970ed48f348f88392779e9a038c6cbc9208d998485072 +87db11014a91cb9b63e8dfaa82cdebca98272d89eb445ee1e3ff9dbaf2b3fad1a03b888cffc128e4fe208ed0dddece0f +aad2e40364edd905d66ea4ac9d51f9640d6fda9a54957d26ba233809851529b32c85660fa401dbee3679ec54fa6dd966 +863e99336ca6edf03a5a259e59a2d0f308206e8a2fb320cfc0be06057366df8e0f94b33a28f574092736b3c5ada84270 +b34bcc56a057589f34939a1adc51de4ff6a9f4fee9c7fa9aa131e28d0cf0759a0c871b640162acdfbf91f3f1b59a3703 +935dd28f2896092995c5eff1618e5b6efe7a40178888d7826da9b0503c2d6e68a28e7fac1a334e166d0205f0695ef614 +b842cd5f8f5de5ca6c68cb4a5c1d7b451984930eb4cc18fd0934d52fdc9c3d2d451b1c395594d73bc3451432bfba653f +9014537885ce2debad736bc1926b25fdab9f69b216bf024f589c49dc7e6478c71d595c3647c9f65ff980b14f4bb2283b +8e827ccca1dd4cd21707140d10703177d722be0bbe5cac578db26f1ef8ad2909103af3c601a53795435b27bf95d0c9ed +8a0b8ad4d466c09d4f1e9167410dbe2edc6e0e6229d4b3036d30f85eb6a333a18b1c968f6ca6d6889bb08fecde017ef4 +9241ee66c0191b06266332dc9161dede384c4bb4e116dbd0890f3c3790ec5566da4568243665c4725b718ac0f6b5c179 +aeb4d5fad81d2b505d47958a08262b6f1b1de9373c2c9ba6362594194dea3e002ab03b8cbb43f867be83065d3d370f19 +8781bc83bb73f7760628629fe19e4714b494dbed444c4e4e4729b7f6a8d12ee347841a199888794c2234f51fa26fc2b9 +b58864f0acd1c2afa29367e637cbde1968d18589245d9936c9a489c6c495f54f0113ecdcbe4680ac085dd3c397c4d0c3 +94a24284afaeead61e70f3e30f87248d76e9726759445ca18cdb9360586c60cc9f0ec1c397f9675083e0b56459784e2e +aed358853f2b54dcbddf865e1816c2e89be12e940e1abfa661e2ee63ffc24a8c8096be2072fa83556482c0d89e975124 +b95374e6b4fc0765708e370bc881e271abf2e35c08b056a03b847e089831ef4fe3124b9c5849d9c276eb2e35b3daf264 +b834cdbcfb24c8f84bfa4c552e7fadc0028a140952fd69ed13a516e1314a4cd35d4b954a77d51a1b93e1f5d657d0315d +8fb6d09d23bfa90e7443753d45a918d91d75d8e12ec7d016c0dfe94e5c592ba6aaf483d2f16108d190822d955ad9cdc3 +aa315cd3c60247a6ad4b04f26c5404c2713b95972843e4b87b5a36a89f201667d70f0adf20757ebe1de1b29ae27dda50 +a116862dca409db8beff5b1ccd6301cdd0c92ca29a3d6d20eb8b87f25965f42699ca66974dd1a355200157476b998f3b +b4c2f5fe173c4dc8311b60d04a65ce1be87f070ac42e13cd19c6559a2931c6ee104859cc2520edebbc66a13dc7d30693 +8d4a02bf99b2260c334e7d81775c5cf582b00b0c982ce7745e5a90624919028278f5e9b098573bad5515ce7fa92a80c8 +8543493bf564ce6d97bd23be9bff1aba08bd5821ca834f311a26c9139c92a48f0c2d9dfe645afa95fec07d675d1fd53b +9344239d13fde08f98cb48f1f87d34cf6abe8faecd0b682955382a975e6eed64e863fa19043290c0736261622e00045c +aa49d0518f343005ca72b9e6c7dcaa97225ce6bb8b908ebbe7b1a22884ff8bfb090890364e325a0d414ad180b8f161d1 +907d7fd3e009355ab326847c4a2431f688627faa698c13c03ffdd476ecf988678407f029b8543a475dcb3dafdf2e7a9c +845f1f10c6c5dad2adc7935f5cd2e2b32f169a99091d4f1b05babe7317b9b1cdce29b5e62f947dc621b9acbfe517a258 +8f3be8e3b380ea6cdf9e9c237f5e88fd5a357e5ded80ea1fc2019810814de82501273b4da38916881125b6fa0cfd4459 +b9c7f487c089bf1d20c822e579628db91ed9c82d6ca652983aa16d98b4270c4da19757f216a71b9c13ddee3e6e43705f +8ba2d8c88ad2b872db104ea8ddbb006ec2f3749fd0e19298a804bb3a5d94de19285cc7fb19fee58a66f7851d1a66c39f +9375ecd3ed16786fe161af5d5c908f56eeb467a144d3bbddfc767e90065b7c94fc53431adebecba2b6c9b5821184d36e +a49e069bfadb1e2e8bff6a4286872e2a9765d62f0eaa4fcb0e5af4bbbed8be3510fb19849125a40a8a81d1e33e81c3eb +9522cc66757b386aa6b88619525c8ce47a5c346d590bb3647d12f991e6c65c3ab3c0cfc28f0726b6756c892eae1672be +a9a0f1f51ff877406fa83a807aeb17b92a283879f447b8a2159653db577848cc451cbadd01f70441e351e9ed433c18bc +8ff7533dcff6be8714df573e33f82cf8e9f2bcaaa43e939c4759d52b754e502717950de4b4252fb904560fc31dce94a4 +959724671e265a28d67c29d95210e97b894b360da55e4cf16e6682e7912491ed8ca14bfaa4dce9c25a25b16af580494f +92566730c3002f4046c737032487d0833c971e775de59fe02d9835c9858e2e3bc37f157424a69764596c625c482a2219 +a84b47ceff13ed9c3e5e9cdf6739a66d3e7c2bd8a6ba318fefb1a9aecf653bb2981da6733ddb33c4b0a4523acc429d23 +b4ddf571317e44f859386d6140828a42cf94994e2f1dcbcc9777f4eebbfc64fc1e160b49379acc27c4672b8e41835c5d +8ab95c94072b853d1603fdd0a43b30db617d13c1d1255b99075198e1947bfa5f59aed2b1147548a1b5e986cd9173d15c +89511f2eab33894fd4b3753d24249f410ff7263052c1fef6166fc63a79816656b0d24c529e45ccce6be28de6e375d916 +a0866160ca63d4f2be1b4ea050dac6b59db554e2ebb4e5b592859d8df339b46fd7cb89aaed0951c3ee540aee982c238a +8fcc5cbba1b94970f5ff2eb1922322f5b0aa7d918d4b380c9e7abfd57afd8b247c346bff7b87af82efbce3052511cd1b +99aeb2a5e846b0a2874cca02c66ed40d5569eb65ab2495bc3f964a092e91e1517941f2688e79f8cca49cd3674c4e06dc +b7a096dc3bad5ca49bee94efd884aa3ff5615cf3825cf95fbe0ce132e35f46581d6482fa82666c7ef5f1643eaee8f1ca +94393b1da6eaac2ffd186b7725eca582f1ddc8cdd916004657f8a564a7c588175cb443fc6943b39029f5bbe0add3fad8 +884b85fe012ccbcd849cb68c3ad832d83b3ef1c40c3954ffdc97f103b1ed582c801e1a41d9950f6bddc1d11f19d5ec76 +b00061c00131eded8305a7ce76362163deb33596569afb46fe499a7c9d7a0734c084d336b38d168024c2bb42b58e7660 +a439153ac8e6ca037381e3240e7ba08d056c83d7090f16ed538df25901835e09e27de2073646e7d7f3c65056af6e4ce7 +830fc9ca099097d1f38b90e6843dc86f702be9d20bdacc3e52cae659dc41df5b8d2c970effa6f83a5229b0244a86fe22 +b81ea2ffaaff2bb00dd59a9ab825ba5eed4db0d8ac9c8ed1a632ce8f086328a1cddd045fbe1ace289083c1325881b7e7 +b51ea03c58daf2db32c99b9c4789b183365168cb5019c72c4cc91ac30b5fb7311d3db76e6fa41b7cd4a8c81e2f6cdc94 +a4170b2c6d09ca5beb08318730419b6f19215ce6c631c854116f904be3bc30dd85a80c946a8ab054d3e307afaa3f8fbc +897cc42ff28971ff54d2a55dd6b35cfb8610ac902f3c06e3a5cea0e0a257e870c471236a8e84709211c742a09c5601a6 +a18f2e98d389dace36641621488664ecbb422088ab03b74e67009b8b8acacaaa24fdcf42093935f355207d934adc52a8 +92adcfb678cc2ba19c866f3f2b988fdcb4610567f3ab436cc0cb9acaf5a88414848d71133ebdbec1983e38e6190f1b5f +a86d43c2ce01b366330d3b36b3ca85f000c3548b8297e48478da1ee7d70d8576d4650cba7852ed125c0d7cb6109aa7f3 +8ed31ceed9445437d7732dce78a762d72ff32a7636bfb3fd7974b7ae15db414d8184a1766915244355deb354fbc5803b +9268f70032584f416e92225d65af9ea18c466ebc7ae30952d56a4e36fd9ea811dde0a126da9220ba3c596ec54d8a335e +9433b99ee94f2d3fbdd63b163a2bdf440379334c52308bd24537f7defd807145a062ff255a50d119a7f29f4b85d250e3 +90ce664f5e4628a02278f5cf5060d1a34f123854634b1870906e5723ac9afd044d48289be283b267d45fcbf3f4656aaf +aaf21c4d59378bb835d42ae5c5e5ab7a3c8c36a59e75997989313197752b79a472d866a23683b329ea69b048b87fa13e +b83c0589b304cec9ede549fde54f8a7c2a468c6657da8c02169a6351605261202610b2055c639b9ed2d5b8c401fb8f56 +9370f326ea0f170c2c05fe2c5a49189f20aec93b6b18a5572a818cd4c2a6adb359e68975557b349fb54f065d572f4c92 +ac3232fa5ce6f03fca238bef1ce902432a90b8afce1c85457a6bee5571c033d4bceefafc863af04d4e85ac72a4d94d51 +80d9ea168ff821b22c30e93e4c7960ce3ad3c1e6deeebedd342a36d01bd942419b187e2f382dbfd8caa34cca08d06a48 +a387a3c61676fb3381eefa2a45d82625635a666e999aba30e3b037ec9e040f414f9e1ad9652abd3bcad63f95d85038db +a1b229fe32121e0b391b0f6e0180670b9dc89d79f7337de4c77ea7ad0073e9593846f06797c20e923092a08263204416 +92164a9d841a2b828cedf2511213268b698520f8d1285852186644e9a0c97512cafa4bfbe29af892c929ebccd102e998 +82ee2fa56308a67c7db4fd7ef539b5a9f26a1c2cc36da8c3206ba4b08258fbb3cec6fe5cdbd111433fb1ba2a1e275927 +8c77bfe9e191f190a49d46f05600603fa42345592539b82923388d72392404e0b29a493a15e75e8b068dddcd444c2928 +80b927f93ccf79dcf5c5b20bcf5a7d91d7a17bc0401bb7cc9b53a6797feac31026eb114257621f5a64a52876e4474cc1 +b6b68b6501c37804d4833d5a063dd108a46310b1400549074e3cac84acc6d88f73948b7ad48d686de89c1ec043ae8c1a +ab3da00f9bdc13e3f77624f58a3a18fc3728956f84b5b549d62f1033ae4b300538e53896e2d943f160618e05af265117 +b6830e87233b8eace65327fdc764159645b75d2fd4024bf8f313b2dd5f45617d7ecfb4a0b53ccafb5429815a9a1adde6 +b9251cfe32a6dc0440615aadcd98b6b1b46e3f4e44324e8f5142912b597ee3526bea2431e2b0282bb58f71be5b63f65e +af8d70711e81cdddfb39e67a1b76643292652584c1ce7ce4feb1641431ad596e75c9120e85f1a341e7a4da920a9cdd94 +98cd4e996594e89495c078bfd52a4586b932c50a449a7c8dfdd16043ca4cda94dafbaa8ad1b44249c99bbcc52152506e +b9fc6d1c24f48404a4a64fbe3e43342738797905db46e4132aee5f086aaa4c704918ad508aaefa455cfe1b36572e6242 +a365e871d30ba9291cedaba1be7b04e968905d003e9e1af7e3b55c5eb048818ae5b913514fb08b24fb4fbdccbb35d0b8 +93bf99510971ea9af9f1e364f1234c898380677c8e8de9b0dd24432760164e46c787bc9ec42a7ad450500706cf247b2d +b872f825a5b6e7b9c7a9ddfeded3516f0b1449acc9b4fd29fc6eba162051c17416a31e5be6d3563f424d28e65bab8b8f +b06b780e5a5e8eb4f4c9dc040f749cf9709c8a4c9ef15e925f442b696e41e5095db0778a6c73bcd329b265f2c6955c8b +848f1a981f5fc6cd9180cdddb8d032ad32cdfa614fc750d690dbae36cc0cd355cbf1574af9b3ffc8b878f1b2fafb9544 +a03f48cbff3e9e8a3a655578051a5ae37567433093ac500ed0021c6250a51b767afac9bdb194ee1e3eac38a08c0eaf45 +b5be78ce638ff8c4aa84352b536628231d3f7558c5be3bf010b28feac3022e64691fa672f358c8b663904aebe24a54ed +a9d4da70ff676fa55d1728ba6ab03b471fa38b08854d99e985d88c2d050102d8ccffbe1c90249a5607fa7520b15fe791 +8fe9f7092ffb0b69862c8e972fb1ecf54308c96d41354ed0569638bb0364f1749838d6d32051fff1599112978c6e229c +ae6083e95f37770ecae0df1e010456f165d96cfe9a7278c85c15cffd61034081ce5723e25e2bede719dc9341ec8ed481 +a260891891103089a7afbd9081ea116cfd596fd1015f5b65e10b0961eb37fab7d09c69b7ce4be8bf35e4131848fb3fe4 +8d729fa32f6eb9fd2f6a140bef34e8299a2f3111bffd0fe463aa8622c9d98bfd31a1df3f3e87cd5abc52a595f96b970e +a30ec6047ae4bc7da4daa7f4c28c93aedb1112cfe240e681d07e1a183782c9ff6783ac077c155af23c69643b712a533f +ac830726544bfe7b5467339e5114c1a75f2a2a8d89453ce86115e6a789387e23551cd64620ead6283dfa4538eb313d86 +8445c135b7a48068d8ed3e011c6d818cfe462b445095e2fbf940301e50ded23f272d799eea47683fc027430ce14613ef +95785411715c9ae9d8293ce16a693a2aa83e3cb1b4aa9f76333d0da2bf00c55f65e21e42e50e6c5772ce213dd7b4f7a0 +b273b024fa18b7568c0d1c4d2f0c4e79ec509dafac8c5951f14192d63ddbcf2d8a7512c1c1b615cc38fa3e336618e0c5 +a78b9d3ea4b6a90572eb27956f411f1d105fdb577ee2ffeec9f221da9b45db84bfe866af1f29597220c75e0c37a628d8 +a4be2bf058c36699c41513c4d667681ce161a437c09d81383244fc55e1c44e8b1363439d0cce90a3e44581fb31d49493 +b6eef13040f17dd4eba22aaf284d2f988a4a0c4605db44b8d2f4bf9567ac794550b543cc513c5f3e2820242dd704152e +87eb00489071fa95d008c5244b88e317a3454652dcb1c441213aa16b28cd3ecaa9b22fec0bdd483c1df71c37119100b1 +92d388acdcb49793afca329cd06e645544d2269234e8b0b27d2818c809c21726bc9cf725651b951e358a63c83dedee24 +ae27e219277a73030da27ab5603c72c8bd81b6224b7e488d7193806a41343dff2456132274991a4722fdb0ef265d04cd +97583e08ecb82bbc27c0c8476d710389fa9ffbead5c43001bd36c1b018f29faa98de778644883e51870b69c5ffb558b5 +90a799a8ce73387599babf6b7da12767c0591cadd36c20a7990e7c05ea1aa2b9645654ec65308ee008816623a2757a6a +a1b47841a0a2b06efd9ab8c111309cc5fc9e1d5896b3e42ed531f6057e5ade8977c29831ce08dbda40348386b1dcc06d +b92b8ef59bbddb50c9457691bc023d63dfcc54e0fd88bd5d27a09e0d98ac290fc90e6a8f6b88492043bf7c87fac8f3e4 +a9d6240b07d62e22ec8ab9b1f6007c975a77b7320f02504fc7c468b4ee9cfcfd945456ff0128bc0ef2174d9e09333f8d +8e96534c94693226dc32bca79a595ca6de503af635f802e86442c67e77564829756961d9b701187fe91318da515bf0e6 +b6ba290623cd8dd5c2f50931c0045d1cfb0c30877bc8fe58cbc3ff61ee8da100045a39153916efa1936f4aee0892b473 +b43baa7717fac02d4294f5b3bb5e58a65b3557747e3188b482410388daac7a9c177f762d943fd5dcf871273921213da8 +b9cf00f8fb5e2ef2b836659fece15e735060b2ea39b8e901d3dcbdcf612be8bf82d013833718c04cd46ffaa70b85f42e +8017d0c57419e414cbba504368723e751ef990cc6f05dad7b3c2de6360adc774ad95512875ab8337d110bf39a42026fa +ae7401048b838c0dcd4b26bb6c56d79d51964a0daba780970b6c97daee4ea45854ea0ac0e4139b3fe60dac189f84df65 +887b237b0cd0f816b749b21db0b40072f9145f7896c36916296973f9e6990ede110f14e5976c906d08987c9836cca57f +a88c3d5770148aee59930561ca1223aceb2c832fb5417e188dca935905301fc4c6c2c9270bc1dff7add490a125eb81c6 +b6cf9b02c0cd91895ad209e38c54039523f137b5848b9d3ad33ae43af6c20c98434952db375fe378de7866f2d0e8b18a +84ef3d322ff580c8ad584b1fe4fe346c60866eb6a56e982ba2cf3b021ecb1fdb75ecc6c29747adda86d9264430b3f816 +a0561c27224baf0927ad144cb71e31e54a064c598373fcf0d66aebf98ab7af1d8e2f343f77baefff69a6da750a219e11 +aa5cc43f5b8162b016f5e1b61214c0c9d15b1078911c650b75e6cdfb49b85ee04c6739f5b1687d15908444f691f732de +ad4ac099b935589c7b8fdfdf3db332b7b82bb948e13a5beb121ebd7db81a87d278024a1434bcf0115c54ca5109585c3d +8a00466abf3f109a1dcd19e643b603d3af23d42794ef8ca2514dd507ecea44a031ac6dbc18bd02f99701168b25c1791e +b00b5900dfad79645f8bee4e5adc7b84eb22e5b1e67df77ccb505b7fc044a6c08a8ea5faca662414eb945f874f884cea +950e204e5f17112250b22ea6bb8423baf522fc0af494366f18fe0f949f51d6e6812074a80875cf1ed9c8e7420058d541 +91e5cbf8bb1a1d50c81608c9727b414d0dd2fb467ebc92f100882a3772e54f94979cfdf8e373fdef7c7fcdd60fec9e00 +a093f6a857b8caaff80599c2e89c962b415ecbaa70d8fd973155fa976a284c6b29a855f5f7a3521134d00d2972755188 +b4d55a3551b00da54cc010f80d99ddd2544bde9219a3173dfaadf3848edc7e4056ab532fb75ac26f5f7141e724267663 +a03ea050fc9b011d1b04041b5765d6f6453a93a1819cd9bd6328637d0b428f08526466912895dcc2e3008ee58822e9a7 +99b12b3665e473d01bc6985844f8994fb65cb15745024fb7af518398c4a37ff215da8f054e8fdf3286984ae36a73ca5e +9972c7e7a7fb12e15f78d55abcaf322c11249cd44a08f62c95288f34f66b51f146302bce750ff4d591707075d9123bd2 +a64b4a6d72354e596d87cda213c4fc2814009461570ccb27d455bbe131f8d948421a71925425b546d8cf63d5458cd64b +91c215c73b195795ede2228b7ed1f6e37892e0c6b0f4a0b5a16c57aa1100c84df9239054a173b6110d6c2b7f4bf1ce52 +88807198910ec1303480f76a3683870246a995e36adaeadc29c22f0bdba8152fe705bd070b75de657b04934f7d0ccf80 +b37c0026c7b32eb02cacac5b55cb5fe784b8e48b2945c64d3037af83ece556a117f0ff053a5968c2f5fa230e291c1238 +94c768384ce212bc2387e91ce8b45e4ff120987e42472888a317abc9dcdf3563b62e7a61c8e98d7cdcbe272167d91fc6 +a10c2564936e967a390cb14ef6e8f8b04ea9ece5214a38837eda09e79e0c7970b1f83adf017c10efd6faa8b7ffa2c567 +a5085eed3a95f9d4b1269182ea1e0d719b7809bf5009096557a0674bde4201b0ddc1f0f16a908fc468846b3721748ce3 +87468eb620b79a0a455a259a6b4dfbc297d0d53336537b771254dd956b145dc816b195b7002647ea218552e345818a3f +ace2b77ffb87366af0a9cb5d27d6fc4a14323dbbf1643f5f3c4559306330d86461bb008894054394cbfaefeaa0bc2745 +b27f56e840a54fbd793f0b7a7631aa4cee64b5947e4382b2dfb5eb1790270288884c2a19afebe5dc0c6ef335d4531c1c +876e438633931f7f895062ee16c4b9d10428875f7bc79a8e156a64d379a77a2c45bf5430c5ab94330f03da352f1e9006 +a2512a252587d200d2092b44c914df54e04ff8bcef36bf631f84bde0cf5a732e3dc7f00f662842cfd74b0b0f7f24180e +827f1bc8f54a35b7a4bd8154f79bcc055e45faed2e74adf7cf21cca95df44d96899e847bd70ead6bb27b9c0ed97bbd8b +a0c92cf5a9ed843714f3aea9fe7b880f622d0b4a3bf66de291d1b745279accf6ba35097849691370f41732ba64b5966b +a63f5c1e222775658421c487b1256b52626c6f79cb55a9b7deb2352622cedffb08502042d622eb3b02c97f9c09f9c957 +8cc093d52651e65fb390e186db6cc4de559176af4624d1c44cb9b0e836832419dacac7b8db0627b96288977b738d785d +aa7b6a17dfcec146134562d32a12f7bd7fe9522e300859202a02939e69dbd345ed7ff164a184296268f9984f9312e8fc +8ac76721f0d2b679f023d06cbd28c85ae5f4b43c614867ccee88651d4101d4fd352dbdb65bf36bfc3ebc0109e4b0c6f9 +8d350f7c05fc0dcd9a1170748846fb1f5d39453e4cb31e6d1457bed287d96fc393b2ecc53793ca729906a33e59c6834a +b9913510dfc5056d7ec5309f0b631d1ec53e3a776412ada9aefdaf033c90da9a49fdde6719e7c76340e86599b1f0eec2 +94955626bf4ce87612c5cfffcf73bf1c46a4c11a736602b9ba066328dc52ad6d51e6d4f53453d4ed55a51e0aad810271 +b0fcab384fd4016b2f1e53f1aafd160ae3b1a8865cd6c155d7073ecc1664e05b1d8bca1def39c158c7086c4e1103345e +827de3f03edfbde08570b72de6662c8bfa499b066a0a27ebad9b481c273097d17a5a0a67f01553da5392ec3f149b2a78 +ab7940384c25e9027c55c40df20bd2a0d479a165ced9b1046958353cd69015eeb1e44ed2fd64e407805ba42df10fc7bf +8ad456f6ff8cd58bd57567d931f923d0c99141978511b17e03cab7390a72b9f62498b2893e1b05c7c22dd274e9a31919 +ac75399e999effe564672db426faa17a839e57c5ef735985c70cd559a377adec23928382767b55ed5a52f7b11b54b756 +b17f975a00b817299ac7af5f2024ea820351805df58b43724393bfb3920a8cd747a3bbd4b8286e795521489db3657168 +a2bed800a6d95501674d9ee866e7314063407231491d794f8cf57d5be020452729c1c7cefd8c50dc1540181f5caab248 +9743f5473171271ffdd3cc59a3ae50545901a7b45cd4bc3570db487865f3b73c0595bebabbfe79268809ee1862e86e4a +b7eab77c2d4687b60d9d7b04e842b3880c7940140012583898d39fcc22d9b9b0a9be2c2e3788b3e6f30319b39c338f09 +8e2b8f797a436a1b661140e9569dcf3e1eea0a77c7ff2bc4ff0f3e49af04ed2de95e255df8765f1d0927fb456a9926b1 +8aefea201d4a1f4ff98ffce94e540bb313f2d4dfe7e9db484a41f13fc316ed02b282e1acc9bc6f56cad2dc2e393a44c9 +b950c17c0e5ca6607d182144aa7556bb0efe24c68f06d79d6413a973b493bfdf04fd147a4f1ab03033a32004cc3ea66f +b7b8dcbb179a07165f2dc6aa829fad09f582a71b05c3e3ea0396bf9e6fe73076f47035c031c2101e8e38e0d597eadd30 +a9d77ed89c77ec1bf8335d08d41c3c94dcca9fd1c54f22837b4e54506b212aa38d7440126c80648ab7723ff18e65ed72 +a819d6dfd4aef70e52b8402fe5d135f8082d40eb7d3bb5c4d7997395b621e2bb10682a1bad2c9caa33dd818550fc3ec6 +8f6ee34128fac8bbf13ce2d68b2bb363eb4fd65b297075f88e1446ddeac242500eeb4ef0735e105882ff5ba8c44c139b +b4440e48255c1644bcecf3a1e9958f1ec4901cb5b1122ee5b56ffd02cad1c29c4266999dbb85aa2605c1b125490074d4 +a43304a067bede5f347775d5811cf65a6380a8d552a652a0063580b5c5ef12a0867a39c7912fa219e184f4538eba1251 +a891ad67a790089ffc9f6d53e6a3d63d3556f5f693e0cd8a7d0131db06fd4520e719cfcc3934f0a8f62a95f90840f1d4 +aea6df8e9bb871081aa0fc5a9bafb00be7d54012c5baf653791907d5042a326aeee966fd9012a582cc16695f5baf7042 +8ffa2660dc52ed1cd4eff67d6a84a8404f358a5f713d04328922269bee1e75e9d49afeec0c8ad751620f22352a438e25 +87ec6108e2d63b06abed350f8b363b7489d642486f879a6c3aa90e5b0f335efc2ff2834eef9353951a42136f8e6a1b32 +865619436076c2760d9e87ddc905023c6de0a8d56eef12c98a98c87837f2ca3f27fd26a2ad752252dbcbe2b9f1d5a032 +980437dce55964293cb315c650c5586ffd97e7a944a83f6618af31c9d92c37b53ca7a21bb5bc557c151b9a9e217e7098 +95d128fc369df4ad8316b72aea0ca363cbc7b0620d6d7bb18f7076a8717a6a46956ff140948b0cc4f6d2ce33b5c10054 +8c7212d4a67b9ec70ebbca04358ad2d36494618d2859609163526d7b3acc2fc935ca98519380f55e6550f70a9bc76862 +893a2968819401bf355e85eee0f0ed0406a6d4a7d7f172d0017420f71e00bb0ba984f6020999a3cdf874d3cd8ebcd371 +9103c1af82dece25d87274e89ea0acd7e68c2921c4af3d8d7c82ab0ed9990a5811231b5b06113e7fa43a6bd492b4564f +99cfd87a94eab7d35466caa4ed7d7bb45e5c932b2ec094258fb14bf205659f83c209b83b2f2c9ccb175974b2a33e7746 +874b6b93e4ee61be3f00c32dd84c897ccd6855c4b6251eb0953b4023634490ed17753cd3223472873cbc6095b2945075 +84a32c0dc4ea60d33aac3e03e70d6d639cc9c4cc435c539eff915017be3b7bdaba33349562a87746291ebe9bc5671f24 +a7057b24208928ad67914e653f5ac1792c417f413d9176ba635502c3f9c688f7e2ee81800d7e3dc0a340c464da2fd9c5 +a03fb9ed8286aacfa69fbd5d953bec591c2ae4153400983d5dbb6cd9ea37fff46ca9e5cceb9d117f73e9992a6c055ad2 +863b2de04e89936c9a4a2b40380f42f20aefbae18d03750fd816c658aee9c4a03df7b12121f795c85d01f415baaeaa59 +8526eb9bd31790fe8292360d7a4c3eed23be23dd6b8b8f01d2309dbfdc0cfd33ad1568ddd7f8a610f3f85a9dfafc6a92 +b46ab8c5091a493d6d4d60490c40aa27950574a338ea5bbc045be3a114af87bdcb160a8c80435a9b7ad815f3cb56a3f3 +aeadc47b41a8d8b4176629557646202f868b1d728b2dda58a347d937e7ffc8303f20d26d6c00b34c851b8aeec547885d +aebb19fc424d72c1f1822aa7adc744cd0ef7e55727186f8df8771c784925058c248406ebeeaf3c1a9ee005a26e9a10c6 +8ff96e81c1a4a2ab1b4476c21018fae0a67e92129ee36120cae8699f2d7e57e891f5c624902cb1b845b944926a605cc3 +8251b8d2c43fadcaa049a9e7aff838dae4fb32884018d58d46403ac5f3beb5c518bfd45f03b8abb710369186075eb71c +a8b2a64f865f51a5e5e86a66455c093407933d9d255d6b61e1fd81ffafc9538d73caaf342338a66ba8ee166372a3d105 +aad915f31c6ba7fdc04e2aaac62e84ef434b7ee76a325f07dc430d12c84081999720181067b87d792efd0117d7ee1eab +a13db3bb60389883fd41d565c54fb5180d9c47ce2fe7a169ae96e01d17495f7f4fa928d7e556e7c74319c4c25d653eb2 +a4491b0198459b3f552855d680a59214eb74e6a4d6c5fa3b309887dc50ebea2ecf6d26c040550f7dc478b452481466fb +8f017f13d4b1e3f0c087843582b52d5f8d13240912254d826dd11f8703a99a2f3166dfbdfdffd9a3492979d77524276b +96c3d5dcd032660d50d7cd9db2914f117240a63439966162b10c8f1f3cf74bc83b0f15451a43b31dbd85e4a7ce0e4bb1 +b479ec4bb79573d32e0ec93b92bdd7ec8c26ddb5a2d3865e7d4209d119fd3499eaac527615ffac78c440e60ef3867ae0 +b2c49c4a33aa94b52b6410b599e81ff15490aafa7e43c8031c865a84e4676354a9c81eb4e7b8be6825fdcefd1e317d44 +906dc51d6a90c089b6704b47592805578a6eed106608eeb276832f127e1b8e858b72e448edcbefb497d152447e0e68ff +b0e81c63b764d7dfbe3f3fddc9905aef50f3633e5d6a4af6b340495124abedcff5700dfd1577bbbed7b6bf97d02719cb +9304c64701e3b4ed6d146e48a881f7d83a17f58357cca0c073b2bb593afd2d94f6e2a7a1ec511d0a67ad6ff4c3be5937 +b6fdbd12ba05aa598d80b83f70a15ef90e5cba7e6e75fa038540ee741b644cd1f408a6cecfd2a891ef8d902de586c6b5 +b80557871a6521b1b3c74a1ba083ae055b575df607f1f7b04c867ba8c8c181ea68f8d90be6031f4d25002cca27c44da2 +aa7285b8e9712e06b091f64163f1266926a36607f9d624af9996856ed2aaf03a580cb22ce407d1ade436c28b44ca173f +8148d72b975238b51e6ea389e5486940d22641b48637d7dfadfa603a605bfc6d74a016480023945d0b85935e396aea5d +8a014933a6aea2684b5762af43dcf4bdbb633cd0428d42d71167a2b6fc563ece5e618bff22f1db2ddb69b845b9a2db19 +990d91740041db770d0e0eb9d9d97d826f09fd354b91c41e0716c29f8420e0e8aac0d575231efba12fe831091ec38d5a +9454d0d32e7e308ddec57cf2522fb1b67a2706e33fb3895e9e1f18284129ab4f4c0b7e51af25681d248d7832c05eb698 +a5bd434e75bac105cb3e329665a35bce6a12f71dd90c15165777d64d4c13a82bceedb9b48e762bd24034e0fc9fbe45f4 +b09e3b95e41800d4dc29c6ffdaab2cd611a0050347f6414f154a47ee20ee59bf8cf7181454169d479ebce1eb5c777c46 +b193e341d6a047d15eea33766d656d807b89393665a783a316e9ba10518e5515c8e0ade3d6e15641d917a8a172a5a635 +ade435ec0671b3621dde69e07ead596014f6e1daa1152707a8c18877a8b067bde2895dd47444ffa69db2bbef1f1d8816 +a7fd3d6d87522dfc56fb47aef9ce781a1597c56a8bbfd796baba907afdc872f753d732bfda1d3402aee6c4e0c189f52d +a298cb4f4218d0464b2fab393e512bbc477c3225aa449743299b2c3572f065bc3a42d07e29546167ed9e1b6b3b3a3af3 +a9ee57540e1fd9c27f4f0430d194b91401d0c642456c18527127d1f95e2dba41c2c86d1990432eb38a692fda058fafde +81d6c1a5f93c04e6d8e5a7e0678c1fc89a1c47a5c920bcd36180125c49fcf7c114866b90e90a165823560b19898a7c16 +a4b7a1ec9e93c899b9fd9aaf264c50e42c36c0788d68296a471f7a3447af4dbc81e4fa96070139941564083ec5b5b5a1 +b3364e327d381f46940c0e11e29f9d994efc6978bf37a32586636c0070b03e4e23d00650c1440f448809e1018ef9f6d8 +8056e0913a60155348300e3a62e28b5e30629a90f7dd4fe11289097076708110a1d70f7855601782a3cdc5bdb1ca9626 +b4980fd3ea17bac0ba9ee1c470b17e575bb52e83ebdd7d40c93f4f87bebeaff1c8a679f9d3d09d635f068d37d5bd28bd +905a9299e7e1853648e398901dfcd437aa575c826551f83520df62984f5679cb5f0ea86aa45ed3e18b67ddc0dfafe809 +ab99553bf31a84f2e0264eb34a08e13d8d15e2484aa9352354becf9a15999c76cc568d68274b70a65e49703fc23540d0 +a43681597bc574d2dae8964c9a8dc1a07613d7a1272bdcb818d98c85d44e16d744250c33f3b5e4d552d97396b55e601f +a54e5a31716fccb50245898c99865644405b8dc920ded7a11f3d19bdc255996054b268e16f2e40273f11480e7145f41e +8134f3ad5ef2ad4ba12a8a4e4d8508d91394d2bcdc38b7c8c8c0b0a820357ac9f79d286c65220f471eb1adca1d98fc68 +94e2f755e60471578ab2c1adb9e9cea28d4eec9b0e92e0140770bca7002c365fcabfe1e5fb4fe6cfe79a0413712aa3ef +ad48f8d0ce7eb3cc6e2a3086ad96f562e5bed98a360721492ae2e74dc158586e77ec8c35d5fd5927376301b7741bad2b +8614f0630bdd7fbad3a31f55afd9789f1c605dc85e7dc67e2edfd77f5105f878bb79beded6e9f0b109e38ea7da67e8d5 +9804c284c4c5e77dabb73f655b12181534ca877c3e1e134aa3f47c23b7ec92277db34d2b0a5d38d2b69e5d1c3008a3e3 +a51b99c3088e473afdaa9e0a9f7e75a373530d3b04e44e1148da0726b95e9f5f0c7e571b2da000310817c36f84b19f7f +ac4ff909933b3b76c726b0a382157cdc74ab851a1ac6cef76953c6444441804cc43abb883363f416592e8f6cfbc4550b +ae7d915eb9fc928b65a29d6edbc75682d08584d0014f7bcf17d59118421ae07d26a02137d1e4de6938bcd1ab8ef48fad +852f7e453b1af89b754df6d11a40d5d41ea057376e8ecacd705aacd2f917457f4a093d6b9a8801837fa0f62986ad7149 +92c6bf5ada5d0c3d4dd8058483de36c215fa98edab9d75242f3eff9db07c734ad67337da6f0eefe23a487bf75a600dee +a2b42c09d0db615853763552a48d2e704542bbd786aae016eb58acbf6c0226c844f5fb31e428cb6450b9db855f8f2a6f +880cc07968266dbfdcfbc21815cd69e0eddfee239167ac693fb0413912d816f2578a74f7716eecd6deefa68c6eccd394 +b885b3ace736cd373e8098bf75ba66fa1c6943ca1bc4408cd98ac7074775c4478594f91154b8a743d9c697e1b29f5840 +a51ce78de512bd87bfa0835de819941dffbf18bec23221b61d8096fc9436af64e0693c335b54e7bfc763f287bdca2db6 +a3c76166a3bdb9b06ef696e57603b58871bc72883ee9d45171a30fe6e1d50e30bc9c51b4a0f5a7270e19a77b89733850 +acefc5c6f8a1e7c24d7b41e0fc7f6f3dc0ede6cf3115ffb9a6e54b1d954cbca9bda8ad7a084be9be245a1b8e9770d141 +b420ed079941842510e31cfad117fa11fb6b4f97dfbc6298cb840f27ebaceba23eeaf3f513bcffbf5e4aae946310182d +95c3bb5ef26c5ed2f035aa5d389c6b3c15a6705b9818a3fefaed28922158b35642b2e8e5a1a620fdad07e75ad4b43af4 +825149f9081ecf07a2a4e3e8b5d21bade86c1a882475d51c55ee909330b70c5a2ac63771c8600c6f38df716af61a3ea1 +873b935aae16d9f08adbc25353cee18af2f1b8d5f26dec6538d6bbddc515f2217ed7d235dcfea59ae61b428798b28637 +9294150843a2bedcedb3bb74c43eb28e759cf9499582c5430bccefb574a8ddd4f11f9929257ff4c153990f9970a2558f +b619563a811cc531da07f4f04e5c4c6423010ff9f8ed7e6ec9449162e3d501b269fb1c564c09c0429431879b0f45df02 +91b509b87eb09f007d839627514658c7341bc76d468920fe8a740a8cb96a7e7e631e0ea584a7e3dc1172266f641d0f5c +8b8aceace9a7b9b4317f1f01308c3904d7663856946afbcea141a1c615e21ccad06b71217413e832166e9dd915fbe098 +87b3b36e725833ea0b0f54753c3728c0dbc87c52d44d705ffc709f2d2394414c652d3283bab28dcce09799504996cee0 +b2670aad5691cbf308e4a6a77a075c4422e6cbe86fdba24e9f84a313e90b0696afb6a067eebb42ba2d10340d6a2f6e51 +876784a9aff3d54faa89b2bacd3ff5862f70195d0b2edc58e8d1068b3c9074c0da1cfa23671fe12f35e33b8a329c0ccd +8b48b9e758e8a8eae182f5cbec96f67d20cca6d3eee80a2d09208eb1d5d872e09ef23d0df8ebbb9b01c7449d0e3e3650 +b79303453100654c04a487bdcadc9e3578bc80930c489a7069a52e8ca1dba36c492c8c899ce025f8364599899baa287d +961b35a6111da54ece6494f24dacd5ea46181f55775b5f03df0e370c34a5046ac2b4082925855325bb42bc2a2c98381d +a31feb1be3f5a0247a1f7d487987eb622e34fca817832904c6ee3ee60277e5847945a6f6ea1ac24542c72e47bdf647df +a12a2aa3e7327e457e1aae30e9612715dd2cfed32892c1cd6dcda4e9a18203af8a44afb46d03b2eed89f6b9c5a2c0c23 +a08265a838e69a2ca2f80fead6ccf16f6366415b920c0b22ee359bcd8d4464ecf156f400a16a7918d52e6d733dd64211 +b723d6344e938d801cca1a00032af200e541d4471fd6cbd38fb9130daa83f6a1dffbbe7e67fc20f9577f884acd7594b2 +a6733d83ec78ba98e72ddd1e7ff79b7adb0e559e256760d0c590a986e742445e8cdf560d44b29439c26d87edd0b07c8c +a61c2c27d3f7b9ff4695a17afedf63818d4bfba390507e1f4d0d806ce8778d9418784430ce3d4199fd3bdbc2504d2af3 +8332f3b63a6dc985376e8b1b25eeae68be6160fbe40053ba7bcf6f073204f682da72321786e422d3482fd60c9e5aa034 +a280f44877583fbb6b860d500b1a3f572e3ee833ec8f06476b3d8002058e25964062feaa1e5bec1536d734a5cfa09145 +a4026a52d277fcea512440d2204f53047718ebfcae7b48ac57ea7f6bfbc5de9d7304db9a9a6cbb273612281049ddaec5 +95cdf69c831ab2fad6c2535ede9c07e663d2ddccc936b64e0843d2df2a7b1c31f1759c3c20f1e7a57b1c8f0dbb21b540 +95c96cec88806469c277ab567863c5209027cecc06c7012358e5f555689c0d9a5ffb219a464f086b45817e8536b86d2f +afe38d4684132a0f03d806a4c8df556bf589b25271fbc6fe2e1ed16de7962b341c5003755da758d0959d2e6499b06c68 +a9b77784fda64987f97c3a23c5e8f61b918be0f7c59ba285084116d60465c4a2aaafc8857eb16823282cc83143eb9126 +a830f05881ad3ce532a55685877f529d32a5dbe56cea57ffad52c4128ee0fad0eeaf0da4362b55075e77eda7babe70e5 +992b3ad190d6578033c13ed5abfee4ef49cbc492babb90061e3c51ee4b5790cdd4c8fc1abff1fa2c00183b6b64f0bbbe +b1015424d9364aeff75de191652dc66484fdbec3e98199a9eb9671ec57bec6a13ff4b38446e28e4d8aedb58dd619cd90 +a745304604075d60c9db36cada4063ac7558e7ec2835d7da8485e58d8422e817457b8da069f56511b02601289fbb8981 +a5ba4330bc5cb3dbe0486ddf995632a7260a46180a08f42ae51a2e47778142132463cc9f10021a9ad36986108fefa1a9 +b419e9fd4babcaf8180d5479db188bb3da232ae77a1c4ed65687c306e6262f8083070a9ac32220cddb3af2ec73114092 +a49e23dc5f3468f3bf3a0bb7e4a114a788b951ff6f23a3396ae9e12cbff0abd1240878a3d1892105413dbc38818e807c +b7ecc7b4831f650202987e85b86bc0053f40d983f252e9832ef503aea81c51221ce93279da4aa7466c026b2d2070e55d +96a8c35cb87f84fa84dcd6399cc2a0fd79cc9158ef4bdde4bae31a129616c8a9f2576cd19baa3f497ca34060979aed7d +8681b2c00aa62c2b519f664a95dcb8faef601a3b961bb4ce5d85a75030f40965e2983871d41ea394aee934e859581548 +85c229a07efa54a713d0790963a392400f55fbb1a43995a535dc6c929f20d6a65cf4efb434e0ad1cb61f689b8011a3bc +90856f7f3444e5ad44651c28e24cc085a5db4d2ffe79aa53228c26718cf53a6e44615f3c5cda5aa752d5f762c4623c66 +978999b7d8aa3f28a04076f74d11c41ef9c89fdfe514936c4238e0f13c38ec97e51a5c078ebc6409e517bfe7ccb42630 +a099914dd7ed934d8e0d363a648e9038eb7c1ec03fa04dbcaa40f7721c618c3ef947afef7a16b4d7ac8c12aa46637f03 +ab2a104fed3c83d16f2cda06878fa5f30c8c9411de71bfb67fd2fc9aa454dcbcf3d299d72f8cc12e919466a50fcf7426 +a4471d111db4418f56915689482f6144efc4664cfb0311727f36c864648d35734351becc48875df96f4abd3cfcf820f9 +83be11727cd30ea94ccc8fa31b09b81c9d6a9a5d3a4686af9da99587332fe78c1f94282f9755854bafd6033549afec91 +88020ff971dc1a01a9e993cd50a5d2131ffdcbb990c1a6aaa54b20d8f23f9546a70918ea57a21530dcc440c1509c24ad +ae24547623465e87905eaffa1fa5d52bb7c453a8dbd89614fa8819a2abcedaf455c2345099b7324ae36eb0ad7c8ef977 +b59b0c60997de1ee00b7c388bc7101d136c9803bf5437b1d589ba57c213f4f835a3e4125b54738e78abbc21b000f2016 +a584c434dfe194546526691b68fa968c831c31da42303a1d735d960901c74011d522246f37f299555416b8cf25c5a548 +80408ce3724f4837d4d52376d255e10f69eb8558399ae5ca6c11b78b98fe67d4b93157d2b9b639f1b5b64198bfe87713 +abb941e8d406c2606e0ddc35c113604fdd9d249eacc51cb64e2991e551b8639ce44d288cc92afa7a1e7fc599cfc84b22 +b223173f560cacb1c21dba0f1713839e348ad02cbfdef0626748604c86f89e0f4c919ed40b583343795bdd519ba952c8 +af1c70512ec3a19d98b8a1fc3ff7f7f5048a27d17d438d43f561974bbdd116fcd5d5c21040f3447af3f0266848d47a15 +8a44809568ebe50405bede19b4d2607199159b26a1b33e03d180e6840c5cf59d991a4fb150d111443235d75ecad085b7 +b06207cdca46b125a27b3221b5b50cf27af4c527dd7c80e2dbcebbb09778a96df3af67e50f07725239ce3583dad60660 +993352d9278814ec89b26a11c4a7c4941bf8f0e6781ae79559d14749ee5def672259792db4587f85f0100c7bb812f933 +9180b8a718b971fd27bc82c8582d19c4b4f012453e8c0ffeeeffe745581fc6c07875ab28be3af3fa3896d19f0c89ac5b +8b8e1263eb48d0fe304032dd5ea1f30e73f0121265f7458ba9054d3626894e8a5fef665340abd2ede9653045c2665938 +99a2beee4a10b7941c24b2092192faf52b819afd033e4a2de050fd6c7f56d364d0cf5f99764c3357cf32399e60fc5d74 +946a4aad7f8647ea60bee2c5fcdeb6f9a58fb2cfca70c4d10e458027a04846e13798c66506151be3df9454b1e417893f +a672a88847652d260b5472d6908d1d57e200f1e492d30dd1cecc441cdfc9b76e016d9bab560efd4d7f3c30801de884a9 +9414e1959c156cde1eb24e628395744db75fc24b9df4595350aaad0bc38e0246c9b4148f6443ef68b8e253a4a6bcf11c +9316e9e4ec5fab4f80d6540df0e3a4774db52f1d759d2e5b5bcd3d7b53597bb007eb1887cb7dc61f62497d51ffc8d996 +902d6d77bb49492c7a00bc4b70277bc28c8bf9888f4307bb017ac75a962decdedf3a4e2cf6c1ea9f9ba551f4610cbbd7 +b07025a18b0e32dd5e12ec6a85781aa3554329ea12c4cd0d3b2c22e43d777ef6f89876dd90a9c8fb097ddf61cf18adc5 +b355a849ad3227caa4476759137e813505ec523cbc2d4105bc7148a4630f9e81918d110479a2d5f5e4cd9ccec9d9d3e3 +b49532cfdf02ee760109881ad030b89c48ee3bb7f219ccafc13c93aead754d29bdafe345be54c482e9d5672bd4505080 +9477802410e263e4f938d57fa8f2a6cac7754c5d38505b73ee35ea3f057aad958cb9722ba6b7b3cfc4524e9ca93f9cdc +9148ea83b4436339580f3dbc9ba51509e9ab13c03063587a57e125432dd0915f5d2a8f456a68f8fff57d5f08c8f34d6e +b00b6b5392b1930b54352c02b1b3b4f6186d20bf21698689bbfc7d13e86538a4397b90e9d5c93fd2054640c4dbe52a4f +926a9702500441243cd446e7cbf15dde16400259726794694b1d9a40263a9fc9e12f7bcbf12a27cb9aaba9e2d5848ddc +a0c6155f42686cbe7684a1dc327100962e13bafcf3db97971fc116d9f5c0c8355377e3d70979cdbd58fd3ea52440901c +a277f899f99edb8791889d0817ea6a96c24a61acfda3ad8c3379e7c62b9d4facc4b965020b588651672fd261a77f1bfc +8f528cebb866b501f91afa50e995234bef5bf20bff13005de99cb51eaac7b4f0bf38580cfd0470de40f577ead5d9ba0f +963fc03a44e9d502cc1d23250efef44d299befd03b898d07ce63ca607bb474b5cf7c965a7b9b0f32198b04a8393821f7 +ab087438d0a51078c378bf4a93bd48ef933ff0f1fa68d02d4460820df564e6642a663b5e50a5fe509527d55cb510ae04 +b0592e1f2c54746bb076be0fa480e1c4bebc4225e1236bcda3b299aa3853e3afb401233bdbcfc4a007b0523a720fbf62 +851613517966de76c1c55a94dc4595f299398a9808f2d2f0a84330ba657ab1f357701d0895f658c18a44cb00547f6f57 +a2fe9a1dd251e72b0fe4db27be508bb55208f8f1616b13d8be288363ec722826b1a1fd729fc561c3369bf13950bf1fd6 +b896cb2bc2d0c77739853bc59b0f89b2e008ba1f701c9cbe3bef035f499e1baee8f0ff1e794854a48c320586a2dfc81a +a1b60f98e5e5106785a9b81a85423452ee9ef980fa7fa8464f4366e73f89c50435a0c37b2906052b8e58e212ebd366cf +a853b0ebd9609656636df2e6acd5d8839c0fda56f7bf9288a943b06f0b67901a32b95e016ca8bc99bd7b5eab31347e72 +b290fa4c1346963bd5225235e6bdf7c542174dab4c908ab483d1745b9b3a6015525e398e1761c90e4b49968d05e30eea +b0f65a33ad18f154f1351f07879a183ad62e5144ad9f3241c2d06533dad09cbb2253949daff1bb02d24d16a3569f7ef0 +a00db59b8d4218faf5aeafcd39231027324408f208ec1f54d55a1c41228b463b88304d909d16b718cfc784213917b71e +b8d695dd33dc2c3bc73d98248c535b2770ad7fa31aa726f0aa4b3299efb0295ba9b4a51c71d314a4a1bd5872307534d1 +b848057cca2ca837ee49c42b88422303e58ea7d2fc76535260eb5bd609255e430514e927cc188324faa8e657396d63ec +92677836061364685c2aaf0313fa32322746074ed5666fd5f142a7e8f87135f45cd10e78a17557a4067a51dfde890371 +a854b22c9056a3a24ab164a53e5c5cf388616c33e67d8ebb4590cb16b2e7d88b54b1393c93760d154208b5ca822dc68f +86fff174920388bfab841118fb076b2b0cdec3fdb6c3d9a476262f82689fb0ed3f1897f7be9dbf0932bb14d346815c63 +99661cf4c94a74e182752bcc4b98a8c2218a8f2765642025048e12e88ba776f14f7be73a2d79bd21a61def757f47f904 +8a8893144d771dca28760cba0f950a5d634195fd401ec8cf1145146286caffb0b1a6ba0c4c1828d0a5480ce49073c64c +938a59ae761359ee2688571e7b7d54692848eb5dde57ffc572b473001ea199786886f8c6346a226209484afb61d2e526 +923f68a6aa6616714cf077cf548aeb845bfdd78f2f6851d8148cba9e33a374017f2f3da186c39b82d14785a093313222 +ac923a93d7da7013e73ce8b4a2b14b8fd0cc93dc29d5de941a70285bdd19be4740fedfe0c56b046689252a3696e9c5bc +b49b32c76d4ec1a2c68d4989285a920a805993bc6fcce6dacd3d2ddae73373050a5c44ba8422a3781050682fa0ef6ba2 +8a367941c07c3bdca5712524a1411bad7945c7c48ffc7103b1d4dff2c25751b0624219d1ccde8c3f70c465f954be5445 +b838f029df455efb6c530d0e370bbbf7d87d61a9aea3d2fe5474c5fe0a39cf235ceecf9693c5c6c5820b1ba8f820bd31 +a8983b7c715eaac7f13a001d2abc462dfc1559dab4a6b554119c271aa8fe00ffcf6b6949a1121f324d6d26cb877bcbae +a2afb24ad95a6f14a6796315fbe0d8d7700d08f0cfaf7a2abe841f5f18d4fecf094406cbd54da7232a159f9c5b6e805e +87e8e95ad2d62f947b2766ff405a23f7a8afba14e7f718a691d95369c79955cdebe24c54662553c60a3f55e6322c0f6f +87c2cbcecb754e0cc96128e707e5c5005c9de07ffd899efa3437cadc23362f5a1d3fcdd30a1f5bdc72af3fb594398c2a +91afd6ee04f0496dc633db88b9370d41c428b04fd991002502da2e9a0ef051bcd7b760e860829a44fbe5539fa65f8525 +8c50e5d1a24515a9dd624fe08b12223a75ca55196f769f24748686315329b337efadca1c63f88bee0ac292dd0a587440 +8a07e8f912a38d94309f317c32068e87f68f51bdfa082d96026f5f5f8a2211621f8a3856dda8069386bf15fb2d28c18f +94ad1dbe341c44eeaf4dc133eed47d8dbfe752575e836c075745770a6679ff1f0e7883b6aa917462993a7f469d74cab5 +8745f8bd86c2bb30efa7efb7725489f2654f3e1ac4ea95bd7ad0f3cfa223055d06c187a16192d9d7bdaea7b050c6a324 +900d149c8d79418cda5955974c450a70845e02e5a4ecbcc584a3ca64d237df73987c303e3eeb79da1af83bf62d9e579f +8f652ab565f677fb1a7ba03b08004e3cda06b86c6f1b0b9ab932e0834acf1370abb2914c15b0d08327b5504e5990681c +9103097d088be1f75ab9d3da879106c2f597e2cc91ec31e73430647bdd5c33bcfd771530d5521e7e14df6acda44f38a6 +b0fec7791cfb0f96e60601e1aeced9a92446b61fedab832539d1d1037558612d78419efa87ff5f6b7aab8fd697d4d9de +b9d2945bdb188b98958854ba287eb0480ef614199c4235ce5f15fc670b8c5ffe8eeb120c09c53ea8a543a022e6a321ac +a9461bb7d5490973ebaa51afc0bb4a5e42acdccb80e2f939e88b77ac28a98870e103e1042899750f8667a8cc9123bae9 +a37fdf11d4bcb2aed74b9f460a30aa34afea93386fa4cdb690f0a71bc58f0b8df60bec56e7a24f225978b862626fa00e +a214420e183e03d531cf91661466ea2187d84b6e814b8b20b3730a9400a7d25cf23181bb85589ebc982cec414f5c2923 +ad09a45a698a6beb3e0915f540ef16e9af7087f53328972532d6b5dfe98ce4020555ece65c6cbad8bd6be8a4dfefe6fd +ab6742800b02728c92d806976764cb027413d6f86edd08ad8bb5922a2969ee9836878cd39db70db0bd9a2646862acc4f +974ca9305bd5ea1dc1755dff3b63e8bfe9f744321046c1395659bcea2a987b528e64d5aa96ac7b015650b2253b37888d +84eee9d6bce039c52c2ebc4fccc0ad70e20c82f47c558098da4be2f386a493cbc76adc795b5488c8d11b6518c2c4fab8 +875d7bda46efcb63944e1ccf760a20144df3b00d53282b781e95f12bfc8f8316dfe6492c2efbf796f1150e36e436e9df +b68a2208e0c587b5c31b5f6cb32d3e6058a9642e2d9855da4f85566e1412db528475892060bb932c55b3a80877ad7b4a +ba006368ecab5febb6ab348644d9b63de202293085ed468df8bc24d992ae8ce468470aa37f36a73630c789fb9c819b30 +90a196035150846cd2b482c7b17027471372a8ce7d914c4d82b6ea7fa705d8ed5817bd42d63886242585baf7d1397a1c +a223b4c85e0daa8434b015fd9170b5561fe676664b67064974a1e9325066ecf88fc81f97ab5011c59fad28cedd04b240 +82e8ec43139cf15c6bbeed484b62e06cded8a39b5ce0389e4cbe9c9e9c02f2f0275d8d8d4e8dfec8f69a191bef220408 +81a3fc07a7b68d92c6ee4b6d28f5653ee9ec85f7e2ee1c51c075c1b130a8c5097dc661cf10c5aff1c7114b1a6a19f11a +8ed2ef8331546d98819a5dd0e6c9f8cb2630d0847671314a28f277faf68da080b53891dd75c82cbcf7788b255490785d +acecabf84a6f9bbed6b2fc2e7e4b48f02ef2f15e597538a73aea8f98addc6badda15e4695a67ecdb505c1554e8f345ec +b8f51019b2aa575f8476e03dcadf86cc8391f007e5f922c2a36b2daa63f5a503646a468990cd5c65148d323942193051 +aaa595a84b403ec65729bc1c8055a94f874bf9adddc6c507b3e1f24f79d3ad359595a672b93aab3394db4e2d4a7d8970 +895144c55fcbd0f64d7dd69e6855cfb956e02b5658eadf0f026a70703f3643037268fdd673b0d21b288578a83c6338dd +a2e92ae6d0d237d1274259a8f99d4ea4912a299816350b876fba5ebc60b714490e198a916e1c38c6e020a792496fa23c +a45795fda3b5bb0ad1d3c628f6add5b2a4473a1414c1a232e80e70d1cfffd7f8a8d9861f8df2946999d7dbb56bf60113 +b6659bf7f6f2fef61c39923e8c23b8c70e9c903028d8f62516d16755cd3fba2fe41c285aa9432dc75ab08f8a1d8a81fc +a735609a6bc5bfd85e58234fc439ff1f58f1ff1dd966c5921d8b649e21f006bf2b8642ad8a75063c159aaf6935789293 +a3c622eb387c9d15e7bda2e3e84d007cb13a6d50d655c3f2f289758e49d3b37b9a35e4535d3cc53d8efd51f407281f19 +8afe147b53ad99220f5ef9d763bfc91f9c20caecbcf823564236fb0e6ede49414c57d71eec4772c8715cc65a81af0047 +b5f0203233cf71913951e9c9c4e10d9243e3e4a1f2cb235bf3f42009120ba96e04aa414c9938ea8873b63148478927e8 +93c52493361b458d196172d7ba982a90a4f79f03aa8008edc322950de3ce6acf4c3977807a2ffa9e924047e02072b229 +b9e72b805c8ac56503f4a86c82720afbd5c73654408a22a2ac0b2e5caccdfb0e20b59807433a6233bc97ae58cf14c70a +af0475779b5cee278cca14c82da2a9f9c8ef222eb885e8c50cca2315fea420de6e04146590ed0dd5a29c0e0812964df5 +b430ccab85690db02c2d0eb610f3197884ca12bc5f23c51e282bf3a6aa7e4a79222c3d8761454caf55d6c01a327595f9 +830032937418b26ee6da9b5206f3e24dc76acd98589e37937e963a8333e5430abd6ce3dd93ef4b8997bd41440eed75d6 +8820a6d73180f3fe255199f3f175c5eb770461ad5cfdde2fb11508041ed19b8c4ce66ad6ecebf7d7e836cc2318df47ca +aef1393e7d97278e77bbf52ef6e1c1d5db721ccf75fe753cf47a881fa034ca61eaa5098ee5a344c156d2b14ff9e284ad +8a4a26c07218948c1196c45d927ef4d2c42ade5e29fe7a91eaebe34a29900072ce5194cf28d51f746f4c4c649daf4396 +84011dc150b7177abdcb715efbd8c201f9cb39c36e6069af5c50a096021768ba40cef45b659c70915af209f904ede3b6 +b1bd90675411389bb66910b21a4bbb50edce5330850c5ab0b682393950124252766fc81f5ecfc72fb7184387238c402e +8dfdcd30583b696d2c7744655f79809f451a60c9ad5bf1226dc078b19f4585d7b3ef7fa9d54e1ac09520d95cbfd20928 +b351b4dc6d98f75b8e5a48eb7c6f6e4b78451991c9ba630e5a1b9874c15ac450cd409c1a024713bf2cf82dc400e025ef +a462b8bc97ac668b97b28b3ae24b9f5de60e098d7b23ecb600d2194cd35827fb79f77c3e50d358f5bd72ee83fef18fa0 +a183753265c5f7890270821880cce5f9b2965b115ba783c6dba9769536f57a04465d7da5049c7cf8b3fcf48146173c18 +a8a771b81ed0d09e0da4d79f990e58eabcd2be3a2680419502dd592783fe52f657fe55125b385c41d0ba3b9b9cf54a83 +a71ec577db46011689d073245e3b1c3222a9b1fe6aa5b83629adec5733dd48617ebea91346f0dd0e6cdaa86e4931b168 +a334b8b244f0d598a02da6ae0f918a7857a54dce928376c4c85df15f3b0f2ba3ac321296b8b7c9dd47d770daf16c8f8c +a29037f8ef925c417c90c4df4f9fb27fb977d04e2b3dd5e8547d33e92ab72e7a00f5461de21e28835319eae5db145eb7 +b91054108ae78b00e3298d667b913ebc44d8f26e531eae78a8fe26fdfb60271c97efb2dee5f47ef5a3c15c8228138927 +926c13efbe90604f6244be9315a34f72a1f8d1aab7572df431998949c378cddbf2fe393502c930fff614ff06ae98a0ce +995c758fd5600e6537089b1baa4fbe0376ab274ff3e82a17768b40df6f91c2e443411de9cafa1e65ea88fb8b87d504f4 +9245ba307a7a90847da75fca8d77ec03fdfc812c871e7a2529c56a0a79a6de16084258e7a9ac4ae8a3756f394336e21c +99e0cfa2bb57a7e624231317044c15e52196ecce020db567c8e8cb960354a0be9862ee0c128c60b44777e65ac315e59f +ad4f6b3d27bbbb744126601053c3dc98c07ff0eb0b38a898bd80dce778372846d67e5ab8fb34fb3ad0ef3f235d77ba7f +a0f12cae3722bbbca2e539eb9cc7614632a2aefe51410430070a12b5bc5314ecec5857b7ff8f41e9980cac23064f7c56 +b487f1bc59485848c98222fd3bc36c8c9bb3d2912e2911f4ceca32c840a7921477f9b1fe00877e05c96c75d3eecae061 +a6033db53925654e18ecb3ce715715c36165d7035db9397087ac3a0585e587998a53973d011ac6d48af439493029cee6 +a6b4d09cd01c70a3311fd131d3710ccf97bde3e7b80efd5a8c0eaeffeb48cca0f951ced905290267b115b06d46f2693b +a9dff1df0a8f4f218a98b6f818a693fb0d611fed0fc3143537cbd6578d479af13a653a8155e535548a2a0628ae24fa58 +a58e469f65d366b519f9a394cacb7edaddac214463b7b6d62c2dbc1316e11c6c5184ce45c16de2d77f990dcdd8b55430 +989e71734f8119103586dc9a3c5f5033ddc815a21018b34c1f876cdfc112efa868d5751bf6419323e4e59fa6a03ece1c +a2da00e05036c884369e04cf55f3de7d659cd5fa3f849092b2519dd263694efe0f051953d9d94b7e121f0aee8b6174d7 +968f3c029f57ee31c4e1adea89a7f92e28483af9a74f30fbdb995dc2d40e8e657dff8f8d340d4a92bf65f54440f2859f +932778df6f60ac1639c1453ef0cbd2bf67592759dcccb3e96dcc743ff01679e4c7dd0ef2b0833dda548d32cb4eba49e2 +a805a31139f8e0d6dae1ac87d454b23a3dc9fc653d4ca18d4f8ebab30fc189c16e73981c2cb7dd6f8c30454a5208109d +a9ba0991296caa2aaa4a1ceacfb205544c2a2ec97088eace1d84ee5e2767656a172f75d2f0c4e16a3640a0e0dec316e0 +b1e49055c968dced47ec95ae934cf45023836d180702e20e2df57e0f62fb85d7ac60d657ba3ae13b8560b67210449459 +a94e1da570a38809c71e37571066acabff7bf5632737c9ab6e4a32856924bf6211139ab3cedbf083850ff2d0e0c0fcfc +88ef1bb322000c5a5515b310c838c9af4c1cdbb32eab1c83ac3b2283191cd40e9573747d663763a28dad0d64adc13840 +a987ce205f923100df0fbd5a85f22c9b99b9b9cbe6ddfa8dfda1b8fe95b4f71ff01d6c5b64ca02eb24edb2b255a14ef0 +84fe8221a9e95d9178359918a108de4763ebfa7a6487facb9c963406882a08a9a93f492f8e77cf9e7ea41ae079c45993 +aa1cf3dc7c5dcfa15bbbc811a4bb6dbac4fba4f97fb1ed344ab60264d7051f6eef19ea9773441d89929ee942ed089319 +8f6a7d610d59d9f54689bbe6a41f92d9f6096cde919c1ab94c3c7fcecf0851423bc191e5612349e10f855121c0570f56 +b5af1fa7894428a53ea520f260f3dc3726da245026b6d5d240625380bfb9c7c186df0204bb604efac5e613a70af5106e +a5bce6055ff812e72ce105f147147c7d48d7a2313884dd1f488b1240ee320f13e8a33f5441953a8e7a3209f65b673ce1 +b9b55b4a1422677d95821e1d042ab81bbf0bf087496504021ec2e17e238c2ca6b44fb3b635a5c9eac0871a724b8d47c3 +941c38e533ce4a673a3830845b56786585e5fe49c427f2e5c279fc6db08530c8f91db3e6c7822ec6bb4f956940052d18 +a38e191d66c625f975313c7007bbe7431b5a06ed2da1290a7d5d0f2ec73770d476efd07b8e632de64597d47df175cbb0 +94ba76b667abf055621db4c4145d18743a368d951565632ed4e743dd50dd3333507c0c34f286a5c5fdbf38191a2255cd +a5ca38c60be5602f2bfa6e00c687ac96ac36d517145018ddbee6f12eb0faa63dd57909b9eeed26085fe5ac44e55d10ab +b00fea3b825e60c1ed1c5deb4b551aa65a340e5af36b17d5262c9cd2c508711e4dc50dc2521a2c16c7c901902266e64a +971b86fc4033485e235ccb0997a236206ba25c6859075edbcdf3c943116a5030b7f75ebca9753d863a522ba21a215a90 +b3b31f52370de246ee215400975b674f6da39b2f32514fe6bd54e747752eedca22bb840493b44a67df42a3639c5f901f +affbbfac9c1ba7cbfa1839d2ae271dd6149869b75790bf103230637da41857fc326ef3552ff31c15bda0694080198143 +a95d42aa7ef1962520845aa3688f2752d291926f7b0d73ea2ee24f0612c03b43f2b0fe3c9a9a99620ffc8d487b981bc2 +914a266065caf64985e8c5b1cb2e3f4e3fe94d7d085a1881b1fefa435afef4e1b39a98551d096a62e4f5cc1a7f0fdc2e +81a0b4a96e2b75bc1bf2dbd165d58d55cfd259000a35504d1ffb18bc346a3e6f07602c683723864ffb980f840836fd8d +91c1556631cddd4c00b65b67962b39e4a33429029d311c8acf73a18600e362304fb68bccb56fde40f49e95b7829e0b87 +8befbacc19e57f7c885d1b7a6028359eb3d80792fe13b92a8400df21ce48deb0bb60f2ddb50e3d74f39f85d7eab23adc +92f9458d674df6e990789690ec9ca73dacb67fc9255b58c417c555a8cc1208ace56e8e538f86ba0f3615573a0fbac00d +b4b1b3062512d6ae7417850c08c13f707d5838e43d48eb98dd4621baf62eee9e82348f80fe9b888a12874bfa538771f8 +a13c4a3ac642ede37d9c883f5319e748d2b938f708c9d779714108a449b343f7b71a6e3ef4080fee125b416762920273 +af44983d5fc8cceee0551ef934e6e653f2d3efa385e5c8a27a272463a6f333e290378cc307c2b664eb923c78994e706e +a389fd6c59fe2b4031cc244e22d3991e541bd203dd5b5e73a6159e72df1ab41d49994961500dcde7989e945213184778 +8d2141e4a17836c548de9598d7b298b03f0e6c73b7364979a411c464e0628e21cff6ac3d6decdba5d1c4909eff479761 +980b22ef53b7bdf188a3f14bc51b0dbfdf9c758826daa3cbc1e3986022406a8aa9a6a79e400567120b88c67faa35ce5f +a28882f0a055f96df3711de5d0aa69473e71245f4f3e9aa944e9d1fb166e02caa50832e46da6d3a03b4801735fd01b29 +8db106a37d7b88f5d995c126abb563934dd8de516af48e85695d02b1aea07f79217e3cdd03c6f5ca57421830186c772b +b5a7e50da0559a675c472f7dfaee456caab6695ab7870541b2be8c2b118c63752427184aad81f0e1afc61aef1f28c46f +9962118780e20fe291d10b64f28d09442a8e1b5cffd0f3dd68d980d0614050a626c616b44e9807fbee7accecae00686a +b38ddf33745e8d2ad6a991aefaf656a33c5f8cbe5d5b6b6fd03bd962153d8fd0e01b5f8f96d80ae53ab28d593ab1d4e7 +857dc12c0544ff2c0c703761d901aba636415dee45618aba2e3454ff9cbc634a85c8b05565e88520ff9be2d097c8b2b1 +a80d465c3f8cc63af6d74a6a5086b626c1cb4a8c0fee425964c3bd203d9d7094e299f81ce96d58afc20c8c9a029d9dae +89e1c8fbde8563763be483123a3ed702efac189c6d8ab4d16c85e74bbaf856048cc42d5d6e138633a38572ba5ec3f594 +893a594cf495535f6d216508f8d03c317dcf03446668cba688da90f52d0111ac83d76ad09bf5ea47056846585ee5c791 +aadbd8be0ae452f7f9450c7d2957598a20cbf10139a4023a78b4438172d62b18b0de39754dd2f8862dbd50a3a0815e53 +ae7d39670ecca3eb6db2095da2517a581b0e8853bdfef619b1fad9aacd443e7e6a40f18209fadd44038a55085c5fe8b2 +866ef241520eacb6331593cfcb206f7409d2f33d04542e6e52cba5447934e02d44c471f6c9a45963f9307e9809ab91d9 +b1a09911ad3864678f7be79a9c3c3eb5c84a0a45f8dcb52c67148f43439aeaaa9fd3ed3471276b7e588b49d6ebe3033a +add07b7f0dbb34049cd8feeb3c18da5944bf706871cfd9f14ff72f6c59ad217ebb1f0258b13b167851929387e4e34cfe +ae048892d5c328eefbdd4fba67d95901e3c14d974bfc0a1fc68155ca9f0d59e61d7ba17c6c9948b120cf35fd26e6fee9 +9185b4f3b7da0ddb4e0d0f09b8a9e0d6943a4611e43f13c3e2a767ed8592d31e0ba3ebe1914026a3627680274291f6e5 +a9c022d4e37b0802284ce3b7ee9258628ab4044f0db4de53d1c3efba9de19d15d65cc5e608dbe149c21c2af47d0b07b5 +b24dbd5852f8f24921a4e27013b6c3fa8885b973266cb839b9c388efad95821d5d746348179dcc07542bd0d0aefad1ce +b5fb4f279300876a539a27a441348764908bc0051ebd66dc51739807305e73db3d2f6f0f294ffb91b508ab150eaf8527 +ace50841e718265b290c3483ed4b0fdd1175338c5f1f7530ae9a0e75d5f80216f4de37536adcbc8d8c95982e88808cd0 +b19cadcde0f63bd1a9c24bd9c2806f53c14c0b9735bf351601498408ba503ddbd2037c891041cbba47f58b8c483f3b21 +b6061e63558d312eb891b97b39aa552fa218568d79ee26fe6dd5b864aea9e3216d8f2e2f3b093503be274766dac41426 +89730fdb2876ab6f0fe780d695f6e12090259027e789b819956d786e977518057e5d1d7f5ab24a3ae3d5d4c97773bd2b +b6fa841e81f9f2cad0163a02a63ae96dc341f7ae803b616efc6e1da2fbea551c1b96b11ad02c4afbdf6d0cc9f23da172 +8fb66187182629c861ddb6896d7ed3caf2ad050c3dba8ab8eb0d7a2c924c3d44c48d1a148f9e33fb1f061b86972f8d21 +86022ac339c1f84a7fa9e05358c1a5b316b4fc0b83dbe9c8c7225dc514f709d66490b539359b084ce776e301024345fa +b50b9c321468da950f01480bb62b6edafd42f83c0001d6e97f2bd523a1c49a0e8574fb66380ea28d23a7c4d54784f9f0 +a31c05f7032f30d1dac06678be64d0250a071fd655e557400e4a7f4c152be4d5c7aa32529baf3e5be7c4bd49820054f6 +b95ac0848cd322684772119f5b682d90a66bbf9dac411d9d86d2c34844bbd944dbaf8e47aa41380455abd51687931a78 +ae4a6a5ce9553b65a05f7935e61e496a4a0f6fd8203367a2c627394c9ce1e280750297b74cdc48fd1d9a31e93f97bef4 +a22daf35f6e9b05e52e0b07f7bd1dbbebd2c263033fb0e1b2c804e2d964e2f11bc0ece6aca6af079dd3a9939c9c80674 +902150e0cb1f16b9b59690db35281e28998ce275acb313900da8b2d8dfd29fa1795f8ca3ff820c31d0697de29df347c1 +b17b5104a5dc665cdd7d47e476153d715eb78c6e5199303e4b5445c21a7fa7cf85fe7cfd08d7570f4e84e579b005428c +a03f49b81c15433f121680aa02d734bb9e363af2156654a62bcb5b2ba2218398ccb0ff61104ea5d7df5b16ea18623b1e +802101abd5d3c88876e75a27ffc2f9ddcce75e6b24f23dba03e5201281a7bd5cc7530b6a003be92d225093ca17d3c3bb +a4d183f63c1b4521a6b52226fc19106158fc8ea402461a5cccdaa35fee93669df6a8661f45c1750cd01308149b7bf08e +8d17c22e0c8403b69736364d460b3014775c591032604413d20a5096a94d4030d7c50b9fe3240e31d0311efcf9816a47 +947225acfcce5992eab96276f668c3cbe5f298b90a59f2bb213be9997d8850919e8f496f182689b5cbd54084a7332482 +8df6f4ed216fc8d1905e06163ba1c90d336ab991a18564b0169623eb39b84e627fa267397da15d3ed754d1f3423bff07 +83480007a88f1a36dea464c32b849a3a999316044f12281e2e1c25f07d495f9b1710b4ba0d88e9560e72433addd50bc2 +b3019d6e591cf5b33eb972e49e06c6d0a82a73a75d78d383dd6f6a4269838289e6e07c245f54fed67f5c9bb0fd5e1c5f +92e8ce05e94927a9fb02debadb99cf30a26172b2705003a2c0c47b3d8002bf1060edb0f6a5750aad827c98a656b19199 +ac2aff801448dbbfc13cca7d603fd9c69e82100d997faf11f465323b97255504f10c0c77401e4d1890339d8b224f5803 +b0453d9903d08f508ee27e577445dc098baed6cde0ac984b42e0f0efed62760bd58d5816cf1e109d204607b7b175e30c +ae68dc4ba5067e825d46d2c7c67f1009ceb49d68e8d3e4c57f4bcd299eb2de3575d42ea45e8722f8f28497a6e14a1cfe +b22486c2f5b51d72335ce819bbafb7fa25eb1c28a378a658f13f9fc79cd20083a7e573248d911231b45a5cf23b561ca7 +89d1201d1dbd6921867341471488b4d2fd0fc773ae1d4d074c78ae2eb779a59b64c00452c2a0255826fca6b3d03be2b1 +a2998977c91c7a53dc6104f5bc0a5b675e5350f835e2f0af69825db8af4aeb68435bdbcc795f3dd1f55e1dd50bc0507f +b0be4937a925b3c05056ed621910d535ccabf5ab99fd3b9335080b0e51d9607d0fd36cb5781ff340018f6acfca4a9736 +aea145a0f6e0ba9df8e52e84bb9c9de2c2dc822f70d2724029b153eb68ee9c17de7d35063dcd6a39c37c59fdd12138f7 +91cb4545d7165ee8ffbc74c874baceca11fdebbc7387908d1a25877ca3c57f2c5def424dab24148826832f1e880bede0 +b3b579cb77573f19c571ad5eeeb21f65548d7dff9d298b8d7418c11f3e8cd3727c5b467f013cb87d6861cfaceee0d2e3 +b98a1eeec2b19fecc8378c876d73645aa52fb99e4819903735b2c7a885b242787a30d1269a04bfb8573d72d9bbc5f0f0 +940c1f01ed362bd588b950c27f8cc1d52276c71bb153d47f07ec85b038c11d9a8424b7904f424423e714454d5e80d1cd +aa343a8ecf09ce11599b8cf22f7279cf80f06dbf9f6d62cb05308dbbb39c46fd0a4a1240b032665fbb488a767379b91b +87c3ac72084aca5974599d3232e11d416348719e08443acaba2b328923af945031f86432e170dcdd103774ec92e988c9 +91d6486eb5e61d2b9a9e742c20ec974a47627c6096b3da56209c2b4e4757f007e793ebb63b2b246857c9839b64dc0233 +aebcd3257d295747dd6fc4ff910d839dd80c51c173ae59b8b2ec937747c2072fa85e3017f9060aa509af88dfc7529481 +b3075ba6668ca04eff19efbfa3356b92f0ab12632dcda99cf8c655f35b7928c304218e0f9799d68ef9f809a1492ff7db +93ba7468bb325639ec2abd4d55179c69fd04eaaf39fc5340709227bbaa4ad0a54ea8b480a1a3c8d44684e3be0f8d1980 +a6aef86c8c0d92839f38544d91b767c582568b391071228ff5a5a6b859c87bf4f81a7d926094a4ada1993ddbd677a920 +91dcd6d14207aa569194aa224d1e5037b999b69ade52843315ca61ba26abe9a76412c9e88259bc5cf5d7b95b97d9c3bc +b3b483d31c88f78d49bd065893bc1e3d2aa637e27dedb46d9a7d60be7660ce7a10aaaa7deead362284a52e6d14021178 +8e5730070acf8371461ef301cc4523e8e672aa0e3d945d438a0e0aa6bdf8cb9c685dcf38df429037b0c8aff3955c6f5b +b8c6d769890a8ee18dc4f9e917993315877c97549549b34785a92543cbeec96a08ae3a28d6e809c4aacd69de356c0012 +95ca86cd384eaceaa7c077c5615736ca31f36824bd6451a16142a1edc129fa42b50724aeed7c738f08d7b157f78b569e +94df609c6d71e8eee7ab74226e371ccc77e01738fe0ef1a6424435b4570fe1e5d15797b66ed0f64eb88d4a3a37631f0e +89057b9783212add6a0690d6bb99097b182738deff2bd9e147d7fd7d6c8eacb4c219923633e6309ad993c24572289901 +83a0f9f5f265c5a0e54defa87128240235e24498f20965009fef664f505a360b6fb4020f2742565dfc7746eb185bcec0 +91170da5306128931349bc3ed50d7df0e48a68b8cc8420975170723ac79d8773e4fa13c5f14dc6e3fafcad78379050b1 +b7178484d1b55f7e56a4cc250b6b2ec6040437d96bdfddfa7b35ed27435860f3855c2eb86c636f2911b012eb83b00db8 +ac0b00c4322d1e4208e09cd977b4e54d221133ff09551f75b32b0b55d0e2be80941dda26257b0e288c162e63c7e9cf68 +9690ed9e7e53ed37ff362930e4096b878b12234c332fd19d5d064824084245952eda9f979e0098110d6963e468cf513e +b6fa547bb0bb83e5c5be0ed462a8783fba119041c136a250045c09d0d2af330c604331e7de960df976ff76d67f8000cd +814603907c21463bcf4e59cfb43066dfe1a50344ae04ef03c87c0f61b30836c3f4dea0851d6fa358c620045b7f9214c8 +9495639e3939fad2a3df00a88603a5a180f3c3a0fe4d424c35060e2043e0921788003689887b1ed5be424d9a89bb18bb +aba4c02d8d57f2c92d5bc765885849e9ff8393d6554f5e5f3e907e5bfac041193a0d8716d7861104a4295d5a03c36b03 +8ead0b56c1ca49723f94a998ba113b9058059321da72d9e395a667e6a63d5a9dac0f5717cec343f021695e8ced1f72af +b43037f7e3852c34ed918c5854cd74e9d5799eeddfe457d4f93bb494801a064735e326a76e1f5e50a339844a2f4a8ec9 +99db8422bb7302199eb0ff3c3d08821f8c32f53a600c5b6fb43e41205d96adae72be5b460773d1280ad1acb806af9be8 +8a9be08eae0086c0f020838925984df345c5512ff32e37120b644512b1d9d4fecf0fd30639ca90fc6cf334a86770d536 +81b43614f1c28aa3713a309a88a782fb2bdfc4261dd52ddc204687791a40cf5fd6a263a8179388596582cccf0162efc2 +a9f3a8b76912deb61d966c75daf5ddb868702ebec91bd4033471c8e533183df548742a81a2671de5be63a502d827437d +902e2415077f063e638207dc7e14109652e42ab47caccd6204e2870115791c9defac5425fd360b37ac0f7bd8fe7011f8 +aa18e4fdc1381b59c18503ae6f6f2d6943445bd00dd7d4a2ad7e5adad7027f2263832690be30d456e6d772ad76f22350 +a348b40ba3ba7d81c5d4631f038186ebd5e5f314f1ea737259151b07c3cc8cf0c6ed4201e71bcc1c22fefda81a20cde6 +aa1306f7ac1acbfc47dc6f7a0cb6d03786cec8c8dc8060388ccda777bca24bdc634d03e53512c23dba79709ff64f8620 +818ccfe46e700567b7f3eb400e5a35f6a5e39b3db3aa8bc07f58ace35d9ae5a242faf8dbccd08d9a9175bbce15612155 +b7e3da2282b65dc8333592bb345a473f03bd6df69170055fec60222de9897184536bf22b9388b08160321144d0940279 +a4d976be0f0568f4e57de1460a1729129252b44c552a69fceec44e5b97c96c711763360d11f9e5bf6d86b4976bf40d69 +85d185f0397c24c2b875b09b6328a23b87982b84ee880f2677a22ff4c9a1ba9f0fea000bb3f7f66375a00d98ebafce17 +b4ccbb8c3a2606bd9b87ce022704663af71d418351575f3b350d294f4efc68c26f9a2ce49ff81e6ff29c3b63d746294e +93ffd3265fddb63724dfde261d1f9e22f15ecf39df28e4d89e9fea03221e8e88b5dd9b77628bacaa783c6f91802d47cc +b1fd0f8d7a01378e693da98d03a2d2fda6b099d03454b6f2b1fa6472ff6bb092751ce6290059826b74ac0361eab00e1e +a89f440c71c561641589796994dd2769616b9088766e983c873fae0716b95c386c8483ab8a4f367b6a68b72b7456dd32 +af4fe92b01d42d03dd5d1e7fa55e96d4bbcb7bf7d4c8c197acd16b3e0f3455807199f683dcd263d74547ef9c244b35cc +a8227f6e0a344dfe76bfbe7a1861be32c4f4bed587ccce09f9ce2cf481b2dda8ae4f566154bc663d15f962f2d41761bd +a7b361663f7495939ed7f518ba45ea9ff576c4e628995b7aea026480c17a71d63fc2c922319f0502eb7ef8f14a406882 +8ddcf382a9f39f75777160967c07012cfa89e67b19714a7191f0c68eaf263935e5504e1104aaabd0899348c972a8d3c6 +98c95b9f6f5c91f805fb185eedd06c6fc4457d37dd248d0be45a6a168a70031715165ea20606245cbdf8815dc0ac697f +805b44f96e001e5909834f70c09be3efcd3b43632bcac5b6b66b6d227a03a758e4b1768ce2a723045681a1d34562aaeb +b0e81b07cdc45b3dca60882676d9badb99f25c461b7efe56e3043b80100bb62d29e1873ae25eb83087273160ece72a55 +b0c53f0abe78ee86c7b78c82ae1f7c070bb0b9c45c563a8b3baa2c515d482d7507bb80771e60b38ac13f78b8af92b4a9 +a7838ef6696a9e4d2e5dfd581f6c8d6a700467e8fd4e85adabb5f7a56f514785dd4ab64f6f1b48366f7d94728359441b +88c76f7700a1d23c30366a1d8612a796da57b2500f97f88fdf2d76b045a9d24e7426a8ffa2f4e86d3046937a841dad58 +ad8964baf98c1f02e088d1d9fcb3af6b1dfa44cdfe0ed2eae684e7187c33d3a3c28c38e8f4e015f9c04d451ed6f85ff6 +90e9d00a098317ececaa9574da91fc149eda5b772dedb3e5a39636da6603aa007804fa86358550cfeff9be5a2cb7845e +a56ff4ddd73d9a6f5ab23bb77efa25977917df63571b269f6a999e1ad6681a88387fcc4ca3b26d57badf91b236503a29 +97ad839a6302c410a47e245df84c01fb9c4dfef86751af3f9340e86ff8fc3cd52fa5ff0b9a0bd1d9f453e02ca80658a6 +a4c8c44cbffa804129e123474854645107d1f0f463c45c30fd168848ebea94880f7c0c5a45183e9eb837f346270bdb35 +a72e53d0a1586d736e86427a93569f52edd2f42b01e78aee7e1961c2b63522423877ae3ac1227a2cf1e69f8e1ff15bc3 +8559f88a7ef13b4f09ac82ae458bbae6ab25671cfbf52dae7eac7280d6565dd3f0c3286aec1a56a8a16dc3b61d78ce47 +8221503f4cdbed550876c5dc118a3f2f17800c04e8be000266633c83777b039a432d576f3a36c8a01e8fd18289ebc10b +99bfbe5f3e46d4d898a578ba86ed26de7ed23914bd3bcdf3c791c0bcd49398a52419077354a5ab75cea63b6c871c6e96 +aa134416d8ff46f2acd866c1074af67566cfcf4e8be8d97329dfa0f603e1ff208488831ce5948ac8d75bfcba058ddcaa +b02609d65ebfe1fe8e52f21224a022ea4b5ea8c1bd6e7b9792eed8975fc387cdf9e3b419b8dd5bcce80703ab3a12a45f +a4f14798508698fa3852e5cac42a9db9797ecee7672a54988aa74037d334819aa7b2ac7b14efea6b81c509134a6b7ad2 +884f01afecbcb987cb3e7c489c43155c416ed41340f61ecb651d8cba884fb9274f6d9e7e4a46dd220253ae561614e44c +a05523c9e71dce1fe5307cc71bd721feb3e1a0f57a7d17c7d1c9fb080d44527b7dbaa1f817b1af1c0b4322e37bc4bb1e +8560aec176a4242b39f39433dd5a02d554248c9e49d3179530815f5031fee78ba9c71a35ceeb2b9d1f04c3617c13d8f0 +996aefd402748d8472477cae76d5a2b92e3f092fc834d5222ae50194dd884c9fb8b6ed8e5ccf8f6ed483ddbb4e80c747 +8fd09900320000cbabc40e16893e2fcf08815d288ec19345ad7b6bb22f7d78a52b6575a3ca1ca2f8bc252d2eafc928ec +939e51f73022bc5dc6862a0adf8fb8a3246b7bfb9943cbb4b27c73743926cc20f615a036c7e5b90c80840e7f1bfee0e7 +a0a6258700cadbb9e241f50766573bf9bdb7ad380b1079dc3afb4054363d838e177b869cad000314186936e40359b1f2 +972699a4131c8ed27a2d0e2104d54a65a7ff1c450ad9da3a325c662ab26869c21b0a84d0700b98c8b5f6ce3b746873d7 +a454c7fe870cb8aa6491eafbfb5f7872d6e696033f92e4991d057b59d70671f2acdabef533e229878b60c7fff8f748b1 +a167969477214201f09c79027b10221e4707662e0c0fde81a0f628249f2f8a859ce3d30a7dcc03b8ecca8f7828ad85c7 +8ff6b7265175beb8a63e1dbf18c9153fb2578c207c781282374f51b40d57a84fd2ef2ea2b9c6df4a54646788a62fd17f +a3d7ebeccde69d73d8b3e76af0da1a30884bb59729503ff0fb0c3bccf9221651b974a6e72ea33b7956fc3ae758226495 +b71ef144c9a98ce5935620cb86c1590bd4f48e5a2815d25c0cdb008fde628cf628c31450d3d4f67abbfeb16178a74cfd +b5e0a16d115134f4e2503990e3f2035ed66b9ccf767063fe6747870d97d73b10bc76ed668550cb82eedc9a2ca6f75524 +b30ffaaf94ee8cbc42aa2c413175b68afdb207dbf351fb20be3852cb7961b635c22838da97eaf43b103aff37e9e725cc +98aa7d52284f6c1f22e272fbddd8c8698cf8f5fbb702d5de96452141fafb559622815981e50b87a72c2b1190f59a7deb +81fbacda3905cfaf7780bb4850730c44166ed26a7c8d07197a5d4dcd969c09e94a0461638431476c16397dd7bdc449f9 +95e47021c1726eac2e5853f570d6225332c6e48e04c9738690d53e07c6b979283ebae31e2af1fc9c9b3e59f87e5195b1 +ac024a661ba568426bb8fce21780406537f518075c066276197300841e811860696f7588188bc01d90bace7bc73d56e3 +a4ebcaf668a888dd404988ab978594dee193dad2d0aec5cdc0ccaf4ec9a7a8228aa663db1da8ddc52ec8472178e40c32 +a20421b8eaf2199d93b083f2aff37fb662670bd18689d046ae976d1db1fedd2c2ff897985ecc6277b396db7da68bcb27 +8bc33d4b40197fd4d49d1de47489d10b90d9b346828f53a82256f3e9212b0cbc6930b895e879da9cec9fedf026aadb3e +aaafdd1bec8b757f55a0433eddc0a39f818591954fd4e982003437fcceb317423ad7ee74dbf17a2960380e7067a6b4e2 +aad34277ebaed81a6ec154d16736866f95832803af28aa5625bf0461a71d02b1faba02d9d9e002be51c8356425a56867 +976e9c8b150d08706079945bd0e84ab09a648ecc6f64ded9eb5329e57213149ae409ae93e8fbd8eda5b5c69f5212b883 +8097fae1653247d2aed4111533bc378171d6b2c6d09cbc7baa9b52f188d150d645941f46d19f7f5e27b7f073c1ebd079 +83905f93b250d3184eaba8ea7d727c4464b6bdb027e5cbe4f597d8b9dc741dcbea709630bd4fd59ce24023bec32fc0f3 +8095030b7045cff28f34271386e4752f9a9a0312f8df75de4f424366d78534be2b8e1720a19cb1f9a2d21105d790a225 +a7b7b73a6ae2ed1009c49960374b0790f93c74ee03b917642f33420498c188a169724945a975e5adec0a1e83e07fb1b2 +856a41c54df393b6660b7f6354572a4e71c8bfca9cabaffb3d4ef2632c015e7ee2bc10056f3eccb3dbed1ad17d939178 +a8f7a55cf04b38cd4e330394ee6589da3a07dc9673f74804fdf67b364e0b233f14aec42e783200a2e4666f7c5ff62490 +82c529f4e543c6bca60016dc93232c115b359eaee2798a9cf669a654b800aafe6ab4ba58ea8b9cdda2b371c8d62fa845 +8caab020c1baddce77a6794113ef1dfeafc5f5000f48e97f4351b588bf02f1f208101745463c480d37f588d5887e6d8c +8fa91b3cc400f48b77b6fd77f3b3fbfb3f10cdff408e1fd22d38f77e087b7683adad258804409ba099f1235b4b4d6fea +8aa02787663d6be9a35677d9d8188b725d5fcd770e61b11b64e3def8808ea5c71c0a9afd7f6630c48634546088fcd8e2 +b5635b7b972e195cab878b97dea62237c7f77eb57298538582a330b1082f6207a359f2923864630136d8b1f27c41b9aa +8257bb14583551a65975946980c714ecd6e5b629672bb950b9caacd886fbd22704bc9e3ba7d30778adab65dc74f0203a +ab5fe1cd12634bfa4e5c60d946e2005cbd38f1063ec9a5668994a2463c02449a0a185ef331bd86b68b6e23a8780cb3ba +a7d3487da56cda93570cc70215d438204f6a2709bfb5fda6c5df1e77e2efc80f4235c787e57fbf2c74aaff8cbb510a14 +b61cff7b4c49d010e133319fb828eb900f8a7e55114fc86b39c261a339c74f630e1a7d7e1350244ada566a0ff3d46c4b +8d4d1d55d321d278db7a85522ccceca09510374ca81d4d73e3bb5249ace7674b73900c35a531ec4fa6448fabf7ad00dc +966492248aee24f0f56c8cfca3c8ec6ba3b19abb69ae642041d4c3be8523d22c65c4dafcab4c58989ccc4e0bd2f77919 +b20c320a90cb220b86e1af651cdc1e21315cd215da69f6787e28157172f93fc8285dcd59b039c626ed8ca4633cba1a47 +aae9e6b22f018ceb5c0950210bb8182cb8cb61014b7e14581a09d36ebd1bbfebdb2b82afb7fdb0cf75e58a293d9c456d +875547fb67951ad37b02466b79f0c9b985ccbc500cfb431b17823457dc79fb9597ec42cd9f198e15523fcd88652e63a4 +92afce49773cb2e20fb21e4f86f18e0959ebb9c33361547ddb30454ee8e36b1e234019cbdca0e964cb292f7f77df6b90 +8af85343dfe1821464c76ba11c216cbef697b5afc69c4d821342e55afdac047081ec2e3f7b09fc14b518d9a23b78c003 +b7de4a1648fd63f3a918096ea669502af5357438e69dac77cb8102b6e6c15c76e033cfaa80dafc806e535ede5c1a20aa +ac80e9b545e8bd762951d96c9ce87f629d01ffcde07efc2ef7879ca011f1d0d8a745abf26c9d452541008871304fac00 +a4cf0f7ed724e481368016c38ea5816698a5f68eb21af4d3c422d2ba55f96a33e427c2aa40de1b56a7cfac7f7cf43ab0 +899b0a678bb2db2cae1b44e75a661284844ebcdd87abf308fedeb2e4dbe5c5920c07db4db7284a7af806a2382e8b111a +af0588a2a4afce2b1b13c1230816f59e8264177e774e4a341b289a101dcf6af813638fed14fb4d09cb45f35d5d032609 +a4b8df79e2be76e9f5fc5845f06fe745a724cf37c82fcdb72719b77bdebea3c0e763f37909373e3a94480cc5e875cba0 +83e42c46d88930c8f386b19fd999288f142d325e2ebc86a74907d6d77112cb0d449bc511c95422cc810574031a8cbba9 +b5e39534070de1e5f6e27efbdd3dc917d966c2a9b8cf2d893f964256e95e954330f2442027dc148c776d63a95bcde955 +958607569dc28c075e658cd4ae3927055c6bc456eef6212a6fea8205e48ed8777a8064f584cda38fe5639c371e2e7fba +812adf409fa63575113662966f5078a903212ffb65c9b0bbe62da0f13a133443a7062cb8fd70f5e5dd5559a32c26d2c8 +a679f673e5ce6a3cce7fa31f22ee3785e96bcb55e5a776e2dd3467bef7440e3555d1a9b87cb215e86ee9ed13a090344b +afedbb34508b159eb25eb2248d7fe328f86ef8c7d84c62d5b5607d74aae27cc2cc45ee148eb22153b09898a835c58df4 +b75505d4f6b67d31e665cfaf5e4acdb5838ae069166b7fbcd48937c0608a59e40a25302fcc1873d2e81c1782808c70f0 +b62515d539ec21a155d94fc00ea3c6b7e5f6636937bce18ed5b618c12257fb82571886287fd5d1da495296c663ebc512 +ab8e1a9446bbdd588d1690243b1549d230e6149c28f59662b66a8391a138d37ab594df38e7720fae53217e5c3573b5be +b31e8abf4212e03c3287bb2c0a153065a7290a16764a0bac8f112a72e632185a654bb4e88fdd6053e6c7515d9719fadb +b55165477fe15b6abd2d0f4fddaa9c411710dcc4dd712daba3d30e303c9a3ee5415c256f9dc917ecf18c725b4dbab059 +a0939d4f57cacaae549b78e87cc234de4ff6a35dc0d9cd5d7410abc30ebcd34c135e008651c756e5a9d2ca79c40ef42b +8cf10e50769f3443340844aad4d56ec790850fed5a41fcbd739abac4c3015f0a085a038fbe7fae9f5ad899cce5069f6b +924055e804d82a99ea4bb160041ea4dc14b568abf379010bc1922fde5d664718c31d103b8b807e3a1ae809390e708c73 +8ec0f9d26f71b0f2e60a179e4fd1778452e2ffb129d50815e5d7c7cb9415fa69ae5890578086e8ef6bfde35ad2a74661 +98c7f12b15ec4426b59f737f73bf5faea4572340f4550b7590dfb7f7ffedb2372e3e555977c63946d579544c53210ad0 +8a935f7a955c78f69d66f18eee0092e5e833fa621781c9581058e219af4d7ceee48b84e472e159dda6199715fb2f9acf +b78d4219f95a2dbfaa7d0c8a610c57c358754f4f43c2af312ab0fe8f10a5f0177e475332fb8fd23604e474fc2abeb051 +8d086a14803392b7318c28f1039a17e3cfdcece8abcaca3657ec3d0ac330842098a85c0212f889fabb296dfb133ce9aa +a53249f417aac82f2c2a50c244ce21d3e08a5e5a8bd33bec2a5ab0d6cd17793e34a17edfa3690899244ce201e2fb9986 +8619b0264f9182867a1425be514dc4f1ababc1093138a728a28bd7e4ecc99b9faaff68c23792264bc6e4dce5f52a5c52 +8c171edbbbde551ec19e31b2091eb6956107dd9b1f853e1df23bff3c10a3469ac77a58335eee2b79112502e8e163f3de +a9d19ec40f0ca07c238e9337c6d6a319190bdba2db76fb63902f3fb459aeeb50a1ac30db5b25ee1b4201f3ca7164a7f4 +b9c6ec14b1581a03520b8d2c1fbbc31fb8ceaef2c0f1a0d0080b6b96e18442f1734bea7ef7b635d787c691de4765d469 +8cb437beb4cfa013096f40ccc169a713dc17afee6daa229a398e45fd5c0645a9ad2795c3f0cd439531a7151945d7064d +a6e8740cc509126e146775157c2eb278003e5bb6c48465c160ed27888ca803fa12eee1f6a8dd7f444f571664ed87fdc1 +b75c1fecc85b2732e96b3f23aefb491dbd0206a21d682aee0225838dc057d7ed3b576176353e8e90ae55663f79e986e4 +ad8d249b0aea9597b08358bce6c77c1fd552ef3fbc197d6a1cfe44e5e6f89b628b12a6fb04d5dcfcbacc51f46e4ae7bb +b998b2269932cbd58d04b8e898d373ac4bb1a62e8567484f4f83e224061bc0f212459f1daae95abdbc63816ae6486a55 +827988ef6c1101cddc96b98f4a30365ff08eea2471dd949d2c0a9b35c3bbfa8c07054ad1f4c88c8fbf829b20bb5a9a4f +8692e638dd60babf7d9f2f2d2ce58e0ac689e1326d88311416357298c6a2bffbfebf55d5253563e7b3fbbf5072264146 +a685d75b91aea04dbc14ab3c1b1588e6de96dae414c8e37b8388766029631b28dd860688079b12d09cd27f2c5af11adf +b57eced93eec3371c56679c259b34ac0992286be4f4ff9489d81cf9712403509932e47404ddd86f89d7c1c3b6391b28c +a1c8b4e42ebcbd8927669a97f1b72e236fb19249325659e72be7ddaaa1d9e81ca2abb643295d41a8c04a2c01f9c0efd7 +877c33de20d4ed31674a671ba3e8f01a316581e32503136a70c9c15bf0b7cb7b1cba6cd4eb641fad165fb3c3c6c235fd +a2a469d84ec478da40838f775d11ad38f6596eb41caa139cc190d6a10b5108c09febae34ffdafac92271d2e73c143693 +972f817caedb254055d52e963ed28c206848b6c4cfdb69dbc961c891f8458eaf582a6d4403ce1177d87bc2ea410ef60a +accbd739e138007422f28536381decc54bb6bd71d93edf3890e54f9ef339f83d2821697d1a4ac1f5a98175f9a9ecb9b5 +8940f8772e05389f823b62b3adc3ed541f91647f0318d7a0d3f293aeeb421013de0d0a3664ea53dd24e5fbe02d7efef6 +8ecce20f3ef6212edef07ec4d6183fda8e0e8cad2c6ccd0b325e75c425ee1faba00b5c26b4d95204238931598d78f49d +97cc72c36335bd008afbed34a3b0c7225933faba87f7916d0a6d2161e6f82e0cdcda7959573a366f638ca75d30e9dab1 +9105f5de8699b5bdb6bd3bb6cc1992d1eac23929c29837985f83b22efdda92af64d9c574aa9640475087201bbbe5fd73 +8ffb33c4f6d05c413b9647eb6933526a350ed2e4278ca2ecc06b0e8026d8dbe829c476a40e45a6df63a633090a3f82ef +8bfc6421fdc9c2d2aaa68d2a69b1a2728c25b84944cc3e6a57ff0c94bfd210d1cbf4ff3f06702d2a8257024d8be7de63 +a80e1dc1dddfb41a70220939b96dc6935e00b32fb8be5dff4eed1f1c650002ff95e4af481c43292e3827363b7ec4768a +96f714ebd54617198bd636ba7f7a7f8995a61db20962f2165078d9ed8ee764d5946ef3cbdc7ebf8435bb8d5dd4c1deac +8cdb0890e33144d66391d2ae73f5c71f5a861f72bc93bff6cc399fc25dd1f9e17d8772592b44593429718784802ac377 +8ccf9a7f80800ee770b92add734ed45a73ecc31e2af0e04364eefc6056a8223834c7c0dc9dfc52495bdec6e74ce69994 +aa0875f423bd68b5f10ba978ddb79d3b96ec093bfbac9ff366323193e339ed7c4578760fb60f60e93598bdf1e5cc4995 +a9214f523957b59c7a4cb61a40251ad72aba0b57573163b0dc0f33e41d2df483fb9a1b85a5e7c080e9376c866790f8cb +b6224b605028c6673a536cc8ff9aeb94e7a22e686fda82cf16068d326469172f511219b68b2b3affb7933af0c1f80d07 +b6d58968d8a017c6a34e24c2c09852f736515a2c50f37232ac6b43a38f8faa7572cc31dade543b594b61b5761c4781d0 +8a97cefe5120020c38deeb861d394404e6c993c6cbd5989b6c9ebffe24f46ad11b4ba6348e2991cbf3949c28cfc3c99d +95bf046f8c3a9c0ce2634be4de3713024daec3fc4083e808903b25ce3ac971145af90686b451efcc72f6b22df0216667 +a6a4e2f71b8fa28801f553231eff2794c0f10d12e7e414276995e21195abc9c2983a8997e41af41e78d19ff6fbb2680b +8e5e62a7ca9c2f58ebaab63db2ff1fb1ff0877ae94b7f5e2897f273f684ae639dff44cc65718f78a9c894787602ab26a +8542784383eec4f565fcb8b9fc2ad8d7a644267d8d7612a0f476fc8df3aff458897a38003d506d24142ad18f93554f2b +b7db68ba4616ea072b37925ec4fb39096358c2832cc6d35169e032326b2d6614479f765ae98913c267105b84afcb9bf2 +8b31dbb9457d23d416c47542c786e07a489af35c4a87dadb8ee91bea5ac4a5315e65625d78dad2cf8f9561af31b45390 +a8545a1d91ac17257732033d89e6b7111db8242e9c6ebb0213a88906d5ef407a2c6fdb444e29504b06368b6efb4f4839 +b1bd85d29ebb28ccfb05779aad8674906b267c2bf8cdb1f9a0591dd621b53a4ee9f2942687ee3476740c0b4a7621a3ae +a2b54534e152e46c50d91fff03ae9cd019ff7cd9f4168b2fe7ac08ef8c3bbc134cadd3f9d6bd33d20ae476c2a8596c8a +b19b571ff4ae3e9f5d95acda133c455e72c9ea9973cae360732859836c0341c4c29ab039224dc5bc3deb824e031675d8 +940b5f80478648bac025a30f3efeb47023ce20ee98be833948a248bca6979f206bb28fc0f17b90acf3bb4abd3d14d731 +8f106b40588586ac11629b96d57808ad2808915d89539409c97414aded90b4ff23286a692608230a52bff696055ba5d6 +ae6bda03aa10da3d2abbc66d764ca6c8d0993e7304a1bdd413eb9622f3ca1913baa6da1e9f4f9e6cf847f14f44d6924d +a18e7796054a340ef826c4d6b5a117b80927afaf2ebd547794c400204ae2caf277692e2eabb55bc2f620763c9e9da66d +8d2d25180dc2c65a4844d3e66819ccfcf48858f0cc89e1c77553b463ec0f7feb9a4002ce26bc618d1142549b9850f232 +863f413a394de42cc8166c1c75d513b91d545fff1de6b359037a742c70b008d34bf8e587afa2d62c844d0c6f0ea753e7 +83cd0cf62d63475e7fcad18a2e74108499cdbf28af2113cfe005e3b5887794422da450b1944d0a986eb7e1f4c3b18f25 +b4f8b350a6d88fea5ab2e44715a292efb12eb52df738c9b2393da3f1ddee68d0a75b476733ccf93642154bceb208f2b8 +b3f52aaa4cd4221cb9fc45936cc67fd3864bf6d26bf3dd86aa85aa55ecfc05f5e392ecce5e7cf9406b4b1c4fce0398c8 +b33137084422fb643123f40a6df2b498065e65230fc65dc31791c330e898c51c3a65ff738930f32c63d78f3c9315f85b +91452bfa75019363976bb7337fe3a73f1c10f01637428c135536b0cdc7da5ce558dae3dfc792aa55022292600814a8ef +ad6ba94c787cd4361ca642c20793ea44f1f127d4de0bb4a77c7fbfebae0fcadbf28e2cb6f0c12c12a07324ec8c19761d +890aa6248b17f1501b0f869c556be7bf2b1d31a176f9978bb97ab7a6bd4138eed32467951c5ef1871944b7f620542f43 +82111db2052194ee7dd22ff1eafffac0443cf969d3762cceae046c9a11561c0fdce9c0711f88ac01d1bed165f8a7cee3 +b1527b71df2b42b55832f72e772a466e0fa05743aacc7814f4414e4bcc8d42a4010c9e0fd940e6f254cafedff3cd6543 +922370fa49903679fc565f09c16a5917f8125e72acfeb060fcdbadbd1644eb9f4016229756019c93c6d609cda5d5d174 +aa4c7d98a96cab138d2a53d4aee8ebff6ef903e3b629a92519608d88b3bbd94de5522291a1097e6acf830270e64c8ee1 +b3dc21608a389a72d3a752883a382baaafc61ecc44083b832610a237f6a2363f24195acce529eb4aed4ef0e27a12b66e +94619f5de05e07b32291e1d7ab1d8b7337a2235e49d4fb5f3055f090a65e932e829efa95db886b32b153bdd05a53ec8c +ade1e92722c2ffa85865d2426fb3d1654a16477d3abf580cfc45ea4b92d5668afc9d09275d3b79283e13e6b39e47424d +b7201589de7bed094911dd62fcd25c459a8e327ac447b69f541cdba30233063e5ddffad0b67e9c3e34adcffedfd0e13d +809d325310f862d6549e7cb40f7e5fc9b7544bd751dd28c4f363c724a0378c0e2adcb5e42ec8f912f5f49f18f3365c07 +a79c20aa533de7a5d671c99eb9eb454803ba54dd4f2efa3c8fec1a38f8308e9905c71e9282955225f686146388506ff6 +a85eeacb5e8fc9f3ed06a3fe2dc3108ab9f8c5877b148c73cf26e4e979bf5795edbe2e63a8d452565fd1176ed40402b2 +97ef55662f8a1ec0842b22ee21391227540adf7708f491436044f3a2eb18c471525e78e1e14fa292507c99d74d7437c6 +93110d64ed5886f3d16ce83b11425576a3a7a9bb831cd0de3f9a0b0f2270a730d68136b4ef7ff035ede004358f419b5c +ac9ed0a071517f0ae4f61ce95916a90ba9a77a3f84b0ec50ef7298acdcd44d1b94525d191c39d6bd1bb68f4471428760 +98abd6a02c7690f5a339adf292b8c9368dfc12e0f8069cf26a5e0ce54b4441638f5c66ea735142f3c28e00a0024267e6 +b51efb73ba6d44146f047d69b19c0722227a7748b0e8f644d0fc9551324cf034c041a2378c56ce8b58d06038fb8a78de +8f115af274ef75c1662b588b0896b97d71f8d67986ae846792702c4742ab855952865ce236b27e2321967ce36ff93357 +b3c4548f14d58b3ab03c222da09e4381a0afe47a72d18d50a94e0008797f78e39e99990e5b4757be62310d400746e35a +a9b1883bd5f31f909b8b1b6dcb48c1c60ed20aa7374b3ffa7f5b2ed036599b5bef33289d23c80a5e6420d191723b92f7 +85d38dffd99487ae5bb41ab4a44d80a46157bbbe8ef9497e68f061721f74e4da513ccc3422936b059575975f6787c936 +adf870fcb96e972c033ab7a35d28ae79ee795f82bc49c3bd69138f0e338103118d5529c53f2d72a9c0d947bf7d312af2 +ab4c7a44e2d9446c6ff303eb49aef0e367a58b22cc3bb27b4e69b55d1d9ee639c9234148d2ee95f9ca8079b1457d5a75 +a386420b738aba2d7145eb4cba6d643d96bda3f2ca55bb11980b318d43b289d55a108f4bc23a9606fb0bccdeb3b3bb30 +847020e0a440d9c4109773ecca5d8268b44d523389993b1f5e60e541187f7c597d79ebd6e318871815e26c96b4a4dbb1 +a530aa7e5ca86fcd1bec4b072b55cc793781f38a666c2033b510a69e110eeabb54c7d8cbcb9c61fee531a6f635ffa972 +87364a5ea1d270632a44269d686b2402da737948dac27f51b7a97af80b66728b0256547a5103d2227005541ca4b7ed04 +8816fc6e16ea277de93a6d793d0eb5c15e9e93eb958c5ef30adaf8241805adeb4da8ce19c3c2167f971f61e0b361077d +8836a72d301c42510367181bb091e4be377777aed57b73c29ef2ce1d475feedd7e0f31676284d9a94f6db01cc4de81a2 +b0d9d8b7116156d9dde138d28aa05a33e61f8a85839c1e9071ccd517b46a5b4b53acb32c2edd7150c15bc1b4bd8db9e3 +ae931b6eaeda790ba7f1cd674e53dc87f6306ff44951fa0df88d506316a5da240df9794ccbd7215a6470e6b31c5ea193 +8c6d5bdf87bd7f645419d7c6444e244fe054d437ed1ba0c122fde7800603a5fadc061e5b836cb22a6cfb2b466f20f013 +90d530c6d0cb654999fa771b8d11d723f54b8a8233d1052dc1e839ea6e314fbed3697084601f3e9bbb71d2b4eaa596df +b0d341a1422588c983f767b1ed36c18b141774f67ef6a43cff8e18b73a009da10fc12120938b8bba27f225bdfd3138f9 +a131b56f9537f460d304e9a1dd75702ace8abd68cb45419695cb8dee76998139058336c87b7afd6239dc20d7f8f940cc +aa6c51fa28975f709329adee1bbd35d49c6b878041841a94465e8218338e4371f5cb6c17f44a63ac93644bf28f15d20f +88440fb584a99ebd7f9ea04aaf622f6e44e2b43bbb49fb5de548d24a238dc8f26c8da2ccf03dd43102bda9f16623f609 +9777b8695b790e702159a4a750d5e7ff865425b95fa0a3c15495af385b91c90c00a6bd01d1b77bffe8c47d01baae846f +8b9d764ece7799079e63c7f01690c8eff00896a26a0d095773dea7a35967a8c40db7a6a74692f0118bf0460c26739af4 +85808c65c485520609c9e61fa1bb67b28f4611d3608a9f7a5030ee61c3aa3c7e7dc17fff48af76b4aecee2cb0dbd22ac +ad2783a76f5b3db008ef5f7e67391fda4e7e36abde6b3b089fc4835b5c339370287935af6bd53998bed4e399eda1136d +96f18ec03ae47c205cc4242ca58e2eff185c9dca86d5158817e2e5dc2207ab84aadda78725f8dc080a231efdc093b940 +97de1ab6c6cc646ae60cf7b86df73b9cf56cc0cd1f31b966951ebf79fc153531af55ca643b20b773daa7cab784b832f7 +870ba266a9bfa86ef644b1ef025a0f1b7609a60de170fe9508de8fd53170c0b48adb37f19397ee8019b041ce29a16576 +ad990e888d279ac4e8db90619d663d5ae027f994a3992c2fbc7d262b5990ae8a243e19157f3565671d1cb0de17fe6e55 +8d9d5adcdd94c5ba3be4d9a7428133b42e485f040a28d16ee2384758e87d35528f7f9868de9bd23d1a42a594ce50a567 +85a33ed75d514ece6ad78440e42f7fcdb59b6f4cff821188236d20edae9050b3a042ce9bc7d2054296e133d033e45022 +92afd2f49a124aaba90de59be85ff269457f982b54c91b06650c1b8055f9b4b0640fd378df02a00e4fc91f7d226ab980 +8c0ee09ec64bd831e544785e3d65418fe83ed9c920d9bb4d0bf6dd162c1264eb9d6652d2def0722e223915615931581c +8369bedfa17b24e9ad48ebd9c5afea4b66b3296d5770e09b00446c5b0a8a373d39d300780c01dcc1c6752792bccf5fd0 +8b9e960782576a59b2eb2250d346030daa50bbbec114e95cdb9e4b1ba18c3d34525ae388f859708131984976ca439d94 +b682bface862008fea2b5a07812ca6a28a58fd151a1d54c708fc2f8572916e0d678a9cb8dc1c10c0470025c8a605249e +a38d5e189bea540a824b36815fc41e3750760a52be0862c4cac68214febdc1a754fb194a7415a8fb7f96f6836196d82a +b9e7fbda650f18c7eb8b40e42cc42273a7298e65e8be524292369581861075c55299ce69309710e5b843cb884de171bd +b6657e5e31b3193874a1bace08f42faccbd3c502fb73ad87d15d18a1b6c2a146f1baa929e6f517db390a5a47b66c0acf +ae15487312f84ed6265e4c28327d24a8a0f4d2d17d4a5b7c29b974139cf93223435aaebe3af918f5b4bb20911799715f +8bb4608beb06bc394e1a70739b872ce5a2a3ffc98c7547bf2698c893ca399d6c13686f6663f483894bccaabc3b9c56ad +b58ac36bc6847077584308d952c5f3663e3001af5ecf2e19cb162e1c58bd6c49510205d453cffc876ca1dc6b8e04a578 +924f65ced61266a79a671ffb49b300f0ea44c50a0b4e3b02064faa99fcc3e4f6061ea8f38168ab118c5d47bd7804590e +8d67d43b8a06b0ff4fafd7f0483fa9ed1a9e3e658a03fb49d9d9b74e2e24858dc1bed065c12392037b467f255d4e5643 +b4d4f87813125a6b355e4519a81657fa97c43a6115817b819a6caf4823f1d6a1169683fd68f8d025cdfa40ebf3069acb +a7fd4d2c8e7b59b8eed3d4332ae94b77a89a2616347402f880bc81bde072220131e6dbec8a605be3a1c760b775375879 +8d4a7d8fa6f55a30df37bcf74952e2fa4fd6676a2e4606185cf154bdd84643fd01619f8fb8813a564f72e3f574f8ce30 +8086fb88e6260e9a9c42e9560fde76315ff5e5680ec7140f2a18438f15bc2cc7d7d43bfb5880b180b738c20a834e6134 +916c4c54721de03934fee6f43de50bb04c81f6f8dd4f6781e159e71c40c60408aa54251d457369d133d4ba3ed7c12cb4 +902e5bf468f11ed9954e2a4a595c27e34abe512f1d6dc08bbca1c2441063f9af3dc5a8075ab910a10ff6c05c1c644a35 +a1302953015e164bf4c15f7d4d35e3633425a78294406b861675667eec77765ff88472306531e5d3a4ec0a2ff0dd6a9e +87874461df3c9aa6c0fa91325576c0590f367075f2f0ecfeb34afe162c04c14f8ce9d608c37ac1adc8b9985bc036e366 +84b50a8a61d3cc609bfb0417348133e698fe09a6d37357ce3358de189efcf35773d78c57635c2d26c3542b13cc371752 +acaed2cff8633d12c1d12bb7270c54d65b0b0733ab084fd47f81d0a6e1e9b6f300e615e79538239e6160c566d8bb8d29 +889e6a0e136372ca4bac90d1ab220d4e1cad425a710e8cdd48b400b73bb8137291ceb36a39440fa84305783b1d42c72f +90952e5becec45b2b73719c228429a2c364991cf1d5a9d6845ae5b38018c2626f4308daa322cab1c72e0f6c621bb2b35 +8f5a97a801b6e9dcd66ccb80d337562c96f7914e7169e8ff0fda71534054c64bf2a9493bb830623d612cfe998789be65 +84f3df8b9847dcf1d63ca470dc623154898f83c25a6983e9b78c6d2d90a97bf5e622445be835f32c1e55e6a0a562ea78 +91d12095cd7a88e7f57f254f02fdb1a1ab18984871dead2f107404bcf8069fe68258c4e6f6ebd2477bddf738135400bb +b771a28bc04baef68604d4723791d3712f82b5e4fe316d7adc2fc01b935d8e644c06d59b83bcb542afc40ebafbee0683 +872f6341476e387604a7e93ae6d6117e72d164e38ebc2b825bc6df4fcce815004d7516423c190c1575946b5de438c08d +90d6b4aa7d40a020cdcd04e8b016d041795961a8e532a0e1f4041252131089114a251791bf57794cadb7d636342f5d1c +899023ba6096a181448d927fed7a0fe858be4eac4082a42e30b3050ee065278d72fa9b9d5ce3bc1372d4cbd30a2f2976 +a28f176571e1a9124f95973f414d5bdbf5794d41c3839d8b917100902ac4e2171eb940431236cec93928a60a77ede793 +838dbe5bcd29c4e465d02350270fa0036cd46f8730b13d91e77afb7f5ed16525d0021d3b2ae173a76c378516a903e0cb +8e105d012dd3f5d20f0f1c4a7e7f09f0fdd74ce554c3032e48da8cce0a77260d7d47a454851387770f5c256fa29bcb88 +8f4df0f9feeb7a487e1d138d13ea961459a6402fd8f8cabb226a92249a0d04ded5971f3242b9f90d08da5ff66da28af6 +ad1cfda4f2122a20935aa32fb17c536a3653a18617a65c6836700b5537122af5a8206befe9eaea781c1244c43778e7f1 +832c6f01d6571964ea383292efc8c8fa11e61c0634a25fa180737cc7ab57bc77f25e614aac9a2a03d98f27b3c1c29de2 +903f89cc13ec6685ac7728521898781fecb300e9094ef913d530bf875c18bcc3ceed7ed51e7b482d45619ab4b025c2e9 +a03c474bb915aad94f171e8d96f46abb2a19c9470601f4c915512ec8b9e743c3938450a2a5b077b4618b9df8809e1dc1 +83536c8456f306045a5f38ae4be2e350878fa7e164ea408d467f8c3bc4c2ee396bd5868008c089183868e4dfad7aa50b +88f26b4ea1b236cb326cd7ad7e2517ec8c4919598691474fe15d09cabcfc37a8d8b1b818f4d112432ee3a716b0f37871 +a44324e3fe96e9c12b40ded4f0f3397c8c7ee8ff5e96441118d8a6bfad712d3ac990b2a6a23231a8f691491ac1fd480f +b0de4693b4b9f932191a21ee88629964878680152a82996c0019ffc39f8d9369bbe2fe5844b68d6d9589ace54af947e4 +8e5d8ba948aea5fd26035351a960e87f0d23efddd8e13236cc8e4545a3dda2e9a85e6521efb8577e03772d3637d213d9 +93efc82d2017e9c57834a1246463e64774e56183bb247c8fc9dd98c56817e878d97b05f5c8d900acf1fbbbca6f146556 +8731176363ad7658a2862426ee47a5dce9434216cef60e6045fa57c40bb3ce1e78dac4510ae40f1f31db5967022ced32 +b10c9a96745722c85bdb1a693100104d560433d45b9ac4add54c7646a7310d8e9b3ca9abd1039d473ae768a18e489845 +a2ac374dfbb464bf850b4a2caf15b112634a6428e8395f9c9243baefd2452b4b4c61b0cb2836d8eae2d57d4900bf407e +b69fe3ded0c4f5d44a09a0e0f398221b6d1bf5dbb8bc4e338b93c64f1a3cac1e4b5f73c2b8117158030ec03787f4b452 +8852cdbaf7d0447a8c6f211b4830711b3b5c105c0f316e3a6a18dcfbb9be08bd6f4e5c8ae0c3692da08a2dfa532f9d5c +93bbf6d7432a7d98ade3f94b57bf9f4da9bc221a180a370b113066dd42601bb9e09edd79e2e6e04e00423399339eebda +a80941c391f1eeafc1451c59e4775d6a383946ff22997aeaadf806542ba451d3b0f0c6864eeba954174a296efe2c1550 +a045fe2bb011c2a2f71a0181a8f457a3078470fb74c628eab8b59aef69ffd0d649723bf74d6885af3f028bc5a104fb39 +b9d8c35911009c4c8cad64692139bf3fc16b78f5a19980790cb6a7aea650a25df4231a4437ae0c351676a7e42c16134f +94c79501ded0cfcbab99e1841abe4a00a0252b3870e20774c3da16c982d74c501916ec28304e71194845be6e3113c7ab +900a66418b082a24c6348d8644ddb1817df5b25cb33044a519ef47cc8e1f7f1e38d2465b7b96d32ed472d2d17f8414c6 +b26f45d393b8b2fcb29bdbb16323dc7f4b81c09618519ab3a39f8ee5bd148d0d9f3c0b5dfab55b5ce14a1cb9206d777b +aa1a87735fc493a80a96a9a57ca40a6d9c32702bfcaa9869ce1a116ae65d69cefe2f3e79a12454b4590353e96f8912b4 +a922b188d3d0b69b4e4ea2a2aa076566962844637da12c0832105d7b31dea4a309eee15d12b7a336be3ea36fcbd3e3b7 +8f3841fcf4105131d8c4d9885e6e11a46c448226401cf99356c291fadb864da9fa9d30f3a73c327f23f9fd99a11d633e +9791d1183fae270e226379af6c497e7da803ea854bb20afa74b253239b744c15f670ee808f708ede873e78d79a626c9a +a4cad52e3369491ada61bf28ada9e85de4516d21c882e5f1cd845bea9c06e0b2887b0c5527fcff6fc28acd3c04f0a796 +b9ac86a900899603452bd11a7892a9bfed8054970bfcbeaa8c9d1930db891169e38d6977f5258c25734f96c8462eee3b +a3a154c28e5580656a859f4efc2f5ebfa7eaa84ca40e3f134fa7865e8581586db74992dbfa4036aa252fba103773ddde +95cc2a0c1885a029e094f5d737e3ecf4d26b99036453a8773c77e360101f9f98676ee246f6f732a377a996702d55691f +842651bbe99720438d8d4b0218feb60481280c05beb17750e9ca0d8c0599a60f873b7fbdcc7d8835ba9a6d57b16eec03 +81ee54699da98f5620307893dcea8f64670609fa20e5622265d66283adeac122d458b3308c5898e6c57c298db2c8b24f +b97868b0b2bc98032d68352a535a1b341b9ff3c7af4e3a7f3ebc82d3419daa1b5859d6aedc39994939623c7cd878bd9b +b60325cd5d36461d07ef253d826f37f9ee6474a760f2fff80f9873d01fd2b57711543cdc8d7afa1c350aa753c2e33dea +8c205326c11d25a46717b780c639d89714c7736c974ae71287e3f4b02e6605ac2d9b4928967b1684f12be040b7bf2dd3 +95a392d82db51e26ade6c2ccd3396d7e40aff68fa570b5951466580d6e56dda51775dce5cf3a74a7f28c3cb2eb551c4d +8f2cc8071eb56dffb70bda6dd433b556221dc8bba21c53353c865f00e7d4d86c9e39f119ea9a8a12ef583e9a55d9a6b6 +9449a71af9672aaf8856896d7e3d788b22991a7103f75b08c0abbcc2bfe60fda4ed8ce502cea4511ff0ea52a93e81222 +857090ab9fdb7d59632d068f3cc8cf27e61f0d8322d30e6b38e780a1f05227199b4cd746aac1311c36c659ef20931f28 +98a891f4973e7d9aaf9ac70854608d4f7493dffc7e0987d7be9dd6029f6ea5636d24ef3a83205615ca1ff403750058e1 +a486e1365bbc278dd66a2a25d258dc82f46b911103cb16aab3945b9c95ae87b386313a12b566df5b22322ede0afe25ad +a9a1eb399ed95d396dccd8d1ac718043446f8b979ec62bdce51c617c97a312f01376ab7fb87d27034e5f5570797b3c33 +b7abc3858d7a74bb446218d2f5a037e0fae11871ed9caf44b29b69c500c1fa1dcfad64c9cdccc9d80d5e584f06213deb +8cfb09fe2e202faa4cebad932b1d35f5ca204e1c2a0c740a57812ac9a6792130d1312aabd9e9d4c58ca168bfebd4c177 +a90a305c2cd0f184787c6be596fa67f436afd1f9b93f30e875f817ac2aae8bdd2e6e656f6be809467e6b3ad84adb86b1 +80a9ef993c2b009ae172cc8f7ec036f5734cf4f4dfa06a7db4d54725e7fbfae5e3bc6f22687bdbb6961939d6f0c87537 +848ade1901931e72b955d7db1893f07003e1708ff5d93174bac5930b9a732640f0578839203e9b77eb27965c700032d3 +93fdf4697609c5ae9c33b9ca2f5f1af44abeb2b98dc4fdf732cf7388de086f410730dc384d9b7a7f447bb009653c8381 +89ce3fb805aea618b5715c0d22a9f46da696b6fa86794f56fdf1d44155a33d42daf1920bcbe36cbacf3cf4c92df9cbc7 +829ce2c342cf82aa469c65f724f308f7a750bd1494adc264609cd790c8718b8b25b5cab5858cf4ee2f8f651d569eea67 +af2f0cee7bf413204be8b9df59b9e4991bc9009e0d6dbe6815181df0ec2ca93ab8f4f3135b1c14d8f53d74bff0bd6f27 +b87998cecf7b88cde93d1779f10a521edd5574a2fbd240102978639ec57433ba08cdb53849038a329cebbe74657268d2 +a64542a1261a6ed3d720c2c3a802303aad8c4c110c95d0f12e05c1065e66f42da494792b6bfc5b9272363f3b1d457f58 +86a6fd042e4f282fadf07a4bfee03fc96a3aea49f7a00f52bf249a20f1ec892326855410e61f37fbb27d9305eb2fc713 +967ea5bc403b6db269682f7fd0df90659350d7e1aa66bc4fab4c9dfcd75ed0bba4b52f1cebc5f34dc8ba810793727629 +a52990f9f3b8616ce3cdc2c74cd195029e6a969753dcf2d1630438700e7d6ebde36538532b3525ac516f5f2ce9dd27a3 +a64f7ff870bab4a8bf0d4ef6f5c744e9bf1021ed08b4c80903c7ad318e80ba1817c3180cc45cb5a1cae1170f0241655f +b00f706fa4de1f663f021e8ad3d155e84ce6084a409374b6e6cd0f924a0a0b51bebaaaf1d228c77233a73b0a5a0df0e9 +8b882cc3bff3e42babdb96df95fb780faded84887a0a9bab896bef371cdcf169d909f5658649e93006aa3c6e1146d62e +9332663ef1d1dcf805c3d0e4ce7a07d9863fb1731172e766b3cde030bf81682cc011e26b773fb9c68e0477b4ae2cfb79 +a8aa8151348dbd4ef40aaeb699b71b4c4bfd3218560c120d85036d14f678f6736f0ec68e80ce1459d3d35feccc575164 +a16cd8b729768f51881c213434aa28301fa78fcb554ddd5f9012ee1e4eae7b5cb3dd88d269d53146dea92d10790faf0b +86844f0ef9d37142faf3b1e196e44fbe280a3ba4189aa05c356778cb9e3b388a2bff95eed305ada8769935c9974e4c57 +ae2eec6b328fccf3b47bcdac32901ac2744a51beb410b04c81dea34dee4912b619466a4f5e2780d87ecefaebbe77b46d +915df4c38d301c8a4eb2dc5b1ba0ffaad67cbb177e0a80095614e9c711f4ef24a4cef133f9d982a63d2a943ba6c8669d +ae6a2a4dedfc2d1811711a8946991fede972fdf2a389b282471280737536ffc0ac3a6d885b1f8bda0366eb0b229b9979 +a9b628c63d08b8aba6b1317f6e91c34b2382a6c85376e8ef2410a463c6796740ae936fc4e9e0737cb9455d1daa287bd8 +848e30bf7edf2546670b390d5cf9ab71f98fcb6add3c0b582cb34996c26a446dee5d1bde4fdcde4fc80c10936e117b29 +907d6096c7c8c087d1808dd995d5d2b9169b3768c3f433475b50c2e2bd4b082f4d543afd8b0b0ddffa9c66222a72d51d +a59970a2493b07339124d763ac9d793c60a03354539ecbcf6035bc43d1ea6e35718202ae6d7060b7d388f483d971573c +b9cfef2af9681b2318f119d8611ff6d9485a68d8044581b1959ab1840cbca576dbb53eec17863d2149966e9feb21122f +ad47271806161f61d3afa45cdfe2babceef5e90031a21779f83dc8562e6076680525b4970b2f11fe9b2b23c382768323 +8e425a99b71677b04fe044625d338811fbb8ee32368a424f6ab2381c52e86ee7a6cecedf777dc97181519d41c351bc22 +86b55b54d7adefc12954a9252ee23ae83efe8b5b4b9a7dc307904413e5d69868c7087a818b2833f9b004213d629be8ad +a14fda6b93923dd11e564ae4457a66f397741527166e0b16a8eb91c6701c244fd1c4b63f9dd3515193ec88fa6c266b35 +a9b17c36ae6cd85a0ed7f6cabc5b47dc8f80ced605db327c47826476dc1fb8f8669aa7a7dc679fbd4ee3d8e8b4bd6a6f +82a0829469c1458d959c821148f15dacae9ea94bf56c59a6ab2d4dd8b3d16d73e313b5a3912a6c1f131d73a8f06730c4 +b22d56d549a53eaef549595924bdb621ff807aa4513feedf3fdcbf7ba8b6b9cfa4481c2f67fc642db397a6b794a8b63a +974c59c24392e2cb9294006cbe3c52163e255f3bd0c2b457bdc68a6338e6d5b6f87f716854492f8d880a6b896ccf757c +b70d247ba7cad97c50b57f526c2ba915786e926a94e8f8c3eebc2e1be6f4255411b9670e382060049c8f4184302c40b2 +ad80201fe75ef21c3ddbd98cf23591e0d7a3ba1036dfe77785c32f44755a212c31f0ceb0a0b6f5ee9b6dc81f358d30c3 +8c656e841f9bb90b9a42d425251f3fdbc022a604d75f5845f479ed4be23e02aaf9e6e56cde351dd7449c50574818a199 +8b88dd3fa209d3063b7c5b058f7249ee9900fbc2287d16da61a0704a0a1d71e45d9c96e1cda7fdf9654534ec44558b22 +961da00cc8750bd84d253c08f011970ae1b1158ad6778e8ed943d547bceaf52d6d5a212a7de3bf2706688c4389b827d2 +a5dd379922549a956033e3d51a986a4b1508e575042b8eaa1df007aa77cf0b8c2ab23212f9c075702788fa9c53696133 +ac8fcfde3a349d1e93fc8cf450814e842005c545c4844c0401bc80e6b96cdb77f29285a14455e167c191d4f312e866cd +ac63d79c799783a8466617030c59dd5a8f92ee6c5204676fd8d881ce5f7f8663bdbeb0379e480ea9b6340ab0dc88e574 +805874fde19ce359041ae2bd52a39e2841acabfd31f965792f2737d7137f36d4e4722ede8340d8c95afa6af278af8acb +8d2f323a228aa8ba7b7dc1399138f9e6b41df1a16a7069003ab8104b8b68506a45141bc5fe66acf430e23e13a545190b +a1610c721a2d9af882bb6b39bea97cff1527a3aea041d25934de080214ae77c959e79957164440686d15ab301e897d4d +aba16d29a47fc36f12b654fde513896723e2c700c4190f11b26aa4011da57737ad717daa02794aa3246e4ae5f0b0cc3a +a406db2f15fdd135f346cc4846623c47edd195e80ba8c7cb447332095314d565e4040694ca924696bb5ee7f8996ea0ba +8b30e2cd9b47d75ba57b83630e40f832249af6c058d4f490416562af451993eec46f3e1f90bc4d389e4c06abd1b32a46 +aacf9eb7036e248e209adbfc3dd7ce386569ea9b312caa4b240726549db3c68c4f1c8cbf8ed5ea9ea60c7e57c9df3b8e +b20fcac63bf6f5ee638a42d7f89be847f348c085ddcbec3fa318f4323592d136c230495f188ef2022aa355cc2b0da6f9 +811eff750456a79ec1b1249d76d7c1547065b839d8d4aaad860f6d4528eb5b669473dcceeeea676cddbc3980b68461b7 +b52d14ae33f4ab422f953392ae76a19c618cc31afc96290bd3fe2fb44c954b5c92c4789f3f16e8793f2c0c1691ade444 +a7826dafeeba0db5b66c4dfcf2b17fd7b40507a5a53ac2e42942633a2cb30b95ba1739a6e9f3b7a0e0f1ec729bf274e2 +8acfd83ddf7c60dd7c8b20c706a3b972c65d336b8f9b3d907bdd8926ced271430479448100050b1ef17578a49c8fa616 +af0c69f65184bb06868029ad46f8465d75c36814c621ac20a5c0b06a900d59305584f5a6709683d9c0e4b6cd08d650a6 +b6cc8588191e00680ee6c3339bd0f0a17ad8fd7f4be57d5d7075bede0ea593a19e67f3d7c1a20114894ee5bfcab71063 +a82fd4f58635129dbb6cc3eb9391cf2d28400018b105fc41500fbbd12bd890b918f97d3d359c29dd3b4c4e34391dfab0 +92fc544ed65b4a3625cf03c41ddff7c039bc22d22c0d59dcc00efd5438401f2606adb125a1d5de294cca216ec8ac35a3 +906f67e4a32582b71f15940523c0c7ce370336935e2646bdaea16a06995256d25e99df57297e39d6c39535e180456407 +97510337ea5bbd5977287339197db55c60533b2ec35c94d0a460a416ae9f60e85cee39be82abeeacd5813cf54df05862 +87e6894643815c0ea48cb96c607266c5ee4f1f82ba5fe352fb77f9b6ed14bfc2b8e09e80a99ac9047dfcf62b2ae26795 +b6fd55dd156622ad7d5d51b7dde75e47bd052d4e542dd6449e72411f68275775c846dde301e84613312be8c7bce58b07 +b98461ac71f554b2f03a94e429b255af89eec917e208a8e60edf5fc43b65f1d17a20de3f31d2ce9f0cb573c25f2f4d98 +96f0dea40ca61cefbee41c4e1fe9a7d81fbe1f49bb153d083ab70f5d0488a1f717fd28cedcf6aa18d07cce2c62801898 +8d7c3ab310184f7dc34b6ce4684e4d29a31e77b09940448ea4daac730b7eb308063125d4dd229046cf11bfd521b771e0 +96f0564898fe96687918bbf0a6adead99cf72e3a35ea3347e124af9d006221f8e82e5a9d2fe80094d5e8d48e610f415e +ad50fcb92c2675a398cf07d4c40a579e44bf8d35f27cc330b57e54d5ea59f7d898af0f75dccfe3726e5471133d70f92b +828beed62020361689ae7481dd8f116902b522fb0c6c122678e7f949fdef70ead011e0e6bffd25678e388744e17cdb69 +8349decac1ca16599eee2efc95bcaabf67631107da1d34a2f917884bd70dfec9b4b08ab7bc4379d6c73b19c0b6e54fb8 +b2a6a2e50230c05613ace9e58bb2e98d94127f196f02d9dddc53c43fc68c184549ca12d713cb1b025d8260a41e947155 +94ff52181aadae832aed52fc3b7794536e2a31a21fc8be3ea312ca5c695750d37f08002f286b33f4023dba1e3253ecfa +a21d56153c7e5972ee9a319501be4faff199fdf09bb821ea9ce64aa815289676c00f105e6f00311b3a5b627091b0d0fc +a27a60d219f1f0c971db73a7f563b371b5c9fc3ed1f72883b2eac8a0df6698400c9954f4ca17d7e94e44bd4f95532afb +a2fc56fae99b1f18ba5e4fe838402164ce82f8a7f3193d0bbd360c2bac07c46f9330c4c7681ffb47074c6f81ee6e7ac6 +b748e530cd3afb96d879b83e89c9f1a444f54e55372ab1dcd46a0872f95ce8f49cf2363fc61be82259e04f555937ed16 +8bf8993e81080c7cbba1e14a798504af1e4950b2f186ab3335b771d6acaee4ffe92131ae9c53d74379d957cb6344d9cd +96774d0ef730d22d7ab6d9fb7f90b9ead44285219d076584a901960542756700a2a1603cdf72be4708b267200f6c36a9 +b47703c2ab17be1e823cc7bf3460db1d6760c0e33862c90ca058845b2ff234b0f9834ddba2efb2ee1770eb261e7d8ffd +84319e67c37a9581f8b09b5e4d4ae88d0a7fb4cbb6908971ab5be28070c3830f040b1de83ee663c573e0f2f6198640e4 +96811875fa83133e0b3c0e0290f9e0e28bca6178b77fdf5350eb19344d453dbd0d71e55a0ef749025a5a2ca0ad251e81 +81a423423e9438343879f2bfd7ee9f1c74ebebe7ce3cfffc8a11da6f040cc4145c3b527bd3cf63f9137e714dbcb474ef +b8c3535701ddbeec2db08e17a4fa99ba6752d32ece5331a0b8743676f421fcb14798afc7c783815484f14693d2f70db8 +81aee980c876949bf40782835eec8817d535f6f3f7e00bf402ddd61101fdcd60173961ae90a1cf7c5d060339a18c959d +87e67b928d97b62c49dac321ce6cb680233f3a394d4c9a899ac2e8db8ccd8e00418e66cdfd68691aa3cb8559723b580c +8eac204208d99a2b738648df96353bbb1b1065e33ee4f6bba174b540bbbd37d205855e1f1e69a6b7ff043ca377651126 +848e6e7a54ad64d18009300b93ea6f459ce855971dddb419b101f5ac4c159215626fadc20cc3b9ab1701d8f6dfaddd8b +88aa123d9e0cf309d46dddb6acf634b1ade3b090a2826d6e5e78669fa1220d6df9a6697d7778cd9b627db17eea846126 +9200c2a629b9144d88a61151b661b6c4256cc5dadfd1e59a8ce17a013c2d8f7e754aabe61663c3b30f1bc47784c1f8cf +b6e1a2827c3bdda91715b0e1b1f10dd363cef337e7c80cac1f34165fc0dea7c8b69747e310563db5818390146ce3e231 +92c333e694f89f0d306d54105b2a5dcc912dbe7654d9e733edab12e8537350815be472b063e56cfde5286df8922fdecb +a6fac04b6d86091158ebb286586ccfec2a95c9786e14d91a9c743f5f05546073e5e3cc717635a0c602cad8334e922346 +a581b4af77feebc1fb897d49b5b507c6ad513d8f09b273328efbb24ef0d91eb740d01b4d398f2738125dacfe550330cd +81c4860cccf76a34f8a2bc3f464b7bfd3e909e975cce0d28979f457738a56e60a4af8e68a3992cf273b5946e8d7f76e2 +8d1eaa09a3180d8af1cbaee673db5223363cc7229a69565f592fa38ba0f9d582cedf91e15dabd06ebbf2862fc0feba54 +9832f49b0147f4552402e54593cfa51f99540bffada12759b71fcb86734be8e500eea2d8b3d036710bdf04c901432de9 +8bdb0e8ec93b11e5718e8c13cb4f5de545d24829fd76161216340108098dfe5148ed25e3b57a89a516f09fa79043734d +ab96f06c4b9b0b2c0571740b24fca758e6976315053a7ecb20119150a9fa416db2d3a2e0f8168b390bb063f0c1caf785 +ab777f5c52acd62ecf4d1f168b9cc8e1a9b45d4ec6a8ff52c583e867c2239aba98d7d3af977289b367edce03d9c2dfb1 +a09d3ce5e748da84802436951acc3d3ea5d8ec1d6933505ed724d6b4b0d69973ab0930daec9c6606960f6e541e4a3ce2 +8ef94f7be4d85d5ad3d779a5cf4d7b2fc3e65c52fb8e1c3c112509a4af77a0b5be994f251e5e40fabeeb1f7d5615c22b +a7406a5bf5708d9e10922d3c5c45c03ef891b8d0d74ec9f28328a72be4cdc05b4f2703fa99366426659dfca25d007535 +b7f52709669bf92a2e070bfe740f422f0b7127392c5589c7f0af71bb5a8428697c762d3c0d74532899da24ea7d8695c2 +b9dfb0c8df84104dbf9239ccefa4672ef95ddabb8801b74997935d1b81a78a6a5669a3c553767ec19a1281f6e570f4ff +ae4d5c872156061ce9195ac640190d8d71dd406055ee43ffa6f9893eb24b870075b74c94d65bc1d5a07a6573282b5520 +afe6bd3eb72266d333f1807164900dcfa02a7eb5b1744bb3c86b34b3ee91e3f05e38fa52a50dc64eeb4bdb1dd62874b8 +948043cf1bc2ef3c01105f6a78dc06487f57548a3e6ef30e6ebc51c94b71e4bf3ff6d0058c72b6f3ecc37efd7c7fa8c0 +a22fd17c2f7ffe552bb0f23fa135584e8d2d8d75e3f742d94d04aded2a79e22a00dfe7acbb57d44e1cdb962fb22ae170 +8cd0f4e9e4fb4a37c02c1bde0f69359c43ab012eb662d346487be0c3758293f1ca560122b059b091fddce626383c3a8f +90499e45f5b9c81426f3d735a52a564cafbed72711d9279fdd88de8038e953bc48c57b58cba85c3b2e4ce56f1ddb0e11 +8c30e4c034c02958384564cac4f85022ef36ab5697a3d2feaf6bf105049675bbf23d01b4b6814711d3d9271abff04cac +81f7999e7eeea30f3e1075e6780bbf054f2fb6f27628a2afa4d41872a385b4216dd5f549da7ce6cf39049b2251f27fb7 +b36a7191f82fc39c283ffe53fc1f5a9a00b4c64eee7792a8443475da9a4d226cf257f226ea9d66e329af15d8f04984ec +aad4da528fdbb4db504f3041c747455baff5fcd459a2efd78f15bdf3aea0bdb808343e49df88fe7a7c8620009b7964a3 +99ebd8c6dd5dd299517fb6381cfc2a7f443e6e04a351440260dd7c2aee3f1d8ef06eb6c18820b394366ecdfd2a3ce264 +8873725b81871db72e4ec3643084b1cdce3cbf80b40b834b092767728605825c19b6847ad3dcf328438607e8f88b4410 +b008ee2f895daa6abd35bd39b6f7901ae4611a11a3271194e19da1cdcc7f1e1ea008fe5c5440e50d2c273784541ad9c5 +9036feafb4218d1f576ef89d0e99124e45dacaa6d816988e34d80f454d10e96809791d5b78f7fd65f569e90d4d7238c5 +92073c1d11b168e4fa50988b0288638b4868e48bbc668c5a6dddf5499875d53be23a285acb5e4bad60114f6cf6c556e9 +88c87dfcb8ba6cbfe7e1be081ccfadbd589301db2cb7c99f9ee5d7db90aa297ed1538d5a867678a763f2deede5fd219a +b42a562805c661a50f5dea63108002c0f27c0da113da6a9864c9feb5552225417c0356c4209e8e012d9bcc9d182c7611 +8e6317d00a504e3b79cd47feb4c60f9df186467fe9ca0f35b55c0364db30528f5ff071109dabb2fc80bb9cd4949f0c24 +b7b1ea6a88694f8d2f539e52a47466695e39e43a5eb9c6f23bca15305fe52939d8755cc3ac9d6725e60f82f994a3772f +a3cd55161befe795af93a38d33290fb642b8d80da8b786c6e6fb02d393ea308fbe87f486994039cbd7c7b390414594b6 +b416d2d45b44ead3b1424e92c73c2cf510801897b05d1724ff31cbd741920cd858282fb5d6040fe1f0aa97a65bc49424 +950ee01291754feace97c2e933e4681e7ddfbc4fcd079eb6ff830b0e481d929c93d0c7fb479c9939c28ca1945c40da09 +869bd916aee8d86efe362a49010382674825d49195b413b4b4018e88ce43fe091b475d0b863ff0ba2259400f280c2b23 +9782f38cd9c9d3385ec286ebbc7cba5b718d2e65a5890b0a5906b10a89dc8ed80d417d71d7c213bf52f2af1a1f513ea7 +91cd33bc2628d096269b23faf47ee15e14cb7fdc6a8e3a98b55e1031ea0b68d10ba30d97e660f7e967d24436d40fad73 +8becc978129cc96737034c577ae7225372dd855da8811ae4e46328e020c803833b5bdbc4a20a93270e2b8bd1a2feae52 +a36b1d8076783a9522476ce17f799d78008967728ce920531fdaf88303321bcaf97ecaa08e0c01f77bc32e53c5f09525 +b4720e744943f70467983aa34499e76de6d59aa6fadf86f6b787fdce32a2f5b535b55db38fe2da95825c51002cfe142d +91ad21fc502eda3945f6de874d1b6bf9a9a7711f4d61354f9e5634fc73f9c06ada848de15ab0a75811d3250be862827d +84f78e2ebf5fc077d78635f981712daf17e2475e14c2a96d187913006ad69e234746184a51a06ef510c9455b38acb0d7 +960aa7906e9a2f11db64a26b5892ac45f20d2ccb5480f4888d89973beb6fa0dfdc06d68d241ff5ffc7f1b82b1aac242d +a99365dcd1a00c66c9db6924b97c920f5c723380e823b250db85c07631b320ec4e92e586f7319e67a522a0578f7b6d6c +a25d92d7f70cf6a88ff317cfec071e13774516da664f5fac0d4ecaa65b8bf4eb87a64a4d5ef2bd97dfae98d388dbf5cc +a7af47cd0041295798f9779020a44653007444e8b4ef0712982b06d0dcdd434ec4e1f7c5f7a049326602cb605c9105b7 +aefe172eac5568369a05980931cc476bebd9dea573ba276d59b9d8c4420784299df5a910033b7e324a6c2dfc62e3ef05 +b69bc9d22ffa645baa55e3e02522e9892bb2daa7fff7c15846f13517d0799766883ee09ae0869df4139150c5b843ca8a +95a10856140e493354fdd12722c7fdded21b6a2ffbc78aa2697104af8ad0c8e2206f44b0bfee077ef3949d46bbf7c16b +891f2fcd2c47cbea36b7fa715968540c233313f05333f09d29aba23c193f462ed490dd4d00969656e89c53155fdfe710 +a6c33e18115e64e385c843dde34e8a228222795c7ca90bc2cc085705d609025f3351d9be61822c69035a49fb3e48f2d5 +b87fb12f12c0533b005adad0487f03393ff682e13575e3cb57280c3873b2c38ba96a63c49eef7a442753d26b7005230b +b905c02ba451bfd411c135036d92c27af3b0b1c9c2f1309d6948544a264b125f39dd41afeff4666b12146c545adc168a +8b29c513f43a78951cf742231cf5457a6d9d55edf45df5481a0f299a418d94effef561b15d2c1a01d1b8067e7153fda9 +b9941cccd51dc645920d2781c81a317e5a33cb7cf76427b60396735912cb6d2ca9292bb4d36b6392467d390d2c58d9f3 +a8546b627c76b6ef5c93c6a98538d8593dbe21cb7673fd383d5401b0c935eea0bdeeefeb1af6ad41bad8464fb87bbc48 +aa286b27de2812de63108a1aec29d171775b69538dc6198640ac1e96767c2b83a50391f49259195957d457b493b667c9 +a932fb229f641e9abbd8eb2bd874015d97b6658ab6d29769fc23b7db9e41dd4f850382d4c1f08af8f156c5937d524473 +a1412840fcc86e2aeec175526f2fb36e8b3b8d21a78412b7266daf81e51b3f68584ed8bd42a66a43afdd8c297b320520 +89c78be9efb624c97ebca4fe04c7704fa52311d183ffd87737f76b7dadc187c12c982bd8e9ed7cd8beb48cdaafd2fd01 +a3f5ddec412a5bec0ce15e3bcb41c6214c2b05d4e9135a0d33c8e50a78eaba71e0a5a6ea8b45854dec5c2ed300971fc2 +9721f9cec7a68b7758e3887548790de49fa6a442d0396739efa20c2f50352a7f91d300867556d11a703866def2d5f7b5 +a23764e140a87e5991573521af039630dd28128bf56eed2edbed130fd4278e090b60cf5a1dca9de2910603d44b9f6d45 +a1a6494a994215e48ab55c70efa8ffdddce6e92403c38ae7e8dd2f8288cad460c6c7db526bbdf578e96ca04d9fe12797 +b1705ea4cb7e074efe0405fc7b8ee2ec789af0426142f3ec81241cacd4f7edcd88e39435e4e4d8e7b1df64f3880d6613 +85595d061d677116089a6064418b93eb44ff79e68d12bd9625078d3bbc440a60d0b02944eff6054433ee34710ae6fbb4 +9978d5e30bedb7526734f9a1febd973a70bfa20890490e7cc6f2f9328feab1e24f991285dbc3711d892514e2d7d005ad +af30243c66ea43b9f87a061f947f7bce745f09194f6e95f379c7582b9fead920e5d6957eaf05c12ae1282ada4670652f +a1930efb473f88001e47aa0b2b2a7566848cccf295792e4544096ecd14ee5d7927c173a8576b405bfa2eec551cd67eb5 +b0446d1c590ee5a45f7e22d269c044f3848c97aec1d226b44bfd0e94d9729c28a38bccddc3a1006cc5fe4e3c24f001f2 +b8a8380172df3d84b06176df916cf557966d4f2f716d3e9437e415d75b646810f79f2b2b71d857181b7fc944018883a3 +a563afec25b7817bfa26e19dc9908bc00aa8fc3d19be7d6de23648701659009d10e3e4486c28e9c6b13d48231ae29ac5 +a5a8e80579de886fb7d6408f542791876885947b27ad6fa99a8a26e381f052598d7b4e647b0115d4b5c64297e00ce28e +8f87afcc7ad33c51ac719bade3cd92da671a37a82c14446b0a2073f4a0a23085e2c8d31913ed2d0be928f053297de8f6 +a43c455ce377e0bc434386c53c752880687e017b2f5ae7f8a15c044895b242dffde4c92fb8f8bb50b18470b17351b156 +8368f8b12a5bceb1dba25adb3a2e9c7dc9b1a77a1f328e5a693f5aec195cd1e06b0fe9476b554c1c25dac6c4a5b640a3 +919878b27f3671fc78396f11531c032f3e2bd132d04cc234fa4858676b15fb1db3051c0b1db9b4fc49038216f11321ce +b48cd67fb7f1242696c1f877da4bdf188eac676cd0e561fbac1a537f7b8229aff5a043922441d603a26aae56a15faee4 +a3e0fdfd4d29ea996517a16f0370b54787fefe543c2fe73bfc6f9e560c1fd30dad8409859e2d7fa2d44316f24746c712 +8bb156ade8faf149df7bea02c140c7e392a4742ae6d0394d880a849127943e6f26312033336d3b9fdc0092d71b5efe87 +8845e5d5cc555ca3e0523244300f2c8d7e4d02aaebcb5bd749d791208856c209a6f84dd99fd55968c9f0ab5f82916707 +a3e90bb5c97b07789c2f32dff1aec61d0a2220928202f5ad5355ae71f8249237799d6c8a22602e32e572cb12eabe0c17 +b150bcc391884c996149dc3779ce71f15dda63a759ee9cc05871f5a8379dcb62b047098922c0f26c7bd04deb394c33f9 +95cd4ad88d51f0f2efcfd0c2df802fe252bb9704d1afbf9c26a248df22d55da87bdfaf41d7bc6e5df38bd848f0b13f42 +a05a49a31e91dff6a52ac8b9c2cfdd646a43f0d488253f9e3cfbce52f26667166bbb9b608fc358763a65cbf066cd6d05 +a59c3c1227fdd7c2e81f5e11ef5c406da44662987bac33caed72314081e2eed66055d38137e01b2268e58ec85dd986c0 +b7020ec3bd73a99861f0f1d88cf5a19abab1cbe14b7de77c9868398c84bb8e18dbbe9831838a96b6d6ca06e82451c67b +98d1ff2525e9718ee59a21d8900621636fcd873d9a564b8dceb4be80a194a0148daf1232742730b3341514b2e5a5436c +886d97b635975fc638c1b6afc493e5998ca139edba131b75b65cfe5a8e814f11bb678e0eeee5e6e5cd913ad3f2fefdfc +8fb9fd928d38d5d813b671c924edd56601dd7163b686c13f158645c2f869d9250f3859aa5463a39258c90fef0f41190a +aac35e1cd655c94dec3580bb3800bd9c2946c4a9856f7d725af15fbea6a2d8ca51c8ad2772abed60ee0e3fb9cb24046b +b8d71fa0fa05ac9e443c9b4929df9e7f09a919be679692682e614d24227e04894bfc14a5c73a62fb927fedff4a0e4aa7 +a45a19f11fbbb531a704badbb813ed8088ab827c884ee4e4ebf363fa1132ff7cfa9d28be9c85b143e4f7cdbc94e7cf1a +82b54703a4f295f5471b255ab59dce00f0fe90c9fb6e06b9ee48b15c91d43f4e2ef4a96c3118aeb03b08767be58181bb +8283264c8e6d2a36558f0d145c18576b6600ff45ff99cc93eca54b6c6422993cf392668633e5df396b9331e873d457e5 +8c549c03131ead601bc30eb6b9537b5d3beb7472f5bb1bcbbfd1e9f3704477f7840ab3ab7f7dc13bbbbcdff886a462d4 +afbb0c520ac1b5486513587700ad53e314cb74bfbc12e0b5fbdcfdaac36d342e8b59856196a0d84a25cff6e6e1d17e76 +89e4c22ffb51f2829061b3c7c1983c5c750cad158e3a825d46f7cf875677da5d63f653d8a297022b5db5845c9271b32b +afb27a86c4c2373088c96b9adf4433f2ebfc78ac5c526e9f0510670b6e4e5e0057c0a4f75b185e1a30331b9e805c1c15 +a18e16b57445f88730fc5d3567bf5a176861dc14c7a08ed2996fe80eed27a0e7628501bcb78a1727c5e9ac55f29c12c4 +93d61bf88b192d6825cf4e1120af1c17aa0f994d158b405e25437eaeefae049f7b721a206e7cc8a04fdc29d3c42580a1 +a99f2995a2e3ed2fd1228d64166112038de2f516410aa439f4c507044e2017ea388604e2d0f7121256fadf7fbe7023d1 +914fd91cffc23c32f1c6d0e98bf660925090d873367d543034654389916f65f552e445b0300b71b61b721a72e9a5983c +b42a578a7787b71f924e7def425d849c1c777156b1d4170a8ee7709a4a914e816935131afd9a0412c4cb952957b20828 +82fb30590e84b9e45db1ec475a39971cf554dc01bcc7050bc89265740725c02e2be5a972168c5170c86ae83e5b0ad2c0 +b14f8d8e1e93a84976289e0cf0dfa6f3a1809e98da16ee5c4932d0e1ed6bf8a07697fdd4dd86a3df84fb0003353cdcc0 +85d7a2f4bda31aa2cb208b771fe03291a4ebdaf6f1dc944c27775af5caec412584c1f45bc741fca2a6a85acb3f26ad7d +af02e56ce886ff2253bc0a68faad76f25ead84b2144e5364f3fb9b648f03a50ee9dc0b2c33ebacf7c61e9e43201ef9ef +87e025558c8a0b0abd06dfc350016847ea5ced7af2d135a5c9eec9324a4858c4b21510fb0992ec52a73447f24945058e +80fff0bafcd058118f5e7a4d4f1ae0912efeb281d2cbe4d34ba8945cc3dbe5d8baf47fb077343b90b8d895c90b297aca +b6edcf3a40e7b1c3c0148f47a263cd819e585a51ef31c2e35a29ce6f04c53e413f743034c0d998d9c00a08ba00166f31 +abb87ed86098c0c70a76e557262a494ff51a30fb193f1c1a32f8e35eafa34a43fcc07aa93a3b7a077d9e35afa07b1a3d +a280214cd3bb0fb7ecd2d8bcf518cbd9078417f2b91d2533ec2717563f090fb84f2a5fcfdbbeb2a2a1f8a71cc5aa5941 +a63083ca7238ea2b57d15a475963cf1d4f550d8cd76db290014a0461b90351f1f26a67d674c837b0b773b330c7c3d534 +a8fa39064cb585ece5263e2f42f430206476bf261bd50f18d2b694889bd79d04d56410664cecad62690e5c5a20b3f6ff +85ba52ce9d700a5dcf6c5b00559acbe599d671ce5512467ff4b6179d7fad550567ce2a9c126a50964e3096458ea87920 +b913501e1008f076e5eac6d883105174f88b248e1c9801e568fefaffa1558e4909364fc6d9512aa4d125cbd7cc895f05 +8eb33b5266c8f2ed4725a6ad147a322e44c9264cf261c933cbbe230a43d47fca0f29ec39756b20561dabafadd5796494 +850ebc8b661a04318c9db5a0515066e6454fa73865aa4908767a837857ecd717387f614acb614a88e075d4edc53a2f5a +a08d6b92d866270f29f4ce23a3f5d99b36b1e241a01271ede02817c8ec3f552a5c562db400766c07b104a331835c0c64 +8131804c89bb3e74e9718bfc4afa547c1005ff676bd4db9604335032b203390cfa54478d45c6c78d1fe31a436ed4be9f +9106d94f23cc1eacec8316f16d6f0a1cc160967c886f51981fdb9f3f12ee1182407d2bb24e5b873de58cb1a3ee915a6b +a13806bfc3eae7a7000c9d9f1bd25e10218d4e67f59ae798b145b098bca3edad2b1040e3fc1e6310e612fb8818f459ac +8c69fbca502046cb5f6db99900a47b34117aef3f4b241690cdb3b84ca2a2fc7833e149361995dc41fa78892525bce746 +852c473150c91912d58ecb05769222fa18312800c3f56605ad29eec9e2d8667b0b81c379048d3d29100ed2773bb1f3c5 +b1767f6074426a00e01095dbb1795beb4e4050c6411792cbad6537bc444c3165d1058bafd1487451f9c5ddd209e0ae7e +80c600a5fe99354ce59ff0f84c760923dc8ff66a30bf47dc0a086181785ceb01f9b951c4e66df800ea6d705e8bc47055 +b5cf19002fbc88a0764865b82afcb4d64a50196ea361e5c71dff7de084f4dcbbc34ec94a45cc9e0247bd51da565981aa +93e67a254ea8ce25e112d93cc927fadaa814152a2c4ec7d9a56eaa1ed47aec99b7e9916b02e64452cc724a6641729bbb +ace70b32491bda18eee4a4d041c3bc9effae9340fe7e6c2f5ad975ee0874c17f1a7da7c96bd85fccff9312c518fac6e9 +ab4cfa02065017dd7f1aadc66f2c92f78f0f11b8597c03a5d69d82cb2eaf95a4476a836ac102908f137662472c8d914b +a40b8cd8deb8ae503d20364d64cab7c2801b7728a9646ed19c65edea6a842756a2f636283494299584ad57f4bb12cd0b +8594e11d5fc2396bcd9dbf5509ce4816dbb2b7305168021c426171fb444d111da5a152d6835ad8034542277011c26c0e +8024de98c26b4c994a66628dc304bb737f4b6859c86ded552c5abb81fd4c6c2e19d5a30beed398a694b9b2fdea1dd06a +8843f5872f33f54df8d0e06166c1857d733995f67bc54abb8dfa94ad92407cf0179bc91b0a50bbb56cdc2b350d950329 +b8bab44c7dd53ef9edf497dcb228e2a41282c90f00ba052fc52d57e87b5c8ab132d227af1fcdff9a12713d1f980bcaae +982b4d7b29aff22d527fd82d2a52601d95549bfb000429bb20789ed45e5abf1f4b7416c7b7c4b79431eb3574b29be658 +8eb1f571b6a1878e11e8c1c757e0bc084bab5e82e897ca9be9b7f4b47b91679a8190bf0fc8f799d9b487da5442415857 +a6e74b588e5af935c8b243e888582ef7718f8714569dd4992920740227518305eb35fab674d21a5551cca44b3e511ef2 +a30fc2f3a4cb4f50566e82307de73cd7bd8fe2c1184e9293c136a9b9e926a018d57c6e4f308c95b9eb8299e94d90a2a1 +a50c5869ca5d2b40722c056a32f918d47e0b65ca9d7863ca7d2fb4a7b64fe523fe9365cf0573733ceaadebf20b48fff8 +83bbdd32c04d17581418cf360749c7a169b55d54f2427390defd9f751f100897b2d800ce6636c5bbc046c47508d60c8c +a82904bdf614de5d8deaff688c8a5e7ac5b3431687acbcda8fa53960b7c417a39c8b2e462d7af91ce6d79260f412db8e +a4362e31ff4b05d278b033cf5eebea20de01714ae16d4115d04c1da4754269873afc8171a6f56c5104bfd7b0db93c3e7 +b5b8daa63a3735581e74a021b684a1038cea77168fdb7fdf83c670c2cfabcfc3ab2fc7359069b5f9048188351aef26b5 +b48d723894b7782d96ac8433c48faca1bdfa5238019c451a7f47d958097cce3ae599b876cf274269236b9d6ff8b6d7ca +98ffff6a61a3a6205c7820a91ca2e7176fab5dba02bc194c4d14942ac421cb254183c705506ab279e4f8db066f941c6c +ae7db24731da2eaa6efc4f7fcba2ecc26940ddd68038dce43acf2cee15b72dc4ef42a7bfdd32946d1ed78786dd7696b3 +a656db14f1de9a7eb84f6301b4acb2fbf78bfe867f48a270e416c974ab92821eb4df1cb881b2d600cfed0034ac784641 +aa315f8ecba85a5535e9a49e558b15f39520fce5d4bf43131bfbf2e2c9dfccc829074f9083e8d49f405fb221d0bc4c3c +90bffba5d9ff40a62f6c8e9fc402d5b95f6077ed58d030c93e321b8081b77d6b8dac3f63a92a7ddc01585cf2c127d66c +abdd733a36e0e0f05a570d0504e73801bf9b5a25ff2c78786f8b805704997acb2e6069af342538c581144d53149fa6d3 +b4a723bb19e8c18a01bd449b1bb3440ddb2017f10bb153da27deb7a6a60e9bb37619d6d5435fbb1ba617687838e01dd0 +870016b4678bab3375516db0187a2108b2e840bae4d264b9f4f27dbbc7cc9cac1d7dc582d7a04d6fd1ed588238e5e513 +80d33d2e20e8fc170aa3cb4f69fffb72aeafb3b5bb4ea0bc79ab55da14142ca19b2d8b617a6b24d537366e3b49cb67c3 +a7ee76aec273aaae03b3b87015789289551969fb175c11557da3ab77e39ab49d24634726f92affae9f4d24003050d974 +8415ea4ab69d779ebd42d0fe0c6aef531d6a465a5739e429b1fcf433ec45aa8296c527e965a20f0ec9f340c9273ea3cf +8c7662520794e8b4405d0b33b5cac839784bc86a5868766c06cbc1fa306dbe334978177417b31baf90ce7b0052a29c56 +902b2abecc053a3dbdea9897ee21e74821f3a1b98b2d560a514a35799f4680322550fd3a728d4f6d64e1de98033c32b8 +a05e84ed9ecab8d508d670c39f2db61ad6e08d2795ec32a3c9d0d3737ef3801618f4fc2a95f90ec2f068606131e076c5 +8b9208ff4d5af0c2e3f53c9375da666773ac57197dfabb0d25b1c8d0588ba7f3c15ee9661bb001297f322ea2fbf6928b +a3c827741b34a03254d4451b5ab74a96f2b9f7fb069e2f5adaf54fd97cc7a4d516d378db5ca07da87d8566d6eef13726 +8509d8a3f4a0ed378e0a1e28ea02f6bf1d7f6c819c6c2f5297c7df54c895b848f841653e32ba2a2c22c2ff739571acb8 +a0ce988b7d3c40b4e496aa83a09e4b5472a2d98679622f32bea23e6d607bc7de1a5374fb162bce0549a67dad948519be +aa8a3dd12bd60e3d2e05f9c683cdcb8eab17fc59134815f8d197681b1bcf65108cba63ac5c58ee632b1e5ed6bba5d474 +8b955f1d894b3aefd883fb4b65f14cd37fc2b9db77db79273f1700bef9973bf3fd123897ea2b7989f50003733f8f7f21 +ac79c00ddac47f5daf8d9418d798d8af89fc6f1682e7e451f71ea3a405b0d36af35388dd2a332af790bc83ca7b819328 +a0d44dd2a4438b809522b130d0938c3fe7c5c46379365dbd1810a170a9aa5818e1c783470dd5d0b6d4ac7edbb7330910 +a30b69e39ad43dd540a43c521f05b51b5f1b9c4eed54b8162374ae11eac25da4f5756e7b70ce9f3c92c2eeceee7431ed +ac43220b762c299c7951222ea19761ab938bf38e4972deef58ed84f4f9c68c230647cf7506d7cbfc08562fcca55f0485 +b28233b46a8fb424cfa386a845a3b5399d8489ceb83c8f3e05c22c934798d639c93718b7b68ab3ce24c5358339e41cbb +ac30d50ee8ce59a10d4b37a3a35e62cdb2273e5e52232e202ca7d7b8d09d28958ee667fae41a7bb6cdc6fe8f6e6c9c85 +b199842d9141ad169f35cc7ff782b274cbaa645fdb727761e0a89edbf0d781a15f8218b4bf4eead326f2903dd88a9cc1 +85e018c7ddcad34bb8285a737c578bf741ccd547e68c734bdb3808380e12c5d4ef60fc896b497a87d443ff9abd063b38 +8c856e6ba4a815bdb891e1276f93545b7072f6cb1a9aa6aa5cf240976f29f4dee01878638500a6bf1daf677b96b54343 +b8a47555fa8710534150e1a3f13eab33666017be6b41005397afa647ea49708565f2b86b77ad4964d140d9ced6b4d585 +8cd1f1db1b2f4c85a3f46211599caf512d5439e2d8e184663d7d50166fd3008f0e9253272f898d81007988435f715881 +b1f34b14612c973a3eceb716dc102b82ab18afef9de7630172c2780776679a7706a4874e1df3eaadf541fb009731807f +b25464af9cff883b55be2ff8daf610052c02df9a5e147a2cf4df6ce63edcdee6dc535c533590084cc177da85c5dc0baa +91c3c4b658b42d8d3448ae1415d4541d02379a40dc51e36a59bd6e7b9ba3ea51533f480c7c6e8405250ee9b96a466c29 +86dc027b95deb74c36a58a1333a03e63cb5ae22d3b29d114cfd2271badb05268c9d0c819a977f5e0c6014b00c1512e3a +ae0e6ff58eb5fa35da5107ebeacf222ab8f52a22bb1e13504247c1dfa65320f40d97b0e6b201cb6613476687cb2f0681 +8f13415d960b9d7a1d93ef28afc2223e926639b63bdefce0f85e945dfc81670a55df288893a0d8b3abe13c5708f82f91 +956f67ca49ad27c1e3a68c1faad5e7baf0160c459094bf6b7baf36b112de935fdfd79fa4a9ea87ea8de0ac07272969f4 +835e45e4a67df9fb51b645d37840b3a15c171d571a10b03a406dd69d3c2f22df3aa9c5cbe1e73f8d767ce01c4914ea9a +919b938e56d4b32e2667469d0bdccb95d9dda3341aa907683ee70a14bbbe623035014511c261f4f59b318b610ac90aa3 +96b48182121ccd9d689bf1dfdc228175564cd68dc904a99c808a7f0053a6f636c9d953e12198bdf2ea49ea92772f2e18 +ac5e5a941d567fa38fdbcfa8cf7f85bb304e3401c52d88752bcd516d1fa9bac4572534ea2205e38423c1df065990790f +ac0bd594fb85a8d4fc26d6df0fa81f11919401f1ecf9168b891ec7f061a2d9368af99f7fd8d9b43b2ce361e7b8482159 +83d92c69ca540d298fe80d8162a1c7af3fa9b49dfb69e85c1d136a3ec39fe419c9fa78e0bb6d96878771fbd37fe92e40 +b35443ae8aa66c763c2db9273f908552fe458e96696b90e41dd509c17a5c04ee178e3490d9c6ba2dc0b8f793c433c134 +923b2d25aa45b2e580ffd94cbb37dc8110f340f0f011217ee1bd81afb0714c0b1d5fb4db86006cdd2457563276f59c59 +96c9125d38fca1a61ac21257b696f8ac3dae78def50285e44d90ea293d591d1c58f703540a7e4e99e070afe4646bbe15 +b57946b2332077fbcdcb406b811779aefd54473b5559a163cd65cb8310679b7e2028aa55c12a1401fdcfcac0e6fae29a +845daedc5cf972883835d7e13c937b63753c2200324a3b8082a6c4abb4be06c5f7c629d4abe4bfaf1d80a1f073eb6ce6 +91a55dfd0efefcd03dc6dacc64ec93b8d296cb83c0ee72400a36f27246e7f2a60e73b7b70ba65819e9cfb73edb7bd297 +8874606b93266455fe8fdd25df9f8d2994e927460af06f2e97dd4d2d90db1e6b06d441b72c2e76504d753badca87fb37 +8ee99e6d231274ff9252c0f4e84549da173041299ad1230929c3e3d32399731c4f20a502b4a307642cac9306ccd49d3c +8836497714a525118e20849d6933bb8535fb6f72b96337d49e3133d936999c90a398a740f42e772353b5f1c63581df6d +a6916945e10628f7497a6cdc5e2de113d25f7ade3e41e74d3de48ccd4fce9f2fa9ab69645275002e6f49399b798c40af +9597706983107eb23883e0812e1a2c58af7f3499d50c6e29b455946cb9812fde1aa323d9ed30d1c0ffd455abe32303cd +a24ee89f7f515cc33bdbdb822e7d5c1877d337f3b2162303cfc2dae028011c3a267c5cb4194afa63a4856a6e1c213448 +8cd25315e4318801c2776824ae6e7d543cb85ed3bc2498ba5752df2e8142b37653cf9e60104d674be3aeb0a66912e97a +b5085ecbe793180b40dbeb879f4c976eaaccaca3a5246807dced5890e0ed24d35f3f86955e2460e14fb44ff5081c07ba +960188cc0b4f908633a6840963a6fa2205fc42c511c6c309685234911c5304ef4c304e3ae9c9c69daa2fb6a73560c256 +a32d0a70bf15d569b4cda5aebe3e41e03c28bf99cdd34ffa6c5d58a097f322772acca904b3a47addb6c7492a7126ebac +977f72d06ad72d4aa4765e0f1f9f4a3231d9f030501f320fe7714cc5d329d08112789fa918c60dd7fdb5837d56bb7fc6 +99fa038bb0470d45852bb871620d8d88520adb701712fcb1f278fed2882722b9e729e6cdce44c82caafad95e37d0e6f7 +b855e8f4fc7634ada07e83b6c719a1e37acb06394bc8c7dcab7747a8c54e5df3943915f021364bd019fdea103864e55f +88bc2cd7458532e98c596ef59ea2cf640d7cc31b4c33cef9ed065c078d1d4eb49677a67de8e6229cc17ea48bace8ee5a +aaa78a3feaa836d944d987d813f9b9741afb076e6aca1ffa42682ab06d46d66e0c07b8f40b9dbd63e75e81efa1ef7b08 +b7b080420cc4d808723b98b2a5b7b59c81e624ab568ecdfdeb8bf3aa151a581b6f56e983ef1b6f909661e25db40b0c69 +abee85c462ac9a2c58e54f06c91b3e5cd8c5f9ab5b5deb602b53763c54826ed6deb0d6db315a8d7ad88733407e8d35e2 +994d075c1527407547590df53e9d72dd31f037c763848d1662eebd4cefec93a24328c986802efa80e038cb760a5300f5 +ab8777640116dfb6678e8c7d5b36d01265dfb16321abbfc277da71556a34bb3be04bc4ae90124ed9c55386d2bfb3bda0 +967e3a828bc59409144463bcf883a3a276b5f24bf3cbfdd7a42343348cba91e00b46ac285835a9b91eef171202974204 +875a9f0c4ffe5bb1d8da5e3c8e41d0397aa6248422a628bd60bfae536a651417d4e8a7d2fb98e13f2dad3680f7bd86d3 +acaa330c3e8f95d46b1880126572b238dbb6d04484d2cd4f257ab9642d8c9fc7b212188b9c7ac9e0fd135c520d46b1bf +aceb762edbb0f0c43dfcdb01ea7a1ac5918ca3882b1e7ebc4373521742f1ed5250d8966b498c00b2b0f4d13212e6dd0b +81d072b4ad258b3646f52f399bced97c613b22e7ad76373453d80b1650c0ca87edb291a041f8253b649b6e5429bb4cff +980a47d27416ac39c7c3a0ebe50c492f8c776ea1de44d5159ac7d889b6d554357f0a77f0e5d9d0ff41aae4369eba1fc2 +8b4dfd5ef5573db1476d5e43aacfb5941e45d6297794508f29c454fe50ea622e6f068b28b3debe8635cf6036007de2e3 +a60831559d6305839515b68f8c3bc7abbd8212cc4083502e19dd682d56ca37c9780fc3ce4ec2eae81ab23b221452dc57 +951f6b2c1848ced9e8a2339c65918e00d3d22d3e59a0a660b1eca667d18f8430d737884e9805865ef3ed0fe1638a22d9 +b02e38fe790b492aa5e89257c4986c9033a8b67010fa2add9787de857d53759170fdd67715ca658220b4e14b0ca48124 +a51007e4346060746e6b0e4797fc08ef17f04a34fe24f307f6b6817edbb8ce2b176f40771d4ae8a60d6152cbebe62653 +a510005b05c0b305075b27b243c9d64bcdce85146b6ed0e75a3178b5ff9608213f08c8c9246f2ca6035a0c3e31619860 +aaff4ef27a7a23be3419d22197e13676d6e3810ceb06a9e920d38125745dc68a930f1741c9c2d9d5c875968e30f34ab5 +864522a9af9857de9814e61383bebad1ba9a881696925a0ea6bfc6eff520d42c506bbe5685a9946ed710e889765be4a0 +b63258c080d13f3b7d5b9f3ca9929f8982a6960bdb1b0f8676f4dca823971601672f15e653917bf5d3746bb220504913 +b51ce0cb10869121ae310c7159ee1f3e3a9f8ad498827f72c3d56864808c1f21fa2881788f19ece884d3f705cd7bd0c5 +95d9cecfc018c6ed510e441cf84c712d9909c778c16734706c93222257f64dcd2a9f1bd0b400ca271e22c9c487014274 +8beff4d7d0140b86380ff4842a9bda94c2d2be638e20ac68a4912cb47dbe01a261857536375208040c0554929ced1ddc +891ff49258749e2b57c1e9b8e04b12c77d79c3308b1fb615a081f2aacdfb4b39e32d53e069ed136fdbd43c53b87418fa +9625cad224e163d387738825982d1e40eeff35fe816d10d7541d15fdc4d3eee48009090f3faef4024b249205b0b28f72 +8f3947433d9bd01aa335895484b540a9025a19481a1c40b4f72dd676bfcf332713714fd4010bde936eaf9470fd239ed0 +a00ec2d67789a7054b53f0e858a8a232706ccc29a9f3e389df7455f1a51a2e75801fd78469a13dbc25d28399ae4c6182 +a3f65884506d4a62b8775a0ea0e3d78f5f46bc07910a93cd604022154eabdf1d73591e304d61edc869e91462951975e1 +a14eef4fd5dfac311713f0faa9a60415e3d30b95a4590cbf95f2033dffb4d16c02e7ceff3dcd42148a4e3bc49cce2dd4 +8afa11c0eef3c540e1e3460bc759bb2b6ea90743623f88e62950c94e370fe4fd01c22b6729beba4dcd4d581198d9358f +afb05548a69f0845ffcc5f5dc63e3cdb93cd270f5655173b9a950394b0583663f2b7164ba6df8d60c2e775c1d9f120af +97f179e01a947a906e1cbeafa083960bc9f1bade45742a3afee488dfb6011c1c6e2db09a355d77f5228a42ccaa7bdf8e +8447fca4d35f74b3efcbd96774f41874ca376bf85b79b6e66c92fa3f14bdd6e743a051f12a7fbfd87f319d1c6a5ce217 +a57ca39c23617cd2cf32ff93b02161bd7baf52c4effb4679d9d5166406e103bc8f3c6b5209e17c37dbb02deb8bc72ddd +9667c7300ff80f0140be002b0e36caab07aaee7cce72679197c64d355e20d96196acaf54e06e1382167d081fe6f739c1 +828126bb0559ce748809b622677267ca896fa2ee76360fd2c02990e6477e06a667241379ca7e65d61a5b64b96d7867de +8b8835dea6ba8cf61c91f01a4b3d2f8150b687a4ee09b45f2e5fc8f80f208ae5d142d8e3a18153f0722b90214e60c5a7 +a98e8ff02049b4da386e3ee93db23bbb13dfeb72f1cfde72587c7e6d962780b7671c63e8ac3fbaeb1a6605e8d79e2f29 +87a4892a0026d7e39ef3af632172b88337cb03669dea564bcdb70653b52d744730ebb5d642e20cb627acc9dbb547a26b +877352a22fc8052878a57effc159dac4d75fe08c84d3d5324c0bab6d564cdf868f33ceee515eee747e5856b62cfa0cc7 +8b801ba8e2ff019ee62f64b8cb8a5f601fc35423eb0f9494b401050103e1307dc584e4e4b21249cd2c686e32475e96c3 +a9e7338d6d4d9bfec91b2af28a8ed13b09415f57a3a00e5e777c93d768fdb3f8e4456ae48a2c6626b264226e911a0e28 +99c05fedf40ac4726ed585d7c1544c6e79619a0d3fb6bda75a08c7f3c0008e8d5e19ed4da48de3216135f34a15eba17c +a61cce8a1a8b13a4a650fdbec0eeea8297c352a8238fb7cac95a0df18ed16ee02a3daa2de108fa122aca733bd8ad7855 +b97f37da9005b440b4cb05870dd881bf8491fe735844f2d5c8281818583b38e02286e653d9f2e7fa5e74c3c3eb616540 +a72164a8554da8e103f692ac5ebb4aece55d5194302b9f74b6f2a05335b6e39beede0bf7bf8c5bfd4d324a784c5fb08c +b87e8221c5341cd9cc8bb99c10fe730bc105550f25ed4b96c0d45e6142193a1b2e72f1b3857373a659b8c09be17b3d91 +a41fb1f327ef91dcb7ac0787918376584890dd9a9675c297c45796e32d6e5985b12f9b80be47fc3a8596c245f419d395 +90dafa3592bdbb3465c92e2a54c2531822ba0459d45d3e7a7092fa6b823f55af28357cb51896d4ec2d66029c82f08e26 +a0a9adc872ebc396557f484f1dd21954d4f4a21c4aa5eec543f5fa386fe590839735c01f236574f7ff95407cd12de103 +b8c5c940d58be7538acf8672852b5da3af34f82405ef2ce8e4c923f1362f97fc50921568d0fd2fe846edfb0823e62979 +85aaf06a8b2d0dac89dafd00c28533f35dbd074978c2aaa5bef75db44a7b12aeb222e724f395513b9a535809a275e30b +81f3cbe82fbc7028c26a6c1808c604c63ba023a30c9f78a4c581340008dbda5ec07497ee849a2183fcd9124f7936af32 +a11ac738de75fd60f15a34209d3825d5e23385796a4c7fc5931822f3f380af977dd0f7b59fbd58eed7777a071e21b680 +85a279c493de03db6fa6c3e3c1b1b29adc9a8c4effc12400ae1128da8421954fa8b75ad19e5388fe4543b76fb0812813 +83a217b395d59ab20db6c4adb1e9713fc9267f5f31a6c936042fe051ce8b541f579442f3dcf0fa16b9e6de9fd3518191 +83a0b86e7d4ed8f9ccdc6dfc8ff1484509a6378fa6f09ed908e6ab9d1073f03011dc497e14304e4e3d181b57de06a5ab +a63ad69c9d25704ce1cc8e74f67818e5ed985f8f851afa8412248b2df5f833f83b95b27180e9e7273833ed0d07113d3b +99b1bc2021e63b561fe44ddd0af81fcc8627a91bfeecbbc989b642bc859abc0c8d636399701aad7bbaf6a385d5f27d61 +b53434adb66f4a807a6ad917c6e856321753e559b1add70824e5c1e88191bf6993fccb9b8b911fc0f473fb11743acacd +97ed3b9e6fb99bf5f945d4a41f198161294866aa23f2327818cdd55cb5dc4c1a8eff29dd8b8d04902d6cd43a71835c82 +b1e808260e368a18d9d10bdea5d60223ba1713b948c782285a27a99ae50cc5fc2c53d407de07155ecc16fb8a36d744a0 +a3eb4665f18f71833fec43802730e56b3ee5a357ea30a888ad482725b169d6f1f6ade6e208ee081b2e2633079b82ba7d +ab8beb2c8353fc9f571c18fdd02bdb977fc883313469e1277b0372fbbb33b80dcff354ca41de436d98d2ed710faa467e +aa9071cfa971e4a335a91ad634c98f2be51544cb21f040f2471d01bb97e1df2277ae1646e1ea8f55b7ba9f5c8c599b39 +80b7dbfdcaf40f0678012acc634eba44ea51181475180d9deb2050dc4f2de395289edd0223018c81057ec79b04b04c49 +89623d7f6cb17aa877af14de842c2d4ab7fd576d61ddd7518b5878620a01ded40b6010de0da3cdf31d837eecf30e9847 +a773bb024ae74dd24761f266d4fb27d6fd366a8634febe8235376b1ae9065c2fe12c769f1d0407867dfbe9f5272c352f +8455a561c3aaa6ba64c881a5e13921c592b3a02e968f4fb24a2243c36202795d0366d9cc1a24e916f84d6e158b7aeac7 +81d8bfc4b283cf702a40b87a2b96b275bdbf0def17e67d04842598610b67ea08c804d400c3e69fa09ea001eaf345b276 +b8f8f82cb11fea1c99467013d7e167ff03deb0c65a677fab76ded58826d1ba29aa7cf9fcd7763615735ea3ad38e28719 +89a6a04baf9cccc1db55179e1650b1a195dd91fb0aebc197a25143f0f393524d2589975e3fbfc2547126f0bced7fd6f2 +b81b2162df045390f04df07cbd0962e6b6ca94275a63edded58001a2f28b2ae2af2c7a6cba4ecd753869684e77e7e799 +a3757f722776e50de45c62d9c4a2ee0f5655a512344c4cbec542d8045332806568dd626a719ef21a4eb06792ca70f204 +8c5590df96ec22179a4e8786de41beb44f987a1dcc508eb341eecbc0b39236fdfad47f108f852e87179ccf4e10091e59 +87502f026ed4e10167419130b88c3737635c5b9074c364e1dd247cef5ef0fc064b4ae99b187e33301e438bbd2fe7d032 +af925a2165e980ced620ff12289129fe17670a90ae0f4db9d4b39bd887ccb1f5d2514ac9ecf910f6390a8fc66bd5be17 +857fca899828cf5c65d26e3e8a6e658542782fc72762b3b9c73514919f83259e0f849a9d4838b40dc905fe43024d0d23 +87ffebdbfb69a9e1007ebac4ffcb4090ff13705967b73937063719aa97908986effcb7262fdadc1ae0f95c3690e3245d +a9ff6c347ac6f4c6ab993b748802e96982eaf489dc69032269568412fc9a79e7c2850dfc991b28211b3522ee4454344b +a65b3159df4ec48bebb67cb3663cd744027ad98d970d620e05bf6c48f230fa45bf17527fe726fdf705419bb7a1bb913e +84b97b1e6408b6791831997b03cd91f027e7660fd492a93d95daafe61f02427371c0e237c75706412f442991dfdff989 +ab761c26527439b209af0ae6afccd9340bbed5fbe098734c3145b76c5d2cd7115d9227b2eb523882b7317fbb09180498 +a0479a8da06d7a69c0b0fee60df4e691c19c551f5e7da286dab430bfbcabf31726508e20d26ea48c53365a7f00a3ad34 +a732dfc9baa0f4f40b5756d2e8d8937742999623477458e0bc81431a7b633eefc6f53b3b7939fe0a020018549c954054 +901502436a1169ba51dc479a5abe7c8d84e0943b16bc3c6a627b49b92cd46263c0005bc324c67509edd693f28e612af1 +b627aee83474e7f84d1bab9b7f6b605e33b26297ac6bbf52d110d38ba10749032bd551641e73a383a303882367af429b +95108866745760baef4a46ef56f82da6de7e81c58b10126ebd2ba2cd13d339f91303bf2fb4dd104a6956aa3b13739503 +899ed2ade37236cec90056f3569bc50f984f2247792defafcceb49ad0ca5f6f8a2f06573705300e07f0de0c759289ff5 +a9f5eee196d608efe4bcef9bf71c646d27feb615e21252cf839a44a49fd89da8d26a758419e0085a05b1d59600e2dc42 +b36c6f68fed6e6c85f1f4a162485f24817f2843ec5cbee45a1ebfa367d44892e464949c6669f7972dc7167af08d55d25 +aaaede243a9a1b6162afbc8f571a52671a5a4519b4062e3f26777664e245ba873ed13b0492c5dbf0258c788c397a0e9e +972b4fb39c31cbe127bf9a32a5cc10d621ebdd9411df5e5da3d457f03b2ab2cd1f6372d8284a4a9400f0b06ecdbfd38e +8f6ca1e110e959a4b1d9a5ce5f212893cec21db40d64d5ac4d524f352d72198f923416a850bf845bc5a22a79c0ea2619 +a0f3c93b22134f66f04b2553a53b738644d1665ceb196b8494b315a4c28236fb492017e4a0de4224827c78e42f9908b7 +807fb5ee74f6c8735b0b5ca07e28506214fe4047dbeb00045d7c24f7849e98706aea79771241224939cb749cf1366c7d +915eb1ff034224c0b645442cdb7d669303fdc00ca464f91aaf0b6fde0b220a3a74ff0cb043c26c9f3a5667b3fdaa9420 +8fda6cef56ed33fefffa9e6ac8e6f76b1af379f89761945c63dd448801f7bb8ca970504a7105fac2f74f652ccff32327 +87380cffdcffb1d0820fa36b63cc081e72187f86d487315177d4d04da4533eb19a0e2ff6115ceab528887819c44a5164 +8cd89e03411a18e7f16f968b89fb500c36d47d229f6487b99e62403a980058db5925ce249206743333538adfad168330 +974451b1df33522ce7056de9f03e10c70bf302c44b0741a59df3d6877d53d61a7394dcee1dd46e013d7cb9d73419c092 +98c35ddf645940260c490f384a49496a7352bb8e3f686feed815b1d38f59ded17b1ad6e84a209e773ed08f7b8ff1e4c2 +963f386cf944bb9b2ddebb97171b64253ea0a2894ac40049bdd86cda392292315f3a3d490ca5d9628c890cfb669f0acb +8d507712152babd6d142ee682638da8495a6f3838136088df9424ef50d5ec28d815a198c9a4963610b22e49b4cdf95e9 +83d4bc6b0be87c8a4f1e9c53f257719de0c73d85b490a41f7420e777311640937320557ff2f1d9bafd1daaa54f932356 +82f5381c965b7a0718441131c4d13999f4cdce637698989a17ed97c8ea2e5bdb5d07719c5f7be8688edb081b23ede0f4 +a6ebecab0b72a49dfd01d69fa37a7f74d34fb1d4fef0aa10e3d6fceb9eccd671225c230af89f6eb514250e41a5f91f52 +846d185bdad6e11e604df7f753b7a08a28b643674221f0e750ebdb6b86ec584a29c869e131bca868972a507e61403f6a +85a98332292acb744bd1c0fd6fdcf1f889a78a2c9624d79413ffa194cc8dfa7821a4b60cde8081d4b5f71f51168dd67f +8f7d97c3b4597880d73200d074eb813d95432306e82dafc70b580b8e08cb8098b70f2d07b4b3ac6a4d77e92d57035031 +8185439c8751e595825d7053518cbe121f191846a38d4dbcb558c3f9d7a3104f3153401adaaaf27843bbe2edb504bfe3 +b3c00d8ece1518fca6b1215a139b0a0e26d9cba1b3a424f7ee59f30ce800a5db967279ed60958dd1f3ee69cf4dd1b204 +a2e6cb6978e883f9719c3c0d44cfe8de0cc6f644b98f98858433bea8bbe7b612c8aca5952fccce4f195f9d54f9722dc2 +99663087e3d5000abbec0fbda4e7342ec38846cc6a1505191fb3f1a337cb369455b7f8531a6eb8b0f7b2c4baf83cbe2b +ab0836c6377a4dbc7ca6a4d6cf021d4cd60013877314dd05f351706b128d4af6337711ed3443cb6ca976f40d74070a9a +87abfd5126152fd3bac3c56230579b489436755ea89e0566aa349490b36a5d7b85028e9fb0710907042bcde6a6f5d7e3 +974ba1033f75f60e0cf7c718a57ae1da3721cf9d0fb925714c46f027632bdd84cd9e6de4cf4d00bc55465b1c5ebb7384 +a607b49d73689ac64f25cec71221d30d53e781e1100d19a2114a21da6507a60166166369d860bd314acb226596525670 +a7c2b0b915d7beba94954f2aa7dd08ec075813661e2a3ecca5d28a0733e59583247fed9528eb28aba55b972cdbaf06eb +b8b3123e44128cc8efbe3270f2f94e50ca214a4294c71c3b851f8cbb70cb67fe9536cf07d04bf7fe380e5e3a29dd3c15 +a59a07e343b62ad6445a0859a32b58c21a593f9ddbfe52049650f59628c93715aa1f4e1f45b109321756d0eeec8a5429 +94f51f8a4ed18a6030d0aaa8899056744bd0e9dc9ac68f62b00355cddab11da5da16798db75f0bfbce0e5bdfe750c0b6 +97460a97ca1e1fa5ce243b81425edc0ec19b7448e93f0b55bc9785eedeeafe194a3c8b33a61a5c72990edf375f122777 +8fa859a089bc17d698a7ee381f37ce9beadf4e5b44fce5f6f29762bc04f96faff5d58c48c73631290325f05e9a1ecf49 +abdf38f3b20fc95eff31de5aa9ef1031abfa48f1305ee57e4d507594570401503476d3bcc493838fc24d6967a3082c7f +b8914bfb82815abb86da35c64d39ab838581bc0bf08967192697d9663877825f2b9d6fbdcf9b410463482b3731361aef +a8187f9d22b193a5f578999954d6ec9aa9b32338ccadb8a3e1ce5bad5ea361d69016e1cdfac44e9d6c54e49dd88561b9 +aac262cb7cba7fd62c14daa7b39677cabc1ef0947dd06dd89cac8570006a200f90d5f0353e84f5ff03179e3bebe14231 +a630ef5ece9733b8c46c0a2df14a0f37647a85e69c63148e79ffdcc145707053f9f9d305c3f1cf3c7915cb46d33abd07 +b102c237cb2e254588b6d53350dfda6901bd99493a3fbddb4121d45e0b475cf2663a40d7b9a75325eda83e4ba1e68cb3 +86a930dd1ddcc16d1dfa00aa292cb6c2607d42c367e470aa920964b7c17ab6232a7108d1c2c11fc40fb7496547d0bbf8 +a832fdc4500683e72a96cce61e62ac9ee812c37fe03527ad4cf893915ca1962cee80e72d4f82b20c8fc0b764376635a1 +88ad985f448dabb04f8808efd90f273f11f5e6d0468b5489a1a6a3d77de342992a73eb842d419034968d733f101ff683 +98a8538145f0d86f7fbf9a81c9140f6095c5bdd8960b1c6f3a1716428cd9cca1bf8322e6d0af24e6169abcf7df2b0ff6 +9048c6eba5e062519011e177e955a200b2c00b3a0b8615bdecdebc217559d41058d3315f6d05617be531ef0f6aef0e51 +833bf225ab6fc68cdcacf1ec1b50f9d05f5410e6cdcd8d56a3081dc2be8a8d07b81534d1ec93a25c2e270313dfb99e3b +a84bcd24c3da5e537e64a811b93c91bfc84d7729b9ead7f79078989a6eb76717d620c1fad17466a0519208651e92f5ff +b7cdd0a3fbd79aed93e1b5a44ca44a94e7af5ed911e4492f332e3a5ed146c7286bde01b52276a2fcc02780d2109874dd +8a19a09854e627cb95750d83c20c67442b66b35896a476358f993ba9ac114d32c59c1b3d0b8787ee3224cf3888b56c64 +a9abd5afb8659ee52ada8fa5d57e7dd355f0a7350276f6160bec5fbf70d5f99234dd179eb221c913e22a49ec6d267846 +8c13c4274c0d30d184e73eaf812200094bbbd57293780bdadbceb262e34dee5b453991e7f37c7333a654fc71c69d6445 +a4320d73296ff8176ce0127ca1921c450e2a9c06eff936681ebaffb5a0b05b17fded24e548454de89aca2dcf6d7a9de4 +b2b8b3e15c1f645f07783e5628aba614e60157889db41d8161d977606788842b67f83f361eae91815dc0abd84e09abd5 +ad26c3aa35ddfddc15719b8bb6c264aaec7065e88ac29ba820eb61f220fef451609a7bb037f3722d022e6c86e4f1dc88 +b8615bf43e13ae5d7b8dd903ce37190800cd490f441c09b22aa29d7a29ed2c0417b7a08ead417868f1de2589deaadd80 +8d3425e1482cd1e76750a76239d33c06b3554c3c3c87c15cb7ab58b1cee86a4c5c4178b44e23f36928365a1b484bde02 +806893a62e38c941a7dd6f249c83af16596f69877cc737d8f73f6b8cd93cbc01177a7a276b2b8c6b0e5f2ad864db5994 +86618f17fa4b0d65496b661bbb5ba3bc3a87129d30a4b7d4f515b904f4206ca5253a41f49fd52095861e5e065ec54f21 +9551915da1304051e55717f4c31db761dcdcf3a1366c89a4af800a9e99aca93a357bf928307f098e62b44a02cb689a46 +8f79c4ec0ec1146cb2a523b52fe33def90d7b5652a0cb9c2d1c8808a32293e00aec6969f5b1538e3a94cd1efa3937f86 +a0c03e329a707300081780f1e310671315b4c6a4cedcb29697aedfabb07a9d5df83f27b20e9c44cf6b16e39d9ded5b98 +86a7cfa7c8e7ce2c01dd0baec2139e97e8e090ad4e7b5f51518f83d564765003c65968f85481bbb97cb18f005ccc7d9f +a33811770c6dfda3f7f74e6ad0107a187fe622d61b444bbd84fd7ef6e03302e693b093df76f6ab39bb4e02afd84a575a +85480f5c10d4162a8e6702b5e04f801874d572a62a130be94b0c02b58c3c59bdcd48cd05f0a1c2839f88f06b6e3cd337 +8e181011564b17f7d787fe0e7f3c87f6b62da9083c54c74fd6c357a1f464c123c1d3d8ade3cf72475000b464b14e2be3 +8ee178937294b8c991337e0621ab37e9ffa4ca2bdb3284065c5e9c08aad6785d50cf156270ff9daf9a9127289710f55b +8bd1e8e2d37379d4b172f1aec96f2e41a6e1393158d7a3dbd9a95c8dd4f8e0b05336a42efc11a732e5f22b47fc5c271d +8f3da353cd487c13136a85677de8cedf306faae0edec733cf4f0046f82fa4639db4745b0095ff33a9766aba50de0cbcf +8d187c1e97638df0e4792b78e8c23967dac43d98ea268ca4aabea4e0fa06cb93183fd92d4c9df74118d7cc27bf54415e +a4c992f08c2f8bac0b74b3702fb0c75c9838d2ce90b28812019553d47613c14d8ce514d15443159d700b218c5a312c49 +a6fd1874034a34c3ea962a316c018d9493d2b3719bb0ec4edbc7c56b240802b2228ab49bee6f04c8a3e9f6f24a48c1c2 +b2efed8e799f8a15999020900dc2c58ece5a3641c90811b86a5198e593d7318b9d53b167818ccdfbe7df2414c9c34011 +995ff7de6181ddf95e3ead746089c6148da3508e4e7a2323c81785718b754d356789b902e7e78e2edc6b0cbd4ff22c78 +944073d24750a9068cbd020b834afc72d2dde87efac04482b3287b40678ad07588519a4176b10f2172a2c463d063a5cd +99db4b1bb76475a6fd75289986ef40367960279524378cc917525fb6ba02a145a218c1e9caeb99332332ab486a125ac0 +89fce4ecd420f8e477af4353b16faabb39e063f3f3c98fde2858b1f2d1ef6eed46f0975a7c08f233b97899bf60ccd60a +8c09a4f07a02b80654798bc63aada39fd638d3e3c4236ccd8a5ca280350c31e4a89e5f4c9aafb34116e71da18c1226b8 +85325cfa7ded346cc51a2894257eab56e7488dbff504f10f99f4cd2b630d913003761a50f175ed167e8073f1b6b63fb0 +b678b4fbec09a8cc794dcbca185f133578f29e354e99c05f6d07ac323be20aecb11f781d12898168e86f2e0f09aca15e +a249cfcbca4d9ba0a13b5f6aac72bf9b899adf582f9746bb2ad043742b28915607467eb794fca3704278f9136f7642be +9438e036c836a990c5e17af3d78367a75b23c37f807228362b4d13e3ddcb9e431348a7b552d09d11a2e9680704a4514f +925ab70450af28c21a488bfb5d38ac994f784cf249d7fd9ad251bb7fd897a23e23d2528308c03415074d43330dc37ef4 +a290563904d5a8c0058fc8330120365bdd2ba1fdbaef7a14bc65d4961bb4217acfaed11ab82669e359531f8bf589b8db +a7e07a7801b871fc9b981a71e195a3b4ba6b6313bc132b04796a125157e78fe5c11a3a46cf731a255ac2d78a4ae78cd0 +b26cd2501ee72718b0eebab6fb24d955a71f363f36e0f6dff0ab1d2d7836dab88474c0cef43a2cc32701fca7e82f7df3 +a1dc3b6c968f3de00f11275092290afab65b2200afbcfa8ddc70e751fa19dbbc300445d6d479a81bda3880729007e496 +a9bc213e28b630889476a095947d323b9ac6461dea726f2dc9084473ae8e196d66fb792a21905ad4ec52a6d757863e7d +b25d178df8c2df8051e7c888e9fa677fde5922e602a95e966db9e4a3d6b23ce043d7dc48a5b375c6b7c78e966893e8c3 +a1c8d88d72303692eaa7adf68ea41de4febec40cc14ae551bb4012afd786d7b6444a3196b5d9d5040655a3366d96b7cd +b22bd44f9235a47118a9bbe2ba5a2ba9ec62476061be2e8e57806c1a17a02f9a51403e849e2e589520b759abd0117683 +b8add766050c0d69fe81d8d9ea73e1ed05f0135d093ff01debd7247e42dbb86ad950aceb3b50b9af6cdc14ab443b238f +af2cf95f30ef478f018cf81d70d47d742120b09193d8bb77f0d41a5d2e1a80bfb467793d9e2471b4e0ad0cb2c3b42271 +8af5ef2107ad284e246bb56e20fef2a255954f72de791cbdfd3be09f825298d8466064f3c98a50496c7277af32b5c0bc +85dc19558572844c2849e729395a0c125096476388bd1b14fa7f54a7c38008fc93e578da3aac6a52ff1504d6ca82db05 +ae8c9b43c49572e2e166d704caf5b4b621a3b47827bb2a3bcd71cdc599bba90396fd9a405261b13e831bb5d44c0827d7 +a7ba7efede25f02e88f6f4cbf70643e76784a03d97e0fbd5d9437c2485283ad7ca3abb638a5f826cd9f6193e5dec0b6c +94a9d122f2f06ef709fd8016fd4b712d88052245a65a301f5f177ce22992f74ad05552b1f1af4e70d1eac62cef309752 +82d999b3e7cf563833b8bc028ff63a6b26eb357dfdb3fd5f10e33a1f80a9b2cfa7814d871b32a7ebfbaa09e753e37c02 +aec6edcde234df502a3268dd2c26f4a36a2e0db730afa83173f9c78fcb2b2f75510a02b80194327b792811caefda2725 +94c0bfa66c9f91d462e9194144fdd12d96f9bbe745737e73bab8130607ee6ea9d740e2cfcbbd00a195746edb6369ee61 +ab7573dab8c9d46d339e3f491cb2826cabe8b49f85f1ede78d845fc3995537d1b4ab85140b7d0238d9c24daf0e5e2a7e +87e8b16832843251fe952dadfd01d41890ed4bb4b8fa0254550d92c8cced44368225eca83a6c3ad47a7f81ff8a80c984 +9189d2d9a7c64791b19c0773ad4f0564ce6bea94aa275a917f78ad987f150fdb3e5e26e7fef9982ac184897ecc04683f +b3661bf19e2da41415396ae4dd051a9272e8a2580b06f1a1118f57b901fa237616a9f8075af1129af4eabfefedbe2f1c +af43c86661fb15daf5d910a4e06837225e100fb5680bd3e4b10f79a2144c6ec48b1f8d6e6b98e067d36609a5d038889a +82ac0c7acaa83ddc86c5b4249aae12f28155989c7c6b91e5137a4ce05113c6cbc16f6c44948b0efd8665362d3162f16a +8f268d1195ab465beeeb112cd7ffd5d5548559a8bc01261106d3555533fc1971081b25558d884d552df0db1cddda89d8 +8ef7caa5521f3e037586ce8ac872a4182ee20c7921c0065ed9986c047e3dda08294da1165f385d008b40d500f07d895f +8c2f98f6880550573fad46075d3eba26634b5b025ce25a0b4d6e0193352c8a1f0661064027a70fe8190b522405f9f4e3 +b7653f353564feb164f0f89ec7949da475b8dad4a4d396d252fc2a884f6932d027b7eb2dc4d280702c74569319ed701a +a026904f4066333befd9b87a8fad791d014096af60cdd668ef919c24dbe295ff31f7a790e1e721ba40cf5105abca67f4 +988f982004ada07a22dd345f2412a228d7a96b9cae2c487de42e392afe1e35c2655f829ce07a14629148ce7079a1f142 +9616add009067ed135295fb74d5b223b006b312bf14663e547a0d306694ff3a8a7bb9cfc466986707192a26c0bce599f +ad4c425de9855f6968a17ee9ae5b15e0a5b596411388cf976df62ecc6c847a6e2ddb2cea792a5f6e9113c2445dba3e5c +b698ac9d86afa3dc69ff8375061f88e3b0cff92ff6dfe747cebaf142e813c011851e7a2830c10993b715e7fd594604a9 +a386fa189847bb3b798efca917461e38ead61a08b101948def0f82cd258b945ed4d45b53774b400af500670149e601b7 +905c95abda2c68a6559d8a39b6db081c68cef1e1b4be63498004e1b2f408409be9350b5b5d86a30fd443e2b3e445640a +9116dade969e7ce8954afcdd43e5cab64dc15f6c1b8da9d2d69de3f02ba79e6c4f6c7f54d6bf586d30256ae405cd1e41 +a3084d173eacd08c9b5084a196719b57e47a0179826fda73466758235d7ecdb87cbcf097bd6b510517d163a85a7c7edd +85bb00415ad3c9be99ff9ba83672cc59fdd24356b661ab93713a3c8eab34e125d8867f628a3c3891b8dc056e69cd0e83 +8d58541f9f39ed2ee4478acce5d58d124031338ec11b0d55551f00a5a9a6351faa903a5d7c132dc5e4bb026e9cbd18e4 +a622adf72dc250e54f672e14e128c700166168dbe0474cecb340da175346e89917c400677b1bc1c11fcc4cc26591d9db +b3f865014754b688ca8372e8448114fff87bf3ca99856ab9168894d0c4679782c1ced703f5b74e851b370630f5e6ee86 +a7e490b2c40c2446fcd91861c020da9742c326a81180e38110558bb5d9f2341f1c1885e79b364e6419023d1cbdc47380 +b3748d472b1062e54572badbb8e87ac36534407f74932e7fc5b8392d008e8e89758f1671d1e4d30ab0fa40551b13bb5e +89898a5c5ec4313aabc607b0049fd1ebad0e0c074920cf503c9275b564d91916c2c446d3096491c950b7af3ac5e4b0ed +8eb8c83fef2c9dd30ea44e286e9599ec5c20aba983f702e5438afe2e5b921884327ad8d1566c72395587efac79ca7d56 +b92479599e806516ce21fb0bd422a1d1d925335ebe2b4a0a7e044dd275f30985a72b97292477053ac5f00e081430da80 +a34ae450a324fe8a3c25a4d653a654f9580ed56bbea213b8096987bbad0f5701d809a17076435e18017fea4d69f414bc +81381afe6433d62faf62ea488f39675e0091835892ecc238e02acf1662669c6d3962a71a3db652f6fe3bc5f42a0e5dc5 +a430d475bf8580c59111103316fe1aa79c523ea12f1d47a976bbfae76894717c20220e31cf259f08e84a693da6688d70 +b842814c359754ece614deb7d184d679d05d16f18a14b288a401cef5dad2cf0d5ee90bad487b80923fc5573779d4e4e8 +971d9a2627ff2a6d0dcf2af3d895dfbafca28b1c09610c466e4e2bff2746f8369de7f40d65b70aed135fe1d72564aa88 +8f4ce1c59e22b1ce7a0664caaa7e53735b154cfba8d2c5cc4159f2385843de82ab58ed901be876c6f7fce69cb4130950 +86cc9dc321b6264297987000d344fa297ef45bcc2a4df04e458fe2d907ad304c0ea2318e32c3179af639a9a56f3263cf +8229e0876dfe8f665c3fb19b250bd89d40f039bbf1b331468b403655be7be2e104c2fd07b9983580c742d5462ca39a43 +99299d73066e8eb128f698e56a9f8506dfe4bd014931e86b6b487d6195d2198c6c5bf15cccb40ccf1f8ddb57e9da44a2 +a3a3be37ac554c574b393b2f33d0a32a116c1a7cfeaf88c54299a4da2267149a5ecca71f94e6c0ef6e2f472b802f5189 +a91700d1a00387502cdba98c90f75fbc4066fefe7cc221c8f0e660994c936badd7d2695893fde2260c8c11d5bdcdd951 +8e03cae725b7f9562c5c5ab6361644b976a68bada3d7ca508abca8dfc80a469975689af1fba1abcf21bc2a190dab397d +b01461ad23b2a8fa8a6d241e1675855d23bc977dbf4714add8c4b4b7469ccf2375cec20e80cedfe49361d1a30414ac5b +a2673bf9bc621e3892c3d7dd4f1a9497f369add8cbaa3472409f4f86bd21ac67cfac357604828adfee6ada1835365029 +a042dff4bf0dfc33c178ba1b335e798e6308915128de91b12e5dbbab7c4ac8d60a01f6aea028c3a6d87b9b01e4e74c01 +86339e8a75293e4b3ae66b5630d375736b6e6b6b05c5cda5e73fbf7b2f2bd34c18a1d6cefede08625ce3046e77905cb8 +af2ebe1b7d073d03e3d98bc61af83bf26f7a8c130fd607aa92b75db22d14d016481b8aa231e2c9757695f55b7224a27f +a00ee882c9685e978041fd74a2c465f06e2a42ffd3db659053519925be5b454d6f401e3c12c746e49d910e4c5c9c5e8c +978a781c0e4e264e0dad57e438f1097d447d891a1e2aa0d5928f79a9d5c3faae6f258bc94fdc530b7b2fa6a9932bb193 +aa4b7ce2e0c2c9e9655bf21e3e5651c8503bce27483017b0bf476be743ba06db10228b3a4c721219c0779747f11ca282 +b003d1c459dacbcf1a715551311e45d7dbca83a185a65748ac74d1800bbeaba37765d9f5a1a221805c571910b34ebca8 +95b6e531b38648049f0d19de09b881baa1f7ea3b2130816b006ad5703901a05da57467d1a3d9d2e7c73fb3f2e409363c +a6cf9c06593432d8eba23a4f131bb7f72b9bd51ab6b4b772a749fe03ed72b5ced835a349c6d9920dba2a39669cb7c684 +aa3d59f6e2e96fbb66195bc58c8704e139fa76cd15e4d61035470bd6e305db9f98bcbf61ac1b95e95b69ba330454c1b3 +b57f97959c208361de6d7e86dff2b873068adb0f158066e646f42ae90e650079798f165b5cd713141cd3a2a90a961d9a +a76ee8ed9052f6a7a8c69774bb2597be182942f08115baba03bf8faaeaee526feba86120039fe8ca7b9354c3b6e0a8e6 +95689d78c867724823f564627d22d25010f278674c6d2d0cdb10329169a47580818995d1d727ce46c38a1e47943ebb89 +ab676d2256c6288a88e044b3d9ffd43eb9d5aaee00e8fc60ac921395fb835044c71a26ca948e557fed770f52d711e057 +96351c72785c32e5d004b6f4a1259fb8153d631f0c93fed172f18e8ba438fbc5585c1618deeabd0d6d0b82173c2e6170 +93dd8d3db576418e22536eba45ab7f56967c6c97c64260d6cddf38fb19c88f2ec5cd0e0156f50e70855eee8a2b879ffd +ad6ff16f40f6de3d7a737f8e6cebd8416920c4ff89dbdcd75eabab414af9a6087f83ceb9aff7680aa86bff98bd09c8cc +84de53b11671abc9c38710e19540c5c403817562aeb22a88404cdaff792c1180f717dbdfe8f54940c062c4d032897429 +872231b9efa1cdd447b312099a5c164c560440a9441d904e70f5abfc3b2a0d16be9a01aca5e0a2599a61e19407587e3d +88f44ac27094a2aa14e9dc40b099ee6d68f97385950f303969d889ee93d4635e34dff9239103bdf66a4b7cbba3e7eb7a +a59afebadf0260e832f6f44468443562f53fbaf7bcb5e46e1462d3f328ac437ce56edbca617659ac9883f9e13261fad7 +b1990e42743a88de4deeacfd55fafeab3bc380cb95de43ed623d021a4f2353530bcab9594389c1844b1c5ea6634c4555 +85051e841149a10e83f56764e042182208591396d0ce78c762c4a413e6836906df67f38c69793e158d64fef111407ba3 +9778172bbd9b1f2ec6bbdd61829d7b39a7df494a818e31c654bf7f6a30139899c4822c1bf418dd4f923243067759ce63 +9355005b4878c87804fc966e7d24f3e4b02bed35b4a77369d01f25a3dcbff7621b08306b1ac85b76fe7b4a3eb5f839b1 +8f9dc6a54fac052e236f8f0e1f571ac4b5308a43acbe4cc8183bce26262ddaf7994e41cf3034a4cbeca2c505a151e3b1 +8cc59c17307111723fe313046a09e0e32ea0cce62c13814ab7c6408c142d6a0311d801be4af53fc9240523f12045f9ef +8e6057975ed40a1932e47dd3ac778f72ee2a868d8540271301b1aa6858de1a5450f596466494a3e0488be4fbeb41c840 +812145efbd6559ae13325d56a15940ca4253b17e72a9728986b563bb5acc13ec86453796506ac1a8f12bd6f9e4a288c3 +911da0a6d6489eb3dab2ec4a16e36127e8a291ae68a6c2c9de33e97f3a9b1f00da57a94e270a0de79ecc5ecb45d19e83 +b72ea85973f4b2a7e6e71962b0502024e979a73c18a9111130e158541fa47bbaaf53940c8f846913a517dc69982ba9e1 +a7a56ad1dbdc55f177a7ad1d0af78447dc2673291e34e8ab74b26e2e2e7d8c5fe5dc89e7ef60f04a9508847b5b3a8188 +b52503f6e5411db5d1e70f5fb72ccd6463fa0f197b3e51ca79c7b5a8ab2e894f0030476ada72534fa4eb4e06c3880f90 +b51c7957a3d18c4e38f6358f2237b3904618d58b1de5dec53387d25a63772e675a5b714ad35a38185409931157d4b529 +b86b4266e719d29c043d7ec091547aa6f65bbf2d8d831d1515957c5c06513b72aa82113e9645ad38a7bc3f5383504fa6 +b95b547357e6601667b0f5f61f261800a44c2879cf94e879def6a105b1ad2bbf1795c3b98a90d588388e81789bd02681 +a58fd4c5ae4673fa350da6777e13313d5d37ed1dafeeb8f4f171549765b84c895875d9d3ae6a9741f3d51006ef81d962 +9398dc348d078a604aadc154e6eef2c0be1a93bb93ba7fe8976edc2840a3a318941338cc4d5f743310e539d9b46613d2 +902c9f0095014c4a2f0dccaaab543debba6f4cc82c345a10aaf4e72511725dbed7a34cd393a5f4e48a3e5142b7be84ed +a7c0447849bb44d04a0393a680f6cd390093484a79a147dd238f5d878030d1c26646d88211108e59fe08b58ad20c6fbd +80db045535d6e67a422519f5c89699e37098449d249698a7cc173a26ccd06f60238ae6cc7242eb780a340705c906790c +8e52b451a299f30124505de2e74d5341e1b5597bdd13301cc39b05536c96e4380e7f1b5c7ef076f5b3005a868657f17c +824499e89701036037571761e977654d2760b8ce21f184f2879fda55d3cda1e7a95306b8abacf1caa79d3cc075b9d27f +9049b956b77f8453d2070607610b79db795588c0cec12943a0f5fe76f358dea81e4f57a4692112afda0e2c05c142b26f +81911647d818a4b5f4990bfd4bc13bf7be7b0059afcf1b6839333e8569cdb0172fd2945410d88879349f677abaed5eb3 +ad4048f19b8194ed45b6317d9492b71a89a66928353072659f5ce6c816d8f21e69b9d1817d793effe49ca1874daa1096 +8d22f7b2ddb31458661abd34b65819a374a1f68c01fc6c9887edeba8b80c65bceadb8f57a3eb686374004b836261ef67 +92637280c259bc6842884db3d6e32602a62252811ae9b019b3c1df664e8809ffe86db88cfdeb8af9f46435c9ee790267 +a2f416379e52e3f5edc21641ea73dc76c99f7e29ea75b487e18bd233856f4c0183429f378d2bfc6cd736d29d6cadfa49 +882cb6b76dbdc188615dcf1a8439eba05ffca637dd25197508156e03c930b17b9fed2938506fdd7b77567cb488f96222 +b68b621bb198a763fb0634eddb93ed4b5156e59b96c88ca2246fd1aea3e6b77ed651e112ac41b30cd361fadc011d385e +a3cb22f6b675a29b2d1f827cacd30df14d463c93c3502ef965166f20d046af7f9ab7b2586a9c64f4eae4fad2d808a164 +8302d9ce4403f48ca217079762ce42cee8bc30168686bb8d3a945fbd5acd53b39f028dce757b825eb63af2d5ae41169d +b2eef1fbd1a176f1f4cd10f2988c7329abe4eb16c7405099fb92baa724ab397bc98734ef7d4b24c0f53dd90f57520d04 +a1bbef0bd684a3f0364a66bde9b29326bac7aa3dde4caed67f14fb84fed3de45c55e406702f1495a3e2864d4ee975030 +976acdb0efb73e3a3b65633197692dedc2adaed674291ae3df76b827fc866d214e9cac9ca46baefc4405ff13f953d936 +b9fbf71cc7b6690f601f0b1c74a19b7d14254183a2daaafec7dc3830cba5ae173d854bbfebeca985d1d908abe5ef0cda +90591d7b483598c94e38969c4dbb92710a1a894bcf147807f1bcbd8aa3ac210b9f2be65519aa829f8e1ccdc83ad9b8cf +a30568577c91866b9c40f0719d46b7b3b2e0b4a95e56196ac80898a2d89cc67880e1229933f2cd28ee3286f8d03414d7 +97589a88c3850556b359ec5e891f0937f922a751ac7c95949d3bbc7058c172c387611c0f4cb06351ef02e5178b3dd9e4 +98e7bbe27a1711f4545df742f17e3233fbcc63659d7419e1ca633f104cb02a32c84f2fac23ca2b84145c2672f68077ab +a7ddb91636e4506d8b7e92aa9f4720491bb71a72dadc47c7f4410e15f93e43d07d2b371951a0e6a18d1bd087aa96a5c4 +a7c006692227a06db40bceac3d5b1daae60b5692dd9b54772bedb5fea0bcc91cbcdb530cac31900ffc70c5b3ffadc969 +8d3ec6032778420dfa8be52066ba0e623467df33e4e1901dbadd586c5d750f4ccde499b5197e26b9ea43931214060f69 +8d9a8410518ea64f89df319bfd1fc97a0971cdb9ad9b11d1f8fe834042ea7f8dce4db56eeaf179ff8dda93b6db93e5ce +a3c533e9b3aa04df20b9ff635cb1154ce303e045278fcf3f10f609064a5445552a1f93989c52ce852fd0bbd6e2b6c22e +81934f3a7f8c1ae60ec6e4f212986bcc316118c760a74155d06ce0a8c00a9b9669ec4e143ca214e1b995e41271774fd9 +ab8e2d01a71192093ef8fafa7485e795567cc9db95a93fb7cc4cf63a391ef89af5e2bfad4b827fffe02b89271300407f +83064a1eaa937a84e392226f1a60b7cfad4efaa802f66de5df7498962f7b2649924f63cd9962d47906380b97b9fe80e1 +b4f5e64a15c6672e4b55417ee5dc292dcf93d7ea99965a888b1cc4f5474a11e5b6520eacbcf066840b343f4ceeb6bf33 +a63d278b842456ef15c278b37a6ea0f27c7b3ffffefca77c7a66d2ea06c33c4631eb242bbb064d730e70a8262a7b848a +83a41a83dbcdf0d22dc049de082296204e848c453c5ab1ba75aa4067984e053acf6f8b6909a2e1f0009ed051a828a73b +819485b036b7958508f15f3c19436da069cbe635b0318ebe8c014cf1ef9ab2df038c81161b7027475bcfa6fff8dd9faf +aa40e38172806e1e045e167f3d1677ef12d5dcdc89b43639a170f68054bd196c4fae34c675c1644d198907a03f76ba57 +969bae484883a9ed1fbed53b26b3d4ee4b0e39a6c93ece5b3a49daa01444a1c25727dabe62518546f36b047b311b177c +80a9e73a65da99664988b238096a090d313a0ee8e4235bc102fa79bb337b51bb08c4507814eb5baec22103ec512eaab0 +86604379aec5bddda6cbe3ef99c0ac3a3c285b0b1a15b50451c7242cd42ae6b6c8acb717dcca7917838432df93a28502 +a23407ee02a495bed06aa7e15f94cfb05c83e6d6fba64456a9bbabfa76b2b68c5c47de00ba169e710681f6a29bb41a22 +98cff5ecc73b366c6a01b34ac9066cb34f7eeaf4f38a5429bad2d07e84a237047e2a065c7e8a0a6581017dadb4695deb +8de9f68a938f441f3b7ab84bb1f473c5f9e5c9e139e42b7ccee1d254bd57d0e99c2ccda0f3198f1fc5737f6023dd204e +b0ce48d815c2768fb472a315cad86aa033d0e9ca506f146656e2941829e0acb735590b4fbc713c2d18d3676db0a954ac +82f485cdefd5642a6af58ac6817991c49fac9c10ace60f90b27f1788cc026c2fe8afc83cf499b3444118f9f0103598a8 +82c24550ed512a0d53fc56f64cc36b553823ae8766d75d772dacf038c460f16f108f87a39ceef7c66389790f799dbab3 +859ffcf1fe9166388316149b9acc35694c0ea534d43f09dae9b86f4aa00a23b27144dda6a352e74b9516e8c8d6fc809c +b8f7f353eec45da77fb27742405e5ad08d95ec0f5b6842025be9def3d9892f85eb5dd0921b41e6eff373618dba215bca +8ccca4436f9017e426229290f5cd05eac3f16571a4713141a7461acfe8ae99cd5a95bf5b6df129148693c533966145da +a2c67ecc19c0178b2994846fea4c34c327a5d786ac4b09d1d13549d5be5996d8a89021d63d65cb814923388f47cc3a03 +aa0ff87d676b418ec08f5cbf577ac7e744d1d0e9ebd14615b550eb86931eafd2a36d4732cc5d6fab1713fd7ab2f6f7c0 +8aef4730bb65e44efd6bb9441c0ae897363a2f3054867590a2c2ecf4f0224e578c7a67f10b40f8453d9f492ac15a9b2d +86a187e13d8fba5addcfdd5b0410cedd352016c930f913addd769ee09faa6be5ca3e4b1bdb417a965c643a99bd92be42 +a0a4e9632a7a094b14b29b78cd9c894218cdf6783e61671e0203865dc2a835350f465fbaf86168f28af7c478ca17bc89 +a8c7b02d8deff2cd657d8447689a9c5e2cd74ef57c1314ac4d69084ac24a7471954d9ff43fe0907d875dcb65fd0d3ce5 +97ded38760aa7be6b6960b5b50e83b618fe413cbf2bcc1da64c05140bcc32f5e0e709cd05bf8007949953fac5716bad9 +b0d293835a24d64c2ae48ce26e550b71a8c94a0883103757fb6b07e30747f1a871707d23389ba2b2065fa6bafe220095 +8f9e291bf849feaa575592e28e3c8d4b7283f733d41827262367ea1c40f298c7bcc16505255a906b62bf15d9f1ba85fb +998f4e2d12708b4fd85a61597ca2eddd750f73c9e0c9b3cf0825d8f8e01f1628fd19797dcaed3b16dc50331fc6b8b821 +b30d1f8c115d0e63bf48f595dd10908416774c78b3bbb3194192995154d80ea042d2e94d858de5f8aa0261b093c401fd +b5d9c75bb41f964cbff3f00e96d9f1480c91df8913f139f0d385d27a19f57a820f838eb728e46823cbff00e21c660996 +a6edec90b5d25350e2f5f0518777634f9e661ec9d30674cf5b156c4801746d62517751d90074830ac0f4b09911c262f1 +82f98da1264b6b75b8fbeb6a4d96d6a05b25c24db0d57ba3a38efe3a82d0d4e331b9fc4237d6494ccfe4727206457519 +b89511843453cf4ecd24669572d6371b1e529c8e284300c43e0d5bb6b3aaf35aeb634b3cb5c0a2868f0d5e959c1d0772 +a82bf065676583e5c1d3b81987aaae5542f522ba39538263a944bb33ea5b514c649344a96c0205a3b197a3f930fcda6c +a37b47ea527b7e06c460776aa662d9a49ff4149d3993f1a974b0dd165f7171770d189b0e2ea54fd5fccb6a14b116e68a +a1017677f97dda818274d47556d09d0e4ccacb23a252f82a6cfe78c630ad46fb9806307445a59fb61262182de3a2b29c +b01e9fcac239ba270e6877b79273ddd768bf8a51d2ed8a051b1c11e18eff3de5920e2fcbfbd26f06d381eddd3b1f1e1b +82fcd53d803b1c8e4ed76adc339b7f3a5962d37042b9683aabac7513ac68775d4a566a9460183926a6a95dbe7d551a1f +a763e78995d55cd21cdb7ef75d9642d6e1c72453945e346ab6690c20a4e1eeec61bb848ef830ae4b56182535e3c71d8f +b769f4db602251d4b0a1186782799bdcef66de33c110999a5775c50b349666ffd83d4c89714c4e376f2efe021a5cfdb2 +a59cbd1b785efcfa6e83fc3b1d8cf638820bc0c119726b5368f3fba9dce8e3414204fb1f1a88f6c1ff52e87961252f97 +95c8c458fd01aa23ecf120481a9c6332ebec2e8bb70a308d0576926a858457021c277958cf79017ddd86a56cacc2d7db +82eb41390800287ae56e77f2e87709de5b871c8bdb67c10a80fc65f3acb9f7c29e8fa43047436e8933f27449ea61d94d +b3ec25e3545eb83aed2a1f3558d1a31c7edde4be145ecc13b33802654b77dc049b4f0065069dd9047b051e52ab11dcdd +b78a0c715738f56f0dc459ab99e252e3b579b208142836b3c416b704ca1de640ca082f29ebbcee648c8c127df06f6b1e +a4083149432eaaf9520188ebf4607d09cf664acd1f471d4fb654476e77a9eaae2251424ffda78d09b6cb880df35c1219 +8c52857d68d6e9672df3db2df2dbf46b516a21a0e8a18eec09a6ae13c1ef8f369d03233320dd1c2c0bbe00abfc1ea18b +8c856089488803066bff3f8d8e09afb9baf20cecc33c8823c1c0836c3d45498c3de37e87c016b705207f60d2b00f8609 +831a3df39be959047b2aead06b4dcd3012d7b29417f642b83c9e8ce8de24a3dbbd29c6fdf55e2db3f7ea04636c94e403 +aed84d009f66544addabe404bf6d65af7779ce140dc561ff0c86a4078557b96b2053b7b8a43432ffb18cd814f143b9da +93282e4d72b0aa85212a77b336007d8ba071eea17492da19860f1ad16c1ea8867ccc27ef5c37c74b052465cc11ea4f52 +a7b78b8c8d057194e8d68767f1488363f77c77bddd56c3da2bc70b6354c7aa76247c86d51f7371aa38a4aa7f7e3c0bb7 +b1c77283d01dcd1bde649b5b044eac26befc98ff57cbee379fb5b8e420134a88f2fc7f0bf04d15e1fbd45d29e7590fe6 +a4aa8de70330a73b2c6458f20a1067eed4b3474829b36970a8df125d53bbdda4f4a2c60063b7cccb0c80fc155527652f +948a6c79ba1b8ad7e0bed2fae2f0481c4e41b4d9bbdd9b58164e28e9065700e83f210c8d5351d0212e0b0b68b345b3a5 +86a48c31dcbbf7b082c92d28e1f613a2378a910677d7db3a349dc089e4a1e24b12eee8e8206777a3a8c64748840b7387 +976adb1af21e0fc34148917cf43d933d7bfd3fd12ed6c37039dcd5a4520e3c6cf5868539ba5bf082326430deb8a4458d +b93e1a4476f2c51864bb4037e7145f0635eb2827ab91732b98d49b6c07f6ac443111aa1f1da76d1888665cb897c3834e +8afd46fb23bf869999fa19784b18a432a1f252d09506b8dbb756af900518d3f5f244989b3d7c823d9029218c655d3dc6 +83f1e59e3abeed18cdc632921672673f1cb6e330326e11c4e600e13e0d5bc11bdc970ae12952e15103a706fe720bf4d6 +90ce4cc660714b0b673d48010641c09c00fc92a2c596208f65c46073d7f349dd8e6e077ba7dcef9403084971c3295b76 +8b09b0f431a7c796561ecf1549b85048564de428dac0474522e9558b6065fede231886bc108539c104ce88ebd9b5d1b0 +85d6e742e2fb16a7b0ba0df64bc2c0dbff9549be691f46a6669bca05e89c884af16822b85faefefb604ec48c8705a309 +a87989ee231e468a712c66513746fcf03c14f103aadca0eac28e9732487deb56d7532e407953ab87a4bf8961588ef7b0 +b00da10efe1c29ee03c9d37d5918e391ae30e48304e294696b81b434f65cf8c8b95b9d1758c64c25e534d045ba28696f +91c0e1fb49afe46c7056400baa06dbb5f6e479db78ee37e2d76c1f4e88994357e257b83b78624c4ef6091a6c0eb8254d +883fb797c498297ccbf9411a3e727c3614af4eccde41619b773dc7f3259950835ee79453debf178e11dec4d3ada687a0 +a14703347e44eb5059070b2759297fcfcfc60e6893c0373eea069388eba3950aa06f1c57cd2c30984a2d6f9e9c92c79e +afebc7585b304ceba9a769634adff35940e89cd32682c78002822aab25eec3edc29342b7f5a42a56a1fec67821172ad5 +aea3ff3822d09dba1425084ca95fd359718d856f6c133c5fabe2b2eed8303b6e0ba0d8698b48b93136a673baac174fd9 +af2456a09aa777d9e67aa6c7c49a1845ea5cdda2e39f4c935c34a5f8280d69d4eec570446998cbbe31ede69a91e90b06 +82cada19fed16b891ef3442bafd49e1f07c00c2f57b2492dd4ee36af2bd6fd877d6cb41188a4d6ce9ec8d48e8133d697 +82a21034c832287f616619a37c122cee265cc34ae75e881fcaea4ea7f689f3c2bc8150bbf7dbcfd123522bfb7f7b1d68 +86877217105f5d0ec3eeff0289fc2a70d505c9fdf7862e8159553ef60908fb1a27bdaf899381356a4ef4649072a9796c +82b196e49c6e861089a427c0b4671d464e9d15555ffb90954cd0d630d7ae02eb3d98ceb529d00719c2526cd96481355a +a29b41d0d43d26ce76d4358e0db2b77df11f56e389f3b084d8af70a636218bd3ac86b36a9fe46ec9058c26a490f887f7 +a4311c4c20c4d7dd943765099c50f2fd423e203ccfe98ff00087d205467a7873762510cac5fdce7a308913ed07991ed7 +b1f040fc5cc51550cb2c25cf1fd418ecdd961635a11f365515f0cb4ffb31da71f48128c233e9cc7c0cf3978d757ec84e +a9ebae46f86d3bd543c5f207ed0d1aed94b8375dc991161d7a271f01592912072e083e2daf30c146430894e37325a1b9 +826418c8e17ad902b5fe88736323a47e0ca7a44bce4cbe27846ec8fe81de1e8942455dda6d30e192cdcc73e11df31256 +85199db563427c5edcbac21f3d39fec2357be91fb571982ddcdc4646b446ad5ced84410de008cb47b3477ee0d532daf8 +b7eed9cd400b2ca12bf1d9ae008214b8561fb09c8ad9ff959e626ffde00fee5ff2f5b6612e231f2a1a9b1646fcc575e3 +8b40bf12501dcbac78f5a314941326bfcddf7907c83d8d887d0bb149207f85d80cd4dfbd7935439ea7b14ea39a3fded7 +83e3041af302485399ba6cd5120e17af61043977083887e8d26b15feec4a6b11171ac5c06e6ad0971d4b58a81ff12af3 +8f5b9a0eecc589dbf8c35a65d5e996a659277ef6ea509739c0cb7b3e2da9895e8c8012de662e5b23c5fa85d4a8f48904 +835d71ed5e919d89d8e6455f234f3ff215462c4e3720c371ac8c75e83b19dfe3ae15a81547e4dc1138e5f5997f413cc9 +8b7d2e4614716b1db18e9370176ea483e6abe8acdcc3dcdf5fb1f4d22ca55d652feebdccc171c6de38398d9f7bfdec7a +93eace72036fe57d019676a02acf3d224cf376f166658c1bf705db4f24295881d477d6fdd7916efcfceff8c7a063deda +b1ac460b3d516879a84bc886c54f020a9d799e7c49af3e4d7de5bf0d2793c852254c5d8fe5616147e6659512e5ccb012 +acd0947a35cb167a48bcd9667620464b54ac0e78f9316b4aa92dcaab5422d7a732087e52e1c827faa847c6b2fe6e7766 +94ac33d21c3d12ff762d32557860e911cd94d666609ddcc42161b9c16f28d24a526e8b10bb03137257a92cec25ae637d +832e02058b6b994eadd8702921486241f9a19e68ed1406dad545e000a491ae510f525ccf9d10a4bba91c68f2c53a0f58 +9471035d14f78ff8f463b9901dd476b587bb07225c351161915c2e9c6114c3c78a501379ab6fb4eb03194c457cbd22bf +ab64593e034c6241d357fcbc32d8ea5593445a5e7c24cac81ad12bd2ef01843d477a36dc1ba21dbe63b440750d72096a +9850f3b30045e927ad3ec4123a32ed2eb4c911f572b6abb79121873f91016f0d80268de8b12e2093a4904f6e6cab7642 +987212c36b4722fe2e54fa30c52b1e54474439f9f35ca6ad33c5130cd305b8b54b532dd80ffd2c274105f20ce6d79f6e +8b4d0c6abcb239b5ed47bef63bc17efe558a27462c8208fa652b056e9eae9665787cd1aee34fbb55beb045c8bfdb882b +a9f3483c6fee2fe41312d89dd4355d5b2193ac413258993805c5cbbf0a59221f879386d3e7a28e73014f10e65dd503d9 +a2225da3119b9b7c83d514b9f3aeb9a6d9e32d9cbf9309cbb971fd53c4b2c001d10d880a8ad8a7c281b21d85ceca0b7c +a050be52e54e676c151f7a54453bbb707232f849beab4f3bf504b4d620f59ed214409d7c2bd3000f3ff13184ccda1c35 +adbccf681e15b3edb6455a68d292b0a1d0f5a4cb135613f5e6db9943f02181341d5755875db6ee474e19ace1c0634a28 +8b6eff675632a6fad0111ec72aacc61c7387380eb87933fd1d098856387d418bd38e77d897e65d6fe35951d0627c550b +aabe2328ddf90989b15e409b91ef055cb02757d34987849ae6d60bef2c902bf8251ed21ab30acf39e500d1d511e90845 +92ba4eb1f796bc3d8b03515f65c045b66e2734c2da3fc507fdd9d6b5d1e19ab3893726816a32141db7a31099ca817d96 +8a98b3cf353138a1810beb60e946183803ef1d39ac4ea92f5a1e03060d35a4774a6e52b14ead54f6794d5f4022b8685c +909f8a5c13ec4a59b649ed3bee9f5d13b21d7f3e2636fd2bb3413c0646573fdf9243d63083356f12f5147545339fcd55 +9359d914d1267633141328ed0790d81c695fea3ddd2d406c0df3d81d0c64931cf316fe4d92f4353c99ff63e2aefc4e34 +b88302031681b54415fe8fbfa161c032ea345c6af63d2fb8ad97615103fd4d4281c5a9cae5b0794c4657b97571a81d3b +992c80192a519038082446b1fb947323005b275e25f2c14c33cc7269e0ec038581cc43705894f94bad62ae33a8b7f965 +a78253e3e3eece124bef84a0a8807ce76573509f6861d0b6f70d0aa35a30a123a9da5e01e84969708c40b0669eb70aa6 +8d5724de45270ca91c94792e8584e676547d7ac1ac816a6bb9982ee854eb5df071d20545cdfd3771cd40f90e5ba04c8e +825a6f586726c68d45f00ad0f5a4436523317939a47713f78fd4fe81cd74236fdac1b04ecd97c2d0267d6f4981d7beb1 93e02b6052719f607dacd3a088274f65596bd0d09920b61ab5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7e024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02b45 -99aca9fb2f7760cecb892bf7262c176b334824f5727f680bba701a33e322cb6667531410dfc7c8e4321a3f0ea8af48cb1436638a2093123f046f0f504cc2a864825542873edbbc5d7ed17af125a4f2cf6433c6f4f61b81173726981dd989761d -88e2e982982bf8231e747e9dfcd14c05bd02623d1332734d2af26246c6869fb56ee6c994843f593178a040495ba61f4a083b0e18110b1d9f5224783d8f9a895e8ee744e87929430e9ba96bd29251cbf61240b256d1525600f3d562894d93d659 -a2d33775e3d9e6af0d1b27d389e6c021a578e617a3d6627686db6288d4b3dffd7a847a00f7ef01828b7f42885b660e4204923402aca18fbae74ccd4e9c50dd8c2281b38dc09c022342ed1ac695d53f7081cb21f05fdfc0a3508c04759196fcd3 -af565445d2ad54c83a75c40e8895f5ad7219a8c728bce9d58d7a83716e095432993ebbd3f6911c66415a6f920d1a4d171478509b54a114308a020b33bf4487a7a8d0aa76ae4676a9b54e765a680f562d3a4fcb2e92c58b14b49b5b2917cc258f -8aa99cfaf514cef4801599cadd780d222194ca1ad69a34779c2bcfda93e5dbeb931e13914421b5809a6c81f12cf7038b04a35257cc9e94c33761e68565b1274aa6a6f9d66477229747a66b308b138f92aa4326a3bf23df65a1fe33b3b289bfe1 -99ba36d8b4f56bde026099278548b1afc0a987cbd7c9baa51fc8e6cbb8237a17636f1a44a385cec69b05a5802059956a11fe793cabb939c38800f9c239ca2518e898ade1ec2513c9ee492071a35aabd78182392a09123d28dbc233313c9120c4 -a7dc40c36afccb30a2eaff250860b28b227c195cf05674704c567d77d6655c446ae835f8fc8667e71147ab02afcb2dad0babe60cbfa37d7c2cddc68d2dec54f28a4142f8353590a3902d5ddaa22066ab563dd1435dda83f276387b9767d69120 -939e6cc97a8b88572852a5b7f25e4838556307f60aeafb5d2b6961edbcafd4b48cb6ac980ffbacf4be963f324ba81e3d12de4f1459d8c746d0762c66ae1b166027f7fbe641d9c48f3c7d97b06d956b0be51dcc9aab65f3e99e1388e63bdd79f9 -b391e156541dfd4003d1697cdb7ec815b309807320574906b2e652ef0175828b356d215cd374b1b34d9f470b3fa0e643113e67b2273268f922f04f072cfb89008358185b25cd631f82911a3f20f90f75758ffb99bebb8076458ae1e9d1ae898c -b9ac9c84934cc2a85c876eff65577e1dfce1935cd6392c877dd881a7d2f5c3e9344f28c04f90c62a6db4237ca00f9e0d00cb5f63e3f060fc7303916e19273b6fe455f331cabbe2fe5a22d584484f0d4176120fec9819fbb0a01e6d38695acfcd -88209eb030c5d78734bf2c2a5c539653fd3c24b4c08e624f9ddc4a6550efbdc1054a56eb0c807595aad6de56fda326aa196d032a8b4b48d40140a2d77df3c7243eda6507936389a321a5811eb38e32ee433c788deeae1eb928b00940e2944bcc -a8632ddc9cf7cbc1e8b74a05b7d4a89618c64afe30367ca0c9550ae7d320bf4e51c5a69e1501a1d8bee4240d13d7835501aa39fdc401a74f4d5734e268a7ce29a1fcfdb0a8bc64e0dd4a9e8578d6985bc2bc6a3764ce7a3703f6fb2e52557a2b -a037ac67e8bb6f4193ac967e05d080a489f58ef8d3d30a89798246f3e4936121ee445b03e410a09e8ebc0db2e2477d110aad0ade99b0887f1eb016e750f42135866907f150bd6f4f99a8cb94281474166874808ebe03b118c5daab16dafdc38b -a50d9143116bffa3b237da8e1805327e81e9cd25e658289bd727d5f9e0020172cc8690dcfe31a240e5cbc48353b88c4908baa1dd7320165556e0aa633f62fcbe7870222d345a3bbcdb7ab6c07f0fd86be559964afabf56f0a8cbc0b4b91d477e -afa988ea6fa4f40c5ad07d2d580d29025ddf56d6ef1171a8b8de3464203f70b97d6f5ace72747345204b35150e06154d1477516a989ce8eea7871cc0d0de00a077c0fb23ad4837e409d0b885bf3f2dde11a30fa6273d662e68e09f461e52932f -97fa1a943ed8b81574304a3d03f4f15907f6e6e0cd36a66bd2ad2c75afafc70a61d3ff69b77ebe4dae9ca0fcedef80081062705e60bbb6ea0f1f398c84d2f8e4a3ac142ac66426c21ad5e9994ebbcc406af474c4aec5e32fadcb21875af7c9f1 -b30a564614493886f14a5dd71c89457504f8c59a7ac01b665ed167e9a8f9ee5832198fd319ecd234196ee57031bdf3840bd5a923e203a1938bc795c704b5285389750e1fd10d7050061ba19db00a60a2c0384a7d661d7d48ebe6962272230859 -84c8dea942cfae71cb02e705ec496d967425793ce8812e7ee53c2f23713abeaff566a658cd1c73dfd18187d16253a6ee0a623e82cd18e31cd1a1875d19c078835dc9292e141686150a88065226ada264740143e87c03a0f6c4da8c187438ebf4 -8c3abae8aed60338f8c4ff80aab22f8a2ae56756a93566c906f490a97151d34a1c3318054e1c494c60cc53327ad86a2d02c6c76a406726ce4f88635bc32eff0db0b61762dc518b95fa8da82e87e4bf3de54f1d72180ef53ed7bc5413e6a9a510 -a328230c92a6b1cef6a444bcb64edb992f71e3d7b93f0b6b8b408ba7c908db746d92ddb2c7588bab438ef3bc61be1c2f0dfc86ba2ff514b42b35c80f89b2e780f813ea1dfb977fbded2cd9b553b747fa952e227ebd8f071163d421fc337f04c9 -b482cab423cd5f1c5df036070aade7aa016283d69619d664025c3feab866a0a5691d344b2ee2bedc5dedd1f9a73eae16003a3827c9e5bbe22ded32d848fba840ffad1141ad158f5c40bc8ae0d03781b9705d851a7f1391b096c576c0f4f2a6b0 -919ee1df27fabcb21237a1b7b98f53d41d849e1b6a8f9e28c3fae2841c6b5a250e4041c737e6725476e5cd715e34d3880f58d80f61efaabc261bdc703e8750f48a923e9bf8980931b9fd9e40014c66c54b3e7c98241d76d1aa47af43313a65a1 -ac94830145dbe9a8f7e6e0fc1f5fb454502d22abcafdc2dd96c6933c604461fa83b2b37385f4bc454875a02a6d4157841250956783515d11c7456e7f11b745f12856d89f5feedaf6a61a483a6c33a21cd2ba0c18eb41a1a2e7fc33bb53e4c570 -b209c699f1233735c5bb4bce848e4365fd76651ae2184d2279a90df0c2f69ffa2a24d84a9b9f274021072953c0d65e1a0202d490d6c37186af240114e445d87bff754b4824937e4f2c90a574061b1c4910fed88d90f698025a2a264e656cb8a4 -93320dc0576b0d069de63c40e5582b4486d9adf5e69e77e3ebaf3da26976fe42147a65051501bc8383f99e7ba75479c70a6726c2cd08bf98c7481f1f819712292d833a879f21a1221a9610bc748fb5e911055122fdb4055cdc84e8bfe0f4df9b -a4380b240e998cdf668591f71a0c88ed143b0185a920787627ce65095f8223dc606fa5bce93377af100de92d663e675c0736d7f1973603a84a5c4162fb5e01c88c7493503ae1d7e9fbe8ece9b418397d68c21eeb88dae226e09875d372c646dd -aab48517d69135a16b36b685adfe9b2544a709135a21ba3e75981a2cba4ec81d1fe28ac0f72fde0c0001c15300ed6a810f58d3117bdd58d0149751d6508cf8a1a1ff7b63dd02d2730a9d6fe96c77c502fe8ed46d50a181ec4bb35e37dfbd6af4 -8277265fe75ab89ce4ec65b33fb4084bec0a56d81faf2f7a9070d2ca3065678e03a790350eba56323a54e0285bc32fe8007d5259740fde226e16cbde8354eacd562294eb9b7f727ed72ffbdad86f467cf057c737b34b80a41deb92634ed866f5 -aa40a24cb2ebe606d969392c03020070f044c95088d80f57f771b837c048342d2cd3474600d7660441090ffb8d2ffb7f0eddd67eb378e3e1477a6ba0bc38096d5d2d3355bc8b60f605f57f0c1899da591457440352381d2b38c0aa9acc7fe419 -80815d10685808cb630820629bcd2fa9041c9b74433630c0b9c1b7f7e8edf1440b520217f76ec9a50c125cf4438aa66006a1928a9ed2321da7ea325c3d56b65462b72118ca2c99a0ea733aa11da9abbeda6cc71ffeed301ae70213a29e697dcd -ac235d079f91b00b1fead7523da8f73a5409fa8970907af0c5d5e4c6a0996dccfcdb0d822d08c7fbc0c24799457d011d04312d20831825f23cf988141056a6814c8a1cac9efe37bdcbfa272aed24cd92810fea7c49b0d07683a5c53643872179 -b8aa59534d75fa5ac1c2c3f963bf73899aff5210059dbde8a8635561c6249e5143affee3bd2fd57575213b52d9a73d5702525867a7dcbb1d0a49b98c2925556fc5463ff0209742046a24ab29e74257d6419401093cc4371944d811cc300b6a67 -80bbfc5b816eea29a6d84e2217dee4d547306994d39e5592515e1b0807b67fe960d1d5addb0ff1a20c158bdb294c04bf093d28996121845a2c9268e2c9ac0f4067e889c6aaca62f8535d35b45036954bd069e3afa84f04721538c26003304c20 -a535c17d0e151d0e03d42dd58ba8c715bee3fabca2890e0e016071d34184b6b34e770d2be29c8ec76b69bcc471d50f4d043c2c240e9b93a81cff7ee2724e02018dfd9b534e40be641fdb4884abcd83b76f517557ffba508f1ba2f56313f4de94 -b237eb7465df0d325a3aa58269be2627e4978f9863f4f100ed4c303cb1f6549e606f2e3c9180824d8049191965c8dacd0a0c76cc56cb22cf1bcfdb39372c8aa29b4f7b34582b1719e6bd59c930d87d5ccd838743b585d6e229d5ed42337315c0 -805c335a2a9d2de30809cf30808ef836d88e9453c510716f01696f14c72dd60505eca8f128970edc8e63a9aa1f8792ac0dd50dcc84fbf4cc8b32349c682a6a27bc7551c7aa273a94c1606d07710188d93579afe3be1781bded15a34ed6047922 -b25dadf385ddd3c39bcb0a014d3d4f66127946b1aceae8809e3a03d66cc25e27142ca108316391f857fe82fdea4db2520cc73793b695eafbf3ade00ef7ec747b0457e49303f5e1a370f5263b436566fe24a0876e5fe088238c7be37a0718d65f -b0f753081cabe2c8fce73aba82ff67dbc9842598b3e7fa3ce2a1f534536f8ac63c532fe66552ac6b7adb28c73ed4c8a4184849be7c1756a4681ce29ebf5e1c3aa806b667ee6bd68f6397aba3215dc1caec6742f21d681e32cd1160d6a3b1d7ee -b798771eeb3d7a17c62ba5916cc034bba870da6b1ac14c2e1cae71af3ad4e0c0d1ff983f691e0e55289d5a33b131f2ec12430c9566dd71f4d8be9c79155357a5c30c5efcfd75bbe1bb6d5ada4d50604ea49ed838d3641f268ca6e25c9c4b6b72 -b52554c017388b099804abbe565346591a086d9979e10140ddaccc0a3680e506db775d7cbeafde67563adf0f09f5c2420caf19629f4e8f03e6fe02e9416ecd5269989e482b90004a083967d1141387eb74865bac6bd17e7a6d5f58225e52d4b7 -b520ff694520919023d44d53f98a7de2f78ff37b2d9193dcaa35556a6a0febf767781a4c961dce7c804bfdf81935f8f0082865253da52e79dfa1c5ff74d61495b2da76e167d46114709e877a7791a3a95e33a42f56b83f5f5afe271c67ae997c -b721401983440797a03d5b99f2088a0b249aa911969c34dd6c615b0060325da555d2ad99d931170c0868b0488a2234a4114cc0013d5163b833f5c45c5eb536421c016cf85788390176bb2dc4c196d6be26bbbfceae048b82f0d8039222e71c94 -acd9d833ba0a8cbd8d1ba939a11ea0fa5607e1bc6e693ec318bdb097aedd042d76e695dcebebd142e2e4ac30b1905dff03ec36d9cc70577e4dbe5e9ed7c20c7afb13a7f0155f203c6b83b9f1ad3d20a0d4aef0fbbbcf466ffc1bcd482bc2f5e0 -8cc1795de015f2b0e72116f169f3b4624b7738ceebea354e0bd9051c27b86f647ea36cad57ea6884c1a8adf9b45cd83514fa687e68878bbd613d793aa10986d5a0411f081689229e0d72133b3667b9f3f1a02211d0e680564eb1ea43393e1f36 -aa9281c61113c343a108de1036570feefc72fb7a96ff11f73024de12b83f29631f5a8a5900e6f10b15227c6f7462881511271bf785ebdf95ce288100e5dab391f664f6ff76c72b65b34479a4f43e5e8eba292209d6654157286ad3242ac342db -aaf16866275082e59d415db317aa874267d048ee405a553e852e6d175711d31a1fee99912345915bce121f43bc3e00d81338e5fcd3c8a1012fb4f172a9fe15622dd368b4d9d5cb60d189f423b071791fe26cea7676aca8df07965cacf80b0cd0 -accc80b3d8a6ffa648487a3d3c0ce1aeeb5401edf3cf2e385ea4a6d5fc110054fcce38f01f1da7141bbed30eb7a0a6810c82212bbb9da75d6033082dbcf6bc6a5791f85aa0f045a10da5de015edbf369b4d23b32b0c058962d2ee88e6911f994 -83f1089395a16077738cc7c9a6d6a3dc9033aac4abc508af5a1f007ca92e1a80b2e6f2dbda7fdcf0d5646de790a6201d0a9cfbcb6620a1426600e3a6a425ec004384f49fb9dcd166691a47177d45dcbcb761a11d46220b0aa09fc946131f7aa5 -9246bb586d43cb817c2e15ed609156e9f1cd284ba2f4797bbfa51c0341e1ba382eaac059aa9f63fb88d228a1a932839a171e7c7d00199dc7c4d6c5ea038a02cbc3cc5297c70401520e70ebbcffacd6a703f62896f3c788f94dde3c33ab0ecbdb -a316cb7c74feb0563c56cc79015e2774fbeca458bf8e9fb07894f9d6bcd73f7fb9428e87c816e5629e4bf7f3ec567fbc091549471b75492dde08217cb334b716b4582b24384586e53388873a78a90ec01bd7c3bace9cfc52161467df16e27c33 -ade18c74bbe60d1d69f4a570f8e5fd8696c26cc9e02829040b6b14cb9c49a4b3263b5bd5e16ec0b29010b4be054c16ab09304e23442af7d7f5fcc60bc6c5634ab6e4aed7ef334b2785e4c7672d59a687278e42d310342db5e5975d716e6d1595 -b7728800bb2039acf228fa3d8028569c426cb85d28b2b5820bbef938d5ca8c4df981d3e01a309e26ca101e8295d0f6990c03b8c239798323575874a4ee5bfe46cfe99b9657189142aacd8f8d1f26cf4c0e73c6397c31ba8f18102b9ea315b638 -8fb14f2a9be193f54977ecd3021663108ea143627b9a9d9faff85d1a86b855f6c437eab435fad3304f245bd7732af07f1173494cdb802fb96e85d2db89e1643206e183f3b228ca8d3f586e71aa9308eaf0223100bf07942fc39e465016d1f775 -ac1e025e53d98fdb3380489dce82d9d4bd3a6c98f0a523b841cb09a6f26ddd4d22efd98776e78d10fd996995fd00e81e08d3c25dd14a54b25a9d483677a24bbb8d1cb41a443b2c71038e6893b1b30f70758424e0f2039a48060191389033ef55 -a4c017311b9e930868132527a9849072b91db04fd36c619ae39c98da9e2174e6201d3c2ff1246c06b1b6815bbf3ea4a1116564f55ee2fe4c4d655e2294c0ded842cba209c255ca3d7b7f82d162f97890dfdeed087aa2f87cbfc61d61815da39d -89516315a3956b455843c2555248bd94dcb19993060fe75fdd51f7aa9c9147ab13997d8a98036a8f04bee5c91d78d2990907e35a52537a8ab3ed15f1a71afdcd38044a5b6e93f662b9d36c16933a881927cacae668c4c06ee6f004c9e3989bad -a1e78a011e210400c68ca76045f7da74119bff3cbe382efd2bd2ac76567c52d68d75536a91999d084043e1ce2d07d02e0b69fb99924101d2543521747536fbc51b0454aa9a4cbbec101121f597863a5c0fee2ca5eab35dff9b9085bef8b2b0d0 -830fd8d083e39153ecab43cabb22e29d7b44a55fba467af4ddd3f069439d2972ef53c3518de788f96b3f4f64963987d0155ba27afc28643af3de8e476ff515a68285728167408f45d99e574680bda6bacdd4322e587e4aa99386e035c0e931ad -b89584da22237e3061d991b1a55a5e55dc637b8b671130d304587729348138ef87885180310efe9f9f6d3580b9d7fdcf0649e8a79d2dec8c25a9f53df0fac5d517db999029cbfdd7c2cbd3e9a5503e5d267d3d8ad752335915c92b850b14bafb -959b8030733799882c5e3735479924b013756e57b893f9792bab4043e2d362d77cf308166d782e3989caa771b8a0c0a01302cb7b5e8ca12e2d6cebd59d4cd173c9dc25f438bac597fab17b4ff44997a489c168e7204b7d7c21d0938f0a2e3b51 -a0a9e5503d9afe0027891dab890c687fd5f5fac5741418490c64d7c15f59533dd603a50163c79402afa61bd02de486761983c94501da17e6bbe78c497f2122210071602f578adc0ebe7a4679f87fe77e09c8c122de69105f13455fea25f08e6f -9811487283ad620cd7c9b303ae2f348d0e6f5ee17b504baaa817ae207adb912a00d3cc36dbf48745eb899e6b6e22f09f0f9ba29d949ecd7350fbbfe87a8c7cdd5d0e687fc807751d07634aaf7c38baf3b24a0670c38fa6ccd7431436fc95525f -8a13aa5071c526e560def7d8583393942f07d88c9d8d26c98738fd65f57af2e3326dbb1edff0f39fe98eda4a13ed4fd71844254b954690154c4804e1c4a53df9dc4643f4b7b09d0860070f6b2318d0d63d28fb56bf5b6ff456a18dfc72fdfbbe -b9c90ff6bff5dd97d90aee27ea1c61c1afe64b054c258b097709561fe00710e9e616773fc4bdedcbf91fbd1a6cf139bf14d20db07297418694c12c6c9b801638eeb537cb3741584a686d69532e3b6c12d8a376837f712032421987f1e770c258 +b5bfd7dd8cdeb128843bc287230af38926187075cbfbefa81009a2ce615ac53d2914e5870cb452d2afaaab24f3499f72185cbfee53492714734429b7b38608e23926c911cceceac9a36851477ba4c60b087041de621000edc98edada20c1def2 +b5337ba0ce5d37224290916e268e2060e5c14f3f9fc9e1ec3af5a958e7a0303122500ce18f1a4640bf66525bd10e763501fe986d86649d8d45143c08c3209db3411802c226e9fe9a55716ac4a0c14f9dcef9e70b2bb309553880dc5025eab3cc +b3c1dcdc1f62046c786f0b82242ef283e7ed8f5626f72542aa2c7a40f14d9094dd1ebdbd7457ffdcdac45fd7da7e16c51200b06d791e5e43e257e45efdf0bd5b06cd2333beca2a3a84354eb48662d83aef5ecf4e67658c851c10b13d8d87c874 +954d91c7688983382609fca9e211e461f488a5971fd4e40d7e2892037268eacdfd495cfa0a7ed6eb0eb11ac3ae6f651716757e7526abe1e06c64649d80996fd3105c20c4c94bc2b22d97045356fe9d791f21ea6428ac48db6f9e68e30d875280 +88a6b6bb26c51cf9812260795523973bb90ce80f6820b6c9048ab366f0fb96e48437a7f7cb62aedf64b11eb4dfefebb0147608793133d32003cb1f2dc47b13b5ff45f1bb1b2408ea45770a08dbfaec60961acb8119c47b139a13b8641e2c9487 +85cd7be9728bd925d12f47fb04b32d9fad7cab88788b559f053e69ca18e463113ecc8bbb6dbfb024835f901b3a957d3108d6770fb26d4c8be0a9a619f6e3a4bf15cbfd48e61593490885f6cee30e4300c5f9cf5e1c08e60a2d5b023ee94fcad0 +80477dba360f04399821a48ca388c0fa81102dd15687fea792ee8c1114e00d1bc4839ad37ac58900a118d863723acfbe08126ea883be87f50e4eabe3b5e72f5d9e041db8d9b186409fd4df4a7dde38c0e0a3b1ae29b098e5697e7f110b6b27e4 +b7a6aec08715a9f8672a2b8c367e407be37e59514ac19dd4f0942a68007bba3923df22da48702c63c0d6b3efd3c2d04e0fe042d8b5a54d562f9f33afc4865dcbcc16e99029e25925580e87920c399e710d438ac1ce3a6dc9b0d76c064a01f6f7 +ac1b001edcea02c8258aeffbf9203114c1c874ad88dae1184fadd7d94cd09053649efd0ca413400e6e9b5fa4eac33261000af88b6bd0d2abf877a4f0355d2fb4d6007adb181695201c5432e50b850b51b3969f893bddf82126c5a71b042b7686 +90043fda4de53fb364fab2c04be5296c215599105ecff0c12e4917c549257125775c29f2507124d15f56e30447f367db0596c33237242c02d83dfd058735f1e3c1ff99069af55773b6d51d32a68bf75763f59ec4ee7267932ae426522b8aaab6 +a8660ce853e9dc08271bf882e29cd53397d63b739584dda5263da4c7cc1878d0cf6f3e403557885f557e184700575fee016ee8542dec22c97befe1d10f414d22e84560741cdb3e74c30dda9b42eeaaf53e27822de2ee06e24e912bf764a9a533 +8fe3921a96d0d065e8aa8fce9aa42c8e1461ca0470688c137be89396dd05103606dab6cdd2a4591efd6addf72026c12e065da7be276dee27a7e30afa2bd81c18f1516e7f068f324d0bad9570b95f6bd02c727cd2343e26db0887c3e4e26dceda +8ae1ad97dcb9c192c9a3933541b40447d1dc4eebf380151440bbaae1e120cc5cdf1bcea55180b128d8e180e3af623815191d063cc0d7a47d55fb7687b9d87040bf7bc1a7546b07c61db5ccf1841372d7c2fe4a5431ffff829f3c2eb590b0b710 +8c2fa96870a88150f7876c931e2d3cc2adeaaaf5c73ef5fa1cf9dfa0991ae4819f9321af7e916e5057d87338e630a2f21242c29d76963cf26035b548d2a63d8ad7bd6efefa01c1df502cbdfdfe0334fb21ceb9f686887440f713bf17a89b8081 +b9aa98e2f02bb616e22ee5dd74c7d1049321ac9214d093a738159850a1dbcc7138cb8d26ce09d8296368fd5b291d74fa17ac7cc1b80840fdd4ee35e111501e3fa8485b508baecda7c1ab7bd703872b7d64a2a40b3210b6a70e8a6ffe0e5127e3 +9292db67f8771cdc86854a3f614a73805bf3012b48f1541e704ea4015d2b6b9c9aaed36419769c87c49f9e3165f03edb159c23b3a49c4390951f78e1d9b0ad997129b17cdb57ea1a6638794c0cca7d239f229e589c5ae4f9fe6979f7f8cba1d7 +91cd9e86550f230d128664f7312591fee6a84c34f5fc7aed557bcf986a409a6de722c4330453a305f06911d2728626e611acfdf81284f77f60a3a1595053a9479964fd713117e27c0222cc679674b03bc8001501aaf9b506196c56de29429b46 +a9516b73f605cc31b89c68b7675dc451e6364595243d235339437f556cf22d745d4250c1376182273be2d99e02c10eee047410a43eff634d051aeb784e76cb3605d8e079b9eb6ad1957dfdf77e1cd32ce4a573c9dfcc207ca65af6eb187f6c3d +a9667271f7d191935cc8ad59ef3ec50229945faea85bfdfb0d582090f524436b348aaa0183b16a6231c00332fdac2826125b8c857a2ed9ec66821cfe02b3a2279be2412441bc2e369b255eb98614e4be8490799c4df22f18d47d24ec70bba5f7 +a4371144d2aa44d70d3cb9789096d3aa411149a6f800cb46f506461ee8363c8724667974252f28aea61b6030c05930ac039c1ee64bb4bd56532a685cae182bf2ab935eee34718cffcb46cae214c77aaca11dbb1320faf23c47247db1da04d8dc +89a7eb441892260b7e81168c386899cd84ffc4a2c5cad2eae0d1ab9e8b5524662e6f660fe3f8bfe4c92f60b060811bc605b14c5631d16709266886d7885a5eb5930097127ec6fb2ebbaf2df65909cf48f253b3d5e22ae48d3e9a2fd2b01f447e +9648c42ca97665b5eccb49580d8532df05eb5a68db07f391a2340769b55119eaf4c52fe4f650c09250fa78a76c3a1e271799b8333cc2628e3d4b4a6a3e03da1f771ecf6516dd63236574a7864ff07e319a6f11f153406280d63af9e2b5713283 +9663bf6dd446ea7a90658ee458578d4196dc0b175ef7fcfa75f44d41670850774c2e46c5a6be132a2c072a3c0180a24f0305d1acac49d2d79878e5cda80c57feda3d01a6af12e78b5874e2a4b3717f11c97503b41a4474e2e95b179113726199 +b212aeb4814e0915b432711b317923ed2b09e076aaf558c3ae8ef83f9e15a83f9ea3f47805b2750ab9e8106cb4dc6ad003522c84b03dc02829978a097899c773f6fb31f7fe6b8f2d836d96580f216fec20158f1590c3e0d7850622e15194db05 +925f005059bf07e9ceccbe66c711b048e236ade775720d0fe479aebe6e23e8af281225ad18e62458dc1b03b42ad4ca290d4aa176260604a7aad0d9791337006fbdebe23746f8060d42876f45e4c83c3643931392fde1cd13ff8bddf8111ef974 +9553edb22b4330c568e156a59ef03b26f5c326424f830fe3e8c0b602f08c124730ffc40bc745bec1a22417adb22a1a960243a10565c2be3066bfdb841d1cd14c624cd06e0008f4beb83f972ce6182a303bee3fcbcabc6cfe48ec5ae4b7941bfc +935f5a404f0a78bdcce709899eda0631169b366a669e9b58eacbbd86d7b5016d044b8dfc59ce7ed8de743ae16c2343b50e2f925e88ba6319e33c3fc76b314043abad7813677b4615c8a97eb83cc79de4fedf6ccbcfa4d4cbf759a5a84e4d9742 +a5b014ab936eb4be113204490e8b61cd38d71da0dec7215125bcd131bf3ab22d0a32ce645bca93e7b3637cf0c2db3d6601a0ddd330dc46f9fae82abe864ffc12d656c88eb50c20782e5bb6f75d18760666f43943abb644b881639083e122f557 +935b7298ae52862fa22bf03bfc1795b34c70b181679ae27de08a9f5b4b884f824ef1b276b7600efa0d2f1d79e4a470d51692fd565c5cf8343dd80e5d3336968fc21c09ba9348590f6206d4424eb229e767547daefa98bc3aa9f421158dee3f2a +9830f92446e708a8f6b091cc3c38b653505414f8b6507504010a96ffda3bcf763d5331eb749301e2a1437f00e2415efb01b799ad4c03f4b02de077569626255ac1165f96ea408915d4cf7955047620da573e5c439671d1fa5c833fb11de7afe6 +840dcc44f673fff3e387af2bb41e89640f2a70bcd2b92544876daa92143f67c7512faf5f90a04b7191de01f3e2b1bde00622a20dc62ca23bbbfaa6ad220613deff43908382642d4d6a86999f662efd64b1df448b68c847cfa87630a3ffd2ec76 +92950c895ed54f7f876b2fda17ecc9c41b7accfbdd42c210cc5b475e0737a7279f558148531b5c916e310604a1de25a80940c94fe5389ae5d6a5e9c371be67bceea1877f5401725a6595bcf77ece60905151b6dfcb68b75ed2e708c73632f4fd +8010246bf8e94c25fd029b346b5fbadb404ef6f44a58fd9dd75acf62433d8cc6db66974f139a76e0c26dddc1f329a88214dbb63276516cf325c7869e855d07e0852d622c332ac55609ba1ec9258c45746a2aeb1af0800141ee011da80af175d4 +b0f1bad257ebd187bdc3f37b23f33c6a5d6a8e1f2de586080d6ada19087b0e2bf23b79c1b6da1ee82271323f5bdf3e1b018586b54a5b92ab6a1a16bb3315190a3584a05e6c37d5ca1e05d702b9869e27f513472bcdd00f4d0502a107773097da +9636d24f1ede773ce919f309448dd7ce023f424afd6b4b69cb98c2a988d849a283646dc3e469879daa1b1edae91ae41f009887518e7eb5578f88469321117303cd3ac2d7aee4d9cb5f82ab9ae3458e796dfe7c24284b05815acfcaa270ff22e2 +b373feb5d7012fd60578d7d00834c5c81df2a23d42794fed91aa9535a4771fde0341c4da882261785e0caca40bf83405143085e7f17e55b64f6c5c809680c20b050409bf3702c574769127c854d27388b144b05624a0e24a1cbcc4d08467005b +b15680648949ce69f82526e9b67d9b55ce5c537dc6ab7f3089091a9a19a6b90df7656794f6edc87fb387d21573ffc847062623685931c2790a508cbc8c6b231dd2c34f4d37d4706237b1407673605a604bcf6a50cc0b1a2db20485e22b02c17e +8817e46672d40c8f748081567b038a3165f87994788ec77ee8daea8587f5540df3422f9e120e94339be67f186f50952504cb44f61e30a5241f1827e501b2de53c4c64473bcc79ab887dd277f282fbfe47997a930dd140ac08b03efac88d81075 +a6e4ef6c1d1098f95aae119905f87eb49b909d17f9c41bcfe51127aa25fee20782ea884a7fdf7d5e9c245b5a5b32230b07e0dbf7c6743bf52ee20e2acc0b269422bd6cf3c07115df4aa85b11b2c16630a07c974492d9cdd0ec325a3fabd95044 +8634aa7c3d00e7f17150009698ce440d8e1b0f13042b624a722ace68ead870c3d2212fbee549a2c190e384d7d6ac37ce14ab962c299ea1218ef1b1489c98906c91323b94c587f1d205a6edd5e9d05b42d591c26494a6f6a029a2aadb5f8b6f67 +821a58092900bdb73decf48e13e7a5012a3f88b06288a97b855ef51306406e7d867d613d9ec738ebacfa6db344b677d21509d93f3b55c2ebf3a2f2a6356f875150554c6fff52e62e3e46f7859be971bf7dd9d5b3e1d799749c8a97c2e04325df +8dba356577a3a388f782e90edb1a7f3619759f4de314ad5d95c7cc6e197211446819c4955f99c5fc67f79450d2934e3c09adefc91b724887e005c5190362245eec48ce117d0a94d6fa6db12eda4ba8dde608fbbd0051f54dcf3bb057adfb2493 +a32a690dc95c23ed9fb46443d9b7d4c2e27053a7fcc216d2b0020a8cf279729c46114d2cda5772fd60a97016a07d6c5a0a7eb085a18307d34194596f5b541cdf01b2ceb31d62d6b55515acfd2b9eec92b27d082fbc4dc59fc63b551eccdb8468 +a040f7f4be67eaf0a1d658a3175d65df21a7dbde99bfa893469b9b43b9d150fc2e333148b1cb88cfd0447d88fa1a501d126987e9fdccb2852ecf1ba907c2ca3d6f97b055e354a9789854a64ecc8c2e928382cf09dda9abde42bbdf92280cdd96 +864baff97fa60164f91f334e0c9be00a152a416556b462f96d7c43b59fe1ebaff42f0471d0bf264976f8aa6431176eb905bd875024cf4f76c13a70bede51dc3e47e10b9d5652d30d2663b3af3f08d5d11b9709a0321aba371d2ef13174dcfcaf +95a46f32c994133ecc22db49bad2c36a281d6b574c83cfee6680b8c8100466ca034b815cfaedfbf54f4e75188e661df901abd089524e1e0eb0bf48d48caa9dd97482d2e8c1253e7e8ac250a32fd066d5b5cb08a8641bdd64ecfa48289dca83a3 +a2cce2be4d12144138cb91066e0cd0542c80b478bf467867ebef9ddaf3bd64e918294043500bf5a9f45ee089a8d6ace917108d9ce9e4f41e7e860cbce19ac52e791db3b6dde1c4b0367377b581f999f340e1d6814d724edc94cb07f9c4730774 +b145f203eee1ac0a1a1731113ffa7a8b0b694ef2312dabc4d431660f5e0645ef5838e3e624cfe1228cfa248d48b5760501f93e6ab13d3159fc241427116c4b90359599a4cb0a86d0bb9190aa7fabff482c812db966fd2ce0a1b48cb8ac8b3bca +adabe5d215c608696e03861cbd5f7401869c756b3a5aadc55f41745ad9478145d44393fec8bb6dfc4ad9236dc62b9ada0f7ca57fe2bae1b71565dbf9536d33a68b8e2090b233422313cc96afc7f1f7e0907dc7787806671541d6de8ce47c4cd0 +ae7845fa6b06db53201c1080e01e629781817f421f28956589c6df3091ec33754f8a4bd4647a6bb1c141ac22731e3c1014865d13f3ed538dcb0f7b7576435133d9d03be655f8fbb4c9f7d83e06d1210aedd45128c2b0c9bab45a9ddde1c862a5 +9159eaa826a24adfa7adf6e8d2832120ebb6eccbeb3d0459ffdc338548813a2d239d22b26451fda98cc0c204d8e1ac69150b5498e0be3045300e789bcb4e210d5cd431da4bdd915a21f407ea296c20c96608ded0b70d07188e96e6c1a7b9b86b +a9fc6281e2d54b46458ef564ffaed6944bff71e389d0acc11fa35d3fcd8e10c1066e0dde5b9b6516f691bb478e81c6b20865281104dcb640e29dc116daae2e884f1fe6730d639dbe0e19a532be4fb337bf52ae8408446deb393d224eee7cfa50 +84291a42f991bfb36358eedead3699d9176a38f6f63757742fdbb7f631f2c70178b1aedef4912fed7b6cf27e88ddc7eb0e2a6aa4b999f3eb4b662b93f386c8d78e9ac9929e21f4c5e63b12991fcde93aa64a735b75b535e730ff8dd2abb16e04 +a1b7fcacae181495d91765dfddf26581e8e39421579c9cbd0dd27a40ea4c54af3444a36bf85a11dda2114246eaddbdd619397424bb1eb41b5a15004b902a590ede5742cd850cf312555be24d2df8becf48f5afba5a8cd087cb7be0a521728386 +92feaaf540dbd84719a4889a87cdd125b7e995a6782911931fef26da9afcfbe6f86aaf5328fe1f77631491ce6239c5470f44c7791506c6ef1626803a5794e76d2be0af92f7052c29ac6264b7b9b51f267ad820afc6f881460521428496c6a5f1 +a525c925bfae1b89320a5054acc1fa11820f73d0cf28d273092b305467b2831fab53b6daf75fb926f332782d50e2522a19edcd85be5eb72f1497193c952d8cd0bcc5d43b39363b206eae4cb1e61668bde28a3fb2fc1e0d3d113f6dfadb799717 +98752bb6f5a44213f40eda6aa4ff124057c1b13b6529ab42fe575b9afa66e59b9c0ed563fb20dff62130c436c3e905ee17dd8433ba02c445b1d67182ab6504a90bbe12c26a754bbf734665c622f76c62fe2e11dd43ce04fd2b91a8463679058b +a9aa9a84729f7c44219ff9e00e651e50ddea3735ef2a73fdf8ed8cd271961d8ed7af5cd724b713a89a097a3fe65a3c0202f69458a8b4c157c62a85668b12fc0d3957774bc9b35f86c184dd03bfefd5c325da717d74192cc9751c2073fe9d170e +b221c1fd335a4362eff504cd95145f122bf93ea02ae162a3fb39c75583fc13a932d26050e164da97cff3e91f9a7f6ff80302c19dd1916f24acf6b93b62f36e9665a8785413b0c7d930c7f1668549910f849bca319b00e59dd01e5dec8d2edacc +a71e2b1e0b16d754b848f05eda90f67bedab37709550171551050c94efba0bfc282f72aeaaa1f0330041461f5e6aa4d11537237e955e1609a469d38ed17f5c2a35a1752f546db89bfeff9eab78ec944266f1cb94c1db3334ab48df716ce408ef +b990ae72768779ba0b2e66df4dd29b3dbd00f901c23b2b4a53419226ef9232acedeb498b0d0687c463e3f1eead58b20b09efcefa566fbfdfe1c6e48d32367936142d0a734143e5e63cdf86be7457723535b787a9cfcfa32fe1d61ad5a2617220 +8d27e7fbff77d5b9b9bbc864d5231fecf817238a6433db668d5a62a2c1ee1e5694fdd90c3293c06cc0cb15f7cbeab44d0d42be632cb9ff41fc3f6628b4b62897797d7b56126d65b694dcf3e298e3561ac8813fbd7296593ced33850426df42db +a92039a08b5502d5b211a7744099c9f93fa8c90cedcb1d05e92f01886219dd464eb5fb0337496ad96ed09c987da4e5f019035c5b01cc09b2a18b8a8dd419bc5895388a07e26958f6bd26751929c25f89b8eb4a299d822e2d26fec9ef350e0d3c +92dcc5a1c8c3e1b28b1524e3dd6dbecd63017c9201da9dbe077f1b82adc08c50169f56fc7b5a3b28ec6b89254de3e2fd12838a761053437883c3e01ba616670cea843754548ef84bcc397de2369adcca2ab54cd73c55dc68d87aec3fc2fe4f10 +97f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb +ad3eb50121139aa34db1d545093ac9374ab7bca2c0f3bf28e27c8dcd8fc7cb42d25926fc0c97b336e9f0fb35e5a04c81 +8029c8ce0d2dce761a7f29c2df2290850c85bdfaec2955626d7acc8864aeb01fe16c9e156863dc63b6c22553910e27c1 +b1386c995d3101d10639e49b9e5d39b9a280dcf0f135c2e6c6928bb3ab8309a9da7178f33925768c324f11c3762cfdd5 +9596d929610e6d2ed3502b1bb0f1ea010f6b6605c95d4859f5e53e09fa68dc71dfd5874905447b5ec6cd156a76d6b6e8 +851e3c3d4b5b7cdbba25d72abf9812cf3d7c5a9dbdec42b6635e2add706cbeea18f985afe5247459f6c908620322f434 +b10f4cf8ec6e02491bbe6d9084d88c16306fdaf399fef3cd1453f58a4f7633f80dc60b100f9236c3103eaf727468374f +ade11ec630127e04d17e70db0237d55f2ff2a2094881a483797e8cddb98b622245e1f608e5dcd1172b9870e733b4a32f +af58c8a2f58f904ce20db81005331bf2d251e227e7d1bef575d691bdca842e6233eb2e26c2e116a61a78594772b38d25 +b3c1313c31ec82da5a7a09e9cf6656ca598c243345fe8d4828e520ade91787ffb8b9867db789b34ad67cef47b26ff86d +a8ed8a235355948e0b04be080b7b3e145293accefb4704d1da9050796b2f6870516c1ebf77ae6a65359edcfd016c0f36 +80e792d5ba24b8058f6d7291a2ec5cb68aab1e16e96d793128e86815631baf42c56b6205c19e25ce9727bd1fd6f9defb +816288c5d726b094e3fdf95cb8882f442c4d9d1101b92c7938a7dfd49bc50636d73ea1b05f75eb731c908c8fd8dee717 +ae009128d128ba2e1519bfa7a0c01ed494a7d461c3aba60f8a301701fed61fe4e31d6c79ce189542ae51df91e73ce1b3 +96a866d60a9007d05825c332476a83e869e15b11d7257172a67690ea9bd3efea44bf9c8d42191454eb04fcf110b16396 +8b250a2a06419adb9b611e89f7f8f2990aa301949b533ad3bf17c4a61ab5f5be0b1d5e2b571864d13f1bb75805c7795d +8450f49facf2e620fa45ee90e1801178842d927a2a25fc6ed7ba99a4eec7ae40eebfee41028eaa84f107f4a777694976 +91049080cf659c0985a22d1366e59191bb89663f922e8168b9b7d85c8a73d74a6d9dceefd855d3d858b493670c750581 +a1e167aeb2008087f3195926f1985c0a459d6ec57237255b1473a96de4e2c1cf766127c862c7dc853a6909e67cb06cf7 +b667c0d4e26e20698b07567358625d5f003839c92de8088e12dbd74a6f6a3156b4ea8d252c9ad62af5f6c4fec1cf6cc7 +8e4b5e304c0b1b161ae3e4b68b5e3ac66c42acd7c1ee2458044f6527c508a93995e50894d72d57c1350f91afe72775ff +8c642640aa7915421cdc21fd639f88a42052b1cfa358ff7702e60793a92b7b5926dae15a0c8f8f59cd3013f01c159ba3 +a356f35e713cfc283056bf539de54a21731e61efb4c47319f20de4a4b723d76a33b65f4a67d298b9ec5c2a1579418657 +93ce204146ce95f484dc79c27919a16c9e3fc14a9111c6c63d44491158d5838117d20851cc3227a5e8ba6ccf79e77f39 +b585664cbb9a84b52f89114e1cf0cf1171bea78a136dc1404ac88a11210b2debc3b7a55e702da93ff629095c134a295e +b6dfd444ec7fdceb14c6328f26ca12c3f9fc4327d8d8c68948e92e7e61262b82d833a65a9e3af6353ffa832b6da25705 +b4d4b8eb9ecfffe3f0d48fb4149c7b31aec1da7041ec03bd0750c52a2a7cbc3a7cfbf09d5bfdc56e3860826a62d0bb91 +a4e248e3d61db52da9683fef188579c470d65e2df9064726847b1599fc774049ffdc6ef2ae578d5ed7874f1298ecdf69 +a68a0fffc2e37d3183feb01b42234c0f4e510f9dc29d09c571e6da00fecad9da224cd0f31550070148667e226c4ca413 +86adda2ffecb77236c18005051f31f9657a0d50fef2a1175dfda32e74d5d53df825c10f289eb0ad39df0c64fc9bc7729 +998266d5c9c3764ed97d66fa9ed176af043999652bae19f0657c8328629d30af453230e3681c5a38e2f01e389ed8d825 +a05261554d3c620af0c914cf27ab98f5d3593c33ab313c198e0c40d6c72022eb5943778cd4f73e9fe8383392a7004976 +ad243fb3631bf90fedb9d679fd71fc0cf06bda028591ded2bd4c634ea7b3c2bd22eca2ab318fcdaa6c2cda1e63e1c57b +89b9859a04f903c95e97fb2951f01cc6418a2505eee0b5bc7266b4d33e01b69b9fe7dc56fa9ebb5856095be0925a422d +a68d118343a5bbfbbab95ff9bfe53aeb7fdbaf16db983e6f4456366df2aa01fbdb6ee9901cb102fc7d2bd099be2f1f3e +b49301f25d5a9dd2ec60ddb0b4b477291958487efea9e54dc0e4ef388f03b8bbadd13259d191f7a0b7513876767d8282 +8b93df7fb4513f67749905fd43db78f7026589b704ebb9ea3255d0ad6415437799f40f02e07efccda1e6fd5e8cd0a721 +ad88769ace96455da37c3c9019a9f523c694643be3f6b37b1e9dcc5053d1fe8e463abebdb1b3ef2f2fb801528a01c47c +80f0eb5dcbfaaf421bf59a8b9bd5245c4823c94510093e23e0b0534647fb5525a25ea3aeea0a927a1ee20c057f2c9234 +b10ad82ea6a5aeabe345d00eb17910d6942b6862f7f3773c7d321194e67c9cced0b3310425662606634dcd7f8b976c04 +82f6fd91f87822f6cc977808eeac77889f4a32fb0d618e784b2331263d0ffa820b3f70b069d32e0319c9e033ab75d3b4 +9436d3dc6b5e25b1f695f8c6c1c553dab312ccace4dac3afddc141d3506467cd50cb04a49ea96ea7f5a8a7b0fc65ef37 +8e0a9491651d52be8ebf4315fbbb410272f9a74b965d33b79ff1b9e1be3be59e43d9566773560e43280549c348e48f01 +8809137e5d3a22400d6e645a9bd84e21c492371736c7e62c51cef50fee3aa7f2405724367a83fd051ff702d971167f67 +b536a24f31a346de7f9863fc351fa602158404d2f94747eebe43abf1f21bf8f95a64146c02a4bec27b503f546789a388 +b5cdf5a04fc12a0e0ef7545830061dff7fd8abea46e48fbe6235109e6c36ee6bffcb9529e2f3d0d701cf58bbfb6a4197 +ab15377525753467d042b7931f66f862cbbb77464212c9aa72d4e5c04375ef55f619b3a446091c1ba1a3b5d9f05e538f +905a75b943ad017ff78ea6ddd1d28a45c7273ee1c2e5e3353685813793ead3370c09cabd903fcab9d8b1c6961372d486 +8147df4324faddc02fb0896367a7647b719b6499a361aecfdd3a34296fa6768ad31c34f9e873fd1e683386c44651883e +ac91d08570dd91f89d2e01dca67cdc83b640e20f073ea9f0734759c92182bb66c5d645f15ebd91ed705b66486ed2088d +ac6295ef2513bbea7ef4cdcf37d280300c34e63c4b9704663d55891a61bf5c91b04cc1d202a3a0a7c4520c30edc277c7 +b604be776a012095c0d4ebc77797dd8dec62a54c0559fb2185d7bac6b50d4e5fd471ac2d7f4523206d5d8178eabd9a87 +80ead68def272ce3f57951145e71ed6dc26da98e5825ef439af577c0c5de766d4e39207f205d5d21db903d89f37bbb02 +9950b4a830388c897158c7fe3921e2fe24beedc7c84e2024e8b92b9775f8f99593b54a86b8870ec5087734295ba06032 +b89ba714adabf94e658a7d14ac8fc197376a416841c2a80e1a6dde4f438d5f747d1fb90b39e8ea435c59d6ecda13dea1 +b0c78e7cc60bd05be46d48fbb0421a678c7f14b8d93730deb66fbe1647613b2c62b5075126d917047820c57fc3509cb9 +a860c4acc5444e9ae987e8c93cb9a5f17d954d63c060cc616f724e26bc73d2c54cd36e0492d1fde173847278e55942ba +8fb8269c9d5c15428e8d45da1251e4c4a4b600d47da0caea29fef246854d8fb6acae86a8e6440d0c429d8dd9c2dfee0c +96c5d8eb6fd5c525b348ee4335d200139e437e4be83690af0f35b7f336a7cda8c6d2958647988b84da9f2dd7bbb7710b +a7f62141c4346cc14e9823dc38ac7d587b0427022afc1498d12ee2c43f6ac3a82167057e670dd524b74137f8c3ceb56d +956aac50d06b46a3e94397f163f593f5010d366aa2d816c2205c7d0f47f90cf0f36c169e964f9bcf698d49182d47d91f +b812899bcdc0e70d79ca729cb01104bf60e1357b9085a10f64f3ba9865d57e9abd0a505a502d4de07afb46f4d266be2f +abce02c7e1372e25d40944dc9ece2904a8f59c8854c5f2875fe63ace8ce37d97881f4f9ab4f7bad070ec8e0daee58d3f +8fb13c515b2d6abb4e14ed753fad5cc36c3631dfe21a23d0f603aad719423dd5423157eefcbd9a9c6074e155b79eb38d +a9ef67304dc297ab5af778cf8afa849eeac27db4b6978963e97b95ef7a8d3264d0d07775f728c298a2b6daed2ecf5053 +a9b975520adb066e2ff2a4cde53284c23bc84261a22dc43b1634d99eff8e7892e46bb6e6da7319c9e72788aa9ea7a1ea +a6eaea4ab4206294474d9b956d9d3188d558a5633de2bd05df0d3bac03dbcbe4ed85406349c1d2e660b77c6da1f5bf8c +af4a19f77290dddee762e1e0d4bc9945aacea3f75756ae46cd3e58a8f74d1b5db73e4834687946b0f39191e32f2fed0c +aafa6523f58f1a4cabc924c86d842816d606afeea21fa4b2b8b9573425810fdcc41c98888318e868f9c05e2be12178a3 +8ef38fba0a3fa4ebe985239c8b759c22aaef0c57e6f39050a651c869487803b0d1e389c3d958fb5a7f37740f050ac69e +b07dfc9f85913c608ca7596a2e361f05e4853fad00e796fd492d247de6414892ce160f627669b1ba933b6ad726415d4e +94da679ad1d78b2bff5283c938f17b2a7d6e9cbcdf59d340e6dfb652951c7a9e852ac0590f99cfee9631b9410f6f00ea +98a907c9c021a5b034d3720197c160a82c4b7146cb73d48efeed99b9d0c6b831812cf80ac7e19e85a676a8cd3ead72de +adb746595466a12929019d0048cea33236b05c1229d2eba73b259a18a786f2bc3f05fc0598d8ce253cecb80bdf679aaf +a2fbac016996d68f9027a157b0a3f6a336144a798d6113adfcda3a5d05b62c31f108f112aa915906aef22b7f83b9228b +81841dea1904406d1b6fa49b4b3f7f6cb40b7646cf44d36c9fa07e3dee29f8e47324b40d8356ddf653109673c3374e9b +a3edbb8aac5e60c775775cbdb19067341b2e2530de48738e84c2c07151241ee31f0d8333bf20c2bc9dcb7b2e638a6b5e +b8aa6890e22964828787ce86460d3a32f12a655bb5c28de500f2fcf6b61e3334640ec6ba96029a4912af0d18df4b4139 +8ca43169f04243ad0fdb0152de17c60d9e31ee0ab520970fccd98590e05508821a183b4b367967e60d53c2c826ec5dbd +b179fffd9df8c00486c5a8b9327d599f5a11745ef564f06e126849b06fe2f99273c81f65bc941efb0debaadfecbfec1c +acf068f1c2b1926279cc82750ce21b0d6b0bfd0406f0d8bbfa959bd83935932957c7f6b8de318315bf0b75f6ee41a0f2 +b97831da260919c856e9f71a41687f5979bc16f8a53b1037285b4a2f9ce93af5cfe70bf0ad484744827fb55c847b58eb +aff50b0bd907383b0c241727af364fe084d021221bfb1b09fb6c1a7752eeba45d662493d590f1f182764b90b25f17906 +aeeef044c14e3ad41e1235c9e816e1eb49087fd3abe877b89b3bade74459186126e160bb569bcd77779e701b19b5f71a +8483deb2b7001ca7c438fcdca8ca6aba96c9cbc4becfd9b16a6062705eae270011bcaedcae69bb54630d8c78129e57c7 +aeee8d24be4ac0d9784c029e239fb5e64316ce29b88f47394cfaaa8bb966a72061bff72f99d02dc51c9705854686e77f +90ae09525a16bb2422169e15d6831c87968a14ebc0d1d27e11a759839c73c655b9d33ee5b12f275d6f440688146fbd2f +a3a41fc7fefef101422465e506bea7f3ff23c26fe35f5732b86f5f2471fb93b37ebc339f84c6be1e8d22abc812c2e212 +86f4b5293e8aea4af1f1fb05dcf99714cb3aff1cfc849b1bb73524061c921c9da9ad92579a852e1889da29d952f02fe5 +8932ef39d4050a1e9dc0fd8afeaf159472d71c5c27f458c69d2730836606ea56e19c8c4febf2535f930d3260e9bc7637 +86307b9f3696bb21c20e4558e30310389e7367803c353d437e9b696039a0ff054d9a4953b75237ab1d1dd6f71118c189 +96e57730e683ef5b550c91de18b19ac73879f3e26234297db68d28747ed0953beb0f3913cfb720c602720bf9330685d8 +b04a19ee70123782e47b238abde55baf60ac0c66292a998af0d14afc8bbeb1134e557b94cd17a020084631c09a0d3c02 +829abc8718be8139569fcb2c398962f38f4201114d30e2b2fb23566f8a27a5c380f5605cec543415202a12ed859e33f6 +a0744fa488c8fa92a722c5fc4ef5a47dfe824eccd87d26c8bab9c174cbb151d44b1b29082c48652f03d3177e5ec86001 +81d4035ae9fd28bdcd78b135cb54955d3b685a527319df6ee7e904b8e6d796f5f5a5f5035ee1de750c4cb6050e452b9e +b205e8c2ec24d7104fa0106c09ad34b5a912c1adef553fb718838dd627355993c2ec01055c11d00b2c75b68e9516d44b +b12d09da7968fa7394e449624fc7174d1d76c069ccb03e140d4d87a2d3f6d1f7b9cfc930f0c80becc673406ebe63f08e +b23752c158695da85048fdf38b395681cc0e8998630af8a9ed41efbda08c9964c2dc8ae6e53377264be4467d702c0de4 +b0d84582fd73628d96b8c1ec96197697c41a963542451a2ade0890af0d33c7161d0f18e1a1ce2c168ca2dc1e9119d55e +8b877e618b469aa187632e410b125d2999d5738fd66d482000706b51fd904a0c7e7daa8c9b729fa33817bbc4154cba2a +b1cfc8a7551b601723b937d497d01dec3ee7614c2bf13d430b1058d5ebc1406045009ff02c2ac15bf8cf16f860193d1e +b6d9da84f97b21e13175bbb0b5cc8e79e88b470c87a3e115726c1bd98e0288526c58f3faaa8aa170ace0cd6a60852525 +ad2e773c2d527671ca5fab7085dde4da31cd35f45d4315dd95d8893ff5fb900494dca08eccfc1a2fc7bf7c7fd2fcab97 +8d5a79b34aeb761d4a0c73f09f02e9548e6d382c33ee6887a759ab05762b490b8a549ef2933c7e3a46415c154c0221c0 +b6f2cbe81bd0a7298403be392f8456bed30aed7ef30216959357698f789affd2942ae5fbaf3f48ecebeb7c273b20cb57 +b5b6c45d99cea7ce6a1dc134aff4a8f630f299b42bd59592a7592345f8cd35bcbee944e61b0723de732fcad6e4425b63 +8077d64dfcb2418974e956ea6dbf8a4c05b25d2a025333ad7e2a379f1976dc036771403383a51bfa3476c9c619ef8bef +ad2e0a9d479c77a5fb73b3613a177fdaad50dcb50fed50e756ba18164c153af30b07fb2565e80ff7469f1b0338b7b5de +81017d1d80a6b6df4e99d0d7f85a8180b5523e8fa2ea2672fddff604933f8a113cab27fce098dcb454d7d1f7ed266e04 +852355479d68e76c7febf6dfe2ef8e80d575c0d3bd52c983803592021cfa898c571c0b884412c21e66f0dbfe03167b53 +98e1bf8ad48421467c93b9f72b47dded7c41b4fcd36ea55ca43ab24b0d0b876f5a731f422579b7167c7138fad2121266 +803369314abd5422019ed4b0ef652b4dbe97ef5a87b0ea373eec9628b64a12120b2c3d4eb53db405131ff786d14c7ac6 +adf2613fc34f73e1160975c140e925ed84d254e03cc3bc7fc1d19957b499c9ba9d9e4c1639981b594a7095c0a52c6757 +a2f6a68efdff6e4173c00692abcfdfcdaf6f8b62369afad3dafaae4f2f38c4860780b4624d185e20e4f4498b75b5fe94 +8b1658aa0e119fb8401d486ed08d60240d26a8623ef9788e3b45ad09ae31259395b021bd16be395139cbb7149714e764 +a7dd8bf21121285e00672ee8bb84e0cb39b2496fb53a26e35dfbca7f2b04e9a9ff9db15f53fe63fcbeafeb2deeaf2ca4 +b6d8d709e44bc18f3b41d69608edce60c02bcba48d3b7e2fd420842657f0665a7343246dea149a25e8f3416284abae66 +aaf744ca5e9bcb63e3e2939b7a1e96e4a93c88c76bec0cf4294dd7db95cdd3f6a7d92196e352d08680e2328bc4592899 +84434b015a7c398d35f1ec71fce455d62ba4ed4f62da042ec31bb2b4db47073314354cd50bc322297a1cfe35138bf490 +8d70b3a3cd9d5dfefdacfa418c0b775a112a47ce538d33a560a519660009c3f141fd6221c18539129e9c0acdaceeeb80 +b8c6903412a800ec78a4c15f31c24385a267b0c0ece32fd31bbbb557fd70c3b2d60d8fc0f90fbd70f43baa1928ea30ba +8e391dd445ea06cabb433f057853f8159511b2f9bef41aed9ccd14e0a6fcd912bbaebd38fd5fb736cfde0fa34b7a4874 +a40cd988f70613df32babbd1bbc2f1b29ff1ab0147b01161555a81d56c9621657999bcdb1df38485f687afc51d5d0f23 +b6a008b4426b3d7b28ae04eee4698fc8ef6a35d89008ef5394da39ce582ce1a45dcfae9a33b90f6fa4237f3667803873 +8987280debfb175c3b44a2f152ea82548e4f680966f1fcbee9bf7d714e31bf8080c33f52705ef3aeee70544b22516aba +a78a51a2c11eea7680a5a0ae417a2981f8c69c396e06da621eadd7510a3664ade49d065617bec67b3de779548a4f4509 +a4d9163f0a1bc048385e94d5e0bcafeee1b18f28eb23505623b9e8ef16f3df76408254dfbe790e45f2884198060d388d +83dcae2568a0c518793c0f6e38b42f9ceb50673d100b556a17ec8bd9faeec84afe50b8d72422c6b2356959667bb8e2de +874731941be4474b4576226e5906b5dee89fc9b56a9870dcc7289c1a7d494d345ba6aba31f7546a16f9963283c05f744 +82c1cfab1f501189ac20147fc4631075dbf1abf9125b7d42fcb4f31cf73f3d6461b1bd08fdf6e45cc54bc08a7d5d51d1 +b978228286f5d4a10ce027b6bea3021affcaa805340ca4b5192c69e8c56db59f48e4a14a284ec015f53baf97389f62b2 +af125f4fdccd1c1b64fdffecb5ec7cf8c7392bbe476e1b89a5b5329c5ba4a526e58c11e72ab9de8a38d60af648d75adc +8411a41ec14295acab0d36389013535a80dfff6e024bffeb32fb3070762f61256419e8c51b2ad6de9dbe4f1e8e286912 +8ea67a91112a41f9c65515cd496f4b0cdefa1400fc06568eef000c9eae6dc250fb7622eb3f2deca10b37287cd96fa463 +8da99b6c55c31dee6a49aabb54da249d348a31d4416201a10c45a3b04b11e99d4ae9813632f0ee36c523b5cca62f6f49 +8b44656341e039e2bd83a19c3bb9a88f6209482e274f8cd4f8557b728e5948dd80b5745f621b96f4562928689314e8c2 +a02d424a615ba0dce8ed91f477e79852215a3a39d025059826fa278e7eebef19824b2a2844f5b3865a0f471b609a23f5 +a1f115cebc3fff3bcf233da27cef19eae791660f155d088003460f75567a550bef0722885010ddc384acdeac635939dc +b61a55ce9d143c17876776e064b58a10baf0ba13553c785c1e47f57b5f94c0cda8bc89d43d73386e57816c15b61a8ec8 +b4073f47041e20a8e548c7fb00e07ba3b9056c34eb4ab63bb0e7b48f8e338e8b56a17611a1b5f4c03b352450b86f1d69 +a7b1a07b213205b682fc5b6acb7e76fdf97b280c26621d8f3b76b7c1deb3511957da33a4e358c8e8f3d98b2a8855d67e +b797e67c2670fbd9844e8a68c585f404b035dc14bd4ec75c3f95f932c777f9db5d5f5df7629164af488fc1213035cc5f +99618200797b945f595794d6468e5c618649554ad9ba896330f1cc844090eb956ae9fc23132912f9047085c5f0c3bf7b +81194aa1319abf534cb3927af9adfb178a99d0e3e8c99ab1105f1d3b4fed40ec2971caf1d6647acb0c8d681eca53097b +80673f18e4978dbc226a6cd4b128a1259d9a7f833879c6e2fbe24d69fef2c3c23a51a4f3e8d88fa4533434bbb0723661 +8125bf6c7dbb2fb63aaa3f53283559f172c788223674adbeb6d5bd17cfe888e6b87a79aec774917f20ce911c1f85f8e7 +884bcdb1878b14fc38adc9fb8b4dd0b3afde404fbeb664f26ddfebc81736018551f23e75ce4cfe4865f610bcd454fbd7 +aec65c8d4be8316e98aa54888af01bc6703a0c5d04b69756ff39a0a947b66817ec59d76afe9f61a25749b5e890f03e02 +aa457aaa1b014a4c5a8992847a187a23321bb43452c98745987d038e3b04046102ae859b7a8e980eea978a39d76a88ef +a9832ee63b08e19123f719bfe2fe742125f32463efa966c7709a98ebfc65277670e9ea1fa2d2d78b96bdc7523b0c4c3e +a87b6b1b7858f96d55064274f29fbde56067064962cf3c3e2ba3110b22ea633bc037a74d23543ce3307a46208855d74f +897cbe4ab68a753020fec732dfcc052c7ed9905342b5a6fe0aa25c631f9ad9b659e0ee75d46f0df6507b6720675ee28c +97c3b5f0d54c1fc45e79445c3ff30458959e406a069f5bbf7979d684195b4fa0406b87c1c008f4075bc9e602ed863152 +921e65d582ea9322ddfad1c855331c3cac81f53c700b96db5305a643c084eb6793094e07944bfd41dc02c3b3cf671530 +8f23ef1aca02a260a3b65d25b110f28d3bafca44727448c8f2d03c5e77eda620c1721b06681bd816ee6027664d76352a +946a89b132ec0795aea9ff9dde7b77e7feafffe6e4a2f093042a7e6c71cd6ab87ce0ca914a1b5fabad4e1f96a795f163 +a01e2de9db33df6511172123ad6f7c64074237471df646b32dd9aff8c15278e2723108e4facaedca97e9f49503f8c792 +99dcdcde45b2ea3f15279936feede5f7d3b63ca4972f335b0559c2fa6f9faabd8127aa892a36deb114357ca906553ed8 +a3f8af37bfcf66b04d1896a4bd5d343f4733d4c3305369ac7e75a08f20f2004c10c642d2c7577f4e5c4d1f2cd851ac3b +b7294d15a3d674a56099f97a1adc9e82c15e90832eaf1722df110fc2abc8634c51515e5ad8522015498a3753b1fa8c49 +b4f27f5062ba7a04ea0048b3025b5e3d5b5d319a9e80310c808a5fb4e8e77b38c10a0f3172cb805cadbcc8bc66d36ec7 +aefe5decee0ae2dc372cc6cf4217daf97c4c908d145f100f0daf1ccdfdf641c78432c2e473e7e4b77dcdf2d4c2bb05f0 +acc84af7648a535ffd218c0cc95c8f7b092418c548815f1bafc286b1fe14f6ccb51b2044db3bff864d0bb70e88604084 +84d8e3dac0df6a22beb03742e1d4af684f139f07e2ea0f7fb27fc2d7d4f1e89b5e89f71af32ff115ed5e6092133535f0 +8ada001e1a03a823c4c056f636e77adc0f9dc08689d28de0d99e0feecab5db13abf37b41ec268dbdb42c75419a046c68 +87dac6c798d1744dff81d8bc3e0e04f3c9bf260e811685ddb9a9a8d6eda73927439b344f9a818d2103fad633de5a4a17 +ad9929a7d8a7d5d5954e48281a87e5c84f67e19110d73296b9989a09c76767a57a8115629239ffb4d99dfdf9c52ef6d9 +81ac7cbeef8ec35a5c3b61cc887080c29e6cd3e08af37e45830d17400dbacfb374dd07bf370b979828c3875b2027d5c6 +97f92c9182953b7e10f7a1bbb6b5b5c40b8275eb5a6eec1e29874c4712814749aa8c409651380216e1ff01d7b8511041 +a09794d0bbe7db013045d3fd857c1544fe6231d21afa3495fa300371f6301a3a0f4b8ea175b281503dd06078ff371ae4 +839bb58d320aa08116dd387a57a2b9bd9efc89c4cdfd82d0e47a00cabe644631d09be5436bd485df3b61b75ddf81a3ef +b1cdaa344f783757e8b9c1f84421da3c5be4c69f019a8fd4c1aa5bf1a63e8970c99e35c22cf3b48a0e6738bc6ba7ce8d +92af68e3216c78998208fb24b5ba0e645d0d3f5e28222b805668d7e9cdd6c033d3b22fd6df4c2d745d7f910d133cd226 +87640a4ea4e605e2204e5232b29a6c1c31152d83547eef14122cb76a0da52b8653801af48455a3ed713b9dcfee7b1ef1 +8147e5bf0c8f4731155ca0517ef3fae5a32b4d5d2d98ed0007b23893d8dbb7f8a1199c50c1750c2fa7c9cebe594b1bb0 +a76b4473c63c3ab6103c729afd2482822e4150f3155af39983b0ff0766c71cb622455ce6304e23853661eaa322219d18 +b3e2f05ca551bc3adec0067e4034aaffd72e0b64ac18ae25452c996927976c6727966e26d213b032521889be2170800d +a8414cd14cb3be658e9e0004ce511ef7063439b1cbc3166a11de030613fde4b59caad4e91d426927863c55382afbf476 +b2f0f8ab99f4d0ea785ac84fdbc00b20217b1df59b30b51d9d209d489d53b69dd5d82cdacc16fd1dd15c3a4001595f50 +8b2025d5fd658c9bbed619f3e3f6ac8efe7aeff8aa9401bd66a7ceb0062c44b353608ca073f95be99204f0a913bb77eb +94a46bc5a87291b42024b2137e623c70115b9c6b196604106bfbfa20f3f56ac7779763f56b580190d3cb2f1c648cada1 +aca9355545118d0769cacf69c4b23d6d68d229cd8f68f1bc0c847c05569c5af6bbbd8c4dceb637b4a6b3b5c83841bf5e +b0731992cab87c7116406b283a84707a34838bfa3284b0f6082dfabeaf41c5ac2b0ddc1b420547a1b0955aee92de2dc0 +b671f77588c0f69f6830a5b28e7d07ed161b81fa9791bb3a24aae6638e3aa5e186df74978a82549c370c18ebee04d4f0 +b5621ed841780f3e6681d880a76cf519cdd20d35197b112eeaa686764d57b5dfa78ffe1a294b6bc76b6e3949cd2a2369 +afeba2524659d00caecf089645611553187a6ed7102050f6dd20f5a19bed08ac7065912d88371ee06242897d58d652a4 +b78bfb83d44ced14a20135804aba3f00128c3ce1f302e95567ce4097b0d973414153fb305b9f156882a5a0554bf25973 +98510aede95d26b1adf214053eae051ffaf24894e2fa37961a91d0ff5392dd09388196648d95b73e90bd88f2587cc4bf +b35c682d49c295946b9f120fbc47b95abd9ee86d294abb003a92139fb825b509209562575015856a270eb3eea86397a7 +b9641bf685571dd9c478dd2033a1f1b11cd3a662b26502c78595863b8e536a189674a9a85f7a253453ebfd1b99fbd841 +b2ad37036a59b1c9b8457972665720a6868422ed8157b6810a9c0783006103be34ab732d7aeb8629653edd18fd0f1717 +af0920cff05179a3896ea6ea322c39adf91ada5bc40fe3f6fb1b1b4e121e907c904bbaa8ca00468b3749f3da144d71f3 +8e269672818ef1e2f9e0c8aa65c84442fcd9151d74bb8e870cee8c0e3fe24526e1a5388b430cef47b67f79b4e4056bcc +aa29a16fe00ea3d143b1032b1dd26b8ce638f37f95c085c7e777e8e2784bd724bd5c38b1583c61a6ec7c451dd78fd3fb +87452b7435911cc5f513b0c81b15aa04972ecbe3d7bbd0a5d676c96a8a311301c0e07fac925c53a350b46fbd3d4d0fc1 +869a81c351096f47748e41566ae7b77a454b1cdfaa41d34a5742f80df38fbf5cbb08924b6fdff58e3b18f05c62bbbbb1 +8b7bc1b0486300981147a40a449ada9a41afc06d735cce8bf0fab3ee94ba2e2ea57b1397e3cd31bc295352beb8334ef7 +93e93fc41adb2df279d95654921b4c2edf0d293dab58d0afefb221f777349ef88d0985b3447e3b935954a81f1580a92c +970fa7cdca8324faf3e62348bb50d78f580b4f43f2e1c11bd8382d48d0074a3c55c6407203a0c9cb1c5f2163ba421ef4 +924983929e608d27e4a36d4ed919297869e3c64de51aca794d32d6e90aea546bf898d98ceca28a0b2187734821b78504 +8d395332529c703d943d68415d443332b5c1342ca9d9a59bfa8bd4ab63e93358c4b0dde6ce1f2e8ea9dc8f52ad7ebd95 +80200dda853e588256599e7f905add5d5ee7c74272780317694fbae39318ae9be05d5bcd7b20cf460069743f3d4ef240 +a287d51d6359c9ef7c7ac1b20e479ce7d0146dba5606397bd04b7a622cec642508d5b45d51b31de71f9763595b6ac88e +a320396c075175d6599225cf2e1de8c7cab549f6316c07feb0f6eaa21f06b2dd29ab14fbdf2af4543b4890ec0fd08a4d +b1e9fe230418d20368691058adcbbe30011bab3000422f0371015ff8bd09c60fb5fa85d18550d35b1c900977ca48f58b +9718fc26a51783b971744933f20490e9b5cd9162f86b84788c4c5217f5409e37b5a39d628b18e5b35a757acf67596321 +a0cf81fdb161f4f1b419c5e4caa36d4bdca2325f0cd25b119a30178016f171bd6fb88403e4e3aec026c4089f180d540e +8ab1e36bd04625ee794ef04c4dcb8e004d61aceb2b62438377f49ad95dcf025ba25eb799280004941e555bf7172af6fe +9257b9e3d14d37fc7efae49b0c68d36eaac546035f4a2654d566b3ce1b2c4564cbb03dc8ec66efceb768559a8a507a18 +945d1123b839637ab5154a1972c3c83a0ff34a3b1a3465de6ef0416b1950f649869a3ef88d7f1036648ee385265ce2df +81449639d708860fc0229c94f754f7262e8a3c7f67960ff12dfd15df95f57a9ffcee2013e81978b7703dd42bd5d0816f +a865481deaae5a690fd53892791e5fa729db283b75a525a11cdfee1ce17e8e7f0b449d25f20b3c1b43da128dbdf98a8b +98766812a65fcd25b853546e3bba618a3edc9fd61510e4f8ab60c038a7fa50d197abeec8776109df0f2119be9445ad00 +b1b8dd5379d903dc41d74e999b1ab693607a0d2905692f4fb96adf08f738e5d31f9d00df28ccb8b5856145ca552c3e3c +99d20be7b511bec78a8ed03c207aa4aa9097ba39d85e18f1b8d52f65431ab7e9a773c7b9ac3e8d8b25458bc91bd00703 +b1b7c3563fe8cb33c7d3e0b89d00bdd13e86452ff507c2e69db7b3af06f247f139155396e9b0278753310dc63940a10b +b3dc9c08451b1de7c9969b1e47574bffff50490f4a16c51e12390195d9e9c72f794790caf7b0a835d64e01fec995d3ac +aaaa4761a00022ede0809d7063d3532b7bfae90ff16f45e17a340ad4ebaa2fbac40728ccc5fbe36a67ab0e707566c5dc +8319a1903314eab01f5442d2aee6ae9c3f6edfda0d9a88b416d0f874d7d1d05d08bb482102f8ca70a4fa34836d0840c1 +932949a6e9edfec344932a74d4f81eec3667ece1e8b8ca840ce07ffd4b5d6d8f01657c764d64ac1b9190f876b136490e +904db1568128487e312fe629dd8bb920cecafd3bb9cad8b63e269ae0129f2f5c80cd82f0d81e7feca9835c3945a72d28 +a17280693d30dcd43c85de8f6b02d5f30cb9097274ad680cede1ef105c903615b4c40f3c6aaca478642de324972514e0 +8d5f76e093aee71d0cdeb017fdfcb13bd068039746de90690ce150a0bfdbe7ddc4d539df0f82c2d2890a40b191900594 +96fa1f2196a3883cdd73c66d28403cbbb58f6a939a3697ee0d308d8a076393cbb4be86255af986869230ee410c01bcfa +a8b74438dc5cabd70a91bf25601af915c4418d074327a9b01e0190c27d3922c89bb9b41e0b366e82e313edda8f21983d +ac9fdc1a9b2e3ff379eb2370979372e13c4177bf4574f1490fadf05a7073e6d61e703e2d8eed9ce984aba317d411e219 +a45a6c9b958169f2f8df70143e6ac3e2f6f969a4eed6fd9f1c620711bc2454739bb69f0094079464790c5429c0d8aedd +8901cbdd1009864386577842c1e3d37835fddf834064d9613b4559ea9aef3084204e1f863c4306f874141f4374f449ff +b6c582161691e3635536686825be9c4d7399d668a7675738417e0363e064dfd28acdbd8dbc9e34c1dab8a1990f1f0eba +89e89ddaf3cacc78428f3168549c161283ca8337345750667c98212717b21e7d994eae4e45bbddacc832a18df1d79276 +84be275627eed8e1a73c7af8a20cee1ef5cc568cfeea7ec323d7f91b44e9653e9aeed47c1896a8240b99dde545f0e1fa +a779a54ab4f40228f6e2539595fb8d509b70aab7c19e1928c1be69ec1dc19285c3898cf15e5f8b8bc725e13af177fe17 +92e2a49d2b9b36349d442283b17d46f8f9bf5932c34223015ce62d2f285e7363b2c12232be4a838b5b6cf08e694c094c +8b4e28c6f3f36caa2cfb82ba88066c830f8017bd35608b077143dff236f3181230166f5a5c02fa0e5272297331726aed +85fd77d46162ffac4b8adb25baff0eb0512a53a3d01638b3a376ea34702279ce21c8e7d8884308c03e00c9bcc1a9fd29 +aad5e46916ff1be29009b595d1d8fa160cc7aa01c7fbf3a68f445c87615790dcab1fcdbdceda533d182b6541f09f2f73 +948df7654726250dae393325addd3c0a20431c81f00470962190335ea4b6d9f7463d6f308cda46b92084c1f24390b1da +8f577474dea132676504376c5542b730b6604fe3d965eaa194659fd11c52233bd0b11ab62e198c0f442327ff1c00e501 +ae2f1001546db3e0c19700adad997cd9f765fe7a51a502cbcd9a2a07a3a5db79c8f603e05cf96d80b688cb6c9b6cd3ae +953b68e5d9561088dd20406ea7fb6894cba33868a38ace38fc30b5813140cb15dd6dd2171befae5b4df2e4a9658889d8 +86c52901655ff11419b084a04da8fc3596eae59d81d3461601c0baff59ba59e3d1dd0b7ce719e741a3e97c013e898579 +b9a72dd5eff73f9912a28b55de073568efb3eb0241a10b77a2bfd4f30c2aa4fbfe0c89eb345c9f07fb725660873cb515 +8e7353f5f2932e4ffd95811caf46c9bd1a53643c27eb41a4ebd211f230955cd71a8b27e17cfe8aa708d8514c0de67a66 +a096b8e66312a92fb10839ebe60189a8d1bd34dff55f7dfae85e4d2f53a1a4a88211c19fc84494f066358ddce82be131 +931c5cd82719d76596832b007969b5f75d65cffabb41b9dac7910300db677c1309abe77eeb9837a68c760bb72013b73a +8ba10f5118d778085122065b55dd1918fddb650cce7854d15a8f0da747da44d7b12d44fc29ad7dc38f174be803db74c6 +8c971deec679372a328587d91fd24ab91043e936ca709c333453d7afd43ee256d08c71cb89f0ab0e89ae119831df6d86 +a2ac28a58034fbd8fd518f409221bad0efec52670880f202e09c0530e2aabc2171ed95e99891790596ffad163d86c110 +b3354e3dfa8068aba4f3741152b9204baa4e342c1cc77e6dd1419cbaf8da1d118be605846b8609e997d6a62a11f3423a +a12ab65a213c9d95c24865fddc2dffe0cf9fc527dd6bcdacc1bd7271e79929a4ab3427a231f4f49d0530474e6cbc88f9 +90afd65b7e6973f8aafbe74da0f42441840d3c93bd69bc1bec8fa56824e7ca97ad1b427c8a85da7d588469bd4ccc50c3 +a09175940c59489bac3d3da3a4091270d9118948cbbdd57f2bcc63fbf45b8010651c801d3e58dccf42733ce1d6b446a3 +a843bbf286e3cecc1fe370ff1bcf5f1001bc2e95b34246625ff50d48ee62343e82fba2d25b8a4bd5f7b5ffe90920efa2 +a3c4d1003219157fdbee2707ce07afa6c2a64ae8e450182c307ed7f070024071f30b12c4b0032960ff913c74e73a9976 +b24af3f68d66f825d06fc3ff94fcccebe28b1a0d4ba29c48d3a3c953b9bf7ae6707f193fef25e2dcbd2b74e483c774f0 +b0f657f7723184ef7d7e4381143f1ac8020d8c6c6f2dcbebb0eaf9870d61a81f2d452596503311e46d1b38f625d4756b +b90091004fc8f6205c51bec68547ac82dba0f5525631e7632cf6efe54eecd9020729fbee6105d1b8012402d3b79c54aa +8e3fa187713c60eb0a416d6900a894cdf81e6b6b69dae0bb64f6287f3c3f030cfa85c665f7aace1eab4937f380b8f728 +879bf0784ccf6725c9cd1ea8c49fde31c91c605de1ea664a33c2ce24c277ee45d20b66309f98d989acb2ff3b77e13101 +af3f3a3ddc4e11abd627d5aef8adffa91c25df5f0c68b4d2b5d51e7d9af3395ba4f6f7ae2325a6672847e1ecc6cad628 +973e667289e796d3a40f072e6fea575a9b371a9997cf8961677f8dd934619ddc47c1a3efe91bae9ef95acb11a8fe6d09 +afa81c5606de82f46b93f4bb6db3fc0670f4e0d1091388b138a66b3827322d95a56168c951c30831d59eeadc227500bd +b83eff77db5b4c18574662942eb36f6261c59f655f8a9c3d3731412d0f257c8e80aacc995c4b2303058a1ba32522a434 +912e5ac9234b9445be8260393ff08e4859a7a385e800b74d1534eeb971f58f74cfb518dfdb89f8705d89fbf721439129 +ab27c8ece4a51d23e22c2e22efa43487c941139b37ea1182e96efb54ca4809d8245eae0ebe8ba94f0ed4457896fe11b1 +a6630585d104a745bc79dba266d9292bbdad346449c8ee8140a5e6e8a6194411df9cdbf3d3ef83468a536d4f052e9335 +8b8c128244da48e7fec641a882d0005a2d05c7138d86a293e6a0a97c76bf632b44767d0ce44663c975e7f9f9679e25e3 +87dbcaca67351a4e7d2297d7cdba4796d12f58857e7ee4abd0645563577ff33544a44cd84e50b3a3b420d6998de9b57c +b859ba43df259d7f8e7fac70bfd7aae546d57a5dc90e107b174a95bf7fd3cf00f740c4434848e69b2a7e6061f66c1ef1 +99d6e20978fefc40c6d310187eb2ad3a39296f189ee122ed64d74f81033c3069d44f7a9d3988a1df635b609603a17272 +99a5ddf3420cc0c92b21f71a805245608d4995ead447d8f73a670d26d33e26920d5f07bfe1f6230bd5f15978055b4253 +b936ac0944d3c5e4b494f48f158000abb37b80b5c763f77fe856398c664b0f1ddbcc0a9a2a672db9278f08b4bafbe2ec +b4af85fbf4040e35a686dd016adec037c99b47cc2e4dfccaf7870ee9e8c97bff30f3035992def2a9d4af323c0b3af8ae +a5ee32b8bd5f8fa9000da4da0bf00565659a43285393d37080b555d0166bde64d87317b2eab2d48a0e7b287caa989be2 +894d4ad58ecb1c9ebc4f5a97407082e56cb7358d7a881ba7da72321c5027498454f2c7fa2bd5f67a4b11d38c7f14344a +965be9eeaa0d450dacc1b1cc2fbf0d5d4b0dd188f2c89aaa9260e7307a2a1eb22db6092fccb662269e9a1abfc547cabb +805893c424aec206260c1c2d2509d2cb9e67ee528bd5179a8417a667aa216a3f318ed118b50d28da18e36c01f0805e3f +972d7040d4963b35260ef0cc37cd01746f1a2a87cedc0dc7b0ee7e838c9e4573784ea743f563b5267eb3905d4fa961ba +8c7156991d4c2e561888feaecf501f721b4174e7d14109e9deeac5a9d748301c07e11fb2b04b09799f0d34ff42cb77d1 +894722ac35af3d507e81d737d21e16c5ba04686f8f004aa75934aae5e17acd3e065b96e229eb011c2f34096f4c62048b +81237937c247c88e8e31e2c72412189fe59c1daf65c5513489d86cf29ee922c0bb08e5f7890f09f4ada7e5262083d266 +8cf62cda2fe0d9a6b42aa2a1c483f4ad26378c7cc2c2d1510a76df7560b07dba8528b33aaacb15f7f20b9d4c7c9f61f6 +aaf0921fb3e1920eee5d0acb59dcc268b42f4b435d60d25d30357edd7dd758d035919691bd15311d85489dfa2e5ee696 +92cec07be2247ef42002ebcaf65ec855611b8e893a5675796f2225f55412201b0bf9f4761924d0c8377b9f131e09e39f +8e514a62ac1e91773d99588415426c97ad63e917c10d762fe06ace5277a5c3bf3730e4b9e5d116f8493b9ab8687b70e3 +83932df2d923a5052468a3ea87f7b55c6a80ede3594046ee4fe233046570921822bc16555b92ba6aeabaef9b1dc0805a +a2b5bfb249de3472113fd3f35bfabf3c21d5609da62a27ea6aab5f309c9068d94bc58ba03efb4ec11be06306d59e60e8 +8106cf3ebe6f0507be8c6e8d137987315fe3689ecb75bb27980f36ba5efac504baccea0e7603549b6d126beccc278804 +a73ee70b6fe8c082443972102c453fc0e386852476cf22224fc0bfe554735c12f96037fbf10922795f4502c4f052b5f4 +932b27e175440169958504f3ed6400e7d6dcd5e716c19dcd0f15c56c04503ed133d5a993e111c016f141e32d68b29886 +96f7ce4595318e0b4a6b368f788ff82226aac676aed4ace343867f751de414453a9aaaabef6e6224ce5aedc3d5cf77c4 +a950c1e3bc9a14484997013d44d876374b939af437ae7c821c131fb886063ee9fe7214a25a0c7084f0b07b99412eff75 +a9dba3886ed6855303106a1bdd26010f294218684e1c178afcfea3f37a2f04fd01724a31d82de3449046617e3507a115 +87a2f776b32a6b550cf3ceeaf78db02819be74968d228b1d14e0d74a1cdf994bb500b7abef6619455e98d728701fac5c +8cd887b07e335edc0b27e6a660cebb64d210741395be431d79d570139687b056557159407459799a8197b6079644f666 +b81a61fce00588909c13a90c1caa150f15788786af443ff60ce654b57147601f7e70b95659e01f470334a220b547611b +8aebc51141544c5f3d3b99422250424b9800031a8fdfbf22c430907a3a446fecaa2392105d66d64b1c8e847240da4a6a +90db7dc12baa02f3f86d3edadf9434e2b9318d4f6f0eca08276b765dbb38d8eb0d08be2fe70adf2bf16ceda5db08d3ca +aa1839894152d548cc6ad963de20fb6fcc843bc9af2a2bf967c63626b8ad19e900894d6106265f38f3afccca317c22f0 +848e27b741496988a582515c0c8847b2bfc6a001259396cdeea1e1b1d2828ca3a626693a1bf4adf3a3d7f8b1fa3d75fe +a0aa11754d4ee136ac3ca609b17bcae77758763b2016544ca7921dddedd8aafcc7ad5f2b337c8bf53084eb8e43ea41fb +b8713b7aa1c112178195fdcc9b7024f46e6bc04c4e76c41abe620aa265287809200d98eaed6c9703fa97e81d6964f0ec +8605b5b33309e9ea6823542b85383c496794b8481c577497aaf99ba90496e794dce405be615bf92c7b6361460e6b82e3 +826fa34faa7f83e063a7bf172addfc07badabada59cfc6604fdf481d29085251c0a67a1355b2cbd374e2975934b84cb6 +b45d131082dc16fa53af010d43eefb79200dc23d2f3ee26af95ac6a5cebc49c84a9ed293e534ed16ff3ef9a4a25456ec +91bd6ce3c5396a7a0de489e49f0cdf6dce1cd2d0be7a410326423c3185bd1125ce1e610768be7f15f4e44b62f8834fc3 +903ffbe3d33fbf106c01c727dc3a385201a67ded70d4df623934882f69a3a96c909b027a124f3d70cb072b0046a149e8 +b405359db9d9ef4821a181b440ef2918c240595141d861d19a85867a5afa74d2972d22c988775eab441e734700bae4a3 +8abb756d027233c83751910a832b0ef4d28d100077f1c5d656720c94906f91d85dd0ea94b1cc0ed95b692efee14c786e +a78ee77ab476a41a3454160ba7ca4085d8b1f7057c63e76db8b07cf20afdeddd2250cd00771a6329133bb4ad48ccc20a +a41810271d8c37197aa9b3dfcefe3498e42f5978d3f3d59defff4676d6402d8575b40683834f184f143b6cfbfc859b3a +90c24a0750242660bcc6d487358a3cc015730538a0a8beb00ad5ac2ef33cb8ca8a62121e50bec8f3d2f43900f8e3134a +8b96c39695d864ef5796941754978a1fd612b369f6b77fe5ae6587beac936ee28190af8f0a3822b63060af35e49a5c8b +acde2548883d0e63c0fc257bb9dadd919aba60a985b69ebcfa1bca78acca42fc1322ec30bcc8e7c188818f858d04ad33 +895c86ae9ff8d95f2707d4838a3bc8ddb05b2611f0476f014b9c150d0e8332bc73285037a747426f09ac8179ba4e19fc +821761fe406e18bd86fa9ca9db99d382cd3b5c70c456f471fa3706d57763d147706304c75d54f51ce8f3115aa26e59d9 +a803a80e3e8f47dc3c59ea23eafdec017458eac648b360cd42cbd075e0dde6f6f450b48c7646fb1e178c04f82ae51a12 +91f40e1b6f588bd592829ce937996452c40be0fd6c43793c607866701ac6a8c7227e0891d45c6e7b1599382b0a3fbdbb +9408246d996a634a58689337f2526dfb3ba9ffef1d3ff91c32aa8cbbed900861ef25d6477308b67d76491edfcc70d65e +a492325a427f3df1c9c690c5b553daa8ac41f62f5ae55f425539222bacf959e2f67afabbba1732e120d3e7a6dcdf7049 +8fd0c3e15477cae228613a171b6e9ec29ddc63ef74854d99b638adeffe39f89f34346a42851e8445e855a9f2bbef0f57 +b735ed01fafa051004dbaad5e8c9e2faca8f6049ef9b590f256ea4d75b04594af12764ad4e6031735eae36f83179db93 +a7d35f43fca06c86b3425dcb68a87186834ba9740664fd657915771beca4cdc0fa2fc9b4c2e9d9bdad8ec33543ddfa59 +a1156e71e2db1b17df5da28747c88e091bd687bfee59d89096437ab4dc9a543fe5c5272d5023d72adbaab397a6fc94d1 +ab06a58bd81b33a411bade8d8c5232d38fadc2e38507159edea6e2e104b8ebd65ca02b05335118f691d44197b847a4dd +848b67a10f1e6ff8f5c228f226ef2ffeb67fb8f50925fc94cbb588d61896d9dc79726959e649898fd3354fe3ff7b7ee3 +aa933397361f32b388edcf832f0db172a38e756b34d5f7a4a050fa7325058006c22cede26ee27917e8f1b0f301792bd7 +89e49e7f02cfaae4a4b9c4180c9f6559d76e3a45774955859d4147970b1470dac37bdc9aedca1c32a20b045049161590 +adc1825d5ab94fc719f25d8c9773f4d518134ed88eb13ac33cb910b2be3523ef9ef88d9e4aea2418b806e20108317bf6 +96c4b444c8a023da644f3a343ebeeed19a8392d2ce175992461451c318a54273b76c3574d8f2dceda2947ddd34d1a674 +8aa7e97e87c8c5b29bbd51a6d30396a6be1fb82b716ef83800f2c36d5b85467ade7e0f59d2db82c310fa92a9265f0b03 +9146c32d99f02c3a6f764dcd9b4807f1585f528ac69dc4f84e4380f6fda4f9d5057c375671d51e7aca2b2b4140e83da0 +a10760a533d9bc57536bcaf65f080302086aa50225437efd64e176841544711828c23a15c49c0dd1f357d3f10722ab72 +acb0811777e17f7ae7aaba5f6fce81b759c067a4908730916195a2505c7450d0e6e2194c2ef0f241090597d58e70de47 +b24f161e9bcdbad56665e2490b5e4c7768390d4668cd69a04ed74739062dbe832636dd33cda89e9b0afa8c77e93fc641 +96b4d01106b831868a88ef016500ef2fa42d0ce87a37ca8ca4194a92a22c113edfe04eb2ca037329f3c1acc635148f55 +aebbb95fb4f7adcc8e7a217aeb73f9e037cbb873d08c1cd9d68c6c6834511adf1af8b44567fee84327599bdcb734dedb +a9bd8b17300532fb94d028659bcafbe7bbdf32f8945baf5db4cfaa1bac09e57c94cad0ba046b4514044b8fe81ea8596d +a5557cbda599857c512533e7cadcf27bf8444daa0602aa7499cafc1cf1cf21f9d16429915db7485f0e9a1b5046cf01c5 +8810307c40bc661c478a9747ebf2a30e5a5ead942d1ac0418db36ba5db0709c476f7d19685cabe6959e33ec1f3bff914 +8829b741f41f2c32e10b252d9338deb486dba2f23996a44cf1dd888ad967a589d51329be34d764139f372a1043f6c2e5 +a6b4728d18857c5fa082fa67bfb3b1d801e76b251b1e211a19c87cea5fe7ce757f943c85071f7a03a718388cd5690e95 +86da7f397e2533cd487f962ae58e87bea2cd50af70ef2df9ea0f29f70b5843cde664d30ec207ab84fc817f3851277e02 +8085776ef4ac6d42ab85b9d9135ecc6380720efd274f966544eeedf4684028197de76ecab919fa5414302597e1962bca +b05a065c733033d223ba13d16baa7a97bd8c8b8b1f0e59a9bdd36ee17e9922d48eb39bd180c168b122088a77f0bf321a +a89343fe44a93023dcc7ef71bd3bcb6786f68e1885ad260edc56a52445d34757f476395ba7ad35437f89bc573c7618dc +a114a9cd6105b524f3969c69faa2e09afe21753a93361a296f9e0e3b4e3e63726ddf2e6bfd3ddc046043e50bd44e539e +8a5611fec539cf681c05636bb580f29acc06f628bb012649ffa41ea6c1521194a5643d5dd843f09b6eb2c3bdb4d41acd +ade247c4011ec73ec90b72f35afa59a999e64ba5a7e664a4b30874fea53ba6a14a76a41b58a5f891a20d019e5f091bdb +905b5d96df388160ade1ffe210d0c6d1979081bc3de3b8d93ac0d677cc2fc2dc1ef6dcd49d3947055514292a3fa2932e +a9520796ca9fccd11b7524d866507f731f0f88976f0de04286e68d7cf6dbd192d0d269f0cd60fd3d34011a9fe9e144c2 +989a1edf4d7dae811eb57a865c8e64297837ffeeaae6ee6ac3af0f1044f023f1ca552bf00f1642491f0f0f20e820632e +879c8e63713f4935ed6e020559e140ea3073ced79d3096c152c430141272117b4fd9a9fc3eef012e81262df02ea14bd7 +95074738ac1540c0312274333acd1ecad9c5509fee883c4d9295fa8d8200f6e637c363de395f9fa612f05c0dc58fae88 +a770e4fc595269eb806b113ab3187ea75c8f96b57bf9fcfaf535f3eedc1d4d7e6285a20990575de0ff09f62d06ed0692 +81283e5dfb6423439ff513eca1cc316941d196df8da2d1069d2d0b63f5289e630af2fd4119bc0144c002d33313372dab +abd1b108e743887b78f698f2aba9d5492f87a22868d1351d705d93a1084fd45be67170c68a6e18b07f400d9a01cda8c2 +8509c3f67b92908cea8144f4e2a71631a66a61ac3547601c788907e52e380e5fe8ae4110aed95d13c67d3bcdd5b55a61 +8fa5a790ec5cce6d4114128c295390120869aac5490a82feebd3c37a167120df2e7fdfaf2a4050a7dfebf48fb093212f +944753e1ea7d8bc727d46a7702077dc01dc0c6574e8263a16579b57ee155ca5901f71bb347a01a9a922b329d3ff75135 +b46bc1fd4590b7a6275e20036d247c5909fc549c78e95b64ae7ed96e3b05bb044840f19f7650ebfe7008ba09fa83c3c9 +b1e47e4d88e59a06c465348c6cc4181d40f45b91e5e883966d370c26622c328415c6144aa2f61ddb88ec752482c550ca +8bd4f8e293e3f1815c7e67167618fb3b0ea76424bc0985908957cfcede36109378e41b4d89555b8c2541b4c447e00461 +a70589a867b2bfb63d0106083d58475d506637148549ed35c83f14e5c8de996e1b1f3447ecc80cf5cd134ef4db9d2fb6 +8048b80ba6131d07370162724127b0f7cb17fa7f71855e55e5a75bd0a9e4fd71b0d0ea2d16ec98858e458528df8d06b5 +97326cb94bae7530f4ec3235770c5a7ba042759e789d91c31fedbd979e3c0e6a2c69e2af3c1979c6fe0094274dbd53ce +a18e9c1d3eabd62af4e31a4b8e08494f4167fd4598c95d0123f39c46c53f9e93f76615900246e81a286c782ac37c569f +80309c59d4522b15aba617cd3c6238663e8b1c7ad84456346082c8f281140fc0edf9caa19de411c7e7fb809ca4fa3f4d +8e450c0990e2f65923f252311623038899eeff7b5c2da85b3a224e0ef7132588b291b782d53c477ecb70f34501466178 +87843f96f41484e254e754c681a65681b9ae5c96c292140368743df9e60f7e2ada58ca2bb95fa39abe064b2ebf21eeba +858e8d5bf2a1cf26d8af5036b28b831d450a446026f58a1734b696c18f1f41482796b91cab0e5b443dd2f0b9cffa52b4 +99627dd6bad8c05c5904cd23aa667d664da846496dbbb8452705c4ec01e1480e9c7295504a5a8529e4a0c842306b038d +b64b33256c18b2c886a837a0c0730fdfe73befb0e2796207c4dc592c5a33cd51f8c2ef47c584dd5773abf9ce9c1b0082 +944f6da2a1546f0bfc4d98c3e73c79e935e33d208b6be26b0b5f8df6d0e3b74a5bda649853b99281bd3a3ec799a7dd04 +a266d165435784d4e884640155e35b2a911b3f89e1e715986de419b166a36a341ba724877d80583fa3da566f6a828971 +adff2698409d0756e78c534032ee926560c13d578cb178d5073172d049ebbce32a92692f7e2033ec781b9b0d894ddce0 +a91933f110756c699c28bf9e24fd405bf432002a28c4349e0ca995528e56a5a2d101b8d78afa90a178ff1a9bf2ba515c +8e77839c0eb4da2d01e4053912cd823eddffbdc6b9c42199fba707ca6ab49fc324288b57be959fbfb11d59085d49324a +aa124517c76692036c737e987f27c2660514e12a953e63ff4bcb269dd18fc44dae95e282de8444bed09639ef6577af88 +b285deae99688f1bd80f338772472fa2b35e68887c7eb52c4ef30fc733812444c5cd110050275ad999d5a9b57f782911 +8877b0fa85b44ef31f50bdb70b879fa6df5eb1940e2b304fd0c8f08abb65f3118fa3d97ff93919038c1e452fb1160334 +8a89f3b50dcbca655024542ca7d93df17deff5c7d01c7da2bdb69e76b3e0b4490d85c800fb3debb4b0b4d20c9527f7ad +b7e5dbe36e985354ac2f4ab7730fea01b850af00767a6c4d8ee72e884d0fe539bb81f2e34638fcf5d07b7c8d605f4c06 +a85a1d78f6d4f9d5d83ec0f2a426708342d4e4a5d15625554e8452f6a843d9aa4db0c7e68caebdaf767c5b3a6a6b2124 +a518078a9dac63c5bf511b21ed8e50d1ccede27ebfe9d240937be813f5ee56aef93dc3bf7c08606be1e6172f13f352ce +91144eedebda4d1ad801654ef4ecd46683489b177ba1de7259f7dd8242c8c1700e15938e06c5d29aa69f4660564209a0 +a16c4657bc29d1d3271f507847b5a4f6401cee4ad35583ad6b7a68e6c2b9b462d77b5dd359fd88ea91ce93bb99130173 +85b855778f4b506880a2833b8468871c700440a87112fa6a83fd3ddb7e294b3a232d045dc37dfc7100b36f910d93c2ae +8d86bb149d31bfbf1fabcae1b8183d19087fd601c3826a72a95d2f9cedb8bb0203d1136a754aa2dd61f84b7f515acfa9 +acfe7264eee24e14e9f95251cbcfdd7e7f7112955a1972058444df3c2d2a1070627baefada3574ebd39600f7f2ea7595 +906bd14ecca20ac4ae44bff77cc94eb5a4ecc61eba130de9838e066e8766ed3b58705f32c650e1e222b3100691b3806b +8f2cbc7b8593c4be941dd01b80dc406fe9dfdf813ef87df911763f644f6309d659ea9e3830ff9155e21b195fc3c01c57 +a68eb15ed78fae0060c6d20852db78f31bebb59d4ddc3c5bdd9a38dbe4efa99141b311473033ff8f8ea23af219bc8125 +a95cb76c9d23fc478c7e8a73161f2ff409c1e28a2624c7d5e026e3cee9e488f22225a0c5907264545a73e83260e3a4ec +b76f90e55fa37c9e2732fd6eba890dd9f1958c1a3e990bd0ce26055e22fe422d6f0bcc57a8a9890585717f0479180905 +b80cc95f365fabd9602ec370ca67aa4fb1219a46e44adf039d63c432e786835bb6b80756b38f80d0864ecb80e4acb453 +b753c86c82d98a5b04e89de8d005f513f5ea5ea5cf281a561d881ed9ad9d9a4be5febb6438e0dba3d377a7509d839df0 +a664733f3b902fac4d1a65ea0d479bb2b54a4f0e2140ed258570da2e5907746e2ac173ace9120d8de4a5e29657ae6e05 +9479722da1a53446e2559bb0e70c4e5bf3f86c0ce478eede6f686db23be97fcd496f00a9e174ceb89ab27f80621f9b80 +b707fd21b75a8d244d8d578f3302d1b32bb2d09f2bd5247dff638d8b8b678c87d4feab83fe275c5553720a059d403836 +93214c16831c6e1d6e5a1266f09f435bbed5030c3c4c96794b38d4a70871782002e558d960778e4465b1ff296ffedad8 +8648f84e18eb63dad624e5fa0e7a28af2ee6d47c28f191be0918c412bf24b5460c04bf2b7a127c472914a0741843f78b +b67f61e75d6b773a6b58b847d87084b94f3cdac3daa7bef75c2238903a84250355a986b158ff96ba276ca13a6035fdd6 +ae9b094b7b5359ee4239d0858d3755a51aba19fce8ad82b0936cca48017523319c3309409ea6e9883a41bece2077e4d8 +8d1d8e1fba8cebd7a0e1effea785a35e16b1a10842f43e2b161d75add11eccf8f942d2ae91c20eef6c1a0c813731ea9a +b82bd387458e3603782d5e2dec32ae03890a3fc156d7138d953f98eff4200de27c224f626e3648e80cd3dfc684c4790f +a6dd02a89ad1c84e25e91176c26355e21a01b126c1df4d22546159dab9d502dbc69bc0d793a017c1456516e4aa5fa53f +a9ab74a5c5459b8500beb0ad13e9cfe2656e966dc9b4f3f98bec7588023b4ddebf74e4fc722d30423f639f4ee1b2587f +b03e5f33ab7ecec12cbc547038d3fa4f7ea0437e571891c39660c38d148212d191be29e04eb2dc001b674219b7a15a9c +925df4fc6e898ca55090ad1a8f756cc5014167a042affda5b24896eeb6aac408545134920586a8e1a2b997de9758b78a +98c8580fb56ed329fad9665bdf5b1676934ddfb701a339cc52c2c051e006f8202e1b2b0f5de01127c2cacf3b84deb384 +afc3765d374c60fac209abd976fe2c6f03ce5cc5c392f664bb8fac01be6d5a6e6251ac5fb54cfcd73e3b2db6af587cbb +8e7e98fb5a0b5b50d1a64a411f216c6738baaca97e06d1eba1c561e5c52809b9dab1da9f378b5f7d56a01af077e4f8cf +b724bf90309651afb2c5babaa62dc6eac2b8a565701520fe0508cee937f4f7b6f483fc164b15d4be4e29414ce5d3c7d4 +9665160e7bf73c94f956ecb8ba8c46fe43ae55c354ce36da40ccc7594beae21d48d9c34d1af15228c42d062a84353a0c +8600ab3aa86b408ee6e477c55572573ed8cfb23689bbdadf9fccb00161b921ec66427d9988763a7009b823fa79f8a187 +b0d8d19fd1022e7bc628d456b9bd1a2584dce504eb0bf0802bdb1abd7a069abbeeccdb97ce688f3f84a229342dbc1c33 +8f447d5e5a65bb4b717d6939cbd06485b1d9870fe43d12f2da93ca3bb636133a96e49f46d2658b6c59f0436d4eede857 +b94e327d408d8553a54e263f6daa5f150f9067364ded7406dcb5c32db3c2dffd81d466ee65378db78d1c90bc20b08ab3 +b58c02781b74ef6f57f9d0714a96161d6bfa04aa758473fb4d67cc02094cd0c0f29d0527c37679a62b98771420cf638b +8cfa0a687ea51561713e928271c43324b938aa11bb90f7ffaa0e4a779b3e98899f2af59364ce67b73a46a88748c76efa +95d6d39c814c5362df69116558d81ce6f1c65fb400fc62de037f670d85f23f392c1451d43341c59bc342bc31842c8582 +af888b384c52d9e04e4db6c4e507c2037eb5857e9bcc33acf84fc3a02d93cbde8cce32141fce9f5fec715b5f24d56356 +a7822bbc3c236fd58bd978f0fc15fe0b60933a0c953db6436a233441219418090ae0c07c490a6548e319029771cdaba7 +8c53729f750922e5eb461774be8851a3f40fe42eed170881cc8024d590bf0a161d861f5c967144d15cdcdc3dc6b5cf88 +a052a25a4aeab0d5bb79bc92a6ae14b5ad07d1baca73f4f6684ccecfc7ea69bc21eadeb9510452fdba116c0502dd698f +923946b83d37f60555dbac99f141f5a232728c6eb819a37e568c8c6e4d9e97a4229fb75d1de7e9d81f3356f69e6d36f1 +8cab82cf7e415b64a63bd272fe514d8b1fa03ba29852ec8ef04e9c73d02a2b0d12092a8937756fdec02d27c8080fb125 +b1123314852495e8d2789260e7b3c6f3e38cb068a47bdf54ed05f963258d8bcabaa36ccbea095ba008e07a2678ec85a7 +a685b779514961e2652155af805996ceb15fb45c7af89c5896f161cac18e07b78c9776047c95b196362c9ad5430bcb22 +b734dd88f6cc6329c1cb0316c08ade03369a11dc33191086c6a177cf24540c7ceee8199b7afa86c344d78d513f828e81 +b0bf492fb136ecdb602c37636ed4deef44560ab752c0af5080a79c9f76a1f954eba60a0bf6ba8bd7b8cac21848c29741 +a5c74682323e85ac20f912ab9c1d6e1b9246c4c829dca40c8a7d58ec07ea0ad3524be30623f351269552f49b65a1245c +837403b9cf830fb33ecc11a7c8433e07745973c36acdeb3fc9ea8f7d8d690d462e1250b7410f79f2f4180fe8f3962a4f +b03d64b944d49c83608f2c5b9c14070c025f7568c4c33d4eeb1da31d07f0bc5897e498b35b50d557ee129f0c3c68e254 +827272aab8bf757e2483156e00fbebe1093a58070dd3af9855bbf946c7abfb9c8a850a6a8acda8c620902f391f968b8f +84c4eb863a865282d321302d06b362f8bd11c2bb0090f90ebffedd3eb3e7af704cff00d39a6d48cbea4262942e95200b +b044eb91653dc55dce75c8d636308a5a0dae1298de4382d318e934140a21ca90e8a210e06fdf93aadbbeab1c2ef3904a +a8c08955a4378522e09a351ecb21b54025a90f2936b974068e80862803e7da2b5380c4b83b4b4aad0409df8d6c8cc0cb +a763a5fb32bd6cb7d7c6199041f429782deacac22b6a8467077fab68824dd69343ebca63a11004c637b9cb3129dbf493 +8c44c8afa9a623f05c2e2aba12e381abdb6753bb494da81f238452f24c758c0a0d517982f3999d2537b7279d381625ed +8613f47fda577cd3bda7c99b80cf4b2dd40699edfd3df78acb5e456dd41fd0773bc8da6c5e8cbf726a519b9fb7646ccc +b21a30d49d7e1c52068482b837a4475568d0923d38e813cea429c1000b5f79b8905b08f6db237e2eccf7ef3e29848162 +b9bdf4915f3fbb8d84cdfd0deedf2c9dc5b14f52bf299ef5dca2f816988e66322df078da2c54b934b69728fd3bef40b5 +993b45f389f55eba8e5ba1042d9a87242c383a066cbf19bc871b090abe04de9ff6c1438cb091875d21b8c10fac51db58 +a85a95d14633d52d499727f3939979a498c154fd7ebb444b08f637b32c1caf5cca5e933a2f5d94f26851ae162707b77d +b9874c7c4be1c88a9646e0c2f467cd76bc21765b5ab85d551305f5ec0b4419e39d90703d4ac1bb01feb3b160517e97b7 +ad6771177fc78812904c90594712956357de1533a07fec3082ba707f19c5866596d624efc3e11773b3100547d8f6c202 +a79f31921134f7197f79c43a4b5d5b86736a8d3ad5af1bdf4ad8789c2bfe1c905199c5e9f21e9f446247224f82b334f8 +a7f1b6c45321222a350a86543162c6e4e3d2a7c2dce41aeb94c42c02418f0892dbd70c31700245d78c4d125163b2cd5e +92abafe3ec9dbe55c193fb69042500067eb8f776e9bf0f1cb5ab8eb12e3d34986d1204136856fb115c12784c3b8dea6e +89bc761238a4d989006ca5af5303c910c584fe7e6f22aa9f65f0718a1bc171e452c43695e9f5a591725e870770c0eceb +aa0e44c2b006a27d35e8087779411ba2f9f1966a0f5646ff6871bcf63a8b1a4a7638751b94c9b9798ccd491c940bc53f +8736fe82862b8106e7fdab7b5a964d87ec291a74b8eb1cb5a6c046a648c1b686064ef3d52297043b8940bfe870c712f8 +956a3def1942f05144d8e9c3a82fd2d3610064b53b9eefde3d5594a8f705bf8f6849eb2c22181796beffeba43cc74ee4 +af27416d00cf97d5a1f4a1b6b51c010884cceca294f1151c3b684a3f83c3c8a3c30771df1166d833cbddf6c873c400c3 +aac3b8dca2336fc4ffc63c362df461289e4bbd3418c621bde6c581d3ecedf66e2b3e523d4db39e3d8ba014577bf85efd +94c3a8167f62074e5b28c2bffe4b6ce645439a9a0c5da3ca1b3ee956590a465d6f84a8a4dbbe9070ffbd6bbc734e4d62 +95e23ba6986d25ed4451215da05bd72c5491528271726d79a94c8cb16aef1c85b190d6c5b8a3a1191c7cafbab1dccf0c +953e3dadb5ad68f7de31ac09692948655d174fe16d88b96930ef35b331da7f1dbc4c17863cd07b4ec3135b5205891a27 +915d018f18b5d63cb3301c2bb5c6e85e75a88ba80663c964d06575b6bacbbe59139d030b218ce0998271d5b28c00b26d +8c871ba3dd138a908b2f7effeea0e71df096b23e0dd47cab10b9762b250abfd1221da94a8ee884e05bdf02271fb85a04 +96bad5c6ebc3080ecbe337409ae398bbeada651221c42a43ea3b7c08c21841ddbcfde544c9b8d4772de6f2ce92c0b963 +b5dbcd0b1c44c62108841558ec0a48df4b327a741e208c38b1c052321eda6e6ad01af71d49dfcdd445ab6fa6f0c34e6d +97dba59219b69e8aef2659d1f10bbea98d74aefff1f6451de3f41be39acbac0122b8ff58b02e90554469e88911ec3547 +b7e5682ec306478be4858296f5d03364a61f3260636a4242f984d351a02e8723378496beb30c4ca22def9c9ca193ea70 +9656a7a3df4d11df3d8bc35930dff70a5e78a488ca57bba20bb06814fc390fc6c7cb3f39b22134992aad196cced577de +8b269695aa63eb56d0324ba984279dc4c88e565321f1d61d553622bd4f1910d5eff68393d3a830eb924472bd478c2aa3 +9177bcd04b28c87bc0440268b4c8995c6790cad6039594971b2c177f0e197055231e776927d3fa30d98fb897a2ba401f +ae0e943973482001c4f214b9da82e1c27e38aa254d0555e016095c537c835d3702bc2de5c67b234ab151e02b3b7a43a6 +82fc719a7d38bf4787fe1888019ad89fbf29beb951d2fece8686d2beb9119d0c8c6d13bc598748c72c70d73d488140ca +b716dc66f87eb16b95df8066877353962d91bf98cf7346a7f27056c2a4956fb65e55cb512af278783887ab269e91cd76 +81d58cd8bc6657362d724b966321cd29a1b5cdc4601a49fa06e07e1ad13b05e9f387ca4f053ed42396c508cd065c5219 +b32ad0280df6651c27bb6ddbdc61d5eb8246722140a2e29c02b8b52127de57a970e1ded5c2a67f9491ae9667349f4c46 +b68a2eb64cc43f423be8985b1a068e3814b0d6217837fb8fbfd9c786db9cca91885c86899c50a1242040b53bf304ced9 +85887515d4e371eabb81194cbc070e0c422179e01dbda050b359bd5870449c7950e6b3947b7a4a0eb68199341cc89fc3 +ac5fff3c27dfbab78eb8aad37ac31cc747a82401ebf3644a4f4f5aa98d37b8bf3b3f4bd8a3428b32a127c25c9e19d239 +86fceaa6fbf8913553a9e1e907fcb1f1986d5e401a7eafd353beefd1899d571454fea96ff5b2a21254d9fb693ec94951 +b6778bb296d3f0de2531b67d36fdbfa21475be0ca48b9dfcc38f396c41b557823735ed0b583e525a2bae1fe06e04058c +898088babeb5b9866537d6489f7514524c118704abd66b54210dc40a1c1ddb0a1edf7fe0b6e0db53b836f1828ecf939e +b27854364b97274765f0fb8d1f80d3660d469785d1b68da05e2bd1e4b8cbbe04304804d4c8aabb44cf030eba6c496510 +8c55bbf3603dc11cb78b6395ccbc01e08afcef13611f7c52956b7a65ccf9c70551bff3ae274367200be9fc2d5cb26506 +947726f73cd6281cd448d94f21d3b91b96de7ad3ff039f9153befbb5f172db9f53cacb4f88c80a3db26e6a0f7a846eb0 +a7b733a05e97528812d71cecb4f638a90d51acf6b8fcbc054787d6deb7e2595b7b8d1cbe1aa09d78375b5e684a2019bc +8d5ca6d161341461544c533314fe0a6655cde032c2d96f0e4ea7e41098b8b39fa075d38e2d8c74e2d0308f250d6cf353 +b960e9f081393e2260b41f988935285586a26657a3d00b0692ea85420373b9f279b2f1bb2da2caae72dd2e314045f1bd +852a49c7388c10821b387c6d51617add97ba72485f52be95d347bac44c638c92e9c6a44ba0d32afc4d59178a497d944a +8412162a65147e1334ad5af512982b2b48eef565682b3f3e0bbe93fbc5e1103db9375a0c486bdb1b2c57e4cb3a8e7851 +8f52c3eb5d4f1e1e82cfd2b291d4910195427603b796f6c311deb35ef14a01a57a9e6cad39619ad108f3e86f384f9e1c +88d221088f2bf0103c53e44d0d96cd7881ec2b0a965db9121a47481771a8b796edd5ac23c4f9c208a171dab301f7d3bb +b49c3235e8b3617ed08a1891b9e2bcb33dbdacceb94ca96330555b7e00904fe6a749ced9312b8634f88bcb4e76f91cb1 +a85834215e32f284d6dfb0cbfd97f6cffc7b9d354e8f8126d54598bb42d7f858a2b914cf84fa664069632db2ff89a332 +aa3d48eb483c6120c27d9b3e3d0178c1c942632ff54b69f5b3cfbc6ad4ff5b2b9ce6eb771fd1eea8edf4a74c97027265 +a446cfded353cdd9487783b45846402b973cdeddf87e2bf10cf4661610fff35743cc25e8d3b5771dcedfb46b018a5d18 +80998377b3b393ef3073f1a655ad9d1e34980750e9a5cfb95f53a221b053ddb4d6985747217e9c920735b0c851d7551f +a35ac469790fac6b8b07b486f36d0c02421a5f74ea2f0a20ffc5da8b622ac45dfccabfb737efa6e1689b4bd908234536 +8fb1f6d8e9c463b16ac1d0f36e04544320d5a482dd6ffaec90ea0f02b4611aaca984828bf67f84dcc3506b69af0a00a1 +b6e818d61aea62c5ed39c0a22ccbb327178feebdabda0c9927aa1549d2c5bb0637785c4aed2a6d9a7b4989fa8634c64a +b4e7208d16018bf67caafe996d436113eac619732e3f529a6efb7e6f094d8ebea55b7be0e122be075770f5957b6ea6f0 +b691d38b552befac61f6d367287c38d01fec73b7f2efdb6713ca30314a37fb7c177eb111fe6bee657f2681014e07630a +9817587e418e6e7e8e97ae27067f17b55d25dfb14e98f63f530620c855d9a348c9fa571c8508e2741f902f8b9fdc0c5c +b6a6e5ca779ba140bf1d84cd5394ede8262f7479637ec0087a4b152243a1774ba916d8115ce759a3bebd1b409de5f2fc +b53d1c84ad766ff794bf497db3228efd2cc8ed5fc1958d89c1126efdff361610ecb45ea8e329b39035ab00a66c1259c7 +adc31333c507c8e0f4aa2934fcdca57fd9c786722a50dbd5404e129541f7ac182cc7373bf14e1e4e06e6cf94b31b90eb +a82b7fde4642d982d95cec669efee140ad797a2442c7f6620580527d163accbf021b893446cbb8038ea82fe25b15d029 +91f7acf8a8903979afa281646fdecb54aa4d2ed905748e156e92f0910de268fa29d67107d40863935d677d1de8039be2 +86fea71c6d43a7d93216a92fc24dfce8521fd4534a9558b33762d002081247867a6eff54cad7116023277fb4049403ad +8ae5369a7f9f4c91f3be44b98089efd9c97c08f5bb4cd8b3150c115ecd86288fa0865a046a489c782973a111eb93966e +b6fb9e829aa2c81c2d9eac72bb2fd7f3a08e0cd763532c2ce3287444d33cf48b3621f205e9603ec58525934b61a795a9 +83e35ca808d84e41fc92115e9f6e283e928c3a614e6dfc48fe78c33b6411262e7bfa731eadb1e1937bc03cff60032e1d +832fca5196c95098ad47b7d24ba2f9d042e1c73ad2273edd1c2ce36386796ccc26e8567847697f3fcc2a0536a2a2087a +8fdb7038bc8f462ab2b76bf7053362f9c030019f1b6105cf42219a4e620ecc961e3eacb16a8e581a562a97f1418b0128 +8d3a5a404b51b1ad8ce3b23970e0d5cc57b573922341008e3a952a1dd24a135e19e55b79d86a70cfd82e1c0e9630f874 +ba00c025c1c21c57c03cdfc0bfd094b35422281ff0a64b68b240617aa58c6b18800af5f2047d3ff9068bbe987d6c7980 +b468f0dd51964b3806b0aa04f3fe28a035e8f5567fc7d27555be33d02701a838b8dbfe1348b6422c4eac46d2c75c40c7 +8a73a18c97da9958903c38584b08d0e7e26993a5d9b068a5e0e1ee0d8a873942745cf795f94f7a3d3ba88790a9fbb2f6 +953a0a40c2c8102723736854d13b228698c14a02d85c8d2e61db1a768019ac305faf0d5db62ac976430ce087a5b20f1e +8998219da6b34f657cb8a621c890a52cb98c2bc0f26f26e2af666eebeadadc5e8bdf4f830a91d04aca8ce186190152c8 +8941e08c3155ad432236ed05460420a05dd0aaab30477493ffb364b14c00ea5b9183d30d3442b6321d2d20c36e4f5c7e +93f293ff7fb56cf5b03aee6f3ad2ad78444398ed5b3be56d7bf5b56b5aa5a2b980d13895dd57a5726d1b067c20cc55e2 +84a16f313e3f75e31824f58d19ab24c6611fb4c75140a7cadc3c166f68819547c1d0ff7f7d13f5d8ae30dff1d80e2aa4 +b6e3e830b15039d3e28b08f5465bb089eade11ee3bd80afe39e010df7db1fcf0c56d698717677a41ddbc91eeaf6544d3 +95e928e6dfff51351281568ae72da7d1edeb6e9fe01f30af0499e7505ba35a22b5bb919d41bb809a432dce83f3977663 +aabeeb60ca46f9b0232ff82ea7766dcab8cc5aaf9d23539f30174f9486640bc9312868ca493b59b314519fc399973e47 +b393a11e957d0bbb3ecf617b075b5906a3450b348e62916c04791b366f0a7397cccd6648440ac544bc30526e1f95aad8 +abb5bfc3964a6d246da60bd809d0ea6daf4f8222efdc12ceb6730194e85f413ee7eb03bae300abf7ea900dbbc3d08971 +96c1bd1d1d216a4bfbcf000c123f296c0d31e1684e9e3884c14df23bf528c8d599f82bb98fcea491716b617216a8e0be +92d1e570a56f1741fd9f3d9f488cc336421c6256c14a08d340a63720be49b0029e3780e3e193a2e22bf66cc652fa22a3 +8769c08551e3a730e46f8e5d0db9cf38e565a001dfb50db3c30fa7fa0e98b19438edc23c6e03c8c144581b720d7b33a4 +b850bd67fdf5d77d9288680b2f6b3bc0f210580447fb6c404eb01139a43fccb7ed20051999ae2323ea5a58de9676bfb4 +80285da7a0aaf72c4528a137182d89a4db22a446e6c4a488cf3411937f4e83f7b00ec7549b0b4417682e283f91225dfe +80520368a80b97d80feb09dbc6908096c40ff7120f415702c1614d7112b0b57f6729581c71f4a3ce794ac959a46494ff +9817b4c27a490b1cd5a6337e7bc7e8005fa075dd980c6bf075ddfa46cd51cc307ad1d9f24e613b762a20fc6c877eab41 +ad66bda1a3034ec5e420b78107896ecf36126ce3ef9705163db259072dfa438c6107717a33572272062b9f60cb89557c +876114ef078c2915288e29c9abe6b0ad6a756b5ee2930ba1b8a17257f3f0557602d1225e8aa41ce8606af71ada2a971b +aa3d6cde4c3b9d3d5d0c77a33e67f182a3e1cf89b0921423b2024236171955b34afc52b1f25b1dad9da9b001371771d7 +984d3e3a72412d290e3459339757af7520d1739c7af0cbcf659c71999328db44f407d92e8a69fea11625612c49eac927 +ae890d0faf5bd3280dcad20a5f90e23a206661be8842375fea2ab22aadc500849ffbc52fe743b376d46bb926cedae6a6 +b1f231f3f4d710c3fe80099faeb56dac67c1baf53b8fe67a9920fe4f90e52cb9a4bf19211249a6456613b28efe337f18 +8caa54b418ba609d16520af3dff2e96d5f2eeb162c065a1763beb926547b2cfb3ae41d738db2c5681a9bc8bc9e6b9a1a +932157ff56c5ac29cf6cf44f450c882b3acfbb9f43d12d118da3d6256bde4e6eb3183aea304ab6967f37baa718ffec99 +9360bed8fc5b6aac36aa69473040689bfc30411d20ffb7275ef39b9ff5789f9055d149383ce9f0f7709a1f9d683adbfe +98b5b33209068335da72782179d0c7aeeabe94b5560a19d72088fe8323e56db7ce65debe37a97536b6b8a0ca3b840b61 +89a385c11be40064160b030a1bb28c3921fc8078522618a238c7ea0f86f34717ed9af9b4e2e20f5128e5f7fc66ad841e +b615703cbc64b4192990cc7e4903b74aed6a0076ce113b59ef7719197ffa46fb29eb78ca56b49873487432d0625c0faa +90f0d77abae9d3ad73a218e5ccec505ad108ea098451461567ae8ef9661606ca8e78df53b5d628b20b7037bd24622330 +92e0e7cc4dfadc5fa0ee6da0c8de0493030db6e54ba0317f52f232a6708b732068b6077bd13a17eb7eb40b88368085b5 +a24dad20094985bfccc6df1343506ed3bf9dcbdf4b2085a87627a5d71f7568db067304e465f8f380c5c88e8a27291a01 +8629a45a10619354c84bdc2f6c42f540eab5a46f53f2ae11970433d7a2aef007897590bf31dfba1c921614c6d6fe1687 +84ac64040d4206f82b08c771f375da4b7d752e41d2aa0da20ce845f6bc1b880a855d3ee966bca19b8ec327b4b43e7f0e +9608e6050c25996c052509f43f24a85cdf184135f46eaac520a9a6e78e0d44a6cee50ebc054048c708aefde8cd6651c2 +a32032b0e0d7cc35e480c328f315327f9385adb102a708c9ba637878deb74582ae26bb6d6e5f8c9e3a839b0e0154b82a +b7e3c78d63acc6564a49e9f00b0a820b56d4f37a2374af1f7f1d016268011df9e7af0670ed2b0eee961f15aa948328dd +8b88bfdd353acc91ad0d308a43e5fb40da22c228f2fe093c6d6904d70f69c6203f56636ed898b05df51d33f1095ef609 +b1d7a430c51fc857af55047683fc18c453b013527196c5e1bf776819a3dffca802217e9249ae03f084e2ea03ad67fcc2 +80558e28a819ddb5e72e97c54be0f57c173ccf78038d360d190b7f1350a19577b8e3f43fa2f7bf113a228cd3b965b2e4 +b4b2ec44e746c00dfc5661ba2514930934fc805cdc29adc531c02d28ce3cc754414b0485d4ee593232cd1175f357ad66 +b57cee5d32835f76572330f61ccd25a203f0e4a7e5053d32965db283aad92f287645533e8e615137208383ec51b1fd99 +930256086b419a8a6581c52590d0dbd9f8a3564c79424198fca3866b786df2f6098a18c50dc4abd20853a7184b1ce15d +8e75fd01181cffcd618a983492390f486e8c889972a46c1f34a4e1b38f384e8e4efc7e3c18533aa2057da9f9623e2238 +b375d927dd988429f9e2764e5943916131092c394fce13b311baa10f34b023dd3571da02553176091a0738cc23771b9a +b9e28e4c0d0477518034d000e32464852e6951c8db6f64ccdb1d2566f5094716213fbf2fc0e29ac88d0e79f725e3c926 +963981e99392afbd2b8318d5a6b2b0cc69c7f2f2f13f4b38dddbfedb2b0eaf0584aecfcbda20a4c60789c15d77970a58 +a7804e1977aa77c263c7c001afa6cf568032dea940e350d6a58ce4614f1a91c13ae1c78bfea740c229dce2444556976a +8787204177da3cde6d35cd3497fa8774d244f9faa9f4bd91b636a613a32ce2ea0326378cf9c4cf475e73ef751b355c4b +895aeef46a07152a04ec812f1aa1fd431389fa0ef6c6e96a5b833e70ea14073bc9984757a8ee456dbec9788e74e6f0ca +8d17f0e5826783440d1f0ec868003510a4d9952bfe4a638e44a36d94482ac18ba70ef7ff773bdf7a3b62d714dcf0fcba +810d5e36b31310b2e054a666d3b3f7ed16dfcb1765532d87ca2a3920316f0187303c27dd113db145d47e8961062a6c03 +b4e2fb48ae04cf8580bb6a28095076c9b95e5f13122b917328f334d4ac8a8648ce442919e28319a40148987350ab5303 +b85549a313544fa1eb3ceb78473b7d3d717fc85b808de7b79db7dbd0af838ebb020622a7503f1cbacab688dddb648f84 +80665adee057088eae827a5fe904ec3ad77d8843cdce0322d535e0659b4abc74a4d7ddd8a94c27f2def5c34ac2c038ee +ad72fc19c2ce99b5b717e35528fe7d3ac8add340b02ebeb4889d9a94c32f312a0b45ea84d21c54f84cc40ee4958b72e1 +99d530c843dff89a47a5ee8c87303ab18f8a82b0d5b808fca050354b35da5c5a5594d55921c6362d6cc917d75bdc18dc +99c7286c293e1be21c5b2a669dfdfcd5aa587105d2886fc5a8eaf8984da4e907f7d7b8c2362d64a4f1621b077a2a08a0 +b4a39e1a9ed5d80c9563c3ca3fadf76f5478c63a98f4346a61b930c9c733e002f3ff02bc16abfdb53d776184cc3f87ba +9378ea71b941979404c92d01fb70b33fa68d085bf15d60eb1c9fc2b5fcdee6379f5583389a3660a756a50019a2f19a69 +b68e17344a2bc45b8e2e19466b86dc139afefbf9bad2e2e28276a725099ebac7f5763f3cb52002261e3abe45ef51eb1a +819e64dc412b2d194d693b9b3157c1070a226af35c629837df145ea12ad52fa8eabd65b025a63c1fb0726207a58cdde8 +a5e8ff8748419466ff6df5d389125f3d46aedacf44eaf12cbfe2f68d218c7d5ab6de4a8279d13aecc25f3b1d98230894 +91560d54a9715cfda9cf7133ae51c432d0bf7fcbaeb468004994e6838bfc5ddcfa30e4e780667d0c4c0376780b083017 +ae8adb3309cc89d79a55ff74f129bb311fe4f5351a8b87600a87e0c3ba60825f71fccf67eadcf7e4b243c619417540fd +8d92cc1a6baa7bfa96fbce9940e7187b3d142f1888bdcb09bb5c8abf63355e9fb942ac4b4819d9be0e0e822d3e8e2e08 +a6e8b79fdd90c34735bb8fbef02165ccbe55ea726dc203b15e7a015bf311c9cac56efd84d221cc55eaa710ee749dbdfe +a409b151de37bddf39ce5f8aa3def60ee91d6f03ddd533fce9bf7bdbeac618cc982c4f1ffbf6e302b8353d8f28f8c479 +b9693975ef82171b3b9fc318ca296e4fe6110b26cbdfd653418f7754563fa7b6e22d64f8025ee4243483fa321572bfe4 +a039ebe0d9ee4a03ade08e2104ffd7169975b224061924cca2aae71464d250851e9f5f6f6cb288b5bf15df9e252712a6 +b27834db422395bd330e53736a001341ce02c9b148c277dabac67dc422741bfa983c28d47c27e8214cd861f2bad8c6f6 +a2bafaf4e2daf629fd27d7d5ac09fb5efc930ff2ae610f37519808683aa583fe1c6f37207daf73de1d8a164f79a0c981 +b856cee1cfcf5e50db9af4ab0aed3db2f43c936eaea369b5bba65582f61f383c285efbda97b1c068c5d230cbe94f7722 +a61ab205554c0550fa267e46a3d454cd1b0a631646b3df140623ff1bfffaa118e9abe6b62814968cc2a506e9c03ea9a0 +8c78edcd106377b9cbdfa2abd5278724aed0d9e4ae5869b5d2b568fdabb7804c953bae96294fcc70ef3cd52ba2cbe4ed +8570869a9bbf6cc84966545a36586a60be4d694839f367b73dfc40b5f623fc4e246b39b9a3090694aa2e17e652d07fd1 +a905b82c4da8d866a894da72315a95dc98faa3c7b3d809aef18f3b2be4801e736a1b79a406179e8cac8f74d27e71ac52 +a8eb8679ff1a64908515f6720ff69434cb33d63aeb22d565fde506618908b1d37585e3bd4d044fd0838b55787af06b42 +af4d86b2fbd1684a657dffe4210321a71e6ae560c144d44668d1f324dc9630e98348c3d444622a689327c1a59cc169dd +80359c6eab16954559ab0e6a1fee9a0526c45d3cae1a371159a2e3aa9b893afdc3a785c9559a5fd9cd8cd774234bf819 +8d4e5ff81eb5d17bbe8ae6416538ca51a9427ce142b311f5cbb14febbbbb9c1ffc6489fd625b9266264c366c12a9d997 +92e181c66489c5fa063ba2a1a354b6fd3439b8b4365a8c90e42e169bfaa1fb5766bf3e0fe804399d18bc8fbcafb5c3b1 +a9ddf229360a095393885083716cb69c819b2d7cfb100e459c2e6beb999ff04446d1e4a0534832ae3b178cbe29f4f1d3 +8e085ef7d919302a1cc797857b75cff194bdbc1c5216434fa808c3dea0cf666f39d9b00f6d12b409693d7a9bd50a912c +916dc4dc89e5e6acf69e4485a09fc66968f9b292eac61a146df1b750aa3da2425a0743d492179f90a543a0d4cd72c980 +b9cbf17e32c43d7863150d4811b974882da338cf0ed1313765b431b89457021dd1e421eeaa52840ef00551bb630962dc +a6fb875786daec1a91484481787093d8d691dd07e15c9c0c6ae0404bf9dc26083ed15d03c6d3fe03e29f28e20da21269 +a870fcb54b9a029e8086de9b08da8782c64ad2cc2e7fdf955b913d294038bb8136193256b85267e75a4ca205808a76b4 +99883f057e09b88bf0e316f9814c091837fd5c26eeb16fec108c9fed4b7a2bd1c783dac0e4242b5a906621ab606c1e50 +85d89069ca3190577dab39bbec43c16bf6dbca439ad3eebd8f5e9f507d84c3c43e77fd6323224582566a3aa2c8018951 +9363ba219e0003f6e8a9d8937b9e1449e4b2c5cd57194563b758bea39deab88778e8f8e4f7816970a617fb077e1e1d42 +820622f25553c035326145c1d2d537dc9cfd064c2f5bdf6d4ec97814de5fe9a0fbd443345fa2ea0a9d40d81d3936aa56 +87e31110aaf447e70c3316459250e4f7f8c24420c97828f9eb33b22107542c5535bdb48b0e58682dd842edea2886ff08 +95bf80cac6f42029d843d1246588acb40a74802f9e94b2bf69b1833936767e701ef7b0e099e22ab9f20f8c0c4a794b6c +a46ecf612b2763d099b27fb814bd8fdbaee51d6b9ac277ad6f28350b843ce91d701371adfaaf4509400dc11628089b58 +8604decf299fb17e073969708be5befeb1090ab688ad9f3f97a0847a40ea9a11bbcfc7a91e8dc27bc67a155123f3bd02 +8eb765c8dc509061825f3688cb2d78b6fef90cf44db33783d256f09be284bc7282205279725b78882688a514247c4976 +b5c30b2244fa109d66b3a5270b178960fdec47d31e63db0b374b80d2b626409eb76d2e8d1ebf47ef96c166743032fc5e +aab01e76290a7e936989530221646160bf8f64e61e79282e980c8c5dcaaa805ff096efd01d075a2c75917a3f4bf15041 +b9d79671debd0b83d0c7c7c3e64c0fb1274300564b262771f839b49218501e7f38ef80cae1f7e5a3c34acdc74c89dab6 +92c0eaceadf036b3b9dfd2712013aba3dd7c30b7760f501f52141618265baa31840fe77850a7014dc528f71f8cf39ce6 +b3cdd098059980455dd5b1c04182df1bd12fa844a866f02a9f8a86aab95b59945baa9af99f687410bffc5b07153cb23c +b361b73a62f71256b7f6ea8e0f6615e14fc5a06ee98b928ab3c9dd3eef9d9d30070e9855c82b7facb639cacb3401e01f +b9c85fc0f25a3271cf28b1ca900078eaaa66cbab0a3e677606e898ac32781a2dfce4d9cbd07404599e2c3c02fa161c9d +ac5b4fdac2a0b2e6430d9fc72bde4249d72183b197fc7347bb1546ae6f544426686bbe0caec3ee973b6836da5e831c44 +b675aebf24b92e398e166f171a6df442b3f5919b6bee192f31675a5e8eeb77d34c6590a6f0c0857417e0f78cfb085db8 +a9bef942044d8d62e6a40169f7dc7b49e40cd0d77f8678dd7c7bae6f46c46786f9b1e319a3fa408f22a54fd2a4d70804 +a20d19cd917d5102ae9ca0cf532127d2b953aa3303310e8a8c4b3da025dded993a47e3a28e6b02acfadb6d65dc2d41a3 +a47fdb04059b83b2afb86a47b2368bbd7247c337a36d3333b6e5ef2cc9476a92c4907e4c58a845c9ef9b497621e0b714 +94a9e9ffc14b411e11a4ffa59878d59460263589003dc7b6915247c549f67feede279bf3645fdd92379022fb21e3caeb +b92e1177dd9ecdaf1370c71b14954219cf0851f309bc216d5907a4e2e84e0df3457018224150c142cc6bf86644bb4b73 +8bc57fadd68a265b7df9b42227a9c0968db7b1bb50dc12f7d755505779f1ff2c408672b3091e903366acc9ce15d19fb6 +b6b5efbe1ac4e1bd2e8447c45000d09397b772ca5496acc447b881022608a41c4f60388814607a01890190105bee7be3 +95f7c85fd614df968f8ccf8d086579c9e1cec4644ecf06da26e3511cb39635a7326b3cec47bd51cf5646f1c660425e9c +b81765fb319bcdc74b4d608383ccb4af7dd84413b23af637be12e2827a75f7e4bcd14441cf979ed9038ae366fbb6f022 +a120ea76cda8c6c50c97035078f6648afe6537809bdba26e7c9e61de8f3070d2347160f9d34010effbf2ec7e94f5749f +92c1b8631953b40d3cc77eee2c72a064b999c09a9b92c11d8fa7b4072966273901c9dba25f9f79f384d9f11a56f3fc7a +a4b00dc0ab67b2300abc9c516e34daf444d6497b066a90cfe3381ed2812304ed37b14f3b948990443dc6c1cf1bed460c +a9e9f7e13c9f031bc7b9e6f1417c7abcc38894fe7d3f54869ee277afd2efa3e6fb50757dd36c8c94d591e0abdea322cc +84f3e98f831792b5ad14bcfe62a4c9f296476c6087c4c1ec7767fc642fbca141ff6a3deeb8b4d4106a9cda5a9937eea0 +8eb1a7931bbea9a714226fd74b0100ab88355287d9b0a349c095e9b5809b98f237ffd706bce7d67a770da355fb9cec7b +9738ef8739e1742c1f26b51a1621be0b89d37406a370c531e236f635c7064c661818817bb3858908986aa687b28b21be +a9cf3ce8501b003ccaf57552a4c4ec31081e44526d3aa3791d3dc4a7e438a357c0956f93c500356186d8fd4588ffac5e +a7af6a219cca59225839a9de5b19263cb23d75557d448bc7d677b62591a2e068c45e5f4457cceb3e9efa01d0601fc18a +972a24ece5eda7692cbb6fb727f92740451bc1281835e2a02931b2b05824a16b01dbe5edd03a0ed5b441ff25a5cc0188 +b21d1ec7597ce95a42f759c9a8d79c8275d7e29047a22e08150f0f65014702f10b7edce8c03f6e7ab578ce8c3b0ec665 +a13a1c7df341bd689e1f8116b7afc149c1ef39161e778aa7903e3df2569356ad31834fa58ceb191485585ce5ef6835c3 +a57bdb08119dc3bc089b5b2b5383455c4de0c2fcdac2dcfa21c7ac5071a61635ff83eceb7412f53fab42d1a01991de32 +b2968748fa4a6921ee752d97aa225d289f599a7db7a222450e69706533573ded450380c87f8cdd4a8b8c8db1b42b5c97 +8718ec04e0d5f38e3034ecd2f13dfde840add500f43a5e13457a1c73db0d18138f938690c8c315b5bcbeb51e8b9a2781 +82094789e26c4a04f2f30bdb97b9aecca9b756cbd28d22ab3c8bed8afc5b2963340ddfc5a5f505e679bf058cbc5dcbb8 +a35b8a566dd6ab67eddc2467906bffc76c345d508e52e9e4bb407b4f2b2c5f39b31d5a4bf5022f87bf7181dc6be2fe41 +a8c93b1e893d4777c0e3a1b4bef3be90c215781501407c4011457fc3240e13524b4d2bea64a6d0a3efe3f3b0dae9b8ab +877095ad18b1e5870818f7a606127ba1736a0b55b0dbcd281ec307c84b08afc0c9117e3a880fe48bfc225fbf37671a97 +84405ee0421ed2db1add3593df8426a9c1fcc8063e875f5311a917febc193748678dd63171d0c21665fb68b6d786c378 +a52cdc8209c3c310bed15a5db260c4f4d4857f19c10e4c4a4cfe9dfc324dfac851421bb801509cf8147f65068d21603c +8f8a028a70dda7285b664722387666274db92230b09b0672f1ead0d778cee79aae60688c3dfd3a8ed1efdeda5784c9d4 +a0be42fecc86f245a45a8ed132d6efc4a0c4e404e1880d14601f5dce3f1c087d8480bad850d18b61629cf0d7b98e0ae0 +83d157445fc45cb963b063f11085746e93ab40ece64648d3d05e33e686770c035022c14fdf3024b32b321abf498689ad +8a72bbf5a732e2d4f02e05f311027c509f228aef3561fc5edac3ef4f93313845d3a9f43c69f42e36f508efcc64a20be0 +b9ca29b0ec8e41c6a02f54d8c16aebf377982488cbe2ed1753090f2db4f804f6269af03e015d647a82ef06ffaa8cba6c +b4df3858d61bbb5ded1cf0be22a79df65ae956e961fbb56c883e1881c4c21fe642e3f5a0c108a882e553ac59595e3241 +86457d8890ac8858d7bab180ef66851247c2bf5e52bf69a4051d1d015252c389684fcc30bb4b664d42fbf670574ab3a3 +86d5576ea6dfa06d9ebce4cd885450f270c88a283e1e0d29cab27851c14ed2f00355e167b52e1539f1218ad11d8f13dd +883ad1364dc2a92388bfafaa9bc943c55b2f813525831e817a6208c666829a40455dde494eba054b2495a95f7ce69e8a +8942371e6925231c2c603b5f5a882d8404d39f0c7c4232557c2610b21c2c07f145466da798ea78b7932da2b774aa3128 +a799eb71496783cc7faf12c9d9804bf6180699a004b2f07fc5cc36840f63ce7eee7dde9275819a9aa3f8d92dc0d47557 +8eb3fb5c769548ee38c7882f51b959c5d5a42b5935269ccf987d6ddbb25a206e80c6000bcc328af149e0727c0b7c02c0 +8f3910d64e421a8f2d8db4c7b352ba5b3fc519d5663973fea5962efe4364fb74448770df944ef37ffe0382648fb56946 +b41413e0c26ff124cf334dab0dc8e538293d8d519d11cc2d10895a96b2064ac60c7da39f08589b38726cffa4c3f0bfef +b46ef2eb10abae0f35fa4c9c7ee2665e8044b8d9f91988a241da40fd5bbc63166925582151941b400006e28bbc5ba22a +b8baa8b4c420bb572a3b6b85479b67d994c49a7ebfe1274687d946a0d0b36dfed7630cfb897350fa166f5e2eff8f9809 +964b46d359c687e0dcfbdab0c2797fc2bd1042af79b7418795b43d32ffca4de89358cee97b9b30401392ff54c7834f9f +8410d0203d382ebf07f200fd02c89b80676957b31d561b76563e4412bebce42ca7cafe795039f46baf5e701171360a85 +b1a8d5d473c1a912ed88ea5cfa37c2aea5c459967546d8f2f5177e04e0813b8d875b525a79c29cb3009c20e7e7292626 +afaab9a1637429251d075e0ba883380043eaf668e001f16d36737028fded6faa6eeed6b5bb340f710961cee1f8801c41 +aef17650003b5185d28d1e2306b2f304279da50925f2704a6a3a68312f29fe5c2f2939f14e08b0ba9dee06ea950ad001 +97bcc442f370804aa4c48c2f8318d6f3452da8389af9335e187482d2e2b83b9382e5c297dce1a0f02935e227b74e09a3 +8a67a27b199f0bcd02d52a3e32f9b76a486b830ec481a49a4e11807e98408b7052b48581b5dd9f0b3e93052ec45dfb68 +b113bf15f430923c9805a5df2709082ab92dcdf686431bbad8c5888ca71cc749290fa4d4388a955c6d6ee3a3b9bc3c53 +8629ca24440740ce86c212afed406026f4ea077e7aa369c4151b6fa57bca7f33f9d026900e5e6e681ae669fd2bd6c186 +933a528371dcecc1ec6ded66b1c7b516bd691b3b8f127c13f948bfbcda3f2c774c7e4a8fbee72139c152064232103bdf +8568ddd01f81a4df34e5fa69c7f4bb8c3c04274147498156aec2e3bd98ea3e57c8a23503925de8fa3de4184563a2b79e +8160874ec030f30fda8f55bcf62613994ff7ed831e4901c7560eac647182b4a9b43bfaff74b916602b9d6ae3bfcaf929 +ae71c48d48cf9459800cdf9f8e96bc22e2d4e37259e5c92a2b24fbe2c6ca42675e312288603c81762f6ceb15400bc4c9 +b05f39bb83fda73e0559db1fd4a71423938a87ad9f060d616d4f4a6c64bf99472a2cbfb95f88b9257c9630fc21a0b81f +80c8479a640ed7a39e67f2db5ad8dfd28979f5443e8e6c23da8087fc24134d4b9e7c94320ffa4154163270f621188c27 +9969ba20ee29c64cb3285a3433a7e56a0fe4ddc6f3d93e147f49fe021bed4a9315266ebb2fb0eb3036bb02001ae015e6 +a198c89fef2ab88e498703b9021becc940a80e32eb897563d65db57cc714eaa0e79092b09dd3a84cfab199250186edcc +8df14a3db8fe558a54d6120bad87405ba9415a92b08c498812c20416c291b09fed33d1e2fcf698eb14471f451e396089 +81e245ef2649b8a5c8d4b27188dd7e985ef6639090bdc03462c081396cf7fc86ed7d01bfe7e649d2b399255e842bdc21 +8659f622c7ab7b40061bcf7a10144b51ad3ab5348567195924f2944e8c4ce137a37f1ba328e4716c10806f3fb7271689 +a575d610fc8fe09334ca619ecdadf02d468ca71dd158a5a913252ca55ea8d8f9ce4548937c239b9cb8ab752a4d5af24a +94744549cd9f29d99f4c8c663997bdfa90e975b31f1086214245de9c87b0c32209f515a0de64d72d5ef49c09b0a031fa +80a8677862b056df59e350c967a27436c671b65d58854e100115bac9824ba177e94c2a1bfcaa191a071b9cefdbee3989 +91be9a5504ec99922440f92a43fe97ddce2f21b9d94cd3a94c085a89b70c903696cec203bbab6d0a70693ba4e558fb01 +8c5a0087bcd370734d12d9b3ab7bc19e9a336d4b49fc42825b2bfedcd73bb85eb47bf8bb8552b9097cc0790e8134d08c +933aa9e6bd86df5d043e0577a48e17eea3352e23befdbb7d7dcac33b5703d5ace230443ac0a40e23bf95da4cc2313478 +984b7ee4bd081ee06c484db6114c2ce0ba356988efb90f4c46ff85ed2865fb37f56a730166c29ef0ae3345a39cdeae7a +ae830f908ea60276c6c949fb8813e2386cf8d1df26dcf8206aa8c849e4467243e074471380ed433465dc8925c138ea4c +874c1df98d45b510b4f22feff46a7e8ed22cfc3fad2ac4094b53b9e6477c8dfc604976ca3cee16c07906dece471aa6c6 +a603eb60d4c0fb90fa000d2913689126849c0261e6a8649218270e22a994902965a4e7f8c9462447259495fe17296093 +a7c73d759a8ad5e3a64c6d050740d444e8d6b6c9ade6fb31cb660fa93dc4a79091230baccb51c888da05c28cb26f6f3f +a4411b79b6a85c79ea173bd9c23d49d19e736475f3d7d53213c5349ebb94a266d510d12ba52b2ac7a62deaaaec7339b8 +943b84f8bbcee53b06266b5c4cd24d649d972593837fe82b0bf5d5e1bbc1a2bf148e1426c366d7c39ab566b10224cadc +8300012096a8b4cefecc080054bf3ceb0918162ba263c6848860423407796b5eb517170c0bad8e4905ac69a383055a21 +8244a1e3ad41908c6f037e2f8db052e81f281646141334829f36c707f307448b9ab79a7f382a1e8d86f877c90b59271c +8eca1b74687802ecc36a5d39e4516a9dee3de61a2047252d9ed737b49e0090c386e9d792ac004c96337681c7f29a16ad +b70fa47535f0524835039a20036c61e77f66146ad79d3d339214d8744742db41ceeb577c829d000011aeafbb12e09579 +84b3abbce48689f3adbb99889c7fd1f3e15ab455d477e34f5151c5c1c358ed77a5b6a581879f7e0f1f34106e0792e547 +ab45ecb58c0ef0dbce3d16afc6ac281e0d90ec48741ea96a141152647e98fcc87f3a3ff07ba81f3179118453ce123156 +90d231a145ba36a59087e259bbfc019fa369201fcfeaa4347d5fd0a22cd8a716e5a797f3cc357f2779edb08f3b666169 +a4f6074d23c6c97e00130bc05f25213ca4fa76c69ca1ace9dece904a2bdd9d987661f5d55023b50028c444af47ff7a08 +933af884939ad0241f3f1f8e8be65f91d77ac0fb234e1134d92713b7cfb927f1933f164aec39177daa13b39c1370fac8 +80d1db6933ce72091332ae47dc691acb2a9038f1239327b26d08ea9d40aa8f2e44410bbda64f2842a398cbe8f74f770f +a7a08605be2241ccc00151b00b3196d9c0717c4150909a2e9cd05538781231762b6cc6994bebbd4cddae7164d048e7b2 +96db0d839765a8fdbbac03430fa800519e11e06c9b402039e9ae8b6503840c7ecac44123df37e3d220ac03e77612f4e4 +96d70f8e9acd5a3151a8a9100ad94f16c289a31d61df681c23b17f21749c9062622d0a90f6d12c52397b609c6e997f76 +8cf8e22273f7459396ff674749ab7e24c94fe8ab36d45d8235e83be98d556f2b8668ba3a4ec1cb98fac3c0925335c295 +97b7e796a822262abc1a1f5a54cb72a1ea12c6c5824ac34cd1310be02d858a3c3aa56a80f340439b60d100e59c25097d +a48208328b08769737aa1a30482563a4a052aea736539eceab148fa6653a80cb6a80542e8b453f1f92a33d0480c20961 +b612184941413fd6c85ff6aa517b58303b9938958aa85a85911e53ed308778624d77eadb27ccf970573e25d3dfd83df7 +b3717068011648c7d03bbd1e2fc9521a86d2c3ae69113d732c2468880a3b932ebec93596957026477b02842ed71a331b +a0ad363e1352dcf035b03830fef4e27d5fd6481d29d5e8c9d51e851e3862d63cdcbaf8e330d61c1b90886921dac2c6fd +8db409fdacfa4bfdaf01cc87c8e97b53ca3a6e3a526d794eaad1c2023f3df4b888f1bf19fee9a990fe6d5c7c3063f30c +b34d6975310ab15938b75ef15020a165fc849949065d32d912554b51ffa1d3f428a6d1a396cb9329367670391de33842 +9117285e9e6762853fc074b8a92b3923864de2c88c13cea7bab574aaf8cdd324843455d2c3f83c00f91f27c7ecc5592a +b4b2e8f190ea0b60819894710c866bf8578dd1b231ae701d430797cc7ede6e216e8ca6a304f3af9484061563645bf2ab +8c493c6853ab135d96a464815dd06cad8b3e8b163849cdefc23d1f20211685753b3d3e147be43e61e92e35d35a0a0697 +9864d7880f778c42d33cf102c425e380d999d55a975a29c2774cad920dfddb80087a446c4f32ed9a6ab5f22ec6f82af0 +90f67fe26f11ca13e0c72b2c2798c0d0569ed6bc4ce5bbaf517c096e7296d5dd5685a25012f6c6d579af5b4f5d400b37 +a228872348966f26e28a962af32e8fa7388d04bc07cfc0224a12be10757ac7ab16a3387c0b8318fcb0c67384b0e8c1a4 +a9d9d64bba3c03b51acf70aeb746a2712ddafe3b3667ae3c25622df377c2b5504e7ab598263bec835ab972283c9a168b +932128971c9d333f32939a1b46c4f7cf7e9d8417bd08dc5bd4573ccbd6ec5b460ac8880fb7f142f7ef8a40eef76d0c6d +964115e7838f2f197d6f09c06fbb2301d6e27c0ecdf208350cf3b36c748436dac50f47f9f9ac651c09ab7ad7221c7e43 +a5941f619e5f55a9cf6e7f1499b1f1bcddcc7cf5e274efedaaad73a75bc71b1fc5c29cd903f6c69dc9a366a6933ca9d1 +a154bf5eaec096029e5fe7c8bf6c695ae51ace356bb1ad234747776c7e1b406dee2d58864c3f4af84ed69f310974125e +b504e6209d48b0338ab1e4bdab663bac343bb6e0433466b70e49dc4464c1ec05f4a98111fd4450393607510ae467c915 +813411918ea79bdde295393284dc378b9bdc6cfcb34678b9733ea8c041ac9a32c1e7906e814887469f2c1e39287e80f8 +8be0369f94e4d72c561e6edb891755368660208853988647c55a8eed60275f2dd6ee27db976de6ecf54ac5c66aaf0ae6 +a7e2701e55b1e7ea9294994c8ad1c080db06a6fc8710cd0c9f804195dce2a97661c566089c80652f27b39018f774f85e +956b537703133b6ddf620d873eac67af058805a8cc4beb70f9c16c6787bf3cc9765e430d57a84a4c3c9fbdd11a007257 +835ae5b3bb3ee5e52e048626e3ddaa49e28a65cb94b7ecdc2e272ff603b7058f1f90b4c75b4b9558f23851f1a5547a35 +85d67c371d1bf6dc72cca7887fa7c886ce988b5d77dc176d767be3205e80f6af2204d6530f7060b1f65d360a0eaeff30 +a84a6647a10fcef8353769ef5f55a701c53870054691a6e9d7e748cbe417b3b41dbb881bae67adc12cb6596c0d8be376 +87ffe271fc0964cb225551c7a61008d8bcb8b3d3942970dbcc2b9f4f9045a767971880368ea254e2038a3a0b94ecf236 +964bb721c51d43ee7dd67c1a2b7dd2cc672ce8fad78c22dcddb43e6aab48d9a4a7dc595d702aa54a6fb0ffabf01f2780 +a89b3f84bb7dcbe3741749776f5b78a269f6b1bebb8e95d3cc80b834fd2177c6be058d16cacfd0d5e1e35e85cde8b811 +b4314538e003a1587b5592ff07355ea03239f17e75c49d51f32babe8e048b90b046a73357bcb9ce382d3e8fbe2f8e68b +86daf4bf201ae5537b5d4f4d734ed2934b9cf74de30513e3280402078f1787871b6973aa60f75858bdf696f19935a0e2 +b1adf5d4f83f089dc4f5dae9dbd215322fa98c964e2eaa409bf8ca3fa5c627880a014ed209492c3894b3df1c117236c4 +b508d52382c5bac5749bc8c89f70c650bb2ed3ef9dc99619468c387c1b6c9ff530a906dfa393f78f34c4f2f31478508a +a8349a5865cb1f191bebb845dfbc25c747681d769dbffd40d8cedf9c9a62fa2cbc14b64bb6121120dab4e24bef8e6b37 +af0500d4af99c83db8890a25f0be1de267a382ec5e9835e2f3503e1bac9412acf9ff83a7b9385708ef8187a38a37bc77 +b76d57a1c1f85b8a8e1722a47057b4c572800957a6b48882d1fc21309c2e45f648a8db0fcff760d1dbc7732cf37c009b +b93c996cec0d3714667b5a5a5f7c05a7dc00bbc9f95ac8e310626b9e41ae4cc5707fac3e5bd86e1e1f2f6d9627b0da94 +93216fdb864217b4c761090a0921cf8d42649ab7c4da1e009ec5450432564cb5a06cb6e8678579202d3985bd9e941cef +8b8be41105186a339987ae3a5f075fbc91f34b9984d222dfed0f0f85d2f684b56a56ab5dc812a411570491743d6c8b18 +959b72782a6b2469e77fe4d492674cc51db148119b0671bd5d1765715f49fa8a87e907646671161586e84979ef16d631 +86b7fc72fb7e7904ea71d5e66ba0d5d898ace7850985c8cc4a1c4902c5bf94351d23ce62eed45e24321fb02adfa49fc8 +a2f244e7c9aa272cb0d067d81d25e5a3045b80b5a520b49fd5996ece267a7f1bea42e53147bbf153d9af215ea605fc9e +81aa2efa5520eebc894ce909ba5ce3250f2d96baa5f4f186a0637a1eea0080dd3a96c2f9fadf92262c1c5566ddb79bab +b607dd110cfe510d087bcff9a18480ba2912662256d0ab7b1d8120b22db4ad036b2266f46152754664c4e08d0fc583f6 +8f588d5f4837e41312744caac5eee9ddc3ad7085871041694f0b5813edf83dc13af7970f7c9b6d234a886e07fa676a04 +924921b903207783b31016cbec4e6c99e70f5244e775755c90d03a8b769738be3ba61577aca70f706a9c2b80040c9485 +ae0a42a222f1a71cd0d3c69ffb2f04c13e1940cce8efabe032629f650be3ceed6abb79651dbb81cb39a33286eb517639 +a07d7d76460f31f5f0e32e40a5ea908d9d2aebf111ac4fadee67ef6540b916733c35a777dcdc05f6417726ca1f2d57dd +88d7f8a31f8c99794291847d28745e5d0b5d3b9684ca4170b686ffbb5bb521a3ef6746c3c8db22e4250a0cdff7939d96 +849573071fd98c020dc9a8622a9eff221cb9f889bde259e7127a8886b73bef7ad430b87750915658918dcfb6b7b4d8d3 +b12d59f732fa47fad175d6263734da8db89230fd340a46ad1cdee51e577041a5c80bf24cd195593e637daf1a66ef5a98 +abbcfb8a4a6d5e269ee1ac5e277df84416c73ca55ec88317f73608201af25af0cb65b943c54684a5651df3a26e3daca2 +ab157f589bdbaf067a6a7ba7513df0492933855d39f3a081196cf2352e0ddc0162d476c433320366e3df601e0556278d +a86c0619b92e5ae4f7daa876a2abc5ba189156afc2fa05eef464dfa342ba37fc670d0dc308ad3822fcb461ab001bac30 +a3f292946476cfe8d5e544a5325439a00e0165a5f9bf3bb6a53f477baeac7697cc0377745536681aa116f326ce911390 +8aecbbfd442a6a0f01c1c09db5d9d50213eb6f1ff6fab674cde3da06a4edff3ed317e804f78300c22ef70c336123e05d +834ed4b58211fcd647d7bf7c0a3ba9085184c5c856b085e8a0fcd5215c661ef43d36f3f0f6329a9f1370501b4e73b6e4 +a114ea5ad2b402a0de6105e5730907f2f1e458d28ae35144cf49836e0ad21325fe3e755cfb67984ae0a32e65402aad1e +a005f12bed97d71cee288b59afe9affb4d256888727343944a99913980df2c963fe02f218e6ea992f88db693a4498066 +a010f286ab06b966e3b91ff8f1bdbe2fe9ab41a27bc392d5787aa02a46e5080e58c62c7d907818caae9f6a8b8123e381 +857bd6df2ddef04dbc7c4f923e0b1696d3016c8bfed07fdfa28a3a3bd62d89b0f9df49aae81cbb6883d5e7b4fadae280 +b3927030da445bc4756ac7230a5d87412a4f7510581fb422212ce2e8cf49689aca7ba71678743af06d4de4914c5aa4a0 +b86403182c98fcce558d995f86752af316b3b2d53ba32075f71c7da2596747b7284c34a1a87de604fcc71e7e117a8add +98dd19b5527733041689b2a4568edaf6aa0fe1a3dd800c290cda157b171e053648a5772c5d3d4c80e5a795bc49adf12e +88a3c227bb7c9bff383f9ad3f7762245939a718ab85ae6e5e13180b12bf724d42054d3852b421c1cd1b3670baddecb63 +b3cfd9ad66b52bbe57b5fff0fad723434d23761409b92c4893124a574acc1e6b1e14b4ec507661551cbbe05e16db362e +923e1bb482cf421dd77801f9780f49c3672b88508a389b94015fd907888dc647ee9ea8ec8d97131d235d066daf1f42b7 +8d5e16240f04f92aa948181d421006bdbc7b215648fb6554193224d00cf337ebbb958f7548cf01b4d828acffb9fbc452 +8b2b8f18ad0559746f6cda3acca294a1467fb1a3bc6b6371bc3a61a3bfe59418934fa8706f78b56005d85d9cb7f90454 +a9316e2a94d6e31426d2ae7312878ba6baaac40f43e2b8a2fa3ab5a774c6918551554b2dbb23dc82f70ba3e0f60b5b0d +9593116d92cf06b8cd6905a2ce569ee6e69a506c897911f43ae80fc66c4914da209fc9347962034eebbc6e3e0fe59517 +887d89d2b2d3c82b30e8f0acf15f0335532bd598b1861755498610cb2dd41ff5376b2a0bb757cb477add0ce8cfe7a9fc +b514cfe17875ecb790ad055271cc240ea4bda39b6cfa6a212908849c0875cb10c3a07826550b24c4b94ea68c6bb9e614 +a563d5187966d1257d2ed71d53c945308f709bcc98e3b13a2a07a1933dc17bcb34b30796bd68c156d91811fbd49da2cb +a7195ccc53b58e65d1088868aeeb9ee208103e8197ad4c317235bb2d0ad3dc56cb7d9a7186416e0b23c226078095d44c +a838e7a368e75b73b5c50fbfedde3481d82c977c3d5a95892ac1b1a3ea6234b3344ad9d9544b5a532ccdef166e861011 +9468ed6942e6b117d76d12d3a36138f5e5fb46e3b87cf6bb830c9b67d73e8176a1511780f55570f52d8cdb51dcf38e8c +8d2fc1899bc3483a77298de0e033085b195caf0e91c8be209fd4f27b60029cbe1f9a801fbd0458b4a686609762108560 +8f4e44f8ca752a56aa96f3602e9234ad905ad9582111daf96a8c4d6f203bf3948f7ce467c555360ad58376ee8effd2ba +8fb88640b656e8f1c7c966c729eb2ba5ccf780c49873f8b873c6971840db7d986bdf1332ba80f8a0bb4b4ee7401468fa +b72aa3235868186913fb5f1d324e748cd3ce1a17d3d6e6ea7639a5076430fe0b08841c95feb19bb94181fe59c483a9eb +b8b102690ebb94fc4148742e7e3fd00f807b745b02cbe92cd92992c9143b6db7bb23a70da64a8b2233e4a6e572fc2054 +8c9ae291f6cd744e2c6afe0719a7fc3e18d79307f781921fb848a0bf222e233879c1eca8236b4b1be217f9440859b6ce +a658ede47e14b3aad789e07f5374402f60e9cacb56b1b57a7c6044ca2418b82c98874e5c8c461898ebd69e38fecd5770 +89c0cb423580e333923eb66bda690f5aca6ec6cba2f92850e54afd882ba608465a7dbb5aa077cd0ca65d9d00909348ab +aed8e28d98d5508bd3818804cf20d296fe050b023db2ed32306f19a7a3f51c7aaafed9d0847a3d2cd5ba5b4dabbc5401 +96a0fcd6235f87568d24fb57269a94402c23d4aa5602572ad361f3f915a5f01be4e6945d576d51be0d37c24b8b0f3d72 +935d0c69edd5dfa8ed07c49661b3e725b50588f814eb38ea31bcc1d36b262fae40d038a90feff42329930f8310348a50 +900518288aa8ea824c7042f76710f2ea358c8bb7657f518a6e13de9123be891fa847c61569035df64605a459dad2ecc8 +947d743a570e84831b4fb5e786024bd752630429d0673bf12028eb4642beb452e133214aff1cfa578a8856c5ebcb1758 +a787266f34d48c13a01b44e02f34a0369c36f7ec0aae3ec92d27a5f4a15b3f7be9b30b8d9dd1217d4eeedff5fd71b2e5 +a24b797214707ccc9e7a7153e94521900c01a1acd7359d4c74b343bfa11ea2cdf96f149802f4669312cd58d5ab159c93 +97f5ee9c743b6845f15c7f0951221468b40e1edaef06328653a0882793f91e8146c26ac76dd613038c5fdcf5448e2948 +80abd843693aed1949b4ea93e0188e281334163a1de150c080e56ca1f655c53eb4e5d65a67bc3fc546ed4445a3c71d00 +908e499eb3d44836808dacff2f6815f883aeced9460913cf8f2fbbb8fe8f5428c6fc9875f60b9996445a032fd514c70f +ae1828ef674730066dc83da8d4dd5fa76fc6eb6fa2f9d91e3a6d03a9e61d7c3a74619f4483fe14cddf31941e5f65420a +a9f4dbe658cd213d77642e4d11385a8f432245b098fccd23587d7b168dbeebe1cca4f37ee8d1725adb0d60af85f8c12f +93e20ee8a314b7772b2439be9d15d0bf30cd612719b64aa2b4c3db48e6df46cea0a22db08ca65a36299a48d547e826a7 +a8746a3e24b08dffa57ae78e53825a9ddbbe12af6e675269d48bff4720babdc24f907fde5f1880a6b31c5d5a51fbb00e +b5e94dfab3c2f5d3aea74a098546aa6a465aa1e3f5989377d0759d1899babf543ad688bb84811d3e891c8713c45886c5 +a3929bada828bd0a72cda8417b0d057ecb2ddd8454086de235540a756e8032f2f47f52001eb1d7b1355339a128f0a53b +b684231711a1612866af1f0b7a9a185a3f8a9dac8bde75c101f3a1022947ceddc472beb95db9d9d42d9f6ccef315edbc +af7809309edbb8eb61ef9e4b62f02a474c04c7c1ffa89543d8c6bf2e4c3d3e5ecbd39ec2fc1a4943a3949b8a09d315a6 +b6f6e224247d9528ef0da4ad9700bee6e040bbf63e4d4c4b5989d0b29a0c17f7b003c60f74332fefa3c8ddbd83cd95c1 +adbcec190a6ac2ddd7c59c6933e5b4e8507ce5fd4e230effc0bd0892fc00e6ac1369a2115f3398dfc074987b3b005c77 +8a735b1bd7f2246d3fa1b729aecf2b1df8e8c3f86220a3a265c23444bdf540d9d6fe9b18ed8e6211fad2e1f25d23dd57 +96b1bf31f46766738c0c687af3893d098d4b798237524cb2c867ed3671775651d5852da6803d0ea7356a6546aa9b33f2 +8036e4c2b4576c9dcf98b810b5739051de4b5dde1e3e734a8e84ab52bc043e2e246a7f6046b07a9a95d8523ec5f7b851 +8a4f4c32ee2203618af3bb603bf10245be0f57f1cfec71037d327fa11c1283b833819cb83b6b522252c39de3ce599fa5 +ad06ed0742c9838e3abaaffdb0ac0a64bad85b058b5be150e4d97d0346ed64fd6e761018d51d4498599669e25a6e3148 +8d91cb427db262b6f912c693db3d0939b5df16bf7d2ab6a7e1bc47f5384371747db89c161b78ff9587259fdb3a49ad91 +ae0a3f84b5acb54729bcd7ef0fbfdcf9ed52da595636777897268d66db3de3f16a9cf237c9f8f6028412d37f73f2dfad +8f774109272dc387de0ca26f434e26bc5584754e71413e35fa4d517ee0f6e845b83d4f503f777fe31c9ec05796b3b4bc +a8670e0db2c537ad387cf8d75c6e42724fae0f16eca8b34018a59a6d539d3c0581e1066053a2ec8a5280ffabad2ca51f +ac4929ed4ecad8124f2a2a482ec72e0ef86d6a4c64ac330dab25d61d1a71e1ee1009d196586ce46293355146086cabba +845d222cb018207976cc2975a9aa3543e46c861486136d57952494eb18029a1ebb0d08b6d7c67c0f37ee82a5c754f26f +b99fa4a29090eac44299f0e4b5a1582eb89b26ed2d4988b36338b9f073851d024b4201cd39a2b176d324f12903c38bee +9138823bc45640b8f77a6464c171af2fe1700bdc2b7b88f4d66b1370b3eafe12f5fbb7b528a7e1d55d9a70ca2f9fc8e6 +8ac387dc4cf52bc48a240f2965ab2531ae3b518d4d1f99c0f520a3d6eb3d5123a35ef96bed8fa71ee2f46793fa5b33b3 +864adec6339d4c2ba2525621fceabd4c455902f6f690f31a26e55413e0722e5711c509dc47ce0bcc27bbdc7651768d2d +a0a52edb72268a15201a968dabc26a22909620bda824bd548fb8c26cc848f704166ed730d958f0173bd3b0a672f367bd +949e445b0459983abd399571a1a7150aab3dd79f4b52a1cd5d733e436c71c1d4b74287c6b0ce6cc90c6711ba4c541586 +858966355dac11369e3b6552f2b381665181693d5a32e596984da3314021710b25a37d8c548b08700eea13d86cb22f21 +974bcbb8d38c5e6518745cc03ad436e585b61f31d705e7e2e5085da9655d768ac4d800904f892c3dab65d6223e3f1fd6 +8092b6506b01308bf6187fde5ebd4fa7448c9a640961ba231be22ac5fa2c7635ef01e8b357722c7695d09b723101ea2a +a5b8ef360bf28533ee17d8cd131fff661d265f609db49599085c0c7d83b0af409a1b5c28e3a5e5d7f8459a368aa121e8 +b031b6d5e3ceab0f0c93314b3b675f55cf18cbc86f70444af266fe39cb22fd7dad75d8c84e07f1c1bfa2cb8283e1361a +93ad489e4f74658320c1cceed0137c023d3001a2c930ed87e6a21dbf02f2eb6ad1c1d8bcb3739c85dcfbecb040928707 +b15e4ec2cdab0d34aec8d6c50338812eb6ecd588cf123a3e9d22a7ca23b5a98662af18289f09e6cdd85a39a2863c945c +b304f71a9717cf40c22073f942618b44bf27cd5e2ed4a386ad45d75b0fcb5a8dafd35158211eaf639495c6f1a651cedb +b82d78d3eaaa7c5101b7a5aae02bd4f002cd5802d18c3abcda0dd53b036661c6d3c8b79e0abe591eab90b6fdc5fef5e3 +abbd1884243a35578b80914a5084449c237ee4e4660c279d1073a4d4217d1b55c6b7e9c087dfd08d94ac1416273d8d07 +92f4b61c62502745e3e198ec29bca2e18696c69dcb914d1f3a73f4998d012b90caf99df46e9bb59942e43cce377fe8fd +906e79df98185820c8208844e1ba6bd86cb96965814b01310bd62f22cbec9b5d379b2ef16772d6fc45a421b60cfd68fe +a0eae2784ef596e2eb270dd40c48d6c508e4394c7d6d08d4cc1b56fde42b604d10ba752b3a80f2c4a737e080ef51b44f +94c084985e276dc249b09029e49a4ef8a369cd1737b51c1772fbb458d61e3fe120d0f517976eba8ffa5711ba93e46976 +83619a0157eff3f480ab91d1d6225fead74c96a6fd685333f1e8e4d746f6273e226bad14232f1d1168a274e889f202f1 +a724fe6a83d05dbbf9bb3f626e96db2c10d6d5c650c0a909415fbda9b5711c8b26e377201fb9ce82e94fa2ab0bf99351 +a8a10c1b91a3a1fa2d7fd1f78a141191987270b13004600601d0f1f357042891010717319489f681aa8a1da79f7f00d5 +a398a2e95b944940b1f8a8e5d697c50e7aa03994a8a640dfad4ea65cfb199a4d97861a3ec62d1c7b2b8d6e26488ca909 +a2eedfe5452513b2a938fffd560798ef81379c5a5032d5b0da7b3bb812addbaad51f564c15d9acbbfc59bb7eddd0b798 +ab31c572f6f145a53e13b962f11320a1f4d411739c86c88989f8f21ab629639905b3eedb0628067942b0dc1814b678ca +ad032736dd0e25652d3566f6763b48b34ea1507922ed162890cd050b1125ec03b6d41d34fccba36ec90336f7cdf788ed +83028a558a5847293147c483b74173eca28578186137df220df747fccd7d769528d7277336ea03c5d9cdd0bc5ae3d666 +ab5d182cd1181de8e14d3ef615580217c165e470b7a094a276b78a3003089123db75c6e1650bf57d23e587c587cd7472 +a4793e089fbdb1597654f43b4f7e02d843d4ab99ee54099c3d9f0bd5c0c5657c90bb076379a055b00c01b12843415251 +98bdc52ee062035356fb2b5c3b41673198ddc60b2d1e546cb44e3bb36094ef3c9cf2e12bbc890feb7d9b15925439d1ea +a4f90cca6f48024a0341bd231797b03693b34e23d3e5b712eb24aba37a27827319b2c16188f97c0636a0c115381dc659 +8888e6c2e4a574d04ba5f4264e77abc24ccc195f1a7e3194169b8a2ceded493740c52db4f9833b3dbf4d67a3c5b252cb +83dc4e302b8b0a76dc0292366520b7d246d73c6aebe1bdd16a02f645c082197bcff24a4369deda60336172cefbcf09af +a4eb2741699febfeb793914da3054337cc05c6fa00d740e5f97cb749ae16802c6256c9d4f0f7297dcdbb8b9f22fc0afa +8b65557d5be273d1cb992a25cfce40d460c3f288d5cb0a54bdef25cbd17cdea5c32ec966e493addf5a74fd8e95b23e63 +97c6577e76c73837bcb398b947cb4d3323d511141e0ddd0b456f59fbb1e8f920a5c20d7827a24309145efddee786140f +abcc0849ffe2a6a72157de907907b0a52deece04cf8317bee6fe1d999444b96e461eac95b6afde3d4fe530344086a625 +9385c0115cb826a49df1917556efa47b5b5e4022b6a0d2082053d498ec9681da904ecf375368bb4e385833116ea61414 +8b868c1841f0cdc175c90a81e610b0652c181db06731f5c8e72f8fafa0191620742e61a00db8215a991d60567b6a81ca +a8df15406f31b8fcf81f8ff98c01f3df73bf9ec84544ddec396bdf7fafa6fe084b3237bf7ef08ad43b26517de8c3cd26 +a9943d21e35464ce54d4cc8b135731265a5d82f9ccf66133effa460ffdb443cdb694a25320506923eede88d972241bf2 +a1378ee107dd7a3abcf269fd828887c288363e9b9ca2711377f2e96d2ed5e7c5ec8d3f1da995a3dcbedf1752d9c088fc +8a230856f9227b834c75bdebc1a57c7298a8351874bf39805c3e0255d6fd0e846f7ad49709b65ec1fd1a309331a83935 +877bcf42549d42610e1780e721f5800972b51ba3b45c95c12b34cb35eeaf7eac8fa752edd7b342411820cf9093fea003 +84c7a0b63842e50905624f1d2662506b16d1f3ea201877dfc76c79181c338b498eceb7cad24c2142c08919120e62f915 +8e18b1bd04b1d65f6ed349b5d33a26fe349219043ead0e350b50ae7a65d6ff5f985dd9d318d3b807d29faa1a7de4fe42 +8ea7b5a7503e1f0b3c3cd01f8e50207044b0a9c50ed1697794048bbe8efd6659e65134d172fb22f95439e1644f662e23 +b1954a2818cad1dad6d343a7b23afa9aa8ad4463edc4eb51e26e087c2010927535020d045d97d44086d76acdb5818cbf +a5271ea85d0d21fa1ff59b027cf88847c0f999bbf578599083ff789a9b5228bc161e1c81deb97e74db1a82a0afd61c50 +aa2fa4c05af3387e2c799315781d1910f69977ec1cfea57a25f1a37c63c4daaa3f0ecd400884a1673e17dd5300853bcf +b1cd2a74ca0b8e6090da29787aef9b037b03b96607983a308b790133bd21297b21ca4e2edec890874096dbf54e9d04c3 +801931607ec66a81272feaa984f0b949ad12d75ecf324ba96627bd4dc5ddead8ebf088f78e836b6587c2b6c0b3366b6c +95d79504710bdf0ad9b9c3da79068c30665818c2f0cdbba02cc0a5e46e29d596032ac984441b429bd62e34535c8d55b0 +9857d41e25e67876510ff8dadf0162019590f902da1897da0ef6fc8556e3c98961edb1eb3a3a5c000f6c494413ded15e +8740c9ffe6bd179c19a400137c3bd3a593b85bd4c264e26b4dfb9e2e17ac73e5b52dfacc1dcb4033cfc0cd04785f4363 +977f98f29d948b4097a4abdf9345f4c1fb0aa94ba0c6bf6faa13b76f3a3efc8f688e1fe96099b71b3e1c05041118c8d1 +a364422b1239126e3e8d7b84953ce2181f9856319b0a29fcab81e17ac27d35798088859c1cfc9fc12b2dbbf54d4f70b3 +a0f6ba637f0db7a48e07439bb92ddb20d590ce9e2ed5bab08d73aa22d82c32a9a370fe934cbe9c08aeb84b11adcf2e0e +a2c548641bd5b677c7748327cca598a98a03a031945276be6d5c4357b6d04f8f40dd1c942ee6ec8499d56a1290ac134d +9863e9cc5fbcdbd105a41d9778d7c402686bfd2d81d9ed107b4fda15e728871c38647529693306855bee33a00d257a7e +a54173bf47b976290c88fd41f99300135de222f1f76293757a438450880e6f13dbde3d5fe7afc687bdfbcfc4fbc1fc47 +b8db413917c60907b73a997b5ab42939abd05552c56a13525e3253eb72b83f0d5cc52b695968a10005c2e2fe13290e61 +a1f8388ef21697c94ba90b1a1c157f0dc138e502379e6fc5dc47890d284563e5db7716266e1b91927e5adf3cde4c0a72 +9949013a59d890eb358eab12e623b2b5edb1acbee238dfad8b7253102abc6173922e188d5b89ec405aa377be8be5f16d +a00fdb7710db992041f6ddb3c00099e1ce311dea43c252c58f560c0d499983a89de67803a8e57baa01ee9d0ee6fa1e44 +a8b1bcbed1951c9cdb974b61078412881b830b48cd6b384db0c00fa68bcc3f4312f8e56c892ea99d3511857ef79d3db9 +8f3ee78404edc08af23b1a28c2012cee0bdf3599a6cb4ea689fc47df4a765ef519191819a72562b91a0fbcdb896a937e +8155bbb7fa8d386848b0a87caae4da3dec1f3dade95c750a64a8e3555166ccc8799f638bd80ed116c74e3a995541587a +abfe30adbc0a6f1fd95c630ed5dac891b85384fa9331e86b83217f29dff0bd7cad19d328485715a7e3df9a19069d4d2f +89d0783e496ee8dbb695764b87fb04cee14d4e96c4ba613a19736971c577d312079048142c12ce5b32b21e4d491d281b +856b8dbc9c5d8f56b6bb7d909f339ca6da9a8787bba91f09130a025ab6d29b64dbf728ba6ed26e160a23c1cdb9bc037b +8a30dd2ea24491141047a7dfe1a4af217661c693edf70b534d52ca547625c7397a0d721e568d5b8398595856e80e9730 +ae7e1412feb68c5721922ed9279fb05549b7ef6812a4fd33dbbbd7effab756ab74634f195d0c072143c9f1fd0e1ee483 +b7ce970e06fa9832b82eef572f2902c263fda29fdce9676f575860aae20863046243558ede2c92343616be5184944844 +85ed0531f0e5c1a5d0bfe819d1aa29d6d5ff7f64ad8a0555560f84b72dee78e66931a594c72e1c01b36a877d48e017ca +b8595be631dc5b7ea55b7eb8f2982c74544b1e5befc4984803b1c69727eac0079558182f109e755df3fd64bee00fcaa5 +99e15a66e5b32468ef8813e106271df4f8ba43a57629162832835b8b89402eb32169f3d2c8de1eb40201ce10e346a025 +844c6f5070a8c73fdfb3ed78d1eddca1be31192797ad53d47f98b10b74cc47a325d2bc07f6ee46f05e26cf46a6433efb +974059da7f13da3694ad33f95829eb1e95f3f3bfc35ef5ef0247547d3d8ee919926c3bd473ab8b877ff4faa07fcc8580 +b6f025aecc5698f6243cc531782b760f946efebe0c79b9a09fe99de1da9986d94fa0057003d0f3631c39783e6d84c7d5 +b0c5358bc9c6dfe181c5fdf853b16149536fbb70f82c3b00db8d854aefe4db26f87332c6117f017386af8b40288d08f9 +a3106be5e52b63119040b167ff9874e2670bd059b924b9817c78199317deb5905ae7bff24a8ff170de54a02c34ff40a4 +ad846eb8953a41c37bcd80ad543955942a47953cbc8fb4d766eac5307892d34e17e5549dc14467724205255bc14e9b39 +b16607e7f0f9d3636e659e907af4a086ad4731488f5703f0917c4ce71a696072a14a067db71a3d103530920e1ec50c16 +8ed820e27116e60c412c608582e9bb262eaaf197197c9b7df6d62b21a28b26d49ea6c8bb77dfde821869d9b58025f939 +97bc25201d98cde389dd5c0c223a6f844393b08f75d3b63326343073e467ac23aacef630ddc68545ea874299ba4a3b4f +b73c9695ad2eefd6cc989a251c433fab7d431f5e19f11d415a901762717d1004bb61e0cc4497af5a8abf2d567e59fef4 +adaabe331eea932533a7cc0cf642e2a5e9d60bbc92dd2924d9b429571cbf0d62d32c207b346607a40643c6909b8727e2 +a7b1bbfe2a5e9e8950c7cb4daab44a40c3ffab01dc012ed7fe445f4af47fa56d774a618fafe332ab99cac4dfb5cf4794 +b4a3c454dcd5af850212e8b9ba5fe5c0d958d6b1cabbf6c6cfe3ccbc4d4c943309c18b047256867daf359006a23f3667 +a5c0b32f6cef993834c1381ec57ad1b6f26ae7a8190dd26af0116e73dadc53bb0eeb1911419d609b79ce98b51fdc33bc +ac2f52de3ecf4c437c06c91f35f7ac7d171121d0b16d294a317897918679f3b9db1cef3dd0f43adb6b89fe3030728415 +94722ae6d328b1f8feaf6f0f78804e9b0219de85d6f14e8626c2845681841b2261d3e6a2c5b124086b7931bf89e26b46 +a841a0602385d17afabca3a1bb6039167d75e5ec870fea60cfcaec4863039b4d745f1a008b40ec07bca4e42cb73f0d21 +8c355f0a1886ffced584b4a002607e58ff3f130e9de827e36d38e57cb618c0cb0b2d2dea2966c461cb3a3887ede9aef1 +a6a9817b0fc2fd1786f5ba1a7b3d8595310987fb8d62f50a752c6bb0b2a95b67d03a4adfd13e10aa6190a280b7ee9a67 +a1d2e552581ecbafeaef08e389eaa0b600a139d446e7d0648ac5db8bbbf3c438d59497e3a2874fc692b4924b87ff2f83 +a1b271c55389f25639fe043e831e2c33a8ba045e07683d1468c6edd81fedb91684e4869becfb164330451cfe699c31a8 +8c263426e7f7e52f299d57d047a09b5eeb893644b86f4d149535a5046afd655a36d9e3fdb35f3201c2ccac2323a9582e +b41c242a7f7880c714241a97d56cce658ee6bcb795aec057a7b7c358d65f809eb901e0d51256826727dc0dc1d1887045 +93001b9445813c82f692f94c0dc1e55298f609936b743cf7aae5ebfa86204f38833d3a73f7b67314be67c06a1de5682d +82087536dc5e78422ad631af6c64c8d44f981c195ddea07d5af9bb0e014cdc949c6fa6e42fce823e0087fdb329d50a34 +8e071861ceba2737792741c031f57e0294c4892684506b7c4a0fc8b2f9a0a6b0a5635de3d1e8716c34df0194d789ae86 +b471c997e1e11774bd053f15609d58838a74073a6c089a7a32c37dd3f933badf98c7e5833263f3e77bc0d156a62dd750 +8d2d8686fb065b61714414bb6878fff3f9e1e303c8e02350fd79e2a7f0555ded05557628152c00166ce71c62c4d2feaa +ae4c75274d21c02380730e91de2056c0262ffcecf0cbdb519f0bdb0b5a10ae2d4996b3dc4b3e16dbaea7f0c63d497fef +97140d819e8ca6330e589c6debdee77041c5a9cedb9b8cbd9c541a49207eeb7f6e6b1c7e736ec8ba6b3ab10f7fcd443a +af6659f31f820291a160be452e64d1293aa68b5074b4c066dac169b8d01d0179139504df867dc56e2a6120354fc1f5be +a5e5d8088a368024617bfde6b731bf9eee35fc362bed3f5dfdd399e23a2495f97f17728fec99ca945b3282d1858aa338 +a59cfc79d15dbdde51ab8e5129c97d3baba5a0a09272e6d2f3862370fdbaf90994e522e8bd99d6b14b3bb2e9e5545c6f +a30499b068083b28d6c7ddcc22f6b39b5ec84c8ee31c5630822c50ea736bb9dca41c265cffc6239f1c9ef2fd21476286 +88ffe103eca84bbe7d1e39a1aa599a5c7c9d5533204d5c4e085402a51441bb8efb8971efe936efbbfa05e5cb0d4b8017 +b202356fbf95a4d699154639e8cb03d02112c3e0128aab54d604645d8510a9ba98936028349b661672c3a4b36b9cb45d +8b89bb6574bf3524473cff1ff743abcf1406bd11fb0a72070ccd7d8fce9493b0069fb0c6655252a5164aee9e446ea772 +93247b1038fa7e26667ee6446561d4882dc808d1015daafb705935ddc3598bb1433182c756465960480f7b2de391649e +b027f94d3358cbb8b6c8c227300293a0dee57bf2fee190a456ad82ecfb6c32f8090afa783e2ab16f8139805e1fb69534 +a18bb1849b2f06c1d2214371031d41c76ffa803ee3aa60920d29dbf3db5fbfac2b7383d5d0080ba29ce25c7baa7c306b +827bf9fd647e238d5ac961c661e5bbf694b4c80b3af8079f94a2484cb8fba2c8cf60e472ebcd0b0024d98ae80ad2ff5a +838e891218c626a7f39b8fd546b013587408e8e366ecc636b54f97fa76f0a758bc1effa1d0f9b6b3bc1a7fcc505970a0 +836523b5e8902d6e430c6a12cff01e417d2bd7b402e03904034e3b39755dee540d382778c1abe851d840d318ebedce7f +850a77dda9ac6c217e2ef00bf386a1adec18b7f462f52801c4f541215690502a77ef7519b690e22fdf54dc2109e0ca38 +a8265c6ae7b29fc2bda6a2f99ced0c1945dd514b1c6ca19da84b5269514f48a4f7b2ccbab65c9107cfd5b30b26e5462f +ab3d02ee1f1267e8d9d8f27cc388e218f3af728f1de811242b10e01de83471a1c8f623e282da5a284d77884d9b8cde0e +831edaf4397e22871ea5ddee1e7036bab9cc72f8d955c7d8a97f5e783f40532edbbb444d0520fefcffeab75677864644 +80484487977e4877738744d67b9a35b6c96be579a9faa4a263e692295bb6e01f6e5a059181f3dd0278e2c3c24d10a451 +aae65a18f28c8812617c11ecf30ad525421f31fb389b8b52d7892415e805a133f46d1feca89923f8f5b8234bd233486a +b3a36fd78979e94288b4cefed82f043a7e24a4a8025479cc7eb39591e34603048a41ee606ee03c0b5781ebe26a424399 +b748b3fc0d1e12e876d626a1ba8ad6ad0c1f41ea89c3948e9f7d2666e90173eb9438027fadcd741d3ae0696bd13840f1 +acdd252d7c216c470683a140a808e011c4d5f1b4e91aeb947f099c717b6a3bad6651142cde988330827eb7d19d5fb25c +b9a25556a6ca35db1ed59a1ec6f23343eab207a3146e4fc3324136e411c8dba77efd567938c63a39c2f1c676b07d8cdb +a8db6aef8f5680d2bdb415d7bcaae11de1458678dcb8c90c441d5986c44f83a9e5855662d0c1aace999172d8628d8fe1 +af58147108e9909c3a9710cc186eab598682dca4bfd22481e040b8c000593ecb22c4ede4253ac9504e964dfa95a9b150 +8dd8bb70f1c9aec0fcc9478f24dfc9c3c36c0bf5ff7a67c017fa4dab2ec633fbd7bc9d8aa41ea63e2696971ed7e375f5 +aa98d600b22aff993a4d7a3ccabd314e1825b200cb598f6b797d7e4d6a76d89e34a4d156c06bddfc62f2ef9b4c809d1d +8a8fc960d6c51294b8205d1dabe430bef59bda69824fa5c3c3105bef22ac77c36d2d0f38ffc95ce63731de5544ccbeff +b6d1020efe01dc8032bd1b35e622325d7b9af9dcd5c9c87c48d7d6ebc58644454294c59b7f4b209204b5b1f899f473bf +8a750dc9fe4891f2dfe5759fb985939810e4cdc0b4e243ff324b6143f87676d8cb4bcb9dfb01b550801cedcaaa5349e2 +98c13142d3a9c5f8d452245c40c6dae4327dd958e0fda85255ea0f87e0bcbaa42a3a0bd50407ed2b23f9f6317a8a4bc5 +99f2b83d9ec4fc46085a6d2a70fd0345df10f4a724c1ba4dee082a1fde9e642e3091992ebf5f90a731abcb6ec11f6d9b +b218546ab2db565b2489ea4205b79daa19ef2acbf772ccaaa5e40150e67ea466090d07198444b48e7109939aa2319148 +84f9d1d868e4b55e535f1016558f1789df0daa0ead2d13153e02f715fe8049b1ce79f5bc1b0bbbb0b7e4dd3c04783f3f +80d870d212fbddfdda943e90d35a5a8aa0509a7a1e7f8909f2fcb09c51c3026be47cc7a22620a3063406872105b4f81a +b5b15138ff6551fac535d4bbce2ea6adc516b6b7734b4601c66ec029da2615e3119dc9ad6a937344acfd7b50e4a1a2ae +95d2f97652086e7ceb54e1d32692b1c867ffba23c4325740c7f10d369283d1b389e8afa0df967831ade55696931e7934 +8a5b580403e1a99cd208f707e8ce0d3f658c8280417683f69008d09cc74d835a85f7380f391b36ead9ac66d9eedd1cbe +a8b0c90bff34c86720637b5a2081f0f144cfe2205c1176cacd87d348609bc67af68aed72414dc9aa6f44a82c92c2a890 +865abbdd96c496892c165a8de0f9e73348bf24fce361d7a9048710178a3625881afb0006e9f5ee39124866b87904c904 +ace67bb994adef4b6f841cdf349195608030044562780a7e9b00b58a4ff117268a03ff01e5a3a9d9d7eff1dd01f5f4bf +b9371d59185b3d2d320d3fefeadb06ba2aa7d164352fb8dc37571509509fa214d736d244ac625a09a033a10d51611e2e +a8ef992771422dcf2d6d84386fde9fe5dba88bfded3dfcd14074ca04331b4fd53a7f316615cdfaf10ed932cbb424a153 +868cbc75f8f789ea45eded2768a1dac0763347e0d8e8028d316a21005f17be179d26d5965903e51b037f2f57fe41765d +b607111bcdfd05fa144aa0281b13ee736079ebbbf384d938a60e5e3579639ed8ef8eb9ca184868cdb220a8e130d4a952 +aca55702af5cae4cae65576769effd98858307a71b011841c563b97c2aa5aeb5c4f8645d254f631ed1582df3dbbf17da +b9b5cbace76246e80c20dfcc6f1e2c757a22ab53f7fd9ff8a1d309538b55174e55e557a13bf68f095ff6a4fa637ef21a +8571b0a96871f254e2397c9be495c76379faf347801cb946b94e63212d6a0da61c80e5d7bebbabcd6eaa7f1029172fe5 +902540326281e6dc9c20d9c4deaaf6fbbbcc3d1869bd0cf7f081c0525bea33df5cfa24ead61430fda47fb964fcc7994b +841af09279d3536a666fa072278950fabf27c59fc15f79bd52acb078675f8087f657929c97b4bc761cbade0ecb955541 +a1f958b147ddf80ab2c0746ba11685c4bae37eb25bfa0442e7e1078a00d5311d25499da30f6d168cb9302ea1f2e35091 +863d939381db37d5a5866964be3392a70be460f0353af799d6b3ed6307176972686bd378f8ad457435a4094d27e8dfb7 +835cd4d7f36eff553d17483eb6c041b14280beb82c7c69bca115929658455a1931212976c619bafb8179aed9940a8cc6 +8d0770e3cb8225e39c454a1fc76954118491b59d97193c72c174ecc7613051e5aed48a534016a8cf0795c524f771a010 +91aa4edb82f6f40db2b7bd4789cc08786f6996ebed3cb6f06248e4884bc949793f04a4c5ea6eefe77984b1cc2a45d699 +8fb494ca2449f659ff4838833507a55500a016be9293e76598bbae0a7cb5687e4693757c2b6d76e62bd6c7f19ed080bb +b59b104449a880a282c1dd6a3d8debb1d8814ef35aab5673c1e500ee4cb0e840fb23e05fa5a0af92509c26b97f098f90 +aca908e3bad65e854ae6be6c5db441a06bcd47f5abafdfa8f5a83c8cd3c6e08c33cab139c45887887a478338e19ceb9f +806f5d802040313a31964fc3eb0ee18ac91b348685bed93c13440984ee46f3d2da7194af18c63dea4196549129660a4e +ae4b2dca75c28d8f23b3ab760b19d839f39ff5a3112e33cb44cff22492604a63c382b88ec67be4b0266924dd438c3183 +99d1c29c6bd8bf384e79cd46e30b8f79f9cbc7d3bf980e9d6ffba048f0fc487cac45c364a8a44bb6027ad90721475482 +a16e861c1af76d35528c25bf804bfc41c4e1e91b2927d07d8e96bffe3a781b4934e9d131ecf173be9399800b8269efac +a253303234fb74f5829060cdcef1d98652441ab6db7344b1e470d195a95722675988048d840201c3b98e794b1e8b037c +905ac8a0ea9ce0eb373fb0f83dd4cbe20afb45b9d21ae307846fd4757d4d891b26a6711924e081e2b8151e14a496da18 +b485315791e775b9856cc5a820b10f1fa5028d5b92c2f0e003ba55134e1eddb3eb25f985f2611a2257acf3e7cfdfab5e +b6189c0458b9a043ebc500abc4d88083a3487b7ac47ed5e13ab2a41e0a1bee50d54a406063f92bc96959f19e822a89a7 +a30e15f995fd099a223fc6dc30dad4b8d40bee00caa2bc3223ba6d53cd717c4968a3e90c4618c711ed37cc4cd4c56cf3 +a1b1ed07fcc350bb12a09cd343768d208fc51a6b3486f0ece8f5a52f8a5810b4bc7ab75582ec0bc2770aed52f68eace5 +88aa739fbae4bece147ba51a863e45d5f7203dbc3138975dc5aef1c32656feb35f014d626e0d5b3d8b1a2bda6f547509 +ab570f3c8eabfca325b3a2ea775ef6b0c6e6138c39d53c2310329e8fb162869fde22b0e55688de9eb63d65c37598fca3 +89d274762c02158e27cb37052e296a78f2b643eb7f9ae409f8dac5c587d8b4d82be4ef7c79344a08ebec16ac4a895714 +99c411d2ad531e64f06e604d44c71c7c384424498ecd0a567d31ec380727fb605af76643d0d5513dd0a8d018076dd087 +80d0777fa9f79f4a0f0f937d6de277eec22b3507e2e398f44b16e11e40edf5feff55b3b07a69e95e7e3a1621add5ed58 +b2430a460783f44feb6e4e342106571ef81ad36e3ddd908ec719febeb7acaf4b833de34998f83a1dab8f0137a3744c11 +b8f38ccfc7279e1e30ad7cefc3ea146b0e2dff62430c50a5c72649a4f38f2bac2996124b03af2079d942b47b078cc4f8 +a178a450a62f30ec2832ac13bbc48789549c64fc9d607b766f6d7998558a0e2fad007ae0148fc5747189b713f654e6ba +98c5ede296f3016f6597f7ccc5f82c88fd38ed6dc3d6da3e4a916bfd7c4c95928722a1d02534fe89387c201d70aa6fd2 +a8cc5e98573705d396576e022b2ba2c3e7c7ece45cd8605cb534b511763682582299e91b4bb4100c967019d9f15bbfaf +848480ea7b7d9536e469da721236d932870b7bbee31ccf7ae31b4d98d91413f59b94a1e0d1786ee7342295aa3734969c +b88ea38f9ee432f49e09e4e013b19dff5a50b65453e17caf612155fff6622198f3cba43b2ea493a87e160935aaaf20a9 +949376934a61e0ef8894339c8913b5f3b228fa0ae5c532ad99b8d783b9e4451e4588541f223d87273c0e96c0020d5372 +96f90bb65ca6b476527d32c415814b9e09061648d34993f72f28fae7dc9c197e04ef979f804076d107bb218dfd9cb299 +a4402da95d9942c8f26617e02a7cef0ebc4b757fac72f222a7958e554c82cc216444de93f659e4a1d643b3e55a95d526 +81179cbc26a33f6d339b05ea3e1d6b9e1190bd44e94161ae36357b9cdf1e37d745d45c61735feed64371fe5384102366 +ad4dc22bdbd60e147fdac57d98166de37c727f090059cfc33e5ee6cf85e23c2643996b75cf1b37c63f3dc9d3c57ffa18 +8a9b1b93dc56e078ce3bb61c2b0088fd6c3e303ba6b943231cc79d4a8e8572f4109bbde5f5aa7333aae3287909cb0fe2 +8876ef583bc1513322457a4807d03381ba1f4d13e179260eaa3bddfede8df677b02b176c6c9f74c8e6eab0e5edee6de6 +b6c67e228bf190fbaeb2b7ec34d4717ce710829c3e4964f56ebb7e64dc85058c30be08030fa87cc94f1734c5206aef5f +a00cb53b804ee9e85ce12c0103f12450d977bc54a41195819973c8a06dcb3f46f2bf83c3102db62c92c57ab4dd1e9218 +a7675a64772eefddf8e94636fb7d1d28f277074327c02eea8fae88989de0c5f2dc1efed010f4992d57b5f59a0ab40d69 +8d42bb915e0bf6a62bcdf2d9330eca9b64f9ec36c21ae14bf1d9b0805e5e0228b8a5872be61be8133ad06f11cb77c363 +a5b134de0d76df71af3001f70e65c6d78bed571bc06bfddf40d0baad7ea2767608b1777b7ef4c836a8445949877eeb34 +aeadbc771eaa5de3a353229d33ed8c66e85efbd498e5be467709cb7ff70d3f1a7640002568b0940e3abd7b2da81d2821 +8c28da8e57a388007bd2620106f6226b011ee716a795c5d9f041c810edf9cf7345b2e2e7d06d8a6b6afa1ee01a5badc1 +8ed070626a4d39ffd952ddb177bc68fd35b325312e7c11694c99b691f92a8ea7734aeb96cf9cc73e05b3c1b1dcad6978 +ada83e18e4842f3d8871881d5dbc81aed88a1328298bfdc9e28275094bd88d71b02e7b8501c380fa8d93096cbc62f4fb +8befc3bec82dcf000a94603b4a35c1950ba5d00d4bed12661e4237afa75062aa5dcef8eac0b9803136c76d2dd424a689 +97c6f36c91ca5ca9230bfcbf109d813728b965a29b62e5f54c8e602d14a52ac38fa1270de8bfe1ab365426f3fc3654c7 +b01d192af3d8dbce2fe2fece231449e70eb9ac194ec98e758da11ca53294a0fa8c29b1d23a5d9064b938b259ea3b4fb5 +819a2c20646178f2f02865340db1c3c6ebc18f4e6559dd93aa604388796a34bd9fed28ad3ccc8afc57a5b60bb5c4e4ec +a9ffc877470afc169fecf9ec2dc33253b677371938b0c4ffa10f77bb80089afa2b4488437be90bb1bcf7586a6f4286e3 +b533051c7ce7107176bcb34ad49fdb41fac32d145854d2fe0a561c200dcf242da484156177e2c8f411c3fdf1559ecf83 +8fe2caff2e4241d353110a3618832f1443f7afe171fd14607009a4a0aa18509a4f1367b67913e1235ac19de15e732eb1 +84705c6370619403b9f498059f9869fdf5f188d9d9231a0cb67b1da2e8c906ead51b934286497293698bba269c48aa59 +899dddf312a37e3b10bdaaacc1789d71d710994b6ee2928ac982ad3fd8a4f6167672bc8bf3419412711c591afe801c28 +b2f7916d946b903ded57b9d57025386143410a41a139b183b70aeca09cf43f5089ead1450fce4e6eb4fba2c8f5c5bbe5 +8d5f742fe27a41623b5820914c5ca59f82246010fa974304204839880e5d0db8bc45ebab2ad19287f0de4ac6af25c09e +b93d4a1f6f73ac34da5ffbd2a4199cf1d51888bc930dc3e481b78806f454fcb700b4021af7525b108d49ebbbaa936309 +8606f8d9121512e0217a70249937e5c7f35fbfe019f02248b035fa3a87d607bc23ae66d0443e26a4324f1f8e57fd6a25 +b21312cdec9c2c30dd7e06e9d3151f3c1aceeb0c2f47cf9800cce41521b9d835cb501f98b410dc1d49a310fdda9bc250 +a56420b64286bdddda1e212bba268e9d1ba6bdb7132484bf7f0b9e38099b94a540884079b07c501c519b0813c184f6b4 +80b2cf0e010118cb2260f9c793cef136f8fa7b5e2711703735524e71d43bce2d296c093be41f2f59118cac71f1c5a2ff +adcb12d65163804d2f66b53f313f97152841c3625dbbda765e889b9937195c6fcd55d45cc48ebffabb56a5e5fe041611 +8b8a42e50dc6b08ab2f69fc0f6d45e1ea3f11ba0c1008ee48448d79d1897356599e84f7f9d8a100329ed384d6787cfc4 +aaa9c74afa2dec7eccfbd8bb0fc6f24ed04e74c9e2566c0755a00afdfdf3c4c7c59e2a037ec89c2f20af3fae1dd83b46 +aa9f6e8fd59187171c6083ae433627d702eb78084f59010ff07aff8f821f7022ef5fbbe23d76814d811b720a8bfa6cc3 +a56a3ded501659ad006d679af3287080b7ee8449e579406c2cae9706ef8bf19c1fc2eb2a6f9eaf2d3c7582cded73e477 +81971e077c1da25845840222b4191e65f6d242b264af4e86800f80072d97d2a27a6adc87c3a1cb1b0dd63d233fbafa81 +a6fa5453c4aaad2947969ee856616bf6448224f7c5bf578f440bcfc85a55beb40bef79df8096c4db59d1bd8ef33293ea +87c545adbfaaf71e0ab4bac9ae4e1419718f52b0060e8bb16b33db6d71b7248ae259d8dd4795b36a4bbb17f8fae9fd86 +b4c7a9bc0910e905713291d549cec5309e2d6c9b5ea96954489b1dff2e490a6c8b1fa1e392232575f0a424ba94202f61 +802350b761bcaba21b7afe82c8c6d36ee892b4524ab67e2161a91bbfa1d8e92e7e771efb1f22c14126218dd2cb583957 +b4e7ddb9143d4d78ea8ea54f1c908879877d3c96ee8b5e1cb738949dcfceb3012a464506d8ae97aa99ea1de2abf34e3d +a49a214065c512ad5b7cc45154657a206ef3979aa753b352f8b334411f096d28fd42bca17e57d4baaafb014ac798fc10 +8a80c70a06792678a97fe307520c0bf8ed3669f2617308752a2ab3c76fdf3726b014335a9b4c9cbcfc1df3b9e983c56f +a34721d9e2a0e4d08995a9d986dc9c266c766296d8d85e7b954651ad2ca07e55abb1b215898ee300da9b67114b036e0d +8cfce4564a526d7dca31e013e0531a9510b63845bbbd868d5783875ed45f92c1c369ce4a01d9d541f55f83c2c0a94f03 +ab3f5f03a5afc727778eb3edf70e4249061810eba06dc3b96b718e194c89429c5bfbec4b06f8bce8a2118a2fdce67b59 +aa80c2529fc19d428342c894d4a30cb876169b1a2df81a723ab313a071cba28321de3511a4de7846207e916b395abcc9 +82b7828249bf535ef24547d6618164b3f72691c17ca1268a5ee9052dba0db2fdd9987c8e083307a54399eab11b0f76b1 +8fbcb56b687adad8655a6cf43364a18a434bf635e60512fad2c435cf046f914228fb314f7d8d24d7e5e774fb5ffb1735 +a3010a61a2642f5ebbce7b4bc5d6ecb3df98722a49eb1655fe43c1d4b08f11dfad4bcec3e3f162d4cc7af6a504f4d47c +b3dcc0fdf531478e7c9ef53190aa5607fd053a7d2af6c24a15d74c279dbb47e3c803a1c6517d7e45d6534bb59e3527f5 +8648f6316c898baaca534dff577c38e046b8dfa8f5a14ee7c7bc95d93ae42aa7794ba0f95688a13b554eeb58aeedf9ba +89fca6fc50407695e9315483b24f8b4e75936edf1475bcf609eed1c4370819abac0e6a7c3c44f669560367d805d9ba63 +a367a17db374f34cd50f66fb31ba5b7de9dbe040f23db2dcc1d6811c0e863606f6c51850af203956f3399000f284d05f +91030f9ca0fff3e2dbd5947dcf2eba95eb3dbca92ee2df0ed83a1f73dbf274611af7daf1bb0c5c2ee46893ab87013771 +84d56181f304ce94015ea575afeef1f84ea0c5dbb5d29fb41f25c7f26077b1a495aff74bd713b83bce48c62d7c36e42d +8fe2f84f178739c3e2a2f7dcac5351c52cbed5fa30255c29b9ae603ffd0c1a181da7fb5da40a4a39eec6ce971c328fcf +a6f9b77b2fdf0b9ee98cb6ff61073260b134eb7a428e14154b3aa34f57628e8980c03664c20f65becfe50d2bdd2751d4 +8c6760865445b9327c34d2a1247583694fbeb876055a6a0a9e5cb460e35d0b2c419e7b14768f1cc388a6468c94fd0a0f +af0350672488a96fe0089d633311ac308978a2b891b6dbb40a73882f1bda7381a1a24a03e115ead2937bf9dcd80572ad +a8e528ec2ee78389dd31d8280e07c3fdd84d49556a0969d9d5c134d9a55cd79e1d65463367b9512389f125ed956bc36a +942c66589b24f93e81fe3a3be3db0cd4d15a93fb75260b1f7419f58d66afaa57c8d2d8e6571536790e2b415eec348fd9 +83fe4184b4b277d8bf65fb747b3c944170824b5832751057e43465526560f60da6e5bbee2f183cb20b896a20197168c7 +88a71aada494e22c48db673d9e203eef7a4e551d25063b126017066c7c241ee82bedaa35741de4bd78a3dd8e21a8af44 +8c642a3186ca264aac16ee5e27bd8da7e40e9c67ae159b5d32daa87b7de394bf2d7e80e7efb1a5506c53bfd6edd8c2c3 +81855d6de9a59cef51bef12c72f07f1e0e8fe324fcc7ec3f850a532e96dcd434c247130610aaee413956f56b31cbb0dc +a01e61390dcd56a58ad2fcdb3275704ddfbedef3ba8b7c5fce4814a6cdd03d19d985dba6fd3383d4db089444ea9b9b4d +96494e89cbf3f9b69488a875434302000c2c49b5d07e5ff048a5b4a8147c98291ae222529b61bb66f1903b2e988e5425 +b9689b3e8dddc6ec9d5c42ba9877f02c1779b2c912bba5183778dc2f022b49aed21c61c8ec7e3c02d74fe3f020a15986 +a2a85e213b80b0511395da318cbb9935c87b82c305f717a264155a28a2ea204e9e726bae04ce6f012e331bd6730cbb9d +91b70f44c7d8c5980ce77e9033a34b05781cbe773854d3f49d2905cc711a3d87c20d5d496801ad6fd82438874ce732b8 +884596417ff741bb4d11925d73852ffeea7161c7f232be3bdce9e6bbe7884c3a784f8f1807356ae49d336b7b53a2b495 +ae2aed8ab6951d8d768789f5bc5d638838d290d33ccc152edfb123e88ba04c6272b44294b0c460880451ad7b3868cc6a +89d8ebfb9beebc77189d27de31c55f823da87798a50bca21622cbf871e5d9f1d3182cf32ee9b90f157e6ce298e9efccf +afd00a4db4c2ed93cf047378c9402914b6b3255779f3bb47ded4ab206acb7eaebba0fd7762928e681b1aebcfee994adc +a2e49b6cd32e95d141ebc29f8c0b398bb5e1a04945f09e7e30a4062142111cd7aa712ac0e3e6394cfb73dd854f41ad77 +ae8e714ab6e01812a4de5828d84060f626358bb2b955f6fb99ae887b0d5ce4f67ebc079ab9e27d189bf1d3f24f7c2014 +a3100c1eebf46d604e75ebf78569c25acf938d112b29ccbe1a91582f6bd8ef5548ae3961c808d3fb73936ac244e28dbc +a9a02dcff0e93d47ead9cdddc4759971c2d848580bf50e117eb100cafca6afeaa7b87208513d5f96b1e1440ffc1b0212 +894ab01462137e1b0db7b84920a3b677fbb46c52b6f4c15320ef64f985e0fc05cec84cd48f389ce039779d5376966ea3 +b1e40e8399ee793e5f501c9c43bde23538e3ce473c20a9f914f4a64f5b565748d13ab2406efe40a048965ee4476113e4 +a5a7d97a19e636238968670a916d007bf2ce6ae8e352345d274101d0bbe3ac9b898f5b85814a7e4c433dd22ac2e000ff +b6394c43b82923231d93fd0aa8124b757163ba62df369898b9481f0118cb85375d0caac979a198ece432dbb4eb7cc357 +82d522ae3ff4fe2c607b34b42af6f39c0cf96fcfe1f5b1812fca21c8d20cece78376da86dcbd6cdb140e23c93ae0bcb2 +b6e0d986383bc4955508d35af92f2993e7e89db745f4525948c5274cfd500880cb5a9d58a5b13d96f6368bb266a4433e +b0b4325772ec156571d740c404e1add233fb693579f653b0fae0042b03157d3b904838f05c321d2d30f2dbd27c4d08ad +ac41367250263a2099006ef80c30bac1d2f25731d4874be623b6e315c45b0dc9a65f530fce82fb3dc25bd0610008c760 +b6c0b1ed7df53da04a6f3e796d3bfa186f9551c523bc67898bc0ecfc6b4a4a22f8c4d3bfc740ebf7b9fa5b0ea9431808 +8e78fca17346601219d01e5cd6a4837161a7c8f86fe2a8d93574d8006da5f06ae7c48eea7d2b70992c2a69184619663c +a21f91f47e04fafbfafacf3185b6863766a2d0c324ccac2c3853a4748af5897dbbe31d91473b480f646121339c9bae2d +a464d68786ab1fc64bd8734fce0be6fbe8dc021d3e771ff492ada76eedff466577c25e282b7c8ab4c1fd95ef5ff3631e +829a24badc7714081e03509ccfb00818ce40430682c1c0e4a399cd10b690bda1f921aabcbf1edfb1d8a2e98e6c0cedd6 +87ccf7e4bbcb818ef525435e7a7f039ecbb9c6670b0af163173da38cbdb07f18bc0b40b7e0c771a74e5a4bc8f12dfe2c +94087bd2af9dbeb449eb7f014cfbf3ee4348c0f47cde7dc0ad401a3c18481a8a33b89322227dee0822244965ae5a2abb +896b83ed78724dac8a3d5a75a99de8e056a083690152c303326aa833618b93ef9ec19ab8c6ef0efe9da2dbcccac54431 +821e6a0d7ccf3c7bd6a6cc67cde6c5b92fb96542cb6b4e65a44bbc90bbc40c51ff9e04702cb69dd2452f39a2ff562898 +b35b2096cda729090663a49cb09656c019fef1fc69a88496028d3a258ad2b3fd6d91ab832163eaa0077989f647e85e7e +b7857ef62c56d8bce62476cdb2ab965eddff24d932e20fc992bd820598686defe6cc0a7232d2be342696c2990d80721a +b343d974dfda3f6589043acd25d53aecf7c34b1e980ae135a55cda554ff55e531bc7c2dfe89b0d2c30e523c7b065dad1 +8d139e16a73cd892b75f3f4e445a10d55d1118f8eeafc75b259d098338419e72e950df6ca49cb45677a3c4e16fb19cdc +817b8535bd759da392b2c5760c51b3952ecf663662a137c997f595c533cd561ed7e655673c11144242160e41d1f2dd71 +817ee0f0819b0ccb794df17982d5b4332abff5fec5e23b69579db2767855642156d9b9acccf6ceab43332ccc8d2744dc +9835d2b652aec9b0eba0c8e3b6169567e257a6a3f274ec705dbc250ee63f0f8e4b342e47b9e0c280c778208483d47af8 +b78c40177f54f0e6d03083a4f50d8e56b5aafdb90f1b047bb504777d6e27be5a58170330aee12fbaa5f1e9d4f944acfc +ab8eebacf3806fac7ab951f6a9f3695545e2e3b839ca399a4ef360a73e77f089bb53d3d31dbd84ddfde55e5f013626e0 +96c411fc6aecca39d07d2aff44d94b40814d8cfc4ee5a192fd23b54589b2801694d820a0dd217e44863ccff31dda891b +8249c424a0caf87d4f7ff255950bbc64064d4d1b093324bfe99583e8457c1f50e6996e3517bf281aa9b252c2a7c5a83a +acf6ed86121821a3dd63f3875b185c5ebe024bdb37878c8a8d558943d36db0616545a60db90789c0925295f45d021225 +a37f155621a789f774dd13e57016b8e91b3a2512b5c75377ec8871b22a66db99655d101f57acaecd93115297caabfc21 +92e60ee245bd4d349f1c656e034b1a7f0c6415a39ac4c54d383112734305488b3b90b0145024255735e0a32f38dba656 +acec614e562ccfc93366309cfdc78c7d7ee0a23e3a7782a4fc4807b8803e6ebfb894a489d03e9a3c817ff2ec14813eba +b912f9dd26ed552cb14b007b893e6ed2494d12517e5761dbeb88521270144f8c3eb9571a0ad444b30a8a65e80bd95996 +8375408dae79c547a29e9a9e5d4ec8241b36b82e45e4ca3b0c36d2227c02d17bb171528d3778eac3bbdc75d6c4e8a367 +8c2d0e6e4406836da112edbbb63996408bb3cda4a2712fd245e4bb29a0100fdc89a2746d859b84a94565bc1cfa681813 +a7431bf59e111c072d28c97626cd54fcdf018421d053a787d2aef454b91251ee8ff9d3702d06b088f92b9ad2bbebff15 +8f3659b0fbeb90b7f30b7a49233325e806551a32911a654dca86e290b314483bbb33fe6482387bc48c35d85c1dd0441c +8dca5ba23f0bb76f7dacabf12886053552ba829a72827b472a2f01e19a893155cdce65f1fb670000f43e8c75ba015a31 +8c1514c083c77624eeb5d995d60994a2866192e15c4474d0be4189fae0e9dbd62494ebb4c02fbc176b53be548abbc5a1 +80498d2ed153381baf3b0f81da839ed0eea6af5796c422b8e59be805dba48c4395bb97824ac308170bb4f14f319c5ddf +84f5ebc3bf96362457993e9fa31493c31c4283075e2403f63d581b6b0db8a3df294b2085643f2007f4de38cb5d627776 +958e6e38774da518193a98397978dbc73d1c3827b4996ec00b4183da2c305a187a0ada9aa306242814b229a395be83c9 +ab8b8fbf73845615e7fab3e09e96cc181159eab09f36b4c1239b3c03313c9aeb4bbb51e16316fe338b2319ed2571b810 +977e4e33b33bd53394e591eba4f9a183e13704c61e467d74b28f4ad0b69aa51501a5221cb1e0e42bcb548ca518caa619 +a9bb7ecb9846cc30d04aad56d253c3df7004cebb272f6adf7b40a84adef9f57291e0d08d64c961b9fc406cdb198aab9b +8d2b72dc36406a545a9da44e1fddfb953d4894710ca026d6421a4ac91e02d0373a599f2acfe41d8258bc9679cf6f43d3 +904192fc8fe250f61ecb8a36abbbccae85f592bbf00c10039c30b5a1c733d752a04e4fd8a1000c6578616f8a16aa83a3 +87f5fdfe20bbbf931b529ec9be77bbfcc398cad9d932d29f62c846e08a91d2f47ae56ad5345122d62a56f629f9a76c4d +84cc3a53b2e7b7e03015f796b6cb7c32d6ded95c5b49c233ac27fafa792994b43c93cda6e618b66fce381f3db69838ba +aab58da10d7bbe091788988d43d66a335644f3d0897bbc98df27dcc0c0fcee0ac72e24f1abdd77e25196a1d0d0728e98 +a10ea8677c2b7da563d84aa91a314a54cab27bb417c257826ebdd3b045d2a0f12729fe630bbbf785d04874f99f26bee8 +acc4970ef2a4435937a9b8a5a5a311226ca188d8f26af1adfcd6efb2376a59155b9a9ff1cff591bde4b684887d5da6e5 +8dc7cf6fcca483c44eb55e7fb924bf3f76cf79b411ae4b01c6c968910877ac9c166b71350f4d935f19bdffb056477961 +ac2dd1182ded2054c2f4dbf27b71a0b517fb57193733a4e4e56aca8a069cff5078ffd3fd033683d076c1c639a4de63c7 +932ec87c450cd0dc678daf8c63cd1bf46124fa472934e517fbbfb78199f288ff7f354b36e0cc6c8739d3f496cfe0913b +b0d631ced213e8492be60ea334dbe3b7799b86d85d5e8e70d02beef3ae87b1d76e1df3bdb5f7ba8a41904c96f6a64455 +929d7239ead7575867e26b536b8badf2e11ca37840034d0e5c77039f8cce122eff5a1bf6e0bcadde6b3858e9f483d475 +aaae5d372d02ee25b14de585af6fbc48f2c7cd2a6af4f08352951b45aa469599eff41e820df642ca1a0f881120e89dbe +b23c411741a6b059f04fa4f5fd9dd10e2a64915f2de6ea31e39c32f2f347a776a953320e5f7613fcb1167efe502f5c5c +a4581b0ae633fe29c6f09928e5efb16db019eeac57f79fef2fa1d3c9bee42ce0e852bc60b9d0133265373747e52a67a4 +81b33afffd7b2575d4a9a1c5dd6eee675c084f82e06b9b3a52a3c9f76e087f12dca6e0ffddc42fb81ce1adb559d47a38 +89cc890f06b424591556aabdfdbb36d7a23700425e90c9cfed7d3da226b4debe414ac5bdf175273828ce6c5355712514 +a4399438be75cfae2bf825496704da5ed9001bed8538d8ac346c8cf0d4407808e9ee67573eb95fe1c6872ac21f639aaa +ad537f7ce74a1ca9a46fc06f15c1c8a6c32363bd6ac78a3c579ed8f84252e38a914cac16709fe65360e822ef47896de4 +8e53b69f5e3e86b86299452e20ea8068b49565d0d0ab5d50ce00158a18403ae44e1b078a3cfd3f919aa81eb049a30c6e +a59f2542c67a430fd3526215c60c02353ee18af2ff87cb6231a2564fe59b8efec421f18d8b8cc7f084675ecf57b3fd05 +b8d9bac93ef56cb4026dd1c731d92260a608fd55b8321e39166678e1dab834d0efddb717685da87786caeb1aaf258089 +aa2df56f4c6fe9e0f899116c37302675f796a1608338700f05a13e779eb7cf278e01947864a8c2c74cc9d9a763804446 +b0108ff2e327dcb6982961232bf7a9a0356d4297902f4b38d380ff1b954bfbcae0093df0f133dd9e84d5966c7b1aada7 +b06b813b01fe7f8cf05b79dc95006f0c01d73101583d456278d71cd78638df2b1115897072b20947943fa263ddab0cd6 +aa41e6c4d50da8abf0ea3c3901412fe9c9dff885383e2c0c0c50ed2f770ada888a27ea08bbb5342b5ff402e7b1230f12 +a48635dbb7debac10cb93d422c2910e5358ba0c584b73f9845028af4a763fd20da8f928b54b27782b27ca47e631ebf38 +80a574c208e994799e4fa9ef895163f33153bc6487491d817c4049e376054c641c4717bda8efbeb09152fa421a7268a7 +b592bfd78ae228afc219c186589b9b0b5c571e314976d1ed5c1642db9159d577679a73c049cfc3dcfefcd5a4f174eeea +aa1f08af3918c61eadf567a5b1a3cdcdfb1b925f23f1f9e3c47889762f4d979d64686ce1ce990055ef8c1030d98daa3b +857df4cfd56d41c6d0c7fcc1c657e83c888253bae58d33b86e0803a37461be5a57140a77fb4b61108d1d8565091ada1c +8fae66a72361df509d253012a94160d84d0b2260822c788927d32fd3c89500500908c8f850ef70df68ddaeb077fd0820 +aa1dbefc9aef1e7b896ff7303837053c63cfb5c8a3d8204680d3228ac16c23636748fe59286468c99699ae668e769a0c +b64b1cb2ba28665ed10bad1dddc42f3f97383c39bad463c6615b527302e2aaf93eb6062946d2150bd41c329697d101be +b6d35e3b524186e9065cee73ea17c082feff1811b5ab5519dd7991cdff2f397e3a79655969755309bd08c7d5a66f5d78 +a4dae7f584270743bbba8bb633bdb8bc4dcc43580e53d3e9e509ff6c327e384f14104b5bdfe5c662dc6568806950da37 +aae84d3d9ad4e237b07c199813a42ed2af3bf641339c342d9abf7ebec29b5bd06249c4488ce5c9277d87f7b71b3ddd37 +b82a463cf643821618a058bddf9f2acb34ac86a8de42a0fa18c9626e51c20351d27a9575398a31227e21e291b0da183e +8b6c921e8707aded3ea693f490322971b1a7f64786ef071bc9826c73a06bd8ae6bf21bc980425769627b529d30b253ce +80724937b27fc50f033c11c50835c632369f0905f413b1713a2b0a2274bec5d7a30438e94193d479ba6679dbe09a65ef +a1d9b259a2ca9cff8af6678b3af0a290c2f51e9cf26d5fe3c6a4fa3d28cbf33cb709b7f78b4f61cb9419427983c61925 +96a3e69a5ed7a98ce59c4481f2ffb75be9542122ad0eb4952c84d4536760df217854d4ec561ce2f4a79d3793c22fa4f4 +990c4d9a4a22d63a8976d34833cafc35936b165f04aed3504e9b435f0de1be4c83b097bbaa062483cf3dee3833b4f5b6 +b9bf5e4b270aec4a0dc219457b5fed984b548892c4b700482525ba1a7df19284464f841dab94abfabcaa9a7b7a757484 +acaecf49cb4786d17cf867d7a93bd4ffee0781766e11b5c1b29089ae0024c859d11b45828fbff5330b888543264d74a9 +b0e1a0865b1e6f9e4a0e31d0c885526ac06678acc526fda5124742a2c303bd0e8871a0cb7951ec8ed9540fc247c8d844 +82b3d327b3d1a631758451e12870816956cd0cef91fcf313a90dd533d5291193a0ff3cc447054564ce68c9b027a7ffd7 +a2843602abb98f0f83e000f3415039788da1e9a096bfe8fed6b99bab96df948c814560424ffebe755cb72f40436fb590 +ab1c7b43cf838798d1e314bc26e04fc021e99a7bfbfc8ffde62fa8d7f92139de86a377289d5177021154229de01ede15 +95e5cf5dd87ae3aed41b03c6c55f9dfad38dc126b17e7e587c156f7745c8da0bd1d60acb718fc1a03b61344f01e3de4d +86f021a3762bb47167f80d4ef1b1c873a91fe83409f9704f192efeebbc3ece0729cd2f92f63419907ea38ae47bc907d2 +aaa1445dafbbcd645d4332d9806225e9346ee5ac6b22ad45e8922134fe12f3d433f567a6a4c19efdd9d5775a7de1e92f +8fd7e15688eef75df7b8bca3d61bc9fca4f56e047cdb6d0b864e7d1c4966eac27d6094b0c8482b49739f83ec51050198 +80aab8b4d394eb011d4ec6a4c2815617308c9b847c6fa6a3d7e6af1c79420ef6ff2a13934a398581c40ee4cf1cac02ac +8970b97ac076a1d8a321ce00eada0edf974a46bf3cc26f6854e4218cdfc8d2b0c32199d9658f254b4fbae5a2c5535f41 +a1aa2ec5b03df0a630e73dd048680ed6d3032c324941423f45cd1f16038789e5e75b876a13948732e9079a422f66a9fc +b5fe5f5e2f2ae2beeb8e95859a02fc45f01f9fb0ebb2bd8ec9ec976b3e806228821a9775096d341d662bc536c4d89452 +a2bc1f170b62d0d5788b02391337b2ab157c38e725694e80aeead7383e05599be0e2f0fa27ef05db007061809356e147 +a8a69701d4a8d0d972390e9f831fd8e9f424b2c2ef069e56bd763e9e835b3ce5f7cf5de5e5c297c06ace4aa74df1067c +b43d551af4ff3873557efe3f3fb98e5ede9008492f181f4796dd1a6bcda8b9445c155e8146966baa812afae1abe06b48 +b4b1dae44fd596813f30602ab20e9b1fb20cb1bd650daacc97b7e054e5c0178b8131d439a9e5b142ca483cc012a362b3 +b95b8a94c30a831eaaebea98c65cc5d0228c78afd6603d4aa426d8186aecc951f1a11c33951f51df04c7e6fa43ffb5ae +b100059624cf9db371bec80013a57a8f296d006c139a8766308f1ea821c7eccc26cad65bc640ab3f6cef9062653bf17d +8e5a2cb76716e0000d13bce5ef87acac307362a6096f090f5f64e5c5c71a10fddfdee8435e7166ba8c3ad8c3f540f3e4 +93d2c43e21588c1e83c4255c52604b4ac3f40e656352d1827e95dd5222a45aebff9674e34fbbe7ed21eca77bd9b8dcbc +8aeaed611546bb9073b07512a9a1f38a7f436ab45e11775a0f9754baaf63e9bcc7bb59b47546a5ded5e4ba2f698e3b5f +af9e6792e74a1163fe27612f999a2f3cfa9048914c5bef69e3b2a75162bb0ce6ece81af699ad7f0c5278a8df0ba000d2 +850bf2d5d34791c371a36404036ad6fdcd8fb62d1bb17a57e88bda7a78ea322397ce24d1abf4d0c89b9cf0b4cc42feb3 +87f7e2a1625e2b7861b11d593aaac933ed08a7c768aebd00a45d893ed295bbb6ed865037b152bb574d70be006ddc1791 +8dcce8f4ad163b29a2348ea15431c2c6ea1189ece88d2790e9f46b9125bd790b22503ec391bc2dee8f35419863b2c50c +b4bf5266c37f12421dd684b29517982d5e4b65dfdfba5fc7bd7479fd854aabf250627498f1e1188a51c0a88d848ec951 +8651623c690247f747af8fdffdc3e5f73d0662bc3279fa2423a3c654af9b6433b9e5e0155f1ce53857e67388e7e3401d +b155120f196d52760129dde2e2b1990039b99484cdc948fa98095cd23da87679850f522e5955eae34ac267d2144160d3 +aec8115e8d7b6601fbceeccf92e35845a06706d46acd188452c9f7d49abef14c6b3a9a9369a8bab2fd4eb9288e2aaca5 +998a8ca4dc0f145f67a8c456f1d6a7323c4836fe036dcbb0f27eb1c596d121eb97369638a9908cfaf218c7706f266245 +b235fbafac62802742ee3d26b1f4e887f7d2da4d711ba7f9bb6ca024de7beec1de66bb830ce96d69538f7dcb93c51b26 +9258d2ddc21ab4e3edcde7eb7f6a382a29f1b626003cc6fdd8858be90f4ad13240072d8a8d44ef8de51ca4f477fa6c45 +99d038487821c948142c678acd8c792960993dd8cb5e02cb229153a1ee9f88249f4ad9007f08e5d82e2a71fb96bb5f32 +a88ee9dbc73d3d8e0f447b76fdb3a27936bde479a58d5799176885583dc93830ac58bca9087075950ea75100cf51af23 +88b9b15816e5a0387153c1f4b90f613beb3ea4596037da01a81fdd2bcbd0baf5598db99f77e7694e5a0d35e822758108 +907ae4b637d06b15846ee27d08c9c9af42df261c5bdd10cf5bc71f8e5ca34b33ac2405307023c50bdb8dc7b98a2cd5fe +9393d6900e1d2d1a1e42412fefd99578d9ac1d855c90a3e7930a739085496448609d674ca9b34016ad91f22d1cac538e +a28ac56b216730b7dcdb5ab3fc22d424c21a677db99a9897a89ed253ea83acfd9d83125133f5be6d9cd92298df110af8 +b027590ee8766f1e352f831fda732adbaf77152485223ad5489ef3b0ce2d2e9f98d547c111fe133847ebb738987fb928 +a9cc08fbd5c3fee8f77cf6eb996a5cafa195df5134dab000e4d0312f970a5577942ee89794e618074f49841f1f933a42 +a8b3535c3df0b1a409d3fc740527ee7dd5ac21756115cde6f87f98cc7623f50cfcf16790689cab113ee7c35a5bd4879f +b61420227b97e5603ae8a716c6759b619f02b8fdc48acbf854352aa6519dad74b97bacc1723ca564cbf3ca48539ed773 +853762498de80eebf955a6c8ddd259af463e4e25f0b6ba7b6a27b19bdbf4c585de55760a16e2d9345cdba6b2a02610f3 +a711c1b13fc6c30745203c5d06390e6c82bd7c50f61734aa8d99c626faba30119bc910be63ec916c91ba53f8483c05a8 +b488c0a793f4481f46b5875d96eecd73e46209a91677769f0890c5e002ecd7d4b1c9f4ba68c47fbed40e3857b1d8717a +a651c5e812ae65b1c66d92c607e80be330737ea49c1dcfe019c0ecea0f41a320406935bb09206a4abff0d1c24599b9ad +85e34e7d96e4b97db98a43247b6c244383b11ca10bf4777364acf509a6faa618bc973e2136a4693fbc8ab597e308fd5a +99837214102b394fffa7f3883759554c6bb7a070f5c809303595a44195e02b9a169460dc6bbffb62bdc0e7ced5f0a5c1 +a952f89c0afb4bdae8c62b89cc3cfb60d0576ba4fe01a5d99534792f38d8848d919b3fc7577435d8443a044d2ee0bcfa +a1ac1f81acb29798acdfc493854663519e2d1b0e9d23d286ce33882c34b4c1c0bb43dd9638166d8026315a44d9ec92a8 +ac9c58aa38219ae659d23007cc7b97fd25b7b610b2d81a8f9f94ddb089efc49c049a8ea4c56e6eaf7b6498f422a97b3c +87e61d501c242b484fb9a937ef21d485f6678d75257fc8fe831b528979068cadbe7e12b49c34058ec96d70a9d179ab14 +aa45f6852f35cc8b65a4a8b5380641d2602a4fa4e3a035db9664df3ac2e170b1280c4a8b7b55161430063e54de4158a6 +a46975614ddde6d134753c8d82c381966f87203d6e5a5fb99a93b0d43aa461466b37f07b8d0973a1abd6ee2b40f24348 +8d35f97297773422351f4d99564c1359ef1a10cfb60aa0e6c8985a78f39b4268486312c8ebf9dd2ef50a771aa03158eb +8497c6242102d21e8b3ade9a9896c96308ab39171ab74cbd94e304c47598e2c2a7b0a0822492ac5c076ba91d4176481d +973f8fcb5f26915b3a3ef6fe58cc44bc7f4e115cd0ad9727d8d1b8113e126ae2e253a19922c5433be4ab2311a839c214 +ae3ee9f1d765a9baf54b4617a289c3b24930aa8d57658a6b0b113bbf9b000c4a78499296c6f428bbb64755dfd4f795d2 +a5be7a8e522ef3dcf9d2951220faf22bb865d050f4af2880b8483222ff7aad7c0866219fcc573df9d829c6efbb517f98 +a5f3c7fabd7853a57695c5ad6d5b99167d08b5414e35ed1068ae386e0cb1ee2afbbe4d2b9024379b6fc3b10c39024d36 +978d5592d4798c9e6baceff095413589461267d6a5b56cd558ec85011342da16f4365d879b905168256f61d36d891b1f +b7b6eaffa095ecbd76d6e1e88ceebabaf674d9ef7e331e875c6d9b9faa1762c800ff1ea597c214c28080f67a50a96c1e +8a1ab53ae5ceaa42e06e58dd8faf6c215fc09ba111ca9eeb800612334d30d5971448be90fec62ed194328aadd8c8eecc +a9ca532cac8ace9a9e845382f8a7840bf40cb426f2fcad8a2f40aadbb400b3a74021627cc9351b0966b841b30284962e +8dddeda8854c8e7ddc52676dd1d0fed1da610ed5415ddd7d25b835bd8420a6f83d7b67ec682270c9648b2e2186343591 +888906aac64fd41d5c518a832d4e044fdc430cfe142fd431caf4676cafc58853ce576f098910d729011be0a9d50d67b5 +96a3f886a2824e750b1e2ea5c587132f52a0c5e3ff192260d8783c666206bd8ebd539933816d7cdd97e4bc374e0b1edf +a150a29ffb2632cc7ec560983d9804cd6da3596c0c25956d27eb04776508eae809659fc883834269437871735de5f9ed +81f7ad4d2959d9d4009d1dfbc6fee38f930f163eb5eac11e98dc38bd2f7f224e3f5c767583f8e52d58d34f3417a6cf90 +97ccac905ea7d9c6349132dd0397b6a2de9e57fd2d70f55e50860e019de15c20171a50b28a5c00ef90d43b838253b3d1 +95694f00c21e8a205d6cbda09956b5b6ec9242ec8c799a91f515b07dcc7de3b6f573e2c0ba149f5a83700cda2d1df0f5 +82bbc3c4a3b3997584903db30fffd182a266c7d1df3e913f908d5a53122fa12cf5acd11d915d85d5bd110fcc43cee736 +8d3f24b4949aa1b4162c28dfbb9f813dd1d8b330f71325448dc45ea34d59b69ca95059402aae011e1b5aba6e536bc6ec +92c734c19752d24782331e74c9af97a8399ddfdd32954e91cda7363dba876aca4f730b451c50a8913950420682da8121 +8653d2c79f77b8c7dcdf7e8dee42433998aeedf1b583abfca686d47a854de1b75e9a4351580c96d1a2a9532659203361 +886f0e414cb558c1a534a1916d3531320a9b6024639712ffe18164ce6313993a553e2b9aafe9c0716318f81a5d0bb1da +b31b5efaba5a5020c3bcea0f54860e0688c2c3f27b9b0e44b45d745158f484e474d5d3b1a0044dd6753c7fb4bf8ace34 +b2d615bbdfdc042d6f67a6170127392d99f0e77ae17b0e1be6786ff2f281795f1bf11f83f2e0f8723b5cdd1db1856e09 +a6e014cca531e6ac2922239b5bee39d69d9ba6d0fa96a4b812217dd342657d35606f0b9c5a317efd423cdb1047815e3d +a8921736b69c9fbb29f443715174bac753e908251804620c542fad6cfbfda7bdfe287f2902f30b043a8a4b4818cfdeef +8d73a9949a042ec2dcefa476e454cd9877eee543b1a6b3b96a78ffcff87421e8b26dd54d5b3192ac32073cb36497acc3 +b936a71ee8df0e48867f3790adf55dc8efc6585024128de2495f8873bd00fd9fa0984472125e801ed9c3cdce6698f160 +82f69c06209c28f64874e850601dda56af44ffc864f42efa8f9c6a0758207bf0a00f583840982dec0a517ab899a98e5b +b7a0a14411101473406f30e82f14b13e6efc9699e7193c0be04bb43d1b49e8c54812ce0f9b39131a20379c4c39d3bbe3 +81159c969f38107af3b858d7582b22925a7ccced02fae3698482d7e9cdc6c568e959651991c6cf16c53a997442054b61 +8bf1116a206e0ce9199fcab6ed2b44a9e46e8143bff3ed3f1431f8d55508fe2728b8902670cfd8d9b316f575f288ed9d +a279b2149824b64144eb92f5a36b22036d34a52bd5a66e5da4b61fbc95af6eda8e485c7914f448abd8674fc14d268d9d +8b98279b5f3588d1a2f8589d2756458690a502728800f8d94b28e00df842a101c96ab9c5aee87c5bbe65552c0c383b80 +b4a27a351ec54420f94e0a0a79d7c7a7337940399646631baca93eeab5fd429d7fb39428be77dcbce64a13eaa3c8ca1d +90c08baa29ec8338ffce381eae3d23ce3f6ba54e5242dec21dc3caaed69cac13f2ab5e8d9d719bc95720fa182eee399c +85156d65bb4fef69ffd539ab918b3286105ca6f1c36a74351ab3310b339727483433e8f8784791f47b4ba35ca933c379 +923005013c27209d07c06a6b92b0cbb248a69c5e15c600bbcc643e8dcd2402adebd94dd4cafb44ec422a127e9780aaec +863b23eb5463a6ef5a12039edc2f8e18e3c97b244841bc50af02459b1bcc558367edf2f6e4fe69f45f37887469dd536d +87a4a7708a112724ff9b69ebb25d623b5cae362ae0946daed2ec80e917800dbfcd69f999c253542533242e7b9a5cc959 +8bf4347ceea7f94b53564f26b1a4749a16f13bf71a9e03a546f906f7c423089820ff217066159b0637d9d6824e9c101c +ab07eef925d264145971628a39e4dd93ff849767f68ed06065802cf22756fc6bf384cf6d9ab174bfc1a87bcc37b037aa +8e3f10a42fad43887d522dc76b1480063267991c2457c39f1e790e0c16c03e38a4c8e79a0b7622892464957bf517ebd8 +a8722fc7b1acf0be18f6ddf3ee97a5a9b02a98da5bc1126a8b7bf10d18ee415be9a85668eb604ef5a1f48659bc447eb5 +878d6b2a9c0aca8e2bc2a5eb7dd8d842aa839bbd7754860c396a641d5794eab88a55f8448de7dbddf9e201cbc54fe481 +ada881c167d39d368c1e9b283cf50491c6bfc66072815608ba23ab468cfbd31ca1bd7f140e158e0d9e4d7ebfa670bc2d +a2b48578fa899d77a7ee1b9cb1e228b40c20b303b3d403fd6612649c81e7db5a7313ba9702adc89627b5fd7439f8b754 +8e051280e10551558dcb5522120ac9216281c29071c0371aaa9bde52961fe26b21d78de3f98cb8cd63e65cff86d1b25c +a7c5022047930c958e499e8051056c5244ae03beb60d4ba9fe666ab77a913a067324dfb6debcb4da4694645145716c9d +95cff6ec03e38c5ab0f6f8dccde252d91856093d8429b7494efc7772996e7985d2d6965307c7fdfa484559c129cca9f9 +993eb550d5e8661791f63e2fa259ab1f78a0e3edad467eb419b076a70923fede2e00ddc48a961d20001aaae89fad11e8 +abb2826e4d4b381d64787a09934b9c4fe1d5f5742f90858228e484f3c546e16ee8a2a0b0a952d834a93154a8b18f3d16 +a922ca9f2061996e65ef38a7c5c7755e59d8d5ce27d577abcdd8165b23b4877398d735f9cb470a771335fc7d99ecb7fc +90f22862216f6bc1bbf5437740a47605d1ff5147b1f06f7b13fec446e4c5a4a4a84792cb244a1905f3478a36f8d7065b +87f3d9a86afef5b79ea1ca690ee1ee4bb9754b66f7c50a42ad6b99af7c222c853ca161f440a0a2a60b3b5a54e3493240 +80a9ca9a2d33b9cf61976b3860d79f5d00de89a06ef043d2a52931809018aeb4ce70423cbef375b29c2c750c2c8704c2 +b4e798ef1d615896108dae37ac50c1e859216ab6dbac11653e44d06ce5209057b4b0dd6d31dcfcda87664a23c8ef1cbd +aaed6d1e7c5b1db06f80dae6c24857daadfb0268f20e48a98fba4b76de1ebf65fb84c3be95fd6a418b498f8285ec63bd +aeceaa316c6369492c939f94809bc80e0857abac86c0d85be8066bbf61afbaaec67e28c572437a8d35c49dd596b3134f +b791c3d53ed34a7d1c8aa89b7953e3684c3cd529230824dc529739a5fbe74b58b87f01e56e7a169f61c508237ef67160 +9351f8c80634386c45c0050d2f813193f9d839173be941e2092d729be5403632a2f18dffdc323d69eb0dc31fa31c5866 +97693184d5c0056ae244dfb6709cafa23a795dc22d497a307a7f9cf442d7452024023c54a8d6bda5d90a355ba2c84f3a +85362daa003d23511ca174a8caafe83d52b6436dc4e43c4c049e5388d9211b5cbef3885896914d86d39be0dd1f910511 +a2511b5fa34b24eeb0e1bcbcf872a569d1ff5570fe7b0fb48f5542f7fe57bad808d34b50afa87580866a6cb0eba02f27 +b382e3327eb1401f2d378dbb56ac7250adde0961bd718575a64d264ffd44772c20752d4035c3ba60eb435e160b375e20 +afad8a5d40b536c0720556845a6b257ed42165c14fb4b4a874717d107752f49ed9380c5b048df3aca67287bb8fc411a8 +8fad0c98434ca5373c2d767868f679b76b4a8d04bca8240ea3f388558262c2d61b73b16fc1160932652b5688c25fffcf +83898008b5cbb6f08f8ef3ec179427869682bb4e8d38f6e6a687a214d4a307436afc64ee67d70a5a8ba9730bf839aecc +b85232e79913785fd82b06890706972b4ad7a309489930ae23390d51aa5189731f8a2df24800409a8c36b3dd6fc91275 +a24ff26ec792f3701da4c5638c1fca4fa4dae95b01827d6200d583c4caf17ea3171393ba2a8c23d1ee8b88402916f176 +adc5c7a7ff6b41d6cc386b7fc69d7bb04179bdf267864f9aa577f0f6a88438191fa81ebaf13055c2f2d7290be6421ace +a05e835abd502d31454d40a019010ff90b6b0b1f993075a35c9907aeab7a342ac0ba6144dc9379aada6119157970e9b2 +85ff07ba58463e7f153fc83f11302e9061e648a5cbd272bb0545030b20e11facd8b3ff90c9ac8c280a704fbda5c9d1b0 +a6c735ada8f4587da8cdad7ea3ada01650b5a3ecab8d81daa7a5f5de51ef4a6592b524692584306f06be3f6701f2870c +b138deee4e53ae8d677fae104f713ef1b8babfecec16b6a85785a66a72784eb09d44c3b63567222ade714e98f7d1604e +ae79c1a49dafcdd972acd95d8ad0a35c02adc7fd736d4c44c3cd13df5789d339b5ea16bddbbd43e486a061ab31baa5c0 +ab3cf2371a1d7dcd0ffe3869a0178230964b06694bf258b2073ea66a2afccd845b38485da83d02e1d607d4c5c36b78a8 +ab9609f28a325fd01cb39540e3a714506c44e52ef28ee640f361deb5760aadbb23e804663b0fa20a66e239c33f8d8bb8 +8ed95ea8e76e1b42823d7915a6aae77d93746f846bf602841dfce0e47543a36efb9ee7e5b42c73c3209d911225cc471b +a80b6162036d43811482323f0ce59eb18740e33a63d7c7bbbf3be206985919e5342d53a69df537d43e8b7d7f51e8892f +93c03d0a5083408ba00c125a8a9385213d4c860072f0297857b1235045819b904e07f2425c13a661d0a01d2e53347f4b +a6581200f00f96c461621e1d26b14a23687dd97eb9f7df4ba641a84340ee7306dc1796248fba4804f185947ad13b4385 +8be174018fa40f7e0cedc5ae68f38969eb7695f2205e9c573641e533d56f68c20abf38a23d2f0dcac371e60b21b18615 +857ad4ee3218c647c58f09b8ab22bcc8976f00a768ab1f708618e868e6143474be846422ce2710a0ed39b5155b6f13a1 +a490bec40f322d599f26bcefcdddd8f2ef6576aa737d5ce7e8d5d422741abe749e3e6a48489aed8c560633f72857e3c2 +a9c0ee339621f1c4a2410f9b4d2f03f1b558dae2973807b8bccd920e8feb7f65dfde3e79986b72ad21fcc4567240381d +8592251568e750a430f7d2c6ddbb3ec82a4dd9fd83efe389e69aa177fd97ac2c96c59a6e86db20d8e6f125d65b46c4d3 +a4e2f4aa6a682913b423b097c4069c4e46a1f3af9556b1bfd0580d0fc01e3991488458049e0735b2a629684a79271c8f +8c4f6a3e738cf74112b08b1680be08158013ef8a515a81215d8a36c9b756786d1b4cb4563923463f3329292f4b48bf6d +8bace547353c02ea00dd547eeda7259aa354d4772dd5e0c486c723cf88627b7112e196b879c3c92a9561b674d9fc486d +8d372f4901e25e8db64fa098148d4a4e709b0e9dcb756d0f90dad99dea393054193ae1a33d292a3dd772ff7ba05e4b71 +a8c7ea6a6a031ed23d65639f01f5423190775558f479700597df7ae7e338a6ae5e9b32f470aff20787ac8b7eec84df6c +b6e9dcba240fdbbf66033410a79a2dd3e9e1ffdf2eae949b3a9ed720e939d92339991dc3e70a5ac7d5253f317daf0b7d +974dec4cd61af75721071752c664d9c2a5121f06ff1515c56139a177a3ca825f763b69d431d4607e393fa74dcc91cc58 +958863e6ad583a9d370a6db3639066982e44766904e7afa849b132f6666b7d08ab931131b3bec7a506d6583e93d56767 +8b93a33b5da9b3300c20a96d80b894e3789c77041183c2cb21751579c8c96857f60cfc2f075201b64e95a78985c5b321 +b726cb9f7ef34ddbc2fad82b3b0af0b30cc913e26c5a614ae5c19cc9c55c8e6dae069db5315a8dcb6d987415bb550ca8 +a730f515398a71bddd66cab2ff996659d4e47dfbb08ce7958a41021f76d269b91c7498b708cd14b183a8ef469c772803 +a4eb3b18132eb0f5337f14e01d63ca0bec0db6a43870f800e5491db756c2f5fce519d8dba5528b4bcef550d06b33699c +b1ab6621eec1ee6784e632e214693f39a14f3715991996b883d66200963e065c86fa0667f7bc36b93b40b5d90ff708c2 +80486a26c3532ad6e19f76d8c9344e2626c07363fd495264927cb5935fa9565ece670dc98767afb04af6a9a5c9231075 +8ee20e0df3c84a1c6b0e21bcc325cf99235b747ffe47f17fdfba548a358ca75cbcc331dd50db2311b400ae882256a608 +aef4268959e5541e7ec69c921a1e81a8374d7e44bf1bb2debf4101cf3cd6b7d6ca7f441758b388de96b3e0edb5b97be9 +8793629bd29d689ec94b016de8886cac6e2ca6638911babb22db4a787661422da0639a4e4089ebeb689d173abfe75950 +b487b3551c20a29e9a5abbda8c50ff594826283e443c09e3ae09b914e46060b3f9abf70434444ce1487e2a74e562616b +8f11531cfc5997dd04b997cb87ba1831aa7041d5434fe72de66304e3f165d882fac891391fbb1eb955c65319e65293b6 +b195136875fd02a75676c33cb3e60504d5964f7a9e81f4c8c8fd38af62e2145c55f765b3158664566191188ac678f381 +b374174b0b3eb04fa49eb4ece45173f0db5d829eac370a20a62309566e0f98b18f72f3633626893c053b7be6bfbd2366 +b2a2f6b0cf652775679b2d677048f2ed8c31a3269e6cddcc7a10e3e6fee89e486b50d9d55fbe452b79c4157c0270fb77 +892177c364dc59032594e7a6fd032286ffdf4fa0b9e3baeb37ec839faebfd2fd46c57b2c9bfe9977b59c93a9cc0ead1d +8ab7c0038a7dbb2ef200dbbe9acbc875829ecad4883792d5c6ce283de67ccd9aa935a9cc7b30b2bd9de7fca7bf2a9a05 +83745cfc78ca709835aa6c6a233c2b86fb31e3f9f6a8becf63e501f2841c4366fb7d131b746c9d3291afda714ff05579 +a723dcb67925ef007e8339dc578d2622d9bb77cfda87cca0088854a59414c02338752c56116a6c1281917842e8467c38 +8a098142da0af2254c425fdbbd0d1b1a17b2bd781391ab37f181775524b8563c64ab8a1602aee2ac6c0a82ba11a8b1d1 +b13bd7529a9b351c5d395c794c28bcb0a3167f1c992e8c062eef47be9be27895945231d249c73a0b6949daa295e14944 +a20dcd2fc2222eaae467d9f5db861040f58bcb991a26e5663ac3aa5e1ff13d0010657c5af586cc4621757add2b905073 +b818f660c3cc4e9f273c25ceeabe562c8afa8ff88529c26f2cf45ae6b2813cca5f350e3cbd56f6257c4df41722dabd25 +b225d5987108b24411bc389276f12509a45e86d5ad6b6d929af5274df0be11109c0fed329669a0acafdf3b0beaa8f2ec +91fcb6d04576d3c6bae947bb7843b430e5fb0592ae49b0a65dfa5791f4eaa4bf2c7f436c8de7360f217001c2b4e5c67a +8821f7a1424ca3fdc5d4a5606ad10dfaba6094cf36669fa9f84cf7617e50425405d14980780e1e18a1ecea7913cda896 +990dcb7f38f56521a70cb71bf4522649fcd46ac052c7feabb0748dfcac9f9c0f95d29e070d32af3cd0adbf869535e17b +b0fac1029fe2c1100f24e2f4bf10c7672199fce53513c7dde2e8d9b00702edf0143e0e1dc7ceae7dcc6994edc2422b6f +a514ebb1a33451b4915c05114db0b10168393613744df848b24e43e09f0bda23baefd9d731075198aace586615ac7911 +8b77f7953c2e67049fdca3653b8d8cf3f799677f79b954da02bdad8cc4d6c855c1c7c16b4f6f9ba35f46426ec28b2d84 +875520cfbda16ec5b1d1d00f578a910d0fc052f17870ba093e22e310bb07648d34817cc2b8811b6f52de535f7046a0d0 +b8c77b4be0b430851c4ff69e91cb770db1935d848198601393810ef395efab52deb9d5c6525472bab720273d5e0e7a79 +b6d4d437146671bdea62fb6545395ea3df39f1cdef21b8476b68e7a25aa7354f847740576d6c9f187bbae9941f0ae450 +95c642f1bccdb62cd6a2212dcdd6ff8d49aee426ca08b7cf3a9d15249d24a9eed5533f92a70c84498c0797f8a57efa27 +b617978047ed0f748c305aa7f30c2dacd0db00baa67fe0c5ce346ef0e6991dc7e05f18dcb2702467421f8390f27aa815 +86411c7a00b3e8b43bf22fb061b1f54ad9bbf632cd74395a478218389c0f544668acf3dd7726532d080ca7da9a5f8608 +97bf684a8849626c4710a6992f6c11f6b5406fd4dfe9e6aa502425aaafe9827e2c435aaf9a5d3d2ba3a4c0e8aec79ba4 +8b178e2a125b461d3180906ffba0af3dce614c64058501fdd35243ababf892d6fcdea4834ce42c25d5569452b782a709 +8ebed2c8a25c61da6a6a8cb0d8f5ea179e28869753eacc728f2c076f7aed8598cd3aa0981f120f9e7ea55b3a689ae882 +a6f235b8e655ca3d634740b53d8c0a757ecc75d2b8838b7948997c1985473d01943d935f687b86cee56cd47c8e773443 +a7959c465a9646908b9d8032a589e41a7dd999f2ffc54bb42f22e5f8a4d8c493a31bcc7ea2cac6c8dbcc59acace7181b +96d0532df2e12da20a57cadb6cf5f6c4ee1aa4775629358c25f1d51677a3e96d1fe3b232532324b4f02f941952d4cc68 +90f493473d686b639a30d1ddc9c72eae6e983f1236e162e58e967a477c0654973ea2e1bdf4ba1a44d7247bc1befc2cab +8b2d87876d9c4085102a07ebb41c565ba69acab99ffc03efc18f20e48d3f3bbe4fc6ddab9c78fe479d9ada80504d85ba +829a0fb3200a28e09cacd6c5346000e7786116ddfd898f37dfd17bef454a8abc0fe939ed8735c00769f7f2f33cd4f906 +86194ec9e88ddb7150e8b03e7a535b6e99863fc6762835601efd03615aa97aaeb413cb210e86035086ed852b39c9d019 +b02efd116a7189cb317ceae392bc301ae55470f0489fa89934e182aeb8c67e280299b975786fe9a470bff46827defb9b +87d7c3903bd22b12d815506f150373f518d47dfc6e5fd74347d88b518124c9923d1e4c98defeb3a45d53d50b423e2175 +a1a430406b28254a7d6348bc98e697e9bab43839aa05d53faee97546f84541ea0b559162619b2045182938f69bf61cae +99d243c226c61c6697fb3d2594f3533fa5dfd7cfc87107908cacde337d7a077fa5a9dc702d26081b065edb1227498e65 +800ee5006ab6217161f42db0cfc552a81728bb4fbd7af6e4620ea099a65ef6664184af3f65a07fcec7e965529c5b49bf +91bfd307579cadc8f81009558605be3edbcb8dbba271475803484017f40130b2b216aef4f620d960193be681877d3a53 +96a060459dec458d19a6f8af6e49dc6c7c58c55dd18915c5fce5e0f4b4a422fce3b9632f6059388fe760289abf70f173 +9921a37f3e657222c7fda3588418a9071409711d9f1fccede7494429f02a45fbc52d79fbb64e9ccd518f60d06d0520d3 +81052b0d15773cb75975ca9230ebb2579700e489c7e3f07cd9cde206fef38b8139bd4976d2b4a7840495fc645f96df03 +88ac37ba66d1de5e23878c992e4d54023729e97e77351f50dc5918d738b5a73faf1dc6feec7e85784761836ba1c6f778 +ae1e6072c13060775f6086d1ae1f88b627ffcb810fc0e0e97deea1f3a15ef0aaa52a6dce2563e4beedadc131af2a8281 +8b60a340f5e4f90badf83001b495ac9f13974c3d2054ddcb3e6b8ca99dec5cd63a263e05c282454191ab2e087d5a2911 +832e2d56ba69dbf817b2b9dbd25c1538d5b8dbf5d9bc05e6be85054a423ebb66a71b157e166e0b9444ac171b34b7ccc9 +8586036fc7dde1e7e3ecb61663130c4529866ae9f5f5095b9fccd24a4c70eea899aae5f10ea1ba66d1665b2d83be35b0 +a77969453b5c083a207913272b5b69d4ccbd8718bdf54be8fbe11b4bd0a2168aae3ba8f9362afa69c0ffa28d7e5a2340 +b7fe9568c214baad0ac5f83745611b481f744ec1c4fa78a549b180dcf79633e5ba75dc20055012a13d849eb7a9be57d3 +b01cad1d2a6c51c0ce88243d1f52f95fb5ee315a905079688027511f0c4ecd0563a3a81846709d272fa5ccb9665e8043 +8eae0a21adfc569aa57237654021c2bdb2c6f0f52ccc90a126682c21a1f9413c63d285f92b2b2f8649150a9284bf70b7 +942acc947192b5f3cf60e92383e5d35f79e7a5904e8e9fd1c8a351676c83ad29b0afb6578d555457cf909f8f4d27adfd +a74e092f8628fba9abcabc27e2e9f3d5a9a941dfe50a2dfde2ad179aabc73afd196676925c2d98643ab8b3d02bdb66ad +896159daa2afd757cf3f9d34af248ad68bb3c62e4c9ac49919422727479cf669098f270b9e645607a7d11adad4c889b2 +a428d8370813d78e7a2a24eebd36e9da2f8bb3605e5a39b5fcda939b531c35a8ebaaa642ba556250a37bddeec90326fb +a5fa04eb60a1d5ee9820e78f42f7be15e1c02757b539aead995768c6209684d6c183c71d282e0c12a4c15c03f9a89d4d +93c77d5d220e40affa7269a6915c076c9aef4db552c643ae5d560a79c955b491c6346ca4cf11cbb7fe1894e28d47b065 +802e605d2de745eef6981d88e7a57ef4046a2062725e8080995374cea2b3273c27f35b7774d0dcba014710d8d6c501f2 +82f7169e6ec9b3e2bd450f35ea2e66d06bcf900acf5b73139677b48e078ce2e16599103027b2326770c99c0a690f2015 +b0c8581879439f9b997551233fe2de71aa03604f9cec37a7b18c5854342d9b67be468f3cac4bf6f64fe8a0066248c498 +a3f626848a4db6e9fb01cac90d3362ec521e969ebd5228af694ea3671061476149f13d652942ac1e39f65591fed740f9 +88a8e759b9cbe16a7c16e43f4afa2de6100d2eafa4dee75ccd653ec38c919013d0a6b35c1ee1eaee7c1985b58bcc9e92 +a3d5fc7aaea072798490616552d947e95f49cf02a420314307aafb555287ec607d75589ba24b009cd68299dc6f7942fa +a809cceeb84f9bcf3c3ddafde3041e7bc3b1d14df8830ab849002176a0725e6f16f70774d8962cb0b8ac0dc43c4ac66f +b8f2e46c031cc8fa160a08c2ebdfa85345ed14771b06daa9636b0e7792b7fddbc501dfc85cc626a01104a43a7d3230c3 +b5367e2a521c318b802ce16ceac80c4b8139f73ddb10ddf38433397cda70a86ea1f051cc55626a4e99d27f30f3975ff5 +96d963660121c1441cd13141279cd371a6a0aa18b6a20761b18df60aa9c14e13489afd83695a0921d5232efe72045f07 +80818d492fd85d666bd91aaf6257b86527fdd796773c793407df1d4a0f91d74649a6bab4d15155c36ed4c6e0a32c5636 +931e22918905fd6c230d3d867ea42861f3074d320d14e1929031924c8ac209a5c552b679b24563bb12f9749b4ee983bd +a4de2c333e74ed9bfa3c0bf6a0beb90427abd9aa4221294cda74331646b58ef46ed57cccc8798ba2b9309894b17cfd69 +883881554c1d88c0ed8d3b6dec3d200f6fea69a77ace3e4d6f86b41506a23724b4394ec8384075f9c75c3868ba8a8e8e +aa0539ecf6ec9bf06f24443027f8f24b6b3d8c5b2084248eecd4bcad3c9a69716e1a0d01057f09a65bff1006ac5e157a +856d74d44c943c9e809b42dc493dff20eca03cb0cf5ed45108c69b1f90d8592a53ae8100e99380a274fafad23e74cdfc +9188257446661c88da093b7c5ce998135913f63842d7c1586065377b169ee35b062d925367fb9b909ca971f1188667b1 +8d3aa57cdafbe998938787479f5d590c1484c6dbe94e6c487e57a746ef5252be0eaa5976d6270de7db64b6b92e57a0f7 +b8f4d6997240f9eda5aca0c43323a828d1563c491b3db2087f60ac4120a3fcd06075fb42bb19d0339ab5ee3fb7db25d2 +ad247ea94b8ae1e81eae4c9fd7b39e6601b53cff47b2547ff90a3cca87192eae28408082774a1fd14bf9ab459b7a4f1f +9598598070f8bdbcc49056c40971e673726cd8c1bc4baa0b5124dfb5fb750e7baa7a7df18eae2bd91955ddcb1ec67955 +b874131ab1608667fa60ea29092d090859eed1812e90c609afff96d79e82c5ba546f617f4c96fc32c9bba97431c1e9af +b00750a9cdc75c2a54f0d3cc99b0fe02300754f25166f7ac85ff41ab5e9cfcca33a29be76a480f12a2d410c7cd5032e5 +84b5bd1c90bb6c66755b28ba4af493ca1b0c3a4df9f436aac67d2e07289053f925cf6a149a84e74e1027dc8758150179 +99caf64bd9d193ff306e8ab5da3f1bb2a190a60c3a82099b8d03d17fa810dc53d176c21379f479e828f60d25beb3ffd0 +a8fd9de502f1c261d5733430e5a18d8b7892a98c9529a016fc2ee53892ae965dcd9c75850bcda4c7edb980b8d88e60ea +848c02cac636e047028a3fe8c1bf4066fb7591b96b0340f8fbd476ff01b35fa3e37d309333771a134f24800e5f3f9289 +a1eab1a06dcca3439f0166441e7e7f2f5b56f5f8aa9f45e411c561f556e0fb71c514c06c26ac53b49a576caca5faac3d +aa603f970dcbe953e700e61c151182c8d32cbbb53ceef572ac93383db33a4b098b5c7b267e42d514ca66b740c0925efe +b55fd5301bd700ddb0b4f72fabe9a91ad49759506101fa802ed1677e9553595aa4d2c66f7574e78d21ce882ce0120ae7 +829137bc4da7b4886d3d04d2c39cbf4b1dc40c813ac1adb425c7b9abf9142b516314cab79c68454df5d71994ce416144 +b83a3a22735001f783dd48a01c4fb3598a51ff3987e842b8045c71c035b9e43645a55254ca5911a5676ef4a8af12d056 +8ca8d463deb13f9eef5e533bc39efaeb0c15631282c5c0deee1673b0053a7cccd514af09801dd6c158caa159fe9351ac +a9ffb1427828f3c456b9c8cc50782de1ab0029b9233a0fd998bad0fd014d27e15c4a32d1e16ad41bff748378b5abdf49 +9627e29f725ddd86456aff813976bbc4a836f4deabf5ad9f73d1a260ceb30948824df9c8841e6b3c529652202be181b3 +b52c988647fe3d9276eed3c262e1044f57fbb116c64cf4f207235c205b3fda0f3d789bf90f5217401b468d85fdfda404 +833bbd6e2924f5c4446cb76b881d1434a5badce9eb9b003f85d076e297ad7ef45b822069fe54d17427a348c3263fb838 +a067a36352db6f82a116cb87d3db5f60b18576852409e2076cbbfc7843af78866313a4969385a40271051dd195d51116 +902b99545971f9a103f99d7399acc347ac46fe156166e51deefc0e92aebf5893460c69aeeae11f5af9f49418e289ce6c +9206a0e9ce9b9880f29ef0417c96931985f5d83bb17cebdbba4ff2af81a3d37155b04649426f698aed372e4f669599e6 +b54a5d7c976e45c0b1d44433595eae9d1ae9aeabfd58cd5ecb0c5804756a7b01c9a517754423b4714a3695533a3114c8 +91b612131e84580ece228b81ace83da0269b53f94d3c02a1a0879ebbd81bdc252064b3d03a7e140b43a90f237d9a45a0 +a6cead3b8607eaeafe37135bd6de8fbd16f806c131eb71c8d36bfbe295d45b070255e50dabf076e2c3f6b8699be71d6a +931da21e67b11ba6ce438546a24d063bcd51aebe39b4220a78d9c0aab88b2d37969b5ef3502d835507f9c8d6d006714c +8fda408caa9daf01122a2308b7b9d328f52e1e2f138a8bec30492488f4d710e5e52524a6455a3a2ae2818ec8a610b650 +ad8ad5c189644352d90c462731c46145410e5adf38682bb80f95495dd64d9d13782537d68690847bbb06c6be7175dbc7 +87bb5cc466ade60feb0961421c3fabdc8a7e20f11df8437bfff63d3f8bd25305002a396c9d0fa4fb9a9986d4717f12c4 +827cff72870ba00c29064a7d2b4973f322d6b6de7924c93d8bf8825e7a0e8478c7748f90f5c716bf83c55b2795d315d8 +a225895a8e94229776ceb51b05356291f2dce748be17a60d5aeb33ef8507c368bafe5d1d6eea927f28b9d1422b661b9a +8e011323ce670ff51c964241a6b72e0e0ffbb3ff9bb2762492323fc3a4abf4718091be0945287c7329850e4f74462cde +a2c03c2e5f4e9d3ef361f68b188451994ad1b24de9f323370559c8abfcdc7bffd289d92e78a5f6b104b0a12c84dab2ef +a22b4771116ce22276fab1fec6826610707ce8a342f9f60b079c4e0259dac3cc41c96c560dfd0ada6edd2828f7c0e8d6 +97c17441d0af9be83b42097aa8b7cec84a253b9a2b957214b8fa93c26d2add46144faffa7b8a55312059b10690f711f1 +94bdf348849f31a2737cbae5e5848aee711067bac85c11c2e68b44c398cfafbf3493a3226cd1ddf7a916e7613fc7b6f6 +838f59c6e8469a8ec6fd40b978a3607439aaebe1e50ff707eec72c0b8278af05b477bf12a384b56d03e3d4eb91e56f67 +a1940f0db58185e2b3aedd2b0bc2b73b4a65c68e09b046f38e9dcd4e13c94f5406bea92635190bf315e48ec64eceef2f +b2f4e0ae44e1f1210a91d8f280f17091fa994034ba8c991583f8182a323e9b3001a712e3584fc2d64ecbf2d319d076b2 +9342b89c721338d02c7854cd7466fb24d93d7313b6114ea591e6607439c8ddb911d1cf35f01898e9c557982bdff8f9b6 +8583fcab15be1dd14d5a415f4b14d706c8c62f058500f1344b37730c8be6741779691f87ded3cbcf6516468b373cafb0 +8fa9587c7989646571ad9032f34cedd353caee14f5be5cde1e9e0a1710f90c08faf6fa96a60e1f150f761c9c8ae7417d +8d9ff904cc08141f5a9879f5f77dc600e6edbe859082231a4d819953890199bcc5f940b730ea688332f07e5279d49e1c +b5f82b46e5ef9a2df8d144202d6e2e4f3bdae8e2048d2af5ea7deb3f722fbe6d370401954e74ff0d8cb1010ffb1f38d5 +a3b5b57d435b06ed70530e060002a8fea71746ad07d969ca23f22b5e52624527595b6a6d54b4e953fb7b7596bac378f0 +b90f89390df6d4b7879b915aa3c29b8d779d035033f8873bb7ac54a14ec98f0d08c0e3bf696e2ffa7b5730d736f571f8 +8e81e371b92887e43d95c0dbdcc9575282b26ccebdc8cbf46587e4f2a83b61e9bc0c6d7d1f114b9d21e04fd6c180b12a +8d682947c51dffc6e0fe0a486293c9ed121f441805168236393087cf62f2a429cca60bf0e472564844347d32c6bea27e +a8341ec7dd189fa7168759240224192c58209b53fc961c18082deba217928c399bde08ceae42bffd37c1135b4d14a845 +a94bb076dcc5ee5ec82fac57c5b384c690df12631882bd1b960e1eb8c04f787bc22b7bac315b9dc5a8a098f17f051a0b +ab64e1c6f01b87706c88a3bd974454a438722768de7340b834ccf93ea9880c14ee7c2181432acf51f980d56de73832ee +b7b0058bb724d879e5ad7aed6230297c54cb599ef659e86bf2cc84c38225899fb388391df9b2e6fdf063171937fd8c72 +ae856f4fb74c27cc98b67429186e7df4feb01278cd57bfd3170af6e52e0a23b9e926bf9565a890cfb4ae8f2d590b2cd5 +804b9c6702f0596d328f92fc1ed5a30a7ba17b9204524135001b569233fc4937035031d079f52fd04968f37c24013898 +84274ed1af6bd6a968583995622b4d18c6a2bc703ce0d0edce45bb736529b4836343dcd11911a94a134dca7877e6cab8 +88808098463f7505034c3b6328c8a08186b33f7a981c08376e429dd64b79b97753170531ed078dd265ded4ec0a1ed8d5 +92823bfb23a4eb84d3759e7d717f0c8641ece0927cd2ba8c728c26bb35df2629a838002f353c8d3d75eb19520aab5f25 +8db36bae4d960cdb9c51f419d7ddc81f372e56be605bc96a9d4072b829f05527c37c8f255cc6115300a2a0d2e6568d89 +a8fcdbd7f3b4d7ff04149a209feb75e97149e7efceaa42d66a6b8e432590fe7bd01f1a77fa8b47108f670b612e33fee9 +a9f4c53c62db7e5dbdea6918862d3c6d24b5bd8732a218edf0ba61e9d1861182323d8ecd7bef8f895b42970b492f6e40 +8b95bc7f07818f4d7b409aff8da0b2c2ae136cde386f53a71565cae9fd14c73c13cc1cfd79c0f97cd77839fb738c5b9a +adbd1d11adc756b51a571ddbcbf4392415231ddad93da09acfafee03a9e4f9e1ce3826110619e5271feadfaffce3e793 +95d327c8bb195cdf25fd79c98f9406a6b0316214b1630ebcce95bdaeffafa36fc1accc6882e0e5d13a8db5c0f3c0e61c +8cb2f1e2fb25558869afdacc7bb866544cfdd566cefcd048b48d458a886130bd086ecb7600a960a7f2563c61cb326510 +b3aa8c4bf5b933d89cd74ca7f7176d6624d562d7d58b041328b49d7562a30b489cb606abb3c49e85baf04c28e9cd1f44 +97f9053a85250c420599827297453c2cfde087065b823d9e43139e6a9cac3a2ec40a1b6e2f0726bdc870fff215462f0b +878d5dbe6b881389c2ca126ff66d87127c9aaa3f62f0d2c1ec0ea2b279ac95f8a06710dce166415db227655e2345a04d +b2c33a6b4203e3ca5247f0890e475518317ffc44cfbb1da9a1ba02114e8b752bea618050b876de5cf3b1906140a64471 +a56170c8313d2b5541a795bea9934d4425b185b5c409f0484df6f44f0e4bcbf50b860ff46b7245cd99c1cfa8fc1965b7 +96e2b658e2876a14147385fc423d2702a3cb76962b6b437222cf9cea39ebf4bdc03bbf434b747866d4bf72b4ceefa639 +89c4a74fa2f067e7ae49c84ef782c331bcc9245db7e941804e2e99d12e987b4d25cb827778ad4c3566c4fc68018650b6 +a01d30cea7d01c80ff26650020fab02e78fc3842e2398a81b44b21d58d4e9816166ff4ed2418831fa995a28ff35cb6f1 +b960c80b55a8845bbf24bc3f23b0110ca701f9544ab6a5bb7929330213cb471321e55c390ceca3e24bff69bdb0d331c0 +802c5b13f22be7be0e5db11eb3be0f0ea7f9182c932265060ba05fba20ea093dd2810d3b969ee3e387e60fe6ee834e8d +92478f88ef7435d15e39a97916c736abb28ea318394b88678fddbbaab3eaf31776110936abad116a8ff6ca632dd12043 +a6d3da0370c303001d5ed99d1db8bce1f26b0e442f0f042e36db9674e92dcd6e80465e772f1e669f99221caee3392fe9 +938f04f70a8f947d6df2f0c0e9af3cce0c06edbb3c131970dd60884fc0b0a0959c504a2a36c3ff76dfe919905671626a +a7117e55224230822e9983df2132347eb7208cb6798f291df926ab51e04b1a1f78d5568c9a8924ee6f57426134360f20 +b91074c77ad93fe48dc2b10c0c5a62ca3ab7d98345b919c52d84a9dc419b59fc1b267e1c2d4b2e120016ef84bbdb0cbe +aa175c6b6edf02fe8778762c9575581c0ee6efc9dbf99c291a41444a23a056b893be6c45333d907d0bbe9fb0eef84d08 +ad36dcb4e2ab425aa339ae464b038d550cb11186741dcf257f1b8b80ed4f32ffabbece45e2dc1525d4c3eeed819ea04f +91cb35c1ffa9cd5aebef523edb8325078da3eb5cf9e95c675a76446fc7692aaee6f949de064ca2f3e0f082cc3fa93e20 +82622f9410c143a86bc4d756b3c7b324dc295231ce865de020d61cc0868f2c150a473cea3a5b756b36771ce1032415a5 +a5c29996ad3a53468ece9356a5b4ccb68971ea1c89cf39644f1da2d4a477c2ea99bf791ef902b87c225d8c53d67c4c92 +92893eceed1af34fa92b23dcbab175b6a0188a27dbac9ad3317c4e39955a763cb383ab13fb1c519cde311d8a4d12e8b3 +8a093cb191b94b0200e38d31955f9d240e2be1edcd6810a2396a061f17c3ddc9c4f4d56766ddff4e121be7110e03b869 +93981473df0cb1f4b47c7d9b64e3123dcf1593845b401e619f5d7c70b5dbea375d1ca43fca65845fcf0a6b2e0af43791 +a6beb6b0697070f9562910add88d9ba91992f8da127b27be81868b1596d1012f09ea7ed601b4a6474c921a1a1a6d866c +92026b1ee30f2ed61c9f30337c3356844217926aabdff383c19ca3c21e0bc49811ca5b308012bee4ef250cfae1615800 +ac0ebaea6d35f84dac4ce648af096305ba68a7a0aea0a11ab2fbe3162075444a158433c98141bc92ef3b3400d6deb46a +83046f482dee24ac3ca83373f0d1b82ac1c4beda0f229a9011a81ec659ff5fc1fb105e219975b5c744308c77a24f71e4 +aa5a312c47ff7248dcb9c6ffbe5a0628ccd565c07365c4413734d415cd4fb35772622ed833862dddff520a67c509c6a5 +a02fb88805c34018ac33582e19ed0a7e4616acc3dd0867e5f21914c2031c05c6dca30b8b35b57c2b137750f3878a6f8c +a60528f1f14bf0c496491d46a0fbbd6c343e4eb3f1631e92f96a3c5e5c684091aabe5801df7a67f7c6dfd1b0d35269d4 +a1fd8e7fad8ca05a340c05a051bb0eb4197eed345f4104629a9e38e234b09d789cc5537024615feb4a6177d32d39e39e +8e70e36c1aa070815440e19443f1f04aae23b1b59fdbcba43b47b94a026c82c8f66c5dfe54f826f4d95ee1930cdb8008 +8234c1969fa7e9079661e4ca309b71b1aaa10f4372be0b963205c23a81f5a3d52ec08ba9ff65b37f832b52d631580d61 +a18cb4134127fb37c4abca328cd0047378a2e1423490af2bd3eba9ffcc99ca81a3c22404c0886f21f65c7b93c41d7981 +b46fa45fe538816de776eec086e040005706cb3eca097e290abfb6864e745c879868aac8361894f3c3564373ef9ad55c +b96ca43b96c59e95439f75d1e726a35a9362f0dbd34963b156e103e080a8126a8dc3501f9fd541ff3bcf4677f5c4a86b +a8e8c87c7301613818d57387009e601a7ab5cbdc2890f63d985c30c74f9cea2d0584c116baf0d9cd5594386ee93fc661 +b47e4f1b9153ef0981f813948150f283b47a7346fd9921d51fe8e4daedaef78ddeb4fd467c2ccb7cebd9816243da1c6e +a370c202a99c8441ffe96fad0f801086d4d7cc7b960f6e98cca29ceedf492afddfd0f351c9c4d29ac008bc255ec1a2a8 +8f5e6ce1655d1c059b006174e3f5a55c88e1821c97f9702ad8e8455d46c2a83ae4482f2d43edda74a835686ec45a8a15 +a30421e694930a3b65d397b2720d5f8e1eec2b6e2bb5a28d3f9b0a84db9aabd83850268bae64c2b10e313cccf120151b +8abe87163046f7a9b18e2a3c0b66e258facc1b31431420e0b70354b7a60ebd250a784634a76692e7d6f4330b62114945 +894f033cf077d4eb312e3258d9dca414356271abce1d6094ecce6d018c5fadb1c15d8d69451574ad0701a2876db191c5 +b0923d64f88ffc872654e1a294bb1af8681689c21cf08f39afe51448a68e60a9a0a74ccce9969276a932a52c07d095a3 +b9ca23b5be8725fae7fa710eefd45522889c50c29c26384e00b78a962384f0aeff9d15cb5910e9565da12a577eb7e5ba +b242ccf292757197a9f470f2d80ccddc48c7f1235ba026bc68a93be2738bc968e8a200aff3e2f4807216442eb3fc50dc +adc2c3b375b308524b79a024ff87d122055440643fea6fc0a651bdb312c7cbe6a456afa9d342bc76446d77d8daf08bc2 +ab645955356c2ebf2f3df9da275e01daf0b44a52afc309277d6d9ad1b05484e5ae0d9d41ad485fe481e5e362826a86ae +8de96ac587a4449fcc8b7fd0a51b4b5185d9c2eb3434f94cbadd092de1e26b0f6b3f7b15a37e8424b1429121ddca0ecd +94c70ad4e9b871566f3da98170b665a09788d421818299857cde0853789fb943cbcf7d4b2c95246ea7b72edc56a8e36c +b2574be63497843340700b701d5cc8be6d23125bd62058802ee67cce1f3b5f5602b27c93fea5611f27dc695ac563f042 +869ec89da7850cedd88bcb3a50a15cece233119b31b64a61bf6b2310892ce42d8b473b584b11e61db29ed24ce8033f83 +8fbaa269da8e28e9adf4c1b08f109da786dbe9cba871c32eecbfb10619b7a5d65a26f9bb33e201a8ed20b3de94003fbb +8bf7a059c37242caf7f821a6314e4e4adf799e0dd86b37892a7172598892c07272acebd05b534755c57b51556b2d610f +b4e72645fca459898cdd9214892ed08b5c99f82049c0a30d72bac0b9717caa9c6cc16c3dc7aa6ea4d42dcd2a6c175df6 +a39170da87a3495da55bbb9701c5461f3403447174ed6a4af75712f7ba4ac35f51a4234bc4b94da888a0959ee109c0c7 +b45675b2774ea7696089dbf7a0afe6c22e85fd0e4ef3db508fbaf96c9d07f700c991789206da9309fd291be696357c5f +b52899e3e3f6341eefcbe1291db6664bf3b6e8021d32fb9c3e37b6258a35c1da927747b2ce990937d6f4c6c3e7d020d2 +84e5bdb3dfe19700d79dd3fabb0159ccfa084f7288db836c855b827613ce8071067c8d7ac5cc2b4e88ed7f84b690f6e1 +801477d200b6d12fc6e0a9bab1c8211193ab06e44551e037a9b4c36fc2d4f67760b9ff4eba9a3bc7b6e177e891f64ff6 +b6b71a5116d3c22af26a7530f535e9b7851f25a84e562a8f17a125d55b9b3fc1bd8cfe65bdcbeeb328409521e802051c +8687e21c34d7804c12489d30680d131ce2133e2981bfa993afd8a8eeda958ebd5e6881d342d725338659882d9f21cf98 +a024e97a7c4de32b6383c34431994abc533ecdbd6be9bff836ec1af022f5a86773bf345c6f33273797a61fb70a8fd5d6 +83f784f095da20ce5b31f54d6cb14b32a8a12675f0029289c9cd036b7c87a8077be2d04a62618685720e6ee69c875e97 +b4e9dfe7cb9d9efd3fe00d99ae5e48769d4af4bf43d4e05c0b54c9cfd8bc854de96b8d3ebf4dcc06b9dac66b7471a0de +a08b79f9d4673afcf7f38b57f484f88feb7c908f597663a2417f92c348150c2be6b5603f914eba0d9d5bdd4e5c5572c1 +b0eaf919589988798cb01ba0610cd1b7fa3c08715675ece8ecd5f9ef6d5d7b2c4c8ae1ea7dfd202237171aa3e6f9de74 +abff99a98baae4dd0954052503ce81827781694a5ea8c1149f96a3adde75dc2d630e138598cd2ae7fdc7a654aa17df8f +83e369b8680d8b9d995222b033b4f4f3e3b20e782113c941325c7fa9c742feef8747e4a212d9aa23285a259cc4faef8d +b16d5855dd2716613697eba36e2fae0872aaea6999e91cf6552f93f9a0b85ed4f6ff922a91b50816bd6cf8e7a4513fc9 +848373db600e32e741aa1d37726bbb28956783f89ce2d781e95fb1ee1adf4359968a141678af268077eae4c25503204e +93a0dd0fdac18a31875564505b4e28f9e8bb2915faae666538597731ac56cd77f23f2456461e2f672983fb24ad91f6e0 +ab1ebbe49fa56524b564bc2e43784147073e6ea5d27a9540fbf2e04d0f87c645ed2fd28b3e4982cc4c0af1734ee47a6f +b3ee30b733839edab6f61f0738e3f4afaeccf700d8dc7415684f193b36d70d07acd5780cf539f12e0fbf8d4683be773a +88388f2cbdec47a6b3ae460b69eb0d2130ac14de950c22fd86de03e40d02292bb93cebe62432da39d509c1289f785fef +9370c41a54b68ff486b4cc6329c3a851716ebf1d088d77a6c56dec93a18b8a77b596cde74cc17d2adb2b2f411a2e4bbb +b9083b60dc16531f77b05a955b51a237a8f8c0173d72c352c5ca441b55abbc890b14937e457aaec4be5cbbf80cae0099 +aafff8f6c6ebaad952c65054dfc7c829453ec735331bf8135e06406b7a9f740c9a200dc48bb2175516b41f77dc160121 +b43d31fbbaf10526809e9e5bd8bb47a76e0fabd7852ee7744404559ab89f0f215ff518f3271a6aa972a459cab82ac558 +b581ede48c6ef34e678f91dc4b89507413e00e70712e3e8c32a80eed770ec8d8b98caee9702d068aeaca6f704be57bd8 +8cb0a137e68b001a5ccac61de27cac9fb78d4af7b2f5a00b8d95d33ac19cc50c69e760c5e0330a85c0ded1edce0fe6f9 +b947fca07c7aa6c2bf13048275402b00b77b28f1d0ba4b589fbcede13f93b5b931c588560ab8ceba23bb8e748031b55d +81753cced5ff819901740a9a584334e355b497cb699f0be5a52cd555a4c9f149535c7bb355b54407f7f0ec27de6c2e19 +b3d59273951ce97838c4853ec329782a255b5fc7c848e7992ded1be28a5ada7fa3254123afe32607b9991ec6e0659b08 +86b253de246f82be1cb0cef01e87c3d022ca1829d2cc7e6a160a5afbd3ca6b94d75739b122e3bb16f8bde28a8f3223ba +b728b659fa2d8487e061a37f7d14a4c2d70cc37497a8715695d8d332cb274deee2ce23b9b5f6a7408516c02c3d526a49 +81277b46d98848a45abfbe39842495659dcbb80dee985a4fc91d77d52b815487aa8bb455f411fcce4c3879c7a075a93f +b05b6f1fb4a6e654f0ee6b83e08b58b57059bb0b7c490405bc8d963c4a2d6be39c558917977e554e1e9e3169961cbf3e +88f75fa7d016fb6442551ec071cc1e2beeb3ccd213d16d744f573a82f5d70f41dd1b18af71d5f9e73d87f2f6b7dbe889 +81a46434f1bbd65a661a0ff45a0295b8fd8a42a7969c5953721bc98698b64bddee3f806876d1e9983063fdd0c11f99df +8b4f6d33c510a4c9c7d623d9ae0c9aa631fcb987704726b2a4d8519372123bce3c439202f25b5b47045ec14ce39a21a8 +8d5112b330fb63cf6ef3d2164b404c14ff9907d685015701399a260951912b19b8f270f869df317e9050a127763d7980 +aadab394e84dfb82db15ecd2427f39b62352c3e1647c3bcd14fb24ae830ad0116f0fed87ddb63963b424a4741961386e +81ca4e5600d00a3bda24cbdea7a532a4cbbd893c10e7ff10667c15ffa8138b91667abe5466b31a3dcdd60155c48538c1 +ad943af1b8a5fcfcf309ed8f2f916339f254cd555c71a407a47365a139306286a05a8314e1c70e20a65fccd75d36fa12 +b16597a0b437060a390467bbfab94c0bdd695ae898894f4689f939e30cc2119cc08ecb594546304adf876f4e275ebcd9 +a44a4e0a6693be356065891c27eefa040a1a79475be53d54d5fdcea7e0668ff9b35f850974000ed119f6865aa6faa721 +adef27d1b6e6921f4eaf69c79e2e01f5174f7033eaafdd33edcfa5119af23f3a834ffe1bdf19576581b797abd1865b34 +90c1e9202f3ffe28f8e1f58e9650dc4ff4dbc158005b6f2296ec36147e524b4f2f87f8aafc39db5b006fe0c491c92f45 +ac817cd54288b6f7fe6338415344fc9e7b669414051631ab2f27851c052c044be06bf7235d668e194bef695923256368 +ab14944ef653a14456d4ebc12e3196df3f1b4707c4e50b317b5ccc8ca3a0720f0330609f0e7e71793f6ca01583f38c70 +ad5353f2f380837e5ffdf079350b3d42935a0517861d03af98db5ed3ea8501abd68885c8c65f5a66e944b1874826a450 +8b5583863f84af8443ce8970b02e26cc5d959e47efbf8a66a54106ab165f1f76b36423aee74c7b5402fd1c4d7c1adfe6 +b3b46037eed9fc30e4f8f0da8bdbdcc40a38e22e876ce9fde981883017854aba82c18eb00887d92ad847d30082fe7271 +98a2b6fc90b7ad172e4368c1e54675b75c8bf2096d91c9f2b60b3397d3be3b705aed5389845dbd68f0f84438cd0f7687 +b155e800852a5f90a2eac69cc4483428da1dc2c31588a13c924e60a7616ce9baeb7d4b829c772b260277cadd8ed84719 +b8b92c520a1302b0cf7d993a52e1dacd7f27bda9868d59c55687d995ae676b7070af4c0792a9bc1c2635d44a4fee01bb +96dfe9bde526b8fc829eda825f55168b88e8f4e43d4d708cc3060df03437b46e12a8ac70d7788aa75760f6294d3e84d8 +a3fa66c54e2fa084ced3bd838614c6c33042f492a5745d167a723c60d5e7d6020ffd1747981a23f8b68df21ad8f0fa77 +b573ca10cc41fc04a642f6f62c355a4fda69b94b8e95dbb02fd1ccce4bce1191356e1fd66d372159944eb36a7071f005 +acd0a1c9abddfd0ea223eda1722aaada362d34234455bd1c6be115d41e535b16f12ca428da7820a757fa4c98884a385d +96f242eee99c4db383b8754fa7987c0c159652e1866faec905a8d3f010e0a1ad05bd77b9ea8dfd653738959180f58430 +9215a9b672a5d6e435e0e0a45156e0e20f75cbbdf1d14940fed3ddb63d433bef643796c7a4fff881829ebb2b2eba9460 +b8ad9bfceaf08dc5a874387219ddd1170bc3a5e25ed72d321d59ae713be5ddf9fdfbd3aa7ab163be28dfa0dd14614e19 +a19a1050590bc500b32c502f393e407abc3d8e683d6f6b978873aff3e3299b18b1f6b59e2b0fe237d819dbdfcfdc98ca +a6870fb11d4429686e52e1f44c8dcfc7ea24a020df9570c021578dbc1f9bdc8cf797cb3a72d7fc52805dba35d59f2cd0 +a7be733b64d5c06c127bd1c87250e42bfe30ca91ed8ce51e0b6e377f454e8f6fef7f99bff650695df2fd10c375da349b +a1b97145dab30330eea2cdc8739b2446a3704b64505fcea3dd8a9b4a72edf222e98d967d6fd7f76794acfd97aa091065 +b2127049907d2a3b654d1c940b740bfba3dbaf660f86ea79c2f909af7c9fe2a07a1caeb1be12370aeffaf8faa50f1582 +8a207701214bb28e99b0784e9228b1c34afa701966267fe7110f6f29f5bb41eaae6cdb98844d0400787978fabd224de8 +9925147a383b6f5f814520220ffdbf20b214225882c3ef49b1a1ca677709176ec82466fb9c4be2dfbe5640afb63b014a +8416ad93871623fb555b5390b80de99edaaf317350cc0c1ae9d54d59517074d40061f315cce8ba2026d9c1e6f6a1009f +a315f943deebbf0a2cdbcf3f8323e215a406e9cbfbcc3f6288714cb3a6befb1bf71b2a21ff7a2ec4731c65044c45b6b5 +8213e0c2539c24efd186ffa8b6dd401ad2233bc19166a0623b26dd1e93614bbf792823f5599ac116231e2efde9885709 +8e5cafd2f34a127a4a896f05e4d929eef06972a1826b3566446942198df26d62f7679b987db2b3765d9d8058b1cd85c2 +b5302b399c9cdf912fd59007ad4737255552663b1e56dbe64a7b2ddd88d2093c73ea319b45db2dd49d1e03f5bef1a0ae +a0c2bcfbed4b008e1a56e5d2f2419aa59d7dd0ebd990f1c18588de702ad0fa79f445d69965fa9381e700eda13b309378 +80a44eea1ffe24c26b16b8e2e70ee519258b9ad4b3e83cc4e5cca88ebc48d0160066f8b91d0581095b0de2428390c8b3 +84a90cb9c7d2f799f1c4ed060387a4b793ab41c5c3eaffd3b60face9b9c3bae93cd2017283bf3de1e3dac63d0d84dd42 +81d22febca276a05ba9bbc5591ee087b0491beb35b4d9f8fc0d041d642a574667ddc57660b20f5c568f7d61fdcb41bda +a3ac965ac27a28e102a439b74fbfc157e75fd57620e4c0750a466165f8aeecb2191dcf8e656f7525aa50d9c7c69b0b5c +913c17434ff0d9fc52e2ece4fec71b37d4474a18f3ea26925c1be2b250434d49759f58033ba0fce1c6862c6197930dc4 +ac430559c151a5e461f67b49c7786c97e1653fa8698e9759ddbdd99f5daf17fc5a012ae6330739440880728f24eba7c9 +b10d8e9f8aed9361b042d1398ec74364f7c7c1cc5c7f917060572761138bdbe89bf409389ee3879f93bc8032dd67b308 +937271005a4cc6a6ec134870c1b56471aa84ed4f4af1b3d5f334bc0c42762fae0c9a6a2828d3de6151a76dad7b72781c +a10e4dcf51889f69e6bd4c052f8d4036b9571ced98a3d7d779cbcb9fa5c3a82228566ea7cc1d012bf56dea0a40c5a64c +a0ed026528d9a8bb3201bc9dcd20598933e8c72fd315deea8da63d06e97392aa729d98a55a8a60fa4d5573513ba5c9fe +b723fcd04cddbd4c36feae827a03746ffef251c4f4c55a88beedaeeee194430a99f566f483668a0d88b13e7a4a37f1de +84a2cdceed44828c7c05a6a762edec0165e434e7029df617d6646aba48776e6c3b823f40689cee136536f8c93e08a629 +b786264e3a237ac3a1d56c9f4e87438dfed620c867100fd38b01287f5b755c7820937403bfb86644e082094d3e410a00 +92cc35b2065fca157c7bba54410f8bd85907a01c9f760aa0ddb7a82cb55811d24cb4dc6b725367a6a1c293b809a48ead +a12bbf22b117f00164a42515bc57cc9e6c43cc77fb737ee3d0c0cad94cb50cd3847d61cab469cf8ca76f7958bdcfc771 +85985b00de533bde2a757eddf53be79ea39091d16af3fc92327bcd1cd59bf2bf4411a334da29ad775e8ffaf3cea7d7b8 +af9eb24185b0d330d0ea1d0b0fa78af0dcf42ced81cb0128f16cafdea687a9c5582bb6d7c5744117b271cd0b3303f0b5 +8c8aaa1d85ed6327f85d579767c7a9158d209171b3efcb3e8a9d9e534c078e821b6aade255101d2c9ef6d67ba66f10be +a450518a03ffb40e1df89e0f88fd55b5b06f4872cdfb7ec55f40dc40d9424b3b289866336c195bdd54597d95569e0096 +81e61cc69f93c435bd77f155e80626a9c764dd92b6c76af15c41346527948d8a6ca87d6351a0fe7987e2ee3aa66a9625 +b615e0cebf4fdff4cb23a20c8389c370915ba26aa703b28efe4ab070b1603d1c5b6541684acf46b52a915f6aee447539 +a7f51885c7a71885cc84ef734ecd107e8bf5f7a25131415f671d143cc1de92859e65001125323c7985799993af6c410d +abfbf7a46f32066989c32f774edcc68163f085ca81e94fe8c9fb32f8d451bbb2c20ac45cd8d97f9e618ab40186933b1a +8cf35a522b5cac1934004aa9dd236bc77198d43272888afa860cfc79b4b28dabf7a3c74098f84510897566fdd609aa45 +86aa927df78f7a06a4985eb0a4f0b93529cef14f9fd2812d46abffbf25e618ead14d99c70e3c3bb2e17f3f7fabc9c264 +860f1b4f4a398e9a8bb4739587cf96979cfbbe1687b7e91e5bd1198db726391b09b1a261bf12e96698818f60b5bd3537 +8e7c4ee19ff115881051e8637dce1f5d6c65e865d0c757e8ce41b6d7bcd86c7070cce60649692bbf28c868c7e2e1e2f4 +acf7ba01b0220419f09169ac8d16e5cc13dce08e88c90b8fdfaa33aab417f011a20b79a178d8a9f7211589d2e0affd7d +b404bde8e715aefbb9f20a353b911b79173ef3e2cf0aba98b5ae6190b90597d65043b0b4e014ad9ea6c77da2d213ea12 +97e3615d1c77a402253bb55da2d1cdf82de316cefffe42b1022c94b4818d6dc4a313731db85321c537914bdf716a875c +940e950b96a4096a578c6874d747515936652b9b113a5f27f5a834a610867b05f9881e2679b0b289b8527baa0009b6dd +8de15a13ca236a3a285ce6e6826c502ae7365bbe468b6e8ac67b15b0bb49be0e996f1eec81ef69e4b7f54f8e4779a054 +a12244777eacb08ecd42b5676b3a51153022ab97e9353ace0f47c6054c22de9ba60d2a60f59a36841c2a791cb1b7c288 +94f7580203e39a2642ee2e7c969b9911f011d7f3a90c398e1302d26edb3df03df1d0c43baa1c6cf90dde95296d49e742 +82ead33144aaecab965faf63af384565992f38fc1066e71e33d53f43ac93892e27fe78c4eaca1cccbc53364e26ff31e9 +a0c129e9706d354249a7f8aa664ccd7ede89aa1445c5547410814b56d10dc086720953363ab1da8ff5f1ed5d8e575104 +93b3057bf3f74edc95237781ae012cc4b1d3fd0455565ceaac7110290aa518ac32478ba4eb9851555fa87270fcc84f1f +949c2fd0b94f31f7cbf00c679bd3f6ec1a2f4056654708d39edf1a450b4e19a6e251d0bb24eb765087e698f61d3fca2c +99fd2e50e211ccb66b895eb2fc42f260f3ad5767f04c2fe238b81dae98aa6e3977443a51f4fe7b43f499caabe45699a5 +84fe19626503218f327b5325bfd7c0c3d2614b47d34964aa0259d564e769c6c81502132cc1765b0b31fbe39852706927 +b43287ec29d9010bec4284de58fed48dd1e129bac79f09d45153c9949131782f77b11b0c9f8ee06a39e5e9bbaa8e2c6d +908902f3ed45482df2f94415fc8e5a308057a40c8905d7cbbd58ec4848e19276577b7f7e69e5e684a8b981738e10f7ef +85cc7d9c1eae372b4f88758cd6e21604b4bc9f0794e1e74b6d9de96347f81944d01331385fae7a38e5f6096c1dc23465 +af60288c702082fc258b3dbd6952c6b75c1641a623905f491b1e72f49b9d39b33d150a336450abd3911a4c128166acdf +a7d8ac7e589558c4014369ab6f4c1f2196205b03e4278152ec0dbbd7ba54e803c3369a71d364a773aac8dbbd117e4a13 +9833aed34e48c206e9328073597aee1123f5bec085339b4e6839a389a429bf3042798a31fac1464ce963204adface76b +84631a4f012bbb62133030224b57deb32dcf464cacc8ffde7775adbe68707263ab5527a1c75e597e03aa703ba658b889 +a686a61f6467858a2a4c13e70ad81b1901290d3e51bbc0c6e366f9e652f575e91b11c75f640ccef8b0c6c1b05a43c9a0 +b585f0ffd5144907703b41539bfad7f9f058f5985f63db911064ba6b07af8da2796b84b16db42b8d11135c3f846cd9e2 +b525539516c7bb25f1d7e165f269dc8c9eedbba74df44887e178ab8fd798e2a31f39812ca922d6b64d91564f14012a64 +91e480d7568fd2fae39c35b0a8d623e66a3160fee1dd4e9097255004938b11ac1cd3918dc6a1e5fbcb700c95a547e5e8 +936ef55c69b842b6177de71fa48dc5442bf5132116b214302f8f242ca36a273a6bbfbfaf373777104dadbe8e7da5e970 +8e950c0f6688abdff8a3b8bd77be6da6f2565c7b55711f5860ea62a3ab1d51aac31821c602bc11a45e33c69e7dde3ea4 +90eed4595104a0527f8db1e028ff622ff70db4eae99cf47f6c2a0246ec7b103570a6a9a877e32e9647cc74969006743d +b756344f6c4ea05b792e416d9bd9ce9dd4bd904e7622761f28a85628506bfc9d88a25e5f04db62fad30a92fb1d8d8556 +ad79ba76534c1a02ac3e9b7308d390792984cd75b7e1d0e5e4ff123642d99d4ea1825643091aa8117336333c40d5bd94 +832b08144887de0c0341d84f6945450af8d7a4eb32367d7703118186c1be525df9382ce61fed5f3b65a0bb3449185f7f +a322fb944e46d8e47994820890c94af423674716da810ea1da71e0a7733ad72c22114ca39a4b59c98ce4291a5684c154 +b982851a65140dbea79bd3b5487e236feccee051deddcc17c2853032efca289ddb6eaf64be3dd85a73012fdbe9d2d4f3 +8eed5e230e201830b44b9fadca4e156fe1a16bf840cf29da0f381ea0587b20c226de2465c67e6268973e776809af68e1 +81c8f1c04490f36e41a53ee1b5185cb8adbb37c258fd6c3be8c56835bf574c37183a94d55b6554fca35d6e6dd9af0133 +8c4928724107cc16d36f2976677eac0b852fc4c3c0bb2f9cd4d59cd24a113faf33b2faf405c3fcce25be51d41e42c2c4 +8e4ba842636fdfc4d71f0983538ea5037d420acd26abd12efca48c252eea85544b2fa9fccdfec4e7c2a6359baffa112d +b4315b84700e26dec26f3488d308430fdff4809c10d4c24309627911cbb769ffaad0d1ecccd622dd02194eaf5ba59f91 +ab888308f757faef32648c1db01650dbc9aea248b09d06e6efcc996d395f48ec96f2d54a02de441d753fe8737862d991 +805094cfd77e207d5c75f3cad99f41f763ec15443052cfd758c6a82ba422d831a1103a7f9b100da49c28198279c3d3dc +ad857f33243e4a2cd2a773700def21fc7f94939d1a6d2c2125ecd58fc206ccafb07a2c02a1cfce19857d3654aca2c70c +a4d12d40149953daa70b89a329e918e9d93efb4e8004a9357fe76682dab9662c8507e16db83e849340f05cdb4933a373 +a0dbac2ed4b5d03606524245e8a31080eb5bd3e9a0c51dad88c3b18e3e6bc5d64953a81c8e60425b80107ee6b62b1fb4 +86da05355900f327164a78901f6e3db857531b33b1e855df1a67a9ba222c6b05fdb6b0ffbacaeb1ba5b45ff8979b6b68 +932c9873aa3e226dd922b5a616c75153bd0390ce8f332a414b9c8cb6606c2501a37a2aa88097bc7d8e2c4261706eb38c +accd9cdf07ccdd42033ce3b105e00bfd39e2304b1e3d66f8b1128645634452c20f759ec45adcef2fdf04408f62c4cc04 +b75cfdfc1cb48918752eab17eb579820ee6e71e6667abdb64df834ffc8c1362fbbc23ca2c80dee248fe1fbb72d87dfc8 +88b998c73b00638fde7d3dd650a08c5ab996dac6ac34251337fbff3fb5ae4a25dd20c1a16c987ad7ded19eca23cea891 +8afef0956c942571a27f504553fb312cca9e50ce41b44e0466d0516c5abe4d8acf4594cdb03b1ccdbe3f2e6a9093b713 +9042cd83c5ff261e9ebda26398caa16cac2cb840d19062fa8ae50e044c27104972948318f4c866dc4d578798272d3e49 +ad536719a64570a2cd1d72b6590ea1d02c8c49f259a7867be26c8191445165954bcfad50ea12688ace3fdfb0e98143bd +97c86328d63d297b6bc9718dc1ad5a05b908a750d1c455c700d84315589128ce4eea958aef2bcf0fcf4adbd8e3ce58d1 +8e592cf0802e6a9541eeb654dc55055e11f3d757847285197132935ca35bbb1a9156829a39384dfa6f645ff89eb36738 +ac16c614998944f77590bf3913a010e13f2d3bbf6a172293baf5983506c1a2d89989fb72e598f5bba1ea10a691377c93 +ab8e6f5b46baa6632de3621497bcbdd584decb999fe7d8a3364843a1e0b76497600630b6a24dd30119d8bcbfca29f335 +abe1d3af5279e60122d9cea8cc6581c819d7a0e20e3715da0f6da7e02d13a7653db643bd946e2fa9ba338eca81fbe140 +8c33bd831ecfb18d1d0713e16beba768e9c42df62170c1f8a16764912be77f2ac5915623d1d25e8c462aa9c2f6669ca4 +903692becae4a6409f7bdb127d9b11de57a5739fe24218dcbaa0092648d5332dfeef29a908ee9e43e5e0a51a4c3639bc +92591e90347ae286acd365eba32cd9ad8f20f4c9cad2dc579b195147ff290adf0d776bcb3d4b04a25d68a941fc0c781b +b64bbccf860299aec16e1f95c768a1f337c740bde612e6ba260e393edb8b04540127194761c42597abb9bcb771c576c3 +9194f056ccfdfeb78a11c5347e2255d7a7ebd1251f9aebc0b58feb68d3e03a7dbbb74e3ef7309455853adfb4694bd01a +aa4f15f6d6a53ae65b7f6f91e8981d07a5919d2138679a561f7bb608dc4596e45ca06c9441d51fb678b2ad89ae7a17ae +90e3d18507beb30bde08c5001faf489a19ab545c177efb3f73fbf5605f9a0abcdc8bfbc44f832d6028e3e0a834bea98f +8f31dc0118c8c88a6e79e502d10e57652b7aba8409a5bf572ca63fed6b7cbad7f28bbc92ac2264f649792fc1d0715085 +a307d1067ea4c56437b6f8913aa8fcbf4a24580fc1e3336e7f6518f0f3adb9c4733090e459a3f737414ec0048179c30a +b7cc41fdf89595cd81a821669be712cd75f3a6c7a18f95da7d7a73de4f51bb0b44771c1f7cd3cd949e6f711313308716 +a9dc74e197fe60e8c0db06b18f8fe536381946edecdf31e9bd90e1ebfcad7f361544884e2fe83c23b5632912ec284faf +8b3e1e81326d611567e26ed29108f33ddb838c45bbd1355b3ae7e5d463612af64b63fff9fa8e6f2c14c8806021a5a080 +92f6537bca12778866335acc1eb4c3dfc2c8e7e5cf03399743dcea46aa66cac92ac2963b0892784263ad0ebe26ffdbf6 +b5cc0061f7a3e41513199c7dd91ac60d727366482a4c7328527f7bd4fc3509412f711bb722b4413b3736a219b843d15d +b3e9711d68d2c6f6e2cc27e385d5f603d9a1c9a96edeefa1ffdf390439954d19504d6aadc566b47e229ad4940ef020d2 +a09d0d3f0e5dc73a4a0827b72710b514bbfce4a7fcd5141d498a5aad6c38071077f50d3f91af897d9ab677b7041dedda +b177fe260f3b86e9ac21f1bfbe2682ae5dd8c9aecebb84f37054bdab6e39094e611ce582210ceeddde66adf759dadb6d +b0ac6595eba9f5dc4b2fd21856267cfbcfb5b12aa34ec69ca32b80071c5b652e85c25a224d80443d503bf25fbbfe07e9 +81f3c0e11b196bd4a2e8f07f8c037002566dc9037da81f3988add458a520c24dd1be3d43d851e28c0c6a85de4b57a542 +a44308c95615f7fedb2d2127012924468c015df9f48359cc2e36ab4223870b0bfc1e9040baabefdf5266f93afaad896b +8493ec4c32d5a13b81039f1b436eb83f259945dc950e3c6c2ccf5087ec56dd2f60890ed4edf01728b6a54950e19b35c6 +a1a439ec2a6a95bdac9aaa925ff337ba956c0d236ab5318354270e73ed6b73b4ae2d27b4c1686cf97b6526d04e65be81 +b4659b7b53c55a4b2bbe210b53520b392f893500e18990d843b72d7379d45fb44dd1dd2184348d6fd853d6b9ecc6b7c6 +afb2c68d75d00130b0e1b4f250001920213121791698ec04262db714cf7b1408d39f6cc10421f954845aad5b8250b77e +b22b843b40a97210f94043b552f348f66743055a3f274856a738e7d90a625b80e9bbb80cbbb450e1666eb56b8bd5c60f +800895ced82fe13d5fff65a93b0051c3df698bf1221b682accfdb63e3970f669ca37025750697f4e8ff2a3322ad57be4 +b21f598c50d7b9f4a584d548f85e42055ef8e24991906d973749090261584c7f4f5e984b528926f7e75375dd84d51af8 +849b1c68192d18274598dd6d0bf48fb5ee3b1ba25b331cff2d06f345bef3bed49760ca5690848cf33388f6a9a32cd646 +aeb6fd9478b10ef456f6bbb1e6dd19b14475e65497772d12cfc097948383d3fbd191bf95f046b8bf1989954118e483d0 +b1b5e0ea2835f7fc8b66e7731e392b43d16cbce04b52906b6751ab1b91978899db5fecbdabc23a19dabb253005468136 +91b6b1284770cf6f7ef35bc0b872b76c7763ffcfa68f9c8cfabcb2f264a66d47598bb9293f6a40f4c3dd33c265f45176 +b9ffed029846487c2cfb8a4bb61782bd8a878f3afdb73c377a0ebe63139fa070e3fcdc583eec3a53fdc5a421ff1fa877 +998007249d041b0b40ff546131cfc86d0b3598dcedf9a8778a223f7ed68ba4833b97324cbb1de91292b8ff51beab44b3 +8eb77ce9e0e406bf6f002870fb2fd1447646dd240df9bd485f8e0869298a1fc799d8a41b130c04370e9a9cc5c7540ca5 +853db8157462c46f2af7e8f94f2ed1c9b9a7ba2896b4973296898ff3d523d6e29e0b63a5d26cecd5e490b33c87a4cecf +b1436b6f3278768f0979ee852944258f2599977d255bea6fc912ba17c5dff5bdc850cf3e1fc52be9d6d188e868670f4f +a76acbc5832019b3b35667ab027feff49f01199a80016620f5c463dfcbfb51bf276ed17b7b683158ba450660cc7973eb +94540cdb051faf3ae8b8c52662868c2dab66bd02505c4f5f8eb4d6b2e2e5fd9a610890c5dcf8fd887eee796d2b5753a8 +aa35099666bceccf4eb3b65b13bba88e30a8be93693ab6761d8e5523343e8d6dd42d977e66499352fe4e9e9784a1dd0d +894471aad17be54319083c4b5e40adcfacf7c36c4aab0b671030b7ef321c53590a25eccd836efd20f32a93185fd315bb +8f52a9f705bb0dea958fcfbd52e2b6c08ad0f89a07a6b2942c1b4c37eead0d97a38a9e9aeb08d5d59b7fa2a9347f738b +9031c16b4f936c9cab55585dc5064739f696c3347ee2c0792320c9f749e760d120e396e8485ffc79d81c9f3337ad3d1c +82090a0d0d9b05459ec1c328ecd4707c333b784e3aaa0ef0072cee1eac83f9a653a75d83b9f63512a8c41200494826b4 +92c3a9553001f9ea4d67236b8ad1a33275378202cc1babc03f313895458f4b2549bfbbbdd37bfb8fbff0decb6b9f820a +88651868f4da37338a22bc553388df5dd1dd0cb78c4d7d07c637d8f6faef4bed72476fdcd4304d5bedf3514011135f08 +83fa0141bfebd88063f1d787719721b4c6b19ecf565b866de9d7d5d1a890e0e3d859b364bb65f8f8e688654456a40263 +90a7fab753e5d56dfc0e53a6b4e6ab14508220f3a62b3f3f30570c4c9ad225e74122635826c92e8e3227ec45e551432a +8fa375b0345bf6e5e062d108f9feaec91029345ecac67ccf1264eac77b8654cbfdda1f10579f481889c0e210254eadde +b83f06116da9daebdb013b26724523f077debaf6bc618b48a7a68858a98d275f7899c4ec73a0a827219b9248dd81c8c9 +8be1cada55e0c5ebb4fd460b2d209ae5326285a20c8bdd54ed9d1a87302f4063c8730bfda52d9d40e0d6fe43a0628465 +a68ad6f813743ec13a811f2ef3982c82d9d9ac1f7733936aa1e122f8dc7f4a305cc221579ab8fc170c3f123a1576f9ab +8878f1128214fdbbb8a0edd85223741e021508ab6d36c50d38680f2951ee713ea056ed03f62b9461897963d50ceefe0b +acc0d43d1b0260528b7425b260a5dea445b232b37240759fc65fe26f7c9d8e51569c5722bc33e94de6492f4ba1783504 +ad80b1dd717b076910ee5ceabcb762e75e4d094dc83b93b65c16de1f75bc712cef223c05d5579c1561829406c07a97d9 +a6fc9803f9c09d95fc326cc284f42ea5566255eb215dba8a9afb0be155ea11bcc55938b2d16f01cd2f2eda218c715efb +83ad733dbdfbaae8095a403dbf09130513f4ed4f08dcf8dd76ce83d1ea72999b7eea3a7b731da0d2bc80a83c6ee0e3e0 +8748912fbd08cb34a85416b0937d9c4327e9eed20d6e30aeb024a7253f14f1e0d774f3326e54738d71aae080e28da0fe +8997e78d8acf23051428af67183ae9b2c4aa42b503745ffe33df35a35103c589987e1473ab14dcd28ee78ebcb10d8e95 +a2f340502a7eb3c4a36412e6f028321372c4fa18a4743945607424e932af1271fa3e6598a162c872072529576eba6283 +868ccf19b5044ab93b45c9ed3ae34fcb504fe1453d6c4a1d12c325032cf01eb90356de82080ed897e97dba13cae33a02 +ac8867005fe4354d67aa37b866a7e581d2f94f7bd0b9f4efb5c2d1370ec13147a60692051b02fd00ae60b512bce9b1ff +8fd01886b046819c83c12bb779e432b25ba13713f9227be702074ec3abb2bba6be37220a0a26a4bd4171b99b14e32bc4 +a128981ed199f92b5959975c150a93a62fec50b61c80a3fa0634d90fc8058f76f5cbee77aae6889af12d296b30e613cd +81fe618552ff7a36c9235c6d4066cf2f930b5b38de4089e18166e4a06ca5723eadd1976d25e34b74b3ce942300b23e5b +ab1223ea049e6e0fbf9b611de7fd7c15e5e9637cbd73aa0e36aea08a7503ba6804f2aa807186fdc9aa7f4f9195f72e24 +b97285286981b2665f898abc13f3243b63005bef8db4cab3f658bf6167036b61af400f08db0fc3c640a9c623b760690d +ae3ddff7c1f0fbb6a13dbbc667a61e863c2c7c51c2051e33cd61620142e7e30a7e0c4c1f8fbb512aa3a8640267c6ac26 +99c2a89d5bef236060e51c4f952664094c20fbfca647e5d24a55c1fb8df2f3df58244fbbf3635db07b1c29ee3234fa6f +a5010764d4b9cd3b410638334d1f70c5f4843f45b4f4a9316aaea5fbb2c510a97449dd7a07b49f47334a69d37d9955d3 +86706d011dcdc9e9d165d01fea1df68dd74bedaf15a39f92893c030cafe96f4498c4c1fec2d2136354341b3f440a1462 +88fd57eb62bd7dc35722f3a0576c2138403a2f663a2603482e8974a895cf56ddbb02657dc6b89eb2cf5c1f9d1aff6426 +b0dfd4c68e3acb6bb8a776adaa421fc5e268ed4d5964bb90a727091e5113b55b3f9c6d33cedb3ee47ff7acc5df8b1749 +93b92bc942e1a636fc5c2dc1840de5faf158a113d640d5a475b48e2c56ccccaf9db0e37e90ce74c4b3f5c9ac3b2eb523 +b29a16fa1ea95cbfc1873c435ad40dc8495ba6341801b72bd95d908147dcffb1b4bb426dd635f3af4c88984f56594dd8 +b8f367105e1a2d554ac30200c66aeb579d3d30a8953d20fb6ebba2d876ec39c52ea5d654f1bb89b8ddf3d9d651f31cdf +b5fbc228c983d08adf8612eba5b3db3acff604439226f86aa133b02cce4ffde2f977c8dbb8b446b4375673f71634c89d +a399bea37d3056e0559f6644faa0af93063b4b545d504d7e228d3dbbc294af83d3c4cf37fe026b63899b4e7d50fd08f5 +928ef411a36414b24aea26fdbed4bdb1bb6bdc2d967e2553ce54c7c4e077e76869cea590257645c9129dd55ce025295c +9684a4adeed416a9ce82ad79b55c4a3adcfbd43950bc442ed8a340381caedb70f4baaaf821e3a152f483f965d8f56162 +92558a37f214d6f4cb6d72cd2f4ad24dff9d17611b9e4a41ee5c741a5d1ca9e4053b0584533ef4da206110b5dc3e2a35 +973bf0724d1785cc5e85d2a8ee8c354ad4cf557217ced0b7940f6f064024c20b2bfc5b144c820b5083da4bf70690de4d +adaf1389dfa528210ca9c2657c5ff10d51f7e3b18e93a59c37211be0506c3576cb2c04ec80cd0f82605e53c5a3556620 +85b58b223b09fda6f3ab674d75e780c49eb2167837243df049281e8f4fed653811138b398db9cdfe7405fdb8485602fe +849504d3db408d80745a07e850b0a804607b91a59922a5d3bc40da2748c029c029419cda38d2a4485cc0824c6b2504f0 +a3f4afcb353bc2582a02be758ebf0cd18752410ca2e64231176bfa23828423e0a450a65f241a9ed8eab36cae8d9c567b +ae362786cdf121206537af9590d330abbc6dc328b53cdd145dbed0e5df1364c816aae757c4c81f9d619e3698dd32bcdf +9024cfa5b0101eb02ab97866d5a3832944e5aa6888484cfba3d856576b920787b364fba5956bd7c68a305afedc958201 +8a116df09fed923acefb2aecf38a4fbc4b973ee964d67f03791d70bee6356af43ffca117d4e9463ffaf0e0d5d5e5a69f +9163016175c73f1bbc912ddfe03bd4e1db19c64951c8909ee6befe71a1249d838e0db49f03670bb4c5c9b2ab0fb4fef3 +8f6357318d8d16e7240a02b05ce5a4976b6079d49daa258789c6dbf4a47950ebe9de6411780fab06c7c1f35651433380 +8e63cbae8be7341892dbedee3111adf0307c4ee9e375181aa53478f5ba9cdce164d6ae890e5f480119a3a51c6e989165 +a9782f30674a4874d91bfba7eda63aeb5dbe66b040c768d6a925d8ee135f0655ea56276b105239cc0668fc91ddb68cd1 +8d9d94b61ab84ec08665cbe0244ea41756785df019e453ef078c19380bd44c39d2958e8465c72eacf41eed5696037805 +b1470e6f5d2e314474937cb5a3bc30c8bf5fc3f79014945f6ee895fe20028ffc272f9d3a7320aac93e36c96d8a5454e3 +a444911bbafc71179766594f3606b6eaff041826607fd3192f62dec05cd0f01b78598609a530f6930e8440db66f76713 +a9823d44e2638fca7bcc8796cc91c3eb17f46ad6db9f7f6510e093727614aa3a4f9b2c4011ef91dc1c2d224d08d8d05b +ab86020972c359ab98294212558b4b14862040139876c67fc494184b5c9bcea1dbe32fe0c8dd9e60be9daa304acd599a +b7e5cb685bbdcfdb1e48259a5d68d047846c8a35c5b3f90172fb183d1df40d22eaf0edaca2761a07c29c577000ccfed0 +8c88319dae4b28989817e79e6667fd891181e8d2ed91b9c6b614985bca14b12982462ec58b17be0463c24bbb79dd62a1 +8c1c6867e7107fb2178157c991b9c8b0f90c8d57a51220bf3650438ccabccf62da4db8a9916491e730ff3d0c106496e3 +a00a79bd58da6528b9af033087260f9f3d00519eafb4746b355204ee994e89481591b508eaa5402821083e250d38467b +8785abd7c37690f6aa870ee5c799eef72e398a7898b6767f698515be277b9c2fc1af12ea89b0620a848221343a3b5ec3 +8aadae68543db65cef71d0e230a09508d72061398ef2fabec0f856aacff2125b79c70e620744aaf331faf3dfc8afb9bc +8ff0cd437fcad9630b8a2333176a55e178db4142ec841581590594d74d5b53baeac5fb903fdf7bcf83e245b95b58285e +af274e8fad6b190be4e5dc92d2705ba6ac0d7e1ea29e958a5cdd4cb764de46a56d9eef62c999a16e7c50a50b2d9fe3a8 +865e6ec7d1aa848786d6a7a4e87a24d442311f0810b01ef5a74928ab59fdfd651e48880b49680047e5b0df6b3c7c2ecc +800706baaeb35bf3bc33bdea9a8b5cb00d82df407b3b7e1b781a9359cf44fb410ed311591080181b768aae223d9246aa +a9496389d0780b309c6998374ae159f58a8d0fe9a1c24c36cebcb45b27d818e653b51a8ee1f01e30a9b2c46a548126ef +b5fccf4fc3186661939fbee2e89c2aa0e3a6ad4907bcc98c7750520540c4c183b1bbfcdf47f2f1c5e75c3a30cdf30c75 +a90028e39081b736e628c2230cc1338f9210ed01309a40fdf08d39c10cced2cdf71271013bea6dba3a0444fe47963106 +a0815cbb325a8fecf2e1bcc5046644be32d43a8001bd5d8cf0022e4572cd0d481b3e717002f7ab21e16da5f5d16886d6 +b2024787fcda52abc4138150f15e81f4a5be442929b1651ddccbfd558029912be4d61c3c9b467605fff640edf7392494 +ab5aa60032304a584cc9245a33f528eae7157808dedd1ad83ebae00aadc25dbe1cd5917eb8b6b2c800df15e67bdd4c4d +866643847ef512c5119f2f6e4e3b8d3f4abb885f530bb16fcef0edb698a5b0768905e51536283925b6795a5e68b60ddc +806aa99c9a46ee11cc3ebf0db2344b7515db8c45b09a46a85f8b2082940a6f7263f3c9b12214116c88310e706f8e973a +a6eada8b9ff3cd010f3174f3d894eb8bb19efdbff4c6d88976514a5b9968b0f1827d8ac4fe510fb0ba92b64583734a1e +98480db817c3abbc8b7baedf9bf5674ec4afcfd0cd0fd670363510a426dad1bcf1b1cb3bf0f1860e54530deb99460291 +81ab480187af4a3dfbc87be29eca39b342a7e8e1d1df3fc61985e0e43d8d116b8eac2f1021bde4ae4e5e3606c1b67a21 +8a37df12dc997bf9b800f8fd581a614a1d5e32b843f067d63d1ca7fde2e229d24413d3a8308ec1e8389bf88154adb517 +b045a55ca0bb505bd5e8fcc4cfdd5e9af1a7d5fe7a797c7ede3f0b09712b37f493d3fcf6ef0e759d7e0157db1f583c95 +ad502e53a50691238323642e1d8b519b3c2c2f0fd6a0dd29de231f453be730cf1adc672887d97df42af0a300f7631087 +80597648f10c6d8fcd7421caf4e7f126179633078a1724817d2adc41b783723f302eabc947a7ba7767166dacf4ce8fa1 +aefb56427966c81081999dffbe89f8a0c402041929cd4e83d6612866cfbb97744f4ab802578349fbecc641fa9955e81b +a340e493fb3fb604eab864d4b18a6e40ba657003f1f88787e88e48b995da3d0ab4926ce438bdc8d100a41912a47dace0 +a6d777bfc0895eac541a092e14499ff8bf7156689d916a678b50a1460583b38e68158984bea113a0a8e970d8a6799a85 +90ce469410f0e8cfff40472817eb445770833cdcf2895a69bc32bcf959854d41712599ceb2b0422008d7300b05e62e02 +815c51be91d8516d5adc2fd61b6600957ed07cf5fdc809aa652b059bea8ed179638a19077a3f040334032f0e7900ac8b +b3ec6c0c3c007c49c6b7f7fc2ffd3d3a41cdff5ad3ac40831f53bfc0c799ffeed5f440a27acc5f64432e847cc17dd82e +823637abeab5fb19e4810b045254558d98828126e9a2d5895a34b9e4b4f49ab0a5b3ee2422f1f378995ea05df5516057 +ac05412bcf46c254f6548d8107a63928bba19ab6889de5d331eb68cf4d8ce206055b83af4cb7c6c23b50188391e93f84 +88514163c587068178302bc56e9a8b3ad2fa62afd405db92f2478bb730101358c99c0fe40020eeed818c4e251007de9c +b1e657d0f7772795b3f5a84317b889e8ded7a08ea5beb2ab437bebf56bcb508ae7215742819ed1e4ae3969995fe3b35d +a727d4f03027fe858656ca5c51240a65924915bd8bd7ffa3cfc8314a03594738234df717e78bb55a7add61a0a4501836 +b601682830fc4d48ece2bdc9f1a1d5b9a2879c40c46135f00c2c3ae1187c821412f0f0cfbc83d4e144ddd7b702ca8e78 +b5cfea436aa1f29c4446979272a8637cb277f282825674ddb3acac2c280662fb119e6b2bdd52c4b8dbf2c39b1d2070d6 +85c211645ff746669f60aa314093703b9045966604c6aa75aae28422621b256c0c2be835b87e87a00d3f144e8ab7b5f0 +867628d25bab4cb85d448fd50fdd117be1decdd57292e194a8baa0655978fae551912851660a1d5b9de7a2afbb88ef5c +a4e79c55d1b13c959ff93ddcf1747722c6312a7941a3b49f79006b3165334bab369e5469f1bddebadb12bfaff53806d5 +ac61f0973e84546487c5da7991209526c380e3731925b93228d93a93bce1283a3e0807152354f5fe7f3ea44fc447f8fe +a1aa676735a73a671a4e10de2078fd2725660052aa344ca2eb4d56ee0fd04552fe9873ee14a85b09c55708443182183a +8e2f13269f0a264ef2b772d24425bef5b9aa7ea5bbfbefbcc5fd2a5efd4927641c3d2374d0548439a9f6302d7e4ba149 +b0aacdaf27548d4f9de6e1ec3ad80e196761e3fb07c440909524a83880d78c93465aea13040e99de0e60340e5a5503cd +a41b25ae64f66de4726013538411d0ac10fdb974420352f2adb6ce2dcad7b762fd7982c8062a9bac85cdfcc4b577fd18 +b32d87d5d551f93a16ec983fd4ef9c0efcdae4f5e242ce558e77bcde8e472a0df666875af0aeec1a7c10daebebab76ea +b8515795775856e25899e487bf4e5c2b49e04b7fbe40cb3b5c25378bcccde11971da280e8b7ba44d72b8436e2066e20f +91769a608c9a32f39ca9d14d5451e10071de2fd6b0baec9a541c8fad22da75ed4946e7f8b081f79cc2a67bd2452066a9 +87b1e6dbca2b9dbc8ce67fd2f54ffe96dfcce9609210a674a4cb47dd71a8d95a5a24191d87ba4effa4a84d7db51f9ba0 +a95accf3dbcbf3798bab280cabe46e3e3688c5db29944dbe8f9bd8559d70352b0cfac023852adc67c73ce203cbb00a81 +a835f8ce7a8aa772c3d7cfe35971c33fc36aa3333b8fae5225787533a1e4839a36c84c0949410bb6aace6d4085588b1e +8ef7faa2cf93889e7a291713ab39b3a20875576a34a8072a133fed01046f8093ace6b858463e1e8a7f923d57e4e1bc38 +969ecd85643a16d937f148e15fb56c9550aefd68a638425de5058333e8c0f94b1df338eaab1bd683190bfde68460622b +8982f4c76b782b9b47a9c5aeb135278e5c991b1558e47b79328c4fae4b30b2b20c01204ff1afb62b7797879d9dee48e2 +b5098b7ba813178ced68f873c8c223e23a3283d9f1a061c95b68f37310bca4b2934a3a725fff1de1341c79bb3ba6007e +97b160787009f7b9649ed63db9387d48a669e17b2aba8656792eb4f5685bb8e6386f275476b4dfbb1b4cb0c2a69bc752 +88b69369c71daad6b84fa51a0f64a6962d8c77e555b13c035ad6fa1038e7190af455b1bd61ae328b65d6a14cf3d5f0d5 +af88b87801361f0de26bd2533554ee6f4d8067e3122b54161c313c52cc9eafea00661c5c43e2d533485d1f26da4e5510 +98ab18e3bbcb23ac1e34439849e56009bb765ab2f2558ebfd0a57cbe742169f114bceb930533fb911b22cb5a8fe172bc +9027507f1725d81e5ac0f0854c89ab627df3020fe928cb8745f887bf3310086c58fca1119fd5cd18a7d3561c042d58de +a676583f8a26e6f8991a0791916ce785b596ce372812f5eb7b4243ba9367ea95c797170fdac5b0c5e6b7f6519cc2b026 +b91b0ab32638aef3365035a41c6068e36d2303bfee8640565e16c9a56c21703270fd45946ce663238a72c053eb3f2230 +aaf4cd1ac0a30906dcd2b66b37848c6cc443da511e0b0367fd792887fdaf1500551590440e61d837dbee9d24c9801108 +a06f20a02d3cd76029baad5a12592f181738378a83a95e90470fa7cc82a5ae9d2ed824a20eeb1e96e6edc0619f298688 +a465d379c3481b294efc3f2f940b651c45579607cf72d143b99705eae42103a0279eb3595966453130e18935265e35d6 +892a8af7816a806295278027a956663ea1297118ede0f2a7e670483b81fb14dccacc7a652e12f160e531d806ca5f2861 +b480917c0e8b6e00de11b4416a20af6c48a343450a32ee43224559d30e1fecdece52cc699493e1754c0571b84f6c02c2 +b3182da84c81e5a52e22cebed985b0efc3056350ec59e8646e7fd984cdb32e6ac14e76609d0ffaca204a7a3c20e9f95d +a04ea6392f3b5a176fa797ddec3214946962b84a8f729ffbd01ca65767ff6237da8147fc9dc7dd88662ad0faefdb538c +95c0d10a9ba2b0eb1fd7aa60c743b6cf333bb7f3d7adedce055d6cd35b755d326bf9102afabb1634f209d8dacfd47f1a +a1a583d28b07601541fa666767f4f45c954431f8f3cc3f96380364c5044ff9f64114160e5002fb2bbc20812b8cbd36cb +a1a0708af5034545e8fcc771f41e14dff421eed08b4606f6d051f2d7799efd00d3a59a1b9a811fa4eddf5682e63102ea +ab27c7f54096483dd85c866cfb347166abe179dc5ffaca0c29cf3bfe5166864c7fa5f954c919b3ba00bdbab38e03407d +ac8c82271c8ca71125b380ed6c61b326c1cfe5664ccd7f52820e11f2bea334b6f60b1cf1d31599ed94d8218aa6fbf546 +a015ea84237d6aa2adb677ce1ff8a137ef48b460afaca20ae826a53d7e731320ebdd9ee836de7d812178bec010dd6799 +925418cda78a56c5b15d0f2dc66f720bda2885f15ffafb02ce9c9eed7167e68c04ad6ae5aa09c8c1c2f387aa39ad6d1b +87c00bba80a965b3742deacafb269ca94ead4eb57fdb3ed28e776b1d0989e1b1dba289019cfb1a0f849e58668a4f1552 +948d492db131ca194f4e6f9ae1ea6ebc46ebbed5d11f1f305d3d90d6b4995b1218b9606d114f48282a15661a8a8051ca +8179617d64306417d6865add8b7be8452f1759721f97d737ef8a3c90da6551034049af781b6686b2ea99f87d376bce64 +918e3da425b7c41e195ed7b726fa26b15a64299fe12a3c22f51a2a257e847611ac6cfcc99294317523fc491e1cbe60c4 +a339682a37844d15ca37f753599d0a71eedfbbf7b241f231dd93e5d349c6f7130e0d0b97e6abd2d894f8b701da37cb11 +8fc284f37bee79067f473bc8b6de4258930a21c28ac54aaf00b36f5ac28230474250f3aa6a703b6057f7fb79a203c2c1 +a2c474e3a52a48cd1928e755f610fefa52d557eb67974d02287dbb935c4b9aab7227a325424fed65f8f6d556d8a46812 +99b88390fa856aa1b8e615a53f19c83e083f9b50705d8a15922e7c3e8216f808a4cc80744ca12506b1661d31d8d962e4 +a1cbd03e4d4f58fc4d48fa165d824b77838c224765f35d976d3107d44a6cf41e13f661f0e86f87589292721f4de703fb +b3a5dde8a40e55d8d5532beaa5f734ee8e91eafad3696df92399ae10793a8a10319b6dc53495edcc9b5cfd50a389a086 +996e25e1df5c2203647b9a1744bd1b1811857f742aee0801508457a3575666fcc8fc0c047c2b4341d4b507008cd674c2 +93e0a66039e74e324ee6c38809b3608507c492ef752202fff0b2c0e1261ca28f1790b3af4fdb236f0ed7e963e05c1ec0 +b6084e5818d2d860ac1606d3858329fbad4708f79d51a6f072dc370a21fdb1e1b207b74bc265a8547658bfb6a9569bb3 +a5336126a99c0ecfc890584b2a167922a26cae652dfc96a96ab2faf0bf9842f166b39ceaf396cd3d300d0ebb2e6e0ebf +b8b6f13ce9201decaba76d4eca9b9fa2e7445f9bc7dc9f82c262f49b15a40d45d5335819b71ff2ee40465da47d015c47 +b45df257b40c68b7916b768092e91c72b37d3ed2a44b09bf23102a4f33348849026cb3f9fbb484adfea149e2d2a180ff +a50d38ee017e28021229c4bb7d83dd9cdad27ab3aa38980b2423b96aa3f7dc618e3b23895b0e1379ca20299ff1919bbf +97542cf600d34e4fdc07d074e8054e950708284ed99c96c7f15496937242365c66e323b0e09c49c9c38113096640a1b6 +822d198629697dcd663be9c95ff1b39419eae2463fa7e6d996b2c009d746bedc8333be241850153d16c5276749c10b20 +9217bc14974766ebdfbf6b434dd84b32b04658c8d8d3c31b5ff04199795d1cfad583782fd0c7438df865b81b2f116f9c +93477879fa28a89471a2c65ef6e253f30911da44260833dd51030b7a2130a923770ebd60b9120f551ab373f7d9ed80aa +87d89ff7373f795a3a798f03e58a0f0f0e7deab8db2802863fab84a7be64ae4dcf82ece18c4ddbefccd356262c2e8176 +a3ba26bd31d3cc53ceeced422eb9a63c0383cde9476b5f1902b7fe2b19e0bbf420a2172ac5c8c24f1f5c466eecc615d4 +a0fe061c76c90d84bd4353e52e1ef4b0561919769dbabe1679b08ef6c98dcfb6258f122bb440993d976c0ab38854386b +b3070aa470185cb574b3af6c94b4069068b89bb9f7ea7db0a668df0b5e6aabdfe784581f13f0cf35cd4c67726f139a8c +9365e4cdf25e116cbc4a55de89d609bba0eaf0df2a078e624765509f8f5a862e5da41b81883df086a0e5005ce1576223 +a9036081945e3072fa3b5f022df698a8f78e62ab1e9559c88f9c54e00bc091a547467d5e2c7cbf6bc7396acb96dd2c46 +8309890959fcc2a4b3d7232f9062ee51ece20c7e631a00ec151d6b4d5dfccf14c805ce5f9aa569d74fb13ae25f9a6bbe +b1dc43f07303634157f78e213c2fae99435661cc56a24be536ccbd345ef666798b3ac53c438209b47eb62b91d6fea90a +84eb451e0a74ef14a2c2266ff01bd33d9a91163c71f89d0a9c0b8edfcfe918fc549565509cd96eed5720a438ff55f7f2 +9863b85a10db32c4317b19cc9245492b9389b318cf128d9bbc7ec80a694fcbbd3c0d3189a8cad00cc9290e67e5b361ee +8a150ee474ebe48bdfcac1b29e46ac90dcded8abbe4807a165214e66f780f424be367df5ef1e94b09acf4a00cd2e614d +a6677a373130b83e30849af12475e192f817ba4f3226529a9cca8baaefb8811db376e4a044b42bf1481268c249b1a66e +b969cbf444c1297aa50d1dfa0894de4565161cb1fc59ba03af9655c5bf94775006fe8659d3445b546538a22a43be6b93 +8383167e5275e0707e391645dc9dea9e8a19640ecfa23387f7f6fcaddff5cde0b4090dfad7af3c36f8d5c7705568e8d8 +a353ddbc6b6837773e49bb1e33a3e00ca2fb5f7e1dba3a004b0de75f94a4e90860d082a455968851ef050ae5904452e0 +adeccf320d7d2831b495479b4db4aa0e25c5f3574f65a978c112e9981b2663f59de4c2fa88974fdcabb2eedb7adab452 +afa0eacc9fdbe27fb5e640ecad7ecc785df0daf00fc1325af716af61786719dd7f2d9e085a71d8dc059e54fd68a41f24 +a5b803a5bbe0ca77c8b95e1e7bacfd22feae9f053270a191b4fd9bca850ef21a2d4bd9bcd50ecfb971bb458ff2354840 +b023c9c95613d9692a301ef33176b655ba11769a364b787f02b42ceb72338642655ea7a3a55a3eec6e1e3b652c3a179e +8fa616aa7196fc2402f23a19e54620d4cf4cf48e1adfb7ea1f3711c69705481ddcc4c97236d47a92e974984d124589e5 +a49e11e30cb81cb7617935e8a30110b8d241b67df2d603e5acc66af53702cf1e9c3ef4a9b777be49a9f0f576c65dcc30 +8df70b0f19381752fe327c81cce15192389e695586050f26344f56e451df2be0b1cdf7ec0cba7ce5b911dcff2b9325ae +8fbbc21a59d5f5a14ff455ca78a9a393cab91deb61cf1c25117db2714d752e0054ed3e7e13dd36ad423815344140f443 +a9a03285488668ab97836a713c6e608986c571d6a6c21e1adbd99ae4009b3dde43721a705d751f1bd4ebf1ea7511dfed +b2f32b8e19e296e8402251df67bae6066aeefd89047586d887ffa2eacdf38e83d4f9dc32e553799024c7a41818945755 +942cf596b2278ad478be5c0ab6a2ad0ceafe110263cc93d15b9a3f420932104e462cf37586c374f10b1040cb83b862e0 +aaa077a55f501c875ceae0a27ef2b180be9de660ef3d6b2132eb17256771ce609d9bc8aaf687f2b56ae46af34ad12b30 +90ac74885be1448101cf3b957d4486e379673328a006ea42715c39916e9334ea77117ff4a60d858e2ccce9694547a14f +9256cdfc2339e89db56fd04bd9b0611be0eefc5ee30711bcece4aadf2efcc5a6dcc0cfd5f733e0e307e3a58055dff612 +a4c7384e208a0863f4c056248f595473dcde70f019ddaede45b8caf0752575c241bac6e436439f380ac88eee23a858e9 +a3aa67391781e0736dddc389f86b430b2fc293b7bd56bfd5a8ec01d1dd52ed940593c3ad4ce25905061936da062b0af6 +80299275ec322fbb66cc7dce4482ddd846534e92121186b6906c9a5d5834346b7de75909b22b98d73120caec964e7012 +aa3a6cd88e5f98a12738b6688f54478815e26778357bcc2bc9f2648db408d6076ef73cced92a0a6b8b486453c9379f18 +b07c444681dc87b08a7d7c86708b82e82f8f2dbd4001986027b82cfbed17b9043e1104ade612e8e7993a00a4f8128c93 +af40e01b68d908ac2a55dca9b07bb46378c969839c6c822d298a01bc91540ea7a0c07720a098be9a3cfe9c27918e80e8 +abd8947c3bbc3883c80d8c873f8e2dc9b878cbbb4fc4a753a68f5027de6d8c26aa8fbbafeb85519ac94e2db660f31f26 +a234f9d1a8f0cb5d017ccca30b591c95ec416c1cb906bd3e71b13627f27960f61f41ed603ffbcf043fd79974ec3169a8 +835aaf52a6af2bc7da4cf1586c1a27c72ad9de03c88922ad172dce7550d70f6f3efcc3820d38cd56ae3f7fc2f901f7a0 +ae75db982a45ad01f4aa7bc50d642ff188219652bb8d521d13a9877049425d57852f3c9e4d340ffec12a4d0c639e7062 +b88884aa9187c33dc784a96832c86a44d24e9ffe6315544d47fc25428f11337b9ffd56eb0a03ad709d1bf86175059096 +8492ca5afcc6c0187b06453f01ed45fd57eb56facbeea30c93686b9e1dab8eaabd89e0ccb24b5f35d3d19cd7a58b5338 +9350623b6e1592b7ea31b1349724114512c3cce1e5459cd5bddd3d0a9b2accc64ab2bf67a71382d81190c3ab7466ba08 +98e8bf9bed6ae33b7c7e0e49fc43de135bffdba12b5dcb9ff38cb2d2a5368bb570fe7ee8e7fbe68220084d1d3505d5be +ab56144393f55f4c6f80c67e0ab68f445568d68b5aa0118c0c666664a43ba6307ee6508ba0bb5eb17664817bc9749af0 +827d5717a41b8592cfd1b796a30d6b2c3ca2cdc92455f9f4294b051c4c97b7ad6373f692ddafda67884102e6c2a16113 +8445ce2bb81598067edaa2a9e356eda42fb6dc5dd936ccf3d1ff847139e6020310d43d0fec1fe70296e8f9e41a40eb20 +9405178d965ee51e8d76d29101933837a85710961bb61f743d563ef17263f3c2e161d57e133afac209cdb5c46b105e31 +b209f9ed324c0daa68f79800c0a1338bbaf6d37b539871cb7570f2c235caca238a2c4407961fcb7471a103545495ef2c +92ae6437af6bbd97e729b82f5b0d8fb081ca822f340e20fae1875bdc65694cd9b8c037a5a1d49aa9cae3d33f5bad414e +9445bdb666eae03449a38e00851629e29a7415c8274e93343dc0020f439a5df0009cd3c4f5b9ce5c0f79aefa53ceac99 +93fdab5f9f792eada28f75e9ac6042a2c7f3142ba416bfdb1f90aa8461dbe4af524eee6db4f421cb70c7bc204684d043 +a7f4dc949af4c3163953320898104a2b17161f7be5a5615da684f881633174fb0b712d0b7584b76302e811f3fac3c12f +a8ac84da817b3066ba9789bf2a566ccf84ab0a374210b8a215a9dcf493656a3fa0ecf07c4178920245fee0e46de7c3ec +8e6a0ae1273acda3aa50d07d293d580414110a63bc3fb6330bb2ee6f824aff0d8f42b7375a1a5ba85c05bfbe9da88cb5 +a5dea98852bd6f51a84fa06e331ea73a08d9d220cda437f694ad9ad02cf10657882242e20bdf21acbbaa545047da4ce5 +b13f410bf4cfce0827a5dfd1d6b5d8eabc60203b26f4c88238b8000f5b3aaf03242cdeadc2973b33109751da367069e1 +a334315a9d61b692ad919b616df0aa75a9f73e4ea6fc27d216f48964e7daebd84b796418580cf97d4f08d4a4b51037cd +8901ba9e963fcd2f7e08179b6d19c7a3b8193b78ca0e5cf0175916de873ca0d000cd7ac678c0473be371e0ac132f35a2 +b11a445433745f6cb14c9a65314bbf78b852f7b00786501b05d66092b871111cd7bee25f702d9e550d7dd91601620abb +8c2f7b8e7b906c71f2f154cc9f053e8394509c37c07b9d4f21b4495e80484fc5fc8ab4bdc525bd6cfa9518680ba0d1a2 +b9733cebe92b43b899d3d1bfbf4b71d12f40d1853b2c98e36e635fdd8a0603ab03119890a67127e6bc79afae35b0bef2 +a560f6692e88510d9ba940371e1ada344caf0c36440f492a3067ba38e9b7011caac37ba096a8a4accb1c8656d3c019b3 +ac18624339c1487b2626eef00d66b302bdb1526b6340d6847befe2fdfb2b410be5555f82939f8707f756db0e021ed398 +afd9a3b8866a7fe4f7bc13470c0169b9705fcd3073685f5a6dcff3bdbbc2be50ac6d9908f9a10c5104b0bffc2bc14dad +97f15c92fe1f10949ed9def5dd238bc1429706e5037a0e0afb71c2d0e5845e2fed95a171c393e372077a7c7059f8c0e0 +9453a1d4d09c309b70968ea527007d34df9c4cfd3048e5391aac5f9b64ca0c05dde5b8c949c481cfc83ef2e57b687595 +b80e4b7c379ad435c91b20b3706253b763cbc980db78f782f955d2516af44c07bbfa5888cbf3a8439dc3907320feb25a +8939f458d28fefe45320b95d75b006e98330254056d063e4a2f20f04bcb25936024efe8d436d491ed34b482f9b9ae49c +a9ead2e833f71f7e574c766440c4b3c9c3363698c7ade14499a56003a272832ee6d99440887fa43ccdf80265b9d56b97 +b6547a36934f05ce7b779e68049d61351cf229ae72dc211cc96a2a471b2724782f9355fdb415ea6f0ea1eb84fe00e785 +828bfb3099b7b650b29b0f21279f829391f64520a6ab916d1056f647088f1e50fac9253ef7464eceab5380035c5a59c4 +8d714b9ea650be4342ff06c0256189e85c5c125adf6c7aeca3dba9b21d5e01a28b688fc2116ce285a0714a8f1425c0b8 +8a82eda041b2e72a3d73d70d85a568e035fbd6dc32559b6c6cfdf6f4edcb59a6ba85b6294a721aa0a71b07714e0b99ae +af5665ebc83d027173b14ffb0e05af0a192b719177889fadc9ac8c082fda721e9a75d9ce3f5602dbfd516600ee3b6405 +a68fdddf03d77bebdb676e40d93e59bd854408793df2935d0a5600601f7691b879981a398d02658c2da39dbbf61ef96c +8c001ebc84fcf0470b837a08a7b6125126b73a2762db47bbdc38c0e7992b1c66bac7a64faa1bf1020d1c63b40adc3082 +8553889b49f9491109792db0a69347880a9cf2911b4f16f59f7f424e5e6b553687d51282e8f95be6a543635247e2e2c2 +a2c269d6370b541daf1f23cc6b5d2b03a5fa0c7538d53ae500ef875952fe215e74a5010329ff41461f4c58b32ad97b3d +a5dae097285392b4eba83a9fd24baa03d42d0a157a37fae4b6efc3f45be86024b1182e4a6b6eadcf5efe37704c0a1ae5 +89871a77d2032387d19369933cd50a26bda643e40cfd0ce73febe717a51b39fae981406fd41e50f4a837c02a99524ef9 +8a76d495e90093ec2ac22f53759dc1cf36fbb8370fb586acbd3895c56a90bbf3796bcc4fc422ca4058adf337ead1402e +ad4eb7576c4954d20623c1336c63662c2a6fb46ec6ef99b7f8e946aa47488dcb136eab60b35600f98c78c16c10c99013 +894c2b120cec539feb1d281baaadde1e44beafedeeec29b804473fe024e25c1db652f151c956e88d9081fb39d27e0b19 +9196bd5c100878792444c573d02b380a69e1b4b30cb59a48114852085058a5fd952df4afee3ecceb5c4ede21e1ed4a1a +a996fffc910764ea87a1eedc3a3d600e6e0ff70e6a999cb435c9b713a89600fc130d1850174efe9fc18244bb7c6c5936 +8591bb8826befa8bee9663230d9a864a5068589f059e37b450e8c85e15ce9a1992f0ce1ead1d9829b452997727edcf9d +9465e20bb22c41bf1fa728be8e069e25cda3f7c243381ca9973cbedad0c7b07d3dd3e85719d77cf80b1058ce60e16d68 +926b5ce39b6e60b94878ffeae9ff20178656c375fb9cfe160b82318ca500eb3e2e3144608b6c3f8d6c856b8fe1e2fbcf +a1ef29cbc83c45eb28ad468d0ce5d0fdd6b9d8191ba5ffa1a781c2b232ed23db6b7b04de06ef31763a6bfe377fa2f408 +9328e63a3c8acf457c9f1f28b32d90d0eeadb0f650b5d43486a61d7374757a7ada5fc1def2a1e600fa255d8b3f48036f +a9c64880fcb7654f4dd08f4c90baac95712dd6dd407e17ea60606e9a97dc8e54dd25cb72a9bf3fc61f8d0ad569fe369d +a908eb7b940c1963f73046d6b35d40e09013bfbfbeb2ccd64df441867e202b0f3b625fa32dd04987c3d7851360abdffc +b3947b5ed6d59e59e4472cdb1c3261de1b5278fb7cb9b5fca553f328b3b3e094596861ea526eca02395f7b7358155b7b +99da7f190d37bc58945f981cf484d40fcf0855cf8178e2ce8d057c7f0a9d9f77425fdbce9ef8366f44f671b20fd27d0b +913976d77d80e3657977df39571577fdf0be68ba846883705b454f8493578baa741cfaede53783e2c97cc08964395d83 +8d754a61e5164a80b5090c13f3e936056812d4ae8dc5cc649e6c7f37464777249bc4ae760a9806939131f39d92cca5bf +82ffd098480828a90cb221a8c28584e15904bad477c13b2e2d6ef0b96a861ce4a309a328fe44342365349456ad7c654f +89ae3ce4b0357044579ca17be85d8361bb1ce3941f87e82077dd67e43ec0f95edd4bd3426225c90994a81a99e79490b7 +a170892074016d57c9d8e5a529379d7e08d2c1158b9ac4487ac9b95266c4fd51cb18ae768a2f74840137eec05000dd5a +aafd8acd1071103c7af8828a7a08076324d41ea530df90f7d98fafb19735fc27ead91b50c2ca45851545b41d589d0f77 +8623c849e61d8f1696dc9752116a26c8503fd36e2cbbc9650feffdd3a083d8cdbb3b2a4e9743a84b9b2ad91ac33083f2 +ac7166ddd253bb22cdbd8f15b0933c001d1e8bc295e7c38dc1d2be30220e88e2155ecd2274e79848087c05e137e64d01 +a5276b216d3df3273bbfa46210b63b84cfe1e599e9e5d87c4e2e9d58666ecf1af66cb7ae65caebbe74b6806677215bd0 +88792f4aa3597bb0aebadb70f52ee8e9db0f7a9d74f398908024ddda4431221a7783e060e0a93bf1f6338af3d9b18f68 +8f5fafff3ecb3aad94787d1b358ab7d232ded49b15b3636b585aa54212f97dc1d6d567c180682cca895d9876cacb7833 +ab7cb1337290842b33e936162c781aa1093565e1a5b618d1c4d87dd866daea5cebbcc486aaa93d8b8542a27d2f8694c7 +88480a6827699da98642152ebc89941d54b4791fbc66110b7632fb57a5b7d7e79943c19a4b579177c6cf901769563f2f +a725ee6d201b3a610ede3459660658ee391803f770acc639cfc402d1667721089fb24e7598f00e49e81e50d9fd8c2423 +98924372da8aca0f67c8c5cad30fa5324519b014fae7849001dcd51b6286118f12b6c49061219c37714e11142b4d46de +a62c27360221b1a7c99697010dfe1fb31ceb17d3291cf2172624ebeff090cbaa3c3b01ec89fe106dace61d934711d42d +825173c3080be62cfdc50256c3f06fe190bc5f190d0eb827d0af5b99d80936e284a4155b46c0d462ee574fe31d60983d +a28980b97023f9595fadf404ed4aa36898d404fe611c32fd66b70252f01618896f5f3fda71aea5595591176aabf0c619 +a50f5f9def2114f6424ff298f3b128068438f40860c2b44e9a6666f43c438f1780be73cf3de884846f1ba67f9bef0802 +b1eee2d730da715543aeb87f104aff6122cb2bf11de15d2519ff082671330a746445777924521ec98568635f26988d0c +862f6994a1ff4adfd9fb021925cccf542fca4d4b0b80fb794f97e1eb2964ef355608a98eec6e07aadd4b45ee625b2a21 +8ce69a18df2f9b9f6e94a456a7d94842c61dea9b00892da7cf5c08144de9be39b8c304aeca8b2e4222f87ba367e61006 +b5f325b1cecd435f5346b6bc562d92f264f1a6d91be41d612df012684fdd69e86063db077bc11ea4e22c5f2a13ae7bee +85526870a911127835446cb83db8986b12d5637d59e0f139ad6501ac949a397a6c73bd2e7fba731b1bb357efe068242c +8552247d3f7778697f77389717def5a149fc20f677914048e1ed41553b039b5427badc930491c0bae663e67668038fd1 +a545640ee5e51f3fe5de7050e914cfe216202056cd9d642c90e89a166566f909ee575353cb43a331fde17f1c9021414e +8b51229b53cff887d4cab573ba32ec52668d197c084414a9ee5589b285481cea0c3604a50ec133105f661321c3ca50f5 +8cdc0b960522bed284d5c88b1532142863d97bbb7dc344a846dc120397570f7bd507ceb15ed97964d6a80eccfef0f28e +a40683961b0812d9d53906e795e6470addc1f30d09affebf5d4fbbd21ddfa88ce441ca5ea99c33fd121405be3f7a3757 +a527875eb2b99b4185998b5d4cf97dd0d4a937724b6ad170411fc8e2ec80f6cee2050f0dd2e6fee9a2b77252d98b9e64 +84f3a75f477c4bc4574f16ebc21aaa32924c41ced435703c4bf07c9119dd2b6e066e0c276ff902069887793378f779e0 +a3544bc22d1d0cab2d22d44ced8f7484bfe391b36991b87010394bfd5012f75d580596ffd4f42b00886749457bb6334b +b81f6eb26934b920285acc20ceef0220dd23081ba1b26e22b365d3165ce2fbae733bbc896bd0932f63dcc84f56428c68 +95e94d40a4f41090185a77bf760915a90b6a3e3ace5e53f0cb08386d438d3aa3479f0cd81081b47a9b718698817265cd +b69bd1625b3d6c17fd1f87ac6e86efa0d0d8abb69f8355a08739109831baeec03fd3cd4c765b5ff8b1e449d33d050504 +8448f4e4c043519d98552c2573b76eebf2483b82d32abb3e2bfc64a538e79e4f59c6ca92adff1e78b2f9d0a91f19e619 +8f11c42d6a221d1fda50887fb68b15acdb46979ab21d909ed529bcad6ae10a66228ff521a54a42aca0dad6547a528233 +a3adb18d7e4a882b13a067784cf80ea96a1d90f5edc61227d1f6e4da560c627688bdf6555d33fe54cab1bca242986871 +a24d333d807a48dc851932ed21cbdd7e255bad2699909234f1706ba55dea4bb6b6f8812ffc0be206755868ba8a4af3f9 +a322de66c22a606e189f7734dbb7fda5d75766d5e69ec04b4e1671d4477f5bcb9ff139ccc18879980ebc3b64ab4a2c49 +88f54b6b410a1edbf125db738d46ee1a507e69bc5a8f2f443eb787b9aa7dbd6e55014ec1e946aabeb3e27a788914fb04 +b32ee6da1dcd8d0a7fd7c1821bb1f1fe919c8922b4c1eeed56e5b068a5a6e68457c42b192cbaef5dc6d49b17fa45bc0f +8a44402da0b3a15c97b0f15db63e460506cb8bef56c457166aea5e8881087d8202724c539ef0feb97131919a73aefca8 +b967e3fead6171fa1d19fd976535d428b501baff59e118050f9901a54b12cc8e4606348454c8f0fc25bd6644e0a5532e +b7a0c9e9371c3efbbb2c6783ce2cc5f149135175f25b6d79b09c808bce74139020e77f0c616fa6dcb3d87a378532529d +a54207782ffc909cd1bb685a3aafabbc4407cda362d7b3c1b14608b6427e1696817aeb4f3f85304ac36e86d3d8caa65b +98c1da056813a7bfebc81d8db7206e3ef9b51f147d9948c088976755826cc5123c239ca5e3fe59bed18b5d0a982f3c3f +ae1c86174dfafa9c9546b17b8201719aecd359f5bbeb1900475041f2d5b8a9600d54d0000c43dd061cfda390585726ff +a8ee5a8be0bd1372a35675c87bfd64221c6696dc16e2d5e0996e481fec5cdbcb222df466c24740331d60f0521285f7d3 +8ddadbe3cf13af50d556ce8fc0dd77971ac83fad9985c3d089b1b02d1e3afc330628635a31707b32595626798ea22d45 +a5c80254baf8a1628dc77c2445ebe21fbda0de09dd458f603e6a9851071b2b7438fe74214df293dfa242c715d4375c95 +b9d83227ed2600a55cb74a7052003a317a85ca4bea50aa3e0570f4982b6fe678e464cc5156be1bd5e7bba722f95e92c5 +b56085f9f3a72bea9aa3a8dc143a96dd78513fa327b4b9ba26d475c088116cab13843c2bff80996bf3b43d3e2bddb1d6 +8fa9b39558c69a9757f1e7bc3f07295e4a433da3e6dd8c0282397d26f64c1ecd8eb3ba9824a7cacfb87496ebbb45d962 +879c6d0cb675812ed9dee68c3479a499f088068501e2677caeae035e6f538da91a49e245f5fcce135066169649872bee +91aa9fd3fed0c2a23d1edda8a6542188aeb8abee8772818769bdee4b512d431e4625a343af5d59767c468779222cf234 +a6be0bb2348c35c4143482c7ef6da9a93a5356f8545e8e9d791d6c08ed55f14d790d21ee61d3a56a2ae7f888a8fd46ca +808ee396a94e1b8755f2b13a6ffbedef9e0369e6c2e53627c9f60130c137299d0e4924d8ef367e0a7fad7f68a8c9193c +ad1086028fcdac94d5f1e7629071e7e47e30ad0190ae59aaebfb7a7ef6202ab91323a503c527e3226a23d7937af41a52 +9102bdaf79b907d1b25b2ec6b497e2d301c8eac305e848c6276b392f0ad734131a39cc02ed42989a53ca8da3d6839172 +8c976c48a45b6bc7cd7a7acea3c2d7c5f43042863b0661d5cd8763e8b50730552187a8eecf6b3d17be89110208808e77 +a2624c7e917e8297faa3af89b701953006bf02b7c95dfba00c9f3de77748bc0b13d6e15bb8d01377f4d98fb189538142 +a405f1e66783cdcfe20081bce34623ec3660950222d50b7255f8b3cc5d4369aeb366e265e5224c0204911539f0fa165e +8d69bdcaa5d883b5636ac8f8842026fcc58c5e2b71b7349844a3f5d6fbecf44443ef4f768eac376f57fb763606e92c9f +82fce0643017d16ec1c3543db95fb57bfa4855cc325f186d109539fcacf8ea15539be7c4855594d4f6dc628f5ad8a7b0 +8860e6ff58b3e8f9ae294ff2487f0d3ffae4cf54fd3e69931662dabc8efd5b237b26b3def3bcd4042869d5087d22afcf +88c80c442251e11c558771f0484f56dc0ed1b7340757893a49acbf96006aa73dfc3668208abea6f65375611278afb02a +8be3d18c6b4aa8e56fcd74a2aacb76f80b518a360814f71edb9ccf3d144bfd247c03f77500f728a62fca7a2e45e504c5 +8b8ebf0df95c3f9b1c9b80469dc0d323784fd4a53f5c5357bb3f250a135f4619498af5700fe54ad08744576588b3dfff +a8d88abdaadd9c2a66bc8db3072032f63ed8f928d64fdb5f810a65074efc7e830d56e0e738175579f6660738b92d0c65 +a0a10b5d1a525eb846b36357983c6b816b8c387d3890af62efb20f50b1cb6dd69549bbef14dab939f1213118a1ae8ec2 +8aadf9b895aeb8fdc9987daa937e25d6964cbd5ec5d176f5cdf2f0c73f6f145f0f9759e7560ab740bf623a3279736c37 +99aeda8a495031cc5bdf9b842a4d7647c55004576a0edc0bd9b985d60182608361ed5459a9d4b21aa8e2bd353d10a086 +832c8b3bfcd6e68eee4b100d58014522de9d4cefa99498bc06c6dca83741e4572e20778e0d846884b33439f160932bca +841f56ebefc0823ab484fc445d62f914e13957e47904419e42771aa605e33ab16c44f781f6f9aa42e3a1baf377f54b42 +a6e40271d419e295a182725d3a9b541ffd343f23e37549c51ecaa20d13cf0c8d282d6d15b24def5702bfee8ba10b12ac +8ac00925ac6187a4c5cde48ea2a4eaf99a607e58b2c617ee6f01df30d03fafada2f0469178dd960d9d64cbd33a0087d8 +b6b80916b540f8a0fe4f23b1a06e2b830008ad138271d5ba3cd16d6619e521fe2a7623c16c41cba48950793386eea942 +8412c0857b96a650e73af9d93087d4109dd092ddf82188e514f18fcac644f44d4d62550bfa63947f2d574a2e9d995bbb +b871395baa28b857e992a28ac7f6d95ec461934b120a688a387e78498eb26a15913b0228488c3e2360391c6b7260b504 +926e2d25c58c679be77d0e27ec3b580645956ba6f13adcbc2ea548ee1b7925c61fcf74c582337a3b999e5427b3f752f2 +a165fa43fecae9b913d5dcfc232568e3e7b8b320ce96b13800035d52844c38fd5dbf7c4d564241d860c023049de4bcbc +b4976d7572fd9cc0ee3f24888634433f725230a7a2159405946a79315bc19e2fc371448c1c9d52bf91539fd1fe39574b +a6b461eb72e07a9e859b9e16dfa5907f4ac92a5a7ca4368b518e4a508dc43f9b4be59db6849739f3ef4c44967b63b103 +b976606d3089345d0bc501a43525d9dca59cf0b25b50dfc8a61c5bd30fac2467331f0638fab2dc68838aa6ee8d2b6bc9 +b16ea61c855da96e180abf7647fa4d9dd6fd90adebadb4c5ed4d7cd24737e500212628fca69615d89cb40e9826e5a214 +95a3e3162eb5ea27a613f8c188f2e0dcc5cbd5b68c239858b989b004d87113e6aa3209fa9fad0ee6ecef42814ba9db1a +b6a026ab56d3224220e5bce8275d023c8d39d1bdf7eec3b0923429b7d5ef18cf613a3591d364be8727bb1fa0ba11eabb +949f117e2e141e25972ee9ccdd0b7a21150de7bbf92bbd89624a0c5f5a88da7b2b172ba2e9e94e1768081f260c2a2f8d +b7c5e9e6630287d2a20a2dfb783ffe6a6ff104ff627c6e4e4342acc2f3eb6e60e9c22f465f8a8dc58c42f49840eca435 +872be5a75c3b85de21447bb06ac9eb610f3a80759f516a2f99304930ddf921f34cbffc7727989cdd7181d5fc62483954 +a50976ea5297d797d220932856afdd214d1248230c9dcd840469ecc28ea9f305b6d7b38339fedb0c00b5251d77af8c95 +80b360f8b44914ff6f0ffbd8b5360e3cabe08639f6fe06d0c1526b1fe9fe9f18c497f1752580b30e950abd3e538ad416 +a2f98f9bf7fac78c9da6bb41de267742a9d31cf5a04b2fb74f551084ec329b376f651a59e1ae919b2928286fb566e495 +8b9d218a8a6c150631548e7f24bbd43f132431ae275c2b72676abbea752f554789c5ff4aac5c0eeee5529af7f2b509ef +aa21a243b07e9c7b169598bf0b102c3c280861780f83121b2ef543b780d47aaa4b1850430ee7927f33ece9847c4e0e1a +8a6f90f4ce58c8aa5d3656fe4e05acccf07a6ec188a5f3cde7bf59a8ae468e66f055ac6dfc50b6e8e98f2490d8deedc5 +8e39f77ca4b5149ffe9945ceac35d068760ba338d469d57c14f626dd8c96dbe993dd7011beff727c32117298c95ee854 +83bd641c76504222880183edd42267e0582642c4993fe2c7a20ce7168e4c3cbf7586e1d2d4b08c84d9b0bf2f6b8800b8 +a9d332993cf0c1c55130e5cf3a478eb5e0bfb49c25c07538accc692ef03d82b458750a7b991cc0b41b813d361a5d31e3 +a0fc60e6a6015df9bee04cea8f20f01d02b14b6f7aa03123ab8d65da071b2d0df5012c2a69e7290baae6ed6dd29ebe07 +a2949dde2e48788ceaac7ec7243f287ffe7c3e788cdba97a4ab0772202aeef2d50382bed8bf7eff5478243f7eabe0bda +a7879373ea18572dba6cf29868ca955ffa55b8af627f29862f6487ee398b81fe3771d8721ca8e06716c5d91b9ac587cb +b3c7081e2c5306303524fbe9fe5645111a57dffd4ec25b7384da12e56376a0150ab52f9d9cc6ca7bdd950695e39b766d +a634a6a19d52dcb9f823352b36c345d2de54b75197bcd90528d27830bd6606d1a9971170de0849ed5010afa9f031d5be +88f2062f405fa181cfdb8475eaf52906587382c666ca09a9522537cfebbc7de8337be12a7fd0db6d6f2f7ab5aefab892 +b1f0058c1f273191247b98783b2a6f5aa716cf799a8370627fc3456683f03a624d0523b63a154fe9243c0dfd5b37c460 +ae39a227cc05852437d87be6a446782c3d7fbe6282e25cf57b6b6e12b189bdc0d4a6e2c3a60b3979256b6b5baf8f1c5f +802a1af228ab0c053b940e695e7ef3338f5be7acf4e5ed01ac8498e55b492d3a9f07996b1700a84e22f0b589638909cd +a36490832f20e4b2f9e79ee358b66d413f034d6a387534b264cdeac2bca96e8b5bcbdd28d1e98c44498032a8e63d94d2 +8728c9a87db2d006855cb304bba54c3c704bf8f1228ae53a8da66ca93b2dac7e980a2a74f402f22b9bc40cd726e9c438 +a08f08ab0c0a1340e53b3592635e256d0025c4700559939aeb9010ed63f7047c8021b4210088f3605f5c14fb51d1c613 +9670fd7e2d90f241e8e05f9f0b475aa260a5fb99aa1c9e61cd023cbad8ed1270ae912f168e1170e62a0f6d319cf45f49 +a35e60f2dd04f098bf274d2999c3447730fe3e54a8aff703bc5a3c274d22f97db4104d61a37417d93d52276b27ef8f31 +859df7a21bc35daec5695201bd69333dc4f0f9e4328f2b75a223e6615b22b29d63b44d338413ca97eb74f15563628cb7 +b2b44ad3e93bc076548acdf2477803203108b89ecc1d0a19c3fb9814d6b342afc420c20f75e9c2188ad75fdb0d34bb2d +941173ee2c87765d10758746d103b667b1227301e1bcfecef2f38f9ab612496a9abd3050cef5537bf28cfecd2aacc449 +92b0bea30ebed20ac30648efb37bac2b865daaa514316e6f5470e1de6cb84651ff77c127aa7beed4521bda5e8fc81122 +af17bf813bb238cf8bb437433f816786612209180a6c0a1d5141292dc2d2c37164ef13bfc50c718bfcc6ce26369298a2 +8461fd951bdfda099318e05cc6f75698784b033f15a71bce26165f0ce421fd632d50df9eeced474838c0050b596e672c +83281aa18ae4b01e8201e1f64248cc6444c92ee846ae72adb178cef356531558597d84ff93a05abf76bfe313eb7dbe86 +b62b150f73999c341daa4d2f7328d2f6ca1ef3b549e01df58182e42927537fc7971c360fe8264af724f4c0247850ef12 +a7022a201f79c012f982b574c714d813064838a04f56964d1186691413757befeeaada063e7884297606e0eea1b1ed43 +a42ac9e8be88e143853fd8e6a9ff21a0461801f0ac76b69cca669597f9af17ecb62cccdcdcbe7f19b62ab93d7f838406 +80f1ca73b6ba3a2fbae6b79b39c0be8c39df81862d46c4990c87cbf45b87996db7859d833abc20af2fcb4faf059c436a +b355943e04132d5521d7bbe49aea26f6aa1c32f5d0853e77cc2400595325e923a82e0ff7601d1aee79f45fd8a254f6ae +87142c891d93e539b31d0b5ead9ea600b9c84db9be9369ff150a8312fe3d10513f4c5b4d483a82b42bc65c45dd9dd3bd +823c3d7f6dda98a9d8c42b3fee28d3154a95451402accadb6cf75fc45d2653c46a569be75a433094fa9e09c0d5cf1c90 +b3c3497fe7356525c1336435976e79ec59c5624c2fb6185ee09ca0510d58b1e392965e25df8a74d90d464c4e8bb1422b +88c48d83e8ddc0d7eea051f3d0e21bc0d3a0bb2b6a39ece76750c1c90c382a538c9a35dc9478b8ceb8157dcccbbf187a +93da81a8939f5f58b668fefdc6f5f7eca6dc1133054de4910b651f8b4a3267af1e44d5a1c9e5964dc7ab741eb146894b +8b396e64985451ac337f16be61105106e262e381ea04660add0b032409b986e1ac64da3bc2feae788e24e9cb431d8668 +9472068b6e331ea67e9b5fbf8057672da93c209d7ded51e2914dbb98dccd8c72b7079b51fd97a7190f8fc8712c431538 +ac47e1446cb92b0a7406f45c708567f520900dfa0070d5e91783139d1bfc946d6e242e2c7b3bf4020500b9f867139709 +896053706869fb26bb6f7933b3d9c7dd6db5c6bd1269c7a0e222b73039e2327d44bda7d7ae82bf5988808b9831d78bcd +a55e397fa7a02321a9fe686654c86083ecedb5757586d7c0250ec813ca6d37151a12061d5feca4691a0fd59d2f0fdd81 +ae23f08ac2b370d845036518f1bddb7fea8dc59371c288a6af310486effeb61963f2eef031ca90f9bdbcf0e475b67068 +b5462921597a79f66c0fec8d4c7cfd89f427692a7ce30d787e6fd6acd2377f238ec74689a0fdbe8ef3c9c9bd24b908dc +ae67e8ea7c46e29e6aae6005131c29472768326819aa294aaf5a280d877de377b44959adb1348fa3e929dcbc3ae1f2c0 +84962b4c66500a20c4424191bdfb619a46cda35bdb34c2d61edcb0b0494f7f61dd5bf8f743302842026b7b7d49edd4b5 +846f76286dc3cc59cb15e5dabb72a54a27c78190631df832d3649b2952fa0408ecde7d4dfdae7046c728efa29879fb51 +8f76c854eaee8b699547e07ad286f7dadfa6974c1328d12502bd7630ae619f6129272fdd15e2137ffef0143c42730977 +8007b163d4ea4ec6d79e7a2aa19d06f388da0b3a56f3ee121441584e22a246c0e792431655632bf6e5e02cb86914eebf +ac4d2cecc1f33e6fb73892980b61e62095ddff5fd6167f53ca93d507328b3c05440729a277dc3649302045b734398af1 +92d2a88f2e9c9875abaff0d42624ccb6d65401de7127b5d42c25e6adccd7a664504c5861618f9031ced8aeb08b779f06 +a832c1821c1b220eb003fc532af02c81196e98df058cdcc9c9748832558362915ea77526937f30a2f74f25073cb89afb +b6f947ab4cc2baec100ed8ec7739a2fd2f9504c982b39ab84a4516015ca56aea8eef5545cfc057dd44c69b42125fb718 +b24afacf2e90da067e5c050d2a63878ee17aaf8fd446536f2462da4f162de87b7544e92c410d35bf2172465940c19349 +b7a0aa92deac71eaab07be8fa43086e071e5580f5dbf9b624427bdd7764605d27303ae86e5165bed30229c0c11958c38 +b0d1d5bfa1823392c5cf6ed927c1b9e84a09a24b284c2cd8fcb5fda8e392c7c59412d8f74eb7c48c6851dff23ae66f58 +a24125ef03a92d2279fb384186ca0274373509cfec90b34a575490486098438932ee1be0334262d22d5f7d3db91efe67 +83e08e5fba9e8e11c164373794f4067b9b472d54f57f4dbe3c241cf7b5b7374102de9d458018a8c51ab3aed1dddf146f +9453101b77bb915ed40990e1e1d2c08ea8ec5deb5b571b0c50d45d1c55c2e2512ec0ceca616ff0376a65678a961d344d +92a0516e9eb6ad233d6b165a8d64a062ce189b25f95d1b3264d6b58da9c8d17da2cd1f534800c43efcf2be73556cd2ff +958d0b5d7d8faf25d2816aa6a2c5770592ad448db778dd9b374085baa66c755b129822632eaabcb65ee35f0bf4b73634 +90a749de8728b301ad2a6b044e8c5fd646ccd8d20220e125cba97667e0bb1d0a62f6e3143b28f3d93f69cdc6aa04122a +84bd34c8d8f74dec07595812058db24d62133c11afed5eb2a8320d3bfc28e442c7f0cfd51011b7b0bb3e5409cb7b6290 +aecc250b556115d97b553ad7b2153f1d69e543e087890000eaa60f4368b736921d0342ce5563124f129096f5d5e2ca9d +977f17ac82ed1fbf422f9b95feb3047a182a27b00960296d804fd74d54bb39ad2c055e665c1240d2ad2e06a3d7501b00 +af5be9846bd4879ebe0af5e7ad253a632f05aedfe306d31fe6debe701ba5aa4e33b65efc05043bc73aadb199f94baed4 +9199e12ec5f2aaaeed6db5561d2dcc1a8fe9c0854f1a069cba090d2dff5e5ba52b10c841ccbd49006a91d881f206150d +8f4a96a96ed8ceaf3beba026c89848c9ca4e6452ce23b7cf34d12f9cc532984a498e051de77745bdc17c7c44c31b7c30 +af3f2a3dbe8652c4bfca0d37fb723f0e66aab4f91b91a625114af1377ad923da8d36da83f75deb7a3219cd63135a3118 +a6d46963195df8962f7aa791d104c709c38caa438ddd192f7647a884282e81f748c94cdf0bb25d38a7b0dc1b1d7bbcf7 +86f3de4b22c42d3e4b24b16e6e8033e60120af341781ab70ae390cb7b5c5216f6e7945313c2e04261a51814a8cb5db92 +b9f86792e3922896cfd847d8ff123ff8d69ecf34968fb3de3f54532f6cd1112b5d34eeabdca46ae64ad9f6e7e5b55edc +83edfbcbc4968381d1e91ab813b3c74ab940eaf6358c226f79182f8b21148ec130685fd91b0ea65916b0a50bccf524ea +93b61daca7a8880b7926398760f50016f2558b0bab74c21181280a1baf3414fc539911bb0b79c4288d29d3c4ad0f4417 +ad541aeb83a47526d38f2e47a5ce7e23a9adabe5efeae03541026881e6d5ef07da3ac1a6ed466ca924fa8e7a91fcff88 +ac4bba31723875025640ed6426003ed8529215a44c9ffd44f37e928feef9fc4dfa889088131c9be3da87e8f3fdf55975 +88fa4d49096586bc9d29592909c38ea3def24629feacd378cc5335b70d13814d6dac415f8c699ee1bf4fe8b85eb89b38 +b67d0b76cbd0d79b71f4673b96e77b6cda516b8faa1510cfe58ff38cc19000bb5d73ff8418b3dab8c1c7960cb9c81e36 +98b4f8766810f0cfecf67bd59f8c58989eb66c07d3dfeee4f4bbce8fd1fce7cc4f69468372eaec7d690748543bd9691d +8445891af3c298b588dec443beacdf41536adb84c812c413a2b843fd398e484eb379075c64066b460839b5fe8f80177c +b603635c3ed6fdc013e2a091fc5164e09acf5f6a00347d87c6ebadb1f44e52ff1a5f0466b91f3f7ffc47d25753e44b75 +87ec2fc928174599a9dafe7538fec7dcf72e6873b17d953ed50708afff0da37653758b52b7cafa0bf50dfcf1eafbb46c +b9dbd0e704d047a457d60efe6822dc679e79846e4cbcb11fa6c02079d65673ee19bbf0d14e8b7b200b9205f4738df7c7 +9591ec7080f3f5ba11197a41f476f9ba17880f414d74f821a072ec5061eab040a2acba3d9856ff8555dfe5eaeb14ca19 +b34c9d1805b5f1ce38a42b800dec4e7f3eb8c38e7d2b0a525378e048426fed150dbfe9cc61f5db82b406d1b9ff2d10bf +a36fdc649dc08f059dfa361e3969d96b4cc4a1ebf10b0cd01a7dd708430979e8d870961fef85878f8779b8e23caafb18 +88dfc739a80c16c95d9d6f73c3357a92d82fa8c3c670c72bee0f1e4bac9ec338e1751eb786eda3e10f747dd7a686900f +84a535ad04f0961756c61c70001903a9adf13126983c11709430a18133c4b4040d17a33765b4a06968f5d536f4bfb5c5 +8c86d695052a2d2571c5ace744f2239840ef21bb88e742f050c7fa737cd925418ecef0971333eb89daa6b3ddfede268c +8e9a700157069dc91e08ddcbdde3a9ad570272ad225844238f1015004239c542fceb0acce6d116c292a55f0d55b6175e +84d659e7f94e4c1d15526f47bc5877a4ef761c2a5f76ec8b09c3a9a30992d41b0e2e38ed0c0106a6b6c86d670c4235f3 +a99253d45d7863db1d27c0ab561fb85da8c025ba578b4b165528d0f20c511a9ca9aff722f4ff7004843f618eb8fced95 +89a3cacb15b84b20e95cd6135550146bbe6c47632cc6d6e14d825a0c79b1e02b66f05d57d1260cb947dc4ae5b0283882 +8385b1555e794801226c44bd5e878cbe68aeac0a19315625a8e5ea0c3526b58cdd4f53f9a14a167a5e8a293b530d615a +b68c729e9df66c5cd22af4909fb3b0057b6a231c4a31cd6bf0fa0e53c5809419d15feb483de6e9408b052458e819b097 +924f56eda269ec7ec2fc20c5731bf7f521546ddf573ccbe145592f1c9fee5134747eb648d9335119a8066ca50a1f7e50 +b2100a26b9c3bec7ec5a53f0febbf56303f199be2f26b2d564cfee2adc65483b84192354f2865c2f4c035fa16252ae55 +8f64dbed62e638563967ec1605a83216aed17eb99aa618c0543d74771ea8f60bbb850c88608d4f8584f922e30a8a0a72 +b31b9e1ffe8d7260479c9413f8e680f3fe391ae8fcf44fcca3000d9b2473a40c1d32299f8f63865a57579a2d6c7e9f08 +a5b1d136142eb23e322c6c07cb838a3f58ab6925472352ebd0bb47041a0d8729e1074ca223922f3a7a672ced7a1e562d +8d9470a5a15d833a447b5f108333d50f30aa7659e331c3f8080b1e928a99922edc650466a2f54f3d48afdb34bff42142 +866368f5891564e5b2de37ad21ff0345c01129a14ea5667f9b64aad12d13ec034622872e414743af0bf20adb2041b497 +88ef9c2ebf25fd0c04b7cfa35fbac2e4156d2f1043fa9f98998b2aa402c8f9a4f1039e782451a46840f3e0e4b3fa47d3 +94ba04a4859273697e264a2d238dc5c9ff573ebc91e4796ea58eebe4080c1bf991255ab2ad8fb1e0301ce7b79cc6e69b +86b6bd0953309a086e526211bf1a99327269304aa74d8cdc994cee63c3a2d4b883e832b0635888dff2a13f1b02eb8df4 +843ea6ea5f2c7a1fd50be56a5765dcce3ea61c99b77c1a729ee0cd8ec706385ac7062e603479d4c8d3527f030762d049 +8d3675195a3b06f2d935d45becc59f9fa8fa440c8df80c029775e47fe9c90e20f7c8e4cc9a2542dd6bfe87536c428f0d +8978580b0c9b0aa3ab2d47e3cfd92fa891d3ddee57829ee4f9780e8e651900457d8e759d1a9b3e8f6ae366e4b57f2865 +890112ec81d0f24b0dfbb4d228e418eff02ae63dc691caf59c1d103e1d194e6e2550e1bec41c0bfdb74fed454f621d0c +97da00bd4b19d1e88caff7f95b8b9a7d29bc0afe85d0c6a163b4b9ef336f0e90e2c49ce6777024bb08df908cc04ea1ca +b458268d275a5211106ccaa8333ce796ef2939b1c4517e502b6462e1f904b41184a89c3954e7c4f933d68b87427a7bfd +aac9c043ba8ba9283e8428044e6459f982413380ee7005a996dc3cc468f6a21001ecaa3b845ce2e73644c2e721940033 +82145013c2155a1200246a1e8720adf8a1d1436b10d0854369d5b1b6208353e484dd16ce59280c6be84a223f2d45e5e2 +b301bafa041f9b203a46beab5f16160d463aa92117c77a3dc6a9261a35645991b9bafcc186c8891ca95021bd35f7f971 +a531b8d2ac3de09b92080a8d8857efa48fb6a048595279110e5104fee7db1dd7f3cfb8a9c45c0ed981cbad101082e335 +a22ac1d627d08a32a8abd41504b5222047c87d558ffae4232cefdeb6a3dc2a8671a4d8ddfba2ff9068a9a3ffb0fe99b1 +b8d9f0e383c35afb6d69be7ff04f31e25c74dd5751f0e51290c18814fbb49ee1486649e64355c80e93a3d9278bd21229 +8165babccd13033a3614c878be749dfa1087ecbeee8e95abcfffe3aa06695711122cb94477a4d55cffd2febf0c1173de +a4c1bc84ecb9d995d1d21c2804adf25621676d60334bd359dac3a2ec5dc8de567aa2831c10147034025fb3e3afb33c4b +b77307cab8e7cb21e4038493058fb6db9e2ec91dda9d7f96f25acbc90309daf7b6d8a205682143ee35d675e9800c3b08 +aaf7466083cd1f325ba860efe3faf4cebe6a5eecf52c3e8375d72043a5cfc8e6cb4b40f8e48f97266e84f0d488e8badf +9264a05a3abc2a5b4958f957f3a486a5eb3ddd10ff57aa6943c9430d0cfa01d63b72695b1ade50ac1b302d312175e702 +b3f9e4c589ad28b1eceed99dc9980fac832524cfcbe4a486dfeedb4b97c080e24bdb3967e9ca63d2240e77f9addfaefd +b2c1e253a78e7179e5d67204422e0debfa09c231970b1bfb70f31a8d77c7f5059a095ca79d2e9830f12c4a8f88881516 +81865a8a25913d1072cb5fd9505c73e0fde45e4c781ddd20fb0a7560d8b1cd5e1f63881c6efc05360e9204dfa6c3ce16 +ab71c2ea7fa7853469a2236dedb344a19a6130dc96d5fd6d87d42d3fffda172557d203b7688ce0f86acd913ce362e6cd +8aa2051bc3926c7bd63565f3782e6f77da824cb3b22bb056aa1c5bccfa274c0d9e49a91df62d0e88876e2bd7776e44b9 +b94e7074167745323d1d353efe7cfb71f40a390e0232354d5dfd041ef523ac8f118fb6dcc42bf16c796e3f61258f36f8 +8210fcf01267300cb1ccf650679cf6e1ee46df24ae4be5364c5ff715332746c113d680c9a8be3f17cacaeb3a7ba226ce +905ac223568eedc5acd8b54e892be05a21abbb4083c5dbec919129f9d9ffa2c4661d78d43bf5656d8d7aafa06f89d647 +a6e93da7e0c998e6ce2592d1aa87d12bf44e71bec12b825139d56682cdce8f0ba6dbfe9441a9989e10578479351a3d9d +acde928a5e2df0d65de595288f2b81838155d5673013100a49b0cb0eb3d633237af1378148539e33ccd1b9a897f0fec3 +a6e1a47e77f0114be6ae7acd2a51e6a9e38415cce7726373988153cdd5d4f86ef58f3309adc5681af4a159300ed4e5b5 +ad2b6a0d72f454054cb0c2ebc42cd59ff2da7990526bd4c9886003ba63b1302a8343628b8fe3295d3a15aa85150e0969 +b0bc3aea89428d7918c2ee0cc57f159fba134dad224d0e72d21a359ca75b08fbb4373542f57a6408352033e1769f72c6 +aad0497525163b572f135fad23fdd8763631f11deeaf61dea5c423f784fe1449c866040f303555920dc25e39cdb2e9b4 +8ce5d8310d2e17342bf881d517c9afc484d12e1f4b4b08ad026b023d98cba410cd9a7cc8e2c3c63456652a19278b6960 +8d9d57dbb24d68b6152337872bd5d422198da773174ade94b633f7c7f27670ff91969579583532ae7d8fe662c6d8a3b0 +855a1c2d83becb3f02a8f9a83519d1cb112102b61d4cdd396844b5206e606b3fefdbcc5aa8751da2b256d987d74d9506 +90eb7e6f938651f733cf81fcd2e7e8f611b627f8d94d4ac17ac00de6c2b841e4f80cada07f4063a13ae87b4a7736ca28 +8161459a21d55e7f5f1cecfc1595c7f468406a82080bfa46d7fb1af4b5ec0cd2064c2c851949483db2aa376e9df418e6 +8344ccd322b2072479f8db2ab3e46df89f536408cba0596f1e4ec6c1957ff0c73f3840990f9028ae0f21c1e9a729d7df +929be2190ddd54a5afe98c3b77591d1eae0ab2c9816dc6fe47508d9863d58f1ea029d503938c8d9e387c5e80047d6f1e +856e3d1f701688c650c258fecd78139ce68e19de5198cf1cd7bb11eba9d0f1c5af958884f58df10e3f9a08d8843f3406 +8490ae5221e27a45a37ca97d99a19a8867bcc026a94f08bdccfbb4b6fa09b83c96b37ec7e0fd6ee05f4ae6141b6b64a8 +b02dbd4d647a05ac248fda13708bba0d6a9cd00cae5634c1938b4c0abbb3a1e4f00f47aa416dcd00ffcdf166330bff9a +9076164bb99ca7b1a98d1e11cb2f965f5c22866658e8259445589b80e3cb3119c8710ede18f396ba902696785619079c +aacf016920936dae63778ad171386f996f65fe98e83cfcdd75e23774f189303e65cc8ad334a7a62f9230ed2c6b7f6fa4 +a8031d46c7f2474789123469ef42e81c9c35eb245d38d8f4796bba406c02b57053f5ec554d45373ab437869a0b1af3f0 +a4b76cd82dc1f305a0ee053e9a4212b67f5acc5e69962a8640d190a176b73fbc2b0644f896ff3927cd708d524668ed09 +b00b029c74e6fdf7fb94df95ef1ccad025c452c19cddb5dccfb91efdcb8a9a1c17847cfa4486eae4f510e8a6c1f0791a +9455e5235f29a73e9f1a707a97ddb104c55b9d6a92cc9952600d49f0447d38ea073ee5cf0d13f7f55f12b4a5132f4b10 +ae118847542ed1084d269e8f3b503d0b6571a2c077def116ad685dcca2fca3dcb3f86e3f244284bdcd5ae7ac968d08a5 +8dcb4965cd57e8b89cd71d6fc700d66caa805bfd29ab71357961527a7894e082d49145c2614b670dcb231ab9050d0663 +add6ed14f3183f4acc73feea19b22c9a330e431c674e5034924da31b69e8c02d79b570d12ef771a04215c4809e0f8a80 +96ae7e110412ee87d0478fdbdbaab290eb0b6edd741bb864961845e87fd44bcbe630371060b8104d8bf17c41f2e3fca0 +a20db17f384e9573ca0928af61affab6ff9dd244296b69b026d737f0c6cd28568846eca8dadf903ee0eecbb47368351d +937bfdf5feb0797863bc7c1be4dcc4f2423787952a3c77dfa3bfe7356f5dbcc4daebde976b84fc6bd97d5124fb8f85c9 +a7050cc780445c124e46bba1acc0347ddcfa09a85b35a52cc5808bf412c859c0c680c0a82218f15a6daeefe73f0d0309 +a9d9b93450e7630f1c018ea4e6a5ca4c19baa4b662eadfbe5c798fe798d8a3775ed1eb12bd96a458806b37ab82bdc10a +a52a4d5639e718380915daaefad7de60764d2d795443a3db7aeab5e16a1b8faa9441a4ccc6e809d8f78b0ac13eef3409 +8e6f72b6664a8433b032849b03af68f9376b3c16c0bc86842c43fc7bf31e40bc9fc105952d5c5780c4afa19d7b802caa +a107ae72f037000c6ee14093de8e9f2c92aa5f89a0a20007f4126419e5cb982469c32187e51a820f94805c9fccd51365 +9708218f9a984fe03abc4e699a4f3378a06530414a2e95e12ca657f031ef2e839c23fd83f96a4ba72f8203d54a1a1e82 +b9129770f4c5fcac999e98c171d67e148abd145e0bf2a36848eb18783bb98dff2c5cef8b7407f2af188de1fae9571b1c +88cc9db8ff27eb583871eeeb517db83039b85404d735517c0c850bdfa99ae1b57fd24cf661ab60b4726878c17e047f37 +a358c9aadc705a11722df49f90b17a2a6ba057b2e652246dc6131aaf23af66c1ca4ac0d5f11073a304f1a1b006bc0aa5 +ac79f25af6364a013ba9b82175ccee143309832df8f9c3f62c193660253679284624e38196733fb2af733488ab1a556e +82338e3ed162274d41a1783f44ae53329610134e6c62565353fbcc81131e88ce9f8a729d01e59e6d73695a378315111b +aa5ddcabf580fd43b6b0c3c8be45ffd26c9de8fa8d4546bb92d34f05469642b92a237d0806a1ad354f3046a4fcf14a92 +b308d2c292052a8e17862c52710140ffafa0b3dbedd6a1b6334934b059fe03e49883529d6baf8b361c6e67b3fbf70100 +96d870a15c833dddd8545b695139733d4a4c07d6206771a1524500c12607048731c49ec4ac26f5acc92dd9b974b2172c +8e99ee9ed51956d05faaf5038bffd48a2957917a76d9974a78df6c1ff3c5423c5d346778f55de07098b578ad623a390e +a19052d0b4b89b26172c292bbf6fd73e7486e7fd3a63c7a501bbd5cf7244e8e8ce3c1113624086b7cdf1a7693fdad8b5 +958957caf99dc4bb6d3c0bc4821be10e3a816bd0ba18094603b56d9d2d1383ccc3ee8bc36d2d0aea90c8a119d4457eb4 +8482589af6c3fc4aa0a07db201d8c0d750dd21ae5446ff7a2f44decf5bff50965fd6338745d179c67ea54095ecd3add4 +8a088cc12cf618761eaa93da12c9158b050c86f10cd9f865b451c69e076c7e5b5a023e2f91c2e1eed2b40746ca06a643 +85e81101590597d7671f606bd1d7d6220c80d3c62e9f20423e734482c94547714a6ac0307e86847cce91de46503c6a8a +b1bd39b481fc452d9abf0fcb73b48c501aaae1414c1c073499e079f719c4e034da1118da4ff5e0ce1c5a71d8af3f4279 +942ae5f64ac7a5353e1deb2213f68aa39daa16bff63eb5c69fc8d9260e59178c0452227b982005f720a3c858542246c8 +99fea18230e39df925f98e26ff03ab959cae7044d773de84647d105dfa75fd602b4f519c8e9d9f226ec0e0de0140e168 +97b9841af4efd2bfd56b9e7cd2275bc1b4ff5606728f1f2b6e24630dbe44bc96f4f2132f7103bca6c37057fc792aeaab +94cdad044a6ab29e646ed30022c6f9a30d259f38043afcea0feceef0edc5f45297770a30718cbfec5ae7d6137f55fe08 +a533a5efa74e67e429b736bb60f2ccab74d3919214351fe01f40a191e3ec321c61f54dd236f2d606c623ad556d9a8b63 +b7bd0bb72cd537660e081f420545f50a6751bb4dd25fde25e8218cab2885dd81ffe3b888d608a396dfcb78d75ba03f3f +b1479e7aa34594ec8a45a97611d377206597149ece991a8cef1399738e99c3fa124a40396a356ab2ea135550a9f6a89f +b75570fc94b491aef11f70ef82aeb00b351c17d216770f9f3bd87f3b5ac90893d70f319b8e0d2450dc8e21b57e26df94 +a5e3f3ab112530fe5c3b41167f7db5708e65479b765b941ce137d647adb4f03781f7821bb4de80c5dc282c6d2680a13d +b9b9c81b4cac7aca7e7c7baac2369d763dd9846c9821536d7467b1a7ec2e2a87b22637ab8bbeddb61879a64d111aa345 +b1e3ee2c4dd03a60b2991d116c372de18f18fe279f712829b61c904103a2bd66202083925bc816d07884982e52a03212 +a13f0593791dbbd360b4f34af42d5cc275816a8db4b82503fe7c2ff6acc22ae4bd9581a1c8c236f682d5c4c02cc274cc +86ba8238d3ed490abcc3f9ecc541305876315fb71bca8aaf87538012daab019992753bf1e10f8670e33bff0d36db0bf0 +b65fbb89fafb0e2a66fe547a60246d00b98fe2cb65db4922d9cef6668de7b2f4bb6c25970f1e112df06b4d1d953d3f34 +abb2d413e6f9e3c5f582e6020f879104473a829380b96a28123eb2bdd41a7a195f769b6ac70b35ba52a9fee9d6a289c3 +88ec764573e501c9d69098a11ea1ad20cdc171362f76eb215129cfcca43460140741ea06cee65a1f21b708afb6f9d5b0 +a7aaec27246a3337911b0201f4c5b746e45780598004dac15d9d15e5682b4c688158adffdef7179abb654f686e4c6adc +a1128589258f1fbfa33341604c3cb07f2a30c651086f90dce63ae48b4f01782e27c3829de5102f847cde140374567c58 +aaf2b149c1ca9352c94cc201125452b1ed7ca7c361ed022d626899426cb2d4cc915d76c58fa58b3ad4a6284a9ae1bc45 +aaf5c71b18b27cd8fe1a9028027f2293f0753d400481655c0d88b081f150d0292fb9bd3e6acabb343a6afb4afdb103b5 +947c0257d1fb29ecc26c4dc5eab977ebb47d698b48f9357ce8ff2d2ed461c5725228cc354a285d2331a60d20de09ff67 +b73e996fa30f581699052ed06054c474ebdf3ae662c4dc6f889e827b8b6263df67aeff7f2c7f2919df319a99bdfdceb1 +b696355d3f742dd1bf5f6fbb8eee234e74653131278861bf5a76db85768f0988a73084e1ae03c2100644a1fa86a49688 +b0abca296a8898ac5897f61c50402bd96b59a7932de61b6e3c073d880d39fc8e109998c9dba666b774415edddcff1997 +b7abe07643a82a7cb409ee4177616e4f91ec1cf733699bf24dec90da0617fe3b52622edec6e12f54897c4b288278e4f3 +8a3fae76993edbc81d7b47f049279f4dd5c408133436605d934dee0eadde187d03e6483409713db122a2a412cd631647 +82eb8e48becfdf06b2d1b93bf072c35df210cf64ed6086267033ad219bf130c55ee60718f28a0e1cad7bc0a39d940260 +a88f783e32944a82ea1ea4206e52c4bcf9962b4232e3c3b45bd72932ee1082527bf80864ce82497e5a8e40f2a60962d0 +830cf6b1e99430ae93a3f26fbfb92c741c895b017924dcd9e418c3dc4a5b21105850a8dd2536fa052667e508b90738f2 +990dce4c2c6f44bb6870328fba6aa2a26b0b8b2d57bfb24acf398b1edc0f3790665275f650884bd438d5403973469fa2 +a2e5b6232d81c94bcb7fed782e2d00ff70fc86a3abddbe4332cb0544b4e109ae9639a180ae4c1f416752ed668d918420 +b4cdf7c2b3753c8d96d92eb3d5fa984fef5d346a76dc5016552069e3f110356b82e9585b9c2f5313c76ffaecef3d6fd8 +83b23b87f91d8d602bff3a4aa1ead39fcc04b26cf113a9da6d2bd08ba7ea827f10b69a699c16911605b0126a9132140f +8aae7a2d9daa8a2b14f9168fe82933b35587a3e9ebf0f9c37bf1f8aa015f18fb116b7fba85a25c0b5e9f4b91ba1d350b +80d1163675145cc1fab9203d5581e4cd2bed26ad49f077a7927dec88814e0bed7912e6bbe6507613b8e393d5ee3be9be +93ddeb77b6a4c62f69b11cf36646ed089dcaa491590450456a525faf5659d810323b3effa0b908000887c20ac6b12c80 +9406360a2b105c44c45ba440055e40da5c41f64057e6b35a3786526869b853472e615e6beb957b62698a2e8a93608e13 +93bfc435ab9183d11e9ad17dac977a5b7e518db720e79a99072ce7e1b8fcb13a738806f414df5a3caa3e0b8a6ce38625 +8a12402c2509053500e8456d8b77470f1bbb9785dd7995ebbbe32fd7171406c7ce7bd89a96d0f41dbc6194e8f7442f42 +aab901e35bf17e6422722c52a9da8b7062d065169bf446ef0cbf8d68167a8b92dab57320c1470fee1f4fc6100269c6e2 +8cad277d9e2ba086378190d33f1116ba40071d2cb78d41012ec605c23f13009e187d094d785012b9c55038ec96324001 +85511c72e2894e75075436a163418279f660c417e1d7792edce5f95f2a52024d1b5677e2e150bf4339ad064f70420c60 +85549ca8dcbe49d16d4b3e2b8a30495f16c0de35711978ada1e2d88ad28e80872fca3fb02deb951b8bcb01b6555492e4 +8d379ab35194fe5edf98045a088db240a643509ddc2794c9900aa6b50535476daa92fd2b0a3d3d638c2069e535cd783b +b45cfebe529556b110392cb64059f4eb4d88aaf10f1000fdd986f7f140fdd878ce529c3c69dfd2c9d06f7b1e426e38f3 +ac009efd11f0c4cdd07dd4283a8181420a2ba6a4155b32c2fed6b9f913d98e057d0f5f85e6af82efc19eb4e2a97a82df +b2c2cdffa82f614e9cb5769b7c33c7d555e264e604e9b6138e19bcfc49284721180b0781ecbf321d7e60259174da9c3c +95789960f848797abbe1c66ef05d01d920228ca1f698130c7b1e6ca73bfda82cee672d30a9787688620554e8886554ee +98444018fa01b7273d3370eeb01adc8db902d5a69b9afc0aa9eadfeb43c4356863f19078d3c0d74e80f06ecf5a5223f4 +87d20b058050542f497c6645de59b8310f6eeec53acbc084e38b85414c3ea3016da3da690853498bde1c14de1db6f391 +a5c12b3a40e54bee82a315c503c1ce431309a862458030dde02376745ec1d6b9c1dbeea481ae6883425e9dae608e444e +b9daa3bf33f0a2979785067dcece83250e7bf6deb75bb1dbbab4af9e95ddfb3d38c288cbef3f80519a8916a77a43b56c +b682ec3118f71bde6c08f06ea53378ea404f8a1c4c273dd08989f2df39d6634f6463be1d172ac0e06f0fa19ac4a62366 +a4f94fd51ecf9d2065177593970854d3dce745eebb2a6d49c573cbf64a586ae949ddfa60466aaef0c0afb22bd92e0b57 +86cd5609efd570c51adbc606c1c63759c5f4f025fcbefab6bc3045b6ad2423628c68f5931ff56fdda985168ce993cc24 +981192e31e62e45572f933e86cdd5b1d28b1790b255c491c79bd9bb4964359b0e5f94f2ae0e00ef7fe7891b5c3904932 +9898f52b57472ebc7053f7bf7ab6695ce8df6213fc7f2d6f6ea68b5baad86ec1371a29304cae1baadf15083296958d27 +b676c4a8a791ae00a2405a0c88b9544878749a7235d3a5a9f53a3f822e0c5c1b147a7f3f0fc228049dc46e87aa6b6368 +9976e10beff544e5c1645c81a807739eff90449df58ffdd8d1aa45dd50b4c62f9370538b9855a00dd596480f38ebe7a5 +a0e91404894187ec23c16d39d647ada912a2c4febfd050a1ea433c4bfdc1568b4e97a78a89ba643aca3e2782033c3c58 +91a6ea9a80476ed137eb81558ff1d55b8581663cccd41db4fc286876226b6515fd38661557419e1e46b6a3bc9cda3741 +b9e8a1e23c60335a37a16f8085f80178a17d5e055d87ffe8cf63c532af923e5a5a2d76cf078164fb577996683796caa6 +ad8e151d87a37e8df438d0a6a7c02c3f511143efb93fde8aef334d218cb25932baf9e97c2f36c633620a024a5626af3d +978f942f210e8a482015e6fdc35a4c967c67b66e6e2a17a05cc7a0f2163aed227b775d4352b0c3cca6cbf4bd5bafaf75 +b5e2e3d8b2e871c07f5899e108e133f87479959b80cb8a103fbecde00ccdbfbd997540eef33079c5cc14b1c00c009fd1 +88a164b3fefd36857f429ab10002243b053f5d386466dbb9e5135ed3c72dd369a5a25e5e2aaa11f25488535e044e2f12 +a66091c0db4e7cf05a089ec2b9ff74744354d0196968201f5e201699144b52bb13b4e68e12502727163e6db96e3565f2 +8e65aff8e37240461b7374c20bfd1d58b73a525c28994a98f723daed9486130b3189f8efe5c5efcd7f5390cc366038da +8b37c21dd7304c3aa366959ba8c77ea8b22164a67e136808b6f8e48604297f7429a6c6ecf67b1d09b8b7ec083eacd7e0 +b689b1277ad050f53da91a702516a06d7406ff33a4714ea859b3b2b69f8d0aa8f983c7e039b19c0759a3815d841fa409 +b17f7a0a182ed4937f88489e4c4e6163dcf49fd2ea4d9efbba8126c743bea951cd769752acd02e921774dc8ebcfae33b +8b7fab4f90be825ac5d782a438e55c0a86be1c314a5dbc3cc6ed60760a8a94ef296391f1f6363652200cce4c188dae67 +ab8410c4eaa2bb43b0dd271aa2836061bc95cb600b0be331dada76ddb46711ff7a4ad8c466cc1078b9f9131f0dc9d879 +9194bd7b3cc218624459d51c4d6dbc13da5d3de313448f8175650fa4cfab7cc4afcda5427b6676c3c13897dc638b401e +980f61a0f01349acd8fc9fdc88fc2c5813610c07eecb6ab14af0845a980792a60dadf13bb4437b0169ae3eff8f5984ce +b783bee24acea9c99d16434195c6940cf01fc2db135e21f16acae45a509eca3af6b9232a8aa3a86f9715c5f6a85cb1c3 +a3079931c4b90966d1faa948db847741878b5828bc60325f5ebe554dcab4adcc19ee8bce645e48a8f4a9413bb3c6a093 +801f61ac9318f6e033a99071a46ae06ed249394638c19720831fff850226363a4ae8486dd00967746298ee9f1d65462f +b34dbbed4f3bb91f28285c40f64ce60c691737cc2b2d2be5c7d0210611cd58341bb5bda51bb642d3ee2d80882e642a13 +8750af19abfb915e63c81542b13d84526a0c809179bbcc1cd8a52b29f3aba3ae0f7cf6f4f01790bf64ef7db01d8ee887 +a6ea10000eb2dd4efc242ac95bc3b3873cdd882fbeb7c9538c87e3143a263ca3a2e192b2159316a625cfb5fb0b6cdcb3 +aa40ca54bc758a6c64cb932924917581062e088b3ad43976b28f2e11d8a7dea73f1fb50aeaa0e70182bb2dc07d805bb9 +a4779dfd25b5ec9d75dfb54a4bb030364899a5e75c1492403acb19f2adc782c7ac4daeb66d2f5aeb74135afe9f318e3f +b4551e2805d63ca453f4f38b1921ac87ff687e1d70575ad38f3469d6f0608ef76b7b1b98ae1e6b1e7d928773aaab6e3b +99490ee722f96aad2743b08dd37bfeb75a8c59efaee4c9b694eaa05eb8a6bb23861a4480544c7617d04d23fd5e2543b4 +8a7050d964d295fff98ae30d77ce730a055719313457e773fcce94c4d71a9b7cf63db67e54a8aab20fb1335b0130b5d5 +903144e6bbee0a4fec17ff80fef0d2103981140c3d41776cfb184ced17f480a687dd093f6b538584327e6142812e3cd5 +a5b30f7c6939bdc24a84ae784add927fec798b5a5ee3dd156c652df020728dd6d43898be364cf5ee181725fbcffc0964 +b43d97ec2bc66af92d921a5c5c20a03ef2be2bc2c9b345f46d8287409fcbfd88ebc49d4509d64468222cd1d2021bf236 +82dc23c7f5086c9ac6b4566359bfb830d203544b0d8332a210775670f899cd9ff48b94bfeba40040c25664ebdd5cfad8 +9294cd017fea581dabb73dcc8c619904d7e022b664b0a8502c9d30f3807668af279948e7e41030ae296d492225297e95 +8d6c9dc636c8e884f9a4299e5cff06d044ebc94ad783a4b71788347ea4a336d4d048b8a9ecabae789e8fcdc459723dfb +801a80bc49e882ec81b04e37407713f033f7bdac79252dfa3dc8c5bd0229fcbd4019890e402cf843b9378df08f72ab84 +b4313ca32569d973900f6196363c0b280ddfa1b47c88d019e5f399b805b444a777950fc21ae198fc23ece52674b94abf +96f06056fd255fdabf78986e315e7c4fdf5495cf850536b7976baa97a994cc6a99c34609c33a0f2facba5e6f1026dce6 +983ed80220a5545ffd70ef5e6ac10217d82ec9cd8f9a27ee77a5ff4074092308c0e6396fc4e9932a77ddd474e61f8b55 +872a059aa630af73c4abbd076e8b333a973ffc5bdecf5dcc0600b00162184213cb19d4f601795030033beb808d5810ce +b040f318d9d3b8833da854014a44296dbd6762dd17cab13f91987256c54353b7f0800547cb645a7cc231997454209fdd +a8c4731a555308e8ce0b8325eb7a4cbf6113d07e9f41932df04480b72628d313b941c7055f1cc2ac45c7353b56e96ca9 +8c24031440b77637e045a52e5ea3f488926ab0b426148975edf066c40a4581beecc1bfb18fc4cf5f9f96dc6681b4bd28 +b39254b475abf342f301298feaa17a4b3051f30ea23a18acf59e003e2704ac96fe40691f1da387913bdf7aee6389f9a8 +a1dbf938b604ccc6d60881cc71f38df568aa02752aa44d123514154017503f6c1c335ae43e359f1487bc8934073cd9c1 +8d52aa1be9f429ece0580498d8fe9fef46d4a11f49436a82b8927f9503dacc41245907f126594c1cd30701286f8c092c +b826f396486942c0326d16f30a01b00a682c30a75553dc6ac34fd5b3e96b13c33b94738f522eebaffb59ff8c571c76e9 +aa89f51cbf6e6c3e2aa2806187b69ab3361c84e89f393f3ed284fe84db46fc3944aa44f8928e3964f9c1a1ec27048f68 +a254df0efa4203fb92b42a1cd81ca955922e14bf408262c8f7cb7dc703da0ca2c71556bd2d05b22ce9a90ad77309833d +93263c507e4d5f4e5df88e85b3d85c46ea729fb542a718b196333e2d9fb8a2e62dc1347cf146466a54ba12d200ef09d9 +922e3c4a84246d89a07aa3e90f02e04b2cea9bebc0e68b742156f702aed31b28c6dfa7ac936ea2fc2e029adf68361f98 +9a00628eeeda4ccbed3ef7834149aec4c77aac1a14bc2491ba5d1a4a2c5d29afb82ceaa5aac1c5ce1e42cdcaf53e30ba +ab3a88df36d703920f6648a295a70ffa5316c96044f39ff132937bfda768937cb6a479e9ba4a4e66b377f3a9996a88c4 +966b11526ab099d550ab33c6a9667e5cfdedf255da17a80a519d09acd78d2ea24ec18bd1ea7d8d63cf0a408f1c1fe0b3 +b5c21b9817dc32f3df9d9988aa3560e1e840d586d01cd596bc0f850ab416b6013cbf7dbfd05ac981f26014c74bd2d2b2 +9040abef5e2523e7f139c9f744a64b98fea3a57952059ffe4d5ed77fa87068203c090ef4e7f52c88fb82ea8a6fdca33e +a0dcdaeb7d3f5d30d49c004c5f478818c470187f4b0b4856812dcd1b3a86de58a99acb8ceb44c6b80c3060cf967c43a4 +b5f4be9a69e4a6719ea91104820df8623b6d1073e8ee4168de10a7e49c8babea772bcbc6b0908185e98d607e49cd3609 +8634020a5a78650015763c06121c606d2dd7b324aa17387910513dd6480fb797df541fc15b70d269b2794ad190595084 +9504d1d0fb31ff1926c89040c04d51fd1f5cddf9d7ca3d036e7fd17e7a0f767ef33cee1d8bf7e17e2bc40949e7630417 +812c72846ef6d692cf11d8f8c3de8fa78cc287303315114492667b19c702cd24d462020f1276895df26e937c38f361f8 +8c97aa5e9ef2aa9a1435ef9ddfe62e850f0360864ed5fb82bf9fef4ef04d8fb4f827dc078bc911ee275e4501edd6617c +ac5f7af5e23c8e429aaa6b6825129922b59d25b4608f07b65f21388a9ac3aa89096712f320afe6d56e44e1f0d51a4eb9 +a8c84d9a8593a0cb5be1e450960f59878a4e6b70da54a7613dfc25911b7cc9e6d789d39401b0a0d6471ab9dcdc707976 +8c9d5fd89611392c0f085ffa4fa642a181f0b9b23593deb5e10fdd1642722ca75ef34a037e88a8d03f2888fe7461f27c +8c74b05f91fb95c85e7bd41f6d9a1e41e667e68f3d19b325c1f25df1767019919edab89b92af237896cbc4e6d6dc1854 +a3caecb91640821f0b2c4981b23f2069df8d2b98ce026c1538bc096b292f5f956a5d52c1c8d6a8165a1608083ba6494b +8ae8e0c36f8b79a69176ff29855df45d0fcd9e4d1dbaed8899f8fcdece676e418ec034a6c161e2a894f0c834aaecbfd1 +b88d18c67dc3b1b6ed60ee437c441c1ed14ecddebccf43683605716f30058b1aa4ba05ff10cd8171ee97d8f58d70c094 +94f43d84dcdfd9cd19115c7d8e9c1e856828eafbfdec93b876cf0007e317e30b2ad951dbabc186aa6ef90fdee4d91990 +b44e4723f41fc1d5b0057f371e3381ae02566590b3f964b6eb07b2104f66ff78410c407235fa98d04f635694f3baca09 +addd8390173d29ca0811534d389253831fed75fed135398617836b6e70767269eacb1560b39a58f02042ca3b97fe59c4 +80bdbdacc0c358c7ea52aeacdc5f9ceb6928bcf6e7dee7c17d8ae3bf7c2372aa7a0372363888968fc0921aaf4776d5d0 +a486e2b6f04f403f9e609d69dfb3cfb992af56ecad1683271df3e3faa3b86638b81e73b39978fb829ee7133d72901f2d +a19472da57457e10c6a6307895393ddaec8f523760d66937fe26a025817319e234eaf69756ffdf1b84c81733424a96d7 +ad6a195397cbc2d75171f5e82090441eed60bd1ba42c39ef565b8b5a8281b04400678625b1dc46d617f694a7652a8e5d +8f98e721c06cec432e2221f2e1b06bb1469d916a8d88d6973acf68d1e003441d00390dafcead8ecdbf9eae4509baf5aa +91d62a0f9d13c59adfe1376ed6d057eae244d13c6b3d99be49a49e0075cf20f4085cf127774644ac93615be9ac9e5db6 +af45dec199245e2b326a0d79c4899ed44b1c0219db42602a4a6184ace0ff831a3276297af28f92e8b008ba412318e33e +8754bde54e8d2d169e6a7d6f0eae6097bc0461c395192bd00dd6f105677ea56ab384c02553ea5eeac0a65adcb0df77ee +b676afd2f5afc37a314c943d496e31b4885efcbcc2061036e370a74cfde5642bb035622d78d693bfc3136fc036c7edb4 +aab6ffe6cc234397cf1822e02912bc282dfb314e92fb5a9e10d0c34ee9b5856d4b76e166bc2bb6fcdd66aabea35ec4ef +ada6e62f90ee6b852ec4b72b22367acac2896f0df2c105beda27096583ddbedddc710d171330569f111c6e44a5b57ae7 +802139dd15241a6de663d9b810121bdd9cf11f7f8c8ca6de63f4f8e731409e40d1fd3558b4f619ed42ee54929dff1c7e +ad8e70531cec21b4e6f55be1751c2d025bd2d7d8158269b054cfe57fa29252d052ce4478ec7db6ec705789e2118d63b3 +a8e4a4271769480e1b33a28c87a150ecc0b48bfe8a15ae04152197881de4ce4b03453aefe574842424edbbe4173e1a3a +b98c65726296610cef16c5b58da5491acd33bd5c5c5af4d934a9840649ef85730fbce8018dee09ded14e278009ed094a +8e213a7861223287b860f040e5caaa563daa0b681e4e09ec79ad00cc459238e70bbeaf7486bbe182fc12650700034ec5 +a2879f9e1a556cf89b9b5b3bd8646a8cce6b60bcbc8095df44637f66a2da5858eee2dc9091475a8f64bb5aff849389cd +8a17cdb4077b9b0bcf28b93294ac5ae4c8bba8839fce0f1012b53187ac008f9858b02925fbfc421f1123afcdbd8b7753 +86fd9c11528aa43946e4415ff64a3ca6409ee6f807368c68997b18605da65e415ccd85ad913820d450cb386593de666d +8ed55923b963c3d85a91aca11c40ff9c6c7f1e2b9bc199d1a270e5fb16aa62dec0136e97866145ae9d58a493e8b1cbbb +ae32af5b5d418668ae123c639b149e5eed602404e8516da4a61db944b537a3620545e8e3d38cf10cdaea980ab2f80973 +95cb8d9e9d6762d78dde0ad73869ffaca904a7d763a378b8cc11a7933d3e7d1c8aec4271a079b1b00f8887ee5b1ea21f +b5ea20b42a3ca247f00ab5328c05f0cf194973d5f7271c66c41c5055b1ffdca136be179709e0c1de209fbe07b9820bf3 +98682f7cce471c92a8d6d15fee4ddf4d43dd97c3e3811d2913618ecacc6440b737717c07736ae4558c910e11ee98104e +a67da2c7cbba48e929ca4e4b9a6299fe01ef79eff8cc5cd3fdbdc0721a68130e4079f30ae151a573a7dcca8ecf2e684e +a9981c9f9dcbb3b0f6996f664fb2acd7573189f203be37b2b714662aa273551396abfb1f612ccde4e4c8127a050dbe4b +92d55eff8da600f886da9bf68e8eecf482faa4b268f3f286b3b3e5cc91b19604081498d4905b201bb4ec68e32b5591d9 +963e3f1728de9d719c86d390f3eb9c3f99d1928347fab0abf10dbb37d76b59ddb64d4734c977863a6cd03ffece5ca895 +93480e2de83c921056b6d8628ac37cd5ef7555ba43b0308fc13386cb0515d42c12ecd06057137aa71a7931beaf90b9ce +8feae57ff0e6a162cc81c99f45c6187d268fc0bee8c2bffc92142ef76c253d201f0e932943cf2fa312982b281ce1066b +8f8f4bd4200fb87afcd743274480220d77571928000d4197410dbb75439d368df6a06d941a6152206371d2ca9cac99e4 +8ee7f11e79af4478e0a70eb424fe8078237ad99ba6d7e6bf1a8d5e44e40abd22d404bd39b718ad6fdf4c6601f2a47665 +a98acfcec612b574943195b9ba95bebcc9c0b945c9f6b3e8760b2a4635909246a9d73b0b095c27b4ecb3339704e389b7 +b520efd19f65e81dc285031ea3593f8c5dad793e4426beb9196ab46e45346f265fd71e50adb0da657977c60ed5724128 +a3d9d0b7415280ce4dfa2429d47b2b8e37604a5157280a72cc81d541ffe44612dbb3ef7d03693fc42a569169d5842dc3 +8c29e2d0b33801f6d9a9c065a76c5cad1fb0a001506b970307e21765ee97c732a4cbf1d7c1b72d95e0ad340b3b075224 +839e21f292892a6eb596b9b1e9c4bd7c22a6fe71d3d04487c77840028d48392c5cbe73140a4e742338e0c8475cd0c1ad +8bea5c68e7743998619185bb662e958f1b4d3ca81019d84ac43c88911aab3abe4ee9bcc73cb95aa3ae87c0138801bde3 +b8f262d21a94604049e008ce03dc857848168e1efca4522acb0ccc827ffb37f545e1947843a356563a76bc6489605b66 +a7bd0842b0bb38d9943b82aa883f36f4eb8a6e8a7790d4f87faf306608f51d250a19b73984f1156cef5dd2581664614b +a993e649bd953627a88a2539dac3a12ec7f37a4c65b01425d9d34edf7ee10a71aa98f65c9e013107f824faf8aee041a9 +8e07eced75c67cb4d2ec01857f6ac1408482e6b31cb2faa249e8cf99f180575587df530c7782a7539b5221121ef48aa0 +b2f4578f26c05ecb9e2669ca744eb19d4f737321ac7d04fafd18beb7866e0fec9dd063953ae1f077b44b9c6f54db1279 +b6b3788a6c7bcaf467d19daf6ab884d549aa866970c05a9181f544ff190d043192c84fe437a75a30b78b425461cca062 +a270684903c61544b85a7041e81f65e787e1c1e23e57538fa8a69836bed0ca1673861dd29f743a1280f2f38eddd3aa83 +a9c2397c4773dcad2821266dadfd2401d013d9f35de6744f2ec201f3507700adb1e6ec4f5a453be4764da8bf68543f26 +83a3025ed6fd5df9d98be32a74e10a0d9728b560942d33ba028536fb148fc34ae87e92be2df3e420a8dfec08da495982 +90dc70c183a90bab988b4a85b7b921c8070af0e5f220364fe11afa0722990b2c971e1e98eef62d3287fedfd9411f1df7 +82d940937a6c636224d04f8e2536f93dcf20dc97a5f188875ad76c21b804aef9af10839419b61143c1f88a695959a6b4 +8017f9473ce49d498d6f168137e77e62fe553e5a51e75b519cf2cbd1ab9afdafad80fd5e6fd0860e640b0d78ca8ed947 +80573a0ec049fe1f7b3013b2839e145cd87e07c0e43826a29ef8c92516f9a30896c2ffcf3ed77ed22a6cf3101b1789d5 +953349abd2559f9824db07cec857ad54f1a05018f3076425f8dbae37f8d92a46af2c04ab7c8ec0250449541187696e98 +ab7bd2c4f05ee9a9f252c4e16a20993a12c535c3809d124bae24642616521a9768d3f19eceaf8524583f47ae1f527684 +9883b77ee834ee0112ca2f366d2a6fc213e0cf454e061438c2901a5ba35b7378f64da8adf6a476eb1562991ef5b4a5bc +89291811db308637356dbf7ed22cf07bfce33eb977734ee346e8c15a231b35d8b4443574f3fa97a40867b3e23b0bbfa4 +93d753849d7d9588d39e38217500b123a6b628a873876612d9f98b5d611f52c89c573432d2176752b5d1cc2d94899b8b +a45add3c4844db3b7a237295fc85fddc788ac1ec395a0524d2fc90a539571a247146aea4aa10eec30a95e9617c85b98d +90f94578842db7a4de672da1e483858ece5e466c73c12f725a0fc71f42ff880c9447a33fa9096839bee817536f2591e2 +b2c1b6fb031bb30460f157356562b44b4de096a0a112eab4fb3cc500aad38bc770da1fc2e73caf687a0da5e8537049c0 +afb15e15fd930929c0e3c66482068a5afe0c7b7f82e216a76c5eb1113625bfa0b045a52259d472284cfbaf4796c71456 +ad222a9a3d907713418c151b8793d5e37634354322068f8206b9d0da1a3f53b0004193713d23ec35990639a1b6c2e075 +b44a128dce97e8c4b178cdbca0a5c1b3f6e164490fac0fd68dbfe0aafa89920bb4ea420a8527e06c80dd19c2f135e3ef +8596e993ef18b8d94e9c42a90cb7060affc586b8e9b526820d25124285de5590134e2e86592e9dc4dd45ccf5d578fa60 +b71bb0ad138141ed506b2253e84110d2db97cc2d24a3fd0d096b0022d9f38f87aa74e2f505074632d64e90bcc491aa30 +84841eafd357309de47b92ca5ec163dec094a2e5271bc65898c31932e0160bee165e4decb23af339cfe09c83e1cc5441 +8a2915ee39a6fd4a240b98533d7690ef1773ce578ed1fb05ed414ebe36f7ef289fa46f41768df57190438c356331e329 +90bb337165386f1990cbd8ed2e8321ef21bc18125b015b4da0c37e5fcc446b26005379ee4fad8ce9348ceb4ab49e82e2 +b707b50ea2ab05c6d183671587f25fe29eef23fe569d731459a1ac111a0b83a2cd65b88242876b34aeead3b05a15d745 +ae1f159f79b7996315c4f9acce7e21a6ed59d4ef76331196fc86911fda3035edd5c11d568b105175a36c948d0263b382 +922bc525bace05e5dff6b5cabde5469ddd2c1c601f7131abc04ecefdd35095e6ac015b1aec3c3b25c5dee8d139baf60d +a7b060405b2740f82db64683187b1bb89e5f40c8438663c7cbc8ef2513929fe5f92625667a7f2f599a72a96b1fc8f08a +b9dfe94a08651db5efefbb813269bce80d814e3089b80c0654491e438d820bf521f8a4a4477909344ba88f7683eebb43 +841817a9729465743576950b6e8eea32ebf39cca99ace86c4792f9f35926e2d6830c52854a3b2eaeb61694e6845008bd +934128034bde8fc7b93b952aa56e0ed28b36cfa04cfa1f0d5b38266dd40beedff5e0bab86e4717b0fb56c56be2eae26b +aee9d64caf28596308782cd8f3cf819506daf3378f86157ff775e618596411adf94efd0e9542787ca942066f02cbd332 +85871184db314411a49575fee088c52ed5dba4e916ee001ec24d90898a0154d9790a06aa8a707ca7a8b986c0293b8d89 +8d3d87edcc0187a099c97b581a598d357a41ac152303bb27c849eb78e72e15cb97cf9a0468fc36f245c3e152c76bb7dd +900475d165dec18b99eb7b5f9e9ad1d2d4f632e55fdcc4c5ecd7775fed462990e6aaafe9c669f40508f9b15f00bda31f +a25b5954edd57e7811a0d18532043d975c7b44b80f65cd630935d7b16ada05f30fe2b7be7ae8a2f54c25957faf3f1950 +a089019afa3a7a15f7e7874e73b6773c0a824e6d3379b4c928e173321fb165ad979a6be004d394c28d19d410b2655d3e +b28f46797dee0c538bd3de815df641a0ef718ad3e52b2764aec380d6905b38b50ad6f60d0f68e096ca39960ba7734355 +b0ac155d3d05851b04104e6b459f1a68e9e155437c92421a7c0e4dd511ef89cf71dfa3cc920769492ee283a65ebf029e +813c69a810745580d43d5b5480f0ba81000fbef0071e6b655c7346bef5ed774e9214a7816d40eb1774a5bd033767a046 +b176345ca75c64f10ec33daa0dcf1f282b66a862fcd3d8d66c913f9a02db4c9d283dadc02eff13aaab94bc932a42234e +92560f67e5b995db4a489bb86ee78b4aee0800143b3535ad557a53e9e08716bd0202d9f5714722c2a5e8310046e3f5b3 +8adb427bad9cc15fc6c457a96a6750dda8c46d859c5f69bf0e7ab8fc0964430b33967fd47cf0675b6ba1757f91255e6e +b120f723b80389a025b2daa891b140b3d7b8d520ae2a6a313f6e3d365a217af73292dcb249dca1f414ec05e865e3cdc7 +a61a5d261a8dfe5996c42ea0a5ae703a2adcfda80e86837074d868eee16f87d38da19596c48b55dbd7a7cbec1a9b4996 +99dc921eacc6bb867c5825ad4c83bc4af9dd78a18b3d0e1a60ad493e3805b8fb9b7922b577da1adb3d805edfc128d51d +85455fa165a07282aaab4a5bfb88027f47b9532e4af8195c048515f88b0db7e80f42e7a385fd4944faaa7f2a6544ad17 +96dff2d1c8a879d443fe576d46bcceaf5f4551d2e8aad9c1a30883637c91090de99ad5eec228eb5febf93911502d3cbb +a87eb7f439377fb26c6bfe779701f4aea78dd7980b452a386afec62905e75217a1996c5234853432a62ef8bab21c31c3 +b598278293823e9ccb638232a799211173b906444376337fdf044d0227d28fcc4c5867e6ecb3200e59ca0b139e71cac9 +aa6fe147edc95027654d68140f428ec53cede3552c5f49c09d18bc6f6ae8c739a63042eb7291d14d717a4e1f0778abcb +ae8ee18913d328b2fba71efe65526d3ee9c81beda53cf776baec4019ea30212010758cbb5dc85ed6620ce04b189f01f2 +ae9fb686777e88dffdd42805fe4114aa0da1b350d92a27ff3f8a817fb25af1fcfc9a06155affe0273bf13caad16a5351 +95d372ba3a2ee38371538f34aae91b4844488e273f70c02f1992370f89fc2343eff95692d52ce9f21206abbee4959958 +b15260376f0a34ca2827ff53acd7eaaef94c9acc2f244b36500423069cb1cdaa57ac8dd74adb5b53d0fd4265fcbb28ea +b0ffce6a8059537ef6affdbbc300547ef86e00109289239b0c6930456c562b4ed97f2e523963af17736dd71b46c44ac7 +b5499a1277d34f9892f7579731ff53f423f2ffffa9ea43a6e929df8c525e301396249a2324818a6a03daa0e71fcd47b3 +98dbfb8e97a377a25605a7665d4d53e66146204d8953afda661ae506858c5cd77ff7f21f5f10232e06dbc37378638948 +84177e27e6da0e900c51f17077f5991e0e61bff00ca62c1623e627c5aea1b743f86eef6d55b13219a1947515150bade6 +b50407bb5c61b057ab8935df94fd43ca04870015705b4f30ceac85c1035db0eb8293babc3d40e513b6fb6792ecbc27a9 +988699a16917514e37f41ab5c24f4835ed8a2ca85d99972646fcc47c7e2a83c2816011144a8968a119657c4cda78d517 +920c43fdcb738239ad542cb6504ab34498bce892311c781971d7db4dec70e288676de4d8697024b108cfa8757fa74035 +aaa106329aac882e8d46b523f126a86d3cee2d888035ce65c0be4eaae3e92fd862f6ac2da458a835539cccafaba9e626 +96e4c1562d14b7556f3d3e8a1b34ea4addc5a8170e1df541dc344728bcb74cd1630eb7ba4c70e9c68fd23c5c5d5a729b +a616ac5016d4e68e03074273cd3df9693ee0ce3458e8758b117a5c1bc6306dd2c7fad96b1bb37219c57ac62c78ad7a3e +8db7d9b20abfb1445babd484ae9e38ff9153ac8492230d7591e14e3fca7388a5ca6ef7d92ed445c8943cf5263e4a6ad7 +88464134221aa7134878eb10928f31c8bd752ab68c27c9061c1de3f145c85731a4b76acdc7e939b399b6e497f9e6c136 +a5f7c794f70b7c191c835dded21d442b6514bab5e4d19b56f630b6a2f1a84a1d69102d7a0dcca256aab5882d3f30f3ca +b96b6f98b6817b5fa6b1b1044e2411bdf08bf3ffaa9f38915d59e1d2b9bed8b3d645eee322ee611102ce308be19dbc15 +92c26ade2e57257f498ac4ff0672d60b7ea26dad3eb39ed9a265162ccd205c36b882dba3689758c675f29e20836b62d9 +8379a0299e75774930577071d258e89e471951642b98e5e664c148af584d80df4caa4bd370174dae258848c306f44be5 +a0e53beda02bd82bf3d24bd1b65b656238128e734b6c7a65e3e45d3658d934f909c86ca4c3f2d19e0ac3c7aae58b342e +8ca5ceaeaf139188afd48f9bf034d8baf77bbf9669791c7e56ebf783394d7fcdf2a25fa4bdfcddfde649aa0dc67ccccd +a8060e6448844e9db4e9fb4da1c04bcf88fda4542def5d223f62c161490cf1408a85b7c484341929c0f9ce2a1d63e84b +af6e1a5ecf50b754bb9eb2723096c9e9a8e82c29e9dcaa8856ab70074430534c5395534e1c0ed9ce98f4b84d4082fa67 +81c8dbbef98f1b561e531683d5ae0f9b27b7f45dc6b2f6d61119ca0d559bf4ceb676d320afc5aba1811eeef7547a59d8 +85b46cd64d605c7090a2faf1a2aadf22403b3692b3de1d83e38b2de0108d90ac56be35b0dca92c7a41c4b179a3567268 +8dd3cc3062ddbe17fd962c2452c2968c73739608f007ad81fa1788931c0e0dda65032f344a12249d743852eb1a6d52a9 +8630f1707aea9c90937b915f1f3d9d7ba6bda6d7fdef7a40877a40c1ee52471fd888f84c2b2c30b125451b2834f90d3b +b4a747e0bd4e1e0357861184dacec6714b2b7e4ee52fa227724369334cf54861d2f61724a4666dae249aa967d8e3972f +a72de682e6f9490b808d58f34a0d67f25db393c6941f9342a375de9ca560e4c5825c83797d7df6ed812b71a25e582fff +8d5ea7d5c01f1f41fffe282a334262cc4c31b5dcf31f42cc31d6c8e37c9bd2f1620a45519dab71e108fe21211c275b6c +8ccdc7e3642c2894acbf9367f3e99c85963cea46dc5473d175339a2391be57dd8815feacadec766e13645971213b9eb8 +858e9b5fc8c13b651ff8eb92324bdda281db4cf39f7e7bd0472908b3e50b761fa06687f3d46f4047643029dc3e0ceeaa +ae20d36c70cd754128c07cbc18dcb8d58b17d7e83416e84964b71ccff9701f63d93b2b44ec3fddc13bbe42ebdd66221e +860dbf7013da7709e24b491de198cb2fa2ffd49a392a7714ad2ab69a656ca23f6eafa90d6fdc2aa04a70f2c056af2703 +8f809e5119429840cb464ed0a1428762ba5e177a16c92581679d7a63f59e510fdc651c6cc84d11e3f663834fcafeafdd +8d8a8dce82c3c8ea7d1cb771865c618d1e3da2348e5d216c4cbbd0ac541107e19b8f8c826220ca631d6f0a329215a8d6 +86e3115c895ae965b819e9161511540445e887815502562930cedc040b162ecb1e8bdc1b6705f74d52bf3e927bc6b057 +b9833b81a14115865ca48c9c6a3855f985228e04cbc285f59bf163dca5e966d69579ea4dba530b1e53f20bd4dccdc919 +a71f5801838a6dbb162aa6f0be7beea56fadac1a4bcd8113a0a74ab14fc470a03775908c76822d64eb52a79b35530c05 +a77ab73ae94b6d3378884f57eee400eff4a2969aa26e76281f577a61257347de704794761ea1465dd22a6cc6304fbc4a +acd1c5df3c487c04cf27f002e81f2348a0119349b3691012526a7b0d3bf911cdd3accbc9883112ed2ba852145e57fe68 +8a28515a48832ac9eaf8a3fb3ad0829c46c944b4cb28acbcdbca1d0d4c3c623a36cda53a29291b8f2e0ea8ee056b1dee +846bafca11a7f45b674237359b2966b7bf5161916a18cf69f3ec42c855792d967d3bf3f3799b72d008766206bb7a1aa3 +b24b341675b1db9a72c3405bbe4a95ccdfd18fa96f876ec946ccb5108f73e8816019998218a036b005ef9a458e75aeb3 +b99c267b4a09193f3448bc8c323e91ef5b97e23aeff227033fe5f00e19bab5583f6e5fcb472ec84f12b13a54d5c0e286 +a088aa478dbe45973b04ecafbcbd7ee85c9a77f594046545cdb83697a0c2b01b22b1af0b97dd75d387bb889e17f17aa7 +a0c6b0cdff2d69964134a014e36c3709d9e63f6463c5cd7b01b6f0be673731b202d577539d89dd57a888326da1df95af +b4e6dc4ef11b2b41794ece70a8968e56705199d183366759568b6fa845d2cae127486e926b5b27ae9118bb21d1682c1d +a007804353f174098f02540a57e96227232444d5ae0a24232c244647148b6c049848cbd2b50d0a25af3ca9164bfff8ee +873fb034cc39c9cee553ece908fbf315f62efbc412b9afdde6a1889326b7f6f813e050b0601ba9921688e958cb75942e +b5676c90f0106c40d8683299e59d564f505ec990230cb076caef3ae33f2021e6aa5c9b27bb8fead05fc076df034c28f5 +b5a67fc4c5539ad1ddf946a063110f824f7f08d2e4d30762c9d437748c96c9147a88efc22260573803ab545c18b108f2 +817ff2b748a949973a91b69b0ec38efbd945aeb26a176d19f0fb76e261c7526c759e6f5516f9ed34de6eb1ac7838c9cb +99b76bda3526a5d841e059010fdb14eb2fa035a7d10463373a062a98c3c1a123e2da0848421dd7546d776438fd05e304 +aa0d363270f90d56bbee7ea577b0c358532bda36d9247af6c57d000044a97ba41e35bb0db438f4c94551c6350e4e0674 +acdae205d05f54b9544be96c9032350511895ccf413dbbc56d1f03053185df22a6d5b7ffcc3fbe96c3e2ce898ccfa73e +b091c220a1de18d384f50dd071dca4648ca4e708162c52a60e2cedc0188e77c54639f75bce9a468a64b2549119c07ded +878676133e5c700b1d4844564fa92a9930badb5293d882aa25ee6721a9f2cfab02088c31d62cf1342ae3edaea99a1ea0 +9756d0793e6aba3b4dff48100bb49a5ec08ec733f966cb438379b91caf52fc2a5930830ec3f49aa15a02c82c1914dc7a +9722f760184d3b2d67cb2cea7fa41b1ff920a63446006bd98c6347c03d224d2d8328fa20ccd057690093d284b9a80360 +b5a68489de4f253715a67f0879437bfe8f4dfc4e655ca344848980e6153b1d728acde028bb66fd626fa72eedd46ff683 +a8cfc900b34835d9fd3add08044636f69614eff9ae929eac616c39bd760fd275ee89bf24b0f275dd77a66e54fd6b94e5 +89967479bebf70b2893cad993bf7236a9efe4042d4408022fdbb47788fabedcec27d3bba99db778fcde41e43887e45af +889235938fcec60275c2cf0f19d73a44d03877d817b60bb26f4cbce09db0afae86d42d6847b21f07b650af9b9381fa82 +b7fc321fa94557d8fbdd9fff55ab5c8788764614c1300d5ef1024290b2dbb9216bce15cb125da541f47b411a2e7e3c2d +b11b0c4dc9477176b3cda6b17858dbd8c35a933ed31364801093f310af082cb5a61700f36851e94835c5d4625bf89e32 +9874e54d2939ee0600f4194f183877c30da26d7515e9e268fea8d24a675dd2945d1565d9016b62b1baab875ac892f4d2 +90df3a77280d6f1fa25a986309bba9d5b89c3cf13656c933069bc78e6c314058716b62eacfa7ab4aff43518b8b815698 +962b08299a287d77f28d3609f39fd31bc0069f7d478de17539e61fcc517045050644b0307c917208b300ce5d32affcca +b30eedca41afb6f083442aaa00f2e4d5dc0fda58e66aaf0f44e93d4af5c4bf8ea22afec888cacbf3fae26d88e8d344cc +847747a22fab3fe3c8cd67f3f1d54440f0b34ce7b513225dc8eb4fa789d7d9f3577631c0890a3d251e782a78418fecfa +8d1ef3cb5836e4039b34ee4e1b4820128eb1e8540e350309e4b8fea80f3ae803d1f25f4b9c115482b324adf7c8178bc7 +8f8a2b0b0f24f09920b58c76f7d99ec2eb2e780b5a66f2f30a9ed267dcaea0ec63b472282076c7bf8548211376c72f6e +831ee6dc8889bbf4d345eaeb2f425959c112d2190764abbbe33bc44e1d9698af87ff5a54d01fac00cfee5878dee7c0f6 +a7eb2479ac80d0ee23f2648fd46c5e819ad3a1f4752b613607ae712961b300e37f98704880ac0a75f700f87d67853c7a +aa4d1b9cec62db549833000d51e83b930db21af1d37c250fdc15d97bc98de7a5af60dbf7268c8ec9c194d5d5ccda3c1d +87396fd7e78c4bcf270369c23bc533b7fb363ca50d67262937dab40c7f15bd8448a8ba42e93cf35fb8b22af76740d5e1 +a958b2a9ffccbca13c0c408f41afcfc14d3c7a4d30ea496ce786927399baaf3514ff70970ef4b2a72740105b8a304509 +a5963a9dd3fe5507e3453b3b8ed4b593a4d2ced75293aee21bfed7280283348d9e08bf8244c1fce459aa2470211d41ea +8b06ddc3359827558b2bb57caf78b3e5a319504f8047735fcc8ec0becf099c0104a60d4d86773e7b841eb5b6b3c0cc03 +9437e7278283f6d4d1a53d976c3c2c85c5fe9b5aec7e29d54a5423e425b4be15400ed314f72e22e7c44ee4bacf0e681c +b56067ee26a485ed532c16ec622bb09135a36c29b0451949aa36fee0b0954d4bf012e30d7e3fc56e9f153616b19349bc +a5c72f7f5d9f5b35e789830a064a59c10175093a0ce17654da7048827d0b9709b443a947346b0e5d96b5ea89b8d7c575 +a8318d01182d4c9af2847a29a6b947feef5795fc12e487a30001cc1ec482b48450c77af4837edfa1aedf69f0642c7e5e +82ea421c091552d3dafa7da161420cb5601b819e861dd2ba1a788c3d1b5e8fa75cc3f2b0db125dde8742eb45b335efa2 +8679fd1c7771ea3b12006d4a972f4f2892e61f108107d4586f58ee7f2533d95d89b9695d369cdace665f19c6bc3bc85e +b5ab3e8adee4c950fce4d33a0e2f85d3d886e60a6e2f4454b57bc68725f0cf246372d863167482cce1ea10a7c67c3af2 +a85696927075ec188979180326c689016a0dc7a2f14ae02ea27c39ef91418cd44177d3fca5752cf6b298fd75fa012e26 +a44f87b7232f102cd092f86c952a88afb635484a984da90a41a57a3d883c9469064bf105b9026024090486b6c6baa939 +866ac91a437db945bbfdc11fcee583f3669fa0a78a7cecf50fbfa6ed1026d63ad6125deba8291452bf0c04f2a50e5981 +b780d5a1e278fd4eef6139982e093ceafea16cb71d930768dea07c9689369ff589d0c7f47d5821d75fe93b28c5f41575 +b025d0046e643506e66642c2c6a5397a8117bbfe086cee4175ff8b7120e4f1e6794e1e3f6ec11390993cca26d207ae43 +a04a22b6e28c959ab265c7f48cde42bb6a00832c6beb2595b5df2879080a9424890960417d7d7ceb013d697d0ebf7267 +81de9c656ac27f54d60d0252e33aff4e9e9e9c3363a50740baf15a2b9061f730a51ae1704e8c4a626153cf66d47f19b1 +a15fab90599df889df11fa60c752948b68fba54005491180dafb66c5775547976d0eef33945e55d4818653e0818c6f92 +b06f9be44ddb103a72fa4ebc242c8ee1975fe9bf9ef7124afeda9967ff3db644dbf31440151b824869406851a90984a2 +99abdfe6806ae5efa2d11577da17bd874d847c5f810460148bc045bcf38c4fd564917eacb6ed61bb9164ed58055cd684 +ac53231077f83f0ae5f25e52b70bb6105d561c0ba178040c11c3df8450c508ed5df34f067fdaacf716f90b4926f36df5 +99e3f509af44fc8d4ebc693d3682db45fd282971659f142c1b9c61592573a008fc00502c6af296c59c2e3e43ed31ec7a +98f2f5819670aff9a344e1c401f9faf5db83f5c0953d3244cfa760762560e1c3a3c7692bb7107ea6eaf5247ac6fd7cc8 +b5b9f90391cec935db8d2b142571650fcbb6f6eb65b89c9329e84b10bfa1c656026674d70280ade4ba87eeaf9333714d +b0696b77ca8a0cdbe86cad12f358880926906fb50e14f55b1afc1e08478ae6376215cbb79bc9035de2808c7cd2b13b85 +a51d746833062a65fd458a48a390631d5d59e98e2230b80d8f852cfc57d77f05eefcfd3c395ade1e86d4a39c2141365c +812d67654319f4ef3c9e4a2d4f027a4cb7768f1ea3f5fdde8d1b79187a4b874ff9a5c70f15b7efa079c2dc69d1b9b1fe +968978b653c6416bf810f6c2ffa3d1abbefbd06f66b6686e9a4fdce3f869e0ab1e43cce14dc83786596761c100ae17e1 +98e1e6ab562ca7743783b802faeb0a24f1341abfb9655f106920aef08964a3c0e8083e1acda7ae28fed7cdd5478decb6 +a91c0b982a0a7085a103600edf99e9d0bee4c4e7db6d9f8f376c215c7d42476218462a3765f2928e12c3dd49d688e4fd +8a43395b3124fab9e2438635bf88952e8e3084dad7ecb3a9927f9af0e0887bce4707084043671fc98ad03621e40a149e +b0b37626143d4a8c6f5693d5f1fe871525b4dd946c4239cde032b91f60a4d7a930d7ba28959737550d71c4a870a3a3be +b01c74acae1715c19df08d5f4a10e0c19d1356264eb17938d97127bf57e09ced05ba30d0fc1a9f32d6cff8b0d5f91c9a +b4c2328eb8a5a673406faed8f0aebb8540d2791646e37ce46e0e382506570ca276eb6f8e166dbbf9e0a84064873473b9 +85cb9f769a185e3538e4a4beda9a008694e1bf8dfeea9dc07c5c40a9ceb1d31fcb13cacfaa52849ba1894b5027cb8c30 +8742f91cddc9a115ddc73982f980f750d82d3760f2d46ee4490d5b17c6c3bb57c7d4c7b8d6311b7b41e59464c009b6a5 +948ef86d17128a061e1bdd3ea7fcc7348e3ec87ec35dc20a58dd757d5d18037fe5e052bb359e27ab4c2320d9a52a6a0b +a70f6a214097c271e0d2d95e30fce72d38c30a2f186271fdff0e38e005aff5baed53739b8c4f9501aa7f529c5cb2da59 +892a7574cf6704ad75b346c95ae6f2668904f1218c35b89b07a0c2dbf3c62173c348f6fd9473926eef56a37c0f635c04 +837e85a41f39b4ded1420aa8fc3be46a7adb99305e0928c6d7643b7c44434b72984cea08eb68f5f803661df0db78c87d +94e495329f2aab3eeb68f347961d1006e69d990095877a4dcc376546233adf29a14bf6b16a0c39aa477e15368e87014c +851860a8fdf76a97048396553262637dade27f1f63f926997e74c7c72b14b10293eae7824e8dedffad1aead57c124f79 +90481017a250972055ab1cf45ff17d2469517f10f18c9d4ef79a9bdc97a49093289bbacfefa8a1e491bbb75388b34ac0 +983db15f7463df28091c691608ca9c51095530fa6b1b7b5b099c612e673d29e16787cc9ae1c64370ba6560582ce623c0 +a477dab41014c778a1b78a7ce5936b7b842124509424e3bfc02cc58878c841c45f9e04ccc58b4f2ff8231488fff0b627 +868ebba1c85d1f2a3bf34c0ab18721ea725378b24f6b6785637ee4019e65d4850e051c8408fe94a995cc918c7b193089 +93cbf4238a37ccd4c8654f01a96af809a7d5b81b9e1eab04be2f861d9d2470996fb67367e5bf9dcd602dc11a3e4cf185 +83113f4e696030cca9fdc2efc96ba179cf26887c677f76cde13820940ad6891cb106bb5b436d6b0f8867f2fd03933f7d +90c709f4e3359a6d215d03f45ad5cf8067aedd4aab03512dd62229696485a41dcd64e2acce327fda390e0352152fce13 +9945cfced107a36f3cf028ba04c653360afc5013858b9a12fac48802efcbc198c9baf3a7f9b23dfdd5036e88bc7274c8 +832ae60192b47fc735a8ddeaf68314b16256c90ab68099f58e43073e249c6939895c544a02fa34e40805bc6b5db33461 +8b12c335818b643c1d22cbc2869606cf64e7ae54a7713617fc4dd3b2f052ebd6b920ca59ba2e9c7aa8cf71bb4f40f9e8 +a2033eb7a373931c65d66989644aa0892ac3778b9a811b2f413d8bf534e282c339717979f9aa742162abb3468c195f87 +aba2b4c37dea36bed6d39323e5f628ab607699c66767f9bf24ef5df1bfcad00c2664123c0d8d5bd782f1e14a06f4c769 +b71963777535b4d407286d08f6f55da8f50418486392a0018ee10f9ae007a377b8b8336f33386b0eb01c45695c3ed2da +88dc87826941340913b564a4f9b74985a311371c8e7b47881235d81c081f1682bef313c2f86561a038757fb7d6a1a8dc +869e13e3fcf91396750150f9dc9307460494c1d365f57893fd06fb8acf87ac7dddc24e4320d9cad0414119013ea739b8 +92194e292303d32b91ae9cecb8d6367c8799c2d928b2e2846dab1b901371a4e522fc4089aad8f4ee676f0614ff8b19d7 +aa589a3e512cb4f8589bc61e826a06d9f9cb9fdfd57cf5c8a5a63841435b0548e30a424ca3d9ef52bf82cc83c6cb1134 +81802e0194bc351b9a5e7a0a47911d3a0a331b280cf1936c6cf86b839d3a4ab64e800a3fe80ea6c72c3751356005a38b +88e5e9e3c802314ddd21cb86f2014948b7618502a70321c1caf72401654e361aac6990a674239afa1f46698545614c93 +abac1e0f85d5c3ff6d54ed94930c81716d0ac92be49e3d393bed858833f4796c2b80bf7c943e7110de7b2d148463bfbf +b7eb416004febd574aef281745464f93ef835fd65b77d460b6ad5d5a85a24b536b4dec800cfe80ae98489e54447e8bb6 +b3fd8ed1c30e7c15b0bc0baf0d9d1ecad266bafb281cd4e37c55edc76c202fb1e4ea315a91a2848f40f481793ae35058 +86ef674ddf4b7d303c68bbfb53db00b925ccbf11d7d775ca09e458f4ecd868ca828103e8e7cd9d99672a193e81b83923 +95ef414e9f7e93f0aaaeb63cd84eb37fc059eb8b6eced2f01b24835b043b1afb3458069c45218da790c44de7246860c9 +93ec8f84c20b7752bfc84bb88c11d5f76456136377272b9ac95d46c34fce6dcfc54c0e4f45186dd8df6e2f924f7726ab +95df5f3f677c03a238a76582d7cb22ed998b9f89aecf701475467616335c18e435283764fb733fb7099810fec35932ae +8cda640695c6bc1497d19b9edc5ff4ea94c1c135d86f573d744358758f6066c1458901f9367190dcd24432ae41684cf0 +b19aedf5569435ff62019d71baa5e0a970c6d95fe4758081604f16b8e6120e6b557209cdea0ccd2efec6ff9e902d6ce6 +b3041f21f07d52e6bd723068df610aa894dfdde88094897593e50c5694c23025e412ef87a9d16cadd1adbb1c6e89ced4 +a7f8d6ab0a7beb4f8d1cfef6960ebdaa364239eca949b535607dee5caeff8e5dfc2a9cfb880cc4466780c696cff2c3a6 +99a565b4796e2b990bfcb234772d93c5ffdbe10453b5aa94662272009a606ba6ea30cc0c3c26aa22982c1e90738418a5 +90c54b55ff19157c1e679d8d4f7f0687a70a27d88f123179a973c62565adfcc9347cfe31f54539038cf2f34556c86870 +8612f34bcd018d742202d77d7ce26cf9bc4e0d78e50ddf75250b9944583b2c6648f992b635ea13fdaae119764e7c28d5 +a04fb38e5529bf9c76ec2b5e3a1ef3c6f9effb6246c7f67301cfed707356ba1bf774f2867c77a5805933f0c8ad0ec644 +b4800e7b503da0164885d253135c3b989690794d145182572181995e6fa1989f3d0324993e871bbd5f48fadd869d8a18 +9981cd4f28ae7b7dadf454fb3aec29746dc2e0ca3bd371b2a57cd2135a7d93559e02132528ccd2d305b639d7ac51613d +a3ceec012dd1fbad3ef9f9f1d6fe7618e13d4d59e3f50540d2a57010d651092979c75442ec8b38a1ab678505e30b710d +8b97b8654d067fb4319a6e4ee439fb8de0f22fd9db5569ba0935a02235cb4edd40a4740836c303ec2394c59a0b96308b +b3d1bf4410fec669a269622c3ce63282c9ac864620d7b46c9dfcec52d8e79b90c4c90a69c32763136a7f2d148493524e +93174eba1e03f879e44921084aa0ee3562e48c2be49085de96ed7621c768ff52324d14c8cc81f17d7ed50c38ffb2c964 +aa2194cd0fb7aec3dac9a1bd8ea08be785926ed6812538be6d3c54218ea4b563646af1f5c5f95cb914f37edfae55137d +93f2c0dd59364f6061d3da189e04d6c64389a3563b062e8f969a982cd68cc55b4f38b21546c8a67c8df466ff4f61f9c5 +aa7dd497cc949c10209c7010ba4ce8a1efd3cd806a849971e3e01716ea06a62e9d5e122ad1d2b8e5a535fae0a01a7761 +ad402424b2a32bca775a66aa087580d7a81f0867f293f1c35580b9e87ccc5a2bab00c29a50fd0d7bd711085ae2248965 +96237843d8e29ac77fc6ebf4acc12946ad11697de8e5f152fe5776f2475b790226a7d156ac48968dd68b89512dc55943 +a45c25cdbb9fc327cc49a1666988af9ab4c5f79cea751437d576793a01c3eeea4c962c05c0947852fe0e4c63e1c84771 +93dcf834a614a6f5484cc4ba059e733ab5dcc54253229df65ff5ad57b447353ebbc930736a4c96322e264e65736948dc +b9a94f82a82c0c5a26f2c1d5381afec3645e8ee04c947dc3b7ad59a73018db1e9965ab3642f2bbf60f32c430b074fb22 +94eab29b3524ccbe0c4b928e5fa5dd8f684074b332fcf301c634d11083653ffee4f7e92ddbcb87ed038024954ad1747b +b8dca5f679931d6abef0674bad0639aefad64c2b80572d646aaab17adf5ca1ab2ebeecd5a526cadc230bec92ed933fc2 +944d394958e539251b475c4304f103a09f62448b7d8a8eaef2f58e7de4f6e2e657d58d5b38e8513474115f323f6ec601 +8a5ae1f13d433962d05df79d049b28e63fe72688fc3e6660aa28e0876a860c3dbc5fc889d79f5c4dec4b3a34cdf89277 +afa5278724998eced338bb5932ecf1043d2be5dd93f4d231d05d2ea05b4455f2ffdc0eadcb335dcace96dd8b2b4926fb +b91153a2f4647ae82fc4ee7396d2ca23270ec7f8884ce9eead7e9376270678edd42dd3d4d6c003dfc2dde9fd88cc6e7c +adc932f1c679bf7889cb1ff4a2d2897d7973483fa283979a0ea3640c80ed106ea0934c1961dd42d74b22504be49851f2 +a82e90761fae684d1415cee0649bb031bcb325ae0b28f128ab8e3650bccedd302a70de1a341ca8decfdda76f3349cad0 +8ae353188b4b98835f4ef0333cccb9e29e1ac3ec11d554bc96f5880c101cb3c84b8eefe72f2287b0812735339fe66cfa +b8b41135bb1a1ffb64afbd83e2189e755f2c350e1273cf47c38ae9b8c4800d831436a69458b8ef9fa8b95a148d8ec9fd +96f75a04d8752fa93dc1eaf85ad333cff4eeec902a345576139e16de3a88eeb71b6726224349bb9844065cc454d959e9 +ab82b05e3923ad4c26f5727c60dc0d23063c03f5a4fd8077da66aa87042cad1bd99586d4ab35aa5e4ce6f4da6fecf3c1 +a50c83db91c26ef7bf1720d8815b41bd056b49fd99710943679a162ccf46097a7a24585750ece886e38eb4fdb866fa37 +a719f667914a84f62350dcc6f4f30b9ab428eac6837b70318c3ac491c1e69d48af5e1656c021818f377d911fe947c113 +a148807aafddfa0a5624c7cb9e42468219e4bdb9994ec36bc19b6e6d7c4a54d3a0763d13ca80624af48bbd96d73afca5 +aa012f205daf22a03e9fb13a63783dda7666f788a237232598d02a4d4becec7a699ab493f78d722ce68519262924c708 +97fc15fab5952c5a2d698fd6f7ad48aff1c8aa589f7d3b14285fea5e858c471cf72f09a892e814104fa2b27eb9771e73 +8da8840236812667c4c51c8fc8ab96d20dae8e2025290b9cde0147570a03384370b0fcbe20339c6aff09cca5d63e726f +b477d85359a8e423fed73409f61417a806cb89c9a401967622aba32bf85b569e82bca1b3394c79e180114a0d60b97316 +b3d6ee2ed1e4c5cf8ba2c3a4f329832e41c7fdcbcda8a3fcbe8f60967fdb1717665610b7c1ac65582534d269d762aa09 +a0b3b30b1b830b8331ee19f96b4a4321a6b93a3395b95d3a895682c65ec6ea64774b878b93514eaf353f2e4be28617b8 +a2b88e9617f4d30ef4e686d1932ad43cd555fadcb5102e51bea19e6fca649284ccf4debb37b5cb2090ef386fa5bf5327 +8a4446f7e8463ea977a68d6217a9046ad4356d6fc1c18d46c5d2ab681ea977b8faff136d65abea6bbf8936369cb33117 +91e7464bc56e03f436228104939ddd50caace5a38f68817bb2991e193b57adf6835152bbf3dbcdebf0382ac9823f60c9 +961a441e6cdf8106c4f45e5b47190d35644faec701c9cfc41ced40cfdd1fa83752fd56c1ac49131a47f1970a8f825904 +94b7b165cc71c2ae82976b8f03c035fb70e90028992b853aa902c0467b384c7bcf01d56166bec5def4453e4d0c907e52 +a5d32cffabbf547f900026b34ef46f08075b7a244565f615370d2f04edf50b094c95088a4a139ce07caf55bcd99afa07 +b4e06e73660745f75ab2f34d9f6d2675b58f80f911ab6dd4c5a6ce1095f9a2b50d86f6ff9a05394190bdf96af0827920 +ad3fd8f83c0103b29d41319209dffca201d2b98094362da08da3fd6ff0ba96796b49d6bed525c9adb96c2954858e7f48 +b0c27430695f0fd20ae31e1ec621da090094f2203e17411db9384695ffcf5c7c6badf461ba49ba70164aacebd6f278ee +b9bc6e972fc3b532fd2b1eeafc4bceb77604885f32132af6a9a842fa2440df452f49ec0cd9d86da1180e8deb0723b260 +9729e22d6104b0174c136a854920f542b384d375040adcebe36acc253bdb55845eb43e34dc5a7cc27d22c417973c24d0 +a8b420b36d48786c9231d454468a6e855dd7f71dcfd095efc9855ee70dbece0f06ad277f7829c5813fc30524c3e40308 +8757dff5499668c93fc5d9cea0a8db61817b8ed407200d623030b5849a913d12f8371b667cfde8d8082026eda7407e8c +b859ad747ca5af661fbd03a1a282df6e84c224ecea645bc2d4ba5e35fa06cbf047387319fca0cbc76b712398c0798968 +8e3173c27875f1460297af0fa736c945dc842ec3e476a973d3d5f790bf183ad3ffe96ac13868c5101d8e299890791864 +a9d725e2b92c878be42b5eecc2c3081c63c7231ccc7e2dee17ca6a4caaeae22788fab1f1465fcbd7fc236613fc2bae4c +86f6c4f04a354cb2470ef91914816fd740f8d5795ce7ff981f55a2634695fde5951bbae7a4bbc4c63747040f8644170a +851773cb26f320f0c3f252d95ea7e058ffcc795dd0dc35e459aa1b6b448238909230d809e82022e64b7fca5d40b8324c +8962641e0306220d9892fe2d452caa286301a3c465185757be7bce2d9b2c9beb3040280099606cc86773e43941fd3439 +8beb6e08c440b0de5fb85251d39d9e72db4e556a2dfe3dae59efd8b359d08492064cebd8d8993254b43bde8bd67d969a +a7e047894466ffe3dec4ab8d5462f2b1d8ac0df006b1d2dd26caf499ea857d93a811cf42233f9e948c9cb903beec004c +92eedd95557a91691a5e2835170390ce2401e223da43b78615a804c49566f9d31cbb7f10c8a8390c4bdcf691544fdba9 +a5e5b5d8fa65824e958bbae98d146b4b332f97ed50e0bc2c58851dc2c174ab71bcbb1ae015cd2955c26b368487dd862f +853a494eafb308175629d581ed04bed71bbc3af9ca4c0dc483d03d27c993a2bbd88cea47c2085a6928d166fe6938fb77 +83f06b88d29afbfbe8f61811690322ac4fdd6abb9a23612162e7a2dd6bcbb5f14cee298ebebc1a382484f7346dc51e60 +8c9cf05735ea5a0e563490bdc7ed29a4426643711c651e35c8551ca6f855c8458ae8f0933a022d0bb9a952edfed411f6 +b906b48d807748a26cc2a8848455a76ce502261afe31f61777b71917bdf7de2fece419db636439478c7582058f626c29 +97efe1fa7c9b25d8bea79d74b6cdcf88f63f1e865f54b58512a2e60428630b0b40b8b6af1b5f71df47520507548c3cad +8ef5ca6e753818906bb3fc71405928d8e4108854ef0ef01c1009071b353bc2852e771fcb619d5fea45590e8f61003d7f +8e4d901661e2913740d70ba4d0745df5e8c9c0a260149d9362beadc7e669630ba909ff0e8a6cc85c54d6b7435d0d351e +b7c6ba3bebbd9592967954e3a480ee8df1d9f5965f04e7d78a5415b645128deae7ddaf6ed507c8877bfca91ce078e529 +840bedb0ad4e25acf6cd25dee4f98fea495b2312dc5cb7a8388c5ab00b2acb9cd25da08e9fbead145a3107972b1ccd5d +a8d4578dbafdb27f3911af59962d89e75dea74db55346720357790da677312c203107d9c7911535aa563446fde7d4c47 +86d3b77f231bfa09251b7fd2ce09c27ac520ec35d783e912476f9a4863f83d269eb175790d6e735da9260293d707f8ee +b34909f1cc033232652da0c34051a769dc76adb1aee00674a59dc1b860f6e610974c3b4bb69a69ccc73e01f042431242 +90799854d0cf34e1d91ff8e101bc7c5007423d34d2f3bd9adea2ecac57e83f3a65a506bb93d4caea49b29f6d18149957 +8ef94cde29b037e19a1ce7bf4418ad3c95cd9457412796ea385750c19a6690f13a3bb5bb6a9ee81e7a40face1e0a8bca +97053d21ae8d75972fb37f6fe516c38c32ab162fb56b9f510f954858f4e3ef6ac8c3a9557ed3f41b7b6aef05fe97f931 +90a9f9f0f40991f3bddc58b92d40382147db22cce50d092d4a05aad251b46b94e71ec9f7107a180243288059fcc5ce29 +a14265b1344ac2921b0f890d13bcfc432e4f648ce403e261fce4d3bb32ffee9e2794c02830346054f998e82784c77040 +91928402ae121e56a3e64cd6f390127e6e92fbfb1967ec6efa4f52f3e8058f1f41a0f4fe96b5bcc11641c1139e790b2b +921c8c92b6d40da6c5a7b592acc74fc0f577d93767b9aa4a1cd302a72dbf503a1ea5b2c29fa0d0359bff3b8f252246d1 +93ae0ebe0e8e133fd80cf67a499047e30ec4c4660ccec9d49098717ef57721a030f423e00c5e74af4ff4acf014a10497 +82c865e21905aebfe0496af1c6ac7e342b5f446a9edb4f7da0f2fb0340abfd8e6fc545da874459d9aabe6bce0dd9bfcb +aee3961d8d2687c0f134b9c28b920bdc4021d925fbe14323c84224a9fe161248789249fb85436a5891d0bbff42c2a3e9 +91aee420b98b6949482b8ff4be996b97245b4e8f583a6e085226539074f42aa89818395efd1a6699735a569bfe19d623 +a48eec22c192e495b01722d0016a54acc45ff837e2a95c4294ce81d5a4e43e0053a6f0ead8a4fb3ddd35faf6607275b0 +a26e15937c11faa30ffa64817f035e294cab0e839f73d29de8a244ad039be4e221eb47ea08d9a4658b0152fc3caf6110 +b84450f948aa7c8682fccb9cae84d8e3558adf2d0ca5fb81eb200415291158720f8f3470542ab5b88c6873ad08e7fa9a +a8e8ec27d0608d020169a85d6ecdb40eb402f006a3b97afe32cc01987721b3a68a92ec693aeb4d357e189e05fadf699e +ac87cd535ef5699312cc26f86adb71baa0be42e858bd5a2d94ac05737dac63430691e29b9a30d2559ad581a172519b2c +a4481e67b524f8cddf2046625efd3d75efee6aab87ddd2c1b22835647e918157e5e924ac760db2195c86d326f3db1615 +891f29ded231486ee826840c8895cb325f7e84a5a6d2eac246cb3573612cde274720233b1978318a57ed337a046330a6 +906b6e750e6178289012769807d2598925d7e51c260c14497d8af978b1695990e3352e6e809a752f376597a68083870c +b7a056898ee1e46f7f29702fb39232f678ec173eccd170303b3b0a30c8d8cf1a5321384e3513e3b03bb742c238deaa54 +8f2f035fd96c3a336354c89ec9b8222803bf42e95fb2412c28d4e75eec99c1d4d402501ccae17357b757db8bdb0bfeab +81228625ffcedf977fba9cfa13f6edead3985e2651d5974789c394a69401cd7face9e20ae6694be4c0d4bab5e99c61a8 +885a83eae25e61439ad809567a2ab148583402e01cfdd77b0e37ab4038935425c64b4e0886949bf06438c35e80aa13f4 +8926387f48752f6933899c48e038cf14e7941ec6a58bcc0a436614b396296a17aa53e6873803dd3041dae470bd493fcb +95d0d3fa061f4d856eca78a569aa132db14cede7646f97e2aceb6da0c8ea53195d3b7a566fe5ec8c41b95ecdd89a1c6b +a3c817f4062ed6aa94064ea695d76c1825f3bf77b310fe1db28b8bedc9aaacbf1019dbd128adfd53042fb943d863a2b7 +af1208417aa584052da309169854149ede38a3ad63c76cad6e43afb6f1a7b854edf8310a0b00088c039259cedf0f859b +8b713fc3196bad35dbf364089049ada5477e540d78d76a5f0a9df98f7ba4a0e65dd0644509c149f9b07887298bf74b04 +89c09c43c5b733c4a417cd9ebc0795cc3348b72778d31828a9171427779a82ef023c1a4fcfcdc919ae25056f9c826fde +a0759c850ed320c8c874435e90ace6edfb8e7b3f2a09d942b8ad8339c508044ee2ee26c70f1b626ec49a77971433b6a8 +b85cbc58d4fd52286e714ac4eaaa0b2743a1de06fa03ddf8f6668ec6f1d204acccce93b10620272afb8c0b49bc4b0a43 +814e0a87384e159892a8d23036985fa3f489c53bce192e107bd2d64f57b1bf5ea0acc1ef46c7a42bbc5cd0924d92b4a0 +aa6821da96ad89d7881b878e141076522f104ea9a5bbdd1fce9f641898f7d6232c518a87a0f666871d7e3165c26081e4 +a9041d714bfc067b5427252186fa3557bad598fc0067dc8521aa9bc1ae298f6e96113db5ac9f6bade9a85d5a950c9755 +b8669340f3064692625e1bf682d34fbe69a61689e3aa6d6a3e822c781d406b0300dba9c3f7b8152a8c2513f1310d4291 +a78c53316ce768a1dc5968030bf4fc885f4029b1ddb6a5d84a61c85af686c73727f62823891edfcb6ccf4545de366cff +ad1d3aa29ea28292ddd438c865e2b5d93f32cdf009e6d5f5dc726de996583925727e6348bf1c28c22dec0bd86aaf867f +ae1447a2062e9e28af5f38aecc60fe150cd10c2edeaf2110034aa144f6235ed7fbce432a58805d4fe1f6b12652d6e1cd +a32146634332d3303934550705353c6d4fae5fa5985105bba35041e74cd71e2aad67b45da171221f6ed80f36bf6dffa3 +a232e8286184196ea77427b53d8b52c44d758ecc42d22556529db3136379b4989dec61cff610cc6cf6700a450a847a94 +8a72c7255125a736da52dff5f77e44c3de29f88fc05f5ff9227c69df296930caaa11446595e6bea3bd946baac5ef957c +9688a981a9457678067f629f8efa6b522e7318b529f88d37ef56c5bf8f1c34fb9bb3a918ab73caab82bf5abb0c03518b +88286f3eabd71115fc3b17a6bf6981340a81cf7e5f96b0a1a016d4ec8c18fb486d46c70919123d0c189a6f5d6ff29a1e +b535e701b40d793c02ac0d625ca91620d3f4a512aa9741f71389e58381008b2f93d597586d06213c4e103d67d0ddf6c5 +80d0c9dd941e8d8d3700cc51a434a5aaa3308cf8ebfd14128ccfd258f826b27cc3cf5c3ad7851340393abb1eeab3a157 +87049225fa2380d93f18d3d90cb0697a56b373b66d7f24ab209966aed8b55a2790194d5885399db29dd5b1f189eda64f +a52df158ce8670e0290551e8878d63dd33b4759d6f50e448e63fc7fe6ea99dddb6f180be5fc0fc3918ce54c05f80b356 +8b2a728b39c465fb0f60b0c486e5dc8d5845ccec03d3dd93b393cedeeb3fe1b44518359f1ed55fc770a8f74bfeb9923d +91fc05419dba718fa4a910dcf256ebea356bbea00522d8d5ec3e7ba4271a26035aac15e8d9f707969df1d655d92dac55 +97c8779ae80c24c1f82d5a714762d6ee81069224e39515e41d8a71c9310dc5d1c55cc92bc5c6a4bd391ae4c321d1d4d2 +b5e5aedba378c4484e3a7a4ed41b75b0844f674261c2501497de6f91f7274b5a4c1be0e055f2e0c0cab843d891169fbf +8a26212f27211b295beea500abc8e9d430a8500d3a350cc62f895d39e8b4668aa638c17633804ba353010000165637ae +864a95118e5d394e00e99efebd505df0125525c9ebe165764c453b80ad3edc730feebde3d93850745dfd88a27bb8f20b +a092e0b78290e826cc1ae56afffdd08f7c10954f549a3ea6666f3db1b6cdaeb7df53db28dd2a92446342930fe60a27ce +a1720224c0626a081b6c637b2a6d37da85d9a82241e5efef3bc15699b02a69f6304e43d8ff3144d60c16e00225d6b39e +a7b3d098cebea9cf32e19c5195608182b6afe9d4af6b9df532c047eb7a941a971279b2ae6a4b80f2f9d9313a6d788ce3 +a3d2451e6788944802c5077a778d7b7299dbb9d1612676bb6baae78f39976e0fd879493cc4a4d737b8174b472a456850 +930121b73da844571b1411d56760e80923a4ee09917b3e9cff4d3dcb0bc27026ff2c4e2c44e7aca7d3f8383f129c7f9b +b4b0119d163ee00a2b74bdf188a5cdcf054daaa48c483b94bbb4d09ff615afb4a91347db6363bc7535e2af9054ec2214 +a5846decee706780201095a8cdd48fbf3d3a2eac8d089a818e5e22c29457494bbfb4399323b067f3d2be2197c33dbd98 +96ba600df10ee7af5a9df29c0ca31dbed275d647faf9c66c7342de927ceb25b5bdd852dd7aae0228b27897f90fdd5d62 +b6ac51ddc98edd9fb9f54ef84bf372a041d58dfdf0dfdbdc4b08ddc1a7ba93ddbb1413dda3c1545a3fd7386c6b85975c +b35f3efd91a0723e0d486188ea9675a3462106470455118392d7610470b623caca2fa33829721c05fbeb0fabcf570bfc +87f49e85df5f8055714a8ce7adf37f6a278e64e76ed74c60abe3edfc3611ef5b0426d4c6da45e5f3b74d30be1dc6f539 +8ff8bb06902a71b1e9177a77367318b2e3e0a88f5d74d6907ca9943f4f9f1ceb5f297132c2a025259d17a67e880d1bad +85eb6de6c70fe5c53ab0ab27aa0fec439f136c979c557d317337cafa6e6c5cb3169679c9169567dec5f6c72b3c057d83 +ac18715ed1080771d760cb7066c6328faf65d9b30517903f8a5cad8d66d5c6381156b521107d7cd75ebb8c30e250706c +b95b9eae4703727e4ac9ddf2ae675906487bb78905a5f9cba74a4cbfd118d96b7afb6ef3ed5edf14fd963b830d71338c +a3b47b52fda16b62b11c8aa4daa56b0b669c4d5c56a3059b7d063284d8a91f6fff9ccccab23d6ceb9650483b2d353039 +96a95b3f327df94c85e92f2e406f1649ac621533c256b062738f3c3ee137059a735a3e6072247acf57b1b0d8c219bd7f +b19b33cc04570be94eae8e943d5bb17bb0c96e9de4ca84f9f41b37320a1a03d397d53747dc13275fef1b356de557214f +a1faa3dcb931dd91507f3f12a17c43f6627fa2bc5c71fbdd27548e091eaaaba262477949cd51290e81196bffb954a492 +b060a16079dca1d28a1fb33cbc26f368630ee042d980ce305230005d5b9ab533a7a695281ab76e9214458303932d8bbc +b303783196a858fe45d67e0520c30576da605fd69964449c20009fbd5099cf1de52a32d326d7c3b864de07440195ef40 +aa550a4c20d1003d137ffd8fbdc1196d09ad53cfa0e202302093a80fa3bbc4c9aff83f34f2151785cc1ce5f30255693b +a7f8585f45566a351058e10c6f1ff4a7ba24811f1482a47202f581525615ca770da93f2f58878788b45b92cb446ef4ec +8206f63a9a5b59bd68e64a843e68fcdf706f4c13bbfcdfa9928298e5b9251006ae0bbd80c715aa3c9957d2c0148b5059 +ac9490abe1241319658f1c2c645cfa01296f5d4106020c7894b7ba4a65cdd52f6c5401bd3b3cf1c9863e088cd8c9a16f +85dd6d9c80a1b58c24c4d2cb7590d33d2454f381f58e820979948e5831972360cde67bbd56e1860077ef5192fcacb904 +8b0285944c676fe2519cb68da0973275fa29c0718d838d363ce46651b068d29f867cf9fe579ff8da0bb8b37d202bb23c +95147275da658d43a758b203b9ca1f1c1478853e9bf77b5218593142e2bd9c0bf46d2206ab64cef99295de6e9a268edc +b8efa187fdd3e1f46c15cd596e9567690c10e253b5beaa5be8074b6ea4e6d3d06e0f2b05323453239e419ae1e7128521 +8340464f52c92e31806fd3e8e65f56e27194d1f6daa4a0f0b3831e8102aba16f88bb5a621633ddb7dd0342e1d2d12343 +8615d87dcab85a78dc052f05a01e751176b756b5dc9985014347454ce5752f459dd6464e1c5aff36cb6c51b783fa2692 +80c6e35c0d3defbe4d3968792724a23f0b8830dd2fac58663583a49339ea20f1812cc4140e3ee867c7e716177319bbbe +a7aa63dbfc201dde8f29bb6e23d7aa5020dd35bd18a0cc93c8a10c35d695913fe25b9e8cf9b5fd1899e9657b22bc8863 +97c2a4ba80c4caba2e729a603d2faa0120915e3fe64cbb065f7ff33de5f877f1ec9461cf455e88ec9e9ded9393939dba +a54bd1419f0e2d2d87757870f37c476c7e3a13502f1ada82fd7394fd29f8a00c4986473d753034d0954a2550badbac0b +8d3e2bf900d0d2b9b46e6e2f37620f0cc90526dbbcfaad4e4a37ed53f39fdd23bd3a6f21aa7e800eaec937d9710dd6e3 +a88d2b1c7802b2dc216c2b6532406c091bfb12f29121b9a82c1154470e250188413ddd3e79f7e009ea987a4c45b332e5 +8c552c2101dfdc3f99c2da436115452e4d364eefe029b12946f05673c5ce1cfb48d39a579625849236dc6c8e7277dd30 +8415c252d52a26a6400c3189c928a98559bf24162ecf3eef1d10e439269c31d854b0b4f6ec7a2430e3f11b5d77de78d6 +8b38905bad93a8d42339dbdb5e510003c51fcaf05e04f88fd7083753353bc1c4c00a5dd4a67431cd4456d0669c7040e2 +b1d0ed8862250d0f0d9ef9dcf0cd16d84313d1a795dc0c08e0b150dadf9ce73d32d735e04632b289cafa69a6ee75dc89 +9434e18a5fb631b10edb02057f2d1fe16000ee55ada3c26a079c9fc3943e29d6de99e52829fe7b333e962270c712e51e +b1b9f3914007e6fca8ad3e7e848a1108988cb2318da36df24767d804e95d1272943fda948451135cc1b5052a3953b081 +8c02947a76d7b6c0a700a83dfb971dc105bfe996e18c521445f036310914b349ab28e57571e36ae08d13a46fb01c2f43 +893472fbc225f973a0ac6a0a0130b9cfb7ab6869dff80df71a62b1f6beb4afd069bbf35b4f327165bc31dff39e4fcaa4 +a7c176c0903175f3540d62f9afee994d5d9bf37081e094644b22f017e94c515afefde7bb07f638342abef7de657f8848 +860186c2b1d3b1e657729bc804275fb5f5ee89eaa60848fcabd3871289665ea9f0efc8a95792d884972bcfa2de96223b +865b38aea6386d0ac8f501a7d934e23d01dc50105324e354d4c4fa3cb1d4c29c26f4566df7b1a728e10cfaa9d24552e6 +b4eea5548de6969dada658df604b5d9c49002e2258352838003e0fdf7b299d81fb025807a7f37cf5b547cebd7f2c1f93 +8982de11ba68d63a649a3b296d4d56c71e3c3eec016db250d733ab7c3b9a620c09c5a5d0b64fd30d3bc03037ca4b17c9 +84d8b8a10d67eda4716673167c360fc9b95717cf36ef1d5bc6f2ef5b9d2624f0e76c2a704d016adf03e775ea8e28d83a +834d03ebd51aff4d777714783e750b84c16cb6627f8311bd8ff17c3b97fc4a5bba57d6c8f6d74f195d3030bcb5f07612 +aaf49e0def0c4d5f2c1e9c17b51e931d2f754b19e80070954980b6c160178349f6d3c8d4808801d362e77f41a0008918 +8ef4115edec841854e89f2bbd11498dac7396bca35dda554290d3db1c459ffc17be671f4a46d29fa78cbd6064cc2da20 +9641dc8a64f4acd38e343a3062787c48c312f1382f7e310ccea3e95e066ab6dc980f6ed90a633236a435e68bf6b3c625 +8a84cfc2cbeb18a11dd6c2a0aebb3f6fd58a33bb4b26101e826add03748595022e816afac79a4e7c20b3805252839dca +9770782d729017659844421e1639ffcda66a2044df9e19769b90292df87dcb146b20c6b9141bb2302029d84a5310665d +98c7ec9696454868ac52799d1c098c15ec4e08b34884dda186ebfe87d32840b81fd3282295df141c91137faf4cc02da8 +a3f6eb921247617292162dfc8eec5b830ddc294a0fb92f5b4828a541091ffdaff34c392c1d7168259d6204405d90ec72 +b185f77a468f07a54222d968a95635234e74fc942485604909308a9028ed2753b15902b9134749f381f7cd6b89cc8c3d +867608a682d53bd691dbc92eeb460d1c300b362ca49c11a280f6768ccec217f1145f9d59fe50d994f715ce89d38a74e1 +afaad630ad8827cd71aade80edf3d7aeb65a344878db12fa848759e6233f6fceca563aa437e506ea9e0f1e47b126d45b +a12afbc84e3441594aecf85d089423dd3bb8bb33a1a384ddf7cc14caa72284caaa56aa179c15e3140fd56bb532491a67 +98757b0b5e5837ddc156a4a01ce78f33bb1fce51e0c1254ee9b6d3942268d0feb50b93edbf6aa88f9ea7b3c0309830d8 +89573f4a4ae752e9f964e42bec77d28a41840c28e4bcdf86a98a131d0b85367b885077823a6f916972de6ac110821bd2 +a17f2745052de5de9c059307308fc49f56cb5230e7a41cb7e14a61c9efa742ee14c41023ce90c7f2261adc71e31045f8 +914b07c53a41c0d480083f41a61c10429ea42dafea9a0db93862d2269ff69c41db8b110b4768687b88089b5e095523cf +b380cc3e0d26370976fe891d24ea4eeb1b6be8cfce01f47fd68838a27190e644fd57b049d3aa0a9589370de20e276944 +906385fdfad60feec79eb1c303e750c659ceb22d9c16a95faaae093daadd53e7aa039a45d57e20951d6e1ca0dc899ef2 +b5211ceee31b194dba60b616bfd91536e71b9213a3aaaf5aaf9b2f4cbdeb05191861d78b97eec58e3c81abe4f0488c04 +97878e9e38c2f69d697800e7a2f132fc4babaacf471c79c26a757f771606e55fe696ece68a3163a0ffeb2f72274cf214 +959431c1f54c46500c05aaa9a2bc4230531dad97ae768fa92bb85436c0ecc6374cf20fb0ef82d122db116820a943b401 +b69e5a1c6798f30d33e42cb8d124f025d2c77c993c4c7107a539aacddf44d8d4d2239e802ece32e60ee4dbfdce201bdb +a8b09e5e9f802ad273b2efa02bcbc3d4a65ac68510510b9400a08d75b47b31c6f61ffdb3704abf535a3d6d9362fc6244 +a41ace7f1efa930564544af9aa7d42a9f50f8ba834badcaf64b0801aaed0f1616b295284e74ca00c29a1e10c3de68996 +a8f2aa0bbbc19420a7c7cec3e8d4229129b4eb08fff814d959300cd7a017ddb6548c9a6efebad567d5a6fde679a6ac6a +9683da74490a2161252d671d0bc16eb07110f7af171a1080dc4d9e4684854336a44c022efe3074eb29958ae8a1a14ace +8ef44d78d10795050c161b36afa9ab2f2f004ccf50fdeef42fe9cdc72ebb15a09389ca72a00001cd6d9b1d7b3bb766c3 +adca54f3b14fb18298098970b0267301b7312afb75894deea1b2afa3e85b7a3b4efac9971ab54c5cbecba2da9f18507e +ac5d4528f06fdccfc1370d5c3d03ed982fed0861a93a3f6453aa64e99360b124926d1892faaf72d89459e663721dfa99 +98aa1c801bd615b8cba728fa993021e181e0ad717ba01c0290e7355694155407083eb53cb70819c4775da39d33224db7 +8b3aea4c7c2bfe1020de3261ec085d79c7bf8a7903b825d2c70ebbb84af197bcc54e3653c5373a2045c3021526b63b66 +a29f3de4cb3d99afff1daf7d431b38a33a9804fedc41626618928ed059df6f6fe9f298a046b594ffee951ed4d4e1400f +803fd346be540c5242667c18ee41b26bc812456ab13ff117196ed69b90ee608c8cb6554396b64066a546ec87a71ed6a9 +a9c18d81ffd029c0339c72c499bb51685392253b996b6eabd8b76f05c6191ed8444a1397d63b9923743661a319517f7e +a048d5c390d08f07161faac71c5994baf152c883b205f3bb10d3501709d6516ae54d491b486303a11b751857a31f0052 +9156fb4803e40e28d8d57d928481a8de4373687288da44fe88c5676a8ae013ed1fcc09d56a31140bf74e7f767253810e +98e289c725b18e0085afdfaf2acbc674dae7b0a2ecc2537a7d0b87e20eb785404ab05973a787f0495d2adb3e5565c09b +8a7237b249325bd67cdc1f9fb278710069033c304afbf270b7ea24dbc10c8eabe559a484d3edc733c77b4384932deb41 +9056f2e5b02e5c2e04a69fa1323bbf1859d143761268d18e74632e43800a2a9c76fd681e924a19bc141de0e128d3e462 +b9f2bf9e4e7263014296a82b9ecbb05d3f1efa4b2e675e3b38d3eace59da06a89c859256e1b77847886d6aa15f98f649 +83b22949cca19030289bbf7cd2a0d8b84e1d468e78bc85271a6753241b89122627632723bc293cf904a5eb2b5dc6c3ae +a919aaf35dd0116168d2ee845122026416bec9633df113fbd913d8db5996221e234f98470d029a8ff182825b59fda20a +91726901f49d32b41afa15219073842278f60dcee223640903d871e318a1c2b541136b7b38a7b2ab7d31e4242fc29674 +942b77666545bc9a858d36cfe857ab1a787c9528f4a0b87918a06bf510793264dcafd12ae6bd3ee300179dab7f40aed0 +80adc1f2f9c47a96d416e44fcba41628abc0fae1f88f6a26aea4648419ab726f7fcc2187c7d5145e3d8f5a75c03937f4 +8041e0f66ba9dcee01e336dd4d16ae5e4e1618512fc147cc8230003aa2940848162dc2187d4130bf550dc1f3559849d4 +999e8adc51bab54386af1c5e8822986ad1b7ecaf1f8a4c2baa5bb2fe9d10710e49545c5a8bd89ed0e61a3d73a908e5ef +89272ffd39b6e9f99fafdd58bd9dc00f66f26a1d36b38a1ac6215e3546d966739eecda7fc236335479207cef95cce484 +b8e0b7532af13f15dc04a0eb4ea8abd67e58f1b1c6ad2e70c0ffa04a5c18ec2018b5d7f4be2f9f86db5e0b3986f639d9 +b96bd11b0f6ead4abd5fe1e4c6e995da7583b901afd01cc05e87d04663fb997997d6d39dd9fb067c62cb1b1cbb67516f +94ab08914088b973e8dbd5685decb95f3bf9e7e4700d50a05dbf5aaac9aea4be2c10c83096c02252e9238ceea1351d05 +a188de419b062af21275d976494c131ba18d2b2ead8bdbfa38a777832448e64d4d9725c6a1d530ffb6513f18d5b68d9d +8f73c8c118fa25c76a4ec5611351953c491452743056a819c8c82ba4737a37d88da0b55f837e7239a5f46d2c05a1bbba +894a44769e0be1c26648b0d89c4c9f46dbdeb3a71b90c493093bee372bb9f2d3f319850fd886d51f4f58db0de5641742 +87d239923b0db024a8d9b0281111d47b0761d81c50652268b074efa3ea70d793e30f874a91ce33a4acecd0cf38c01951 +b1b48b75a97f9fc2dc9530dc69f6268829dd0ddd574516e7eb1b9f5c3a90058889a7bcf3d378738e6d4b02f5fbfa44db +83e3ee9526ffcb60c6e75b75550fc017912ec0daf96d0a0d5f58c1b229cce90c684ac7c3e17fb998def8e7e2e155d750 +b9b7bba579e474b0abdc7775ff5f84c9f117c6ca17788cf5a5f01b2c35a14aa39036031c8d799fec2cfb371d9f7471fd +90d7faf4891fbc368a32f575dfb69f13e37161ab4f63a7139be103285a49490c2851a907f8d36e09e7d1a190dddbc6cd +968c8b9affe18fc34a4e21f0d8c5518341c566099e6b45b8721c9912bab3693c9cc343406fe90279692a1eef2a3f7311 +8735baaf4704207550f77df73fb701d9a63329993a8cb355ccc0d80daf950145f37e9b4b22be2aba29898e974f9fd552 +90f52b2dccf525b9191d836b205ffe966d9a94f6c5800f8f51f51f6c822619e5abdf1257ee523597858032d2e21014ec +831209f8f5257bb3eb452d3ee643d5f063299f8e4bfea91b47fc27453ac49fd0ba3cf9d493c24f2ca10d3c06d7c51cd6 +a5a4db4571f69b0f60fb3e63af37c3c2f99b2add4fc0e5baf1a22de24f456e6146c8dc66a2ecaafeb71dce970083cd68 +b63da69108fad437e48bd5c4fc6f7a06c4274afc904b77e3993db4575d3275fce6cffa1246de1346c10a617074b57c07 +a449448d4156b6b701b1fa6e0fe334d7d5dd758432a0f91d785b4d45fb8a78e29d42631bc22aaa4ea26f8669e531fed7 +aabe43de1350b6831ef03b0eef52c49ffb0ccd6189cce6f87f97c57a510ac0440806700ce2902e2e0b7a57b851405845 +91015f144fe12d5d0b0808c61fa03efe0249058e1829bb18770242f5fb3811e4c8b57ff9cb43deccfc70552e4993892f +8e9c570811ce44133ce3e0a208053acb2493ef18aade57c319276ad532578a60d939ed0bde92f98b0e6a8d8aabd60111 +8b21839b5dc1c9a38515c1076b45cedec245d1c185c0faac1d3d317f71f1bfebba57c2559bcdb413d9d7f0a2b07f3563 +90413bbd162be1b711e9355d83769e6aac52fdfa74802d628ff009325aa174c68f5329ddd552ef93e8fdcb9b03b34af3 +8b6b02e3f9dd1031ebd3df9a30432a3c86e64306062ef00a6d1243620d0cb66dc76f8d0d412eceff877ff8768c2696ce +9894b41d9fc715f8f6addace65451f41dc5ce7b983dd8cb33757b4d7259bef12f144e0077d0b662aa847d5a45f33c563 +a353a9740f6188d73aa4175a6c5f97898a05ed7aae9d2a365f15b91dfa7c28b921fdef0a32d90b6fb82718b33d3ddb8d +984eab8faed87c403c9979f2d2340fb090cc26d00cb4092aeb187c3f4ee1df3f57cb8363f7764073188790b16dfc464b +a5c5ae0ba435fb7f3ddd5ad962358da326239ff236fc3b51bd22e88296236b109951cee1b98f444302badc58d1b5bfbe +880be1006b0156f2788813432f450f613d235f41aba52a6000d2ad310408ad73d86b79f6081aef1e8c51010d404ba670 +937da751aae68f865c7a33fa38d718f20e2a1c65cb18c8e08f8441f0cdc77662789d2793794dd0a427cad30cd0b33f42 +9496fde66c834ff86f205897db12bbf9a9bb78d9ba8b5fb539cd0a2c927cc6b4120c017b0a652750b45edbe5f650e5dd +97a6f409ffeb593e149307a14bc47befb632412d70565c5f13d6b7d032acd2e3ed0f7b6af701b387f11d69ee4a8094d7 +97ed94934263dc0260f4f7513745ed3483cdddb9adb85dc33193c3a8b4d52affaf1ded23b59c34651afbffe80d40dc36 +b2b26378d44f916bcf999db218b9892e06de8075f205c7dafd6d37a252185c2d1b58e2e809c717963d25627e31f068e4 +b8f9fa1fb45fb19a45223f7be06c37d3a3501dd227c3e15999d1c34b605f888123026590697d0ae24d6c421df8112520 +997aa71e3b2e8c780f6855e94453c682bee1356b5ce804619ef14834475511105b1e4d01470fe4e2215dc72182d9909c +ac2cb2a7cf55aaf990cfada0218453853047e813d3f51f5a623d09f4714da79de6592671358a5edf938a67f905b6cb5b +8d8340d0c3081cd30d34f3ff6191e1ff6ad7994b4ebac19e5936f1157ca84e1813228b7605ee226366d6bab1e2bf62a2 +9693b17669086003cb46c75fed26ea83914a54901a145e18c799a777db1df9c9ca6b2ea3ee91e7b0ab848dc89cf77f19 +a6b6b2a6cd8c4922d78c8ba379373b375d66ac6ea04b830a23d5a496cf714a9439d81c865da92d52600aa4e2e43afcf1 +89cb665020abc3f5e11a03c7ba5ec9d890fa9ed2630f1443a8e45a28c32786ed980b5343ffffaea60eeff5b313bc0d66 +b37b989106594221bc6cf33a1a83c3e65ecdef279e90333a9e105b8139dc28384bb2277edd4b77c9e59d15e6afe074c5 +98ce5aee5918d18b2326b30c1ba41669cce20bc7a1d1b585363305fbdea66055164a7ac398ca0f0e670291a3061022eb +b57f472d5f34beb4cf430d7c0f8ac5bd1c0621a284633ed36e6f7804bc2b7847f54b469c7ea163a436510d9e3b32f97e +ae673a6579dbf0504c8fd0c8fc0252d2f7ae8da615a06f4d215c2f8a8f516201f24e5cc42967630c252905e5dbbd6377 +97c1501835a31091a5a83f0546e01c85ee847a0ca52fb3cc0653f6a826e13d25ddc623a5dea139108f7270a1fd7043ea +9376ee667f3834f6c0da4324fdcca5c04712e0649877ee19da79a2d23be24640c38758fce562470ce2134ca34148ffe3 +818af89c40379a10074cfaba6d5968ecf667f1a68a7edaa18e8977ccb34e0829f237c5634fbd079e7f22928b277f1096 +b8e0af0be0a252b28df25d4a509f31878bcddf702af0e5553393c3dfd4a1f1247ad8dc2668bc8dedc9b41f6ad8e71b15 +811667ffb60bc4316e44bd04573503f5b4dc44d1ec824393a699c950e5fa085b146537ddd6a08a3fede7700396a0df7d +ad834cbf850b2f61ce799c4a0f8ab0c57039d4e1113933c50b0c00175171aadee84894d1376cf325bfd434c3deb44315 +a8b7dfcdb40373ba4d55e751ccfb9070554434df9e359fc165284ee3dc35db6fb6055657ecf5a9e9b7b8e2e1abea4375 +b56a5b9fd41c9d3f65532aa58bf71a38fcf07782e1ae0084dc537862fa02e6d66658b19d6f71c39cd5dbfac418da1837 +a935af5ed224b9533b41a7e79f872f6851591da9e9d906050ccd1b2c772a1d6d010c5fc7160c4f8cd7d3aa14c3bcdc26 +a81e580fc98692567b28323fc746f70c3139d989fb6aabf3529504d42d0620f05327e3385c2bd5faea010d60dd5c8bdf +a8b352054cdcde8ddb24989329a249b71498a5593a13edad1e913c795dcad3d24789abca9c7ed1d57efcc9e3156da479 +b0de8a2bd7f93284b2bc700e442f52ada16a22ad8d86329591547411c23fff0333b2ab0c9edf82bf7903ebf69916eed1 +843e9781b653d1a427f3534b2e86add49d308ca247546f9fcf565f9e08df921e4d969e1b8ed83f3f849e98c0f63e39be +84a4098c5dca9f73e827d44025473096101affd7193c40a0307e3215e850e753e9a08e6e74a442d57626ff26df77faac +b463eaaa2f3315b511c22a97fad353014d840a6a95fe0d457d0677e63e571407d7f5268f8775381a5e7adc3b4163eb88 +ad0417edaa16cfddc288eef4173aa7057ca4f81e815541ac588ef5f24b98d56fed6845deb6ae1a9740a28bb1cd8780a7 +9271963b8fb2288a96e07eac13c0543ec41abdc6d978bd7c44ae08251ea49994412b542c77c8208cd71fd8e7852d4a70 +8b68b6db9044d8bafc155d69e0daba95cd59d6afebb085791e999afed4f33a2479c633d31d534ff767b8cd433d591a23 +a6a06a0e433e385437d9996ce823abda9848754aa9cdd25ec8701af35c9ec15df999825669bbc2e17cedb597a96e8eeb +94d414bff8b6b8597634b77a77d1060db8e1af0d0ddfb737a9bf1c66c8430e93a425510af2464bce4a7b29bc66cf325b +b6514049562af1c6fb7d0e8df6987b020f0b7a6e721f4862e36b1ba0e19af19414ede04b346be22d348b50875803d1bf +a42c7fb34f2fbee8aaccd1d86672d0acdf4e6bb083ff0456512d7e1e43be041cc0924322fcd986e6e1bce5d5ecce6f92 +867cbdd169a52440ae0a75d33a28c7d00aa92b4b65aaac5e62aa53a8fc367c08ab8828cc8fa18b6e7d1f908d158e3382 +a6fe0b768fff3e4a6153e59a7b7508eb2ee8165eaf5274d41ac2812bd4563c4ca2b132f0e27ea2f1c98759cc3589b61c +b3eb1dba43d10b9e17ffec8def053fc96f9883bacb49330a089a0ca5b9ab0182e8b5111ad4aa55c1ce1b6f4afa5c70a3 +a1531351098bdfcda566ff4d811301c0305626c77f954a38420c490e7c684f517eb1a4e4bd2c3904a10bac889cba314a +92278d106ad2f27eacdb86bdb1faa0a07a93765bb79dcff191873c52253af83480114b2299ffe5324f9c31d0abbdbbd1 +8900ba95a90c447fb6fa1f528af3d7a378aec25feb0620516b6b97e54b328fc31af42e46a8ad5e6e3029d83a6f2bbe5f +86053d481179c1ac910d5e7b9a5de82794b442f20e854583512ce1f9c3f09e71d1bf97d6700fe776debfe1527ab97a82 +a32a60de492fc4340336416bccbd2591b5e414fca0aead82281212e24490acc01747537b3da783684e27aeb987245cc8 +9820fe8e0338f21797143f368177e3669a1f3894b40ae9fa3b353125f7c8e85cc424dcf89878f2c7667f65db3b1e4165 +934d64711b4348ac5e1395cc6a3215e5643b540f591380d254165486b0ec2a1d0d21c7d2c6310f9e0eed3d08ecf4b57c +b9fd32d589432eddcb66dc30ad78981360915854cc44b2afeb826b5d48a08e377dc91be66f5bf1e783d1a8bb320f7ccb +98c972cf01efff4fc2e485b47572e2d8dde22461d127ef401b71a111b0603203971e3cde40912643affd7341cd27e57a +8db6c1620760063edabd376f4399b6e1355462e04f5c81cdcb3989fdc00f9a466bc85ed899e886c89c149adad69edbad +ad7b7fda0aa6e2aa66a27235ac5cc680aa04b85dce329fc4be84f75c9c961120a3d9e446aa44539aaac8ea203eecb4eb +8ccb01eaf41d816ce69ebd57754859e263530915e775c4e7d9dac37b2457a9099b9ae9b4c6cb09eb5ff246e3c9320c59 +b895b83b5f7ca46e02697dbaa6157df6c7571864c83e504a8c77d965bc2ba97bf9353a71c56a020df64498bd40e30b21 +8018c07a81c522fbc25f2cb14f2321c61b98bd8962ed8eb7d5823dbe5d1958a5ec2fb5622fd0868e991bcb6cae016ea1 +95b16364e94d01b3664812264d7185032722a4afc23bdd33bc16ae87ee61816c741657c37138d9312cebfb5fcfbb3b2d +94a709209990a8b09bfb4b9581ab471aae3a29526eae861108b28edb84aab6d28f1d7a25dddd8150b70af34bee4ca2e4 +ae06c80839c5a13269b984ff4d8a5938c6f4d8d647b1b1daa8cf7f6145340b76a286cd615ec251a65501e6290162da50 +875cbd0694eeb90d3567da9dc7f570d97b02bd9cf17bfa011efdd48f1d580608a3213bff4006603b8b4079fa66bded10 +b27f88c455f025e1cd902097d6a224d76bdf9c9195adee30bef4a0b0411fff980787285896e1943a62271d0aca531446 +8024880cde783cdb2b863e3dd856be92bacc5b2a1347e96e039fe34279ce528560d2df7d4d1624a4595dbafb40529697 +8883d02c2a5c0e026d941c785128d4ac6f7a9de625ea735b7d6ff27a5ba10fa4d6370d450d99a855d919f40d64f86afc +a1beb985c45fdc30ac536f1c385b40b6113ef6fabc2f76d255490fe529468847a776efa674ba8fed72180f07d3f701f1 +ab83bd9b007561695210e3276fde72e507456ba277ad4c348a2aec7a6e9ebdc2277cb4bd0bca73bd79bd2240a1fc4456 +8db27f516153812149854fd6bb1250e843a3ae1c9637df818b08bd016a769d0497ab6087fe3b2fd4080882713607bf46 +b3891dde4e00d60386aeff161b4a0fbc30bb31ee7918ce5fc0b49aac3238a000ced192c9c4c08d90de3a0ba973d7cfd6 +90a2049a15c02e59024a7a1cb0adea97501c60b1c7442fbbe560054c3d69264e69627ac57b7d9be01bef498bb2a60198 +87df67a4bd72444b5faa4f3b067204c4927c869dd3b29ad192d859589a9b2c1d6d35ed68310081e140add254a9463092 +8f80986a8dc8a0d6408ebbcb4f234e76413c11cb0d66067f9436bb232373100f20a4fded60f08dec3525315abfaa8523 +b061e10beb12ba3683688a4ae3a91600d14878ef78a308d01b93e4918efc666450e3f7b0e56283468e218934231df98c +86b9e55f3783d62e381659d3e06699d788b88aab1ff99848db328a83c97d223f602201bf2127c5ecf419752fed0a224d +858d878e29925c87243e010020007f96fa33264e89c8693af12857b362aee3fac2244057e159651c476ebe1dfbd67bcb +8fd47cdef87d7a569ffce806d2c2dad100692d6c53e5f5dfc6e274f897dccadcee30fc6c6e61373961bbc1f3ecbfa698 +892f2822daf3df3a759bef03168c1cb07408df62e024747a788e94d2da325f880bb9c6e136c7f6643f45b021c6ccb654 +8714e37ac24f5a198f219e7c88a92172fc3db129e044e914663ac708d8101851e7c53fce79d32d0e6da74f2ccd1d30ff +ae95e1dbba8b9e2c8dfbe1c202e9ccfd04fa396470035a699b902fbd86d5e6a31732a7c8cae00b9a4f6e51c8d560c7c3 +b0cd058e77498e860fa20c5f8d9bd09bb249add1badf84ba8d1bd49e704b9b4bcd67a5c3d211840a2c8fefab3fea639b +b78e468d3a7da0dd481f333ae56534e2ef97587be2e259a458e25aa37952aed1cc5f835640f812d8052f5bada8f57b12 +835de7965c6b26e7ad1b92eb6f0261d1f376fa12d61eb618d9b342b597c9c117a5a8f6a36269aeea88072b4641e6b5bf +b4d0eb99136b3643468c9c48a20fad62785a60fbdd3c054efac4bd1fa7979b4c9ca6c2c0b18069c0912bea2f19832790 +a00c47315dc0700a850966836a95f3cebfde04dd094bde0742dee77b89a05b5ad655921f86fafd1e902938ff34d4c58d +ab13fa0afaa92229a71ee91efae6d1b15f14b6eacefffb7401d41d0d6db24e24a8dbe8ee19b4680ecb69d2a0cb4e84e7 +aa56c0fb18401210062dbc653df8e3732aa8921a1280e9737e99b26a0100a13a9cba8ad0317a69bba16193362ee0f030 +8b410324a6406b345df0fa25f541ac20b7313fa55832752f70cf4c79f43b0bd3d5b4cdc447e6ba7bca08d0edffa8e29c +893362241ae412d9e5df46506407595c58ffbd7fb1fdaf0694c3432470599291238997abe118bf7737e56a4f5c9dc292 +921618194a756be81cb49d6357cb392b32cc62d96c8ffb7e16d9659a0f226a0436bd378da7b835054dbe0de2c6372ef2 +94a2904f10994928ff5367b777e1430047736fbece33442cf452018bfdeae62e84cd75cf80f8468285e347d504c94111 +b4b81545b767f380bfe10e0fea9c3cc62ca8db40b43c83ffb245259378731298e3eb6c3bdc3a16932f88f5d8a86edc4d +936203c2453ff01c6fc635e4d54320d69e60047d805daae3b75633c2259108497b778f011e5a057249f11b2b888ea76c +b90bf6378d29339443c3f2008b1e2b5f0345f86e393027f14a295e583bf6e6c2b10f54b6dcc42079ff0d356c405b03bb +916913f550d327de2d8d6c7723dcef2e3869efaf95fd963d95c8980b97748c61ad8e2e629cead8577266d93fe39203bd +a033c6f3d5ecbabeb83eb363e54e5faa7ed2d7f4fb771b161762c4f003eac4e1afb236806b784baf2222cad54e2d3cd9 +ab289d4a5771147e6c29ff9ac2bf65d70081ea6c6af2d9b728c3c144574a31b5fd8632af57c18c389aa2cd994938bb0b +9488da2019ff13e290eeac132b491df58b5b7b23c2898ff1a67bffd7e9c9464c39bc8177a57950fd28589e3d9ff9c6c4 +a5abe42b2e0891851440fb2aa6c1d8a86b571bce8b80c8e9e2692e5cb6d45a1b2f055c9fc4c74a7cd292871604129ea9 +90bfef698e83c2ba4dc9304aa01edd274169a978b7154bca518daef394f55857d0d1922ebef3d91fc5ecb3b895d9e0ec +92328f1372b6406ec80786041b6d57018b8507e3881a08727aadfecfdfcfb0824394cbb1150117ac5da5d71b89e895ae +9719751c5f7a65ae2bed8aff7b4b8c34539ff011b259b7ff54f63f9d987b3fbdce5c99534ed561aadaf07bb6e939e208 +a151816774aa9379fccec21cf212429a1c68cf91b055cbb9d931f461a8d5616c693331a11ac5c6fcfbd17d84ee0b44e4 +a72977b1285618a45943ad00f33f37102e2885eccd2f76785254eeca495068fb1d8d49865343e9e8313c6c2c3b2024da +a6f5ad2e023a1585d90625c9f7094f0e8851c79f0eede8ec582ee8e063407cc5b8298e5fdc4c786e4fbbcecaf33e787e +82901e008febcea0c0a14ae21d985a397630e18ee6e346f4a449f23be228e8f338df567d30211a11180b94fbc5204bec +b9b57fdb8d14d1be87a25f89553b3966eb7869e0519ffdf4cc4d51f4cec90d68f7b81cdc0450e04207276e9c63ace721 +a06eabcf43585a001448f3dc30411f3d5b74fd0a695c81eda9981842ba2bb0081d3f5a8360aa18b6d43ef13ea78b293d +926fe48a7e8f07559b7237beff9504476dd97b5b4d67acd01a3633358a6ba4c7abed5c87683a11209aa2ee759888e00e +a716cd3a84a963e2a5a46145b6ef4ebce705de52bf2945c374152a1e41c228a9c4eae0b6d1e222c1eea8b9c13c002177 +8a9b5985df6fb32cdb06ba1591a977545444478f2fe985ed1b10de61c630f0a4693c2185d63f0dc0256b208072c43b17 +a8eab26ae0ebcdf96a59fad1dc2d5e83b94abb2ea1774b607023f9d9e0fe065853b1e2242e794f989a80a47f550c0bd9 +84adbf38164cd04f3d770a7f4b8eae7a5d25b4a803fb63c02b95b71b33e454319c44e07a760d22bf5f58e7e372d09a16 +90f443a3ba1b9129a0bee400b5b29d42e50bb2aa56b0022bbfc3c6f8d69db40299871ec7c1b68421cc89e1af6b13a39a +81c5a94b379eb98c494a8d0067c748ba47e87a2ada0105202ed7651eb4e5111a0cd8569b06ae68d392c4fd74a37833d2 +8f92324b14a1549ee0b186073a26691088e41556d33b54258fc6e0b000e9624156db4e97861a0ec22960e6c47ca8a1dd +8b021cd0fffe055068cc460aec3cc455952e2ac32be5fa060e0d1b6cf30ed15381618f801249e893b1b9f10dd82077b0 +b3e9f0dcb3d6f0b138f589fa54dfb01f849890ab97016372d004aac55103f363a64bc0e606ddf75430f1534a30fc522d +8fdfe64af891db89b25daa859864d479cb7599486bd6f36e593f8f2f839f942261ffc3eed5001a93fde44cbcdc24c583 +a9e4554373c5073e135874e2bacbee69c65308eb0785532fec6a37834e8d0b437b77a2f11cc63c87d7183b82cd9b6bc9 +b4c47daca723ad7193ac5098cad4dcab654186ec5ea5c0fd014a3ac39726be954565a901694ba211820c011fa1c59e18 +8835427e86cdceb4c11cbea331ed724e4e78af15e3bab5be54f6b926bf66b5d99bcc40dbc456d86342c9fa83a033c2d5 +8ea84590a400cedba047c2661378921a42f5ca0421da58c1bcb37bc686a2aed98afab3fa5e6ba3a51029390ef3cdf4d4 +b48551170fc479d69fffb00fae4fba301e92e37cae08f596db6f6489c3b7020edc074f9e8d7465b84e9dcef1b6b3aecc +a6f318b1eaab00836a330710e88bfe400395b3081485f6a212e3cba9463f6fe7864ba4f71e57a411ecdf2bcb4d189f96 +848d5137a39999141a79f4bdf91150796ba36352d8525821bf3bd6e070b352792d79147341b8254dd60fa8c36e9e2618 +a8526f8904b1eac4ae2a25534aa91e8031e9aac7b8f58d8f49897e920c36c0232f4a30aa6eed305deb0f7793c115b267 +b8b6a727c44c37a8388383e959d195d1d0e51a657d4ba360633d219d43c5df645383e2406c25f1d418e72b862c3a6e9b +92e64adf65b42c978f36dd03ab22ba983bfbb61944efccdb45b337ceb486beda99818bf20d32a545503c4572bb0a4983 +9653bb83df66260a0bd059cd4244ef7c661b089e403d26ba777d2090783ff31f963f5d3a9c125b1ad1a1d19134f3fc8d +a74e72355e71ae5eb36dc75191643500ca3e67f18833ee981010e7e7e60a68e1b01b05901eff05014b9ef29aa4829f45 +8b2139a5da14524cf6acc593144db23db424b95b8c7041d8f6c7a14a6725dda1cd09c42bb3ae26a5a3650affaa742800 +a60ddff4300ca44a7c7a00a1f98441ad1438e07c30275bc46551cee1b681926d2c825cc8f90399ee5f36bb9fbd07d3dd +a04e5e9958867a5acc15fdea0d88951cfebd37c657102f6ba1dcdaa5e46cf1c823ad0d98718e88e436f260b770599102 +95e977abeb70d46fe8d7584204770f14c856a77680607304ce58077550152733758e7a8b98b11b378540542b1175fecd +8c9ec93ed35a25ce00d61609e92d567459a45e39922ccd1c64ab512e292787125bd4164c00af4cf89fd3cf9deddcd8bb +819819ad0338250d9c89aceda9e217df12ac54e940c77fb8420575caa3fa78930689d0377ba88f16d38179a807135dc6 +8baafb379d4150ac382b14a64788d819146480d7a1dccd3deef6889686ded375900f5df069843ef14d754ad3d7540401 +ab827236996bb79b447714c6993af941c5ae66248df4d9a6f3650d44b853badb5c0cb67804210e07a7b9d66ca43092f6 +927656c3eac8d2eb575e3daeb77f9605771170c325bee6aeade10c083d42bd8dcbf3bcc3d929ea437001c7cf9a95e2da +af22b212d5ee44fd4197966b9690487c38a119cd6536cfb8c181f38a94610dd9e057f95774047a446504dd96dd11e326 +a44bd94b9e01e3ba36340f2ac2201ecb477495d4f1fb6726a6b439302deabb5a35d237c6a6aeb7e3b0a65649f8656716 +af367aeeae3bba14fbdb05bcc1a521000dd9d37f5c34ae56fb306d3dfda201d0329a8b6e89d98e15825cb3c6bfdb1194 +abcc4fbdea43e50ded9e2fb01464f4e87fb136e960141e8d39214f92794cfab5634f22cd40b18d8c0e501f2307aad23e +920786cbd674348b9853689915dfcab02cce2a4596d117962bce36aadddf4bdd143891e22f2c8015517039a64e8aede3 +8cde63b9bd57cb3ef743f1f3e8250669eed739e5fbd68c500a3cc0c12f93862a69aebcdbc69dd8f476c2eb307f572a53 +b967e65a5f1cd8d5d570f5e87e7e186fba51b9504f8e466392a76d8a971fb91fd9b7565bcc1647f50d7d15e48b93bc95 +8d5a87b25fedf5edd57d870304bfd9081dc78c3e3e3b38b997260a92edac7feccdaf24feb51822d2edc223b70bb4ed5f +b6cd5d340a57f8ec73723c4f3ecd6601620dc8137a3e75a5d3c578bc79a9cae86b379950c644dee2ff99dad780d025c1 +b6f0a8e754b7f52a85a2a2e6512cfd017f7fb0418d19bb318308951c4e242d3c65bbcb9748da9cbc91a738f9ca577332 +a89dcf7d410bccec385400dd96b1cc6af89026a431d0f531aa992cbd7bc8bfd7c5f360bcb665bda1d72efa17bb982551 +97788e7522427a46c4b6258d15623ef7a565712812fa80d001e1de8dc1791392702f3fa3cce5a8cd1c5755625a0ad10a +b5338fb5e137ff625b27c5148298f27ce8f493e2527c5d0facaa49f29cae34580d0d6c3c1074a2e46cd8db3f56004ea9 +8962f006d7b1095dd0dd132ffe7e87e328510c95ad893cf3b2ab21c177c5cf2c27f47d8856f87e9762c547be009d25c0 +87fee9ce9c26aa476e67e0791a809e0a06a8a98facf3faea730d438d3e516cdf75d645fa75c906e4e44ab9237a22c016 +b75ab972e1a1214bab0b38cc3e973d44bb233acda5b4291f5e110b6fb78fdcab93dc63f01168debd898e165f615be1f7 +b5a0fb52bca279d3853761a94b206acaf313df33ae6303d9b71edae90b66fc507adbc60fb11e758888736c81d5d80c0a +849b8f0005010e684701cd3a4e59e8c89e5fec59af6d2de5b6332cde03b865ea84f07f0b80ec3404380b0e148fbd2c24 +96e2b0b6fe78408f9208f809f5c40398100b2dac202c8c5c33c2189560dea868270a598c419871a5a2b67783354f6014 +b234b81f996142d0df2c719760bf996544820a03195a6dc0ff6a72543692f5a369bf63d1f0b477ef2fe7b3234e41f685 +b85e39bcf40da1a12a535740176f4de749a93824079deb5fdaa004f3282fdefaf5275e3418c88c419bd42a3dd2ed2b3b +a27279304b89a18a4e2b443246f2368fb8b15f46a34533179b6bd2ef683f6e98e222b7a32880b39b8fac1afa90133803 +8923c22cf15c9c1964213d725b337ece9ea854775a06f75f232c4859c7142a3942f418354e33066298aedfba3cb27e62 +b109f714311fb9bc431ef57911e2cad6a3949455b9f23255cd7edea35be629e07f845fe53e2b12a32305ee2f4f264f27 +b51e82ae5c7d48050e405897d0053e9ea4b2714d002e88f78c9a307cd50b9c6b3ee7cb86f86527be9d964b01895fab20 +90db256931c7f98bcf3bffff4d496739185e7a20f329ee7bffd4e0850a37739948ec745285703967f4ca50ec370cf68b +a0485ac0445d88dafac56bfba2563b020cfc370f54c1606c89d12cfd8a4d1336d2ba50306e476155a6f5b0e0a1f2d092 +a00754c3462e74bda928da855bbf90f9077db395e32f03cce9b2955546d900b72330d247b7d607b65e130f5b0d883de0 +8547d56727c3ad8b5c8ce622ed9ad86fe8cd78e6e4848c9845914b5063b17330bd10b46d8d3f18f83ca09ecb28d1afb2 +95b937b2a979bce0e159ac75c7d5d659be8599c92305e73e942aab414793364a3ec28c7c1c8491a5750ba84a29828d8d +b011e150f0294e45a0f4c69409999d0c2e602449dbd67ab95e8258466687cd733a0329083a31b03722f4e2580ddc95e9 +924651a733ad5e5d9adadad3ea6a6babb8e455c8d5f2cb5bdc83fa422e7752592190ccedaa827b866861e73506a6968e +a4d5180122f8e31503ae027e54da50f72f5cfb910a6f7309bd882b5cd666f454672591f1f20e461e182a47d03b47052a +ab19ae659c4f73ea3d21895269dbec583c7029955a36469124ebe295027010faab56c4a475973497f28e9a77c03b8fd0 +ae7ea1a803d0f439e91494f8f35fc1167dae23834c0c699ffe65d3da8b09f8df5a53195a99ca7b8558242279e69578fa +b9d63cf0e30f9800101b43b980bcd2f229758e74b21ad5354866b4e684791c08a184330dc316228a0d67fe0210f2bc4d +8c41629744391ddb96dcbbf9cd99b13d36e57d65962e0aeb92ebccf1c4cc769626feb3ec0363def08eceb102b3dd4ad6 +b2848ff24faf9e667a8c19d050a93896e9e75b86595f7b762c7c74ccdfb9db126ae094961fee7f5d1192776c1ac1a524 +af013bc29206743ce934d5887b8d0fb3667c89bda465d2321835a3618513fba6a459dd7566268220ffce7e0c97e22b2c +8bb799e36db1132da8e8b028ea8487dd3266b4628c56dfae4ea275f3c47c78e3d7445ab8d0aaee4cbf42148b3a148175 +ae2b81fd47c038b5195a52ab8431f0d3cab4cf24c4237252d955aad2156adc16dda9d3270157e0bfe5a44022e5c051ef +8e0129213b1698d2ec6df132356805a8633ba79e672e586dfef664ffccca71834253ba14f296da962651fcba2c002622 +a1ae30b500ae77cd9bbb803d737b4a5991cc780618ac22b5cc179efd8fe10afb8c135457f2e7b86ded485ea12eae70e5 +8a39723077b7c0df6e3bf6548afa3910c214ee275951fbe5155a39473be98099626ea14d844630a6fa90292b9594665d +a628386c79b61aa7314b01d9814aeec20c2a66e3deda322a39957e7135c2e52b1da486d1b9cd61c87afb22c1d10f6462 +97867f469b01249820aadd9a54e12d4fdadd4555f2d530450e1f8f6d2dae57360578e2c2c8ba41e3b5950df596537a98 +97f192d0457c217affa5a24267dd16cb4c01de8fefde9df4884e1906d2f22e73382dcee6c7d910bf6430bb03f4a4f1e1 +86d5b5739de8442dc74d0d8dc78e49210fe11bf8c6ff0f0faecbc47b64812d6b28c8afddf6d9c0212f1988451d6ccb1c +8ff3312ce9693cd4a9f4b8e75bd805f65b0790ee43fd9e075fe4cebc87185bdf161335049819f22530f54fed2779a5b9 +8dc41d85548bee5d51941d55752a500bde3c5a8f3b362da4eec307a963968e26605048a111c9166d448b8dddf6f53892 +996bdfd004b534151e309ac925fa5ee7801c9da4f6b4c43e156d1158b134535a2a3956e1255e0dd72ac2af6bddaebcaf +aead652704b788bf4983c8f725c644c327a6e9f6683215f5c826c09f82fd2e40631791f51d14e6aded91fdc018d45501 +991ffab58a82b98ed8fc7b00c3faca153589fe09cebf6a137ad506387a1ca4dba475b0e4a1b9bdad829f1422facaec39 +9652e6c4ae084221d6bad855ec0bc11b5f855c6efba67f644e0902ab790a98861cecc6ce047c68273c3aa7eeb2f4c7d9 +b88b816507aaeea6dc92b861eabdc96988b74d7883f20a4b30ba249158acaff3c50d261742fc9ad2e9eba888a8d59065 +acd028a51e16c07a10d2073b9d03070457ac5f1246365295a1359d015c460b92b4861125fabe6f114de8197045df408d +806d3cd9d02d41c49179fe7dac5b05dcfc9a205a283135d4f008d0771c58e6f963d7ad0f6798606edda718eb5c7ff3ed +b9b71f1657a6b206fc40159a941e127f252a7b324dea864ecd804f48c0ed86da9778a925fb65491204a92bc2a26fef32 +80ed67bd0e74350c875abedc0e07fd42ce7cb926f0f3fb1949c6ac73f2300b5a14a5c6f6ff8aed99d5ea5029bb8e7ae6 +9875f67a7a473714e4dd75ee0c763ddf88101532d9680724b3848fef69e218b04a96b90f88e0f4409aa40b9a21507ecc +b4a2bb1b421e5243e5e7576a0672dc19f9f70315a03f6411c19f76616ffbb70fc5dc0e57fd4ab85e24ea2261b7ce38ab +879723002ce43e6c75ba2246f51436efe3376242beff987d025c3c4476495af32d52a54fad5d9ec329a442b93bcff1ce +a4121efbefd9c3eb143619afa52a916f199c75024908047763b29466cdfc837c2fcc894aca63044c33c41c777e529b5b +895f637b497a9766714a3d9e3c275a1f0c9ddab105bf4c8b7e663f36cd79492022415bb4938c1a4849bda73106ace77c +b119acb8b161ce4384a924645a248a656a831af526cd337d97e08405415b9dd22060849c76b88a4785eb5e7214961759 +802e712f4c0a17009c4be6c1e5ba2ca3b82adcb68793ec81f4489b7985babd8a3873d544de63d5e5de0cb4dc5048c030 +ab111051e4651b910c68ecfdc33f2d99e7bf4182df68cedbdbbcac219a543e04d93ecb2763fe32b40c095c7ca193c331 +855c73ef6afc6bcaab4c1e6388519fd5cbb682f91995bebd558167715db454f38012291beccea8186a3fb7045c685b67 +a29d02ec6d9baf84c19dfd0eb378307703bfafc0744b73335550f3cd1b647275e70215f02d1f4ab82a5df4d4e12dd938 +91510a45b8a50cac982d2db8faf8318352418c3f1c59bc6bc95eab0089d5d3a3a215533c415380e50b7928b9d388ff89 +8286e7a2751ca4e23ea7a15851ad96d2cadf5b47f39f43165dde40d38ddb33f63a07bc00600c22e41d68a66fd8a0fa51 +a413d4e619b63799dd0f42ac57e99628d338b676d52aec2bb0d1bb39155ad9344b50cdfe1fe643ff041f1bc9e2cec833 +85524e5bb43ae58784d7e0966a664717289e541c8fcaff651541718d79a718f040a70aa8daf735f6635dabfc85c00663 +97f0d48a4028ff4266faf1c6997b6ad27404daa50ca4420c00b90f0b3e2d82ef8134d0a04108a74955e61e8dfeac082c +8df6145c6cc39034c2f7331d488b8a411931c8faa25d99c5432831292637fd983d4f6b1a6f55522b4a42a462d63c6845 +98c2060f67a916991b391e67fcf23e5f305112807fe95bdddb8ce6c4084126557e4c5f003afb32e30bc6808b30d4b526 +8964246b3c2b8f7312f0a99647c38ef41daf70d2b99b112412356e680185da6810ab8ee0855ad7409d334173bcc4438f +b56c2c416a7069c14bdb3f2e208c5a6ad5aac1cbe5b1faf99dc89c7141d0259d1c6250be9d9195500c4a41182ad2ec3d +b7864583a4cae3b1083dcdcff7f123d24a69920a57d6594d0b7219e31bf0e236682442b6499a1f6795cfeb4f5f236695 +a064f94139bf1b70d476bde97099631b1284aa6b4d87f16bfc65c075e58b2f1b3c2d057605259f806e545674a1169881 +80d1bc4acf14c0f487cd57c5d6157b7f38917e93cb660f1c25e474fcdcac3c3dfda50f6bcccfd6676bae25c4b6b5014e +8ad9a4976c4e3e282843518149fcf5d454240740f4b91466f6310b7216d23d70b9b47c42870293252f29f092f330967a +914197593d2d99d784c704cad7ecd3f0b9f55dce03fc928d13e1a1034566c4de754f1c2a5ade047b0956415fe40399ec +8d77f5e29c572ec3c0ca39cbae2072ba4102403265b3d8c347a00386da9c0b8688d6e3280c96037c300d57b3545f3773 +abfdf79d935fd4f06a04938d6580a8cbf9735f0d498f49677f26e73d3b34b7075d525afcb4f14ef1632cb375bef7dd55 +a97a8c446e3edc86efac7bda5e2e5d0158c909552a3bf86151df20ece63b8d18b608f477286fb1c7f05605ab7e6a7c2c +8618d946c7fd62486551c35486fa466bdfcdc63c941e4cff5a01fbbe566b7ea9dc763cbe73e2acae063060b619a212a9 +8d03ee468070936004b06acf64b868963f721f37faa09887f8a82c155ad5c5732572a6855b531db58af03b1afe034a18 +8d3247f75966ea63935ef6049f7c889c1651374adb446f49499fc9191dbcde7ea33cbc1f1e2d3d1756b6e69870404643 +afc853c3a3facb4ba0267512b8242327cd88007cef3bf549184ee891b5ddc8c27267bae7700758ad5bc32753ebf55dae +80df863eaea289de5a2101f2288046fdbfaa64f2cf1d6419a0e0eb8c93e3880d3a3fdf4940f7524ea1514eef77fb514e +8434b5888c2b51d12d57da6fb7392fff29393c2e3bfee8e3f9d395e23ddc016f10ebe3e3182d9584fddbd93a6effcefc +b78cbb4c9e80e3808c8f006dc3148a59a9cace55bcbb20dd27597557f931e5df7eb3efd18d880fe63466636701a8925e +acb140e44098414ae513b6ef38480e4f6180c6d5f9d1ca40ae7fbadb8b046829f79c97fe2cc663cbccd5ccf3994180c6 +936cb8dc959e1fc574f6bb31f28b756499532ebb79b2c97ff58b720d1cd50dc24b1c17d3beb853ba76cb8334106ce807 +adda2116d9fab2c214ec10c0b75f7f1d75e0dd01e9c3e295a0a126af0ea2c66373d977f0aefdda2e569c0a25f4921d0e +89a5cefb80c92dcad7653b1545f11701d6312aef392986835d048f39d5bc062cabc8a9501c5439c2b922efc5f04954d0 +b9acb52747ce7f759b9cdc781f54938968c7eeacb27c1a080474e59394a55ae1d5734caf22d80289d3392aab76441e89 +8564f72ce60f15a4225f1a223d757ebd19300e341fd9c1fe5a8ece8776c69c601938fa2d5c21b0935bd2bb593293272b +a5567d7b277c4ebf80e09c7e200c20d6cb27acbaa118c66ef71cbccb33ee3ddce0e0f57b77277ae1db9c66ed6e2d8f30 +b82e9c2d8df1cdd3b2417bf316d53e9f3cb58473c4cb5383f521ef53e0af961ef916e4f6557a6d8b4655ec01415231cd +aa816dfd2814c8a25bd2cbaf66303ee49784df471bac4b3188074ea30816f00f425234454d40d8ad8035aa925d74da36 +9919f384df20faaa2d226b521cab207dd2b62420d25ebbda28c9b2ca76a2a52203b2ad7844c1a25f5c75f005c5a83149 +b24a6aa35c2d0f87e36598b36224c64427cd69642b6f9c1bd478a62c70f8ee69f85028648f6603b4f04fb21355f2afb1 +892e044bdb1276b455eac2204be105e1821f987c2570494b1f32aa09506caba7ed343cd09b1bc126fed5e0fda3d0eaad +af0e01a3ad954dc048de18bc46bb1c4971db2467e839698e4dd05cd1adcb9261013fe9fd0cafb946c0b586f6aad86d4e +ac152f0a9ace425378daf02510eb7923ff1ed2c0f8d1deb918e4efb63655de1ba58c96438e9aa23abdf2431dc771370d +ad8c7419c097709347e2394195924e09617b47ac5c7a84aeb9deab8975f22155de0f70cf20d8a976551b14e3a2683a2b +808f14f67ae801536fb70a5898ab86e50ad35340cffd0648daed2f2c4564c9ad538034b2a179a6a8bfa27e9d93b4cbe0 +80a74ab7ce4769db93cfa695a166db95f0a9c47885ff826ad5d93310f36d6b18b5351c67c858b9837b925e85a1995b63 +95b88c3cdd64401c345828f4e4754b1a88b4875a14c08a668b90acd499b3b858842669ecd73a46c5d9f1de32ec1a0120 +8ddbd770b7b18a5917eb43926fa05004e819f1d1ead05b915269e4a86b53e0633a90559007e59f6705a3769e2126ac56 +ab6db5fc220754f19948bef98844e6e38dd623565d1695e1198040c228ac4fd863c1f168cac1d036bbfb718d9d8dd036 +97bef628e977c069e60c395a17740e0e1bc1828f5607ae7f30ce5a0c95f02b53af2ad062700a75212e462aa22c3c5465 +b68d465e04fd17ca98501e61eccb0ce30401855e98046e0c1debba71c2153d6a7a704aa36a6f12454696e78e87181cdc +a79cfdd048f4181e005bd0fbac0a8424495474956b58ce858d2b700fb0f931c406282bd33bfa25c8991bc528d12a69c1 +843f55fa0a6a0969daf2b48080738f30b269b2e7ec123a799e5b203c0b3b4b956dc95d095bc6550b0013918cdff8a225 +b683cdf2823036827e5b454bfe04af9bec1850d25a7a7a44aee7696b6ff0468b7ed6885a41dde2b8f3ecc4aec880c3d2 +8b500796e82acdc89778e0c0f230f744fb05f762000fee877bcf57e8fb703d212dbc2374887bdc2e7b7a273d83a85798 +ac35a8ee87bafecb1a87f15abc7ccf4109aab4ac91d357821e417f9b1474d196c38cc41cd13667f68d1ffab5e79a6e92 +b6e517739390cfed5b395d33b14bce7cd7aaece57fe79a7eb3cbf150dc10765c3ea9fef7976a21a2243687e6eea38ef6 +b53901eeee26692273365b789f2a60afc9b5f0df229c6d21b07016cf4c0e7985beec748aeca52262f68084393ab038e1 +ac4804f33d8ba2b4854ca3537bd8bf2dda72d4e94ff7ecaaf9bd3b7f098343d74d765471ef80072ae34f860b052cbfb1 +8c6a30a93f1dde18039bbdd1ef294552bf79856e20bce863e4b8dd72d906be3ff22468ff3610e06b5a7d1745dde7ead9 +88f0607fa3b7cefe20a02115572b16fc3222be86bb19e592c86c48afbe7e0dd523492b0c29a3bceb9a20f5538bc3134c +a660b801bbddad725975ddf9a8f606f76ecef831f954be224d6178c368e1c72d346f00c4a4c95c289b62d36f2af323cf +a75b9a6aea9542b698938dcd6cc2f6fe0c43e29f64b2f54aeb05d35fac73d41aa7fd750af4fa9333644aab8db90775b9 +83e1b7129d963d1cd076c3baa5fe422148e939273db173e4d59d1858a7d841eacac7fe817d15ab8f8a493bf46c2045e6 +9060a2e9c24de11f9c70e039b5ffe9e6d32f1ae39f3dda263610df2265d917679e689898e4a8bd84ad34613dca5e3761 +b42fc8b863a2af15e04d1fe6693c09b46007c0b8298973fb4762b45b4590ad7fe0aa758918b2fe5ed1ed0359754fd955 +83e6de7860fb256ecf7b47506a5e557d0fb0aefe57fb513c7dee2bd9604712d08ca26adca7ba9a54b712372a7c585a26 +90586e9cbbf71475ecd3e7b5753b286804dcce61e165502a82b960099e79272de8b7494b8877b54ae838eb5d0f71af2f +b2e4b0d21208f73b7b75e08df80cde20c4578e117d37092a490af82354e2afd3a7dbab46fa2d12fcb731cdaece69c2ba +a010961239bb8809fc7fb4aa08fa30d33a130f9f417ee9ea60f587dcc5ef4e1b7abcdcbf8e848ecdcb7972ef6af46e78 +8f511fd58d1e3403a5eefdc0a4ba6b8af848c7efddbf9575ee84449facde05ae9a24aa41a5725416467f6fbd11369c52 +b24ebbd2d4482eb618cea1ac4fbfd9ed8c46c0988a27259300a7ce5ce1bb256aeca0357828cbbc4cf0dfafbf586040e1 +b3ea29e9cca55250e9b7b9bd854edae40f0f0cc65fe478cd468795d1288cc20d7b34ced33bd1356f1f54a4291faa877d +8a8b20f222d9e65bbde33638033972e7d44c6a310b92a9d9c5273b324c4ad1a94f2a10cbce8300c34dbd9beb618c877d +b2436a9a647dc3f12c550e4ddc5b010e6f9cb3f3504742d377384b625fc38f5b71710a49fb73ffaf95b9856047c98201 +a13f8b77c70621e421be94c7412454adc1937b9e09845c2853ef72cdbe500e5c1bf08e3c8b8d6b8eff4bce5b8dec9213 +b25de8780c80d779e6c2e3c4e839a5a107d55b9cccc3ad7c575f9fe37ef44b35db4c1b58f6114a5f2f9ca11e1eb9c5fa +96ba6ad4358c7a645e5edb07d23836cbd35c47d9a66937d09486570e68da3c8f72a578bd2e14188d3acc17e563a652d7 +a7f55989814051fda73f83b5f1a3d5385cd31dc34baf94b37c208b3eaca008ff696fd7f41e2ecffc2dd586de905bf613 +882d0c7c81e58eb9560349f35c35e4498dcde7af7be8d7974b79d262304c26ab67ffa5ed287bb193d5f0ab46b4096015 +a607158f0c1fd0377a8ee5e9715ac230abf97406c19b233d22f5911ebe716967cc10425546dc44e40c38bd6c2b4bca2e +87e8cde50e5d852d3f073a43d652f7186bac7354612517cfaecd4a1b942f06fef6f14546279c0dc0262e2997b835b2a4 +a1c93acc6db9d5ee426fb4a0b846bb7a7b8d5915bec777a9fe6907246b0beafb8938941c8c79ed6082155f75dbc1e332 +b1e4f61457b86f76cd93eafd7536f72baf239ce5a62bd5a8085a34e90576b1e118e25002d2de49b01d6e9a245ee7d3a2 +a0435fe9a4bd1031ec5973a103ec9396b2ce9fd982f6d9ed780fa80ac06a6e47a0a6eb2daf52df1dc9292db622ee9fa3 +b66d8e8a1717e4bfa42083b6ef4490e090a73168b2912f2111743e089027be0a4945a229ecf5d0b5eec11b23f0e11303 +8eb764f26904eea4f4169be6e75beaa6a39e4eb524625a15a78befe3d8e3cc82692d9b135590c20ed460d6e4ba630ef7 +b7e4aea6bb09829e53fe83e53f49a7a331a6d7bf76e0073d758577e6d6fbe63dab642b23657355cad48896ad8715119c +8f94207982373a99ffa282673f192aa98d0c4461fb77c31dc4549628bd9687a249f1b3c66b1840929341e42516c5c64a +a9c673cb247b13e17fa5e616f0399b7f5c7ad043e143e44ae68855a840870ab3d2aad737ebcf74c2cc9688d17ef3a794 +b02635104dd28c02068985256975c0af783899eb996e37d021d9a35238deeea9e836760db21869be7b6c82aa687ded29 +b33bc0966389710812b5f6698afa3e9c84839a1b85492ba11e6ded26695260abf66be6fb355d12d3a8524966f0f89e0f +a79c0dd09506951c33da3cbc23843fd02d641fc24c640a205e6e8150240372847312b9381fb03c5d301fe4dbee8d0da2 +b74de6f3a2c502b5b658ebe8a9b7edd78afd036f5a2736aa06502863b6865d131b9e3542e72a86fa2e1d2db4927661ed +99e365def1452ff9fb4b9eccd36ff4154d128469ba5bd73e83ae457ab53977cf6fc04a5d05bdcde357ab539e34bd9fe0 +b4f2bfb95abb47c67870aa6ca38ac8f3ae1b1a2bed064b1be7ff90865ea12e4930fcf66429c7ecd1183fae4a01539386 +ae4bde87f36b912e92398bf72e11d5389e93b2de1b277d7ed4b6fb5a9ab9f71a959ec3bcb734c11079440fe42b86fafd +b826459e568efdeeb66688482b67ef5020787275123fd3192f979b6175e3b0ed59e17cb734a0a052bf13f0afc7bd237c +a99dd735f4a7c85cb23dcc7f4835f9ab32026886909aaa95876b98029c37dc4d621726c872d3a9e50403443c958f4029 +99083545034768010988bf8a9f34486c2cd9da27a1d10db3ab86eb69a1dd9c8ee723e7da4ef2aced63c1dbd53ccc52cb +8ac3209349f0142546c714ef7e9d1b094aab5469b8f080c0a37cb0362da5349e108760f272fbba770aa468e48d9a34c4 +af5f48ed74b21e3f2c1430192adb4b804dc873cd7e8f07130c556c30e7b78df0ef5a14b205368848fa9185e5a68dee0d +b8b741b65d68df89443523ba74203226f1e0d13bab073d183662d124e83e76cd318b2bfff09879c04d81b577ac895638 +914abe4282d11176d4f2f08c6f15e6c2d0cde1ab4de00bbe888015c205f51929d97296a0a8d3ca5641f085a29ea89505 +83ec306b2a9a6780efafe799df90b1aebdbff7d47921a136ea8a5648b9708a97231245a1082fea38e47ecafbbe000528 +95d6b58d70b388dfcee4eda0c9805362ccfb60a87603add565b175b2c14ed92999dfdb0d3724ee3e5d30535f282641e9 +97eeb4de607c8306e1d4e494f0d5db126d53fd04983ab5674ec5996b971899e734fa4011f2c889da21154ea1e76dbd2f +84ff21977fbd873ea06bec444d4ec9ff0e3902edc29dfa25f3bed269b3709e3116e99dc06cc3e77f53c53b736bf8fc29 +8ecf483874a040a4a1c293af145094fedf203a5eb37c3e165857e108cce3e1210e0bfc0f26f4ae5e2194024929ba034d +97d9b92b2ef34609d69402167f81bce225ed3a95718a3b403f702b93e96a121a8f7f072d0ff47e8b25164e204d1576bf +ab87c39cca1803b4e84b32e40ff30289e3cbbcfbe16a70f9e025643824752359be1f10c3e5398df402b6fec64d5a3537 +af84ca57e6944332884b5c84750afe0d5950015e127acec161853d55d48fd864c7da8d59cc5aba4ceceac650b813fcc0 +b1d23d98edbe7089ce0a8432e0eb3b427c350fb4bb39eb2aca3c2bef68c432078cb9b4b2c4966255e00e734fa616638b +8e2b5252e0ea96d40835ebfb5693af49946509975682d68651396d6bb1463f09e75fd0afa04ccea49893b5b9c3e77e40 +8db25e762f1d4a89a9a1cbc61c01698e775906bc88a921b2905735457a35df9ab84bae12e1b1b8dafadd50212f1acda1 +b5f7cd163a801770a4034e2b837e00191b0ac63a2b91032ae9a99ec182d748798df48a14644935fabdbac9a43a26749a +998e7232e5906843d6272d4e04f3f00ca41a57e6dcc393c68b5b5899e6d3f23001913a24383ed00955d5ec823dbd3844 +ab2110a5174ae55ebb0a788f753597bd060ee8d6beafc5f7ce25046ea036dba939d67104bba91103d7838b50e36703d1 +a211972a4f6a0303bec6c86f5c23c0d25ab4df0ba25876cbaad66ae010b5a00aa0c5daded85e4326261a17a563508a25 +a49f53496a4041a01e07f2c2cf1e84e2ee726917bb103fd267451b9b7bb1331c0afde85a79a55409bfde27328b2a4745 +934e915c67c7fc47adeabdde49f63f04644fe234672003be2aa0a2454dc8d9288f94293478936a450f2e3f249d395b5b +b6e69e9d6808ff7f60a01b7aea6781495d7a20f5b547852d3f0af727a7434209d3015a9dd04cbe3e272918e32e345508 +b348d3462092b5c6fead7e515e09611438db8d69650876dd3b56226e303252bbeb9e9f3b888fb911445b0c87132a1d0e +8d6510334a905efe5a32001e167f1ba06f9bc4af7ffbf11b7f7bf3c0076b5cca373d8c47e98c1ba8755bb22632bfe0e7 +a2d5200f20985dcd473d119ee97e1c0fafafa0f191185bfed9cac429cef8198d17665dac4f70342eea66e6e4a7370d58 +8dd7eb6b1841b3f33425a158d33a172b79b2dc8a01378e4174e67a1a4c8f4b887f02c7c3a8f354ed9eac718155bcdf37 +b16ca19388642f71afcd9f7007b490d82f83210ac1a989da9d4bf4c419de07af8c048cd301ec7e01b9d06abda7c169d5 +93cb2d847d1a88de8c1c9d5b3c83efd0b7afb3682942bd2c8ab5ef35b33dc31a097a3e181daab8630d4e840b677216dc +a8b648c769e77a7b41c0c689fe2fba9bc585067e004bcb1732cb7b1618e97b317781c36c23a00680fc780b58c301a789 +918c321100d57712866bdae84edf7e42df30a32853af257e0cb4da028842a43b49e775f3cecb85cd817269c728de7319 +a7b0f6ce42e00c519e69b2c78fd9b75a2e7103e5892d3c1afd70c9b5b9e706180a4bf73dbb2d3eed52bfd521103ec5b3 +90041994af3322b010891356afd8115340bd7fd7ba328716fbc4fe458236c8cad8c7564ae473d6091ec3a54bdab524c0 +acb1ac83809573846231f9be2dc5f3e986cc36dd9574a620b1cced45bad0b11ea957ce8c6cbf964a0af916781c574f05 +ac54677dc002698fc4d454c7beb862ad085d0514f92576f3485a44c0cb47afb9db2c085058918a3508f9b3de0137d97c +8dea56e1bfa150e442f8484b2952b116781d08cfa3072d08657cc09b0217276efc4ab6f5fd726bfd826f6976ced8da29 +a2b09e25baf01d4364b5205fa0c4dea84ef8fe03709113b034f88a0f0a502a81bf92c1d4641e2ac9f3a6f4203d3645ee +b95fe37aa351b4292691a9c2e547224c37ec2751a31ecce59810cb2ae0993da6fbe5efe0ab82f164462fa3764b6eb20f +a3498947e91a3a540e86940be664fc82f1e83ff41a0d95eb84b925e820602a41b7393c8b458bd4ebbe574a754586787a +aa2516d3620c832e5728fefdb1af0be30c871cbad4b166a7a4565af676e73bddc2f2f51acc603b3a022056daad2b330e +a9251b56467fb55f64c70729e2ec77a59d7eac79cc0b4b25ee405ac02aea46bf1cbc858bc773934a6d9bea57cb528185 +ae8c0a4ca7ba6bdca8764bac98df0581f00358db904e57867e6ffdf15542e55f7bad2dedac152ef88038b466ed901934 +b0881e27e52cc6a57c4f3f278dffc7f63a9174b68bc867c16d8a151d9cc4d0aeb703d1074d1927faa9ffb43e10912c9a +b67138465d6654ded486d18e682f11a238d6a65d90f23d6b13eb6a1b7471efbac9ada6345dfb13e5432196d2a256829a +944c69a6f1126edd38f6eef60b8a5bd17147ab511e44e8e0a442e87244d8f35236ee0b8d3dac0631f8598f16486a5f74 +995679dbe03dec775da26708cb9200dabcad983825f1ba601eb9395f9da350ca71e8af61dbff4c668fd0eebac7e4e356 +89de362f02dc14de6995d43cdea3c854a0986c605ba5eb5dacf24e3a85983229bc99a2fcf50aba3df59f0fb20daffe29 +84607f0e2d078df22d0866285614f5d78cf7697c94a7d1b5e02b770101ceecbfd53806b377b124a7320d9fed65000b97 +93e3faab60050dac76ab44a29bcd521813e76ec8e4ae22712d77bb489bb49f98f9087acfd6a77016a09a42ddedab2d73 +b7d64a7a35f21747b8e6a874be31ba770c0d13cbd41448411994e8cebb59591295a26bacbf74ee91e248a5b111aacca0 +8dcad429a2b0d66b9eb8c1c3924d7a72979727db6a535526a3518bed2a9532d12aad1c5a778824ca4cb98e3e513f85f8 +980882895faa347bd2fd1dda7b8ee7ed49e69843afe646f677b371eecc7a10e0f4e40bb55f28995a40080df471876816 +89e8e7fb51df79971e2f7bf65783614abbb0d7f3f1b4a15d3f0d160deafa7ed1c446d9a5ae1a77160d4dd94ceed8af13 +93fda8d350392e9c4d4ffe6534f7e7be53f32483d9319093e8436fbb8166a3c01085dc858373e65c7f4d014e0dc2bab7 +897521a87b7ebf7152de5260c0875e3c7df1c53e734c672569219ee6f9bd196c5ecef159b6a1d3b7cd95e91b9b8803ff +b59affa408a0f7bd7930fa3b88750fd043ce672c10a3adeba95a12f23f0dda1793f761a86f7409ce1e6fd3b3b7195381 +b4422ccc12f4fe99c530cda610053af9ffe635b633d52492fd81271d1f6f91b87171d572d5bd0e46ff63e221fb2fc4a5 +a4542cdf3346ee0867c08d630c2aefc57442f1c05c0eba52d223bfdca5e9d0bb80775cff6ce2e28aa2730231fd7b1bb1 +a7d297bb09118b914d286e5d1e87bdf13f7d174b988e38fb5427902e8e8c674072f36b19055a1070abcf357f8668f35b +9213b0ae24b7cb43ae95e25c09fead8bdbac55141694137d67eb5eab5e90a348a13d4d4d2cbc6436fc4f4f9f7334ced2 +8aed71a0d116d832a372b42a0bb92a1980f3edf8189bdbaed7cde89fc0418b3ab21a04f5c6e1d3b8edf73f1f62bd6b15 +a6c47d77d714c285c84c6b9458cbec5e3b191c0502dffd10ce049cf1ea27ddf868ef0cff13a2377289fa6c932b8e4f28 +92f45622ec02483f2c1e07075a6695416d3768c8984856f284f40734346d56cb5b3322f20c2c9f0ef8e58ddc294a309a +af6450d02b79ac9fc79f35655b58fd3619cd5d38c5317564b453f5f2d79d7a030bf767e399fe01b658a72fbd2cac2356 +a3c01fed5240eb8a61ffa8ff4a120dbcebb53b8e19845949c77fb4f9b2c3dd52c7001df6219ad2f76c785a4ee0f64a2a +af3136bfe8f774187bdf87555a1ac505322a956229a285d28bab1c88d4f4d12245af8dff35914a62e90e49f3dce6acb0 +b20e21d28444fc96737958cd951858fda324b924b4d3d08932540fd4b87150f053db6985b96903906ce83dde0578cbb2 +b7978101071268d1f485134b4dfd1e35f89b82c7d99ae91f58b6745f5e0273b7e06f3b23009033ecc3e41b2e9e85219b +9104b7d75245b784187175912cc0ad869e12f1983b98e052710fb33663224362bffd69ceed43e7d4ad7f998c0a699eb7 +a7624cd71b92699ce3fde0e747976ee04ee820032ac45dd27d769edf3b3379a4b8db358e50c9d057c63b5a9b13d76bcd +9354a76f294005de8c59db10e638ae6e8c6d6b86a699d8da93143da8478d36116211c788d8285d8e01ea6647dfcaa1aa +b85935c04cae14af9848db5339ab6420122c041075ec1549314e3c9c5a610d9b794ea3617c50ca7af6b4aec8b06bc7dd +ad6835a62311c84b30ce90e86c91c0f31c4a44bf0a1db65bf331b7cf530cca0488efaac009ab9ed14c1d487da9e88feb +80339f0245cc37a42bd14cd58d2a8d50c554364d3a8485d0520ea6d2c83db3597bf51a858b10c838bfc8b6bc35619638 +b370420ac1a011f6d8f930511b788708ccf2fe23ca7b775b65faa5f5a15c112a4667ed6496ae452baf2204e9ce0dbf09 +8ceab3dadca807a1c8de58ac5788313419c37bc89603692c7a4d96e2311b7fe9e813cc691a7e25a242828cdf98f8bbcd +ac1526ebc6bd4ac92ee1b239f915e494d0279fbd065e4cab1f1b8a1663f67daa89560f6c99bbc3e63fa845520316d2e6 +8240ab0bc36a29d43ec3059c7e6355ff39567e135f93b243145d3ada97fd1c970743819e0d58bd5171967daec144e7a1 +a99743192a6f1967511b2d3038cc73edacb7e85f84b2926d8880d932d2fa12f5215592311a7548494b68a87ec70c93eb +8ffffc31c235997e59ab33c2f79f468399eb52b776fd7968f37a73e41949111957434f2c0a27645ab34c741eb627cd1f +8949d955309415d6d2cf6ee682ccd0427565142c1bfe43b17c38de05cd7185c48549a35b67665a0380f51aef10b62a8e +9614f727a9dac8ecd22b5b81b6e14d34f516db23a1a7d81771ddaa11f516ed04d4e78b78fda5dc9c276a55372f44c4d4 +aa85d3ef157407bd8aa74032f66bc375fddaff90c612470b5ff5d93659f8c3523b2d1b6937b3cc4201c2aa339621180e +86f8fe8bf4c262dc6a04620a848e3844f5e39a2e1700c960f20ee66d4a559a90141ef4e5091d0f32acb1e915af1e0472 +b3af2eb785b00588371beb3b49536b7919a3f2175d4817de5dcbf7fcc20c512852ef0f313327fd0589b10173f77b92e0 +8388703c512eea59190351f3bd2cce83ff8bcb3c5aefc114cccf9e9b3f78200d8034c3ebe60448aaf6c912f0ff8f0cc4 +95d0dbbbf08ec1ed3975fe7dd542be0a05156a2b3db5092825d918a849411ee536ed958201f74a5513e9743674d6658d +8d1a48802f1a2db247e633ddf61d3ef7a2c062c48dda59bf858916e04f56651a7d51e367d6535964ebf3ae6d2b21b421 +971436871bfe868f25247145a55802945409b3150008535b372c949760d7949dd2fdb40d9b96ae7473bc8f6e9b83ecdb +8ca431728ac0f156763090828a7b6d860bf591e5b9dd3bb3b7f3ba0ca74191f9710ee55efd32db7d18eab5b479cee8a4 +81e28f1a506e84c2b9aba1df720cb50e0b597b2c22f98acc34e710c934cc6f97dcaf33d589e845c2c1f6d8716d05ccac +8f43b11d3f00c41d16c9bc9bc0c44227c056bd77de4f1ca9a799418c5601e744f99066bef47da2d9088ae88eb259327c +8d330aa52744c08ef98cc5599eec8b9b4dd18aa01b803f1d1ca0e29b74f1aa2886ed0224390fc377af25852851fbee03 +a06f5b203b67134c685039ec2bdbcc787353e2575ce73a415db24a517c0c31b59d1de89f12b97cbef0219fb6a1e90a20 +9269a5f49bbb8fec1a387b5d105df88a027de615d5ca6afae20fe89b11746f8d23880db78dac238c955fc8bb3de18046 +af5074b3bc0656421c314547b45b5abd3045ca1b17f5e34ba39d8c1f7928a55d4ca5ea9c2ab59a55909b25255233e04e +8e7ee5d733c8e08f3fb7d85f0628de3de6835121672c65374905dc6d19e02fa2df14c13d5e9835dacd609a4df09abd26 +a9b9aaf83d31e879dfb8e73a0708801b4dbdb5d7c8654b27d2c0f5797ebcacc8d00a82143e2060f0917c9d41f1a03de6 +904872aa1c093cb00e1c8e369a3bdae6931c5b1ed705dd3bffba243dc4f42df3e7d7cf70303d513b34d2245743d765cf +8a4d6b3b1d6afe67383c66693f70b397e510be28e3d97dbc8ec543d699b6cbb0e72eb90a7f65e83cf9f7ef50fb18b128 +a914de13916e6a0dc0e0fefecb3a443cca80d83276513b70c22c6e566a2d41acbd33a0e2836ee09abeffd3a4894e437e +b9c408f5f05934b0aefab301ba22f8254c5ebbf5405b6aa788f76e4b328c150b395f441e3566015a0deb3eca89afe9ff +8d32aa2c81b2a8b89f347c2e0b6567b2117ddbb778fda8a3f19004b7f5aa9dd814b9b3ad35f9223715d2447b2d12f159 +8230e8b9c84cada1bf14ea6aa9ecdadd978d893cf5962fee6c7167ed21239210ea491987f2c8f2e8cfea8c140704ca28 +a5d7b6285fea51c6f21d0976a7c3a97baa3d733a201bfaac0994db6c65611d91c5fc0ebc2a7724ee02b371e575573649 +a54f00a9530f6930069f5e3a8b8b1d52ee1def0aad1763e3c609ec07f25410969b43d5943a94c235ed5eb207b33a402e +a8dc6e96399b81397734c61c3a8154e55a670fa25fa5854b3c66734cbb4ec0d8f6ba650ee3c71da3773ffc9e37abf8bd +8841fbfae1af4d400d49f74495f864804f043416c09c64705251d021b3ab7881f134a00b0241e61010617d04979d747d +95acea7ff4861cc969c1d8cc8775c5eae014ad6e2e0e2d0a911dd916c34ae69f53eef779cc24ff1eac18c2b478d3ba2b +a5dce74abcfb8c68031b47364bd9baf71a91db01e45514ab6216f5eb582ef8fe9b06aaa02f17be8b93392d9b19ab9c06 +89e111169e4ae2f4016c07c574a3bdacd8d2f359561fbbdaa3474de9bc24ef8936784dfe6fe0e29a13cac85a3e622b61 +a4c511af6bdf3892939aab651828259e4ef6ebecfdd503ecc14e61001575b313a89e209cb55a77ec19a64d29ada066ef +923c62156fbf3a44926ffb5dc71f7cef602dbe941a98c61f019a27a18a50c16b6135b6099fe04a2e1dc88a6cad989fb7 +afb9191c541b61afa0ef14652e563cc5a557842ce2afea13e21507dde0ebbe6da5233af949c998c00865c79bb3d45ec8 +8a1f0ad65cb2b225931f41dc53547d756111ecbf5bc57c5ee2cc1ffd61b126d0389d311ffe26cf06eaead95af09c5ca3 +9040b20b5ac2e1a9d30abf7a4eea1ec2db8f3077cb2cfc8736b37222d8d3937f5d9f421167086dc5551e9f0bd2522d07 +b6d888b8c6bd448dccaf99c3f690d47f802e134709ce102fb6f6fc68156943c0762be6f386338163e01eed2d1dd5f734 +b94f0e27bbcda793e4a272603b3dcc739d3bf3207798df7319f8dc9d37cbd850e3724bdd30498c929debad971950223c +9769827767be9d7bacba1b687289e0794c6fe630d33c9b607da1f6a65e3f34cb8bd65327d9287c8c5f3c8b5f6d3d133e +aaac72c993aa2356c9a6a030950441de42b2d746bace29865382f0ef54835bc96958b2f00237d805ee6a69ca82117c1b +a2b1f027d80c1b0e79bfc7dd252e095b436fba23a97a1b2b16cdd39fd39a49e06a1ca9a1345c4dbb3d601ffa99f42bdc +b3fa0ad1478ca571e8aa230921f95d81aed7eca00275a51b33aadabd5cb9c530030691d1242a6ff24e2d4cfd72a47203 +a43ed4368e78daad51b9bf1a685b1e1bfe05bed7340d4a00df718133f686690c99198b60031513328fc353c6825a5f2f +965e145711ecf998b01a18843cbb8db6b91ff46f668229281d4ca52236c4d40804ebc54276e9c168d2a2bfc299bcf397 +ae18e6efc6f54c1d9230210ac859c2f19180f31d2e37a94da2983a4264dbb58ad328ab3cbc6884ce4637c8c2390f7fc1 +83a9200486d4d85f5671643b6daf3d0290b2e41520fb7ea7030e7e342d7789023da6a293a3984308b27eb55f879ad99d +b925fb6ca83479355a44abbcdf182bfac8a3c7cce6cfc7962be277ce34460eb837c561257569be3cb28023208dea80dd +9583dd991b62ae4bd5f379ccd3cec72cfae1c08137ddfbacc659a9641e7d5a82083de60005f74fc807bd2acd218d0789 +ae73bc32e9ff5926e1e06c07a3963080881b976c9875777f8e4cf96af91bf41bdbed4bd77e91253b8ec3c15b4a6d3977 +b2a3ea90aa398717ba7d8c46743e4c487b63c5abb140555d8d20e5115df2f70d3c84a2cb9a5e0536b2d93d24f271b38d +91d119d3bf1d34cd839eb69c6de998b78482ab66bc93fa97e31fb9592f36cdfcd673f52366f8c8e8877e313b92d4a2ad +a1907e20120902cf68912cc3046f8806cabbd7673e80218814cb088e080dd93b5dccba395b13e0025f5755c183276c3a +b2e2011df72504065ec4c12cbc2137b95cfcd1355509671feb7b00dbf7f8d500476a49754cb7fb9219cb5cba7c8afe01 +a48589fb7a74a3dfd782cb3503e6294a81dbb6adb412887569f9408e9079371edbd9822388e0b7ec8d3297ba270f53ef +a203909bfe196ac65ed3e6800d577b6ca5c8fe1d40f7f925a43852951e38883f2ffd250a9e16fab3ed3dc1249650247b +997ac293722a8b98f7e819f8e6c2d4c5bd1103b82d489d8b8aabeb905e95450b9b75bd61442cf68cc957212ec1c55617 +9895a3de62395c33509b153b7820bd94fd2b011f0cac135fcf916482f1eda272ecc79f83a61837e99c3a3c4ab2c5c2a2 +98c2ece4d49a64ec8e06407a0585081003bcef88af35210e22eab91169f8f0c044d611494b755e5bd915804b1d857747 +8bc6dd083b36d076ddf0e0bb1bb87cfd059283ddabb3886f02eb7e27f1f0539b2819527b56b5c13436523c4603ac1d12 +85ab8b7a696333c82dd5e179e12b2e127e67d911de609ff9a03cab95cbeedb1f364aa1f2b5e59353e4ba0d177f996151 +a9478e214afa68c395aa2c7daf8ba1627feb71ad6d8bc7339734cdcdd5a42838e032736c28e6251c808d5a4875ef0d06 +8c53f62cf06a35321c8af3871ee4459768d0745ebf48942b9f464206309f42fc7b2c50f196ae1e43b664f0e2e718a23a +8ba80662f6642d8866e832ec8082a4204ebc993fc304c4b794666856de0407620131a18dc053597bb40a3de0bf8aca22 +8c8fac6b911785d1561a985580c03fb2ebc613ae33e486a92638aa7d4493374118d9a6d9d99121e29c68c3d67ee4e3f3 +90f2c793eee07ad90157040b30558bb3b0164e8ddf856389d6742cf5bd1c712e4c6a8e5678da70a8e9e242ec7864117e +954abed8f6d58896b7f6438c9780236c1c83b02d60a29fa7361559e619e5bc9d67b3646ee39ffafe2b3019bb3357fb50 +b79874f757a33085e1e751544de8fe3afbea92e0234f9c00254c2b36115a16ee46f085f22aa66e0c9177e5106f51b03b +aa148b287cf4f60c64f774282b421aae075f0eaa93a45aab4927750f47e2ef0b811d1846bbb15eeb2f293c80a7612e83 +a588d8825e7b0168d45499dcff6faf0dfe1ba4f090fdc7c06d50344960c0121f10ad109b0b9d13b06ef22de5a04eef87 +8f61ec93d14ebfa9c31731f9ef0fb8907505fedc79378e9a3f65c27bed4d74b41e129c97672ce5f567d897befbceec8c +a008218633f1da10efd01c155f7ed739faec902da6dc48e9f19ccbc8d32bb318d71806285cf2003de2c907bbdd4f8b22 +88ad82c66f7085632d7e348d69da84200c53594553acf5432b50dd1e87f410c802dfea91be3cf804e3117ce13103f23e +8498dba17de0318af227a3f9ed86df37a5c33f9a538be9823f8dce4efc3579e8296cb3b7200cee7c5e0bfd9da23a4b69 +b3c0342231dffe4c9bc7d9265597bc8cc4a82e2980ac6d1407108db5b00349dc91d5116fab51cf2802d58f05f653861d +b3f2730455f9bf5a058598bc60f47740117ba51f6a767e1134516a4e42338b513f377027acf8825da5c4d047a62984fd +816360914fbc9d8b865157bfab07aeb7b90bb5a7c5cd64847b1c3184a52266cd3f8f8f3ef99309ba2edc4622304bacc0 +8fd21b2315b44a52d60b39ebc45970a47b9495f42b88217ae057bebcd3ea0e2476c0c3d13de7f72016ae12ae966a008d +b62014485bc217a0fe892ef1aef0e59604ad5a868face7a93f77a70ba3d7413443fbe7a44552a784d8eae1acb1d1c52b +a905822507e431b35f56724f6c8d2e93b0607ed7a4533073a99cce2b7c1c35367382447073a53036dfdb0d04978ccf2a +81672e39c2b31845142963351de3d9cd04c67c806fdfe77467867463dbbd8a9b0e2400ccc55016e57cbedb02d83a0544 +90919c970ec668de8ec48a2a73bb75cb94f0f8380c79a7909fd8084df61ecd631476ddd474b27103c6817c8f3f260db9 +8fbe37dfb04bf1d3029f8070fd988fc5e4b585e61eab6a8b66caf0ffef979d3ed6a662cd99468ce98ec802e985da5fad +950939aabb90b57a3d667f9820880eb0c4fee5c27fe211ce8ecd34663c21b5543c810b3676111d079ac98644c75ee0ae +b06201ec3c3cfdaf864a66af128effee8ec42d25f1e173c1edf9207979fa52c871757000c591d71a9b6cde40f5001a06 +a79054e8febd0450c96ac7a5fd6bf419c4b17a5926f3bc23a8616f0cfbc2849d97470174cd1baa7c739b12615334b6b7 +81c7391b2a1844ed26a84f054b5f03865b442b7a8d614cd44805b5705fe6a356ac182b66a3c8d415132e389efac5f6b2 +825af1563d0fe53925ec9ac0df65d8211b333474e59359bf1bde8861eecd03f2ac74534d34b7e61031227c2fa7a74e1e +b60dd9bf036f1825295cd2014ef1f6d520cf729b4d6cee0b42cb871b60ae539b27c83aa3f96ee3d490ec27ce7e915115 +89ca43d5b7f3622b42df7887572297a7f52d5204d85e2e1ac6e5d7aa7f8aaea5e3a07280477d910db025d17cd2e7373b +b93a2bc9b1b597f0e514fde76ce5bfb6e61eee39cbf1971ea6db38c3ecb055e7913ec8cd07fb0b0ffae3ca345883101c +8d45546bc30266b20c6c59fc4339eb633155aa58f115a8f976d13789eaae20a95b064fedead247c46665cc13ba856663 +aa8eacfe00e8a4d9815de3f7619d9c420629ada6489933ca66a571bf6c044d08b391e0d9eec7d1cbebe8def1e7523f1e +b32fefc59a0d0319ccb1946b351ed70445d78d9fbb536fa710d3162b9659f10288f12d82b32ecc026d55f16cbad55441 +99c7c45c34044c056b24e8f57123ba5e2c2c039e9f038a66899362840cffe021733e078866a8708504cdc35816cb335d +80def162c134540d5ec071b25ccc3eef4efe158be453af41a310b7916c49ec0ce06bb43dfee96b6d77339e11587de448 +b5f2fa4f68f6a26bcb70d8eab62ad73509c08ee7aa622a14b3d16973ffff508ce6f1aff9ced77b8dcfef7319245cf2de +b4d0436019e779c789464716e1741c189e8945dab7f3072720bd9aa89882fa5b085a1755c48da21541f3cd70a41b0a71 +931e798ef672e1472f4f84c727a101e70d77b3a9f0c0803a5220958d6bbeb8aeeb56c769ab472a3d6451249a13a3f56e +918c10a84de268aa8f1ba24b38fe55ff907be07b1e86b4a4adbf305c0d705c1cf5f65ce99e03e11676cedc89f1a4f331 +8e55a8413b823715ccd92daee357cedd797e69a0e78b6fcdacb7318646b9903dfe05e5501f47b3c52e74055b9eb619a4 +8b329bb63e6c985d7d072dff4680b3f8b1217ed20543277386bd30ec25240d9dc378837dcd5cf4fd9548658635f4c537 +8c2be5386052b22986b33dbc63c5afacb6d0095495564ba4aa28fc8c880a3c78242fb083248d788ed928deb1e30a82c2 +83a2b7bdfcbd25d6b059f27218e009ecb5ecc4da68ead885e00216411d8222062ca42f21c4d9cfa19c31522080af677b +9620334d2633e85646b2e2fc48dc6c3f09c64ef1706ed78a3bb6ce1f6b274a727364df71e97531dfdcb392f70f27f536 +b6c84970ec04545121ec3b79376f4e45053c97e8bf2b11922cc2490a429c38735466097ecb81cc9d9692c74d2fb8abc8 +8e55d707dcf265c5ae29a32c27ce66f200fddb724faa5bbf145ef42280ef645fa2f0cc3cfe2db8599b26c83b91e077df +b910b96b763966402bbebd68a32c15a225ec21e1357fa298478c5981a4310e556103fef0c73bd8903e11c4ed2c065647 +a8fd933a0e9fe8c459809bd93b8ce153e2af55df94b61a1490736b19c89469954da8b72dbd072d798fc06fc3d7a3d60a +811b279c113828e114fd82c2070caa7eb089a46c8cabf865f9c77354a77ebebe0c4c6400dda0e66dd017cfc44d76851d +8ed03e91c331afb3ad6e42767e1b3e8d3a35fb831805ff1b5fd3e91878e04027ff5af1165a3ac295f1578faf2c83b581 +95bf53683d64a0621bf1ca6ee17446783f6c535b7a54d6ea57723487a215759a54f886597a55dfdd560424e368ab2759 +a9bea378768fb1d7ba365a16531c51fc1975f1c73caf2a0891da28509805fa84e2a8db7c6ccfbc620e9002317abf174c +b8308250891015deaf851c4e5a4cf4704d104f94064418488d7e3076d49f36240dcf6fdcf83f45fe8a1d97fb02e3db59 +adcda6b63da21f4074f142f8e7f3a2274f624c733e3a4001054a1809711529c61356aa087f73aed877a58ccb41d38d12 +b80e7869239ae26d1da2e6683f064d1dc93cf4a2b66e9439b3ad9b25324e969bf98014760d29e6b8de7ff152ef498d0f +8e9bf968911df3bb5e3a7655e9d8143e91ee87f14464d7ba9c86e1e31b03ab31b91eda121281b79cd974d9ed2657e33e +9007277e8335a43e6bc3c2f5f98c0ba7024a679b7156aeefe964f1a962e5ac82154ac39d1ffbad85a8f2440f3c1e354b +9422b9d670e997b7c919a429499f38e863c69c6a4d2bb28d85e36ae0895c620f68b71e39eba785e3d39a45be91507757 +926094e01132938000d82dd9a571fef5ef104cd25b4015a25e3442af0329e585aaad5472f0e7a69899ba2d6f734b40aa +95552d8057f7e32c24d69e4d6c51c98403f198a20c5be8826254d19cab2f84d5758e2220cea7e38b7c8a7a23178fd564 +8abcf8dcc8488bcc9ab23c51b9e7a0d91dfc7bebe88b7ed370ee68eceba643e939c5eae66a4aa5fe85120751780e351c +a91bf8198f029e6a4cf6f0cc39b629e9aeff1c77b8739e1d5c73d8c1d3fb5c8f6f23e27b435bf10b5b4ec1cf6a7249ed +b932d87ee3a4b81341511f90fe5aa36c571e8b914f25abcc33dd40ca67a3f6444fe9362c1434744e4af18d6e045c54a3 +a8e960c2be9b1d805d387b3ebe2134d421a65f1fd4c1b4cccdce78f9926f139eea78e3afb449b3d6dd19b5d16ace48fe +a7e2f57cce509fe66707eaba9b4c042c1be93fd6034a9b51d1d30c45c4363eac79d54663d525c9873ab0eec0b1cc4ed3 +aa162a31c2078f4b080199debf24494a8dfdfb9d8fc85b198a861b12a629c73128c55a883e4c2de3dfed6e0e1b83eeab +b5a4d075433eaf4115717a84b4dc37f843d44bba0bf820c92ecdedd5afb61be60f7708c8a151a678d9d5c0ae531bffb7 +b56ab96f7a463c0079e05dc766f3a6a31cae5c5044947734ebe0a26e01367c6763cc8de6c2ee2f3b8218f05bef217474 +b60792ac506b901065a8bc0180a86e028fe34b62ceae1ad640c759538ebf3a2ad9c8c927d662deed6f489ff3ff7813c4 +8c8c2cdf075504d12d441a58542e1f8e4bdf92b3ee4775e836b2734c5ec1e3df919b931386417d04489a1dca806c87d2 +8ed78e91e5c4a68894cefc2f7fa71f02e5e12d40f1bb74332139bc7be4d92c24e07d5ece0e82150ed474aa1337af4c18 +87119c22ff8aa31150bde537d863cad661cc5159b12f084cc319224c533f0deb28526ed8568d00a1441e7d8bb4f05673 +83a60ba5a9cccf22cebadf7318b706c9f29abd25db0e2fc1c802965351b53cbf316df72ee3e9b2d3ae7f3c4494cfdff1 +b73b6a9fdd3e7463fbdaabc9a885b7c82201ad867d1bced1c2484300a01cbbb3f1e21afa95d4c7cbb6cb983416b63b90 +b1d89ad16981ff9217708090d4017662d8838f21f3a3296cffe14590b533905fa06a20e40dd497bd291fa4dfd1bfc511 +8abde560083e071a402e3c7bf31930f537f67d2a7bbc734a7480b1b760aa712ebd1cbcb65b00e11e384e980222fe14a9 +89c731d8f31afea8bdc9c32527bdca257f2a840764d40f6e49403b8e75ae51017d505ea4fff91bf28b6f3a1bc65b8bbc +80e9ac8e077e86ad050ee73dfce268a69564ff1b8419e9c236d981fe7a5f0c2bc756e8603ec604b3b9e36da8fe10a49c +b4f1eea0f304898b1323c6382732e6f40e556bfc68af9ce73f6d54e92f5f23cc4f78eb3f43d578d81e7627fb40f092b3 +a0e3a8d1348f8f153e08ac4839232d75d1d6e81b5de184ec4724f8213baf98d3fe739a96f6b39d79a053b628c3a09981 +a6915ba0b52ffe4a381bbb8ff3791d9d3b848bf89b3bacbb2a7d2e5ae21f1353cdc304b3cb6e82416f7e604035c27d7e +b2c4c9cdfdd2fc9a340ba3ade9423344b9f429e8c7e20a8abbf26400376e312f3ae35d1c456be99dfb5c02fc8a36cbfa +9657d57ca0641825a0aa5687f3f87659d893f33aee819bafa5b1ca1db554811c1c844f971e278606e3a2f096defdc67c +a4ad24d0a557704ada24d8e27a15604bca28679e260b2c69ccc8e6cae5499866724b700605a90df7dfb35130756939b9 +b18d9ea6682f73a1f99a9a4fc98c38fcda02c1a18e8c5fc080cf935a2ac877dc5223fca273dcde190b906178d0fd05bc +8ea5fefad0799c885f50ff10d94bd0af5b99b0a446cd1f367ae5ff529cc47e09f3018115f3c0ccac2fa05bb65b84945e +92450d52e6c7d13ebfcdf5674d6761bbae2fc5aabc865d35d031b588c383e0a64cf69a73dc93948632e2b98f74a5ed86 +a356f171a98df4ec5a96d556eaccc6ad34b4238aafcf0e94ece27cdbb491749fc9692e78b84dfe80bdef2914079d34b5 +b918703a4d3507d266414712ba8eb7ad17da07cc5f952b5c62ef130cc6ed1ae3bf01237fc8848c179725bdddd465b301 +ad2b0554570bfc9d97510cf59bc38e10ca54a93649c30ac9919bd0255e43bf525ab11b74f78a51ac0973cd0c5a5dcb54 +a7ecaf4b631d179d32ac1632390d95196a0035e00da6c0e6e13b5c09ae44b15ae6c21538b5a31b73bc5f650ecd979b59 +a37704eb4d728df2a367e59fcb6c26023136230e37f3b8a2f3ceeb1467f5cd30186fc0116f98b64a8146fd2c5903e8d9 +b09373ce92314678299ae10ec1f93c702911beb4115c6b5ba6efbcab9c7afb599f59793912df70a98868bce6545a33dd +b52a878a1393094fd2b93f2d1eccabf2830ab10800ba4cc24dcc7849cd0978733263aef2fcb766a7cb575a7a99383db8 +8dac097e006fda4fb9d6d7ae52adabd9448ebc8d5bd5b38ac0c4ed38ceb510763174f7adfb0b473c38e52147ccab4239 +86b19c41efb949937d74a7875549ee5e997f9fdac7f7198085afda233cf74341a38d0ca3767c76cd35f875b89a35f78c +99f0d927e5ad25cd134f1c70b72631cc6b5cb4ddb86c0642b900464e33d971213a5239dddaf71f7a42f2d6d02a12dcc6 +8355c38806c335d747d4e97f0083fb96585677da18b409a85175ec35dc3f74671817b34203eb18c2f729717ce083ede8 +abb3603adb061a036eae0afa5f23d79c3b62442e0e3bcdeef896f88995585c1105cd3065410368456a4d36b5b0485a83 +9051c5c0011784885187d04749f774b9b4f6bc594b0e4e18226de79dedc4d7aefa3529c3d2c728e180f96f3e204d578b +91888213e7d321d0bfac884edbd5cb756b280753bb5f8bc6acfc208f525757beca24bdf86fc68d3d8736ef176a960b49 +91258bd7ce6e3b7516fe2f5391a368d826da299e0e99b1f82eaa44b62b110ab696adc92debab8ba098a52f38dfb3c5d8 +96e3907340dffa9da3602d3b94bacff7e1bb8649edd3b9bbd06e1bc6781e78f91ababab12c0b9be7c66dfedc7001b66e +9513555688fcfb12ba63952ab36a67b36affdd71f7b843e8eb99ccbd45421698024608233efbdc905eaeb26b334b33af +9913ca9bcf11eeb408da02e4317c5ca0010fb2f4490b282ddb758001c08b438c3b35351a8cbe10b7fffc1293ccd22d4b +85dc2471860ebca88e5a2766161fdd77f926d2a34825d1134a30418f91a741759668e32fd1e37c415d07ab5824338e8a +8b128917e828a0b5eb6fa8ed72b52fae2dfaf74febee69a2e2f87e8df702f0c5bc0fb620c8d1d2a07f35a15ec9c0f5a8 +964c39e7840c130b01bb481ae7bfc92682b0f124c9c383f9dbf3027f2249151925f4faf36905af476a54778d69da3f48 +80671ece658cf850e522d46d25678f934ce6df043f25f8707235125765d40c2eaaf39eda6092f75039b22cb58bf2c29d +ad4bb0e79fdaa340b1347a46b0f64e801c72a89770dda0a6e4bfd35f2df5146fce9934e4baecb1c2671077c771eb8089 +80b3bd3adc6cf198fcd997f8867d2839a2eb28f57390352ec423b8a14cc1f2ab21c6e286505d6a21fb134dcd8d8f11cf +a26d46a6b8a75748895a1d599e7fd120d896340e79813167a400b2fe463452532a4cab419074663fe1d29fa716b76a33 +82b1f3a8a1df29207d7ff020809113ab06080a7f0c631f76ad33f47cdfb6a567143144df97b4ed7f676d929195b04bba +ad96633a3744648ff0a2e4491e8219c9c6ba6e655cb058c36320a8f72cd5f72c00bddf97083d07650ea9ddc005fc1ff4 +91d0783788626c91662359dc3ff36a8bcc6831e3f4114f85c99910256b1d8f88a8612f53c7c417d55581dea486f38926 +84edd9e87ff3d193ebb25f43474c33fe502a1e2100fd3f93fda6520f5e42214cc12e9f8045f99aa2423a0ee35e671854 +b55e06a4b1fc3ff9a5520e0b7c8b5ac11b28385cce78d91ce93b82f1bd7f7afdd4195d0c13a76e80d0ed5a4f12325fa7 +b0b15c7ddede2b81d9c835ecaa887650622e75d0d85f81b8bbec7ef24e9a31a9c9e3de1f382d8c76d878d1b01373f6c8 +b1adb47c20f29784116b80f3670182d01b17612d5d91bd6502b0dcecdcf072541f582aafc5e7dd9a765cad52151684f4 +8efd1018df9c9e9814a9c48f68c168551b999914a6719229f0c5bf0f20a288a2f5ba4a48ba966c5bffb0fbd346a4fcc6 +b34ea2bd3269a4ddb2fbf2514401d2712fc46c22642f3557e3b9c7acbce9b454dcf789573ede9aa14f39605fdd03f8c4 +a9e1428ce24eacfc460aec2e787c053327ba612f50d93510d58b2cb0f13291ca3d16358325ab3e86693fe686e4f526f7 +91eac7361af4c66f725c153da665a3c55aca9ae73ead84ca2662cf736fe6a348a301be1954723206dda4a2120202954b +a6f02db89739c686407825fa7e84000ceedb9bd943e8a0908fef6f0d35dbc33c336072ba65e33e15ecfcd5714d01c2f0 +a25666faa12e843a80365c0fef7d328a480c6e3cb7f224763c11d8cbabd0e7e91a5b647585ee905cc036afca14842bae +b4348576439cd2e48c01cb9cded7cc4a0ea364ab936dd679ddc7d58b48807e7fab070f2f1ea88595b11af4500849026a +a8c6c731e0d0464ef7e4fc1b049065eb4ce100c01e1a376365c636a0b23851022bf55805963bc15eb57434a837e81167 +b0952937b154e3a4c206f96cd96c76ba37624956b0e4d43470bdd97b4af878326b589e3eaee82fc192437123096799a2 +97d07ec31ecc9923192e48d37df2cf08750050fb452dcfbdb350fbc43e146bae3590c5b732b31ebfa1ce5d884ad5ad57 +a69359aebbfe4cbc4d39d178150039fbf284cbc0edc68a6bd635ee3a1c76569a4a575c907fff691b2a4d82a384c2945f +b321c2c0f6b5902ee9056cce7404d858da9a573d27348c1a6bfea29b2746f2aee7abcb6192504e5a583b0caeaba117d7 +a74e738aa6eb4eea58855ae6f422af22812fb388c83aacca5bd5fa4a88d4c01463174a229aea2830c348dd9ab9307854 +94306a3b106bc1644346bc45c05cdc8287811d5c86cad691bde0c65d6a686eb9c0ce79ad91baa4547e5d058ae8bf7310 +b64140fd77a07633e4ca8d60786452311dcdb8ce7095ba51dad8486f57c3bf4e69bced92603f71da992a48ad817ab275 +affe7f4310f1dc68e5e3cd640bedf864f51bfb46bb752063bfc18e95930021f784e509261ff9c560f53000c361b142d1 +b0d2fee222c6f963ba3385547f921a48964da031d737892604f8f2677d4905dbf615046db57eae6c6dd756709ae6932a +81700c66aad7c2e51168e028b0fe086dea75d3b17d93a4dc1f47a6a0f025df0bae1c8c997901837ad859a84197e7bb00 +aa4ac5fdd602f8b79cace18690e67bad557a93d00c0e295074185e8c6b4059a65495d9971685de2fc01d2171ac8b706a +a8becb3a64fdf35d65d2857898dcf8053b5057a73ab8c5bb5324af1a8015cff47efb85dc3eae7364cd5c850b7962bedf +b72ea09bd0b72f8cde3466f359ea69b194ede93dced534efba1b9ebc6f3bd53942fe2965e992e82edb6050cac4ed88dd +85bb8dd7eef023a251fb6f220af54687747f4c91983ff728163c4618ffac40ee6edc29a0aa6d455276bbe017f63757c2 +85a485254a11b4c4a943d9ec509c0dd1cbfc0ff5273a00cf5c9f0babec973efb15348e5d9451b548293d778e3a2b62a5 +b109f3ac809391e772b589c196b013db69a9b2b10ac3898feb70b986973731f30722b573cd0c9324158ec20416825385 +8a4eb579a840d438bed008644f373ea9ba2f28470d50cf1d70af38ba0e17326c948527b1719dd1bd9ac656ebd5aedd10 +a52e9d66ead5ee1e02ce6108e4ded790d8ec83164a0fa275ab1f89a32200726c8e988d66df131df9e62dd80203c13dce +b541cee9febf15d252475507e11d65c4b7819c26cf6d90352f5e8a8f5c63e254eddf22df0c35a7be5b244233e8e4ee5e +8153c297772adf4603c39349142f98cc15baeccaeae10c3230ee87d62255f6814d88d6ed208c368d2c02332426589748 +970dc9782f1828474e9fab7dcdec19aa106725465a5844caed948eef5c9e48199c1b6bc1a637ed7864116927e84bc65a +a975a920624967f4ecc77ea5d9869c434caa64c330024194615a8d0640c5d4d4fb139ea11a0c73a5c6ae6dd3fbf0ab5d +811f0f9e0c12acfb4b9dca359eaef3bed18083bad96188befc036ad3143b121fff4777ca6dc70a835bbc4921bd25f5ff +82341c6ebdb97c8b72910da95c7eebccd1308b6a92999886aab552f0642882d5c7cc60931577d200efd6066530c998dd +860f7162c2f5fd1c0953c6ce75bd8c52eaa48032b914410681b8cc05e00b64130d1f96ec5a52df66a04c78a9f9f42981 +8a578e674875571fe1a0459843495a5ee1d9fb6cd684b244feb9488f999a46f43363938cd0542879ea18ed14fba10a6e +8df217aba4da6781f0f5139aced472025523ed6e17e504511c04b677ca8197488e237d8bb5dff7b6b3898cd5a6393dd5 +b2c9230ad35d7b471d3aee6f771517cf3145ad26200bd6fe9c7cf28120e2945fed402e212d2330a692f97bb9ac4dcf12 +b78b89e29e8b782603b222cc8724eeb83b2d9d56bc02f59a3c899ab76429dc721358b07dcdaf422f59520b7e7ab4fb55 +82682a5617843c4ac8d4efb4c3ce715c76c1da2c3bab1ede387db503f3489c1bfdfc07d9231d96f955df84fd225bc81b +b0f53725cc610e78b8e8a4e6823a2ffe44dd15a9a5bc8151ab7a3787ddd97e1d7f2f0e6efd2876e5f96417157143e3bf +92c5a93233085e2b244519078770c7192af62f3562113abc8902f9d72591eacf52bd15ce78653ab9170d5067606287f8 +a43ef97dcd9b6ad288846bf31fccf78df72f94bc7ad768baf5bf0d5dfa27bd74ffcc6b6c6ed1d1f09e09be3afa5eaedf +817d43bd684a261fb30f709f7926cc4e1a31fd3a1a5e7e53ba4d664856827b340d7867e23d55617ab3514c8a26a7040d +a599e22d3286b32fafaaf79bd5b0c5b72f6bf266ec68948478f055391336d756b58f9afea0167b961fd94234989f0f02 +b70db7d8e8356df2e2070f8d658e560081442f3f3b95e20f4bf30106835d76161101163659d5d12cc0f335fb042dc66e +b8f725b70c957aa3cd6b4bef0d9647393f7c9e0b7343e92439372f0e9aa3ceddd0cb9c30be331742b87c53f2eb030593 +b2fb5e7762f26036e7e966f4454f886758804d1f4c2da17f3d13b0b67ca337f1fd89fd3cc798b07da6e05e8582c9537b +a377f944dccc300921e238ed67989872338137fe57f04cb5a913c787842e08b8a1adcfb4d2200abdc911fc1c766a7092 +b82e98a606071c2a33f2ad44e7ace6d9471d5434500de8307b5d4e0083e3a5cbc67f0609ca8055f0ea0ee7501b9ed916 +8e58f9a04d33a41ace4944615041662dc35057e645f63e127cf0d70f96ac307d33a62ce98f164d6eed8536c1a747dcbe +b5b11388071ffbf57ac47fc195736613b964ebb91cc8e2c17b32646f91d64ea506282b881897fca96c317364d3290de2 +a40ee9b7551133856cfb3904837f9949a9558e59a418898affb78adf1500fd6ef6328fc4422161909aea2c79ad08c14b +81f9eb4ef28aacdb43e11dfc9aa92ba990be4d3c14b484fa677edad3a3fbfeaa859a7f9322b5e95818240d7326215abf +84939b2b6bc859437d1a7a8d6ec9a357c6b716c4b4cc22abc274af872655940cfc72c99f5d0283d90e05191fcdb1c232 +b78a5b74a90a805410b6225fb9576d6d73752520f25cc3fd1edf8ea9f6559d3080f9acaa2246809b6a66879cd2ae446b +8d0a92baa88bf38dce5385ccf15d345b28e2e5d0a2d469e689353d80eaed8e8408933816d70ad752f226c59a0d5b5f0c +a7e15f8a8c1655b7b346c9488cff278c793505379b781b31b273b4bf09b3bdfca1c8ab2334746075d636b2e05859f215 +b70daf14f2adce03c7b92d6aa181f0c507a80a37493d8dd12419d5ed5f943a98099fefb46ac827d6e4efb9b8233c99d6 +8c2480814661744d116fba7355bc6b1914975e44cf0e976d50b6a20092bb1c636b7b44ed3fe8d63b5555ffc89fa759d6 +a6059528a4fed36abb74ab992b22a4f9bf1d05c5de2bfe6837b9af1adfed98bc37ed7481b5a99675d432743021fcfdb3 +b7e19f1b25bc159e5a769811e773c3a8ffe8be8ac77ed0b711540915e5c6e7bafdb407cf9b85c551f67fd621ce8142a5 +a2f66d4f7d16ed3e7ef5fc90b42676c61a98ff18bd26ccce91de03b6a0130c1db17a6bc57be135e410a76d2255b15813 +a139c916927dc3d3fb83598da9217ca64f0ae127215332e9a7ed82be923b89a801c44580d5617297175f9dafb1c4eaf3 +af08e1e1b04ec95366a12d99c80a9a9ac40ac984a575dd0230cdf4eb346a7686da55ef0a276f3356f814af31f9cbf1aa +98840aefe287369221c0721cd7c1b15b1d670c3cbbfda191cdb5434bcad757e59c30ec82b2d8c75947405888d44da435 +b7c61c8d42daf2e278a12d8f6eed76090b71c82275f8b33504aba75d95103840e8acd083e97a5a5aa79897876a68940d +a0264048d2a2061d32eee4f661957ff351e78436bf49ef973c059612874ce9c91970869d011dc13a5b7c754476880a68 +897199a4d8db8aa2db5d9be3d4f4312e41fa0739eb06c62e2e046c4b9be829a447e5d47227e2d96195d3b7b66eb59da6 +b512a9082881f5dc90b02f8bc4f38b133348c2e933813852f6a8e7d8c270c9ce68a5524af7d1d3123e53b2d02a53d465 +80b332469254a96f53c95ec79bb5a8bb1c387d40e58b73d72f84384c696ba0d3c81d6ac90be2979c364c44294e90432e +ab680c2e547ea5cbf95bf813020beb461d50ee4341dea944eb48f6a8584d35682d20186e3b190b849a1ba25625a7f499 +9070581993a0531d6be372d370c2e4ab2ee53f30e04a75ae61ea0fc2c320914506c4d2d4b4487c1f8fa88356fc45c895 +8424303dad6b4051ab633ad27ee51783b2ead61c5a6dae1eb3ed72fc1f36e2a9b1f315504a4bd90f9664091f2f403d4c +82225611eee626556553b9316dab4043aff241a81826a33aebd9864a91e299b765ba1fb43eea2c2047e6b75b6d7fe3de +8a3fb221c616ad55c352dd5e0c09ee892022013d6965aef40d4f277a42e9fa01226fe973cb99aaf6ffe4f4f348fb54d1 +b07c07679aa51713e8a7d7bc304dc15ed5664b66bd371877023f3b110b3927e09e259ef22895c4001421a69c6c013cc6 +83556c76bdac0dd8db6da231b863c335be076e7299802eebc259e0818c369f933a4a4b18e2df8ca07e82f60767b462e0 +a516f659b7915d2f7cd0f0f5ea2491b15f0c84dcb191e7671b28adf7cf14a56d42cfc0da94b3c269b45c535f6eeded49 +80d7cc6f26066f753041b17ff1bd27f6d4b5603a43729d33d596e21a67356db84ca9710158089def425f6afaf3207f9e +b802a47f9009dbd48851209ea1e2739020e717f0ae80671d9f97a0e43de923273f66b7fcc136a064c8467372a5b02d28 +ac92fec1864a8a911633f377df87aab56713876316d48240fefeee49ab97f7406c22e70f4938b5912c5c4e766146b7a5 +89224225b9835d04428b0a74edbff53dee2be285ddd1e5a3a8c37307c0500578155f0c4052e4bc8be04c56862fac099d +b1d3c8492fbf22ea60732745edd3b0163ba5a20d1a3315e3773f2540ee38cf308d42ec72cbb3e3dcea457d1d132c3904 +8bd00e38ec30ee6c44a0e5b222f1f737c9ed2a4bb9225f1741d6334df966318c8a0fd2fbb109557fe8c9479694b8d8dc +a930ce5454efc0b247dc148aff869963fc5c240241d5590415cbd36634801a04d3873d93635911bb9c0c42ecb005cc63 +b83d4f80e9e0fa47b42175df74935ba8aad2e559b80e84478ab1685bc3eb65d51b93e5738d5ca968cc055ca0c552a03c +b3ae21258f98051f13af3878b8103bc541fe6f20b1c3f8fb4689ddb8800b3c25cca9b55f0a4104bdf15dc4d5844abb8c +831ef8684c1cd446c58c59d0152aeade5cc305bca6aa296b92162615f052ba280fe289edd62fda6d9f0667c186445f52 +97bf9659b14f133885916733b7d4ac7e215495953caba970fa259f7bf6b79e661090ec8d79e1c9ce8dfb17e8552f93af +84d5a89cc2332baaaf3d19627a65f4b107f8dd9228a1434b327732f59883bb54fb8ce60d6acd026ed4b0e94e545d1c33 +8e66cb743f95ca5486400b0d89d02e20b98044be1e3a12983ff9fe086179e5a0ebf4dcd5098703191552e9aa660a6de5 +87b4cfb35bacec805f8148786788db84eb8f4bcecdd0570ecb592c705450ce1a90b6d183d37ef58780ede3995be67497 +a72a4fece5478011973afa543f6d8a8ea06a64b241cf7d8bd81fa3740ac2a4cf10e5120abcc1c1101f94da89507a40ca +89dc6001a96adcd2679916f43dd19ea00508c8d5dd6b0090eab7982fd2f3571b62f3029588a0649e73f49124525407ea +8ca75edf1259599e873530eff6151c822a4018e71a340534219ef8641cb6683215891df41d4e3c0ca2560e57a7aa913e +9282d32f868e5ee6f7fc229dda5b94b603476de30cec0a44a30edf396b52dc0ebd472b8f726d4b67d76179fecc1666a1 +afa24704223707db89690bcf9761f07a093f6009ca9fc945e0a8801fc29f9f51292bf95243e466fe736088af36c55ca6 +b51332508ddd9a2610edd2b0ad120272ca342e96c28baae37a2c4f07e689303a46c237712d07e446b1d67c75aa8ce32f +9219249f3799dfa4eb4770ee323f821e559e7406bb11b1f1889286221b22c8b40ccacbd9ac50ea3fa9ed754860bc24f0 +993515270c128ede64fe6f06755259105d0ec74947b7eb05924a375fa5c6d14822f3d7d41dd04fa5df8aa2aa205a1dec +a83be4c2511bae430034ab15b194ac719d7b7041f9c0e321317f513a97db39e97b9ee1df92a1962f265b7a3e98cdd753 +8ac7feaecd26f7b99fda3ed0b8a08bd6dd33ed5ba687c913ec0ffc64bbbefcda6f265072add4d944f2005634601ce68b +b4e3ac6b09299db9e1a469f3a0b2d8d724ee47a417a517bebc4c2ac3efc5cde086b57b9aa4efccdef2bcf8f456d973f6 +9262a24a84fb7b2a84d700f98dcf3fefab8b47293778c20bfc356860cb84e0bf102bae9facd9986d92d1762e0a955836 +97be2041c42bd25e5eb519279163b0857f8bef627492c27b1182f8bf0033769246be5886422cbd2409c08a2615352465 +b0b87d059a00e3effa2e5e4925da913b245785f2932ac3ed364ad19a064d3561b8aa6afea22c951316074f0df179af36 +891644b7b3321b06a2a40cd96c2b8b29d81cde5b48546483fdda439000982a9cbf1f6333fb6c089d39da6492cdfaefe9 +8da9149b7f4783a24240b7b9c7e6df4abf8d699d3834e31ee591489bf4744141ab199c173db64397c1f9bd5f9c862ca1 +8ad7f9fb2742654aa2964fd468e7645436cefd1308b064fd63fdf0d3adb4caf6cfe5426354f6cc284f208b03d6b2d918 +8435e4668f7aeb027100d21e4e0b6ee22b401d21966a3736b95610de86c7e2f2c9ee5d0f901353675eee5ff458dad69e +9010895f045538bd11b47bb8996f27198c8d6cffd3220569e6b7407f68f35c47d1efdbcecbf9b5e241c3c2879a4f6936 +92a9aa443b5ee7bf13b6f43f2d8d8db7f6f33fd4073a606ec5772421a55f464831419726130dd97829a7d4bfeb1ab078 +843f3266560be6dcbe0258c3c7d7e332330e10630c069892954290288eda301e247f479505a8a1bf7e59c99ccafd104f +915bd1dad808f8a568725bd243f80b5476a2999d0ef60ea3ef6e754155bc4121b2b879d01570725b510c5a3f09cd83ef +97250d781815b1825be192714884630e9f564b9bd737d55b8ac79ab48d0fb3ca53bd21ead7b2fa82a05f24083f25645d +81e2d52333391ff2faab39611689a62d6ead77039e8703f4e012d53eea17a4d46f2e3342e44b6edbe73a542b461bda45 +89c9f9fd5f638156b018831c1bb70c91215f4a2f5a73c84b1208bdf6ad652a55df7213336ce12bd910a0e1a726474f95 +92bd02984d090ea7e2f3eb7d36d1e7b9d731b6b047e3cdd4af7cc4ee177415fea7a145205e484b366d84191f06af85c9 +85a86fc61d5d916ccbb219db52953e1495230aaaca63237e9165276405f07ad9644e253ae394f1ccdd231944e7143313 +a2ca5b3fbc9f3530f88c0ed7071ec3d89b272174c366eedb5d15d2b648c65d23c0faa4e92c776357e7c6883a0084d03c +ad171f5badcc99c8ffc9d8b707d792046f86cd0aa478e0e2fbb32fe095f96cd134ca548d1f7713057694dc6b26465315 +96bd15d57da9980870fbadc98c68db76824407dff2700c45b859bb70d98374d4a4ba99e3ed0b0c17f480fe08f16c6b8a +8300bac69ca088c3ff35749b437215e9e35a16393e9dc094f520516ba57a485def7029d30adfc72bca36eeb285c19301 +8a09e20be64f346668fcc7b07fee9c0ea8094c935cbf4f3a4cdbb613d4b936c1edb9256b7c884efb72393d97c0da00e1 +b1f85827ee6f041f93ab174d847a55710824fa131c9ade9561168c3962a25c617475ebc4105eba6e738961a754442bc8 +a131558f92e215969f41b6a57d1e2f424149eea531723821dd4cf8c54325cbe66b002de2c8287de6b41ab4b5c35f060a +81ba492b8956f73557f361a856c6c884ebb300d828287d5699e22e0cfa75c8e77a61616551d0be5178263898c461d6f7 +b2608f44d3c22fac8e13cb59e4ade8b9a98c4eb1ec0959ea400c97eb937ae3f66837e91917057148befade8389af2f6a +a6ff0323b5a18a4becb2cc6b376086b47cb2baffbfd1b0f2229ef2286fb4a34c5cd83a5faed5def7bbad519fcab8a856 +857d879cb9eff22501d883071382832730704bfcc5cd5b07cdce7ab8dc41c565a1eb0e7e4befce8e0e03a4975d3f11ef +a2879a20c0360c516811c490289be7dfbf7dbd41d2f172c9239f99e3d091957e0446854f9d0f753d90384a80feb6fa56 +83518624f33f19f87096a47d7b8e5f2d019b927e935a9021823fac6564c4f2328dcb172e25bb052748191e75ac682bd0 +817ec79132faa4e2950665712b2c503d7fb542aa57b7b36e324f77cda79f8b77bde12314e2df65c5b5296a6bca9bb0b4 +b2abf8fb7c3690816fa133d5b4aa509cd5a6e3257cfeb7513d1408b12371c4d58c44d123ac07360be0d0dd378e5bcf99 +a9fe1e4fb1574c1affac5560939face1af6657f5d6abce08d32fc9d98ef03186dbb2dbb9fd1decd6d8f4e4687afecce9 +89b2f41e51f33c3ca3e44b692e8a6681eb42a7f90b81c9e0a0bc538341df9e2039ee61f26d2ebe9e68df5ed1bccf8cdf +8b35aa7b1d9e2135b35a1d801f6c9f47c08a80e48603f3850b425f64e7fb9860d1adda04f92a1ba22d00dd0a26e781ca +960574978cadedbd4cd9f764bee92f94e08b7af65403de36b21bffc9424bcee845b3b028af2e9e545dd77cf1e69a6a7d +840aa0f34b5b6c39471f54d9e85f1eb946468c4fc01963a9027cd7864df01f73c2e864f1f07aeed4b1b1af72808dfa07 +834464a84a11200e3c60f816044c254a7d9baed64aed45a17325cef7fd62338e0a26da78d199d30ac3411714dc813223 +b4ac6fe2f5059546f4ad9a361426ead33237b6b9030b129bf0122085c85fe4ccb33cf90f5a7f23c5b708a5ac64b487f6 +a12aa9035464795f2a67f3eaba478d5ebc838ed9e997c7dfa241e1ed60a94b367d3f969ccf0ef02028c35215698b309f +ac8d926492ec2bb68c6d8aa9bce49085d3d266f3d5f1f924032b87c42b44e41da7c047eeb01e4618f9d0f123dcaa537d +a5142425825d813ed8ce1849d81aa40b11f1cc3daa89a9f798dd83065c74820b4da6122b3308f528b074531df66e1a5e +87ff55c9f5aae079e7bf24084dd9c6b3bc260727d942d79cbe8dc13341d98525b4ece3ed8169994b56a387642f09134a +88e680f148ef2ecdcfed33b61f9e0224790fddc9069bd6999e9bede1791e761637c0fd60b52990b6c93e6e5429e483ce +94bc20bf5aac6e9f1060d02eacd06c42aeac9a1c5635b15a83985dfb03938ddb4999a822e865635201489c7f75601b29 +849221cab7599f25f0b114df092bd5e8c2430503ae959bef1543a101de0790a78245db6a145e26f40b5f9bcf533219a3 +88b6f2c2e7a7954fad11009d839ce50780921f80292320868d481e38d26aecd80fa607e82219a99532d88cf33b39f562 +b0d82947dc23c0b88b86c321b582c15decdb825ed909a731b42d46bc895009515a3dc646c98dbec7d71b0722df82392e +a2cfb9f7c1a76c8073363c1c3bebe5dc29fa76533caea41046c51ea9bbdc693a121b957cd96be5b6da18704d1865cff7 +8f0ffab9a83355a22683a9d998d1c1089449eb308711eaad4265f05927ec6d0d1ca39217082a0b372e02234e78dbaaad +ab024661e2b2937ad374c8cf2e3669f1dc55558a3a881e9ec4d461f27e0fa92e2bc88230f038bfb051cf2145ca747a07 +b98d9b9ec9eefa56d38cca959ce1aee7b6d4b41a8dbbd34b3f50c0a5f97f84ed2502ded1ce8cdb5895872360d4ba6d61 +851244158b3184a62d2c98d148e2b1102cf0d5500906bbc2deda95acc5e3bc4b4a3344febbb31ce05a56dfee86a74913 +860d9e2cb886bd3620b5d7499d14b415532482569bd45fd76e3e8052d78a73ae4b2b41f139f9cfb136564108cd93c0f3 +8305a052a0fb2bcd41f3aca075c5f7f233bd8f861451d03f3a6e6e31f7d08dd89fe1eb4dd7b238a78b12ddceaad9768c +adb703e4778c7e14fb83541ab00b5fc344108243ec6827c5d9b302ee68321aa569da1718424e6a57979ab7536d5eb43b +b1a754b87b9e21aeb86217ec5b4fadb7535344567f1bd15e88ec12a833fed68e26bfbe03b7709ce24ba6c925ea0a0e07 +8c1e2f6bf820e1653f3b8213e9d959d8649196223c2aab57b7ebda094f4919f88d883bcc6a0cd0be335f26f5a2a9c962 +a082deb9865fe8668e91db0e4fd7fb50fb3fdae3e7bf1217ce0aa6f286a624624cf936d762bb2b6c3fead6826694f846 +a10540ca05fbcccdd0a2a66aabab3b36e9bb525794cbae68bc3dace6116f58942218e9d5e9af10d67b5f6fb6c774fdd4 +b81d22c4ab0ccaf447cc5fc2ff3bd21746617e6773bf43257c0d80331be2e8437b88c9c45309ee46402b38d3d4911caf +84c7c6e924713cab3b149f641dabf63ad5abbc17c1d8ee7802a6630507aa1137f7e034ba1d12ec13f1e31efbab79bf13 +8773b9d236e5fcfa8c32e471b555264692006bf9a869a3c327aed33da22dfbf5780ecea7158904d4d6ac4acfe9789388 +a4c2c1bb7290eb7af2013f7dde78282148593f066b09faf42e61a3fcf81297caa5a00fdbf6b93609c8c5782a0f25341a +a7bfa6e3f273da3dcfac7cb9906bbe9fa4fc2872b184d79813ee273e6cc4d7f37f46164362707a1976f5b6a2c5d7ed1a +8b71502019e4263fcda354a0fd10aaa7da47f4abb7a0c715c7b017e9eea14f2b64009b29b467394668c7ca995adedf82 +ad7460fba7deccc3f9a7d204233de47ce30ffa55e1e164975cdf06480a6108720bc397b93ca8c959df77d44a1e1f05f4 +a5b8df96ccb7b078a3918e74b1b10da21df982538d2c9313f5129b2797c8a6db9ff8707241ff72d3e9d5983397321736 +aa6cfa6386660c01879656da6c4e72497690708bae6c5cd1d088f443cb5bbbe75561d6eec256a72b9728377eb83ef973 +b9699ce7c5c878e44114ab7a598646c6c7616b8e08a9ef8ec291189ef9945c1a538d2abf1ce3b0da0f8eecb303b81b43 +b8d0fd1d278f53c455de92ec4357885fc6648dc5f276930263da7dc885b4a9628a2113e28b66b1e64fd08189427c614f +84ad8d262f6ef5d93e82ff6f4af995148eedf6d8e079124daee9b99f506e2968922eac2c7d4aea741fceb7733f20b2d2 +ab5e30ab54641e3a44450118b8235554e0fcfffdfbe1430ceb3f7ef33325725741995fbbbb0c16f0875aef0f1e0c98ec +80e2cf8bf386ebda46045852751611f2af80eca2e910d9ec5f6e2c7376611534604ceafa639272b3d503b02bd66525a6 +aaac69af8fbb87da1c1b7c1b9e59942887ae839a91f0c1d191c40fe8163d7f1dbe984e4fd33619c73e63abfa7058f1e3 +a6194224ad838ab86e84dc80e9b8abb121ae6c3c7fddc476463d81f14168131e429a9757e18219b3896a667edda2c751 +b68f36aa57aedc7d65752b74761e49127afa65466005a42556230dd608ecc8f5efdb2ce90bb445a8466e1fc780eea8c3 +886c3fa235d6977822846b3d6eccb77f1e2cd8ba3dc04780666cf070cae208b7513dc4525d19a3fb6385cb55f5048e2a +a9801273ef850b99eb28f3dee84ba4c4017c95398730c447efe8c1146b0719f252709d3397ce60509e05da74ed0f373f +a58c2a5dd13e08ffa26a6c5e5eb18bd8f761ab64a711e928e6101512401ef2b1c41f67ba6d0823e16e89395d6b03ebb7 +91318b564ec8b2d8c347ca827d4d3a060272aec585e1acd693b2bafa750565c72fec6a52c73bb3ae964fdaa479700532 +a058db5d76f329c7e6873e80c7b6a088974522390ccaf171896066f0476742fd87a12fe9606c20d80920786a88d42cec +9838e07f9ed8b3fbca701be0ef32a3f90752bbe325aca4eaea5150d99eb2243332745c9e544fd1bb17e7e917202edab9 +85a9ae7dd354f36e73baa5ecf8465d03f0c53b24caf510036b3e796e4764a2bc17f0373013af5b9f1b8973226eb58cd1 +896a4ff4508d069a7da6ef7bed66e1080991daee8b227f3c959b4f47feaf75fd1b9e03d0917b247c2db11e105395d685 +a36d9a6a037bf498dfc0e535f2034e6cd433c7b52e520469811eb2e9f04499a6ce40257d2905300df7d81f38d1bba075 +97aac3c5492aca879b4c06db1834b30b8850a244d29296046a84c637d9580c8521ab4752ef814c96f255a139660d7639 +8552bf592a84ab4b356d01643c90347377ebf1f2b38a8c2e55a3f34537b8c7dcbd62e6776d6c2114f2bc2d4344d1567c +84474ad163db8e590943ccd1dc50b4f444beb8275919b33f53d42cba89831e9d42ce2de52b26f4412e2a0676ce913277 +900799dfaf5eafeb297c7b4f892438bf2a65ce04034d66f8e5cc3836e4eaffe782fba4f4455a0fcab49102a240d1780e +817176415e35ad4a204b9fd5771bae6cc270f6ff050996cec89efbe461b2940ae5dd3c6c7d7e31b1da5285b207efed27 +965e5791c927d47569bc54ec9b4c5305788aecd87a26e402aabeaeccc03480df46f0586ca2e2a9918885cd03332af166 +b96d9ada4b5a04a94807d71726bd557de94fbd44042d7dba40560eebe8658d1da49eba54499360619f3b2c38e8b5ed6a +a07b6d641a43e02e7868f30db4dd5069a2f221b4f122ce9b11eac04abadc4f25f3207f1d2d86c7935b1a3d9992ea9814 +8250d4d8ccac846a4b1a9fa392d9279b5bf2283c8b95d8164c3c0d199fec8849eab85755f2a2a99d584a0407742e3200 +8324cf49f56fc14162f9a9ebda1ebda0388d09d8688f1938aef7dbf9505fc119069efc552f68cc7cd9213f96fda2c6de +a98e6f1e85268dccbe3bf4e92c9f455c58dcb53de1dba3b78589adf2e50e79f8e245f956e0d098eb46f5d3746826c6dd +b103ec12f266b4153d67b54d8fc079357ee342cbe5008adc3e0689a7f788534c4601e60e939731f49e4a1e24fd589f82 +b2d7681e866420413cc98eae67614d383943e3762d5742cb3c57e26157633c20880eea1209feaf68402d5d33dd699708 +99fed0ae4112ec9ed74baac70d202a885aa51cb555a3886b49016744dd4017640dd5dd564998c4d842a9f38f3e004e68 +95c35401314467219c8bfb1ccd1f1eae6ef4fa9e48fbea14f70d5315e67b16c46cd03554471840e4a5030b077d2a3856 +8d029380e0c294400d6b8673a23aed43697cb6460fc1bcf217aca3b47cf240886644ed09521d6a05f6abf56f99722d84 +8ef54d1dc0b84575d3a01ecba8a249739edfd25513714dd4d1941fbde99dbbc392f7eb9fb96690d7052609af23aa57f7 +b8ad2b7af4812417aa8de8f33a26547f84bb84f39501d4b7c484cc8bb54c7e166c849b95240fbe459a4719a6e3bf1651 +9858545de898721d19930d8b360cacc5ce262c8e004867a050f849f7a2f2aba968c28d51f24a9af56aaba23a9ded4349 +94ea5043b70df1db63f9b66b4f9d8082776f721b559f27d37b45e0a84faf47f948d7c4532dfd854a4bac49fb2ec8e69e +a2fd88d7b15e3c2778f6c74470d0f9e1a1f979a4d58bd205361eacadab9973d585a6508e685e640b272d6f8a448eae05 +88defd6bccd55db8ca84e3c8d0fc55a3456b41788f1e209d0aec19c9c70febebf3ae32cacaa1dbbf796d7ddea4b17995 +88b8cde2449d5ee7de2ee2f32e845d27e171a51ef64f1d3d8a5fd7dbb9f898ea70eb7f6410cddfd7b7ae70ea8073cc2e +8e044fff6ec557824866ac76301b6d93ed19b7177aa6baa95046330f5d69b572b59200e3653cf2f2b559455e782e8960 +b5446b4d6741c824885790d2d26258729dc0ba2f469c85a47d38886d933b785a4f38a951d37f3ef4bd5091c03fa3a071 +956c8afa8056e9a71ab2e8be5241ddbb3a8b3cff2110cb0e7389493d9fa45e6c4b769ebef540a952db6dcd8bd55baf64 +925950cae25615246e29d594ebf34fa7d52f78a9867338648158f2131e6eb4dc17e18f9db8a5fdd76d017b3a9798b3a7 +a17ea4b43211ba990270c21562690b3ef154a46c3d669c4674c80bd424cdfa95d8850c8e882b8d06504f929cba3d93af +b315ec723973a138508afc387ef651fd8a8804f93975fc36c2eeb796a304eeb1508518d8703e666a74d14318253f526f +a995742d7433b3f230e622de23cb2d81cac76de54831491cc29768eb4a56da60a5cbd573e1da81fddc359b489a98f85c +adb2e89f0d15294d7118fc06d4fdbd9c51d3ecbcc23c69797e5b8197eea0d6cd1240910cf22fcab4ef1e2dc2dd99da91 +b5ec9f9fcd0b5d176b643df989bb4c4c1c167112373d662fb414875662d1a93160dc0b5cdf540e8a30e5fcbe6cfbbd49 +b1291b53f90aed275df8b540c74a1f9c6f582e16c5df9f5393a453a3e95624ab7552e93d6e2999784e164046e92ef219 +8bc7b7b1a584a12d5ae63d0bbe4dc1b63c9df9c89bdd1095ff4b8e7c822bf8c1994c92310a3644033c7c9689f4b7d2b0 +ad7fc45506a10ca48f991714ecc055cea376c0cbe667f3b40ee8dad8446218835439ae59bccc474cf47b053748ceba6d +b134756828a5f5725c0b95109e09ca450e3834b127163a0aeeb544e63cc0cdcdf66f8ed98c331c7c98758f46af369a84 +94535bf1636be0974b112fcec480ed8eafc529933f3065c40e417e608e43a392206cfde8bb5a87b720263446c90de663 +a4df4f6efbc3701000fb072e5cbed2754b9ef5618386c51ff12f95d281d1b700fea81fc1365f4afc66a7c83bd0228fbf +b0336b3552b721087c7e2194976a9119aee13ebed9f1c3c494353707fffde52d004a712965f460062ec9443620716302 +99a39d1d1ee4283b75fa8c1fa42b6a3836b734be48bdd48050f9b05e48db6354fef509623c6ec8d447d630a9b3352b77 +8e3dc3583d40956f9e784e8bbd0b5e65671d2ff2a7c387b20fcb7da9b969f2d122aaf7f054d450dc611737604548c03a +b5068ec5b7bcb5d8583d51cb25345990f50d1f7b82fe535a6a6b17756355885047916f466ea3ab09eef5516bbf2dda90 +a8284ec1eb1d21e693f31a6c074199ee85d8a8da2167bffab5fe240defa2773971c8437e358a18f7e58d1e2954f57f6f +aa7415639d29081acbaac3e9c6b059d68e8702db3f430b86bb6e220d476fa74841c875e9d471c8a5423c58b6fee3cb54 +8afcfe6f65fa6e07c2cb3e1756c0ef2c589830be96edd50c3c248e3b17f51a4b08ba92ef7eed7991d81667ddfbf2bf7f +83b9c8dec8ca8f9b85f0e36c08c5523cfeafb15a544398e6f93b48b5fc4b15a0bd05c0f176a9c2469664acab8dffb0a8 +82a128a89ea46b9debe5c903b950c0ab30cd7570b979ca911500b5c2cca5c4ee6b2c2fa414b5f28e367f4671ffce60f4 +b79fd0ccd2629a361cd6f9307c02ecd4d1f07e4ee03ce4b542997e055b07a026cbc0ba05fe3da309efc58db2e401a8fe +b190751141093823b4b5324cc26c4f3258552f7893241201f2fca1ae9b1a1d4d4964a9abdde8642cf308ded61ce5ef09 +935fd48b95aa6f9eada0cf9a25a573f0ffe039888b3410788c41d173747bf384c0ec40371bb4383ddcc7d9f2db3d386b +b9affe100d878491ff345636ffd874ce1f27852a92417694afce4163e6a80c78b2f28d78102fd06c3283ef273ad37642 +a877670276d49ec1d16c9f1671e43ade11c0c1a1413755f6b92be9ad56bc283e4bd2ad860367c675d5b32ff567301fc4 +8c660d16464878590761bd1990fd0fc30766e7e49e97b82ec24346937856f43990e45aa8ad37283cb83fa16080d4a818 +ae1412087da5a88f3ccc45b1483096aeb4dcf4f519ff3dbe613f63712f484bdd8b2c98a152a9db54cf1a239ae808f075 +ad83cead97a9c3d26a141604268f8a627a100c3db7e5eefaf55a1787ddc1dd5ffc7544e4947784cb73b90d1729003c8f +97c3140ce435512a509e6ff3150da385fdf9e0883a5dc7cb83d616ec8d0a0014e4e0fa57a4d12c7997cd84e07d49a303 +a353773ff68f1615454555bf658eabdcca40a9c7bced8537ea6fa8d54764fd1f032889e910d2a2a342835513352e2d2e +89e8df0c17a36ffe08149c2ef8b27306d04cdf437135aaeba697abc65e3c8e91bcf1817919a8a826acdbbe7dce79a18a +9928c2da15ac6cb20b15859c22508cfcd452c5643cd22eb84abf5f0a1a694fdefcd8fc329c9b40babc52630743d6b65a +99d837b556f8d13108eef6c26333a183f59383b39958dd807b10590c3d37f62ade6c4a320ca2e70567e0218b0ad5807d +9272da080e4aa18720b634640b01bf1fe506c7c8a89dee8759a53e2ca5cdbbd4a4f3aca54924c46b935362cf1eca066e +b4d39752c882de1c1daf3854202c1d58c2bcf35c882006eb640fe54a97be2655281cdb91c30d1a41c698617c2cf64b01 +8bf827f4a7d47e07374d338a3d8b5c2cc3183015b5a474b64b6086fcf0cdcf4852046c9e34d7917d69caa65a9f80346c +901bffc7db9c9416e06f593a76d14f6d9e5dea1c5f9557bd8c93b9e70aa4782bab3518775c2a5b285739323579f7cf0a +af7e204388568627ca23e517bcf95112ca8afd4c6056b7f2c77c4da4b838c48791191565fd38398587761c8047d11c47 +ab2576b5366e6bd88b347703f9549da7947520d4e9de95d7e49966d98249406ed9270fe69347c7752dad47e42c4ea2f4 +b12e3b228b761dedd99d02928105494ded6d4fea3026d73d65ebffa2e85e2cd75b6d091135d418dd95ac102c22b5ee31 +a20b4a752685d5e31ee7e2353c8a1b9a5265f12bb775004d282a3ecd9deda44831bac1ac5151646428b66909b2a423f5 +91a1d4bc0062a86cc6786a96fd3eb4436d8a4a187b7cbba02190d1cd6ed3c3797d9ae7d6ddc413f1c94a21f62bd04ef5 +977f18da1a5df5cfdd0276f583cfba2b2a0fc6139520664e20068f8dfdde33e29d179abfd722f142448f4677aa47be6c +abc3ece90f0f7b1d80fd917de27ab0d88cca584ef959da520825e54cb5a71336b15f8b348532d08d47a6fa600527ef25 +888d36a2c7cc13a1c1aa338a183a74a1f57713e76cb825f9837f43279ce4741999b76a16928147537bcc20f2e0195b0f +af3f5dfdc2dcfe19de893f385f39f550cb1dab67c2e97f1d5fa735e5ec96d6680066803e8a0eb010dd4399f654195513 +a0fb4e08ff56530a940a86c28830956eb6dec2f020f7faaea7566faf0a4fafe0cffe01480e87763ec22f201be51a6451 +92343c5b107910b203c64a79c93d354f7ee5b7d1e62e56732386776e275285561cb887019cc00d3fdbe3b5d54460bec1 +acfe7df83c4624188a1011ad88c1e1490d31a8a8c8016b40aebcdd7590d9c0793e80d2d7ce6a7048876621c252a06a5e +a7da001dc1e33e0e129c192d469d2bd6e5d2982eb38f3ba78bae0670690c8e70f40e8114a57bd0718c870ca5dd25b648 +a903de5ff97dc83628290d781e206ef9d7c6b6d00cadc5bacffb31dc8935623ab96ade616413cb196a50f533e63641d6 +8f9658d42ad14a60bbf7263f6bd516cfee6b37b91a8f53715d69f718a090ad92484061c2cef999816760a78552fae45b +8c15b72b3d5fcb9ffd377fd67d9dfbdd706593fba9629002639973db12aac987bd1db70250ded31c88e19efff612cdb8 +88a2a4034decd854fb557960194ff3404e239953818a8a891bf72a0b26a8e570a65c4a630884de991ae7452b3234f31a +a09cae5c4c190537bf1dd75bd7bce56f7b799762af865bb9d1ee970f6a133c27cce0dd0f14a0e0516ceac41054e6998f +9760ebb1b40f9a97530c3b940d4ef772a225e5b63bf18283f8e302b9436c5209f6294980fd37058060e429fb7fdc3a56 +adaa9400eb86d857dc591b25dbe3bc8f207b69e77b03cb5ee01f7e4b006b5c8f6ba2b51b5a45687479885708509363de +949efe6b00b3248846747a9ad4a934d6e4255994c2b540a59fbbde395fe96d69bb67908441cfadd8c8bbb561fe52da03 +a19a45504b6b1dc3a0fe0e6a1384734a3dcd5a7cb8fb59eb70e49426c4fc44946547443d558e5719a04884ab3a2811ca +8934c9ee21e8d1435426fd0f64232a0670a7946ec524c054cd4f2cc8b1be9f89cc11002ca8aebae646a2050d91716b10 +b1150ff8ffb34ffdcf7d603348c0aed61e5f90ee0a1b814079fc2a41325c75f2f9ee81542797ede3f947884266a772e0 +86ce8cc7c1f92af68de2bca96ccb732f9b3374dad6657dfd523a95e8a931a0af2a80df74098514a06174406a40c16ba5 +90faabb9ace9e13fd9584932846ab28a618f50958d2ce0d50310a50c3bc6b0da4338288e06e5fcbaa499f24a42c000d5 +af4a935c2d8df73332a16dc6da490075cf93365bd0e53e2374ef397514c30c250bcac569b6df443985cf3720a4534889 +b7f948ee90f394789eb0644d9f5ad0b700c8e44e5e9ed0e49da4cc18483676d25740710b1c15a557965da635f425b62e +a917913091245beed6a997ff7043ecf60c4d655c4db0b1ef1c704fd9b0e1ea1335ce8b9f45d6e120f81805ce31555e30 +a48099da8406399bfb1ba834f6f7d864111d0036969a5cb64089947a63dd9467d3857b605e9f57f5ad5f4ec915088d9b +9784c3f9be42eed354542b1446d734521f8e3f01cd9d495ae98f2e4a3a16767fe2ad909e0def5d9a6267f3fc6a172cd2 +8d9afaa323847a3226ad7d7b60d87322ffcda2e4a8df89f58a076f7972d896588de685a2e155e243bcf9456b0a0d6d1f +994413faf0b843f4ec1842c706c45ea5f24351c68674a27887bc8b182eda756856e507a4e8bbfd937e2c4c581b629ee6 +b3e72d9d1ddaa00c7d22f25462d6e9f2faf55e30d138dce8bb1517eb0b67132db758668aac26164fd934d732633bdea5 +8e95875e338f714e9e293df104f0ad66833bbd7a49d53a4f7f5fd5b18a66a61aa0a0f65cc31d55e0c075e0d3e412cb90 +b980091862b1a9f9334b428eae14bbf1cecb4849e3a5809773b0d071d609727270f6ad97f329eca896c178ce65883db9 +915d7ae5ae780bdba27ba51a9788a8852a15355b569581d1f18f0d94bcdfed2c1ed5a4f58e049e9825cda11f92b2c2d4 +83e581058edf9259d0b06128282327cacbb6afc939578223cbf93544599f799a8dce1fb21d52464f990a877086f42506 +803612a38b6f6efb97941997e101ac1878e192456f8fbddb3359aa7f3023434ed8fa92e60ec8e7b4473b1948850e4311 +864a1bf4ac046161617dde282e44ab3cc1843da01a09ca58aa00ed00eaea9351a07a9ec16d910819e7dcc28b8d2c8ada +922eb142845975d5f6f7dcfee6cac8c299b3730400e6bf82cc0bdd9888de21de9d9f1530640f702c003e1ed63b140cc7 +a7db03c5be647dce1385ebc02f4825a654447fa8c4c8d4b22e635dbdd2b3ccdf219384e49a80cfb1e9e6182b6e4227ed +a167289ff0f0967bbab6479e4a8a6f508b001bbe0d16cad36ab4c105ad44f3f180e39a6694e6cd53bc300fe64dac1e8c +b7766431f6379ce62cba22ab938cdbb1b0c7903dfb43980a417e0ee96c10b86b447241e9dd4722fa716283061b847fb3 +90cda18c5d66f5945c07c8c7dc453dee1370217ccb851bbea32578599aa669b4dd245dd8a9711b27c5df918eadf9746c +ac690cd2af39932874385fbf73c22b5d0162f371c2d818ec8a83761e0a57d2db2fca1d757343e141e1a0348016d5fc44 +abac820f170ae9daa820661f32a603ed81013c6130d1ca1659137d94835e1546c39a2be898b187108662cdcbb99d24fe +b2ea5a5950096772f2b210d9f562f1a4cfacc021c2e3801ac3a935f2120d537471307d27b13d538dcbf877a35ff79a2e +ad94af4d0699cd49ba8ca3f15945bd09f3f7d20c3aa282a3113cdf89f943d7793e59468386b067e3c1d53425dfe84db4 +83788367ec97cc4bbc18241cbed465b19baa76fab51759355d5618067009298c79d0a62a22e2a1e6dc63c7b90f21a4a5 +a3e142d879096d90b1e0a778e726351fa71996466c39ee58a964e6b5a29855123d4a8af47e159027e8e6be0ca93d9955 +860831f8d3edaabd41be5d4d79c94921625252aaec806251fb508e364e39fde8808d38b10d557e487603a1b274c9bc3a +88da39f334bd656a73c414ec17dda532059183664bbbac44eb4686c2601629ef8ff9da992c337a842e3885b684dd0032 +b50addbdf7164e8303f33de5ce854d6f023d39c1c1984b214d9e5fb6f6001cd5bdda816f048a438ff3d696872672f805 +999e58c4c69a912b84561cb09610e415b43832beeb95897eca8c403ef4754f4277754d492eef3673afd4362f50060fc9 +b88ea0f60f8119c5a1fd9294796d387472dfad22442b29659713d1d88e7d854cb7cf5c9ef773627781188626bb2fb573 +a068b3844e9dbcf74b54fd55904d56af754d8ce4c619fead7a07f9bfb9d02118db7c512ccec2489d2a84374ec1d1fb6d +871dee023768636003c799e6f6fd8d31315a4c0da7286345cd64264a016693b3485e0732be1bbd34dd5fa04dfa58a983 +8021e8f508680df12e4a5a1bd49f2d7142df65158b0a7198ffa83abd16053a542fb93ffc33e5279020ba8c6a26feacf2 +b5d3cd64df5bc965228b0bd4ce9e5797c409f7b64a172ba165e44a8e4b38e3d5fabc3e0b9a19afbfe427f887c40a315d +a54fdebbb594bafcefb1a03697711e0091c072e1cc24fb441fefd4e0a0518675a1d7b0966cb8294051d7ec0ac175d0cd +93922202337f72969d6d6e14a29c9c75e0420dfba712029941d1504b9f6f9761d706cbc0652cd09a1aa5d22aec766af1 +9711ebf1c7c7426190d4afd5dd03b014a456bbd9d90ed101623866a280550df26a629dde400c03ee3699f7d827dc0bb9 +b4d686d8bc5c1e822a50124c1cc23c6bc3a1577a3d0b8d4b70d1797418aaa763283c09e8a0d31ae6d4e6115f39e713c4 +a533ea2ac683e4ba07e320501a5d82a1cfc4fa1d65451000c3043f0fdac0a765cc1125d6cc14fe69975f3b346be0fdde +94ee563134fe233a4a48cf1380df55ead2a8ec3bf58313c208659003fb615a71477e5c994dc4dcfb2a8c6f2d0cb27594 +93e97d3f3f70664d0925be7aee3a358e95ae7da394220928ae48da7251e287a6dfbd3e04003a31fab771c874328ae005 +b57440d34615e2e7b1f676f2a8e379e1d961209fe00a0cf6798f42b7c28dbd03172fce689305e5b83e54424bc3f4a47c +97644084c6f7b4162bc098bed781dd3af6e49e7661db510975528f1dea8154f3d87e979bcae90c3df3a7752eb0752889 +a923b27b225b2a6dd5bdc2e3d295b101cac5b629a86c483577e073cea1c7d942c457d7ff66b42fcf33e26c510b180bc2 +86698d3b3873ed3f8ab3269556f03ac8d53c6e2c47e5174ec5d14b3ed5c939750245441c00e2e9bb4d6f604179f255ef +87946826d3aa6c7d53435c78005509b178fdb9befc191c107aee0b48fbe4c88a54cebf1aae08c32c3df103c678bad0ca +860864896c32b5d4cb075176f4755ea87fea6b9cb541c255a83d56c0a4092f92396a3e2b357c71833979b23508865457 +b78fa75d687349e28b4ddfe9e2d32bb6a3be13220b8f3ff1ded712088bd0643da9b72778bcca9e3b103b80097f48bdd0 +8a188b940446598d1f0e8c6d81d3cada34c4c1ae0118ec7e0eacc70d1bced28ae34b99667d5793d9d315a414601c3b22 +842ac6f7dc14191ab6dddffcbc7cb9effba42700a77584aa6a8e17a855cd444c5d138f9d61bf55f43c6ffbcc83f92bc9 +b6742902c3d145a6af9738c01cf9880dd05c85f0d0ef7dbe93c06fdd6493333d218339ebc2a02be1895436a2f734a866 +98bf18488483c627b7181b049d3e6f849fce1f15794de59dcde6e5a9b0d76fd484a46e48822a6a93001d3aa12f48bc6d +8769cac10bda8c53a1c19419ef073a5998f73dcf2ba1b849561615a17cbc0a49bfe3eb4ff8801dd36a22fa34b9a3a7e2 +b45c084d58028fdfae792210fcd183abc4ffddeb4cf52ebf3f8a50e4c4eec2a2758f1241b0920bebcb24b757c778577c +85c1216eec8e1fbc1af9b36b93c5d073a81d5fba86a6daae38748ec1573eacc6bef209e76c87a6efbd7a3f80e11d4c3c +b8007e34bb3f927ec06a050b51e633d7eb9e9a44715d5b39712e69c36177a03cd68391090cc3293098e54f6cf65f6caf +8e85527b27c9152b1ba3fdd532a76a79064ab097570508f233e09978761dfe3012d537411b47d0e4b65265eb32cea2ae +899779f3c31a20b76068ec8d59d97a64d2249588ddfd69dcbaac6bfaee8ce0ff3c5afc4e17c934ae7cd041b760eb555d +a5dac3d8f5fbef018509612e25d179f60d2a62451c76426bf546e9666fcdc73263d34aa6fa7e2bfd4c9947bbf5095eff +896900eeef9be2b2e755128e7b1c436af6fb3984f1e66c444bc15fcf3959013b4902c381f0eab1247f878a6ebd1f4ee0 +8cb17f4b0af2e9b2cbb56f46e6a5d6874ea0daf147aae77303020b4e592ddc92e0dd058def7da96258b3a68b223bf22d +a1b6d3f09a9fa7ecc021ab7c5396541895da6e9bf1f9a156c08fc6f2b815a57f18c337ccfe540b62d79e0d261facb2be +ae70888811434ef93da60aeee44f113510069fd21161e5bb787295492eb8df85103794663fc9305f04adcbcf11ff0c5e +a84bbc8624100acfae080ba8cfb48fd4d0229a60b62d070bd08fade709efc6914dc232d3f7bed76a59204f9252321aad +aea47d54652abd8ca213cfc623c8e30780f37b095b59ac4795252a29c2b6bc703a5203acff8831314478b8ee8771d4d7 +8dd438eb8be14935f759aa93021c2b24e1d588f7a162c42c90ec3a647b0ff857f60e24c0a8953eb7bb04e04be70f11ce +922b07b5469680a10e7532766e099896f4dc3d70c522d8add18f5f7765d4ddb840df109146607b51ceddd2189fa7b9c0 +83ef6ebd0ae6c569d580093e8b0b78daa964760556272d202d343e824c38eccb424262e5b7809d3c586f9e2e9c5c5f22 +97f98bd357db6e093e967fe180cf67ed09fa711580a5ad48f07cf095b2e8fabbe6319f97d1f15d62c0ec2227569d8dbf +a1953a4a22fe6c2beaf2a5e39666b0eb53018af6976e3a7aab5515550ff2efa89400605a43fb2c4ac1e51961dbd271d8 +a5cbd67f4c0bc98e20aa74c09e6f5fb6f42c08e59aaa477b4b4e61434c8884bc14f17cf11faecf46dc4b6c055affbad2 +87d96818f2c4f12fd7705cf4060a97bd28037c5ac0f0cc38f71189ec49361e438ce863e6617651977708094d5336d1da +85e7c2daae5fe59f8a1541c94df50402a671a17dbb8838113fa4b7aaff6114cf2bb5969410cf21e6a162857f2f7a83a8 +a19575083e1731bb04bb4a49414e97aaadb36d883aa993d1f6847db50007315444814740e67e10177a14e0e074fd4c7d +a00ebfb5bcc3a6da835078189038a1e56b7dab6be74332b5ff7440e53b0f9e1eb9973effecbbf37000021fcf50c7c1ff +8969d7943abd3b1375fdfc7d6124dde82b0f7193068ed6ec83bcf908734daf3487a6a30f7b322e54a4818ae5f86d91c0 +b959c8d210fa43af9b20d1fe0ea8c4921280eb4544ef6ea913309ff9d61c9327096707e84dc1662960519be8e7d080a4 +9011d8ac651c42e0cb03931a9e960f58e02524c6b666047525e3b9097e9f35fb2b4b278efcce2bd5ad463c6d7fd56694 +937e3b22ed0fcdbd9ea5a1b97b84bbe86b7f5b2de3866a930611112f2217f4ee7d9822c4ab1253823f77bceeae0c8e10 +828997e5d121f4c305e018a0a0ba338bd6a34a7b4dc3c5ceab098ee57490311c130e2c045b9238a83908d07098d9fc32 +8d114808eac0f2e1a942d80dad16756ec24f0276763cd6771acb6049472e05a9bb1d3bbd5957f092936b415d25c746b0 +a063c5c26267ae12887387cbebbe51fd31bc604630b3a6e8e177e71d4f26263be89112cd12d139dd4c39f55f0e496be0 +ab1e1582c8d67196d10f969eeb44e6e16214f1316aa4a2a821f65ba5834326da6cba04373eabfd3b3072e79e5c9717e6 +a17b1dbaa11d41457e71a9d45d032448091df7a006c1a7836557923ab1a8d7290ec92a7a02b7e2a29fcea8f8e374c096 +a1ed7198da3591771c7c6802a1d547cf4fcd055ca9010756d2a89a49a3581dfe9886e02ee08c4a2f00b2688d0600509a +af09aa60c0a185e19b3d99ffdc8c6196d8806169086c8ff577bf3801c8ab371e74165ba0f7329981e9252bfe965be617 +98c04cc8bb26ffce187fa0051d068977c8f09303a08a575175072744e0a5fb61191b1769f663a426c30d405515329986 +a542bf1c9c3262d488ea896f973d62923be982e572172e2461e0146190f2a531f62acd44a5e955a9f1e242b3e46d63ae +aef7b7f30efd50e4a66c87482386f39f095bff6108e68f74fd3bb92156c71c75757912b111060cdee46a6b3452eed657 +8afe1e0ccd00079702f16ab364a23bbbd3da1889d07c4f8cb04fd994bf9353216360dbd364492932bfe20b8b69ae8028 +9896c690999db3c08cd7b25efb1b912c3e0f976db98a3e830f086aef93222d06ce570a7b2babcd7c81d8f9955169669c +ac7bcab6a281468907ef1ea8a6c1cd624159c88839131bef6aa0c22f331fc87ec6128a2c2a333fb79df549e4587e1a12 +987935c08a30b099d19f96901315a2e60591baf898581c40bf5eddcda806ff24a4536e30ed1e6c0b128a83fc77b6e81d +a0a6945bbede3bb09a4a09ef27baa20619d3e15af5673b9350601bcebe952597c989870746cf75767ffb73b32c6c9c6f +b0f5590079f0a0302b08a0cc1b7a5f39cc6900c2a5cdc7baa333d8328a731b2df5dbb67e27a154d3c44ed1a795fc4adb +a7294bdeea210e528f277f3d50e89e6d79950494478998181ecb38de675020130256f2f2a075899170be964d478458b0 +8ab3041b895a631869b439d5599a66facba919226ca9b39d915f19d59f9fc82393ea781377e9bd3bcc5a310e41376914 +8da399b59151fd48b2579948bb82698e3c9804d70ec7d6f3cc7e82901f9f2de5ee850349a7d6f43e5e9ebd47bd78620f +80e8c32de83d1083916d768b11a982955614a345d26d85b457f2280ff6c52bb776958add7c1c8878f7d520d815b8e014 +81bbec7bd99d2917d2dcd8a288722fb33ad5a4bf5416fba8609fa215fb80e0f873535349e7dc287f892aa56eb9e39c4a +9665796fe04c8519206fba58496bc84a8b9113e7ea8e152b65f7f732e88beea271dc97b1ea420dbc8257cc4b18a77463 +a97e342aaaf693ddc87e02790278e4bb50117af4413cd703bdf3b7cad2d1facf31fde1303b43ab2e0265467474f97a8a +925549ebebed348886e37773b05cd8ad04906eca4536bfed951d1ee41b3d362ddc6e1a302c21ff3a2d1e70e95117922c +818fdf74d7903502101551bbf48d3c7819786b04b192d9e94362d2fcb85760d8b6f45165a5443aa5221bef400525ddb4 +a9d29de7e8fd31b59f4a087168d062a478b1329cd3c81c31e56de4fb40de7a5be9a5269ef0be452c487443a0b097dd50 +a85286ad573db4c9aa56221135da1e31d742e0f6ff01d6b159086d7258f78b08dad55ec8eb5c91ee9d3404b2eeb67e1e +92a79b37db5e777f9ebbebde24a95430a199e866e56597c7d0b0e7fb54c7b092c2f6cf61fb24470ddf250cf609898281 +8d79f5ca67ed67d52c82949af342a9fc60fb793c47c76d84b4863c550796fcae2dd59e285897c6fb96fe31cee1efa62c +8ad2e0bda03415ab86324992bb62dfa3612d2d003765bcad1468087c27971d08bdbae5252681f0115a184f4885d444e4 +a08815af979286538c31b4aa5ec805053790af1ca58a8c4341be51136d094a8a05e569d876a079033298ad355ccb7ca8 +b96c2978d0165d619d08281d295e90df78bc2375d0afbc3142ebff9c2cd4b0f0aa97a9a0e3740bc4dce0ff8a9fac8252 +b7752cd0e582f35ab0d0036ca9c0a9fe893a6ad325164d78d865a604a85d3d23729e0362553e8b8a3d51816beeaa30cf +99cef1fafc29e7adfe247c753c475ad4bda7a5f9558b79c86e8a65968ede67adb38dc30071925c9d66a13860027a6735 +b9f6c65af178c791b6137d71980651fb09cb5b42f268999c728c6e129985a9c7d77b3dc3b50751bd29ec9ee0b3111dfc +8d73ae61fff5be883a281782698075c5650083f00399992688738856d76d159803be0059fbd9dec48f4f0432f0590bbb +a8a4a2865226de9bbf19e12c7e75318439fa6cf1cbf344d5e79a8f363439d3bc5bcf4df91b54581e7866e46db04eaf0d +894582aeff222e145f092ba15c60d3207340c38f2c6792ee2ab4d82d50fb544ae366c2985cc2b6c2f970bcc5f4b46385 +956014ba2d20a056fd86cb8c7ceeab9a2c6f905dae24fc1c5278fa5b84335148ebdefec5dcde8eb9b084700724fc93d7 +af217fe2b654eff6d11a2a79fe0339a1d4cb3708b7be9f09d852158b5a44b4f9b04406d6d67c4f144fb6b69a41ae9d0f +a90752a784bc00df94d960e523f5596695d16a534fc806179e0f878fc0e82a91b25e758e91a165debd815dd1af5f1028 +a697606fb32979549ad822b31df8eaaf50de4ead984439a0a33e955937d326519bb9f62c8243ad37f764655f8d32cc80 +a3ad4a30922e45a3e665551e5611384f1c2d414f6fa806184b0c826af05f014dc872585e255543794ee41e43cdadd856 +b29c255843a82ea74a013bac6c36a694646e61e6b9cefc4c130e2ee261e3bb5da3e0fe3ee7e6fbb009deed0530bc1c82 +87e1cc7febefa829cf050aa2aea59385d1048f8617abba691f7ea9ef58eb90ad12eeb9c439af228b0e34897ba1cf1b47 +994d3222f89e9c8c154362190be7167c8c2662f0cfa9d50eb4d8175b255ff0de09dc548ee312fc8226963c8c16f43e8b +8f1a980be640820f2d1e953264ca4c30330878971669852be3d5d6b41c488be1628b935388bfa2bd4de484acb0fe661d +854d90d0721579c8c88e147a4aa83553c960617b18075f8224b975562dccb30b0e02e81fa9df7070f356a0eeffc3b14f +8e156da9d4330a03e32a25a2f0b861fd3ea5c719fa4f834119baab6e5fa5236a9baaf0d44147bf0841418900037f6eac +96586fc49e53a6799242ddf617000db5a0ad20c6cb1686af2102623d64a71aaddb8e468b15fa6d100d0384e448548db4 +b44d8d85c8df95d504f82d597f8c515866d4d4a326fa1b816dcc5bb0cc4ef1a52647aa5d2e84c62e194c01cae0885d21 +b75c43e676a7efd199f8b32ae31f176ec667e714df355e9eecee97246f72af5bef9c5b04c11e7e90fc37bb9163f957ec +a49835ac0565a79f6a9078cf0443c5be20561a68b448289589721fded55188583f1d301925a34eea647f90a6e66c6774 +b47c17ff6824a00b8f29df0adb7f06223208d062bd703b0f763c6eee4ae62d4217eef2da4f4dde33f0b469c2f2db9e42 +957cf039cea6f6d41e368e2bd0cf77315938a0738f15ed9ca342f0a28658b763659ac1d1a85ecb362f13de12b77bb582 +903a52f8d2439fa63f59e1e9aba864d87b0464ded63814474947112375236a6f84e8fa003cc4433c8208d80e05fbd1b0 +8afd524209ff08d1eb6312b078f7afeb8e1155af649e930ab711dedda226dc2db6b0354aab9652eea7f433f90015bf7b +a95c3c9277b11bc8fe191773bf567641be57c0549913b973fb18740ff9cd7b3f7ce198fa4dc1086b2b8a446012459193 +9455ce8163fce04aeff61e7808ef3aac4725e51404f0858fe5d39d7344f55dcc7871ca332aa5cb1a63a4399529e48907 +809fa35b6958f94e781f2c584438b33f5ed528a6b492d08960cf22ecf63ea3aa1e2d29bc879e17296e0a6cc495439cb6 +b0f50774de212dd33e5837f6b496556215c665437e657f674fc5117e5c07dadbd0d057e6ac4c42d50a8eb81edfebf315 +844c65e263891d0b2fea7db6934cc4b7fb6bee2c1d0b9ab4c47f2eb3e9c5d7197dad828d38c54139123740151420280b +b13c78c9efcbb3b28eb3fe0b971380b7d5151c80948a99cd93c78b4c3ab0e86df6226a64d91e0a2ea4a1c0a46bc0404e +90300a541decad460c348b8f4257f7a29687b2362ebee8d92fd03cc0e85b285ccb0ab1cb2ff5e29c5cc5295e351017cd +ac49b409ded770c6d74f6e70104c2cdc95b7b90609da0743c9923179e8e5201ead03becc0ab10d65b3d91a5be0d52371 +a257b815bd8289dfdfc21af218aaba12ccfd84ebf77642cc4cf744d9b0174ca0b0d7ab2a545c2a314fd5f63c140f41ab +a34778d8446e4d74d8fe33de64b2694ef1e50bc140e252af6eff3ce7b57acf8b6577a02ba94b74a8ae32e5113cf0a29b +ab9e935bcf0d8607e3d66f013d9bce7909962cb7a81174923db02dc89e485c2b1c33d6065bdc7bbbe0450b5c49fbe640 +94d2c5c5c309c9eac04be4636f61bc47fd9579b47aded57cc6c736fefb8dfd8f8a5de32210f7baf2052d04c0219d3b4b +b8dda9046ae265214086355101be3460421f7cd0ed01bde9c1621da510941d42bc93cd8060fd73f374fb1b0a5f38d45e +a6674649dab5f92ab9fa811d9da1d342cf89ff6eff13ad49f4d81de45438e81a384098d3ae5ccce4c67bda5dbe246d95 +8d619f7564677bacba29c346c4ef67c211f7a3a14c73433dd1a7692e16a7e2562f1d0532454af62fc04c2fd2bb1789b0 +a2b93d2fd4c707f5908f624a0fc889e20164d3c61850af9125f47a1719757a6ce6375aa1910eafa4c1e8b6e20c312775 +a07d5585447654d82817ef4d199984542328b238157976eb9a267f0bdb2229acc25aee510be68f65a312b68fdd9e0447 +8ef55cf95e2b24d8ec88e4136399a7763bd1b73d5e90ea45e9845123e9d39a625cc336e9b67988374b8ebcbc75f2ed21 +b62c1fc32e27c767c461411b02fe9aa44a86586e1427406f4ef0b346d077db91952abce79318b382ec75b7be23058cac +b252900345f5fa15a4b77fb6af6a2d04db16e878b7bd98005333f7f6e3c8e6e46cf38fc5d1b2bc399c5c2ff4af730dc6 +a4ab5ac0cc15d3d17b1747c6e3133d586870eae0a0d9c8fa7fd990ebd4fbb62e9090557ca2792a6bc6271856aa3c9a05 +8e706b3f2e902faee10b22742c6c33bea6f670a8937c243db96885143c1db5c979e33ab73a38359b52b8d668ccd092a9 +8a6792190ee6c959d79f60c22980ca140c638d88d75660adaf9bcbe6dc4692ab5f01e0c460170f09f74d5e582e85ff1f +97ffeedfc94c98ec85ea937e064d7b290a326838e62cebd407facd1ab4f08d9c0c109d79af7cb6170fccfa6c8243c127 +b79970b67c09453614ffd83a0c923c17f857c6ce3c87a356298f8351cab0def7ed83efd4f6638f48df67e07bef4ad9d8 +b90f1931c7cf1822cc0a97401119910cdfd0482daf09a4d7612e4e05046295cfb4cc50d5214b31676bb1a1c9d15f9c7f +922921ad813c01fb5d12fa7fb7ed8e0b0abbf7b19affa190b36013c55b88fe3c7df0ae663c970eec7725ba37b95a7cb7 +a124f33e7f28feabb4089a063a08d52b7395d24eecd06857a720439dd9414b7073bb86fbd0b04e7bfac62d3dc0fdb2f2 +b252fe50bc6677c004550f240fe670974a33ffe7191ed7675da6ac36c780c2f8d02be7da5d92cbe2d0ce90147847f8b1 +ae5f8c9c56070f919f3df2d2284348fa4b2e39881f7bc42c9b2f5b7cb1ebeef8ecac000f37329bbe04cc1680cefc7f4e +b432a4575caf7337f11eecfcbd34a6705d0f82c216301725ceae2b3c9df20fa53d1ebef65513e305013d1e0c2df522b6 +b7c016fbbc4614cdbb12db1c9ac41f9a45d5e5ce82594d568a30cd2c66c3cc9d91a2c959697b67c582a0913de661505d +8f6f3e5e0347dddc1b2a34ec0dbbbb7cafbf976f19c9c902efb5c1427d1bbd4b71abd9f3fba20dda75c35a39393c989f +b0042a1d33a1ee9fdf3fad2299b8d70c4f1862d8393b5ebe3ac2189a2c5a58bb826128cd7a39b70d524a6dd976097e26 +85297c4e8ae8d9b44c3fe51aa926c77d55db766c2a9f91b659040de36e34c9a4fc6f44380f8d61704498f6fd52395a49 +8c61a988b6a00fe5a277450f30bf6daa932e42a2eae844568e3babf8815e09311f3c352dae6eb2d57a98d16b7beb2d22 +990be28aaecd932e7edb2a97b9be2789a3905cb88737b1c79881302585801c69a3dd5fb230808b39db1352fc06e0b4a8 +82fd14bdb335aa46f022dfe0ed4d631911e6b6f5eefb10d11e9e2e02a7df55012ed8162249d10b58eb76ced5a7b06cda +ac39cb058df764e161db9c39b185f09aa210bddbd66f681f1697ddbe6b305735612d5dd321d3ffbb4876771bdb321e2f +858a3f7e57ccb81387caf8e89f9b6039e9aadeab06886d8688fe6427151a59ab2e77e85ba850c67d099965426c97779a +b57fb9ea623cec432946819937c6bded0b5d03c8c67b52b44a4b67d34adfb055e6cabca67a48e4d859b4be45162c5083 +b84d2990b563d6d7fe1f4c1894989db25b81745090b94b1fe2ef708ac3b2110ef93d647820b2a51fcf78e3f00fef5412 +817d85b9f5e1521733d2b1fa6d4f4957ac445dc803f97fc495e20b819b14e651332f9e0573d684b854fd47824c53f0e8 +b09e18e97e93a8523101af594422fb71afc5b8826002314269016fcc1b44002d91bcb7c90d923d460f0cc03bddfe9af1 +b867cbede82102de7cf6cd0dae68506869576eaa66c3fc806e73585310602682fc912dc37adf5ff6f0f34a07831735b1 +b1126255798368b692f2796a3470ed16e5ffdee2d8c9e0f7ee3d2e92950c3e6365c32895171c3494aff2a6d6356f7e25 +b05f0a0996dec16335c770a5df3f0b08e20020c838c2caaa1d3a4a2490ede98552f5de349de2ce6e4c4a839731d80919 +98c512bb91c8fa191120ddf5d63c88076581cf41e15eec3c168822f12b3dd0ce4d6df74a7e3093d3e35cad1cb3135421 +84ce38fd97f7f90012c2c1e59a67bf9f465a7ccfb6f308bdd0446cc82b8a26ff7c30e5c7cc375011718cad1b31adaa9f +93139db52c9fb96dee97a0825f21e34c5d6d36838e1e42f4d12d01eacbe94426c85a811fe16ca78e89e08f1c27383d28 +81454037b1e7a1765f67e4288b8742eebf6d864d9b0f508ab44fa3243168ce0ed30cb5f33dfcdb995cd2c2710ff97a6d +828deb2a26efb2ff1842f735e2cc27162360f619b6e3e27a85bedf384912d4726bb2759a3016937973092ece1bf90540 +87e5a7d4e7bd301078f625d9a99b99e6e8e1207c9f8a679f8ebbbfb467bfa0b5f7ef4a4d577c7d2670efa88221153012 +b9dc9d0ea48deee201e34379447bec789c8924aecd030eeb93db159af77eff230976ef60ea9f4b4a9e9e95c1f9f4284e +aa6528268d46bf0627d87d58e243d3ac34b863513c725908a2617e4c6a46ccb1d8c8334bd6dd0eea7ffebec44259dae5 +8d26c9ce07293f6a32a664d31e6df9a7ace47e6c38001635918efd9872aceab62de7757b13b783d422eb67bd28ce7bbb +b0d3ca88d9829a7459b89b0dcbdb8bbb5180b00d750bd959bd110f53c2dd5d4db554b6005c4765fbe7ec5903669e5ebc +a94d1c72bf3b2dc6bfebc9dee40f6a89a516b252bd9f4fad96f156e3dbfc151a9b8a02324d764c7656d59230a18eb61f +88996e79171e30b16505638d8ecb25afd875e5f3cc3e29860937f2b5e751c66e78dc77f744a0cc454a8a655142a93ffb +af4d94f342665fe7ecda318de6cf1bc1c40c37dd83d060fedaf827459728152b5f0e280286ff5e6a0012036f6715f53f +96beaa7a2d565ec14a4e5cb895d33624c69da56b75c8d06ac729cb6d0cb64470ed4f9b0387083cd827b1609c8cabde8c +96b773fa2fcb7377bf71a7e286f37f1f24ee42cba5b4f33903c4566e5e5bcc501ea360e3c8435749107c3de84e272d8e +a69ac6218454c3f40ad0beb48821a218fb0a4f33ebade986d2fffd9a3900d8cfa613bc71676c46cfeaa5f644d1f239a9 +857f139c08fcc45370f448ce3e4915bcb30f23daa4134407fc6d78efac7d718b2cd89e9a743eec7bf2cc0eccf55eb907 +adeeba36af137fd3c371a2adbefea614c3ae3a69f8755ce892d0dd7102fb60717f5245d30119c69c582804e7e56f1626 +afa97ca3548b35aeda6bfed7fbb39af907ed82a09348004d5705b4bb000173270ce44eb5d181819088aa5a2f20a547a2 +8423bd2d07073b0e87819b4e81997e4d3188b0a5592621a30981dc0a5a9d0578fde1638a364f015078a001afb00891c2 +b92e9d4ec3966981ee574695d6e4865810b8e75313e48c1e4bc5eebae77eb28740e97ecc3e5c42040f9eb1ee4b13b0ea +b07b218321d54cecfcd2ed54a5fd588a6be8d7a5b6a66dff7facfe061222c40553e076e57cbdfa0bdb08e0a009c94ba5 +a71e1ae4d6096eac9ea4c21f621c875423de7c620544e520fb6ec3cb41a78554aedd79493cbd2c2ba4f0387f902ddd2a +807cdac291246a02f60c8937532c8969e689b1cfe811f239bfdee0791e7aa0545e9686cfb9ed0c1df84748e5efa5e3da +a1faeb4504c057304d27d54fb3ec681462384a354a4f0b6c759d4fa313253a789250c6b0f44f751b0718592637438a19 +996bcd3215182d49f1cd15a05e1e0a4bf57e264400bf14f7253c6611d2571de7130cce81fd28e0411e0a80e9054f4f98 +89d15b38f14bcd46f4b2dcae82b0e7bf9a35e40bf57aa947e9c4a8f87a440b5cea95229708de08ca596762062c34aaa0 +8d8ddcaf79374c750b8b0b3d196acb6bb921e51b4619876a29d09161ba82a42271066187211ef746f9f40a5ca17b75f7 +a3dc7f70f3a6c7edc483e712770abbaa94bfa3174cfee872b2cc011b267e0ef9baa1ab49e4a6c6c30dbba0e0a1237117 +aa9e958bbdcb192b19c43fc6fd34afcd754949fdada98e9f4848e8db0e23acb27d19dd073c951a8819000f2356aa22e1 +a4714e45ec853eadfe5c3bee7f683b81f97857bbd7833192a48936dd1460aee68f700a21658658b74b737c4fecf90c7f +a1ecab4215c1892e4a8ff3405d710163875e5dfef8a8cb84f5cac4e317d89c7696e3f496ed1747ca6f52b304190f4ba1 +b9b48943eca3686219575026d395b969e6ff8159dc5317005df090e79d26901984e40ae4b1af060ed3ff6f42e0417d76 +9644b9f90a66edb0396abd8c00066886f978ebf56fc22081031fbc9ce371bf9b04aa5a4ef59e59319b3a05bb7fb88b43 +b2bb14f1c055a78596488e4e2d4135a6470c1ee43961952160b8498f674a4d23040606e937c02c1fc23dbd47e9bd4633 +8c61f2fce9a42b94a389c7e52d7d093fc011099d0f4914f6d6f05b631df7b88182826edf9bbb1225971a080ca5c0d15a +aa6a7b8499cc7d256043eacad18528d38bf3be970bea4c6d4cb886690280bdb373688ceba3e506471e1d9493dc76f3f4 +8127703363b3b35b06762c2353d4de82b7b85bb860db1028d3640f46bdb78f2d104fa77ee3e0d9db83833d2b12a966f8 +b7b01f5909f2c66ae0fab156be5d79954e3a304615e1fe55945049dd4bd95f973bb3821117eb54db7e9ed1ee9a527652 +8be47ba5dfe212420649193490838670c40540e0ea24adbab18c4a66e7ac3dcf94f068dec2533b60e08c1f64e7533e54 +905a6c7e24b86aa54a05c329a6b4616d335bb0b1f1e9987562eee0acf82ad302c7c44981a1dd6b24c6121ca12fb92996 +86969ccfd91deed93b355a2c21319e3bb08cc652b741463bf68c626b7ba2afce3f7cc397f2fb74588c2893477c948ae2 +b5a9d20eb12c331d0d300fd4b85b0ac0bb74573178a5fac8ec9dce5e95acba07fab444260355ece442a846737a2dcd1c +a13497c11df21b11fc1a63b0ffdcf7f432da4dc2c98f8d07d36da4fa68aceb57af2158088e5b05e334fe0f264aeb7a97 +882e4597cc66498a45e86a2ed9ee24652da4699af00ad35f73b5e74fde6ac3cee70630962d5ddd86162d4aaf11bbc11c +b748858c2bafa4a14ce44af35195e9c52aa75e109719243bbe278095acbfd6a7ae7e084caf8dae6939039b5a4e8fd675 +83a2e0524507e74f51fe976441108f8226ba1b3a33f4e16ec45c5661ce80cb1840a93d17122cb8ca9e0f80d14f69877d +846cd2946c93ee5f24243d9ebc69936b3a1a6d59f45fec6c79b1eddf15ce30a8e73ad03cf606ee66baea3d8ff115f70f +8d98d0a3a94f6efe158f8423c041b546416145c5c2254bfa157efea0d1c99fe58acc7df6424ef29f75960b18d664ea4e +a39fa47e4b79f54dbf59d0b1726f1e78bc219fcfc56ad238c84b4b610e7892ff1e65d537baf5118a32f5e2eb80d5ee0c +8c30969a4519131de5e30121c84c04f67b98c8ad109fa4710dd3149cae303d51778add3f258f0482f1c89c169824dffc +af7f80d141ceb78b4762015de17fef49d7ff6202d292e9604deb508272ee7569f7fd5be3b2438da1dfecf0c26533ef86 +97cf82f70128251944d79b8845506975405bd720e150d836205b048ff36ba8801eb74cdcc6425f28f6bc0acec0a81463 +8c276c876eb88688957d1868bf3a1462375e608ff72b49870a5dac82cbf6584e00e3f36f236f732348a47502ccf9539d +964765f1a5c8a41d8025ddf56dc01b78424703d8a64a4e5539e477cb2445cb541c70127c561e717256d13f91a830ba83 +a2aacd9e21b8c8efaf2319611addea1b9f41430aee42e7f2a640cc693aa395287cc8fdc2806b76b577d84fbd05378ead +ab11eabbf5be4345a77323a3b75f9ee93b011fd2a9d0154e88183cafe47f82a7888666af16b40d3cb677c94bcc755ff7 +a0bfe715a7af5a29b1b6148b8cbee585d2b49fa6ce59bcd173ea3bbc60d71a62f9da27ffcbbd5a6da75502112fe44d70 +902e6cc38ee42245103d90b65028a471bc7a48b825599d361aa81d8c56e0fcf9fbe8d4c13802040d2cfb85b7e022eea1 +8832e2b5014fdef4003bdbb87e3298fdbdbbe49673f6b66e2373f1cb2605f9c4af2cdf9bfd45d1993208681d29ee1c9d +a7d39d3fa1ec1e0c87730fa43d4900e91932d1cafb36c76b2934907becf7d15a1d84d7234591ad4c322b5a24673bba8d +836ed5f09d99624204aa3aa7ac601980fda223f3b4b96b4a8fb235c574a3545d518787c12f81bd5851987f2860d41886 +94235e94445e6086f6e9331923262070a4c2ed930ec519eabb8a30133bd4fc6debb99185f4b668431fae1b485c5c81b7 +9828ffe20b9405f117dac044159be2d3c6e2b50ecdd1651d6a73f7633e6e2a7ba3d783ae939973604446d3a1ef0fb20f +92f03dc365dfe9154743ca70e6dd2758f064e3286fc543cf8c50f68effdf7c554bd17b3507c6ff4127046d9bbb5522ef +91ed07df479d8eb3d31292a0e987672a7f3d45ecafe72935b7abbc3f23493605134ce573f309e226c9efe830b6868220 +93bee582661e6d6cefeff29002afc2f36dd2c13dbf33f0574c35b290ddc426170a5f7f196369ad592efcd72cfb6f8fc0 +89a51467d966f48fed15dea5a12dda54d0015f69e2169b5e34f44c7b5a5d4c282d6f138116a0cd06a8476980e420f8d8 +b8ccebc14b6679ba2399370848864f15f63512fd6139df7359b7b93e82c1007fd85137ecb0597294b46643e1a9e7ab5e +841fa301567fc57b2cd09508ce75326684e12bfb8add671dc208f579b2500b93d5b641e9f59bba798ed4ed1259757f7d +b3cb45c15eb00b4ccb7013299f761cb8fefc17adf6db50e9ecb8abe927a3bc7f28e359e64693813e078e1dac800ad55b +96e55d3b9f445f5679e34fa5425b3e87cb221cfbdd07f8353868c7f7f4ba388ee3841cb9a1d638583bc20d03a9d071f2 +a7dee9377de740270c5b57cf86699004ba8dc2766af56b388b5cb0814ec71bb99ecf43ee3d82a552733854ecc7def0fe +b129dfff23b3c1c95ddb214c4711961fcb129efe2b6557ec9e116ada909593d0d2eec2c628434493393c58c52aa86847 +aed2670e201cb3e38a8be3c86735a4d76255e1e5a4c67b91df6ed262d09c8d10b0a3891da3e6ab934058cc9a7178931b +b20b8921ae52e5b3c94fa3a8b46489044174f7b897779e7763d6eb419e808d76705b7e7ba5131576f425aa81b6b0de53 +a7e45bbc3ba1bc36617291ba7663806e247f1b57a89e31520c64a90cbf8d426cac2e2f381338baf78c8f92fdbbcb7026 +a99e651e73a507e9e663e2364fcc193ec77e8afdc08c2bed6ad864e49b537ec31e9114ee72291a7657899f2033a849e2 +af966033636c2e9e8280d173f556fe07f8b6940bbcf6b2df7e2165c30bea66cced2596f6c17ca7c1aa0e614174953ba9 +b69ca7a79e3d55ef21e0ebdc6f0c4bd17182d30cf6290cccca7d2551c91c12b966020d8e40e4ee4179488c9809c03ae4 +b981cd36244e035fef043f70b1d7188d7cd045b4de0581c459fc5730e10eb7f3d5893b54cc4243849c0855e4e621167a +b20fea858a36921b35a3051ce787b73f70fdecd3fef283c15a2eb1bffb1dcba5991eee4a047ce4e87802da923fd9457b +b040e6f2e56dc1860274c263d4045837456f74b354a679f6b5ea70919835ebe5d32bf1f519e218730096c98ff396dc9d +8d2dd60e702c923a7204b530e7d6c193c6f93ca648c4f7bb38f4edbeb0aaed84184213afafb8db6aeb9197c24364276c +95dfa7348709e43d71285b28a0bfad3ca805b6ed4ae99753e9f736c79d58a35a3a50b42760ccdd03eda50f6e59494968 +b8585632a13f18c139a411bb2f02df809591834d127cd1ff081e26d0abfe0e3fbb54abea26538b25a0dcb4d7e969590e +b46ba47858a29c6d523c9982660949567666daf2582b93393a4802a9e077eedbc0d49d454731696bc8e46ca50c7caa40 +84b756b901b98a4404e58d70f39f6ccac877146c866732ae65e7e82727448d1550343bf7cdff1bfd4ee1ed73793db255 +83e5be888eaf877a2c755897410865f64a6d1169a8ccf0336092f3932abab915e542ab75a35ffe016042340d581ee987 +8cb274fc39285aed451a7def72cfbf73168ee10be02affe355a2bf87cf361a81ad284e9334cf00c5bf99a13d9f75e116 +91ff6220924b94ae13f50eeac16a159232e4f16a73fbd5c22c0e185cd1998403904d36bad203baa82b85819ee4a8ac10 +87f46e08e09aea2ab37b55fc300689d9b58ff3e72f1cffe023386035888f714fac4673c7c5193d3f3f3c568c640694f0 +835d7d84ca7641e1b15095830114aa6072fe12260d2202456cafe2308c22651af9ffbcf6b7e56af97167dd0c4e2a4cf2 +91202183f79794f114fd9e3b9bd05553c0e8985919965101a57d97ef666b028863e6cea9735af016dc1864f1542dee51 +81ab2b02a9b0a490a74ae615ddd4fe560734c1bfdde6b8dd13303c1481ba0e8ab14473535a93cfe4e824a0ab29445f8c +8a32d73f4fc006551d4e2c61eec6130355ec9b8c39a65c24ec1edc00e80155ca83a8ef2455e892521a3d47634d82a987 +af70d7b8f13bc90193cc1cfb0c400c4224cf10f1887848aa93e6380f7087782fc41a159926ab53c53eb95c2383b1a849 +989bf42f9d357c51774f1c7c0f7c0c46a8cb7398a74497141c32685be098e38b4230ffe833a6d880ec391a35b1a747b6 +94cb6715ee95700020c630b8c19e35f231de970219bd7e6ba7ced01899197da473b6c45cacfab0d652ddaf547b4ea58c +b12e3331f1f7d7458393a785e22e9a5e1d1daea521b4e78c0ee8ca59b41ade1735a29820e18f6afb2f2c3c56fecc16b6 +ad4b7cf654349d136fb41fb0dd65b588199f68b462b05f5c4e5c2b468bfaa6c26329033e3c3f7873dc8ace89cf873ea5 +a3279969e1ab596df0559ffc5ac7a6dc849680354e01c3f4fd34c6413a3f9f046f89c1e1be0b315d8b6dfab3d23d5c14 +ac74cc5562836ed89d09a9ae6a3644c936d64bdda9e77659d9982f1be29541b03ef2723236d5465e398373ea19a4ccc6 +98138ebce1af531dd8b631b3e74c84f0c700355a2a9bde31e5e51bb10c8bbd766559c63f6041f4002568803fe08438e0 +9006445da131349fe5714e0777a4f82a82da343612589a0c1596393e8b6894ce1cf42784f95ff67a8384ffe1f1a4ad76 +88502a84a85e4ce54cfed297b5d355867cc770a8ffd0714a6f23b1ab320a9903c6e42809e034bb67dbf94c4fc0d9c790 +aa8b4bf123d1a6ccaa44b86be8f980005f2a0a388a76cb111b0e85cd072ef64167fb0c097c7b23c4bca64c0260f6cce0 +ad49eb35dfea9feabb513a78dd1152ad7eba22fbb02a80cefc494a7037699c8df81202dfec12acc1b9e33ad680cb72d2 +8694da730231b29afd5196371ddcb15b4dcc499574bdd063f4864ab80749833ea38ab8b0ca1629a367fe378e87a60a86 +8eca7b488e810c479e7e32e24b8afcd837f7df183fe4f621a0336b53a9ed77603c84bdc365d8be68179a32b71a1deb7e +8875cd3e23c7e1af55af1b091025a08255743984186770bcd43f30b4a58d175cfdf1984bad97a15e08dac2da27198c3d +abdafcf58ec72997e494d4714645f40d09dcd0fbd0733e640eca44eeea67c25bb0c270299c459991f2fae59d13b4f4d5 +8f040970141e61489284f3efd907705eae6ec757fe8e1d284eac123d313e9ac1e8dc14ae3f04d281e1effc49d5d2f51d +a7ff115f0d2dbf66c0e8770b3d05157b37357b9e33e9a447f0f3fa9da69ad04e371fd1e4848cfb9e8d05e3165bd969d8 +a39b1a8c39d317fcc97bf6c396e6ed4a85640aeeadbf45166bd02bc3bdfb6266509159c03afd492e642384c635b824c0 +a2e1b90f3dd2d0038eaa5be52127844ccf35d997143179d95ffd3749c0896398b130094d01eb1bb31ffe80ef34b42b48 +a2bbe31f89b0c3c375ffaf63c8b7831860a921d5e388eb7907dbf61f2601ea40db86bb3952ecaa26a5eca4317a848ff9 +87d885bb0f2ce04b40ce94d2557c15f1698dc652e938f9a2d69a73ccf4899e08eafa1a59a20cae92823795f5b94f04b9 +8f7746370f8a24a2889d351f3e36b8a7d60e75e50e8f5abeea7dafc75441e95915721654e61ceac51bb6f112780d352c +a7272847526ed3d9e0d0fea1d8685b07b5b908971490bf8a46748c8b1783c629b8644feb5bac772ae615daae383d5e72 +978c9aa2996d8bd6fda7e0393fa8b38747f8f99712427705c00f6e9a12c36f8d8b4cedb03fcb9867155cbddb5200e6e1 +a4dec4a2354b2b32434c5bcdc380bf84580c6f9940f94dc0498a5bfe89c675a0921e66b807a3d859a6059a464cb2a9ac +99459ddecc7abce437f68722dae556d8ffaf8ed974f459e52e6d4a64f176caa4d42c2f2ec57e8a5b5f2034638e8acb0a +928c68c0c9213fe6258ab5bb0c693d97203d15da359784de7824dec143212da57d062a1fc70a79172cee31adc7aff382 +aad3f318f1622ea87e12541dfd982d71629b8f1ded4c301f9f6b6af9432716ad057773c33bdaa6f15dc151b0ee4505ea +8eb8e978f149a983fd6ad01773f9aacf57bd0cc622d8a301e404184b37e610123dd081faeda571a0ab1f149a3960af10 +851e7191d7b94bd422bcece5b92609fc1b1c8556229bc53e32963b2d2fd1cacd8ce5da9040b599eca6e610540f8a7987 +9414157fe9d50e5a0b5a7397417681bcb3a651eec1cab63f2a88d5df68ab1fef6e4c1d7ba657cbaf241a7cb790297633 +b5cb2dafdc5408959780754a58b2da55b2a9136672ebca42f34da4e329ddc89360e7218cde3efdbf784ddb390deacc57 +ac6b70f65503a8e94b773fda3e72615745824930114fe72b6d833484285462392617c1b2eea4a250fedbee88f503f3ba +b0829a5312f9ac6c06fddee2f835a3452fe994f6d42c9edfc390d7d5b3240ca544433b544cbbddd6516b38a6d5d7c21d +95f8e2c59905957e34d53be3d6fb85732f834e2cb9ab4c333fea2f502452a87ccd035fc9075d7c0bd8530bb0a0c96527 +b93f279b7045f2d97c674495f6e69a3e352f32f43cc60300193b936c2850b2805c15457251f7e3f633f435cb2b60405c +915abf16cba1a0b655b92a8a70c03e7fb306b86f3bbfb66967ca63e64c003b59c7a5953675efa4fa0bce9bed536b6700 +ac2047f50a319d09df1ec44d71afdcec5ac3bd2765dc98aba347734aa780863545df9f6d71214d443e3f37edc0dae45a +ad49c74ddb24c8a26b14ec08bc807313c77c5967fbb36237f55994d7511bbac8d7e7b9b8ec53eb1b3b066989f078dbd9 +961483105f605e959213fe9e8a52b76dac62d7efd2319ec71fc4e92d68fbe44cd2f65d7adefb2eb64d591b91648b8085 +b67fcafc97d8df2b3075bbff7b3d7471dbf1f3048f309e55d5e2c5bcbc7a73aebcb0697859be9f387cbc7ce98041e154 +8da70ac16468cab6066992389cb37c79ff5e0babbe67d76878aef9408b9597a3dc2eb5de87428bc761a0d78957b0eb28 +aec0ce89770d299b631f15ae12f94b1e1014ac57d38fcf037c2c7712d770d074affa06e97c60691bad8733874b6ad2ed +8b702c85fa4c915a09fc86507f44d7aeda0993b77af87780d70cc98d580c6e996b64b7c16cdb4dd4562cb0f75da36ee7 +aaeb43aa472aac2253e211fd1066c3a5422ea041cef20168702d0618a1a742a44f7fb30a76677640fea1a24e7fae1996 +a8820e92825d6e02b9b4ad5ebc86161d3244cddd3d244333ba1576b6ae10948145b68d9e926bf6b7a2c25dab4cf43f3e +8ffdae28a1f1d15d7ffa473628a66ee9a739073f59ba781248286b39cb8f7255f66d62337064246713cbb5017e615174 +adfc5dd142b7911326d8424881d5d92006f3b17de4cce91674d6ea37f00fbb266c791ac13f6c7a0f61d04f2a952e6a04 +87f98982444bf661f539bec73a10256f079a4baa88a1cea0351ae3de929e1c500485b2d1b5d933063cd7d9123d5050e4 +8f217ba4dd404c5ee384f0c9a126686db001ff0344c01c82174c5e5ef89d1a241b146008c534b13a0da6c8afe7450fbb +afc85476dddaf1cbb4ba8b22186789f3818c7964f9f613e55010278800cd95422702248bdf9c73760702ef24854795ec +a59e0f6ac2ccdfbd01f002008034390c0ea78716f5e0de4e474e3558755705c9c7afb6e3c5c4370e7bbc85958a9c7a63 +97c0695c58d792ec31d9b86d3b2fc1382f0855057b24d5f6a54c41f76f9e2f52882cadc89a8b2f121530e7f1393faa95 +8e49112de0b2649c08a96cf737af68fa8055f1af594846a2d0534c94df6f926f200405edaa6e6ac9db7e380707a2571d +99a1bd83a7ac5f8d77ddf044c80ebfc5745b998714696d67b94d185c97e9d6db989bacac646d9def463127a8b2febc00 +aba80725f9f9f7abe10760eca73ba427ca8df864a157122eb9af828a05b0199de3add02019a297750bdab5380e505c58 +ae18f62573275c1eb268f74c5e54e8958547f9e7d1d36a05b084eb53e5704fafe2200b8aff95cc7e9af5be2391c42b7c +908b8031d09d22b2aefeaa876a998e0a97c7a1070aad9e9c97836cc5aa6d2d5ef94230e1222074837b5e21b4e6490f01 +b3132282e8b41ca6789ec5c43c1fecf3a65b8eefbc2f3d10f746a843b9ba4ce6db664678e75e424f7b11a00c1440de15 +a1eb49440cc106ebc09cf198c93e8070271eb5a936d31c04858a2b311a037350100c7957d5545c9653f396aa968b91f4 +81df6ad1bdd5eee4cc2f94318467b8602d15cc1be2b48b09ade12cc46ee05cbaaf77a20397e5015030b1f1db5dd9dac0 +87236c68a2a93c8442d15d7f1d1dc01d1fd123439c183e1d843f4ddd2bcf638c128f66f1ef9b710e5d1f64a52726007a +84f2e7f85563bb2f61b10a712c7605d63f79af5be0dba056814fd3efebc20e9c53227c56577b72c68d185571b775eff6 +a36d4ae06688ece2927aeb2c7f058a3cd2aa1de1601282d4e688e1d76ef20728b892928deda2314eba41675eba3912f1 +b8326dcbcdcfce017b263c456c47692fb476c4225c95981666fff0b7d4522fc23b7f12273f0f47cf0442662124e6648f +84c66463ab277cda2cc7007d0509269e89cdd41c5e0d3773a92615f0fc5da63811186b05d7a11088048a5d4834a7e0df +b20d3571d970712ef4699b0e7034fd269c361f53e1572e2ea2676b4245e992d43b8b5931a801439a44d977a988cc360b +94dba6007e6d4998ca1eb84aa8e2a7e9f5c164b9d80df2825f2208ce5640a05aacac2e4f08918268990f43ae1ccab69a +a1c25f0b3ef9d1982153207570d9ce8d692e1b6963b509958dc4d9bcd80074bb221c46804a6d9a29e76149cc7787c282 +8857748fcdab1199fc96084323a81d3bd8b5a7f0b1abc5bc3b5252a19268344e2e7d2d086c90fc9b5fa4b92feedb93a4 +8b9c1d841447354b6c086549e4d1d435ab64c13933488c34bc30f0f6eb36c5c5b838b7b6bb018542247edd1ada091045 +8f5b655416da0e719a204fc567e93792c301acb4374cf7bbabc6ce51dbeaaadfd75c2db0e16ce073ab8e91fd3d7ea9d4 +90f2846b19be46a75c5cd0cafefcf9192e6fd80c479e8d6320c4b8d8d7d96703c9e77ff31a67afa9858e6b7bde1f7cce +a53e383947fd98aa1a55ac956214b46b20a52758461e8ba41341a23a835ebb713038bf048edb1202bbfd0b56a96bf292 +9542d7debbcfb9cda6fa279c699a7b655c03b9a9b456a5d3cfc41a826c94eafa43e01155a29e39ff0bcd965f4c0c512d +a43792864ec5fc549f7afc02622454afc0e425c310c4039ba615067243ebb26a4c7ebfd19bd4d57ff412a4bb2a7958a0 +b85123950e30c048465bf32365d24a5d4b21fffc6183cdbf71643a07b87463989b72dd9a6a47f134856f704909a6b38f +944ea689aec1376f855c0bc9c51378ad06ff758a2c075b95a60b535b88b36eca0be11e4edb5152e98cb2137d6e749f27 +a6bef52cda22325e4c62d323e2a0e3fa91c5552fcfce951edfd52ad6f652bfdcc2341f1cd349e6b5d447924dc569bfe2 +b56bff8ffe981bfcb30791836da10b87f2ccbe17ed969e7f7a650af07d27ae0223805b1264d985148208483be50578a6 +8b209cac898dd580c82d854a553e2517497ad1a4cd198e1360b8b50639b380aee70ee4b87625d9b2278228ff644cd25c +877cce233fec74c7158b3c5bf108365e98238418b8a71f058f1aca44a0fd3a1021e3e9025bd11fe244d9fe0f5034ce7f +b1b871aeedb03d6f6accc99816b89f5958178738d8d8cd9717527d04363c80fdb5f6848122ae19fdbc450cfa11e753c8 +858aca51b9e5b0a724e88688d5124eb24c9faf01a3d465e74d31de6da315f311143f22f60201ea09f62c92f61f09d889 +8521d409615dfc8c8289e00f6aaa6297c2c4e1439b25952afd76aac641b81c70b9cef07cd58c1c0198382bddd2bd8544 +88647c3e41666b88acca42505f1f5da226937e0522b538fe0cebb724e9a99730ca2522989e94a96cac94109aef675c0f +b417fdaf719caf38854e89ce52031b30ce61a632e6c3135adec9002280e022d82ab0ea4ac5ebdb21f1f0169e4c37bcda +9367a6feb5e23ea2eab8ddd5e7bdf32b4d2419fad1c71a1ed327b77362d8942dad971a1c2e6f7073885149cdf0a0c339 +a71c5c08d50c57d094d6a4f02e97d3799bada92f238ffc07bd223bbe8379507b7310d20b28f5bbbf331e5e153515e491 +9630a9a3bcb044b51299c4d3d3388a4ff47308dd27be3229601985478c0f6b55faa7e20815d8694f910611396a9d0d45 +b0bfaf56a5aa59b48960aa7c1617e832e65c823523fb2a5cd44ba606800501cf873e8db1d0dda64065285743dc40786e \ No newline at end of file diff --git a/infrastructure/kzg/src/testFixtures/resources/tech/pegasys/teku/kzg/trusted_setups/broken/trusted_setup_g2_length.txt b/infrastructure/kzg/src/testFixtures/resources/tech/pegasys/teku/kzg/trusted_setups/broken/trusted_setup_g2_length.txt index 9911117385c..e050e96cec2 100644 --- a/infrastructure/kzg/src/testFixtures/resources/tech/pegasys/teku/kzg/trusted_setups/broken/trusted_setup_g2_length.txt +++ b/infrastructure/kzg/src/testFixtures/resources/tech/pegasys/teku/kzg/trusted_setups/broken/trusted_setup_g2_length.txt @@ -1,4162 +1,8258 @@ 4096 65 -8d0c6eeadd3f8529d67246f77404a4ac2d9d7fd7d50cf103d3e6abb9003e5e36d8f322663ebced6707a7f46d97b7566d -a0d2392f030681c61c2a867862917e10f7678d882034bb89af3db87e6ab3883a304034643dc9688a04e41a5b831582bc -94298073048d70c74f36685e547d04b7311479daa05912e18ead64b2099a194bf48ec344273d58daf0b86b1d8f1d318d -85c4063d13499013dc2ccaa98c1606763e6b1e8cca20922d4cec12ecbaf006ea81ffabe6596d1ac7ba1daf7e63e30898 -84c64bce36c6b5145c6880113366025ab9a8f88e3948d374e27be8b8f9f87402c70fec9b3c621a2d1d26764a84370d0c -8b206c823acf5294552ee54579fac0f45ea15bd273dbacd63b88cd7cddbcce23b56e52f8ea352e1e1d7dcd9b3991b413 -b70aaa4038ba3f5ff306c647b4392d004950c53ad8f6713b5c9c21ac99f5c56cf57323dac500a1f4e9507c4746b07a2f -895f6d1fc70b52f838d81b24f4840729cd5988b649e9d6e6f6dbac4281d8818f39ebdae7e6ea139d7f98a832bd6f29f1 -a71a2832bbaade974c9ef7505dfa24e1ba466a9951b7c2db56886be31c9c7b871f3ee76cb1fcc1aab4b906d6502bc9b5 -9530ba64a21e27834609c00616bc63e8fc2dc7800e478ad728ec39c624f65bbc62cb48f59decb7fbf605ce1920d02622 -8d0609affaf8619bb2f6c80699e5bc7783becbd5973630cdd227ae52d6d701c45f4270becca97701b40279fab588cf64 -8f5d5b4c3bb8dc9a19e5a0f84df6322a79a00c7783c86254197d313a5b35d3965a1f7c0b9c4e39ec1e8f5d02d3aa0862 -96aa47a3ba20b1cfe81eb26bef503225037fdf4c9df53bea1b520841875cd1db6aa8e0f34685da08b55a3ce7289e6de0 -b4c27ee3f4b8c0031837160f0a75632f5b51b5850d52b530096443f54c2b264aeccc5c61b4fcc8de7074475f354fa0d8 -acfd735cda20be1d6f425a7886629c91732fbb5a4e0350ca740a8fb5b39f2001071cec0b2a0f6ca35e1f35a5ea18d00f -ae44d87b1d16d59504c602cbacde2c2791f1520391ca50154e6036d3953ca466cf93d6537da2adb729e6f9f4ffa87853 -97b492872ce44941ea4668ffca83b82fac0f4021bd47e0a5ffeaaacb1b3fc924ee4d53b99f7bcafe0985caf0fbe5d1d3 -b3fbe2f9103d293f49c6c6016d5913f041c9113295397388111a0fdf4245d8edd6e63b9a1a1c9c8f868d6e1988116880 -805efa08fd2046c44c427b225c17bed8a1eb3320cdf94026fdc24c6d345a6cfebfd7475f85d2d1bf22018ca72d2761d3 -9888bae0d83077d1dfde82fdffb1195565c31c519b80cba1e21aba58ee9ccb5677f74bfde13fa5723026514a7d839661 -922e19d2646ba90c9f56278bddf74621cc4518ae2f042fb8245843e87cd82724c6d7c9a99907ac6de5f2187fd2e77cbe -a38f0e1faf97dd1e0804b44e4d150dbfa48318442d1c5255eb0c14ea56b50502f3c7cb216a0336e7c140398088dc01cf -93598ea391c8735799a1d4cd0456f34994ccdf4883fad57419f634f30fee595938bc66b066dade9ae52578818c00d899 -a528dc920734cfaee9feacbc0baa5b73befb1ec6fbd422fcad09a9c1f8f8c40b5ea332b2cf04dc1d6d921e9da9ddfeb4 -b38d45316bf78d11e796a34ee535814e6cde0e642f14108329c5b21f4fec18cd61f84a3025824bb8dc4cbd26b2ecc9bf -8eec35a7404c9a35dc6ad0260b7f0f7fd1bfe92a2e08bc72548b99ed9acdc378728a8ea9c6879a6e47e37edb0d28c193 -a68a4446274ccd947c61bf736c5219dad680b99c6085a26719793e0d9dab26d5f8a0b28e71be6e1b9ea4ae39139f7f57 -a0acb543f41ad12e3b2e096629ccdd719a001d0ff53bb151e9a37aa57852f7275a7bbd06dc2a06af9144524548164af5 -b271e74cdbcf8b9143f8472174bdb068c23308ea807c60a554c185f7be6f231aac13347139837514171a876dfac5baa5 -8195a460719000cd1df379ebbf7918f71301a50a2fa587505cc5b8c4534c3d2343f63d28e7ee991d7a1cebb15d380696 -96202b60426773e8731dcbedbf613477f65940a19fb4be0f4f742b0c76ae9d88ecdb6d36cd4f12bb404dd5d360c819e2 -b0a80fe60b71ca9e80157138de8787b8a786326179604b8a15a744e52662645987e5f859ef5c76492d560daf4624b9a7 -a331ea8adf87daa5e2d458d0113c307edae1a84927bca7d484aca5f8c1b6378ab42981c44b0d916d7249f4b475f926f1 -aa1a8f59ae0912abf191ea7e209ff401628278dfb2269db6d87cf33bd52af3dbffbe96513a8b210e965c853a554b787a -ac4f4a0e1b1a155e1f22a9085b0b047fe54c8437dbbb8e9720fd6b0cdd76557d19ca2e885a48890f0247b1a72be0e287 -a428465505eac7b9660eb0d495a7a00c8cc238de3a02ebbd2eb07e502e9868086e9584b59953cf1480c0b781295db339 -b7b77e21e08f6357cbd3dcd3035c3e8ec84cdfa13c7baef6c67e0ef43095e61fd549694263d7def8b8adc3a0fdcc7987 -abb991d17c5bdd264c592c55101e265cb3210c4157aee4079173fd51da1e0199eed1d6c890aab95817ec078561d771af -846a8e4f801faf5fbec078b09c362ee30a00b2b58a4871744d03cd118b913464233ff926e52b0c75fbfcf098ad25a1e6 -947e91ffa32f38c1ccb72cca4bfabaee9e63ab74a16f034cabba25e462f7331ebe5a7ba393f69e91830415fa75b1b52e -8dc5e26adc693f4e300cab7385edca1a2fe14c8ee6dc0cd6d013cb5aa154dc380e9e81e259cbc59c1f38f7c4a57f1c7d -9818ef6605d6ea3b7bf4da5c6d6d8ed540bb94df4d14c974e1b79ed2fd1a0b897b8cf1ff671a181a697effd66b1644a5 -b5eab6baf03af994fc32cc9dce388394c18c01cdafe7909fde948f3e00a72dc8f30d15977d0f114bd7c140f5f94cf005 -83b2e9858d3b929f9a2ad66a91a2c0c44d15d288c17c12a1614301a6f2d61d31eaa540ca7781520fe4420afae0ec0208 -ab338fbd38bce4d1b7a759f71e5e5673746c52846eff3d0b6825e390aeeca8f9f123ee88c78fe4d520cc415cbae32bf1 -81adb6322b8db95d1711304e5b59f37640ca88c03e6c7e15de932be5267dff7351fa17664113ecc528e8920f5bfdc0d1 -89e2e0c0d769e4107232df741678a6bacb041d0154385450aaca8be9c3c18c42f817373962e7569d33935c35666a8a6a -8f0756fea8b34a2b471ec39e4448a6a6935e5432ec2859d222964a4c82777a340e1d702777aeb946fa405afc0438221a -a2bf90c505a6f03b3dd09d04e1e7cf301fe3415b273e263f15fdfe5d0e40f619b95e8bf00916d3eaa7d7f8c0bae41c8e -91d5c76b5542637588cd47279d0bd74a25dbda0d8ec0ff68b62d7e01e34a63fc3e06d116ee75c803864b1cf330f6c360 -a9958c388d25315a979566174b0622446335cb559aff1992bd71910c47497536019c6854d31c0e22df07505963fc44ff -91d82b09d5726077eed6c19bcb398abe79d87ce16c413df6bf5932b8fd64b4c0fd19c9bf0fa8db657a4a4d4c0d8f5a2d -ac6e0a86e0ee416855c3e9eef2526c43835f5245527ed0038bc83b4fcadb4ea5beb91143cc674486681a9f0e63f856b1 -aaf00d6efd0c6efb9f7d6a42555abec05c5af8f324e2e579fc2ac83bdc937cc682d9bc2ffd250619c8bb098b8c84db80 -963f5fcd8476d0dbeb03a62cde40e3deee25f55e7ded7572d8884975f38eddc5406fc4b0adff602a1cca90f7205a7fdc -a3805ee01512f644d2679511bd8607890ee9721e75ac9a85ab9fd6fceb1308d5b9b0e9907686b4e683b34aed0f34cd81 -a483d7708465cd4e33b4407fe82c84ef6bc7fa21475d961fe2e99802d0c999b6474ef7a46dd615b219c9c7e9faec45ee -b6b5f9456f12d6781c41f17cdc9d259f9515994d5dee49bb701a33fa2e8dcbb2c8c13f822b51ad232fc5e05bff2f68ef -8766b721b0cf9b1a42614c7d29aad2d89da4996dc9e2a3baeba4b33ca74100ab0b83f55c546c963e3b6af1dcf9ca067c -ac5e8da1154cf4be8df2bbd2e212b7f8077099b2010c99e739441198f65337c6f7ef0d9136453a7668fde6e1389c32c7 -a9d6d2c8845e5f1fec183c5153f1f6e23421e28ce0c86b0ce993b30b87869065acad9e6d9927d9f03c590852821b2f9c -a320ca07c44f7ea3ff858fe18395a86f59559617f13ec96d1e8b4a3f01d9c066a45c8d8cf8f1f14a360bb774d55f5f18 -b3adb00e1312dce73b74fbd2ea16f0fb0085bd0db10772e9c260e9ed9f8829ff690e3dfffacaddc8233d484bb69778b3 -87b0c8d8a167d5199d0b0743c20fb83ec8a1c442f0204bcc53bf292ba382bef58a58a6d1e2467920e32c290fdc6dae7c -a74fa436a5adc280a68e0c56b28ac33647bdfc8c5326f4c99db6dbd1b98d91afb1f41f5fffd6bcc31c1f8789c148e2db -8a37349e4ba7558965077f7f9d839c61b7dcb857fcc7965c76a64a75e377bfea8cd09b7a269ce602cc4472affc483b69 -8af813f62c5962ff96bf73e33f47fd5a8e3e55651d429e77d2ce64a63c535ecc5cfc749bb120c489b7ea1d9b2a5d233c -833021445b7d9817caa33d6853fa25efc38e9d62494d209627d26799432ea7b87a96de4694967151abc1252dd2d04dfc -8f78a715107e0ace3a41bff0385fd75c13bf1250f9e5ddecf39e81bacc1244b978e3464892f7fb2596957855b8bf9fc7 -aed144134dc1cc6c671f70ebe71a3aadf7511eea382969bc5d499a678d2d8ce249ebf1a06b51183f61413eba0517012b -b39a53e82c5553943a5e45bc5116d8672ec44bed96b3541dead40344b287a7b02dbf7107372effb067edd946f47de500 -b383844c3b20a8bc06098046ec6b406df9419ad86fac4a000905c01325426903a5e369af856d71ccd52fea362ed29db5 -83815a7098283723eec6aa6451b5d99578bf28a02971375a1fe90c15a20963e129372ac4af7b306ee2e7316472c5d66d -b426b4e185806a31febd745fa8d26b6397832a04e33c9a7eb460cbf302b4c134a8a01d4e5e40bc9b73296c539e60b3ca -a6cabf8205711457e6363ef4379ebc1226001e1aaea3002b25bfd9e173f4368002f4461e79eeb9f4aa46f1b56c739ab9 -a6e88ab01282313269cd2d8c0df1a79dada5b565d6623900af9e7e15351de2b0105cc55d3e9080e1e41efe48be32a622 -b2b106db3d56d189ea57afa133ae4941b4eb1dc168357af488e46811c687713fc66bbd6f8500bbd13cdb45cb82c14d1d -b3a74780ff949d19e6438db280e53632c60dc544f41320d40297fe5bb7fcee7e7931111053c30fb1ed9019ab28965b44 -8c67f32b9fdc04ec291cc0d928841ab09b08e87356e43fbbf7ac3ff0f955642628f661b6f0c8e2192a887489fddf07bb -b3be58bd628383352e6473fe9a1a27cf17242df0b1273f5867e9119e908969b9e9e7e294a83b9ea14825003cb652d80c -a867acf6ab03e50936c19a21d4040bfd97eb5a89852bd9967da0e326d67ce839937cab4e910d1149ecef9d5f1b2d8f08 -8006b19126bd49cbb40d73a99a37c2e02d6d37065bbe0cfcee888280176184964bd8f222f85960667c5b36dfaee0ee35 -ac50967b8b7840bf9d51216d68a274f1d3431c7d4031fbac75a754befbbb707c2bb184867db6b9d957f3ba0fd0a26231 -b5a794c928aff0c4271674eb0a02143ed9b4d3bc950584c7cd97b7d3c3f2e323798fd5ccc6fcc0eb2e417d87f4c542a2 -a2ca3d6509f04b37091ce6697672ee6495b42d986d75bd2d2058faa100d09fd0a145350f2d280d2cb36516171bd97dbf -92cfa293469967a9207b37cd70392312faf81b52963bfbad5f9f3da00817d26e10faf469e0e720c3bb195f23dda8c696 -a0dd5135da0a0e33fa922c623263b29518d7fa000e5beefc66faa4d6201516d058f155475c4806917a3259db4377c38a -8fc3ae8ea6231aa9afb245a0af437e88ebca2c9ab76850c731981afba90d5add0ea254053449355eccf39df55bd912ed -9727afe1f0804297717cec9dc96d2d27024a6ae6d352fee5d25377ee858ee801593df6124b79cb62ddc9235ec1ade4ac -8bcb2c53fcaa38e8e2e0fd0929bc4d9ddce73c0282c8675676950ff806cb9f56ebd398b269f9a8c2a6265b15faf25fca -a8bd9007fbbdd4b8c049d0eb7d3649bd6a3e5097372fa8ea4b8821ba955c9ef3f39ac8b19f39d3af98640c74b9595005 -92c7e851c8bd6b09dfcbfdb644725c4f65e1c3dbd111df9d85d14a0bb2d7b657eb0c7db796b42bf447b3912ef1d3b8c3 -98c499b494d5b2b8bea97d00ac3a6d826ab3045bb35424575c87117fc2a1958f3829813e266630749caf0fa6eeb76819 -8df190d71e432fe8691d843f6eb563445805c372eb5b6b064ec4e939be3e07526b5b7f5a289ede44ae6116a91357b8b1 -b5010243f7c760fb52a935f6d8ed8fc12c0c2f57db3de8bb01fdeedf7e1c87b08f3dd3c649b65751f9fd27afa6be34c7 -889c8057402cc18649f5f943aed38d6ef609b66c583f75584f3b876c1f50c5dc7d738dc7642135742e1f13fa87be46c1 -996087337f69a19a4ebe8e764acf7af8170a7ad733cd201b0e4efde6ea11039a1853e115ad11387e0fb30ab655a666d8 -902732c429e767ab895f47b2e72f7facad5ef05a72c36a5f9762c2194eb559f22845bbb87c1acc985306ecb4b4fbbf79 -8519b62a150ea805cdfc05788b8d4e797d8396a7306b41777c438c2e8b5c38839cfec5e7dc5d546b42b7b76e062982a7 -862a53ba169e6842a72763f9082ff48fbfbb63129d5a26513917c2bca9ad6362c624ce6fc973cf464f2eb4892131eb04 -b86cd67c809d75fdb9f1c9453a39870f448b138f2b4058d07a707b88bb37f29d42e33ce444f4fbe50d6be13339cae8a6 -8cf5d8365dbbafc0af192feb4fc00c181e2c3babc5d253268ef5564934555fb1e9b1d85ec46f0ca4709b7d5b27169b89 -b48f11a1809ec780bf6181fae3b8d14f8d4dc7d1721128854354be691c7fc7695d60624f84016c1cea29a02aaf28bfbc -8b46b695a08cb9a2f29ab9dd79ab8a39ec7f0086995b8685568e007cd73aa2cd650d4fae6c3fb109c35612f751ba225e -8d2f9f0a5a7de894d6c50baceb8d75c96082df1dcf893ac95f420a93acbbf910204903d2eb6012b1b0495f08aaf9992f -b334db00a770394a84ec55c1bd5440b7d9f2521029030ef3411b0c2e0a34c75c827fd629c561ea76bd21cd6cf47027f4 -96e9ff76c42bcb36f2fb7819e9123420ed5608132f7c791f95cb657a61b13041e9ba2b36f798a0fdb484878cbe015905 -99f8d701e889abd7815d43ba99e0a85776ec48311fa7cb719d049f73b5d530fa950746ffbbb7beb9e30c39d864891dc2 -98169c20df7c15d7543991f9c68e40ac66607cbd43fc6195416e40009917039357e932d6e807f3a40bc4503ad01ae80a -84bd97dd9e4e2ba75d0dee7d4418c720d4746203d847ce2bdd6ed17d492023df48d7b1de27e3f5cb8660c4bb9519ae1b -a54319e06db7f5f826277a54734a875c5b3fd2fa09d36d8b73594137aa62774b7356560157bc9e3fdf1046dc57b6006a -90cfff7cd4e7c73b84f63455d31b0d428cb5eee53e378028591478511985bcc95eb94f79ad28af5b3bed864e422d7b06 -a11c23cc8dce26ac35aea9abe911905a32616a259fa7da3a20f42dc853ad31b2634007aa110c360d3771ff19851f4fb4 -9856fbee9095074ad0568498ff45f13fe81e84ea5edaf04127d9ee7e35e730c6d23fa7f8f49d092cf06b222f94ab7f36 -818862dec89f0dc314629fffbca9b96f24dfde2d835fa8bde21b30dc99fe46d837d8f745e41b39b8cf26bfe7f338f582 -831819d41524c50d19f7720bf48f65346b42fb7955ee6ecc192f7e9fed2e7010abccdfdeac2b0c7c599bc83ac70be371 -b367e588eb96aa8a908d8cc354706fee97e092d1bc7a836dbcc97c6ed4de349643a783fb4ddf0dec85a32060318efa85 -b7aaef729befd4ab2be5ec957d7d1dbe6178de1d05c2b230d8c4b0574a3363e2d51bc54ea0279a49cc7adffa15a5a43a -ae2891d848822794ecb641e12e30701f571431821d281ceecbccaaa69b8cd8242495dc5dbf38f7d8ed98f6c6919038aa -872cf2f230d3fffce17bf6f70739084876dc13596415644d151e477ce04170d6ab5a40773557eeb3600c1ad953a0bfce -b853d0a14cef7893ba1efb8f4c0fdb61342d30fa66f8e3d2ca5208826ce1db5c8a99aa5b64c97e9d90857d53beb93d67 -910b434536cec39a2c47ca396e279afdbc997a1c0192a7d8be2ba24126b4d762b4525a94cea593a7c1f707ba39f17c0c -b6511e9dea1fbccedd7b8bb0a790a71db3999bd4e3db91be2f1e25062fae9bb4e94e50d8ec0dcc67b7a0abce985200b2 -936885c90ebe5a231d9c2eb0dfd8d08a55ecaa8e0db31c28b7416869b3cc0371448168cbec968d4d26d1cb5a16ebe541 -b71c2ac873b27fe3da67036ca546d31ca7f7a3dc13070f1530fce566e7a707daeb22b80423d505f1835fe557173754f8 -85acb64140915c940b078478b7d4dadd4d8504cde595e64f60bd6c21e426b4e422608df1ed2dd94709c190e8592c22d7 -b5831c7d7c413278070a4ef1653cec9c4c029ee27a209a6ea0ad09b299309dea70a7aef4ff9c6bdeda87dcda8fa0c318 -aa0e56e3205751b4b8f8fa2b6d68b25121f2b2468df9f1bd4ef55f236b031805a7d9fd6f3bba876c69cdba8c5ea5e05f -b021f5ae4ed50f9b53f66dd326e3f49a96f4314fc7986ace23c1f4be9955ec61d8f7c74961b5fdeabcd0b9bccbf92ce8 -88df439f485c297469e04a1d407e738e4e6ac09a7a0e14e2df66681e562fdb637a996df4b9df4e185faab8914a5cef76 -8e7ae06baa69cb23ca3575205920cb74ac3cda9eb316f4eef7b46e2bff549175a751226d5b5c65fe631a35c3f8e34d61 -99b26ff174418d1efc07dfbed70be8e0cb86ac0cec84e7524677161f519977d9ca3e2bbe76face8fe9016f994dafc0ff -a5f17fe28992be57abd2d2dcaa6f7c085522795bfdf87ba9d762a0070ad4630a42aa1e809801bc9f2a5daf46a03e0c22 -8d673c7934d0e072b9d844994f30c384e55cec8d37ce88d3ad21f8bb1c90ecc770a0eaf2945851e5dab697c3fc2814a9 -a003ed4eb401cfe08d56405442ca572f29728cfff8f682ef4d0e56dd06557750f6a9f28a20c033bc6bbb792cc76cc1a8 -8010408f845cf1185b381fed0e03c53b33b86ea4912426819d431477bd61c534df25b6d3cf40042583543093e5f4bb44 -9021a1ae2eb501134e0f51093c9f9ac7d276d10b14471b14f4a9e386256e8c155bef59973a3d81c38bdab683cd5c10e0 -a5abf269ceabbb1cf0b75d5b9c720a3d230d38f284ed787b6a05145d697a01909662a5b095269996e6fa021849d0f41f -b4b260af0a005220deb2266518d11dbc36d17e59fc7b4780ab20a813f2412ebd568b1f8adc45bf045fcbe0e60c65fd24 -b8c4cb93bedbb75d058269dfccda44ae92fe37b3ab2ef3d95c4a907e1fadf77c3db0fa5869c19843e14b122e01e5c1f4 -ac818f7cdecc7b495779d8d0ff487f23ab36a61d0cf073e11000349747537b5b77044203585a55214bb34f67ef76f2d2 -86215799c25356904611e71271327ca4882f19a889938839c80a30d319ddbe6c0f1dfa9d5523813a096048c4aef338cd -a9204889b9388bf713ca59ea35d288cd692285a34e4aa47f3751453589eb3b03a9cc49a40d82ec2c913c736752d8674d -893aecf973c862c71602ffb9f5ac7bf9c256db36e909c95fe093d871aab2499e7a248f924f72dea604de14abfc00e21c -b8882ee51cfe4acba958fa6f19102aa5471b1fbaf3c00292e474e3e2ec0d5b79af3748b7eea7489b17920ce29efc4139 -8350813d2ec66ef35f1efa6c129e2ebaedc082c5160507bcf04018e170fc0731858ad417a017dadbd9ade78015312e7f -83f6829532be8cd92f3bf1fef264ee5b7466b96e2821d097f56cbb292d605a6fb26cd3a01d4037a3b1681d8143ae54d7 -87d6258777347e4c1428ba3dcbf87fdd5113d5c30cf329e89fa3c9c1d954d031e8acacb4eed9dca8d44507c65e47e7cd -a05669a1e561b1c131b0f70e3d9fc846dc320dc0872334d07347e260d40b2e51fdbabeb0d1ae1fb89fba70af51f25a1a -819925c23fd4d851ea0eecc8c581f4a0047f5449c821d34eccc59a2911f1bd4c319dab6ece19411d028b7fdedece366b -b831b762254afd35364a04966d07b3c97e0b883c27444ff939c2ab1b649dc21ac8915b99dc6903623ed7adaae44870ac -93ec0190f47deffe74179879d3df8113a720423f5ca211d56db9654db20afe10371f3f8ec491d4e166609b9b9a82d0d4 -8f4aa6313719bcfad7ca1ed0af2d2ee10424ea303177466915839f17d2c5df84cc28fcef192cbb91bb696dd383efd3b2 -8d9c9fdf4b8b6a0a702959cf784ad43d550834e5ab2cd3bebede7773c0c755417ad2de7d25b7ff579f377f0800234b44 -99d9427c20752f89049195a91cf85e7082f9150c3b5cb66b267be44c89d41e7cc269a66dacabacadab62f2fa00cc03be -b37709d1aca976cbbf3dc4f08d9c35924d1b8b0f1c465bd92e4c8ff9708e7d045c423183b04a0e0ab4c29efd99ef6f0e -a163f42fb371b138d59c683c2a4db4ca8cbc971ae13f9a9cc39d7f253b7ee46a207b804360e05e8938c73bf3193bab55 -87a037aa558508773fc9a0b9ba18e3d368ffe47dfaf1afacee4748f72e9d3decc2f7c44b7bf0b0268873a9c2ef5fe916 -a1f20cb535cc3aebd6e738491fe3446478f7609d210af56a4004d72500b3ec2236e93446783fe628c9337bcd89c1e8e1 -9757aa358dfbba4f7116da00fe9af97f7ac6d390792ea07682b984aa853379ac525222ac8a83de802859c6dec9182ef7 -815daca1eded189ec7cb7cbc8ad443f38e6ddb3fb1301d1e5a1b02586f1329035209b7c9232dc4dff3fc546cb5ac7835 -aed86dfaf9c4f0a4b2a183f70f9041172002a773482a8ebf3d9d5f97d37ee7c6767badfda15476b3b243931235c7831c -8d032e681e89e41b29f26be02f80030fa888f6967061d2204c1ebb2279a3211d759d187bce6408c6830affa1337fb4e0 -877bff5c2db06116f918a722b26422c920aeade1efa02fa61773fca77f0ea4a7e4ee0ecaaa5cfe98044c0ff91b627588 -b9ee5310d0996a10a242738d846565bdb343a4049a24cd4868db318ea6168a32548efaf4ab84edfbf27ce8aec1be2d1c -b59f6928167323037c6296dd7697846e80a7a4b81320cfae9073ebd2002a03bdf6933e887f33ad83eda8468876c2c4fb -8167686245149dc116a175331c25301e18bb48a6627e2835ae3dd80dd373d029129c50ab2aebeaf2c2ccddc58dcc72ec -82b7dcc29803f916effb67c5ba96a1c067ed8ca43ad0e8d61a510ab067baefd4d6b49e3886b863da2de1d8f2979a4baa -b43824cd6f6872a576d64372dde466fef6decdbb5ad5db55791249fde0a483e4e40c6e1c221e923e096a038fe47dab5e -ab1e9884cf5a8444140cf4a22b9a4311a266db11b392e06c89843ac9d027729fee410560bcd35626fd8de3aad19afc4a -a0dbd92a8d955eb1d24887ca739c639bdee8493506d7344aadb28c929f9eb3b4ebaae6bd7fd9ffe8abb83d0d29091e43 -8352a47a70e343f21b55da541b8c0e35cd88731276a1550d45792c738c4d4d7dc664f447c3933daabd4dbb29bb83be4a -8ce4a1e3c4370346d6f58528a5ef1a85360d964f89e54867ba09c985c1e6c07e710a32cdda8da9fa0e3b26622d866874 -b5e356d67dd70b6f01dd6181611d89f30ea00b179ae1fa42c7eadb0b077fb52b19212b0b9a075ebd6dc62c74050b2d2f -b68f2cd1db8e4ad5efdba3c6eaa60bfcc7b51c2b0ce8bb943a4bc6968995abe8a45fe7f12434e5b0076f148d942786be -b5c7b07f80cd05c0b0840a9f634845928210433b549fb0f84a36c87bf5f7d7eb854736c4083445c952348482a300226a -8cfd9ea5185ff9779dee35efe0252957d6a74693104fb7c2ea989252a1aa99d19abaab76b2d7416eb99145c6fdb89506 -8cc8e2c5c6ddee7ef720052a39cab1ecc5e1d4c5f00fb6989731a23f6d87ac4b055abb47da7202a98c674684d103152a -8c95394c9ed45e1bf1b7cfe93b2694f6a01ff5fed8f6064e673ba3e67551829949f6885963d11860d005e6fabd5ac32c -adf00b86f4a295b607df157f14195d6b51e18e2757778fde0006289fabba8c0a4ab8fad5e3e68ddbb16ccb196cc5973f -b1714b95c4885aac0ee978e6bbabbc9596f92b8858cb953df077511d178527c462cbe1d97fdc898938bae2cd560f7b66 -adf103f4344feb6b9c8104105d64475abc697e5f805e9b08aa874e4953d56605677ef7ff4b0b97987dc47257168ae94d -b0ce6ede9edb272d8769aed7c9c7a7c9df2fb83d31cc16771f13173bcdc209daf2f35887dcca85522d5fdae39f7b8e36 -ad698d1154f7eda04e2e65f66f7fcdb7b0391f248ba37d210a18db75dafd10aedc8a4d6f9299d5b6a77964c58b380126 -904856cd3ecdbb1742239441f92d579beb5616a6e46a953cf2f1dd4a83a147679fc45270dcac3e9e3d346b46ab061757 -b600b5b521af51cdfcb75581e1eccc666a7078d6a7f49f4fdb0d73c9b2dab4ce0ecafcbd71f6dd22636e135c634ee055 -a170c5d31f6657f85078c48c7bbf11687ce032ab2ff4b9b3aee5af742baecf41ea1c2db83bcba00bccc977af7d0c5c8e -a9ef1cbb6a7acb54faf1bcbd4676cdeba36013ca5d1ac1914c3ff353954f42e152b16da2bdf4a7d423b986d62b831974 -aa706d88d3bd2ce9e992547e285788295fd3e2bbf88e329fae91e772248aa68fdfdb52f0b766746a3d7991308c725f47 -911a837dfff2062bae6bcd1fe41032e889eb397e8206cedadf888c9a427a0afe8c88dcb24579be7bfa502a40f6a8c1cc -ae80382929b7a9b6f51fe0439528a7b1a78f97a8565ba8cddb9ee4ba488f2ab710e7923443f8759a10f670087e1292c4 -b8962de382aaa844d45a882ffb7cd0cd1ab2ef073bce510a0d18a119f7a3f9088a7e06d8864a69b13dc2f66840af35ae -954538ffff65191538dca17ec1df5876cb2cd63023ff2665cc3954143e318ece7d14d64548929e939b86038f6c323fc1 -89efa770de15201a41f298020d1d6880c032e3fb8de3690d482843eb859e286acabb1a6dc001c94185494759f47a0c83 -a7a22d95b97c7c07b555764069adaa31b00b6738d853a5da0fe7dc47297d4912a0add87b14fa7db0a087a9de402ea281 -9190d60740c0813ba2ae1a7a1400fa75d6db4d5ce88b4db0626922647f0c50796a4e724e9cc67d635b8a03c5f41978f7 -ab07c30b95477c65f35dc4c56d164e9346d393ad1c2f989326763a4cc04b2cb0386e263007cc5d0125631a09ad3b874c -9398d8e243147de3f70ce60f162c56c6c75f29feb7bc913512420ee3f992e3c3fb964d84ef8de70ef2c118db7d6d7fd5 -b161b15b38cbd581f51ca991d1d897e0710cd6fdf672b9467af612cd26ec30e770c2553469de587af44b17e3d7fea9f7 -8c5d0260b6eb71375c7ad2e243257065e4ea15501190371e9c33721a121c8111e68387db278e8f1a206c0cce478aaa2b -b54ac06a0fb7711d701c0cd25c01ef640e60e3cb669f76e530a97615680905b5c5eac3c653ce6f97ceca2b04f6248e46 -b5c7f76e3ed6dc6c5d45494f851fa1b5eaf3b89adac7c34ad66c730e10488928f6ef0c399c4c26cbeb231e6e0d3d5022 -b6cd90bdd011ac1370a7bbc9c111489da2968d7b50bf1c40330375d1a405c62a31e338e89842fe67982f8165b03480c7 -b0afcaf8d01f5b57cdeb54393f27b27dc81922aa9eaccc411de3b03d920ae7b45295b090ef65685457b1f8045c435587 -b2786c0460e5057f94d346c8ebe194f994f6556ab2904a1d1afd66c0ff36391b56f72ed769dcc58558ee5efaa2ed6785 -965dbb0cb671be339afcb2d6f56e3c386fb5d28536d61d6073b420ee15dee79c205af2f089fbb07514a03c71bf54b4e2 -90f2003e2286bba9cebff3a6791637ca83b6509201c6aed1d47f27097d383d5c2d8532bff9e3541d2c34259841cf26ab -902142d1224e1888ebbfef66aaf8d5b98c27927a00b950753a41d1d28a687a8286b51655da9a60db285b20dc81d5ea89 -a5d364448bf0d0849e5104bdaef9cb2cc8c555f5d6d34239c68671fbe1252f7c8c75b83cea10159dee4da73298f39a12 -b013a54c5b99e296d9419ad5c2aaf4545acd34405e57d13cb764e92132cc20d1a14b33e10caf22d898b608670c04f273 -b92976dceda373331804d48a7847f508cafde8d15949df53dbda09d03908678db1e61ee637baad5f05b2b03ea6f5a870 -968bcb308c7ad0813dc9b3170f23f419aecd7b42176f27fac698811795bf42659fea6b04dab4ef43595dcc990622041b -a9d0a20e9367ea831dccd37f4d97ea75e9aeec952947a7946d95e0d249c94024183ef79a624bdea782469824df0ee4e4 -8521b9667453c3658703e5db365b13f0e0d2331ce611ff1e708f8124d8a81bb5e82871de4a66d45c1a6b0a3901bd901e -b9c88e76e69b0722c0a2f97e57dbc4a6f7456434cd694e2ff67f4e24740cffa4db03e2b18f07f22954ae7db2286e1fa2 -8400e55aa9ab01d4cc0affd611127b5d8d9a9dbd897f3cb8e2050379983aa54249be17d7b7891977b2515bb44a483f65 -8cbb967b4ed31dc40ea06822a94d54cbfc8845c66fbafa3474c8f5fe1ada97299ed4ca955d9d7a39af8821eabf711854 -b4d266ee3fea264a6c563fd6bed46f958c2d7bd328225f6e47faf41a0916aef3b697574322f8b814dfb2f5c242022bf6 -8f7c72d69a919450215ead660ffa9637642c5306354888d549fd4a42e11c649b389f67cc802a0184d10fdb261351140c -a5f9e494ea9b2393ec32c48aac76c04158ccef436d4e70ad930cba20c55fbf61e8f239f70b9d75462405c4b6317c71a1 -b3befb259b52a44a6f44345859e315c20efa48c0c992b0b1621d903164a77667a93f13859790a5e4acb9f3ec6c5a3c6e -b9e4ca259b4ee490d0824207d4d05baf0910d3fe5561ff8b514d8aa5c646417ca76f36ab7c6a9d0fb04c279742f6167a -98fa8c32a39092edb3c2c65c811d2a553931010ccb18d2124d5b96debd8b637d42b8a80111289f2079d9ebca2131a6dc -a65e5aa4631ab168b0954e404006ce05ac088fd3d8692d48af2de5fd47edbf306c80e1c7529697754dbbba1b54164ba0 -b94b7d37e4d970b4bb67bf324ebf80961a1b5a1fa7d9531286ab81a71d6c5f79886f8ef59d38ae35b518a10ed8176dcc -b5ed2f4b0a9ae9ace2e8f6a7fd6560d17c90ae11a74fa8bef2c6c0e38bfd2b9dd2984480633bca276cb73137467e2ce3 -a18556fe291d87a2358e804ee62ddff2c1d53569858b8ae9b4949d117e3bfb4aefce1950be8b6545277f112bebeeb93d -a0d60b9def5d3c05856dff874b4b66ec6e6f0a55c7b33060cc26206c266017cdcf79b1d6f6be93ed7005a932f9c6a0b9 -801fced58a3537c69c232ce846b7517efd958e57c4d7cd262dbec9038d71246dafad124aa48e47fe84ecc786433747c7 -a5e9a8ea302524323aa64a7c26274f08d497df3d570676ecc86bd753c96a487a650389a85f0bc8f5ea94fe6819dc14e5 -a8a2963dc9238a268045d103db101adc3b2f3ab4651b7703b2fe40ece06f66bf60af91369c712aa176df6ed3d64a82fa -a4a8ff0a9a98442357bcdd9a44665919c5d9da6a7d7d21ccdbbd8f3079b1e01125af054b43b37fc303941d0a2e7baee0 -90ef893350f50d6f61ee13dfab6e3121f4a06a1908a707b5f0036cdc2fe483614de3b1445df663934036784342b0106f -84e74d5bc40aaab2cc1d52946b7e06781fbef9d8de6f8b50cd74955d6bdb724864c0e31d5ac57bf271a521db6a352bd6 -832cdf653bbbd128e2e36e7360354a9e82813737c8ab194303d76667a27aa95252756c1514b9e4257db1875f70f73eb4 -a0af8660ed32e6dbcc4d5d21b0a79a25ff49394224f14e6e47604cf3b00136de8f9ab92e82814a595bf65340271c16c3 -9040b5caf5e4dc4118572a2df6176716b5b79d510877bbb4a1211b046596899ea193be4d889e11e464ffb445ab71907b -b9bf8354c70238ab084b028f59e379b8a65c21604034d1b8c9b975f35a476e3c0ba09dd25bf95c5d8ffb25832537319b -a7b492cc1df2a8f62c935d49770d5078586bd0fefda262eb5622033e867e0b9dc0ffc2ce61cd678136a3878d4cbb2b56 -95a5ef06f38743bba187a7a977023b1d9d5ec9ef95ba4343ad149a7b8b0db0e8e528bfb268dc7e5c708bc614dc3d02c8 -99dcf7f123df6c55aeff0a20885a73e84d861ec95cf9208ba90494f37a2dcaacebc8344f392547d3046616d9753c7217 -b3e14f309281a3685ceb14f8921c1e021b7e93c9e9595596b9fb627e60d09ed9e5534733fcbdf2fbc8c981698f5e62ac -816a5e0463074f8c7fb2998e0f0cf89b55790bdbbb573715f6268afb0492453bd640dd07a9953d0400169d555fdf4ac8 -8356d68f3fe7e02a751f579813bd888c9f4edcc568142307d1c9259caef692800e1581d14225e3a3585dac667928fa94 -8d70ea3314c91bfc3f7c1dcf08328ae96f857d98c6aac12ad9eebc2f77e514afdbaf728dfcb192ed29e7ce9a0623ecbb -b68280e7f62ced834b55bc2fcc38d9ea0b1fbcd67cc1682622231894d707c51478ed5edf657d68e0b1b734d9f814b731 -b712dd539e1d79a6222328615d548612eab564ace9737d0249aa2eefed556bbcf3101eba35a8d429d4a5f9828c2ac1fe -8da42ca096419f267f0680fd3067a5dbb790bc815606800ae87fe0263cae47c29a9a1d8233b19fe89f8cc8df6f64697e -8cb2ffd647e07a6754b606bde29582c0665ac4dde30ebdda0144d3479998948dae9eb0f65f82a6c5630210449fbd59f7 -8064c3ef96c8e04398d49e665d6de714de6ee0fced836695baa2aa31139373fad63a7fc3d40600d69799c9df1374a791 -aec99bea8ab4e6d4b246c364b5edc27631c0acc619687941d83fa5ba087dd41f8eaec024c7e5c97cf83b141b6fb135da -8db6051f48901308b08bb1feb8fd2bceaedde560548e79223bd87e485ea45d28c6dcec58030537406ed2b7a9e94e60cc -a5b812c92d0081833dcf9e54f2e1979a919b01302535d10b03b779330c6d25d2de1f374b77fe357db65d24f9cbcd5572 -967d442485c44cf94971d035040e090c98264e3348f55deabd9b48366ec8fe0d5a52e4b2c9a96780a94fc1340338484e -a4b4110bef27f55d70f2765fc3f83c5ddcdfe7f8c341ea9d7c5bcee2f6341bcfbf7b170b52e51480e9b5509f3b52048f -a0d39e4eb013da967a6ac808625122a1c69bf589e3855482dedb6847bb78adc0c8366612c1886d485b31cda7304ec987 -a92f756b44d44b4e22ad265b688b13c9358114557489b8fb0d9720a35e1773b3f0fa7805ac59b35d119a57fe0f596692 -aa27e4b979af6742b49db8bf73c064afd83a9cfe9016131a10381f35a46169e8cfd1a466f295fcc432c217c7c9fa44a5 -845961319cc10bcfbb1f3cb414a5c6a6d008fb3aac42c7d5d74e892cc998af97bc9a9120c3f794e4078135e16a416e38 -a18dbe3015c26ae3e95034c01d7898e3c884d49cc82e71ddb2cf89d11cec34cc2a3dff0fafb464e8e59b82ce1a0a7a11 -a954aed6d7124fa5bd5074bd65be4d28547a665fb4fe5a31c75a5313b77d1c6fc3c978e24c9591a2774f97f76632bdde -8f983b2da584bdff598fcb83c4caa367b4542f4417cc9fa05265ff11d6e12143c384b4398d3745a2d826235c72186a79 -b2caa17d434982d8dd59a9427307dfe4416b0efc8df627dd5fc20d2c11046c93461d669cab2862c094eec6a9845990c6 -8c2baa5a97ee3154cce9fa24f6b54b23e9d073e222220fdd0e83e210c0058fb45ce844382828b0cb21438cf4cad76ee6 -b93437406e4755ccf1de89f5cbe89e939490a2a5cf1585d4363c21ae35b986cb0b981dec02be2940b4ec429cc7a64d4c -a90ac36c97b7ea2eddb65e98e0d08a61e5253019eeb138b9f68f82bb61cdbadf06245b9dfffe851dfa3aa0667c6ac4b8 -8bcdd7b92f43b721ddbfd7596e104bc30b8b43bdaee098aac11222903c37f860df29d888a44aa19f6041da8400ddd062 -98f62d96bdf4e93ed25b2184598081f77732795b06b3041515aa95ffda18eb2af5da1db0e7cfed3899143e4a5d5e7d6c -ad541e3d7f24e4546b4ae1160c1c359f531099dab4be3c077e446c82cb41b9e20b35fa7569798a9f72c1fae312b140b4 -8844a1471ff3f868c6465459a5e0f2fb4d93c65021641760f1bb84f792b151bc04b5a0421bbc72cf978e038edc046b8f -af895aebe27f8357ae6d991c2841572c2063b8d0b05a2a35e51d9b58944c425c764f45a3f3b13f50b1b1f3d9025e52ad -adf85265bb8ee7fead68d676a8301129a6b4984149f0eb4701eae82ec50120ddad657d8798af533e2295877309366e9c -962e157fe343d7296b45f88d9495d2e5481e05ea44ca7661c1fdf8cc0ac87c403753ca81101c1294f248e09089c090eb -a7c8959548c7ae2338b083172fee07543dc14b25860538b48c76ef98ab8f2f126ecb53f8576b8a2b5813ecb152867f18 -ae71680366e11471e1c9a0bc7ea3095bc4d6ceb6cf15b51f1b6061b043f6d5941c9f869be7cb5513e8450dca16df2547 -831290201f42ebf21f611ca769477b767cf0ee58d549fcd9e993fae39d07745813c5ce66afa61b55bb5b4664f400ece7 -af5879e992f86de4787f1bc6decbc4de7d340367b420a99a6c34ac4650d2a40cbe1cef5c6470fc6c72de8ee1fe6bcce4 -8d3c27e1b2ef88d76ac0b1441d327567c761962779c8b1f746e3c976acb63b21d03e5e76589ce9bb0d9ba6e849ed3d53 -ab23b09c9f4151e22654d43c1523f009623b01fe1953d343107cef38b95bd10afd898964946d3cb8521bcbe893e1c84d -8a6acade9520e7a8c07f33d60a87fd53faa6fbf7f018735bffcbbb757c3bafb26f547ceb68e7b8b6bca74819bfcd521a -94db50080d557440a46b6b45ee8083bc90e9267d40489040cbed6234bebf350c788ec51557b969f95194102fde8e9713 -8be8031f32504e0c44958d893649f76cec17af79efcd22bbedb78378f0a150845467e59f79a3f2a3b6a66bdf0d71d13c -a69a4ac47fd92e1926b5e14adcbebbef049848e8a00d4bb387340892e5a9333cae512f447201728d3b53c6cf980a5fdc -8fc713825277c5a8d9ef0a1f6219d141def6d8b30aff0d901026280a17d1265d563ff5192a0817e0e1a04ff447fb6643 -8bf0a85569c4f0770ff09db30b8b2ea6c687630c7801302c17986c69a57c30f0781d14b3f98a10b50c4ecebc16a5b5ec -896baa4135d5621fd6b6a19c6d20b47415923c6e10f76c03a8879fd8354e853b0b98993aa44e334623d60166ba3e3ca9 -b82cde1c2e75a519ef727b17f1e76f4a858857261be9d866a4429d9facf9ea71d16b8af53c26bde34739fe6ea99edc73 -b1a9e1f2e34895a7c5711b983220580589713306837c14073d952fe2aef0297135de0be4b25cbfaed5e2566727fb32ef -b42ed0e9eaf02312d1dba19a044702038cf72d02944d3018960077effc6da86c5753036a85d93cd7233671f03d78d49a -a402e34849e911dbf0981328b9fe6fff834c1b8683591efd3b85aa7d249811d6b460a534d95e7a96fdd7f821a201c2c4 -a774417470c1532f39923d499566af762fa176c9d533767efd457cc5e4a27f60e9217f4b84a9343ecb133d9a9aab96b7 -83dc340541b9ef2eb8394d957cd07b996d2b52ac6eb5562cbba8f1a3312f941c424c12d1341a6dc19d18d289c681ef40 -b2906c32d5756b5712e45dec53782494a81e80f887c6e1ef76e79c737625eccecb8fd17b20e6f84890d322b6ffde6eab -b89705c30cec4d50691bc9f4d461c902d6a4d147cf75ee2f1c542ad73e5f0dabe3d04cd41c6c04ab1422be4134cf1ad7 -8c3293651f4c4fac688bf5837c208b15e5a19ce51b20dd80ffc7fca12d3e615b2773cfc3ed62a1b39c66808a116bde06 -8fceb8ef481163527d1fc3abc7e1a5b3b6de2f654c3fe116d1367b177dcba2e0d2124a7216803513a3d53fc1e30435b9 -b2a42c827da630aaa3eb20ed07d136aa11ba01b4c8efc0a57ebab7d5b851a15daa6ba118bcffbc20703916e430e30a87 -a86340153abb3fe97414e2fde857e15aac27c9bb9b61258eea6766024f426ed0753f08f07f6b02b5375e1587ea3afcab -b006465e258e646f91ba889765113d3dc9bd657246c533cab6516d55ba054baa9d7276a3b0fa31730c3bd824845bf107 -a08aadc09428719cde0050d064c0f42c5b7c4f6c158227d7636f870957d6cfe821b4c62d39279a7c98f5a75fcb7bbfba -885e7d47ce9b50d21b95116be195be25f15223a6a189387575cc76740174c3e9044f1196986d82856b3fb25cdd562049 -b18c3780362d822cc06910743c4cbcef044823a22d12987fe2e56f3801e417f2e9cd31574ea1c5c6ee7673a14aa56e3e -a625570ef7d31c042d968018865aeeba34ee65a059ab1ec079c7a8ba1be9e24bce6afb7036c07d9d6c96ab014f95d661 -8fc9bd4764adc4c300b5bd49a06dce885d1d8aff9bae68a47976d0cd42110aa6afa2d7b90b64e81c0f14de729f2fb851 -91d88714cb669f5f00241aa5ab80dffb04109492ea9c72b59645eb1f85f3539c61db2ab418af986f42241df8b35445e9 -b98f14e664df2590dd2d00b5b5c817e388e5d9fb074f718637c33b3d4969c89e82fdd12db8997f5ff3bf5bb5ca5dd839 -86cb3d9f148cb2170317a4c22af7092155aa66ecff7ab1299b102fbbaa33ed2a284b97b08f529d2da9faea63fb98972c -92449f6b8a7c737ecef291c947cbd602c47d7fe47dc3426c2b413f3019169aa56e14c2a7216adce713e1c7bd5c08a83f -b08c1b9080bba88b44a65070948142d73c00730715fbdd01e13fc3415c5b4f3248ef514fa3ade4a918c9a820cccae97c -b0a05297da76e37c22be7383e60bba1cbc4f98ba650e12d4afcfcea569842003644a10ad73c9148958f7bf1ffa0a27d0 -839092c1f4e9fb1ec0dde8176f013b0d706ab275079f00f8e774287dd658d1b5638d5fe206f5f2a141911a74bb120f75 -a36bd669bdc055ece4b17ff6eac4c60a2f23324a5eb6d0d6c16a2fce44c39cfd52d1fa2b67f3f5e83504e36426fbfc40 -8aa428323512cf769645e2913a72976d32da4c0062ffe468a6062fd009340f0f23c6b63285848a0e7631a907adb032a0 -944800f7d43f41283eb56115ac39ccc5bf107ae5db6abcaba6936b896260cd09428a6b828c0bccebeb00541073dbf38e -8e700ca7c9e1538cf64e161dd8d16af56fc29d53c79648150d6d8c268b0c95c76acded723e29918690d66252bd75f5b3 -b9c4ce35b5b16b4c39b6e85800c76b26e8d0999500fabc1e5b6234a7f8da18c621266ac0d5ebc085354297ff21ac89a5 -a0c706d32063f1877f7e903048ce885f5d012008d4a8019dd00261a8bbc30834bffeba56cdeddc59167d54cc9e65f8fa -839813b736225087cbbcf24506ea7bf69138605036b764ec0514055ac174bbc67c786a405708eb39a6c14c8d7e0ec6ee -b1a5fef055a7e921c664f1a6d3cb8b21943c89b7e61524a307d8e45aa432e5765a27c32efdb32d88062cd80800a260de -b17f8202d9ed42f0f5cb1b1dbda60711de3b917a77f6069546fa3f86d21f372b8dd5cb86f1994b873ba9982404e08daf -b5211d54bd02d44d4d808ad57067606f3e9fa2cad244a5f2acef0edf82de3c496d2b800f7c05f175d01fa6ace28b44d1 -aa9c6f8f489b35fdb7544116fe5102a34ff542de29262f156df4db4ea6e064f5ea20c4bd877d40377ed5d58114b68f19 -826668b1f32e85844ff85dd7e2a8e7f4e0fd349162428bc9d91626b5ab21bdbacd1c9e30cf16f5809b8bf5da4f4fe364 -b30d14917b49437f9fdbae13d50aee3d8a18da3a7f247b39e5d3e975c60bd269da32da4e4cc8844666fca0d65f4e3640 -8c6918d8d94b36c6b9e772e9a432e66df16724e3b0660bde5ea397e6ef88028bb7d26184fbe266a1e86aef4a0dfe5faa -906d80ffd692c1dd03ab89be52e0a5a9e90a9cdbfc523d2b99c138ae81f45d24c34703f9cb5a666b67416e3bb6272bc4 -8b07e8ba22b436e64f011cacf5e89c55cd3bfb72ae8b32a3a8922c4fccb29de6f73662d6e330da6aa6e732a2187ef3c9 -9547466b4553a49adf59cc65d4c3c9401b2178947ebe3bd33c6e63cfb67d6be8729033158594f6f244b272c4487d6958 -aafcccea41e05cb47223fa8dfec0dd55964268bd4d05e24469614077668655ac8a51d2ac2bfb22862f8f4fa817048c2f -870f8c1173e8fd365b0a2e55c66eea3ab55355990c311f3042377803d37e68d712edcc5a0a2e2f5a46df0c1c8e6310c2 -b4288f792008f342935f18d8d9447fe4ddcfea350566e13dba451f58c68e27241af1367f2603a9dff6748e7fe0c53de4 -91c58c0e537d3afdcf7783601dd9cda2aa9956e11f711b15403760cf15fc6dffb40ed643886854571da8c0f84e17adfe -a43fec8ee92febed32e7cdd4e6314a62d9d3052c7a9504057dfba6c71fdfbeff1cef945d8f087bd106b5bec7478ad51f -99cf5e0e3593a92f2ec12eb71d00eccec3eec8662333471b2cb3a7826b7daca2c4d57ffba18299189cf7364e2af5df6d -af50f9ab890b7517ff1f1194c5b3b6f7f82eabc607687a8380be371a6a67b117aeb9b6f725556551b81f8117971706a2 -aa352430887053602a54403bd0d24d6b5181b44aa976dfa190e21851699a88127dcc904c90a48ec44610056b5dcd36c4 -964c821ea1902354736fa382a929c156bd67b9468d6920d47c27b9d0d304b6144118888d124c1f6785da596435ed2410 -b2284a67af26b5f5aff87b4d8e12c78ab37c5eb6e92718fca8549f86f4f001b660fc4520456aff72c9bcddd686603942 -83c54cbb997ea493dc75df4023071dce6da94268feaa2352373789616f012098270ba4fd60c791796a6f5062fb2cd35e -9143e8fee0b8f0f34c65c7750858093dcf165c6a83c026bfac2d5ffa746361eb4b6a14fdb43e403add901ac3735735a3 -97d7748a5b278ee47b18c9e60689b12a0a05be47e58e78bf8c04b9e8b34e2e2f2d3ac3c25c76ab2e0a75e8a54777b7c8 -b4e68f6f2d978a5411414c164c81ddb2a141b01ebe18c65a8626ca75d6432e5988310b50a888a78c3a0a242353525af5 -8976f4cc3eaf2684718cf584712c4adaf00a4d9c521f395f937e13233b30329658b3deacfe7e29fac84c496047f2d36b -a40bcdf4b6e95f1535c88dddcbf2074ef2e746b7fd232bdfd2b88f2f6d4bbf21c6b263cf5fd3e12a03476f2f5ffe00d2 -88c7b6337ee705acd8358ef6d2242d36b140afff0579a7784b3928a0c49698bd39c1f400e8a2e3eda5fbfb2e8f28fe51 -a98612ba8b450a71d2075d51617ebeb7ca401ad3cbd9b8554850c65ef4f093ba78defb00638428c9f1f6f850d619287f -b7e71d3ffa18b185c1a6bd75668ff65d985efc0a0c19f3812cafde9adbfb59ffd108abeb376e6a8877fdf5061562f82b -8a3e5fd776cc26908a108a22b1b122d60cb8c4f483cbedcd8af78a85217bb5a887df3efed2b8b4ec66e68eb02a56ca93 -b0d92b28b169d9422c75f9d5cb0a701e2e47b051e4eacd2fd1aa46e25581a711c16caf32f40de7c7721f5bf19f48b3f5 -88895739d5152282f23e5909cf4beebda0425116eb45fc5a6a162e19207686d164506c53b745fb2e051bb493f6dbad74 -adbccfed12085cd3930bd97534980888ee564dda49e510c4e3ca0c088894855ef6178d5b060bca8a8a1a427afdbec8a8 -87d00674abd3d2e7047a07ed82d887e1d8b8155635887f232dd50d6a0de3fb8e45b80b5a05bc2ec0dea9497b4aa783ac -806e1d3dfadd91cbf10e0d6a5e61738d0dbff83407b523720dce8f21f8468b8a3fc8102acf6ba3cf632ca1cb2af54675 -95a9dff67cf30e993071edede12623d60031fa684dfbe1654f278a1eb1eb7e1be47886d3f8a46c29b032da3176c0d857 -9721973288384c70a9b191436029e85be57970ad001717edc76d44cbfa0dff74f8af61d5279c5cd5c92c9d0f6c793f63 -95c22d1d9b51ef36ba30ee059dcd61d22be3c65f245d0a5179186874219c08e1a4266f687fc973e71f3e33df2b0f7fd3 -b53ec083dd12cc42ae2bae46883a71f2a35443c9ce4ed43aa341eb5f616a53b64211ed5aac717fe09ef1d50f551ed9f0 -a103dab6695c682400f60be8d5851ce07f12e4bd9f454d83b39c41ddcf1443bb14c719b00b4da477a03f341aa1e920cb -b522236988518e5363b1c4bb3f641ff91d3d4c4d64c5f065415b738160b4ce4b0c22e1e054a876aa6c6a52fa4a21dfa2 -a6a00562f0879702cdba5befd256a09f44bf48e61780e0677ff8c3fda81d8e6dc76ba1b05e3494ca9a4cef057eba6610 -b974a2ae631e0b348421f0cda5bd4ce7d73c22dd0fc30404c28852c33499818cab89fbf5c95436d56a0aab3bf2bbab51 -9148cf2a7b7e773245d4df5a9d34cf6d9d42b1a26a4ca6bc3013feca6f3941d6c44f29ba9328b7fe6ce6d7f6565f8e4a -a34035c4a63e98528a135cc53bbbcfcda75572bc4c765f212507f33ac1a4f55563c1a2991624f7133c77b748bbe1a6da -a0c45923cfb7bd272ee113aecb21ae8c94dda7ad1fe051ddb37ab13d3bb7da5d52d86fff9f807273476c24f606a21521 -81ec2ca57f4e7d47897d0c5b232c59d7b56fe9ce0a204be28256a7472808de93d99b43c824a0cd26391e6cac59171daa -8373852f14a3366d46c7a4fc470199f4eebe8ee40379bd5aae36e9dd3336decaead2a284975ba8c84d08236e6b87c369 -b47e878a93779f71773af471ba372cb998f43baca1ae85ea7ff1b93a4dee9327e2fb79691c468ec6e61ab0eae7ceb9f1 -8fc8f260f74303f26360464cfef5ee7eebcbb06073cef3b1b71dab806d7c22f6b3244ce21d0945b35c41f032f7929683 -87e3c4e1dab00596e051ce780b9a8dba02ecdc358f6ddaeb4ec03c326e4b7da248404745392658eb1defff75b1ba25c8 -aac95d8e3b7fe236a7ca347d12a13ec33073f2b2b5a220ecfd1986ca5c3889f0e6a9d9c377a721949aa8991c1821953a -91a483679437ae126a16f5dc3bba6e9bb199dfbba417f0dc479f22819b018c420edc79b602db6183c6591b1909df4488 -94a4b2c663aa87a2417cad4daf21a88b84983a7b212ffcd18048a297b98e07dd4c059617136976fac1d9e94c8c25b8d2 -83e2a690bfa93c79f878a63c0f69f57aabdd8bede16b5966ffba7903dc6ad76775df1fd5347e6f2825f6cd7640f45a45 -a316af7ac11b7780d15312dc729499a1a63b61c4283e103ecce43c3b0cbb0f4bce6ff04e403f5c7cb670dee80c75ab99 -8d0a911c54ee1f9f7e7794732ad87b434c3f356294d196a5e35eac871727fd32a49c27c2dfa10833f9e6f9c7ccbe0064 -8b8db09028298a1f6362b346c8bfeced7cb5d13165a67c0559a9798a95b7a4a9810c02bb852289d47c59f507bd24ce77 -962d57305c518f175ed5d0847fb52ddc4258ca0e4c9ddfc8c333a2ee9f8b4e48d25a3d7e644b785a5953e2e4063da224 -92e0799491898271769250fe88b0cb9dadec98ac92f79de58c418d23ef8c47fcf21ddc90e0cd68bb8f1deb5da82da183 -99855067125f6a6c3a3e58d3bd2700a73ef558926bd8320d2c805a68e94207b63eda6bdc5a925ec36556045900802d51 -a724ae105ab4364a17ddb43d93da1e3fc6b50213f99b7be60954b24dc375c4f93a0737f4a10b4499b6f52667d5f3a64e -82070fb43a63fb50869b118f8940108f0a3e4cc5e4618948417e5cc3801996f2c869d22f90ca4ca1fdbef83c4778421a -b25c04365d6f24d5d3296c10d85a5de87d52a139ddbcbf9e0142074bc18b63a8bc5f5d135bd1e06c111702a4db4cee28 -851093282dcda93e5c98d687a17a7ee828cf868f6c85d372d9ae87f55d0593d8f9f0c273d31f7afa031cf6aea6a7ef93 -93f04f086fa48578210ed207065d80a40abcc82d8bfc99386a4044561d35748ff6c3da6489933c23644ad4b60726da8a -84b1b50d1e876ca5fc341bbedab5b3cc0f6a3f43ea7dd72605f74d0d9c781297b2f12b7872dd600924f1659a4cdf8089 -81b0ba88c582d3956f6b49ca3e031c6400f2ec7e1cd73684f380f608101e9807f54866be0bb9a09c03953c4c74fbb3c8 -a641af6ac644c41a55dee2ef55d3c37abdb19d52bc1835d88e7adda6b6ccd13987c5fd9cba9d318cabb541aa6a0c652e -a7b75b0624d04ad0901070e691eb2d2645b60f87e9d6b26e77a5fb843f846c32fc26e76ae93fd33fe3b857f87bc25162 -a81ba3e2ed0f94c67cd02ba7360e134f8becf7ed2ed2db09b9f5ef0942f7073bfee74ca446067db6092f7b38f74ccc11 -ab80edcabab5830a24210420f880ebac4e41bf7650c11ba230f4889634dbf8e8e2309f36be892b071c67a3bab8fc7ed6 -94d69b64675076fecad40fae4887fb13a8b991b325fa84e9d2d66e3b57646de71a58ad8fd8700fefb46975b18289250b -b44fc0df480cd753a041620fa655be9df74963ae03d4625847d5bb025ceb37f48d19c8c9c444546fba5fe5abb2868506 -b56e2c51324d6200b3d9781b68b5b5e1617a68afccd28b3a12a4be498d2e3aafcd86514c373a9f3a001db733010c29cf -a359a0c172e5cd7ce25080dd2652d863d7c95a4a502ae277ac47f613be5991300f05978404a0acb3bcda93524dcf36e4 -b01427a3dfdf8888727c0c9b01590b8ae372b7b4080d61e17ccb581bac21e61c4a58c75db7a410d1b2a367304e1e4943 -95cb08be4a96c18fbf9d32a4bbf632242029d039a5fdea811488d3634cd86520d4f9806250a8c01855ee2481210f542a -b8594fe6c0717164058f08aedeed1853523f56cec5edbf0d2be271fa5e8bfd61f2974b0f3988d70f5baa2e7888c7ec1f -8f64ee89f59daf74fa1056803247c9d678783ee3917b12a201f30f7523957763e979ceaddb38bae20de40b9885728049 -b6093ee4bdb837bcc59172e236f4bdbd439c0a5a50e2aa16636cbff81b51e92989eb5f80a3f75c37ae7b5b942e55b3d2 -913b6fbb7b43e3e5c49e96cd8e82ed25c655e51c7b8ca82e8fbf92b01ac83c39d52f6f4efab5d39b0591a0538601a86f -81f42668479ca0bec589678dc0973bf716b632578690efe1a0f13de630f306fb4a189a98c2302572fd85d3877ee030b5 -90ff89c38a9a7189f28d35a088657f52283670e7fec842fa91c265660ea2e73b0ad6c46703d649f406f787490b7a7e4b -9077b8b5f1e083183f3152ceb9c5491b5d4b86525a08879f7fb6d5e27f9f1a6867cf0d81b669a4a2d1f1654b67fa8d9c -a7a0275cf5b894adbf2e54a972310cfe113e811872111d6ee497d03750d9f6ffa5517b6c13a99b111a4a91e8e4dfeeee -a08976bf8125b7538313a584bbe710741d630cab067a204ad4501cc4938874ce7aa6a1a826259c2e82ef10a66f1f36fa -8aa45385b5b97f1f3e45f2bbf7a4f3e8ef068e628608484971c97adeb610ebd5deec31317e03eb6536808921062c04db -945b106b8f3ae85e60dfd34ef3dcc079bc6f0aab6df279ed000856efd51321462038ac0a1ca5db3ebf6379bc341e7c55 -a4199c87a96f98cc9d8776fe6de131d2c706b481eb9e9a3bbc50a93d492d7fd724ea469f723fbcfb94920cb5b32c1d76 -a5347b1b2f6149805de67546c5ed72253311099bf1473dbc63edcf14a0a5e68d401f5341338623fbe2e2715b8257e386 -af5dcd03ddc3769e83351d6b958d47a06d4e5224bd5b0ec40ffe6b319763fab8572002f4da294a9673d47762fd0e6e1d -82ec1031b7430419d83b3eea10a4af4c7027f32b91c3ae723de043233b4a2e0c022c9e0f5a1ac49753800f119159112d -8a744d911b67d03b69811f72e9b40d77084547e4da5c05ff33893468b029a08266fc07303f7005fd6099683ca42b3db4 -93ab566bd62d3439b8fc620f3313ef0d4cb369f0f0c352cdaf8e5c9e50b9950ac3540b72f4bf5adcb9635f9f7ce74219 -b2a211d72e314799bc2ac7030b8bbb8ef4c38ebd0ebb09d6cbd43bd40c6c61d80a3aad02cc73f5775a08b9657da20a48 -98d60f0a98d28718e0c6dcccc35a53521ea7f2d8fe08ea474374a336b44cea4cd1c63b31f2ad10186822bfb54aca53e6 -831f89cb94627cfe554d46ae1aad8c1cde7ebe86c4bd8fac4ef73ac2d5b491f5efa5dc4198cb8ffbec563e0606b91d89 -8f8552583bc6cb3fb176b7202236ee4128faf0c8ec608f9150f8e011d8c80b42aab5242c434d622b6d43510eaef752c0 -897bf27baaee0f9a8445200c3d688ae04789c380d1b795557841606a2031092328eb4c47fef31c27fdd64ba841d9d691 -b57589a4af8184b4a8ceb6d8657a35522672229b91692c1cec3ac632951e707922a00086d55d7550d699c4828bcfaab1 -98c2fe98095e026aa34074bcff1215e5a8595076167b6023311176e1c314b92b5a6d5faa9599d28fca286fadd4e3b26c -a034992e563bd31ede3360efd9987ecddc289bc31046aa8680903bb82345724805e6f6cf30f7889b6b95cf7319c3aea1 -85c33d9f10cc7185f54d53c24095e621966065e0ff2689a9aa6bb3d63706796c37a95021738df990c2c19493c0d44b64 -a8c1247d6de2215f45b50dd2dc24945ff9b93184bcc2159b69703b0bba246adcd1a70a12659f34c4ca4ba27dea6e3df5 -83ebdad2834c97bf92aac8717bab2f5cb1f01026b964d78e2f3b44e99d7908e419165b345d2b2f125b903096584e6683 -b0af6f7f81780ceb6e70adfd98e7702ec930c8ca854b50704c4a0fc8b887b9df60a6fe9038b487f3ed0eb8eb457307ea -933ec7e53882453898617f842ab2efae4756eb6f6ea0161cced5b62a0cdde4c08c7700d52f7546d4dd11a4c9e25d624e -adf6e6d4706025f85eb734f506dde66459c9537a1abf6189199cf219ae583b461e11c6242fce5f0795e4d9025270fabf -89e4316319483098761b0b065df4cfb542963b7a2556ba5425b6442fb0e596eb2a4f03e2dc8c617eebe8f243a12e7d10 -90c5a147555759ebc4d0e15e957a548315f9994ef0c7a3f53f2d18da44fb93bf051d96ba8551597a6f3e701b926fd791 -a151a9a5199c72c697b771cd81e550fc6f9596c752ae686ad988b316a7548360cf9785ab4645164d96cfdf9069a94020 -80cba11a3977729d7948db5bcc186159f4cae7c0a835bb38bb781e287dd6c238508e748f23454405c9d5eed28e77df02 -ae4b92ea03cb8ad12ad3ec76869ad05acb09f9d07a3c9a87dec0e50d9a276fe5d3d515a8c446f3aa35cd7d340a22c369 -8630062709a1f180f952de9f1ca3f41acce5420677f43d9619097e905a6237f1908d66db7a4dfdf1b2b92fb087e9944f -81defc33dd383d984c902c014424bddd5e53b013f67f791a919446daa103b09b972fa5242aba1b1dbe4a93149373f6c3 -963891ecaea97e661bac2594642327a54f5a0beb38fcb1c642c44b0b61faab9c87b0c9f544a3369171b533d3ab22f8f1 -932fadbff5f922ddcd4da942d57fe3e6da45c3d230808d800a3ca55f39b0b62f159be31a5924b395d577a259f48c6400 -992ce13bd037723447f88aeb6c7722fd9510c7474192b174ea914ed57c195c44c298aec9a8cabac103f0a5b50051c70b -b032157b3e4fe69db6ce6bb10bdf706a853fbd0bee08c2ab89da51ad827425df5df498b90e7a30247a7f9e954ca986e5 -b2478d4874578da3d5000893736bb65712e6aafe96e6fa5cf5878ae59ba0ce640dbe5d76ec2b5baca75af57def471719 -a387c17b14dd54910fecf472f760e67cf71a95e9e965cc09484e19581ada65e79938b86136a93e287e615fbd4908e080 -98f02be271d0f8841d8d561163f9e55e99b57aff121a93fba7a4654bcf15a0899811f00f5bcbfbebd98e365a0e332e97 -a3c34f01d54cab52a8890391b8cf152cc9cdc16e7e53794ed11aa7b1a21e9a84d39ddcfbcb36c5df6891c12307efc2e0 -a940331f491ec7ad4a9236ca581b280688d7015eb839ee6a64415827693d82d01710dc4bbd5352396be22781fea7a900 -b10874ed88423731535094031c40c4b82af407160dfade4229ac8f4ef09d57b3db95c4a9d73c1a35704f6bd0d5f6c561 -a9c5a4a7680261c1b0596f8ab631d73d4a7881b01e6559c628b5cdafa6dd2b6db2db64f3f2ab5841413a8a52b966a0da -8fc154564a61d5e799badc98b43a3587f804385a850adce9a115cbd2ad911f3fd4072b8e6b22fc6c025a6b7e7ea5a49f -b9caf7c6dcce3d378aa62c182b50bc9c6f651eb791d20fffa37ef4c9925962335fe0b3bc90190539312aa9ccf596b3b9 -90c5b7acf5cb37596d1f64fc91dee90f625f4219fa05e03e29aebea416c8e13384f2996f8d56791bcf44ae67dc808945 -ab8d311fc78f8a1b98830555a447c230c03981f59089e3d8a73069d402a3c7485abe3db82faf6304aaca488a12dbe921 -8a74fda6100c1f8810a8cacc41b62875dd46d5c4a869e3db46202d45a8d9c733b9299dda17ce2ad3e159122412a29372 -8769dcacba90e6fc8cab8592f996c95a9991a3efecfb8646555f93c8e208af9b57cf15569e1d6e603edac0148a94eb87 -854fd65eea71247df6963499bafc7d0e4e9649f970716d5c02fbd8708346dcde878253febb5797a0690bd45a2779fa04 -83e12dc75ef79fd4cc0c89c99d2dace612956723fb2e888432ec15b858545f94c16fae6230561458ceee658738db55ba -8416ef9ac4e93deff8a571f10ed05588bef96a379a4bdcc1d4b31891a922951fa9580e032610ac1bb694f01cb78e099b -93aea6e5561c9470b69d6a3a1801c7eef59d792d2795a428970185c0d59b883ab12e5e30612d5b6cde60323d8b6a4619 -91d383035aa4ec3d71e84675be54f763f03427d26c83afb229f9a59e748fb1919a81aca9c049f2f2b69c17207b0fb410 -b1c438956f015aef0d89304beb1477a82aed7b01703c89372b0e6f114c1d6e02a1b90d961b4acbb411cd730e8cacc022 -a1ee864a62ca6007681d1f859d868e0bcd9e0d27d1da220a983106dc695cb440980cfdb286e31768b0324b39ae797f18 -b57881eba0712599d588258ceada1f9e59c246cc38959747d86e5a286d5780d72d09e77fd1284614122e73da30d5cf5c -a48f9ae05ba0e3a506ba2e8bbce0d04e10c9238fa3dffa273ef3ffe9ec2ed929198a46507c0c9d9b54653427f12160f9 -8db18da7426c7779756790c62daf32ae40d4b797073cd07d74e5a7a3858c73850a3060f5a3506aae904c3219a149e35d -a2bf815f1a18d7be8ce0c452dfc421da00dcd17e794300cdd536e4c195b8c5b7ccc9729f78936940a527672ac538c470 -a34c6f1f2398c5712acc84e2314f16d656055adcafad765575ae909f80ab706cf526d59e5a43074d671c55b3a4c3c718 -b19357c82069a51a856f74cbb848d99166ce37bd9aca993467d5c480a1b54e6122ebddb6aa86d798188ea9f3087f7534 -b440eac6f24d12c293d21f88e7c57c17be2bdb2a0569a593766ae90d43eccf813a884f09d45a0fb044ee0b74ff54146a -b585d42ef5c7f8d5a1f47aa1329f3b1a566c38bf812af522aa26553010a02bfd6e9cc78fdb940ef413e163c836396a5f -aca213b27f3718348e5496342c89fffc7335f6792283084458c4a1aa5fe0a1e534fcec8e7c002f36141308faae73ef2a -b24c07359769f8ffc33bb60c1f463ea2baad440687ef83d8b7c77931592d534b2c44953c405914ace5b90b65646c1913 -b53dfaf381205a87ca4347328ff14a27541fa6436538f697824071d02d4a737ceb76a38dcc6e8dadef3b5bc6442f5109 -b55972d8ed5197215c0a9144fc76f2cd562ca5f4e28c33a4df913363fd1388978b224c44814adb4c065c588a4ac1fe10 -a3303bc650e120c2e9b8e964ad550eb6ac65ffe6b520768b3e8735565ae37eafdc00e3c15fae766d812f66956a460733 -b11e53912ea0e40c3636d81d7637e10c94cc7ed9330a7e78171a66d02b7603f4cb9b3f6968104b158de254e65b81640f -b076bb9f6d396aa09c2f4706ea553b426fdfd87d7d69e438285b74d334e82f73973cb4dbd6cb1647493433dad65dbc41 -9415828b1632175f0b733541e32c26a9c88fe12c721c23e595f2efceaa7f867f359e32564b7c032185686587ac935cf4 -89579a112c306181c79aabdbf683e7806357febcb73bf5e8883862ae29618ef89498b62634404bb612d618fcd16da415 -8761bcd55d04297c4f24899e8fb9f7c1fcd7449ae86371ee985b6a262e228f561c2584980694d9bf354bdf01543edb6a -9100c88bf5f6f00305de0c9cf73555f16a2016d71c50cb77438e8062bd549fa5407793a8a6a7e06398756777680a2069 -9235dfef45aeff9c174898b0755881b7171ed86362854f0eabc3bc9256176c05a5dc27ca527c91c3fa70c0ec5fd5e160 -ac53b1d677cebab6a99381dd9072b8ac1abae9870ec04a1f8d2a59b6f1de797c1492b59af6948f5cf2b20599170f5bba -946542936b0c59156e8fd5c1623b41369bc2cbcc46ece80360dcb5e7cce718a3dd8a021f0b9c223062a4e43d910b634f -b1e9939b34e1fcc026e820fcfa9ce748b79499f8e81d24a3ef0457b3f507fe5fa37b975a47c143e92eb695623b4e253b -9382d9b5766f6ae960d8a8435e8b5666e57ef8e5f56219e7bfd02857afe5cb16f44d70a9e444cfb1008649ae9b863857 -91770ed1215ed97dca1282b60b960be69c78e1473edb17cd833e712632f4338ff74bf435c3b257439497c72d535ae31f -8eb2cbe8681bb289781bf5250e8fa332141548234c5c428ff648700103a7cd31fdc2f17230992516c674aa0ab211af02 -a823b71c82481bc6ac4f157d5c7f84b893a326bbb498c74222427ded463d231bc6e0240d572ab96266e60eb7c8486aea -a13ce4f482089d867e5babcd11c39fa9a9facd41a2c34ee2577de9ce9c249187e16f2b3a984cc55f9e45b9343462d6d2 -8d80e7bc706059cf5151f9f90e761b033db35d16b80b34dc8b538adc8709d305a0c06933dcd391e96629cf3888c8bf87 -abcd36cdd86c0fb57fb7c0d7a3b9af5fd9aed14e9f4e7e84b0796c5c0ad18c41585e8c46e511cef73dc486fe43f6a014 -a947a5b6916f416fa5a69c31aba94add48584791148b27d0b3ed32c02a05dfc06f7fdc5006e3b2503bdf6e410e30f2fb -b158e621580659f1fa061d976b8591ac03b53ecd23d9eb2b08c1a20353d78438287749664d196020d469ef44b3b8752e -90a5a9540281e481ac4b8d29968f477cb006b56bd145529da855d65d7db0cf610062418c41a1d80c4a5a880c0abe62a0 -b2c91808b6289d08a395204a5c416d4e50a8bb1a8d04a4117c596c4ad8f4dd9e3fb9ce5336d745fc6566086ae2b8e94f -af6767c9b4a444b90aeb69dfddae5ee05d73b5d96e307ce0f3c12bccca7bc16475b237ba3bc401d8dafb413865edf71e -8dcecf624419f6517ef038748ac50797623b771d6111aa29194f7d44cfb30097ced26879e24f1b12a1f6b4591af4639b -954437559d082a718b0d6d7cec090532104ab4e85088e1fc8ee781d42e1a7f4cdb99960429707d72f195ff5d00928793 -80f0b7d190baa6e6ab859dc5baab355e277b00ddcca32e5cebe192877ad1b90ead9e4e846ca0c94c26315465aeb21108 -b8c29f181ed0bb6ac5f6a8d9016980303bb9a6e3bd63ce7a1a03b73829ac306d4fab306ac21c4d285e0d9acb289c8f2a -a7685079fe73ecaeabf2a0ef56bad8b8afb6aeca50f550c97bf27e6b4a8b6866601427fcd741dc9cb4ce67a223d52990 -ada2ebf6f2a05708d3757fbf91365ec4d8747eb4c9d7a8728de3198ceac5694516ab6fd6235568aecd8d6d21fef5ef48 -846bc5da33d969c53ab98765396cab8dcdbb73b9836c9bda176470582a3427cb6de26d9732fab5395d042a66bdba704c -800a3a7ea83ce858b5ebc80820f4117efa5e3927a7350d9771cad9cb38b8299a5ad6d1593682bba281c23a48d8b2aa71 -a002b18595dec90b5b7103a5e3ec55bdd7a5602ee2d3e5bd4d635730483d42745d339521c824128423dfe7571e66cbaf -b6b4e2067ac00a32f74b71007d8ab058c2ef6b7f57249cb02301085e1a1e71d5de8f24f79b463376fd5c848f2ab1c5bc -a3e03036db1b6117efe995bf238b0353ad6f12809630dca51f7daaaf69f7db18702e6b265208944bfb1e8d3897878a51 -add16712f66d48aab0885bd8f0f1fb8230227b8e0ffca751951c97077888e496d6bfab678cb8f9ffba34cee7a8027634 -ad211af2dd0748f85a9701b68c19edd4a7c420e497cb2e20afdc9df0e79663841e03b3c52b66d4474736f50d66c713ce -8c8a899ce0f16d797b342dc03c2212dda9ee02244c73c7511626dba845d11a0feb138441da5459c42f97209bf758cd9b -a17efc75c7d34326564ec2fdc3b7450e08ad5d1de4eb353de9d1cd919d90f4be99f7d8e236908b1f29cf07ae1ffe0f84 -862d4a8b844e1b0dd9f4deff180456ebed5333b54290b84f23c0ddb2725ac20307e21cbb7343feac598756fe36d39053 -9187fbb19e728a95629deda66a59e178f3fcd6e9d7877465aa5a02cea3baba2b684bd247b4afbf4aa466b64cb6460485 -85ae5636688d06eab3be16e44fe148515d9448c6123af2365d2c997f511764f16830610a58d747adab6db5031bea3981 -8aa8a82891f4e041ce6df3d6d5d7e5c9aaaffe08e0a345ac0a34df218272664c1b7be2450abb9bc428bd4077e6e5dcc4 -8c3bcc85ea574dfe1b9ca8748565c88024e94374434612925b4e9a09fa9d49c0a56b8d0e44de7bd49a587ef71c4bff5f -9524f9dd866fe62faf8049a0a3f1572b024120d2e27d1be90ad8b8805b4e2c14a58614516281cc646c19460a6b75587c -84580d9c72cfa6726ff07e8d9628f0382dc84ce586d616c0c1bd1fd193d0a49305893eae97388de45ba79afe88052ee9 -b5573e7b9e5f0e423548f0583423a5db453790ab4869bd83d4d860167e13fd78f49f9a1ffe93ddddf5d7cd6ec1402bc4 -aff658033db3dad70170decb471aee2cf477cf4d7e03267a45f1af5fd18200f5505c7ce75516d70af0b0804ec5868a05 -84a0eab4e732a0484c6c9ed51431e80cea807702fa99c8209f4371e55551088a12e33a11a7ef69012202b0bc2b063159 -a68f8e730f8eb49420fe9d7d39bb986f0584c1775817e35bb3f7dae02fd860cddf44f1788dc9e10d5bf837886b51947f -946002dd6cf7a4fd3be4bf451440e3f3fd7e9b09f609fa4e64767180b43146095dfc4b6994287f8cfa6d1390d144be71 -b7f19777d0da06f2ab53d6382751dc5e415249d2c96fce94ef971401935c1d1f7d3b678501e785cf04b237efe2fe736e -81e5c66dd404fc8ffd3ac5fe5e69ead7b32a5a7bc8605a2c19185efcc65c5073e7817be41e1c49143e191c63f35239c1 -b5f49c523532dfa897034977b9151d753e8a0fc834fa326d0f3d6dacc7c7370a53fc6e80f6d5a90a3fbec9bbb61b4b7c -8fc8e78c07319877adfaa154a339e408a4ae7572c4fb33c8c5950376060667fbfc8ede31e1b067933d47e3fdbf8564d7 -859cfef032a1a044532e2346975679545fbb3993a34497ce81bdcc312e8d51b021f153090724e4b08214f38276ee1e0d -ae476722f456c79a9c9dfdc1c501efa37f2bff19ab33a049908409c7309d8dd2c2912aa138a57a8d5cb3790ca3c0ba2f -89acbbeffb37a19d89cfe8ed9aa8b6acf332767a4c54900428dd9ab3bf223b97315aca399c6971fe3b73a10a5e95a325 -90a4a00418fdf4420a4f48e920622aae6feb5bf41fd21a54e44039378e24f0d93ccc858d2d8a302200c199987d7cb5e4 -a3f316b0bd603143eba4c3d2f8efe51173c48afe3c25b4ca69d862c44922c441bd50d9a5040b7b42ba5685b44071c272 -a22f4dc96fedd62b9a9f51812349e04d42d81d0103465c09295a26544e394a34abdc6ded37902d913d7f99752dbfb627 -a49f51baf32d0b228f76796a0fef0fe48a0c43ec5d6af1aa437603d7332505be8b57b1c5e133bc5d413739f5ae2ce9d0 -a9e4fe133057a0cd991898e119b735b31a79811307625277c97491ff5d864c428cfa42ae843601d7bb05c0313472d086 -b987edfe0add1463a797ff3de10492b2b6b7ef0da67c221ab6f0f2b259445768a73fbe495de238c4abbe4d328e817c49 -b7f0e4532a379a4c306bbef98b45af3b82b17175dfe0f884222ed954c12f27d8a5bdd0cdeb1df27ff5832ba42a6dd521 -9471bc5ad5ec554acfd61b2eb97b752cb754536f95ae54ca2cbd1dc2b32eb618881f6d8a8b2802c1a4e58c927067d6cf -b4c84f09225cf963c7cc9d082efe51afbbbe33469dd90b072807438e6bde71db8352a31bb0efde6cd3529619812ef067 -8f08005a83e716062d6659c7e86c7d3b51e27b22be70371c125046de08f10ea51db12d616fbf43e47a52e546e7acaac7 -a8937e66a23f9d9b353224491f06e98750b04eca14a88021ee72caf41bdce17d128957c78127fba8ef3dc47598d768a7 -80ad991de9bd3ad543cddeaa1d69ca4e749aaefb461644de9fc4bd18c3b4376c6555fc73517a8b1268d0e1e1628d3c1f -b22f98bca8fe5a048ba0e155c03e7df3e3cee2bfe8d50e110159abdb16b316d6948f983c056991a737b646b4d1807866 -b0bb925c19ca875cf8cdbefa8879b950016cc98b1deb59df8b819018e8c0ad71ea7413733286f9a1db457066965ce452 -95a991e66d00dd99a1f4753f6171046a5ab4f4d5d4fe0adfe9842795348a772d5a4a714dba06b4264b30f22dafa1322f -ad91e781fa68527a37c7d43dd242455752da9c3f6065cd954c46ae23ce2db08f9df9fec3917e80912f391c7a7f2f7ffa -a202d3becbf28d899fe28f09a58a0a742617c1b9b03209eca1be7f072a8ada1f7eac2cc47e08788d85e1908eb9d3d8ee -a360ccb27e40d774d5a07b4ebed713e59a0d71b3ee3f02374e7582b59ec4a5ce22cc69c55e89742ba036dd9b4edd8f34 -a10b897a946882b7c9e28abbb512a603ffa18f9274369843eb3491524a321df1f572eea349099ac6e749ea253c901ea0 -b782a672cd344da368732ecd7e0a1476c2af04613d3eb6da0e322f80438af932bd6d49be7a6f69f7c877512731723d89 -aeccee8dfd764e1adcfc4bf669e0fa87a94e7c79324333e958df47888bff5cec358b8b5bbb48db54822b54d11bbb4bc6 -ad4953913662a9ee8753a354864339f43916f2c2390d0a3f847c712b42718ee00ee14158d730709971941e8680d54560 -92ccb31d6c9e8940c7e8a4873e7eb9de9fb2fa2bac344fa367062ea451fd49a6920a45218dca3ee968711397d2a01536 -9448d9b2b3d12dde9b702f53373db8b8595f9d1f9de2ebee76de292f966f375316953aadf6bfc0e4e853e1fa12d8f02c -8919230878a7219da8c80a4b7d00b9169fb503e72d79789dd53863c243b8d0fb0a819d46fa636d805d0b9b1d15d1f2d9 -b6581ab01215aac023f5e6f57419b6aa63c0743c07caf57d4e146b56b02d90ce1423f70489ac3a11e5c968cb924f937c -a793ec1b1fe56a76920296af06073caadfd6f1d7e30950f8ca13de3de45fe275ca4b361f5249d9405264c3a06ebb5502 -86385b4a4e1bfb5efe7bfef8fd0dfeba7f4400852237cab60febb1dfa409e497a649e81284b5a15fe680b78927256756 -85d10600de96103daa7c90657174b6cb4a1286df5379f1eda9f11c97f9df57043c290eb1ae83658530fe0fd264867b86 -ae01b2396d0f598c21659cd854c15edd4904a34d22278aef97c9260a14a8b250b52d972d304ac4b187c24d08795d5355 -b91b3e4b6fc06e88081fe023ef1b773d82c628eb0f73a2731a9aa05b0dc89b7aeef2eea60125d302e696f45c407aeac2 -986d0f478e33af7568eab6bb26a55c13ffd7cae27525b4abe2f3a994bdb11bbc73d59bdb9a2f6b6ba420a26f8f620ba6 -9746f4fdeef35feaff1def0ea5366b64f21ed29749ae6349f9cb75987e7f931952f913f446100f2a6b182561f382e8eb -a34a116cfde1acbce0d7de037f72a7ca30ab126d8f4815b2b8bcb88e0e6c89015a4daaf4d4ce8eae23eb5d059cf9a5cf -80c3ea37f6a44f07cc9c9c881990f2a5deb9f9489a382718b18a287aa3c50ee6ebe8fd1b3afb84a3cf87f06556f4ca15 -97cff3bc88cfc72ce5e561f7eeb95d4ffb32697e290190c7902e9570c56b3854753777fc417fd27536fc398c8fefb63b -b8807232455833e4072df9bffa388ae6e8099758c2a739194719af7d9ed4041974a6cd9605f089de8b43f0e12f181358 -96f79fca72f75dc182c71f2343f0c43b06d98563fd02d2e1fbc031b96601608d8a726c811a74bb51ab8b0a3ce3632dc4 -b5262761680a4235a8c1257de4735cdcadf08d5d12c6e9d4f628464d5c05dfff3884a9ef2af3b7724b5a8c97e6be74eb -b6ce0eada73433d98f8fae7d55e4ea2b9d9d7a0ae850d328dd06991f27b1f03e470868fb102800ff3efe4ee1698531b9 -a37b7d9fe9d3fdfbc72c59cf6cacc7e7a89d534dea3d73121f7483331aec8ab3fbff58ffabb943b75d6f86df0ba43262 -93fce9be8a27fcaa1283d90d3e87265a6221ee302ec708161a42bd00ffe8e726743d9e187e1bf4307c0e3f25afbb1d44 -a4ea919021346ae7ea69d5e8f46d860b24c35c676b62f4e577c90e0c05c5646fe73721b143b7c38835dd4b443e6c3676 -b79983a5948453f70dfa4c396ce1945204498fe79f40c0667291bd0fdd96ed0b9ea424571f7ade342275c854c9f03d9e -866f8e395ed730b614b70bf999cad6e87e9086c1f5aea8d69020b562ee285dd0fb93afaca0dd13a0713f74a3f9340f01 -a3fef158782292c6139f9a0d01711aa4ed6f5cac11d4c499e9e65c60469ae3afbde44fb059845973a4b3bbca627b7eb7 -b4a2c0321b68f056e7d8051beede396fa2f0704d8aa34224f79f7b7a62eb485fc81889cb617019622fd5b5fa604516f5 -8f0e3edddbaead9059df94de4139e3a70693c9ea9bc6baaa5695dddfd67263b33926670159846292801941b9a0c6545b -9804e850f961e091dadd985d43d526ba8054d1bf9c573ed38f24bbd87aeaad4dcba4c321480abc515a16b3b28f27bb2a -95f330da28af29e362da3776f153f391703a0595323585220712dae2b54362cc6222070edd2f0dd970acfbe2e3147d5c -82d03b771231179cc31b29fe1e53379d77b5273b5c0a68d973accd7a757c7584dbb37f0507cdfde8807313ec733a6393 -81b3c39a9f632086e97b7c1f0ec7e2eaf9dc3cb0d84dec18a4441dbdc9fe9878fde4bcfa686bca1a9522632a353a5566 -a2db124ab2b493d5f9a1e4ca6b3144593c2fc8bfac129fd79da11dfbb7ef410a234fda9273a50a5ca05d7b37cc2088a2 -aa8550633c9449228702690cc505c0fc4837ea40862058e8f9713622b34d49fdc3a979b9317993c5da53b5bb5b7f4974 -ae783bcf7a736fdc815d0205b4c2c2b2fee0a854765228f76c39638ba503e2d37f1e28f6bdf263923f96fead76b4187b -b5ec86092c1d250251e93bab2f24e321afd2cd24cf49adfcbed9e8bc5142343ae750206c556320551e50fc972142f0da -b3b5791b590a6e9b3f473d5148624014aa244495249322a5d75cde2c64117ff9d32f4b0698b0e4382e5e7f72933061f8 -876c6a9162c17b16d6b35e6ce1ba32e26aec7dd1368bceab261ab880ad845c91e54b96a52c7d3aafbfbafc0e37139dca -902ddb5774d20b0707a704486457c29048776a5b88c377b14af6616c8ddf6cd34f49807df9c9d8866d6b39685cfb0f19 -8b87f71f94bc96de927d77a5d7123fa9cdda8c76aff64a5e6112cbc2eca43b07f8376db3e330f8af6a1db9b948908a6a -a69a5922e572b13d6778218e3657f1e1eea9a9682f6eb1b731d676d03563e14a37ff69bc5e673c74090ecb0969a593f7 -aff3510d78ba72f3cf5e3101847b7c4a956815aa77148689c07864e8a12dd0ef33d5f6c8cb486e0ea55850161f6afed0 -aa9c459cb2a008d94cbee2c6b561d18b0d7c6ffa8a65cbf86ae2c14eec070ee9d5324f5d38f25a945ddcd70307e964c4 -8310e15b050b1e40ece7530b22964bde0fd04f48dfffdec5a0d1fb8af0799a7fdc1d878139fb7cb8d043d3a52c2d1605 -b8f0856ce2c4034ee4041d0383f25fb0eeefc00b82443311a466fc18608313683af2e70e333eb87e7c687e8498e8a1ce -a8200a75c158fbb78474cab8a543caecd430b5d8b9964fc45d2d494dd938021cd00c7c33413ad53aa437d508f460a42a -a310091472b5b42b02176b72d5f8120bdb173025de24b420e3ca3fb9a386c39092a1d1bb591c6f68ee97a268a7ff9e95 -b23f1bf8bcec9cb5232b407115eead855fd06f5bf86ba322ad61d45460c84f0f36911aba303de788c9a0878207eac288 -ae4c129ad6d08be44690bb84370e48bfd92c5d87940750ee2c98c9a2604456f7f42727ab211989657bb202f6d907df04 -95992057d654f3e189a859346aa9aa009f074cb193b7f5720fa70c2b7c9ce887d886f6cff93fa57c1f7c8eaa187603f6 -ad12d560273963da94151dd6be49c665d7624011c67d54ab41447452a866bc997e92a80bdd9ca56a03528e72c456dc76 -8e4eda72e9cfcaa07265bb6a66d88e9ce3390ae1a6b8831045b36ea4156b53d23724824d0f0bca250ce850c5926fa38f -980fe29c1a267c556532c46130fb54a811944bdfea263f1afcdab248fa85591c22ac26167f4133372b18d9f5cce83707 -a7da9f99ddde16c0eac63d534a6b6776ad89b48a5b9718a2f2331dce903a100a2b7855cf7b257565a326ddc76adc71a5 -8ca854c55e256efd790940cb01125f293e60a390b5bd3e7a60e13ac11a24f350a7eb5ebddfa0a2890905ca0f1980b315 -9440335818859b5e8f180893a8acedceabaaa44e320286506721c639a489b5bfb80b42b28902ee87237b0bd3dd49552a -b9da545a20a5e7d60fd0c376dcaf4b144f5c5a62c8ffa7b250c53ce44be69c4e0d5e4e11422ef90593ae58ae1df0e5d3 -b75852a850687f477849fc51e0479703cd44428671c71bfdd27fe3e7930b97d2fc55f20348ca4e5bc08db2fc16a4f23c -b515081d8d099e4b6253c991ca2d3e42633f5832c64aa8f9cde23cb42c097c2c3717c46c5f178f16c58295f97b2b3fe7 -9506c9902419243e73d3197e407985dd5113f16c6be492651bbbf9576621942710aea74522d6fb56d5b52c6ccdaa4307 -952673ae27462a0f6c9545eede245c2f8e2fd6077b72a71f5672f1a5a02c263bc2a66f24f0e30376feb7a8187b715f08 -a8f1e2085ed666a8f86b474d9589dc309d5c83bd53e745f8e09abe0dfbaf53e5384c68580672990344d4aa739438b4d8 -ad6e04d4a67a5a5529ceaf7de6e19416be5b4c436610aa576ac04aee3b73317da88f891121f966393a37f52b775a2dd8 -a35a884736f08c7f76923ae7adb17fdac04e6c505178bca9502eaa2ed16d4d93fa953fb6dcf99e9e9962a6eb3eeead00 -b8af72273360bab4b3ca302cf0659717cbfb335fbc9ad4ffdd3340113ece9e63b2bdbd611e5f6b740a4689286f9a452d -b1a1f4ba2640800c3ed3892e049f6e10f8a571efa3bbe21fe2d6cee8fded171c675a3bb8aa121e2d1d715de84bad2e2b -8102a6c3598b40da4d6e8eccfdd5dadc8d6262e38b69c5b211b0732f4c6e3045d79fba12770a0b2b66f1e9f4664b1510 -90979587d75bf12819f63832beea7dcbef101f6814bf88db4575bfcd9cf0ea8eceba76d4d6db17630b73b46c1acfe011 -8dd98f14d2beb5b5b79cc30f6825ec11ed76bd5a8864593ffc0c2baffab6872bad182e1c64b93aab8dd5adb465fa5cec -8083334dadc49c84f936c603a2857f174eda5659ab2b7214572f318aba3ebd7b1c50e7cbea57272b9edf106bd016df3b -a634d08d2e8641b852e89d7ccab1bab700c32fb143bcbea132f2a5fb2968d74ded2af4107f69818798f0128cc245a8cb -94fc2dccf746d5b3027f7cf4547edf97097cd11db8d6a304c1c2ca6b3aba28c1af17c08d2bbb66f88c14472e0196a45e -b257a6fb01424b35e414c1c002e60487abb3b889d74c60cbdbf591e222739c6f97b95f6962842401f5e2009e91b28c55 -81955bdbf25741f3b85d5044898dc76ae51b1b805a51f7c72a389d3b4d94b2e3e0aa1ec271685bbcf192ed80db7367ab -86eb229b66c542514e42b113b9de7d4f146861a60f2a253264873e7de7da2ac206e156ff11f2de88491b9897174fe2f4 -8b8db00533afbb56b3d7d7a9a4a6af3cebb523699ffcb974603e54f268b3ef739c41cd11850b9651d9640d72217c3402 -8b7cbb72a6c4408d5f1b61001e65de459790444530245d47d4ee8e2d17716695283f21540bd7ac4f5a793a0d00bdf1d4 -875920b9bab4bc1712e6af89ae2e58e9928c22095026070b07e338421b554d9f96e549ac3706c6c8d73f502913a27553 -9455d192db7b039b3e8f0bc186c25ff07dfbe90dab911e3c62e3bd636db8019ed712cbb0ecd5cbb9a36c11034e102aba -8cb0b28e5d3838d69f6c12274d6b1250f8843938065d0665b347977fa3c1c685caef6930bae9483ed0d0a67005baad76 -94df2e14aae1ae2882ab22a7baf3dc768c4a72b346c2d46bfd93d394458398f91315e85dc68be371f35d5720d6ca8e11 -aacd94b416bfbeb5334032701214dd453ad6be312f303b7bec16a9b7d46ab95432a14c0fbf21a90f26aafb50ec7bb887 -b43d26963665244633cbb9b3c000cacce068c688119e94cc0dac7df0e6ee30188e53befff255977788be888a74c60fc2 -b40d67c9ad0078f61e8744be175e19c659a12065fe4363b0e88482b098b2431612e7c2fa7e519a092965de09ceafe25c -82cd4a4e547c798f89ce8b59687614aa128877e6d38b761646d03dc78f6cdd28054649fb3441bcd95c59b65a6d0dd158 -a058e9700f05cef6e40c88b154d66a818298e71ae9c2cf23e2af99a0a7dc8f57fbe529d566cb4247432e3c1dee839b08 -95c6f84406466346c0b4a2a7331ac266177fb08c493d9febb284c5ca0b141ccc17aa32407f579666b208fb187c0227dd -905d1d47a26b154f44d7531c53efbc3743ff70bd7dba50c9b9d26636767b0ae80de3963c56d4604399126f4ad41a0574 -83dfa11c520b4abaefe1b2bc1ce117806e222f373cd4fb724f3c037c228e3379d27a364e68faa73984ba73a0845f1b9a -a16e54786ba308a9c0241aff8f1bf785dece387d93bd74aa31de0969e3431479e2c0abebff9939a6644d2b0af44f80bb -81ac565212365176f5be1c0217f4e7c9fdbc9fe90f16161367635d52edcf57af79290531d2e8b585e1223d33febd957d -a296f4b09915e5d80ff7274dc3ffc9b04f0427e049ea4ef83dca91095275e8a260ef0335c7b6585953b62682da8c8e99 -a9150626208168a21ae871192ca9f11c1f7f6e41e8e02de00732de2324d0d69fe52f8762155c9913ee408a034552e49a -a42a56008ca340c6e9ff5a68c8778bb899ba5de9e7508c0cac355c157979a7ff6a6bd64f98b182114d3831cfa97ee72b -a4f05adf22c051812279258eea9eb00956b04ef095f2ca175f775ff53c710fb0020266adabd1dacaee814c4f1d965299 -967492e78ac0bceb8ad726ea0d2292b760043d16d64a6b1bb896e32630a7bf405c2b20e4e00842ae519a21697ff8db2d -adbf05e9b5931ae3dd24d105b5c523c221a486a4123c727069b9e295a5bc94f3e647a3c2cde1f9f45dbd89df411453c9 -a1759c0ebebd146ee3be0e5461a642938a8e6d0cdd2253ebd61645b227624c10c711e12615cd1e7ea9de9b83d63d1a25 -a4c5945d635b9efc89ad51f5428862aefe3d868d8fb8661911338a6d9e12b6c4e5c15a25e8cb4a7edc889b9fa2b57592 -aff127675ea6ad99cb51c6e17c055c9f8fd6c40130c195a78afdf4f9f7bc9c21eed56230adb316d681fc5cacc97187da -9071294e8ff05b246ff4526105742c8bf2d97a7e7913f4541080838ecfd2dbc67c7be664a8521af48dbc417c1b466a85 -990880b0dd576b04f4b4ce6f0c5d9ff4606ec9d3f56743ac2f469ac6a78c33d25c3105cf54f675e300ac68073b61b97a -a8d1a62ce47a4648988633ed1f22b6dea50a31d11fdddf490c81de08599f6b665e785d9d2a56be05844bd27e6d2e0933 -8ea5a6c06f2096ded450c9538da7d9e402a27d070f43646533c69de8ea7993545673a469c0e59c31520e973de71db1b4 -99d3a098782520612b98a5b1862ae91bcb338ab97d1a75536e44b36a22885f1450a50af05c76da3dd5ca3c718e69fdd4 -b987451526e0389b5fe94c8be92f4e792405745b0a76acd6f777053d0809868657ba630aa5945f4bd7ce51319f8996f7 -afffccc5ddd41313888a4f9fee189f3d20d8b2918aa5ad0617009ea6d608e7968063c71bd5e6a1d7557880d9a639328d -8ac51a02505d5cadfd158dde44932ab33984c420aeceb032ed1ee3a72770d268f9e60ccf80ce8494dfc7434b440daafd -b6543e50bd9c6f8e0862850c3d89835ddd96231527681d4ab7ae039c4a3a5a0b133a6d40cdb35c8a6c8dbb8d421d3e2b -a2ba901f4fde2b62274d0c5b4dbbea8f89518571d8f95ec0705b303b91832f7027704790a30f7d9d2cdafde92f241b3e -a6974b09280591c86998a6854a7d790f2a6fbe544770e062845cfc8f25eb48c58f5dfb1b325b21f049d81998029ad221 -890baeb336bbf6c16a65c839ffaab7b13dd3e55a3e7189f7732dbcb281b2901b6d8ba896650a55caa71f0c2219d9b70e -b694211e0556aebbe4baf9940326e648c34fda17a34e16aa4cefd0133558c8513ffb3b35e4ee436d9d879e11a44ec193 -97cf9eb2611d467421a3e0bfe5c75382696b15346f781311e4c9192b7bca5eb8eaf24fa16156f91248053d44de8c7c6f -8247f88605bd576e97128d4115a53ab1f33a730dc646c40d76c172ca2aa8641c511dddad60ee3a6fbe1bb15cac94a36c -ae7ecd1c4a5e9e6b46b67366bc85b540915623a63ab67e401d42ca1d34ae210a0d5487f2eef96d0021ebecfd8d4cd9a8 -aec5123fff0e5d395babe3cb7c3813e2888eb8d9056ad4777097e4309fb9d0928f5c224c00260a006f0e881be6a3bf8f -8101724fa0ce7c40ea165e81f3c8d52aa55951cc49b4da0696d98c9fafd933e7b6c28119aa33f12928d9f2339a1075d1 -a8360843bab19590e6f20694cdd8c15717a8539616f2c41a3e1690f904b5575adb0849226502a305baefb2ead2024974 -ade5cad933e6ed26bba796c9997b057c68821e87645c4079e38e3048ea75d8372758f8819cde85a3ab3ab8e44a7d9742 -ab1fe373fb2454174bd2bd1fe15251c6140b4ac07bda1a15e5eabf74b6f9a5b47581ef5f0dbd99fdf4d1c8c56a072af7 -b425e1af8651e2be3891213ff47a4d92df7432b8d8ea045bb6670caf37800a4cd563931a4eb13bff77575cbcae8bc14f -b274799fe9dd410e7aed7436f0c562010b3da9106dc867405822b1e593f56478645492dbc101a871f1d20acf554c3be6 -b01a62a9d529cc3156bc3e07f70e7a5614b8d005646c0d193c4feb68be0b449d02b8f0000da3404e75dbdfa9ca655186 -878b95e692d938573cdb8c3a5841de0b05e5484a61e36ea14042f4eadb8b54a24038d2f09745455715d7562b38a8e0df -a89e998e979dba65c5b1a9000ad0fd9bb1b2e1c168970f2744982781306bbe338857e2fac49c8cafda23f7cc7c22f945 -85880fdf30faed6acce9973225e8fe160e680a55fc77a31daacf9df185453ad0c0552eb3fd874698ad8e33c224f7f615 -ac28d20d4bbb35ba77366272474f90f0ed1519a0e4d5de737adee2de774ccd5f115949e309e85c5883dbc63daaa6e27b -a1758ac86db859e323f5231ad82d78acbe11d53d3ebf7e644e581b646eede079d86f90dc23b54e5de55f5b75f7ea7758 -ae4c0b84903f89353bf9a462370f0bf22c04628c38bb0caae23d6e2d91699a58bd064e3c2b1cbda7f0a675d129f67930 -95f21a099ffc21a0f9064d9b94ce227b3ff0a8c5a2af06ff5ee6b7f3248a17a8ca2f78cd7929ef1d0784f81eddefcd48 -8d06fbc1b468f12b381fd1e6108c63c0d898ddf123ea4e2e1247af115043c4f90b52796076277b722dd2b92708f80c21 -a300f39039d8b2452e63b272c6d1f6d14a808b2cd646e04476545da65b71a6e29060f879409f6941c84bde9abe3c7d01 -adecce1ccc5373072ba73930e47b17298e16d19dbb512eed88ad58d3046bb7eec9d90b3e6c9ba6b51e9119cf27ce53f2 -941a7e03a64a2885d9e7bee604ddc186f93ff792877a04209bbee2361ab4cb2aed3291f51a39be10900a1a11479282ca -acbcb1ab19f3add61d4544c5e3c1f6022e5cc20672b5dc28586e0e653819bdae18cda221bb9017dfaa89c217f9394f63 -b8d92cea7766d3562772b0f287df4d2e486657b7ab743ed31ec48fdc15b271c2b41d6264697282b359f5cb4d91200195 -957360ecb5d242f06d13c1b6d4fcd19897fb50a9a27eb1bd4882b400dc3851d0871c0c52716c05c6c6cf3dee3d389002 -abd2a23abbc903fbb00454c44b9fb4a03554a5ef04101b2f66b259101125058346d44d315b903c6d8d678132f30b1393 -ae9572beff080dd51d3c132006107a99c4271210af8fbe78beb98d24a40b782537c89308c5a2bddfdfe770f01f482550 -82c7e5a5e723938eb698602dc84d629042c1999938ebd0a55411be894bccfb2c0206ac1644e11fddd7f7ab5ee3de9fdc -aba22f23c458757dc71adb1ce7ef158f50fdd1917b24d09cfc2fbbcbe430b2d60785ab141cf35ad9f3d0a2b3e2c7f058 -8eff41278e6c512c7552469b74abedf29efa4632f800f1a1058a0b7a9d23da55d21d07fdbb954acb99de3a3e56f12df6 -8abd591e99b7e0169459861a3c2429d1087b4f5c7b3814e8cee12ecc527a14a3bdda3472409f62f49a1eb4b473f92dbf -82dcbff4c49a9970893afc965f1264fcab9bae65e8fb057f883d4417b09e547924123493501c3d6c23a5160277d22a8e -b5a919fcb448a8203ad3a271c618e7824a33fd523ed638c9af7cfe2c23e3290e904d2cd217a7f1f7170a5545f7e49264 -96d6834b592ddb9cf999ad314c89c09bedc34545eeda4698507676674b62c06cc9b5256483f4f114cd1ed9aaec2fba5e -a4e878cf4976eb5ff3b0c8f19b87de0ef10cd8ec06fe3cd0677bd6be80ba052ff721a4b836841bdffb1df79639d0446c -8e15787a8075fd45ab92503120de67beb6d37c1cc0843c4d3774e1f939ac5ed0a85dad7090d92fa217bd9d831319021b -8506c7fea5a90cd12b68fdbbae4486a630372e6fd97a96eea83a31863905def661c5cdead3cf8819515afe258dbcd4d9 -952ef3bc16a93714d611072a6d54008b5e1bf138fd92e57f40a6efb1290d6a1ffcc0e55ff7e1a6f5d106702bd06807cd -a5f7761fa0be1e160470e3e9e6ab4715992587c0a81b028c9e2cf89d6f9531c2f83c31d42b71fca4cc873d85eba74f33 -b4811f0df11ff05bf4c2c108a48eece601109304f48cde358400d4d2fa5c1fdaaf3627f31cb3a1bdd3c98862b221720d -9207ad280b0832f8687def16ad8686f6ce19beb1ca20c01b40dd49b1313f486f2cb837cfbbf243be64d1c2ab9d497c3f -b18a8c1e6363fadd881efb638013e980e4edb68c1313f3744e781ce38730e7777f0cba70ea97440318d93a77059d4a2b -901faf777867995aac092f23c99c61f97eeadf4ac6bcb7791c67fa3c495947baef494b2aace77077c966c5d427abbf92 -a123281aca1c4f98f56cff7ff2ae36862449f234d1723b2f54ebfccd2740d83bd768f9f4008b4771e56c302d7bfc764f -8cffe1266468cad1075652d0765ff9b89f19b3d385e29b40f5395b5a3ad4b157eed62e94279ac3ec5090a6bad089d8b3 -8d39870719bc4ebbcecba2c54322111b949a6ed22bda28a6cea4b150272e98c9ded48cc58fc5c6e3a6002327856726ec -b3d482c00301f6e7667aaeaf261150b322164a5a19a2fa3d7e7c7bf77dc12fa74f5b5685228ab8bf0daf4b87d9092447 -801acb8e2204afb513187936d30eb7cab61f3fbb87bfd4cd69d7f3b3ddba8e232b93050616c5a2e6daa0e64cef6d106f -ac11e18adda82d2a65e1363eb21bda612414b20202ecc0e2e80cc95679a9efa73029034b38fd8745ce7f85172a9ab639 -b631d6990d0f975a3394f800f3df1174a850b60111567784f1c4d5bba709739d8af934acfa4efc784b8fc151e3e4e423 -aeda6279b136b043415479a18b3bbff83f50e4207b113e30a9ccfd16bd1756065fc3b97553a97998a66013c6ac28f3d8 -8840b305dc893f1cb7ad9dd288f40774ec29ea7545477573a6f1b23eaee11b20304939797fd4bcab8703567929ce93ad -963cc84505a28571b705166592bffa4ea5c4eeafe86be90b3e4ae7b699aaaca968a151fe3d1e89709fe0a3f0edf5d61a -8e1ec0d0e51f89afea325051fc2fa69ab77d6c7363cc762e470a9dfa28d4827de5e50f0b474c407b8c8713bad85c4acd -909f313420403cb36c11d392cf929a4c20514aa2cb2d9c80565f79029121efd5410ef74e51faba4e9ba6d06fcf9f1bd1 -b2992b45da467e9c327ac4d8815467cf4d47518fc2094870d4355eb941534d102354fbda5ab7f53fbf9defa7e767ca13 -9563b50feb99df160946da0b435ac26f9c8b26f4470c88a62755cdf57faebeefffff41c7bdc6711511b1f33e025f6870 -a2a364d9536cd5537a4add24867deec61e38d3f5eb3490b649f61c72b20205a17545e61403d1fb0d3a6f382c75da1eb3 -89b6d7c56251304b57b1d1a4255cb588bd7a851e33bf9070ee0b1d841d5c35870f359bc0fdc0c69afe4e0a99f3b16ec2 -a8ae1ee0484fe46b13a627741ddcdae6a71c863b78aafe3852b49775a0e44732eaf54d81715b1dca06bb0f51a604b7e2 -b814ecbfbc9645c46fc3d81c7917268e86314162d270aed649171db8c8603f2bd01370f181f77dbcbcc5caf263bedc6c -8e5d7cc8aad908f3b4e96af00e108754915fecebdb54f0d78d03153d63267b67682e72cd9b427839dca94902d2f3cda7 -8fc5ff6d61dd5b1de8c94053aef5861009cb6781efcca5050172ef9502e727d648838f43df567f2e777b7d3a47c235dd -8788eea19d09e42b0e3e35eb9bcd14f643751c80c6e69a6ff3a9f1711e8031bbe82ccd854a74a5cfcf25dda663a49a62 -95d441d8cd715596343182ddcecb8566d47eaa2d957d8aea1313bbed9d643a52b954443deb90a8037a7fa51c88eec942 -a15efd36ef72783ccdc6336ef22a68cc46b1ecec0f660cfe8a055952a974342bf30f08cb808214bce69e516ff94c14c5 -acc084d36907a16de09a5299f183391e597beaf9fa27d905f74dc227701a7678a0f5a5d1be83657de45c9270a287ec69 -b3fd385764356346061570beb760ccf3808619618fd7521eb0feadc55b8153ef4986ff0cbfcbd4153ad4ea566989d72a -91ec6b26725532e8edfda109daa7ce578235f33bd858238dfa2eb6f3cd214115b44cce262a0f2f46727a96b7311d32e1 -96b867ccddb73afe1049bda018c96cfe4083fff5bb499e6a4d9fd1a88a325144f9a08cb0aee310e1bb4f6a5793777e80 -ad10c18465910152676f1bc6a40986119607b5c272488e6422cfda2eb31da741af13a50f5de84037348014a869c8e686 -86ade2dbc4cceb52b84afe1c874d1e3644691284c189761febc4804b520adf60b25817e46f3f3c08d2ab227d00b93076 -998b949af82065c709fc8f63113a9fecdd1367fc84fc3b88857d92321ba795e630ce1396a39c2e056b5acd206ee011d8 -8dec440bbd17b47dfd04e566c2d1b46f9133023b982fdc5eaeae51404bc83a593f8d10c30b24e13aec709549137cae47 -89436ff47431b99f037cddaee08bb199be836587a7db6ed740317888638e5f4bebbb86b80549edff89678fc137dfb40a -a8e9960746769b3f76246c82cd722d46d66625e124d99a1f71a790c01cec842bcf6c23c19cc7011ec972cedf54dc8a4c -980979dafedfd75ff235b37e09e17361cfdda14a5ac3db0b90ed491abfd551916016b2254538da7f4b86ece3038b1b1c -8ec340ca7654720bb9d2f209985439ebbc3f9990ef27e7d7ae366e0c45b4ed973316943122119604ea9a87fc41ebd29f -ab24440a40ab238d8cd811edb3ef99948ae0f33bf3d257b22c445204016cce22b6f06a1ca979fa72a36c4ddedc2b3195 -a1bcd2473ac7cfebfa61c10e56cae5422c6b261a4a1be60b763fcbcdf2eae4ccf80695f09b062b6cf5654dfab0ee62a5 -9027a613ce7bd827110a3a0e63e83f652e9bc7f4ce8da26c38b28ee893fd0c38bdb20f63a33470a73cb77f776244ab4a -86911cc8aeb628197a22bf44d95a0b49afb8332c38857fba8e390c27c527b8b45335e22b0f2e0a3395c16ced3c1ed2e8 -8f0529a330a3e9967dce09357d774715fd305bd9e47b53b8b71a2a1303d390942a835aa02fb865a14cfed4f6f2f33fe6 -b71ec81a64c834e7e6ef75b7f321a308943b4bad55b92f4dbaf46658613cebf7e4b5b1bc7f1cdc5d50d1a2a0690e2766 -98d66aaed9fb92f4c7bb1b488ccbca5e570aa14433028867562a561d84f673ac72e971cbe2cb3cbbb0a702797dc45a7e -8380aa94d96c6b3efd178de39f92f12ca4edd49fe3fe098b2b7781e7f3e5f81ee71d196fb8e260d1d52f2e300e72e7bc -8c36296ff907893ac58cecadd957b29f5508ae75c6cc61b15ae147b789e38c0eace67963ae62eff556221b3d64a257a2 -97e17676cbc0f62a93555375e82422ee49bc7cf56ad6c3d69bb1989d1dc043f9f7113d0ed84616dde310441b795db843 -a952229615534c7e9a715409d68e33086cdaddf0aec51f4369c4017a94ec3d7113a045054d695fb9d7fd335527259012 -817b90958246f15cbd73a9679e10192ca7f5325b41af6388b666d8436706dea94eafffbc3b8d53057f67ad726dbcd528 -95776e378c8abd9223c55cd6a2608e42e851c827b6f71ad3d4dc255c400f9eccf4847c43155f2d56af0c881abef4acfa -8476c254f4b82858ecbe128ed7d4d69a6563fd9c5f7d4defc3c67e0bfa44e41cfd78b8e2a63b0773ce3076e01d3f6a7d -a64b0b189063d31bcae1d13931e92d5ab0cfc23bf40566ac34b5b8b711d0e7d941102e6beb140547512e1fe2d9342e6c -9678460acff1f6eae81a14d5c8049cdcd50779a8719b5c5861762a035b07f7fa1b1ada8b6173f9decf051fd5a55bebd8 -88398758ce86ed0388b13413a73062adb8a026d6b044cd1e7f52142758bed397befee46f161f8a99900ae6a2b8f6b89f -a7dfaf40637c81d8b28358b6135bd7ad9cc59177bd9bc8e42ba54d687d974cdf56be0457638c46b6a18ceaa02d3c53f3 -b0e885e5d48aa8d7af498c5e00b7862ed4be1dad52002f2135d98e8f2e89ca0b36cf95b3218aad71d5b4ada403b7045b -803b0e69a89e8de138123f8da76f6c3e433402d80d2baba98cde3b775a8eda4168530a49345962c4b25a57257ba9f0a7 -8ce6ef80dadb4b1790167fbc48be10ef24248536834ff2b74887b1716c75cb5480c30aa8439c20474477f1ac69734e61 -824764396e2b1e8dcc9f83827a665ef493faec007276f118b5a1f32526340b117c0df12bea630030a131bf389ec78fc3 -874edb379ce4cc8247d071ef86e6efbd8890ba6fcb41ea7427942c140347ebf93e8cf369d1c91bd5f486eb69b45bce70 -adadcb6eb4cafa1e2a9aef3efb5b09ffa2a5cf3ce21f886d96a136336be680dabc0a7c96ec327d172072f66d6dcdbb39 -b993591b280e1f3527f083d238a8f7cf516d3cf00c3690d384881911c1495192a419b8e37872a565ce8007eb04ebe1b6 -b125faaeca3f0b9af7cb51bb30a7c446adbb9a993b11600c8b533bff43c1278de5cdda8cb46a4df46f2e42adb995bce8 -a7efe1b57326b57c2c01720d4fdf348d6a84d35f229d32a8f2eb5d2be4e561ef8aea4d4d0bcfcbf17da10a8e49835031 -a6bd4f5a87574b90a37b44f778d5c7117d78eb38f3d7874bad15ae141b60eed4ab0a7281ed747297f92e0b3fe5f9cafa -94b5e3067ca1db3c4e82daf6189d7d00246b0360cb863940840358daa36cb33857fde4c01acd0457a90e15accee7d764 -a5ff3ab12197b8a07dd80222a709271ab3b07beba453aacbaf225cfb055d729e5a17a20f0ff9e08febf307823cba4383 -a76dd8aa2b6a957ed82ecec49b72085394af22843272f19360a5b5f700910c6ec65bf2a832e1d70aa53fd6baa43c24f6 -8dfcbe4143ae63c6515f151e78e6690078a349a69bb1602b79f59dc51dea7d00d808cf3e9a88b3f390f29aaae6e69834 -8c6134b95946a1dd54126952e805aeb682bc634c17fe642d5d3d8deffffd7693c90c4cd7d112890abfd874aa26736a93 -933531875561d327c181a2e89aaaac0b53e7f506d59ef2dfc930c166446565bd3df03bab8f7d0da7c65624949cfbae2f -ac6937c5e2193395e5bb69fd45aa6a9ae76b336ea7b6fd3e6aeac124365edcba7e918ec2c663fb5142df2f3ad03411a6 -a8f0f968f2a61d61d2cf01625e6ac423b447d3e48378ea70d6ff38bc98c42e222fe3cbcb04662b19973a160dc9f868a2 -94100a36f63d5c3a6cfb903c25a228389921684cc84f123390f38f90859f37ec9714942ffe6766f9b615101a3c009e43 -b5321b07f5b1eb2c1c20b0c8ab407f72f9705b55a761ec5176c5bcc6e585a01cae78546c54117ca3428b2b63793f2e65 -9922f61ed6763d1c4d12485c142b8ff02119066b5011c43e78da1ee51f10a1cf514329874061e67b55597ca01a7b92ab -a212eb2d72af0c45c9ef547d7c34ac5c4f81a4f5ec41459c4abd83d06ec6b09fdab52f801a2209b79612ae797fa4507b -8577d2d8f17c7d90a90bab477a432602d6918ca3d2af082fbb9e83644b93e21ca0bced7f90f6e9279eaa590f4e41dc4d -9002d424e3bebd908b95c5e6a47180b7e1d83e507bfb81d6ad7903aa106df4808c55f10aa34d1dccad3fab4d3f7a453e -b9050299bf9163f6ebeff57c748cb86f587aea153c2e06e334b709a7c48c4cbfba427babf6188786a0387b0c4f50b5ce -852ae1195cc657c4d4690d4b9a5dea8e0baaa59c8de363ba5fccd9e39ec50c6aa8d2087c8b7589b19248c84608f5d0a8 -a02ff5781417ca0c476d82cf55b35615f9995dc7a482124bc486e29b0b06a215fbe3e79228c04547c143d32cd3bac645 -8d7bc95e34bc914642e514a401448b23cf58bce767bab1277697327eb47c4a99214a78b04c92d2e3f99a654308b96e34 -adb28445d3b1cc7d4e4dd1f8b992a668f6b6f777810465fdab231fd42f06b5bada290ba9ae0472110366fad033da514e -a0c72b15a609f56ff71da17b5b744d8701af24b99fbc24a88588213864f511bfa592775e9ab4d11959f4c8538dc015b8 -933205a40379d5f5a7fb62cda17873fbbd99a0aaa8773ddf4cd2707966d8f3b93a107ebfe98b2bb222fe0de33ef68d03 -90690c1a4635e2e165773249477fc07bf48b1fd4d27c1b41a8f83a898c8d3763efb289867f8d6b0d354d7f4c3f5c7320 -99858d8c4f1be5a462e17a349b60991cb8ce9990895d6e42ae762ce144abc65b5a6f6e14df6592a4a07a680e0f103b2a -b354a7da06bd93fb5269e44925295b7c5049467b5cacce68cbb3cab60135b15e2010037a889cb927e6065053af9ccb77 -af01fc4ac396d9b15a4bbd8cc4fe7b30c32a9f544d39e88cdcb9b20c1c3056f56d92583a9781ddb039ec2eeda31fb653 -a8d889fb7155f7900982cf2a65eb2121eb1cc8525bbee48fae70e5f6275c5b554e923d29ebbd9772b62109ff48fb7c99 -b80edae6e26364c28749fd17c7c10eb96787053c7744a5cc6c44082ae96c5d3a4008c899a284f2747d25b72ecb9cb3d0 -b495b37503d77e7aafc226fca575e974b7bb6af2b7488372b32055feecc465a9f2909729e6114b52a69d8726e08739cb -a877f18b1144ff22e10a4879539968a01321cecde898894cbe0c34348b5e6faa85e1597105c49653faed631b1e913ec7 -8c235c558a065f64e06b4bb4f876fe549aab73302a25d8c06a60df9fad05843915ac91b507febca6fe78c69b51b597de -b4c31398b854ccc3847065e79329a3fdae960f200c1cce020234778d9c519a244ff1988c1fbc12eb3da2540a5fa33327 -b7bd134b3460cb05abf5aed0bc3f9d0ccbfac4647324bedbdf5011da18d8b85dc4178dd128f6ddbe9d56ea58f59d0b5d -92594c786c810cf3b5d24c433c8a947f9277fe6c669e51ceb359f0ae8a2c4e513a6dad1ae71b7ded3cdca823a51e849b -b178535e043f1efcce10fbec720c05458e459fdda727753e0e412ef0114db957dc9793e58ec2c031008e8fb994145d59 -b31da7189abf3e66042053f0261c248d4da142861bfd76a9aced19559be5284523d3e309ef69843772b05e03741a13fe -b190a8c1a477e4187fecff2a93033e77e02de20aae93dda1e154598814b78fdf8b9ff574c5f63047d97e736e69621462 -98234bd1d079c52f404bf5e7f68b349a948ec1f770c999c3c98888a55d370982bfa976e7e32848a1ebb4c7694acc1740 -99b9eeb33a6fb104bba5571a3822ebe612bf4b07d720d46bde17f0db0b8e8b52165f9b569be9356a302614e43df3e087 -a1e3915b0dd90625b424303860d78e243dda73eecd01cba7c33100b30471d0a1ec378c29da0f5a297008b115be366160 -975118bf6ca718671335a427b6f2946ee7ece2d09ccfb1df08aa1e98ff8863b6c8b174c608b6b2f4b1176fb3cbc1e30d -903cb1e469694b99360a5850e2ca4201cad23cfccce15de9441e9065eb3e6e87f51cba774ab9015852abd51194c25e57 -821f7ff4d0b133e3be4e91d7ff241fa46c649ff61fc25a9fdcf23d685fe74cf6fade5729763f206876764a3d1a8e9b24 -a1ee8db859439c17e737b4b789023d8b3ce15f3294ec39684f019e1ea94b234ec8a5402bc6e910c2ed1cd22ff3add4de -af27383148757bdf6631c0ea8a5c382f65fc6ab09f3d342a808ca7e18401e437cd1df3b4383190fdf437a3b35cbcc069 -8310551d240750cef8232cd935869bad092b81add09e2e638e41aa8a50042ce25742120b25fb54ebece0b9f9bdb3f255 -8b1954e0761a6397e8da47dc07133434ebe2f32c1c80cd1f7f941f9965acdf3d0c0b1eb57f7ff45a55697d8b804e1d03 -8c11612381c6be93df17851d9f516395a14a13c7816c8556d9510472b858184bf3cc5b9d14ded8d72e8fb4729f0b23ba -b413ac49121c7e8731e536b59d5f40d73a200c4e8300f8b9f2b01df95a3dc5fe85404027fc79b0e52946e8679b3a8e43 -8451e5c1c83df9b590ec53d1f1717d44229ed0f0b6e7011d01ea355d8b351f572866b88032030af372bd9104124df55a -8d0a5c848ec43299bc3ea106847ed418876bc3cd09b2280c2a9b798c469661505ed147a8f4ffba33af0e1167fdb17508 -a6aa97a1f10709582471000b54ec046925a6ad72f2b37c4435621c9f48026d3e332b8e205b6518f11b90b476405960a9 -97696635b5a2a6c51de823eea97d529f6c94846abb0bd4c322b108825589eba9af97762484efaac04ee4847fb2fb7439 -92fd142181fe6ca8d648736866fed8bc3a158af2a305084442155ba8ce85fa1dfb31af7610c1c52a1d38686ac1306b70 -ae3da824ecc863b5229a1a683145be51dd5b81c042b3910a5409ca5009ba63330e4983020271aa4a1304b63b2a2df69e -aecc0fe31432c577c3592110c2f4058c7681c1d15cd8ed8ffb137da4de53188a5f34ca3593160936119bdcf3502bff7c -821eac5545e7f345a865a65e54807e66de3b114a31ddeb716f38fe76fdd9d117bee0d870dd37f34b91d4c070a60d81f4 -91a02abb7923f37d9d8aa9e22ded576c558188c5f6093c891c04d98ab9886893f82b25b962e9b87f3bf93d2c37a53cb9 -99a96f5d6c612ee68e840d5f052bf6a90fecfd61891d8a973e64be2e2bdd5de555b1d8bffbd2d3c66621f6e8a5072106 -b1d5ec8f833d8fbb0e320ff03141868d4a8fff09d6a401c22dbefadbb64323e6d65932879291090daf25658844c91f2e -a06afd66ebc68af507c7cf5ab514947ca7d6ccc89fb2e2e8cb6e5ae0f471473e5fba40bb84d05f2c0f97c87f9a50cb73 -83de3ca182bcf1eac0cc1db6ad9b1c2a1ecd5e394e78add7faa36e039a1b13cb0d1d2639892489df080fbf43e5cef8d5 -adf77fc7b342ff67a2eddaa4be2f04b4e6ceaca8ea89a9fc45cc892fcce8ac3cf8646cfa5aab10ac9d9706ce4c48a636 -8509a430ef8dc9a0abc30ef8f8ccdb349d66d40390fb39f0d3281f3f44acb034625361270162822ef0743d458a82b836 -8350fc09e8617826f708e8154a3280d8753e7dbbcf87e852f9b789fdbeb10bf3fed84fb76edd7b8239a920c449e2f4b7 -a2e7a29da8391a5b2d762bf86cb6ae855cdfad49821175f83f4713dd0c342a0784beba98d4948356985a44d9b8b9d0f7 -a99c50a1a88b8efe540e0f246439db73263648546d199ef0d5bc941524a07d7e02b3ef6e5b08dc9e316b0b4c6966823e -b34ba55136c341f4ca2927080a07476915b86aa820066230903f1f503afebd79f2acf52a0bc8589b148d3a9a4a99f536 -af637be5a3e71c172af1f2644d3674e022bc49c393df565ea5b05ce6401a27718c38a9232049dd18cbd5bf4f2ce65b32 -a2972ba7bfa7f40c2e175bb35048a8ef9bc296d5e5a6c4ca7ab3728f4264d64f2d81d29dce518dc86849485ff9703d7d -8c9db203e8726299adeb331d6f4c235dc3873a8022138d35796fb7098887e95e06dcfad5d766ceaa2c4fb0f8857f37fa -a82bfbaa9a6379442109e89aad0c0cfc6a27d4a5db5480741a509d549c229cb847b46a974dde9f1398c6b3010530f612 -b2d8ef6e091a76dfc04ab85a24dbe8b5a611c85f0ed529a752c2e4c04500de5b305c539d807184e05f120be2c4a05fc3 -8c6ffc66a87d38cea485d16ee6c63ce79c56b64ae413b7593f99cc9c6d3cd78ef3fa2ab8a7943d2f0e182176642adadb -acbc92de68b2b04e3dc128109511a1cbe07518042f365d5634e8b651cb1ac435ea48eeeb2b921876239183096ef6edee -979c4e1165e0ecfa17ed59fb33f70797e000ddbb64acf5fc478cccde940451df051e51b6449c5b11a36afa7868af82e3 -a5a017c5a94952aeae473976027124231abe50460cec4db3ebeb8b1290525776be7c15d108b749c2a1e4b018de827915 -8b6922ab1db925eed24b2586e95f5c709b79d2408a8fa2a71057045ead3ebdd0cc72bee23d9064cd824166eda1e29318 -89a991087a0b5805fcc5c6c5f6ac27e100da0d3713645aa9c90114e68ca9f185f21155eb7645a2c6c0616a47291fe129 -ae6ef954c942cbfd37f8f2dc58a649e2584d6777e7eb09ae6992ccde283ac4f4ec39e3a5cda7f7c60f467fb308d37f08 -9335ca5ccac59b39eb2bcef09c54b778ebb690415ba13fe5c8e4b6091d9343a01cc9baa6228cefd8dba98f0710f714da -a0211c9328be2b46f90ff13614eeffb4c1285e55580db3874610653219926af1d83bda5b089fd37a7c7440a0f1d94984 -a82e097dfa782c40808fac5d8ed1c4fccf6b95ef92e22276fd8d285303fcf18c46d8f752595a658ee5294088b9dc6fc0 -ad108fcd0ead65f7f839a1337d520f5bd0cb665ee7100fc3f0563ff1d2959eb01617de8eb7a67c9b98b7b4892082acdb -b89e6aeabcb3ee3cbf12e3c836bab29e59d49676bcf17a922f861d63141076833f4149fe9e9c3beed24edfacdf1e248b -8477501bd91211e3b1f66c3bfd399ef785271511bc9366366ce95ec5ea95d9288ab0928a6b7887aba62de4da754d3eaf -aeec40c04b279096946b743ad8171bf27988405e1321c04894d9a34e2cbd71f444ff0d14da6cda47e93aa6fe9c780d50 -a703bd2d8a5c3521a8aad92afef5162aed64e9e6343d5b0096ca87b5b5d05e28ed31ba235ab1a626943533a57872dd01 -b52d9dfc12c359efb548d7e2b36ddedaefdec0ef78eda8ac49a990b3eb0ed7668690a98d4d3c7bec4748a43df73f0271 -af887c008bad761ee267b9c1600054c9f17f9fc71acfe0d26d3b9b55536bca5c8aebe403a80aa66a1e3748bb150b20ef -ad2f7a545ef2c2a2978f25cf2402813665c156bab52c9e436d962e54913c85d815f0ba1ce57f61e944f84d9835ce05ea -91a0a9b3cfd05baf9b7df8e1fb42577ec873f8a46bb69a777a6ac9f702735d6e75e66c9257822c781c47b9f78993a46b -939fdc380fb527f9a1ddecf9c9460f37e406cd06c59ce988e361404acbfcb6379f2664a078531705dbc0c375d724137b -8bbbe5d5a0d102b8e0c8a62e7542e13c8c8a6acb88859e78d8e1d01ec0ddff71d429fcb98099e09ff0aa673c8b399dc4 -b67a70e4ef138f48258f7d905af753c962c3cc21b7b8ae8b311a2356c4753f8cd42fdee09ac5ed6de31296ead88c351a -8d21539e7dca02a271ce7d16431773bbe30e6a03f5aff517132d34cdd215ad0da2f06aa4a2a595be489234b233e0852e -892ae11513f572cc5dc8b734b716bb38c0876e50e5e942631bb380b754e9114c34b0606740301e29b27d88439fb32071 -a8780dc9faa485f51b6f93a986bc4e15b166986b13d22ec2fefc6b25403b8b81c15cc9ac0025acc09d84932b15afa09b -b01af013360cd9f2bb9789a2b909c5e010fe6ff179f15997dee1a2ba9ef1ccec19545afdecfcb476f92fcdd482bb2b5a -b5202e5d5053d3af21375d50ad1ccd92538ef9916d17c60eb55c164767c3c74681886297b6f52e258c98d0304d195d3d -8f6adbcfbb0734bf3a4609d75cf2e10f74ed855a8b07cf04ac89a73d23b2e3e5cf270a1f2547b3d73e9da033a3c514b0 -8abe529cd31e4cb2bd75fa2a5e45bd92cbe3b281e90ffc7dea01ba0df17c9a3df97a3fde373cce5d25b5814cf1128fed -b8bbf51187bb3bb124da3870e2dfecb326f25a9383e5cc3323813487457010b9055811669c3da87105050825dc98a743 -a5c83875fe61ebbdd3fd478540d7e5a1ad0f8c790bad0b7dd3a44831e2c376c4fffbc6b988667afa1b67bfaa2dbbb256 -a0606b3062e4beba9031ba2a8e6e90aa5a43ba7321003976e721fd4eedb56486f2c5b10ba7a7f5383272f4022092eacb -b485cc5e001de6bd1bbc9cd8d777098e426d88275aaa659232f317352e1ddff3478262d06b46a573c45409bc461883e1 -916449580b64a9d8510e2f8c7aee0b467a0e93b11edc3d50725bcbc3ca53c2b8bb231fdc0fc0ed5270bf2df3f64750d9 -b2e687caa9f148c2b20a27a91bada01a88bff47faaf6ed87815db26bb6cdd93672199661654763a6b8b4b2012f59dcca -b6933f7f9dabc8fb69197571366ac61295160d25881adf2fcc8aaabc9c5ed7cf229a493fd9e2f1c2f84facd1f55fee84 -b01eb8b2cf88c75c3e31807cfc7a4d5cafded88b1974ba0a9d5aaeda95a788030898239e12843eda02873b0cabe30e2b -a3ca290fa6ce064514a3431b44ecdb390ef500629270202041f23bc2f74038147f338189c497949fb3126bae3a6e3524 -93b0f8d02bd08af74918b1c22131865aa82aba9429dc47f6b51354ba72e33a8b56684b335a44661aa87774931eb85974 -81eebeb9bd92546c37c98e0a5deba012c159f69331a89615cf40c5b95c73dcdbf3ceb46b8620d94ff44fcdad88020c1e -b350e497932382c453a27bb33d2a9e0dbadf4cd8a858b6b72d1f3a0921afc571371e22b051b97da3bb08694c4ca3a4e8 -8c7052f63ba16f14fa85d885aa857d52f04b3a899a4108493799c90c0410de7549be85bec1f539f1608924668df48e5a -b397574d1fb43de0faaea67d1d9348d67b712b1adce300d6dc497bca94e0994eef8707c285c5c9ac0a66022655a8420b -a934661d2168ae1bd95b1143c2e5c19261708aeb795abad8ec87f23dc1b352fa436de997ebb4903d97cb875adb40dc2b -acf535fa1b77255210e1b8975e0e195624c9e9ffd150286ccd531a276cadc12047a4ded6362977891e145a2bd765e6b9 -8cc32356015d7fd29738dcc13c8008cdbe487755dd87d449ab569c85d0556a1ec520dbce6c3698fc413d470c93cb0c92 -8787c7b3b890e0d3734ac1c196588cacf0a3bde65e2cf42e961e23dbf784eef14c07337d3300ed430f518b03037bd558 -99da90994030cbc2fb8a057350765acac66129a62514bbd3f4ec29d5aab8acdd5f4d69ca83efe7f62b96b36116181e79 -a306424f71e8b58dfa0a0564b2b249f0d02c795c30eee5b0ad276db60423210bba33380fb45dbe2c7fedd6ee83794819 -b207a35d31ce966282348792d53d354bbd29ac1f496f16f3d916e9adbf321dc8a14112ca44965eb67370a42f64ca1850 -89e62e208147a7f57e72290eefccb9d681baa505d615ca33325dfa7b91919214646ca9bdc7749d89c9a2ce78c1b55936 -ac2d0ec2b26552335c6c30f56925baa7f68886a0917e41cfbc6358a7c82c1cb1b536246f59638fb2de84b9e66d2e57eb -8f1487659ecc3b383cebc23a1dc417e5e1808e5c8ae77c7c9d86d5ab705e8041ce5a906a700d1e06921f899f9f0ee615 -a58f1d414f662f4b78b86cae7b0e85dfddae33c15431af47352b6e7168a96c1d307d8b93f9888871fc859f3ed61c6efc -94f3626a225ac8e38a592b9c894e3b9168f9cf7116d5e43e570368ee6ee4ab76e725a59029006a9b12d5c19ddce8f811 -b5986e2601ad9b3260e691c34f78e1a015c3286fdd55101dcef7921f6cbcc910c79025d5b2b336d2b2f6fd86ee4e041e -b6e6798ddd0255fbe5cb04a551a32d4c5d21bdfd8444ff2c879afe722af8878d0a3a2fe92d63936f1f63fea2d213febf -86bea9bfffef8bc11758f93928c9fdfae916703b110c61fa7d8fe65653f8c62c6fecd4ff66a1f1a7f3c5e349492e334c -9595a4606284569f4b41d88111320840159fd3b446e00ec8afd7ddaa53dd5268db523f011074a092f8e931fc301a8081 -83b540a6bc119bf604a7db5f6c0665c33b41c365c12c72ca4fa7b0724115bbb0ff1ae38532c3356e8bb3ac551285929f -92c6daf961ca4eb25293e1794cf85cda4333cf1c128207af8a434e7e0b45d365f0f5baaefc4ebd5cd9720c245139c6e2 -b71465f3d7dba67990afc321384a8bb17f6d59243098dbed5abd9a6ffc7a3133b301dd0c6ca3843abbaa51d0953abbed -b15d93482d2ee5b1fec7921fcc5e218c1f4a9105a554220a4fb1895c7b1d7a41f90bbf8463d195eecf919fcbe8738c51 -a79c98e70931ffd64f4dcf7157fbae601a358261e280fe607eb70cef7d87f03efa44cf6ba0f17fbb283a9c8a437d2fdb -9019d51a6873331f8fe04cb45e728a0c8724a93d904522a9915c748360ddf5cdbf426a47b24abf2005295ed2a676cbf0 -b34cc339fec9a903a0c92ce265e64626029497762ff4dcaaf9bb3994298400ce80f4fb7dbe9ec55fe0c4a522c495cb69 -8fda9be7abfe3b2033cad31661432300e2905aef45a6f9a884e97729224887a6ec13368075df88bd75c11d05247bef15 -9417d120e70d6d5ca4b9369cba255805b5083c84d62dc8afec1a716ead1f874c71a98ad102dac4224467178fe3228f62 -a0a06b64867eebb70d3ce8aaa62908a767fb55438a0af3edf9a8249cd115879cde9f7425778b66bb6778cb0afeb44512 -a44309d3e1624b62754a3a4de28b4421f1969870f005ac5dc7e15183fa5b3ad182bcd09cca44924e03fbdb22f92f8cf8 -aea80f1c3a8fc36cfb5c9357d59470915370b2bec05f51f1d0e1d4437657e2303ba2d1ac3f64cf88f2df412dff158160 -b3f1557883d91b24485123d2f3ae0fce65caa533c09345ae6b30d2ac49953acee61c880c57975be7b4f5558d3a081305 -b52cb1e56f0d147cfb58528b29c7a40bab7cfc9365f2409df7299bfc92614269ff9de3cb2500bbc4909f6a56cf4b9984 -aa4f8fd0f5f87c177ee7242f7da76d352db161846cd31523a2100c069d9e4464170eec0bffc6d4da4f9e87017b415dbd -b5b61f52242985c718461a34504f82495d73cbb4bc51f9554b7fe9799491f26826d773656225f52a1531cd5bd6103cde -ad12ba9697804ede96001181c048f95b24ba60761c93fb41f4b4a27e0f361e6b1434e9b61391bacaf0705fdaa4a3a90e -9319286cbda236f19192ae9eb8177e5a57a195c261082ba1385b20328fb83ed438f29d263dddae2f5278c09548830c4a -88b01ee88c3a7ae2c9f80317dddbaa2b7b0c3a3c23828f03ff196e244500410c9ac81c2e2d3e1f609d4b36ee1732738c -8e31f30600a9d629488d44a008c821c3c57f13734eaee5a19f0182a2de9e538fff7d982980d7fcc725c969f29f7c2572 -b215740eea98b4bb14197a803a8975700ad2f25a25ef3628eae10166d56c823301f6dd62ce3f9ebf2d42d1f33d535004 -8fb0fdb253d4bcc6693642779be13a5b816189532763dfd7da868cfacfdb87cb5ebe53b18b69dfd721f8d4baf3c1d22d -8cdd050a447f431ff792156d10381aaf83c6634a94b614dd5b428274538a9cc1f830073533b4fd0a734d6dd4f8d9c4ce -81b01ee8c72ac668ad9dd19ead2d69cac28c3525e613e036e87aa455c2da9651cc8fcc97c451a8c8a071a4eb69623cd1 -8d9e02dc9ac83f861b3745bd69216232144c47cb468a7dbc49083ed961f978e34265b3f42c400339120bdc4644fe5711 -89e9410455b34cba9db0a5ea738e150fae54dd000d61e614f3274a6c8102ba7cd05b0936f484a85711ad9da7946f51ea -91f9d4949678f8e6f4b8499899818bdd0f510da552b5d79d8e09bf3b69d706ab36524b5e86d3251318899b9223debf6b -8b3c38eec7e1926a4be5e6863038c2d38ab41057bcfa20f2b494e9a0c13bc74c3a44c653402eb62a98e934928d0ebccb -a5cfe465bfbf6e8bfbd19d5e2da2fc434bd71acd651371087450c041aa55e3c4f822361e113c6c3d58646ed3ba89d6da -918665b8810bcb8d573ca88b02a02c62eaa5a4a689efb5c564b0c9183f78144e75d91fd1603e17d2c77586cbe5932954 -997dace0b739aeb52ba786faae5bdf1d48630a90321f9ceebfa9e86d189a3d79d7b04e459ac8e4adcfe83a5ce964eb1c -a5a1ca9f0ccc88017a616d481d912aab3f0e154b673f1131c5d9c9c3f5f147d25b6392b2c31e49f7bb7eb2697d05dbec -a76e99bec509eff01bf6767a06ac97ebc6671cb58bc3d4acc2803580a874885453dbba2e1bba26e45f8d2bda5f688860 -956c1362c8123c5d9ebff7049e851235d69fa645f211ef98e2b6564f2871114a12224e0ec676738d77d23c709dd28a6c -885efede83b1a3e96417e9f2858ab0c7a576fc420e8f1f26cabf3b1abeec36bcaa63e535da177847f5e0afdb211bf347 -affca2257f292a2db52f8b1bab350093f16f27ef17e724728eeaec324e2513cd576f6d2e003cc1c6e881334cb2e8bf22 -8dac963d34dcc9d479207a586715e938c232612107bb2d0af534d8da57ad678555d7c1887fadca6551c4f736ffa61739 -b55e600a6bbde81f5a0384f17679d3facb93a7c62ca50c81a1d520cf6e8008ac0160e9763cb2ca6f2e65d93ca458783b -9485e6c5ab2ebfb51498017e3823547b6ab297d818521ceac85cd6c3aa2d85ae075a0a264ae748fc76ce96a601462ffa -b4d8abca786c0db304a6634fba9b2a40d055c737ed0f933e1739354befdae138dae3c8620a44138f50ebeaf13b91929f -8bde7ca39c7bda95b1677a206b16c3a752db76869ea23c4b445c2ff320f2ee01f7358d67a514982ee3d1fb92b7bd7229 -8f8cd0acc689b6403ee401383e36cae5db2ff36fc2311bbadf8ebb6c31cbcc2ca4ffac4c049da5ba387761ef5ec93b02 -a06f42d5f69a566ff959139c707355bbf7aa033c08d853dce43f74a9933e6d7b90e72010ef3fcb3d12e25852343d1d31 -b10ece7cf6b69a76dba453b41049db0cdf13d116cf09c625312b150ee7437abd71d921eda872403d7d7ce7af1e6dccb7 -a3d820318e0f3b54fba7a4567912a82d6e6adf22b67cfc39784683a8e75f77538e793d9708aae228fa48a71abb596195 -8758fad55b68a260bea3bd113e078fd58d64a92f7935ff877f9f77d8adc0994b27040cfc850126c7777cfdfb2428a3e5 -b504913ee96c10f00b848cd417c555a24bc549bf5c7306140eff0af2ada8cb5e76bed1adb188e494332b210fbf24e781 -a00e019a40acc7aab84c1cc27c69920ad7205c2a3dc9e908a7ef59383695c9cb7093c4bcbc2945aab2655119552e3810 -b1000b4c4f306672e39d634e5e2026886a99930d81b8670a5d4046db9621e44997c4b78f583374a09c60995f18a6fd4f -a6c5053c4e748540ad2b622c28896c9d4ca3978ca4784ac8f09da5314a245f5cdc5d6203c84e6e0bcb3081829720a56d -8e37e67a70205a5c7da95de94ac4d0ebd287c1c9922d60c18eec1705030dfcbf74ae179e377c008bf5a8bc29c7c07cce -a66bd7c0243319b553d5cb7013f17e3504216e8b51ba4f0947b008c53bcb6b4979286b614a4a828ee40d58b5ef83e527 -97e2110b0fb485508a2d82ecc2ce1fbe9e12e188f06c7ef2ac81caeeb3aca2c00e5e6c031243b5ca870a9692e1c4e69b -8734ce8bbc862e12bea5f18d8a8d941d7b16a56ef714792fed912ca9c087497e69b6481fdf14efe1f9d1af0a77dac9b1 -b441dddac94a6a6ae967e0e8d7ab9a52eb9525fb7039e42665e33d697e9a39c7dcef19c28932fb3736e5651d56944756 -918b8997f2d99a3a6150d738daed2ff9eb1f5ed4a1c432d18eab4a898297f7ffbffd1e4ae9037acf589b1cd9e1185ef6 -a0247b8ac4d708cf6b398dc2d5c127a291d98e8bef5f195f820c4fddb490574ba4f62647c2d725237a3e4856eec73af0 -b45636e7e0a823c2a32e8529bb06fcccfd88e9964f61201ee116279223ed77458811d1b23bcb6b70508d16d4570a7afb -a99c1188fa22b30b04fda180d2733586ea6ef414618f1f766d240c71f66b453900d3645541c019361027aebe0a0f305f -b4c2f758e27fe233f7e590e8e0c6de88441164da3fcd5211a228318d3066dfdafc1d40246dd194f2b597f6fe9600b3d7 -972530819445b11374c3043d7855d5f1d3c4922b3b205d0bf40162c51605375dd0b61f49cd7f3d39a533a86a13005989 -992b533a13e5d790259bfdfdf1074f84a5e5a0a0d7be9cd6568cdc1662524f1a6666a46da36cea3792ba6707850f4d86 -9875d130457e04dc6ea2607309bfbb900ad3cb5f3e0574f808d27b20cbf6f88389d87dca19998680c5bc30d1df30a41b -adea8494a69e83221edf360ab847272b5c47eba5404665fb743d98c0682732c30085ae3ec82bc1e8e4aba8454c9b1849 -887d4c624ce05e224216c5f6fa13c5741012ac33330bc291754782f0bfe668decdc98c0e43a1ce28323effe6b639f477 -ab6b167aeb5e93ab155990b94895e7e7ff6dea91384854a42cc8a3b9983495b4b3c33ab1b60b2b6450ccf0418fada158 -a7588d0b7c6a6bc32fc474aa0f4e51dfb8e6e010346ad32c59d6f99e6f0522424111a03a4f56ba4075da8009ee7a63e9 -94d645cc3936db1563568193639badfc064dd5bda8d0631804ee00b09e141b200619e07506b5a8225130541436327194 -8d695c03cc51530bdc01ee8afcd424e1460d2c009e1d7765c335368e5c563cf01a2373c32a36400c10e2bf23c185ed19 -ad824a0a7ed5528e1f9992cbb2050785e092b1ea73edd7fb92b174849794a5b04059e276f2941e945bc0f3e46172f2af -ad6ed2af077a495d84f8eeed7d340b75c0d1c8b7c5a854dfc63ab40a3d0c2b0d45016d30b3373a13f0caae549f657976 -82454126c666023c5028599a24be76d8776d49951dfe403ebf9a5739b8eb2480c6934a34010d32cd384c91c62a9aa251 -b57070006793eca9fa2f5237453ed853994ad22c21deb9b835e1fb3fbc5ac73aec265a4a08de7afae1610dc8c42b7745 -ad94667c791cf58875eb77eb17b6ad02de44e4ba2ddc2efe4d0ff22a5e1a090c670354437847349fd61edc4ba5606f07 -b2aac0c345ffc00badaab331c12a22019617b004d32c099c78fa406d683744d96d51d1237ad0842f9f54655186f8f95b -8fed51076cc939b354e3b69034a594e6c9c98425ccf546154ab087a195375128444732388d2eb28f82877de971ec2f58 -8e521c0093deb9dff37888893db8ffebc139984e7701e68b94d053c544c1be0d85f0f98d84b2657933647b17e10a474c -a2c6c9a307aff9b1dea85f90fa9e3b8057fd854835055edeb73842a7ef7c5ae63d97c51fec19dd8f15d696a18a0424a6 -a3390b25a9c11344ed1e8a0de44c848313026067a0f289481673c2c0e7883a8fc9f6cab6ccd9129729a6d8d0a2498dc2 -82770c42b1c67bbd8698c7fe84dd38cc5f2ad69a898097a33b5d7c5638928eb1520df2cb29853d1fa86a0f1bcc1187e8 -a6fdf7a4af67bc4708b1d589135df81607332a410741f6e1cc87b92362a4d7a1a791b191e145be915aa2d8531ee7a150 -aecac69574188afc5b6394f48ba39607fe5bb2aa1bd606bc0848128a3630d7d27101eb2cea1fb3e6f9380353a1bb2acc -a23fd0c52c95d0dffb7c17ec45b79bf48ed3f760a3a035626f00b6fe151af2e8b83561d0b9f042eaae99fde4cbd0788d -a5f98068525cdd9b9af60e0353beb3ac5ac61e6d3bac1322e55c94b3d29909d414f7f3a3f897d5ae61f86226219215c6 -b2a4d724faac0adf0637c303ff493a1d269b2cdbec5f514c027d2d81af0d740de04fb40c07344e224908f81f5e303c61 -adeadb3521e1f32ef7def50512854b5d99552e540ec0a58ea8e601008de377538c44e593e99060af76f6126d40477641 -a18b7fc2fcd78404fed664272e0fef08766a3e2bc2a46301451df158bd6c1c8aa8cf674dd4d5b3dedfaceb9dd8a68ae3 -83bcfb49313d6db08b58c6827486224115ceef01ca96c620e105f06954298e301399cdd657a5ff6df0b0c696feec1a08 -8c94391eba496e53428ec76dfe5fa38f773c55c0f34a567823316522a0664a3d92bff38ec21cf62ac061d7d1030650c5 -b1fa196ccfd7d5f1535b2e1c002b5cde01165c444757c606b9848bc5f11b7960973038fb7cc3da24300fc1848e34c9af -b139f6c6449449638de220c9d294e53fc09865a171756d63bbf28ec7916bf554f587c24bddf51dd44372d15260d8fe25 -b716242299d4ee72b5b218781b38ca5e005dcf52333364f85130615d1dbf56216af8ee2c9c652d82f7aab5345356538c -9909f24e4ad561aa31afd3a3b9456b2bd13a1d2e21e809a66af62fec5f95b504507ac50e81d2233da2b223f5443e7585 -ae863530a02cf3a757f72b945c8c0725d9f634d2ff26233478d1883595ff9a1eef69e8babffdbfa161452fc204f5b5a1 -8eb82bde283b6a6e692b30236cbf41433b03eda8dad121282772edd56f144b1ebf5fb489d18c6ce8776135771cbb91e2 -9296141fadf8dadc885fff4999c36efa25ec76c5637a8300a1a7dc9cf55bcedfe159e0ef33f90eee9be8c4f085734e10 -b6c07f2e6fcbd6c42a8b51e52fbcd5df3aa9f7c3f0b3c31021de1aec2111d0a1c36b5ab489ba126af44fd43cf31c2594 -a70ca669c357535b363d16b240fd9cb9c5ba1b648510afc21218ea034e9bf5f22717ae31ff43ef89dded95b7132fa58f -b350721f8f6b4d164fd08aca30cd4dece9b4a81aed0ac12119c9399bab691d5945814306f9a61f0106b76d4d96f7b9d6 -b6886076c9d8c344bf3fb6975173d00fa82866012894f31c17e6fc784fbc0dd2d24d6a1cddd17f7379c74566a23219aa -87636e4a83ceadc170a4b2517b19525c98e2163900401996b7a995b2f3da8d6ba2ab92f909eade65074fac07cf42f6fa -8ff61d87c4699a067a54b8540e8642f4c7be09d3783ec18318bcba903c6714fcd61be69165e07e1ca561fe98e07507de -85485d6b569ac20e6b81a9e97ef724e038f4fee482f0c294c755c7b6dad91293814f143bfcfc157f6cfa50b77b677f37 -a49256cb1970cc1011a7aed489128f9b6981f228c68d53b1214d28fbcfb921386cc7cf5059027e667a18073efa525a74 -87bc710444b0c3e6682d19307bedc99c22952af76e2d851465ee4f60e5e1146a69f9e0f0314f38a18342e04ece8e3ed3 -a671a6cabfd19121a421fdfe7732eccbb5105dfb68e8cbcf2b44ae8465c99e78c31b99730beca5bc47db6fc2f167203a -a2f3270c184629f6dfc5bf4bdd6e1b8a41e8840a1e4b152253c35c3d9e7ab4b8e3516dc999c31f567e246243e4a92141 -b9795a5a44f3f68a2460be69ecacdbb4664991ebbedffed5c95952147ad739e2874c099029412b9653d980a2d4307462 -959053faec9a966dd5a4a767a3154e4b8e4f56ca540ae53e373c565dda99fb626f725e5a5e3721c82918f8c5f2e9e0a3 -b3ef9d6a1b3cd44a3e5112819fa91cb8a7becc3f5b164c6f759f93171d568497b01c8e743f4727b341a1296a0dbadf4f -b852dfdfbe2b8c77d938fad45f00737e14eacf71d5fecbb3e4f60052ec9efb502c38c1fcecaf71da69eabe8b33852a67 -921c7007f26bdd4139e919dfe27d87b489a0bc5bd6fb341e949e4451f14c74add0489b108c9c9666a54c5455ac914a9f -86b63d73ba31c02e5337f4138e1684eccdc45ab5e4f30e952fb37d638b54ecec11010414d7a4b7aa91f7cc658f638845 -853c55e0720b66708a648933407795571fc11ad5c234e97f92faabce9e592983dfb97a1705047ee803648ecf9fbb2e5c -995fe7d1dc09bb0c3c3f9557c4146534778f5ea9c1d731c57440fdcf8094f82debf19090b5d23298da1ed71c283b3ae5 -b9c49c911a0c4d716b7baec130f9e615bfa7d504aa8766ed38878a93c22b1f6353503d4f7f425d4902239fb4689429df -80504d964246789a09dcd5c0298680afb6fe50bca3bb9c43d088f044df2424a1828de10e0dbdc5c0aac114fa6d9cf5d1 -90249351f109f6b23a49a610aaa3b2032189fd50e5e87cdc3b20f23ed4998af3a8b292bf9fbab9bd1cbe0a1371081878 -abb5f0148850f0d80b429c2b9e0038772432340ef0862ccb5dcb7347026ca95bf9a5857f538e295aebd3a6a5027adb4c -b92ac9c0f7e73150798348265e5f01f3c752480c72613c6894a95e9330bba1c642b21b9cbd8988442b5975476634b4fa -af3fbcc825abd92c6d7ea259467f27045e288f27a505e6a3c9ec864aa08fcaca0d4123034513dbd4c82d4814075708ab -a738232a66030e0e9c78e093a92fcc545b10e62fb0ecb832bbbc71471b28eb6ec422a498c2402e2c6d74983df801e947 -ae60194ce2035edd1af253b9eefbb4b1b7609c9678256c89c3cb076c332a9f4442c3441ad2ecc9d73265359bdadc926c -8b2fd55e686f16725fc0addb4065f696275852320b03221fd22889825d66fae5bb986b03c47452e32b3a32c1fdfc8dfd -8e2e1a36673b7729b07e7bc5014584e1c03e9552f7440fbfda0a6a7f41953947fcdf8d666f843bfc03dcca5b06a14318 -95a3df04368c069f3fd32a20b627c5f043e952167c9e80bf5914bbf2086879909c60e089bbd488725ab977c0e6051728 -9856403b2211d0152d4eec10db7ec34c16ac35170714b75af3ebc398a676c171b24b6f370361de0f9057ba444293db14 -a2cb484b758af5fd8e2baca7f0406f849c71255e58ef110d685cd0c1137893a25d85a4d8582e3ced7dd14287faa95476 -b0f697b6a42f37916b90ab91994ae4a92c96dc71e4da527af41b9d510bc2db5a9b4f29183a758074b6437a1e62b2d1d7 -b39c49266aae46f257b7ae57322972fb1483125298f9f04c30910a70fe5629dba0ec86b94cc6ba16df3537a55e06f189 -86cd5595b5b769dfd9ceb68b11b451f6c5b2e7a9f6f6958eac8037db1c616e8a9defb68a0d6c2287494d1f18076072c1 -b462e8fa9a372d4c1888fd20708c3bed1cb00c17f7d91a0481238d6584fbbf2d238e25931154f78a17296a12825d7053 -a5ef28286628ba509bac34c9f13158d0013239fdca96b5165161f90b89d6e46295822ebdf63f22d7739911363a0e0e86 -a629a95a24e2545862b41a97ecba61b1efa792fd5555dc0599c175947e9501bffc82b05a605fd5aabc06969ccf14fff4 -af83467e4b1f23a641630cc00c38d4225ff2b4277612b204d88de12a07d9de52fb4d54a2375a7fd91eb768623c255376 -a630f29fb2e9a9e2096d7f3b2f6814ee046ebc515f6911d4bc54ad8a5a821a41511ff9dcfbe3176f35c444338ecd0288 -950dedc11bd29e01ba9744bec681ad9462127c35e9fcadfacc9405ec86b985a1b1c4f9ac374c0f1fa248212e5e170503 -82e8e7be8011ee0fd9c682d26a0ef992d0191e621d07fd46a3a5640ef93a42e1b98a33cad1f8017341a671d28caebb03 -a075860554e712398dac2fb0375067a48d0e4ca655195cefc5ccb1feb8900d77124aa52a12e4f54f7dab2a8f1c905b5b -81d2183d868f08714046128df0525653a2dc2ff9e2c3b17900139c9e315b9f4f796e0fb9d1d8cbadbaa439931c0e0879 -81fb1456969579515a75fb66560f873302088cde2edc67659b99a29172165482ca1f563758c750f00086b362ae405322 -a13c15ab19203c89208c6af48d2734bb0873b70edb660d1d5953141f44db9012528d48fb05aa91d16638cbda2ca8f0cc -8ba46eef93e4ec8d7818124a0b9fcfe2bcf84a98db3545d2b3d0192cfadc81fc667dcc22ab833c3e71508d0f3c621fe4 -b9bd60d2266a7d01e1665631a6ed6d80ffc0cd7f088f115a5d4ea785c518a8f97d955e2115b13c4960302b9825526c92 -b26fa4e87142150250876083a70c229249099331410f0e09096077fdf97b31b88dc57a3e3568d2a66a39af161cf5dfec -b9d147564124728b813d8660ba15fa030c924f0e381ad51d4e0cf11cc92537c512499d3c2983dd15f2e24ca166070d70 -b6fb44e1a111efb3890306fa911fafda88324335da07f7de729b2239921ef15b481630a89c80e228bec7ab6444a0b719 -a6cd9c7acac052909ef0cf848b6012375486b59b7bac55b42c41f0255b332c1d45a801f6212d735be8341053bd5070b9 -864258d69234786af5de874c02856fc64df51eff16d43bfb351b410402ab28f66895aec4025e370a4864f19ff30fd683 -84370fa1243b64b3669dd62e1e041ff9bd62810752603486aac3cba69978bd5f525c93cbc5f120d6f2af24db31ec3638 -b983c2cdc1a310446de71a7380b916f9866d16837855b7d4a3a6c56c54dab3e373a6fc6563b8309dc3b984d4e09275d6 -914f8587f876470f7812fa11c6f67e2dd38bf3090e8928e91fe2fe5595bee96cbe5f93d26fdced6b4e7b94f75662b35d -8b47bcb111d91aa3d80e4ceef283824aa00d1faeb6fe4111aecd9819869c0e1f6f4b6fb2018aebb07a0f997412cda031 -95b2befa98f9992450ca7ff715ae4da8c36dd8adcfef3f0097de6e3a0b68674b05cbf98734f9665051bb4562692641e0 -8bcd1651a2bfce390873a958e5ff9ca62aac5edd1b2fd0f414d6bcf2f4cf5fa828e9004a9d0629621b5e80fbbd5edb90 -af79bed3c4d63239ac050e4fa1516c8ad990e2f3d5cb0930fc9d3ce36c81c1426e6b9fe26ac6a416d148bf5025d29f8b -881257e86b7ab5af385c567fde5badf67a8e7fff9b7521931b3ce3bac60485c0fe7497339194fb7d40e1fad727c5c558 -a1b40b63482cd5109990dfb5a1f1084b114696cbbf444bf3b4200ab78c51dad62c84731879ea9d5d8d1220e297d6e78a -b472212baa2a31480791828ca5538c3dcc92e23f561b0412f8cc9e58839d1625ddcaf09c8078d31ac93470436843cd74 -8f516d252b1863cd3608d852a2857052bb2a3570066d4332fa61cb684b10ac8d1a31c8d32f2a0d1c77eee2ad7a49643d -8d20b75c51daa56117eda2fd5d7a80a62226074b6a3ff201519f2054eecfeff0aa2b2f34b63bea3f53d7d0ce5c036db9 -8282f433229e7948a286ba7f4a25deb0e0a3c5da8870562c3646757bef90ca1e8d3390b0a25b3f2bf45bf259a4569b77 -8a2dbf4b55cc74f0a085d143a88ebc8c2a75a08eab2703d13a00b747eaddc259a3dd57f7330be938131835a6da9a6a68 -aa0bc51617a938ea6a7b0570e98b8a80862dd9e1cf87e572b51b2a973e027bcd444ef08e0d7b5dee642e0da894435e91 -aa7319ca1ac4fe3cc7835e255419eeb7d5b2d9680769cc0ca11283e6147295db75713b71a9312418a8f5505cd45b783d -ab3f9c465663dc90fae327a2ee9cb7b55361a9b6fbe713540a7edd3cff1c716802fb8ad4dd8fb0c945d96b3b44c5795b -913a2ae88acffab12541fc08920ee13ab949f985a117efe9a5b2c76f69f327f60c5b5ad3fa5afa748034ac14298fc45a -9008f044183d2237b723b235953e4d8b47bec6a7b300d98075555478da173b599ba9c7c547c2f111ce1fae5ac646e7a3 -a26b4cc42b353e1c18222d2e088d7f705c36be12e01179db440f10fcfa9691d31fc4fc7e7ee47876f1624e6d44be1021 -995e75824f322294336bfa2c5d1a319f0d77f6a0709beabaf1b43015d8a78d62447eab907349524734170f0294d1ca7a -8b96f04a19dbe4edc71d1f2c6d3475ae77962e070ec5797752453283c027c6b29b6e58e8b7eb5c3f9770557be7e80b67 -8621459865234734bcfaa492ca1b89899525198a7916ccc6f078fb24c8bf01154815bb5b12e1c3d0a10bd4f1e2ea2338 -ab52174541185b72650212e10a0fe2e18ccfd4b266a81233706e6988c4af751b89af87de0989875f7b5107d8d34c6108 -966819d637bdd36db686be5a85065071cf17e1b2c53b0e59594897afc29354ecba73bf5fc6fa8d332959607f8c0a9c27 -b7411209b5ab50b3292c3a30e16f50d46351b67b716b0efb7853f75dc4e59ec530a48c121b0b5410854cd830f6c4b3ea -a5dc04adbadce0af5dc1d6096bad47081110d4233c1bf59a5c48a8e8422858620f4be89bf1f770681be2f4684ee4cce7 -af77a8f83cffb5f8d17be0ab628dedcad63226c9b13ce4975fb047f44bfef7d85e7179aa485abb581624913eddbb27ec -82bf28dc58c893c93712ce297cc0d64f70acb73a641cb4954ccf9bf17597f6d85eecf5a77c8984ab9afbe588562a0ee9 -988a7cef9a178e8edb91f3ec12f878fd68af2ac0762fa0a48a2423e24f765ed8f7837429fd8bc0e547e82e6894e63008 -a5d5969311056d84b3ee87f49286fac0bd9a7220c196cea4f9dced3b858dcdba74718eab95b38bd5d38d2d1184679c98 -af4d51b3ded0aaad8f12bef66c0616e9398fc42618852ac958e6ab2984a720a6111ac55b249d7e4523051740e12b346f -ac635b4a49f6fbb94a5f663660f28431ba9f7c5c18c36ebc84fd51e16077de7753595f64619b10c16510ecbc94c2052d -ae25eb349735ced1fe8952c023a9b186a1f628a7ddf1a4b6f682354a88f98987ac35b80b33189b016182f3428a276936 -ae3ab269690fdd94134403691ba4f5ed291c837c1f5fdc56b63b44e716526e18abb54f68ca5d880e2fb7bea38e74c287 -a748b03b2bd3fbc862572bc4ddc0579fa268ee7089bcfd0d07d0c5776afcd721302dbb67cb94128e0b1b25c75f28e09a -8f09a2aaa9ba3dfe7271f06648aba9cc1ea149e500a7902d94bb9c941a4b01d1bb80226fd0fd2a59ad72c4f85a2a95d0 -853d55ad8446fd7034e67d79e55d73a0afcb5e473ed290e1c3c7aa5497e7f6e9bbf12d513fc29e394a3dc84158a6d630 -b1610417fb404336354f384d0bf9e0eb085073005d236a0b25c515d28235cea5733d6fbd0ac0483d23d4960064306745 -86de805b3d4f6fbb75233b2cf4d22fcc589faa2ac9688b26730cb5f487a3c6800c09bb041b2c6ab0807bfd61b255d4c9 -893b38c72cf2566282ee558d8928588dca01def9ba665fcb9a8d0164ee00dedafbf9d7c6c13bcc6b823294b2e8a6a32c -8e50de7a70ac9a25b0b5cf4abc188d88141605e60ce16d74a17913a2aff3862dec8fbbf7c242cf956f0caae5bcc4c6bf -b5cf09886a4fb4ce9ea07d1601d648f9f9d1a435b5e1e216826c75197cd6dafd6b2b07d0425a4397a38d859a13fdb6dc -859dc05daf98e7f778a7e96591cc344159c1cbe1a7d017d77111db95b491da0a9272866d2638a731923ca559b2345ebe -8ff1792f77ecdfbd9962f791a89521561c7b82031a4e53725f32fe7d99634a97b43af04cbf3e0b0fdff4afa84c49eb99 -81e2cd8a221b68ae46dd7ce97563bd58767dc4ce1192b50ff385423de92206ff585107865c693c707e9d4ed05f3149fb -8fce7da7574e915def0d1a3780aa47ef79b6d13c474192bd1f510539359494ddc07e5412f9aac4fc6c8725ade4529173 -ac02f5df60242734f5ead3b8a62f712fefdb33f434f019868a0b8ddf286770244e2ddfb35e04e5243ba1e42bcd98a6a5 -a8d69783349a442c4a21ecb3abd478a63e2c24312cb2d2b3e10ea37829eb2226a9b8d05a8c9b56db79ffaa10d1f582d1 -b25b5cca48bf01535aba6d435f0d999282845d07ac168f2ca7d5dba56ee556b37eab9221abdb1809767b2de7c01866c1 -8af7e1d1f4df21857d84e5767c3abe9a04de3256652b882672b056a3ab9528e404a8597b1ad87b6644243f8c4cd3799f -a6718308dfa6992ae84fcb5361e172dbbb24a1258a6bd108fd7fc78f44cc1d91be36e423204a219a259be4ab030f27ff -b99cbe3552c1a5259e354c008b58767c53451932162e92231b1bebfc6a962eb97535966a9bd1dfd39010dfcda622d62a -a8458f6b8b259581f894e4b5ce04d865f80c5a900736ca5b7c303c64eaf11fe9cb75e094eece0424ba871b2aee9f7a46 -914f763e646107b513c88f899335d0c93688ffa6e56c3d76bff6c7d35cb35a09f70dc9f2fe31673a364119c67cd21939 -9210f2d39e04374f39b7650debe4aceeb21508f6110ab6fc0ab105ec7b99b825e65753d4d40f35fad283eeff22a63db0 -98729cf927a4222c643b2aa45b3957b418bce3f20715dd9d07997a3c66daa48dd62355dbd95a73be9f1d1516d1910964 -a602c399f1217264325b82e5467a67afed333651c9f97230baf86aec0dd4edeae1e973cafef2ea2236d6d5b26719954d -ac9632921d45900bf3be122c229ba20b105b84d0f0cba208ccdce867d3e9addfb3ef6ece9955950d41e1b98e9191ef42 -a76ce1f53e1dc82245679077cb3bca622558f2269f2d1a1d76b053896eba1c3fc29d6c94d67523beb38a47998b8c0aa7 -b22b51fcc1b328caa67cc97fb4966cb27d0916488a43248309c745cd6e2225f55ad8736d049250fa0d647e5f8daa713c -b7645c1923a6243fa652494fe9033fa0da2d32a0fb3ab7fcb40a97d784282a1ffad3646c499961d4b16dadbc3cbb6fd6 -acab12b490da690db77c4efdc8b2fe6c97ac4ba5afb5165d6647fdd743b4edbad4e78d939fc512bebcf73019c73bae40 -ad7a0fcd4e4ccb937a20e46232a6938fccf66c48a858cf14c8e3035d63db9d1486e68a6bf113227406087b94a0ece6a0 -a78605beaa50c7db7f81ab5d77a8e64180feea00347c059b15dc44c7274f542dc4c6c3a9c3760240df5f196d40f3e78b -8763315981c8efa9b8ae531b5b21cfc1bbc3da3d6de8628a11dcc79dee8706bd8309f9524ec84915f234e685dd744b69 -b4a6c48531190219bf11be8336ec32593b58ff8c789ee0b1024414179814df20402c94f5bfd3157f40eb50e4ef30c520 -8dac8a3f152f608ce07b44aee9f0ed6030fa993fd902e3d12f5ac70bf19f9cde2168777d2683952a00b4b3027d7b45ea -8baf7dfae8a5840c5d94eabfe8960265f6287bb8bc9d0794a6d142266667a48bec99b11d91120907592950a0dddc97d9 -b8595e6ea6b8734d8ae02118da161d3d8d47298d43128a47e13557976032dad8c2ccbfff7080261c741d84d973f65961 -8b93979c51c8d49f4f3825826a5b9121c4351e0241b60434a3c94f2c84f0b46bbf8245f4d03068676166d0280cf4f90c -aceb0fdaf20bf3be6daebf53719604d3ab865807cc2523285f8fef6f3fc4f86f92a83ad65da39de5bd3d73718a9c4bd2 -814dd41764a7d0f1a14a9c92e585f154a26c8dbf2f9bff7c63ae47f1ac588cec94f601ccc12e8a63a7a7fce75a4287f2 -b47b711848e54fa5c73efc079d0a51a095fa6f176e1e4047e4dac4a1c609e72099df905958421aee0460a645cba14006 -aaf7bd7e1282e9449c0bc3a61a4fca3e8e1f55b1c65b29e9c642bb30a8381ce6451f60c5e0403abc8cee91c121fa001f -b8b0e16e93b47f7828826e550f68e71a578a567055c83e031033c1b7f854e7fc8359662a32cc5f857b6de4aff49e8828 -b3eb70b8c8743a64e1657be22a0d5aeb093070f85a5795f0c4cb35dc555958b857c6c6b7727f45bf5bedf6e6dc079f40 -ae68987acd1666f9d5fa8b51a6d760a7fb9f85bf9413a6c80e5a4837eb8e3651a12e4d1c5105bfb5cfa0d134d0d9cfc2 -acd8fa5742b0bac8bd2e68c037b9a940f62284ff74c717f0db0c033bf8637e4f50774a25eb57f17b2db46e5a05e1d13d -a98dac386e7b00397f623f5f4b6c742c48ab3c75d619f3eaf87b1a0692baf7cb7deac13f61e7035423e339c5f9ae8abf -99169bd4d1b4c72852245ebfbc08f18a68fb5bcce6208dd6d78b512b0bc7461f5caf70472b8babf3e6be2b0276e12296 -937d908967f12bf7f728fe7287988c9b3f06c1006d7cd082e079d9820d67080736910bc7e0e458df5bae77adb9a7cbc1 -8c50e90ce67c6b297fd9406c8f9174058c29e861597a0f4ed2126d854a5632fa408dfa62ad9bb8b6b9b6b67b895d5a4d -8f4840a91b0a198226631a28e7a2e893fc6fed4d5eb3cb87b585aac7f4e780855a353631ad56731803296f931e68a8d0 -96a4b8c64d3d29765e877345383bf0e59f4ac08798ac79dd530acd7f3e693256f85823ad3130fb373d21a546fe3ca883 -b0dce7a6ab5e6e98b362442d6e365f8063ba9fef4b2461809b756b5da6f310839ac19b01d3fd96e6d6b178db4ff90ee1 -8f012cb2be5f7cb842b1ffc5b9137cafef4bd807188c1791936248570138f59f646230a1876f45b38a396cbdd3d02e08 -94a87b5ce36253491739ca5325e84d84aaff9556d83dcb718e93f3ff5d1eecf9ae09d0800a20b9e5c54a95dfebfcecd3 -b993ec5f9e82cc9ceeb7c5755d768bc68af92cc84f109dfaf9cf5feb3aa54881e43c3f598ba74ed98e8d6163377440ca -92f845d4d06a5b27d16aef942f1e3bcbe479b10fef313f9ca995315983090511701b39ccbb86b62d0c7c90a2d1f0c071 -b6ec6da0f9e7881e57fa3385f712e77f798abc523609a5b23e017bb05acc6898825541aed7fe2416c4873de129feceea -86b181183655badfe222161d4adf92a59371624a358d0ec10e72ee9fa439d8418f03d635435ec431161b79fd3fa0d611 -b5e28eeed55fb5318b06a0f63dbf23e00128d3b70358f1c6549fd21c08ef34cb1372bc0d4b0906cc18005a2f4cd349bf -85c4d3fddda61dbfb802214aa0f7fc68e81230fb6a99f312848df76cddc7b6dfd02860e8a4feb085dad1c92d9c6c65e0 -80f7fdec119309b2ac575562854f6c2918f80fc51346de4523ec32154d278f95364fdef6f93c7d3537a298dd88df7be6 -9192c1949d058614c25f99d4db48f97d64e265a15254aa6ed429e1ef61d46aa12355769f1909a5545cd925d455a57dbe -a0b1e7d928efc4dcbd79db45df026ae59c20c1a4538d650c0415ab7cb0657bc1e9daeacc3053ee547e8f9c01bdbd59c4 -893e84c41d3a56bca35652983c53c906143b9ad8d37b7c57f9dacbeb7b8dd34defc6a841f5b9857ffb90062bbd8e9dee -a7f89a448349dbc79854cf888980327f92aedc383c7fadd34fdc0eaa4f63d751315b4f979e14f188854ef4d16c9e8107 -833f2774a96187805f8d6b139c22e7476bce93bc5507344d345008080fb01b36d702b96e4c045617a23a8ca1770b4901 -80e46e86d68bd0a48ac6fa0b376d5bb93a5d6b14f08b3a47efa02bb604c8828c2047695f1f88fc5080e5548e1a37130f -943f42b7b4ad930059a26ad06b62e639f06c1c425d66066c55134e97c49abe412358c7cb994fcc1cf517ea296bca1f68 -8b9d4fe835dc6a2cbf85738937bbfb03f0119ab8df04a7d68860716ce6ee757dbe388a1e8854ddb69fe0c9fa7ed51822 -909030c7fde2591f9ea41ae6b8fa6095e6e1a14180dda478e23f9c1a87b42c082a1ea5489c98702f6ccd2ba5812d1133 -a715ec1beb421b41c5155c7ef065bbb50b691d0fa76d7df7ee47683d9e4eb69b9ea3e62fc65196a405d6e5e29e6c2c60 -8c9e801cb7ef780a535be5c2a59b03e56912acbfdb00447bfa22e8fc4b11dceecc528f848d5fba0eec4237d6f81f4c79 -b96b6af857c3bc0344082bd08ec49a9bed478d4d35b85a2099b1849cd6997521c42225305f414cdd82aef94b9e1007d3 -8764db720b4e44a4d2527f7f9b535a494a46c60e28eac06bf1569d0703c4284aefa6cb81fbba9d967286f9202d4b59ea -a66fd2f9158e1ffcdd576cba1413081f43eed00c7eb8f5919226f7b423f34ac783c1c06247819b238de150eb5a48d977 -82c52e817ac3bb0833ea055dec58c276c86ca5181811cf7a483b3703a06ea1bee90ae3aeaa2cffeaeba0b15fe5bf99be -987d07cb276f7f03a492cfb82bba6d841981518286402d3e69e730a9a0e29689a3619298124030da494e2a91974e0258 -b34f2c5740236bc6d4ae940920c5bc2d89ff62a3dd3a3ec9a0d904d812b16f483073db1e53b07f2b62e23f381d7bdbe5 -a1c0679331ab779501516681b3db9eefb7e3c0affb689e33326306ada6d7115fafd2cc8c1c57b2fa6c2072552f90a86e -94805e30d7852fc746e0c105f36961cc62648e438e8b9182fc0140dbf566ec14a37ad6e7f61cacb82596fc82aed321e5 -a42fb00b29a760141ff0faaeb7aca50b44e7bbc0a3f00e9fb8842da7abfcaae6fae9450abe6ba11e8ecf11d449cbe792 -8fb36ce4cfa6187bfe8080ac86b0fa4994f20575fb853bd8ffa57c696179cc39f58ff3b4bd5a2542ff1c8b09015539df -a1c54e7aa64df7fb85ce26521ecfc319563b687ffecd7ca9b9da594bbef03f2d39f51f6aaff9a3b5872d59388c0511c6 -855e48fdb8f771d4e824dbedff79f372fd2d9b71aa3c3ecf39e25bf935e2d6e0429934817d7356429d26bf5fd9f3dd79 -8ae6157a8026352a564de5ee76b9abb292ae598694d0ea16c60f9379e3bb9838ce7fd21def755f331482dc1c880f2306 -a78de754e826989de56fe4f52047b3ffd683c6ceaf3e569a7926f51f0a4c4203354f7b5cfa10c4880ba2a034d55a9b0d -97609477d0a1af746455bbd8cb2216adacc42f22bfd21f0d6124588cd4fec0c74d5bde2cdba04cdbfbff4ac6041b61b1 -a03dc3173417381eb427a4949c2dbfa0835ef6032e038bf4f99297acf4f0ba34a5fc8ccf7e11f95d701f24ee45b70e27 -aad6283e85cd1b873aeb8b5a3759b43343fdadc9c814a5bf2e8cf3137d686b3270f1ec2fb20d155bbfd38c7091f82c44 -92ab94ed989203a283d9c190f84479c2b683615438d37018e9c8de29c2610bb8fccd97bb935dca000d97d91f11a98d65 -8c0444a0b9feb3acb65a53014742e764fa07105e1c1db016aec84f7a3011d9adc168dbba8034da8d0d5db177a244d655 -95a33d25e682f6c542d4e81716cc1c57ef19938409df38bf8f434bc03193b07cedd4e0563414ce00ab1eebbd3256f3e7 -8716c30e3e4b3778f25c021946c6fb5813db765fde55e7e9083a8985c7c815e1b3d3b74925ba108d9a733ddf93b056af -a186aabc10f1fff820376fa4cc254211c850c23a224f967d602324daec041bbe0996bf359ed26806a8c18e13633a18a8 -a1e8489f3db6487c81be0c93bade31e4d56ec89d1a1b00c7df847f5cd7b878671015f5eaa42ee02165087991936660b9 -8f688c969c1304dfa6c1a370119d1988604026a2ab8e059016c5d33393d149aae6e56f3ee2b5d25edc20d4c6c9666ad9 -91950b651fefd13d2fa383fd0fdc022138ce064ee3b0911157768ad67ed1fb862257c06211cf429fba0865e0b1d06fc8 -86cff4080870d3e94ed5c51226a64d0e30266641272666c2348671a02049ae2e8530f5fb1c866c89b28740a9110e8478 -88732c4d9e165d4bb40fb5f98c6d17744a91ff72ca344bc0623d4b215849a420f23338d571a03dd3e973877228334111 -afcc476ad92f09cf2ac7297c5f2eb24d27896d7648ba3e78e1f538c353ceeb1e569917a2447f03f3d4d7735b92687ba5 -b622aa475e70d9b47b56f8f5026e2304d207684726fb470a0f36da7cb17c30dd952813fab6c7eb9c14579aacca76f391 -802cf5630c0407ae0d3c5cf3bef84e223e9eb81e7c697ea10ec12e029fc4697ce7385b5efab7014976dacc4eb834a841 -a08596493f4cd1b8ac2ec8604496ee66aa77f79454bb8ab6fdf84208dc7607b81406c31845d386f6ac8326a9a90e7fc5 -a54652ca9e6b7515cb16e5e60e9eabbccbc40bb52423d56f0532d0bac068aec659a16103342971f2cc68178f29f695db -a3ab54875cb4914c3a75b35d47855df50694310c49eb567f12bbc5fa56296e11f4930162700e85ba2dbfdd94c7339f91 -94183a040285259c8f56bef0f03975a75d4def33222cc7f615f0463798f01b1c25756502385020750ac20ae247f649a1 -b0004261cc47b0dc0b554b7c6ebf7adf3a5ece004f06e6db3bbac880634cdf100523b952256a796998a5c25359f12665 -a25dfeb0e18ebe0eb47339190f6a16f8e116509ab2eef4920f0d3ff354e3ead5abe7f5050b2f74f00b0885ea75b4b590 -ab10ef2f5dc0ede54e20fa8b0bce4439543db8d8b31e7f8600f926b87ec5b8eea0ac2153685c7585e062ffac9e8633c3 -8386eac1d34d033df85690807251e47d0eaacb5fe219df410ab492e9004e8adabb91de7c3e162de5388f30e03336d922 -b6f44245a7d0cb6b1e1a68f5003a9461c3d950c60b2c802e904bc4bc976d79e051900168b17c5ac70a0aed531e442964 -ad12f06af4aa5030b506e6c6f3244f79f139f48aec9fc9e89bbfbd839674cfd5b74cea5b118fb8434ba035bda20180af -88511306dfe1e480a17dba764de9b11b9126b99f340ceb17598b1c1f1e5acbdd1932301806fe7e7e5e9aa487a35e85de -a17cdf656e1492e73321134a7678296a144c9c88c9a413932d1e4ca0983e63afc9cdc20fd34b5c6a545436b4db50f699 -b555b11598a76de00df0f83f0a6b8c866c5b07f7ac2325f64fb4a0c2db5b84e0e094d747186c3c698ee4d0af259dc4c7 -88014560587365e1138d5b95c2a69bdae5d64eb475838fee387b7eb4c41d8c11925c4402b33d6360f0da257907aa2650 -b220634e6adee56e250e211e0339701b09bf1ea21cd68a6bd6ee79b37750da4efe9402001ba0b5f5cbbfcb6a29b20b0c -ac5970adc08bc9acec46121b168af1b3f4697fb38a2f90a0fbc53416a2030da4c7e5864321225526662d26f162559230 -97667115b459b270e6e0f42475f5bce4f143188efc886e0e0977fb6a31aba831a8e8149f39bc8f61848e19bcd60ceb52 -b6c456b36c40a0914417dd7395da9ed608b1d09e228c4f0880719549367f6398116bf215db67efe2813aa2d8122048f2 -ab7aef0d6cda6b4e5b82d554bd8416a566d38ded953ffd61ef1fcca92df96cdcc75b99a266205ff84180ab1c3de852a4 -81d354c70ce31174888c94e6cf28b426e7d5c4f324dc005cd3b13e22d3080f3881d883ca009800f21b0bb32fa323a0cf -94f3440965f12bee4916fcc46723135b56773adba612f5ce5400f58e4d4c21435e70518bdef4f81e595fa89e76d08fc6 -a6683e7a1147f87cbeeb5601184cc10f81bca4c3c257fd7b796a2786c83381e7698fb5d1898eb5b5457571619e89e7d6 -8ca29539600f8040793b3e25d28808127f7dc20c191827a26b830fff284739fb3fc111453ff7333d63bce334653a0875 -98a69644048b63e92670e3e460f9587cf545a05882eb5cba0bcbd2d080636a0a48147048a26743509ab3729484b3cc12 -84d40302889c03c3578c93aca9d09a1b072aadd51873a19ef4a371ca4427267615050c320165abece7f37c13a73d4857 -87954271e3de3f0b061c6469d038108aac36f148c3c97aefb24bf1d3563f342ea6c1c1c44c703e1587a801708a5e03f8 -86b6f5367e04c5caa3ec95fd5678c0df650371edac68f8719910adf1c3b9df902cc709a2bddc4b6dde334568ca8f98ac -a95fed2895a035811a5fee66ca796fdecce1157481dd422f8427033ed50c559692908d05f39cb6bea5b17f78a924633c -8ba05bdadde08a6592a506ea438dbdc3211b97ea853d1ad995681a1065ececce80f954552b1685ef8def4d2d6a72e279 -90b6b7494687923e9c5eb350e4b4b2e2fa362764d9a9d2ebb60ee2ad15b761e0850c9a293123cf2ef74d087693e41015 -8819ea00c5ea7b960eb96ab56a18c10a41fd77e150ab6c409258bc7f88a8d718d053e8f6cb5879825b86563e8740808d -91e42031d866a6c7b4fd336a2ae25da28f8bde7ace6ff15dc509708b693327884e270d889fff725e6403914546055c28 -85763642052f21cf1d8bd15fd2dc0c2b91bba076751e4c4f7a31fbdb28787b4c6a74d434d6ef58b10f3ad5cde53ef56d -8b61c36c7342a1967a1e7b4c01cddf4dce0e2025bc4a4a827c64994825f53e45277550ceb73c34bb277323fb784aa3c6 -80b9634a45c8b3770e993257bd14df6a17709243d5429969ab8b9a4645bf2a94f9b3cd3d759169887b4aa0eb50f4f78c -b5c44db9439dd8aa4edd151d95e48a25c1154e1525c337f97109f40131db81a4898344c8c3144c270bdc835c269b3477 -863080fcbc227eea32d0dc844f42dc642fbda7efc398ab698be3a3c6f3bf8803dea6ba2b51fed6151f9522b4ab2a8722 -8481e871129e9cb9d2d109c513cbba264053e75192e967f89659dcfcc1499de9ae7a1ac4f88f02289150231c70b4da01 -834d8183698d3d2d1352c22c373222cb78d0f4c8cb15e0ad82073dde273b613515ebcd184aa020f48f8e6fc18f3e223c -a227e300f0c5bc1b8d9138411413d56c274cc014ae8747ec9713f3314d5fae48bb6f8cc896f232fd066182af12c924e4 -ab7242835e91ba273de1c21eb4fca8312bdda5b63b080888b96a67a819b50294a7f17a7dc0cd87fae5e7f34bc24c209a -86eb27c898a5d6c3618c3b8927acee195d45fe3f27b0991903520a26fb8021b279e2a8015fbbba5352223ae906c7c5d6 -a61b1c200b0af25da8ad8e29f78d000a98683d1508ae92ee7f4326a7c88e0edb645b6cb5dde393ac74d322895e77ba24 -887739318c710aae457b9fe709debff63bfbb3ffbbb48a582c758b45d6bf47a7d563f954b1f085c3bc633ffd68c93902 -aacfcb0e2b0a868b1c41680487dc6600577ce00aa2edeee8c6141f4dc407217ddb4d37b79e7c9182258c750d12a91508 -ad8cd2cf5ccd350cd675a17f31b86a0e47499c6c4c11df640a5391bb10989c9c70df0a3ddeba9c89c51e15fedaf67644 -8aba897d32c7ef615c4dfa9498436529c91c488a83efc07ba9600875c90c08b00f66a51469eb901451b6e18e7f38ffd7 -aab8a600609b80e36b4a6772308bac77929a0c5d8d92bbc38e9999186a1c2bfdbef4f7a2b1efba9c17a68dc15a9373ab -b95811d1454307a30c2ac8588c8104804b06c1aec783fed75a6f12c9df626be57865850100f1ad28073e3867aca941cf -8b119d3bd4ee644469457df5d8a0020fd99b8b20bd65ab121cf95a7f55e50dd8945fcf1dff9d269d9d0b74b4edbc7726 -a980b912df832ea09353fd755aa3eec9eb4cfd07ca04387f02a27feab26efa036fca54cc290bb0c04a8a42fdfd94ce2f -91288e84da1d4ee2a4dad2df712544da3a098fdb06a5470c981fb6d6f3dcc1c141b6f426d6196ff3df6f551287179820 -98b0473bcffcbd478fd1b49895c61dd2311dab3cdec84f8e3402f8add126c439ffcb09cae3b7f8523754090d8487b5a9 -abe76988cf3065801f62a1eb3cfe9f8185bd6ab6f126c1b4b4fde497ca9118d02a0db3fadccd4ca98826b30475fa67ef -94a316a0faa177273574e9e31989576a43e9feb4cc0f67aa14d5c1967c4e10fc99db3ef4fdca2e63800a0b75f4b84256 -975ad39adadc7e69e34981be2e5dc379b325dc24dddacc0bb22311ff4a551a0020a8bdecf8ab8ac5830ca651b7b630ce -8b3bc73b640dc80ac828541b723a968fb1b51a70fa05872b5db2c2f9b16242c5fe2e8d1d01a1dbeaac67262e0088b7b0 -aa8d892a6c23dbc028aae82c1534acb430a1e7891b2a9337cedb913ff286da5715209cffb4a11008eae2578f072836cb -8dee9747a3ae8ed43ce47d3b4db24905c651663e0f70e2d6d2ddb84841272848a1106c1aa6ba7800c5a9693c8ac2804e -81e2c651b8b448f7b2319173ecdc35005c2180a1263e685a7e3a8af05e27d57ec96d1b2af2cae4e16f6382b9f6ec917c -98a9a47635de61462943f4a9098747a9cf6a9072a6d71903d2173d17c073eff3fc59b2db4168515be31e6867210ecbcd -912b2398505c45b0bb4a749c3f690b1553b76f580b57007f82f7f6cce4fadd290d6df9048258978c8a95ef9c751a59a2 -8ac8f0893fe642111ef98ae4e7b6378313a12041bbca52141e94d23152f78c2e4747ae50521fc9c5874f5eb06976e5cf -946b4a8eb05b529aaed56ac05e7abeb307b186a7835623fa4e85ed9eb41a4910663c09ea1bd932a2c467d28776b67811 -a4be51abeddd40e1da6fdb395d1c741244988ff30e10705417b508574b32dce14d08b464486114709339549794df9254 -b33b6b7d66cb013e7afeabbd7ed1e0734eb0364afe4f0f4c3093938eec15f808985fb7f3976969bf059fa95f4d8e335b -a808adbcf0049f394914482483ee0f711d9a865615ff39b5313ed997f7a0d202ad9ed6e6de5be8a5c1aaafe61df84bca -8856268be15a78465ad00b495162dc14f28d4ef4dcf2b5cba4f383472363716f66dabc961a6dbdda396e900551411e41 -b16ba931e570e1bf124ea3bd3bdf79aed8aa556697ea333e6a7d3f11d41538f98dcde893d0d9ba7050442f1515fb83b1 -91ecde1864c1a9c950fd28fa4c160958246b6f0aa9dda2a442f7222641433f1592d38763c77d3f036a3dbb535b8c6d8f -92cda991f69fbf8e55c6bf281b07fff5dbbb79d1222b8c55686480669247b60212aac27aa7cccd12fcee94e7a759b8af -b1d9b5b4e996b375d505d7250a54c12d32372c004a9cabf1497899054cb8b5584b1cef1105f87b6e97603ccbf2035260 -86e98bde8b484fb809b100f150199f13a70c80813ad8b673bf38e291595e2e362ad1fa6470d07d6fbe2cf7aeac08effc -aa12f7c39ba0597a8b15405057822e083aca3cee6ed30c4e0861eeb22620823588d96c97bb1c3776b711041c4dc3d85d -b477b34f29334f3bae69c7781d574342b7c27326088f9a622559ab93075c7357953ae84eb40e3421f453e04e9b4d5877 -9625067cb2120ce8220a469900aa1d1bb10db8fe1609988786b07eb2b88e0ddb35a3eccd4b6741e1fa2365c0db6b1134 -997b92af7765f587d70ea9718e78a05498cd523fc675ad7b0e54a4aae75fbeac55d0c8d72471471439dacd5bfcfae78d -88b59eaea802e6a2cf0c0075bf3fd6891515adcb9adf480b793f87f1e38d2188c5ed61ac83d16268182771237047ec8a -a57d078b230b1532c706a81eaabfef190fb3eb2932f4764631e916a0f0d837d6014da84ede100abaf610519b01054976 -94ed5c5b96f6afa9f2d5e57e1c847ae711839126ab6efb4b0cf10c4564ff63c819d206fdc706178eb6a0301df2434c01 -980296511019c86cc32212bad6e4a77bc5668b82a2321a1ecabc759a8bbc516183a4787c7f75f9ee7f1338691dc426cc -b10ef97db257343474601fd95f9016c205e28bd22bf7b8f9e30c3b14aca1cc9a11e6404ff412ef269c55fb101fee5a37 -b670d5d9c77fc6aa14212dd3eae100620f3510031b11a9625aa40bf31835c9fd717753b555bd159b1aa64a2104929340 -862054fabf6d6d529a7584d1a48f72d2eb216caf959c782ec36c69c26aef4595415d19a28b041946811b34a629105241 -ae4bf2ccd7b0f3774653848b5b4d39e5517dcbcff30d8441d78bc387ff42b573f16b7b0a7366e6ca5cef1dd9f0816df9 -8f810527badcb49f1542a0ccd12e3541efa084243f7106eae003458c176f4c1f01daae9d4a073c2cb2aced747e8a4576 -8a32c2067aaf6baf32db67acd4974a22a6da33db5444028a7c8c4135f9c84e102dc3b2c635b15afa6dc907d0270daffb -b15fc057f306a60b20c8487125b6b334ab749cf70eb8a30c962f625bb203ebd0d2a315949ee3b7a99e3d91acec384806 -a37f145d321359b21cba7be8b64dfae7c67a20b7b324f27c9db172d58e77a49fa02ed3d06d09d7644bf1fd81f4aab44b -b338d2e39a485ee4297adcf5e58e16c3cc331c5dffeade0be190907c1c5bdfed38537a6d81dc39a2cdfc1bc45e677886 -b69d84d8511b3aedfdc7c7e66f68b24e12e5a2365dbbe014bddd2e99e54143428cf8b74cf12c0e71316038aa5300e87e -ab210cc38661667450561a1857337879633f5d5bf2c434a3df74ff67f5c3ba69a7880872f19ae4dcbbb426462cd7d0fb -94538ef487a58a5ff93a5e9616494c5f066715d02be5b249d881a00bd0edfe2fe19dd7a5daa27f043d1dbb5ac69cf58d -afb47a899c1b25fe800241635fa05de9687a69722802ad45434f551971df91d8ca9edda0d835d82eb8f36ff9378ed7e8 -827a10d7536230887283a9b1dedccc6b95ef89cb883c4ee7b9821058b0f559704d1636670c0ada2b253bf60b7cb8a820 -97cc07965065d64409f19fb2c833b89ca3a249694b16b58818a6f49d3800926627ce0f87e5c0853ae868b4699cfdee5e -ae0c93d44780ef48ea537cf4cb8713fd49227f4b233bc074e339d754b5953e637a7289c6f965162701e4b64e4eaec26d -80953053397c4c0ba9b8e434707f183f9ced2a4c00d5c83b7dc204e247ad7febc1855daeb906c53abfdf3fe3caca30c4 -80f017e87b471b5216ebe25d807be6c027614572337f59f0b19d2d1f3125537478cb58e148f3f29b94985eac526cd92f -8a8e1c0d49801a8dd97e9e7c6955fc8b2c163a63bd6a4be90bb13e7809bb0dddc7a5025cc7d289a165d24048eac4e496 -8530e5b5c551a2e513d04e046672902c29e3bb3436b54869c6dea21bab872d84c4b90465de25dff58669c87c4c7d2292 -ae3589d389766b94428e9bde35e937ed11aac7ead3ce1b8efe4916c9bfff231d83b7e904fe203884825b41022988897a -ac02e629a900438350dd0df7134dfa33e3624169a5386ea7411177b40aa7a638e8d8aef8a528535efdbe1ca549911c0b -b1ac60b7270e789422c3871db0fa6c52946d709087b3b82e6eba0d54f478520b1dc366bb8b7f00ff4cf76e065c4146eb -a7465e1f8e57de1a087144d3c735fee2b8213fcbf2b9e987bb33c2d4f811de237bf007402e8d7f895563e88b864f7933 -8ab0007ba8984dee8695ec831d3c07524c5d253e04ec074f4d9f8bd36e076b7160eb150d33d15de5dd6e6fb94f709006 -9605bbe98dadd29504ce13078c1891eca955f08f366e681d8b5c691eadb74d6b1f2620220b823f90ef72eb4ab7098e16 -942a083d07c9cb7f415fedef01e86af4019b14ef72d8ab39fe6bd474f61ba444b9aac7776bea7e975724adb737e6337a -b9a49a8c4e210022d013b42363ac3609f90ea94b111af014f2c5754fbc2270f6846fa6a8deb81b1513bb8a5d442ea8dc -99cd62b177d5d7ce922e980cc891b4f0a5a8fa5b96dfc3204673fbef2e7fb2d7553bbacd7b2e6eca4efb5e9a86096e2e -94e30b65b3edd7472111566dde7fab0e39a17e1f462686050f7134c7d3897e977550faf00174748cbeaec6c9c928baa8 -a32fbcb29f3391d62092f2720e92b6ef4d687d8a3eae39395e0464669a64a38fe21a887f60bc9519d831b9efde27f0f4 -8f1492c4890d8f9deecb4adada35656e078754dcf40b81291e7ef9666d11ba3747a478f9420a17409d7d242cecd2808f -8942960b319ef65812d74cb1d08a492334db58d41e8437e83ddf32e387d9f3ad36834f59e6a71d1afb31263773c3ec49 -88d692f4976c99e763b027df9c2d95744d224724041dfbe35afc78b1f12626db60b9d0056b3673af3a1741eaf5f61b43 -9920cd37eab256108249a34d3f1cc487829cc5f16d1bce3a2328fe48b4de735ebde56c8b5cf4e532a4d68792387257c5 -87d34c9f5a913b806504a458c843eda9f00ff02ad982142543aa85551208cab36ebf8b3409f1c566a09a60001891a921 -a2ee8339c96f790b3cf86435860219322428b03ea7909784f750fe222bc99128d1da2670ad0b1f45e71a6856c7744e09 -84bd257f755de6e729cc3798777c8e688da0251a2c66d7ba2e0ce5470414db607f94572f5559f55648373ce70e0b560e -8d0e170714ddf5dde98b670846307ab7346d623f7e504874bfd19fbf2a96c85e91351ba198d09caa63489552b708fbc8 -9484cc95d64f5a913ed15d380c2301a74da3d489b8689f92c03c6109a99f7431feb8a07d9f39905dcef25a8e04bcec9b -b14685f67dd781f8ef3f20b4370e8a77fef558aa212982f1014f14b1bdd8b375c8a782d1b8c79efc31b41eec5aa10731 -b22fb1541aa7d2b792aa25d335d66e364193fdbf51b24a90677191cae443f0ce40a52faf5983d2cb5f91f0b62a5f20e1 -b06fa9489123ab7209d85e8c34d7122eb0c35c88ee6c4c5e8ae03a5f1ae7c497c859b0d62e0e91f5e549952330aa95a4 -b5cd71617ff848178650e6f54836d83947714d2e074d8954cfb361d9a01e578e8537d4a42eb345031e3566c294813f73 -848d39ea2975d5de89125a5cbe421496d32414032c1e2fbc96af33501d3062745b94e27dfe1798acaf9626eabff66c79 -ad35955efd5a7b6d06b15d8738c32067ffa7dd21cf24afc8ea4772e11b79b657af706ce58a7adcc3947e026768d9cdaf -aff6d7c4861ff06da7cb9252e3bd447309ad553b2f529200df304953f76b712ac8b24925cf4d80a80b1adaa2396f259a -b4b88d35e03b7404fc14880b029c188feecb4d712057f7ba9dedb77a25d4023e5a2eb29c408fde2c0329718bdaf1ff63 -88e96720e2f7c63236cca923e017ca665b867ba363bc72e653830caf585d802fad485199055b5dba94a4af2c3130a6f6 -982675dc0299aeedba4b122b9b5f523ca06d54dc35da0f21b24f7c56c07f4280265fb64cec2f130993521272c3470504 -95c77d418490e7e28293169cf7a491a7dcc138362f444c65b75d245c1b986d67c9e979a43c6bd8634dae3052df975124 -8fd6c4dff54fb2edc0bdd44ccd1f18238c145859ccd40fbfbc1cf485264445b9d55ffd4089c31a9c7a0543cc411a0398 -b153eb30af9807b5fe05d99735c97471d369c8a1af06b2e2f0b903b991eb787ab5a88c6e406e86225582acf8186ad5ef -826b55de54496751b0134583b35c0c2049b38de82821177e893feeeeb76ceeb747c7a18312cb79a6fc52f2c18f62f33e -91650d7205b232c495f1386bea0c36e136a22b645ffd4f5207f5870b9ce329c44524781c983adf2769f4c05b28a8f385 -b8d51a39162ebb38625e341caacc030913f7971f178b3eee62dc96f979495a94763ea52152198919c6dd4733bc234f64 -a1fbd3673f2ae18a61e402fe3129b7506d9142f2baca78f461579a99183c596b17d65821f00d797519e9d3c44884d8a6 -b7c5f5407263398cf0ed3f0cf3e6fcebdd05c4b8fd4656a152cedcdbf9204315f265fd8a34a2206131585fad978a0d6c -94fa71804e90f0e530a3f2853164bc90929af242e8703671aa33d2baad57928f5336e67c9efdcbd92c5e32a220b4df07 -b75dcea5ad5e3ed9d49062713c158ebc244c2e4455e7a930239998b16836b737dd632a00664fded275abe4f40a286952 -a02f7b37fc30874898618bfcc5b8ff8d85ef19f455f2120c36f4014549d68a60a0473ddfd294530dfd47f87fbd5e992d -8b48e1626917b8ba70c945fe0d92d65cab0609f0a1371fd6614d262d49fe037f96991c697904d02031ec47aab4b32f48 -b368f02c21d4af59c4d11027e583ca03ef727f2b2b7918ef623f529ceac76753a05a4ce724ce2e018da6ecc5c1c1261b -a95cba06eeae3b846fc19a36d840cbcf8036c6b0dc8c2a090afcf3434aaf5f51ef5d14b1e9189b1d8f6e4961bf39bbf8 -b32ca4dfbeb1d3114163152361754e97d3300e0647d255c34ec3025d867ed99e36d67ebafe8255b8c29be41864c08edc -8e4eddefa27d4fe581f331314d203a6a0417c481085134d8376898f9260f133e2bf48576528d62adf29953ad303e63a7 -92b7d5505833f00d5901ae16c87af028de6921c2d1752a4d08a594eb15446756ea905b0036ae6ffe6b8374e85eb49348 -b50e9018d3c4e05ba9b28b74b6634043f622d06aa8123da7cd0bc482b3131912149214d51bdfd887484422e143c3c1c0 -ab980a2f5317dfcb92baa4e2b3eb64a9ac2a755da6c11094d57e781ae5cf43e351824f1dd3abb4c6df75065b3784210b -aaabb009dfcb0bae65a0aee26ed74872c226965c52a6ed0998209e020a9ee806297dba4b15845cf61e1a514de5d125db -a1fe78f67000ebb6e90fe33e1a9dd5489be6e15fedb93b2a37a961932b77137fe85d46e89a132ecf7bcfb7aa95e16757 -85bc6e7d660180de2803d87b19ed719d3f195ea0a92baf9bfff6113c743f4237f51355b048549913e95be8ddf237864d -87a167968c4973105710e6d24ad550302ee47fe1f5079d0f9f9d49f829b9f5c1cd65d832d10fe63533e9ad1fa0ad20f5 -b2ad1a7b95b8a89d58e0b05c8b04ae6b21b571d035ae56dc935f673d2813418e21a271cccaf9d03f0d6fa311f512d28c -8268e555319992d5ac50cb457516bd80c69888d4afa5795fcc693d48a297034f51e79f877487b6f7219cfdd34f373e14 -b235411f1f6d89de3898642f9f110811e82b04ad7e960d1dd66ec7a9bf21de60e00cfabcd3004f3b5c4f89f5d9c7422a -b6963effcfe883f7ed782a3df3c40edd70f54ceca551859bcccb5d3e28fd2c1fcbdd7acc7af24a104687fd02b53c704d -862645c944e1e2909b941578cc5071afd7353fed1c2c99517e2de7573037704ef5d35accf6ec79b8269da27564209d50 -90f585eeb1a053e2f18c1280c9d6a561c0bc510b5f43cd68370ed6daac4b3749852b66c371397b6a7c1ece05ee5906c9 -876d9a3686feb79ce781e87ac3e3fbeef747b6ab031285e808c8a73f73f55b44507850dcaa745c0791d2cae8ad61d74e -a7ecc3b8c10de41a7bd9527228a0d3b695a651a5b5cb552a3664a887077d39ee60e649aecd68ed630da6288d9c3074ad -83529f1f2b4dc731ea05c1ee602fa2e4c3eebe2f963f3625959ba47657be30716d64e05e8b7e645a98bf71c237d9c189 -834ca6b14428c30a4bc8d5a795596820af6f3606f85bee9f3008f3fb94b3adffa968d21a29e2588d7a473d8b5d3a8b42 -b8d08cd8b73430984fd16e8db0525ae2b76253c92cccd7b3470add4d12d082eafb55a72bde04870924d0bdaf61f76c5d -96ef32df669690c2391f82136fc720231e4a185c90ba79eef7beaadedf7fbeb56ed264825564bdc7da01829b47f4aa88 -93d637b2f04d71891a80a1ee93fd9c9046d671bc4c15c4e597cfcc36f4ae85a7efc111359628965fd10d36c39129b160 -89f28dd3f7bc43749d0e3750c136385d4ffaf2c40354d3be38341416d755de7886d8108d83721b36f99feb3bccd73c88 -ac6392e274659f4c293e5cb19859828f101959c4c0939920a8dfed0e2df24a0cbf89a7aa983e947318c58791c893928e -83b2d4ce42c2fa0f672cd911365d1f1a3e19f1c38f32bedc82820ad665d83ae5fac4068e4eca6907bd116898966fed92 -b5e0144d6e59a9d178d4ee9f8c5dba18d22747fcdf8dc4d96d4596a6e048e384cd1e211065f34109c9ed6b96010d37e5 -b1a65e6b38c9e84b3937404d5b86c803c2dac2b369a97cbf532cfdd9478ee7972cf42677296ad23a094da748d910bc48 -849d7f012df85c4c881b4d5c5859ab3fb12407b3258799cfc2cb0a48ae07305923d7c984ff168b3e7166698368a0653d -84d9b7ee22bf4e779c5b1dd5f2d378ef74878899e9dbb475dfdcd30c2d13460f97f71c2e142c4442160b467a84f1c57d -964e497ef289fac7e67673a6cb0e6f0462cd27fc417479ecb5eb882e83be594977fb0c15a360418886aece1aaf9f4828 -ae1226222098a38ce71f88ab72de6ededb2497e30580e7ae63d4829dcc9c093bdd486102b7a7441cb06253cf0df93772 -a72865b66d79009b759022e53b9eedbd647ff4b1aab5d98b188100d01fc6b5d8c02b80eb6f53dc686f1fdda47d4722b8 -93aa8d7d8400bdfa736521133c8485c973d6d989ec0a81db503074fe46957a3999880fd9e4e7f44de92adf6ac0abe99b -a75e5ab84399962ada1f9ebcfc29f64405a1b17cd0a983950d0595b17f66386393d95a5aa4c6c878408984141625141c -91b1e5e75f4b55ec2e8f922897537082a1414eedc2bc92608376a626d8752d5d94f22f0e78ea1970eb0e7969874ad203 -83bf9c308424ef4711bfa2324d722f550d95f37d7f7b4de0487ccf952b89d7219ca94e7fa25bee60309efefd9a0e4716 -a42060476c425ff7979456d3c5484bc205fb1ef2d7149554a4d483d48e2a19119f708c263e902943bcf20a47e6c7d605 -8170c45ea126e6367aa5f4a44b27f7489a5dd50202cb7c69f27a2bdf86d22cf6b00613b0080d75fca22439eeaaaa9707 -8e5a82da70617697e42c6b829e1889b550c9d481408fe4cf8dc9d01daccabdec01f9e1b8c27dc84902a615d539bf9bc6 -80606c51401d0bf5f2700ebce694c807ab1f7d668920bdcccef2775e0939472419a8f404567bd4f9355095517eb4d628 -a40314565d60d0ddf8995673e8c643b1baa77a143b3d29433263730a6871032260abc1320e95af8287b90aa316133da0 -a87e07e84435f9e8a51ce155cd3096aa4b20d18e493c9dcbc0ac997ac180f3a255bf68ccd8195f2564d35ec60551a628 -84d2ab98416643c457bf7ddd9f1aa82967ecea189db08f3558f56803fe7001693ed67ec6ca8574c81ec1293b84a7c542 -937c3b955889ceae77f28054ce53d75f33cfe3a04f28e049cea8b8ade2a0440d5e2e8c4f377e6c1ae2115d68cc95fc16 -885a911f16845fe587b15ce7cd18cc2a84295bf609732340f74e0f5275b698cffed3e9aa1440e19e6940a7fa8f24c89c -ad90059a50c399996aaa0a10a8f637b7bab0dd5d9100301f0159a2c816596da55c30b2568d1717705fd2826b117a42d6 -828de9ff1e095c189da1f1ee18009afe14613ac696025add6f4e330488e02d5f1a90be69edd9a17bfb3355a0ca77b525 -b7aedb8394064a58dd802be6457555c0cf7b94805ed00cc66f38449773f4b1865feaee3a6f166eb51b2123b89d853a4d -b09c564ff37ccea34e90f2d50a40919a94c2e10d4fa58ffeaed656f88f9f4ae712d51c751b1b8f443dc6c9506d442301 -b24882d66b2ebb0271ebb939c72308d81f653940e70d6f1bcaae352f829134aff7f37522cc42de9e7fe6243db2c4806f -8e6f8dd906e0d4eb8d883f527e926ad1d8156b500c4cfa27214450c8112267c319900de2443c87bed1e4bb4466297dd5 -ae42f4578e8d79b6aa2dca422ada767e63553a5ee913ff09cb18918116905b68f365720a1a8c54c62cce4475ba5cdd47 -ade639bcd5017ea83ec84689874175ed9835c91f4ec858039948010a50c2b62abc46b9aee66a26bf9387ab78f968b73e -8d310a57aeb123cc895ee2fd37edc3e36ce12743f1a794ad0e1a46d0f5e4c9a68b3f128719ed003e010f717ec8949f43 -8606c086fcf3e2f92c1b483f7e2a4d034f08aef1a9d5db9e8a598718e544b82544268a0a54dfed65b4d0e6027a901d47 -8ccd95dd673d8cfdfa5554c61bcdbe6bb5b026403a320856fe51571e7c59504fe1c035f2ad87d67827339d84c0e1a0c6 -955a7cb4afcf70f2eb78756fc3a82e85ab4330eb89a87117294809beb197d1d474001e25306e8ad71daab6928abf6d64 -ae6b44ec6294736ea853ddeb18fc00cce0ac63b38170ff0416a7825cd9a0450e2f2b340d27a7f2e9c5ac479b4cb8a5fe -a88ec3f12b7020dd593c54376597b056e70c772c0ec62c24c5bfd258b02f772161b66e5dcd95c0c0fceb23433df9ff23 -b4a83933b4de552dba45eedf3711f32714e58ae41d4dab8a6114daeb06e90a5a5732c70384150d04124ac6936ca9804b -b8b7c4fa549b0fa1dc9c1f0af0750d6573f1648767751882d41f0dd7e430e3934590757e1c8b436ac35381bdde808117 -ab598b911234a98cfde07234cfc0d2fddfc5cb9ea760212aa3e175a787ce012965c8fcfdf52d30347f5f1b79cf4a0f54 -a9d354f9dfbd1976e5921dd80cbb56b2e15df53ce099ecb4368eff416998130d7830209282aaf1d4354129845f47eb80 -8c889afff546c721969e4d8aae6e6716ad7c2e9c1914dd650e30419ee77d630efb54dfffb4ec4ff487687b1864bf5667 -94ed2fa79116c7c8c554dc306b1617834dd3eab58baf8f0d085132c4688ca4a6bd38420281283678b38970a3f02b9a94 -944fdc8f0516d22f1672193d183833d3e3b043e26807fb2123729a0216c299785b1c4e24b5aa56e9bbe74fa54d43e22a -a48521454a3e0c10a13d8e810fad9d0522c68eea841821a8e0e57811362f7064a8f9c50f79c780a02df7df8c277feaef -8f3d26670ab55e1bd63144e785203373b2b13b76cac305f0363e48a6339fac3364caa3fceb245527161fc2fac9890912 -b4d6fe71001cb4141f6d8174dd7586d617cfccb54471e1fbce30debc2b1dead62cab29565abb140b682811c6231acb03 -91dc8afc4934fcc53ef851462a055cc1c3c87d7d767e128806891738427606d2fbfa832664d2a7f95f8ffe2cf0c44dc6 -b297eb432c74071764272c1b1663547ba753e66bf026643bfc0e42a9c5cdfb05a88083ad67d6ddfe6ab290678c607b29 -b343d1df85be154faeb5b21741a5ac454ca93f70a0b83a98f5901d1be173a1b2969d43e646363c5d4975924e1912599e -b2d74a66e4dfc41128aee6a3f0ff1e5137a953ed7a2a0ab5a08d7ea75642f12bd150b965c8f786ad0caf55ef7c26be4f -a54141faa8dd9a567c3cd507e4fc9057535ffe352fa1e8a311538fe17e4a72df073fbf9371523e5390303db02321650e -8e229a58f1acc641202d2a7c7e120210b9924e048603b9f785a9787ad4688294140ef3f4508c8c332d2dedafff2485be -9523554c11d39b56e6a38b3b0fadb7a9a32a73c55e455efdcfda923aff1e9f457d1b7cbc859b5ecbb03094eae8b87d38 -a199ffdff1812aaea10cd21a02b3e7bf3d8e80e501aa20bb2105b5f4cb3d37265abcda4fd4c298d6c555e43fa34517f8 -97f1285229b07f6f9acd84559afef5daad4320de633c9898b8068c6cb3b19b4468b4445607559ddf719f97d2410e2872 -a1dfff82908c90fc38ec7108c484735f104e6ce7f06097e1e80f6545702b6a0bc2a2706203cd85162edb7e9294fdedba -b12a706311c617d6c19e964e296072afce520c2711086b827cff43a18e26577e103434c0086d9d880c709df53947b48c -88503a6f48cef2f5cd3efa96a5aacc85dc3712a3b9abbb720a2cff582a6ea3c2afc49288b6832c8599f894950843ac11 -83ed63e38dfbe062fe8c7e6bc2eeb5a116f1cc505c6b038990038de6051281f9062e761ea882906ccff69c9c5b8a4a25 -911090d5d0231dde1189408dca939daddcb69a812ac408d1326060f0220781bcc131c9229e6015540f529d9fb33d9b0a -8a8352f1d9e5c7e80276e4448f997d420d5a7e0e2d5be58ae4106f47f867d1caa478b2e714d9c3263e93e5cc4c7be08b -9362f1ea9995f9b3850ebb7c8d5bf95927ab5ea25ee00e85d7456b3bf54459798b1fffde049d445c0d0587b0ab0a1694 -8859502b391273f4a00b6c0e87e5cdae676b7baf6c402f12b3360db6a5dfb4931ece4da0e1e4d98c7a71c3d01a183a9b -a9a5edf474120f9bbec9485d8b1e6f83be68b10de3d765219b0bf3e5d2840e478f1fb2bf806d78a8b8ad22ec50cf7555 -82c75daf983b06e49f0d75a042dfaae8cc92af050293d9059d6e8b01ca3ab2597e7adfc1159ed805513488944e739fa5 -a5cf240f04a9bfa65b811702c923d209e01f9535e217fa55ae3e0d1eb3257d6749e5587e727091e860609d1df29a1305 -95608ab8ade1c9fb814bad78d9cc99a36ad3e9562d5319830e4611ceea508ef76be04639294be9062f938667e33bce6e -8e44181f35c38b02133473de15560ae6588ac744cfdaf5cdfc34f30ca8e5ff6c85eb67dddc1c7d764f96ed7717c89f06 -8007b6ddece0646b7e9b694931a6a59e65a5660c723ebdffb036cf3eb4564177725b1e858ed8bc8561220e9352f23166 -a2d9d10fa3879de69c2a5325f31d36e26a7fb789dc3058ee12e6ccdda3394b8b33f6287ba1699fce7989d81f51390465 -81993d0806f877ca59d7ffa97bd9b90c4ebf16455ea44b9fe894323c8de036c5cc64eacf3f53b51461f18fa701a5860d -a20030f457874d903b2940ec32fa482410efecb8a20e93f7406fc55ab444e6c93fa46561786e40e9bf1e3c7d5d130bc8 -80c72d4985346ac71a231e7bbbb3e4a91bf50142af0927e8eb86069303eb4ce7fca1aa5b919d5efc82f2f09b41949acb -91b857d2f47f1408494940281127ba4b9ac93525788e700889aa43402eedea002e70eded017f5f5263741ed3ee53a36c -97445d007f08e285ea7f4d25e34890e955dac97448f87d8baa408e826763c06cbd58dd26416ba038d6c28f55bcea2d3a -a409c89526c2886f6a6439e2cd477351fc7f886d1a48acc221d628e11895a4eedd426112a368a0dbd02440cd577880a8 -a2c6adc7866535f6ffc29e00be4a20fa301357e1b86dff6df5f8b395ad9fb1cdc981ff3f101a1d66672b9b22bd94ec0f -8887fc53ffc45e4335778325463b3242190f65ae5d086c294a1dd587f62dd0d6dc57ca0c784bf1acaa5bbba996af201c -9731d3261a7a0e8c7d2b11886cd7c0b6bb1f5c57816944cc146caa518565034cea250eeee44ddffaeb6e818c6b519f4d -afe91c706efb9ee9e9c871e46abde63573baa8b2ea2b61e426cd70d25de3cc8b46d94c142749094287a71f4dfadd3507 -ae7bdf6ecc4fc0d8d8a7fa7159aae063d035f96ca5a06b6438b6562a4eee2b48d9024dbe0a54cfd075eac39b7a517f2b -a382e5205bfa21a6259f42e9ebc11406b5da2aad47f7a722212fdd6fef39117dd158a9991ff95e82efa0826625168a1c -862760c80bf44c2d41c2a9a15c887889eaeea32acc894f92167fb6f72593377c228499f445ccb59794415597f038ac9e -b4e96595a91a611c4563d09f29a136a4c04f07be74dd71a6bbabc836617ecb95494e48971a8229f980b2189fd108d2e5 -b5e7200357317c36244c2e902de660d3c86774f7da348aca126e2fc2e2ba765fa0facd29eebcb3db3d306260e91a6739 -a64c7133156afee0613701189c37c1362e2b4414f7e99408e66370680c554de67832c30c211c2c678dab5cfcdcecb3f7 -88f4cb67b1db497a91a0823ee3541378133eb98777842d73e43ab99efe8aa52fa02dfb611c1691be23684618394988d6 -89a9382a147d7387d0ff9516ee0c75cd1f8ee23333f4a2c9693d1a8cbe03680bc5b10c43c238c2190db746cac409bf39 -ad510bcc067373d40b05a830bf96fac5487de1ad5b708a13f62484c09b00fba6c5b00b981004e5ab3f28e55c9a5bce26 -8384156d7117675547279ad40dc6bf81e8f9a57b2d8cfebeea6b9cd1d8534dc0cf704068bc3ba0815010cd8731d93932 -a818fb76e53165b2f86c7f2317d64cf5e45f48405a34560983cd88bfbd48369e258ce2952233a8ce09c464e07afcade6 -ab19a4ed90527e30796064634b66cdc023bc5966e2c282468f5abef7879fc52986d5bb873a796b077d10e7b374b60309 -a17dafe2484d633fe295f8533662631b0bb93cdb4e7cd6115271f20336f602f7f8b073983cd23115093c7f9891c4eef5 -804acbc149d0334c0b505a8b04f99c455a01592a12f64d1ec3b82b2f053ccc4107e47f418f813d6f400940c7c8700a4a -965e097a825d8511d095b247554ec736bcb3701ead3ba785bd425cbabd56f4b989764e0965a437fa63e7e16efd991fc0 -b6701675ca27d7a4084f06f89bd61a250b4a292ee0521b2a857c88c32b75f2a70b97f98abce563a25d57555b631844e0 -abbdf65fcbdf7d6551ccd8d6e5edc556f1ecd275ccd87ee2bda8ea577c74615f725aa66e0911e76661a77f5278e0c2b9 -ab715ae372c900239a0758a3524e42063afc605b8fb72f884dc82ab9b0ff16715f3fb2fd06f20f15f9e454f73a34e668 -b45f41ea1d25a90af80a8a67c45dea881775fed000538a15edc72e64c7aa435a5e4375dcdedc5c652397c02b0bc61b16 -86f7be9252f8ed9078e642c31a70a09639899f7ffcd7faaf1a039fec8f37e1fa318fba0ed1097f54fc55d79900265478 -a30e5ed4277dd94007d58d5a3dc2f8d3e729d14d33a83d23c44ddfc31c6eac3c6fe5eb13b5b4be81b6230cfd13517163 -87e723d916f5fcda13fab337af80354e8efe6b1c09ae5a8ceeb52df45bfca618eb4bec95fefef3404671fb21e80bf9db -a521b8a04dc3abd3e9e0454b9a395b3638e5394dc2d60e97fda61b0a1880d1d73a64a4633f3d7acbd379bde113240d03 -851686c79c5403d5f05fbaac4959fcbfdfb51151bec55e10481b3c16e3be019e449907ae782ca154f76a805543d5755d -8ec1929e746b6c62b0c3fdd8f4e255e5c707e6e0d8d57ff9e409ae2dd6e76fdb50af923749992cf92d1b5f2f770bafbc -9175f7b6820d47205c9e44f8c684833e1e81da46c1fdf918a4dcafbc3231173f68370d442a20e45f8902bcab76a4e259 -b4f66c698115333b5ac00c9fe09aa9e1e9c943fbb4cce09c7d8a6ed4f030e5d97b48e944fd6d3e69ac70f1ae49d35332 -b958878b875eead61a4416a4597b1c567ddbb1eaaa971033f4a656f01a277822c1f4ea3972045156c2a5a28d159f5ddf -8188de8ad5258024d0280137a40909d24748137ac7c045dddd2bc794eac8edd5850b9d38f568fa8174b2c0593bb57e96 -91152c7bafce7a0358152221081bc065796fa4736bfc7d78076a0a6845287cde2ee2a2c9b96f500297c0a00410634888 -a5328ab939a2d3bd4c21e5f3894c02986b6590ad551c7734be3f4e70380eb7bc19629e9031b886ce3b4074ee4edee63a -97c4d49db40e266bcedaacb55edca4e1ebf50294679b271f3a2332c841705089b5ba96ef2064040fa56c36bb1375a8d9 -85cf0514f340f9d865b32415710d7451b9d50342dbf2c99a91a502a9691c24cd3403cb20d84809101cd534408ddf74e8 -950c3d167f59f03f803dcba3f34fe841d40adc31e5be7eefff2103d84e77a7cbe4f14bd9c3dfa51cde71feb3468a9c00 -96a69624e29c0fde3b92caf75a63ac0f3921e483f52e398652f27a1ec4e3cc3202f17af1f66224731bc736a25638d3e4 -aeac4170cf4b967227f66212f25edc76157eb4fb44c84190b520ecc2946470c37da505790e225fd1b0682bef7fc12657 -a94146a04e3662c50c2580ae1dba969cbb3fb0f43a038729c9e8be6ed45860b2c7de74f248dfa50ccdbe2ecaf3f2b201 -917b8e2880e85b8db723631c539992ec42536146e7091d4a3f87d37f051b5da934d84393523814f19962c78e6cb12ef8 -931f140ff8f7de79e399f5cd8503558d566b5c2ab41671724dd38aed08dd378210f01ac8fa9911f3047993dbc10cf8c4 -859eb9b560bc36273694f8ae1a70d25e7f206013597c4855a11328162ba1254bb736f1ae41240c8ec8dea8db035e08f2 -b4ad2cb2c3a3e6ab1e174f2dbfb1787a8544f3c9109215aa6d33265ef269455e3cde9858738b4fe04711a9cf9050e7d4 -8a3b342b87b19c0cdb866afff60317e722013c02dee458ba71e7123edc8b5a9f308c533b9074c7dd0d684948467502d1 -89185ac5cc5ea8f10a1f2a3eb968bb5867376d3cff98ef7560b9a0060206c4046ff7001be10b9e4d7ad0836178eba7e4 -845f48301f25868f6d0f55b678eab1f8458e3321137dba02b4cfbb782cbc09f736a7585bf62f485e06a4e205b54a10b7 -931a6c523d4a66b51efadb7eefadba15bf639d52d1df5026d81fd1734e7f8d5b51b3f815f4370b618747e3e8eb19699c -8eb3a64fa83dcd8dd2258942aea3f11e9cf8207f2fdd7617507c6dae5ea603f9c89f19d1a75d56eaa74305a1284ce047 -912a5050ed6058221d780235fb0233207c546236316176a104a9761bc332323cf03786dbac196d80a9084790506e0a88 -945fe10ec8dc5e51aa6f8ba7dace6f489449810f664484e572bfe30c2fe6b64229f3c8801e2eb1a9cb92ff3c4428cdf7 -b62383bf99c7822efd659e3ef667efee67956c5150aea57e412cbd6cd470807dfaad65c857fada374c82fcfca2516ad1 -a727a31c45b2970d08a37e169ea578c21484dde15cb11f9c94eaaf3736652619ce9d3a44e7431d50b0e75b658ebbc1da -97bf54ea9b84b82e4616027bd903ef6152439f1c6a8e1bae6db1d10fdf016af2cac10ff539845833dfd1ddad1403aa8c -a08cf36437e010e59b2057aedb7192e04b16f1cc66382cdef3490b7ad1544ae51f03e87cba0fe43a275841c247a2a0cf -acafab9fa28c1a607df2246490b630ddda1ecf0885ad24c2ecb2c2c1b7b9c7de8066714bf5b9b25f61981d08576789ec -851f0375128d2782586223467d0a595f4c5baa79616622a32f7d6ce1f08af06f8a109bd6527f88d93367dba17be661e8 -a2f1187c2a7cbf776653ff834ed703dd32e68eaf36f0700709be929f4c0ce5fa1d9930d1e3ea2aa01c7a16239e66cb33 -b3721f4a5d24ca112f020cb3f849543bf0e7f84b470fb00126ae80aaaa6f2c208d8359cd82ad9fbafd3ef2ac70656fb2 -98773ac3ce9528c73cfd8e7b95976ce597f67e146357642ac4fb6cb35046f3f39cf6c4a7b5af5c7740dda358aa0d2d08 -92c883a5d820541692af75be1b25dd4a50a4b91f39f367a551a7d5ad6065a26b60d68221a01e4950559717b559c2626a -b82e46dd25fd1234dad26fbcd8bb5177d7b87d79d362ffb9c2f6a5c16eb2ff324d135996fcd6274d919634597869d772 -82a53ed356ced5e94d77ee2a7f6e63f2ad8240aff2d17c5012cf5d1f18512c88c24793339b565dfbb659bd7c48dcbcd2 -84d20c7859b35a1cae1ff2b486d50822f9e6858b6a1f089ce4c598970e63e7c0f7dfbcb3337845e897a9dedf9d449dd3 -974892e5cf5ee809e9353d00e9cd5253d04826a8989d30cf488528c5dcdcad7650e23b4d228c3eb81f6647d2035a9e02 -b2327854910dbf3d97fe668da5fc507e179c4bc941f39bdd62e8b6035f004449c467240f656417e501f32dee109f0365 -88888f73475613d45d0b441276b1dd55835b69adfb27e26c4186936dae047b85478cca56be8dc06107b89a28f3bbb707 -836ba22e40511feff81a5dace3df54e2c822b55e66874dd1a73929994ec29909ffc2a8e39bfc2d16e316b621eb4a5ec6 -a754cedcccf4165a8d998f326f3f37d2989f92ca36d9da066a153c4aab5a62bb0011896bcbf90f14c18e00488d4123bd -86c26fa9584314292c4b7d6fe315f65dadd0f811c699e6e45c95a7a4ea4886c57dc5417b67edd78e597d037c7689568e -b205589648aa49ef56637712490e6867aa3b85b2b31e91437a249fb51bdb31401bff57b865c9e27293b30014b4604246 -afab0843ede582e5a1898ee266235066b94ea378884eaf34919ceaacc0e2738e1074b6ed41e0a1dd9711563e24f0215d -996ed65fbcab7611eada5bd0fd592d3e44705098b8b1dfba6dcdbdcfa1382fe893fa55270a0df0be0e1938bd71ab997c -881bc448a5ef8c3756b67ecb1a378a5792525d0a5adb26cc22a36c5df69e14925f67c9cb747a2f7e5f86ba1435509d7c -b219303c02c9015c6a9a737b35fb38578ab6b85194950a0695f7d521206e1e12956cd010d4d6c3bc3fafd6415845d5d1 -91748829bbd005d2ec37fc36fee97adaccb015208b74d2f89faa2e4295679f7685298f6a94b42d93c75ca9d256487427 -a41d6fd33b9864ebc404d10a07b82ba9d733e904875f75526d9a1f1c1c08b27160dcdb9023c5d99b8ff8a3461d57281f -b68978d39c97d34f2b2fea61174e05e05e6e49cde587e818b584201cf59b7096cf1807b68f315119c6db8d6110b28a9f -b64e66cec798022d64ce52477475d27ea7340817fe7f570617f58c3a9c74071d7ea6b54743d4f520b62aecad9a3a6620 -87b2b9e1c1786b7824f239a857024780a1457e51c64599b858118885833fb87a17d408bc09dcc0607d15ec1e53683a74 -9814799bac07dab4f0c934cc3c051676ca13abd49cf8d4739864e5bb9f2a8474897695113f49239f28832a8658332846 -806931a1526a843a9c2045943d616a8102b02b1f219535a1f1fbda659a1244f1bfead52ca7f1851ff8a97169b91c9ec0 -b8678249595a9641c6404c35f89745b93d8e7b34d9d44da933a1b2f1606972624c5108f1c04eb42e454d0509f441ed9e -81426714851741045a4332eb32b6dfe6422a4a2e75b094fb7c3f37da85648c47ee8af1e54ba26f4e1b57ebe32d0e8392 -b7a1875ea3f119fe0429fd9068548f65cf2869f8519dbbce0b143e66127cb618c81d7578e8391d676b2f3963e9d87f43 -872220a803ea0c6294cdc55aceea42cfacfd7a482982bcb90c0361c351a900c46736a890609cd78f02fb5c8cc21fa04b -974f0380197b68205ff4bb2c9efe5626add52c0ad9441d7b83e6e59ddb2ed93ad4e9bbdbf33b3e0a206ed97e114ea0f2 -a840f2d9a74fca343aedb32ac970a30cbb38991f010d015dc76eb38c5bb0bfe97dd8951de925a692057262e28f2b4e9d -b0913c3ce61f12f9fdc4be3366ed514c3efc438f82fc58c4de60fe76098fbc033a580ec6e4531b9799611c89a8063a66 -a0180d533eee93b070dac618be1496f653a9a0e4e3455b58752bf1703ec68d0be33ec0b786f9431ef4208574b0ad316e -a4a6b871bc95d3aa57bed90e14a0a1dda6e7b92b7ae50e364593ce6773fbf736672b1f4c44e383af4c3cc33e017a545a -a3f44cf19fe52bacc4f911cab435a9accbe137bdbe05d34bdd8951531eb20b41d17e3540e8d81e6b3eea92c744562ee5 -ae6b6d0ff3b30ff0b7f9984ef741cba27ffb70d558de78b897199d586cf60622ec2d8a9d841712fe719cf0f97628842c -87abf72f98c81d6d3a57ab1e224fe4b502ab0d8090d8abc71791271550b721c220d4e2e7da3be94a20c0e63d98e39a50 -b2f73ebdfe7133af57353052f4599776e16862905e64d97e1020c4bb84132e476d1ab79a9fb71611410f3f9d56c95433 -ae1a928253af2b210d31e1b64c765fcbd20a96b8d53823a6b9b6e7fc62249abf4a66c6a6aedb0b687e7384af9a845e0d -99c54398627833ca1435718154de171a47c709e4d5c58589fdabe62e72f2a7a11ae561bc31d7cbe92df4aff23e08cd0e -8a1310bbf1a31fae18189479f470977d324dec6518a5d374ab2ffcc8f64412fb765df57d2ddf69b9a6efaeb2b4c723b8 -898312c6c0d3d3438229b19a8a233eca8f62f680c2897f4dd9bbcacde32c5996d56ac0e63e3e9360158761185491ce93 -81b3f965815b97bc6988d945496a51e4a4d8582679c22d138f3d3bd467ed1f59545da2d66e7b4c2e0373628ae2682686 -b9aca91c6e6f4199beb6976b28e0e35e36e8752618468d436b1cf00d8d23538d0747920e5b2c31f71e34dfe4d5c86a0d -b908f4aa18293295b8cacfda8f3ea731bc791074902c554764c603ab9a1de1bbc72654fd826bffc632d95ce9f79c27d9 -a7316ae1baf4b1196961d53be7fe36535499287aba9bc5f3bed4323039b4121b65bb0bd15a14c1b9cd8b65ede3566da2 -815e39208f205c5fac25ac9988c14a62ab01657c7737a24472d17b0e765644bc2cbb7ff1e8ea169b8b0b17b6996c4704 -89a451d2b740cdaa83ccaa9efb4d0ff5822140783979a4fee89eda68329a08c018a75d58bd9325bdc648b0d08340b944 -8cd08f768438c76bae6bee1809dd7be38ec42e49eb6a4d6862db7698f338bf6b4b409088e4f3d1c5bee430295b12a71f -a4bd8c312103a4bfeb25b0cfffec7a1c15e6e6513b35af685286333c1dce818ffeb52826f2f5bada6b67d109c4ab709e -93afbef5382d89fa539ca527f3e9b4a8e27ab69fd5d5023962cc6d8932b33cb4dfc5f14343e1a3749bfd5e100c9924e5 -8d8e69d046992ec9ff14f21840809166cae8e0e9e7c8f14fb29daf163b05abe6611daa4010960e1141c5ab24373fb58e -96f8e72e96ba673c9265e9cc312f6b9c3b931745fc62d2444d59404bb08e5fb02ddb60715181feb9971cbd954526a616 -8d444c2b8e4d0baadb79e3147a2ee20f1bfe30d72eb9a02f15d632185fb8f4e8c3116066f7de1ebfe38577aaccacb927 -971410c0b10e3698f4f64148b3d2148fc6a4a22217fcf4253583530a9d6fbec77e2cf6f7bb5e819120a29c44653de3fc -99e7e1857bd5ee57007b7b99494b1f1c6bf1b0abd70c054770427d59a3c48eda71b7de7a0d7fcf6084a454469a439b41 -8c8a4cd864894f7a870f35b242b01d17133cb5dfdf2e8007cd5f1753decc0d1fd41be04e1e724df89f1d727e760fdb15 -890a24328bdeaaadf901b120497d1efa17d798f6f4406661e46ecdc64951f9d123d724ab1b2b49e0e9a10d532dd6f06c -a7cbe1f42981c9518608569a133b0b449e9d67c742d62f0d3358112c97e65ee3f08ec0ff4894ce538b64e134d168e5c8 -87c976dea77b3b750c3a50847f25b851af95afbaad635f9bb9f7a6ba8f0c4faeb099dd777cf7eac41072a526474cb594 -9882aa5e9bcc4ea2dd3de4bb5a0878a672bea924b50c58ae077563b6df0268910a60e969d3da1694ae7394ad0d9acd3d -90d35ce677327c461fb5dcb032202e851af1d205e9d21a34ed2b95635f13f8fb8dfa470ea202ccfa4b08140d0cf1d636 -b3b4cbb521cce2b681e45e30a4d22078267e97ccdbdc611b2c9719705650dd87e0ca6e80cf2e174f8f8160be94232c36 -95892b00478e6b27ed09efe23a2092c08e691b4120336109d51e24efbf8aba31d59abf3cf55c0cdab1c210670b9743ba -8643018957fb8ef752673ad73102d0b928796c6496e22f47b6454c9ed5df784306f4908641ae23695db46ebfcfb0b62b -b166ce57669bf0543019ecf832d85164c551c3a3a66c05b17874bccd5d0ae87245925d6f8edc62ac13dbd5db265823a2 -89fb4800ce4b6c5900d58f1a216ad77a170ea186f3aa0e355840aeedcf374e92a15ae442800c9d60334544be020b17a4 -8c65e586215a97bf11ffc591bce5147b4e20750e82486cc868070c7736c3de697debc1f335674aef24b7afdd41922d93 -90f68ce0c97d2661d3df1040ce9c4fa106661a719e97c7b2d7c96f0a958930c57d6b78d823a2d41910261ae1f10e7b0e -adda85e1287371ccbe752aa2a3c1d5285595027ba4a47b67baf7b105a22fb8548fa2b5b3eb93ca6850ecc3995f76d3dd -b26535d218f48d6c846828f028c5b733594ce01186e22e412dd4f4a45b3d87d2ac1bfe5d54c987e4e8aaddeb86366d7d -a081bd86962ea3d4fd13df6481f3aeaabdd7ceae66f7bbb913e601131f95d016cf147d045253d28457a28b56f15643c8 -b3d852cef4c8b4c7a694edbf6f0e103f3ae7f046a45945c77a1a85ec8dad3423636a89058fafc6628aabff4dbb95c2ba -b424ffc94e06e6addc90a6324e0482814229b5902e2a266d0c2d716e40651b952bc9f00d7dad9b6050377a70a72c7f24 -b2cafd908cae0ca22eaa2d9a96175744897a20eb7b0a6d43b0098cb1c69e3cb55373888201e4ed32816655eb7d8a3dd7 -b61177ecf1ae9d7e7852d98cbf6080d9f1e33c90f2436720b4ea4690437e8c7850c3754768fc1312cb4e838d855c5ccc -81b486644e1ae22cf0ba3a37e1df34dc186c82a99ab35ad6f475c37babdea574ddfbe5811d4aa020581292a793d66bd2 -97ae848a823ea7a99f91834e537fb47208f616c08fe32c8f8fe06bd35c9b638698c513265d0b4de9e572a2f9692b98e2 -81b8fef4ea5d399c65e78f40e47c559ada86d890777c549ce362e7ab81b3bfb00d5ff4ae4ee30fd7bda7ee90d28f85d8 -aada6912cc748923ea40bf01922c06c84bc81b2ab0bb3664a0579b646f03d47ce88de733ac7f2cb9be4a8200584cdb71 -89b48b9c79332f8f58eac9100ada5bb7decdc4b1555c5d383e2c1ce447efb0ebdff9c50bb52bc3042107f33a61ab2520 -a32ecca8b870b2b6e9d10b5c1d8f925b3d629d271febad65abed316262bb283c60cade0e91047fbd0fac53ac6db372b9 -b829cd1f13409e3573a8e109c9541b0a9546e98b6c879a11152b5564477ada4d8cb4b3079040e05a5cb63d75ef11eaab -91f3b100baa19e960b170fe9e03b799faac5b9c6f305c56115940bf81f6e64dcb9cda77e8de70ed73a21c0e8a74acc58 -b25b5e872c84065aee04822bbcb4f3bdff57fbd7cea314c383765cc387786c17de3d5bb3de3ae3314bdede14542bfac6 -a89bea9eca1f5a17a3efccfa4987d8e5366b0dba70ef1fef43aaea83c528428d1498c8b056ac27f16e8946ee93f7028e -818a1f7b0b8b06ea0514d6b4a0296da4f69cb18ac8e48c5579e6ba2880b06215fcbe81672566b8b94fcc3c0cadecb191 -98dd6e6b4b4d63d9aa7464a2be08ae8babac4da7716a3f109340bc9187d59c6ca0c88e6877a67c65096f64a3ced22a4b -a2069c5bac4f6590042aefb37570cc20908b0df9d0130180f565ed8a53b4ea476a274de993561fb4d009f529fe7aa1cd -860b7ec2410f033a7b0c5ca08f88a0ad29f951a5ebd5383408a84367e92f1bd33bee3b87adef2466b7e33b47daabf30e -a408855a8414102c3cb49f47dda104edf0887e414723da59b6b6537ada7433529f6a4d1a4ad4fe311c279213cdd59356 -8ca0d81dcb43b89a4c6742747d29598ede83a185a8301d78c6e7f1c02c938441360a1ab62a5e571e3eb16fe17131cbc0 -af7875a495cb4201cdb26e23b7c76492f47f8dd4c81251de2397d73d4c8d5f419cdbad69ba88ef0dc3552e460dbcd22e -80e901e433dca34f3d386f39b975e97f7fc16c7f692808221fb2ee60c1aaa8db079cc48c7d72fd548aaf8dde8d0b8f05 -b6062319e13926416e57a0ffc65668bfa667e708a4e3f5cb26d8a6a32072f5b790d628052d5946c5068dd17cf4a81df8 -90094b569e8975f8799863798912dbf89b12d2c2d62b3e5fac7efc245436fcd33af23b8c509ae28c6591d3f020966e06 -a504f72d3d06a0c9b188a1035c7c6d80047451c378b6c5b2ffa1f8cecdb64871cb6440afb296974c0a528e5e563061a1 -959061c4924e133a419e76e000e7c62204093576ff733ce0b8ae656ec6045ef94c5a1f3c934fb76fa9188c5eb397a548 -a8b9d0b58de38cb86cb88fb039a7c4c0c79e9f07f03954af29013baa18fc2633883f8f9ca847209c61a8da378f9075d3 -b16d8341da4ff003ed6d1bbdb3be4e35654a77277341fe604b4c4e4a1cb95e61362094fb3d20ab8482ea14661c8b9852 -8ea4ca202e3aed58081a208a74b912d1a17f7b99a9aa836cfaa689a4a6aa9d9fbfe48425cad53b972000f23940db4c5c -96a372f55e9a25652db144ec077f17acc1be6aa8b4891e408f1909100cd62644a1c0296a3ddc38cd63ef46bef4e08462 -87df40018ab3a47c3782e053dbd020f199fda791f3109253334a71be4159f893a197a494de8f94d6f09efa5811a99977 -aff82d2ea6b3ad28d0ca1999a4b390641d727689dc2df6829a53e57d4f6418196f63a18495caf19d31fc23fdff26d5e2 -9091053c4a18a22d13ad309313b6d2133a96df10fe167f96ec367f9b8c789ecca7667f47d486fc5ba8531323b9f035ac -a4842090515a1faccc3d8cadbb234b7024254eba5fdfcef0d15265c7cec9dc8727c496ad4e46565d1f08504c77e511d2 -b1d8a37b1a97883d5804d0d2adaa8dbf0c2d334ef4b5095170b19613fb05e9c648484093d0c70d545cf9b043b449c707 -b1ea40f3dd1c3d437072f8adf02c32024f32488dd59389d1c3dfe78aca3df0bab7767f6ded5943cc10f50555da6092f5 -ad219c6a8149f10391452892b65a3268743baa7402736f810a35d56cdfed83d2172b03f15c205f0dc5446baf855907a5 -afe44c3e1373df9fc53a440807fa6af8ebc53f705e8ee44a162891684970b04fb55d60bc2595626b020532cb455ee868 -859ae154b017eae9be9da5c02d151de747cc23094d8f96d5db7d397e529b12fb55666f55e846e2bbe5e6f5b59c9d8b05 -8aa01354697de23e890fe54869cd3ec371f1be32064616ca3a556d3019541ba8e00d683f1396ca08e48988f7f7df5de4 -b8f682487460b9d825302c40a7d6dd0353ff43bf24cd8807cdfa46c043e3f5a7db182b27a8350b28e91888802a015af4 -b6d4d6c3ac40f8976b50be271cf64539eb66dc5d5b7cec06804dfe486d1e386037b01271cf81ef96dba5ea98a35a4b43 -9385a2fd1cd3549b0056af53f9e4a6c2dfcd229801ffda266610118ade9a568b33e75b6964e52fcc49c8e3b900e1e380 -98f4aa0e4ef039786cbd569536204e02b0b1338568d1d22bb5bc47b5e0633fb7ffe1da93eb9d825b40b9b7f291f84d51 -b7b3460cf706dc270a773c66d50b949dabad07075021d373c41fbb56228355324d120703e523ea3f345ef7249bfff99d -81b826255f95201987513d7987cdc0ca0529524d0e043b315a47583136dbada23a114d50d885bb3f855fa8313eff801a -afdc6c35161645a14b54f7b7a799910e2e07c8a5efe1827031a2eecd5d9263b3baa367fdd867360fabc41e85ab687e74 -817b361ce582153f2952f3042e235ee2d229e5a6b51c3d3da7bbe840b5c6ec2f01446125045848d15fd77dc46c8a8fe2 -aeb599265398af6e5613297d97d2b70222534590fcbd534d68b24a0289b6366ac8188b753f6fd1000ee73ef44f8fb7af -a5a9e528b606557be64460c1ad302a43e741357827b92ddc50766a7e6287740fc23bd528d9faf23345ce8bff527d5bc7 -a8d3b3b438d5f75efaae6ce7b67c2212899ece5b5bdc9bac655e271fd1846ea8560e646fdbded3d9363eefe29473d80d -984c7976d557e2f591e779c2885f5033da6f90d63a898d515b5da3adbffa526764cd8eb679b771573fdf7eed82c594ec -8ac748689cc3280e064807e68e27e234609e3cc87cb011f172204e1865ad7fdc78bec1672bd6e6fddcf4e7902b0f38bf -877bb392059540b1c8f45917254b8cc34fb7e423952bdc927e0a1622efec4113fa88988686b48134eb67ddebcb7c3ef4 -ac04b154ccd307ca20428091585e00121b61bae37b22d5d2a1565bc1134be3c81ccf3715fffebe90744164e5091b3d9a -90745c04278c3a47ceea491d9dc70a21a99d52648149b1ab623b5396b7d968fd3c4d1a2d08fc5638e8790463e0cf934e -80bf26ca7301e370f101cc69e7921e187cf5315b484fc80a872dec28bb65886569611a939958f4a3d2d3da4350011298 -87cbf4d6f0c06cc5f24e0f173a5f2f9bf2083a619dcce69a8347c1a6cd1d03325544610f2984eb87a13241e6ab9a22b7 -8909368817a515789ff4d19ed26afafa5729a24b303a368ea945a9287bc9facec9e1c8af19cbec8dab4acbb6a6ddf6c7 -ad8d2f82b08e0990dfd6b09fd54db3a30fd70aad218275550f173fd862347e1258a4716ca2bf4c40e4963850b2277eab -a9467ceacf9337cae4f2c7eeb3e03752ac7d77692b07d5e5d75c438fbe7dc2029ff84f7759372a0ddfa953b4ec7e9e38 -a5feb7669e84b977cb1a50ff3a39c28f7ad1ecc33a893fdf1ddae7a0d8a4c5f6fbaff25cc56631b708af038a961f3b55 -8f2e1fa07963ba18db890b44c3b9ae7f8992b702a5148679df69e4d9d4b1c082b2bd2ae53f96a4fe24b54f3dc1588f17 -896778f35cbecb43f001277c306e38a9c637275101f1a09546f87378b10ccc025644bc650b3b6c36e4fd0c09fbb3df35 -91dc702778176a4d089dc65502d703752dd9a766f125ffef26bdc38fe4abcae07cdea14102c3448d10f8dd6c852ee720 -a5df3004cec6b68b937cadded0dd2f48bd3203a903a3e1c22498c1193f4567659ecaaf3deb7ed7cf43796da9188f5dc6 -b18b4c8ffcb8599c24d9851abf8ee43047cbd4c9074c9cfbf88376a170da4554978988f550afde8a45306ca32713c204 -8370bc38c84da04d236e3c5a6c063e1db6613dcc4b47239d23efdcb0cf86846955b60da3e50f17b17cd3f7e0c29302d9 -ab7d6bb6be10aa52ef43abbe90945e78e488561afb959dc2fe768f8fd660d267c7203a2b7bdfa1b44cd07898f4849e06 -965c96047d82d76ec2cfe5035fd58d483cd2cb7f65c728ab3049562c5d1943096d6a5014c05babc697d79c07907cf284 -9614f7006aef6f0478ebd37fbf17276fe48db877394590e348c724059f07c3d1da80d357120d3063cd2b2bc56c58d9d6 -819c7b2a1a4bb4915b434b40a4e86dd7863ea85177b47a759bc8ecd8017f78d643982e8a091ee9a9e582f2b0208725a5 -8e159a185b5790a3ed444b6daab45f430f72f4ac4026750cbd5c7cd7947b5e00f2b10eaaf5aadf8d23054c5b29245546 -b48cb6f6c0aaea04833e10d735b67607846158b6663da380ef01c5bca3c9d537611716867dc2259883e5bc9daed57473 -8b48ce8b5ab76b7d662c29d0f874f5eec178baf3f14221bffd5d20e952f54f3ed053182a486da1d1f400e0acef58f673 -b6fd3cba177bfbcb5e7ebb1e3c1967cad5848c09c615ba2a6c277908f8b1f4f1ac5f184c33f2a401e8bdafcaed48bb88 -abd8f44c4a447de8fde1c119f4fd43c75b4cc99de9c817a019d219d4b2ad2a73b60606c27e36e9856a86bf03e7fc861f -af9f7e8b3e9e8599c7e355433c503a05171900a5754200520fd2afed072305be0e4aebb9764525d2c37a5a7eede72025 -a0960a58bd2681804edd7684793e3cbb0e20d1d4bd8721b192baf9aee97266be14c4ee8b3a3715845dca157ba2fb2c1d -949a37213209adfbfa4e67c7bad591c128352efd9b881c1202cf526bf4f657140ef213acf0efeb827a0c51a1f18809c4 -9192fae84a2a256f69a5e4a968d673bebf14ea9a2c3953f69fe0416f7b0fafa5166f3e4588d281f00d6deac1b6ec08bc -b1a249662f34a88d2798eae20c096268d19f1769d94879b8f1aa40a37b3764349b8e6ab970558436a88a5aa5c37e150d -aea87086dcd6de0b92886b3da0813ff271a7107ab1a3cb7021b85172c1e816a84dbb1a8fdb47e8a8eb5e6fcddd5b919a -a586b5078b3f113eec9f074430bcf9aabe4e82752e5b421c6e31d1c2a911512e34154bf8143b5197e820c5af42aa8ac7 -a6eda122e400a6600f025daa383685a10f72f62317a621698bd0106b331077b05ac1afc68ece7a2e285c54a366921a3c -8875e9ba654ad7b1d57ede84e2b702600416d40f7475fe2df25dd1b95c0178a227ee187547898e5b9d1ce8ce9ebd15c9 -af2cb289f8c75f4ddae9e3ef9c1977fe4d4d513e411777b03b996f5baa372eb995b5ca96255fad9ace776168806ecc42 -8d24c465d26bd93290f45ef035bb6dde4530d9d7d051baf583b1f8b98e9886de262c88b5709084710cffa7c767b4c27d -8cf35b1b28a7726645971805170392d522f5e7e6cb94157fe9c122a987051c1c90abe3c5bdb957ef97b1c45dd9bba05c -93e2bbd82a3cb872cea663f9248b21d4541d981f3f8d5af80a43920db5194857f69e2884753f6ed03b6d748dbfb33620 -8b774b97657db654ebdafce3654d645f849203452e876e49dad7af562491cb6531bd056f51cb5b2e8f0a99e69bd8566b -b5333c49d3e1c4c52f70f3a52f0ad77165bed6ad9dcbfaf1364e7a8a0f24570e85a218e4c2193f63d58a7dd975ceb7a5 -b4a34c443e4fdaab8e69fcda1fce5e72eaa50cf968f5d3d19084d049c5e005d63ab6e1d63dee038317da36f50ffb6b74 -824a224009c6848b92d6e1c96e77cb913fee098aaac810e2c39a0e64d5adb058e626d6a99be58593d921198edd48b19c -a86f1fdd2e1ba11ebda82411b75536fc0c7d2cdb99424e0896d7db6cae0743ee9349ffa5bff8a8995e011337fa735a9d -b406b5b89b8bed7221628b0b24eb23b91f548e9079a3abd18be2ed49baf38536a2c1ec61ab1ddc17928f14b006623e7b -8a7ea88d1f7420e2aaf06ee90efa4af798e2ec7cd297aacd44141471ed500107fdd93bd43b6de540314ef576646a7535 -a7a8c071e68bbae9aca110394cf56daad89404dff3e91ea3440670cd3d0423b67905e32b1ba7218fd4f24d2f8bd86ce7 -b959830f152e4d31c357be1ded5782aed5d6970e823cf8809434cf4fddd364963bc7cfda15c8f6b53eda16ab20ca3451 -b59232c8396c418238807ce07e0d248ad2045289e032678b811cc52730f99b480eb76f6adf985e6d5e38331d4bb2b9d5 -a14092fddecc1df18847ab659f6cf7c8603769a4e96fbe386d8303b225cebbbe8f61d6ab3dca08e3ed027e7e39f2641f -941cb0632acd395439f615c6b4b7da9ed5abf39700a8f6e6f3d3b87a58a1a7dbb2478a6c9ff1990637ada7f7d883f103 -951b8805ecb46c68101078847737e579206f2029e24b071bae6013e9dde8efa22bce28aa72c71708caf4e37f9789a803 -b2cbf22e53f6535fa950dd8de4aa6a85e72784dd1b800c7f31ec5030709d93595768748785ff2dd196fbedf3b53cd9d7 -8d84ea3a7eafb014b6bd6d57b02cab5ac3533aa7be4b86d2c5d53ce2d281304409071100d508ed276f09df81db9080ea -a2204b60836cba8bf29acd33709e6424226ae4d789ef6b280df8a62e30d940bc9f958ff44b5590d12fa99fcde2a4a7a9 -86692c58214f326c70eb2aaf2d8b26eae66fb624f143a3c144fd00f0249e30e0c832733a7822fac05c8fe74293768ace -b1cb3d64eb5b9ca0e01211128f990506fba602cd1417da02237205aa42879ae2a6457386da5f06434bcb757f745f701d -b3eb4290a53d5ff9b4596e4854516f05283f2c9f616ec928a0934b81c61afc351835f7eca66704a18a8b6695571adb30 -b0bfb1d44b039d067d7e0e2621e7c4444a648bce4231a6245179a58cd99758ec8c9e3f261d0adb22f9f1551fceb13e4a -a29320f71a9e23115672ea2b611764fe60df0374e0d3ff83237d78032e69c591a4bdec514e8b34f4b3aeb98181153081 -8a6abe9c8a048002b2ff34154a02c2f13fc6dbae928da47c77f3e5b553ea93d8f763821a6ead3c6069677870fdff7ff3 -b73ab66a62f427e1a5e315239a2e823e2a43550d245cff243c2799eb2e4701fabb7d5f9ce74a601b5ee65f6555dacf64 -b64858e98b9c10de8c9264b841b87e7396ba1da52f0f25029339ca1d13f7f9d97f4de008cfe12a1e27b0a6b0f2c9e1ab -807d2440d1f79a03f7163f5669021f3518094881f190cb02922eb4e9b17312da5e729316fe7ba9bfffc21ed247b033cb -a7f06458d47ebe932c2af053823433a8a06061c48f44314fad8c34846261c8c3f7f63d585a7930937327ad7d7ca31a6f -82ac2215eba9352b37eb8980f03374f5e0a2f439c0508daa7a32cdce398dde2a600e65a36795a4f5cc95bbcf49b01936 -a1882c83a2f946d54d74a008eac4aed70664db969e6799b142e0d0465e5662ba0d224a1cc33be339438d69bdad446ff6 -8009776f7a34a3c8779e21511fa409b0c5a38e172d1331acc29a16114e002f5f2f001381adb5fb3427a100752d775114 -b24441019af4a0df2dc68e3a736f358da0fd930c288398a18bb5a8d9a1e98ea376395f19d8e03a5f020b83fcb709f1af -ac72b4de3920c4f3c9b8ea90035cd7ed74d34b79e79aab392f057c3e992ebe79050cc1c6ccf87120e4162b29419147de -973e75577cd2a131a0bd568fd44e43554ac5a9ea3bf10f02d1ad3ac6ce9dc7a8a7ea93aacf3325f7d252d094a0de1376 -98a114de2a86f62c86862de37c328bf6a7fccff4d45a124addbe0eb64debe365409fcb72ce763f2a75030e1ff4060c64 -aff753e1dd4707f1a359eaec06ebef1903242889a2cb705d59dd78a79eb5b894731f5a91547479506145ca5768877dec -b856e4234858b5aa515de843e8bd4141c15a4cc02c51640e98a8aaa1e40344f1ff8ef7c3b913ea2ae7411713daa558d2 -863525eb2f8147a6d1d0d4304881795bfed348913cd7f38d815d929a426788b69e41f022dba5fdcaf56c85720e37fefe -a14ad76b145a6de2e0f8d4f615288c1512701a7b3010eb8a95941a2171bc23561e9c643764a08c4599040a3b4f5e936a -a18bfc66f6139dcb0485a193104fec2e7d52043837a4c0cadb95743e229712a05cf9ce4ccb482f36ff1ce021e04b574a -991c8e6678077d6e5f5733267c1819d8f7594e3b2c468b86a5c6346495a50701b1b05967e9590c15cef2f72bc10a38f9 -a034e7f9b547b047c99b99a0dd45509b0ac520d09130519174611de5bcdb9998259e1543470b74dcd112d0305c058bad -95ffe0d02317b5c6d5bfddbcec7f3fdfb257b26ad1783bb5634d983012e2ea1c6b9778009e1b6d10564198562f849ac0 -b3db442aa4adb33577583b2a4ad743f41efe0e1f87bfc66091d1d975333ffc00b4afc43057bcb88a7d68b0c9695d38dd -ad2e97d10d7c53d231619e3f2e8155a27ea4f2fb3c0cecf5c7f14f4cfcdd21f62ea46d843b21df748b2892131633fed2 -905d7aad6d3b56bad48694b6b20b27e370ebca8b91d0821e48e2f9cad39910c26cc11c77c266894db3d470485a63ed11 -99bfadefca796ce6af04ede65ba5ef5bf683ff7e2852bb9c406fda77b95ef382289853dfe4d933525071e4cab8ce3936 -94d9905ed4ef92107d0adb9ea38f085a2a24b8f792108bec702d747c215b1f14aafd486ea0c07ed42602b12d8f602b93 -a78dce23ca09dda2d5e7fe923290062546825286d624de35ac5756b6c8ae030e211f4f9c9c8d18a924f5880e3b383d1f -abce9e2128ff51fa17e73d93e63d7134859b2f328eedbcefb337c39e752d6750d9cffe6abfcd359c135dc5a12018827b -a9ea7d91e8a3524acb3182bedd7e1614d37b48f8eb2d8f677eb682d38408b8d512786d8bb65811f4d96788b9378e59b3 -912c9f804fb57dd1928f8274be58b42618f589fc72a7e5b6cb4d4b5d78c547f80737cdd77ebe5d2b71eaf60b8fd2b663 -b7227ec9a62d5538974547f717fdd554ab522d8782667fc3e9962e9c79a21134ef168371bf3b67e28d0964e92cf44028 -89440a781c812a19c758172bf722139598023ed0425374fbb0d91f33be7b7f62a36d7aa34696c4fb0da533bd5dd41532 -b31e4a9792d6e9c625c95aa3c0cd3519410dec07940afab820ef9f63017415d237a47f957d0b591b6de399ffc2a8a893 -a66ec47393df2693be161daaa88be0cf07b430c709ca97246d10a6080ae79db55c9e206b69a61f52512b868ba543e96b -90ca425dee74cc6a7e8eb1755cf9b7b76ba2a36ab851333b0fb7b35e8e6e189702456f2781ad87b4215993d62230ff4f -88b64741f93a2ae5d7b90b22a5e83c9d56bcee5c6bfcedb86f212acc776cc3ebd0b62cc025f596cd8db4f4b6a7aeebab -a1b6c7d2358bb201b42264f8fbebaa242ef105450bab21b4a2f16f368048c16ad1f3695841787eb33a0192f1f6b595eb -8a932f1cd227ceb18389791ed9ea1ff26571715ed1ab56601a994795713a8f7f031d1e8472ec3eb665b7bfbbca8ca623 -8bb2e34a2bf77f9f657dfc51ff296a6279a4d7d15860924f72b184fb7d5680320c7769954b9dac73c4bfe9c698e65e58 -af54e7367891c09f2cea44cc7d908d37d058162ec40059d32ded3983a4cabfe5057953878cf23bfad5292dbd0e03c0e1 -8a202532b9205385cf79f0299ddcb3156fd9fab09f9197bce762b5623f75c72ab1d74334ee6f0d289007befe222bf588 -83bd0f5896eaad58cfa7c88fc5ed505cd223f815dcfe93881b7b696cdd08b8b5ede03ea5b98e195c1a99c74ac5394c1b -b4a84d9940e58e3b4f804e4dd506f8c242579cfa19323c6e59047e5a1e35150699a2fab2f4862dba2f0ee4ed1d8970f8 -8c9ec477d057abebc2e2f6df5c4356a4f565bde09f499a131967d803d4bf36940ca2ed9d4a72adbe0a4a8b83fc686176 -8598f43c32623fd5b563d1ec8048ffc36db3d7f9b3a784299811687976f64b60585b2a2707050a3c36523b75d1e26716 -b55eb07014fe5ad3e5c9359259733945799e7429435d9bf5c72b2e0418776e329379433e17206f9f0a892d702a342917 -a5ed942eda7b36a3b0f516fafd43d9133986e4c623b14c0f6405db04e29c2d0f22f1c588150f670dbb501edda6e6dd4b -92b6abb28cefab2e332c41c98bfa53d065b7d262638389603a43f4431e6caf837b986254c71f7cdacf4d6cc4064b0195 -b01806178a28cc00d1561db03721eef6f6539676d93dd1fa76a13b42a31d38797e99b1848de92fd11821a342b04f3f72 -a2f10303437acfbb5912e186bbff1c15b27ed194c02cbc1c5b482b0b732c41fa809136e8e314e26b5bfe57690fe3b250 -9990207fcc711102e7e941b3ac105547a3e7301390e84f03086c99c6d3e14efff3a2e2b06e26227f496d88d5cdaa3af1 -b903cdb0c2fd578612398c30fe76d435cd1c2bab755478761244abb1e18ba8506fd9c95b326422affbcaf237309959d7 -99e0c12cae23f244f551d649302aac29bfdeb2c7b95578c591f512ad7ac562bd47e7c7317ac9bac52c9ea246617bdb48 -b996d267ab5149c1c06168ee41e403be83f99c385be118928d6e2c042a782de0659d4d837f0c58b26df0ce22049a5836 -989001b8414743765282f7e9517e4b8983a929341b8971d7dd8a87d246f6c8ba5e550c983566ddd932c22948f4fa5402 -a0b006a2c9124375364b8fc5ddb543a7468fa6d321ea046d0fd2bfdaef79e5e3600b3d56190733491ca499add1298c7f -80881d6f3ee507089b7dfb847fc53dd443d4384ef6fce878d07d9b4a1171eefea98242580e8a6a69664699f31e675cfb -adc48ef53d88b9d70409ed89cc3be592c4bd5eb65d9b1b28f2167dc4b12406889c00f2465c554f3aff673debc2997ccf -a62f5d9f167b9f4a4aab40d9cd8c8a48c519f64a1985823e20e233191b037c02e511b0280487112a9f8b1f1503b02db7 -b89aa2d4fb345a1d21133b0bd87f2326eb3285bd4da78b62174bf43d30a36340e4217dbe233afb925ab59e74c90fccf0 -932ba22acdd2f9d9494da90958bf39d8793af22417647d2082d2c3e6a5e17a2d14b0c096139fa8fa3f03967ca2f84963 -b67b107e71d96de1488b4154da83919d990502601c719e89feabe779049ddf7e4fb7e146eb05e754b70bbead4449efb1 -84509de1b8dc35aa2966d8a48501f725d59b4c65f3abf314b2009b9a573365ae3163c1f276708c66af17de180aae0868 -849153fe837a33fcb32c5fa6722c2db9753e984867c112a364eb880d87467782142d1c53a74b41df1dec7e900c877e1f -903d05c73ae043b69b18e980a058ce2254d008647a8d951175b9c47984164b34fc857108dcc29ad9df0806d7e90405f4 -a6b05917ac32c0b0eeea18f1ef3af5343778c543592078fdf6a1b47165013e2676bfe6a592a24efab9d49c4bd92b8fc0 -8648482f6947a5a8d892a39f098160aae1a648cb93e7724ea9e91b0d1a4f4150b91481f6e67d3bf29ff9d65ba4fa61a8 -a6ecaabc38895013297ae020686f04ea739c4512d2e3d6f2d9caf3f54000fb031f202e804ee615eb3357714a18657bcf -912f5935acc2dd20d5ef42b2ad5b307c925324a84a3c78ff66bc5885751934bd92f244e9636b60a744d750a2a7621198 -a0d6f261a776c5b114298f5de08d6e3372649b562051ea2470d3edfc376048793e18fc57ec84809b463dc72496d94329 -940744cd3118d1598c248b38503f6f1fbdbe7a147e683e5b3635140aa91679f8d6c1472600f8e9c36117a60203be6b4e -ab81737c839fe340f6f1fb7275811cb0c0d5fe8bbc265f6a56c6c68d0291bc7234eaa581ff26f8929d9a5bed4aac7002 -8df47341160f1c728c3e31be17a32e42b54faaa1286ef2c7946882ca4dd46443b8428f3654616c6e4053f1cda2e11994 -a721067e75c3c791f4d9f58d4810ac9621606e29c6badb593d6bb78c39968b45be1777ddb9bf03696d4d4be95b2dc1bf -a4e399213d3c4350c2d0cbe30757ba7e1f9680f58e214ff65433b36232323744c866a87d717851ba1dbd6769599f69a6 -b0be851d1e43dee27abe68f85e2330d94521b5f1c1a356ad83fcd09162c0ca9c2e88bccbcc5bacfa59661764361867a3 -86111bdd3dbfca232aa5802a6db41d639502e43a2e24cb06bb5d05c7f9b5ccac334d16b61d1c5eaac4fa0cab91113b46 -a4f805b11c174c34250748b9beebfb7c8c243198fb13463911906ee4effe7d331258a077e374b639a0c5cdcdff166b7f -87e4cf2c6f46d2dbac726a121127502921decf0195d7165e7bbeec6f976adb2d1c375eaa57f419895a2c70193215dc4c -8ff06de2c1c4d0744483bb4f7c5c80bf9c97b4df23e86c0bb17f1498ea70e0ee3af20827da5e8cb9d7f279dc50d7bd85 -ab112c0116471b4dc3fd1e6d918f99158eb7a08153e891ddbba2fe5bf0eeb188209e3019176e758231c3df937438136c -a67f89194e99e028a5da57747268e5ef66fefb881144043429920d222d37aaf268ebf73ca1da659fcdac3b4e7a65092a -b4da1dcc791566140d6abeaa2923cb6b21a6e6aaa30bb4cc70011e931eefa71f96b7e05358c0654bad7ce45191ab9fa8 -8283933231bca359db588c80e043ad6ea765fb0cba5ef233c5d514ba01ddd1b409efbadb368f26763402e4576dc4655f -97f568ce3edacd06f3e31a15462f5f9818a8c3fdbcf92b1ac5840b0b6e73166a154013dd52e85a18e8ead3fc9e54aca0 -a9cd1601c41e5ab2018f986443914fb703ddb6b06a36c06fb58065f2fee8e1751071ef924ea3ad76f0c19baccb1b5f8b -92aad71bb7e929cc35a48020d16a5822f4f106a7f59985005a5ae5ba8e8016ec33727610393498f56b4f353b3d5161b8 -89427780aa4e7ac894c681fbe2889153b94db883f17f109bc9caa93f0c259dda42aab502bbefaf572c56f70abbc42db8 -aa8cf76ff847dfe59534432ed8520bb48bf412c28497747dce04d2b2a54ba843c3be1564630cb49ec0217167847ba590 -a1570a6748a2303e74a31c2131d05ab372ec006ee92ef74c42f2e9a250663bebdfb3777e7ad91f50c954889a59c2d434 -a4c2b1bbc48199c31ea8d8196729eab00ce0200350d4aa9f23347a3289355e5828cb2f93036a14d2d9ec575fb3835239 -84819d0bedbaab5bf8afdf23f59a7ec5f50da3063cfdd1ef5fc4ca4c1fe68980b5c80e30a49f38e5816765e81dfc5a57 -a57cfb5e877b88202f589be777605deafbfc85ed1357af03a18709cfb4b668a271199899243cd3750f1cb77ebc40bba7 -8d95934bbb0efaf3339f27cb96de46e4486aa58a2c40dbc77c1c3ac7c27a228062824b9045c046631b2e286e8549603a -b99a8356abeee69f40cb3bd8c87e8039a1e076897dde430bfbf989dc495c48609a7122bc6c1d1c32ccac687b47d5558a -aac2edcf2fe5d3f1a84e8f1f27ece920eabe7793bf0ed5290cda380752e55d57a55a362c5253bebb71e4a55f2c437ff6 -af7c76876072c3b0091e22b9c5b27ce99bf1f0079ea1a7816ad9c06e9e5fc407595c7f4f9953e67d86fb2da656443dc3 -9175b64d104f78d3310c9c02f82e04c8e9878d2044ea5ee9c799846a3d23afa5fa2aa4af7350956136c69a0eed03cb2e -b3328e953317494a3d976e7f7c3d264258a5d4b2c88e12d06786a9e7b2affd41086762ef6124c6a6e5b6b028db933c14 -a49d166065e19d39299ee870229e4a04be81acd6af3a2201f3a291a025dd5f8bc3e676ee123cd4b9d8455f6a330b395b -85fa15bc8947ba03681d87b50bd2f8238b1c07849a7ed4e065053fad46aac9dd428186a6dd69dc61b5eba6ffec470831 -b6fcb2f694a47d3879b374b8b2967dcd59bd82a5d67ae6289a7326c18791b1b374e12571e8c8ea16a4bfc5525ced3ec4 -b6115f52566aa90ccac2aab6d2dbf46eca296d047db1eb29a1b8a2bc2eef7a24e90407f8dae528806aceb2a1e684d49e -9707e66220233f6a48a93e8dec7b253d19075eaa79238e519b82ce1ac5562cca184f8a1c14f708a96c34ad234673d646 -a0822903fb3825eae07ee9d3482277c0b8fc811856dfe4a51cf24b373f603924166fc5485185f99c4547cd6476b62270 -88dac6366c439daaeee2532b2ddbe206132cf6e12befbb8e99870ac684e04e62de150cba0e22e395a0b858948f40808b -a72dfba9caad3179f43fead0f75e33ba5342470d8c9cb7c86d30d2c7ce7244a8aafd1d558b0ec8e2a9436de2c2e95ccc -8d696046defcc32cc19954c559213100f0ba273ea12abb55ca7c42818071d853846bd4213af2c41ecd4442f6b4b511b1 -89d6f2d52cf65414da15a2fb1911c53afbfb50bb5f2638844abfc325ff2651cd9130be4beff05dc4046adfc44394a182 -afb91abd7c2a9cfe62855ede3c6960ad037fe8778364a2746ff7c214c55f84e19a474a9a0062b52a380d3170456ee9c6 -87f724a16ec8fdae8c05788fa3f823ecc3613df46581a63fc79b58f7c0dc2519b6b23e3dd441a0ca6946dfe4bc6cd0ce -86760f90f6bedfba404b234e90fbf981d26c29b87f2fa272c09540afa0f22e6682d08c21627b8a153c0feb27150458e2 -ad4d0342f255a232252450ce4209507ba619abfd1ffcb9c5707cfa45f89be41d88f1837acea993a1c47211b110250b4d -ace54b5889bccdf1d46c4ca21ed97cca57f7d12648381411d1b64afdfc64532a12d49655776ea24cf5eabe34145705ad -936dac693d0c1b1e5de1701f0bc46aef6e439e84bc368a23c0abe942eb539a2950e8929265786fcdb18d40a44bda14b9 -94fafbc544decec1d489b9ad6b23410b9de4779f9f44aabd093d7fab08340a4646a8cba31633e49c04d2690b8369a1d7 -98157e757f1a677c5d9d65c47759727a4dbc49fec2da4d9889c4ea90573fb42e2a8d72eaef92b782ac6f320970f09363 -8eaa0498c191c810c7e1ca7398f7c80dd0a7e7d7829ed07039490f60e7c2ae108843c06fe38fa36d45d63da46cba887c -a0ae116e5b0d2dccf83f056ad876037225687904e0290fe513fdc6b2dbe4cbf5fac1d828352e64734895895840b3c57c -b592b318dbbd7ec4872aae5e64bdf2305db2e5e8cfe0ad77b691f542ba5e066dd20b09b0b08ff0d798bd79ad946ddf7f -879e50c8c3e7f414ad2b38632bc482b71759cd561aeb2215550186ebb4559e4cf744cdf980512d8321954b3458d21e11 -aed5c6c7ce0407d7b2c04785fcb9deadb9b9413e37cef5b1d918f474cccc7de012fe1fa6f5fa93cb7ef9ac974d9fbc20 -892274a9f0afc68fa74be276c2a16de5cec674193f96b27a80bbb9f3add163f85716b531f3c920b98577a0225f84e8ca -938fb7a53266b997a7669596577af82f5289b160b7fcf06d76eee2a094696f6f12b28c2c65b833a52529a116c42e6c7e -892083929b6067f5045b1208f3dc8f0ee25bd0533a8831f5c23bb4ff46a82d48f0a34523359df5061d84a86b718d5060 -99159ae9574df6c16273eda66b6d8b79a327940e335b28c75d647f4744a009f4b5f0f385e2017bd3e7fbf59e629cd215 -a03e5757ef7738eba32d396923ff7ef82db2c15bb6adc8770fcb37260b7bda3be62473bc352a9a2ef7ec8ebe0d7688bc -ae3c24a85c9b1fa55158b2acd56d2016f70dca45a23f3ef7e0c6b096f4a7c54c14020d61bec7c7f87be4a595bf254209 -a920a6f9cc803fe31352fca39c13f8ac1e8d494fcf11b206092227c2af38469b1fbc068b8fe014800b70f137107aafc4 -b893853be57519ffa6410da605e7d3a746ebadec4788c7907f6e0dde9f20f5a6a01181148b874b3decf9b4814846a11a -b46f43918c5195729f6532439f815d1eb519e91005bc641a4a30ae88700982bf4ed07a342e77945780317c297c903755 -8e431bf4497d0ef6538c93c4bdda520179301a0104eebcfd104efa1edea876818d7d31079656f01a5ff76c4f5fcd71df -92e3dbcb580dfb9cc998f878052b0c3be1c5119e5249ae9bad3538ebb0f0c4ab5a959b04033b96d61836ef07784e6b64 -b712d9d63aa888156f4ec83e939c6bad53de18045f115f54fbf4261fb02f10a8a46a8d716ab43d4acbad3b02283c32fc -b2334e776988b4f772446a47c87416b4f19f9b44164a5f828424d3f35ef10baa56afe810d49b0b86b786b9c0227681a6 -a3f25ad18e435ef585fa90e6cef65a8ba327e5e33701979e27e64ef7d8e09e2591e52bff9c5749d35643456d18625685 -adcfa48ae43cac6fa9866b4cce10a243969965942c891d5e6c0e5b03bd4763f9b63779fbf40d26ac674534fe7cc478d7 -a0eb3448e045038740e2ee666e88aa0f8b8e24b1b55d7d4964f01bfc0c581f7e9d4c0e79f8cfbfecfa8b024b216c8ea6 -8110aa1d82f11965af4f4eedb4de09ee9c353481b2d7ee7a2bc2f302d2a5ae6c31ebc6451309ba7c305da41070b0f666 -b074fdad419d42783ebda17f19863aa499eec71fda5aab6cdcc389276b7bf08053795d15890175ca3dc89f6d8d17758c -a14665846d95d7d5f0b5381502080c822776ec0994ccb1ae1ffbb3f19205ce9c7c9bf9c2d2ca098807ce99f29e4f07a0 -b4884842670a333cb5548a842fa2971881e26b442dfab0b91d6bf3b4cbdf99adbbc9d14fe2bb46872cfcabedae85db30 -94549b01cb47ba16c0cf6f7522c833545397de0b3388c25d03e60132eddada6401682f9ffd8c50d1a61b4d2dde37461f -a790c9b4cec96e4c54777f3e03cea5769b20382cdcaf1de494bac2b9425eaf453eff643c62ab284cc1af33bbd36013be -b1b45fd298ed11609aa1ae6c5ac655e365bb451de1b9fc92aad40422ba85c6a454f33b8142acabe55171328c13d92edf -a74cea9e7096e38327064f058a3cdaa34e6eafaa9c7d58f753c40be67998152380fbd612b9dc0751bda7befcdffcc749 -b18978dfc5efb07b7ef992c7b0cf5d1b4ca551578b1dd13057b7aced8b1deb9f2036e1e3116248a803e922659d206545 -8153c07603cdff6622835a9853b795274390abf7197d7a192193bec44acb43e8cd50b56c11a03f4a2a27124c36974f3d -86b987f30bb9a37cc91d22dffffcd346ec5773e846a6c2b8f9e03b25ffcae859c470c901c4e29695d325dfe4eee927bd -af5e980b9507d10d5269c1a5d02bc16f4f009b663e413ea6a7c655250f3a21c608c12f4002269a05d3779907e7be7d69 -a6f737fab2af9f27bfb8ca87f5fdab6ad51e73ccf074e90576db57b309dfa0a95f9624526dfa4feaef39c388802f2ae9 -b7ed51f699f615f58a7ff4f99d52c4ce7a8d662843c1f4d91f1620fa119b80a0f6848f9fb6c4b9822dc019830e7dfd11 -b71f27f291aa6ef0723ed79c13a1c7a1c40198ffb780a129d9d20e250406bc91f459705b2b6674c9bb412a7b5dd9ff07 -9698cf8f638c3d2916fefa5f28c6050784479f84c2ee76a8aeda7e562630a6ae135b445ec4e29af8588ca5ad94a67f49 -9270aa5030966a9990d8bc71b00b9a7a1d7c1ad8f4c7f78a31b3d7f86467332f21407c74a89ba4f574d723acaf0d2042 -b1b82faceed8e2297cd49cc355471d15ff8dc2ccc78f6944c8f7a75d3ad1629a2e2f1d0a2ff7fa2b3c38cd19839aa5e9 -8a8c4ed49dc9bd961773edf8d41d04385b11bbd3577024639a39319cc7068380236bf73fce0b83e6535bd3f95cef0e65 -8d04ec1e7d148b7e66910ab45a0e6bf409612a3b560bfa784e26f2963152821c646a655cf17a0ce3d4ba4c4ebeeb4a1e -8e9d707f6186d93accb60813715ed1f6b3001ff6d2f87daf8b906bd0b988c1833b2ccd80dee9bdefb45901e81bb82971 -9762317ca6a5e6fe0b2991e0fa54b5fbf419dd0550d70074957d65cd7ebf79ceba607dd40d709ed635c822b3b4da2cac -82b53cd9a1eca2f5d3256723dc4b6531ca422bd87bab36243c727d1952db58d7288ab11467305d875d172ce165b1e4a5 -b4dbeafa05c87029ae257bee1ed7603645fab41f6ba7ac8b57ced5b4774a72ba3e671c2433a93acc3c498795b5cccc42 -a916d3ab7f0e7cef294e11c97c910a19c338ad8e615406e6d1c8995b4a19c3b2527100cc6b97a950ec5a4f3f6db7d01a -b9a785c7123609bdc96f8dd74500c6c77831d9d246f73244de964910b4045ce3242c881271bb1a4bc207d67de7b62e97 -b5f94084f695d0821c472e59c0b761e625b537c8ae3a09f11d9a57259e148cfadba1e43bf22c681b6b32390121cec208 -8f91b36d8570f19a90cf3ed6d5bb25f49a3315ddb566280c091fe2795c4e25ed2c6a1ef8d2669b83f2d7bb78fc8c40f5 -80f27359a73ed8fdd52762f0c7b9f676be2398b1f33c67877261480bf375f975f626c2ca3e7a9f59634db176ed672c98 -b96b91e3d5148ca793edefe4ca776b949c9305acb6f3a3cf87767a684014d2c8f2937c2c672eef8510f17d2da5d51385 -99c4e1ca2cabd4388ea2437dbdf809013d19be9bd09ff6088c8c0cfdb9ecf8fd514391a07b4288dd362434638b8834d9 -b6fdfb812e145f74853892c14f77c29b0c877d8b00055fd084b81360425b3660cd42236ecc853eadb25253e1cd8445c4 -a714af044ef500104576898b9409a9a326ef4286a45c3dae440bd9003fdf689c5f498f24a6f6d18502ce705c60a1cf14 -a9444e201be4a4d8c72119b3d3b13098afee6e5d13c5448fa2e9845cc9188239778f29b208749c960571dfa02b484f05 -91c826a6b8425f93ff395d9fdfa60dbfa655534c36c40a295906578540b9a0e6b94fd8d025b8b8611433022fbbc4fb0b -a355d76bc3cc48ba07026197130f25a593ec730d2ef0d5d2642bfcad745ecbe5c391324bc2485944060ff3100c952557 -b5f9b5a289a6f9a7252cc1f381c892bdb6836a5998f323ee21ae387936148ad1ad7cc6eca37ecece36404b958ae01e8e -a3c7ae04a6208851f6cc40ff270047283b95218905396c5dedc490e405061cbefd1251ecf77837d08c5ec1c77d2776ce -aa02ee387dd2cc7a23cf5cd582da0bc84bb33a7158d76545cbd6e06b26a6f30565dc712d7a8594c29f0529a892138802 -8aff025c841f167fadaf77a68284c355ace41d6df3a9f1e41a6e91454b336f0b69ea34cce495839b642a7c43997a8fd9 -82eccf0b6b4b6460f676d677266451d50f775446df313fc89bdf4c96e082340f6811939d215a54ba0fe30c69b3e43e25 -af324d871b038ff45a04366817c31d2c1e810359776fb57ac44907c6157004e3705476574e676b405d48a48bfb596f59 -9411dcca93ef5620ce375f379fea5c1017a2dd299e288e77b1ab126273631a299d7436f3bf3c860bf795e5faaaefa804 -934fca809e66f582c690c3778ea49de2e7940c0aeb8d7edad68f2edccdfda853d2c4844abd366fbc2215348935e4b2e2 -a1b1fa4c088418f2609d4dea0656b02a8ee664db25f40d53d8f4b1be89a55e5abecbf2c44c0499874abeb3d3a80acf71 -ae6ed7a0ba6280c679b0bf86111afad76fc5d930e9fb199df08134ba807f781d7e0b8b9b2c8c03b02d8cc20dbe949a28 -937d200a72fe4ab8d52f6cb849e322bc5959632b85a93c89744b33e832e8dcf1dddd6ffac0c049b03c105afb8930f7f5 -b4b4a46ebe0c5db16004933c08ad039d365db600a13d68be5346b1c840cce154f56c858874e866de8c3711e755c6e5dd -afcbcb7170c8caa2b77d2b3388dc2f640aeb9eff55798aeceb6eb6494438be05a2ae82f7034b2d439a45ad31d8c64b07 -a2c676273081b8761f58e0b11306ddb6a4cde3d90e7c47b434468700c5b749932819b01efd7637ca820e10fc28dfb427 -b445715162d834c9ee75ac2ff8932ace91c8242d67926b2a650217e4765e0531c2393c9438a52852d63dbbe2cceaafc5 -a0c0ebdc1480fb238a25fbfc77fae0db6e5e74b91809f0ff20a819e56b8c3141549615d1bd7b99829898f6028e8c86be -b3d11933e9d1db8ca617934261ed26c6f5ca06ba16369e7541482bf99c4f86520d43fbb10f4effb2fdf3cc70a189fdb5 -888ac610f8fd87a36b5646e1016eaf6dbca04aa0cc43f53a1046d74a658c4d2794606e79fb07fae57cf9d71ed339f4b6 -979818dab00c58435dc0d0d21185943f95819d2a13531abd2d798e1773c4bbd90047f4eebe117868743db75604a50227 -a6fbcd2656e475065fe44e995e8e2b5309b286b787a7597117e7acc3bb159e591a3e7304ef26f567b5720799d8ae1836 -a03f0ac08d2101ec4d99ca1443eea0efa767a65448a8ecd73a7818a99e863a04392bec8c5b8e5192834e8f98d4683f13 -b3c4ea8c6c3ee8aab2873d446ad702000b0e927e0991c9e30d83c6fe62a604efdc3ac92453313ff0d5e0ac6952922366 -ab25c857f26830631113d50145e961441b5e35d47b9e57f92466654dffebde43e4f78b0867d20929f97c2888c2f06509 -98950aa5a70ef41f274775f021a284d4d801a2efe2dea38460db8a3a8c08c243836d176e69127c2cd17497b0ca393e9e -a9698113febfb6d87fcb84bad82ce52d85a279d3a2933bdd179d53cfe8d6c6c68770e549a1e2947e7528a0e82c95d582 -832b504513266259db78478bd1b5a3b0f3bf2c6d25f1013e64bf0cfae9dc23da8ecd25f7f1047d2efb90e5f1d9b4b3cc -b588bba7bcc0d268ab260d5c1db2122cee7fd01583c7cc27a8ae6b48b29f34c6ea8a6acbb71b9b09c6156ec0a0766142 -a73d2223c7afadc381951a2e9e7bcb7b5c232369f27108c9f3c2ced2dc173e0f49531d0ca527eb142fbb70285307433f -9152cd6b97bd3278465348dde2095892f46342aed0e3d48675848c05b9aee6ef5ad7fe26e0dcd4ab176532289d40eedd -a7812a95a43b020721f688dd726356dda8ebe4de79b4f0fdef78615795e29681bff7c6ff710ff5b2d6ae3fd81bdb8507 -83724c16049e9eaae3269ea8e65caa212f0592e0190b47159bb3346208ccb9af3cfe8f6c3176fa566377da1046044ab8 -877634ec37c7dcd3b83705b103c31013697012795f11e8abf88d54bc84f2c060f665f0c3b14ef8087d3c6a8a7982d64f -b3e53aaacef7a20327bdbba8cd84513534d2e12fd5e1dcf2849f43146e098143b539ebd555623d0ecc46f5ebb4051fca -952d58ecafca9b7ffc25768ee4f05ce138f0289d72978eb5e5d3b23a0daedcb17478890afdce42e30d924d680e13c561 -a10dcc725f9a261de53dd3133858c126f6aa684cf26d92bce63a70e0ff5fff9610ad00d2b87e598b0a7548cfd1ffe713 -b7bc5d0c6b665d5e6f4d0af1c539d8a636550a327e50a0915c898ac494c42b3100e5fae0074c282d1c5073bf4a5456fb -8adc330d3b49ddf3ed210166afc944491aaedb28cb4e67472aeb496f66ce59184c842aa583bfb1a26d67d03b85065134 -b2df992a1310936394a1ebca94a7885b4c0a785638f92a7b567cfb4e68504ac5966a9e2b14891d0aa67d035a99e6583a -96f5da525d140739d19cebb706e2e1e0211edea1f518e040d361d5aca4c80f15be797f58cb4cd3908e4c360c18821243 -b2c0d9173a3d4867c8842e9b58feb1fb47f139f25d1e2332d6b70a85a58811ef99324bf8e52e144e839a4fe2d484e37b -ad95a7631ddb4846d9343d16533493524dfd22e8cbfc280a202343fccee86ab14446f6e7dad9bad9b4185c43fd5f862e -97f38ab82a51a7a792d459a90e7ea71c5a2f02d58e7d542eb3776d82413932737d9431bd6b74ec2a6a8b980d22d55887 -ad4e4c57ec3def5350c37659e8c15bd76d4c13d6de5453493123198dda2c2f40df349f20190e84d740a6b05e0b8f3deb -a691bc10810d11172a6662e46b6bbc48c351df32f325b319553377f525af44a50aaa02790c915b3a49824aa43f17fff0 -a80ccac79bb4014ee366dbf6e380beb61552bd30ef649d4ec39ab307e4139b7775e776fab30831517674ff3d673566f6 -b11e010b855d80e171705ab9e94364c45998e69d9120e4ca4127049b7a620c2eec1377356e7b877874e767f7c44afef4 -96bfab7777769a1e00ce16ada6667a0d21d709e71bd0371c03002427d138d9172640cdd5c529c710fea74bb9d19270c7 -a5bffd2c30e29633b4ecf637c1e792c0378252e2a99b385a093675940b48de2f262c275332ed4765f4a02467f98e3ddd -8d11929d67a6bd8a835b80660a89496250c766e713bddb2cd7052d67b92c39a38ce49005d38b4877856c4bef30fb9af4 -8e704597a0dba1dbd1ff8c9755ddac3f334eeeb513fd1c6b78366603ebc1778231deb8e18f2889421f0091e2c24d3668 -904fbb3f78a49e391a0544cf1faa96ba9402cba818359582258d00aff5319e3c214156cff8c603fbc53a45ede22443e9 -af12ac61eaa9c636481a46fd91903c8a16e7647534fc6fd9baa58ae2998c38ffbd9f03182062311c8adfef0a338aa075 -87f2e544b2993349ab305ab8c3bf050e7764f47d3f3031e26e084e907523d49e1d46c63d0c97b790394f25868e12b932 -a279a7bef6de9d4e183e2bedaf8c553fadfc623a9af8785fe7577cadced02b86e3dab1e97b492d4680c060ea0126abeb -8ece08667ed826f0a239cea72e11359f7e85d891826292b61d4edbdc672f8342e32c66bec3e6498016b8194168ba0e0d -90a15162586e991b302427bc0307790a957b53ab0e83c8b2216f6e6302bc496cb256f0f054ff2cccdfe042763de00976 -9966c0413b086a983f031a39080efde41a9fedcaf8e92897ce92e0c573b37981f5ea266b39dc4f4fb926a1bce5e95ad7 -9515be2f65a57e6960d71bfb1917d33f3f6d8b06f8f31df30fc76622949770fea90ff20be525ae3294c56bc91efb7654 -86e71c9b4059dc4fd1ce7e28883e4f579a51449cab5899e371118cdb6afe2758b1485961ca637c299896dea7c732151b -8695b4ff746d573f8d150f564e69fe51c0726c5d14aa1d72d944f4195e96165eca7eba8cac583fd19d26718b0ce3eb61 -813eecf402151c99c1a55b4c931716e95810fc4e6d117dfc44abbf5ef8dcdf3f971d90d7fa5e5def393681b9584637e0 -a9caf7219eed1db14b7b8f626f20294a3305ed1f6c22f6a26962772c2fa3e50b5234f6d9ba7fa5c3448824c2a15271b3 -b2b2ee20de9b334f2d82cbe0d2e426ca1f35f76218737d0069af9b727a1bfc12d40cf8b88d4afcbeaadf317b7f7ad418 -b853960749521a17ff45f16ac46813d249c4e26e3c08fd33d31ef1ed2b2e157c9cb18bd2454fb5c62690bdd090a48f60 -88772297d2972471b3db71f3ddbf5945a90154768ca49fa6729a5e2299f1795445fb3d4d969d1620e87dca618fbc8a6c -a2bb783fd13aee993e3efd3a963ebc8a8eacfc8450042f018f2040353de88c71ac784b0898bdff27f606c60a3d5ef2c6 -9210903ac619edca0cb8c288ed6dcc93c472f45182cd6614a8e2390801ddea41d48a4ac04a40e2f0adfd48f91aabe2ea -a621d00f83260c22db9fa28757ea81dabcc78b10eeaaf58b06b401db6cc7a7d9a6831a16f171ead4e8506d0c46a752ca -b25c525bf6761a18bbd156ac141df2595940c7b011ed849dbb8ac3a2cd2da6b63ba4755324d70dc14c959deb29fb9ad3 -a35111d0db3e862e1b06249d289e0fc6b110877d254f2ae1604fb21292c227a8b6d87dd17a7b31166038d6860b1bd249 -90bf057309867d95f27637bd10ef15ceb788f07d38aca7ad7920042293d7c4a1a13d4ca1d6db202864d86d20a93e16cf -a88510e110b268d15dcd163ba1e403e44b656771399ac3a049dcb672a1201e88bf60bdd1d303158888a3d30d616cc0bd -b33b7e1f765e9cbd5eeb925e69c39b0a9ea3348ab17f1dbb84b66f4a4b3233e28cbdeb0903d6cfe49ec4fc2f27378ff9 -b777da64fa64d9bc3d2d81b088933fce0e5fcc29c15536159c82af3622a2604c2b968991edea7b6882c9e6f76b544203 -8ea598e402a056fd8031fbf3b9e392347999adc1bd5b68c5797a791a787d006e96918c799467af9ac7f5f57eb30b4f94 -b6901a389bf3b3045e679d015c714d24f8bbe6183349b7f6b42f43409a09f0d5bd4b794012257d735c5fdf6d1812554b -b5866426336d1805447e6efc3f3deb629b945b2781f618df9a2cc48c96020846e9108f9d8507a42ba58d7617cb796c31 -a18ccc6ad1caa8462fa9bec79510689dd2a68d2e8b8e0ddbeb50be4d77728e1d6a18748a11e27edd8d3336c212689a4d -abbd48c48a271b6b7c95518a9352d01a84fb165f7963b87cdc95d5891119a219571a920f0d9ceedc8f9f0de4ab9deb65 -94a4e5f4d7e49229e435530b12a1ff0e9259a44a4f183fb1fe5b7b59970436e19cf932625f83f7b75702fd2456c3b801 -af0a6f2a0d0af7fc72e8cb690f0c4b4b57b82e1034cca3d627e8ef85415adec8eb5df359932c570b1ee077c1d7a5a335 -9728025e03114b9e37ed43e9dcba54a2d67f1c99c34c6139e03d4f9c57c9e28b6b27941d9fca4051d32f9b89bec6537b -941601742d1e1ec8426591733a4f1c13785b0a9b0a6b2275909301a6a3c6c1e2fb1ffa5fdcc08d7fb69f836ae641ced5 -b84b90480defd22f309e294379d1ca324a76b8f0ba13b8496b75a6657494e97d48b0ea5cfdb8e8ac7f2065360e4b1048 -95cc438ee8e370fc857fd36c3679c5660cf6a6c870f56ef8adf671e6bf4b25d1dbad78872cc3989fdfe39b29fc30486d -8aafba32e4a30cad79c5800c8709241b4041b0c13185ea1aa9bc510858709870b931d70b5d9a629f47579b161f1d8af7 -865b0155d9013e80cba57f204c21910edbd4d15e53ae4fee79992cb854dc8b8a73f0a9be92f74893e30eb70f270511bc -b9a49ce58d40b429ac7192cdbf76da31300efc88c827b1e441dd5bdb2f1c180d57808c48992492a2dc5231008629159f -8d1438b10f6cd996494d4c7b5a0841617ec7cf237c9e0956eac04fda3f9ded5110ec99776b816e3c78abd24eb4a9c635 -af2dd18211bb8a3e77c0a49d5773da6e29e4e6fa6632a6eeb56c4be233f6afe81655d977932548de2be16567c54ffbd7 -92b92443f44464f2b48002a966664a4267eae559fa24051983bcf09d81bed5bcc15cb6ff95139d991707697a5d0cc1ab -a1864a2bac0c0dd5b2fb1a79913dd675fe0a5ae08603a9f69d8ca33268239ac7f2fed4f6bf6182a4775683cb9ccd92a8 -948e8f1cf5bd594c5372845b940db4cb2cb5694f62f687952c73eb77532993de2e2d7d974a2ced58730d12c8255c30a2 -aa825c08284fa74a99fcfc473576e8a9788277f72f8c87f29be1dd41229c286c2753ff7444c753767bd8180226763dfc -8384d8d51415e1a4d6fe4324504e958c1b86374cc0513ddf5bcbffabb3edcf4b7d401421e5d1aa9da9010f07ef502677 -8b8223a42585409041d8a6e3326342df02b2fe0bcc1758ff950288e8e4677e3dc17b0641286eaf759a68e005791c249c -a98a98cc2fb14e71928da7f8ce53ab1fb339851c9f1f4bceb5f1d896c46906bd027ef5950ca53b3c8850407439efedd4 -866f44d2e35a4dbffe6cd539b6ef5901924061e37f9a0e7007696fb23526379c9b8d095b417effe1eecda698de744dcb -91774f44bf15edafdf43957fdf254682a97e493eb49d0779c745cb5dbe5d313bf30b372edd343f6d2220475084430a2e -ab52fc3766c499a5f5c838210aada2c3bcc1a2ec1a82f5227d4243df60809ee7be10026642010869cfbf53b335834608 -a0e613af98f92467339c1f3dc4450b7af396d30cefd35713388ccd600a3d7436620e433bf294285876a92f2e845b90d0 -8a1b5ca60a9ae7adc6999c2143c07a855042013d93b733595d7a78b2dc94a9daa8787e2e41b89197a0043343dbd7610f -ae7e4557bc47b1a9af81667583d30d0da0d4a9bb0c922450c04ec2a4ae796c3f6b0ede7596a7a3d4e8a64c1f9ee8ff36 -8d4e7368b542f9f028309c296b4f84d4bde4837350cf71cfe2fa9d4a71bce7b860f48e556db5e72bc21cf994ffdf8e13 -af6ed1fbff52dd7d67d6a0edfa193aa0aab1536979d27dba36e348759d3649779f74b559194b56e9378b41e896c4886f -a069ba90a349ac462cac0b44d02c52a4adf06f40428aef5a2ddff713de31f991f2247fc63426193a3ea1b1e50aa69ded -8750f5f4baf49a5987470f5022921108abe0ead3829ddef00e61aedd71f11b1cdd4be8c958e169440b6a8f8140f4fbf9 -a0c53cefc08a8d125abd6e9731bd351d3d05f078117ff9c47ae6b71c8b8d8257f0d830481f941f0c349fc469f01c9368 -94eea18c5ed056900c8285b05ba47c940dff0a4593b627fdd8f952c7d0122b2c26200861ef3e5c9688511857535be823 -8e1b7bd80d13460787e5060064c65fbcdac000c989886d43c7244ccb5f62dcc771defc6eb9e00bae91b47e23aeb9a21f -b4b23f9dd17d12e145e7c9d3c6c0b0665d1b180a7cfdf7f8d1ab40b501c4b103566570dca2d2f837431b4bf698984cad -847a47c6b225a8eb5325af43026fb9ef737eede996257e63601f80302092516013fde27b93b40ff8a631887e654f7a54 -9582d7afb77429461bd8ebb5781e6390a4dde12a9e710e183581031ccfacd9067686cfaf47584efaafeb1936eae495cc -8e4fd5dbd9002720202151608f49ef260b2af647bd618eb48ebeceeb903b5d855aa3e3f233632587a88dc4d12a482df9 -87b99fe6a9c1d8413a06a60d110d9e56bb06d9f0268dc12e4ab0f17dd6ca088a16ade8f4fb7f15d3322cbe7bfd319ae1 -b562d23002ed00386db1187f519018edd963a72fca7d2b9fcaab9a2213ac862803101b879d1d8ac28d1ccae3b4868a05 -b4cc8b2acacf2ce7219a17af5d42ce50530300029bc7e8e6e2a3c14ff02a5b33f0a7fecb0bb4a7900ea63befa854a840 -9789f0fe18d832ff72df45befa7cabf0a326b42ada3657d164c821c35ac7ed7b2e0eba3d67856e8c387626770059b0c3 -986c6fe6771418549fa3263fa8203e48552d5ecb4e619d35483cb4e348d849851f09692821c9233ae9f16f36979c30c2 -a9160182a9550c5756f35cea1fe752c647d1b64a12426a0b5b8d48af06a12896833ec5f5d9b90185764db0160905ca01 -82614dbd89d54c1e0af4f6ffe8710e6e871f57ef833cbcb3d3d7c617a75ec31e2a459a89ebb716b18fc77867ff8d5d47 -8fc298ffba280d903a7873d1b5232ce0d302201957226cddff120ffe8df9fee34e08420302c6b301d90e3d58f10beeb9 -898da9ac8494e31705bdf684545eee1c99b564b9601877d226d0def9ec67a20e06f8c8ba2a5202cc57a643487b94af19 -88218478d51c3ed2de35b310beedf2715e30208c18f046ee65e824f5e6fd9def921f6d5f75fd6dde47fa670c9520f91a -89703ae7dff9b3bc2a93b44cdbab12c3d8496063a3c658e21a7c2078e4c00be0eecae6379ee8c400c67c879748f1d909 -a44d463477dece0d45abb0ebb5f130bfb9c0a3bbcd3be62adf84a47bbd6938568a89bc92a53ca638ff1a2118c1744738 -95df2b4d392143ee4c39ad72f636d0ed72922de492769c6264015776a652f394a688f1d2b5cf46077d01fda8319ba265 -aa989867375710ed07ad6789bfb32f85bdc71d207f6f838bd3bde9da5a169325481ac326076b72358808bd5c763ba5bb -b859d97d0173920d16bc01eb7d3ddd47273daac72f86c4c30392f8de05fee643e8d6aa8bebdbc5c2d89037bc68a8a105 -b0249ec97411fa39aa06b3d9a6e04bbbcd5e99a7bc527273b6aa95e7ae5f437b495385adaefa4327231562d232c9f822 -8209e156fe525d67e1c83ec2340d50d45eba5363f617f2e5738117cdcc4a829c4cc37639afd7745cbe929c66754fd486 -99fd2728ceb4c62e5f0763337e6d28bf11fbe5df114217f002bc5cd3543c9f62a05a8a41b2e02295360d007eaab796a6 -902ebc68b8372feeaf2e0b40bd6998a0e17981db9cc9d23f932c34fbcc680292a0d8adcea2ad3fb2c9ed89e7019445c2 -8b5653f4770df67f87cb68970555b9131c3d01e597f514e0a399eec8056e4c5a7deed0371a27b3b2be426d8e860bf9f2 -8f5af27fdc98a29c647de60d01b9e9fd0039013003b44ba7aa75a4b9c42c91feb41c8ae06f39e22d3aed0932a137affa -81babb9c1f5bcc0fd3b97d11dd871b1bbd9a56947794ff70ab4758ae9850122c2e78d53cb30db69ece23538dc4ee033e -b8b65d972734f8ecae10dd4e072fa73c9a1bf37484abcfa87e0d2fcecac57294695765f63be87e1ba4ec0eb95688403a -b0fe17d0e53060aef1947d776b06ab5b461a8ef41235b619ca477e3182fadaf9574f12ffc76420f074f82ac4a9aa7071 -ae265c0b90bf064d7a938e224cb1cd3b7eca3e348fbc4f50a29ac0930a803b96e0640992354aa14b303ea313cb523697 -8bc10ffde3224e8668700a3450463ab460ec6f198e1deb016e2c9d1643cc2fe1b377319223f41ffeb0b85afd35400d40 -8d5113b43aea2e0cc6f8ec740d6254698aff7881d72a6d77affd6e6b182909b4de8eb5f524714b5971b418627f15d218 -ae2ef0a401278b7b5d333f0588773ec62ead58807cdee679f72b1af343c1689c5f314989d9e6c9369f8da9ce76979db6 -b9c1cb996a78d4f7793956daaa8d8825dd43c4c37877bc04026db4866144b1bf37aa804d2fe0a63c374cf89e55e9069f -a35f73851081f6540e536a24a28808d478a2bb1fd15ee7ff61b1562e44fbafc0004b9c92c9f96328d546b1287e523e48 -82007f34e3383c628c8f490654369744592aa95a63a72be6e90848ad54f8bc2d0434b62f92a7c802c93017214ecf326e -9127db515b1ed3644c64eaf17a6656e6663838fed4c6612a444a6761636eaaeb6a27b72d0e6d438c863f67b0d3ec25c5 -984c9fcc3deccf83df3bbbb9844204c68f6331f0f8742119ba30634c8c5d786cd708aa99555196cf6563c953816aec44 -a0f9daf900112029474c56ddd9eb3b84af3ed2f52cd83b4eb34531cf5218e7c58b3cab4027b9fc17831e1b6078f3bf4a -90adbcc921369023866a23f5cea7b0e587d129ad71cab0449e2e2137838cea759dec27b0b922c59ac4870ef6146ea283 -8c5650b6b9293c168af98cf60ad35c945a30f5545992a5a8c05d42e09f43b04d370c4d800f474b2323b4269281ca50f8 -868d95be8b34a337b5da5d886651e843c073f324f9f1b4fbd1db14f74aba6559449f94c599f387856c5f8a7bc83b52a1 -812df0401d299c9e95a8296f9c520ef12d9a3dd88749b51eab8c1b7cc97961608ab9fc241a7e2888a693141962c8fd6d -abda319119d8a4d089393846830eee19d5d6e65059bf78713b307d0b4aad245673608b0880aa31c27e96c8d02eff39c0 -887f11ae9e488b99cb647506dcaa5e2518b169ee70a55cd49e45882fe5bfb35ffaf11feb2bf460c17d5e0490b7c1c14d -b36b6e9f95ffff917ca472a38fa7028c38dc650e1e906e384c10fe38a6f55e9b84b56ffa3a429d3b0c3e2cf8169e66a9 -a0450514d20622b7c534f54be3260bab8309632ca21c6093aa0ccc975b8eed33a922cbcc30a730ccc506edf9b188a879 -87cfaf7bcd5d26875ca665ac45f9decd3854701b0443332da0f9b213e69d6f5521ae0217ec375489cd4fad7b4babf724 -842ad67c1baf7a9d4504c10c5c979ce0a4d1b86a263899e2b5757407c2adcdcf7ed58173ad9d156d84075ef8798cb1c4 -ac1a05755fe4d3fb2ab5b951bafe65cca7c7842022ca567b32cddf7741782cbf8c4990c1dd4ea05dc087a4712844aebb -a000c8cecc4fddeb926dc8dd619952bc51d00d7c662e025f973387a3fc8b1ef5c7c10b6a62e963eb785e0ec04cb1ffbe -8a573c9986dbeb469547dfd09f60078eab252d8ec17351fe373a38068af046b0037967f2b3722fa73ed73512afd038d2 -b8dff15dff931f58ba05b6010716c613631d7dd9562ae5138dbec966630bcdb0e72552e4eefc0351a6a6b7912d785094 -990e81fd459433522e8b475e67e847cb342c4742f0dbf71acc5754244ccd1d9ff75919168588d8f18b8aea17092dd2a4 -b012f8644da2113bef7dd6cdc622a55cfa0734bd267b847d11bba2e257a97a2a465c2bb616c240e197ff7b23e2ce8d8e -a659bd590fde467766e2091c34a0b070772f79380be069eef1afecc470368a95afd9eed6520d542c09c0d1a9dca23bd0 -b9239f318b849079477d1cf0a60a3d530391adacd95c449373da1c9f83f03c496c42097c3f9aca10c1b9b3dbe5d98923 -851e9a6add6e4a0ee9994962178d06f6d4fbc0def97feef1ba4c86d3bcf027a59bafa0cf25876ca33e515a1e1696e5cc -803b9c5276eed78092de2f340b2f0d0165349a24d546e495bd275fe16f89a291e4c74c22fdee5185f8fce0c7fbced201 -95915654ca4656d07575168fb7290f50dc5dcbbcdf55a44df9ec25a9754a6571ab8ca8a159bc27d9fa47c35ffd8f7ffd -88f865919764e8e765948780c4fdd76f79af556cd95e56105d603c257d3bfb28f11efca1dfb2ce77162f9a5b1700bac8 -b1233131f666579b4cc8b37cfa160fc10551b1ec33b784b82685251464d3c095cdde53d0407c73f862520aa8667b1981 -a91115a15cf4a83bda1b46f9b9719cfba14ffb8b6e77add8d5a0b61bea2e4ea8ce208e3d4ed8ca1aab50802b800e763a -93553b6c92b14546ae6011a34600a46021ce7d5b6fbfcda2a70335c232612205dbe6bfb1cc42db6d49bd4042c8919525 -8c2a498e5d102e80c93786f13ccf3c9cab7f4c538ccf0aee8d8191da0dbca5d07dff4448383e0cf5146f6d7e629d64f8 -a66ab92c0d2c07ea0c36787a86b63ee200499527c93b9048b4180fc77e0bb0aa919f4222c4bec46eeb3f93845ab2f657 -917e4fc34081a400fc413335fdf5a076495ae19705f8542c09db2f55fa913d6958fa6d711f49ad191aec107befc2f967 -940631a5118587291c48ac8576cdc7e4a904dd9272acb79407a7d3549c3742d9b3669338adbc1386724cc17ee0cc1ca3 -ae23ae3a531900550671fd10447a35d3653c5f03f65b0fdffe092844c1c95d0e67cab814d36e6388db5f8bd0667cd232 -ae545727fca94fd02f43e848f0fbbb1381fd0e568a1a082bf3929434cc73065bfbc9f2c840b270dda8cc2e08cd4d44b0 -8a9bc9b90e98f55007c3a830233c7e5dc3c4760e4e09091ff30ee484b54c5c269e1292ce4e05c303f6462a2a1bd5de33 -a5a2e7515ce5e5c1a05e5f4c42f99835f6fde14d47ecb4a4877b924246038f5bc1b91622e2ff97ed58737ed58319acfa -8fa9f5edf9153618b72b413586e10aaa6c4b6e5d2d9c3e8693ca6b87804c58dc4bf23a480c0f80cb821ebc3cf20ea4fc -925134501859a181913aadac9f07f73d82555058d55a7d5aaa305067fbd0c43017178702facc404e952ea5cfd39db59b -8b5ab1d9b5127cb590d6bddbf698ffe08770b6fc6527023d6c381f39754aecc43f985c47a46be23fe29f6ca170249b44 -aa39c6b9626354c967d93943f4ef09d637e13c505e36352c385b66e996c19c5603b9f0488ad4014bb5fc2e051b2876cc -8e77399c6e9cb8345002195feb7408eb571e6a81c0418590d2d775af7414fc17e61fe0cd37af8e737b59b89c849d3a28 -a0150aeca2ddc9627c7ea0af0dd4426726583389169bc8174fc1597cc8048299cc594b22d234a4e013dff7232b2d946c -98659422ef91f193e6104b09ff607d1ed856bb6baed2a6386c9457efbc748bd1bf436573d80465ebc54f8c340b697ea5 -8d6fb015898d3672eb580e1ffdf623fc4b23076664623b66bfb18f450d29522e8cb9c90f00d28ccf00af34f730bff7ac -996a8538efa9e2937c1caad58dc6564e5c185ada6cdcef07d5ec0056eb1259b0e4cef410252a1b5dbaee0da0b98dac91 -aa0ae2548149d462362a33f96c3ce9b5010ebf202602e81e0ef77e22cfc57ecf03946a3076b6171bea3d3dc9681187d7 -a5ce876b29f6b89050700df46d679bed85690daf7bad5c0df65e6f3bde5673e6055e6c29a4f4dcb82b93ccecf3bad9cc -81d824bb283c2f55554340c3514e15f7f1db8e9e95dd60a912826b1cccb1096f993a6440834dad3f2a5de70071b4b4b5 -914e7291da286a89dfc923749da8f0bf61a04faa3803d6d10633261a717184065dcc4980114ad852e359f79794877dd9 -ae49dc760db497c8e834510fe89419cc81f33fd2a2d33de3e5e680d9a95a0e6a3ccbdf7c0953beeb3d1caf0a08b3e131 -b24f527d83e624d71700a4b238016835a2d06f905f3740f0005105f4b2e49fc62f7e800e33cdc900d805429267e42fc0 -b03471ecaa7a3bf54503347f470a6c611e44a3cee8218ad3fcad61d286cfb7bb6a1113dad18475ec3354a71fcc4ec1e2 -881289b82b30aff4c8f467c2a25fced6064e1eece97c0de083e224b21735da61c51592a60f2913e8c8ba4437801f1a83 -b4ce59c0fc1e0ecad88e79b056c2fd09542d53c40f41dea0f094b7f354ad88db92c560b9aeb3c0ef48137b1a0b1c3f95 -a1ffb30eb8ef0e3ea749b5f300241ebe748ed7cf480e283dfcda7380aa1c15347491be97e65bc96bdf3fe62d8b74b3ae -b8954a826c59d18c6bfab24719f8730cc901868a95438838cd61dac468a2d79b1d42f77284e86e3382bf4f2a22044927 -818e7e7c59b6b5e22b3c2c19c163f2e787f2ff3758d395a4da02766948935eb44413c3ddd2bf45804a3c19744aa332f3 -a29556e49866e4e6f01d4f042eed803beeda781462884a603927791bd3750331a11bc013138f3270c216ab3aa5d39221 -b40885fa0287dc92859b8b030c7cca4497e96c387dcfe6ed13eb7f596b1eb18fb813e4ae139475d692f196431acb58fe -89cd634682fd99ee74843ae619832780cf7cd717f230ea30f0b1821caf2f312b41c91f459bdba723f780c7e3eed15676 -b48c550db835750d45a7f3f06c58f8f3bf8766a441265ca80089ead0346f2e17cbb1a5e843557216f5611978235e0f83 -90936ee810039783c09392857164ab732334be3a3b9c6776b8b19f5685379c623b1997fb0cdd43af5061d042247bc72f -a6258a6bae36525794432f058d4b3b7772ba6a37f74ef1c1106c80a380fc894cbeac4f340674b4e2f7a0f9213b001afd -8f26943a32cf239c4e2976314e97f2309a1c775777710393c672a4aab042a8c6ee8aa9ac168aed7c408a436965a47aeb -820f793573ca5cc3084fe5cef86894c5351b6078df9807d4e1b9341f9d5422dd29d19a73b0843a14ad63e8827a75d2da -a3c4fca786603cd28f2282ba02afe7cf9287529e0e924ca90d6cdfd1a3912478ebb3076b370ee72e00df5517134fe17f -8f3cdabd0b64a35b9ee9c6384d3a8426cc49ae6063632fb1a56a0ae94affa833955f458976ff309dafd0b2dd540786ae -945a0630cd8fa111cfd776471075e5d2bbe8eb7512408b5c79c8999bfaeca6c097f988fb1c38fa9c1048bac2bca19f2e -8a7f6c4e0ba1920c98d0b0235b4dda73b631f511e209b10c05c550f51e91b4ba3893996d1562f04ac7105a141464e0e9 -ab3c13d8b78203b4980412edc8a8f579e999bf79569e028993da9138058711d19417cf20b477ef7ed627fa4a234c727a -82b00d9a3e29ed8d14c366f7bb25b8cfe953b7be275db9590373a7d8a86ea927d56dc3070a09ef7f265f6dd99a7c896e -b6e48a282de57949821e0c06bc9ba686f79e76fb7cbf50ea8b4651ccd29bc4b6da67efea4662536ba9912d197b78d915 -a749e9edcba6b4f72880d3f84a493f4e8146c845637009f6ff227ff98521dbbe556a3446340483c705a87e40d07364bc -b9b93c94bd0603ce5922e9c4c29a60066b64a767b3aed81d8f046f48539469f5886f14c09d83b5c4742f1b03f84bb619 -afa70b349988f85ed438faafa982df35f242dd7869bda95ae630b7fd48b5674ef0f2b4d7a1ca8d3a2041eff9523e9333 -a8e7e09b93010982f50bd0930842898c0dcd30cdb9b123923e9d5ef662b31468222fc50f559edc57fcfdc597151ebb6e -8ce73be5ac29b0c2f5ab17cae32c715a91380288137d7f8474610d2f28d06d458495d42b9cb156fb1b2a7dfdcc437e1c -85596c1d81f722826d778e62b604eb0867337b0204c9fae636399fa25bb81204b501e5a5912654d215ec28ff48b2cb07 -96ff380229393ea94d9d07e96d15233f76467b43a3e245ca100cbecbdbb6ad8852046ea91b95bb03d8c91750b1dfe6e1 -b7417d9860b09f788eb95ef89deb8e528befcfa24efddbc18deaf0b8b9867b92361662db49db8121aeea85a9396f64fd -97b07705332a59cdba830cc8490da53624ab938e76869b2ce56452e696dcc18eb63c95da6dffa933fb5ffb7585070e2d -971f757d08504b154f9fc1c5fd88e01396175b36acf7f7abcfed4fff0e421b859879ed268e2ac13424c043b96fbe99fc -b9adb5d3605954943a7185bddf847d4dbe7bafe970e55dc0ec84d484967124c26dd60f57800d0a8d38833b91e4da476a -b4856741667bb45cae466379d9d6e1e4191f319b5001b4f963128b0c4f01819785732d990b2f5db7a3452722a61cd8cc -a81ec9f2ab890d099fb078a0c430d64e1d06cbbe00b1f140d75fc24c99fe35c13020af22de25bbe3acf6195869429ba5 -99dcea976c093a73c08e574d930d7b2ae49d7fe43064c3c52199307e54db9e048abe3a370b615798b05fe8425a260ba0 -a1f7437c0588f8958b06beb07498e55cd6553429a68cd807082aa4cc031ab2d998d16305a618b3d92221f446e6cd766d -806e4e0958e0b5217996d6763293f39c4f4f77016b3373b9a88f7b1221728d14227fce01b885a43b916ff6c7a8bc2e06 -8e210b7d1aff606a6fc9e02898168d48ec39bc687086a7fe4be79622dd12284a5991eb53c4adfe848251f20d5bfe9de0 -82810111e10c654a6c07cbfd1aff66727039ebc3226eef8883d570f25117acf259b1683742f916ac287097223afc6343 -92f0e28cca06fd543f2f620cc975303b6e9a3d7c96a760e1d65b740514ccd713dc7a27a356a4be733570ca199edd17ba -900810aa4f98a0d6e13baf5403761a0aeb6422249361380c52f98b2c79c651e3c72f7807b5b5e3a30d65d6ff7a2a9203 -b0740bfefea7470c4c94e85185dbe6e20685523d870ff3ef4eb2c97735cef41a6ab9d8f074a37a81c35f3f8a7d259f0e -af022e98f2f418efbbe2de6fefb2aa133c726174f0f36925a4eafd2c6fd6c744edb91386bafb205ce13561de4294f3a6 -95e4592e21ba97e950abb463e1bc7b0d65f726e84c06a98eb200b1d8bfc75d4b8cff3f55924837009e88272542fd25ec -b13bd6b18cd8a63f76c9831d547c39bbd553bda66562c3085999c4da5e95b26b74803d7847af86b613a2e80e2f08caae -a5625658b474a95aba3e4888c57d82fb61c356859a170bc5022077aa6c1245022e94d3a800bf7bd5f2b9ab1348a8834e -a097ee9e6f1d43e686df800c6ce8cfc1962e5a39bb6de3cf5222b220a41b3d608922dae499bce5c89675c286a98fdabd -94230ba8e9a5e9749cd476257b3f14a6bf9683e534fb5c33ca21330617533c773cb80e508e96150763699ad6ecd5aee7 -b5fea7e1f4448449c4bc5f9cc01ac32333d05f464d0ed222bf20e113bab0ee7b1b778cd083ceae03fdfd43d73f690728 -a18a41a78a80a7db8860a6352642cdeef8a305714543b857ca53a0ee6bed70a69eeba8cfcf617b11586a5cc66af4fc4f -85d7f4b3ff9054944ac80a51ef43c04189d491e61a58abed3f0283d041f0855612b714a8a0736d3d25c27239ab08f2ec -b1da94f1e2aedd357cb35d152e265ccfc43120825d86733fa007fc1e291192e8ff8342306bef0c28183d1df0ccec99d0 -852893687532527d0fbeea7543ac89a37195eadab2f8f0312a77c73bdeed4ad09d0520f008d7611539425f3e1b542cfd -99e3bd4d26df088fc9019a8c0b82611fd4769003b2a262be6b880651d687257ded4b4d18ccb102cba48c5e53891535e4 -98c407bc3bbc0e8f24bedf7a24510a5d16bce1df22940515a4fbdacd20d06d522ef9405f5f9b9b55964915dd474e2b5c -80de0a12f917717c6fc9dc3ccc9732c28bae36cff4a9f229d5eaf0d3e43f0581a635ba2e38386442c973f7cb3f0fdfa7 -94f9615f51466ae4bb9c8478200634b9a3d762d63f2a16366849096f9fc57f56b2e68fe0ca5d4d1327a4f737b3c30154 -a3dcbe16499be5ccb822dfcd7c2c8848ba574f73f9912e9aa93d08d7f030b5076ca412ad4bf6225b6c67235e0ab6a748 -98f137bf2e1aea18289750978feb2e379054021e5d574f66ca7b062410dcfe7abb521fab428f5b293bbe2268a9af3aa4 -8f5021c8254ba426f646e2a15b6d96b337a588f4dfb8cbae2d593a4d49652ca2ada438878de5e7c2dbbd69b299506070 -8cc3f67dd0edcdb51dfd0c390586622e4538c7a179512f3a4f84dd7368153a28b1cf343afd848ac167cb3fcaa6aee811 -863690f09ac98484d6189c95bc0d9e8f3b01c489cb3f9f25bf7a13a9b6c1deaf8275ad74a95f519932149d9c2a41db42 -8494e70d629543de6f937b62beca44d10a04875bd782c9a457d510f82c85c52e6d34b9c3d4415dd7a461abbcc916c3c4 -925b5e1e38fbc7f20371b126d76522c0ea1649eb6f8af8efb389764ddcf2653775ef99a58a2dcf1812ce882964909798 -94d0494dcc44893c65152e7d42f4fb0dc46af5dc5674d3c607227160447939a56d9f9ea2b3d3736074eef255f7ec7566 -b0484d33f0ef80ff9b9d693c0721c77e518d0238918498ddf71f14133eb484defb9f9f7b9083d52bc6d6ba2012c7b036 -8979e41e0bb3b501a7ebbd024567ce7f0171acfea8403a530fe9e791e6e859dfbd60b742b3186d7cf5ab264b14d34d04 -af93185677d39e94a2b5d08867b44be2ba0bb50642edca906066d80facde22df4e6a7a2bd8b2460a22bdf6a6e59c5fdd -90f0ef0d7e7ab878170a196da1b8523488d33e0fde7481f6351558b312d00fa2b6b725b38539063f035d2a56a0f5e8f1 -a9ca028ccb373f9886574c2d0ea5184bc5b94d519aa07978a4814d649e1b6c93168f77ae9c6aa3872dd0eea17968ec22 -82e7aa6e2b322f9f9c180af585b9213fb9d3ad153281f456a02056f2d31b20d0f1e8807ff0c85e71e7baca8283695403 -affce186f842c547e9db2dffc0f3567b175be754891f616214e8c341213cbf7345c9ecd2f704bb0f4b6eba8845c8d8a7 -ab119eb621fade27536e98c6d1bc596388bb8f5cad65194ea75c893edbe6b4d860006160f1a9053aea2946bd663e5653 -99cd2c1c38ead1676657059dc9b43d104e8bd00ae548600d5fc5094a4d875d5b2c529fac4af601a262045e1af3892b5e -b531a43b0714cc638123487ef2f03dfb5272ff399ff1aa67e8bc6a307130d996910fb27075cbe53050c0f2902fc32ffe -923b59ac752c77d16b64a2d0a5f824e718460ef78d732b70c4c776fecc43718ecfaf35f11afbb544016232f445ecab66 -a53439cd05e6e1633cdce4a14f01221efcd3f496ac1a38331365c3cadc30013e5a71600c097965927ee824b9983a79cb -8af976ffab688d2d3f9e537e2829323dda9abf7f805f973b7e0a01e25c88425b881466dee37b25fda4ea683a0e7b2c03 -92e5f40230a9bfbb078fa965f58912abb753b236f6a5c28676fb35be9b7f525e25428160caeaf0e3645f2be01f1a6599 -8c4e7b04e2f968be527feba16f98428508a157b7b4687399df87666a86583b4446a9f4b86358b153e1660bb80bd92e8b -97cd622d4d8e94dceb753c7a4d49ea7914f2eb7d70c9f56d1d9a6e5e5cc198a3e3e29809a1d07d563c67c1f8b8a5665a -967bfa8f411e98bec142c7e379c21f5561f6fd503aaf3af1a0699db04c716c2795d1cb909cccbcb917794916fdb849f1 -b3c18a6caa5ca2be52dd500f083b02a4745e3bcaed47b6a000ce7149cee4ed7a78d2d7012bf3731b1c15c6f04cbd0bd1 -b3f651f1f84026f1936872956a88f39fcfe3e5a767233349123f52af160f6c59f2c908c2b5691255561f0e70620c8998 -ae23b59dc2d81cec2aebcaaf607d7d29cf588f0cbf7fa768c422be911985ca1f532bb39405f3653cc5bf0dcba4194298 -a1f4da396f2eec8a9b3252ea0e2d4ca205f7e003695621ae5571f62f5708d51ca3494ac09c824fca4f4d287a18beea9a -a036fa15e929abed7aac95aa2718e9f912f31e3defd224e5ed379bf6e1b43a3ad75b4b41208c43d7b2c55e8a6fedca72 -80e8372d8a2979ee90afbdb842624ace72ab3803542365a9d1a778219d47f6b01531185f5a573db72213ab69e3ffa318 -af68b5cdc39e5c4587e491b2e858a728d79ae7e5817a93b1ea39d34aec23dea452687046c8feae4714def4d0ed71da16 -b36658dfb756e7e9eec175918d3fe1f45b398679f296119cd53be6c6792d765ef5c7d5afadc5f3886e3f165042f4667f -ad831da03b759716f51099d7c046c1a8e7bf8bb45a52d2f2bfd769e171c8c6871741ef8474f06e2aca6d2b141cf2971f -8bae1202dde053c2f59efc1b05cb8268ba9876e4bd3ff1140fa0cc5fa290b13529aede965f5efdff3f72e1a579efc9cc -86344afbc9fe077021558e43d2a032fcc83b328f72948dba1a074bb1058e8a8faec85b1c019fc9836f0d11d2585d69c8 -831d1fc7aa28f069585d84c46bdc030d6cb12440cfaae28098365577fc911c4b8f566d88f80f3a3381be2ec8088bf119 -899de139797ac1c8f0135f0656f04ad4f9b0fa2c83a264d320eb855a3c0b9a4907fc3dc01521d33c07b5531e6a997064 -855bc752146d3e5b8ba7f382b198d7dc65321b93cdfc76250eabc28dba5bbf0ad1be8ccda1adf2024125107cb52c6a6e -af0aeccab48eb35f8986cabf07253c5b876dd103933e1eee0d99dc0105936236b2a6c413228490ed3db4fa69aab51a80 -ae62e9d706fbf535319c909855909b3deba3e06eaf560803fa37bce3b5aab5ea6329f7609fea84298b9da48977c00c3b -823a8d222e8282d653082d55a9508d9eaf9703ce54d0ab7e2b3c661af745a8b6571647ec5bd3809ae6dddae96a220ea7 -a4c87e0ea142fc287092bc994e013c85e884bc7c2dde771df30ca887a07f955325c387b548de3caa9efa97106da8176a -b55d925e2f614f2495651502cf4c3f17f055041fa305bb20195146d896b7b542b1e45d37fa709ca4bfc6b0d49756af92 -b0ebe8947f8c68dc381d7bd460995340efcbb4a2b89f17077f5fde3a9e76aef4a9a430d1f85b2274993afc0f17fdbead -8baaa640d654e2652808afd68772f6489df7cad37b7455b9cd9456bdddae80555a3f84b68906cc04185b8462273dcfc9 -add9aa08f827e7dc292ac80e374c593cd40ac5e34ad4391708b3db2fe89550f293181ea11b5c0a341b5e3f7813512739 -909e31846576c6bdd2c162f0f29eea819b6125098452caad42451491a7cde9fd257689858f815131194200bca54511f4 -abc4b34098db10d71ce7297658ef03edfa7377bd7ed36b2ffbab437f8fd47a60e2bcfbc93ff74c85cfce74ca9f93106c -857dbecc5879c1b952f847139484ef207cecf80a3d879849080758ef7ac96acfe16a11afffb42daf160dc4b324279d9b -aab0b49beecbcf3af7c08fbf38a6601c21061bed7c8875d6e3c2b557ecb47fd93e2114a3b09b522a114562467fcd2f7d -94306dec35e7b93d43ed7f89468b15d3ce7d7723f5179cacc8781f0cf500f66f8c9f4e196607fd14d56257d7df7bf332 -9201784d571da4a96ef5b8764f776a0b86615500d74ec72bc89e49d1e63a3763b867deca07964e2f3914e576e2ca0ded -aabe1260a638112f4280d3bdea3c84ce3c158b81266d5df480be02942cecf3de1ac1284b9964c93d2db33f3555373dcc -8ef28607ca2e0075aa07de9af5a0f2d0a97f554897cab8827dfe3623a5e9d007d92755d114b7c390d29e988b40466db9 -87a9b1b097c3a7b5055cd9cb0c35ba6251c50e21c74f6a0bca1e87e6463efc38385d3acc9d839b4698dfa2eb4cb7a2ef -aee277e90d2ffce9c090295c575e7cd3bafc214d1b5794dd145e6d02d987a015cb807bd89fd6268cd4c59350e7907ee2 -836ad3c9324eaa5e022e9835ff1418c8644a8f4cd8e4378bd4b7be5632b616bb6f6c53399752b96d77472f99ece123cd -8ffffdb67faa5f56887c834f9d489bb5b4dab613b72eac8abf7e4bcb799ccd0dbd88a2e73077cadf7e761cb159fb5ec5 -9158f6cd4f5e88e6cdb700fddcbc5a99b2d31a7a1b37dce704bd9dd3385cca69607a615483350a2b1153345526c8e05d -a7ff0958e9f0ccff76742fc6b60d2dd91c552e408c84172c3a736f64acb133633540b2b7f33bc7970220b35ce787cd4e -8f196938892e2a79f23403e1b1fb4687a62e3a951f69a7874ec0081909eb4627973a7a983f741c65438aff004f03ba6f -97e3c1981c5cdb0a388f1e4d50b9b5b5f3b86d83417831c27b143698b432bb5dba3f2e590d6d211931ed0f3d80780e77 -903a53430b87a7280d37816946245db03a49e38a789f866fe00469b7613ee7a22d455fb271d42825957282c8a4e159d9 -b78955f686254c3994f610e49f1c089717f5fb030da4f9b66e9a7f82d72381ba77e230764ab593335ff29a1874848a09 -938b6d04356b9d7c8c56be93b0049d0d0c61745af7790edf4ef04e64de2b4740b038069c95be5c91a0ba6a1bb38512a9 -a769073b9648fe21bc66893a9ef3b8848d06f4068805a43f1c180fdd0d37c176b4546f8e5e450f7b09223c2f735b006f -863c30ebe92427cdd7e72d758f2c645ab422e51ecef6c402eb1a073fd7f715017cd58a2ad1afe7edccdf4ff01309e306 -a617b0213d161964eccfc68a7ad00a3ee4365223b479576e887c41ef658f846f69edf928bd8da8785b6e9887031f6a57 -a699834bf3b20d345082f13f360c5f8a86499e498e459b9e65b5a56ae8a65a9fcb5c1f93c949391b4795ef214c952e08 -9921f1da00130f22e38908dd2e44c5f662ead6c4526ebb50011bc2f2819e8e3fca64c9428b5106fa8924db76b7651f35 -98da928be52eb5b0287912fd1c648f8bbda00f5fd0289baf161b5a7dbda685db6ad6bdc121bc9ffa7ed6ae03a13dbee3 -927b91d95676ff3c99de1312c20f19251e21878bfb47ad9f19c9791bc7fb9d6f5c03e3e61575c0760180d3445be86125 -b8e4977a892100635310dfcb46d8b74931ac59ae687b06469b3cee060888a3b6b52d89de54e173d9e1641234754b32b1 -98f6fd5f81ca6e2184abd7a3a59b764d4953d408cec155b4e5cf87cd1f6245d8bdd58b52e1e024e22903e85ae15273f1 -909aaacbbfe30950cf7587faa190dc36c05e3c8131749cc21a0c92dc4afc4002275762ca7f66f91aa751b630ad3e324d -91712141592758f0e43398c075aaa7180f245189e5308e6605a6305d01886d2b22d144976b30460d8ce17312bb819e8f -947d85cb299b189f9116431f1c5449f0f8c3f1a70061aa9ebf962aa159ab76ee2e39b4706365d44a5dbf43120a0ac255 -b39eced3e9a2e293e04d236976e7ee11e2471fe59b43e7b6dd32ab74f51a3d372afee70be1d90af017452ec635574e0e -8a4ba456491911fc17e1cadcbb3020500587c5b42cf6b538d1cb907f04c65c168add71275fbf21d3875e731404f3f529 -8f6858752363e2a94c295e0448078e9144bf033ccd4d74f4f6b95d582f3a7638b6d3f921e2d89fcd6afd878b12977a9d -b7f349aa3e8feb844a56a42f82b6b00f2bfe42cab19f5a68579a6e8a57f5cf93e3cdb56cbbb9163ab4d6b599d6c0f6aa -a4a24dc618a6b4a0857fb96338ac3e10b19336efc26986e801434c8fdde42ca8777420722f45dfe7b67b9ed9d7ce8fb1 -aafe4d415f939e0730512fc2e61e37d65c32e435991fb95fb73017493014e3f8278cd0d213379d2330b06902f21fe4e1 -845cc6f0f0a41cc6a010d5cb938c0ef8183ff5ed623b70f7ea65a8bdbc7b512ea33c0ee8b8f31fdf5f39ec88953f0c1e -811173b4dd89d761c0bdffe224cd664ef303c4647e6cf5ef0ed665d843ed556b04882c2a4adfc77709e40af1cfdea40b -93ba1db7c20bfba22da123b6813cb38c12933b680902cef3037f01f03ab003f76260acc12e01e364c0d0cf8d45fca694 -b41694db978b2cf0f4d2aa06fcfc4182d65fb7c9b5e909650705f779b28e47672c47707d0e5308cd680c5746c37e1bc7 -a0e92c4c5be56a4ccf1f94d289e453a5f80e172fc90786e5b03c1c14ce2f3c392c349f76e48a7df02c8ae535326ea8fe -96cbeb1d0693f4f0b0b71ad30def5ccc7ad9ebe58dbe9d3b077f2ac16256cde10468875e4866d63e88ce82751aaf8ef6 -935b87fd336f0bf366046e10f7c2f7c2a2148fa6f53af5607ad66f91f850894527ecec7d23d81118d3b2ee23351ed6ed -b7c2c1fa6295735f6b31510777b597bc8a7bfb014e71b4d1b5859be0d8d64f62a1587caafc669dfe865b365eb27bd94f -b25d93af43d8704ffd53b1e5c16953fd45e57a9a4b7acfcfa6dd4bf30ee2a8e98d2a76f3c8eba8dc7d08d9012b9694c6 -b5a005cd9f891e33882f5884f6662479d5190b7e2aec1aa5a6d15a8cb60c9c983d1e7928e25e4cf43ec804eaea1d97b0 -93f9f0725a06e4a0fb83892102b7375cf5438b5ebc9e7be5a655f3478d18706cf7dbb1cd1adcee7444c575516378aa1b -900d7cbf43fd6ac64961287fe593c08446874bfc1eb09231fc93de858ac7a8bca496c9c457bced5881f7bf245b6789e0 -90c198526b8b265d75160ef3ed787988e7632d5f3330e8c322b8faf2ac51eef6f0ce5a45f3b3a890b90aecf1244a3436 -b499707399009f9fe7617d8e73939cb1560037ad59ac9f343041201d7cc25379df250219fd73fa012b9ade0b04e92efa -94415f6c3a0705a9be6a414be19d478181d82752b9af760dda0dbd24a8ff0f873c4d89e61ad2c13ebf01de55892d07fa -90a9f0b9f1edb87751c696d390e5f253586aae6ebfc31eb3b2125d23877a497b4aa778de8b11ec85efe49969021eaa5a -a9942c56506e5cd8f9289be8205823b403a2ea233ba211cf72c2b3827064fd34cd9b61ff698a4158e7379891ca4120d8 -83bb2ee8c07be1ab3a488ec06b0c85e10b83a531758a2a6741c17a3ccfa6774b34336926a50e11c8543d30b56a6ac570 -8a08a3e5ebe10353e0b7fff5f887e7e25d09bb65becf7c74a03c60c166132efaada27e5aea242c8b9f43b472561ae3ed -957c7a24cefaa631fe8a28446bc44b09a3d8274591ade53ba489757b854db54820d98df47c8a0fbee0e094f8ad7a5dc4 -b63556e1f47ed3ee283777ed46b69be8585d5930960d973f8a5a43508fc56000009605662224daec2de54ea52a8dcd82 -abed2b3d16641f0f459113b105f884886d171519b1229758f846a488c7a474a718857323c3e239faa222c1ab24513766 -882d36eed6756d86335de2f7b13d753f91c0a4d42ef50e30195cc3e5e4f1441afa5ff863022434acb66854eda5de8715 -a65ea7f8745bb8a623b44e43f19158fd96e7d6b0a5406290f2c1348fc8674fbfc27beb4f724cc2b217c6042cb82bc178 -a038116a0c76af090a069ca289eb2c3a615b96093efacfe68ea1610890b291a274e26b445d34f414cfec00c333906148 -90294f452f8b80b0a47c3bcb6e30bdd6854e3b01deaf93f5e82a1889a4a1036d17ecb59b48efa7dc41412168d7a523dd -88faf969c8978a756f48c6114f7f33a1ca3fd7b5865c688aa9cd32578b1f7ba7c06120502f8dc9aee174ecd41597f055 -8883763b2762dfff0d9be9ac19428d9fd00357ac8b805efda213993152b9b7eb7ba3b1b2623015d60778bffda07a724d -a30a1a5a9213636aa9b0f8623345dc7cf5c563b906e11cc4feb97d530a1480f23211073dcb81105b55193dcde5a381d2 -b45ee93c58139a5f6be82572d6e14e937ef9fcbb6154a2d77cb4bf2e4b63c5aabc3277527ecf4e531fe3c58f521cc5e3 -ac5a73e4f686978e06131a333f089932adda6c7614217fcaf0e9423b96e16fd73e913e5e40bf8d7800bed4318b48d4b1 -b6c1e6cdd14a48a7fe27cd370d2e3f7a52a91f3e8d80fb405f142391479f6c6f31aa5c59a4a0fdc9e88247c42688e0cf -ab1760530312380152d05c650826a16c26223960fc8e3bf813161d129c01bac77583eff04ce8678ff52987a69886526b -a4252dffae7429d4f81dfaeeecc48ab922e60d6a50986cf063964f282e47407b7e9c64cf819da6f93735de000a70f0b2 -94c19f96d5ecf4a15c9c5a24598802d2d21acbbd9ee8780b1bc234b794b8442437c36badc0a24e8d2cff410e892bb1d2 -89fafe1799cf7b48a9ea24f707d912fccb99a8700d7287c6438a8879f3a3ca3e60a0f66640e31744722624139ba30396 -b0108405df25cf421c2f1873b20b28552f4d5d1b4a0bf1c202307673927931cbd59f5781e6b8748ddb1206a5ec332c0b -aa0f0e7d09f12b48f1e44d55ec3904aa5707e263774126e0b30f912e2f83df9eb933ca073752e6b86876adaf822d14ba -b0cbe8abb58876d055c8150d9fdbde4fea881a517a2499e7c2ea4d55c518a3c2d00b3494f6a8fd1a660bfca102f86d2a -b1ef80ec903bac55f58b75933dc00f1751060690fd9dfb54cf448a7a4b779c2a80391f5fda65609274bd9e0d83f36141 -8b52e05b1845498c4879bb12816097be7fc268ce1cf747f83a479c8e08a44159fc7b244cf24d55aca06dccf0b97d11e1 -b632a2fc4fdb178687e983a2876ae23587fd5b7b5e0bb8c0eb4cfe6d921a2c99894762e2aaccdc5da6c48da3c3c72f6c -953ef80ab5f74274ae70667e41363ae6e2e98ccbd6b7d21f7283f0c1cafb120338b7a8b64e7c189d935a4e5b87651587 -b929cfd311017c9731eed9d08d073f6cf7e9d4cd560cddd3fdcb1149ab20c6610a7674a66a3616785b13500f8f43ee86 -870fb0d02704b6a328e68721fb6a4b0f8647681bfcb0d92ec3e241e94b7a53aecc365ed384e721c747b13fbf251002f1 -979501159833a8ba5422ed9b86f87b5961711f5b474d8b0e891373fe2d0b98ff41a3a7a74a8b154615bb412b662a48be -b20f9c13cdeceef67f877b3878839ef425f645b16a69c785fe38f687c87a03b9de9ae31ac2edb1e1dd3a9f2c0f09d35d -8c7705ed93290731b1cf6f3bf87fc4d7159bb2c039d1a9f2246cda462d9cdf2beef62d9f658cfeea2e6aef7869a6fc00 -aa439eb15705ad729b9163daee2598d98a32a8a412777c0d12fd48dc7796d422227a014705e445cc9d66f115c96bbc24 -a32307e16f89749fe98b5df1effef0429801c067e0d8067794e56b01c4fef742ad5e7ab42a1a4cc4741808f47a0b7cb8 -b31e65c549003c1207258a2912a72f5bad9844e18f16b0773ea7af8ff124390eb33b2f715910fc156c104572d4866b91 -85608d918ed7b08a0dc03aee60ea5589713304d85eee7b4c8c762b6b34c9355d9d2e192575af0fd523318ae36e19ae1c -a6497dbaf0e7035160b7a787150971b19cf5ba272c235b0113542288611ebecefa2b22f08008d3f17db6a70a542c258d -87862adb1ac0510614ab909457c49f9ec86dc8bdf0e4682f76d2739df11f6ffcfb59975527f279e890d22964a1fba9b6 -8717ac3b483b3094c3b642f3fafe4fbafc52a5d4f2f5d43c29d9cfe02a569daee34c178ee081144494f3a2ca6e67d7b1 -855100ac1ec85c8b437fdd844abaa0ca4ac9830a5bdd065b68dafb37046fcf8625dd482dc0253476926e80a4c438c9ec -ae74821bf265ca3c8702c557cf9ef0732ede7ef6ed658283af669d19c6f6b6055aca807cf2fa1a64785ec91c42b18ae5 -812a745b1419a306f7f20429103d6813cbdea68f82ff635ac59da08630cd61bda6e0fa9a3735bfd4378f58ad179c1332 -867dbbfe0d698f89451c37ca6d0585fd71ee07c3817e362ef6779b7b1d70b27c989cdd5f85ac33a0498db1c4d14521fe -84db735d3eb4ff7f16502dccc3b604338c3a4a301220ad495991d6f507659db4b9f81bba9c528c5a6114bcdba0160252 -aadc83d1c4e5e32bf786cfb26f2f12a78c8024f1f5271427b086370cdef7a71d8a5bf7cd7690bae40df56c38b1ad2411 -a27860eb0caaea37298095507f54f7729d8930ac1929de3b7a968df9737f4c6da3173bda9d64ff797ed4c6f3a1718092 -a3cdcaa74235c0440a34171506ed03d1f72b150d55904ce60ec7b90fcd9a6f46f0e45feab0f9166708b533836686d909 -b209a30bdac5c62e95924928f9d0d0b4113ebb8b346d7f3a572c024821af7f036222a3bd38bd8efd2ee1dbf9ac9556cd -83c93987eff8bc56506e7275b6bef0946672621ded641d09b28266657db08f75846dcbde80d8abc9470e1b24db4ca65b -800c09b3ee5d0251bdaef4a82a7fe8173de997cc1603a2e8df020dd688a0c368ad1ebef016b35136db63e774b266c74c -93fb52de00d9f799a9bce3e3e31aaf49e0a4fc865473feb728217bd70f1bc8a732ec37ac3582bf30ab60e8c7fdf3cb8d -a1aff6b4a50d02f079a8895c74443539231bfdf474600910febf52c9151da7b31127242334ac63f3093e83a047769146 -8c4532d8e3abb5f0da851138bfa97599039bcd240d87bbdf4fd6553b2329abb4781074b63caf09bc724ceb4d36cb3952 -8bd9b0ae3da5acda9eb3881172d308b03beec55014cd73b15026299541c42fd38bab4983a85c06894ebb7a2af2a23d4c -979441e7f5a0e6006812f21b0d236c5f505bb30f7d023cb4eb84ec2aa54a33ac91d87ece704b8069259d237f40901356 -a1c6d2d82e89957d6a3e9fef48deb112eb00519732d66d55aa0f8161e19a01e83b9f7c42ac2b94f337dcc9865f0da837 -97a0b8e04e889d18947d5bf77d06c25bbd62b19ce4be36aaa90ddbeafd93a07353308194199ba138efaadf1b928cd8d2 -822f7fbe9d966b8ec3db0fc8169ab39334e91bf027e35b8cc7e1fe3ead894d8982505c092f15ddfe5d8f726b360ac058 -a6e517eedd216949e3a10bf12c8c8ddbfde43cddcd2c0950565360a38444459191bdbc6c0af0e2e6e98bc6a813601c6d -858b5f15c46c074adb879b6ba5520966549420cb58721273119f1f8bc335605aeb4aa6dbe64aae9e573ca7cc1c705cdc -b5191bb105b60deb10466d8114d48fb95c4d72036164dd35939976e41406dff3ee3974c49f00391abfad51b695b3258c -b1b375353ed33c734f4a366d4afad77168c4809aff1b972a078fd2257036fd6b7a7edad569533abf71bc141144a14d62 -a94c502a9cdd38c0a0e0187de1637178ad4fa0763887f97cc5bdd55cb6a840cb68a60d7dbb7e4e0e51231f7d92addcff -8fe2082c1b410486a3e24481ae0630f28eb5b488e0bb2546af3492a3d9318c0d4c52db1407e8b9b1d1f23a7ffbaf260a -b73fe7aa2b73f9cae6001af589bf8a9e73ea2bb3bb01b46743e39390c08d8e1be5e85a3d562857a9c9b802b780c78e6d -8e347f51330ae62275441ccd60f5ac14e1a925a54ced8a51893d956acc26914df1bb8595385d240aa9b0e5ada7b520ea -8dc573d6357c0113b026a0191a5807dbe42dcd2e19772d14b2ca735e1e67c70e319ef571db1f2a20e62254ed7fb5bcd6 -a5dacbe51549fe412e64af100b8b5eba5ec2258cc2a7c27a34bc10177d1894baf8707886d2f2ef438f077596a07681e9 -8349153c64961d637a5ff56f49003cb24106de19a5bbcf674016a466bfbe0877f5d1e74ccb7c2920665ef90a437b1b7e -96ad35429d40a262fdc8f34b379f2e05a411057d7852c3d77b9c6c01359421c71ef8620f23854e0f5d231a1d037e3a0d -b52385e40af0ed16e31c2154d73d1517e10a01435489fc801fbea65b92b3866ab46dab38d2c25e5fb603b029ae727317 -8e801c7a3e8fa91d9c22ebd3e14a999023a7b5beea13ec0456f7845425d28c92452922ca35ec64012276acb3bbc93515 -a8630870297d415e9b709c7f42aa4a32210b602f03a3015410123f0988aea2688d8bcfc6d07dc3602884abbf6199b23f -8cd518392e09df2a3771a736f72c05af60efc030d62dbbb9cd68dc6cbbe1fb0854eb78b6ed38337010eb1bb44a5d5d30 -921aa4c66590f6c54bf2fa2b324f08cbe866329cc31f6e3477f97f73e1a1721d5eb50ed4eacc38051fe9eda76ba17632 -a37e595cb63524cb033c5540b6343c3a292569fc115e813979f63fe1a3c384b554cecc2cae76b510b640fe3a18800c81 -b0bb57e4e31ae3ce9f28cef158ed52dabfad5aa612f5fcc75b3f7f344b7cec56b989b5690dacd294e49c922d550ee36b -a3c618ce4d091e768c7295d37e3f9b11c44c37507ae1f89867441f564bf0108f67bf64b4cf45d73c2afc17a4dc8b2c68 -999e6650eda5455e474c22a8c7a3fd5b547ec2875dc3043077ad70c332f1ccd02135e7b524fcbf3621d386dec9e614fa -b018f080888dec3c2ca7fcfeb0d3d9984699b8435d8823079fc9e1af4ca44e257fbe8da2f6f641ee6152b5c7110e3e3c -a2bcd4bcd9b40c341e9bba76b86481842f408166c9a7159205726f0776dcb7f15a033079e7589699e9e94ce24b2a77fd -b03de48f024a520bb9c54985ca356fd087ca35ac1dd6e95168694d9dae653138c9755e18d5981946a080e32004e238fe -a6c1a54973c0c32a410092441e20594aa9aa3700513ed90c8854956e98894552944b0b7ee9edf6e62e487dc4565baa2f -845d7abf577c27c4c1fafc955dcad99a1f2b84b2c978cfe4bd3cd2a6185979491f3f3b0ec693818739ed9184aba52654 -9531bcfc0d3fcd4d7459484d15607d6e6181cee440ba6344b12a21daa62ff1153a4e9a0b5c3c33d373a0a56a7ad18025 -a0bbf49b2dd581be423a23e8939528ceaae7fb8c04b362066fe7d754ca2546304a2a90e6ac25cdf6396bf0096fae9781 -a1ec264c352e34ed2bf49681b4e294ffea7d763846be62b96b234d9a28905cdece4be310a56ec6a00fc0361d615b547c -87c575e85b5dfbfd215432cb355a86f69256fff5318e8fda457763ac513b53baa90499dc37574bdfad96b117f71cb45e -9972edfdeec56897bef4123385ee643a1b9dc24e522752b5a197ce6bd2e53d4b6b782b9d529ca50592ee65b60e4c9c3c -b8bcf8d4ab6ad37bdd6ad9913a1ba0aba160cb83d1d6f33a8524064a27ba74a33984cc64beeee9d834393c2636ff831a -83082b7ec5b224422d0ff036fbb89dc68918e6fde4077dfc0b8e2ee02595195ecadb60c9ab0ad69deb1bac9be75024fa -8b061fce6df6a0e5c486fd8d8809f6f3c93bd3378a537ff844970492384fb769d3845d0805edd7f0fcd19efabf32f197 -b9597e717bb53e6afae2278dbc45d98959c7a10c87c1001ed317414803b5f707f3c559be6784119d08f0c06547ec60b1 -b9d990fd7677dd80300714cfd09336e7748bbf26f4bb0597406fcb756d8828c33695743d7a3e3bd6ddf4f508149610ef -b45f7d2b00ceea3bf6131b230b5b401e13a6c63ba8d583a4795701226bf9eb5c88506f4a93219ac90ccbceef0bfd9d49 -a8ccaa13ca7986bc34e4a4f5e477b11ae91abb45c8f8bf44a1f5e839289681495aba3daa8fb987e321d439bbf00be789 -ae0f59f7a94288a0ead9a398fdd088c2f16cccb68624de4e77b70616a17ddf7406ca9dc88769dadeb5673ff9346d6006 -b28e965dcc08c07112ae3817e98f8d8b103a279ad7e1b7c3de59d9dbd14ab5a3e3266775a5b8bbf0868a14ae4ab110f1 -84751c1a945a6db3df997fcbde9d4fe824bc7ba51aa6cb572bb5a8f9561bef144c952198a783b0b5e06f9dd8aa421be8 -a83586db6d90ef7b4fa1cbda1de1df68ee0019f9328aded59b884329b616d888f300abb90e4964021334d6afdea058fd -8fcea1ce0abf212a56c145f0b8d47376730611e012b443b3d1563498299f55cbcbe8cbd02f10b78224818bb8cbbd9aaa -8d66c30a40c34f23bae0ea0999754d19c0eb84c6c0aa1b2cf7b0740a96f55dd44b8fee82b625e2dd6c3182c021340ac6 -92c9b35076e2998f1a0f720d5a507a602bd6bd9d44ffc29ede964044b17c710d24ce3c0b4a53c12195de93278f9ec83b -a37d213913aff0b792ee93da5d7e876f211e10a027883326d582ad7c41deebdfce52f86b57d07868918585908ebd070a -a03995b4c6863f80dd02ed0169b4f1609dc48174ec736de78be1cdff386648426d031f6d81d1d2a7f2c683b31e7628c0 -b08b628d481302aa68daf0fa31fd909064380d62d8ed23a49037cb38569058e4c16c80e600e84828d37a89a33c323d1f -a0ee2e2dd8e27661d7b607c61ac36f590909aa97f80bdfd5b42463ca147b610ac31a9f173cbecdd2260f0f9ea9e56033 -967162fba8b69ffce9679aac49214debb691c6d9f604effd6493ce551abacbe4c8cc2b0ccee6c9927c3d3cfbdcb0be11 -8deab0c5ed531ce99dadb98b8d37b3ff017f07438bc6d50840577f0f3b56be3e801181333b4e8a070135f9d82872b7f2 -b1bfa00ec8c9365b3d5b4d77a718cb3a66ed6b6cf1f5cf5c5565d3aa20f63d3c06bb13d47d2524e159debf81325ba623 -90109780e53aeacd540b9fe9fc9b88e83c73eaf3507e2b76edc67f97a656c06a8a9e1ec5bce58bfd98b59a6b9f81b89d -88a1009a39a40421fdcc0ffc3c78a4fbace96a4e53420b111218091223494e780a998ebecf5a0abd0243e1523df90b28 -90b77146711ee8d91b0346de40eca2823f4e4671a12dad486a8ec104c01ef5ee7ab9bd0398f35b02b8cb62917455f8b3 -b262c5e25f24ae7e0e321b66fdb73b3bf562ded566a2d6a0152cf8bafb56138d87b6a917a82f5ace65efc73cfc177d81 -ae65a438c7ea46c82925b5ec5f71314558ca5146f5d90311431d363cfeac0537223c02cbb50fa6535d72fc2d949f4482 -8984208bfc193a6ef4720cc9d40c17f4be2f14595ef887980f2e61fa6927f9d73c00220937013b46290963116cbe66ac -a8f33a580508f667fac866456dce5d9246562188ad0f568eb1a2f28cf9fd3452dd20dc613adb1d07a5542319a37ecf1a -aedadd705fc086d8d2b647c62e209e2d499624ab37c8b19af80229f85e64a6e608d9cd414cb95ae38cf147d80ec3f894 -ae28077a235cd959f37dc3daedc3706f7a7c2ffe324e695f2e65f454bf5a9fc27b10149a6268ebfaa961ad67bb9b75d7 -a234c7f5a5e0e30f2026d62657bd92d91a9907ec6a2177f91383f86abb919778121ff78afb8f52c473fe6fb731018b52 -816a2ea7826b778f559a815267b6c6eb588558391c0a675d61bb19470d87489ba6c1e2486ea81dd5420a42ee7c35a8de -9218b61948c14234f549c438105ae98367ef6b727ad185f17ad69a6965c044bb857c585b84d72ef4c5fb46962974eed7 -a628031217a0b1330b497351758cf72d90fb87d8bdf542ea32092e14ff32d5ef4ca700653794bb78514d4b0edfd7a8d7 -ab4e977141be639a78eb9ed17366f9642f9335873aca87cce2bae0dddc161621d0e23264a54a7395ae706d748c690ee9 -b1538c4edff59bcf5668557d994bac77d508c757e382512c4368c1ded4242a41f6200b73fe8809fb528a7a0c1fc96feb -965caabe5590e2ff8c9f1048bbdda2817e7a2847e287944bfab40d94cb48389441ac42ff3a7b559760bfab42ff82e1e0 -a64b7484d22c4b8047c7a8ef54dc88cb8d110c61ef28ba853821b61e87d318b2b4226f7f0d1f3cdf086a0e1666d0212c -8915ab7e41d974eef9a651b01c2521392e8899e6ab91c22aeee61605c78fb2b052399ba1d03473aa9cfb52d1a8ba4257 -8dd26875d4a1716db2f75a621d01e971983267770e2da92399aecf08f74af1f7e73643ac6f0a9b610eda54e5460f70ed -83dabcb84c9cbce67e1a24ecbfa4473766b9519588b22288edbaa29aca34cefd9884f7310e7771f8f7a7cbced2e7eea0 -956be00c67987fb4971afca261065a7f6fcef9fb6b1fcb1939f664bbc5b704223253ebfda48565624a68fb249742c2cf -a374824a24db1ab298bee759cee8d8260e0ac92cd1c196f896600fd57484a9f9be1912ded01203976ac4fab66c0e5091 -a225f2ed0de4e06c500876e68e0c58be49535885378584a1442aae2140c38d3ca35c1bc41936a3baf8a78e7ab516f790 -8e79c8de591a6c70e2ef2de35971888ab0ca6fd926fdb6e845fb4b63eb3831c5839f084201b951984f6d66a214b946b8 -91babc849a9e67ab40192342c3d0d6ce58798101cb85c9bd7fc0ac4509ffc17b5ea19e58045cf1ca09ec0dee0e18c8f9 -8b4897fc2aef5bbe0fa3c3015ca09fc9414fdb2315f54dbecc03b9ae3099be6c0767b636b007a804d8b248c56e670713 -8f63ba42e7459ea191a8ad18de0b90b151d5acbf4751e2c790e7d8328e82c20de518132d6290ff3c23d2601f21c1558e -a1a035dc9b936587a16665ea25646d0bb2322f81960d9b6468c3234c9137f7c2b1e4f0b9dbe59e290a418007b0e7a138 -81c4904c08f7bb2ac7b6d4ac4577f10dd98c318f35aac92fc31bab05eceb80a0556a7fc82614b8d95357af8a9c85a829 -8c40e44e5e8e65f61e0a01f79057e1cb29966cc5074de790ea9c60454b25d7ea2b04c3e5decb9f27f02a7f3d3cb7014f -ad8709e357094076eb1eb601539b7bcc37247a25fbc6ada5f74bb88b1b371917c2a733522190f076c44e9b8e2ae127fb -92d43cd82c943fd71b8700977244436c696df808c34d4633f0624700a3445f3ecc15b426c850f9fb60b9aa4708f2c7c0 -b2cb8080697d1524a6dcb640b25e7255ae2e560613dbd27beaa8c5fc5c8d2524b7e6edd6db7ad0bb8a4e2e2735d4a6f7 -971ca6393d9e312bfb5c33955f0325f34946d341ff7077151f0bcafd2e6cbd23e2ad62979454f107edc6a756a443e888 -b6a563f42866afcee0df6c6c2961c800c851aa962d04543541a3cedeb3a6a2a608c1d8391cf405428cd40254e59138f3 -986bd17bad9a8596f372a0185f7f9e0fb8de587cd078ae40f3cd1048305ba00954aff886b18d0d04640b718ea1f0d5a3 -ae32dbccfb7be8e9165f4e663b26f57c407f96750e0f3a5e8e27a7c0ca36bc89e925f64ddd116263be90ace4a27872c4 -83725445ec8916c7c2dd46899241a03cf23568ac63ae2d34de3bce6d2db0bc1cfd00055d850b644a059fb26c62ed3585 -a83f7e61c05b1c6797a36ad5ded01bf857a838147f088d33eb19a5f7652b88e55734e8e884d1d1103a50d4393dfcd7a8 -aa010b4ec76260d88855347df9eaf036911d5d178302063d6fd7ecad009e353162177f92240fe5a239acd1704d188a9d -a88f4ba3cf4aff68ec1e3ded24622d4f1b9812350f6670d2909ea59928eb1d2e8d66935634d218aeac6d1a0fc6cae893 -b819112b310b8372be40b2752c6f08426ef154b53ef2814ae7d67d58586d7023ffa29d6427a044a3b288e0c779866791 -b5d1e728de5daf68e63b0bb1dee5275edae203e53614edeeeefff0f2f7ac4281191a33b7811de83b7f68111361ef42e1 -953fb3ddc6f78045e53eaacfd83c5c769d32608b29391e05612e4e75725e54e82ad4960fbef96da8b2f35ba862968a3e -936471136fb2c1b3bb986a5207a225a8bf3b206a1a9db54dc3029e408e78c95bfb7539b67006d269c09df6354d7254ac -ac353364b413cae799b13d7dc6fa09c322b47e60b9333e06499155e22d913929b92a45a0ad04ba90b29358f7b792d864 -a0177419ead02ba3f0755a32eee3fd23ec81a13c01eab462f3b0af1e2dba42f81b47b2c8b1a90d8cec5a0afa371b7f11 -b009eeb5db80d4244c130e6e3280af120917bb6fcebac73255c09f3f0c9da3b2aa718cd92d3d40e6b50737dbd23461aa -b8a43426c3746c1a5445535338c6a10b65474b684a2c81cd2f4b8ebecc91a57e2e0687df4a40add015cd12e351bbb3eb -94ff3698a6ac6e7df222675a00279c0ea42925dc6b748e3e74a62ea5d1e3fd70d5ab2d0c20b83704d389dd3a6063cf1a -90e4142e7ce15266144153e21b9893d3e14b3b4d980e5c87ce615ecd27efac87d86fa90354307857f75d7ebaeffe79ef -a5fd82c3f509ec9a36d72ba204a16f905e1e329f75cfd18aaa14fb00a212d21f3fac17e1a8e3bc5691ab0d07f8ec3cd0 -962e6bfd75ea554f304a5fee1123e5bf2e048ccd3b401716b34c52740384579188ac98bc0d91269fc814de23f4b2dd34 -b50b4e45c180badf9cd842cd769f78f963e077a9a4c016098dc19b18210580ad271ae1ba86de7760dd2e1f299c13f6a0 -84cf08858d08eca6acc86158ffda3fbe920d1d5c04ac6f1fc677760e46e66599df697397373959acf319c31e47db115c -a697a38ba21caa66b7739ed0e74fe762a3da02144b67971fcad28c1132d7b83e0ac062cc71479f99e2219086d7d23374 -ad1f6d01dd7f0de814fe5fbb6f08c1190ff37f4a50754d7b6291fc547c0820506ea629aabacf749fec9c1bbfda22d2d0 -b11fd7f8c120d8a370a223a1adc053a31bef7454b5522b848dec82de5482308fc68fdaf479875b7a4bc3fc94e1ea30eb -93ecf90ebfc190f30086bcaeee18cda972073a8469cf42a3b19f8c1ec5419dff2d6a5cc8ef412ccd9725b0f0a5f38f88 -911f25aaa5260b56b3009fa5e1346a29f13a085cf8a61b36b2d851791f7bcf8456840eccbfc23797b63ecd312e2d5e12 -a52f17a8b2db66c98291020b1db44ab23827e1790e418e078d1316185df6aa9f78292f43a12cd47131bd4b521d134060 -9646fca10bf7401e91d9a49753c72f3ecb142f5ed13aba2c510a6c5ccb8d07b8e8d1581fc81321ad5e3996b6d81b5538 -aa1da4a5665b91b62dda7f71bb19c8e3f6f49cc079d94fcd07b3604a74547e8334efa5a202822d0078158056bbda2822 -a2432ae5feeaf38252c28aa491e92a68b47d5b4c6f44c1b3d7f3abc2f10b588f64a23c3357e742a0f5e4f216e7ca5827 -83c7b47735cd0ef80658a387f34f259940096ebb9464c67919b278db4109fea294d09ea01a371b79b332cff6777c116d -a740a2959e86e413c62d6bdd1bc27efe9596ee363c2460535eab89ba1715e808b658bd9581b894b5d5997132b0c9c85c -b76947237fa9d71c3bece0b4f7119d7f94d2162d0ced52f2eac4de92b41da5b72ad332db9f31ebb2df1c02f400a76481 -a20e1f2b7e9cc1443226d2b1a29696f627c83836116d64d2a5559d08b67e7e4efa9a849f5bb93a0dadb62450f5a9eaab -b44bff680fba52443a5b3bd25f69c5640006d544fca1d3dc11482ee8e03b4463aae59d1ec9d200aa6711ce72350580fb -a9490f5643bacec7e5adcda849ab3e7ff1f89026bf7597980b13a09887376f243158d0035e9d24fdee7cb6500e53ef29 -96081010b82c04ad0bfc3605df622db27c10a91494685ef2e6e1839c218b91cbb56e043e9a25c7b18c5ddee7c6769517 -a9522d59bcf887cbbbc130d8de3ff29a86df5d9343a918f5e52c65a28e4c33f6106ac4b48ecd849a33d39eeb2319d85b -aa5e0cea1a1db2283783788b4d77c09829563b75c503c154fdaa2247c9149918edac7737ef58c079e02dca7d8397b0eb -8c03f064e777d0c07c4f04c713a86bf581cc85155afe40e9065ead15139b47a50ead5c87ac032f01b142d63ff849758a -a34d672bf33def02ee7a63e6d6519676c052fa65ca91ed0fe5fdd785c231ba7af19f1e990fc33f5d1d17e75f6af270be -8680443393e8ac45a0b07c30a82ac18e67dcc8f20254bd5ede7bf99fc03e6123f2fcd64c0ca62f69d240f23acd777482 -a4e00ab43d8ae5b13a6190f8ef5395ec17fbac4aa7dfa25b33e81b7e7bf63a4c28910b3a7dc9204dbc4168b08575a75e -8249259066ee5672b422c1889ab5ed620bddd1297f70b4197c40bb736afba05d513b91d3a82ee030336c311d952cd60c -a0651d8cf34fa971bde1ec037158a229e8e9ad4b5ca6c4a41adedb6d306a7772634f703dcfac36f9daf17289f33c23fb -b02ff6e8abff19969e265395ceaf465f43e7f1c3c9cfc91f1748042d9c352b284e49515a58078c877a37ff6915ee8bf4 -927fb7351ac28254458a1a2ea7388e1fbd831fbc2feedb230818f73cc8c505b7ff61e150898ce1567fcb0d2c40881c7b -a9d3861f72090bc61382a81286bb71af93cdeefab9a83b3c59537ad21810104e0e054859eeafa13be10f8027b6fc33b8 -a523306656730b1a31b9a370c45224b08baf45773d62952a0bf7d6c4684898ae78914cfafbd3e21406407cc39e12afdc -947a090e7703a3ea303a4a09b3ab6b6d3fda72912c9f42cc37627557028b4667f5398a6d64b9281fa2efbe16f6c61ed6 -b41d24d40c10239c85d5b9bf1a3886d514a7a06b31ca982ea983e37162293350b12428eabc9f6a460473ad811e61ba40 -b0bb9805724f4ca860e687985c0dc6b8f9017fe71147e5383cfbbbdcb2a42c93c7062ba42acdead9d992b6f48fc1d5ac -aec775aa97a78851893d3c5c209a91267f1daf4205bfb719c44a9ed2614d71854b95bb523cd04a7f818a4a70aa27d8fc -b53e52e32ca90b38987610585ad5b77ecd584bd22c55af7d7c9edf5fbcae9c9241b55200b51eaed0fbdb6f7be356368f -a2c5ac7822c2529f0201717b4922fb30fb037540ab222c97f0cdac341d09ccb1415e7908288fabef60177c0643ed21bf -92162fda0cbd1dafbed9419ae0837e470451403231ee086b49a21d20de2e3eed7ce64382153272b02cf099106688af70 -8452d5df66682396718a76f219a9333a3559231e5f7f109a1f25c1970eb7c3408a5e32a479357f148af63b7a1d352451 -831ea95d4feb520994bc4904017a557797e7ad455a431d94de03b873a57b24b127fcc9ff5b97c255c6c8d8e18c5c7e12 -93d451d5e0885ccdbb113a267c31701e7c3d9e823d735dc9dfd6cfdcd82767012dc71396af53d3bedd2e0d9210acf57f -a2126f75a768dcc7ebddf2452aebf20ad790c844442b78e4027c0b511a054c27efb987550fcab877c46f2c7be4883ae0 -aa4d2dcba2ccfc11a002639c30af6beb35e33745ecbab0627cf0f200fdae580e42d5a8569a9c971044405dfdafed4887 -ab13616069ef71d308e8bf6724e13737dc98b06a8f2d2631284429787d25d43c04b584793256ed358234e7cd9ad37d1f -9115ee0edc9f96a10edcafeb9771c74321106e7f74e48652df96e7ca5592a2f448659939291ff613dd41f42170b600ad -97b10a37243dc897ccc143da8c27e53ccc31f68220bffd344835729942bb5905ae16f71ccaed29ca189432d1c2cc09b1 -875cf9c71ae29c3bde8cdcb9af5c7aca468fbb9243718f2b946e49314221a664959140c1ebc8622e4ed0ba81526302fd -86b193afbb7ff135ce5fc7eb0ee838a22e04806ceec7e02b3fb010e938fff733fc8e3a1d4b6cba970852d6307018b738 -b3403a94f1483edce5d688e5ed4ab67933430ede39cd57e2cddb4b469479018757d37dd2687f7182b202967da12a6c16 -83edfa0a6f77974c4047b03d7930e10251e939624afa2dcafbd35a9523c6bf684e1bb7915fc2e5b3ded3e6dc78daacf2 -88ff3375fe33942e6d534f76ed0f1dfa35ae1d62c97c84e85f884da76092a83ecd08454096c83c3c67fac4cd966673d7 -af0726a2a92ee12a9411db66333c347e1a634c0ab8709cc0eab5043a2f4afac08a7ae3a15ce37f5042548c6764ae4cf6 -81cfa33bb702e2f26169a006af0af0dcaa849cec2faf0f4784a06aa3c232d85a85b8123d49a1555cca7498d65e0317e4 -910a16526176b6e01eb8fb2033ffbb8c9b48be6e65f4c52c582909681805b3d9e1c28e3b421be9b9829b32175b8d4d80 -93d23befa411ca1adbdba726f762f2403e1cc740e44c9af3e895962e4047c2782ca7f2f9878512c37afd5a5a0abbd259 -82fcf316027fedfe235905588b7651b41e703836f96cb7ac313b23b4e6c134bff39cd10b3bddb7458d418d2b9b3c471b -8febc47c5752c513c4e5573428ad0bb40e15a5e12dbfa4c1ef29453f0588f0b75c3591075fef698e5abcf4d50c818a27 -83dab521d58b976dcea1576a8e2808dfaea9fa3e545902d0e0ce184d02dca8245d549134a238ab757950ad8bc11f56eb -898cfb9bf83c1c424eca817e8d0b99f5e482865070167adab0ecf04f3deeb3c71363b9f155c67b84d5e286c28238bef8 -b845e388cc1a8e8b72a24d48219ac4fd7868ee5e30960f7074b27dada842aa206889122acfce9e28512038547b428225 -b1ce4720e07e6eecc2a652f9edbad6bd5d787fbaff2a72a5ca33fa5a054dd3b4d5952563bc6db6d1ce1757a578bba480 -8db6990dd10741cf5de36e47726d76a12ebe2235fdcb8957ab26dba9466e6707d4a795d4e12ec7400d961bd564bdee7e -a3ca7afd20e16c2a45f73fc36357763847ed0be11cb05bfd9722f92c7ba3fa708cf10d4e0ae726c3eccae23cc55fd2be -8701b085c45b36f3afb589207bbf245ef4c5c82aa967ecd0c334daa1f5a54093c5e0fcacd09be540801920f49766aa0f -84e3736727ba76191d9a6a2a3796f55bb3c3a8bbb6e41f58e892ea282c90530b53ab5490bbf1a066723399bb132160fb -87c02a01917333c7b8866f6b717b1e727b279894108f70574d1b6e9e8dc978eda8778342baf3c6464d6e0dd507163e76 -b8da532dac81fafaed759e99c3ae011d75f3fda67a8c420c3b9747281fe32e31ac3c81e539940286440704c2c3e3b53e -a0cc63c3bef75a5c02942977a68a88cd3d103d829b6c0f070f64206da7e3638f10f42452788092de8fbbc626ce17b0d4 -b5c9317b3f6b1d7ee6871506c0430cdf73e28b02c001ba6ca11061c7e121c91152d2b80c4f80e1d8f51ff5653bc0db5b -b798fb572da977dd3ef2dce64042b012a470d6bd2cb61a16267abe2b8399f74540d7c70462a6b2278d73567447e31994 -b868eda58739effda68c834745cd2cf66a09f0f215607b65685bb5ca3eba71150f43a6e47b81a0c19fb58eeae3da56e8 -9041c93a7e8f2c34812fd6e9744b154e898e1ef69db72bf36242c71e2c251f3db7e86cbd802da603a92cd0b06b62ea63 -a834d648e974230582fc17b3a449f4f65b3297038a3a5401e975b9b60ff79b2006a33e1486d3428106580276993311e1 -a3ce874da6ade9f0f854d7ae7651fc3ff63cec748a847527539fe0d67e6c99eaa3011065a4627c2192af7f9569f7ab57 -ae78ad16de150cc0400d3b6b424c608cd2b2d01a7a38ea9c4e504d8463c0af09613774dbefdd5198415b29904e0fbb63 -b966db5a961067e743212d564595ef534e71dcd79b690a5a2c642d787059fc7959b9039b650372461a1f52910f7e857b -8069904f360af3edfd6cabd9b7f2adf5b61bd7feb0e9a040dc15c2a9d20052c3e5e0158f3065ec3200d19b91db603b71 -9600917dbcd80a47f81c02c3aafecfcef77f031bf612a0f1a8bdef09de9656f4bb0f8e3e95f72ece1c22bd2824f145b6 -834a0767b7b6199496c1faee0e3580c233cc0763e71eebc5d7c112a5a5e5bd95c0cf76a32ea5bb1b74f3cf00fbd2cfb4 -99469a893579ed5da7d34ec228854c4666c58115d3cae86d4fc2d03d38f10d8c5dc8fb693763a96ab6be2045cc8d518b -a52cc0aecda6594de57d8ca13b146e77212cc55854929c03f2a8a6cdfa46296791c336aebcc2610d98612d5b4c0452df -97864434d55aa8a7aad0415d36f9558ce6e6c00452923db68a1e738232d0cb2d47e3b0b8f340c709112838adeaee4695 -a4a7f2c45db3661b6af7ec759f9455ba043b0de6fd4787e3372cba215b9f7c641d5d817a0576e7aa28a46349d2fe0ae6 -864e857652d95e1d168c1b9c294777fc9251a4d5b4b00a346b1f1c9c898af9a9b5ec0ac1f3a66f18a370b721dbd77b23 -ab8eac458fa8e7eb5539da3964ccd297a216448c3af4e4af0dcfed0ce29e877a85e29b9601dc7508a060b97a05f37e15 -a6fd0782c5629c824fcd89ac80e81d95b97d8374c82010a1c69f30cef16ffc0f19e5da2d0648d2a36a636071cb4b69a7 -ad35a75fd8832643989d51d94ee6462d729e15f6444ffdf340dfb222af5d2b6b52e5df86082dbc7728fde7c1f28ac6b4 -8e06831cc8a0c34245732ea610ea6aae6d02950299aa071a1b3df43b474e5baee815648784718b63acfd02a6655e8ea7 -994ac097f913a4ce2a65236339fe523888ee43494499c5abf4ac3bce3e4b090f45d9abd750f4142a9f8f800a0115488c -a3e6a8e5e924f3a4f93e43f3f5aafb8b5831ce8169cddde7296c319d8964a0b6322a0aa69e1da1778fcc24b7de9d8b93 -81a9bd04f4c6e75517de4b5e2713f746bd7f3f78a81a2d95adc87ba0e266d1f5e89c9cfb04b5159c1ff813f7968a27a4 -b24de8f3a5b480981c6f29607b257ded665ecd8db73e2a69a32fcf44e926fdc7e6610598e10081cf270d2f879414b1ab -adc1b3f8ed1e7d5a26b0959ffe5afc19e235028b94cb7f364f6e57b6bf7f04742986f923fae9bf3802d163d4d0ebc519 -a9fa5092b6dd0b4e1a338a06900b790abbc25e2f867b9fb319fdcdfb58600315a45a49584c614f0f9f8b844aa59dd785 -b29c06b92b14215e7ef4120562893351ae8bf97cc5c3d64f4ecd0eb365b0e464cf27beec3f3ddac17ed5e725706b6343 -adc0d532ba4c1c033da92ba31aa83c64054de79508d06ee335dcab5cabae204a05e427f6f8c2a556870a8230b4115fd0 -9737150d439e6db2471d51e006891d9687593af4e38ee8e38bfa626abcefa768ca22d39133f865d0a25b8bbf7443d7db -a10d1e6a760f54d26c923c773b963534e5c2c0826c0a7462db2ea2c34d82890f9c58f0150db00aa2679aa0fdb1afcb08 -816947dc6c08ee779e9c2229d73dbfd42c2b3b6749b98ec76dbad017f4b4d4f77b5916600b576691978287208c025d6f -a2dc52b6056219d999f07b11869c254e8b3977113fd9ba1a7f322377a5d20e16c2adf46efb7d8149e94989b3f063334a -8153900aae9cf48ebc7438b75c16f5478960ef9170e251708f0c2457967b7b31521c889b5fe843d2694a07c0e804fa48 -a9e9d8d66c8774972cc1686809ce1fa5f0e16997ef2178b49bcd8654541b5b6e234cb55188f071477ba1cebcf770da45 -b1fa775f9b2a9b05b4b1f0d6ad5635c7d7f4d3af8abaa01e28d32b62684f9921197ba040777711836bc78429bf339977 -b1afbbd522b30e1ae2adf9a22993ab28b72a86a3d68d67b1833115e513632db075d047e21dfe442d6facc7b0a1b856bf -8779b7d22f42845a06ae31ac434e0044f5f9b4e704847fb93943e118e642a8b21265505ad9d6e418405d0cb529e00691 -ab2c6cef1c4e7c410e9e8deb74c84bedeb3c454ae98e3bc228eb13f6b7081b57977b3e849ba66346250e37c86842c10c -908d6c781d7d96aa2048c83e865896c720a66fdec7b06ab4b172192fe82f9ff6167815ffb66549d72bfb540bb35c36c6 -b790440f205ece489e2703d5d1d01ba8921dd237c8814afb5cb521515ed4c3b0a6df45fd4bd65ba63592c2fe1d008df3 -aec346251f9c78336b388c4e9069a1c6c3afbbb6bfaffdad050a9e70e92fb3cae3609067b4903552936f904c804b0ea6 -a0e528cc2cb84b04cc91b4084e53ead4188682a6050b3857c34280899c8233aa8c1a9c6fa4fd6a7087acf1b36d67734a -aa8d7632be3e4340712a1461a0ad0ae90ba6d76e2916511c263f484c6c426939fa93ffbb702cd0341eea404d6ddffebb -a4ea871d8a1d4b925d890aefb9897847599b92e15ce14886b27ce5c879daa9edead26e02ccc33fcf37f40ff0783d4d9e -ab63e4dc0dbdaf2ada03b3733aafe17e719d028b30dc9a7e5783c80933a39935dbe1ef0320bb03f9564cafdf7a4b029b -8219761bbaa39b96b835f9c2b4cec0bf53801f8e4f4a4498d19638be2fa0a193b2c1fbf94e26c1058d90a9ac145a7a12 -a609ee5561828b0f634640c68a98da47cb872b714df7302ef6b24d253211e770acd0aa888802cd378e7fa036d829cd36 -90793ff0736f3c80b5e0c5098b56cda8b0b2bca5032bb153d7b3aa3def277f2fc6cea60ac03edc82e3a9d06aff7d1c56 -8760085283a479d15a72429971a0a5b885609fd61787a40adb3d3d7c139b97497aa6bcb11b08979e2354f1bc4dbf7a0d -b168ede8b9a528c60666057f746530fc52327546872dd03c8903f827d02c8313e58c38791fb46e154d4247ea4b859473 -842c1149ca212736ebe7b6b2cb9a7c3b81ae893393c20a2f1a8c8bfef16d0a473ff865a1c130d90cc3626045f9088100 -b41d0e2c7d55108a8526aa0b951a5c8d7e3734e22fe0a6a2dd25361a5d6dea45c4ab4a71440b582a2f9337940238fe20 -8380bd49677e61123506dd482cdf76a8f1877ea54ed023d1deabfc05846103cfd213de2aef331cdf1baf69cfc6767be9 -a026f92030666b723d937f507e5a40e3f3cfd414ad4b2712db0a7a245a31a46002504974ed8ba9d8e714f37353926a4e -b492e9e9917b29eb04cde0b012df15cbd04f3963d120b63c55dc4369e04f5ac7682b2c7dff8c03410936c26ca73ad34c -81fd9271b4ee36be0ba8f560d191e1b6616dd53c56d1d8deac8c1be7bc67bbc53d434cf70d04e7fa9de3e63415389693 -835c3711abe85683d2344a3ee5f70e68342fd1aec025ad248efe66aab3e3d5790fad2f45bae0d7a53a80998fde45f0aa -b46599be80b8f7dbad0b17808dd5ca91d787929c0bef96fbbcf6c767727d07ed6785bad164d733ecb015eb6c8469a16d -b36bf5c17271d39f5ccb3d82a5e002957207a0cdf9ae7108a4946e6f3ed21a5d353fa940b6fe949c39422b452339bae9 -a12f5444e602d6fb8be51a08b8bc4ec105dfd759d2afe98d51ff4edd673c92e4fc91ff32417ae8070e12169004f8aad3 -892ce3ca0a2961a01f7f0149b8a98fdc0f8871c2d85e76daf7c8aed2a18624b978a4d0a84213f81f9d2a81f7ca4826d0 -b1e6229ebd5b3d85e62d0474d1fed34564f1b5b9c5856fae36164dd0eff378d67d6717dda77536379006fb462bced9da -ac852921dcb81e54e1e315fd6226219932f7b785c2ceb2035710e814899784d7001101f1515d68e3fb74cdbb4baf9e26 -989a42d851123d708a213f3a02cfc926df15af058ec9b5a9df968fe16decbd781b5e65a4c17fbfedd2ac17126084700f -b1d0fc2f7c948e466445f307da7b64b3070057c79c07c7ebbbe6f8ed300a642b3567aed2e5f28988ac566ba62e0d2a79 -83057263b41775bc29f1d59868a05b0f76d3bdf8a13c1014496feb4c0ee379bfd0d4079785252f51fbeb641e47a89b69 -ac9e6a208aa9c557155cf82b389bb4227db5ac4b22a0c7c8d1c3d98946df8b82b0c49d093ba55c8255e024a6d67c14b4 -8294a11cd3f5111b1f8bd135be23b4de337ac45711db9566ebf6e162cd58e7859b1309eba8149b0f0a43e07f62a92411 -8c15f3388b196603c05adec195c1d2cc589e3466da3169e9afd37157fa55cd34bfafbfc5ff10ac0e04aa6a0d0b2ce3db -b8faf8ba89c3115576ab6b340f6cc09edfea8f7331f5a5e8003960c584e839fcecf401113dfbb9a5c11a13721b35c263 -955c63b1166514c02847402d0e92dccfe3c0dee3bc70d2375669afb061594c85651e6569f471a6969759e5f373277da4 -963bd4f9ae7361d6936d209592a07d9a22cc9ef330cf0c5cb845cb4085d76e114aee66d7599bf5b9f11c6b1c05dade8d -85509b3c97e06e0db113b8b40022c8989a305cec39acab36ba3a73a4b4719573e5bdb82dc4795699c26d983465cd61b0 -b870cfd7f691f88db8d1dfbe809b7b402eabd3b3299606b7dfdb7ef49415411f01d2a7e4f7ebd919ac82c7094f628166 -a5533e7b58a6a9e5c25589134f501584163551247d36f50666eeb0a0745cf33e65bb8f7a9c2dc7fe7cb392414f1ece4a -b93d1ade01ff5678fcd5b5b4f06a32b706213748076cae3a375e20a97231133ec37c1c3202cbc4896b66c3410210f446 -86ed3a58000a46fe2c37d4de515430a57d8f54ab4300294685534372fed1d68e192dd43d43ea190accf3dc9b22e1548b -a8c7d8dc30057bb8ad66b9cfda5e223334407730aeb0f51705922c18e7a07d960c470d463d1781899203e1b1ed1df484 -8d86821d006e957e8544f95a98b110c89941bcc6985562e7a97285f5826b35b690963b2c141ff3f389d92ee18ec76d24 -a4e1108cd3cf01810e74dbbf94340487011b80013b9bfdc04f019188c0d4d077a54b71a3f97a036601aad42a268531e8 -a822cd61db07f64bea00de226102f5fc0adf8fa9f05a6c7478b0ff93e48f6cc3191302d22e1f369b571877d5eb96139c -b1ad4094d0bb4c325dfe072b17711962247dd7ff7e4bce4612e80a6f3c1bde04880ba1682f60d5f1451318afd4d3ba60 -88e7beb0cfd7361288ea27f6b2cb18870e621152ff47994440c18d45284d21bad80d9806ed7d9d392a5cd791d5150ce2 -aad3724a176cf4476595cdfb9e2c3261c37052324c0b5373a30b6cbeb481bccd303720840c49a84ddca916d470eb6929 -a57983370d159e7078a273746fb22468000a6448b1a31d277272e35c6f548f97928e9015f1daf577511bd9cfee165237 -a54136e9db381cdd6dfb3fff8bdec427d4dc1072f914f6fecfec13d7b8f95bb3b5f30ad7677288c008ce134edfb039a7 -a25dfc4019f165db552f769f9c8e94fa7dbbf5c54a9b7cde76629cc08808c1039ecbd916560c2b6307696dd9db87d030 -a917d25328b0754d70f36e795fe928e71ae77e93166c5e4788716c1ef431115c966f2aad0ce016f4bacc2649f7466647 -842ce5e4ad7d8d4b8c58430e97ff40a9fce1f1c65ecba75fed2e215e101d1b2d7ab32c18df38dab722c329ab724e8866 -a8eb2ed2986ff937a26a72699eb3b87ef88119179719ff1335f53094c690020123f27e44fc6b09f7a3874bf739b97629 -96753c1f9c226f626122dad6981e9810a3cf3bbee15cfc88e617cfd42753e34593610861be147a7b8966bcdec55bba8d -94119d31606098f5b129931b51b4b42c4e3513a128b9bfb03cfeee78b77b9909b1c2fcf0a292e49d63bc4e5fe823dfef -a869654f5880d9c21a0af1ff4cfa926e03ec1f2d80fe5524605e04f484e09dc80d6769249f31fd378ff3926ab4cebc69 -b2a539bdd8de4499c5f35cd8824974c2abb1933b3f50d0175dd044563ca829eaa0fc47bdac97eafa98434d1cd05d7c5d -85f53b2bfcde1986ce7279f3a2f5f841f87d75af5d197c897f261d4874bc6868c575ecf7556a32b7b33f7b2795454591 -964f087ed02228b30f401d8aea35c1a7f76698e4075e1bb343398be74c716884e9ca1a31b81566e1ff7513cf76a2f0cd -a1c9d9c9bfbc9c4e281a2953d5991e7b22ff1a32ddaace9e8d9a42e080efb802b853d3276973b5189a5745943c9b4389 -b0c45a9852663a427d7f50c608a6419fbd00f90e8452757a45269d25c0386ec29942f48a34aafc0187ef6020e581d290 -aa3ca7b01862d5d2aea714fa06724b7dda7062b6608605cb712588b2c49fc3c7d89a8799e6e7c31e7a9ef28b1ad4d1f7 -88f5e98ae8c5ae7add42f6d358a35667e590aa80e1869593cbf597d7ee466efa35b429f1836ba2199d8280fe7f60ce3a -8a3bff472e8008f7e50362acc1a0b53c09ac60430942544532722e938470376f0672662261992146765b7c75a380c318 -b9847be7f7aee7532282c279dde928698a892a183ca3047ceda521e9e0a50d96fd3ce59f8e58f31af49508ade6d4ba51 -98065dc23ea3df6d9f8459e81887d88d5752b7e7ba6050ec5c3f0dce93e463e0bf12be3c94ec74c16e2f7ba62e447845 -994aff677b97ee790894dbdb21b1f9210734e008cee2aa2200c8f2579ea650b872f39776a13a8c31e95cc817091bae1c -b292811674e18912ebe79df1af4a132b04ab702c125c039e0213f735f658fafd36c38e5bbd7cad35842576431f5f3630 -96520d750ec10bb10f75019f8f0e4a93ecbc6b678a710d76cd10aa27a6642ad1461bd58fc2aab8e0391b3f788339ed29 -80d478da7fe246ad0e81a00141229e9d91ffb7fd1b29975c8ec358ed5e864e481bf01b927a9ba002c5ec4aa226d0cb57 -ae58049d93a11ae845dc5be2505e95657f83b95d83ff3591a3c565d587157be795ff4481f42d59eda95e6d523444e199 -85f1f5ad988b9f8a7e24b6d6a22b9de9fb3fe408f95711389c444d7ba2243987225b04318aa97a4cde2cb4c30c05508f -922092d0cb828e764ce62f86cbc55c04dce07233cff041888fae48cfe93818780b4aec9b4ff4718275bb2bfa6bd9e9ba -a85ba97125feff0590a05fb78f19a7338639ad1748802918af4d59307bc994536c0ad638b97b9acd26a08b6b4370dfbf -8c46fcaa8d13266d650bd9366180e5ebbfa002c339e4424a030de19ed922e2daa9a353ae54921a42299607ae53feb075 -b8549832230eb1ec6ee3c33c078deb47f556a0907d2a85fde7720391c82d2ed63dd753cf544a6a0a46eed4b8d1ecd9b8 -b7b96f24504c7f8fbed9c1c654a2550feeee068407b809c43f1082c9558c8665806d911d5d244308169d8a531373bf56 -81c483fd9d9ad7af7869d617ac592e7e951e39738da041d8c4110637689108eb29c8acadfc85366c70885cdf77b353c3 -acf33bcfd9080dfdba828727fe36803327a94e8a3ee5b6e445274f0e8267ad3c943994a8dd6d09b8072912b57e1e25b8 -b3475e7456ff96861bc11068198d51b69b899f5ff13022694b501d3adc8bac58a16204b12011d61e880c8459f4badbbb -8ceb9562026aa96d6e786ec2e5cd49200b5b424349a2214cd3ff5c8f1c2bf1b9872480428f5428e45cc61106cbfbd953 -af56f7e482c24a1367fd798201a20c464848ece431f2d8a31a6ef4f9bdbaa50991e748dcb4ef0c08fdac0ef8ddda3b80 -896dae8b12549909d512fd5c02a2f72dde4086aef6c8007ddb26bb04dff51a707ae94ff87e45191fc10339967fa28958 -8ed1c606840e07a2ac6ff16ac6e81ed3e1c90872ababfe68d56ed2dc50d9294579b9c3546dc63292874299a3162d59f9 -b4d7a5c0836e419a46942281ce77d0aade8e39eb1bf1190dd274ca5070898a1c02ad9d165855629d6e1c96df1a6bd5f3 -aebad8939ac117deb28b789d9846c2c80359dc260920ac8408dbae0b6228dbf496dac0023a3b4302bb9a53e8ada18e61 -812d07c74a8650dc3f318c9b2dbf265f181041fb432fee989cedabd44b933dc6590e36c71dcf9dbe7b4bbf74ea0d7c50 -87b131dd3489889e090839c392231e0ee198acac65bb2e9e63e7d6da322391d1685cfc8ba60699308054c4b0fd89c90c -8b12110ece0b99b2e653b4bc840a12bce5b85abf6fb953a2b23483b15b732a0068824f25fcaa100900e742886c7b4a0d -8765fc9b526a98512e5264c877bdca567e32fdcde95cdbcf4f4c88ce8501e1c7fab755f80b87b9b32d86d18856f1d005 -ac806a32a14019337dfdb5f781ecba5cdea8fb69b23e0e57a0f885e0082a9c330ba808621a48e24316604f6c6c550991 -a711970fa40cf067c73e3edee9a111bf00cd927112205e9d36a21897529be9a051be45c336d6b56725dca3aeea0aed15 -908adbc17fc18821f217d46c25656de811d4473779a41eacd70d2a0d7dd3010de4268a562378814e619e13ac594bb0c3 -894251b79be5ae763f44853f6999289b3a9abda64d52797c6c7d6d31ff2a79e9b3906da72f9ebb95b61d6b29479e076f -aadcf11ea15bcb6d979c3ea320cff8dfcc23c5118ed075f35e77f71459b2141253060e3a90839adbcd3d040ad3bdc5e2 -b4e55d7d2eeaaffb0267448ecce0b75166e4805dc0e261eb5634d4a3f3c08964a597302fd8f6b45ec48178619291dadc -a8e2a02c93d6bec7f42f9265269660b4b404940c3e3de9515b4d826ea7e71f18c6f90a71ce3fbe452d0713de73cb391e -8e2467accfe207cb1ba37d60662920f95338ee212927edb706228c25345734217740159310edf17687f58b333754cb65 -90376b88f653381b3bab673c48c2b84fa82a091e18f710a732fef836e0d39043fcd5527aa97a3a385c0a77cf53746993 -b16530e289198c235ab680f86851bcc177f0c16a58483d83a89213077b06d6840600b03834b6b7af0e22b1914f72de43 -8c4fc3854f938ef1c2b5df065e4e75e9f299798afae8205706439491bdf9784c756134922e77af007e349a790afa52b7 -a68aaec4341d29b92b35322f89b1ae3612e7b440c89a86135a07c261dc5799217a651460c92113d099b486817226d8cd -a653f965feefd2df24156478f0cf3755274ca395afb79e8c72d3b6e1d1f5ba7f3e4f9a4c5ee85355de6f3c81935ff579 -aaf6c8d2717b57f6b14e06c742a11a3bc736bfc0327ca4b8a005b6e924f06871141d231737698a9a59286e44f244a168 -8de32e3c104b4278e27aac695d224f134001c3619f15186466c57c0c46f67e2efe537501d0d9f52f4cdbc724a170b92d -8e9b5858b6d4ffe811f6498bd80e454f0d6b345d4729c946626c7cdc196c803a349a14515296aadb7258bb7a5b37e930 -82fc711043aaf1d7a9c712d00eafd816a710f82eb10818ba6af09f591447f36814dbff6e6a1cb2b5c7f16c73930dbbca -b2f0205327fc8ff687f751e7b97788732afaef4fcf51bb17fd7579ed07501915790b70fc36624371fe4fb87a0179d850 -add87d5b1288d30f3449d3ccfa11cba4dc7756d85cee1cb6171b493680a625a01f273d0bb8e6332d0410250036b3acdd -a411f75ef7dd8de8062331ea40929db989e4d65ae8f33d3fa6cc19c98fa8a8ec2b7c7534a5c5eee9e5051626a6a2e47c -89d40a647781e7f2e8ab3a0f7dc7133669944c0cf627376433687a2ea15c137be26f582a6b07ff94b266ac0910009f7c -b2b5f808c26b40ed507922ed119b0fb95e0d6d8b084bbbba58ca456b4354d03110c99989b93207998334ea5d1b70fe49 -8c8db028671969a1e80e595283ce5e678ee955d785043bb5fd39fdb68a00e4c15b462600a7ab1f41486b6883e725894e -958087ce0c75fe77b71770c2f645ef3360c1a9c98637693b988c5f6ce731f72b24ab8b734e8eb6258ee8b23914451f0d -aad6c00df131c1eec6c556bae642e6dcc031e70f63eee18682f711c7b2fcd9afbf1f18cf8a4af562759130add67bd4a3 -b6d23c567291f019cd9008e727704e7e6679b274feb29abba0d92e036f349b1f0fa8c5271ec7384e8d70a2c3977b1f8a -a942c770e903d4150b5684e4b94bb72d0e171df2c7cae6f46e002c41c6b04d774ac6e2753ba8dccdbba3ad1e297a9ae5 -aa542d1849390f86d797408ed7f6a31504aa65d583481a00e475028af20f8b69248a87a8ffab1dace0377db77fe5f9b2 -a1ed3f9564a97f7cabe7c67e018eaeaa42db73a2f3d2332041ca9a7bea57436d848784d6dc402862c22a47f0692b1286 -925c757750c91db8b1b3c220fcbdd80742b4a060abfb0a402071d215c780ef6b420132ec5a43043b9fd7a06bf1b323db -94e575daa7fa0bbb35b4386f510fc3877c9df57bcf15349c5923f30ad6a8df95372835cc078216b41a7192921c1e8973 -9346a41174865d9ab31c7fb9a5329f322bfce06002386d3f5a2e2193de9bfff12bd0bd93307928f7b85e1097b2aaddff -a6e54c9324baa1bff7e9bf39c94fdd308ec6f210aad937112ec727565f8a6141375c04196831873bf506294854f6a20e -98d47b662504f400f1a0e14e24b43829490d022ade02a56288aaf148d466b45d89b5fc146cef67c9ba548cd37ad5e354 -ab690dd59a69904b6b3a4d5a42d17ea4898d9b00c6753aec216d5d4ea564f9a1642697df44d5a62f2c2ab19aaabf1532 -8d0aa8d3c5ec944af49beb99e403cc0d6d1adc6003b960075358a4ff1cbfa02a83d6cb4d848d9e83b34882446a330883 -af9334b7300780c752f32eaa68f3dcecd07dc50d265083f37f9800b02c2595ba24dab89f5fc27c1ecfdbf5291b4d77bc -81c4a6aaf7d4ccee9925c512dae5da6d916a6dd59f7a4cc79d216a91201b4d300114a309e3ddb3291bb95f85bec2a8ea -8c804e810c0785789de26e12b1beff56a163769733be7a31f34f81093782d6410293768a166c9191ef8636fc8724a31e -a91222b48de238f6dfe79c84080cee618611bd0bdca15cfe44474829e42481f8511a82589e69964e19f8cba04e3f5f3f -b26a8885aa594b0c8ad4a1711d80bcf687df996442075dd1497db1b446d16c74e28bc6f0e92b2ecea9c3e15c9c7e828a -85940f45d324ad1d335bd1d7d6f81758f52213e63d5770d9fe0c0c9507d5550795e538b6a2dd463f73d789b5ce377aed -931a277c78082f416880620df3aeb6d0bff2103d19679dd092ea981f5323e438c50a0d094908034ff8a2cb47b1a44108 -88dd85e4e2aa349a757b98661fc00d4538ec1d3f53daf44b16ffcf7f943dd4f2bba5b8ba3b05c529251dfeed73f6f1e9 -b7fd7182cd33639710b8216c54a11bb02e199bbc54fe33492a809dbe17771a685d6238ea3ebcfc75e3b0d4ea5369bc9f -85d77194d910f8cdad7330e1bca9087529a40fece17492f1d17cc4790833891b6d01d24f036b6422175c732b438faeb5 -9845265892d672d9517fbd22f88be4f225711b4abafa8327cc059f000656e4737188506051565d97912a0c19c3d063c0 -90a81987aa841c7f640c298b816643a0ae00cd3609c3a31d0b01245283cc785d9bb27763131b31a4f21aeda4e50073e8 -8b1256eb41a600bda8a06ac08b98a220ebfd52f89a0e4fdce32425db7a0481e9b7873ba3b7a24ad9fb782ee217dfdbf6 -870548998deed85c59507cec7e69cc001c279bb2a99c45a4d030a35c107e69feb76afecb9e435e67965051d6d7a88220 -b1504d194a0dd8df48d431ce991f89d7a0f72f573d21bd5bb46474c5005e43820877a44e62db555f194427ac8a4b9168 -a00d7423ec2cf0c9e9da07f3dae092d09e1ff4be852e07e531aa54d62ad937bfb52c8bf44683ac3a70f6dfc125575da1 -8019625ad3d218018803aacc2efcedba3a41c24aca8c5aab2005556e58fdf2ed614831277df7937aa594e97a2fc65e7d -8595596284f3add0155ecfee3fc0b66a6b6fc7923d82ca8302952e2ed906d119a1c053aed1123b51f73e1d30d93aba57 -a8ba033f5e7d06177e9ae2d99c40ed4e99e14e1c1b61795997f62e21ed8af1531c4720f23d6a39b0f75c6cd91c58c700 -a94f4167c0f6ae214bae75dd92c63299dd954b00b0d8b0416b8af929fe5aec6a259e44f83a183412d7ba4eb3a49728c0 -a73ee3c3a0fd2a369e0a279c3e214fb662d0378eea3c95cfb91412d7213a1f05958bd0de8f2a4f80f9f80d7eef943b41 -8ef6f3e241f6a761c9ab412629a49648c08b70b837c2cd8bea620bc93056ec73754e3e11f0df50f8e9fa67a9867501a9 -80b473ac4ba8cb82b4ae684206cde124d10fcf619f55a6c90d035981e1b08b9e141b4e5fa9a9af0b7f0c281b355dd593 -a566e2be0b41f01978dfffbb32f442b5e6706f5b9901110e645cf390f6a82869e3ca16887ffa35782a004d251d29c26e -a74e01eefa03546d00afdd24bf17015eee95d36de28c03c9b055e062cd5e8d8f20473c6d7ad21c94f9058fc5e84f9628 -acefc74de146911275dfd19bbe43d72729e89e96da04aff58e5fcb90962856c0b24eb13f43e30329f5477a1b65ae9400 -b5f113ef36e75de6d6d44130f38e460ad3ffc65cb9a5606828c4f7617981fecf76f5e862d7626ccb117aa757cc3c3e52 -96d3aeb1d3a66b136244062b891fc7f93ce745b776478d361a375ae57bdba9b4fcb257becbae228c1a3aff4a1c4fb5e2 -ab26c4a110877e5495b674569a32025dad599637b5dafedcfe32f205dfa68cd46f3ddf4f132a8e5765883b5c83214a07 -922a7a738066692193af32ccbab74edef067668ce3253e18a3275afcd5a6df7168deb2f5175c5fb413dc08fdaef63b17 -a47542f8e4a3a35ef6049280d1a9442c920887d5f1a1483149e143ca412318495a36decb804f81c9f5a7672a14965a4c -8fde57991e72a2aebd3376b4d9fdd795943ba3833431e52b136683567e6ee2cc1c1847dc49dc9534983060c54bf22f7e -addb041f01a99e7238ab2f9f2f94579861d0470b93b91cfb29f3a2e4c82386c868b2cfb6f3778b8a9cf908788acafe58 -a8c4e1df726431c43703739776e2cc51f5ebac57051244991baf53582538120133a44ca603d0722a4b5193e1be3c5ec0 -846379125968d1154376c5dc63100bdcd99b9403d182e3566fe48d79099099f51523cd81d21f0d1dcd622b715bdd851a -b828bf0d936d275abb40e3d73ef57fcd7ce97e9af35e194ae61463317bac6c1b0c3e4b40afe08a1061037bb7149108fc -abd07c71754973e698fa26c5019afd9551548f8369e2249b9902513f19a097057ee7065a1d88912e8f52e6e0fbfa6d82 -a9e36b6fcc9a3cc98e76d5751c76c50e1f92b7670f8076ab6ca8a30de4ec14c34669e049fd39bd293cde8789b1ca67f0 -8c060835496a04c7b51790790035862b20547e62fa8bb4e8857fb36891ec6309520af5c0f45d5ea46e3d228747d710a4 -8cc472ec62b8dce244373f40a821db585628989b6a7c4d394edffbc6346c8be455f4528d528fff41f91f2c875bd9fc0f -b4a75571f84f93451f15b3a86479063d7324d2789b6d2f2f4f8af68c66fac32743dc09b51df29608d62aaba78f6904af -916484984743b5ac16d40d0544faf9184819d92f779254b7fb892eb68cefbe59e75be8a6336a585e120f6ccae0a1eeac -b906ae585a73119764024e9eb87d92e53ee0c673474fec43fec4d344a3bbf471ce3976d25e37d197604689bbc944f1ab -8552708487305f16f95db3e01fbbfb969398f5b6d116844cbb000c9befd03f15c767584bf9541a42141949a4dc787a3a -a6025a2773f78c247f78c0d895ade8a6baa76e5499085f6175935d98a05fc41c1359f7843e0c6c323f1be256c45f45e6 -96dac695dd9288aeb6e32dce50e51ddf1fbd41de6146e3605c7a81f2253b17babf2bfda4f5a9d0c28352b9746c0dfa2c -a215b21f8eb2290f9d308278f2859a999eb3a31f4888f84a65f9ed05e1151c17777f91054d4d0de759ac5c3547d91929 -8fd7c9a279e9b619acf927d501b35dc551979731a89eab91d38b2356c0d73569baddacb9d1096d20a75c917ecaedadd6 -b985e8baa5195e2f1ea1091122d55aa321178d597f87b732b23eccb12b891638be1a992305a1ffcf5233af34339fa02c -ae1a9604b7f569aa48d2daa1889e76d3d103065fc8c3deb9ae127a6d94145695cab3bef640fa781612e8082c6d616c47 -a8fc67f9069f753360349eb874fa4dcadb2ec48d97c61abe568faee5f370ec3c87786c7faf0f73fc0ae7181a36eb89ca -a506d13acc3a9f80509fac936aef848cd30698631fff6130ed6217512ed9527d075f653cf6ef91f68e48a24c903eeb3a -a415093755cc012863043bf586b970bafdd87653ad14d1929672e04949bae4a753d16aa3eb5bd1afe3df3691b80f240f -ace3b792a1960580348b6fae8513149242378a18382741bbc2fb2f785cb8bf87550da4b5e0df2955970ab3a31f99f5d7 -a47d7fa7522664c8f9c404c18102f6f13a1db33ba8b0a56faa31a78a3decba3168c68f410115c5d9f240b3dc046dc9b4 -a9c930db3ea948cd2dd6ea9d0f9a465a5018bbaf6e9958013f151f89a3040cc03ae0b8eaf74b0ff96b4e7a6cd8aa5b4f -88abd235e3e760166cdedff4be82cf6ba02d68f51c6d53b1de326769f1f635215890f9a4c35b06dd16a9b93f30f3a471 -8f8d7b2fcdb70bfedde1ffd7f0b94108f0fa432f6ae81097988521dd2c4da928c10c5da3c7f33f11bd5331f2da8ec219 -b7abdbd48cece30d8f795a58a94913d76842cb006892485a9382a0502826538ca4ff951cc1ef4493e45de8571360d20d -b3e7b125f350c52695f7c5ec4a30916ea6c11744f1151a18ea0510e6cf6ed6f6dba4beaa4ca56988d306bd80ec360056 -9a004423c95e1f1714f98fb97ab798d6ab16cb5f6d6cad860635585d4d4b43ffcda63d8e931351189275e5a2cef28c2f -a8eab6ef917cacdc9b1932eb312309e1f85298d63e55ed9c89ab79da99d3eb60f1643d16be920e82d9285f60c7f7cab3 -934df955485113d10c4dde476ec14a98771145aadf3c8b61af26b09b9948757fa1abcc945ac91466a18c18c2fdce40d0 -99ed9146561597cff8add2196ff3a0f161dd5302685ceb846afca6efb5225f642e8f4a0970eecb01cdf18694fa697095 -b37062dd12a81267bbbf89bc9d6e30784c0e11e713cc49c6c96440f800f2a6a2a7e7f6c7f6c9eed4bc3c8890f2787342 -83a3d70055b6044e0207b3ece4da849755ab5798317b36b20c3555a392c27982f811e1c5007697554eeedc737b37f3ef -a85392c07ff8658935fbc52acec7221cd916c5fde8537a8444eefd507220e76f600350ae8f5dc3353911087b88b91045 -b1ea23558ad805dde9cc1eade995cd8e7f46d9afa230908b5fbaaa09f48547f49c2bd277bff8ab176f1c240beedd2b09 -8a16a48b9105d94700e8e5706b8d8a1ed14cffda5558a596974ea3191c5c3449da6e7efe2059e7baf4530a15f175ce16 -ac5fa54381fc565842417558e131df26e9505027759416165035357816a7e1859a7c14c228c79b4e5ba2ef6758e12ad8 -8475e290c399cc9322c05264a516cf766bf5fdb6b9dec7283961da0b99012d499b244b33fc0eaf94b461ab777f2a9537 -a7922f3c70e6857652805af7d435646c66d94eec174be997c4fe973d8f019990c4f757eeb730b2cfdf8154e6e97f7d5b -b90deb797fba3150cf265a23ea6bd49a382855cd4efe171cbcb1664683a9f1687cfcadfdca4e39cd971ec13aa5cdc296 -91ca761dd9659007d2fe8970bbd336c19ed0d2845d0d8aaab397116affcc793de2da73d89e6625cf4dae5983cceffa56 -9121ae9b60323ab1301e97555bcc74ddba0f5b1e62bfe9eaa2c239e1d685c4a614d397b32a59febed4db9968db44f38a -8477b07da4bbfe9087975f30d2c2333fccfcd7149f90e0e6fabecee627eee3ea324df31cf6a680393f5dedf68a35c9de -946a9c0f02fa6bf9f9d4933e7fc691749f4ac2f82a9b880666b5185189d4f3432da9096d0ea4d6baacbc079e19c887ce -b24663332914ea519435874d4c42d11842ea84dd3dc55292d5b0f27f64587848d095bacaec235a37003bdb5185daa6f2 -b980f46f84ac21dea75b4650f9412f6123325842758589a9b47caa68545905061f03fcad23cc102e2ce8ffeb1ae634a8 -90e9ebb060182d3043ea4210a2d934858559522a19eab9f0ff81a367484a05ec7cce78ee6a91dfff96145869db6a4e80 -b04228a009c91847693eab29c9ea71d1d6ba07060bc2b0b3bb81c46a125baecb3e1412f6ce4305076a97d316d14e4665 -8d3268370dbf38d378c7228c7b54e91f90f43cbfddc0d8468de11a4312616ca6372619209b89114152b16f334f4d2780 -964a63ffae653e0249685e227d937937b079ec3da9c977dad2b2e052af5eb560ce7d175941f2ae0df90e3d0a20b77e75 -855604c2910be885b14b27896e16d8dc339236b975398c771d29ac74e4278a2305fcf85203050a8faffddf64ea19cf78 -8e0b1d61a4349411eec77cf3490555843187a25a93e1f45bf66ad3982b9cc141b07805f8cb252b0fcc125e0052a7c450 -a03bc9588f971a1257cd0cfd2ca406c76aaeb634001864b0e4dda91e009d3361b33fc39f34922835031a423a13619a82 -b703fa855c2c4e1641d2687717fe8c5061acab71cd2dab55cdb069a6865464c3080f7936ddfd320516b6791b36c64b8c -aad1cfa7295e463fc3d5374ea4b952020010d67a77c7a86fe2c351a5959cd50df6a0045ad588257567a99bfd0e9400b3 -97906fb82abf5c1d9be8f72add8e6f175a6a5a4300b40295cb5ec8527cc7ec700fa03a7a494122d9605d212457452e41 -a83366cf93ad9a07f617e4002a10b624270f60083559b045ab5a805aaa592ac37b90c1e8b5437158f3bd942cf33bb633 -a585168e157e111bfa329d0ed6651a96509b20b30f6bb0691c6a5875d134d4a284867ab52511cdc19e360d10638e58a1 -b17d480a0b39f2487b7f3878714658fda82f2147c5ecbccd4004eb92d267c4663b42c93bafb95ce24e2f2f0a9ea14b8f -9362297a1a3951d92db4fd8ea6b48c403d6d8d2f7e7b6310b9cf9b4e4ba9e84cfe1ae025830aab9466c32fd659144474 -b1a62fbadfd4ea4909d8d0714c1e3ee9f95237fde20720f88d5ad25c274a6792158b99966d7b93151f769c832b6a132b -8d9af736949a33fe929548abe72384281365385862821a584f5198eed63bc5388f89fc574cda35a9eaabed0d336b86b6 -90ee2235f4ec2c6089b5cb7b8a41c9bc39e4a57935022ef28bed490e2ab12680922af7395bda4f708809e2bfc62192c9 -91f3a123d420bca34d3d751119bbebc435630c6605fb59a8d80d16a4895972e56cfe4cf1998e0a527c18ee38c2796617 -a2c4fbb20e7fbaae103b86ca9d8dbc2828e6bf33d1d7ce153bd98e8880fe7ac62abbf7059194b1eee64f4526a36c63a9 -91a7f93310ac74f385f11509f4bea9a4d74f2ce91cf2024fee32a4a44d5e636a73339c6b4027ee4d014a24b90de41ecb -914a6d405fee0a15e99704efb93fd240105572335f418d95e1f2de9afeb97f5f4b80aaf20bd5bf150b9da9abc2b6d6a5 -9462cf2c7e57e224389269b9fdddc593b31e1b72ab5389346aa9759fad5d218039a4a5bc496f4bf7982481bc0086292a -b7596132d972e15dc24f2cd0cf55ee4a6cc3f5a0e66dff33021a95e5a742889e811afd1dc0cd465cee6336ad96f25162 -99409bba2548f4ece04751308f815ecee71222869d8548fa142788fb19df5366d093a5131e57560237471bbd5279bbe5 -8e7560988a844b5b844ad460b19c452a5a04346d8c51ca20d3b144a3670ecc60c064b2415c2eeebf140d6ae4ba5c5360 -8cd9e18d311e178e00eb81ca839cfaa8e64e50a197de8461f07135fca28c1d895dd9c2401b923a4175ff711853497317 -91ebf99c95e8f653402b3079ecbd533ed7cd3b6c857a710142354ce8330cebdee7cf0fd0400417883b66055bec9d0552 -a9d0cf8cc6bbdc44426dcb716df667826426b4559056d73738bf3eaa6df373403861b6bbd6fa0454b1d2730e3b0015c4 -928320b452ef21d2443dee360110550f531d7a4275b2cb227814150f3e9e360e05a884d6e3bc4415f202120ea5ac333e -b9551f2b2e7bb984618f2e7467e33b5b5303b8707f503f2e696e49c2990ea760c31e0944d52257c7a38b553a67cf621c -b2ec34126fe61345e5c6361fe55b8fb3218cdcc9103bba5b200252d50b758153cd549226b7aabedd265906401e755190 -a8cf814926082a96a921d471036a9919a58e68d02ee671c215ea304759cd92a7c2c9ccebdd5e9ec5572164ad2abb22ad -8c0563c28c261bbe9a1ec4986f8b277324bf05b4fe5e2b79a862168e646bbea50ce7c4622b2aa7ca899c1a728c226d24 -b558cdc334ea894d3a13347ea9e30f78a0a20621903d6c009c54feceba3ba81d2445a43572e088ae691f65489702e963 -a62ba0b20f46c367cfd409beb300e39f1a6cd5be95e63457b6ad3cb66374aed754fd037b8e4215d651a7d8e1a442f762 -8543e2c6135df471bd7a5c09f1313674c7f6847cb88f15eabf40b2bc9535d0ec606725b97103334a0c162a20d9f5bb53 -8c0367d7058d63b425450f8ee9252e64234c0c2e61878c7c2d4b17bab22a72f40c75ac3bf8b64f264c00d9c5963af041 -acb7207445993d563f1b6e7b179bbd6e87044399f80e6d15980acf7aaccb9d85071fecb22250afb3aba850712fbda240 -b93725e66184bb03f0ab4078c737a7fb2b10294a3a09995958de3dcf5316b476ce9b5cd8d180017196d9482abdfcab88 -afcb52bb7b8f45a945299da6fc6a877ba9f69f7f23d5f94b5f5d9a04c3cf3089333bbd50fc305e3907825003da73b9f6 -961de781cb238cef52d43bc0dc7d8e3a75bca4c27ab37a2e9353137a9aa9403444a5841b595adeca75a3de5485ab97f6 -9408c828d3ed6df40cc167d72ca9882a9c9cf8e765d6f9125e02e0d66ee0ac94f449803afb50bf1b92176feae92473d6 -a85480591e7e033b9087fd0efe5cf3c88c10a75de4a5d7da4443df1cc1fa1aa59b6cde3ce7453fcabe555495e49ef6f7 -a2611bd82344bc5d70d7e6cf3f0d25866b9f709ac4bf6f75d1006da2a11e2cd07a4c0ac71505e5062a04f71db7a3063b -ac466aaa96febb5b810ba350c7a874797ce4bd6c9585f6b9d114d646894a67c9af9526ade4f7ec834d3a69e18ab643af -b73fc98a79fe77cdbc524c76a09cb9f2d5f8b0a5508846bed1ba5ea9ae3bb62120e01d3b8fb544d90ac9ae0c3d4ccefe -aed333c3403adc899a870082f70aadc770c9f880dc057f05a46d7400be9d893354121a0a31e5475898f437bf722eefcf -97f02133c72187178a8c48db26031f0b2c0317a6648d2be5f7450f00c37391cec935bea46b8144ec9fea5327ee959f27 -940b582b41f1d0f09f0c5f51bab471e4eb143e91b1e96dde83e94650421d51f9c9baec10cc802fb83cd63b56d0b907c0 -b1286a55a74a88a75da47671994916be428be1ca3f42783e497d6478eaa6aca69d50a421b210e9ed3283d578b651b8cf -97cd4e87e21c71d11f1df1c0b6518c00e1610661be4b13cdbdbb026d60fc3f4a2b8549326a648b3fdecb7de8f6aa9fb7 -8f36bbcccee986c35328633bf6ee8f70b5dbf42d0f677c0f4e009d2289976e512af6af91a6ddcd87dc0df93bc4ecd02d -9253ad44ad182e67ab574d718733a69c05cd5bcc43e6292ef0519a9430460aa6a233fe26269da7298ea88cf406e733c0 -b616b5ea74db0dcf8f10a2db79df6ec3566c06410f68a933eff150194608c591b2b175908d4b4ccaef1018b0fefc5693 -80a712ba89394381cbb83fedcaae914cc4f21ab024b8da8a7bbad7762a22f82940451427b1a3f5d84c246d5ba0c7ccc7 -a806909a5517a970879143ad789c6cb6256b82553b649f6865cdafbbc050b1f86528241b3cb600e784186e1a672b588f -b6ae801d1f0e4adf3ce57659d7c61f94abd3c8d1635ad28133a79eff0586fc48bdc195615335449e9bfee39e8a955eb2 -b8a000561211844bef72adf3413f3b438a8789fcddf6676402ca6a1c2c63b9deed322030de2ae3a0aeb3cedbb89406c3 -8bc3615b28e33fc24a7c989f8b4f719c914c4c65b35ad3d4cf15e2196e37c62e42ca34e8b1275e0f32589b969bdfc21b -b2f9637f370a79e7591e5056dac004f56b375f33645ae9f5a192cc6b7b6b3d8a1105cc00f10d8bc8ef250ecc2ac63c39 -b51899978b9c5b737999fee1935a5b0944261e7005bea411b5903d2c16ea045a3b0bcd69395b6733752caed43bc4e343 -873c71a01009dddb9885c48658f83aa6320e74bc152e09de8b631c763c2b4e2e8cbac921418a0d9085ff5c53a2b52d39 -96470f48efd7d2ac2daea8753ef097c09c6fc128a54cc7ef758ff07e32c0b0ac7d122f97b53e88a29cc26874dfee5e0d -8dd2decbd3504b7961d65edb8d51b96377f4edd2e0d2cd8a4d98333f373c79a8d7ca8f8408718d0e7b5e48255857c339 -b536ae387bdd0f6e40850c71fcaecb1051b2c8f7bf5cf92c6bda030de72a03e9212d00390c53a72a08e9fb2bff1249c0 -b1566076f59064e3545adef74fd1acadc1bee0ae23543c30caf9e1ad1fc20ebe84ee25004c612525b26857253f5345b7 -afd180e25444cb720342923b8897d38a6537bc33a0ca1fc9c6e4d524b280193618f19e2bcfbd07606b78b734fe6114ed -89b2a6c8811e5a6d07aa74c79dd854bdfc292cc104b525bc37e4c7c1f9485e19d759c8e27cd7cd73c46346f56ce3b189 -8234196e196898b2501b79d0dc016f6df3d5878952cdb8a93735e4ce2ecf77d07924c701e084533a20f0c50a7d1ee376 -adea7ce2efc77711f50138691ef1a2b946aaba08e7e3b21378708dd5a10bae933ed121e71834b43b14e2ea30a7b306e8 -a566d406a35fae703b3d1ea1791d9207116002e5ee008d01e053a1ea4fe5af2feb63605b011ae6a14414028aa054b861 -b83bbb063682386456719179b6f6bbc8cf6f791229600b7d402167737492f99437b45886695b26a28731e952e56f1ee1 -a8f5fffc2c335d3ad5c7593e81f0862351413cc348392afa86d50921dabb929a5a1de20d604666af9e17a13bbc30bc3b -8d5dcdc1335f01847f6ef650ff64b26e7c4cecb934a7bbce11254e8ced9fa9e4fc87eec55248f69bf499180101c63f5a -83fec30b8bc62f9fc28301a03ef18158d6364738f1c42de311bbfba2e62b25d4c9ea9d6097698b24c84fff956a6748b9 -96394fbe0c2d03cdaa56e13326aeb62344238ad3043ee2fb4f18ebf0a6f7f090f410032a2d15bfbeca9449202d59f2a0 -94880f5928fe71a797362a37d05849d23e118742697f75bc87173a777e7b9d4383b8796a8a2bbee27fb781f363301dfe -af229535896ab86fdf6d2ae676a0dbf44f868f6c7f17bd9a65567631c7aa2e29758f41de050ca5311bd1528bcc811532 -8d4fa4968575b483b3ac16345e7f1ea3f81e8dad72c945a48b7b982054fe1030584be2f89b2f53af84d2490cda551b84 -8052aeb115e4d242078c8726d376a13156cc832705243f14adaa3ef3889e1f2fcdfd46e087acab6fa85a74afde5f5eef -a1349c8a22788a1937a837fceecfaada9e93a63e582a09c56b53da52c9db1600254dc85f63f5eadfa30b89b31dcbdb30 -a10178cdb263ff1a5e0cc034b6deaa160d00c3c3fe1fd1ff0c55fdf1ecb83d771070c10930f88832b75fef39a10024ea -938b17e4405934ea5ef29c2187d6787c5ff5d8c9a02665efb453117d462dbc50ef2c202cbc884305cd807a70b5cc177b -84f01f0da6b58c71788616be71fb3c259ceea7f8bd131a5661c5c03d0205feaff6dac2915919347b0559c381477b3d89 -98787f0a2fac2b04bb7aa247ac77236bbe690aae64203e553be328a2c3bffb772e7a0244e585d27558cc64b089a5ee11 -a14501d8b6b3a84b13b9006d521667e8d168f642ebf154c4e90ec8c75d11985fd0c9d86fc2efa6c7077dafecfdf0ab13 -8215dee75eed04de83a3e910129bee8c48ce01cf1317ea477ff35c09a6f9e9771a8b05aa79e6b0f3e71b9874695e7a2a -85763c3072c7400a2c5668ef5cc53e6f4b8dff474146028a8be370ca9d8af9bf9ee10cd7d23d33eb6d6e257dd3af38d6 -91bf62245c5a59d514d39bfb74db7f72ca7160c1c5d5be3844fff37e53e99d451e18a6747c65e33f98f48a55f38962c6 -8c68817c6a6ea348d9aedce99929371c440fbad72718c2d239ffcaebb26ecc8a4e8c38c2819d945fdb7f02ffda70a5e0 -a96ce2745866a22267a49faa7ea00ebf009ea8d0b0ca2c233c62759b9d5514306b5822dd2eee0124c9e28380e2f97aa4 -8b18d5757c73843dcd55f0f0dc894bcd17e0ecf4c9fd901eacd38480844a15b4ce5e9598ccee039f9d93185137630cdb -a5b45c403b6735aaae14389bcee23ca10571f5437f1f5ab0c2b4e573dfd3341c638fff2cc780166af96b118d47ff2299 -ac849a0ccd354dd46bf55ea837d509b4ae3eefcbd5b8eb2582d301fd56c27b89950c6eefdd4e98e608ef4a6b75251311 -89f13ac14bb064e9c6b49a482831ecea6344faec490bd18bb44028b83a0f22e21145861558029bd172ba7c5247c2cba7 -aa57b057a2ac32c101e442c33831630c81b2e061a542e3e1d6897b2b7ca8a7241ef717a548b3f751d60d89be384ba5da -8a43db4e12682b98230364f25c75b49002f5002bd72a1674cf2a9d53197b5ef1b95e48429af98af503b0d5c3e0e017b2 -a10cd7b8e1574d78c4e917cf833d3d845b878e8e8b60312e6a994bd4f391a5e8c38dcd774087b93c9241238f43f80937 -8b61ccb949088286216cd628811df1a362a7f5c333654ce823e63ebd04b069d5b0f627fb6c96d54c7b853de8aab05472 -887b902020ad45f70f2d5bcfa7324fcbe7be09fd2b1bd40f9ae43a89d487986e89867aee0945ea6a0fe8dfd051ffec56 -822fcd260a7876cad31f54987053aab06108de336878b91b7a15d35013d6d4d6de2d4b30397bb6f1d5c1a7b48e9d1ced -80b89ff95d725858b50e84d825ea99fb6a8866f10b91a5d364671ccbb89cb292bada9537c30dbde56b989c8bdc355baa -b53cab156006c3a1766a57dd8013f4563a2e8250995dbeda99c5286a447618e8ac33ebf25704b9245266e009a0712dc5 -b6e2da9c1156e68c15861a05cd572976b21773e60fc5f2f58c93f3e19c73ad6c2ee3239e6cb4654040c8e15df75a505d -8b7e187d473a0bd0b493adcdb91ca07c9310fd915dec46c2c9f36a5144eb7425dd35dfa50feb0e9ef747caed9f199944 -9743ec3917e953e0a420406b53f4daa433adf4ad686207e9f296e7c83d1ffdbf81191b920ba635c85416e580178c16ff -98d1476fd4504a347c5261012298ca69c8593fec91919d37ddfdf84155b6f1c600cd8dbb92b93f3262da16cf40a0b3c6 -94f50d52982a3c81ac47a7b3032dad505b4e556804f8606d63d821f2c1a4830917614630d943642ba375b30409546385 -b5c0eb5f4cf3f719be1a9ad0103349269e8b798dbffe1b5b132370b9de1188a6d71dcbc3635dfdb4b888400f790b6ea4 -b47fb45ec73392598866d27994c2feb0b0f3d7fc54303a2090757a64b6426d183ae41af16794ced349ede98b9b3fd48c -b5f45fd0aee6194dd207e11881694191e7538b830bfe10a9666493ae8b971d65bc72214a4d483de17c2530d24687d666 -a50c149ea189387740d717290064a776e2af277deafcf5f0115bbbdc73c0840d630965a4e0214b738d1cb0d75737e822 -b941afc772043928c62e5dbe5aa563fa29882bff9b5811673f72286ac04fddf9a9ed0f9faf348268fa593a57bc00ba6b -839051a7838937270bdf2f8990fd9aa7d72bfc86cffe0b057aa8eca7393abf16b70d71a6470d877f8ec6771efa5a8f26 -835bc9d049418ab24dd1cbf76ed5811381e2f0b04035f15943327771f574f723b07c2b61a67a6f9ddc1a6a20b01f990d -8935cf5634d6ae7b21c797a7d56675e50f9d50240cb2461056632420f7f466fdcd944a777437dcb3342841ad4c3834bf -b5698fe3da1f9d1e176c9919fddd0d4d7376106774aa23a7a699f631566318d59b74ae8c033eba04d06f8cdcb4edbbed -ad11421ba75d74c600e220f4bce2ca7eacb28e082b993b4368d91218e7b96029acfbdf15a2ab0b8133b7c8027b3c785b -886ef813644599051dafdaa65363795cf34a3009933c469bd66a676fdd47fc0d590c401cc2686d1ba61fce0f693426d4 -8858fdf3e98e36d644257ab6076f7956f2e7eacc8530ec1da7f3e9001036cba7a0855fb5011925cdc95a69600de58b2d -b59eca7085a2f6dfeaa6a414b5216ff0160fbea28c0e2ad4f4ffd3d388e1cc2c23a32dbe517648221b75a92500af85e3 -abec62d259bcd65b31892badad4ac8d2088366d9591cd0dab408a9b70ad517db39c2ef5df52348ba4334dce06a4e3ba5 -a9acfe8f5a310779509621ed2946166ffb6168e68ecf6d5a3b2f6008df1728c8fceb811636c50d2e419b642a848a9ca9 -9929bb1a3537362848fac3f1bcb7cfb503dac0a0b1bebbfd6ddf14c9a73731e2248cbaf0fbb16c7d9c40cc6737c3a555 -981d06c7431e6f4654e32f1c5b27e7be89e7c38d59c4e2a872a0f0934cb852c6aeff2d2eaee8302131795590b8913f5e -a6ba9dd43354320f65fd5cdd5446cfa40080bcf3ef4a083a76ad4e6a609b0b088bcf26c4957bfab829dca6064410ca5f -9367ef28def311c79adfd87e617651fcc41ad8caf047d73ce9a1f327e8871e9b35d5b203fd0c0138e32e2ef91e20ba62 -855d1bb508a9036f42116c8bbb830c576189798baee27c7c3477ef1b1fc5d7b0c2c7203457f1eb48d4b029dd6f646be2 -8539a5d0528d3d601083e162b34cb33b5bf6736b4feeeab4941f10eea127c56b7e0b8d57f34b72f8f674d89c10bf302c -a3b71a9a9ac2dfcd681bfd8f6a5d9abf5df6950821705bdfb19db25f80d9b8a89fac7a922541cc681325679c629743d2 -8e95929dfd4e5b56e5a8882aad6b7e783337e39055a228b36022646a13a853d574603de5fed12b6c1f2585621ead7afd -8b05c885575d6894cb67ba737db5915639a6f281bf249480df444ff9f02724e28ed7371ee7ec26d50d25f3966010f763 -90f1a45de0cc0641181d54ee86630b5d182d24e7c30c2615803f16de90ec7c982a00b21f250ccebc2e94ef53a13e77e6 -90f0e97a132092e51a4521c2ecaaa47e4e4f319e67a3cdbd00ed85c2f10dfb69c339bc9498e2abbffcd54b1fdc509a20 -a9995234520cab9d1bdec1897b0b67571b718d5021c0fcf913140206b50ab515273b5f8a77e88fe96f718c80dd9be048 -aebc6495d54d0e45a3c74388891dbcfab767f574fed0581566415af872dc5b3bd5d808c44f6e1fbdde7aa9ffd260b035 -ae757f8f4b1000a623a7d8e337a50c3681544520683207e09d05e08a6f39384b7aaadf72018e88b401e4a7bb636f6483 -a626a28d5ce144cc0c6a30b90ec2c1412cbbc464ee96ac49035e5b3a37bb3e4ed74e8934c489b4563f2f7db1caf8b2ad -8c994e81dfd7a5c2f9d4425636611d5dd72d0b091a5862f8bec609d0cdd3c423eb95b0c999c48faa5dbb31e510c22b61 -a1c0e59e076b908de760d9becff24883c6eb9f968eac356e719c75cce481f2f7bcb1a41ed983a00c1a3b9369a7ff18f9 -8d7e199044fe2e552bc514668fe8171c3416515f7a5019f239c0384f0ade349e88df26cd30f6b67d02b83bf005d85de8 -80190f2255199be690fb502d02ed159aa568c390a684f7840512efc3d2a62f28a49d5d1928ad99a5f975ad81a245acd5 -889d84cefef33f5714e14d558f41d406072ba66b427bf27918b669c5be46261c3de0139610a2c2eadef8e6508e937bcb -a480a686d5085b854ccf9e261e7f1f2d40d978fc30b62b1a8fa9561127745529405820df21a680ee2258b8cefa5f0201 -ae6243400d416a8c13b80b6637726959ef07b8d9b6aff2bd3bb23aaaf97337c7a6b466c5db617bf2798e01d4ccc68e4d -85e0ff143657e465f3d934ee781de5cbd2bfd24f2fbbe6d65c698cdd93204a845f6ef1fa8941c2578463a06a8a418481 -8f4f8b45f1a9f6c2a711776db70f20149dd6d0e28d125906ba9893c5e74e31c195b0906f04c922c8b556ced7cd3d611d -877b852c33483b25c4cd8da74b6b589d8aa96e217c3c4d813466c77ef83af95a94a47364aa8421f0396ce631ad87d543 -852cb06bc4222ce125287a7a55a79ad0bf55596f26830dd6d79da3c60f80e3ba7b9a9b42b126dcb99d2cb9ce142783ef -810cd64c1dfce85d509eeb57a5c84efafe1d671454ef601a040de8d46fb33bc419577f6a6c404e28ffdfe315ffec558a -b60ff8bc804d101a32079b8ed52285fdbb47fd60c3c15cef17cfe7f6b0567de6b50128b9dbc49a1d9811b62b22c99143 -a9df7068b26a6a58f7a499e67b17d34f2a2e8e5029c6e51e2b4c0d19324fb5cd9734c4c4d5034e1bfc274cd0c74a82d0 -ad93c50802ded1e21217a58b874c074ea52322492d589820691572084d8edaede8c2ce8021c6df8c0060f395f3c25ee8 -a17b98e090f7ef5800477132b436c1fccc1802f34956711bfc176e36890c7df95a108e03f34659142434cbd8aee9dccd -acb14aea5575c293dc0a2b58c5350390801d57e9bcda876d87c56565043ddde1a544a88b48ad0d8ec3d41f690aef801e -88b8e26cbc83faa053fa247e26c95d1bbb77955b336e1b0e41d080633248238de8adc9b98688c98fdfc67e7286bc5be4 -899f69823cf1b2204c8da91bb4f943c04d943137b08b1c46e160919e3378bd22a666a079a66e63d81c05336c742efdd2 -8d7ffbc0b47a32408c9e88676ac4f87683cf37c37d214163ca630aec2d3cc014d88caff35022ff3b6d036eb8343d52a3 -b7760f27db0704a6742855998a0c31333bb34d60ddebc95588e25b72445ae2030427aab088ec023f94563118980f3b74 -ad06ecc0f3745861c266bf93f00b30d41ed89d41e99ab63fedd795c970d3ad40560e57ab7333883a72e5575a059df39c -8687d28b1cbc8aa34a0e5dbdb540a517da9bda36160daaa7801fce99754f5d16eda3bc8e1df6b0722cfb49e177e9bcb6 -a38332c3ebbd7f734c8e6ab23ae9756f47afbf7d1786fe45daebc8d7d005d6d8fd22f5dbd0fa8741e1bfb2014d3f9df7 -b86f84426dee88188be9c5cc10a41599e53b7733ba6f2402392b0ea985effc7525756ca1b7b92041ae323337618b238f -958731a6f1881f652d340832728bc7fadd1acebd8daebd772b5acea634e9f7b7254b76d38a7065ea1b2cdea83b18a54f -adb90bff1f0d7d45b8ba28b536c0e0f7f4dc4b9a0354692ecf29539631d7a57d308db3e438e0f907810234c490b42153 -a5188c775ad76617d3bb6e7f1f3b2449f48b7bb7a84035c316284396529564a227e3b9762a89c7114fa47b3ca7ba418a -a3826ef63c98793a5c8c5d5159e2e00cc85fb5e5124f06421b165de68c9495e93c2f23cd446adf6e6528967aa3ed3909 -80eab97de89f3824ace5565b540b229adcc6ef9d2940e90de185af309234cd8aa4ae9c7ce1b409b3898c8fd10c8c2896 -8824f5acd4c2330c459fdb9ece9313263a8b20419f50f8d49958dc21754c21a77bcf7fbf3e0041f78d8fb667a3342188 -95091cf06911a997a09b643326c2fadbbe302555ab2521db806a762a5f4492636507ca71d7a093840236ac3c096614f7 -a392c81a546196d7e78b61f3ceaadfb2771d09fe43f862c0af65f5e55ce490a0293b9ab754cb5ab03ff642a9a8213a23 -afd76cce1dfa2c9e4af4f840376674f090af37d8c6541824963373f97b9dd1f405c50b2ff56165e1d4dde760e590738a -8fc4f513d3b40c10872603e1c29a4b2cf4c99320962644ce89f69ffb57f844344e1d472b2d43559119bdfb5a2c21749a -9951ca8e13b9a2b4a789e851c04c4f030470772da62f101074ef304612e9653b43b37d2c081b5d0a09196b3a167f5871 -b4f16fc2a113403ab5fc1b6a9afddec77be7406413b70ee126f0e84796168a572940550d61e443e5635591d4b6c46ca9 -8d71452cf39e7345c7298d514b9638a5cbe78af7652f0286d42632c5c6d7953ed284551fb40c77569a7721413cdbf79c -953625b58d52a308cb00ad87c44a3fd936786ada44000d45bb609ea9db6b156a0d0f9475e13ee5e053eaded19a09990a -a0983a3baa278ad5f5de734eb1b65a04f668408994e396fb0b054991ad2e56e27ac522b04fe37c9583b754e344f795b3 -8eaa454257f77a6754b2c1c5ff0036fa5b03e214576fabc657902c737fcbf298b1795b43c5006e18894f951f5f7cd203 -90183fdeae2ce2a295a567fa61b997b1f975d1be7b03d0101728cd707bb2a7111c222588ab22e573518fa1ef03719f54 -8abec7f31f6b897a1d497368a42733a6bd14ffbb8b21d3e49fc4cd3c802da70e8886827c1aea0b18d1b44635f81ec461 -a6d1e6fd24b0878ff264b725662e489451c590b2aadaf357d64210a3701fe763f529826fa6e0555267c1f5ecc2c52c05 -8fe6d2a4ea0d91702cb2a8a1d802f5598f26d892f1a929ff056d2b928821e4b172c1c1c0505aa245813fe67074cf9834 -82a026a408003583036f16268113ca6067ce13e89c6e9af0a760f4b2481851c62fadeeef0d361f51dcd9fa5674ec5750 -a489a574b862d4056091ef630e089c163c16c2f104d95eb79a27ae1e898b26d6c1adc23edc1490f73bb545d3a6e3b348 -939d85148547fc7b9894497841bd4430bc670bb670f0efeac424b529a9aebf2c02ac18a9d1402a12e4e590d623de09f0 -a3ab52cf911a2ba7fb0cd242d7778ec0d4fa382960c9bd5b476bb1cd44ff1430a3871bbbcea0a0db2630c39ee639fd1e -b7629509d8c3a3b88b31f1af137a25c38f536284f11a5bbbe0d05b86a86bc92ebbf70f17c256dc8b0d48374e1985e6f3 -8a8647ff33e0747dd6c6ceddcf7938a542656174a08a31b08337ea49b08d814e75f8363fb51676a2cd2746569e3bc14e -a7a7f8d94d32b7cee00b3ff272d644b8dca86b8da38c726f632c2bcdfa0afb13fd0a9a5685ddaeb6073df4d9cfa3d878 -b7136eea8d05bfee2265b0e9addb4bdf060270894de30d593627891584b9446b363973de334b6105e0495cf8cb98e8f7 -a9fcd33ea59315ad7611a3e87e8d1fd6730c8cbeeaebd254e4d59ed7d92c97670303a2d22e881ab16c58779331837529 -965fd41741a0d898c2f2048945b2aefc49c735228c25deaf17fed82c4d52cf3f8e93b3fb8825ade632dc4940311b1542 -b9f400a2c7ca7da8b36470ee5d26c672b529b98e6582012cbfc2a3c24b72e73f5633de4265c417c0d47c474155a603c6 -85f333b0b1630a688a385f48bf0175cd13ecdd92fa5499494f4ad5aea0ef1b9d180fad8f936018538d842630ff72884c -8da95a735a1a98ed8e563099bd87d13a237dd7ec6880cfac56c6416b001e983a56f3d72dda7f68684bb33e4f64cadd30 -a29b66a2095e1acce751f6aec8dfeae1e5b24187dfedb5d1635ca8deae19b580ef09329a18b3385ebb117cd71671f4dd -b001deeeaf5eaf99ac558c60677b667b9f3d57cf43a2c4d57fd74b125a6da72ea6c9dc81b110655e0df01ca7b8a7a7ed -912e11dfff77c778969836d5029747b494dd81d9f965f8be2c9db9e8b08f53858eface81862c3ee6a9aa10993d0d23f3 -ac166a00e9793cf86753aa002ca274cb6f62328869fe920f5632a69a5d30d8d3ce3f0c5487cb354165763ca41d83495a -b74df519ae1a8faeff2ccd29892886b327c7434360ab5c5355752667069a77d466a48cb57b1950d10b6c47c88b2a8538 -8751679aeffa39da55f2c2a668f7b26fb8258f70c5454b13e2483e3ad452f3ac7cc4fa075783e72b4a121cd69936c176 -ae0cc16848b8bf8fffbb44047d6f1d32b52b19d3551d443a39fb25976a89d1a5d2909a4fc42ee81a98ad09d896bd90a9 -a0c8acd6a2f0d4ab0e0a680fa4a67b076bbbf42b9ec512eb04be05fb2625f6d2ed7b4349eebe61eb9f7bd4f85e9de7fa -85c629ce0deeb75c18a3b1b4e14577b5666cf25453a89d27f1029a2984133a2b8e7766597e2ff9ee26a65649b816b650 -938dbb477840d3ed27f903d09fd9959f6fec443fbc93324bc28300dd29e602bd3861fd29508da0dfdbb0fff7f09c5a6c -a7c76cd4a42ab7904d036fe6637471d9836ad15d0d26a07b1803b7fb8988b8c9edf522e0d337a1852131d0f658565ae7 -838a30260cf341ae0cd7a9df84cbc36354c6bc7b8f50c95d154453c9e8ec5435d5f9b23de2a5d91b55adde3dbdb755b9 -8f870b1f798c0516b679273c583c266c2020b8dea7e68be4b0628b85059d49e5a680709c3d6caabe767a0f03975c4626 -89bad0b6499d671b362ae898fee34ad285aa8c77d33ca1d66e8f85b5d637bbd7ae2145caae7d9f47e94c25e9d16b8c4f -af963d3dd3d983864c54b0ed1429c52b466383f07a1504215bbf998c071a099a3a1deb08d94b54630ac76d1d40cfc3da -b5686de207c3d60d4dcfe6a109c0b2f343ed1eb785941301b827b8c07a8f1311e481a56a4baab88edb3ddc4dace6a66a -95e5978739a3e875e76d927f7c68bdf7ab20966db9fa8859f46a837760dfe529afa9a371a184dfb89d2962c95d5fcf3b -96d2855e20c37ed7bd7f736e11cfba5f61bb78a68303a7ced418c4c29a889a4798c5680be721a46d548d63525637e6b0 -b134bceb776cd5866e911f8e96016704c9a3caeadcabd7c0f37204497d789bc949e41b93e4c2d597e4c924853f1b21e3 -a1949ff397013acde0303e5d64432bf6dd7f01caa03c5fc38e7c8ae705b9d5c2646b4b02d013004e5eb58e344703260c -8036a5f79d8aeb6df4810974cf8dbd0ac778906d2f82b969ac9dcfbe7ece832a7e8aad08a4dc520f7abeb24b1610ae84 -982b6b0af8602a992c389232b525d4239edc3ae6ceea77d7729d1fffc829664dd647ff91c4cb9c7f7c25cea507f03167 -b34c7d24fa56ab6acdb8af5b4fa694a1985a1741cc53a2b0c5833611e8ed6fb3b663a4d9a126bb4a1a469f2072199d66 -8166366fec4ee2b3eda097dc200cdfa0533a742dfbe7082dfa14c1c1ecafc9d9fa71f518476634f29d06430869bd5e02 -86c0251ac00b8200618c8b7ce696d1e88c587f91e38580b2d6ae48a3ef904e0ba1b20b7f432719ca40e7995f2281a696 -afd89f3bc7843a1e45ac961e49c1971114c5238d9e21647804b1852b8f476a89c12d1edfb97fff71445e879d6bfd3b70 -911d8bec4d4c3e73a2c35469b2167569f59705404425bd95440408fb788e122f96e9b1bd695f35c6b090f10135b20cd3 -b3f6350ff7afaa0660f9dddd9559db7f164e89351a743fc695d987c88f89fc29136e3c5eb81963edabf2b6f2057120be -a371229680d1468777862e9c0e864156f9cd7c12ce7313a8de67b7bd34e3d1b6fa45ce891a81f8316f4afcbdecf3b6ca -a6a9a875ef9efe8ba72523e645b5773aa62c4fb41efd23da3fa38105472308b8d293be766342ee0a2f00758825bd3b6a -a840d495a184f4499b944ee08f07193a1e1bb8ab21f8ce7aa51d03bd8643f2bc2616c17b68d3fe7c0fb364136926a166 -b55200ae7d6ebb0b04b748051c5907293184b126cf8a1c2f357e024f1a63220b573e2875df83d9b5e0c6e2ace9300c40 -b1e0870f2e3719f42a48256ee58cc27f613308680f2d3645c0f6db0187042dddcfed0cb545423a1a0b851b3a16146d70 -b43a22ff3f838ad43786dc120b7f89a399ed432c7d3aa4e2062ad4152021b6fa01d41b7698da596d6452570c49a62062 -88b1dc50873564560affaa277b1c9d955aebdcdd4117dab1973306893b0e3f090899210102e7e1eef6f7cdf2f4e0e5db -9223c6246aa320b1b36eb1e28b5f9ccc2977e847850964f9762c7559da9546e508503050e5566ccb67262d570162b7a3 -aeeed21b932752709f43dc0c2c7d27d20263b96a54175dd675677a40a093f02bba80e2e65afe3eb22732a7617bf4ff9d -b47cae580ae84f4e4303db8f684f559382f075ef6e95698b9a629e92b67bf004f64e7cf47e401768fa170c4259efbda1 -849821e1ead81fe2dc49cd59f2bba305578c4ea0e8f4b8ae8fc275a1c4a6192f8819d5b6d7da786c94dfc16aacf3e236 -8c60d9a8baefc72a3d3f9dd2e24cca40fb5ce36b19d075122391d9b371c904a0a15d2196c0f2ac9da3acf188d15b0fe8 -946edfe168bbe5ddb0fa6c2890bb227d8418bfbebe2bafab84909825484f799407b610d8aab6a900c5ff9eb796cdc4bf -ae7bf8ae71de5d7ea644d9541e49da1ec31eca6ff4c3fbec5480d30e07ef2c2046cc0a486af7b3615a6a908846341e99 -b4d31a6f578463c9a5ccde0ea526c95b1981eb79468665395c0e550829abfdfa86689699d57830856e324092a423f231 -93415ad3a732417cca9771b056ed42db7ce50879aca7c6f71883ad297eaf5a37fd4641d44a0b7e28b90c168834141340 -98960617a413a3ba86d8257a7386355a69258943aa71834166bd624ea93b0af06178e86538e237f88fd039eacf7cb04a -881335200a487545e38d5b1ffda3080caf5729e1b980603bcdf9ea652cea7848335b83aeeaa321d3476ae4a8d9073582 -b39e84c14666d51895b7a8341fd8319f9e0a58b2a50fc3d7925cce3037f7c75367b5fb5bf25ff4720c9992cab7b8b9f4 -8ea4bab42ee3f0772d6bd24dff3643d8b61147b46ada374414d8d35c0c340e458e449d31023d96e66decf9c58e30cc34 -a5198f6759a045b6a4ba28e4bc3bb638fad44c5a139064327580e285adf38ea82a7570acebf925e81a39d9025f3a6f2e -80267097e2d27c1b19ecf95d184dcff822d34e03326b9fc139a4f8b75b3f80777bb97a9dd284d9b755f14dd401d63c0e -946f346220bd3b6f733e94b61a1ad0b44e45c356fa6036dde5882d93b5613c98e23b20e91eddc6b3c5acea38085705af -a5f559e110cad99bbcae2d9362434aee7db0f3b6d72311291649dbda3f84c10e9760b66b988db3d30067bf18ae2e5238 -8433b38e5c7b293ef532f8c70cef1ed9be7f31f60d5b532e65df7d2885203be78b7ad78ab3011bc54cd9f64c789bf837 -a5a4c0a9b0e0b6bb912cf6ecd30738b0acc0146d77442449b486c3f32d7e60244f643a5cf9cc6da2de5408d0c5f17691 -a81feb329fb51b72464bddcfcf4e02149d995b548d88c64ba143144ce16b652c9913c8ee948ee837596ec97cc43d8cc9 -88e5a7e93a738d61330425bc21ade88d33d7160d124bf174eb3e12a00283654431036977c4f1a47a1bbbf2ef8449ac89 -ac75ad7c099383069e662bfd3624b92b64b5838246902e167fc31b9411efda89b2c6bbd1d61b9eb7d304faacf438d70b -8583bcd1c7cb9bb4bb6bcff803b0a991912b8403a63c0d997761ff77295ccc357d0292318601a8c61329ab28fed7bb83 -a1f9aa0523f1dff00023a44a6c3a9e4e123be0f6722a1c6682ac3c6047efe9e62f4773daf4767e854e1fcbf8ee7339e2 -85f65ebcf5c7e574174b7c4c4166a9a5368e7986b8c0ef846c2e13b75dea7311a87483503149ebfb3cb839b3ef35c82d -abc55eeb72699031a367b9675a2b91a8434e1f01467660903ced43a0b2a11a85ebdf48f95c13ff67e4e2958065a50ff3 -a4ff77c9b86939a15647499b9412417b984bfb051e5bf27b35392a258a5dac297bbdbcf753a4be6729ffb16be924a2ff -af0d41c15b5172efa801cc85ed101b76844dcd06712d0d21160893235a2dbedd15d187a9b31cf0d0ca6c14de6ab2b707 -92661339199f18e5dd9a210783c1d173a26dfa315bd99a33d6f04bf506c871a2b47745c1909faa209d5e6c5c645124a4 -b35813dafb52df709dfa47982bfb44e1bf704f9f46085b2a0e92511dff90e5597110f614f8915830821fc5ed69ae0083 -934a05aa713fa276a4d47f1a28ef06591e5a9a69293c1651c223174df0af4927fc9cd43d374d89c1b4f7c8dc91abe44b -8f83a0ef05202c0b7170ac96f880135e2256fdf8964dae5aed5dd0f6452a6d8e123321e8c182b3aa6f1f8ab767caa735 -b92db10c21c321cf1349fd34129d7180e5088daf2bbe570de6427299aab68992c011c2e2939a44247396f5427c1d914a -95ce1892d1ce25ef2bc88a23880055a4d829a3b31f3806635fd49bec32cca4e965b129b6dd3e90f7e3a2eb293ffc548d -970cf816ee7501ade36b0b59f87c7e352957f67f1f75bbacd8ed52893f9fc40572c76f49c23db44866af7e34a63cd3f9 -a2fcd08581d3569fff699fd7ed1ede5f98f2b95956ecdf975a29af053d9f4f42600b3616ad6161e958c3ce60139c20a4 -b032688b6cc8a7e63dcb82694f71f087b1ee74c4d5fa27323b1ead3ba21722d7fc49eda765725b5553db5260005049c3 -b0b79e4329f1ad25ef6a603390baf889757cab5af10bfa6953a61f89aaace0442b9ef08e57ba778f1e97bf22f16f0ace -a2e6ac06f8973266cd0df447f82cec16614df65174c756e07f513e2c19aa82c10d8670047860960cfba3c5e4c42768c8 -811e66df0f3721a1ae0293549a0e3cd789f93fb6be2cab8e16015a6d52482af9057b1b75e9456322a5a9e87235e024cd -8744a80b3d9e37da4c50c536007981a4958d7e531cb93916dbf985cdc22f4ff482a5cc4fe50915c049d2de66530f1881 -b20b6e8c7be654c23c8ca440be2c37cf9cc9f4e81feedfd0cd7c56f37eda8f295fe5d415e9bac93d5f0a237edd8bc465 -b33fd84377f31f7819150d464b5eb3ef66e06cb8712665cf0587d61e1b1c121d11cc647f3753bbc18604941c77edbc1f -83acb8a3ec5f477b6d44cd49f9e091bc2bf7c9dfee876cde12075a7db9262314cb66ad2e7557114e0c19373e31c6eff1 -acfe4172327832ee207eb07da9cd37da3b009c776f7a8290529f0249f58da213254baddc7c3074fbaa1d226ba1e52b7c -81911b4dea863424b9d77a981987732382702e0294d8c8e1ec48e89678ecb0e64836b45205a120885fa8f8a3a4b9d4b0 -b11f61b1302579a11077bb2f1f0db371ab943573b261be288dc76172eee8a5102b992a5b526092d160ffd20aac2d4856 -ab491f7f1e002a44944c02537f365e525ebb6d5614bba8e5e8e8bd12064c702a1759571ddbeee592a0ba8b73cfce8810 -89211da3d92aed6b111de001b8b5a9231a1c2d09fb1cd2618ec457b635a6c8590fe119acca42fce76dce791c35b889c7 -a5f076c8f7164bcab8af59021ef97a0afa93d0877e52241c3ff5a9a9f81227a55c119ed6a84d34b196e94ec851ca5ca0 -80d91417d0d6c1adb5a3708165da1d54a83caaff482a4f65abf3fb335cbbc738c74ed19a8c451ca98befdf9b2d8b5f90 -aecba33a67f66401614eec5fa945e763da284edb9dc713bad4ac03972630781a09a3e2a291aac0605a9560c5f3444de5 -8a0aa1320bf5217a049b02ad02a4f892bfd6a3f5b48f472041d12f3aaab8dd197307f144f9de5f9e762c6b4971a121b4 -a4120a569e446fe4129f998e51f09c1cc7b29dc2b353d6f6f05daad1a4ef99acfcbaa4950a58aacf7ee1b3fde0af33d0 -aff71370d58b145758a5f24cf3c0c6667d22a1f950b8137c369fa845a5265cd645b422f24fa95e1cd7db1d68686120b6 -a839f075a8a702809a51fbc94595eab4f269a2e7a027aa1f4fc472e77f586138bf5aa4e5570a560e139eb6cda4cca161 -9484f1caa3e35cda0e3d36e43aff3dd8cf45a5a51fc34aafa3a63ed3543047ba9d6af2a9bc7c201c028499e6b4c41b28 -84ddb374c5c9170903bb3e1054fad071b0a147a9ca2ebe2fdb491ebb2431d53b398872a39cc385f973e38579d8e60158 -acaad8babaeaeb52c5b5a16ae689fa5ae15846f2d1f3596a52371bd8681819603822ee8d32ab8cda1bd5290d601e483f -946b69ca5361b60c3dc31db13669b05e5c0452f3c80e7e185f9667a36f351e9ed83bcb5c6dd2439ecd4490e3a87d260a -99f457221ac40df86f9b4bef0bf8812720b2f7218273a0aab08c4d4d4fb18a0fb0ef6ba9bf7fa53c116cc6f16742e44f -8bc0e812d8b718dbe48ead74a6bc7bac68897d01d097422be04110a25589bacd50d336d2c8b70d0dfde6c1b8bc372dc3 -895d118dae2fb35a4b0de22be0d000ec0f0f317b9494db7c12f10d7db81b6f3eaf6d6f3fdfe952f86ec4143d7469368d -893bf3d7e579e800526bc317438a69590d33759931830daf965cec721baa793ea335e9624a86b84b8fed5effc3e2bbac -a112d30dda88c749ca15d6dc65bcbc7fe838b2d25329d44410a9a96db195c7ce6a6921196a61ba7c9d40efdb101a164d -b88b5340af052fc3b8e1a8cf7532206801e79d878f1fb02b32ac4f8e91b64e0ec9252d808b87c4579de15886a20aaef1 -865f76475bb5da18c6a078c720c7b718e55d310876c98017c30ac31882ae347258b508ec34001918324250241d2df5b7 -b6d8a15913eb1714061d5cacbd0bb05edd83ecdb848a89b864e7411598e9f7814d0c039ebe4735437c8370d2ff183751 -a95fedce8351ae9c24d7fa06ebc5cd4e3aef87afaf04a7150e561a6a7f2347bdcec1e56b82d6e5f597fe7124f6cc503b -8526004ca0c802b073d50b0902ea69975949e7567b2e59ca2cf420bc53d91951d26096f2abb07a2955a51506e86488dd -99ccecaab68b6e5adadb9c848cb577de7e7ff4afc48d3b6b73bc0872730245b8a1c68cebf467074af6756d6226f4f4a7 -b5497d5c0cd79b7e6022e295642e1f2161254379eb78ef45e47f02c84ef5a3f6b6297718e4fac8093bf017287e456917 -b6943f30012b2093c351413c2b1b648afc14a5c4c0c338179d497e908451d2779919fe806181452ed386c1e8f8e8c25c -afdb56ce89bcd3247876c918cad68aad8da65d03c7c73ccbee0c4c39f3ad615aab87ffa0db5b3b63b4cc915d0b66deb7 -a44659d7be2f11d4d4949571d7bf84a6f27f874d3281edc34ef1098d321a4dcad9a42632b39633f8f9d20a39f54a2464 -a3e489b4db5832280dd58c62120262471b6fb4355c2ad307bd17c5c246b3f1e1b00f925930f5f5f6987de234fcbb7d16 -87a4e3a190340ed4949597703083d338e9c17263ba8a39b67100589f0dddbc420d9557f9522c17c71ae04b76876f8db0 -a35a3978e928eaac8c182a0a613c611ae7b4827c5e999f938eed06921c0294befdc21d02e68d035a2fc8d03c82641126 -a6898d90265dcf0fb215629f04b07c7918e022667583efe0bfe02f258b446954876c6ca9e369ffe1bb079e2314ebda32 -922fc52e648b6b2b6768c079c67ab425da72907a46add801715f8a2537280869d7071d527b833aa63ef562ce059a392b -8acbb7c4297196d8d1c131040c34cc7064656a148c2110b19c672abb094b1d084fafe967f7122ba9dd1523a4eaec3b42 -82dbf2cdd581fe3b81b156792228eae2485710e6c21dd5fd14614dc341bb0afbebbc0f32340eda9f094b630afcfc17e8 -907a095dca885da219e4558e9251ec765cf616e995c61546bc010963bf26f2d8adbd9b2ef61f2036e1740a627c20fbed -a7a83f849691d04640137989a2d0c90a7ed42a42b0ad328435d7e1fba557a27a58eec9170ab3d0099ec97da0c950765a -b7d435a801c2a5652cb479027f2c172eafa3df8ca0d896bbb9d49a42c42660fb382a8439bfed09ddf7e0214cb6066761 -8bc6b5e79af5512589f90de8e69bc858277055cf7243f592cc4edd193f03f71d16c9300097ddafb79752c63f135c884c -913264fca800467bee58a429e1f245ef303f5dbeea90f0ce6bb3c7ae6d1bd0f99ea75d3d309634684d2178642c81b5d8 -83ba558f9c23b785a123027c52924a1d7334c853a6165d4f5afd093b0b41951a36860ba0a20fa68f73d7db9df0e3ef38 -875b2df7cb54ecdf7ba31181b9dc7dbe02761ab8ffb61757d42a735c8e20d44bad5b904e76dcec6bb44883fdb9f4ad84 -af3dc5d2dd29565de8f4c700d5f1ab71dadb4351f06e9ee2eb5ee7a9b5da827d0c6726c6dc780748a26aa3b4d10e6c2d -a113ff09296b25f550f6d0d3f37dd4517b14cf6d5517293bd3068aa3aea765a8640fcd4bf0ba96db5c00167267fbd574 -a138c5cca485b9180ef091c9e327982bea203c165cb83564f416c36e813bea1ef1f6345f57c8a591df360541b7b758f5 -85793441e917ed520d41dda6e762269fb9f9702e5ef83cee3e90652d324536bf4233425cd05b54a383609076ab84ea13 -b422ac9de53d329e6321a8544c264d63cffc37965d627d7e180a999c3332644e21fedf10cd2f43cf6ba4fc542db91155 -a85d31d4bfa583a493681e57bfccca677ec5b85870a53de37f7be7833b573f8c8dcf029cea4ae548d83048030d77d56d -ab8a0702a371db496715a4ee8fcb6d430641b0f666d7fe3ef80c09df0bf570293cec1aa1675381c6bbd9ecc1f7cdccf9 -b308ef2b87438d35957191294782e9f5014a3394fadad3e2ccaf6ebf20fd889a36dbb8ddb3634baa8e2e131618aa4e70 -919e972e5b67cd65f377e937d67c27b4dd6fd42cfe394a34a70e8c253a1922f62ff36b9dcc7fbbc29b0960ad6a7fde88 -a0e4d4be28301af38a910971c8391ef3ec822ce35757226a7fd96955cd79afa14accba484ef4e7073e46b4b240a5863f -9422f6d424c1736b4b9bb9762aa62944085e8662c4460319dac4877b1e705aa5cd8b6b3a91268363ec3857c185685f4b -b7cf9f2053119d284a37df4e4489b632594df64e5dc846652ee26b4715e352e6333118b125021481138e4ec3e9f9987b -aea983e81c823472df8652654be8a60a8bf40147d599f87e323397f06bf88c98e9c6db0f28414f6ea4091f3eb0f6a96d -aa20bf03cd8b6ffda09fe0ef693fc0aaa3bb372603e786700e52063a4f7ee742771c41cf5e67e6248f99b7fc73f68dbf -8748a4978198071d7d5ddc08f8c8f0675d895dc19df0889e70bd86d44c469c719b93f6526c7e7e916c7bfeb9a1379aaf -b8fcd863d55dab2f7b1c93844306e00056ba17338ddfa3f02689a0b58b30239beb687b64c79b8420ecea8d0d082d9ffa -abb1a35952dc8a74dd1cdbc8ae7294c6bfd1910edab6f05c879e9ed06c636a949fe0017ec67f8f6f73effcb5817cccae -8bef43422b1c59e354b7f46c08a8eb78e26c4d01c236a4fe781cefb7465293a4444f2bdc68c6a221cd585a2494d9a1d7 -93527258940feff61befa18fcd6626fcff019d34a3ac8c6886599cbef75b15c15d689e8c1bd2177cc93c4c1792dee8d7 -b7f114eea99c8278841180ec8886ad2bab1826554a1657b9eeb17aa815f31b59c3931913ddec40aa9923bc92f8975635 -91a96446158b194a0a6ada2e37c8a45f3017c34034f757245f6f3b98c65d39d084e74d2a9dc271e5918faa53990ec63f -aea4ada0a853753db03f9790e20bab80d106f9b09e950f09aeaba5d869f0173bed673b866a96d6b0dd8123a539caac9a -b8e3e98ff0d3e512441e008a4a6783233045a4639e0c215c81984846b43ff98de99d7925cf717b1ca644f6229b6d16a2 -8987ef81a75213894e11e0310e8ba60fe06e2b264cc61655e5b51bf41cc8c3d6c10696642ea3517770f93be360207621 -8d4eff7335252f74af4a619c78625fd245df640f2086338dbb6c26b059f83fe70f3e81f5b6c12d62c0f784e572d56865 -a56f6389b0bac338f20c615d7d11e16045a76cbea23ced0a9d9067f538421c378200bfd4523b7c96094ab67f47f98d42 -83f5ab0727fd6ce8b3370ce3fac1f3a9c1930ea7ebbd16be61cc26f34aa1291ba4b5f16729d7d4f5924eaa4a1e31a04e -8cc62366874bf8751067a526ea32927584cef41174e2ec5a53079ee557067bc282f372b831cb2547c5e21a2f178c91b4 -b609e141006dc8d8649457efc03f8710d49abb34bc26a33ed4e173e51b85d7acdf18d74aed161b074f679d88f5aa2bf3 -873c7aa784c17b678443320950e494250baff8766db42619b9fc7ec4c3afa4eee290cd1f822b925d5b9e55c9cdd1af2f -859ba787f052d3665481c3dd58159ec8c238d918fb6d2787ebe275ef9acd377cb7aaa03a69820c78247bf51afee3d5bf -8eb1e6d2b0f51a3275b4a8be96957cb2d518b32c815dc0dfd5f75340c7dee73e5edc45db7c7d375c4ffaf8c59767d0c1 -85f3876ff5edbb826a9592e68db3dcc975725bfdda4fcac197758a8b27e4f493e6c531b1342ba0f5a75f965273720345 -8a1272f2678d4ba57e76c8758818965e6849971e8296b60ff85a522feeaaa3d23d3696c040d8bdaf1b380db392e988aa -85002b31ce31be7cc8757141a59a7cf9228b83144993d325b2241f5bfac09a02aca0c336307257f1a978c0bbf79fa4fe -b96bd26a6bbbc705c640285fd561943ef659fca73f25e8bf28cfcd21195752b40359d0edca0adc252d6e1784da267197 -936cfe367b83a798ab495b220f19cfe2e5bde1b879c8a130f84516ac07e3e3addcc791dc0e83a69c3afc225bed008542 -b1302f36190e204efd9b1d720bfaec162fcbba1b30400669dbcdd6e302c8c28f8b58b8bbde10f4512467dd78ed70d5e0 -8291b49f56259c8d6b4fd71525725dd1f35b87858606fc3fe7e048ac48b8a23ba3f0b1907b7c0d0c5ef6fa76cddc23f0 -97aca69d8e88ed8d468d538f863e624f6aed86424c6b7a861e3f45c8bf47c03e7b15d35e01f7add0a4157af171d9360c -b590d896e6b6f2e4dcffebfa67fc087fa518a9c8cb0834a5668cabe44e5c2b6f248f309b9cd74779030e172dba5d9e29 -97e7099bff654bcb37b051a3e8a5a7672d6ab7e93747a97b062fc7ae00c95deef51f5ced2966499217147058e00da4be -83435b739426f1b57f54ebad423939a68ad3d520db8ca5b7e28d1142ebfb4df93f418b180a6c226c0ca28fa0651163a0 -946c9144d982837c4dbc0b59544bdbc9f57e7c9ef0c82a7ad8cfddea78dedc379dbc97af54ba3ac751d844842a2990a4 -90ba1eff9c25adba8c3e6ef5b0d46c13de304632fec0646ee3a7bee69da2bc29e162dd3fb98a37ed1184ae5da359cf0a -b17b7a5c0a48eb9784efb5ff8499230b45efeb801cf68e13fe16d0d308511af5aa60e3b9a5610f96d7c2242ae57d455b -9991245e5617c4ea71575e5b2efe444f09cbbed13b130da08f8e9809d62512e8298a88d41f6aa3dbf3bcbc90654ceb18 -a1190c4cbccf2898a7fe025afd03f8652973a11cef59775fb47d69a6b4dcb9a5a0c554070421a5e10a75e43b63d37b79 -857c0a5f291eb35a76be11543a8c3d798187bd0717e2cdee50d390b66322d0d9529520fd3377136cdc93cfee99b6403f -944d11e5f9a3493c67786df94f129352d892fbdc43e98206b8dbf83cce240f65305e1768b38e5576048a31dca5c18f31 -818f361c5dae709e067a82b81beffbd9674de8df2bc1bfc3a27ddf326260e124e46b1e36697fb8de539b7736db093e9e -b07f5b737735a0d628e7ac2d335080b769bdb3acea38ad121e247a6e4307916ba1d029da5d341f079ea61eeaf7d8554e -a69e338803f3ee0fbbddc7ee481a13f6b64d25d71bae0d76f4b5145b54923cf1616c77ba0fd9ca37a3ae47208f490423 -acaee66b94e226622e28a144f93f6b1b442b9c79d7a8a1740c4d53044d0675a661e7453509b9e716e469fe11ce45ee31 -9402ca799d2e1cce0317ed49453ee0b2669b05e68ff101b89306db215c3941b3786ad3402d00369cb1dee020b56d3142 -849440c539fc0df3c8d06e23e271e6faa50234d5c057b8561e9376415f4396e548351cc677b0abeafe4f51b855a3dc83 -865b99587eb3dbc17e412647673f22b2e89185d1df1ec8ea04515585ad2edfb731be458123118dcd7b41b475026477b9 -9390618833b5adbaf24bd38cf9fc6f25104717f314259bb4da5c7a1f6963ecdc04d07bed391d8cd765c3d53567b2b6b1 -95383e8b1d0a629cec238b5ae2bda236a027f4e3b5f99ceace05f1d5a781ec1e7a43058f44ef0a5aee6b0db5697a0d89 -91739b8946d90db3a5244f7485295cc58143ba0449c9e539df1ba3c166ecf85ff914c9941192963c32d35033ae2f0980 -b5d88848d856d882db5947b9182025f0abf2bc4335b650fa0a48a578e2c87f32cc86d42d3b665ee2eab46d072bf1eccd -91f4c754549f5a53b1902ef84274ce9acf0bfd2e824e62eb127d67e3214ce05fc2430c05ea51e94dc6e8978f5d076bab -91fff8c75f8ad86afe78ec301de05e4ca71421d731419a17c747a9a0bf81129422c9499e4749107b168d1695dc90292f -99fbd7bede9cc1e2974c2a21c70788960c2dbf45a89552da8d73bb1d398b8399590707f2f4ba4b43cb356e703eb01b5e -80a51cd83e3d748c07b9ac82de1a697b09031e3edc7bf585f06cd0ffa8ea319517fcc2b735614b656677b54b4910814e -886b27de1f93311d1a31b6d698aa28b54fbd800decd8e25243d89e352ee38cb252d5648b5134a3e1ed021bae46e9da48 -976e70c94db905f83b4ef72188d840874bf005814c0c772f3832aa65b1f21927403125eea7a07b6d3305b1a781b36ab7 -b4adb9d1c49eb31462583580e3ffa625bea4f8b2a7d4927e4ff925c1759d4b3c1e43283d635b54fb0eabfbe1f4c12992 -b66b466bd48485ebeedd47e749d86cbaa3deffbbee2e69cfaa5e9f3bd28b143d7c1c0255a7a1393a2cc1490b2c485571 -8bded5bc0794513947ddb00ff6b780c5cc63a74e2a0b0284153c346a31c82e1eff07c073939da39e6f87a06c14ff1a80 -aceea8c6f799589f6b7070abf69fec724e6679514e60f1eaf9a52c37e9cebb72abcc833a81d8da1a4f5194c1a7eeff63 -89a9f76d053379687fd221ebcaf02c15c2c241bb673ef5298e32640a115d9e0f2331c3e185572cd65946dd6c5bd42412 -a57b6f1e3fdd92eadc6220760f22d0685a82cada1c7a1bda96d36e48e2852f74f3a83c757dd8857e0aee59e978da4919 -9106cf0891bb39ce87433c5f06a5c97a071d08ad44a7cbcd6918c0729c66bb317fbbee8aa45591cee332ad1234c7257d -96c18cca4a0f0299e0027ff697798085f9f698a7237052c5f191b1dba914e5a015ae356b80c17f0fdd31d08c5a939ebb -a892103c93df126c024825c07d8769bdac5f1d26ea9509ee26530dc594384b2a5095cc34e0b41ab3db0392a29792c9e8 -b7c2dbc95edb6fc25802ea051803b7bea682f87a99f8a9fdcc3091c81d914b9493dfb18a8894c964805298a6c22b07f2 -8e40948927d560a6840d7fb99802989ce72b43693e9dc7ed9dcda4bca7daedf75271cf656bcc22b3f999a550faad8648 -b354de1c6f0603df3ed9036c610281e55b51a48950ee3ce57a00b4692232de7ca57d19722700e15cbe67a91fcec2f786 -adf987b90737b933436d8036c1d3f0c9104f26c540052e22e703964f72739ac1261e4289b8f27dec47281a0f3f51378a -8ed5248e9c836fffa7c924178db593e1aaeb54bcf2e93c1983c1f3899cad538deeb2b836430fddc9b2f283e0797ea11e -907e5410e3bd5d7f55340e2f497bd1ca10bfcb4abed2c66a3cdf94dc40bbd7c43ac98754e0b4b223ea4c61eebf2f27f5 -8e81b441ea0397db28840fb4b3c3bfe6d8e31418816f7bda36f9c1cfe4556daee30c43639d90a2dc9b02a3d65e5f4ab2 -897085c477f5030f9fed06e181b05953a8cd2001d959dd6139738d40f1d673b2c7120b5348f678547acfdc90ffc9fcc6 -b0bf2784c4b3808a04be5a00a0593035ce162b3886e1500247b48365eac8ec3d27c7e5e6372e030c779c75fb79772d0d -af3fe6c75f2a1241ac885d5091ff3882cf01695d957d882e940f0c31f7a5b5e269c1a2bae7336e9a7cda2b1d23c03bd1 -a6d94e065f85736d77080a4f775885ccb0dd5efdbe747e4595280bca0ebe12450257c1beadcbec77566ef57508c5d4df -a5c50fe56b5532bf391da639a2f2b6cbb2634fc6637416fea7c29a522dea024d4adaaa29b6d472b4d2cc3e3b85c72e2a -afc35f5a03b245a6286318ef489db05d397bbd16c17b4e92eeb56509f875246c0176c01804139eb67dc4247c2a36ff9e -99ba14ab5a9612c078f9bbaa0e68fd1d52ecceb2ed19bd9abf8f98dd4ed1f9c4fa6e4d41bcef69be2ff020b291749ca8 -8018cdd3d96f331b4c470a4c3904bed44cadecbeec2544ca10e4352cf4ae1a856cf55f6383d666bf997ad3e16816006e -a9964790c318bb07b8fe61d230dd2161dd3160e186004647a925cfec4c583b4e33530bf5d93d8a14338b090055085b05 -ab89d8401df722101c2785cb3ef833017f58376ee82cedd3e9405b2534f259bb76063434a247652c7615a6de5194de65 -a72c3d320a0d40936dee8edfb36703be633aefbb8f89530df04eb6aebe0305ef4f4b6709436f8036d417272a7e47e22a -b3457661ad62634cc25e2918921a97b0bf5c59ccc7063bc8eb53194783f07659f42f8978c589228af5b12696588d8b2f -926fa35cd3ed4c8ad78af6284b87ae53b2e25a1ff50398034142a2bbed5b989ba3181ff116838931742c0fbcd8b8a56c -ae57fe506626432f27ae4f8791421c2df9efd9aaabe4b840ccf65fc3d0dd2f83e19eb63ae87bfa6898d37b5da869ddb2 -99c0a26ac74211db77918156d7ae9bea6ecf48da3ce9e53829a9ad5ed41321227c94fbd7449ae2e44aae801811552b1b -abdd2635b61cb948e51b762a256cf9d159b9fcb39b2fb11ba2fed1cb53475a03fc6e024a6a824a67a689396119a36a7b -a5ca98b98da8bb8eb07b1e5e3c85a854db42addefacd141771a0c63a8e198421dccc55ef1d94662ca99a7d83b9173fc3 -a821bb5cf1eb3aeae6318c8d554e2ea3137d73bb29d2e4450c9a33f441355ea77bb0e0e0ce7c819abc3ed119110a3a92 -95cdfb19b3f7196c26d60586e2c1efaa93352a712f8c8ef6209f6f318cecd52d7bebdfbfee4be1f5903a1595f73bc985 -aef6e6a400106e217f9888afcef0a1e1299b59017e77dc5453317dec0c32ae96873608bef3f1b504a7e4f45b06edc9c6 -96399ad093299ba26dc09ae85dbec9a1801dea4a338dd5d578bcdcb91246db0059e54098ba8a56cbb24600a40095cf79 -ad8b018ac99857ad4b38bdf6d110bbef64029a4d9f08df85a278c6ddc362a5f64e1f3a919f798ccb2f85a7f4ca1260b4 -b211f3b5dd91941d119c4fe05e2b4c7bb0ce0a8d7ef05932a96e850f549a78cd20cded0b3adb3f9f8b7058889ae2cb4e -ab780dd363671765c9c9ab0f4e7096aacf5894e042b75f40a92df8eb272a6229078cd6eadcc500eead3650860aa82177 -a4d96b16ab3abe77ead9b4477c81957e66a028f95557e390352743da53d1a7ba0c81d928a7ea8bc03b9900135ac36a6a -b4d4e028099bf0f28ac32141cd8de4ee7c3d62d4f519fad6abbb4ba39592750812220a4167d1da4c4f46df965f7cf43d -aa929c5f0bd8cb44a861bfb3d18340a58c61d82afa642447b71b1470a7b99fe3d5796bdd016b121838cb3594f5a92967 -a038e66f0a28aba19d7079643788db3eed8e412fb9ab4c0f6cacf438af4657cc386a7c22ae97ccc8c33f19a572d6431c -89c1ff879faa80428910e00b632d31c0cebb0c67e8f5ded333d41f918032282fb59fbcbe26d3156592f9692213667560 -8d899072c9d30e27065d73c79ce3130a09b6a4a4c7d9c4e4488fda4d52ad72bd5f1fd80f3a8936ef79cf362a60817453 -8ffb84a897df9031f9a8e7af06855180562f7ca796489b51bb7cca8d0ca1d9766a4de197a3eb7e298b1dfb39bc6e9778 -836ebd0b37e7ef4ff7b4fc5af157b75fa07a2244045c3852702eaafa119ca1260c654a872f1b3708b65671a2ece66ad2 -9292dfd6d5bfc95f043f4eb9855c10cbcf90fbd03e7a256c163749b23a307b46a331bdbd202236dca0e8ea29e24906de -8bc37eaa720e293e32b7986061d2ffcbd654d8143e661aabe5602adc832ab535cffbe12a7b571d423675636a74b956e4 -887455f368515340eb6f9b535f16a1cf3e22f0ceda2ead08c5caefccef4087e9f4b5d61c5b110ff3e28e4ab2ad9e97c5 -a6e5ec36e7712056fec00de15b8696952b17891e48ebe2fa90c6f782c7d927b430917b36b4a25b3d8466da3ca2a4985d -895cae36ba786104ec45740c5dc4f2416b2adce6e806815e3994e98d9e1be372eaec50094fbb7089015684874631ab7e -9687444fe6250c246b1711a8f73992f15c3cac801e79c54ffd5e243ad539fdd98727043e4f62d36daf866750de1ba926 -b17f75044c8e9ce311bb421a5427006b6fa1428706d04613bd31328f4549decd133e62f4b1917016e36eb02ea316a0ca -8538a84d2f9079dd272a7383ff03b7674f50b9c220e0399c794a2bcb825d643d0fc8095d972d5186b6f0fe9db0f7084f -af07b37644cc216e7083bac1c4e6095fa898f3417699df172c1f6e55d6c13c11f5279edd4c7714d65360b5e4c3c6731e -87eed8fe7486c0794884c344c07d3964f8fc065aebb0bb3426506ab879b2e0dfaefa5cece213ec16c7b20e6f946c0bd2 -8a4bf42f141d8bc47c9702779d692a72752510ef38e290d36f529f545a2295082a936c8420f59d74b200a8fff55167c4 -a7170e5e00a504a3b37cb19facf399c227497a0b1e9c8a161d541cb553eb8211449c6ac26fe79a7ff7b1c17f33591d74 -a9a2cc7232f07ef9f6d451680648f6b4985ecab5db0125787ac37280e4c07c8210bab254d0b758fd5e8c6bcf2ee2b9ff -8908d82ebfa78a3de5c56e052d9b5d442af67a510e88a76ba89e4919ae1620c5d15655f663810cfc0ee56c256a420737 -a9d47f3d14047ca86c5db9b71f99568768eaa8a6eb327981203fdb594bdb0a8df2a4a307f22dcea19d74801f4648ea89 -a7c287e0e202ebfc5be261c1279af71f7a2096614ee6526cd8b70e38bb5b0b7aca21a17140d0eddea2f2b849c251656a -97807451e61557d122f638c3f736ab4dab603538396dca0fcdf99f434a6e1f9def0521816b819b1c57ecdfa93bd077eb -a8486d60742446396c9d8bc0d4bed868171de4127e9a5a227f24cbf4efbbe5689bbd38f2105498706a6179340b00aed5 -a03b97c2a543dfefa1deb316db9316191ab14e3dd58255ce1027b4e65060d02fb5cb0d6ac1a2bf45bfeac72537b26429 -a7d25060f6861873410c296a4959a058174e9a1681ac41770788191df67fc1391545dab09de06b56cd73a811b676aa1b -96bb9c9aa85d205e085434d44f5021d8bbafc52cd2727b44e2a66094a4e5467b6294d24146b54c0d964c711e74a258d4 -b07b17f11267e577191e920fa5966880f85ff7089ac59d5d550e46f3a5cdadd94f438a547cd1ec66f20a447e421f96c6 -964e33e1571c97088fe7c8ca3430db60a8119f743a47aa0827e6e2fb9bae5ff3bf6cecd17b11dd34628546b6eb938372 -82a0513a05870b96509a559164e6ff26988ea8a2227ac6da9adc96fe793485a9eb6bdcab09afac7be4aef9a5ae358199 -b1185bc679623e7a37a873d90a2a6393fb5ccc86e74ba4ba6f71277df3623cde632feae4414d6429db6b4babde16dee0 -b3d77504b7032b5593a674d3c0cd2efbf56b2b44ed7fe8669f752828045e4e68202a37bf441f674b9c134886d4cee1df -95ab31749ff1f7b3f165ce45af943c6ed1f1071448c37009643a5f0281875695c16c28fc8d8011a71a108a2d8758e57d -b234dee9c56c582084af6546d1853f58e158549b28670b6783b4b5d7d52f00e805e73044a8b8bd44f3d5e10816c57ecc -86da5d2343f652715c1df58a4581e4010cf4cbe27a8c72bb92e322152000d14e44cc36e37ff6a55db890b29096c599b9 -8b7be904c50f36453eff8c6267edcb4086a2f4803777d4414c5c70c45b97541753def16833e691d6b68d9ef19a15cb23 -b1f4e81b2cdb08bd73404a4095255fa5d28bcd1992a5fd7e5d929cfd5f35645793462805a092ec621946aaf5607ef471 -a7f2ca8dacb03825ef537669baff512baf1ea39a1a0333f6af93505f37ed2e4bbd56cb9c3b246810feee7bacdf4c2759 -996d0c6c0530c44c1599ffdf7042c42698e5e9efee4feb92f2674431bbddf8cf26d109f5d54208071079dfa801e01052 -b99647e7d428f3baa450841f10e2dc704ce8125634cc5e7e72a8aa149bf1b6035adce8979a116a97c58c93e5774f72b7 -95960a7f95ad47b4a917920f1a82fbbecd17a4050e443f7f85b325929c1e1f803cf3d812d2cedeab724d11b135dde7a3 -8f9cd1efdf176b80e961c54090e114324616b2764a147a0d7538efe6b0c406ec09fd6f04a011ff40e0fa0b774dd98888 -b99431d2e946ac4be383b38a49b26e92139b17e6e0f0b0dc0481b59f1ff029fb73a0fc7e6fff3e28d7c3678d6479f5a3 -a888887a4241ce156bedf74f5e72bfa2c6d580a438e206932aefc020678d3d0eb7df4c9fe8142a7c27191837f46a6af6 -ab62224ea33b9a66722eb73cfd1434b85b63c121d92e3eebb1dff8b80dd861238acf2003f80f9341bfea6bde0bfcd38c -9115df3026971dd3efe7e33618449ff94e8fd8c165de0b08d4a9593a906bbed67ec3ed925b921752700f9e54cd00b983 -95de78c37e354decd2b80f8f5a817d153309a6a8e2f0c82a9586a32051a9af03e437a1fb03d1b147f0be489ef76b578b -a7b8a6e383de7739063f24772460e36209be9e1d367fe42153ffe1bccb788a699e1c8b27336435cd7bf85d51ba6bfdd6 -937a8af7ed18d1a55bf3bbe21e24363ae2cb4c8f000418047bf696501aaeec41f2ddf952fd80ef3373f61566faa276a9 -ab5e4931771aeb41c10fa1796d6002b06e512620e9d1c1649c282f296853c913f44e06e377a02f57192b8f09937282eb -893d88009754c84ec1c523a381d2a443cb6d3879e98a1965e41759420a088a7582e4d0456067b2f90d9d56af4ea94bba -91b2388a4146ebaaa977fec28ffbfb88ac2a1089a8a258f0451c4152877065f50402a9397ba045b896997208b46f3ebf -8ce0523192e4cc8348cd0c79354a4930137f6f08063de4a940ea66c0b31d5ea315ce9d9c5c2ec4fa6ee79d4df83840dd -b72f75c4ab77aca8df1a1b691b6ef1a3ff1c343dd9ed48212542e447d2ed3af3017c9ad6826991e9ef472348c21b72a4 -af0fa5a960f185326877daf735ad96c6bd8f8f99ab0ab22e0119c22a0939976ece5c6a878c40380497570dc397844dba -adf9f41393e1196e59b39499623da81be9f76df047ae2472ce5a45f83871bb2a0233e00233b52c5c2fa97a6870fbab0a -8d9fc3aecd8b9a9fca8951753eea8b3e6b9eb8819a31cca8c85a9606ce1bd3885edb4d8cdbc6f0c54449c12927285996 -901969c1d6cac2adcdc83818d91b41dc29ef39c3d84a6f68740b262657ec9bd7871e09b0a9b156b39fa62065c61dacb1 -9536a48ccd2c98f2dcbff3d81578bbb8f828bf94d8d846d985f575059cd7fb28dfa138b481d305a07b42fcb92bacfa11 -8d336654833833558e01b7213dc0217d7943544d36d25b46ecc1e31a2992439679205b5b3ab36a8410311109daa5aa00 -95113547163e969240701e7414bf38212140db073f90a65708c5970a6aaf3aba029590a94839618fc3f7dd4f23306734 -a959d77a159b07b0d3d41a107c24a39f7514f8ce24efa046cfcf6ace852a1d948747f59c80eb06277dce1a2ba2ec8ea9 -8d2cb52dd7f5c56ef479c0937b83b8519fa49eb19b13ea2ec67266a7b3d227fb8d0c2454c4618d63da1c8e5d4171ac7b -9941698c5078936d2c402d7db6756cc60c542682977f7e0497906a45df6b8d0ffe540f09a023c9593188ba1b8ce6dfcb -9631d9b7ec0fc2de8051c0a7b68c831ba5271c17644b815e8428e81bad056abb51b9ca2424d41819e09125baf7aaf2d4 -a0f3d27b29a63f9626e1925eec38047c92c9ab3f72504bf1d45700a612682ad4bf4a4de41d2432e27b745b1613ff22f9 -80e3701acfd01fc5b16ecfa0c6c6fd4c50fe60643c77de513f0ad7a1a2201e49479aa59056fd6c331e44292f820a6a2c -a758c81743ab68b8895db3d75030c5dd4b2ccc9f4a26e69eb54635378a2abfc21cba6ca431afb3f00be66cffba6ab616 -a397acb2e119d667f1ab5f13796fd611e1813f98f554112c4c478956c6a0ebaceef3afae7ee71f279277df19e8e4543a -a95df7d52b535044a7c3cf3b95a03bafd4466bdb905f9b5f5290a6e5c2ac0f0e295136da2625df6161ab49abcdacb40f -8639fc0c48211135909d9e999459568dbdbbc7439933bab43d503e07e796a1f008930e8a8450e8346ab110ec558bcbb9 -a837bcc0524614af9e7b677532fabfb48a50d8bec662578ba22f72462caabda93c35750eed6d77b936636bf165c6f14e -97d51535c469c867666e0e0d9ed8c2472aa27916370e6c3de7d6b2351a022e2a5330de6d23c112880b0dc5a4e90f2438 -aadb093c06bd86bd450e3eb5aa20f542d450f9f62b4510e196f2659f2e3667b0fe026517c33e268af75a9c1b2bc45619 -860cef2e0310d1a49a9dd6bc18d1ca3841ed1121d96a4f51008799b6e99eb65f48838cd1e0c134f7358a3346332f3c73 -b11c4f9e7ef56db46636474a91d6416bcb4954e34b93abf509f8c3f790b98f04bd0853104ec4a1ff5401a66f27475fce -87cb52e90a96c5ee581dc8ab241e2fd5df976fe57cc08d9ffda3925a04398e7cffaf5a74c90a7319927f27c8a1f3cef5 -b03831449f658a418a27fd91da32024fdf2b904baf1ba3b17bbf9400eaddc16c3d09ad62cc18a92b780c10b0543c9013 -94e228af11cb38532e7256fa4a293a39ffa8f3920ed1c5ad6f39ce532e789bb262b354273af062add4ca04841f99d3aa -99eb3aeb61ec15f3719145cf80501f1336f357cc79fca6981ea14320faed1d04ebe0dbce91d710d25c4e4dc5b6461ebf -920a3c4b0d0fbe379a675e8938047ea3ec8d47b94430399b69dd4f46315ee44bd62089c9a25e7fa5a13a989612fe3d09 -b6414a9a9650100a4c0960c129fa67e765fe42489e50868dd94e315e68d5471e11bfbc86faffb90670e0bec6f4542869 -94b85e0b06580a85d45e57dae1cfd9d967d35bdfcd84169ef48b333c9321f2902278c2594c2e51fecd8dbcd221951e29 -b2c0a0dd75e04a85def2a886ee1fda51f530e33b56f3c2cf61d1605d40217aa549eef3361d05975d565519c6079cc2ac -abb0ea261116c3f395360d5ac731a7514a3c290f29346dc82bacb024d5455d61c442fefe99cc94dddcae47e30c0e031f -a32d95ae590baa7956497eddf4c56bff5dfdc08c5817168196c794516610fcc4dbcd82cf9061716d880e151b455b01e0 -8bd589fb6e3041f3ef9b8c50d29aed1a39e90719681f61b75a27489256a73c78c50c09dd9d994c83f0e75dfe40b4de84 -82d01cdaf949d2c7f4db7bfadbf47e80ff9d9374c91512b5a77762488308e013689416c684528a1b16423c6b48406baf -b23e20deb7e1bbbc328cbe6e11874d6bdbb675704a55af1039b630a2866b53d4b48419db834a89b31ebed2cfc41278dd -a371559d29262abd4b13df5a6a5c23adab5a483f9a33a8d043163fcb659263322ee94f872f55b67447b0a488f88672d6 -85b33ddf4a6472cacc0ed9b5ec75ed54b3157e73a2d88986c9afa8cb542e662a74797a9a4fec9111c67e5a81c54c82b3 -af1248bc47a6426c69011694f369dc0ec445f1810b3914a2ff7b830b69c7e4eaa4bafec8b10ed00b5372b0c78655a59b -94b261ed52d5637fd4c81187000bd0e5c5398ce25797b91c61b30d7b18d614ab9a2ca83d66a51faf4c3f98714e5b0ea5 -953d4571c1b83279f6c5958727aaf9285d8b8cbdbfbaff51527b4a8cfdd73d3439ba862cdb0e2356e74987ff66d2c4d9 -b765dae55d0651aca3b3eaef4ca477f0b0fda8d25c89dccd53a5573dd0c4be7faaadaa4e90029cdd7c09a76d4ce51b91 -b6d7b7c41556c85c3894d0d350510b512a0e22089d3d1dd240ad14c2c2b0ce1f003388100f3154ad80ec50892a033294 -a64561dc4b42289c2edf121f934bc6a6e283d7dce128a703f9a9555e0df7dda2825525dbd3679cd6ba7716de230a3142 -a46c574721e8be4a3b10d41c71057270cca42eec94ca2268ee4ab5426c7ce894efa9fa525623252a6a1b97bcf855a0a5 -a66d37f1999c9c6e071d2a961074c3d9fdcf9c94bf3e6c6ed82693095538dd445f45496e4c83b5333b9c8e0e64233adc -ab13814b227a0043e7d1ff6365360e292aca65d39602d8e0a574d22d25d99ccb94417c9b73095632ff302e3d9a09d067 -b2c445b69cff70d913143b722440d2564a05558d418c8ef847483b5196d7e581c094bae1dbb91c4499501cfa2c027759 -87cbde089962d5f093324b71e2976edbe6ad54fb8834dd6e73da9585b8935fca1c597b4d525949699fdfa79686721616 -a2c7e60966acb09c56cf9ad5bdcc820dcabf21ef7784970d10353048cf3b7df7790a40395561d1064e03109eaac0df98 -8ea7b8af208678178553946b2ee9e68c0e751b34f3652409a5e66c40d3aee3a40ba6ffe2175ce16c6a81b78ecc597d02 -960234239e1e3ea262e53d256ad41b2fe73f506b3d130732d0ee48819eb8a9c85bb5106a304874d8625afae682c34015 -858459694c4e8fdafa6cdaee1184e1305ca6e102222b99b8e283dd9bb3ebf80e55d6c4d8831a072b813c8eceb8124d95 -a30a8ce0f44aeb5590dc618c81c7cac441470ce79fd7881a8f2ea4ca5f9d848ebde762fcaee985cbd3d5990367403351 -a83867643672248b07d3705813b56489453e7bc546cdba570468152d9a1bd04f0656034e7d03736ea156fc97c88dc37f -a7bb52e0fc58b940dc47ea4d0a583012ee41fad285aba1a60a6c54fa32cfe819146888c5d63222c93f90de15745efb2b -8627bcc853bdeaad37f1d0f7d6b30ada9b481ccdf79b618803673de8a142e8a4ce3e7e16caed1170a7332119bcdc10a9 -8903d9dc3716b59e8e99e469bd9fde6f4bca857ce24f3a23db817012f1ea415c2b4656c7aeca31d810582bb3e1c08cc6 -875169863a325b16f892ad8a7385be94d35e398408138bd0a8468923c05123d53dba4ce0e572ea48fcdadd9bd9faa47a -b255b98d46d6cc44235e6ce794cc0c1d3bd074c51d58436a7796ce6dc0ae69f4edaa3771b35d3b8a2a9acd2f6736fab3 -9740c4d0ee40e79715a70890efda3455633ce3a715cbfc26a53e314ebbe61937b0346b4859df5b72eb20bcba96983870 -a44ce22ab5ddc23953b02ec187a0f419db134522306a9078e1e13d5bf45d536450d48016a5e1885a346997003d024db0 -90af81c08afdccd83a33f21d0dc0305898347f8bd77cc29385b9de9d2408434857044aec3b74cb72585338c122e83bb4 -80e162a7656c9ae38efa91ae93e5bd6cb903f921f9f50874694b9a9e0e2d2595411963d0e3f0c2d536b86f83b6e4d6ef -8b49fa6babe47291f9d290df35e94e83be1946784b9c7867efd8bc97a12be453013939667164b24aeb53d8950288a442 -a1df6435d718915df3da6dda61da1532a86e196dc7632703508679630f5f14d4cb44ce89eff489d7ff3fe599cc193940 -afd44c143dbb94c71acc2a309c9c88b8847ef45d98479fccce9920db9b268e8e36f8db9f02ff4ee3cff01e548f719627 -b2cf33d65d205e944b691292c2d9b0b124c9de546076dd80630742989f1ffd07102813c64d69ba2a902a928a08bce801 -b9f295e9f9eca432b2d5c77d6316186027caca40a6d6713f41356497a507b6e8716fb471faf973aaa4e856983183c269 -b3bd50c4b034473edce4b9be1171376a522899cb0c1a1ae7dc22dd2b52d20537cf4129797235084648ac4a3afc1fa854 -8ef37683d7ca37c950ba4df72564888bedaf681931d942d0ea88ead5cc90f4cbef07985a3c55686a225f76f7d90e137d -82107855b330bc9d644129cebecf2efbfab90f81792c3928279f110250e727ce12790fd5117501c895057fa76a484fc0 -816a5474c3b545fb0b58d3118cc3088a6d83aad790dbf93025ad8b94a2659cceba4fa6a6b994cb66603cc9aef683a5e3 -8f633f9b31f3bb9b0b01ea1a8830f897ecd79c28f257a6417af6a5f64e6c78b66c586cf8d26586830bd007fb6279cd35 -acb69d55a732b51693d4b11f7d14d21258d3a3af0936385a7ce61e9d7028a8fe0dd902bda09b33fb728bc8a1bc542035 -8d099582ac1f46768c17bf5a39c13015cfe145958d7fc6ddfd2876ad3b1a55a383fbe940e797db2b2b3dc8a232f545dc -97a4dd488b70bf772348ececaca4cf87bc2875d3846f29fe6ef01190c5b030219b9e4f8137d49ea0cc50ca418024c488 -b4d81148f93fa8ec0656bbfb5f9d96bbf5879fa533004a960faac9fd9f0fe541481935fdf1f9b5dd08dff38469ef81c5 -8e9b2ae4fc57b817f9465610a77966caaff013229018f6c90fa695bd734cb713b78a345b2e9254b1aff87df58c1cd512 -99eb7126e347c636e9a906e6bfdc7c8ca0c1d08580c08e6609889a5d515848c7ca0f32ab3a90c0e346f976a7883611f7 -8ca87944aa3e398492b268bda0d97917f598bc0b28584aa629dfec1c3f5729d2874db422727d82219880577267641baa -88ab0e290dc9a6878d6b4e98891ff6bfc090e8f621d966493fcbe1336cc6848fcbb958d15abcfa77091d337da4e70e74 -8956a2e1dc3ec5eb21f4f93a5e8f0600a06e409bb5ec54e062a1290dff9ce339b53fbbfc4d42b4eed21accea07b724d6 -8d22220da9dc477af2bddb85c7073c742c4d43b7afee4761eba9346cadbcd522106ed8294281a7ef2e69883c28da0685 -90dafd9a96db7e1d6bde424245305c94251d5d07e682198ae129cd77bd2907a86d34722cbde06683cc2ca67cebe54033 -b5202e62cf8ea8e145b12394bd52fd09bda9145a5f78285b52fda4628c4e2ccfc2c208ecde4951bd0a59ac03fa8bc202 -8959856793ba4acf680fb36438c9722da74d835a9fe25a08cf9e32d7800c890a8299c7d350141d2e6b9feceb2ebb636f -ab0aa23c1cd2d095825a3456861871d298043b615ae03fcd9283f388f0deef3cc76899e7fde15899e3edf362b4b4657f -9603b333cc48fe39bea8d9824cfee6ac6c4e21668c162c196ecd1ff08ef4052ace96a785c36b8f7906fdcb6bc8802ddd -93bfecbc3c7cc03c563240e109850a74948f9fa078eb903b322368cda0b50888663a17953579578ba060b14dbf053024 -b01f843b808cf7939a474de155a45462e159eb5044f00c6d77e0f7ec812720a3153209e971a971ccbf5ebee76ec4074f -b009e0567c3c75ed767247d06fa39049a4d95df3392d35a9808cb114accf934e78f765cd18a2290efef016f1918c7aeb -ad35631df8331da3a12f059813dfa343d831225a392f9c7e641c7d23a6c1ad8df8e021201c9f6afb27c1575948d6bf68 -a89c2a631d84128471c8ef3d24b6c35c97b4b9b5dad905c1a092fb9396ae0370e215a82308e13e90e7bb6ebcc455eb2a -b59c7f5fbfeb02f8f69e6cedef7ff104982551f842c890a14834f5e834b32de1148cf4b414a11809d53dd3f002b15d6a -aa6f267305b55fede2f3547bc751ba844ce189d0b4852022712b0aee474de54a257d4abcd95efe7854e33a912c774eba -afddd668f30cce70904577f49071432c49386ec27389f30a8223b5273b37e6de9db243aceb461a7dc8f1f231517463a9 -b902a09da9157b3efa1d98f644371904397019d0c84915880628a646a3ad464a9d130fdc651315098179e11da643ad2e -b05f31957364b016c6f299ae4c62eede54cab8ea3871d49534828c8bdc6adbc6a04a708df268f50107d81d1384d983ae -b4c3f7284802e614ddf1f51640f29e7139aae891467d5f62778310372071793e56fbd770837b97d501191edd0da06572 -b4eddb7c3775fb14fac7f63bb73b3cde0efa2f9a3b70e6a65d200765f6c4b466d3d76fcd4d329baee88e2aba183b8e69 -a83e7dbae5a279f0cfd1c94e9849c58a3d4cecc6d6d44bb9b17508576ca347fca52c2c81371d946b11a09d4ed76ec846 -8018ea17e2381c0233867670f9e04c8a47ace1207fdcf72dce61b6c280ba42d0a65f4b4e0b1070cc19c7bb00734974d9 -af90b541dfed22e181ff3ef4cf11f5e385fd215c1e99d988e4d247bc9dcee9f04f2182b961797c0bcc5f2aaa05c901a9 -a37046e44cf35944e8b66df80c985b8a1aa7004a2fd0b81ac251638977d2ff1465f23f93ac0ce56296f88fdc591bbdd7 -a735bd94d3be9d41fcd764ec0d8d7e732c9fc5038463f7728fd9d59321277e2c73a45990223bd571dab831545d46e7aa -94b32dcb86f5d7e83d70a5b48fe42c50f419be2f848f2d3d32ee78bf4181ab18077a7666eedb08607eece4de90f51a46 -a7f0804cafbf513293485afc1b53117f0cbfaea10919e96d9e4eb06f0c96535e87065d93f3def1bbc42044dbb00eb523 -aaaad1166d7f19f08583dd713275a71a856ab89312f84ca8078957664924bb31994b5c9a1210d0c41b085be4058ed52e -a1757aac9f64f953e68e680985a8d97c5aac8688b7d90f4db860166dd3d6119e8fca7d700a9530a2b9ba3932c5e74e33 -98cada5db4a1430c272bfc1065fb685872e664ed200d84060ee9f797d0a00864f23943e0fb84ba122a961996a73dfb14 -a5e609f716dc7729d1247f40f9368a2e4a15067e1dd6a231fece85eeefb7e7d4a5ac8918fb376debd79d95088750b2ca -b5365eb8caab8b1118619a626ff18ce6b2e717763f04f6fa8158cdca530c5779204efa440d088083f1a3685454aa0555 -a6e01b8da5f008b3d09e51a5375d3c87c1da82dff337a212223e4d0cdb2d02576d59f4eef0652d6b5f2fc806d8c8149c -ae310f613d81477d413d19084f117248ad756572c22a85b9e4c86b432e6c602c4a6db5edf2976e11f7353743d679e82a -a1f219c0b8e8bb8a9df2c6c030acbb9bbfa17ba3db0366f547da925a6abb74e1d7eb852bd5a34bae6ac61d033c37e9dc -a2087fa121c0cdd5ea495e911b4bc0e29f1d5c725aadfb497d84434d2291c350cdaa3dc8c85285f65a7d91b163789b7a -929c63c266da73d726435fa89d47041cfe39d4efa0edce7fc6eca43638740fbc82532fd44d24c7e7dd3a208536025027 -91c1051dcc5f52ad89720a368dddd2621f470e184e746f5985908ba34e1d3e8078a32e47ab7132be780bea5277afecb0 -ae089b90ba99894d5a21016b1ea0b72a6e303d87e59fb0223f12e4bb92262e4d7e64bfdbdb71055d23344bc76e7794b2 -8b69aa29a6970f9e66243494223bad07ac8f7a12845f60c19b1963e55a337171a67bdc27622153016fce9828473a3056 -95ca6b08680f951f6f05fd0d180d5805d25caf7e5bda21c218c1344e661d0c723a4dfc2493642be153793c1b3b2caaa4 -a4789dc0f2a07c794dab7708510d3c893d82ddbd1d7e7e4bbbeca7684d9e6f4520fb019b923a06c7efab0735f94aa471 -93c4f57a3cf75085f5656b08040f4cd49c40f1aab6384a1def4c5c48a9fe4c03514f8e61aabe2cfa399ff1ccac06f869 -b6c37f92c76a96b852cd41445aa46a9c371836dd40176cc92d06666f767695d2284a2780fdfd5efc34cf6b18bcfb5430 -9113e4575e4b363479daa7203be662c13d7de2debcda1c142137228aeead2c1c9bc2d06d93a226302fa63cc75b7353ec -b70addeb5b842ac78c70272137f6a1cef6b1d3a551d3dd906d9a0e023c8f49f9b6a13029010f3309d0b4c8623a329faf -b976a5132b7eb42d5b759c2d06f87927ef66ecd6c94b1a08e4c9e02a4ce7feca3ac91f9479daa1f18da3d4a168c2ba77 -8fdab795af64b16a7ddf3fad11ab7a85d10f4057cf7716784184960013baa54e7ba2050b0e036dc978ff8c9a25dc5832 -b2c982ad13be67d5cdc1b8fac555d4d1ec5d25f84e58b0553a9836f8f9e1c37582d69ad52c086a880a08b4efcccd552e -810661d9075ae6942735215f2ab46d60763412e1f6334e4e00564b6e5f479fc48cf37225512abbccf249c0ca225fc935 -a0c4bf00a20f19feff4004004f08231b4c6c86ac4ed57921eea28d7dea32034f3f4ab5b7ded7184f6c7ffbf5847232ad -b2bb5a9eea80bf067f3686a488529d9c2abd63fc9e1d4d921b1247ef86d40cd99e0a8b74f750e85c962af84e84e163a6 -887ee493c96d50f619ba190ce23acddc5f31913e7a8f1895e6339d03794ecefd29da5f177d1d25bc8df8337ae963fc7b -b7966fb07029d040f2228efa2cfcd04341e4666c4cf0b653e6e5708631aa2dd0e8c2ac1a62b50c5a1219a2737b82f4f7 -92234cfd6b07f210b82db868f585953aafbcbc9b07b02ded73ff57295104c6f44a16e2775ca7d7d8ee79babb20160626 -8d3cd7f09c6fd1072bc326ff329e19d856e552ac2a9f20274bc9752527cd3274142aa2e32b65f285fb84bc3adaaea3cc -8caed1cb90d8cd61e7f66edc132672172f4fa315e594273bb0a7f58a75c30647ec7d52eda0394c86e6477fbc352f4fe8 -ae192194b09e9e17f35d8537f947b56f905766c31224e41c632c11cd73764d22496827859c72f4c1ab5fd73e26175a5d -8b7be56aac76d053969e46882d80a254e89f55c5ab434883cbafc634a2c882375898074a57bc24be3c7b2c56401a7842 -98bc4a7a9b05ba19f6b85f3ee82b08bed0640fd7d24d4542eb7a7f7fde443e880bdb6f5499bd8cb64e1ddd7c5f529b19 -a5a41eaa5e9c1d52b00d64ab72bc9def6b9d41972d80703e9bfe080199d4e476e8833a51079c6b0155b78c3ab195a2a7 -a0823f6f66465fd9be3769c164183f8470c74e56af617f8afd99b742909d1a51f2e0f96a84397597afbd8eeaabb51996 -801da41d47207bdd280cc4c4c9753a0f0e9d655e09e0be5f89aeed4ce875a904f3da952464399bf8efc2398940d5fba2 -a719314085fd8c9beac4706c24875833d59a9a59b55bca5da339037c0a5fc03df46dbecb2b4efcfed67830942e3c4ea1 -a75dde0a56070bb7e9237b144ea79f578d413a1cbbd1821cee04f14f533638b24f46d88a7001e92831843b37ed7a709f -a6b4ef8847a4b980146e1849e1d8ab38695635e0394ca074589f900ce41fa1bb255938dc5f37027523bac6a291779bef -b26d84dfd0b7bd60bcfdbea667350462a93dca8ff5a53d6fc226214dcb765fada0f39e446a1a87f18e4e4f4a7133155f -ae7bd66cc0b72f14ac631ff329a5ca4958a80ba7597d6da049b4eb16ac3decde919ca5f6f9083e6e541b303fb336dc2f -a69306e6bfbbc10de0621cffb13c586e2fcfd1a80935e07c746c95651289aec99066126a6c33cb8eb93e87d843fc631f -a47e4815585865218d73c68ba47139568ea7ae23bfa863cb914a68454242dd79beaec760616b48eea74ceab6df2298dd -b2da3cfb07d0721cd226c9513e5f3ace98ed2bc0b198f6626b8d8582268e441fa839f5834f650e2db797655ca2afa013 -b615d0819554f1a301a704d3fc4742bd259d04ad75d50bccee3a949b6226655f7d623301703506253cca464208a56232 -85e06ed5797207f0e7ae85909e31776eb9dae8af2ec39cc7f6a42843d94ea1de8be2a3cdadfcbe779da59394d4ffeb45 -8c3529475b5fdbc636ee21d763f5ec11b8cb040a592116fb609f8e89ca9f032b4fa158dd6e9ceab9aceb28e067419544 -accddb9c341f32be82b6fa2ef258802c9ae77cd8085c16ec6a5a83db4ab88255231b73a0e100c75b7369a330bfc82e78 -93b8e4c6e7480948fa17444b59545a5b28538b8484a75ad6bc6044a1d2dbd76e7c44970757ca53188d951dc7347d6a37 -90111721d68b29209f4dc4cfb2f75ab31d15c55701922e50a5d786fb01707ab53fcec08567cd366362c898df2d6e0e93 -b60a349767df04bd15881c60be2e5cc5864d00075150d0be3ef8f6b778715bebca8be3be2aa9dbdc49f1a485aeb76cda -b8d5a967fdd3a9bcf89a774077db39ef72ca9316242f3e5f2a350202102d494b2952e4c22badecd56b72ba1eea25e64b -8499ebd860f31f44167183b29574447b37a7ee11efcc9e086d56e107b826b64646b1454f40f748ccac93883918c89a91 -99c35e529782db30f7ccab7f31c225858cf2393571690b229ece838ec421a628f678854a1ddbd83fa57103ccebd92c7f -99817660d8b00cbe03ec363bcdc5a77885586c9e8da9e01a862aca0fc69bf900c09b4e929171bc6681681eae10450541 -8055e130964c3c2ebd980d3dc327a40a416bcdbf29f480480a89a087677a1fb51c823b57392c1db72f4093597100b8d3 -877eaddef845215f8e6f9ed24060c87e3ab6b1b8fbb8037d1a57e6a1e8ed34d00e64abb98d4bf75edb5c9788cbdccbef -b5432bbff60aeae47f2438b68b123196dfb4a65cc875b8e080501a4a44f834b739e121bec58d39ac36f908881e4aa8ab -b3c3f859b7d03ff269228c0f9a023b12e1231c73aba71ad1e6d86700b92adc28dfa3757c052bbc0ba2a1d11b7fda4643 -ab8a29f7519a465f394ef4a5b3d4924d5419ca1489e4c89455b66a63ac430c8c9d121d9d2e2ed8aa1964e02cd4ebac8c -866ae1f5c2a6e159f2e9106221402d84c059f40d166fab355d970773189241cd5ee996540d7c6fc4faf6f7bcff967dce -973a63939e8f1142a82b95e699853c1e78d6e05536782b9bb178c799b884f1bc60177163a79a9d200b5ff4628beeb9e7 -a5fc84798d3e2d7632e91673e89e968f5a67b7c8bb557ea467650d6e05e7fe370e18d9f2bdd44c244978295cf312dc27 -b328fe036bcd0645b0e6a15e79d1dd8a4e2eda128401a4e0a213d9f92d07c88201416fc76193bb5b1fe4cb4203bab194 -99239606b3725695a570ae9b6fb0fb0a34ad2f468460031cfa87aa09a0d555ff606ff204be42c1596c4b3b9e124b8bd6 -af3432337ca9d6cce3574e23e5b7e4aa8eda11d306dc612918e970cc7e5c756836605a3391f090a630bac0e2c6c42e61 -8a545b3cb962ce5f494f2de3301de99286c4d551eaa93a9a1d6fef86647321834c95bf754c62ec6c77116a21494f380d -8f9b8ea4c25469c93556f1d91be583a5f0531ac828449b793ba03c0a841c9c73f251f49dd05cbb415f5d26e6f6802c99 -a87199e33628eeffd3aff114e81f53dd54fba61ba9a9a4d7efdbff64503f25bc418969ab76ef1cf9016dd344d556bb29 -a2fda05a566480602274d7ffcaefdd9e94171286e307581142974f57e1db1fa21c30be9e3c1ac4c9f2b167f92e7c7768 -a6235d6a23304b5c797efb2b476ed02cb0f93b6021a719ae5389eb1e1d032944ae4d69aec2f29fcd6cbc71a6d789a3ba -a7f4a73215f7e99e2182c6157dd0f22e71b288e696a8cff2450689a3998f540cfb82f16b143e90add01b386cb60d8a33 -922d8f9cd55423f5f6a60d26de2f8a396ac4070a6e2dc956e50c2a911906aa364d4718aea29c5b61c12603534e331e7e -96d7fdf5465f028fc28f21fbfe14c2db2061197baf26849e6a0989a4ea7d5e09ab49a15ba43a5377b9354d01e30ce860 -8f94c4255a0fc1bd0fa60e8178c17f2a8e927cac7941c5547d2f8f539e7c6ed0653cab07e9fb1f2c56cdd03bb876512a -95984c10a2917bfa6647ebce69bf5252d9e72d9d15921f79b2c6d7c15ee61342b4fb8a6d34838e07132b904f024ded04 -93e65e765a574277d3a4d1d08ca2f2ff46e9921a7806ca8ca3d8055f22d6507744a649db7c78117d9168a1cbdb3bbc61 -8d453b7364662dc6f36faf099aa7cbbe61151d79da7e432deba7c3ed8775cfe51eaf1ba7789779713829dde6828e189a -acffa3ee6c75160286090162df0a32a123afb1f9b21e17fd8b808c2c4d51a4270cab18fba06c91ef9d22e98a8dc26cdd -a5597cc458186efa1b3545a3926f6ecaaa6664784190e50eed1feac8de56631bee645c3bac1589fa9d0e85feb2be79d4 -87ba9a898df9dfa7dabc4ab7b28450e4daf6013340e329408d1a305de959415ab7315251bad40511f917dfc43974e5f0 -a598778cf01d6eef2c6aabc2678e1b5194ee8a284ebd18a2a51a3c28a64110d5117bcbf68869147934e600572a9e4c8a -84c69a4ad95861d48709f93ade5ac3800f811b177feb852ebcd056e35f5af5201f1d8a34ab318da8fe214812d0a7d964 -9638a237e4aed623d80980d91eda45e24ebf48c57a25e389c57bd5f62fa6ffa7ca3fb7ae9887faf46d3e1288af2c153b -800f975721a942a4b259d913f25404d5b7b4c5bf14d1d7e30eee106a49cb833b92058dab851a32ee41faf4ef9cb0dea4 -b9127a34a59fed9b5b56b6d912a29b0c7d3cb9581afc9bd174fc308b86fdb076f7d436f2abc8f61cef04c4e80cd47f59 -8004eda83f3263a1ccfc8617bc4f76305325c405160fb4f8efeff0662d605e98ba2510155c74840b6fe4323704e903c4 -aa857b771660d6799ff03ccad1ab8479e7f585a1624260418fc66dc3e2b8730cfa491d9e249505141103f9c52f935463 -98b21083942400f34cde9adbe1977dee45ba52743dc54d99404ad9da5d48691ddea4946f08470a2faad347e9535690c7 -a4b766b2faec600a6305d9b2f7317b46f425442da0dc407321fc5a63d4571c26336d2bccedf61097f0172ec90fb01f5f -b9736619578276f43583de1e4ed8632322ea8a351f3e1506c5977b5031d1c8ad0646fb464010e97c4ddb30499ddc3fb0 -973444ffaff75f84c17f9a4f294a13affd10e2bceed6b4b327e4a32c07595ff891b887a9f1af34d19766d8e6cb42bfd1 -b09ce4964278eff81a976fbc552488cb84fc4a102f004c87179cb912f49904d1e785ecaf5d184522a58e9035875440ef -b80c2aa3d0e52b4d8b02c0b706e54b70c3dbca80e5e5c6a354976721166ea0ca9f59c490b3e74272ef669179f53cb50d -8e52fa5096ff960c0d7da1aa4bce80e89527cdc3883eba0c21cb9a531088b9d027aa22e210d58cf7cbc82f1ec71eb44f -969f85db95f455b03114e4d3dc1f62a58996d19036513e56bee795d57bf4ed18da555722cd77a4f6e6c1a8e5efe2f5d7 -ab84b29b04a117e53caea394a9b452338364c45a0c4444e72c44132a71820b96a6754828e7c8b52282ad8dca612d7b6a -83e97e9ab3d9e453a139c9e856392f4cef3ec1c43bce0a879b49b27a0ce16f9c69063fd8e0debbe8fabafc0621bc200c -8c138ebdf3914a50be41be8aa8e2530088fb38af087fa5e873b58b4df8e8fd560e8090c7a337a5e36ef65566409ad8f3 -a56da9db2f053516a2141c1a8ed368ae278ab33a572122450249056857376d1dffc76d1b34daf89c86b6fe1ead812a0c -a3233ea249f07531f5bc6e94e08cea085fd2b2765636d75ff5851f224f41a63085510db26f3419b031eb6b5143735914 -b034bb6767ce818371c719b84066d3583087979ba405d8fbb2090b824633241e1c001b0cb0a7856b1af7a70e9a7b397e -8722803fe88877d14a4716e59b070dd2c5956bb66b7038f6b331b650e0c31230c8639c0d87ddc3c21efc005d74a4b5cc -8afe664cb202aacf3bd4810ebf820c2179c11c997f8c396692a93656aa249a0df01207c680157e851a30330a73e386b9 -a999e86319395351d2b73ff3820f49c6516285e459224f82174df57deb3c4d11822fd92cbbed4fc5a0a977d01d241b19 -9619408e1b58b6610d746b058d7b336d178e850065ba73906e08e748651e852f5e3aab17dcadcb47cc21ff61d1f02fcf -947cf9c2ed3417cd53ea498d3f8ae891efe1f1b5cd777e64cec05aba3d97526b8322b4558749f2d8a8f17836fb6e07aa -aec2fdae2009fda6852decb6f2ff24e4f8d8ca67c59f92f4b0cf7184be72602f23753ed781cf04495c3c72c5d1056ffe -8dba3d8c09df49fbfc9506f7a71579348c51c6024430121d1c181cad7c9f7e5e9313c1d151d46d4aa85fb0f68dd45573 -b6334cb2580ae33720ebf91bb616294532a1d1640568745dcda756a3a096786e004c6375728a9c2c0fb320441e7d297a -9429224c1205d5ecd115c052b701c84c390f4e3915275bb8ce6504e08c2e9b4dd67b764dd2ea99f317b4c714f345b6ff -abe421db293f0e425cfd1b806686bdfd8fdbac67a33f4490a2dc601e0ddbf69899aa9a119360dad75de78c8c688ca08b -95c78bffed9ae3fff0f12754e2bd66eb6a9b6d66a9b7faaeb7a1c112015347374c9fe6ce14bf588f8b06a78e9a98f44c -ac08f8b96b52c77d6b48999a32b337c5ad377adf197cda18dbdf6e2a50260b4ee23ca6b983f95e33f639363e11229ee4 -911a0e85815b3b9f3ba417da064f760e84af94712184faeb9957ddd2991dee71c3f17e82a1a8fbeec192b0d73f0ebce7 -aa640bd5cb9f050568a0ad37168f53b2f2b13a91e12b6980ca47ae40289cf14b5b89ddd0b4ca452ce9b1629da0ce4b5d -907486f31b4ecea0125c1827007ea0ecb1c55cadb638e65adc9810ca331e82bb2fd87e3064045f8d2c5d93dc6c2f5368 -8cbfaf4ce0bbbf89208c980ff8b7bc8f3cfef90f0fe910f463cb1c0f8e17cce18db120142d267045a00ba6b5368f0dd3 -9286f08f4e315df470d4759dec6c9f8eacef345fc0c0b533ad487bb6cfefa8c6c3821a22265c9e77d34170e0bc0d078b -94a3c088bc1a7301579a092b8ece2cefc9633671bc941904488115cd5cb01bd0e1d2deef7bdccb44553fd123201a7a53 -8f3d0114fbf85e4828f34abb6d6fddfa12789d7029d9f1bb5e28bc161c37509afdab16c32c90ec346bc6a64a0b75726f -a8ed2d774414e590ec49cb9a3a726fafd674e9595dd8a1678484f2897d6ea0eea1a2ee8525afac097b1f35e5f8b16077 -9878789ff33b11527355a317343f34f70c7c1aa9dc1eca16ca4a21e2e15960be8a050ec616ffb97c76d756ce4bce2e90 -854e47719dae1fe5673cacf583935122139cf71a1e7936cf23e4384fbf546d48e9a7f6b65c3b7bf60028e5aa1234ba85 -af74bdda2c6772fe9a02d1b95e437787effad834c91c8174720cc6e2ea1f1f6c32a9d73094fc494c0d03eef60b1a0f05 -80a3e22139029b8be32cb167d3bc9e62d16ca446a588b644e53b5846d9d8b7ab1ad921057d99179e41515df22470fb26 -86c393afd9bd3c7f42008bba5fe433ec66c790ebd7aa15d4aeaf9bb39a42af3cfaf8c677f3580932bbd7ada47f406c8c -90433c95c9bb86a2c2ddcf10adccb521532ebd93db9e072671a4220f00df014e20cd9ce70c4397567a439b24893808dc -95b2c170f08c51d187270ddc4f619300b5f079bbc89dbca0656eae23eecc6339bf27fa5bf5fd0f5565d4021105e967d2 -8e5eced897e2535199951d4cff8383be81703bca3818837333dd41a130aa8760156af60426ceadb436f5dea32af2814c -a254a460ebefbe91d6e32394e1c8f9075f3e7a2bb078430ac6922ab14d795b7f2df1397cb8062e667d809b506b0e28d4 -ac2062e8ca7b1c6afb68af0ebab31aebd56fc0a0f949ef4ea3e36baf148681619b7a908facf962441905782d26ecbdb5 -8b96af45b283b3d7ffeec0a7585fc6b077ea5fd9e208e18e9f8997221b303ab0ce3b5bafa516666591f412109ce71aa5 -afd73baada5a27e4fa3659f70083bf728d4dc5c882540638f85ea53bf2b1a45ddf50abc2458c79f91fb36d13998c7604 -a5d2fff226e80cb2e9f456099812293333d6be31dd1899546e3ad0cd72b2a8bcb45ec5986e20faa77c2564b93983210c -a8c9b8de303328fbdaccf60f4de439cf28f5360cf4104581dc2d126bc2e706f49b7281723487ff0eaf92b4cc684bc167 -a5d0d5849102bf1451f40e8261cb71fc57a49e032773cb6cd7b137f71ee32438d9e958077ffafce080a116ccc788a2d4 -80716596f502d1c727d5d2f1469ce35f15e2dbd048d2713aa4975ee757d09c38d20665326bd63303cfe7e820b6de393d -97baf29b20f3719323cc1d5de23eaa4899dc4f4e58f6c356ec4c3ad3896a89317c612d74e0d3ab623fe73370c5972e2f -b58bdc9aa5061bf6e5add99a7443d7a8c7ba8f6875b8667d1acbe96fc3ecafbdcc2b4010cb6970a3b849fff84660e588 -b6be68728776d30c8541d743b05a9affc191ad64918fdbd991d2ddd4b32b975c4d3377f9242defef3805c0bfb80fbac7 -b0cddace33333b8a358acad84b9c83382f0569d3854b4b34450fd6f757d63c5bdab090e330b0f86e578f22c934d09c36 -854bd205d6051b87f9914c8c2494075d7620e3d61421cc80f06b13cea64fd1e16c62c01f107a5987d10b8a95a8416ad9 -80351254a353132300ba73a3d23a966f4d10ce9bf6eae82aedb6cdc30d71f9d08a9dd73cb6441e02a7b2ad93ad43159c -937aae24fb1b636929453fc308f23326b74c810f5755d9a0290652c9c2932ad52cc272b1c83bd3d758ef7da257897eae -b84d51ef758058d5694ffeac6d8ce70cef8d680a7902f867269c33717f55dd2e57b25347841d3c0872ae5f0d64f64281 -a4b31bb7c878d5585193535b51f04135108134eff860f4eac941053155f053d8f85ff47f16268a986b2853480a6e75e6 -93543f0828835186a4af1c27bdf97b5dd72b6dfa91b4bf5e759ff5327eaf93b0cb55d9797149e465a6b842c02635ffe5 -afdac9e07652bf1668183664f1dd6818ef5109ee9b91827b3d7d5970f6a03e716adcc191e3e78b0c474442a18ad3fc65 -9314077b965aa2977636ae914d4a2d3ce192641a976ffa1624c116828668edbfbe5a09e3a81cb3eed0694566c62a9757 -b395ddcf5082de6e3536825a1c352802c557b3a5118b25c29f4c4e3565ecaaf4bdd543a3794d05156f91fc4ceadc0a11 -b71f774aad394c36609b8730e5be244aaebfff22e0e849acc7ee9d33bedc3ec2e787e0b8b2ffe535560fcd9e15a0897e -92e9409fa430f943a49bce3371b35ac2efb5bc09c88f70ff7120f5e7da3258a4387dfc45c8b127f2ef2668679aeb314e -8ef55bef7b71952f05e20864b10f62be45c46e2dca0ef880a092d11069b8a4aa05f2e0251726aca1d5933d7dea98f3f8 -aad3fba9e09fae885cdeef45dfafa901419f5156fb673818f92a4acc59d0e2e9870b025e711de590a63fd481164f3aa8 -b444d52af545dd3a2d3dd94e6613816b154afea0c42b96468aceb0c721395de89e53e81a25db857ca2e692dcb24ba971 -88b279fe173007e64fe58f2c4adba68a1f538dbd3d32d175aa0d026bbb05b72a0c9f5d02b8201a94adb75fe01f6aa8b2 -88494cea4260741c198640a079e584cabfea9fcfb8bcf2520c9becd2419cde469b79021e5578a00d0f7dbc25844d2683 -94f3cce58837c76584b26426b9abdb45f05fee34dd9e5914b6eae08e78b7262ed51c4317031dab1ad716f28b287f9fc2 -b8c7ed564f54df01c0fbd5a0c741beed8183ce0d7842dc3a862a1b335de518810077314aa9d6054bb939663362f496da -81c153320d85210394d48340619d5eb41304daea65e927266f0262c8a7598321aba82ad6c3f78e5104db2afd2823baca -ab6695a8d48a179e9cd32f205608359cf8f6a9aead016252a35b74287836aa395e76572f21a3839bec6a244aa49573e5 -920ed571539b3002a9cd358095b8360400e7304e9a0717cc8c85ab4a0514a8ad3b9bf5c30cb997647066f93a7e683da9 -a7ec7c194d1e5103bc976e072bf1732d9cb995984d9a8c70a8ee55ce23007f21b8549ad693f118aa974f693ed6da0291 -87a042d6e40c2951a68afc3ccf9646baf031286377f37f6ac47e37a0ec04d5ac69043757d7dff7959e7cd57742017a8d -b9f054dd8117dd41b6e5b9d3af32ee4a9eebef8e4a5c6daa9b99c30a9024eabeae850ab90dbdb188ca32fd31fd071445 -a8386da875799a84dc519af010eaf47cdbc4a511fe7e0808da844a95a3569ce94054efd32a4d3a371f6aba72c5993902 -8b3343a7cf4ffb261d5f2dbd217fb43590e00feac82510bdf73b34595b10ee51acae878a09efebc5a597465777ef4c05 -8312a5f1ea4f9e93578e0f50169286e97884a5ed17f1780275ab2b36f0a8aa1ab2e45c1de4c8bce87e99e3896af1fa45 -b461198cb7572ac04c484a9454954e157bdd4db457816698b7290f93a10268d75a7e1211e757c6190df6144bbb605d91 -9139764a099580d6f1d462c8bf7d339c537167be92c780e76acb6e638f94d3c54b40ed0892843f6532366861e85a515a -8bb70acb3c9e041b4fc20e92ba0f3f28f0d5c677bcb017af26f9171e07d28c3c0729bef72457231e3512f909455a13a2 -93301a18e5064c55fcfe8e860fab72da1b89a824ca77c8932023b7c79e4a51df93a89665d308a8d3aa145e46ebe6a0ad -ae3bca496fbd70ce44f916e2db875b2ce2e1ded84edd2cebc0503bdfdec40ec30e1d9afb4eb58c8fa23f7b44e71d88f8 -93cb3a918c95c5d973c0cb7621b66081ed81fba109b09a5e71e81ca01ec6a8bb5657410fdec453585309ef5bf10d6263 -95a50b9b85bb0fc8ff6d5f800d683f0f645e7c2404f7f63228a15b95ce85a1f8100e2e56c0acee19c36ed3346f190e87 -816cc4d9337461caca888809b746ab3713054f5b0eac823b795a1a9de9417c58e32a9f020fef807908fa530cbf35dee8 -a9c2890c2dd0d5d7aedc4cca7f92764086c50f92f0efd2642c59920d807086031bfe2d3ba574318db236c61a8f5f69c2 -ad0d5c8c80bddfe14bdaf507da96dc01dc9941aecc8ad3b64513d0a00d67c3f4b4659defb6839b8b18d8775e5344c107 -9047c9fad6ef452e0219e58e52c686b620e2eb769571021e3524bd7eac504f03b84834b16b849d42b3d75c601fd36bb7 -a04dd988fed91fb09cb747a3ac84efe639d7d355524cd7dee5477ecbcdec44d8ac1cec2c181755dcfdb77e9594fb3c5b -b0ea0c725debd1cec496ced9ce48f456f19af36e8b027094bf38fa37de9b9b2d10282363ea211a93a34a0a5387cace5d -b5fc46e2bb3e4653ea5e6884dcb3c14e401a6005685ee5a3983644b5b92300b7066289159923118df4332aac52045b8c -841fc5b26b23226e725e29802da86b35e4f5e3babc8b394f74e30fd5dec6d3840b19a9a096625ce79a4f1edae6369700 -8fd2bbbeea452451def3659bbe0ceb396120ebe8f81eee1ea848691614422c81d7c3e6a7a38032b4120b25c5ffa8f0c2 -9131ce3d25c3d418f50c0ab99e229d4190027ee162b8ba7c6670420ea821831dec1294ac00d66c50fac61c275a9e2c71 -99ec6eafe0eb869d128158cee97b984fb589e1af07699247946e4a85db772289dff3084d224a6f208005c342f32bbd73 -ac100fbbe7c2bf00cc56fcd5aa1f27181f82c150c53bbb1e15d2c18a51ed13dcfa7bccab85821b8ddddf493603e38809 -affd73a458d70c0d9d221e0c2da4348fed731f6b34c0b3e2d5711ba432e85a1ec92e40b83b246a9031b61f5bc824be47 -8ed30ed817816a817e9e07374ef1f94405a7e22dd0096aeaae54504382fc50e7d07b4f1186c1792fc25ea442cd7edc6b -a52370cfe99a35fa1405aeca9f922ad8d31905e41f390e514ea8d22ee66469637d6c2d4d3a7ee350d59af019ae5a10a4 -8d0b439741c57b82c8e4b994cf3956b5aeaee048b17e0a1edb98253a8d7256f436d8b2f36b7e12504132dbf91f3376b1 -8caac7e1a4486c35109cff63557a0f77d0e4ca94de0817e100678098a72b3787a1c5afc7244991cebcd1f468e18d91d4 -a729a8e64b7405db5ebfb478bb83b51741569331b88de80680e9e283cc8299ba0de07fcf252127750f507e273dc4c576 -a30545a050dad030db5583c768a6e593a7d832145b669ad6c01235813da749d38094a46ac3b965700230b8deacd91f82 -9207e059a9d696c46fa95bd0925983cd8e42aefd6b3fb9d5f05420a413cbc9e7c91213648554228f76f2dd757bde0492 -a83fa862ae3a8d98c1e854a8b17181c1025f4f445fbc3af265dc99e44bbd74cfa5cc25497fb63ee9a7e1f4a624c3202c -84cdfc490343b3f26b5ad9e1d4dcf2a2d373e05eb9e9c36b6b7b5de1ce29fda51383761a47dbd96deca593a441ccb28e -881a1aa0c60bb0284a58b0a44d3f9ca914d6d8fa1437315b9ad2a4351c4da3ee3e01068aa128284a8926787ea2a618d1 -aace78e497b32fbff4df81b1b2de69dbc650645e790953d543282cb8d004a59caf17d9d385673a146a9be70bf08a2279 -aa2da4760f1261615bffd1c3771c506965c17e6c8270c0f7c636d90428c0054e092247c3373eca2fb858211fdb17f143 -acb79f291b19e0aa8edb4c4476a172834009c57e0dcc544c7ce95084488c3ad0c63ffd51c2b48855e429b6e1a9555433 -814b58773a18d50a716c40317f8b80362b6c746a531776a9251c831d34fb63e9473197c899c0277838668babc4aa0ecb -b1f69522b0f7657d78bd1ee3020bcce3447116bf62c146d20684537d36cafb5a7a1531b86932b51a70e6d3ce0808a17e -8549712c251ef382f7abe5798534f8c8394aa8bcecdca9e7aa1a688dc19dc689dcd017a78b118f3bd585673514832fe4 -912a04463e3240e0293cfc5234842a88513ff930c47bd6b60f22d6bc2d8404e10270d46bf6900fee338d8ac873ebb771 -a327cb7c3fada842e5dd05c2eeedd6fcd8cf2bfb2f90c71c6a8819fb5783c97dd01bd2169018312d33078b2bc57e19f7 -b4794f71d3eceed331024a4cee246cc427a31859c257e0287f5a3507bfbd4d3486cb7781c5c9c5537af3488d389fe03e -82ffcb418d354ed01688e2e8373a8db07197a2de702272a9f589aed08468eab0c8f14e6d0b3146e2eb8908e40e8389c5 -910b73421298f1315257f19d0dfd47e79d7d2a98310fb293f704e387a4dc84909657f0f236b70b309910271b2f2b5d46 -a15466397302ea22f240eb7316e14d88376677b060c0b0ae9a1c936eb8c62af8530732fc2359cfd64a339a1c564f749b -a8091975a0d94cdc82fbaff8091d5230a70d6ea461532050abbdfee324c0743d14445cfe6efe6959c89a7c844feaa435 -a677d1af454c7b7731840326589a22c9e81efbbf2baf3fdeaf8ea3f263a522584fbca4405032c4cdf4a2a6109344dfc8 -894e6ffa897b6e0b37237e6587a42bbc7f2dd34fb09c2e8ac79e2b25b18180e158c6dc2dd26761dba0cfed1fb4eb4080 -928d31b87f4fe8fe599d2c9889b0ff837910427ba9132d2fba311685635458041321ae178a6331ed0c398efe9d7912f0 -afc1c4a31f0db24b53ee71946c3c1e1a0884bd46f66b063a238e6b65f4e8a675faa844e4270892035ef0dae1b1442aa0 -a294fcb23d87cf5b1e4237d478cac82ba570649d425b43b1e4feead6da1f031e3af0e4df115ca46689b9315268c92336 -85d12fd4a8fcfd0d61cbf09b22a9325f0b3f41fb5eb4285b327384c9056b05422d535f74d7dc804fb4bab8fb53d556bd -91b107d9b0ea65c48128e09072acd7c5949a02dd2a68a42ff1d63cf528666966f221005c2e5ca0a4f85df28459cdede6 -89aa5dc255c910f439732fcd4e21341707e8dd6689c67c60551a8b6685bd3547e3f47db4df9dfadd212405f644c4440b -8c307d6b827fa1adcf0843537f12121d68087d686e9cc283a3907b9f9f36b7b4d05625c33dab2b8e206c7f5aabd0c1e5 -843f48dadf8523d2b4b0db4e01f3c0ea721a54d821098b578fcaa6433e8557cadfea50d16e85133fa78f044a3e8c1e5b -9942eb8bd88a8afa9c0e3154b3c16554428309624169f66606bfb2814e8bac1c93825780cf68607f3e7cffe7bf9be737 -b7edb0c7637a5beb2332f2ae242ba4732837f9da0a83f00f9e9a77cf35516e6236eb013133ddc2f958ea09218fe260d3 -9655fe4910bc1e0208afbcf0ff977a2e23faded393671218fba0d9927a70d76514a0c45d473a97ecb00cf9031b9d527c -8434bc8b4c5839d9e4404ff17865ded8dd76af56ef2a24ea194c579d41b40ed3450c4e7d52219807db93e8e6f001f8da -b6c6d844860353dab49818bed2c80536dbc932425fdaa29915405324a6368277cf94d5f4ab45ea074072fc593318edff -b2887e04047660aa5c83aad3fa29b79c5555dd4d0628832c84ba7bf1f8619df4c9591fcde122c174de16ca7e5a95d5e3 -953ba5221360444b32911c8b24689078df3fbf58b53f3eec90923f53a22c0fc934db04dd9294e9ec724056076229cf42 -926917529157063e4aade647990577394c34075d1cb682da1acf600639d53a350b33df6a569d5ebb753687374b86b227 -b37894a918d6354dd28f850d723c1c5b839f2456e2a220f64ecadac88ae5c9e9cf9ab64b53aac7d77bf3c6dfa09632dc -b9d28148c2c15d50d1d13153071d1f6e83c7bb5cb5614adf3eb9edede6f707a36c0fa0eadb6a6135ead3c605dfb75bd1 -9738d73ea0b9154ed38da9e6bd3a741be789ea882d909af93e58aa097edf0df534849f3b1ba03099a61ceb6a11f34c4d -afabbecbbf73705851382902ec5f1da88b84a06b3abfb4df8d33df6a60993867f853d0d9bd324d49a808503615c7858a -a9e395ddd855b12c87ba8fdb0ea93c5bd045e4f6f57611b27a2ee1b8129efe111e484abc27cb256ed9dcace58975d311 -b501c2f3d8898934e45e456d36a8a5b0258aeea6ff7ac46f951f36da1ec01bd6d0914c4d83305eb517545f1f35e033cc -86f79688315241fe619b727b7f426dbd27bcc8f33aef043438c95c0751ada6f4cd0831b25ae3d53bcf61324d69ea01eb -83237e42fa773a4ccaa811489964f3fab100b9eea48c98bdef05fa119a61bde9efe7d0399369f87c775f4488120b4f2e -b89f437552cab77d0cd5f87aca52dd827fb6648c033351c00ab6d40ac0b1829b4fcdf8a7dad467d4408c691223987fbe -8e21061698cb1a233792976c2d8ab2eeb6e84925d59bb34434fff688be2b5b2973d737d9dda164bd407be852d48ef43f -b17a9e43aa4580f542e00c3212fbf974f1363f433c5502f034dfd5ed8c05ac88b901729d3b822bec391cca24cc9f5348 -aac6d6cda3e207006c042a4d0823770632fc677e312255b4aff5ad1598dc1022cab871234ad3aa40b61dc033a5b0930b -b25e69f17b36a30dada96a39bc75c0d5b79d63e5088da62be9fcbddfd1230d11654890caa8206711d59836d6abbc3e03 -af59fe667dd9e7e4a9863c994fc4212de4714d01149a2072e97197f311be1f39e7ad3d472e446dcc439786bf21359ede -957952988f8c777516527b63e0c717fc637d89b0fd590bcb8c72d0e8a40901598930c5b2506ff7fea371c73a1b12a9be -a46becd9b541fc37d0857811062ca1c42c96181c7d285291aa48dc2f6d115fcff5f3dfdf4490d8c619da9b5ce7878440 -87168fbd32c01a4e0be2b46fe58b74d6e6586e66bbb4a74ad94d5975ac09aa6fa48fd9d87f1919bd0d37b8ebe02c180c -895c4aa29de9601fc01298d54cfb62dd7b137e6f4f6c69b15dc3769778bfba5fc9cbd2fc57fd3fad78d6c5a3087f6576 -b9cf19416228230319265557285f8da5b3ca503de586180f68cf055407d1588ecec2e13fc38817064425134f1c92b4d5 -9302aaef005b22f7b41a0527b36d60801ff6e8aa26fe8be74685b5f3545f902012fcade71edca7aaa0560296dac5fca5 -a0ccda9883027f6b29da1aaa359d8f2890ce1063492c875d34ff6bf2e7efea917e7369d0a2b35716e5afd68278e1a93a -a086ac36beeba9c0e5921f5a8afea87167f59670e72f98e788f72f4546af1e1b581b29fbdd9a83f24f44bd3ec14aee91 -8be471bf799cab98edf179d0718c66bbc2507d3a4dac4b271c2799113ce65645082dc49b3a02a8c490e0ef69d7edbcb1 -8a7f5b50a18baf9e9121e952b65979bda5f1c32e779117e21238fb9e7f49e15008d5c878581ac9660f6f79c73358934a -b3520a194d42b45cbab66388bee79aad895a7c2503b8d65e6483867036497d3e2e905d4d51f76871d0114ec13280d82f -8e6ca8342ec64f6dbe6523dc6d87c48065cd044ea45fa74b05fff548539fd2868eb6dd038d38d19c09d81d5a96364053 -b126a0e8263a948ba8813bf5fb95d786ae7d1aa0069a63f3e847957822b5fe79a3a1afa0ce2318b9ba1025f229a92eb7 -8e4461d6708cac53441a3d23ac4b5ff2b9a835b05008c26d7d9c0562a29403847cf760b7e9d0bcb24a6f498d2a8a9dd2 -b280a761bab256dfe7a8d617863999e3b4255ddbdc11fe7fe5b3bb9633fc8f0cb4f28e594d3b5b0b649c8e7082c4666a -a3e3043bfd7461e38088ee6a165d2ca015de98350f1cb0efc8e39ed4fcdb12a717f0ede7fbf9dadb90496c47652cc0ce -a4c1f5b1b88ae3c397d171e64395afe0cd13c717677775a01dd0461d44a04ee30ec3da58a54c89a3ca77b19b5e51062c -a268638e0655b6d5a037061808619b9ae276bb883999d60c33a9f7f872c46d83d795d1f302b4820030c57604fa3686e7 -ac20176111c5c6db065668987227658c00a1572ce21fe15f25e62d816b56472c5d847dd9c781fb293c6d49cc33b1f98f -acc0e22d9b6b45c968c22fd16b4ece85e82a1b0ab72369bdd467857fee1a12b9635f5b339a9236cbd1acc791811d0e29 -b56066e522bee1f31480ff8450f4d469ace8eb32730c55b7c9e8fa160070bdec618454e665b8cbc5483bc30b6cebbfb9 -8c1772bdfacff85f174d35c36f2d2182ae7897ad5e06097511968bbb136b626c0c7e462b08a21aca70f8e456b0204bf8 -b4de3cf4a064bf589be92513b8727df58f2da4cd891580ef79635ac8c195f15a6199327bb41864e2f614c8589b24f67e -8f3c534125613f2d17bf3e5b667c203cb3eab0dbca0638e222fe552fddf24783965aa111de844e8c3595304bfc41c33b -8e445b2711987fe0bf260521cb21a5b71db41f19396822059912743bf6ca146100c755c8b6e0e74f1bf2e34c03b19db9 -87ff9adf319adb78c9393003b5bdda08421f95551d81b37520b413fe439e42acf82d47fa3b61476b53166bf4f8544f0e -83f3c00c55632e1937dcdc1857de4eccd072efa319b3953d737e1d37382b3cf8343d54a435588eb75aa05bf413b4caa0 -b4d8ee1004bac0307030b8605a2e949ca2f8d237e9c1dcf1553bd1eb9b4156e2deb8c79331e84d2936ec5f1224b8b655 -93b2812b6377622e67bf9a624898227b56ebe3c7a1d917487fc9e4941f735f83679f7ac137065eb4098ad1a4cfbc3892 -81943d9eab6dcea8a120dde5356a0a665b1466709ebb18d1cbfa5f213a31819cb3cf2634e6d293b5b13caa158a9bb30b -a9042aae02efd4535681119e67a60211fc46851319eb389b42ebadcab1229c94199091fb1652beba3434f7b98c90785f -91db52b27fd9b1715df202106b373c4e63ce8ec7db8c818c9016ace5b08ef5f8c27e67f093395937ba4ce2f16edf9aef -83cb9b7b94bd6ead3ff2a7d40394f54612c9cb80c4e0adadffea39e301d1052305eb1fe0f7467268b5aba3b423a87246 -8720fd6712a99d92dd3fdaae922743ab53fad50d183e119a59dae47cdac6fbea6064c732d02cb341eaea10723db048fa -8d40022c1254462a2ac2380a85381c370b1221e5a202d95c75bccba6d1e52972dd5585a1294a1e487bf6ae6651867167 -b7bc06e08d8c72daba143627582f4b4f34cc2234b5cb5cd83536f2ef2e058631a3920468ea4d550aea01cad221d6a8a6 -a6e1a6f70fba42d3b9ce5f04ffdcfca46fc94041840c0066a204030cf75ea9f9856113fea3a9f69ea0037d9a68e3a9d4 -8b064c350083fce9a52da2e2e17bf44c4c9643d2d83667cbd9ad650bbeba55e2c408e746ccf693e56d08826e8a6d57fc -8d304a5405a0c0696917fcddc6795dd654567ca427f007d9b16be5de98febbf8692374e93f40822f63cf6f143c4d9499 -b968db239efec353a44f20a7cf4c0d0fca4c4c2dc21e6cbb5d669e4fe624356a8341e1eec0955b70afb893f55e9a9e32 -98971f745ce4ce5f1f398b1cd25d1697ada0cc7b329cee11d34b2d171e384b07aeb06ac7896c8283664a06d6dd82ec6b -881f5a20a80f728354fad9d0a32a79ffe0ba9bed644ed9d6a2d85444cda9821018159a3fa3d3d6b4fadbf6ea97e6aff6 -b7c76cbb82919ec08cf0bd7430b868a74cb4021e43b5e291caa0495ca579798fab1b64855e2d301f3461dd4d153adeb6 -b44c8c69b3df9b4e933fe6550982a6f76e18046e050229bd2456337e02efb75efa0dfe1b297ed9f5d7fa37fec69c8374 -a5bd7781820ba857aee07e38406538b07ab5180317689a58676f77514747672dd525ea64512a0e4958896f8df85e9d4d -a8443d1dc91b4faa20a2626505b5b4ad49cc5c1fd7a240a0e65d12f52d31df1585ba52c21e604dcec65ec00b81ae21fe -a157ae42fc6302c54bcdd774e8b8bafc4f5d221717f7bf49668c620e47051b930dce262d55668e546272dd07ca7c8d3f -8732c10448b63e907ff95f53cd746f970c946fd84fcbfe4cf9ede63afbbfc66b293bbc7c470d691bbd149bb3c78bb351 -a82192f4fd9a0c33489a0486b79d0f6c797c7eccb45f91f7f1e8e1dd1924ca9944b983951025b99ab5861d31841451fe -839efc6d199ddd43f34f6729b6b63f9ee05f18859bf8fd3f181fa71f4399a48bff7dde89b36e9dc1c572f1b9b6127cca -992ef084abe57adfd5eb65f880b411d5f4ed34c1aeb0d2cfac84fff4f92a9a855c521a965ba81b5eef2268e9a9e73048 -a2518ab712fa652e6e0bd0840307ef3831094e9a18723fb8ec052adacbb87f488d33778c6ec3fd845003af62e75125d1 -b630ac3c9e71b85dd9e9f2984bb5b762e8491d8edb99cad82c541faf5a22dd96f0fddb49d9a837b1955dea2d91284f28 -8d886d1b7f818391b473deba4a9a01acce1fe2abe9152955e17ba39adc55400590c61582c4fef37a286e2151566576ed -884f100dc437639247f85e5d638fcc7583d21bf37a66ce11e05bfc12f5dbe78685b0e51b4594e10549c92bb980512e12 -806d7bac2d24cfff6090ba9513698292d411cdea02976daa3c91c352b09f5a80a092cfa31304dcfcd9356eaf5164c81b -934ed65f8579ee458b9959295f69e4c7333775eb77084db69ad7096f07ad50ad88f65e31818b1942380f5b89e8d12f1b -aaf50ca5df249f0a7caf493334b6dca1700f34bd0c33fe8844fadd4afedbb87a09673426741ac7cbbb3bf4ab73f2d0f3 -b2868642cfa0a4a8a2553691c2bef41dab9dff87a94d100eaa41645614ab4d0e839ec2f465cc998c50cd203f0c65df22 -a326513112e0b46600d52be9aa04d8e47fe84e57b3b7263e2f3cf1a2c0e73269acb9636a99eb84417f3ae374c56e99b0 -97b93efc047896ddf381e8a3003b9e1229c438cc93a6dbef174bb74be30fac47c2d7e7dc250830459bed61d950e9c924 -b45e4f0a9806e44db75dbb80edc369be45f6e305352293bcae086f2193e3f55e6a75068de08d751151fdf9ebc6094fa1 -87f2161c130e57e8b4bb15616e63fa1f20a1b44d3e1683967a285f0d4f0b810f9202e75af2efa9fc472687c007a163f7 -8f6400a45666142752580a2dce55ef974f59235a209d32d2036c229c33a6189d51435b7ea184db36f765b0db574a9c52 -a0ee079462805f91b2200417da4900227acde0d48c98e92c8011a05b01c9db78fc5c0157d15cb084b947a68588f146f4 -ab0612d9bb228b30366b48e8d6ae11026230695f6f0607c7fa7a6e427e520121ff0edea55d1f0880a7478c4a8060872d -ad65dfde48f914de69f255bb58fa095a75afe9624fc8b7b586d23eb6cf34a4905e61186bc978e71ccb2b26b0381778a6 -8c8a4847d138d221c0b6d3194879fd462fb42ed5bd99f34ebe5f5b1e1d7902903ec55e4b52c90217b8b6e65379f005a4 -a41dca4449584353337aef1496b70e751502aeed9d51202de6d9723e155ca13be2d0db059748704653685a98eaa72a07 -ae40e5450fd994d1be245a7cd176a98dd26332b78da080159295f38802a7e7c9c17cc95da78d56558d84948cf48242cd -863878fda80ad64244b7493e3578908d4a804887ad1ad2c26f84404dcad69ea2851846ad2c6f2080e1ed64fe93bbec31 -b262fb990535f162dc2b039057a1d744409a3f41dd4b70f93ff29ba41c264c11cb78a3579aad82f3fa2163b33a8ce0e1 -a7f6eb552b9a1bb7c9cb50bc93d0dda4c7ecf2d4805535f10de0b6f2b3316688c5e19199d5c9ec2968e2d9e2bd0c6205 -a50aa5869412dc7081c8d827299237910ecec3154587692548da73e71fa398ff035656972777950ba84e472f267ba475 -924c3af750afc5dfad99d5f3ed3d6bdd359492cff81abcb6505696bb4c2b4664926cb1078a55851809f630e199955eb3 -a1acffa31323ce6b9c2135fb9b5705664de8949f8235b4889803fbd1b27eb80eb3f6a81e5b7cc44e3a67b288b747cf2f -8dec9fd48db028c33c03d4d96c5eecea2b27201f2b33d22e08529e1ae06da89449fe260703ac7bb6d794be4c0c6ea432 -aa6642922ccf912d60d678612fffe22ef4f77368a3c53a206c072ed07c024aa9dcde2df068c9821b4c12e5606cfe9be2 -a16ddf02609038fcb9655031b1cb94afe30b801739e02a5743c6cd2f79b04b2524c2085ca32ec3a39df53de0280f555d -b067d48589e9d3428c6d6129e104c681e4af376a351f502840bbea6c3e11fcbfdf54dadf6f1729621720a75ff89786c3 -b14a24079de311c729750bb4dd318590df1cd7ffc544a0a4b79432c9a2903d36a0d50ecd452b923730ade6d76a75c02c -97437bac649f70464ace93e9bec49659a7f01651bba762c4e626b5b6aa5746a3f0a8c55b555b1d0dc356d1e81f84c503 -a6f4cb2ffc83564b1170e7a9a34460a58a4d6129bd514ff23371a9e38b7da6a214ac47f23181df104c1619c57dff8fe2 -896d0f31dfc440cc6c8fde8831a2181f7257ffb73e1057fd39f1b7583ea35edf942ad67502cd895a1ad6091991eabc5e -9838007f920559af0de9c07e348939dfd9afe661b3c42053b4d9f11d79768cba268a2ee83bb07a655f8c970c0ee6844b -b41b8a47e3a19cadec18bff250068e1b543434ce94a414750852709cd603fc2e57cd9e840609890c8ff69217ea1f7593 -a0fb4396646c0a2272059b5aeb95b513e84265b89e58c87d6103229f489e2e900f4414133ed2458ddf9528461cfa8342 -ae026cfa49babc1006a3e8905d6f237a56a3db9ddf7559b0e4de8d47d08c3f172bde117cdf28dfdfd7627bd47d6a3c85 -a6a3f3e7006bc67290c0c40c1680bf9367982eb8aaf17ecb484a58c8e9c2a7c24932e2caa9aacc9b4fbf4c0abd087a46 -9093e05bd814177a01a3b8d7b733db66294e1c688c56def6e1827c0f2d9a97cf202721641bf81fb837f8581ae68cb5ce -87feef4de24942044f47d193d4efc44e39a8c0f4042fba582f2491a063e3a4640cb81f69579b6f353b9208884a4f7ce6 -975f9b94e78aac55bd4755f475e171e04f6fbddb6fd3d20a89a64a6346754a3ff64ecff8c04b612a1250e1d8d8a9e048 -87cde4d0164922d654cf2dc08df009e923c62f1a2e3b905dfde30f958e9e4dd6070d9f889712acd6c658804f48f3edb1 -ae8e22e158dda90a185eec92602831b5d826e5a19aab8c6400dba38b024c7d31c4cf265eb7b206dd45834f020b3f53cd -a4475807adc28aa086e977b65bbd7c8512119318c89d2619ea03a6739a72c3fb90c9622451896c7113ad4d12a3004de6 -97f1ae1e0d258a94532c7b73fa8ebdbbd53349a4d2d0a217fe56dfdd084dd879960bc6ff45ebb61b5dbf2054642800a4 -b3c832bd3691332a658b0caaa7717db13f5b5df2b5776b38131ac334b5fd80d0b90b6993701e5d74d2b7f6b2fd1f6b9d -a4b6af590187eb1b2cb5ae2b8cffa45c5e76abdb37cec56fc9b07a457730f5af0706d9ce0a17da792bbece5056d05670 -97b99a73a0e3145bf91f9dd611a67f894d608c954e9b8f5a4c77e07574064b3db47353eba8038062cebaad06a2500bab -8e5ca5a675de6e6d3916bd9ce5898bb379372afe3f310e70ff031bc8cc8fabfb7f3bfb784f409bb7eb06fdb4511ee477 -aabbbee4da1f16b5bbe001c19debe04745932d36dfbbf023fbf1010a2b1d54eb92fa5e266ac1e9337e26e2ddba752f40 -b13447c77496825f48e35c14f9b501c5056e6d5519f397a2580cea9a383a56a96994d88926aa681142fe2f1589c03185 -b89c55db39ff0e73dde7435b61e8a4d3e10f51dd8096cbc7f678661962e6de3d16f2f17a0e729cc699234cb847f55378 -82c36b7de53698a1bafbb311fefc6007fcefa47a806ebe33a4e7e0fc1c7b6b92a40a1860702cf9295a16c6b1433e3323 -8daeec8c88543d09c494a15cc9a83c0b918d544311fd2a7d09e06cf39cdebfa0cfc0e8fc0e3b5954960b92332f98697c -b18e55a1a7ae16be3a453d2bfa7659a7ec2d283dd46bdc82decef6d3751eeafc4f86f2416a22955c7e750c0582d4f3eb -b50c743462e2915bf773848669e50a3bcdb5a9ac5f664e97eaccf568c7d64a6493d321be0225de16142ce82ce1e24f66 -af69c9643805fb860434424b1608aababc593aaebc6a75fc017f7f62bb2b1da932b0b9bd5e6dcbba328422dafc06efd8 -b5947db4f809fd0d27af838b82eef8ab4fe78687a23ebc61c09c67eb7e8d0e6a310ecb907fd257859d5a2759a07c21cc -92c7960e163ca5bdf9196c7215102f8e9d88efc718843321c6e2a6170137b8ecec4ea5d5a5ce4c28012b6cdbd777dd01 -b63f9509ed5e798add4db43b562e8f57df50d5844af6e5c7acf6c3b71637c0a2d2433f4a0627b944f0af584892208bb8 -8ef28304a9bfe5220af6a9a6a942d2589606f5dc970d708ef18bc7ed08e433161020d36fb327c525398cd8ecb57002f9 -b722e0410f896c4462d630a84a5a14e94289fc38ed6d513ca88a09005935cec334c480028efa1943c7a5e202ae8c8379 -b56b6672b488e64d4dde43571f9ceaa7e61e336b0fd55bb769a57cd894a6300e724e5f88bad39a68bc307eb7406cb832 -8bf493da411fd41502b61a47827731193652e6ce3810709e70869d9aae49e4b17a40437a7a0dcc0547dbac21f355c0da -9613b60a144c01f6a0e7d46ddde07402e2133a1fe005c049a56415ff90401765040b2fc55971d24b94c5fd69fec58941 -85e2f02b291563d8eea3768cf6a4602c0ca36568ffcf3d93795d642044196ca6b0b28991ea5898e7974ee02831a0ec70 -b08ef66703dd9ac46e0208487566fbf8d8654d08c00f03e46f112c204782ccc02a880a3f9dffd849088693cee33b7b6d -a0b19eeda6c71b0e83b1f95dffef4d370318bdea6ea31d0845695e6b48d5c428c3dbba1a0ded80964992c4a0695f12ee -b052642e5772d2ef6f49dd35c5e765c5f305006b2add3b4bee5909ca572161edf0e9c2bc3bc3bc7f56fd596360ef2201 -8261af164c768fec80d63fca6cd07d1c0449e9ca665fe60c29babdbd8a2b20cf1f556a4b24cd7341712468a731c21b32 -8a17016a1b2fc0fa0d9e3610ea80548fcf514e0a35e327f6b5f8069b425c0f0829af7e206013eab552be92b241be5ac5 -8eea25c680172696f5600271761d27ef4c8cec9ab22f01f72b2c7c313a142fafaec39e6920b96fcace858883e02eff7a -b8e0c590106e125c5bca7e7a071cc408b93629da0d8d6381f1b73fbdf17024a0cf13f679f5203a99bbbcb664b4a94e88 -b9943b29395258b7afdf1781cfaf131297a4f325540755df73401b2ec4a549f962952e9907413c39a95585c4aff38157 -8286eab4a04f8113fb3f738a9bc9c2deaf3a22bf247151515568703da4efe6450ab3970f5c74e978a2db7e8d795331b7 -a10cf383c8a7e3f0a0a5556b57532170ff46dabdcbb6a31c4617271634b99540aa575786c636d3809207cbf1d2f364d3 -a5af7eb998140d01ba24baa0e8c71625aee6bd37db4c5ff607518f907892219ba8c9a03c326b273bfd7068232809b73c -aed5f461e38fccc8b3936f1328a9747efcbceb66312f6d6eddce57c59570852767159f1a7d9998f63342515fef4ba9bf -aec3e94b029aa692bfe2b8dbc6c3b0d132b504242e5ebe0cad79c065085e2fc05550e5cdaa2353892a40ff1a062dd9eb -87c23703960129396018d0347f5dd034abdbd57232b74195b6a29af34b6197b3cd63c60ac774d525add96ae54d5c0fb4 -97964a7768216e1c84dece71ce9202cc64b6d483650aa6f6d67215f655f66cda14df0a0f251db55832c77bfd9b6316e2 -8167aaf24c8a023d0aea16b8c24d993618b9d0c63619e11a28feab8f14952bafcb0918ed322cbc0ae1b2e1786071819b -b58318bd62852ffb712fc58f368c21b641dde7b3fa7d7269974c7a7b5b3e1641569fc7b5f32ca49de22f4f993506d92d -b172e7911d5cd3f53af388af847b928947c711185aebd3328f8e6ed1106c161ae0c1b67d3d9eb237e9e66eb0672edec0 -a6834cf69b2c4433cf6e779bfbb736b12e73e71e149c38101d13dbacf6c5048db53994a6a039381df40bbd67de40fcd0 -882604aa3bb19fffd6db744b5cf4a2431b157dac06d0617e0703684a118ca90b2d22a7758a1de7732a7144e68b11b7f7 -addc128ba52bf7553b9ba49eff42004d388a02c6b6e9809abe1c0d88f467e5ff6cb0c82a8fd901b80dfc9a001f7b9997 -abf19604a3f0cffefa7a9ced81627f6aacb8d7267b52b825f25d813d9afa24af6d70da21450ed93eaff8b4d2a9b905a9 -a3c67e7bf02dbca183d86924611a7149556ee17cb3469793624da496b6c25617a9071925dd02aab9cb028739cb79043d -b1cea4284a3ac4d5b1c6f0947c6ec8365b3281ed15495bf328a907a9a02cdd186e7cb1ef080385b3399df786855985a9 -a6edb126314559e6129caf1111dc3c82ff914efce658b11f2c9b48081be1cf3f46bde482469d493379025a158d95ab1b -9843fd7dd424da1acc6f92f87fac364a8b0d4097d74b6b451386384966c85145d43fc6ecedf04271b0f963ac731fd93f -83852bedca03a97a2e63053cb102387866cbefe6707ebb6dae2d32a59c343079f1a863f299fd64d0ecbe024d0a1247d5 -a570e645a0679ebc6f0ca03cc8f7367b03c3886f3d9c787992de7f3e93360a170d3ac9ae7720999c727a887b1dc762bb -ad644c40555238f28844eed632c8972b63d2602098031d53b5599d1a874903e0d0c428e0ab12a209ea3fb31225578f1c -b64e9f92a14812ed31075f9fdd3324659a036ef2f293ef9ca6f6feb87d0c138e1ba74bc36a910afd22ff9b3c8ec7cfa5 -8f2d75a86d517dafac09b65596f4b89c4a9c0a7003632407504153fa297c9e3228e236948a5d5224b8df49a087c8e0e3 -b02d6ab9292ae336c8a74115f33765af2c9f62c331d70c087cf4c2979792bb3c2666f6699c017f8d4c6b378fd4bda86a -a923d660d2e55228b8bc74f87d966069bd77c34a776fa96f37b48539c85634482e514e2cb76cb8eb20efd85eb9c83fae -81d7ffb53090a6d512055ecfd582ca92805525a05654e39bb12653a6a8902a16e651ba7b687b36b8bea7186632c7e9e3 -83e9b33e29b57ae53d9f72bd4622ff388252333b4fa32ad360a5b00f3ffc8813b9cb8a1361454d3bb7156c01b94b6a08 -ad7d6bffe4d67eb53b58daa3fc8a5a60790c54fa42226ae12847e94c6de3b4365b3be39855a4f6a5f12e4803cdaed96b -a7709fed85abbee5a2fa49c5238582ec565da08c132d4912821491985bf83b681eb4823634bfe826abd63a6c41a64ea7 -b8fb6ed55741132a1053b6ca77bdf892e96b048488373ba4aa2f2225fae6d578724124eb6975e7518e2bf3d25d215763 -85e0c53089529a09b5bce50f5760af6aeafef9395388aa4b6144ca59953169101783347ee46264ec0163713a25fe7c63 -8f9e47a9c37b678e56c92b38d5b4dab05defc6b9c35b05e28431d54b1d69ac31878c82c1357d016f3e57ca07d82d9c16 -a81f508136ee6ec9122c48584df51637f768ccfe8a0b812af02b122a0fafa9abcc24778bf54143abb79eccebbdde2aac -931a96d2257a4714d1ef20ac0704438481632647b993467e806b1acc4a381cc5a9dec257e63239ba285deb79f92122dd -99fb0ff747bcd44b512bf8a963b3183ce3f0e825a7b92ddd179253e65942a79494a515c0c0bc9345db136b774b0a76b0 -a9dbb940b5f8ab92f2d85fc5999e982e3d990fe9df247cfc6f3a3f8934fb7b70e2d0362ba3a71edc5d0b039db2a5f705 -99011a1e2670b1b142ec68b276ff6b38c1687eed310a79e2b902065bc798618c0cdee7b2009ad49623ed7ae0aa2b5219 -9361e9f3aa859c07924c49f3d6e9b5d39a3df2fc1c10769202ec812955d7d3814c9e6982f4df3a8f3bdbfb4550cd1819 -a8aa23f177ddc1e7a7856da3eac559791d8b3f188c0b3ae7021bcb35dfb72b0f043c3699597a9188200408bc3daf6ab7 -a5a502ff673f6dab7ae4591a7b550c04ede22a45a960c6b5499644f721c62b12b9e08248e7f8b8a59a740b058d2a67e6 -ad374f80f0b52bc5a9491f79a547ce5e4a3ce4468a35d7dbca8a64083af35ab38eff9aa774ccba2e2e1e006e45cb0b85 -ab6851827125e3f869e2b7671a80e2dff3d2d01ce5bfbeb36cbaf30c3d974a2d36fd9f7c3d331bb96d24b33dbd21f307 -96658f6a2d225a82f7ccee7f7a7e476967e31a0cd6c62859d3b13ee89702bb821547f70ffd31cb46a6a0d26a93158883 -878f59ff2590bc3d44fdc674717589800748b78d543d3c0dbb50125b1d6011d6a083f10ab396e36b79f2d89b7cf51cdd -b8bdfb97829c5d973a15172bfe4cb39620af148d496900969bd7ca35de9b0e98eec87af4e20bef1022e5fb6c73952aa0 -a292a78b452743998aee099f5a0b075e88762222da7a10398761030ffcc01128138d0f32fccf3296fcbea4f07b398b5f -85da44fdd7b852a766f66ba8804ed53e1fc54d282f9a6410106c45626df5a4380cbea2b76677fdfde32446a4d313742a -84bebf036073d121e11abc6180cba440465c6eaadc9a0c0853a5f1418f534d21cccf0cfc62533eaeae4653c7b4988046 -923dec006a6af04ef675f5351afffffd2c62a17a98f4144221927c69f4553dd105e4fcc2227b5f493653d758cd7d0352 -a51eda64f4a4410a1cfa080d1f8598e23b59856436eb20a241e11106989fbbb48f14c2251f608cbf9531c7c442b30bf7 -ac6d26ae7bab22d49b7fba7fe4b8cf6d70617977008c8290787c9da1a4759c17c5e441efb3dee706d5d64d9d2ace1de5 -ab5138b94d23c1bf920b2fb54039e8a3c41960a0fe6173261a5503da11ff7b3afdb43204f84a99e99888618a017aac1b -8c85647a91e652190eee4e98a1eec13a09a33f6532926427bf09e038f487e483f7930fbe6ff7a2126ccde989690dc668 -a6026ab87cffec3e47b4c9673957d670cb48c9b968d2ad0e3d624d81c1082dcebbc70d0815cbd0325e0a900d703a6909 -ac4f6ff6baf8374a3c62bdd5a8d207d184ff993f6055bcee1e6dcc54173d756c37c24570d6462395add6f7871d60b1ae -a0dd6bc93930d0016557588f2598b7462ca48cbed637c8190be0fb4811e4576217ca9fc3c669c2a4db82e3f8bb24acaf -a67c1d79f7e7193a23e42928a5cc6a6e8e0c48b6b286607dbcfaaa0f10a7ba29ad62d1d57ca28c486794f0908bece29c -822f411bab4882202ed24e67c84e0c9a8da5b3389804ed9dfba0f672e3e1457ea76cad0cb935dbb3d7a39500fba5fe12 -8a1198572323689300a9d7db2e2bcb7c519392e5d3d33e83cd64bcf1517a7dde52318a98203727b186597702c0eed258 -8a84141b02f1d037c68d92567d71cda3a0b805d1e200b1d3fff3caf9902457cbfbaac33157b87ab0bb9e4fe3bac882c3 -8070ace16d9eef8658fdcf21bed0d6938f948f31ca9d40b8bdb97fc20432cd2a7ef78eeefc991a87eae7f8c81adf9b19 -9522e7123b733ce9ca58ab364509f308a1ead0915421ccede48071a983fd102e81e1634ffa07a9e03766f167f5c7cb5e -82cbdf97a755e952304f5a933fd4d74a3038009f242dac149595439130a815e9cc0065597c0b362130183a4c4a444173 -81e904f9b65cd7049c75f64c7261e0cbb0cc15961ffcac063d09399d0d2b0553b19e7c233aca0f209f90cf50c7f5e0b2 -8f5f6ea87429542ea04ad3eb5fc7eeb28fcf69c01c1a5d29b0de219524f6fba90c26069bfc9092379fe18cb46274393a -a4e5815481eb33b7990d2de1a3a591c1ab545b64fbeb4cff8c71b6bcb04d28940097899062bf43b27c5a8f899616703e -a7afe6066681e312882b3b181f462a1af2139d9bd2aefffae7976f3fc357bfd8fbd6ddd4e5e321412f107736e77f0cb6 -b8ab102d7ff8d46b055095d8fb0ec2f658c9e18eee523c295b148b37f8342c120798113553b8bfebf2a11f27bc704cc4 -862175ecc7e0e294c304a0352cd0f1d11b2603d326bb0e54e02b6cc8d04d01ac31c8864e9395aa1f3b90b76bc4397f5b -a4ea51ef3d82509f0e4eb6af705fa7530921cf9512cb5bf030571e69f4504a299297219a0a7e40db1b45165a5ea3a3f2 -a6fb8b573e2ba6db0e8aba53a489e99bebe533c0fcd947dbfa732e00594f03f4e8609ccc44d8215986d38bc3d4e55d48 -93fe8e0bdd5d66df2bd18be5963e864bddfcdcd3298590e7c3b11d99a070a4948fecef46453f19960bbfeada37979613 -acbc45bc55c7080b45c69a3db80cbfc0267006dcf49c47330975aeff2a8ac07b206e1b1c3a515e50866ff510739b92c0 -94a577df0983e4ee3d6b80c73d7e8e3bb78bd8390ff56fea350e51bdf5e0176b8494e7e81dc7b1d842ada961089cd1eb -81eb1fbe9e9c89f5818d0ef98e694da86e88625f0a37cfe88e6de69f90e58297e67f1d5c9d71263b523b63e42685975a -a81a2391ea4d0f65ab4325196559d67e2648b3f1e464509430b40d9948d5b0fc01c337d9b51048a93c4d62e6b73e1e8c -849a026e55ed77135138836c9df67883763e4602357d8566da2ee2505d135d44061de0c070cf333ffb9ac2e55a0894b2 -8e272cc5734374c003c7b2e6ba833eb99b6be608da04e576df471c24705b6b2a790549c53e7971df2d9f0b88d0f570c6 -b0f9e6d985064aa311d4a147f41007fdc576b7b9194aa4b8712bf59a76a71543fec2ee3db21bd3d30d4096f25babc543 -96331837f0d74e2ba6cb1bfaddf4b1fb359bf46cb6c3c664938eb030e56bc85a5ce17bcd60b7fa7b72cb0ba1f3af0b5b -a0eaab6de4b5a551896e7d26153fb5df4bc22a37833ec864090b57b5115b0f8f1279e855cea456bb844802b294b0dbb7 -955e87d3b966edff34f28137f871881c59bbbc6d69986b739867807680ca22b5e3272ced1d25854ed9700d87f133848b -9270a6db157a8ce78a1af6bfe2b5bbe7b621d56cc8f9940a03b5a5f600848b87b05d83595b2a3a315d4b7f4687c46085 -9043328f2dd4dd85e14c91237a3478dc1eed239164924b53d1de9364d76c81315afa9639b58eedb1ab2122e2ae2e7cfb -857fe9f7d00b03bce367de7f789d755911a5f85d78044f18311ecd9b955e821b4a50228347260ba1205aef61219001fe -a0f878050367a7103fddf380908da66058ef4430eae1758335c46c24f5c22fefb0753991b3a47dba5c7eaafa4d598178 -ab5959296b1af14d2878816c7da9926484cbf8896b7eeac8a99dc255013319a67a0209025e1f8266ffd8cd7d960bdc87 -abe53abc57ea46419dbe0ac1f39eee39a4feae265e58b50928eb0695e25938a16a8b00e65c1313837dc3367297e2c258 -93e3e42ed6ba9c45d4e7a4bf21c1e469efafded1f3be9931a683dbb780db2494742fd76c9ad29fd7d12da2b778ede543 -ab3e64035c488a6e63496ddb2de9648cc63a670c5d4b610c187d8ceb144fcc50b016046f50b10e93b82937ebe932ac08 -a3a8fa898f489b313d31838ad9f0c7ffe62ef7155de5da9ffe6ecd49a984fac3c6763e8cb64e675e1c4a0e45e7daf078 -8356b26aa7c9fc9734b511480dad07b164cfec1324ad98eec9839a7943f2889d37c188d465515ad4e47c23df641c18c3 -83c4476f829e0fe91da2353d5b58091e9335157941e89ca60ccab1d7fdd014bcf21bd55249805780ddc655c5c8c2536e -814f6e66505b2cb36de92c0de8004d6d094476522e66b9537787beff8f71a1381ed9f2b7d86778979ad016a7dae6cbac -b1cd7f6da4a625b82bea475442f65d1caa881b0f7ce0d37d4b12134d3f1beb3ad4c2f25f352811e618c446185486adb6 -a71b918481b9bda667de0533292d81396853a3b7e2504edd63904400511f1a29891564d0091409f1de61276d2aebc12a -a2cd3d4104ec5fb6d75f5f34762d5e7d2ff0b261bea5f40a00deec08fbdab730721231a214e4df9b47685d5bacfe37c6 -807f2d9de1399093bf284814bc4093f448f56a9bde0169407cdc0e7d2a34ff45052aef18bcb92f0ac7a0a5e54bd843e9 -abeb03010c3ac38587be2547890a8476dd166ac7b2a92c50d442f031eaf273ad97114c38e57fe76d662c3e615334ac0b -b90a688da4b0bf65ff01bcf8699f0cba995b3397fcbe472e876ae1091a294463e4b94350ae8bd5c63b8441089e0884fd -ad88db4afb177931788fb08eff187e15ad739edc7e1a14c8b777b6bf668aec69ca4749773f94250c1fdda3b59f705f7c -9886809f9ae952797c6527c6db297d2aa3d5209b360efe6a19970575a9f78aee3c21daadb8e8dfcbeeea5290238d16d9 -930f486e95d7c053c9742e6f0b31e6d4fa2187e41229e46a074b469aafb87880aa8e972719b363049fc9fe2db8f03ce2 -8d229af4fa08bd8aeb5fd9acfee47571eb03fcd2f19073b94cd27e2a6735029d31f123249d557f8d20c32ac881eae3aa -84576ed5aebe3a9c3449243a25247628993fdb2cc327072418ea2f1d11342756e56e9a82449bc3ea6e8eaecabc62e9b5 -b775cb86cbec9c46a4a93d426379c62872c85dd08bccda39b21cb471222b85b93afd34a53337b6d258f4891c6458e502 -8be1540e6b535b416b8d21e3ecf67dfb27a10fd4010f9f19426422edaeb0a4961d43ff3afd1db0994170056ce4d77aec -b9c7438e90a5501a4d05bbb8ab68d6db7e9baa8927231a5c58715ee2ab76ca1da0e94910a076958654869148d813d0e9 -aa9bed1c4d2e7cbc2e1a884c8998773f7cc6fa9d6493c8abe8b425114a48305c3a43a1abda2292177ffd39ef02db4163 -897b395356047cd86f576cfc050f7e4546ecd4df30b2c31ed8945797b81dd4ed9b9106cfbe6d7dd8bf91882e3cf1f42e -949a37e1037d9464b2ccd3ad23eda7089570d6b5ffa18025d2548a9df8829de8d62960f04a603f21eecbca5893d45284 -b8a0642f68ff169ffbcd8cd684fae75d96f9bd76949472775bf155edc55a3d9c3e6f0299ee73a6cfb96289361fdbe9ee -a1273141510fcddd89b9b92c19a268dadd1528ad85744b8174684c9b56668e6b35dabb05f2b4cc6ef5611eaea6052f27 -97c7415c82de83ecc066eb922268b8205ad7266c65b2b8f7e0aadac87f076c738cea72f9b0f069b8d28cf9d5438b8287 -b32c7005380c848f71092a74297555dc6022369fc2a4f285e586ac8f53f6bd354fbe4b1f8a4cfb406a101103bf87bb64 -91b48eeba52f02d04f536d32112038f8ba70bb34284fbb39e0f7bae2e08b3f45ad32e2f55d1beae94b949c15652d06a1 -99e24f5ea378cb816a4436af2ee7891ac78a2e37c72590be0abd619244a190fee51fc701b6c1c073611b412cb76332c9 -9465d1e73a1a0a5f7b1cd85f4fa4f5dee008b622b14d228d5cd5baeec174451e7ae93c5de688393d37cc24ce15df4139 -a6ac3986ee01debdacb5ddc1e2550cb4f039156df15c7d5752b79f333175b840bdca89c4959a523e58cf97bbd6b2039e -b7f7a5cc1b1b6145988170d619c170c130231abbe0b5143a9bccaaebeef9ceb1c16e26749bc9dc5650fe91f92fa1b79b -854cb04f1557457383a401d79a655adfd0a4b706ea2bbc6262949c8d657efcfdc9c7960cbe1a50b5eebb361c5e378f80 -8dd199dccbdc85aeca9ddcb5a78dd741a452f7a0d3ceb6546d76624bad2fce0e7e6c47ee30d60bf773f18d98503e7f9c -889e1ca9f0582be9bf5f1aede6a7312b30ea9bed45ab02d87182a013430f16007ae477ee6a823ae86c7fef7da016a0ec -892a60e63edfb3e7a6cf2d0be184413d214401fc1e6c004ca2902c3f1423728bf759a136e6e715d26d5bb229c75cc20a -a2287cd092261b39d22dcb1fa19512590b244771bb69fb62eda72f12be37d48e408b3e37a47608f68d743834edee7f15 -b3b6afb950bbec0ff631bdf18af433e68adc63d02cb479704f24329ca6b6edd9a3d1d606563dbdce6038b676b85130b9 -847da90f37b294509de51ab6521fdff12d5a1ec3cccaf730aa744da7e54b85fd9c70618787e87c0ba9947ce6c81387fb -ad872153c00bccac75bdb30d1ab7044d814f4f8655ff26421d48fea04fb21d4dc82c1900620a57d13adc45c1062a1817 -90fa5ee98fd7ec719f2a8543bbd0ff45ac69296c2416fc8666d05de3deea1017079a68aba55540a19585925803c8335d -962ba6d029e9176d0e8c80a21f2413f7322f22a9e9a32c933697a8b0e995ce25bea5264736a75718b3d330e215a58a05 -a446f9530db30c5e9c1b3844d635e5c2cd311cc4537ff277fe83dd1a0382bcfa73beb07aaa0cf5a97d24c67e688086a4 -8766b2053f16c72db387abe18b43d7b357a542916c9b8d530ee264e921c999494d6eb1e491352ecdf53758640c7a246d -83f32f511f7b0233662acfc14f30df345af99d2d6c777ce0b4bcdc4dd110533f30b45071df17230aaec392cc482355e1 -82e3521bc9519b36f0cc020225586b263e4feb57b533b38d8e89ccf8d03f301d94da90efb4902002732fbf3876697f38 -b5d1ea69c97ceaa34a720bb67af3fcf0c24293df37a5f6d06268b1eabe441531606954ac2598a1513f64231af722b3a3 -956842696b411e6221c5064e6f16739e731497e074326ef9517b095671f52a19e792d93fe1b99b5a99a5dc29782a5deb -b19b5658e55c279eb4b0c19a0807865858cbec1255acd621f6d60c7e9c50e5d3ee57da76b133580899a97c09f1dd8dac -89e6a8b916d3fcc8607790e5da7e391f6bc9eae44cc7665eb326a230b02bc4eb4ef66e608ccc6031048fc682529833d0 -b1a210bc8070ed68b79debd0ec8f24ec5241457b2d79fd651e5d12ceb7920e0136c3e0260bc75c7ff23a470da90d8de9 -85b1954278e2c69007ad3ab9be663ad23ae37c8e7fa9bc8bd64143184d51aea913a25b954471b8badc9e49078146f5ac -98bf63c7a4b200f3ce6bf99e98543925bc02659dc76dfedebe91ec5c8877d1271973a6e75dad1d56c54d5844617313e1 -b7404b6e0f320889e2a0a9c3c8238b918b5eb37bcdab6925c9c8865e22192ba9be2b7d408e1ea921a71af3f4d46806d0 -b73cbbebf1d89801aa838475be27c15b901f27d1052072d8317dcae630ab2af0986e56e755431f1c93f96cd249f2c564 -95b2027302f7f536e009f8a63018da6c91ec2b2733c07f526cc34cbcfa2f895ccfd3cc70be89f4e92c63c7ddc2a93370 -9201d9ff5d0b1222bfa2345394f88ddf4fe9282acf51bee9b18b96bb724fdf8e736d7101acc2795a34e72f9e0545c9a8 -acbff7eb160f427d8de6f29feeddfa8994674e033a0ccdc8e8c73f9243968f1a6379da670a7340f422892d50c97113c7 -97ae8d03352c3729e1623e680dd9664f303b3bcfb844ef80d21e9c773a247967d27b86c9326af29db5eefd0bd3d4fac8 -8e53ae5c22f5bfa5fe4c414dad6a10b28a3e5b82a22e24a94e50ce3b2bf41af31e7ba017d2968811c179017b78741ef0 -b5ac7dd150247eb63dfb7dd28f64b1bf14426dc3c95c941e8e92750c206c4c7f4ad1a6b89e777cfe26ecb680dbf0acb6 -99ae2e4652ea1c1c695e7ea2022fd35bd72b1a0d145c0b050da1be48ad781a413dc20fbda1b0b538881d4421e7609286 -b8abe1fb3a7443f19cd8b687a45e68364842fc8c23d5af5ec85da41d73afb6840ef4b160d022b2dad1a75456d809e80b -842619c3547e44db805127c462f5964551f296a270ed2b922e271f9dc1074fdf1c5e45bb31686cec55cb816d77853c01 -902dff769391de4e241a98c3ed759436e018e82b2c50b57147552bb94baddd1f66530915555e45404df9e7101b20e607 -82e4f2ee7c7ca1ee8f38afa295d884e0629a509c909a5464eb9ea6b2d089205478120eed7b6049b077b2df685ec8ba48 -aa21a68b0888e4a98b919002a7e71e6876b4eb42227858bf48c82daf664c3870df49e4d5f6363c05878a9a00a0bcf178 -a8420cd71b1d8edd11ebc6a52ba7fc82da87dd0a1af386d5471b8b5362c4f42718338bcbc302d53794204a0a06b0671d -98c686bd3a994668fbbd80c472eed8aedd3ab5aa730c8d3ce72e63fb70742e58525437be1f260b7ecc6d9d18a43356a0 -aca0b2df9ec8ede0b72f03b121cded5387d9f472b8c1f3a5f1badd5879fb2d5d0bbb6af1a2dd6bdebf758cfceadbe61d -93b1abd9cb41da1422d171b4dbf6fbcb5421189c48e85c9b8492d0597838f5845198494c13032e631c32456054598e1d -a246ab3a47f7dc5caedc26c6c2f0f3f303ed24188844ab67a3da1e793d64c7c7fe3e5cc46efafbd791b751e71de0614c -b9b52095ca98f1f07f3b0f568dd8462b4056c7350c449aa6ce10e5e8e313c2516ac4b303a4fc521fe51faf9bf7766ce9 -8e2e9d26036e847c2a2e4ba25706a465ac9fbb27804a243e3f1da15dd4084f184e37808661ec929479d3c735555085ee -8b8c4f4ad5c8e57e6a7c55d70ef643083d4b8dac02716ea476d02dbbb16c702a2f2d5dd5efe3aec7704d2b8cdafe3959 -a800afea30d0df333805d295bac25419b7049d70044be00c7c85a92a0503ca471001bc1e6552323f1a719eb96616fc20 -868bced4560e1495b8527058ebc82a538b7cf806f8d8fe8eeed6981aba771de4d5e9f03cbfc7157d38b9f99cdea87b96 -86b86258b0c1feb988cc79f6c4d4b458ff39428eda292f9608a5fc4c3765782c8c23c66f82d7538e78e092cd81d69a56 -9370eac15de2555824c7d48520a678316a7bb672e66f8115ad7dbc7c7b1f35a7718e8fa0c35f37e3ef2df32dfa7ca8d1 -ae200bc5be0c1c8c6ec8e9fd28b4d256c6f806c0f270766099e191e256d67b9cceda2cc2fed46dfa2d410971a7408993 -af2428c77b2b9887ecde1ea835ed53c04891547fb79fe92e92f9c6009cdfffa0cb14de390532ad0ef81348b91798bd47 -a9069eef0316a5d13d1aa4cef0cf9431518f99b916c8d734bd27b789828ae03e5870837163ea6ad0be67c69184b31e8d -b1b1ce6d529f5a8f80728173b2f873c8357f29644b00f619c15111224377ae31a2efb98f7e0c06f5f868030aab78ed52 -b89c98beef19ee7f300e1c332a91569618ef8bf2c1d3de284fc393d45f036e2335d54917c762f7c2874a03fe4f0f6926 -8264f993dceb202f8426339183157e9e0e026d4e935efe4cf957eb14cd53edcdc866305fb1334cdf0e819b69eafbaccf -aebd113f73210b11f5ac75b474f70a2005e5c349345003989175dffa19f168abd7f0e28125b18907502fff6fcc6f769b -9993ad061066ca6c2bb29fe258a645089184c5a5a2ef22c811352749a199be3a3af3a0d5ce963febf20b7d9e63508139 -97952105000c6fc6c2dcae1ebdb2feae64f578d26a5523807d88e6caf1fe944b8185e49222d06a4553b3bdb48c3267a2 -82dd955f208957d74693bed78d479c9663f7d911f68ff033929418eb4a5c5dc467589ca210c1ba3c2e37d18f04afe887 -b816fc4763d4c8a1d64a549c4ef22918e045ea25fa394272c7e8a46dcb0c84d843d323a68cc3b2ef47a5bbb11b3913bc -a7a87ba4d12a60ee459aad306309b66b935d0c6115a5d62a8738482f89e4f80d533c7bba8503e0d53e9e11a7fd5fe72b -92b36d8fa2fdee71b7eea62a5cc739be518d0ecf5056f93e30b8169c3729a6a7ed3aa44c329aa1990809142e0e5e2b15 -8835b6cf207b4499529a9034997d2d3bc2054e35937038deb9c3e2f729ebd97125f111c12816d30b716b397016133c52 -acf14cd6d978ba905cf33b9839b386958b7a262b41cbd15e0d3a9d4ef191fcc598c5ab5681cf63bc722fe8acfda25ce6 -b31302881969c5b283c6df90971f4fb2cc8b9a5da8073662da4029f7977fbb4aaa57dd95b003a9e509c817b739f964e7 -b74669e1c3fa7f435e15b5e81f40de6cfb4ad252fcdfb29862724b0a540f373d6e26c3d600471c7421b60a1d43dbeb0f -861d01615cba6ca4e4ef86b8b90f37fa9a4cc65cef25d12370f7e3313b33bb75de0953c8e69972b3c2a54fe110f2a520 -a58a56820efaf9572fd0f487542aaff37171d5db4a5d25bfb1a5c36ca975eb5df3cb3f427589e1101494abb96b5e4031 -af13d0a6869ef95cb8025367c0a12350800c6bc4ae5b5856dcb0a3ca495211d4139f30a8682d848cb7c05c14ae9f48cb -8c385767d49ba85b25a3a00026dd6a3052e09cd28809d5a1374edf4f02dc1beed367055b0dee09102c85985492b90333 -b5129fc2fec76711449f0fcb057f9cf65add01b254900c425e89b593b8d395fc53bb0a83ddbd3166acc6d2c17f7fc2a4 -86bd01b3417d192341518ad4abf1b59190d9c1829041e6f621068bce0bef77ec3b86875b7803cf84ff93c053c2e9aad1 -a74fc276f6af05348b5fabccb03179540858e55594eb8d42417788438c574784919fb6297460f698bd0da31ce84cebfc -967ed3ec9f1fc51f76f07b956e1568d597f59840ef899472a3138f8af4b4c90861e23690c56b7db536f4dd477f23add6 -b9e678206de4fc1437c62d63814d65f3496be25a7a452e53d719981d09c7e3cae75e6475f00474e7c8a589e2e0c6bfa3 -b028eaffaa4ff2b1b508886ff13c522d0b6881998e60e06b83abe2ac1b69f036eece3ded0f95e9ae721aea02efff17b6 -935f82de9be578c12de99707af6905c04c30a993a70e20c7e9dd2088c05660e361942fa3099db14f55a73097bfd32a44 -96a1cc133997d6420a45555611af8bcd09a4c7dbddf11dbe65aab7688cc5a397485596c21d67d1c60aae9d840f2d8e48 -80d117b25aa1a78e5d92ea50e8f1e932d632d8b37bebf444dcc76cc409322fb8eface74a5dddab101e793ff0a31f0a53 -893229136d5ab555dc3217fb4e8c6d785b5e97a306cdaa62f98c95bad7b5558ed43e9a62a87af39630a1563abd56ec54 -b7ec1973ec60bd61d34201a7f8f7d89d2bc468c8edc772a0ba4b886785f4dadc979e23d37b9f7ef3ff7d2101d3aa8947 -b6080ca201d99205a90953b50fc0d1bd5efd5eadbfe5014db2aeb2e1874d645ab152fb4b0ff836f691b013b98ce7c010 -b546e66ec0c39037bbaa66b2b3f4704a6a72cf1924a561550564b6fcf41fbc2930e708cd5cac1d05e12a4b8ec93ff7eb -8abeed90a01477260f4b09fff8fa00e93afe727e8eed6f111d225c872a67e6ab61d0472ab6add3fe987744e16f7c5268 -8e02342d5cc1836ed21834b9ef81686172cc730f0412479db5f590b0ff7a729a0e986ffed16d6ecafd6b83d65922ca5e -b05660605cf8e8a10c8d3c77cccbe4e7179fa27cc829571f6b722a58e65e4e44d7fe977446118e9da2d2f40af146cc2d -942a00e006baba6d025cbd99297bdb0cbf3d84cddf849b1b5a9fe9ef1745352fad81313cce5d7622d6652096a8fa065c -aace8212b3d8dbe44ac97460a5938a3b803aca9bd00d8a643a859351daf391b22d1fd2a6b3e0ff83cc9ee272a1ad7686 -965a9885a5259197a75a19707a2f040e0fd62505e00e35ebe5041d8467596752aedf0b7ec12111689eceb3e2e01ecfc8 -81d58270a4e7ee0137cb2bf559c78c4fd5b3a613468a8157b6a9c5c0b6ca20a071b87c127d59cecc3d0359237a66d890 -af92b6354fbf35674abf005cb109edc5d95845e3d84b968e6001c4b83d548715dffc6723ac754c45a5ace8cd7dd30a24 -b112caa707f9be48fdde27f1649149d9456857f928ea73e05b64bb62d597801daac0b89165fea76074f8b5770043f673 -b6e7380746da358fc429f676b3d800341e7ab3f9072c271310626ae7f67b62562ff76c63bc9f5a1dbc0e0af87752408a -a45e9e8d0931207ebc75199aa0c983134aa97f771ff546a94a3367bcedf14486f761e7f572cf112e8c412018995fdaf4 -854381128de5bfb79c67b3820f3005555f3ee6f1200046ebbfaee4b61b3b80a9cebf059c363a76b601ff574b8dbf0e6b -aa1b828a8b015d7c879669d5b729709f20a2614be6af6ff43b9c09b031f725f15b30cde63521edda6cd4cf9e4ab4b840 -8f28f6b62c744084eeddcb756eced786c33725f0f255e5999af32b81d6c6506a3f83b99a46c68fc822643339fe1b91c5 -ac584e76a74cafe4298ca4954c5189ccc0cc92840c42f557c40e65a173ea2a5cd4ae9d9f9b4211c9e3dfd6471fc03a1b -a413365df01db91e6a9933d52ab3e5ed22d7f36a5585ad6054e96753b832e363484fb388c82d808d1e4dfb77f836eab9 -8a68c51006d45bf1454a6c48a2923a6dbeb04bd78b720bb6921a3ca64c007043937498557f0a157262aac906f84f9bf8 -b93ff8b6c8c569cc90ee00cfe2fc3c23cccea2d69cbca98a4007554878311635cb3b6582f91636006c47b97e989fe53d -b9a8a44d54592511d74c92f6a64d4a8c539a1d8949916ef3773e544f6f72c19a79577de9878433bd35bb5f14d92f411d -94f066a7e49ae88d497893e4ce6d34edc2dc0b42fe03934da5d4ed264d1620d506fcc0661faa90a6cf5083e1720beaaf -b42b102adef8f42c1059b5ca90fe3524dcd633cf49893b04b4a97a1b932ca4c7f305cebd89f466d5c79e246bad9c5ced -86b560d78d3c5fb24a81317c32912b92f6ea644e9bedfdea224a2f0e069f87d59e6680b36c18b3b955c43c52f0a9d040 -a3829fa7e017c934fa999779c50618c6fb5eafb5e6dec0183f7254708a275c94ba6d2226c5ca0c0c357b2f2b053eea93 -9337dda730076da88798fd50faed1efa062f7936a8879ea4658c41d4fcf18cee7120366100d574536e71f2f11271b574 -853d09a30f4342f5a84c4758e4f55517a9c878b9b3f8f19e1362be9ae85ca0d79c2d4a1c0c14f5eff86010ad21476a7a -b0bc74cb69bdd8fdffca647979e693ad5cbf12a9f4ead139162fa3263bfebef3d085aab424ed8c6220b655228c63c6b1 -88d8dc8faf3aab12ba7180550e6a047f00d63798775b038e4a43a3b40a421a3f5f152a7e09f28ccd7198bb8cefc40c07 -88db2e3b8746415d0c3e9f5706eda69a29d0b9ee5135ad006060be7787f4f1f7069e2e2e693c5e10b7c3d5a949085ae0 -b5bd830d2f1c722188dba2690d21b7b84b92cbdd873a55aaa966f1d08d217bfc8cffe8caea68868f3850b90b4ab68439 -b5ad4be0c9626a33fce6c8501297bdde21b07b88531451912ed41971a4c48fdd1036d8a4994a99a7fbba4a5901a7095e -b0e1337a2a1772191faa91302f1e562e7cdc69ba5b25139e7728ce778a68a7fa9817f852ec8e04a159122cff62992ec6 -b4fd4a4c1be8bc7e4e2bfd45404c35d65b75f45fb19ce55c213a8035b41f1ccbce9766f3df687c0d7cd6cdfc1abb00a5 -814bf565ece6e9e2a094ffbd101f0b9fea7f315a2f4917abe2bf7d070ed8c64a2987bd288385a42fd336ed0a70a9d132 -af860af861dc80894ed69f29c8601d986917ec4add3d3f7c933a5e9d540bc8ff8e4e79d0bb01bbc08fa19ef062f2890c -b66d33fcf3cd28f15111960ffc6ed032c3b33d4bb53d035ab460cc5fa7ce78872f0476d0bb13f1d38f2672347d2d6c4d -89603ae1a5dd7c526936b86a3b69b7b1d0bdf79ba3cc9cc2e542ec801a6126d1514c075d6ad119fe6b6e95544ffe7fbe -8a1b097f46a62d85cff354d1e38df19a9619875aad055cc6313fdb17e2866d8f837a369a9ee56d4f57995e2b0a94310e -8dc165d86c7f80b0fcd4b6f90d96cd11dc62e61d4aae27594e661d5b08ef6c91156c749de8948adfaf3265b1d13e21cf -98e3173772c3b083b728040b8e0ee01dc717b74c48b79669dd9d2f7da207af64ccd7e9244bc21438a5d4ac79b88e9822 -924d168099b6952d6fe615355851f2b474f6edfcd6a4bd3ad2972e6e45c31bf0a7fb6f7fca5879a0de3ea99830cfb5bc -95452f0b7efda93c9e7a99348e13f356bad4350f60fcd246a8f2aa5f595a9505d05ec9f88b1fe01b90ecd781027b9856 -b95e8af516bb0941fc0767ecd651ada2bc64cc3e5c67a1f70048c634260c0f2c0e55ed22948e1870c54590b36683a977 -82f7feb71e746d5ca24455e3f3e57e4eade92669ab043e877b836612efd3de82009f0555e5d8811bff9f2b75fc57a01d -87623c02caf590ea84cf4a84d1be501f89262e26eb463f2f94a2d3042889c051b058823c3367a989498e46ff25edab16 -b88da847b1ef74c66f923773ce8c920ca89751335fde17b3a98c0603862069a2afbf35b1552b43ad64dccea69f040ff8 -96b734758c823e5ce5b44625c252957e16fa09f87f869baac195956052dc92f933f377b288c7f63b8028751cbbdca609 -a23cc5fbbe5cb7c1d33d433cec4e502f6548412e2374e285d307f75e98280b0c0af4f46bba18015be88cdf7db8b1239c -8bd5bbe04bc929ca8f546e673803ec79602f66ec24298d3e3b6bf6f2c25180fc0032ea6f86c38a6e0ec20ff4eaafc7a1 -b95768ca113e5d57ad887a1cb5ef84ce89007ce34c3156cd80b9aa891f3ebaa52b74c0cb42919cfbcf0cb8bafa8085f9 -a117f99045f65e88acc5a14fc944f8363f466e4a64057eb8fc64569da5dd022a01f2860c8e21b16aff98aebdf89461b7 -895cda6503907c98c43477eaf71dfd26759032523691659f13662ca3a967d93bbc5be342d168223cef7e8a333987d6a0 -a084d77d913d3ec0586ad5df2647610c7ed1f592e06a4993a5914f41994a29c4a8492d9dce2e14d8130c872d20722920 -84a328b73c64137bb97a0a289b56b12060fa186ce178f46fe96648402f1b6a97d1c6c7b75321e4b546046c726add5a08 -b7c35087b2c95127ce1470d97bceb8d873a7ad11a8034cc1cba7b60d56f7e882fc06796048435a9586eab25880787804 -ab05e3394375ee617c39c25c0ec76e8a7f2381954650c94fbcd11063ea6772c1823c693d2d9dd18bd540a130d7b92855 -82ba5907051d84b37fd9d28f8b9abebc41fc4aaa334570516ca2e848846644016356d40fa9314543017d4f710d193901 -9170517b6e23ee2b87ff7c930cb02b3e6bd8e2ae446107b5b19e269bf88f08de5ded3d81a2ff71b632ca8b8f933253a0 -93dc0e3f6234b756cdbb3fe473b9214e970972e6bf70803f4e2bf25b195b60075177a1a16382f1dee612a4758aa076ee -b4b49fac49cdfccda33db991994a8e26ab97366545166cc7140aef3d965529f96a5dac14d038191af4fb9beb020ff6d5 -b826537670acdf7a8a45ef4a422d5ae5a1b5416ad0b938307518d103cc7ba78e495ea200adc5941414a70158a366e8a2 -8ae3588b1fbecbc769c761f0390d888e34773cf521d976ee335f6c813bf06dad38850871ac8a8e16528684f1e093d0c1 -ad9c00b8dccdb545315fbf26849135699c6aa3735f89581244281154c906aba80d20c1e7f18f41acc61e0565f8015a33 -954ce68146c05fc1c9e536add3d4f702335d93c1650b8c1fad893722a81f915eee2d38275dad00ce87f3f5bc90ef7341 -8243feaeff9a12f5aeb782e3dd68609ce04ecde897c90fd8a19c9c5dace3cf43bd5bc0f1624bf7fd2607ca0d71adbba8 -a8a1be55259cd27898d9d60a61998d8da2bf2d439ba6eedb61d6d16dacc4a81ec706b9196dfa080ba20701d2cd9fa1f4 -b0eac6212c7a62ef6062c30875fbe24b8e1a9d88854c035686f849a9eed4d17fbc9af27429eb7c3fd60b47a5e29f6783 -878561a88412e95f19f1cb8894be9d0ea4a2cdd44f343387f87dd37445e5777bceb643cebc68c910acb5e588c509cd2e -a57b6c347955d8b0057a87494223148ff9ff12b88e79dbd9d0aae352fe55e15ea57fcfb9add3d5d269ee0001d8660f20 -a07fa66340d4082585e4d72c77510c59b272e7a3345f4b1de6be7ff4a11ea95d712d035a7355fc8d2e571fa65fe8236f -b9d84a627462438e8ede6c453e3367bfaf81cff199d3e5157ef2bc582d358b28b5ccc3bc27bb73af98ef45179ea79caf -b14f26ea7ca558761cb19508e5940fbf5dcf2ad8555c5a03e8ff92481994072f523b1ab6b7176f698e2cfd83d4f8caad -800cca1cbb14e1fc230c7b420ff06864a934b082321bbf5b71f37340383923f23183d4fdc8fa2913928722b8892db28e -94790c950b92e971ec39e9396c3f32dee32a8275d78e6ea28a47130651bddc86a189ef404c5e8c210bd291186dee0df4 -ad7b3b3e377df64023b8726d43a7b6ec81e5a5e8c0943c5bebe5ab5ddd6597255f434a205c14ba90e9e5e3c462a1fe0c -86ff8156cc857a416e735009cf656b89da59b766b4c4e5a0c0165282b530c10657cc28cf5cb847696725c37ac48b69d7 -89cb64cf9294f68f01533660a2af2aec0ec34cc0b4a0cc36a128f2e0efb3da244981f69aede962f50590faeeb9a5da01 -a2ea5a94a524bb8e6f767017246cd1af9d87c9abb9894e91c4e90c34c5161be6179b49dafcab9cff877a522c76beb145 -b5d9abf29ed6030a1e0f9dc19be416c45ba8cb5ed21aff5492233e114035715d77405d574cd62f2716285e49f79b9c99 -ac441cf6104473420babdfb74c76459cbea901f56938723de7ad3c2d3fadb0c47f19c8d9cb15a3ff374e01480b78a813 -abea34bd2d36c5c15f6f1cdd906eb887f0dd89726279925dbe20546609178afd7c37676c1db9687bc7c7ea794516af03 -8140abfd0ec5ca60ef21ad1f9aabbb41c4198bac0198cb4d220e8d26864eedb77af438349a89ca4c3ff0f732709d41a9 -a5a25abf69f3acd7745facb275d85df23e0f1f4104e7a3d2d533c0b98af80477a26ac3cf5a73117db8954d08f9c67222 -b45ac8d221a7e726ad2233ba66f46e83ed7d84dbe68182a00a0cf10020b6d4872f3707d90a6da85f6440c093914c4efa -80f586dfd0ceaa8844441c3337195ba5392c1c655403a1d6375f441e89d86ce678b207be5698c120166999576611b157 -b8ce52089e687d77408d69f2d1e4f160a640778466489d93b0ec4281db68564b544ec1228b5ab03e518a12a365915e49 -8990f80bae5f61542cc07cb625d988800954aa6d3b2af1997415f35bd12d3602071503b9483c27db4197f0f1f84a97ac -8329858a37285249d37225b44b68e4e70efeef45f889d2d62de4e60bd89dde32e98e40e2422f7908e244f5bd4ffc9fe2 -8d70c66ea780c68735283ed8832dc10b99d3daeb18329c8a44a99611a3f49542e215bf4066ff4232d36ad72f1a17ccc3 -a3b2676cc8cdf4cc9e38c6cb8482c088e5e422163357da3b7586a3768030f851ad2a138eeb31584845be9ffb8067fc00 -95b1fa74e9f429c26d84a8e3c500c943c585ad8df3ce3aea1f6ab3d6c5d0ed8bb8fa5c2e50dd395fa8d4d40e30f26947 -b1185f2ac7ada67b63a06d2aa42c4970ca8ef4233d4f87c8ffa14a712a211b1ffde0752916bfafdfa739be30e39af15d -8705a8f86db7c4ecd3fd8cc42dd8c9844eab06b27d66809dc1e893ece07186c57b615eab957a623a7cf3283ddc880107 -af6356b372f0280658744c355051f38ff086f5563491fc1b3b1c22cfec41d5c42b47762baeb9ee6c2d9be59efd21d2b7 -86bdd4527b6fe79872740d399bc2ebf6c92c423f629cdfcd5ece58e8ed86e797378a2485ead87cbb5e2f91ba7b3fbda1 -a900f0be1785b7f1fda90b8aedd17172d389c55907f01c2dfb9da07c4dc4743cb385e94f1b0fc907dd0fedb6c52e0979 -a9f59f79829a9e3d9a591e4408eaec68782c30bc148d16eb6ae2efccb0e5478830bbdaa4ae6eac1f1088e7de2a60f542 -99cf54a69ad5e8c8ec2c67880900e0202bcc90c9815531d66de8866c0a06489ea750745cc3e3aa1c4d5cb55dcd1e88f7 -8676246a4710d6d73066f23078e09b3fa19411af067258e0b8790456525c02081727b585d6f428c8be285da4aa775a4b -b596c7014fe9214529c8e6b7602f501f796b545b8c70dbf3d47acc88e2f5afd65dccef2ef01010df31f03653566b16df -a12205c6c1780fc8aebdd98611e12180005b57750d40210b9eff0396d06023bd4ff7e45f36777123ff8bed7c5f52e7a3 -ae7dbd435bba81685d5eab9abc806e620253da83e56b4170952852d442648a5d8743f494a4b0fc9d606574f87895b0d6 -9786257b1726b7cdc85219ca9eec415f98f5a11e78027c67c7b38f36f29fe7a56443570fdfedc1d9293a50e4c89d89f6 -aaf0515070d1ca92aacdf5fac84193d98473d8eb2592381f391b8599bcd7503dbf23055324399d84f75b4278a601c8b2 -b31654dbf62fbbe24db4055f750f43b47f199a2f03c4d5b7155645276b2e456a218ca133743fb29d6f1a711977323f6e -8f4d39106ecdca55c1122346bdaaac7f3589d0cf0897a6b4b69e14b4d60550fd017876399401ce7c5d35f27da95f50be -8a7bfdb48cd47afe94aff705fac65f260b3a3359223cff159b4135565c04b544dd889f6c9a6686f417e6081ad01e0685 -967ba91111e5e08f9befcbaad031c4fb193776320989f8ede4018254be0e94586254432d3dbae1455014f3a2f2549d01 -a9db52352feeb76715a35c8bed49fb3a8774c9c8e58838febf800285fd6c4938ec162eb8457029e6984d8397dc79ea19 -811794e6bfe2539e8f6d5397c6058876e9e30763ad20dad942bb5dbcab2f16d51718ce52bfb4de17889ba91da1b85bcd -a6db0f65a6dc8b8cc2312a3e0146d8daf520255bb12f74874c05693914e64e92be0cd53d479c72cb2591e7725dfaf8b0 -918d21bfa06d166e9eb5b7875c600663a0f19cc88c8e14412319d7aa982e3365f2dff79c09c915fc45013f6b3a21200d -9894852b7d5d7f8d335dd5f0f3d455b98f1525ad896fdd54c020eeaf52824cc0277ecbfa242001070dc83368e219b76d -ad00acc47080c31fcc17566b29b9f1f19ccaae9e85a312a8dcc0340965c4db17e6c8bd085b327eaf867f72966bf61452 -965e74649e35696744ecc8bed1589700bae9ca83978966f602cf4d9518074a9aa7c29bc81d36e868a0161293f5a96e95 -961e29a239c2e0e0999b834e430b8edfe481eb024cc54ffaffd14edaf4b8522e6350dc32039465badfff90dcb2ba31cc -943dda8fa8237418a07e311efde8353c56dd8ec0bfa04889ccdd7faa3dee527e316fdc60d433a3b75a3e36ca2aa9d441 -a0ed4c102e3f1d6ebf52e85a2bc863c1af2f55dc48eb94e40066f96964e4d37fff86db2cff55a8d43d517e47d49b5bd7 -9045770ad4e81345bc6d9a10853ee131232bf5634ef4931b0e4ba56161585b4286876bc8a49b7b1f458d768718cb8ebf -b0dd430295ff28f81895fde7e96809630d1360009bbe555e3ac10962de217d93ead55a99fd4f84d8cadd1e8d86d7b7ef -95ced48419b870ea4d478a2c8db699b94292f03303f1bf4560b5b1e49ca9b47e7008514fe0a9cf785717f3824567e1b2 -a7986e0e389e8aef6aac4a7a95e2440a9af877ae2bc5ad4c5f29d198ec66aa0db1d58c451e76ae70275a2e44c3d3fa68 -85a8490faf32d15de12d6794c47cc48e02428af1e32205e0742f8299ea96b64bcd6d3b4655272afa595eec74ecbb047c -b790d7fb1307aacc2d303d9b6753a9773252b66c6b67763cf8841c690cbccc4866ffb5fec1c068b97601a7953fe0f7e8 -afcc4011f8c53f10d63c29b74d9779cd75c861e01974c28a4ec2cbb909b67a1b2287ead175231343c936ad75dfa416ff -918058bffdecc1ae8779dccf1d874bb9e28edbe34c8b5954a8da64a848858d2f0776437b423baf4e731f3f5fa05a2841 -ab554db549aa36dfa9f966a5ed6be8267e3aa9ced348695f3dafc96333c6dbb48ef031693aafd59d1b746ecd11a89c51 -ac4ecf746b46b26a7af49cc9cc1d381e1e49b538dbd7fb773ce6b1df63ae31c916693cca8a90fb89f1e7ec5e0e8dd467 -a8de66d48f16b016f780a25ba25bd6338fd8895a1909aabcfb6e70f04ff66f9866e6e2a339bcbfa4bfba4070a6a8db26 -b4b49374eff6dac622e49b0e9c0e334ecbec513a96297f6369696ad39e5ec0de81a1417f6544be866c9f60957a9ba09a -b8023968549ebab6c1e7a8e82954a5b213bec50bbf35b36697a8d4fd75f9e12d510b365962aace4c9978c5b04da974a7 -8d4bc016026dd19e4059d1c5784897cefa47f7ae2ed6dfa2b3c14a852fff2b64abc09549d106584e0daed861a2d6d6c2 -85e26f433d0b657a53da4c1353485e0c2efa092484c5b8adb3f63dc72ee00be79197ebef7937b37a6a006571641cd6af -abb37a917301e68328032ff4715abc0fee32e5f5be68232ca8bf7ffb8732bc47504e75b40bcc0a7c7720b71496fa80af -9837c8d2660522c0357f5222777559d40321a1377f89ca1717215195bad4a348a14764bd87fa75f08e1f6263e9d08982 -97e06f971b4c56408ed5f1de621d233e6a91c797f96ec912737be29352760a58831aaf1f64e377c3ed9f2f4dc8ad1adb -a12d211304da7b91101513d57a557b2504069b4383db8ecb88aa91e9e66e46e8139dadc1270620c0982103bc89666215 -aab74ba48991c728ba65213e8c769e6824c594a31a9b73804e53d0fda9429403ff3d9f6ea5ef60884585d46356c87390 -92f19be2b7adf031f73611282ad33e462852f778c5e072f689dd0e9458fa6ebccfae02f2b2dc021802c9225035862468 -953bb843c48d722604576cef297123755cef8daa648c30c3a678eada8718dfdb16e71cc3e042a51fedc80577235c2563 -86f509e3c1b9ee9a3b95e6da8516b47feb8c8a83403984228f4903c7ee1ee4f03addcb8fe86283af1196a54b36b9470c -903d793a377e98e2562c49de33e3fbf84bf99211925e7002a4f688470db655884e1efe92782bf970ffa55d9c418ef3b5 -a41b65681ed7f10987a7bfdf9e56b010d53683819d845d880fc21b2d525540605c5823e75c434f17b5a0d08a091c1564 -971be802de51cfc0d10a96be7977c037873f19334ed4ed4904b7675aec8bfa1f8956cd0150b07064caf18229ffd1ccd9 -b253ebe4f82cdbefbc3ef816d40c497fe426a9f0f0f170e783fa4a05ae6dabdfa8c448817a24e723a314b43e76a7c422 -86f397c95025489929ce9230b1466b5c330ec7c58a3c7e3153d6d05bcb8348a13398908e192590b8812f5c5ff09c133a -a0713983a3dc9f10b3833687cd2575de2fc63c4ad8d2f54ff85c6db23dd308daefef1bd1e51eec26732f77c1f37ba793 -8249a1d53ec92f311f4fa77e777800d777f3e9d4d452df740fc767fa7b0f36c8dce603d6e6e25f464c0399b8d0b93c30 -a73d0a206a62922f07b928501940d415e5a95716ee23bf6625b01ff2cd303f777adfa373d70279ba8a30fbb4c99a6f1f -b1106b407ecf234e73b95ff58ac9fdf6709ad2e763b58f0aacc5d41790226d441b5d41405ac03a0641f577848a4f5e8e -b009963ccc7b2d42792f09ab7cb0e929503dd1438f33b953104b4de43274ca3ce051554d10d7b37041b6f47d7a2dab6f -b744512a1b3c7ef9180b095c6a0c5bc16086a50020cf20dc2216bbff24d91ca99b95cb73070444dafc3ab45c3598960d -a0209669ffeddc074d35cc6aa2dac53acac8e870f8a8a5118e734482245b70c3175f760652e792118fdddac028642259 -8ddd3e0d313da17292fdcc1bbc6e9d81189bb1d768411c6fe99801975eddb48dbf76699dcf785cac20ab2d48e392c8fd -8392aa285b8b734aa7a6e0f5a1850b631ddf6315922e39314916e627e7078065d705ff63adbc85e281d214ec7567863e -b655a1fff4dba544a068bf944e9de35eaaa6c9a0672d193c23926776c82bebed8aa6c07c074b352882136b17abdab04b -af5095f40d1e345b3d37bebee3eb48c5d7b0547f12c030d5bfe8c0285943e0a7a53a186f33f791decba6a416cba0c5c9 -8223527f9eb3c8ff52708613cd2ee47e64c0da039cea3a0189b211dc25e9bfa3d5367a137f024abe94f98722e5c14b67 -afdb106d279273edc1ee43b4eead697f73cb0d291388f7e3fc70f0dd06513e20cc88b32056567dcc9d05364cb9ca8c58 -9319eac79ff22a2d538dcd451d69bca8aa8e639979b0d1b60d494809dbd184a60e92ad03b889037a1ac29a5547423070 -b79191ce22dbd356044e1777b6373b2d9d55d02b2cc23167642bc26d5f29fd9e2fb67dce5bd5cf81a602c3243bedd55c -988e0da1e96188ffd7c5460ecdf2321f07bc539d61c74a3292c34cb8c56dbafbca23eb4471a61e8e64e9a771a49fd967 -b0792b6cf4b10f8af89d3401c91c9833736616bb9fe1367b5f561c09d8911fb5a43b7a4fd808927b33ab06e82dd37a28 -862f68ea55206023ca470dbd08b69f0f785fcbabb575a1306ff3453c98ffcad5fd6ead42e8a1f9edf14c6fd165ffd63a -815ff0898b1330ac70610180c0f909561877888ff10def749a1e65edf9f4f7cea710a757c85241dfb13d0031efb5e54b -aa6e6ce21776ea4507d452ccdaf43a161a63687aae1cb009d340c9200e5646e9c2de4104dfd66b8e55dfa6de6ee83e4a -8e8f3d3403e0256ecc254b9b1464edca199cad3f3348002d744721c345a1a3c7f257c3587d2229774cd395e26693d1ba -90483e28985e4a0f7a3cb4bc5e865b9d408b94cd2146c04aed00b48a7ab80a28deb05efec320817d63578d4f953bd137 -84fb2a762ba29193b07f1dd84b3f69153cedb679b66ad04f8a4adf01c14f115163a107e6db23aaf0f0c9687824ded197 -b4a23922bf4302cc9a6583f252a1afa026c87c132b9ae44cc1f75a972cb6ae473447c500827906f9b677617ddd6fb473 -809bb9edbbe3a2769165f029f2a48b6e10e833eb55d8f9107c4a09ca71f0986dc28f3bf4ead9cab498086eb54c626bbf -a0459dbb08db4155d16301933ec03df77c4f835db2aa3f9697eeb2bb6fcd03337fab45fa43372a469fecc9a8be2e3119 -a638eaace7f21854de49f4db6e4ea83d2983751645e0fb200c5e56561f599fd37dac70bdbd36566fdd10d4114fbb9c2f -a3a27bc2728390643a524521bf8ef3b6437cfba6febfd8bb54f2b6ecbafafb96196d3dea279ce782efd97b212f364ef5 -b86693b3ea23ea6b2c4d52554f61ef39c0ef57e514ff6da80c6e54395df8376e2e96b9d50e4ec301c59e022c5c5610db -af4d7cd678d79e67ae19789d43331dff99346cd18efff7bab68f6170c111598d32837372e3afe3e881fd1e984648483e -b8735a555ba7fe294e7adc471145276b6525de31cda8c75aae39182915129025fb572ed10c51392e93c114f3a71bd0be -b1dfb6dbda4e0faaa90fe0154f4ddaf68ee7da19b03daad1356a8550fca78a7354a58e00adeecb364e2fd475f8242c24 -9044b73c1bd19cd8bb46d778214d047f5dd89b99b42466431b661279220af5c50c0cffecebd2b64c3d0847a9c7a8b1ec -891f0d162651a0aa0d68fb1cc39fa8d77fd9f41ff98b5d6c056c969c4bac05ba8c52cbfa7fbb6ef9adfe44543a6ec416 -8920ae1d5ac05bf4be6aba843e9fc1bc5b109817381cdd9aa13df53cabea319a34ee122dcb32086d880b20900ff28239 -abb14023142876cbc9301336dced18c7878daa830070b5515ff4ac87b7bf358aa7ff129ebbf6fb78e827570a4142661f -a74b15e178cf91cde56eab0332e62d5ff84c05fcc849b86f45f94d7978bf9c0fc72a04f24d092a9d795ca3d976467f46 -806829621a908ca9b6433f04557a305814a95d91c13152dca221e4c56bfaa3473d8bb1bacd66e5095a53070f85954278 -b09a3c185e93869aa266a0593456a5d70587712bca81983dbc9eebbb0bd4b9108a38ae1643020ecf60c39c55bb3ac062 -b2bbe8f5361a3ecdb19598dd02e85a4c4c87e009f66fee980b4819a75d61f0a5c5e0bdc882830606cb89554ef1f90ead -825e16cb54fc2e378187aedae84a037e32903467ac022deb302cf4142da3eda3ead5b9f3e188d44f004824a3b5d94fbe -8b39d4a11d9b8ba885d36bcdb6446b41da12cfd66cb22705be05ab86936464716954360cc403f8a0fd3db6d8b301cb59 -ac19d453106c9121b856c4b327ddb3e3112b3af04793df13f02d760842b93d1b1fbdff5734edc38e53103a6e429a1d1f -b1cacbb965ec563f9e07d669ffc5e84d4149f1fb9fcfbc505788c073578c8f67956fb8f603e0b9a9d65e2d41803038ce -b7612d9e7dc930bff29191d1503feb2d6451b368b69fa8ecb06353c959967daccdc262a963f01c7fb95496f1bd50d92e -93f8fceb65ea9ef2052fa8113fb6720c94f0fed3432d89014ee5ad16260aeb428aadea0d1f1e002d2f670612ba565da3 -b3eb9213752156ed1fced3bca151fd0c630554215c808b9a0938b55fed42b6b89f9b76bc698f3e37c3c348d2395dbed1 -b46ab3553ef172ae40fc21c51d1d7eab8599a67f2f89a32a971aa52c2f031664e268b976dd2f7dc2195458fcf4bf3860 -8fb66f2c67ca5b6fb371c7d04592385a15df0c343857ba8037fe2aa9f2a5d4abc1058323ff9652653261b1c7db0edc24 -a7dfdbbf0b14e4af70fdb017875cdc36ad2108f90deb30bfca49301c92cbf821645a00ade1d1ee59a1a55a346675c904 -856199cad25ec80ee0327869077f272e33d59bf2af66c972e4a5839ec3b2a689e16f7fd0a03a3138bec458fcff8edbea -a2842ac5a715c2f48394988c6f84a6644c567673806feaa575838e906138c1b25d699e1b6ffdfc9be850b15da34077e4 -814b448ada88f769de33054c3c19f988226317797acacdbe55ed2485b52cd259ac5bcbee13f9de057eee33930a7fa0c0 -b49de8dd90da916ed374ca42665464b6abe89ff4453168921f5a7e5ddd3dcfa69422782e389e586e531fd78a1f236a8b -851f9d942b4c8ffc020c02c7fbee0f65ef42b1ab210ab4668a3db6aa0f8ab9eedb16f6fd739a542cc7e3cc03172b565b -a5128c155b8062d7fa0117412f43a6fdc2de98fa5628e1f5fc1175de0fa49fc52d015ec0aff228f060628268359e299c -b0765849127cc4ce1a1668011556367d22ce46027aa3056f741c7869287abcaccf0da726a5781a03964a9ded1febf67d -984562c64f3338ffe82f840c6a98a3dc958113f7ed28ee085af6890bbc0cd025723543a126df86f379e9c4771bb69c17 -8087fe60a9a22a4333f6fbe7d070b372c428d8c5df3804bb874b6035e5602c0693757fb30a9cd5a86684b5bca6737106 -a15e195b5850f7d45674cdc3bd74f972768b46fe9473182498263edc401745a8716fc532df8fc8c1375e39e391019226 -858ec10208c14a67c4156ea9c147f36d36c4fa0a232195b647e976ba82c8e16262b2b68d31e3b4702070c3dc701bccb5 -84bf3fb83c003380ee1158e2d6b1dca75cd14c7b2a32aec89d901f0d79e1475aa0827cb07cba1784a6bb0d37f6ca5cd4 -91e69f5392648e7f7c698059a0fc4b8478ab8af166d3842fb382ec5c396daa082ee3b2cb0192da3c9d90f6523c4c039d -8f7299f451c5e641d6fd961946b7a6ba4755685b2a40164e6276c25aefc66715b92492097a191813d39bb4405dc5da36 -ade2cf04ff6c94c1019bfa1e0e8f580696230fa6ee9695c4772e5a44501b2fffdd765ec7cc71ba14b83559ad62cc0fc5 -85fc98ecf469d6f98c8b3e441680816f764de39001a249bc7162f990c5a5354683e849164d4fc9287ee516780cdcd436 -928d118188120d038c37abdbe66c05adaa87f1cf9957dee2783b09fa91c4c43a7b0d0b2b6c5f4dea57e3ec8af230e84f -8025f71cf8d3085d6ea5104dddea8fa66cdb8527e40db01472469be021632daf22721f4acf1a8698a53439fe2f82596c -83266fffb12b3c795a6b551ac2aa7d9a29c183f861e78768c11286a04e22bd423bba05a68775bd77273e3ca316a4318e -95fd0c69c2d9df4e795c7ba71ed71a9d9f2878cd7e3a64be7b671d9611649fd41d29f8bdab642ba19cbd3db660d6a7e7 -92a912cb4d5ef4b639876daf4289500c4ebdbd80aff07fd93dc3eea645f084f910e5c02c10492a37f16acaa7e646d073 -b3d2622c987189a0873932aaea8b92ebb6e9e67ff46e91a96bf733c3b84175fffe950f8f4622cc4fa50f116321c5537f -a98f9a40054b31023a8f7549a44cae853b379bbfe673c815b8726e43ecd11a96db40b20369d712cbf72ffab064ecfac5 -b4e9a38e371fc21f4b8a3d7ad173c9ffad0554530dc053365d9555ddb60f5c9063c72ff4c65d78b091af631a9e1ee430 -875a31aee4ba19e09f8c2754fab0b5530ec283c7861a4858b239a12432f09ef155a35fedb0bc33eac2117c7e62f1c7ee -95edd0d1a6e94af718590756b5c5f5492f1c3441ecc7fa22f4e37f4ec256b9fffd2fda4c11fc1a7c220daee096eb1ff8 -b35fdc435adc73e15c5aaf4e2eea795f9e590d3e3ee4066cafa9c489ee5917466c2a4c897a186b2d27b848c8a65fa8a8 -94a5ce56f8d72ec4d0f480cb8f03e52b22f7d43f949a4b50d4a688a928ffd2c9074ecbab37733c0c30759204a54f9a6a -987562d78ef42228c56074193f80de1b5a9ed625dd7c4c7df3bf5096e7d7b08e2ee864bd12d2ea563e24fa20ad4d30ef -95a8218405038c991ace2f45980dbb1efa9e4ad0d8153486b0213a89e4d7e3cac6d607100660784627c74f90a8e55482 -b6a29d566f5a924355b7f7912f55140e1b5f99f983c614b8a92814ce261f2750e8db178866651ea3b461fb8f92890b14 -afdacc0a13da0446a92455f57a42b3ba27ba707f24171727aa974d05143fae219de9e2eb7c857235dd9c7568f43be5a8 -862a7dc25f7cfa4a09aeca0ed2c9c5ee66189e119e226720b19344e231981504e37bca179aa7cad238ee3ab1386aa722 -a336364e76635f188e544613a47a85978073f1686e4ee7a8987f54da91c4193540ac448b91d07d1fc5c7a8538b1f1688 -8f1ddca9638decd8247c1ce49c1e6cf494d03d91c4f33e48a84452d12b6736e8bd18c157068dfeff3a90977af19e5b1e -96ae91b9aaf00e437c18ddfc1aef2113ee278153ba090aedeb3f48f1e66feb8897bb1ac7f5ffeffc3be29376dd51e498 -8230b5bd9067efb6089e50213f1cc84da892e6faf0b79d5e4768c29303a80b1b754cb09d17a21933aba4c5f32070878a -a79dfe217faec7b4d3cf97d8363949efbc6f3d2c6bbc25df2c7bb8b7fd2521e6d3fa76672bfc06de6f426290d0b3cc45 -8290bd36552609d6b3ac9ccb57ff8668fc8290548eecdcee9a231f1125298c20bd8e60f033214dfbd42cd3c8642c699b -8945db9e8ec437c5145add028d25936ee8823ceb300a959402d262232ae0cbd9a64c1f0a1be6aed15ff152202ea9a70c -949e232b48adeaf57bd38eacb035267d3e78333c6b4524cab86651a428a730baf9c27ff42cb172526d925de863132e82 -98917e7a5073a9c93a526399bb74af71c76958a74619caccf47949f8fd25962810a19e399b4efcba0c550c371bea3676 -b5b144e0707aefc853ea5570bd78dedc4e690cf29edc9413080f28335ac78022139bfe7f7d6986eb1f76872bb91e82ad -949945072a08de6fd5838e9d2c3dc3200d048b5d21183020240fa13e71a1a8d30e6bfee4e6895e91d87b92f1444d0589 -b351a03c7c98506ee92d7fb9476065839baa8ed8ac1dc250f5a095c0d4c8abcfab62690d29d001f0862672da29721f16 -a82d81c136bc5e418d1fba614cb40a11f39dc526e66a8b1d7609f42fea4c02b63196315014400084f31f62c24b177cbd -87d51c907fdcdf528d01291b28adfee1e5b6221c6da68fd92ab66126247cd8086a6bcffff0ea17e7b57b0ba8d01bb95d -a2a9a1a91dfd918f36c1bfeeca705ea8e926ee012f8c18d633e50ec6e50f68f3380ef2ee839e5a43cf80fbb75bfb5304 -86f22616caed13c9e9cd5568175b6b0a6a463f9a15c301b8766feca593efa6e5ee4c7066e1cd61b407c0be12b3d8236a -b57e0a2c42790d2fd0207ef6476a433fca0cf213d70840c4af1ad45833f23fca082d21a484f78af447a19a0b068ea55c -8ae9bda5d85e6e3600dde26379b7270abd088678098506b72196ac8f9ce5b0173bc9c7ff245c95cbab5b5b967bcb043b -95c7d11f6c874f59ba632b63ce07a7a9d917a74d0b89cefa043f52aa1a7fe2e81c38dea0b20378264b5b4f64039932bc -ac7dee7479f50722526ea1c9d4e2f1a4578d1b5cce2092a07722069c96bb4da295de1c4f16e21005276e3b3f1624ac5a -89b8aaa49bd18b09f78fc5a1f3dd85d69b5dfcff28fc6d5a92b1520bc54107b8b71bb71fd6e0bde10e0a5809c633e5d2 -8982cb43fe4d3488c55e8c08b935e6c8d31bb57e4f2aeb76d6319470cce99ebf7dc2f116ac15b9d845ab1bc16aa6a583 -a12c63f48e27b1a1c83a32992642f37fb5b89851a35e80f6d1f9bc483cb25acd0e12b1dcf68781ae0cc861f002368bcb -aa6da92a4b4fa229afc8007abca257ce0ff5fad3b1ccfe5d836b9b52ff6b72575a0b915a759403b993733b16a47fdb15 -8bf706a92fe54f15d633b9463926b874dd43e28aaeca3fe2353fb58ad7753c8a293c56b0e94176070e8a9ec7401073a1 -b81e86de4bb5c1046e40cca79585c5b98c8673626fd3a28e563c5a3296256c2f7086522ae95cbabfaa8f1a8f7eae6272 -ad10f895b05d35cb251f78cc042d3f0969a8b6b3f289ddb4b016e0b8e06bfffc3a3e1afa9b0cc548f8c092832bb766bc -ad993aceb68d5217cfb07f862956cde83d05dec5060fc7a8fbfd37c6bfd5429ba69bdaf478b6cd01c323a06793dcd9fa -83da9c9a8fcb2775df0777aceabe90642a2df1c6abc646566e954f42d6e43455b00b101ec5ef58850c8d4b3100222ca1 -b55484f339fe7c7d107e70432601f4a34e1cc02ae4de5d18b99e5aa995f7b3710fc745769b85c1af803d457491dd8ce3 -8009d80593e82f3e751cec9e7e495fd29ad6f45f8d3ae513bec998b43c49fed74c44229c6f27c421e80c65413b897644 -9868081bbcc71192f7ff8dcf99a91dcd40f96556fbd6f285bdbfdfc785f604d8bf75c368c59db5ac8cdcc663087db53a -a04b1e91af025b4387ee0a2d790a1afb842e46f4c3717e355578efd1f84fea78782c6f7944b4961268de7f1ac71fb92b -a7b6301ddb9738b89b28a36d29d5323264a78d93d369f57ddab4cea399c36018a1fcc2cc1bfadf956a775124ae2925bd -a6cdb469014b33c590a07a728ce48f15f17c027eb92055e1858a1f9805c8deb58491a471aaa765de86a6bda62a18aef4 -828a23280ec67384a8846376378896037bd0cb5a6927ff9422fca266ee10a6fde5b95d963a4acfa92efbb0309cdb17b4 -b498ec16bcdb50091647ae02d199d70c783d7c91348a1354661b1c42bc1266e5a5309b542ef5fdf5281d426819a671cb -806533fb603e78b63598ff390375eebe5b68380640f5e020e89a5430037db2e519ab8ae5d0d0ad3fa041921c098448e1 -9104ad119681c54cdee19f0db92ebfe1da2fa6bef4177f5a383df84512d1b0af5cbe7baf6a93ad4b89138cd51c7c5838 -ac695cde30d021d9f4f295109890c4013f7e213d2150c9d5c85a36d4abfdca4cdc88faee9891e927a82fc204b988dcd9 -a311c244df546d5dc76eccb91fe4c47055fc9d222d310b974d4c067923a29e7a7f6d5a88bfef72fd6d317471f80d5c82 -89e4518335240479ad041a0915fc4f1afaab660bd4033c5d09c6707f0cc963eb2e6872cabc4a02169893943be7f847d4 -a8ad395b784c83aacf133de50d6b23bd63b4f245bb9e180c11f568faca4c897f8dbda73335ef0f80a8cb548a0c3c48fc -93e02b6052719f607dacd3a088274f65596bd0d09920b61ab5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7e024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02b4510b647ae3d1770bac0326a805bbefd48056c8c121bdb8 -99aca9fb2f7760cecb892bf7262c176b334824f5727f680bba701a33e322cb6667531410dfc7c8e4321a3f0ea8af48cb1436638a2093123f046f0f504cc2a864825542873edbbc5d7ed17af125a4f2cf6433c6f4f61b81173726981dd989761d -88e2e982982bf8231e747e9dfcd14c05bd02623d1332734d2af26246c6869fb56ee6c994843f593178a040495ba61f4a083b0e18110b1d9f5224783d8f9a895e8ee744e87929430e9ba96bd29251cbf61240b256d1525600f3d562894d93d659 -a2d33775e3d9e6af0d1b27d389e6c021a578e617a3d6627686db6288d4b3dffd7a847a00f7ef01828b7f42885b660e4204923402aca18fbae74ccd4e9c50dd8c2281b38dc09c022342ed1ac695d53f7081cb21f05fdfc0a3508c04759196fcd3 -af565445d2ad54c83a75c40e8895f5ad7219a8c728bce9d58d7a83716e095432993ebbd3f6911c66415a6f920d1a4d171478509b54a114308a020b33bf4487a7a8d0aa76ae4676a9b54e765a680f562d3a4fcb2e92c58b14b49b5b2917cc258f -8aa99cfaf514cef4801599cadd780d222194ca1ad69a34779c2bcfda93e5dbeb931e13914421b5809a6c81f12cf7038b04a35257cc9e94c33761e68565b1274aa6a6f9d66477229747a66b308b138f92aa4326a3bf23df65a1fe33b3b289bfe1 -99ba36d8b4f56bde026099278548b1afc0a987cbd7c9baa51fc8e6cbb8237a17636f1a44a385cec69b05a5802059956a11fe793cabb939c38800f9c239ca2518e898ade1ec2513c9ee492071a35aabd78182392a09123d28dbc233313c9120c4 -a7dc40c36afccb30a2eaff250860b28b227c195cf05674704c567d77d6655c446ae835f8fc8667e71147ab02afcb2dad0babe60cbfa37d7c2cddc68d2dec54f28a4142f8353590a3902d5ddaa22066ab563dd1435dda83f276387b9767d69120 -939e6cc97a8b88572852a5b7f25e4838556307f60aeafb5d2b6961edbcafd4b48cb6ac980ffbacf4be963f324ba81e3d12de4f1459d8c746d0762c66ae1b166027f7fbe641d9c48f3c7d97b06d956b0be51dcc9aab65f3e99e1388e63bdd79f9 -b391e156541dfd4003d1697cdb7ec815b309807320574906b2e652ef0175828b356d215cd374b1b34d9f470b3fa0e643113e67b2273268f922f04f072cfb89008358185b25cd631f82911a3f20f90f75758ffb99bebb8076458ae1e9d1ae898c -b9ac9c84934cc2a85c876eff65577e1dfce1935cd6392c877dd881a7d2f5c3e9344f28c04f90c62a6db4237ca00f9e0d00cb5f63e3f060fc7303916e19273b6fe455f331cabbe2fe5a22d584484f0d4176120fec9819fbb0a01e6d38695acfcd -88209eb030c5d78734bf2c2a5c539653fd3c24b4c08e624f9ddc4a6550efbdc1054a56eb0c807595aad6de56fda326aa196d032a8b4b48d40140a2d77df3c7243eda6507936389a321a5811eb38e32ee433c788deeae1eb928b00940e2944bcc -a8632ddc9cf7cbc1e8b74a05b7d4a89618c64afe30367ca0c9550ae7d320bf4e51c5a69e1501a1d8bee4240d13d7835501aa39fdc401a74f4d5734e268a7ce29a1fcfdb0a8bc64e0dd4a9e8578d6985bc2bc6a3764ce7a3703f6fb2e52557a2b -a037ac67e8bb6f4193ac967e05d080a489f58ef8d3d30a89798246f3e4936121ee445b03e410a09e8ebc0db2e2477d110aad0ade99b0887f1eb016e750f42135866907f150bd6f4f99a8cb94281474166874808ebe03b118c5daab16dafdc38b -a50d9143116bffa3b237da8e1805327e81e9cd25e658289bd727d5f9e0020172cc8690dcfe31a240e5cbc48353b88c4908baa1dd7320165556e0aa633f62fcbe7870222d345a3bbcdb7ab6c07f0fd86be559964afabf56f0a8cbc0b4b91d477e -afa988ea6fa4f40c5ad07d2d580d29025ddf56d6ef1171a8b8de3464203f70b97d6f5ace72747345204b35150e06154d1477516a989ce8eea7871cc0d0de00a077c0fb23ad4837e409d0b885bf3f2dde11a30fa6273d662e68e09f461e52932f -97fa1a943ed8b81574304a3d03f4f15907f6e6e0cd36a66bd2ad2c75afafc70a61d3ff69b77ebe4dae9ca0fcedef80081062705e60bbb6ea0f1f398c84d2f8e4a3ac142ac66426c21ad5e9994ebbcc406af474c4aec5e32fadcb21875af7c9f1 -b30a564614493886f14a5dd71c89457504f8c59a7ac01b665ed167e9a8f9ee5832198fd319ecd234196ee57031bdf3840bd5a923e203a1938bc795c704b5285389750e1fd10d7050061ba19db00a60a2c0384a7d661d7d48ebe6962272230859 -84c8dea942cfae71cb02e705ec496d967425793ce8812e7ee53c2f23713abeaff566a658cd1c73dfd18187d16253a6ee0a623e82cd18e31cd1a1875d19c078835dc9292e141686150a88065226ada264740143e87c03a0f6c4da8c187438ebf4 -8c3abae8aed60338f8c4ff80aab22f8a2ae56756a93566c906f490a97151d34a1c3318054e1c494c60cc53327ad86a2d02c6c76a406726ce4f88635bc32eff0db0b61762dc518b95fa8da82e87e4bf3de54f1d72180ef53ed7bc5413e6a9a510 -a328230c92a6b1cef6a444bcb64edb992f71e3d7b93f0b6b8b408ba7c908db746d92ddb2c7588bab438ef3bc61be1c2f0dfc86ba2ff514b42b35c80f89b2e780f813ea1dfb977fbded2cd9b553b747fa952e227ebd8f071163d421fc337f04c9 -b482cab423cd5f1c5df036070aade7aa016283d69619d664025c3feab866a0a5691d344b2ee2bedc5dedd1f9a73eae16003a3827c9e5bbe22ded32d848fba840ffad1141ad158f5c40bc8ae0d03781b9705d851a7f1391b096c576c0f4f2a6b0 -919ee1df27fabcb21237a1b7b98f53d41d849e1b6a8f9e28c3fae2841c6b5a250e4041c737e6725476e5cd715e34d3880f58d80f61efaabc261bdc703e8750f48a923e9bf8980931b9fd9e40014c66c54b3e7c98241d76d1aa47af43313a65a1 -ac94830145dbe9a8f7e6e0fc1f5fb454502d22abcafdc2dd96c6933c604461fa83b2b37385f4bc454875a02a6d4157841250956783515d11c7456e7f11b745f12856d89f5feedaf6a61a483a6c33a21cd2ba0c18eb41a1a2e7fc33bb53e4c570 -b209c699f1233735c5bb4bce848e4365fd76651ae2184d2279a90df0c2f69ffa2a24d84a9b9f274021072953c0d65e1a0202d490d6c37186af240114e445d87bff754b4824937e4f2c90a574061b1c4910fed88d90f698025a2a264e656cb8a4 -93320dc0576b0d069de63c40e5582b4486d9adf5e69e77e3ebaf3da26976fe42147a65051501bc8383f99e7ba75479c70a6726c2cd08bf98c7481f1f819712292d833a879f21a1221a9610bc748fb5e911055122fdb4055cdc84e8bfe0f4df9b -a4380b240e998cdf668591f71a0c88ed143b0185a920787627ce65095f8223dc606fa5bce93377af100de92d663e675c0736d7f1973603a84a5c4162fb5e01c88c7493503ae1d7e9fbe8ece9b418397d68c21eeb88dae226e09875d372c646dd -aab48517d69135a16b36b685adfe9b2544a709135a21ba3e75981a2cba4ec81d1fe28ac0f72fde0c0001c15300ed6a810f58d3117bdd58d0149751d6508cf8a1a1ff7b63dd02d2730a9d6fe96c77c502fe8ed46d50a181ec4bb35e37dfbd6af4 -8277265fe75ab89ce4ec65b33fb4084bec0a56d81faf2f7a9070d2ca3065678e03a790350eba56323a54e0285bc32fe8007d5259740fde226e16cbde8354eacd562294eb9b7f727ed72ffbdad86f467cf057c737b34b80a41deb92634ed866f5 -aa40a24cb2ebe606d969392c03020070f044c95088d80f57f771b837c048342d2cd3474600d7660441090ffb8d2ffb7f0eddd67eb378e3e1477a6ba0bc38096d5d2d3355bc8b60f605f57f0c1899da591457440352381d2b38c0aa9acc7fe419 -80815d10685808cb630820629bcd2fa9041c9b74433630c0b9c1b7f7e8edf1440b520217f76ec9a50c125cf4438aa66006a1928a9ed2321da7ea325c3d56b65462b72118ca2c99a0ea733aa11da9abbeda6cc71ffeed301ae70213a29e697dcd -ac235d079f91b00b1fead7523da8f73a5409fa8970907af0c5d5e4c6a0996dccfcdb0d822d08c7fbc0c24799457d011d04312d20831825f23cf988141056a6814c8a1cac9efe37bdcbfa272aed24cd92810fea7c49b0d07683a5c53643872179 -b8aa59534d75fa5ac1c2c3f963bf73899aff5210059dbde8a8635561c6249e5143affee3bd2fd57575213b52d9a73d5702525867a7dcbb1d0a49b98c2925556fc5463ff0209742046a24ab29e74257d6419401093cc4371944d811cc300b6a67 -80bbfc5b816eea29a6d84e2217dee4d547306994d39e5592515e1b0807b67fe960d1d5addb0ff1a20c158bdb294c04bf093d28996121845a2c9268e2c9ac0f4067e889c6aaca62f8535d35b45036954bd069e3afa84f04721538c26003304c20 -a535c17d0e151d0e03d42dd58ba8c715bee3fabca2890e0e016071d34184b6b34e770d2be29c8ec76b69bcc471d50f4d043c2c240e9b93a81cff7ee2724e02018dfd9b534e40be641fdb4884abcd83b76f517557ffba508f1ba2f56313f4de94 -b237eb7465df0d325a3aa58269be2627e4978f9863f4f100ed4c303cb1f6549e606f2e3c9180824d8049191965c8dacd0a0c76cc56cb22cf1bcfdb39372c8aa29b4f7b34582b1719e6bd59c930d87d5ccd838743b585d6e229d5ed42337315c0 -805c335a2a9d2de30809cf30808ef836d88e9453c510716f01696f14c72dd60505eca8f128970edc8e63a9aa1f8792ac0dd50dcc84fbf4cc8b32349c682a6a27bc7551c7aa273a94c1606d07710188d93579afe3be1781bded15a34ed6047922 -b25dadf385ddd3c39bcb0a014d3d4f66127946b1aceae8809e3a03d66cc25e27142ca108316391f857fe82fdea4db2520cc73793b695eafbf3ade00ef7ec747b0457e49303f5e1a370f5263b436566fe24a0876e5fe088238c7be37a0718d65f -b0f753081cabe2c8fce73aba82ff67dbc9842598b3e7fa3ce2a1f534536f8ac63c532fe66552ac6b7adb28c73ed4c8a4184849be7c1756a4681ce29ebf5e1c3aa806b667ee6bd68f6397aba3215dc1caec6742f21d681e32cd1160d6a3b1d7ee -b798771eeb3d7a17c62ba5916cc034bba870da6b1ac14c2e1cae71af3ad4e0c0d1ff983f691e0e55289d5a33b131f2ec12430c9566dd71f4d8be9c79155357a5c30c5efcfd75bbe1bb6d5ada4d50604ea49ed838d3641f268ca6e25c9c4b6b72 -b52554c017388b099804abbe565346591a086d9979e10140ddaccc0a3680e506db775d7cbeafde67563adf0f09f5c2420caf19629f4e8f03e6fe02e9416ecd5269989e482b90004a083967d1141387eb74865bac6bd17e7a6d5f58225e52d4b7 -b520ff694520919023d44d53f98a7de2f78ff37b2d9193dcaa35556a6a0febf767781a4c961dce7c804bfdf81935f8f0082865253da52e79dfa1c5ff74d61495b2da76e167d46114709e877a7791a3a95e33a42f56b83f5f5afe271c67ae997c -b721401983440797a03d5b99f2088a0b249aa911969c34dd6c615b0060325da555d2ad99d931170c0868b0488a2234a4114cc0013d5163b833f5c45c5eb536421c016cf85788390176bb2dc4c196d6be26bbbfceae048b82f0d8039222e71c94 -acd9d833ba0a8cbd8d1ba939a11ea0fa5607e1bc6e693ec318bdb097aedd042d76e695dcebebd142e2e4ac30b1905dff03ec36d9cc70577e4dbe5e9ed7c20c7afb13a7f0155f203c6b83b9f1ad3d20a0d4aef0fbbbcf466ffc1bcd482bc2f5e0 -8cc1795de015f2b0e72116f169f3b4624b7738ceebea354e0bd9051c27b86f647ea36cad57ea6884c1a8adf9b45cd83514fa687e68878bbd613d793aa10986d5a0411f081689229e0d72133b3667b9f3f1a02211d0e680564eb1ea43393e1f36 -aa9281c61113c343a108de1036570feefc72fb7a96ff11f73024de12b83f29631f5a8a5900e6f10b15227c6f7462881511271bf785ebdf95ce288100e5dab391f664f6ff76c72b65b34479a4f43e5e8eba292209d6654157286ad3242ac342db -aaf16866275082e59d415db317aa874267d048ee405a553e852e6d175711d31a1fee99912345915bce121f43bc3e00d81338e5fcd3c8a1012fb4f172a9fe15622dd368b4d9d5cb60d189f423b071791fe26cea7676aca8df07965cacf80b0cd0 -accc80b3d8a6ffa648487a3d3c0ce1aeeb5401edf3cf2e385ea4a6d5fc110054fcce38f01f1da7141bbed30eb7a0a6810c82212bbb9da75d6033082dbcf6bc6a5791f85aa0f045a10da5de015edbf369b4d23b32b0c058962d2ee88e6911f994 -83f1089395a16077738cc7c9a6d6a3dc9033aac4abc508af5a1f007ca92e1a80b2e6f2dbda7fdcf0d5646de790a6201d0a9cfbcb6620a1426600e3a6a425ec004384f49fb9dcd166691a47177d45dcbcb761a11d46220b0aa09fc946131f7aa5 -9246bb586d43cb817c2e15ed609156e9f1cd284ba2f4797bbfa51c0341e1ba382eaac059aa9f63fb88d228a1a932839a171e7c7d00199dc7c4d6c5ea038a02cbc3cc5297c70401520e70ebbcffacd6a703f62896f3c788f94dde3c33ab0ecbdb -a316cb7c74feb0563c56cc79015e2774fbeca458bf8e9fb07894f9d6bcd73f7fb9428e87c816e5629e4bf7f3ec567fbc091549471b75492dde08217cb334b716b4582b24384586e53388873a78a90ec01bd7c3bace9cfc52161467df16e27c33 -ade18c74bbe60d1d69f4a570f8e5fd8696c26cc9e02829040b6b14cb9c49a4b3263b5bd5e16ec0b29010b4be054c16ab09304e23442af7d7f5fcc60bc6c5634ab6e4aed7ef334b2785e4c7672d59a687278e42d310342db5e5975d716e6d1595 -b7728800bb2039acf228fa3d8028569c426cb85d28b2b5820bbef938d5ca8c4df981d3e01a309e26ca101e8295d0f6990c03b8c239798323575874a4ee5bfe46cfe99b9657189142aacd8f8d1f26cf4c0e73c6397c31ba8f18102b9ea315b638 -8fb14f2a9be193f54977ecd3021663108ea143627b9a9d9faff85d1a86b855f6c437eab435fad3304f245bd7732af07f1173494cdb802fb96e85d2db89e1643206e183f3b228ca8d3f586e71aa9308eaf0223100bf07942fc39e465016d1f775 -ac1e025e53d98fdb3380489dce82d9d4bd3a6c98f0a523b841cb09a6f26ddd4d22efd98776e78d10fd996995fd00e81e08d3c25dd14a54b25a9d483677a24bbb8d1cb41a443b2c71038e6893b1b30f70758424e0f2039a48060191389033ef55 -a4c017311b9e930868132527a9849072b91db04fd36c619ae39c98da9e2174e6201d3c2ff1246c06b1b6815bbf3ea4a1116564f55ee2fe4c4d655e2294c0ded842cba209c255ca3d7b7f82d162f97890dfdeed087aa2f87cbfc61d61815da39d -89516315a3956b455843c2555248bd94dcb19993060fe75fdd51f7aa9c9147ab13997d8a98036a8f04bee5c91d78d2990907e35a52537a8ab3ed15f1a71afdcd38044a5b6e93f662b9d36c16933a881927cacae668c4c06ee6f004c9e3989bad -a1e78a011e210400c68ca76045f7da74119bff3cbe382efd2bd2ac76567c52d68d75536a91999d084043e1ce2d07d02e0b69fb99924101d2543521747536fbc51b0454aa9a4cbbec101121f597863a5c0fee2ca5eab35dff9b9085bef8b2b0d0 -830fd8d083e39153ecab43cabb22e29d7b44a55fba467af4ddd3f069439d2972ef53c3518de788f96b3f4f64963987d0155ba27afc28643af3de8e476ff515a68285728167408f45d99e574680bda6bacdd4322e587e4aa99386e035c0e931ad -b89584da22237e3061d991b1a55a5e55dc637b8b671130d304587729348138ef87885180310efe9f9f6d3580b9d7fdcf0649e8a79d2dec8c25a9f53df0fac5d517db999029cbfdd7c2cbd3e9a5503e5d267d3d8ad752335915c92b850b14bafb -959b8030733799882c5e3735479924b013756e57b893f9792bab4043e2d362d77cf308166d782e3989caa771b8a0c0a01302cb7b5e8ca12e2d6cebd59d4cd173c9dc25f438bac597fab17b4ff44997a489c168e7204b7d7c21d0938f0a2e3b51 -a0a9e5503d9afe0027891dab890c687fd5f5fac5741418490c64d7c15f59533dd603a50163c79402afa61bd02de486761983c94501da17e6bbe78c497f2122210071602f578adc0ebe7a4679f87fe77e09c8c122de69105f13455fea25f08e6f -9811487283ad620cd7c9b303ae2f348d0e6f5ee17b504baaa817ae207adb912a00d3cc36dbf48745eb899e6b6e22f09f0f9ba29d949ecd7350fbbfe87a8c7cdd5d0e687fc807751d07634aaf7c38baf3b24a0670c38fa6ccd7431436fc95525f -8a13aa5071c526e560def7d8583393942f07d88c9d8d26c98738fd65f57af2e3326dbb1edff0f39fe98eda4a13ed4fd71844254b954690154c4804e1c4a53df9dc4643f4b7b09d0860070f6b2318d0d63d28fb56bf5b6ff456a18dfc72fdfbbe +a0413c0dcafec6dbc9f47d66785cf1e8c981044f7d13cfe3e4fcbb71b5408dfde6312493cb3c1d30516cb3ca88c03654 +8b997fb25730d661918371bb41f2a6e899cac23f04fc5365800b75433c0a953250e15e7a98fb5ca5cc56a8cd34c20c57 +83302852db89424d5699f3f157e79e91dc1380f8d5895c5a772bb4ea3a5928e7c26c07db6775203ce33e62a114adaa99 +a759c48b7e4a685e735c01e5aa6ef9c248705001f470f9ad856cd87806983e917a8742a3bd5ee27db8d76080269b7c83 +967f8dc45ebc3be14c8705f43249a30ff48e96205fb02ae28daeab47b72eb3f45df0625928582aa1eb4368381c33e127 +a418eb1e9fb84cb32b370610f56f3cb470706a40ac5a47c411c464299c45c91f25b63ae3fcd623172aa0f273c0526c13 +8f44e3f0387293bc7931e978165abbaed08f53acd72a0a23ac85f6da0091196b886233bcee5b4a194db02f3d5a9b3f78 +97173434b336be73c89412a6d70d416e170ea355bf1956c32d464090b107c090ef2d4e1a467a5632fbc332eeb679bf2d +a24052ad8d55ad04bc5d951f78e14213435681594110fd18173482609d5019105b8045182d53ffce4fc29fc8810516c1 +b950768136b260277590b5bec3f56bbc2f7a8bc383d44ce8600e85bf8cf19f479898bcc999d96dfbd2001ede01d94949 +92ab8077871037bd3b57b95cbb9fb10eb11efde9191690dcac655356986fd02841d8fdb25396faa0feadfe3f50baf56d +a79b096dff98038ac30f91112dd14b78f8ad428268af36d20c292e2b3b6d9ed4fb28480bb04e465071cc67d05786b6d1 +b9ff71461328f370ce68bf591aa7fb13027044f42a575517f3319e2be4aa4843fa281e756d0aa5645428d6dfa857cef2 +8d765808c00b3543ff182e2d159c38ae174b12d1314da88ea08e13bd9d1c37184cb515e6bf6420531b5d41767987d7ce +b8c9a837d20c3b53e6f578e4a257bb7ef8fc43178614ec2a154915b267ad2be135981d01ed2ee1b5fbd9d9bb27f0800a +a9773d92cf23f65f98ef68f6cf95c72b53d0683af2f9bf886bb9036e4a38184b1131b26fd24397910b494fbef856f3aa +b41ebe38962d112da4a01bf101cb248d808fbd50aaf749fc7c151cf332032eb3e3bdbd716db899724b734d392f26c412 +90fbb030167fb47dcc13d604a726c0339418567c1d287d1d87423fa0cb92eec3455fbb46bcbe2e697144a2d3972142e4 +b11d298bd167464b35fb923520d14832bd9ed50ed841bf6d7618424fd6f3699190af21759e351b89142d355952149da1 +8bc36066f69dc89f7c4d1e58d67497675050c6aa002244cebd9fc957ec5e364c46bab4735ea3db02b73b3ca43c96e019 +ab7ab92c5d4d773068e485aa5831941ebd63db7118674ca38089635f3b4186833af2455a6fb9ed2b745df53b3ce96727 +af191ca3089892cb943cd97cf11a51f38e38bd9be50844a4e8da99f27e305e876f9ed4ab0628e8ae3939066b7d34a15f +a3204c1747feabc2c11339a542195e7cb6628fd3964f846e71e2e3f2d6bb379a5e51700682ea1844eba12756adb13216 +903a29883846b7c50c15968b20e30c471aeac07b872c40a4d19eb1a42da18b649d5bbfde4b4cf6225d215a461b0deb6d +8e6e9c15ffbf1e16e5865a5fef7ed751dc81957a9757b535cb38b649e1098cda25d42381dc4f776778573cdf90c3e6e0 +a8f6dd26100b512a8c96c52e00715c4b2cb9ac457f17aed8ffe1cf1ea524068fe5a1ddf218149845fc1417b789ecfc98 +a5b0ffc819451ea639cfd1c18cbc9365cc79368d3b2e736c0ae54eba2f0801e6eb0ee14a5f373f4a70ca463bdb696c09 +879f91ccd56a1b9736fbfd20d8747354da743fb121f0e308a0d298ff0d9344431890e41da66b5009af3f442c636b4f43 +81bf3a2d9755e206b515a508ac4d1109bf933c282a46a4ae4a1b4cb4a94e1d23642fad6bd452428845afa155742ade7e +8de778d4742f945df40004964e165592f9c6b1946263adcdd5a88b00244bda46c7bb49098c8eb6b3d97a0dd46148a8ca +b7a57b21d13121907ee28c5c1f80ee2e3e83a3135a8101e933cf57171209a96173ff5037f5af606e9fd6d066de6ed693 +b0877d1963fd9200414a38753dffd9f23a10eb3198912790d7eddbc9f6b477019d52ddd4ebdcb9f60818db076938a5a9 +88da2d7a6611bc16adc55fc1c377480c828aba4496c645e3efe0e1a67f333c05a0307f7f1d2df8ac013602c655c6e209 +95719eb02e8a9dede1a888c656a778b1c69b7716fbe3d1538fe8afd4a1bc972183c7d32aa7d6073376f7701df80116d8 +8e8a1ca971f2444b35af3376e85dccda3abb8e8e11d095d0a4c37628dfe5d3e043a377c3de68289ef142e4308e9941a0 +b720caaff02f6d798ac84c4f527203e823ff685869e3943c979e388e1c34c3f77f5c242c6daa7e3b30e511aab917b866 +86040d55809afeec10e315d1ad950d269d37cfee8c144cd8dd4126459e3b15a53b3e68df5981df3c2346d23c7b4baaf4 +82d8cabf13ab853db0377504f0aec00dba3a5cd3119787e8ad378ddf2c40b022ecfc67c642b7acc8c1e3dd03ab50993e +b8d873927936719d2484cd03a6687d65697e17dcf4f0d5aed6f5e4750f52ef2133d4645894e7ebfc4ef6ce6788d404c8 +b1235594dbb15b674a419ff2b2deb644ad2a93791ca05af402823f87114483d6aa1689b7a9bea0f547ad12fe270e4344 +a53fda86571b0651f5affb74312551a082fffc0385cfd24c1d779985b72a5b1cf7c78b42b4f7e51e77055f8e5e915b00 +b579adcfd9c6ef916a5a999e77a0cb21d378c4ea67e13b7c58709d5da23a56c2e54218691fc4ac39a4a3d74f88cc31f7 +ab79e584011713e8a2f583e483a91a0c2a40771b77d91475825b5acbea82db4262132901cb3e4a108c46d7c9ee217a4e +a0fe58ea9eb982d7654c8aaf9366230578fc1362f6faae0594f8b9e659bcb405dff4aac0c7888bbe07f614ecf0d800a6 +867e50e74281f28ecd4925560e2e7a6f8911b135557b688254623acce0dbc41e23ac3e706a184a45d54c586edc416eb0 +89f81b61adda20ea9d0b387a36d0ab073dc7c7cbff518501962038be19867042f11fcc7ff78096e5d3b68c6d8dc04d9b +a58ee91bb556d43cf01f1398c5811f76dc0f11efdd569eed9ef178b3b0715e122060ec8f945b4dbf6eebfa2b90af6fa6 +ac460be540f4c840def2eef19fc754a9af34608d107cbadb53334cf194cc91138d53b9538fcd0ec970b5d4aa455b224a +b09b91f929de52c09d48ca0893be6eb44e2f5210a6c394689dc1f7729d4be4e11d0474b178e80cea8c2ac0d081f0e811 +8d37a442a76b06a02a4e64c2504aea72c8b9b020ab7bcc94580fe2b9603c7c50d7b1e9d70d2a7daea19c68667e8f8c31 +a9838d4c4e3f3a0075a952cf7dd623307ec633fcc81a7cf9e52e66c31780de33dbb3d74c320dc7f0a4b72f7a49949515 +a44766b6251af458fe4f5f9ed1e02950f35703520b8656f09fc42d9a2d38a700c11a7c8a0436ac2e5e9f053d0bb8ff91 +ad78d9481c840f5202546bea0d13c776826feb8b1b7c72e83d99a947622f0bf38a4208551c4c41beb1270d7792075457 +b619ffa8733b470039451e224b777845021e8dc1125f247a4ff2476cc774657d0ff9c5279da841fc1236047de9d81c60 +af760b0a30a1d6af3bc5cd6686f396bd41779aeeb6e0d70a09349bd5da17ca2e7965afc5c8ec22744198fbe3f02fb331 +a0cc209abdb768b589fcb7b376b6e1cac07743288c95a1cf1a0354b47f0cf91fca78a75c1fcafa6f5926d6c379116608 +864add673c89c41c754eeb3cd8dcff5cdde1d739fce65c30e474a082bb5d813cba6412e61154ce88fdb6c12c5d9be35b +b091443b0ce279327dc37cb484e9a5b69b257a714ce21895d67539172f95ffa326903747b64a3649e99aea7bb10d03f7 +a8c452b8c4ca8e0a61942a8e08e28f17fb0ef4c5b018b4e6d1a64038280afa2bf1169202f05f14af24a06ca72f448ccd +a23c24721d18bc48d5dcf70effcbef89a7ae24e67158d70ae1d8169ee75d9a051d34b14e9cf06488bac324fe58549f26 +92a730e30eb5f3231feb85f6720489dbb1afd42c43f05a1610c6b3c67bb949ec8fde507e924498f4ffc646f7b07d9123 +8dbe5abf4031ec9ba6bb06d1a47dd1121fb9e03b652804069250967fd5e9577d0039e233441b7f837a7c9d67ba18c28e +aa456bcfef6a21bb88181482b279df260297b3778e84594ebddbdf337e85d9e3d46ca1d0b516622fb0b103df8ec519b7 +a3b31ae621bd210a2b767e0e6f22eb28fe3c4943498a7e91753225426168b9a26da0e02f1dc5264da53a5ad240d9f51b +aa8d66857127e6e71874ce2202923385a7d2818b84cb73a6c42d71afe70972a70c6bdd2aad1a6e8c5e4ca728382a8ea8 +ac7e8e7a82f439127a5e40558d90d17990f8229852d21c13d753c2e97facf077cf59582b603984c3dd3faebd80aff4f5 +93a8bcf4159f455d1baa73d2ef2450dcd4100420de84169bbe28b8b7a5d1746273f870091a87a057e834f754f34204b1 +89d0ebb287c3613cdcae7f5acc43f17f09c0213fc40c074660120b755d664109ffb9902ed981ede79e018ddb0c845698 +a87ccbfad431406aadbee878d9cf7d91b13649d5f7e19938b7dfd32645a43b114eef64ff3a13201398bd9b0337832e5a +833c51d0d0048f70c3eefb4e70e4ff66d0809c41838e8d2c21c288dd3ae9d9dfaf26d1742bf4976dab83a2b381677011 +8bcd6b1c3b02fffead432e8b1680bad0a1ac5a712d4225e220690ee18df3e7406e2769e1f309e2e803b850bc96f0e768 +b61e3dbd88aaf4ff1401521781e2eea9ef8b66d1fac5387c83b1da9e65c2aa2a56c262dea9eceeb4ad86c90211672db0 +866d3090db944ecf190dd0651abf67659caafd31ae861bab9992c1e3915cb0952da7c561cc7e203560a610f48fae633b +a5e8971543c14274a8dc892b0be188c1b4fbc75c692ed29f166e0ea80874bc5520c2791342b7c1d2fb5dd454b03b8a5b +8f2f9fc50471bae9ea87487ebd1bc8576ef844cc42d606af5c4c0969670fdf2189afd643e4de3145864e7773d215f37f +b1bb0f2527db6d51f42b9224383c0f96048bbc03d469bf01fe1383173ef8b1cc9455d9dd8ba04d46057f46949bfc92b5 +aa7c99d906b4d7922296cfe2520473fc50137c03d68b7865c5bfb8adbc316b1034310ec4b5670c47295f4a80fb8d61e9 +a5d1da4d6aba555919df44cbaa8ff79378a1c9e2cfdfbf9d39c63a4a00f284c5a5724e28ecbc2d9dba27fe4ee5018bd5 +a8db53224f70af4d991b9aae4ffe92d2aa5b618ad9137784b55843e9f16cefbfd25ada355d308e9bbf55f6d2f7976fb3 +b6536c4232bb20e22af1a8bb12de76d5fec2ad9a3b48af1f38fa67e0f8504ef60f305a73d19385095bb6a9603fe29889 +87f7e371a1817a63d6838a8cf4ab3a8473d19ce0d4f40fd013c03d5ddd5f4985df2956531cc9f187928ef54c68f4f9a9 +ae13530b1dbc5e4dced9d909ea61286ec09e25c12f37a1ed2f309b0eb99863d236c3b25ed3484acc8c076ad2fa8cd430 +98928d850247c6f7606190e687d5c94a627550198dbdbea0161ef9515eacdb1a0f195cae3bb293112179082daccf8b35 +918528bb8e6a055ad4db6230d3a405e9e55866da15c4721f5ddd1f1f37962d4904aad7a419218fe6d906fe191a991806 +b71e31a06afe065773dd3f4a6e9ef81c3292e27a3b7fdfdd452d03e05af3b6dd654c355f7516b2a93553360c6681a73a +8870b83ab78a98820866f91ac643af9f3ff792a2b7fda34185a9456a63abdce42bfe8ad4dc67f08a6392f250d4062df4 +91eea1b668e52f7a7a5087fabf1cab803b0316f78d9fff469fbfde2162f660c250e4336a9eea4cb0450bd30ac067bc8b +8b74990946de7b72a92147ceac1bd9d55999a8b576e8df68639e40ed5dc2062cfcd727903133de482b6dca19d0aaed82 +8ebad537fece090ebbab662bdf2618e21ca30cf6329c50935e8346d1217dcbe3c1fe1ea28efca369c6003ce0a94703c1 +a8640479556fb59ebd1c40c5f368fbd960932fdbb782665e4a0e24e2bdb598fc0164ce8c0726d7759cfc59e60a62e182 +a9a52a6bf98ee4d749f6d38be2c60a6d54b64d5cbe4e67266633dc096cf28c97fe998596707d31968cbe2064b72256bf +847953c48a4ce6032780e9b39d0ed4384e0be202c2bbe2dfda3910f5d87aa5cd3c2ffbfcfae4dddce16d6ab657599b95 +b6f6e1485d3ec2a06abaecd23028b200b2e4a0096c16144d07403e1720ff8f9ba9d919016b5eb8dc5103880a7a77a1d3 +98dfc2065b1622f596dbe27131ea60bef7a193b12922cecb27f8c571404f483014f8014572e86ae2e341ab738e4887ef +acb0d205566bacc87bbe2e25d10793f63f7a1f27fd9e58f4f653ceae3ffeba511eaf658e068fad289eeb28f9edbeb35b +ae4411ed5b263673cee894c11fe4abc72a4bf642d94022a5c0f3369380fcdfc1c21e277f2902972252503f91ada3029a +ac4a7a27ba390a75d0a247d93d4a8ef1f0485f8d373a4af4e1139369ec274b91b3464d9738eeaceb19cd6f509e2f8262 +87379c3bf231fdafcf6472a79e9e55a938d851d4dd662ab6e0d95fd47a478ed99e2ad1e6e39be3c0fc4f6d996a7dd833 +81316904b035a8bcc2041199a789a2e6879486ba9fddcba0a82c745cc8dd8374a39e523b91792170cd30be7aa3005b85 +b8206809c6cd027ed019f472581b45f7e12288f89047928ba32b4856b6560ad30395830d71e5e30c556f6f182b1fe690 +88d76c028f534a62e019b4a52967bb8642ede6becfa3807be68fdd36d366fc84a4ac8dc176e80a68bc59eb62caf5dff9 +8c3b8be685b0f8aad131ee7544d0e12f223f08a6f8edaf464b385ac644e0ddc9eff7cc7cb5c1b50ab5d71ea0f41d2213 +8d91410e004f76c50fdc05784157b4d839cb5090022c629c7c97a5e0c3536eeafee17a527b54b1165c3cd81774bb54ce +b25c2863bc28ec5281ce800ddf91a7e1a53f4c6d5da1e6c86ef4616e93bcf55ed49e297216d01379f5c6e7b3c1e46728 +865f7b09ac3ca03f20be90c48f6975dd2588838c2536c7a3532a6aa5187ed0b709cd03d91ff4048061c10d0aa72b69ce +b3f7477c90c11596eb4f8bbf34adbcb832638c4ff3cdd090d4d477ee50472ac9ddaf5be9ad7eca3f148960d362bbd098 +8db35fd53fca04faecd1c76a8227160b3ab46ac1af070f2492445a19d8ff7c25bbaef6c9fa0c8c088444561e9f7e4eb2 +a478b6e9d058a2e01d2fc053b739092e113c23a6a2770a16afbef044a3709a9e32f425ace9ba7981325f02667c3f9609 +98caa6bd38916c08cf221722a675a4f7577f33452623de801d2b3429595f988090907a7e99960fff7c076d6d8e877b31 +b79aaaacefc49c3038a14d2ac468cfec8c2161e88bdae91798d63552cdbe39e0e02f9225717436b9b8a40a022c633c6e +845a31006c680ee6a0cc41d3dc6c0c95d833fcf426f2e7c573fa15b2c4c641fbd6fe5ebb0e23720cc3467d6ee1d80dc4 +a1bc287e272cf8b74dbf6405b3a5190883195806aa351f1dc8e525aa342283f0a35ff687e3b434324dedee74946dd185 +a4fd2dc8db75d3783a020856e2b3aa266dc6926e84f5c491ef739a3bddd46dc8e9e0fc1177937839ef1b18d062ffbb9e +acbf0d3c697f57c202bb8c5dc4f3fc341b8fc509a455d44bd86acc67cad2a04495d5537bcd3e98680185e8aa286f2587 +a5caf423a917352e1b8e844f5968a6da4fdeae467d10c6f4bbd82b5eea46a660b82d2f5440d3641c717b2c3c9ed0be52 +8a39d763c08b926599ab1233219c49c825368fad14d9afc7c0c039224d37c00d8743293fd21645bf0b91eaf579a99867 +b2b53a496def0ba06e80b28f36530fbe0fb5d70a601a2f10722e59abee529369c1ae8fd0f2db9184dd4a2519bb832d94 +a73980fcef053f1b60ebbb5d78ba6332a475e0b96a0c724741a3abf3b59dd344772527f07203cf4c9cb5155ebed81fa0 +a070d20acce42518ece322c9db096f16aed620303a39d8d5735a0df6e70fbeceb940e8d9f5cc38f3314b2240394ec47b +a50cf591f522f19ca337b73089557f75929d9f645f3e57d4f241e14cdd1ea3fb48d84bcf05e4f0377afbb789fbdb5d20 +82a5ffce451096aca8eeb0cd2ae9d83db3ed76da3f531a80d9a70a346359bf05d74863ce6a7c848522b526156a5e20cd +88e0e84d358cbb93755a906f329db1537c3894845f32b9b0b691c29cbb455373d9452fadd1e77e20a623f6eaf624de6f +aa07ac7b84a6d6838826e0b9e350d8ec75e398a52e9824e6b0da6ae4010e5943fec4f00239e96433f291fef9d1d1e609 +ac8887bf39366034bc63f6cc5db0c26fd27307cbc3d6cce47894a8a019c22dd51322fb5096edc018227edfafc053a8f6 +b7d26c26c5b33f77422191dca94977588ab1d4b9ce7d0e19c4a3b4cd1c25211b78c328dbf81e755e78cd7d1d622ad23e +99a676d5af49f0ba44047009298d8474cabf2d5bca1a76ba21eff7ee3c4691a102fdefea27bc948ccad8894a658abd02 +b0d09a91909ab3620c183bdf1d53d43d39eb750dc7a722c661c3de3a1a5d383ad221f71bae374f8a71867505958a3f76 +84681a883de8e4b93d68ac10e91899c2bbb815ce2de74bb48a11a6113b2a3f4df8aceabda1f5f67bc5aacac8c9da7221 +9470259957780fa9b43521fab3644f555f5343281c72582b56d2efd11991d897b3b481cafa48681c5aeb80c9663b68f7 +ab1b29f7ece686e6fa968a4815da1d64f3579fed3bc92e1f3e51cd13a3c076b6cf695ed269d373300a62463dc98a4234 +8ab415bfcd5f1061f7687597024c96dd9c7cb4942b5989379a7a3b5742f7d394337886317659cbeacaf030234a24f972 +b9b524aad924f9acc63d002d617488f31b0016e0f0548f050cada285ce7491b74a125621638f19e9c96eabb091d945be +8c4c373e79415061837dd0def4f28a2d5d74d21cb13a76c9049ad678ca40228405ab0c3941df49249847ecdefc1a5b78 +a8edf4710b5ab2929d3db6c1c0e3e242261bbaa8bcec56908ddadd7d2dad2dca9d6eb9de630b960b122ebeea41040421 +8d66bb3b50b9df8f373163629f9221b3d4b6980a05ea81dc3741bfe9519cf3ebba7ab98e98390bae475e8ede5821bd5c +8d3c21bae7f0cfb97c56952bb22084b58e7bb718890935b73103f33adf5e4d99cd262f929c6eeab96209814f0dbae50a +a5c66cfab3d9ebf733c4af24bebc97070e7989fe3c73e79ac85fb0e4d40ae44fb571e0fad4ad72560e13ed453900d14f +9362e6b50b43dbefbc3254471372297b5dcce809cd3b60bf74a1268ab68bdb50e46e462cbd78f0d6c056330e982846af +854630d08e3f0243d570cc2e856234cb4c1a158d9c1883bf028a76525aaa34be897fe918d5f6da9764a3735fa9ebd24a +8c7d246985469ff252c3f4df6c7c9196fc79f05c1c66a609d84725c78001d0837c7a7049394ba5cf7e863e2d58af8417 +ae050271e01b528925302e71903f785b782f7bf4e4e7a7f537140219bc352dc7540c657ed03d3a297ad36798ecdb98cd +8d2ae9179fcf2b0c69850554580b52c1f4a5bd865af5f3028f222f4acad9c1ad69a8ef6c7dc7b03715ee5c506b74325e +b8ef8de6ce6369a8851cd36db0ccf00a85077e816c14c4e601f533330af9e3acf0743a95d28962ed8bfcfc2520ef3cfe +a6ecad6fdfb851b40356a8b1060f38235407a0f2706e7b8bb4a13465ca3f81d4f5b99466ac2565c60af15f022d26732e +819ff14cdea3ab89d98e133cd2d0379361e2e2c67ad94eeddcdb9232efd509f51d12f4f03ebd4dd953bd262a886281f7 +8561cd0f7a6dbcddd83fcd7f472d7dbcba95b2d4fb98276f48fccf69f76d284e626d7e41314b633352df8e6333fd52a1 +b42557ccce32d9a894d538c48712cb3e212d06ac05cd5e0527ccd2db1078ee6ae399bf6a601ffdab1f5913d35fc0b20c +89b4008d767aad3c6f93c349d3b956e28307311a5b1cec237e8d74bb0dee7e972c24f347fd56afd915a2342bd7bc32f0 +877487384b207e53f5492f4e36c832c2227f92d1bb60542cfeb35e025a4a7afc2b885fae2528b33b40ab09510398f83e +8c411050b63c9053dd0cd81dacb48753c3d7f162028098e024d17cd6348482703a69df31ad6256e3d25a8bbf7783de39 +a8506b54a88d17ac10fb1b0d1fe4aa40eae7553a064863d7f6b52ccc4236dd4b82d01dca6ba87da9a239e3069ba879fb +b1a24caef9df64750c1350789bb8d8a0db0f39474a1c74ea9ba064b1516db6923f00af8d57c632d58844fb8786c3d47a +959d6e255f212b0708c58a2f75cb1fe932248c9d93424612c1b8d1e640149656059737e4db2139afd5556bcdacf3eda2 +84525af21a8d78748680b6535bbc9dc2f0cf9a1d1740d12f382f6ecb2e73811d6c1da2ad9956070b1a617c61fcff9fe5 +b74417d84597a485d0a8e1be07bf78f17ebb2e7b3521b748f73935b9afbbd82f34b710fb7749e7d4ab55b0c7f9de127d +a4a9aecb19a6bab167af96d8b9d9aa5308eab19e6bfb78f5a580f9bf89bdf250a7b52a09b75f715d651cb73febd08e84 +9777b30be2c5ffe7d29cc2803a562a32fb43b59d8c3f05a707ab60ec05b28293716230a7d264d7cd9dd358fc031cc13e +95dce7a3d4f23ac0050c510999f5fbf8042f771e8f8f94192e17bcbfa213470802ebdbe33a876cb621cf42e275cbfc8b +b0b963ebcbbee847ab8ae740478544350b3ac7e86887e4dfb2299ee5096247cd2b03c1de74c774d9bde94ae2ee2dcd59 +a4ab20bafa316030264e13f7ef5891a2c3b29ab62e1668fcb5881f50a9acac6adbe3d706c07e62f2539715db768f6c43 +901478a297669d608e406fe4989be75264b6c8be12169aa9e0ad5234f459ca377f78484ffd2099a2fe2db5e457826427 +88c76e5c250810c057004a03408b85cd918e0c8903dc55a0dd8bb9b4fc2b25c87f9b8cf5943eb19fbbe99d36490050c5 +91607322bbad4a4f03fc0012d0821eff5f8c516fda45d1ec1133bface6f858bf04b25547be24159cab931a7aa08344d4 +843203e07fce3c6c81f84bc6dc5fb5e9d1c50c8811ace522dc66e8658433a0ef9784c947e6a62c11bf705307ef05212e +91dd8813a5d6dddcda7b0f87f672b83198cd0959d8311b2b26fb1fae745185c01f796fbd03aad9db9b58482483fdadd8 +8d15911aacf76c8bcd7136e958febd6963104addcd751ce5c06b6c37213f9c4fb0ffd4e0d12c8e40c36d658999724bfd +8a36c5732d3f1b497ebe9250610605ee62a78eaa9e1a45f329d09aaa1061131cf1d9df00f3a7d0fe8ad614a1ff9caaae +a407d06affae03660881ce20dab5e2d2d6cddc23cd09b95502a9181c465e57597841144cb34d22889902aff23a76d049 +b5fd856d0578620a7e25674d9503be7d97a2222900e1b4738c1d81ff6483b144e19e46802e91161e246271f90270e6cf +91b7708869cdb5a7317f88c0312d103f8ce90be14fb4f219c2e074045a2a83636fdc3e69e862049fc7c1ef000e832541 +b64719cc5480709d1dae958f1d3082b32a43376da446c8f9f64cb02a301effc9c34d9102051733315a8179aed94d53cc +94347a9542ff9d18f7d9eaa2f4d9b832d0e535fe49d52aa2de08aa8192400eddabdb6444a2a78883e27c779eed7fdf5a +840ef44a733ff1376466698cd26f82cf56bb44811e196340467f932efa3ae1ef9958a0701b3b032f50fd9c1d2aed9ab5 +90ab3f6f67688888a31ffc2a882bb37adab32d1a4b278951a21646f90d03385fc976715fc639a785d015751171016f10 +b56f35d164c24b557dbcbc8a4bfa681ec916f8741ffcb27fb389c164f4e3ed2be325210ef5bdaeae7a172ca9599ab442 +a7921a5a80d7cf6ae81ba9ee05e0579b18c20cd2852762c89d6496aa4c8ca9d1ca2434a67b2c16d333ea8e382cdab1e3 +a506bcfbd7e7e5a92f68a1bd87d07ad5fe3b97aeee40af2bf2cae4efcd77fff03f872732c5b7883aa6584bee65d6f8cb +a8c46cff58931a1ce9cbe1501e1da90b174cddd6d50f3dfdfb759d1d4ad4673c0a8feed6c1f24c7af32865a7d6c984e5 +b45686265a83bff69e312c5149db7bb70ac3ec790dc92e392b54d9c85a656e2bf58596ce269f014a906eafc97461aa5f +8d4009a75ccb2f29f54a5f16684b93202c570d7a56ec1a8b20173269c5f7115894f210c26b41e8d54d4072de2d1c75d0 +aef8810af4fc676bf84a0d57b189760ddc3375c64e982539107422e3de2580b89bd27aa6da44e827b56db1b5555e4ee8 +888f0e1e4a34f48eb9a18ef4de334c27564d72f2cf8073e3d46d881853ac1424d79e88d8ddb251914890588937c8f711 +b64b0aa7b3a8f6e0d4b3499fe54e751b8c3e946377c0d5a6dbb677be23736b86a7e8a6be022411601dd75012012c3555 +8d57776f519f0dd912ea14f79fbab53a30624e102f9575c0bad08d2dc754e6be54f39b11278c290977d9b9c7c0e1e0ad +a018fc00d532ceb2e4de908a15606db9b6e0665dd77190e2338da7c87a1713e6b9b61554e7c1462f0f6d4934b960b15c +8c932be83ace46f65c78e145b384f58e41546dc0395270c1397874d88626fdeda395c8a289d602b4c312fe98c1311856 +89174838e21639d6bdd91a0621f04dc056907b88e305dd66e46a08f6d65f731dea72ae87ca5e3042d609e8de8de9aa26 +b7b7f508bb74f7a827ac8189daa855598ff1d96fa3a02394891fd105d8f0816224cd50ac4bf2ed1cf469ace516c48184 +b31877ad682583283baadd68dc1bebd83f5748b165aadd7fe9ef61a343773b88bcd3a022f36d6c92f339b7bfd72820a9 +b79d77260b25daf9126dab7a193df2d7d30542786fa1733ffaf6261734770275d3ca8bae1d9915d1181a78510b3439db +91894fb94cd4c1dd2ceaf9c53a7020c5799ba1217cf2d251ea5bc91ed26e1159dd758e98282ebe35a0395ef9f1ed15a0 +ab59895cdafd33934ceedfc3f0d5d89880482cba6c99a6db93245f9e41987efd76e0640e80aef31782c9a8c7a83fccec +aa22ea63654315e033e09d4d4432331904a6fc5fb1732557987846e3c564668ca67c60a324b4af01663a23af11a9ce4b +b53ba3ef342601467e1f71aa280e100fbabbd38518fa0193e0099505036ee517c1ac78e96e9baeb549bb6879bb698fb0 +943fd69fd656f37487cca3605dc7e5a215fddd811caf228595ec428751fc1de484a0cb84c667fe4d7c35599bfa0e5e34 +9353128b5ebe0dddc555093cf3e5942754f938173541033e8788d7331fafc56f68d9f97b4131e37963ab7f1c8946f5f1 +a76cd3c566691f65cfb86453b5b31dbaf3cab8f84fe1f795dd1e570784b9b01bdd5f0b3c1e233942b1b5838290e00598 +983d84b2e53ffa4ae7f3ba29ef2345247ea2377686b74a10479a0ef105ecf90427bf53b74c96dfa346d0f842b6ffb25b +92e0fe9063306894a2c6970c001781cff416c87e87cb5fbac927a3192655c3da4063e6fa93539f6ff58efac6adcc5514 +b00a81f03c2b8703acd4e2e4c21e06973aba696415d0ea1a648ace2b0ea19b242fede10e4f9d7dcd61c546ab878bc8f9 +b0d08d880f3b456a10bf65cff983f754f545c840c413aea90ce7101a66eb0a0b9b1549d6c4d57725315828607963f15a +90cb64d03534f913b411375cce88a9e8b1329ce67a9f89ca5df8a22b8c1c97707fec727dbcbb9737f20c4cf751359277 +8327c2d42590dfcdb78477fc18dcf71608686ad66c49bce64d7ee874668be7e1c17cc1042a754bbc77c9daf50b2dae07 +8532171ea13aa7e37178e51a6c775da469d2e26ec854eb16e60f3307db4acec110d2155832c202e9ba525fc99174e3b0 +83ca44b15393d021de2a511fa5511c5bd4e0ac7d67259dce5a5328f38a3cce9c3a269405959a2486016bc27bb140f9ff +b1d36e8ca812be545505c8214943b36cabee48112cf0de369957afa796d37f86bf7249d9f36e8e990f26f1076f292b13 +9803abf45be5271e2f3164c328d449efc4b8fc92dfc1225d38e09630909fe92e90a5c77618daa5f592d23fc3ad667094 +b268ad68c7bf432a01039cd889afae815c3e120f57930d463aece10af4fd330b5bd7d8869ef1bcf6b2e78e4229922edc +a4c91a0d6f16b1553264592b4cbbbf3ca5da32ab053ffbdd3dbb1aed1afb650fb6e0dc5274f71a51d7160856477228db +ad89d043c2f0f17806277ffdf3ecf007448e93968663f8a0b674254f36170447b7527d5906035e5e56f4146b89b5af56 +8b6964f757a72a22a642e4d69102951897e20c21449184e44717bd0681d75f7c5bfa5ee5397f6e53febf85a1810d6ed1 +b08f5cdaabec910856920cd6e836c830b863eb578423edf0b32529488f71fe8257d90aed4a127448204df498b6815d79 +af26bb3358be9d280d39b21d831bb53145c4527a642446073fee5a86215c4c89ff49a3877a7a549486262f6f57a0f476 +b4010b37ec4d7c2af20800e272539200a6b623ae4636ecbd0e619484f4ab9240d02bc5541ace3a3fb955dc0a3d774212 +82752ab52bdcc3cc2fc405cb05a2e694d3df4a3a68f2179ec0652536d067b43660b96f85f573f26fbd664a9ef899f650 +96d392dde067473a81faf2d1fea55b6429126b88b160e39b4210d31d0a82833ffd3a80e07d24d495aea2d96be7251547 +a76d8236d6671204d440c33ac5b8deb71fa389f6563d80e73be8b043ec77d4c9b06f9a586117c7f957f4af0331cbc871 +b6c90961f68b5e385d85c9830ec765d22a425f506904c4d506b87d8944c2b2c09615e740ed351df0f9321a7b93979cae +a6ec5ea80c7558403485b3b1869cdc63bde239bafdf936d9b62a37031628402a36a2cfa5cfbb8e26ac922cb0a209b3ba +8c3195bbdbf9bc0fc95fa7e3d7f739353c947f7767d1e3cb24d8c8602d8ea0a1790ac30b815be2a2ba26caa5227891e2 +a7f8a63d809f1155722c57f375ea00412b00147776ae4444f342550279ef4415450d6f400000a326bf11fea6c77bf941 +97fa404df48433a00c85793440e89bb1af44c7267588ae937a1f5d53e01e1c4d4fc8e4a6d517f3978bfdd6c2dfde012f +a984a0a3836de3d8d909c4629a2636aacb85393f6f214a2ef68860081e9db05ad608024762db0dc35e895dc00e2d4cdd +9526cf088ab90335add1db4d3a4ac631b58cbfbe88fa0845a877d33247d1cfeb85994522e1eb8f8874651bfb1df03e2a +ac83443fd0afe99ad49de9bf8230158c118e2814c9c89db5ac951c240d6c2ce45e7677221279d9e97848ec466b99aafe +aeeefdbaba612e971697798ceaf63b247949dc823a0ad771ae5b988a5e882b338a98d3d0796230f49d533ec5ba411b39 +ae3f248b5a7b0f92b7820a6c5ae21e5bd8f4265d4f6e21a22512079b8ee9be06393fd3133ce8ebac0faf23f4f8517e36 +a64a831b908eee784b8388b45447d2885ec0551b26b0c2b15e5f417d0a12c79e867fb7bd3d008d0af98b44336f8ec1ad +b242238cd8362b6e440ba21806905714dd55172db25ec7195f3fc4937b2aba146d5cbf3cf691a1384b4752dc3b54d627 +819f97f337eea1ffb2a678cc25f556f1aab751c6b048993a1d430fe1a3ddd8bb411c152e12ca60ec6e057c190cd1db9a +b9d7d187407380df54ee9fef224c54eec1bfabf17dc8abf60765b7951f538f59aa26fffd5846cfe05546c35f59b573f4 +aa6e3c14efa6a5962812e3f94f8ce673a433f4a82d07a67577285ea0eaa07f8be7115853122d12d6d4e1fdf64c504be1 +82268bee9c1662d3ddb5fb785abfae6fb8b774190f30267f1d47091d2cd4b3874db4372625aa36c32f27b0eee986269b +b236459565b7b966166c4a35b2fa71030b40321821b8e96879d95f0e83a0baf33fa25721f30af4a631df209e25b96061 +8708d752632d2435d2d5b1db4ad1fa2558d776a013655f88e9a3556d86b71976e7dfe5b8834fdec97682cd94560d0d0d +ae1424a68ae2dbfb0f01211f11773732a50510b5585c1fb005cb892b2c6a58f4a55490b5c5b4483c6fce40e9d3236a52 +b3f5f722af9dddb07293c871ce97abbccba0093ca98c8d74b1318fa21396fc1b45b69c15084f63d728f9908442024506 +9606f3ce5e63886853ca476dc0949e7f1051889d529365c0cb0296fdc02abd088f0f0318ecd2cf36740a3634132d36f6 +b11a833a49fa138db46b25ff8cdda665295226595bc212c0931b4931d0a55c99da972c12b4ef753f7e37c6332356e350 +afede34e7dab0a9e074bc19a7daddb27df65735581ca24ad70c891c98b1349fcebbcf3ba6b32c2617fe06a5818dabc2d +97993d456e459e66322d01f8eb13918979761c3e8590910453944bdff90b24091bb018ac6499792515c9923be289f99f +977e3e967eff19290a192cd11df3667d511b398fb3ac9a5114a0f3707e25a0edcb56105648b1b85a8b7519fc529fc6f6 +b873a7c88bf58731fe1bf61ff6828bf114cf5228f254083304a4570e854e83748fc98683ddba62d978fff7909f2c5c47 +ad4b2691f6f19da1d123aaa23cca3e876247ed9a4ab23c599afdbc0d3aa49776442a7ceaa996ac550d0313d9b9a36cee +b9210713c78e19685608c6475bfa974b57ac276808a443f8b280945c5d5f9c39da43effa294bfb1a6c6f7b6b9f85bf6c +a65152f376113e61a0e468759de38d742caa260291b4753391ee408dea55927af08a4d4a9918600a3bdf1df462dffe76 +8bf8c27ad5140dde7f3d2280fd4cc6b29ab76537e8d7aa7011a9d2796ee3e56e9a60c27b5c2da6c5e14fc866301dc195 +92fde8effc9f61393a2771155812b863cff2a0c5423d7d40aa04d621d396b44af94ddd376c28e7d2f53c930aea947484 +97a01d1dd9ee30553ce676011aea97fa93d55038ada95f0057d2362ae9437f3ed13de8290e2ff21e3167dd7ba10b9c3f +89affffaa63cb2df3490f76f0d1e1d6ca35c221dd34057176ba739fa18d492355e6d2a5a5ad93a136d3b1fed0bb8aa19 +928b8e255a77e1f0495c86d3c63b83677b4561a5fcbbe5d3210f1e0fc947496e426d6bf3b49394a5df796c9f25673fc4 +842a0af91799c9b533e79ee081efe2a634cac6c584c2f054fb7d1db67dde90ae36de36cbf712ec9cd1a0c7ee79e151ea +a65b946cf637e090baf2107c9a42f354b390e7316beb8913638130dbc67c918926eb87bec3b1fe92ef72bc77a170fa3b +aafc0f19bfd71ab5ae4a8510c7861458b70ad062a44107b1b1dbacbfa44ba3217028c2824bd7058e2fa32455f624040b +95269dc787653814e0be899c95dba8cfa384f575a25e671c0806fd80816ad6797dc819d30ae06e1d0ed9cb01c3950d47 +a1e760f7fa5775a1b2964b719ff961a92083c5c617f637fc46e0c9c20ab233f8686f7f38c3cb27d825c54dd95e93a59b +ac3b8a7c2317ea967f229eddc3e23e279427f665c4705c7532ed33443f1243d33453c1088f57088d2ab1e3df690a9cc9 +b787beeddfbfe36dd51ec4efd9cf83e59e84d354c3353cc9c447be53ae53d366ed1c59b686e52a92f002142c8652bfe0 +b7a64198300cb6716aa7ac6b25621f8bdec46ad5c07a27e165b3f774cdf65bcfdbf31e9bae0c16b44de4b00ada7a4244 +b8ae9f1452909e0c412c7a7fe075027691ea8df1347f65a5507bc8848f1d2c833d69748076db1129e5b4fb912f65c86c +9682e41872456b9fa67def89e71f06d362d6c8ca85c9c48536615bc401442711e1c9803f10ab7f8ab5feaec0f9df20a6 +88889ff4e271dc1c7e21989cc39f73cde2f0475acd98078281591ff6c944fadeb9954e72334319050205d745d4df73df +8f79b5b8159e7fd0d93b0645f3c416464f39aec353b57d99ecf24f96272df8a068ad67a6c90c78d82c63b40bb73989bb +838c01a009a3d8558a3f0bdd5e22de21af71ca1aefc8423c91dc577d50920e9516880e87dce3e6d086e11cd45c9052d9 +b97f1c6eee8a78f137c840667cc288256e39294268a3009419298a04a1d0087c9c9077b33c917c65caf76637702dda8a +972284ce72f96a61c899260203dfa06fc3268981732bef74060641c1a5068ead723e3399431c247ca034b0dae861e8df +945a8d52d6d3db6663dbd3110c6587f9e9c44132045eeffba15621576d178315cb52870fa5861669f84f0bee646183fe +a0a547b5f0967b1c3e5ec6c6a9a99f0578521489180dfdfbb5561f4d166baac43a2f06f950f645ce991664e167537eed +a0592cda5cdddf1340033a745fd13a6eff2021f2e26587116c61c60edead067e0f217bc2bef4172a3c9839b0b978ab35 +b9c223b65a3281587fa44ec829e609154b32f801fd1de6950e01eafb07a8324243b960d5735288d0f89f0078b2c42b5b +99ebfc3b8f9f98249f4d37a0023149ed85edd7a5abe062c8fb30c8c84555258b998bdcdd1d400bc0fa2a4aaa8b224466 +955b68526e6cb3937b26843270f4e60f9c6c8ece2fa9308fe3e23afa433309c068c66a4bc16ee2cf04220f095e9afce4 +b766caeafcc00378135ae53397f8a67ed586f5e30795462c4a35853de6681b1f17401a1c40958de32b197c083b7279c1 +921bf87cad947c2c33fa596d819423c10337a76fe5a63813c0a9dc78a728207ae7b339407a402fc4d0f7cba3af6da6fc +a74ba1f3bc3e6c025db411308f49b347ec91da1c916bda9da61e510ec8d71d25e0ac0f124811b7860e5204f93099af27 +a29b4d144e0bf17a7e8353f2824cef0ce85621396babe8a0b873ca1e8a5f8d508b87866cf86da348470649fceefd735c +a8040e12ffc3480dd83a349d06741d1572ef91932c46f5cf03aee8454254156ee95786fd013d5654725e674c920cec32 +8c4cf34ca60afd33923f219ffed054f90cd3f253ffeb2204a3b61b0183417e366c16c07fae860e362b0f2bfe3e1a1d35 +8195eede4ddb1c950459df6c396b2e99d83059f282b420acc34220cadeed16ab65c856f2c52568d86d3c682818ed7b37 +91fff19e54c15932260aa990c7fcb3c3c3da94845cc5aa8740ef56cf9f58d19b4c3c55596f8d6c877f9f4d22921d93aa +a3e0bf7e5d02a80b75cf75f2db7e66cb625250c45436e3c136d86297d652590ec97c2311bafe407ad357c79ab29d107b +81917ff87e5ed2ae4656b481a63ced9e6e5ff653b8aa6b7986911b8bc1ee5b8ef4f4d7882c3f250f2238e141b227e510 +915fdbe5e7de09c66c0416ae14a8750db9412e11dc576cf6158755fdcaf67abdbf0fa79b554cac4fe91c4ec245be073f +8df27eafb5c3996ba4dc5773c1a45ca77e626b52e454dc1c4058aa94c2067c18332280630cc3d364821ee53bf2b8c130 +934f8a17c5cbb827d7868f5c8ca00cb027728a841000a16a3428ab16aa28733f16b52f58c9c4fbf75ccc45df72d9c4df +b83f4da811f9183c25de8958bc73b504cf790e0f357cbe74ef696efa7aca97ad3b7ead1faf76e9f982c65b6a4d888fc2 +87188213c8b5c268dc2b6da413f0501c95749e953791b727450af3e43714149c115b596b33b63a2f006a1a271b87efd0 +83e9e888ab9c3e30761de635d9aabd31248cdd92f7675fc43e4b21fd96a03ec1dc4ad2ec94fec857ffb52683ac98e360 +b4b9a1823fe2d983dc4ec4e3aaea297e581c3fc5ab4b4af5fa1370caa37af2d1cc7fc6bfc5e7da60ad8fdce27dfe4b24 +856388bc78aef465dbcdd1f559252e028c9e9a2225c37d645c138e78f008f764124522705822a61326a6d1c79781e189 +a6431b36db93c3b47353ba22e7c9592c9cdfb9cbdd052ecf2cc3793f5b60c1e89bc96e6bae117bfd047f2308da00dd2f +b619972d48e7e4291542dcde08f7a9cdc883c892986ded2f23ccb216e245cd8d9ad1d285347b0f9d7611d63bf4cee2bc +8845cca6ff8595955f37440232f8e61d5351500bd016dfadd182b9d39544db77a62f4e0102ff74dd4173ae2c181d24ef +b2f5f7fa26dcd3b6550879520172db2d64ee6aaa213cbef1a12befbce03f0973a22eb4e5d7b977f466ac2bf8323dcedd +858b7f7e2d44bdf5235841164aa8b4f3d33934e8cb122794d90e0c1cac726417b220529e4f896d7b77902ab0ccd35b3a +80b0408a092dae2b287a5e32ea1ad52b78b10e9c12f49282976cd738f5d834e03d1ad59b09c5ccaccc39818b87d06092 +b996b0a9c6a2d14d984edcd6ab56bc941674102980d65b3ad9733455f49473d3f587c8cbf661228a7e125ddbe07e3198 +90224fcebb36865293bd63af786e0c5ade6b67c4938d77eb0cbae730d514fdd0fe2d6632788e858afd29d46310cf86df +b71351fdfff7168b0a5ec48397ecc27ac36657a8033d9981e97002dcca0303e3715ce6dd3f39423bc8ef286fa2e9e669 +ae2a3f078b89fb753ce4ed87e0c1a58bb19b4f0cfb6586dedb9fcab99d097d659a489fb40e14651741e1375cfc4b6c5f +8ef476b118e0b868caed297c161f4231bbeb863cdfa5e2eaa0fc6b6669425ce7af50dc374abceac154c287de50c22307 +92e46ab472c56cfc6458955270d3c72b7bde563bb32f7d4ab4d959db6f885764a3d864e1aa19802fefaa5e16b0cb0b54 +96a3f68323d1c94e73d5938a18a377af31b782f56212de3f489d22bc289cf24793a95b37f1d6776edf88114b5c1fa695 +962cc068cfce6faaa27213c4e43e44eeff0dfbb6d25b814e82c7da981fb81d7d91868fa2344f05fb552362f98cfd4a72 +895d4e4c4ad670abf66d43d59675b1add7afad7438ada8f42a0360c704cee2060f9ac15b4d27e9b9d0996bb801276fe3 +b3ad18d7ece71f89f2ef749b853c45dc56bf1c796250024b39a1e91ed11ca32713864049c9aaaea60cde309b47486bbf +8f05404e0c0258fdbae50e97ccb9b72ee17e0bd2400d9102c0dad981dac8c4c71585f03e9b5d50086d0a2d3334cb55d1 +8bd877e9d4591d02c63c6f9fc9976c109de2d0d2df2bfa5f6a3232bab5b0b8b46e255679520480c2d7a318545efa1245 +8d4c16b5d98957c9da13d3f36c46f176e64e5be879f22be3179a2c0e624fe4758a82bf8c8027410002f973a3b84cd55a +86e2a8dea86427b424fa8eada881bdff896907084a495546e66556cbdf070b78ba312bf441eb1be6a80006d25d5097a3 +8608b0c117fd8652fdab0495b08fadbeba95d9c37068e570de6fddfef1ba4a1773b42ac2be212836141d1bdcdef11a17 +a13d6febf5fb993ae76cae08423ca28da8b818d6ef0fde32976a4db57839cd45b085026b28ee5795f10a9a8e3098c683 +8e261967fa6de96f00bc94a199d7f72896a6ad8a7bbb1d6187cca8fad824e522880e20f766620f4f7e191c53321d70f9 +8b8e8972ac0218d7e3d922c734302803878ad508ca19f5f012bc047babd8a5c5a53deb5fe7c15a4c00fd6d1cb9b1dbd0 +b5616b233fb3574a2717d125a434a2682ff68546dccf116dd8a3b750a096982f185614b9fb6c7678107ff40a451f56fa +aa6adf9b0c3334b0d0663f583a4914523b2ac2e7adffdb026ab9109295ff6af003ef8357026dbcf789896d2afded8d73 +acb72df56a0b65496cd534448ed4f62950bb1e11e50873b6ed349c088ee364441821294ce0f7c61bd7d38105bea3b442 +abae12df83e01ec947249fedd0115dc501d2b03ff7232092979eda531dbbca29ace1d46923427c7dde4c17bdf3fd7708 +820b4fc2b63a9fda7964acf5caf19a2fc4965007cb6d6b511fcafcb1f71c3f673a1c0791d3f86e3a9a1eb6955b191cc0 +af277259d78c6b0f4f030a10c53577555df5e83319ddbad91afbd7c30bc58e7671c56d00d66ec3ab5ef56470cd910cee +ad4a861c59f1f5ca1beedd488fb3d131dea924fffd8e038741a1a7371fad7370ca5cf80dc01f177fbb9576713bb9a5b3 +b67a5162982ce6a55ccfb2f177b1ec26b110043cf18abd6a6c451cf140b5af2d634591eb4f28ad92177d8c7e5cd0a5e8 +96176d0a83816330187798072d449cbfccff682561e668faf6b1220c9a6535b32a6e4f852e8abb00f79abb87493df16b +b0afe6e7cb672e18f0206e4423f51f8bd0017bf464c4b186d46332c5a5847647f89ff7fa4801a41c1b0b42f6135bcc92 +8fc5e7a95ef20c1278c645892811f6fe3f15c431ebc998a32ec0da44e7213ea934ed2be65239f3f49b8ec471e9914160 +b7793e41adda6c82ba1f2a31f656f6205f65bf8a3d50d836ee631bc7ce77c153345a2d0fc5c60edf8b37457c3729c4ec +a504dd7e4d6b2f4379f22cc867c65535079c75ccc575955f961677fa63ecb9f74026fa2f60c9fb6323c1699259e5e9c8 +ab899d00ae693649cc1afdf30fb80d728973d2177c006e428bf61c7be01e183866614e05410041bc82cb14a33330e69c +8a3bd8b0b1be570b65c4432a0f6dc42f48a2000e30ab089cf781d38f4090467b54f79c0d472fcbf18ef6a00df69cc6f3 +b4d7028f7f76a96a3d7803fca7f507ae11a77c5346e9cdfccb120a833a59bda1f4264e425aa588e7a16f8e7638061d84 +b9c7511a76ea5fb105de905d44b02edb17008335766ee357ed386b7b3cf19640a98b38785cb14603c1192bee5886c9b6 +8563afb12e53aed71ac7103ab8602bfa8371ae095207cb0d59e8fd389b6ad1aff0641147e53cb6a7ca16c7f37c9c5e6b +8e108be614604e09974a9ed90960c28c4ea330a3d9a0cb4af6dd6f193f84ab282b243ecdf549b3131036bebc8905690c +b794d127fbedb9c5b58e31822361706ffac55ce023fbfe55716c3c48c2fd2f2c7660a67346864dfe588812d369cb50b6 +b797a3442fc3b44f41baefd30346f9ac7f96e770d010d53c146ce74ce424c10fb62758b7e108b8abfdc5fafd89d745cb +993bb71e031e8096442e6205625e1bfddfe6dd6a83a81f3e2f84fafa9e5082ab4cad80a099f21eff2e81c83457c725c3 +8711ab833fc03e37acf2e1e74cfd9133b101ff4144fe30260654398ae48912ab46549d552eb9d15d2ea57760d35ac62e +b21321fd2a12083863a1576c5930e1aecb330391ef83326d9d92e1f6f0d066d1394519284ddab55b2cb77417d4b0292f +877d98f731ffe3ee94b0b5b72d127630fa8a96f6ca4f913d2aa581f67732df6709493693053b3e22b0181632ac6c1e3b +ae391c12e0eb8c145103c62ea64f41345973311c3bf7281fa6bf9b7faafac87bcf0998e5649b9ef81e288c369c827e07 +b83a2842f36998890492ab1cd5a088d9423d192681b9a3a90ec518d4c541bce63e6c5f4df0f734f31fbfdd87785a2463 +a21b6a790011396e1569ec5b2a423857b9bec16f543e63af28024e116c1ea24a3b96e8e4c75c6537c3e4611fd265e896 +b4251a9c4aab3a495da7a42e684ba4860dbcf940ad1da4b6d5ec46050cbe8dab0ab9ae6b63b5879de97b905723a41576 +8222f70aebfe6ac037f8543a08498f4cadb3edaac00336fc00437eb09f2cba758f6c38e887cc634b4d5b7112b6334836 +86f05038e060594c46b5d94621a1d9620aa8ba59a6995baf448734e21f58e23c1ea2993d3002ad5250d6edd5ba59b34f +a7c0c749baef811ab31b973c39ceb1d94750e2bc559c90dc5eeb20d8bb6b78586a2b363c599ba2107d6be65cd435f24e +861d46a5d70b38d6c1cd72817a2813803d9f34c00320c8b62f8b9deb67f5b5687bc0b37c16d28fd017367b92e05da9ca +b3365d3dab639bffbe38e35383686a435c8c88b397b717cd4aeced2772ea1053ceb670f811f883f4e02975e5f1c4ac58 +a5750285f61ab8f64cd771f6466e2c0395e01b692fd878f2ef2d5c78bdd8212a73a3b1dfa5e4c8d9e1afda7c84857d3b +835a10809ccf939bc46cf950a33b36d71be418774f51861f1cd98a016ade30f289114a88225a2c11e771b8b346cbe6ef +a4f59473a037077181a0a62f1856ec271028546ca9452b45cedfcb229d0f4d1aabfc13062b07e536cc8a0d4b113156a2 +95cd14802180b224d44a73cc1ed599d6c4ca62ddcaa503513ccdc80aaa8be050cc98bd4b4f3b639549beb4587ac6caf9 +973b731992a3e69996253d7f36dd7a0af1982b5ed21624b77a7965d69e9a377b010d6dabf88a8a97eec2a476259859cc +af8a1655d6f9c78c8eb9a95051aa3baaf9c811adf0ae8c944a8d3fcba87b15f61021f3baf6996fa0aa51c81b3cb69de1 +835aad5c56872d2a2d6c252507b85dd742bf9b8c211ccb6b25b52d15c07245b6d89b2a40f722aeb5083a47cca159c947 +abf4e970b02bef8a102df983e22e97e2541dd3650b46e26be9ee394a3ea8b577019331857241d3d12b41d4eacd29a3ac +a13c32449dbedf158721c13db9539ae076a6ce5aeaf68491e90e6ad4e20e20d1cdcc4a89ed9fd49cb8c0dd50c17633c1 +8c8f78f88b7e22dd7e9150ab1c000f10c28e696e21d85d6469a6fe315254740f32e73d81ab1f3c1cf8f544c86df506e8 +b4b77f2acfe945abf81f2605f906c10b88fb4d28628487fb4feb3a09f17f28e9780445dfcee4878349d4c6387a9d17d4 +8d255c235f3812c6ecc646f855fa3832be5cb4dbb9c9e544989fafdf3f69f05bfd370732eaf954012f0044aa013fc9c6 +b982efd3f34b47df37c910148ac56a84e8116647bea24145a49e34e0a6c0176e3284d838dae6230cb40d0be91c078b85 +983f365aa09bd85df2a6a2ad8e4318996b1e27d02090755391d4486144e40d80b1fbfe1c798d626db92f52e33aa634da +95fd1981271f3ea3a41d654cf497e6696730d9ff7369f26bc4d7d15c7adb4823dd0c42e4a005a810af12d234065e5390 +a9f5219bd4b913c186ef30c02f995a08f0f6f1462614ea5f236964e02bdaa33db9d9b816c4aee5829947840a9a07ba60 +9210e6ceb05c09b46fd09d036287ca33c45124ab86315e5d6911ff89054f1101faaa3e83d123b7805056d388bcec6664 +8ed9cbf69c6ff3a5c62dd9fe0d7264578c0f826a29e614bc2fb4d621d90c8c9992438accdd7a614b1dca5d1bb73dc315 +85cf2a8cca93e00da459e3cecd22c342d697eee13c74d5851634844fc215f60053cf84b0e03c327cb395f48d1c71a8a4 +8818a18e9a2ec90a271b784400c1903089ffb0e0b40bc5abbbe12fbebe0f731f91959d98c5519ef1694543e31e2016d4 +8dabc130f296fa7a82870bf9a8405aaf542b222ed9276bba9bd3c3555a0f473acb97d655ee7280baff766a827a8993f0 +ac7952b84b0dc60c4d858f034093b4d322c35959605a3dad2b806af9813a4680cb038c6d7f4485b4d6b2ff502aaeca25 +ad65cb6d57b48a2602568d2ec8010baed0eb440eec7638c5ec8f02687d764e9de5b5d42ad5582934e592b48471c22d26 +a02ab8bd4c3d114ea23aebdd880952f9495912817da8c0c08eabc4e6755439899d635034413d51134c72a6320f807f1c +8319567764b8295402ec1ebef4c2930a138480b37e6d7d01c8b4c9cd1f2fc3f6e9a44ae6e380a0c469b25b06db23305f +afec53b2301dc0caa8034cd9daef78c48905e6068d692ca23d589b84a6fa9ddc2ed24a39480597e19cb3e83eec213b3f +ac0b4ffdb5ae08e586a9cdb98f9fe56f4712af3a97065e89e274feacfb52b53c839565aee93c4cfaaccfe51432c4fab0 +8972cbf07a738549205b1094c5987818124144bf187bc0a85287c94fdb22ce038c0f11df1aa16ec5992e91b44d1af793 +b7267aa6f9e3de864179b7da30319f1d4cb2a3560f2ea980254775963f1523b44c680f917095879bebfa3dc2b603efcf +80f68f4bfc337952e29504ee5149f15093824ea7ab02507efd1317a670f6cbc3611201848560312e3e52e9d9af72eccf +8897fee93ce8fc1e1122e46b6d640bba309384dbd92e46e185e6364aa8210ebf5f9ee7e5e604b6ffba99aa80a10dd7d0 +b58ea6c02f2360be60595223d692e82ee64874fda41a9f75930f7d28586f89be34b1083e03bbc1575bbfdda2d30db1ea +85a523a33d903280d70ac5938770453a58293480170c84926457ac2df45c10d5ff34322ab130ef4a38c916e70d81af53 +a2cbf045e1bed38937492c1f2f93a5ba41875f1f262291914bc1fc40c60bd0740fb3fea428faf6da38b7c180fe8ac109 +8c09328770ed8eb17afc6ac7ddd87bb476de18ed63cab80027234a605806895959990c47bd10d259d7f3e2ecb50074c9 +b4b9e19edb4a33bde8b7289956568a5b6b6557404e0a34584b5721fe6f564821091013fbb158e2858c6d398293bb4b59 +8a47377df61733a2aa5a0e945fce00267f8e950f37e109d4487d92d878fb8b573317bb382d902de515b544e9e233458d +b5804c9d97efeff5ca94f3689b8088c62422d92a1506fd1d8d3b1b30e8a866ad0d6dad4abfa051dfc4471250cac4c5d9 +9084a6ee8ec22d4881e9dcc8a9eb3c2513523d8bc141942370fd191ad2601bf9537a0b1e84316f3209b3d8a54368051e +85447eea2fa26656a649f8519fa67279183044791d61cf8563d0783d46d747d96af31d0a93507bbb2242666aa87d3720 +97566a84481027b60116c751aec552adfff2d9038e68d48c4db9811fb0cbfdb3f1d91fc176a0b0d988a765f8a020bce1 +ae87e5c1b9e86c49a23dceda4ecfd1dcf08567f1db8e5b6ec752ebd45433c11e7da4988573cdaebbb6f4135814fc059e +abee05cf9abdbc52897ac1ce9ed157f5466ed6c383d6497de28616238d60409e5e92619e528af8b62cc552bf09970dc2 +ae6d31cd7bf9599e5ee0828bab00ceb4856d829bba967278a73706b5f388465367aa8a6c7da24b5e5f1fdd3256ef8e63 +ac33e7b1ee47e1ee4af472e37ab9e9175260e506a4e5ce449788075da1b53c44cb035f3792d1eea2aa24b1f688cc6ed3 +80f65b205666b0e089bb62152251c48c380a831e5f277f11f3ef4f0d52533f0851c1b612267042802f019ec900dc0e8f +858520ad7aa1c9fed738e3b583c84168f2927837ad0e1d326afe9935c26e9b473d7f8c382e82ef1fe37d2b39bb40a1ee +b842dd4af8befe00a97c2d0f0c33c93974761e2cb9e5ab8331b25170318ddd5e4bdbc02d8f90cbfdd5f348f4f371c1f7 +8bf2cb79bc783cb57088aae7363320cbeaabd078ffdec9d41bc74ff49e0043d0dad0086a30e5112b689fd2f5a606365d +982eb03bbe563e8850847cd37e6a3306d298ab08c4d63ab6334e6b8c1fa13fce80cf2693b09714c7621d74261a0ff306 +b143edb113dec9f1e5105d4a93fbe502b859e587640d3db2f628c09a17060e6aec9e900e2c8c411cda99bc301ff96625 +af472d9befa750dcebc5428fe1a024f18ec1c07bca0f95643ce6b5f4189892a910285afb03fd7ed7068fbe614e80d33c +a97e3bc57ede73ecd1bbf02de8f51b4e7c1a067da68a3cd719f4ba26a0156cbf1cef2169fd35a18c5a4cced50d475998 +a862253c937cf3d75d7183e5f5be6a4385d526aeda5171c1c60a8381fea79f88f5f52a4fab244ecc70765d5765e6dfd5 +90cb776f8e5a108f1719df4a355bebb04bf023349356382cae55991b31720f0fd03206b895fa10c56c98f52453be8778 +a7614e8d0769dccd520ea4b46f7646e12489951efaef5176bc889e9eb65f6e31758df136b5bf1e9107e68472fa9b46ec +ac3a9b80a3254c42e5ed3a090a0dd7aee2352f480de96ad187027a3bb6c791eddfc3074b6ffd74eea825188f107cda4d +82a01d0168238ef04180d4b6e0a0e39024c02c2d75b065017c2928039e154d093e1af4503f4d1f3d8a948917abb5d09f +8fab000a2b0eef851a483aec8d2dd85fe60504794411a2f73ed82e116960547ac58766cb73df71aea71079302630258d +872451a35c6db61c63e9b8bb9f16b217f985c20be4451c14282c814adb29d7fb13f201367c664435c7f1d4d9375d7a58 +887d9ff54cc96b35d562df4a537ff972d7c4b3fd91ab06354969a4cfede0b9fc68bbffb61d0dbf1a58948dc701e54f5a +8cb5c2a6bd956875d88f41ae24574434f1308514d44057b55c9c70f13a3366ed054150eed0955a38fda3f757be73d55f +89ad0163cad93e24129d63f8e38422b7674632a8d0a9016ee8636184cab177659a676c4ee7efba3abe1a68807c656d60 +b9ec01c7cab6d00359b5a0b4a1573467d09476e05ca51a9227cd16b589a9943d161eef62dcc73f0de2ec504d81f4d252 +8031d17635d39dfe9705c485d2c94830b6fc9bc67b91300d9d2591b51e36a782e77ab5904662effa9382d9cca201f525 +8be5a5f6bc8d680e5092d6f9a6585acbaaaa2ddc671da560dcf5cfa4472f4f184b9597b5b539438accd40dda885687cc +b1fc0f052fae038a2e3de3b3a96b0a1024b009de8457b8b3adb2d315ae68a89af905720108a30038e5ab8d0d97087785 +8b8bdc77bd3a6bc7ca5492b6f8c614852c39a70d6c8a74916eaca0aeb4533b11898b8820a4c2620a97bf35e275480029 +af35f4dc538d4ad5cdf710caa38fd1eb496c3fa890a047b6a659619c5ad3054158371d1e88e0894428282eed9f47f76b +8166454a7089cc07758ad78724654f4e7a1a13e305bbf88ddb86f1a4b2904c4fc8ab872d7da364cdd6a6c0365239e2ad +ab287c7d3addce74ce40491871c768abe01daaa0833481276ff2e56926b38a7c6d2681ffe837d2cc323045ad1a4414f9 +b90317f4505793094d89365beb35537f55a6b5618904236258dd04ca61f21476837624a2f45fef8168acf732cab65579 +98ae5ea27448e236b6657ab5ef7b1cccb5372f92ab25f5fa651fbac97d08353a1dae1b280b1cd42b17d2c6a70a63ab9d +adcf54e752d32cbaa6cb98fbca48d8cd087b1db1d131d465705a0d8042c8393c8f4d26b59006eb50129b21e6240f0c06 +b591a3e4db18a7345fa935a8dd7994bbac5cc270b8ebd84c8304c44484c7a74afb45471fdbe4ab22156a30fae1149b40 +806b53ac049a42f1dcc1d6335505371da0bf27c614f441b03bbf2e356be7b2fb4eed7117eabcce9e427a542eaa2bf7d8 +800482e7a772d49210b81c4a907f5ce97f270b959e745621ee293cf8c71e8989363d61f66a98f2d16914439544ca84c7 +99de9eafdad3617445312341644f2bb888680ff01ce95ca9276b1d2e5ef83fa02dab5e948ebf66c17df0752f1bd37b70 +961ee30810aa4c93ae157fbe9009b8e443c082192bd36a73a6764ff9b2ad8b0948fe9a73344556e01399dd77badb4257 +ae0a361067c52efbe56c8adf982c00432cd478929459fc7f74052c8ee9531cd031fe1335418fde53f7c2ef34254eb7ac +a3503d16b6b27eb20c1b177bcf90d13706169220523a6271b85b2ce35a9a2b9c5bed088540031c0a4ebfdae3a4c6ab04 +909420122c3e723289ca4e7b81c2df5aff312972a2203f4c45821b176e7c862bf9cac7f7df3adf1d59278f02694d06e7 +989f42380ae904b982f85d0c6186c1aef5d6bcba29bcfbb658e811b587eb2749c65c6e4a8cc6409c229a107499a4f5d7 +8037a6337195c8e26a27ea4ef218c6e7d79a9720aaab43932d343192abc2320fe72955f5e431c109093bda074103330a +b312e168663842099b88445e940249cc508f080ab0c94331f672e7760258dbd86be5267e4cf25ea25facb80bff82a7e9 +aaa3ff8639496864fcdbfdda1ac97edc4f08e3c9288b768f6c8073038c9fbbf7e1c4bea169b4d45c31935cdf0680d45e +97dbd3df37f0b481a311dfc5f40e59227720f367912200d71908ef6650f32cc985cb05b981e3eea38958f7e48d10a15d +a89d49d1e267bb452d6cb621b9a90826fe55e9b489c0427b94442d02a16f390eed758e209991687f73f6b5a032321f42 +9530dea4e0e19d6496f536f2e75cf7d814d65fde567055eb20db48fd8d20d501cd2a22fb506db566b94c9ee10f413d43 +81a7009b9e67f1965fa7da6a57591c307de91bf0cd35ab4348dc4a98a4961e096d004d7e7ad318000011dc4342c1b809 +83440a9402b766045d7aca61a58bba2aa29cac1cf718199e472ba086f5d48093d9dda4d135292ba51d049a23964eceae +a06c9ce5e802df14f6b064a3d1a0735d429b452f0e2e276042800b0a4f16df988fd94cf3945921d5dd3802ab2636f867 +b1359e358b89936dee9e678a187aad3e9ab14ac40e96a0a68f70ee2583cdcf467ae03bef4215e92893f4e12f902adec8 +835304f8619188b4d14674d803103d5a3fa594d48e96d9699e653115dd05fdc2dda6ba3641cf7ad53994d448da155f02 +8327cba5a9ff0d3f5cd0ae55e77167448926d5fcf76550c0ad978092a14122723090c51c415e88e42a2b62eb07cc3981 +b373dcdaea85f85ce9978b1426a7ef4945f65f2d3467a9f1cc551a99766aac95df4a09e2251d3f89ca8c9d1a7cfd7b0e +ab1422dc41af2a227b973a6fd124dfcb2367e2a11a21faa1d381d404f51b7257e5bc82e9cf20cd7fe37d7ae761a2ab37 +a93774a03519d2f20fdf2ef46547b0a5b77c137d6a3434b48d56a2cbef9e77120d1b85d0092cf8842909213826699477 +8eb967a495a38130ea28711580b7e61bcd1d051cd9e4f2dbf62f1380bd86e0d60e978d72f6f31e909eb97b3b9a2b867c +ae8213378da1287ba1fe4242e1acaec19b877b6fe872400013c6eac1084b8d03156792fa3020201725b08228a1e80f49 +b143daf6893d674d607772b3b02d8ac48f294237e2f2c87963c0d4e26d9227d94a2a13512457c3d5883544bbc259f0ef +b343bd2aca8973888e42542218924e2dda2e938fd1150d06878af76f777546213912b7c7a34a0f94186817d80ffa185c +b188ebc6a8c3007001aa347ae72cc0b15d09bc6c19a80e386ee4b334734ec0cc2fe8b493c2422f38d1e6d133cc3db6fe +b795f6a8b9b826aaeee18ccd6baf6c5adeeec85f95eb5b6d19450085ec7217e95a2d9e221d77f583b297d0872073ba0e +b1c7dbd998ad32ae57bfa95deafa147024afd57389e98992c36b6e52df915d3d5a39db585141ec2423173e85d212fed8 +812bcdeb9fe5f12d0e1df9964798056e1f1c3de3b17b6bd2919b6356c4b86d8e763c01933efbe0224c86a96d5198a4be +b19ebeda61c23d255cbf472ef0b8a441f4c55b70f0d8ed47078c248b1d3c7c62e076b43b95c00a958ec8b16d5a7cb0d7 +b02adc9aaa20e0368a989c2af14ff48b67233d28ebee44ff3418bb0473592e6b681af1cc45450bd4b175df9051df63d9 +8d87f0714acee522eb58cec00360e762adc411901dba46adc9227124fa70ee679f9a47e91a6306d6030dd4eb8de2f3c1 +8be54cec21e74bcc71de29dc621444263737db15f16d0bb13670f64e42f818154e04b484593d19ef95f2ee17e4b3fe21 +ab8e20546c1db38d31493b5d5f535758afb17e459645c1b70813b1cf7d242fd5d1f4354a7c929e8f7259f6a25302e351 +89f035a1ed8a1e302ac893349ba8ddf967580fcb6e73d44af09e3929cde445e97ff60c87dafe489e2c0ab9c9986cfa00 +8b2b0851a795c19191a692af55f7e72ad2474efdc5401bc3733cfdd910e34c918aaebe69d5ea951bdddf3c01cabbfc67 +a4edb52c2b51495ccd1ee6450fc14b7b3ede8b3d106808929d02fb31475bacb403e112ba9c818d2857651e508b3a7dd1 +9569341fded45d19f00bcf3cbf3f20eb2b4d82ef92aba3c8abd95866398438a2387437e580d8b646f17cf6fde8c5af23 +aa4b671c6d20f72f2f18a939a6ff21cc37e0084b44b4a717f1be859a80b39fb1be026b3205adec2a66a608ec2bcd578f +94902e980de23c4de394ad8aec91b46f888d18f045753541492bfbb92c59d3daa8de37ae755a6853744af8472ba7b72b +af651ef1b2a0d30a7884557edfad95b6b5d445a7561caebdc46a485aedd25932c62c0798465c340a76f6feaa196dd712 +b7b669b8e5a763452128846dd46b530dca4893ace5cc5881c7ddcd3d45969d7e73fbebdb0e78aa81686e5f7b22ec5759 +82507fd4ebe9fa656a7f2e084d64a1fa6777a2b0bc106d686e2d9d2edafc58997e58cb6bfd0453b2bf415704aa82ae62 +b40bce2b42b88678400ecd52955bbdadd15f8b9e1b3751a1a3375dc0efb5ca3ee258cf201e1140b3c09ad41217d1d49e +b0210d0cbb3fbf3b8cdb39e862f036b0ff941cd838e7aaf3a8354e24246e64778d22f3de34572e6b2a580614fb6425be +876693cba4301b251523c7d034108831df3ce133d8be5a514e7a2ca494c268ca0556fa2ad8310a1d92a16b55bcd99ea9 +8660281406d22a4950f5ef050bf71dd3090edb16eff27fa29ef600cdea628315e2054211ed2cc6eaf8f2a1771ef689fd +a610e7e41e41ab66955b809ba4ade0330b8e9057d8efc9144753caed81995edeb1a42a53f93ce93540feca1fae708dac +a49e2c176a350251daef1218efaccc07a1e06203386ede59c136699d25ca5cb2ac1b800c25b28dd05678f14e78e51891 +83e0915aa2b09359604566080d411874af8c993beba97d4547782fdbe1a68e59324b800ff1f07b8db30c71adcbd102a8 +a19e84e3541fb6498e9bb8a099c495cbfcad113330e0262a7e4c6544495bb8a754b2208d0c2d895c93463558013a5a32 +87f2bd49859a364912023aca7b19a592c60214b8d6239e2be887ae80b69ebdeb59742bdebcfa73a586ab23b2c945586c +b8e8fdddae934a14b57bc274b8dcd0d45ebb95ddbaabef4454e0f6ce7d3a5a61c86181929546b3d60c447a15134d08e1 +87e0c31dcb736ea4604727e92dc1d9a3cf00adcff79df3546e02108355260f3dd171531c3c0f57be78d8b28058fcc8c0 +9617d74e8f808a4165a8ac2e30878c349e1c3d40972006f0787b31ea62d248c2d9f3fc3da83181c6e57e95feedfd0e8c +8949e2cee582a2f8db86e89785a6e46bc1565c2d8627d5b6bf43ba71ffadfab7e3c5710f88dcb5fb2fc6edf6f4fae216 +ad3fa7b0edceb83118972a2935a09f409d09a8db3869f30be3a76f67aa9fb379cabb3a3aff805ba023a331cad7d7eb64 +8c95718a4112512c4efbd496be38bf3ca6cdcaad8a0d128f32a3f9aae57f3a57bdf295a3b372a8c549fda8f4707cffed +88f3261d1e28a58b2dee3fcc799777ad1c0eb68b3560f9b4410d134672d9533532a91ea7be28a041784872632d3c9d80 +b47472a41d72dd2e8b72f5c4f8ad626737dde3717f63d6bc776639ab299e564cbad0a2ad5452a07f02ff49a359c437e5 +9896d21dc2e8aad87b76d6df1654f10cd7bceed4884159d50a818bea391f8e473e01e14684814c7780235f28e69dca6e +82d47c332bbd31bbe83b5eb44a23da76d4a7a06c45d7f80f395035822bc27f62f59281d5174e6f8e77cc9b5c3193d6f0 +95c74cd46206e7f70c9766117c34c0ec45c2b0f927a15ea167901a160e1530d8522943c29b61e03568aa0f9c55926c53 +a89d7757825ae73a6e81829ff788ea7b3d7409857b378ebccd7df73fdbe62c8d9073741cf038314971b39af6c29c9030 +8c1cd212d0b010905d560688cfc036ae6535bc334fa8b812519d810b7e7dcf1bb7c5f43deaa40f097158358987324a7f +b86993c383c015ed8d847c6b795164114dd3e9efd25143f509da318bfba89389ea72a420699e339423afd68b6512fafb +8d06bd379c6d87c6ed841d8c6e9d2d0de21653a073725ff74be1934301cc3a79b81ef6dd0aad4e7a9dc6eac9b73019bc +81af4d2d87219985b9b1202d724fe39ef988f14fef07dfe3c3b11714e90ffba2a97250838e8535eb63f107abfe645e96 +8c5e0af6330a8becb787e4b502f34f528ef5756e298a77dc0c7467433454347f3a2e0bd2641fbc2a45b95e231c6e1c02 +8e2a8f0f04562820dc8e7da681d5cad9fe2e85dd11c785fb6fba6786c57a857e0b3bd838fb849b0376c34ce1665e4837 +a39be8269449bfdfc61b1f62077033649f18dae9bef7c6163b9314ca8923691fb832f42776f0160b9e8abd4d143aa4e1 +8c154e665706355e1cc98e0a4cabf294ab019545ba9c4c399d666e6ec5c869ca9e1faf8fb06cd9c0a5c2f51a7d51b70a +a046a7d4de879d3ebd4284f08f24398e9e3bf006cd4e25b5c67273ade248689c69affff92ae810c07941e4904296a563 +afd94c1cb48758e5917804df03fb38a6da0e48cd9b6262413ea13b26973f9e266690a1b7d9d24bbaf7e82718e0e594b0 +859e21080310c8d6a38e12e2ac9f90a156578cdeb4bb2e324700e97d9a5511cd6045dc39d1d0de3f94aeed043a24119d +a219fb0303c379d0ab50893264919f598e753aac9065e1f23ef2949abc992577ab43c636a1d2c089203ec9ddb941e27d +b0fdb639d449588a2ca730afcba59334e7c387342d56defdfb7ef79c493f7fd0e5277eff18e7203e756c7bdda5803047 +87f9c3b7ed01f54368aca6dbcf2f6e06bff96e183c4b2c65f8baa23b377988863a0a125d5cdd41a072da8462ced4c070 +99ef7a5d5ac2f1c567160e1f8c95f2f38d41881850f30c461a205f7b1b9fb181277311333839b13fb3ae203447e17727 +aeaca9b1c2afd24e443326cc68de67b4d9cedb22ad7b501a799d30d39c85bb2ea910d4672673e39e154d699e12d9b3dc +a11675a1721a4ba24dd3d0e4c3c33a6edf4cd1b9f6b471070b4386c61f77452266eae6e3f566a40cfc885eada9a29f23 +b228334445e37b9b49cb4f2cc56b454575e92173ddb01370a553bba665adadd52df353ad74470d512561c2c3473c7bb9 +a18177087c996572d76f81178d18ed1ceebc8362a396348ce289f1d8bd708b9e99539be6fccd4acb1112381cfc5749b4 +8e7b8bf460f0d3c99abb19803b9e43422e91507a1c0c22b29ee8b2c52d1a384da4b87c292e28eff040db5be7b1f8641f +b03d038d813e29688b6e6f444eb56fec3abba64c3d6f890a6bcf2e916507091cdb2b9d2c7484617be6b26552ed1c56cb +a1c88ccd30e934adfc5494b72655f8afe1865a84196abfb376968f22ddc07761210b6a9fb7638f1413d1b4073d430290 +961b714faebf172ad2dbc11902461e286e4f24a99a939152a53406117767682a571057044decbeb3d3feef81f4488497 +a03dc4059b46effdd786a0a03cc17cfee8585683faa35bb07936ded3fa3f3a097f518c0b8e2db92fd700149db1937789 +adf60180c99ca574191cbcc23e8d025b2f931f98ca7dfcebfc380226239b6329347100fcb8b0fcb12db108c6ad101c07 +805d4f5ef24d46911cbf942f62cb84b0346e5e712284f82b0db223db26d51aabf43204755eb19519b00e665c7719fcaa +8dea7243e9c139662a7fe3526c6c601eee72fd8847c54c8e1f2ad93ef7f9e1826b170afe58817dac212427164a88e87f +a2ba42356606d651b077983de1ad643650997bb2babb188c9a3b27245bb65d2036e46667c37d4ce02cb1be5ae8547abe +af2ae50b392bdc013db2d12ce2544883472d72424fc767d3f5cb0ca2d973fc7d1f425880101e61970e1a988d0670c81b +98e6bec0568d3939b31d00eb1040e9b8b2a35db46ddf4369bdaee41bbb63cc84423d29ee510a170fb5b0e2df434ba589 +822ff3cd12fbef4f508f3ca813c04a2e0b9b799c99848e5ad3563265979e753ee61a48f6adc2984a850f1b46c1a43d35 +891e8b8b92a394f36653d55725ef514bd2e2a46840a0a2975c76c2a935577f85289026aaa74384da0afe26775cbddfb9 +b2a3131a5d2fe7c8967047aa66e4524babae941d90552171cc109527f345f42aa0df06dcbb2fa01b33d0043917bbed69 +80c869469900431f3eeefafdbe07b8afd8cee7739e659e6d0109b397cacff85a88247698f87dc4e2fe39a592f250ac64 +9091594f488b38f9d2bb5df49fd8b4f8829d9c2f11a197dd1431ed5abbc5c954bbde3387088f9ee3a5a834beb7619bce +b472e241e6956146cca57b97a8a204668d050423b4e76f857bad5b47f43b203a04c8391ba9d9c3e95093c071f9d376a1 +b7dd2de0284844392f7dfb56fe7ca3ede41e27519753ffc579a0a8d2d65ceb8108d06b6b0d4c3c1a2588951297bd1a1e +902116ce70d0a079ac190321c1f48701318c05f8e69ee09694754885d33a835a849cafe56f499a2f49f6cda413ddf9a7 +b18105cc736787fafaf7c3c11c448bce9466e683159dff52723b7951dff429565e466e4841d982e3aaa9ee2066838666 +97ab9911f3f659691762d568ae0b7faa1047b0aed1009c319fa79d15d0db8db9f808fc385dc9a68fa388c10224985379 +b2a2cba65f5b927e64d2904ba412e2bac1cf18c9c3eda9c72fb70262497ecf505b640827e2afebecf10eebbcf48ccd3e +b36a3fd677baa0d3ef0dac4f1548ff50a1730286b8c99d276a0a45d576e17b39b3cbadd2fe55e003796d370d4be43ce3 +a5dfec96ca3c272566e89dc453a458909247e3895d3e44831528130bc47cc9d0a0dac78dd3cad680a4351d399d241967 +8029382113909af6340959c3e61db27392531d62d90f92370a432aec3eb1e4c36ae1d4ef2ba8ec6edb4d7320c7a453f6 +971d85121ea108e6769d54f9c51299b0381ece8b51d46d49c89f65bedc123bab4d5a8bc14d6f67f4f680077529cbae4c +98ff6afc01d0bec80a278f25912e1b1ebff80117adae72e31d5b9fa4d9624db4ba2065b444df49b489b0607c45e26c4c +8fa29be10fb3ab30ce25920fec0187e6e91e458947009dabb869aade7136c8ba23602682b71e390c251f3743164cbdaa +b3345c89eb1653418fe3940cf3e56a9a9c66526389b98f45ca02dd62bfb37baa69a4baaa7132d7320695f8ea6ad1fd94 +b72c7f5541c9ac6b60a7ec9f5415e7fb14da03f7164ea529952a29399f3a071576608dbbcc0d45994f21f92ddbeb1e19 +aa3450bb155a5f9043d0ef95f546a2e6ade167280bfb75c9f09c6f9cdb1fffb7ce8181436161a538433afa3681c7a141 +92a18fecaded7854b349f441e7102b638ababa75b1b0281dd0bded6541abe7aa37d96693595be0b01fe0a2e2133d50f9 +980756ddf9d2253cfe6c94960b516c94889d09e612810935150892627d2ecee9a2517e04968eea295d0106850c04ca44 +ae68c6ccc454318cdd92f32b11d89116a3b8350207a36d22a0f626718cad671d960090e054c0c77ac3162ae180ecfd4b +99f31f66eaaa551749ad91d48a0d4e3ff4d82ef0e8b28f3184c54e852422ba1bdafd53b1e753f3a070f3b55f3c23b6a2 +a44eaeaa6589206069e9c0a45ff9fc51c68da38d4edff1d15529b7932e6f403d12b9387019c44a1488a5d5f27782a51f +b80b5d54d4b344840e45b79e621bd77a3f83fb4ce6d8796b7d6915107b3f3c34d2e7d95bdafd120f285669e5acf2437a +b36c069ec085a612b5908314d6b84c00a83031780261d1c77a0384c406867c9847d5b0845deddfa512cc04a8df2046fb +b09dbe501583220f640d201acea7ee3e39bf9eda8b91aa07b5c50b7641d86d71acb619b38d27835ce97c3759787f08e9 +87403d46a2bf63170fff0b857acacf42ee801afe9ccba8e5b4aea967b68eac73a499a65ca46906c2eb4c8f27bc739faa +82b93669f42a0a2aa5e250ffe6097269da06a9c02fcd1801abbad415a7729a64f830754bafc702e64600ba47671c2208 +8e3a3029be7edb8dd3ab1f8216664c8dc50d395f603736061d802cef77627db7b859ef287ed850382c13b4d22d6a2d80 +968e9ec7194ff424409d182ce0259acd950c384c163c04463bc8700a40b79beba6146d22b7fa7016875a249b7b31c602 +8b42c984bbe4996e0c20862059167c6bdc5164b1ffcd928f29512664459212d263e89f0f0e30eed4e672ffa5ed0b01b5 +96bac54062110dada905363211133f1f15dc7e4fd80a4c6e4a83bc9a0bcbbaba11cd2c7a13debcf0985e1a954c1da66b +a16dc8a653d67a7cd7ae90b2fffac0bf1ca587005430fe5ba9403edd70ca33e38ba5661d2ed6e9d2864400d997626a62 +a68ab11a570a27853c8d67e491591dcba746bfbee08a2e75ae0790399130d027ed387f41ef1d7de8df38b472df309161 +92532b74886874447c0300d07eda9bbe4b41ed25349a3da2e072a93fe32c89d280f740d8ff70d5816793d7f2b97373cc +88e35711b471e89218fd5f4d0eadea8a29405af1cd81974427bc4a5fb26ed60798daaf94f726c96e779b403a2cd82820 +b5c72aa4147c19f8c4f3a0a62d32315b0f4606e0a7025edc5445571eaf4daff64f4b7a585464821574dd50dbe1b49d08 +9305d9b4095258e79744338683fd93f9e657367b3ab32d78080e51d54eec331edbc224fad5093ebf8ee4bd4286757eb8 +b2a17abb3f6a05bcb14dc7b98321fa8b46d299626c73d7c6eb12140bf4c3f8e1795250870947af817834f033c88a59d6 +b3477004837dbd8ba594e4296f960fc91ab3f13551458445e6c232eb04b326da803c4d93e2e8dcd268b4413305ff84da +924b4b2ebaafdcfdfedb2829a8bf46cd32e1407d8d725a5bd28bdc821f1bafb3614f030ea4352c671076a63494275a3f +8b81b9ef6125c82a9bece6fdcb9888a767ac16e70527753428cc87c56a1236e437da8be4f7ecfe57b9296dc3ae7ba807 +906e19ec8b8edd58bdf9ae05610a86e4ea2282b1bbc1e8b00b7021d093194e0837d74cf27ac9916bdb8ec308b00da3da +b41c5185869071760ac786078a57a2ab4e2af60a890037ac0c0c28d6826f15c2cf028fddd42a9b6de632c3d550bfbc14 +a646e5dec1b713ae9dfdf7bdc6cd474d5731a320403c7dfcfd666ffc9ae0cff4b5a79530e8df3f4aa9cb80568cb138e9 +b0efad22827e562bd3c3e925acbd0d9425d19057868608d78c2209a531cccd0f2c43dc5673acf9822247428ffa2bb821 +a94c19468d14b6f99002fc52ac06bbe59e5c472e4a0cdb225144a62f8870b3f10593749df7a2de0bd3c9476ce682e148 +803864a91162f0273d49271dafaab632d93d494d1af935aefa522768af058fce52165018512e8d6774976d52bd797e22 +a08711c2f7d45c68fb340ac23597332e1bcaec9198f72967b9921204b9d48a7843561ff318f87908c05a44fc35e3cc9d +91c3cad94a11a3197ae4f9461faab91a669e0dddb0371d3cab3ed9aeb1267badc797d8375181130e461eadd05099b2a2 +81bdaaf48aae4f7b480fc13f1e7f4dd3023a41439ba231760409ce9292c11128ab2b0bdbbf28b98af4f97b3551f363af +8d60f9df9fd303f625af90e8272c4ecb95bb94e6efc5da17b8ab663ee3b3f673e9f6420d890ccc94acf4d2cae7a860d8 +a7b75901520c06e9495ab983f70b61483504c7ff2a0980c51115d11e0744683ce022d76e3e09f4e99e698cbd21432a0d +82956072df0586562fda7e7738226f694e1c73518dd86e0799d2e820d7f79233667192c9236dcb27637e4c65ef19d493 +a586beb9b6ffd06ad200957490803a7cd8c9bf76e782734e0f55e04a3dc38949de75dc607822ec405736c576cf83bca3 +a179a30d00def9b34a7e85607a447eea0401e32ab5abeee1a281f2acd1cf6ec81a178020666f641d9492b1bdf66f05a3 +83e129705c538787ed8e0fdc1275e6466a3f4ee21a1e6abedd239393b1df72244723b92f9d9d9339a0cab6ebf28f5a16 +811bd8d1e3722b64cd2f5b431167e7f91456e8bba2cc669d3fbbce7d553e29c3c19f629fcedd2498bc26d33a24891d17 +a243c030c858f1f60cccd26b45b024698cc6d9d9e6198c1ed4964a235d9f8d0baf9cde10c8e63dfaa47f8e74e51a6e85 +ab839eb82e23ca52663281f863b55b0a3d6d4425c33ffb4eeb1d7979488ab068bf99e2a60e82cea4dc42c56c26cbfebe +8b896f9bb21d49343e67aec6ad175b58c0c81a3ca73d44d113ae4354a0065d98eb1a5cafedaf232a2bb9cdc62152f309 +af6230340cc0b66f5bf845540ed4fc3e7d6077f361d60762e488d57834c3e7eb7eacc1b0ed73a7d134f174a01410e50c +88975e1b1af678d1b5179f72300a30900736af580dd748fd9461ef7afccc91ccd9bed33f9da55c8711a7635b800e831f +a97486bb9047391661718a54b8dd5a5e363964e495eae6c692730264478c927cf3e66dd3602413189a3699fbeae26e15 +a5973c161ab38732885d1d2785fd74bf156ba34881980cba27fe239caef06b24a533ffe6dbbbeca5e6566682cc00300a +a24776e9a840afda0003fa73b415d5bd6ecd9b5c2cc842b643ee51b8c6087f4eead4d0bfbd987eb174c489a7b952ff2a +a8a6ee06e3af053b705a12b59777267c546f33ba8a0f49493af8e6df4e15cf8dd2d4fb4daf7e84c6b5d3a7363118ff03 +a28e59ce6ad02c2ce725067c0123117e12ac5a52c8f5af13eec75f4a9efc4f696777db18a374fa33bcae82e0734ebd16 +86dfc3b78e841c708aff677baa8ee654c808e5d257158715097c1025d46ece94993efe12c9d188252ad98a1e0e331fec +a88d0275510f242eab11fdb0410ff6e1b9d7a3cbd3658333539815f1b450a84816e6613d15aa8a8eb15d87cdad4b27a2 +8440acea2931118a5b481268ff9f180ee4ede85d14a52c026adc882410825b8275caa44aff0b50c2b88d39f21b1a0696 +a7c3182eab25bd6785bacf12079d0afb0a9b165d6ed327814e2177148539f249eb9b5b2554538f54f3c882d37c0a8abe +85291fbe10538d7da38efdd55a7acebf03b1848428a2f664c3ce55367aece60039f4f320b1771c9c89a35941797f717c +a2c6414eeb1234728ab0de94aa98fc06433a58efa646ca3fcbd97dbfb8d98ae59f7ce6d528f669c8149e1e13266f69c9 +840c8462785591ee93aee2538d9f1ec44ba2ca61a569ab51d335ac873f5d48099ae8d7a7efa0725d9ff8f9475bfa4f56 +a7065a9d02fb3673acf7702a488fbc01aa69580964932f6f40b6c2d1c386b19e50b0e104fcac24ea26c4e723611d0238 +b72db6d141267438279e032c95e6106c2ccb3164b842ba857a2018f3a35f4b040da92680881eb17cd61d0920d5b8f006 +a8005d6c5960e090374747307ef0be2871a7a43fa4e76a16c35d2baab808e9777b496e9f57a4218b23390887c33a0b55 +8e152cea1e00a451ca47c20a1e8875873419700af15a5f38ee2268d3fbc974d4bd5f4be38008fa6f404dbdedd6e6e710 +a3391aed1fcd68761f06a7d1008ec62a09b1cb3d0203cd04e300a0c91adfed1812d8bc1e4a3fd7976dc0aae0e99f52f1 +967eb57bf2aa503ee0c6e67438098149eac305089c155f1762cf5e84e31f0fbf27c34a9af05621e34645c1ec96afaec8 +88af97ddc4937a95ec0dcd25e4173127260f91c8db2f6eac84afb789b363705fb3196235af631c70cafd09411d233589 +a32df75b3f2c921b8767638fd289bcfc61e08597170186637a7128ffedd52c798c434485ac2c7de07014f9e895c2c3d8 +b0a783832153650aa0d766a3a73ec208b6ce5caeb40b87177ffc035ab03c7705ecdd1090b6456a29f5fb7e90e2fa8930 +b59c8e803b4c3486777d15fc2311b97f9ded1602fa570c7b0200bada36a49ee9ef4d4c1474265af8e1c38a93eb66b18b +982f2c85f83e852022998ff91bafbb6ff093ef22cf9d5063e083a48b29175ccbd51b9c6557151409e439096300981a6c +939e3b5989fefebb9d272a954659a4eb125b98c9da6953f5e628d26266bd0525ec38304b8d56f08d65abc4d6da4a8dbb +8898212fe05bc8de7d18503cb84a1c1337cc2c09d1eeef2b475aa79185b7322bf1f8e065f1bf871c0c927dd19faf1f6d +94b0393a41cd00f724aee2d4bc72103d626a5aecb4b5486dd1ef8ac27528398edf56df9db5c3d238d8579af368afeb09 +96ac564450d998e7445dd2ea8e3fc7974d575508fa19e1c60c308d83b645864c029f2f6b7396d4ff4c1b24e92e3bac37 +8adf6638e18aff3eb3b47617da696eb6c4bdfbecbbc3c45d3d0ab0b12cbad00e462fdfbe0c35780d21aa973fc150285e +b53f94612f818571b5565bbb295e74bada9b5f9794b3b91125915e44d6ddcc4da25510eab718e251a09c99534d6042d9 +8b96462508d77ee083c376cd90807aebad8de96bca43983c84a4a6f196d5faf6619a2351f43bfeec101864c3bf255519 +aeadf34657083fc71df33bd44af73bf5281c9ca6d906b9c745536e1819ea90b56107c55e2178ebad08f3ba75b3f81c86 +9784ba29b2f0057b5af1d3ab2796d439b8753f1f749c73e791037461bdfc3f7097394283105b8ab01788ea5255a96710 +8756241bda159d4a33bf74faba0d4594d963c370fb6a18431f279b4a865b070b0547a6d1613cf45b8cfb5f9236bbf831 +b03ebfd6b71421dfd49a30460f9f57063eebfe31b9ceaa2a05c37c61522b35bdc09d7db3ad75c76c253c00ba282d3cd2 +b34e7e6341fa9d854b2d3153bdda0c4ae2b2f442ab7af6f99a0975d45725aa48e36ae5f7011edd249862e91f499687d4 +b462ee09dc3963a14354244313e3444de5cc37ea5ccfbf14cd9aca8027b59c4cb2a949bc30474497cab8123e768460e6 +aea753290e51e2f6a21a9a0ee67d3a2713f95c2a5c17fe41116c87d3aa77b1683761264d704df1ac34f8b873bc88ef7b +98430592afd414394f98ddfff9f280fcb1c322dbe3510f45e1e9c4bb8ee306b3e0cf0282c0ee73ebb8ba087d4d9e0858 +b95d3b5aaf54ffca11f4be8d57f76e14afdb20afc859dc7c7471e0b42031e8f3d461b726ecb979bdb2f353498dfe95ea +984d17f9b11a683132e0b5a9ee5945e3ff7054c2d5c716be73b29078db1d36f54c6e652fd2f52a19da313112e97ade07 +ab232f756b3fff3262be418a1af61a7e0c95ceebbc775389622a8e10610508cd6784ab7960441917a83cc191c58829ea +a28f41678d6e60de76b0e36ab10e4516e53e02e9c77d2b5af3cfeee3ce94cfa30c5797bd1daab20c98e1cad83ad0f633 +b55395fca84dd3ccc05dd480cb9b430bf8631ff06e24cb51d54519703d667268c2f8afcde4ba4ed16bece8cc7bc8c6e0 +8a8a5392a0e2ea3c7a8c51328fab11156004e84a9c63483b64e8f8ebf18a58b6ffa8fe8b9d95af0a2f655f601d096396 +ab480000fe194d23f08a7a9ec1c392334e9c687e06851f083845121ce502c06b54dda8c43092bcc1035df45cc752fe9b +b265644c29f628d1c7e8e25a5e845cabb21799371814730a41a363e1bda8a7be50fee7c3996a365b7fcba4642add10db +b8a915a3c685c2d4728f6931c4d29487cad764c5ce23c25e64b1a3259ac27235e41b23bfe7ae982921b4cb84463097df +8efa7338442a4b6318145a5440fc213b97869647eeae41b9aa3c0a27ee51285b73e3ae3b4a9423df255e6add58864aa9 +9106d65444f74d217f4187dfc8fcf3810b916d1e4275f94f6a86d1c4f3565b131fd6cde1fa708bc05fe183c49f14941a +948252dac8026bbbdb0a06b3c9d66ec4cf9532163bab68076fda1bd2357b69e4b514729c15aaa83b5618b1977bbc60c4 +ae6596ccfdf5cbbc5782efe3bb0b101bb132dbe1d568854ca24cacc0b2e0e9fabcb2ca7ab42aecec412efd15cf8cb7a2 +84a0b6c198ff64fd7958dfd1b40eac9638e8e0b2c4cd8cf5d8cdf80419baee76a05184bce6c5b635f6bf2d30055476a7 +8893118be4a055c2b3da593dbca51b1ae2ea2469911acfb27ee42faf3e6c3ad0693d3914c508c0b05b36a88c8b312b76 +b097479e967504deb6734785db7e60d1d8034d6ca5ba9552887e937f5e17bb413fccac2c1d1082154ed76609127860ad +a0294e6b9958f244d29943debf24b00b538b3da1116269b6e452bb12dc742226712fd1a15b9c88195afeb5d2415f505c +b3cc15f635080bc038f61b615f62b5b5c6f2870586191f59476e8368a73641d6ac2f7d0c1f54621982defdb318020230 +99856f49b9fe1604d917c94d09cc0ed753d13d015d30587a94e6631ffd964b214e607deb8a69a8b5e349a7edf4309206 +a8571e113ea22b4b4fce41a094da8c70de37830ae32e62c65c2fa5ad06a9bc29e884b945e73d448c72b176d6ecebfb58 +a9e9c6e52beb0013273c29844956b3ce291023678107cdc785f7b44eff5003462841ad8780761b86aefc6b734adde7cf +80a784b0b27edb51ef2bad3aee80e51778dcaa0f3f5d3dcb5dc5d4f4b2cf7ae35b08de6680ea9dac53f8438b92eb09ef +827b543e609ea328e97e373f70ad72d4915a2d1daae0c60d44ac637231070e164c43a2a58db80a64df1c624a042b38f9 +b449c65e8195202efdcb9bdb4e869a437313b118fef8b510cbbf8b79a4e99376adb749b37e9c20b51b31ed3310169e27 +8ea3028f4548a79a94c717e1ed28ad4d8725b8d6ab18b021063ce46f665c79da3c49440c6577319dab2d036b7e08f387 +897798431cfb17fe39f08f5f854005dc37b1c1ec1edba6c24bc8acb3b88838d0534a75475325a5ea98b326ad47dbad75 +89cf232e6303b0751561960fd4dea5754a28c594daf930326b4541274ffb03c7dd75938e411eb9a375006a70ce38097f +9727c6ae7f0840f0b6c8bfb3a1a5582ceee705e0b5c59b97def7a7a2283edd4d3f47b7971e902a3a2079e40b53ff69b8 +b76ed72b122c48679d221072efc0eeea063cb205cbf5f9ef0101fd10cb1075b8628166c83577cced654e1c001c7882f7 +ae908c42d208759da5ee9b405df85a6532ea35c6f0f6a1288d22870f59d98edc896841b8ac890a538e6c8d1e8b02d359 +809d12fe4039a0ec80dc9be6a89acaab7797e5f7f9b163378f52f9a75a1d73b2e9ae6e3dd49e32ced439783c1cabbef5 +a4149530b7f85d1098ba534d69548c6c612c416e8d35992fc1f64f4deeb41e09e49c6cf7aadbed7e846b91299358fe2d +a49342eacd1ec1148b8df1e253b1c015f603c39de11fa0a364ccb86ea32d69c34fd7aa6980a1fadcd8e785a57fa46f60 +87d43eff5a006dc4dddcf76cc96c656a1f3a68f19f124181feab86c6cc9a52cb9189cdbb423414defdd9bb0ca8ff1ddc +861367e87a9aa2f0f68296ba50aa5dbc5713008d260cc2c7e62d407c2063064749324c4e8156dc21b749656cfebce26b +b5303c2f72e84e170e66ae1b0fbd51b8c7a6f27476eaf5694b64e8737d5c84b51fe90100b256465a4c4156dd873cddb0 +b62849a4f891415d74f434cdc1d23c4a69074487659ca96e1762466b2b7a5d8525b056b891d0feea6fe6845cba8bc7fb +923dd9e0d6590a9307e8c4c23f13bae3306b580e297a937711a8b13e8de85e41a61462f25b7d352b682e8437bf2b4ab3 +9147379860cd713cd46c94b8cdf75125d36c37517fbecf81ace9680b98ce6291cd1c3e472f84249cc3b2b445e314b1b6 +a808a4f17ac21e3fb5cfef404e61fae3693ca3e688d375f99b6116779696059a146c27b06de3ac36da349b0649befd56 +87787e9322e1b75e66c1f0d9ea0915722a232770930c2d2a95e9478c4b950d15ab767e30cea128f9ed65893bfc2d0743 +9036a6ee2577223be105defe1081c48ea7319e112fff9110eb9f61110c319da25a6cea0464ce65e858635b079691ef1f +af5548c7c24e1088c23b57ee14d26c12a83484c9fd9296edf1012d8dcf88243f20039b43c8c548c265ef9a1ffe9c1c88 +a0fff520045e14065965fb8accd17e878d3fcaf9e0af2962c8954e50be6683d31fa0bf4816ab68f08630dbac6bfce52a +b4c1b249e079f6ae1781af1d97a60b15855f49864c50496c09c91fe1946266915b799f0406084d7783f5b1039116dd8b +8b0ffa5e7c498cb3879dddca34743b41eee8e2dea3d4317a6e961b58adb699ef0c92400c068d5228881a2b08121226bf +852ae8b19a1d80aa8ae5382e7ee5c8e7670ceb16640871c56b20b96b66b3b60e00015a3dde039446972e57b49a999ddd +a49942f04234a7d8492169da232cfff8051df86e8e1ba3db46aede02422c689c87dc1d99699c25f96cb763f5ca0983e5 +b04b597b7760cf5dcf411ef896d1661e6d5b0db3257ac2cf64b20b60c6cc18fa10523bb958a48d010b55bac7b02ab3b1 +a494591b51ea8285daecc194b5e5bd45ae35767d0246ac94fae204d674ee180c8e97ff15f71f28b7aeb175b8aea59710 +97d2624919e78406e7460730680dea8e71c8571cf988e11441aeea54512b95bd820e78562c99372d535d96f7e200d20d +ac693ddb00e48f76e667243b9b6a7008424043fb779e4f2252330285232c3fccac4da25cbd6d95fe9ad959ff305a91f6 +8d20ca0a71a64a3f702a0825bb46bd810d03bebfb227683680d474a52f965716ff99e19a165ebaf6567987f4f9ee3c94 +a5c516a438f916d1d68ca76996404792e0a66e97b7f18fc54c917bf10cf3211b62387932756e39e67e47b0bd6e88385a +b089614d830abc0afa435034cec7f851f2f095d479cacf1a3fb57272da826c499a52e7dcbc0eb85f4166fb94778e18e9 +a8dacc943765d930848288192f4c69e2461c4b9bc6e79e30eeef9a543318cf9ae9569d6986c65c5668a89d49993f8e07 +ab5a9361fa339eec8c621bdad0a58078983abd8942d4282b22835d7a3a47e132d42414b7c359694986f7db39386c2e19 +94230517fb57bd8eb26c6f64129b8b2abd0282323bf7b94b8bac7fab27b4ecc2c4290c294275e1a759de19f2216134f3 +b8f158ea5006bc3b90b285246625faaa6ac9b5f5030dc69701b12f3b79a53ec7e92eeb5a63bbd1f9509a0a3469ff3ffc +8b6944fd8cb8540957a91a142fdcda827762aa777a31e8810ca6d026e50370ee1636fc351724767e817ca38804ebe005 +82d1ee40fe1569c29644f79fa6c4033b7ed45cd2c3b343881f6eb0de2e79548fded4787fae19bed6ee76ed76ff9f2f11 +a8924c7035e99eaed244ca165607e7e568b6c8085510dcdbaf6ebdbed405af2e6c14ee27d94ffef10d30aa52a60bf66d +956f82a6c2ae044635e85812581e4866c5fa2f427b01942047d81f6d79a14192f66fbbe77c9ffeaef4e6147097fdd2b5 +b1100255a1bcf5e05b6aff1dfeb6e1d55b5d68d43a7457ba10cc76b61885f67f4d0d5179abda786e037ae95deb8eea45 +99510799025e3e5e8fbf06dedb14c060c6548ba2bda824f687d3999dc395e794b1fb6514b9013f3892b6cf65cb0d65aa +8f9091cebf5e9c809aab415942172258f894e66e625d7388a05289183f01b8d994d52e05a8e69f784fba41db9ea357f0 +a13d2eeb0776bdee9820ecb6693536720232848c51936bb4ef4fe65588d3f920d08a21907e1fdb881c1ad70b3725e726 +a68b8f18922d550284c5e5dc2dda771f24c21965a6a4d5e7a71678178f46df4d8a421497aad8fcb4c7e241aba26378a0 +8b7601f0a3c6ad27f03f2d23e785c81c1460d60100f91ea9d1cab978aa03b523150206c6d52ce7c7769c71d2c8228e9e +a8e02926430813caa851bb2b46de7f0420f0a64eb5f6b805401c11c9091d3b6d67d841b5674fa2b1dce0867714124cd8 +b7968ecba568b8193b3058400af02c183f0a6df995a744450b3f7e0af7a772454677c3857f99c140bbdb2a09e832e8e0 +8f20b1e9ba87d0a3f35309b985f3c18d2e8800f1ca7f0c52cadef773f1496b6070c936eea48c4a1cae83fd2524e9d233 +88aef260042db0d641a51f40639dbeeefa9e9811df30bee695f3791f88a2f84d318f04e8926b7f47bf25956cb9e3754f +9725345893b647e9ba4e6a29e12f96751f1ae25fcaec2173e9a259921a1a7edb7a47159b3c8767e44d9e2689f5aa0f72 +8c281e6f72752cb11e239e4df9341c45106eb7993c160e54423c2bffe10bc39d42624b45a1f673936ef2e1a02fc92f1a +90aba2f68bddb2fcce6c51430dacdfeec43ea8dc379660c99095df11017691ccf5faa27665cf4b9f0eea7728ae53c327 +b7022695c16521c5704f49b7ddbdbec9b5f57ce0ceebe537bc0ebb0906d8196cc855a9afeb8950a1710f6a654464d93f +8fe1b9dd3c6a258116415d36e08374e094b22f0afb104385a5da48be17123e86fb8327baacc4f0d9ebae923d55d99bb5 +817e85d8e3d19a4cbc1dec31597142c2daa4871bda89c2177fa719c00eda3344eb08b82eb92d4aa91a9eaacb3fc09783 +b59053e1081d2603f1ca0ba553804d6fa696e1fd996631db8f62087b26a40dfef02098b0326bb75f99ec83b9267ca738 +990a173d857d3ba81ff3789b931bfc9f5609cde0169b7f055fa3cb56451748d593d62d46ba33f80f9cafffe02b68dd14 +b0c538dbba4954b809ab26f9f94a3cf1dcb77ce289eaec1d19f556c0ae4be1fa03af4a9b7057837541c3cc0a80538736 +ac3ba42f5f44f9e1fc453ce49c4ab79d0e1d5c42d3b30b1e098f3ab3f414c4c262fa12fb2be249f52d4aaf3c5224beb9 +af47467eb152e59870e21f0d4da2f43e093daf40180ab01438030684b114d025326928eaab12c41b81a066d94fce8436 +98d1b58ba22e7289b1c45c79a24624f19b1d89e00f778eef327ec4856a9a897278e6f1a9a7e673844b31dde949153000 +97ccb15dfadc7c59dca08cfe0d22df2e52c684cf97de1d94bc00d7ba24e020025130b0a39c0f4d46e4fc872771ee7875 +b699e4ed9a000ff96ca296b2f09dce278832bc8ac96851ff3cff99ed3f6f752cfc0fea8571be28cd9b5a7ec36f1a08ee +b9f49f0edb7941cc296435ff0a912e3ad16848ee8765ab5f60a050b280d6ea585e5b34051b15f6b8934ef01ceb85f648 +ac3893df7b4ceab23c6b9054e48e8ba40d6e5beda8fbe90b814f992f52494186969b35d8c4cdc3c99890a222c9c09008 +a41293ad22fae81dea94467bc1488c3707f3d4765059173980be93995fa4fcc3c9340796e3eed0beeb0ba0d9bb4fa3aa +a0543e77acd2aeecde13d18d258aeb2c7397b77f17c35a1992e8666ea7abcd8a38ec6c2741bd929abba2f766138618cc +92e79b22bc40e69f6527c969500ca543899105837b6b1075fa1796755c723462059b3d1b028e0b3df2559fa440e09175 +a1fa1eac8f41a5197a6fb4aa1eae1a031c89f9c13ff9448338b222780cf9022e0b0925d930c37501a0ef7b2b00fdaf83 +b3cb29ff73229f0637335f28a08ad8c5f166066f27c6c175164d0f26766a927f843b987ee9b309ed71cbf0a65d483831 +84d4ab787f0ac00f104f4a734dc693d62d48c2aeb03913153da62c2ae2c27d11b1110dcef8980368dd84682ea2c1a308 +ab6a8e4bbc78d4a7b291ad3e9a8fe2d65f640524ba3181123b09d2d18a9e300e2509ccf7000fe47e75b65f3e992a2e7e +b7805ebe4f1a4df414003dc10bca805f2ab86ca75820012653e8f9b79c405196b0e2cab099f2ab953d67f0d60d31a0f9 +b12c582454148338ea605d22bd00a754109063e22617f1f8ac8ddf5502c22a181c50c216c3617b9852aa5f26af56b323 +86333ad9f898947e31ce747728dc8c887479e18d36ff3013f69ebef807d82c6981543b5c3788af93c4d912ba084d3cba +b514efa310dc4ad1258add138891e540d8c87142a881b5f46563cc58ecd1488e6d3a2fca54c0b72a929f3364ca8c333e +aa0a30f92843cf2f484066a783a1d75a7aa6f41f00b421d4baf20a6ac7886c468d0eea7ca8b17dd22f4f74631b62b640 +b3b7dc63baec9a752e8433c0cdee4d0f9bc41f66f2b8d132faf925eef9cf89aae756fc132c45910f057122462605dc10 +b9b8190dac5bfdeb59fd44f4da41a57e7f1e7d2c21faba9da91fa45cbeca06dcf299c9ae22f0c89ece11ac46352d619f +89f8cf36501ad8bdfeab863752a9090e3bfda57cf8fdeca2944864dc05925f501e252c048221bcc57136ab09a64b64b2 +b0cbfaf317f05f97be47fc9d69eda2dd82500e00d42612f271a1fe24626408c28881f171e855bd5bd67409f9847502b4 +a7c21a8fcede581bfd9847b6835eda62ba250bea81f1bb17372c800a19c732abe03064e64a2f865d974fb636cab4b859 +95f9df524ba7a4667351696c4176b505d8ea3659f5ff2701173064acc624af69a0fad4970963736383b979830cb32260 +856a74fe8b37a2e3afeac858c8632200485d438422a16ae3b29f359e470e8244995c63ad79c7e007ed063f178d0306fd +b37faa4d78fdc0bb9d403674dbea0176c2014a171c7be8527b54f7d1a32a76883d3422a3e7a5f5fcc5e9b31b57822eeb +8d37234d8594ec3fe75670b5c9cc1ec3537564d4739b2682a75b18b08401869a4264c0f264354219d8d896cded715db4 +b5289ee5737f0e0bde485d32096d23387d68dab8f01f47821ab4f06cc79a967afe7355e72dc0c751d96b2747b26f6255 +9085e1fdf9f813e9c3b8232d3c8863cd84ab30d45e8e0d3d6a0abd9ebc6fd70cdf749ff4d04390000e14c7d8c6655fc7 +93a388c83630331eca4da37ea4a97b3b453238af474817cc0a0727fd3138dcb4a22de38c04783ec829c22cb459cb4e8e +a5377116027c5d061dbe24c240b891c08cdd8cd3f0899e848d682c873aff5b8132c1e7cfe76d2e5ed97ee0eb1d42cb68 +a274c84b04338ed28d74683e2a7519c2591a3ce37c294d6f6e678f7d628be2db8eff253ede21823e2df7183e6552f622 +8bc201147a842453a50bec3ac97671397bc086d6dfc9377fa38c2124cdc286abda69b7324f47d64da094ae011d98d9d9 +9842d0c066c524592b76fbec5132bc628e5e1d21c424bec4555efca8619cc1fd8ea3161febcb8b9e8ab54702f4e815e2 +a19191b713a07efe85c266f839d14e25660ee74452e6c691cd9997d85ae4f732052d802d3deb018bdd847caa298a894b +a24f71fc0db504da4e287dd118a4a74301cbcd16033937ba2abc8417956fcb4ae19b8e63b931795544a978137eff51cb +a90eec4a6a3a4b8f9a5b93d978b5026fcf812fe65585b008d7e08c4aaf21195a1d0699f12fc16f79b6a18a369af45771 +8b551cf89737d7d06d9b3b9c4c1c73b41f2ea0af4540999c70b82dabff8580797cf0a3caf34c86c59a7069eb2e38f087 +b8d312e6c635e7a216a1cda075ae77ba3e1d2fd501dc31e83496e6e81ed5d9c7799f8e578869c2e0e256fb29f5de10a7 +8d144bdb8cae0b2cdb5b33d44bbc96984a5925202506a8cc65eb67ac904b466f5a7fe3e1cbf04aa785bbb7348c4bb73c +a101b3d58b7a98659244b88de0b478b3fb87dc5fc6031f6e689b99edf498abd43e151fd32bd4bbd240e0b3e59c440359 +907453abca7d8e7151a05cc3d506c988007692fe7401395dc93177d0d07d114ab6cca0cc658eb94c0223fe8658295cad +825329ffbe2147ddb68f63a0a67f32d7f309657b8e5d9ab5bb34b3730bfa2c77a23eaaadb05def7d9f94a9e08fdc1e96 +88ee923c95c1dac99ae7ed6067906d734d793c5dc5d26339c1bb3314abe201c5dccb33b9007351885eb2754e9a8ea06c +98bc9798543f5f1adc9f2cfcfa72331989420e9c3f6598c45269f0dc9b7c8607bbeaf03faa0aea2ddde2b8f17fdceff5 +8ee87877702a79aef923ab970db6fa81561b3c07d5bf1a072af0a7bad765b4cbaec910afe1a91703feacc7822fa38a94 +8060b9584aa294fe8adc2b22f67e988bc6da768eae91e429dcc43ddc53cfcc5d6753fdc1b420b268c7eb2fb50736a970 +b344a5524d80a2f051870c7001f74fcf348a70fcf78dbd20c6ff9ca85d81567d2318c8b8089f2c4f195d6aec9fc15fa6 +8f5a5d893e1936ed062149d20eb73d98b62b7f50ab5d93a6429c03656b36688d1c80cb5010e4977491e51fa0d7dd35d5 +86fa32ebbf97328c5f5f15564e1238297e289ec3219b9a741724e9f3ae8d5c15277008f555863a478b247ba5dc601d44 +9557e55377e279f4b6b5e0ffe01eca037cc13aac242d67dfcd0374a1e775c5ed5cb30c25fe21143fee54e3302d34a3ea +8cb6bcbc39372d23464a416ea7039f57ba8413cf3f00d9a7a5b356ab20dcb8ed11b3561f7bce372b8534d2870c7ee270 +b5d59075cb5abde5391f64b6c3b8b50adc6e1f654e2a580b6d6d6eff3f4fbdd8fffc92e06809c393f5c8eab37f774c4b +afcfb6903ef13e493a1f7308675582f15af0403b6553e8c37afb8b2808ad21b88b347dc139464367dc260df075fea1ad +810fbbe808375735dd22d5bc7fc3828dc49fdd22cc2d7661604e7ac9c4535c1df578780affb3b895a0831640a945bcad +8056b0c678803b416f924e09a6299a33cf9ad7da6fe1ad7accefe95c179e0077da36815fde3716711c394e2c5ea7127f +8b67403702d06979be19f1d6dc3ec73cc2e81254d6b7d0cc49cd4fdda8cd51ab0835c1d2d26fc0ecab5df90585c2f351 +87f97f9e6d4be07e8db250e5dd2bffdf1390665bc5709f2b631a6fa69a7fca958f19bd7cc617183da1f50ee63e9352b5 +ae151310985940471e6803fcf37600d7fa98830613e381e00dab943aec32c14162d51c4598e8847148148000d6e5af5c +81eb537b35b7602c45441cfc61b27fa9a30d3998fad35a064e05bc9479e9f10b62eba2b234b348219eea3cadcaac64bb +8a441434934180ab6f5bc541f86ebd06eadbee01f438836d797e930fa803a51510e005c9248cecc231a775b74d12b5e9 +81f3c250a27ba14d8496a5092b145629eb2c2e6a5298438670375363f57e2798207832c8027c3e9238ad94ecdadfc4df +a6217c311f2f3db02ceaa5b6096849fe92b6f4b6f1491535ef8525f6ccee6130bed2809e625073ecbaddd4a3eb3df186 +82d1c396f0388b942cf22b119d7ef1ad03d3dad49a74d9d01649ee284f377c8daddd095d596871669e16160299a210db +a40ddf7043c5d72a7246bd727b07f7fff1549f0e443d611de6f9976c37448b21664c5089c57f20105102d935ab82f27b +b6c03c1c97adf0c4bf4447ec71366c6c1bff401ba46236cd4a33d39291e7a1f0bb34bd078ba3a18d15c98993b153a279 +8a94f5f632068399c359c4b3a3653cb6df2b207379b3d0cdace51afdf70d6d5cce6b89a2b0fee66744eba86c98fb21c2 +b2f19e78ee85073f680c3bba1f07fd31b057c00b97040357d97855b54a0b5accb0d3b05b2a294568fcd6a4be6f266950 +a74632d13bbe2d64b51d7a9c3ae0a5a971c19f51cf7596a807cea053e6a0f3719700976d4e394b356c0329a2dced9aa2 +afef616d341a9bc94393b8dfba68ff0581436aa3a3adb7c26a1bbf2cf19fa877066191681f71f17f3cd6f9cf6bf70b5a +8ce96d93ae217408acf7eb0f9cbb9563363e5c7002e19bbe1e80760bc9d449daee2118f3878b955163ed664516b97294 +8414f79b496176bc8b8e25f8e4cfee28f4f1c2ddab099d63d2aca1b6403d26a571152fc3edb97794767a7c4686ad557c +b6c61d01fd8ce087ef9f079bf25bf10090db483dd4f88c4a786d31c1bdf52065651c1f5523f20c21e75cea17df69ab73 +a5790fd629be70545093631efadddc136661f63b65ec682609c38ef7d3d7fa4e56bdf94f06e263bc055b90cb1c6bcefe +b515a767e95704fb7597bca9e46f1753abacdc0e56e867ee3c6f4cd382643c2a28e65312c05ad040eaa3a8cbe7217a65 +8135806a02ead6aa92e9adb6fefb91349837ab73105aaa7be488ef966aa8dfaafdfa64bbae30fcbfa55dd135a036a863 +8f22435702716d76b1369750694540742d909d5e72b54d0878245fab7c269953b1c6f2b29c66f08d5e0263ca3a731771 +8e0f8a8e8753e077dac95848212aeffd51c23d9b6d611df8b102f654089401954413ecbedc6367561ca599512ae5dda7 +815a9084e3e2345f24c5fa559deec21ee1352fb60f4025c0779be65057f2d528a3d91593bd30d3a185f5ec53a9950676 +967e6555ccba395b2cc1605f8484c5112c7b263f41ce8439a99fd1c71c5ed14ad02684d6f636364199ca48afbbde13be +8cd0ccf17682950b34c796a41e2ea7dd5367aba5e80a907e01f4cdc611e4a411918215e5aebf4292f8b24765d73314a6 +a58bf1bbb377e4b3915df6f058a0f53b8fb8130fdec8c391f6bc82065694d0be59bb67ffb540e6c42cc8b380c6e36359 +92af3151d9e6bfb3383d85433e953c0160859f759b0988431ec5893542ba40288f65db43c78a904325ef8d324988f09d +8011bbb05705167afb47d4425065630f54cb86cd462095e83b81dfebf348f846e4d8fbcf1c13208f5de1931f81da40b9 +81c743c104fc3cb047885c9fa0fb9705c3a83ee24f690f539f4985509c3dafd507af3f6a2128276f45d5939ef70c167f +a2c9679b151c041aaf5efeac5a737a8f70d1631d931609fca16be1905682f35e291292874cb3b03f14994f98573c6f44 +a4949b86c4e5b1d5c82a337e5ce6b2718b1f7c215148c8bfb7e7c44ec86c5c9476048fc5c01f57cb0920876478c41ad6 +86c2495088bd1772152e527a1da0ef473f924ea9ab0e5b8077df859c28078f73c4e22e3a906b507fdf217c3c80808b5c +892e0a910dcf162bcea379763c3e2349349e4cda9402949255ac4a78dd5a47e0bf42f5bd0913951576b1d206dc1e536a +a7009b2c6b396138afe4754b7cc10dee557c51c7f1a357a11486b3253818531f781ea8107360c8d4c3b1cd96282353c0 +911763ef439c086065cc7b4e57484ed6d693ea44acee4b18c9fd998116da55fbe7dcb8d2a0f0f9b32132fca82d73dff6 +a722000b95a4a2d40bed81870793f15ba2af633f9892df507f2842e52452e02b5ea8dea6a043c2b2611d82376e33742a +9387ac49477bd719c2f92240d0bdfcf9767aad247ca93dc51e56106463206bc343a8ec855eb803471629a66fffb565d6 +92819a1fa48ab4902939bb72a0a4e6143c058ea42b42f9bc6cea5df45f49724e2530daf3fc4f097cceefa2a8b9db0076 +98eac7b04537653bc0f4941aae732e4b1f84bd276c992c64a219b8715eb1fb829b5cbd997d57feb15c7694c468f95f70 +b275e7ba848ce21bf7996e12dbeb8dadb5d0e4f1cb5a0248a4f8f9c9fe6c74e3c93f4b61edbcb0a51af5a141e1c14bc7 +97243189285aba4d49c53770c242f2faf5fd3914451da4931472e3290164f7663c726cf86020f8f181e568c72fd172d1 +839b0b3c25dd412bee3dc24653b873cc65454f8f16186bb707bcd58259c0b6765fa4c195403209179192a4455c95f3b8 +8689d1a870514568a074a38232e2ceb4d7df30fabeb76cff0aed5b42bf7f02baea12c5fadf69f4713464dbd52aafa55f +8958ae7b290f0b00d17c3e9fdb4dbf168432b457c7676829299dd428984aba892de1966fc106cfc58a772862ecce3976 +a422bc6bd68b8870cfa5bc4ce71781fd7f4368b564d7f1e0917f6013c8bbb5b240a257f89ecfdbecb40fe0f3aa31d310 +aa61f78130cebe09bc9a2c0a37f0dd57ed2d702962e37d38b1df7f17dc554b1d4b7a39a44182a452ce4c5eb31fa4cfcc +b7918bd114f37869bf1a459023386825821bfadce545201929d13ac3256d92a431e34f690a55d944f77d0b652cefeffc +819bba35fb6ace1510920d4dcff30aa682a3c9af9022e287751a6a6649b00c5402f14b6309f0aeef8fce312a0402915e +8b7c9ad446c6f63c11e1c24e24014bd570862b65d53684e107ba9ad381e81a2eaa96731b4b33536efd55e0f055071274 +8fe79b53f06d33386c0ec7d6d521183c13199498594a46d44a8a716932c3ec480c60be398650bbfa044fa791c4e99b65 +9558e10fb81250b9844c99648cf38fa05ec1e65d0ccbb18aa17f2d1f503144baf59d802c25be8cc0879fff82ed5034ad +b538a7b97fbd702ba84645ca0a63725be1e2891c784b1d599e54e3480e4670d0025526674ef5cf2f87dddf2290ba09f0 +92eafe2e869a3dd8519bbbceb630585c6eb21712b2f31e1b63067c0acb5f9bdbbcbdb612db4ea7f9cc4e7be83d31973f +b40d21390bb813ab7b70a010dff64c57178418c62685761784e37d327ba3cb9ef62df87ecb84277c325a637fe3709732 +b349e6fbf778c4af35fbed33130bd8a7216ed3ba0a79163ebb556e8eb8e1a7dad3456ddd700dad9d08d202491c51b939 +a8fdaedecb251f892b66c669e34137f2650509ade5d38fbe8a05d9b9184bb3b2d416186a3640429bd1f3e4b903c159dd +ac6167ebfee1dbab338eff7642f5e785fc21ef0b4ddd6660333fe398068cbd6c42585f62e81e4edbb72161ce852a1a4f +874b1fbf2ebe140c683bd7e4e0ab017afa5d4ad38055aaa83ee6bbef77dbc88a6ce8eb0dcc48f0155244af6f86f34c2d +903c58e57ddd9c446afab8256a6bb6c911121e6ccfb4f9b4ed3e2ed922a0e500a5cb7fa379d5285bc16e11dac90d1fda +8dae7a0cffa2fd166859cd1bf10ff82dd1932e488af377366b7efc0d5dec85f85fe5e8150ff86a79a39cefc29631733a +aa047857a47cc4dfc08585f28640420fcf105b881fd59a6cf7890a36516af0644d143b73f3515ab48faaa621168f8c31 +864508f7077c266cc0cb3f7f001cb6e27125ebfe79ab57a123a8195f2e27d3799ff98413e8483c533b46a816a3557f1f +8bcd45ab1f9cbab36937a27e724af819838f66dfeb15923f8113654ff877bd8667c54f6307aaf0c35027ca11b6229bfd +b21aa34da9ab0a48fcfdd291df224697ce0c1ebc0e9b022fdee8750a1a4b5ba421c419541ed5c98b461eecf363047471 +a9a18a2ab2fae14542dc336269fe612e9c1af6cf0c9ac933679a2f2cb77d3c304114f4d219ca66fe288adde30716775b +b5205989b92c58bdda71817f9a897e84100b5c4e708de1fced5c286f7a6f01ae96b1c8d845f3a320d77c8e2703c0e8b1 +a364059412bbcc17b8907d43ac8e5df90bc87fd1724b5f99832d0d24559fae6fa76a74cff1d1eac8cbac6ec80b44af20 +ae709f2c339886b31450834cf29a38b26eb3b0779bd77c9ac269a8a925d1d78ea3837876c654b61a8fe834b3b6940808 +8802581bba66e1952ac4dab36af371f66778958f4612901d95e5cac17f59165e6064371d02de8fb6fccf89c6dc8bd118 +a313252df653e29c672cbcfd2d4f775089cb77be1077381cf4dc9533790e88af6cedc8a119158e7da5bf6806ad9b91a1 +992a065b4152c7ef11515cd54ba9d191fda44032a01aed954acff3443377ee16680c7248d530b746b8c6dee2d634e68c +b627b683ee2b32c1ab4ccd27b9f6cce2fe097d96386fa0e5c182ad997c4c422ab8dfc03870cd830b8c774feb66537282 +b823cf8a9aee03dadd013eb9efe40a201b4b57ef67efaae9f99683005f5d1bf55e950bf4af0774f50859d743642d3fea +b8a7449ffac0a3f206677097baf7ce00ca07a4d2bd9b5356fbcb83f3649b0fda07cfebad220c1066afba89e5a52abf4b +b2dd1a2f986395bb4e3e960fbbe823dbb154f823284ebc9068502c19a7609790ec0073d08bfa63f71e30c7161b6ef966 +98e5236de4281245234f5d40a25b503505af140b503a035fc25a26159a9074ec81512b28f324c56ea2c9a5aa7ce90805 +89070847dc8bbf5bc4ed073aa2e2a1f699cf0c2ca226f185a0671cecc54e7d3e14cd475c7752314a7a8e7476829da4bc +a9402dc9117fdb39c4734c0688254f23aed3dce94f5f53f5b7ef2b4bf1b71a67f85ab1a38ec224a59691f3bee050aeb3 +957288f9866a4bf56a4204218ccc583f717d7ce45c01ea27142a7e245ad04a07f289cc044f8cf1f21d35e67e39299e9c +b2fb31ccb4e69113763d7247d0fc8edaae69b550c5c56aecacfd780c7217dc672f9fb7496edf4aba65dacf3361268e5b +b44a4526b2f1d6eb2aa8dba23bfa385ff7634572ab2afddd0546c3beb630fbfe85a32f42dd287a7fec069041411537f7 +8db5a6660c3ac7fd7a093573940f068ee79a82bc17312af900b51c8c439336bc86ca646c6b7ab13aaaa008a24ca508ab +8f9899a6d7e8eb4367beb5c060a1f8e94d8a21099033ae582118477265155ba9e72176a67f7f25d7bad75a152b56e21a +a67de0e91ade8d69a0e00c9ff33ee2909b8a609357095fa12319e6158570c232e5b6f4647522efb7345ce0052aa9d489 +82eb2414898e9c3023d57907a2b17de8e7eea5269029d05a94bfd7bf5685ac4a799110fbb375eb5e0e2bd16acf6458ae +94451fc7fea3c5a89ba701004a9693bab555cb622caf0896b678faba040409fdfd14a978979038b2a81e8f0abc4994d2 +ac879a5bb433998e289809a4a966bd02b4bf6a9c1cc276454e39c886efcf4fc68baebed575826bde577ab5aa71d735a9 +880c0f8f49c875dfd62b4ddedde0f5c8b19f5687e693717f7e5c031bc580e58e13ab497d48b4874130a18743c59fdce3 +b582af8d8ff0bf76f0a3934775e0b54c0e8fed893245d7d89cae65b03c8125b7237edc29dc45b4fe1a3fe6db45d280ee +89f337882ed3ae060aaee98efa20d79b6822bde9708c1c5fcee365d0ec9297f694cae37d38fd8e3d49717c1e86f078e7 +826d2c1faea54061848b484e288a5f4de0d221258178cf87f72e14baaa4acc21322f8c9eab5dde612ef497f2d2e1d60b +a5333d4f227543e9cd741ccf3b81db79f2f03ca9e649e40d6a6e8ff9073e06da83683566d3b3c8d7b258c62970fb24d1 +a28f08c473db06aaf4c043a2fae82b3c8cfaa160bce793a4c208e4e168fb1c65115ff8139dea06453c5963d95e922b94 +8162546135cc5e124e9683bdfaa45833c18553ff06a0861c887dc84a5b12ae8cd4697f6794c7ef6230492c32faba7014 +b23f0d05b74c08d6a7df1760792be83a761b36e3f8ae360f3c363fb196e2a9dd2de2e492e49d36561366e14daa77155c +b6f70d6c546722d3907c708d630dbe289771d2c8bf059c2e32b77f224696d750b4dda9b3a014debda38e7d02c9a77585 +83bf4c4a9f3ca022c631017e7a30ea205ba97f7f5927cba8fc8489a4646eac6712cb821c5668c9ffe94d69d524374a27 +b0371475425a8076d0dd5f733f55aabbe42d20a7c8ea7da352e736d4d35a327b2beb370dfcb05284e22cfd69c5f6c4cc +a0031ba7522c79211416c2cca3aa5450f96f8fee711552a30889910970ba13608646538781a2c08b834b140aadd7166f +99d273c80c7f2dc6045d4ed355d9fc6f74e93549d961f4a3b73cd38683f905934d359058cd1fc4da8083c7d75070487f +b0e4b0efa3237793e9dcce86d75aafe9879c5fa23f0d628649aef2130454dcf72578f9bf227b9d2b9e05617468e82588 +a5ab076fa2e1c5c51f3ae101afdd596ad9d106bba7882b359c43d8548b64f528af19afa76cd6f40da1e6c5fca4def3fa +8ce2299e570331d60f6a6eff1b271097cd5f1c0e1113fc69b89c6a0f685dabea3e5bc2ac6bd789aa492ab189f89be494 +91b829068874d911a310a5f9dee001021f97471307b5a3de9ec336870ec597413e1d92010ce320b619f38bed7c4f7910 +b14fe91f4b07bf33b046e9285b66cb07927f3a8da0af548ac2569b4c4fb1309d3ced76d733051a20814e90dd5b75ffd1 +abaab92ea6152d40f82940277c725aa768a631ee0b37f5961667f82fb990fc11e6d3a6a2752b0c6f94563ed9bb28265c +b7fe28543eca2a716859a76ab9092f135337e28109544f6bd2727728d0a7650428af5713171ea60bfc273d1c821d992c +8a4917b2ab749fc7343fc64bdf51b6c0698ff15d740cc7baf248c030475c097097d5a473bcc00d8c25817563fe0447b4 +aa96156d1379553256350a0a3250166add75948fb9cde62aa555a0a9dc0a9cb7f2f7b8428aff66097bf6bfedaf14bbe2 +ae4ffeb9bdc76830d3eca2b705f30c1bdede6412fa064260a21562c8850c7fb611ec62bc68479fe48f692833e6f66d8d +b96543caaba9d051600a14997765d49e4ab10b07c7a92cccf0c90b309e6da334fdd6d18c96806cbb67a7801024fbd3c7 +97b2b9ad76f19f500fcc94ca8e434176249f542ac66e5881a3dccd07354bdab6a2157018b19f8459437a68d8b86ba8e0 +a8d206f6c5a14c80005849474fde44b1e7bcf0b2d52068f5f97504c3c035b09e65e56d1cf4b5322791ae2c2fdbd61859 +936bad397ad577a70cf99bf9056584a61bd7f02d2d5a6cf219c05d770ae30a5cd902ba38366ce636067fc1dd10108d31 +a77e30195ee402b84f3882e2286bf5380c0ed374a112dbd11e16cef6b6b61ab209d4635e6f35cdaaa72c1a1981d5dabe +a46ba4d3947188590a43c180757886a453a0503f79cc435322d92490446f37419c7b999fdf868a023601078070e03346 +80d8d4c5542f223d48240b445d4d8cf6a75d120b060bc08c45e99a13028b809d910b534d2ac47fb7068930c54efd8da9 +803be9c68c91b42b68e1f55e58917a477a9a6265e679ca44ee30d3eb92453f8c89c64eafc04c970d6831edd33d066902 +b14b2b3d0dfe2bb57cee4cd72765b60ac33c1056580950be005790176543826c1d4fbd737f6cfeada6c735543244ab57 +a9e480188bba1b8fb7105ff12215706665fd35bf1117bacfb6ab6985f4dbc181229873b82e5e18323c2b8f5de03258e0 +a66a0f0779436a9a3999996d1e6d3000f22c2cac8e0b29cddef9636393c7f1457fb188a293b6c875b05d68d138a7cc4a +848397366300ab40c52d0dbbdafbafef6cd3dadf1503bb14b430f52bb9724188928ac26f6292a2412bc7d7aa620763c8 +95466cc1a78c9f33a9aaa3829a4c8a690af074916b56f43ae46a67a12bb537a5ac6dbe61590344a25b44e8512355a4a7 +8b5f7a959f818e3baf0887f140f4575cac093d0aece27e23b823cf421f34d6e4ff4bb8384426e33e8ec7b5eed51f6b5c +8d5e1368ec7e3c65640d216bcc5d076f3d9845924c734a34f3558ac0f16e40597c1a775a25bf38b187213fbdba17c93b +b4647c1b823516880f60d20c5cc38c7f80b363c19d191e8992226799718ee26b522a12ecb66556ed3d483aa4824f3326 +ac3abaea9cd283eb347efda4ed9086ea3acf495043e08d0d19945876329e8675224b685612a6badf8fd72fb6274902b1 +8eae1ce292d317aaa71bcf6e77e654914edd5090e2e1ebab78b18bb41b9b1bc2e697439f54a44c0c8aa0d436ebe6e1a9 +94dc7d1aec2c28eb43d93b111fa59aaa0d77d5a09501220bd411768c3e52208806abf973c6a452fd8292ff6490e0c9e2 +8fd8967f8e506fef27d17b435d6b86b232ec71c1036351f12e6fb8a2e12daf01d0ee04451fb944d0f1bf7fd20e714d02 +824e6865be55d43032f0fec65b3480ea89b0a2bf860872237a19a54bc186a85d2f8f9989cc837fbb325b7c72d9babe2c +8bd361f5adb27fd6f4e3f5de866e2befda6a8454efeb704aacc606f528c03f0faae888f60310e49440496abd84083ce2 +b098a3c49f2aaa28b6b3e85bc40ce6a9cdd02134ee522ae73771e667ad7629c8d82c393fba9f27f5416986af4c261438 +b385f5ca285ff2cfe64dcaa32dcde869c28996ed091542600a0b46f65f3f5a38428cca46029ede72b6cf43e12279e3d3 +8196b03d011e5be5288196ef7d47137d6f9237a635ab913acdf9c595fa521d9e2df722090ec7eb0203544ee88178fc5f +8ed1270211ef928db18e502271b7edf24d0bbd11d97f2786aee772d70c2029e28095cf8f650b0328cc8a4c38d045316d +a52ab60e28d69b333d597a445884d44fd2a7e1923dd60f763951e1e45f83e27a4dac745f3b9eff75977b3280e132c15d +91e9fe78cdac578f4a4687f71b800b35da54b824b1886dafec073a3c977ce7a25038a2f3a5b1e35c2c8c9d1a7312417c +a42832173f9d9491c7bd93b21497fbfa4121687cd4d2ab572e80753d7edcbb42cfa49f460026fbde52f420786751a138 +97b947126d84dcc70c97be3c04b3de3f239b1c4914342fa643b1a4bb8c4fe45c0fcb585700d13a7ed50784790c54bef9 +860e407d353eac070e2418ef6cb80b96fc5f6661d6333e634f6f306779651588037be4c2419562c89c61f9aa2c4947f5 +b2c9d93c3ba4e511b0560b55d3501bf28a510745fd666b3cb532db051e6a8617841ea2f071dda6c9f15619c7bfd2737f +8596f4d239aeeac78311207904d1bd863ef68e769629cc379db60e019aaf05a9d5cd31dc8e630b31e106a3a93e47cbc5 +8b26e14e2e136b65c5e9e5c2022cee8c255834ea427552f780a6ca130a6446102f2a6f334c3f9a0308c53df09e3dba7e +b54724354eb515a3c8bed0d0677ff1db94ac0a07043459b4358cb90e3e1aa38ac23f2caa3072cf9647275d7cd61d0e80 +b7ce9fe0e515e7a6b2d7ddcb92bc0196416ff04199326aea57996eef8c5b1548bd8569012210da317f7c0074691d01b7 +a1a13549c82c877253ddefa36a29ea6a23695ee401fdd48e65f6f61e5ebd956d5e0edeff99484e9075cb35071fec41e2 +838ba0c1e5bd1a6da05611ff1822b8622457ebd019cb065ece36a2d176bd2d889511328120b8a357e44569e7f640c1e6 +b916eccff2a95519400bbf76b5f576cbe53cf200410370a19d77734dc04c05b585cfe382e8864e67142d548cd3c4c2f4 +a610447cb7ca6eea53a6ff1f5fe562377dcb7f4aaa7300f755a4f5e8eba61e863c51dc2aa9a29b35525b550fbc32a0fe +9620e8f0f0ee9a4719aa9685eeb1049c5c77659ba6149ec4c158f999cfd09514794b23388879931fe26fea03fa471fd3 +a9dcf8b679e276583cf5b9360702a185470d09aea463dc474ee9c8aee91ef089dacb073e334e47fbc78ec5417c90465c +8c9adee8410bdd99e5b285744cee61e2593b6300ff31a8a83b0ec28da59475a5c6fb9346fe43aadea2e6c3dad2a8e30a +97d5afe9b3897d7b8bb628b7220cf02d8ee4e9d0b78f5000d500aaf4c1df9251aaaabfd1601626519f9d66f00a821d4e +8a382418157b601ce4c3501d3b8409ca98136a4ef6abcbf62885e16e215b76b035c94d149cc41ff92e42ccd7c43b9b3d +b64b8d11fb3b01abb2646ac99fdb9c02b804ce15d98f9fe0fbf1c9df8440c71417487feb6cdf51e3e81d37104b19e012 +849d7d044f9d8f0aab346a9374f0b3a5d14a9d1faa83dbacccbdc629ad1ef903a990940255564770537f8567521d17f0 +829dbb0c76b996c2a91b4cbbe93ba455ca0d5729755e5f0c92aaee37dff7f36fcdc06f33aca41f1b609c784127b67d88 +85a7c0069047b978422d264d831ab816435f63938015d2e977222b6b5746066c0071b7f89267027f8a975206ed25c1b0 +84b9fbc1cfb302df1acdcf3dc5d66fd1edfe7839f7a3b2fb3a0d5548656249dd556104d7c32b73967bccf0f5bdcf9e3b +972220ac5b807f53eac37dccfc2ad355d8b21ea6a9c9b011c09fe440ddcdf7513e0b43d7692c09ded80d7040e26aa28f +855885ed0b21350baeca890811f344c553cf9c21024649c722453138ba29193c6b02c4b4994cd414035486f923472e28 +841874783ae6d9d0e59daea03e96a01cbbe4ecaced91ae4f2c8386e0d87b3128e6d893c98d17c59e4de1098e1ad519dd +827e50fc9ce56f97a4c3f2f4cbaf0b22f1c3ce6f844ff0ef93a9c57a09b8bf91ebfbd2ba9c7f83c442920bffdaf288cc +a441f9136c7aa4c08d5b3534921b730e41ee91ab506313e1ba5f7c6f19fd2d2e1594e88c219834e92e6fb95356385aa7 +97d75b144471bf580099dd6842b823ec0e6c1fb86dd0da0db195e65524129ea8b6fd4a7a9bbf37146269e938a6956596 +a4b6fa87f09d5a29252efb2b3aaab6b3b6ea9fab343132a651630206254a25378e3e9d6c96c3d14c150d01817d375a8e +a31a671876d5d1e95fe2b8858dc69967231190880529d57d3cab7f9f4a2b9b458ac9ee5bdaa3289158141bf18f559efb +90bee6fff4338ba825974021b3b2a84e36d617e53857321f13d2b3d4a28954e6de3b3c0e629d61823d18a9763313b3bf +96b622a63153f393bb419bfcf88272ea8b3560dbd46b0aa07ada3a6223990d0abdd6c2adb356ef4be5641688c8d83941 +84c202adeaff9293698022bc0381adba2cd959f9a35a4e8472288fd68f96f6de8be9da314c526d88e291c96b1f3d6db9 +8ca01a143b8d13809e5a8024d03e6bc9492e22226073ef6e327edf1328ef4aff82d0bcccee92cb8e212831fa35fe1204 +b2f970dbad15bfbefb38903c9bcc043d1367055c55dc1100a850f5eb816a4252c8c194b3132c929105511e14ea10a67d +a5e36556472a95ad57eb90c3b6623671b03eafd842238f01a081997ffc6e2401f76e781d049bb4aa94d899313577a9cf +8d1057071051772f7c8bedce53a862af6fd530dd56ae6321eaf2b9fc6a68beff5ed745e1c429ad09d5a118650bfd420a +8aadc4f70ace4fcb8d93a78610779748dcffc36182d45b932c226dc90e48238ea5daa91f137c65ed532352c4c4d57416 +a2ea05ae37e673b4343232ae685ee14e6b88b867aef6dfac35db3589cbcd76f99540fed5c2641d5bb5a4a9f808e9bf0d +947f1abad982d65648ae4978e094332b4ecb90f482c9be5741d5d1cf5a28acf4680f1977bf6e49dd2174c37f11e01296 +a27b144f1565e4047ba0e3f4840ef19b5095d1e281eaa463c5358f932114cbd018aa6dcf97546465cf2946d014d8e6d6 +8574e1fc3acade47cd4539df578ce9205e745e161b91e59e4d088711a7ab5aa3b410d517d7304b92109924d9e2af8895 +a48ee6b86b88015d6f0d282c1ae01d2a5b9e8c7aa3d0c18b35943dceb1af580d08a65f54dc6903cde82fd0d73ce94722 +8875650cec543a7bf02ea4f2848a61d167a66c91ffaefe31a9e38dc8511c6a25bde431007eefe27a62af3655aca208dc +999b0a6e040372e61937bf0d68374e230346b654b5a0f591a59d33a4f95bdb2f3581db7c7ccb420cd7699ed709c50713 +878c9e56c7100c5e47bbe77dc8da5c5fe706cec94d37fa729633bca63cace7c40102eee780fcdabb655f5fa47a99600e +865006fb5b475ada5e935f27b96f9425fc2d5449a3c106aa366e55ebed3b4ee42adc3c3f0ac19fd129b40bc7d6bc4f63 +b7a7da847f1202e7bc1672553e68904715e84fd897d529243e3ecda59faa4e17ba99c649a802d53f6b8dfdd51f01fb74 +8b2fb4432c05653303d8c8436473682933a5cb604da10c118ecfcd2c8a0e3132e125afef562bdbcc3df936164e5ce4f2 +808d95762d33ddfa5d0ee3d7d9f327de21a994d681a5f372e2e3632963ea974da7f1f9e5bac8ccce24293509d1f54d27 +932946532e3c397990a1df0e94c90e1e45133e347a39b6714c695be21aeb2d309504cb6b1dde7228ff6f6353f73e1ca2 +9705e7c93f0cdfaa3fa96821f830fe53402ad0806036cd1b48adc2f022d8e781c1fbdab60215ce85c653203d98426da3 +aa180819531c3ec1feb829d789cb2092964c069974ae4faad60e04a6afcce5c3a59aec9f11291e6d110a788d22532bc6 +88f755097f7e25cb7dd3c449520c89b83ae9e119778efabb54fbd5c5714b6f37c5f9e0346c58c6ab09c1aef2483f895d +99fc03ab7810e94104c494f7e40b900f475fde65bdec853e60807ffd3f531d74de43335c3b2646b5b8c26804a7448898 +af2dea9683086bed1a179110efb227c9c00e76cd00a2015b089ccbcee46d1134aa18bda5d6cab6f82ae4c5cd2461ac21 +a500f87ba9744787fdbb8e750702a3fd229de6b8817594348dec9a723b3c4240ddfa066262d002844b9e38240ce55658 +924d0e45c780f5bc1c1f35d15dfc3da28036bdb59e4c5440606750ecc991b85be18bc9a240b6c983bc5430baa4c68287 +865b11e0157b8bf4c5f336024b016a0162fc093069d44ac494723f56648bc4ded13dfb3896e924959ea11c96321afefc +93672d8607d4143a8f7894f1dcca83fb84906dc8d6dd7dd063bb0049cfc20c1efd933e06ca7bd03ea4cb5a5037990bfe +826891efbdff0360446825a61cd1fa04326dd90dae8c33dfb1ed97b045e165766dd070bd7105560994d0b2044bdea418 +93c4a4a8bcbc8b190485cc3bc04175b7c0ed002c28c98a540919effd6ed908e540e6594f6db95cd65823017258fb3b1c +aeb2a0af2d2239fda9aa6b8234b019708e8f792834ff0dd9c487fa09d29800ddceddd6d7929faa9a3edcb9e1b3aa0d6b +87f11de7236d387863ec660d2b04db9ac08143a9a2c4dfff87727c95b4b1477e3bc473a91e5797313c58754905079643 +80dc1db20067a844fe8baceca77f80db171a5ca967acb24e2d480eae9ceb91a3343c31ad1c95b721f390829084f0eae6 +9825c31f1c18da0de3fa84399c8b40f8002c3cae211fb6a0623c76b097b4d39f5c50058f57a16362f7a575909d0a44a2 +a99fc8de0c38dbf7b9e946de83943a6b46a762167bafe2a603fb9b86f094da30d6de7ed55d639aafc91936923ee414b3 +ad594678b407db5d6ea2e90528121f84f2b96a4113a252a30d359a721429857c204c1c1c4ff71d8bb5768c833f82e80e +b33d985e847b54510b9b007e31053732c8a495e43be158bd2ffcea25c6765bcbc7ca815f7c60b36ad088b955dd6e9350 +815f8dfc6f90b3342ca3fbd968c67f324dae8f74245cbf8bc3bef10e9440c65d3a2151f951e8d18959ba01c1b50b0ec1 +94c608a362dd732a1abc56e338637c900d59013db8668e49398b3c7a0cae3f7e2f1d1bf94c0299eeafe6af7f76c88618 +8ebd8446b23e5adfcc393adc5c52fe172f030a73e63cd2d515245ca0dd02782ceed5bcdd9ccd9c1b4c5953dfac9c340c +820437f3f6f9ad0f5d7502815b221b83755eb8dc56cd92c29e9535eb0b48fb8d08c9e4fcc26945f9c8cca60d89c44710 +8910e4e8a56bf4be9cc3bbf0bf6b1182a2f48837a2ed3c2aaec7099bfd7f0c83e14e608876b17893a98021ff4ab2f20d +9633918fde348573eec15ce0ad53ac7e1823aac86429710a376ad661002ae6d049ded879383faaa139435122f64047c6 +a1f5e3fa558a9e89318ca87978492f0fb4f6e54a9735c1b8d2ecfb1d1c57194ded6e0dd82d077b2d54251f3bee1279e1 +b208e22d04896abfd515a95c429ff318e87ff81a5d534c8ac2c33c052d6ffb73ef1dccd39c0bbe0734b596c384014766 +986d5d7d2b5bde6d16336f378bd13d0e671ad23a8ec8a10b3fc09036faeeb069f60662138d7a6df3dfb8e0d36180f770 +a2d4e6c5f5569e9cef1cddb569515d4b6ace38c8aed594f06da7434ba6b24477392cc67ba867c2b079545ca0c625c457 +b5ac32b1d231957d91c8b7fc43115ce3c5c0d8c13ca633374402fa8000b6d9fb19499f9181844f0c10b47357f3f757ce +96b8bf2504b4d28fa34a4ec378e0e0b684890c5f44b7a6bb6e19d7b3db2ab27b1e2686389d1de9fbd981962833a313ea +953bfd7f6c3a0469ad432072b9679a25486f5f4828092401eff494cfb46656c958641a4e6d0d97d400bc59d92dba0030 +876ab3cea7484bbfd0db621ec085b9ac885d94ab55c4bb671168d82b92e609754b86aaf472c55df3d81421d768fd108a +885ff4e67d9ece646d02dd425aa5a087e485c3f280c3471b77532b0db6145b69b0fbefb18aa2e3fa5b64928b43a94e57 +b91931d93f806d0b0e6cc62a53c718c099526140f50f45d94b8bbb57d71e78647e06ee7b42aa5714aed9a5c05ac8533f +a0313eeadd39c720c9c27b3d671215331ab8d0a794e71e7e690f06bcd87722b531d6525060c358f35f5705dbb7109ccb +874c0944b7fedc6701e53344100612ddcb495351e29305c00ec40a7276ea5455465ffb7bded898886c1853139dfb1fc7 +8dc31701a01ee8137059ca1874a015130d3024823c0576aa9243e6942ec99d377e7715ed1444cd9b750a64b85dcaa3e5 +836d2a757405e922ec9a2dfdcf489a58bd48b5f9683dd46bf6047688f778c8dee9bc456de806f70464df0b25f3f3d238 +b30b0a1e454a503ea3e2efdec7483eaf20b0a5c3cefc42069e891952b35d4b2c955cf615f3066285ed8fafd9fcfbb8f6 +8e6d4044b55ab747e83ec8762ea86845f1785cc7be0279c075dadf08aca3ccc5a096c015bb3c3f738f647a4eadea3ba5 +ad7735d16ab03cbe09c029610aa625133a6daecfc990b297205b6da98eda8c136a7c50db90f426d35069708510d5ae9c +8d62d858bbb59ec3c8cc9acda002e08addab4d3ad143b3812098f3d9087a1b4a1bb255dcb1635da2402487d8d0249161 +805beec33238b832e8530645a3254aeef957e8f7ea24bcfc1054f8b9c69421145ebb8f9d893237e8a001c857fedfc77e +b1005644be4b085e3f5775aa9bd3e09a283e87ddada3082c04e7a62d303dcef3b8cf8f92944c200c7ae6bb6bdf63f832 +b4ba0e0790dc29063e577474ffe3b61f5ea2508169f5adc1e394934ebb473e356239413a17962bc3e5d3762d72cce8c2 +a157ba9169c9e3e6748d9f1dd67fbe08b9114ade4c5d8fc475f87a764fb7e6f1d21f66d7905cd730f28a1c2d8378682a +913e52b5c93989b5d15e0d91aa0f19f78d592bc28bcfdfddc885a9980c732b1f4debb8166a7c4083c42aeda93a702898 +90fbfc1567e7cd4e096a38433704d3f96a2de2f6ed3371515ccc30bc4dd0721a704487d25a97f3c3d7e4344472702d8d +89646043028ffee4b69d346907586fd12c2c0730f024acb1481abea478e61031966e72072ff1d5e65cb8c64a69ad4eb1 +b125a45e86117ee11d2fb42f680ab4a7894edd67ff927ae2c808920c66c3e55f6a9d4588eee906f33a05d592e5ec3c04 +aad47f5b41eae9be55fb4f67674ff1e4ae2482897676f964a4d2dcb6982252ee4ff56aac49578b23f72d1fced707525e +b9ddff8986145e33851b4de54d3e81faa3352e8385895f357734085a1616ef61c692d925fe62a5ed3be8ca49f5d66306 +b3cb0963387ed28c0c0adf7fe645f02606e6e1780a24d6cecef5b7c642499109974c81a7c2a198b19862eedcea2c2d8c +ac9c53c885457aaf5cb36c717a6f4077af701e0098eebd7aa600f5e4b14e6c1067255b3a0bc40e4a552025231be7de60 +8e1a8d823c4603f6648ec21d064101094f2a762a4ed37dd2f0a2d9aa97b2d850ce1e76f4a4b8cae58819b058180f7031 +b268b73bf7a179b6d22bd37e5e8cb514e9f5f8968c78e14e4f6d5700ca0d0ca5081d0344bb73b028970eebde3cb4124e +a7f57d71940f0edbd29ed8473d0149cae71d921dd15d1ff589774003e816b54b24de2620871108cec1ab9fa956ad6ce6 +8053e6416c8b120e2b999cc2fc420a6a55094c61ac7f2a6c6f0a2c108a320890e389af96cbe378936132363c0d551277 +b3823f4511125e5aa0f4269e991b435a0d6ceb523ebd91c04d7add5534e3df5fc951c504b4fd412a309fd3726b7f940b +ae6eb04674d04e982ca9a6add30370ab90e303c71486f43ed3efbe431af1b0e43e9d06c11c3412651f304c473e7dbf39 +96ab55e641ed2e677591f7379a3cd126449614181fce403e93e89b1645d82c4af524381ff986cae7f9cebe676878646d +b52423b4a8c37d3c3e2eca8f0ddbf7abe0938855f33a0af50f117fab26415fb0a3da5405908ec5fdc22a2c1f2ca64892 +82a69ce1ee92a09cc709d0e3cd22116c9f69d28ea507fe5901f5676000b5179b9abe4c1875d052b0dd42d39925e186bb +a84c8cb84b9d5cfb69a5414f0a5283a5f2e90739e9362a1e8c784b96381b59ac6c18723a4aa45988ee8ef5c1f45cc97d +afd7efce6b36813082eb98257aae22a4c1ae97d51cac7ea9c852d4a66d05ef2732116137d8432e3f117119725a817d24 +a0f5fe25af3ce021b706fcff05f3d825384a272284d04735574ce5fb256bf27100fad0b1f1ba0e54ae9dcbb9570ecad3 +8751786cb80e2e1ff819fc7fa31c2833d25086534eb12b373d31f826382430acfd87023d2a688c65b5e983927e146336 +8cf5c4b17fa4f3d35c78ce41e1dc86988fd1135cd5e6b2bb0c108ee13538d0d09ae7102609c6070f39f937b439b31e33 +a9108967a2fedd7c322711eca8159c533dd561bedcb181b646de98bf5c3079449478eab579731bee8d215ae8852c7e21 +b54c5171704f42a6f0f4e70767cdb3d96ffc4888c842eece343a01557da405961d53ffdc34d2f902ea25d3e1ed867cad +ae8d4b764a7a25330ba205bf77e9f46182cd60f94a336bbd96773cf8064e3d39caf04c310680943dc89ed1fbad2c6e0d +aa5150e911a8e1346868e1b71c5a01e2a4bb8632c195861fb6c3038a0e9b85f0e09b3822e9283654a4d7bb17db2fc5f4 +9685d3756ce9069bf8bb716cf7d5063ebfafe37e15b137fc8c3159633c4e006ff4887ddd0ae90360767a25c3f90cba7f +82155fd70f107ab3c8e414eadf226c797e07b65911508c76c554445422325e71af8c9a8e77fd52d94412a6fc29417cd3 +abfae52f53a4b6e00760468d973a267f29321997c3dbb5aee36dc1f20619551229c0c45b9d9749f410e7f531b73378e8 +81a76d921f8ef88e774fd985e786a4a330d779b93fad7def718c014685ca0247379e2e2a007ad63ee7f729cd9ed6ce1b +81947c84bc5e28e26e2e533af5ae8fe10407a7b77436dbf8f1d5b0bbe86fc659eae10f974659dc7c826c6dabd03e3a4b +92b8c07050d635b8dd4fd09df9054efe4edae6b86a63c292e73cc819a12a21dd7d104ce51fa56af6539dedf6dbe6f7b6 +b44c579e3881f32b32d20c82c207307eca08e44995dd2aac3b2692d2c8eb2a325626c80ac81c26eeb38c4137ff95add5 +97efab8941c90c30860926dea69a841f2dcd02980bf5413b9fd78d85904588bf0c1021798dbc16c8bbb32cce66c82621 +913363012528b50698e904de0588bf55c8ec5cf6f0367cfd42095c4468fcc64954fbf784508073e542fee242d0743867 +8ed203cf215148296454012bd10fddaf119203db1919a7b3d2cdc9f80e66729464fdfae42f1f2fc5af1ed53a42b40024 +ab84312db7b87d711e9a60824f4fe50e7a6190bf92e1628688dfcb38930fe87b2d53f9e14dd4de509b2216856d8d9188 +880726def069c160278b12d2258eac8fa63f729cd351a710d28b7e601c6712903c3ac1e7bbd0d21e4a15f13ca49db5aa +980699cd51bac6283959765f5174e543ed1e5f5584b5127980cbc2ef18d984ecabba45042c6773b447b8e694db066028 +aeb019cb80dc4cb4207430d0f2cd24c9888998b6f21d9bf286cc638449668d2eec0018a4cf3fe6448673cd6729335e2b +b29852f6aa6c60effdffe96ae88590c88abae732561d35cc19e82d3a51e26cb35ea00986193e07f90060756240f5346e +a0fa855adc5ba469f35800c48414b8921455950a5c0a49945d1ef6e8f2a1881f2e2dfae47de6417270a6bf49deeb091d +b6c7332e3b14813641e7272d4f69ecc7e09081df0037d6dab97ce13a9e58510f5c930d300633f208181d9205c5534001 +85a6c050f42fce560b5a8d54a11c3bbb8407abbadd859647a7b0c21c4b579ec65671098b74f10a16245dc779dff7838e +8f3eb34bb68759d53c6677de4de78a6c24dd32c8962a7fb355ed362572ef8253733e6b52bc21c9f92ecd875020a9b8de +a17dd44181e5dab4dbc128e1af93ec22624b57a448ca65d2d9e246797e4af7d079e09c6e0dfb62db3a9957ce92f098d5 +a56a1b854c3183082543a8685bb34cae1289f86cfa8123a579049dbd059e77982886bfeb61bf6e05b4b1fe4e620932e7 +aedae3033cb2fb7628cb4803435bdd7757370a86f808ae4cecb9a268ad0e875f308c048c80cbcac523de16b609683887 +9344905376aa3982b1179497fac5a1d74b14b7038fd15e3b002db4c11c8bfc7c39430db492cdaf58b9c47996c9901f28 +a3bfafdae011a19f030c749c3b071f83580dee97dd6f949e790366f95618ca9f828f1daaeabad6dcd664fcef81b6556d +81c03d8429129e7e04434dee2c529194ddb01b414feda3adee2271eb680f6c85ec872a55c9fa9d2096f517e13ed5abcc +98205ef3a72dff54c5a9c82d293c3e45d908946fa74bb749c3aabe1ab994ea93c269bcce1a266d2fe67a8f02133c5985 +85a70aeed09fda24412fadbafbbbf5ba1e00ac92885df329e147bfafa97b57629a3582115b780d8549d07d19b7867715 +b0fbe81c719f89a57d9ea3397705f898175808c5f75f8eb81c2193a0b555869ba7bd2e6bc54ee8a60cea11735e21c68c +b03a0bd160495ee626ff3a5c7d95bc79d7da7e5a96f6d10116600c8fa20bedd1132f5170f25a22371a34a2d763f2d6d0 +a90ab04091fbca9f433b885e6c1d60ab45f6f1daf4b35ec22b09909d493a6aab65ce41a6f30c98239cbca27022f61a8b +b66f92aa3bf2549f9b60b86f99a0bd19cbdd97036d4ae71ca4b83d669607f275260a497208f6476cde1931d9712c2402 +b08e1fdf20e6a9b0b4942f14fa339551c3175c1ffc5d0ab5b226b6e6a322e9eb0ba96adc5c8d59ca4259e2bdd04a7eb0 +a2812231e92c1ce74d4f5ac3ab6698520288db6a38398bb38a914ac9326519580af17ae3e27cde26607e698294022c81 +abfcbbcf1d3b9e84c02499003e490a1d5d9a2841a9e50c7babbef0b2dd20d7483371d4dc629ba07faf46db659459d296 +b0fe9f98c3da70927c23f2975a9dc4789194d81932d2ad0f3b00843dd9cbd7fb60747a1da8fe5a79f136a601becf279d +b130a6dba7645165348cb90f023713bed0eefbd90a976b313521c60a36d34f02032e69a2bdcf5361e343ed46911297ec +862f0cffe3020cea7a5fd4703353aa1eb1be335e3b712b29d079ff9f7090d1d8b12013011e1bdcbaa80c44641fd37c9f +8c6f11123b26633e1abb9ed857e0bce845b2b3df91cc7b013b2fc77b477eee445da0285fc6fc793e29d5912977f40916 +91381846126ea819d40f84d3005e9fb233dc80071d1f9bb07f102bf015f813f61e5884ffffb4f5cd333c1b1e38a05a58 +8add7d908de6e1775adbd39c29a391f06692b936518db1f8fde74eb4f533fc510673a59afb86e3a9b52ade96e3004c57 +8780e086a244a092206edcde625cafb87c9ab1f89cc3e0d378bc9ee776313836160960a82ec397bc3800c0a0ec3da283 +a6cb4cd9481e22870fdd757fae0785edf4635e7aacb18072fe8dc5876d0bab53fb99ce40964a7d3e8bcfff6f0ab1332f +af30ff47ecc5b543efba1ba4706921066ca8bb625f40e530fb668aea0551c7647a9d126e8aba282fbcce168c3e7e0130 +91b0bcf408ce3c11555dcb80c4410b5bc2386d3c05caec0b653352377efdcb6bab4827f2018671fc8e4a0e90d772acc1 +a9430b975ef138b6b2944c7baded8fe102d31da4cfe3bd3d8778bda79189c99d38176a19c848a19e2d1ee0bddd9a13c1 +aa5a4eef849d7c9d2f4b018bd01271c1dd83f771de860c4261f385d3bdcc130218495860a1de298f14b703ec32fa235f +b0ce79e7f9ae57abe4ff366146c3b9bfb38b0dee09c28c28f5981a5d234c6810ad4d582751948affb480d6ae1c8c31c4 +b75122748560f73d15c01a8907d36d06dc068e82ce22b84b322ac1f727034493572f7907dec34ebc3ddcc976f2f89ed7 +b0fc7836369a3e4411d34792d6bd5617c14f61d9bba023dda64e89dc5fb0f423244e9b48ee64869258931daa9753a56f +8956d7455ae9009d70c6e4a0bcd7610e55f37494cf9897a8f9e1b904cc8febc3fd2d642ebd09025cfff4609ad7e3bc52 +ad741efe9e472026aa49ae3d9914cb9c1a6f37a54f1a6fe6419bebd8c7d68dca105a751c7859f4389505ede40a0de786 +b52f418797d719f0d0d0ffb0846788b5cba5d0454a69a2925de4b0b80fa4dd7e8c445e5eac40afd92897ed28ca650566 +a0ab65fb9d42dd966cd93b1de01d7c822694669dd2b7a0c04d99cd0f3c3de795f387b9c92da11353412f33af5c950e9a +a0052f44a31e5741a331f7cac515a08b3325666d388880162d9a7b97598fde8b61f9ff35ff220df224eb5c4e40ef0567 +a0101cfdc94e42b2b976c0d89612a720e55d145a5ef6ef6f1f78cf6de084a49973d9b5d45915349c34ce712512191e3c +a0dd99fcf3f5cead5aaf08e82212df3a8bb543c407a4d6fab88dc5130c1769df3f147e934a46f291d6c1a55d92b86917 +a5939153f0d1931bbda5cf6bdf20562519ea55fbfa978d6dbc6828d298260c0da7a50c37c34f386e59431301a96c2232 +9568269f3f5257200f9ca44afe1174a5d3cf92950a7f553e50e279c239e156a9faaa2a67f288e3d5100b4142efe64856 +b746b0832866c23288e07f24991bbf687cad794e7b794d3d3b79367566ca617d38af586cdc8d6f4a85a34835be41d54f +a871ce28e39ab467706e32fec1669fda5a4abba2f8c209c6745df9f7a0fa36bbf1919cf14cb89ea26fa214c4c907ae03 +a08dacdd758e523cb8484f6bd070642c0c20e184abdf8e2a601f61507e93952d5b8b0c723c34fcbdd70a8485eec29db2 +85bdb78d501382bb95f1166b8d032941005661aefd17a5ac32df9a3a18e9df2fc5dc2c1f07075f9641af10353cecc0c9 +98d730c28f6fa692a389e97e368b58f4d95382fad8f0baa58e71a3d7baaea1988ead47b13742ce587456f083636fa98e +a557198c6f3d5382be9fb363feb02e2e243b0c3c61337b3f1801c4a0943f18e38ce1a1c36b5c289c8fa2aa9d58742bab +89174f79201742220ac689c403fc7b243eed4f8e3f2f8aba0bf183e6f5d4907cb55ade3e238e3623d9885f03155c4d2b +b891d600132a86709e06f3381158db300975f73ea4c1f7c100358e14e98c5fbe792a9af666b85c4e402707c3f2db321e +b9e5b2529ef1043278c939373fc0dbafe446def52ddd0a8edecd3e4b736de87e63e187df853c54c28d865de18a358bb6 +8589b2e9770340c64679062c5badb7bbef68f55476289b19511a158a9a721f197da03ece3309e059fc4468b15ac33aa3 +aad8c6cd01d785a881b446f06f1e9cd71bca74ba98674c2dcddc8af01c40aa7a6d469037498b5602e76e9c91a58d3dbd +abaccb1bd918a8465f1bf8dbe2c9ad4775c620b055550b949a399f30cf0d9eb909f3851f5b55e38f9e461e762f88f499 +ae62339d26db46e85f157c0151bd29916d5cc619bd4b832814b3fd2f00af8f38e7f0f09932ffe5bba692005dab2d9a74 +93a6ff30a5c0edf8058c89aba8c3259e0f1b1be1b80e67682de651e5346f7e1b4b4ac3d87cbaebf198cf779524aff6bf +8980a2b1d8f574af45b459193c952400b10a86122b71fca2acb75ee0dbd492e7e1ef5b959baf609a5172115e371f3177 +8c2f49f3666faee6940c75e8c7f6f8edc3f704cca7a858bbb7ee5e96bba3b0cf0993996f781ba6be3b0821ef4cb75039 +b14b9e348215b278696018330f63c38db100b0542cfc5be11dc33046e3bca6a13034c4ae40d9cef9ea8b34fef0910c4e +b59bc3d0a30d66c16e6a411cb641f348cb1135186d5f69fda8b0a0934a5a2e7f6199095ba319ec87d3fe8f1ec4a06368 +8874aca2a3767aa198e4c3fec2d9c62d496bc41ff71ce242e9e082b7f38cdf356089295f80a301a3cf1182bde5308c97 +b1820ebd61376d91232423fc20bf008b2ba37e761199f4ef0648ea2bd70282766799b4de814846d2f4d516d525c8daa7 +a6b202e5dedc16a4073e04a11af3a8509b23dfe5a1952f899adeb240e75c3f5bde0c424f811a81ea48d343591faffe46 +a69becee9c93734805523b92150a59a62eed4934f66056b645728740d42223f2925a1ad38359ba644da24d9414f4cdda +ad72f0f1305e37c7e6b48c272323ee883320994cb2e0d850905d6655fafc9f361389bcb9c66b3ff8d2051dbb58c8aa96 +b563600bd56fad7c8853af21c6a02a16ed9d8a8bbeea2c31731d63b976d83cb05b9779372d898233e8fd597a75424797 +b0abb78ce465bf7051f563c62e8be9c57a2cc997f47c82819300f36e301fefd908894bb2053a9d27ce2d0f8c46d88b5b +a071a85fb8274bac2202e0cb8e0e2028a5e138a82d6e0374d39ca1884a549c7c401312f00071b91f455c3a2afcfe0cda +b931c271513a0f267b9f41444a5650b1918100b8f1a64959c552aff4e2193cc1b9927906c6fa7b8a8c68ef13d79aaa52 +a6a1bb9c7d32cb0ca44d8b75af7e40479fbce67d216b48a2bb680d3f3a772003a49d3cd675fc64e9e0f8fabeb86d6d61 +b98d609858671543e1c3b8564162ad828808bb50ded261a9f8690ded5b665ed8368c58f947365ed6e84e5a12e27b423d +b3dca58cd69ec855e2701a1d66cad86717ff103ef862c490399c771ad28f675680f9500cb97be48de34bcdc1e4503ffd +b34867c6735d3c49865e246ddf6c3b33baf8e6f164db3406a64ebce4768cb46b0309635e11be985fee09ab7a31d81402 +acb966c554188c5b266624208f31fab250b3aa197adbdd14aee5ab27d7fb886eb4350985c553b20fdf66d5d332bfd3fe +943c36a18223d6c870d54c3b051ef08d802b85e9dd6de37a51c932f90191890656c06adfa883c87b906557ae32d09da0 +81bca7954d0b9b6c3d4528aadf83e4bc2ef9ea143d6209bc45ae9e7ae9787dbcd8333c41f12c0b6deee8dcb6805e826a +aba176b92256efb68f574e543479e5cf0376889fb48e3db4ebfb7cba91e4d9bcf19dcfec444c6622d9398f06de29e2b9 +b9f743691448053216f6ece7cd699871fff4217a1409ceb8ab7bdf3312d11696d62c74b0664ba0a631b1e0237a8a0361 +a383c2b6276fa9af346b21609326b53fb14fdf6f61676683076e80f375b603645f2051985706d0401e6fbed7eb0666b6 +a9ef2f63ec6d9beb8f3d04e36807d84bda87bdd6b351a3e4a9bf7edcb5618c46c1f58cfbf89e64b40f550915c6988447 +a141b2d7a82f5005eaea7ae7d112c6788b9b95121e5b70b7168d971812f3381de8b0082ac1f0a82c7d365922ebd2d26a +b1b76ef8120e66e1535c17038b75255a07849935d3128e3e99e56567b842fb1e8d56ef932d508d2fb18b82f7868fe1a9 +8e2e234684c81f21099f5c54f6bbe2dd01e3b172623836c77668a0c49ce1fe218786c3827e4d9ae2ea25c50a8924fb3c +a5caf5ff948bfd3c4ca3ffbdfcd91eec83214a6c6017235f309a0bbf7061d3b0b466307c00b44a1009cf575163898b43 +986415a82ca16ebb107b4c50b0c023c28714281db0bcdab589f6cb13d80e473a3034b7081b3c358e725833f6d845cb14 +b94836bf406ac2cbacb10e6df5bcdfcc9d9124ae1062767ca4e322d287fd5e353fdcebd0e52407cb3cd68571258a8900 +83c6d70a640b33087454a4788dfd9ef3ed00272da084a8d36be817296f71c086b23b576f98178ab8ca6a74f04524b46b +ad4115182ad784cfe11bcfc5ce21fd56229cc2ce77ac82746e91a2f0aa53ca6593a22efd2dc4ed8d00f84542643d9c58 +ab1434c5e5065da826d10c2a2dba0facccab0e52b506ce0ce42fbe47ced5a741797151d9ecc99dc7d6373cfa1779bbf6 +8a8b591d82358d55e6938f67ea87a89097ab5f5496f7260adb9f649abb289da12b498c5b2539c2f9614fb4e21b1f66b0 +964f355d603264bc1f44c64d6d64debca66f37dff39c971d9fc924f2bc68e6c187b48564a6dc82660a98b035f8addb5d +b66235eaaf47456bc1dc4bde454a028e2ce494ece6b713a94cd6bf27cf18c717fd0c57a5681caaa2ad73a473593cdd7a +9103e3bb74304186fa4e3e355a02da77da4aca9b7e702982fc2082af67127ebb23a455098313c88465bc9b7d26820dd5 +b6a42ff407c9dd132670cdb83cbad4b20871716e44133b59a932cd1c3f97c7ac8ff7f61acfaf8628372508d8dc8cad7c +883a9c21c16a167a4171b0f084565c13b6f28ba7c4977a0de69f0a25911f64099e7bbb4da8858f2e93068f4155d04e18 +8dbb3220abc6a43220adf0331e3903d3bfd1d5213aadfbd8dfcdf4b2864ce2e96a71f35ecfb7a07c3bbabf0372b50271 +b4ad08aee48e176bda390b7d9acf2f8d5eb008f30d20994707b757dc6a3974b2902d29cd9b4d85e032810ad25ac49e97 +865bb0f33f7636ec501bb634e5b65751c8a230ae1fa807a961a8289bbf9c7fe8c59e01fbc4c04f8d59b7f539cf79ddd5 +86a54d4c12ad1e3605b9f93d4a37082fd26e888d2329847d89afa7802e815f33f38185c5b7292293d788ad7d7da1df97 +b26c8615c5e47691c9ff3deca3021714662d236c4d8401c5d27b50152ce7e566266b9d512d14eb63e65bc1d38a16f914 +827639d5ce7db43ba40152c8a0eaad443af21dc92636cc8cc2b35f10647da7d475a1e408901cd220552fddad79db74df +a2b79a582191a85dbe22dc384c9ca3de345e69f6aa370aa6d3ff1e1c3de513e30b72df9555b15a46586bd27ea2854d9d +ae0d74644aba9a49521d3e9553813bcb9e18f0b43515e4c74366e503c52f47236be92dfbd99c7285b3248c267b1de5a0 +80fb0c116e0fd6822a04b9c25f456bdca704e2be7bdc5d141dbf5d1c5eeb0a2c4f5d80db583b03ef3e47517e4f9a1b10 +ac3a1fa3b4a2f30ea7e0a114cdc479eb51773573804c2a158d603ad9902ae8e39ffe95df09c0d871725a5d7f9ba71a57 +b56b2b0d601cba7f817fa76102c68c2e518c6f20ff693aad3ff2e07d6c4c76203753f7f91686b1801e8c4659e4d45c48 +89d50c1fc56e656fb9d3915964ebce703cb723fe411ab3c9eaa88ccc5d2b155a9b2e515363d9c600d3c0cee782c43f41 +b24207e61462f6230f3cd8ccf6828357d03e725769f7d1de35099ef9ee4dca57dbce699bb49ed994462bee17059d25ce +b886f17fcbcbfcd08ac07f04bb9543ef58510189decaccea4b4158c9174a067cb67d14b6be3c934e6e2a18c77efa9c9c +b9c050ad9cafd41c6e2e192b70d080076eed59ed38ea19a12bd92fa17b5d8947d58d5546aaf5e8e27e1d3b5481a6ce51 +aaf7a34d3267e3b1ddbc54c641e3922e89303f7c86ebebc7347ebca4cffad5b76117dac0cbae1a133053492799cd936f +a9ee604ada50adef82e29e893070649d2d4b7136cc24fa20e281ce1a07bd736bf0de7c420369676bcbcecff26fb6e900 +9855315a12a4b4cf80ab90b8bd13003223ba25206e52fd4fe6a409232fbed938f30120a3db23eab9c53f308bd8b9db81 +8cd488dd7a24f548a3cf03c54dec7ff61d0685cb0f6e5c46c2d728e3500d8c7bd6bba0156f4bf600466fda53e5b20444 +890ad4942ebac8f5b16c777701ab80c68f56fa542002b0786f8fea0fb073154369920ac3dbfc07ea598b82f4985b8ced +8de0cf9ddc84c9b92c59b9b044387597799246b30b9f4d7626fc12c51f6e423e08ee4cbfe9289984983c1f9521c3e19d +b474dfb5b5f4231d7775b3c3a8744956b3f0c7a871d835d7e4fd9cc895222c7b868d6c6ce250de568a65851151fac860 +86433b6135d9ed9b5ee8cb7a6c40e5c9d30a68774cec04988117302b8a02a11a71a1e03fd8e0264ef6611d219f103007 +80b9ed4adbe9538fb1ef69dd44ec0ec5b57cbfea820054d8d445b4261962624b4c70ac330480594bc5168184378379c3 +8b2e83562ccd23b7ad2d17f55b1ab7ef5fbef64b3a284e6725b800f3222b8bdf49937f4a873917ada9c4ddfb090938c2 +abe78cebc0f5a45d754140d1f685e387489acbfa46d297a8592aaa0d676a470654f417a4f7d666fc0b2508fab37d908e +a9c5f8ff1f8568e252b06d10e1558326db9901840e6b3c26bbd0cd5e850cb5fb3af3f117dbb0f282740276f6fd84126f +975f8dc4fb55032a5df3b42b96c8c0ffecb75456f01d4aef66f973cb7270d4eff32c71520ceefc1adcf38d77b6b80c67 +b043306ed2c3d8a5b9a056565afd8b5e354c8c4569fda66b0d797a50a3ce2c08cffbae9bbe292da69f39e89d5dc7911e +8d2afc36b1e44386ba350c14a6c1bb31ff6ea77128a0c5287584ac3584282d18516901ce402b4644a53db1ed8e7fa581 +8c294058bed53d7290325c363fe243f6ec4f4ea2343692f4bac8f0cb86f115c069ccb8334b53d2e42c067691ad110dba +b92157b926751aaf7ef82c1aa8c654907dccab6376187ee8b3e8c0c82811eae01242832de953faa13ebaff7da8698b3e +a780c4bdd9e4ba57254b09d745075cecab87feda78c88ffee489625c5a3cf96aa6b3c9503a374a37927d9b78de9bd22b +811f548ef3a2e6a654f7dcb28ac9378de9515ed61e5a428515d9594a83e80b35c60f96a5cf743e6fab0d3cb526149f49 +85a4dccf6d90ee8e094731eec53bd00b3887aec6bd81a0740efddf812fd35e3e4fe4f983afb49a8588691c202dabf942 +b152c2da6f2e01c8913079ae2b40a09b1f361a80f5408a0237a8131b429677c3157295e11b365b1b1841924b9efb922e +849b9efee8742502ffd981c4517c88ed33e4dd518a330802caff168abae3cd09956a5ee5eda15900243bc2e829016b74 +955a933f3c18ec0f1c0e38fa931e4427a5372c46a3906ebe95082bcf878c35246523c23f0266644ace1fa590ffa6d119 +911989e9f43e580c886656377c6f856cdd4ff1bd001b6db3bbd86e590a821d34a5c6688a29b8d90f28680e9fdf03ba69 +b73b8b4f1fd6049fb68d47cd96a18fcba3f716e0a1061aa5a2596302795354e0c39dea04d91d232aec86b0bf2ba10522 +90f87456d9156e6a1f029a833bf3c7dbed98ca2f2f147a8564922c25ae197a55f7ea9b2ee1f81bf7383197c4bad2e20c +903cba8b1e088574cb04a05ca1899ab00d8960580c884bd3c8a4c98d680c2ad11410f2b75739d6050f91d7208cac33a5 +9329987d42529c261bd15ecedd360be0ea8966e7838f32896522c965adfc4febf187db392bd441fb43bbd10c38fdf68b +8178ee93acf5353baa349285067b20e9bb41aa32d77b5aeb7384fe5220c1fe64a2461bd7a83142694fe673e8bbf61b7c +a06a8e53abcff271b1394bcc647440f81fb1c1a5f29c27a226e08f961c3353f4891620f2d59b9d1902bf2f5cc07a4553 +aaf5fe493b337810889e777980e6bbea6cac39ac66bc0875c680c4208807ac866e9fda9b5952aa1d04539b9f4a4bec57 +aa058abb1953eceac14ccfa7c0cc482a146e1232905dcecc86dd27f75575285f06bbae16a8c9fe8e35d8713717f5f19f +8f15dd732799c879ca46d2763453b359ff483ca33adb1d0e0a57262352e0476c235987dc3a8a243c74bc768f93d3014c +a61cc8263e9bc03cce985f1663b8a72928a607121005a301b28a278e9654727fd1b22bc8a949af73929c56d9d3d4a273 +98d6dc78502d19eb9f921225475a6ebcc7b44f01a2df6f55ccf6908d65b27af1891be2a37735f0315b6e0f1576c1f8d8 +8bd258b883f3b3793ec5be9472ad1ff3dc4b51bc5a58e9f944acfb927349ead8231a523cc2175c1f98e7e1e2b9f363b8 +aeacc2ecb6e807ad09bedd99654b097a6f39840e932873ace02eabd64ccfbb475abdcb62939a698abf17572d2034c51e +b8ccf78c08ccd8df59fd6eda2e01de328bc6d8a65824d6f1fc0537654e9bc6bf6f89c422dd3a295cce628749da85c864 +8f91fd8cb253ba2e71cc6f13da5e05f62c2c3b485c24f5d68397d04665673167fce1fc1aec6085c69e87e66ec555d3fd +a254baa10cb26d04136886073bb4c159af8a8532e3fd36b1e9c3a2e41b5b2b6a86c4ebc14dbe624ee07b7ccdaf59f9ab +94e3286fe5cd68c4c7b9a7d33ae3d714a7f265cf77cd0e9bc19fc51015b1d1c34ad7e3a5221c459e89f5a043ee84e3a9 +a279da8878af8d449a9539bec4b17cea94f0242911f66fab275b5143ab040825f78c89cb32a793930609415cfa3a1078 +ac846ceb89c9e5d43a2991c8443079dc32298cd63e370e64149cec98cf48a6351c09c856f2632fd2f2b3d685a18bbf8b +a847b27995c8a2e2454aaeb983879fb5d3a23105c33175839f7300b7e1e8ec3efd6450e9fa3f10323609dee7b98c6fd5 +a2f432d147d904d185ff4b2de8c6b82fbea278a2956bc406855b44c18041854c4f0ecccd472d1d0dff1d8aa8e281cb1d +94a48ad40326f95bd63dff4755f863a1b79e1df771a1173b17937f9baba57b39e651e7695be9f66a472f098b339364fc +a12a0ccd8f96e96e1bc6494341f7ebce959899341b3a084aa1aa87d1c0d489ac908552b7770b887bb47e7b8cbc3d8e66 +81a1f1681bda923bd274bfe0fbb9181d6d164fe738e54e25e8d4849193d311e2c4253614ed673c98af2c798f19a93468 +abf71106a05d501e84cc54610d349d7d5eae21a70bd0250f1bebbf412a130414d1c8dbe673ffdb80208fd72f1defa4d4 +96266dc2e0df18d8136d79f5b59e489978eee0e6b04926687fe389d4293c14f36f055c550657a8e27be4118b64254901 +8df5dcbefbfb4810ae3a413ca6b4bf08619ca53cd50eb1dde2a1c035efffc7b7ac7dff18d403253fd80104bd83dc029e +9610b87ff02e391a43324a7122736876d5b3af2a137d749c52f75d07b17f19900b151b7f439d564f4529e77aa057ad12 +a90a5572198b40fe2fcf47c422274ff36c9624df7db7a89c0eb47eb48a73a03c985f4ac5016161c76ca317f64339bce1 +98e5e61a6ab6462ba692124dba7794b6c6bde4249ab4fcc98c9edd631592d5bc2fb5e38466691a0970a38e48d87c2e43 +918cefb8f292f78d4db81462c633daf73b395e772f47b3a7d2cea598025b1d8c3ec0cbff46cdb23597e74929981cde40 +a98918a5dc7cf610fe55f725e4fd24ce581d594cb957bb9b4e888672e9c0137003e1041f83e3f1d7b9caab06462c87d4 +b92b74ac015262ca66c33f2d950221e19d940ba3bf4cf17845f961dc1729ae227aa9e1f2017829f2135b489064565c29 +a053ee339f359665feb178b4e7ee30a85df37debd17cacc5a27d6b3369d170b0114e67ad1712ed26d828f1df641bcd99 +8c3c8bad510b35da5ce5bd84b35c958797fbea024ad1c97091d2ff71d9b962e9222f65a9b776e5b3cc29c36e1063d2ee +af99dc7330fe7c37e850283eb47cc3257888e7c197cb0d102edf94439e1e02267b6a56306d246c326c4c79f9dc8c6986 +afecb2dc34d57a725efbd7eb93d61eb29dbe8409b668ab9ea040791f5b796d9be6d4fc10d7f627bf693452f330cf0435 +93334fedf19a3727a81a6b6f2459db859186227b96fe7a391263f69f1a0884e4235de64d29edebc7b99c44d19e7c7d7a +89579c51ac405ad7e9df13c904061670ce4b38372492764170e4d3d667ed52e5d15c7cd5c5991bbfa3a5e4e3fa16363e +9778f3e8639030f7ef1c344014f124e375acb8045bd13d8e97a92c5265c52de9d1ffebaa5bc3e1ad2719da0083222991 +88f77f34ee92b3d36791bdf3326532524a67d544297dcf1a47ff00b47c1b8219ff11e34034eab7d23b507caa2fd3c6b9 +a699c1e654e7c484431d81d90657892efeb4adcf72c43618e71ca7bd7c7a7ebbb1db7e06e75b75dc4c74efd306b5df3f +81d13153baebb2ef672b5bdb069d3cd669ce0be96b742c94e04038f689ff92a61376341366b286eee6bf3ae85156f694 +81efb17de94400fdacc1deec2550cbe3eecb27c7af99d8207e2f9be397e26be24a40446d2a09536bb5172c28959318d9 +989b21ebe9ceab02488992673dc071d4d5edec24bff0e17a4306c8cb4b3c83df53a2063d1827edd8ed16d6e837f0d222 +8d6005d6536825661b13c5fdce177cb37c04e8b109b7eb2b6d82ea1cb70efecf6a0022b64f84d753d165edc2bba784a3 +a32607360a71d5e34af2271211652d73d7756d393161f4cf0da000c2d66a84c6826e09e759bd787d4fd0305e2439d342 +aaad8d6f6e260db45d51b2da723be6fa832e76f5fbcb77a9a31e7f090dd38446d3b631b96230d78208cae408c288ac4e +abcfe425255fd3c5cffd3a818af7650190c957b6b07b632443f9e33e970a8a4c3bf79ac9b71f4d45f238a04d1c049857 +aeabf026d4c783adc4414b5923dbd0be4b039cc7201219f7260d321f55e9a5b166d7b5875af6129c034d0108fdc5d666 +af49e740c752d7b6f17048014851f437ffd17413c59797e5078eaaa36f73f0017c3e7da020310cfe7d3c85f94a99f203 +8854ca600d842566e3090040cd66bb0b3c46dae6962a13946f0024c4a8aca447e2ccf6f240045f1ceee799a88cb9210c +b6c03b93b1ab1b88ded8edfa1b487a1ed8bdce8535244dddb558ffb78f89b1c74058f80f4db2320ad060d0c2a9c351cc +b5bd7d17372faff4898a7517009b61a7c8f6f0e7ed4192c555db264618e3f6e57fb30a472d169fea01bf2bf0362a19a8 +96eb1d38319dc74afe7e7eb076fcd230d19983f645abd14a71e6103545c01301b31c47ae931e025f3ecc01fb3d2f31fa +b55a8d30d4403067def9b65e16f867299f8f64c9b391d0846d4780bc196569622e7e5b64ce799b5aefac8f965b2a7a7b +8356d199a991e5cbbff608752b6291731b6b6771aed292f8948b1f41c6543e4ab1bedc82dd26d10206c907c03508df06 +97f4137445c2d98b0d1d478049de952610ad698c91c9d0f0e7227d2aae690e9935e914ec4a2ea1fbf3fc1dddfeeacebb +af5621707e0938320b15ddfc87584ab325fbdfd85c30efea36f8f9bd0707d7ec12c344eff3ec21761189518d192df035 +8ac7817e71ea0825b292687928e349da7140285d035e1e1abff0c3704fa8453faaae343a441b7143a74ec56539687cc4 +8a5e0a9e4758449489df10f3386029ada828d1762e4fb0a8ffe6b79e5b6d5d713cb64ed95960e126398b0cdb89002bc9 +81324be4a71208bbb9bca74b77177f8f1abb9d3d5d9db195d1854651f2cf333cd618d35400da0f060f3e1b025124e4b2 +849971d9d095ae067525b3cbc4a7dfae81f739537ade6d6cec1b42fb692d923176197a8770907c58069754b8882822d6 +89f830825416802477cc81fdf11084885865ee6607aa15aa4eb28e351c569c49b8a1b9b5e95ddc04fa0ebafe20071313 +9240aeeaff37a91af55f860b9badd466e8243af9e8c96a7aa8cf348cd270685ab6301bc135b246dca9eda696f8b0e350 +acf74db78cc33138273127599eba35b0fb4e7b9a69fe02dae18fc6692d748ca332bd00b22afa8e654ed587aab11833f3 +b091e6d37b157b50d76bd297ad752220cd5c9390fac16dc838f8557aed6d9833fc920b61519df21265406216315e883f +a6446c429ebf1c7793c622250e23594c836b2fbcaf6c5b3d0995e1595a37f50ea643f3e549b0be8bbdadd69044d72ab9 +93e675353bd60e996bf1c914d5267eeaa8a52fc3077987ccc796710ef9becc6b7a00e3d82671a6bdfb8145ee3c80245a +a2f731e43251d04ed3364aa2f072d05355f299626f2d71a8a38b6f76cf08c544133f7d72dd0ab4162814b674b9fc7fa6 +97a8b791a5a8f6e1d0de192d78615d73d0c38f1e557e4e15d15adc663d649e655bc8da3bcc499ef70112eafe7fb45c7a +98cd624cbbd6c53a94469be4643c13130916b91143425bcb7d7028adbbfede38eff7a21092af43b12d4fab703c116359 +995783ce38fd5f6f9433027f122d4cf1e1ff3caf2d196ce591877f4a544ce9113ead60de2de1827eaff4dd31a20d79a8 +8cf251d6f5229183b7f3fe2f607a90b4e4b6f020fb4ba2459d28eb8872426e7be8761a93d5413640a661d73e34a5b81f +b9232d99620652a3aa7880cad0876f153ff881c4ed4c0c2e7b4ea81d5d42b70daf1a56b869d752c3743c6d4c947e6641 +849716f938f9d37250cccb1bf77f5f9fde53096cdfc6f2a25536a6187029a8f1331cdbed08909184b201f8d9f04b792f +80c7c4de098cbf9c6d17b14eba1805e433b5bc905f6096f8f63d34b94734f2e4ebf4bce8a177efd1186842a61204a062 +b790f410cf06b9b8daadceeb4fd5ff40a2deda820c8df2537e0a7554613ae3948e149504e3e79aa84889df50c8678eeb +813aab8bd000299cd37485b73cd7cba06e205f8efb87f1efc0bae8b70f6db2bc7702eb39510ad734854fb65515fe9d0f +94f0ab7388ac71cdb67f6b85dfd5945748afb2e5abb622f0b5ad104be1d4d0062b651f134ba22385c9e32c2dfdcccce1 +ab6223dca8bd6a4f969e21ccd9f8106fc5251d321f9e90cc42cea2424b3a9c4e5060a47eeef6b23c7976109b548498e8 +859c56b71343fce4d5c5b87814c47bf55d581c50fd1871a17e77b5e1742f5af639d0e94d19d909ec7dfe27919e954e0c +aae0d632b6191b8ad71b027791735f1578e1b89890b6c22e37de0e4a6074886126988fe8319ae228ac9ef3b3bcccb730 +8ca9f32a27a024c3d595ecfaf96b0461de57befa3b331ab71dc110ec3be5824fed783d9516597537683e77a11d334338 +a061df379fb3f4b24816c9f6cd8a94ecb89b4c6dc6cd81e4b8096fa9784b7f97ab3540259d1de9c02eb91d9945af4823 +998603102ac63001d63eb7347a4bb2bf4cf33b28079bb48a169076a65c20d511ccd3ef696d159e54cc8e772fb5d65d50 +94444d96d39450872ac69e44088c252c71f46be8333a608a475147752dbb99db0e36acfc5198f158509401959c12b709 +ac1b51b6c09fe055c1d7c9176eea9adc33f710818c83a1fbfa073c8dc3a7eb3513cbdd3f5960b7845e31e3e83181e6ba +803d530523fc9e1e0f11040d2412d02baef3f07eeb9b177fa9bfa396af42eea898a4276d56e1db998dc96ae47b644cb2 +85a3c9fc7638f5bf2c3e15ba8c2fa1ae87eb1ceb44c6598c67a2948667a9dfa41e61f66d535b4e7fda62f013a5a8b885 +a961cf5654c46a1a22c29baf7a4e77837a26b7f138f410e9d1883480ed5fa42411d522aba32040b577046c11f007388e +ad1154142344f494e3061ef45a34fab1aaacf5fdf7d1b26adbb5fbc3d795655fa743444e39d9a4119b4a4f82a6f30441 +b1d6c30771130c77806e7ab893b73d4deb590b2ff8f2f8b5e54c2040c1f3e060e2bd99afc668cf706a2df666a508bbf6 +a00361fd440f9decabd98d96c575cd251dc94c60611025095d1201ef2dedde51cb4de7c2ece47732e5ed9b3526c2012c +a85c5ab4d17d328bda5e6d839a9a6adcc92ff844ec25f84981e4f44a0e8419247c081530f8d9aa629c7eb4ca21affba6 +a4ddd3eab4527a2672cf9463db38bc29f61460e2a162f426b7852b7a7645fbd62084fd39a8e4d60e1958cce436dd8f57 +811648140080fe55b8618f4cf17f3c5a250adb0cd53d885f2ddba835d2b4433188e41fc0661faac88e4ff910b16278c0 +b85c7f1cfb0ed29addccf7546023a79249e8f15ac2d14a20accbfef4dd9dc11355d599815fa09d2b6b4e966e6ea8cff1 +a10b5d8c260b159043b020d5dd62b3467df2671afea6d480ca9087b7e60ed170c82b121819d088315902842d66c8fb45 +917e191df1bcf3f5715419c1e2191da6b8680543b1ba41fe84ed07ef570376e072c081beb67b375fca3565a2565bcabb +881fd967407390bfd7badc9ab494e8a287559a01eb07861f527207c127eadea626e9bcc5aa9cca2c5112fbac3b3f0e9c +959fd71149af82cc733619e0e5bf71760ca2650448c82984b3db74030d0e10f8ab1ce1609a6de6f470fe8b5bd90df5b3 +a3370898a1c5f33d15adb4238df9a6c945f18b9ada4ce2624fc32a844f9ece4c916a64e9442225b6592afa06d2e015f2 +817efb8a791435e4236f7d7b278181a5fa34587578c629dbc14fbf9a5c26772290611395eecd20222a4c58649fc256d8 +a04c9876acf2cfdc8ef96de4879742709270fa1d03fe4c8511fbef2d59eb0aaf0336fa2c7dfe41a651157377fa217813 +81e15875d7ea7f123e418edf14099f2e109d4f3a6ce0eb65f67fe9fb10d2f809a864a29f60ad3fc949f89e2596b21783 +b49f529975c09e436e6bc202fdc16e3fdcbe056db45178016ad6fdece9faad4446343e83aed096209690b21a6910724f +879e8eda589e1a279f7f49f6dd0580788c040d973748ec4942dbe51ea8fbd05983cc919b78f0c6b92ef3292ae29db875 +81a2b74b2118923f34139a102f3d95e7eee11c4c2929c2576dee200a5abfd364606158535a6c9e4178a6a83dbb65f3c4 +8913f281d8927f2b45fc815d0f7104631cb7f5f7278a316f1327d670d15868daadd2a64e3eb98e1f53fe7e300338cc80 +a6f815fba7ef9af7fbf45f93bc952e8b351f5de6568a27c7c47a00cb39a254c6b31753794f67940fc7d2e9cc581529f4 +b3722a15c66a0014ce4d082de118def8d39190c15678a472b846225585f3a83756ae1b255b2e3f86a26168878e4773b2 +817ae61ab3d0dd5b6e24846b5a5364b1a7dc2e77432d9fed587727520ae2f307264ea0948c91ad29f0aea3a11ff38624 +b3db467464415fcad36dc1de2d6ba7686772a577cc2619242ac040d6734881a45d3b40ed4588db124e4289cfeec4bbf6 +ad66a14f5a54ac69603b16e5f1529851183da77d3cc60867f10aea41339dd5e06a5257982e9e90a352cdd32750f42ee4 +adafa3681ef45d685555601a25a55cf23358319a17f61e2179e704f63df83a73bdd298d12cf6cef86db89bd17119e11d +a379dc44cb6dd3b9d378c07b2ec654fec7ca2f272de6ba895e3d00d20c9e4c5550498a843c8ac67e4221db2115bedc1c +b7bf81c267a78efc6b9e5a904574445a6487678d7ef70054e3e93ea6a23f966c2b68787f9164918e3b16d2175459ed92 +b41d66a13a4afafd5760062b77f79de7e6ab8ccacde9c6c5116a6d886912fb491dc027af435b1b44aacc6af7b3c887f2 +9904d23a7c1c1d2e4bab85d69f283eb0a8e26d46e8b7b30224438015c936729b2f0af7c7c54c03509bb0500acb42d8a4 +ae30d65e9e20c3bfd603994ae2b175ff691d51f3e24b2d058b3b8556d12ca4c75087809062dddd4aaac81c94d15d8a17 +9245162fab42ac01527424f6013310c3eb462982518debef6c127f46ba8a06c705d7dc9f0a41e796ba8d35d60ae6cc64 +87fab853638d7a29a20f3ba2b1a7919d023e9415bfa78ebb27973d8cbc7626f584dc5665d2e7ad71f1d760eba9700d88 +85aac46ecd330608e5272430970e6081ff02a571e8ea444f1e11785ea798769634a22a142d0237f67b75369d3c484a8a +938c85ab14894cc5dfce3d80456f189a2e98eddbc8828f4ff6b1df1dcb7b42b17ca2ff40226a8a1390a95d63dca698dd +a18ce1f846e3e3c4d846822f60271eecf0f5d7d9f986385ac53c5ace9589dc7c0188910448c19b91341a1ef556652fa9 +8611608a9d844f0e9d7584ad6ccf62a5087a64f764caf108db648a776b5390feb51e5120f0ef0e9e11301af3987dd7dc +8106333ba4b4de8d1ae43bc9735d3fea047392e88efd6a2fa6f7b924a18a7a265ca6123c3edc0f36307dd7fb7fe89257 +a91426fa500951ff1b051a248c050b7139ca30dde8768690432d597d2b3c4357b11a577be6b455a1c5d145264dcf81fc +b7f9f90e0e450f37b081297f7f651bad0496a8b9afd2a4cf4120a2671aaaa8536dce1af301258bfbfdb122afa44c5048 +84126da6435699b0c09fa4032dec73d1fca21d2d19f5214e8b0bea43267e9a8dd1fc44f8132d8315e734c8e2e04d7291 +aff064708103884cb4f1a3c1718b3fc40a238d35cf0a7dc24bdf9823693b407c70da50df585bf5bc4e9c07d1c2d203e8 +a8b40fc6533752983a5329c31d376c7a5c13ce6879cc7faee648200075d9cd273537001fb4c86e8576350eaac6ba60c2 +a02db682bdc117a84dcb9312eb28fcbde12d49f4ce915cc92c610bb6965ec3cc38290f8c5b5ec70afe153956692cda95 +86decd22b25d300508472c9ce75d3e465b737e7ce13bc0fcce32835e54646fe12322ba5bc457be18bfd926a1a6ca4a38 +a18666ef65b8c2904fd598791f5627207165315a85ee01d5fb0e6b2e10bdd9b00babc447da5bd63445e3337de33b9b89 +89bb0c06effadefdaf34ffe4b123e1678a90d4451ee856c863df1e752eef41fd984689ded8f0f878bf8916d5dd8e8024 +97cfcba08ebec05d0073992a66b1d7d6fb9d95871f2cdc36db301f78bf8069294d1c259efef5c93d20dc937eedae3a1a +ac2643b14ece79dcb2e289c96776a47e2bebd40dd6dc74fd035df5bb727b5596f40e3dd2d2202141e69b0993717ede09 +a5e6fd88a2f9174d9bd4c6a55d9c30974be414992f22aa852f552c7648f722ed8077acf5aba030abd47939bb451b2c60 +8ad40a612824a7994487731a40b311b7349038c841145865539c6ada75c56de6ac547a1c23df190e0caaafecddd80ccc +953a7cea1d857e09202c438c6108060961f195f88c32f0e012236d7a4b39d840c61b162ec86436e8c38567328bea0246 +80d8b47a46dae1868a7b8ccfe7029445bbe1009dad4a6c31f9ef081be32e8e1ac1178c3c8fb68d3e536c84990cc035b1 +81ecd99f22b3766ce0aca08a0a9191793f68c754fdec78b82a4c3bdc2db122bbb9ebfd02fc2dcc6e1567a7d42d0cc16a +b1dd0446bccc25846fb95d08c1c9cc52fb51c72c4c5d169ffde56ecfe800f108dc1106d65d5c5bd1087c656de3940b63 +b87547f0931e164e96de5c550ca5aa81273648fe34f6e193cd9d69cf729cb432e17aa02e25b1c27a8a0d20a3b795e94e +820a94e69a927e077082aae66f6b292cfbe4589d932edf9e68e268c9bd3d71ef76cf7d169dd445b93967c25db11f58f1 +b0d07ddf2595270c39adfa0c8cf2ab1322979b0546aa4d918f641be53cd97f36c879bb75d205e457c011aca3bbd9f731 +8700b876b35b4b10a8a9372c5230acecd39539c1bb87515640293ad4464a9e02929d7d6a6a11112e8a29564815ac0de4 +a61a601c5bb27dcb97e37c8e2b9ce479c6b192a5e04d9ed5e065833c5a1017ee5f237b77d1a17be5d48f8e7cc0bcacf6 +92fb88fe774c1ba1d4a08cae3c0e05467ad610e7a3f1d2423fd47751759235fe0a3036db4095bd6404716aa03820f484 +b274f140d77a3ce0796f5e09094b516537ccaf27ae1907099bff172e6368ba85e7c3ef8ea2a07457cac48ae334da95b3 +b2292d9181f16581a9a9142490b2bdcdfb218ca6315d1effc8592100d792eb89d5356996c890441f04f2b4a95763503e +8897e73f576d86bc354baa3bd96e553107c48cf5889dcc23c5ba68ab8bcd4e81f27767be2233fdfa13d39f885087e668 +a29eac6f0829791c728d71abc49569df95a4446ecbfc534b39f24f56c88fe70301838dfc1c19751e7f3c5c1b8c6af6a0 +9346dc3720adc5df500a8df27fd9c75ef38dc5c8f4e8ed66983304750e66d502c3c59b8e955be781b670a0afc70a2167 +9566d534e0e30a5c5f1428665590617e95fd05d45f573715f58157854ad596ece3a3cfec61356aee342308d623e029d5 +a464fb8bffe6bd65f71938c1715c6e296cc6d0311a83858e4e7eb5873b7f2cf0c584d2101e3407b85b64ca78b2ac93ce +b54088f7217987c87e9498a747569ac5b2f8afd5348f9c45bf3fd9fbf713a20f495f49c8572d087efe778ac7313ad6d3 +91fa9f5f8000fe050f5b224d90b59fcce13c77e903cbf98ded752e5b3db16adb2bc1f8c94be48b69f65f1f1ad81d6264 +92d04a5b0ac5d8c8e313709b432c9434ecd3e73231f01e9b4e7952b87df60cbfa97b5dedd2200bd033b4b9ea8ba45cc1 +a94b90ad3c3d6c4bbe169f8661a790c40645b40f0a9d1c7220f01cf7fc176e04d80bab0ced9323fcafb93643f12b2760 +94d86149b9c8443b46196f7e5a3738206dd6f3be7762df488bcbb9f9ee285a64c997ed875b7b16b26604fa59020a8199 +82efe4ae2c50a2d7645240c173a047f238536598c04a2c0b69c96e96bd18e075a99110f1206bc213f39edca42ba00cc1 +ab8667685f831bc14d4610f84a5da27b4ea5b133b4d991741a9e64dceb22cb64a3ce8f1b6e101d52af6296df7127c9ad +83ba433661c05dcc5d562f4a9a261c8110dac44b8d833ae1514b1fc60d8b4ee395b18804baea04cb10adb428faf713c3 +b5748f6f660cc5277f1211d2b8649493ed8a11085b871cd33a5aea630abd960a740f08c08be5f9c21574600ac9bf5737 +a5c8dd12af48fb710642ad65ebb97ca489e8206741807f7acfc334f8035d3c80593b1ff2090c9bb7bd138f0c48714ca8 +a2b382fd5744e3babf454b1d806cc8783efeb4761bc42b6914ea48a46a2eae835efbe0a18262b6bc034379e03cf1262b +b3145ffaf603f69f15a64936d32e3219eea5ed49fdfd2f5bf40ea0dfd974b36fb6ff12164d4c2282d892db4cf3ff3ce1 +87a316fb213f4c5e30c5e3face049db66be4f28821bd96034714ec23d3e97849d7b301930f90a4323c7ccf53de23050c +b9de09a919455070fed6220fc179c8b7a4c753062bcd27acf28f5b9947a659c0b364298daf7c85c4ca6fca7f945add1f +806fbd98d411b76979464c40ad88bc07a151628a27fcc1012ba1dfbaf5b5cc9d962fb9b3386008978a12515edce934bc +a15268877fae0d21610ae6a31061ed7c20814723385955fac09fdc9693a94c33dea11db98bb89fdfe68f933490f5c381 +8d633fb0c4da86b2e0b37d8fad5972d62bff2ac663c5ec815d095cd4b7e1fe66ebef2a2590995b57eaf941983c7ad7a4 +8139e5dd9cf405e8ef65f11164f0440827d98389ce1b418b0c9628be983a9ddd6cf4863036ccb1483b40b8a527acd9ed +88b15fa94a08eac291d2b94a2b30eb851ff24addf2cc30b678e72e32cfcb3424cf4b33aa395d741803f3e578ddf524de +b5eaf0c8506e101f1646bcf049ee38d99ea1c60169730da893fd6020fd00a289eb2f415947e44677af49e43454a7b1be +8489822ad0647a7e06aa2aa5595960811858ddd4542acca419dd2308a8c5477648f4dd969a6740bb78aa26db9bfcc555 +b1e9a7b9f3423c220330d45f69e45fa03d7671897cf077f913c252e3e99c7b1b1cf6d30caad65e4228d5d7b80eb86e5e +b28fe9629592b9e6a55a1406903be76250b1c50c65296c10c5e48c64b539fb08fe11f68cf462a6edcbba71b0cee3feb2 +a41acf96a02c96cd8744ff6577c244fc923810d17ade133587e4c223beb7b4d99fa56eae311a500d7151979267d0895c +880798938fe4ba70721be90e666dfb62fcab4f3556fdb7b0dc8ec5bc34f6b4513df965eae78527136eb391889fe2caf9 +98d4d89d358e0fb7e212498c73447d94a83c1b66e98fc81427ab13acddb17a20f52308983f3a5a8e0aaacec432359604 +81430b6d2998fc78ba937a1639c6020199c52da499f68109da227882dc26d005b73d54c5bdcac1a04e8356a8ca0f7017 +a8d906a4786455eb74613aba4ce1c963c60095ffb8658d368df9266fdd01e30269ce10bf984e7465f34b4fd83beba26a +af54167ac1f954d10131d44a8e0045df00d581dd9e93596a28d157543fbe5fb25d213806ed7fb3cba6b8f5b5423562db +8511e373a978a12d81266b9afbd55035d7bc736835cfa921903a92969eeba3624437d1346b55382e61415726ab84a448 +8cf43eea93508ae586fa9a0f1354a1e16af659782479c2040874a46317f9e8d572a23238efa318fdfb87cc63932602b7 +b0bdd3bacff077173d302e3a9678d1d37936188c7ecc34950185af6b462b7c679815176f3cce5db19aac8b282f2d60ad +a355e9b87f2f2672052f5d4d65b8c1c827d24d89b0d8594641fccfb69aef1b94009105f3242058bb31c8bf51caae5a41 +b8baa9e4b950b72ff6b88a6509e8ed1304bc6fd955748b2e59a523a1e0c5e99f52aec3da7fa9ff407a7adf259652466c +840bc3dbb300ea6f27d1d6dd861f15680bd098be5174f45d6b75b094d0635aced539fa03ddbccb453879de77fb5d1fe9 +b4bc7e7e30686303856472bae07e581a0c0bfc815657c479f9f5931cff208d5c12930d2fd1ff413ebd8424bcd7a9b571 +89b5d514155d7999408334a50822508b9d689add55d44a240ff2bdde2eee419d117031f85e924e2a2c1ca77db9b91eea +a8604b6196f87a04e1350302e8aa745bba8dc162115d22657b37a1d1a98cb14876ddf7f65840b5dbd77e80cd22b4256c +83cb7acdb9e03247515bb2ce0227486ccf803426717a14510f0d59d45e998b245797d356f10abca94f7a14e1a2f0d552 +aeb3266a9f16649210ab2df0e1908ac259f34ce1f01162c22b56cf1019096ee4ea5854c36e30bb2feb06c21a71e8a45c +89e72e86edf2aa032a0fc9acf4d876a40865fbb2c8f87cb7e4d88856295c4ac14583e874142fd0c314a49aba68c0aa3c +8c3576eba0583c2a7884976b4ed11fe1fda4f6c32f6385d96c47b0e776afa287503b397fa516a455b4b8c3afeedc76db +a31e5b633bda9ffa174654fee98b5d5930a691c3c42fcf55673d927dbc8d91c58c4e42e615353145431baa646e8bbb30 +89f2f3f7a8da1544f24682f41c68114a8f78c86bd36b066e27da13acb70f18d9f548773a16bd8e24789420e17183f137 +ada27fa4e90a086240c9164544d2528621a415a5497badb79f8019dc3dce4d12eb6b599597e47ec6ac39c81efda43520 +90dc1eb21bf21c0187f359566fc4bf5386abea52799306a0e5a1151c0817c5f5bc60c86e76b1929c092c0f3ff48cedd2 +b702a53ebcc17ae35d2e735a347d2c700e9cbef8eadbece33cac83df483b2054c126593e1f462cfc00a3ce9d737e2af5 +9891b06455ec925a6f8eafffba05af6a38cc5e193acaaf74ffbf199df912c5197106c5e06d72942bbb032ce277b6417f +8c0ee71eb01197b019275bcf96cae94e81d2cdc3115dbf2d8e3080074260318bc9303597e8f72b18f965ad601d31ec43 +8aaf580aaf75c1b7a5f99ccf60503506e62058ef43b28b02f79b8536a96be3f019c9f71caf327b4e6730134730d1bef5 +ae6f9fc21dd7dfa672b25a87eb0a41644f7609fab5026d5cedb6e43a06dbbfd6d6e30322a2598c8dedde88c52eaed626 +8159b953ffece5693edadb2e906ebf76ff080ee1ad22698950d2d3bfc36ac5ea78f58284b2ca180664452d55bd54716c +ab7647c32ca5e9856ac283a2f86768d68de75ceeba9e58b74c5324f8298319e52183739aba4340be901699d66ac9eb3f +a4d85a5701d89bcfaf1572db83258d86a1a0717603d6f24ac2963ffcf80f1265e5ab376a4529ca504f4396498791253c +816080c0cdbfe61b4d726c305747a9eb58ac26d9a35f501dd32ba43c098082d20faf3ccd41aad24600aa73bfa453dfac +84f3afac024f576b0fd9acc6f2349c2fcefc3f77dbe5a2d4964d14b861b88e9b1810334b908cf3427d9b67a8aee74b18 +94b390655557b1a09110018e9b5a14490681ade275bdc83510b6465a1218465260d9a7e2a6e4ec700f58c31dc3659962 +a8c66826b1c04a2dd4c682543242e7a57acae37278bd09888a3d17747c5b5fec43548101e6f46d703638337e2fd3277b +86e6f4608a00007fa533c36a5b054c5768ccafe41ad52521d772dcae4c8a4bcaff8f7609be30d8fab62c5988cbbb6830 +837da4cf09ae8aa0bceb16f8b3bfcc3b3367aecac9eed6b4b56d7b65f55981ef066490764fb4c108792623ecf8cad383 +941ff3011462f9b5bf97d8cbdb0b6f5d37a1b1295b622f5485b7d69f2cb2bcabc83630dae427f0259d0d9539a77d8424 +b99e5d6d82aa9cf7d5970e7f710f4039ac32c2077530e4c2779250c6b9b373bc380adb0a03b892b652f649720672fc8c +a791c78464b2d65a15440b699e1e30ebd08501d6f2720adbc8255d989a82fcded2f79819b5f8f201bed84a255211b141 +84af7ad4a0e31fcbb3276ab1ad6171429cf39adcf78dc03750dc5deaa46536d15591e26d53e953dfb31e1622bc0743ab +a833e62fe97e1086fae1d4917fbaf09c345feb6bf1975b5cb863d8b66e8d621c7989ab3dbecda36bc9eaffc5eaa6fa66 +b4ef79a46a2126f53e2ebe62770feb57fd94600be29459d70a77c5e9cc260fa892be06cd60f886bf48459e48eb50d063 +b43b8f61919ea380bf151c294e54d3a3ff98e20d1ee5efbfe38aa2b66fafbc6a49739793bd5cb1c809f8b30466277c3a +ab37735af2412d2550e62df9d8b3b5e6f467f20de3890bf56faf1abf2bf3bd1d98dc3fa0ad5e7ab3fce0fa20409eb392 +82416b74b1551d484250d85bb151fabb67e29cce93d516125533df585bc80779ab057ea6992801a3d7d5c6dcff87a018 +8145d0787f0e3b5325190ae10c1d6bee713e6765fb6a0e9214132c6f78f4582bb2771aaeae40d3dad4bafb56bf7e36d8 +b6935886349ecbdd5774e12196f4275c97ec8279fdf28ccf940f6a022ebb6de8e97d6d2173c3fe402cbe9643bed3883b +87ef9b4d3dc71ac86369f8ed17e0dd3b91d16d14ae694bc21a35b5ae37211b043d0e36d8ff07dcc513fb9e6481a1f37f +ae1d0ded32f7e6f1dc8fef495879c1d9e01826f449f903c1e5034aeeabc5479a9e323b162b688317d46d35a42d570d86 +a40d16497004db4104c6794e2f4428d75bdf70352685944f3fbe17526df333e46a4ca6de55a4a48c02ecf0bde8ba03c0 +8d45121efba8cc308a498e8ee39ea6fa5cae9fb2e4aab1c2ff9d448aa8494ccbec9a078f978a86fcd97b5d5e7be7522a +a8173865c64634ba4ac2fa432740f5c05056a9deaf6427cb9b4b8da94ca5ddbc8c0c5d3185a89b8b28878194de9cdfcd +b6ec06a74d690f6545f0f0efba236e63d1fdfba54639ca2617408e185177ece28901c457d02b849fd00f1a53ae319d0a +b69a12df293c014a40070e3e760169b6f3c627caf9e50b35a93f11ecf8df98b2bc481b410eecb7ab210bf213bbe944de +97e7dc121795a533d4224803e591eef3e9008bab16f12472210b73aaf77890cf6e3877e0139403a0d3003c12c8f45636 +acdfa6fdd4a5acb7738cc8768f7cba84dbb95c639399b291ae8e4e63df37d2d4096900a84d2f0606bf534a9ccaa4993f +86ee253f3a9446a33e4d1169719b7d513c6b50730988415382faaf751988c10a421020609f7bcdef91be136704b906e2 +aac9438382a856caf84c5a8a234282f71b5fc5f65219103b147e7e6cf565522285fbfd7417b513bdad8277a00f652ca1 +83f3799d8e5772527930f5dc071a2e0a65471618993ec8990a96ccdeee65270e490bda9d26bb877612475268711ffd80 +93f28a81ac8c0ec9450b9d762fae9c7f8feaace87a6ee6bd141ef1d2d0697ef1bbd159fe6e1de640dbdab2b0361fca8a +a0825c95ba69999b90eac3a31a3fd830ea4f4b2b7409bde5f202b61d741d6326852ce790f41de5cb0eccec7af4db30c1 +83924b0e66233edd603c3b813d698daa05751fc34367120e3cf384ea7432e256ccee4d4daf13858950549d75a377107d +956fd9fa58345277e06ba2ec72f49ed230b8d3d4ff658555c52d6cddeb84dd4e36f1a614f5242d5ca0192e8daf0543c2 +944869912476baae0b114cced4ff65c0e4c90136f73ece5656460626599051b78802df67d7201c55d52725a97f5f29fe +865cb25b64b4531fb6fe4814d7c8cd26b017a6c6b72232ff53defc18a80fe3b39511b23f9e4c6c7249d06e03b2282ed2 +81e09ff55214960775e1e7f2758b9a6c4e4cd39edf7ec1adfaad51c52141182b79fe2176b23ddc7df9fd153e5f82d668 +b31006896f02bc90641121083f43c3172b1039334501fbaf1672f7bf5d174ddd185f945adf1a9c6cf77be34c5501483d +88b92f6f42ae45e9f05b16e52852826e933efd0c68b0f2418ac90957fd018df661bc47c8d43c2a7d7bfcf669dab98c3c +92fc68f595853ee8683930751789b799f397135d002eda244fe63ecef2754e15849edde3ba2f0cc8b865c9777230b712 +99ca06a49c5cd0bb097c447793fcdd809869b216a34c66c78c7e41e8c22f05d09168d46b8b1f3390db9452d91bc96dea +b48b9490a5d65296802431852d548d81047bbefc74fa7dc1d4e2a2878faacdfcb365ae59209cb0ade01901a283cbd15d +aff0fdbef7c188b120a02bc9085d7b808e88f73973773fef54707bf2cd772cd066740b1b6f4127b5c349f657bd97e738 +966fd4463b4f43dd8ccba7ad50baa42292f9f8b2e70da23bb6780e14155d9346e275ef03ddaf79e47020dcf43f3738bd +9330c3e1fadd9e08ac85f4839121ae20bbeb0a5103d84fa5aadbd1213805bdcda67bf2fb75fc301349cbc851b5559d20 +993bb99867bd9041a71a55ad5d397755cfa7ab6a4618fc526179bfc10b7dc8b26e4372fe9a9b4a15d64f2b63c1052dda +a29b59bcfab51f9b3c490a3b96f0bf1934265c315349b236012adbd64a56d7f6941b2c8cc272b412044bc7731f71e1dc +a65c9cefe1fc35d089fe8580c2e7671ebefdb43014ac291528ff4deefd4883fd4df274af83711dad610dad0d615f9d65 +944c78c56fb227ae632805d448ca3884cd3d2a89181cead3d2b7835e63297e6d740aa79a112edb1d4727824991636df5 +a73d782da1db7e4e65d7b26717a76e16dd9fab4df65063310b8e917dc0bc24e0d6755df5546c58504d04d9e68c3b474a +af80f0b87811ae3124f68108b4ca1937009403f87928bbc53480e7c5408d072053ace5eeaf5a5aba814dab8a45502085 +88aaf1acfc6e2e19b8387c97da707cb171c69812fefdd4650468e9b2c627bd5ccfb459f4d8e56bdfd84b09ddf87e128f +92c97276ff6f72bab6e9423d02ad6dc127962dbce15a0dd1e4a393b4510c555df6aa27be0f697c0d847033a9ca8b8dfd +a0e07d43d96e2d85b6276b3c60aadb48f0aedf2de8c415756dc597249ea64d2093731d8735231dadc961e5682ac59479 +adc9e6718a8f9298957d1da3842a7751c5399bbdf56f8de6c1c4bc39428f4aee6f1ba6613d37bf46b9403345e9d6fc81 +951da434da4b20d949b509ceeba02e24da7ed2da964c2fcdf426ec787779c696b385822c7dbea4df3e4a35921f1e912c +a04cbce0d2b2e87bbf038c798a12ec828423ca6aca08dc8d481cf6466e3c9c73d4d4a7fa47df9a7e2e15aae9e9f67208 +8f855cca2e440d248121c0469de1f94c2a71b8ee2682bbad3a78243a9e03da31d1925e6760dbc48a1957e040fae9abe8 +b642e5b17c1df4a4e101772d73851180b3a92e9e8b26c918050f51e6dd3592f102d20b0a1e96f0e25752c292f4c903ff +a92454c300781f8ae1766dbbb50a96192da7d48ef4cbdd72dd8cbb44c6eb5913c112cc38e9144615fdc03684deb99420 +8b74f7e6c2304f8e780df4649ef8221795dfe85fdbdaa477a1542d135b75c8be45bf89adbbb6f3ddf54ca40f02e733e9 +85cf66292cbb30cec5fd835ab10c9fcb3aea95e093aebf123e9a83c26f322d76ebc89c4e914524f6c5f6ee7d74fc917d +ae0bfe0cdc97c09542a7431820015f2d16067b30dca56288013876025e81daa8c519e5e347268e19aa1a85fa1dc28793 +921322fc6a47dc091afa0ad6df18ed14cde38e48c6e71550aa513918b056044983aee402de21051235eecf4ce8040fbe +96c030381e97050a45a318d307dcb3c8377b79b4dd5daf6337cded114de26eb725c14171b9b8e1b3c08fe1f5ea6b49e0 +90c23b86b6111818c8baaf53a13eaee1c89203b50e7f9a994bf0edf851919b48edbac7ceef14ac9414cf70c486174a77 +8bf6c301240d2d1c8d84c71d33a6dfc6d9e8f1cfae66d4d0f7a256d98ae12b0bcebfa94a667735ee89f810bcd7170cff +a41a4ffbbea0e36874d65c009ee4c3feffff322f6fc0e30d26ee4dbc1f46040d05e25d9d0ecb378cef0d24a7c2c4b850 +a8d4cdd423986bb392a0a92c12a8bd4da3437eec6ef6af34cf5310944899287452a2eb92eb5386086d5063381189d10e +a81dd26ec057c4032a4ed7ad54d926165273ed51d09a1267b2e477535cf6966835a257c209e4e92d165d74fa75695fa3 +8d7f708c3ee8449515d94fc26b547303b53d8dd55f177bc3b25d3da2768accd9bc8e9f09546090ebb7f15c66e6c9c723 +839ba65cffcd24cfffa7ab3b21faabe3c66d4c06324f07b2729c92f15cad34e474b0f0ddb16cd652870b26a756b731d3 +87f1a3968afec354d92d77e2726b702847c6afcabb8438634f9c6f7766de4c1504317dc4fa9a4a735acdbf985e119564 +91a8a7fd6542f3e0673f07f510d850864b34ac087eb7eef8845a1d14b2b1b651cbdc27fa4049bdbf3fea54221c5c8549 +aef3cf5f5e3a2385ead115728d7059e622146c3457d266c612e778324b6e06fbfb8f98e076624d2f3ce1035d65389a07 +819915d6232e95ccd7693fdd78d00492299b1983bc8f96a08dcb50f9c0a813ed93ae53c0238345d5bea0beda2855a913 +8e9ba68ded0e94935131b392b28218315a185f63bf5e3c1a9a9dd470944509ca0ba8f6122265f8da851b5cc2abce68f1 +b28468e9b04ee9d69003399a3cf4457c9bf9d59f36ab6ceeb8e964672433d06b58beeea198fedc7edbaa1948577e9fa2 +a633005e2c9f2fd94c8bce2dd5bb708fe946b25f1ec561ae65e54e15cdd88dc339f1a083e01f0d39610c8fe24151aaf0 +841d0031e22723f9328dd993805abd13e0c99b0f59435d2426246996b08d00ce73ab906f66c4eab423473b409e972ce0 +85758d1b084263992070ec8943f33073a2d9b86a8606672550c17545507a5b3c88d87382b41916a87ee96ff55a7aa535 +8581b06b0fc41466ef94a76a1d9fb8ae0edca6d018063acf6a8ca5f4b02d76021902feba58972415691b4bdbc33ae3b4 +83539597ff5e327357ee62bc6bf8c0bcaec2f227c55c7c385a4806f0d37fb461f1690bad5066b8a5370950af32fafbef +aee3557290d2dc10827e4791d00e0259006911f3f3fce4179ed3c514b779160613eca70f720bff7804752715a1266ffa +b48d2f0c4e90fc307d5995464e3f611a9b0ef5fe426a289071f4168ed5cc4f8770c9332960c2ca5c8c427f40e6bb389f +847af8973b4e300bb06be69b71b96183fd1a0b9d51b91701bef6fcfde465068f1eb2b1503b07afda380f18d69de5c9e1 +a70a6a80ce407f07804c0051ac21dc24d794b387be94eb24e1db94b58a78e1bcfb48cd0006db8fc1f9bedaece7a44fbe +b40e942b8fa5336910ff0098347df716bff9d1fa236a1950c16eeb966b3bc1a50b8f7b0980469d42e75ae13ced53cead +b208fabaa742d7db3148515330eb7a3577487845abdb7bd9ed169d0e081db0a5816595c33d375e56aeac5b51e60e49d3 +b7c8194b30d3d6ef5ab66ec88ad7ebbc732a3b8a41731b153e6f63759a93f3f4a537eab9ad369705bd730184bdbbdc34 +9280096445fe7394d04aa1bc4620c8f9296e991cc4d6c131bd703cb1cc317510e6e5855ac763f4d958c5edfe7eebeed7 +abc2aa4616a521400af1a12440dc544e3c821313d0ab936c86af28468ef8bbe534837e364598396a81cf8d06274ed5a6 +b18ca8a3325adb0c8c18a666d4859535397a1c3fe08f95eebfac916a7a99bbd40b3c37b919e8a8ae91da38bc00fa56c0 +8a40c33109ecea2a8b3558565877082f79121a432c45ec2c5a5e0ec4d1c203a6788e6b69cb37f1fd5b8c9a661bc5476d +88c47301dd30998e903c84e0b0f2c9af2e1ce6b9f187dab03528d44f834dc991e4c86d0c474a2c63468cf4020a1e24a0 +920c832853e6ab4c851eecfa9c11d3acc7da37c823be7aa1ab15e14dfd8beb5d0b91d62a30cec94763bd8e4594b66600 +98e1addbe2a6b8edc7f12ecb9be81c3250aeeca54a1c6a7225772ca66549827c15f3950d01b8eb44aecb56fe0fff901a +8cfb0fa1068be0ec088402f5950c4679a2eb9218c729da67050b0d1b2d7079f3ddf4bf0f57d95fe2a8db04bc6bcdb20c +b70f381aafe336b024120453813aeab70baac85b9c4c0f86918797b6aee206e6ed93244a49950f3d8ec9f81f4ac15808 +a4c8edf4aa33b709a91e1062939512419711c1757084e46f8f4b7ed64f8e682f4e78b7135920c12f0eb0422fe9f87a6a +b4817e85fd0752d7ebb662d3a51a03367a84bac74ebddfba0e5af5e636a979500f72b148052d333b3dedf9edd2b4031b +a87430169c6195f5d3e314ff2d1c2f050e766fd5d2de88f5207d72dba4a7745bb86d0baca6e9ae156582d0d89e5838c7 +991b00f8b104566b63a12af4826b61ce7aa40f4e5b8fff3085e7a99815bdb4471b6214da1e480214fac83f86a0b93cc5 +b39966e3076482079de0678477df98578377a094054960ee518ef99504d6851f8bcd3203e8da5e1d4f6f96776e1fe6eb +a448846d9dc2ab7a0995fa44b8527e27f6b3b74c6e03e95edb64e6baa4f1b866103f0addb97c84bef1d72487b2e21796 +894bec21a453ae84b592286e696c35bc30e820e9c2fd3e63dd4fbe629e07df16439c891056070faa490155f255bf7187 +a9ec652a491b11f6a692064e955f3f3287e7d2764527e58938571469a1e29b5225b9415bd602a45074dfbfe9c131d6ca +b39d37822e6cbe28244b5f42ce467c65a23765bd16eb6447c5b3e942278069793763483dafd8c4dd864f8917aad357fe +88dba51133f2019cb266641c56101e3e5987d3b77647a2e608b5ff9113dfc5f85e2b7c365118723131fbc0c9ca833c9c +b566579d904b54ecf798018efcb824dccbebfc6753a0fd2128ac3b4bd3b038c2284a7c782b5ca6f310eb7ea4d26a3f0a +a97a55c0a492e53c047e7d6f9d5f3e86fb96f3dddc68389c0561515343b66b4bc02a9c0d5722dff1e3445308240b27f7 +a044028ab4bcb9e1a2b9b4ca4efbf04c5da9e4bf2fff0e8bd57aa1fc12a71e897999c25d9117413faf2f45395dee0f13 +a78dc461decbeaeed8ebd0909369b491a5e764d6a5645a7dac61d3140d7dc0062526f777b0eb866bff27608429ebbdde +b2c2a8991f94c39ca35fea59f01a92cb3393e0eccb2476dfbf57261d406a68bd34a6cff33ed80209991688c183609ef4 +84189eefb521aff730a4fd3fd5b10ddfd29f0d365664caef63bb015d07e689989e54c33c2141dd64427805d37a7e546e +85ac80bd734a52235da288ff042dea9a62e085928954e8eacd2c751013f61904ed110e5b3afe1ab770a7e6485efb7b5e +9183a560393dcb22d0d5063e71182020d0fbabb39e32493eeffeb808df084aa243eb397027f150b55a247d1ed0c8513e +81c940944df7ecc58d3c43c34996852c3c7915ed185d7654627f7af62abae7e0048dd444a6c09961756455000bd96d09 +aa8c34e164019743fd8284b84f06c3b449aae7996e892f419ee55d82ad548cb300fd651de329da0384243954c0ef6a60 +89a7b7bdfc7e300d06a14d463e573d6296d8e66197491900cc9ae49504c4809ff6e61b758579e9091c61085ba1237b83 +878d21809ba540f50bd11f4c4d9590fb6f3ab9de5692606e6e2ef4ed9d18520119e385be5e1f4b3f2e2b09c319f0e8fc +8eb248390193189cf0355365e630b782cd15751e672dc478b39d75dc681234dcd9309df0d11f4610dbb249c1e6be7ef9 +a1d7fb3aecb896df3a52d6bd0943838b13f1bd039c936d76d03de2044c371d48865694b6f532393b27fd10a4cf642061 +a34bca58a24979be442238cbb5ece5bee51ae8c0794dd3efb3983d4db713bc6f28a96e976ac3bd9a551d3ed9ba6b3e22 +817c608fc8cacdd178665320b5a7587ca21df8bdd761833c3018b967575d25e3951cf3d498a63619a3cd2ad4406f5f28 +86c95707db0495689afd0c2e39e97f445f7ca0edffad5c8b4cacd1421f2f3cc55049dfd504f728f91534e20383955582 +99c3b0bb15942c301137765d4e19502f65806f3b126dc01a5b7820c87e8979bce6a37289a8f6a4c1e4637227ad5bf3bf +8aa1518a80ea8b074505a9b3f96829f5d4afa55a30efe7b4de4e5dbf666897fdd2cf31728ca45921e21a78a80f0e0f10 +8d74f46361c79e15128ac399e958a91067ef4cec8983408775a87eca1eed5b7dcbf0ddf30e66f51780457413496c7f07 +a41cde4a786b55387458a1db95171aca4fd146507b81c4da1e6d6e495527c3ec83fc42fad1dfe3d92744084a664fd431 +8c352852c906fae99413a84ad11701f93f292fbf7bd14738814f4c4ceab32db02feb5eb70bc73898b0bc724a39d5d017 +a5993046e8f23b71ba87b7caa7ace2d9023fb48ce4c51838813174880d918e9b4d2b0dc21a2b9c6f612338c31a289df8 +83576d3324bf2d8afbfb6eaecdc5d767c8e22e7d25160414924f0645491df60541948a05e1f4202e612368e78675de8a +b43749b8df4b15bc9a3697e0f1c518e6b04114171739ef1a0c9c65185d8ec18e40e6954d125cbc14ebc652cf41ad3109 +b4eebd5d80a7327a040cafb9ccdb12b2dfe1aa86e6bc6d3ac8a57fadfb95a5b1a7332c66318ff72ba459f525668af056 +9198be7f1d413c5029b0e1c617bcbc082d21abe2c60ec8ce9b54ca1a85d3dba637b72fda39dae0c0ae40d047eab9f55a +8d96a0232832e24d45092653e781e7a9c9520766c3989e67bbe86b3a820c4bf621ea911e7cd5270a4bfea78b618411f6 +8d7160d0ea98161a2d14d46ef01dff72d566c330cd4fabd27654d300e1bc7644c68dc8eabf2a20a59bfe7ba276545f9b +abb60fce29dec7ba37e3056e412e0ec3e05538a1fc0e2c68877378c867605966108bc5742585ab6a405ce0c962b285b6 +8fabffa3ed792f05e414f5839386f6449fd9f7b41a47595c5d71074bd1bb3784cc7a1a7e1ad6b041b455035957e5b2dc +90ff017b4804c2d0533b72461436b10603ab13a55f86fd4ec11b06a70ef8166f958c110519ca1b4cc7beba440729fe2d +b340cfd120f6a4623e3a74cf8c32bfd7cd61a280b59dfd17b15ca8fae4d82f64a6f15fbde4c02f424debc72b7db5fe67 +871311c9c7220c932e738d59f0ecc67a34356d1429fe570ca503d340c9996cb5ee2cd188fad0e3bd16e4c468ec1dbebd +a772470262186e7b94239ba921b29f2412c148d6f97c4412e96d21e55f3be73f992f1ad53c71008f0558ec3f84e2b5a7 +b2a897dcb7ffd6257f3f2947ec966f2077d57d5191a88840b1d4f67effebe8c436641be85524d0a21be734c63ab5965d +a044f6eacc48a4a061fa149500d96b48cbf14853469aa4d045faf3dca973be1bd4b4ce01646d83e2f24f7c486d03205d +981af5dc2daa73f7fa9eae35a93d81eb6edba4a7f673b55d41f6ecd87a37685d31bb40ef4f1c469b3d72f2f18b925a17 +912d2597a07864de9020ac77083eff2f15ceb07600f15755aba61251e8ce3c905a758453b417f04d9c38db040954eb65 +9642b7f6f09394ba5e0805734ef6702c3eddf9eea187ba98c676d5bbaec0e360e3e51dc58433aaa1e2da6060c8659cb7 +8ab3836e0a8ac492d5e707d056310c4c8e0489ca85eb771bff35ba1d658360084e836a6f51bb990f9e3d2d9aeb18fbb5 +879e058e72b73bb1f4642c21ffdb90544b846868139c6511f299aafe59c2d0f0b944dffc7990491b7c4edcd6a9889250 +b9e60b737023f61479a4a8fd253ed0d2a944ea6ba0439bbc0a0d3abf09b0ad1f18d75555e4a50405470ae4990626f390 +b9c2535d362796dcd673640a9fa2ebdaec274e6f8b850b023153b0a7a30fffc87f96e0b72696f647ebe7ab63099a6963 +94aeff145386a087b0e91e68a84a5ede01f978f9dd9fe7bebca78941938469495dc30a96bba9508c0d017873aeea9610 +98b179f8a3d9f0d0a983c30682dd425a2ddc7803be59bd626c623c8951a5179117d1d2a68254c95c9952989877d0ee55 +889ecf5f0ee56938273f74eb3e9ecfb5617f04fb58e83fe4c0e4aef51615cf345bc56f3f61b17f6eed3249d4afd54451 +a0f2b2c39bcea4b50883e2587d16559e246248a66ecb4a4b7d9ab3b51fb39fe98d83765e087eee37a0f86b0ba4144c02 +b2a61e247ed595e8a3830f7973b07079cbda510f28ad8c78c220b26cb6acde4fbb5ee90c14a665f329168ee951b08cf0 +95bd0fcfb42f0d6d8a8e73d7458498a85bcddd2fb132fd7989265648d82ac2707d6d203fac045504977af4f0a2aca4b7 +843e5a537c298666e6cf50fcc044f13506499ef83c802e719ff2c90e85003c132024e04711be7234c04d4b0125512d5d +a46d1797c5959dcd3a5cfc857488f4d96f74277c3d13b98b133620192f79944abcb3a361d939a100187f1b0856eae875 +a1c7786736d6707a48515c38660615fcec67eb8a2598f46657855215f804fd72ab122d17f94fcffad8893f3be658dca7 +b23dc9e610abc7d8bd21d147e22509a0fa49db5be6ea7057b51aae38e31654b3aa044df05b94b718153361371ba2f622 +b00cc8f257d659c22d30e6d641f79166b1e752ea8606f558e4cad6fc01532e8319ea4ee12265ba4140ac45aa4613c004 +ac7019af65221b0cc736287b32d7f1a3561405715ba9a6a122342e04e51637ba911c41573de53e4781f2230fdcb2475f +81a630bc41b3da8b3eb4bf56cba10cd9f93153c3667f009dc332287baeb707d505fb537e6233c8e53d299ec0f013290c +a6b7aea5c545bb76df0f230548539db92bc26642572cb7dd3d5a30edca2b4c386f44fc8466f056b42de2a452b81aff5b +8271624ff736b7b238e43943c81de80a1612207d32036d820c11fc830c737972ccc9c60d3c2359922b06652311e3c994 +8a684106458cb6f4db478170b9ad595d4b54c18bf63b9058f095a2fa1b928c15101472c70c648873d5887880059ed402 +a5cc3c35228122f410184e4326cf61a37637206e589fcd245cb5d0cec91031f8f7586b80503070840fdfd8ce75d3c88b +9443fc631aed8866a7ed220890911057a1f56b0afe0ba15f0a0e295ab97f604b134b1ed9a4245e46ee5f9a93aa74f731 +984b6f7d79835dffde9558c6bb912d992ca1180a2361757bdba4a7b69dc74b056e303adc69fe67414495dd9c2dd91e64 +b15a5c8cba5de080224c274d31c68ed72d2a7126d347796569aef0c4e97ed084afe3da4d4b590b9dda1a07f0c2ff3dfb +991708fe9650a1f9a4e43938b91d45dc68c230e05ee999c95dbff3bf79b1c1b2bb0e7977de454237c355a73b8438b1d9 +b4f7edc7468b176a4a7c0273700c444fa95c726af6697028bed4f77eee887e3400f9c42ee15b782c0ca861c4c3b8c98a +8c60dcc16c51087eb477c13e837031d6c6a3dc2b8bf8cb43c23f48006bc7173151807e866ead2234b460c2de93b31956 +83ad63e9c910d1fc44bc114accfb0d4d333b7ebe032f73f62d25d3e172c029d5e34a1c9d547273bf6c0fead5c8801007 +85de73213cc236f00777560756bdbf2b16841ba4b55902cf2cad9742ecaf5d28209b012ceb41f337456dfeca93010cd7 +a7561f8827ccd75b6686ba5398bb8fc3083351c55a589b18984e186820af7e275af04bcd4c28e1dc11be1e8617a0610b +88c0a4febd4068850557f497ea888035c7fc9f404f6cc7794e7cc8722f048ad2f249e7dc62743e7a339eb7473ad3b0cd +932b22b1d3e6d5a6409c34980d176feb85ada1bf94332ef5c9fc4d42b907dabea608ceef9b5595ef3feee195151f18d8 +a2867bb3f5ab88fbdae3a16c9143ab8a8f4f476a2643c505bb9f37e5b1fd34d216cab2204c9a017a5a67b7ad2dda10e8 +b573d5f38e4e9e8a3a6fd82f0880dc049efa492a946d00283019bf1d5e5516464cf87039e80aef667cb86fdea5075904 +b948f1b5ab755f3f5f36af27d94f503b070696d793b1240c1bdfd2e8e56890d69e6904688b5f8ff5a4bdf5a6abfe195f +917eae95ebc4109a2e99ddd8fec7881d2f7aaa0e25fda44dec7ce37458c2ee832f1829db7d2dcfa4ca0f06381c7fe91d +95751d17ed00a3030bce909333799bb7f4ab641acf585807f355b51d6976dceee410798026a1a004ef4dcdff7ec0f5b8 +b9b7bd266f449a79bbfe075e429613e76c5a42ac61f01c8f0bbbd34669650682efe01ff9dbbc400a1e995616af6aa278 +ac1722d097ce9cd7617161f8ec8c23d68f1fb1c9ca533e2a8b4f78516c2fd8fb38f23f834e2b9a03bb06a9d655693ca9 +a7ad9e96ffd98db2ecdb6340c5d592614f3c159abfd832fe27ee9293519d213a578e6246aae51672ee353e3296858873 +989b8814d5de7937c4acafd000eec2b4cd58ba395d7b25f98cafd021e8efa37029b29ad8303a1f6867923f5852a220eb +a5bfe6282c771bc9e453e964042d44eff4098decacb89aecd3be662ea5b74506e1357ab26f3527110ba377711f3c9f41 +8900a7470b656639721d2abbb7b06af0ac4222ab85a1976386e2a62eb4b88bfb5b72cf7921ddb3cf3a395d7eeb192a2e +95a71b55cd1f35a438cf5e75f8ff11c5ec6a2ebf2e4dba172f50bfad7d6d5dca5de1b1afc541662c81c858f7604c1163 +82b5d62fea8db8d85c5bc3a76d68dedd25794cf14d4a7bc368938ffca9e09f7e598fdad2a5aac614e0e52f8112ae62b9 +997173f07c729202afcde3028fa7f52cefc90fda2d0c8ac2b58154a5073140683e54c49ed1f254481070d119ce0ce02a +aeffb91ccc7a72bbd6ffe0f9b99c9e66e67d59cec2e02440465e9636a613ab3017278cfa72ea8bc4aba9a8dc728cb367 +952743b06e8645894aeb6440fc7a5f62dd3acf96dab70a51e20176762c9751ea5f2ba0b9497ccf0114dc4892dc606031 +874c63baeddc56fbbca2ff6031f8634b745f6e34ea6791d7c439201aee8f08ef5ee75f7778700a647f3b21068513fce6 +85128fec9c750c1071edfb15586435cc2f317e3e9a175bb8a9697bcda1eb9375478cf25d01e7fed113483b28f625122d +85522c9576fd9763e32af8495ae3928ed7116fb70d4378448926bc9790e8a8d08f98cf47648d7da1b6e40d6a210c7924 +97d0f37a13cfb723b848099ca1c14d83e9aaf2f7aeb71829180e664b7968632a08f6a85f557d74b55afe6242f2a36e7c +abaa472d6ad61a5fccd1a57c01aa1bc081253f95abbcba7f73923f1f11c4e79b904263890eeb66926de3e2652f5d1c70 +b3c04945ba727a141e5e8aec2bf9aa3772b64d8fd0e2a2b07f3a91106a95cbcb249adcd074cbe498caf76fffac20d4ef +82c46781a3d730d9931bcabd7434a9171372dde57171b6180e5516d4e68db8b23495c8ac3ab96994c17ddb1cf249b9fb +a202d8b65613c42d01738ccd68ed8c2dbc021631f602d53f751966e04182743ebc8e0747d600b8a8676b1da9ae7f11ab +ae73e7256e9459db04667a899e0d3ea5255211fb486d084e6550b6dd64ca44af6c6b2d59d7aa152de9f96ce9b58d940d +b67d87b176a9722945ec7593777ee461809861c6cfd1b945dde9ee4ff009ca4f19cf88f4bbb5c80c9cbab2fe25b23ac8 +8f0b7a317a076758b0dac79959ee4a06c08b07d0f10538a4b53d3da2eda16e2af26922feb32c090330dc4d969cf69bd3 +90b36bf56adbd8c4b6cb32febc3a8d5f714370c2ac3305c10fa6d168dffb2a026804517215f9a2d4ec8310cdb6bb459b +aa80c19b0682ead69934bf18cf476291a0beddd8ef4ed75975d0a472e2ab5c70f119722a8574ae4973aceb733d312e57 +a3fc9abb12574e5c28dcb51750b4339b794b8e558675eef7d26126edf1de920c35e992333bcbffcbf6a5f5c0d383ce62 +a1573ff23ab972acdcd08818853b111fc757fdd35aa070186d3e11e56b172fb49d840bf297ac0dd222e072fc09f26a81 +98306f2be4caa92c2b4392212d0cbf430b409b19ff7d5b899986613bd0e762c909fc01999aa94be3bd529d67f0113d7f +8c1fc42482a0819074241746d17dc89c0304a2acdae8ed91b5009e9e3e70ff725ba063b4a3e68fdce05b74f5180c545e +a6c6113ebf72d8cf3163b2b8d7f3fa24303b13f55752522c660a98cd834d85d8c79214d900fa649499365e2e7641f77a +ab95eea424f8a2cfd9fb1c78bb724e5b1d71a0d0d1e4217c5d0f98b0d8bbd3f8400a2002abc0a0e4576d1f93f46fefad +823c5a4fd8cf4a75fdc71d5f2dd511b6c0f189b82affeacd2b7cfcad8ad1a5551227dcc9bfdb2e34b2097eaa00efbb51 +b97314dfff36d80c46b53d87a61b0e124dc94018a0bb680c32765b9a2d457f833a7c42bbc90b3b1520c33a182580398d +b17566ee3dcc6bb3b004afe4c0136dfe7dd27df9045ae896dca49fb36987501ae069eb745af81ba3fc19ff037e7b1406 +b0bdc0f55cfd98d331e3a0c4fbb776a131936c3c47c6bffdc3aaf7d8c9fa6803fbc122c2fefbb532e634228687d52174 +aa5d9e60cc9f0598559c28bb9bdd52aa46605ab4ffe3d192ba982398e72cec9a2a44c0d0d938ce69935693cabc0887ea +802b6459d2354fa1d56c592ac1346c428dadea6b6c0a87bf7d309bab55c94e1cf31dd98a7a86bd92a840dd51f218b91b +a526914efdc190381bf1a73dd33f392ecf01350b9d3f4ae96b1b1c3d1d064721c7d6eec5788162c933245a3943f5ee51 +b3b8fcf637d8d6628620a1a99dbe619eabb3e5c7ce930d6efd2197e261bf394b74d4e5c26b96c4b8009c7e523ccfd082 +8f7510c732502a93e095aba744535f3928f893f188adc5b16008385fb9e80f695d0435bfc5b91cdad4537e87e9d2551c +97b90beaa56aa936c3ca45698f79273a68dd3ccd0076eab48d2a4db01782665e63f33c25751c1f2e070f4d1a8525bf96 +b9fb798324b1d1283fdc3e48288e3861a5449b2ab5e884b34ebb8f740225324af86e4711da6b5cc8361c1db15466602f +b6d52b53cea98f1d1d4c9a759c25bf9d8a50b604b144e4912acbdbdc32aab8b9dbb10d64a29aa33a4f502121a6fb481c +9174ffff0f2930fc228f0e539f5cfd82c9368d26b074467f39c07a774367ff6cccb5039ac63f107677d77706cd431680 +a33b6250d4ac9e66ec51c063d1a6a31f253eb29bbaed12a0d67e2eccfffb0f3a52750fbf52a1c2aaba8c7692346426e7 +a97025fd5cbcebe8ef865afc39cd3ea707b89d4e765ec817fd021d6438e02fa51e3544b1fd45470c58007a08efac6edd +b32a78480edd9ff6ba2f1eec4088db5d6ceb2d62d7e59e904ecaef7bb4a2e983a4588e51692b3be76e6ffbc0b5f911a5 +b5ab590ef0bb77191f00495b33d11c53c65a819f7d0c1f9dc4a2caa147a69c77a4fff7366a602d743ee1f395ce934c1e +b3fb0842f9441fb1d0ee0293b6efbc70a8f58d12d6f769b12872db726b19e16f0f65efbc891cf27a28a248b0ef9c7e75 +9372ad12856fefb928ccb0d34e198df99e2f8973b07e9d417a3134d5f69e12e79ff572c4e03ccd65415d70639bc7c73e +aa8d6e83d09ce216bfe2009a6b07d0110d98cf305364d5529c170a23e693aabb768b2016befb5ada8dabdd92b4d012bb +a954a75791eeb0ce41c85200c3763a508ed8214b5945a42c79bfdcfb1ec4f86ad1dd7b2862474a368d4ac31911a2b718 +8e2081cfd1d062fe3ab4dab01f68062bac802795545fede9a188f6c9f802cb5f884e60dbe866710baadbf55dc77c11a4 +a2f06003b9713e7dd5929501ed485436b49d43de80ea5b15170763fd6346badf8da6de8261828913ee0dacd8ff23c0e1 +98eecc34b838e6ffd1931ca65eec27bcdb2fdcb61f33e7e5673a93028c5865e0d1bf6d3bec040c5e96f9bd08089a53a4 +88cc16019741b341060b95498747db4377100d2a5bf0a5f516f7dec71b62bcb6e779de2c269c946d39040e03b3ae12b7 +ad1135ccbc3019d5b2faf59a688eef2500697642be8cfbdf211a1ab59abcc1f24483e50d653b55ff1834675ac7b4978f +a946f05ed9972f71dfde0020bbb086020fa35b482cce8a4cc36dd94355b2d10497d7f2580541bb3e81b71ac8bba3c49f +a83aeed488f9a19d8cfd743aa9aa1982ab3723560b1cd337fc2f91ad82f07afa412b3993afb845f68d47e91ba4869840 +95eebe006bfc316810cb71da919e5d62c2cebb4ac99d8e8ef67be420302320465f8b69873470982de13a7c2e23516be9 +a55f8961295a11e91d1e5deadc0c06c15dacbfc67f04ccba1d069cba89d72aa3b3d64045579c3ea8991b150ac29366ae +b321991d12f6ac07a5de3c492841d1a27b0d3446082fbce93e7e1f9e8d8fe3b45d41253556261c21b70f5e189e1a7a6f +a0b0822f15f652ce7962a4f130104b97bf9529797c13d6bd8e24701c213cc37f18157bd07f3d0f3eae6b7cd1cb40401f +96e2fa4da378aa782cc2d5e6e465fc9e49b5c805ed01d560e9b98abb5c0de8b74a2e7bec3aa5e2887d25cccb12c66f0c +97e4ab610d414f9210ed6f35300285eb3ccff5b0b6a95ed33425100d7725e159708ea78704497624ca0a2dcabce3a2f9 +960a375b17bdb325761e01e88a3ea57026b2393e1d887b34b8fa5d2532928079ce88dc9fd06a728b26d2bb41b12b9032 +8328a1647398e832aadc05bd717487a2b6fcdaa0d4850d2c4da230c6a2ed44c3e78ec4837b6094f3813f1ee99414713f +aa283834ebd18e6c99229ce4b401eda83f01d904f250fedd4e24f1006f8fa0712a6a89a7296a9bf2ce8de30e28d1408e +b29e097f2caadae3e0f0ae3473c072b0cd0206cf6d2e9b22c1a5ad3e07d433e32bd09ed1f4e4276a2da4268633357b7f +9539c5cbba14538b2fe077ecf67694ef240da5249950baaabea0340718b882a966f66d97f08556b08a4320ceb2cc2629 +b4529f25e9b42ae8cf8338d2eface6ba5cd4b4d8da73af502d081388135c654c0b3afb3aa779ffc80b8c4c8f4425dd2b +95be0739c4330619fbe7ee2249c133c91d6c07eab846c18c5d6c85fc21ac5528c5d56dcb0145af68ed0c6a79f68f2ccd +ac0c83ea802227bfc23814a24655c9ff13f729619bcffdb487ccbbf029b8eaee709f8bddb98232ef33cd70e30e45ca47 +b503becb90acc93b1901e939059f93e671900ca52c6f64ae701d11ac891d3a050b505d89324ce267bc43ab8275da6ffe +98e3811b55b1bacb70aa409100abb1b870f67e6d059475d9f278c751b6e1e2e2d6f2e586c81a9fb6597fda06e7923274 +b0b0f61a44053fa6c715dbb0731e35d48dba257d134f851ee1b81fd49a5c51a90ebf5459ec6e489fce25da4f184fbdb1 +b1d2117fe811720bb997c7c93fe9e4260dc50fca8881b245b5e34f724aaf37ed970cdad4e8fcb68e05ac8cf55a274a53 +a10f502051968f14b02895393271776dee7a06db9de14effa0b3471825ba94c3f805302bdddac4d397d08456f620999d +a3dbad2ef060ae0bb7b02eaa4a13594f3f900450faa1854fc09620b01ac94ab896321dfb1157cf2374c27e5718e8026a +b550fdec503195ecb9e079dcdf0cad559d64d3c30818ef369b4907e813e689da316a74ad2422e391b4a8c2a2bef25fc0 +a25ba865e2ac8f28186cea497294c8649a201732ecb4620c4e77b8e887403119910423df061117e5f03fc5ba39042db1 +b3f88174e03fdb443dd6addd01303cf88a4369352520187c739fc5ae6b22fa99629c63c985b4383219dab6acc5f6f532 +97a7503248e31e81b10eb621ba8f5210c537ad11b539c96dfb7cf72b846c7fe81bd7532c5136095652a9618000b7f8d3 +a8bcdc1ce5aa8bfa683a2fc65c1e79de8ff5446695dcb8620f7350c26d2972a23da22889f9e2b1cacb3f688c6a2953dc +8458c111df2a37f5dd91a9bee6c6f4b79f4f161c93fe78075b24a35f9817da8dde71763218d627917a9f1f0c4709c1ed +ac5f061a0541152b876cbc10640f26f1cc923c9d4ae1b6621e4bb3bf2cec59bbf87363a4eb72fb0e5b6d4e1c269b52d5 +a9a25ca87006e8a9203cbb78a93f50a36694aa4aad468b8d80d3feff9194455ca559fcc63838128a0ab75ad78c07c13a +a450b85f5dfffa8b34dfd8bc985f921318efacf8857cf7948f93884ba09fb831482ee90a44224b1a41e859e19b74962f +8ed91e7f92f5c6d7a71708b6132f157ac226ecaf8662af7d7468a4fa25627302efe31e4620ad28719318923e3a59bf82 +ab524165fd4c71b1fd395467a14272bd2b568592deafa039d8492e9ef36c6d3f96927c95c72d410a768dc0b6d1fbbc9b +b662144505aa8432c75ffb8d10318526b6d5777ac7af9ebfad87d9b0866c364f7905a6352743bd8fd79ffd9d5dd4f3e6 +a48f1677550a5cd40663bb3ba8f84caaf8454f332d0ceb1d94dbea52d0412fe69c94997f7749929712fd3995298572f7 +8391cd6e2f6b0c242de1117a612be99776c3dc95cb800b187685ea5bf7e2722275eddb79fd7dfc8be8e389c4524cdf70 +875d3acb9af47833b72900bc0a2448999d638f153c5e97e8a14ec02d0c76f6264353a7e275e1f1a5855daced523d243b +91f1823657d30b59b2f627880a9a9cb530f5aca28a9fd217fe6f2f5133690dfe7ad5a897872e400512db2e788b3f7628 +ad3564332aa56cea84123fc7ca79ea70bb4fef2009fa131cb44e4b15e8613bd11ca1d83b9d9bf456e4b7fee9f2e8b017 +8c530b84001936d5ab366c84c0b105241a26d1fb163669f17c8f2e94776895c2870edf3e1bc8ccd04d5e65531471f695 +932d01fa174fdb0c366f1230cffde2571cc47485f37f23ba5a1825532190cc3b722aeb1f15aed62cf83ccae9403ba713 +88b28c20585aca50d10752e84b901b5c2d58efef5131479fbbe53de7bce2029e1423a494c0298e1497669bd55be97a5d +b914148ca717721144ebb3d3bf3fcea2cd44c30c5f7051b89d8001502f3856fef30ec167174d5b76265b55d70f8716b5 +81d0173821c6ddd2a068d70766d9103d1ee961c475156e0cbd67d54e668a796310474ef698c7ab55abe6f2cf76c14679 +8f28e8d78e2fe7fa66340c53718e0db4b84823c8cfb159c76eac032a62fb53da0a5d7e24ca656cf9d2a890cb2a216542 +8a26360335c73d1ab51cec3166c3cf23b9ea51e44a0ad631b0b0329ef55aaae555420348a544e18d5760969281759b61 +94f326a32ed287545b0515be9e08149eb0a565025074796d72387cc3a237e87979776410d78339e23ef3172ca43b2544 +a785d2961a2fa5e70bffa137858a92c48fe749fee91b02599a252b0cd50d311991a08efd7fa5e96b78d07e6e66ffe746 +94af9030b5ac792dd1ce517eaadcec1482206848bea4e09e55cc7f40fd64d4c2b3e9197027c5636b70d6122c51d2235d +9722869f7d1a3992850fe7be405ec93aa17dc4d35e9e257d2e469f46d2c5a59dbd504056c85ab83d541ad8c13e8bcd54 +b13c4088b61a06e2c03ac9813a75ff1f68ffdfee9df6a8f65095179a475e29cc49119cad2ce05862c3b1ac217f3aace9 +8c64d51774753623666b10ca1b0fe63ae42f82ed6aa26b81dc1d48c86937c5772eb1402624c52a154b86031854e1fb9f +b47e4df18002b7dac3fee945bf9c0503159e1b8aafcce2138818e140753011b6d09ef1b20894e08ba3006b093559061b +93cb5970076522c5a0483693f6a35ffd4ea2aa7aaf3730c4eccd6af6d1bebfc1122fc4c67d53898ae13eb6db647be7e2 +a68873ef80986795ea5ed1a597d1cd99ed978ec25e0abb57fdcc96e89ef0f50aeb779ff46e3dce21dc83ada3157a8498 +8cab67f50949cc8eee6710e27358aea373aae3c92849f8f0b5531c080a6300cdf2c2094fe6fecfef6148de0d28446919 +993e932bcb616dbaa7ad18a4439e0565211d31071ef1b85a0627db74a05d978c60d507695eaeea5c7bd9868a21d06923 +acdadff26e3132d9478a818ef770e9fa0d2b56c6f5f48bd3bd674436ccce9bdfc34db884a73a30c04c5f5e9764cb2218 +a0d3e64c9c71f84c0eef9d7a9cb4fa184224b969db5514d678e93e00f98b41595588ca802643ea225512a4a272f5f534 +91c9140c9e1ba6e330cb08f6b2ce4809cd0d5a0f0516f70032bf30e912b0ed684d07b413b326ab531ee7e5b4668c799b +87bc2ee7a0c21ba8334cd098e35cb703f9af57f35e091b8151b9b63c3a5b0f89bd7701dbd44f644ea475901fa6d9ef08 +9325ccbf64bf5d71b303e31ee85d486298f9802c5e55b2c3d75427097bf8f60fa2ab4fcaffa9b60bf922c3e24fbd4b19 +95d0506e898318f3dc8d28d16dfd9f0038b54798838b3c9be2a2ae3c2bf204eb496166353fc042220b0bd4f6673b9285 +811de529416331fe9c416726d45df9434c29dcd7e949045eb15740f47e97dde8f31489242200e19922cac2a8b7c6fd1f +ade632d04a4c8bbab6ca7df370b2213cb9225023e7973f0e29f4f5e52e8aeaabc65171306bbdd12a67b195dfbb96d48f +88b7f029e079b6ae956042c0ea75d53088c5d0efd750dd018adaeacf46be21bf990897c58578c491f41afd3978d08073 +91f477802de507ffd2be3f4319903119225b277ad24f74eb50f28b66c14d32fae53c7edb8c7590704741af7f7f3e3654 +809838b32bb4f4d0237e98108320d4b079ee16ed80c567e7548bd37e4d7915b1192880f4812ac0e00476d246aec1dbc8 +84183b5fc4a7997a8ae5afedb4d21dce69c480d5966b5cbdafd6dd10d29a9a6377f3b90ce44da0eb8b176ac3af0253bb +8508abbf6d3739a16b9165caf0f95afb3b3ac1b8c38d6d374cf0c91296e2c1809a99772492b539cda184510bce8a0271 +8722054e59bab2062e6419a6e45fc803af77fde912ef2cd23055ad0484963de65a816a2debe1693d93c18218d2b8e81a +8e895f80e485a7c4f56827bf53d34b956281cdc74856c21eb3b51f6288c01cc3d08565a11cc6f3e2604775885490e8c5 +afc92714771b7aa6e60f3aee12efd9c2595e9659797452f0c1e99519f67c8bc3ac567119c1ddfe82a3e961ee9defea9a +818ff0fd9cefd32db87b259e5fa32967201016fc02ef44116cdca3c63ce5e637756f60477a408709928444a8ad69c471 +8251e29af4c61ae806fc5d032347fb332a94d472038149225298389495139ce5678fae739d02dfe53a231598a992e728 +a0ea39574b26643f6f1f48f99f276a8a64b5481989cfb2936f9432a3f8ef5075abfe5c067dc5512143ce8bf933984097 +af67a73911b372bf04e57e21f289fc6c3dfac366c6a01409b6e76fea4769bdb07a6940e52e8d7d3078f235c6d2f632c6 +b5291484ef336024dd2b9b4cf4d3a6b751133a40656d0a0825bcc6d41c21b1c79cb50b0e8f4693f90c29c8f4358641f9 +8bc0d9754d70f2cb9c63f991902165a87c6535a763d5eece43143b5064ae0bcdce7c7a8f398f2c1c29167b2d5a3e6867 +8d7faff53579ec8f6c92f661c399614cc35276971752ce0623270f88be937c414eddcb0997e14724a783905a026c8883 +9310b5f6e675fdf60796f814dbaa5a6e7e9029a61c395761e330d9348a7efab992e4e115c8be3a43d08e90d21290c892 +b5eb4f3eb646038ad2a020f0a42202532d4932e766da82b2c1002bf9c9c2e5336b54c8c0ffcc0e02d19dde2e6a35b6cc +91dabfd30a66710f1f37a891136c9be1e23af4abf8cb751f512a40c022a35f8e0a4fb05b17ec36d4208de02d56f0d53a +b3ded14e82d62ac7a5a036122a62f00ff8308498f3feae57d861babaff5a6628d43f0a0c5fc903f10936bcf4e2758ceb +a88e8348fed2b26acca6784d19ef27c75963450d99651d11a950ea81d4b93acd2c43e0ecce100eaf7e78508263d5baf3 +b1f5bbf7c4756877b87bb42163ac570e08c6667c4528bf68b5976680e19beeff7c5effd17009b0718797077e2955457a +ad2e7b516243f915d4d1415326e98b1a7390ae88897d0b03b66c2d9bd8c3fba283d7e8fe44ed3333296a736454cef6d8 +8f82eae096d5b11f995de6724a9af895f5e1c58d593845ad16ce8fcae8507e0d8e2b2348a0f50a1f66a17fd6fac51a5c +890e4404d0657c6c1ee14e1aac132ecf7a568bb3e04137b85ac0f84f1d333bd94993e8750f88eee033a33fb00f85dcc7 +82ac7d3385e035115f1d39a99fc73e5919de44f5e6424579776d118d711c8120b8e5916372c6f27bed4cc64cac170b6c +85ee16d8901c272cfbbe966e724b7a891c1bd5e68efd5d863043ad8520fc409080af61fd726adc680b3f1186fe0ac8b8 +86dc564c9b545567483b43a38f24c41c6551a49cabeebb58ce86404662a12dbfafd0778d30d26e1c93ce222e547e3898 +a29f5b4522db26d88f5f95f18d459f8feefab02e380c2edb65aa0617a82a3c1a89474727a951cef5f15050bcf7b380fb +a1ce039c8f6cac53352899edb0e3a72c76da143564ad1a44858bd7ee88552e2fe6858d1593bbd74aeee5a6f8034b9b9d +97f10d77983f088286bd7ef3e7fdd8fa275a56bec19919adf33cf939a90c8f2967d2b1b6fc51195cb45ad561202a3ed7 +a25e2772e8c911aaf8712bdac1dd40ee061c84d3d224c466cfaae8e5c99604053f940cde259bd1c3b8b69595781dbfec +b31bb95a0388595149409c48781174c340960d59032ab2b47689911d03c68f77a2273576fbe0c2bf4553e330656058c7 +b8b2e9287ad803fb185a13f0d7456b397d4e3c8ad5078f57f49e8beb2e85f661356a3392dbd7bcf6a900baa5582b86a1 +a3d0893923455eb6e96cc414341cac33d2dbc88fba821ac672708cce131761d85a0e08286663a32828244febfcae6451 +82310cb42f647d99a136014a9f881eb0b9791efd2e01fc1841907ad3fc8a9654d3d1dab6689c3607214b4dc2aca01cee +874022d99c16f60c22de1b094532a0bc6d4de700ad01a31798fac1d5088b9a42ad02bef8a7339af7ed9c0d4f16b186ee +94981369e120265aed40910eebc37eded481e90f4596b8d57c3bec790ab7f929784bd33ddd05b7870aad6c02e869603b +a4f1f50e1e2a73f07095e0dd31cb45154f24968dae967e38962341c1241bcd473102fff1ff668b20c6547e9732d11701 +ae2328f3b0ad79fcda807e69a1b5278145225083f150f67511dafc97e079f860c3392675f1752ae7e864c056e592205b +875d8c971e593ca79552c43d55c8c73b17cd20c81ff2c2fed1eb19b1b91e4a3a83d32df150dbfd5db1092d0aebde1e1f +add2e80aa46aae95da73a11f130f4bda339db028e24c9b11e5316e75ba5e63bc991d2a1da172c7c8e8fee038baae3433 +b46dbe1cb3424002aa7de51e82f600852248e251465c440695d52538d3f36828ff46c90ed77fc1d11534fe3c487df8ef +a5e5045d28b4e83d0055863c30c056628c58d4657e6176fd0536f5933f723d60e851bb726d5bf3c546b8ce4ac4a57ef8 +91fec01e86dd1537e498fff7536ea3ca012058b145f29d9ada49370cd7b7193ac380e116989515df1b94b74a55c45df3 +a7428176d6918cd916a310bdc75483c72de660df48cac4e6e7478eef03205f1827ea55afc0df5d5fa7567d14bbea7fc9 +851d89bef45d9761fe5fdb62972209335193610015e16a675149519f9911373bac0919add226ef118d9f3669cfdf4734 +b74acf5c149d0042021cb2422ea022be4c4f72a77855f42393e71ffd12ebb3eec16bdf16f812159b67b79a9706e7156d +99f35dce64ec99aa595e7894b55ce7b5a435851b396e79036ffb249c28206087db4c85379df666c4d95857db02e21ff9 +b6b9a384f70db9e298415b8ab394ee625dafff04be2886476e59df8d052ca832d11ac68a9b93fba7ab055b7bc36948a4 +898ee4aefa923ffec9e79f2219c7389663eb11eb5b49014e04ed4a336399f6ea1691051d86991f4c46ca65bcd4fdf359 +b0f948217b0d65df7599a0ba4654a5e43c84db477936276e6f11c8981efc6eaf14c90d3650107ed4c09af4cc8ec11137 +aa6286e27ac54f73e63dbf6f41865dd94d24bc0cf732262fcaff67319d162bb43af909f6f8ee27b1971939cfbba08141 +8bca7cdf730cf56c7b2c8a2c4879d61361a6e1dba5a3681a1a16c17a56e168ace0e99cf0d15826a1f5e67e6b8a8a049a +a746d876e8b1ce225fcafca603b099b36504846961526589af977a88c60d31ba2cc56e66a3dec8a77b3f3531bf7524c9 +a11e2e1927e6704cdb8874c75e4f1842cef84d7d43d7a38e339e61dc8ba90e61bbb20dd3c12e0b11d2471d58eed245be +a36395e22bc1d1ba8b0459a235203177737397da5643ce54ded3459d0869ff6d8d89f50c73cb62394bf66a959cde9b90 +8b49f12ba2fdf9aca7e5f81d45c07d47f9302a2655610e7634d1e4bd16048381a45ef2c95a8dd5b0715e4b7cf42273af +91cffa2a17e64eb7f76bccbe4e87280ee1dd244e04a3c9eac12e15d2d04845d876eb24fe2ec6d6d266cce9efb281077f +a6b8afabf65f2dee01788114e33a2f3ce25376fb47a50b74da7c3c25ff1fdc8aa9f41307534abbf48acb6f7466068f69 +8d13db896ccfea403bd6441191995c1a65365cab7d0b97fbe9526da3f45a877bd1f4ef2edef160e8a56838cd1586330e +98c717de9e01bef8842c162a5e757fe8552d53269c84862f4d451e7c656ae6f2ae473767b04290b134773f63be6fdb9d +8c2036ace1920bd13cf018e82848c49eb511fad65fd0ff51f4e4b50cf3bfc294afb63cba682c16f52fb595a98fa84970 +a3520fdff05dbad9e12551b0896922e375f9e5589368bcb2cc303bde252743b74460cb5caf99629325d3620f13adc796 +8d4f83a5bfec05caf5910e0ce538ee9816ee18d0bd44c1d0da2a87715a23cd2733ad4d47552c6dc0eb397687d611dd19 +a7b39a0a6a02823452d376533f39d35029867b3c9a6ad6bca181f18c54132d675613a700f9db2440fb1b4fa13c8bf18a +80bcb114b2544b80f404a200fc36860ed5e1ad31fe551acd4661d09730c452831751baa9b19d7d311600d267086a70bc +90dcce03c6f88fc2b08f2b42771eedde90cc5330fe0336e46c1a7d1b5a6c1641e5fcc4e7b3d5db00bd8afca9ec66ed81 +aec15f40805065c98e2965b1ae12a6c9020cfdb094c2d0549acfc7ea2401a5fb48d3ea7d41133cf37c4e096e7ff53eb9 +80e129b735dba49fa627a615d6c273119acec8e219b2f2c4373a332b5f98d66cbbdd688dfbe72a8f8bfefaccc02c50c1 +a9b596da3bdfe23e6799ece5f7975bf7a1979a75f4f546deeaf8b34dfe3e0d623217cb4cf4ccd504cfa3625b88cd53f1 +abcbbb70b16f6e517c0ab4363ab76b46e4ff58576b5f8340e5c0e8cc0e02621b6e23d742d73b015822a238b17cfd7665 +a046937cc6ea6a2e1adae543353a9fe929c1ae4ad655be1cc051378482cf88b041e28b1e9a577e6ccff2d3570f55e200 +831279437282f315e65a60184ef158f0a3dddc15a648dc552bdc88b3e6fe8288d3cfe9f0031846d81350f5e7874b4b33 +993d7916fa213c6d66e7c4cafafc1eaec9a2a86981f91c31eb8a69c5df076c789cbf498a24c84e0ee77af95b42145026 +823907a3b6719f8d49b3a4b7c181bd9bb29fcf842d7c70660c4f351852a1e197ca46cf5e879b47fa55f616fa2b87ce5e +8d228244e26132b234930ee14c75d88df0943cdb9c276a8faf167d259b7efc1beec2a87c112a6c608ad1600a239e9aae +ab6e55766e5bfb0cf0764ed909a8473ab5047d3388b4f46faeba2d1425c4754c55c6daf6ad4751e634c618b53e549529 +ab0cab6860e55a84c5ad2948a7e0989e2b4b1fd637605634b118361497332df32d9549cb854b2327ca54f2bcb85eed8f +b086b349ae03ef34f4b25a57bcaa5d1b29bd94f9ebf87e22be475adfe475c51a1230c1ebe13506cb72c4186192451658 +8a0b49d8a254ca6d91500f449cbbfbb69bb516c6948ac06808c65595e46773e346f97a5ce0ef7e5a5e0de278af22709c +ac49de11edaaf04302c73c578cc0824bdd165c0d6321be1c421c1950e68e4f3589aa3995448c9699e93c6ebae8803e27 +884f02d841cb5d8f4c60d1402469216b114ab4e93550b5bc1431756e365c4f870a9853449285384a6fa49e12ce6dc654 +b75f3a28fa2cc8d36b49130cb7448a23d73a7311d0185ba803ad55c8219741d451c110f48b786e96c728bc525903a54f +80ae04dbd41f4a35e33f9de413b6ad518af0919e5a30cb0fa1b061b260420780bb674f828d37fd3b52b5a31673cbd803 +b9a8011eb5fcea766907029bf743b45262db3e49d24f84503687e838651ed11cb64c66281e20a0ae9f6aa51acc552263 +90bfdd75e2dc9cf013e22a5d55d2d2b8a754c96103a17524488e01206e67f8b6d52b1be8c4e3d5307d4fe06d0e51f54c +b4af353a19b06203a815ec43e79a88578cc678c46f5a954b85bc5c53b84059dddba731f3d463c23bfd5273885c7c56a4 +aa125e96d4553b64f7140e5453ff5d2330318b69d74d37d283e84c26ad672fa00e3f71e530eb7e28be1e94afb9c4612e +a18e060aee3d49cde2389b10888696436bb7949a79ca7d728be6456a356ea5541b55492b2138da90108bd1ce0e6f5524 +93e55f92bdbccc2de655d14b1526836ea2e52dba65eb3f87823dd458a4cb5079bf22ce6ef625cb6d6bfdd0995ab9a874 +89f5a683526b90c1c3ceebbb8dc824b21cff851ce3531b164f6626e326d98b27d3e1d50982e507d84a99b1e04e86a915 +83d1c38800361633a3f742b1cb2bfc528129496e80232611682ddbe403e92c2ac5373aea0bca93ecb5128b0b2b7a719e +8ecba560ac94905e19ce8d9c7af217bf0a145d8c8bd38e2db82f5e94cc3f2f26f55819176376b51f154b4aab22056059 +a7e2a4a002b60291924850642e703232994acb4cfb90f07c94d1e0ecd2257bb583443283c20fc6017c37e6bfe85b7366 +93ed7316fa50b528f1636fc6507683a672f4f4403e55e94663f91221cc198199595bd02eef43d609f451acc9d9b36a24 +a1220a8ebc5c50ceed76a74bc3b7e0aa77f6884c71b64b67c4310ac29ce5526cb8992d6abc13ef6c8413ce62486a6795 +b2f6eac5c869ad7f4a25161d3347093e2f70e66cd925032747e901189355022fab3038bca4d610d2f68feb7e719c110b +b703fa11a4d511ca01c7462979a94acb40b5d933759199af42670eb48f83df202fa0c943f6ab3b4e1cc54673ea3aab1e +b5422912afbfcb901f84791b04f1ddb3c3fbdc76d961ee2a00c5c320e06d3cc5b5909c3bb805df66c5f10c47a292b13d +ad0934368da823302e1ac08e3ede74b05dfdbfffca203e97ffb0282c226814b65c142e6e15ec1e754518f221f01b30f7 +a1dd302a02e37df15bf2f1147efe0e3c06933a5a767d2d030e1132f5c3ce6b98e216b6145eb39e1e2f74e76a83165b8d +a346aab07564432f802ae44738049a36f7ca4056df2d8f110dbe7fef4a3e047684dea609b2d03dc6bf917c9c2a47608f +b96c5f682a5f5d02123568e50f5d0d186e4b2c4c9b956ec7aabac1b3e4a766d78d19bd111adb5176b898e916e49be2aa +8a96676d56876fc85538db2e806e1cba20fd01aeb9fa3cb43ca6ca94a2c102639f65660db330e5d74a029bb72d6a0b39 +ab0048336bd5c3def1a4064eadd49e66480c1f2abb4df46e03afbd8a3342c2c9d74ee35d79f08f4768c1646681440984 +888427bdf76caec90814c57ee1c3210a97d107dd88f7256f14f883ad0f392334b82be11e36dd8bfec2b37935177c7831 +b622b282becf0094a1916fa658429a5292ba30fb48a4c8066ce1ddcefb71037948262a01c95bab6929ed3a76ba5db9fe +b5b9e005c1f456b6a368a3097634fb455723abe95433a186e8278dceb79d4ca2fbe21f8002e80027b3c531e5bf494629 +a3c6707117a1e48697ed41062897f55d8119403eea6c2ee88f60180f6526f45172664bfee96bf61d6ec0b7fbae6aa058 +b02a9567386a4fbbdb772d8a27057b0be210447348efe6feb935ceec81f361ed2c0c211e54787dc617cdffed6b4a6652 +a9b8364e40ef15c3b5902e5534998997b8493064fa2bea99600def58279bb0f64574c09ba11e9f6f669a8354dd79dc85 +9998a2e553a9aa9a206518fae2bc8b90329ee59ab23005b10972712389f2ec0ee746033c733092ffe43d73d33abbb8ef +843a4b34d9039bf79df96d79f2d15e8d755affb4d83d61872daf540b68c0a3888cf8fc00d5b8b247b38524bcb3b5a856 +84f7128920c1b0bb40eee95701d30e6fc3a83b7bb3709f16d97e72acbb6057004ee7ac8e8f575936ca9dcb7866ab45f7 +918d3e2222e10e05edb34728162a899ad5ada0aaa491aeb7c81572a9c0d506e31d5390e1803a91ff3bd8e2bb15d47f31 +9442d18e2489613a7d47bb1cb803c8d6f3259d088cd079460976d87f7905ee07dea8f371b2537f6e1d792d36d7e42723 +b491976970fe091995b2ed86d629126523ccf3e9daf8145302faca71b5a71a5da92e0e05b62d7139d3efac5c4e367584 +aa628006235dc77c14cef4c04a308d66b07ac92d377df3de1a2e6ecfe3144f2219ad6d7795e671e1cb37a3641910b940 +99d386adaea5d4981d7306feecac9a555b74ffdc218c907c5aa7ac04abaead0ec2a8237300d42a3fbc464673e417ceed +8f78e8b1556f9d739648ea3cab9606f8328b52877fe72f9305545a73b74d49884044ba9c1f1c6db7d9b7c7b7c661caba +8fb357ae49932d0babdf74fc7aa7464a65d3b6a2b3acf4f550b99601d3c0215900cfd67f2b6651ef94cfc323bac79fae +9906f2fa25c0290775aa001fb6198113d53804262454ae8b83ef371b5271bde189c0460a645829cb6c59f9ee3a55ce4d +8f4379b3ebb50e052325b27655ca6a82e6f00b87bf0d2b680d205dd2c7afdc9ff32a9047ae71a1cdf0d0ce6b9474d878 +a85534e88c2bd43c043792eaa75e50914b21741a566635e0e107ae857aed0412035f7576cf04488ade16fd3f35fdbb87 +b4ce93199966d3c23251ca7f28ec5af7efea1763d376b0385352ffb2e0a462ef95c69940950278cf0e3dafd638b7bd36 +b10cb3d0317dd570aa73129f4acf63c256816f007607c19b423fb42f65133ce21f2f517e0afb41a5378cccf893ae14d0 +a9b231c9f739f7f914e5d943ed9bff7eba9e2c333fbd7c34eb1648a362ee01a01af6e2f7c35c9fe962b11152cddf35de +99ff6a899e156732937fb81c0cced80ae13d2d44c40ba99ac183aa246103b31ec084594b1b7feb96da58f4be2dd5c0ed +8748d15d18b75ff2596f50d6a9c4ce82f61ecbcee123a6ceae0e43cab3012a29b6f83cf67b48c22f6f9d757c6caf76b2 +b88ab05e4248b7fb634cf640a4e6a945d13e331237410f7217d3d17e3e384ddd48897e7a91e4516f1b9cbd30f35f238b +8d826deaeeb84a3b2d2c04c2300ca592501f992810582d6ae993e0d52f6283a839dba66c6c72278cff5871802b71173b +b36fed027c2f05a5ef625ca00b0364b930901e9e4420975b111858d0941f60e205546474bb25d6bfa6928d37305ae95f +af2fcfc6b87967567e8b8a13a4ed914478185705724e56ce68fb2df6d1576a0cf34a61e880997a0d35dc2c3276ff7501 +ac351b919cd1fbf106feb8af2c67692bfcddc84762d18cea681cfa7470a5644839caace27efee5f38c87d3df306f4211 +8d6665fb1d4d8d1fa23bd9b8a86e043b8555663519caac214d1e3e3effbc6bee7f2bcf21e645f77de0ced279d69a8a8b +a9fc1c2061756b2a1a169c1b149f212ff7f0d2488acd1c5a0197eba793cffa593fc6d1d1b40718aa75ca3ec77eff10e1 +aff64f0fa009c7a6cf0b8d7a22ddb2c8170c3cb3eec082e60d5aadb00b0040443be8936d728d99581e33c22178c41c87 +82e0b181adc5e3b1c87ff8598447260e839d53debfae941ebea38265575546c3a74a14b4325a030833a62ff6c52d9365 +b7ad43cbb22f6f892c2a1548a41dc120ab1f4e1b8dea0cb6272dd9cb02054c542ecabc582f7e16de709d48f5166cae86 +985e0c61094281532c4afb788ecb2dfcba998e974b5d4257a22040a161883908cdd068fe80f8eb49b8953cfd11acf43a +ae46895c6d67ea6d469b6c9c07b9e5d295d9ae73b22e30da4ba2c973ba83a130d7eef39717ec9d0f36e81d56bf742671 +8600177ea1f7e7ef90514b38b219a37dedfc39cb83297e4c7a5b479817ef56479d48cf6314820960c751183f6edf8b0e +b9208ec1c1d7a1e99b59c62d3e4e61dfb706b0e940d09d3abfc3454c19749083260614d89cfd7e822596c3cdbcc6bb95 +a1e94042c796c2b48bc724352d2e9f3a22291d9a34705993357ddb6adabd76da6fc25dac200a8cb0b5bbd99ecddb7af6 +b29c3adedd0bcad8a930625bc4dfdc3552a9afd5ca6dd9c0d758f978068c7982b50b711aa0eb5b97f2b84ee784637835 +af0632a238bb1f413c7ea8e9b4c3d68f2827bd2e38cd56024391fba6446ac5d19a780d0cfd4a78fe497d537b766a591a +aaf6e7f7d54f8ef5e2e45dd59774ecbeecf8683aa70483b2a75be6a6071b5981bbaf1627512a65d212817acdfab2e428 +8c751496065da2e927cf492aa5ca9013b24f861d5e6c24b30bbf52ec5aaf1905f40f9a28175faef283dd4ed4f2182a09 +8952377d8e80a85cf67d6b45499f3bad5fd452ea7bcd99efc1b066c4720d8e5bff1214cea90fd1f972a7f0baac3d29be +a1946ee543d1a6e21f380453be4d446e4130950c5fc3d075794eb8260f6f52d0a795c1ff91d028a648dc1ce7d9ab6b47 +89f3fefe37af31e0c17533d2ca1ce0884cc1dc97c15cbfab9c331b8debd94781c9396abef4bb2f163d09277a08d6adf0 +a2753f1e6e1a154fb117100a5bd9052137add85961f8158830ac20541ab12227d83887d10acf7fd36dcaf7c2596d8d23 +814955b4198933ee11c3883863b06ff98c7eceb21fc3e09df5f916107827ccf3323141983e74b025f46ae00284c9513b +8cc5c6bb429073bfef47cae7b3bfccb0ffa076514d91a1862c6bda4d581e0df87db53cc6c130bf8a7826304960f5a34e +909f22c1f1cdc87f7be7439c831a73484a49acbf8f23d47087d7cf867c64ef61da3bde85dc57d705682b4c3fc710d36e +8048fee7f276fcd504aed91284f28e73693615e0eb3858fa44bcf79d7285a9001c373b3ef71d9a3054817ba293ebe28c +94400e5cf5d2700ca608c5fe35ce14623f71cc24959f2bc27ca3684092850f76b67fb1f07ca9e5b2ca3062cf8ad17bd4 +81c2ae7d4d1b17f8b6de6a0430acc0d58260993980fe48dc2129c4948269cdc74f9dbfbf9c26b19360823fd913083d48 +8c41fe765128e63f6889d6a979f6a4342300327c8b245a8cfe3ecfbcac1e09c3da30e2a1045b24b78efc6d6d50c8c6ac +a5dd4ae51ae48c8be4b218c312ade226cffce671cf121cb77810f6c0990768d6dd767badecb5c69921d5574d5e8433d3 +b7642e325f4ba97ae2a39c1c9d97b35aafd49d53dba36aed3f3cb0ca816480b3394079f46a48252d46596559c90f4d58 +ae87375b40f35519e7bd4b1b2f73cd0b329b0c2cb9d616629342a71c6c304338445eda069b78ea0fbe44087f3de91e09 +b08918cb6f736855e11d3daca1ddfbdd61c9589b203b5493143227bf48e2c77c2e8c94b0d1aa2fab2226e0eae83f2681 +ac36b84a4ac2ebd4d6591923a449c564e3be8a664c46092c09e875c2998eba16b5d32bfd0882fd3851762868e669f0b1 +a44800a3bb192066fa17a3f29029a23697240467053b5aa49b9839fb9b9b8b12bcdcbfc557f024b61f4f51a9aacdefcb +9064c688fec23441a274cdf2075e5a449caf5c7363cc5e8a5dc9747183d2e00a0c69f2e6b3f6a7057079c46014c93b3b +aa367b021469af9f5b764a79bb3afbe2d87fe1e51862221672d1a66f954b165778b7c27a705e0f93841fab4c8468344d +a1a8bfc593d4ab71f91640bc824de5c1380ab2591cfdafcbc78a14b32de3c0e15f9d1b461d85c504baa3d4232c16bb53 +97df48da1799430f528184d30b6baa90c2a2f88f34cdfb342d715339c5ebd6d019aa693cea7c4993daafc9849063a3aa +abd923831fbb427e06e0dd335253178a9e5791395c84d0ab1433c07c53c1209161097e9582fb8736f8a60bde62d8693e +84cd1a43f1a438b43dc60ffc775f646937c4f6871438163905a3cebf1115f814ccd38a6ccb134130bff226306e412f32 +91426065996b0743c5f689eb3ca68a9f7b9e4d01f6c5a2652b57fa9a03d8dc7cd4bdbdab0ca5a891fee1e97a7f00cf02 +a4bee50249db3df7fd75162b28f04e57c678ba142ce4d3def2bc17bcb29e4670284a45f218dad3969af466c62a903757 +83141ebcc94d4681404e8b67a12a46374fded6df92b506aff3490d875919631408b369823a08b271d006d5b93136f317 +a0ea1c8883d58d5a784da3d8c8a880061adea796d7505c1f903d07c287c5467f71e4563fc0faafbc15b5a5538b0a7559 +89d9d480574f201a87269d26fb114278ed2c446328df431dc3556e3500e80e4cd01fcac196a2459d8646361ebda840df +8bf302978973632dd464bec819bdb91304712a3ec859be071e662040620422c6e75eba6f864f764cffa2799272efec39 +922f666bc0fd58b6d7d815c0ae4f66d193d32fc8382c631037f59eeaeae9a8ca6c72d08e72944cf9e800b8d639094e77 +81ad8714f491cdff7fe4399f2eb20e32650cff2999dd45b9b3d996d54a4aba24cc6c451212e78c9e5550368a1a38fb3f +b58fcf4659d73edb73175bd9139d18254e94c3e32031b5d4b026f2ed37aa19dca17ec2eb54c14340231615277a9d347e +b365ac9c2bfe409b710928c646ea2fb15b28557e0f089d39878e365589b9d1c34baf5566d20bb28b33bb60fa133f6eff +8fcae1d75b53ab470be805f39630d204853ca1629a14158bac2f52632277d77458dec204ff84b7b2d77e641c2045be65 +a03efa6bebe84f4f958a56e2d76b5ba4f95dd9ed7eb479edc7cc5e646c8d4792e5b0dfc66cc86aa4b4afe2f7a4850760 +af1c823930a3638975fb0cc5c59651771b2719119c3cd08404fbd4ce77a74d708cefbe3c56ea08c48f5f10e6907f338f +8260c8299b17898032c761c325ac9cabb4c5b7e735de81eacf244f647a45fb385012f4f8df743128888c29aefcaaad16 +ab2f37a573c82e96a8d46198691cd694dfa860615625f477e41f91b879bc58a745784fccd8ffa13065834ffd150d881d +986c746c9b4249352d8e5c629e8d7d05e716b3c7aab5e529ca969dd1e984a14b5be41528baef4c85d2369a42d7209216 +b25e32da1a8adddf2a6080725818b75bc67240728ad1853d90738485d8924ea1e202df0a3034a60ffae6f965ec55cf63 +a266e627afcebcefea6b6b44cbc50f5c508f7187e87d047b0450871c2a030042c9e376f3ede0afcf9d1952f089582f71 +86c3bbca4c0300606071c0a80dbdec21ce1dd4d8d4309648151c420854032dff1241a1677d1cd5de4e4de4385efda986 +b9a21a1fe2d1f3273a8e4a9185abf2ff86448cc98bfa435e3d68306a2b8b4a6a3ea33a155be3cb62a2170a86f77679a5 +b117b1ea381adce87d8b342cba3a15d492ff2d644afa28f22424cb9cbc820d4f7693dfc1a4d1b3697046c300e1c9b4c8 +9004c425a2e68870d6c69b658c344e3aa3a86a8914ee08d72b2f95c2e2d8a4c7bb0c6e7e271460c0e637cec11117bf8e +86a18aa4783b9ebd9131580c8b17994825f27f4ac427b0929a1e0236907732a1c8139e98112c605488ee95f48bbefbfc +84042243b955286482ab6f0b5df4c2d73571ada00716d2f737ca05a0d2e88c6349e8ee9e67934cfee4a1775dbf7f4800 +92c2153a4733a62e4e1d5b60369f3c26777c7d01cd3c8679212660d572bd3bac9b8a8a64e1f10f7dbf5eaa7579c4e423 +918454b6bb8e44a2afa144695ba8d48ae08d0cdfef4ad078f67709eddf3bb31191e8b006f04e82ea45a54715ef4d5817 +acf0b54f6bf34cf6ed6c2b39cf43194a40d68de6bcf1e4b82c34c15a1343e9ac3737885e1a30b78d01fa3a5125463db8 +a7d60dbe4b6a7b054f7afe9ee5cbbfeca0d05dc619e6041fa2296b549322529faddb8a11e949562309aecefb842ac380 +91ffb53e6d7e5f11159eaf13e783d6dbdfdb1698ed1e6dbf3413c6ea23492bbb9e0932230a9e2caac8fe899a17682795 +b6e8d7be5076ee3565d5765a710c5ecf17921dd3cf555c375d01e958a365ae087d4a88da492a5fb81838b7b92bf01143 +a8c6b763de2d4b2ed42102ef64eccfef31e2fb2a8a2776241c82912fa50fc9f77f175b6d109a97ede331307c016a4b1a +99839f86cb700c297c58bc33e28d46b92931961548deac29ba8df91d3e11721b10ea956c8e16984f9e4acf1298a79b37 +8c2e2c338f25ea5c25756b7131cde0d9a2b35abf5d90781180a00fe4b8e64e62590dc63fe10a57fba3a31c76d784eb01 +9687d7df2f41319ca5469d91978fed0565a5f11f829ebadaa83db92b221755f76c6eacd7700735e75c91e257087512e3 +8795fdfb7ff8439c58b9bf58ed53873d2780d3939b902b9ddaaa4c99447224ced9206c3039a23c2c44bcc461e2bb637f +a803697b744d2d087f4e2307218d48fa88620cf25529db9ce71e2e3bbcc65bac5e8bb9be04777ef7bfb5ed1a5b8e6170 +80f3d3efbbb9346ddd413f0a8e36b269eb5d7ff6809d5525ff9a47c4bcab2c01b70018b117f6fe05253775612ff70c6b +9050e0e45bcc83930d4c505af35e5e4d7ca01cd8681cba92eb55821aececcebe32bb692ebe1a4daac4e7472975671067 +8d206812aac42742dbaf233e0c080b3d1b30943b54b60283515da005de05ea5caa90f91fedcfcba72e922f64d7040189 +a2d44faaeb2eff7915c83f32b13ca6f31a6847b1c1ce114ea240bac3595eded89f09b2313b7915ad882292e2b586d5b4 +961776c8576030c39f214ea6e0a3e8b3d32f023d2600958c098c95c8a4e374deeb2b9dc522adfbd6bda5949bdc09e2a2 +993fa7d8447407af0fbcd9e6d77f815fa5233ab00674efbcf74a1f51c37481445ae291cc7b76db7c178f9cb0e570e0fc +abd5b1c78e05f9d7c8cc99bdaef8b0b6a57f2daf0f02bf492bec48ea4a27a8f1e38b5854da96efff11973326ff980f92 +8f15af4764bc275e6ccb892b3a4362cacb4e175b1526a9a99944e692fe6ccb1b4fc19abf312bb2a089cb1f344d91a779 +a09b27ccd71855512aba1d0c30a79ffbe7f6707a55978f3ced50e674b511a79a446dbc6d7946add421ce111135a460af +94b2f98ce86a9271fbd4153e1fc37de48421fe3490fb3840c00f2d5a4d0ba8810c6a32880b002f6374b59e0a7952518b +8650ac644f93bbcb88a6a0f49fee2663297fd4bc6fd47b6a89b9d8038d32370438ab3a4775ec9b58cb10aea8a95ef7b6 +95e5c2f2e84eed88c6980bbba5a1c0bb375d5a628bff006f7516d45bb7d723da676add4fdd45956f312e7bab0f052644 +b3278a3fa377ac93af7cfc9453f8cb594aae04269bbc99d2e0e45472ff4b6a2f97a26c4c57bf675b9d86f5e77a5d55d1 +b4bcbe6eb666a206e2ea2f877912c1d3b5bdbd08a989fc4490eb06013e1a69ad1ba08bcdac048bf29192312be399077b +a76d70b78c99fffcbf9bb9886eab40f1ea4f99a309710b660b64cbf86057cbcb644d243f6e341711bb7ef0fedf0435a7 +b2093c1ee945dca7ac76ad5aed08eae23af31dd5a77c903fd7b6f051f4ab84425d33a03c3d45bf2907bc93c02d1f3ad8 +904b1f7534e053a265b22d20be859912b9c9ccb303af9a8d6f1d8f6ccdc5c53eb4a45a1762b880d8444d9be0cd55e7f9 +8f664a965d65bc730c9ef1ec7467be984d4b8eb46bd9b0d64e38e48f94e6e55dda19aeac82cbcf4e1473440e64c4ca18 +8bcee65c4cc7a7799353d07b114c718a2aae0cd10a3f22b7eead5185d159dafd64852cb63924bf87627d176228878bce +8c78f2e3675096fef7ebaa898d2615cd50d39ca3d8f02b9bdfb07e67da648ae4be3da64838dffc5935fd72962c4b96c7 +8c40afd3701629421fec1df1aac4e849384ef2e80472c0e28d36cb1327acdf2826f99b357f3d7afdbc58a6347fc40b3c +a197813b1c65a8ea5754ef782522a57d63433ef752215ecda1e7da76b0412ee619f58d904abd2e07e0c097048b6ae1dd +a670542629e4333884ad7410f9ea3bd6f988df4a8f8a424ca74b9add2312586900cf9ae8bd50411f9146e82626b4af56 +a19875cc07ab84e569d98b8b67fb1dbbdfb59093c7b748fae008c8904a6fd931a63ca8d03ab5fea9bc8d263568125a9b +b57e7f68e4eb1bd04aafa917b1db1bdab759a02aa8a9cdb1cba34ba8852b5890f655645c9b4e15d5f19bf37e9f2ffe9f +8abe4e2a4f6462b6c64b3f10e45db2a53c2b0d3c5d5443d3f00a453e193df771eda635b098b6c8604ace3557514027af +8459e4fb378189b22b870a6ef20183deb816cefbf66eca1dc7e86d36a2e011537db893729f500dc154f14ce24633ba47 +930851df4bc7913c0d8c0f7bd3b071a83668987ed7c397d3d042fdc0d9765945a39a3bae83da9c88cb6b686ed8aeeb26 +8078c9e5cd05e1a8c932f8a1d835f61a248b6e7133fcbb3de406bf4ffc0e584f6f9f95062740ba6008d98348886cf76b +addff62bb29430983fe578e3709b0949cdc0d47a13a29bc3f50371a2cb5c822ce53e2448cfaa01bcb6e0aa850d5a380e +9433add687b5a1e12066721789b1db2edf9b6558c3bdc0f452ba33b1da67426abe326e9a34d207bfb1c491c18811bde1 +822beda3389963428cccc4a2918fa9a8a51cf0919640350293af70821967108cded5997adae86b33cb917780b097f1ca +a7a9f52bda45e4148ed56dd176df7bd672e9b5ed18888ccdb405f47920fdb0844355f8565cefb17010b38324edd8315f +b35c3a872e18e607b2555c51f9696a17fa18da1f924d503b163b4ec9fe22ed0c110925275cb6c93ce2d013e88f173d6a +adf34b002b2b26ab84fc1bf94e05bd8616a1d06664799ab149363c56a6e0c807fdc473327d25632416e952ea327fcd95 +ae4a6b9d22a4a3183fac29e2551e1124a8ce4a561a9a2afa9b23032b58d444e6155bb2b48f85c7b6d70393274e230db7 +a2ea3be4fc17e9b7ce3110284038d46a09e88a247b6971167a7878d9dcf36925d613c382b400cfa4f37a3ebea3699897 +8e5863786b641ce3140fbfe37124d7ad3925472e924f814ebfc45959aaf3f61dc554a597610b5defaecc85b59a99b50f +aefde3193d0f700d0f515ab2aaa43e2ef1d7831c4f7859f48e52693d57f97fa9e520090f3ed700e1c966f4b76048e57f +841a50f772956622798e5cd208dc7534d4e39eddee30d8ce133383d66e5f267e389254a0cdae01b770ecd0a9ca421929 +8fbc2bfd28238c7d47d4c03b1b910946c0d94274a199575e5b23242619b1de3497784e646a92aa03e3e24123ae4fcaba +926999579c8eec1cc47d7330112586bdca20b4149c8b2d066f527c8b9f609e61ce27feb69db67eea382649c6905efcf9 +b09f31f305efcc65589adf5d3690a76cf339efd67cd43a4e3ced7b839507466e4be72dd91f04e89e4bbef629d46e68c0 +b917361f6b95f759642638e0b1d2b3a29c3bdef0b94faa30de562e6078c7e2d25976159df3edbacbf43614635c2640b4 +8e7e8a1253bbda0e134d62bfe003a2669d471b47bd2b5cde0ff60d385d8e62279d54022f5ac12053b1e2d3aaa6910b4c +b69671a3c64e0a99d90b0ed108ce1912ff8ed983e4bddd75a370e9babde25ee1f5efb59ec707edddd46793207a8b1fe7 +910b2f4ebd37b7ae94108922b233d0920b4aba0bd94202c70f1314418b548d11d8e9caa91f2cd95aff51b9432d122b7f +82f645c90dfb52d195c1020346287c43a80233d3538954548604d09fbab7421241cde8593dbc4acc4986e0ea39a27dd9 +8fee895f0a140d88104ce442fed3966f58ff9d275e7373483f6b4249d64a25fb5374bbdc6bce6b5ab0270c2847066f83 +84f5bd7aab27b2509397aeb86510dd5ac0a53f2c8f73799bf720f2f87a52277f8d6b0f77f17bc80739c6a7119b7eb062 +9903ceced81099d7e146e661bcf01cbaccab5ba54366b85e2177f07e2d8621e19d9c9c3eee14b9266de6b3f9b6ea75ae +b9c16ea2a07afa32dd6c7c06df0dec39bca2067a9339e45475c98917f47e2320f6f235da353fd5e15b477de97ddc68dd +9820a9bbf8b826bec61ebf886de2c4f404c1ebdc8bab82ee1fea816d9de29127ce1852448ff717a3fe8bbfe9e92012e5 +817224d9359f5da6f2158c2c7bf9165501424f063e67ba9859a07ab72ee2ee62eb00ca6da821cfa19065c3282ca72c74 +94b95c465e6cb00da400558a3c60cfec4b79b27e602ca67cbc91aead08de4b6872d8ea096b0dc06dca4525c8992b8547 +a2b539a5bccd43fa347ba9c15f249b417997c6a38c63517ca38394976baa08e20be384a360969ff54e7e721db536b3e5 +96caf707e34f62811ee8d32ccf28d8d6ec579bc33e424d0473529af5315c456fd026aa910c1fed70c91982d51df7d3ca +8a77b73e890b644c6a142bdbac59b22d6a676f3b63ddafb52d914bb9d395b8bf5aedcbcc90429337df431ebd758a07a6 +8857830a7351025617a08bc44caec28d2fae07ebf5ffc9f01d979ce2a53839a670e61ae2783e138313929129790a51a1 +aa3e420321ed6f0aa326d28d1a10f13facec6f605b6218a6eb9cbc074801f3467bf013a456d1415a5536f12599efa3d3 +824aed0951957b00ea2f3d423e30328a3527bf6714cf9abbae84cf27e58e5c35452ba89ccc011de7c68c75d6e021d8f1 +a2e87cc06bf202e953fb1081933d8b4445527dde20e38ed1a4f440144fd8fa464a2b73e068b140562e9045e0f4bd3144 +ae3b8f06ad97d7ae3a5e5ca839efff3e4824dc238c0c03fc1a8d2fc8aa546cdfd165b784a31bb4dec7c77e9305b99a4b +b30c3e12395b1fb8b776f3ec9f87c70e35763a7b2ddc68f0f60a4982a84017f27c891a98561c830038deb033698ed7fc +874e507757cd1177d0dff0b0c62ce90130324442a33da3b2c8ee09dbca5d543e3ecfe707e9f1361e7c7db641c72794bb +b53012dd10b5e7460b57c092eaa06d6502720df9edbbe3e3f61a9998a272bf5baaac4a5a732ad4efe35d6fac6feca744 +85e6509d711515534d394e6cacbed6c81da710074d16ef3f4950bf2f578d662a494d835674f79c4d6315bced4defc5f0 +b6132b2a34b0905dcadc6119fd215419a7971fe545e52f48b768006944b4a9d7db1a74b149e2951ea48c083b752d0804 +989867da6415036d19b4bacc926ce6f4df7a556f50a1ba5f3c48eea9cefbb1c09da81481c8009331ee83f0859185e164 +960a6c36542876174d3fbc1505413e29f053ed87b8d38fef3af180491c7eff25200b45dd5fe5d4d8e63c7e8c9c00f4c8 +9040b59bd739d9cc2e8f6e894683429e4e876a8106238689ff4c22770ae5fdae1f32d962b30301fa0634ee163b524f35 +af3fcd0a45fe9e8fe256dc7eab242ef7f582dd832d147444483c62787ac820fafc6ca55d639a73f76bfa5e7f5462ab8f +b934c799d0736953a73d91e761767fdb78454355c4b15c680ce08accb57ccf941b13a1236980001f9e6195801cffd692 +8871e8e741157c2c326b22cf09551e78da3c1ec0fc0543136f581f1550f8bab03b0a7b80525c1e99812cdbf3a9698f96 +a8a977f51473a91d178ee8cfa45ffef8d6fd93ab1d6e428f96a3c79816d9c6a93cd70f94d4deda0125fd6816e30f3bea +a7688b3b0a4fc1dd16e8ba6dc758d3cfe1b7cf401c31739484c7fa253cce0967df1b290769bcefc9d23d3e0cb19e6218 +8ae84322662a57c6d729e6ff9d2737698cc2da2daeb1f39e506618750ed23442a6740955f299e4a15dda6db3e534d2c6 +a04a961cdccfa4b7ef83ced17ab221d6a043b2c718a0d6cc8e6f798507a31f10bf70361f70a049bc8058303fa7f96864 +b463e39732a7d9daec8a456fb58e54b30a6e160aa522a18b9a9e836488cce3342bcbb2e1deab0f5e6ec0a8796d77197d +b1434a11c6750f14018a2d3bcf94390e2948f4f187e93bb22070ca3e5393d339dc328cbfc3e48815f51929465ffe7d81 +84ff81d73f3828340623d7e3345553610aa22a5432217ef0ebd193cbf4a24234b190c65ca0873c22d10ea7b63bd1fbed +b6fe2723f0c47757932c2ddde7a4f8434f665612f7b87b4009c2635d56b6e16b200859a8ade49276de0ef27a2b6c970a +9742884ed7cd52b4a4a068a43d3faa02551a424136c85a9313f7cb58ea54c04aa83b0728fd741d1fe39621e931e88f8f +b7d2d65ea4d1ad07a5dee39e40d6c03a61264a56b1585b4d76fc5b2a68d80a93a42a0181d432528582bf08d144c2d6a9 +88c0f66bada89f8a43e5a6ead2915088173d106c76f724f4a97b0f6758aed6ae5c37c373c6b92cdd4aea8f6261f3a374 +81f9c43582cb42db3900747eb49ec94edb2284999a499d1527f03315fd330e5a509afa3bff659853570e9886aab5b28b +821f9d27d6beb416abf9aa5c79afb65a50ed276dbda6060103bc808bcd34426b82da5f23e38e88a55e172f5c294b4d40 +8ba307b9e7cb63a6c4f3851b321aebfdb6af34a5a4c3bd949ff7d96603e59b27ff4dc4970715d35f7758260ff942c9e9 +b142eb6c5f846de33227d0bda61d445a7c33c98f0a8365fe6ab4c1fabdc130849be597ef734305894a424ea715372d08 +a732730ae4512e86a741c8e4c87fee8a05ee840fec0e23b2e037d58dba8dde8d10a9bc5191d34d00598941becbbe467f +adce6f7c30fd221f6b10a0413cc76435c4bb36c2d60bca821e5c67409fe9dbb2f4c36ef85eb3d734695e4be4827e9fd3 +a74f00e0f9b23aff7b2527ce69852f8906dab9d6abe62ecd497498ab21e57542e12af9918d4fd610bb09e10b0929c510 +a593b6b0ef26448ce4eb3ab07e84238fc020b3cb10d542ff4b16d4e2be1bcde3797e45c9cf753b8dc3b0ffdb63984232 +aed3913afccf1aa1ac0eb4980eb8426d0baccebd836d44651fd72af00d09fac488a870223c42aca3ceb39752070405ae +b2c44c66a5ea7fde626548ba4cef8c8710191343d3dadfd3bb653ce715c0e03056a5303a581d47dde66e70ea5a2d2779 +8e5029b2ccf5128a12327b5103f7532db599846e422531869560ceaff392236434d87159f597937dbf4054f810c114f4 +82beed1a2c4477e5eb39fc5b0e773b30cfec77ef2b1bf17eadaf60eb35b6d0dd9d8cf06315c48d3546badb3f21cd0cca +90077bd6cc0e4be5fff08e5d07a5a158d36cebd1d1363125bc4fae0866ffe825b26f933d4ee5427ba5cd0c33c19a7b06 +a7ec0d8f079970e8e34f0ef3a53d3e0e45428ddcef9cc776ead5e542ef06f3c86981644f61c5a637e4faf001fb8c6b3e +ae6d4add6d1a6f90b22792bc9d40723ee6850c27d0b97eefafd5b7fd98e424aa97868b5287cc41b4fbd7023bca6a322c +831aa917533d077da07c01417feaa1408846363ba2b8d22c6116bb858a95801547dd88b7d7fa1d2e3f0a02bdeb2e103d +96511b860b07c8a5ed773f36d4aa9d02fb5e7882753bf56303595bcb57e37ccc60288887eb83bef08c657ec261a021a2 +921d2a3e7e9790f74068623de327443666b634c8443aba80120a45bba450df920b2374d96df1ce3fb1b06dd06f8cf6e3 +aa74451d51fe82b4581ead8e506ec6cd881010f7e7dd51fc388eb9a557db5d3c6721f81c151d08ebd9c2591689fbc13e +a972bfbcf4033d5742d08716c927c442119bdae336bf5dff914523b285ccf31953da2733759aacaa246a9af9f698342c +ad1fcd0cae0e76840194ce4150cb8a56ebed728ec9272035f52a799d480dfc85840a4d52d994a18b6edb31e79be6e8ad +a2c69fe1d36f235215432dad48d75887a44c99dfa0d78149acc74087da215a44bdb5f04e6eef88ff7eff80a5a7decc77 +a94ab2af2b6ee1bc6e0d4e689ca45380d9fbd3c5a65b9bd249d266a4d4c07bf5d5f7ef2ae6000623aee64027892bf8fe +881ec1fc514e926cdc66480ac59e139148ff8a2a7895a49f0dff45910c90cdda97b66441a25f357d6dd2471cddd99bb3 +884e6d3b894a914c8cef946a76d5a0c8351843b2bffa2d1e56c6b5b99c84104381dd1320c451d551c0b966f4086e60f9 +817c6c10ce2677b9fc5223500322e2b880583254d0bb0d247d728f8716f5e05c9ff39f135854342a1afecd9fbdcf7c46 +aaf4a9cb686a14619aa1fc1ac285dd3843ac3dd99f2b2331c711ec87b03491c02f49101046f3c5c538dc9f8dba2a0ac2 +97ecea5ce53ca720b5d845227ae61d70269a2f53540089305c86af35f0898bfd57356e74a8a5e083fa6e1ea70080bd31 +a22d811e1a20a75feac0157c418a4bfe745ccb5d29466ffa854dca03e395b6c3504a734341746b2846d76583a780b32e +940cbaa0d2b2db94ae96b6b9cf2deefbfd059e3e5745de9aec4a25f0991b9721e5cd37ef71c631575d1a0c280b01cd5b +ae33cb4951191258a11044682de861bf8d92d90ce751b354932dd9f3913f542b6a0f8a4dc228b3cd9244ac32c4582832 +a580df5e58c4274fe0f52ac2da1837e32f5c9db92be16c170187db4c358f43e5cfdda7c5911dcc79d77a5764e32325f5 +81798178cb9d8affa424f8d3be67576ba94d108a28ccc01d330c51d5a63ca45bb8ca63a2f569b5c5fe1303cecd2d777f +89975b91b94c25c9c3660e4af4047a8bacf964783010820dbc91ff8281509379cb3b24c25080d5a01174dd9a049118d5 +a7327fcb3710ed3273b048650bde40a32732ef40a7e58cf7f2f400979c177944c8bc54117ba6c80d5d4260801dddab79 +92b475dc8cb5be4b90c482f122a51bcb3b6c70593817e7e2459c28ea54a7845c50272af38119406eaadb9bcb993368d0 +9645173e9ecefc4f2eae8363504f7c0b81d85f8949a9f8a6c01f2d49e0a0764f4eacecf3e94016dd407fc14494fce9f9 +9215fd8983d7de6ae94d35e6698226fc1454977ae58d42d294be9aad13ac821562ad37d5e7ee5cdfe6e87031d45cd197 +810360a1c9b88a9e36f520ab5a1eb8bed93f52deefbe1312a69225c0a08edb10f87cc43b794aced9c74220cefcc57e7d +ad7e810efd61ed4684aeda9ed8bb02fb9ae4b4b63fda8217d37012b94ff1b91c0087043bfa4e376f961fff030c729f3b +8b07c95c6a06db8738d10bb03ec11b89375c08e77f0cab7e672ce70b2685667ca19c7e1c8b092821d31108ea18dfd4c7 +968825d025ded899ff7c57245250535c732836f7565eab1ae23ee7e513201d413c16e1ba3f5166e7ac6cf74de8ceef4f +908243370c5788200703ade8164943ad5f8c458219186432e74dbc9904a701ea307fd9b94976c866e6c58595fd891c4b +959969d16680bc535cdc6339e6186355d0d6c0d53d7bbfb411641b9bf4b770fd5f575beef5deec5c4fa4d192d455c350 +ad177f4f826a961adeac76da40e2d930748effff731756c797eddc4e5aa23c91f070fb69b19221748130b0961e68a6bb +82f8462bcc25448ef7e0739425378e9bb8a05e283ce54aae9dbebaf7a3469f57833c9171672ad43a79778366c72a5e37 +a28fb275b1845706c2814d9638573e9bc32ff552ebaed761fe96fdbce70395891ca41c400ae438369264e31a2713b15f +8a9c613996b5e51dadb587a787253d6081ea446bf5c71096980bf6bd3c4b69905062a8e8a3792de2d2ece3b177a71089 +8d5aefef9f60cb27c1db2c649221204dda48bb9bf8bf48f965741da051340e8e4cab88b9d15c69f3f84f4c854709f48a +93ebf2ca6ad85ab6deace6de1a458706285b31877b1b4d7dcb9d126b63047efaf8c06d580115ec9acee30c8a7212fa55 +b3ee46ce189956ca298057fa8223b7fd1128cf52f39159a58bca03c71dd25161ac13f1472301f72aef3e1993fe1ab269 +a24d7a8d066504fc3f5027ccb13120e2f22896860e02c45b5eba1dbd512d6a17c28f39155ea581619f9d33db43a96f92 +ae9ceacbfe12137db2c1a271e1b34b8f92e4816bad1b3b9b6feecc34df0f8b3b0f7ed0133acdf59c537d43d33fc8d429 +83967e69bf2b361f86361bd705dce0e1ad26df06da6c52b48176fe8dfcbeb03c462c1a4c9e649eff8c654b18c876fdef +9148e6b814a7d779c19c31e33a068e97b597de1f8100513db3c581190513edc4d544801ce3dd2cf6b19e0cd6daedd28a +94ccdafc84920d320ed22de1e754adea072935d3c5f8c2d1378ebe53d140ea29853f056fb3fb1e375846061a038cc9bc +afb43348498c38b0fa5f971b8cdd3a62c844f0eb52bc33daf2f67850af0880fce84ecfb96201b308d9e6168a0d443ae3 +86d5736520a83538d4cd058cc4b4e84213ed00ebd6e7af79ae787adc17a92ba5359e28ba6c91936d967b4b28d24c3070 +b5210c1ff212c5b1e9ef9126e08fe120a41e386bb12c22266f7538c6d69c7fd8774f11c02b81fd4e88f9137b020801fe +b78cfd19f94d24e529d0f52e18ce6185cb238edc6bd43086270fd51dd99f664f43dd4c7d2fe506762fbd859028e13fcf +a6e7220598c554abdcc3fdc587b988617b32c7bb0f82c06205467dbedb58276cc07cae317a190f19d19078773f4c2bbb +b88862809487ee430368dccd85a5d72fa4d163ca4aad15c78800e19c1a95be2192719801e315d86cff7795e0544a77e4 +87ecb13a03921296f8c42ceb252d04716f10e09c93962239fcaa0a7fef93f19ab3f2680bc406170108bc583e9ff2e721 +a810cd473832b6581c36ec4cb403f2849357ba2d0b54df98ef3004b8a530c078032922a81d40158f5fb0043d56477f6e +a247b45dd85ca7fbb718b328f30a03f03c84aef2c583fbdc9fcc9eb8b52b34529e8c8f535505c10598b1b4dac3d7c647 +96ee0b91313c68bac4aa9e065ce9e1d77e51ca4cff31d6a438718c58264dee87674bd97fc5c6b8008be709521e4fd008 +837567ad073e42266951a9a54750919280a2ac835a73c158407c3a2b1904cf0d17b7195a393c71a18ad029cbd9cf79ee +a6a469c44b67ebf02196213e7a63ad0423aab9a6e54acc6fcbdbb915bc043586993454dc3cd9e4be8f27d67c1050879b +8712d380a843b08b7b294f1f06e2f11f4ad6bcc655fdde86a4d8bc739c23916f6fad2b902fe47d6212f03607907e9f0e +920adfb644b534789943cdae1bdd6e42828dda1696a440af2f54e6b97f4f97470a1c6ea9fa6a2705d8f04911d055acd1 +a161c73adf584a0061e963b062f59d90faac65c9b3a936b837a10d817f02fcabfa748824607be45a183dd40f991fe83f +874f4ecd408c76e625ea50bc59c53c2d930ee25baf4b4eca2440bfbffb3b8bc294db579caa7c68629f4d9ec24187c1ba +8bff18087f112be7f4aa654e85c71fef70eee8ae480f61d0383ff6f5ab1a0508f966183bb3fc4d6f29cb7ca234aa50d3 +b03b46a3ca3bc743a173cbc008f92ab1aedd7466b35a6d1ca11e894b9482ea9dc75f8d6db2ddd1add99bfbe7657518b7 +8b4f3691403c3a8ad9e097f02d130769628feddfa8c2b3dfe8cff64e2bed7d6e5d192c1e2ba0ac348b8585e94acd5fa1 +a0d9ca4a212301f97591bf65d5ef2b2664766b427c9dd342e23cb468426e6a56be66b1cb41fea1889ac5d11a8e3c50a5 +8c93ed74188ca23b3df29e5396974b9cc135c91fdefdea6c0df694c8116410e93509559af55533a3776ac11b228d69b1 +82dd331fb3f9e344ebdeeb557769b86a2cc8cc38f6c298d7572a33aea87c261afa9dbd898989139b9fc16bc1e880a099 +a65faedf326bcfd8ef98a51410c78b021d39206704e8291cd1f09e096a66b9b0486be65ff185ca224c45918ac337ddeb +a188b37d363ac072a766fd5d6fa27df07363feff1342217b19e3c37385e42ffde55e4be8355aceaa2f267b6d66b4ac41 +810fa3ba3e96d843e3bafd3f2995727f223d3567c8ba77d684c993ba1773c66551eb5009897c51b3fe9b37196984f5ec +87631537541852da323b4353af45a164f68b304d24c01183bf271782e11687f3fcf528394e1566c2a26cb527b3148e64 +b721cb2b37b3c477a48e3cc0044167d51ff568a5fd2fb606e5aec7a267000f1ddc07d3db919926ae12761a8e017c767c +904dfad4ba2cc1f6e60d1b708438a70b1743b400164cd981f13c064b8328d5973987d4fb9cf894068f29d3deaf624dfb +a70491538893552c20939fae6be2f07bfa84d97e2534a6bbcc0f1729246b831103505e9f60e97a8fa7d2e6c1c2384579 +8726cf1b26b41f443ff7485adcfddc39ace2e62f4d65dd0bb927d933e262b66f1a9b367ded5fbdd6f3b0932553ac1735 +ae8a11cfdf7aa54c08f80cb645e3339187ab3886babe9fae5239ba507bb3dd1c0d161ca474a2df081dcd3d63e8fe445e +92328719e97ce60e56110f30a00ac5d9c7a2baaf5f8d22355d53c1c77941e3a1fec7d1405e6fbf8959665fe2ba7a8cad +8d9d6255b65798d0018a8cccb0b6343efd41dc14ff2058d3eed9451ceaad681e4a0fa6af67b0a04318aa628024e5553d +b70209090055459296006742d946a513f0cba6d83a05249ee8e7a51052b29c0ca9722dc4af5f9816a1b7938a5dac7f79 +aab7b766b9bf91786dfa801fcef6d575dc6f12b77ecc662eb4498f0312e54d0de9ea820e61508fc8aeee5ab5db529349 +a8104b462337748b7f086a135d0c3f87f8e51b7165ca6611264b8fb639d9a2f519926cb311fa2055b5fadf03da70c678 +b0d2460747d5d8b30fc6c6bd0a87cb343ddb05d90a51b465e8f67d499cfc5e3a9e365da05ae233bbee792cdf90ec67d5 +aa55f5bf3815266b4a149f85ed18e451c93de9163575e3ec75dd610381cc0805bb0a4d7c4af5b1f94d10231255436d2c +8d4c6a1944ff94426151909eb5b99cfd92167b967dabe2bf3aa66bb3c26c449c13097de881b2cfc1bf052862c1ef7b03 +8862296162451b9b6b77f03bf32e6df71325e8d7485cf3335d66fd48b74c2a8334c241db8263033724f26269ad95b395 +901aa96deb26cda5d9321190ae6624d357a41729d72ef1abfd71bebf6139af6d690798daba53b7bc5923462115ff748a +96c195ec4992728a1eb38cdde42d89a7bce150db43adbc9e61e279ea839e538deec71326b618dd39c50d589f78fc0614 +b6ff8b8aa0837b99a1a8b46fb37f20ad4aecc6a98381b1308697829a59b8442ffc748637a88cb30c9b1f0f28a926c4f6 +8d807e3dca9e7bef277db1d2cfb372408dd587364e8048b304eff00eacde2c723bfc84be9b98553f83cba5c7b3cba248 +8800c96adb0195c4fc5b24511450dee503c32bf47044f5e2e25bd6651f514d79a2dd9b01cd8c09f3c9d3859338490f57 +89fe366096097e38ec28dd1148887112efa5306cc0c3da09562aafa56f4eb000bf46ff79bf0bdd270cbde6bf0e1c8957 +af409a90c2776e1e7e3760b2042507b8709e943424606e31e791d42f17873a2710797f5baaab4cc4a19998ef648556b0 +8d761863c9b6edbd232d35ab853d944f5c950c2b643f84a1a1327ebb947290800710ff01dcfa26dc8e9828481240e8b1 +90b95e9be1e55c463ed857c4e0617d6dc3674e99b6aa62ed33c8e79d6dfcf7d122f4f4cc2ee3e7c5a49170cb617d2e2e +b3ff381efefabc4db38cc4727432e0301949ae4f16f8d1dea9b4f4de611cf5a36d84290a0bef160dac4e1955e516b3b0 +a8a84564b56a9003adcadb3565dc512239fc79572762cda7b5901a255bc82656bb9c01212ad33d6bef4fbbce18dacc87 +90a081890364b222eef54bf0075417f85e340d2fec8b7375995f598aeb33f26b44143ebf56fca7d8b4ebb36b5747b0eb +ade6ee49e1293224ddf2d8ab7f14bb5be6bc6284f60fd5b3a1e0cf147b73cff57cf19763b8a36c5083badc79c606b103 +b2fa99806dd2fa3de09320b615a2570c416c9bcdb052e592b0aead748bbe407ec9475a3d932ae48b71c2627eb81986a6 +91f3b7b73c8ccc9392542711c45fe6f236057e6efad587d661ad5cb4d6e88265f86b807bb1151736b1009ab74fd7acb4 +8800e2a46af96696dfbdcbf2ca2918b3dcf28ad970170d2d1783b52b8d945a9167d052beeb55f56c126da7ffa7059baa +9862267a1311c385956b977c9aa08548c28d758d7ba82d43dbc3d0a0fd1b7a221d39e8399997fea9014ac509ff510ac4 +b7d24f78886fd3e2d283e18d9ad5a25c1a904e7d9b9104bf47da469d74f34162e27e531380dbbe0a9d051e6ffd51d6e7 +b0f445f9d143e28b9df36b0f2c052da87ee2ca374d9d0fbe2eff66ca6fe5fe0d2c1951b428d58f7314b7e74e45d445ea +b63fc4083eabb8437dafeb6a904120691dcb53ce2938b820bb553da0e1eecd476f72495aacb72600cf9cad18698fd3db +b9ffd8108eaebd582d665f8690fe8bb207fd85185e6dd9f0b355a09bac1bbff26e0fdb172bc0498df025414e88fe2eda +967ed453e1f1a4c5b7b6834cc9f75c13f6889edc0cc91dc445727e9f408487bbf05c337103f61397a10011dfbe25d61d +98ceb673aff36e1987d5521a3984a07079c3c6155974bb8b413e8ae1ce84095fe4f7862fba7aefa14753eb26f2a5805f +85f01d28603a8fdf6ce6a50cb5c44f8a36b95b91302e3f4cd95c108ce8f4d212e73aec1b8d936520d9226802a2bd9136 +88118e9703200ca07910345fbb789e7a8f92bd80bbc79f0a9e040e8767d33df39f6eded403a9b636eabf9101e588482a +90833a51eef1b10ed74e8f9bbd6197e29c5292e469c854eed10b0da663e2bceb92539710b1858bbb21887bd538d28d89 +b513b905ec19191167c6193067b5cfdf5a3d3828375360df1c7e2ced5815437dfd37f0c4c8f009d7fb29ff3c8793f560 +b1b6d405d2d18f9554b8a358cc7e2d78a3b34269737d561992c8de83392ac9a2857be4bf15de5a6c74e0c9d0f31f393c +b828bd3e452b797323b798186607849f85d1fb20c616833c0619360dfd6b3e3aa000fd09dafe4b62d74abc41072ff1a9 +8efde67d0cca56bb2c464731879c9ac46a52e75bac702a63200a5e192b4f81c641f855ca6747752b84fe469cb7113b6c +b2762ba1c89ac3c9a983c242e4d1c2610ff0528585ed5c0dfc8a2c0253551142af9b59f43158e8915a1da7cc26b9df67 +8a3f1157fb820d1497ef6b25cd70b7e16bb8b961b0063ad340d82a79ee76eb2359ca9e15e6d42987ed7f154f5eeaa2da +a75e29f29d38f09c879f971c11beb5368affa084313474a5ecafa2896180b9e47ea1995c2733ec46f421e395a1d9cffe +8e8c3dd3e7196ef0b4996b531ec79e4a1f211db5d5635e48ceb80ff7568b2ff587e845f97ee703bb23a60945ad64314a +8e7f32f4a3e3c584af5e3d406924a0aa34024c42eca74ef6cc2a358fd3c9efaf25f1c03aa1e66bb94b023a2ee2a1cace +ab7dce05d59c10a84feb524fcb62478906b3fa045135b23afbede3bb32e0c678d8ebe59feabccb5c8f3550ea76cae44b +b38bb4b44d827f6fd3bd34e31f9186c59e312dbfadd4a7a88e588da10146a78b1f8716c91ad8b806beb8da65cab80c4c +9490ce9442bbbd05438c7f5c4dea789f74a7e92b1886a730544b55ba377840740a3ae4f2f146ee73f47c9278b0e233bc +83c003fab22a7178eed1a668e0f65d4fe38ef3900044e9ec63070c23f2827d36a1e73e5c2b883ec6a2afe2450171b3b3 +9982f02405978ddc4fca9063ebbdb152f524c84e79398955e66fe51bc7c1660ec1afc3a86ec49f58d7b7dde03505731c +ab337bd83ccdd2322088ffa8d005f450ced6b35790f37ab4534313315ee84312adc25e99cce052863a8bedee991729ed +8312ce4bec94366d88f16127a17419ef64285cd5bf9e5eda010319b48085966ed1252ed2f5a9fd3e0259b91bb65f1827 +a60d5a6327c4041b0c00a1aa2f0af056520f83c9ce9d9ccd03a0bd4d9e6a1511f26a422ea86bd858a1f77438adf07e6c +b84a0a0b030bdad83cf5202aa9afe58c9820e52483ab41f835f8c582c129ee3f34aa096d11c1cd922eda02ea1196a882 +8077d105317f4a8a8f1aadeb05e0722bb55f11abcb490c36c0904401107eb3372875b0ac233144829e734f0c538d8c1d +9202503bd29a6ec198823a1e4e098f9cfe359ed51eb5174d1ca41368821bfeebcbd49debfd02952c41359d1c7c06d2b1 +abc28c155e09365cb77ffead8dc8f602335ef93b2f44e4ef767ce8fc8ef9dd707400f3a722e92776c2e0b40192c06354 +b0f6d1442533ca45c9399e0a63a11f85ff288d242cea6cb3b68c02e77bd7d158047cae2d25b3bcd9606f8f66d9b32855 +b01c3d56a0db84dc94575f4b6ee2de4beca3230e86bed63e2066beb22768b0a8efb08ebaf8ac3dedb5fe46708b084807 +8c8634b0432159f66feaabb165842d1c8ac378f79565b1b90c381aa8450eb4231c3dad11ec9317b9fc2b155c3a771e32 +8e67f623d69ecd430c9ee0888520b6038f13a2b6140525b056dc0951f0cfed2822e62cf11d952a483107c5c5acac4826 +9590bb1cba816dd6acd5ac5fba5142c0a19d53573e422c74005e0bcf34993a8138c83124cad35a3df65879dba6134edd +801cd96cde0749021a253027118d3ea135f3fcdbe895db08a6c145641f95ebd368dd6a1568d995e1d0084146aebe224a +848b5d196427f6fc1f762ee3d36e832b64a76ec1033cfedc8b985dea93932a7892b8ef1035c653fb9dcd9ab2d9a44ac8 +a1017eb83d5c4e2477e7bd2241b2b98c4951a3b391081cae7d75965cadc1acaec755cf350f1f3d29741b0828e36fedea +8d6d2785e30f3c29aad17bd677914a752f831e96d46caf54446d967cb2432be2c849e26f0d193a60bee161ea5c6fe90a +935c0ba4290d4595428e034b5c8001cbd400040d89ab00861108e8f8f4af4258e41f34a7e6b93b04bc253d3b9ffc13bf +aac02257146246998477921cef2e9892228590d323b839f3e64ea893b991b463bc2f47e1e5092ddb47e70b2f5bce7622 +b921fde9412970a5d4c9a908ae8ce65861d06c7679af577cf0ad0d5344c421166986bee471fd6a6cecb7d591f06ec985 +8ef4c37487b139d6756003060600bb6ebac7ea810b9c4364fc978e842f13ac196d1264fbe5af60d76ff6d9203d8e7d3f +94b65e14022b5cf6a9b95f94be5ace2711957c96f4211c3f7bb36206bd39cfbd0ea82186cab5ad0577a23214a5c86e9e +a31c166d2a2ca1d5a75a5920fef7532681f62191a50d8555fdaa63ba4581c3391cc94a536fc09aac89f64eafceec3f90 +919a8cc128de01e9e10f5d83b08b52293fdd41bde2b5ae070f3d95842d4a16e5331cf2f3d61c765570c8022403610fa4 +b23d6f8331eef100152d60483cfa14232a85ee712c8538c9b6417a5a7c5b353c2ac401390c6c215cb101f5cee6b5f43e +ab357160c08a18319510a571eafff154298ce1020de8e1dc6138a09fcb0fcbcdd8359f7e9386bda00b7b9cdea745ffdc +ab55079aea34afa5c0bd1124b9cdfe01f325b402fdfa017301bf87812eaa811ea5798c3aaf818074d420d1c782b10ada +ade616010dc5009e7fc4f8d8b00dc716686a5fa0a7816ad9e503e15839d3b909b69d9dd929b7575376434ffec0d2bea8 +863997b97ed46898a8a014599508fa3079f414b1f4a0c4fdc6d74ae8b444afa350f327f8bfc2a85d27f9e2d049c50135 +8d602ff596334efd4925549ed95f2aa762b0629189f0df6dbb162581657cf3ea6863cd2287b4d9c8ad52813d87fcd235 +b70f68c596dcdeed92ad5c6c348578b26862a51eb5364237b1221e840c47a8702f0fbc56eb520a22c0eed99795d3903e +9628088f8e0853cefadee305a8bf47fa990c50fa96a82511bbe6e5dc81ef4b794e7918a109070f92fc8384d77ace226f +97e26a46e068b605ce96007197ecd943c9a23881862f4797a12a3e96ba2b8d07806ad9e2a0646796b1889c6b7d75188c +b1edf467c068cc163e2d6413cc22b16751e78b3312fe47b7ea82b08a1206d64415b2c8f2a677fa89171e82cc49797150 +a44d15ef18745b251429703e3cab188420e2d974de07251501799b016617f9630643fcd06f895634d8ecdd579e1bf000 +abd126df3917ba48c618ee4dbdf87df506193462f792874439043fa1b844466f6f4e0ff2e42516e63b5b23c0892b2695 +a2a67f57c4aa3c2aa1eeddbfd5009a89c26c2ce8fa3c96a64626aba19514beb125f27df8559506f737de3eae0f1fc18f +a633e0132197e6038197304b296ab171f1d8e0d0f34dcf66fe9146ac385b0239232a8470b9205a4802ab432389f4836d +a914b3a28509a906c3821463b936455d58ff45dcbe158922f9efb2037f2eb0ce8e92532d29b5d5a3fcd0d23fa773f272 +a0e1412ce4505daf1a2e59ce4f0fc0e0023e335b50d2b204422f57cd65744cc7a8ed35d5ef131a42c70b27111d3115b7 +a2339e2f2b6072e88816224fdd612c04d64e7967a492b9f8829db15367f565745325d361fd0607b0def1be384d010d9e +a7309fc41203cb99382e8193a1dcf03ac190a7ce04835304eb7e341d78634e83ea47cb15b885601956736d04cdfcaa01 +81f3ccd6c7f5b39e4e873365f8c37b214e8ab122d04a606fbb7339dc3298c427e922ec7418002561d4106505b5c399ee +92c121cf914ca549130e352eb297872a63200e99b148d88fbc9506ad882bec9d0203d65f280fb5b0ba92e336b7f932e8 +a4b330cf3f064f5b131578626ad7043ce2a433b6f175feb0b52d36134a454ca219373fd30d5e5796410e005b69082e47 +86fe5774112403ad83f9c55d58317eeb17ad8e1176d9f2f69c2afb7ed83bc718ed4e0245ceab4b377f5f062dcd4c00e7 +809d152a7e2654c7fd175b57f7928365a521be92e1ed06c05188a95864ddb25f7cab4c71db7d61bbf4cae46f3a1d96ce +b82d663e55c2a5ada7e169e9b1a87bc1c0177baf1ec1c96559b4cb1c5214ce1ddf2ab8d345014cab6402f3774235cf5a +86580af86df1bd2c385adb8f9a079e925981b7184db66fc5fe5b14cddb82e7d836b06eaeef14924ac529487b23dae111 +b5f5f4c5c94944ecc804df6ab8687d64e27d988cbfeae1ba7394e0f6adbf778c5881ead7cd8082dd7d68542b9bb4ecd5 +a6016916146c2685c46e8fdd24186394e2d5496e77e08c0c6a709d4cd7dfa97f1efcef94922b89196819076a91ad37b5 +b778e7367ded3b6eab53d5fc257f7a87e8faf74a593900f2f517220add2125be3f6142022660d8181df8d164ad9441ce +8581b2d36abe6f553add4d24be761bec1b8efaa2929519114346615380b3c55b59e6ad86990e312f7e234d0203bdf59b +9917e74fd45c3f71a829ff5498a7f6b5599b48c098dda2339bf04352bfc7f368ccf1a407f5835901240e76452ae807d7 +afd196ce6f9335069138fd2e3d133134da253978b4ce373152c0f26affe77a336505787594022e610f8feb722f7cc1fb +a477491a1562e329764645e8f24d8e228e5ef28c9f74c6b5b3abc4b6a562c15ffb0f680d372aed04d9e1bf944dece7be +9767440d58c57d3077319d3a330e5322b9ba16981ec74a5a14d53462eab59ae7fd2b14025bfc63b268862094acb444e6 +80986d921be3513ef69264423f351a61cb48390c1be8673aee0f089076086aaebea7ebe268fd0aa7182695606116f679 +a9554c5c921c07b450ee04e34ec58e054ac1541b26ce2ce5a393367a97348ba0089f53db6660ad76b60278b66fd12e3e +95097e7d2999b3e84bf052c775581cf361325325f4a50192521d8f4693c830bed667d88f482dc1e3f833aa2bd22d2cbf +9014c91d0f85aefd28436b5228c12f6353c055a9326c7efbf5e071e089e2ee7c070fcbc84c5fafc336cbb8fa6fec1ca1 +90f57ba36ee1066b55d37384942d8b57ae00f3cf9a3c1d6a3dfee1d1af42d4b5fa9baeb0cd7e46687d1d6d090ddb931d +8e4b1db12fd760a17214c9e47f1fce6e43c0dbb4589a827a13ac61aaae93759345697bb438a00edab92e0b7b62414683 +8022a959a513cdc0e9c705e0fc04eafd05ff37c867ae0f31f6d01cddd5df86138a426cab2ff0ac8ff03a62e20f7e8f51 +914e9a38829834c7360443b8ed86137e6f936389488eccf05b4b4db7c9425611705076ecb3f27105d24b85c852be7511 +957fb10783e2bd0db1ba66b18e794df710bc3b2b05776be146fa5863c15b1ebdd39747b1a95d9564e1772cdfc4f37b8a +b6307028444daed8ed785ac9d0de76bc3fe23ff2cc7e48102553613bbfb5afe0ebe45e4212a27021c8eb870721e62a1f +8f76143597777d940b15a01b39c5e1b045464d146d9a30a6abe8b5d3907250e6c7f858ff2308f8591e8b0a7b3f3c568a +96163138ac0ce5fd00ae9a289648fd9300a0ca0f63a88481d703ecd281c06a52a3b5178e849e331f9c85ca4ba398f4cc +a63ef47c3e18245b0482596a09f488a716df3cbd0f9e5cfabed0d742843e65db8961c556f45f49762f3a6ac8b627b3ef +8cb595466552e7c4d42909f232d4063e0a663a8ef6f6c9b7ce3a0542b2459cde04e0e54c7623d404acb5b82775ac04f6 +b47fe69960eb45f399368807cff16d941a5a4ebad1f5ec46e3dc8a2e4d598a7e6114d8f0ca791e9720fd786070524e2b +89eb5ff83eea9df490e5beca1a1fbbbbcf7184a37e2c8c91ede7a1e654c81e8cd41eceece4042ea7918a4f4646b67fd6 +a84f5d155ed08b9054eecb15f689ba81e44589e6e7207a99790c598962837ca99ec12344105b16641ca91165672f7153 +a6cc8f25c2d5b2d2f220ec359e6a37a52b95fa6af6e173c65e7cd55299eff4aa9e6d9e6f2769e6459313f1f2aecb0fab +afcde944411f017a9f7979755294981e941cc41f03df5e10522ef7c7505e5f1babdd67b3bf5258e8623150062eb41d9b +8fab39f39c0f40182fcd996ade2012643fe7731808afbc53f9b26900b4d4d1f0f5312d9d40b3df8baa4739970a49c732 +ae193af9726da0ebe7df1f9ee1c4846a5b2a7621403baf8e66c66b60f523e719c30c6b4f897bb14b27d3ff3da8392eeb +8ac5adb82d852eba255764029f42e6da92dcdd0e224d387d1ef94174038db9709ac558d90d7e7c57ad4ce7f89bbfc38c +a2066b3458fdf678ee487a55dd5bfb74fde03b54620cb0e25412a89ee28ad0d685e309a51e3e4694be2fa6f1593a344c +88d031745dd0ae07d61a15b594be5d4b2e2a29e715d081649ad63605e3404b0c3a5353f0fd9fad9c05c18e93ce674fa1 +8283cfb0ef743a043f2b77ecaeba3005e2ca50435585b5dd24777ee6bce12332f85e21b446b536da38508807f0f07563 +b376de22d5f6b0af0b59f7d9764561f4244cf8ffe22890ecd3dcf2ff1832130c9b821e068c9d8773136f4796721e5963 +ae3afc50c764f406353965363840bf28ee85e7064eb9d5f0bb3c31c64ab10f48c853e942ee2c9b51bae59651eaa08c2f +948b204d103917461a01a6c57a88f2d66b476eae5b00be20ec8c747650e864bc8a83aee0aff59cb7584b7a3387e0ee48 +81ab098a082b07f896c5ffd1e4446cb7fb44804cbbf38d125208b233fc82f8ec9a6a8d8dd1c9a1162dc28ffeec0dde50 +a149c6f1312821ced2969268789a3151bdda213451760b397139a028da609c4134ac083169feb0ee423a0acafd10eceb +b0ac9e27a5dadaf523010f730b28f0ebac01f460d3bbbe277dc9d44218abb5686f4fac89ae462682fef9edbba663520a +8d0e0073cca273daaaa61b6fc54bfe5a009bc3e20ae820f6c93ba77b19eca517d457e948a2de5e77678e4241807157cb +ad61d3a2edf7c7533a04964b97499503fd8374ca64286dba80465e68fe932e96749b476f458c6fc57cb1a7ca85764d11 +90eb5e121ae46bc01a30881eaa556f46bd8457a4e80787cf634aab355082de34ac57d7f497446468225f7721e68e2a47 +8cdac557de7c42d1f3780e33dec1b81889f6352279be81c65566cdd4952d4c15d79e656cbd46035ab090b385e90245ef +82b67e61b88b84f4f4d4f65df37b3e3dcf8ec91ea1b5c008fdccd52da643adbe6468a1cfdb999e87d195afe2883a3b46 +8503b467e8f5d6048a4a9b78496c58493a462852cab54a70594ae3fd064cfd0deb4b8f336a262155d9fedcaa67d2f6fd +8db56c5ac763a57b6ce6832930c57117058e3e5a81532b7d19346346205e2ec614eb1a2ee836ef621de50a7bc9b7f040 +ad344699198f3c6e8c0a3470f92aaffc805b76266734414c298e10b5b3797ca53578de7ccb2f458f5e0448203f55282b +80602032c43c9e2a09154cc88b83238343b7a139f566d64cb482d87436b288a98f1ea244fd3bff8da3c398686a900c14 +a6385bd50ecd548cfb37174cdbb89e10025b5cadaf3cff164c95d7aef5a33e3d6a9bf0c681b9e11db9ef54ebeee2a0c1 +abf2d95f4aa34b0581eb9257a0cc8462b2213941a5deb8ba014283293e8b36613951b61261cc67bbd09526a54cbbff76 +a3d5de52f48df72c289ff713e445991f142390798cd42bd9d9dbefaee4af4f5faf09042d126b975cf6b98711c3072553 +8e627302ff3d686cff8872a1b7c2a57b35f45bf2fc9aa42b049d8b4d6996a662b8e7cbac6597f0cb79b0cc4e29fbf133 +8510702e101b39a1efbf4e504e6123540c34b5689645e70d0bac1ecc1baf47d86c05cef6c4317a4e99b4edaeb53f2d00 +aa173f0ecbcc6088f878f8726d317748c81ebf501bba461f163b55d66099b191ec7c55f7702f351a9c8eb42cfa3280e2 +b560a697eafab695bcef1416648a0a664a71e311ecbe5823ae903bd0ed2057b9d7574b9a86d3fe22aa3e6ddce38ea513 +8df6304a3d9cf40100f3f687575419c998cd77e5cc27d579cf4f8e98642de3609af384a0337d145dd7c5635172d26a71 +8105c7f3e4d30a29151849673853b457c1885c186c132d0a98e63096c3774bc9deb956cf957367e633d0913680bda307 +95373fc22c0917c3c2044ac688c4f29a63ed858a45c0d6d2d0fe97afd6f532dcb648670594290c1c89010ecc69259bef +8c2fae9bcadab341f49b55230310df93cac46be42d4caa0d42e45104148a91e527af1b4209c0d972448162aed28fab64 +b05a77baab70683f76209626eaefdda2d36a0b66c780a20142d23c55bd479ddd4ad95b24579384b6cf62c8eb4c92d021 +8e6bc6a7ea2755b4aaa19c1c1dee93811fcde514f03485fdc3252f0ab7f032c315614f6336e57cea25dcfb8fb6084eeb +b656a27d06aade55eadae2ad2a1059198918ea6cc3fd22c0ed881294d34d5ac7b5e4700cc24350e27d76646263b223aa +a296469f24f6f56da92d713afcd4dd606e7da1f79dc4e434593c53695847eefc81c7c446486c4b3b8c8d00c90c166f14 +87a326f57713ac2c9dffeb3af44b9f3c613a8f952676fc46343299122b47ee0f8d792abaa4b5db6451ced5dd153aabd0 +b689e554ba9293b9c1f6344a3c8fcb6951d9f9eac4a2e2df13de021aade7c186be27500e81388e5b8bcab4c80f220a31 +87ae0aa0aa48eac53d1ca5a7b93917de12db9e40ceabf8fdb40884ae771cfdf095411deef7c9f821af0b7070454a2608 +a71ffa7eae8ace94e6c3581d4cb2ad25d48cbd27edc9ec45baa2c8eb932a4773c3272b2ffaf077b40f76942a1f3af7f2 +94c218c91a9b73da6b7a495b3728f3028df8ad9133312fc0c03e8c5253b7ccb83ed14688fd4602e2fd41f29a0bc698bd +ae1e77b90ca33728af07a4c03fb2ef71cd92e2618e7bf8ed4d785ce90097fc4866c29999eb84a6cf1819d75285a03af2 +b7a5945b277dab9993cf761e838b0ac6eaa903d7111fca79f9fde3d4285af7a89bf6634a71909d095d7619d913972c9c +8c43b37be02f39b22029b20aca31bff661abce4471dca88aa3bddefd9c92304a088b2dfc8c4795acc301ca3160656af2 +b32e5d0fba024554bd5fe8a793ebe8003335ddd7f585876df2048dcf759a01285fecb53daae4950ba57f3a282a4d8495 +85ea7fd5e10c7b659df5289b2978b2c89e244f269e061b9a15fcab7983fc1962b63546e82d5731c97ec74b6804be63ef +96b89f39181141a7e32986ac02d7586088c5a9662cec39843f397f3178714d02f929af70630c12cbaba0268f8ba2d4fa +929ab1a2a009b1eb37a2817c89696a06426529ebe3f306c586ab717bd34c35a53eca2d7ddcdef36117872db660024af9 +a696dccf439e9ca41511e16bf3042d7ec0e2f86c099e4fc8879d778a5ea79e33aa7ce96b23dc4332b7ba26859d8e674d +a8fe69a678f9a194b8670a41e941f0460f6e2dbc60470ab4d6ae2679cc9c6ce2c3a39df2303bee486dbfde6844e6b31a +95f58f5c82de2f2a927ca99bf63c9fc02e9030c7e46d0bf6b67fe83a448d0ae1c99541b59caf0e1ccab8326231af09a5 +a57badb2c56ca2c45953bd569caf22968f76ed46b9bac389163d6fe22a715c83d5e94ae8759b0e6e8c2f27bff7748f3f +868726fd49963b24acb5333364dffea147e98f33aa19c7919dc9aca0fd26661cfaded74ede7418a5fadbe7f5ae67b67b +a8d8550dcc64d9f1dd7bcdab236c4122f2b65ea404bb483256d712c7518f08bb028ff8801f1da6aed6cbfc5c7062e33b +97e25a87dae23155809476232178538d4bc05d4ff0882916eb29ae515f2a62bfce73083466cc0010ca956aca200aeacc +b4ea26be3f4bd04aa82d7c4b0913b97bcdf5e88b76c57eb1a336cbd0a3eb29de751e1bc47c0e8258adec3f17426d0c71 +99ee555a4d9b3cf2eb420b2af8e3bc99046880536116d0ce7193464ac40685ef14e0e3c442f604e32f8338cb0ef92558 +8c64efa1da63cd08f319103c5c7a761221080e74227bbc58b8fb35d08aa42078810d7af3e60446cbaff160c319535648 +8d9fd88040076c28420e3395cbdfea402e4077a3808a97b7939d49ecbcf1418fe50a0460e1c1b22ac3f6e7771d65169a +ae3c19882d7a9875d439265a0c7003c8d410367627d21575a864b9cb4918de7dbdb58a364af40c5e045f3df40f95d337 +b4f7bfacab7b2cafe393f1322d6dcc6f21ffe69cd31edc8db18c06f1a2b512c27bd0618091fd207ba8df1808e9d45914 +94f134acd0007c623fb7934bcb65ef853313eb283a889a3ffa79a37a5c8f3665f3d5b4876bc66223610c21dc9b919d37 +aa15f74051171daacdc1f1093d3f8e2d13da2833624b80a934afec86fc02208b8f55d24b7d66076444e7633f46375c6a +a32d6bb47ef9c836d9d2371807bafbbbbb1ae719530c19d6013f1d1f813c49a60e4fa51d83693586cba3a840b23c0404 +b61b3599145ea8680011aa2366dc511a358b7d67672d5b0c5be6db03b0efb8ca5a8294cf220ea7409621f1664e00e631 +859cafc3ee90b7ececa1ed8ef2b2fc17567126ff10ca712d5ffdd16aa411a5a7d8d32c9cab1fbf63e87dce1c6e2f5f53 +a2fef1b0b2874387010e9ae425f3a9676d01a095d017493648bcdf3b31304b087ccddb5cf76abc4e1548b88919663b6b +939e18c73befc1ba2932a65ede34c70e4b91e74cc2129d57ace43ed2b3af2a9cc22a40fbf50d79a63681b6d98852866d +b3b4259d37b1b14aee5b676c9a0dd2d7f679ab95c120cb5f09f9fbf10b0a920cb613655ddb7b9e2ba5af4a221f31303c +997255fe51aaca6e5a9cb3359bcbf25b2bb9e30649bbd53a8a7c556df07e441c4e27328b38934f09c09d9500b5fabf66 +abb91be2a2d860fd662ed4f1c6edeefd4da8dc10e79251cf87f06029906e7f0be9b486462718f0525d5e049472692cb7 +b2398e593bf340a15f7801e1d1fbda69d93f2a32a889ec7c6ae5e8a37567ac3e5227213c1392ee86cfb3b56ec2787839 +8ddf10ccdd72922bed36829a36073a460c2118fc7a56ff9c1ac72581c799b15c762cb56cb78e3d118bb9f6a7e56cb25e +93e6bc0a4708d16387cacd44cf59363b994dc67d7ada7b6d6dbd831c606d975247541b42b2a309f814c1bfe205681fc6 +b93fc35c05998cffda2978e12e75812122831523041f10d52f810d34ff71944979054b04de0117e81ddf5b0b4b3e13c0 +92221631c44d60d68c6bc7b287509f37ee44cbe5fdb6935cee36b58b17c7325098f98f7910d2c3ca5dc885ad1d6dabc7 +a230124424a57fad3b1671f404a94d7c05f4c67b7a8fbacfccea28887b78d7c1ed40b92a58348e4d61328891cd2f6cee +a6a230edb8518a0f49d7231bc3e0bceb5c2ac427f045819f8584ba6f3ae3d63ed107a9a62aad543d7e1fcf1f20605706 +845be1fe94223c7f1f97d74c49d682472585d8f772762baad8a9d341d9c3015534cc83d102113c51a9dea2ab10d8d27b +b44262515e34f2db597c8128c7614d33858740310a49cdbdf9c8677c5343884b42c1292759f55b8b4abc4c86e4728033 +805592e4a3cd07c1844bc23783408310accfdb769cca882ad4d07d608e590a288b7370c2cb327f5336e72b7083a0e30f +95153e8b1140df34ee864f4ca601cb873cdd3efa634af0c4093fbaede36f51b55571ab271e6a133020cd34db8411241f +82878c1285cfa5ea1d32175c9401f3cc99f6bb224d622d3fd98cc7b0a27372f13f7ab463ce3a33ec96f9be38dbe2dfe3 +b7588748f55783077c27fc47d33e20c5c0f5a53fc0ac10194c003aa09b9f055d08ec971effa4b7f760553997a56967b3 +b36b4de6d1883b6951f59cfae381581f9c6352fcfcf1524fccdab1571a20f80441d9152dc6b48bcbbf00371337ca0bd5 +89c5523f2574e1c340a955cbed9c2f7b5fbceb260cb1133160dabb7d41c2f613ec3f6e74bbfab3c4a0a6f0626dbe068f +a52f58cc39f968a9813b1a8ddc4e83f4219e4dd82c7aa1dd083bea7edf967151d635aa9597457f879771759b876774e4 +8300a67c2e2e123f89704abfde095463045dbd97e20d4c1157bab35e9e1d3d18f1f4aaba9cbe6aa2d544e92578eaa1b6 +ac6a7f2918768eb6a43df9d3a8a04f8f72ee52f2e91c064c1c7d75cad1a3e83e5aba9fe55bb94f818099ac91ccf2e961 +8d64a2b0991cf164e29835c8ddef6069993a71ec2a7de8157bbfa2e00f6367be646ed74cbaf524f0e9fe13fb09fa15fd +8b2ffe5a545f9f680b49d0a9797a4a11700a2e2e348c34a7a985fc278f0f12def6e06710f40f9d48e4b7fbb71e072229 +8ab8f71cd337fa19178924e961958653abf7a598e3f022138b55c228440a2bac4176cea3aea393549c03cd38a13eb3fc +8419d28318c19ea4a179b7abb43669fe96347426ef3ac06b158d79c0acf777a09e8e770c2fb10e14b3a0421705990b23 +8bacdac310e1e49660359d0a7a17fe3d334eb820e61ae25e84cb52f863a2f74cbe89c2e9fc3283745d93a99b79132354 +b57ace3fa2b9f6b2db60c0d861ace7d7e657c5d35d992588aeed588c6ce3a80b6f0d49f8a26607f0b17167ab21b675e4 +83e265cde477f2ecc164f49ddc7fb255bb05ff6adc347408353b7336dc3a14fdedc86d5a7fb23f36b8423248a7a67ed1 +a60ada971f9f2d79d436de5d3d045f5ab05308cae3098acaf5521115134b2a40d664828bb89895840db7f7fb499edbc5 +a63eea12efd89b62d3952bf0542a73890b104dd1d7ff360d4755ebfa148fd62de668edac9eeb20507967ea37fb220202 +a0275767a270289adc991cc4571eff205b58ad6d3e93778ddbf95b75146d82517e8921bd0d0564e5b75fa0ccdab8e624 +b9b03fd3bf07201ba3a039176a965d736b4ef7912dd9e9bf69fe1b57c330a6aa170e5521fe8be62505f3af81b41d7806 +a95f640e26fb1106ced1729d6053e41a16e4896acac54992279ff873e5a969aad1dcfa10311e28b8f409ac1dab7f03bb +b144778921742418053cb3c70516c63162c187f00db2062193bb2c14031075dbe055d020cde761b26e8c58d0ea6df2c1 +8432fbb799e0435ef428d4fefc309a05dd589bce74d7a87faf659823e8c9ed51d3e42603d878e80f439a38be4321c2fa +b08ddef14e42d4fd5d8bf39feb7485848f0060d43b51ed5bdda39c05fe154fb111d29719ee61a23c392141358c0cfcff +8ae3c5329a5e025b86b5370e06f5e61177df4bda075856fade20a17bfef79c92f54ed495f310130021ba94fb7c33632b +92b6d3c9444100b4d7391febfc1dddaa224651677c3695c47a289a40d7a96d200b83b64e6d9df51f534564f272a2c6c6 +b432bc2a3f93d28b5e506d68527f1efeb2e2570f6be0794576e2a6ef9138926fdad8dd2eabfa979b79ab7266370e86bc +8bc315eacedbcfc462ece66a29662ca3dcd451f83de5c7626ef8712c196208fb3d8a0faf80b2e80384f0dd9772f61a23 +a72375b797283f0f4266dec188678e2b2c060dfed5880fc6bb0c996b06e91a5343ea2b695adaab0a6fd183b040b46b56 +a43445036fbaa414621918d6a897d3692fdae7b2961d87e2a03741360e45ebb19fcb1703d23f1e15bb1e2babcafc56ac +b9636b2ffe305e63a1a84bd44fb402442b1799bd5272638287aa87ca548649b23ce8ce7f67be077caed6aa2dbc454b78 +99a30bf0921d854c282b83d438a79f615424f28c2f99d26a05201c93d10378ab2cd94a792b571ddae5d4e0c0013f4006 +8648e3c2f93d70b392443be116b48a863e4b75991bab5db656a4ef3c1e7f645e8d536771dfe4e8d1ceda3be8d32978b0 +ab50dc9e6924c1d2e9d2e335b2d679fc7d1a7632e84964d3bac0c9fe57e85aa5906ec2e7b0399d98ddd022e9b19b5904 +ab729328d98d295f8f3272afaf5d8345ff54d58ff9884da14f17ecbdb7371857fdf2f3ef58080054e9874cc919b46224 +83fa5da7592bd451cad3ad7702b4006332b3aae23beab4c4cb887fa6348317d234bf62a359e665b28818e5410c278a09 +8bdbff566ae9d368f114858ef1f009439b3e9f4649f73efa946e678d6c781d52c69af195df0a68170f5f191b2eac286b +91245e59b4425fd4edb2a61d0d47c1ccc83d3ced8180de34887b9655b5dcda033d48cde0bdc3b7de846d246c053a02e8 +a2cb00721e68f1cad8933947456f07144dc69653f96ceed845bd577d599521ba99cdc02421118971d56d7603ed118cbf +af8cd66d303e808b22ec57860dd909ca64c27ec2c60e26ffecfdc1179d8762ffd2739d87b43959496e9fee4108df71df +9954136812dffcd5d3f167a500e7ab339c15cfc9b3398d83f64b0daa3dd5b9a851204f424a3493b4e326d3de81e50a62 +93252254d12511955f1aa464883ad0da793f84d900fea83e1df8bca0f2f4cf5b5f9acbaec06a24160d33f908ab5fea38 +997cb55c26996586ba436a95566bd535e9c22452ca5d2a0ded2bd175376557fa895f9f4def4519241ff386a063f2e526 +a12c78ad451e0ac911260ade2927a768b50cb4125343025d43474e7f465cdc446e9f52a84609c5e7e87ae6c9b3f56cda +a789d4ca55cbba327086563831b34487d63d0980ba8cf55197c016702ed6da9b102b1f0709ce3da3c53ff925793a3d73 +a5d76acbb76741ce85be0e655b99baa04f7f587347947c0a30d27f8a49ae78cce06e1cde770a8b618d3db402be1c0c4b +873c0366668c8faddb0eb7c86f485718d65f8c4734020f1a18efd5fa123d3ea8a990977fe13592cd01d17e60809cb5ff +b659b71fe70f37573ff7c5970cc095a1dc0da3973979778f80a71a347ef25ad5746b2b9608bad4ab9a4a53a4d7df42d7 +a34cbe05888e5e5f024a2db14cb6dcdc401a9cbd13d73d3c37b348f68688f87c24ca790030b8f84fef9e74b4eab5e412 +94ce8010f85875c045b0f014db93ef5ab9f1f6842e9a5743dce9e4cb872c94affd9e77c1f1d1ab8b8660b52345d9acb9 +adefa9b27a62edc0c5b019ddd3ebf45e4de846165256cf6329331def2e088c5232456d3de470fdce3fa758bfdd387512 +a6b83821ba7c1f83cc9e4529cf4903adb93b26108e3d1f20a753070db072ad5a3689643144bdd9c5ea06bb9a7a515cd0 +a3a9ddedc2a1b183eb1d52de26718151744db6050f86f3580790c51d09226bf05f15111691926151ecdbef683baa992c +a64bac89e7686932cdc5670d07f0b50830e69bfb8c93791c87c7ffa4913f8da881a9d8a8ce8c1a9ce5b6079358c54136 +a77b5a63452cb1320b61ab6c7c2ef9cfbcade5fd4727583751fb2bf3ea330b5ca67757ec1f517bf4d503ec924fe32fbd +8746fd8d8eb99639d8cd0ca34c0d9c3230ed5a312aab1d3d925953a17973ee5aeb66e68667e93caf9cb817c868ea8f3d +88a2462a26558fc1fbd6e31aa8abdc706190a17c27fdc4217ffd2297d1b1f3321016e5c4b2384c5454d5717dc732ed03 +b78893a97e93d730c8201af2e0d3b31cb923d38dc594ffa98a714e627c473d42ea82e0c4d2eeb06862ee22a9b2c54588 +920cc8b5f1297cf215a43f6fc843e379146b4229411c44c0231f6749793d40f07b9af7699fd5d21fd69400b97febe027 +a0f0eafce1e098a6b58c7ad8945e297cd93aaf10bc55e32e2e32503f02e59fc1d5776936577d77c0b1162cb93b88518b +98480ba0064e97a2e7a6c4769b4d8c2a322cfc9a3b2ca2e67e9317e2ce04c6e1108169a20bd97692e1cb1f1423b14908 +83dbbb2fda7e287288011764a00b8357753a6a44794cc8245a2275237f11affdc38977214e463ad67aec032f3dfa37e9 +86442fff37598ce2b12015ff19b01bb8a780b40ad353d143a0f30a06f6d23afd5c2b0a1253716c855dbf445cc5dd6865 +b8a4c60c5171189414887847b9ed9501bff4e4c107240f063e2d254820d2906b69ef70406c585918c4d24f1dd052142b +919f33a98e84015b2034b57b5ffe9340220926b2c6e45f86fd79ec879dbe06a148ae68b77b73bf7d01bd638a81165617 +95c13e78d89474a47fbc0664f6f806744b75dede95a479bbf844db4a7f4c3ae410ec721cb6ffcd9fa9c323da5740d5ae +ab7151acc41fffd8ec6e90387700bcd7e1cde291ea669567295bea1b9dd3f1df2e0f31f3588cd1a1c08af8120aca4921 +80e74c5c47414bd6eeef24b6793fb1fa2d8fb397467045fcff887c52476741d5bc4ff8b6d3387cb53ad285485630537f +a296ad23995268276aa351a7764d36df3a5a3cffd7dbeddbcea6b1f77adc112629fdeffa0918b3242b3ccd5e7587e946 +813d2506a28a2b01cb60f49d6bd5e63c9b056aa56946faf2f33bd4f28a8d947569cfead3ae53166fc65285740b210f86 +924b265385e1646287d8c09f6c855b094daaee74b9e64a0dddcf9ad88c6979f8280ba30c8597b911ef58ddb6c67e9fe3 +8d531513c70c2d3566039f7ca47cd2352fd2d55b25675a65250bdb8b06c3843db7b2d29c626eed6391c238fc651cf350 +82b338181b62fdc81ceb558a6843df767b6a6e3ceedc5485664b4ea2f555904b1a45fbb35f6cf5d96f27da10df82a325 +92e62faaedea83a37f314e1d3cb4faaa200178371d917938e59ac35090be1db4b4f4e0edb78b9c991de202efe4f313d8 +99d645e1b642c2dc065bac9aaa0621bc648c9a8351efb6891559c3a41ba737bd155fb32d7731950514e3ecf4d75980e4 +b34a13968b9e414172fb5d5ece9a39cf2eb656128c3f2f6cc7a9f0c69c6bae34f555ecc8f8837dc34b5e470e29055c78 +a2a0bb7f3a0b23a2cbc6585d59f87cd7e56b2bbcb0ae48f828685edd9f7af0f5edb4c8e9718a0aaf6ef04553ba71f3b7 +8e1a94bec053ed378e524b6685152d2b52d428266f2b6eadd4bcb7c4e162ed21ab3e1364879673442ee2162635b7a4d8 +9944adaff14a85eab81c73f38f386701713b52513c4d4b838d58d4ffa1d17260a6d056b02334850ea9a31677c4b078bd +a450067c7eceb0854b3eca3db6cf38669d72cb7143c3a68787833cbca44f02c0be9bfbe082896f8a57debb13deb2afb1 +8be4ad3ac9ef02f7df09254d569939757101ee2eda8586fefcd8c847adc1efe5bdcb963a0cafa17651befaafb376a531 +90f6de91ea50255f148ac435e08cf2ac00c772a466e38155bd7e8acf9197af55662c7b5227f88589b71abe9dcf7ba343 +86e5a24f0748b106dee2d4d54e14a3b0af45a96cbee69cac811a4196403ebbee17fd24946d7e7e1b962ac7f66dbaf610 +afdd96fbcda7aa73bf9eeb2292e036c25753d249caee3b9c013009cc22e10d3ec29e2aa6ddbb21c4e949b0c0bccaa7f4 +b5a4e7436d5473647c002120a2cb436b9b28e27ad4ebdd7c5f122b91597c507d256d0cbd889d65b3a908531936e53053 +b632414c3da704d80ac2f3e5e0e9f18a3637cdc2ebeb613c29300745582427138819c4e7b0bec3099c1b8739dac1807b +a28df1464d3372ce9f37ef1db33cc010f752156afae6f76949d98cd799c0cf225c20228ae86a4da592d65f0cffe3951b +898b93d0a31f7d3f11f253cb7a102db54b669fd150da302d8354d8e02b1739a47cb9bd88015f3baf12b00b879442464e +96fb88d89a12049091070cb0048a381902965e67a8493e3991eaabe5d3b7ff7eecd5c94493a93b174df3d9b2c9511755 +b899cb2176f59a5cfba3e3d346813da7a82b03417cad6342f19cc8f12f28985b03bf031e856a4743fd7ebe16324805b0 +a60e2d31bc48e0c0579db15516718a03b73f5138f15037491f4dae336c904e312eda82d50862f4debd1622bb0e56d866 +979fc8b987b5cef7d4f4b58b53a2c278bd25a5c0ea6f41c715142ea5ff224c707de38451b0ad3aa5e749aa219256650a +b2a75bff18e1a6b9cf2a4079572e41205741979f57e7631654a3c0fcec57c876c6df44733c9da3d863db8dff392b44a3 +b7a0f0e811222c91e3df98ff7f286b750bc3b20d2083966d713a84a2281744199e664879401e77470d44e5a90f3e5181 +82b74ba21c9d147fbc338730e8f1f8a6e7fc847c3110944eb17a48bea5e06eecded84595d485506d15a3e675fd0e5e62 +a7f44eef817d5556f0d1abcf420301217d23c69dd2988f44d91ea1f1a16c322263cbacd0f190b9ba22b0f141b9267b4f +aadb68164ede84fc1cb3334b3194d84ba868d5a88e4c9a27519eef4923bc4abf81aab8114449496c073c2a6a0eb24114 +b5378605fabe9a8c12a5dc55ef2b1de7f51aedb61960735c08767a565793cea1922a603a6983dc25f7cea738d0f7c40d +a97a4a5cd8d51302e5e670aee78fe6b5723f6cc892902bbb4f131e82ca1dfd5de820731e7e3367fb0c4c1922a02196e3 +8bdfeb15c29244d4a28896f2b2cb211243cd6a1984a3f5e3b0ebe5341c419beeab3304b390a009ffb47588018034b0ea +a9af3022727f2aa2fca3b096968e97edad3f08edcbd0dbca107b892ae8f746a9c0485e0d6eb5f267999b23a845923ed0 +8e7594034feef412f055590fbb15b6322dc4c6ab7a4baef4685bd13d71a83f7d682b5781bdfa0d1c659489ce9c2b8000 +84977ca6c865ebee021c58106c1a4ad0c745949ecc5332948002fd09bd9b890524878d0c29da96fd11207621136421fe +8687551a79158e56b2375a271136756313122132a6670fa51f99a1b5c229ed8eea1655a734abae13228b3ebfd2a825dd +a0227d6708979d99edfc10f7d9d3719fd3fc68b0d815a7185b60307e4c9146ad2f9be2b8b4f242e320d4288ceeb9504c +89f75583a16735f9dd8b7782a130437805b34280ccea8dac6ecaee4b83fe96947e7b53598b06fecfffdf57ffc12cc445 +a0056c3353227f6dd9cfc8e3399aa5a8f1d71edf25d3d64c982910f50786b1e395c508d3e3727ac360e3e040c64b5298 +b070e61a6d813626144b312ded1788a6d0c7cec650a762b2f8df6e4743941dd82a2511cd956a3f141fc81e15f4e092da +b4e6db232e028a1f989bb5fc13416711f42d389f63564d60851f009dcffac01acfd54efa307aa6d4c0f932892d4e62b0 +89b5991a67db90024ddd844e5e1a03ef9b943ad54194ae0a97df775dde1addf31561874f4e40fbc37a896630f3bbda58 +ad0e8442cb8c77d891df49cdb9efcf2b0d15ac93ec9be1ad5c3b3cca1f4647b675e79c075335c1f681d56f14dc250d76 +b5d55a6ae65bb34dd8306806cb49b5ccb1c83a282ee47085cf26c4e648e19a52d9c422f65c1cd7e03ca63e926c5e92ea +b749501347e5ec07e13a79f0cb112f1b6534393458b3678a77f02ca89dca973fa7b30e55f0b25d8b92b97f6cb0120056 +94144b4a3ffc5eec6ba35ce9c245c148b39372d19a928e236a60e27d7bc227d18a8cac9983851071935d8ffb64b3a34f +92bb4f9f85bc8c028a3391306603151c6896673135f8a7aefedd27acb322c04ef5dac982fc47b455d6740023e0dd3ea3 +b9633a4a101461a782fc2aa092e9dbe4e2ad00987578f18cd7cf0021a909951d60fe79654eb7897806795f93c8ff4d1c +809f0196753024821b48a016eca5dbb449a7c55750f25981bb7a4b4c0e0846c09b8f6128137905055fc43a3f0deb4a74 +a27dc9cdd1e78737a443570194a03d89285576d3d7f3a3cf15cc55b3013e42635d4723e2e8fe1d0b274428604b630db9 +861f60f0462e04cd84924c36a28163def63e777318d00884ab8cb64c8df1df0bce5900342163edb60449296484a6c5bf +b7bc23fb4e14af4c4704a944253e760adefeca8caee0882b6bbd572c84434042236f39ae07a8f21a560f486b15d82819 +b9a6eb492d6dd448654214bd01d6dc5ff12067a11537ab82023fc16167507ee25eed2c91693912f4155d1c07ed9650b3 +97678af29c68f9a5e213bf0fb85c265303714482cfc4c2c00b4a1e8a76ed08834ee6af52357b143a1ca590fb0265ea5a +8a15b499e9eca5b6cac3070b5409e8296778222018ad8b53a5d1f6b70ad9bb10c68a015d105c941ed657bf3499299e33 +b487fefede2e8091f2c7bfe85770db2edff1db83d4effe7f7d87bff5ab1ace35e9b823a71adfec6737fede8d67b3c467 +8b51b916402aa2c437fce3bcad6dad3be8301a1a7eab9d163085b322ffb6c62abf28637636fe6114573950117fc92898 +b06a2106d031a45a494adec0881cb2f82275dff9dcdd2bc16807e76f3bec28a6734edd3d54f0be8199799a78cd6228ad +af0a185391bbe2315eb97feac98ad6dd2e5d931d012c621abd6e404a31cc188b286fef14871762190acf086482b2b5e2 +8e78ee8206506dd06eb7729e32fceda3bebd8924a64e4d8621c72e36758fda3d0001af42443851d6c0aea58562870b43 +a1ba52a569f0461aaf90b49b92be976c0e73ec4a2c884752ee52ffb62dd137770c985123d405dfb5de70692db454b54a +8d51b692fa1543c51f6b62b9acb8625ed94b746ef96c944ca02859a4133a5629da2e2ce84e111a7af8d9a5b836401c64 +a7a20d45044cf6492e0531d0b8b26ffbae6232fa05a96ed7f06bdb64c2b0f5ca7ec59d5477038096a02579e633c7a3ff +84df867b98c53c1fcd4620fef133ee18849c78d3809d6aca0fb6f50ff993a053a455993f216c42ab6090fa5356b8d564 +a7227c439f14c48e2577d5713c97a5205feb69acb0b449152842e278fa71e8046adfab468089c8b2288af1fc51fa945b +855189b3a105670779997690876dfaa512b4a25a24931a912c2f0f1936971d2882fb4d9f0b3d9daba77eaf660e9d05d5 +b5696bd6706de51c502f40385f87f43040a5abf99df705d6aac74d88c913b8ecf7a99a63d7a37d9bdf3a941b9e432ff5 +ab997beb0d6df9c98d5b49864ef0b41a2a2f407e1687dfd6089959757ba30ed02228940b0e841afe6911990c74d536c4 +b36b65f85546ebfdbe98823d5555144f96b4ab39279facd19c0de3b8919f105ba0315a0784dce4344b1bc62d8bb4a5a3 +b8371f0e4450788720ac5e0f6cd3ecc5413d33895083b2c168d961ec2b5c3de411a4cc0712481cbe8df8c2fa1a7af006 +98325d8026b810a8b7a114171ae59a57e8bbc9848e7c3df992efc523621729fd8c9f52114ce01d7730541a1ada6f1df1 +8d0e76dbd37806259486cd9a31bc8b2306c2b95452dc395546a1042d1d17863ef7a74c636b782e214d3aa0e8d717f94a +a4e15ead76da0214d702c859fb4a8accdcdad75ed08b865842bd203391ec4cba2dcc916455e685f662923b96ee0c023f +8618190972086ebb0c4c1b4a6c94421a13f378bc961cc8267a301de7390c5e73c3333864b3b7696d81148f9d4843fd02 +85369d6cc7342e1aa15b59141517d8db8baaaeb7ab9670f3ba3905353948d575923d283b7e5a05b13a30e7baf1208a86 +87c51ef42233c24a6da901f28c9a075d9ba3c625687c387ad6757b72ca6b5a8885e6902a3082da7281611728b1e45f26 +aa6348a4f71927a3106ad0ea8b02fc8d8c65531e4ab0bd0a17243e66f35afe252e40ab8eef9f13ae55a72566ffdaff5c +96a3bc976e9d03765cc3fee275fa05b4a84c94fed6b767e23ca689394501e96f56f7a97cffddc579a6abff632bf153be +97dbf96c6176379fdb2b888be4e757b2bca54e74124bd068d3fa1dbd82a011bbeb75079da38e0cd22a761fe208ecad9b +b70cf0a1d14089a4129ec4e295313863a59da8c7e26bf74cc0e704ed7f0ee4d7760090d0ddf7728180f1bf2c5ac64955 +882d664714cc0ffe53cbc9bef21f23f3649824f423c4dbad1f893d22c4687ab29583688699efc4d5101aa08b0c3e267a +80ecb7cc963e677ccaddbe3320831dd6ee41209acf4ed41b16dc4817121a3d86a1aac9c4db3d8c08a55d28257088af32 +a25ba667d832b145f9ce18c3f9b1bd00737aa36db020e1b99752c8ef7d27c6c448982bd8d352e1b6df266b8d8358a8d5 +83734841c13dee12759d40bdd209b277e743b0d08cc0dd1e0b7afd2d65bfa640400eefcf6be4a52e463e5b3d885eeac6 +848d16505b04804afc773aebabb51b36fd8aacfbb0e09b36c0d5d57df3c0a3b92f33e7d5ad0a7006ec46ebb91df42b8c +909a8d793f599e33bb9f1dc4792a507a97169c87cd5c087310bc05f30afcd247470b4b56dec59894c0fb1d48d39bb54e +8e558a8559df84a1ba8b244ece667f858095c50bb33a5381e60fcc6ba586b69693566d8819b4246a27287f16846c1dfa +84d6b69729f5aaa000cd710c2352087592cfbdf20d5e1166977e195818e593fa1a50d1e04566be23163a2523dc1612f1 +9536d262b7a42125d89f4f32b407d737ba8d9242acfc99d965913ab3e043dcac9f7072a43708553562cac4cba841df30 +9598548923ca119d6a15fd10861596601dd1dedbcccca97bb208cdc1153cf82991ea8cc17686fbaa867921065265970c +b87f2d4af6d026e4d2836bc3d390a4a18e98a6e386282ce96744603bab74974272e97ac2da281afa21885e2cbb3a8001 +991ece62bf07d1a348dd22191868372904b9f8cf065ae7aa4e44fd24a53faf6d851842e35fb472895963aa1992894918 +a8c53dea4c665b30e51d22ca6bc1bc78aaf172b0a48e64a1d4b93439b053877ec26cb5221c55efd64fa841bbf7d5aff4 +93487ec939ed8e740f15335b58617c3f917f72d07b7a369befd479ae2554d04deb240d4a14394b26192efae4d2f4f35d +a44793ab4035443f8f2968a40e043b4555960193ffa3358d22112093aadfe2c136587e4139ffd46d91ed4107f61ea5e0 +b13fe033da5f0d227c75927d3dacb06dbaf3e1322f9d5c7c009de75cdcba5e308232838785ab69a70f0bedea755e003f +970a29b075faccd0700fe60d1f726bdebf82d2cc8252f4a84543ebd3b16f91be42a75c9719a39c4096139f0f31393d58 +a4c3eb1f7160f8216fc176fb244df53008ff32f2892363d85254002e66e2de21ccfe1f3b1047589abee50f29b9d507e3 +8c552885eab04ba40922a8f0c3c38c96089c95ff1405258d3f1efe8d179e39e1295cbf67677894c607ae986e4e6b1fb0 +b3671746fa7f848c4e2ae6946894defadd815230b906b419143523cc0597bc1d6c0a4c1e09d49b66b4a2c11cde3a4de3 +937a249a95813a5e2ef428e355efd202e15a37d73e56cfb7e57ea9f943f2ce5ca8026f2f1fd25bf164ba89d07077d858 +83646bdf6053a04aa9e2f112499769e5bd5d0d10f2e13db3ca89bd45c0b3b7a2d752b7d137fb3909f9c62b78166c9339 +b4eac4b91e763666696811b7ed45e97fd78310377ebea1674b58a2250973f80492ac35110ed1240cd9bb2d17493d708c +82db43a99bc6573e9d92a3fd6635dbbb249ac66ba53099c3c0c8c8080b121dd8243cd5c6e36ba0a4d2525bae57f5c89c +a64d6a264a681b49d134c655d5fc7756127f1ee7c93d328820f32bca68869f53115c0d27fef35fe71f7bc4fdaed97348 +8739b7a9e2b4bc1831e7f04517771bc7cde683a5e74e052542517f8375a2f64e53e0d5ac925ef722327e7bb195b4d1d9 +8f337cdd29918a2493515ebb5cf702bbe8ecb23b53c6d18920cc22f519e276ca9b991d3313e2d38ae17ae8bdfa4f8b7e +b0edeab9850e193a61f138ef2739fc42ceec98f25e7e8403bfd5fa34a7bc956b9d0898250d18a69fa4625a9b3d6129da +a9920f26fe0a6d51044e623665d998745c9eca5bce12051198b88a77d728c8238f97d4196f26e43b24f8841500b998d0 +86e655d61502b979eeeeb6f9a7e1d0074f936451d0a1b0d2fa4fb3225b439a3770767b649256fe481361f481a8dbc276 +84d3b32fa62096831cc3bf013488a9f3f481dfe293ae209ed19585a03f7db8d961a7a9dd0db82bd7f62d612707575d9c +81c827826ec9346995ffccf62a241e3b2d32f7357acd1b1f8f7a7dbc97022d3eb51b8a1230e23ce0b401d2e535e8cd78 +94a1e40c151191c5b055b21e86f32e69cbc751dcbdf759a48580951834b96a1eed75914c0d19a38aefd21fb6c8d43d0c +ab890222b44bc21b71f7c75e15b6c6e16bb03371acce4f8d4353ff3b8fcd42a14026589c5ed19555a3e15e4d18bfc3a3 +accb0be851e93c6c8cc64724cdb86887eea284194b10e7a43c90528ed97e9ec71ca69c6fac13899530593756dd49eab2 +b630220aa9e1829c233331413ee28c5efe94ea8ea08d0c6bfd781955078b43a4f92915257187d8526873e6c919c6a1de +add389a4d358c585f1274b73f6c3c45b58ef8df11f9d11221f620e241bf3579fba07427b288c0c682885a700cc1fa28d +a9fe6ca8bf2961a3386e8b8dcecc29c0567b5c0b3bcf3b0f9169f88e372b80151af883871fc5229815f94f43a6f5b2b0 +ad839ae003b92b37ea431fa35998b46a0afc3f9c0dd54c3b3bf7a262467b13ff3c323ada1c1ae02ac7716528bdf39e3e +9356d3fd0edcbbb65713c0f2a214394f831b26f792124b08c5f26e7f734b8711a87b7c4623408da6a091c9aef1f6af3c +896b25b083c35ac67f0af3784a6a82435b0e27433d4d74cd6d1eafe11e6827827799490fb1c77c11de25f0d75f14e047 +8bfa019391c9627e8e5f05c213db625f0f1e51ec68816455f876c7e55b8f17a4f13e5aae9e3fb9e1cf920b1402ee2b40 +8ba3a6faa6a860a8f3ce1e884aa8769ceded86380a86520ab177ab83043d380a4f535fe13884346c5e51bee68da6ab41 +a8292d0844084e4e3bb7af92b1989f841a46640288c5b220fecfad063ee94e86e13d3d08038ec2ac82f41c96a3bfe14d +8229bb030b2fc566e11fd33c7eab7a1bb7b49fed872ea1f815004f7398cb03b85ea14e310ec19e1f23e0bdaf60f8f76c +8cfbf869ade3ec551562ff7f63c2745cc3a1f4d4dc853a0cd42dd5f6fe54228f86195ea8fe217643b32e9f513f34a545 +ac52a3c8d3270ddfe1b5630159da9290a5ccf9ccbdef43b58fc0a191a6c03b8a5974cf6e2bbc7bd98d4a40a3581482d7 +ab13decb9e2669e33a7049b8eca3ca327c40dea15ad6e0e7fa63ed506db1d258bc36ac88b35f65cae0984e937eb6575d +b5e748eb1a7a1e274ff0cc56311c198f2c076fe4b7e73e5f80396fe85358549df906584e6bb2c8195b3e2be7736850a5 +b5cb911325d8f963c41f691a60c37831c7d3bbd92736efa33d1f77a22b3fde7f283127256c2f47e197571e6fe0b46149 +8a01dc6ed1b55f26427a014faa347130738b191a06b800e32042a46c13f60b49534520214359d68eb2e170c31e2b8672 +a72fa874866e19b2efb8e069328362bf7921ec375e3bcd6b1619384c3f7ee980f6cf686f3544e9374ff54b4d17a1629c +8db21092f7c5f110fba63650b119e82f4b42a997095d65f08f8237b02dd66fdf959f788df2c35124db1dbd330a235671 +8c65d50433d9954fe28a09fa7ba91a70a590fe7ba6b3060f5e4be0f6cef860b9897fa935fb4ebc42133524eb071dd169 +b4614058e8fa21138fc5e4592623e78b8982ed72aa35ee4391b164f00c68d277fa9f9eba2eeefc890b4e86eba5124591 +ab2ad3a1bce2fbd55ca6b7c23786171fe1440a97d99d6df4d80d07dd56ac2d7203c294b32fc9e10a6c259381a73f24a1 +812ae3315fdc18774a8da3713a4679e8ed10b9405edc548c00cacbe25a587d32040566676f135e4723c5dc25df5a22e9 +a464b75f95d01e5655b54730334f443c8ff27c3cb79ec7af4b2f9da3c2039c609908cd128572e1fd0552eb597e8cef8d +a0db3172e93ca5138fe419e1c49a1925140999f6eff7c593e5681951ee0ec1c7e454c851782cbd2b8c9bc90d466e90e0 +806db23ba7d00b87d544eed926b3443f5f9c60da6b41b1c489fba8f73593b6e3b46ebfcab671ee009396cd77d5e68aa1 +8bfdf2c0044cc80260994e1c0374588b6653947b178e8b312be5c2a05e05767e98ea15077278506aee7df4fee1aaf89e +827f6558c16841b5592ff089c9c31e31eb03097623524394813a2e4093ad2d3f8f845504e2af92195aaa8a1679d8d692 +925c4f8eab2531135cd71a4ec88e7035b5eea34ba9d799c5898856080256b4a15ed1a746e002552e2a86c9c157e22e83 +a9f9a368f0e0b24d00a35b325964c85b69533013f9c2cfad9708be5fb87ff455210f8cb8d2ce3ba58ca3f27495552899 +8ac0d3bebc1cae534024187e7c71f8927ba8fcc6a1926cb61c2b6c8f26bb7831019e635a376146c29872a506784a4aaa +97c577be2cbbfdb37ad754fae9df2ada5fc5889869efc7e18a13f8e502fbf3f4067a509efbd46fd990ab47ce9a70f5a8 +935e7d82bca19f16614aa43b4a3474e4d20d064e4bfdf1cea2909e5c9ab72cfe3e54dc50030e41ee84f3588cebc524e9 +941aafc08f7c0d94cebfbb1f0aad5202c02e6e37f2c12614f57e727efa275f3926348f567107ee6d8914dd71e6060271 +af0fbc1ba05b4b5b63399686df3619968be5d40073de0313cbf5f913d3d4b518d4c249cdd2176468ccaa36040a484f58 +a0c414f23f46ca6d69ce74c6f8a00c036cb0edd098af0c1a7d39c802b52cfb2d5dbdf93fb0295453d4646e2af7954d45 +909cf39e11b3875bb63b39687ae1b5d1f5a15445e39bf164a0b14691b4ddb39a8e4363f584ef42213616abc4785b5d66 +a92bac085d1194fbd1c88299f07a061d0bdd3f980b663e81e6254dbb288bf11478c0ee880e28e01560f12c5ccb3c0103 +841705cd5cd76b943e2b7c5e845b9dd3c8defe8ef67e93078d6d5e67ade33ad4b0fd413bc196f93b0a4073c855cd97d4 +8e7eb8364f384a9161e81d3f1d52ceca9b65536ae49cc35b48c3e2236322ba4ae9973e0840802d9fa4f4d82ea833544f +aed3ab927548bc8bec31467ba80689c71a168e34f50dcb6892f19a33a099f5aa6b3f9cb79f5c0699e837b9a8c7f27efe +b8fbf7696210a36e20edabd77839f4dfdf50d6d015cdf81d587f90284a9bcef7d2a1ff520728d7cc69a4843d6c20dedd +a9d533769ce6830211c884ae50a82a7bf259b44ac71f9fb11f0296fdb3981e6b4c1753fe744647b247ebc433a5a61436 +8b4bdf90d33360b7f428c71cde0a49fb733badba8c726876945f58c620ce7768ae0e98fc8c31fa59d8955a4823336bb1 +808d42238e440e6571c59e52a35ae32547d502dc24fd1759d8ea70a7231a95859baf30b490a4ba55fa2f3aaa11204597 +85594701f1d2fee6dc1956bc44c7b31db93bdeec2f3a7d622c1a08b26994760773e3d57521a44cfd7e407ac3fd430429 +a66de045ce7173043a6825e9dc440ac957e2efb6df0a337f4f8003eb0c719d873a52e6eba3cb0d69d977ca37d9187674 +87a1c6a1fdff993fa51efa5c3ba034c079c0928a7d599b906336af7c2dcab9721ceaf3108c646490af9dff9a754f54b3 +926424223e462ceb75aed7c22ade8a7911a903b7e5dd4bc49746ddce8657f4616325cd12667d4393ac52cdd866396d0e +b5dc96106593b42b30f06f0b0a1e0c1aafc70432e31807252d3674f0b1ea5e58eac8424879d655c9488d85a879a3e572 +997ca0987735cc716507cb0124b1d266d218b40c9d8e0ecbf26a1d65719c82a637ce7e8be4b4815d307df717bde7c72a +92994d3f57a569b7760324bb5ae4e8e14e1633d175dab06aa57b8e391540e05f662fdc08b8830f489a063f59b689a688 +a8087fcc6aa4642cb998bea11facfe87eb33b90a9aa428ab86a4124ad032fc7d2e57795311a54ec9f55cc120ebe42df1 +a9bd7d1de6c0706052ca0b362e2e70e8c8f70f1f026ea189b4f87a08ce810297ebfe781cc8004430776c54c1a05ae90c +856d33282e8a8e33a3d237fb0a0cbabaf77ba9edf2fa35a831fdafcadf620561846aa6cbb6bdc5e681118e1245834165 +9524a7aa8e97a31a6958439c5f3339b19370f03e86b89b1d02d87e4887309dbbe9a3a8d2befd3b7ed5143c8da7e0a8ad +824fdf433e090f8acbd258ac7429b21f36f9f3b337c6d0b71d1416a5c88a767883e255b2888b7c906dd2e9560c4af24c +88c7fee662ca7844f42ed5527996b35723abffd0d22d4ca203b9452c639a5066031207a5ae763dbc0865b3299d19b1ec +919dca5c5595082c221d5ab3a5bc230f45da7f6dec4eb389371e142c1b9c6a2c919074842479c2844b72c0d806170c0c +b939be8175715e55a684578d8be3ceff3087f60fa875fff48e52a6e6e9979c955efef8ff67cfa2b79499ea23778e33b0 +873b6db725e7397d11bc9bed9ac4468e36619135be686790a79bc6ed4249058f1387c9a802ea86499f692cf635851066 +aeae06db3ec47e9e5647323fa02fac44e06e59b885ad8506bf71b184ab3895510c82f78b6b22a5d978e8218e7f761e9f +b99c0a8359c72ab88448bae45d4bf98797a26bca48b0d4460cd6cf65a4e8c3dd823970ac3eb774ae5d0cea4e7fadf33e +8f10c8ec41cdfb986a1647463076a533e6b0eec08520c1562401b36bb063ac972aa6b28a0b6ce717254e35940b900e3c +a106d9be199636d7add43b942290269351578500d8245d4aae4c083954e4f27f64740a3138a66230391f2d0e6043a8de +a469997908244578e8909ff57cffc070f1dbd86f0098df3cfeb46b7a085cfecc93dc69ee7cad90ff1dc5a34d50fe580c +a4ef087bea9c20eb0afc0ee4caba7a9d29dfa872137828c721391273e402fb6714afc80c40e98bbd8276d3836bffa080 +b07a013f73cd5b98dae0d0f9c1c0f35bff8a9f019975c4e1499e9bee736ca6fcd504f9bc32df1655ff333062382cff04 +b0a77188673e87cc83348c4cc5db1eecf6b5184e236220c8eeed7585e4b928db849944a76ec60ef7708ef6dac02d5592 +b1284b37e59b529f0084c0dacf0af6c0b91fc0f387bf649a8c74819debf606f7b07fc3e572500016fb145ec2b24e9f17 +97b20b5b4d6b9129da185adfbf0d3d0b0faeba5b9715f10299e48ea0521709a8296a9264ce77c275a59c012b50b6519a +b9d37e946fae5e4d65c1fbfacc8a62e445a1c9d0f882e60cca649125af303b3b23af53c81d7bac544fb7fcfc7a314665 +8e5acaac379f4bb0127efbef26180f91ff60e4c525bc9b798fc50dfaf4fe8a5aa84f18f3d3cfb8baead7d1e0499af753 +b0c0b8ab1235bf1cda43d4152e71efc1a06c548edb964eb4afceb201c8af24240bf8ab5cae30a08604e77432b0a5faf0 +8cc28d75d5c8d062d649cbc218e31c4d327e067e6dbd737ec0a35c91db44fbbd0d40ec424f5ed79814add16947417572 +95ae6219e9fd47efaa9cb088753df06bc101405ba50a179d7c9f7c85679e182d3033f35b00dbba71fdcd186cd775c52e +b5d28fa09f186ebc5aa37453c9b4d9474a7997b8ae92748ecb940c14868792292ac7d10ade01e2f8069242b308cf97e5 +8c922a0faa14cc6b7221f302df3342f38fc8521ec6c653f2587890192732c6da289777a6cd310747ea7b7d104af95995 +b9ad5f660b65230de54de535d4c0fcae5bc6b59db21dea5500fdc12eea4470fb8ea003690fdd16d052523418d5e01e8c +a39a9dd41a0ff78c82979483731f1cd68d3921c3e9965869662c22e02dde3877802e180ba93f06e7346f96d9fa9261d2 +8b32875977ec372c583b24234c27ed73aef00cdff61eb3c3776e073afbdeade548de9497c32ec6d703ff8ad0a5cb7fe4 +9644cbe755a5642fe9d26cfecf170d3164f1848c2c2e271d5b6574a01755f3980b3fc870b98cf8528fef6ecef4210c16 +81ea9d1fdd9dd66d60f40ce0712764b99da9448ae0b300f8324e1c52f154e472a086dda840cb2e0b9813dc8ce8afd4b5 +906aaa4a7a7cdf01909c5cfbc7ded2abc4b869213cbf7c922d4171a4f2e637e56f17020b852ad339d83b8ac92f111666 +939b5f11acbdeff998f2a080393033c9b9d8d5c70912ea651c53815c572d36ee822a98d6dfffb2e339f29201264f2cf4 +aba4898bf1ccea9b9e2df1ff19001e05891581659c1cbbde7ee76c349c7fc7857261d9785823c9463a8aea3f40e86b38 +83ca1a56b8a0be4820bdb5a9346357c68f9772e43f0b887729a50d2eb2a326bbcede676c8bf2e51d7c89bbd8fdb778a6 +94e86e9fe6addfe2c3ee3a547267ed921f4230d877a85bb4442c2d9350c2fa9a9c54e6fe662de82d1a2407e4ab1691c2 +a0cc3bdef671a59d77c6984338b023fa2b431b32e9ed2abe80484d73edc6540979d6f10812ecc06d4d0c5d4eaca7183c +b5343413c1b5776b55ea3c7cdd1f3af1f6bd802ea95effe3f2b91a523817719d2ecc3f8d5f3cc2623ace7e35f99ca967 +92085d1ed0ed28d8cabe3e7ff1905ed52c7ceb1eac5503760c52fb5ee3a726aba7c90b483c032acc3f166b083d7ec370 +8ec679520455275cd957fca8122724d287db5df7d29f1702a322879b127bff215e5b71d9c191901465d19c86c8d8d404 +b65eb2c63d8a30332eb24ee8a0c70156fc89325ebbb38bacac7cf3f8636ad8a472d81ccca80423772abc00192d886d8a +a9fe1c060b974bee4d590f2873b28635b61bfcf614e61ff88b1be3eee4320f4874e21e8d666d8ac8c9aba672efc6ecae +b3fe2a9a389c006a831dea7e777062df84b5c2803f9574d7fbe10b7e1c125817986af8b6454d6be9d931a5ac94cfe963 +95418ad13b734b6f0d33822d9912c4c49b558f68d08c1b34a0127fcfa666bcae8e6fda8832d2c75bb9170794a20e4d7c +a9a7df761e7f18b79494bf429572140c8c6e9d456c4d4e336184f3f51525a65eb9582bea1e601bdb6ef8150b7ca736a5 +a0de03b1e75edf7998c8c1ac69b4a1544a6fa675a1941950297917366682e5644a4bda9cdeedfaf9473d7fccd9080b0c +a61838af8d95c95edf32663a68f007d95167bf6e41b0c784a30b22d8300cfdd5703bd6d16e86396638f6db6ae7e42a85 +8866d62084d905c145ff2d41025299d8b702ac1814a7dec4e277412c161bc9a62fed735536789cb43c88693c6b423882 +91da22c378c81497fe363e7f695c0268443abee50f8a6625b8a41e865638a643f07b157ee566de09ba09846934b4e2d7 +941d21dd57c9496aa68f0c0c05507405fdd413acb59bc668ce7e92e1936c68ec4b065c3c30123319884149e88228f0b2 +a77af9b094bc26966ddf2bf9e1520c898194a5ccb694915950dadc204facbe3066d3d89f50972642d76b14884cfbaa21 +8e76162932346869f4618bde744647f7ab52ab498ad654bdf2a4feeb986ac6e51370841e5acbb589e38b6e7142bb3049 +b60979ace17d6937ece72e4f015da4657a443dd01cebc7143ef11c09e42d4aa8855999a65a79e2ea0067f31c9fc2ab0f +b3e2ffdd5ee6fd110b982fd4fad4b93d0fca65478f986d086eeccb0804960bfaa1919afa743c2239973ea65091fe57d2 +8ce0ce05e7d7160d44574011da687454dbd3c8b8290aa671731b066e2c82f8cf2d63cb8e932d78c6122ec610e44660e6 +ab005dd8d297045c39e2f72fb1c48edb501ccf3575d3d04b9817b3afee3f0bb0f3f53f64bda37d1d9cde545aae999bae +95bd7edb4c4cd60e3cb8a72558845a3cce6bb7032ccdf33d5a49ebb6ddf203bc3c79e7b7e550735d2d75b04c8b2441e8 +889953ee256206284094e4735dbbb17975bafc7c3cb94c9fbfee4c3e653857bfd49e818f64a47567f721b98411a3b454 +b188423e707640ab0e75a061e0b62830cde8afab8e1ad3dae30db69ffae4e2fc005bababbdcbd7213b918ed4f70e0c14 +a97e0fafe011abd70d4f99a0b36638b3d6e7354284588f17a88970ed48f348f88392779e9a038c6cbc9208d998485072 +87db11014a91cb9b63e8dfaa82cdebca98272d89eb445ee1e3ff9dbaf2b3fad1a03b888cffc128e4fe208ed0dddece0f +aad2e40364edd905d66ea4ac9d51f9640d6fda9a54957d26ba233809851529b32c85660fa401dbee3679ec54fa6dd966 +863e99336ca6edf03a5a259e59a2d0f308206e8a2fb320cfc0be06057366df8e0f94b33a28f574092736b3c5ada84270 +b34bcc56a057589f34939a1adc51de4ff6a9f4fee9c7fa9aa131e28d0cf0759a0c871b640162acdfbf91f3f1b59a3703 +935dd28f2896092995c5eff1618e5b6efe7a40178888d7826da9b0503c2d6e68a28e7fac1a334e166d0205f0695ef614 +b842cd5f8f5de5ca6c68cb4a5c1d7b451984930eb4cc18fd0934d52fdc9c3d2d451b1c395594d73bc3451432bfba653f +9014537885ce2debad736bc1926b25fdab9f69b216bf024f589c49dc7e6478c71d595c3647c9f65ff980b14f4bb2283b +8e827ccca1dd4cd21707140d10703177d722be0bbe5cac578db26f1ef8ad2909103af3c601a53795435b27bf95d0c9ed +8a0b8ad4d466c09d4f1e9167410dbe2edc6e0e6229d4b3036d30f85eb6a333a18b1c968f6ca6d6889bb08fecde017ef4 +9241ee66c0191b06266332dc9161dede384c4bb4e116dbd0890f3c3790ec5566da4568243665c4725b718ac0f6b5c179 +aeb4d5fad81d2b505d47958a08262b6f1b1de9373c2c9ba6362594194dea3e002ab03b8cbb43f867be83065d3d370f19 +8781bc83bb73f7760628629fe19e4714b494dbed444c4e4e4729b7f6a8d12ee347841a199888794c2234f51fa26fc2b9 +b58864f0acd1c2afa29367e637cbde1968d18589245d9936c9a489c6c495f54f0113ecdcbe4680ac085dd3c397c4d0c3 +94a24284afaeead61e70f3e30f87248d76e9726759445ca18cdb9360586c60cc9f0ec1c397f9675083e0b56459784e2e +aed358853f2b54dcbddf865e1816c2e89be12e940e1abfa661e2ee63ffc24a8c8096be2072fa83556482c0d89e975124 +b95374e6b4fc0765708e370bc881e271abf2e35c08b056a03b847e089831ef4fe3124b9c5849d9c276eb2e35b3daf264 +b834cdbcfb24c8f84bfa4c552e7fadc0028a140952fd69ed13a516e1314a4cd35d4b954a77d51a1b93e1f5d657d0315d +8fb6d09d23bfa90e7443753d45a918d91d75d8e12ec7d016c0dfe94e5c592ba6aaf483d2f16108d190822d955ad9cdc3 +aa315cd3c60247a6ad4b04f26c5404c2713b95972843e4b87b5a36a89f201667d70f0adf20757ebe1de1b29ae27dda50 +a116862dca409db8beff5b1ccd6301cdd0c92ca29a3d6d20eb8b87f25965f42699ca66974dd1a355200157476b998f3b +b4c2f5fe173c4dc8311b60d04a65ce1be87f070ac42e13cd19c6559a2931c6ee104859cc2520edebbc66a13dc7d30693 +8d4a02bf99b2260c334e7d81775c5cf582b00b0c982ce7745e5a90624919028278f5e9b098573bad5515ce7fa92a80c8 +8543493bf564ce6d97bd23be9bff1aba08bd5821ca834f311a26c9139c92a48f0c2d9dfe645afa95fec07d675d1fd53b +9344239d13fde08f98cb48f1f87d34cf6abe8faecd0b682955382a975e6eed64e863fa19043290c0736261622e00045c +aa49d0518f343005ca72b9e6c7dcaa97225ce6bb8b908ebbe7b1a22884ff8bfb090890364e325a0d414ad180b8f161d1 +907d7fd3e009355ab326847c4a2431f688627faa698c13c03ffdd476ecf988678407f029b8543a475dcb3dafdf2e7a9c +845f1f10c6c5dad2adc7935f5cd2e2b32f169a99091d4f1b05babe7317b9b1cdce29b5e62f947dc621b9acbfe517a258 +8f3be8e3b380ea6cdf9e9c237f5e88fd5a357e5ded80ea1fc2019810814de82501273b4da38916881125b6fa0cfd4459 +b9c7f487c089bf1d20c822e579628db91ed9c82d6ca652983aa16d98b4270c4da19757f216a71b9c13ddee3e6e43705f +8ba2d8c88ad2b872db104ea8ddbb006ec2f3749fd0e19298a804bb3a5d94de19285cc7fb19fee58a66f7851d1a66c39f +9375ecd3ed16786fe161af5d5c908f56eeb467a144d3bbddfc767e90065b7c94fc53431adebecba2b6c9b5821184d36e +a49e069bfadb1e2e8bff6a4286872e2a9765d62f0eaa4fcb0e5af4bbbed8be3510fb19849125a40a8a81d1e33e81c3eb +9522cc66757b386aa6b88619525c8ce47a5c346d590bb3647d12f991e6c65c3ab3c0cfc28f0726b6756c892eae1672be +a9a0f1f51ff877406fa83a807aeb17b92a283879f447b8a2159653db577848cc451cbadd01f70441e351e9ed433c18bc +8ff7533dcff6be8714df573e33f82cf8e9f2bcaaa43e939c4759d52b754e502717950de4b4252fb904560fc31dce94a4 +959724671e265a28d67c29d95210e97b894b360da55e4cf16e6682e7912491ed8ca14bfaa4dce9c25a25b16af580494f +92566730c3002f4046c737032487d0833c971e775de59fe02d9835c9858e2e3bc37f157424a69764596c625c482a2219 +a84b47ceff13ed9c3e5e9cdf6739a66d3e7c2bd8a6ba318fefb1a9aecf653bb2981da6733ddb33c4b0a4523acc429d23 +b4ddf571317e44f859386d6140828a42cf94994e2f1dcbcc9777f4eebbfc64fc1e160b49379acc27c4672b8e41835c5d +8ab95c94072b853d1603fdd0a43b30db617d13c1d1255b99075198e1947bfa5f59aed2b1147548a1b5e986cd9173d15c +89511f2eab33894fd4b3753d24249f410ff7263052c1fef6166fc63a79816656b0d24c529e45ccce6be28de6e375d916 +a0866160ca63d4f2be1b4ea050dac6b59db554e2ebb4e5b592859d8df339b46fd7cb89aaed0951c3ee540aee982c238a +8fcc5cbba1b94970f5ff2eb1922322f5b0aa7d918d4b380c9e7abfd57afd8b247c346bff7b87af82efbce3052511cd1b +99aeb2a5e846b0a2874cca02c66ed40d5569eb65ab2495bc3f964a092e91e1517941f2688e79f8cca49cd3674c4e06dc +b7a096dc3bad5ca49bee94efd884aa3ff5615cf3825cf95fbe0ce132e35f46581d6482fa82666c7ef5f1643eaee8f1ca +94393b1da6eaac2ffd186b7725eca582f1ddc8cdd916004657f8a564a7c588175cb443fc6943b39029f5bbe0add3fad8 +884b85fe012ccbcd849cb68c3ad832d83b3ef1c40c3954ffdc97f103b1ed582c801e1a41d9950f6bddc1d11f19d5ec76 +b00061c00131eded8305a7ce76362163deb33596569afb46fe499a7c9d7a0734c084d336b38d168024c2bb42b58e7660 +a439153ac8e6ca037381e3240e7ba08d056c83d7090f16ed538df25901835e09e27de2073646e7d7f3c65056af6e4ce7 +830fc9ca099097d1f38b90e6843dc86f702be9d20bdacc3e52cae659dc41df5b8d2c970effa6f83a5229b0244a86fe22 +b81ea2ffaaff2bb00dd59a9ab825ba5eed4db0d8ac9c8ed1a632ce8f086328a1cddd045fbe1ace289083c1325881b7e7 +b51ea03c58daf2db32c99b9c4789b183365168cb5019c72c4cc91ac30b5fb7311d3db76e6fa41b7cd4a8c81e2f6cdc94 +a4170b2c6d09ca5beb08318730419b6f19215ce6c631c854116f904be3bc30dd85a80c946a8ab054d3e307afaa3f8fbc +897cc42ff28971ff54d2a55dd6b35cfb8610ac902f3c06e3a5cea0e0a257e870c471236a8e84709211c742a09c5601a6 +a18f2e98d389dace36641621488664ecbb422088ab03b74e67009b8b8acacaaa24fdcf42093935f355207d934adc52a8 +92adcfb678cc2ba19c866f3f2b988fdcb4610567f3ab436cc0cb9acaf5a88414848d71133ebdbec1983e38e6190f1b5f +a86d43c2ce01b366330d3b36b3ca85f000c3548b8297e48478da1ee7d70d8576d4650cba7852ed125c0d7cb6109aa7f3 +8ed31ceed9445437d7732dce78a762d72ff32a7636bfb3fd7974b7ae15db414d8184a1766915244355deb354fbc5803b +9268f70032584f416e92225d65af9ea18c466ebc7ae30952d56a4e36fd9ea811dde0a126da9220ba3c596ec54d8a335e +9433b99ee94f2d3fbdd63b163a2bdf440379334c52308bd24537f7defd807145a062ff255a50d119a7f29f4b85d250e3 +90ce664f5e4628a02278f5cf5060d1a34f123854634b1870906e5723ac9afd044d48289be283b267d45fcbf3f4656aaf +aaf21c4d59378bb835d42ae5c5e5ab7a3c8c36a59e75997989313197752b79a472d866a23683b329ea69b048b87fa13e +b83c0589b304cec9ede549fde54f8a7c2a468c6657da8c02169a6351605261202610b2055c639b9ed2d5b8c401fb8f56 +9370f326ea0f170c2c05fe2c5a49189f20aec93b6b18a5572a818cd4c2a6adb359e68975557b349fb54f065d572f4c92 +ac3232fa5ce6f03fca238bef1ce902432a90b8afce1c85457a6bee5571c033d4bceefafc863af04d4e85ac72a4d94d51 +80d9ea168ff821b22c30e93e4c7960ce3ad3c1e6deeebedd342a36d01bd942419b187e2f382dbfd8caa34cca08d06a48 +a387a3c61676fb3381eefa2a45d82625635a666e999aba30e3b037ec9e040f414f9e1ad9652abd3bcad63f95d85038db +a1b229fe32121e0b391b0f6e0180670b9dc89d79f7337de4c77ea7ad0073e9593846f06797c20e923092a08263204416 +92164a9d841a2b828cedf2511213268b698520f8d1285852186644e9a0c97512cafa4bfbe29af892c929ebccd102e998 +82ee2fa56308a67c7db4fd7ef539b5a9f26a1c2cc36da8c3206ba4b08258fbb3cec6fe5cdbd111433fb1ba2a1e275927 +8c77bfe9e191f190a49d46f05600603fa42345592539b82923388d72392404e0b29a493a15e75e8b068dddcd444c2928 +80b927f93ccf79dcf5c5b20bcf5a7d91d7a17bc0401bb7cc9b53a6797feac31026eb114257621f5a64a52876e4474cc1 +b6b68b6501c37804d4833d5a063dd108a46310b1400549074e3cac84acc6d88f73948b7ad48d686de89c1ec043ae8c1a +ab3da00f9bdc13e3f77624f58a3a18fc3728956f84b5b549d62f1033ae4b300538e53896e2d943f160618e05af265117 +b6830e87233b8eace65327fdc764159645b75d2fd4024bf8f313b2dd5f45617d7ecfb4a0b53ccafb5429815a9a1adde6 +b9251cfe32a6dc0440615aadcd98b6b1b46e3f4e44324e8f5142912b597ee3526bea2431e2b0282bb58f71be5b63f65e +af8d70711e81cdddfb39e67a1b76643292652584c1ce7ce4feb1641431ad596e75c9120e85f1a341e7a4da920a9cdd94 +98cd4e996594e89495c078bfd52a4586b932c50a449a7c8dfdd16043ca4cda94dafbaa8ad1b44249c99bbcc52152506e +b9fc6d1c24f48404a4a64fbe3e43342738797905db46e4132aee5f086aaa4c704918ad508aaefa455cfe1b36572e6242 +a365e871d30ba9291cedaba1be7b04e968905d003e9e1af7e3b55c5eb048818ae5b913514fb08b24fb4fbdccbb35d0b8 +93bf99510971ea9af9f1e364f1234c898380677c8e8de9b0dd24432760164e46c787bc9ec42a7ad450500706cf247b2d +b872f825a5b6e7b9c7a9ddfeded3516f0b1449acc9b4fd29fc6eba162051c17416a31e5be6d3563f424d28e65bab8b8f +b06b780e5a5e8eb4f4c9dc040f749cf9709c8a4c9ef15e925f442b696e41e5095db0778a6c73bcd329b265f2c6955c8b +848f1a981f5fc6cd9180cdddb8d032ad32cdfa614fc750d690dbae36cc0cd355cbf1574af9b3ffc8b878f1b2fafb9544 +a03f48cbff3e9e8a3a655578051a5ae37567433093ac500ed0021c6250a51b767afac9bdb194ee1e3eac38a08c0eaf45 +b5be78ce638ff8c4aa84352b536628231d3f7558c5be3bf010b28feac3022e64691fa672f358c8b663904aebe24a54ed +a9d4da70ff676fa55d1728ba6ab03b471fa38b08854d99e985d88c2d050102d8ccffbe1c90249a5607fa7520b15fe791 +8fe9f7092ffb0b69862c8e972fb1ecf54308c96d41354ed0569638bb0364f1749838d6d32051fff1599112978c6e229c +ae6083e95f37770ecae0df1e010456f165d96cfe9a7278c85c15cffd61034081ce5723e25e2bede719dc9341ec8ed481 +a260891891103089a7afbd9081ea116cfd596fd1015f5b65e10b0961eb37fab7d09c69b7ce4be8bf35e4131848fb3fe4 +8d729fa32f6eb9fd2f6a140bef34e8299a2f3111bffd0fe463aa8622c9d98bfd31a1df3f3e87cd5abc52a595f96b970e +a30ec6047ae4bc7da4daa7f4c28c93aedb1112cfe240e681d07e1a183782c9ff6783ac077c155af23c69643b712a533f +ac830726544bfe7b5467339e5114c1a75f2a2a8d89453ce86115e6a789387e23551cd64620ead6283dfa4538eb313d86 +8445c135b7a48068d8ed3e011c6d818cfe462b445095e2fbf940301e50ded23f272d799eea47683fc027430ce14613ef +95785411715c9ae9d8293ce16a693a2aa83e3cb1b4aa9f76333d0da2bf00c55f65e21e42e50e6c5772ce213dd7b4f7a0 +b273b024fa18b7568c0d1c4d2f0c4e79ec509dafac8c5951f14192d63ddbcf2d8a7512c1c1b615cc38fa3e336618e0c5 +a78b9d3ea4b6a90572eb27956f411f1d105fdb577ee2ffeec9f221da9b45db84bfe866af1f29597220c75e0c37a628d8 +a4be2bf058c36699c41513c4d667681ce161a437c09d81383244fc55e1c44e8b1363439d0cce90a3e44581fb31d49493 +b6eef13040f17dd4eba22aaf284d2f988a4a0c4605db44b8d2f4bf9567ac794550b543cc513c5f3e2820242dd704152e +87eb00489071fa95d008c5244b88e317a3454652dcb1c441213aa16b28cd3ecaa9b22fec0bdd483c1df71c37119100b1 +92d388acdcb49793afca329cd06e645544d2269234e8b0b27d2818c809c21726bc9cf725651b951e358a63c83dedee24 +ae27e219277a73030da27ab5603c72c8bd81b6224b7e488d7193806a41343dff2456132274991a4722fdb0ef265d04cd +97583e08ecb82bbc27c0c8476d710389fa9ffbead5c43001bd36c1b018f29faa98de778644883e51870b69c5ffb558b5 +90a799a8ce73387599babf6b7da12767c0591cadd36c20a7990e7c05ea1aa2b9645654ec65308ee008816623a2757a6a +a1b47841a0a2b06efd9ab8c111309cc5fc9e1d5896b3e42ed531f6057e5ade8977c29831ce08dbda40348386b1dcc06d +b92b8ef59bbddb50c9457691bc023d63dfcc54e0fd88bd5d27a09e0d98ac290fc90e6a8f6b88492043bf7c87fac8f3e4 +a9d6240b07d62e22ec8ab9b1f6007c975a77b7320f02504fc7c468b4ee9cfcfd945456ff0128bc0ef2174d9e09333f8d +8e96534c94693226dc32bca79a595ca6de503af635f802e86442c67e77564829756961d9b701187fe91318da515bf0e6 +b6ba290623cd8dd5c2f50931c0045d1cfb0c30877bc8fe58cbc3ff61ee8da100045a39153916efa1936f4aee0892b473 +b43baa7717fac02d4294f5b3bb5e58a65b3557747e3188b482410388daac7a9c177f762d943fd5dcf871273921213da8 +b9cf00f8fb5e2ef2b836659fece15e735060b2ea39b8e901d3dcbdcf612be8bf82d013833718c04cd46ffaa70b85f42e +8017d0c57419e414cbba504368723e751ef990cc6f05dad7b3c2de6360adc774ad95512875ab8337d110bf39a42026fa +ae7401048b838c0dcd4b26bb6c56d79d51964a0daba780970b6c97daee4ea45854ea0ac0e4139b3fe60dac189f84df65 +887b237b0cd0f816b749b21db0b40072f9145f7896c36916296973f9e6990ede110f14e5976c906d08987c9836cca57f +a88c3d5770148aee59930561ca1223aceb2c832fb5417e188dca935905301fc4c6c2c9270bc1dff7add490a125eb81c6 +b6cf9b02c0cd91895ad209e38c54039523f137b5848b9d3ad33ae43af6c20c98434952db375fe378de7866f2d0e8b18a +84ef3d322ff580c8ad584b1fe4fe346c60866eb6a56e982ba2cf3b021ecb1fdb75ecc6c29747adda86d9264430b3f816 +a0561c27224baf0927ad144cb71e31e54a064c598373fcf0d66aebf98ab7af1d8e2f343f77baefff69a6da750a219e11 +aa5cc43f5b8162b016f5e1b61214c0c9d15b1078911c650b75e6cdfb49b85ee04c6739f5b1687d15908444f691f732de +ad4ac099b935589c7b8fdfdf3db332b7b82bb948e13a5beb121ebd7db81a87d278024a1434bcf0115c54ca5109585c3d +8a00466abf3f109a1dcd19e643b603d3af23d42794ef8ca2514dd507ecea44a031ac6dbc18bd02f99701168b25c1791e +b00b5900dfad79645f8bee4e5adc7b84eb22e5b1e67df77ccb505b7fc044a6c08a8ea5faca662414eb945f874f884cea +950e204e5f17112250b22ea6bb8423baf522fc0af494366f18fe0f949f51d6e6812074a80875cf1ed9c8e7420058d541 +91e5cbf8bb1a1d50c81608c9727b414d0dd2fb467ebc92f100882a3772e54f94979cfdf8e373fdef7c7fcdd60fec9e00 +a093f6a857b8caaff80599c2e89c962b415ecbaa70d8fd973155fa976a284c6b29a855f5f7a3521134d00d2972755188 +b4d55a3551b00da54cc010f80d99ddd2544bde9219a3173dfaadf3848edc7e4056ab532fb75ac26f5f7141e724267663 +a03ea050fc9b011d1b04041b5765d6f6453a93a1819cd9bd6328637d0b428f08526466912895dcc2e3008ee58822e9a7 +99b12b3665e473d01bc6985844f8994fb65cb15745024fb7af518398c4a37ff215da8f054e8fdf3286984ae36a73ca5e +9972c7e7a7fb12e15f78d55abcaf322c11249cd44a08f62c95288f34f66b51f146302bce750ff4d591707075d9123bd2 +a64b4a6d72354e596d87cda213c4fc2814009461570ccb27d455bbe131f8d948421a71925425b546d8cf63d5458cd64b +91c215c73b195795ede2228b7ed1f6e37892e0c6b0f4a0b5a16c57aa1100c84df9239054a173b6110d6c2b7f4bf1ce52 +88807198910ec1303480f76a3683870246a995e36adaeadc29c22f0bdba8152fe705bd070b75de657b04934f7d0ccf80 +b37c0026c7b32eb02cacac5b55cb5fe784b8e48b2945c64d3037af83ece556a117f0ff053a5968c2f5fa230e291c1238 +94c768384ce212bc2387e91ce8b45e4ff120987e42472888a317abc9dcdf3563b62e7a61c8e98d7cdcbe272167d91fc6 +a10c2564936e967a390cb14ef6e8f8b04ea9ece5214a38837eda09e79e0c7970b1f83adf017c10efd6faa8b7ffa2c567 +a5085eed3a95f9d4b1269182ea1e0d719b7809bf5009096557a0674bde4201b0ddc1f0f16a908fc468846b3721748ce3 +87468eb620b79a0a455a259a6b4dfbc297d0d53336537b771254dd956b145dc816b195b7002647ea218552e345818a3f +ace2b77ffb87366af0a9cb5d27d6fc4a14323dbbf1643f5f3c4559306330d86461bb008894054394cbfaefeaa0bc2745 +b27f56e840a54fbd793f0b7a7631aa4cee64b5947e4382b2dfb5eb1790270288884c2a19afebe5dc0c6ef335d4531c1c +876e438633931f7f895062ee16c4b9d10428875f7bc79a8e156a64d379a77a2c45bf5430c5ab94330f03da352f1e9006 +a2512a252587d200d2092b44c914df54e04ff8bcef36bf631f84bde0cf5a732e3dc7f00f662842cfd74b0b0f7f24180e +827f1bc8f54a35b7a4bd8154f79bcc055e45faed2e74adf7cf21cca95df44d96899e847bd70ead6bb27b9c0ed97bbd8b +a0c92cf5a9ed843714f3aea9fe7b880f622d0b4a3bf66de291d1b745279accf6ba35097849691370f41732ba64b5966b +a63f5c1e222775658421c487b1256b52626c6f79cb55a9b7deb2352622cedffb08502042d622eb3b02c97f9c09f9c957 +8cc093d52651e65fb390e186db6cc4de559176af4624d1c44cb9b0e836832419dacac7b8db0627b96288977b738d785d +aa7b6a17dfcec146134562d32a12f7bd7fe9522e300859202a02939e69dbd345ed7ff164a184296268f9984f9312e8fc +8ac76721f0d2b679f023d06cbd28c85ae5f4b43c614867ccee88651d4101d4fd352dbdb65bf36bfc3ebc0109e4b0c6f9 +8d350f7c05fc0dcd9a1170748846fb1f5d39453e4cb31e6d1457bed287d96fc393b2ecc53793ca729906a33e59c6834a +b9913510dfc5056d7ec5309f0b631d1ec53e3a776412ada9aefdaf033c90da9a49fdde6719e7c76340e86599b1f0eec2 +94955626bf4ce87612c5cfffcf73bf1c46a4c11a736602b9ba066328dc52ad6d51e6d4f53453d4ed55a51e0aad810271 +b0fcab384fd4016b2f1e53f1aafd160ae3b1a8865cd6c155d7073ecc1664e05b1d8bca1def39c158c7086c4e1103345e +827de3f03edfbde08570b72de6662c8bfa499b066a0a27ebad9b481c273097d17a5a0a67f01553da5392ec3f149b2a78 +ab7940384c25e9027c55c40df20bd2a0d479a165ced9b1046958353cd69015eeb1e44ed2fd64e407805ba42df10fc7bf +8ad456f6ff8cd58bd57567d931f923d0c99141978511b17e03cab7390a72b9f62498b2893e1b05c7c22dd274e9a31919 +ac75399e999effe564672db426faa17a839e57c5ef735985c70cd559a377adec23928382767b55ed5a52f7b11b54b756 +b17f975a00b817299ac7af5f2024ea820351805df58b43724393bfb3920a8cd747a3bbd4b8286e795521489db3657168 +a2bed800a6d95501674d9ee866e7314063407231491d794f8cf57d5be020452729c1c7cefd8c50dc1540181f5caab248 +9743f5473171271ffdd3cc59a3ae50545901a7b45cd4bc3570db487865f3b73c0595bebabbfe79268809ee1862e86e4a +b7eab77c2d4687b60d9d7b04e842b3880c7940140012583898d39fcc22d9b9b0a9be2c2e3788b3e6f30319b39c338f09 +8e2b8f797a436a1b661140e9569dcf3e1eea0a77c7ff2bc4ff0f3e49af04ed2de95e255df8765f1d0927fb456a9926b1 +8aefea201d4a1f4ff98ffce94e540bb313f2d4dfe7e9db484a41f13fc316ed02b282e1acc9bc6f56cad2dc2e393a44c9 +b950c17c0e5ca6607d182144aa7556bb0efe24c68f06d79d6413a973b493bfdf04fd147a4f1ab03033a32004cc3ea66f +b7b8dcbb179a07165f2dc6aa829fad09f582a71b05c3e3ea0396bf9e6fe73076f47035c031c2101e8e38e0d597eadd30 +a9d77ed89c77ec1bf8335d08d41c3c94dcca9fd1c54f22837b4e54506b212aa38d7440126c80648ab7723ff18e65ed72 +a819d6dfd4aef70e52b8402fe5d135f8082d40eb7d3bb5c4d7997395b621e2bb10682a1bad2c9caa33dd818550fc3ec6 +8f6ee34128fac8bbf13ce2d68b2bb363eb4fd65b297075f88e1446ddeac242500eeb4ef0735e105882ff5ba8c44c139b +b4440e48255c1644bcecf3a1e9958f1ec4901cb5b1122ee5b56ffd02cad1c29c4266999dbb85aa2605c1b125490074d4 +a43304a067bede5f347775d5811cf65a6380a8d552a652a0063580b5c5ef12a0867a39c7912fa219e184f4538eba1251 +a891ad67a790089ffc9f6d53e6a3d63d3556f5f693e0cd8a7d0131db06fd4520e719cfcc3934f0a8f62a95f90840f1d4 +aea6df8e9bb871081aa0fc5a9bafb00be7d54012c5baf653791907d5042a326aeee966fd9012a582cc16695f5baf7042 +8ffa2660dc52ed1cd4eff67d6a84a8404f358a5f713d04328922269bee1e75e9d49afeec0c8ad751620f22352a438e25 +87ec6108e2d63b06abed350f8b363b7489d642486f879a6c3aa90e5b0f335efc2ff2834eef9353951a42136f8e6a1b32 +865619436076c2760d9e87ddc905023c6de0a8d56eef12c98a98c87837f2ca3f27fd26a2ad752252dbcbe2b9f1d5a032 +980437dce55964293cb315c650c5586ffd97e7a944a83f6618af31c9d92c37b53ca7a21bb5bc557c151b9a9e217e7098 +95d128fc369df4ad8316b72aea0ca363cbc7b0620d6d7bb18f7076a8717a6a46956ff140948b0cc4f6d2ce33b5c10054 +8c7212d4a67b9ec70ebbca04358ad2d36494618d2859609163526d7b3acc2fc935ca98519380f55e6550f70a9bc76862 +893a2968819401bf355e85eee0f0ed0406a6d4a7d7f172d0017420f71e00bb0ba984f6020999a3cdf874d3cd8ebcd371 +9103c1af82dece25d87274e89ea0acd7e68c2921c4af3d8d7c82ab0ed9990a5811231b5b06113e7fa43a6bd492b4564f +99cfd87a94eab7d35466caa4ed7d7bb45e5c932b2ec094258fb14bf205659f83c209b83b2f2c9ccb175974b2a33e7746 +874b6b93e4ee61be3f00c32dd84c897ccd6855c4b6251eb0953b4023634490ed17753cd3223472873cbc6095b2945075 +84a32c0dc4ea60d33aac3e03e70d6d639cc9c4cc435c539eff915017be3b7bdaba33349562a87746291ebe9bc5671f24 +a7057b24208928ad67914e653f5ac1792c417f413d9176ba635502c3f9c688f7e2ee81800d7e3dc0a340c464da2fd9c5 +a03fb9ed8286aacfa69fbd5d953bec591c2ae4153400983d5dbb6cd9ea37fff46ca9e5cceb9d117f73e9992a6c055ad2 +863b2de04e89936c9a4a2b40380f42f20aefbae18d03750fd816c658aee9c4a03df7b12121f795c85d01f415baaeaa59 +8526eb9bd31790fe8292360d7a4c3eed23be23dd6b8b8f01d2309dbfdc0cfd33ad1568ddd7f8a610f3f85a9dfafc6a92 +b46ab8c5091a493d6d4d60490c40aa27950574a338ea5bbc045be3a114af87bdcb160a8c80435a9b7ad815f3cb56a3f3 +aeadc47b41a8d8b4176629557646202f868b1d728b2dda58a347d937e7ffc8303f20d26d6c00b34c851b8aeec547885d +aebb19fc424d72c1f1822aa7adc744cd0ef7e55727186f8df8771c784925058c248406ebeeaf3c1a9ee005a26e9a10c6 +8ff96e81c1a4a2ab1b4476c21018fae0a67e92129ee36120cae8699f2d7e57e891f5c624902cb1b845b944926a605cc3 +8251b8d2c43fadcaa049a9e7aff838dae4fb32884018d58d46403ac5f3beb5c518bfd45f03b8abb710369186075eb71c +a8b2a64f865f51a5e5e86a66455c093407933d9d255d6b61e1fd81ffafc9538d73caaf342338a66ba8ee166372a3d105 +aad915f31c6ba7fdc04e2aaac62e84ef434b7ee76a325f07dc430d12c84081999720181067b87d792efd0117d7ee1eab +a13db3bb60389883fd41d565c54fb5180d9c47ce2fe7a169ae96e01d17495f7f4fa928d7e556e7c74319c4c25d653eb2 +a4491b0198459b3f552855d680a59214eb74e6a4d6c5fa3b309887dc50ebea2ecf6d26c040550f7dc478b452481466fb +8f017f13d4b1e3f0c087843582b52d5f8d13240912254d826dd11f8703a99a2f3166dfbdfdffd9a3492979d77524276b +96c3d5dcd032660d50d7cd9db2914f117240a63439966162b10c8f1f3cf74bc83b0f15451a43b31dbd85e4a7ce0e4bb1 +b479ec4bb79573d32e0ec93b92bdd7ec8c26ddb5a2d3865e7d4209d119fd3499eaac527615ffac78c440e60ef3867ae0 +b2c49c4a33aa94b52b6410b599e81ff15490aafa7e43c8031c865a84e4676354a9c81eb4e7b8be6825fdcefd1e317d44 +906dc51d6a90c089b6704b47592805578a6eed106608eeb276832f127e1b8e858b72e448edcbefb497d152447e0e68ff +b0e81c63b764d7dfbe3f3fddc9905aef50f3633e5d6a4af6b340495124abedcff5700dfd1577bbbed7b6bf97d02719cb +9304c64701e3b4ed6d146e48a881f7d83a17f58357cca0c073b2bb593afd2d94f6e2a7a1ec511d0a67ad6ff4c3be5937 +b6fdbd12ba05aa598d80b83f70a15ef90e5cba7e6e75fa038540ee741b644cd1f408a6cecfd2a891ef8d902de586c6b5 +b80557871a6521b1b3c74a1ba083ae055b575df607f1f7b04c867ba8c8c181ea68f8d90be6031f4d25002cca27c44da2 +aa7285b8e9712e06b091f64163f1266926a36607f9d624af9996856ed2aaf03a580cb22ce407d1ade436c28b44ca173f +8148d72b975238b51e6ea389e5486940d22641b48637d7dfadfa603a605bfc6d74a016480023945d0b85935e396aea5d +8a014933a6aea2684b5762af43dcf4bdbb633cd0428d42d71167a2b6fc563ece5e618bff22f1db2ddb69b845b9a2db19 +990d91740041db770d0e0eb9d9d97d826f09fd354b91c41e0716c29f8420e0e8aac0d575231efba12fe831091ec38d5a +9454d0d32e7e308ddec57cf2522fb1b67a2706e33fb3895e9e1f18284129ab4f4c0b7e51af25681d248d7832c05eb698 +a5bd434e75bac105cb3e329665a35bce6a12f71dd90c15165777d64d4c13a82bceedb9b48e762bd24034e0fc9fbe45f4 +b09e3b95e41800d4dc29c6ffdaab2cd611a0050347f6414f154a47ee20ee59bf8cf7181454169d479ebce1eb5c777c46 +b193e341d6a047d15eea33766d656d807b89393665a783a316e9ba10518e5515c8e0ade3d6e15641d917a8a172a5a635 +ade435ec0671b3621dde69e07ead596014f6e1daa1152707a8c18877a8b067bde2895dd47444ffa69db2bbef1f1d8816 +a7fd3d6d87522dfc56fb47aef9ce781a1597c56a8bbfd796baba907afdc872f753d732bfda1d3402aee6c4e0c189f52d +a298cb4f4218d0464b2fab393e512bbc477c3225aa449743299b2c3572f065bc3a42d07e29546167ed9e1b6b3b3a3af3 +a9ee57540e1fd9c27f4f0430d194b91401d0c642456c18527127d1f95e2dba41c2c86d1990432eb38a692fda058fafde +81d6c1a5f93c04e6d8e5a7e0678c1fc89a1c47a5c920bcd36180125c49fcf7c114866b90e90a165823560b19898a7c16 +a4b7a1ec9e93c899b9fd9aaf264c50e42c36c0788d68296a471f7a3447af4dbc81e4fa96070139941564083ec5b5b5a1 +b3364e327d381f46940c0e11e29f9d994efc6978bf37a32586636c0070b03e4e23d00650c1440f448809e1018ef9f6d8 +8056e0913a60155348300e3a62e28b5e30629a90f7dd4fe11289097076708110a1d70f7855601782a3cdc5bdb1ca9626 +b4980fd3ea17bac0ba9ee1c470b17e575bb52e83ebdd7d40c93f4f87bebeaff1c8a679f9d3d09d635f068d37d5bd28bd +905a9299e7e1853648e398901dfcd437aa575c826551f83520df62984f5679cb5f0ea86aa45ed3e18b67ddc0dfafe809 +ab99553bf31a84f2e0264eb34a08e13d8d15e2484aa9352354becf9a15999c76cc568d68274b70a65e49703fc23540d0 +a43681597bc574d2dae8964c9a8dc1a07613d7a1272bdcb818d98c85d44e16d744250c33f3b5e4d552d97396b55e601f +a54e5a31716fccb50245898c99865644405b8dc920ded7a11f3d19bdc255996054b268e16f2e40273f11480e7145f41e +8134f3ad5ef2ad4ba12a8a4e4d8508d91394d2bcdc38b7c8c8c0b0a820357ac9f79d286c65220f471eb1adca1d98fc68 +94e2f755e60471578ab2c1adb9e9cea28d4eec9b0e92e0140770bca7002c365fcabfe1e5fb4fe6cfe79a0413712aa3ef +ad48f8d0ce7eb3cc6e2a3086ad96f562e5bed98a360721492ae2e74dc158586e77ec8c35d5fd5927376301b7741bad2b +8614f0630bdd7fbad3a31f55afd9789f1c605dc85e7dc67e2edfd77f5105f878bb79beded6e9f0b109e38ea7da67e8d5 +9804c284c4c5e77dabb73f655b12181534ca877c3e1e134aa3f47c23b7ec92277db34d2b0a5d38d2b69e5d1c3008a3e3 +a51b99c3088e473afdaa9e0a9f7e75a373530d3b04e44e1148da0726b95e9f5f0c7e571b2da000310817c36f84b19f7f +ac4ff909933b3b76c726b0a382157cdc74ab851a1ac6cef76953c6444441804cc43abb883363f416592e8f6cfbc4550b +ae7d915eb9fc928b65a29d6edbc75682d08584d0014f7bcf17d59118421ae07d26a02137d1e4de6938bcd1ab8ef48fad +852f7e453b1af89b754df6d11a40d5d41ea057376e8ecacd705aacd2f917457f4a093d6b9a8801837fa0f62986ad7149 +92c6bf5ada5d0c3d4dd8058483de36c215fa98edab9d75242f3eff9db07c734ad67337da6f0eefe23a487bf75a600dee +a2b42c09d0db615853763552a48d2e704542bbd786aae016eb58acbf6c0226c844f5fb31e428cb6450b9db855f8f2a6f +880cc07968266dbfdcfbc21815cd69e0eddfee239167ac693fb0413912d816f2578a74f7716eecd6deefa68c6eccd394 +b885b3ace736cd373e8098bf75ba66fa1c6943ca1bc4408cd98ac7074775c4478594f91154b8a743d9c697e1b29f5840 +a51ce78de512bd87bfa0835de819941dffbf18bec23221b61d8096fc9436af64e0693c335b54e7bfc763f287bdca2db6 +a3c76166a3bdb9b06ef696e57603b58871bc72883ee9d45171a30fe6e1d50e30bc9c51b4a0f5a7270e19a77b89733850 +acefc5c6f8a1e7c24d7b41e0fc7f6f3dc0ede6cf3115ffb9a6e54b1d954cbca9bda8ad7a084be9be245a1b8e9770d141 +b420ed079941842510e31cfad117fa11fb6b4f97dfbc6298cb840f27ebaceba23eeaf3f513bcffbf5e4aae946310182d +95c3bb5ef26c5ed2f035aa5d389c6b3c15a6705b9818a3fefaed28922158b35642b2e8e5a1a620fdad07e75ad4b43af4 +825149f9081ecf07a2a4e3e8b5d21bade86c1a882475d51c55ee909330b70c5a2ac63771c8600c6f38df716af61a3ea1 +873b935aae16d9f08adbc25353cee18af2f1b8d5f26dec6538d6bbddc515f2217ed7d235dcfea59ae61b428798b28637 +9294150843a2bedcedb3bb74c43eb28e759cf9499582c5430bccefb574a8ddd4f11f9929257ff4c153990f9970a2558f +b619563a811cc531da07f4f04e5c4c6423010ff9f8ed7e6ec9449162e3d501b269fb1c564c09c0429431879b0f45df02 +91b509b87eb09f007d839627514658c7341bc76d468920fe8a740a8cb96a7e7e631e0ea584a7e3dc1172266f641d0f5c +8b8aceace9a7b9b4317f1f01308c3904d7663856946afbcea141a1c615e21ccad06b71217413e832166e9dd915fbe098 +87b3b36e725833ea0b0f54753c3728c0dbc87c52d44d705ffc709f2d2394414c652d3283bab28dcce09799504996cee0 +b2670aad5691cbf308e4a6a77a075c4422e6cbe86fdba24e9f84a313e90b0696afb6a067eebb42ba2d10340d6a2f6e51 +876784a9aff3d54faa89b2bacd3ff5862f70195d0b2edc58e8d1068b3c9074c0da1cfa23671fe12f35e33b8a329c0ccd +8b48b9e758e8a8eae182f5cbec96f67d20cca6d3eee80a2d09208eb1d5d872e09ef23d0df8ebbb9b01c7449d0e3e3650 +b79303453100654c04a487bdcadc9e3578bc80930c489a7069a52e8ca1dba36c492c8c899ce025f8364599899baa287d +961b35a6111da54ece6494f24dacd5ea46181f55775b5f03df0e370c34a5046ac2b4082925855325bb42bc2a2c98381d +a31feb1be3f5a0247a1f7d487987eb622e34fca817832904c6ee3ee60277e5847945a6f6ea1ac24542c72e47bdf647df +a12a2aa3e7327e457e1aae30e9612715dd2cfed32892c1cd6dcda4e9a18203af8a44afb46d03b2eed89f6b9c5a2c0c23 +a08265a838e69a2ca2f80fead6ccf16f6366415b920c0b22ee359bcd8d4464ecf156f400a16a7918d52e6d733dd64211 +b723d6344e938d801cca1a00032af200e541d4471fd6cbd38fb9130daa83f6a1dffbbe7e67fc20f9577f884acd7594b2 +a6733d83ec78ba98e72ddd1e7ff79b7adb0e559e256760d0c590a986e742445e8cdf560d44b29439c26d87edd0b07c8c +a61c2c27d3f7b9ff4695a17afedf63818d4bfba390507e1f4d0d806ce8778d9418784430ce3d4199fd3bdbc2504d2af3 +8332f3b63a6dc985376e8b1b25eeae68be6160fbe40053ba7bcf6f073204f682da72321786e422d3482fd60c9e5aa034 +a280f44877583fbb6b860d500b1a3f572e3ee833ec8f06476b3d8002058e25964062feaa1e5bec1536d734a5cfa09145 +a4026a52d277fcea512440d2204f53047718ebfcae7b48ac57ea7f6bfbc5de9d7304db9a9a6cbb273612281049ddaec5 +95cdf69c831ab2fad6c2535ede9c07e663d2ddccc936b64e0843d2df2a7b1c31f1759c3c20f1e7a57b1c8f0dbb21b540 +95c96cec88806469c277ab567863c5209027cecc06c7012358e5f555689c0d9a5ffb219a464f086b45817e8536b86d2f +afe38d4684132a0f03d806a4c8df556bf589b25271fbc6fe2e1ed16de7962b341c5003755da758d0959d2e6499b06c68 +a9b77784fda64987f97c3a23c5e8f61b918be0f7c59ba285084116d60465c4a2aaafc8857eb16823282cc83143eb9126 +a830f05881ad3ce532a55685877f529d32a5dbe56cea57ffad52c4128ee0fad0eeaf0da4362b55075e77eda7babe70e5 +992b3ad190d6578033c13ed5abfee4ef49cbc492babb90061e3c51ee4b5790cdd4c8fc1abff1fa2c00183b6b64f0bbbe +b1015424d9364aeff75de191652dc66484fdbec3e98199a9eb9671ec57bec6a13ff4b38446e28e4d8aedb58dd619cd90 +a745304604075d60c9db36cada4063ac7558e7ec2835d7da8485e58d8422e817457b8da069f56511b02601289fbb8981 +a5ba4330bc5cb3dbe0486ddf995632a7260a46180a08f42ae51a2e47778142132463cc9f10021a9ad36986108fefa1a9 +b419e9fd4babcaf8180d5479db188bb3da232ae77a1c4ed65687c306e6262f8083070a9ac32220cddb3af2ec73114092 +a49e23dc5f3468f3bf3a0bb7e4a114a788b951ff6f23a3396ae9e12cbff0abd1240878a3d1892105413dbc38818e807c +b7ecc7b4831f650202987e85b86bc0053f40d983f252e9832ef503aea81c51221ce93279da4aa7466c026b2d2070e55d +96a8c35cb87f84fa84dcd6399cc2a0fd79cc9158ef4bdde4bae31a129616c8a9f2576cd19baa3f497ca34060979aed7d +8681b2c00aa62c2b519f664a95dcb8faef601a3b961bb4ce5d85a75030f40965e2983871d41ea394aee934e859581548 +85c229a07efa54a713d0790963a392400f55fbb1a43995a535dc6c929f20d6a65cf4efb434e0ad1cb61f689b8011a3bc +90856f7f3444e5ad44651c28e24cc085a5db4d2ffe79aa53228c26718cf53a6e44615f3c5cda5aa752d5f762c4623c66 +978999b7d8aa3f28a04076f74d11c41ef9c89fdfe514936c4238e0f13c38ec97e51a5c078ebc6409e517bfe7ccb42630 +a099914dd7ed934d8e0d363a648e9038eb7c1ec03fa04dbcaa40f7721c618c3ef947afef7a16b4d7ac8c12aa46637f03 +ab2a104fed3c83d16f2cda06878fa5f30c8c9411de71bfb67fd2fc9aa454dcbcf3d299d72f8cc12e919466a50fcf7426 +a4471d111db4418f56915689482f6144efc4664cfb0311727f36c864648d35734351becc48875df96f4abd3cfcf820f9 +83be11727cd30ea94ccc8fa31b09b81c9d6a9a5d3a4686af9da99587332fe78c1f94282f9755854bafd6033549afec91 +88020ff971dc1a01a9e993cd50a5d2131ffdcbb990c1a6aaa54b20d8f23f9546a70918ea57a21530dcc440c1509c24ad +ae24547623465e87905eaffa1fa5d52bb7c453a8dbd89614fa8819a2abcedaf455c2345099b7324ae36eb0ad7c8ef977 +b59b0c60997de1ee00b7c388bc7101d136c9803bf5437b1d589ba57c213f4f835a3e4125b54738e78abbc21b000f2016 +a584c434dfe194546526691b68fa968c831c31da42303a1d735d960901c74011d522246f37f299555416b8cf25c5a548 +80408ce3724f4837d4d52376d255e10f69eb8558399ae5ca6c11b78b98fe67d4b93157d2b9b639f1b5b64198bfe87713 +abb941e8d406c2606e0ddc35c113604fdd9d249eacc51cb64e2991e551b8639ce44d288cc92afa7a1e7fc599cfc84b22 +b223173f560cacb1c21dba0f1713839e348ad02cbfdef0626748604c86f89e0f4c919ed40b583343795bdd519ba952c8 +af1c70512ec3a19d98b8a1fc3ff7f7f5048a27d17d438d43f561974bbdd116fcd5d5c21040f3447af3f0266848d47a15 +8a44809568ebe50405bede19b4d2607199159b26a1b33e03d180e6840c5cf59d991a4fb150d111443235d75ecad085b7 +b06207cdca46b125a27b3221b5b50cf27af4c527dd7c80e2dbcebbb09778a96df3af67e50f07725239ce3583dad60660 +993352d9278814ec89b26a11c4a7c4941bf8f0e6781ae79559d14749ee5def672259792db4587f85f0100c7bb812f933 +9180b8a718b971fd27bc82c8582d19c4b4f012453e8c0ffeeeffe745581fc6c07875ab28be3af3fa3896d19f0c89ac5b +8b8e1263eb48d0fe304032dd5ea1f30e73f0121265f7458ba9054d3626894e8a5fef665340abd2ede9653045c2665938 +99a2beee4a10b7941c24b2092192faf52b819afd033e4a2de050fd6c7f56d364d0cf5f99764c3357cf32399e60fc5d74 +946a4aad7f8647ea60bee2c5fcdeb6f9a58fb2cfca70c4d10e458027a04846e13798c66506151be3df9454b1e417893f +a672a88847652d260b5472d6908d1d57e200f1e492d30dd1cecc441cdfc9b76e016d9bab560efd4d7f3c30801de884a9 +9414e1959c156cde1eb24e628395744db75fc24b9df4595350aaad0bc38e0246c9b4148f6443ef68b8e253a4a6bcf11c +9316e9e4ec5fab4f80d6540df0e3a4774db52f1d759d2e5b5bcd3d7b53597bb007eb1887cb7dc61f62497d51ffc8d996 +902d6d77bb49492c7a00bc4b70277bc28c8bf9888f4307bb017ac75a962decdedf3a4e2cf6c1ea9f9ba551f4610cbbd7 +b07025a18b0e32dd5e12ec6a85781aa3554329ea12c4cd0d3b2c22e43d777ef6f89876dd90a9c8fb097ddf61cf18adc5 +b355a849ad3227caa4476759137e813505ec523cbc2d4105bc7148a4630f9e81918d110479a2d5f5e4cd9ccec9d9d3e3 +b49532cfdf02ee760109881ad030b89c48ee3bb7f219ccafc13c93aead754d29bdafe345be54c482e9d5672bd4505080 +9477802410e263e4f938d57fa8f2a6cac7754c5d38505b73ee35ea3f057aad958cb9722ba6b7b3cfc4524e9ca93f9cdc +9148ea83b4436339580f3dbc9ba51509e9ab13c03063587a57e125432dd0915f5d2a8f456a68f8fff57d5f08c8f34d6e +b00b6b5392b1930b54352c02b1b3b4f6186d20bf21698689bbfc7d13e86538a4397b90e9d5c93fd2054640c4dbe52a4f +926a9702500441243cd446e7cbf15dde16400259726794694b1d9a40263a9fc9e12f7bcbf12a27cb9aaba9e2d5848ddc +a0c6155f42686cbe7684a1dc327100962e13bafcf3db97971fc116d9f5c0c8355377e3d70979cdbd58fd3ea52440901c +a277f899f99edb8791889d0817ea6a96c24a61acfda3ad8c3379e7c62b9d4facc4b965020b588651672fd261a77f1bfc +8f528cebb866b501f91afa50e995234bef5bf20bff13005de99cb51eaac7b4f0bf38580cfd0470de40f577ead5d9ba0f +963fc03a44e9d502cc1d23250efef44d299befd03b898d07ce63ca607bb474b5cf7c965a7b9b0f32198b04a8393821f7 +ab087438d0a51078c378bf4a93bd48ef933ff0f1fa68d02d4460820df564e6642a663b5e50a5fe509527d55cb510ae04 +b0592e1f2c54746bb076be0fa480e1c4bebc4225e1236bcda3b299aa3853e3afb401233bdbcfc4a007b0523a720fbf62 +851613517966de76c1c55a94dc4595f299398a9808f2d2f0a84330ba657ab1f357701d0895f658c18a44cb00547f6f57 +a2fe9a1dd251e72b0fe4db27be508bb55208f8f1616b13d8be288363ec722826b1a1fd729fc561c3369bf13950bf1fd6 +b896cb2bc2d0c77739853bc59b0f89b2e008ba1f701c9cbe3bef035f499e1baee8f0ff1e794854a48c320586a2dfc81a +a1b60f98e5e5106785a9b81a85423452ee9ef980fa7fa8464f4366e73f89c50435a0c37b2906052b8e58e212ebd366cf +a853b0ebd9609656636df2e6acd5d8839c0fda56f7bf9288a943b06f0b67901a32b95e016ca8bc99bd7b5eab31347e72 +b290fa4c1346963bd5225235e6bdf7c542174dab4c908ab483d1745b9b3a6015525e398e1761c90e4b49968d05e30eea +b0f65a33ad18f154f1351f07879a183ad62e5144ad9f3241c2d06533dad09cbb2253949daff1bb02d24d16a3569f7ef0 +a00db59b8d4218faf5aeafcd39231027324408f208ec1f54d55a1c41228b463b88304d909d16b718cfc784213917b71e +b8d695dd33dc2c3bc73d98248c535b2770ad7fa31aa726f0aa4b3299efb0295ba9b4a51c71d314a4a1bd5872307534d1 +b848057cca2ca837ee49c42b88422303e58ea7d2fc76535260eb5bd609255e430514e927cc188324faa8e657396d63ec +92677836061364685c2aaf0313fa32322746074ed5666fd5f142a7e8f87135f45cd10e78a17557a4067a51dfde890371 +a854b22c9056a3a24ab164a53e5c5cf388616c33e67d8ebb4590cb16b2e7d88b54b1393c93760d154208b5ca822dc68f +86fff174920388bfab841118fb076b2b0cdec3fdb6c3d9a476262f82689fb0ed3f1897f7be9dbf0932bb14d346815c63 +99661cf4c94a74e182752bcc4b98a8c2218a8f2765642025048e12e88ba776f14f7be73a2d79bd21a61def757f47f904 +8a8893144d771dca28760cba0f950a5d634195fd401ec8cf1145146286caffb0b1a6ba0c4c1828d0a5480ce49073c64c +938a59ae761359ee2688571e7b7d54692848eb5dde57ffc572b473001ea199786886f8c6346a226209484afb61d2e526 +923f68a6aa6616714cf077cf548aeb845bfdd78f2f6851d8148cba9e33a374017f2f3da186c39b82d14785a093313222 +ac923a93d7da7013e73ce8b4a2b14b8fd0cc93dc29d5de941a70285bdd19be4740fedfe0c56b046689252a3696e9c5bc +b49b32c76d4ec1a2c68d4989285a920a805993bc6fcce6dacd3d2ddae73373050a5c44ba8422a3781050682fa0ef6ba2 +8a367941c07c3bdca5712524a1411bad7945c7c48ffc7103b1d4dff2c25751b0624219d1ccde8c3f70c465f954be5445 +b838f029df455efb6c530d0e370bbbf7d87d61a9aea3d2fe5474c5fe0a39cf235ceecf9693c5c6c5820b1ba8f820bd31 +a8983b7c715eaac7f13a001d2abc462dfc1559dab4a6b554119c271aa8fe00ffcf6b6949a1121f324d6d26cb877bcbae +a2afb24ad95a6f14a6796315fbe0d8d7700d08f0cfaf7a2abe841f5f18d4fecf094406cbd54da7232a159f9c5b6e805e +87e8e95ad2d62f947b2766ff405a23f7a8afba14e7f718a691d95369c79955cdebe24c54662553c60a3f55e6322c0f6f +87c2cbcecb754e0cc96128e707e5c5005c9de07ffd899efa3437cadc23362f5a1d3fcdd30a1f5bdc72af3fb594398c2a +91afd6ee04f0496dc633db88b9370d41c428b04fd991002502da2e9a0ef051bcd7b760e860829a44fbe5539fa65f8525 +8c50e5d1a24515a9dd624fe08b12223a75ca55196f769f24748686315329b337efadca1c63f88bee0ac292dd0a587440 +8a07e8f912a38d94309f317c32068e87f68f51bdfa082d96026f5f5f8a2211621f8a3856dda8069386bf15fb2d28c18f +94ad1dbe341c44eeaf4dc133eed47d8dbfe752575e836c075745770a6679ff1f0e7883b6aa917462993a7f469d74cab5 +8745f8bd86c2bb30efa7efb7725489f2654f3e1ac4ea95bd7ad0f3cfa223055d06c187a16192d9d7bdaea7b050c6a324 +900d149c8d79418cda5955974c450a70845e02e5a4ecbcc584a3ca64d237df73987c303e3eeb79da1af83bf62d9e579f +8f652ab565f677fb1a7ba03b08004e3cda06b86c6f1b0b9ab932e0834acf1370abb2914c15b0d08327b5504e5990681c +9103097d088be1f75ab9d3da879106c2f597e2cc91ec31e73430647bdd5c33bcfd771530d5521e7e14df6acda44f38a6 +b0fec7791cfb0f96e60601e1aeced9a92446b61fedab832539d1d1037558612d78419efa87ff5f6b7aab8fd697d4d9de +b9d2945bdb188b98958854ba287eb0480ef614199c4235ce5f15fc670b8c5ffe8eeb120c09c53ea8a543a022e6a321ac +a9461bb7d5490973ebaa51afc0bb4a5e42acdccb80e2f939e88b77ac28a98870e103e1042899750f8667a8cc9123bae9 +a37fdf11d4bcb2aed74b9f460a30aa34afea93386fa4cdb690f0a71bc58f0b8df60bec56e7a24f225978b862626fa00e +a214420e183e03d531cf91661466ea2187d84b6e814b8b20b3730a9400a7d25cf23181bb85589ebc982cec414f5c2923 +ad09a45a698a6beb3e0915f540ef16e9af7087f53328972532d6b5dfe98ce4020555ece65c6cbad8bd6be8a4dfefe6fd +ab6742800b02728c92d806976764cb027413d6f86edd08ad8bb5922a2969ee9836878cd39db70db0bd9a2646862acc4f +974ca9305bd5ea1dc1755dff3b63e8bfe9f744321046c1395659bcea2a987b528e64d5aa96ac7b015650b2253b37888d +84eee9d6bce039c52c2ebc4fccc0ad70e20c82f47c558098da4be2f386a493cbc76adc795b5488c8d11b6518c2c4fab8 +875d7bda46efcb63944e1ccf760a20144df3b00d53282b781e95f12bfc8f8316dfe6492c2efbf796f1150e36e436e9df +b68a2208e0c587b5c31b5f6cb32d3e6058a9642e2d9855da4f85566e1412db528475892060bb932c55b3a80877ad7b4a +ba006368ecab5febb6ab348644d9b63de202293085ed468df8bc24d992ae8ce468470aa37f36a73630c789fb9c819b30 +90a196035150846cd2b482c7b17027471372a8ce7d914c4d82b6ea7fa705d8ed5817bd42d63886242585baf7d1397a1c +a223b4c85e0daa8434b015fd9170b5561fe676664b67064974a1e9325066ecf88fc81f97ab5011c59fad28cedd04b240 +82e8ec43139cf15c6bbeed484b62e06cded8a39b5ce0389e4cbe9c9e9c02f2f0275d8d8d4e8dfec8f69a191bef220408 +81a3fc07a7b68d92c6ee4b6d28f5653ee9ec85f7e2ee1c51c075c1b130a8c5097dc661cf10c5aff1c7114b1a6a19f11a +8ed2ef8331546d98819a5dd0e6c9f8cb2630d0847671314a28f277faf68da080b53891dd75c82cbcf7788b255490785d +acecabf84a6f9bbed6b2fc2e7e4b48f02ef2f15e597538a73aea8f98addc6badda15e4695a67ecdb505c1554e8f345ec +b8f51019b2aa575f8476e03dcadf86cc8391f007e5f922c2a36b2daa63f5a503646a468990cd5c65148d323942193051 +aaa595a84b403ec65729bc1c8055a94f874bf9adddc6c507b3e1f24f79d3ad359595a672b93aab3394db4e2d4a7d8970 +895144c55fcbd0f64d7dd69e6855cfb956e02b5658eadf0f026a70703f3643037268fdd673b0d21b288578a83c6338dd +a2e92ae6d0d237d1274259a8f99d4ea4912a299816350b876fba5ebc60b714490e198a916e1c38c6e020a792496fa23c +a45795fda3b5bb0ad1d3c628f6add5b2a4473a1414c1a232e80e70d1cfffd7f8a8d9861f8df2946999d7dbb56bf60113 +b6659bf7f6f2fef61c39923e8c23b8c70e9c903028d8f62516d16755cd3fba2fe41c285aa9432dc75ab08f8a1d8a81fc +a735609a6bc5bfd85e58234fc439ff1f58f1ff1dd966c5921d8b649e21f006bf2b8642ad8a75063c159aaf6935789293 +a3c622eb387c9d15e7bda2e3e84d007cb13a6d50d655c3f2f289758e49d3b37b9a35e4535d3cc53d8efd51f407281f19 +8afe147b53ad99220f5ef9d763bfc91f9c20caecbcf823564236fb0e6ede49414c57d71eec4772c8715cc65a81af0047 +b5f0203233cf71913951e9c9c4e10d9243e3e4a1f2cb235bf3f42009120ba96e04aa414c9938ea8873b63148478927e8 +93c52493361b458d196172d7ba982a90a4f79f03aa8008edc322950de3ce6acf4c3977807a2ffa9e924047e02072b229 +b9e72b805c8ac56503f4a86c82720afbd5c73654408a22a2ac0b2e5caccdfb0e20b59807433a6233bc97ae58cf14c70a +af0475779b5cee278cca14c82da2a9f9c8ef222eb885e8c50cca2315fea420de6e04146590ed0dd5a29c0e0812964df5 +b430ccab85690db02c2d0eb610f3197884ca12bc5f23c51e282bf3a6aa7e4a79222c3d8761454caf55d6c01a327595f9 +830032937418b26ee6da9b5206f3e24dc76acd98589e37937e963a8333e5430abd6ce3dd93ef4b8997bd41440eed75d6 +8820a6d73180f3fe255199f3f175c5eb770461ad5cfdde2fb11508041ed19b8c4ce66ad6ecebf7d7e836cc2318df47ca +aef1393e7d97278e77bbf52ef6e1c1d5db721ccf75fe753cf47a881fa034ca61eaa5098ee5a344c156d2b14ff9e284ad +8a4a26c07218948c1196c45d927ef4d2c42ade5e29fe7a91eaebe34a29900072ce5194cf28d51f746f4c4c649daf4396 +84011dc150b7177abdcb715efbd8c201f9cb39c36e6069af5c50a096021768ba40cef45b659c70915af209f904ede3b6 +b1bd90675411389bb66910b21a4bbb50edce5330850c5ab0b682393950124252766fc81f5ecfc72fb7184387238c402e +8dfdcd30583b696d2c7744655f79809f451a60c9ad5bf1226dc078b19f4585d7b3ef7fa9d54e1ac09520d95cbfd20928 +b351b4dc6d98f75b8e5a48eb7c6f6e4b78451991c9ba630e5a1b9874c15ac450cd409c1a024713bf2cf82dc400e025ef +a462b8bc97ac668b97b28b3ae24b9f5de60e098d7b23ecb600d2194cd35827fb79f77c3e50d358f5bd72ee83fef18fa0 +a183753265c5f7890270821880cce5f9b2965b115ba783c6dba9769536f57a04465d7da5049c7cf8b3fcf48146173c18 +a8a771b81ed0d09e0da4d79f990e58eabcd2be3a2680419502dd592783fe52f657fe55125b385c41d0ba3b9b9cf54a83 +a71ec577db46011689d073245e3b1c3222a9b1fe6aa5b83629adec5733dd48617ebea91346f0dd0e6cdaa86e4931b168 +a334b8b244f0d598a02da6ae0f918a7857a54dce928376c4c85df15f3b0f2ba3ac321296b8b7c9dd47d770daf16c8f8c +a29037f8ef925c417c90c4df4f9fb27fb977d04e2b3dd5e8547d33e92ab72e7a00f5461de21e28835319eae5db145eb7 +b91054108ae78b00e3298d667b913ebc44d8f26e531eae78a8fe26fdfb60271c97efb2dee5f47ef5a3c15c8228138927 +926c13efbe90604f6244be9315a34f72a1f8d1aab7572df431998949c378cddbf2fe393502c930fff614ff06ae98a0ce +995c758fd5600e6537089b1baa4fbe0376ab274ff3e82a17768b40df6f91c2e443411de9cafa1e65ea88fb8b87d504f4 +9245ba307a7a90847da75fca8d77ec03fdfc812c871e7a2529c56a0a79a6de16084258e7a9ac4ae8a3756f394336e21c +99e0cfa2bb57a7e624231317044c15e52196ecce020db567c8e8cb960354a0be9862ee0c128c60b44777e65ac315e59f +ad4f6b3d27bbbb744126601053c3dc98c07ff0eb0b38a898bd80dce778372846d67e5ab8fb34fb3ad0ef3f235d77ba7f +a0f12cae3722bbbca2e539eb9cc7614632a2aefe51410430070a12b5bc5314ecec5857b7ff8f41e9980cac23064f7c56 +b487f1bc59485848c98222fd3bc36c8c9bb3d2912e2911f4ceca32c840a7921477f9b1fe00877e05c96c75d3eecae061 +a6033db53925654e18ecb3ce715715c36165d7035db9397087ac3a0585e587998a53973d011ac6d48af439493029cee6 +a6b4d09cd01c70a3311fd131d3710ccf97bde3e7b80efd5a8c0eaeffeb48cca0f951ced905290267b115b06d46f2693b +a9dff1df0a8f4f218a98b6f818a693fb0d611fed0fc3143537cbd6578d479af13a653a8155e535548a2a0628ae24fa58 +a58e469f65d366b519f9a394cacb7edaddac214463b7b6d62c2dbc1316e11c6c5184ce45c16de2d77f990dcdd8b55430 +989e71734f8119103586dc9a3c5f5033ddc815a21018b34c1f876cdfc112efa868d5751bf6419323e4e59fa6a03ece1c +a2da00e05036c884369e04cf55f3de7d659cd5fa3f849092b2519dd263694efe0f051953d9d94b7e121f0aee8b6174d7 +968f3c029f57ee31c4e1adea89a7f92e28483af9a74f30fbdb995dc2d40e8e657dff8f8d340d4a92bf65f54440f2859f +932778df6f60ac1639c1453ef0cbd2bf67592759dcccb3e96dcc743ff01679e4c7dd0ef2b0833dda548d32cb4eba49e2 +a805a31139f8e0d6dae1ac87d454b23a3dc9fc653d4ca18d4f8ebab30fc189c16e73981c2cb7dd6f8c30454a5208109d +a9ba0991296caa2aaa4a1ceacfb205544c2a2ec97088eace1d84ee5e2767656a172f75d2f0c4e16a3640a0e0dec316e0 +b1e49055c968dced47ec95ae934cf45023836d180702e20e2df57e0f62fb85d7ac60d657ba3ae13b8560b67210449459 +a94e1da570a38809c71e37571066acabff7bf5632737c9ab6e4a32856924bf6211139ab3cedbf083850ff2d0e0c0fcfc +88ef1bb322000c5a5515b310c838c9af4c1cdbb32eab1c83ac3b2283191cd40e9573747d663763a28dad0d64adc13840 +a987ce205f923100df0fbd5a85f22c9b99b9b9cbe6ddfa8dfda1b8fe95b4f71ff01d6c5b64ca02eb24edb2b255a14ef0 +84fe8221a9e95d9178359918a108de4763ebfa7a6487facb9c963406882a08a9a93f492f8e77cf9e7ea41ae079c45993 +aa1cf3dc7c5dcfa15bbbc811a4bb6dbac4fba4f97fb1ed344ab60264d7051f6eef19ea9773441d89929ee942ed089319 +8f6a7d610d59d9f54689bbe6a41f92d9f6096cde919c1ab94c3c7fcecf0851423bc191e5612349e10f855121c0570f56 +b5af1fa7894428a53ea520f260f3dc3726da245026b6d5d240625380bfb9c7c186df0204bb604efac5e613a70af5106e +a5bce6055ff812e72ce105f147147c7d48d7a2313884dd1f488b1240ee320f13e8a33f5441953a8e7a3209f65b673ce1 +b9b55b4a1422677d95821e1d042ab81bbf0bf087496504021ec2e17e238c2ca6b44fb3b635a5c9eac0871a724b8d47c3 +941c38e533ce4a673a3830845b56786585e5fe49c427f2e5c279fc6db08530c8f91db3e6c7822ec6bb4f956940052d18 +a38e191d66c625f975313c7007bbe7431b5a06ed2da1290a7d5d0f2ec73770d476efd07b8e632de64597d47df175cbb0 +94ba76b667abf055621db4c4145d18743a368d951565632ed4e743dd50dd3333507c0c34f286a5c5fdbf38191a2255cd +a5ca38c60be5602f2bfa6e00c687ac96ac36d517145018ddbee6f12eb0faa63dd57909b9eeed26085fe5ac44e55d10ab +b00fea3b825e60c1ed1c5deb4b551aa65a340e5af36b17d5262c9cd2c508711e4dc50dc2521a2c16c7c901902266e64a +971b86fc4033485e235ccb0997a236206ba25c6859075edbcdf3c943116a5030b7f75ebca9753d863a522ba21a215a90 +b3b31f52370de246ee215400975b674f6da39b2f32514fe6bd54e747752eedca22bb840493b44a67df42a3639c5f901f +affbbfac9c1ba7cbfa1839d2ae271dd6149869b75790bf103230637da41857fc326ef3552ff31c15bda0694080198143 +a95d42aa7ef1962520845aa3688f2752d291926f7b0d73ea2ee24f0612c03b43f2b0fe3c9a9a99620ffc8d487b981bc2 +914a266065caf64985e8c5b1cb2e3f4e3fe94d7d085a1881b1fefa435afef4e1b39a98551d096a62e4f5cc1a7f0fdc2e +81a0b4a96e2b75bc1bf2dbd165d58d55cfd259000a35504d1ffb18bc346a3e6f07602c683723864ffb980f840836fd8d +91c1556631cddd4c00b65b67962b39e4a33429029d311c8acf73a18600e362304fb68bccb56fde40f49e95b7829e0b87 +8befbacc19e57f7c885d1b7a6028359eb3d80792fe13b92a8400df21ce48deb0bb60f2ddb50e3d74f39f85d7eab23adc +92f9458d674df6e990789690ec9ca73dacb67fc9255b58c417c555a8cc1208ace56e8e538f86ba0f3615573a0fbac00d +b4b1b3062512d6ae7417850c08c13f707d5838e43d48eb98dd4621baf62eee9e82348f80fe9b888a12874bfa538771f8 +a13c4a3ac642ede37d9c883f5319e748d2b938f708c9d779714108a449b343f7b71a6e3ef4080fee125b416762920273 +af44983d5fc8cceee0551ef934e6e653f2d3efa385e5c8a27a272463a6f333e290378cc307c2b664eb923c78994e706e +a389fd6c59fe2b4031cc244e22d3991e541bd203dd5b5e73a6159e72df1ab41d49994961500dcde7989e945213184778 +8d2141e4a17836c548de9598d7b298b03f0e6c73b7364979a411c464e0628e21cff6ac3d6decdba5d1c4909eff479761 +980b22ef53b7bdf188a3f14bc51b0dbfdf9c758826daa3cbc1e3986022406a8aa9a6a79e400567120b88c67faa35ce5f +a28882f0a055f96df3711de5d0aa69473e71245f4f3e9aa944e9d1fb166e02caa50832e46da6d3a03b4801735fd01b29 +8db106a37d7b88f5d995c126abb563934dd8de516af48e85695d02b1aea07f79217e3cdd03c6f5ca57421830186c772b +b5a7e50da0559a675c472f7dfaee456caab6695ab7870541b2be8c2b118c63752427184aad81f0e1afc61aef1f28c46f +9962118780e20fe291d10b64f28d09442a8e1b5cffd0f3dd68d980d0614050a626c616b44e9807fbee7accecae00686a +b38ddf33745e8d2ad6a991aefaf656a33c5f8cbe5d5b6b6fd03bd962153d8fd0e01b5f8f96d80ae53ab28d593ab1d4e7 +857dc12c0544ff2c0c703761d901aba636415dee45618aba2e3454ff9cbc634a85c8b05565e88520ff9be2d097c8b2b1 +a80d465c3f8cc63af6d74a6a5086b626c1cb4a8c0fee425964c3bd203d9d7094e299f81ce96d58afc20c8c9a029d9dae +89e1c8fbde8563763be483123a3ed702efac189c6d8ab4d16c85e74bbaf856048cc42d5d6e138633a38572ba5ec3f594 +893a594cf495535f6d216508f8d03c317dcf03446668cba688da90f52d0111ac83d76ad09bf5ea47056846585ee5c791 +aadbd8be0ae452f7f9450c7d2957598a20cbf10139a4023a78b4438172d62b18b0de39754dd2f8862dbd50a3a0815e53 +ae7d39670ecca3eb6db2095da2517a581b0e8853bdfef619b1fad9aacd443e7e6a40f18209fadd44038a55085c5fe8b2 +866ef241520eacb6331593cfcb206f7409d2f33d04542e6e52cba5447934e02d44c471f6c9a45963f9307e9809ab91d9 +b1a09911ad3864678f7be79a9c3c3eb5c84a0a45f8dcb52c67148f43439aeaaa9fd3ed3471276b7e588b49d6ebe3033a +add07b7f0dbb34049cd8feeb3c18da5944bf706871cfd9f14ff72f6c59ad217ebb1f0258b13b167851929387e4e34cfe +ae048892d5c328eefbdd4fba67d95901e3c14d974bfc0a1fc68155ca9f0d59e61d7ba17c6c9948b120cf35fd26e6fee9 +9185b4f3b7da0ddb4e0d0f09b8a9e0d6943a4611e43f13c3e2a767ed8592d31e0ba3ebe1914026a3627680274291f6e5 +a9c022d4e37b0802284ce3b7ee9258628ab4044f0db4de53d1c3efba9de19d15d65cc5e608dbe149c21c2af47d0b07b5 +b24dbd5852f8f24921a4e27013b6c3fa8885b973266cb839b9c388efad95821d5d746348179dcc07542bd0d0aefad1ce +b5fb4f279300876a539a27a441348764908bc0051ebd66dc51739807305e73db3d2f6f0f294ffb91b508ab150eaf8527 +ace50841e718265b290c3483ed4b0fdd1175338c5f1f7530ae9a0e75d5f80216f4de37536adcbc8d8c95982e88808cd0 +b19cadcde0f63bd1a9c24bd9c2806f53c14c0b9735bf351601498408ba503ddbd2037c891041cbba47f58b8c483f3b21 +b6061e63558d312eb891b97b39aa552fa218568d79ee26fe6dd5b864aea9e3216d8f2e2f3b093503be274766dac41426 +89730fdb2876ab6f0fe780d695f6e12090259027e789b819956d786e977518057e5d1d7f5ab24a3ae3d5d4c97773bd2b +b6fa841e81f9f2cad0163a02a63ae96dc341f7ae803b616efc6e1da2fbea551c1b96b11ad02c4afbdf6d0cc9f23da172 +8fb66187182629c861ddb6896d7ed3caf2ad050c3dba8ab8eb0d7a2c924c3d44c48d1a148f9e33fb1f061b86972f8d21 +86022ac339c1f84a7fa9e05358c1a5b316b4fc0b83dbe9c8c7225dc514f709d66490b539359b084ce776e301024345fa +b50b9c321468da950f01480bb62b6edafd42f83c0001d6e97f2bd523a1c49a0e8574fb66380ea28d23a7c4d54784f9f0 +a31c05f7032f30d1dac06678be64d0250a071fd655e557400e4a7f4c152be4d5c7aa32529baf3e5be7c4bd49820054f6 +b95ac0848cd322684772119f5b682d90a66bbf9dac411d9d86d2c34844bbd944dbaf8e47aa41380455abd51687931a78 +ae4a6a5ce9553b65a05f7935e61e496a4a0f6fd8203367a2c627394c9ce1e280750297b74cdc48fd1d9a31e93f97bef4 +a22daf35f6e9b05e52e0b07f7bd1dbbebd2c263033fb0e1b2c804e2d964e2f11bc0ece6aca6af079dd3a9939c9c80674 +902150e0cb1f16b9b59690db35281e28998ce275acb313900da8b2d8dfd29fa1795f8ca3ff820c31d0697de29df347c1 +b17b5104a5dc665cdd7d47e476153d715eb78c6e5199303e4b5445c21a7fa7cf85fe7cfd08d7570f4e84e579b005428c +a03f49b81c15433f121680aa02d734bb9e363af2156654a62bcb5b2ba2218398ccb0ff61104ea5d7df5b16ea18623b1e +802101abd5d3c88876e75a27ffc2f9ddcce75e6b24f23dba03e5201281a7bd5cc7530b6a003be92d225093ca17d3c3bb +a4d183f63c1b4521a6b52226fc19106158fc8ea402461a5cccdaa35fee93669df6a8661f45c1750cd01308149b7bf08e +8d17c22e0c8403b69736364d460b3014775c591032604413d20a5096a94d4030d7c50b9fe3240e31d0311efcf9816a47 +947225acfcce5992eab96276f668c3cbe5f298b90a59f2bb213be9997d8850919e8f496f182689b5cbd54084a7332482 +8df6f4ed216fc8d1905e06163ba1c90d336ab991a18564b0169623eb39b84e627fa267397da15d3ed754d1f3423bff07 +83480007a88f1a36dea464c32b849a3a999316044f12281e2e1c25f07d495f9b1710b4ba0d88e9560e72433addd50bc2 +b3019d6e591cf5b33eb972e49e06c6d0a82a73a75d78d383dd6f6a4269838289e6e07c245f54fed67f5c9bb0fd5e1c5f +92e8ce05e94927a9fb02debadb99cf30a26172b2705003a2c0c47b3d8002bf1060edb0f6a5750aad827c98a656b19199 +ac2aff801448dbbfc13cca7d603fd9c69e82100d997faf11f465323b97255504f10c0c77401e4d1890339d8b224f5803 +b0453d9903d08f508ee27e577445dc098baed6cde0ac984b42e0f0efed62760bd58d5816cf1e109d204607b7b175e30c +ae68dc4ba5067e825d46d2c7c67f1009ceb49d68e8d3e4c57f4bcd299eb2de3575d42ea45e8722f8f28497a6e14a1cfe +b22486c2f5b51d72335ce819bbafb7fa25eb1c28a378a658f13f9fc79cd20083a7e573248d911231b45a5cf23b561ca7 +89d1201d1dbd6921867341471488b4d2fd0fc773ae1d4d074c78ae2eb779a59b64c00452c2a0255826fca6b3d03be2b1 +a2998977c91c7a53dc6104f5bc0a5b675e5350f835e2f0af69825db8af4aeb68435bdbcc795f3dd1f55e1dd50bc0507f +b0be4937a925b3c05056ed621910d535ccabf5ab99fd3b9335080b0e51d9607d0fd36cb5781ff340018f6acfca4a9736 +aea145a0f6e0ba9df8e52e84bb9c9de2c2dc822f70d2724029b153eb68ee9c17de7d35063dcd6a39c37c59fdd12138f7 +91cb4545d7165ee8ffbc74c874baceca11fdebbc7387908d1a25877ca3c57f2c5def424dab24148826832f1e880bede0 +b3b579cb77573f19c571ad5eeeb21f65548d7dff9d298b8d7418c11f3e8cd3727c5b467f013cb87d6861cfaceee0d2e3 +b98a1eeec2b19fecc8378c876d73645aa52fb99e4819903735b2c7a885b242787a30d1269a04bfb8573d72d9bbc5f0f0 +940c1f01ed362bd588b950c27f8cc1d52276c71bb153d47f07ec85b038c11d9a8424b7904f424423e714454d5e80d1cd +aa343a8ecf09ce11599b8cf22f7279cf80f06dbf9f6d62cb05308dbbb39c46fd0a4a1240b032665fbb488a767379b91b +87c3ac72084aca5974599d3232e11d416348719e08443acaba2b328923af945031f86432e170dcdd103774ec92e988c9 +91d6486eb5e61d2b9a9e742c20ec974a47627c6096b3da56209c2b4e4757f007e793ebb63b2b246857c9839b64dc0233 +aebcd3257d295747dd6fc4ff910d839dd80c51c173ae59b8b2ec937747c2072fa85e3017f9060aa509af88dfc7529481 +b3075ba6668ca04eff19efbfa3356b92f0ab12632dcda99cf8c655f35b7928c304218e0f9799d68ef9f809a1492ff7db +93ba7468bb325639ec2abd4d55179c69fd04eaaf39fc5340709227bbaa4ad0a54ea8b480a1a3c8d44684e3be0f8d1980 +a6aef86c8c0d92839f38544d91b767c582568b391071228ff5a5a6b859c87bf4f81a7d926094a4ada1993ddbd677a920 +91dcd6d14207aa569194aa224d1e5037b999b69ade52843315ca61ba26abe9a76412c9e88259bc5cf5d7b95b97d9c3bc +b3b483d31c88f78d49bd065893bc1e3d2aa637e27dedb46d9a7d60be7660ce7a10aaaa7deead362284a52e6d14021178 +8e5730070acf8371461ef301cc4523e8e672aa0e3d945d438a0e0aa6bdf8cb9c685dcf38df429037b0c8aff3955c6f5b +b8c6d769890a8ee18dc4f9e917993315877c97549549b34785a92543cbeec96a08ae3a28d6e809c4aacd69de356c0012 +95ca86cd384eaceaa7c077c5615736ca31f36824bd6451a16142a1edc129fa42b50724aeed7c738f08d7b157f78b569e +94df609c6d71e8eee7ab74226e371ccc77e01738fe0ef1a6424435b4570fe1e5d15797b66ed0f64eb88d4a3a37631f0e +89057b9783212add6a0690d6bb99097b182738deff2bd9e147d7fd7d6c8eacb4c219923633e6309ad993c24572289901 +83a0f9f5f265c5a0e54defa87128240235e24498f20965009fef664f505a360b6fb4020f2742565dfc7746eb185bcec0 +91170da5306128931349bc3ed50d7df0e48a68b8cc8420975170723ac79d8773e4fa13c5f14dc6e3fafcad78379050b1 +b7178484d1b55f7e56a4cc250b6b2ec6040437d96bdfddfa7b35ed27435860f3855c2eb86c636f2911b012eb83b00db8 +ac0b00c4322d1e4208e09cd977b4e54d221133ff09551f75b32b0b55d0e2be80941dda26257b0e288c162e63c7e9cf68 +9690ed9e7e53ed37ff362930e4096b878b12234c332fd19d5d064824084245952eda9f979e0098110d6963e468cf513e +b6fa547bb0bb83e5c5be0ed462a8783fba119041c136a250045c09d0d2af330c604331e7de960df976ff76d67f8000cd +814603907c21463bcf4e59cfb43066dfe1a50344ae04ef03c87c0f61b30836c3f4dea0851d6fa358c620045b7f9214c8 +9495639e3939fad2a3df00a88603a5a180f3c3a0fe4d424c35060e2043e0921788003689887b1ed5be424d9a89bb18bb +aba4c02d8d57f2c92d5bc765885849e9ff8393d6554f5e5f3e907e5bfac041193a0d8716d7861104a4295d5a03c36b03 +8ead0b56c1ca49723f94a998ba113b9058059321da72d9e395a667e6a63d5a9dac0f5717cec343f021695e8ced1f72af +b43037f7e3852c34ed918c5854cd74e9d5799eeddfe457d4f93bb494801a064735e326a76e1f5e50a339844a2f4a8ec9 +99db8422bb7302199eb0ff3c3d08821f8c32f53a600c5b6fb43e41205d96adae72be5b460773d1280ad1acb806af9be8 +8a9be08eae0086c0f020838925984df345c5512ff32e37120b644512b1d9d4fecf0fd30639ca90fc6cf334a86770d536 +81b43614f1c28aa3713a309a88a782fb2bdfc4261dd52ddc204687791a40cf5fd6a263a8179388596582cccf0162efc2 +a9f3a8b76912deb61d966c75daf5ddb868702ebec91bd4033471c8e533183df548742a81a2671de5be63a502d827437d +902e2415077f063e638207dc7e14109652e42ab47caccd6204e2870115791c9defac5425fd360b37ac0f7bd8fe7011f8 +aa18e4fdc1381b59c18503ae6f6f2d6943445bd00dd7d4a2ad7e5adad7027f2263832690be30d456e6d772ad76f22350 +a348b40ba3ba7d81c5d4631f038186ebd5e5f314f1ea737259151b07c3cc8cf0c6ed4201e71bcc1c22fefda81a20cde6 +aa1306f7ac1acbfc47dc6f7a0cb6d03786cec8c8dc8060388ccda777bca24bdc634d03e53512c23dba79709ff64f8620 +818ccfe46e700567b7f3eb400e5a35f6a5e39b3db3aa8bc07f58ace35d9ae5a242faf8dbccd08d9a9175bbce15612155 +b7e3da2282b65dc8333592bb345a473f03bd6df69170055fec60222de9897184536bf22b9388b08160321144d0940279 +a4d976be0f0568f4e57de1460a1729129252b44c552a69fceec44e5b97c96c711763360d11f9e5bf6d86b4976bf40d69 +85d185f0397c24c2b875b09b6328a23b87982b84ee880f2677a22ff4c9a1ba9f0fea000bb3f7f66375a00d98ebafce17 +b4ccbb8c3a2606bd9b87ce022704663af71d418351575f3b350d294f4efc68c26f9a2ce49ff81e6ff29c3b63d746294e +93ffd3265fddb63724dfde261d1f9e22f15ecf39df28e4d89e9fea03221e8e88b5dd9b77628bacaa783c6f91802d47cc +b1fd0f8d7a01378e693da98d03a2d2fda6b099d03454b6f2b1fa6472ff6bb092751ce6290059826b74ac0361eab00e1e +a89f440c71c561641589796994dd2769616b9088766e983c873fae0716b95c386c8483ab8a4f367b6a68b72b7456dd32 +af4fe92b01d42d03dd5d1e7fa55e96d4bbcb7bf7d4c8c197acd16b3e0f3455807199f683dcd263d74547ef9c244b35cc +a8227f6e0a344dfe76bfbe7a1861be32c4f4bed587ccce09f9ce2cf481b2dda8ae4f566154bc663d15f962f2d41761bd +a7b361663f7495939ed7f518ba45ea9ff576c4e628995b7aea026480c17a71d63fc2c922319f0502eb7ef8f14a406882 +8ddcf382a9f39f75777160967c07012cfa89e67b19714a7191f0c68eaf263935e5504e1104aaabd0899348c972a8d3c6 +98c95b9f6f5c91f805fb185eedd06c6fc4457d37dd248d0be45a6a168a70031715165ea20606245cbdf8815dc0ac697f +805b44f96e001e5909834f70c09be3efcd3b43632bcac5b6b66b6d227a03a758e4b1768ce2a723045681a1d34562aaeb +b0e81b07cdc45b3dca60882676d9badb99f25c461b7efe56e3043b80100bb62d29e1873ae25eb83087273160ece72a55 +b0c53f0abe78ee86c7b78c82ae1f7c070bb0b9c45c563a8b3baa2c515d482d7507bb80771e60b38ac13f78b8af92b4a9 +a7838ef6696a9e4d2e5dfd581f6c8d6a700467e8fd4e85adabb5f7a56f514785dd4ab64f6f1b48366f7d94728359441b +88c76f7700a1d23c30366a1d8612a796da57b2500f97f88fdf2d76b045a9d24e7426a8ffa2f4e86d3046937a841dad58 +ad8964baf98c1f02e088d1d9fcb3af6b1dfa44cdfe0ed2eae684e7187c33d3a3c28c38e8f4e015f9c04d451ed6f85ff6 +90e9d00a098317ececaa9574da91fc149eda5b772dedb3e5a39636da6603aa007804fa86358550cfeff9be5a2cb7845e +a56ff4ddd73d9a6f5ab23bb77efa25977917df63571b269f6a999e1ad6681a88387fcc4ca3b26d57badf91b236503a29 +97ad839a6302c410a47e245df84c01fb9c4dfef86751af3f9340e86ff8fc3cd52fa5ff0b9a0bd1d9f453e02ca80658a6 +a4c8c44cbffa804129e123474854645107d1f0f463c45c30fd168848ebea94880f7c0c5a45183e9eb837f346270bdb35 +a72e53d0a1586d736e86427a93569f52edd2f42b01e78aee7e1961c2b63522423877ae3ac1227a2cf1e69f8e1ff15bc3 +8559f88a7ef13b4f09ac82ae458bbae6ab25671cfbf52dae7eac7280d6565dd3f0c3286aec1a56a8a16dc3b61d78ce47 +8221503f4cdbed550876c5dc118a3f2f17800c04e8be000266633c83777b039a432d576f3a36c8a01e8fd18289ebc10b +99bfbe5f3e46d4d898a578ba86ed26de7ed23914bd3bcdf3c791c0bcd49398a52419077354a5ab75cea63b6c871c6e96 +aa134416d8ff46f2acd866c1074af67566cfcf4e8be8d97329dfa0f603e1ff208488831ce5948ac8d75bfcba058ddcaa +b02609d65ebfe1fe8e52f21224a022ea4b5ea8c1bd6e7b9792eed8975fc387cdf9e3b419b8dd5bcce80703ab3a12a45f +a4f14798508698fa3852e5cac42a9db9797ecee7672a54988aa74037d334819aa7b2ac7b14efea6b81c509134a6b7ad2 +884f01afecbcb987cb3e7c489c43155c416ed41340f61ecb651d8cba884fb9274f6d9e7e4a46dd220253ae561614e44c +a05523c9e71dce1fe5307cc71bd721feb3e1a0f57a7d17c7d1c9fb080d44527b7dbaa1f817b1af1c0b4322e37bc4bb1e +8560aec176a4242b39f39433dd5a02d554248c9e49d3179530815f5031fee78ba9c71a35ceeb2b9d1f04c3617c13d8f0 +996aefd402748d8472477cae76d5a2b92e3f092fc834d5222ae50194dd884c9fb8b6ed8e5ccf8f6ed483ddbb4e80c747 +8fd09900320000cbabc40e16893e2fcf08815d288ec19345ad7b6bb22f7d78a52b6575a3ca1ca2f8bc252d2eafc928ec +939e51f73022bc5dc6862a0adf8fb8a3246b7bfb9943cbb4b27c73743926cc20f615a036c7e5b90c80840e7f1bfee0e7 +a0a6258700cadbb9e241f50766573bf9bdb7ad380b1079dc3afb4054363d838e177b869cad000314186936e40359b1f2 +972699a4131c8ed27a2d0e2104d54a65a7ff1c450ad9da3a325c662ab26869c21b0a84d0700b98c8b5f6ce3b746873d7 +a454c7fe870cb8aa6491eafbfb5f7872d6e696033f92e4991d057b59d70671f2acdabef533e229878b60c7fff8f748b1 +a167969477214201f09c79027b10221e4707662e0c0fde81a0f628249f2f8a859ce3d30a7dcc03b8ecca8f7828ad85c7 +8ff6b7265175beb8a63e1dbf18c9153fb2578c207c781282374f51b40d57a84fd2ef2ea2b9c6df4a54646788a62fd17f +a3d7ebeccde69d73d8b3e76af0da1a30884bb59729503ff0fb0c3bccf9221651b974a6e72ea33b7956fc3ae758226495 +b71ef144c9a98ce5935620cb86c1590bd4f48e5a2815d25c0cdb008fde628cf628c31450d3d4f67abbfeb16178a74cfd +b5e0a16d115134f4e2503990e3f2035ed66b9ccf767063fe6747870d97d73b10bc76ed668550cb82eedc9a2ca6f75524 +b30ffaaf94ee8cbc42aa2c413175b68afdb207dbf351fb20be3852cb7961b635c22838da97eaf43b103aff37e9e725cc +98aa7d52284f6c1f22e272fbddd8c8698cf8f5fbb702d5de96452141fafb559622815981e50b87a72c2b1190f59a7deb +81fbacda3905cfaf7780bb4850730c44166ed26a7c8d07197a5d4dcd969c09e94a0461638431476c16397dd7bdc449f9 +95e47021c1726eac2e5853f570d6225332c6e48e04c9738690d53e07c6b979283ebae31e2af1fc9c9b3e59f87e5195b1 +ac024a661ba568426bb8fce21780406537f518075c066276197300841e811860696f7588188bc01d90bace7bc73d56e3 +a4ebcaf668a888dd404988ab978594dee193dad2d0aec5cdc0ccaf4ec9a7a8228aa663db1da8ddc52ec8472178e40c32 +a20421b8eaf2199d93b083f2aff37fb662670bd18689d046ae976d1db1fedd2c2ff897985ecc6277b396db7da68bcb27 +8bc33d4b40197fd4d49d1de47489d10b90d9b346828f53a82256f3e9212b0cbc6930b895e879da9cec9fedf026aadb3e +aaafdd1bec8b757f55a0433eddc0a39f818591954fd4e982003437fcceb317423ad7ee74dbf17a2960380e7067a6b4e2 +aad34277ebaed81a6ec154d16736866f95832803af28aa5625bf0461a71d02b1faba02d9d9e002be51c8356425a56867 +976e9c8b150d08706079945bd0e84ab09a648ecc6f64ded9eb5329e57213149ae409ae93e8fbd8eda5b5c69f5212b883 +8097fae1653247d2aed4111533bc378171d6b2c6d09cbc7baa9b52f188d150d645941f46d19f7f5e27b7f073c1ebd079 +83905f93b250d3184eaba8ea7d727c4464b6bdb027e5cbe4f597d8b9dc741dcbea709630bd4fd59ce24023bec32fc0f3 +8095030b7045cff28f34271386e4752f9a9a0312f8df75de4f424366d78534be2b8e1720a19cb1f9a2d21105d790a225 +a7b7b73a6ae2ed1009c49960374b0790f93c74ee03b917642f33420498c188a169724945a975e5adec0a1e83e07fb1b2 +856a41c54df393b6660b7f6354572a4e71c8bfca9cabaffb3d4ef2632c015e7ee2bc10056f3eccb3dbed1ad17d939178 +a8f7a55cf04b38cd4e330394ee6589da3a07dc9673f74804fdf67b364e0b233f14aec42e783200a2e4666f7c5ff62490 +82c529f4e543c6bca60016dc93232c115b359eaee2798a9cf669a654b800aafe6ab4ba58ea8b9cdda2b371c8d62fa845 +8caab020c1baddce77a6794113ef1dfeafc5f5000f48e97f4351b588bf02f1f208101745463c480d37f588d5887e6d8c +8fa91b3cc400f48b77b6fd77f3b3fbfb3f10cdff408e1fd22d38f77e087b7683adad258804409ba099f1235b4b4d6fea +8aa02787663d6be9a35677d9d8188b725d5fcd770e61b11b64e3def8808ea5c71c0a9afd7f6630c48634546088fcd8e2 +b5635b7b972e195cab878b97dea62237c7f77eb57298538582a330b1082f6207a359f2923864630136d8b1f27c41b9aa +8257bb14583551a65975946980c714ecd6e5b629672bb950b9caacd886fbd22704bc9e3ba7d30778adab65dc74f0203a +ab5fe1cd12634bfa4e5c60d946e2005cbd38f1063ec9a5668994a2463c02449a0a185ef331bd86b68b6e23a8780cb3ba +a7d3487da56cda93570cc70215d438204f6a2709bfb5fda6c5df1e77e2efc80f4235c787e57fbf2c74aaff8cbb510a14 +b61cff7b4c49d010e133319fb828eb900f8a7e55114fc86b39c261a339c74f630e1a7d7e1350244ada566a0ff3d46c4b +8d4d1d55d321d278db7a85522ccceca09510374ca81d4d73e3bb5249ace7674b73900c35a531ec4fa6448fabf7ad00dc +966492248aee24f0f56c8cfca3c8ec6ba3b19abb69ae642041d4c3be8523d22c65c4dafcab4c58989ccc4e0bd2f77919 +b20c320a90cb220b86e1af651cdc1e21315cd215da69f6787e28157172f93fc8285dcd59b039c626ed8ca4633cba1a47 +aae9e6b22f018ceb5c0950210bb8182cb8cb61014b7e14581a09d36ebd1bbfebdb2b82afb7fdb0cf75e58a293d9c456d +875547fb67951ad37b02466b79f0c9b985ccbc500cfb431b17823457dc79fb9597ec42cd9f198e15523fcd88652e63a4 +92afce49773cb2e20fb21e4f86f18e0959ebb9c33361547ddb30454ee8e36b1e234019cbdca0e964cb292f7f77df6b90 +8af85343dfe1821464c76ba11c216cbef697b5afc69c4d821342e55afdac047081ec2e3f7b09fc14b518d9a23b78c003 +b7de4a1648fd63f3a918096ea669502af5357438e69dac77cb8102b6e6c15c76e033cfaa80dafc806e535ede5c1a20aa +ac80e9b545e8bd762951d96c9ce87f629d01ffcde07efc2ef7879ca011f1d0d8a745abf26c9d452541008871304fac00 +a4cf0f7ed724e481368016c38ea5816698a5f68eb21af4d3c422d2ba55f96a33e427c2aa40de1b56a7cfac7f7cf43ab0 +899b0a678bb2db2cae1b44e75a661284844ebcdd87abf308fedeb2e4dbe5c5920c07db4db7284a7af806a2382e8b111a +af0588a2a4afce2b1b13c1230816f59e8264177e774e4a341b289a101dcf6af813638fed14fb4d09cb45f35d5d032609 +a4b8df79e2be76e9f5fc5845f06fe745a724cf37c82fcdb72719b77bdebea3c0e763f37909373e3a94480cc5e875cba0 +83e42c46d88930c8f386b19fd999288f142d325e2ebc86a74907d6d77112cb0d449bc511c95422cc810574031a8cbba9 +b5e39534070de1e5f6e27efbdd3dc917d966c2a9b8cf2d893f964256e95e954330f2442027dc148c776d63a95bcde955 +958607569dc28c075e658cd4ae3927055c6bc456eef6212a6fea8205e48ed8777a8064f584cda38fe5639c371e2e7fba +812adf409fa63575113662966f5078a903212ffb65c9b0bbe62da0f13a133443a7062cb8fd70f5e5dd5559a32c26d2c8 +a679f673e5ce6a3cce7fa31f22ee3785e96bcb55e5a776e2dd3467bef7440e3555d1a9b87cb215e86ee9ed13a090344b +afedbb34508b159eb25eb2248d7fe328f86ef8c7d84c62d5b5607d74aae27cc2cc45ee148eb22153b09898a835c58df4 +b75505d4f6b67d31e665cfaf5e4acdb5838ae069166b7fbcd48937c0608a59e40a25302fcc1873d2e81c1782808c70f0 +b62515d539ec21a155d94fc00ea3c6b7e5f6636937bce18ed5b618c12257fb82571886287fd5d1da495296c663ebc512 +ab8e1a9446bbdd588d1690243b1549d230e6149c28f59662b66a8391a138d37ab594df38e7720fae53217e5c3573b5be +b31e8abf4212e03c3287bb2c0a153065a7290a16764a0bac8f112a72e632185a654bb4e88fdd6053e6c7515d9719fadb +b55165477fe15b6abd2d0f4fddaa9c411710dcc4dd712daba3d30e303c9a3ee5415c256f9dc917ecf18c725b4dbab059 +a0939d4f57cacaae549b78e87cc234de4ff6a35dc0d9cd5d7410abc30ebcd34c135e008651c756e5a9d2ca79c40ef42b +8cf10e50769f3443340844aad4d56ec790850fed5a41fcbd739abac4c3015f0a085a038fbe7fae9f5ad899cce5069f6b +924055e804d82a99ea4bb160041ea4dc14b568abf379010bc1922fde5d664718c31d103b8b807e3a1ae809390e708c73 +8ec0f9d26f71b0f2e60a179e4fd1778452e2ffb129d50815e5d7c7cb9415fa69ae5890578086e8ef6bfde35ad2a74661 +98c7f12b15ec4426b59f737f73bf5faea4572340f4550b7590dfb7f7ffedb2372e3e555977c63946d579544c53210ad0 +8a935f7a955c78f69d66f18eee0092e5e833fa621781c9581058e219af4d7ceee48b84e472e159dda6199715fb2f9acf +b78d4219f95a2dbfaa7d0c8a610c57c358754f4f43c2af312ab0fe8f10a5f0177e475332fb8fd23604e474fc2abeb051 +8d086a14803392b7318c28f1039a17e3cfdcece8abcaca3657ec3d0ac330842098a85c0212f889fabb296dfb133ce9aa +a53249f417aac82f2c2a50c244ce21d3e08a5e5a8bd33bec2a5ab0d6cd17793e34a17edfa3690899244ce201e2fb9986 +8619b0264f9182867a1425be514dc4f1ababc1093138a728a28bd7e4ecc99b9faaff68c23792264bc6e4dce5f52a5c52 +8c171edbbbde551ec19e31b2091eb6956107dd9b1f853e1df23bff3c10a3469ac77a58335eee2b79112502e8e163f3de +a9d19ec40f0ca07c238e9337c6d6a319190bdba2db76fb63902f3fb459aeeb50a1ac30db5b25ee1b4201f3ca7164a7f4 +b9c6ec14b1581a03520b8d2c1fbbc31fb8ceaef2c0f1a0d0080b6b96e18442f1734bea7ef7b635d787c691de4765d469 +8cb437beb4cfa013096f40ccc169a713dc17afee6daa229a398e45fd5c0645a9ad2795c3f0cd439531a7151945d7064d +a6e8740cc509126e146775157c2eb278003e5bb6c48465c160ed27888ca803fa12eee1f6a8dd7f444f571664ed87fdc1 +b75c1fecc85b2732e96b3f23aefb491dbd0206a21d682aee0225838dc057d7ed3b576176353e8e90ae55663f79e986e4 +ad8d249b0aea9597b08358bce6c77c1fd552ef3fbc197d6a1cfe44e5e6f89b628b12a6fb04d5dcfcbacc51f46e4ae7bb +b998b2269932cbd58d04b8e898d373ac4bb1a62e8567484f4f83e224061bc0f212459f1daae95abdbc63816ae6486a55 +827988ef6c1101cddc96b98f4a30365ff08eea2471dd949d2c0a9b35c3bbfa8c07054ad1f4c88c8fbf829b20bb5a9a4f +8692e638dd60babf7d9f2f2d2ce58e0ac689e1326d88311416357298c6a2bffbfebf55d5253563e7b3fbbf5072264146 +a685d75b91aea04dbc14ab3c1b1588e6de96dae414c8e37b8388766029631b28dd860688079b12d09cd27f2c5af11adf +b57eced93eec3371c56679c259b34ac0992286be4f4ff9489d81cf9712403509932e47404ddd86f89d7c1c3b6391b28c +a1c8b4e42ebcbd8927669a97f1b72e236fb19249325659e72be7ddaaa1d9e81ca2abb643295d41a8c04a2c01f9c0efd7 +877c33de20d4ed31674a671ba3e8f01a316581e32503136a70c9c15bf0b7cb7b1cba6cd4eb641fad165fb3c3c6c235fd +a2a469d84ec478da40838f775d11ad38f6596eb41caa139cc190d6a10b5108c09febae34ffdafac92271d2e73c143693 +972f817caedb254055d52e963ed28c206848b6c4cfdb69dbc961c891f8458eaf582a6d4403ce1177d87bc2ea410ef60a +accbd739e138007422f28536381decc54bb6bd71d93edf3890e54f9ef339f83d2821697d1a4ac1f5a98175f9a9ecb9b5 +8940f8772e05389f823b62b3adc3ed541f91647f0318d7a0d3f293aeeb421013de0d0a3664ea53dd24e5fbe02d7efef6 +8ecce20f3ef6212edef07ec4d6183fda8e0e8cad2c6ccd0b325e75c425ee1faba00b5c26b4d95204238931598d78f49d +97cc72c36335bd008afbed34a3b0c7225933faba87f7916d0a6d2161e6f82e0cdcda7959573a366f638ca75d30e9dab1 +9105f5de8699b5bdb6bd3bb6cc1992d1eac23929c29837985f83b22efdda92af64d9c574aa9640475087201bbbe5fd73 +8ffb33c4f6d05c413b9647eb6933526a350ed2e4278ca2ecc06b0e8026d8dbe829c476a40e45a6df63a633090a3f82ef +8bfc6421fdc9c2d2aaa68d2a69b1a2728c25b84944cc3e6a57ff0c94bfd210d1cbf4ff3f06702d2a8257024d8be7de63 +a80e1dc1dddfb41a70220939b96dc6935e00b32fb8be5dff4eed1f1c650002ff95e4af481c43292e3827363b7ec4768a +96f714ebd54617198bd636ba7f7a7f8995a61db20962f2165078d9ed8ee764d5946ef3cbdc7ebf8435bb8d5dd4c1deac +8cdb0890e33144d66391d2ae73f5c71f5a861f72bc93bff6cc399fc25dd1f9e17d8772592b44593429718784802ac377 +8ccf9a7f80800ee770b92add734ed45a73ecc31e2af0e04364eefc6056a8223834c7c0dc9dfc52495bdec6e74ce69994 +aa0875f423bd68b5f10ba978ddb79d3b96ec093bfbac9ff366323193e339ed7c4578760fb60f60e93598bdf1e5cc4995 +a9214f523957b59c7a4cb61a40251ad72aba0b57573163b0dc0f33e41d2df483fb9a1b85a5e7c080e9376c866790f8cb +b6224b605028c6673a536cc8ff9aeb94e7a22e686fda82cf16068d326469172f511219b68b2b3affb7933af0c1f80d07 +b6d58968d8a017c6a34e24c2c09852f736515a2c50f37232ac6b43a38f8faa7572cc31dade543b594b61b5761c4781d0 +8a97cefe5120020c38deeb861d394404e6c993c6cbd5989b6c9ebffe24f46ad11b4ba6348e2991cbf3949c28cfc3c99d +95bf046f8c3a9c0ce2634be4de3713024daec3fc4083e808903b25ce3ac971145af90686b451efcc72f6b22df0216667 +a6a4e2f71b8fa28801f553231eff2794c0f10d12e7e414276995e21195abc9c2983a8997e41af41e78d19ff6fbb2680b +8e5e62a7ca9c2f58ebaab63db2ff1fb1ff0877ae94b7f5e2897f273f684ae639dff44cc65718f78a9c894787602ab26a +8542784383eec4f565fcb8b9fc2ad8d7a644267d8d7612a0f476fc8df3aff458897a38003d506d24142ad18f93554f2b +b7db68ba4616ea072b37925ec4fb39096358c2832cc6d35169e032326b2d6614479f765ae98913c267105b84afcb9bf2 +8b31dbb9457d23d416c47542c786e07a489af35c4a87dadb8ee91bea5ac4a5315e65625d78dad2cf8f9561af31b45390 +a8545a1d91ac17257732033d89e6b7111db8242e9c6ebb0213a88906d5ef407a2c6fdb444e29504b06368b6efb4f4839 +b1bd85d29ebb28ccfb05779aad8674906b267c2bf8cdb1f9a0591dd621b53a4ee9f2942687ee3476740c0b4a7621a3ae +a2b54534e152e46c50d91fff03ae9cd019ff7cd9f4168b2fe7ac08ef8c3bbc134cadd3f9d6bd33d20ae476c2a8596c8a +b19b571ff4ae3e9f5d95acda133c455e72c9ea9973cae360732859836c0341c4c29ab039224dc5bc3deb824e031675d8 +940b5f80478648bac025a30f3efeb47023ce20ee98be833948a248bca6979f206bb28fc0f17b90acf3bb4abd3d14d731 +8f106b40588586ac11629b96d57808ad2808915d89539409c97414aded90b4ff23286a692608230a52bff696055ba5d6 +ae6bda03aa10da3d2abbc66d764ca6c8d0993e7304a1bdd413eb9622f3ca1913baa6da1e9f4f9e6cf847f14f44d6924d +a18e7796054a340ef826c4d6b5a117b80927afaf2ebd547794c400204ae2caf277692e2eabb55bc2f620763c9e9da66d +8d2d25180dc2c65a4844d3e66819ccfcf48858f0cc89e1c77553b463ec0f7feb9a4002ce26bc618d1142549b9850f232 +863f413a394de42cc8166c1c75d513b91d545fff1de6b359037a742c70b008d34bf8e587afa2d62c844d0c6f0ea753e7 +83cd0cf62d63475e7fcad18a2e74108499cdbf28af2113cfe005e3b5887794422da450b1944d0a986eb7e1f4c3b18f25 +b4f8b350a6d88fea5ab2e44715a292efb12eb52df738c9b2393da3f1ddee68d0a75b476733ccf93642154bceb208f2b8 +b3f52aaa4cd4221cb9fc45936cc67fd3864bf6d26bf3dd86aa85aa55ecfc05f5e392ecce5e7cf9406b4b1c4fce0398c8 +b33137084422fb643123f40a6df2b498065e65230fc65dc31791c330e898c51c3a65ff738930f32c63d78f3c9315f85b +91452bfa75019363976bb7337fe3a73f1c10f01637428c135536b0cdc7da5ce558dae3dfc792aa55022292600814a8ef +ad6ba94c787cd4361ca642c20793ea44f1f127d4de0bb4a77c7fbfebae0fcadbf28e2cb6f0c12c12a07324ec8c19761d +890aa6248b17f1501b0f869c556be7bf2b1d31a176f9978bb97ab7a6bd4138eed32467951c5ef1871944b7f620542f43 +82111db2052194ee7dd22ff1eafffac0443cf969d3762cceae046c9a11561c0fdce9c0711f88ac01d1bed165f8a7cee3 +b1527b71df2b42b55832f72e772a466e0fa05743aacc7814f4414e4bcc8d42a4010c9e0fd940e6f254cafedff3cd6543 +922370fa49903679fc565f09c16a5917f8125e72acfeb060fcdbadbd1644eb9f4016229756019c93c6d609cda5d5d174 +aa4c7d98a96cab138d2a53d4aee8ebff6ef903e3b629a92519608d88b3bbd94de5522291a1097e6acf830270e64c8ee1 +b3dc21608a389a72d3a752883a382baaafc61ecc44083b832610a237f6a2363f24195acce529eb4aed4ef0e27a12b66e +94619f5de05e07b32291e1d7ab1d8b7337a2235e49d4fb5f3055f090a65e932e829efa95db886b32b153bdd05a53ec8c +ade1e92722c2ffa85865d2426fb3d1654a16477d3abf580cfc45ea4b92d5668afc9d09275d3b79283e13e6b39e47424d +b7201589de7bed094911dd62fcd25c459a8e327ac447b69f541cdba30233063e5ddffad0b67e9c3e34adcffedfd0e13d +809d325310f862d6549e7cb40f7e5fc9b7544bd751dd28c4f363c724a0378c0e2adcb5e42ec8f912f5f49f18f3365c07 +a79c20aa533de7a5d671c99eb9eb454803ba54dd4f2efa3c8fec1a38f8308e9905c71e9282955225f686146388506ff6 +a85eeacb5e8fc9f3ed06a3fe2dc3108ab9f8c5877b148c73cf26e4e979bf5795edbe2e63a8d452565fd1176ed40402b2 +97ef55662f8a1ec0842b22ee21391227540adf7708f491436044f3a2eb18c471525e78e1e14fa292507c99d74d7437c6 +93110d64ed5886f3d16ce83b11425576a3a7a9bb831cd0de3f9a0b0f2270a730d68136b4ef7ff035ede004358f419b5c +ac9ed0a071517f0ae4f61ce95916a90ba9a77a3f84b0ec50ef7298acdcd44d1b94525d191c39d6bd1bb68f4471428760 +98abd6a02c7690f5a339adf292b8c9368dfc12e0f8069cf26a5e0ce54b4441638f5c66ea735142f3c28e00a0024267e6 +b51efb73ba6d44146f047d69b19c0722227a7748b0e8f644d0fc9551324cf034c041a2378c56ce8b58d06038fb8a78de +8f115af274ef75c1662b588b0896b97d71f8d67986ae846792702c4742ab855952865ce236b27e2321967ce36ff93357 +b3c4548f14d58b3ab03c222da09e4381a0afe47a72d18d50a94e0008797f78e39e99990e5b4757be62310d400746e35a +a9b1883bd5f31f909b8b1b6dcb48c1c60ed20aa7374b3ffa7f5b2ed036599b5bef33289d23c80a5e6420d191723b92f7 +85d38dffd99487ae5bb41ab4a44d80a46157bbbe8ef9497e68f061721f74e4da513ccc3422936b059575975f6787c936 +adf870fcb96e972c033ab7a35d28ae79ee795f82bc49c3bd69138f0e338103118d5529c53f2d72a9c0d947bf7d312af2 +ab4c7a44e2d9446c6ff303eb49aef0e367a58b22cc3bb27b4e69b55d1d9ee639c9234148d2ee95f9ca8079b1457d5a75 +a386420b738aba2d7145eb4cba6d643d96bda3f2ca55bb11980b318d43b289d55a108f4bc23a9606fb0bccdeb3b3bb30 +847020e0a440d9c4109773ecca5d8268b44d523389993b1f5e60e541187f7c597d79ebd6e318871815e26c96b4a4dbb1 +a530aa7e5ca86fcd1bec4b072b55cc793781f38a666c2033b510a69e110eeabb54c7d8cbcb9c61fee531a6f635ffa972 +87364a5ea1d270632a44269d686b2402da737948dac27f51b7a97af80b66728b0256547a5103d2227005541ca4b7ed04 +8816fc6e16ea277de93a6d793d0eb5c15e9e93eb958c5ef30adaf8241805adeb4da8ce19c3c2167f971f61e0b361077d +8836a72d301c42510367181bb091e4be377777aed57b73c29ef2ce1d475feedd7e0f31676284d9a94f6db01cc4de81a2 +b0d9d8b7116156d9dde138d28aa05a33e61f8a85839c1e9071ccd517b46a5b4b53acb32c2edd7150c15bc1b4bd8db9e3 +ae931b6eaeda790ba7f1cd674e53dc87f6306ff44951fa0df88d506316a5da240df9794ccbd7215a6470e6b31c5ea193 +8c6d5bdf87bd7f645419d7c6444e244fe054d437ed1ba0c122fde7800603a5fadc061e5b836cb22a6cfb2b466f20f013 +90d530c6d0cb654999fa771b8d11d723f54b8a8233d1052dc1e839ea6e314fbed3697084601f3e9bbb71d2b4eaa596df +b0d341a1422588c983f767b1ed36c18b141774f67ef6a43cff8e18b73a009da10fc12120938b8bba27f225bdfd3138f9 +a131b56f9537f460d304e9a1dd75702ace8abd68cb45419695cb8dee76998139058336c87b7afd6239dc20d7f8f940cc +aa6c51fa28975f709329adee1bbd35d49c6b878041841a94465e8218338e4371f5cb6c17f44a63ac93644bf28f15d20f +88440fb584a99ebd7f9ea04aaf622f6e44e2b43bbb49fb5de548d24a238dc8f26c8da2ccf03dd43102bda9f16623f609 +9777b8695b790e702159a4a750d5e7ff865425b95fa0a3c15495af385b91c90c00a6bd01d1b77bffe8c47d01baae846f +8b9d764ece7799079e63c7f01690c8eff00896a26a0d095773dea7a35967a8c40db7a6a74692f0118bf0460c26739af4 +85808c65c485520609c9e61fa1bb67b28f4611d3608a9f7a5030ee61c3aa3c7e7dc17fff48af76b4aecee2cb0dbd22ac +ad2783a76f5b3db008ef5f7e67391fda4e7e36abde6b3b089fc4835b5c339370287935af6bd53998bed4e399eda1136d +96f18ec03ae47c205cc4242ca58e2eff185c9dca86d5158817e2e5dc2207ab84aadda78725f8dc080a231efdc093b940 +97de1ab6c6cc646ae60cf7b86df73b9cf56cc0cd1f31b966951ebf79fc153531af55ca643b20b773daa7cab784b832f7 +870ba266a9bfa86ef644b1ef025a0f1b7609a60de170fe9508de8fd53170c0b48adb37f19397ee8019b041ce29a16576 +ad990e888d279ac4e8db90619d663d5ae027f994a3992c2fbc7d262b5990ae8a243e19157f3565671d1cb0de17fe6e55 +8d9d5adcdd94c5ba3be4d9a7428133b42e485f040a28d16ee2384758e87d35528f7f9868de9bd23d1a42a594ce50a567 +85a33ed75d514ece6ad78440e42f7fcdb59b6f4cff821188236d20edae9050b3a042ce9bc7d2054296e133d033e45022 +92afd2f49a124aaba90de59be85ff269457f982b54c91b06650c1b8055f9b4b0640fd378df02a00e4fc91f7d226ab980 +8c0ee09ec64bd831e544785e3d65418fe83ed9c920d9bb4d0bf6dd162c1264eb9d6652d2def0722e223915615931581c +8369bedfa17b24e9ad48ebd9c5afea4b66b3296d5770e09b00446c5b0a8a373d39d300780c01dcc1c6752792bccf5fd0 +8b9e960782576a59b2eb2250d346030daa50bbbec114e95cdb9e4b1ba18c3d34525ae388f859708131984976ca439d94 +b682bface862008fea2b5a07812ca6a28a58fd151a1d54c708fc2f8572916e0d678a9cb8dc1c10c0470025c8a605249e +a38d5e189bea540a824b36815fc41e3750760a52be0862c4cac68214febdc1a754fb194a7415a8fb7f96f6836196d82a +b9e7fbda650f18c7eb8b40e42cc42273a7298e65e8be524292369581861075c55299ce69309710e5b843cb884de171bd +b6657e5e31b3193874a1bace08f42faccbd3c502fb73ad87d15d18a1b6c2a146f1baa929e6f517db390a5a47b66c0acf +ae15487312f84ed6265e4c28327d24a8a0f4d2d17d4a5b7c29b974139cf93223435aaebe3af918f5b4bb20911799715f +8bb4608beb06bc394e1a70739b872ce5a2a3ffc98c7547bf2698c893ca399d6c13686f6663f483894bccaabc3b9c56ad +b58ac36bc6847077584308d952c5f3663e3001af5ecf2e19cb162e1c58bd6c49510205d453cffc876ca1dc6b8e04a578 +924f65ced61266a79a671ffb49b300f0ea44c50a0b4e3b02064faa99fcc3e4f6061ea8f38168ab118c5d47bd7804590e +8d67d43b8a06b0ff4fafd7f0483fa9ed1a9e3e658a03fb49d9d9b74e2e24858dc1bed065c12392037b467f255d4e5643 +b4d4f87813125a6b355e4519a81657fa97c43a6115817b819a6caf4823f1d6a1169683fd68f8d025cdfa40ebf3069acb +a7fd4d2c8e7b59b8eed3d4332ae94b77a89a2616347402f880bc81bde072220131e6dbec8a605be3a1c760b775375879 +8d4a7d8fa6f55a30df37bcf74952e2fa4fd6676a2e4606185cf154bdd84643fd01619f8fb8813a564f72e3f574f8ce30 +8086fb88e6260e9a9c42e9560fde76315ff5e5680ec7140f2a18438f15bc2cc7d7d43bfb5880b180b738c20a834e6134 +916c4c54721de03934fee6f43de50bb04c81f6f8dd4f6781e159e71c40c60408aa54251d457369d133d4ba3ed7c12cb4 +902e5bf468f11ed9954e2a4a595c27e34abe512f1d6dc08bbca1c2441063f9af3dc5a8075ab910a10ff6c05c1c644a35 +a1302953015e164bf4c15f7d4d35e3633425a78294406b861675667eec77765ff88472306531e5d3a4ec0a2ff0dd6a9e +87874461df3c9aa6c0fa91325576c0590f367075f2f0ecfeb34afe162c04c14f8ce9d608c37ac1adc8b9985bc036e366 +84b50a8a61d3cc609bfb0417348133e698fe09a6d37357ce3358de189efcf35773d78c57635c2d26c3542b13cc371752 +acaed2cff8633d12c1d12bb7270c54d65b0b0733ab084fd47f81d0a6e1e9b6f300e615e79538239e6160c566d8bb8d29 +889e6a0e136372ca4bac90d1ab220d4e1cad425a710e8cdd48b400b73bb8137291ceb36a39440fa84305783b1d42c72f +90952e5becec45b2b73719c228429a2c364991cf1d5a9d6845ae5b38018c2626f4308daa322cab1c72e0f6c621bb2b35 +8f5a97a801b6e9dcd66ccb80d337562c96f7914e7169e8ff0fda71534054c64bf2a9493bb830623d612cfe998789be65 +84f3df8b9847dcf1d63ca470dc623154898f83c25a6983e9b78c6d2d90a97bf5e622445be835f32c1e55e6a0a562ea78 +91d12095cd7a88e7f57f254f02fdb1a1ab18984871dead2f107404bcf8069fe68258c4e6f6ebd2477bddf738135400bb +b771a28bc04baef68604d4723791d3712f82b5e4fe316d7adc2fc01b935d8e644c06d59b83bcb542afc40ebafbee0683 +872f6341476e387604a7e93ae6d6117e72d164e38ebc2b825bc6df4fcce815004d7516423c190c1575946b5de438c08d +90d6b4aa7d40a020cdcd04e8b016d041795961a8e532a0e1f4041252131089114a251791bf57794cadb7d636342f5d1c +899023ba6096a181448d927fed7a0fe858be4eac4082a42e30b3050ee065278d72fa9b9d5ce3bc1372d4cbd30a2f2976 +a28f176571e1a9124f95973f414d5bdbf5794d41c3839d8b917100902ac4e2171eb940431236cec93928a60a77ede793 +838dbe5bcd29c4e465d02350270fa0036cd46f8730b13d91e77afb7f5ed16525d0021d3b2ae173a76c378516a903e0cb +8e105d012dd3f5d20f0f1c4a7e7f09f0fdd74ce554c3032e48da8cce0a77260d7d47a454851387770f5c256fa29bcb88 +8f4df0f9feeb7a487e1d138d13ea961459a6402fd8f8cabb226a92249a0d04ded5971f3242b9f90d08da5ff66da28af6 +ad1cfda4f2122a20935aa32fb17c536a3653a18617a65c6836700b5537122af5a8206befe9eaea781c1244c43778e7f1 +832c6f01d6571964ea383292efc8c8fa11e61c0634a25fa180737cc7ab57bc77f25e614aac9a2a03d98f27b3c1c29de2 +903f89cc13ec6685ac7728521898781fecb300e9094ef913d530bf875c18bcc3ceed7ed51e7b482d45619ab4b025c2e9 +a03c474bb915aad94f171e8d96f46abb2a19c9470601f4c915512ec8b9e743c3938450a2a5b077b4618b9df8809e1dc1 +83536c8456f306045a5f38ae4be2e350878fa7e164ea408d467f8c3bc4c2ee396bd5868008c089183868e4dfad7aa50b +88f26b4ea1b236cb326cd7ad7e2517ec8c4919598691474fe15d09cabcfc37a8d8b1b818f4d112432ee3a716b0f37871 +a44324e3fe96e9c12b40ded4f0f3397c8c7ee8ff5e96441118d8a6bfad712d3ac990b2a6a23231a8f691491ac1fd480f +b0de4693b4b9f932191a21ee88629964878680152a82996c0019ffc39f8d9369bbe2fe5844b68d6d9589ace54af947e4 +8e5d8ba948aea5fd26035351a960e87f0d23efddd8e13236cc8e4545a3dda2e9a85e6521efb8577e03772d3637d213d9 +93efc82d2017e9c57834a1246463e64774e56183bb247c8fc9dd98c56817e878d97b05f5c8d900acf1fbbbca6f146556 +8731176363ad7658a2862426ee47a5dce9434216cef60e6045fa57c40bb3ce1e78dac4510ae40f1f31db5967022ced32 +b10c9a96745722c85bdb1a693100104d560433d45b9ac4add54c7646a7310d8e9b3ca9abd1039d473ae768a18e489845 +a2ac374dfbb464bf850b4a2caf15b112634a6428e8395f9c9243baefd2452b4b4c61b0cb2836d8eae2d57d4900bf407e +b69fe3ded0c4f5d44a09a0e0f398221b6d1bf5dbb8bc4e338b93c64f1a3cac1e4b5f73c2b8117158030ec03787f4b452 +8852cdbaf7d0447a8c6f211b4830711b3b5c105c0f316e3a6a18dcfbb9be08bd6f4e5c8ae0c3692da08a2dfa532f9d5c +93bbf6d7432a7d98ade3f94b57bf9f4da9bc221a180a370b113066dd42601bb9e09edd79e2e6e04e00423399339eebda +a80941c391f1eeafc1451c59e4775d6a383946ff22997aeaadf806542ba451d3b0f0c6864eeba954174a296efe2c1550 +a045fe2bb011c2a2f71a0181a8f457a3078470fb74c628eab8b59aef69ffd0d649723bf74d6885af3f028bc5a104fb39 +b9d8c35911009c4c8cad64692139bf3fc16b78f5a19980790cb6a7aea650a25df4231a4437ae0c351676a7e42c16134f +94c79501ded0cfcbab99e1841abe4a00a0252b3870e20774c3da16c982d74c501916ec28304e71194845be6e3113c7ab +900a66418b082a24c6348d8644ddb1817df5b25cb33044a519ef47cc8e1f7f1e38d2465b7b96d32ed472d2d17f8414c6 +b26f45d393b8b2fcb29bdbb16323dc7f4b81c09618519ab3a39f8ee5bd148d0d9f3c0b5dfab55b5ce14a1cb9206d777b +aa1a87735fc493a80a96a9a57ca40a6d9c32702bfcaa9869ce1a116ae65d69cefe2f3e79a12454b4590353e96f8912b4 +a922b188d3d0b69b4e4ea2a2aa076566962844637da12c0832105d7b31dea4a309eee15d12b7a336be3ea36fcbd3e3b7 +8f3841fcf4105131d8c4d9885e6e11a46c448226401cf99356c291fadb864da9fa9d30f3a73c327f23f9fd99a11d633e +9791d1183fae270e226379af6c497e7da803ea854bb20afa74b253239b744c15f670ee808f708ede873e78d79a626c9a +a4cad52e3369491ada61bf28ada9e85de4516d21c882e5f1cd845bea9c06e0b2887b0c5527fcff6fc28acd3c04f0a796 +b9ac86a900899603452bd11a7892a9bfed8054970bfcbeaa8c9d1930db891169e38d6977f5258c25734f96c8462eee3b +a3a154c28e5580656a859f4efc2f5ebfa7eaa84ca40e3f134fa7865e8581586db74992dbfa4036aa252fba103773ddde +95cc2a0c1885a029e094f5d737e3ecf4d26b99036453a8773c77e360101f9f98676ee246f6f732a377a996702d55691f +842651bbe99720438d8d4b0218feb60481280c05beb17750e9ca0d8c0599a60f873b7fbdcc7d8835ba9a6d57b16eec03 +81ee54699da98f5620307893dcea8f64670609fa20e5622265d66283adeac122d458b3308c5898e6c57c298db2c8b24f +b97868b0b2bc98032d68352a535a1b341b9ff3c7af4e3a7f3ebc82d3419daa1b5859d6aedc39994939623c7cd878bd9b +b60325cd5d36461d07ef253d826f37f9ee6474a760f2fff80f9873d01fd2b57711543cdc8d7afa1c350aa753c2e33dea +8c205326c11d25a46717b780c639d89714c7736c974ae71287e3f4b02e6605ac2d9b4928967b1684f12be040b7bf2dd3 +95a392d82db51e26ade6c2ccd3396d7e40aff68fa570b5951466580d6e56dda51775dce5cf3a74a7f28c3cb2eb551c4d +8f2cc8071eb56dffb70bda6dd433b556221dc8bba21c53353c865f00e7d4d86c9e39f119ea9a8a12ef583e9a55d9a6b6 +9449a71af9672aaf8856896d7e3d788b22991a7103f75b08c0abbcc2bfe60fda4ed8ce502cea4511ff0ea52a93e81222 +857090ab9fdb7d59632d068f3cc8cf27e61f0d8322d30e6b38e780a1f05227199b4cd746aac1311c36c659ef20931f28 +98a891f4973e7d9aaf9ac70854608d4f7493dffc7e0987d7be9dd6029f6ea5636d24ef3a83205615ca1ff403750058e1 +a486e1365bbc278dd66a2a25d258dc82f46b911103cb16aab3945b9c95ae87b386313a12b566df5b22322ede0afe25ad +a9a1eb399ed95d396dccd8d1ac718043446f8b979ec62bdce51c617c97a312f01376ab7fb87d27034e5f5570797b3c33 +b7abc3858d7a74bb446218d2f5a037e0fae11871ed9caf44b29b69c500c1fa1dcfad64c9cdccc9d80d5e584f06213deb +8cfb09fe2e202faa4cebad932b1d35f5ca204e1c2a0c740a57812ac9a6792130d1312aabd9e9d4c58ca168bfebd4c177 +a90a305c2cd0f184787c6be596fa67f436afd1f9b93f30e875f817ac2aae8bdd2e6e656f6be809467e6b3ad84adb86b1 +80a9ef993c2b009ae172cc8f7ec036f5734cf4f4dfa06a7db4d54725e7fbfae5e3bc6f22687bdbb6961939d6f0c87537 +848ade1901931e72b955d7db1893f07003e1708ff5d93174bac5930b9a732640f0578839203e9b77eb27965c700032d3 +93fdf4697609c5ae9c33b9ca2f5f1af44abeb2b98dc4fdf732cf7388de086f410730dc384d9b7a7f447bb009653c8381 +89ce3fb805aea618b5715c0d22a9f46da696b6fa86794f56fdf1d44155a33d42daf1920bcbe36cbacf3cf4c92df9cbc7 +829ce2c342cf82aa469c65f724f308f7a750bd1494adc264609cd790c8718b8b25b5cab5858cf4ee2f8f651d569eea67 +af2f0cee7bf413204be8b9df59b9e4991bc9009e0d6dbe6815181df0ec2ca93ab8f4f3135b1c14d8f53d74bff0bd6f27 +b87998cecf7b88cde93d1779f10a521edd5574a2fbd240102978639ec57433ba08cdb53849038a329cebbe74657268d2 +a64542a1261a6ed3d720c2c3a802303aad8c4c110c95d0f12e05c1065e66f42da494792b6bfc5b9272363f3b1d457f58 +86a6fd042e4f282fadf07a4bfee03fc96a3aea49f7a00f52bf249a20f1ec892326855410e61f37fbb27d9305eb2fc713 +967ea5bc403b6db269682f7fd0df90659350d7e1aa66bc4fab4c9dfcd75ed0bba4b52f1cebc5f34dc8ba810793727629 +a52990f9f3b8616ce3cdc2c74cd195029e6a969753dcf2d1630438700e7d6ebde36538532b3525ac516f5f2ce9dd27a3 +a64f7ff870bab4a8bf0d4ef6f5c744e9bf1021ed08b4c80903c7ad318e80ba1817c3180cc45cb5a1cae1170f0241655f +b00f706fa4de1f663f021e8ad3d155e84ce6084a409374b6e6cd0f924a0a0b51bebaaaf1d228c77233a73b0a5a0df0e9 +8b882cc3bff3e42babdb96df95fb780faded84887a0a9bab896bef371cdcf169d909f5658649e93006aa3c6e1146d62e +9332663ef1d1dcf805c3d0e4ce7a07d9863fb1731172e766b3cde030bf81682cc011e26b773fb9c68e0477b4ae2cfb79 +a8aa8151348dbd4ef40aaeb699b71b4c4bfd3218560c120d85036d14f678f6736f0ec68e80ce1459d3d35feccc575164 +a16cd8b729768f51881c213434aa28301fa78fcb554ddd5f9012ee1e4eae7b5cb3dd88d269d53146dea92d10790faf0b +86844f0ef9d37142faf3b1e196e44fbe280a3ba4189aa05c356778cb9e3b388a2bff95eed305ada8769935c9974e4c57 +ae2eec6b328fccf3b47bcdac32901ac2744a51beb410b04c81dea34dee4912b619466a4f5e2780d87ecefaebbe77b46d +915df4c38d301c8a4eb2dc5b1ba0ffaad67cbb177e0a80095614e9c711f4ef24a4cef133f9d982a63d2a943ba6c8669d +ae6a2a4dedfc2d1811711a8946991fede972fdf2a389b282471280737536ffc0ac3a6d885b1f8bda0366eb0b229b9979 +a9b628c63d08b8aba6b1317f6e91c34b2382a6c85376e8ef2410a463c6796740ae936fc4e9e0737cb9455d1daa287bd8 +848e30bf7edf2546670b390d5cf9ab71f98fcb6add3c0b582cb34996c26a446dee5d1bde4fdcde4fc80c10936e117b29 +907d6096c7c8c087d1808dd995d5d2b9169b3768c3f433475b50c2e2bd4b082f4d543afd8b0b0ddffa9c66222a72d51d +a59970a2493b07339124d763ac9d793c60a03354539ecbcf6035bc43d1ea6e35718202ae6d7060b7d388f483d971573c +b9cfef2af9681b2318f119d8611ff6d9485a68d8044581b1959ab1840cbca576dbb53eec17863d2149966e9feb21122f +ad47271806161f61d3afa45cdfe2babceef5e90031a21779f83dc8562e6076680525b4970b2f11fe9b2b23c382768323 +8e425a99b71677b04fe044625d338811fbb8ee32368a424f6ab2381c52e86ee7a6cecedf777dc97181519d41c351bc22 +86b55b54d7adefc12954a9252ee23ae83efe8b5b4b9a7dc307904413e5d69868c7087a818b2833f9b004213d629be8ad +a14fda6b93923dd11e564ae4457a66f397741527166e0b16a8eb91c6701c244fd1c4b63f9dd3515193ec88fa6c266b35 +a9b17c36ae6cd85a0ed7f6cabc5b47dc8f80ced605db327c47826476dc1fb8f8669aa7a7dc679fbd4ee3d8e8b4bd6a6f +82a0829469c1458d959c821148f15dacae9ea94bf56c59a6ab2d4dd8b3d16d73e313b5a3912a6c1f131d73a8f06730c4 +b22d56d549a53eaef549595924bdb621ff807aa4513feedf3fdcbf7ba8b6b9cfa4481c2f67fc642db397a6b794a8b63a +974c59c24392e2cb9294006cbe3c52163e255f3bd0c2b457bdc68a6338e6d5b6f87f716854492f8d880a6b896ccf757c +b70d247ba7cad97c50b57f526c2ba915786e926a94e8f8c3eebc2e1be6f4255411b9670e382060049c8f4184302c40b2 +ad80201fe75ef21c3ddbd98cf23591e0d7a3ba1036dfe77785c32f44755a212c31f0ceb0a0b6f5ee9b6dc81f358d30c3 +8c656e841f9bb90b9a42d425251f3fdbc022a604d75f5845f479ed4be23e02aaf9e6e56cde351dd7449c50574818a199 +8b88dd3fa209d3063b7c5b058f7249ee9900fbc2287d16da61a0704a0a1d71e45d9c96e1cda7fdf9654534ec44558b22 +961da00cc8750bd84d253c08f011970ae1b1158ad6778e8ed943d547bceaf52d6d5a212a7de3bf2706688c4389b827d2 +a5dd379922549a956033e3d51a986a4b1508e575042b8eaa1df007aa77cf0b8c2ab23212f9c075702788fa9c53696133 +ac8fcfde3a349d1e93fc8cf450814e842005c545c4844c0401bc80e6b96cdb77f29285a14455e167c191d4f312e866cd +ac63d79c799783a8466617030c59dd5a8f92ee6c5204676fd8d881ce5f7f8663bdbeb0379e480ea9b6340ab0dc88e574 +805874fde19ce359041ae2bd52a39e2841acabfd31f965792f2737d7137f36d4e4722ede8340d8c95afa6af278af8acb +8d2f323a228aa8ba7b7dc1399138f9e6b41df1a16a7069003ab8104b8b68506a45141bc5fe66acf430e23e13a545190b +a1610c721a2d9af882bb6b39bea97cff1527a3aea041d25934de080214ae77c959e79957164440686d15ab301e897d4d +aba16d29a47fc36f12b654fde513896723e2c700c4190f11b26aa4011da57737ad717daa02794aa3246e4ae5f0b0cc3a +a406db2f15fdd135f346cc4846623c47edd195e80ba8c7cb447332095314d565e4040694ca924696bb5ee7f8996ea0ba +8b30e2cd9b47d75ba57b83630e40f832249af6c058d4f490416562af451993eec46f3e1f90bc4d389e4c06abd1b32a46 +aacf9eb7036e248e209adbfc3dd7ce386569ea9b312caa4b240726549db3c68c4f1c8cbf8ed5ea9ea60c7e57c9df3b8e +b20fcac63bf6f5ee638a42d7f89be847f348c085ddcbec3fa318f4323592d136c230495f188ef2022aa355cc2b0da6f9 +811eff750456a79ec1b1249d76d7c1547065b839d8d4aaad860f6d4528eb5b669473dcceeeea676cddbc3980b68461b7 +b52d14ae33f4ab422f953392ae76a19c618cc31afc96290bd3fe2fb44c954b5c92c4789f3f16e8793f2c0c1691ade444 +a7826dafeeba0db5b66c4dfcf2b17fd7b40507a5a53ac2e42942633a2cb30b95ba1739a6e9f3b7a0e0f1ec729bf274e2 +8acfd83ddf7c60dd7c8b20c706a3b972c65d336b8f9b3d907bdd8926ced271430479448100050b1ef17578a49c8fa616 +af0c69f65184bb06868029ad46f8465d75c36814c621ac20a5c0b06a900d59305584f5a6709683d9c0e4b6cd08d650a6 +b6cc8588191e00680ee6c3339bd0f0a17ad8fd7f4be57d5d7075bede0ea593a19e67f3d7c1a20114894ee5bfcab71063 +a82fd4f58635129dbb6cc3eb9391cf2d28400018b105fc41500fbbd12bd890b918f97d3d359c29dd3b4c4e34391dfab0 +92fc544ed65b4a3625cf03c41ddff7c039bc22d22c0d59dcc00efd5438401f2606adb125a1d5de294cca216ec8ac35a3 +906f67e4a32582b71f15940523c0c7ce370336935e2646bdaea16a06995256d25e99df57297e39d6c39535e180456407 +97510337ea5bbd5977287339197db55c60533b2ec35c94d0a460a416ae9f60e85cee39be82abeeacd5813cf54df05862 +87e6894643815c0ea48cb96c607266c5ee4f1f82ba5fe352fb77f9b6ed14bfc2b8e09e80a99ac9047dfcf62b2ae26795 +b6fd55dd156622ad7d5d51b7dde75e47bd052d4e542dd6449e72411f68275775c846dde301e84613312be8c7bce58b07 +b98461ac71f554b2f03a94e429b255af89eec917e208a8e60edf5fc43b65f1d17a20de3f31d2ce9f0cb573c25f2f4d98 +96f0dea40ca61cefbee41c4e1fe9a7d81fbe1f49bb153d083ab70f5d0488a1f717fd28cedcf6aa18d07cce2c62801898 +8d7c3ab310184f7dc34b6ce4684e4d29a31e77b09940448ea4daac730b7eb308063125d4dd229046cf11bfd521b771e0 +96f0564898fe96687918bbf0a6adead99cf72e3a35ea3347e124af9d006221f8e82e5a9d2fe80094d5e8d48e610f415e +ad50fcb92c2675a398cf07d4c40a579e44bf8d35f27cc330b57e54d5ea59f7d898af0f75dccfe3726e5471133d70f92b +828beed62020361689ae7481dd8f116902b522fb0c6c122678e7f949fdef70ead011e0e6bffd25678e388744e17cdb69 +8349decac1ca16599eee2efc95bcaabf67631107da1d34a2f917884bd70dfec9b4b08ab7bc4379d6c73b19c0b6e54fb8 +b2a6a2e50230c05613ace9e58bb2e98d94127f196f02d9dddc53c43fc68c184549ca12d713cb1b025d8260a41e947155 +94ff52181aadae832aed52fc3b7794536e2a31a21fc8be3ea312ca5c695750d37f08002f286b33f4023dba1e3253ecfa +a21d56153c7e5972ee9a319501be4faff199fdf09bb821ea9ce64aa815289676c00f105e6f00311b3a5b627091b0d0fc +a27a60d219f1f0c971db73a7f563b371b5c9fc3ed1f72883b2eac8a0df6698400c9954f4ca17d7e94e44bd4f95532afb +a2fc56fae99b1f18ba5e4fe838402164ce82f8a7f3193d0bbd360c2bac07c46f9330c4c7681ffb47074c6f81ee6e7ac6 +b748e530cd3afb96d879b83e89c9f1a444f54e55372ab1dcd46a0872f95ce8f49cf2363fc61be82259e04f555937ed16 +8bf8993e81080c7cbba1e14a798504af1e4950b2f186ab3335b771d6acaee4ffe92131ae9c53d74379d957cb6344d9cd +96774d0ef730d22d7ab6d9fb7f90b9ead44285219d076584a901960542756700a2a1603cdf72be4708b267200f6c36a9 +b47703c2ab17be1e823cc7bf3460db1d6760c0e33862c90ca058845b2ff234b0f9834ddba2efb2ee1770eb261e7d8ffd +84319e67c37a9581f8b09b5e4d4ae88d0a7fb4cbb6908971ab5be28070c3830f040b1de83ee663c573e0f2f6198640e4 +96811875fa83133e0b3c0e0290f9e0e28bca6178b77fdf5350eb19344d453dbd0d71e55a0ef749025a5a2ca0ad251e81 +81a423423e9438343879f2bfd7ee9f1c74ebebe7ce3cfffc8a11da6f040cc4145c3b527bd3cf63f9137e714dbcb474ef +b8c3535701ddbeec2db08e17a4fa99ba6752d32ece5331a0b8743676f421fcb14798afc7c783815484f14693d2f70db8 +81aee980c876949bf40782835eec8817d535f6f3f7e00bf402ddd61101fdcd60173961ae90a1cf7c5d060339a18c959d +87e67b928d97b62c49dac321ce6cb680233f3a394d4c9a899ac2e8db8ccd8e00418e66cdfd68691aa3cb8559723b580c +8eac204208d99a2b738648df96353bbb1b1065e33ee4f6bba174b540bbbd37d205855e1f1e69a6b7ff043ca377651126 +848e6e7a54ad64d18009300b93ea6f459ce855971dddb419b101f5ac4c159215626fadc20cc3b9ab1701d8f6dfaddd8b +88aa123d9e0cf309d46dddb6acf634b1ade3b090a2826d6e5e78669fa1220d6df9a6697d7778cd9b627db17eea846126 +9200c2a629b9144d88a61151b661b6c4256cc5dadfd1e59a8ce17a013c2d8f7e754aabe61663c3b30f1bc47784c1f8cf +b6e1a2827c3bdda91715b0e1b1f10dd363cef337e7c80cac1f34165fc0dea7c8b69747e310563db5818390146ce3e231 +92c333e694f89f0d306d54105b2a5dcc912dbe7654d9e733edab12e8537350815be472b063e56cfde5286df8922fdecb +a6fac04b6d86091158ebb286586ccfec2a95c9786e14d91a9c743f5f05546073e5e3cc717635a0c602cad8334e922346 +a581b4af77feebc1fb897d49b5b507c6ad513d8f09b273328efbb24ef0d91eb740d01b4d398f2738125dacfe550330cd +81c4860cccf76a34f8a2bc3f464b7bfd3e909e975cce0d28979f457738a56e60a4af8e68a3992cf273b5946e8d7f76e2 +8d1eaa09a3180d8af1cbaee673db5223363cc7229a69565f592fa38ba0f9d582cedf91e15dabd06ebbf2862fc0feba54 +9832f49b0147f4552402e54593cfa51f99540bffada12759b71fcb86734be8e500eea2d8b3d036710bdf04c901432de9 +8bdb0e8ec93b11e5718e8c13cb4f5de545d24829fd76161216340108098dfe5148ed25e3b57a89a516f09fa79043734d +ab96f06c4b9b0b2c0571740b24fca758e6976315053a7ecb20119150a9fa416db2d3a2e0f8168b390bb063f0c1caf785 +ab777f5c52acd62ecf4d1f168b9cc8e1a9b45d4ec6a8ff52c583e867c2239aba98d7d3af977289b367edce03d9c2dfb1 +a09d3ce5e748da84802436951acc3d3ea5d8ec1d6933505ed724d6b4b0d69973ab0930daec9c6606960f6e541e4a3ce2 +8ef94f7be4d85d5ad3d779a5cf4d7b2fc3e65c52fb8e1c3c112509a4af77a0b5be994f251e5e40fabeeb1f7d5615c22b +a7406a5bf5708d9e10922d3c5c45c03ef891b8d0d74ec9f28328a72be4cdc05b4f2703fa99366426659dfca25d007535 +b7f52709669bf92a2e070bfe740f422f0b7127392c5589c7f0af71bb5a8428697c762d3c0d74532899da24ea7d8695c2 +b9dfb0c8df84104dbf9239ccefa4672ef95ddabb8801b74997935d1b81a78a6a5669a3c553767ec19a1281f6e570f4ff +ae4d5c872156061ce9195ac640190d8d71dd406055ee43ffa6f9893eb24b870075b74c94d65bc1d5a07a6573282b5520 +afe6bd3eb72266d333f1807164900dcfa02a7eb5b1744bb3c86b34b3ee91e3f05e38fa52a50dc64eeb4bdb1dd62874b8 +948043cf1bc2ef3c01105f6a78dc06487f57548a3e6ef30e6ebc51c94b71e4bf3ff6d0058c72b6f3ecc37efd7c7fa8c0 +a22fd17c2f7ffe552bb0f23fa135584e8d2d8d75e3f742d94d04aded2a79e22a00dfe7acbb57d44e1cdb962fb22ae170 +8cd0f4e9e4fb4a37c02c1bde0f69359c43ab012eb662d346487be0c3758293f1ca560122b059b091fddce626383c3a8f +90499e45f5b9c81426f3d735a52a564cafbed72711d9279fdd88de8038e953bc48c57b58cba85c3b2e4ce56f1ddb0e11 +8c30e4c034c02958384564cac4f85022ef36ab5697a3d2feaf6bf105049675bbf23d01b4b6814711d3d9271abff04cac +81f7999e7eeea30f3e1075e6780bbf054f2fb6f27628a2afa4d41872a385b4216dd5f549da7ce6cf39049b2251f27fb7 +b36a7191f82fc39c283ffe53fc1f5a9a00b4c64eee7792a8443475da9a4d226cf257f226ea9d66e329af15d8f04984ec +aad4da528fdbb4db504f3041c747455baff5fcd459a2efd78f15bdf3aea0bdb808343e49df88fe7a7c8620009b7964a3 +99ebd8c6dd5dd299517fb6381cfc2a7f443e6e04a351440260dd7c2aee3f1d8ef06eb6c18820b394366ecdfd2a3ce264 +8873725b81871db72e4ec3643084b1cdce3cbf80b40b834b092767728605825c19b6847ad3dcf328438607e8f88b4410 +b008ee2f895daa6abd35bd39b6f7901ae4611a11a3271194e19da1cdcc7f1e1ea008fe5c5440e50d2c273784541ad9c5 +9036feafb4218d1f576ef89d0e99124e45dacaa6d816988e34d80f454d10e96809791d5b78f7fd65f569e90d4d7238c5 +92073c1d11b168e4fa50988b0288638b4868e48bbc668c5a6dddf5499875d53be23a285acb5e4bad60114f6cf6c556e9 +88c87dfcb8ba6cbfe7e1be081ccfadbd589301db2cb7c99f9ee5d7db90aa297ed1538d5a867678a763f2deede5fd219a +b42a562805c661a50f5dea63108002c0f27c0da113da6a9864c9feb5552225417c0356c4209e8e012d9bcc9d182c7611 +8e6317d00a504e3b79cd47feb4c60f9df186467fe9ca0f35b55c0364db30528f5ff071109dabb2fc80bb9cd4949f0c24 +b7b1ea6a88694f8d2f539e52a47466695e39e43a5eb9c6f23bca15305fe52939d8755cc3ac9d6725e60f82f994a3772f +a3cd55161befe795af93a38d33290fb642b8d80da8b786c6e6fb02d393ea308fbe87f486994039cbd7c7b390414594b6 +b416d2d45b44ead3b1424e92c73c2cf510801897b05d1724ff31cbd741920cd858282fb5d6040fe1f0aa97a65bc49424 +950ee01291754feace97c2e933e4681e7ddfbc4fcd079eb6ff830b0e481d929c93d0c7fb479c9939c28ca1945c40da09 +869bd916aee8d86efe362a49010382674825d49195b413b4b4018e88ce43fe091b475d0b863ff0ba2259400f280c2b23 +9782f38cd9c9d3385ec286ebbc7cba5b718d2e65a5890b0a5906b10a89dc8ed80d417d71d7c213bf52f2af1a1f513ea7 +91cd33bc2628d096269b23faf47ee15e14cb7fdc6a8e3a98b55e1031ea0b68d10ba30d97e660f7e967d24436d40fad73 +8becc978129cc96737034c577ae7225372dd855da8811ae4e46328e020c803833b5bdbc4a20a93270e2b8bd1a2feae52 +a36b1d8076783a9522476ce17f799d78008967728ce920531fdaf88303321bcaf97ecaa08e0c01f77bc32e53c5f09525 +b4720e744943f70467983aa34499e76de6d59aa6fadf86f6b787fdce32a2f5b535b55db38fe2da95825c51002cfe142d +91ad21fc502eda3945f6de874d1b6bf9a9a7711f4d61354f9e5634fc73f9c06ada848de15ab0a75811d3250be862827d +84f78e2ebf5fc077d78635f981712daf17e2475e14c2a96d187913006ad69e234746184a51a06ef510c9455b38acb0d7 +960aa7906e9a2f11db64a26b5892ac45f20d2ccb5480f4888d89973beb6fa0dfdc06d68d241ff5ffc7f1b82b1aac242d +a99365dcd1a00c66c9db6924b97c920f5c723380e823b250db85c07631b320ec4e92e586f7319e67a522a0578f7b6d6c +a25d92d7f70cf6a88ff317cfec071e13774516da664f5fac0d4ecaa65b8bf4eb87a64a4d5ef2bd97dfae98d388dbf5cc +a7af47cd0041295798f9779020a44653007444e8b4ef0712982b06d0dcdd434ec4e1f7c5f7a049326602cb605c9105b7 +aefe172eac5568369a05980931cc476bebd9dea573ba276d59b9d8c4420784299df5a910033b7e324a6c2dfc62e3ef05 +b69bc9d22ffa645baa55e3e02522e9892bb2daa7fff7c15846f13517d0799766883ee09ae0869df4139150c5b843ca8a +95a10856140e493354fdd12722c7fdded21b6a2ffbc78aa2697104af8ad0c8e2206f44b0bfee077ef3949d46bbf7c16b +891f2fcd2c47cbea36b7fa715968540c233313f05333f09d29aba23c193f462ed490dd4d00969656e89c53155fdfe710 +a6c33e18115e64e385c843dde34e8a228222795c7ca90bc2cc085705d609025f3351d9be61822c69035a49fb3e48f2d5 +b87fb12f12c0533b005adad0487f03393ff682e13575e3cb57280c3873b2c38ba96a63c49eef7a442753d26b7005230b +b905c02ba451bfd411c135036d92c27af3b0b1c9c2f1309d6948544a264b125f39dd41afeff4666b12146c545adc168a +8b29c513f43a78951cf742231cf5457a6d9d55edf45df5481a0f299a418d94effef561b15d2c1a01d1b8067e7153fda9 +b9941cccd51dc645920d2781c81a317e5a33cb7cf76427b60396735912cb6d2ca9292bb4d36b6392467d390d2c58d9f3 +a8546b627c76b6ef5c93c6a98538d8593dbe21cb7673fd383d5401b0c935eea0bdeeefeb1af6ad41bad8464fb87bbc48 +aa286b27de2812de63108a1aec29d171775b69538dc6198640ac1e96767c2b83a50391f49259195957d457b493b667c9 +a932fb229f641e9abbd8eb2bd874015d97b6658ab6d29769fc23b7db9e41dd4f850382d4c1f08af8f156c5937d524473 +a1412840fcc86e2aeec175526f2fb36e8b3b8d21a78412b7266daf81e51b3f68584ed8bd42a66a43afdd8c297b320520 +89c78be9efb624c97ebca4fe04c7704fa52311d183ffd87737f76b7dadc187c12c982bd8e9ed7cd8beb48cdaafd2fd01 +a3f5ddec412a5bec0ce15e3bcb41c6214c2b05d4e9135a0d33c8e50a78eaba71e0a5a6ea8b45854dec5c2ed300971fc2 +9721f9cec7a68b7758e3887548790de49fa6a442d0396739efa20c2f50352a7f91d300867556d11a703866def2d5f7b5 +a23764e140a87e5991573521af039630dd28128bf56eed2edbed130fd4278e090b60cf5a1dca9de2910603d44b9f6d45 +a1a6494a994215e48ab55c70efa8ffdddce6e92403c38ae7e8dd2f8288cad460c6c7db526bbdf578e96ca04d9fe12797 +b1705ea4cb7e074efe0405fc7b8ee2ec789af0426142f3ec81241cacd4f7edcd88e39435e4e4d8e7b1df64f3880d6613 +85595d061d677116089a6064418b93eb44ff79e68d12bd9625078d3bbc440a60d0b02944eff6054433ee34710ae6fbb4 +9978d5e30bedb7526734f9a1febd973a70bfa20890490e7cc6f2f9328feab1e24f991285dbc3711d892514e2d7d005ad +af30243c66ea43b9f87a061f947f7bce745f09194f6e95f379c7582b9fead920e5d6957eaf05c12ae1282ada4670652f +a1930efb473f88001e47aa0b2b2a7566848cccf295792e4544096ecd14ee5d7927c173a8576b405bfa2eec551cd67eb5 +b0446d1c590ee5a45f7e22d269c044f3848c97aec1d226b44bfd0e94d9729c28a38bccddc3a1006cc5fe4e3c24f001f2 +b8a8380172df3d84b06176df916cf557966d4f2f716d3e9437e415d75b646810f79f2b2b71d857181b7fc944018883a3 +a563afec25b7817bfa26e19dc9908bc00aa8fc3d19be7d6de23648701659009d10e3e4486c28e9c6b13d48231ae29ac5 +a5a8e80579de886fb7d6408f542791876885947b27ad6fa99a8a26e381f052598d7b4e647b0115d4b5c64297e00ce28e +8f87afcc7ad33c51ac719bade3cd92da671a37a82c14446b0a2073f4a0a23085e2c8d31913ed2d0be928f053297de8f6 +a43c455ce377e0bc434386c53c752880687e017b2f5ae7f8a15c044895b242dffde4c92fb8f8bb50b18470b17351b156 +8368f8b12a5bceb1dba25adb3a2e9c7dc9b1a77a1f328e5a693f5aec195cd1e06b0fe9476b554c1c25dac6c4a5b640a3 +919878b27f3671fc78396f11531c032f3e2bd132d04cc234fa4858676b15fb1db3051c0b1db9b4fc49038216f11321ce +b48cd67fb7f1242696c1f877da4bdf188eac676cd0e561fbac1a537f7b8229aff5a043922441d603a26aae56a15faee4 +a3e0fdfd4d29ea996517a16f0370b54787fefe543c2fe73bfc6f9e560c1fd30dad8409859e2d7fa2d44316f24746c712 +8bb156ade8faf149df7bea02c140c7e392a4742ae6d0394d880a849127943e6f26312033336d3b9fdc0092d71b5efe87 +8845e5d5cc555ca3e0523244300f2c8d7e4d02aaebcb5bd749d791208856c209a6f84dd99fd55968c9f0ab5f82916707 +a3e90bb5c97b07789c2f32dff1aec61d0a2220928202f5ad5355ae71f8249237799d6c8a22602e32e572cb12eabe0c17 +b150bcc391884c996149dc3779ce71f15dda63a759ee9cc05871f5a8379dcb62b047098922c0f26c7bd04deb394c33f9 +95cd4ad88d51f0f2efcfd0c2df802fe252bb9704d1afbf9c26a248df22d55da87bdfaf41d7bc6e5df38bd848f0b13f42 +a05a49a31e91dff6a52ac8b9c2cfdd646a43f0d488253f9e3cfbce52f26667166bbb9b608fc358763a65cbf066cd6d05 +a59c3c1227fdd7c2e81f5e11ef5c406da44662987bac33caed72314081e2eed66055d38137e01b2268e58ec85dd986c0 +b7020ec3bd73a99861f0f1d88cf5a19abab1cbe14b7de77c9868398c84bb8e18dbbe9831838a96b6d6ca06e82451c67b +98d1ff2525e9718ee59a21d8900621636fcd873d9a564b8dceb4be80a194a0148daf1232742730b3341514b2e5a5436c +886d97b635975fc638c1b6afc493e5998ca139edba131b75b65cfe5a8e814f11bb678e0eeee5e6e5cd913ad3f2fefdfc +8fb9fd928d38d5d813b671c924edd56601dd7163b686c13f158645c2f869d9250f3859aa5463a39258c90fef0f41190a +aac35e1cd655c94dec3580bb3800bd9c2946c4a9856f7d725af15fbea6a2d8ca51c8ad2772abed60ee0e3fb9cb24046b +b8d71fa0fa05ac9e443c9b4929df9e7f09a919be679692682e614d24227e04894bfc14a5c73a62fb927fedff4a0e4aa7 +a45a19f11fbbb531a704badbb813ed8088ab827c884ee4e4ebf363fa1132ff7cfa9d28be9c85b143e4f7cdbc94e7cf1a +82b54703a4f295f5471b255ab59dce00f0fe90c9fb6e06b9ee48b15c91d43f4e2ef4a96c3118aeb03b08767be58181bb +8283264c8e6d2a36558f0d145c18576b6600ff45ff99cc93eca54b6c6422993cf392668633e5df396b9331e873d457e5 +8c549c03131ead601bc30eb6b9537b5d3beb7472f5bb1bcbbfd1e9f3704477f7840ab3ab7f7dc13bbbbcdff886a462d4 +afbb0c520ac1b5486513587700ad53e314cb74bfbc12e0b5fbdcfdaac36d342e8b59856196a0d84a25cff6e6e1d17e76 +89e4c22ffb51f2829061b3c7c1983c5c750cad158e3a825d46f7cf875677da5d63f653d8a297022b5db5845c9271b32b +afb27a86c4c2373088c96b9adf4433f2ebfc78ac5c526e9f0510670b6e4e5e0057c0a4f75b185e1a30331b9e805c1c15 +a18e16b57445f88730fc5d3567bf5a176861dc14c7a08ed2996fe80eed27a0e7628501bcb78a1727c5e9ac55f29c12c4 +93d61bf88b192d6825cf4e1120af1c17aa0f994d158b405e25437eaeefae049f7b721a206e7cc8a04fdc29d3c42580a1 +a99f2995a2e3ed2fd1228d64166112038de2f516410aa439f4c507044e2017ea388604e2d0f7121256fadf7fbe7023d1 +914fd91cffc23c32f1c6d0e98bf660925090d873367d543034654389916f65f552e445b0300b71b61b721a72e9a5983c +b42a578a7787b71f924e7def425d849c1c777156b1d4170a8ee7709a4a914e816935131afd9a0412c4cb952957b20828 +82fb30590e84b9e45db1ec475a39971cf554dc01bcc7050bc89265740725c02e2be5a972168c5170c86ae83e5b0ad2c0 +b14f8d8e1e93a84976289e0cf0dfa6f3a1809e98da16ee5c4932d0e1ed6bf8a07697fdd4dd86a3df84fb0003353cdcc0 +85d7a2f4bda31aa2cb208b771fe03291a4ebdaf6f1dc944c27775af5caec412584c1f45bc741fca2a6a85acb3f26ad7d +af02e56ce886ff2253bc0a68faad76f25ead84b2144e5364f3fb9b648f03a50ee9dc0b2c33ebacf7c61e9e43201ef9ef +87e025558c8a0b0abd06dfc350016847ea5ced7af2d135a5c9eec9324a4858c4b21510fb0992ec52a73447f24945058e +80fff0bafcd058118f5e7a4d4f1ae0912efeb281d2cbe4d34ba8945cc3dbe5d8baf47fb077343b90b8d895c90b297aca +b6edcf3a40e7b1c3c0148f47a263cd819e585a51ef31c2e35a29ce6f04c53e413f743034c0d998d9c00a08ba00166f31 +abb87ed86098c0c70a76e557262a494ff51a30fb193f1c1a32f8e35eafa34a43fcc07aa93a3b7a077d9e35afa07b1a3d +a280214cd3bb0fb7ecd2d8bcf518cbd9078417f2b91d2533ec2717563f090fb84f2a5fcfdbbeb2a2a1f8a71cc5aa5941 +a63083ca7238ea2b57d15a475963cf1d4f550d8cd76db290014a0461b90351f1f26a67d674c837b0b773b330c7c3d534 +a8fa39064cb585ece5263e2f42f430206476bf261bd50f18d2b694889bd79d04d56410664cecad62690e5c5a20b3f6ff +85ba52ce9d700a5dcf6c5b00559acbe599d671ce5512467ff4b6179d7fad550567ce2a9c126a50964e3096458ea87920 +b913501e1008f076e5eac6d883105174f88b248e1c9801e568fefaffa1558e4909364fc6d9512aa4d125cbd7cc895f05 +8eb33b5266c8f2ed4725a6ad147a322e44c9264cf261c933cbbe230a43d47fca0f29ec39756b20561dabafadd5796494 +850ebc8b661a04318c9db5a0515066e6454fa73865aa4908767a837857ecd717387f614acb614a88e075d4edc53a2f5a +a08d6b92d866270f29f4ce23a3f5d99b36b1e241a01271ede02817c8ec3f552a5c562db400766c07b104a331835c0c64 +8131804c89bb3e74e9718bfc4afa547c1005ff676bd4db9604335032b203390cfa54478d45c6c78d1fe31a436ed4be9f +9106d94f23cc1eacec8316f16d6f0a1cc160967c886f51981fdb9f3f12ee1182407d2bb24e5b873de58cb1a3ee915a6b +a13806bfc3eae7a7000c9d9f1bd25e10218d4e67f59ae798b145b098bca3edad2b1040e3fc1e6310e612fb8818f459ac +8c69fbca502046cb5f6db99900a47b34117aef3f4b241690cdb3b84ca2a2fc7833e149361995dc41fa78892525bce746 +852c473150c91912d58ecb05769222fa18312800c3f56605ad29eec9e2d8667b0b81c379048d3d29100ed2773bb1f3c5 +b1767f6074426a00e01095dbb1795beb4e4050c6411792cbad6537bc444c3165d1058bafd1487451f9c5ddd209e0ae7e +80c600a5fe99354ce59ff0f84c760923dc8ff66a30bf47dc0a086181785ceb01f9b951c4e66df800ea6d705e8bc47055 +b5cf19002fbc88a0764865b82afcb4d64a50196ea361e5c71dff7de084f4dcbbc34ec94a45cc9e0247bd51da565981aa +93e67a254ea8ce25e112d93cc927fadaa814152a2c4ec7d9a56eaa1ed47aec99b7e9916b02e64452cc724a6641729bbb +ace70b32491bda18eee4a4d041c3bc9effae9340fe7e6c2f5ad975ee0874c17f1a7da7c96bd85fccff9312c518fac6e9 +ab4cfa02065017dd7f1aadc66f2c92f78f0f11b8597c03a5d69d82cb2eaf95a4476a836ac102908f137662472c8d914b +a40b8cd8deb8ae503d20364d64cab7c2801b7728a9646ed19c65edea6a842756a2f636283494299584ad57f4bb12cd0b +8594e11d5fc2396bcd9dbf5509ce4816dbb2b7305168021c426171fb444d111da5a152d6835ad8034542277011c26c0e +8024de98c26b4c994a66628dc304bb737f4b6859c86ded552c5abb81fd4c6c2e19d5a30beed398a694b9b2fdea1dd06a +8843f5872f33f54df8d0e06166c1857d733995f67bc54abb8dfa94ad92407cf0179bc91b0a50bbb56cdc2b350d950329 +b8bab44c7dd53ef9edf497dcb228e2a41282c90f00ba052fc52d57e87b5c8ab132d227af1fcdff9a12713d1f980bcaae +982b4d7b29aff22d527fd82d2a52601d95549bfb000429bb20789ed45e5abf1f4b7416c7b7c4b79431eb3574b29be658 +8eb1f571b6a1878e11e8c1c757e0bc084bab5e82e897ca9be9b7f4b47b91679a8190bf0fc8f799d9b487da5442415857 +a6e74b588e5af935c8b243e888582ef7718f8714569dd4992920740227518305eb35fab674d21a5551cca44b3e511ef2 +a30fc2f3a4cb4f50566e82307de73cd7bd8fe2c1184e9293c136a9b9e926a018d57c6e4f308c95b9eb8299e94d90a2a1 +a50c5869ca5d2b40722c056a32f918d47e0b65ca9d7863ca7d2fb4a7b64fe523fe9365cf0573733ceaadebf20b48fff8 +83bbdd32c04d17581418cf360749c7a169b55d54f2427390defd9f751f100897b2d800ce6636c5bbc046c47508d60c8c +a82904bdf614de5d8deaff688c8a5e7ac5b3431687acbcda8fa53960b7c417a39c8b2e462d7af91ce6d79260f412db8e +a4362e31ff4b05d278b033cf5eebea20de01714ae16d4115d04c1da4754269873afc8171a6f56c5104bfd7b0db93c3e7 +b5b8daa63a3735581e74a021b684a1038cea77168fdb7fdf83c670c2cfabcfc3ab2fc7359069b5f9048188351aef26b5 +b48d723894b7782d96ac8433c48faca1bdfa5238019c451a7f47d958097cce3ae599b876cf274269236b9d6ff8b6d7ca +98ffff6a61a3a6205c7820a91ca2e7176fab5dba02bc194c4d14942ac421cb254183c705506ab279e4f8db066f941c6c +ae7db24731da2eaa6efc4f7fcba2ecc26940ddd68038dce43acf2cee15b72dc4ef42a7bfdd32946d1ed78786dd7696b3 +a656db14f1de9a7eb84f6301b4acb2fbf78bfe867f48a270e416c974ab92821eb4df1cb881b2d600cfed0034ac784641 +aa315f8ecba85a5535e9a49e558b15f39520fce5d4bf43131bfbf2e2c9dfccc829074f9083e8d49f405fb221d0bc4c3c +90bffba5d9ff40a62f6c8e9fc402d5b95f6077ed58d030c93e321b8081b77d6b8dac3f63a92a7ddc01585cf2c127d66c +abdd733a36e0e0f05a570d0504e73801bf9b5a25ff2c78786f8b805704997acb2e6069af342538c581144d53149fa6d3 +b4a723bb19e8c18a01bd449b1bb3440ddb2017f10bb153da27deb7a6a60e9bb37619d6d5435fbb1ba617687838e01dd0 +870016b4678bab3375516db0187a2108b2e840bae4d264b9f4f27dbbc7cc9cac1d7dc582d7a04d6fd1ed588238e5e513 +80d33d2e20e8fc170aa3cb4f69fffb72aeafb3b5bb4ea0bc79ab55da14142ca19b2d8b617a6b24d537366e3b49cb67c3 +a7ee76aec273aaae03b3b87015789289551969fb175c11557da3ab77e39ab49d24634726f92affae9f4d24003050d974 +8415ea4ab69d779ebd42d0fe0c6aef531d6a465a5739e429b1fcf433ec45aa8296c527e965a20f0ec9f340c9273ea3cf +8c7662520794e8b4405d0b33b5cac839784bc86a5868766c06cbc1fa306dbe334978177417b31baf90ce7b0052a29c56 +902b2abecc053a3dbdea9897ee21e74821f3a1b98b2d560a514a35799f4680322550fd3a728d4f6d64e1de98033c32b8 +a05e84ed9ecab8d508d670c39f2db61ad6e08d2795ec32a3c9d0d3737ef3801618f4fc2a95f90ec2f068606131e076c5 +8b9208ff4d5af0c2e3f53c9375da666773ac57197dfabb0d25b1c8d0588ba7f3c15ee9661bb001297f322ea2fbf6928b +a3c827741b34a03254d4451b5ab74a96f2b9f7fb069e2f5adaf54fd97cc7a4d516d378db5ca07da87d8566d6eef13726 +8509d8a3f4a0ed378e0a1e28ea02f6bf1d7f6c819c6c2f5297c7df54c895b848f841653e32ba2a2c22c2ff739571acb8 +a0ce988b7d3c40b4e496aa83a09e4b5472a2d98679622f32bea23e6d607bc7de1a5374fb162bce0549a67dad948519be +aa8a3dd12bd60e3d2e05f9c683cdcb8eab17fc59134815f8d197681b1bcf65108cba63ac5c58ee632b1e5ed6bba5d474 +8b955f1d894b3aefd883fb4b65f14cd37fc2b9db77db79273f1700bef9973bf3fd123897ea2b7989f50003733f8f7f21 +ac79c00ddac47f5daf8d9418d798d8af89fc6f1682e7e451f71ea3a405b0d36af35388dd2a332af790bc83ca7b819328 +a0d44dd2a4438b809522b130d0938c3fe7c5c46379365dbd1810a170a9aa5818e1c783470dd5d0b6d4ac7edbb7330910 +a30b69e39ad43dd540a43c521f05b51b5f1b9c4eed54b8162374ae11eac25da4f5756e7b70ce9f3c92c2eeceee7431ed +ac43220b762c299c7951222ea19761ab938bf38e4972deef58ed84f4f9c68c230647cf7506d7cbfc08562fcca55f0485 +b28233b46a8fb424cfa386a845a3b5399d8489ceb83c8f3e05c22c934798d639c93718b7b68ab3ce24c5358339e41cbb +ac30d50ee8ce59a10d4b37a3a35e62cdb2273e5e52232e202ca7d7b8d09d28958ee667fae41a7bb6cdc6fe8f6e6c9c85 +b199842d9141ad169f35cc7ff782b274cbaa645fdb727761e0a89edbf0d781a15f8218b4bf4eead326f2903dd88a9cc1 +85e018c7ddcad34bb8285a737c578bf741ccd547e68c734bdb3808380e12c5d4ef60fc896b497a87d443ff9abd063b38 +8c856e6ba4a815bdb891e1276f93545b7072f6cb1a9aa6aa5cf240976f29f4dee01878638500a6bf1daf677b96b54343 +b8a47555fa8710534150e1a3f13eab33666017be6b41005397afa647ea49708565f2b86b77ad4964d140d9ced6b4d585 +8cd1f1db1b2f4c85a3f46211599caf512d5439e2d8e184663d7d50166fd3008f0e9253272f898d81007988435f715881 +b1f34b14612c973a3eceb716dc102b82ab18afef9de7630172c2780776679a7706a4874e1df3eaadf541fb009731807f +b25464af9cff883b55be2ff8daf610052c02df9a5e147a2cf4df6ce63edcdee6dc535c533590084cc177da85c5dc0baa +91c3c4b658b42d8d3448ae1415d4541d02379a40dc51e36a59bd6e7b9ba3ea51533f480c7c6e8405250ee9b96a466c29 +86dc027b95deb74c36a58a1333a03e63cb5ae22d3b29d114cfd2271badb05268c9d0c819a977f5e0c6014b00c1512e3a +ae0e6ff58eb5fa35da5107ebeacf222ab8f52a22bb1e13504247c1dfa65320f40d97b0e6b201cb6613476687cb2f0681 +8f13415d960b9d7a1d93ef28afc2223e926639b63bdefce0f85e945dfc81670a55df288893a0d8b3abe13c5708f82f91 +956f67ca49ad27c1e3a68c1faad5e7baf0160c459094bf6b7baf36b112de935fdfd79fa4a9ea87ea8de0ac07272969f4 +835e45e4a67df9fb51b645d37840b3a15c171d571a10b03a406dd69d3c2f22df3aa9c5cbe1e73f8d767ce01c4914ea9a +919b938e56d4b32e2667469d0bdccb95d9dda3341aa907683ee70a14bbbe623035014511c261f4f59b318b610ac90aa3 +96b48182121ccd9d689bf1dfdc228175564cd68dc904a99c808a7f0053a6f636c9d953e12198bdf2ea49ea92772f2e18 +ac5e5a941d567fa38fdbcfa8cf7f85bb304e3401c52d88752bcd516d1fa9bac4572534ea2205e38423c1df065990790f +ac0bd594fb85a8d4fc26d6df0fa81f11919401f1ecf9168b891ec7f061a2d9368af99f7fd8d9b43b2ce361e7b8482159 +83d92c69ca540d298fe80d8162a1c7af3fa9b49dfb69e85c1d136a3ec39fe419c9fa78e0bb6d96878771fbd37fe92e40 +b35443ae8aa66c763c2db9273f908552fe458e96696b90e41dd509c17a5c04ee178e3490d9c6ba2dc0b8f793c433c134 +923b2d25aa45b2e580ffd94cbb37dc8110f340f0f011217ee1bd81afb0714c0b1d5fb4db86006cdd2457563276f59c59 +96c9125d38fca1a61ac21257b696f8ac3dae78def50285e44d90ea293d591d1c58f703540a7e4e99e070afe4646bbe15 +b57946b2332077fbcdcb406b811779aefd54473b5559a163cd65cb8310679b7e2028aa55c12a1401fdcfcac0e6fae29a +845daedc5cf972883835d7e13c937b63753c2200324a3b8082a6c4abb4be06c5f7c629d4abe4bfaf1d80a1f073eb6ce6 +91a55dfd0efefcd03dc6dacc64ec93b8d296cb83c0ee72400a36f27246e7f2a60e73b7b70ba65819e9cfb73edb7bd297 +8874606b93266455fe8fdd25df9f8d2994e927460af06f2e97dd4d2d90db1e6b06d441b72c2e76504d753badca87fb37 +8ee99e6d231274ff9252c0f4e84549da173041299ad1230929c3e3d32399731c4f20a502b4a307642cac9306ccd49d3c +8836497714a525118e20849d6933bb8535fb6f72b96337d49e3133d936999c90a398a740f42e772353b5f1c63581df6d +a6916945e10628f7497a6cdc5e2de113d25f7ade3e41e74d3de48ccd4fce9f2fa9ab69645275002e6f49399b798c40af +9597706983107eb23883e0812e1a2c58af7f3499d50c6e29b455946cb9812fde1aa323d9ed30d1c0ffd455abe32303cd +a24ee89f7f515cc33bdbdb822e7d5c1877d337f3b2162303cfc2dae028011c3a267c5cb4194afa63a4856a6e1c213448 +8cd25315e4318801c2776824ae6e7d543cb85ed3bc2498ba5752df2e8142b37653cf9e60104d674be3aeb0a66912e97a +b5085ecbe793180b40dbeb879f4c976eaaccaca3a5246807dced5890e0ed24d35f3f86955e2460e14fb44ff5081c07ba +960188cc0b4f908633a6840963a6fa2205fc42c511c6c309685234911c5304ef4c304e3ae9c9c69daa2fb6a73560c256 +a32d0a70bf15d569b4cda5aebe3e41e03c28bf99cdd34ffa6c5d58a097f322772acca904b3a47addb6c7492a7126ebac +977f72d06ad72d4aa4765e0f1f9f4a3231d9f030501f320fe7714cc5d329d08112789fa918c60dd7fdb5837d56bb7fc6 +99fa038bb0470d45852bb871620d8d88520adb701712fcb1f278fed2882722b9e729e6cdce44c82caafad95e37d0e6f7 +b855e8f4fc7634ada07e83b6c719a1e37acb06394bc8c7dcab7747a8c54e5df3943915f021364bd019fdea103864e55f +88bc2cd7458532e98c596ef59ea2cf640d7cc31b4c33cef9ed065c078d1d4eb49677a67de8e6229cc17ea48bace8ee5a +aaa78a3feaa836d944d987d813f9b9741afb076e6aca1ffa42682ab06d46d66e0c07b8f40b9dbd63e75e81efa1ef7b08 +b7b080420cc4d808723b98b2a5b7b59c81e624ab568ecdfdeb8bf3aa151a581b6f56e983ef1b6f909661e25db40b0c69 +abee85c462ac9a2c58e54f06c91b3e5cd8c5f9ab5b5deb602b53763c54826ed6deb0d6db315a8d7ad88733407e8d35e2 +994d075c1527407547590df53e9d72dd31f037c763848d1662eebd4cefec93a24328c986802efa80e038cb760a5300f5 +ab8777640116dfb6678e8c7d5b36d01265dfb16321abbfc277da71556a34bb3be04bc4ae90124ed9c55386d2bfb3bda0 +967e3a828bc59409144463bcf883a3a276b5f24bf3cbfdd7a42343348cba91e00b46ac285835a9b91eef171202974204 +875a9f0c4ffe5bb1d8da5e3c8e41d0397aa6248422a628bd60bfae536a651417d4e8a7d2fb98e13f2dad3680f7bd86d3 +acaa330c3e8f95d46b1880126572b238dbb6d04484d2cd4f257ab9642d8c9fc7b212188b9c7ac9e0fd135c520d46b1bf +aceb762edbb0f0c43dfcdb01ea7a1ac5918ca3882b1e7ebc4373521742f1ed5250d8966b498c00b2b0f4d13212e6dd0b +81d072b4ad258b3646f52f399bced97c613b22e7ad76373453d80b1650c0ca87edb291a041f8253b649b6e5429bb4cff +980a47d27416ac39c7c3a0ebe50c492f8c776ea1de44d5159ac7d889b6d554357f0a77f0e5d9d0ff41aae4369eba1fc2 +8b4dfd5ef5573db1476d5e43aacfb5941e45d6297794508f29c454fe50ea622e6f068b28b3debe8635cf6036007de2e3 +a60831559d6305839515b68f8c3bc7abbd8212cc4083502e19dd682d56ca37c9780fc3ce4ec2eae81ab23b221452dc57 +951f6b2c1848ced9e8a2339c65918e00d3d22d3e59a0a660b1eca667d18f8430d737884e9805865ef3ed0fe1638a22d9 +b02e38fe790b492aa5e89257c4986c9033a8b67010fa2add9787de857d53759170fdd67715ca658220b4e14b0ca48124 +a51007e4346060746e6b0e4797fc08ef17f04a34fe24f307f6b6817edbb8ce2b176f40771d4ae8a60d6152cbebe62653 +a510005b05c0b305075b27b243c9d64bcdce85146b6ed0e75a3178b5ff9608213f08c8c9246f2ca6035a0c3e31619860 +aaff4ef27a7a23be3419d22197e13676d6e3810ceb06a9e920d38125745dc68a930f1741c9c2d9d5c875968e30f34ab5 +864522a9af9857de9814e61383bebad1ba9a881696925a0ea6bfc6eff520d42c506bbe5685a9946ed710e889765be4a0 +b63258c080d13f3b7d5b9f3ca9929f8982a6960bdb1b0f8676f4dca823971601672f15e653917bf5d3746bb220504913 +b51ce0cb10869121ae310c7159ee1f3e3a9f8ad498827f72c3d56864808c1f21fa2881788f19ece884d3f705cd7bd0c5 +95d9cecfc018c6ed510e441cf84c712d9909c778c16734706c93222257f64dcd2a9f1bd0b400ca271e22c9c487014274 +8beff4d7d0140b86380ff4842a9bda94c2d2be638e20ac68a4912cb47dbe01a261857536375208040c0554929ced1ddc +891ff49258749e2b57c1e9b8e04b12c77d79c3308b1fb615a081f2aacdfb4b39e32d53e069ed136fdbd43c53b87418fa +9625cad224e163d387738825982d1e40eeff35fe816d10d7541d15fdc4d3eee48009090f3faef4024b249205b0b28f72 +8f3947433d9bd01aa335895484b540a9025a19481a1c40b4f72dd676bfcf332713714fd4010bde936eaf9470fd239ed0 +a00ec2d67789a7054b53f0e858a8a232706ccc29a9f3e389df7455f1a51a2e75801fd78469a13dbc25d28399ae4c6182 +a3f65884506d4a62b8775a0ea0e3d78f5f46bc07910a93cd604022154eabdf1d73591e304d61edc869e91462951975e1 +a14eef4fd5dfac311713f0faa9a60415e3d30b95a4590cbf95f2033dffb4d16c02e7ceff3dcd42148a4e3bc49cce2dd4 +8afa11c0eef3c540e1e3460bc759bb2b6ea90743623f88e62950c94e370fe4fd01c22b6729beba4dcd4d581198d9358f +afb05548a69f0845ffcc5f5dc63e3cdb93cd270f5655173b9a950394b0583663f2b7164ba6df8d60c2e775c1d9f120af +97f179e01a947a906e1cbeafa083960bc9f1bade45742a3afee488dfb6011c1c6e2db09a355d77f5228a42ccaa7bdf8e +8447fca4d35f74b3efcbd96774f41874ca376bf85b79b6e66c92fa3f14bdd6e743a051f12a7fbfd87f319d1c6a5ce217 +a57ca39c23617cd2cf32ff93b02161bd7baf52c4effb4679d9d5166406e103bc8f3c6b5209e17c37dbb02deb8bc72ddd +9667c7300ff80f0140be002b0e36caab07aaee7cce72679197c64d355e20d96196acaf54e06e1382167d081fe6f739c1 +828126bb0559ce748809b622677267ca896fa2ee76360fd2c02990e6477e06a667241379ca7e65d61a5b64b96d7867de +8b8835dea6ba8cf61c91f01a4b3d2f8150b687a4ee09b45f2e5fc8f80f208ae5d142d8e3a18153f0722b90214e60c5a7 +a98e8ff02049b4da386e3ee93db23bbb13dfeb72f1cfde72587c7e6d962780b7671c63e8ac3fbaeb1a6605e8d79e2f29 +87a4892a0026d7e39ef3af632172b88337cb03669dea564bcdb70653b52d744730ebb5d642e20cb627acc9dbb547a26b +877352a22fc8052878a57effc159dac4d75fe08c84d3d5324c0bab6d564cdf868f33ceee515eee747e5856b62cfa0cc7 +8b801ba8e2ff019ee62f64b8cb8a5f601fc35423eb0f9494b401050103e1307dc584e4e4b21249cd2c686e32475e96c3 +a9e7338d6d4d9bfec91b2af28a8ed13b09415f57a3a00e5e777c93d768fdb3f8e4456ae48a2c6626b264226e911a0e28 +99c05fedf40ac4726ed585d7c1544c6e79619a0d3fb6bda75a08c7f3c0008e8d5e19ed4da48de3216135f34a15eba17c +a61cce8a1a8b13a4a650fdbec0eeea8297c352a8238fb7cac95a0df18ed16ee02a3daa2de108fa122aca733bd8ad7855 +b97f37da9005b440b4cb05870dd881bf8491fe735844f2d5c8281818583b38e02286e653d9f2e7fa5e74c3c3eb616540 +a72164a8554da8e103f692ac5ebb4aece55d5194302b9f74b6f2a05335b6e39beede0bf7bf8c5bfd4d324a784c5fb08c +b87e8221c5341cd9cc8bb99c10fe730bc105550f25ed4b96c0d45e6142193a1b2e72f1b3857373a659b8c09be17b3d91 +a41fb1f327ef91dcb7ac0787918376584890dd9a9675c297c45796e32d6e5985b12f9b80be47fc3a8596c245f419d395 +90dafa3592bdbb3465c92e2a54c2531822ba0459d45d3e7a7092fa6b823f55af28357cb51896d4ec2d66029c82f08e26 +a0a9adc872ebc396557f484f1dd21954d4f4a21c4aa5eec543f5fa386fe590839735c01f236574f7ff95407cd12de103 +b8c5c940d58be7538acf8672852b5da3af34f82405ef2ce8e4c923f1362f97fc50921568d0fd2fe846edfb0823e62979 +85aaf06a8b2d0dac89dafd00c28533f35dbd074978c2aaa5bef75db44a7b12aeb222e724f395513b9a535809a275e30b +81f3cbe82fbc7028c26a6c1808c604c63ba023a30c9f78a4c581340008dbda5ec07497ee849a2183fcd9124f7936af32 +a11ac738de75fd60f15a34209d3825d5e23385796a4c7fc5931822f3f380af977dd0f7b59fbd58eed7777a071e21b680 +85a279c493de03db6fa6c3e3c1b1b29adc9a8c4effc12400ae1128da8421954fa8b75ad19e5388fe4543b76fb0812813 +83a217b395d59ab20db6c4adb1e9713fc9267f5f31a6c936042fe051ce8b541f579442f3dcf0fa16b9e6de9fd3518191 +83a0b86e7d4ed8f9ccdc6dfc8ff1484509a6378fa6f09ed908e6ab9d1073f03011dc497e14304e4e3d181b57de06a5ab +a63ad69c9d25704ce1cc8e74f67818e5ed985f8f851afa8412248b2df5f833f83b95b27180e9e7273833ed0d07113d3b +99b1bc2021e63b561fe44ddd0af81fcc8627a91bfeecbbc989b642bc859abc0c8d636399701aad7bbaf6a385d5f27d61 +b53434adb66f4a807a6ad917c6e856321753e559b1add70824e5c1e88191bf6993fccb9b8b911fc0f473fb11743acacd +97ed3b9e6fb99bf5f945d4a41f198161294866aa23f2327818cdd55cb5dc4c1a8eff29dd8b8d04902d6cd43a71835c82 +b1e808260e368a18d9d10bdea5d60223ba1713b948c782285a27a99ae50cc5fc2c53d407de07155ecc16fb8a36d744a0 +a3eb4665f18f71833fec43802730e56b3ee5a357ea30a888ad482725b169d6f1f6ade6e208ee081b2e2633079b82ba7d +ab8beb2c8353fc9f571c18fdd02bdb977fc883313469e1277b0372fbbb33b80dcff354ca41de436d98d2ed710faa467e +aa9071cfa971e4a335a91ad634c98f2be51544cb21f040f2471d01bb97e1df2277ae1646e1ea8f55b7ba9f5c8c599b39 +80b7dbfdcaf40f0678012acc634eba44ea51181475180d9deb2050dc4f2de395289edd0223018c81057ec79b04b04c49 +89623d7f6cb17aa877af14de842c2d4ab7fd576d61ddd7518b5878620a01ded40b6010de0da3cdf31d837eecf30e9847 +a773bb024ae74dd24761f266d4fb27d6fd366a8634febe8235376b1ae9065c2fe12c769f1d0407867dfbe9f5272c352f +8455a561c3aaa6ba64c881a5e13921c592b3a02e968f4fb24a2243c36202795d0366d9cc1a24e916f84d6e158b7aeac7 +81d8bfc4b283cf702a40b87a2b96b275bdbf0def17e67d04842598610b67ea08c804d400c3e69fa09ea001eaf345b276 +b8f8f82cb11fea1c99467013d7e167ff03deb0c65a677fab76ded58826d1ba29aa7cf9fcd7763615735ea3ad38e28719 +89a6a04baf9cccc1db55179e1650b1a195dd91fb0aebc197a25143f0f393524d2589975e3fbfc2547126f0bced7fd6f2 +b81b2162df045390f04df07cbd0962e6b6ca94275a63edded58001a2f28b2ae2af2c7a6cba4ecd753869684e77e7e799 +a3757f722776e50de45c62d9c4a2ee0f5655a512344c4cbec542d8045332806568dd626a719ef21a4eb06792ca70f204 +8c5590df96ec22179a4e8786de41beb44f987a1dcc508eb341eecbc0b39236fdfad47f108f852e87179ccf4e10091e59 +87502f026ed4e10167419130b88c3737635c5b9074c364e1dd247cef5ef0fc064b4ae99b187e33301e438bbd2fe7d032 +af925a2165e980ced620ff12289129fe17670a90ae0f4db9d4b39bd887ccb1f5d2514ac9ecf910f6390a8fc66bd5be17 +857fca899828cf5c65d26e3e8a6e658542782fc72762b3b9c73514919f83259e0f849a9d4838b40dc905fe43024d0d23 +87ffebdbfb69a9e1007ebac4ffcb4090ff13705967b73937063719aa97908986effcb7262fdadc1ae0f95c3690e3245d +a9ff6c347ac6f4c6ab993b748802e96982eaf489dc69032269568412fc9a79e7c2850dfc991b28211b3522ee4454344b +a65b3159df4ec48bebb67cb3663cd744027ad98d970d620e05bf6c48f230fa45bf17527fe726fdf705419bb7a1bb913e +84b97b1e6408b6791831997b03cd91f027e7660fd492a93d95daafe61f02427371c0e237c75706412f442991dfdff989 +ab761c26527439b209af0ae6afccd9340bbed5fbe098734c3145b76c5d2cd7115d9227b2eb523882b7317fbb09180498 +a0479a8da06d7a69c0b0fee60df4e691c19c551f5e7da286dab430bfbcabf31726508e20d26ea48c53365a7f00a3ad34 +a732dfc9baa0f4f40b5756d2e8d8937742999623477458e0bc81431a7b633eefc6f53b3b7939fe0a020018549c954054 +901502436a1169ba51dc479a5abe7c8d84e0943b16bc3c6a627b49b92cd46263c0005bc324c67509edd693f28e612af1 +b627aee83474e7f84d1bab9b7f6b605e33b26297ac6bbf52d110d38ba10749032bd551641e73a383a303882367af429b +95108866745760baef4a46ef56f82da6de7e81c58b10126ebd2ba2cd13d339f91303bf2fb4dd104a6956aa3b13739503 +899ed2ade37236cec90056f3569bc50f984f2247792defafcceb49ad0ca5f6f8a2f06573705300e07f0de0c759289ff5 +a9f5eee196d608efe4bcef9bf71c646d27feb615e21252cf839a44a49fd89da8d26a758419e0085a05b1d59600e2dc42 +b36c6f68fed6e6c85f1f4a162485f24817f2843ec5cbee45a1ebfa367d44892e464949c6669f7972dc7167af08d55d25 +aaaede243a9a1b6162afbc8f571a52671a5a4519b4062e3f26777664e245ba873ed13b0492c5dbf0258c788c397a0e9e +972b4fb39c31cbe127bf9a32a5cc10d621ebdd9411df5e5da3d457f03b2ab2cd1f6372d8284a4a9400f0b06ecdbfd38e +8f6ca1e110e959a4b1d9a5ce5f212893cec21db40d64d5ac4d524f352d72198f923416a850bf845bc5a22a79c0ea2619 +a0f3c93b22134f66f04b2553a53b738644d1665ceb196b8494b315a4c28236fb492017e4a0de4224827c78e42f9908b7 +807fb5ee74f6c8735b0b5ca07e28506214fe4047dbeb00045d7c24f7849e98706aea79771241224939cb749cf1366c7d +915eb1ff034224c0b645442cdb7d669303fdc00ca464f91aaf0b6fde0b220a3a74ff0cb043c26c9f3a5667b3fdaa9420 +8fda6cef56ed33fefffa9e6ac8e6f76b1af379f89761945c63dd448801f7bb8ca970504a7105fac2f74f652ccff32327 +87380cffdcffb1d0820fa36b63cc081e72187f86d487315177d4d04da4533eb19a0e2ff6115ceab528887819c44a5164 +8cd89e03411a18e7f16f968b89fb500c36d47d229f6487b99e62403a980058db5925ce249206743333538adfad168330 +974451b1df33522ce7056de9f03e10c70bf302c44b0741a59df3d6877d53d61a7394dcee1dd46e013d7cb9d73419c092 +98c35ddf645940260c490f384a49496a7352bb8e3f686feed815b1d38f59ded17b1ad6e84a209e773ed08f7b8ff1e4c2 +963f386cf944bb9b2ddebb97171b64253ea0a2894ac40049bdd86cda392292315f3a3d490ca5d9628c890cfb669f0acb +8d507712152babd6d142ee682638da8495a6f3838136088df9424ef50d5ec28d815a198c9a4963610b22e49b4cdf95e9 +83d4bc6b0be87c8a4f1e9c53f257719de0c73d85b490a41f7420e777311640937320557ff2f1d9bafd1daaa54f932356 +82f5381c965b7a0718441131c4d13999f4cdce637698989a17ed97c8ea2e5bdb5d07719c5f7be8688edb081b23ede0f4 +a6ebecab0b72a49dfd01d69fa37a7f74d34fb1d4fef0aa10e3d6fceb9eccd671225c230af89f6eb514250e41a5f91f52 +846d185bdad6e11e604df7f753b7a08a28b643674221f0e750ebdb6b86ec584a29c869e131bca868972a507e61403f6a +85a98332292acb744bd1c0fd6fdcf1f889a78a2c9624d79413ffa194cc8dfa7821a4b60cde8081d4b5f71f51168dd67f +8f7d97c3b4597880d73200d074eb813d95432306e82dafc70b580b8e08cb8098b70f2d07b4b3ac6a4d77e92d57035031 +8185439c8751e595825d7053518cbe121f191846a38d4dbcb558c3f9d7a3104f3153401adaaaf27843bbe2edb504bfe3 +b3c00d8ece1518fca6b1215a139b0a0e26d9cba1b3a424f7ee59f30ce800a5db967279ed60958dd1f3ee69cf4dd1b204 +a2e6cb6978e883f9719c3c0d44cfe8de0cc6f644b98f98858433bea8bbe7b612c8aca5952fccce4f195f9d54f9722dc2 +99663087e3d5000abbec0fbda4e7342ec38846cc6a1505191fb3f1a337cb369455b7f8531a6eb8b0f7b2c4baf83cbe2b +ab0836c6377a4dbc7ca6a4d6cf021d4cd60013877314dd05f351706b128d4af6337711ed3443cb6ca976f40d74070a9a +87abfd5126152fd3bac3c56230579b489436755ea89e0566aa349490b36a5d7b85028e9fb0710907042bcde6a6f5d7e3 +974ba1033f75f60e0cf7c718a57ae1da3721cf9d0fb925714c46f027632bdd84cd9e6de4cf4d00bc55465b1c5ebb7384 +a607b49d73689ac64f25cec71221d30d53e781e1100d19a2114a21da6507a60166166369d860bd314acb226596525670 +a7c2b0b915d7beba94954f2aa7dd08ec075813661e2a3ecca5d28a0733e59583247fed9528eb28aba55b972cdbaf06eb +b8b3123e44128cc8efbe3270f2f94e50ca214a4294c71c3b851f8cbb70cb67fe9536cf07d04bf7fe380e5e3a29dd3c15 +a59a07e343b62ad6445a0859a32b58c21a593f9ddbfe52049650f59628c93715aa1f4e1f45b109321756d0eeec8a5429 +94f51f8a4ed18a6030d0aaa8899056744bd0e9dc9ac68f62b00355cddab11da5da16798db75f0bfbce0e5bdfe750c0b6 +97460a97ca1e1fa5ce243b81425edc0ec19b7448e93f0b55bc9785eedeeafe194a3c8b33a61a5c72990edf375f122777 +8fa859a089bc17d698a7ee381f37ce9beadf4e5b44fce5f6f29762bc04f96faff5d58c48c73631290325f05e9a1ecf49 +abdf38f3b20fc95eff31de5aa9ef1031abfa48f1305ee57e4d507594570401503476d3bcc493838fc24d6967a3082c7f +b8914bfb82815abb86da35c64d39ab838581bc0bf08967192697d9663877825f2b9d6fbdcf9b410463482b3731361aef +a8187f9d22b193a5f578999954d6ec9aa9b32338ccadb8a3e1ce5bad5ea361d69016e1cdfac44e9d6c54e49dd88561b9 +aac262cb7cba7fd62c14daa7b39677cabc1ef0947dd06dd89cac8570006a200f90d5f0353e84f5ff03179e3bebe14231 +a630ef5ece9733b8c46c0a2df14a0f37647a85e69c63148e79ffdcc145707053f9f9d305c3f1cf3c7915cb46d33abd07 +b102c237cb2e254588b6d53350dfda6901bd99493a3fbddb4121d45e0b475cf2663a40d7b9a75325eda83e4ba1e68cb3 +86a930dd1ddcc16d1dfa00aa292cb6c2607d42c367e470aa920964b7c17ab6232a7108d1c2c11fc40fb7496547d0bbf8 +a832fdc4500683e72a96cce61e62ac9ee812c37fe03527ad4cf893915ca1962cee80e72d4f82b20c8fc0b764376635a1 +88ad985f448dabb04f8808efd90f273f11f5e6d0468b5489a1a6a3d77de342992a73eb842d419034968d733f101ff683 +98a8538145f0d86f7fbf9a81c9140f6095c5bdd8960b1c6f3a1716428cd9cca1bf8322e6d0af24e6169abcf7df2b0ff6 +9048c6eba5e062519011e177e955a200b2c00b3a0b8615bdecdebc217559d41058d3315f6d05617be531ef0f6aef0e51 +833bf225ab6fc68cdcacf1ec1b50f9d05f5410e6cdcd8d56a3081dc2be8a8d07b81534d1ec93a25c2e270313dfb99e3b +a84bcd24c3da5e537e64a811b93c91bfc84d7729b9ead7f79078989a6eb76717d620c1fad17466a0519208651e92f5ff +b7cdd0a3fbd79aed93e1b5a44ca44a94e7af5ed911e4492f332e3a5ed146c7286bde01b52276a2fcc02780d2109874dd +8a19a09854e627cb95750d83c20c67442b66b35896a476358f993ba9ac114d32c59c1b3d0b8787ee3224cf3888b56c64 +a9abd5afb8659ee52ada8fa5d57e7dd355f0a7350276f6160bec5fbf70d5f99234dd179eb221c913e22a49ec6d267846 +8c13c4274c0d30d184e73eaf812200094bbbd57293780bdadbceb262e34dee5b453991e7f37c7333a654fc71c69d6445 +a4320d73296ff8176ce0127ca1921c450e2a9c06eff936681ebaffb5a0b05b17fded24e548454de89aca2dcf6d7a9de4 +b2b8b3e15c1f645f07783e5628aba614e60157889db41d8161d977606788842b67f83f361eae91815dc0abd84e09abd5 +ad26c3aa35ddfddc15719b8bb6c264aaec7065e88ac29ba820eb61f220fef451609a7bb037f3722d022e6c86e4f1dc88 +b8615bf43e13ae5d7b8dd903ce37190800cd490f441c09b22aa29d7a29ed2c0417b7a08ead417868f1de2589deaadd80 +8d3425e1482cd1e76750a76239d33c06b3554c3c3c87c15cb7ab58b1cee86a4c5c4178b44e23f36928365a1b484bde02 +806893a62e38c941a7dd6f249c83af16596f69877cc737d8f73f6b8cd93cbc01177a7a276b2b8c6b0e5f2ad864db5994 +86618f17fa4b0d65496b661bbb5ba3bc3a87129d30a4b7d4f515b904f4206ca5253a41f49fd52095861e5e065ec54f21 +9551915da1304051e55717f4c31db761dcdcf3a1366c89a4af800a9e99aca93a357bf928307f098e62b44a02cb689a46 +8f79c4ec0ec1146cb2a523b52fe33def90d7b5652a0cb9c2d1c8808a32293e00aec6969f5b1538e3a94cd1efa3937f86 +a0c03e329a707300081780f1e310671315b4c6a4cedcb29697aedfabb07a9d5df83f27b20e9c44cf6b16e39d9ded5b98 +86a7cfa7c8e7ce2c01dd0baec2139e97e8e090ad4e7b5f51518f83d564765003c65968f85481bbb97cb18f005ccc7d9f +a33811770c6dfda3f7f74e6ad0107a187fe622d61b444bbd84fd7ef6e03302e693b093df76f6ab39bb4e02afd84a575a +85480f5c10d4162a8e6702b5e04f801874d572a62a130be94b0c02b58c3c59bdcd48cd05f0a1c2839f88f06b6e3cd337 +8e181011564b17f7d787fe0e7f3c87f6b62da9083c54c74fd6c357a1f464c123c1d3d8ade3cf72475000b464b14e2be3 +8ee178937294b8c991337e0621ab37e9ffa4ca2bdb3284065c5e9c08aad6785d50cf156270ff9daf9a9127289710f55b +8bd1e8e2d37379d4b172f1aec96f2e41a6e1393158d7a3dbd9a95c8dd4f8e0b05336a42efc11a732e5f22b47fc5c271d +8f3da353cd487c13136a85677de8cedf306faae0edec733cf4f0046f82fa4639db4745b0095ff33a9766aba50de0cbcf +8d187c1e97638df0e4792b78e8c23967dac43d98ea268ca4aabea4e0fa06cb93183fd92d4c9df74118d7cc27bf54415e +a4c992f08c2f8bac0b74b3702fb0c75c9838d2ce90b28812019553d47613c14d8ce514d15443159d700b218c5a312c49 +a6fd1874034a34c3ea962a316c018d9493d2b3719bb0ec4edbc7c56b240802b2228ab49bee6f04c8a3e9f6f24a48c1c2 +b2efed8e799f8a15999020900dc2c58ece5a3641c90811b86a5198e593d7318b9d53b167818ccdfbe7df2414c9c34011 +995ff7de6181ddf95e3ead746089c6148da3508e4e7a2323c81785718b754d356789b902e7e78e2edc6b0cbd4ff22c78 +944073d24750a9068cbd020b834afc72d2dde87efac04482b3287b40678ad07588519a4176b10f2172a2c463d063a5cd +99db4b1bb76475a6fd75289986ef40367960279524378cc917525fb6ba02a145a218c1e9caeb99332332ab486a125ac0 +89fce4ecd420f8e477af4353b16faabb39e063f3f3c98fde2858b1f2d1ef6eed46f0975a7c08f233b97899bf60ccd60a +8c09a4f07a02b80654798bc63aada39fd638d3e3c4236ccd8a5ca280350c31e4a89e5f4c9aafb34116e71da18c1226b8 +85325cfa7ded346cc51a2894257eab56e7488dbff504f10f99f4cd2b630d913003761a50f175ed167e8073f1b6b63fb0 +b678b4fbec09a8cc794dcbca185f133578f29e354e99c05f6d07ac323be20aecb11f781d12898168e86f2e0f09aca15e +a249cfcbca4d9ba0a13b5f6aac72bf9b899adf582f9746bb2ad043742b28915607467eb794fca3704278f9136f7642be +9438e036c836a990c5e17af3d78367a75b23c37f807228362b4d13e3ddcb9e431348a7b552d09d11a2e9680704a4514f +925ab70450af28c21a488bfb5d38ac994f784cf249d7fd9ad251bb7fd897a23e23d2528308c03415074d43330dc37ef4 +a290563904d5a8c0058fc8330120365bdd2ba1fdbaef7a14bc65d4961bb4217acfaed11ab82669e359531f8bf589b8db +a7e07a7801b871fc9b981a71e195a3b4ba6b6313bc132b04796a125157e78fe5c11a3a46cf731a255ac2d78a4ae78cd0 +b26cd2501ee72718b0eebab6fb24d955a71f363f36e0f6dff0ab1d2d7836dab88474c0cef43a2cc32701fca7e82f7df3 +a1dc3b6c968f3de00f11275092290afab65b2200afbcfa8ddc70e751fa19dbbc300445d6d479a81bda3880729007e496 +a9bc213e28b630889476a095947d323b9ac6461dea726f2dc9084473ae8e196d66fb792a21905ad4ec52a6d757863e7d +b25d178df8c2df8051e7c888e9fa677fde5922e602a95e966db9e4a3d6b23ce043d7dc48a5b375c6b7c78e966893e8c3 +a1c8d88d72303692eaa7adf68ea41de4febec40cc14ae551bb4012afd786d7b6444a3196b5d9d5040655a3366d96b7cd +b22bd44f9235a47118a9bbe2ba5a2ba9ec62476061be2e8e57806c1a17a02f9a51403e849e2e589520b759abd0117683 +b8add766050c0d69fe81d8d9ea73e1ed05f0135d093ff01debd7247e42dbb86ad950aceb3b50b9af6cdc14ab443b238f +af2cf95f30ef478f018cf81d70d47d742120b09193d8bb77f0d41a5d2e1a80bfb467793d9e2471b4e0ad0cb2c3b42271 +8af5ef2107ad284e246bb56e20fef2a255954f72de791cbdfd3be09f825298d8466064f3c98a50496c7277af32b5c0bc +85dc19558572844c2849e729395a0c125096476388bd1b14fa7f54a7c38008fc93e578da3aac6a52ff1504d6ca82db05 +ae8c9b43c49572e2e166d704caf5b4b621a3b47827bb2a3bcd71cdc599bba90396fd9a405261b13e831bb5d44c0827d7 +a7ba7efede25f02e88f6f4cbf70643e76784a03d97e0fbd5d9437c2485283ad7ca3abb638a5f826cd9f6193e5dec0b6c +94a9d122f2f06ef709fd8016fd4b712d88052245a65a301f5f177ce22992f74ad05552b1f1af4e70d1eac62cef309752 +82d999b3e7cf563833b8bc028ff63a6b26eb357dfdb3fd5f10e33a1f80a9b2cfa7814d871b32a7ebfbaa09e753e37c02 +aec6edcde234df502a3268dd2c26f4a36a2e0db730afa83173f9c78fcb2b2f75510a02b80194327b792811caefda2725 +94c0bfa66c9f91d462e9194144fdd12d96f9bbe745737e73bab8130607ee6ea9d740e2cfcbbd00a195746edb6369ee61 +ab7573dab8c9d46d339e3f491cb2826cabe8b49f85f1ede78d845fc3995537d1b4ab85140b7d0238d9c24daf0e5e2a7e +87e8b16832843251fe952dadfd01d41890ed4bb4b8fa0254550d92c8cced44368225eca83a6c3ad47a7f81ff8a80c984 +9189d2d9a7c64791b19c0773ad4f0564ce6bea94aa275a917f78ad987f150fdb3e5e26e7fef9982ac184897ecc04683f +b3661bf19e2da41415396ae4dd051a9272e8a2580b06f1a1118f57b901fa237616a9f8075af1129af4eabfefedbe2f1c +af43c86661fb15daf5d910a4e06837225e100fb5680bd3e4b10f79a2144c6ec48b1f8d6e6b98e067d36609a5d038889a +82ac0c7acaa83ddc86c5b4249aae12f28155989c7c6b91e5137a4ce05113c6cbc16f6c44948b0efd8665362d3162f16a +8f268d1195ab465beeeb112cd7ffd5d5548559a8bc01261106d3555533fc1971081b25558d884d552df0db1cddda89d8 +8ef7caa5521f3e037586ce8ac872a4182ee20c7921c0065ed9986c047e3dda08294da1165f385d008b40d500f07d895f +8c2f98f6880550573fad46075d3eba26634b5b025ce25a0b4d6e0193352c8a1f0661064027a70fe8190b522405f9f4e3 +b7653f353564feb164f0f89ec7949da475b8dad4a4d396d252fc2a884f6932d027b7eb2dc4d280702c74569319ed701a +a026904f4066333befd9b87a8fad791d014096af60cdd668ef919c24dbe295ff31f7a790e1e721ba40cf5105abca67f4 +988f982004ada07a22dd345f2412a228d7a96b9cae2c487de42e392afe1e35c2655f829ce07a14629148ce7079a1f142 +9616add009067ed135295fb74d5b223b006b312bf14663e547a0d306694ff3a8a7bb9cfc466986707192a26c0bce599f +ad4c425de9855f6968a17ee9ae5b15e0a5b596411388cf976df62ecc6c847a6e2ddb2cea792a5f6e9113c2445dba3e5c +b698ac9d86afa3dc69ff8375061f88e3b0cff92ff6dfe747cebaf142e813c011851e7a2830c10993b715e7fd594604a9 +a386fa189847bb3b798efca917461e38ead61a08b101948def0f82cd258b945ed4d45b53774b400af500670149e601b7 +905c95abda2c68a6559d8a39b6db081c68cef1e1b4be63498004e1b2f408409be9350b5b5d86a30fd443e2b3e445640a +9116dade969e7ce8954afcdd43e5cab64dc15f6c1b8da9d2d69de3f02ba79e6c4f6c7f54d6bf586d30256ae405cd1e41 +a3084d173eacd08c9b5084a196719b57e47a0179826fda73466758235d7ecdb87cbcf097bd6b510517d163a85a7c7edd +85bb00415ad3c9be99ff9ba83672cc59fdd24356b661ab93713a3c8eab34e125d8867f628a3c3891b8dc056e69cd0e83 +8d58541f9f39ed2ee4478acce5d58d124031338ec11b0d55551f00a5a9a6351faa903a5d7c132dc5e4bb026e9cbd18e4 +a622adf72dc250e54f672e14e128c700166168dbe0474cecb340da175346e89917c400677b1bc1c11fcc4cc26591d9db +b3f865014754b688ca8372e8448114fff87bf3ca99856ab9168894d0c4679782c1ced703f5b74e851b370630f5e6ee86 +a7e490b2c40c2446fcd91861c020da9742c326a81180e38110558bb5d9f2341f1c1885e79b364e6419023d1cbdc47380 +b3748d472b1062e54572badbb8e87ac36534407f74932e7fc5b8392d008e8e89758f1671d1e4d30ab0fa40551b13bb5e +89898a5c5ec4313aabc607b0049fd1ebad0e0c074920cf503c9275b564d91916c2c446d3096491c950b7af3ac5e4b0ed +8eb8c83fef2c9dd30ea44e286e9599ec5c20aba983f702e5438afe2e5b921884327ad8d1566c72395587efac79ca7d56 +b92479599e806516ce21fb0bd422a1d1d925335ebe2b4a0a7e044dd275f30985a72b97292477053ac5f00e081430da80 +a34ae450a324fe8a3c25a4d653a654f9580ed56bbea213b8096987bbad0f5701d809a17076435e18017fea4d69f414bc +81381afe6433d62faf62ea488f39675e0091835892ecc238e02acf1662669c6d3962a71a3db652f6fe3bc5f42a0e5dc5 +a430d475bf8580c59111103316fe1aa79c523ea12f1d47a976bbfae76894717c20220e31cf259f08e84a693da6688d70 +b842814c359754ece614deb7d184d679d05d16f18a14b288a401cef5dad2cf0d5ee90bad487b80923fc5573779d4e4e8 +971d9a2627ff2a6d0dcf2af3d895dfbafca28b1c09610c466e4e2bff2746f8369de7f40d65b70aed135fe1d72564aa88 +8f4ce1c59e22b1ce7a0664caaa7e53735b154cfba8d2c5cc4159f2385843de82ab58ed901be876c6f7fce69cb4130950 +86cc9dc321b6264297987000d344fa297ef45bcc2a4df04e458fe2d907ad304c0ea2318e32c3179af639a9a56f3263cf +8229e0876dfe8f665c3fb19b250bd89d40f039bbf1b331468b403655be7be2e104c2fd07b9983580c742d5462ca39a43 +99299d73066e8eb128f698e56a9f8506dfe4bd014931e86b6b487d6195d2198c6c5bf15cccb40ccf1f8ddb57e9da44a2 +a3a3be37ac554c574b393b2f33d0a32a116c1a7cfeaf88c54299a4da2267149a5ecca71f94e6c0ef6e2f472b802f5189 +a91700d1a00387502cdba98c90f75fbc4066fefe7cc221c8f0e660994c936badd7d2695893fde2260c8c11d5bdcdd951 +8e03cae725b7f9562c5c5ab6361644b976a68bada3d7ca508abca8dfc80a469975689af1fba1abcf21bc2a190dab397d +b01461ad23b2a8fa8a6d241e1675855d23bc977dbf4714add8c4b4b7469ccf2375cec20e80cedfe49361d1a30414ac5b +a2673bf9bc621e3892c3d7dd4f1a9497f369add8cbaa3472409f4f86bd21ac67cfac357604828adfee6ada1835365029 +a042dff4bf0dfc33c178ba1b335e798e6308915128de91b12e5dbbab7c4ac8d60a01f6aea028c3a6d87b9b01e4e74c01 +86339e8a75293e4b3ae66b5630d375736b6e6b6b05c5cda5e73fbf7b2f2bd34c18a1d6cefede08625ce3046e77905cb8 +af2ebe1b7d073d03e3d98bc61af83bf26f7a8c130fd607aa92b75db22d14d016481b8aa231e2c9757695f55b7224a27f +a00ee882c9685e978041fd74a2c465f06e2a42ffd3db659053519925be5b454d6f401e3c12c746e49d910e4c5c9c5e8c +978a781c0e4e264e0dad57e438f1097d447d891a1e2aa0d5928f79a9d5c3faae6f258bc94fdc530b7b2fa6a9932bb193 +aa4b7ce2e0c2c9e9655bf21e3e5651c8503bce27483017b0bf476be743ba06db10228b3a4c721219c0779747f11ca282 +b003d1c459dacbcf1a715551311e45d7dbca83a185a65748ac74d1800bbeaba37765d9f5a1a221805c571910b34ebca8 +95b6e531b38648049f0d19de09b881baa1f7ea3b2130816b006ad5703901a05da57467d1a3d9d2e7c73fb3f2e409363c +a6cf9c06593432d8eba23a4f131bb7f72b9bd51ab6b4b772a749fe03ed72b5ced835a349c6d9920dba2a39669cb7c684 +aa3d59f6e2e96fbb66195bc58c8704e139fa76cd15e4d61035470bd6e305db9f98bcbf61ac1b95e95b69ba330454c1b3 +b57f97959c208361de6d7e86dff2b873068adb0f158066e646f42ae90e650079798f165b5cd713141cd3a2a90a961d9a +a76ee8ed9052f6a7a8c69774bb2597be182942f08115baba03bf8faaeaee526feba86120039fe8ca7b9354c3b6e0a8e6 +95689d78c867724823f564627d22d25010f278674c6d2d0cdb10329169a47580818995d1d727ce46c38a1e47943ebb89 +ab676d2256c6288a88e044b3d9ffd43eb9d5aaee00e8fc60ac921395fb835044c71a26ca948e557fed770f52d711e057 +96351c72785c32e5d004b6f4a1259fb8153d631f0c93fed172f18e8ba438fbc5585c1618deeabd0d6d0b82173c2e6170 +93dd8d3db576418e22536eba45ab7f56967c6c97c64260d6cddf38fb19c88f2ec5cd0e0156f50e70855eee8a2b879ffd +ad6ff16f40f6de3d7a737f8e6cebd8416920c4ff89dbdcd75eabab414af9a6087f83ceb9aff7680aa86bff98bd09c8cc +84de53b11671abc9c38710e19540c5c403817562aeb22a88404cdaff792c1180f717dbdfe8f54940c062c4d032897429 +872231b9efa1cdd447b312099a5c164c560440a9441d904e70f5abfc3b2a0d16be9a01aca5e0a2599a61e19407587e3d +88f44ac27094a2aa14e9dc40b099ee6d68f97385950f303969d889ee93d4635e34dff9239103bdf66a4b7cbba3e7eb7a +a59afebadf0260e832f6f44468443562f53fbaf7bcb5e46e1462d3f328ac437ce56edbca617659ac9883f9e13261fad7 +b1990e42743a88de4deeacfd55fafeab3bc380cb95de43ed623d021a4f2353530bcab9594389c1844b1c5ea6634c4555 +85051e841149a10e83f56764e042182208591396d0ce78c762c4a413e6836906df67f38c69793e158d64fef111407ba3 +9778172bbd9b1f2ec6bbdd61829d7b39a7df494a818e31c654bf7f6a30139899c4822c1bf418dd4f923243067759ce63 +9355005b4878c87804fc966e7d24f3e4b02bed35b4a77369d01f25a3dcbff7621b08306b1ac85b76fe7b4a3eb5f839b1 +8f9dc6a54fac052e236f8f0e1f571ac4b5308a43acbe4cc8183bce26262ddaf7994e41cf3034a4cbeca2c505a151e3b1 +8cc59c17307111723fe313046a09e0e32ea0cce62c13814ab7c6408c142d6a0311d801be4af53fc9240523f12045f9ef +8e6057975ed40a1932e47dd3ac778f72ee2a868d8540271301b1aa6858de1a5450f596466494a3e0488be4fbeb41c840 +812145efbd6559ae13325d56a15940ca4253b17e72a9728986b563bb5acc13ec86453796506ac1a8f12bd6f9e4a288c3 +911da0a6d6489eb3dab2ec4a16e36127e8a291ae68a6c2c9de33e97f3a9b1f00da57a94e270a0de79ecc5ecb45d19e83 +b72ea85973f4b2a7e6e71962b0502024e979a73c18a9111130e158541fa47bbaaf53940c8f846913a517dc69982ba9e1 +a7a56ad1dbdc55f177a7ad1d0af78447dc2673291e34e8ab74b26e2e2e7d8c5fe5dc89e7ef60f04a9508847b5b3a8188 +b52503f6e5411db5d1e70f5fb72ccd6463fa0f197b3e51ca79c7b5a8ab2e894f0030476ada72534fa4eb4e06c3880f90 +b51c7957a3d18c4e38f6358f2237b3904618d58b1de5dec53387d25a63772e675a5b714ad35a38185409931157d4b529 +b86b4266e719d29c043d7ec091547aa6f65bbf2d8d831d1515957c5c06513b72aa82113e9645ad38a7bc3f5383504fa6 +b95b547357e6601667b0f5f61f261800a44c2879cf94e879def6a105b1ad2bbf1795c3b98a90d588388e81789bd02681 +a58fd4c5ae4673fa350da6777e13313d5d37ed1dafeeb8f4f171549765b84c895875d9d3ae6a9741f3d51006ef81d962 +9398dc348d078a604aadc154e6eef2c0be1a93bb93ba7fe8976edc2840a3a318941338cc4d5f743310e539d9b46613d2 +902c9f0095014c4a2f0dccaaab543debba6f4cc82c345a10aaf4e72511725dbed7a34cd393a5f4e48a3e5142b7be84ed +a7c0447849bb44d04a0393a680f6cd390093484a79a147dd238f5d878030d1c26646d88211108e59fe08b58ad20c6fbd +80db045535d6e67a422519f5c89699e37098449d249698a7cc173a26ccd06f60238ae6cc7242eb780a340705c906790c +8e52b451a299f30124505de2e74d5341e1b5597bdd13301cc39b05536c96e4380e7f1b5c7ef076f5b3005a868657f17c +824499e89701036037571761e977654d2760b8ce21f184f2879fda55d3cda1e7a95306b8abacf1caa79d3cc075b9d27f +9049b956b77f8453d2070607610b79db795588c0cec12943a0f5fe76f358dea81e4f57a4692112afda0e2c05c142b26f +81911647d818a4b5f4990bfd4bc13bf7be7b0059afcf1b6839333e8569cdb0172fd2945410d88879349f677abaed5eb3 +ad4048f19b8194ed45b6317d9492b71a89a66928353072659f5ce6c816d8f21e69b9d1817d793effe49ca1874daa1096 +8d22f7b2ddb31458661abd34b65819a374a1f68c01fc6c9887edeba8b80c65bceadb8f57a3eb686374004b836261ef67 +92637280c259bc6842884db3d6e32602a62252811ae9b019b3c1df664e8809ffe86db88cfdeb8af9f46435c9ee790267 +a2f416379e52e3f5edc21641ea73dc76c99f7e29ea75b487e18bd233856f4c0183429f378d2bfc6cd736d29d6cadfa49 +882cb6b76dbdc188615dcf1a8439eba05ffca637dd25197508156e03c930b17b9fed2938506fdd7b77567cb488f96222 +b68b621bb198a763fb0634eddb93ed4b5156e59b96c88ca2246fd1aea3e6b77ed651e112ac41b30cd361fadc011d385e +a3cb22f6b675a29b2d1f827cacd30df14d463c93c3502ef965166f20d046af7f9ab7b2586a9c64f4eae4fad2d808a164 +8302d9ce4403f48ca217079762ce42cee8bc30168686bb8d3a945fbd5acd53b39f028dce757b825eb63af2d5ae41169d +b2eef1fbd1a176f1f4cd10f2988c7329abe4eb16c7405099fb92baa724ab397bc98734ef7d4b24c0f53dd90f57520d04 +a1bbef0bd684a3f0364a66bde9b29326bac7aa3dde4caed67f14fb84fed3de45c55e406702f1495a3e2864d4ee975030 +976acdb0efb73e3a3b65633197692dedc2adaed674291ae3df76b827fc866d214e9cac9ca46baefc4405ff13f953d936 +b9fbf71cc7b6690f601f0b1c74a19b7d14254183a2daaafec7dc3830cba5ae173d854bbfebeca985d1d908abe5ef0cda +90591d7b483598c94e38969c4dbb92710a1a894bcf147807f1bcbd8aa3ac210b9f2be65519aa829f8e1ccdc83ad9b8cf +a30568577c91866b9c40f0719d46b7b3b2e0b4a95e56196ac80898a2d89cc67880e1229933f2cd28ee3286f8d03414d7 +97589a88c3850556b359ec5e891f0937f922a751ac7c95949d3bbc7058c172c387611c0f4cb06351ef02e5178b3dd9e4 +98e7bbe27a1711f4545df742f17e3233fbcc63659d7419e1ca633f104cb02a32c84f2fac23ca2b84145c2672f68077ab +a7ddb91636e4506d8b7e92aa9f4720491bb71a72dadc47c7f4410e15f93e43d07d2b371951a0e6a18d1bd087aa96a5c4 +a7c006692227a06db40bceac3d5b1daae60b5692dd9b54772bedb5fea0bcc91cbcdb530cac31900ffc70c5b3ffadc969 +8d3ec6032778420dfa8be52066ba0e623467df33e4e1901dbadd586c5d750f4ccde499b5197e26b9ea43931214060f69 +8d9a8410518ea64f89df319bfd1fc97a0971cdb9ad9b11d1f8fe834042ea7f8dce4db56eeaf179ff8dda93b6db93e5ce +a3c533e9b3aa04df20b9ff635cb1154ce303e045278fcf3f10f609064a5445552a1f93989c52ce852fd0bbd6e2b6c22e +81934f3a7f8c1ae60ec6e4f212986bcc316118c760a74155d06ce0a8c00a9b9669ec4e143ca214e1b995e41271774fd9 +ab8e2d01a71192093ef8fafa7485e795567cc9db95a93fb7cc4cf63a391ef89af5e2bfad4b827fffe02b89271300407f +83064a1eaa937a84e392226f1a60b7cfad4efaa802f66de5df7498962f7b2649924f63cd9962d47906380b97b9fe80e1 +b4f5e64a15c6672e4b55417ee5dc292dcf93d7ea99965a888b1cc4f5474a11e5b6520eacbcf066840b343f4ceeb6bf33 +a63d278b842456ef15c278b37a6ea0f27c7b3ffffefca77c7a66d2ea06c33c4631eb242bbb064d730e70a8262a7b848a +83a41a83dbcdf0d22dc049de082296204e848c453c5ab1ba75aa4067984e053acf6f8b6909a2e1f0009ed051a828a73b +819485b036b7958508f15f3c19436da069cbe635b0318ebe8c014cf1ef9ab2df038c81161b7027475bcfa6fff8dd9faf +aa40e38172806e1e045e167f3d1677ef12d5dcdc89b43639a170f68054bd196c4fae34c675c1644d198907a03f76ba57 +969bae484883a9ed1fbed53b26b3d4ee4b0e39a6c93ece5b3a49daa01444a1c25727dabe62518546f36b047b311b177c +80a9e73a65da99664988b238096a090d313a0ee8e4235bc102fa79bb337b51bb08c4507814eb5baec22103ec512eaab0 +86604379aec5bddda6cbe3ef99c0ac3a3c285b0b1a15b50451c7242cd42ae6b6c8acb717dcca7917838432df93a28502 +a23407ee02a495bed06aa7e15f94cfb05c83e6d6fba64456a9bbabfa76b2b68c5c47de00ba169e710681f6a29bb41a22 +98cff5ecc73b366c6a01b34ac9066cb34f7eeaf4f38a5429bad2d07e84a237047e2a065c7e8a0a6581017dadb4695deb +8de9f68a938f441f3b7ab84bb1f473c5f9e5c9e139e42b7ccee1d254bd57d0e99c2ccda0f3198f1fc5737f6023dd204e +b0ce48d815c2768fb472a315cad86aa033d0e9ca506f146656e2941829e0acb735590b4fbc713c2d18d3676db0a954ac +82f485cdefd5642a6af58ac6817991c49fac9c10ace60f90b27f1788cc026c2fe8afc83cf499b3444118f9f0103598a8 +82c24550ed512a0d53fc56f64cc36b553823ae8766d75d772dacf038c460f16f108f87a39ceef7c66389790f799dbab3 +859ffcf1fe9166388316149b9acc35694c0ea534d43f09dae9b86f4aa00a23b27144dda6a352e74b9516e8c8d6fc809c +b8f7f353eec45da77fb27742405e5ad08d95ec0f5b6842025be9def3d9892f85eb5dd0921b41e6eff373618dba215bca +8ccca4436f9017e426229290f5cd05eac3f16571a4713141a7461acfe8ae99cd5a95bf5b6df129148693c533966145da +a2c67ecc19c0178b2994846fea4c34c327a5d786ac4b09d1d13549d5be5996d8a89021d63d65cb814923388f47cc3a03 +aa0ff87d676b418ec08f5cbf577ac7e744d1d0e9ebd14615b550eb86931eafd2a36d4732cc5d6fab1713fd7ab2f6f7c0 +8aef4730bb65e44efd6bb9441c0ae897363a2f3054867590a2c2ecf4f0224e578c7a67f10b40f8453d9f492ac15a9b2d +86a187e13d8fba5addcfdd5b0410cedd352016c930f913addd769ee09faa6be5ca3e4b1bdb417a965c643a99bd92be42 +a0a4e9632a7a094b14b29b78cd9c894218cdf6783e61671e0203865dc2a835350f465fbaf86168f28af7c478ca17bc89 +a8c7b02d8deff2cd657d8447689a9c5e2cd74ef57c1314ac4d69084ac24a7471954d9ff43fe0907d875dcb65fd0d3ce5 +97ded38760aa7be6b6960b5b50e83b618fe413cbf2bcc1da64c05140bcc32f5e0e709cd05bf8007949953fac5716bad9 +b0d293835a24d64c2ae48ce26e550b71a8c94a0883103757fb6b07e30747f1a871707d23389ba2b2065fa6bafe220095 +8f9e291bf849feaa575592e28e3c8d4b7283f733d41827262367ea1c40f298c7bcc16505255a906b62bf15d9f1ba85fb +998f4e2d12708b4fd85a61597ca2eddd750f73c9e0c9b3cf0825d8f8e01f1628fd19797dcaed3b16dc50331fc6b8b821 +b30d1f8c115d0e63bf48f595dd10908416774c78b3bbb3194192995154d80ea042d2e94d858de5f8aa0261b093c401fd +b5d9c75bb41f964cbff3f00e96d9f1480c91df8913f139f0d385d27a19f57a820f838eb728e46823cbff00e21c660996 +a6edec90b5d25350e2f5f0518777634f9e661ec9d30674cf5b156c4801746d62517751d90074830ac0f4b09911c262f1 +82f98da1264b6b75b8fbeb6a4d96d6a05b25c24db0d57ba3a38efe3a82d0d4e331b9fc4237d6494ccfe4727206457519 +b89511843453cf4ecd24669572d6371b1e529c8e284300c43e0d5bb6b3aaf35aeb634b3cb5c0a2868f0d5e959c1d0772 +a82bf065676583e5c1d3b81987aaae5542f522ba39538263a944bb33ea5b514c649344a96c0205a3b197a3f930fcda6c +a37b47ea527b7e06c460776aa662d9a49ff4149d3993f1a974b0dd165f7171770d189b0e2ea54fd5fccb6a14b116e68a +a1017677f97dda818274d47556d09d0e4ccacb23a252f82a6cfe78c630ad46fb9806307445a59fb61262182de3a2b29c +b01e9fcac239ba270e6877b79273ddd768bf8a51d2ed8a051b1c11e18eff3de5920e2fcbfbd26f06d381eddd3b1f1e1b +82fcd53d803b1c8e4ed76adc339b7f3a5962d37042b9683aabac7513ac68775d4a566a9460183926a6a95dbe7d551a1f +a763e78995d55cd21cdb7ef75d9642d6e1c72453945e346ab6690c20a4e1eeec61bb848ef830ae4b56182535e3c71d8f +b769f4db602251d4b0a1186782799bdcef66de33c110999a5775c50b349666ffd83d4c89714c4e376f2efe021a5cfdb2 +a59cbd1b785efcfa6e83fc3b1d8cf638820bc0c119726b5368f3fba9dce8e3414204fb1f1a88f6c1ff52e87961252f97 +95c8c458fd01aa23ecf120481a9c6332ebec2e8bb70a308d0576926a858457021c277958cf79017ddd86a56cacc2d7db +82eb41390800287ae56e77f2e87709de5b871c8bdb67c10a80fc65f3acb9f7c29e8fa43047436e8933f27449ea61d94d +b3ec25e3545eb83aed2a1f3558d1a31c7edde4be145ecc13b33802654b77dc049b4f0065069dd9047b051e52ab11dcdd +b78a0c715738f56f0dc459ab99e252e3b579b208142836b3c416b704ca1de640ca082f29ebbcee648c8c127df06f6b1e +a4083149432eaaf9520188ebf4607d09cf664acd1f471d4fb654476e77a9eaae2251424ffda78d09b6cb880df35c1219 +8c52857d68d6e9672df3db2df2dbf46b516a21a0e8a18eec09a6ae13c1ef8f369d03233320dd1c2c0bbe00abfc1ea18b +8c856089488803066bff3f8d8e09afb9baf20cecc33c8823c1c0836c3d45498c3de37e87c016b705207f60d2b00f8609 +831a3df39be959047b2aead06b4dcd3012d7b29417f642b83c9e8ce8de24a3dbbd29c6fdf55e2db3f7ea04636c94e403 +aed84d009f66544addabe404bf6d65af7779ce140dc561ff0c86a4078557b96b2053b7b8a43432ffb18cd814f143b9da +93282e4d72b0aa85212a77b336007d8ba071eea17492da19860f1ad16c1ea8867ccc27ef5c37c74b052465cc11ea4f52 +a7b78b8c8d057194e8d68767f1488363f77c77bddd56c3da2bc70b6354c7aa76247c86d51f7371aa38a4aa7f7e3c0bb7 +b1c77283d01dcd1bde649b5b044eac26befc98ff57cbee379fb5b8e420134a88f2fc7f0bf04d15e1fbd45d29e7590fe6 +a4aa8de70330a73b2c6458f20a1067eed4b3474829b36970a8df125d53bbdda4f4a2c60063b7cccb0c80fc155527652f +948a6c79ba1b8ad7e0bed2fae2f0481c4e41b4d9bbdd9b58164e28e9065700e83f210c8d5351d0212e0b0b68b345b3a5 +86a48c31dcbbf7b082c92d28e1f613a2378a910677d7db3a349dc089e4a1e24b12eee8e8206777a3a8c64748840b7387 +976adb1af21e0fc34148917cf43d933d7bfd3fd12ed6c37039dcd5a4520e3c6cf5868539ba5bf082326430deb8a4458d +b93e1a4476f2c51864bb4037e7145f0635eb2827ab91732b98d49b6c07f6ac443111aa1f1da76d1888665cb897c3834e +8afd46fb23bf869999fa19784b18a432a1f252d09506b8dbb756af900518d3f5f244989b3d7c823d9029218c655d3dc6 +83f1e59e3abeed18cdc632921672673f1cb6e330326e11c4e600e13e0d5bc11bdc970ae12952e15103a706fe720bf4d6 +90ce4cc660714b0b673d48010641c09c00fc92a2c596208f65c46073d7f349dd8e6e077ba7dcef9403084971c3295b76 +8b09b0f431a7c796561ecf1549b85048564de428dac0474522e9558b6065fede231886bc108539c104ce88ebd9b5d1b0 +85d6e742e2fb16a7b0ba0df64bc2c0dbff9549be691f46a6669bca05e89c884af16822b85faefefb604ec48c8705a309 +a87989ee231e468a712c66513746fcf03c14f103aadca0eac28e9732487deb56d7532e407953ab87a4bf8961588ef7b0 +b00da10efe1c29ee03c9d37d5918e391ae30e48304e294696b81b434f65cf8c8b95b9d1758c64c25e534d045ba28696f +91c0e1fb49afe46c7056400baa06dbb5f6e479db78ee37e2d76c1f4e88994357e257b83b78624c4ef6091a6c0eb8254d +883fb797c498297ccbf9411a3e727c3614af4eccde41619b773dc7f3259950835ee79453debf178e11dec4d3ada687a0 +a14703347e44eb5059070b2759297fcfcfc60e6893c0373eea069388eba3950aa06f1c57cd2c30984a2d6f9e9c92c79e +afebc7585b304ceba9a769634adff35940e89cd32682c78002822aab25eec3edc29342b7f5a42a56a1fec67821172ad5 +aea3ff3822d09dba1425084ca95fd359718d856f6c133c5fabe2b2eed8303b6e0ba0d8698b48b93136a673baac174fd9 +af2456a09aa777d9e67aa6c7c49a1845ea5cdda2e39f4c935c34a5f8280d69d4eec570446998cbbe31ede69a91e90b06 +82cada19fed16b891ef3442bafd49e1f07c00c2f57b2492dd4ee36af2bd6fd877d6cb41188a4d6ce9ec8d48e8133d697 +82a21034c832287f616619a37c122cee265cc34ae75e881fcaea4ea7f689f3c2bc8150bbf7dbcfd123522bfb7f7b1d68 +86877217105f5d0ec3eeff0289fc2a70d505c9fdf7862e8159553ef60908fb1a27bdaf899381356a4ef4649072a9796c +82b196e49c6e861089a427c0b4671d464e9d15555ffb90954cd0d630d7ae02eb3d98ceb529d00719c2526cd96481355a +a29b41d0d43d26ce76d4358e0db2b77df11f56e389f3b084d8af70a636218bd3ac86b36a9fe46ec9058c26a490f887f7 +a4311c4c20c4d7dd943765099c50f2fd423e203ccfe98ff00087d205467a7873762510cac5fdce7a308913ed07991ed7 +b1f040fc5cc51550cb2c25cf1fd418ecdd961635a11f365515f0cb4ffb31da71f48128c233e9cc7c0cf3978d757ec84e +a9ebae46f86d3bd543c5f207ed0d1aed94b8375dc991161d7a271f01592912072e083e2daf30c146430894e37325a1b9 +826418c8e17ad902b5fe88736323a47e0ca7a44bce4cbe27846ec8fe81de1e8942455dda6d30e192cdcc73e11df31256 +85199db563427c5edcbac21f3d39fec2357be91fb571982ddcdc4646b446ad5ced84410de008cb47b3477ee0d532daf8 +b7eed9cd400b2ca12bf1d9ae008214b8561fb09c8ad9ff959e626ffde00fee5ff2f5b6612e231f2a1a9b1646fcc575e3 +8b40bf12501dcbac78f5a314941326bfcddf7907c83d8d887d0bb149207f85d80cd4dfbd7935439ea7b14ea39a3fded7 +83e3041af302485399ba6cd5120e17af61043977083887e8d26b15feec4a6b11171ac5c06e6ad0971d4b58a81ff12af3 +8f5b9a0eecc589dbf8c35a65d5e996a659277ef6ea509739c0cb7b3e2da9895e8c8012de662e5b23c5fa85d4a8f48904 +835d71ed5e919d89d8e6455f234f3ff215462c4e3720c371ac8c75e83b19dfe3ae15a81547e4dc1138e5f5997f413cc9 +8b7d2e4614716b1db18e9370176ea483e6abe8acdcc3dcdf5fb1f4d22ca55d652feebdccc171c6de38398d9f7bfdec7a +93eace72036fe57d019676a02acf3d224cf376f166658c1bf705db4f24295881d477d6fdd7916efcfceff8c7a063deda +b1ac460b3d516879a84bc886c54f020a9d799e7c49af3e4d7de5bf0d2793c852254c5d8fe5616147e6659512e5ccb012 +acd0947a35cb167a48bcd9667620464b54ac0e78f9316b4aa92dcaab5422d7a732087e52e1c827faa847c6b2fe6e7766 +94ac33d21c3d12ff762d32557860e911cd94d666609ddcc42161b9c16f28d24a526e8b10bb03137257a92cec25ae637d +832e02058b6b994eadd8702921486241f9a19e68ed1406dad545e000a491ae510f525ccf9d10a4bba91c68f2c53a0f58 +9471035d14f78ff8f463b9901dd476b587bb07225c351161915c2e9c6114c3c78a501379ab6fb4eb03194c457cbd22bf +ab64593e034c6241d357fcbc32d8ea5593445a5e7c24cac81ad12bd2ef01843d477a36dc1ba21dbe63b440750d72096a +9850f3b30045e927ad3ec4123a32ed2eb4c911f572b6abb79121873f91016f0d80268de8b12e2093a4904f6e6cab7642 +987212c36b4722fe2e54fa30c52b1e54474439f9f35ca6ad33c5130cd305b8b54b532dd80ffd2c274105f20ce6d79f6e +8b4d0c6abcb239b5ed47bef63bc17efe558a27462c8208fa652b056e9eae9665787cd1aee34fbb55beb045c8bfdb882b +a9f3483c6fee2fe41312d89dd4355d5b2193ac413258993805c5cbbf0a59221f879386d3e7a28e73014f10e65dd503d9 +a2225da3119b9b7c83d514b9f3aeb9a6d9e32d9cbf9309cbb971fd53c4b2c001d10d880a8ad8a7c281b21d85ceca0b7c +a050be52e54e676c151f7a54453bbb707232f849beab4f3bf504b4d620f59ed214409d7c2bd3000f3ff13184ccda1c35 +adbccf681e15b3edb6455a68d292b0a1d0f5a4cb135613f5e6db9943f02181341d5755875db6ee474e19ace1c0634a28 +8b6eff675632a6fad0111ec72aacc61c7387380eb87933fd1d098856387d418bd38e77d897e65d6fe35951d0627c550b +aabe2328ddf90989b15e409b91ef055cb02757d34987849ae6d60bef2c902bf8251ed21ab30acf39e500d1d511e90845 +92ba4eb1f796bc3d8b03515f65c045b66e2734c2da3fc507fdd9d6b5d1e19ab3893726816a32141db7a31099ca817d96 +8a98b3cf353138a1810beb60e946183803ef1d39ac4ea92f5a1e03060d35a4774a6e52b14ead54f6794d5f4022b8685c +909f8a5c13ec4a59b649ed3bee9f5d13b21d7f3e2636fd2bb3413c0646573fdf9243d63083356f12f5147545339fcd55 +9359d914d1267633141328ed0790d81c695fea3ddd2d406c0df3d81d0c64931cf316fe4d92f4353c99ff63e2aefc4e34 +b88302031681b54415fe8fbfa161c032ea345c6af63d2fb8ad97615103fd4d4281c5a9cae5b0794c4657b97571a81d3b +992c80192a519038082446b1fb947323005b275e25f2c14c33cc7269e0ec038581cc43705894f94bad62ae33a8b7f965 +a78253e3e3eece124bef84a0a8807ce76573509f6861d0b6f70d0aa35a30a123a9da5e01e84969708c40b0669eb70aa6 +8d5724de45270ca91c94792e8584e676547d7ac1ac816a6bb9982ee854eb5df071d20545cdfd3771cd40f90e5ba04c8e +825a6f586726c68d45f00ad0f5a4436523317939a47713f78fd4fe81cd74236fdac1b04ecd97c2d0267d6f4981d7beb1 +b5bfd7dd8cdeb128843bc287230af38926187075cbfbefa81009a2ce615ac53d2914e5870cb452d2afaaab24f3499f72185cbfee53492714734429b7b38608e23926c911cceceac9a36851477ba4c60b087041de621000edc98edada20c1def2 +b5337ba0ce5d37224290916e268e2060e5c14f3f9fc9e1ec3af5a958e7a0303122500ce18f1a4640bf66525bd10e763501fe986d86649d8d45143c08c3209db3411802c226e9fe9a55716ac4a0c14f9dcef9e70b2bb309553880dc5025eab3cc +b3c1dcdc1f62046c786f0b82242ef283e7ed8f5626f72542aa2c7a40f14d9094dd1ebdbd7457ffdcdac45fd7da7e16c51200b06d791e5e43e257e45efdf0bd5b06cd2333beca2a3a84354eb48662d83aef5ecf4e67658c851c10b13d8d87c874 +954d91c7688983382609fca9e211e461f488a5971fd4e40d7e2892037268eacdfd495cfa0a7ed6eb0eb11ac3ae6f651716757e7526abe1e06c64649d80996fd3105c20c4c94bc2b22d97045356fe9d791f21ea6428ac48db6f9e68e30d875280 +88a6b6bb26c51cf9812260795523973bb90ce80f6820b6c9048ab366f0fb96e48437a7f7cb62aedf64b11eb4dfefebb0147608793133d32003cb1f2dc47b13b5ff45f1bb1b2408ea45770a08dbfaec60961acb8119c47b139a13b8641e2c9487 +85cd7be9728bd925d12f47fb04b32d9fad7cab88788b559f053e69ca18e463113ecc8bbb6dbfb024835f901b3a957d3108d6770fb26d4c8be0a9a619f6e3a4bf15cbfd48e61593490885f6cee30e4300c5f9cf5e1c08e60a2d5b023ee94fcad0 +80477dba360f04399821a48ca388c0fa81102dd15687fea792ee8c1114e00d1bc4839ad37ac58900a118d863723acfbe08126ea883be87f50e4eabe3b5e72f5d9e041db8d9b186409fd4df4a7dde38c0e0a3b1ae29b098e5697e7f110b6b27e4 +b7a6aec08715a9f8672a2b8c367e407be37e59514ac19dd4f0942a68007bba3923df22da48702c63c0d6b3efd3c2d04e0fe042d8b5a54d562f9f33afc4865dcbcc16e99029e25925580e87920c399e710d438ac1ce3a6dc9b0d76c064a01f6f7 +ac1b001edcea02c8258aeffbf9203114c1c874ad88dae1184fadd7d94cd09053649efd0ca413400e6e9b5fa4eac33261000af88b6bd0d2abf877a4f0355d2fb4d6007adb181695201c5432e50b850b51b3969f893bddf82126c5a71b042b7686 +90043fda4de53fb364fab2c04be5296c215599105ecff0c12e4917c549257125775c29f2507124d15f56e30447f367db0596c33237242c02d83dfd058735f1e3c1ff99069af55773b6d51d32a68bf75763f59ec4ee7267932ae426522b8aaab6 +a8660ce853e9dc08271bf882e29cd53397d63b739584dda5263da4c7cc1878d0cf6f3e403557885f557e184700575fee016ee8542dec22c97befe1d10f414d22e84560741cdb3e74c30dda9b42eeaaf53e27822de2ee06e24e912bf764a9a533 +8fe3921a96d0d065e8aa8fce9aa42c8e1461ca0470688c137be89396dd05103606dab6cdd2a4591efd6addf72026c12e065da7be276dee27a7e30afa2bd81c18f1516e7f068f324d0bad9570b95f6bd02c727cd2343e26db0887c3e4e26dceda +8ae1ad97dcb9c192c9a3933541b40447d1dc4eebf380151440bbaae1e120cc5cdf1bcea55180b128d8e180e3af623815191d063cc0d7a47d55fb7687b9d87040bf7bc1a7546b07c61db5ccf1841372d7c2fe4a5431ffff829f3c2eb590b0b710 +8c2fa96870a88150f7876c931e2d3cc2adeaaaf5c73ef5fa1cf9dfa0991ae4819f9321af7e916e5057d87338e630a2f21242c29d76963cf26035b548d2a63d8ad7bd6efefa01c1df502cbdfdfe0334fb21ceb9f686887440f713bf17a89b8081 +b9aa98e2f02bb616e22ee5dd74c7d1049321ac9214d093a738159850a1dbcc7138cb8d26ce09d8296368fd5b291d74fa17ac7cc1b80840fdd4ee35e111501e3fa8485b508baecda7c1ab7bd703872b7d64a2a40b3210b6a70e8a6ffe0e5127e3 +9292db67f8771cdc86854a3f614a73805bf3012b48f1541e704ea4015d2b6b9c9aaed36419769c87c49f9e3165f03edb159c23b3a49c4390951f78e1d9b0ad997129b17cdb57ea1a6638794c0cca7d239f229e589c5ae4f9fe6979f7f8cba1d7 +91cd9e86550f230d128664f7312591fee6a84c34f5fc7aed557bcf986a409a6de722c4330453a305f06911d2728626e611acfdf81284f77f60a3a1595053a9479964fd713117e27c0222cc679674b03bc8001501aaf9b506196c56de29429b46 +a9516b73f605cc31b89c68b7675dc451e6364595243d235339437f556cf22d745d4250c1376182273be2d99e02c10eee047410a43eff634d051aeb784e76cb3605d8e079b9eb6ad1957dfdf77e1cd32ce4a573c9dfcc207ca65af6eb187f6c3d +a9667271f7d191935cc8ad59ef3ec50229945faea85bfdfb0d582090f524436b348aaa0183b16a6231c00332fdac2826125b8c857a2ed9ec66821cfe02b3a2279be2412441bc2e369b255eb98614e4be8490799c4df22f18d47d24ec70bba5f7 +a4371144d2aa44d70d3cb9789096d3aa411149a6f800cb46f506461ee8363c8724667974252f28aea61b6030c05930ac039c1ee64bb4bd56532a685cae182bf2ab935eee34718cffcb46cae214c77aaca11dbb1320faf23c47247db1da04d8dc +89a7eb441892260b7e81168c386899cd84ffc4a2c5cad2eae0d1ab9e8b5524662e6f660fe3f8bfe4c92f60b060811bc605b14c5631d16709266886d7885a5eb5930097127ec6fb2ebbaf2df65909cf48f253b3d5e22ae48d3e9a2fd2b01f447e +9648c42ca97665b5eccb49580d8532df05eb5a68db07f391a2340769b55119eaf4c52fe4f650c09250fa78a76c3a1e271799b8333cc2628e3d4b4a6a3e03da1f771ecf6516dd63236574a7864ff07e319a6f11f153406280d63af9e2b5713283 +9663bf6dd446ea7a90658ee458578d4196dc0b175ef7fcfa75f44d41670850774c2e46c5a6be132a2c072a3c0180a24f0305d1acac49d2d79878e5cda80c57feda3d01a6af12e78b5874e2a4b3717f11c97503b41a4474e2e95b179113726199 +b212aeb4814e0915b432711b317923ed2b09e076aaf558c3ae8ef83f9e15a83f9ea3f47805b2750ab9e8106cb4dc6ad003522c84b03dc02829978a097899c773f6fb31f7fe6b8f2d836d96580f216fec20158f1590c3e0d7850622e15194db05 +925f005059bf07e9ceccbe66c711b048e236ade775720d0fe479aebe6e23e8af281225ad18e62458dc1b03b42ad4ca290d4aa176260604a7aad0d9791337006fbdebe23746f8060d42876f45e4c83c3643931392fde1cd13ff8bddf8111ef974 +9553edb22b4330c568e156a59ef03b26f5c326424f830fe3e8c0b602f08c124730ffc40bc745bec1a22417adb22a1a960243a10565c2be3066bfdb841d1cd14c624cd06e0008f4beb83f972ce6182a303bee3fcbcabc6cfe48ec5ae4b7941bfc +935f5a404f0a78bdcce709899eda0631169b366a669e9b58eacbbd86d7b5016d044b8dfc59ce7ed8de743ae16c2343b50e2f925e88ba6319e33c3fc76b314043abad7813677b4615c8a97eb83cc79de4fedf6ccbcfa4d4cbf759a5a84e4d9742 +a5b014ab936eb4be113204490e8b61cd38d71da0dec7215125bcd131bf3ab22d0a32ce645bca93e7b3637cf0c2db3d6601a0ddd330dc46f9fae82abe864ffc12d656c88eb50c20782e5bb6f75d18760666f43943abb644b881639083e122f557 +935b7298ae52862fa22bf03bfc1795b34c70b181679ae27de08a9f5b4b884f824ef1b276b7600efa0d2f1d79e4a470d51692fd565c5cf8343dd80e5d3336968fc21c09ba9348590f6206d4424eb229e767547daefa98bc3aa9f421158dee3f2a +9830f92446e708a8f6b091cc3c38b653505414f8b6507504010a96ffda3bcf763d5331eb749301e2a1437f00e2415efb01b799ad4c03f4b02de077569626255ac1165f96ea408915d4cf7955047620da573e5c439671d1fa5c833fb11de7afe6 +840dcc44f673fff3e387af2bb41e89640f2a70bcd2b92544876daa92143f67c7512faf5f90a04b7191de01f3e2b1bde00622a20dc62ca23bbbfaa6ad220613deff43908382642d4d6a86999f662efd64b1df448b68c847cfa87630a3ffd2ec76 +92950c895ed54f7f876b2fda17ecc9c41b7accfbdd42c210cc5b475e0737a7279f558148531b5c916e310604a1de25a80940c94fe5389ae5d6a5e9c371be67bceea1877f5401725a6595bcf77ece60905151b6dfcb68b75ed2e708c73632f4fd +8010246bf8e94c25fd029b346b5fbadb404ef6f44a58fd9dd75acf62433d8cc6db66974f139a76e0c26dddc1f329a88214dbb63276516cf325c7869e855d07e0852d622c332ac55609ba1ec9258c45746a2aeb1af0800141ee011da80af175d4 +b0f1bad257ebd187bdc3f37b23f33c6a5d6a8e1f2de586080d6ada19087b0e2bf23b79c1b6da1ee82271323f5bdf3e1b018586b54a5b92ab6a1a16bb3315190a3584a05e6c37d5ca1e05d702b9869e27f513472bcdd00f4d0502a107773097da +9636d24f1ede773ce919f309448dd7ce023f424afd6b4b69cb98c2a988d849a283646dc3e469879daa1b1edae91ae41f009887518e7eb5578f88469321117303cd3ac2d7aee4d9cb5f82ab9ae3458e796dfe7c24284b05815acfcaa270ff22e2 +b373feb5d7012fd60578d7d00834c5c81df2a23d42794fed91aa9535a4771fde0341c4da882261785e0caca40bf83405143085e7f17e55b64f6c5c809680c20b050409bf3702c574769127c854d27388b144b05624a0e24a1cbcc4d08467005b +b15680648949ce69f82526e9b67d9b55ce5c537dc6ab7f3089091a9a19a6b90df7656794f6edc87fb387d21573ffc847062623685931c2790a508cbc8c6b231dd2c34f4d37d4706237b1407673605a604bcf6a50cc0b1a2db20485e22b02c17e +8817e46672d40c8f748081567b038a3165f87994788ec77ee8daea8587f5540df3422f9e120e94339be67f186f50952504cb44f61e30a5241f1827e501b2de53c4c64473bcc79ab887dd277f282fbfe47997a930dd140ac08b03efac88d81075 +a6e4ef6c1d1098f95aae119905f87eb49b909d17f9c41bcfe51127aa25fee20782ea884a7fdf7d5e9c245b5a5b32230b07e0dbf7c6743bf52ee20e2acc0b269422bd6cf3c07115df4aa85b11b2c16630a07c974492d9cdd0ec325a3fabd95044 +8634aa7c3d00e7f17150009698ce440d8e1b0f13042b624a722ace68ead870c3d2212fbee549a2c190e384d7d6ac37ce14ab962c299ea1218ef1b1489c98906c91323b94c587f1d205a6edd5e9d05b42d591c26494a6f6a029a2aadb5f8b6f67 +821a58092900bdb73decf48e13e7a5012a3f88b06288a97b855ef51306406e7d867d613d9ec738ebacfa6db344b677d21509d93f3b55c2ebf3a2f2a6356f875150554c6fff52e62e3e46f7859be971bf7dd9d5b3e1d799749c8a97c2e04325df +8dba356577a3a388f782e90edb1a7f3619759f4de314ad5d95c7cc6e197211446819c4955f99c5fc67f79450d2934e3c09adefc91b724887e005c5190362245eec48ce117d0a94d6fa6db12eda4ba8dde608fbbd0051f54dcf3bb057adfb2493 +a32a690dc95c23ed9fb46443d9b7d4c2e27053a7fcc216d2b0020a8cf279729c46114d2cda5772fd60a97016a07d6c5a0a7eb085a18307d34194596f5b541cdf01b2ceb31d62d6b55515acfd2b9eec92b27d082fbc4dc59fc63b551eccdb8468 +a040f7f4be67eaf0a1d658a3175d65df21a7dbde99bfa893469b9b43b9d150fc2e333148b1cb88cfd0447d88fa1a501d126987e9fdccb2852ecf1ba907c2ca3d6f97b055e354a9789854a64ecc8c2e928382cf09dda9abde42bbdf92280cdd96 +864baff97fa60164f91f334e0c9be00a152a416556b462f96d7c43b59fe1ebaff42f0471d0bf264976f8aa6431176eb905bd875024cf4f76c13a70bede51dc3e47e10b9d5652d30d2663b3af3f08d5d11b9709a0321aba371d2ef13174dcfcaf +95a46f32c994133ecc22db49bad2c36a281d6b574c83cfee6680b8c8100466ca034b815cfaedfbf54f4e75188e661df901abd089524e1e0eb0bf48d48caa9dd97482d2e8c1253e7e8ac250a32fd066d5b5cb08a8641bdd64ecfa48289dca83a3 +a2cce2be4d12144138cb91066e0cd0542c80b478bf467867ebef9ddaf3bd64e918294043500bf5a9f45ee089a8d6ace917108d9ce9e4f41e7e860cbce19ac52e791db3b6dde1c4b0367377b581f999f340e1d6814d724edc94cb07f9c4730774 +b145f203eee1ac0a1a1731113ffa7a8b0b694ef2312dabc4d431660f5e0645ef5838e3e624cfe1228cfa248d48b5760501f93e6ab13d3159fc241427116c4b90359599a4cb0a86d0bb9190aa7fabff482c812db966fd2ce0a1b48cb8ac8b3bca +adabe5d215c608696e03861cbd5f7401869c756b3a5aadc55f41745ad9478145d44393fec8bb6dfc4ad9236dc62b9ada0f7ca57fe2bae1b71565dbf9536d33a68b8e2090b233422313cc96afc7f1f7e0907dc7787806671541d6de8ce47c4cd0 +ae7845fa6b06db53201c1080e01e629781817f421f28956589c6df3091ec33754f8a4bd4647a6bb1c141ac22731e3c1014865d13f3ed538dcb0f7b7576435133d9d03be655f8fbb4c9f7d83e06d1210aedd45128c2b0c9bab45a9ddde1c862a5 +9159eaa826a24adfa7adf6e8d2832120ebb6eccbeb3d0459ffdc338548813a2d239d22b26451fda98cc0c204d8e1ac69150b5498e0be3045300e789bcb4e210d5cd431da4bdd915a21f407ea296c20c96608ded0b70d07188e96e6c1a7b9b86b +a9fc6281e2d54b46458ef564ffaed6944bff71e389d0acc11fa35d3fcd8e10c1066e0dde5b9b6516f691bb478e81c6b20865281104dcb640e29dc116daae2e884f1fe6730d639dbe0e19a532be4fb337bf52ae8408446deb393d224eee7cfa50 +84291a42f991bfb36358eedead3699d9176a38f6f63757742fdbb7f631f2c70178b1aedef4912fed7b6cf27e88ddc7eb0e2a6aa4b999f3eb4b662b93f386c8d78e9ac9929e21f4c5e63b12991fcde93aa64a735b75b535e730ff8dd2abb16e04 +a1b7fcacae181495d91765dfddf26581e8e39421579c9cbd0dd27a40ea4c54af3444a36bf85a11dda2114246eaddbdd619397424bb1eb41b5a15004b902a590ede5742cd850cf312555be24d2df8becf48f5afba5a8cd087cb7be0a521728386 +92feaaf540dbd84719a4889a87cdd125b7e995a6782911931fef26da9afcfbe6f86aaf5328fe1f77631491ce6239c5470f44c7791506c6ef1626803a5794e76d2be0af92f7052c29ac6264b7b9b51f267ad820afc6f881460521428496c6a5f1 +a525c925bfae1b89320a5054acc1fa11820f73d0cf28d273092b305467b2831fab53b6daf75fb926f332782d50e2522a19edcd85be5eb72f1497193c952d8cd0bcc5d43b39363b206eae4cb1e61668bde28a3fb2fc1e0d3d113f6dfadb799717 +98752bb6f5a44213f40eda6aa4ff124057c1b13b6529ab42fe575b9afa66e59b9c0ed563fb20dff62130c436c3e905ee17dd8433ba02c445b1d67182ab6504a90bbe12c26a754bbf734665c622f76c62fe2e11dd43ce04fd2b91a8463679058b +a9aa9a84729f7c44219ff9e00e651e50ddea3735ef2a73fdf8ed8cd271961d8ed7af5cd724b713a89a097a3fe65a3c0202f69458a8b4c157c62a85668b12fc0d3957774bc9b35f86c184dd03bfefd5c325da717d74192cc9751c2073fe9d170e +b221c1fd335a4362eff504cd95145f122bf93ea02ae162a3fb39c75583fc13a932d26050e164da97cff3e91f9a7f6ff80302c19dd1916f24acf6b93b62f36e9665a8785413b0c7d930c7f1668549910f849bca319b00e59dd01e5dec8d2edacc +a71e2b1e0b16d754b848f05eda90f67bedab37709550171551050c94efba0bfc282f72aeaaa1f0330041461f5e6aa4d11537237e955e1609a469d38ed17f5c2a35a1752f546db89bfeff9eab78ec944266f1cb94c1db3334ab48df716ce408ef +b990ae72768779ba0b2e66df4dd29b3dbd00f901c23b2b4a53419226ef9232acedeb498b0d0687c463e3f1eead58b20b09efcefa566fbfdfe1c6e48d32367936142d0a734143e5e63cdf86be7457723535b787a9cfcfa32fe1d61ad5a2617220 +8d27e7fbff77d5b9b9bbc864d5231fecf817238a6433db668d5a62a2c1ee1e5694fdd90c3293c06cc0cb15f7cbeab44d0d42be632cb9ff41fc3f6628b4b62897797d7b56126d65b694dcf3e298e3561ac8813fbd7296593ced33850426df42db +a92039a08b5502d5b211a7744099c9f93fa8c90cedcb1d05e92f01886219dd464eb5fb0337496ad96ed09c987da4e5f019035c5b01cc09b2a18b8a8dd419bc5895388a07e26958f6bd26751929c25f89b8eb4a299d822e2d26fec9ef350e0d3c +92dcc5a1c8c3e1b28b1524e3dd6dbecd63017c9201da9dbe077f1b82adc08c50169f56fc7b5a3b28ec6b89254de3e2fd12838a761053437883c3e01ba616670cea843754548ef84bcc397de2369adcca2ab54cd73c55dc68d87aec3fc2fe4f10 +97f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb +ad3eb50121139aa34db1d545093ac9374ab7bca2c0f3bf28e27c8dcd8fc7cb42d25926fc0c97b336e9f0fb35e5a04c81 +8029c8ce0d2dce761a7f29c2df2290850c85bdfaec2955626d7acc8864aeb01fe16c9e156863dc63b6c22553910e27c1 +b1386c995d3101d10639e49b9e5d39b9a280dcf0f135c2e6c6928bb3ab8309a9da7178f33925768c324f11c3762cfdd5 +9596d929610e6d2ed3502b1bb0f1ea010f6b6605c95d4859f5e53e09fa68dc71dfd5874905447b5ec6cd156a76d6b6e8 +851e3c3d4b5b7cdbba25d72abf9812cf3d7c5a9dbdec42b6635e2add706cbeea18f985afe5247459f6c908620322f434 +b10f4cf8ec6e02491bbe6d9084d88c16306fdaf399fef3cd1453f58a4f7633f80dc60b100f9236c3103eaf727468374f +ade11ec630127e04d17e70db0237d55f2ff2a2094881a483797e8cddb98b622245e1f608e5dcd1172b9870e733b4a32f +af58c8a2f58f904ce20db81005331bf2d251e227e7d1bef575d691bdca842e6233eb2e26c2e116a61a78594772b38d25 +b3c1313c31ec82da5a7a09e9cf6656ca598c243345fe8d4828e520ade91787ffb8b9867db789b34ad67cef47b26ff86d +a8ed8a235355948e0b04be080b7b3e145293accefb4704d1da9050796b2f6870516c1ebf77ae6a65359edcfd016c0f36 +80e792d5ba24b8058f6d7291a2ec5cb68aab1e16e96d793128e86815631baf42c56b6205c19e25ce9727bd1fd6f9defb +816288c5d726b094e3fdf95cb8882f442c4d9d1101b92c7938a7dfd49bc50636d73ea1b05f75eb731c908c8fd8dee717 +ae009128d128ba2e1519bfa7a0c01ed494a7d461c3aba60f8a301701fed61fe4e31d6c79ce189542ae51df91e73ce1b3 +96a866d60a9007d05825c332476a83e869e15b11d7257172a67690ea9bd3efea44bf9c8d42191454eb04fcf110b16396 +8b250a2a06419adb9b611e89f7f8f2990aa301949b533ad3bf17c4a61ab5f5be0b1d5e2b571864d13f1bb75805c7795d +8450f49facf2e620fa45ee90e1801178842d927a2a25fc6ed7ba99a4eec7ae40eebfee41028eaa84f107f4a777694976 +91049080cf659c0985a22d1366e59191bb89663f922e8168b9b7d85c8a73d74a6d9dceefd855d3d858b493670c750581 +a1e167aeb2008087f3195926f1985c0a459d6ec57237255b1473a96de4e2c1cf766127c862c7dc853a6909e67cb06cf7 +b667c0d4e26e20698b07567358625d5f003839c92de8088e12dbd74a6f6a3156b4ea8d252c9ad62af5f6c4fec1cf6cc7 +8e4b5e304c0b1b161ae3e4b68b5e3ac66c42acd7c1ee2458044f6527c508a93995e50894d72d57c1350f91afe72775ff +8c642640aa7915421cdc21fd639f88a42052b1cfa358ff7702e60793a92b7b5926dae15a0c8f8f59cd3013f01c159ba3 +a356f35e713cfc283056bf539de54a21731e61efb4c47319f20de4a4b723d76a33b65f4a67d298b9ec5c2a1579418657 +93ce204146ce95f484dc79c27919a16c9e3fc14a9111c6c63d44491158d5838117d20851cc3227a5e8ba6ccf79e77f39 +b585664cbb9a84b52f89114e1cf0cf1171bea78a136dc1404ac88a11210b2debc3b7a55e702da93ff629095c134a295e +b6dfd444ec7fdceb14c6328f26ca12c3f9fc4327d8d8c68948e92e7e61262b82d833a65a9e3af6353ffa832b6da25705 +b4d4b8eb9ecfffe3f0d48fb4149c7b31aec1da7041ec03bd0750c52a2a7cbc3a7cfbf09d5bfdc56e3860826a62d0bb91 +a4e248e3d61db52da9683fef188579c470d65e2df9064726847b1599fc774049ffdc6ef2ae578d5ed7874f1298ecdf69 +a68a0fffc2e37d3183feb01b42234c0f4e510f9dc29d09c571e6da00fecad9da224cd0f31550070148667e226c4ca413 +86adda2ffecb77236c18005051f31f9657a0d50fef2a1175dfda32e74d5d53df825c10f289eb0ad39df0c64fc9bc7729 +998266d5c9c3764ed97d66fa9ed176af043999652bae19f0657c8328629d30af453230e3681c5a38e2f01e389ed8d825 +a05261554d3c620af0c914cf27ab98f5d3593c33ab313c198e0c40d6c72022eb5943778cd4f73e9fe8383392a7004976 +ad243fb3631bf90fedb9d679fd71fc0cf06bda028591ded2bd4c634ea7b3c2bd22eca2ab318fcdaa6c2cda1e63e1c57b +89b9859a04f903c95e97fb2951f01cc6418a2505eee0b5bc7266b4d33e01b69b9fe7dc56fa9ebb5856095be0925a422d +a68d118343a5bbfbbab95ff9bfe53aeb7fdbaf16db983e6f4456366df2aa01fbdb6ee9901cb102fc7d2bd099be2f1f3e +b49301f25d5a9dd2ec60ddb0b4b477291958487efea9e54dc0e4ef388f03b8bbadd13259d191f7a0b7513876767d8282 +8b93df7fb4513f67749905fd43db78f7026589b704ebb9ea3255d0ad6415437799f40f02e07efccda1e6fd5e8cd0a721 +ad88769ace96455da37c3c9019a9f523c694643be3f6b37b1e9dcc5053d1fe8e463abebdb1b3ef2f2fb801528a01c47c +80f0eb5dcbfaaf421bf59a8b9bd5245c4823c94510093e23e0b0534647fb5525a25ea3aeea0a927a1ee20c057f2c9234 +b10ad82ea6a5aeabe345d00eb17910d6942b6862f7f3773c7d321194e67c9cced0b3310425662606634dcd7f8b976c04 +82f6fd91f87822f6cc977808eeac77889f4a32fb0d618e784b2331263d0ffa820b3f70b069d32e0319c9e033ab75d3b4 +9436d3dc6b5e25b1f695f8c6c1c553dab312ccace4dac3afddc141d3506467cd50cb04a49ea96ea7f5a8a7b0fc65ef37 +8e0a9491651d52be8ebf4315fbbb410272f9a74b965d33b79ff1b9e1be3be59e43d9566773560e43280549c348e48f01 +8809137e5d3a22400d6e645a9bd84e21c492371736c7e62c51cef50fee3aa7f2405724367a83fd051ff702d971167f67 +b536a24f31a346de7f9863fc351fa602158404d2f94747eebe43abf1f21bf8f95a64146c02a4bec27b503f546789a388 +b5cdf5a04fc12a0e0ef7545830061dff7fd8abea46e48fbe6235109e6c36ee6bffcb9529e2f3d0d701cf58bbfb6a4197 +ab15377525753467d042b7931f66f862cbbb77464212c9aa72d4e5c04375ef55f619b3a446091c1ba1a3b5d9f05e538f +905a75b943ad017ff78ea6ddd1d28a45c7273ee1c2e5e3353685813793ead3370c09cabd903fcab9d8b1c6961372d486 +8147df4324faddc02fb0896367a7647b719b6499a361aecfdd3a34296fa6768ad31c34f9e873fd1e683386c44651883e +ac91d08570dd91f89d2e01dca67cdc83b640e20f073ea9f0734759c92182bb66c5d645f15ebd91ed705b66486ed2088d +ac6295ef2513bbea7ef4cdcf37d280300c34e63c4b9704663d55891a61bf5c91b04cc1d202a3a0a7c4520c30edc277c7 +b604be776a012095c0d4ebc77797dd8dec62a54c0559fb2185d7bac6b50d4e5fd471ac2d7f4523206d5d8178eabd9a87 +80ead68def272ce3f57951145e71ed6dc26da98e5825ef439af577c0c5de766d4e39207f205d5d21db903d89f37bbb02 +9950b4a830388c897158c7fe3921e2fe24beedc7c84e2024e8b92b9775f8f99593b54a86b8870ec5087734295ba06032 +b89ba714adabf94e658a7d14ac8fc197376a416841c2a80e1a6dde4f438d5f747d1fb90b39e8ea435c59d6ecda13dea1 +b0c78e7cc60bd05be46d48fbb0421a678c7f14b8d93730deb66fbe1647613b2c62b5075126d917047820c57fc3509cb9 +a860c4acc5444e9ae987e8c93cb9a5f17d954d63c060cc616f724e26bc73d2c54cd36e0492d1fde173847278e55942ba +8fb8269c9d5c15428e8d45da1251e4c4a4b600d47da0caea29fef246854d8fb6acae86a8e6440d0c429d8dd9c2dfee0c +96c5d8eb6fd5c525b348ee4335d200139e437e4be83690af0f35b7f336a7cda8c6d2958647988b84da9f2dd7bbb7710b +a7f62141c4346cc14e9823dc38ac7d587b0427022afc1498d12ee2c43f6ac3a82167057e670dd524b74137f8c3ceb56d +956aac50d06b46a3e94397f163f593f5010d366aa2d816c2205c7d0f47f90cf0f36c169e964f9bcf698d49182d47d91f +b812899bcdc0e70d79ca729cb01104bf60e1357b9085a10f64f3ba9865d57e9abd0a505a502d4de07afb46f4d266be2f +abce02c7e1372e25d40944dc9ece2904a8f59c8854c5f2875fe63ace8ce37d97881f4f9ab4f7bad070ec8e0daee58d3f +8fb13c515b2d6abb4e14ed753fad5cc36c3631dfe21a23d0f603aad719423dd5423157eefcbd9a9c6074e155b79eb38d +a9ef67304dc297ab5af778cf8afa849eeac27db4b6978963e97b95ef7a8d3264d0d07775f728c298a2b6daed2ecf5053 +a9b975520adb066e2ff2a4cde53284c23bc84261a22dc43b1634d99eff8e7892e46bb6e6da7319c9e72788aa9ea7a1ea +a6eaea4ab4206294474d9b956d9d3188d558a5633de2bd05df0d3bac03dbcbe4ed85406349c1d2e660b77c6da1f5bf8c +af4a19f77290dddee762e1e0d4bc9945aacea3f75756ae46cd3e58a8f74d1b5db73e4834687946b0f39191e32f2fed0c +aafa6523f58f1a4cabc924c86d842816d606afeea21fa4b2b8b9573425810fdcc41c98888318e868f9c05e2be12178a3 +8ef38fba0a3fa4ebe985239c8b759c22aaef0c57e6f39050a651c869487803b0d1e389c3d958fb5a7f37740f050ac69e +b07dfc9f85913c608ca7596a2e361f05e4853fad00e796fd492d247de6414892ce160f627669b1ba933b6ad726415d4e +94da679ad1d78b2bff5283c938f17b2a7d6e9cbcdf59d340e6dfb652951c7a9e852ac0590f99cfee9631b9410f6f00ea +98a907c9c021a5b034d3720197c160a82c4b7146cb73d48efeed99b9d0c6b831812cf80ac7e19e85a676a8cd3ead72de +adb746595466a12929019d0048cea33236b05c1229d2eba73b259a18a786f2bc3f05fc0598d8ce253cecb80bdf679aaf +a2fbac016996d68f9027a157b0a3f6a336144a798d6113adfcda3a5d05b62c31f108f112aa915906aef22b7f83b9228b +81841dea1904406d1b6fa49b4b3f7f6cb40b7646cf44d36c9fa07e3dee29f8e47324b40d8356ddf653109673c3374e9b +a3edbb8aac5e60c775775cbdb19067341b2e2530de48738e84c2c07151241ee31f0d8333bf20c2bc9dcb7b2e638a6b5e +b8aa6890e22964828787ce86460d3a32f12a655bb5c28de500f2fcf6b61e3334640ec6ba96029a4912af0d18df4b4139 +8ca43169f04243ad0fdb0152de17c60d9e31ee0ab520970fccd98590e05508821a183b4b367967e60d53c2c826ec5dbd +b179fffd9df8c00486c5a8b9327d599f5a11745ef564f06e126849b06fe2f99273c81f65bc941efb0debaadfecbfec1c +acf068f1c2b1926279cc82750ce21b0d6b0bfd0406f0d8bbfa959bd83935932957c7f6b8de318315bf0b75f6ee41a0f2 +b97831da260919c856e9f71a41687f5979bc16f8a53b1037285b4a2f9ce93af5cfe70bf0ad484744827fb55c847b58eb +aff50b0bd907383b0c241727af364fe084d021221bfb1b09fb6c1a7752eeba45d662493d590f1f182764b90b25f17906 +aeeef044c14e3ad41e1235c9e816e1eb49087fd3abe877b89b3bade74459186126e160bb569bcd77779e701b19b5f71a +8483deb2b7001ca7c438fcdca8ca6aba96c9cbc4becfd9b16a6062705eae270011bcaedcae69bb54630d8c78129e57c7 +aeee8d24be4ac0d9784c029e239fb5e64316ce29b88f47394cfaaa8bb966a72061bff72f99d02dc51c9705854686e77f +90ae09525a16bb2422169e15d6831c87968a14ebc0d1d27e11a759839c73c655b9d33ee5b12f275d6f440688146fbd2f +a3a41fc7fefef101422465e506bea7f3ff23c26fe35f5732b86f5f2471fb93b37ebc339f84c6be1e8d22abc812c2e212 +86f4b5293e8aea4af1f1fb05dcf99714cb3aff1cfc849b1bb73524061c921c9da9ad92579a852e1889da29d952f02fe5 +8932ef39d4050a1e9dc0fd8afeaf159472d71c5c27f458c69d2730836606ea56e19c8c4febf2535f930d3260e9bc7637 +86307b9f3696bb21c20e4558e30310389e7367803c353d437e9b696039a0ff054d9a4953b75237ab1d1dd6f71118c189 +96e57730e683ef5b550c91de18b19ac73879f3e26234297db68d28747ed0953beb0f3913cfb720c602720bf9330685d8 +b04a19ee70123782e47b238abde55baf60ac0c66292a998af0d14afc8bbeb1134e557b94cd17a020084631c09a0d3c02 +829abc8718be8139569fcb2c398962f38f4201114d30e2b2fb23566f8a27a5c380f5605cec543415202a12ed859e33f6 +a0744fa488c8fa92a722c5fc4ef5a47dfe824eccd87d26c8bab9c174cbb151d44b1b29082c48652f03d3177e5ec86001 +81d4035ae9fd28bdcd78b135cb54955d3b685a527319df6ee7e904b8e6d796f5f5a5f5035ee1de750c4cb6050e452b9e +b205e8c2ec24d7104fa0106c09ad34b5a912c1adef553fb718838dd627355993c2ec01055c11d00b2c75b68e9516d44b +b12d09da7968fa7394e449624fc7174d1d76c069ccb03e140d4d87a2d3f6d1f7b9cfc930f0c80becc673406ebe63f08e +b23752c158695da85048fdf38b395681cc0e8998630af8a9ed41efbda08c9964c2dc8ae6e53377264be4467d702c0de4 +b0d84582fd73628d96b8c1ec96197697c41a963542451a2ade0890af0d33c7161d0f18e1a1ce2c168ca2dc1e9119d55e +8b877e618b469aa187632e410b125d2999d5738fd66d482000706b51fd904a0c7e7daa8c9b729fa33817bbc4154cba2a +b1cfc8a7551b601723b937d497d01dec3ee7614c2bf13d430b1058d5ebc1406045009ff02c2ac15bf8cf16f860193d1e +b6d9da84f97b21e13175bbb0b5cc8e79e88b470c87a3e115726c1bd98e0288526c58f3faaa8aa170ace0cd6a60852525 +ad2e773c2d527671ca5fab7085dde4da31cd35f45d4315dd95d8893ff5fb900494dca08eccfc1a2fc7bf7c7fd2fcab97 +8d5a79b34aeb761d4a0c73f09f02e9548e6d382c33ee6887a759ab05762b490b8a549ef2933c7e3a46415c154c0221c0 +b6f2cbe81bd0a7298403be392f8456bed30aed7ef30216959357698f789affd2942ae5fbaf3f48ecebeb7c273b20cb57 +b5b6c45d99cea7ce6a1dc134aff4a8f630f299b42bd59592a7592345f8cd35bcbee944e61b0723de732fcad6e4425b63 +8077d64dfcb2418974e956ea6dbf8a4c05b25d2a025333ad7e2a379f1976dc036771403383a51bfa3476c9c619ef8bef +ad2e0a9d479c77a5fb73b3613a177fdaad50dcb50fed50e756ba18164c153af30b07fb2565e80ff7469f1b0338b7b5de +81017d1d80a6b6df4e99d0d7f85a8180b5523e8fa2ea2672fddff604933f8a113cab27fce098dcb454d7d1f7ed266e04 +852355479d68e76c7febf6dfe2ef8e80d575c0d3bd52c983803592021cfa898c571c0b884412c21e66f0dbfe03167b53 +98e1bf8ad48421467c93b9f72b47dded7c41b4fcd36ea55ca43ab24b0d0b876f5a731f422579b7167c7138fad2121266 +803369314abd5422019ed4b0ef652b4dbe97ef5a87b0ea373eec9628b64a12120b2c3d4eb53db405131ff786d14c7ac6 +adf2613fc34f73e1160975c140e925ed84d254e03cc3bc7fc1d19957b499c9ba9d9e4c1639981b594a7095c0a52c6757 +a2f6a68efdff6e4173c00692abcfdfcdaf6f8b62369afad3dafaae4f2f38c4860780b4624d185e20e4f4498b75b5fe94 +8b1658aa0e119fb8401d486ed08d60240d26a8623ef9788e3b45ad09ae31259395b021bd16be395139cbb7149714e764 +a7dd8bf21121285e00672ee8bb84e0cb39b2496fb53a26e35dfbca7f2b04e9a9ff9db15f53fe63fcbeafeb2deeaf2ca4 +b6d8d709e44bc18f3b41d69608edce60c02bcba48d3b7e2fd420842657f0665a7343246dea149a25e8f3416284abae66 +aaf744ca5e9bcb63e3e2939b7a1e96e4a93c88c76bec0cf4294dd7db95cdd3f6a7d92196e352d08680e2328bc4592899 +84434b015a7c398d35f1ec71fce455d62ba4ed4f62da042ec31bb2b4db47073314354cd50bc322297a1cfe35138bf490 +8d70b3a3cd9d5dfefdacfa418c0b775a112a47ce538d33a560a519660009c3f141fd6221c18539129e9c0acdaceeeb80 +b8c6903412a800ec78a4c15f31c24385a267b0c0ece32fd31bbbb557fd70c3b2d60d8fc0f90fbd70f43baa1928ea30ba +8e391dd445ea06cabb433f057853f8159511b2f9bef41aed9ccd14e0a6fcd912bbaebd38fd5fb736cfde0fa34b7a4874 +a40cd988f70613df32babbd1bbc2f1b29ff1ab0147b01161555a81d56c9621657999bcdb1df38485f687afc51d5d0f23 +b6a008b4426b3d7b28ae04eee4698fc8ef6a35d89008ef5394da39ce582ce1a45dcfae9a33b90f6fa4237f3667803873 +8987280debfb175c3b44a2f152ea82548e4f680966f1fcbee9bf7d714e31bf8080c33f52705ef3aeee70544b22516aba +a78a51a2c11eea7680a5a0ae417a2981f8c69c396e06da621eadd7510a3664ade49d065617bec67b3de779548a4f4509 +a4d9163f0a1bc048385e94d5e0bcafeee1b18f28eb23505623b9e8ef16f3df76408254dfbe790e45f2884198060d388d +83dcae2568a0c518793c0f6e38b42f9ceb50673d100b556a17ec8bd9faeec84afe50b8d72422c6b2356959667bb8e2de +874731941be4474b4576226e5906b5dee89fc9b56a9870dcc7289c1a7d494d345ba6aba31f7546a16f9963283c05f744 +82c1cfab1f501189ac20147fc4631075dbf1abf9125b7d42fcb4f31cf73f3d6461b1bd08fdf6e45cc54bc08a7d5d51d1 +b978228286f5d4a10ce027b6bea3021affcaa805340ca4b5192c69e8c56db59f48e4a14a284ec015f53baf97389f62b2 +af125f4fdccd1c1b64fdffecb5ec7cf8c7392bbe476e1b89a5b5329c5ba4a526e58c11e72ab9de8a38d60af648d75adc +8411a41ec14295acab0d36389013535a80dfff6e024bffeb32fb3070762f61256419e8c51b2ad6de9dbe4f1e8e286912 +8ea67a91112a41f9c65515cd496f4b0cdefa1400fc06568eef000c9eae6dc250fb7622eb3f2deca10b37287cd96fa463 +8da99b6c55c31dee6a49aabb54da249d348a31d4416201a10c45a3b04b11e99d4ae9813632f0ee36c523b5cca62f6f49 +8b44656341e039e2bd83a19c3bb9a88f6209482e274f8cd4f8557b728e5948dd80b5745f621b96f4562928689314e8c2 +a02d424a615ba0dce8ed91f477e79852215a3a39d025059826fa278e7eebef19824b2a2844f5b3865a0f471b609a23f5 +a1f115cebc3fff3bcf233da27cef19eae791660f155d088003460f75567a550bef0722885010ddc384acdeac635939dc +b61a55ce9d143c17876776e064b58a10baf0ba13553c785c1e47f57b5f94c0cda8bc89d43d73386e57816c15b61a8ec8 +b4073f47041e20a8e548c7fb00e07ba3b9056c34eb4ab63bb0e7b48f8e338e8b56a17611a1b5f4c03b352450b86f1d69 +a7b1a07b213205b682fc5b6acb7e76fdf97b280c26621d8f3b76b7c1deb3511957da33a4e358c8e8f3d98b2a8855d67e +b797e67c2670fbd9844e8a68c585f404b035dc14bd4ec75c3f95f932c777f9db5d5f5df7629164af488fc1213035cc5f +99618200797b945f595794d6468e5c618649554ad9ba896330f1cc844090eb956ae9fc23132912f9047085c5f0c3bf7b +81194aa1319abf534cb3927af9adfb178a99d0e3e8c99ab1105f1d3b4fed40ec2971caf1d6647acb0c8d681eca53097b +80673f18e4978dbc226a6cd4b128a1259d9a7f833879c6e2fbe24d69fef2c3c23a51a4f3e8d88fa4533434bbb0723661 +8125bf6c7dbb2fb63aaa3f53283559f172c788223674adbeb6d5bd17cfe888e6b87a79aec774917f20ce911c1f85f8e7 +884bcdb1878b14fc38adc9fb8b4dd0b3afde404fbeb664f26ddfebc81736018551f23e75ce4cfe4865f610bcd454fbd7 +aec65c8d4be8316e98aa54888af01bc6703a0c5d04b69756ff39a0a947b66817ec59d76afe9f61a25749b5e890f03e02 +aa457aaa1b014a4c5a8992847a187a23321bb43452c98745987d038e3b04046102ae859b7a8e980eea978a39d76a88ef +a9832ee63b08e19123f719bfe2fe742125f32463efa966c7709a98ebfc65277670e9ea1fa2d2d78b96bdc7523b0c4c3e +a87b6b1b7858f96d55064274f29fbde56067064962cf3c3e2ba3110b22ea633bc037a74d23543ce3307a46208855d74f +897cbe4ab68a753020fec732dfcc052c7ed9905342b5a6fe0aa25c631f9ad9b659e0ee75d46f0df6507b6720675ee28c +97c3b5f0d54c1fc45e79445c3ff30458959e406a069f5bbf7979d684195b4fa0406b87c1c008f4075bc9e602ed863152 +921e65d582ea9322ddfad1c855331c3cac81f53c700b96db5305a643c084eb6793094e07944bfd41dc02c3b3cf671530 +8f23ef1aca02a260a3b65d25b110f28d3bafca44727448c8f2d03c5e77eda620c1721b06681bd816ee6027664d76352a +946a89b132ec0795aea9ff9dde7b77e7feafffe6e4a2f093042a7e6c71cd6ab87ce0ca914a1b5fabad4e1f96a795f163 +a01e2de9db33df6511172123ad6f7c64074237471df646b32dd9aff8c15278e2723108e4facaedca97e9f49503f8c792 +99dcdcde45b2ea3f15279936feede5f7d3b63ca4972f335b0559c2fa6f9faabd8127aa892a36deb114357ca906553ed8 +a3f8af37bfcf66b04d1896a4bd5d343f4733d4c3305369ac7e75a08f20f2004c10c642d2c7577f4e5c4d1f2cd851ac3b +b7294d15a3d674a56099f97a1adc9e82c15e90832eaf1722df110fc2abc8634c51515e5ad8522015498a3753b1fa8c49 +b4f27f5062ba7a04ea0048b3025b5e3d5b5d319a9e80310c808a5fb4e8e77b38c10a0f3172cb805cadbcc8bc66d36ec7 +aefe5decee0ae2dc372cc6cf4217daf97c4c908d145f100f0daf1ccdfdf641c78432c2e473e7e4b77dcdf2d4c2bb05f0 +acc84af7648a535ffd218c0cc95c8f7b092418c548815f1bafc286b1fe14f6ccb51b2044db3bff864d0bb70e88604084 +84d8e3dac0df6a22beb03742e1d4af684f139f07e2ea0f7fb27fc2d7d4f1e89b5e89f71af32ff115ed5e6092133535f0 +8ada001e1a03a823c4c056f636e77adc0f9dc08689d28de0d99e0feecab5db13abf37b41ec268dbdb42c75419a046c68 +87dac6c798d1744dff81d8bc3e0e04f3c9bf260e811685ddb9a9a8d6eda73927439b344f9a818d2103fad633de5a4a17 +ad9929a7d8a7d5d5954e48281a87e5c84f67e19110d73296b9989a09c76767a57a8115629239ffb4d99dfdf9c52ef6d9 +81ac7cbeef8ec35a5c3b61cc887080c29e6cd3e08af37e45830d17400dbacfb374dd07bf370b979828c3875b2027d5c6 +97f92c9182953b7e10f7a1bbb6b5b5c40b8275eb5a6eec1e29874c4712814749aa8c409651380216e1ff01d7b8511041 +a09794d0bbe7db013045d3fd857c1544fe6231d21afa3495fa300371f6301a3a0f4b8ea175b281503dd06078ff371ae4 +839bb58d320aa08116dd387a57a2b9bd9efc89c4cdfd82d0e47a00cabe644631d09be5436bd485df3b61b75ddf81a3ef +b1cdaa344f783757e8b9c1f84421da3c5be4c69f019a8fd4c1aa5bf1a63e8970c99e35c22cf3b48a0e6738bc6ba7ce8d +92af68e3216c78998208fb24b5ba0e645d0d3f5e28222b805668d7e9cdd6c033d3b22fd6df4c2d745d7f910d133cd226 +87640a4ea4e605e2204e5232b29a6c1c31152d83547eef14122cb76a0da52b8653801af48455a3ed713b9dcfee7b1ef1 +8147e5bf0c8f4731155ca0517ef3fae5a32b4d5d2d98ed0007b23893d8dbb7f8a1199c50c1750c2fa7c9cebe594b1bb0 +a76b4473c63c3ab6103c729afd2482822e4150f3155af39983b0ff0766c71cb622455ce6304e23853661eaa322219d18 +b3e2f05ca551bc3adec0067e4034aaffd72e0b64ac18ae25452c996927976c6727966e26d213b032521889be2170800d +a8414cd14cb3be658e9e0004ce511ef7063439b1cbc3166a11de030613fde4b59caad4e91d426927863c55382afbf476 +b2f0f8ab99f4d0ea785ac84fdbc00b20217b1df59b30b51d9d209d489d53b69dd5d82cdacc16fd1dd15c3a4001595f50 +8b2025d5fd658c9bbed619f3e3f6ac8efe7aeff8aa9401bd66a7ceb0062c44b353608ca073f95be99204f0a913bb77eb +94a46bc5a87291b42024b2137e623c70115b9c6b196604106bfbfa20f3f56ac7779763f56b580190d3cb2f1c648cada1 +aca9355545118d0769cacf69c4b23d6d68d229cd8f68f1bc0c847c05569c5af6bbbd8c4dceb637b4a6b3b5c83841bf5e +b0731992cab87c7116406b283a84707a34838bfa3284b0f6082dfabeaf41c5ac2b0ddc1b420547a1b0955aee92de2dc0 +b671f77588c0f69f6830a5b28e7d07ed161b81fa9791bb3a24aae6638e3aa5e186df74978a82549c370c18ebee04d4f0 +b5621ed841780f3e6681d880a76cf519cdd20d35197b112eeaa686764d57b5dfa78ffe1a294b6bc76b6e3949cd2a2369 +afeba2524659d00caecf089645611553187a6ed7102050f6dd20f5a19bed08ac7065912d88371ee06242897d58d652a4 +b78bfb83d44ced14a20135804aba3f00128c3ce1f302e95567ce4097b0d973414153fb305b9f156882a5a0554bf25973 +98510aede95d26b1adf214053eae051ffaf24894e2fa37961a91d0ff5392dd09388196648d95b73e90bd88f2587cc4bf +b35c682d49c295946b9f120fbc47b95abd9ee86d294abb003a92139fb825b509209562575015856a270eb3eea86397a7 +b9641bf685571dd9c478dd2033a1f1b11cd3a662b26502c78595863b8e536a189674a9a85f7a253453ebfd1b99fbd841 +b2ad37036a59b1c9b8457972665720a6868422ed8157b6810a9c0783006103be34ab732d7aeb8629653edd18fd0f1717 +af0920cff05179a3896ea6ea322c39adf91ada5bc40fe3f6fb1b1b4e121e907c904bbaa8ca00468b3749f3da144d71f3 +8e269672818ef1e2f9e0c8aa65c84442fcd9151d74bb8e870cee8c0e3fe24526e1a5388b430cef47b67f79b4e4056bcc +aa29a16fe00ea3d143b1032b1dd26b8ce638f37f95c085c7e777e8e2784bd724bd5c38b1583c61a6ec7c451dd78fd3fb +87452b7435911cc5f513b0c81b15aa04972ecbe3d7bbd0a5d676c96a8a311301c0e07fac925c53a350b46fbd3d4d0fc1 +869a81c351096f47748e41566ae7b77a454b1cdfaa41d34a5742f80df38fbf5cbb08924b6fdff58e3b18f05c62bbbbb1 +8b7bc1b0486300981147a40a449ada9a41afc06d735cce8bf0fab3ee94ba2e2ea57b1397e3cd31bc295352beb8334ef7 +93e93fc41adb2df279d95654921b4c2edf0d293dab58d0afefb221f777349ef88d0985b3447e3b935954a81f1580a92c +970fa7cdca8324faf3e62348bb50d78f580b4f43f2e1c11bd8382d48d0074a3c55c6407203a0c9cb1c5f2163ba421ef4 +924983929e608d27e4a36d4ed919297869e3c64de51aca794d32d6e90aea546bf898d98ceca28a0b2187734821b78504 +8d395332529c703d943d68415d443332b5c1342ca9d9a59bfa8bd4ab63e93358c4b0dde6ce1f2e8ea9dc8f52ad7ebd95 +80200dda853e588256599e7f905add5d5ee7c74272780317694fbae39318ae9be05d5bcd7b20cf460069743f3d4ef240 +a287d51d6359c9ef7c7ac1b20e479ce7d0146dba5606397bd04b7a622cec642508d5b45d51b31de71f9763595b6ac88e +a320396c075175d6599225cf2e1de8c7cab549f6316c07feb0f6eaa21f06b2dd29ab14fbdf2af4543b4890ec0fd08a4d +b1e9fe230418d20368691058adcbbe30011bab3000422f0371015ff8bd09c60fb5fa85d18550d35b1c900977ca48f58b +9718fc26a51783b971744933f20490e9b5cd9162f86b84788c4c5217f5409e37b5a39d628b18e5b35a757acf67596321 +a0cf81fdb161f4f1b419c5e4caa36d4bdca2325f0cd25b119a30178016f171bd6fb88403e4e3aec026c4089f180d540e +8ab1e36bd04625ee794ef04c4dcb8e004d61aceb2b62438377f49ad95dcf025ba25eb799280004941e555bf7172af6fe +9257b9e3d14d37fc7efae49b0c68d36eaac546035f4a2654d566b3ce1b2c4564cbb03dc8ec66efceb768559a8a507a18 +945d1123b839637ab5154a1972c3c83a0ff34a3b1a3465de6ef0416b1950f649869a3ef88d7f1036648ee385265ce2df +81449639d708860fc0229c94f754f7262e8a3c7f67960ff12dfd15df95f57a9ffcee2013e81978b7703dd42bd5d0816f +a865481deaae5a690fd53892791e5fa729db283b75a525a11cdfee1ce17e8e7f0b449d25f20b3c1b43da128dbdf98a8b +98766812a65fcd25b853546e3bba618a3edc9fd61510e4f8ab60c038a7fa50d197abeec8776109df0f2119be9445ad00 +b1b8dd5379d903dc41d74e999b1ab693607a0d2905692f4fb96adf08f738e5d31f9d00df28ccb8b5856145ca552c3e3c +99d20be7b511bec78a8ed03c207aa4aa9097ba39d85e18f1b8d52f65431ab7e9a773c7b9ac3e8d8b25458bc91bd00703 +b1b7c3563fe8cb33c7d3e0b89d00bdd13e86452ff507c2e69db7b3af06f247f139155396e9b0278753310dc63940a10b +b3dc9c08451b1de7c9969b1e47574bffff50490f4a16c51e12390195d9e9c72f794790caf7b0a835d64e01fec995d3ac +aaaa4761a00022ede0809d7063d3532b7bfae90ff16f45e17a340ad4ebaa2fbac40728ccc5fbe36a67ab0e707566c5dc +8319a1903314eab01f5442d2aee6ae9c3f6edfda0d9a88b416d0f874d7d1d05d08bb482102f8ca70a4fa34836d0840c1 +932949a6e9edfec344932a74d4f81eec3667ece1e8b8ca840ce07ffd4b5d6d8f01657c764d64ac1b9190f876b136490e +904db1568128487e312fe629dd8bb920cecafd3bb9cad8b63e269ae0129f2f5c80cd82f0d81e7feca9835c3945a72d28 +a17280693d30dcd43c85de8f6b02d5f30cb9097274ad680cede1ef105c903615b4c40f3c6aaca478642de324972514e0 +8d5f76e093aee71d0cdeb017fdfcb13bd068039746de90690ce150a0bfdbe7ddc4d539df0f82c2d2890a40b191900594 +96fa1f2196a3883cdd73c66d28403cbbb58f6a939a3697ee0d308d8a076393cbb4be86255af986869230ee410c01bcfa +a8b74438dc5cabd70a91bf25601af915c4418d074327a9b01e0190c27d3922c89bb9b41e0b366e82e313edda8f21983d +ac9fdc1a9b2e3ff379eb2370979372e13c4177bf4574f1490fadf05a7073e6d61e703e2d8eed9ce984aba317d411e219 +a45a6c9b958169f2f8df70143e6ac3e2f6f969a4eed6fd9f1c620711bc2454739bb69f0094079464790c5429c0d8aedd +8901cbdd1009864386577842c1e3d37835fddf834064d9613b4559ea9aef3084204e1f863c4306f874141f4374f449ff +b6c582161691e3635536686825be9c4d7399d668a7675738417e0363e064dfd28acdbd8dbc9e34c1dab8a1990f1f0eba +89e89ddaf3cacc78428f3168549c161283ca8337345750667c98212717b21e7d994eae4e45bbddacc832a18df1d79276 +84be275627eed8e1a73c7af8a20cee1ef5cc568cfeea7ec323d7f91b44e9653e9aeed47c1896a8240b99dde545f0e1fa +a779a54ab4f40228f6e2539595fb8d509b70aab7c19e1928c1be69ec1dc19285c3898cf15e5f8b8bc725e13af177fe17 +92e2a49d2b9b36349d442283b17d46f8f9bf5932c34223015ce62d2f285e7363b2c12232be4a838b5b6cf08e694c094c +8b4e28c6f3f36caa2cfb82ba88066c830f8017bd35608b077143dff236f3181230166f5a5c02fa0e5272297331726aed +85fd77d46162ffac4b8adb25baff0eb0512a53a3d01638b3a376ea34702279ce21c8e7d8884308c03e00c9bcc1a9fd29 +aad5e46916ff1be29009b595d1d8fa160cc7aa01c7fbf3a68f445c87615790dcab1fcdbdceda533d182b6541f09f2f73 +948df7654726250dae393325addd3c0a20431c81f00470962190335ea4b6d9f7463d6f308cda46b92084c1f24390b1da +8f577474dea132676504376c5542b730b6604fe3d965eaa194659fd11c52233bd0b11ab62e198c0f442327ff1c00e501 +ae2f1001546db3e0c19700adad997cd9f765fe7a51a502cbcd9a2a07a3a5db79c8f603e05cf96d80b688cb6c9b6cd3ae +953b68e5d9561088dd20406ea7fb6894cba33868a38ace38fc30b5813140cb15dd6dd2171befae5b4df2e4a9658889d8 +86c52901655ff11419b084a04da8fc3596eae59d81d3461601c0baff59ba59e3d1dd0b7ce719e741a3e97c013e898579 +b9a72dd5eff73f9912a28b55de073568efb3eb0241a10b77a2bfd4f30c2aa4fbfe0c89eb345c9f07fb725660873cb515 +8e7353f5f2932e4ffd95811caf46c9bd1a53643c27eb41a4ebd211f230955cd71a8b27e17cfe8aa708d8514c0de67a66 +a096b8e66312a92fb10839ebe60189a8d1bd34dff55f7dfae85e4d2f53a1a4a88211c19fc84494f066358ddce82be131 +931c5cd82719d76596832b007969b5f75d65cffabb41b9dac7910300db677c1309abe77eeb9837a68c760bb72013b73a +8ba10f5118d778085122065b55dd1918fddb650cce7854d15a8f0da747da44d7b12d44fc29ad7dc38f174be803db74c6 +8c971deec679372a328587d91fd24ab91043e936ca709c333453d7afd43ee256d08c71cb89f0ab0e89ae119831df6d86 +a2ac28a58034fbd8fd518f409221bad0efec52670880f202e09c0530e2aabc2171ed95e99891790596ffad163d86c110 +b3354e3dfa8068aba4f3741152b9204baa4e342c1cc77e6dd1419cbaf8da1d118be605846b8609e997d6a62a11f3423a +a12ab65a213c9d95c24865fddc2dffe0cf9fc527dd6bcdacc1bd7271e79929a4ab3427a231f4f49d0530474e6cbc88f9 +90afd65b7e6973f8aafbe74da0f42441840d3c93bd69bc1bec8fa56824e7ca97ad1b427c8a85da7d588469bd4ccc50c3 +a09175940c59489bac3d3da3a4091270d9118948cbbdd57f2bcc63fbf45b8010651c801d3e58dccf42733ce1d6b446a3 +a843bbf286e3cecc1fe370ff1bcf5f1001bc2e95b34246625ff50d48ee62343e82fba2d25b8a4bd5f7b5ffe90920efa2 +a3c4d1003219157fdbee2707ce07afa6c2a64ae8e450182c307ed7f070024071f30b12c4b0032960ff913c74e73a9976 +b24af3f68d66f825d06fc3ff94fcccebe28b1a0d4ba29c48d3a3c953b9bf7ae6707f193fef25e2dcbd2b74e483c774f0 +b0f657f7723184ef7d7e4381143f1ac8020d8c6c6f2dcbebb0eaf9870d61a81f2d452596503311e46d1b38f625d4756b +b90091004fc8f6205c51bec68547ac82dba0f5525631e7632cf6efe54eecd9020729fbee6105d1b8012402d3b79c54aa +8e3fa187713c60eb0a416d6900a894cdf81e6b6b69dae0bb64f6287f3c3f030cfa85c665f7aace1eab4937f380b8f728 +879bf0784ccf6725c9cd1ea8c49fde31c91c605de1ea664a33c2ce24c277ee45d20b66309f98d989acb2ff3b77e13101 +af3f3a3ddc4e11abd627d5aef8adffa91c25df5f0c68b4d2b5d51e7d9af3395ba4f6f7ae2325a6672847e1ecc6cad628 +973e667289e796d3a40f072e6fea575a9b371a9997cf8961677f8dd934619ddc47c1a3efe91bae9ef95acb11a8fe6d09 +afa81c5606de82f46b93f4bb6db3fc0670f4e0d1091388b138a66b3827322d95a56168c951c30831d59eeadc227500bd +b83eff77db5b4c18574662942eb36f6261c59f655f8a9c3d3731412d0f257c8e80aacc995c4b2303058a1ba32522a434 +912e5ac9234b9445be8260393ff08e4859a7a385e800b74d1534eeb971f58f74cfb518dfdb89f8705d89fbf721439129 +ab27c8ece4a51d23e22c2e22efa43487c941139b37ea1182e96efb54ca4809d8245eae0ebe8ba94f0ed4457896fe11b1 +a6630585d104a745bc79dba266d9292bbdad346449c8ee8140a5e6e8a6194411df9cdbf3d3ef83468a536d4f052e9335 +8b8c128244da48e7fec641a882d0005a2d05c7138d86a293e6a0a97c76bf632b44767d0ce44663c975e7f9f9679e25e3 +87dbcaca67351a4e7d2297d7cdba4796d12f58857e7ee4abd0645563577ff33544a44cd84e50b3a3b420d6998de9b57c +b859ba43df259d7f8e7fac70bfd7aae546d57a5dc90e107b174a95bf7fd3cf00f740c4434848e69b2a7e6061f66c1ef1 +99d6e20978fefc40c6d310187eb2ad3a39296f189ee122ed64d74f81033c3069d44f7a9d3988a1df635b609603a17272 +99a5ddf3420cc0c92b21f71a805245608d4995ead447d8f73a670d26d33e26920d5f07bfe1f6230bd5f15978055b4253 +b936ac0944d3c5e4b494f48f158000abb37b80b5c763f77fe856398c664b0f1ddbcc0a9a2a672db9278f08b4bafbe2ec +b4af85fbf4040e35a686dd016adec037c99b47cc2e4dfccaf7870ee9e8c97bff30f3035992def2a9d4af323c0b3af8ae +a5ee32b8bd5f8fa9000da4da0bf00565659a43285393d37080b555d0166bde64d87317b2eab2d48a0e7b287caa989be2 +894d4ad58ecb1c9ebc4f5a97407082e56cb7358d7a881ba7da72321c5027498454f2c7fa2bd5f67a4b11d38c7f14344a +965be9eeaa0d450dacc1b1cc2fbf0d5d4b0dd188f2c89aaa9260e7307a2a1eb22db6092fccb662269e9a1abfc547cabb +805893c424aec206260c1c2d2509d2cb9e67ee528bd5179a8417a667aa216a3f318ed118b50d28da18e36c01f0805e3f +972d7040d4963b35260ef0cc37cd01746f1a2a87cedc0dc7b0ee7e838c9e4573784ea743f563b5267eb3905d4fa961ba +8c7156991d4c2e561888feaecf501f721b4174e7d14109e9deeac5a9d748301c07e11fb2b04b09799f0d34ff42cb77d1 +894722ac35af3d507e81d737d21e16c5ba04686f8f004aa75934aae5e17acd3e065b96e229eb011c2f34096f4c62048b +81237937c247c88e8e31e2c72412189fe59c1daf65c5513489d86cf29ee922c0bb08e5f7890f09f4ada7e5262083d266 +8cf62cda2fe0d9a6b42aa2a1c483f4ad26378c7cc2c2d1510a76df7560b07dba8528b33aaacb15f7f20b9d4c7c9f61f6 +aaf0921fb3e1920eee5d0acb59dcc268b42f4b435d60d25d30357edd7dd758d035919691bd15311d85489dfa2e5ee696 +92cec07be2247ef42002ebcaf65ec855611b8e893a5675796f2225f55412201b0bf9f4761924d0c8377b9f131e09e39f +8e514a62ac1e91773d99588415426c97ad63e917c10d762fe06ace5277a5c3bf3730e4b9e5d116f8493b9ab8687b70e3 +83932df2d923a5052468a3ea87f7b55c6a80ede3594046ee4fe233046570921822bc16555b92ba6aeabaef9b1dc0805a +a2b5bfb249de3472113fd3f35bfabf3c21d5609da62a27ea6aab5f309c9068d94bc58ba03efb4ec11be06306d59e60e8 +8106cf3ebe6f0507be8c6e8d137987315fe3689ecb75bb27980f36ba5efac504baccea0e7603549b6d126beccc278804 +a73ee70b6fe8c082443972102c453fc0e386852476cf22224fc0bfe554735c12f96037fbf10922795f4502c4f052b5f4 +932b27e175440169958504f3ed6400e7d6dcd5e716c19dcd0f15c56c04503ed133d5a993e111c016f141e32d68b29886 +96f7ce4595318e0b4a6b368f788ff82226aac676aed4ace343867f751de414453a9aaaabef6e6224ce5aedc3d5cf77c4 +a950c1e3bc9a14484997013d44d876374b939af437ae7c821c131fb886063ee9fe7214a25a0c7084f0b07b99412eff75 +a9dba3886ed6855303106a1bdd26010f294218684e1c178afcfea3f37a2f04fd01724a31d82de3449046617e3507a115 +87a2f776b32a6b550cf3ceeaf78db02819be74968d228b1d14e0d74a1cdf994bb500b7abef6619455e98d728701fac5c +8cd887b07e335edc0b27e6a660cebb64d210741395be431d79d570139687b056557159407459799a8197b6079644f666 +b81a61fce00588909c13a90c1caa150f15788786af443ff60ce654b57147601f7e70b95659e01f470334a220b547611b +8aebc51141544c5f3d3b99422250424b9800031a8fdfbf22c430907a3a446fecaa2392105d66d64b1c8e847240da4a6a +90db7dc12baa02f3f86d3edadf9434e2b9318d4f6f0eca08276b765dbb38d8eb0d08be2fe70adf2bf16ceda5db08d3ca +aa1839894152d548cc6ad963de20fb6fcc843bc9af2a2bf967c63626b8ad19e900894d6106265f38f3afccca317c22f0 +848e27b741496988a582515c0c8847b2bfc6a001259396cdeea1e1b1d2828ca3a626693a1bf4adf3a3d7f8b1fa3d75fe +a0aa11754d4ee136ac3ca609b17bcae77758763b2016544ca7921dddedd8aafcc7ad5f2b337c8bf53084eb8e43ea41fb +b8713b7aa1c112178195fdcc9b7024f46e6bc04c4e76c41abe620aa265287809200d98eaed6c9703fa97e81d6964f0ec +8605b5b33309e9ea6823542b85383c496794b8481c577497aaf99ba90496e794dce405be615bf92c7b6361460e6b82e3 +826fa34faa7f83e063a7bf172addfc07badabada59cfc6604fdf481d29085251c0a67a1355b2cbd374e2975934b84cb6 +b45d131082dc16fa53af010d43eefb79200dc23d2f3ee26af95ac6a5cebc49c84a9ed293e534ed16ff3ef9a4a25456ec +91bd6ce3c5396a7a0de489e49f0cdf6dce1cd2d0be7a410326423c3185bd1125ce1e610768be7f15f4e44b62f8834fc3 +903ffbe3d33fbf106c01c727dc3a385201a67ded70d4df623934882f69a3a96c909b027a124f3d70cb072b0046a149e8 +b405359db9d9ef4821a181b440ef2918c240595141d861d19a85867a5afa74d2972d22c988775eab441e734700bae4a3 +8abb756d027233c83751910a832b0ef4d28d100077f1c5d656720c94906f91d85dd0ea94b1cc0ed95b692efee14c786e +a78ee77ab476a41a3454160ba7ca4085d8b1f7057c63e76db8b07cf20afdeddd2250cd00771a6329133bb4ad48ccc20a +a41810271d8c37197aa9b3dfcefe3498e42f5978d3f3d59defff4676d6402d8575b40683834f184f143b6cfbfc859b3a +90c24a0750242660bcc6d487358a3cc015730538a0a8beb00ad5ac2ef33cb8ca8a62121e50bec8f3d2f43900f8e3134a +8b96c39695d864ef5796941754978a1fd612b369f6b77fe5ae6587beac936ee28190af8f0a3822b63060af35e49a5c8b +acde2548883d0e63c0fc257bb9dadd919aba60a985b69ebcfa1bca78acca42fc1322ec30bcc8e7c188818f858d04ad33 +895c86ae9ff8d95f2707d4838a3bc8ddb05b2611f0476f014b9c150d0e8332bc73285037a747426f09ac8179ba4e19fc +821761fe406e18bd86fa9ca9db99d382cd3b5c70c456f471fa3706d57763d147706304c75d54f51ce8f3115aa26e59d9 +a803a80e3e8f47dc3c59ea23eafdec017458eac648b360cd42cbd075e0dde6f6f450b48c7646fb1e178c04f82ae51a12 +91f40e1b6f588bd592829ce937996452c40be0fd6c43793c607866701ac6a8c7227e0891d45c6e7b1599382b0a3fbdbb +9408246d996a634a58689337f2526dfb3ba9ffef1d3ff91c32aa8cbbed900861ef25d6477308b67d76491edfcc70d65e +a492325a427f3df1c9c690c5b553daa8ac41f62f5ae55f425539222bacf959e2f67afabbba1732e120d3e7a6dcdf7049 +8fd0c3e15477cae228613a171b6e9ec29ddc63ef74854d99b638adeffe39f89f34346a42851e8445e855a9f2bbef0f57 +b735ed01fafa051004dbaad5e8c9e2faca8f6049ef9b590f256ea4d75b04594af12764ad4e6031735eae36f83179db93 +a7d35f43fca06c86b3425dcb68a87186834ba9740664fd657915771beca4cdc0fa2fc9b4c2e9d9bdad8ec33543ddfa59 +a1156e71e2db1b17df5da28747c88e091bd687bfee59d89096437ab4dc9a543fe5c5272d5023d72adbaab397a6fc94d1 +ab06a58bd81b33a411bade8d8c5232d38fadc2e38507159edea6e2e104b8ebd65ca02b05335118f691d44197b847a4dd +848b67a10f1e6ff8f5c228f226ef2ffeb67fb8f50925fc94cbb588d61896d9dc79726959e649898fd3354fe3ff7b7ee3 +aa933397361f32b388edcf832f0db172a38e756b34d5f7a4a050fa7325058006c22cede26ee27917e8f1b0f301792bd7 +89e49e7f02cfaae4a4b9c4180c9f6559d76e3a45774955859d4147970b1470dac37bdc9aedca1c32a20b045049161590 +adc1825d5ab94fc719f25d8c9773f4d518134ed88eb13ac33cb910b2be3523ef9ef88d9e4aea2418b806e20108317bf6 +96c4b444c8a023da644f3a343ebeeed19a8392d2ce175992461451c318a54273b76c3574d8f2dceda2947ddd34d1a674 +8aa7e97e87c8c5b29bbd51a6d30396a6be1fb82b716ef83800f2c36d5b85467ade7e0f59d2db82c310fa92a9265f0b03 +9146c32d99f02c3a6f764dcd9b4807f1585f528ac69dc4f84e4380f6fda4f9d5057c375671d51e7aca2b2b4140e83da0 +a10760a533d9bc57536bcaf65f080302086aa50225437efd64e176841544711828c23a15c49c0dd1f357d3f10722ab72 +acb0811777e17f7ae7aaba5f6fce81b759c067a4908730916195a2505c7450d0e6e2194c2ef0f241090597d58e70de47 +b24f161e9bcdbad56665e2490b5e4c7768390d4668cd69a04ed74739062dbe832636dd33cda89e9b0afa8c77e93fc641 +96b4d01106b831868a88ef016500ef2fa42d0ce87a37ca8ca4194a92a22c113edfe04eb2ca037329f3c1acc635148f55 +aebbb95fb4f7adcc8e7a217aeb73f9e037cbb873d08c1cd9d68c6c6834511adf1af8b44567fee84327599bdcb734dedb +a9bd8b17300532fb94d028659bcafbe7bbdf32f8945baf5db4cfaa1bac09e57c94cad0ba046b4514044b8fe81ea8596d +a5557cbda599857c512533e7cadcf27bf8444daa0602aa7499cafc1cf1cf21f9d16429915db7485f0e9a1b5046cf01c5 +8810307c40bc661c478a9747ebf2a30e5a5ead942d1ac0418db36ba5db0709c476f7d19685cabe6959e33ec1f3bff914 +8829b741f41f2c32e10b252d9338deb486dba2f23996a44cf1dd888ad967a589d51329be34d764139f372a1043f6c2e5 +a6b4728d18857c5fa082fa67bfb3b1d801e76b251b1e211a19c87cea5fe7ce757f943c85071f7a03a718388cd5690e95 +86da7f397e2533cd487f962ae58e87bea2cd50af70ef2df9ea0f29f70b5843cde664d30ec207ab84fc817f3851277e02 +8085776ef4ac6d42ab85b9d9135ecc6380720efd274f966544eeedf4684028197de76ecab919fa5414302597e1962bca +b05a065c733033d223ba13d16baa7a97bd8c8b8b1f0e59a9bdd36ee17e9922d48eb39bd180c168b122088a77f0bf321a +a89343fe44a93023dcc7ef71bd3bcb6786f68e1885ad260edc56a52445d34757f476395ba7ad35437f89bc573c7618dc +a114a9cd6105b524f3969c69faa2e09afe21753a93361a296f9e0e3b4e3e63726ddf2e6bfd3ddc046043e50bd44e539e +8a5611fec539cf681c05636bb580f29acc06f628bb012649ffa41ea6c1521194a5643d5dd843f09b6eb2c3bdb4d41acd +ade247c4011ec73ec90b72f35afa59a999e64ba5a7e664a4b30874fea53ba6a14a76a41b58a5f891a20d019e5f091bdb +905b5d96df388160ade1ffe210d0c6d1979081bc3de3b8d93ac0d677cc2fc2dc1ef6dcd49d3947055514292a3fa2932e +a9520796ca9fccd11b7524d866507f731f0f88976f0de04286e68d7cf6dbd192d0d269f0cd60fd3d34011a9fe9e144c2 +989a1edf4d7dae811eb57a865c8e64297837ffeeaae6ee6ac3af0f1044f023f1ca552bf00f1642491f0f0f20e820632e +879c8e63713f4935ed6e020559e140ea3073ced79d3096c152c430141272117b4fd9a9fc3eef012e81262df02ea14bd7 +95074738ac1540c0312274333acd1ecad9c5509fee883c4d9295fa8d8200f6e637c363de395f9fa612f05c0dc58fae88 +a770e4fc595269eb806b113ab3187ea75c8f96b57bf9fcfaf535f3eedc1d4d7e6285a20990575de0ff09f62d06ed0692 +81283e5dfb6423439ff513eca1cc316941d196df8da2d1069d2d0b63f5289e630af2fd4119bc0144c002d33313372dab +abd1b108e743887b78f698f2aba9d5492f87a22868d1351d705d93a1084fd45be67170c68a6e18b07f400d9a01cda8c2 +8509c3f67b92908cea8144f4e2a71631a66a61ac3547601c788907e52e380e5fe8ae4110aed95d13c67d3bcdd5b55a61 +8fa5a790ec5cce6d4114128c295390120869aac5490a82feebd3c37a167120df2e7fdfaf2a4050a7dfebf48fb093212f +944753e1ea7d8bc727d46a7702077dc01dc0c6574e8263a16579b57ee155ca5901f71bb347a01a9a922b329d3ff75135 +b46bc1fd4590b7a6275e20036d247c5909fc549c78e95b64ae7ed96e3b05bb044840f19f7650ebfe7008ba09fa83c3c9 +b1e47e4d88e59a06c465348c6cc4181d40f45b91e5e883966d370c26622c328415c6144aa2f61ddb88ec752482c550ca +8bd4f8e293e3f1815c7e67167618fb3b0ea76424bc0985908957cfcede36109378e41b4d89555b8c2541b4c447e00461 +a70589a867b2bfb63d0106083d58475d506637148549ed35c83f14e5c8de996e1b1f3447ecc80cf5cd134ef4db9d2fb6 +8048b80ba6131d07370162724127b0f7cb17fa7f71855e55e5a75bd0a9e4fd71b0d0ea2d16ec98858e458528df8d06b5 +97326cb94bae7530f4ec3235770c5a7ba042759e789d91c31fedbd979e3c0e6a2c69e2af3c1979c6fe0094274dbd53ce +a18e9c1d3eabd62af4e31a4b8e08494f4167fd4598c95d0123f39c46c53f9e93f76615900246e81a286c782ac37c569f +80309c59d4522b15aba617cd3c6238663e8b1c7ad84456346082c8f281140fc0edf9caa19de411c7e7fb809ca4fa3f4d +8e450c0990e2f65923f252311623038899eeff7b5c2da85b3a224e0ef7132588b291b782d53c477ecb70f34501466178 +87843f96f41484e254e754c681a65681b9ae5c96c292140368743df9e60f7e2ada58ca2bb95fa39abe064b2ebf21eeba +858e8d5bf2a1cf26d8af5036b28b831d450a446026f58a1734b696c18f1f41482796b91cab0e5b443dd2f0b9cffa52b4 +99627dd6bad8c05c5904cd23aa667d664da846496dbbb8452705c4ec01e1480e9c7295504a5a8529e4a0c842306b038d +b64b33256c18b2c886a837a0c0730fdfe73befb0e2796207c4dc592c5a33cd51f8c2ef47c584dd5773abf9ce9c1b0082 +944f6da2a1546f0bfc4d98c3e73c79e935e33d208b6be26b0b5f8df6d0e3b74a5bda649853b99281bd3a3ec799a7dd04 +a266d165435784d4e884640155e35b2a911b3f89e1e715986de419b166a36a341ba724877d80583fa3da566f6a828971 +adff2698409d0756e78c534032ee926560c13d578cb178d5073172d049ebbce32a92692f7e2033ec781b9b0d894ddce0 +a91933f110756c699c28bf9e24fd405bf432002a28c4349e0ca995528e56a5a2d101b8d78afa90a178ff1a9bf2ba515c +8e77839c0eb4da2d01e4053912cd823eddffbdc6b9c42199fba707ca6ab49fc324288b57be959fbfb11d59085d49324a +aa124517c76692036c737e987f27c2660514e12a953e63ff4bcb269dd18fc44dae95e282de8444bed09639ef6577af88 +b285deae99688f1bd80f338772472fa2b35e68887c7eb52c4ef30fc733812444c5cd110050275ad999d5a9b57f782911 +8877b0fa85b44ef31f50bdb70b879fa6df5eb1940e2b304fd0c8f08abb65f3118fa3d97ff93919038c1e452fb1160334 +8a89f3b50dcbca655024542ca7d93df17deff5c7d01c7da2bdb69e76b3e0b4490d85c800fb3debb4b0b4d20c9527f7ad +b7e5dbe36e985354ac2f4ab7730fea01b850af00767a6c4d8ee72e884d0fe539bb81f2e34638fcf5d07b7c8d605f4c06 +a85a1d78f6d4f9d5d83ec0f2a426708342d4e4a5d15625554e8452f6a843d9aa4db0c7e68caebdaf767c5b3a6a6b2124 +a518078a9dac63c5bf511b21ed8e50d1ccede27ebfe9d240937be813f5ee56aef93dc3bf7c08606be1e6172f13f352ce +91144eedebda4d1ad801654ef4ecd46683489b177ba1de7259f7dd8242c8c1700e15938e06c5d29aa69f4660564209a0 +a16c4657bc29d1d3271f507847b5a4f6401cee4ad35583ad6b7a68e6c2b9b462d77b5dd359fd88ea91ce93bb99130173 +85b855778f4b506880a2833b8468871c700440a87112fa6a83fd3ddb7e294b3a232d045dc37dfc7100b36f910d93c2ae +8d86bb149d31bfbf1fabcae1b8183d19087fd601c3826a72a95d2f9cedb8bb0203d1136a754aa2dd61f84b7f515acfa9 +acfe7264eee24e14e9f95251cbcfdd7e7f7112955a1972058444df3c2d2a1070627baefada3574ebd39600f7f2ea7595 +906bd14ecca20ac4ae44bff77cc94eb5a4ecc61eba130de9838e066e8766ed3b58705f32c650e1e222b3100691b3806b +8f2cbc7b8593c4be941dd01b80dc406fe9dfdf813ef87df911763f644f6309d659ea9e3830ff9155e21b195fc3c01c57 +a68eb15ed78fae0060c6d20852db78f31bebb59d4ddc3c5bdd9a38dbe4efa99141b311473033ff8f8ea23af219bc8125 +a95cb76c9d23fc478c7e8a73161f2ff409c1e28a2624c7d5e026e3cee9e488f22225a0c5907264545a73e83260e3a4ec +b76f90e55fa37c9e2732fd6eba890dd9f1958c1a3e990bd0ce26055e22fe422d6f0bcc57a8a9890585717f0479180905 +b80cc95f365fabd9602ec370ca67aa4fb1219a46e44adf039d63c432e786835bb6b80756b38f80d0864ecb80e4acb453 +b753c86c82d98a5b04e89de8d005f513f5ea5ea5cf281a561d881ed9ad9d9a4be5febb6438e0dba3d377a7509d839df0 +a664733f3b902fac4d1a65ea0d479bb2b54a4f0e2140ed258570da2e5907746e2ac173ace9120d8de4a5e29657ae6e05 +9479722da1a53446e2559bb0e70c4e5bf3f86c0ce478eede6f686db23be97fcd496f00a9e174ceb89ab27f80621f9b80 +b707fd21b75a8d244d8d578f3302d1b32bb2d09f2bd5247dff638d8b8b678c87d4feab83fe275c5553720a059d403836 +93214c16831c6e1d6e5a1266f09f435bbed5030c3c4c96794b38d4a70871782002e558d960778e4465b1ff296ffedad8 +8648f84e18eb63dad624e5fa0e7a28af2ee6d47c28f191be0918c412bf24b5460c04bf2b7a127c472914a0741843f78b +b67f61e75d6b773a6b58b847d87084b94f3cdac3daa7bef75c2238903a84250355a986b158ff96ba276ca13a6035fdd6 +ae9b094b7b5359ee4239d0858d3755a51aba19fce8ad82b0936cca48017523319c3309409ea6e9883a41bece2077e4d8 +8d1d8e1fba8cebd7a0e1effea785a35e16b1a10842f43e2b161d75add11eccf8f942d2ae91c20eef6c1a0c813731ea9a +b82bd387458e3603782d5e2dec32ae03890a3fc156d7138d953f98eff4200de27c224f626e3648e80cd3dfc684c4790f +a6dd02a89ad1c84e25e91176c26355e21a01b126c1df4d22546159dab9d502dbc69bc0d793a017c1456516e4aa5fa53f +a9ab74a5c5459b8500beb0ad13e9cfe2656e966dc9b4f3f98bec7588023b4ddebf74e4fc722d30423f639f4ee1b2587f +b03e5f33ab7ecec12cbc547038d3fa4f7ea0437e571891c39660c38d148212d191be29e04eb2dc001b674219b7a15a9c +925df4fc6e898ca55090ad1a8f756cc5014167a042affda5b24896eeb6aac408545134920586a8e1a2b997de9758b78a +98c8580fb56ed329fad9665bdf5b1676934ddfb701a339cc52c2c051e006f8202e1b2b0f5de01127c2cacf3b84deb384 +afc3765d374c60fac209abd976fe2c6f03ce5cc5c392f664bb8fac01be6d5a6e6251ac5fb54cfcd73e3b2db6af587cbb +8e7e98fb5a0b5b50d1a64a411f216c6738baaca97e06d1eba1c561e5c52809b9dab1da9f378b5f7d56a01af077e4f8cf +b724bf90309651afb2c5babaa62dc6eac2b8a565701520fe0508cee937f4f7b6f483fc164b15d4be4e29414ce5d3c7d4 +9665160e7bf73c94f956ecb8ba8c46fe43ae55c354ce36da40ccc7594beae21d48d9c34d1af15228c42d062a84353a0c +8600ab3aa86b408ee6e477c55572573ed8cfb23689bbdadf9fccb00161b921ec66427d9988763a7009b823fa79f8a187 +b0d8d19fd1022e7bc628d456b9bd1a2584dce504eb0bf0802bdb1abd7a069abbeeccdb97ce688f3f84a229342dbc1c33 +8f447d5e5a65bb4b717d6939cbd06485b1d9870fe43d12f2da93ca3bb636133a96e49f46d2658b6c59f0436d4eede857 +b94e327d408d8553a54e263f6daa5f150f9067364ded7406dcb5c32db3c2dffd81d466ee65378db78d1c90bc20b08ab3 +b58c02781b74ef6f57f9d0714a96161d6bfa04aa758473fb4d67cc02094cd0c0f29d0527c37679a62b98771420cf638b +8cfa0a687ea51561713e928271c43324b938aa11bb90f7ffaa0e4a779b3e98899f2af59364ce67b73a46a88748c76efa +95d6d39c814c5362df69116558d81ce6f1c65fb400fc62de037f670d85f23f392c1451d43341c59bc342bc31842c8582 +af888b384c52d9e04e4db6c4e507c2037eb5857e9bcc33acf84fc3a02d93cbde8cce32141fce9f5fec715b5f24d56356 +a7822bbc3c236fd58bd978f0fc15fe0b60933a0c953db6436a233441219418090ae0c07c490a6548e319029771cdaba7 +8c53729f750922e5eb461774be8851a3f40fe42eed170881cc8024d590bf0a161d861f5c967144d15cdcdc3dc6b5cf88 +a052a25a4aeab0d5bb79bc92a6ae14b5ad07d1baca73f4f6684ccecfc7ea69bc21eadeb9510452fdba116c0502dd698f +923946b83d37f60555dbac99f141f5a232728c6eb819a37e568c8c6e4d9e97a4229fb75d1de7e9d81f3356f69e6d36f1 +8cab82cf7e415b64a63bd272fe514d8b1fa03ba29852ec8ef04e9c73d02a2b0d12092a8937756fdec02d27c8080fb125 +b1123314852495e8d2789260e7b3c6f3e38cb068a47bdf54ed05f963258d8bcabaa36ccbea095ba008e07a2678ec85a7 +a685b779514961e2652155af805996ceb15fb45c7af89c5896f161cac18e07b78c9776047c95b196362c9ad5430bcb22 +b734dd88f6cc6329c1cb0316c08ade03369a11dc33191086c6a177cf24540c7ceee8199b7afa86c344d78d513f828e81 +b0bf492fb136ecdb602c37636ed4deef44560ab752c0af5080a79c9f76a1f954eba60a0bf6ba8bd7b8cac21848c29741 +a5c74682323e85ac20f912ab9c1d6e1b9246c4c829dca40c8a7d58ec07ea0ad3524be30623f351269552f49b65a1245c +837403b9cf830fb33ecc11a7c8433e07745973c36acdeb3fc9ea8f7d8d690d462e1250b7410f79f2f4180fe8f3962a4f +b03d64b944d49c83608f2c5b9c14070c025f7568c4c33d4eeb1da31d07f0bc5897e498b35b50d557ee129f0c3c68e254 +827272aab8bf757e2483156e00fbebe1093a58070dd3af9855bbf946c7abfb9c8a850a6a8acda8c620902f391f968b8f +84c4eb863a865282d321302d06b362f8bd11c2bb0090f90ebffedd3eb3e7af704cff00d39a6d48cbea4262942e95200b +b044eb91653dc55dce75c8d636308a5a0dae1298de4382d318e934140a21ca90e8a210e06fdf93aadbbeab1c2ef3904a +a8c08955a4378522e09a351ecb21b54025a90f2936b974068e80862803e7da2b5380c4b83b4b4aad0409df8d6c8cc0cb +a763a5fb32bd6cb7d7c6199041f429782deacac22b6a8467077fab68824dd69343ebca63a11004c637b9cb3129dbf493 +8c44c8afa9a623f05c2e2aba12e381abdb6753bb494da81f238452f24c758c0a0d517982f3999d2537b7279d381625ed +8613f47fda577cd3bda7c99b80cf4b2dd40699edfd3df78acb5e456dd41fd0773bc8da6c5e8cbf726a519b9fb7646ccc +b21a30d49d7e1c52068482b837a4475568d0923d38e813cea429c1000b5f79b8905b08f6db237e2eccf7ef3e29848162 +b9bdf4915f3fbb8d84cdfd0deedf2c9dc5b14f52bf299ef5dca2f816988e66322df078da2c54b934b69728fd3bef40b5 +993b45f389f55eba8e5ba1042d9a87242c383a066cbf19bc871b090abe04de9ff6c1438cb091875d21b8c10fac51db58 +a85a95d14633d52d499727f3939979a498c154fd7ebb444b08f637b32c1caf5cca5e933a2f5d94f26851ae162707b77d +b9874c7c4be1c88a9646e0c2f467cd76bc21765b5ab85d551305f5ec0b4419e39d90703d4ac1bb01feb3b160517e97b7 +ad6771177fc78812904c90594712956357de1533a07fec3082ba707f19c5866596d624efc3e11773b3100547d8f6c202 +a79f31921134f7197f79c43a4b5d5b86736a8d3ad5af1bdf4ad8789c2bfe1c905199c5e9f21e9f446247224f82b334f8 +a7f1b6c45321222a350a86543162c6e4e3d2a7c2dce41aeb94c42c02418f0892dbd70c31700245d78c4d125163b2cd5e +92abafe3ec9dbe55c193fb69042500067eb8f776e9bf0f1cb5ab8eb12e3d34986d1204136856fb115c12784c3b8dea6e +89bc761238a4d989006ca5af5303c910c584fe7e6f22aa9f65f0718a1bc171e452c43695e9f5a591725e870770c0eceb +aa0e44c2b006a27d35e8087779411ba2f9f1966a0f5646ff6871bcf63a8b1a4a7638751b94c9b9798ccd491c940bc53f +8736fe82862b8106e7fdab7b5a964d87ec291a74b8eb1cb5a6c046a648c1b686064ef3d52297043b8940bfe870c712f8 +956a3def1942f05144d8e9c3a82fd2d3610064b53b9eefde3d5594a8f705bf8f6849eb2c22181796beffeba43cc74ee4 +af27416d00cf97d5a1f4a1b6b51c010884cceca294f1151c3b684a3f83c3c8a3c30771df1166d833cbddf6c873c400c3 +aac3b8dca2336fc4ffc63c362df461289e4bbd3418c621bde6c581d3ecedf66e2b3e523d4db39e3d8ba014577bf85efd +94c3a8167f62074e5b28c2bffe4b6ce645439a9a0c5da3ca1b3ee956590a465d6f84a8a4dbbe9070ffbd6bbc734e4d62 +95e23ba6986d25ed4451215da05bd72c5491528271726d79a94c8cb16aef1c85b190d6c5b8a3a1191c7cafbab1dccf0c +953e3dadb5ad68f7de31ac09692948655d174fe16d88b96930ef35b331da7f1dbc4c17863cd07b4ec3135b5205891a27 +915d018f18b5d63cb3301c2bb5c6e85e75a88ba80663c964d06575b6bacbbe59139d030b218ce0998271d5b28c00b26d +8c871ba3dd138a908b2f7effeea0e71df096b23e0dd47cab10b9762b250abfd1221da94a8ee884e05bdf02271fb85a04 +96bad5c6ebc3080ecbe337409ae398bbeada651221c42a43ea3b7c08c21841ddbcfde544c9b8d4772de6f2ce92c0b963 +b5dbcd0b1c44c62108841558ec0a48df4b327a741e208c38b1c052321eda6e6ad01af71d49dfcdd445ab6fa6f0c34e6d +97dba59219b69e8aef2659d1f10bbea98d74aefff1f6451de3f41be39acbac0122b8ff58b02e90554469e88911ec3547 +b7e5682ec306478be4858296f5d03364a61f3260636a4242f984d351a02e8723378496beb30c4ca22def9c9ca193ea70 +9656a7a3df4d11df3d8bc35930dff70a5e78a488ca57bba20bb06814fc390fc6c7cb3f39b22134992aad196cced577de +8b269695aa63eb56d0324ba984279dc4c88e565321f1d61d553622bd4f1910d5eff68393d3a830eb924472bd478c2aa3 +9177bcd04b28c87bc0440268b4c8995c6790cad6039594971b2c177f0e197055231e776927d3fa30d98fb897a2ba401f +ae0e943973482001c4f214b9da82e1c27e38aa254d0555e016095c537c835d3702bc2de5c67b234ab151e02b3b7a43a6 +82fc719a7d38bf4787fe1888019ad89fbf29beb951d2fece8686d2beb9119d0c8c6d13bc598748c72c70d73d488140ca +b716dc66f87eb16b95df8066877353962d91bf98cf7346a7f27056c2a4956fb65e55cb512af278783887ab269e91cd76 +81d58cd8bc6657362d724b966321cd29a1b5cdc4601a49fa06e07e1ad13b05e9f387ca4f053ed42396c508cd065c5219 +b32ad0280df6651c27bb6ddbdc61d5eb8246722140a2e29c02b8b52127de57a970e1ded5c2a67f9491ae9667349f4c46 +b68a2eb64cc43f423be8985b1a068e3814b0d6217837fb8fbfd9c786db9cca91885c86899c50a1242040b53bf304ced9 +85887515d4e371eabb81194cbc070e0c422179e01dbda050b359bd5870449c7950e6b3947b7a4a0eb68199341cc89fc3 +ac5fff3c27dfbab78eb8aad37ac31cc747a82401ebf3644a4f4f5aa98d37b8bf3b3f4bd8a3428b32a127c25c9e19d239 +86fceaa6fbf8913553a9e1e907fcb1f1986d5e401a7eafd353beefd1899d571454fea96ff5b2a21254d9fb693ec94951 +b6778bb296d3f0de2531b67d36fdbfa21475be0ca48b9dfcc38f396c41b557823735ed0b583e525a2bae1fe06e04058c +898088babeb5b9866537d6489f7514524c118704abd66b54210dc40a1c1ddb0a1edf7fe0b6e0db53b836f1828ecf939e +b27854364b97274765f0fb8d1f80d3660d469785d1b68da05e2bd1e4b8cbbe04304804d4c8aabb44cf030eba6c496510 +8c55bbf3603dc11cb78b6395ccbc01e08afcef13611f7c52956b7a65ccf9c70551bff3ae274367200be9fc2d5cb26506 +947726f73cd6281cd448d94f21d3b91b96de7ad3ff039f9153befbb5f172db9f53cacb4f88c80a3db26e6a0f7a846eb0 +a7b733a05e97528812d71cecb4f638a90d51acf6b8fcbc054787d6deb7e2595b7b8d1cbe1aa09d78375b5e684a2019bc +8d5ca6d161341461544c533314fe0a6655cde032c2d96f0e4ea7e41098b8b39fa075d38e2d8c74e2d0308f250d6cf353 +b960e9f081393e2260b41f988935285586a26657a3d00b0692ea85420373b9f279b2f1bb2da2caae72dd2e314045f1bd +852a49c7388c10821b387c6d51617add97ba72485f52be95d347bac44c638c92e9c6a44ba0d32afc4d59178a497d944a +8412162a65147e1334ad5af512982b2b48eef565682b3f3e0bbe93fbc5e1103db9375a0c486bdb1b2c57e4cb3a8e7851 +8f52c3eb5d4f1e1e82cfd2b291d4910195427603b796f6c311deb35ef14a01a57a9e6cad39619ad108f3e86f384f9e1c +88d221088f2bf0103c53e44d0d96cd7881ec2b0a965db9121a47481771a8b796edd5ac23c4f9c208a171dab301f7d3bb +b49c3235e8b3617ed08a1891b9e2bcb33dbdacceb94ca96330555b7e00904fe6a749ced9312b8634f88bcb4e76f91cb1 +a85834215e32f284d6dfb0cbfd97f6cffc7b9d354e8f8126d54598bb42d7f858a2b914cf84fa664069632db2ff89a332 +aa3d48eb483c6120c27d9b3e3d0178c1c942632ff54b69f5b3cfbc6ad4ff5b2b9ce6eb771fd1eea8edf4a74c97027265 +a446cfded353cdd9487783b45846402b973cdeddf87e2bf10cf4661610fff35743cc25e8d3b5771dcedfb46b018a5d18 +80998377b3b393ef3073f1a655ad9d1e34980750e9a5cfb95f53a221b053ddb4d6985747217e9c920735b0c851d7551f +a35ac469790fac6b8b07b486f36d0c02421a5f74ea2f0a20ffc5da8b622ac45dfccabfb737efa6e1689b4bd908234536 +8fb1f6d8e9c463b16ac1d0f36e04544320d5a482dd6ffaec90ea0f02b4611aaca984828bf67f84dcc3506b69af0a00a1 +b6e818d61aea62c5ed39c0a22ccbb327178feebdabda0c9927aa1549d2c5bb0637785c4aed2a6d9a7b4989fa8634c64a +b4e7208d16018bf67caafe996d436113eac619732e3f529a6efb7e6f094d8ebea55b7be0e122be075770f5957b6ea6f0 +b691d38b552befac61f6d367287c38d01fec73b7f2efdb6713ca30314a37fb7c177eb111fe6bee657f2681014e07630a +9817587e418e6e7e8e97ae27067f17b55d25dfb14e98f63f530620c855d9a348c9fa571c8508e2741f902f8b9fdc0c5c +b6a6e5ca779ba140bf1d84cd5394ede8262f7479637ec0087a4b152243a1774ba916d8115ce759a3bebd1b409de5f2fc +b53d1c84ad766ff794bf497db3228efd2cc8ed5fc1958d89c1126efdff361610ecb45ea8e329b39035ab00a66c1259c7 +adc31333c507c8e0f4aa2934fcdca57fd9c786722a50dbd5404e129541f7ac182cc7373bf14e1e4e06e6cf94b31b90eb +a82b7fde4642d982d95cec669efee140ad797a2442c7f6620580527d163accbf021b893446cbb8038ea82fe25b15d029 +91f7acf8a8903979afa281646fdecb54aa4d2ed905748e156e92f0910de268fa29d67107d40863935d677d1de8039be2 +86fea71c6d43a7d93216a92fc24dfce8521fd4534a9558b33762d002081247867a6eff54cad7116023277fb4049403ad +8ae5369a7f9f4c91f3be44b98089efd9c97c08f5bb4cd8b3150c115ecd86288fa0865a046a489c782973a111eb93966e +b6fb9e829aa2c81c2d9eac72bb2fd7f3a08e0cd763532c2ce3287444d33cf48b3621f205e9603ec58525934b61a795a9 +83e35ca808d84e41fc92115e9f6e283e928c3a614e6dfc48fe78c33b6411262e7bfa731eadb1e1937bc03cff60032e1d +832fca5196c95098ad47b7d24ba2f9d042e1c73ad2273edd1c2ce36386796ccc26e8567847697f3fcc2a0536a2a2087a +8fdb7038bc8f462ab2b76bf7053362f9c030019f1b6105cf42219a4e620ecc961e3eacb16a8e581a562a97f1418b0128 +8d3a5a404b51b1ad8ce3b23970e0d5cc57b573922341008e3a952a1dd24a135e19e55b79d86a70cfd82e1c0e9630f874 +ba00c025c1c21c57c03cdfc0bfd094b35422281ff0a64b68b240617aa58c6b18800af5f2047d3ff9068bbe987d6c7980 +b468f0dd51964b3806b0aa04f3fe28a035e8f5567fc7d27555be33d02701a838b8dbfe1348b6422c4eac46d2c75c40c7 +8a73a18c97da9958903c38584b08d0e7e26993a5d9b068a5e0e1ee0d8a873942745cf795f94f7a3d3ba88790a9fbb2f6 +953a0a40c2c8102723736854d13b228698c14a02d85c8d2e61db1a768019ac305faf0d5db62ac976430ce087a5b20f1e +8998219da6b34f657cb8a621c890a52cb98c2bc0f26f26e2af666eebeadadc5e8bdf4f830a91d04aca8ce186190152c8 +8941e08c3155ad432236ed05460420a05dd0aaab30477493ffb364b14c00ea5b9183d30d3442b6321d2d20c36e4f5c7e +93f293ff7fb56cf5b03aee6f3ad2ad78444398ed5b3be56d7bf5b56b5aa5a2b980d13895dd57a5726d1b067c20cc55e2 +84a16f313e3f75e31824f58d19ab24c6611fb4c75140a7cadc3c166f68819547c1d0ff7f7d13f5d8ae30dff1d80e2aa4 +b6e3e830b15039d3e28b08f5465bb089eade11ee3bd80afe39e010df7db1fcf0c56d698717677a41ddbc91eeaf6544d3 +95e928e6dfff51351281568ae72da7d1edeb6e9fe01f30af0499e7505ba35a22b5bb919d41bb809a432dce83f3977663 +aabeeb60ca46f9b0232ff82ea7766dcab8cc5aaf9d23539f30174f9486640bc9312868ca493b59b314519fc399973e47 +b393a11e957d0bbb3ecf617b075b5906a3450b348e62916c04791b366f0a7397cccd6648440ac544bc30526e1f95aad8 +abb5bfc3964a6d246da60bd809d0ea6daf4f8222efdc12ceb6730194e85f413ee7eb03bae300abf7ea900dbbc3d08971 +96c1bd1d1d216a4bfbcf000c123f296c0d31e1684e9e3884c14df23bf528c8d599f82bb98fcea491716b617216a8e0be +92d1e570a56f1741fd9f3d9f488cc336421c6256c14a08d340a63720be49b0029e3780e3e193a2e22bf66cc652fa22a3 +8769c08551e3a730e46f8e5d0db9cf38e565a001dfb50db3c30fa7fa0e98b19438edc23c6e03c8c144581b720d7b33a4 +b850bd67fdf5d77d9288680b2f6b3bc0f210580447fb6c404eb01139a43fccb7ed20051999ae2323ea5a58de9676bfb4 +80285da7a0aaf72c4528a137182d89a4db22a446e6c4a488cf3411937f4e83f7b00ec7549b0b4417682e283f91225dfe +80520368a80b97d80feb09dbc6908096c40ff7120f415702c1614d7112b0b57f6729581c71f4a3ce794ac959a46494ff +9817b4c27a490b1cd5a6337e7bc7e8005fa075dd980c6bf075ddfa46cd51cc307ad1d9f24e613b762a20fc6c877eab41 +ad66bda1a3034ec5e420b78107896ecf36126ce3ef9705163db259072dfa438c6107717a33572272062b9f60cb89557c +876114ef078c2915288e29c9abe6b0ad6a756b5ee2930ba1b8a17257f3f0557602d1225e8aa41ce8606af71ada2a971b +aa3d6cde4c3b9d3d5d0c77a33e67f182a3e1cf89b0921423b2024236171955b34afc52b1f25b1dad9da9b001371771d7 +984d3e3a72412d290e3459339757af7520d1739c7af0cbcf659c71999328db44f407d92e8a69fea11625612c49eac927 +ae890d0faf5bd3280dcad20a5f90e23a206661be8842375fea2ab22aadc500849ffbc52fe743b376d46bb926cedae6a6 +b1f231f3f4d710c3fe80099faeb56dac67c1baf53b8fe67a9920fe4f90e52cb9a4bf19211249a6456613b28efe337f18 +8caa54b418ba609d16520af3dff2e96d5f2eeb162c065a1763beb926547b2cfb3ae41d738db2c5681a9bc8bc9e6b9a1a +932157ff56c5ac29cf6cf44f450c882b3acfbb9f43d12d118da3d6256bde4e6eb3183aea304ab6967f37baa718ffec99 +9360bed8fc5b6aac36aa69473040689bfc30411d20ffb7275ef39b9ff5789f9055d149383ce9f0f7709a1f9d683adbfe +98b5b33209068335da72782179d0c7aeeabe94b5560a19d72088fe8323e56db7ce65debe37a97536b6b8a0ca3b840b61 +89a385c11be40064160b030a1bb28c3921fc8078522618a238c7ea0f86f34717ed9af9b4e2e20f5128e5f7fc66ad841e +b615703cbc64b4192990cc7e4903b74aed6a0076ce113b59ef7719197ffa46fb29eb78ca56b49873487432d0625c0faa +90f0d77abae9d3ad73a218e5ccec505ad108ea098451461567ae8ef9661606ca8e78df53b5d628b20b7037bd24622330 +92e0e7cc4dfadc5fa0ee6da0c8de0493030db6e54ba0317f52f232a6708b732068b6077bd13a17eb7eb40b88368085b5 +a24dad20094985bfccc6df1343506ed3bf9dcbdf4b2085a87627a5d71f7568db067304e465f8f380c5c88e8a27291a01 +8629a45a10619354c84bdc2f6c42f540eab5a46f53f2ae11970433d7a2aef007897590bf31dfba1c921614c6d6fe1687 +84ac64040d4206f82b08c771f375da4b7d752e41d2aa0da20ce845f6bc1b880a855d3ee966bca19b8ec327b4b43e7f0e +9608e6050c25996c052509f43f24a85cdf184135f46eaac520a9a6e78e0d44a6cee50ebc054048c708aefde8cd6651c2 +a32032b0e0d7cc35e480c328f315327f9385adb102a708c9ba637878deb74582ae26bb6d6e5f8c9e3a839b0e0154b82a +b7e3c78d63acc6564a49e9f00b0a820b56d4f37a2374af1f7f1d016268011df9e7af0670ed2b0eee961f15aa948328dd +8b88bfdd353acc91ad0d308a43e5fb40da22c228f2fe093c6d6904d70f69c6203f56636ed898b05df51d33f1095ef609 +b1d7a430c51fc857af55047683fc18c453b013527196c5e1bf776819a3dffca802217e9249ae03f084e2ea03ad67fcc2 +80558e28a819ddb5e72e97c54be0f57c173ccf78038d360d190b7f1350a19577b8e3f43fa2f7bf113a228cd3b965b2e4 +b4b2ec44e746c00dfc5661ba2514930934fc805cdc29adc531c02d28ce3cc754414b0485d4ee593232cd1175f357ad66 +b57cee5d32835f76572330f61ccd25a203f0e4a7e5053d32965db283aad92f287645533e8e615137208383ec51b1fd99 +930256086b419a8a6581c52590d0dbd9f8a3564c79424198fca3866b786df2f6098a18c50dc4abd20853a7184b1ce15d +8e75fd01181cffcd618a983492390f486e8c889972a46c1f34a4e1b38f384e8e4efc7e3c18533aa2057da9f9623e2238 +b375d927dd988429f9e2764e5943916131092c394fce13b311baa10f34b023dd3571da02553176091a0738cc23771b9a +b9e28e4c0d0477518034d000e32464852e6951c8db6f64ccdb1d2566f5094716213fbf2fc0e29ac88d0e79f725e3c926 +963981e99392afbd2b8318d5a6b2b0cc69c7f2f2f13f4b38dddbfedb2b0eaf0584aecfcbda20a4c60789c15d77970a58 +a7804e1977aa77c263c7c001afa6cf568032dea940e350d6a58ce4614f1a91c13ae1c78bfea740c229dce2444556976a +8787204177da3cde6d35cd3497fa8774d244f9faa9f4bd91b636a613a32ce2ea0326378cf9c4cf475e73ef751b355c4b +895aeef46a07152a04ec812f1aa1fd431389fa0ef6c6e96a5b833e70ea14073bc9984757a8ee456dbec9788e74e6f0ca +8d17f0e5826783440d1f0ec868003510a4d9952bfe4a638e44a36d94482ac18ba70ef7ff773bdf7a3b62d714dcf0fcba +810d5e36b31310b2e054a666d3b3f7ed16dfcb1765532d87ca2a3920316f0187303c27dd113db145d47e8961062a6c03 +b4e2fb48ae04cf8580bb6a28095076c9b95e5f13122b917328f334d4ac8a8648ce442919e28319a40148987350ab5303 +b85549a313544fa1eb3ceb78473b7d3d717fc85b808de7b79db7dbd0af838ebb020622a7503f1cbacab688dddb648f84 +80665adee057088eae827a5fe904ec3ad77d8843cdce0322d535e0659b4abc74a4d7ddd8a94c27f2def5c34ac2c038ee +ad72fc19c2ce99b5b717e35528fe7d3ac8add340b02ebeb4889d9a94c32f312a0b45ea84d21c54f84cc40ee4958b72e1 +99d530c843dff89a47a5ee8c87303ab18f8a82b0d5b808fca050354b35da5c5a5594d55921c6362d6cc917d75bdc18dc +99c7286c293e1be21c5b2a669dfdfcd5aa587105d2886fc5a8eaf8984da4e907f7d7b8c2362d64a4f1621b077a2a08a0 +b4a39e1a9ed5d80c9563c3ca3fadf76f5478c63a98f4346a61b930c9c733e002f3ff02bc16abfdb53d776184cc3f87ba +9378ea71b941979404c92d01fb70b33fa68d085bf15d60eb1c9fc2b5fcdee6379f5583389a3660a756a50019a2f19a69 +b68e17344a2bc45b8e2e19466b86dc139afefbf9bad2e2e28276a725099ebac7f5763f3cb52002261e3abe45ef51eb1a +819e64dc412b2d194d693b9b3157c1070a226af35c629837df145ea12ad52fa8eabd65b025a63c1fb0726207a58cdde8 +a5e8ff8748419466ff6df5d389125f3d46aedacf44eaf12cbfe2f68d218c7d5ab6de4a8279d13aecc25f3b1d98230894 +91560d54a9715cfda9cf7133ae51c432d0bf7fcbaeb468004994e6838bfc5ddcfa30e4e780667d0c4c0376780b083017 +ae8adb3309cc89d79a55ff74f129bb311fe4f5351a8b87600a87e0c3ba60825f71fccf67eadcf7e4b243c619417540fd +8d92cc1a6baa7bfa96fbce9940e7187b3d142f1888bdcb09bb5c8abf63355e9fb942ac4b4819d9be0e0e822d3e8e2e08 +a6e8b79fdd90c34735bb8fbef02165ccbe55ea726dc203b15e7a015bf311c9cac56efd84d221cc55eaa710ee749dbdfe +a409b151de37bddf39ce5f8aa3def60ee91d6f03ddd533fce9bf7bdbeac618cc982c4f1ffbf6e302b8353d8f28f8c479 +b9693975ef82171b3b9fc318ca296e4fe6110b26cbdfd653418f7754563fa7b6e22d64f8025ee4243483fa321572bfe4 +a039ebe0d9ee4a03ade08e2104ffd7169975b224061924cca2aae71464d250851e9f5f6f6cb288b5bf15df9e252712a6 +b27834db422395bd330e53736a001341ce02c9b148c277dabac67dc422741bfa983c28d47c27e8214cd861f2bad8c6f6 +a2bafaf4e2daf629fd27d7d5ac09fb5efc930ff2ae610f37519808683aa583fe1c6f37207daf73de1d8a164f79a0c981 +b856cee1cfcf5e50db9af4ab0aed3db2f43c936eaea369b5bba65582f61f383c285efbda97b1c068c5d230cbe94f7722 +a61ab205554c0550fa267e46a3d454cd1b0a631646b3df140623ff1bfffaa118e9abe6b62814968cc2a506e9c03ea9a0 +8c78edcd106377b9cbdfa2abd5278724aed0d9e4ae5869b5d2b568fdabb7804c953bae96294fcc70ef3cd52ba2cbe4ed +8570869a9bbf6cc84966545a36586a60be4d694839f367b73dfc40b5f623fc4e246b39b9a3090694aa2e17e652d07fd1 +a905b82c4da8d866a894da72315a95dc98faa3c7b3d809aef18f3b2be4801e736a1b79a406179e8cac8f74d27e71ac52 +a8eb8679ff1a64908515f6720ff69434cb33d63aeb22d565fde506618908b1d37585e3bd4d044fd0838b55787af06b42 +af4d86b2fbd1684a657dffe4210321a71e6ae560c144d44668d1f324dc9630e98348c3d444622a689327c1a59cc169dd +80359c6eab16954559ab0e6a1fee9a0526c45d3cae1a371159a2e3aa9b893afdc3a785c9559a5fd9cd8cd774234bf819 +8d4e5ff81eb5d17bbe8ae6416538ca51a9427ce142b311f5cbb14febbbbb9c1ffc6489fd625b9266264c366c12a9d997 +92e181c66489c5fa063ba2a1a354b6fd3439b8b4365a8c90e42e169bfaa1fb5766bf3e0fe804399d18bc8fbcafb5c3b1 +a9ddf229360a095393885083716cb69c819b2d7cfb100e459c2e6beb999ff04446d1e4a0534832ae3b178cbe29f4f1d3 +8e085ef7d919302a1cc797857b75cff194bdbc1c5216434fa808c3dea0cf666f39d9b00f6d12b409693d7a9bd50a912c +916dc4dc89e5e6acf69e4485a09fc66968f9b292eac61a146df1b750aa3da2425a0743d492179f90a543a0d4cd72c980 +b9cbf17e32c43d7863150d4811b974882da338cf0ed1313765b431b89457021dd1e421eeaa52840ef00551bb630962dc +a6fb875786daec1a91484481787093d8d691dd07e15c9c0c6ae0404bf9dc26083ed15d03c6d3fe03e29f28e20da21269 +a870fcb54b9a029e8086de9b08da8782c64ad2cc2e7fdf955b913d294038bb8136193256b85267e75a4ca205808a76b4 +99883f057e09b88bf0e316f9814c091837fd5c26eeb16fec108c9fed4b7a2bd1c783dac0e4242b5a906621ab606c1e50 +85d89069ca3190577dab39bbec43c16bf6dbca439ad3eebd8f5e9f507d84c3c43e77fd6323224582566a3aa2c8018951 +9363ba219e0003f6e8a9d8937b9e1449e4b2c5cd57194563b758bea39deab88778e8f8e4f7816970a617fb077e1e1d42 +820622f25553c035326145c1d2d537dc9cfd064c2f5bdf6d4ec97814de5fe9a0fbd443345fa2ea0a9d40d81d3936aa56 +87e31110aaf447e70c3316459250e4f7f8c24420c97828f9eb33b22107542c5535bdb48b0e58682dd842edea2886ff08 +95bf80cac6f42029d843d1246588acb40a74802f9e94b2bf69b1833936767e701ef7b0e099e22ab9f20f8c0c4a794b6c +a46ecf612b2763d099b27fb814bd8fdbaee51d6b9ac277ad6f28350b843ce91d701371adfaaf4509400dc11628089b58 +8604decf299fb17e073969708be5befeb1090ab688ad9f3f97a0847a40ea9a11bbcfc7a91e8dc27bc67a155123f3bd02 +8eb765c8dc509061825f3688cb2d78b6fef90cf44db33783d256f09be284bc7282205279725b78882688a514247c4976 +b5c30b2244fa109d66b3a5270b178960fdec47d31e63db0b374b80d2b626409eb76d2e8d1ebf47ef96c166743032fc5e +aab01e76290a7e936989530221646160bf8f64e61e79282e980c8c5dcaaa805ff096efd01d075a2c75917a3f4bf15041 +b9d79671debd0b83d0c7c7c3e64c0fb1274300564b262771f839b49218501e7f38ef80cae1f7e5a3c34acdc74c89dab6 +92c0eaceadf036b3b9dfd2712013aba3dd7c30b7760f501f52141618265baa31840fe77850a7014dc528f71f8cf39ce6 +b3cdd098059980455dd5b1c04182df1bd12fa844a866f02a9f8a86aab95b59945baa9af99f687410bffc5b07153cb23c +b361b73a62f71256b7f6ea8e0f6615e14fc5a06ee98b928ab3c9dd3eef9d9d30070e9855c82b7facb639cacb3401e01f +b9c85fc0f25a3271cf28b1ca900078eaaa66cbab0a3e677606e898ac32781a2dfce4d9cbd07404599e2c3c02fa161c9d +ac5b4fdac2a0b2e6430d9fc72bde4249d72183b197fc7347bb1546ae6f544426686bbe0caec3ee973b6836da5e831c44 +b675aebf24b92e398e166f171a6df442b3f5919b6bee192f31675a5e8eeb77d34c6590a6f0c0857417e0f78cfb085db8 +a9bef942044d8d62e6a40169f7dc7b49e40cd0d77f8678dd7c7bae6f46c46786f9b1e319a3fa408f22a54fd2a4d70804 +a20d19cd917d5102ae9ca0cf532127d2b953aa3303310e8a8c4b3da025dded993a47e3a28e6b02acfadb6d65dc2d41a3 +a47fdb04059b83b2afb86a47b2368bbd7247c337a36d3333b6e5ef2cc9476a92c4907e4c58a845c9ef9b497621e0b714 +94a9e9ffc14b411e11a4ffa59878d59460263589003dc7b6915247c549f67feede279bf3645fdd92379022fb21e3caeb +b92e1177dd9ecdaf1370c71b14954219cf0851f309bc216d5907a4e2e84e0df3457018224150c142cc6bf86644bb4b73 +8bc57fadd68a265b7df9b42227a9c0968db7b1bb50dc12f7d755505779f1ff2c408672b3091e903366acc9ce15d19fb6 +b6b5efbe1ac4e1bd2e8447c45000d09397b772ca5496acc447b881022608a41c4f60388814607a01890190105bee7be3 +95f7c85fd614df968f8ccf8d086579c9e1cec4644ecf06da26e3511cb39635a7326b3cec47bd51cf5646f1c660425e9c +b81765fb319bcdc74b4d608383ccb4af7dd84413b23af637be12e2827a75f7e4bcd14441cf979ed9038ae366fbb6f022 +a120ea76cda8c6c50c97035078f6648afe6537809bdba26e7c9e61de8f3070d2347160f9d34010effbf2ec7e94f5749f +92c1b8631953b40d3cc77eee2c72a064b999c09a9b92c11d8fa7b4072966273901c9dba25f9f79f384d9f11a56f3fc7a +a4b00dc0ab67b2300abc9c516e34daf444d6497b066a90cfe3381ed2812304ed37b14f3b948990443dc6c1cf1bed460c +a9e9f7e13c9f031bc7b9e6f1417c7abcc38894fe7d3f54869ee277afd2efa3e6fb50757dd36c8c94d591e0abdea322cc +84f3e98f831792b5ad14bcfe62a4c9f296476c6087c4c1ec7767fc642fbca141ff6a3deeb8b4d4106a9cda5a9937eea0 +8eb1a7931bbea9a714226fd74b0100ab88355287d9b0a349c095e9b5809b98f237ffd706bce7d67a770da355fb9cec7b +9738ef8739e1742c1f26b51a1621be0b89d37406a370c531e236f635c7064c661818817bb3858908986aa687b28b21be +a9cf3ce8501b003ccaf57552a4c4ec31081e44526d3aa3791d3dc4a7e438a357c0956f93c500356186d8fd4588ffac5e +a7af6a219cca59225839a9de5b19263cb23d75557d448bc7d677b62591a2e068c45e5f4457cceb3e9efa01d0601fc18a +972a24ece5eda7692cbb6fb727f92740451bc1281835e2a02931b2b05824a16b01dbe5edd03a0ed5b441ff25a5cc0188 +b21d1ec7597ce95a42f759c9a8d79c8275d7e29047a22e08150f0f65014702f10b7edce8c03f6e7ab578ce8c3b0ec665 +a13a1c7df341bd689e1f8116b7afc149c1ef39161e778aa7903e3df2569356ad31834fa58ceb191485585ce5ef6835c3 +a57bdb08119dc3bc089b5b2b5383455c4de0c2fcdac2dcfa21c7ac5071a61635ff83eceb7412f53fab42d1a01991de32 +b2968748fa4a6921ee752d97aa225d289f599a7db7a222450e69706533573ded450380c87f8cdd4a8b8c8db1b42b5c97 +8718ec04e0d5f38e3034ecd2f13dfde840add500f43a5e13457a1c73db0d18138f938690c8c315b5bcbeb51e8b9a2781 +82094789e26c4a04f2f30bdb97b9aecca9b756cbd28d22ab3c8bed8afc5b2963340ddfc5a5f505e679bf058cbc5dcbb8 +a35b8a566dd6ab67eddc2467906bffc76c345d508e52e9e4bb407b4f2b2c5f39b31d5a4bf5022f87bf7181dc6be2fe41 +a8c93b1e893d4777c0e3a1b4bef3be90c215781501407c4011457fc3240e13524b4d2bea64a6d0a3efe3f3b0dae9b8ab +877095ad18b1e5870818f7a606127ba1736a0b55b0dbcd281ec307c84b08afc0c9117e3a880fe48bfc225fbf37671a97 +84405ee0421ed2db1add3593df8426a9c1fcc8063e875f5311a917febc193748678dd63171d0c21665fb68b6d786c378 +a52cdc8209c3c310bed15a5db260c4f4d4857f19c10e4c4a4cfe9dfc324dfac851421bb801509cf8147f65068d21603c +8f8a028a70dda7285b664722387666274db92230b09b0672f1ead0d778cee79aae60688c3dfd3a8ed1efdeda5784c9d4 +a0be42fecc86f245a45a8ed132d6efc4a0c4e404e1880d14601f5dce3f1c087d8480bad850d18b61629cf0d7b98e0ae0 +83d157445fc45cb963b063f11085746e93ab40ece64648d3d05e33e686770c035022c14fdf3024b32b321abf498689ad +8a72bbf5a732e2d4f02e05f311027c509f228aef3561fc5edac3ef4f93313845d3a9f43c69f42e36f508efcc64a20be0 +b9ca29b0ec8e41c6a02f54d8c16aebf377982488cbe2ed1753090f2db4f804f6269af03e015d647a82ef06ffaa8cba6c +b4df3858d61bbb5ded1cf0be22a79df65ae956e961fbb56c883e1881c4c21fe642e3f5a0c108a882e553ac59595e3241 +86457d8890ac8858d7bab180ef66851247c2bf5e52bf69a4051d1d015252c389684fcc30bb4b664d42fbf670574ab3a3 +86d5576ea6dfa06d9ebce4cd885450f270c88a283e1e0d29cab27851c14ed2f00355e167b52e1539f1218ad11d8f13dd +883ad1364dc2a92388bfafaa9bc943c55b2f813525831e817a6208c666829a40455dde494eba054b2495a95f7ce69e8a +8942371e6925231c2c603b5f5a882d8404d39f0c7c4232557c2610b21c2c07f145466da798ea78b7932da2b774aa3128 +a799eb71496783cc7faf12c9d9804bf6180699a004b2f07fc5cc36840f63ce7eee7dde9275819a9aa3f8d92dc0d47557 +8eb3fb5c769548ee38c7882f51b959c5d5a42b5935269ccf987d6ddbb25a206e80c6000bcc328af149e0727c0b7c02c0 +8f3910d64e421a8f2d8db4c7b352ba5b3fc519d5663973fea5962efe4364fb74448770df944ef37ffe0382648fb56946 +b41413e0c26ff124cf334dab0dc8e538293d8d519d11cc2d10895a96b2064ac60c7da39f08589b38726cffa4c3f0bfef +b46ef2eb10abae0f35fa4c9c7ee2665e8044b8d9f91988a241da40fd5bbc63166925582151941b400006e28bbc5ba22a +b8baa8b4c420bb572a3b6b85479b67d994c49a7ebfe1274687d946a0d0b36dfed7630cfb897350fa166f5e2eff8f9809 +964b46d359c687e0dcfbdab0c2797fc2bd1042af79b7418795b43d32ffca4de89358cee97b9b30401392ff54c7834f9f +8410d0203d382ebf07f200fd02c89b80676957b31d561b76563e4412bebce42ca7cafe795039f46baf5e701171360a85 +b1a8d5d473c1a912ed88ea5cfa37c2aea5c459967546d8f2f5177e04e0813b8d875b525a79c29cb3009c20e7e7292626 +afaab9a1637429251d075e0ba883380043eaf668e001f16d36737028fded6faa6eeed6b5bb340f710961cee1f8801c41 +aef17650003b5185d28d1e2306b2f304279da50925f2704a6a3a68312f29fe5c2f2939f14e08b0ba9dee06ea950ad001 +97bcc442f370804aa4c48c2f8318d6f3452da8389af9335e187482d2e2b83b9382e5c297dce1a0f02935e227b74e09a3 +8a67a27b199f0bcd02d52a3e32f9b76a486b830ec481a49a4e11807e98408b7052b48581b5dd9f0b3e93052ec45dfb68 +b113bf15f430923c9805a5df2709082ab92dcdf686431bbad8c5888ca71cc749290fa4d4388a955c6d6ee3a3b9bc3c53 +8629ca24440740ce86c212afed406026f4ea077e7aa369c4151b6fa57bca7f33f9d026900e5e6e681ae669fd2bd6c186 +933a528371dcecc1ec6ded66b1c7b516bd691b3b8f127c13f948bfbcda3f2c774c7e4a8fbee72139c152064232103bdf +8568ddd01f81a4df34e5fa69c7f4bb8c3c04274147498156aec2e3bd98ea3e57c8a23503925de8fa3de4184563a2b79e +8160874ec030f30fda8f55bcf62613994ff7ed831e4901c7560eac647182b4a9b43bfaff74b916602b9d6ae3bfcaf929 +ae71c48d48cf9459800cdf9f8e96bc22e2d4e37259e5c92a2b24fbe2c6ca42675e312288603c81762f6ceb15400bc4c9 +b05f39bb83fda73e0559db1fd4a71423938a87ad9f060d616d4f4a6c64bf99472a2cbfb95f88b9257c9630fc21a0b81f +80c8479a640ed7a39e67f2db5ad8dfd28979f5443e8e6c23da8087fc24134d4b9e7c94320ffa4154163270f621188c27 +9969ba20ee29c64cb3285a3433a7e56a0fe4ddc6f3d93e147f49fe021bed4a9315266ebb2fb0eb3036bb02001ae015e6 +a198c89fef2ab88e498703b9021becc940a80e32eb897563d65db57cc714eaa0e79092b09dd3a84cfab199250186edcc +8df14a3db8fe558a54d6120bad87405ba9415a92b08c498812c20416c291b09fed33d1e2fcf698eb14471f451e396089 +81e245ef2649b8a5c8d4b27188dd7e985ef6639090bdc03462c081396cf7fc86ed7d01bfe7e649d2b399255e842bdc21 +8659f622c7ab7b40061bcf7a10144b51ad3ab5348567195924f2944e8c4ce137a37f1ba328e4716c10806f3fb7271689 +a575d610fc8fe09334ca619ecdadf02d468ca71dd158a5a913252ca55ea8d8f9ce4548937c239b9cb8ab752a4d5af24a +94744549cd9f29d99f4c8c663997bdfa90e975b31f1086214245de9c87b0c32209f515a0de64d72d5ef49c09b0a031fa +80a8677862b056df59e350c967a27436c671b65d58854e100115bac9824ba177e94c2a1bfcaa191a071b9cefdbee3989 +91be9a5504ec99922440f92a43fe97ddce2f21b9d94cd3a94c085a89b70c903696cec203bbab6d0a70693ba4e558fb01 +8c5a0087bcd370734d12d9b3ab7bc19e9a336d4b49fc42825b2bfedcd73bb85eb47bf8bb8552b9097cc0790e8134d08c +933aa9e6bd86df5d043e0577a48e17eea3352e23befdbb7d7dcac33b5703d5ace230443ac0a40e23bf95da4cc2313478 +984b7ee4bd081ee06c484db6114c2ce0ba356988efb90f4c46ff85ed2865fb37f56a730166c29ef0ae3345a39cdeae7a +ae830f908ea60276c6c949fb8813e2386cf8d1df26dcf8206aa8c849e4467243e074471380ed433465dc8925c138ea4c +874c1df98d45b510b4f22feff46a7e8ed22cfc3fad2ac4094b53b9e6477c8dfc604976ca3cee16c07906dece471aa6c6 +a603eb60d4c0fb90fa000d2913689126849c0261e6a8649218270e22a994902965a4e7f8c9462447259495fe17296093 +a7c73d759a8ad5e3a64c6d050740d444e8d6b6c9ade6fb31cb660fa93dc4a79091230baccb51c888da05c28cb26f6f3f +a4411b79b6a85c79ea173bd9c23d49d19e736475f3d7d53213c5349ebb94a266d510d12ba52b2ac7a62deaaaec7339b8 +943b84f8bbcee53b06266b5c4cd24d649d972593837fe82b0bf5d5e1bbc1a2bf148e1426c366d7c39ab566b10224cadc +8300012096a8b4cefecc080054bf3ceb0918162ba263c6848860423407796b5eb517170c0bad8e4905ac69a383055a21 +8244a1e3ad41908c6f037e2f8db052e81f281646141334829f36c707f307448b9ab79a7f382a1e8d86f877c90b59271c +8eca1b74687802ecc36a5d39e4516a9dee3de61a2047252d9ed737b49e0090c386e9d792ac004c96337681c7f29a16ad +b70fa47535f0524835039a20036c61e77f66146ad79d3d339214d8744742db41ceeb577c829d000011aeafbb12e09579 +84b3abbce48689f3adbb99889c7fd1f3e15ab455d477e34f5151c5c1c358ed77a5b6a581879f7e0f1f34106e0792e547 +ab45ecb58c0ef0dbce3d16afc6ac281e0d90ec48741ea96a141152647e98fcc87f3a3ff07ba81f3179118453ce123156 +90d231a145ba36a59087e259bbfc019fa369201fcfeaa4347d5fd0a22cd8a716e5a797f3cc357f2779edb08f3b666169 +a4f6074d23c6c97e00130bc05f25213ca4fa76c69ca1ace9dece904a2bdd9d987661f5d55023b50028c444af47ff7a08 +933af884939ad0241f3f1f8e8be65f91d77ac0fb234e1134d92713b7cfb927f1933f164aec39177daa13b39c1370fac8 +80d1db6933ce72091332ae47dc691acb2a9038f1239327b26d08ea9d40aa8f2e44410bbda64f2842a398cbe8f74f770f +a7a08605be2241ccc00151b00b3196d9c0717c4150909a2e9cd05538781231762b6cc6994bebbd4cddae7164d048e7b2 +96db0d839765a8fdbbac03430fa800519e11e06c9b402039e9ae8b6503840c7ecac44123df37e3d220ac03e77612f4e4 +96d70f8e9acd5a3151a8a9100ad94f16c289a31d61df681c23b17f21749c9062622d0a90f6d12c52397b609c6e997f76 +8cf8e22273f7459396ff674749ab7e24c94fe8ab36d45d8235e83be98d556f2b8668ba3a4ec1cb98fac3c0925335c295 +97b7e796a822262abc1a1f5a54cb72a1ea12c6c5824ac34cd1310be02d858a3c3aa56a80f340439b60d100e59c25097d +a48208328b08769737aa1a30482563a4a052aea736539eceab148fa6653a80cb6a80542e8b453f1f92a33d0480c20961 +b612184941413fd6c85ff6aa517b58303b9938958aa85a85911e53ed308778624d77eadb27ccf970573e25d3dfd83df7 +b3717068011648c7d03bbd1e2fc9521a86d2c3ae69113d732c2468880a3b932ebec93596957026477b02842ed71a331b +a0ad363e1352dcf035b03830fef4e27d5fd6481d29d5e8c9d51e851e3862d63cdcbaf8e330d61c1b90886921dac2c6fd +8db409fdacfa4bfdaf01cc87c8e97b53ca3a6e3a526d794eaad1c2023f3df4b888f1bf19fee9a990fe6d5c7c3063f30c +b34d6975310ab15938b75ef15020a165fc849949065d32d912554b51ffa1d3f428a6d1a396cb9329367670391de33842 +9117285e9e6762853fc074b8a92b3923864de2c88c13cea7bab574aaf8cdd324843455d2c3f83c00f91f27c7ecc5592a +b4b2e8f190ea0b60819894710c866bf8578dd1b231ae701d430797cc7ede6e216e8ca6a304f3af9484061563645bf2ab +8c493c6853ab135d96a464815dd06cad8b3e8b163849cdefc23d1f20211685753b3d3e147be43e61e92e35d35a0a0697 +9864d7880f778c42d33cf102c425e380d999d55a975a29c2774cad920dfddb80087a446c4f32ed9a6ab5f22ec6f82af0 +90f67fe26f11ca13e0c72b2c2798c0d0569ed6bc4ce5bbaf517c096e7296d5dd5685a25012f6c6d579af5b4f5d400b37 +a228872348966f26e28a962af32e8fa7388d04bc07cfc0224a12be10757ac7ab16a3387c0b8318fcb0c67384b0e8c1a4 +a9d9d64bba3c03b51acf70aeb746a2712ddafe3b3667ae3c25622df377c2b5504e7ab598263bec835ab972283c9a168b +932128971c9d333f32939a1b46c4f7cf7e9d8417bd08dc5bd4573ccbd6ec5b460ac8880fb7f142f7ef8a40eef76d0c6d +964115e7838f2f197d6f09c06fbb2301d6e27c0ecdf208350cf3b36c748436dac50f47f9f9ac651c09ab7ad7221c7e43 +a5941f619e5f55a9cf6e7f1499b1f1bcddcc7cf5e274efedaaad73a75bc71b1fc5c29cd903f6c69dc9a366a6933ca9d1 +a154bf5eaec096029e5fe7c8bf6c695ae51ace356bb1ad234747776c7e1b406dee2d58864c3f4af84ed69f310974125e +b504e6209d48b0338ab1e4bdab663bac343bb6e0433466b70e49dc4464c1ec05f4a98111fd4450393607510ae467c915 +813411918ea79bdde295393284dc378b9bdc6cfcb34678b9733ea8c041ac9a32c1e7906e814887469f2c1e39287e80f8 +8be0369f94e4d72c561e6edb891755368660208853988647c55a8eed60275f2dd6ee27db976de6ecf54ac5c66aaf0ae6 +a7e2701e55b1e7ea9294994c8ad1c080db06a6fc8710cd0c9f804195dce2a97661c566089c80652f27b39018f774f85e +956b537703133b6ddf620d873eac67af058805a8cc4beb70f9c16c6787bf3cc9765e430d57a84a4c3c9fbdd11a007257 +835ae5b3bb3ee5e52e048626e3ddaa49e28a65cb94b7ecdc2e272ff603b7058f1f90b4c75b4b9558f23851f1a5547a35 +85d67c371d1bf6dc72cca7887fa7c886ce988b5d77dc176d767be3205e80f6af2204d6530f7060b1f65d360a0eaeff30 +a84a6647a10fcef8353769ef5f55a701c53870054691a6e9d7e748cbe417b3b41dbb881bae67adc12cb6596c0d8be376 +87ffe271fc0964cb225551c7a61008d8bcb8b3d3942970dbcc2b9f4f9045a767971880368ea254e2038a3a0b94ecf236 +964bb721c51d43ee7dd67c1a2b7dd2cc672ce8fad78c22dcddb43e6aab48d9a4a7dc595d702aa54a6fb0ffabf01f2780 +a89b3f84bb7dcbe3741749776f5b78a269f6b1bebb8e95d3cc80b834fd2177c6be058d16cacfd0d5e1e35e85cde8b811 +b4314538e003a1587b5592ff07355ea03239f17e75c49d51f32babe8e048b90b046a73357bcb9ce382d3e8fbe2f8e68b +86daf4bf201ae5537b5d4f4d734ed2934b9cf74de30513e3280402078f1787871b6973aa60f75858bdf696f19935a0e2 +b1adf5d4f83f089dc4f5dae9dbd215322fa98c964e2eaa409bf8ca3fa5c627880a014ed209492c3894b3df1c117236c4 +b508d52382c5bac5749bc8c89f70c650bb2ed3ef9dc99619468c387c1b6c9ff530a906dfa393f78f34c4f2f31478508a +a8349a5865cb1f191bebb845dfbc25c747681d769dbffd40d8cedf9c9a62fa2cbc14b64bb6121120dab4e24bef8e6b37 +af0500d4af99c83db8890a25f0be1de267a382ec5e9835e2f3503e1bac9412acf9ff83a7b9385708ef8187a38a37bc77 +b76d57a1c1f85b8a8e1722a47057b4c572800957a6b48882d1fc21309c2e45f648a8db0fcff760d1dbc7732cf37c009b +b93c996cec0d3714667b5a5a5f7c05a7dc00bbc9f95ac8e310626b9e41ae4cc5707fac3e5bd86e1e1f2f6d9627b0da94 +93216fdb864217b4c761090a0921cf8d42649ab7c4da1e009ec5450432564cb5a06cb6e8678579202d3985bd9e941cef +8b8be41105186a339987ae3a5f075fbc91f34b9984d222dfed0f0f85d2f684b56a56ab5dc812a411570491743d6c8b18 +959b72782a6b2469e77fe4d492674cc51db148119b0671bd5d1765715f49fa8a87e907646671161586e84979ef16d631 +86b7fc72fb7e7904ea71d5e66ba0d5d898ace7850985c8cc4a1c4902c5bf94351d23ce62eed45e24321fb02adfa49fc8 +a2f244e7c9aa272cb0d067d81d25e5a3045b80b5a520b49fd5996ece267a7f1bea42e53147bbf153d9af215ea605fc9e +81aa2efa5520eebc894ce909ba5ce3250f2d96baa5f4f186a0637a1eea0080dd3a96c2f9fadf92262c1c5566ddb79bab +b607dd110cfe510d087bcff9a18480ba2912662256d0ab7b1d8120b22db4ad036b2266f46152754664c4e08d0fc583f6 +8f588d5f4837e41312744caac5eee9ddc3ad7085871041694f0b5813edf83dc13af7970f7c9b6d234a886e07fa676a04 +924921b903207783b31016cbec4e6c99e70f5244e775755c90d03a8b769738be3ba61577aca70f706a9c2b80040c9485 +ae0a42a222f1a71cd0d3c69ffb2f04c13e1940cce8efabe032629f650be3ceed6abb79651dbb81cb39a33286eb517639 +a07d7d76460f31f5f0e32e40a5ea908d9d2aebf111ac4fadee67ef6540b916733c35a777dcdc05f6417726ca1f2d57dd +88d7f8a31f8c99794291847d28745e5d0b5d3b9684ca4170b686ffbb5bb521a3ef6746c3c8db22e4250a0cdff7939d96 +849573071fd98c020dc9a8622a9eff221cb9f889bde259e7127a8886b73bef7ad430b87750915658918dcfb6b7b4d8d3 +b12d59f732fa47fad175d6263734da8db89230fd340a46ad1cdee51e577041a5c80bf24cd195593e637daf1a66ef5a98 +abbcfb8a4a6d5e269ee1ac5e277df84416c73ca55ec88317f73608201af25af0cb65b943c54684a5651df3a26e3daca2 +ab157f589bdbaf067a6a7ba7513df0492933855d39f3a081196cf2352e0ddc0162d476c433320366e3df601e0556278d +a86c0619b92e5ae4f7daa876a2abc5ba189156afc2fa05eef464dfa342ba37fc670d0dc308ad3822fcb461ab001bac30 +a3f292946476cfe8d5e544a5325439a00e0165a5f9bf3bb6a53f477baeac7697cc0377745536681aa116f326ce911390 +8aecbbfd442a6a0f01c1c09db5d9d50213eb6f1ff6fab674cde3da06a4edff3ed317e804f78300c22ef70c336123e05d +834ed4b58211fcd647d7bf7c0a3ba9085184c5c856b085e8a0fcd5215c661ef43d36f3f0f6329a9f1370501b4e73b6e4 +a114ea5ad2b402a0de6105e5730907f2f1e458d28ae35144cf49836e0ad21325fe3e755cfb67984ae0a32e65402aad1e +a005f12bed97d71cee288b59afe9affb4d256888727343944a99913980df2c963fe02f218e6ea992f88db693a4498066 +a010f286ab06b966e3b91ff8f1bdbe2fe9ab41a27bc392d5787aa02a46e5080e58c62c7d907818caae9f6a8b8123e381 +857bd6df2ddef04dbc7c4f923e0b1696d3016c8bfed07fdfa28a3a3bd62d89b0f9df49aae81cbb6883d5e7b4fadae280 +b3927030da445bc4756ac7230a5d87412a4f7510581fb422212ce2e8cf49689aca7ba71678743af06d4de4914c5aa4a0 +b86403182c98fcce558d995f86752af316b3b2d53ba32075f71c7da2596747b7284c34a1a87de604fcc71e7e117a8add +98dd19b5527733041689b2a4568edaf6aa0fe1a3dd800c290cda157b171e053648a5772c5d3d4c80e5a795bc49adf12e +88a3c227bb7c9bff383f9ad3f7762245939a718ab85ae6e5e13180b12bf724d42054d3852b421c1cd1b3670baddecb63 +b3cfd9ad66b52bbe57b5fff0fad723434d23761409b92c4893124a574acc1e6b1e14b4ec507661551cbbe05e16db362e +923e1bb482cf421dd77801f9780f49c3672b88508a389b94015fd907888dc647ee9ea8ec8d97131d235d066daf1f42b7 +8d5e16240f04f92aa948181d421006bdbc7b215648fb6554193224d00cf337ebbb958f7548cf01b4d828acffb9fbc452 +8b2b8f18ad0559746f6cda3acca294a1467fb1a3bc6b6371bc3a61a3bfe59418934fa8706f78b56005d85d9cb7f90454 +a9316e2a94d6e31426d2ae7312878ba6baaac40f43e2b8a2fa3ab5a774c6918551554b2dbb23dc82f70ba3e0f60b5b0d +9593116d92cf06b8cd6905a2ce569ee6e69a506c897911f43ae80fc66c4914da209fc9347962034eebbc6e3e0fe59517 +887d89d2b2d3c82b30e8f0acf15f0335532bd598b1861755498610cb2dd41ff5376b2a0bb757cb477add0ce8cfe7a9fc +b514cfe17875ecb790ad055271cc240ea4bda39b6cfa6a212908849c0875cb10c3a07826550b24c4b94ea68c6bb9e614 +a563d5187966d1257d2ed71d53c945308f709bcc98e3b13a2a07a1933dc17bcb34b30796bd68c156d91811fbd49da2cb +a7195ccc53b58e65d1088868aeeb9ee208103e8197ad4c317235bb2d0ad3dc56cb7d9a7186416e0b23c226078095d44c +a838e7a368e75b73b5c50fbfedde3481d82c977c3d5a95892ac1b1a3ea6234b3344ad9d9544b5a532ccdef166e861011 +9468ed6942e6b117d76d12d3a36138f5e5fb46e3b87cf6bb830c9b67d73e8176a1511780f55570f52d8cdb51dcf38e8c +8d2fc1899bc3483a77298de0e033085b195caf0e91c8be209fd4f27b60029cbe1f9a801fbd0458b4a686609762108560 +8f4e44f8ca752a56aa96f3602e9234ad905ad9582111daf96a8c4d6f203bf3948f7ce467c555360ad58376ee8effd2ba +8fb88640b656e8f1c7c966c729eb2ba5ccf780c49873f8b873c6971840db7d986bdf1332ba80f8a0bb4b4ee7401468fa +b72aa3235868186913fb5f1d324e748cd3ce1a17d3d6e6ea7639a5076430fe0b08841c95feb19bb94181fe59c483a9eb +b8b102690ebb94fc4148742e7e3fd00f807b745b02cbe92cd92992c9143b6db7bb23a70da64a8b2233e4a6e572fc2054 +8c9ae291f6cd744e2c6afe0719a7fc3e18d79307f781921fb848a0bf222e233879c1eca8236b4b1be217f9440859b6ce +a658ede47e14b3aad789e07f5374402f60e9cacb56b1b57a7c6044ca2418b82c98874e5c8c461898ebd69e38fecd5770 +89c0cb423580e333923eb66bda690f5aca6ec6cba2f92850e54afd882ba608465a7dbb5aa077cd0ca65d9d00909348ab +aed8e28d98d5508bd3818804cf20d296fe050b023db2ed32306f19a7a3f51c7aaafed9d0847a3d2cd5ba5b4dabbc5401 +96a0fcd6235f87568d24fb57269a94402c23d4aa5602572ad361f3f915a5f01be4e6945d576d51be0d37c24b8b0f3d72 +935d0c69edd5dfa8ed07c49661b3e725b50588f814eb38ea31bcc1d36b262fae40d038a90feff42329930f8310348a50 +900518288aa8ea824c7042f76710f2ea358c8bb7657f518a6e13de9123be891fa847c61569035df64605a459dad2ecc8 +947d743a570e84831b4fb5e786024bd752630429d0673bf12028eb4642beb452e133214aff1cfa578a8856c5ebcb1758 +a787266f34d48c13a01b44e02f34a0369c36f7ec0aae3ec92d27a5f4a15b3f7be9b30b8d9dd1217d4eeedff5fd71b2e5 +a24b797214707ccc9e7a7153e94521900c01a1acd7359d4c74b343bfa11ea2cdf96f149802f4669312cd58d5ab159c93 +97f5ee9c743b6845f15c7f0951221468b40e1edaef06328653a0882793f91e8146c26ac76dd613038c5fdcf5448e2948 +80abd843693aed1949b4ea93e0188e281334163a1de150c080e56ca1f655c53eb4e5d65a67bc3fc546ed4445a3c71d00 +908e499eb3d44836808dacff2f6815f883aeced9460913cf8f2fbbb8fe8f5428c6fc9875f60b9996445a032fd514c70f +ae1828ef674730066dc83da8d4dd5fa76fc6eb6fa2f9d91e3a6d03a9e61d7c3a74619f4483fe14cddf31941e5f65420a +a9f4dbe658cd213d77642e4d11385a8f432245b098fccd23587d7b168dbeebe1cca4f37ee8d1725adb0d60af85f8c12f +93e20ee8a314b7772b2439be9d15d0bf30cd612719b64aa2b4c3db48e6df46cea0a22db08ca65a36299a48d547e826a7 +a8746a3e24b08dffa57ae78e53825a9ddbbe12af6e675269d48bff4720babdc24f907fde5f1880a6b31c5d5a51fbb00e +b5e94dfab3c2f5d3aea74a098546aa6a465aa1e3f5989377d0759d1899babf543ad688bb84811d3e891c8713c45886c5 +a3929bada828bd0a72cda8417b0d057ecb2ddd8454086de235540a756e8032f2f47f52001eb1d7b1355339a128f0a53b +b684231711a1612866af1f0b7a9a185a3f8a9dac8bde75c101f3a1022947ceddc472beb95db9d9d42d9f6ccef315edbc +af7809309edbb8eb61ef9e4b62f02a474c04c7c1ffa89543d8c6bf2e4c3d3e5ecbd39ec2fc1a4943a3949b8a09d315a6 +b6f6e224247d9528ef0da4ad9700bee6e040bbf63e4d4c4b5989d0b29a0c17f7b003c60f74332fefa3c8ddbd83cd95c1 +adbcec190a6ac2ddd7c59c6933e5b4e8507ce5fd4e230effc0bd0892fc00e6ac1369a2115f3398dfc074987b3b005c77 +8a735b1bd7f2246d3fa1b729aecf2b1df8e8c3f86220a3a265c23444bdf540d9d6fe9b18ed8e6211fad2e1f25d23dd57 +96b1bf31f46766738c0c687af3893d098d4b798237524cb2c867ed3671775651d5852da6803d0ea7356a6546aa9b33f2 +8036e4c2b4576c9dcf98b810b5739051de4b5dde1e3e734a8e84ab52bc043e2e246a7f6046b07a9a95d8523ec5f7b851 +8a4f4c32ee2203618af3bb603bf10245be0f57f1cfec71037d327fa11c1283b833819cb83b6b522252c39de3ce599fa5 +ad06ed0742c9838e3abaaffdb0ac0a64bad85b058b5be150e4d97d0346ed64fd6e761018d51d4498599669e25a6e3148 +8d91cb427db262b6f912c693db3d0939b5df16bf7d2ab6a7e1bc47f5384371747db89c161b78ff9587259fdb3a49ad91 +ae0a3f84b5acb54729bcd7ef0fbfdcf9ed52da595636777897268d66db3de3f16a9cf237c9f8f6028412d37f73f2dfad +8f774109272dc387de0ca26f434e26bc5584754e71413e35fa4d517ee0f6e845b83d4f503f777fe31c9ec05796b3b4bc +a8670e0db2c537ad387cf8d75c6e42724fae0f16eca8b34018a59a6d539d3c0581e1066053a2ec8a5280ffabad2ca51f +ac4929ed4ecad8124f2a2a482ec72e0ef86d6a4c64ac330dab25d61d1a71e1ee1009d196586ce46293355146086cabba +845d222cb018207976cc2975a9aa3543e46c861486136d57952494eb18029a1ebb0d08b6d7c67c0f37ee82a5c754f26f +b99fa4a29090eac44299f0e4b5a1582eb89b26ed2d4988b36338b9f073851d024b4201cd39a2b176d324f12903c38bee +9138823bc45640b8f77a6464c171af2fe1700bdc2b7b88f4d66b1370b3eafe12f5fbb7b528a7e1d55d9a70ca2f9fc8e6 +8ac387dc4cf52bc48a240f2965ab2531ae3b518d4d1f99c0f520a3d6eb3d5123a35ef96bed8fa71ee2f46793fa5b33b3 +864adec6339d4c2ba2525621fceabd4c455902f6f690f31a26e55413e0722e5711c509dc47ce0bcc27bbdc7651768d2d +a0a52edb72268a15201a968dabc26a22909620bda824bd548fb8c26cc848f704166ed730d958f0173bd3b0a672f367bd +949e445b0459983abd399571a1a7150aab3dd79f4b52a1cd5d733e436c71c1d4b74287c6b0ce6cc90c6711ba4c541586 +858966355dac11369e3b6552f2b381665181693d5a32e596984da3314021710b25a37d8c548b08700eea13d86cb22f21 +974bcbb8d38c5e6518745cc03ad436e585b61f31d705e7e2e5085da9655d768ac4d800904f892c3dab65d6223e3f1fd6 +8092b6506b01308bf6187fde5ebd4fa7448c9a640961ba231be22ac5fa2c7635ef01e8b357722c7695d09b723101ea2a +a5b8ef360bf28533ee17d8cd131fff661d265f609db49599085c0c7d83b0af409a1b5c28e3a5e5d7f8459a368aa121e8 +b031b6d5e3ceab0f0c93314b3b675f55cf18cbc86f70444af266fe39cb22fd7dad75d8c84e07f1c1bfa2cb8283e1361a +93ad489e4f74658320c1cceed0137c023d3001a2c930ed87e6a21dbf02f2eb6ad1c1d8bcb3739c85dcfbecb040928707 +b15e4ec2cdab0d34aec8d6c50338812eb6ecd588cf123a3e9d22a7ca23b5a98662af18289f09e6cdd85a39a2863c945c +b304f71a9717cf40c22073f942618b44bf27cd5e2ed4a386ad45d75b0fcb5a8dafd35158211eaf639495c6f1a651cedb +b82d78d3eaaa7c5101b7a5aae02bd4f002cd5802d18c3abcda0dd53b036661c6d3c8b79e0abe591eab90b6fdc5fef5e3 +abbd1884243a35578b80914a5084449c237ee4e4660c279d1073a4d4217d1b55c6b7e9c087dfd08d94ac1416273d8d07 +92f4b61c62502745e3e198ec29bca2e18696c69dcb914d1f3a73f4998d012b90caf99df46e9bb59942e43cce377fe8fd +906e79df98185820c8208844e1ba6bd86cb96965814b01310bd62f22cbec9b5d379b2ef16772d6fc45a421b60cfd68fe +a0eae2784ef596e2eb270dd40c48d6c508e4394c7d6d08d4cc1b56fde42b604d10ba752b3a80f2c4a737e080ef51b44f +94c084985e276dc249b09029e49a4ef8a369cd1737b51c1772fbb458d61e3fe120d0f517976eba8ffa5711ba93e46976 +83619a0157eff3f480ab91d1d6225fead74c96a6fd685333f1e8e4d746f6273e226bad14232f1d1168a274e889f202f1 +a724fe6a83d05dbbf9bb3f626e96db2c10d6d5c650c0a909415fbda9b5711c8b26e377201fb9ce82e94fa2ab0bf99351 +a8a10c1b91a3a1fa2d7fd1f78a141191987270b13004600601d0f1f357042891010717319489f681aa8a1da79f7f00d5 +a398a2e95b944940b1f8a8e5d697c50e7aa03994a8a640dfad4ea65cfb199a4d97861a3ec62d1c7b2b8d6e26488ca909 +a2eedfe5452513b2a938fffd560798ef81379c5a5032d5b0da7b3bb812addbaad51f564c15d9acbbfc59bb7eddd0b798 +ab31c572f6f145a53e13b962f11320a1f4d411739c86c88989f8f21ab629639905b3eedb0628067942b0dc1814b678ca +ad032736dd0e25652d3566f6763b48b34ea1507922ed162890cd050b1125ec03b6d41d34fccba36ec90336f7cdf788ed +83028a558a5847293147c483b74173eca28578186137df220df747fccd7d769528d7277336ea03c5d9cdd0bc5ae3d666 +ab5d182cd1181de8e14d3ef615580217c165e470b7a094a276b78a3003089123db75c6e1650bf57d23e587c587cd7472 +a4793e089fbdb1597654f43b4f7e02d843d4ab99ee54099c3d9f0bd5c0c5657c90bb076379a055b00c01b12843415251 +98bdc52ee062035356fb2b5c3b41673198ddc60b2d1e546cb44e3bb36094ef3c9cf2e12bbc890feb7d9b15925439d1ea +a4f90cca6f48024a0341bd231797b03693b34e23d3e5b712eb24aba37a27827319b2c16188f97c0636a0c115381dc659 +8888e6c2e4a574d04ba5f4264e77abc24ccc195f1a7e3194169b8a2ceded493740c52db4f9833b3dbf4d67a3c5b252cb +83dc4e302b8b0a76dc0292366520b7d246d73c6aebe1bdd16a02f645c082197bcff24a4369deda60336172cefbcf09af +a4eb2741699febfeb793914da3054337cc05c6fa00d740e5f97cb749ae16802c6256c9d4f0f7297dcdbb8b9f22fc0afa +8b65557d5be273d1cb992a25cfce40d460c3f288d5cb0a54bdef25cbd17cdea5c32ec966e493addf5a74fd8e95b23e63 +97c6577e76c73837bcb398b947cb4d3323d511141e0ddd0b456f59fbb1e8f920a5c20d7827a24309145efddee786140f +abcc0849ffe2a6a72157de907907b0a52deece04cf8317bee6fe1d999444b96e461eac95b6afde3d4fe530344086a625 +9385c0115cb826a49df1917556efa47b5b5e4022b6a0d2082053d498ec9681da904ecf375368bb4e385833116ea61414 +8b868c1841f0cdc175c90a81e610b0652c181db06731f5c8e72f8fafa0191620742e61a00db8215a991d60567b6a81ca +a8df15406f31b8fcf81f8ff98c01f3df73bf9ec84544ddec396bdf7fafa6fe084b3237bf7ef08ad43b26517de8c3cd26 +a9943d21e35464ce54d4cc8b135731265a5d82f9ccf66133effa460ffdb443cdb694a25320506923eede88d972241bf2 +a1378ee107dd7a3abcf269fd828887c288363e9b9ca2711377f2e96d2ed5e7c5ec8d3f1da995a3dcbedf1752d9c088fc +8a230856f9227b834c75bdebc1a57c7298a8351874bf39805c3e0255d6fd0e846f7ad49709b65ec1fd1a309331a83935 +877bcf42549d42610e1780e721f5800972b51ba3b45c95c12b34cb35eeaf7eac8fa752edd7b342411820cf9093fea003 +84c7a0b63842e50905624f1d2662506b16d1f3ea201877dfc76c79181c338b498eceb7cad24c2142c08919120e62f915 +8e18b1bd04b1d65f6ed349b5d33a26fe349219043ead0e350b50ae7a65d6ff5f985dd9d318d3b807d29faa1a7de4fe42 +8ea7b5a7503e1f0b3c3cd01f8e50207044b0a9c50ed1697794048bbe8efd6659e65134d172fb22f95439e1644f662e23 +b1954a2818cad1dad6d343a7b23afa9aa8ad4463edc4eb51e26e087c2010927535020d045d97d44086d76acdb5818cbf +a5271ea85d0d21fa1ff59b027cf88847c0f999bbf578599083ff789a9b5228bc161e1c81deb97e74db1a82a0afd61c50 +aa2fa4c05af3387e2c799315781d1910f69977ec1cfea57a25f1a37c63c4daaa3f0ecd400884a1673e17dd5300853bcf +b1cd2a74ca0b8e6090da29787aef9b037b03b96607983a308b790133bd21297b21ca4e2edec890874096dbf54e9d04c3 +801931607ec66a81272feaa984f0b949ad12d75ecf324ba96627bd4dc5ddead8ebf088f78e836b6587c2b6c0b3366b6c +95d79504710bdf0ad9b9c3da79068c30665818c2f0cdbba02cc0a5e46e29d596032ac984441b429bd62e34535c8d55b0 +9857d41e25e67876510ff8dadf0162019590f902da1897da0ef6fc8556e3c98961edb1eb3a3a5c000f6c494413ded15e +8740c9ffe6bd179c19a400137c3bd3a593b85bd4c264e26b4dfb9e2e17ac73e5b52dfacc1dcb4033cfc0cd04785f4363 +977f98f29d948b4097a4abdf9345f4c1fb0aa94ba0c6bf6faa13b76f3a3efc8f688e1fe96099b71b3e1c05041118c8d1 +a364422b1239126e3e8d7b84953ce2181f9856319b0a29fcab81e17ac27d35798088859c1cfc9fc12b2dbbf54d4f70b3 +a0f6ba637f0db7a48e07439bb92ddb20d590ce9e2ed5bab08d73aa22d82c32a9a370fe934cbe9c08aeb84b11adcf2e0e +a2c548641bd5b677c7748327cca598a98a03a031945276be6d5c4357b6d04f8f40dd1c942ee6ec8499d56a1290ac134d +9863e9cc5fbcdbd105a41d9778d7c402686bfd2d81d9ed107b4fda15e728871c38647529693306855bee33a00d257a7e +a54173bf47b976290c88fd41f99300135de222f1f76293757a438450880e6f13dbde3d5fe7afc687bdfbcfc4fbc1fc47 +b8db413917c60907b73a997b5ab42939abd05552c56a13525e3253eb72b83f0d5cc52b695968a10005c2e2fe13290e61 +a1f8388ef21697c94ba90b1a1c157f0dc138e502379e6fc5dc47890d284563e5db7716266e1b91927e5adf3cde4c0a72 +9949013a59d890eb358eab12e623b2b5edb1acbee238dfad8b7253102abc6173922e188d5b89ec405aa377be8be5f16d +a00fdb7710db992041f6ddb3c00099e1ce311dea43c252c58f560c0d499983a89de67803a8e57baa01ee9d0ee6fa1e44 +a8b1bcbed1951c9cdb974b61078412881b830b48cd6b384db0c00fa68bcc3f4312f8e56c892ea99d3511857ef79d3db9 +8f3ee78404edc08af23b1a28c2012cee0bdf3599a6cb4ea689fc47df4a765ef519191819a72562b91a0fbcdb896a937e +8155bbb7fa8d386848b0a87caae4da3dec1f3dade95c750a64a8e3555166ccc8799f638bd80ed116c74e3a995541587a +abfe30adbc0a6f1fd95c630ed5dac891b85384fa9331e86b83217f29dff0bd7cad19d328485715a7e3df9a19069d4d2f +89d0783e496ee8dbb695764b87fb04cee14d4e96c4ba613a19736971c577d312079048142c12ce5b32b21e4d491d281b +856b8dbc9c5d8f56b6bb7d909f339ca6da9a8787bba91f09130a025ab6d29b64dbf728ba6ed26e160a23c1cdb9bc037b +8a30dd2ea24491141047a7dfe1a4af217661c693edf70b534d52ca547625c7397a0d721e568d5b8398595856e80e9730 +ae7e1412feb68c5721922ed9279fb05549b7ef6812a4fd33dbbbd7effab756ab74634f195d0c072143c9f1fd0e1ee483 +b7ce970e06fa9832b82eef572f2902c263fda29fdce9676f575860aae20863046243558ede2c92343616be5184944844 +85ed0531f0e5c1a5d0bfe819d1aa29d6d5ff7f64ad8a0555560f84b72dee78e66931a594c72e1c01b36a877d48e017ca +b8595be631dc5b7ea55b7eb8f2982c74544b1e5befc4984803b1c69727eac0079558182f109e755df3fd64bee00fcaa5 +99e15a66e5b32468ef8813e106271df4f8ba43a57629162832835b8b89402eb32169f3d2c8de1eb40201ce10e346a025 +844c6f5070a8c73fdfb3ed78d1eddca1be31192797ad53d47f98b10b74cc47a325d2bc07f6ee46f05e26cf46a6433efb +974059da7f13da3694ad33f95829eb1e95f3f3bfc35ef5ef0247547d3d8ee919926c3bd473ab8b877ff4faa07fcc8580 +b6f025aecc5698f6243cc531782b760f946efebe0c79b9a09fe99de1da9986d94fa0057003d0f3631c39783e6d84c7d5 +b0c5358bc9c6dfe181c5fdf853b16149536fbb70f82c3b00db8d854aefe4db26f87332c6117f017386af8b40288d08f9 +a3106be5e52b63119040b167ff9874e2670bd059b924b9817c78199317deb5905ae7bff24a8ff170de54a02c34ff40a4 +ad846eb8953a41c37bcd80ad543955942a47953cbc8fb4d766eac5307892d34e17e5549dc14467724205255bc14e9b39 +b16607e7f0f9d3636e659e907af4a086ad4731488f5703f0917c4ce71a696072a14a067db71a3d103530920e1ec50c16 +8ed820e27116e60c412c608582e9bb262eaaf197197c9b7df6d62b21a28b26d49ea6c8bb77dfde821869d9b58025f939 +97bc25201d98cde389dd5c0c223a6f844393b08f75d3b63326343073e467ac23aacef630ddc68545ea874299ba4a3b4f +b73c9695ad2eefd6cc989a251c433fab7d431f5e19f11d415a901762717d1004bb61e0cc4497af5a8abf2d567e59fef4 +adaabe331eea932533a7cc0cf642e2a5e9d60bbc92dd2924d9b429571cbf0d62d32c207b346607a40643c6909b8727e2 +a7b1bbfe2a5e9e8950c7cb4daab44a40c3ffab01dc012ed7fe445f4af47fa56d774a618fafe332ab99cac4dfb5cf4794 +b4a3c454dcd5af850212e8b9ba5fe5c0d958d6b1cabbf6c6cfe3ccbc4d4c943309c18b047256867daf359006a23f3667 +a5c0b32f6cef993834c1381ec57ad1b6f26ae7a8190dd26af0116e73dadc53bb0eeb1911419d609b79ce98b51fdc33bc +ac2f52de3ecf4c437c06c91f35f7ac7d171121d0b16d294a317897918679f3b9db1cef3dd0f43adb6b89fe3030728415 +94722ae6d328b1f8feaf6f0f78804e9b0219de85d6f14e8626c2845681841b2261d3e6a2c5b124086b7931bf89e26b46 +a841a0602385d17afabca3a1bb6039167d75e5ec870fea60cfcaec4863039b4d745f1a008b40ec07bca4e42cb73f0d21 +8c355f0a1886ffced584b4a002607e58ff3f130e9de827e36d38e57cb618c0cb0b2d2dea2966c461cb3a3887ede9aef1 +a6a9817b0fc2fd1786f5ba1a7b3d8595310987fb8d62f50a752c6bb0b2a95b67d03a4adfd13e10aa6190a280b7ee9a67 +a1d2e552581ecbafeaef08e389eaa0b600a139d446e7d0648ac5db8bbbf3c438d59497e3a2874fc692b4924b87ff2f83 +a1b271c55389f25639fe043e831e2c33a8ba045e07683d1468c6edd81fedb91684e4869becfb164330451cfe699c31a8 +8c263426e7f7e52f299d57d047a09b5eeb893644b86f4d149535a5046afd655a36d9e3fdb35f3201c2ccac2323a9582e +b41c242a7f7880c714241a97d56cce658ee6bcb795aec057a7b7c358d65f809eb901e0d51256826727dc0dc1d1887045 +93001b9445813c82f692f94c0dc1e55298f609936b743cf7aae5ebfa86204f38833d3a73f7b67314be67c06a1de5682d +82087536dc5e78422ad631af6c64c8d44f981c195ddea07d5af9bb0e014cdc949c6fa6e42fce823e0087fdb329d50a34 +8e071861ceba2737792741c031f57e0294c4892684506b7c4a0fc8b2f9a0a6b0a5635de3d1e8716c34df0194d789ae86 +b471c997e1e11774bd053f15609d58838a74073a6c089a7a32c37dd3f933badf98c7e5833263f3e77bc0d156a62dd750 +8d2d8686fb065b61714414bb6878fff3f9e1e303c8e02350fd79e2a7f0555ded05557628152c00166ce71c62c4d2feaa +ae4c75274d21c02380730e91de2056c0262ffcecf0cbdb519f0bdb0b5a10ae2d4996b3dc4b3e16dbaea7f0c63d497fef +97140d819e8ca6330e589c6debdee77041c5a9cedb9b8cbd9c541a49207eeb7f6e6b1c7e736ec8ba6b3ab10f7fcd443a +af6659f31f820291a160be452e64d1293aa68b5074b4c066dac169b8d01d0179139504df867dc56e2a6120354fc1f5be +a5e5d8088a368024617bfde6b731bf9eee35fc362bed3f5dfdd399e23a2495f97f17728fec99ca945b3282d1858aa338 +a59cfc79d15dbdde51ab8e5129c97d3baba5a0a09272e6d2f3862370fdbaf90994e522e8bd99d6b14b3bb2e9e5545c6f +a30499b068083b28d6c7ddcc22f6b39b5ec84c8ee31c5630822c50ea736bb9dca41c265cffc6239f1c9ef2fd21476286 +88ffe103eca84bbe7d1e39a1aa599a5c7c9d5533204d5c4e085402a51441bb8efb8971efe936efbbfa05e5cb0d4b8017 +b202356fbf95a4d699154639e8cb03d02112c3e0128aab54d604645d8510a9ba98936028349b661672c3a4b36b9cb45d +8b89bb6574bf3524473cff1ff743abcf1406bd11fb0a72070ccd7d8fce9493b0069fb0c6655252a5164aee9e446ea772 +93247b1038fa7e26667ee6446561d4882dc808d1015daafb705935ddc3598bb1433182c756465960480f7b2de391649e +b027f94d3358cbb8b6c8c227300293a0dee57bf2fee190a456ad82ecfb6c32f8090afa783e2ab16f8139805e1fb69534 +a18bb1849b2f06c1d2214371031d41c76ffa803ee3aa60920d29dbf3db5fbfac2b7383d5d0080ba29ce25c7baa7c306b +827bf9fd647e238d5ac961c661e5bbf694b4c80b3af8079f94a2484cb8fba2c8cf60e472ebcd0b0024d98ae80ad2ff5a +838e891218c626a7f39b8fd546b013587408e8e366ecc636b54f97fa76f0a758bc1effa1d0f9b6b3bc1a7fcc505970a0 +836523b5e8902d6e430c6a12cff01e417d2bd7b402e03904034e3b39755dee540d382778c1abe851d840d318ebedce7f +850a77dda9ac6c217e2ef00bf386a1adec18b7f462f52801c4f541215690502a77ef7519b690e22fdf54dc2109e0ca38 +a8265c6ae7b29fc2bda6a2f99ced0c1945dd514b1c6ca19da84b5269514f48a4f7b2ccbab65c9107cfd5b30b26e5462f +ab3d02ee1f1267e8d9d8f27cc388e218f3af728f1de811242b10e01de83471a1c8f623e282da5a284d77884d9b8cde0e +831edaf4397e22871ea5ddee1e7036bab9cc72f8d955c7d8a97f5e783f40532edbbb444d0520fefcffeab75677864644 +80484487977e4877738744d67b9a35b6c96be579a9faa4a263e692295bb6e01f6e5a059181f3dd0278e2c3c24d10a451 +aae65a18f28c8812617c11ecf30ad525421f31fb389b8b52d7892415e805a133f46d1feca89923f8f5b8234bd233486a +b3a36fd78979e94288b4cefed82f043a7e24a4a8025479cc7eb39591e34603048a41ee606ee03c0b5781ebe26a424399 +b748b3fc0d1e12e876d626a1ba8ad6ad0c1f41ea89c3948e9f7d2666e90173eb9438027fadcd741d3ae0696bd13840f1 +acdd252d7c216c470683a140a808e011c4d5f1b4e91aeb947f099c717b6a3bad6651142cde988330827eb7d19d5fb25c +b9a25556a6ca35db1ed59a1ec6f23343eab207a3146e4fc3324136e411c8dba77efd567938c63a39c2f1c676b07d8cdb +a8db6aef8f5680d2bdb415d7bcaae11de1458678dcb8c90c441d5986c44f83a9e5855662d0c1aace999172d8628d8fe1 +af58147108e9909c3a9710cc186eab598682dca4bfd22481e040b8c000593ecb22c4ede4253ac9504e964dfa95a9b150 +8dd8bb70f1c9aec0fcc9478f24dfc9c3c36c0bf5ff7a67c017fa4dab2ec633fbd7bc9d8aa41ea63e2696971ed7e375f5 +aa98d600b22aff993a4d7a3ccabd314e1825b200cb598f6b797d7e4d6a76d89e34a4d156c06bddfc62f2ef9b4c809d1d +8a8fc960d6c51294b8205d1dabe430bef59bda69824fa5c3c3105bef22ac77c36d2d0f38ffc95ce63731de5544ccbeff +b6d1020efe01dc8032bd1b35e622325d7b9af9dcd5c9c87c48d7d6ebc58644454294c59b7f4b209204b5b1f899f473bf +8a750dc9fe4891f2dfe5759fb985939810e4cdc0b4e243ff324b6143f87676d8cb4bcb9dfb01b550801cedcaaa5349e2 +98c13142d3a9c5f8d452245c40c6dae4327dd958e0fda85255ea0f87e0bcbaa42a3a0bd50407ed2b23f9f6317a8a4bc5 +99f2b83d9ec4fc46085a6d2a70fd0345df10f4a724c1ba4dee082a1fde9e642e3091992ebf5f90a731abcb6ec11f6d9b +b218546ab2db565b2489ea4205b79daa19ef2acbf772ccaaa5e40150e67ea466090d07198444b48e7109939aa2319148 +84f9d1d868e4b55e535f1016558f1789df0daa0ead2d13153e02f715fe8049b1ce79f5bc1b0bbbb0b7e4dd3c04783f3f +80d870d212fbddfdda943e90d35a5a8aa0509a7a1e7f8909f2fcb09c51c3026be47cc7a22620a3063406872105b4f81a +b5b15138ff6551fac535d4bbce2ea6adc516b6b7734b4601c66ec029da2615e3119dc9ad6a937344acfd7b50e4a1a2ae +95d2f97652086e7ceb54e1d32692b1c867ffba23c4325740c7f10d369283d1b389e8afa0df967831ade55696931e7934 +8a5b580403e1a99cd208f707e8ce0d3f658c8280417683f69008d09cc74d835a85f7380f391b36ead9ac66d9eedd1cbe +a8b0c90bff34c86720637b5a2081f0f144cfe2205c1176cacd87d348609bc67af68aed72414dc9aa6f44a82c92c2a890 +865abbdd96c496892c165a8de0f9e73348bf24fce361d7a9048710178a3625881afb0006e9f5ee39124866b87904c904 +ace67bb994adef4b6f841cdf349195608030044562780a7e9b00b58a4ff117268a03ff01e5a3a9d9d7eff1dd01f5f4bf +b9371d59185b3d2d320d3fefeadb06ba2aa7d164352fb8dc37571509509fa214d736d244ac625a09a033a10d51611e2e +a8ef992771422dcf2d6d84386fde9fe5dba88bfded3dfcd14074ca04331b4fd53a7f316615cdfaf10ed932cbb424a153 +868cbc75f8f789ea45eded2768a1dac0763347e0d8e8028d316a21005f17be179d26d5965903e51b037f2f57fe41765d +b607111bcdfd05fa144aa0281b13ee736079ebbbf384d938a60e5e3579639ed8ef8eb9ca184868cdb220a8e130d4a952 +aca55702af5cae4cae65576769effd98858307a71b011841c563b97c2aa5aeb5c4f8645d254f631ed1582df3dbbf17da +b9b5cbace76246e80c20dfcc6f1e2c757a22ab53f7fd9ff8a1d309538b55174e55e557a13bf68f095ff6a4fa637ef21a +8571b0a96871f254e2397c9be495c76379faf347801cb946b94e63212d6a0da61c80e5d7bebbabcd6eaa7f1029172fe5 +902540326281e6dc9c20d9c4deaaf6fbbbcc3d1869bd0cf7f081c0525bea33df5cfa24ead61430fda47fb964fcc7994b +841af09279d3536a666fa072278950fabf27c59fc15f79bd52acb078675f8087f657929c97b4bc761cbade0ecb955541 +a1f958b147ddf80ab2c0746ba11685c4bae37eb25bfa0442e7e1078a00d5311d25499da30f6d168cb9302ea1f2e35091 +863d939381db37d5a5866964be3392a70be460f0353af799d6b3ed6307176972686bd378f8ad457435a4094d27e8dfb7 +835cd4d7f36eff553d17483eb6c041b14280beb82c7c69bca115929658455a1931212976c619bafb8179aed9940a8cc6 +8d0770e3cb8225e39c454a1fc76954118491b59d97193c72c174ecc7613051e5aed48a534016a8cf0795c524f771a010 +91aa4edb82f6f40db2b7bd4789cc08786f6996ebed3cb6f06248e4884bc949793f04a4c5ea6eefe77984b1cc2a45d699 +8fb494ca2449f659ff4838833507a55500a016be9293e76598bbae0a7cb5687e4693757c2b6d76e62bd6c7f19ed080bb +b59b104449a880a282c1dd6a3d8debb1d8814ef35aab5673c1e500ee4cb0e840fb23e05fa5a0af92509c26b97f098f90 +aca908e3bad65e854ae6be6c5db441a06bcd47f5abafdfa8f5a83c8cd3c6e08c33cab139c45887887a478338e19ceb9f +806f5d802040313a31964fc3eb0ee18ac91b348685bed93c13440984ee46f3d2da7194af18c63dea4196549129660a4e +ae4b2dca75c28d8f23b3ab760b19d839f39ff5a3112e33cb44cff22492604a63c382b88ec67be4b0266924dd438c3183 +99d1c29c6bd8bf384e79cd46e30b8f79f9cbc7d3bf980e9d6ffba048f0fc487cac45c364a8a44bb6027ad90721475482 +a16e861c1af76d35528c25bf804bfc41c4e1e91b2927d07d8e96bffe3a781b4934e9d131ecf173be9399800b8269efac +a253303234fb74f5829060cdcef1d98652441ab6db7344b1e470d195a95722675988048d840201c3b98e794b1e8b037c +905ac8a0ea9ce0eb373fb0f83dd4cbe20afb45b9d21ae307846fd4757d4d891b26a6711924e081e2b8151e14a496da18 +b485315791e775b9856cc5a820b10f1fa5028d5b92c2f0e003ba55134e1eddb3eb25f985f2611a2257acf3e7cfdfab5e +b6189c0458b9a043ebc500abc4d88083a3487b7ac47ed5e13ab2a41e0a1bee50d54a406063f92bc96959f19e822a89a7 +a30e15f995fd099a223fc6dc30dad4b8d40bee00caa2bc3223ba6d53cd717c4968a3e90c4618c711ed37cc4cd4c56cf3 +a1b1ed07fcc350bb12a09cd343768d208fc51a6b3486f0ece8f5a52f8a5810b4bc7ab75582ec0bc2770aed52f68eace5 +88aa739fbae4bece147ba51a863e45d5f7203dbc3138975dc5aef1c32656feb35f014d626e0d5b3d8b1a2bda6f547509 +ab570f3c8eabfca325b3a2ea775ef6b0c6e6138c39d53c2310329e8fb162869fde22b0e55688de9eb63d65c37598fca3 +89d274762c02158e27cb37052e296a78f2b643eb7f9ae409f8dac5c587d8b4d82be4ef7c79344a08ebec16ac4a895714 +99c411d2ad531e64f06e604d44c71c7c384424498ecd0a567d31ec380727fb605af76643d0d5513dd0a8d018076dd087 +80d0777fa9f79f4a0f0f937d6de277eec22b3507e2e398f44b16e11e40edf5feff55b3b07a69e95e7e3a1621add5ed58 +b2430a460783f44feb6e4e342106571ef81ad36e3ddd908ec719febeb7acaf4b833de34998f83a1dab8f0137a3744c11 +b8f38ccfc7279e1e30ad7cefc3ea146b0e2dff62430c50a5c72649a4f38f2bac2996124b03af2079d942b47b078cc4f8 +a178a450a62f30ec2832ac13bbc48789549c64fc9d607b766f6d7998558a0e2fad007ae0148fc5747189b713f654e6ba +98c5ede296f3016f6597f7ccc5f82c88fd38ed6dc3d6da3e4a916bfd7c4c95928722a1d02534fe89387c201d70aa6fd2 +a8cc5e98573705d396576e022b2ba2c3e7c7ece45cd8605cb534b511763682582299e91b4bb4100c967019d9f15bbfaf +848480ea7b7d9536e469da721236d932870b7bbee31ccf7ae31b4d98d91413f59b94a1e0d1786ee7342295aa3734969c +b88ea38f9ee432f49e09e4e013b19dff5a50b65453e17caf612155fff6622198f3cba43b2ea493a87e160935aaaf20a9 +949376934a61e0ef8894339c8913b5f3b228fa0ae5c532ad99b8d783b9e4451e4588541f223d87273c0e96c0020d5372 +96f90bb65ca6b476527d32c415814b9e09061648d34993f72f28fae7dc9c197e04ef979f804076d107bb218dfd9cb299 +a4402da95d9942c8f26617e02a7cef0ebc4b757fac72f222a7958e554c82cc216444de93f659e4a1d643b3e55a95d526 +81179cbc26a33f6d339b05ea3e1d6b9e1190bd44e94161ae36357b9cdf1e37d745d45c61735feed64371fe5384102366 +ad4dc22bdbd60e147fdac57d98166de37c727f090059cfc33e5ee6cf85e23c2643996b75cf1b37c63f3dc9d3c57ffa18 +8a9b1b93dc56e078ce3bb61c2b0088fd6c3e303ba6b943231cc79d4a8e8572f4109bbde5f5aa7333aae3287909cb0fe2 +8876ef583bc1513322457a4807d03381ba1f4d13e179260eaa3bddfede8df677b02b176c6c9f74c8e6eab0e5edee6de6 +b6c67e228bf190fbaeb2b7ec34d4717ce710829c3e4964f56ebb7e64dc85058c30be08030fa87cc94f1734c5206aef5f +a00cb53b804ee9e85ce12c0103f12450d977bc54a41195819973c8a06dcb3f46f2bf83c3102db62c92c57ab4dd1e9218 +a7675a64772eefddf8e94636fb7d1d28f277074327c02eea8fae88989de0c5f2dc1efed010f4992d57b5f59a0ab40d69 +8d42bb915e0bf6a62bcdf2d9330eca9b64f9ec36c21ae14bf1d9b0805e5e0228b8a5872be61be8133ad06f11cb77c363 +a5b134de0d76df71af3001f70e65c6d78bed571bc06bfddf40d0baad7ea2767608b1777b7ef4c836a8445949877eeb34 +aeadbc771eaa5de3a353229d33ed8c66e85efbd498e5be467709cb7ff70d3f1a7640002568b0940e3abd7b2da81d2821 +8c28da8e57a388007bd2620106f6226b011ee716a795c5d9f041c810edf9cf7345b2e2e7d06d8a6b6afa1ee01a5badc1 +8ed070626a4d39ffd952ddb177bc68fd35b325312e7c11694c99b691f92a8ea7734aeb96cf9cc73e05b3c1b1dcad6978 +ada83e18e4842f3d8871881d5dbc81aed88a1328298bfdc9e28275094bd88d71b02e7b8501c380fa8d93096cbc62f4fb +8befc3bec82dcf000a94603b4a35c1950ba5d00d4bed12661e4237afa75062aa5dcef8eac0b9803136c76d2dd424a689 +97c6f36c91ca5ca9230bfcbf109d813728b965a29b62e5f54c8e602d14a52ac38fa1270de8bfe1ab365426f3fc3654c7 +b01d192af3d8dbce2fe2fece231449e70eb9ac194ec98e758da11ca53294a0fa8c29b1d23a5d9064b938b259ea3b4fb5 +819a2c20646178f2f02865340db1c3c6ebc18f4e6559dd93aa604388796a34bd9fed28ad3ccc8afc57a5b60bb5c4e4ec +a9ffc877470afc169fecf9ec2dc33253b677371938b0c4ffa10f77bb80089afa2b4488437be90bb1bcf7586a6f4286e3 +b533051c7ce7107176bcb34ad49fdb41fac32d145854d2fe0a561c200dcf242da484156177e2c8f411c3fdf1559ecf83 +8fe2caff2e4241d353110a3618832f1443f7afe171fd14607009a4a0aa18509a4f1367b67913e1235ac19de15e732eb1 +84705c6370619403b9f498059f9869fdf5f188d9d9231a0cb67b1da2e8c906ead51b934286497293698bba269c48aa59 +899dddf312a37e3b10bdaaacc1789d71d710994b6ee2928ac982ad3fd8a4f6167672bc8bf3419412711c591afe801c28 +b2f7916d946b903ded57b9d57025386143410a41a139b183b70aeca09cf43f5089ead1450fce4e6eb4fba2c8f5c5bbe5 +8d5f742fe27a41623b5820914c5ca59f82246010fa974304204839880e5d0db8bc45ebab2ad19287f0de4ac6af25c09e +b93d4a1f6f73ac34da5ffbd2a4199cf1d51888bc930dc3e481b78806f454fcb700b4021af7525b108d49ebbbaa936309 +8606f8d9121512e0217a70249937e5c7f35fbfe019f02248b035fa3a87d607bc23ae66d0443e26a4324f1f8e57fd6a25 +b21312cdec9c2c30dd7e06e9d3151f3c1aceeb0c2f47cf9800cce41521b9d835cb501f98b410dc1d49a310fdda9bc250 +a56420b64286bdddda1e212bba268e9d1ba6bdb7132484bf7f0b9e38099b94a540884079b07c501c519b0813c184f6b4 +80b2cf0e010118cb2260f9c793cef136f8fa7b5e2711703735524e71d43bce2d296c093be41f2f59118cac71f1c5a2ff +adcb12d65163804d2f66b53f313f97152841c3625dbbda765e889b9937195c6fcd55d45cc48ebffabb56a5e5fe041611 +8b8a42e50dc6b08ab2f69fc0f6d45e1ea3f11ba0c1008ee48448d79d1897356599e84f7f9d8a100329ed384d6787cfc4 +aaa9c74afa2dec7eccfbd8bb0fc6f24ed04e74c9e2566c0755a00afdfdf3c4c7c59e2a037ec89c2f20af3fae1dd83b46 +aa9f6e8fd59187171c6083ae433627d702eb78084f59010ff07aff8f821f7022ef5fbbe23d76814d811b720a8bfa6cc3 +a56a3ded501659ad006d679af3287080b7ee8449e579406c2cae9706ef8bf19c1fc2eb2a6f9eaf2d3c7582cded73e477 +81971e077c1da25845840222b4191e65f6d242b264af4e86800f80072d97d2a27a6adc87c3a1cb1b0dd63d233fbafa81 +a6fa5453c4aaad2947969ee856616bf6448224f7c5bf578f440bcfc85a55beb40bef79df8096c4db59d1bd8ef33293ea +87c545adbfaaf71e0ab4bac9ae4e1419718f52b0060e8bb16b33db6d71b7248ae259d8dd4795b36a4bbb17f8fae9fd86 +b4c7a9bc0910e905713291d549cec5309e2d6c9b5ea96954489b1dff2e490a6c8b1fa1e392232575f0a424ba94202f61 +802350b761bcaba21b7afe82c8c6d36ee892b4524ab67e2161a91bbfa1d8e92e7e771efb1f22c14126218dd2cb583957 +b4e7ddb9143d4d78ea8ea54f1c908879877d3c96ee8b5e1cb738949dcfceb3012a464506d8ae97aa99ea1de2abf34e3d +a49a214065c512ad5b7cc45154657a206ef3979aa753b352f8b334411f096d28fd42bca17e57d4baaafb014ac798fc10 +8a80c70a06792678a97fe307520c0bf8ed3669f2617308752a2ab3c76fdf3726b014335a9b4c9cbcfc1df3b9e983c56f +a34721d9e2a0e4d08995a9d986dc9c266c766296d8d85e7b954651ad2ca07e55abb1b215898ee300da9b67114b036e0d +8cfce4564a526d7dca31e013e0531a9510b63845bbbd868d5783875ed45f92c1c369ce4a01d9d541f55f83c2c0a94f03 +ab3f5f03a5afc727778eb3edf70e4249061810eba06dc3b96b718e194c89429c5bfbec4b06f8bce8a2118a2fdce67b59 +aa80c2529fc19d428342c894d4a30cb876169b1a2df81a723ab313a071cba28321de3511a4de7846207e916b395abcc9 +82b7828249bf535ef24547d6618164b3f72691c17ca1268a5ee9052dba0db2fdd9987c8e083307a54399eab11b0f76b1 +8fbcb56b687adad8655a6cf43364a18a434bf635e60512fad2c435cf046f914228fb314f7d8d24d7e5e774fb5ffb1735 +a3010a61a2642f5ebbce7b4bc5d6ecb3df98722a49eb1655fe43c1d4b08f11dfad4bcec3e3f162d4cc7af6a504f4d47c +b3dcc0fdf531478e7c9ef53190aa5607fd053a7d2af6c24a15d74c279dbb47e3c803a1c6517d7e45d6534bb59e3527f5 +8648f6316c898baaca534dff577c38e046b8dfa8f5a14ee7c7bc95d93ae42aa7794ba0f95688a13b554eeb58aeedf9ba +89fca6fc50407695e9315483b24f8b4e75936edf1475bcf609eed1c4370819abac0e6a7c3c44f669560367d805d9ba63 +a367a17db374f34cd50f66fb31ba5b7de9dbe040f23db2dcc1d6811c0e863606f6c51850af203956f3399000f284d05f +91030f9ca0fff3e2dbd5947dcf2eba95eb3dbca92ee2df0ed83a1f73dbf274611af7daf1bb0c5c2ee46893ab87013771 +84d56181f304ce94015ea575afeef1f84ea0c5dbb5d29fb41f25c7f26077b1a495aff74bd713b83bce48c62d7c36e42d +8fe2f84f178739c3e2a2f7dcac5351c52cbed5fa30255c29b9ae603ffd0c1a181da7fb5da40a4a39eec6ce971c328fcf +a6f9b77b2fdf0b9ee98cb6ff61073260b134eb7a428e14154b3aa34f57628e8980c03664c20f65becfe50d2bdd2751d4 +8c6760865445b9327c34d2a1247583694fbeb876055a6a0a9e5cb460e35d0b2c419e7b14768f1cc388a6468c94fd0a0f +af0350672488a96fe0089d633311ac308978a2b891b6dbb40a73882f1bda7381a1a24a03e115ead2937bf9dcd80572ad +a8e528ec2ee78389dd31d8280e07c3fdd84d49556a0969d9d5c134d9a55cd79e1d65463367b9512389f125ed956bc36a +942c66589b24f93e81fe3a3be3db0cd4d15a93fb75260b1f7419f58d66afaa57c8d2d8e6571536790e2b415eec348fd9 +83fe4184b4b277d8bf65fb747b3c944170824b5832751057e43465526560f60da6e5bbee2f183cb20b896a20197168c7 +88a71aada494e22c48db673d9e203eef7a4e551d25063b126017066c7c241ee82bedaa35741de4bd78a3dd8e21a8af44 +8c642a3186ca264aac16ee5e27bd8da7e40e9c67ae159b5d32daa87b7de394bf2d7e80e7efb1a5506c53bfd6edd8c2c3 +81855d6de9a59cef51bef12c72f07f1e0e8fe324fcc7ec3f850a532e96dcd434c247130610aaee413956f56b31cbb0dc +a01e61390dcd56a58ad2fcdb3275704ddfbedef3ba8b7c5fce4814a6cdd03d19d985dba6fd3383d4db089444ea9b9b4d +96494e89cbf3f9b69488a875434302000c2c49b5d07e5ff048a5b4a8147c98291ae222529b61bb66f1903b2e988e5425 +b9689b3e8dddc6ec9d5c42ba9877f02c1779b2c912bba5183778dc2f022b49aed21c61c8ec7e3c02d74fe3f020a15986 +a2a85e213b80b0511395da318cbb9935c87b82c305f717a264155a28a2ea204e9e726bae04ce6f012e331bd6730cbb9d +91b70f44c7d8c5980ce77e9033a34b05781cbe773854d3f49d2905cc711a3d87c20d5d496801ad6fd82438874ce732b8 +884596417ff741bb4d11925d73852ffeea7161c7f232be3bdce9e6bbe7884c3a784f8f1807356ae49d336b7b53a2b495 +ae2aed8ab6951d8d768789f5bc5d638838d290d33ccc152edfb123e88ba04c6272b44294b0c460880451ad7b3868cc6a +89d8ebfb9beebc77189d27de31c55f823da87798a50bca21622cbf871e5d9f1d3182cf32ee9b90f157e6ce298e9efccf +afd00a4db4c2ed93cf047378c9402914b6b3255779f3bb47ded4ab206acb7eaebba0fd7762928e681b1aebcfee994adc +a2e49b6cd32e95d141ebc29f8c0b398bb5e1a04945f09e7e30a4062142111cd7aa712ac0e3e6394cfb73dd854f41ad77 +ae8e714ab6e01812a4de5828d84060f626358bb2b955f6fb99ae887b0d5ce4f67ebc079ab9e27d189bf1d3f24f7c2014 +a3100c1eebf46d604e75ebf78569c25acf938d112b29ccbe1a91582f6bd8ef5548ae3961c808d3fb73936ac244e28dbc +a9a02dcff0e93d47ead9cdddc4759971c2d848580bf50e117eb100cafca6afeaa7b87208513d5f96b1e1440ffc1b0212 +894ab01462137e1b0db7b84920a3b677fbb46c52b6f4c15320ef64f985e0fc05cec84cd48f389ce039779d5376966ea3 +b1e40e8399ee793e5f501c9c43bde23538e3ce473c20a9f914f4a64f5b565748d13ab2406efe40a048965ee4476113e4 +a5a7d97a19e636238968670a916d007bf2ce6ae8e352345d274101d0bbe3ac9b898f5b85814a7e4c433dd22ac2e000ff +b6394c43b82923231d93fd0aa8124b757163ba62df369898b9481f0118cb85375d0caac979a198ece432dbb4eb7cc357 +82d522ae3ff4fe2c607b34b42af6f39c0cf96fcfe1f5b1812fca21c8d20cece78376da86dcbd6cdb140e23c93ae0bcb2 +b6e0d986383bc4955508d35af92f2993e7e89db745f4525948c5274cfd500880cb5a9d58a5b13d96f6368bb266a4433e +b0b4325772ec156571d740c404e1add233fb693579f653b0fae0042b03157d3b904838f05c321d2d30f2dbd27c4d08ad +ac41367250263a2099006ef80c30bac1d2f25731d4874be623b6e315c45b0dc9a65f530fce82fb3dc25bd0610008c760 +b6c0b1ed7df53da04a6f3e796d3bfa186f9551c523bc67898bc0ecfc6b4a4a22f8c4d3bfc740ebf7b9fa5b0ea9431808 +8e78fca17346601219d01e5cd6a4837161a7c8f86fe2a8d93574d8006da5f06ae7c48eea7d2b70992c2a69184619663c +a21f91f47e04fafbfafacf3185b6863766a2d0c324ccac2c3853a4748af5897dbbe31d91473b480f646121339c9bae2d +a464d68786ab1fc64bd8734fce0be6fbe8dc021d3e771ff492ada76eedff466577c25e282b7c8ab4c1fd95ef5ff3631e +829a24badc7714081e03509ccfb00818ce40430682c1c0e4a399cd10b690bda1f921aabcbf1edfb1d8a2e98e6c0cedd6 +87ccf7e4bbcb818ef525435e7a7f039ecbb9c6670b0af163173da38cbdb07f18bc0b40b7e0c771a74e5a4bc8f12dfe2c +94087bd2af9dbeb449eb7f014cfbf3ee4348c0f47cde7dc0ad401a3c18481a8a33b89322227dee0822244965ae5a2abb +896b83ed78724dac8a3d5a75a99de8e056a083690152c303326aa833618b93ef9ec19ab8c6ef0efe9da2dbcccac54431 +821e6a0d7ccf3c7bd6a6cc67cde6c5b92fb96542cb6b4e65a44bbc90bbc40c51ff9e04702cb69dd2452f39a2ff562898 +b35b2096cda729090663a49cb09656c019fef1fc69a88496028d3a258ad2b3fd6d91ab832163eaa0077989f647e85e7e +b7857ef62c56d8bce62476cdb2ab965eddff24d932e20fc992bd820598686defe6cc0a7232d2be342696c2990d80721a +b343d974dfda3f6589043acd25d53aecf7c34b1e980ae135a55cda554ff55e531bc7c2dfe89b0d2c30e523c7b065dad1 +8d139e16a73cd892b75f3f4e445a10d55d1118f8eeafc75b259d098338419e72e950df6ca49cb45677a3c4e16fb19cdc +817b8535bd759da392b2c5760c51b3952ecf663662a137c997f595c533cd561ed7e655673c11144242160e41d1f2dd71 +817ee0f0819b0ccb794df17982d5b4332abff5fec5e23b69579db2767855642156d9b9acccf6ceab43332ccc8d2744dc +9835d2b652aec9b0eba0c8e3b6169567e257a6a3f274ec705dbc250ee63f0f8e4b342e47b9e0c280c778208483d47af8 +b78c40177f54f0e6d03083a4f50d8e56b5aafdb90f1b047bb504777d6e27be5a58170330aee12fbaa5f1e9d4f944acfc +ab8eebacf3806fac7ab951f6a9f3695545e2e3b839ca399a4ef360a73e77f089bb53d3d31dbd84ddfde55e5f013626e0 +96c411fc6aecca39d07d2aff44d94b40814d8cfc4ee5a192fd23b54589b2801694d820a0dd217e44863ccff31dda891b +8249c424a0caf87d4f7ff255950bbc64064d4d1b093324bfe99583e8457c1f50e6996e3517bf281aa9b252c2a7c5a83a +acf6ed86121821a3dd63f3875b185c5ebe024bdb37878c8a8d558943d36db0616545a60db90789c0925295f45d021225 +a37f155621a789f774dd13e57016b8e91b3a2512b5c75377ec8871b22a66db99655d101f57acaecd93115297caabfc21 +92e60ee245bd4d349f1c656e034b1a7f0c6415a39ac4c54d383112734305488b3b90b0145024255735e0a32f38dba656 +acec614e562ccfc93366309cfdc78c7d7ee0a23e3a7782a4fc4807b8803e6ebfb894a489d03e9a3c817ff2ec14813eba +b912f9dd26ed552cb14b007b893e6ed2494d12517e5761dbeb88521270144f8c3eb9571a0ad444b30a8a65e80bd95996 +8375408dae79c547a29e9a9e5d4ec8241b36b82e45e4ca3b0c36d2227c02d17bb171528d3778eac3bbdc75d6c4e8a367 +8c2d0e6e4406836da112edbbb63996408bb3cda4a2712fd245e4bb29a0100fdc89a2746d859b84a94565bc1cfa681813 +a7431bf59e111c072d28c97626cd54fcdf018421d053a787d2aef454b91251ee8ff9d3702d06b088f92b9ad2bbebff15 +8f3659b0fbeb90b7f30b7a49233325e806551a32911a654dca86e290b314483bbb33fe6482387bc48c35d85c1dd0441c +8dca5ba23f0bb76f7dacabf12886053552ba829a72827b472a2f01e19a893155cdce65f1fb670000f43e8c75ba015a31 +8c1514c083c77624eeb5d995d60994a2866192e15c4474d0be4189fae0e9dbd62494ebb4c02fbc176b53be548abbc5a1 +80498d2ed153381baf3b0f81da839ed0eea6af5796c422b8e59be805dba48c4395bb97824ac308170bb4f14f319c5ddf +84f5ebc3bf96362457993e9fa31493c31c4283075e2403f63d581b6b0db8a3df294b2085643f2007f4de38cb5d627776 +958e6e38774da518193a98397978dbc73d1c3827b4996ec00b4183da2c305a187a0ada9aa306242814b229a395be83c9 +ab8b8fbf73845615e7fab3e09e96cc181159eab09f36b4c1239b3c03313c9aeb4bbb51e16316fe338b2319ed2571b810 +977e4e33b33bd53394e591eba4f9a183e13704c61e467d74b28f4ad0b69aa51501a5221cb1e0e42bcb548ca518caa619 +a9bb7ecb9846cc30d04aad56d253c3df7004cebb272f6adf7b40a84adef9f57291e0d08d64c961b9fc406cdb198aab9b +8d2b72dc36406a545a9da44e1fddfb953d4894710ca026d6421a4ac91e02d0373a599f2acfe41d8258bc9679cf6f43d3 +904192fc8fe250f61ecb8a36abbbccae85f592bbf00c10039c30b5a1c733d752a04e4fd8a1000c6578616f8a16aa83a3 +87f5fdfe20bbbf931b529ec9be77bbfcc398cad9d932d29f62c846e08a91d2f47ae56ad5345122d62a56f629f9a76c4d +84cc3a53b2e7b7e03015f796b6cb7c32d6ded95c5b49c233ac27fafa792994b43c93cda6e618b66fce381f3db69838ba +aab58da10d7bbe091788988d43d66a335644f3d0897bbc98df27dcc0c0fcee0ac72e24f1abdd77e25196a1d0d0728e98 +a10ea8677c2b7da563d84aa91a314a54cab27bb417c257826ebdd3b045d2a0f12729fe630bbbf785d04874f99f26bee8 +acc4970ef2a4435937a9b8a5a5a311226ca188d8f26af1adfcd6efb2376a59155b9a9ff1cff591bde4b684887d5da6e5 +8dc7cf6fcca483c44eb55e7fb924bf3f76cf79b411ae4b01c6c968910877ac9c166b71350f4d935f19bdffb056477961 +ac2dd1182ded2054c2f4dbf27b71a0b517fb57193733a4e4e56aca8a069cff5078ffd3fd033683d076c1c639a4de63c7 +932ec87c450cd0dc678daf8c63cd1bf46124fa472934e517fbbfb78199f288ff7f354b36e0cc6c8739d3f496cfe0913b +b0d631ced213e8492be60ea334dbe3b7799b86d85d5e8e70d02beef3ae87b1d76e1df3bdb5f7ba8a41904c96f6a64455 +929d7239ead7575867e26b536b8badf2e11ca37840034d0e5c77039f8cce122eff5a1bf6e0bcadde6b3858e9f483d475 +aaae5d372d02ee25b14de585af6fbc48f2c7cd2a6af4f08352951b45aa469599eff41e820df642ca1a0f881120e89dbe +b23c411741a6b059f04fa4f5fd9dd10e2a64915f2de6ea31e39c32f2f347a776a953320e5f7613fcb1167efe502f5c5c +a4581b0ae633fe29c6f09928e5efb16db019eeac57f79fef2fa1d3c9bee42ce0e852bc60b9d0133265373747e52a67a4 +81b33afffd7b2575d4a9a1c5dd6eee675c084f82e06b9b3a52a3c9f76e087f12dca6e0ffddc42fb81ce1adb559d47a38 +89cc890f06b424591556aabdfdbb36d7a23700425e90c9cfed7d3da226b4debe414ac5bdf175273828ce6c5355712514 +a4399438be75cfae2bf825496704da5ed9001bed8538d8ac346c8cf0d4407808e9ee67573eb95fe1c6872ac21f639aaa +ad537f7ce74a1ca9a46fc06f15c1c8a6c32363bd6ac78a3c579ed8f84252e38a914cac16709fe65360e822ef47896de4 +8e53b69f5e3e86b86299452e20ea8068b49565d0d0ab5d50ce00158a18403ae44e1b078a3cfd3f919aa81eb049a30c6e +a59f2542c67a430fd3526215c60c02353ee18af2ff87cb6231a2564fe59b8efec421f18d8b8cc7f084675ecf57b3fd05 +b8d9bac93ef56cb4026dd1c731d92260a608fd55b8321e39166678e1dab834d0efddb717685da87786caeb1aaf258089 +aa2df56f4c6fe9e0f899116c37302675f796a1608338700f05a13e779eb7cf278e01947864a8c2c74cc9d9a763804446 +b0108ff2e327dcb6982961232bf7a9a0356d4297902f4b38d380ff1b954bfbcae0093df0f133dd9e84d5966c7b1aada7 +b06b813b01fe7f8cf05b79dc95006f0c01d73101583d456278d71cd78638df2b1115897072b20947943fa263ddab0cd6 +aa41e6c4d50da8abf0ea3c3901412fe9c9dff885383e2c0c0c50ed2f770ada888a27ea08bbb5342b5ff402e7b1230f12 +a48635dbb7debac10cb93d422c2910e5358ba0c584b73f9845028af4a763fd20da8f928b54b27782b27ca47e631ebf38 +80a574c208e994799e4fa9ef895163f33153bc6487491d817c4049e376054c641c4717bda8efbeb09152fa421a7268a7 +b592bfd78ae228afc219c186589b9b0b5c571e314976d1ed5c1642db9159d577679a73c049cfc3dcfefcd5a4f174eeea +aa1f08af3918c61eadf567a5b1a3cdcdfb1b925f23f1f9e3c47889762f4d979d64686ce1ce990055ef8c1030d98daa3b +857df4cfd56d41c6d0c7fcc1c657e83c888253bae58d33b86e0803a37461be5a57140a77fb4b61108d1d8565091ada1c +8fae66a72361df509d253012a94160d84d0b2260822c788927d32fd3c89500500908c8f850ef70df68ddaeb077fd0820 +aa1dbefc9aef1e7b896ff7303837053c63cfb5c8a3d8204680d3228ac16c23636748fe59286468c99699ae668e769a0c +b64b1cb2ba28665ed10bad1dddc42f3f97383c39bad463c6615b527302e2aaf93eb6062946d2150bd41c329697d101be +b6d35e3b524186e9065cee73ea17c082feff1811b5ab5519dd7991cdff2f397e3a79655969755309bd08c7d5a66f5d78 +a4dae7f584270743bbba8bb633bdb8bc4dcc43580e53d3e9e509ff6c327e384f14104b5bdfe5c662dc6568806950da37 +aae84d3d9ad4e237b07c199813a42ed2af3bf641339c342d9abf7ebec29b5bd06249c4488ce5c9277d87f7b71b3ddd37 +b82a463cf643821618a058bddf9f2acb34ac86a8de42a0fa18c9626e51c20351d27a9575398a31227e21e291b0da183e +8b6c921e8707aded3ea693f490322971b1a7f64786ef071bc9826c73a06bd8ae6bf21bc980425769627b529d30b253ce +80724937b27fc50f033c11c50835c632369f0905f413b1713a2b0a2274bec5d7a30438e94193d479ba6679dbe09a65ef +a1d9b259a2ca9cff8af6678b3af0a290c2f51e9cf26d5fe3c6a4fa3d28cbf33cb709b7f78b4f61cb9419427983c61925 +96a3e69a5ed7a98ce59c4481f2ffb75be9542122ad0eb4952c84d4536760df217854d4ec561ce2f4a79d3793c22fa4f4 +990c4d9a4a22d63a8976d34833cafc35936b165f04aed3504e9b435f0de1be4c83b097bbaa062483cf3dee3833b4f5b6 +b9bf5e4b270aec4a0dc219457b5fed984b548892c4b700482525ba1a7df19284464f841dab94abfabcaa9a7b7a757484 +acaecf49cb4786d17cf867d7a93bd4ffee0781766e11b5c1b29089ae0024c859d11b45828fbff5330b888543264d74a9 +b0e1a0865b1e6f9e4a0e31d0c885526ac06678acc526fda5124742a2c303bd0e8871a0cb7951ec8ed9540fc247c8d844 +82b3d327b3d1a631758451e12870816956cd0cef91fcf313a90dd533d5291193a0ff3cc447054564ce68c9b027a7ffd7 +a2843602abb98f0f83e000f3415039788da1e9a096bfe8fed6b99bab96df948c814560424ffebe755cb72f40436fb590 +ab1c7b43cf838798d1e314bc26e04fc021e99a7bfbfc8ffde62fa8d7f92139de86a377289d5177021154229de01ede15 +95e5cf5dd87ae3aed41b03c6c55f9dfad38dc126b17e7e587c156f7745c8da0bd1d60acb718fc1a03b61344f01e3de4d +86f021a3762bb47167f80d4ef1b1c873a91fe83409f9704f192efeebbc3ece0729cd2f92f63419907ea38ae47bc907d2 +aaa1445dafbbcd645d4332d9806225e9346ee5ac6b22ad45e8922134fe12f3d433f567a6a4c19efdd9d5775a7de1e92f +8fd7e15688eef75df7b8bca3d61bc9fca4f56e047cdb6d0b864e7d1c4966eac27d6094b0c8482b49739f83ec51050198 +80aab8b4d394eb011d4ec6a4c2815617308c9b847c6fa6a3d7e6af1c79420ef6ff2a13934a398581c40ee4cf1cac02ac +8970b97ac076a1d8a321ce00eada0edf974a46bf3cc26f6854e4218cdfc8d2b0c32199d9658f254b4fbae5a2c5535f41 +a1aa2ec5b03df0a630e73dd048680ed6d3032c324941423f45cd1f16038789e5e75b876a13948732e9079a422f66a9fc +b5fe5f5e2f2ae2beeb8e95859a02fc45f01f9fb0ebb2bd8ec9ec976b3e806228821a9775096d341d662bc536c4d89452 +a2bc1f170b62d0d5788b02391337b2ab157c38e725694e80aeead7383e05599be0e2f0fa27ef05db007061809356e147 +a8a69701d4a8d0d972390e9f831fd8e9f424b2c2ef069e56bd763e9e835b3ce5f7cf5de5e5c297c06ace4aa74df1067c +b43d551af4ff3873557efe3f3fb98e5ede9008492f181f4796dd1a6bcda8b9445c155e8146966baa812afae1abe06b48 +b4b1dae44fd596813f30602ab20e9b1fb20cb1bd650daacc97b7e054e5c0178b8131d439a9e5b142ca483cc012a362b3 +b95b8a94c30a831eaaebea98c65cc5d0228c78afd6603d4aa426d8186aecc951f1a11c33951f51df04c7e6fa43ffb5ae +b100059624cf9db371bec80013a57a8f296d006c139a8766308f1ea821c7eccc26cad65bc640ab3f6cef9062653bf17d +8e5a2cb76716e0000d13bce5ef87acac307362a6096f090f5f64e5c5c71a10fddfdee8435e7166ba8c3ad8c3f540f3e4 +93d2c43e21588c1e83c4255c52604b4ac3f40e656352d1827e95dd5222a45aebff9674e34fbbe7ed21eca77bd9b8dcbc +8aeaed611546bb9073b07512a9a1f38a7f436ab45e11775a0f9754baaf63e9bcc7bb59b47546a5ded5e4ba2f698e3b5f +af9e6792e74a1163fe27612f999a2f3cfa9048914c5bef69e3b2a75162bb0ce6ece81af699ad7f0c5278a8df0ba000d2 +850bf2d5d34791c371a36404036ad6fdcd8fb62d1bb17a57e88bda7a78ea322397ce24d1abf4d0c89b9cf0b4cc42feb3 +87f7e2a1625e2b7861b11d593aaac933ed08a7c768aebd00a45d893ed295bbb6ed865037b152bb574d70be006ddc1791 +8dcce8f4ad163b29a2348ea15431c2c6ea1189ece88d2790e9f46b9125bd790b22503ec391bc2dee8f35419863b2c50c +b4bf5266c37f12421dd684b29517982d5e4b65dfdfba5fc7bd7479fd854aabf250627498f1e1188a51c0a88d848ec951 +8651623c690247f747af8fdffdc3e5f73d0662bc3279fa2423a3c654af9b6433b9e5e0155f1ce53857e67388e7e3401d +b155120f196d52760129dde2e2b1990039b99484cdc948fa98095cd23da87679850f522e5955eae34ac267d2144160d3 +aec8115e8d7b6601fbceeccf92e35845a06706d46acd188452c9f7d49abef14c6b3a9a9369a8bab2fd4eb9288e2aaca5 +998a8ca4dc0f145f67a8c456f1d6a7323c4836fe036dcbb0f27eb1c596d121eb97369638a9908cfaf218c7706f266245 +b235fbafac62802742ee3d26b1f4e887f7d2da4d711ba7f9bb6ca024de7beec1de66bb830ce96d69538f7dcb93c51b26 +9258d2ddc21ab4e3edcde7eb7f6a382a29f1b626003cc6fdd8858be90f4ad13240072d8a8d44ef8de51ca4f477fa6c45 +99d038487821c948142c678acd8c792960993dd8cb5e02cb229153a1ee9f88249f4ad9007f08e5d82e2a71fb96bb5f32 +a88ee9dbc73d3d8e0f447b76fdb3a27936bde479a58d5799176885583dc93830ac58bca9087075950ea75100cf51af23 +88b9b15816e5a0387153c1f4b90f613beb3ea4596037da01a81fdd2bcbd0baf5598db99f77e7694e5a0d35e822758108 +907ae4b637d06b15846ee27d08c9c9af42df261c5bdd10cf5bc71f8e5ca34b33ac2405307023c50bdb8dc7b98a2cd5fe +9393d6900e1d2d1a1e42412fefd99578d9ac1d855c90a3e7930a739085496448609d674ca9b34016ad91f22d1cac538e +a28ac56b216730b7dcdb5ab3fc22d424c21a677db99a9897a89ed253ea83acfd9d83125133f5be6d9cd92298df110af8 +b027590ee8766f1e352f831fda732adbaf77152485223ad5489ef3b0ce2d2e9f98d547c111fe133847ebb738987fb928 +a9cc08fbd5c3fee8f77cf6eb996a5cafa195df5134dab000e4d0312f970a5577942ee89794e618074f49841f1f933a42 +a8b3535c3df0b1a409d3fc740527ee7dd5ac21756115cde6f87f98cc7623f50cfcf16790689cab113ee7c35a5bd4879f +b61420227b97e5603ae8a716c6759b619f02b8fdc48acbf854352aa6519dad74b97bacc1723ca564cbf3ca48539ed773 +853762498de80eebf955a6c8ddd259af463e4e25f0b6ba7b6a27b19bdbf4c585de55760a16e2d9345cdba6b2a02610f3 +a711c1b13fc6c30745203c5d06390e6c82bd7c50f61734aa8d99c626faba30119bc910be63ec916c91ba53f8483c05a8 +b488c0a793f4481f46b5875d96eecd73e46209a91677769f0890c5e002ecd7d4b1c9f4ba68c47fbed40e3857b1d8717a +a651c5e812ae65b1c66d92c607e80be330737ea49c1dcfe019c0ecea0f41a320406935bb09206a4abff0d1c24599b9ad +85e34e7d96e4b97db98a43247b6c244383b11ca10bf4777364acf509a6faa618bc973e2136a4693fbc8ab597e308fd5a +99837214102b394fffa7f3883759554c6bb7a070f5c809303595a44195e02b9a169460dc6bbffb62bdc0e7ced5f0a5c1 +a952f89c0afb4bdae8c62b89cc3cfb60d0576ba4fe01a5d99534792f38d8848d919b3fc7577435d8443a044d2ee0bcfa +a1ac1f81acb29798acdfc493854663519e2d1b0e9d23d286ce33882c34b4c1c0bb43dd9638166d8026315a44d9ec92a8 +ac9c58aa38219ae659d23007cc7b97fd25b7b610b2d81a8f9f94ddb089efc49c049a8ea4c56e6eaf7b6498f422a97b3c +87e61d501c242b484fb9a937ef21d485f6678d75257fc8fe831b528979068cadbe7e12b49c34058ec96d70a9d179ab14 +aa45f6852f35cc8b65a4a8b5380641d2602a4fa4e3a035db9664df3ac2e170b1280c4a8b7b55161430063e54de4158a6 +a46975614ddde6d134753c8d82c381966f87203d6e5a5fb99a93b0d43aa461466b37f07b8d0973a1abd6ee2b40f24348 +8d35f97297773422351f4d99564c1359ef1a10cfb60aa0e6c8985a78f39b4268486312c8ebf9dd2ef50a771aa03158eb +8497c6242102d21e8b3ade9a9896c96308ab39171ab74cbd94e304c47598e2c2a7b0a0822492ac5c076ba91d4176481d +973f8fcb5f26915b3a3ef6fe58cc44bc7f4e115cd0ad9727d8d1b8113e126ae2e253a19922c5433be4ab2311a839c214 +ae3ee9f1d765a9baf54b4617a289c3b24930aa8d57658a6b0b113bbf9b000c4a78499296c6f428bbb64755dfd4f795d2 +a5be7a8e522ef3dcf9d2951220faf22bb865d050f4af2880b8483222ff7aad7c0866219fcc573df9d829c6efbb517f98 +a5f3c7fabd7853a57695c5ad6d5b99167d08b5414e35ed1068ae386e0cb1ee2afbbe4d2b9024379b6fc3b10c39024d36 +978d5592d4798c9e6baceff095413589461267d6a5b56cd558ec85011342da16f4365d879b905168256f61d36d891b1f +b7b6eaffa095ecbd76d6e1e88ceebabaf674d9ef7e331e875c6d9b9faa1762c800ff1ea597c214c28080f67a50a96c1e +8a1ab53ae5ceaa42e06e58dd8faf6c215fc09ba111ca9eeb800612334d30d5971448be90fec62ed194328aadd8c8eecc +a9ca532cac8ace9a9e845382f8a7840bf40cb426f2fcad8a2f40aadbb400b3a74021627cc9351b0966b841b30284962e +8dddeda8854c8e7ddc52676dd1d0fed1da610ed5415ddd7d25b835bd8420a6f83d7b67ec682270c9648b2e2186343591 +888906aac64fd41d5c518a832d4e044fdc430cfe142fd431caf4676cafc58853ce576f098910d729011be0a9d50d67b5 +96a3f886a2824e750b1e2ea5c587132f52a0c5e3ff192260d8783c666206bd8ebd539933816d7cdd97e4bc374e0b1edf +a150a29ffb2632cc7ec560983d9804cd6da3596c0c25956d27eb04776508eae809659fc883834269437871735de5f9ed +81f7ad4d2959d9d4009d1dfbc6fee38f930f163eb5eac11e98dc38bd2f7f224e3f5c767583f8e52d58d34f3417a6cf90 +97ccac905ea7d9c6349132dd0397b6a2de9e57fd2d70f55e50860e019de15c20171a50b28a5c00ef90d43b838253b3d1 +95694f00c21e8a205d6cbda09956b5b6ec9242ec8c799a91f515b07dcc7de3b6f573e2c0ba149f5a83700cda2d1df0f5 +82bbc3c4a3b3997584903db30fffd182a266c7d1df3e913f908d5a53122fa12cf5acd11d915d85d5bd110fcc43cee736 +8d3f24b4949aa1b4162c28dfbb9f813dd1d8b330f71325448dc45ea34d59b69ca95059402aae011e1b5aba6e536bc6ec +92c734c19752d24782331e74c9af97a8399ddfdd32954e91cda7363dba876aca4f730b451c50a8913950420682da8121 +8653d2c79f77b8c7dcdf7e8dee42433998aeedf1b583abfca686d47a854de1b75e9a4351580c96d1a2a9532659203361 +886f0e414cb558c1a534a1916d3531320a9b6024639712ffe18164ce6313993a553e2b9aafe9c0716318f81a5d0bb1da +b31b5efaba5a5020c3bcea0f54860e0688c2c3f27b9b0e44b45d745158f484e474d5d3b1a0044dd6753c7fb4bf8ace34 +b2d615bbdfdc042d6f67a6170127392d99f0e77ae17b0e1be6786ff2f281795f1bf11f83f2e0f8723b5cdd1db1856e09 +a6e014cca531e6ac2922239b5bee39d69d9ba6d0fa96a4b812217dd342657d35606f0b9c5a317efd423cdb1047815e3d +a8921736b69c9fbb29f443715174bac753e908251804620c542fad6cfbfda7bdfe287f2902f30b043a8a4b4818cfdeef +8d73a9949a042ec2dcefa476e454cd9877eee543b1a6b3b96a78ffcff87421e8b26dd54d5b3192ac32073cb36497acc3 +b936a71ee8df0e48867f3790adf55dc8efc6585024128de2495f8873bd00fd9fa0984472125e801ed9c3cdce6698f160 +82f69c06209c28f64874e850601dda56af44ffc864f42efa8f9c6a0758207bf0a00f583840982dec0a517ab899a98e5b +b7a0a14411101473406f30e82f14b13e6efc9699e7193c0be04bb43d1b49e8c54812ce0f9b39131a20379c4c39d3bbe3 +81159c969f38107af3b858d7582b22925a7ccced02fae3698482d7e9cdc6c568e959651991c6cf16c53a997442054b61 +8bf1116a206e0ce9199fcab6ed2b44a9e46e8143bff3ed3f1431f8d55508fe2728b8902670cfd8d9b316f575f288ed9d +a279b2149824b64144eb92f5a36b22036d34a52bd5a66e5da4b61fbc95af6eda8e485c7914f448abd8674fc14d268d9d +8b98279b5f3588d1a2f8589d2756458690a502728800f8d94b28e00df842a101c96ab9c5aee87c5bbe65552c0c383b80 +b4a27a351ec54420f94e0a0a79d7c7a7337940399646631baca93eeab5fd429d7fb39428be77dcbce64a13eaa3c8ca1d +90c08baa29ec8338ffce381eae3d23ce3f6ba54e5242dec21dc3caaed69cac13f2ab5e8d9d719bc95720fa182eee399c +85156d65bb4fef69ffd539ab918b3286105ca6f1c36a74351ab3310b339727483433e8f8784791f47b4ba35ca933c379 +923005013c27209d07c06a6b92b0cbb248a69c5e15c600bbcc643e8dcd2402adebd94dd4cafb44ec422a127e9780aaec +863b23eb5463a6ef5a12039edc2f8e18e3c97b244841bc50af02459b1bcc558367edf2f6e4fe69f45f37887469dd536d +87a4a7708a112724ff9b69ebb25d623b5cae362ae0946daed2ec80e917800dbfcd69f999c253542533242e7b9a5cc959 +8bf4347ceea7f94b53564f26b1a4749a16f13bf71a9e03a546f906f7c423089820ff217066159b0637d9d6824e9c101c +ab07eef925d264145971628a39e4dd93ff849767f68ed06065802cf22756fc6bf384cf6d9ab174bfc1a87bcc37b037aa +8e3f10a42fad43887d522dc76b1480063267991c2457c39f1e790e0c16c03e38a4c8e79a0b7622892464957bf517ebd8 +a8722fc7b1acf0be18f6ddf3ee97a5a9b02a98da5bc1126a8b7bf10d18ee415be9a85668eb604ef5a1f48659bc447eb5 +878d6b2a9c0aca8e2bc2a5eb7dd8d842aa839bbd7754860c396a641d5794eab88a55f8448de7dbddf9e201cbc54fe481 +ada881c167d39d368c1e9b283cf50491c6bfc66072815608ba23ab468cfbd31ca1bd7f140e158e0d9e4d7ebfa670bc2d +a2b48578fa899d77a7ee1b9cb1e228b40c20b303b3d403fd6612649c81e7db5a7313ba9702adc89627b5fd7439f8b754 +8e051280e10551558dcb5522120ac9216281c29071c0371aaa9bde52961fe26b21d78de3f98cb8cd63e65cff86d1b25c +a7c5022047930c958e499e8051056c5244ae03beb60d4ba9fe666ab77a913a067324dfb6debcb4da4694645145716c9d +95cff6ec03e38c5ab0f6f8dccde252d91856093d8429b7494efc7772996e7985d2d6965307c7fdfa484559c129cca9f9 +993eb550d5e8661791f63e2fa259ab1f78a0e3edad467eb419b076a70923fede2e00ddc48a961d20001aaae89fad11e8 +abb2826e4d4b381d64787a09934b9c4fe1d5f5742f90858228e484f3c546e16ee8a2a0b0a952d834a93154a8b18f3d16 +a922ca9f2061996e65ef38a7c5c7755e59d8d5ce27d577abcdd8165b23b4877398d735f9cb470a771335fc7d99ecb7fc +90f22862216f6bc1bbf5437740a47605d1ff5147b1f06f7b13fec446e4c5a4a4a84792cb244a1905f3478a36f8d7065b +87f3d9a86afef5b79ea1ca690ee1ee4bb9754b66f7c50a42ad6b99af7c222c853ca161f440a0a2a60b3b5a54e3493240 +80a9ca9a2d33b9cf61976b3860d79f5d00de89a06ef043d2a52931809018aeb4ce70423cbef375b29c2c750c2c8704c2 +b4e798ef1d615896108dae37ac50c1e859216ab6dbac11653e44d06ce5209057b4b0dd6d31dcfcda87664a23c8ef1cbd +aaed6d1e7c5b1db06f80dae6c24857daadfb0268f20e48a98fba4b76de1ebf65fb84c3be95fd6a418b498f8285ec63bd +aeceaa316c6369492c939f94809bc80e0857abac86c0d85be8066bbf61afbaaec67e28c572437a8d35c49dd596b3134f +b791c3d53ed34a7d1c8aa89b7953e3684c3cd529230824dc529739a5fbe74b58b87f01e56e7a169f61c508237ef67160 +9351f8c80634386c45c0050d2f813193f9d839173be941e2092d729be5403632a2f18dffdc323d69eb0dc31fa31c5866 +97693184d5c0056ae244dfb6709cafa23a795dc22d497a307a7f9cf442d7452024023c54a8d6bda5d90a355ba2c84f3a +85362daa003d23511ca174a8caafe83d52b6436dc4e43c4c049e5388d9211b5cbef3885896914d86d39be0dd1f910511 +a2511b5fa34b24eeb0e1bcbcf872a569d1ff5570fe7b0fb48f5542f7fe57bad808d34b50afa87580866a6cb0eba02f27 +b382e3327eb1401f2d378dbb56ac7250adde0961bd718575a64d264ffd44772c20752d4035c3ba60eb435e160b375e20 +afad8a5d40b536c0720556845a6b257ed42165c14fb4b4a874717d107752f49ed9380c5b048df3aca67287bb8fc411a8 +8fad0c98434ca5373c2d767868f679b76b4a8d04bca8240ea3f388558262c2d61b73b16fc1160932652b5688c25fffcf +83898008b5cbb6f08f8ef3ec179427869682bb4e8d38f6e6a687a214d4a307436afc64ee67d70a5a8ba9730bf839aecc +b85232e79913785fd82b06890706972b4ad7a309489930ae23390d51aa5189731f8a2df24800409a8c36b3dd6fc91275 +a24ff26ec792f3701da4c5638c1fca4fa4dae95b01827d6200d583c4caf17ea3171393ba2a8c23d1ee8b88402916f176 +adc5c7a7ff6b41d6cc386b7fc69d7bb04179bdf267864f9aa577f0f6a88438191fa81ebaf13055c2f2d7290be6421ace +a05e835abd502d31454d40a019010ff90b6b0b1f993075a35c9907aeab7a342ac0ba6144dc9379aada6119157970e9b2 +85ff07ba58463e7f153fc83f11302e9061e648a5cbd272bb0545030b20e11facd8b3ff90c9ac8c280a704fbda5c9d1b0 +a6c735ada8f4587da8cdad7ea3ada01650b5a3ecab8d81daa7a5f5de51ef4a6592b524692584306f06be3f6701f2870c +b138deee4e53ae8d677fae104f713ef1b8babfecec16b6a85785a66a72784eb09d44c3b63567222ade714e98f7d1604e +ae79c1a49dafcdd972acd95d8ad0a35c02adc7fd736d4c44c3cd13df5789d339b5ea16bddbbd43e486a061ab31baa5c0 +ab3cf2371a1d7dcd0ffe3869a0178230964b06694bf258b2073ea66a2afccd845b38485da83d02e1d607d4c5c36b78a8 +ab9609f28a325fd01cb39540e3a714506c44e52ef28ee640f361deb5760aadbb23e804663b0fa20a66e239c33f8d8bb8 +8ed95ea8e76e1b42823d7915a6aae77d93746f846bf602841dfce0e47543a36efb9ee7e5b42c73c3209d911225cc471b +a80b6162036d43811482323f0ce59eb18740e33a63d7c7bbbf3be206985919e5342d53a69df537d43e8b7d7f51e8892f +93c03d0a5083408ba00c125a8a9385213d4c860072f0297857b1235045819b904e07f2425c13a661d0a01d2e53347f4b +a6581200f00f96c461621e1d26b14a23687dd97eb9f7df4ba641a84340ee7306dc1796248fba4804f185947ad13b4385 +8be174018fa40f7e0cedc5ae68f38969eb7695f2205e9c573641e533d56f68c20abf38a23d2f0dcac371e60b21b18615 +857ad4ee3218c647c58f09b8ab22bcc8976f00a768ab1f708618e868e6143474be846422ce2710a0ed39b5155b6f13a1 +a490bec40f322d599f26bcefcdddd8f2ef6576aa737d5ce7e8d5d422741abe749e3e6a48489aed8c560633f72857e3c2 +a9c0ee339621f1c4a2410f9b4d2f03f1b558dae2973807b8bccd920e8feb7f65dfde3e79986b72ad21fcc4567240381d +8592251568e750a430f7d2c6ddbb3ec82a4dd9fd83efe389e69aa177fd97ac2c96c59a6e86db20d8e6f125d65b46c4d3 +a4e2f4aa6a682913b423b097c4069c4e46a1f3af9556b1bfd0580d0fc01e3991488458049e0735b2a629684a79271c8f +8c4f6a3e738cf74112b08b1680be08158013ef8a515a81215d8a36c9b756786d1b4cb4563923463f3329292f4b48bf6d +8bace547353c02ea00dd547eeda7259aa354d4772dd5e0c486c723cf88627b7112e196b879c3c92a9561b674d9fc486d +8d372f4901e25e8db64fa098148d4a4e709b0e9dcb756d0f90dad99dea393054193ae1a33d292a3dd772ff7ba05e4b71 +a8c7ea6a6a031ed23d65639f01f5423190775558f479700597df7ae7e338a6ae5e9b32f470aff20787ac8b7eec84df6c +b6e9dcba240fdbbf66033410a79a2dd3e9e1ffdf2eae949b3a9ed720e939d92339991dc3e70a5ac7d5253f317daf0b7d +974dec4cd61af75721071752c664d9c2a5121f06ff1515c56139a177a3ca825f763b69d431d4607e393fa74dcc91cc58 +958863e6ad583a9d370a6db3639066982e44766904e7afa849b132f6666b7d08ab931131b3bec7a506d6583e93d56767 +8b93a33b5da9b3300c20a96d80b894e3789c77041183c2cb21751579c8c96857f60cfc2f075201b64e95a78985c5b321 +b726cb9f7ef34ddbc2fad82b3b0af0b30cc913e26c5a614ae5c19cc9c55c8e6dae069db5315a8dcb6d987415bb550ca8 +a730f515398a71bddd66cab2ff996659d4e47dfbb08ce7958a41021f76d269b91c7498b708cd14b183a8ef469c772803 +a4eb3b18132eb0f5337f14e01d63ca0bec0db6a43870f800e5491db756c2f5fce519d8dba5528b4bcef550d06b33699c +b1ab6621eec1ee6784e632e214693f39a14f3715991996b883d66200963e065c86fa0667f7bc36b93b40b5d90ff708c2 +80486a26c3532ad6e19f76d8c9344e2626c07363fd495264927cb5935fa9565ece670dc98767afb04af6a9a5c9231075 +8ee20e0df3c84a1c6b0e21bcc325cf99235b747ffe47f17fdfba548a358ca75cbcc331dd50db2311b400ae882256a608 +aef4268959e5541e7ec69c921a1e81a8374d7e44bf1bb2debf4101cf3cd6b7d6ca7f441758b388de96b3e0edb5b97be9 +8793629bd29d689ec94b016de8886cac6e2ca6638911babb22db4a787661422da0639a4e4089ebeb689d173abfe75950 +b487b3551c20a29e9a5abbda8c50ff594826283e443c09e3ae09b914e46060b3f9abf70434444ce1487e2a74e562616b +8f11531cfc5997dd04b997cb87ba1831aa7041d5434fe72de66304e3f165d882fac891391fbb1eb955c65319e65293b6 +b195136875fd02a75676c33cb3e60504d5964f7a9e81f4c8c8fd38af62e2145c55f765b3158664566191188ac678f381 +b374174b0b3eb04fa49eb4ece45173f0db5d829eac370a20a62309566e0f98b18f72f3633626893c053b7be6bfbd2366 +b2a2f6b0cf652775679b2d677048f2ed8c31a3269e6cddcc7a10e3e6fee89e486b50d9d55fbe452b79c4157c0270fb77 +892177c364dc59032594e7a6fd032286ffdf4fa0b9e3baeb37ec839faebfd2fd46c57b2c9bfe9977b59c93a9cc0ead1d +8ab7c0038a7dbb2ef200dbbe9acbc875829ecad4883792d5c6ce283de67ccd9aa935a9cc7b30b2bd9de7fca7bf2a9a05 +83745cfc78ca709835aa6c6a233c2b86fb31e3f9f6a8becf63e501f2841c4366fb7d131b746c9d3291afda714ff05579 +a723dcb67925ef007e8339dc578d2622d9bb77cfda87cca0088854a59414c02338752c56116a6c1281917842e8467c38 +8a098142da0af2254c425fdbbd0d1b1a17b2bd781391ab37f181775524b8563c64ab8a1602aee2ac6c0a82ba11a8b1d1 +b13bd7529a9b351c5d395c794c28bcb0a3167f1c992e8c062eef47be9be27895945231d249c73a0b6949daa295e14944 +a20dcd2fc2222eaae467d9f5db861040f58bcb991a26e5663ac3aa5e1ff13d0010657c5af586cc4621757add2b905073 +b818f660c3cc4e9f273c25ceeabe562c8afa8ff88529c26f2cf45ae6b2813cca5f350e3cbd56f6257c4df41722dabd25 +b225d5987108b24411bc389276f12509a45e86d5ad6b6d929af5274df0be11109c0fed329669a0acafdf3b0beaa8f2ec +91fcb6d04576d3c6bae947bb7843b430e5fb0592ae49b0a65dfa5791f4eaa4bf2c7f436c8de7360f217001c2b4e5c67a +8821f7a1424ca3fdc5d4a5606ad10dfaba6094cf36669fa9f84cf7617e50425405d14980780e1e18a1ecea7913cda896 +990dcb7f38f56521a70cb71bf4522649fcd46ac052c7feabb0748dfcac9f9c0f95d29e070d32af3cd0adbf869535e17b +b0fac1029fe2c1100f24e2f4bf10c7672199fce53513c7dde2e8d9b00702edf0143e0e1dc7ceae7dcc6994edc2422b6f +a514ebb1a33451b4915c05114db0b10168393613744df848b24e43e09f0bda23baefd9d731075198aace586615ac7911 +8b77f7953c2e67049fdca3653b8d8cf3f799677f79b954da02bdad8cc4d6c855c1c7c16b4f6f9ba35f46426ec28b2d84 +875520cfbda16ec5b1d1d00f578a910d0fc052f17870ba093e22e310bb07648d34817cc2b8811b6f52de535f7046a0d0 +b8c77b4be0b430851c4ff69e91cb770db1935d848198601393810ef395efab52deb9d5c6525472bab720273d5e0e7a79 +b6d4d437146671bdea62fb6545395ea3df39f1cdef21b8476b68e7a25aa7354f847740576d6c9f187bbae9941f0ae450 +95c642f1bccdb62cd6a2212dcdd6ff8d49aee426ca08b7cf3a9d15249d24a9eed5533f92a70c84498c0797f8a57efa27 +b617978047ed0f748c305aa7f30c2dacd0db00baa67fe0c5ce346ef0e6991dc7e05f18dcb2702467421f8390f27aa815 +86411c7a00b3e8b43bf22fb061b1f54ad9bbf632cd74395a478218389c0f544668acf3dd7726532d080ca7da9a5f8608 +97bf684a8849626c4710a6992f6c11f6b5406fd4dfe9e6aa502425aaafe9827e2c435aaf9a5d3d2ba3a4c0e8aec79ba4 +8b178e2a125b461d3180906ffba0af3dce614c64058501fdd35243ababf892d6fcdea4834ce42c25d5569452b782a709 +8ebed2c8a25c61da6a6a8cb0d8f5ea179e28869753eacc728f2c076f7aed8598cd3aa0981f120f9e7ea55b3a689ae882 +a6f235b8e655ca3d634740b53d8c0a757ecc75d2b8838b7948997c1985473d01943d935f687b86cee56cd47c8e773443 +a7959c465a9646908b9d8032a589e41a7dd999f2ffc54bb42f22e5f8a4d8c493a31bcc7ea2cac6c8dbcc59acace7181b +96d0532df2e12da20a57cadb6cf5f6c4ee1aa4775629358c25f1d51677a3e96d1fe3b232532324b4f02f941952d4cc68 +90f493473d686b639a30d1ddc9c72eae6e983f1236e162e58e967a477c0654973ea2e1bdf4ba1a44d7247bc1befc2cab +8b2d87876d9c4085102a07ebb41c565ba69acab99ffc03efc18f20e48d3f3bbe4fc6ddab9c78fe479d9ada80504d85ba +829a0fb3200a28e09cacd6c5346000e7786116ddfd898f37dfd17bef454a8abc0fe939ed8735c00769f7f2f33cd4f906 +86194ec9e88ddb7150e8b03e7a535b6e99863fc6762835601efd03615aa97aaeb413cb210e86035086ed852b39c9d019 +b02efd116a7189cb317ceae392bc301ae55470f0489fa89934e182aeb8c67e280299b975786fe9a470bff46827defb9b +87d7c3903bd22b12d815506f150373f518d47dfc6e5fd74347d88b518124c9923d1e4c98defeb3a45d53d50b423e2175 +a1a430406b28254a7d6348bc98e697e9bab43839aa05d53faee97546f84541ea0b559162619b2045182938f69bf61cae +99d243c226c61c6697fb3d2594f3533fa5dfd7cfc87107908cacde337d7a077fa5a9dc702d26081b065edb1227498e65 +800ee5006ab6217161f42db0cfc552a81728bb4fbd7af6e4620ea099a65ef6664184af3f65a07fcec7e965529c5b49bf +91bfd307579cadc8f81009558605be3edbcb8dbba271475803484017f40130b2b216aef4f620d960193be681877d3a53 +96a060459dec458d19a6f8af6e49dc6c7c58c55dd18915c5fce5e0f4b4a422fce3b9632f6059388fe760289abf70f173 +9921a37f3e657222c7fda3588418a9071409711d9f1fccede7494429f02a45fbc52d79fbb64e9ccd518f60d06d0520d3 +81052b0d15773cb75975ca9230ebb2579700e489c7e3f07cd9cde206fef38b8139bd4976d2b4a7840495fc645f96df03 +88ac37ba66d1de5e23878c992e4d54023729e97e77351f50dc5918d738b5a73faf1dc6feec7e85784761836ba1c6f778 +ae1e6072c13060775f6086d1ae1f88b627ffcb810fc0e0e97deea1f3a15ef0aaa52a6dce2563e4beedadc131af2a8281 +8b60a340f5e4f90badf83001b495ac9f13974c3d2054ddcb3e6b8ca99dec5cd63a263e05c282454191ab2e087d5a2911 +832e2d56ba69dbf817b2b9dbd25c1538d5b8dbf5d9bc05e6be85054a423ebb66a71b157e166e0b9444ac171b34b7ccc9 +8586036fc7dde1e7e3ecb61663130c4529866ae9f5f5095b9fccd24a4c70eea899aae5f10ea1ba66d1665b2d83be35b0 +a77969453b5c083a207913272b5b69d4ccbd8718bdf54be8fbe11b4bd0a2168aae3ba8f9362afa69c0ffa28d7e5a2340 +b7fe9568c214baad0ac5f83745611b481f744ec1c4fa78a549b180dcf79633e5ba75dc20055012a13d849eb7a9be57d3 +b01cad1d2a6c51c0ce88243d1f52f95fb5ee315a905079688027511f0c4ecd0563a3a81846709d272fa5ccb9665e8043 +8eae0a21adfc569aa57237654021c2bdb2c6f0f52ccc90a126682c21a1f9413c63d285f92b2b2f8649150a9284bf70b7 +942acc947192b5f3cf60e92383e5d35f79e7a5904e8e9fd1c8a351676c83ad29b0afb6578d555457cf909f8f4d27adfd +a74e092f8628fba9abcabc27e2e9f3d5a9a941dfe50a2dfde2ad179aabc73afd196676925c2d98643ab8b3d02bdb66ad +896159daa2afd757cf3f9d34af248ad68bb3c62e4c9ac49919422727479cf669098f270b9e645607a7d11adad4c889b2 +a428d8370813d78e7a2a24eebd36e9da2f8bb3605e5a39b5fcda939b531c35a8ebaaa642ba556250a37bddeec90326fb +a5fa04eb60a1d5ee9820e78f42f7be15e1c02757b539aead995768c6209684d6c183c71d282e0c12a4c15c03f9a89d4d +93c77d5d220e40affa7269a6915c076c9aef4db552c643ae5d560a79c955b491c6346ca4cf11cbb7fe1894e28d47b065 +802e605d2de745eef6981d88e7a57ef4046a2062725e8080995374cea2b3273c27f35b7774d0dcba014710d8d6c501f2 +82f7169e6ec9b3e2bd450f35ea2e66d06bcf900acf5b73139677b48e078ce2e16599103027b2326770c99c0a690f2015 +b0c8581879439f9b997551233fe2de71aa03604f9cec37a7b18c5854342d9b67be468f3cac4bf6f64fe8a0066248c498 +a3f626848a4db6e9fb01cac90d3362ec521e969ebd5228af694ea3671061476149f13d652942ac1e39f65591fed740f9 +88a8e759b9cbe16a7c16e43f4afa2de6100d2eafa4dee75ccd653ec38c919013d0a6b35c1ee1eaee7c1985b58bcc9e92 +a3d5fc7aaea072798490616552d947e95f49cf02a420314307aafb555287ec607d75589ba24b009cd68299dc6f7942fa +a809cceeb84f9bcf3c3ddafde3041e7bc3b1d14df8830ab849002176a0725e6f16f70774d8962cb0b8ac0dc43c4ac66f +b8f2e46c031cc8fa160a08c2ebdfa85345ed14771b06daa9636b0e7792b7fddbc501dfc85cc626a01104a43a7d3230c3 +b5367e2a521c318b802ce16ceac80c4b8139f73ddb10ddf38433397cda70a86ea1f051cc55626a4e99d27f30f3975ff5 +96d963660121c1441cd13141279cd371a6a0aa18b6a20761b18df60aa9c14e13489afd83695a0921d5232efe72045f07 +80818d492fd85d666bd91aaf6257b86527fdd796773c793407df1d4a0f91d74649a6bab4d15155c36ed4c6e0a32c5636 +931e22918905fd6c230d3d867ea42861f3074d320d14e1929031924c8ac209a5c552b679b24563bb12f9749b4ee983bd +a4de2c333e74ed9bfa3c0bf6a0beb90427abd9aa4221294cda74331646b58ef46ed57cccc8798ba2b9309894b17cfd69 +883881554c1d88c0ed8d3b6dec3d200f6fea69a77ace3e4d6f86b41506a23724b4394ec8384075f9c75c3868ba8a8e8e +aa0539ecf6ec9bf06f24443027f8f24b6b3d8c5b2084248eecd4bcad3c9a69716e1a0d01057f09a65bff1006ac5e157a +856d74d44c943c9e809b42dc493dff20eca03cb0cf5ed45108c69b1f90d8592a53ae8100e99380a274fafad23e74cdfc +9188257446661c88da093b7c5ce998135913f63842d7c1586065377b169ee35b062d925367fb9b909ca971f1188667b1 +8d3aa57cdafbe998938787479f5d590c1484c6dbe94e6c487e57a746ef5252be0eaa5976d6270de7db64b6b92e57a0f7 +b8f4d6997240f9eda5aca0c43323a828d1563c491b3db2087f60ac4120a3fcd06075fb42bb19d0339ab5ee3fb7db25d2 +ad247ea94b8ae1e81eae4c9fd7b39e6601b53cff47b2547ff90a3cca87192eae28408082774a1fd14bf9ab459b7a4f1f +9598598070f8bdbcc49056c40971e673726cd8c1bc4baa0b5124dfb5fb750e7baa7a7df18eae2bd91955ddcb1ec67955 +b874131ab1608667fa60ea29092d090859eed1812e90c609afff96d79e82c5ba546f617f4c96fc32c9bba97431c1e9af +b00750a9cdc75c2a54f0d3cc99b0fe02300754f25166f7ac85ff41ab5e9cfcca33a29be76a480f12a2d410c7cd5032e5 +84b5bd1c90bb6c66755b28ba4af493ca1b0c3a4df9f436aac67d2e07289053f925cf6a149a84e74e1027dc8758150179 +99caf64bd9d193ff306e8ab5da3f1bb2a190a60c3a82099b8d03d17fa810dc53d176c21379f479e828f60d25beb3ffd0 +a8fd9de502f1c261d5733430e5a18d8b7892a98c9529a016fc2ee53892ae965dcd9c75850bcda4c7edb980b8d88e60ea +848c02cac636e047028a3fe8c1bf4066fb7591b96b0340f8fbd476ff01b35fa3e37d309333771a134f24800e5f3f9289 +a1eab1a06dcca3439f0166441e7e7f2f5b56f5f8aa9f45e411c561f556e0fb71c514c06c26ac53b49a576caca5faac3d +aa603f970dcbe953e700e61c151182c8d32cbbb53ceef572ac93383db33a4b098b5c7b267e42d514ca66b740c0925efe +b55fd5301bd700ddb0b4f72fabe9a91ad49759506101fa802ed1677e9553595aa4d2c66f7574e78d21ce882ce0120ae7 +829137bc4da7b4886d3d04d2c39cbf4b1dc40c813ac1adb425c7b9abf9142b516314cab79c68454df5d71994ce416144 +b83a3a22735001f783dd48a01c4fb3598a51ff3987e842b8045c71c035b9e43645a55254ca5911a5676ef4a8af12d056 +8ca8d463deb13f9eef5e533bc39efaeb0c15631282c5c0deee1673b0053a7cccd514af09801dd6c158caa159fe9351ac +a9ffb1427828f3c456b9c8cc50782de1ab0029b9233a0fd998bad0fd014d27e15c4a32d1e16ad41bff748378b5abdf49 +9627e29f725ddd86456aff813976bbc4a836f4deabf5ad9f73d1a260ceb30948824df9c8841e6b3c529652202be181b3 +b52c988647fe3d9276eed3c262e1044f57fbb116c64cf4f207235c205b3fda0f3d789bf90f5217401b468d85fdfda404 +833bbd6e2924f5c4446cb76b881d1434a5badce9eb9b003f85d076e297ad7ef45b822069fe54d17427a348c3263fb838 +a067a36352db6f82a116cb87d3db5f60b18576852409e2076cbbfc7843af78866313a4969385a40271051dd195d51116 +902b99545971f9a103f99d7399acc347ac46fe156166e51deefc0e92aebf5893460c69aeeae11f5af9f49418e289ce6c +9206a0e9ce9b9880f29ef0417c96931985f5d83bb17cebdbba4ff2af81a3d37155b04649426f698aed372e4f669599e6 +b54a5d7c976e45c0b1d44433595eae9d1ae9aeabfd58cd5ecb0c5804756a7b01c9a517754423b4714a3695533a3114c8 +91b612131e84580ece228b81ace83da0269b53f94d3c02a1a0879ebbd81bdc252064b3d03a7e140b43a90f237d9a45a0 +a6cead3b8607eaeafe37135bd6de8fbd16f806c131eb71c8d36bfbe295d45b070255e50dabf076e2c3f6b8699be71d6a +931da21e67b11ba6ce438546a24d063bcd51aebe39b4220a78d9c0aab88b2d37969b5ef3502d835507f9c8d6d006714c +8fda408caa9daf01122a2308b7b9d328f52e1e2f138a8bec30492488f4d710e5e52524a6455a3a2ae2818ec8a610b650 +ad8ad5c189644352d90c462731c46145410e5adf38682bb80f95495dd64d9d13782537d68690847bbb06c6be7175dbc7 +87bb5cc466ade60feb0961421c3fabdc8a7e20f11df8437bfff63d3f8bd25305002a396c9d0fa4fb9a9986d4717f12c4 +827cff72870ba00c29064a7d2b4973f322d6b6de7924c93d8bf8825e7a0e8478c7748f90f5c716bf83c55b2795d315d8 +a225895a8e94229776ceb51b05356291f2dce748be17a60d5aeb33ef8507c368bafe5d1d6eea927f28b9d1422b661b9a +8e011323ce670ff51c964241a6b72e0e0ffbb3ff9bb2762492323fc3a4abf4718091be0945287c7329850e4f74462cde +a2c03c2e5f4e9d3ef361f68b188451994ad1b24de9f323370559c8abfcdc7bffd289d92e78a5f6b104b0a12c84dab2ef +a22b4771116ce22276fab1fec6826610707ce8a342f9f60b079c4e0259dac3cc41c96c560dfd0ada6edd2828f7c0e8d6 +97c17441d0af9be83b42097aa8b7cec84a253b9a2b957214b8fa93c26d2add46144faffa7b8a55312059b10690f711f1 +94bdf348849f31a2737cbae5e5848aee711067bac85c11c2e68b44c398cfafbf3493a3226cd1ddf7a916e7613fc7b6f6 +838f59c6e8469a8ec6fd40b978a3607439aaebe1e50ff707eec72c0b8278af05b477bf12a384b56d03e3d4eb91e56f67 +a1940f0db58185e2b3aedd2b0bc2b73b4a65c68e09b046f38e9dcd4e13c94f5406bea92635190bf315e48ec64eceef2f +b2f4e0ae44e1f1210a91d8f280f17091fa994034ba8c991583f8182a323e9b3001a712e3584fc2d64ecbf2d319d076b2 +9342b89c721338d02c7854cd7466fb24d93d7313b6114ea591e6607439c8ddb911d1cf35f01898e9c557982bdff8f9b6 +8583fcab15be1dd14d5a415f4b14d706c8c62f058500f1344b37730c8be6741779691f87ded3cbcf6516468b373cafb0 +8fa9587c7989646571ad9032f34cedd353caee14f5be5cde1e9e0a1710f90c08faf6fa96a60e1f150f761c9c8ae7417d +8d9ff904cc08141f5a9879f5f77dc600e6edbe859082231a4d819953890199bcc5f940b730ea688332f07e5279d49e1c +b5f82b46e5ef9a2df8d144202d6e2e4f3bdae8e2048d2af5ea7deb3f722fbe6d370401954e74ff0d8cb1010ffb1f38d5 +a3b5b57d435b06ed70530e060002a8fea71746ad07d969ca23f22b5e52624527595b6a6d54b4e953fb7b7596bac378f0 +b90f89390df6d4b7879b915aa3c29b8d779d035033f8873bb7ac54a14ec98f0d08c0e3bf696e2ffa7b5730d736f571f8 +8e81e371b92887e43d95c0dbdcc9575282b26ccebdc8cbf46587e4f2a83b61e9bc0c6d7d1f114b9d21e04fd6c180b12a +8d682947c51dffc6e0fe0a486293c9ed121f441805168236393087cf62f2a429cca60bf0e472564844347d32c6bea27e +a8341ec7dd189fa7168759240224192c58209b53fc961c18082deba217928c399bde08ceae42bffd37c1135b4d14a845 +a94bb076dcc5ee5ec82fac57c5b384c690df12631882bd1b960e1eb8c04f787bc22b7bac315b9dc5a8a098f17f051a0b +ab64e1c6f01b87706c88a3bd974454a438722768de7340b834ccf93ea9880c14ee7c2181432acf51f980d56de73832ee +b7b0058bb724d879e5ad7aed6230297c54cb599ef659e86bf2cc84c38225899fb388391df9b2e6fdf063171937fd8c72 +ae856f4fb74c27cc98b67429186e7df4feb01278cd57bfd3170af6e52e0a23b9e926bf9565a890cfb4ae8f2d590b2cd5 +804b9c6702f0596d328f92fc1ed5a30a7ba17b9204524135001b569233fc4937035031d079f52fd04968f37c24013898 +84274ed1af6bd6a968583995622b4d18c6a2bc703ce0d0edce45bb736529b4836343dcd11911a94a134dca7877e6cab8 +88808098463f7505034c3b6328c8a08186b33f7a981c08376e429dd64b79b97753170531ed078dd265ded4ec0a1ed8d5 +92823bfb23a4eb84d3759e7d717f0c8641ece0927cd2ba8c728c26bb35df2629a838002f353c8d3d75eb19520aab5f25 +8db36bae4d960cdb9c51f419d7ddc81f372e56be605bc96a9d4072b829f05527c37c8f255cc6115300a2a0d2e6568d89 +a8fcdbd7f3b4d7ff04149a209feb75e97149e7efceaa42d66a6b8e432590fe7bd01f1a77fa8b47108f670b612e33fee9 +a9f4c53c62db7e5dbdea6918862d3c6d24b5bd8732a218edf0ba61e9d1861182323d8ecd7bef8f895b42970b492f6e40 +8b95bc7f07818f4d7b409aff8da0b2c2ae136cde386f53a71565cae9fd14c73c13cc1cfd79c0f97cd77839fb738c5b9a +adbd1d11adc756b51a571ddbcbf4392415231ddad93da09acfafee03a9e4f9e1ce3826110619e5271feadfaffce3e793 +95d327c8bb195cdf25fd79c98f9406a6b0316214b1630ebcce95bdaeffafa36fc1accc6882e0e5d13a8db5c0f3c0e61c +8cb2f1e2fb25558869afdacc7bb866544cfdd566cefcd048b48d458a886130bd086ecb7600a960a7f2563c61cb326510 +b3aa8c4bf5b933d89cd74ca7f7176d6624d562d7d58b041328b49d7562a30b489cb606abb3c49e85baf04c28e9cd1f44 +97f9053a85250c420599827297453c2cfde087065b823d9e43139e6a9cac3a2ec40a1b6e2f0726bdc870fff215462f0b +878d5dbe6b881389c2ca126ff66d87127c9aaa3f62f0d2c1ec0ea2b279ac95f8a06710dce166415db227655e2345a04d +b2c33a6b4203e3ca5247f0890e475518317ffc44cfbb1da9a1ba02114e8b752bea618050b876de5cf3b1906140a64471 +a56170c8313d2b5541a795bea9934d4425b185b5c409f0484df6f44f0e4bcbf50b860ff46b7245cd99c1cfa8fc1965b7 +96e2b658e2876a14147385fc423d2702a3cb76962b6b437222cf9cea39ebf4bdc03bbf434b747866d4bf72b4ceefa639 +89c4a74fa2f067e7ae49c84ef782c331bcc9245db7e941804e2e99d12e987b4d25cb827778ad4c3566c4fc68018650b6 +a01d30cea7d01c80ff26650020fab02e78fc3842e2398a81b44b21d58d4e9816166ff4ed2418831fa995a28ff35cb6f1 +b960c80b55a8845bbf24bc3f23b0110ca701f9544ab6a5bb7929330213cb471321e55c390ceca3e24bff69bdb0d331c0 +802c5b13f22be7be0e5db11eb3be0f0ea7f9182c932265060ba05fba20ea093dd2810d3b969ee3e387e60fe6ee834e8d +92478f88ef7435d15e39a97916c736abb28ea318394b88678fddbbaab3eaf31776110936abad116a8ff6ca632dd12043 +a6d3da0370c303001d5ed99d1db8bce1f26b0e442f0f042e36db9674e92dcd6e80465e772f1e669f99221caee3392fe9 +938f04f70a8f947d6df2f0c0e9af3cce0c06edbb3c131970dd60884fc0b0a0959c504a2a36c3ff76dfe919905671626a +a7117e55224230822e9983df2132347eb7208cb6798f291df926ab51e04b1a1f78d5568c9a8924ee6f57426134360f20 +b91074c77ad93fe48dc2b10c0c5a62ca3ab7d98345b919c52d84a9dc419b59fc1b267e1c2d4b2e120016ef84bbdb0cbe +aa175c6b6edf02fe8778762c9575581c0ee6efc9dbf99c291a41444a23a056b893be6c45333d907d0bbe9fb0eef84d08 +ad36dcb4e2ab425aa339ae464b038d550cb11186741dcf257f1b8b80ed4f32ffabbece45e2dc1525d4c3eeed819ea04f +91cb35c1ffa9cd5aebef523edb8325078da3eb5cf9e95c675a76446fc7692aaee6f949de064ca2f3e0f082cc3fa93e20 +82622f9410c143a86bc4d756b3c7b324dc295231ce865de020d61cc0868f2c150a473cea3a5b756b36771ce1032415a5 +a5c29996ad3a53468ece9356a5b4ccb68971ea1c89cf39644f1da2d4a477c2ea99bf791ef902b87c225d8c53d67c4c92 +92893eceed1af34fa92b23dcbab175b6a0188a27dbac9ad3317c4e39955a763cb383ab13fb1c519cde311d8a4d12e8b3 +8a093cb191b94b0200e38d31955f9d240e2be1edcd6810a2396a061f17c3ddc9c4f4d56766ddff4e121be7110e03b869 +93981473df0cb1f4b47c7d9b64e3123dcf1593845b401e619f5d7c70b5dbea375d1ca43fca65845fcf0a6b2e0af43791 +a6beb6b0697070f9562910add88d9ba91992f8da127b27be81868b1596d1012f09ea7ed601b4a6474c921a1a1a6d866c +92026b1ee30f2ed61c9f30337c3356844217926aabdff383c19ca3c21e0bc49811ca5b308012bee4ef250cfae1615800 +ac0ebaea6d35f84dac4ce648af096305ba68a7a0aea0a11ab2fbe3162075444a158433c98141bc92ef3b3400d6deb46a +83046f482dee24ac3ca83373f0d1b82ac1c4beda0f229a9011a81ec659ff5fc1fb105e219975b5c744308c77a24f71e4 +aa5a312c47ff7248dcb9c6ffbe5a0628ccd565c07365c4413734d415cd4fb35772622ed833862dddff520a67c509c6a5 +a02fb88805c34018ac33582e19ed0a7e4616acc3dd0867e5f21914c2031c05c6dca30b8b35b57c2b137750f3878a6f8c +a60528f1f14bf0c496491d46a0fbbd6c343e4eb3f1631e92f96a3c5e5c684091aabe5801df7a67f7c6dfd1b0d35269d4 +a1fd8e7fad8ca05a340c05a051bb0eb4197eed345f4104629a9e38e234b09d789cc5537024615feb4a6177d32d39e39e +8e70e36c1aa070815440e19443f1f04aae23b1b59fdbcba43b47b94a026c82c8f66c5dfe54f826f4d95ee1930cdb8008 +8234c1969fa7e9079661e4ca309b71b1aaa10f4372be0b963205c23a81f5a3d52ec08ba9ff65b37f832b52d631580d61 +a18cb4134127fb37c4abca328cd0047378a2e1423490af2bd3eba9ffcc99ca81a3c22404c0886f21f65c7b93c41d7981 +b46fa45fe538816de776eec086e040005706cb3eca097e290abfb6864e745c879868aac8361894f3c3564373ef9ad55c +b96ca43b96c59e95439f75d1e726a35a9362f0dbd34963b156e103e080a8126a8dc3501f9fd541ff3bcf4677f5c4a86b +a8e8c87c7301613818d57387009e601a7ab5cbdc2890f63d985c30c74f9cea2d0584c116baf0d9cd5594386ee93fc661 +b47e4f1b9153ef0981f813948150f283b47a7346fd9921d51fe8e4daedaef78ddeb4fd467c2ccb7cebd9816243da1c6e +a370c202a99c8441ffe96fad0f801086d4d7cc7b960f6e98cca29ceedf492afddfd0f351c9c4d29ac008bc255ec1a2a8 +8f5e6ce1655d1c059b006174e3f5a55c88e1821c97f9702ad8e8455d46c2a83ae4482f2d43edda74a835686ec45a8a15 +a30421e694930a3b65d397b2720d5f8e1eec2b6e2bb5a28d3f9b0a84db9aabd83850268bae64c2b10e313cccf120151b +8abe87163046f7a9b18e2a3c0b66e258facc1b31431420e0b70354b7a60ebd250a784634a76692e7d6f4330b62114945 +894f033cf077d4eb312e3258d9dca414356271abce1d6094ecce6d018c5fadb1c15d8d69451574ad0701a2876db191c5 +b0923d64f88ffc872654e1a294bb1af8681689c21cf08f39afe51448a68e60a9a0a74ccce9969276a932a52c07d095a3 +b9ca23b5be8725fae7fa710eefd45522889c50c29c26384e00b78a962384f0aeff9d15cb5910e9565da12a577eb7e5ba +b242ccf292757197a9f470f2d80ccddc48c7f1235ba026bc68a93be2738bc968e8a200aff3e2f4807216442eb3fc50dc +adc2c3b375b308524b79a024ff87d122055440643fea6fc0a651bdb312c7cbe6a456afa9d342bc76446d77d8daf08bc2 +ab645955356c2ebf2f3df9da275e01daf0b44a52afc309277d6d9ad1b05484e5ae0d9d41ad485fe481e5e362826a86ae +8de96ac587a4449fcc8b7fd0a51b4b5185d9c2eb3434f94cbadd092de1e26b0f6b3f7b15a37e8424b1429121ddca0ecd +94c70ad4e9b871566f3da98170b665a09788d421818299857cde0853789fb943cbcf7d4b2c95246ea7b72edc56a8e36c +b2574be63497843340700b701d5cc8be6d23125bd62058802ee67cce1f3b5f5602b27c93fea5611f27dc695ac563f042 +869ec89da7850cedd88bcb3a50a15cece233119b31b64a61bf6b2310892ce42d8b473b584b11e61db29ed24ce8033f83 +8fbaa269da8e28e9adf4c1b08f109da786dbe9cba871c32eecbfb10619b7a5d65a26f9bb33e201a8ed20b3de94003fbb +8bf7a059c37242caf7f821a6314e4e4adf799e0dd86b37892a7172598892c07272acebd05b534755c57b51556b2d610f +b4e72645fca459898cdd9214892ed08b5c99f82049c0a30d72bac0b9717caa9c6cc16c3dc7aa6ea4d42dcd2a6c175df6 +a39170da87a3495da55bbb9701c5461f3403447174ed6a4af75712f7ba4ac35f51a4234bc4b94da888a0959ee109c0c7 +b45675b2774ea7696089dbf7a0afe6c22e85fd0e4ef3db508fbaf96c9d07f700c991789206da9309fd291be696357c5f +b52899e3e3f6341eefcbe1291db6664bf3b6e8021d32fb9c3e37b6258a35c1da927747b2ce990937d6f4c6c3e7d020d2 +84e5bdb3dfe19700d79dd3fabb0159ccfa084f7288db836c855b827613ce8071067c8d7ac5cc2b4e88ed7f84b690f6e1 +801477d200b6d12fc6e0a9bab1c8211193ab06e44551e037a9b4c36fc2d4f67760b9ff4eba9a3bc7b6e177e891f64ff6 +b6b71a5116d3c22af26a7530f535e9b7851f25a84e562a8f17a125d55b9b3fc1bd8cfe65bdcbeeb328409521e802051c +8687e21c34d7804c12489d30680d131ce2133e2981bfa993afd8a8eeda958ebd5e6881d342d725338659882d9f21cf98 +a024e97a7c4de32b6383c34431994abc533ecdbd6be9bff836ec1af022f5a86773bf345c6f33273797a61fb70a8fd5d6 +83f784f095da20ce5b31f54d6cb14b32a8a12675f0029289c9cd036b7c87a8077be2d04a62618685720e6ee69c875e97 +b4e9dfe7cb9d9efd3fe00d99ae5e48769d4af4bf43d4e05c0b54c9cfd8bc854de96b8d3ebf4dcc06b9dac66b7471a0de +a08b79f9d4673afcf7f38b57f484f88feb7c908f597663a2417f92c348150c2be6b5603f914eba0d9d5bdd4e5c5572c1 +b0eaf919589988798cb01ba0610cd1b7fa3c08715675ece8ecd5f9ef6d5d7b2c4c8ae1ea7dfd202237171aa3e6f9de74 +abff99a98baae4dd0954052503ce81827781694a5ea8c1149f96a3adde75dc2d630e138598cd2ae7fdc7a654aa17df8f +83e369b8680d8b9d995222b033b4f4f3e3b20e782113c941325c7fa9c742feef8747e4a212d9aa23285a259cc4faef8d +b16d5855dd2716613697eba36e2fae0872aaea6999e91cf6552f93f9a0b85ed4f6ff922a91b50816bd6cf8e7a4513fc9 +848373db600e32e741aa1d37726bbb28956783f89ce2d781e95fb1ee1adf4359968a141678af268077eae4c25503204e +93a0dd0fdac18a31875564505b4e28f9e8bb2915faae666538597731ac56cd77f23f2456461e2f672983fb24ad91f6e0 +ab1ebbe49fa56524b564bc2e43784147073e6ea5d27a9540fbf2e04d0f87c645ed2fd28b3e4982cc4c0af1734ee47a6f +b3ee30b733839edab6f61f0738e3f4afaeccf700d8dc7415684f193b36d70d07acd5780cf539f12e0fbf8d4683be773a +88388f2cbdec47a6b3ae460b69eb0d2130ac14de950c22fd86de03e40d02292bb93cebe62432da39d509c1289f785fef +9370c41a54b68ff486b4cc6329c3a851716ebf1d088d77a6c56dec93a18b8a77b596cde74cc17d2adb2b2f411a2e4bbb +b9083b60dc16531f77b05a955b51a237a8f8c0173d72c352c5ca441b55abbc890b14937e457aaec4be5cbbf80cae0099 +aafff8f6c6ebaad952c65054dfc7c829453ec735331bf8135e06406b7a9f740c9a200dc48bb2175516b41f77dc160121 +b43d31fbbaf10526809e9e5bd8bb47a76e0fabd7852ee7744404559ab89f0f215ff518f3271a6aa972a459cab82ac558 +b581ede48c6ef34e678f91dc4b89507413e00e70712e3e8c32a80eed770ec8d8b98caee9702d068aeaca6f704be57bd8 +8cb0a137e68b001a5ccac61de27cac9fb78d4af7b2f5a00b8d95d33ac19cc50c69e760c5e0330a85c0ded1edce0fe6f9 +b947fca07c7aa6c2bf13048275402b00b77b28f1d0ba4b589fbcede13f93b5b931c588560ab8ceba23bb8e748031b55d +81753cced5ff819901740a9a584334e355b497cb699f0be5a52cd555a4c9f149535c7bb355b54407f7f0ec27de6c2e19 +b3d59273951ce97838c4853ec329782a255b5fc7c848e7992ded1be28a5ada7fa3254123afe32607b9991ec6e0659b08 +86b253de246f82be1cb0cef01e87c3d022ca1829d2cc7e6a160a5afbd3ca6b94d75739b122e3bb16f8bde28a8f3223ba +b728b659fa2d8487e061a37f7d14a4c2d70cc37497a8715695d8d332cb274deee2ce23b9b5f6a7408516c02c3d526a49 +81277b46d98848a45abfbe39842495659dcbb80dee985a4fc91d77d52b815487aa8bb455f411fcce4c3879c7a075a93f +b05b6f1fb4a6e654f0ee6b83e08b58b57059bb0b7c490405bc8d963c4a2d6be39c558917977e554e1e9e3169961cbf3e +88f75fa7d016fb6442551ec071cc1e2beeb3ccd213d16d744f573a82f5d70f41dd1b18af71d5f9e73d87f2f6b7dbe889 +81a46434f1bbd65a661a0ff45a0295b8fd8a42a7969c5953721bc98698b64bddee3f806876d1e9983063fdd0c11f99df +8b4f6d33c510a4c9c7d623d9ae0c9aa631fcb987704726b2a4d8519372123bce3c439202f25b5b47045ec14ce39a21a8 +8d5112b330fb63cf6ef3d2164b404c14ff9907d685015701399a260951912b19b8f270f869df317e9050a127763d7980 +aadab394e84dfb82db15ecd2427f39b62352c3e1647c3bcd14fb24ae830ad0116f0fed87ddb63963b424a4741961386e +81ca4e5600d00a3bda24cbdea7a532a4cbbd893c10e7ff10667c15ffa8138b91667abe5466b31a3dcdd60155c48538c1 +ad943af1b8a5fcfcf309ed8f2f916339f254cd555c71a407a47365a139306286a05a8314e1c70e20a65fccd75d36fa12 +b16597a0b437060a390467bbfab94c0bdd695ae898894f4689f939e30cc2119cc08ecb594546304adf876f4e275ebcd9 +a44a4e0a6693be356065891c27eefa040a1a79475be53d54d5fdcea7e0668ff9b35f850974000ed119f6865aa6faa721 +adef27d1b6e6921f4eaf69c79e2e01f5174f7033eaafdd33edcfa5119af23f3a834ffe1bdf19576581b797abd1865b34 +90c1e9202f3ffe28f8e1f58e9650dc4ff4dbc158005b6f2296ec36147e524b4f2f87f8aafc39db5b006fe0c491c92f45 +ac817cd54288b6f7fe6338415344fc9e7b669414051631ab2f27851c052c044be06bf7235d668e194bef695923256368 +ab14944ef653a14456d4ebc12e3196df3f1b4707c4e50b317b5ccc8ca3a0720f0330609f0e7e71793f6ca01583f38c70 +ad5353f2f380837e5ffdf079350b3d42935a0517861d03af98db5ed3ea8501abd68885c8c65f5a66e944b1874826a450 +8b5583863f84af8443ce8970b02e26cc5d959e47efbf8a66a54106ab165f1f76b36423aee74c7b5402fd1c4d7c1adfe6 +b3b46037eed9fc30e4f8f0da8bdbdcc40a38e22e876ce9fde981883017854aba82c18eb00887d92ad847d30082fe7271 +98a2b6fc90b7ad172e4368c1e54675b75c8bf2096d91c9f2b60b3397d3be3b705aed5389845dbd68f0f84438cd0f7687 +b155e800852a5f90a2eac69cc4483428da1dc2c31588a13c924e60a7616ce9baeb7d4b829c772b260277cadd8ed84719 +b8b92c520a1302b0cf7d993a52e1dacd7f27bda9868d59c55687d995ae676b7070af4c0792a9bc1c2635d44a4fee01bb +96dfe9bde526b8fc829eda825f55168b88e8f4e43d4d708cc3060df03437b46e12a8ac70d7788aa75760f6294d3e84d8 +a3fa66c54e2fa084ced3bd838614c6c33042f492a5745d167a723c60d5e7d6020ffd1747981a23f8b68df21ad8f0fa77 +b573ca10cc41fc04a642f6f62c355a4fda69b94b8e95dbb02fd1ccce4bce1191356e1fd66d372159944eb36a7071f005 +acd0a1c9abddfd0ea223eda1722aaada362d34234455bd1c6be115d41e535b16f12ca428da7820a757fa4c98884a385d +96f242eee99c4db383b8754fa7987c0c159652e1866faec905a8d3f010e0a1ad05bd77b9ea8dfd653738959180f58430 +9215a9b672a5d6e435e0e0a45156e0e20f75cbbdf1d14940fed3ddb63d433bef643796c7a4fff881829ebb2b2eba9460 +b8ad9bfceaf08dc5a874387219ddd1170bc3a5e25ed72d321d59ae713be5ddf9fdfbd3aa7ab163be28dfa0dd14614e19 +a19a1050590bc500b32c502f393e407abc3d8e683d6f6b978873aff3e3299b18b1f6b59e2b0fe237d819dbdfcfdc98ca +a6870fb11d4429686e52e1f44c8dcfc7ea24a020df9570c021578dbc1f9bdc8cf797cb3a72d7fc52805dba35d59f2cd0 +a7be733b64d5c06c127bd1c87250e42bfe30ca91ed8ce51e0b6e377f454e8f6fef7f99bff650695df2fd10c375da349b +a1b97145dab30330eea2cdc8739b2446a3704b64505fcea3dd8a9b4a72edf222e98d967d6fd7f76794acfd97aa091065 +b2127049907d2a3b654d1c940b740bfba3dbaf660f86ea79c2f909af7c9fe2a07a1caeb1be12370aeffaf8faa50f1582 +8a207701214bb28e99b0784e9228b1c34afa701966267fe7110f6f29f5bb41eaae6cdb98844d0400787978fabd224de8 +9925147a383b6f5f814520220ffdbf20b214225882c3ef49b1a1ca677709176ec82466fb9c4be2dfbe5640afb63b014a +8416ad93871623fb555b5390b80de99edaaf317350cc0c1ae9d54d59517074d40061f315cce8ba2026d9c1e6f6a1009f +a315f943deebbf0a2cdbcf3f8323e215a406e9cbfbcc3f6288714cb3a6befb1bf71b2a21ff7a2ec4731c65044c45b6b5 +8213e0c2539c24efd186ffa8b6dd401ad2233bc19166a0623b26dd1e93614bbf792823f5599ac116231e2efde9885709 +8e5cafd2f34a127a4a896f05e4d929eef06972a1826b3566446942198df26d62f7679b987db2b3765d9d8058b1cd85c2 +b5302b399c9cdf912fd59007ad4737255552663b1e56dbe64a7b2ddd88d2093c73ea319b45db2dd49d1e03f5bef1a0ae +a0c2bcfbed4b008e1a56e5d2f2419aa59d7dd0ebd990f1c18588de702ad0fa79f445d69965fa9381e700eda13b309378 +80a44eea1ffe24c26b16b8e2e70ee519258b9ad4b3e83cc4e5cca88ebc48d0160066f8b91d0581095b0de2428390c8b3 +84a90cb9c7d2f799f1c4ed060387a4b793ab41c5c3eaffd3b60face9b9c3bae93cd2017283bf3de1e3dac63d0d84dd42 +81d22febca276a05ba9bbc5591ee087b0491beb35b4d9f8fc0d041d642a574667ddc57660b20f5c568f7d61fdcb41bda +a3ac965ac27a28e102a439b74fbfc157e75fd57620e4c0750a466165f8aeecb2191dcf8e656f7525aa50d9c7c69b0b5c +913c17434ff0d9fc52e2ece4fec71b37d4474a18f3ea26925c1be2b250434d49759f58033ba0fce1c6862c6197930dc4 +ac430559c151a5e461f67b49c7786c97e1653fa8698e9759ddbdd99f5daf17fc5a012ae6330739440880728f24eba7c9 +b10d8e9f8aed9361b042d1398ec74364f7c7c1cc5c7f917060572761138bdbe89bf409389ee3879f93bc8032dd67b308 +937271005a4cc6a6ec134870c1b56471aa84ed4f4af1b3d5f334bc0c42762fae0c9a6a2828d3de6151a76dad7b72781c +a10e4dcf51889f69e6bd4c052f8d4036b9571ced98a3d7d779cbcb9fa5c3a82228566ea7cc1d012bf56dea0a40c5a64c +a0ed026528d9a8bb3201bc9dcd20598933e8c72fd315deea8da63d06e97392aa729d98a55a8a60fa4d5573513ba5c9fe +b723fcd04cddbd4c36feae827a03746ffef251c4f4c55a88beedaeeee194430a99f566f483668a0d88b13e7a4a37f1de +84a2cdceed44828c7c05a6a762edec0165e434e7029df617d6646aba48776e6c3b823f40689cee136536f8c93e08a629 +b786264e3a237ac3a1d56c9f4e87438dfed620c867100fd38b01287f5b755c7820937403bfb86644e082094d3e410a00 +92cc35b2065fca157c7bba54410f8bd85907a01c9f760aa0ddb7a82cb55811d24cb4dc6b725367a6a1c293b809a48ead +a12bbf22b117f00164a42515bc57cc9e6c43cc77fb737ee3d0c0cad94cb50cd3847d61cab469cf8ca76f7958bdcfc771 +85985b00de533bde2a757eddf53be79ea39091d16af3fc92327bcd1cd59bf2bf4411a334da29ad775e8ffaf3cea7d7b8 +af9eb24185b0d330d0ea1d0b0fa78af0dcf42ced81cb0128f16cafdea687a9c5582bb6d7c5744117b271cd0b3303f0b5 +8c8aaa1d85ed6327f85d579767c7a9158d209171b3efcb3e8a9d9e534c078e821b6aade255101d2c9ef6d67ba66f10be +a450518a03ffb40e1df89e0f88fd55b5b06f4872cdfb7ec55f40dc40d9424b3b289866336c195bdd54597d95569e0096 +81e61cc69f93c435bd77f155e80626a9c764dd92b6c76af15c41346527948d8a6ca87d6351a0fe7987e2ee3aa66a9625 +b615e0cebf4fdff4cb23a20c8389c370915ba26aa703b28efe4ab070b1603d1c5b6541684acf46b52a915f6aee447539 +a7f51885c7a71885cc84ef734ecd107e8bf5f7a25131415f671d143cc1de92859e65001125323c7985799993af6c410d +abfbf7a46f32066989c32f774edcc68163f085ca81e94fe8c9fb32f8d451bbb2c20ac45cd8d97f9e618ab40186933b1a +8cf35a522b5cac1934004aa9dd236bc77198d43272888afa860cfc79b4b28dabf7a3c74098f84510897566fdd609aa45 +86aa927df78f7a06a4985eb0a4f0b93529cef14f9fd2812d46abffbf25e618ead14d99c70e3c3bb2e17f3f7fabc9c264 +860f1b4f4a398e9a8bb4739587cf96979cfbbe1687b7e91e5bd1198db726391b09b1a261bf12e96698818f60b5bd3537 +8e7c4ee19ff115881051e8637dce1f5d6c65e865d0c757e8ce41b6d7bcd86c7070cce60649692bbf28c868c7e2e1e2f4 +acf7ba01b0220419f09169ac8d16e5cc13dce08e88c90b8fdfaa33aab417f011a20b79a178d8a9f7211589d2e0affd7d +b404bde8e715aefbb9f20a353b911b79173ef3e2cf0aba98b5ae6190b90597d65043b0b4e014ad9ea6c77da2d213ea12 +97e3615d1c77a402253bb55da2d1cdf82de316cefffe42b1022c94b4818d6dc4a313731db85321c537914bdf716a875c +940e950b96a4096a578c6874d747515936652b9b113a5f27f5a834a610867b05f9881e2679b0b289b8527baa0009b6dd +8de15a13ca236a3a285ce6e6826c502ae7365bbe468b6e8ac67b15b0bb49be0e996f1eec81ef69e4b7f54f8e4779a054 +a12244777eacb08ecd42b5676b3a51153022ab97e9353ace0f47c6054c22de9ba60d2a60f59a36841c2a791cb1b7c288 +94f7580203e39a2642ee2e7c969b9911f011d7f3a90c398e1302d26edb3df03df1d0c43baa1c6cf90dde95296d49e742 +82ead33144aaecab965faf63af384565992f38fc1066e71e33d53f43ac93892e27fe78c4eaca1cccbc53364e26ff31e9 +a0c129e9706d354249a7f8aa664ccd7ede89aa1445c5547410814b56d10dc086720953363ab1da8ff5f1ed5d8e575104 +93b3057bf3f74edc95237781ae012cc4b1d3fd0455565ceaac7110290aa518ac32478ba4eb9851555fa87270fcc84f1f +949c2fd0b94f31f7cbf00c679bd3f6ec1a2f4056654708d39edf1a450b4e19a6e251d0bb24eb765087e698f61d3fca2c +99fd2e50e211ccb66b895eb2fc42f260f3ad5767f04c2fe238b81dae98aa6e3977443a51f4fe7b43f499caabe45699a5 +84fe19626503218f327b5325bfd7c0c3d2614b47d34964aa0259d564e769c6c81502132cc1765b0b31fbe39852706927 +b43287ec29d9010bec4284de58fed48dd1e129bac79f09d45153c9949131782f77b11b0c9f8ee06a39e5e9bbaa8e2c6d +908902f3ed45482df2f94415fc8e5a308057a40c8905d7cbbd58ec4848e19276577b7f7e69e5e684a8b981738e10f7ef +85cc7d9c1eae372b4f88758cd6e21604b4bc9f0794e1e74b6d9de96347f81944d01331385fae7a38e5f6096c1dc23465 +af60288c702082fc258b3dbd6952c6b75c1641a623905f491b1e72f49b9d39b33d150a336450abd3911a4c128166acdf +a7d8ac7e589558c4014369ab6f4c1f2196205b03e4278152ec0dbbd7ba54e803c3369a71d364a773aac8dbbd117e4a13 +9833aed34e48c206e9328073597aee1123f5bec085339b4e6839a389a429bf3042798a31fac1464ce963204adface76b +84631a4f012bbb62133030224b57deb32dcf464cacc8ffde7775adbe68707263ab5527a1c75e597e03aa703ba658b889 +a686a61f6467858a2a4c13e70ad81b1901290d3e51bbc0c6e366f9e652f575e91b11c75f640ccef8b0c6c1b05a43c9a0 +b585f0ffd5144907703b41539bfad7f9f058f5985f63db911064ba6b07af8da2796b84b16db42b8d11135c3f846cd9e2 +b525539516c7bb25f1d7e165f269dc8c9eedbba74df44887e178ab8fd798e2a31f39812ca922d6b64d91564f14012a64 +91e480d7568fd2fae39c35b0a8d623e66a3160fee1dd4e9097255004938b11ac1cd3918dc6a1e5fbcb700c95a547e5e8 +936ef55c69b842b6177de71fa48dc5442bf5132116b214302f8f242ca36a273a6bbfbfaf373777104dadbe8e7da5e970 +8e950c0f6688abdff8a3b8bd77be6da6f2565c7b55711f5860ea62a3ab1d51aac31821c602bc11a45e33c69e7dde3ea4 +90eed4595104a0527f8db1e028ff622ff70db4eae99cf47f6c2a0246ec7b103570a6a9a877e32e9647cc74969006743d +b756344f6c4ea05b792e416d9bd9ce9dd4bd904e7622761f28a85628506bfc9d88a25e5f04db62fad30a92fb1d8d8556 +ad79ba76534c1a02ac3e9b7308d390792984cd75b7e1d0e5e4ff123642d99d4ea1825643091aa8117336333c40d5bd94 +832b08144887de0c0341d84f6945450af8d7a4eb32367d7703118186c1be525df9382ce61fed5f3b65a0bb3449185f7f +a322fb944e46d8e47994820890c94af423674716da810ea1da71e0a7733ad72c22114ca39a4b59c98ce4291a5684c154 +b982851a65140dbea79bd3b5487e236feccee051deddcc17c2853032efca289ddb6eaf64be3dd85a73012fdbe9d2d4f3 +8eed5e230e201830b44b9fadca4e156fe1a16bf840cf29da0f381ea0587b20c226de2465c67e6268973e776809af68e1 +81c8f1c04490f36e41a53ee1b5185cb8adbb37c258fd6c3be8c56835bf574c37183a94d55b6554fca35d6e6dd9af0133 +8c4928724107cc16d36f2976677eac0b852fc4c3c0bb2f9cd4d59cd24a113faf33b2faf405c3fcce25be51d41e42c2c4 +8e4ba842636fdfc4d71f0983538ea5037d420acd26abd12efca48c252eea85544b2fa9fccdfec4e7c2a6359baffa112d +b4315b84700e26dec26f3488d308430fdff4809c10d4c24309627911cbb769ffaad0d1ecccd622dd02194eaf5ba59f91 +ab888308f757faef32648c1db01650dbc9aea248b09d06e6efcc996d395f48ec96f2d54a02de441d753fe8737862d991 +805094cfd77e207d5c75f3cad99f41f763ec15443052cfd758c6a82ba422d831a1103a7f9b100da49c28198279c3d3dc +ad857f33243e4a2cd2a773700def21fc7f94939d1a6d2c2125ecd58fc206ccafb07a2c02a1cfce19857d3654aca2c70c +a4d12d40149953daa70b89a329e918e9d93efb4e8004a9357fe76682dab9662c8507e16db83e849340f05cdb4933a373 +a0dbac2ed4b5d03606524245e8a31080eb5bd3e9a0c51dad88c3b18e3e6bc5d64953a81c8e60425b80107ee6b62b1fb4 +86da05355900f327164a78901f6e3db857531b33b1e855df1a67a9ba222c6b05fdb6b0ffbacaeb1ba5b45ff8979b6b68 +932c9873aa3e226dd922b5a616c75153bd0390ce8f332a414b9c8cb6606c2501a37a2aa88097bc7d8e2c4261706eb38c +accd9cdf07ccdd42033ce3b105e00bfd39e2304b1e3d66f8b1128645634452c20f759ec45adcef2fdf04408f62c4cc04 +b75cfdfc1cb48918752eab17eb579820ee6e71e6667abdb64df834ffc8c1362fbbc23ca2c80dee248fe1fbb72d87dfc8 +88b998c73b00638fde7d3dd650a08c5ab996dac6ac34251337fbff3fb5ae4a25dd20c1a16c987ad7ded19eca23cea891 +8afef0956c942571a27f504553fb312cca9e50ce41b44e0466d0516c5abe4d8acf4594cdb03b1ccdbe3f2e6a9093b713 +9042cd83c5ff261e9ebda26398caa16cac2cb840d19062fa8ae50e044c27104972948318f4c866dc4d578798272d3e49 +ad536719a64570a2cd1d72b6590ea1d02c8c49f259a7867be26c8191445165954bcfad50ea12688ace3fdfb0e98143bd +97c86328d63d297b6bc9718dc1ad5a05b908a750d1c455c700d84315589128ce4eea958aef2bcf0fcf4adbd8e3ce58d1 +8e592cf0802e6a9541eeb654dc55055e11f3d757847285197132935ca35bbb1a9156829a39384dfa6f645ff89eb36738 +ac16c614998944f77590bf3913a010e13f2d3bbf6a172293baf5983506c1a2d89989fb72e598f5bba1ea10a691377c93 +ab8e6f5b46baa6632de3621497bcbdd584decb999fe7d8a3364843a1e0b76497600630b6a24dd30119d8bcbfca29f335 +abe1d3af5279e60122d9cea8cc6581c819d7a0e20e3715da0f6da7e02d13a7653db643bd946e2fa9ba338eca81fbe140 +8c33bd831ecfb18d1d0713e16beba768e9c42df62170c1f8a16764912be77f2ac5915623d1d25e8c462aa9c2f6669ca4 +903692becae4a6409f7bdb127d9b11de57a5739fe24218dcbaa0092648d5332dfeef29a908ee9e43e5e0a51a4c3639bc +92591e90347ae286acd365eba32cd9ad8f20f4c9cad2dc579b195147ff290adf0d776bcb3d4b04a25d68a941fc0c781b +b64bbccf860299aec16e1f95c768a1f337c740bde612e6ba260e393edb8b04540127194761c42597abb9bcb771c576c3 +9194f056ccfdfeb78a11c5347e2255d7a7ebd1251f9aebc0b58feb68d3e03a7dbbb74e3ef7309455853adfb4694bd01a +aa4f15f6d6a53ae65b7f6f91e8981d07a5919d2138679a561f7bb608dc4596e45ca06c9441d51fb678b2ad89ae7a17ae +90e3d18507beb30bde08c5001faf489a19ab545c177efb3f73fbf5605f9a0abcdc8bfbc44f832d6028e3e0a834bea98f +8f31dc0118c8c88a6e79e502d10e57652b7aba8409a5bf572ca63fed6b7cbad7f28bbc92ac2264f649792fc1d0715085 +a307d1067ea4c56437b6f8913aa8fcbf4a24580fc1e3336e7f6518f0f3adb9c4733090e459a3f737414ec0048179c30a +b7cc41fdf89595cd81a821669be712cd75f3a6c7a18f95da7d7a73de4f51bb0b44771c1f7cd3cd949e6f711313308716 +a9dc74e197fe60e8c0db06b18f8fe536381946edecdf31e9bd90e1ebfcad7f361544884e2fe83c23b5632912ec284faf +8b3e1e81326d611567e26ed29108f33ddb838c45bbd1355b3ae7e5d463612af64b63fff9fa8e6f2c14c8806021a5a080 +92f6537bca12778866335acc1eb4c3dfc2c8e7e5cf03399743dcea46aa66cac92ac2963b0892784263ad0ebe26ffdbf6 +b5cc0061f7a3e41513199c7dd91ac60d727366482a4c7328527f7bd4fc3509412f711bb722b4413b3736a219b843d15d +b3e9711d68d2c6f6e2cc27e385d5f603d9a1c9a96edeefa1ffdf390439954d19504d6aadc566b47e229ad4940ef020d2 +a09d0d3f0e5dc73a4a0827b72710b514bbfce4a7fcd5141d498a5aad6c38071077f50d3f91af897d9ab677b7041dedda +b177fe260f3b86e9ac21f1bfbe2682ae5dd8c9aecebb84f37054bdab6e39094e611ce582210ceeddde66adf759dadb6d +b0ac6595eba9f5dc4b2fd21856267cfbcfb5b12aa34ec69ca32b80071c5b652e85c25a224d80443d503bf25fbbfe07e9 +81f3c0e11b196bd4a2e8f07f8c037002566dc9037da81f3988add458a520c24dd1be3d43d851e28c0c6a85de4b57a542 +a44308c95615f7fedb2d2127012924468c015df9f48359cc2e36ab4223870b0bfc1e9040baabefdf5266f93afaad896b +8493ec4c32d5a13b81039f1b436eb83f259945dc950e3c6c2ccf5087ec56dd2f60890ed4edf01728b6a54950e19b35c6 +a1a439ec2a6a95bdac9aaa925ff337ba956c0d236ab5318354270e73ed6b73b4ae2d27b4c1686cf97b6526d04e65be81 +b4659b7b53c55a4b2bbe210b53520b392f893500e18990d843b72d7379d45fb44dd1dd2184348d6fd853d6b9ecc6b7c6 +afb2c68d75d00130b0e1b4f250001920213121791698ec04262db714cf7b1408d39f6cc10421f954845aad5b8250b77e +b22b843b40a97210f94043b552f348f66743055a3f274856a738e7d90a625b80e9bbb80cbbb450e1666eb56b8bd5c60f +800895ced82fe13d5fff65a93b0051c3df698bf1221b682accfdb63e3970f669ca37025750697f4e8ff2a3322ad57be4 +b21f598c50d7b9f4a584d548f85e42055ef8e24991906d973749090261584c7f4f5e984b528926f7e75375dd84d51af8 +849b1c68192d18274598dd6d0bf48fb5ee3b1ba25b331cff2d06f345bef3bed49760ca5690848cf33388f6a9a32cd646 +aeb6fd9478b10ef456f6bbb1e6dd19b14475e65497772d12cfc097948383d3fbd191bf95f046b8bf1989954118e483d0 +b1b5e0ea2835f7fc8b66e7731e392b43d16cbce04b52906b6751ab1b91978899db5fecbdabc23a19dabb253005468136 +91b6b1284770cf6f7ef35bc0b872b76c7763ffcfa68f9c8cfabcb2f264a66d47598bb9293f6a40f4c3dd33c265f45176 +b9ffed029846487c2cfb8a4bb61782bd8a878f3afdb73c377a0ebe63139fa070e3fcdc583eec3a53fdc5a421ff1fa877 +998007249d041b0b40ff546131cfc86d0b3598dcedf9a8778a223f7ed68ba4833b97324cbb1de91292b8ff51beab44b3 +8eb77ce9e0e406bf6f002870fb2fd1447646dd240df9bd485f8e0869298a1fc799d8a41b130c04370e9a9cc5c7540ca5 +853db8157462c46f2af7e8f94f2ed1c9b9a7ba2896b4973296898ff3d523d6e29e0b63a5d26cecd5e490b33c87a4cecf +b1436b6f3278768f0979ee852944258f2599977d255bea6fc912ba17c5dff5bdc850cf3e1fc52be9d6d188e868670f4f +a76acbc5832019b3b35667ab027feff49f01199a80016620f5c463dfcbfb51bf276ed17b7b683158ba450660cc7973eb +94540cdb051faf3ae8b8c52662868c2dab66bd02505c4f5f8eb4d6b2e2e5fd9a610890c5dcf8fd887eee796d2b5753a8 +aa35099666bceccf4eb3b65b13bba88e30a8be93693ab6761d8e5523343e8d6dd42d977e66499352fe4e9e9784a1dd0d +894471aad17be54319083c4b5e40adcfacf7c36c4aab0b671030b7ef321c53590a25eccd836efd20f32a93185fd315bb +8f52a9f705bb0dea958fcfbd52e2b6c08ad0f89a07a6b2942c1b4c37eead0d97a38a9e9aeb08d5d59b7fa2a9347f738b +9031c16b4f936c9cab55585dc5064739f696c3347ee2c0792320c9f749e760d120e396e8485ffc79d81c9f3337ad3d1c +82090a0d0d9b05459ec1c328ecd4707c333b784e3aaa0ef0072cee1eac83f9a653a75d83b9f63512a8c41200494826b4 +92c3a9553001f9ea4d67236b8ad1a33275378202cc1babc03f313895458f4b2549bfbbbdd37bfb8fbff0decb6b9f820a +88651868f4da37338a22bc553388df5dd1dd0cb78c4d7d07c637d8f6faef4bed72476fdcd4304d5bedf3514011135f08 +83fa0141bfebd88063f1d787719721b4c6b19ecf565b866de9d7d5d1a890e0e3d859b364bb65f8f8e688654456a40263 +90a7fab753e5d56dfc0e53a6b4e6ab14508220f3a62b3f3f30570c4c9ad225e74122635826c92e8e3227ec45e551432a +8fa375b0345bf6e5e062d108f9feaec91029345ecac67ccf1264eac77b8654cbfdda1f10579f481889c0e210254eadde +b83f06116da9daebdb013b26724523f077debaf6bc618b48a7a68858a98d275f7899c4ec73a0a827219b9248dd81c8c9 +8be1cada55e0c5ebb4fd460b2d209ae5326285a20c8bdd54ed9d1a87302f4063c8730bfda52d9d40e0d6fe43a0628465 +a68ad6f813743ec13a811f2ef3982c82d9d9ac1f7733936aa1e122f8dc7f4a305cc221579ab8fc170c3f123a1576f9ab +8878f1128214fdbbb8a0edd85223741e021508ab6d36c50d38680f2951ee713ea056ed03f62b9461897963d50ceefe0b +acc0d43d1b0260528b7425b260a5dea445b232b37240759fc65fe26f7c9d8e51569c5722bc33e94de6492f4ba1783504 +ad80b1dd717b076910ee5ceabcb762e75e4d094dc83b93b65c16de1f75bc712cef223c05d5579c1561829406c07a97d9 +a6fc9803f9c09d95fc326cc284f42ea5566255eb215dba8a9afb0be155ea11bcc55938b2d16f01cd2f2eda218c715efb +83ad733dbdfbaae8095a403dbf09130513f4ed4f08dcf8dd76ce83d1ea72999b7eea3a7b731da0d2bc80a83c6ee0e3e0 +8748912fbd08cb34a85416b0937d9c4327e9eed20d6e30aeb024a7253f14f1e0d774f3326e54738d71aae080e28da0fe +8997e78d8acf23051428af67183ae9b2c4aa42b503745ffe33df35a35103c589987e1473ab14dcd28ee78ebcb10d8e95 +a2f340502a7eb3c4a36412e6f028321372c4fa18a4743945607424e932af1271fa3e6598a162c872072529576eba6283 +868ccf19b5044ab93b45c9ed3ae34fcb504fe1453d6c4a1d12c325032cf01eb90356de82080ed897e97dba13cae33a02 +ac8867005fe4354d67aa37b866a7e581d2f94f7bd0b9f4efb5c2d1370ec13147a60692051b02fd00ae60b512bce9b1ff +8fd01886b046819c83c12bb779e432b25ba13713f9227be702074ec3abb2bba6be37220a0a26a4bd4171b99b14e32bc4 +a128981ed199f92b5959975c150a93a62fec50b61c80a3fa0634d90fc8058f76f5cbee77aae6889af12d296b30e613cd +81fe618552ff7a36c9235c6d4066cf2f930b5b38de4089e18166e4a06ca5723eadd1976d25e34b74b3ce942300b23e5b +ab1223ea049e6e0fbf9b611de7fd7c15e5e9637cbd73aa0e36aea08a7503ba6804f2aa807186fdc9aa7f4f9195f72e24 +b97285286981b2665f898abc13f3243b63005bef8db4cab3f658bf6167036b61af400f08db0fc3c640a9c623b760690d +ae3ddff7c1f0fbb6a13dbbc667a61e863c2c7c51c2051e33cd61620142e7e30a7e0c4c1f8fbb512aa3a8640267c6ac26 +99c2a89d5bef236060e51c4f952664094c20fbfca647e5d24a55c1fb8df2f3df58244fbbf3635db07b1c29ee3234fa6f +a5010764d4b9cd3b410638334d1f70c5f4843f45b4f4a9316aaea5fbb2c510a97449dd7a07b49f47334a69d37d9955d3 +86706d011dcdc9e9d165d01fea1df68dd74bedaf15a39f92893c030cafe96f4498c4c1fec2d2136354341b3f440a1462 +88fd57eb62bd7dc35722f3a0576c2138403a2f663a2603482e8974a895cf56ddbb02657dc6b89eb2cf5c1f9d1aff6426 +b0dfd4c68e3acb6bb8a776adaa421fc5e268ed4d5964bb90a727091e5113b55b3f9c6d33cedb3ee47ff7acc5df8b1749 +93b92bc942e1a636fc5c2dc1840de5faf158a113d640d5a475b48e2c56ccccaf9db0e37e90ce74c4b3f5c9ac3b2eb523 +b29a16fa1ea95cbfc1873c435ad40dc8495ba6341801b72bd95d908147dcffb1b4bb426dd635f3af4c88984f56594dd8 +b8f367105e1a2d554ac30200c66aeb579d3d30a8953d20fb6ebba2d876ec39c52ea5d654f1bb89b8ddf3d9d651f31cdf +b5fbc228c983d08adf8612eba5b3db3acff604439226f86aa133b02cce4ffde2f977c8dbb8b446b4375673f71634c89d +a399bea37d3056e0559f6644faa0af93063b4b545d504d7e228d3dbbc294af83d3c4cf37fe026b63899b4e7d50fd08f5 +928ef411a36414b24aea26fdbed4bdb1bb6bdc2d967e2553ce54c7c4e077e76869cea590257645c9129dd55ce025295c +9684a4adeed416a9ce82ad79b55c4a3adcfbd43950bc442ed8a340381caedb70f4baaaf821e3a152f483f965d8f56162 +92558a37f214d6f4cb6d72cd2f4ad24dff9d17611b9e4a41ee5c741a5d1ca9e4053b0584533ef4da206110b5dc3e2a35 +973bf0724d1785cc5e85d2a8ee8c354ad4cf557217ced0b7940f6f064024c20b2bfc5b144c820b5083da4bf70690de4d +adaf1389dfa528210ca9c2657c5ff10d51f7e3b18e93a59c37211be0506c3576cb2c04ec80cd0f82605e53c5a3556620 +85b58b223b09fda6f3ab674d75e780c49eb2167837243df049281e8f4fed653811138b398db9cdfe7405fdb8485602fe +849504d3db408d80745a07e850b0a804607b91a59922a5d3bc40da2748c029c029419cda38d2a4485cc0824c6b2504f0 +a3f4afcb353bc2582a02be758ebf0cd18752410ca2e64231176bfa23828423e0a450a65f241a9ed8eab36cae8d9c567b +ae362786cdf121206537af9590d330abbc6dc328b53cdd145dbed0e5df1364c816aae757c4c81f9d619e3698dd32bcdf +9024cfa5b0101eb02ab97866d5a3832944e5aa6888484cfba3d856576b920787b364fba5956bd7c68a305afedc958201 +8a116df09fed923acefb2aecf38a4fbc4b973ee964d67f03791d70bee6356af43ffca117d4e9463ffaf0e0d5d5e5a69f +9163016175c73f1bbc912ddfe03bd4e1db19c64951c8909ee6befe71a1249d838e0db49f03670bb4c5c9b2ab0fb4fef3 +8f6357318d8d16e7240a02b05ce5a4976b6079d49daa258789c6dbf4a47950ebe9de6411780fab06c7c1f35651433380 +8e63cbae8be7341892dbedee3111adf0307c4ee9e375181aa53478f5ba9cdce164d6ae890e5f480119a3a51c6e989165 +a9782f30674a4874d91bfba7eda63aeb5dbe66b040c768d6a925d8ee135f0655ea56276b105239cc0668fc91ddb68cd1 +8d9d94b61ab84ec08665cbe0244ea41756785df019e453ef078c19380bd44c39d2958e8465c72eacf41eed5696037805 +b1470e6f5d2e314474937cb5a3bc30c8bf5fc3f79014945f6ee895fe20028ffc272f9d3a7320aac93e36c96d8a5454e3 +a444911bbafc71179766594f3606b6eaff041826607fd3192f62dec05cd0f01b78598609a530f6930e8440db66f76713 +a9823d44e2638fca7bcc8796cc91c3eb17f46ad6db9f7f6510e093727614aa3a4f9b2c4011ef91dc1c2d224d08d8d05b +ab86020972c359ab98294212558b4b14862040139876c67fc494184b5c9bcea1dbe32fe0c8dd9e60be9daa304acd599a +b7e5cb685bbdcfdb1e48259a5d68d047846c8a35c5b3f90172fb183d1df40d22eaf0edaca2761a07c29c577000ccfed0 +8c88319dae4b28989817e79e6667fd891181e8d2ed91b9c6b614985bca14b12982462ec58b17be0463c24bbb79dd62a1 +8c1c6867e7107fb2178157c991b9c8b0f90c8d57a51220bf3650438ccabccf62da4db8a9916491e730ff3d0c106496e3 +a00a79bd58da6528b9af033087260f9f3d00519eafb4746b355204ee994e89481591b508eaa5402821083e250d38467b +8785abd7c37690f6aa870ee5c799eef72e398a7898b6767f698515be277b9c2fc1af12ea89b0620a848221343a3b5ec3 +8aadae68543db65cef71d0e230a09508d72061398ef2fabec0f856aacff2125b79c70e620744aaf331faf3dfc8afb9bc +8ff0cd437fcad9630b8a2333176a55e178db4142ec841581590594d74d5b53baeac5fb903fdf7bcf83e245b95b58285e +af274e8fad6b190be4e5dc92d2705ba6ac0d7e1ea29e958a5cdd4cb764de46a56d9eef62c999a16e7c50a50b2d9fe3a8 +865e6ec7d1aa848786d6a7a4e87a24d442311f0810b01ef5a74928ab59fdfd651e48880b49680047e5b0df6b3c7c2ecc +800706baaeb35bf3bc33bdea9a8b5cb00d82df407b3b7e1b781a9359cf44fb410ed311591080181b768aae223d9246aa +a9496389d0780b309c6998374ae159f58a8d0fe9a1c24c36cebcb45b27d818e653b51a8ee1f01e30a9b2c46a548126ef +b5fccf4fc3186661939fbee2e89c2aa0e3a6ad4907bcc98c7750520540c4c183b1bbfcdf47f2f1c5e75c3a30cdf30c75 +a90028e39081b736e628c2230cc1338f9210ed01309a40fdf08d39c10cced2cdf71271013bea6dba3a0444fe47963106 +a0815cbb325a8fecf2e1bcc5046644be32d43a8001bd5d8cf0022e4572cd0d481b3e717002f7ab21e16da5f5d16886d6 +b2024787fcda52abc4138150f15e81f4a5be442929b1651ddccbfd558029912be4d61c3c9b467605fff640edf7392494 +ab5aa60032304a584cc9245a33f528eae7157808dedd1ad83ebae00aadc25dbe1cd5917eb8b6b2c800df15e67bdd4c4d +866643847ef512c5119f2f6e4e3b8d3f4abb885f530bb16fcef0edb698a5b0768905e51536283925b6795a5e68b60ddc +806aa99c9a46ee11cc3ebf0db2344b7515db8c45b09a46a85f8b2082940a6f7263f3c9b12214116c88310e706f8e973a +a6eada8b9ff3cd010f3174f3d894eb8bb19efdbff4c6d88976514a5b9968b0f1827d8ac4fe510fb0ba92b64583734a1e +98480db817c3abbc8b7baedf9bf5674ec4afcfd0cd0fd670363510a426dad1bcf1b1cb3bf0f1860e54530deb99460291 +81ab480187af4a3dfbc87be29eca39b342a7e8e1d1df3fc61985e0e43d8d116b8eac2f1021bde4ae4e5e3606c1b67a21 +8a37df12dc997bf9b800f8fd581a614a1d5e32b843f067d63d1ca7fde2e229d24413d3a8308ec1e8389bf88154adb517 +b045a55ca0bb505bd5e8fcc4cfdd5e9af1a7d5fe7a797c7ede3f0b09712b37f493d3fcf6ef0e759d7e0157db1f583c95 +ad502e53a50691238323642e1d8b519b3c2c2f0fd6a0dd29de231f453be730cf1adc672887d97df42af0a300f7631087 +80597648f10c6d8fcd7421caf4e7f126179633078a1724817d2adc41b783723f302eabc947a7ba7767166dacf4ce8fa1 +aefb56427966c81081999dffbe89f8a0c402041929cd4e83d6612866cfbb97744f4ab802578349fbecc641fa9955e81b +a340e493fb3fb604eab864d4b18a6e40ba657003f1f88787e88e48b995da3d0ab4926ce438bdc8d100a41912a47dace0 +a6d777bfc0895eac541a092e14499ff8bf7156689d916a678b50a1460583b38e68158984bea113a0a8e970d8a6799a85 +90ce469410f0e8cfff40472817eb445770833cdcf2895a69bc32bcf959854d41712599ceb2b0422008d7300b05e62e02 +815c51be91d8516d5adc2fd61b6600957ed07cf5fdc809aa652b059bea8ed179638a19077a3f040334032f0e7900ac8b +b3ec6c0c3c007c49c6b7f7fc2ffd3d3a41cdff5ad3ac40831f53bfc0c799ffeed5f440a27acc5f64432e847cc17dd82e +823637abeab5fb19e4810b045254558d98828126e9a2d5895a34b9e4b4f49ab0a5b3ee2422f1f378995ea05df5516057 +ac05412bcf46c254f6548d8107a63928bba19ab6889de5d331eb68cf4d8ce206055b83af4cb7c6c23b50188391e93f84 +88514163c587068178302bc56e9a8b3ad2fa62afd405db92f2478bb730101358c99c0fe40020eeed818c4e251007de9c +b1e657d0f7772795b3f5a84317b889e8ded7a08ea5beb2ab437bebf56bcb508ae7215742819ed1e4ae3969995fe3b35d +a727d4f03027fe858656ca5c51240a65924915bd8bd7ffa3cfc8314a03594738234df717e78bb55a7add61a0a4501836 +b601682830fc4d48ece2bdc9f1a1d5b9a2879c40c46135f00c2c3ae1187c821412f0f0cfbc83d4e144ddd7b702ca8e78 +b5cfea436aa1f29c4446979272a8637cb277f282825674ddb3acac2c280662fb119e6b2bdd52c4b8dbf2c39b1d2070d6 +85c211645ff746669f60aa314093703b9045966604c6aa75aae28422621b256c0c2be835b87e87a00d3f144e8ab7b5f0 +867628d25bab4cb85d448fd50fdd117be1decdd57292e194a8baa0655978fae551912851660a1d5b9de7a2afbb88ef5c +a4e79c55d1b13c959ff93ddcf1747722c6312a7941a3b49f79006b3165334bab369e5469f1bddebadb12bfaff53806d5 +ac61f0973e84546487c5da7991209526c380e3731925b93228d93a93bce1283a3e0807152354f5fe7f3ea44fc447f8fe +a1aa676735a73a671a4e10de2078fd2725660052aa344ca2eb4d56ee0fd04552fe9873ee14a85b09c55708443182183a +8e2f13269f0a264ef2b772d24425bef5b9aa7ea5bbfbefbcc5fd2a5efd4927641c3d2374d0548439a9f6302d7e4ba149 +b0aacdaf27548d4f9de6e1ec3ad80e196761e3fb07c440909524a83880d78c93465aea13040e99de0e60340e5a5503cd +a41b25ae64f66de4726013538411d0ac10fdb974420352f2adb6ce2dcad7b762fd7982c8062a9bac85cdfcc4b577fd18 +b32d87d5d551f93a16ec983fd4ef9c0efcdae4f5e242ce558e77bcde8e472a0df666875af0aeec1a7c10daebebab76ea +b8515795775856e25899e487bf4e5c2b49e04b7fbe40cb3b5c25378bcccde11971da280e8b7ba44d72b8436e2066e20f +91769a608c9a32f39ca9d14d5451e10071de2fd6b0baec9a541c8fad22da75ed4946e7f8b081f79cc2a67bd2452066a9 +87b1e6dbca2b9dbc8ce67fd2f54ffe96dfcce9609210a674a4cb47dd71a8d95a5a24191d87ba4effa4a84d7db51f9ba0 +a95accf3dbcbf3798bab280cabe46e3e3688c5db29944dbe8f9bd8559d70352b0cfac023852adc67c73ce203cbb00a81 +a835f8ce7a8aa772c3d7cfe35971c33fc36aa3333b8fae5225787533a1e4839a36c84c0949410bb6aace6d4085588b1e +8ef7faa2cf93889e7a291713ab39b3a20875576a34a8072a133fed01046f8093ace6b858463e1e8a7f923d57e4e1bc38 +969ecd85643a16d937f148e15fb56c9550aefd68a638425de5058333e8c0f94b1df338eaab1bd683190bfde68460622b +8982f4c76b782b9b47a9c5aeb135278e5c991b1558e47b79328c4fae4b30b2b20c01204ff1afb62b7797879d9dee48e2 +b5098b7ba813178ced68f873c8c223e23a3283d9f1a061c95b68f37310bca4b2934a3a725fff1de1341c79bb3ba6007e +97b160787009f7b9649ed63db9387d48a669e17b2aba8656792eb4f5685bb8e6386f275476b4dfbb1b4cb0c2a69bc752 +88b69369c71daad6b84fa51a0f64a6962d8c77e555b13c035ad6fa1038e7190af455b1bd61ae328b65d6a14cf3d5f0d5 +af88b87801361f0de26bd2533554ee6f4d8067e3122b54161c313c52cc9eafea00661c5c43e2d533485d1f26da4e5510 +98ab18e3bbcb23ac1e34439849e56009bb765ab2f2558ebfd0a57cbe742169f114bceb930533fb911b22cb5a8fe172bc +9027507f1725d81e5ac0f0854c89ab627df3020fe928cb8745f887bf3310086c58fca1119fd5cd18a7d3561c042d58de +a676583f8a26e6f8991a0791916ce785b596ce372812f5eb7b4243ba9367ea95c797170fdac5b0c5e6b7f6519cc2b026 +b91b0ab32638aef3365035a41c6068e36d2303bfee8640565e16c9a56c21703270fd45946ce663238a72c053eb3f2230 +aaf4cd1ac0a30906dcd2b66b37848c6cc443da511e0b0367fd792887fdaf1500551590440e61d837dbee9d24c9801108 +a06f20a02d3cd76029baad5a12592f181738378a83a95e90470fa7cc82a5ae9d2ed824a20eeb1e96e6edc0619f298688 +a465d379c3481b294efc3f2f940b651c45579607cf72d143b99705eae42103a0279eb3595966453130e18935265e35d6 +892a8af7816a806295278027a956663ea1297118ede0f2a7e670483b81fb14dccacc7a652e12f160e531d806ca5f2861 +b480917c0e8b6e00de11b4416a20af6c48a343450a32ee43224559d30e1fecdece52cc699493e1754c0571b84f6c02c2 +b3182da84c81e5a52e22cebed985b0efc3056350ec59e8646e7fd984cdb32e6ac14e76609d0ffaca204a7a3c20e9f95d +a04ea6392f3b5a176fa797ddec3214946962b84a8f729ffbd01ca65767ff6237da8147fc9dc7dd88662ad0faefdb538c +95c0d10a9ba2b0eb1fd7aa60c743b6cf333bb7f3d7adedce055d6cd35b755d326bf9102afabb1634f209d8dacfd47f1a +a1a583d28b07601541fa666767f4f45c954431f8f3cc3f96380364c5044ff9f64114160e5002fb2bbc20812b8cbd36cb +a1a0708af5034545e8fcc771f41e14dff421eed08b4606f6d051f2d7799efd00d3a59a1b9a811fa4eddf5682e63102ea +ab27c7f54096483dd85c866cfb347166abe179dc5ffaca0c29cf3bfe5166864c7fa5f954c919b3ba00bdbab38e03407d +ac8c82271c8ca71125b380ed6c61b326c1cfe5664ccd7f52820e11f2bea334b6f60b1cf1d31599ed94d8218aa6fbf546 +a015ea84237d6aa2adb677ce1ff8a137ef48b460afaca20ae826a53d7e731320ebdd9ee836de7d812178bec010dd6799 +925418cda78a56c5b15d0f2dc66f720bda2885f15ffafb02ce9c9eed7167e68c04ad6ae5aa09c8c1c2f387aa39ad6d1b +87c00bba80a965b3742deacafb269ca94ead4eb57fdb3ed28e776b1d0989e1b1dba289019cfb1a0f849e58668a4f1552 +948d492db131ca194f4e6f9ae1ea6ebc46ebbed5d11f1f305d3d90d6b4995b1218b9606d114f48282a15661a8a8051ca +8179617d64306417d6865add8b7be8452f1759721f97d737ef8a3c90da6551034049af781b6686b2ea99f87d376bce64 +918e3da425b7c41e195ed7b726fa26b15a64299fe12a3c22f51a2a257e847611ac6cfcc99294317523fc491e1cbe60c4 +a339682a37844d15ca37f753599d0a71eedfbbf7b241f231dd93e5d349c6f7130e0d0b97e6abd2d894f8b701da37cb11 +8fc284f37bee79067f473bc8b6de4258930a21c28ac54aaf00b36f5ac28230474250f3aa6a703b6057f7fb79a203c2c1 +a2c474e3a52a48cd1928e755f610fefa52d557eb67974d02287dbb935c4b9aab7227a325424fed65f8f6d556d8a46812 +99b88390fa856aa1b8e615a53f19c83e083f9b50705d8a15922e7c3e8216f808a4cc80744ca12506b1661d31d8d962e4 +a1cbd03e4d4f58fc4d48fa165d824b77838c224765f35d976d3107d44a6cf41e13f661f0e86f87589292721f4de703fb +b3a5dde8a40e55d8d5532beaa5f734ee8e91eafad3696df92399ae10793a8a10319b6dc53495edcc9b5cfd50a389a086 +996e25e1df5c2203647b9a1744bd1b1811857f742aee0801508457a3575666fcc8fc0c047c2b4341d4b507008cd674c2 +93e0a66039e74e324ee6c38809b3608507c492ef752202fff0b2c0e1261ca28f1790b3af4fdb236f0ed7e963e05c1ec0 +b6084e5818d2d860ac1606d3858329fbad4708f79d51a6f072dc370a21fdb1e1b207b74bc265a8547658bfb6a9569bb3 +a5336126a99c0ecfc890584b2a167922a26cae652dfc96a96ab2faf0bf9842f166b39ceaf396cd3d300d0ebb2e6e0ebf +b8b6f13ce9201decaba76d4eca9b9fa2e7445f9bc7dc9f82c262f49b15a40d45d5335819b71ff2ee40465da47d015c47 +b45df257b40c68b7916b768092e91c72b37d3ed2a44b09bf23102a4f33348849026cb3f9fbb484adfea149e2d2a180ff +a50d38ee017e28021229c4bb7d83dd9cdad27ab3aa38980b2423b96aa3f7dc618e3b23895b0e1379ca20299ff1919bbf +97542cf600d34e4fdc07d074e8054e950708284ed99c96c7f15496937242365c66e323b0e09c49c9c38113096640a1b6 +822d198629697dcd663be9c95ff1b39419eae2463fa7e6d996b2c009d746bedc8333be241850153d16c5276749c10b20 +9217bc14974766ebdfbf6b434dd84b32b04658c8d8d3c31b5ff04199795d1cfad583782fd0c7438df865b81b2f116f9c +93477879fa28a89471a2c65ef6e253f30911da44260833dd51030b7a2130a923770ebd60b9120f551ab373f7d9ed80aa +87d89ff7373f795a3a798f03e58a0f0f0e7deab8db2802863fab84a7be64ae4dcf82ece18c4ddbefccd356262c2e8176 +a3ba26bd31d3cc53ceeced422eb9a63c0383cde9476b5f1902b7fe2b19e0bbf420a2172ac5c8c24f1f5c466eecc615d4 +a0fe061c76c90d84bd4353e52e1ef4b0561919769dbabe1679b08ef6c98dcfb6258f122bb440993d976c0ab38854386b +b3070aa470185cb574b3af6c94b4069068b89bb9f7ea7db0a668df0b5e6aabdfe784581f13f0cf35cd4c67726f139a8c +9365e4cdf25e116cbc4a55de89d609bba0eaf0df2a078e624765509f8f5a862e5da41b81883df086a0e5005ce1576223 +a9036081945e3072fa3b5f022df698a8f78e62ab1e9559c88f9c54e00bc091a547467d5e2c7cbf6bc7396acb96dd2c46 +8309890959fcc2a4b3d7232f9062ee51ece20c7e631a00ec151d6b4d5dfccf14c805ce5f9aa569d74fb13ae25f9a6bbe +b1dc43f07303634157f78e213c2fae99435661cc56a24be536ccbd345ef666798b3ac53c438209b47eb62b91d6fea90a +84eb451e0a74ef14a2c2266ff01bd33d9a91163c71f89d0a9c0b8edfcfe918fc549565509cd96eed5720a438ff55f7f2 +9863b85a10db32c4317b19cc9245492b9389b318cf128d9bbc7ec80a694fcbbd3c0d3189a8cad00cc9290e67e5b361ee +8a150ee474ebe48bdfcac1b29e46ac90dcded8abbe4807a165214e66f780f424be367df5ef1e94b09acf4a00cd2e614d +a6677a373130b83e30849af12475e192f817ba4f3226529a9cca8baaefb8811db376e4a044b42bf1481268c249b1a66e +b969cbf444c1297aa50d1dfa0894de4565161cb1fc59ba03af9655c5bf94775006fe8659d3445b546538a22a43be6b93 +8383167e5275e0707e391645dc9dea9e8a19640ecfa23387f7f6fcaddff5cde0b4090dfad7af3c36f8d5c7705568e8d8 +a353ddbc6b6837773e49bb1e33a3e00ca2fb5f7e1dba3a004b0de75f94a4e90860d082a455968851ef050ae5904452e0 +adeccf320d7d2831b495479b4db4aa0e25c5f3574f65a978c112e9981b2663f59de4c2fa88974fdcabb2eedb7adab452 +afa0eacc9fdbe27fb5e640ecad7ecc785df0daf00fc1325af716af61786719dd7f2d9e085a71d8dc059e54fd68a41f24 +a5b803a5bbe0ca77c8b95e1e7bacfd22feae9f053270a191b4fd9bca850ef21a2d4bd9bcd50ecfb971bb458ff2354840 +b023c9c95613d9692a301ef33176b655ba11769a364b787f02b42ceb72338642655ea7a3a55a3eec6e1e3b652c3a179e +8fa616aa7196fc2402f23a19e54620d4cf4cf48e1adfb7ea1f3711c69705481ddcc4c97236d47a92e974984d124589e5 +a49e11e30cb81cb7617935e8a30110b8d241b67df2d603e5acc66af53702cf1e9c3ef4a9b777be49a9f0f576c65dcc30 +8df70b0f19381752fe327c81cce15192389e695586050f26344f56e451df2be0b1cdf7ec0cba7ce5b911dcff2b9325ae +8fbbc21a59d5f5a14ff455ca78a9a393cab91deb61cf1c25117db2714d752e0054ed3e7e13dd36ad423815344140f443 +a9a03285488668ab97836a713c6e608986c571d6a6c21e1adbd99ae4009b3dde43721a705d751f1bd4ebf1ea7511dfed +b2f32b8e19e296e8402251df67bae6066aeefd89047586d887ffa2eacdf38e83d4f9dc32e553799024c7a41818945755 +942cf596b2278ad478be5c0ab6a2ad0ceafe110263cc93d15b9a3f420932104e462cf37586c374f10b1040cb83b862e0 +aaa077a55f501c875ceae0a27ef2b180be9de660ef3d6b2132eb17256771ce609d9bc8aaf687f2b56ae46af34ad12b30 +90ac74885be1448101cf3b957d4486e379673328a006ea42715c39916e9334ea77117ff4a60d858e2ccce9694547a14f +9256cdfc2339e89db56fd04bd9b0611be0eefc5ee30711bcece4aadf2efcc5a6dcc0cfd5f733e0e307e3a58055dff612 +a4c7384e208a0863f4c056248f595473dcde70f019ddaede45b8caf0752575c241bac6e436439f380ac88eee23a858e9 +a3aa67391781e0736dddc389f86b430b2fc293b7bd56bfd5a8ec01d1dd52ed940593c3ad4ce25905061936da062b0af6 +80299275ec322fbb66cc7dce4482ddd846534e92121186b6906c9a5d5834346b7de75909b22b98d73120caec964e7012 +aa3a6cd88e5f98a12738b6688f54478815e26778357bcc2bc9f2648db408d6076ef73cced92a0a6b8b486453c9379f18 +b07c444681dc87b08a7d7c86708b82e82f8f2dbd4001986027b82cfbed17b9043e1104ade612e8e7993a00a4f8128c93 +af40e01b68d908ac2a55dca9b07bb46378c969839c6c822d298a01bc91540ea7a0c07720a098be9a3cfe9c27918e80e8 +abd8947c3bbc3883c80d8c873f8e2dc9b878cbbb4fc4a753a68f5027de6d8c26aa8fbbafeb85519ac94e2db660f31f26 +a234f9d1a8f0cb5d017ccca30b591c95ec416c1cb906bd3e71b13627f27960f61f41ed603ffbcf043fd79974ec3169a8 +835aaf52a6af2bc7da4cf1586c1a27c72ad9de03c88922ad172dce7550d70f6f3efcc3820d38cd56ae3f7fc2f901f7a0 +ae75db982a45ad01f4aa7bc50d642ff188219652bb8d521d13a9877049425d57852f3c9e4d340ffec12a4d0c639e7062 +b88884aa9187c33dc784a96832c86a44d24e9ffe6315544d47fc25428f11337b9ffd56eb0a03ad709d1bf86175059096 +8492ca5afcc6c0187b06453f01ed45fd57eb56facbeea30c93686b9e1dab8eaabd89e0ccb24b5f35d3d19cd7a58b5338 +9350623b6e1592b7ea31b1349724114512c3cce1e5459cd5bddd3d0a9b2accc64ab2bf67a71382d81190c3ab7466ba08 +98e8bf9bed6ae33b7c7e0e49fc43de135bffdba12b5dcb9ff38cb2d2a5368bb570fe7ee8e7fbe68220084d1d3505d5be +ab56144393f55f4c6f80c67e0ab68f445568d68b5aa0118c0c666664a43ba6307ee6508ba0bb5eb17664817bc9749af0 +827d5717a41b8592cfd1b796a30d6b2c3ca2cdc92455f9f4294b051c4c97b7ad6373f692ddafda67884102e6c2a16113 +8445ce2bb81598067edaa2a9e356eda42fb6dc5dd936ccf3d1ff847139e6020310d43d0fec1fe70296e8f9e41a40eb20 +9405178d965ee51e8d76d29101933837a85710961bb61f743d563ef17263f3c2e161d57e133afac209cdb5c46b105e31 +b209f9ed324c0daa68f79800c0a1338bbaf6d37b539871cb7570f2c235caca238a2c4407961fcb7471a103545495ef2c +92ae6437af6bbd97e729b82f5b0d8fb081ca822f340e20fae1875bdc65694cd9b8c037a5a1d49aa9cae3d33f5bad414e +9445bdb666eae03449a38e00851629e29a7415c8274e93343dc0020f439a5df0009cd3c4f5b9ce5c0f79aefa53ceac99 +93fdab5f9f792eada28f75e9ac6042a2c7f3142ba416bfdb1f90aa8461dbe4af524eee6db4f421cb70c7bc204684d043 +a7f4dc949af4c3163953320898104a2b17161f7be5a5615da684f881633174fb0b712d0b7584b76302e811f3fac3c12f +a8ac84da817b3066ba9789bf2a566ccf84ab0a374210b8a215a9dcf493656a3fa0ecf07c4178920245fee0e46de7c3ec +8e6a0ae1273acda3aa50d07d293d580414110a63bc3fb6330bb2ee6f824aff0d8f42b7375a1a5ba85c05bfbe9da88cb5 +a5dea98852bd6f51a84fa06e331ea73a08d9d220cda437f694ad9ad02cf10657882242e20bdf21acbbaa545047da4ce5 +b13f410bf4cfce0827a5dfd1d6b5d8eabc60203b26f4c88238b8000f5b3aaf03242cdeadc2973b33109751da367069e1 +a334315a9d61b692ad919b616df0aa75a9f73e4ea6fc27d216f48964e7daebd84b796418580cf97d4f08d4a4b51037cd +8901ba9e963fcd2f7e08179b6d19c7a3b8193b78ca0e5cf0175916de873ca0d000cd7ac678c0473be371e0ac132f35a2 +b11a445433745f6cb14c9a65314bbf78b852f7b00786501b05d66092b871111cd7bee25f702d9e550d7dd91601620abb +8c2f7b8e7b906c71f2f154cc9f053e8394509c37c07b9d4f21b4495e80484fc5fc8ab4bdc525bd6cfa9518680ba0d1a2 +b9733cebe92b43b899d3d1bfbf4b71d12f40d1853b2c98e36e635fdd8a0603ab03119890a67127e6bc79afae35b0bef2 +a560f6692e88510d9ba940371e1ada344caf0c36440f492a3067ba38e9b7011caac37ba096a8a4accb1c8656d3c019b3 +ac18624339c1487b2626eef00d66b302bdb1526b6340d6847befe2fdfb2b410be5555f82939f8707f756db0e021ed398 +afd9a3b8866a7fe4f7bc13470c0169b9705fcd3073685f5a6dcff3bdbbc2be50ac6d9908f9a10c5104b0bffc2bc14dad +97f15c92fe1f10949ed9def5dd238bc1429706e5037a0e0afb71c2d0e5845e2fed95a171c393e372077a7c7059f8c0e0 +9453a1d4d09c309b70968ea527007d34df9c4cfd3048e5391aac5f9b64ca0c05dde5b8c949c481cfc83ef2e57b687595 +b80e4b7c379ad435c91b20b3706253b763cbc980db78f782f955d2516af44c07bbfa5888cbf3a8439dc3907320feb25a +8939f458d28fefe45320b95d75b006e98330254056d063e4a2f20f04bcb25936024efe8d436d491ed34b482f9b9ae49c +a9ead2e833f71f7e574c766440c4b3c9c3363698c7ade14499a56003a272832ee6d99440887fa43ccdf80265b9d56b97 +b6547a36934f05ce7b779e68049d61351cf229ae72dc211cc96a2a471b2724782f9355fdb415ea6f0ea1eb84fe00e785 +828bfb3099b7b650b29b0f21279f829391f64520a6ab916d1056f647088f1e50fac9253ef7464eceab5380035c5a59c4 +8d714b9ea650be4342ff06c0256189e85c5c125adf6c7aeca3dba9b21d5e01a28b688fc2116ce285a0714a8f1425c0b8 +8a82eda041b2e72a3d73d70d85a568e035fbd6dc32559b6c6cfdf6f4edcb59a6ba85b6294a721aa0a71b07714e0b99ae +af5665ebc83d027173b14ffb0e05af0a192b719177889fadc9ac8c082fda721e9a75d9ce3f5602dbfd516600ee3b6405 +a68fdddf03d77bebdb676e40d93e59bd854408793df2935d0a5600601f7691b879981a398d02658c2da39dbbf61ef96c +8c001ebc84fcf0470b837a08a7b6125126b73a2762db47bbdc38c0e7992b1c66bac7a64faa1bf1020d1c63b40adc3082 +8553889b49f9491109792db0a69347880a9cf2911b4f16f59f7f424e5e6b553687d51282e8f95be6a543635247e2e2c2 +a2c269d6370b541daf1f23cc6b5d2b03a5fa0c7538d53ae500ef875952fe215e74a5010329ff41461f4c58b32ad97b3d +a5dae097285392b4eba83a9fd24baa03d42d0a157a37fae4b6efc3f45be86024b1182e4a6b6eadcf5efe37704c0a1ae5 +89871a77d2032387d19369933cd50a26bda643e40cfd0ce73febe717a51b39fae981406fd41e50f4a837c02a99524ef9 +8a76d495e90093ec2ac22f53759dc1cf36fbb8370fb586acbd3895c56a90bbf3796bcc4fc422ca4058adf337ead1402e +ad4eb7576c4954d20623c1336c63662c2a6fb46ec6ef99b7f8e946aa47488dcb136eab60b35600f98c78c16c10c99013 +894c2b120cec539feb1d281baaadde1e44beafedeeec29b804473fe024e25c1db652f151c956e88d9081fb39d27e0b19 +9196bd5c100878792444c573d02b380a69e1b4b30cb59a48114852085058a5fd952df4afee3ecceb5c4ede21e1ed4a1a +a996fffc910764ea87a1eedc3a3d600e6e0ff70e6a999cb435c9b713a89600fc130d1850174efe9fc18244bb7c6c5936 +8591bb8826befa8bee9663230d9a864a5068589f059e37b450e8c85e15ce9a1992f0ce1ead1d9829b452997727edcf9d +9465e20bb22c41bf1fa728be8e069e25cda3f7c243381ca9973cbedad0c7b07d3dd3e85719d77cf80b1058ce60e16d68 +926b5ce39b6e60b94878ffeae9ff20178656c375fb9cfe160b82318ca500eb3e2e3144608b6c3f8d6c856b8fe1e2fbcf +a1ef29cbc83c45eb28ad468d0ce5d0fdd6b9d8191ba5ffa1a781c2b232ed23db6b7b04de06ef31763a6bfe377fa2f408 +9328e63a3c8acf457c9f1f28b32d90d0eeadb0f650b5d43486a61d7374757a7ada5fc1def2a1e600fa255d8b3f48036f +a9c64880fcb7654f4dd08f4c90baac95712dd6dd407e17ea60606e9a97dc8e54dd25cb72a9bf3fc61f8d0ad569fe369d +a908eb7b940c1963f73046d6b35d40e09013bfbfbeb2ccd64df441867e202b0f3b625fa32dd04987c3d7851360abdffc +b3947b5ed6d59e59e4472cdb1c3261de1b5278fb7cb9b5fca553f328b3b3e094596861ea526eca02395f7b7358155b7b +99da7f190d37bc58945f981cf484d40fcf0855cf8178e2ce8d057c7f0a9d9f77425fdbce9ef8366f44f671b20fd27d0b +913976d77d80e3657977df39571577fdf0be68ba846883705b454f8493578baa741cfaede53783e2c97cc08964395d83 +8d754a61e5164a80b5090c13f3e936056812d4ae8dc5cc649e6c7f37464777249bc4ae760a9806939131f39d92cca5bf +82ffd098480828a90cb221a8c28584e15904bad477c13b2e2d6ef0b96a861ce4a309a328fe44342365349456ad7c654f +89ae3ce4b0357044579ca17be85d8361bb1ce3941f87e82077dd67e43ec0f95edd4bd3426225c90994a81a99e79490b7 +a170892074016d57c9d8e5a529379d7e08d2c1158b9ac4487ac9b95266c4fd51cb18ae768a2f74840137eec05000dd5a +aafd8acd1071103c7af8828a7a08076324d41ea530df90f7d98fafb19735fc27ead91b50c2ca45851545b41d589d0f77 +8623c849e61d8f1696dc9752116a26c8503fd36e2cbbc9650feffdd3a083d8cdbb3b2a4e9743a84b9b2ad91ac33083f2 +ac7166ddd253bb22cdbd8f15b0933c001d1e8bc295e7c38dc1d2be30220e88e2155ecd2274e79848087c05e137e64d01 +a5276b216d3df3273bbfa46210b63b84cfe1e599e9e5d87c4e2e9d58666ecf1af66cb7ae65caebbe74b6806677215bd0 +88792f4aa3597bb0aebadb70f52ee8e9db0f7a9d74f398908024ddda4431221a7783e060e0a93bf1f6338af3d9b18f68 +8f5fafff3ecb3aad94787d1b358ab7d232ded49b15b3636b585aa54212f97dc1d6d567c180682cca895d9876cacb7833 +ab7cb1337290842b33e936162c781aa1093565e1a5b618d1c4d87dd866daea5cebbcc486aaa93d8b8542a27d2f8694c7 +88480a6827699da98642152ebc89941d54b4791fbc66110b7632fb57a5b7d7e79943c19a4b579177c6cf901769563f2f +a725ee6d201b3a610ede3459660658ee391803f770acc639cfc402d1667721089fb24e7598f00e49e81e50d9fd8c2423 +98924372da8aca0f67c8c5cad30fa5324519b014fae7849001dcd51b6286118f12b6c49061219c37714e11142b4d46de +a62c27360221b1a7c99697010dfe1fb31ceb17d3291cf2172624ebeff090cbaa3c3b01ec89fe106dace61d934711d42d +825173c3080be62cfdc50256c3f06fe190bc5f190d0eb827d0af5b99d80936e284a4155b46c0d462ee574fe31d60983d +a28980b97023f9595fadf404ed4aa36898d404fe611c32fd66b70252f01618896f5f3fda71aea5595591176aabf0c619 +a50f5f9def2114f6424ff298f3b128068438f40860c2b44e9a6666f43c438f1780be73cf3de884846f1ba67f9bef0802 +b1eee2d730da715543aeb87f104aff6122cb2bf11de15d2519ff082671330a746445777924521ec98568635f26988d0c +862f6994a1ff4adfd9fb021925cccf542fca4d4b0b80fb794f97e1eb2964ef355608a98eec6e07aadd4b45ee625b2a21 +8ce69a18df2f9b9f6e94a456a7d94842c61dea9b00892da7cf5c08144de9be39b8c304aeca8b2e4222f87ba367e61006 +b5f325b1cecd435f5346b6bc562d92f264f1a6d91be41d612df012684fdd69e86063db077bc11ea4e22c5f2a13ae7bee +85526870a911127835446cb83db8986b12d5637d59e0f139ad6501ac949a397a6c73bd2e7fba731b1bb357efe068242c +8552247d3f7778697f77389717def5a149fc20f677914048e1ed41553b039b5427badc930491c0bae663e67668038fd1 +a545640ee5e51f3fe5de7050e914cfe216202056cd9d642c90e89a166566f909ee575353cb43a331fde17f1c9021414e +8b51229b53cff887d4cab573ba32ec52668d197c084414a9ee5589b285481cea0c3604a50ec133105f661321c3ca50f5 +8cdc0b960522bed284d5c88b1532142863d97bbb7dc344a846dc120397570f7bd507ceb15ed97964d6a80eccfef0f28e +a40683961b0812d9d53906e795e6470addc1f30d09affebf5d4fbbd21ddfa88ce441ca5ea99c33fd121405be3f7a3757 +a527875eb2b99b4185998b5d4cf97dd0d4a937724b6ad170411fc8e2ec80f6cee2050f0dd2e6fee9a2b77252d98b9e64 +84f3a75f477c4bc4574f16ebc21aaa32924c41ced435703c4bf07c9119dd2b6e066e0c276ff902069887793378f779e0 +a3544bc22d1d0cab2d22d44ced8f7484bfe391b36991b87010394bfd5012f75d580596ffd4f42b00886749457bb6334b +b81f6eb26934b920285acc20ceef0220dd23081ba1b26e22b365d3165ce2fbae733bbc896bd0932f63dcc84f56428c68 +95e94d40a4f41090185a77bf760915a90b6a3e3ace5e53f0cb08386d438d3aa3479f0cd81081b47a9b718698817265cd +b69bd1625b3d6c17fd1f87ac6e86efa0d0d8abb69f8355a08739109831baeec03fd3cd4c765b5ff8b1e449d33d050504 +8448f4e4c043519d98552c2573b76eebf2483b82d32abb3e2bfc64a538e79e4f59c6ca92adff1e78b2f9d0a91f19e619 +8f11c42d6a221d1fda50887fb68b15acdb46979ab21d909ed529bcad6ae10a66228ff521a54a42aca0dad6547a528233 +a3adb18d7e4a882b13a067784cf80ea96a1d90f5edc61227d1f6e4da560c627688bdf6555d33fe54cab1bca242986871 +a24d333d807a48dc851932ed21cbdd7e255bad2699909234f1706ba55dea4bb6b6f8812ffc0be206755868ba8a4af3f9 +a322de66c22a606e189f7734dbb7fda5d75766d5e69ec04b4e1671d4477f5bcb9ff139ccc18879980ebc3b64ab4a2c49 +88f54b6b410a1edbf125db738d46ee1a507e69bc5a8f2f443eb787b9aa7dbd6e55014ec1e946aabeb3e27a788914fb04 +b32ee6da1dcd8d0a7fd7c1821bb1f1fe919c8922b4c1eeed56e5b068a5a6e68457c42b192cbaef5dc6d49b17fa45bc0f +8a44402da0b3a15c97b0f15db63e460506cb8bef56c457166aea5e8881087d8202724c539ef0feb97131919a73aefca8 +b967e3fead6171fa1d19fd976535d428b501baff59e118050f9901a54b12cc8e4606348454c8f0fc25bd6644e0a5532e +b7a0c9e9371c3efbbb2c6783ce2cc5f149135175f25b6d79b09c808bce74139020e77f0c616fa6dcb3d87a378532529d +a54207782ffc909cd1bb685a3aafabbc4407cda362d7b3c1b14608b6427e1696817aeb4f3f85304ac36e86d3d8caa65b +98c1da056813a7bfebc81d8db7206e3ef9b51f147d9948c088976755826cc5123c239ca5e3fe59bed18b5d0a982f3c3f +ae1c86174dfafa9c9546b17b8201719aecd359f5bbeb1900475041f2d5b8a9600d54d0000c43dd061cfda390585726ff +a8ee5a8be0bd1372a35675c87bfd64221c6696dc16e2d5e0996e481fec5cdbcb222df466c24740331d60f0521285f7d3 +8ddadbe3cf13af50d556ce8fc0dd77971ac83fad9985c3d089b1b02d1e3afc330628635a31707b32595626798ea22d45 +a5c80254baf8a1628dc77c2445ebe21fbda0de09dd458f603e6a9851071b2b7438fe74214df293dfa242c715d4375c95 +b9d83227ed2600a55cb74a7052003a317a85ca4bea50aa3e0570f4982b6fe678e464cc5156be1bd5e7bba722f95e92c5 +b56085f9f3a72bea9aa3a8dc143a96dd78513fa327b4b9ba26d475c088116cab13843c2bff80996bf3b43d3e2bddb1d6 +8fa9b39558c69a9757f1e7bc3f07295e4a433da3e6dd8c0282397d26f64c1ecd8eb3ba9824a7cacfb87496ebbb45d962 +879c6d0cb675812ed9dee68c3479a499f088068501e2677caeae035e6f538da91a49e245f5fcce135066169649872bee +91aa9fd3fed0c2a23d1edda8a6542188aeb8abee8772818769bdee4b512d431e4625a343af5d59767c468779222cf234 +a6be0bb2348c35c4143482c7ef6da9a93a5356f8545e8e9d791d6c08ed55f14d790d21ee61d3a56a2ae7f888a8fd46ca +808ee396a94e1b8755f2b13a6ffbedef9e0369e6c2e53627c9f60130c137299d0e4924d8ef367e0a7fad7f68a8c9193c +ad1086028fcdac94d5f1e7629071e7e47e30ad0190ae59aaebfb7a7ef6202ab91323a503c527e3226a23d7937af41a52 +9102bdaf79b907d1b25b2ec6b497e2d301c8eac305e848c6276b392f0ad734131a39cc02ed42989a53ca8da3d6839172 +8c976c48a45b6bc7cd7a7acea3c2d7c5f43042863b0661d5cd8763e8b50730552187a8eecf6b3d17be89110208808e77 +a2624c7e917e8297faa3af89b701953006bf02b7c95dfba00c9f3de77748bc0b13d6e15bb8d01377f4d98fb189538142 +a405f1e66783cdcfe20081bce34623ec3660950222d50b7255f8b3cc5d4369aeb366e265e5224c0204911539f0fa165e +8d69bdcaa5d883b5636ac8f8842026fcc58c5e2b71b7349844a3f5d6fbecf44443ef4f768eac376f57fb763606e92c9f +82fce0643017d16ec1c3543db95fb57bfa4855cc325f186d109539fcacf8ea15539be7c4855594d4f6dc628f5ad8a7b0 +8860e6ff58b3e8f9ae294ff2487f0d3ffae4cf54fd3e69931662dabc8efd5b237b26b3def3bcd4042869d5087d22afcf +88c80c442251e11c558771f0484f56dc0ed1b7340757893a49acbf96006aa73dfc3668208abea6f65375611278afb02a +8be3d18c6b4aa8e56fcd74a2aacb76f80b518a360814f71edb9ccf3d144bfd247c03f77500f728a62fca7a2e45e504c5 +8b8ebf0df95c3f9b1c9b80469dc0d323784fd4a53f5c5357bb3f250a135f4619498af5700fe54ad08744576588b3dfff +a8d88abdaadd9c2a66bc8db3072032f63ed8f928d64fdb5f810a65074efc7e830d56e0e738175579f6660738b92d0c65 +a0a10b5d1a525eb846b36357983c6b816b8c387d3890af62efb20f50b1cb6dd69549bbef14dab939f1213118a1ae8ec2 +8aadf9b895aeb8fdc9987daa937e25d6964cbd5ec5d176f5cdf2f0c73f6f145f0f9759e7560ab740bf623a3279736c37 +99aeda8a495031cc5bdf9b842a4d7647c55004576a0edc0bd9b985d60182608361ed5459a9d4b21aa8e2bd353d10a086 +832c8b3bfcd6e68eee4b100d58014522de9d4cefa99498bc06c6dca83741e4572e20778e0d846884b33439f160932bca +841f56ebefc0823ab484fc445d62f914e13957e47904419e42771aa605e33ab16c44f781f6f9aa42e3a1baf377f54b42 +a6e40271d419e295a182725d3a9b541ffd343f23e37549c51ecaa20d13cf0c8d282d6d15b24def5702bfee8ba10b12ac +8ac00925ac6187a4c5cde48ea2a4eaf99a607e58b2c617ee6f01df30d03fafada2f0469178dd960d9d64cbd33a0087d8 +b6b80916b540f8a0fe4f23b1a06e2b830008ad138271d5ba3cd16d6619e521fe2a7623c16c41cba48950793386eea942 +8412c0857b96a650e73af9d93087d4109dd092ddf82188e514f18fcac644f44d4d62550bfa63947f2d574a2e9d995bbb +b871395baa28b857e992a28ac7f6d95ec461934b120a688a387e78498eb26a15913b0228488c3e2360391c6b7260b504 +926e2d25c58c679be77d0e27ec3b580645956ba6f13adcbc2ea548ee1b7925c61fcf74c582337a3b999e5427b3f752f2 +a165fa43fecae9b913d5dcfc232568e3e7b8b320ce96b13800035d52844c38fd5dbf7c4d564241d860c023049de4bcbc +b4976d7572fd9cc0ee3f24888634433f725230a7a2159405946a79315bc19e2fc371448c1c9d52bf91539fd1fe39574b +a6b461eb72e07a9e859b9e16dfa5907f4ac92a5a7ca4368b518e4a508dc43f9b4be59db6849739f3ef4c44967b63b103 +b976606d3089345d0bc501a43525d9dca59cf0b25b50dfc8a61c5bd30fac2467331f0638fab2dc68838aa6ee8d2b6bc9 +b16ea61c855da96e180abf7647fa4d9dd6fd90adebadb4c5ed4d7cd24737e500212628fca69615d89cb40e9826e5a214 +95a3e3162eb5ea27a613f8c188f2e0dcc5cbd5b68c239858b989b004d87113e6aa3209fa9fad0ee6ecef42814ba9db1a +b6a026ab56d3224220e5bce8275d023c8d39d1bdf7eec3b0923429b7d5ef18cf613a3591d364be8727bb1fa0ba11eabb +949f117e2e141e25972ee9ccdd0b7a21150de7bbf92bbd89624a0c5f5a88da7b2b172ba2e9e94e1768081f260c2a2f8d +b7c5e9e6630287d2a20a2dfb783ffe6a6ff104ff627c6e4e4342acc2f3eb6e60e9c22f465f8a8dc58c42f49840eca435 +872be5a75c3b85de21447bb06ac9eb610f3a80759f516a2f99304930ddf921f34cbffc7727989cdd7181d5fc62483954 +a50976ea5297d797d220932856afdd214d1248230c9dcd840469ecc28ea9f305b6d7b38339fedb0c00b5251d77af8c95 +80b360f8b44914ff6f0ffbd8b5360e3cabe08639f6fe06d0c1526b1fe9fe9f18c497f1752580b30e950abd3e538ad416 +a2f98f9bf7fac78c9da6bb41de267742a9d31cf5a04b2fb74f551084ec329b376f651a59e1ae919b2928286fb566e495 +8b9d218a8a6c150631548e7f24bbd43f132431ae275c2b72676abbea752f554789c5ff4aac5c0eeee5529af7f2b509ef +aa21a243b07e9c7b169598bf0b102c3c280861780f83121b2ef543b780d47aaa4b1850430ee7927f33ece9847c4e0e1a +8a6f90f4ce58c8aa5d3656fe4e05acccf07a6ec188a5f3cde7bf59a8ae468e66f055ac6dfc50b6e8e98f2490d8deedc5 +8e39f77ca4b5149ffe9945ceac35d068760ba338d469d57c14f626dd8c96dbe993dd7011beff727c32117298c95ee854 +83bd641c76504222880183edd42267e0582642c4993fe2c7a20ce7168e4c3cbf7586e1d2d4b08c84d9b0bf2f6b8800b8 +a9d332993cf0c1c55130e5cf3a478eb5e0bfb49c25c07538accc692ef03d82b458750a7b991cc0b41b813d361a5d31e3 +a0fc60e6a6015df9bee04cea8f20f01d02b14b6f7aa03123ab8d65da071b2d0df5012c2a69e7290baae6ed6dd29ebe07 +a2949dde2e48788ceaac7ec7243f287ffe7c3e788cdba97a4ab0772202aeef2d50382bed8bf7eff5478243f7eabe0bda +a7879373ea18572dba6cf29868ca955ffa55b8af627f29862f6487ee398b81fe3771d8721ca8e06716c5d91b9ac587cb +b3c7081e2c5306303524fbe9fe5645111a57dffd4ec25b7384da12e56376a0150ab52f9d9cc6ca7bdd950695e39b766d +a634a6a19d52dcb9f823352b36c345d2de54b75197bcd90528d27830bd6606d1a9971170de0849ed5010afa9f031d5be +88f2062f405fa181cfdb8475eaf52906587382c666ca09a9522537cfebbc7de8337be12a7fd0db6d6f2f7ab5aefab892 +b1f0058c1f273191247b98783b2a6f5aa716cf799a8370627fc3456683f03a624d0523b63a154fe9243c0dfd5b37c460 +ae39a227cc05852437d87be6a446782c3d7fbe6282e25cf57b6b6e12b189bdc0d4a6e2c3a60b3979256b6b5baf8f1c5f +802a1af228ab0c053b940e695e7ef3338f5be7acf4e5ed01ac8498e55b492d3a9f07996b1700a84e22f0b589638909cd +a36490832f20e4b2f9e79ee358b66d413f034d6a387534b264cdeac2bca96e8b5bcbdd28d1e98c44498032a8e63d94d2 +8728c9a87db2d006855cb304bba54c3c704bf8f1228ae53a8da66ca93b2dac7e980a2a74f402f22b9bc40cd726e9c438 +a08f08ab0c0a1340e53b3592635e256d0025c4700559939aeb9010ed63f7047c8021b4210088f3605f5c14fb51d1c613 +9670fd7e2d90f241e8e05f9f0b475aa260a5fb99aa1c9e61cd023cbad8ed1270ae912f168e1170e62a0f6d319cf45f49 +a35e60f2dd04f098bf274d2999c3447730fe3e54a8aff703bc5a3c274d22f97db4104d61a37417d93d52276b27ef8f31 +859df7a21bc35daec5695201bd69333dc4f0f9e4328f2b75a223e6615b22b29d63b44d338413ca97eb74f15563628cb7 +b2b44ad3e93bc076548acdf2477803203108b89ecc1d0a19c3fb9814d6b342afc420c20f75e9c2188ad75fdb0d34bb2d +941173ee2c87765d10758746d103b667b1227301e1bcfecef2f38f9ab612496a9abd3050cef5537bf28cfecd2aacc449 +92b0bea30ebed20ac30648efb37bac2b865daaa514316e6f5470e1de6cb84651ff77c127aa7beed4521bda5e8fc81122 +af17bf813bb238cf8bb437433f816786612209180a6c0a1d5141292dc2d2c37164ef13bfc50c718bfcc6ce26369298a2 +8461fd951bdfda099318e05cc6f75698784b033f15a71bce26165f0ce421fd632d50df9eeced474838c0050b596e672c +83281aa18ae4b01e8201e1f64248cc6444c92ee846ae72adb178cef356531558597d84ff93a05abf76bfe313eb7dbe86 +b62b150f73999c341daa4d2f7328d2f6ca1ef3b549e01df58182e42927537fc7971c360fe8264af724f4c0247850ef12 +a7022a201f79c012f982b574c714d813064838a04f56964d1186691413757befeeaada063e7884297606e0eea1b1ed43 +a42ac9e8be88e143853fd8e6a9ff21a0461801f0ac76b69cca669597f9af17ecb62cccdcdcbe7f19b62ab93d7f838406 +80f1ca73b6ba3a2fbae6b79b39c0be8c39df81862d46c4990c87cbf45b87996db7859d833abc20af2fcb4faf059c436a +b355943e04132d5521d7bbe49aea26f6aa1c32f5d0853e77cc2400595325e923a82e0ff7601d1aee79f45fd8a254f6ae +87142c891d93e539b31d0b5ead9ea600b9c84db9be9369ff150a8312fe3d10513f4c5b4d483a82b42bc65c45dd9dd3bd +823c3d7f6dda98a9d8c42b3fee28d3154a95451402accadb6cf75fc45d2653c46a569be75a433094fa9e09c0d5cf1c90 +b3c3497fe7356525c1336435976e79ec59c5624c2fb6185ee09ca0510d58b1e392965e25df8a74d90d464c4e8bb1422b +88c48d83e8ddc0d7eea051f3d0e21bc0d3a0bb2b6a39ece76750c1c90c382a538c9a35dc9478b8ceb8157dcccbbf187a +93da81a8939f5f58b668fefdc6f5f7eca6dc1133054de4910b651f8b4a3267af1e44d5a1c9e5964dc7ab741eb146894b +8b396e64985451ac337f16be61105106e262e381ea04660add0b032409b986e1ac64da3bc2feae788e24e9cb431d8668 +9472068b6e331ea67e9b5fbf8057672da93c209d7ded51e2914dbb98dccd8c72b7079b51fd97a7190f8fc8712c431538 +ac47e1446cb92b0a7406f45c708567f520900dfa0070d5e91783139d1bfc946d6e242e2c7b3bf4020500b9f867139709 +896053706869fb26bb6f7933b3d9c7dd6db5c6bd1269c7a0e222b73039e2327d44bda7d7ae82bf5988808b9831d78bcd +a55e397fa7a02321a9fe686654c86083ecedb5757586d7c0250ec813ca6d37151a12061d5feca4691a0fd59d2f0fdd81 +ae23f08ac2b370d845036518f1bddb7fea8dc59371c288a6af310486effeb61963f2eef031ca90f9bdbcf0e475b67068 +b5462921597a79f66c0fec8d4c7cfd89f427692a7ce30d787e6fd6acd2377f238ec74689a0fdbe8ef3c9c9bd24b908dc +ae67e8ea7c46e29e6aae6005131c29472768326819aa294aaf5a280d877de377b44959adb1348fa3e929dcbc3ae1f2c0 +84962b4c66500a20c4424191bdfb619a46cda35bdb34c2d61edcb0b0494f7f61dd5bf8f743302842026b7b7d49edd4b5 +846f76286dc3cc59cb15e5dabb72a54a27c78190631df832d3649b2952fa0408ecde7d4dfdae7046c728efa29879fb51 +8f76c854eaee8b699547e07ad286f7dadfa6974c1328d12502bd7630ae619f6129272fdd15e2137ffef0143c42730977 +8007b163d4ea4ec6d79e7a2aa19d06f388da0b3a56f3ee121441584e22a246c0e792431655632bf6e5e02cb86914eebf +ac4d2cecc1f33e6fb73892980b61e62095ddff5fd6167f53ca93d507328b3c05440729a277dc3649302045b734398af1 +92d2a88f2e9c9875abaff0d42624ccb6d65401de7127b5d42c25e6adccd7a664504c5861618f9031ced8aeb08b779f06 +a832c1821c1b220eb003fc532af02c81196e98df058cdcc9c9748832558362915ea77526937f30a2f74f25073cb89afb +b6f947ab4cc2baec100ed8ec7739a2fd2f9504c982b39ab84a4516015ca56aea8eef5545cfc057dd44c69b42125fb718 +b24afacf2e90da067e5c050d2a63878ee17aaf8fd446536f2462da4f162de87b7544e92c410d35bf2172465940c19349 +b7a0aa92deac71eaab07be8fa43086e071e5580f5dbf9b624427bdd7764605d27303ae86e5165bed30229c0c11958c38 +b0d1d5bfa1823392c5cf6ed927c1b9e84a09a24b284c2cd8fcb5fda8e392c7c59412d8f74eb7c48c6851dff23ae66f58 +a24125ef03a92d2279fb384186ca0274373509cfec90b34a575490486098438932ee1be0334262d22d5f7d3db91efe67 +83e08e5fba9e8e11c164373794f4067b9b472d54f57f4dbe3c241cf7b5b7374102de9d458018a8c51ab3aed1dddf146f +9453101b77bb915ed40990e1e1d2c08ea8ec5deb5b571b0c50d45d1c55c2e2512ec0ceca616ff0376a65678a961d344d +92a0516e9eb6ad233d6b165a8d64a062ce189b25f95d1b3264d6b58da9c8d17da2cd1f534800c43efcf2be73556cd2ff +958d0b5d7d8faf25d2816aa6a2c5770592ad448db778dd9b374085baa66c755b129822632eaabcb65ee35f0bf4b73634 +90a749de8728b301ad2a6b044e8c5fd646ccd8d20220e125cba97667e0bb1d0a62f6e3143b28f3d93f69cdc6aa04122a +84bd34c8d8f74dec07595812058db24d62133c11afed5eb2a8320d3bfc28e442c7f0cfd51011b7b0bb3e5409cb7b6290 +aecc250b556115d97b553ad7b2153f1d69e543e087890000eaa60f4368b736921d0342ce5563124f129096f5d5e2ca9d +977f17ac82ed1fbf422f9b95feb3047a182a27b00960296d804fd74d54bb39ad2c055e665c1240d2ad2e06a3d7501b00 +af5be9846bd4879ebe0af5e7ad253a632f05aedfe306d31fe6debe701ba5aa4e33b65efc05043bc73aadb199f94baed4 +9199e12ec5f2aaaeed6db5561d2dcc1a8fe9c0854f1a069cba090d2dff5e5ba52b10c841ccbd49006a91d881f206150d +8f4a96a96ed8ceaf3beba026c89848c9ca4e6452ce23b7cf34d12f9cc532984a498e051de77745bdc17c7c44c31b7c30 +af3f2a3dbe8652c4bfca0d37fb723f0e66aab4f91b91a625114af1377ad923da8d36da83f75deb7a3219cd63135a3118 +a6d46963195df8962f7aa791d104c709c38caa438ddd192f7647a884282e81f748c94cdf0bb25d38a7b0dc1b1d7bbcf7 +86f3de4b22c42d3e4b24b16e6e8033e60120af341781ab70ae390cb7b5c5216f6e7945313c2e04261a51814a8cb5db92 +b9f86792e3922896cfd847d8ff123ff8d69ecf34968fb3de3f54532f6cd1112b5d34eeabdca46ae64ad9f6e7e5b55edc +83edfbcbc4968381d1e91ab813b3c74ab940eaf6358c226f79182f8b21148ec130685fd91b0ea65916b0a50bccf524ea +93b61daca7a8880b7926398760f50016f2558b0bab74c21181280a1baf3414fc539911bb0b79c4288d29d3c4ad0f4417 +ad541aeb83a47526d38f2e47a5ce7e23a9adabe5efeae03541026881e6d5ef07da3ac1a6ed466ca924fa8e7a91fcff88 +ac4bba31723875025640ed6426003ed8529215a44c9ffd44f37e928feef9fc4dfa889088131c9be3da87e8f3fdf55975 +88fa4d49096586bc9d29592909c38ea3def24629feacd378cc5335b70d13814d6dac415f8c699ee1bf4fe8b85eb89b38 +b67d0b76cbd0d79b71f4673b96e77b6cda516b8faa1510cfe58ff38cc19000bb5d73ff8418b3dab8c1c7960cb9c81e36 +98b4f8766810f0cfecf67bd59f8c58989eb66c07d3dfeee4f4bbce8fd1fce7cc4f69468372eaec7d690748543bd9691d +8445891af3c298b588dec443beacdf41536adb84c812c413a2b843fd398e484eb379075c64066b460839b5fe8f80177c +b603635c3ed6fdc013e2a091fc5164e09acf5f6a00347d87c6ebadb1f44e52ff1a5f0466b91f3f7ffc47d25753e44b75 +87ec2fc928174599a9dafe7538fec7dcf72e6873b17d953ed50708afff0da37653758b52b7cafa0bf50dfcf1eafbb46c +b9dbd0e704d047a457d60efe6822dc679e79846e4cbcb11fa6c02079d65673ee19bbf0d14e8b7b200b9205f4738df7c7 +9591ec7080f3f5ba11197a41f476f9ba17880f414d74f821a072ec5061eab040a2acba3d9856ff8555dfe5eaeb14ca19 +b34c9d1805b5f1ce38a42b800dec4e7f3eb8c38e7d2b0a525378e048426fed150dbfe9cc61f5db82b406d1b9ff2d10bf +a36fdc649dc08f059dfa361e3969d96b4cc4a1ebf10b0cd01a7dd708430979e8d870961fef85878f8779b8e23caafb18 +88dfc739a80c16c95d9d6f73c3357a92d82fa8c3c670c72bee0f1e4bac9ec338e1751eb786eda3e10f747dd7a686900f +84a535ad04f0961756c61c70001903a9adf13126983c11709430a18133c4b4040d17a33765b4a06968f5d536f4bfb5c5 +8c86d695052a2d2571c5ace744f2239840ef21bb88e742f050c7fa737cd925418ecef0971333eb89daa6b3ddfede268c +8e9a700157069dc91e08ddcbdde3a9ad570272ad225844238f1015004239c542fceb0acce6d116c292a55f0d55b6175e +84d659e7f94e4c1d15526f47bc5877a4ef761c2a5f76ec8b09c3a9a30992d41b0e2e38ed0c0106a6b6c86d670c4235f3 +a99253d45d7863db1d27c0ab561fb85da8c025ba578b4b165528d0f20c511a9ca9aff722f4ff7004843f618eb8fced95 +89a3cacb15b84b20e95cd6135550146bbe6c47632cc6d6e14d825a0c79b1e02b66f05d57d1260cb947dc4ae5b0283882 +8385b1555e794801226c44bd5e878cbe68aeac0a19315625a8e5ea0c3526b58cdd4f53f9a14a167a5e8a293b530d615a +b68c729e9df66c5cd22af4909fb3b0057b6a231c4a31cd6bf0fa0e53c5809419d15feb483de6e9408b052458e819b097 +924f56eda269ec7ec2fc20c5731bf7f521546ddf573ccbe145592f1c9fee5134747eb648d9335119a8066ca50a1f7e50 +b2100a26b9c3bec7ec5a53f0febbf56303f199be2f26b2d564cfee2adc65483b84192354f2865c2f4c035fa16252ae55 +8f64dbed62e638563967ec1605a83216aed17eb99aa618c0543d74771ea8f60bbb850c88608d4f8584f922e30a8a0a72 +b31b9e1ffe8d7260479c9413f8e680f3fe391ae8fcf44fcca3000d9b2473a40c1d32299f8f63865a57579a2d6c7e9f08 +a5b1d136142eb23e322c6c07cb838a3f58ab6925472352ebd0bb47041a0d8729e1074ca223922f3a7a672ced7a1e562d +8d9470a5a15d833a447b5f108333d50f30aa7659e331c3f8080b1e928a99922edc650466a2f54f3d48afdb34bff42142 +866368f5891564e5b2de37ad21ff0345c01129a14ea5667f9b64aad12d13ec034622872e414743af0bf20adb2041b497 +88ef9c2ebf25fd0c04b7cfa35fbac2e4156d2f1043fa9f98998b2aa402c8f9a4f1039e782451a46840f3e0e4b3fa47d3 +94ba04a4859273697e264a2d238dc5c9ff573ebc91e4796ea58eebe4080c1bf991255ab2ad8fb1e0301ce7b79cc6e69b +86b6bd0953309a086e526211bf1a99327269304aa74d8cdc994cee63c3a2d4b883e832b0635888dff2a13f1b02eb8df4 +843ea6ea5f2c7a1fd50be56a5765dcce3ea61c99b77c1a729ee0cd8ec706385ac7062e603479d4c8d3527f030762d049 +8d3675195a3b06f2d935d45becc59f9fa8fa440c8df80c029775e47fe9c90e20f7c8e4cc9a2542dd6bfe87536c428f0d +8978580b0c9b0aa3ab2d47e3cfd92fa891d3ddee57829ee4f9780e8e651900457d8e759d1a9b3e8f6ae366e4b57f2865 +890112ec81d0f24b0dfbb4d228e418eff02ae63dc691caf59c1d103e1d194e6e2550e1bec41c0bfdb74fed454f621d0c +97da00bd4b19d1e88caff7f95b8b9a7d29bc0afe85d0c6a163b4b9ef336f0e90e2c49ce6777024bb08df908cc04ea1ca +b458268d275a5211106ccaa8333ce796ef2939b1c4517e502b6462e1f904b41184a89c3954e7c4f933d68b87427a7bfd +aac9c043ba8ba9283e8428044e6459f982413380ee7005a996dc3cc468f6a21001ecaa3b845ce2e73644c2e721940033 +82145013c2155a1200246a1e8720adf8a1d1436b10d0854369d5b1b6208353e484dd16ce59280c6be84a223f2d45e5e2 +b301bafa041f9b203a46beab5f16160d463aa92117c77a3dc6a9261a35645991b9bafcc186c8891ca95021bd35f7f971 +a531b8d2ac3de09b92080a8d8857efa48fb6a048595279110e5104fee7db1dd7f3cfb8a9c45c0ed981cbad101082e335 +a22ac1d627d08a32a8abd41504b5222047c87d558ffae4232cefdeb6a3dc2a8671a4d8ddfba2ff9068a9a3ffb0fe99b1 +b8d9f0e383c35afb6d69be7ff04f31e25c74dd5751f0e51290c18814fbb49ee1486649e64355c80e93a3d9278bd21229 +8165babccd13033a3614c878be749dfa1087ecbeee8e95abcfffe3aa06695711122cb94477a4d55cffd2febf0c1173de +a4c1bc84ecb9d995d1d21c2804adf25621676d60334bd359dac3a2ec5dc8de567aa2831c10147034025fb3e3afb33c4b +b77307cab8e7cb21e4038493058fb6db9e2ec91dda9d7f96f25acbc90309daf7b6d8a205682143ee35d675e9800c3b08 +aaf7466083cd1f325ba860efe3faf4cebe6a5eecf52c3e8375d72043a5cfc8e6cb4b40f8e48f97266e84f0d488e8badf +9264a05a3abc2a5b4958f957f3a486a5eb3ddd10ff57aa6943c9430d0cfa01d63b72695b1ade50ac1b302d312175e702 +b3f9e4c589ad28b1eceed99dc9980fac832524cfcbe4a486dfeedb4b97c080e24bdb3967e9ca63d2240e77f9addfaefd +b2c1e253a78e7179e5d67204422e0debfa09c231970b1bfb70f31a8d77c7f5059a095ca79d2e9830f12c4a8f88881516 +81865a8a25913d1072cb5fd9505c73e0fde45e4c781ddd20fb0a7560d8b1cd5e1f63881c6efc05360e9204dfa6c3ce16 +ab71c2ea7fa7853469a2236dedb344a19a6130dc96d5fd6d87d42d3fffda172557d203b7688ce0f86acd913ce362e6cd +8aa2051bc3926c7bd63565f3782e6f77da824cb3b22bb056aa1c5bccfa274c0d9e49a91df62d0e88876e2bd7776e44b9 +b94e7074167745323d1d353efe7cfb71f40a390e0232354d5dfd041ef523ac8f118fb6dcc42bf16c796e3f61258f36f8 +8210fcf01267300cb1ccf650679cf6e1ee46df24ae4be5364c5ff715332746c113d680c9a8be3f17cacaeb3a7ba226ce +905ac223568eedc5acd8b54e892be05a21abbb4083c5dbec919129f9d9ffa2c4661d78d43bf5656d8d7aafa06f89d647 +a6e93da7e0c998e6ce2592d1aa87d12bf44e71bec12b825139d56682cdce8f0ba6dbfe9441a9989e10578479351a3d9d +acde928a5e2df0d65de595288f2b81838155d5673013100a49b0cb0eb3d633237af1378148539e33ccd1b9a897f0fec3 +a6e1a47e77f0114be6ae7acd2a51e6a9e38415cce7726373988153cdd5d4f86ef58f3309adc5681af4a159300ed4e5b5 +ad2b6a0d72f454054cb0c2ebc42cd59ff2da7990526bd4c9886003ba63b1302a8343628b8fe3295d3a15aa85150e0969 +b0bc3aea89428d7918c2ee0cc57f159fba134dad224d0e72d21a359ca75b08fbb4373542f57a6408352033e1769f72c6 +aad0497525163b572f135fad23fdd8763631f11deeaf61dea5c423f784fe1449c866040f303555920dc25e39cdb2e9b4 +8ce5d8310d2e17342bf881d517c9afc484d12e1f4b4b08ad026b023d98cba410cd9a7cc8e2c3c63456652a19278b6960 +8d9d57dbb24d68b6152337872bd5d422198da773174ade94b633f7c7f27670ff91969579583532ae7d8fe662c6d8a3b0 +855a1c2d83becb3f02a8f9a83519d1cb112102b61d4cdd396844b5206e606b3fefdbcc5aa8751da2b256d987d74d9506 +90eb7e6f938651f733cf81fcd2e7e8f611b627f8d94d4ac17ac00de6c2b841e4f80cada07f4063a13ae87b4a7736ca28 +8161459a21d55e7f5f1cecfc1595c7f468406a82080bfa46d7fb1af4b5ec0cd2064c2c851949483db2aa376e9df418e6 +8344ccd322b2072479f8db2ab3e46df89f536408cba0596f1e4ec6c1957ff0c73f3840990f9028ae0f21c1e9a729d7df +929be2190ddd54a5afe98c3b77591d1eae0ab2c9816dc6fe47508d9863d58f1ea029d503938c8d9e387c5e80047d6f1e +856e3d1f701688c650c258fecd78139ce68e19de5198cf1cd7bb11eba9d0f1c5af958884f58df10e3f9a08d8843f3406 +8490ae5221e27a45a37ca97d99a19a8867bcc026a94f08bdccfbb4b6fa09b83c96b37ec7e0fd6ee05f4ae6141b6b64a8 +b02dbd4d647a05ac248fda13708bba0d6a9cd00cae5634c1938b4c0abbb3a1e4f00f47aa416dcd00ffcdf166330bff9a +9076164bb99ca7b1a98d1e11cb2f965f5c22866658e8259445589b80e3cb3119c8710ede18f396ba902696785619079c +aacf016920936dae63778ad171386f996f65fe98e83cfcdd75e23774f189303e65cc8ad334a7a62f9230ed2c6b7f6fa4 +a8031d46c7f2474789123469ef42e81c9c35eb245d38d8f4796bba406c02b57053f5ec554d45373ab437869a0b1af3f0 +a4b76cd82dc1f305a0ee053e9a4212b67f5acc5e69962a8640d190a176b73fbc2b0644f896ff3927cd708d524668ed09 +b00b029c74e6fdf7fb94df95ef1ccad025c452c19cddb5dccfb91efdcb8a9a1c17847cfa4486eae4f510e8a6c1f0791a +9455e5235f29a73e9f1a707a97ddb104c55b9d6a92cc9952600d49f0447d38ea073ee5cf0d13f7f55f12b4a5132f4b10 +ae118847542ed1084d269e8f3b503d0b6571a2c077def116ad685dcca2fca3dcb3f86e3f244284bdcd5ae7ac968d08a5 +8dcb4965cd57e8b89cd71d6fc700d66caa805bfd29ab71357961527a7894e082d49145c2614b670dcb231ab9050d0663 +add6ed14f3183f4acc73feea19b22c9a330e431c674e5034924da31b69e8c02d79b570d12ef771a04215c4809e0f8a80 +96ae7e110412ee87d0478fdbdbaab290eb0b6edd741bb864961845e87fd44bcbe630371060b8104d8bf17c41f2e3fca0 +a20db17f384e9573ca0928af61affab6ff9dd244296b69b026d737f0c6cd28568846eca8dadf903ee0eecbb47368351d +937bfdf5feb0797863bc7c1be4dcc4f2423787952a3c77dfa3bfe7356f5dbcc4daebde976b84fc6bd97d5124fb8f85c9 +a7050cc780445c124e46bba1acc0347ddcfa09a85b35a52cc5808bf412c859c0c680c0a82218f15a6daeefe73f0d0309 +a9d9b93450e7630f1c018ea4e6a5ca4c19baa4b662eadfbe5c798fe798d8a3775ed1eb12bd96a458806b37ab82bdc10a +a52a4d5639e718380915daaefad7de60764d2d795443a3db7aeab5e16a1b8faa9441a4ccc6e809d8f78b0ac13eef3409 +8e6f72b6664a8433b032849b03af68f9376b3c16c0bc86842c43fc7bf31e40bc9fc105952d5c5780c4afa19d7b802caa +a107ae72f037000c6ee14093de8e9f2c92aa5f89a0a20007f4126419e5cb982469c32187e51a820f94805c9fccd51365 +9708218f9a984fe03abc4e699a4f3378a06530414a2e95e12ca657f031ef2e839c23fd83f96a4ba72f8203d54a1a1e82 +b9129770f4c5fcac999e98c171d67e148abd145e0bf2a36848eb18783bb98dff2c5cef8b7407f2af188de1fae9571b1c +88cc9db8ff27eb583871eeeb517db83039b85404d735517c0c850bdfa99ae1b57fd24cf661ab60b4726878c17e047f37 +a358c9aadc705a11722df49f90b17a2a6ba057b2e652246dc6131aaf23af66c1ca4ac0d5f11073a304f1a1b006bc0aa5 +ac79f25af6364a013ba9b82175ccee143309832df8f9c3f62c193660253679284624e38196733fb2af733488ab1a556e +82338e3ed162274d41a1783f44ae53329610134e6c62565353fbcc81131e88ce9f8a729d01e59e6d73695a378315111b +aa5ddcabf580fd43b6b0c3c8be45ffd26c9de8fa8d4546bb92d34f05469642b92a237d0806a1ad354f3046a4fcf14a92 +b308d2c292052a8e17862c52710140ffafa0b3dbedd6a1b6334934b059fe03e49883529d6baf8b361c6e67b3fbf70100 +96d870a15c833dddd8545b695139733d4a4c07d6206771a1524500c12607048731c49ec4ac26f5acc92dd9b974b2172c +8e99ee9ed51956d05faaf5038bffd48a2957917a76d9974a78df6c1ff3c5423c5d346778f55de07098b578ad623a390e +a19052d0b4b89b26172c292bbf6fd73e7486e7fd3a63c7a501bbd5cf7244e8e8ce3c1113624086b7cdf1a7693fdad8b5 +958957caf99dc4bb6d3c0bc4821be10e3a816bd0ba18094603b56d9d2d1383ccc3ee8bc36d2d0aea90c8a119d4457eb4 +8482589af6c3fc4aa0a07db201d8c0d750dd21ae5446ff7a2f44decf5bff50965fd6338745d179c67ea54095ecd3add4 +8a088cc12cf618761eaa93da12c9158b050c86f10cd9f865b451c69e076c7e5b5a023e2f91c2e1eed2b40746ca06a643 +85e81101590597d7671f606bd1d7d6220c80d3c62e9f20423e734482c94547714a6ac0307e86847cce91de46503c6a8a +b1bd39b481fc452d9abf0fcb73b48c501aaae1414c1c073499e079f719c4e034da1118da4ff5e0ce1c5a71d8af3f4279 +942ae5f64ac7a5353e1deb2213f68aa39daa16bff63eb5c69fc8d9260e59178c0452227b982005f720a3c858542246c8 +99fea18230e39df925f98e26ff03ab959cae7044d773de84647d105dfa75fd602b4f519c8e9d9f226ec0e0de0140e168 +97b9841af4efd2bfd56b9e7cd2275bc1b4ff5606728f1f2b6e24630dbe44bc96f4f2132f7103bca6c37057fc792aeaab +94cdad044a6ab29e646ed30022c6f9a30d259f38043afcea0feceef0edc5f45297770a30718cbfec5ae7d6137f55fe08 +a533a5efa74e67e429b736bb60f2ccab74d3919214351fe01f40a191e3ec321c61f54dd236f2d606c623ad556d9a8b63 +b7bd0bb72cd537660e081f420545f50a6751bb4dd25fde25e8218cab2885dd81ffe3b888d608a396dfcb78d75ba03f3f +b1479e7aa34594ec8a45a97611d377206597149ece991a8cef1399738e99c3fa124a40396a356ab2ea135550a9f6a89f +b75570fc94b491aef11f70ef82aeb00b351c17d216770f9f3bd87f3b5ac90893d70f319b8e0d2450dc8e21b57e26df94 +a5e3f3ab112530fe5c3b41167f7db5708e65479b765b941ce137d647adb4f03781f7821bb4de80c5dc282c6d2680a13d +b9b9c81b4cac7aca7e7c7baac2369d763dd9846c9821536d7467b1a7ec2e2a87b22637ab8bbeddb61879a64d111aa345 +b1e3ee2c4dd03a60b2991d116c372de18f18fe279f712829b61c904103a2bd66202083925bc816d07884982e52a03212 +a13f0593791dbbd360b4f34af42d5cc275816a8db4b82503fe7c2ff6acc22ae4bd9581a1c8c236f682d5c4c02cc274cc +86ba8238d3ed490abcc3f9ecc541305876315fb71bca8aaf87538012daab019992753bf1e10f8670e33bff0d36db0bf0 +b65fbb89fafb0e2a66fe547a60246d00b98fe2cb65db4922d9cef6668de7b2f4bb6c25970f1e112df06b4d1d953d3f34 +abb2d413e6f9e3c5f582e6020f879104473a829380b96a28123eb2bdd41a7a195f769b6ac70b35ba52a9fee9d6a289c3 +88ec764573e501c9d69098a11ea1ad20cdc171362f76eb215129cfcca43460140741ea06cee65a1f21b708afb6f9d5b0 +a7aaec27246a3337911b0201f4c5b746e45780598004dac15d9d15e5682b4c688158adffdef7179abb654f686e4c6adc +a1128589258f1fbfa33341604c3cb07f2a30c651086f90dce63ae48b4f01782e27c3829de5102f847cde140374567c58 +aaf2b149c1ca9352c94cc201125452b1ed7ca7c361ed022d626899426cb2d4cc915d76c58fa58b3ad4a6284a9ae1bc45 +aaf5c71b18b27cd8fe1a9028027f2293f0753d400481655c0d88b081f150d0292fb9bd3e6acabb343a6afb4afdb103b5 +947c0257d1fb29ecc26c4dc5eab977ebb47d698b48f9357ce8ff2d2ed461c5725228cc354a285d2331a60d20de09ff67 +b73e996fa30f581699052ed06054c474ebdf3ae662c4dc6f889e827b8b6263df67aeff7f2c7f2919df319a99bdfdceb1 +b696355d3f742dd1bf5f6fbb8eee234e74653131278861bf5a76db85768f0988a73084e1ae03c2100644a1fa86a49688 +b0abca296a8898ac5897f61c50402bd96b59a7932de61b6e3c073d880d39fc8e109998c9dba666b774415edddcff1997 +b7abe07643a82a7cb409ee4177616e4f91ec1cf733699bf24dec90da0617fe3b52622edec6e12f54897c4b288278e4f3 +8a3fae76993edbc81d7b47f049279f4dd5c408133436605d934dee0eadde187d03e6483409713db122a2a412cd631647 +82eb8e48becfdf06b2d1b93bf072c35df210cf64ed6086267033ad219bf130c55ee60718f28a0e1cad7bc0a39d940260 +a88f783e32944a82ea1ea4206e52c4bcf9962b4232e3c3b45bd72932ee1082527bf80864ce82497e5a8e40f2a60962d0 +830cf6b1e99430ae93a3f26fbfb92c741c895b017924dcd9e418c3dc4a5b21105850a8dd2536fa052667e508b90738f2 +990dce4c2c6f44bb6870328fba6aa2a26b0b8b2d57bfb24acf398b1edc0f3790665275f650884bd438d5403973469fa2 +a2e5b6232d81c94bcb7fed782e2d00ff70fc86a3abddbe4332cb0544b4e109ae9639a180ae4c1f416752ed668d918420 +b4cdf7c2b3753c8d96d92eb3d5fa984fef5d346a76dc5016552069e3f110356b82e9585b9c2f5313c76ffaecef3d6fd8 +83b23b87f91d8d602bff3a4aa1ead39fcc04b26cf113a9da6d2bd08ba7ea827f10b69a699c16911605b0126a9132140f +8aae7a2d9daa8a2b14f9168fe82933b35587a3e9ebf0f9c37bf1f8aa015f18fb116b7fba85a25c0b5e9f4b91ba1d350b +80d1163675145cc1fab9203d5581e4cd2bed26ad49f077a7927dec88814e0bed7912e6bbe6507613b8e393d5ee3be9be +93ddeb77b6a4c62f69b11cf36646ed089dcaa491590450456a525faf5659d810323b3effa0b908000887c20ac6b12c80 +9406360a2b105c44c45ba440055e40da5c41f64057e6b35a3786526869b853472e615e6beb957b62698a2e8a93608e13 +93bfc435ab9183d11e9ad17dac977a5b7e518db720e79a99072ce7e1b8fcb13a738806f414df5a3caa3e0b8a6ce38625 +8a12402c2509053500e8456d8b77470f1bbb9785dd7995ebbbe32fd7171406c7ce7bd89a96d0f41dbc6194e8f7442f42 +aab901e35bf17e6422722c52a9da8b7062d065169bf446ef0cbf8d68167a8b92dab57320c1470fee1f4fc6100269c6e2 +8cad277d9e2ba086378190d33f1116ba40071d2cb78d41012ec605c23f13009e187d094d785012b9c55038ec96324001 +85511c72e2894e75075436a163418279f660c417e1d7792edce5f95f2a52024d1b5677e2e150bf4339ad064f70420c60 +85549ca8dcbe49d16d4b3e2b8a30495f16c0de35711978ada1e2d88ad28e80872fca3fb02deb951b8bcb01b6555492e4 +8d379ab35194fe5edf98045a088db240a643509ddc2794c9900aa6b50535476daa92fd2b0a3d3d638c2069e535cd783b +b45cfebe529556b110392cb64059f4eb4d88aaf10f1000fdd986f7f140fdd878ce529c3c69dfd2c9d06f7b1e426e38f3 +ac009efd11f0c4cdd07dd4283a8181420a2ba6a4155b32c2fed6b9f913d98e057d0f5f85e6af82efc19eb4e2a97a82df +b2c2cdffa82f614e9cb5769b7c33c7d555e264e604e9b6138e19bcfc49284721180b0781ecbf321d7e60259174da9c3c +95789960f848797abbe1c66ef05d01d920228ca1f698130c7b1e6ca73bfda82cee672d30a9787688620554e8886554ee +98444018fa01b7273d3370eeb01adc8db902d5a69b9afc0aa9eadfeb43c4356863f19078d3c0d74e80f06ecf5a5223f4 +87d20b058050542f497c6645de59b8310f6eeec53acbc084e38b85414c3ea3016da3da690853498bde1c14de1db6f391 +a5c12b3a40e54bee82a315c503c1ce431309a862458030dde02376745ec1d6b9c1dbeea481ae6883425e9dae608e444e +b9daa3bf33f0a2979785067dcece83250e7bf6deb75bb1dbbab4af9e95ddfb3d38c288cbef3f80519a8916a77a43b56c +b682ec3118f71bde6c08f06ea53378ea404f8a1c4c273dd08989f2df39d6634f6463be1d172ac0e06f0fa19ac4a62366 +a4f94fd51ecf9d2065177593970854d3dce745eebb2a6d49c573cbf64a586ae949ddfa60466aaef0c0afb22bd92e0b57 +86cd5609efd570c51adbc606c1c63759c5f4f025fcbefab6bc3045b6ad2423628c68f5931ff56fdda985168ce993cc24 +981192e31e62e45572f933e86cdd5b1d28b1790b255c491c79bd9bb4964359b0e5f94f2ae0e00ef7fe7891b5c3904932 +9898f52b57472ebc7053f7bf7ab6695ce8df6213fc7f2d6f6ea68b5baad86ec1371a29304cae1baadf15083296958d27 +b676c4a8a791ae00a2405a0c88b9544878749a7235d3a5a9f53a3f822e0c5c1b147a7f3f0fc228049dc46e87aa6b6368 +9976e10beff544e5c1645c81a807739eff90449df58ffdd8d1aa45dd50b4c62f9370538b9855a00dd596480f38ebe7a5 +a0e91404894187ec23c16d39d647ada912a2c4febfd050a1ea433c4bfdc1568b4e97a78a89ba643aca3e2782033c3c58 +91a6ea9a80476ed137eb81558ff1d55b8581663cccd41db4fc286876226b6515fd38661557419e1e46b6a3bc9cda3741 +b9e8a1e23c60335a37a16f8085f80178a17d5e055d87ffe8cf63c532af923e5a5a2d76cf078164fb577996683796caa6 +ad8e151d87a37e8df438d0a6a7c02c3f511143efb93fde8aef334d218cb25932baf9e97c2f36c633620a024a5626af3d +978f942f210e8a482015e6fdc35a4c967c67b66e6e2a17a05cc7a0f2163aed227b775d4352b0c3cca6cbf4bd5bafaf75 +b5e2e3d8b2e871c07f5899e108e133f87479959b80cb8a103fbecde00ccdbfbd997540eef33079c5cc14b1c00c009fd1 +88a164b3fefd36857f429ab10002243b053f5d386466dbb9e5135ed3c72dd369a5a25e5e2aaa11f25488535e044e2f12 +a66091c0db4e7cf05a089ec2b9ff74744354d0196968201f5e201699144b52bb13b4e68e12502727163e6db96e3565f2 +8e65aff8e37240461b7374c20bfd1d58b73a525c28994a98f723daed9486130b3189f8efe5c5efcd7f5390cc366038da +8b37c21dd7304c3aa366959ba8c77ea8b22164a67e136808b6f8e48604297f7429a6c6ecf67b1d09b8b7ec083eacd7e0 +b689b1277ad050f53da91a702516a06d7406ff33a4714ea859b3b2b69f8d0aa8f983c7e039b19c0759a3815d841fa409 +b17f7a0a182ed4937f88489e4c4e6163dcf49fd2ea4d9efbba8126c743bea951cd769752acd02e921774dc8ebcfae33b +8b7fab4f90be825ac5d782a438e55c0a86be1c314a5dbc3cc6ed60760a8a94ef296391f1f6363652200cce4c188dae67 +ab8410c4eaa2bb43b0dd271aa2836061bc95cb600b0be331dada76ddb46711ff7a4ad8c466cc1078b9f9131f0dc9d879 +9194bd7b3cc218624459d51c4d6dbc13da5d3de313448f8175650fa4cfab7cc4afcda5427b6676c3c13897dc638b401e +980f61a0f01349acd8fc9fdc88fc2c5813610c07eecb6ab14af0845a980792a60dadf13bb4437b0169ae3eff8f5984ce +b783bee24acea9c99d16434195c6940cf01fc2db135e21f16acae45a509eca3af6b9232a8aa3a86f9715c5f6a85cb1c3 +a3079931c4b90966d1faa948db847741878b5828bc60325f5ebe554dcab4adcc19ee8bce645e48a8f4a9413bb3c6a093 +801f61ac9318f6e033a99071a46ae06ed249394638c19720831fff850226363a4ae8486dd00967746298ee9f1d65462f +b34dbbed4f3bb91f28285c40f64ce60c691737cc2b2d2be5c7d0210611cd58341bb5bda51bb642d3ee2d80882e642a13 +8750af19abfb915e63c81542b13d84526a0c809179bbcc1cd8a52b29f3aba3ae0f7cf6f4f01790bf64ef7db01d8ee887 +a6ea10000eb2dd4efc242ac95bc3b3873cdd882fbeb7c9538c87e3143a263ca3a2e192b2159316a625cfb5fb0b6cdcb3 +aa40ca54bc758a6c64cb932924917581062e088b3ad43976b28f2e11d8a7dea73f1fb50aeaa0e70182bb2dc07d805bb9 +a4779dfd25b5ec9d75dfb54a4bb030364899a5e75c1492403acb19f2adc782c7ac4daeb66d2f5aeb74135afe9f318e3f +b4551e2805d63ca453f4f38b1921ac87ff687e1d70575ad38f3469d6f0608ef76b7b1b98ae1e6b1e7d928773aaab6e3b +99490ee722f96aad2743b08dd37bfeb75a8c59efaee4c9b694eaa05eb8a6bb23861a4480544c7617d04d23fd5e2543b4 +8a7050d964d295fff98ae30d77ce730a055719313457e773fcce94c4d71a9b7cf63db67e54a8aab20fb1335b0130b5d5 +903144e6bbee0a4fec17ff80fef0d2103981140c3d41776cfb184ced17f480a687dd093f6b538584327e6142812e3cd5 +a5b30f7c6939bdc24a84ae784add927fec798b5a5ee3dd156c652df020728dd6d43898be364cf5ee181725fbcffc0964 +b43d97ec2bc66af92d921a5c5c20a03ef2be2bc2c9b345f46d8287409fcbfd88ebc49d4509d64468222cd1d2021bf236 +82dc23c7f5086c9ac6b4566359bfb830d203544b0d8332a210775670f899cd9ff48b94bfeba40040c25664ebdd5cfad8 +9294cd017fea581dabb73dcc8c619904d7e022b664b0a8502c9d30f3807668af279948e7e41030ae296d492225297e95 +8d6c9dc636c8e884f9a4299e5cff06d044ebc94ad783a4b71788347ea4a336d4d048b8a9ecabae789e8fcdc459723dfb +801a80bc49e882ec81b04e37407713f033f7bdac79252dfa3dc8c5bd0229fcbd4019890e402cf843b9378df08f72ab84 +b4313ca32569d973900f6196363c0b280ddfa1b47c88d019e5f399b805b444a777950fc21ae198fc23ece52674b94abf +96f06056fd255fdabf78986e315e7c4fdf5495cf850536b7976baa97a994cc6a99c34609c33a0f2facba5e6f1026dce6 +983ed80220a5545ffd70ef5e6ac10217d82ec9cd8f9a27ee77a5ff4074092308c0e6396fc4e9932a77ddd474e61f8b55 +872a059aa630af73c4abbd076e8b333a973ffc5bdecf5dcc0600b00162184213cb19d4f601795030033beb808d5810ce +b040f318d9d3b8833da854014a44296dbd6762dd17cab13f91987256c54353b7f0800547cb645a7cc231997454209fdd +a8c4731a555308e8ce0b8325eb7a4cbf6113d07e9f41932df04480b72628d313b941c7055f1cc2ac45c7353b56e96ca9 +8c24031440b77637e045a52e5ea3f488926ab0b426148975edf066c40a4581beecc1bfb18fc4cf5f9f96dc6681b4bd28 +b39254b475abf342f301298feaa17a4b3051f30ea23a18acf59e003e2704ac96fe40691f1da387913bdf7aee6389f9a8 +a1dbf938b604ccc6d60881cc71f38df568aa02752aa44d123514154017503f6c1c335ae43e359f1487bc8934073cd9c1 +8d52aa1be9f429ece0580498d8fe9fef46d4a11f49436a82b8927f9503dacc41245907f126594c1cd30701286f8c092c +b826f396486942c0326d16f30a01b00a682c30a75553dc6ac34fd5b3e96b13c33b94738f522eebaffb59ff8c571c76e9 +aa89f51cbf6e6c3e2aa2806187b69ab3361c84e89f393f3ed284fe84db46fc3944aa44f8928e3964f9c1a1ec27048f68 +a254df0efa4203fb92b42a1cd81ca955922e14bf408262c8f7cb7dc703da0ca2c71556bd2d05b22ce9a90ad77309833d +93263c507e4d5f4e5df88e85b3d85c46ea729fb542a718b196333e2d9fb8a2e62dc1347cf146466a54ba12d200ef09d9 +922e3c4a84246d89a07aa3e90f02e04b2cea9bebc0e68b742156f702aed31b28c6dfa7ac936ea2fc2e029adf68361f98 +9a00628eeeda4ccbed3ef7834149aec4c77aac1a14bc2491ba5d1a4a2c5d29afb82ceaa5aac1c5ce1e42cdcaf53e30ba +ab3a88df36d703920f6648a295a70ffa5316c96044f39ff132937bfda768937cb6a479e9ba4a4e66b377f3a9996a88c4 +966b11526ab099d550ab33c6a9667e5cfdedf255da17a80a519d09acd78d2ea24ec18bd1ea7d8d63cf0a408f1c1fe0b3 +b5c21b9817dc32f3df9d9988aa3560e1e840d586d01cd596bc0f850ab416b6013cbf7dbfd05ac981f26014c74bd2d2b2 +9040abef5e2523e7f139c9f744a64b98fea3a57952059ffe4d5ed77fa87068203c090ef4e7f52c88fb82ea8a6fdca33e +a0dcdaeb7d3f5d30d49c004c5f478818c470187f4b0b4856812dcd1b3a86de58a99acb8ceb44c6b80c3060cf967c43a4 +b5f4be9a69e4a6719ea91104820df8623b6d1073e8ee4168de10a7e49c8babea772bcbc6b0908185e98d607e49cd3609 +8634020a5a78650015763c06121c606d2dd7b324aa17387910513dd6480fb797df541fc15b70d269b2794ad190595084 +9504d1d0fb31ff1926c89040c04d51fd1f5cddf9d7ca3d036e7fd17e7a0f767ef33cee1d8bf7e17e2bc40949e7630417 +812c72846ef6d692cf11d8f8c3de8fa78cc287303315114492667b19c702cd24d462020f1276895df26e937c38f361f8 +8c97aa5e9ef2aa9a1435ef9ddfe62e850f0360864ed5fb82bf9fef4ef04d8fb4f827dc078bc911ee275e4501edd6617c +ac5f7af5e23c8e429aaa6b6825129922b59d25b4608f07b65f21388a9ac3aa89096712f320afe6d56e44e1f0d51a4eb9 +a8c84d9a8593a0cb5be1e450960f59878a4e6b70da54a7613dfc25911b7cc9e6d789d39401b0a0d6471ab9dcdc707976 +8c9d5fd89611392c0f085ffa4fa642a181f0b9b23593deb5e10fdd1642722ca75ef34a037e88a8d03f2888fe7461f27c +8c74b05f91fb95c85e7bd41f6d9a1e41e667e68f3d19b325c1f25df1767019919edab89b92af237896cbc4e6d6dc1854 +a3caecb91640821f0b2c4981b23f2069df8d2b98ce026c1538bc096b292f5f956a5d52c1c8d6a8165a1608083ba6494b +8ae8e0c36f8b79a69176ff29855df45d0fcd9e4d1dbaed8899f8fcdece676e418ec034a6c161e2a894f0c834aaecbfd1 +b88d18c67dc3b1b6ed60ee437c441c1ed14ecddebccf43683605716f30058b1aa4ba05ff10cd8171ee97d8f58d70c094 +94f43d84dcdfd9cd19115c7d8e9c1e856828eafbfdec93b876cf0007e317e30b2ad951dbabc186aa6ef90fdee4d91990 +b44e4723f41fc1d5b0057f371e3381ae02566590b3f964b6eb07b2104f66ff78410c407235fa98d04f635694f3baca09 +addd8390173d29ca0811534d389253831fed75fed135398617836b6e70767269eacb1560b39a58f02042ca3b97fe59c4 +80bdbdacc0c358c7ea52aeacdc5f9ceb6928bcf6e7dee7c17d8ae3bf7c2372aa7a0372363888968fc0921aaf4776d5d0 +a486e2b6f04f403f9e609d69dfb3cfb992af56ecad1683271df3e3faa3b86638b81e73b39978fb829ee7133d72901f2d +a19472da57457e10c6a6307895393ddaec8f523760d66937fe26a025817319e234eaf69756ffdf1b84c81733424a96d7 +ad6a195397cbc2d75171f5e82090441eed60bd1ba42c39ef565b8b5a8281b04400678625b1dc46d617f694a7652a8e5d +8f98e721c06cec432e2221f2e1b06bb1469d916a8d88d6973acf68d1e003441d00390dafcead8ecdbf9eae4509baf5aa +91d62a0f9d13c59adfe1376ed6d057eae244d13c6b3d99be49a49e0075cf20f4085cf127774644ac93615be9ac9e5db6 +af45dec199245e2b326a0d79c4899ed44b1c0219db42602a4a6184ace0ff831a3276297af28f92e8b008ba412318e33e +8754bde54e8d2d169e6a7d6f0eae6097bc0461c395192bd00dd6f105677ea56ab384c02553ea5eeac0a65adcb0df77ee +b676afd2f5afc37a314c943d496e31b4885efcbcc2061036e370a74cfde5642bb035622d78d693bfc3136fc036c7edb4 +aab6ffe6cc234397cf1822e02912bc282dfb314e92fb5a9e10d0c34ee9b5856d4b76e166bc2bb6fcdd66aabea35ec4ef +ada6e62f90ee6b852ec4b72b22367acac2896f0df2c105beda27096583ddbedddc710d171330569f111c6e44a5b57ae7 +802139dd15241a6de663d9b810121bdd9cf11f7f8c8ca6de63f4f8e731409e40d1fd3558b4f619ed42ee54929dff1c7e +ad8e70531cec21b4e6f55be1751c2d025bd2d7d8158269b054cfe57fa29252d052ce4478ec7db6ec705789e2118d63b3 +a8e4a4271769480e1b33a28c87a150ecc0b48bfe8a15ae04152197881de4ce4b03453aefe574842424edbbe4173e1a3a +b98c65726296610cef16c5b58da5491acd33bd5c5c5af4d934a9840649ef85730fbce8018dee09ded14e278009ed094a +8e213a7861223287b860f040e5caaa563daa0b681e4e09ec79ad00cc459238e70bbeaf7486bbe182fc12650700034ec5 +a2879f9e1a556cf89b9b5b3bd8646a8cce6b60bcbc8095df44637f66a2da5858eee2dc9091475a8f64bb5aff849389cd +8a17cdb4077b9b0bcf28b93294ac5ae4c8bba8839fce0f1012b53187ac008f9858b02925fbfc421f1123afcdbd8b7753 +86fd9c11528aa43946e4415ff64a3ca6409ee6f807368c68997b18605da65e415ccd85ad913820d450cb386593de666d +8ed55923b963c3d85a91aca11c40ff9c6c7f1e2b9bc199d1a270e5fb16aa62dec0136e97866145ae9d58a493e8b1cbbb +ae32af5b5d418668ae123c639b149e5eed602404e8516da4a61db944b537a3620545e8e3d38cf10cdaea980ab2f80973 +95cb8d9e9d6762d78dde0ad73869ffaca904a7d763a378b8cc11a7933d3e7d1c8aec4271a079b1b00f8887ee5b1ea21f +b5ea20b42a3ca247f00ab5328c05f0cf194973d5f7271c66c41c5055b1ffdca136be179709e0c1de209fbe07b9820bf3 +98682f7cce471c92a8d6d15fee4ddf4d43dd97c3e3811d2913618ecacc6440b737717c07736ae4558c910e11ee98104e +a67da2c7cbba48e929ca4e4b9a6299fe01ef79eff8cc5cd3fdbdc0721a68130e4079f30ae151a573a7dcca8ecf2e684e +a9981c9f9dcbb3b0f6996f664fb2acd7573189f203be37b2b714662aa273551396abfb1f612ccde4e4c8127a050dbe4b +92d55eff8da600f886da9bf68e8eecf482faa4b268f3f286b3b3e5cc91b19604081498d4905b201bb4ec68e32b5591d9 +963e3f1728de9d719c86d390f3eb9c3f99d1928347fab0abf10dbb37d76b59ddb64d4734c977863a6cd03ffece5ca895 +93480e2de83c921056b6d8628ac37cd5ef7555ba43b0308fc13386cb0515d42c12ecd06057137aa71a7931beaf90b9ce +8feae57ff0e6a162cc81c99f45c6187d268fc0bee8c2bffc92142ef76c253d201f0e932943cf2fa312982b281ce1066b +8f8f4bd4200fb87afcd743274480220d77571928000d4197410dbb75439d368df6a06d941a6152206371d2ca9cac99e4 +8ee7f11e79af4478e0a70eb424fe8078237ad99ba6d7e6bf1a8d5e44e40abd22d404bd39b718ad6fdf4c6601f2a47665 +a98acfcec612b574943195b9ba95bebcc9c0b945c9f6b3e8760b2a4635909246a9d73b0b095c27b4ecb3339704e389b7 +b520efd19f65e81dc285031ea3593f8c5dad793e4426beb9196ab46e45346f265fd71e50adb0da657977c60ed5724128 +a3d9d0b7415280ce4dfa2429d47b2b8e37604a5157280a72cc81d541ffe44612dbb3ef7d03693fc42a569169d5842dc3 +8c29e2d0b33801f6d9a9c065a76c5cad1fb0a001506b970307e21765ee97c732a4cbf1d7c1b72d95e0ad340b3b075224 +839e21f292892a6eb596b9b1e9c4bd7c22a6fe71d3d04487c77840028d48392c5cbe73140a4e742338e0c8475cd0c1ad +8bea5c68e7743998619185bb662e958f1b4d3ca81019d84ac43c88911aab3abe4ee9bcc73cb95aa3ae87c0138801bde3 +b8f262d21a94604049e008ce03dc857848168e1efca4522acb0ccc827ffb37f545e1947843a356563a76bc6489605b66 +a7bd0842b0bb38d9943b82aa883f36f4eb8a6e8a7790d4f87faf306608f51d250a19b73984f1156cef5dd2581664614b +a993e649bd953627a88a2539dac3a12ec7f37a4c65b01425d9d34edf7ee10a71aa98f65c9e013107f824faf8aee041a9 +8e07eced75c67cb4d2ec01857f6ac1408482e6b31cb2faa249e8cf99f180575587df530c7782a7539b5221121ef48aa0 +b2f4578f26c05ecb9e2669ca744eb19d4f737321ac7d04fafd18beb7866e0fec9dd063953ae1f077b44b9c6f54db1279 +b6b3788a6c7bcaf467d19daf6ab884d549aa866970c05a9181f544ff190d043192c84fe437a75a30b78b425461cca062 +a270684903c61544b85a7041e81f65e787e1c1e23e57538fa8a69836bed0ca1673861dd29f743a1280f2f38eddd3aa83 +a9c2397c4773dcad2821266dadfd2401d013d9f35de6744f2ec201f3507700adb1e6ec4f5a453be4764da8bf68543f26 +83a3025ed6fd5df9d98be32a74e10a0d9728b560942d33ba028536fb148fc34ae87e92be2df3e420a8dfec08da495982 +90dc70c183a90bab988b4a85b7b921c8070af0e5f220364fe11afa0722990b2c971e1e98eef62d3287fedfd9411f1df7 +82d940937a6c636224d04f8e2536f93dcf20dc97a5f188875ad76c21b804aef9af10839419b61143c1f88a695959a6b4 +8017f9473ce49d498d6f168137e77e62fe553e5a51e75b519cf2cbd1ab9afdafad80fd5e6fd0860e640b0d78ca8ed947 +80573a0ec049fe1f7b3013b2839e145cd87e07c0e43826a29ef8c92516f9a30896c2ffcf3ed77ed22a6cf3101b1789d5 +953349abd2559f9824db07cec857ad54f1a05018f3076425f8dbae37f8d92a46af2c04ab7c8ec0250449541187696e98 +ab7bd2c4f05ee9a9f252c4e16a20993a12c535c3809d124bae24642616521a9768d3f19eceaf8524583f47ae1f527684 +9883b77ee834ee0112ca2f366d2a6fc213e0cf454e061438c2901a5ba35b7378f64da8adf6a476eb1562991ef5b4a5bc +89291811db308637356dbf7ed22cf07bfce33eb977734ee346e8c15a231b35d8b4443574f3fa97a40867b3e23b0bbfa4 +93d753849d7d9588d39e38217500b123a6b628a873876612d9f98b5d611f52c89c573432d2176752b5d1cc2d94899b8b +a45add3c4844db3b7a237295fc85fddc788ac1ec395a0524d2fc90a539571a247146aea4aa10eec30a95e9617c85b98d +90f94578842db7a4de672da1e483858ece5e466c73c12f725a0fc71f42ff880c9447a33fa9096839bee817536f2591e2 +b2c1b6fb031bb30460f157356562b44b4de096a0a112eab4fb3cc500aad38bc770da1fc2e73caf687a0da5e8537049c0 +afb15e15fd930929c0e3c66482068a5afe0c7b7f82e216a76c5eb1113625bfa0b045a52259d472284cfbaf4796c71456 +ad222a9a3d907713418c151b8793d5e37634354322068f8206b9d0da1a3f53b0004193713d23ec35990639a1b6c2e075 +b44a128dce97e8c4b178cdbca0a5c1b3f6e164490fac0fd68dbfe0aafa89920bb4ea420a8527e06c80dd19c2f135e3ef +8596e993ef18b8d94e9c42a90cb7060affc586b8e9b526820d25124285de5590134e2e86592e9dc4dd45ccf5d578fa60 +b71bb0ad138141ed506b2253e84110d2db97cc2d24a3fd0d096b0022d9f38f87aa74e2f505074632d64e90bcc491aa30 +84841eafd357309de47b92ca5ec163dec094a2e5271bc65898c31932e0160bee165e4decb23af339cfe09c83e1cc5441 +8a2915ee39a6fd4a240b98533d7690ef1773ce578ed1fb05ed414ebe36f7ef289fa46f41768df57190438c356331e329 +90bb337165386f1990cbd8ed2e8321ef21bc18125b015b4da0c37e5fcc446b26005379ee4fad8ce9348ceb4ab49e82e2 +b707b50ea2ab05c6d183671587f25fe29eef23fe569d731459a1ac111a0b83a2cd65b88242876b34aeead3b05a15d745 +ae1f159f79b7996315c4f9acce7e21a6ed59d4ef76331196fc86911fda3035edd5c11d568b105175a36c948d0263b382 +922bc525bace05e5dff6b5cabde5469ddd2c1c601f7131abc04ecefdd35095e6ac015b1aec3c3b25c5dee8d139baf60d +a7b060405b2740f82db64683187b1bb89e5f40c8438663c7cbc8ef2513929fe5f92625667a7f2f599a72a96b1fc8f08a +b9dfe94a08651db5efefbb813269bce80d814e3089b80c0654491e438d820bf521f8a4a4477909344ba88f7683eebb43 +841817a9729465743576950b6e8eea32ebf39cca99ace86c4792f9f35926e2d6830c52854a3b2eaeb61694e6845008bd +934128034bde8fc7b93b952aa56e0ed28b36cfa04cfa1f0d5b38266dd40beedff5e0bab86e4717b0fb56c56be2eae26b +aee9d64caf28596308782cd8f3cf819506daf3378f86157ff775e618596411adf94efd0e9542787ca942066f02cbd332 +85871184db314411a49575fee088c52ed5dba4e916ee001ec24d90898a0154d9790a06aa8a707ca7a8b986c0293b8d89 +8d3d87edcc0187a099c97b581a598d357a41ac152303bb27c849eb78e72e15cb97cf9a0468fc36f245c3e152c76bb7dd +900475d165dec18b99eb7b5f9e9ad1d2d4f632e55fdcc4c5ecd7775fed462990e6aaafe9c669f40508f9b15f00bda31f +a25b5954edd57e7811a0d18532043d975c7b44b80f65cd630935d7b16ada05f30fe2b7be7ae8a2f54c25957faf3f1950 +a089019afa3a7a15f7e7874e73b6773c0a824e6d3379b4c928e173321fb165ad979a6be004d394c28d19d410b2655d3e +b28f46797dee0c538bd3de815df641a0ef718ad3e52b2764aec380d6905b38b50ad6f60d0f68e096ca39960ba7734355 +b0ac155d3d05851b04104e6b459f1a68e9e155437c92421a7c0e4dd511ef89cf71dfa3cc920769492ee283a65ebf029e +813c69a810745580d43d5b5480f0ba81000fbef0071e6b655c7346bef5ed774e9214a7816d40eb1774a5bd033767a046 +b176345ca75c64f10ec33daa0dcf1f282b66a862fcd3d8d66c913f9a02db4c9d283dadc02eff13aaab94bc932a42234e +92560f67e5b995db4a489bb86ee78b4aee0800143b3535ad557a53e9e08716bd0202d9f5714722c2a5e8310046e3f5b3 +8adb427bad9cc15fc6c457a96a6750dda8c46d859c5f69bf0e7ab8fc0964430b33967fd47cf0675b6ba1757f91255e6e +b120f723b80389a025b2daa891b140b3d7b8d520ae2a6a313f6e3d365a217af73292dcb249dca1f414ec05e865e3cdc7 +a61a5d261a8dfe5996c42ea0a5ae703a2adcfda80e86837074d868eee16f87d38da19596c48b55dbd7a7cbec1a9b4996 +99dc921eacc6bb867c5825ad4c83bc4af9dd78a18b3d0e1a60ad493e3805b8fb9b7922b577da1adb3d805edfc128d51d +85455fa165a07282aaab4a5bfb88027f47b9532e4af8195c048515f88b0db7e80f42e7a385fd4944faaa7f2a6544ad17 +96dff2d1c8a879d443fe576d46bcceaf5f4551d2e8aad9c1a30883637c91090de99ad5eec228eb5febf93911502d3cbb +a87eb7f439377fb26c6bfe779701f4aea78dd7980b452a386afec62905e75217a1996c5234853432a62ef8bab21c31c3 +b598278293823e9ccb638232a799211173b906444376337fdf044d0227d28fcc4c5867e6ecb3200e59ca0b139e71cac9 +aa6fe147edc95027654d68140f428ec53cede3552c5f49c09d18bc6f6ae8c739a63042eb7291d14d717a4e1f0778abcb +ae8ee18913d328b2fba71efe65526d3ee9c81beda53cf776baec4019ea30212010758cbb5dc85ed6620ce04b189f01f2 +ae9fb686777e88dffdd42805fe4114aa0da1b350d92a27ff3f8a817fb25af1fcfc9a06155affe0273bf13caad16a5351 +95d372ba3a2ee38371538f34aae91b4844488e273f70c02f1992370f89fc2343eff95692d52ce9f21206abbee4959958 +b15260376f0a34ca2827ff53acd7eaaef94c9acc2f244b36500423069cb1cdaa57ac8dd74adb5b53d0fd4265fcbb28ea +b0ffce6a8059537ef6affdbbc300547ef86e00109289239b0c6930456c562b4ed97f2e523963af17736dd71b46c44ac7 +b5499a1277d34f9892f7579731ff53f423f2ffffa9ea43a6e929df8c525e301396249a2324818a6a03daa0e71fcd47b3 +98dbfb8e97a377a25605a7665d4d53e66146204d8953afda661ae506858c5cd77ff7f21f5f10232e06dbc37378638948 +84177e27e6da0e900c51f17077f5991e0e61bff00ca62c1623e627c5aea1b743f86eef6d55b13219a1947515150bade6 +b50407bb5c61b057ab8935df94fd43ca04870015705b4f30ceac85c1035db0eb8293babc3d40e513b6fb6792ecbc27a9 +988699a16917514e37f41ab5c24f4835ed8a2ca85d99972646fcc47c7e2a83c2816011144a8968a119657c4cda78d517 +920c43fdcb738239ad542cb6504ab34498bce892311c781971d7db4dec70e288676de4d8697024b108cfa8757fa74035 +aaa106329aac882e8d46b523f126a86d3cee2d888035ce65c0be4eaae3e92fd862f6ac2da458a835539cccafaba9e626 +96e4c1562d14b7556f3d3e8a1b34ea4addc5a8170e1df541dc344728bcb74cd1630eb7ba4c70e9c68fd23c5c5d5a729b +a616ac5016d4e68e03074273cd3df9693ee0ce3458e8758b117a5c1bc6306dd2c7fad96b1bb37219c57ac62c78ad7a3e +8db7d9b20abfb1445babd484ae9e38ff9153ac8492230d7591e14e3fca7388a5ca6ef7d92ed445c8943cf5263e4a6ad7 +88464134221aa7134878eb10928f31c8bd752ab68c27c9061c1de3f145c85731a4b76acdc7e939b399b6e497f9e6c136 +a5f7c794f70b7c191c835dded21d442b6514bab5e4d19b56f630b6a2f1a84a1d69102d7a0dcca256aab5882d3f30f3ca +b96b6f98b6817b5fa6b1b1044e2411bdf08bf3ffaa9f38915d59e1d2b9bed8b3d645eee322ee611102ce308be19dbc15 +92c26ade2e57257f498ac4ff0672d60b7ea26dad3eb39ed9a265162ccd205c36b882dba3689758c675f29e20836b62d9 +8379a0299e75774930577071d258e89e471951642b98e5e664c148af584d80df4caa4bd370174dae258848c306f44be5 +a0e53beda02bd82bf3d24bd1b65b656238128e734b6c7a65e3e45d3658d934f909c86ca4c3f2d19e0ac3c7aae58b342e +8ca5ceaeaf139188afd48f9bf034d8baf77bbf9669791c7e56ebf783394d7fcdf2a25fa4bdfcddfde649aa0dc67ccccd +a8060e6448844e9db4e9fb4da1c04bcf88fda4542def5d223f62c161490cf1408a85b7c484341929c0f9ce2a1d63e84b +af6e1a5ecf50b754bb9eb2723096c9e9a8e82c29e9dcaa8856ab70074430534c5395534e1c0ed9ce98f4b84d4082fa67 +81c8dbbef98f1b561e531683d5ae0f9b27b7f45dc6b2f6d61119ca0d559bf4ceb676d320afc5aba1811eeef7547a59d8 +85b46cd64d605c7090a2faf1a2aadf22403b3692b3de1d83e38b2de0108d90ac56be35b0dca92c7a41c4b179a3567268 +8dd3cc3062ddbe17fd962c2452c2968c73739608f007ad81fa1788931c0e0dda65032f344a12249d743852eb1a6d52a9 +8630f1707aea9c90937b915f1f3d9d7ba6bda6d7fdef7a40877a40c1ee52471fd888f84c2b2c30b125451b2834f90d3b +b4a747e0bd4e1e0357861184dacec6714b2b7e4ee52fa227724369334cf54861d2f61724a4666dae249aa967d8e3972f +a72de682e6f9490b808d58f34a0d67f25db393c6941f9342a375de9ca560e4c5825c83797d7df6ed812b71a25e582fff +8d5ea7d5c01f1f41fffe282a334262cc4c31b5dcf31f42cc31d6c8e37c9bd2f1620a45519dab71e108fe21211c275b6c +8ccdc7e3642c2894acbf9367f3e99c85963cea46dc5473d175339a2391be57dd8815feacadec766e13645971213b9eb8 +858e9b5fc8c13b651ff8eb92324bdda281db4cf39f7e7bd0472908b3e50b761fa06687f3d46f4047643029dc3e0ceeaa +ae20d36c70cd754128c07cbc18dcb8d58b17d7e83416e84964b71ccff9701f63d93b2b44ec3fddc13bbe42ebdd66221e +860dbf7013da7709e24b491de198cb2fa2ffd49a392a7714ad2ab69a656ca23f6eafa90d6fdc2aa04a70f2c056af2703 +8f809e5119429840cb464ed0a1428762ba5e177a16c92581679d7a63f59e510fdc651c6cc84d11e3f663834fcafeafdd +8d8a8dce82c3c8ea7d1cb771865c618d1e3da2348e5d216c4cbbd0ac541107e19b8f8c826220ca631d6f0a329215a8d6 +86e3115c895ae965b819e9161511540445e887815502562930cedc040b162ecb1e8bdc1b6705f74d52bf3e927bc6b057 +b9833b81a14115865ca48c9c6a3855f985228e04cbc285f59bf163dca5e966d69579ea4dba530b1e53f20bd4dccdc919 +a71f5801838a6dbb162aa6f0be7beea56fadac1a4bcd8113a0a74ab14fc470a03775908c76822d64eb52a79b35530c05 +a77ab73ae94b6d3378884f57eee400eff4a2969aa26e76281f577a61257347de704794761ea1465dd22a6cc6304fbc4a +acd1c5df3c487c04cf27f002e81f2348a0119349b3691012526a7b0d3bf911cdd3accbc9883112ed2ba852145e57fe68 +8a28515a48832ac9eaf8a3fb3ad0829c46c944b4cb28acbcdbca1d0d4c3c623a36cda53a29291b8f2e0ea8ee056b1dee +846bafca11a7f45b674237359b2966b7bf5161916a18cf69f3ec42c855792d967d3bf3f3799b72d008766206bb7a1aa3 +b24b341675b1db9a72c3405bbe4a95ccdfd18fa96f876ec946ccb5108f73e8816019998218a036b005ef9a458e75aeb3 +b99c267b4a09193f3448bc8c323e91ef5b97e23aeff227033fe5f00e19bab5583f6e5fcb472ec84f12b13a54d5c0e286 +a088aa478dbe45973b04ecafbcbd7ee85c9a77f594046545cdb83697a0c2b01b22b1af0b97dd75d387bb889e17f17aa7 +a0c6b0cdff2d69964134a014e36c3709d9e63f6463c5cd7b01b6f0be673731b202d577539d89dd57a888326da1df95af +b4e6dc4ef11b2b41794ece70a8968e56705199d183366759568b6fa845d2cae127486e926b5b27ae9118bb21d1682c1d +a007804353f174098f02540a57e96227232444d5ae0a24232c244647148b6c049848cbd2b50d0a25af3ca9164bfff8ee +873fb034cc39c9cee553ece908fbf315f62efbc412b9afdde6a1889326b7f6f813e050b0601ba9921688e958cb75942e +b5676c90f0106c40d8683299e59d564f505ec990230cb076caef3ae33f2021e6aa5c9b27bb8fead05fc076df034c28f5 +b5a67fc4c5539ad1ddf946a063110f824f7f08d2e4d30762c9d437748c96c9147a88efc22260573803ab545c18b108f2 +817ff2b748a949973a91b69b0ec38efbd945aeb26a176d19f0fb76e261c7526c759e6f5516f9ed34de6eb1ac7838c9cb +99b76bda3526a5d841e059010fdb14eb2fa035a7d10463373a062a98c3c1a123e2da0848421dd7546d776438fd05e304 +aa0d363270f90d56bbee7ea577b0c358532bda36d9247af6c57d000044a97ba41e35bb0db438f4c94551c6350e4e0674 +acdae205d05f54b9544be96c9032350511895ccf413dbbc56d1f03053185df22a6d5b7ffcc3fbe96c3e2ce898ccfa73e +b091c220a1de18d384f50dd071dca4648ca4e708162c52a60e2cedc0188e77c54639f75bce9a468a64b2549119c07ded +878676133e5c700b1d4844564fa92a9930badb5293d882aa25ee6721a9f2cfab02088c31d62cf1342ae3edaea99a1ea0 +9756d0793e6aba3b4dff48100bb49a5ec08ec733f966cb438379b91caf52fc2a5930830ec3f49aa15a02c82c1914dc7a +9722f760184d3b2d67cb2cea7fa41b1ff920a63446006bd98c6347c03d224d2d8328fa20ccd057690093d284b9a80360 +b5a68489de4f253715a67f0879437bfe8f4dfc4e655ca344848980e6153b1d728acde028bb66fd626fa72eedd46ff683 +a8cfc900b34835d9fd3add08044636f69614eff9ae929eac616c39bd760fd275ee89bf24b0f275dd77a66e54fd6b94e5 +89967479bebf70b2893cad993bf7236a9efe4042d4408022fdbb47788fabedcec27d3bba99db778fcde41e43887e45af +889235938fcec60275c2cf0f19d73a44d03877d817b60bb26f4cbce09db0afae86d42d6847b21f07b650af9b9381fa82 +b7fc321fa94557d8fbdd9fff55ab5c8788764614c1300d5ef1024290b2dbb9216bce15cb125da541f47b411a2e7e3c2d +b11b0c4dc9477176b3cda6b17858dbd8c35a933ed31364801093f310af082cb5a61700f36851e94835c5d4625bf89e32 +9874e54d2939ee0600f4194f183877c30da26d7515e9e268fea8d24a675dd2945d1565d9016b62b1baab875ac892f4d2 +90df3a77280d6f1fa25a986309bba9d5b89c3cf13656c933069bc78e6c314058716b62eacfa7ab4aff43518b8b815698 +962b08299a287d77f28d3609f39fd31bc0069f7d478de17539e61fcc517045050644b0307c917208b300ce5d32affcca +b30eedca41afb6f083442aaa00f2e4d5dc0fda58e66aaf0f44e93d4af5c4bf8ea22afec888cacbf3fae26d88e8d344cc +847747a22fab3fe3c8cd67f3f1d54440f0b34ce7b513225dc8eb4fa789d7d9f3577631c0890a3d251e782a78418fecfa +8d1ef3cb5836e4039b34ee4e1b4820128eb1e8540e350309e4b8fea80f3ae803d1f25f4b9c115482b324adf7c8178bc7 +8f8a2b0b0f24f09920b58c76f7d99ec2eb2e780b5a66f2f30a9ed267dcaea0ec63b472282076c7bf8548211376c72f6e +831ee6dc8889bbf4d345eaeb2f425959c112d2190764abbbe33bc44e1d9698af87ff5a54d01fac00cfee5878dee7c0f6 +a7eb2479ac80d0ee23f2648fd46c5e819ad3a1f4752b613607ae712961b300e37f98704880ac0a75f700f87d67853c7a +aa4d1b9cec62db549833000d51e83b930db21af1d37c250fdc15d97bc98de7a5af60dbf7268c8ec9c194d5d5ccda3c1d +87396fd7e78c4bcf270369c23bc533b7fb363ca50d67262937dab40c7f15bd8448a8ba42e93cf35fb8b22af76740d5e1 +a958b2a9ffccbca13c0c408f41afcfc14d3c7a4d30ea496ce786927399baaf3514ff70970ef4b2a72740105b8a304509 +a5963a9dd3fe5507e3453b3b8ed4b593a4d2ced75293aee21bfed7280283348d9e08bf8244c1fce459aa2470211d41ea +8b06ddc3359827558b2bb57caf78b3e5a319504f8047735fcc8ec0becf099c0104a60d4d86773e7b841eb5b6b3c0cc03 +9437e7278283f6d4d1a53d976c3c2c85c5fe9b5aec7e29d54a5423e425b4be15400ed314f72e22e7c44ee4bacf0e681c +b56067ee26a485ed532c16ec622bb09135a36c29b0451949aa36fee0b0954d4bf012e30d7e3fc56e9f153616b19349bc +a5c72f7f5d9f5b35e789830a064a59c10175093a0ce17654da7048827d0b9709b443a947346b0e5d96b5ea89b8d7c575 +a8318d01182d4c9af2847a29a6b947feef5795fc12e487a30001cc1ec482b48450c77af4837edfa1aedf69f0642c7e5e +82ea421c091552d3dafa7da161420cb5601b819e861dd2ba1a788c3d1b5e8fa75cc3f2b0db125dde8742eb45b335efa2 +8679fd1c7771ea3b12006d4a972f4f2892e61f108107d4586f58ee7f2533d95d89b9695d369cdace665f19c6bc3bc85e +b5ab3e8adee4c950fce4d33a0e2f85d3d886e60a6e2f4454b57bc68725f0cf246372d863167482cce1ea10a7c67c3af2 +a85696927075ec188979180326c689016a0dc7a2f14ae02ea27c39ef91418cd44177d3fca5752cf6b298fd75fa012e26 +a44f87b7232f102cd092f86c952a88afb635484a984da90a41a57a3d883c9469064bf105b9026024090486b6c6baa939 +866ac91a437db945bbfdc11fcee583f3669fa0a78a7cecf50fbfa6ed1026d63ad6125deba8291452bf0c04f2a50e5981 +b780d5a1e278fd4eef6139982e093ceafea16cb71d930768dea07c9689369ff589d0c7f47d5821d75fe93b28c5f41575 +b025d0046e643506e66642c2c6a5397a8117bbfe086cee4175ff8b7120e4f1e6794e1e3f6ec11390993cca26d207ae43 +a04a22b6e28c959ab265c7f48cde42bb6a00832c6beb2595b5df2879080a9424890960417d7d7ceb013d697d0ebf7267 +81de9c656ac27f54d60d0252e33aff4e9e9e9c3363a50740baf15a2b9061f730a51ae1704e8c4a626153cf66d47f19b1 +a15fab90599df889df11fa60c752948b68fba54005491180dafb66c5775547976d0eef33945e55d4818653e0818c6f92 +b06f9be44ddb103a72fa4ebc242c8ee1975fe9bf9ef7124afeda9967ff3db644dbf31440151b824869406851a90984a2 +99abdfe6806ae5efa2d11577da17bd874d847c5f810460148bc045bcf38c4fd564917eacb6ed61bb9164ed58055cd684 +ac53231077f83f0ae5f25e52b70bb6105d561c0ba178040c11c3df8450c508ed5df34f067fdaacf716f90b4926f36df5 +99e3f509af44fc8d4ebc693d3682db45fd282971659f142c1b9c61592573a008fc00502c6af296c59c2e3e43ed31ec7a +98f2f5819670aff9a344e1c401f9faf5db83f5c0953d3244cfa760762560e1c3a3c7692bb7107ea6eaf5247ac6fd7cc8 +b5b9f90391cec935db8d2b142571650fcbb6f6eb65b89c9329e84b10bfa1c656026674d70280ade4ba87eeaf9333714d +b0696b77ca8a0cdbe86cad12f358880926906fb50e14f55b1afc1e08478ae6376215cbb79bc9035de2808c7cd2b13b85 +a51d746833062a65fd458a48a390631d5d59e98e2230b80d8f852cfc57d77f05eefcfd3c395ade1e86d4a39c2141365c +812d67654319f4ef3c9e4a2d4f027a4cb7768f1ea3f5fdde8d1b79187a4b874ff9a5c70f15b7efa079c2dc69d1b9b1fe +968978b653c6416bf810f6c2ffa3d1abbefbd06f66b6686e9a4fdce3f869e0ab1e43cce14dc83786596761c100ae17e1 +98e1e6ab562ca7743783b802faeb0a24f1341abfb9655f106920aef08964a3c0e8083e1acda7ae28fed7cdd5478decb6 +a91c0b982a0a7085a103600edf99e9d0bee4c4e7db6d9f8f376c215c7d42476218462a3765f2928e12c3dd49d688e4fd +8a43395b3124fab9e2438635bf88952e8e3084dad7ecb3a9927f9af0e0887bce4707084043671fc98ad03621e40a149e +b0b37626143d4a8c6f5693d5f1fe871525b4dd946c4239cde032b91f60a4d7a930d7ba28959737550d71c4a870a3a3be +b01c74acae1715c19df08d5f4a10e0c19d1356264eb17938d97127bf57e09ced05ba30d0fc1a9f32d6cff8b0d5f91c9a +b4c2328eb8a5a673406faed8f0aebb8540d2791646e37ce46e0e382506570ca276eb6f8e166dbbf9e0a84064873473b9 +85cb9f769a185e3538e4a4beda9a008694e1bf8dfeea9dc07c5c40a9ceb1d31fcb13cacfaa52849ba1894b5027cb8c30 +8742f91cddc9a115ddc73982f980f750d82d3760f2d46ee4490d5b17c6c3bb57c7d4c7b8d6311b7b41e59464c009b6a5 +948ef86d17128a061e1bdd3ea7fcc7348e3ec87ec35dc20a58dd757d5d18037fe5e052bb359e27ab4c2320d9a52a6a0b +a70f6a214097c271e0d2d95e30fce72d38c30a2f186271fdff0e38e005aff5baed53739b8c4f9501aa7f529c5cb2da59 +892a7574cf6704ad75b346c95ae6f2668904f1218c35b89b07a0c2dbf3c62173c348f6fd9473926eef56a37c0f635c04 +837e85a41f39b4ded1420aa8fc3be46a7adb99305e0928c6d7643b7c44434b72984cea08eb68f5f803661df0db78c87d +94e495329f2aab3eeb68f347961d1006e69d990095877a4dcc376546233adf29a14bf6b16a0c39aa477e15368e87014c +851860a8fdf76a97048396553262637dade27f1f63f926997e74c7c72b14b10293eae7824e8dedffad1aead57c124f79 +90481017a250972055ab1cf45ff17d2469517f10f18c9d4ef79a9bdc97a49093289bbacfefa8a1e491bbb75388b34ac0 +983db15f7463df28091c691608ca9c51095530fa6b1b7b5b099c612e673d29e16787cc9ae1c64370ba6560582ce623c0 +a477dab41014c778a1b78a7ce5936b7b842124509424e3bfc02cc58878c841c45f9e04ccc58b4f2ff8231488fff0b627 +868ebba1c85d1f2a3bf34c0ab18721ea725378b24f6b6785637ee4019e65d4850e051c8408fe94a995cc918c7b193089 +93cbf4238a37ccd4c8654f01a96af809a7d5b81b9e1eab04be2f861d9d2470996fb67367e5bf9dcd602dc11a3e4cf185 +83113f4e696030cca9fdc2efc96ba179cf26887c677f76cde13820940ad6891cb106bb5b436d6b0f8867f2fd03933f7d +90c709f4e3359a6d215d03f45ad5cf8067aedd4aab03512dd62229696485a41dcd64e2acce327fda390e0352152fce13 +9945cfced107a36f3cf028ba04c653360afc5013858b9a12fac48802efcbc198c9baf3a7f9b23dfdd5036e88bc7274c8 +832ae60192b47fc735a8ddeaf68314b16256c90ab68099f58e43073e249c6939895c544a02fa34e40805bc6b5db33461 +8b12c335818b643c1d22cbc2869606cf64e7ae54a7713617fc4dd3b2f052ebd6b920ca59ba2e9c7aa8cf71bb4f40f9e8 +a2033eb7a373931c65d66989644aa0892ac3778b9a811b2f413d8bf534e282c339717979f9aa742162abb3468c195f87 +aba2b4c37dea36bed6d39323e5f628ab607699c66767f9bf24ef5df1bfcad00c2664123c0d8d5bd782f1e14a06f4c769 +b71963777535b4d407286d08f6f55da8f50418486392a0018ee10f9ae007a377b8b8336f33386b0eb01c45695c3ed2da +88dc87826941340913b564a4f9b74985a311371c8e7b47881235d81c081f1682bef313c2f86561a038757fb7d6a1a8dc +869e13e3fcf91396750150f9dc9307460494c1d365f57893fd06fb8acf87ac7dddc24e4320d9cad0414119013ea739b8 +92194e292303d32b91ae9cecb8d6367c8799c2d928b2e2846dab1b901371a4e522fc4089aad8f4ee676f0614ff8b19d7 +aa589a3e512cb4f8589bc61e826a06d9f9cb9fdfd57cf5c8a5a63841435b0548e30a424ca3d9ef52bf82cc83c6cb1134 +81802e0194bc351b9a5e7a0a47911d3a0a331b280cf1936c6cf86b839d3a4ab64e800a3fe80ea6c72c3751356005a38b +88e5e9e3c802314ddd21cb86f2014948b7618502a70321c1caf72401654e361aac6990a674239afa1f46698545614c93 +abac1e0f85d5c3ff6d54ed94930c81716d0ac92be49e3d393bed858833f4796c2b80bf7c943e7110de7b2d148463bfbf +b7eb416004febd574aef281745464f93ef835fd65b77d460b6ad5d5a85a24b536b4dec800cfe80ae98489e54447e8bb6 +b3fd8ed1c30e7c15b0bc0baf0d9d1ecad266bafb281cd4e37c55edc76c202fb1e4ea315a91a2848f40f481793ae35058 +86ef674ddf4b7d303c68bbfb53db00b925ccbf11d7d775ca09e458f4ecd868ca828103e8e7cd9d99672a193e81b83923 +95ef414e9f7e93f0aaaeb63cd84eb37fc059eb8b6eced2f01b24835b043b1afb3458069c45218da790c44de7246860c9 +93ec8f84c20b7752bfc84bb88c11d5f76456136377272b9ac95d46c34fce6dcfc54c0e4f45186dd8df6e2f924f7726ab +95df5f3f677c03a238a76582d7cb22ed998b9f89aecf701475467616335c18e435283764fb733fb7099810fec35932ae +8cda640695c6bc1497d19b9edc5ff4ea94c1c135d86f573d744358758f6066c1458901f9367190dcd24432ae41684cf0 +b19aedf5569435ff62019d71baa5e0a970c6d95fe4758081604f16b8e6120e6b557209cdea0ccd2efec6ff9e902d6ce6 +b3041f21f07d52e6bd723068df610aa894dfdde88094897593e50c5694c23025e412ef87a9d16cadd1adbb1c6e89ced4 +a7f8d6ab0a7beb4f8d1cfef6960ebdaa364239eca949b535607dee5caeff8e5dfc2a9cfb880cc4466780c696cff2c3a6 +99a565b4796e2b990bfcb234772d93c5ffdbe10453b5aa94662272009a606ba6ea30cc0c3c26aa22982c1e90738418a5 +90c54b55ff19157c1e679d8d4f7f0687a70a27d88f123179a973c62565adfcc9347cfe31f54539038cf2f34556c86870 +8612f34bcd018d742202d77d7ce26cf9bc4e0d78e50ddf75250b9944583b2c6648f992b635ea13fdaae119764e7c28d5 +a04fb38e5529bf9c76ec2b5e3a1ef3c6f9effb6246c7f67301cfed707356ba1bf774f2867c77a5805933f0c8ad0ec644 +b4800e7b503da0164885d253135c3b989690794d145182572181995e6fa1989f3d0324993e871bbd5f48fadd869d8a18 +9981cd4f28ae7b7dadf454fb3aec29746dc2e0ca3bd371b2a57cd2135a7d93559e02132528ccd2d305b639d7ac51613d +a3ceec012dd1fbad3ef9f9f1d6fe7618e13d4d59e3f50540d2a57010d651092979c75442ec8b38a1ab678505e30b710d +8b97b8654d067fb4319a6e4ee439fb8de0f22fd9db5569ba0935a02235cb4edd40a4740836c303ec2394c59a0b96308b +b3d1bf4410fec669a269622c3ce63282c9ac864620d7b46c9dfcec52d8e79b90c4c90a69c32763136a7f2d148493524e +93174eba1e03f879e44921084aa0ee3562e48c2be49085de96ed7621c768ff52324d14c8cc81f17d7ed50c38ffb2c964 +aa2194cd0fb7aec3dac9a1bd8ea08be785926ed6812538be6d3c54218ea4b563646af1f5c5f95cb914f37edfae55137d +93f2c0dd59364f6061d3da189e04d6c64389a3563b062e8f969a982cd68cc55b4f38b21546c8a67c8df466ff4f61f9c5 +aa7dd497cc949c10209c7010ba4ce8a1efd3cd806a849971e3e01716ea06a62e9d5e122ad1d2b8e5a535fae0a01a7761 +ad402424b2a32bca775a66aa087580d7a81f0867f293f1c35580b9e87ccc5a2bab00c29a50fd0d7bd711085ae2248965 +96237843d8e29ac77fc6ebf4acc12946ad11697de8e5f152fe5776f2475b790226a7d156ac48968dd68b89512dc55943 +a45c25cdbb9fc327cc49a1666988af9ab4c5f79cea751437d576793a01c3eeea4c962c05c0947852fe0e4c63e1c84771 +93dcf834a614a6f5484cc4ba059e733ab5dcc54253229df65ff5ad57b447353ebbc930736a4c96322e264e65736948dc +b9a94f82a82c0c5a26f2c1d5381afec3645e8ee04c947dc3b7ad59a73018db1e9965ab3642f2bbf60f32c430b074fb22 +94eab29b3524ccbe0c4b928e5fa5dd8f684074b332fcf301c634d11083653ffee4f7e92ddbcb87ed038024954ad1747b +b8dca5f679931d6abef0674bad0639aefad64c2b80572d646aaab17adf5ca1ab2ebeecd5a526cadc230bec92ed933fc2 +944d394958e539251b475c4304f103a09f62448b7d8a8eaef2f58e7de4f6e2e657d58d5b38e8513474115f323f6ec601 +8a5ae1f13d433962d05df79d049b28e63fe72688fc3e6660aa28e0876a860c3dbc5fc889d79f5c4dec4b3a34cdf89277 +afa5278724998eced338bb5932ecf1043d2be5dd93f4d231d05d2ea05b4455f2ffdc0eadcb335dcace96dd8b2b4926fb +b91153a2f4647ae82fc4ee7396d2ca23270ec7f8884ce9eead7e9376270678edd42dd3d4d6c003dfc2dde9fd88cc6e7c +adc932f1c679bf7889cb1ff4a2d2897d7973483fa283979a0ea3640c80ed106ea0934c1961dd42d74b22504be49851f2 +a82e90761fae684d1415cee0649bb031bcb325ae0b28f128ab8e3650bccedd302a70de1a341ca8decfdda76f3349cad0 +8ae353188b4b98835f4ef0333cccb9e29e1ac3ec11d554bc96f5880c101cb3c84b8eefe72f2287b0812735339fe66cfa +b8b41135bb1a1ffb64afbd83e2189e755f2c350e1273cf47c38ae9b8c4800d831436a69458b8ef9fa8b95a148d8ec9fd +96f75a04d8752fa93dc1eaf85ad333cff4eeec902a345576139e16de3a88eeb71b6726224349bb9844065cc454d959e9 +ab82b05e3923ad4c26f5727c60dc0d23063c03f5a4fd8077da66aa87042cad1bd99586d4ab35aa5e4ce6f4da6fecf3c1 +a50c83db91c26ef7bf1720d8815b41bd056b49fd99710943679a162ccf46097a7a24585750ece886e38eb4fdb866fa37 +a719f667914a84f62350dcc6f4f30b9ab428eac6837b70318c3ac491c1e69d48af5e1656c021818f377d911fe947c113 +a148807aafddfa0a5624c7cb9e42468219e4bdb9994ec36bc19b6e6d7c4a54d3a0763d13ca80624af48bbd96d73afca5 +aa012f205daf22a03e9fb13a63783dda7666f788a237232598d02a4d4becec7a699ab493f78d722ce68519262924c708 +97fc15fab5952c5a2d698fd6f7ad48aff1c8aa589f7d3b14285fea5e858c471cf72f09a892e814104fa2b27eb9771e73 +8da8840236812667c4c51c8fc8ab96d20dae8e2025290b9cde0147570a03384370b0fcbe20339c6aff09cca5d63e726f +b477d85359a8e423fed73409f61417a806cb89c9a401967622aba32bf85b569e82bca1b3394c79e180114a0d60b97316 +b3d6ee2ed1e4c5cf8ba2c3a4f329832e41c7fdcbcda8a3fcbe8f60967fdb1717665610b7c1ac65582534d269d762aa09 +a0b3b30b1b830b8331ee19f96b4a4321a6b93a3395b95d3a895682c65ec6ea64774b878b93514eaf353f2e4be28617b8 +a2b88e9617f4d30ef4e686d1932ad43cd555fadcb5102e51bea19e6fca649284ccf4debb37b5cb2090ef386fa5bf5327 +8a4446f7e8463ea977a68d6217a9046ad4356d6fc1c18d46c5d2ab681ea977b8faff136d65abea6bbf8936369cb33117 +91e7464bc56e03f436228104939ddd50caace5a38f68817bb2991e193b57adf6835152bbf3dbcdebf0382ac9823f60c9 +961a441e6cdf8106c4f45e5b47190d35644faec701c9cfc41ced40cfdd1fa83752fd56c1ac49131a47f1970a8f825904 +94b7b165cc71c2ae82976b8f03c035fb70e90028992b853aa902c0467b384c7bcf01d56166bec5def4453e4d0c907e52 +a5d32cffabbf547f900026b34ef46f08075b7a244565f615370d2f04edf50b094c95088a4a139ce07caf55bcd99afa07 +b4e06e73660745f75ab2f34d9f6d2675b58f80f911ab6dd4c5a6ce1095f9a2b50d86f6ff9a05394190bdf96af0827920 +ad3fd8f83c0103b29d41319209dffca201d2b98094362da08da3fd6ff0ba96796b49d6bed525c9adb96c2954858e7f48 +b0c27430695f0fd20ae31e1ec621da090094f2203e17411db9384695ffcf5c7c6badf461ba49ba70164aacebd6f278ee +b9bc6e972fc3b532fd2b1eeafc4bceb77604885f32132af6a9a842fa2440df452f49ec0cd9d86da1180e8deb0723b260 +9729e22d6104b0174c136a854920f542b384d375040adcebe36acc253bdb55845eb43e34dc5a7cc27d22c417973c24d0 +a8b420b36d48786c9231d454468a6e855dd7f71dcfd095efc9855ee70dbece0f06ad277f7829c5813fc30524c3e40308 +8757dff5499668c93fc5d9cea0a8db61817b8ed407200d623030b5849a913d12f8371b667cfde8d8082026eda7407e8c +b859ad747ca5af661fbd03a1a282df6e84c224ecea645bc2d4ba5e35fa06cbf047387319fca0cbc76b712398c0798968 +8e3173c27875f1460297af0fa736c945dc842ec3e476a973d3d5f790bf183ad3ffe96ac13868c5101d8e299890791864 +a9d725e2b92c878be42b5eecc2c3081c63c7231ccc7e2dee17ca6a4caaeae22788fab1f1465fcbd7fc236613fc2bae4c +86f6c4f04a354cb2470ef91914816fd740f8d5795ce7ff981f55a2634695fde5951bbae7a4bbc4c63747040f8644170a +851773cb26f320f0c3f252d95ea7e058ffcc795dd0dc35e459aa1b6b448238909230d809e82022e64b7fca5d40b8324c +8962641e0306220d9892fe2d452caa286301a3c465185757be7bce2d9b2c9beb3040280099606cc86773e43941fd3439 +8beb6e08c440b0de5fb85251d39d9e72db4e556a2dfe3dae59efd8b359d08492064cebd8d8993254b43bde8bd67d969a +a7e047894466ffe3dec4ab8d5462f2b1d8ac0df006b1d2dd26caf499ea857d93a811cf42233f9e948c9cb903beec004c +92eedd95557a91691a5e2835170390ce2401e223da43b78615a804c49566f9d31cbb7f10c8a8390c4bdcf691544fdba9 +a5e5b5d8fa65824e958bbae98d146b4b332f97ed50e0bc2c58851dc2c174ab71bcbb1ae015cd2955c26b368487dd862f +853a494eafb308175629d581ed04bed71bbc3af9ca4c0dc483d03d27c993a2bbd88cea47c2085a6928d166fe6938fb77 +83f06b88d29afbfbe8f61811690322ac4fdd6abb9a23612162e7a2dd6bcbb5f14cee298ebebc1a382484f7346dc51e60 +8c9cf05735ea5a0e563490bdc7ed29a4426643711c651e35c8551ca6f855c8458ae8f0933a022d0bb9a952edfed411f6 +b906b48d807748a26cc2a8848455a76ce502261afe31f61777b71917bdf7de2fece419db636439478c7582058f626c29 +97efe1fa7c9b25d8bea79d74b6cdcf88f63f1e865f54b58512a2e60428630b0b40b8b6af1b5f71df47520507548c3cad +8ef5ca6e753818906bb3fc71405928d8e4108854ef0ef01c1009071b353bc2852e771fcb619d5fea45590e8f61003d7f +8e4d901661e2913740d70ba4d0745df5e8c9c0a260149d9362beadc7e669630ba909ff0e8a6cc85c54d6b7435d0d351e +b7c6ba3bebbd9592967954e3a480ee8df1d9f5965f04e7d78a5415b645128deae7ddaf6ed507c8877bfca91ce078e529 +840bedb0ad4e25acf6cd25dee4f98fea495b2312dc5cb7a8388c5ab00b2acb9cd25da08e9fbead145a3107972b1ccd5d +a8d4578dbafdb27f3911af59962d89e75dea74db55346720357790da677312c203107d9c7911535aa563446fde7d4c47 +86d3b77f231bfa09251b7fd2ce09c27ac520ec35d783e912476f9a4863f83d269eb175790d6e735da9260293d707f8ee +b34909f1cc033232652da0c34051a769dc76adb1aee00674a59dc1b860f6e610974c3b4bb69a69ccc73e01f042431242 +90799854d0cf34e1d91ff8e101bc7c5007423d34d2f3bd9adea2ecac57e83f3a65a506bb93d4caea49b29f6d18149957 +8ef94cde29b037e19a1ce7bf4418ad3c95cd9457412796ea385750c19a6690f13a3bb5bb6a9ee81e7a40face1e0a8bca +97053d21ae8d75972fb37f6fe516c38c32ab162fb56b9f510f954858f4e3ef6ac8c3a9557ed3f41b7b6aef05fe97f931 +90a9f9f0f40991f3bddc58b92d40382147db22cce50d092d4a05aad251b46b94e71ec9f7107a180243288059fcc5ce29 +a14265b1344ac2921b0f890d13bcfc432e4f648ce403e261fce4d3bb32ffee9e2794c02830346054f998e82784c77040 +91928402ae121e56a3e64cd6f390127e6e92fbfb1967ec6efa4f52f3e8058f1f41a0f4fe96b5bcc11641c1139e790b2b +921c8c92b6d40da6c5a7b592acc74fc0f577d93767b9aa4a1cd302a72dbf503a1ea5b2c29fa0d0359bff3b8f252246d1 +93ae0ebe0e8e133fd80cf67a499047e30ec4c4660ccec9d49098717ef57721a030f423e00c5e74af4ff4acf014a10497 +82c865e21905aebfe0496af1c6ac7e342b5f446a9edb4f7da0f2fb0340abfd8e6fc545da874459d9aabe6bce0dd9bfcb +aee3961d8d2687c0f134b9c28b920bdc4021d925fbe14323c84224a9fe161248789249fb85436a5891d0bbff42c2a3e9 +91aee420b98b6949482b8ff4be996b97245b4e8f583a6e085226539074f42aa89818395efd1a6699735a569bfe19d623 +a48eec22c192e495b01722d0016a54acc45ff837e2a95c4294ce81d5a4e43e0053a6f0ead8a4fb3ddd35faf6607275b0 +a26e15937c11faa30ffa64817f035e294cab0e839f73d29de8a244ad039be4e221eb47ea08d9a4658b0152fc3caf6110 +b84450f948aa7c8682fccb9cae84d8e3558adf2d0ca5fb81eb200415291158720f8f3470542ab5b88c6873ad08e7fa9a +a8e8ec27d0608d020169a85d6ecdb40eb402f006a3b97afe32cc01987721b3a68a92ec693aeb4d357e189e05fadf699e +ac87cd535ef5699312cc26f86adb71baa0be42e858bd5a2d94ac05737dac63430691e29b9a30d2559ad581a172519b2c +a4481e67b524f8cddf2046625efd3d75efee6aab87ddd2c1b22835647e918157e5e924ac760db2195c86d326f3db1615 +891f29ded231486ee826840c8895cb325f7e84a5a6d2eac246cb3573612cde274720233b1978318a57ed337a046330a6 +906b6e750e6178289012769807d2598925d7e51c260c14497d8af978b1695990e3352e6e809a752f376597a68083870c +b7a056898ee1e46f7f29702fb39232f678ec173eccd170303b3b0a30c8d8cf1a5321384e3513e3b03bb742c238deaa54 +8f2f035fd96c3a336354c89ec9b8222803bf42e95fb2412c28d4e75eec99c1d4d402501ccae17357b757db8bdb0bfeab +81228625ffcedf977fba9cfa13f6edead3985e2651d5974789c394a69401cd7face9e20ae6694be4c0d4bab5e99c61a8 +885a83eae25e61439ad809567a2ab148583402e01cfdd77b0e37ab4038935425c64b4e0886949bf06438c35e80aa13f4 +8926387f48752f6933899c48e038cf14e7941ec6a58bcc0a436614b396296a17aa53e6873803dd3041dae470bd493fcb +95d0d3fa061f4d856eca78a569aa132db14cede7646f97e2aceb6da0c8ea53195d3b7a566fe5ec8c41b95ecdd89a1c6b +a3c817f4062ed6aa94064ea695d76c1825f3bf77b310fe1db28b8bedc9aaacbf1019dbd128adfd53042fb943d863a2b7 +af1208417aa584052da309169854149ede38a3ad63c76cad6e43afb6f1a7b854edf8310a0b00088c039259cedf0f859b +8b713fc3196bad35dbf364089049ada5477e540d78d76a5f0a9df98f7ba4a0e65dd0644509c149f9b07887298bf74b04 +89c09c43c5b733c4a417cd9ebc0795cc3348b72778d31828a9171427779a82ef023c1a4fcfcdc919ae25056f9c826fde +a0759c850ed320c8c874435e90ace6edfb8e7b3f2a09d942b8ad8339c508044ee2ee26c70f1b626ec49a77971433b6a8 +b85cbc58d4fd52286e714ac4eaaa0b2743a1de06fa03ddf8f6668ec6f1d204acccce93b10620272afb8c0b49bc4b0a43 +814e0a87384e159892a8d23036985fa3f489c53bce192e107bd2d64f57b1bf5ea0acc1ef46c7a42bbc5cd0924d92b4a0 +aa6821da96ad89d7881b878e141076522f104ea9a5bbdd1fce9f641898f7d6232c518a87a0f666871d7e3165c26081e4 +a9041d714bfc067b5427252186fa3557bad598fc0067dc8521aa9bc1ae298f6e96113db5ac9f6bade9a85d5a950c9755 +b8669340f3064692625e1bf682d34fbe69a61689e3aa6d6a3e822c781d406b0300dba9c3f7b8152a8c2513f1310d4291 +a78c53316ce768a1dc5968030bf4fc885f4029b1ddb6a5d84a61c85af686c73727f62823891edfcb6ccf4545de366cff +ad1d3aa29ea28292ddd438c865e2b5d93f32cdf009e6d5f5dc726de996583925727e6348bf1c28c22dec0bd86aaf867f +ae1447a2062e9e28af5f38aecc60fe150cd10c2edeaf2110034aa144f6235ed7fbce432a58805d4fe1f6b12652d6e1cd +a32146634332d3303934550705353c6d4fae5fa5985105bba35041e74cd71e2aad67b45da171221f6ed80f36bf6dffa3 +a232e8286184196ea77427b53d8b52c44d758ecc42d22556529db3136379b4989dec61cff610cc6cf6700a450a847a94 +8a72c7255125a736da52dff5f77e44c3de29f88fc05f5ff9227c69df296930caaa11446595e6bea3bd946baac5ef957c +9688a981a9457678067f629f8efa6b522e7318b529f88d37ef56c5bf8f1c34fb9bb3a918ab73caab82bf5abb0c03518b +88286f3eabd71115fc3b17a6bf6981340a81cf7e5f96b0a1a016d4ec8c18fb486d46c70919123d0c189a6f5d6ff29a1e +b535e701b40d793c02ac0d625ca91620d3f4a512aa9741f71389e58381008b2f93d597586d06213c4e103d67d0ddf6c5 +80d0c9dd941e8d8d3700cc51a434a5aaa3308cf8ebfd14128ccfd258f826b27cc3cf5c3ad7851340393abb1eeab3a157 +87049225fa2380d93f18d3d90cb0697a56b373b66d7f24ab209966aed8b55a2790194d5885399db29dd5b1f189eda64f +a52df158ce8670e0290551e8878d63dd33b4759d6f50e448e63fc7fe6ea99dddb6f180be5fc0fc3918ce54c05f80b356 +8b2a728b39c465fb0f60b0c486e5dc8d5845ccec03d3dd93b393cedeeb3fe1b44518359f1ed55fc770a8f74bfeb9923d +91fc05419dba718fa4a910dcf256ebea356bbea00522d8d5ec3e7ba4271a26035aac15e8d9f707969df1d655d92dac55 +97c8779ae80c24c1f82d5a714762d6ee81069224e39515e41d8a71c9310dc5d1c55cc92bc5c6a4bd391ae4c321d1d4d2 +b5e5aedba378c4484e3a7a4ed41b75b0844f674261c2501497de6f91f7274b5a4c1be0e055f2e0c0cab843d891169fbf +8a26212f27211b295beea500abc8e9d430a8500d3a350cc62f895d39e8b4668aa638c17633804ba353010000165637ae +864a95118e5d394e00e99efebd505df0125525c9ebe165764c453b80ad3edc730feebde3d93850745dfd88a27bb8f20b +a092e0b78290e826cc1ae56afffdd08f7c10954f549a3ea6666f3db1b6cdaeb7df53db28dd2a92446342930fe60a27ce +a1720224c0626a081b6c637b2a6d37da85d9a82241e5efef3bc15699b02a69f6304e43d8ff3144d60c16e00225d6b39e +a7b3d098cebea9cf32e19c5195608182b6afe9d4af6b9df532c047eb7a941a971279b2ae6a4b80f2f9d9313a6d788ce3 +a3d2451e6788944802c5077a778d7b7299dbb9d1612676bb6baae78f39976e0fd879493cc4a4d737b8174b472a456850 +930121b73da844571b1411d56760e80923a4ee09917b3e9cff4d3dcb0bc27026ff2c4e2c44e7aca7d3f8383f129c7f9b +b4b0119d163ee00a2b74bdf188a5cdcf054daaa48c483b94bbb4d09ff615afb4a91347db6363bc7535e2af9054ec2214 +a5846decee706780201095a8cdd48fbf3d3a2eac8d089a818e5e22c29457494bbfb4399323b067f3d2be2197c33dbd98 +96ba600df10ee7af5a9df29c0ca31dbed275d647faf9c66c7342de927ceb25b5bdd852dd7aae0228b27897f90fdd5d62 +b6ac51ddc98edd9fb9f54ef84bf372a041d58dfdf0dfdbdc4b08ddc1a7ba93ddbb1413dda3c1545a3fd7386c6b85975c +b35f3efd91a0723e0d486188ea9675a3462106470455118392d7610470b623caca2fa33829721c05fbeb0fabcf570bfc +87f49e85df5f8055714a8ce7adf37f6a278e64e76ed74c60abe3edfc3611ef5b0426d4c6da45e5f3b74d30be1dc6f539 +8ff8bb06902a71b1e9177a77367318b2e3e0a88f5d74d6907ca9943f4f9f1ceb5f297132c2a025259d17a67e880d1bad +85eb6de6c70fe5c53ab0ab27aa0fec439f136c979c557d317337cafa6e6c5cb3169679c9169567dec5f6c72b3c057d83 +ac18715ed1080771d760cb7066c6328faf65d9b30517903f8a5cad8d66d5c6381156b521107d7cd75ebb8c30e250706c +b95b9eae4703727e4ac9ddf2ae675906487bb78905a5f9cba74a4cbfd118d96b7afb6ef3ed5edf14fd963b830d71338c +a3b47b52fda16b62b11c8aa4daa56b0b669c4d5c56a3059b7d063284d8a91f6fff9ccccab23d6ceb9650483b2d353039 +96a95b3f327df94c85e92f2e406f1649ac621533c256b062738f3c3ee137059a735a3e6072247acf57b1b0d8c219bd7f +b19b33cc04570be94eae8e943d5bb17bb0c96e9de4ca84f9f41b37320a1a03d397d53747dc13275fef1b356de557214f +a1faa3dcb931dd91507f3f12a17c43f6627fa2bc5c71fbdd27548e091eaaaba262477949cd51290e81196bffb954a492 +b060a16079dca1d28a1fb33cbc26f368630ee042d980ce305230005d5b9ab533a7a695281ab76e9214458303932d8bbc +b303783196a858fe45d67e0520c30576da605fd69964449c20009fbd5099cf1de52a32d326d7c3b864de07440195ef40 +aa550a4c20d1003d137ffd8fbdc1196d09ad53cfa0e202302093a80fa3bbc4c9aff83f34f2151785cc1ce5f30255693b +a7f8585f45566a351058e10c6f1ff4a7ba24811f1482a47202f581525615ca770da93f2f58878788b45b92cb446ef4ec +8206f63a9a5b59bd68e64a843e68fcdf706f4c13bbfcdfa9928298e5b9251006ae0bbd80c715aa3c9957d2c0148b5059 +ac9490abe1241319658f1c2c645cfa01296f5d4106020c7894b7ba4a65cdd52f6c5401bd3b3cf1c9863e088cd8c9a16f +85dd6d9c80a1b58c24c4d2cb7590d33d2454f381f58e820979948e5831972360cde67bbd56e1860077ef5192fcacb904 +8b0285944c676fe2519cb68da0973275fa29c0718d838d363ce46651b068d29f867cf9fe579ff8da0bb8b37d202bb23c +95147275da658d43a758b203b9ca1f1c1478853e9bf77b5218593142e2bd9c0bf46d2206ab64cef99295de6e9a268edc +b8efa187fdd3e1f46c15cd596e9567690c10e253b5beaa5be8074b6ea4e6d3d06e0f2b05323453239e419ae1e7128521 +8340464f52c92e31806fd3e8e65f56e27194d1f6daa4a0f0b3831e8102aba16f88bb5a621633ddb7dd0342e1d2d12343 +8615d87dcab85a78dc052f05a01e751176b756b5dc9985014347454ce5752f459dd6464e1c5aff36cb6c51b783fa2692 +80c6e35c0d3defbe4d3968792724a23f0b8830dd2fac58663583a49339ea20f1812cc4140e3ee867c7e716177319bbbe +a7aa63dbfc201dde8f29bb6e23d7aa5020dd35bd18a0cc93c8a10c35d695913fe25b9e8cf9b5fd1899e9657b22bc8863 +97c2a4ba80c4caba2e729a603d2faa0120915e3fe64cbb065f7ff33de5f877f1ec9461cf455e88ec9e9ded9393939dba +a54bd1419f0e2d2d87757870f37c476c7e3a13502f1ada82fd7394fd29f8a00c4986473d753034d0954a2550badbac0b +8d3e2bf900d0d2b9b46e6e2f37620f0cc90526dbbcfaad4e4a37ed53f39fdd23bd3a6f21aa7e800eaec937d9710dd6e3 +a88d2b1c7802b2dc216c2b6532406c091bfb12f29121b9a82c1154470e250188413ddd3e79f7e009ea987a4c45b332e5 +8c552c2101dfdc3f99c2da436115452e4d364eefe029b12946f05673c5ce1cfb48d39a579625849236dc6c8e7277dd30 +8415c252d52a26a6400c3189c928a98559bf24162ecf3eef1d10e439269c31d854b0b4f6ec7a2430e3f11b5d77de78d6 +8b38905bad93a8d42339dbdb5e510003c51fcaf05e04f88fd7083753353bc1c4c00a5dd4a67431cd4456d0669c7040e2 +b1d0ed8862250d0f0d9ef9dcf0cd16d84313d1a795dc0c08e0b150dadf9ce73d32d735e04632b289cafa69a6ee75dc89 +9434e18a5fb631b10edb02057f2d1fe16000ee55ada3c26a079c9fc3943e29d6de99e52829fe7b333e962270c712e51e +b1b9f3914007e6fca8ad3e7e848a1108988cb2318da36df24767d804e95d1272943fda948451135cc1b5052a3953b081 +8c02947a76d7b6c0a700a83dfb971dc105bfe996e18c521445f036310914b349ab28e57571e36ae08d13a46fb01c2f43 +893472fbc225f973a0ac6a0a0130b9cfb7ab6869dff80df71a62b1f6beb4afd069bbf35b4f327165bc31dff39e4fcaa4 +a7c176c0903175f3540d62f9afee994d5d9bf37081e094644b22f017e94c515afefde7bb07f638342abef7de657f8848 +860186c2b1d3b1e657729bc804275fb5f5ee89eaa60848fcabd3871289665ea9f0efc8a95792d884972bcfa2de96223b +865b38aea6386d0ac8f501a7d934e23d01dc50105324e354d4c4fa3cb1d4c29c26f4566df7b1a728e10cfaa9d24552e6 +b4eea5548de6969dada658df604b5d9c49002e2258352838003e0fdf7b299d81fb025807a7f37cf5b547cebd7f2c1f93 +8982de11ba68d63a649a3b296d4d56c71e3c3eec016db250d733ab7c3b9a620c09c5a5d0b64fd30d3bc03037ca4b17c9 +84d8b8a10d67eda4716673167c360fc9b95717cf36ef1d5bc6f2ef5b9d2624f0e76c2a704d016adf03e775ea8e28d83a +834d03ebd51aff4d777714783e750b84c16cb6627f8311bd8ff17c3b97fc4a5bba57d6c8f6d74f195d3030bcb5f07612 +aaf49e0def0c4d5f2c1e9c17b51e931d2f754b19e80070954980b6c160178349f6d3c8d4808801d362e77f41a0008918 +8ef4115edec841854e89f2bbd11498dac7396bca35dda554290d3db1c459ffc17be671f4a46d29fa78cbd6064cc2da20 +9641dc8a64f4acd38e343a3062787c48c312f1382f7e310ccea3e95e066ab6dc980f6ed90a633236a435e68bf6b3c625 +8a84cfc2cbeb18a11dd6c2a0aebb3f6fd58a33bb4b26101e826add03748595022e816afac79a4e7c20b3805252839dca +9770782d729017659844421e1639ffcda66a2044df9e19769b90292df87dcb146b20c6b9141bb2302029d84a5310665d +98c7ec9696454868ac52799d1c098c15ec4e08b34884dda186ebfe87d32840b81fd3282295df141c91137faf4cc02da8 +a3f6eb921247617292162dfc8eec5b830ddc294a0fb92f5b4828a541091ffdaff34c392c1d7168259d6204405d90ec72 +b185f77a468f07a54222d968a95635234e74fc942485604909308a9028ed2753b15902b9134749f381f7cd6b89cc8c3d +867608a682d53bd691dbc92eeb460d1c300b362ca49c11a280f6768ccec217f1145f9d59fe50d994f715ce89d38a74e1 +afaad630ad8827cd71aade80edf3d7aeb65a344878db12fa848759e6233f6fceca563aa437e506ea9e0f1e47b126d45b +a12afbc84e3441594aecf85d089423dd3bb8bb33a1a384ddf7cc14caa72284caaa56aa179c15e3140fd56bb532491a67 +98757b0b5e5837ddc156a4a01ce78f33bb1fce51e0c1254ee9b6d3942268d0feb50b93edbf6aa88f9ea7b3c0309830d8 +89573f4a4ae752e9f964e42bec77d28a41840c28e4bcdf86a98a131d0b85367b885077823a6f916972de6ac110821bd2 +a17f2745052de5de9c059307308fc49f56cb5230e7a41cb7e14a61c9efa742ee14c41023ce90c7f2261adc71e31045f8 +914b07c53a41c0d480083f41a61c10429ea42dafea9a0db93862d2269ff69c41db8b110b4768687b88089b5e095523cf +b380cc3e0d26370976fe891d24ea4eeb1b6be8cfce01f47fd68838a27190e644fd57b049d3aa0a9589370de20e276944 +906385fdfad60feec79eb1c303e750c659ceb22d9c16a95faaae093daadd53e7aa039a45d57e20951d6e1ca0dc899ef2 +b5211ceee31b194dba60b616bfd91536e71b9213a3aaaf5aaf9b2f4cbdeb05191861d78b97eec58e3c81abe4f0488c04 +97878e9e38c2f69d697800e7a2f132fc4babaacf471c79c26a757f771606e55fe696ece68a3163a0ffeb2f72274cf214 +959431c1f54c46500c05aaa9a2bc4230531dad97ae768fa92bb85436c0ecc6374cf20fb0ef82d122db116820a943b401 +b69e5a1c6798f30d33e42cb8d124f025d2c77c993c4c7107a539aacddf44d8d4d2239e802ece32e60ee4dbfdce201bdb +a8b09e5e9f802ad273b2efa02bcbc3d4a65ac68510510b9400a08d75b47b31c6f61ffdb3704abf535a3d6d9362fc6244 +a41ace7f1efa930564544af9aa7d42a9f50f8ba834badcaf64b0801aaed0f1616b295284e74ca00c29a1e10c3de68996 +a8f2aa0bbbc19420a7c7cec3e8d4229129b4eb08fff814d959300cd7a017ddb6548c9a6efebad567d5a6fde679a6ac6a +9683da74490a2161252d671d0bc16eb07110f7af171a1080dc4d9e4684854336a44c022efe3074eb29958ae8a1a14ace +8ef44d78d10795050c161b36afa9ab2f2f004ccf50fdeef42fe9cdc72ebb15a09389ca72a00001cd6d9b1d7b3bb766c3 +adca54f3b14fb18298098970b0267301b7312afb75894deea1b2afa3e85b7a3b4efac9971ab54c5cbecba2da9f18507e +ac5d4528f06fdccfc1370d5c3d03ed982fed0861a93a3f6453aa64e99360b124926d1892faaf72d89459e663721dfa99 +98aa1c801bd615b8cba728fa993021e181e0ad717ba01c0290e7355694155407083eb53cb70819c4775da39d33224db7 +8b3aea4c7c2bfe1020de3261ec085d79c7bf8a7903b825d2c70ebbb84af197bcc54e3653c5373a2045c3021526b63b66 +a29f3de4cb3d99afff1daf7d431b38a33a9804fedc41626618928ed059df6f6fe9f298a046b594ffee951ed4d4e1400f +803fd346be540c5242667c18ee41b26bc812456ab13ff117196ed69b90ee608c8cb6554396b64066a546ec87a71ed6a9 +a9c18d81ffd029c0339c72c499bb51685392253b996b6eabd8b76f05c6191ed8444a1397d63b9923743661a319517f7e +a048d5c390d08f07161faac71c5994baf152c883b205f3bb10d3501709d6516ae54d491b486303a11b751857a31f0052 +9156fb4803e40e28d8d57d928481a8de4373687288da44fe88c5676a8ae013ed1fcc09d56a31140bf74e7f767253810e +98e289c725b18e0085afdfaf2acbc674dae7b0a2ecc2537a7d0b87e20eb785404ab05973a787f0495d2adb3e5565c09b +8a7237b249325bd67cdc1f9fb278710069033c304afbf270b7ea24dbc10c8eabe559a484d3edc733c77b4384932deb41 +9056f2e5b02e5c2e04a69fa1323bbf1859d143761268d18e74632e43800a2a9c76fd681e924a19bc141de0e128d3e462 +b9f2bf9e4e7263014296a82b9ecbb05d3f1efa4b2e675e3b38d3eace59da06a89c859256e1b77847886d6aa15f98f649 +83b22949cca19030289bbf7cd2a0d8b84e1d468e78bc85271a6753241b89122627632723bc293cf904a5eb2b5dc6c3ae +a919aaf35dd0116168d2ee845122026416bec9633df113fbd913d8db5996221e234f98470d029a8ff182825b59fda20a +91726901f49d32b41afa15219073842278f60dcee223640903d871e318a1c2b541136b7b38a7b2ab7d31e4242fc29674 +942b77666545bc9a858d36cfe857ab1a787c9528f4a0b87918a06bf510793264dcafd12ae6bd3ee300179dab7f40aed0 +80adc1f2f9c47a96d416e44fcba41628abc0fae1f88f6a26aea4648419ab726f7fcc2187c7d5145e3d8f5a75c03937f4 +8041e0f66ba9dcee01e336dd4d16ae5e4e1618512fc147cc8230003aa2940848162dc2187d4130bf550dc1f3559849d4 +999e8adc51bab54386af1c5e8822986ad1b7ecaf1f8a4c2baa5bb2fe9d10710e49545c5a8bd89ed0e61a3d73a908e5ef +89272ffd39b6e9f99fafdd58bd9dc00f66f26a1d36b38a1ac6215e3546d966739eecda7fc236335479207cef95cce484 +b8e0b7532af13f15dc04a0eb4ea8abd67e58f1b1c6ad2e70c0ffa04a5c18ec2018b5d7f4be2f9f86db5e0b3986f639d9 +b96bd11b0f6ead4abd5fe1e4c6e995da7583b901afd01cc05e87d04663fb997997d6d39dd9fb067c62cb1b1cbb67516f +94ab08914088b973e8dbd5685decb95f3bf9e7e4700d50a05dbf5aaac9aea4be2c10c83096c02252e9238ceea1351d05 +a188de419b062af21275d976494c131ba18d2b2ead8bdbfa38a777832448e64d4d9725c6a1d530ffb6513f18d5b68d9d +8f73c8c118fa25c76a4ec5611351953c491452743056a819c8c82ba4737a37d88da0b55f837e7239a5f46d2c05a1bbba +894a44769e0be1c26648b0d89c4c9f46dbdeb3a71b90c493093bee372bb9f2d3f319850fd886d51f4f58db0de5641742 +87d239923b0db024a8d9b0281111d47b0761d81c50652268b074efa3ea70d793e30f874a91ce33a4acecd0cf38c01951 +b1b48b75a97f9fc2dc9530dc69f6268829dd0ddd574516e7eb1b9f5c3a90058889a7bcf3d378738e6d4b02f5fbfa44db +83e3ee9526ffcb60c6e75b75550fc017912ec0daf96d0a0d5f58c1b229cce90c684ac7c3e17fb998def8e7e2e155d750 +b9b7bba579e474b0abdc7775ff5f84c9f117c6ca17788cf5a5f01b2c35a14aa39036031c8d799fec2cfb371d9f7471fd +90d7faf4891fbc368a32f575dfb69f13e37161ab4f63a7139be103285a49490c2851a907f8d36e09e7d1a190dddbc6cd +968c8b9affe18fc34a4e21f0d8c5518341c566099e6b45b8721c9912bab3693c9cc343406fe90279692a1eef2a3f7311 +8735baaf4704207550f77df73fb701d9a63329993a8cb355ccc0d80daf950145f37e9b4b22be2aba29898e974f9fd552 +90f52b2dccf525b9191d836b205ffe966d9a94f6c5800f8f51f51f6c822619e5abdf1257ee523597858032d2e21014ec +831209f8f5257bb3eb452d3ee643d5f063299f8e4bfea91b47fc27453ac49fd0ba3cf9d493c24f2ca10d3c06d7c51cd6 +a5a4db4571f69b0f60fb3e63af37c3c2f99b2add4fc0e5baf1a22de24f456e6146c8dc66a2ecaafeb71dce970083cd68 +b63da69108fad437e48bd5c4fc6f7a06c4274afc904b77e3993db4575d3275fce6cffa1246de1346c10a617074b57c07 +a449448d4156b6b701b1fa6e0fe334d7d5dd758432a0f91d785b4d45fb8a78e29d42631bc22aaa4ea26f8669e531fed7 +aabe43de1350b6831ef03b0eef52c49ffb0ccd6189cce6f87f97c57a510ac0440806700ce2902e2e0b7a57b851405845 +91015f144fe12d5d0b0808c61fa03efe0249058e1829bb18770242f5fb3811e4c8b57ff9cb43deccfc70552e4993892f +8e9c570811ce44133ce3e0a208053acb2493ef18aade57c319276ad532578a60d939ed0bde92f98b0e6a8d8aabd60111 +8b21839b5dc1c9a38515c1076b45cedec245d1c185c0faac1d3d317f71f1bfebba57c2559bcdb413d9d7f0a2b07f3563 +90413bbd162be1b711e9355d83769e6aac52fdfa74802d628ff009325aa174c68f5329ddd552ef93e8fdcb9b03b34af3 +8b6b02e3f9dd1031ebd3df9a30432a3c86e64306062ef00a6d1243620d0cb66dc76f8d0d412eceff877ff8768c2696ce +9894b41d9fc715f8f6addace65451f41dc5ce7b983dd8cb33757b4d7259bef12f144e0077d0b662aa847d5a45f33c563 +a353a9740f6188d73aa4175a6c5f97898a05ed7aae9d2a365f15b91dfa7c28b921fdef0a32d90b6fb82718b33d3ddb8d +984eab8faed87c403c9979f2d2340fb090cc26d00cb4092aeb187c3f4ee1df3f57cb8363f7764073188790b16dfc464b +a5c5ae0ba435fb7f3ddd5ad962358da326239ff236fc3b51bd22e88296236b109951cee1b98f444302badc58d1b5bfbe +880be1006b0156f2788813432f450f613d235f41aba52a6000d2ad310408ad73d86b79f6081aef1e8c51010d404ba670 +937da751aae68f865c7a33fa38d718f20e2a1c65cb18c8e08f8441f0cdc77662789d2793794dd0a427cad30cd0b33f42 +9496fde66c834ff86f205897db12bbf9a9bb78d9ba8b5fb539cd0a2c927cc6b4120c017b0a652750b45edbe5f650e5dd +97a6f409ffeb593e149307a14bc47befb632412d70565c5f13d6b7d032acd2e3ed0f7b6af701b387f11d69ee4a8094d7 +97ed94934263dc0260f4f7513745ed3483cdddb9adb85dc33193c3a8b4d52affaf1ded23b59c34651afbffe80d40dc36 +b2b26378d44f916bcf999db218b9892e06de8075f205c7dafd6d37a252185c2d1b58e2e809c717963d25627e31f068e4 +b8f9fa1fb45fb19a45223f7be06c37d3a3501dd227c3e15999d1c34b605f888123026590697d0ae24d6c421df8112520 +997aa71e3b2e8c780f6855e94453c682bee1356b5ce804619ef14834475511105b1e4d01470fe4e2215dc72182d9909c +ac2cb2a7cf55aaf990cfada0218453853047e813d3f51f5a623d09f4714da79de6592671358a5edf938a67f905b6cb5b +8d8340d0c3081cd30d34f3ff6191e1ff6ad7994b4ebac19e5936f1157ca84e1813228b7605ee226366d6bab1e2bf62a2 +9693b17669086003cb46c75fed26ea83914a54901a145e18c799a777db1df9c9ca6b2ea3ee91e7b0ab848dc89cf77f19 +a6b6b2a6cd8c4922d78c8ba379373b375d66ac6ea04b830a23d5a496cf714a9439d81c865da92d52600aa4e2e43afcf1 +89cb665020abc3f5e11a03c7ba5ec9d890fa9ed2630f1443a8e45a28c32786ed980b5343ffffaea60eeff5b313bc0d66 +b37b989106594221bc6cf33a1a83c3e65ecdef279e90333a9e105b8139dc28384bb2277edd4b77c9e59d15e6afe074c5 +98ce5aee5918d18b2326b30c1ba41669cce20bc7a1d1b585363305fbdea66055164a7ac398ca0f0e670291a3061022eb +b57f472d5f34beb4cf430d7c0f8ac5bd1c0621a284633ed36e6f7804bc2b7847f54b469c7ea163a436510d9e3b32f97e +ae673a6579dbf0504c8fd0c8fc0252d2f7ae8da615a06f4d215c2f8a8f516201f24e5cc42967630c252905e5dbbd6377 +97c1501835a31091a5a83f0546e01c85ee847a0ca52fb3cc0653f6a826e13d25ddc623a5dea139108f7270a1fd7043ea +9376ee667f3834f6c0da4324fdcca5c04712e0649877ee19da79a2d23be24640c38758fce562470ce2134ca34148ffe3 +818af89c40379a10074cfaba6d5968ecf667f1a68a7edaa18e8977ccb34e0829f237c5634fbd079e7f22928b277f1096 +b8e0af0be0a252b28df25d4a509f31878bcddf702af0e5553393c3dfd4a1f1247ad8dc2668bc8dedc9b41f6ad8e71b15 +811667ffb60bc4316e44bd04573503f5b4dc44d1ec824393a699c950e5fa085b146537ddd6a08a3fede7700396a0df7d +ad834cbf850b2f61ce799c4a0f8ab0c57039d4e1113933c50b0c00175171aadee84894d1376cf325bfd434c3deb44315 +a8b7dfcdb40373ba4d55e751ccfb9070554434df9e359fc165284ee3dc35db6fb6055657ecf5a9e9b7b8e2e1abea4375 +b56a5b9fd41c9d3f65532aa58bf71a38fcf07782e1ae0084dc537862fa02e6d66658b19d6f71c39cd5dbfac418da1837 +a935af5ed224b9533b41a7e79f872f6851591da9e9d906050ccd1b2c772a1d6d010c5fc7160c4f8cd7d3aa14c3bcdc26 +a81e580fc98692567b28323fc746f70c3139d989fb6aabf3529504d42d0620f05327e3385c2bd5faea010d60dd5c8bdf +a8b352054cdcde8ddb24989329a249b71498a5593a13edad1e913c795dcad3d24789abca9c7ed1d57efcc9e3156da479 +b0de8a2bd7f93284b2bc700e442f52ada16a22ad8d86329591547411c23fff0333b2ab0c9edf82bf7903ebf69916eed1 +843e9781b653d1a427f3534b2e86add49d308ca247546f9fcf565f9e08df921e4d969e1b8ed83f3f849e98c0f63e39be +84a4098c5dca9f73e827d44025473096101affd7193c40a0307e3215e850e753e9a08e6e74a442d57626ff26df77faac +b463eaaa2f3315b511c22a97fad353014d840a6a95fe0d457d0677e63e571407d7f5268f8775381a5e7adc3b4163eb88 +ad0417edaa16cfddc288eef4173aa7057ca4f81e815541ac588ef5f24b98d56fed6845deb6ae1a9740a28bb1cd8780a7 +9271963b8fb2288a96e07eac13c0543ec41abdc6d978bd7c44ae08251ea49994412b542c77c8208cd71fd8e7852d4a70 +8b68b6db9044d8bafc155d69e0daba95cd59d6afebb085791e999afed4f33a2479c633d31d534ff767b8cd433d591a23 +a6a06a0e433e385437d9996ce823abda9848754aa9cdd25ec8701af35c9ec15df999825669bbc2e17cedb597a96e8eeb +94d414bff8b6b8597634b77a77d1060db8e1af0d0ddfb737a9bf1c66c8430e93a425510af2464bce4a7b29bc66cf325b +b6514049562af1c6fb7d0e8df6987b020f0b7a6e721f4862e36b1ba0e19af19414ede04b346be22d348b50875803d1bf +a42c7fb34f2fbee8aaccd1d86672d0acdf4e6bb083ff0456512d7e1e43be041cc0924322fcd986e6e1bce5d5ecce6f92 +867cbdd169a52440ae0a75d33a28c7d00aa92b4b65aaac5e62aa53a8fc367c08ab8828cc8fa18b6e7d1f908d158e3382 +a6fe0b768fff3e4a6153e59a7b7508eb2ee8165eaf5274d41ac2812bd4563c4ca2b132f0e27ea2f1c98759cc3589b61c +b3eb1dba43d10b9e17ffec8def053fc96f9883bacb49330a089a0ca5b9ab0182e8b5111ad4aa55c1ce1b6f4afa5c70a3 +a1531351098bdfcda566ff4d811301c0305626c77f954a38420c490e7c684f517eb1a4e4bd2c3904a10bac889cba314a +92278d106ad2f27eacdb86bdb1faa0a07a93765bb79dcff191873c52253af83480114b2299ffe5324f9c31d0abbdbbd1 +8900ba95a90c447fb6fa1f528af3d7a378aec25feb0620516b6b97e54b328fc31af42e46a8ad5e6e3029d83a6f2bbe5f +86053d481179c1ac910d5e7b9a5de82794b442f20e854583512ce1f9c3f09e71d1bf97d6700fe776debfe1527ab97a82 +a32a60de492fc4340336416bccbd2591b5e414fca0aead82281212e24490acc01747537b3da783684e27aeb987245cc8 +9820fe8e0338f21797143f368177e3669a1f3894b40ae9fa3b353125f7c8e85cc424dcf89878f2c7667f65db3b1e4165 +934d64711b4348ac5e1395cc6a3215e5643b540f591380d254165486b0ec2a1d0d21c7d2c6310f9e0eed3d08ecf4b57c +b9fd32d589432eddcb66dc30ad78981360915854cc44b2afeb826b5d48a08e377dc91be66f5bf1e783d1a8bb320f7ccb +98c972cf01efff4fc2e485b47572e2d8dde22461d127ef401b71a111b0603203971e3cde40912643affd7341cd27e57a +8db6c1620760063edabd376f4399b6e1355462e04f5c81cdcb3989fdc00f9a466bc85ed899e886c89c149adad69edbad +ad7b7fda0aa6e2aa66a27235ac5cc680aa04b85dce329fc4be84f75c9c961120a3d9e446aa44539aaac8ea203eecb4eb +8ccb01eaf41d816ce69ebd57754859e263530915e775c4e7d9dac37b2457a9099b9ae9b4c6cb09eb5ff246e3c9320c59 +b895b83b5f7ca46e02697dbaa6157df6c7571864c83e504a8c77d965bc2ba97bf9353a71c56a020df64498bd40e30b21 +8018c07a81c522fbc25f2cb14f2321c61b98bd8962ed8eb7d5823dbe5d1958a5ec2fb5622fd0868e991bcb6cae016ea1 +95b16364e94d01b3664812264d7185032722a4afc23bdd33bc16ae87ee61816c741657c37138d9312cebfb5fcfbb3b2d +94a709209990a8b09bfb4b9581ab471aae3a29526eae861108b28edb84aab6d28f1d7a25dddd8150b70af34bee4ca2e4 +ae06c80839c5a13269b984ff4d8a5938c6f4d8d647b1b1daa8cf7f6145340b76a286cd615ec251a65501e6290162da50 +875cbd0694eeb90d3567da9dc7f570d97b02bd9cf17bfa011efdd48f1d580608a3213bff4006603b8b4079fa66bded10 +b27f88c455f025e1cd902097d6a224d76bdf9c9195adee30bef4a0b0411fff980787285896e1943a62271d0aca531446 +8024880cde783cdb2b863e3dd856be92bacc5b2a1347e96e039fe34279ce528560d2df7d4d1624a4595dbafb40529697 +8883d02c2a5c0e026d941c785128d4ac6f7a9de625ea735b7d6ff27a5ba10fa4d6370d450d99a855d919f40d64f86afc +a1beb985c45fdc30ac536f1c385b40b6113ef6fabc2f76d255490fe529468847a776efa674ba8fed72180f07d3f701f1 +ab83bd9b007561695210e3276fde72e507456ba277ad4c348a2aec7a6e9ebdc2277cb4bd0bca73bd79bd2240a1fc4456 +8db27f516153812149854fd6bb1250e843a3ae1c9637df818b08bd016a769d0497ab6087fe3b2fd4080882713607bf46 +b3891dde4e00d60386aeff161b4a0fbc30bb31ee7918ce5fc0b49aac3238a000ced192c9c4c08d90de3a0ba973d7cfd6 +90a2049a15c02e59024a7a1cb0adea97501c60b1c7442fbbe560054c3d69264e69627ac57b7d9be01bef498bb2a60198 +87df67a4bd72444b5faa4f3b067204c4927c869dd3b29ad192d859589a9b2c1d6d35ed68310081e140add254a9463092 +8f80986a8dc8a0d6408ebbcb4f234e76413c11cb0d66067f9436bb232373100f20a4fded60f08dec3525315abfaa8523 +b061e10beb12ba3683688a4ae3a91600d14878ef78a308d01b93e4918efc666450e3f7b0e56283468e218934231df98c +86b9e55f3783d62e381659d3e06699d788b88aab1ff99848db328a83c97d223f602201bf2127c5ecf419752fed0a224d +858d878e29925c87243e010020007f96fa33264e89c8693af12857b362aee3fac2244057e159651c476ebe1dfbd67bcb +8fd47cdef87d7a569ffce806d2c2dad100692d6c53e5f5dfc6e274f897dccadcee30fc6c6e61373961bbc1f3ecbfa698 +892f2822daf3df3a759bef03168c1cb07408df62e024747a788e94d2da325f880bb9c6e136c7f6643f45b021c6ccb654 +8714e37ac24f5a198f219e7c88a92172fc3db129e044e914663ac708d8101851e7c53fce79d32d0e6da74f2ccd1d30ff +ae95e1dbba8b9e2c8dfbe1c202e9ccfd04fa396470035a699b902fbd86d5e6a31732a7c8cae00b9a4f6e51c8d560c7c3 +b0cd058e77498e860fa20c5f8d9bd09bb249add1badf84ba8d1bd49e704b9b4bcd67a5c3d211840a2c8fefab3fea639b +b78e468d3a7da0dd481f333ae56534e2ef97587be2e259a458e25aa37952aed1cc5f835640f812d8052f5bada8f57b12 +835de7965c6b26e7ad1b92eb6f0261d1f376fa12d61eb618d9b342b597c9c117a5a8f6a36269aeea88072b4641e6b5bf +b4d0eb99136b3643468c9c48a20fad62785a60fbdd3c054efac4bd1fa7979b4c9ca6c2c0b18069c0912bea2f19832790 +a00c47315dc0700a850966836a95f3cebfde04dd094bde0742dee77b89a05b5ad655921f86fafd1e902938ff34d4c58d +ab13fa0afaa92229a71ee91efae6d1b15f14b6eacefffb7401d41d0d6db24e24a8dbe8ee19b4680ecb69d2a0cb4e84e7 +aa56c0fb18401210062dbc653df8e3732aa8921a1280e9737e99b26a0100a13a9cba8ad0317a69bba16193362ee0f030 +8b410324a6406b345df0fa25f541ac20b7313fa55832752f70cf4c79f43b0bd3d5b4cdc447e6ba7bca08d0edffa8e29c +893362241ae412d9e5df46506407595c58ffbd7fb1fdaf0694c3432470599291238997abe118bf7737e56a4f5c9dc292 +921618194a756be81cb49d6357cb392b32cc62d96c8ffb7e16d9659a0f226a0436bd378da7b835054dbe0de2c6372ef2 +94a2904f10994928ff5367b777e1430047736fbece33442cf452018bfdeae62e84cd75cf80f8468285e347d504c94111 +b4b81545b767f380bfe10e0fea9c3cc62ca8db40b43c83ffb245259378731298e3eb6c3bdc3a16932f88f5d8a86edc4d +936203c2453ff01c6fc635e4d54320d69e60047d805daae3b75633c2259108497b778f011e5a057249f11b2b888ea76c +b90bf6378d29339443c3f2008b1e2b5f0345f86e393027f14a295e583bf6e6c2b10f54b6dcc42079ff0d356c405b03bb +916913f550d327de2d8d6c7723dcef2e3869efaf95fd963d95c8980b97748c61ad8e2e629cead8577266d93fe39203bd +a033c6f3d5ecbabeb83eb363e54e5faa7ed2d7f4fb771b161762c4f003eac4e1afb236806b784baf2222cad54e2d3cd9 +ab289d4a5771147e6c29ff9ac2bf65d70081ea6c6af2d9b728c3c144574a31b5fd8632af57c18c389aa2cd994938bb0b +9488da2019ff13e290eeac132b491df58b5b7b23c2898ff1a67bffd7e9c9464c39bc8177a57950fd28589e3d9ff9c6c4 +a5abe42b2e0891851440fb2aa6c1d8a86b571bce8b80c8e9e2692e5cb6d45a1b2f055c9fc4c74a7cd292871604129ea9 +90bfef698e83c2ba4dc9304aa01edd274169a978b7154bca518daef394f55857d0d1922ebef3d91fc5ecb3b895d9e0ec +92328f1372b6406ec80786041b6d57018b8507e3881a08727aadfecfdfcfb0824394cbb1150117ac5da5d71b89e895ae +9719751c5f7a65ae2bed8aff7b4b8c34539ff011b259b7ff54f63f9d987b3fbdce5c99534ed561aadaf07bb6e939e208 +a151816774aa9379fccec21cf212429a1c68cf91b055cbb9d931f461a8d5616c693331a11ac5c6fcfbd17d84ee0b44e4 +a72977b1285618a45943ad00f33f37102e2885eccd2f76785254eeca495068fb1d8d49865343e9e8313c6c2c3b2024da +a6f5ad2e023a1585d90625c9f7094f0e8851c79f0eede8ec582ee8e063407cc5b8298e5fdc4c786e4fbbcecaf33e787e +82901e008febcea0c0a14ae21d985a397630e18ee6e346f4a449f23be228e8f338df567d30211a11180b94fbc5204bec +b9b57fdb8d14d1be87a25f89553b3966eb7869e0519ffdf4cc4d51f4cec90d68f7b81cdc0450e04207276e9c63ace721 +a06eabcf43585a001448f3dc30411f3d5b74fd0a695c81eda9981842ba2bb0081d3f5a8360aa18b6d43ef13ea78b293d +926fe48a7e8f07559b7237beff9504476dd97b5b4d67acd01a3633358a6ba4c7abed5c87683a11209aa2ee759888e00e +a716cd3a84a963e2a5a46145b6ef4ebce705de52bf2945c374152a1e41c228a9c4eae0b6d1e222c1eea8b9c13c002177 +8a9b5985df6fb32cdb06ba1591a977545444478f2fe985ed1b10de61c630f0a4693c2185d63f0dc0256b208072c43b17 +a8eab26ae0ebcdf96a59fad1dc2d5e83b94abb2ea1774b607023f9d9e0fe065853b1e2242e794f989a80a47f550c0bd9 +84adbf38164cd04f3d770a7f4b8eae7a5d25b4a803fb63c02b95b71b33e454319c44e07a760d22bf5f58e7e372d09a16 +90f443a3ba1b9129a0bee400b5b29d42e50bb2aa56b0022bbfc3c6f8d69db40299871ec7c1b68421cc89e1af6b13a39a +81c5a94b379eb98c494a8d0067c748ba47e87a2ada0105202ed7651eb4e5111a0cd8569b06ae68d392c4fd74a37833d2 +8f92324b14a1549ee0b186073a26691088e41556d33b54258fc6e0b000e9624156db4e97861a0ec22960e6c47ca8a1dd +8b021cd0fffe055068cc460aec3cc455952e2ac32be5fa060e0d1b6cf30ed15381618f801249e893b1b9f10dd82077b0 +b3e9f0dcb3d6f0b138f589fa54dfb01f849890ab97016372d004aac55103f363a64bc0e606ddf75430f1534a30fc522d +8fdfe64af891db89b25daa859864d479cb7599486bd6f36e593f8f2f839f942261ffc3eed5001a93fde44cbcdc24c583 +a9e4554373c5073e135874e2bacbee69c65308eb0785532fec6a37834e8d0b437b77a2f11cc63c87d7183b82cd9b6bc9 +b4c47daca723ad7193ac5098cad4dcab654186ec5ea5c0fd014a3ac39726be954565a901694ba211820c011fa1c59e18 +8835427e86cdceb4c11cbea331ed724e4e78af15e3bab5be54f6b926bf66b5d99bcc40dbc456d86342c9fa83a033c2d5 +8ea84590a400cedba047c2661378921a42f5ca0421da58c1bcb37bc686a2aed98afab3fa5e6ba3a51029390ef3cdf4d4 +b48551170fc479d69fffb00fae4fba301e92e37cae08f596db6f6489c3b7020edc074f9e8d7465b84e9dcef1b6b3aecc +a6f318b1eaab00836a330710e88bfe400395b3081485f6a212e3cba9463f6fe7864ba4f71e57a411ecdf2bcb4d189f96 +848d5137a39999141a79f4bdf91150796ba36352d8525821bf3bd6e070b352792d79147341b8254dd60fa8c36e9e2618 +a8526f8904b1eac4ae2a25534aa91e8031e9aac7b8f58d8f49897e920c36c0232f4a30aa6eed305deb0f7793c115b267 +b8b6a727c44c37a8388383e959d195d1d0e51a657d4ba360633d219d43c5df645383e2406c25f1d418e72b862c3a6e9b +92e64adf65b42c978f36dd03ab22ba983bfbb61944efccdb45b337ceb486beda99818bf20d32a545503c4572bb0a4983 +9653bb83df66260a0bd059cd4244ef7c661b089e403d26ba777d2090783ff31f963f5d3a9c125b1ad1a1d19134f3fc8d +a74e72355e71ae5eb36dc75191643500ca3e67f18833ee981010e7e7e60a68e1b01b05901eff05014b9ef29aa4829f45 +8b2139a5da14524cf6acc593144db23db424b95b8c7041d8f6c7a14a6725dda1cd09c42bb3ae26a5a3650affaa742800 +a60ddff4300ca44a7c7a00a1f98441ad1438e07c30275bc46551cee1b681926d2c825cc8f90399ee5f36bb9fbd07d3dd +a04e5e9958867a5acc15fdea0d88951cfebd37c657102f6ba1dcdaa5e46cf1c823ad0d98718e88e436f260b770599102 +95e977abeb70d46fe8d7584204770f14c856a77680607304ce58077550152733758e7a8b98b11b378540542b1175fecd +8c9ec93ed35a25ce00d61609e92d567459a45e39922ccd1c64ab512e292787125bd4164c00af4cf89fd3cf9deddcd8bb +819819ad0338250d9c89aceda9e217df12ac54e940c77fb8420575caa3fa78930689d0377ba88f16d38179a807135dc6 +8baafb379d4150ac382b14a64788d819146480d7a1dccd3deef6889686ded375900f5df069843ef14d754ad3d7540401 +ab827236996bb79b447714c6993af941c5ae66248df4d9a6f3650d44b853badb5c0cb67804210e07a7b9d66ca43092f6 +927656c3eac8d2eb575e3daeb77f9605771170c325bee6aeade10c083d42bd8dcbf3bcc3d929ea437001c7cf9a95e2da +af22b212d5ee44fd4197966b9690487c38a119cd6536cfb8c181f38a94610dd9e057f95774047a446504dd96dd11e326 +a44bd94b9e01e3ba36340f2ac2201ecb477495d4f1fb6726a6b439302deabb5a35d237c6a6aeb7e3b0a65649f8656716 +af367aeeae3bba14fbdb05bcc1a521000dd9d37f5c34ae56fb306d3dfda201d0329a8b6e89d98e15825cb3c6bfdb1194 +abcc4fbdea43e50ded9e2fb01464f4e87fb136e960141e8d39214f92794cfab5634f22cd40b18d8c0e501f2307aad23e +920786cbd674348b9853689915dfcab02cce2a4596d117962bce36aadddf4bdd143891e22f2c8015517039a64e8aede3 +8cde63b9bd57cb3ef743f1f3e8250669eed739e5fbd68c500a3cc0c12f93862a69aebcdbc69dd8f476c2eb307f572a53 +b967e65a5f1cd8d5d570f5e87e7e186fba51b9504f8e466392a76d8a971fb91fd9b7565bcc1647f50d7d15e48b93bc95 +8d5a87b25fedf5edd57d870304bfd9081dc78c3e3e3b38b997260a92edac7feccdaf24feb51822d2edc223b70bb4ed5f +b6cd5d340a57f8ec73723c4f3ecd6601620dc8137a3e75a5d3c578bc79a9cae86b379950c644dee2ff99dad780d025c1 +b6f0a8e754b7f52a85a2a2e6512cfd017f7fb0418d19bb318308951c4e242d3c65bbcb9748da9cbc91a738f9ca577332 +a89dcf7d410bccec385400dd96b1cc6af89026a431d0f531aa992cbd7bc8bfd7c5f360bcb665bda1d72efa17bb982551 +97788e7522427a46c4b6258d15623ef7a565712812fa80d001e1de8dc1791392702f3fa3cce5a8cd1c5755625a0ad10a +b5338fb5e137ff625b27c5148298f27ce8f493e2527c5d0facaa49f29cae34580d0d6c3c1074a2e46cd8db3f56004ea9 +8962f006d7b1095dd0dd132ffe7e87e328510c95ad893cf3b2ab21c177c5cf2c27f47d8856f87e9762c547be009d25c0 +87fee9ce9c26aa476e67e0791a809e0a06a8a98facf3faea730d438d3e516cdf75d645fa75c906e4e44ab9237a22c016 +b75ab972e1a1214bab0b38cc3e973d44bb233acda5b4291f5e110b6fb78fdcab93dc63f01168debd898e165f615be1f7 +b5a0fb52bca279d3853761a94b206acaf313df33ae6303d9b71edae90b66fc507adbc60fb11e758888736c81d5d80c0a +849b8f0005010e684701cd3a4e59e8c89e5fec59af6d2de5b6332cde03b865ea84f07f0b80ec3404380b0e148fbd2c24 +96e2b0b6fe78408f9208f809f5c40398100b2dac202c8c5c33c2189560dea868270a598c419871a5a2b67783354f6014 +b234b81f996142d0df2c719760bf996544820a03195a6dc0ff6a72543692f5a369bf63d1f0b477ef2fe7b3234e41f685 +b85e39bcf40da1a12a535740176f4de749a93824079deb5fdaa004f3282fdefaf5275e3418c88c419bd42a3dd2ed2b3b +a27279304b89a18a4e2b443246f2368fb8b15f46a34533179b6bd2ef683f6e98e222b7a32880b39b8fac1afa90133803 +8923c22cf15c9c1964213d725b337ece9ea854775a06f75f232c4859c7142a3942f418354e33066298aedfba3cb27e62 +b109f714311fb9bc431ef57911e2cad6a3949455b9f23255cd7edea35be629e07f845fe53e2b12a32305ee2f4f264f27 +b51e82ae5c7d48050e405897d0053e9ea4b2714d002e88f78c9a307cd50b9c6b3ee7cb86f86527be9d964b01895fab20 +90db256931c7f98bcf3bffff4d496739185e7a20f329ee7bffd4e0850a37739948ec745285703967f4ca50ec370cf68b +a0485ac0445d88dafac56bfba2563b020cfc370f54c1606c89d12cfd8a4d1336d2ba50306e476155a6f5b0e0a1f2d092 +a00754c3462e74bda928da855bbf90f9077db395e32f03cce9b2955546d900b72330d247b7d607b65e130f5b0d883de0 +8547d56727c3ad8b5c8ce622ed9ad86fe8cd78e6e4848c9845914b5063b17330bd10b46d8d3f18f83ca09ecb28d1afb2 +95b937b2a979bce0e159ac75c7d5d659be8599c92305e73e942aab414793364a3ec28c7c1c8491a5750ba84a29828d8d +b011e150f0294e45a0f4c69409999d0c2e602449dbd67ab95e8258466687cd733a0329083a31b03722f4e2580ddc95e9 +924651a733ad5e5d9adadad3ea6a6babb8e455c8d5f2cb5bdc83fa422e7752592190ccedaa827b866861e73506a6968e +a4d5180122f8e31503ae027e54da50f72f5cfb910a6f7309bd882b5cd666f454672591f1f20e461e182a47d03b47052a +ab19ae659c4f73ea3d21895269dbec583c7029955a36469124ebe295027010faab56c4a475973497f28e9a77c03b8fd0 +ae7ea1a803d0f439e91494f8f35fc1167dae23834c0c699ffe65d3da8b09f8df5a53195a99ca7b8558242279e69578fa +b9d63cf0e30f9800101b43b980bcd2f229758e74b21ad5354866b4e684791c08a184330dc316228a0d67fe0210f2bc4d +8c41629744391ddb96dcbbf9cd99b13d36e57d65962e0aeb92ebccf1c4cc769626feb3ec0363def08eceb102b3dd4ad6 +b2848ff24faf9e667a8c19d050a93896e9e75b86595f7b762c7c74ccdfb9db126ae094961fee7f5d1192776c1ac1a524 +af013bc29206743ce934d5887b8d0fb3667c89bda465d2321835a3618513fba6a459dd7566268220ffce7e0c97e22b2c +8bb799e36db1132da8e8b028ea8487dd3266b4628c56dfae4ea275f3c47c78e3d7445ab8d0aaee4cbf42148b3a148175 +ae2b81fd47c038b5195a52ab8431f0d3cab4cf24c4237252d955aad2156adc16dda9d3270157e0bfe5a44022e5c051ef +8e0129213b1698d2ec6df132356805a8633ba79e672e586dfef664ffccca71834253ba14f296da962651fcba2c002622 +a1ae30b500ae77cd9bbb803d737b4a5991cc780618ac22b5cc179efd8fe10afb8c135457f2e7b86ded485ea12eae70e5 +8a39723077b7c0df6e3bf6548afa3910c214ee275951fbe5155a39473be98099626ea14d844630a6fa90292b9594665d +a628386c79b61aa7314b01d9814aeec20c2a66e3deda322a39957e7135c2e52b1da486d1b9cd61c87afb22c1d10f6462 +97867f469b01249820aadd9a54e12d4fdadd4555f2d530450e1f8f6d2dae57360578e2c2c8ba41e3b5950df596537a98 +97f192d0457c217affa5a24267dd16cb4c01de8fefde9df4884e1906d2f22e73382dcee6c7d910bf6430bb03f4a4f1e1 +86d5b5739de8442dc74d0d8dc78e49210fe11bf8c6ff0f0faecbc47b64812d6b28c8afddf6d9c0212f1988451d6ccb1c +8ff3312ce9693cd4a9f4b8e75bd805f65b0790ee43fd9e075fe4cebc87185bdf161335049819f22530f54fed2779a5b9 +8dc41d85548bee5d51941d55752a500bde3c5a8f3b362da4eec307a963968e26605048a111c9166d448b8dddf6f53892 +996bdfd004b534151e309ac925fa5ee7801c9da4f6b4c43e156d1158b134535a2a3956e1255e0dd72ac2af6bddaebcaf +aead652704b788bf4983c8f725c644c327a6e9f6683215f5c826c09f82fd2e40631791f51d14e6aded91fdc018d45501 +991ffab58a82b98ed8fc7b00c3faca153589fe09cebf6a137ad506387a1ca4dba475b0e4a1b9bdad829f1422facaec39 +9652e6c4ae084221d6bad855ec0bc11b5f855c6efba67f644e0902ab790a98861cecc6ce047c68273c3aa7eeb2f4c7d9 +b88b816507aaeea6dc92b861eabdc96988b74d7883f20a4b30ba249158acaff3c50d261742fc9ad2e9eba888a8d59065 +acd028a51e16c07a10d2073b9d03070457ac5f1246365295a1359d015c460b92b4861125fabe6f114de8197045df408d +806d3cd9d02d41c49179fe7dac5b05dcfc9a205a283135d4f008d0771c58e6f963d7ad0f6798606edda718eb5c7ff3ed +b9b71f1657a6b206fc40159a941e127f252a7b324dea864ecd804f48c0ed86da9778a925fb65491204a92bc2a26fef32 +80ed67bd0e74350c875abedc0e07fd42ce7cb926f0f3fb1949c6ac73f2300b5a14a5c6f6ff8aed99d5ea5029bb8e7ae6 +9875f67a7a473714e4dd75ee0c763ddf88101532d9680724b3848fef69e218b04a96b90f88e0f4409aa40b9a21507ecc +b4a2bb1b421e5243e5e7576a0672dc19f9f70315a03f6411c19f76616ffbb70fc5dc0e57fd4ab85e24ea2261b7ce38ab +879723002ce43e6c75ba2246f51436efe3376242beff987d025c3c4476495af32d52a54fad5d9ec329a442b93bcff1ce +a4121efbefd9c3eb143619afa52a916f199c75024908047763b29466cdfc837c2fcc894aca63044c33c41c777e529b5b +895f637b497a9766714a3d9e3c275a1f0c9ddab105bf4c8b7e663f36cd79492022415bb4938c1a4849bda73106ace77c +b119acb8b161ce4384a924645a248a656a831af526cd337d97e08405415b9dd22060849c76b88a4785eb5e7214961759 +802e712f4c0a17009c4be6c1e5ba2ca3b82adcb68793ec81f4489b7985babd8a3873d544de63d5e5de0cb4dc5048c030 +ab111051e4651b910c68ecfdc33f2d99e7bf4182df68cedbdbbcac219a543e04d93ecb2763fe32b40c095c7ca193c331 +855c73ef6afc6bcaab4c1e6388519fd5cbb682f91995bebd558167715db454f38012291beccea8186a3fb7045c685b67 +a29d02ec6d9baf84c19dfd0eb378307703bfafc0744b73335550f3cd1b647275e70215f02d1f4ab82a5df4d4e12dd938 +91510a45b8a50cac982d2db8faf8318352418c3f1c59bc6bc95eab0089d5d3a3a215533c415380e50b7928b9d388ff89 +8286e7a2751ca4e23ea7a15851ad96d2cadf5b47f39f43165dde40d38ddb33f63a07bc00600c22e41d68a66fd8a0fa51 +a413d4e619b63799dd0f42ac57e99628d338b676d52aec2bb0d1bb39155ad9344b50cdfe1fe643ff041f1bc9e2cec833 +85524e5bb43ae58784d7e0966a664717289e541c8fcaff651541718d79a718f040a70aa8daf735f6635dabfc85c00663 +97f0d48a4028ff4266faf1c6997b6ad27404daa50ca4420c00b90f0b3e2d82ef8134d0a04108a74955e61e8dfeac082c +8df6145c6cc39034c2f7331d488b8a411931c8faa25d99c5432831292637fd983d4f6b1a6f55522b4a42a462d63c6845 +98c2060f67a916991b391e67fcf23e5f305112807fe95bdddb8ce6c4084126557e4c5f003afb32e30bc6808b30d4b526 +8964246b3c2b8f7312f0a99647c38ef41daf70d2b99b112412356e680185da6810ab8ee0855ad7409d334173bcc4438f +b56c2c416a7069c14bdb3f2e208c5a6ad5aac1cbe5b1faf99dc89c7141d0259d1c6250be9d9195500c4a41182ad2ec3d +b7864583a4cae3b1083dcdcff7f123d24a69920a57d6594d0b7219e31bf0e236682442b6499a1f6795cfeb4f5f236695 +a064f94139bf1b70d476bde97099631b1284aa6b4d87f16bfc65c075e58b2f1b3c2d057605259f806e545674a1169881 +80d1bc4acf14c0f487cd57c5d6157b7f38917e93cb660f1c25e474fcdcac3c3dfda50f6bcccfd6676bae25c4b6b5014e +8ad9a4976c4e3e282843518149fcf5d454240740f4b91466f6310b7216d23d70b9b47c42870293252f29f092f330967a +914197593d2d99d784c704cad7ecd3f0b9f55dce03fc928d13e1a1034566c4de754f1c2a5ade047b0956415fe40399ec +8d77f5e29c572ec3c0ca39cbae2072ba4102403265b3d8c347a00386da9c0b8688d6e3280c96037c300d57b3545f3773 +abfdf79d935fd4f06a04938d6580a8cbf9735f0d498f49677f26e73d3b34b7075d525afcb4f14ef1632cb375bef7dd55 +a97a8c446e3edc86efac7bda5e2e5d0158c909552a3bf86151df20ece63b8d18b608f477286fb1c7f05605ab7e6a7c2c +8618d946c7fd62486551c35486fa466bdfcdc63c941e4cff5a01fbbe566b7ea9dc763cbe73e2acae063060b619a212a9 +8d03ee468070936004b06acf64b868963f721f37faa09887f8a82c155ad5c5732572a6855b531db58af03b1afe034a18 +8d3247f75966ea63935ef6049f7c889c1651374adb446f49499fc9191dbcde7ea33cbc1f1e2d3d1756b6e69870404643 +afc853c3a3facb4ba0267512b8242327cd88007cef3bf549184ee891b5ddc8c27267bae7700758ad5bc32753ebf55dae +80df863eaea289de5a2101f2288046fdbfaa64f2cf1d6419a0e0eb8c93e3880d3a3fdf4940f7524ea1514eef77fb514e +8434b5888c2b51d12d57da6fb7392fff29393c2e3bfee8e3f9d395e23ddc016f10ebe3e3182d9584fddbd93a6effcefc +b78cbb4c9e80e3808c8f006dc3148a59a9cace55bcbb20dd27597557f931e5df7eb3efd18d880fe63466636701a8925e +acb140e44098414ae513b6ef38480e4f6180c6d5f9d1ca40ae7fbadb8b046829f79c97fe2cc663cbccd5ccf3994180c6 +936cb8dc959e1fc574f6bb31f28b756499532ebb79b2c97ff58b720d1cd50dc24b1c17d3beb853ba76cb8334106ce807 +adda2116d9fab2c214ec10c0b75f7f1d75e0dd01e9c3e295a0a126af0ea2c66373d977f0aefdda2e569c0a25f4921d0e +89a5cefb80c92dcad7653b1545f11701d6312aef392986835d048f39d5bc062cabc8a9501c5439c2b922efc5f04954d0 +b9acb52747ce7f759b9cdc781f54938968c7eeacb27c1a080474e59394a55ae1d5734caf22d80289d3392aab76441e89 +8564f72ce60f15a4225f1a223d757ebd19300e341fd9c1fe5a8ece8776c69c601938fa2d5c21b0935bd2bb593293272b +a5567d7b277c4ebf80e09c7e200c20d6cb27acbaa118c66ef71cbccb33ee3ddce0e0f57b77277ae1db9c66ed6e2d8f30 +b82e9c2d8df1cdd3b2417bf316d53e9f3cb58473c4cb5383f521ef53e0af961ef916e4f6557a6d8b4655ec01415231cd +aa816dfd2814c8a25bd2cbaf66303ee49784df471bac4b3188074ea30816f00f425234454d40d8ad8035aa925d74da36 +9919f384df20faaa2d226b521cab207dd2b62420d25ebbda28c9b2ca76a2a52203b2ad7844c1a25f5c75f005c5a83149 +b24a6aa35c2d0f87e36598b36224c64427cd69642b6f9c1bd478a62c70f8ee69f85028648f6603b4f04fb21355f2afb1 +892e044bdb1276b455eac2204be105e1821f987c2570494b1f32aa09506caba7ed343cd09b1bc126fed5e0fda3d0eaad +af0e01a3ad954dc048de18bc46bb1c4971db2467e839698e4dd05cd1adcb9261013fe9fd0cafb946c0b586f6aad86d4e +ac152f0a9ace425378daf02510eb7923ff1ed2c0f8d1deb918e4efb63655de1ba58c96438e9aa23abdf2431dc771370d +ad8c7419c097709347e2394195924e09617b47ac5c7a84aeb9deab8975f22155de0f70cf20d8a976551b14e3a2683a2b +808f14f67ae801536fb70a5898ab86e50ad35340cffd0648daed2f2c4564c9ad538034b2a179a6a8bfa27e9d93b4cbe0 +80a74ab7ce4769db93cfa695a166db95f0a9c47885ff826ad5d93310f36d6b18b5351c67c858b9837b925e85a1995b63 +95b88c3cdd64401c345828f4e4754b1a88b4875a14c08a668b90acd499b3b858842669ecd73a46c5d9f1de32ec1a0120 +8ddbd770b7b18a5917eb43926fa05004e819f1d1ead05b915269e4a86b53e0633a90559007e59f6705a3769e2126ac56 +ab6db5fc220754f19948bef98844e6e38dd623565d1695e1198040c228ac4fd863c1f168cac1d036bbfb718d9d8dd036 +97bef628e977c069e60c395a17740e0e1bc1828f5607ae7f30ce5a0c95f02b53af2ad062700a75212e462aa22c3c5465 +b68d465e04fd17ca98501e61eccb0ce30401855e98046e0c1debba71c2153d6a7a704aa36a6f12454696e78e87181cdc +a79cfdd048f4181e005bd0fbac0a8424495474956b58ce858d2b700fb0f931c406282bd33bfa25c8991bc528d12a69c1 +843f55fa0a6a0969daf2b48080738f30b269b2e7ec123a799e5b203c0b3b4b956dc95d095bc6550b0013918cdff8a225 +b683cdf2823036827e5b454bfe04af9bec1850d25a7a7a44aee7696b6ff0468b7ed6885a41dde2b8f3ecc4aec880c3d2 +8b500796e82acdc89778e0c0f230f744fb05f762000fee877bcf57e8fb703d212dbc2374887bdc2e7b7a273d83a85798 +ac35a8ee87bafecb1a87f15abc7ccf4109aab4ac91d357821e417f9b1474d196c38cc41cd13667f68d1ffab5e79a6e92 +b6e517739390cfed5b395d33b14bce7cd7aaece57fe79a7eb3cbf150dc10765c3ea9fef7976a21a2243687e6eea38ef6 +b53901eeee26692273365b789f2a60afc9b5f0df229c6d21b07016cf4c0e7985beec748aeca52262f68084393ab038e1 +ac4804f33d8ba2b4854ca3537bd8bf2dda72d4e94ff7ecaaf9bd3b7f098343d74d765471ef80072ae34f860b052cbfb1 +8c6a30a93f1dde18039bbdd1ef294552bf79856e20bce863e4b8dd72d906be3ff22468ff3610e06b5a7d1745dde7ead9 +88f0607fa3b7cefe20a02115572b16fc3222be86bb19e592c86c48afbe7e0dd523492b0c29a3bceb9a20f5538bc3134c +a660b801bbddad725975ddf9a8f606f76ecef831f954be224d6178c368e1c72d346f00c4a4c95c289b62d36f2af323cf +a75b9a6aea9542b698938dcd6cc2f6fe0c43e29f64b2f54aeb05d35fac73d41aa7fd750af4fa9333644aab8db90775b9 +83e1b7129d963d1cd076c3baa5fe422148e939273db173e4d59d1858a7d841eacac7fe817d15ab8f8a493bf46c2045e6 +9060a2e9c24de11f9c70e039b5ffe9e6d32f1ae39f3dda263610df2265d917679e689898e4a8bd84ad34613dca5e3761 +b42fc8b863a2af15e04d1fe6693c09b46007c0b8298973fb4762b45b4590ad7fe0aa758918b2fe5ed1ed0359754fd955 +83e6de7860fb256ecf7b47506a5e557d0fb0aefe57fb513c7dee2bd9604712d08ca26adca7ba9a54b712372a7c585a26 +90586e9cbbf71475ecd3e7b5753b286804dcce61e165502a82b960099e79272de8b7494b8877b54ae838eb5d0f71af2f +b2e4b0d21208f73b7b75e08df80cde20c4578e117d37092a490af82354e2afd3a7dbab46fa2d12fcb731cdaece69c2ba +a010961239bb8809fc7fb4aa08fa30d33a130f9f417ee9ea60f587dcc5ef4e1b7abcdcbf8e848ecdcb7972ef6af46e78 +8f511fd58d1e3403a5eefdc0a4ba6b8af848c7efddbf9575ee84449facde05ae9a24aa41a5725416467f6fbd11369c52 +b24ebbd2d4482eb618cea1ac4fbfd9ed8c46c0988a27259300a7ce5ce1bb256aeca0357828cbbc4cf0dfafbf586040e1 +b3ea29e9cca55250e9b7b9bd854edae40f0f0cc65fe478cd468795d1288cc20d7b34ced33bd1356f1f54a4291faa877d +8a8b20f222d9e65bbde33638033972e7d44c6a310b92a9d9c5273b324c4ad1a94f2a10cbce8300c34dbd9beb618c877d +b2436a9a647dc3f12c550e4ddc5b010e6f9cb3f3504742d377384b625fc38f5b71710a49fb73ffaf95b9856047c98201 +a13f8b77c70621e421be94c7412454adc1937b9e09845c2853ef72cdbe500e5c1bf08e3c8b8d6b8eff4bce5b8dec9213 +b25de8780c80d779e6c2e3c4e839a5a107d55b9cccc3ad7c575f9fe37ef44b35db4c1b58f6114a5f2f9ca11e1eb9c5fa +96ba6ad4358c7a645e5edb07d23836cbd35c47d9a66937d09486570e68da3c8f72a578bd2e14188d3acc17e563a652d7 +a7f55989814051fda73f83b5f1a3d5385cd31dc34baf94b37c208b3eaca008ff696fd7f41e2ecffc2dd586de905bf613 +882d0c7c81e58eb9560349f35c35e4498dcde7af7be8d7974b79d262304c26ab67ffa5ed287bb193d5f0ab46b4096015 +a607158f0c1fd0377a8ee5e9715ac230abf97406c19b233d22f5911ebe716967cc10425546dc44e40c38bd6c2b4bca2e +87e8cde50e5d852d3f073a43d652f7186bac7354612517cfaecd4a1b942f06fef6f14546279c0dc0262e2997b835b2a4 +a1c93acc6db9d5ee426fb4a0b846bb7a7b8d5915bec777a9fe6907246b0beafb8938941c8c79ed6082155f75dbc1e332 +b1e4f61457b86f76cd93eafd7536f72baf239ce5a62bd5a8085a34e90576b1e118e25002d2de49b01d6e9a245ee7d3a2 +a0435fe9a4bd1031ec5973a103ec9396b2ce9fd982f6d9ed780fa80ac06a6e47a0a6eb2daf52df1dc9292db622ee9fa3 +b66d8e8a1717e4bfa42083b6ef4490e090a73168b2912f2111743e089027be0a4945a229ecf5d0b5eec11b23f0e11303 +8eb764f26904eea4f4169be6e75beaa6a39e4eb524625a15a78befe3d8e3cc82692d9b135590c20ed460d6e4ba630ef7 +b7e4aea6bb09829e53fe83e53f49a7a331a6d7bf76e0073d758577e6d6fbe63dab642b23657355cad48896ad8715119c +8f94207982373a99ffa282673f192aa98d0c4461fb77c31dc4549628bd9687a249f1b3c66b1840929341e42516c5c64a +a9c673cb247b13e17fa5e616f0399b7f5c7ad043e143e44ae68855a840870ab3d2aad737ebcf74c2cc9688d17ef3a794 +b02635104dd28c02068985256975c0af783899eb996e37d021d9a35238deeea9e836760db21869be7b6c82aa687ded29 +b33bc0966389710812b5f6698afa3e9c84839a1b85492ba11e6ded26695260abf66be6fb355d12d3a8524966f0f89e0f +a79c0dd09506951c33da3cbc23843fd02d641fc24c640a205e6e8150240372847312b9381fb03c5d301fe4dbee8d0da2 +b74de6f3a2c502b5b658ebe8a9b7edd78afd036f5a2736aa06502863b6865d131b9e3542e72a86fa2e1d2db4927661ed +99e365def1452ff9fb4b9eccd36ff4154d128469ba5bd73e83ae457ab53977cf6fc04a5d05bdcde357ab539e34bd9fe0 +b4f2bfb95abb47c67870aa6ca38ac8f3ae1b1a2bed064b1be7ff90865ea12e4930fcf66429c7ecd1183fae4a01539386 +ae4bde87f36b912e92398bf72e11d5389e93b2de1b277d7ed4b6fb5a9ab9f71a959ec3bcb734c11079440fe42b86fafd +b826459e568efdeeb66688482b67ef5020787275123fd3192f979b6175e3b0ed59e17cb734a0a052bf13f0afc7bd237c +a99dd735f4a7c85cb23dcc7f4835f9ab32026886909aaa95876b98029c37dc4d621726c872d3a9e50403443c958f4029 +99083545034768010988bf8a9f34486c2cd9da27a1d10db3ab86eb69a1dd9c8ee723e7da4ef2aced63c1dbd53ccc52cb +8ac3209349f0142546c714ef7e9d1b094aab5469b8f080c0a37cb0362da5349e108760f272fbba770aa468e48d9a34c4 +af5f48ed74b21e3f2c1430192adb4b804dc873cd7e8f07130c556c30e7b78df0ef5a14b205368848fa9185e5a68dee0d +b8b741b65d68df89443523ba74203226f1e0d13bab073d183662d124e83e76cd318b2bfff09879c04d81b577ac895638 +914abe4282d11176d4f2f08c6f15e6c2d0cde1ab4de00bbe888015c205f51929d97296a0a8d3ca5641f085a29ea89505 +83ec306b2a9a6780efafe799df90b1aebdbff7d47921a136ea8a5648b9708a97231245a1082fea38e47ecafbbe000528 +95d6b58d70b388dfcee4eda0c9805362ccfb60a87603add565b175b2c14ed92999dfdb0d3724ee3e5d30535f282641e9 +97eeb4de607c8306e1d4e494f0d5db126d53fd04983ab5674ec5996b971899e734fa4011f2c889da21154ea1e76dbd2f +84ff21977fbd873ea06bec444d4ec9ff0e3902edc29dfa25f3bed269b3709e3116e99dc06cc3e77f53c53b736bf8fc29 +8ecf483874a040a4a1c293af145094fedf203a5eb37c3e165857e108cce3e1210e0bfc0f26f4ae5e2194024929ba034d +97d9b92b2ef34609d69402167f81bce225ed3a95718a3b403f702b93e96a121a8f7f072d0ff47e8b25164e204d1576bf +ab87c39cca1803b4e84b32e40ff30289e3cbbcfbe16a70f9e025643824752359be1f10c3e5398df402b6fec64d5a3537 +af84ca57e6944332884b5c84750afe0d5950015e127acec161853d55d48fd864c7da8d59cc5aba4ceceac650b813fcc0 +b1d23d98edbe7089ce0a8432e0eb3b427c350fb4bb39eb2aca3c2bef68c432078cb9b4b2c4966255e00e734fa616638b +8e2b5252e0ea96d40835ebfb5693af49946509975682d68651396d6bb1463f09e75fd0afa04ccea49893b5b9c3e77e40 +8db25e762f1d4a89a9a1cbc61c01698e775906bc88a921b2905735457a35df9ab84bae12e1b1b8dafadd50212f1acda1 +b5f7cd163a801770a4034e2b837e00191b0ac63a2b91032ae9a99ec182d748798df48a14644935fabdbac9a43a26749a +998e7232e5906843d6272d4e04f3f00ca41a57e6dcc393c68b5b5899e6d3f23001913a24383ed00955d5ec823dbd3844 +ab2110a5174ae55ebb0a788f753597bd060ee8d6beafc5f7ce25046ea036dba939d67104bba91103d7838b50e36703d1 +a211972a4f6a0303bec6c86f5c23c0d25ab4df0ba25876cbaad66ae010b5a00aa0c5daded85e4326261a17a563508a25 +a49f53496a4041a01e07f2c2cf1e84e2ee726917bb103fd267451b9b7bb1331c0afde85a79a55409bfde27328b2a4745 +934e915c67c7fc47adeabdde49f63f04644fe234672003be2aa0a2454dc8d9288f94293478936a450f2e3f249d395b5b +b6e69e9d6808ff7f60a01b7aea6781495d7a20f5b547852d3f0af727a7434209d3015a9dd04cbe3e272918e32e345508 +b348d3462092b5c6fead7e515e09611438db8d69650876dd3b56226e303252bbeb9e9f3b888fb911445b0c87132a1d0e +8d6510334a905efe5a32001e167f1ba06f9bc4af7ffbf11b7f7bf3c0076b5cca373d8c47e98c1ba8755bb22632bfe0e7 +a2d5200f20985dcd473d119ee97e1c0fafafa0f191185bfed9cac429cef8198d17665dac4f70342eea66e6e4a7370d58 +8dd7eb6b1841b3f33425a158d33a172b79b2dc8a01378e4174e67a1a4c8f4b887f02c7c3a8f354ed9eac718155bcdf37 +b16ca19388642f71afcd9f7007b490d82f83210ac1a989da9d4bf4c419de07af8c048cd301ec7e01b9d06abda7c169d5 +93cb2d847d1a88de8c1c9d5b3c83efd0b7afb3682942bd2c8ab5ef35b33dc31a097a3e181daab8630d4e840b677216dc +a8b648c769e77a7b41c0c689fe2fba9bc585067e004bcb1732cb7b1618e97b317781c36c23a00680fc780b58c301a789 +918c321100d57712866bdae84edf7e42df30a32853af257e0cb4da028842a43b49e775f3cecb85cd817269c728de7319 +a7b0f6ce42e00c519e69b2c78fd9b75a2e7103e5892d3c1afd70c9b5b9e706180a4bf73dbb2d3eed52bfd521103ec5b3 +90041994af3322b010891356afd8115340bd7fd7ba328716fbc4fe458236c8cad8c7564ae473d6091ec3a54bdab524c0 +acb1ac83809573846231f9be2dc5f3e986cc36dd9574a620b1cced45bad0b11ea957ce8c6cbf964a0af916781c574f05 +ac54677dc002698fc4d454c7beb862ad085d0514f92576f3485a44c0cb47afb9db2c085058918a3508f9b3de0137d97c +8dea56e1bfa150e442f8484b2952b116781d08cfa3072d08657cc09b0217276efc4ab6f5fd726bfd826f6976ced8da29 +a2b09e25baf01d4364b5205fa0c4dea84ef8fe03709113b034f88a0f0a502a81bf92c1d4641e2ac9f3a6f4203d3645ee +b95fe37aa351b4292691a9c2e547224c37ec2751a31ecce59810cb2ae0993da6fbe5efe0ab82f164462fa3764b6eb20f +a3498947e91a3a540e86940be664fc82f1e83ff41a0d95eb84b925e820602a41b7393c8b458bd4ebbe574a754586787a +aa2516d3620c832e5728fefdb1af0be30c871cbad4b166a7a4565af676e73bddc2f2f51acc603b3a022056daad2b330e +a9251b56467fb55f64c70729e2ec77a59d7eac79cc0b4b25ee405ac02aea46bf1cbc858bc773934a6d9bea57cb528185 +ae8c0a4ca7ba6bdca8764bac98df0581f00358db904e57867e6ffdf15542e55f7bad2dedac152ef88038b466ed901934 +b0881e27e52cc6a57c4f3f278dffc7f63a9174b68bc867c16d8a151d9cc4d0aeb703d1074d1927faa9ffb43e10912c9a +b67138465d6654ded486d18e682f11a238d6a65d90f23d6b13eb6a1b7471efbac9ada6345dfb13e5432196d2a256829a +944c69a6f1126edd38f6eef60b8a5bd17147ab511e44e8e0a442e87244d8f35236ee0b8d3dac0631f8598f16486a5f74 +995679dbe03dec775da26708cb9200dabcad983825f1ba601eb9395f9da350ca71e8af61dbff4c668fd0eebac7e4e356 +89de362f02dc14de6995d43cdea3c854a0986c605ba5eb5dacf24e3a85983229bc99a2fcf50aba3df59f0fb20daffe29 +84607f0e2d078df22d0866285614f5d78cf7697c94a7d1b5e02b770101ceecbfd53806b377b124a7320d9fed65000b97 +93e3faab60050dac76ab44a29bcd521813e76ec8e4ae22712d77bb489bb49f98f9087acfd6a77016a09a42ddedab2d73 +b7d64a7a35f21747b8e6a874be31ba770c0d13cbd41448411994e8cebb59591295a26bacbf74ee91e248a5b111aacca0 +8dcad429a2b0d66b9eb8c1c3924d7a72979727db6a535526a3518bed2a9532d12aad1c5a778824ca4cb98e3e513f85f8 +980882895faa347bd2fd1dda7b8ee7ed49e69843afe646f677b371eecc7a10e0f4e40bb55f28995a40080df471876816 +89e8e7fb51df79971e2f7bf65783614abbb0d7f3f1b4a15d3f0d160deafa7ed1c446d9a5ae1a77160d4dd94ceed8af13 +93fda8d350392e9c4d4ffe6534f7e7be53f32483d9319093e8436fbb8166a3c01085dc858373e65c7f4d014e0dc2bab7 +897521a87b7ebf7152de5260c0875e3c7df1c53e734c672569219ee6f9bd196c5ecef159b6a1d3b7cd95e91b9b8803ff +b59affa408a0f7bd7930fa3b88750fd043ce672c10a3adeba95a12f23f0dda1793f761a86f7409ce1e6fd3b3b7195381 +b4422ccc12f4fe99c530cda610053af9ffe635b633d52492fd81271d1f6f91b87171d572d5bd0e46ff63e221fb2fc4a5 +a4542cdf3346ee0867c08d630c2aefc57442f1c05c0eba52d223bfdca5e9d0bb80775cff6ce2e28aa2730231fd7b1bb1 +a7d297bb09118b914d286e5d1e87bdf13f7d174b988e38fb5427902e8e8c674072f36b19055a1070abcf357f8668f35b +9213b0ae24b7cb43ae95e25c09fead8bdbac55141694137d67eb5eab5e90a348a13d4d4d2cbc6436fc4f4f9f7334ced2 +8aed71a0d116d832a372b42a0bb92a1980f3edf8189bdbaed7cde89fc0418b3ab21a04f5c6e1d3b8edf73f1f62bd6b15 +a6c47d77d714c285c84c6b9458cbec5e3b191c0502dffd10ce049cf1ea27ddf868ef0cff13a2377289fa6c932b8e4f28 +92f45622ec02483f2c1e07075a6695416d3768c8984856f284f40734346d56cb5b3322f20c2c9f0ef8e58ddc294a309a +af6450d02b79ac9fc79f35655b58fd3619cd5d38c5317564b453f5f2d79d7a030bf767e399fe01b658a72fbd2cac2356 +a3c01fed5240eb8a61ffa8ff4a120dbcebb53b8e19845949c77fb4f9b2c3dd52c7001df6219ad2f76c785a4ee0f64a2a +af3136bfe8f774187bdf87555a1ac505322a956229a285d28bab1c88d4f4d12245af8dff35914a62e90e49f3dce6acb0 +b20e21d28444fc96737958cd951858fda324b924b4d3d08932540fd4b87150f053db6985b96903906ce83dde0578cbb2 +b7978101071268d1f485134b4dfd1e35f89b82c7d99ae91f58b6745f5e0273b7e06f3b23009033ecc3e41b2e9e85219b +9104b7d75245b784187175912cc0ad869e12f1983b98e052710fb33663224362bffd69ceed43e7d4ad7f998c0a699eb7 +a7624cd71b92699ce3fde0e747976ee04ee820032ac45dd27d769edf3b3379a4b8db358e50c9d057c63b5a9b13d76bcd +9354a76f294005de8c59db10e638ae6e8c6d6b86a699d8da93143da8478d36116211c788d8285d8e01ea6647dfcaa1aa +b85935c04cae14af9848db5339ab6420122c041075ec1549314e3c9c5a610d9b794ea3617c50ca7af6b4aec8b06bc7dd +ad6835a62311c84b30ce90e86c91c0f31c4a44bf0a1db65bf331b7cf530cca0488efaac009ab9ed14c1d487da9e88feb +80339f0245cc37a42bd14cd58d2a8d50c554364d3a8485d0520ea6d2c83db3597bf51a858b10c838bfc8b6bc35619638 +b370420ac1a011f6d8f930511b788708ccf2fe23ca7b775b65faa5f5a15c112a4667ed6496ae452baf2204e9ce0dbf09 +8ceab3dadca807a1c8de58ac5788313419c37bc89603692c7a4d96e2311b7fe9e813cc691a7e25a242828cdf98f8bbcd +ac1526ebc6bd4ac92ee1b239f915e494d0279fbd065e4cab1f1b8a1663f67daa89560f6c99bbc3e63fa845520316d2e6 +8240ab0bc36a29d43ec3059c7e6355ff39567e135f93b243145d3ada97fd1c970743819e0d58bd5171967daec144e7a1 +a99743192a6f1967511b2d3038cc73edacb7e85f84b2926d8880d932d2fa12f5215592311a7548494b68a87ec70c93eb +8ffffc31c235997e59ab33c2f79f468399eb52b776fd7968f37a73e41949111957434f2c0a27645ab34c741eb627cd1f +8949d955309415d6d2cf6ee682ccd0427565142c1bfe43b17c38de05cd7185c48549a35b67665a0380f51aef10b62a8e +9614f727a9dac8ecd22b5b81b6e14d34f516db23a1a7d81771ddaa11f516ed04d4e78b78fda5dc9c276a55372f44c4d4 +aa85d3ef157407bd8aa74032f66bc375fddaff90c612470b5ff5d93659f8c3523b2d1b6937b3cc4201c2aa339621180e +86f8fe8bf4c262dc6a04620a848e3844f5e39a2e1700c960f20ee66d4a559a90141ef4e5091d0f32acb1e915af1e0472 +b3af2eb785b00588371beb3b49536b7919a3f2175d4817de5dcbf7fcc20c512852ef0f313327fd0589b10173f77b92e0 +8388703c512eea59190351f3bd2cce83ff8bcb3c5aefc114cccf9e9b3f78200d8034c3ebe60448aaf6c912f0ff8f0cc4 +95d0dbbbf08ec1ed3975fe7dd542be0a05156a2b3db5092825d918a849411ee536ed958201f74a5513e9743674d6658d +8d1a48802f1a2db247e633ddf61d3ef7a2c062c48dda59bf858916e04f56651a7d51e367d6535964ebf3ae6d2b21b421 +971436871bfe868f25247145a55802945409b3150008535b372c949760d7949dd2fdb40d9b96ae7473bc8f6e9b83ecdb +8ca431728ac0f156763090828a7b6d860bf591e5b9dd3bb3b7f3ba0ca74191f9710ee55efd32db7d18eab5b479cee8a4 +81e28f1a506e84c2b9aba1df720cb50e0b597b2c22f98acc34e710c934cc6f97dcaf33d589e845c2c1f6d8716d05ccac +8f43b11d3f00c41d16c9bc9bc0c44227c056bd77de4f1ca9a799418c5601e744f99066bef47da2d9088ae88eb259327c +8d330aa52744c08ef98cc5599eec8b9b4dd18aa01b803f1d1ca0e29b74f1aa2886ed0224390fc377af25852851fbee03 +a06f5b203b67134c685039ec2bdbcc787353e2575ce73a415db24a517c0c31b59d1de89f12b97cbef0219fb6a1e90a20 +9269a5f49bbb8fec1a387b5d105df88a027de615d5ca6afae20fe89b11746f8d23880db78dac238c955fc8bb3de18046 +af5074b3bc0656421c314547b45b5abd3045ca1b17f5e34ba39d8c1f7928a55d4ca5ea9c2ab59a55909b25255233e04e +8e7ee5d733c8e08f3fb7d85f0628de3de6835121672c65374905dc6d19e02fa2df14c13d5e9835dacd609a4df09abd26 +a9b9aaf83d31e879dfb8e73a0708801b4dbdb5d7c8654b27d2c0f5797ebcacc8d00a82143e2060f0917c9d41f1a03de6 +904872aa1c093cb00e1c8e369a3bdae6931c5b1ed705dd3bffba243dc4f42df3e7d7cf70303d513b34d2245743d765cf +8a4d6b3b1d6afe67383c66693f70b397e510be28e3d97dbc8ec543d699b6cbb0e72eb90a7f65e83cf9f7ef50fb18b128 +a914de13916e6a0dc0e0fefecb3a443cca80d83276513b70c22c6e566a2d41acbd33a0e2836ee09abeffd3a4894e437e +b9c408f5f05934b0aefab301ba22f8254c5ebbf5405b6aa788f76e4b328c150b395f441e3566015a0deb3eca89afe9ff +8d32aa2c81b2a8b89f347c2e0b6567b2117ddbb778fda8a3f19004b7f5aa9dd814b9b3ad35f9223715d2447b2d12f159 +8230e8b9c84cada1bf14ea6aa9ecdadd978d893cf5962fee6c7167ed21239210ea491987f2c8f2e8cfea8c140704ca28 +a5d7b6285fea51c6f21d0976a7c3a97baa3d733a201bfaac0994db6c65611d91c5fc0ebc2a7724ee02b371e575573649 +a54f00a9530f6930069f5e3a8b8b1d52ee1def0aad1763e3c609ec07f25410969b43d5943a94c235ed5eb207b33a402e +a8dc6e96399b81397734c61c3a8154e55a670fa25fa5854b3c66734cbb4ec0d8f6ba650ee3c71da3773ffc9e37abf8bd +8841fbfae1af4d400d49f74495f864804f043416c09c64705251d021b3ab7881f134a00b0241e61010617d04979d747d +95acea7ff4861cc969c1d8cc8775c5eae014ad6e2e0e2d0a911dd916c34ae69f53eef779cc24ff1eac18c2b478d3ba2b +a5dce74abcfb8c68031b47364bd9baf71a91db01e45514ab6216f5eb582ef8fe9b06aaa02f17be8b93392d9b19ab9c06 +89e111169e4ae2f4016c07c574a3bdacd8d2f359561fbbdaa3474de9bc24ef8936784dfe6fe0e29a13cac85a3e622b61 +a4c511af6bdf3892939aab651828259e4ef6ebecfdd503ecc14e61001575b313a89e209cb55a77ec19a64d29ada066ef +923c62156fbf3a44926ffb5dc71f7cef602dbe941a98c61f019a27a18a50c16b6135b6099fe04a2e1dc88a6cad989fb7 +afb9191c541b61afa0ef14652e563cc5a557842ce2afea13e21507dde0ebbe6da5233af949c998c00865c79bb3d45ec8 +8a1f0ad65cb2b225931f41dc53547d756111ecbf5bc57c5ee2cc1ffd61b126d0389d311ffe26cf06eaead95af09c5ca3 +9040b20b5ac2e1a9d30abf7a4eea1ec2db8f3077cb2cfc8736b37222d8d3937f5d9f421167086dc5551e9f0bd2522d07 +b6d888b8c6bd448dccaf99c3f690d47f802e134709ce102fb6f6fc68156943c0762be6f386338163e01eed2d1dd5f734 +b94f0e27bbcda793e4a272603b3dcc739d3bf3207798df7319f8dc9d37cbd850e3724bdd30498c929debad971950223c +9769827767be9d7bacba1b687289e0794c6fe630d33c9b607da1f6a65e3f34cb8bd65327d9287c8c5f3c8b5f6d3d133e +aaac72c993aa2356c9a6a030950441de42b2d746bace29865382f0ef54835bc96958b2f00237d805ee6a69ca82117c1b +a2b1f027d80c1b0e79bfc7dd252e095b436fba23a97a1b2b16cdd39fd39a49e06a1ca9a1345c4dbb3d601ffa99f42bdc +b3fa0ad1478ca571e8aa230921f95d81aed7eca00275a51b33aadabd5cb9c530030691d1242a6ff24e2d4cfd72a47203 +a43ed4368e78daad51b9bf1a685b1e1bfe05bed7340d4a00df718133f686690c99198b60031513328fc353c6825a5f2f +965e145711ecf998b01a18843cbb8db6b91ff46f668229281d4ca52236c4d40804ebc54276e9c168d2a2bfc299bcf397 +ae18e6efc6f54c1d9230210ac859c2f19180f31d2e37a94da2983a4264dbb58ad328ab3cbc6884ce4637c8c2390f7fc1 +83a9200486d4d85f5671643b6daf3d0290b2e41520fb7ea7030e7e342d7789023da6a293a3984308b27eb55f879ad99d +b925fb6ca83479355a44abbcdf182bfac8a3c7cce6cfc7962be277ce34460eb837c561257569be3cb28023208dea80dd +9583dd991b62ae4bd5f379ccd3cec72cfae1c08137ddfbacc659a9641e7d5a82083de60005f74fc807bd2acd218d0789 +ae73bc32e9ff5926e1e06c07a3963080881b976c9875777f8e4cf96af91bf41bdbed4bd77e91253b8ec3c15b4a6d3977 +b2a3ea90aa398717ba7d8c46743e4c487b63c5abb140555d8d20e5115df2f70d3c84a2cb9a5e0536b2d93d24f271b38d +91d119d3bf1d34cd839eb69c6de998b78482ab66bc93fa97e31fb9592f36cdfcd673f52366f8c8e8877e313b92d4a2ad +a1907e20120902cf68912cc3046f8806cabbd7673e80218814cb088e080dd93b5dccba395b13e0025f5755c183276c3a +b2e2011df72504065ec4c12cbc2137b95cfcd1355509671feb7b00dbf7f8d500476a49754cb7fb9219cb5cba7c8afe01 +a48589fb7a74a3dfd782cb3503e6294a81dbb6adb412887569f9408e9079371edbd9822388e0b7ec8d3297ba270f53ef +a203909bfe196ac65ed3e6800d577b6ca5c8fe1d40f7f925a43852951e38883f2ffd250a9e16fab3ed3dc1249650247b +997ac293722a8b98f7e819f8e6c2d4c5bd1103b82d489d8b8aabeb905e95450b9b75bd61442cf68cc957212ec1c55617 +9895a3de62395c33509b153b7820bd94fd2b011f0cac135fcf916482f1eda272ecc79f83a61837e99c3a3c4ab2c5c2a2 +98c2ece4d49a64ec8e06407a0585081003bcef88af35210e22eab91169f8f0c044d611494b755e5bd915804b1d857747 +8bc6dd083b36d076ddf0e0bb1bb87cfd059283ddabb3886f02eb7e27f1f0539b2819527b56b5c13436523c4603ac1d12 +85ab8b7a696333c82dd5e179e12b2e127e67d911de609ff9a03cab95cbeedb1f364aa1f2b5e59353e4ba0d177f996151 +a9478e214afa68c395aa2c7daf8ba1627feb71ad6d8bc7339734cdcdd5a42838e032736c28e6251c808d5a4875ef0d06 +8c53f62cf06a35321c8af3871ee4459768d0745ebf48942b9f464206309f42fc7b2c50f196ae1e43b664f0e2e718a23a +8ba80662f6642d8866e832ec8082a4204ebc993fc304c4b794666856de0407620131a18dc053597bb40a3de0bf8aca22 +8c8fac6b911785d1561a985580c03fb2ebc613ae33e486a92638aa7d4493374118d9a6d9d99121e29c68c3d67ee4e3f3 +90f2c793eee07ad90157040b30558bb3b0164e8ddf856389d6742cf5bd1c712e4c6a8e5678da70a8e9e242ec7864117e +954abed8f6d58896b7f6438c9780236c1c83b02d60a29fa7361559e619e5bc9d67b3646ee39ffafe2b3019bb3357fb50 +b79874f757a33085e1e751544de8fe3afbea92e0234f9c00254c2b36115a16ee46f085f22aa66e0c9177e5106f51b03b +aa148b287cf4f60c64f774282b421aae075f0eaa93a45aab4927750f47e2ef0b811d1846bbb15eeb2f293c80a7612e83 +a588d8825e7b0168d45499dcff6faf0dfe1ba4f090fdc7c06d50344960c0121f10ad109b0b9d13b06ef22de5a04eef87 +8f61ec93d14ebfa9c31731f9ef0fb8907505fedc79378e9a3f65c27bed4d74b41e129c97672ce5f567d897befbceec8c +a008218633f1da10efd01c155f7ed739faec902da6dc48e9f19ccbc8d32bb318d71806285cf2003de2c907bbdd4f8b22 +88ad82c66f7085632d7e348d69da84200c53594553acf5432b50dd1e87f410c802dfea91be3cf804e3117ce13103f23e +8498dba17de0318af227a3f9ed86df37a5c33f9a538be9823f8dce4efc3579e8296cb3b7200cee7c5e0bfd9da23a4b69 +b3c0342231dffe4c9bc7d9265597bc8cc4a82e2980ac6d1407108db5b00349dc91d5116fab51cf2802d58f05f653861d +b3f2730455f9bf5a058598bc60f47740117ba51f6a767e1134516a4e42338b513f377027acf8825da5c4d047a62984fd +816360914fbc9d8b865157bfab07aeb7b90bb5a7c5cd64847b1c3184a52266cd3f8f8f3ef99309ba2edc4622304bacc0 +8fd21b2315b44a52d60b39ebc45970a47b9495f42b88217ae057bebcd3ea0e2476c0c3d13de7f72016ae12ae966a008d +b62014485bc217a0fe892ef1aef0e59604ad5a868face7a93f77a70ba3d7413443fbe7a44552a784d8eae1acb1d1c52b +a905822507e431b35f56724f6c8d2e93b0607ed7a4533073a99cce2b7c1c35367382447073a53036dfdb0d04978ccf2a +81672e39c2b31845142963351de3d9cd04c67c806fdfe77467867463dbbd8a9b0e2400ccc55016e57cbedb02d83a0544 +90919c970ec668de8ec48a2a73bb75cb94f0f8380c79a7909fd8084df61ecd631476ddd474b27103c6817c8f3f260db9 +8fbe37dfb04bf1d3029f8070fd988fc5e4b585e61eab6a8b66caf0ffef979d3ed6a662cd99468ce98ec802e985da5fad +950939aabb90b57a3d667f9820880eb0c4fee5c27fe211ce8ecd34663c21b5543c810b3676111d079ac98644c75ee0ae +b06201ec3c3cfdaf864a66af128effee8ec42d25f1e173c1edf9207979fa52c871757000c591d71a9b6cde40f5001a06 +a79054e8febd0450c96ac7a5fd6bf419c4b17a5926f3bc23a8616f0cfbc2849d97470174cd1baa7c739b12615334b6b7 +81c7391b2a1844ed26a84f054b5f03865b442b7a8d614cd44805b5705fe6a356ac182b66a3c8d415132e389efac5f6b2 +825af1563d0fe53925ec9ac0df65d8211b333474e59359bf1bde8861eecd03f2ac74534d34b7e61031227c2fa7a74e1e +b60dd9bf036f1825295cd2014ef1f6d520cf729b4d6cee0b42cb871b60ae539b27c83aa3f96ee3d490ec27ce7e915115 +89ca43d5b7f3622b42df7887572297a7f52d5204d85e2e1ac6e5d7aa7f8aaea5e3a07280477d910db025d17cd2e7373b +b93a2bc9b1b597f0e514fde76ce5bfb6e61eee39cbf1971ea6db38c3ecb055e7913ec8cd07fb0b0ffae3ca345883101c +8d45546bc30266b20c6c59fc4339eb633155aa58f115a8f976d13789eaae20a95b064fedead247c46665cc13ba856663 +aa8eacfe00e8a4d9815de3f7619d9c420629ada6489933ca66a571bf6c044d08b391e0d9eec7d1cbebe8def1e7523f1e +b32fefc59a0d0319ccb1946b351ed70445d78d9fbb536fa710d3162b9659f10288f12d82b32ecc026d55f16cbad55441 +99c7c45c34044c056b24e8f57123ba5e2c2c039e9f038a66899362840cffe021733e078866a8708504cdc35816cb335d +80def162c134540d5ec071b25ccc3eef4efe158be453af41a310b7916c49ec0ce06bb43dfee96b6d77339e11587de448 +b5f2fa4f68f6a26bcb70d8eab62ad73509c08ee7aa622a14b3d16973ffff508ce6f1aff9ced77b8dcfef7319245cf2de +b4d0436019e779c789464716e1741c189e8945dab7f3072720bd9aa89882fa5b085a1755c48da21541f3cd70a41b0a71 +931e798ef672e1472f4f84c727a101e70d77b3a9f0c0803a5220958d6bbeb8aeeb56c769ab472a3d6451249a13a3f56e +918c10a84de268aa8f1ba24b38fe55ff907be07b1e86b4a4adbf305c0d705c1cf5f65ce99e03e11676cedc89f1a4f331 +8e55a8413b823715ccd92daee357cedd797e69a0e78b6fcdacb7318646b9903dfe05e5501f47b3c52e74055b9eb619a4 +8b329bb63e6c985d7d072dff4680b3f8b1217ed20543277386bd30ec25240d9dc378837dcd5cf4fd9548658635f4c537 +8c2be5386052b22986b33dbc63c5afacb6d0095495564ba4aa28fc8c880a3c78242fb083248d788ed928deb1e30a82c2 +83a2b7bdfcbd25d6b059f27218e009ecb5ecc4da68ead885e00216411d8222062ca42f21c4d9cfa19c31522080af677b +9620334d2633e85646b2e2fc48dc6c3f09c64ef1706ed78a3bb6ce1f6b274a727364df71e97531dfdcb392f70f27f536 +b6c84970ec04545121ec3b79376f4e45053c97e8bf2b11922cc2490a429c38735466097ecb81cc9d9692c74d2fb8abc8 +8e55d707dcf265c5ae29a32c27ce66f200fddb724faa5bbf145ef42280ef645fa2f0cc3cfe2db8599b26c83b91e077df +b910b96b763966402bbebd68a32c15a225ec21e1357fa298478c5981a4310e556103fef0c73bd8903e11c4ed2c065647 +a8fd933a0e9fe8c459809bd93b8ce153e2af55df94b61a1490736b19c89469954da8b72dbd072d798fc06fc3d7a3d60a +811b279c113828e114fd82c2070caa7eb089a46c8cabf865f9c77354a77ebebe0c4c6400dda0e66dd017cfc44d76851d +8ed03e91c331afb3ad6e42767e1b3e8d3a35fb831805ff1b5fd3e91878e04027ff5af1165a3ac295f1578faf2c83b581 +95bf53683d64a0621bf1ca6ee17446783f6c535b7a54d6ea57723487a215759a54f886597a55dfdd560424e368ab2759 +a9bea378768fb1d7ba365a16531c51fc1975f1c73caf2a0891da28509805fa84e2a8db7c6ccfbc620e9002317abf174c +b8308250891015deaf851c4e5a4cf4704d104f94064418488d7e3076d49f36240dcf6fdcf83f45fe8a1d97fb02e3db59 +adcda6b63da21f4074f142f8e7f3a2274f624c733e3a4001054a1809711529c61356aa087f73aed877a58ccb41d38d12 +b80e7869239ae26d1da2e6683f064d1dc93cf4a2b66e9439b3ad9b25324e969bf98014760d29e6b8de7ff152ef498d0f +8e9bf968911df3bb5e3a7655e9d8143e91ee87f14464d7ba9c86e1e31b03ab31b91eda121281b79cd974d9ed2657e33e +9007277e8335a43e6bc3c2f5f98c0ba7024a679b7156aeefe964f1a962e5ac82154ac39d1ffbad85a8f2440f3c1e354b +9422b9d670e997b7c919a429499f38e863c69c6a4d2bb28d85e36ae0895c620f68b71e39eba785e3d39a45be91507757 +926094e01132938000d82dd9a571fef5ef104cd25b4015a25e3442af0329e585aaad5472f0e7a69899ba2d6f734b40aa +95552d8057f7e32c24d69e4d6c51c98403f198a20c5be8826254d19cab2f84d5758e2220cea7e38b7c8a7a23178fd564 +8abcf8dcc8488bcc9ab23c51b9e7a0d91dfc7bebe88b7ed370ee68eceba643e939c5eae66a4aa5fe85120751780e351c +a91bf8198f029e6a4cf6f0cc39b629e9aeff1c77b8739e1d5c73d8c1d3fb5c8f6f23e27b435bf10b5b4ec1cf6a7249ed +b932d87ee3a4b81341511f90fe5aa36c571e8b914f25abcc33dd40ca67a3f6444fe9362c1434744e4af18d6e045c54a3 +a8e960c2be9b1d805d387b3ebe2134d421a65f1fd4c1b4cccdce78f9926f139eea78e3afb449b3d6dd19b5d16ace48fe +a7e2f57cce509fe66707eaba9b4c042c1be93fd6034a9b51d1d30c45c4363eac79d54663d525c9873ab0eec0b1cc4ed3 +aa162a31c2078f4b080199debf24494a8dfdfb9d8fc85b198a861b12a629c73128c55a883e4c2de3dfed6e0e1b83eeab +b5a4d075433eaf4115717a84b4dc37f843d44bba0bf820c92ecdedd5afb61be60f7708c8a151a678d9d5c0ae531bffb7 +b56ab96f7a463c0079e05dc766f3a6a31cae5c5044947734ebe0a26e01367c6763cc8de6c2ee2f3b8218f05bef217474 +b60792ac506b901065a8bc0180a86e028fe34b62ceae1ad640c759538ebf3a2ad9c8c927d662deed6f489ff3ff7813c4 +8c8c2cdf075504d12d441a58542e1f8e4bdf92b3ee4775e836b2734c5ec1e3df919b931386417d04489a1dca806c87d2 +8ed78e91e5c4a68894cefc2f7fa71f02e5e12d40f1bb74332139bc7be4d92c24e07d5ece0e82150ed474aa1337af4c18 +87119c22ff8aa31150bde537d863cad661cc5159b12f084cc319224c533f0deb28526ed8568d00a1441e7d8bb4f05673 +83a60ba5a9cccf22cebadf7318b706c9f29abd25db0e2fc1c802965351b53cbf316df72ee3e9b2d3ae7f3c4494cfdff1 +b73b6a9fdd3e7463fbdaabc9a885b7c82201ad867d1bced1c2484300a01cbbb3f1e21afa95d4c7cbb6cb983416b63b90 +b1d89ad16981ff9217708090d4017662d8838f21f3a3296cffe14590b533905fa06a20e40dd497bd291fa4dfd1bfc511 +8abde560083e071a402e3c7bf31930f537f67d2a7bbc734a7480b1b760aa712ebd1cbcb65b00e11e384e980222fe14a9 +89c731d8f31afea8bdc9c32527bdca257f2a840764d40f6e49403b8e75ae51017d505ea4fff91bf28b6f3a1bc65b8bbc +80e9ac8e077e86ad050ee73dfce268a69564ff1b8419e9c236d981fe7a5f0c2bc756e8603ec604b3b9e36da8fe10a49c +b4f1eea0f304898b1323c6382732e6f40e556bfc68af9ce73f6d54e92f5f23cc4f78eb3f43d578d81e7627fb40f092b3 +a0e3a8d1348f8f153e08ac4839232d75d1d6e81b5de184ec4724f8213baf98d3fe739a96f6b39d79a053b628c3a09981 +a6915ba0b52ffe4a381bbb8ff3791d9d3b848bf89b3bacbb2a7d2e5ae21f1353cdc304b3cb6e82416f7e604035c27d7e +b2c4c9cdfdd2fc9a340ba3ade9423344b9f429e8c7e20a8abbf26400376e312f3ae35d1c456be99dfb5c02fc8a36cbfa +9657d57ca0641825a0aa5687f3f87659d893f33aee819bafa5b1ca1db554811c1c844f971e278606e3a2f096defdc67c +a4ad24d0a557704ada24d8e27a15604bca28679e260b2c69ccc8e6cae5499866724b700605a90df7dfb35130756939b9 +b18d9ea6682f73a1f99a9a4fc98c38fcda02c1a18e8c5fc080cf935a2ac877dc5223fca273dcde190b906178d0fd05bc +8ea5fefad0799c885f50ff10d94bd0af5b99b0a446cd1f367ae5ff529cc47e09f3018115f3c0ccac2fa05bb65b84945e +92450d52e6c7d13ebfcdf5674d6761bbae2fc5aabc865d35d031b588c383e0a64cf69a73dc93948632e2b98f74a5ed86 +a356f171a98df4ec5a96d556eaccc6ad34b4238aafcf0e94ece27cdbb491749fc9692e78b84dfe80bdef2914079d34b5 +b918703a4d3507d266414712ba8eb7ad17da07cc5f952b5c62ef130cc6ed1ae3bf01237fc8848c179725bdddd465b301 +ad2b0554570bfc9d97510cf59bc38e10ca54a93649c30ac9919bd0255e43bf525ab11b74f78a51ac0973cd0c5a5dcb54 +a7ecaf4b631d179d32ac1632390d95196a0035e00da6c0e6e13b5c09ae44b15ae6c21538b5a31b73bc5f650ecd979b59 +a37704eb4d728df2a367e59fcb6c26023136230e37f3b8a2f3ceeb1467f5cd30186fc0116f98b64a8146fd2c5903e8d9 +b09373ce92314678299ae10ec1f93c702911beb4115c6b5ba6efbcab9c7afb599f59793912df70a98868bce6545a33dd +b52a878a1393094fd2b93f2d1eccabf2830ab10800ba4cc24dcc7849cd0978733263aef2fcb766a7cb575a7a99383db8 +8dac097e006fda4fb9d6d7ae52adabd9448ebc8d5bd5b38ac0c4ed38ceb510763174f7adfb0b473c38e52147ccab4239 +86b19c41efb949937d74a7875549ee5e997f9fdac7f7198085afda233cf74341a38d0ca3767c76cd35f875b89a35f78c +99f0d927e5ad25cd134f1c70b72631cc6b5cb4ddb86c0642b900464e33d971213a5239dddaf71f7a42f2d6d02a12dcc6 +8355c38806c335d747d4e97f0083fb96585677da18b409a85175ec35dc3f74671817b34203eb18c2f729717ce083ede8 +abb3603adb061a036eae0afa5f23d79c3b62442e0e3bcdeef896f88995585c1105cd3065410368456a4d36b5b0485a83 +9051c5c0011784885187d04749f774b9b4f6bc594b0e4e18226de79dedc4d7aefa3529c3d2c728e180f96f3e204d578b +91888213e7d321d0bfac884edbd5cb756b280753bb5f8bc6acfc208f525757beca24bdf86fc68d3d8736ef176a960b49 +91258bd7ce6e3b7516fe2f5391a368d826da299e0e99b1f82eaa44b62b110ab696adc92debab8ba098a52f38dfb3c5d8 +96e3907340dffa9da3602d3b94bacff7e1bb8649edd3b9bbd06e1bc6781e78f91ababab12c0b9be7c66dfedc7001b66e +9513555688fcfb12ba63952ab36a67b36affdd71f7b843e8eb99ccbd45421698024608233efbdc905eaeb26b334b33af +9913ca9bcf11eeb408da02e4317c5ca0010fb2f4490b282ddb758001c08b438c3b35351a8cbe10b7fffc1293ccd22d4b +85dc2471860ebca88e5a2766161fdd77f926d2a34825d1134a30418f91a741759668e32fd1e37c415d07ab5824338e8a +8b128917e828a0b5eb6fa8ed72b52fae2dfaf74febee69a2e2f87e8df702f0c5bc0fb620c8d1d2a07f35a15ec9c0f5a8 +964c39e7840c130b01bb481ae7bfc92682b0f124c9c383f9dbf3027f2249151925f4faf36905af476a54778d69da3f48 +80671ece658cf850e522d46d25678f934ce6df043f25f8707235125765d40c2eaaf39eda6092f75039b22cb58bf2c29d +ad4bb0e79fdaa340b1347a46b0f64e801c72a89770dda0a6e4bfd35f2df5146fce9934e4baecb1c2671077c771eb8089 +80b3bd3adc6cf198fcd997f8867d2839a2eb28f57390352ec423b8a14cc1f2ab21c6e286505d6a21fb134dcd8d8f11cf +a26d46a6b8a75748895a1d599e7fd120d896340e79813167a400b2fe463452532a4cab419074663fe1d29fa716b76a33 +82b1f3a8a1df29207d7ff020809113ab06080a7f0c631f76ad33f47cdfb6a567143144df97b4ed7f676d929195b04bba +ad96633a3744648ff0a2e4491e8219c9c6ba6e655cb058c36320a8f72cd5f72c00bddf97083d07650ea9ddc005fc1ff4 +91d0783788626c91662359dc3ff36a8bcc6831e3f4114f85c99910256b1d8f88a8612f53c7c417d55581dea486f38926 +84edd9e87ff3d193ebb25f43474c33fe502a1e2100fd3f93fda6520f5e42214cc12e9f8045f99aa2423a0ee35e671854 +b55e06a4b1fc3ff9a5520e0b7c8b5ac11b28385cce78d91ce93b82f1bd7f7afdd4195d0c13a76e80d0ed5a4f12325fa7 +b0b15c7ddede2b81d9c835ecaa887650622e75d0d85f81b8bbec7ef24e9a31a9c9e3de1f382d8c76d878d1b01373f6c8 +b1adb47c20f29784116b80f3670182d01b17612d5d91bd6502b0dcecdcf072541f582aafc5e7dd9a765cad52151684f4 +8efd1018df9c9e9814a9c48f68c168551b999914a6719229f0c5bf0f20a288a2f5ba4a48ba966c5bffb0fbd346a4fcc6 +b34ea2bd3269a4ddb2fbf2514401d2712fc46c22642f3557e3b9c7acbce9b454dcf789573ede9aa14f39605fdd03f8c4 +a9e1428ce24eacfc460aec2e787c053327ba612f50d93510d58b2cb0f13291ca3d16358325ab3e86693fe686e4f526f7 +91eac7361af4c66f725c153da665a3c55aca9ae73ead84ca2662cf736fe6a348a301be1954723206dda4a2120202954b +a6f02db89739c686407825fa7e84000ceedb9bd943e8a0908fef6f0d35dbc33c336072ba65e33e15ecfcd5714d01c2f0 +a25666faa12e843a80365c0fef7d328a480c6e3cb7f224763c11d8cbabd0e7e91a5b647585ee905cc036afca14842bae +b4348576439cd2e48c01cb9cded7cc4a0ea364ab936dd679ddc7d58b48807e7fab070f2f1ea88595b11af4500849026a +a8c6c731e0d0464ef7e4fc1b049065eb4ce100c01e1a376365c636a0b23851022bf55805963bc15eb57434a837e81167 +b0952937b154e3a4c206f96cd96c76ba37624956b0e4d43470bdd97b4af878326b589e3eaee82fc192437123096799a2 +97d07ec31ecc9923192e48d37df2cf08750050fb452dcfbdb350fbc43e146bae3590c5b732b31ebfa1ce5d884ad5ad57 +a69359aebbfe4cbc4d39d178150039fbf284cbc0edc68a6bd635ee3a1c76569a4a575c907fff691b2a4d82a384c2945f +b321c2c0f6b5902ee9056cce7404d858da9a573d27348c1a6bfea29b2746f2aee7abcb6192504e5a583b0caeaba117d7 +a74e738aa6eb4eea58855ae6f422af22812fb388c83aacca5bd5fa4a88d4c01463174a229aea2830c348dd9ab9307854 +94306a3b106bc1644346bc45c05cdc8287811d5c86cad691bde0c65d6a686eb9c0ce79ad91baa4547e5d058ae8bf7310 +b64140fd77a07633e4ca8d60786452311dcdb8ce7095ba51dad8486f57c3bf4e69bced92603f71da992a48ad817ab275 +affe7f4310f1dc68e5e3cd640bedf864f51bfb46bb752063bfc18e95930021f784e509261ff9c560f53000c361b142d1 +b0d2fee222c6f963ba3385547f921a48964da031d737892604f8f2677d4905dbf615046db57eae6c6dd756709ae6932a +81700c66aad7c2e51168e028b0fe086dea75d3b17d93a4dc1f47a6a0f025df0bae1c8c997901837ad859a84197e7bb00 +aa4ac5fdd602f8b79cace18690e67bad557a93d00c0e295074185e8c6b4059a65495d9971685de2fc01d2171ac8b706a +a8becb3a64fdf35d65d2857898dcf8053b5057a73ab8c5bb5324af1a8015cff47efb85dc3eae7364cd5c850b7962bedf +b72ea09bd0b72f8cde3466f359ea69b194ede93dced534efba1b9ebc6f3bd53942fe2965e992e82edb6050cac4ed88dd +85bb8dd7eef023a251fb6f220af54687747f4c91983ff728163c4618ffac40ee6edc29a0aa6d455276bbe017f63757c2 +85a485254a11b4c4a943d9ec509c0dd1cbfc0ff5273a00cf5c9f0babec973efb15348e5d9451b548293d778e3a2b62a5 +b109f3ac809391e772b589c196b013db69a9b2b10ac3898feb70b986973731f30722b573cd0c9324158ec20416825385 +8a4eb579a840d438bed008644f373ea9ba2f28470d50cf1d70af38ba0e17326c948527b1719dd1bd9ac656ebd5aedd10 +a52e9d66ead5ee1e02ce6108e4ded790d8ec83164a0fa275ab1f89a32200726c8e988d66df131df9e62dd80203c13dce +b541cee9febf15d252475507e11d65c4b7819c26cf6d90352f5e8a8f5c63e254eddf22df0c35a7be5b244233e8e4ee5e +8153c297772adf4603c39349142f98cc15baeccaeae10c3230ee87d62255f6814d88d6ed208c368d2c02332426589748 +970dc9782f1828474e9fab7dcdec19aa106725465a5844caed948eef5c9e48199c1b6bc1a637ed7864116927e84bc65a +a975a920624967f4ecc77ea5d9869c434caa64c330024194615a8d0640c5d4d4fb139ea11a0c73a5c6ae6dd3fbf0ab5d +811f0f9e0c12acfb4b9dca359eaef3bed18083bad96188befc036ad3143b121fff4777ca6dc70a835bbc4921bd25f5ff +82341c6ebdb97c8b72910da95c7eebccd1308b6a92999886aab552f0642882d5c7cc60931577d200efd6066530c998dd +860f7162c2f5fd1c0953c6ce75bd8c52eaa48032b914410681b8cc05e00b64130d1f96ec5a52df66a04c78a9f9f42981 +8a578e674875571fe1a0459843495a5ee1d9fb6cd684b244feb9488f999a46f43363938cd0542879ea18ed14fba10a6e +8df217aba4da6781f0f5139aced472025523ed6e17e504511c04b677ca8197488e237d8bb5dff7b6b3898cd5a6393dd5 +b2c9230ad35d7b471d3aee6f771517cf3145ad26200bd6fe9c7cf28120e2945fed402e212d2330a692f97bb9ac4dcf12 +b78b89e29e8b782603b222cc8724eeb83b2d9d56bc02f59a3c899ab76429dc721358b07dcdaf422f59520b7e7ab4fb55 +82682a5617843c4ac8d4efb4c3ce715c76c1da2c3bab1ede387db503f3489c1bfdfc07d9231d96f955df84fd225bc81b +b0f53725cc610e78b8e8a4e6823a2ffe44dd15a9a5bc8151ab7a3787ddd97e1d7f2f0e6efd2876e5f96417157143e3bf +92c5a93233085e2b244519078770c7192af62f3562113abc8902f9d72591eacf52bd15ce78653ab9170d5067606287f8 +a43ef97dcd9b6ad288846bf31fccf78df72f94bc7ad768baf5bf0d5dfa27bd74ffcc6b6c6ed1d1f09e09be3afa5eaedf +817d43bd684a261fb30f709f7926cc4e1a31fd3a1a5e7e53ba4d664856827b340d7867e23d55617ab3514c8a26a7040d +a599e22d3286b32fafaaf79bd5b0c5b72f6bf266ec68948478f055391336d756b58f9afea0167b961fd94234989f0f02 +b70db7d8e8356df2e2070f8d658e560081442f3f3b95e20f4bf30106835d76161101163659d5d12cc0f335fb042dc66e +b8f725b70c957aa3cd6b4bef0d9647393f7c9e0b7343e92439372f0e9aa3ceddd0cb9c30be331742b87c53f2eb030593 +b2fb5e7762f26036e7e966f4454f886758804d1f4c2da17f3d13b0b67ca337f1fd89fd3cc798b07da6e05e8582c9537b +a377f944dccc300921e238ed67989872338137fe57f04cb5a913c787842e08b8a1adcfb4d2200abdc911fc1c766a7092 +b82e98a606071c2a33f2ad44e7ace6d9471d5434500de8307b5d4e0083e3a5cbc67f0609ca8055f0ea0ee7501b9ed916 +8e58f9a04d33a41ace4944615041662dc35057e645f63e127cf0d70f96ac307d33a62ce98f164d6eed8536c1a747dcbe +b5b11388071ffbf57ac47fc195736613b964ebb91cc8e2c17b32646f91d64ea506282b881897fca96c317364d3290de2 +a40ee9b7551133856cfb3904837f9949a9558e59a418898affb78adf1500fd6ef6328fc4422161909aea2c79ad08c14b +81f9eb4ef28aacdb43e11dfc9aa92ba990be4d3c14b484fa677edad3a3fbfeaa859a7f9322b5e95818240d7326215abf +84939b2b6bc859437d1a7a8d6ec9a357c6b716c4b4cc22abc274af872655940cfc72c99f5d0283d90e05191fcdb1c232 +b78a5b74a90a805410b6225fb9576d6d73752520f25cc3fd1edf8ea9f6559d3080f9acaa2246809b6a66879cd2ae446b +8d0a92baa88bf38dce5385ccf15d345b28e2e5d0a2d469e689353d80eaed8e8408933816d70ad752f226c59a0d5b5f0c +a7e15f8a8c1655b7b346c9488cff278c793505379b781b31b273b4bf09b3bdfca1c8ab2334746075d636b2e05859f215 +b70daf14f2adce03c7b92d6aa181f0c507a80a37493d8dd12419d5ed5f943a98099fefb46ac827d6e4efb9b8233c99d6 +8c2480814661744d116fba7355bc6b1914975e44cf0e976d50b6a20092bb1c636b7b44ed3fe8d63b5555ffc89fa759d6 +a6059528a4fed36abb74ab992b22a4f9bf1d05c5de2bfe6837b9af1adfed98bc37ed7481b5a99675d432743021fcfdb3 +b7e19f1b25bc159e5a769811e773c3a8ffe8be8ac77ed0b711540915e5c6e7bafdb407cf9b85c551f67fd621ce8142a5 +a2f66d4f7d16ed3e7ef5fc90b42676c61a98ff18bd26ccce91de03b6a0130c1db17a6bc57be135e410a76d2255b15813 +a139c916927dc3d3fb83598da9217ca64f0ae127215332e9a7ed82be923b89a801c44580d5617297175f9dafb1c4eaf3 +af08e1e1b04ec95366a12d99c80a9a9ac40ac984a575dd0230cdf4eb346a7686da55ef0a276f3356f814af31f9cbf1aa +98840aefe287369221c0721cd7c1b15b1d670c3cbbfda191cdb5434bcad757e59c30ec82b2d8c75947405888d44da435 +b7c61c8d42daf2e278a12d8f6eed76090b71c82275f8b33504aba75d95103840e8acd083e97a5a5aa79897876a68940d +a0264048d2a2061d32eee4f661957ff351e78436bf49ef973c059612874ce9c91970869d011dc13a5b7c754476880a68 +897199a4d8db8aa2db5d9be3d4f4312e41fa0739eb06c62e2e046c4b9be829a447e5d47227e2d96195d3b7b66eb59da6 +b512a9082881f5dc90b02f8bc4f38b133348c2e933813852f6a8e7d8c270c9ce68a5524af7d1d3123e53b2d02a53d465 +80b332469254a96f53c95ec79bb5a8bb1c387d40e58b73d72f84384c696ba0d3c81d6ac90be2979c364c44294e90432e +ab680c2e547ea5cbf95bf813020beb461d50ee4341dea944eb48f6a8584d35682d20186e3b190b849a1ba25625a7f499 +9070581993a0531d6be372d370c2e4ab2ee53f30e04a75ae61ea0fc2c320914506c4d2d4b4487c1f8fa88356fc45c895 +8424303dad6b4051ab633ad27ee51783b2ead61c5a6dae1eb3ed72fc1f36e2a9b1f315504a4bd90f9664091f2f403d4c +82225611eee626556553b9316dab4043aff241a81826a33aebd9864a91e299b765ba1fb43eea2c2047e6b75b6d7fe3de +8a3fb221c616ad55c352dd5e0c09ee892022013d6965aef40d4f277a42e9fa01226fe973cb99aaf6ffe4f4f348fb54d1 +b07c07679aa51713e8a7d7bc304dc15ed5664b66bd371877023f3b110b3927e09e259ef22895c4001421a69c6c013cc6 +83556c76bdac0dd8db6da231b863c335be076e7299802eebc259e0818c369f933a4a4b18e2df8ca07e82f60767b462e0 +a516f659b7915d2f7cd0f0f5ea2491b15f0c84dcb191e7671b28adf7cf14a56d42cfc0da94b3c269b45c535f6eeded49 +80d7cc6f26066f753041b17ff1bd27f6d4b5603a43729d33d596e21a67356db84ca9710158089def425f6afaf3207f9e +b802a47f9009dbd48851209ea1e2739020e717f0ae80671d9f97a0e43de923273f66b7fcc136a064c8467372a5b02d28 +ac92fec1864a8a911633f377df87aab56713876316d48240fefeee49ab97f7406c22e70f4938b5912c5c4e766146b7a5 +89224225b9835d04428b0a74edbff53dee2be285ddd1e5a3a8c37307c0500578155f0c4052e4bc8be04c56862fac099d +b1d3c8492fbf22ea60732745edd3b0163ba5a20d1a3315e3773f2540ee38cf308d42ec72cbb3e3dcea457d1d132c3904 +8bd00e38ec30ee6c44a0e5b222f1f737c9ed2a4bb9225f1741d6334df966318c8a0fd2fbb109557fe8c9479694b8d8dc +a930ce5454efc0b247dc148aff869963fc5c240241d5590415cbd36634801a04d3873d93635911bb9c0c42ecb005cc63 +b83d4f80e9e0fa47b42175df74935ba8aad2e559b80e84478ab1685bc3eb65d51b93e5738d5ca968cc055ca0c552a03c +b3ae21258f98051f13af3878b8103bc541fe6f20b1c3f8fb4689ddb8800b3c25cca9b55f0a4104bdf15dc4d5844abb8c +831ef8684c1cd446c58c59d0152aeade5cc305bca6aa296b92162615f052ba280fe289edd62fda6d9f0667c186445f52 +97bf9659b14f133885916733b7d4ac7e215495953caba970fa259f7bf6b79e661090ec8d79e1c9ce8dfb17e8552f93af +84d5a89cc2332baaaf3d19627a65f4b107f8dd9228a1434b327732f59883bb54fb8ce60d6acd026ed4b0e94e545d1c33 +8e66cb743f95ca5486400b0d89d02e20b98044be1e3a12983ff9fe086179e5a0ebf4dcd5098703191552e9aa660a6de5 +87b4cfb35bacec805f8148786788db84eb8f4bcecdd0570ecb592c705450ce1a90b6d183d37ef58780ede3995be67497 +a72a4fece5478011973afa543f6d8a8ea06a64b241cf7d8bd81fa3740ac2a4cf10e5120abcc1c1101f94da89507a40ca +89dc6001a96adcd2679916f43dd19ea00508c8d5dd6b0090eab7982fd2f3571b62f3029588a0649e73f49124525407ea +8ca75edf1259599e873530eff6151c822a4018e71a340534219ef8641cb6683215891df41d4e3c0ca2560e57a7aa913e +9282d32f868e5ee6f7fc229dda5b94b603476de30cec0a44a30edf396b52dc0ebd472b8f726d4b67d76179fecc1666a1 +afa24704223707db89690bcf9761f07a093f6009ca9fc945e0a8801fc29f9f51292bf95243e466fe736088af36c55ca6 +b51332508ddd9a2610edd2b0ad120272ca342e96c28baae37a2c4f07e689303a46c237712d07e446b1d67c75aa8ce32f +9219249f3799dfa4eb4770ee323f821e559e7406bb11b1f1889286221b22c8b40ccacbd9ac50ea3fa9ed754860bc24f0 +993515270c128ede64fe6f06755259105d0ec74947b7eb05924a375fa5c6d14822f3d7d41dd04fa5df8aa2aa205a1dec +a83be4c2511bae430034ab15b194ac719d7b7041f9c0e321317f513a97db39e97b9ee1df92a1962f265b7a3e98cdd753 +8ac7feaecd26f7b99fda3ed0b8a08bd6dd33ed5ba687c913ec0ffc64bbbefcda6f265072add4d944f2005634601ce68b +b4e3ac6b09299db9e1a469f3a0b2d8d724ee47a417a517bebc4c2ac3efc5cde086b57b9aa4efccdef2bcf8f456d973f6 +9262a24a84fb7b2a84d700f98dcf3fefab8b47293778c20bfc356860cb84e0bf102bae9facd9986d92d1762e0a955836 +97be2041c42bd25e5eb519279163b0857f8bef627492c27b1182f8bf0033769246be5886422cbd2409c08a2615352465 +b0b87d059a00e3effa2e5e4925da913b245785f2932ac3ed364ad19a064d3561b8aa6afea22c951316074f0df179af36 +891644b7b3321b06a2a40cd96c2b8b29d81cde5b48546483fdda439000982a9cbf1f6333fb6c089d39da6492cdfaefe9 +8da9149b7f4783a24240b7b9c7e6df4abf8d699d3834e31ee591489bf4744141ab199c173db64397c1f9bd5f9c862ca1 +8ad7f9fb2742654aa2964fd468e7645436cefd1308b064fd63fdf0d3adb4caf6cfe5426354f6cc284f208b03d6b2d918 +8435e4668f7aeb027100d21e4e0b6ee22b401d21966a3736b95610de86c7e2f2c9ee5d0f901353675eee5ff458dad69e +9010895f045538bd11b47bb8996f27198c8d6cffd3220569e6b7407f68f35c47d1efdbcecbf9b5e241c3c2879a4f6936 +92a9aa443b5ee7bf13b6f43f2d8d8db7f6f33fd4073a606ec5772421a55f464831419726130dd97829a7d4bfeb1ab078 +843f3266560be6dcbe0258c3c7d7e332330e10630c069892954290288eda301e247f479505a8a1bf7e59c99ccafd104f +915bd1dad808f8a568725bd243f80b5476a2999d0ef60ea3ef6e754155bc4121b2b879d01570725b510c5a3f09cd83ef +97250d781815b1825be192714884630e9f564b9bd737d55b8ac79ab48d0fb3ca53bd21ead7b2fa82a05f24083f25645d +81e2d52333391ff2faab39611689a62d6ead77039e8703f4e012d53eea17a4d46f2e3342e44b6edbe73a542b461bda45 +89c9f9fd5f638156b018831c1bb70c91215f4a2f5a73c84b1208bdf6ad652a55df7213336ce12bd910a0e1a726474f95 +92bd02984d090ea7e2f3eb7d36d1e7b9d731b6b047e3cdd4af7cc4ee177415fea7a145205e484b366d84191f06af85c9 +85a86fc61d5d916ccbb219db52953e1495230aaaca63237e9165276405f07ad9644e253ae394f1ccdd231944e7143313 +a2ca5b3fbc9f3530f88c0ed7071ec3d89b272174c366eedb5d15d2b648c65d23c0faa4e92c776357e7c6883a0084d03c +ad171f5badcc99c8ffc9d8b707d792046f86cd0aa478e0e2fbb32fe095f96cd134ca548d1f7713057694dc6b26465315 +96bd15d57da9980870fbadc98c68db76824407dff2700c45b859bb70d98374d4a4ba99e3ed0b0c17f480fe08f16c6b8a +8300bac69ca088c3ff35749b437215e9e35a16393e9dc094f520516ba57a485def7029d30adfc72bca36eeb285c19301 +8a09e20be64f346668fcc7b07fee9c0ea8094c935cbf4f3a4cdbb613d4b936c1edb9256b7c884efb72393d97c0da00e1 +b1f85827ee6f041f93ab174d847a55710824fa131c9ade9561168c3962a25c617475ebc4105eba6e738961a754442bc8 +a131558f92e215969f41b6a57d1e2f424149eea531723821dd4cf8c54325cbe66b002de2c8287de6b41ab4b5c35f060a +81ba492b8956f73557f361a856c6c884ebb300d828287d5699e22e0cfa75c8e77a61616551d0be5178263898c461d6f7 +b2608f44d3c22fac8e13cb59e4ade8b9a98c4eb1ec0959ea400c97eb937ae3f66837e91917057148befade8389af2f6a +a6ff0323b5a18a4becb2cc6b376086b47cb2baffbfd1b0f2229ef2286fb4a34c5cd83a5faed5def7bbad519fcab8a856 +857d879cb9eff22501d883071382832730704bfcc5cd5b07cdce7ab8dc41c565a1eb0e7e4befce8e0e03a4975d3f11ef +a2879a20c0360c516811c490289be7dfbf7dbd41d2f172c9239f99e3d091957e0446854f9d0f753d90384a80feb6fa56 +83518624f33f19f87096a47d7b8e5f2d019b927e935a9021823fac6564c4f2328dcb172e25bb052748191e75ac682bd0 +817ec79132faa4e2950665712b2c503d7fb542aa57b7b36e324f77cda79f8b77bde12314e2df65c5b5296a6bca9bb0b4 +b2abf8fb7c3690816fa133d5b4aa509cd5a6e3257cfeb7513d1408b12371c4d58c44d123ac07360be0d0dd378e5bcf99 +a9fe1e4fb1574c1affac5560939face1af6657f5d6abce08d32fc9d98ef03186dbb2dbb9fd1decd6d8f4e4687afecce9 +89b2f41e51f33c3ca3e44b692e8a6681eb42a7f90b81c9e0a0bc538341df9e2039ee61f26d2ebe9e68df5ed1bccf8cdf +8b35aa7b1d9e2135b35a1d801f6c9f47c08a80e48603f3850b425f64e7fb9860d1adda04f92a1ba22d00dd0a26e781ca +960574978cadedbd4cd9f764bee92f94e08b7af65403de36b21bffc9424bcee845b3b028af2e9e545dd77cf1e69a6a7d +840aa0f34b5b6c39471f54d9e85f1eb946468c4fc01963a9027cd7864df01f73c2e864f1f07aeed4b1b1af72808dfa07 +834464a84a11200e3c60f816044c254a7d9baed64aed45a17325cef7fd62338e0a26da78d199d30ac3411714dc813223 +b4ac6fe2f5059546f4ad9a361426ead33237b6b9030b129bf0122085c85fe4ccb33cf90f5a7f23c5b708a5ac64b487f6 +a12aa9035464795f2a67f3eaba478d5ebc838ed9e997c7dfa241e1ed60a94b367d3f969ccf0ef02028c35215698b309f +ac8d926492ec2bb68c6d8aa9bce49085d3d266f3d5f1f924032b87c42b44e41da7c047eeb01e4618f9d0f123dcaa537d +a5142425825d813ed8ce1849d81aa40b11f1cc3daa89a9f798dd83065c74820b4da6122b3308f528b074531df66e1a5e +87ff55c9f5aae079e7bf24084dd9c6b3bc260727d942d79cbe8dc13341d98525b4ece3ed8169994b56a387642f09134a +88e680f148ef2ecdcfed33b61f9e0224790fddc9069bd6999e9bede1791e761637c0fd60b52990b6c93e6e5429e483ce +94bc20bf5aac6e9f1060d02eacd06c42aeac9a1c5635b15a83985dfb03938ddb4999a822e865635201489c7f75601b29 +849221cab7599f25f0b114df092bd5e8c2430503ae959bef1543a101de0790a78245db6a145e26f40b5f9bcf533219a3 +88b6f2c2e7a7954fad11009d839ce50780921f80292320868d481e38d26aecd80fa607e82219a99532d88cf33b39f562 +b0d82947dc23c0b88b86c321b582c15decdb825ed909a731b42d46bc895009515a3dc646c98dbec7d71b0722df82392e +a2cfb9f7c1a76c8073363c1c3bebe5dc29fa76533caea41046c51ea9bbdc693a121b957cd96be5b6da18704d1865cff7 +8f0ffab9a83355a22683a9d998d1c1089449eb308711eaad4265f05927ec6d0d1ca39217082a0b372e02234e78dbaaad +ab024661e2b2937ad374c8cf2e3669f1dc55558a3a881e9ec4d461f27e0fa92e2bc88230f038bfb051cf2145ca747a07 +b98d9b9ec9eefa56d38cca959ce1aee7b6d4b41a8dbbd34b3f50c0a5f97f84ed2502ded1ce8cdb5895872360d4ba6d61 +851244158b3184a62d2c98d148e2b1102cf0d5500906bbc2deda95acc5e3bc4b4a3344febbb31ce05a56dfee86a74913 +860d9e2cb886bd3620b5d7499d14b415532482569bd45fd76e3e8052d78a73ae4b2b41f139f9cfb136564108cd93c0f3 +8305a052a0fb2bcd41f3aca075c5f7f233bd8f861451d03f3a6e6e31f7d08dd89fe1eb4dd7b238a78b12ddceaad9768c +adb703e4778c7e14fb83541ab00b5fc344108243ec6827c5d9b302ee68321aa569da1718424e6a57979ab7536d5eb43b +b1a754b87b9e21aeb86217ec5b4fadb7535344567f1bd15e88ec12a833fed68e26bfbe03b7709ce24ba6c925ea0a0e07 +8c1e2f6bf820e1653f3b8213e9d959d8649196223c2aab57b7ebda094f4919f88d883bcc6a0cd0be335f26f5a2a9c962 +a082deb9865fe8668e91db0e4fd7fb50fb3fdae3e7bf1217ce0aa6f286a624624cf936d762bb2b6c3fead6826694f846 +a10540ca05fbcccdd0a2a66aabab3b36e9bb525794cbae68bc3dace6116f58942218e9d5e9af10d67b5f6fb6c774fdd4 +b81d22c4ab0ccaf447cc5fc2ff3bd21746617e6773bf43257c0d80331be2e8437b88c9c45309ee46402b38d3d4911caf +84c7c6e924713cab3b149f641dabf63ad5abbc17c1d8ee7802a6630507aa1137f7e034ba1d12ec13f1e31efbab79bf13 +8773b9d236e5fcfa8c32e471b555264692006bf9a869a3c327aed33da22dfbf5780ecea7158904d4d6ac4acfe9789388 +a4c2c1bb7290eb7af2013f7dde78282148593f066b09faf42e61a3fcf81297caa5a00fdbf6b93609c8c5782a0f25341a +a7bfa6e3f273da3dcfac7cb9906bbe9fa4fc2872b184d79813ee273e6cc4d7f37f46164362707a1976f5b6a2c5d7ed1a +8b71502019e4263fcda354a0fd10aaa7da47f4abb7a0c715c7b017e9eea14f2b64009b29b467394668c7ca995adedf82 +ad7460fba7deccc3f9a7d204233de47ce30ffa55e1e164975cdf06480a6108720bc397b93ca8c959df77d44a1e1f05f4 +a5b8df96ccb7b078a3918e74b1b10da21df982538d2c9313f5129b2797c8a6db9ff8707241ff72d3e9d5983397321736 +aa6cfa6386660c01879656da6c4e72497690708bae6c5cd1d088f443cb5bbbe75561d6eec256a72b9728377eb83ef973 +b9699ce7c5c878e44114ab7a598646c6c7616b8e08a9ef8ec291189ef9945c1a538d2abf1ce3b0da0f8eecb303b81b43 +b8d0fd1d278f53c455de92ec4357885fc6648dc5f276930263da7dc885b4a9628a2113e28b66b1e64fd08189427c614f +84ad8d262f6ef5d93e82ff6f4af995148eedf6d8e079124daee9b99f506e2968922eac2c7d4aea741fceb7733f20b2d2 +ab5e30ab54641e3a44450118b8235554e0fcfffdfbe1430ceb3f7ef33325725741995fbbbb0c16f0875aef0f1e0c98ec +80e2cf8bf386ebda46045852751611f2af80eca2e910d9ec5f6e2c7376611534604ceafa639272b3d503b02bd66525a6 +aaac69af8fbb87da1c1b7c1b9e59942887ae839a91f0c1d191c40fe8163d7f1dbe984e4fd33619c73e63abfa7058f1e3 +a6194224ad838ab86e84dc80e9b8abb121ae6c3c7fddc476463d81f14168131e429a9757e18219b3896a667edda2c751 +b68f36aa57aedc7d65752b74761e49127afa65466005a42556230dd608ecc8f5efdb2ce90bb445a8466e1fc780eea8c3 +886c3fa235d6977822846b3d6eccb77f1e2cd8ba3dc04780666cf070cae208b7513dc4525d19a3fb6385cb55f5048e2a +a9801273ef850b99eb28f3dee84ba4c4017c95398730c447efe8c1146b0719f252709d3397ce60509e05da74ed0f373f +a58c2a5dd13e08ffa26a6c5e5eb18bd8f761ab64a711e928e6101512401ef2b1c41f67ba6d0823e16e89395d6b03ebb7 +91318b564ec8b2d8c347ca827d4d3a060272aec585e1acd693b2bafa750565c72fec6a52c73bb3ae964fdaa479700532 +a058db5d76f329c7e6873e80c7b6a088974522390ccaf171896066f0476742fd87a12fe9606c20d80920786a88d42cec +9838e07f9ed8b3fbca701be0ef32a3f90752bbe325aca4eaea5150d99eb2243332745c9e544fd1bb17e7e917202edab9 +85a9ae7dd354f36e73baa5ecf8465d03f0c53b24caf510036b3e796e4764a2bc17f0373013af5b9f1b8973226eb58cd1 +896a4ff4508d069a7da6ef7bed66e1080991daee8b227f3c959b4f47feaf75fd1b9e03d0917b247c2db11e105395d685 +a36d9a6a037bf498dfc0e535f2034e6cd433c7b52e520469811eb2e9f04499a6ce40257d2905300df7d81f38d1bba075 +97aac3c5492aca879b4c06db1834b30b8850a244d29296046a84c637d9580c8521ab4752ef814c96f255a139660d7639 +8552bf592a84ab4b356d01643c90347377ebf1f2b38a8c2e55a3f34537b8c7dcbd62e6776d6c2114f2bc2d4344d1567c +84474ad163db8e590943ccd1dc50b4f444beb8275919b33f53d42cba89831e9d42ce2de52b26f4412e2a0676ce913277 +900799dfaf5eafeb297c7b4f892438bf2a65ce04034d66f8e5cc3836e4eaffe782fba4f4455a0fcab49102a240d1780e +817176415e35ad4a204b9fd5771bae6cc270f6ff050996cec89efbe461b2940ae5dd3c6c7d7e31b1da5285b207efed27 +965e5791c927d47569bc54ec9b4c5305788aecd87a26e402aabeaeccc03480df46f0586ca2e2a9918885cd03332af166 +b96d9ada4b5a04a94807d71726bd557de94fbd44042d7dba40560eebe8658d1da49eba54499360619f3b2c38e8b5ed6a +a07b6d641a43e02e7868f30db4dd5069a2f221b4f122ce9b11eac04abadc4f25f3207f1d2d86c7935b1a3d9992ea9814 +8250d4d8ccac846a4b1a9fa392d9279b5bf2283c8b95d8164c3c0d199fec8849eab85755f2a2a99d584a0407742e3200 +8324cf49f56fc14162f9a9ebda1ebda0388d09d8688f1938aef7dbf9505fc119069efc552f68cc7cd9213f96fda2c6de +a98e6f1e85268dccbe3bf4e92c9f455c58dcb53de1dba3b78589adf2e50e79f8e245f956e0d098eb46f5d3746826c6dd +b103ec12f266b4153d67b54d8fc079357ee342cbe5008adc3e0689a7f788534c4601e60e939731f49e4a1e24fd589f82 +b2d7681e866420413cc98eae67614d383943e3762d5742cb3c57e26157633c20880eea1209feaf68402d5d33dd699708 +99fed0ae4112ec9ed74baac70d202a885aa51cb555a3886b49016744dd4017640dd5dd564998c4d842a9f38f3e004e68 +95c35401314467219c8bfb1ccd1f1eae6ef4fa9e48fbea14f70d5315e67b16c46cd03554471840e4a5030b077d2a3856 +8d029380e0c294400d6b8673a23aed43697cb6460fc1bcf217aca3b47cf240886644ed09521d6a05f6abf56f99722d84 +8ef54d1dc0b84575d3a01ecba8a249739edfd25513714dd4d1941fbde99dbbc392f7eb9fb96690d7052609af23aa57f7 +b8ad2b7af4812417aa8de8f33a26547f84bb84f39501d4b7c484cc8bb54c7e166c849b95240fbe459a4719a6e3bf1651 +9858545de898721d19930d8b360cacc5ce262c8e004867a050f849f7a2f2aba968c28d51f24a9af56aaba23a9ded4349 +94ea5043b70df1db63f9b66b4f9d8082776f721b559f27d37b45e0a84faf47f948d7c4532dfd854a4bac49fb2ec8e69e +a2fd88d7b15e3c2778f6c74470d0f9e1a1f979a4d58bd205361eacadab9973d585a6508e685e640b272d6f8a448eae05 +88defd6bccd55db8ca84e3c8d0fc55a3456b41788f1e209d0aec19c9c70febebf3ae32cacaa1dbbf796d7ddea4b17995 +88b8cde2449d5ee7de2ee2f32e845d27e171a51ef64f1d3d8a5fd7dbb9f898ea70eb7f6410cddfd7b7ae70ea8073cc2e +8e044fff6ec557824866ac76301b6d93ed19b7177aa6baa95046330f5d69b572b59200e3653cf2f2b559455e782e8960 +b5446b4d6741c824885790d2d26258729dc0ba2f469c85a47d38886d933b785a4f38a951d37f3ef4bd5091c03fa3a071 +956c8afa8056e9a71ab2e8be5241ddbb3a8b3cff2110cb0e7389493d9fa45e6c4b769ebef540a952db6dcd8bd55baf64 +925950cae25615246e29d594ebf34fa7d52f78a9867338648158f2131e6eb4dc17e18f9db8a5fdd76d017b3a9798b3a7 +a17ea4b43211ba990270c21562690b3ef154a46c3d669c4674c80bd424cdfa95d8850c8e882b8d06504f929cba3d93af +b315ec723973a138508afc387ef651fd8a8804f93975fc36c2eeb796a304eeb1508518d8703e666a74d14318253f526f +a995742d7433b3f230e622de23cb2d81cac76de54831491cc29768eb4a56da60a5cbd573e1da81fddc359b489a98f85c +adb2e89f0d15294d7118fc06d4fdbd9c51d3ecbcc23c69797e5b8197eea0d6cd1240910cf22fcab4ef1e2dc2dd99da91 +b5ec9f9fcd0b5d176b643df989bb4c4c1c167112373d662fb414875662d1a93160dc0b5cdf540e8a30e5fcbe6cfbbd49 +b1291b53f90aed275df8b540c74a1f9c6f582e16c5df9f5393a453a3e95624ab7552e93d6e2999784e164046e92ef219 +8bc7b7b1a584a12d5ae63d0bbe4dc1b63c9df9c89bdd1095ff4b8e7c822bf8c1994c92310a3644033c7c9689f4b7d2b0 +ad7fc45506a10ca48f991714ecc055cea376c0cbe667f3b40ee8dad8446218835439ae59bccc474cf47b053748ceba6d +b134756828a5f5725c0b95109e09ca450e3834b127163a0aeeb544e63cc0cdcdf66f8ed98c331c7c98758f46af369a84 +94535bf1636be0974b112fcec480ed8eafc529933f3065c40e417e608e43a392206cfde8bb5a87b720263446c90de663 +a4df4f6efbc3701000fb072e5cbed2754b9ef5618386c51ff12f95d281d1b700fea81fc1365f4afc66a7c83bd0228fbf +b0336b3552b721087c7e2194976a9119aee13ebed9f1c3c494353707fffde52d004a712965f460062ec9443620716302 +99a39d1d1ee4283b75fa8c1fa42b6a3836b734be48bdd48050f9b05e48db6354fef509623c6ec8d447d630a9b3352b77 +8e3dc3583d40956f9e784e8bbd0b5e65671d2ff2a7c387b20fcb7da9b969f2d122aaf7f054d450dc611737604548c03a +b5068ec5b7bcb5d8583d51cb25345990f50d1f7b82fe535a6a6b17756355885047916f466ea3ab09eef5516bbf2dda90 +a8284ec1eb1d21e693f31a6c074199ee85d8a8da2167bffab5fe240defa2773971c8437e358a18f7e58d1e2954f57f6f +aa7415639d29081acbaac3e9c6b059d68e8702db3f430b86bb6e220d476fa74841c875e9d471c8a5423c58b6fee3cb54 +8afcfe6f65fa6e07c2cb3e1756c0ef2c589830be96edd50c3c248e3b17f51a4b08ba92ef7eed7991d81667ddfbf2bf7f +83b9c8dec8ca8f9b85f0e36c08c5523cfeafb15a544398e6f93b48b5fc4b15a0bd05c0f176a9c2469664acab8dffb0a8 +82a128a89ea46b9debe5c903b950c0ab30cd7570b979ca911500b5c2cca5c4ee6b2c2fa414b5f28e367f4671ffce60f4 +b79fd0ccd2629a361cd6f9307c02ecd4d1f07e4ee03ce4b542997e055b07a026cbc0ba05fe3da309efc58db2e401a8fe +b190751141093823b4b5324cc26c4f3258552f7893241201f2fca1ae9b1a1d4d4964a9abdde8642cf308ded61ce5ef09 +935fd48b95aa6f9eada0cf9a25a573f0ffe039888b3410788c41d173747bf384c0ec40371bb4383ddcc7d9f2db3d386b +b9affe100d878491ff345636ffd874ce1f27852a92417694afce4163e6a80c78b2f28d78102fd06c3283ef273ad37642 +a877670276d49ec1d16c9f1671e43ade11c0c1a1413755f6b92be9ad56bc283e4bd2ad860367c675d5b32ff567301fc4 +8c660d16464878590761bd1990fd0fc30766e7e49e97b82ec24346937856f43990e45aa8ad37283cb83fa16080d4a818 +ae1412087da5a88f3ccc45b1483096aeb4dcf4f519ff3dbe613f63712f484bdd8b2c98a152a9db54cf1a239ae808f075 +ad83cead97a9c3d26a141604268f8a627a100c3db7e5eefaf55a1787ddc1dd5ffc7544e4947784cb73b90d1729003c8f +97c3140ce435512a509e6ff3150da385fdf9e0883a5dc7cb83d616ec8d0a0014e4e0fa57a4d12c7997cd84e07d49a303 +a353773ff68f1615454555bf658eabdcca40a9c7bced8537ea6fa8d54764fd1f032889e910d2a2a342835513352e2d2e +89e8df0c17a36ffe08149c2ef8b27306d04cdf437135aaeba697abc65e3c8e91bcf1817919a8a826acdbbe7dce79a18a +9928c2da15ac6cb20b15859c22508cfcd452c5643cd22eb84abf5f0a1a694fdefcd8fc329c9b40babc52630743d6b65a +99d837b556f8d13108eef6c26333a183f59383b39958dd807b10590c3d37f62ade6c4a320ca2e70567e0218b0ad5807d +9272da080e4aa18720b634640b01bf1fe506c7c8a89dee8759a53e2ca5cdbbd4a4f3aca54924c46b935362cf1eca066e +b4d39752c882de1c1daf3854202c1d58c2bcf35c882006eb640fe54a97be2655281cdb91c30d1a41c698617c2cf64b01 +8bf827f4a7d47e07374d338a3d8b5c2cc3183015b5a474b64b6086fcf0cdcf4852046c9e34d7917d69caa65a9f80346c +901bffc7db9c9416e06f593a76d14f6d9e5dea1c5f9557bd8c93b9e70aa4782bab3518775c2a5b285739323579f7cf0a +af7e204388568627ca23e517bcf95112ca8afd4c6056b7f2c77c4da4b838c48791191565fd38398587761c8047d11c47 +ab2576b5366e6bd88b347703f9549da7947520d4e9de95d7e49966d98249406ed9270fe69347c7752dad47e42c4ea2f4 +b12e3b228b761dedd99d02928105494ded6d4fea3026d73d65ebffa2e85e2cd75b6d091135d418dd95ac102c22b5ee31 +a20b4a752685d5e31ee7e2353c8a1b9a5265f12bb775004d282a3ecd9deda44831bac1ac5151646428b66909b2a423f5 +91a1d4bc0062a86cc6786a96fd3eb4436d8a4a187b7cbba02190d1cd6ed3c3797d9ae7d6ddc413f1c94a21f62bd04ef5 +977f18da1a5df5cfdd0276f583cfba2b2a0fc6139520664e20068f8dfdde33e29d179abfd722f142448f4677aa47be6c +abc3ece90f0f7b1d80fd917de27ab0d88cca584ef959da520825e54cb5a71336b15f8b348532d08d47a6fa600527ef25 +888d36a2c7cc13a1c1aa338a183a74a1f57713e76cb825f9837f43279ce4741999b76a16928147537bcc20f2e0195b0f +af3f5dfdc2dcfe19de893f385f39f550cb1dab67c2e97f1d5fa735e5ec96d6680066803e8a0eb010dd4399f654195513 +a0fb4e08ff56530a940a86c28830956eb6dec2f020f7faaea7566faf0a4fafe0cffe01480e87763ec22f201be51a6451 +92343c5b107910b203c64a79c93d354f7ee5b7d1e62e56732386776e275285561cb887019cc00d3fdbe3b5d54460bec1 +acfe7df83c4624188a1011ad88c1e1490d31a8a8c8016b40aebcdd7590d9c0793e80d2d7ce6a7048876621c252a06a5e +a7da001dc1e33e0e129c192d469d2bd6e5d2982eb38f3ba78bae0670690c8e70f40e8114a57bd0718c870ca5dd25b648 +a903de5ff97dc83628290d781e206ef9d7c6b6d00cadc5bacffb31dc8935623ab96ade616413cb196a50f533e63641d6 +8f9658d42ad14a60bbf7263f6bd516cfee6b37b91a8f53715d69f718a090ad92484061c2cef999816760a78552fae45b +8c15b72b3d5fcb9ffd377fd67d9dfbdd706593fba9629002639973db12aac987bd1db70250ded31c88e19efff612cdb8 +88a2a4034decd854fb557960194ff3404e239953818a8a891bf72a0b26a8e570a65c4a630884de991ae7452b3234f31a +a09cae5c4c190537bf1dd75bd7bce56f7b799762af865bb9d1ee970f6a133c27cce0dd0f14a0e0516ceac41054e6998f +9760ebb1b40f9a97530c3b940d4ef772a225e5b63bf18283f8e302b9436c5209f6294980fd37058060e429fb7fdc3a56 +adaa9400eb86d857dc591b25dbe3bc8f207b69e77b03cb5ee01f7e4b006b5c8f6ba2b51b5a45687479885708509363de +949efe6b00b3248846747a9ad4a934d6e4255994c2b540a59fbbde395fe96d69bb67908441cfadd8c8bbb561fe52da03 +a19a45504b6b1dc3a0fe0e6a1384734a3dcd5a7cb8fb59eb70e49426c4fc44946547443d558e5719a04884ab3a2811ca +8934c9ee21e8d1435426fd0f64232a0670a7946ec524c054cd4f2cc8b1be9f89cc11002ca8aebae646a2050d91716b10 +b1150ff8ffb34ffdcf7d603348c0aed61e5f90ee0a1b814079fc2a41325c75f2f9ee81542797ede3f947884266a772e0 +86ce8cc7c1f92af68de2bca96ccb732f9b3374dad6657dfd523a95e8a931a0af2a80df74098514a06174406a40c16ba5 +90faabb9ace9e13fd9584932846ab28a618f50958d2ce0d50310a50c3bc6b0da4338288e06e5fcbaa499f24a42c000d5 +af4a935c2d8df73332a16dc6da490075cf93365bd0e53e2374ef397514c30c250bcac569b6df443985cf3720a4534889 +b7f948ee90f394789eb0644d9f5ad0b700c8e44e5e9ed0e49da4cc18483676d25740710b1c15a557965da635f425b62e +a917913091245beed6a997ff7043ecf60c4d655c4db0b1ef1c704fd9b0e1ea1335ce8b9f45d6e120f81805ce31555e30 +a48099da8406399bfb1ba834f6f7d864111d0036969a5cb64089947a63dd9467d3857b605e9f57f5ad5f4ec915088d9b +9784c3f9be42eed354542b1446d734521f8e3f01cd9d495ae98f2e4a3a16767fe2ad909e0def5d9a6267f3fc6a172cd2 +8d9afaa323847a3226ad7d7b60d87322ffcda2e4a8df89f58a076f7972d896588de685a2e155e243bcf9456b0a0d6d1f +994413faf0b843f4ec1842c706c45ea5f24351c68674a27887bc8b182eda756856e507a4e8bbfd937e2c4c581b629ee6 +b3e72d9d1ddaa00c7d22f25462d6e9f2faf55e30d138dce8bb1517eb0b67132db758668aac26164fd934d732633bdea5 +8e95875e338f714e9e293df104f0ad66833bbd7a49d53a4f7f5fd5b18a66a61aa0a0f65cc31d55e0c075e0d3e412cb90 +b980091862b1a9f9334b428eae14bbf1cecb4849e3a5809773b0d071d609727270f6ad97f329eca896c178ce65883db9 +915d7ae5ae780bdba27ba51a9788a8852a15355b569581d1f18f0d94bcdfed2c1ed5a4f58e049e9825cda11f92b2c2d4 +83e581058edf9259d0b06128282327cacbb6afc939578223cbf93544599f799a8dce1fb21d52464f990a877086f42506 +803612a38b6f6efb97941997e101ac1878e192456f8fbddb3359aa7f3023434ed8fa92e60ec8e7b4473b1948850e4311 +864a1bf4ac046161617dde282e44ab3cc1843da01a09ca58aa00ed00eaea9351a07a9ec16d910819e7dcc28b8d2c8ada +922eb142845975d5f6f7dcfee6cac8c299b3730400e6bf82cc0bdd9888de21de9d9f1530640f702c003e1ed63b140cc7 +a7db03c5be647dce1385ebc02f4825a654447fa8c4c8d4b22e635dbdd2b3ccdf219384e49a80cfb1e9e6182b6e4227ed +a167289ff0f0967bbab6479e4a8a6f508b001bbe0d16cad36ab4c105ad44f3f180e39a6694e6cd53bc300fe64dac1e8c +b7766431f6379ce62cba22ab938cdbb1b0c7903dfb43980a417e0ee96c10b86b447241e9dd4722fa716283061b847fb3 +90cda18c5d66f5945c07c8c7dc453dee1370217ccb851bbea32578599aa669b4dd245dd8a9711b27c5df918eadf9746c +ac690cd2af39932874385fbf73c22b5d0162f371c2d818ec8a83761e0a57d2db2fca1d757343e141e1a0348016d5fc44 +abac820f170ae9daa820661f32a603ed81013c6130d1ca1659137d94835e1546c39a2be898b187108662cdcbb99d24fe +b2ea5a5950096772f2b210d9f562f1a4cfacc021c2e3801ac3a935f2120d537471307d27b13d538dcbf877a35ff79a2e +ad94af4d0699cd49ba8ca3f15945bd09f3f7d20c3aa282a3113cdf89f943d7793e59468386b067e3c1d53425dfe84db4 +83788367ec97cc4bbc18241cbed465b19baa76fab51759355d5618067009298c79d0a62a22e2a1e6dc63c7b90f21a4a5 +a3e142d879096d90b1e0a778e726351fa71996466c39ee58a964e6b5a29855123d4a8af47e159027e8e6be0ca93d9955 +860831f8d3edaabd41be5d4d79c94921625252aaec806251fb508e364e39fde8808d38b10d557e487603a1b274c9bc3a +88da39f334bd656a73c414ec17dda532059183664bbbac44eb4686c2601629ef8ff9da992c337a842e3885b684dd0032 +b50addbdf7164e8303f33de5ce854d6f023d39c1c1984b214d9e5fb6f6001cd5bdda816f048a438ff3d696872672f805 +999e58c4c69a912b84561cb09610e415b43832beeb95897eca8c403ef4754f4277754d492eef3673afd4362f50060fc9 +b88ea0f60f8119c5a1fd9294796d387472dfad22442b29659713d1d88e7d854cb7cf5c9ef773627781188626bb2fb573 +a068b3844e9dbcf74b54fd55904d56af754d8ce4c619fead7a07f9bfb9d02118db7c512ccec2489d2a84374ec1d1fb6d +871dee023768636003c799e6f6fd8d31315a4c0da7286345cd64264a016693b3485e0732be1bbd34dd5fa04dfa58a983 +8021e8f508680df12e4a5a1bd49f2d7142df65158b0a7198ffa83abd16053a542fb93ffc33e5279020ba8c6a26feacf2 +b5d3cd64df5bc965228b0bd4ce9e5797c409f7b64a172ba165e44a8e4b38e3d5fabc3e0b9a19afbfe427f887c40a315d +a54fdebbb594bafcefb1a03697711e0091c072e1cc24fb441fefd4e0a0518675a1d7b0966cb8294051d7ec0ac175d0cd +93922202337f72969d6d6e14a29c9c75e0420dfba712029941d1504b9f6f9761d706cbc0652cd09a1aa5d22aec766af1 +9711ebf1c7c7426190d4afd5dd03b014a456bbd9d90ed101623866a280550df26a629dde400c03ee3699f7d827dc0bb9 +b4d686d8bc5c1e822a50124c1cc23c6bc3a1577a3d0b8d4b70d1797418aaa763283c09e8a0d31ae6d4e6115f39e713c4 +a533ea2ac683e4ba07e320501a5d82a1cfc4fa1d65451000c3043f0fdac0a765cc1125d6cc14fe69975f3b346be0fdde +94ee563134fe233a4a48cf1380df55ead2a8ec3bf58313c208659003fb615a71477e5c994dc4dcfb2a8c6f2d0cb27594 +93e97d3f3f70664d0925be7aee3a358e95ae7da394220928ae48da7251e287a6dfbd3e04003a31fab771c874328ae005 +b57440d34615e2e7b1f676f2a8e379e1d961209fe00a0cf6798f42b7c28dbd03172fce689305e5b83e54424bc3f4a47c +97644084c6f7b4162bc098bed781dd3af6e49e7661db510975528f1dea8154f3d87e979bcae90c3df3a7752eb0752889 +a923b27b225b2a6dd5bdc2e3d295b101cac5b629a86c483577e073cea1c7d942c457d7ff66b42fcf33e26c510b180bc2 +86698d3b3873ed3f8ab3269556f03ac8d53c6e2c47e5174ec5d14b3ed5c939750245441c00e2e9bb4d6f604179f255ef +87946826d3aa6c7d53435c78005509b178fdb9befc191c107aee0b48fbe4c88a54cebf1aae08c32c3df103c678bad0ca +860864896c32b5d4cb075176f4755ea87fea6b9cb541c255a83d56c0a4092f92396a3e2b357c71833979b23508865457 +b78fa75d687349e28b4ddfe9e2d32bb6a3be13220b8f3ff1ded712088bd0643da9b72778bcca9e3b103b80097f48bdd0 +8a188b940446598d1f0e8c6d81d3cada34c4c1ae0118ec7e0eacc70d1bced28ae34b99667d5793d9d315a414601c3b22 +842ac6f7dc14191ab6dddffcbc7cb9effba42700a77584aa6a8e17a855cd444c5d138f9d61bf55f43c6ffbcc83f92bc9 +b6742902c3d145a6af9738c01cf9880dd05c85f0d0ef7dbe93c06fdd6493333d218339ebc2a02be1895436a2f734a866 +98bf18488483c627b7181b049d3e6f849fce1f15794de59dcde6e5a9b0d76fd484a46e48822a6a93001d3aa12f48bc6d +8769cac10bda8c53a1c19419ef073a5998f73dcf2ba1b849561615a17cbc0a49bfe3eb4ff8801dd36a22fa34b9a3a7e2 +b45c084d58028fdfae792210fcd183abc4ffddeb4cf52ebf3f8a50e4c4eec2a2758f1241b0920bebcb24b757c778577c +85c1216eec8e1fbc1af9b36b93c5d073a81d5fba86a6daae38748ec1573eacc6bef209e76c87a6efbd7a3f80e11d4c3c +b8007e34bb3f927ec06a050b51e633d7eb9e9a44715d5b39712e69c36177a03cd68391090cc3293098e54f6cf65f6caf +8e85527b27c9152b1ba3fdd532a76a79064ab097570508f233e09978761dfe3012d537411b47d0e4b65265eb32cea2ae +899779f3c31a20b76068ec8d59d97a64d2249588ddfd69dcbaac6bfaee8ce0ff3c5afc4e17c934ae7cd041b760eb555d +a5dac3d8f5fbef018509612e25d179f60d2a62451c76426bf546e9666fcdc73263d34aa6fa7e2bfd4c9947bbf5095eff +896900eeef9be2b2e755128e7b1c436af6fb3984f1e66c444bc15fcf3959013b4902c381f0eab1247f878a6ebd1f4ee0 +8cb17f4b0af2e9b2cbb56f46e6a5d6874ea0daf147aae77303020b4e592ddc92e0dd058def7da96258b3a68b223bf22d +a1b6d3f09a9fa7ecc021ab7c5396541895da6e9bf1f9a156c08fc6f2b815a57f18c337ccfe540b62d79e0d261facb2be +ae70888811434ef93da60aeee44f113510069fd21161e5bb787295492eb8df85103794663fc9305f04adcbcf11ff0c5e +a84bbc8624100acfae080ba8cfb48fd4d0229a60b62d070bd08fade709efc6914dc232d3f7bed76a59204f9252321aad +aea47d54652abd8ca213cfc623c8e30780f37b095b59ac4795252a29c2b6bc703a5203acff8831314478b8ee8771d4d7 +8dd438eb8be14935f759aa93021c2b24e1d588f7a162c42c90ec3a647b0ff857f60e24c0a8953eb7bb04e04be70f11ce +922b07b5469680a10e7532766e099896f4dc3d70c522d8add18f5f7765d4ddb840df109146607b51ceddd2189fa7b9c0 +83ef6ebd0ae6c569d580093e8b0b78daa964760556272d202d343e824c38eccb424262e5b7809d3c586f9e2e9c5c5f22 +97f98bd357db6e093e967fe180cf67ed09fa711580a5ad48f07cf095b2e8fabbe6319f97d1f15d62c0ec2227569d8dbf +a1953a4a22fe6c2beaf2a5e39666b0eb53018af6976e3a7aab5515550ff2efa89400605a43fb2c4ac1e51961dbd271d8 +a5cbd67f4c0bc98e20aa74c09e6f5fb6f42c08e59aaa477b4b4e61434c8884bc14f17cf11faecf46dc4b6c055affbad2 +87d96818f2c4f12fd7705cf4060a97bd28037c5ac0f0cc38f71189ec49361e438ce863e6617651977708094d5336d1da +85e7c2daae5fe59f8a1541c94df50402a671a17dbb8838113fa4b7aaff6114cf2bb5969410cf21e6a162857f2f7a83a8 +a19575083e1731bb04bb4a49414e97aaadb36d883aa993d1f6847db50007315444814740e67e10177a14e0e074fd4c7d +a00ebfb5bcc3a6da835078189038a1e56b7dab6be74332b5ff7440e53b0f9e1eb9973effecbbf37000021fcf50c7c1ff +8969d7943abd3b1375fdfc7d6124dde82b0f7193068ed6ec83bcf908734daf3487a6a30f7b322e54a4818ae5f86d91c0 +b959c8d210fa43af9b20d1fe0ea8c4921280eb4544ef6ea913309ff9d61c9327096707e84dc1662960519be8e7d080a4 +9011d8ac651c42e0cb03931a9e960f58e02524c6b666047525e3b9097e9f35fb2b4b278efcce2bd5ad463c6d7fd56694 +937e3b22ed0fcdbd9ea5a1b97b84bbe86b7f5b2de3866a930611112f2217f4ee7d9822c4ab1253823f77bceeae0c8e10 +828997e5d121f4c305e018a0a0ba338bd6a34a7b4dc3c5ceab098ee57490311c130e2c045b9238a83908d07098d9fc32 +8d114808eac0f2e1a942d80dad16756ec24f0276763cd6771acb6049472e05a9bb1d3bbd5957f092936b415d25c746b0 +a063c5c26267ae12887387cbebbe51fd31bc604630b3a6e8e177e71d4f26263be89112cd12d139dd4c39f55f0e496be0 +ab1e1582c8d67196d10f969eeb44e6e16214f1316aa4a2a821f65ba5834326da6cba04373eabfd3b3072e79e5c9717e6 +a17b1dbaa11d41457e71a9d45d032448091df7a006c1a7836557923ab1a8d7290ec92a7a02b7e2a29fcea8f8e374c096 +a1ed7198da3591771c7c6802a1d547cf4fcd055ca9010756d2a89a49a3581dfe9886e02ee08c4a2f00b2688d0600509a +af09aa60c0a185e19b3d99ffdc8c6196d8806169086c8ff577bf3801c8ab371e74165ba0f7329981e9252bfe965be617 +98c04cc8bb26ffce187fa0051d068977c8f09303a08a575175072744e0a5fb61191b1769f663a426c30d405515329986 +a542bf1c9c3262d488ea896f973d62923be982e572172e2461e0146190f2a531f62acd44a5e955a9f1e242b3e46d63ae +aef7b7f30efd50e4a66c87482386f39f095bff6108e68f74fd3bb92156c71c75757912b111060cdee46a6b3452eed657 +8afe1e0ccd00079702f16ab364a23bbbd3da1889d07c4f8cb04fd994bf9353216360dbd364492932bfe20b8b69ae8028 +9896c690999db3c08cd7b25efb1b912c3e0f976db98a3e830f086aef93222d06ce570a7b2babcd7c81d8f9955169669c +ac7bcab6a281468907ef1ea8a6c1cd624159c88839131bef6aa0c22f331fc87ec6128a2c2a333fb79df549e4587e1a12 +987935c08a30b099d19f96901315a2e60591baf898581c40bf5eddcda806ff24a4536e30ed1e6c0b128a83fc77b6e81d +a0a6945bbede3bb09a4a09ef27baa20619d3e15af5673b9350601bcebe952597c989870746cf75767ffb73b32c6c9c6f +b0f5590079f0a0302b08a0cc1b7a5f39cc6900c2a5cdc7baa333d8328a731b2df5dbb67e27a154d3c44ed1a795fc4adb +a7294bdeea210e528f277f3d50e89e6d79950494478998181ecb38de675020130256f2f2a075899170be964d478458b0 +8ab3041b895a631869b439d5599a66facba919226ca9b39d915f19d59f9fc82393ea781377e9bd3bcc5a310e41376914 +8da399b59151fd48b2579948bb82698e3c9804d70ec7d6f3cc7e82901f9f2de5ee850349a7d6f43e5e9ebd47bd78620f +80e8c32de83d1083916d768b11a982955614a345d26d85b457f2280ff6c52bb776958add7c1c8878f7d520d815b8e014 +81bbec7bd99d2917d2dcd8a288722fb33ad5a4bf5416fba8609fa215fb80e0f873535349e7dc287f892aa56eb9e39c4a +9665796fe04c8519206fba58496bc84a8b9113e7ea8e152b65f7f732e88beea271dc97b1ea420dbc8257cc4b18a77463 +a97e342aaaf693ddc87e02790278e4bb50117af4413cd703bdf3b7cad2d1facf31fde1303b43ab2e0265467474f97a8a +925549ebebed348886e37773b05cd8ad04906eca4536bfed951d1ee41b3d362ddc6e1a302c21ff3a2d1e70e95117922c +818fdf74d7903502101551bbf48d3c7819786b04b192d9e94362d2fcb85760d8b6f45165a5443aa5221bef400525ddb4 +a9d29de7e8fd31b59f4a087168d062a478b1329cd3c81c31e56de4fb40de7a5be9a5269ef0be452c487443a0b097dd50 +a85286ad573db4c9aa56221135da1e31d742e0f6ff01d6b159086d7258f78b08dad55ec8eb5c91ee9d3404b2eeb67e1e +92a79b37db5e777f9ebbebde24a95430a199e866e56597c7d0b0e7fb54c7b092c2f6cf61fb24470ddf250cf609898281 +8d79f5ca67ed67d52c82949af342a9fc60fb793c47c76d84b4863c550796fcae2dd59e285897c6fb96fe31cee1efa62c +8ad2e0bda03415ab86324992bb62dfa3612d2d003765bcad1468087c27971d08bdbae5252681f0115a184f4885d444e4 +a08815af979286538c31b4aa5ec805053790af1ca58a8c4341be51136d094a8a05e569d876a079033298ad355ccb7ca8 +b96c2978d0165d619d08281d295e90df78bc2375d0afbc3142ebff9c2cd4b0f0aa97a9a0e3740bc4dce0ff8a9fac8252 +b7752cd0e582f35ab0d0036ca9c0a9fe893a6ad325164d78d865a604a85d3d23729e0362553e8b8a3d51816beeaa30cf +99cef1fafc29e7adfe247c753c475ad4bda7a5f9558b79c86e8a65968ede67adb38dc30071925c9d66a13860027a6735 +b9f6c65af178c791b6137d71980651fb09cb5b42f268999c728c6e129985a9c7d77b3dc3b50751bd29ec9ee0b3111dfc +8d73ae61fff5be883a281782698075c5650083f00399992688738856d76d159803be0059fbd9dec48f4f0432f0590bbb +a8a4a2865226de9bbf19e12c7e75318439fa6cf1cbf344d5e79a8f363439d3bc5bcf4df91b54581e7866e46db04eaf0d +894582aeff222e145f092ba15c60d3207340c38f2c6792ee2ab4d82d50fb544ae366c2985cc2b6c2f970bcc5f4b46385 +956014ba2d20a056fd86cb8c7ceeab9a2c6f905dae24fc1c5278fa5b84335148ebdefec5dcde8eb9b084700724fc93d7 +af217fe2b654eff6d11a2a79fe0339a1d4cb3708b7be9f09d852158b5a44b4f9b04406d6d67c4f144fb6b69a41ae9d0f +a90752a784bc00df94d960e523f5596695d16a534fc806179e0f878fc0e82a91b25e758e91a165debd815dd1af5f1028 +a697606fb32979549ad822b31df8eaaf50de4ead984439a0a33e955937d326519bb9f62c8243ad37f764655f8d32cc80 +a3ad4a30922e45a3e665551e5611384f1c2d414f6fa806184b0c826af05f014dc872585e255543794ee41e43cdadd856 +b29c255843a82ea74a013bac6c36a694646e61e6b9cefc4c130e2ee261e3bb5da3e0fe3ee7e6fbb009deed0530bc1c82 +87e1cc7febefa829cf050aa2aea59385d1048f8617abba691f7ea9ef58eb90ad12eeb9c439af228b0e34897ba1cf1b47 +994d3222f89e9c8c154362190be7167c8c2662f0cfa9d50eb4d8175b255ff0de09dc548ee312fc8226963c8c16f43e8b +8f1a980be640820f2d1e953264ca4c30330878971669852be3d5d6b41c488be1628b935388bfa2bd4de484acb0fe661d +854d90d0721579c8c88e147a4aa83553c960617b18075f8224b975562dccb30b0e02e81fa9df7070f356a0eeffc3b14f +8e156da9d4330a03e32a25a2f0b861fd3ea5c719fa4f834119baab6e5fa5236a9baaf0d44147bf0841418900037f6eac +96586fc49e53a6799242ddf617000db5a0ad20c6cb1686af2102623d64a71aaddb8e468b15fa6d100d0384e448548db4 +b44d8d85c8df95d504f82d597f8c515866d4d4a326fa1b816dcc5bb0cc4ef1a52647aa5d2e84c62e194c01cae0885d21 +b75c43e676a7efd199f8b32ae31f176ec667e714df355e9eecee97246f72af5bef9c5b04c11e7e90fc37bb9163f957ec +a49835ac0565a79f6a9078cf0443c5be20561a68b448289589721fded55188583f1d301925a34eea647f90a6e66c6774 +b47c17ff6824a00b8f29df0adb7f06223208d062bd703b0f763c6eee4ae62d4217eef2da4f4dde33f0b469c2f2db9e42 +957cf039cea6f6d41e368e2bd0cf77315938a0738f15ed9ca342f0a28658b763659ac1d1a85ecb362f13de12b77bb582 +903a52f8d2439fa63f59e1e9aba864d87b0464ded63814474947112375236a6f84e8fa003cc4433c8208d80e05fbd1b0 +8afd524209ff08d1eb6312b078f7afeb8e1155af649e930ab711dedda226dc2db6b0354aab9652eea7f433f90015bf7b +a95c3c9277b11bc8fe191773bf567641be57c0549913b973fb18740ff9cd7b3f7ce198fa4dc1086b2b8a446012459193 +9455ce8163fce04aeff61e7808ef3aac4725e51404f0858fe5d39d7344f55dcc7871ca332aa5cb1a63a4399529e48907 +809fa35b6958f94e781f2c584438b33f5ed528a6b492d08960cf22ecf63ea3aa1e2d29bc879e17296e0a6cc495439cb6 +b0f50774de212dd33e5837f6b496556215c665437e657f674fc5117e5c07dadbd0d057e6ac4c42d50a8eb81edfebf315 +844c65e263891d0b2fea7db6934cc4b7fb6bee2c1d0b9ab4c47f2eb3e9c5d7197dad828d38c54139123740151420280b +b13c78c9efcbb3b28eb3fe0b971380b7d5151c80948a99cd93c78b4c3ab0e86df6226a64d91e0a2ea4a1c0a46bc0404e +90300a541decad460c348b8f4257f7a29687b2362ebee8d92fd03cc0e85b285ccb0ab1cb2ff5e29c5cc5295e351017cd +ac49b409ded770c6d74f6e70104c2cdc95b7b90609da0743c9923179e8e5201ead03becc0ab10d65b3d91a5be0d52371 +a257b815bd8289dfdfc21af218aaba12ccfd84ebf77642cc4cf744d9b0174ca0b0d7ab2a545c2a314fd5f63c140f41ab +a34778d8446e4d74d8fe33de64b2694ef1e50bc140e252af6eff3ce7b57acf8b6577a02ba94b74a8ae32e5113cf0a29b +ab9e935bcf0d8607e3d66f013d9bce7909962cb7a81174923db02dc89e485c2b1c33d6065bdc7bbbe0450b5c49fbe640 +94d2c5c5c309c9eac04be4636f61bc47fd9579b47aded57cc6c736fefb8dfd8f8a5de32210f7baf2052d04c0219d3b4b +b8dda9046ae265214086355101be3460421f7cd0ed01bde9c1621da510941d42bc93cd8060fd73f374fb1b0a5f38d45e +a6674649dab5f92ab9fa811d9da1d342cf89ff6eff13ad49f4d81de45438e81a384098d3ae5ccce4c67bda5dbe246d95 +8d619f7564677bacba29c346c4ef67c211f7a3a14c73433dd1a7692e16a7e2562f1d0532454af62fc04c2fd2bb1789b0 +a2b93d2fd4c707f5908f624a0fc889e20164d3c61850af9125f47a1719757a6ce6375aa1910eafa4c1e8b6e20c312775 +a07d5585447654d82817ef4d199984542328b238157976eb9a267f0bdb2229acc25aee510be68f65a312b68fdd9e0447 +8ef55cf95e2b24d8ec88e4136399a7763bd1b73d5e90ea45e9845123e9d39a625cc336e9b67988374b8ebcbc75f2ed21 +b62c1fc32e27c767c461411b02fe9aa44a86586e1427406f4ef0b346d077db91952abce79318b382ec75b7be23058cac +b252900345f5fa15a4b77fb6af6a2d04db16e878b7bd98005333f7f6e3c8e6e46cf38fc5d1b2bc399c5c2ff4af730dc6 +a4ab5ac0cc15d3d17b1747c6e3133d586870eae0a0d9c8fa7fd990ebd4fbb62e9090557ca2792a6bc6271856aa3c9a05 +8e706b3f2e902faee10b22742c6c33bea6f670a8937c243db96885143c1db5c979e33ab73a38359b52b8d668ccd092a9 +8a6792190ee6c959d79f60c22980ca140c638d88d75660adaf9bcbe6dc4692ab5f01e0c460170f09f74d5e582e85ff1f +97ffeedfc94c98ec85ea937e064d7b290a326838e62cebd407facd1ab4f08d9c0c109d79af7cb6170fccfa6c8243c127 +b79970b67c09453614ffd83a0c923c17f857c6ce3c87a356298f8351cab0def7ed83efd4f6638f48df67e07bef4ad9d8 +b90f1931c7cf1822cc0a97401119910cdfd0482daf09a4d7612e4e05046295cfb4cc50d5214b31676bb1a1c9d15f9c7f +922921ad813c01fb5d12fa7fb7ed8e0b0abbf7b19affa190b36013c55b88fe3c7df0ae663c970eec7725ba37b95a7cb7 +a124f33e7f28feabb4089a063a08d52b7395d24eecd06857a720439dd9414b7073bb86fbd0b04e7bfac62d3dc0fdb2f2 +b252fe50bc6677c004550f240fe670974a33ffe7191ed7675da6ac36c780c2f8d02be7da5d92cbe2d0ce90147847f8b1 +ae5f8c9c56070f919f3df2d2284348fa4b2e39881f7bc42c9b2f5b7cb1ebeef8ecac000f37329bbe04cc1680cefc7f4e +b432a4575caf7337f11eecfcbd34a6705d0f82c216301725ceae2b3c9df20fa53d1ebef65513e305013d1e0c2df522b6 +b7c016fbbc4614cdbb12db1c9ac41f9a45d5e5ce82594d568a30cd2c66c3cc9d91a2c959697b67c582a0913de661505d +8f6f3e5e0347dddc1b2a34ec0dbbbb7cafbf976f19c9c902efb5c1427d1bbd4b71abd9f3fba20dda75c35a39393c989f +b0042a1d33a1ee9fdf3fad2299b8d70c4f1862d8393b5ebe3ac2189a2c5a58bb826128cd7a39b70d524a6dd976097e26 +85297c4e8ae8d9b44c3fe51aa926c77d55db766c2a9f91b659040de36e34c9a4fc6f44380f8d61704498f6fd52395a49 +8c61a988b6a00fe5a277450f30bf6daa932e42a2eae844568e3babf8815e09311f3c352dae6eb2d57a98d16b7beb2d22 +990be28aaecd932e7edb2a97b9be2789a3905cb88737b1c79881302585801c69a3dd5fb230808b39db1352fc06e0b4a8 +82fd14bdb335aa46f022dfe0ed4d631911e6b6f5eefb10d11e9e2e02a7df55012ed8162249d10b58eb76ced5a7b06cda +ac39cb058df764e161db9c39b185f09aa210bddbd66f681f1697ddbe6b305735612d5dd321d3ffbb4876771bdb321e2f +858a3f7e57ccb81387caf8e89f9b6039e9aadeab06886d8688fe6427151a59ab2e77e85ba850c67d099965426c97779a +b57fb9ea623cec432946819937c6bded0b5d03c8c67b52b44a4b67d34adfb055e6cabca67a48e4d859b4be45162c5083 +b84d2990b563d6d7fe1f4c1894989db25b81745090b94b1fe2ef708ac3b2110ef93d647820b2a51fcf78e3f00fef5412 +817d85b9f5e1521733d2b1fa6d4f4957ac445dc803f97fc495e20b819b14e651332f9e0573d684b854fd47824c53f0e8 +b09e18e97e93a8523101af594422fb71afc5b8826002314269016fcc1b44002d91bcb7c90d923d460f0cc03bddfe9af1 +b867cbede82102de7cf6cd0dae68506869576eaa66c3fc806e73585310602682fc912dc37adf5ff6f0f34a07831735b1 +b1126255798368b692f2796a3470ed16e5ffdee2d8c9e0f7ee3d2e92950c3e6365c32895171c3494aff2a6d6356f7e25 +b05f0a0996dec16335c770a5df3f0b08e20020c838c2caaa1d3a4a2490ede98552f5de349de2ce6e4c4a839731d80919 +98c512bb91c8fa191120ddf5d63c88076581cf41e15eec3c168822f12b3dd0ce4d6df74a7e3093d3e35cad1cb3135421 +84ce38fd97f7f90012c2c1e59a67bf9f465a7ccfb6f308bdd0446cc82b8a26ff7c30e5c7cc375011718cad1b31adaa9f +93139db52c9fb96dee97a0825f21e34c5d6d36838e1e42f4d12d01eacbe94426c85a811fe16ca78e89e08f1c27383d28 +81454037b1e7a1765f67e4288b8742eebf6d864d9b0f508ab44fa3243168ce0ed30cb5f33dfcdb995cd2c2710ff97a6d +828deb2a26efb2ff1842f735e2cc27162360f619b6e3e27a85bedf384912d4726bb2759a3016937973092ece1bf90540 +87e5a7d4e7bd301078f625d9a99b99e6e8e1207c9f8a679f8ebbbfb467bfa0b5f7ef4a4d577c7d2670efa88221153012 +b9dc9d0ea48deee201e34379447bec789c8924aecd030eeb93db159af77eff230976ef60ea9f4b4a9e9e95c1f9f4284e +aa6528268d46bf0627d87d58e243d3ac34b863513c725908a2617e4c6a46ccb1d8c8334bd6dd0eea7ffebec44259dae5 +8d26c9ce07293f6a32a664d31e6df9a7ace47e6c38001635918efd9872aceab62de7757b13b783d422eb67bd28ce7bbb +b0d3ca88d9829a7459b89b0dcbdb8bbb5180b00d750bd959bd110f53c2dd5d4db554b6005c4765fbe7ec5903669e5ebc +a94d1c72bf3b2dc6bfebc9dee40f6a89a516b252bd9f4fad96f156e3dbfc151a9b8a02324d764c7656d59230a18eb61f +88996e79171e30b16505638d8ecb25afd875e5f3cc3e29860937f2b5e751c66e78dc77f744a0cc454a8a655142a93ffb +af4d94f342665fe7ecda318de6cf1bc1c40c37dd83d060fedaf827459728152b5f0e280286ff5e6a0012036f6715f53f +96beaa7a2d565ec14a4e5cb895d33624c69da56b75c8d06ac729cb6d0cb64470ed4f9b0387083cd827b1609c8cabde8c +96b773fa2fcb7377bf71a7e286f37f1f24ee42cba5b4f33903c4566e5e5bcc501ea360e3c8435749107c3de84e272d8e +a69ac6218454c3f40ad0beb48821a218fb0a4f33ebade986d2fffd9a3900d8cfa613bc71676c46cfeaa5f644d1f239a9 +857f139c08fcc45370f448ce3e4915bcb30f23daa4134407fc6d78efac7d718b2cd89e9a743eec7bf2cc0eccf55eb907 +adeeba36af137fd3c371a2adbefea614c3ae3a69f8755ce892d0dd7102fb60717f5245d30119c69c582804e7e56f1626 +afa97ca3548b35aeda6bfed7fbb39af907ed82a09348004d5705b4bb000173270ce44eb5d181819088aa5a2f20a547a2 +8423bd2d07073b0e87819b4e81997e4d3188b0a5592621a30981dc0a5a9d0578fde1638a364f015078a001afb00891c2 +b92e9d4ec3966981ee574695d6e4865810b8e75313e48c1e4bc5eebae77eb28740e97ecc3e5c42040f9eb1ee4b13b0ea +b07b218321d54cecfcd2ed54a5fd588a6be8d7a5b6a66dff7facfe061222c40553e076e57cbdfa0bdb08e0a009c94ba5 +a71e1ae4d6096eac9ea4c21f621c875423de7c620544e520fb6ec3cb41a78554aedd79493cbd2c2ba4f0387f902ddd2a +807cdac291246a02f60c8937532c8969e689b1cfe811f239bfdee0791e7aa0545e9686cfb9ed0c1df84748e5efa5e3da +a1faeb4504c057304d27d54fb3ec681462384a354a4f0b6c759d4fa313253a789250c6b0f44f751b0718592637438a19 +996bcd3215182d49f1cd15a05e1e0a4bf57e264400bf14f7253c6611d2571de7130cce81fd28e0411e0a80e9054f4f98 +89d15b38f14bcd46f4b2dcae82b0e7bf9a35e40bf57aa947e9c4a8f87a440b5cea95229708de08ca596762062c34aaa0 +8d8ddcaf79374c750b8b0b3d196acb6bb921e51b4619876a29d09161ba82a42271066187211ef746f9f40a5ca17b75f7 +a3dc7f70f3a6c7edc483e712770abbaa94bfa3174cfee872b2cc011b267e0ef9baa1ab49e4a6c6c30dbba0e0a1237117 +aa9e958bbdcb192b19c43fc6fd34afcd754949fdada98e9f4848e8db0e23acb27d19dd073c951a8819000f2356aa22e1 +a4714e45ec853eadfe5c3bee7f683b81f97857bbd7833192a48936dd1460aee68f700a21658658b74b737c4fecf90c7f +a1ecab4215c1892e4a8ff3405d710163875e5dfef8a8cb84f5cac4e317d89c7696e3f496ed1747ca6f52b304190f4ba1 +b9b48943eca3686219575026d395b969e6ff8159dc5317005df090e79d26901984e40ae4b1af060ed3ff6f42e0417d76 +9644b9f90a66edb0396abd8c00066886f978ebf56fc22081031fbc9ce371bf9b04aa5a4ef59e59319b3a05bb7fb88b43 +b2bb14f1c055a78596488e4e2d4135a6470c1ee43961952160b8498f674a4d23040606e937c02c1fc23dbd47e9bd4633 +8c61f2fce9a42b94a389c7e52d7d093fc011099d0f4914f6d6f05b631df7b88182826edf9bbb1225971a080ca5c0d15a +aa6a7b8499cc7d256043eacad18528d38bf3be970bea4c6d4cb886690280bdb373688ceba3e506471e1d9493dc76f3f4 +8127703363b3b35b06762c2353d4de82b7b85bb860db1028d3640f46bdb78f2d104fa77ee3e0d9db83833d2b12a966f8 +b7b01f5909f2c66ae0fab156be5d79954e3a304615e1fe55945049dd4bd95f973bb3821117eb54db7e9ed1ee9a527652 +8be47ba5dfe212420649193490838670c40540e0ea24adbab18c4a66e7ac3dcf94f068dec2533b60e08c1f64e7533e54 +905a6c7e24b86aa54a05c329a6b4616d335bb0b1f1e9987562eee0acf82ad302c7c44981a1dd6b24c6121ca12fb92996 +86969ccfd91deed93b355a2c21319e3bb08cc652b741463bf68c626b7ba2afce3f7cc397f2fb74588c2893477c948ae2 +b5a9d20eb12c331d0d300fd4b85b0ac0bb74573178a5fac8ec9dce5e95acba07fab444260355ece442a846737a2dcd1c +a13497c11df21b11fc1a63b0ffdcf7f432da4dc2c98f8d07d36da4fa68aceb57af2158088e5b05e334fe0f264aeb7a97 +882e4597cc66498a45e86a2ed9ee24652da4699af00ad35f73b5e74fde6ac3cee70630962d5ddd86162d4aaf11bbc11c +b748858c2bafa4a14ce44af35195e9c52aa75e109719243bbe278095acbfd6a7ae7e084caf8dae6939039b5a4e8fd675 +83a2e0524507e74f51fe976441108f8226ba1b3a33f4e16ec45c5661ce80cb1840a93d17122cb8ca9e0f80d14f69877d +846cd2946c93ee5f24243d9ebc69936b3a1a6d59f45fec6c79b1eddf15ce30a8e73ad03cf606ee66baea3d8ff115f70f +8d98d0a3a94f6efe158f8423c041b546416145c5c2254bfa157efea0d1c99fe58acc7df6424ef29f75960b18d664ea4e +a39fa47e4b79f54dbf59d0b1726f1e78bc219fcfc56ad238c84b4b610e7892ff1e65d537baf5118a32f5e2eb80d5ee0c +8c30969a4519131de5e30121c84c04f67b98c8ad109fa4710dd3149cae303d51778add3f258f0482f1c89c169824dffc +af7f80d141ceb78b4762015de17fef49d7ff6202d292e9604deb508272ee7569f7fd5be3b2438da1dfecf0c26533ef86 +97cf82f70128251944d79b8845506975405bd720e150d836205b048ff36ba8801eb74cdcc6425f28f6bc0acec0a81463 +8c276c876eb88688957d1868bf3a1462375e608ff72b49870a5dac82cbf6584e00e3f36f236f732348a47502ccf9539d +964765f1a5c8a41d8025ddf56dc01b78424703d8a64a4e5539e477cb2445cb541c70127c561e717256d13f91a830ba83 +a2aacd9e21b8c8efaf2319611addea1b9f41430aee42e7f2a640cc693aa395287cc8fdc2806b76b577d84fbd05378ead +ab11eabbf5be4345a77323a3b75f9ee93b011fd2a9d0154e88183cafe47f82a7888666af16b40d3cb677c94bcc755ff7 +a0bfe715a7af5a29b1b6148b8cbee585d2b49fa6ce59bcd173ea3bbc60d71a62f9da27ffcbbd5a6da75502112fe44d70 +902e6cc38ee42245103d90b65028a471bc7a48b825599d361aa81d8c56e0fcf9fbe8d4c13802040d2cfb85b7e022eea1 +8832e2b5014fdef4003bdbb87e3298fdbdbbe49673f6b66e2373f1cb2605f9c4af2cdf9bfd45d1993208681d29ee1c9d +a7d39d3fa1ec1e0c87730fa43d4900e91932d1cafb36c76b2934907becf7d15a1d84d7234591ad4c322b5a24673bba8d +836ed5f09d99624204aa3aa7ac601980fda223f3b4b96b4a8fb235c574a3545d518787c12f81bd5851987f2860d41886 +94235e94445e6086f6e9331923262070a4c2ed930ec519eabb8a30133bd4fc6debb99185f4b668431fae1b485c5c81b7 +9828ffe20b9405f117dac044159be2d3c6e2b50ecdd1651d6a73f7633e6e2a7ba3d783ae939973604446d3a1ef0fb20f +92f03dc365dfe9154743ca70e6dd2758f064e3286fc543cf8c50f68effdf7c554bd17b3507c6ff4127046d9bbb5522ef +91ed07df479d8eb3d31292a0e987672a7f3d45ecafe72935b7abbc3f23493605134ce573f309e226c9efe830b6868220 +93bee582661e6d6cefeff29002afc2f36dd2c13dbf33f0574c35b290ddc426170a5f7f196369ad592efcd72cfb6f8fc0 +89a51467d966f48fed15dea5a12dda54d0015f69e2169b5e34f44c7b5a5d4c282d6f138116a0cd06a8476980e420f8d8 +b8ccebc14b6679ba2399370848864f15f63512fd6139df7359b7b93e82c1007fd85137ecb0597294b46643e1a9e7ab5e +841fa301567fc57b2cd09508ce75326684e12bfb8add671dc208f579b2500b93d5b641e9f59bba798ed4ed1259757f7d +b3cb45c15eb00b4ccb7013299f761cb8fefc17adf6db50e9ecb8abe927a3bc7f28e359e64693813e078e1dac800ad55b +96e55d3b9f445f5679e34fa5425b3e87cb221cfbdd07f8353868c7f7f4ba388ee3841cb9a1d638583bc20d03a9d071f2 +a7dee9377de740270c5b57cf86699004ba8dc2766af56b388b5cb0814ec71bb99ecf43ee3d82a552733854ecc7def0fe +b129dfff23b3c1c95ddb214c4711961fcb129efe2b6557ec9e116ada909593d0d2eec2c628434493393c58c52aa86847 +aed2670e201cb3e38a8be3c86735a4d76255e1e5a4c67b91df6ed262d09c8d10b0a3891da3e6ab934058cc9a7178931b +b20b8921ae52e5b3c94fa3a8b46489044174f7b897779e7763d6eb419e808d76705b7e7ba5131576f425aa81b6b0de53 +a7e45bbc3ba1bc36617291ba7663806e247f1b57a89e31520c64a90cbf8d426cac2e2f381338baf78c8f92fdbbcb7026 +a99e651e73a507e9e663e2364fcc193ec77e8afdc08c2bed6ad864e49b537ec31e9114ee72291a7657899f2033a849e2 +af966033636c2e9e8280d173f556fe07f8b6940bbcf6b2df7e2165c30bea66cced2596f6c17ca7c1aa0e614174953ba9 +b69ca7a79e3d55ef21e0ebdc6f0c4bd17182d30cf6290cccca7d2551c91c12b966020d8e40e4ee4179488c9809c03ae4 +b981cd36244e035fef043f70b1d7188d7cd045b4de0581c459fc5730e10eb7f3d5893b54cc4243849c0855e4e621167a +b20fea858a36921b35a3051ce787b73f70fdecd3fef283c15a2eb1bffb1dcba5991eee4a047ce4e87802da923fd9457b +b040e6f2e56dc1860274c263d4045837456f74b354a679f6b5ea70919835ebe5d32bf1f519e218730096c98ff396dc9d +8d2dd60e702c923a7204b530e7d6c193c6f93ca648c4f7bb38f4edbeb0aaed84184213afafb8db6aeb9197c24364276c +95dfa7348709e43d71285b28a0bfad3ca805b6ed4ae99753e9f736c79d58a35a3a50b42760ccdd03eda50f6e59494968 +b8585632a13f18c139a411bb2f02df809591834d127cd1ff081e26d0abfe0e3fbb54abea26538b25a0dcb4d7e969590e +b46ba47858a29c6d523c9982660949567666daf2582b93393a4802a9e077eedbc0d49d454731696bc8e46ca50c7caa40 +84b756b901b98a4404e58d70f39f6ccac877146c866732ae65e7e82727448d1550343bf7cdff1bfd4ee1ed73793db255 +83e5be888eaf877a2c755897410865f64a6d1169a8ccf0336092f3932abab915e542ab75a35ffe016042340d581ee987 +8cb274fc39285aed451a7def72cfbf73168ee10be02affe355a2bf87cf361a81ad284e9334cf00c5bf99a13d9f75e116 +91ff6220924b94ae13f50eeac16a159232e4f16a73fbd5c22c0e185cd1998403904d36bad203baa82b85819ee4a8ac10 +87f46e08e09aea2ab37b55fc300689d9b58ff3e72f1cffe023386035888f714fac4673c7c5193d3f3f3c568c640694f0 +835d7d84ca7641e1b15095830114aa6072fe12260d2202456cafe2308c22651af9ffbcf6b7e56af97167dd0c4e2a4cf2 +91202183f79794f114fd9e3b9bd05553c0e8985919965101a57d97ef666b028863e6cea9735af016dc1864f1542dee51 +81ab2b02a9b0a490a74ae615ddd4fe560734c1bfdde6b8dd13303c1481ba0e8ab14473535a93cfe4e824a0ab29445f8c +8a32d73f4fc006551d4e2c61eec6130355ec9b8c39a65c24ec1edc00e80155ca83a8ef2455e892521a3d47634d82a987 +af70d7b8f13bc90193cc1cfb0c400c4224cf10f1887848aa93e6380f7087782fc41a159926ab53c53eb95c2383b1a849 +989bf42f9d357c51774f1c7c0f7c0c46a8cb7398a74497141c32685be098e38b4230ffe833a6d880ec391a35b1a747b6 +94cb6715ee95700020c630b8c19e35f231de970219bd7e6ba7ced01899197da473b6c45cacfab0d652ddaf547b4ea58c +b12e3331f1f7d7458393a785e22e9a5e1d1daea521b4e78c0ee8ca59b41ade1735a29820e18f6afb2f2c3c56fecc16b6 +ad4b7cf654349d136fb41fb0dd65b588199f68b462b05f5c4e5c2b468bfaa6c26329033e3c3f7873dc8ace89cf873ea5 +a3279969e1ab596df0559ffc5ac7a6dc849680354e01c3f4fd34c6413a3f9f046f89c1e1be0b315d8b6dfab3d23d5c14 +ac74cc5562836ed89d09a9ae6a3644c936d64bdda9e77659d9982f1be29541b03ef2723236d5465e398373ea19a4ccc6 +98138ebce1af531dd8b631b3e74c84f0c700355a2a9bde31e5e51bb10c8bbd766559c63f6041f4002568803fe08438e0 +9006445da131349fe5714e0777a4f82a82da343612589a0c1596393e8b6894ce1cf42784f95ff67a8384ffe1f1a4ad76 +88502a84a85e4ce54cfed297b5d355867cc770a8ffd0714a6f23b1ab320a9903c6e42809e034bb67dbf94c4fc0d9c790 +aa8b4bf123d1a6ccaa44b86be8f980005f2a0a388a76cb111b0e85cd072ef64167fb0c097c7b23c4bca64c0260f6cce0 +ad49eb35dfea9feabb513a78dd1152ad7eba22fbb02a80cefc494a7037699c8df81202dfec12acc1b9e33ad680cb72d2 +8694da730231b29afd5196371ddcb15b4dcc499574bdd063f4864ab80749833ea38ab8b0ca1629a367fe378e87a60a86 +8eca7b488e810c479e7e32e24b8afcd837f7df183fe4f621a0336b53a9ed77603c84bdc365d8be68179a32b71a1deb7e +8875cd3e23c7e1af55af1b091025a08255743984186770bcd43f30b4a58d175cfdf1984bad97a15e08dac2da27198c3d +abdafcf58ec72997e494d4714645f40d09dcd0fbd0733e640eca44eeea67c25bb0c270299c459991f2fae59d13b4f4d5 +8f040970141e61489284f3efd907705eae6ec757fe8e1d284eac123d313e9ac1e8dc14ae3f04d281e1effc49d5d2f51d +a7ff115f0d2dbf66c0e8770b3d05157b37357b9e33e9a447f0f3fa9da69ad04e371fd1e4848cfb9e8d05e3165bd969d8 +a39b1a8c39d317fcc97bf6c396e6ed4a85640aeeadbf45166bd02bc3bdfb6266509159c03afd492e642384c635b824c0 +a2e1b90f3dd2d0038eaa5be52127844ccf35d997143179d95ffd3749c0896398b130094d01eb1bb31ffe80ef34b42b48 +a2bbe31f89b0c3c375ffaf63c8b7831860a921d5e388eb7907dbf61f2601ea40db86bb3952ecaa26a5eca4317a848ff9 +87d885bb0f2ce04b40ce94d2557c15f1698dc652e938f9a2d69a73ccf4899e08eafa1a59a20cae92823795f5b94f04b9 +8f7746370f8a24a2889d351f3e36b8a7d60e75e50e8f5abeea7dafc75441e95915721654e61ceac51bb6f112780d352c +a7272847526ed3d9e0d0fea1d8685b07b5b908971490bf8a46748c8b1783c629b8644feb5bac772ae615daae383d5e72 +978c9aa2996d8bd6fda7e0393fa8b38747f8f99712427705c00f6e9a12c36f8d8b4cedb03fcb9867155cbddb5200e6e1 +a4dec4a2354b2b32434c5bcdc380bf84580c6f9940f94dc0498a5bfe89c675a0921e66b807a3d859a6059a464cb2a9ac +99459ddecc7abce437f68722dae556d8ffaf8ed974f459e52e6d4a64f176caa4d42c2f2ec57e8a5b5f2034638e8acb0a +928c68c0c9213fe6258ab5bb0c693d97203d15da359784de7824dec143212da57d062a1fc70a79172cee31adc7aff382 +aad3f318f1622ea87e12541dfd982d71629b8f1ded4c301f9f6b6af9432716ad057773c33bdaa6f15dc151b0ee4505ea +8eb8e978f149a983fd6ad01773f9aacf57bd0cc622d8a301e404184b37e610123dd081faeda571a0ab1f149a3960af10 +851e7191d7b94bd422bcece5b92609fc1b1c8556229bc53e32963b2d2fd1cacd8ce5da9040b599eca6e610540f8a7987 +9414157fe9d50e5a0b5a7397417681bcb3a651eec1cab63f2a88d5df68ab1fef6e4c1d7ba657cbaf241a7cb790297633 +b5cb2dafdc5408959780754a58b2da55b2a9136672ebca42f34da4e329ddc89360e7218cde3efdbf784ddb390deacc57 +ac6b70f65503a8e94b773fda3e72615745824930114fe72b6d833484285462392617c1b2eea4a250fedbee88f503f3ba +b0829a5312f9ac6c06fddee2f835a3452fe994f6d42c9edfc390d7d5b3240ca544433b544cbbddd6516b38a6d5d7c21d +95f8e2c59905957e34d53be3d6fb85732f834e2cb9ab4c333fea2f502452a87ccd035fc9075d7c0bd8530bb0a0c96527 +b93f279b7045f2d97c674495f6e69a3e352f32f43cc60300193b936c2850b2805c15457251f7e3f633f435cb2b60405c +915abf16cba1a0b655b92a8a70c03e7fb306b86f3bbfb66967ca63e64c003b59c7a5953675efa4fa0bce9bed536b6700 +ac2047f50a319d09df1ec44d71afdcec5ac3bd2765dc98aba347734aa780863545df9f6d71214d443e3f37edc0dae45a +ad49c74ddb24c8a26b14ec08bc807313c77c5967fbb36237f55994d7511bbac8d7e7b9b8ec53eb1b3b066989f078dbd9 +961483105f605e959213fe9e8a52b76dac62d7efd2319ec71fc4e92d68fbe44cd2f65d7adefb2eb64d591b91648b8085 +b67fcafc97d8df2b3075bbff7b3d7471dbf1f3048f309e55d5e2c5bcbc7a73aebcb0697859be9f387cbc7ce98041e154 +8da70ac16468cab6066992389cb37c79ff5e0babbe67d76878aef9408b9597a3dc2eb5de87428bc761a0d78957b0eb28 +aec0ce89770d299b631f15ae12f94b1e1014ac57d38fcf037c2c7712d770d074affa06e97c60691bad8733874b6ad2ed +8b702c85fa4c915a09fc86507f44d7aeda0993b77af87780d70cc98d580c6e996b64b7c16cdb4dd4562cb0f75da36ee7 +aaeb43aa472aac2253e211fd1066c3a5422ea041cef20168702d0618a1a742a44f7fb30a76677640fea1a24e7fae1996 +a8820e92825d6e02b9b4ad5ebc86161d3244cddd3d244333ba1576b6ae10948145b68d9e926bf6b7a2c25dab4cf43f3e +8ffdae28a1f1d15d7ffa473628a66ee9a739073f59ba781248286b39cb8f7255f66d62337064246713cbb5017e615174 +adfc5dd142b7911326d8424881d5d92006f3b17de4cce91674d6ea37f00fbb266c791ac13f6c7a0f61d04f2a952e6a04 +87f98982444bf661f539bec73a10256f079a4baa88a1cea0351ae3de929e1c500485b2d1b5d933063cd7d9123d5050e4 +8f217ba4dd404c5ee384f0c9a126686db001ff0344c01c82174c5e5ef89d1a241b146008c534b13a0da6c8afe7450fbb +afc85476dddaf1cbb4ba8b22186789f3818c7964f9f613e55010278800cd95422702248bdf9c73760702ef24854795ec +a59e0f6ac2ccdfbd01f002008034390c0ea78716f5e0de4e474e3558755705c9c7afb6e3c5c4370e7bbc85958a9c7a63 +97c0695c58d792ec31d9b86d3b2fc1382f0855057b24d5f6a54c41f76f9e2f52882cadc89a8b2f121530e7f1393faa95 +8e49112de0b2649c08a96cf737af68fa8055f1af594846a2d0534c94df6f926f200405edaa6e6ac9db7e380707a2571d +99a1bd83a7ac5f8d77ddf044c80ebfc5745b998714696d67b94d185c97e9d6db989bacac646d9def463127a8b2febc00 +aba80725f9f9f7abe10760eca73ba427ca8df864a157122eb9af828a05b0199de3add02019a297750bdab5380e505c58 +ae18f62573275c1eb268f74c5e54e8958547f9e7d1d36a05b084eb53e5704fafe2200b8aff95cc7e9af5be2391c42b7c +908b8031d09d22b2aefeaa876a998e0a97c7a1070aad9e9c97836cc5aa6d2d5ef94230e1222074837b5e21b4e6490f01 +b3132282e8b41ca6789ec5c43c1fecf3a65b8eefbc2f3d10f746a843b9ba4ce6db664678e75e424f7b11a00c1440de15 +a1eb49440cc106ebc09cf198c93e8070271eb5a936d31c04858a2b311a037350100c7957d5545c9653f396aa968b91f4 +81df6ad1bdd5eee4cc2f94318467b8602d15cc1be2b48b09ade12cc46ee05cbaaf77a20397e5015030b1f1db5dd9dac0 +87236c68a2a93c8442d15d7f1d1dc01d1fd123439c183e1d843f4ddd2bcf638c128f66f1ef9b710e5d1f64a52726007a +84f2e7f85563bb2f61b10a712c7605d63f79af5be0dba056814fd3efebc20e9c53227c56577b72c68d185571b775eff6 +a36d4ae06688ece2927aeb2c7f058a3cd2aa1de1601282d4e688e1d76ef20728b892928deda2314eba41675eba3912f1 +b8326dcbcdcfce017b263c456c47692fb476c4225c95981666fff0b7d4522fc23b7f12273f0f47cf0442662124e6648f +84c66463ab277cda2cc7007d0509269e89cdd41c5e0d3773a92615f0fc5da63811186b05d7a11088048a5d4834a7e0df +b20d3571d970712ef4699b0e7034fd269c361f53e1572e2ea2676b4245e992d43b8b5931a801439a44d977a988cc360b +94dba6007e6d4998ca1eb84aa8e2a7e9f5c164b9d80df2825f2208ce5640a05aacac2e4f08918268990f43ae1ccab69a +a1c25f0b3ef9d1982153207570d9ce8d692e1b6963b509958dc4d9bcd80074bb221c46804a6d9a29e76149cc7787c282 +8857748fcdab1199fc96084323a81d3bd8b5a7f0b1abc5bc3b5252a19268344e2e7d2d086c90fc9b5fa4b92feedb93a4 +8b9c1d841447354b6c086549e4d1d435ab64c13933488c34bc30f0f6eb36c5c5b838b7b6bb018542247edd1ada091045 +8f5b655416da0e719a204fc567e93792c301acb4374cf7bbabc6ce51dbeaaadfd75c2db0e16ce073ab8e91fd3d7ea9d4 +90f2846b19be46a75c5cd0cafefcf9192e6fd80c479e8d6320c4b8d8d7d96703c9e77ff31a67afa9858e6b7bde1f7cce +a53e383947fd98aa1a55ac956214b46b20a52758461e8ba41341a23a835ebb713038bf048edb1202bbfd0b56a96bf292 +9542d7debbcfb9cda6fa279c699a7b655c03b9a9b456a5d3cfc41a826c94eafa43e01155a29e39ff0bcd965f4c0c512d +a43792864ec5fc549f7afc02622454afc0e425c310c4039ba615067243ebb26a4c7ebfd19bd4d57ff412a4bb2a7958a0 +b85123950e30c048465bf32365d24a5d4b21fffc6183cdbf71643a07b87463989b72dd9a6a47f134856f704909a6b38f +944ea689aec1376f855c0bc9c51378ad06ff758a2c075b95a60b535b88b36eca0be11e4edb5152e98cb2137d6e749f27 +a6bef52cda22325e4c62d323e2a0e3fa91c5552fcfce951edfd52ad6f652bfdcc2341f1cd349e6b5d447924dc569bfe2 +b56bff8ffe981bfcb30791836da10b87f2ccbe17ed969e7f7a650af07d27ae0223805b1264d985148208483be50578a6 +8b209cac898dd580c82d854a553e2517497ad1a4cd198e1360b8b50639b380aee70ee4b87625d9b2278228ff644cd25c +877cce233fec74c7158b3c5bf108365e98238418b8a71f058f1aca44a0fd3a1021e3e9025bd11fe244d9fe0f5034ce7f +b1b871aeedb03d6f6accc99816b89f5958178738d8d8cd9717527d04363c80fdb5f6848122ae19fdbc450cfa11e753c8 +858aca51b9e5b0a724e88688d5124eb24c9faf01a3d465e74d31de6da315f311143f22f60201ea09f62c92f61f09d889 +8521d409615dfc8c8289e00f6aaa6297c2c4e1439b25952afd76aac641b81c70b9cef07cd58c1c0198382bddd2bd8544 +88647c3e41666b88acca42505f1f5da226937e0522b538fe0cebb724e9a99730ca2522989e94a96cac94109aef675c0f +b417fdaf719caf38854e89ce52031b30ce61a632e6c3135adec9002280e022d82ab0ea4ac5ebdb21f1f0169e4c37bcda +9367a6feb5e23ea2eab8ddd5e7bdf32b4d2419fad1c71a1ed327b77362d8942dad971a1c2e6f7073885149cdf0a0c339 +a71c5c08d50c57d094d6a4f02e97d3799bada92f238ffc07bd223bbe8379507b7310d20b28f5bbbf331e5e153515e491 +9630a9a3bcb044b51299c4d3d3388a4ff47308dd27be3229601985478c0f6b55faa7e20815d8694f910611396a9d0d45 +b0bfaf56a5aa59b48960aa7c1617e832e65c823523fb2a5cd44ba606800501cf873e8db1d0dda64065285743dc40786e \ No newline at end of file diff --git a/infrastructure/kzg/src/testFixtures/resources/tech/pegasys/teku/kzg/trusted_setups/trusted_setup_monomial.txt b/infrastructure/kzg/src/testFixtures/resources/tech/pegasys/teku/kzg/trusted_setups/trusted_setup_monomial.txt deleted file mode 100644 index 1119746748e..00000000000 --- a/infrastructure/kzg/src/testFixtures/resources/tech/pegasys/teku/kzg/trusted_setups/trusted_setup_monomial.txt +++ /dev/null @@ -1,4163 +0,0 @@ -4096 -65 -97f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb -854262641262cb9e056a8512808ea6864d903dbcad713fd6da8dddfa5ce40d85612c912063ace060ed8c4bf005bab839 -86f708eee5ae0cf40be36993e760d9cb3b2371f22db3209947c5d21ea68e55186b30871c50bf11ef29e5248bf42d5678 -94f9c0bafb23cbbf34a93a64243e3e0f934b57593651f3464de7dc174468123d9698f1b9dfa22bb5b6eb96eae002f29f -82b8775b874067bdd4479ac237f8d56036a742c17901354caaf38bf8c70e696650fbec76f0cd941ed8c658f44ea359ff -a7ce299c79c7d7e4f1adecd754c5aff8a720728ab27f5737b7b399f72724407ac54965088596375b8c876665ed8e4ff1 -81ca4c808a76a6f217f8b0540ff400199295da69b2587b7be6aeb56447fa4fac08d154a27c4aa6082bc40660078d36e9 -a70bad5311c97f1f3fea5d3375da1a11ba948aca41609ea28666dd343e07af766834e1256dc685ac1dcd915073250864 -a91c2911a658ba79f56abe30716a3398387630e785b351b07344022a04b2f5c90de5573bd6e8048fe8878dde19336c5b -a8c560283fce9813bcbaddfb78cff93efcbc39b33025cfad94ebd40942a9fa605d2a947dc3a1f03c2e454075892e96bf -aa14f07fbd2c1ce7bd995e335c69b5f675ea573517c1834e787b30ab4fa10aecc62ecc5e617ac8a539af1aff114dc9ec -87f03429aff126b7c5a918423da278e17b5f48a4cdd6d34dba77a75f4f99e26a417e65d6a8579bcb2eaaf1d4d8c64dce -b1ac81ba91ede78315f712d524e9d821a152203f04141ba77f4e481ad5881473dff14a71788ce941f0905b429e7ee5b2 -8f5c2af611ddfa3edf7e442d00e56a24d615bac848c05070c908c741ba18b67eb2e82e6651c9b3c70fb8edbf051810c4 -aa4115b19221e4d17cc335d4f9b0aad22df566231f2286d550e97ff2875cbc419edfa189c4ecb24001123b95c6aaa2da -b363ba913969df0debd4e2712ae6e9177ce82e169ce7e0ff1d7616ef8e352aff3efb40fffbf7bff1b21cb8a33e19b455 -b1013d778727d20466778cea47e1bf56a77168a8ce1b33bb1265f66438ab2bf4a7df4f4142b8681f2993ea9baf798d17 -83b7250ee17d8529207db97b73c1c4a92ac076951a577ce2fe3a2cd633b461c1820c139ab36a895a5962e143c6198386 -86d180bd2f0a4919764e6f4e846ec0d5ebe44060ec1e529ed15101d7e531bf1b8f9412916ea5aeb93b37b2d7c6bfb408 -827451462c79d74b504c01bda199481b3c70416f66a95b2216686ca4d48da48932b0d323d0cd630a1e86e8033e832e5f -b789d217cb12c334fedff0ae01f85b96e968fb98761755d1ba3ee17934e8fbd83172225df7c0c6cb99432a30a0ef8c24 -b730e5412dfbd646b0d2fe084a1a32eb5596c3fe8a5bc0f430151804f9e67f05f70b522e9aef08082b0afdc652a1d213 -9987653bacd9bc1659b17f6964aec06ea63b787813d4601bee0479706aed5595ac82c87ed4f96f0cd30c19e1d9510a91 -9506a9ba38f1d26c35a17c7e2554e28eb347a19cef523846a2559fb80fb40306b2f85bdc2c9fb98c2267df21c1ee3589 -98dda58de74c0cdaef97b2826b4a9d53c9e9ea592dc0a755ccf5b3fbc1264979578563f5979aaa246e679918053c5f83 -b00aaa16841ab53883af481e2f925050f5f7bf7d8088bc696f55f30593bdbbaf434f5d2b46095ed097b6cdb96c8fbc3b -b463d656480f89335d3a840a7b9398877003985388871b148ba708c60f9857c7585ef17c8b2ae67fbb191c04ad61e692 -80af54f3d0584126e23635276d650292baf7e3e12bb06468708107bcd80937d36575721ee7472c5f085ffa71dbf438ad -94ccb8ade84e834685110c96908b42e10d2184208f434d7f98d96cc158e0c0c95135979600e5e9f465d5846b0bb3c787 -8e13674b00c633d7cceb4f6ecd61e4f99420d6cccf9db5e81f8c90f6c661bc76e10939b83b56c225fce8565f525d4fa4 -a46a15b2e671c1a1df2490768dec1093caf537e1a21fbc11ff8ba8b21b9f2be8d50257027d9357df20d9fbb1307d7249 -b8ed532d48b0533a3084d7a5eea7b401255c5825e9a1b80ed81fd530cd69e347d152b1ad8a899acff7d68e0103bbfbde -ad6b7df980ebaa24177d830c4aa522d6179a9a489257f60ee6604cccc2cbe90fb1f72aa9d5bee0d3a88f73b179485f56 -a56855e9fcf62ceef3043991a93ec24f8f6b5667ef5fb7ad1771249ece68a73580ec3cf3e58a009ca4650c01241ad172 -ab2f25517d4b0b33d317eb78d091d3c3f98dc352b8a3e4650f7005f9327129e23d95f38eaeda5e9b51c50a31d20a4c20 -a2d4071385b8a421da86f39739eaadcdea5685466feb6ac083cba0ea4c71dbbdf655032097276d703f9a77a4ca6fab03 -a8681d7c258984f01e92e92c95738692b7bbd59c3a802adf4dda8d34add69590b080391c09e98e3b75c085c9f191e5e5 -97685643da6c07b5e5fe91393122813ba11c8ef3dbd43a03b3a22a7a1603201fd516c1929418eafb14039270694c239a -a7bb3b85d6101e4fb0bcf540f52041cdb3e819d517465e342b832f0e91346a9a18bdb38845ea4d2b71ab87ef3bf59f96 -8afc90b7d35336fdcf8f81cd024e921e244520ecfcb5a3994f2bbd595366b68bfa792a8dceb11e1e889b11432c9dad6b -94d9db7bd04f962d8d6caa3b7aa0f19acbd58a09d35ae187158d77e537d2fc65215f51f1afd62d4ba378e7d176a680f9 -ad62d7c01b14b6f97e6084ec9f9d084f106a7ff3d603032e6e34c027cdce4b0fe3c20ac7931f1209439a59c9fede4815 -a5b44a87bd0ada7498e011e495a2818a8694746c4e7dc9d24c0c1096f54be6439e08c1b11c10d7c4bf68fe392000e971 -828626c6609acc599f1bf216e9a4310fc3cb227e0d2e47bfe3360239427c8b0cc300cddf92456a5c36620596a6d37027 -8380f91baac6447dd39886455ec5d99b874ac114a3c6a6ded18fc4ef69c2208ec19732428d8329d200a69f31792b852e -85a8389b522b0a686234450165514127006baaa3907f6eb29c976522591a542ffb681b3b88c4886814fd7ba3cc8110f7 -b8ae7949ddafad37c0bc4d48325a7cbcd3096fb92c04a027c650a03cc609c7eac250d6a7ba341616bc36f64f1b4c8be4 -8f9b9d2c2ab5c85abe946ed9986e0f304281b277d4d48c7760ea2331b55a9e9a1c4d53a6bdd83fa6294f421ca7431e29 -9464b906ea8bc994b31e03c5f2af2be0724a43293fd42cbd2263b2de75a2ec04832d1100ce62ac2c0708f05fb6bb3ce6 -93d923f6805e7cf972d8387b352d77215724a3e1f5489c4114fcf0b25fc2231963eda872387a1369a02b2e8b888d6427 -aba4af392884eb7283fc5611ddc1cebfecf9477462e951bdae650e311606e129b4424452a3a14717146f954a7fa1cfc3 -a8d0bab694d116e4f21fa19ff8fa4c6fe4061dbb54cbceda8235a7e05159737f87e008beccb90df0bac9c7d572281903 -85743e3ecbac7ae04a81a09c2961397aa4bd20401533cd24d5fc0693cbfbdd2b37bbee6dec2ae5d0a66250d1fcba6944 -80ae913447d7d3f6c54f9cb584aa1603308146daeb3024c8e06ede66ddc97821df09f9591453e9b617b828a02d54c719 -803c2a64bb1c68890b5f1909be3aa180830ee3ef316d3aac38bfd909e2b19d890525e18e8fc2f405ee70ac14f5569b3f -964d2968724eb790f2f42263fcaaa1869c373b57b3eeee904f8b36f13169f07d5e29cb2b03c74d3a7adb772e91d5a59a -98a72ce71a57262aa058643a5cd39af64cc9eee88bef7edb003143983f29d87c7f9658b1ec89712f79f6f79dc24a6a45 -91f3479c5d7c76acd2d51883961179efc975c714720187cc9c0aa7aeff71ca1b3e2db5b0a90fd3ff6abf880ebc49fe36 -84312757edd09f111420bfede10ed3c1fa39d1723ddb9bd4d0004c829f0c1eb060e9648fd75f2e5427a67a5b37945a9f -95edd726cf4042a082d786262304c51d8d5e6a89b1b58e825a11febe5f861d5ce076bdcb2fc0a5dfa95eb2e5b0ffc32e -96500da38f942871d78fcc46cda1e72944c7888b538b82e2a979f149e5061a20c7602860f82b76510d02efdf3a911f5a -8ac62eda98bef8864df243696b53651a02a391b898535d2d76ac5a8e9322e0178a290c83f5afe72ffe80ad56183469e3 -8ab2d4427fb6d3da5cf6c59835bdb39fb0c2de82c213b5de77edae3304458ea505511bd98fda95bdbbb9058bd5e92c34 -ab67c4344a5080930029ca3b803883ad05ca004ddefb48d5164e71a1c6dd96b27aaec70f62b39bb126ce1a57bbff1453 -86c6bf91686bff714a873a78b0fe449db5317a5172a0a14eb3a96b2997b888d5d3f440de8baa32a6966fe44c3625b014 -81d4f1e9d9e550125290d993a4886d46aac8cb29dbbba1e608aefc3432569c5faf14d8b49fcb485d9b75b649ad6b2fa5 -8594140f253ced6fa98dd90ab4f38899916bcc6f1052572f182e46c00752f3053c390512338a0bc8f8c27a91916b855f -911284d4fad4999bb37590206d582b9e62ffbb815f414fd829f5b2843e6f0e1a132cd64464c131d5a0f476469a37daa1 -8631a6a4987410982db9c0ba632023a5b613f553b6b8ffd3cfd501b2417523ba8cf06741c62f24b405554bd93e39e626 -906ac35d22794a10a7273fdbca499fd921799b1ce9414643779dce9e1ec37920a5aa2caceb4b70a0eaf56c6032ef1b43 -87374cdb8b7a1ce3c182b31eec465d435e35df782fe3a11f421462b48cf56c6fef2a9cb8ee4fe89672ba7804156d9e3a -a1f825e0246eee506c8ce40f849a17f75e8a0d6fc3f68b6a4dd431173b4fe997d30dca53005829e4e2422a4077ce35c7 -875ad0379abd9873f6634692e33e9b36353e1a0d15b13d3215eb591244e1f236eb2f8f75274ca7f096179d1714fa68b7 -b87b4e1acc09c5701fd9d75375ab896f178c1b3648fb9a2e2c6e1478778156decc32cd390766f3e80b36beb1e3a6bdec -836ca80949269eb52395776ac5ceb35b7df717a981c5cbbbb627f73c274aa8164e973a7b01012fa72a02404e878a9918 -a770b13a8f07f74e5a75842b18f2520f6d0be42c865a29dd81bfe485e69a83c40ad10ce229afce276ccc9cb46c54b912 -b4b919322bba2866baeed38bf0e2389d4fe6ab6166597e87dbfee75acac7c2f5ad3bef55293b56957c103d5825051bb5 -b6171f1bbeedb3ee1af368c9c9f327d1dc3e55aeaffbe15f14db8038cd72540b62fe65f44ad0b5486dcf4023f0e91af8 -8e42d0c1e8e8c2ccaf06edcc3c686aed56b8c987f9d68f20937fc088120a410cb92fb0ab45bba5db70b86876015a6b72 -937bcff1af9685fd0d1f6616acf91d97ac9fcb1eb96d49d1c880c9945c1fcf1414f63d59fb78348d08a8546f6e83e407 -a6eeb4873c0531fbcd407c2e702c68e4980fa77c9c032b9913b89031702cfa56f335fc413576c37ac4d523357a841203 -b3962b5eed69cfa27fb94edba74b6cedd7569352ea71861494dd579da96d9743655b6308e54f8a42ee6d7e805c1bc0f9 -8eea944dce7202b033ce734c9e88e82dd760c916e00b217cf1f00bf6ec5f20e21885d5fe95d6138871d167de4c46359e -81e6c7b356e2703ee333a9dfeb2b54260636422b9bda118e0523a20ce83b30fefc2f019e8291a8db05d207f0fa7332fb -83817f6164dc9e8e2506252511cb9871a8c9b595dde45f67e75ce3505f947b3fb3b804c18c054ad13b1518a98f59f008 -a9ab4dbe7699e7982cd750d7effe031f273fab6b2e024a0b4f8beccb5c280903bcd3f2400b9cac7e8c94e157b4658ab6 -84d2e3bc66fc6b59a1ee98b8981ebca0901d846c40d207e5bb5004ec9339d28956d16f054af52453f6a7ff3fc66c346b -b24bf0f69c3e86f610b6d27885ac5f4556fbb14e8286681538ddbb0b4921aa0d5604fedef0daf4a514ae15268a640174 -a4be967f7f31995562669bf9587f5463bd1d9873fe9169687790e75961efa5ce2252fd21276d022f580de23527282838 -a3f3c4e673b302bdb91fa3cbdec88499752e6ffe37e2215d69b8a426f4da98c3a10e4c659e77c656172e4e8b1b1a41bb -b704ffbb3434563bbbce69ca7e812a8bd30757b1e90630bf3261735f9ea221524b36f97dec324ffd209bef45bdf6f2b4 -959dde49f15c663a2de000195e182a11d8c396c1380f98322cbe5521b697bc3bec3223ca9e94ee2734c4ffdfb6a19e8c -a469685143cd82b78d7b1854c350da63819d9d86670e9b35a72381d0362cf5c3f1d24e22ef2ea6a12176c9dad39fd51c -adb97ef4463e5e13d91b75a3086d72a841a60be278e9651d9ac5f76c9537bac5eac33424a1ea00522b3357fcefea0738 -a4597b2ced7566576e71b4f105b5ee48aa4ffca93901e9b626f7059824f53be3e8f3560e6861285f3d97fe88054fee83 -a18d9b1b81564447f798ce5966bf10c823aedb14b143972eb4dbbba9312fc79f46635aa016cd20c53be90f170f06fb84 -ac4724069177d3c6ac1b72ea2a7d6bc5ac3d4b2a4dbad124152fbd170c9c1038cdcf255d162a25c14ae8df11a3849945 -892683f64179ba84f6a447c5c7489e3cdf02474d2837dd7bf3b82a4dd05a6461ce94fff28d65b9539cacaf47dddedbc1 -a68ad797bbc1b2909e216a0b3f39aa6c3e4dfc7a49f81a206b530ec0c6ba30f871e4a0053625aeb99448026ae2e0a6eb -964ff8badf35b6b93be6d97209d87f4ac8847be1c2ac4bcafa1db5c3f604f61834c85b3dcf58af50d09bd03ff8d78f27 -b76dc9ec64b1fab7be269097a18a77144623d37bc656934fa1562817c922485e69b18ef40413ee309e100fde645fa7b2 -b2a812be6e69f284580ebdec5ae2cdffd587bc7eae10989e9d2f290498b1eaa934b148ec7783edec300be5d7a9b34af0 -85ffcabc623f8ffc58c5f640f857e27b7c105359315a3969f346e1366acb2af88f4acc025b299b9c324a8535c380a2c5 -8d0140f79fb8ef02d13b1d51c4ba1af5b5ffb19322f88912215d4198f9a592f7ec6800c8a3ca853a3b68f9bf0353a13a -b3174deb53c1ebb6a1e16c915cac287573b70fe4e0036e8e971e8e807a77362ede632f6e3f29cb87a80a318213946ff1 -8c58d603f6420e3f55522ec2853065125af4e7773a909e28296552f7f8ec4691ada9211d834dca38e118f432b6cfe03b -aa7ac268e155ff074bfc197844e21fc2a9f9aec9b50d9cda63f50d3c4fbbf9221e6fac3a6ba0f7e4cde71fecd493a15d -a191337721bc9fd2d3ec2ca6f6f97ca2462ef5e207464bf9e746a650a67d69abb5f578a8238521cee3f704b275845e47 -93521abea8f38c103ebed3313a3af8f27f03c9a54681847f4201bf9f72f1f63064b18175986fca64f80b4380905e894c -a1b9d063d6538885f9826b84944123d7d6027dd030aef29fd6229f4cf5d32404f7dd0e899a0c8f4b6bdf4649e8a8966f -a15d5497f0fd2fd0b2c2e5df58a25a72a9d99df8215951ea58c15569d312c6f096f78034f6a8502f808e649f6cb9283a -b3c275306852612362e1073d0f4da3ce598dc5fac3f3eefa22ccee35dd57a4caae347b43342cd1f6a6e068d3ea9fd30c -94eb678e0700bf39caf428c65bbf2fbf7f601c39e382570a4df9186ff1dd5a958d78e051a5fd084e4f75536a14b7690b -97b13995bbcb8e824bec28488994a830a9c1f34ae4c1a16d5528d57f09e4c8b5d81677ea9f979f0acb8cac629ee09c85 -817c99ad48bc05bd4fd29f952dbdc5ef56bb02f3442c18e3b91cb6d72ac2d2a5df901c099165ded1bee62c3ed13c41e8 -a884acf980f6470e11cff347692d8a7cb7860d4822112f7bfeb02efb05948ea98c837d5d98dd7a104aa36eb8f016a0f4 -95debd2ed23a23a16a393f59f666cfc864f63751238b73981faec4a85b4c04cfa11520c9e4cbe4e23fe80e86c260093a -937b4691c59453bc6cf6468ed5b17dbb25496bfa3817798562cd5fd86ab5ee35745991afea2fe271ce0fbe5a990c41c7 -b4da98c879e6b475c540ff2c5501299f0e3e97b7b93beb45faef1253f7de96968898505e672cfc4a3ee7e20c1f72c256 -8ec9d806f344d0c675bb5ecd47c54defb5f059a5233dfb2d459632b9b22edd6c4b8c47fd7899ab13e35f37ede9b124f8 -aab4408410abb4d2cd98694f71b5452e6fab2690daa3066b3f9747e7dc40b57259d52e6fddeaeeca227b733d049b9694 -b85a12f39808961c331038159255140a61dedc56050345a2eb13b1f7d140ae07b353d68d22f2cf60925fe66e598213e9 -b61bc3bd68bffdbe9731f48fcd523491da04dab83add49fde390070513b9ad87a489010f1ccfe6f54e9a48edaf88b5f9 -8f50f6d8235824cf25031f09e4b139bd89c1090269dae95a5aa0dacaf5f9b59c329a5a3cdddf9efe6c77cd61f481dcbc -91a543b85e18f34361d7df5ece8504d456627fbce65abff437007e9109359538a03996e35393a40f0586f962921eccaf -b7557bc52931324dd4c58d0e63c89a8dbdd2d00d0baf79d81d7a062aedd2de9dd743ea30fb031b18c806ba03175d7e1d -8e056b842a9af7aeb6c0d113a3acc8bfb5c6a8980fa81869747f75abef76b7fd20cb67694e70016e3de6e7821cde030b -966c00fd6472bb13ffa531d8eedc145ffb7733114e0f4a6a9fddb34ab7601f6cfb056460f757636230b692453d8b31d6 -a25d85947c6939547fbee088e0131988053c5bb23aa2bd48ca764f4ef2b29235a817b8918d1de6865695977a95711e9d -958567f217ce7a6d74861777801663d7175eeeca8ff62e240582fb603ac91dc402331034fb4855632352df2328fe0233 -85e53f3802a7d32dec2db84fad7f8c8fc856037cc0cd4ef9a8988e97ab580d4b929023f1fcde7633828b5e8bcdab08c7 -878d1fbbedee7f7ff72eaa3848d7f6bc3cd13b40149278b3afe5e3621e6d1f0386f8ede32971d3f33be189c927bef6f7 -b041e880e4ecb254f6f8d92635a1ef3be3d5d885c751f247bec2d8a016aada6a7fd2f7c599f458ee466886abe721bba9 -920747dac9f35ba0b2670f82c762a71ee9bfb9e490825fb7ed613bf2548ef4ea00bc01e9d2c952dd9c56f3586a3ffb49 -800005cefda1ddb860fd8974342fe315d227902dcb5f3736f8b9ad1fa2f8fbeff8c8ba0eb3f0c21a6706f288ef4bb13b -91f2b822b728fc5d1f15b69a303985bab14c08df5e929decbfa5aa5689f3cd93ccfe19ab10499d31df9d38c84039e492 -957a909486abd85b1e627a4739c7d212cd03f2b62952045b704c415acdf2e6c0cc627af93f382836603f33d1a716ac7d -9733ec7a30ed833cc1e7e0ada4badddb1cd1908bcbd3d4e4694576421c94090a9297aacd7f42d9d305b87d711828304a -ac2785a0dadfd246fe12b63f759e9f021006cff4f06b2b5a9986f0b02a40f29513feb1c9044af6e27d1c5029b1e1db35 -948b22bddf55f4b4bc26892e83f70b882a0458582ed87fbbc81bbd037c946d833c19162327354240c42e05cfef55394b -a49c5d81544028d56f4caf8699477bcda589c65f6754dd40a487ef88d93925008dc7fefa6d458619d51a54b3edb5e5c4 -ac57b8ca2d0623f5c4137cada67afd6935fb75fd82567f2c57cb22e89a0562d3c0716d5e903fc06694a8c2edbc9a6f1c -ad52af6a0cf838bbca5a97aec5d87fee1aec4fcf5e802b8bbad1b110c31ed777de0b0ebf74384bae68289af20e351bb3 -b0c7c48d734e5a1b37674465eb07a629dbdf8f9080c44a578f3dd687261d9d1cc5cbdc084488c745c9114fd998bfefb2 -8a2b2ccd4c52d15bf7aa4a8847b8015bd53f58ee484589339b4510ef08a27db56178c15b4d79a9c6eba1ac0b641eaa61 -98f659a37bffd7a9b7759bb111412ea9e9eec483645511590f683064eaf15e1b101b5eac3b98f79ea38662b1956a06d2 -af6cda3fb2479b6f2d959f2d03e52b49afd12bdccd7a65a1bf6b91e345387924d5e355363f79bbe32a4624287cf4c1ac -a24d325d8c2dbf9d2e346e3504154018937efb74246ee0658e68d148d9ad0f4bfe348ea9bdca77d4467ea1b3dc2fae5f -81a729dad3798121027c29e9310d56e36a48c1c479cffe674cbf9131c562f541d7e6c52c2718025d3470b05b67cdd321 -95bd5cd6d9895c775e58cd4296ebefa51ab9e324418208c3c4d073be59410497a4d0daddba6c1e7373abc08e13d32b89 -809fa97a229b056def6b548902d8d90c873e496db6cb1b2d448709b9ae08d9b9762559666cd96b6bba396eebbab4ea4e -8bcae63cc680494606e44037a3bf6dc7bae2e723e5ec3ac0451550b8ca7914ee1d4bed0f40adc3dfa45f8f80a36c11a5 -b3474711a0f933cf269e97e4e1e98762ddbbf49dd72e468f1e8a2f89514c1c35cb8db32d08dff50f93e50db43bed54f2 -9788a37c3d95310627deec58ba6d9e0324618469275276632a3fa7841fb127c8fefc1b7392064f2eecb508056bd346c7 -8d031fdb156023e185fe5fcac67b966baf9c098fddead4a6f1a3cef54d8e912d0de2d1e1d3f3f05da538eac4af5b6973 -a5efe72b86a714dbbae40fa69fbccf41042e0647d177cd60275700257aa583708130a64b2f9dcacde4fb636b5cbd5aac -824092ea32eb7a8c619182d926f292cedce7ac3d3fc64f60d00fcd767649e1d6cffc20dd9c1d1c8ef6f64be315d1e2b3 -900ad22d3b63376b1ac80c7343a58df23c03c4e7d6e5740dc10d8cdee793be07fec09cfbdf29e1d1c6484d3077630d6a -826815005550844ac5a6e831de0e25fadc49aff808cd601d70743d4873a341e3f0cd40d490422c87df3f3c40921fa723 -b39d189aea740c52b03660c0abc8e796cab72193ed44a4b1f59fd1ec0e283ef7d5e157ed23741eaf289cf968597c0900 -968ed61662d1e656e039900912ab61173b49d2e24aa6b7d3af07c3b04a2c89c4516540934aa543bb48ee14153780d10a -a433b8b689007ecae7f1df15d442b0570664a2db6318de66c6e5fd68884615778d296bd260ab7d07469bfb5f6d8c94ca -a69ed4a0f39920d1a62a01214daec143fb7596212e2439583df9ba508784ef4d2fe86334f0f9a6b7a3342ec0a72ef15f -96f260d9cd88757e7c45201d57bd816f1cfd37587ba17a64997bf7716ca1c2cfe16a7119c36acf1754231f303058a9cf -a51f2bb09d30028eeb0860e2de38094623e5b5514fd5d591a7d4a9731cd4b9c4c12c5dd6ef409e009dafb10d185d5346 -8abe821036140ccb3ff9063dcb5e8b8724cff1cf0784b8f44486c8380fc51715cf55b443cc20870f426c4874be93caeb -acd73facb964d9012ad12405dc866beb52d8de3ef81fe966cfdb14d22a19bbd2e7ad3a29cf029617b9d6510ed323c6a2 -8f18f6883c8e4741cd6c52e0d3335dd71b5571446ee28e8c27cb0625f77a9f5bd0720d960e5e8970257907f503d58a9a -b66457a91e7ddcf56c8ce4936a209c69ee53d71236b72ea386f7719c8b8c9b4ba4ea19039a8de17a0a869da427da42e7 -80b1de58bb3ac5f264e0273061f485e49413de604b5ade73ef81bc249f5e89ce97dbec7d99b088b5a2ff65c0bb93fa76 -8bdf276c88f80371ef0ef7e1224929681629aaebc8cba3c0db0b258be3c26cd17268f56369832f564b1679be33e98c69 -943cf6fc88678816da42e4f337c730eb2dd59f8d738ea638a799e8b77214ad7e74723056bae96b100f9a972155885d26 -91c8c1a8a61f47119005869c11edf0b69d0bcf40534b82e46aa96bb6107f940e582b6733f855144accb8dc21d79acc39 -96ba98bd291faa0904ca0398d6c50eb5bc2ab5a389c359ca42b8909f41f4fc37dcedc370ece777d5035074a597da503e -b4598e6f889d319713a9896161a6c9bd8575ca30c21d3fdd37cff15dc0141ce28dc536f73957e6fc8f6185fc0adb731d -af1ed593a0547c26ff729c159ef14bd0818f25e7c1c6c51ce8ce5425bd2526086eff9fa3341279daf82e480bfe431230 -8c02b9ad3aebf156c80fec9b012241f3794d736adfbe4a272faf505ab818cb121ad2ad7c2eb1716e252d0a2e7ee6b246 -8d2a8a31784c446eff4c2ed7b004009f08b86c87a4786a0b7be3df36ca9130a0ec42a58d09dfede1279a4a6d3d37b501 -a78b61be13005b1718a3aa3deba103ce71e1ff73163c76815f9cbcc101d993f119ca128a25c51a12fa52f46550c4b609 -b990d81d7aec9fc50d798eb8c38b40b162004f78730e9ed4a103faeea0995bb654893e557e5eee9b74046ddcaa70617b -ad56d68777d0ed53d3331b0cfd44503b27435278416ac2268965d8ef711fdd819c16ef5499d8d7fddadd229c3d0d4bd6 -b5110140b9ee542ec03c945cd6180ab1af205537704fd408fc4490d799d87a3f3aa0f1f0ae9c8daa55c1757f7bb53cbd -b7d8a4080c5eeb00be4540a00e65e744f4c7792b518c9fd2dbdd25abd0dd89e76563618cdb92e4cda0fe3ba4597508dd -a880b33af98cc0bd1065767a2600145e6e326c3cee25602dd22d531c26c4b8543f846fadf679e26749c929310779d858 -941f124078990e03310cacd79e4a38667f4dac4dda4dfa3173a03c14aafbf538fdaa01b940fd5be770c1cde0a84bfefd -b234e9d0f04da6efc5aa5c77bf71cb05001cd193178fdd546e4ec81875830113d3d4f1512e7405b16d0b3aead285999d -b857bf6f62c4b19ca9441f700ea6676ffa3b0c7138299533ede59a9b9cf9b94295046e7eafcf1d4ecaf0341898ed6b15 -a2b0d74f17d3387566bb4f17dfef214cdc6b61dc50698fbbe298a7e2f4a82d20aefd719c5e82bbf4ba4fee0e2e35b4c6 -b5ffae433aafad3fd51ac137976e2c22661d8a286b221e0107baf19f5c8f2f6c7eac1e785f145bf7c16a497310fbf51d -a69e9dfb14f8c6cda716166cb69f06879718656c9f46730d94f194e2888fec371a11c9701071bf8690e57996fa91d213 -a1f51ecd5c5d73155013dcf02b327cdbae9f9c2fbc62f73959050cd3a0bd66192213d1f4bb56a85cd21343722ff3f57c -ab3e54b8f4829f1115694a4be7d16e8214c94387ae783263cfe145f965705d51943176191c706f6211c8be2699dc79a9 -8cd6a64c5d30149ca4dae4fb7e8974dce1200aba9be9c8cf9af5d43e40098746ecff7bcde7ff84a0072138dcd04c2771 -a52f6fe24305bcff685f2d047c9a8d9a1f70c2b416cfe55fc137c6b5b185029f3644890418873665712dba4886e3fc07 -b2e8e3d2ba2d64815bafb678dfc1180534186eca415bd8cd32b303bbac6cfb637b17200aa7cacb953e656ad19dd5c9b4 -b5412d1073b3b80bf0d18f791a6d02727cd9c40a86ab0f13ccfd847bf4e767b8b79aba3935194398da2c9cf17c6bfc8a -8bbaee84aca9089585d5ff385dc2ee6e653d0fcb9088f98bc5fb1c6c83db026d9a73d77c33c6cae3268be90805d862fa -9691343d1a8b7fcebefe2584b28ab5808764ed79d8f28168a65ca90b0094e7920fa43e56b960331209f4b8465cb8a5bd -8ea475e12088d558f5cf6dea2da71837791093a622d5cbee608a95b4c8a61296255c1545d454562e371ea0e2cb2e0b1f -951d6b404667ccca099d01328562790d1e8446231d7d22bc2b1c4c6b15785bf59f2099accc58817a06d24d59ff4e6a2f -a5d012687f341eb9c783c1c2040388eb7ad662cfb2b84cd94d270bcc99116939aea80440d7ab726f9abcad22fcd90274 -818fb57b7a8cc59f06af054ce09dfef812f8f115eb2473d06c8f20fc50cf17423331aae1f843bcae57fe4e2926ad5aaa -aad27bde8eaa2e7fb1a9a5ab531eb41f475afdc89b7f02085f7289f8f84d172fe516d0104560a40c89e97db7e5e836ee -b8cd923efac1b09d9c6b1d97a0c1bce9fe4eba1d872eaa3c0df34dcff2e7ea2354f1b31b69c6b266944ec8cae2a16865 -af628e772d609224aa7cd3eddbbfe965fdae6a05cf6d14959c5c26c4806043afd5fef803091bec710c6854ec095ba18e -b662e1d32704d96919f5dbefc3cc40e7d41d4124c5865b46408c2ee5c40926eed71fa3df71fa7ad349d476d9a525d7fc -ae4c5512396f9c26381394ff8e22b1d6267e3d3a5d3fe48457450694520c5e173716572b68fc1dc352761991abd262b4 -86b530978a7e549e6ca014168fa4aeda9438bcd3a29f7edb1f4e9c712c16faa58b81b028c25a8e90b421b61a1766d7d7 -97b32f1371f76dac7a449295365780d1bd03f290a041b3d19db3f14bee6365a614ca356e7cbd6f966260420b451f6117 -8be97569ea08d0b6c4d46e9565ae14f79d1990f192a26ec935a865cedd6bb5f69f608b069f7d645877c5081fb4a68c54 -9733488f48de05f57f623752b80b37c91f6c9afc0f9b4df4cf400f3f82b137bdf06fee82190f2a4ad4aad20e964cc214 -a794f6dbf155666056529748a792be13011bee6ca10e0d55c82c3e84c5dfa1f370c8e8abf2971a75c73a4ddef3da3319 -95ff5d16c0d9bd679738257a1f7f309f257c20469f2fa41bcfadc671ad65acb249793defab591f515bb3d8072e2e05f3 -8d849150bf8dc3452839256ec4eb65cc9ef87aa0f90dfea4d1d486f16ee855d6c480a8fa4b6cf8d536e435f9fb7bf507 -b61c29121dca2bbc6024ad2f487bb57b926786ae60a9e7a721440787752432ba9c7e1df86ef0d74c2592d23f0e89326e -819630a678e4a5e6adbde9b292f5c8f2b6e3f2ecc9bcec60ba0f8502e503f697b0ded4f0f7157b60ddc976ded66713aa -b3525b071e26babf669ae2b98319b3516c083e797d74bd5b9b0e1f67792a2e8ab2c60921812690b5928de66290ff7b86 -a344c6670718b9824ae62b309813bd31984eefb5efee38052cd06812308edcc39fdee165f8164629267bc0e98fb50ba6 -81d78d54738817dadee7bf70a468a51728de0e9775f8779fea5d0d95e55b2004377b4e2db595d420f017af18a384d9aa -848c97b9413ba6ede751ece925ba57b8f8ae27168c5d46347d39e0232a5eb42069a85f1ee2d30d8b94fde574642be5d1 -b020048c5a5a2d186df628550c6f61a204f16e6eb991283e975de520c4f916badc999b3b7e9402ccc39db5c0b510e2d4 -9298c1aec9664ab3fe328f532428e9b037efe8412ccfdd15e33c9c82dc3631e49f84e0d2d75dced85e3a4e0fd0f3f2dc -8c4a78841f51e2f8b91defb0a3844933999f9884e2b324bd89a01e482756758b1b5a278289163409947c73106bf934f7 -b328a9db915c4bea1783218c7668e2bd7a8fa62e52d3a005a43590041d34ff388c0555b044ec5ff85368352a3643b7eb -8a395d89469d374c1ec472c4d571ae670849549d05124907faae5a086519686683c1773d22d290ebdcfb8dab926d10b5 -aec52b8a883f4ff68fa5f418cc91c8e9d08ef324544356b0ac56a7f0980fab6b376b8f567e357ba96b408652b8e568ed -af80f0c5d50ab23d8ad99c7fba504f2f02b7307b5ae5ff529142bead28d69c3d55f4e2226c44549548fdf761ce30cff2 -af73700803caf7b06f5453a620253731de33a458da01f5790106e9418fb59e7aecf6fc1d1b650e1c7b3456f7a55d4301 -8be3ee3caa86cbe21ce9998fe1c0de73ba6481125ef28e312002377676317b5ac4c27180086fb83794efbf86438ad27e -a0439d051d06a7fbd5ab83f32f0f95364bc043d9d934ac64df7031223e731d7992206879d567e77f35badcb7623f03fc -b99de1a16670fbbe3ec26ccd37399e2a23c96813c26428deda4f74dd3afdbd28cbe47e074379f6094b85176f8ab349fc -8a943a039aa33f38d3887de4e77566d446e87225bb8333e3ea991466c15c6487077c6decb9cc10e5de6af03e6b81a10f -80b109fb49ab810121fd411e4cb85773a1004af2d257e85ab5b4c99aad8d66e5803a8ca7b95587197e88abaaef0b8d42 -892148bd190b042fe9b7914b8aab073c0d19001158087077a5946690dd60d99a1ef372ac01e372a434d00b0568a75fd7 -a266dcc9ccbda054e396e1605eabde6cf79a028b697898090e9f34a4a4e0b771c121b8d470b14130a79cebc19f8d6e58 -b1ab30b97c76392712b173460c227247cac50597c036f674361c63c3638a4c03420fa5b7efdacd0496a9b83956cf5d06 -8a33c46084f669455ba089b369b9c8493a97c131f09c66f9347873504f35d6b94a09483b2775656ab32a12c7b9766ab1 -b77a7c1402edd9ae448b7a606ba2eed192a9bb8f852b647b6ed689b0a3ccb81a4632edbca4c113750f62643a0626e2a2 -8586e85e3bb07b07a39ecbd822d2adbfbf1fc66cf2377fbe6b1bc38369f86292c6cfdb5b405a0bc4d584c0600178321f -80cfe5b1b032d5a28662d13772fe112e9b73c997f8ef0fc796576bb39e02189c3ec0228d192c981061dcccb9dd3c4f39 -873c085029b900d1fcbe93f8789d635e3a8fa558766701ba9fee76dcf05abb6cef518f2b56c4ca5e26f3847cf23bfd72 -ae8075937a23505f51a1a26f7f54e35caadff44ffc43465368daa9c330b553cb4548adbdb04e24c3977e35a08841c36a -b1c7076afec527912f7648bedef633ea0e3b02e5fc3fc495779b93e8a9f64eb503f46a1372c8dcd8fc2572c198112da2 -b5233c4545bae360b07c4411776218a1d9040bad1e788e099f90149c58258ecdf01dbf246ddea48ac8fc2dcde6f34f20 -b62655a8376ce1ca225dba04cb29f1a95d09e1a20b58f0330c478c6acf931ae52268779d6cab87d9074a362b9e82b205 -9684e676088b409052773bb740bd3577bf0dc15d0392ea792393a158e643b165f8cbdd91cf355d5425682c77f2a91f34 -a892744cc0c428c97bc929913ada86c36f280f49bd1603e21bf6b6abf8ed195cb05b22e586f0c841ee02f234731985cd -a62c089a73c6dcf3f7d957719c7d452962ee851d6ed8c4b57ade8a1e57156762c348fe5f20adf6d6ce47b4e98f93d60d -91b29be6022d43937df9c597d19e23cbb83cb6f5b764e1f7db6cf60dd9b3e9c79f1f617c3101c60fe6c7af9b5719fd5d -91d13fe99d7dd7b4744fa2fde41bb51f4edbefb2189ef3ca5d337ee84ca3f728e300aec19b96dee18aec090669c85400 -b17a5328808ca929b794dbf0bf3a3fc318f8df144a892ec0ac2163a0f7c3a4614d7ec433b66bc491c05a286fe986d986 -84a9e84bbecfc2aaf8bd623d79bd4240c630b81ecd55a50198de21758255207238179a345700e65d9bc6eec1a1a1985a -8d428be451efbe630740449ab3677ce6f69d94d75c5a9d91d14b2493a838260d6418be3d4658fd15218eabe3adfe455d -af11126224f6ff0e88a09dbc0de6db3c70e3db3f6e154deb448d044100f989ea41c6c0259a8ecefdcf531f892a957d82 -a51716b900a00277aa932bb03fb61eab3bd8e74edfad6153a06f85aece6f832af710f1477d883dd8e48931deca12bae9 -9542a82039c2d3c538f15da884f090622c5af556c16370d21bdd6544208cb17e0a30e511b0af4a618e8ef70d0c43af07 -af76f93250bd7bda2b5e30e6f88416ef6fc8ce0cb614515a1f8d81dec717077209493cb47b79e8b1a62e09e394038338 -8fa8d657f1d584b06d5bf41a52bc2c73853e4092290789df04eb8952c6eb236df601a1c6cc81de420a424d8e748dfc38 -a6e93e27421b9e32b170d240b4cf2710c97b49dabfc0ea25759c5f61937eb3da8d45a6400f8bcfbb42bc9a7ae9b66ef1 -81848c8d66d34d274b21dfc10bb36fb9497a1b152aad64a8f7c874e58d31d5dd5f39e30e6000b6d7b444e573da1e043f -b85692a84154f87869d97cb5f16c81fb0559e097fc37473bb11dc9cbd311ab91a46b01aa9debcada590992c2473ef0fe -b565371692ab0f0d899d8139d3eaacd213e7d23d6f5df6ac3409c961aca019ce861fb4ca8317f462be01e8c1dc7af154 -82ae2bda0228d36343f6153fbc41fc5c79fafbc03c99a7926c624dfa28ed0a1d215e11ab83cfd438fe5d85d7fee50363 -923f38a2f839e165fd197e1711ad52673deed9774e0590ff63ff9a9985f99612aabe003b9a98db2407c2878abc6d9b0a -af8d5e1048de3b813308544705eeb0facbd604a0ed03e66c1d221be64cad35d71748d2a55d1ff3049e1e5053c7b1f712 -a90a4b3b9d3b7c87c34f85c7643fd67dc771caa940c9e2ea81294ce6c072eaed698368a0e8056d7b819ce3d73de4424e -93a106e914d2c6892fee866602edfbf8d03dea1918d82d511e528b99c8423c260c0d103bfaf9992e0e24638b913af737 -864cb44b1adf5a59ce7baeda0ddec3a0ecedd42923205dfabf30dcdb216a7b760d8895dedab52ee09bb09e999486b521 -acb5f2bc1257c49c7df89837502e699bcb9652567c1716513f258f021755092954f2dc65b9766ffd9a10584bba424c7c -86653b3a479bf6e10e781e316e61437af1abc988f59399bed8fb4ff128f5f6d53f50a293da58774acd42b8d342e52429 -926b7b90eb7d81fdad2a8a59e13b1573970e15c10515954b7c232c37955755b6758178314439ee6c3b0c881d4092c838 -ac05f011011a354f0e16fbbfb7e9dff03b3cf403dcc449eb5c71067128e314badf4d4dc5dca4b8616994ecdb15909c93 -8e063c6601e553f33abc64f9553db5a19ea794a1f254d5a5f7b8ff2db4ed9d180f68ec919a0f83142c5710813baef4a7 -b6e891dd4d44fd54120b7b8716292c27d4bc8744d96253a841433cf4b07895606db4a3cc5872c480616b863073bf77e1 -8dc623d7928234bfbb8cd0b4fce5c8d9a9db848ab0af967ba9c49daffdf719cf8b55e1dad0b7e421571b8770cdfe9df0 -b5b53f7d6b5d1af75e5a1720281feefb8c9039ef7f1e1969d83bed5a2f73cfbca91dbf4fb8179d9b0d3bd06d1207089b -a5dbce9e6db637e053b4b4d3df07b724b50d11eacd3327ddfc5aa8f37b9a5bf628cc9b428328e16cacc552c1dba505c9 -acb82d6c9af9af0dd426a07b1aec81b388b61042bd601546cde248730ef85a09016bdc66dd014447fbb56fdcc23011a7 -a41692e96f1d775b3a9378b3634495a8350dcfa52b4b2b7773b39d36f7d349fd5ee9a2b3e72769ca98f2319319890216 -a0b4bd6a68ac5735539cbbdd78ee4faaef7d6488eb7a11e091d94e315cfcc49a90f204f636dd8033857378ddd67cc153 -ac3dab32427b0583159482f73f94236980d69f9f8f781b93f44aeb43dbeaa740c77898c38c57677b42c248b9bbb1d673 -a6cd1090b97826486f59a056ed90cde29f2ed821211391f2f16e66f1e8914398348cf6f0df6d3acaadab31f0382bb5bb -abd1252b722aa56010e3bd4119f2a28a852e9ac1a8ce68c96b6da9d00fac0c9fa70e67cd4afd45e0a8042a810b8e0a91 -9194b629ca80b3bfefc0144553017343d0915aab59faa3d0e2bb3720dd3c8fe07804be6e582c6d57c764be96cd40f2c9 -b6bece03ae1c5935eb38b14f0f64d9d0b4410c02ac309e085a233c74bc3e67ce63edea56ea37f4532e8b864aecacadd0 -b753eb9184f5b30e77bcb5d3487323e0f1178f1ab3e15130953381272209a97c3e8084e810dcebf1ea7b22f0a90b9c77 -87dd4a76955bc98326823cffd653fb7b7eda5df1a971b72ec2a4d25fb3958b9d6092369539361069e7e4f1dc9343d929 -b0f1e8b25a2687d98cc037272473b4e3f33cc8d49a3c83a335d48b8a0d3ca5f84e8e2bde304ade6f7d50e5f3539d639b -afce1c0205adad1ce52fcca71a99cd6df9da5b748209c2ed1013b5b7d484b937bfbb26db9e9f8e77c081e0a0384114b4 -b363d31209c075b94441d1a8ddcc6bcf9eaee78f8adbf0992d5c7e7d638a02d58e19203247443c35d700fc8ac8a1b7ef -a0aac7dbb08a10f6cc2c6a4d37aea6bc3dc034d933f49de3dcc79bc0b7a011b1e27df7cb882d155287436b72092a1da7 -86dde01fb7090c80fb404afdc9ec64ac40909b64c4e16460a4c862c3a3f857ebfc0c3122250306c266cb1e9f9f245934 -8b3ebbbb0ccc466c72afb4c27ad99d2d4e98b5aee9c05bc283ea3332e5f67a3d9263b71d16b20db31ad4d8f48174b0d7 -8610c492ce130e76c06b7e0204617087ebd8f285cc3f007897c253a0e1af50f80a825ea7fa3167f882e146402fd342b7 -b17f04a257d3142005b8517dfb57d28661604eea9050ce39c60ba9a05d23897114c59c55af199ed186034e456e111cb2 -a04cd806847686ffe023db1721fffbc26160582c239d5bdef08f4730e2fbb64c341fbabf1fd831af6eb84a113ad7e2f7 -879018340deed1fc762e1b8f3a8b78a40539d6f917215621b725c0a3aa347eeff60765e5ad6f4a36bbea51ab77f88726 -b421e65891dd0c6641e8ddf479b065163897a418d723fc6dce19046501e01c616bd19c9d5fd6b395e65abe0ef956d53b -89350af1d432a8c209b69f937d2aa20a24d5eb95c5b4cec097ca3dbbb3ea9efcde2a8c56c58f8d7901b96a627c45df9e -a32d6b31cc9efbad4bcffd8b0ffa46b8fa97ddf3453ed151d7de1d03a02cf233f07415584893155d2d7e14b9534921d1 -8efad47caa32277eb04137c92def618e0715c1e77b5053b0cdd60fa03256fa1c9fba9aa86fdf1c04cda9c5450863d58f -8dff9d309f7294ba750158e70474c978d1dd98739df654945f5f29fedc607caa06b2866c93a0c7b830ff9b26955833a6 -84bb00fbaa4358a2563abf96d2434e4a26acda87b189cd8d2aabde1323dc1eb2eefcdaba3b90e9ad1215ee469745b72e -b75acb924159ecdcf49df587d5ac1b1b04291600a4f530fb7cb6231e7fd1029f8cfc957c891a59182518480c2947f472 -8d2c671ad0d442664a0cf267b39be742b1d3760935137e4c50195695bdb99254c4a4d5830634059d96dfb2b4e214b067 -ac27b31843caa8140e729a01e7d0229d7c221feccc89ffc173c11a419af3db0f8a47a41cac358e15ef41f679a3f0b96b -b0b3e33c590bc00faeb83f4b160748fea4fad3e21dfa324bc14a138ee8c5e18743b6bb27cd0ad7c7c28c2b3e92040b0e -b0d2882c5a0a21fe05b522f2e8a4f43a402bfc961874deec962a1e3d039e411d43bd3d95a26d930c2509aec8ed69e2e0 -aded1e47b3ea6ea7276736fbd1896297b9ead21dc634d68ee56c20fae3da90170f30ad0642be10929ecfe7de5ad8ce5e -aefe525c0dd24d6c0a66b43ebc6403ac75bfc322d1a22f76340948cf3536d2ae87290ca80acd3e55d2df9aaf0fe6bfcf -979d1510d3271ff1f06d9cefe30badaece436fae8de70b01ac843850f678aa5f48821dea48ce1c363fa35eec37283f3e -b8e8d10692f1bad943052fc366291c134a0fc7ca4696feb216aed46eb32de7333a9ba4f553389e7e58c8fa96ba023f58 -913353bc585c0248a54d4705b5e29cc778f304472446eb4baaf30bafa30f2ad0643aaf21196a6c4d177b11eb4e2ad5b2 -b25a0e3b9f983c47b8faaae8549fa7d00d12d7145e1b232d1813ff94058ed603957a340beff25711075cefacde767661 -8515151729ce9a7984af3b94f74880a2402ff853b99f924d581fd3935d8ecfc80e2a1185918a5b1c4902106bd1561ff8 -88e4282ded5e2163874f6464236d5bdcc3c484a0fef8ed0da8d0177973e8175432b75afcde2a4d7d6aefeaed52fbeaa7 -81c31113f2a5ff37250f395d6722a43cebe2a267a0ee40ac06faccaffd7d6eb522103f0431a325aa46a54e606b14de84 -9302ade30ccd62a803b9610a397661298941a644b1ee9d293c63a6c3368fa3557dcf6bfd0c9b44c5c2a6be06d1baf663 -b4ff9f1f6a2a64c50b0a16980ca7cdcc297c6f93e11c580019de52f58381fd0f60a66d3e010fa7ab56bdd250e7b2df2b -8e57eb61ed3c919dfa0f0cbca2cf559cbede5bbb1e89ae4849b380339cb1c567c98fc2c671211fff4df1a058d46a42bc -b3d5b45b4096eb088523d16bda1c6aacda01473533314961e6a8de36ccfb35d4b717eeb1ee1bce47ad3b80e9e5084d4e -b933ff4d3c5a77cd7cd32926266d4f05198178ce350f7215e512e71b07177ac1ff89ba183e424138e1fbf088ecf86c24 -8cf430a6e4eafd23bcb5ec8ca3d711bb56ae719c8621ecee964ef3bae7c53044f7ab3d5d0b911e09c7543e56c1e82e11 -8b3c34f5321c9ed48024196e1e941fb7a5975a045a5a9de88d7f200fc7ffaa0b3e500ab7b535e02bc5c35fbe420e2c3a -b3c235b65fbdd5c4c2aa45271b9e51674f9a0383a8ac383b0de53125a67c87261540a95b8f81ffe67ecdbf3955b13814 -aaa93ce79ed6e7084fe906c9a1002435ed6829ee3d1380681b902d35dc9e5a23a214ae12dd4fb76691b0016f28d43651 -b4c9533e50ec58f75ea82e2aa7f735c4257bdc1ecd0da0b6521d1442fa61f19e4f73cc90972b47a762f5cd9af591d957 -ae0255dd70befe7eb979d41f9a7407040937e7a879daa64353c66d524d3d3cf1d5e854886a6c32c142f4673c56a4df1d -805fc5ea840d1c2e6b35ce586309698530f056b41de7a403d9e7d81efc2d7068976e8e23bc0b9ee256f39b15bc4f7ecd -a8de5055b6d2310b6ccb211a397077b211683b05c7e68e55ff05b546c5c81522e6097a3c3b4b4c21fe06667071beaa4c -a4014d39b23c13efb4326956c5ee476b1d474663950c9e3e45aa1345037be862cfa14aa1d03bb388085bdb4ba9d70a59 -aebe9a9ba34d6cd3692a8bc0b0aff5648e16b36d6c123e636e9260386642e29d52ba71ef7778481c1b1cfeca7fe6acba -b59706380c9271918ee16a04e84e91046caf99623a0120aeb37a7a98d4c954d3d880960086de6cb180c8b922ca1d7405 -8dc0713371808850f2137a89c33fd55ec2df6a028e22b2679e09f7084d5c471451187f6488fbd9b5100b84593540e5f3 -b492c55e470c35c7a7efa536f3e7c1e586b623c6669ba6eceeebaa1f81fe3b8b927c2e522fb12e603ae246d9566e4d23 -a5148eadcedab9ae08f5db6265326fa415aef46d0b24155910210338500be6d77bc9fa6f6e284a4c2552dac09167e450 -a0af7b66c8a1319ffbe7a0180795b442cffde153f9a871046d6bdef959378c3068813c516e280371825af06ef2320b15 -95479ffc4903f252fe58632e833d63d963469e89744d5c91315d38eca21b98f1ad6fb3ca77d620a6f97d9ca3aefa1f7e -84861bdb5880f663a5d9b5e89b59a940611a233d82a9895a330464f7e9b7a6965c2420704f3adc61f876584d06771f03 -933c374f176381a3a63fa98d238d3b7d337aa745528e271168f5b550fb703664c3128097b927b5922b4ae8fad30d5e40 -a3ed2c5080c52ad1235fd93c9bbf128b48ba8abe364247104bbf298582930bf3faaa4f4b6103062a4696e68c44f79555 -94668bae91eccfa8ad459588f927bd1a169af834a76132b2f2d5cda26a91094cb94661e3c59f7547b290f827eb43125f -b704404a487a7dce87ea8207dd5d813378a345375e8e2c07de349c1448a39af8672bb4436779b3485adc46df2212f409 -9347dacaf6dd678574a4f1a95df79369e3f5543c565b1580f907ecfd17b5d6e1ee3322d83601cbbc6d6ffe0bd2833a83 -92841abd813bd9934bfe945e428193e33ae6d4dd235a16edfecd6e4184abefb8a1f85015ee83caf9532dda380fd678b6 -95c14a1d3a1e1ea18f8a61f34b85ee8a794c95d3b4b0ce6ffc89013c9a80291a9a2487b00bb3de51ca2e4290fead7482 -962fb52a2134123ca31d91027fe9fb62dff4e0542c66b55899a163e50f6ff2c4c4b9c1f5b5b3d6c6dbda40e757c0bd3a -8aa06ae95b0ff361dea2792e465436d810b86f803ba6121ff93fddd9ba60ce47e846eb2d248b28f2c47bccc9457c1ece -81adde02ddc49b6cc89561716a839fdee2879c78d1ea0fc0418a6cd4a2a8189a2bc245bf2d1e535dde07e93b8a5e18c0 -a7a5713055455728d6d982a6650d1edf1a3b4612c9072ee8ee0bdaa3992963a6fe91ca242fe36f839595d09f6a47aaa5 -93900cefff6f918dfb12ccbb256adec89fb8da019324b811398eea03f6fd34f28a6eac2ce5580904cdb289879bd4b4d1 -820262cbf7864213e768b5a38f39d27dcfa7baa5abca557ab575b07c33917f7b0f06f0a6abd81222fe8a5a69d95d774f -a33114d4cc3cc84258fdf252e754c8bb1feb6a130785d35a78b4b05d0f782424a5ce0f34be3c1a14e3bb1bc0246bf0b6 -b966ca0a11f0361e611ab2a8907f78a3d639980cae405d380f3a080125c734059acb08431a42ef3a60ae9331a07e6a5b -9305d107311654ee727182a1683f322a78fc637bc214eae311f8778773e5bc52063bb0a902a5a962a4a26fa0cba3b06c -b3dc808231c75e681aa2bc4358c41f01e371bfa5bd504e7bd2282e35e72a2889a51747cc008dd4d8b2a070c8e4c2d7a5 -8f05cc76848367abf2020461b6bcc1ecc412ae9f114d44715875f25f34d8cd26b84b01fd6c0640648676b8d2d5120814 -8798c23f0ca8a7b23152ce17086f31e2a80533067f15ab4a7b43c127a5d8af3297115a3cd7978ace811fcc38805abccb -99a917f54253059a45103e15e92e1bbdb03e80584a85b658f231aa5947b29388f5b04588de1ed6de998741d360015313 -8b0ce3f6afb5aa83ff229ae1ee0f986ec4d31b113070c7ef3c1ca3613d74e3f23cc1cc81957bddc709a5c5bd85cc64f1 -9035b71e4cbdc7c410fc03a85543aed34a1c0a98e07ddc933e64886f1796416ff3a0f7754b5246ec93d617aad0f53d5d -87478f69c45394f94c67b7196f60aca42823ad92ea86a427d705576fa6a9bead40b1a4106767b8a20411e757f8762b68 -b36901adf577f159b4263821a48fc5888e7bbd6c9f3857968a9cd02e1a1a788c08a566b7bd5bb6be294fa5ab92b4ff6f -8a738b1392aecb35a5a1f12920522997c9016a0455354e41d2e1b81d8ec9b30a90f71492c7bc122505b2ecb0654545ec -a5a422515f17f2bf4b9b6c4b5b94df27ce80826cc3ad2a8579eb6666c67a96355e60bf227b36e1f082d749ade7a38a92 -b6d0e36a98e0518b14728bfd79db76c408f58220111e8c4dbf5bcfbd7a85bc68022456196f07b9f40158037a3c3eb90b -82ad91b812d08bfa815a93b47bd3656b493853bad52656450eb408fc915e430192ae123fb9daf4aeef4608800e818b74 -b8ae5b30118dda7b972464e14a96853147c4b362e9cde22130250447575c0d8d05053202db4c650467dc16330cb54b36 -835d913a3d15ff205497b98107eca77058beebe1aa35ffc20241bbc2a9b4d2019ba41fa3c9b43fe2265a1110b5c2fbe7 -a283d88acbddb50983356f2aed99c2f153b6a8f489b0597d8db08ff7e3b04392609e01aceb37fe985f59773327258195 -b6927dc3318931eac59c6e21def3ca79154beeaa4c57e11ec1f3362aeb33445366dae770e533aaf33c273eaa4f54275e -a6033a62119e077b438e0170f27835597e21c1d6e4acbd53fec7df69bd1372148f90966732fc5c004857cdd44b8a03c2 -acc764a116e31d63f534b3e0e42a3f899d817d3ec32fb4504045bce7ba3a952ddc81a33d48c5b0499eacbef4268bd5ae -af5d1f6a67dc6361e19f222a24163be388033a3fd0d33ad204f4411302668436f933c4a91c6472fd4262397417e3c588 -a2b1fe93eb481d4fec6fccbd64945a12cfeca85aa8b8bbadc4e4ecab2f3ef65616294dc168d6c955744b7c6acd712012 -acb6d3e123572ec20d0ecceaf4916401874f0298218b36a0ce089acef90329204611968c7397c2a518c0a78d02a9285e -88e4457b1c9b56957b76a08e98c569fb588b081e0e420a0d859b70296f648a8d64ff35ca61a39d1b8ac3613ea5fdc2eb -a7d1643b3bbef49b2f9fff326061cc27a7f65228e40929562de73e1c66a9d164d42bfcc3dae9103b2acf27606f18b031 -a66e3b97efb7ce4e81534453d3d41ecd4b5b6e9bb829b07b5afbf11fc6ea30382a0059c33c97afd906656ec19432830d -ae9a17d0044abbf3e6aa2e388a986754d6b0fa35d115e410f69ad4aa114db1af5dd0389222b838cfd859d436aded1b5c -a4a66a163365528b08333f15c6673ca48d7a9b6d17822f1e5390fecad122bcf7ec5656eed2f22fbc6ccb6dd96ee260f3 -b7dd42c938c2ec50c3b3fde92ff629a571e46f8ce128fde7c2d8f18796ba1b1d7eaf7337212f55cf5cfc540c7d2dbf31 -a36bcad22f3408b3bfd45d272f3387cdfbff57e014226dcd1db54bf3f8d1d896fc4fd16640b5d1484c9567ab9322a37d -8c9831fd5f74ffac203aa6b6ce03acfde8a2fd939b79236a01931d28b424fd8f6b6e44522d28e086aa12f0b110e5688c -b48bc95abd331d901610335299580ecec02a263d2b03bb0579cae3aa87ebf5e93dd110e7fa4306d31974099fe6e8f58b -a15e27a87bcd8ba69ebfb6228c3c48e19d79b22978d3a63af553b3083ad13e48dca496896cec195e63b8a4e2c40cae7e -96f3de6fa492dd2d653888311bc918ab832d6342dc7af9155bc7070004e89ca940b7672dce0a1b4976a7c3018f13e49b -81a022bee3593997f556ea53e2ee484188cfba0be4b831ccc048ae4b5a6df9e3b4d57c436caae5cba92486abb71813b0 -b9d8e46df67e481c84d5520a9613aa92750c8e8a1e8f376b8ad7b71a3ebd95d2d191ce538e6f7fde3ac5943f70c670a9 -8f0b52365d944f59d2ed445b6ecc4f88c687fd281c1913912c8e6075c3a59667060b42f2c1589a5955e9f3791e23aa02 -ad07429bab813045fd909b928ba4eaf262b6ea40b353aa43157e1e683b2752c5bf19eea7ab6ebb8daa8ee91241fbe84f -b90a99ec1f31c43060ef649e047bf24f2fa7fa9daf904136c6a5846d9479966b54090ded7093e481c52d872c6377eb65 -8cb05fab3ee23db24c9bac109db52895b200dd115209bfa41fde510b29d9871907d44f689fa0f5474d12314a711f6fa4 -b00d8f280ee21866b01ba3de3bf943a7d0825ed67db03d13a0b69f54a4ab389df1cb10909e831ec0af8f1675fa7dc399 -b383d14fdc47df80be46390420603e7f505052b1a44ebf595354726f2b487f7f18d4243709d347e1e584c28167a0e988 -aa951f60d1e069304222a8eb0338a94c8b3b4515d7cee833864b6c222ad76f6c48e0346c5603c35a3b52edb6f9381911 -b887070ecae2884109eed80ff9341f5fc514d59158f5dc755ea46ba396f6783b8a86ffd2fae4419cec2ed57f4dfd4327 -b1a6f1e4d25f4aade76714e52bc426beaa7592b975f07d0a6b372a3f94e7a3ab0e8829575bccc953195ba0c9bf46e68c -aa64bc4e0d9502d294f0d3e6a1400dc38f28e87c85d3429ab3575c821e1229f1dc8e2c13f03080006bc897e8fc3555c8 -8f215476d94bc2af7d2e0eb68783292e314c9a4f812f3065cf064f427aae165990dc9665011af502f5713f3664317989 -a578c8991e9e29bf3ad7be44bce3817e1c4af3e4a8ba3d82643378da78538787f581b9caea7602b87619e5f8cfb337fc -abe5453b650106cf65bf2b7faf8ff973b7b3be0e6f42983daaa5359dd4ca225edb7228bcca3d71bcb8d77241b320fa90 -b7ed1d027dfa91d0ca5d797295e359bdb1b0221b1f5eabd2ef76ea3bf456f9aa9788dd00ea24fe0add9e3d9b09ae2428 -96ba0f0c5ac0eae3f0031f8b7a87543ac369c22122681cade0ea33a6ca370cafd360ea6b80758476ab94cb07ad6820e6 -966f6191951b998202b8a63e3b10ece69616b989e9695cda84a450cb953acaf9c4f902200b7492eb66cb9ae0cdc8ecf0 -8d7bf21f76ca0e3b3758c293e66e977f83533d918dc445a09f4f38975ccf7220855627de6460d318290daa03a5f5c68f -b10dcd91d6602852783bb76b0a286523a0942e8eaaca4e0ee5bc76cf19d33bc631f6d0fda1c1ca51bb3d5d5c7dd43728 -884d502d934e2b045357e981506900849e6eb051ca3ecf3079b485b348372496db97da384f8d2b5a52216b4d223c90ea -b074162e5d33171477ed48f2f185b1c83e8fc2e7906681f96ed97da8ee86be7476d65e61648383c2766ad9853ead35b5 -90bd3d8b475da20c6e32324e30bab475f2059cd81fa67840a6c831026cf3d5806496a3a25192128da4b819c1b7cd6bd8 -8da4889258cd6ffdf1608af8325230f74abe6a2a511872c2dd10123b491cb09407fb979d80fb1185ebedf421ba22d0fc -96fe1d9137c24fba18b1ac431ccffc01ef1792623bc334ec362751b7bac73c4d4f7e9bdc2d595ad4731c71808adea15e -ac816ee0b9103f0bbdb50cc05f9c5c8f7ff2f14bb827541c51ae5d788f979c00fe4796b86eb9e3ba5d810925c1f34a17 -b231e98ecb3a534dfda5b40916fd4fda270e316399c9d514dd510f0602cbc29e51c5ed60107b73e3c9721f7ada779f91 -80115e104f22ff2653ba7c4e1cc417dc054663d488f861a9bbec4b9e907dedbb985e6e78f31dc16defa3aaf4f88dabe8 -a0dbc25dde933e6114f2ec22445f1e209836585997b14100f3f8b7e62f5fdc6aa2a85ba5ec39a5197c9d4dabc9a5c452 -8d2deffdeb1f0abed8ba62187f5e1cc06a1e2bc49b3e15f73c3d8e574dfba7efdfb762ab512cce53d7db790a7354c56b -b73f4897e221927feedbbf209e3d5b9c08f52bb732dc0d710822576abb7ba5ef0e728d2d95c802a00eba925ce99d734a -970761c7ee891b3ed08253d2c0d28478145d0776e2429c85b4734e5eb7a6416d197d0b1ad3392b37ce8d86fcaf9de7ec -b4c9e2acb4c05236357be37609abc437612244bb4421d69486050e390d5ddb52887a1b3e1bfe968a90f1695d892ba8cd -87caac2c93e192c34b5dabc36abe26a844a33bf63e9b01a668c90b70701360a0417ae3248173450c64034685d913f4f1 -a16ac64cd1a7ad46cde1c93024fdeff724afe228818b72bb66176c7daa090acf58e7fc0aabc582ad22486e46f0b96c5c -936bdd6d67d666274c29765690f4ad9c4b9203e9bc9dd5af558a8d908dfe8d6d4346f6fbbfa69158cdaccb0058ed0193 -b39af8d43ce9d120497888fba0dc95ceeabdd3d84421c1a30fea226e03b78cadca0eee57db524f6ccf1f6235fadd1470 -847da75509ca07fde2277aac9e7622c5874256903a92f7a56382ad3f79d1b3b0cc0b06b2a6b2bd1749ed567e68816d31 -969407bab3f8106a49be63f17ddd603e185afc1c9fc0ca0e90ac415f53923e3c6a69fe488d33403521231c5008bc11e4 -82e25ef35abbd9b98c55a45e7a71791925639afd92780e64a154ad8a94e9807f2643854250f30bff1c5e8806632778f7 -8e6da5cb8cd80d6b8e2321ba3f034ece1813a7b6ee3afac73371a51434a3e66221188162cd9b9ec035326e7e04e74b25 -9868bc3e60478fd0ce37d35e0e4f7695f1ffb7cf2e05842b3a09e832af33c7ba48448935d425196fdaea9c3e8a5122e7 -ac7733adfeba1da388eee6540a127d0eadcbd23770f2deec39edc0bfb1002beacb9a8c7106baedb22e664f37771c1410 -912581c23e3ad0d7eb886cfc22633fc704e530b6b4977086f68f1d9f839bbca3bf0162acede87c853e8ad8137b5cf345 -a0315fee6285a33d4ec60f6c1557ebe4473e8990ade0feff7e008d3be1a709f5f486abe784398734d9ea1193929697e8 -a44a08d6fe0a22849a8f518ed9b30b78367de205c3301fc8159ea273076488299b35c362530436dbb7e21b6b9f36835c -a591ea6ef83f2ec78a402a86ae5b82e330998e18ce66126a89046f169dee58634dfc531b1286277eed49f571df5202a8 -a60d86619b41f59b48c800a302775656266725b44ff8318014fb668f331bec82b3b543ca848a7d40b2718f29e5ce6cd1 -9420d0219d407583fff43c560964e1da06b105043187ea156771b1e4dfb5d5851d06fcfd819c7d8bb6568fa1bdacd916 -97ba0b6731c78eed331530be7cc374a7f4a7cb2144ac73b7c000ca36036f68754d4edccf73ce373dd6c6be55177d89d0 -b4e07b5c1376900fa2dfef8fd1a5a4b6152df7b805d5efc29057d1df2343f8bc841284ed23d2bab5cd1431fb95f71b60 -8017de31e62a24bed74460dbdde1717f3a9cc17e2e2ca9848d77c3b5c364e7e1d58ac0eabb3daa2b7336edcc8a418b01 -ab6e409231b778bbc1ab74c3062a376c5287c0cbd7d19d4ac1d5da1a8d0571864d0723944da72581783cd7b6b0d529a6 -b5f2fd4ef29a2ac847358abf2b3e7a3567b8653a4b9ed8da70809f2affc6ab44c65cd17f255db0cd8315e4801bb1a408 -91b61d5d047e9c672d7312f563b8da90d9c2c1c1268913656f061028748a351e116f524593b1be7117a46f168b3e829a -b6c10b09ecfb92168906191756cb824694caa32c6f2f9b19c51658d44dc330dcd344e7b04333392a8a93c73346a3845b -9431d01a121e6ffa15c32e724dadcebff65f806c11717b050c106c0c80e43e622130f41224533d13be4a8d14a66ae1e7 -a1248085c85855b4df6eb5a02df0dbd5de5a8a82656e1a5f61214885fcb75428647c8545a848960701d61c3002840647 -9867caba8f4be9483df9b48e2bfa024e79e6797adc2198f2b5115d7283931fe4cefc382323edfa1e850c3970bd1a2d53 -89e88c50c43d7e966e60d49b3afea792429563c93550b10584c91e4a827a3617971eb286c39205e2af4e7dfbc523fd8e -8ed261502f95814410fb081e7348eb09f3a3df22cc3ca82a2f071abca0190e9f041e8714b811418caf7e1753cf284e9e -87ac65370073b6bb85a945e138e4d0a5d71ed88739f72b9ba747d2a03b5d4877e8e526026348d2578c752bc4102055ed -b07de38d07906dc2838be840c291f467d9b695c62175c5afa46d80f34674d061107d6fec6847ba5f17f2d8729f31f5f5 -899348bd385a7c3d38f9d740001c9a543dd8496b58807a6a73180c94f3aa5c15a56cbb85cd7124458e2ae44a454a8a58 -91b70c3543b8e21cbcc8a40cbe00cf2ee0372ba9ddc7f610b711a070110508159e6a52e8778b20f0194ca09b109881bb -8ab84d75831ec1e708ec74eb6d6de2b13bf97e2d2262ece39e5ba5a4a3049c8303023e40fce5e87b237bb1dabfff5246 -914ac70dd91ccb6d7b83a5ed0a9250c66e77a815aca17416f1796fc0e1c26bee7acec5de11e65061a44d2d9c35f5d19a -8867260f8024f533fcb75d9c3f2ab113d349504b40f650a2c92bb46aebae3a55de6a113cb6387bf00eeb2bd4719d87ea -9976dd4e56b16fe11533dce2734e2903a3ec986dca6540bd9ca8b758a59a1e45b1e69c0b8f094d42cf7e015363ce37ff -b48c840786653a0f3ed6b07f8f980284c5eb2dd22e9ecd5a0566754a1534300e129b39a8a6d4fc48bd403b351e714f05 -b1633aae7c5e5c51a82aa4e4bf9f92c0cd30cc1067b03364825ecc492fa43391ea075195f2f73b99a11dc49f670c0e89 -8769a592f503bf8ab03d767524d9ec2223c502ebf15b69eb4b3d53325ab366888afbb668bcb380230b5bd74b32d90a44 -87439671fda66bf5989fe1fa2aa32519ef908aa6ab3eb34eb5b7d908e9a7db2d679170cf3fa0e0a388a355b8c51d306c -ae1ca219832c90554a91a7258ca5598f8bcaaa7059c574803b2688d8026df9083985c2f8f4ad3aa9b122efe64e0b2481 -94916e6dca309d9c7afb9aa4c0bc89a3de875a8537cae1fd32258b34782994e5be5c4987577d697ddc86b8d68dbbcbaa -8c5361b85176adf77ab1949d34edd562d8c16979e33b59d09548ad372b8c913ef385166bae53c8fef814a529fceafaef -b968172a6a831c6ae53e876dc4ef8686879cdadff0aef4147c4dc3ccbc173f89748b840a30ad393eaab69e422363bb86 -8fabda060f8bb2bfcd675803ff0a3f834e2356152f88bc79c23f58fbfa6b0c82850f281f7b8fd2a5e16230aeb4077320 -8e5c887c318335c5561e63fd3c3f64edc669c0b03b217e3ae40ea29245885442864dde15751d7c6ab177a91fdc1f7235 -b2f67f9d64650c6b51b88e7ee6d6a796b453131c93a7791cdb2d0a4922d3c913a4ac988bac5b4b9bfe61469886e1e7a4 -96b836824dc2a12ffecc6a053f7549b7faad9808e98bf20f3c9146fab05098df56fc2833a6002eb39c935fd8757d4716 -a4aa33fa77b62605f751bcad91333659e9345967845226371e5f38d5a7f72405d0e30777b485b730e6c62d8216790cba -a041bf3467320df4bb7baee569cd685a65c9d0e431824b7de93ee47ab8b3ab20298d60746fea7fefb5bc82d3f7e25dd6 -a85842f11f490bda22e9f73409de0909a2e61efc6d8be0c3f561d881988b4d2e6924ffaf0a4c40843481892b272943cc -94de0ecf58ef27228f5afb12496c53b075bb347f900b2df98f47ceda8675bc2941aec04d1c8ca0dec0233430f2759824 -b1795a70651be509c0955b07d58a1b8655a2e6c292b939b6c156f0c0983abd7e416cb0cf14afac6ceec85f2c46b83a28 -b6beb936ea1f1639ae59eaf53015dc1855ca0f798d9ed72607edbc6c119741e10af5354c29571af8befd83b8255a8f58 -9424188ceb15c1b470c4bb17c71a37af56c87625e7b7fa752099802673c3a5a99d16e7d6dd8f8b680e89b75cbe7920f9 -b9e22b5df8318bc0ff81003e8208ff3217ba1a84edf6a0b326b7180208d3a9144c6fa54c57ce6d6071ccb1a40eaf4509 -8e5fb55da49feb7a9152528ad6a6766af75cce249eadaaf4806c6d4162f65f3c7311bcf8da72b96f6636cc019546c05e -a55f751de82aed5842f94d1ba1e29976c3d0146267b11eacaa4fc765da8d2acf617d3a65a2a74aa983130851f8c57d05 -9647758fc596b78fb52db58f2ec31cea186d9d4f68692f56e474961b277396af4a51781b0a358a6a6aa8138e46443a43 -9461f6dc72988b44c662865cdc01c0f970f078637859cbe6314fb17d2cfb3451b222cfb93a5c6eecafd1ddb36de075ef -93b30bbf4fa0926cc5483ba9803c8b001aa80322addcc866bc514f2a10aa43bbd86008e4671ea26d8e0d2ffd4bb8f2f1 -b44020d0f062a001bd6dca2bc3ce61b17efc7a121a9035709f01a8c34708ed0c1c85cfe98c534189e0669eea719c88fb -afabce43f35e0d3201b60226c72c30177c4c5d75bac654fd2b58b3ce9de7d83ef01be60514817f1e7bdb525c910b8bca -a97bbab394253ebb02ba47ad391db3aec1b4d03e88ab3e7505730640558c11fbfce42d53b7f85787cb564208d3dc826f -805a34cb0c8c7ade28c69dfdde46b7a283e539977602aab165316e973c62bc65396b6fe2c96750ba028c550de03100ea -a0be38fdba281e0c248933ed73f1119f90e34d5b4435bb704a5fb7c20805e195518a2a424bb483f16500d74f440d4a53 -abbabc7db0a20030c6e687b89162e704720a010d7ac53b9766a9ccb7e02d4ea1926792f5263d715cb97d67f2010288c2 -b9e471a7a433a678090fe4324739dffe238ed7e9a867159e0b43fa80c9c0798cac6b58bc09a389223f94f22fec43e18b -9818e9a42ebf415c6d970c87261645f876d709751c8629d1ffbcba4abc8e3a2a1db8c4c6a6324dbf433c43fff62803d1 -8290ed53eecdb61157cc458dd081b9e890bed5e4cfb643d11b549b2c65fe68fb981d4311473510781945b0ee763a84aa -ae730a7c69866f22d8f9b0d8e17d7564c25763cc77a5eb718d5651b9c5198b2b9d3eed1c066f4985b2f6d7edb0a109d2 -88325e421a1be440175293efd498cd167dcd0914c8827ebf64ad86788f1fdeb3c16d3de7a681f958b0f49046c54fd804 -a8f592d6ba7fc3ab8ce8260f13f9c4886191530cb1d7505d0beae54d4c97d09712930b8f34ad74f1ac5ebedcea25dc8b -81c0853b0310a96674a92a144a14c48fcee0d72a772451ed046c284f16fd6447f67389ff7841d752a025da172d62e73e -b9f50526ce4bee12fc3fd8f3582f3829b90840f6eba06f37b53febc1d0987bbf58107d73fe4373d79e53827270bcd817 -a2ca28f619d4821f450b9431bdcdb129d4f35dbc2a4976e4d416dbd14e378d4d60a517457aa0343f7a5e60a7e246e22f -b9576225cf7e13374d3975703b3850251d53ccafc6feeedd07be2b0bdea63b899139a1fb446dcf76f62f3c03beea0486 -a88df9f6e95df995345c6265af546158499fc0d89447d3b387e7708fa037f95ac9c4e20ed35b749b8d8a7471dedeea87 -a853ec333af8f35d51ddd6c4d45972b68fb36219e34278efa6cce02bf8193d72c6014ba6961f8448785b0a43a31a688d -a1ead9282496e590bb43908dc64341595cd22b844624e02f2daf597f708ab0d336bcacb5862bce3ce23d1a9616fc6179 -b97398d8ebb52535a1ce3a10b2255d358142ff653def823ad9e9ce4ca5f372c6e7c9301588ae5d914b2b921a0fac7442 -8d0d292c7e9122b8d001b3a3323f9d37dca61de5a595f9402ab0e53e941c83f80237a853abe4aaf012a35cf59df48c68 -830535a5a8268d5ce4e7462fca4f809348908ae7ee117312244e0a9c30b09d91b6f798654d8064091078400346614e04 -a44a90d3d307ee3a3c3838ce43a873311789a9b9292c62a01622bb813a02f6defd21b0889cb6dda6d7225009cc6d2641 -a219afe00a9327f2c937afabdf5f10bca0687f48d8f7a2a046a52e6924af613f38cf82454df4f412f5991ba20b7db74e -b448ed4b15ced4de098781793a6e850ea1547d514646fb8f1c137c86e14231ac4340b308bf07813fb813cd02e47c015e -905fb68b8f5bc14834a06d61f3da686bee77b3b590a33c640c82f34e68ab993f8c4897df463973d6d9f0d53f9ac5cf5e -991cb6857dd0b3ee6597aa2fb1f4ccc962cb038228615466964680795587240e6ccf7861ec220a53ede1e2e9752e1cb7 -b823dc0249ae72e2de91108cd4ae6d6af3e464f12a53a46ca583727c7351a67f2d12c911534e234ee187389fcbf1f621 -981ba6bda1816036e75a864f635629a141905a4805c706260e7a5e12b82dfa9de4f4058143065b10a1012adca6b7d083 -8bd8ec0e77a6867057e5393d82132474eba9fcc4bbe025544bab0ada4ebad3d296ceffa3788acfea0a44406e2ab637bc -93eaca3a7f9a0dc809eb9f604905b0cab18750a9bfa42d98d99728a6de6e0f1e05b6e98bb3b0d9862a69eb57ee2e18f3 -90b077d7b7b1651ac0d723978b3e408191c2b8b08247fe2a7fd69afe0615dec09e43771cd845c2cd064b56295e53f634 -847e8f607332129e95eb1f3e00003b087e92ebf1ac9477304b0d54ea38419fe8581122d21bef8d034f788a9c92f4ec00 -b0301becb003dc7cd56ea7d830bf0fb4b85bdb33606d8d9ab2b70c6415ab5c8f4934bb7079ced16081b8f6d16b77c0c0 -9068fbbfcc95fff7ef79ab64063dd9bff0c40b4855eedb39bfced9250cc351b5b3b1bc6c2d038cb6d59a12a41b3db664 -84857e081fa1c6c08bf7b0bcfe7c6d74b57cbad1b67676e99686bcca0b17715ede19f826517dce3f84cfa014e11909b0 -98fbfd6a94ac3e4b53b811e4d275b865486a52884352ff514889313c7a15b07822f76d428533a0f8d3cb42f1e6f72356 -b4faa1b1245aa6339b5bb987f3423d187f6e7e5d4b4b341de87ebdea53b124932cd0e586470cf4a3b1060a126e4ce7e1 -973e88d073071c2cf5ed643d770a45f6be7b230896caf72a2cef10e56ff0a4e032d6ae1ff4c19bba2cc29f29ba70cc19 -8d40b3285879fb9ac0b6c9d92199afaf4716fe21edcd56b1a1fcb6ed298b5ec5b3b64222eb6f0cd1086d41872911068a -b5e338a02076ad851778d590ada4af1c217d035c2505b891163689a554e5a957219410bbb435bbb38c8a1515146f8789 -b1d3e990d027a38fc8a38579e39e199d9984dc6d857bf51e2ed5fae061c8723fed3c74662405378c29342bc4f1fff7ca -8679f10f866804b19dd0b14b24068c1d32908a52149d33ab03394990cc60c0f388eef02bc0db819f92f8197b1fc60c17 -aee5157db1cb7ca8013b0c19201ea1e7af32e4117896b3f8ec0ef0b2a4ded6a5e7c893281865cdae7deff4532a6a3fe0 -950315818b710d3903b679dd0de0619059bea7dac3bf4edc8fd4a6dba81b7aff9bca7cf1972940b789458f287609439b -ade345a6171b8e8afce7a455cb98024d0d91dfa347632e1a5a40721868bfed1c1959300f1e1e39a551d99a4e1abb563a -adde1719c13b3ec224bdb6b44dc2c5f2daad54e7ee736209653a0198a769180019d87fe6bdc37ec1b48f0212ea5a8927 -a3397eba3ed2ea491e8d0328333689f66b2bbed0e1892d7b14b2aa45460a12e4d592d78a5d0ac20bd6d34c88b8f1f7a3 -8613160aca85f0154e170b1b3f1052ba984f5c422c4c25e0771a53469c274130a31f875a0ba9650f77fabd910cb10467 -a91ae4d048c56d5b2383a9d8f6396837543b609d8b0be139ebd5fd31fe4a90071656442ca7f14136cb8205734d929b5b -8e42732269c77887f105d1c326488025f9938cbade678bc6b39941311360408ea6baf274bbf5ffff996756cd2390bf1d -b96e1ca66d51a186237fef402bc4e14f8f96a138db377b7e2c3243954b6f47ca75cf4fb5dd081aaee634b5e2efe2a065 -81d1c20d76ed054923c17b362b50205050f185137ea10559e35ee7e191bd89383b68179c0aa4531eb61abdc239ae6891 -a350b5778e26ee808466619f73900e09bd387849d072c0c014517d16adb4e3394673238c4f4e705d30b4ec2edfe5a695 -a13657433e39c0241d48075ae8ab1efe3680c96d078685c5dc0ac3c49d468db98f2094dd4204f44e8e90bf54059b5807 -a96255abe489be9d42ce6fa76ee90e4bb6a36421fb78068432cc935632ea5b5bb2ab70790ef79422f93d35d1034568b0 -b745d643480edb577b1f92ded38a522236fa1be2944ad8102ca64c3d55f6297b7e0aa1beb082261af1cc334f5a723614 -b235ccbf94e2bbd3c794bcaf84266141c0e04ecdcd7d2def83a7eeb86a2ff4dd3ddbd8245296b27344770f3d5d332f90 -935f3e4e9dceb4f58404ba1a489985001827e96bf6be227a8ac4e2eb8a950d4a446320ce3a245d09d2d74776c7033a3e -99cb7f3d6256ee8918f40642f5cb788f0047a04c482146e70687c3298629bf082dd98d4a4c222fbfea3afa3d7d806f00 -ad6abd2fcc67af691e76792432b83b8cd9b0a9e5e73de21f89ab54081ea002ffd904d77ab8efb6906790987e29c53ff9 -b6de4c3a45ed7898abc037a47507f46f7327c057a911529d3a671286f98e79a421f4586a7ff3235f1892d0cbbd0e7bff -9120311b071d38214e39f4b48ce6299ae9297c7b76ab364353d3816669cba56592fe4c7f1f93507bec7ddc1df471f0f1 -a6daf71681485d01ae7fd4bb81a326d3d2764bbed5d3be45efcbc04aed190163ce8f9d04a84bacf25ec151790f8fe917 -9534da45c2a497607f7440f61943f4c16878a18f0bbce00dd644de88383470705b489225f5be4428d1f988256b70c926 -b2d1b633b4832dab1a530a1d85415e7fa3e4a1fd383ddb898a79c7ad028f2dd8fbd56b83600cf481eb14a073cd65431a -8c43dc994dfeb5f22df9560518df32deb1af43f254acb8e6f93eec3fb3ac80081b39610800d0822246e130e8c5f7a067 -a18174ffb85d13b7edde5822f22872ece12383d79fbbdb8c02bcc9f654cea904ed8c03b8709d70736dd4b308ecc1607c -a54e4bb27d6d561261a3fc48705781399f337448c0afa68c074918d2c14ea7d51263199b01070b7161c3db8b9949717d -a7457cba2c5b455584980ab6d0bb5253dbf2cafea4efe5bd769020b970dc35fba4109d002f5934610b8b4a158252ebdc -877d4111f50f77463b60e07843b4521b2c44629a7deff20dbabd412206a4fe03f976de1a3897b9df7eed16217f03e2c2 -84d1ab99732fed1470f69fdb499dd3de795b055354e89d522c6a7df4d6a5375052c8befa4dc7615d29b3d92ce7df2f24 -93bd139c343d8b83403e04547072c3e546c67445220afd06c119f7119730288629439640302d0628e74fa596e305c0e0 -8157b5ab48d026684f6b51b802b4d8e7f85ef82583d1e8dfeca042b47a0e0f58e30cfdf4738e6d51394b260a4ca7e19f -8f03d5c1720540c29a1dee44ef5c7f8b209094ba8376d8e5eb9b52537d9843912b68562eff742f0a7a07f5faf6abd1ba -a15e4999a0028b8b083c2afbf4968a1f0397c26cda8dd7f6c134c6a860e740ac4bf1a1936849a4f2080e0cc9f8e44387 -8b71fb85363158c7afc3c41422e9a32ecb2d1f9d3c01fff00b77e0ec6a8661e95b552a7f05f4acebee751448ed750684 -b34125432d0704c0638090fc4566780d2d8038d803f96e19ff748325f8b5579cb8867e12491921feaf3c0df949f36aab -968196e10bcdc6cba28331a229acd54b59edaa83cad0f8d14f39d787467bd5ea725a3dc3d50accc334e74c81fd762cff -968abfa40af365986e68c47b4eb3562a72793fbd66a7d1b3804a5bac8137f0a3cbbf5cd306097cbf1a3b95c3414fb061 -85395fa84223dcc16b7e620a7ef6f902f7b29dce7760f57baafb37d985755e65623768b8bd745c8de7d00e2035aba7ab -b57ad86ab3f5cb00ca0855088921865893b6e539edbbd504238df2f9b2fa7c7bdbf2d6eec6ba8e2a70a4c4fa3f459a97 -a2f203ed1f07cca3f8c0d35ccf7a63216ab98c9e71557e829dea45e2c723583bfbaa7a83d66521b08a0718c63973a6b2 -99a3522974525f4ed10623bae83dddace6f9495687cb9cf4ef52c8530b05672c2b226d3fc5058c56462ab3737a068baf -a4a50d127ad06067f1eac2d61c0a1e813fceba2e5e895467b5e6045c9b7308d3678bed9212b98e44c19a1783e0f57bef -a62d103ecc1d5e1d5cb98a0bbf9682ad65774d63f67f95bcbfb0cdb5e2437f2279043e4426d490f534961a2487782cce -b12fdaa5ca77456e6e96eccf97a303ee2d73f547916ed67378835402136c2aa03e63912edf5a67785f7ac1636f6ddb51 -91315750043c4e08c7e4359b9cba25309eedc9c85672851f05a0651dd9b9329bef00a79cfe73ddc308d97cf548486b47 -947115aa6cb3c635bda7f3c5fc3dd0e4881500d74db4c0579e4b9039b75b131eb5db54174b1bb970064740551e6cd1c7 -aff091a9c7e86c80646cfffbf154ecbcfeb66877c5b773b6e8759649ada1094270e57970cbf2b0a4bcde9bbfa9689b1c -81e3cb9116f81e583b7579f9af06931a5337fae0d57d9ef777003f32e0eb619b75b74137385f9e30dfe0e10c2120b02e -81ab49647db2a5a6f47ec757d8427325fe721142377a287c547fbe04ea280acb32d71f3dedf7ec0f67b43ffc5d748342 -84b0e16d8478b798694503ac4a87ff31affe0ef6d2bad47abe0fcb3a2571fc8e4e9c966276a5f4968b2675827a115818 -9567b2edd65974393cf2181d235f877f5827a6d5ca16e77165ef35f6c66370f0c55a2dca5387c02ae73a66b81f01798c -af19f841026271e284548b2cfe9fe7d6f9acdb4759ca76fc566de7a8d835408f86627185fe32e705f94e6a719e463cd3 -83883e1c9d215c90948d066d2210528552093a726f0a27b8342b611e4b8639f6d2a5f95bef8cfea4312c1f2203f34986 -a48019b2da37a232b7999f6b668e2758f82132e15ea93608bb2350d3188297c8ff8c791977f2a083ad9773570bb560db -a1fcc29974eb065a350cdcb4283b2a813f02421b872eb3c15056ef96e2d5ffe2fba0e10ba19a4d271937cf08838e4106 -86f9ec59a1f5a5796e498247c0ef1457ea7ab098247f363329a336a1ee57afb31cc18d35e008a5263e7c401fad5719eb -a903f95675c14cc618b02f7a0401ab67170b4a143925979791d76aacc90ad1faab828fe904f13d155425b2ffd79c008e -8f652c4982220b8e9868a621a91eee85279b13b0c2974472fbba11775e6bb1d8d53309f500fbdacdd432170bc76c93a8 -a9b02cfa052b5808c1c9ee65ade446a6ce20174bd2e9d9c7388a1973b0290debbb6fe82697f09afee6ed01c9dd99b905 -8b4c700fdbcb13854c7b1d257a781fb7449a9e3236b962871f11b31b1f2e69ecfa6039e2d168ebdf2f142f93b91f5882 -a9ba2295980603515f80f0130993f1be434281fd4442ce7e68b2fee12b24e440bc0282df67707e460bc67a4706bdf8b8 -a382b85dd64b70296a2d16d1d15d6de80687dec9cc074445fac8de7bad616a95972ec399bda7c2cffa4247bd04413b76 -b6adb37da1c6cba5ddfaafa3718aa66fe2821b43923ec371cd4eb9e974ebf3d0e94dff1ffc1347cee5c9e19af7c76be9 -b5b531ea7f93c4756e5799118654ebc478a3ab57ea51125fd31c012053c759c8a52c8830b53208f74215e437d059eda6 -89c88a5ecee1931dc027d1553b5aa82dbc5fed2a4bed329809467f79f2712fa5529c0f80ce6891817927d0b66d356db6 -b4ad1964f73d3b7bc338909df2ab8889c4faad9b3b8a5959ea81f44c6c4bec95f0fb6e8fea1fb7e09789c690423e2b85 -b573bcbd8f484e350db04eb263187ae4e99ecd03494058e68221aad8d044db82957f4bf23f71a9634b2ef9612a78ecc8 -93c3dd86f7c3105fe482f62b0a56fe43338aef50f0d10f237ca774f834151273aa653e17bf919e54aeb35343ed790c0e -9069c429e7c6507a755871b301b31c3b4233006c51bb66ea2c9051c6caa52e933ad81a8e879129e0c1b099a124bcb295 -a22203e5bb65593bd22cd5bc6e95a2f5c9a9aac1e14d948a7e0aebce4f009a56623026e0980bd194a633b42f15822ad5 -b1585de69b3014634da2ba76218321ff4ce8476b653ea985a7330290b1bb1445db3e1f3c510f9ae7c22940157e2df36f -802a70ea7fa057a03d12538c3ad6b348a8e694bc6b483cd62c97af8809627a161223557f1d5196e23f13eddce15c814f -afe8b0e94d8d9b44652602c5ad15bb0140456d90c95af4ba58cff528e2834e0036572af867488f27cb2d27d81cf02e30 -93bb332d924bcacc41b4b9bf726647d7cbb642847fee5ee7dbf3d2a0489d71802d959a3e905a80ab1f34097328632f00 -8caad1d29fe712bf09d505ccfc724574c8edaf5fc743953b2771cdae006ad9792a889e0c8136409b8f92e2cab5ba09f9 -8678be67412da4d43d74660df98744c54365cf10aa59e522c59afc3836d115380416cb1ae497ba4b50ad31a23ece8b92 -a48e64a5447ebeb5f6b0e0fea29fd5845b378e83f6b06b79b604081e5e723930a0d4c6025627382f6baba8d47425cd27 -b8914eefa2f5613dfe99f11212912dd53d678ed349fe871781074d5b6eed1fc7f2e5bbfad3356a685c52a3c8a26e7963 -836ba66155facd2a1839f603644aa5520cecaad130fcd5cf379139056d3e163bf35f172a4a1f015924b89137f83d366a -835b70cc340b57a09b1fecac678be381ffa4c4951f6742322c2751cf1c748ffc2b9bee8f155c007d88ca69c12bd9db20 -8e98b4ae7c68941a48a70f703c3d5bc9a4cf6c20c61eb4c1338095920c4f23aa9eeb474a0430dc28d355b15dc6e83b22 -b24be8171a105f203c5bf2ab0797dca8ce61ee07307e1d82fd26fcc064bd8a8a5b6bcae8dd611f8ab650176e694da677 -b057bec8ca008dbfd4982ce4516a4925a61bd68e7a36b182575c6a4044c7a413ecd1dffa66ae3cfe2213763dd0f55a01 -8d270924c541120a18d587cee51711486f09a39444182800355c4193a76789614c6925e6a448f46c1891106f866f08db -a0ebf85c44453153764bfc817364493166833b0f84b7a7c505a955cf3a7d4c1b4d2dd00145220d8a3207758a82dd8e4c -a56fbc83a3f1034337ca0d5aa89a0a18f900c3654d171d47ee86b0720c6a965c09c9b06678e3f25b151b115d129ff7bb -833618f5d13b7919206c8e9666997ef26c04a74844f57150e7268bea540e30b93eb785803535566765bdc899d4f10667 -987daa13c00dcacdfb1f0eb13c38ddf773e7e8e19af125604ede42c6d0907f9ed1e4b8b8c9118b14f9449026802a6200 -99b6e669cd7532b435d01b20dfed29211042beea6de58acd68b6eba26baa1687d80aadff901b5607a2553df047ac51d0 -82c81899cb76ae21838558a1946425c719cf68d07950b0f106b859048107c13e4e83b0f2762ac8590cdd044c3e731f6f -8f1c5f634e38f47cc6967f2a80a449f5bf69585622c333d784263e3f6f027bccf8910da76435a84155a6fbe9a8adc4cc -92d3b5515744115dd20742be1a72a455c6d481855f4366a0e960104665db4ecae8925182f32d4e1d9dd7fb9aa246726c -ac86e14775cc4ef22cafa8ac3298bff27fbefa9b7004ccb16d2937128492a2c1319641062f609d27b9314aa225301d14 -a07e1ac19f4c374d68084415fa4a8068c0be540c8b9d81c0837347fe096547d8318bbd804b7642820e43c284af663258 -839266a2fe6dddc446d4b515eb538a27b5a3a5e1a8246f6df77c2de8267e172bb7522aa7985e0503c68db9cf93399b95 -8a381fa29e553fb57e3780f915a86048aa82a8a09059c80154df9490271aa6b99baf6bb217df43c8ea1265e85f07adfc -8d8806db0093161d7f83aaa2cbf0bfb8cabf823cb54bec094f886da6461397f41d54c39f216d7ff4a8262d12aa8ebfc7 -90aff3f98394674791e194b57c3f4e6e019471df1a74dc47bed725d4c47399e91c88a955612be47e89002f451ebacb55 -8bce2d60f3e82042ba94cddd02543b46cebb8770e9b7833b4e79289d4c491df7f4da0ab69778cef92dd81e5a6f0eb71d -8246fc9424b5d5ae0a3344acd7d6962fba6b68cde09332c262d7b3f379cac2c650d80cb5ed4baeea16a5557efb6878d9 -92ea8547fedbf440517522c687f1d652ae4637cd072147ef31338a40e11017bfdeac42a32808d33522a71136cc3bf26b -84f6a64600184c54d3d5c320498282947b8a8166f09ccfdfd6d285cff374312da57087fec3838a49eac5b93315f03b80 -86dfa1485e343c861286c057109119ce8e20abc646a4411696a3bf4718ce03d37fe14b6ea1600d8a7b172fcca6d08ea1 -8dd3404facfe49c2f096d2e74641c474c9c54cd6121771061db3c1757cdb1cd6813d3ffd79e3b839b348d34b7b4f1ba4 -8870cf255b342ffbaa2dcff41910a37afb29ca6a721774953dec182d95b426a481eac7bc107c4c2ef3df9f70e04e0b88 -b0b843ccc630209b9ab35a69f3aad58c76b2cd3cbe94579b5757350460633217246b342fd098e365fb3ae88d5b7d13f0 -804fe307b2d477085f8d9800c8a11c2dbf6f662d684d6a0d2fd415cbe4a09255e47535a08796a805188e1bad779ce121 -93d91029bce430ecc5f41a460c02cefd3fdcb8c3e761ba26a020e108e06520cbe2eb0c04139aad0c0fe58ed34d8b2215 -830867ec984210b314e7f23dc5b10e6d9ca53789cc447e29ebca229f4c79c9120618a540a9d21e4ba2ed8a811d6c456b -8d7a89ae9d7318d6578c1fa75b3babfa7c9df7099eefc2a9983ffa96627f4e7fc99dfde21b92fef5e0034dfaee35e97b -8eb68f5875dac63cdbbeb5df2fad7c1426939ecb6e3b6a48f737bbac1179ed4cf5a1e6919529878169d6d8552fa5ad56 -861e26c9a31d21839735cca8a384b981f7346b026cab7d60fa95a7ad7a4a370cfb409812ca285090c3f1c3a95e5194b0 -a02ab98589d48b2240209f54b0be78edb56b614b1aa02095ab5a9cec6a04faf065eb7b81bfe45aead551b1f774c60161 -88124374273a2425bd5932a6b446986756379c7eb93d3ba0c5d7cbc3477e6267d9c67e5e956cf6df841bb263d1a8e224 -91a766128a4c718a45db571606867bfe6e1b1049f0ccf71a01138d5443014c9758000a8be4dae0caca56321e3f992e99 -8dbfc433e2477b9d86f221e9c49fb8db67c85438fd54b670ce44b68b62d4c0a9cd56c37a2127fb2adef22c07643fdd3d -880cb650f01191db0dbfe63215d208f70f924380fa22baa0e5bcab60f61ece3c6d4cca0e4363291f6a10aca9649da69d -8532214650619e201bd330865a3228e9ffaf1f64ddd33d206be5616c691b1965814f8bc507fc8a695c8291c2f8713dae -90e81d5a9d8fc976a3bf6ee6d3022107d3a9441ff212305cbc7c35bc9163321cadb352632181ccdc1450f91f51872b00 -94d656836edd68384df1fe61239d40a36a0fadd59abead673e4a2ae58de5e2a6bcc4b980dd9b517e7212726b8ac94ee7 -afa70edfed2d81326f26f111982aafad55f510de95555a4d05d9916a600f3ca6c1e3f66d6b092c91c1fce6c407e022a8 -95cfbd616c2a59acde8152578737d3ed329aa82a950dcbb9378bebc3ec8beef9be2759a937381ed5aec1a46d486d1afc -a0a1ae94bcd07ba44c30bf50cbe0ddca2fdb5db82ae73e53c2efe9446c2464fea8e5de31da4afb99c6405798f0f9a59c -848e10f6c12a6adcf711ae3af8382178c46b90b9ff9970350f14b1a1b565a7efd91eb96871277b86040d26561acee099 -815e749e4a56c3b982b50ef5ed249c4defee558647a5c6062022c3ef42b5ebb219ba770f0de74869bea14a98eec02360 -a4d88794689a0f2e194988114ab96d28f77a29cfff606228ebe030a62eb4fba25cefd59d3d5f2fb66acaeda866f5c24c -ad59a8541eb9641c3045d5cea6e3930b35886da4c96906f701ed3ef90cf74431df3c444174d9071a1657efc8cebdc739 -97ae83289d535707039e9df8ebc73262f881ee8e288f73b9f0d6fd209385d3e2b761fb87ca852e10cc4818384ee155de -b47983e11702462a23e26c8d6407b01b67ad532bce3f1e0626fe3164886603bbc803c688729a64a69d119b15235389bd -b447011409a07a2d9074e08502e882098799f3b649e947de44c79ecf86a63045a19985857ec500638a3baa2b228a79c7 -870f506356aa4f8df7d61449a7c7a8689705388b8b81dfe08fd79e8a734c998a7ba71f1f6e9df085b8aa5813a4ec4adc -a07abf6abcacd7612338b455c1461ff484dccda7430d4e9c5f9b4e5c1cb65055f4be650e6d67179b2c62709cd52a9b07 -988b73c2a71f3b1d6b4734d231c089ad6cb07f7ea6f4b8fcfdd34aa33f09feab6cda91232c06b47e90ae9930ea46beeb -886443bb8d7d6c7634f55da1c5695f1691750fbf9ad2d63621589f91a0205ed4adbd4b905c62effaab235e740a172040 -b66caf1ac38a8a66c43767e8597ddb66fbefd888989ca1ed56abb96ab9fb41937927a792ce422577c68286e53bb4856b -a84be3b37007cc932429ba2b4064ab7fabbd0b77400bbeaff09f8c6b818b5cd127ff8497e131dd8bf4323e092c690219 -a99e9898b6f9b7b1b9ef6f28f60fe2ea71e961b64b262cceae41003f6aaa16fa3dc1c2ab63bf63534718ad812e882a35 -a1cea8f3f5605a5c60144fed53943d3f259e3e33545eb0dfeb211a9dad8d99cb3cd3b2cf5031b85778ef6520700eac4f -8b979026924097a06b3827ad28f3efd7f0e5aaf7920ebe5347fabc61b000631f0ee973b61b7468fcc60ba6e4381ee478 -b5dd7393dcff33d6d337328167ceaa7a04a98e0acf1dcbaf454247e85793fcc9a7d280ab14693cf2cee01afdf44506d4 -8580c90d72c0c83c6c003dcc340553ea547eca5989780493c2551ea9f04225d77ea76acc1bde20fef1a0bb7ec01685c4 -8c77db66f09e76ebf7ac14fe2fadabd41291f7ec5971060580b317f6af0daabe099f9db2c3d09c4c6edfa41211da0c4a -b6dec051200c25f150d3b9a7802f5b7c361b074528c79dccefa77d26ea2f67562a6d9fb8246369c6a60f832fec6b7636 -8620173e19eac12fdc7796df12bd3648c66f78fb83a8e6f6c9077c34027a3acd0884ef2e3455a3de0fbfd4ca130ed545 -b44e3ae4047f917fe1af378cacae2813f8774307c20d54c565b674de197fdf90e1a6da0733e948c3218353c613d23fbc -b330af874ac5d749a4ce1a23f4fbfa67f71e8fd16f6da07c714218be431b2a30cc4ad2594994a7a35f5aa06bf87ea3ff -a5be67aad05a965685aadfe03d66ea1136e6979cef00605e92912fe8f84be7351a6acf6b73c567a20ce6045a703cf557 -a1672ed63df30aabe34e8eb81209ff31f4e5eee620b58074d92d9cf2687e40217169df59be8af7374aa5a9107c5f51c1 -ac01de17b74e2dacfe3db539910b6c370de94e646b6f2dd2a828a381b04f2979f8a62bac473659fe7b6e126f15ed7aed -b978099cd3aec49300ef9ce5561aa30da4d37cb5c697e0b5cbc3c42ccf2f96e53e948fc579cbd24605101176a353a962 -8c8c439d9da3627e9f74da784bab8191552b945bb5bf9abb673659c939a60903e11f37300dddcbc8a495adf5c038234c -8b4570ac55ea349560a4e7043fa17f264dbaae15a2f3dbc5ef8a6579e1f9b5a440aeda94122982fe564f78b615de3e1f -a76bbb163db2ba26f5dcae8267d1a890815a76196af10444d3a04c1debeaa3c7cd51102fd0bff8944710c743f5393745 -8d3ba2494b612f93b4ebab77e6f207b636e2d09a3e4a9666d4ddd5859fdbb9747a88eddb7749356b141a071584677ec5 -a8bfd973dee352ae653f7c7bc7df2b32d790653a3f1f2b239d71677992938cabe941fa609e915e607809b5fa954c9073 -aeb4c1ccee15753d4fbba545ec4ebb05c7428427f087fdc0852a18439b19b1669a3c744a0ae2e7f74c46905f520c3231 -8fffac3ff9de863257a836aff3cdb705fe7f4bf604c2cbe10180d81c0956f723b69438bb8a3aa094fc755e386234dbf9 -a583153b241d31223ebec9a95e11ebc4a657b14056b8ca052aebdd9866140dc4669bef4f02b5ffdf667ddc9a87e0bac4 -93177005082ccf2143f24c063d20068fda393948bfac34af57ca58cfbcd0bf9a0de46f8f41312e83a502b7ad69b8f2ce -a79b0967599894340ef2408b48f42e6ba4f406e5ccaff13b46414ee38e5329ffc145f6c34d8e8acc6aba41c23e57e7f8 -809a356a76d54a05e5006f2cddf0decf73e5392b57ead32ab56bea9fe13c1ad090cd69a8e297fa6e017b39361906360f -b051226cb44ab1bf94a9cc0e4f246751d68f32ffd12f1d077d3318de642f3997fbfb0f2ae1dd103264542c2bd0293e57 -8cac28256b1a82d0be373d884d00e9ff2e384d5afbeedda706f942b1d222694f126ad44f9453fc8a985cf69fe11ad70d -a13b073290de7a2f01a65e429e1adb78cd37eb23c24d6fd5a1632cce2275496179e3c22e0b7f59fb51d526402c0f3f7a -92dab68d1dbf07e5b058120422ae610806809ddecd2aeb9d11d8fcac738c72eca584b88ff52c95817b79b9e0369e3ba6 -b24267fbee28883cc8649c243b13905874e5d97a285b9c6abec749a53e106db0a6fd6fd8671d5b7c9a1851da75a4ac5a -99cdf977dbfc10084b698c81cffb431a9eabb55b1323e1b15baed5984a1ed212ec5f6c58372f965fe18de0100292e26c -b021c697c56989bc8c06636cd623c3672e8885598fd2014f5e560fa2f721f9487cfdbcf4adfa34c178ac84771fbb77a1 -8fd7e3ad3330d4eb1a0bd42801d95ce40a82b43c366abc823e25311aa1ed882446d60b6309e1a1e201e725326736257a -b1b3c641ef4cbd5e9c69955217f53373cbd104916e04d012eb40a24d798e76bf05ed0a218862ce02619ef694c42be170 -a376d0296c0105789e9fe539a5d22bf62ee36a2de4c9aa0f5e57210ae49e2cfc5209fe0f467ed19dc95b9746595255e0 -8a0ec125a145e373929ae33efb978bdaf16041eba684ada612c244bc3e28c7027886e6308373a5ea53c9c3d8e868ce1b -93fde45cbf04cc386507b03eeb93c885da12bfe519df9fbdac5ada735934ea6e1a6cce066d033be66163b078e96e2100 -80c1839ee1d2ddcae1fed77d5f8091ae3074409461e04153db801e05b44a7658c6ccadd33ad682e51e211dd9e3c80f72 -87112961553b4a243875ac8d46bb6e274325699ccbdc40d7d9b7f7e58d3fd164f86b0b1df5df5f980785cb3918dc9b33 -a011463964a319c1ea11c7c55c607bffe0116fc834b8a1d3684df33f77f6e51dbe16a891307c9f51d5b4d205c4530072 -b316c4be33abd10400a4925f9d20ba02ab1feb50af39b6f6120d6dbcf1bde0a8dff7e08c64bd1f5c43543b013e242483 -9555b696d428c4b74806a7d08b9ff17c8512a86cbb13040360ce248de241facc42c042d3779c28fe98dc3ca96a47b2fa -819f54bcfc58a7b793d185d8ffe411bde6207b77cf22b0d5e1b3d9843e4638009c907fdec1966b485f95870da57f131a -82c3f9623bfb8a8ff3573197497c175fcb314addafadd025528f805b7a63c87b0e54b48d46c0322110b0043f7f77153c -abc023b35318fd97ec81933ce55799d8c36c3d55cf59b9efb302b276a76a37c517d5c690287f216ffc5d1fc082e116c3 -a6579226d602a7ceec06d402d38f217b836c8804e9da202bfaf1f3f4f15c24762ad6a2414ac022d8de68fb76ba8a725f -b701d6d60387d4e2308a77cebd210e868eaec10d86532ea18c0c6393475b3976a3eddd79e469458bae4f496da7398fcc -ab202a2acd4ff874cfc147ad1b02d4515ace254f8b828f619df2537698f4e1b2687e004c70a152d605a73ab1ae40fb3c -a7e09ef6c86ec7475eb3ed69e57e0cbe86114ca5c0748069d00b6e3a1e2ed74e4366adfcb4d938023560fd91d0f64612 -a9fc42b05ceaff4312d5dacd78fd2394dfb8dc87d52efb0529595877727747827c1c7e3a3da81255356033fce1f97513 -b0150a1dadde09cd60ec3686256b4378f47dc6a55c092c60a3a3f0bbf586013dc37ed53ba7a91c72791c0d52e4c49c2e -ac88e91b48f031df297c29fbb2cd0d2bcc767be5e0a7db87acc87fcc0f4300cce6deffc0b1cb6fc7e51c6ab13ec2ea24 -a8fb1542a956fdb1dcf90da2672d40c90a4aaa2f1232318b4112816bab660657eb97e3d0fee9f327793f6ba9bf8df2cd -b78191d1ec4615b03b21d7730d48fd9643c78c31feea19866429073f4cbb0d1a67f7d7ed210ab62b760c679515b20acb -967c20d53d46011f59ae675a26aaadbb7512d9f7fe87b7a20c3a84c76569d23920121063235e37cee2692bca3af69039 -9766abf0251cefbcfbf85ab1322f62267c22e6556b7fb909413a7819f635e3ac1670da6f5f72d3bb4b739e12eae5ccc6 -b0e9c5c327fba5347474366eed1ff60b986a41aabab00abe18a91dec69aa54197d3f5680603057f05d5efa0a48dbc92b -ae2f5defdbd14e2c7eaf595b017b4a97edf521f561ca649b6bc2e66382478b5323aaf84f0b90f0147e20ad078d185248 -b841bb6e04d2409a419dff4bf97dd3d4f06f6fa4e5e23e4c85f23533b7f25fe3da9285ba033c6eae7e5e447e35329c0c -85e26db850536cb6d3de259f662a88d23577fd56d1f99b3113ef1bb166456324d3f141a7ff63dbccc639cff68e7ae5a5 -8cc36d89424da80bcc2b9d9969bbd75bab038c0cf836f561080e14bb691e8e0c17306fd6d42522030d4640a01d5c0704 -817e72d50f68dfbdfc9d5611eef7c6b490ef1509559801fe1ff916050429a5f79c8d03c60d2bcb02e72310b3c4c9d068 -a15ed72881c49b545413102975fc69649fd5417f5b7ea9091f8209974024785496fa0682352c879953cd1e9edb3fbee7 -adafd20b962921334f4be2188f9ced4a5914389d0afcdbb485096d3848db85152e2881aed0fdfca11f9c8a9858a745eb -8d8aaea706815f1ec45d9ee470698ff199c40b1ff2d75bb54afd4a29250b094335538dd41637eb862e822c4cf0e2bebf -b8480d2a79cb6ada254435dd19d793598adda44f44a386ccb1a90d32cd13fe129a8d66d8babd67044de375ee59d8db51 -97c17d6594ccefd8f17944fb760fd32cc41a9b046f87893bb7ab2260090de291e8260ffc63e774a4b6b1dfe0e5107ef8 -b5b7e1d4d9683de7193120be850395762ac9a5669cded9226f5ca2a3de13eb13b2900af083645ec35345894de349433f -9405d473872cc9f9b9c57bb9976d3ec6892ea429cbd1b12f22962b74d88448d4ccdfcc6d5c6ffa068d560d7bdc3208a1 -b99cca139a3733b365f4718beb4ff4a5fd6aada0173471156640d8be2cc69f2a70d959b57688f927bca2329c3b30477a -94872ec872f19279fd26abfb132b4a7fd8c485fbdf04515c7b416fc564e61a7b0fc5da9f1a380d2b3db989f1832ac1b4 -92aba716538bd66e35a7bb877cd364c1b8dc3055a9cba2da23c7d9c0a010209ba8afab455da99747fb4bcc8fd3144cd8 -95ec4c205be3dd5df181220c96bba3f4e3b526fe5369035edfcf706c1eca43f29a4c95cfcf94cecfc974e01547e55125 -b48c719d7cbda1e79b3f7ee9c17c13bbac197bb015b344f79bc6785b28a1e9484e2349178178a2fe94c46132c54983c3 -908c495c355a0555544ec6f0b8e0dd0926ef2c5c640fcb89049e6178697625b85492722d42bb5c966aee2cee9981607e -98ded9cdfa92bc8e3664ae90af87f88759503715f6eaccfc983e3ab53f7b3af6802999da93caa7eb3530402ec4d8901e -993266bb366ba46d532973391af7204aab46a3189c83ce7cfd2713bc11e99066b1a5a012bead2fedb09274e7b362e8be -88d462a3a17f84326b1e4177799d6e9c5f4ef57152cb83ffff4353a8382ac8be7d50381723aeca77d33d8f07fccf69f7 -80438d9eadea15c90008ccf4758d4e3fd5a7bd02809eed5b683f2c96a15d24524ffe75683b7167d42a47161c65d533a2 -b9e7dbbd3d3d0d86e347831cf99657fb269930087920637ac6cdf185d5eded3f09cf3eb27759ce3f4b46f41411e2fdce -8f0215f23b4945470f74b99607c12c36eca41aaaf99747f522d8531244b668d6ab8c1096b9b5697208c3931e1fefaed4 -b2c8d8515ff16beae04c855b4365e450e0ebfb423acf5da2501fea76259f862bf29738a858a4093b98c2a444396249f6 -b27364a7258c30a59d1f13d358eb49dcef298a92bfa699b3b91817d2f324be8fff91c0b71cabf26747802a92582e7dea -aee7d6f71fd674cdd8dd1f22195981e7160990c16647c871835d988e881a3d4c52345e74f7a54768fd97a65fdbd84567 -91356cb2024f7703ccd662f50baee33409c28ff13bb5eb92fa93f303913e9bf31bf83b0babff4b5e3649003ae95492e6 -b744e4754043d3ed85c3bf6ccda60e665568dd087548ac70670b90328509d0d5013cbdd07bf603949067e54d8094fc2a -8146cbea5899401a80676850d0b43b02d376b4b8f02ed63a7d92532d13689e2c02846df79cffa0f33ff81c3bf492339a -94bba8a1508c6296d3dd5d2e609d6d732ab2541849deea5436a4a9034e1e6f1c8d26f6b781fa34dcdae7cbf8899d006b -80260b321d932e1179667de4916428c1b77ee1ea537a569dc64a12da5ddc85d09896939718ce08ea7e0fe8f8b115c408 -89d4640cbbca5d105dd67250f3bbfaa96d7ce19a89f8d6e188353f3a9b8737f2db1707c506f8ffe1d3144dd1da371920 -92f5962946ef7190fbb7bd3935427157ffc815a52ef44397ead3aaddddc82e5f85b1edcca1e9082a500960e19b492614 -8b89240c9b7257cbbfcd6e415fd035ce33bb46c773569d217c82ecee5dc2d66eedc9333e0b043616b0cbf21744909b60 -a3d23484916d2c0ad1b81fc7df70c97d711040799cab076223e0ee02a45a0fe9ab564faf7a225982468f3e62e32424d0 -b31751386bcd471b5858d001fee15d566215e34d2d62556c51ddc60a834d3f1acf18c415c23a36b581cdf4791f461ce1 -860a99003b841221dc5ea2bd7e226e5aad72db8a5959d5d4dae8a86114d30b9e8915b2314ef867e9c2a477d9424a2d94 -ac925b330cafddc7d95d115a9e62b2c135acd22b5e35a4aa789f4318f03aabef818805845f2532e9504bb19f69171809 -95d8180cae0815d33bf8854f4590be652f95f72fc29f0c519ca9bf3f490ba4a724b23d9054e08e3d31bd61d609a8f0dc -994f223740ff95764fb88de1ad6dd90c9c58c0dfbf8482e1dd9bafc20c099a6772acf40569c54143f6697fab72772296 -971d93cb1e7aec5defa52815bf202b11de6a2ac9c5d4c0eb236cf2c4941460731e12b718f4a5b980ec6f4c54c3d17deb -a341095fe5adb96dec2be367f09804ef4fe77d553102ddf7d643b7277992708e84be9a7748a97a56f065002a97dd7cbe -843709280fba29d446779b1ac6e31bc3ec8ab8082e8b063ef8d2f3733ee77a4191b55772302964bf867fe1044dbfad65 -b7ccc71fd0d0c9642c32d292ae88ca369d1fb5cabb97b1745c621aee41da8f94bb580c1ab23664c1baee65e97b21f0b0 -a9b41f31be84f8ba061570633bd9e5f4d8af6fcc5276c25d9ab67b2b88c1f8c2a87eb19280cd4fe7b4c04da8b2d02d7e -93eb14ce0632cd325429e1c23340da9655d3d7c2b42a4594bfd5a4e07815afc9eb1ac737228771492020f6528c0b7c61 -959aedea532471b9610150657b895c5f51ca950aaca910df137dbda2d17184173cf2638a2a0efea3f61d82b6ef8a7c3e -8ebfb50bd48fbf9a6f782454ea900acf0c7143164de9b5b46c1cd072c69b76143ac4c99bd43139b5e55f847841fa6a1c -851499b3a1eae6da530a47d3e8bc068e6e7144b744d5eca5394f96253df65094e5f3c34abfaf7c7d78c4d5a5d4863da4 -a8d68bf15b900cc47197739856557b43a5eb233b6c095f21a14a90ac8c36caaa1a54690c95840f0a4d2e2ffad0874a2d -81a6ff8fb1dc4d4042089d4cfc10cf826e39083aa5983e53f4866f8f4c10cf06cd8608c4cb1b785f8d309bdb9b2dda63 -82f658bd1a95fac0b65d337efc95d856aa65541d49aa993b094d70e527e7d478970eeb3daa2904a1309d755e1d677691 -b46ba4f3d8f287eb92390e5d930df4f1a40abe500c9aebf62e2eeeb2e5ecfe5296b09fa22d6c9cfdae28d431fd10a00a -b5b38508befa4623166f6213cfd160782fae5b7c3c7ec279b42a83d43a7adcfaa6c5b34cedbf98bba357fa663eec896c -89b8a0fb37a0c45eb1f234ae9c7be65c8a708f08d431728572169b33f8288b1e17b7d4b18de9fb76afc37ae609290623 -a7d1f5779c043900f3ddf29b6b7ae4301699c0ee9e70314fcd3bb2643f912fb1225a0164f45c47419ab762420bf8e5ad -89d2a69fc014068aa6d0b79784b8953f3519f563b5c9f774f4b148334d822aa645b662d5efe7dc6f9cccc2f67268c3fa -a698d3f0b1b6b72b72358d5fd5e49e928cfde69bfda10e163b9b43bb9604362b32af1909d28da5e0364abcf5e96cc226 -91c12dc25c48aee56484172de8c6aba0d9f5eae8db848a7b53d76001c292d115ec57d816c2cf10bb9e901b2707dcb71d -b0740219e084d56db4829daa30b2812115b2e95ae85ee96a140b7c4012860e8017e19b482e981547e50e25bd4ba76716 -8c84d4fa255e2de7cd23b0bbd110687edc47ed7fa87bd42658fbaf3831c6d68cde3ef403ed6c585f8654d0cd32074bad -a530d3272aa1740a73e15cb9b31c5e2e54c404db72274b0840c19b164642389acdab4514b9b2bf9688ce51392d8b6793 -a601f52bf7b3226fcab93c67dccd95c1d6673270671c4a099b867bd5578d5711fe9acc9b935b867ca780ba4a394279ef -8a238082dc8ae33314fe1257e7bec69e905c194ded6f894267bce97443166fb443628490755e1d453545f389b5beaa2f -88a9737f3e9ded874681fb6cc8abe0f6e1ce18a05ab599b2f855f73e6fe5bf804de5c5dddeb11057aeca6613bba72c8c -8a5cf70293eb99ad3c34992c47299646c8702d1035b75e4784cbec67b28cd4c88eb8c721f4cb8982d3c6a42d1b9f7fae -8a62228b84fa7463a6a8392a7af767b661382175633c5e00b36979d816a53b388f31afedfc47a5d8cbcb645e8d5928b7 -92836b5a41900a1c1ceec83cf4f15c6177dc20f95eed23a203810116ede2a072a8d6c96532ef32c93ee21acfb14448b9 -b4e538d7bf40c263dd1ede65c81883dd31f9237a0fc8d134a2b480a1a681dd89cd2edb19e63070ee69e96cd12069ce3f -913eceddd4c9939cf82c7e9ca5ac300cd79dc5a72b8458cd69e9f8929168eb19e5f21eac12a3b09eb8d3998e28e3801f -81f4a3e7195661b174aa2059796dd88d3206bedeb7d7cfbb7e61aee335a01ac50bb8edeb258a68949492d4ac6215d95f -913a393eba8eb88d1076effa8d2a30258d83635ccb346f1bfe099fb5fcc69d0457ce5a79363a618f9e8b43f53728433b -b11d721b08be428254665bd64a8864d78c5112e252feccca113631b2818fb729129fcff1e739178507ece41b807ffafd -92603fb7d50d11b59fe376720aa57412b866fcd5da90195a5a401e6222201b30c29f8797dcc1b41ee2cbc6349bd5ee1d -a466c5d41cd4a8d1f47a650ca67b529ad3873ba3fd3a36db27f7a5869b74b42381788bb1a1c100ed184118839b9879e5 -85c50607a86d4f76826220286784fa9b6ccbaadccb661fb3489fd35a3a8917d6999ac891190f2297afac3c37abba2967 -966320c2762b266cf7eac7aae39221599df4fd608036f6101cb8c68192fcbfd5f61c7f93172aa2be0934486fdf4816f6 -ab69525f1c77b6706592cdd5b98f840184b49efc6fc2687d6dad3b014f6a12c4d5cbcb5120d8869246da010823534d8b -aa2c9df15c06b58d7b9bdf617df8bcda83ccaaf6ddeb8074db931f7f03dc06a7914e322777e297226ee51dc8268e80af -97035b62f8db4df6e787cc2c940f2298c7d26c2127c7a76e4660d132a14f43c8bac8dd4e261605611b2e9c08929f2bac -8ace33e696953806f594427f137e84ea6b22ca9b48c3bdf3830b3e951e5a463d4a7067c68d2033eff452295a741fa1cb -b621fe49b12580bc8ec68fa39d5133875da23524a5ebc793c35040fa3436350d0f3e4bb4e53eaa23d312a7847e2eb2d6 -ab7d6ccc0de9c7ddea145e83fb423a535cf26d470af3326d1d6a9a579592b32ededb078bae4613028557877a9fe71642 -97528eef76389dd77d33ee7daebbb290814911beb725ef1326c3160b9003c3043be09bf3f84e4818bc2a7960ce1acef5 -a408eaf5c675b50dc1c655f83b9595dabed68e74e6d2eca5a4948252667413cfffb46358400df5d35f92657811ae56e2 -b36537726b26b474e184dce0ad868a66f0944b4105ff6d35a2cae0f3a520fd14a66630388aeba178d400b5fe104e521b -b2b88518d10bdcb111c82a261076367e34718f1d0a1a06b421891b4eca1e3c1f904b66e65dc914ff1ea5991f6a638a02 -aa3172531879a5c8f594ce96277b2c8c8d4a2d0f4bbe567ae40d5b36fa6108e00f0b1dc94b81f36c9eb6d1e9ee1896ca -a53975587f10667a9474ae2756faefe43e7f81bf9e051049de175a8ec085530fdee3d5e3db15d4be874ecacf49f31691 -a1abdc58bff4fad0f6562338daeacdac8e37f9f3212aa252b17389bd9c54db58706129a63bd0695d299d043b5ef0e2d3 -b8588fa1090597fe0f6275e5779da11a4d128c52fb8954e475c4940f1a3e10fc23ce1f61e9aabe8a75e82824f718a94c -8a1981c536747d4cc06315c794f1536db7ab3c9dfa024a0df854b948d93bee72083b6c9c4c4a7ce999c98b904813a659 -95b2b1ed525d629eed454bd6bd059b01869423c3463a56689a7c39cffbd3453c962426a1126ed631b25ae8cd7538302c -8032c60f083477693f533c2d8ae391d62ea754b8eb41ce9cd59bc469b980dd959a8ac840ccac54b404a9d08a6f9e4b98 -a72ccc14eeed758d3d43c51d68341fd7e98880c3687e122238d77dac8d987c8edb3067bb63baf13a0e57fe02334545c7 -aac3eb536a5061a8ec788ce131582dea691957ce8b9c6af5ab7224bdf0fd15c77bc6bc63ad037bd83e0ae52fda738361 -97dfa193800e57e6b19d1b7fbab40da6dd1463f043eeec34b316ba6bee21b6bb633ec0c4fe107c9dab6e06e07e0acdce -966ee3cf2f54777968fbc34f08c8de121ae7c1d6b2cdf1f1f9c675828d22ccb909bfdffa2e3f2ce51b0cc85bb29f8504 -a9df6dfd12f8c43c28b929280355cb23ab0ddd2cc2e4fe76603a2e5dc2ef5d1aca2edf89b304a27345cbb1f24a86cad6 -abbceef80c744e5a1194313f7b84b5dee1c9861cd4bd3d0d12c433e5f2e8c6ef6f10b860abf3b788aa04896f708426bf -b1dffdd81711e9782c992c4b14583ad9d6c39ef88974682a72e717e21923da6892490d7efd121423fdc638467e62e064 -817f30dd799c422da33e13ac2bada8cce3930233ddad495f714a1c789b7aa8f41ff6e688bbffc5f2e8dfc72e5243b645 -96760a79e4414ff1d19fee65b6e65b2dd6665323981ce8b4ee93d0a9c410b018ac086c08fcbc7a71720e1e3a676f2b3f -95445cabb75909262975a5b06381af2bff5c4c6cf51cc84adbc0b7f2a985117f35c014e33672cd5216a9737d3f37e067 -a279c905fd9d49482d213f5eb98256d020c2b90bebac45004d6f152ee4ddcfc72a7e6b188ce3b6c93ebb9ba9b8be587f -8591e8379a78af8860e6a0e002be5b25aa4b93c5e556f5ae2e40400f828dfa19d93a4910823e230a51e2c1ea5464d437 -a6fde17d41fd9f03605ab6ddfc992e36535a23b2c39608d30cd6d72588f1ec6afb9db193e88eb609e104e73ddde779a7 -93e2cb6352a5eec063151e5c9a822f6fd475a072dfde2464af4afaf6a730a6af1fd74c424c09727328a7f23505b91407 -a7b1e4f703386fdd16f5fc9b59ef1dd682bfe5a23bd42b3c4b1385bff894e758ab09674dd6d0ded5b32a0a0526aa6d98 -aa7f01c450e619c4bb42d6cb1a90a94dfe132a641728a642997b71e2c3b02d09a7695b544712b2e14416e7de0252fb11 -ae840b870a938668d0d4404b76f5d4d252d8ae1e3619661df0890ccbab900e3d8dbd5dc9f96013413e3f1e30dc541db3 -ab7552930ab07b0f5d50edea3a2e5ea3ac1a05cc985246ca066fc3350bc58949dfb99d4f6a6408d1bba64d3de47a3c2b -8053634d4c730b5e90d68c2830a73e93f1c9e522ae0e00a04e2ba15a1b7b4fffb8b25516ceea61719f886c7763d46219 -880c39ca4cafa622bc767d3127d62143434d0a1d7de8dce1a2f94cdcaa023a7096641a46e6b97e1b1ce9c233c873a519 -ab9d46e46cb2f382ee7d21b6da01578b786b7998e0fc2b5d5a4e1a0d93aaab997b5c481c2d9a741865d6460ceef57a5b -857a5957adc3a888cf93f144aa809c70a211932742a258978af5e657f4f57fcb6d9e39dbe8d3128fac6c592dd5bc4ddb -8c98656861fb8c8a03d491db45077f1d136a759177842ecf6c1ca36923088237e928558433d5b631590f395db56f96c1 -abddacadd7d536e91d36609fd0047f5db113be0f4d84abc7631ffc5c00df919c085c049c013a05131150b0043d51f892 -a8b14af12cfdd0e11c8487334efbfdd22c8b4fe6bf350333d42ac8c704efe54f50a4bb51d9d802e5185ce72e4b21aa58 -a8badc2bb3cad0143db1bb3cc81751f9974ff3f0e2ee35921d04985409def84ac2803a657571699eba34767b773666e5 -a6739a05d270efdab18462e8536f43dad577158e1c1655fa130da97e469adce9bb7cda6f9ac26f4a9ba3f9b22329b066 -842ed6efb4395603e7fef0bf92326c0c63992da4ce7912f850c4960f7a19e0b2ecc720d9510f15ba6f73a2c5ada8ea71 -8502ede859944047898d533e1923ef90e1b5c17d985c9fb4c6aa39d50636de4c5a4df278f2f62cfd3ad08bba4c5ca6cb -8c738573226dd5617b3ca1dec8780000a77f3fa8de241cac99b0d9b1b6c90cbb8aa2009668005f2c5c7abb09c0ab3f99 -b101335c403d769313bd05c755a9196769465f7068fd6f9e00937f3cc843d48f013f5931f999bb5c0082d4315134f5d5 -925ace190259b321981fcf8bcf52c6852b206099f25c0f278439ef6edc4320d6f926cd6fccf1b4cd224bc52e5c681612 -95f5855ad1bf14224e51f7d5e0d229683c0d38fa324b1abe9d595685d3497955e30289618c4775f6083bbf923ff3a37d -a3d3c7100962c8b60c40b830af834ddc48858e7eba5ebe2874ebf74e505c25cf52e661b49d7619f2f2a039e1df02f5c8 -af7e66c1d5dca63e6be117b210c616efd533e77199d67d8f694e4278841963e0a46e4e44f0416e69bce6a7156e1872ca -ab796760166d1e1fceb20f9bf19b1b7cfcd327650cc7cc35c161ddbb3cd4846e9a971b541f303cf62fdc0124688fbd41 -b920211c5b440b3567942dedf62a65ffbcad1e3516f58d14d8f8dbe86f45c4b9745fbce43f5219b7052b27a3a04df12b -ab6d5d25b9fc46b0824df1628993e44535febd7c62185b6795550388185035ae12bab60fa34848f465fb4f4a8add3544 -a6539b67dfd6f3976cb6b304f4d152532b3f08c02bb97730c03c746da0f7b38ba65536faa43953d46e5e7687a86c356e -95bb225586b1c82d894ababea7e5dfa8468bc0e10a2ef34e5f736fd1611114cddaf1a5c58bc9d664b667adef68b5c25c -a16eefa4e6161a8e7bac63cffb2dd5cefcae57144e63b3fded581abf7ce32016a654aaa582fc25bfa51c83f352e09372 -8b742428f6af81261a47a0df061e480ef9176694d361ecb57967bea67e11cd44df686e38e35b7d4a6ee02ebd520aa1c0 -a2a4f2307f646384a0238a711c2dcf7000b4747b8df1d46c5da962fdb106c5339790b48682e8ec2532b8d319ccafae5f -81910c1d72f6731d27d3a4059ccb0316faf51fa58e0fb3d1287b798ea8f9b00bbbde31fac03f93c7e9a1cdbc9502d5df -b846b933c2acd71e9f9845f1013cea14d35cd4b8f7a371b9be9bec9d4b3c37a2d0da315ba766c3a126f8e2893f10af4b -8ffad59284b41b75064c277ab01c5b4b3a4f3c4b355bf9128160b1a55ed6b0d91366f7804006b4e6991525d3435d5235 -82ff36a72533fd5d6745d0c3a346fce4f62b6aca0b8eccd11399b482f91cdf6a5a4135c627043008cb137ef4ccd935d0 -a11c27f6eefe54cf32fd86333d9ccb59477a655bb0c35dcd028eea58d4cc40ef9a26cf3432fad4e9d058a27b419b8f04 -96642ce0eea3c2c0fd155a75bec3b5cd573d41e8081632c56528464cd69a1141be3180c457213128bcd37f5fae47f7f2 -8349a9e390e05150bbab2351b77a3674f1af000b6eb6752927ef838b6f0a1200e6fd7201dad8565e3caf3802f204246c -b8ae7fea6275ea61935d3047d8156e8fbc4a95c9fefd1c36439b2111b9ebeb7ccc306e0f8c875fa772f7b433cff848aa -b366f056e23905bae10ef7ce1728b317b83f504d128f5bd34701ecb0d25ec08491969625e23d5a2fcf0048af610664df -a3d88d506ba46b73bf07729aafe9698e788fd688647a6b4145761275257d262cc450c7889b8a40d698455baca55e3da4 -891ebaac7a7a408aee4ba61605f44f9ca5a6d5e046eebfd8f5108b6dc4479482806dd01686045b4c7760051f22bce468 -a6ddb74e3e3725e6f2d9025532ee3f357ee35289e1cb38dcd5b2ea8ebc0bb697416fb3aa73e1eba632d593d40fdb030c -a7dc097f440ebd31ec1a005648468c702bb77073ac8cfa32b050e90a9e1cf388f138abdd18f07951c752f7e19f706af1 -a200f25299f9a0542c196adc2e00289f453411066b88b125d3f0e6b17e98efe9da8096312a2f1841e01837da90a65440 -97cd3a9d4185d77d4c7bd4ee80928def7b660d8b949b0face798c62a7cadce1000997af29504d28ccf9070fc3016dc56 -b9ebaba1a15eecae6b1998ae6d08233d05610dc0933b16922076b2dc4418cbeb4e5cbe099bbded3139d8a47f2b2eae10 -86f5fe8fb36b419fe6fece1c5c4b9d64468b4aa0154bb5dca466a243b6fb1227c3b8bdaf7ce5c2d4fd05c061979f87df -8050e011011e7918ebc25825d9863c91046fc3756703bdedf936dec2815cbd10c2403ce6f4a0b4f576cdfa1347efdb85 -ac22132a482d2950be9442167be214ed9d24519073bf5ef1c8e3e6f4a77065da198a851950330fe4d62b2a1272835015 -819e2e8e3ac43b6ae4885899346f3b558bd7658ef7d380070588154694957596695a925a001a9fec7cf3655326c50c2c -b00f40c084d2eafa36811e0d822ffef874a0d4bebd4817690408a737624be05c920a08307cfa0c1195505c5e7a5fd878 -8355768c09515a593c8fc8289baa3b6cf7fc10d302abc93f72090ad99a70a1ef1107eccf839be722132259500a565d68 -8bf0615d2cd11b03546ab7a0c90c0c938776aca8a8b989a709c367f0f5eea7b0a7cdd78f96050cdd5d0a123d01b99c53 -827c2cce458464fdc716a2198fc67b3cf2ed7802a1f53f7a2793b2314789998b13ea61343c723da8863cb63def6a285c -b609cfe6acfccd632759700bbb0a06fc7903a6c0c5875c2c3bd85c65bfae7b29b03e77092f29d565a6a89b85012396fc -b73ddbc330e872363bed36578b245b666d42923393a1341816769ce0af24b700c19ea0f579e4f9aff1c3ff369e63da8b -976d658085e5978807e13b150c7aa539b44ab8855a386bb58a52d9ec9b5e21ddaf89a18b043394d6cf47bd589d04b240 -a213897312aa28cbb2c572e643d3aed003c84bc2ca571dc5fbea8a0b642313be94db0047e293078d975fbc6800751a87 -b54f2914f6a7508b6686280d3cc955730458ff035978be29645fba161ed54ef3d4086f956e68d2a48c49afe904edff5a -af99e470055062390904673e18d04427c16afeb7b9f13ad83bc2599e9a92314bd91d6f1f81b55419a4d668bd889ec8c5 -946ff0cff4030b73a1342a9173fe697ab20cc5e43ea6158573f2def601e12a174da431f8170bd31ceed4be48c90b4f6b -abc51f8bb5f74cee819ee383cbab739026c453bb55336fdf423af2c2ac6712ba90006d62dd72d8cc1b2ff6cac900c8b6 -b43623a56c5fd1bf28bc356fb4a875d72dd4cbb00c9c863646a3376937088f9932a4a0aa26afe2ad69840b06242ec76c -b0f371952f99eabf7ed368a142ee07d06bf2b7ec1ff852fd948b8c53eaa52300753fb9ff6765201e35873b5167583f3a -b3906488172c09e148c571ef0712f88bc9f1ecae0db95380f61901660fc1aa090d0740378d5b9b76883507bed100093c -945373b5e6ffce11d39a722df7b24eb929b14a967d211be3b969f48fe1ad3dd4280317d1ca772a69b033f3bf26c02c4f -b2ad3490389fe5bfdd5ac7eb5bd61facff8d57a8f9969f4938ea56f4a85eaa2c1179a2e5b4f87d9e6409925c75b61828 -a4d61547e405319cbc20cad16a2bfd9e6d093a064522c332dd22134ab05e893bc84786b21b4c71a6265bbd06da2ef4b1 -86749c26715d22b185e1b25dd34818e96aad319d7add22a98486ef9f9808b5e4b938c6320d391dc4e0fb5d57bd41778c -acc554d5b866693a453a9ec46d422c8b410458fe8397384b927a62bf5f2b1fb9706c8c21af9845050fea8a91786e3577 -8eb7e763d297cd93a7a54dbe4654c39c0ebfd73fcc34d3f1338de0c347676f445d32f270664fcb7b33347bd377c9f867 -a1b469e3f9dabd36b13149c83aa5b7b5987eb0ecc1ce6b68c72acb39ed503a11ab4451e658576a92df4aa51d1bc709f6 -b1ef105cd0259486be8f265a73ea089d5b7fab7bd7547932134539963467fb917b2206aa72446e2fed5a8185b04d345d -b3e211c1a14925f6de451271728a3c1e555ebebecd4bae29bf666927868039d4ec99d9f9aa98d835da7845a5c863dfaf -a416632a50500f29b6bb471bf00b37558975ac91e5c5b5004b67e130be1acc954a8ebaee7efcaf6883187ee9173d1ccb -8c655a85f66b5f28ab8760c94b6cf01cdc36fedd19a09c261e432fa7eda7928c3c88355384e689f1d2715d419fd8d898 -b1fa9f82c9866d4f296755bef5b7c39fadd09374f38ef9954aa57b1431a1ea4cc17a9750da844fa1f5848f0ab7ca295c -b45cdf1a9eaaf85c0b07bfe239da618ee649ce90b417d90b08eb518b1fd88c0d25cd29fa7a0d8058d6616627a3dda306 -a2be1552d3c4142755e0371a9543032ee82ad669d7edd24c4e2941bde3b78c5c6df427228fc45812a55943b3663cdbda -a28feb053e86dd9e2f9ccbb7c38467e2425fd580ba0f63190036fb47d01eb198ba8590b5cf68d1c0f47638e9dbdaec74 -ae06b849e080efcdba86fa03a0c9dacb38a15ba911aaec624d15787c3e11ada6909b1e33a2e3de928a23818d833eade4 -b4888445d86bcf4d1f6a9c2d253f277596795084c3d45a4591b307b7ae4ba177d6ce871c2cacdcf9457f9c132f244722 -87a568aa2f5471214f63932b0d48e589898e82a1f4c1055a9e73120763430537c233e9a3cb6cc178df53768e4c58c993 -81e0ec97cdf91ae66d065234492a1119198c396e2db204b7edf192c88eb4238e0a45bf7e245f3714bd864244cba0ebed -a954a3785588d4bb3cfd7cb27df45c82e6958051f916594d76cdb35bb07e4f88e2831a5cda35fe1f3c99f32a275f0668 -a9c9f4d54339d414342e87b03679baf29c219d28b6548f01891cf94d0313a64d3384658d82373d6e838d886235ac446d -8ef46cb24432b419b4cc803e60b3ef5872db8ea614dc37643e4592fbb2891cdff61f6b2a10653d9e99e6c7359ca4c590 -b23eeb458c05ffa5d58be21cd0699974694dc61a9a928fb1eb509954a3dfe7d8a71620a2d4046a448de0fb213be7e97d -ad631be8e17285f6310fb72ba913c564fc66d14460c4e8c4b0c68c572a5c2a45b088ef60eaa9d317403bacf534d57a23 -b7130f5607f236374f5e023fd43cc6dee38286ca47d504c9e75c6504957ac2bb9134fd59d8bb1010d545c56ad9c71c4b -b83cb511757d80781e26b5e9b3e0597c4cf9a976a3fb60c84efeab2b6793e46282612da45b1bb8b45af4b7f39877feb2 -a0c5f8b0027ee11cd5f86515698f689ad514cfa890ac4ead5502b5ede9d7d7ad12285f5806c9c85ab58f89bd9f188938 -aa8e8f9335c6e34bca3472b5f412ce93ab1ed5f9e51c3affdf986a5badd2ba3ca1ee69eae53ba8144927f082371b4cf3 -b2a4f775a10cd9caa776123771f08e928ecdb22dcb91efc440c69e37c6b467acfa6112c2776d4a530bfd6df3b04fd50d -a0c553d5d2a9b0525f71a5a0a539d579d937275df9220a0c3c322d6c0ac7fbd2fc55335a1a283e687856e2b30398e4b6 -8ab800ab4c810e8f6a9d42d2dae9be89841bc7328bab06b88bbe1256f720ca99c056fbe4e1378d7cf805586ae18dcc55 -b9a8766f4f4bf796e2517a8a7a05bafaa6d3ec601a85c466d33b8a7e0498fa1dd4e2a9e42161fe2362c81d4c8ee1fbf3 -8cb7d054162e9f41245b0914e7dcf6108ec11456b39b473ecf6c40e56b172fe5be4e7b0753a3685667436796a977b977 -9131d0395897f5591ad56b62ef83a3ed9e7b3951080b33ea606a15742f78a283f924373e813b877f32762dd69884658e -8d784d7f0884cce988305d314896dc6dac2d2934cf5d650904e1397f9b9dca397eb7f3accad60ab5e34cb2e494bb640b -8819629608ca1535bfc156c1e17f8fce5821d81e6661bca75a1754a5919d0404e31e65bd509387383a4111535e949f5a -820a6f46e251a1e6d92784aee18fb0d265d7e2f0a5b7e0b15180273eabdefb34f1d575e1d8e93dfc2be1114d10abf31c -8d10d0e0557beb8db344c2d8bcada724e720823fc37ee7c51b322c3269559ae932bb2ea07e50d7ada88ede788839dc8f -911a333e2f7578a0ff6533284176cf235036047a11534acb649a0043a326723662bccddaf1970b7c37b5146977277b88 -a4be2104cc5d6fce4a46de5de8d210559a6b743b6347b8d9990315bb56cbf80695ff936afadfdcc415d88b23ce6863ce -87ec5877ea8f1123371c49263dd9fedfbde41846a23e12073ef80f7afddf5a0ddab298cc02e861a90188ef1282139ecf -a3f1dae70745b8284b1353aa6902ebe3cf5580e24e02490d42b2f509ffec7e8e777fdce4f1a92d83bbb23cbaeaddac57 -8ed5a0733b42482d88da7c24e85a841ece65f6066dec060bb267a8d1f1ec165ad5f7964c2908d3fbdc2999c580eb8990 -b124a1db23f4875e0caff1c7f4b9a411564b93a9ec3ad8143bc7a70b8305d380b934c194de8201f7e3699e905a1f0115 -8af58886d4ac5578a29c2e309a68f19a62edef5285d0757c42f0ec2550c633c0e991c4cd7a60df4523cdde40c3909345 -a63fbdbde883f54667c6cacb356db1fb976bad147b790064ff25ae72be53bb6f4d74b22ca803996e0d95d216caa3fa81 -b99fc9012ad938b36246a4471d29f0a2b37b2a3be6fbfae7ec9fdccbfd14d48fdbede0d88ef3b6cc273f2488f4cab55f -acb6cd4e1672eabf530d38f50ae651db8bc4025c2557c59ac4f1a278b4741f1e2cda978e5d1337f9e5aae77c95ccb872 -8f8f6964534e4a9294c61c76206674d836d4d56970e9c14ad6835adc6b0d256402742d8a4879764569d9082ea6a750cb -969607ac6ca9bbef4fbc2fac22b12714a31f5d6103dfb998c3b6f2776283ebc7346e81a22da168af40752f28ff60d97b -b633f60cf6eb8ed588c545c04972ff156cee767edf31720c9715be3cda8c8de0290b623b22cb8fadb1690bf3665a7be6 -8235bc2e818e4d259bf2c9fcc9646ccf83b7e238044e26be417d1d0dd5283d7b38c86e8c88a5447645be191516e2993c -b503052246ea840a4083bb4a8978029af3e242e831518bcca015f2c2df504e98a48c9002b6b9fbb97e861a0a3c5b4b5c -a145ac57d7c028c3cbd2a2bfea25caa35a9b5d69cb491b13eaadc2b0d927a590decb7c4995541f8f29089a2cbde6429a -80b4c0938058fa5d03c948777f13c70f46fc025d4d6c2f2051915b476eb0c0bef902374d784df57ac368c01e1fd51c00 -92eb253e3b1770b36c4b2869a944caeed7b5c8a5b8356b25dcd4102df79fab8dd2c9d01e3253070f1206d149c43f64e2 -b7979ad6187f7921e725787b0a99050f4c98762c63fa64a467f7f110932f6d07556453a95e3a2c0162bf1c9c41424c90 -8808ae4c7cb38202c8c8bca0321e827580155197a700fa54b6a15b0f14b001327d4c9a0923168bb5afdd1b45d6a78367 -b16a4ceee9de5f49a99430e18aefc192f3c1ffdc4b41392069f690893bccdca760e6dadf4127539a763e4f60aef37dde -8ac113da7ca59ca97d6bf7d6e03f1e9570867bed27230515475f965ce9ce0b424c85810e18a584ae5a3d5c2c80c6d4a0 -847ae1b0ef5cb11be37320f3ab5e30f59d7910ba3d7cbf8265c74df25f4b8f56f1ac96cf49fd166c3b6985d1e8091e6f -aaa9b04f50ed6778e2481842cda30c7dbc7d462b40c7602a438ca9f2c1599e83fe6423f30d7789fd240d2e3166836f5d -8c18492569faa8cfa1c2a05a0edeea3f63d003e38d9ce23c4a5b31cde993a4ec88c9db83011ae15b578e0d0f6b72ddb8 -838b400217af9241755032c21a3ac4610f77f3ad76abc43f0c59a59f9bd52f2251e46fcf1552b6ee0220f4f2902e54e5 -8675f8de084c6c05644deeed1ff45090096c72c0db6bb2ceaf1c0d070bd10ff1e83b2dcd89b6f99bf132d3e131ef6d0f -89611bc63c83d56131bc2a8653278b234b4635aa7a05033d71a8377a5d188ffed7506a50a5c37a33d199a42b9e55fea4 -90c290c17f1687a87023fadf74b1e10ad0c0414cf08629b2a313347f0f6913bbe511e5d18d1c3264b47f65dee7887d4a -a590bcb6391506035466dea82617f11dd9417c9f379d32b4c3bbf723840e1a3124d2327deb28849aacac278470d7ae20 -97c55f459ebdf94ade7bc3bb18b329bbe2bccea345f0b4dc38cfff2839749b8f9365e8a1cf31722649c165e265344c35 -8159d02fd03c1d0b3c928658b3df1a27a57699ed8a573e0c3a179e97f50b6c1a6467b7055e42f9f9c6c858459eed517f -84d4f009c052f3bf76b2b972b3d8f7a4b2d78605a566478670c33016aab06828a1737a36d3c9173583e7bed0aee84fcc -b99d7558944ac2d61f5a800c24ee47fca719e69f7284956be94596623cf434a214c042aa46d54019de3556540ea53236 -8d1efbad46f69b80efc5776d8afe95dc0a8182d57318b9f2d6fb5b7d5c48e7181e6bd61a8446a553c58f7899ea7a7c78 -84a9cf6a9d64cee7e7d8f0b678d3606c9080ab3ecf62fe0d6f994a681de68b30534ded61db1445a257b2c5427e97b36c -b6a5d2c55a23841a4263b10cdf784be6fdfe1b25350a4af510ca294949716711363ca19f9c44ab1c347aa3fcd60f0573 -b1b5b6dbe6945db539fe7e2de07d222c88d7b91753118593ad9890c55c4c3d83b4194f886ea7f66ccbb348f5a23a2a22 -a8a58169edd3e58f87fe8529f5cf7da7679807467ec707ab96faedf75085185a78f2ef912d9180a5e820adfad32ae4ae -874c1f416f866756ae3e93360342848afdea0048a575f977fb1f8a57325e50da122d3e9f423e308f0acb1b28fd47a6eb -95cbe8b47ec42a5c72ef7b1f91e3de0b1f648ae8069416c48d5529c9cffb104ba4dcbe87cc06e4e798a1b23bf1595f9a -a1b6e9c5d63ab1262559727872d1140b74a4f01c12366ed2d401c64007faf7917ec591b631c6bb4dd44b39aa43c7f965 -89e6f4a05679c95d45b54e760056378a5eeacc72624eec8b5f19aecf8ef0d8acfb2d807d3b88c6b1206827203f219905 -b7f7b30cdea6377d5f16d200b987e3b4a6f28387faa701dc579cf7b3c6887d74ca43609c5bc36414a6dfd0317ec75448 -83474b58135f3e2c5e8355e31ae44a77721db71cb2919c3f3403f44903622d4116e812ea9ee9ca073938dee780f4aa22 -a3e4cbbec770630c5e2f3b67059a55b1217435bb70ba5b5010244e241ad6a3e6b8d9261d8a0765c4b42bf795fa4e96d4 -87d3ebf0fc03ad67299f3b9cf9c9ff0890b1d0d2d1a0ca2a62147444922d207663329e49898d79bd8e09ee48a1560fa5 -a1d33282cb17c7a4c5cfeab4dee8875d324aca8d0513567c4e5eae180d1e8ac98b2ef16b31afa7c3f2ec25cf3e8bbd11 -b10b6cfe3ba563b41ae0d66813105948416ce0848ba3b34b8e96547e8842086b632a52904e56eb61d93e0cbdd402d305 -84c4feb35c8d3583ca17245e6f7e73cb488aed515c2ef671b09a04d8eebe6b7579e5b1fc8634fcd4c3bf8100d2cb98de -918d8fa2f52a9b3957ba412c24cc579dbd1f0b0834b909a6ac0da5dc602ceec17046f61b3d4a2658f724757ca8041fb9 -87296e4775fb887bb00dd3265f202f31a8fdeae5c6ad8ec63508476cc57d330827d0d241c68091bb724a2ba921694a7a -a8908019d96c506b314c84b22c475157daa36016a9b94feecc4571e869918e4e5a9e39fb7c9ae0f73f9f868bdc50e2af -abedfabf75a93e7521eb339ce2e22e0e887f94ea28d3adfa42d1e0523686c6cbee4c96b2bbab3b8393feda1099b24d4b -a464d6bb17386cb431520cdbb3818beb3951b0255d72f58c300fd780aea1fe4dbce5532f5321e80e16db2f9b9bfe8a1b -8cb8fe0df930e1e19446ff0183c7034e35e33442da346df8a802160120a5f4d8abac236763114a650dcb1a1d38bafb37 -975c47ea6412bfa97db9cf12c2b4c07ebbda436716aaa7253b2343138b36de6c897386833849f539bad7659d9319abce -8cf94457a5a708cc91bca9615e599b0c0afa92a7f2d9c83704e05a3dba56a90c4eedebb6d2d25b3080786e16c27194c6 -950d02a5e41c8f704184c7c59715fdf3b48d86b53b04dff7c21738c7c38c9f4f75349ac1e70ca18a0744b01fb8b13504 -9458faad893db4458b330ee283d6a90f68346332c99cbe8e121c890bfca908f0c91168072aa221c3c078d7fd5e4b44d9 -b0262948c113fa2a122dc6208250b62ff35b12d3aa1e5735e95198424cf16a4829e9211c9edad83989c537572c5b41ad -abed7125de7dc52b0b42cd34fb350d4c6c45016319ab776b52289bc8c2b341a15d48165c0eb09511a1a5a5ed7ff39e4e -b4c352b4a127afb5b0833d210dc2c216bea666e7c5a940a3372988c0b02dfd236e4ac7c124664bcbf353132d6f061f3f -a334c5919909dadca50f3124de06400df660082b527f1f32b386b9216d021d38685f1839bafbaa7950eea6c1cb14bf53 -a52f4534e9de29f91039af3fce055f2f6726fd9b10595a43ae41f7b466cc4ea6314487081e867ff4b5e35cd622fb428a -a68c6ba9673896bf49ed145935773fa50d95ec0103f97a6f1ed698d93b4dd78111325f797e47fe153fb3852f4590ee89 -a5c456d516a557aaca80441705cda63d081181199097e83b22e9cf7b9947a8bb78cc476642f04a5ca3b13032319591eb -8a359a3dacc7b45da2b826dc27700178553f6a52e9705451f24c6d6026a0c597328acaa10b3b5a883b6353eee4eca594 -807217b435d73c1374bca84d2d3e069db756176220a01607b81438a70f69232b82099c676fff361dd909271be8d5d555 -965d0f46eb0804f19dd700d8721349287335c70e992efdfe89058ec424b87acccb3fbb18d84b727ff5ccb6f6783e9065 -aeb5f2a0bff1e6115bc2fa73093019f8c679efec91d03398e24651be187265f7ca80369a1dfa61e8701385dc0ce9a0a8 -85732f872228dd5d691f1507ba00cc94e054baa59a764565401e9e9b3287d2d0cd0f2af290b28b5e3c80da9cf23ded63 -8e9a315c5b40e7cdb866b8a7e6ec01eeb27a52a76a88d5956ac3e66fd9ade3ec954acce816227b57fea6ae9244f1303c -80436457879607efd008f959cfd7507fbe22e417c701f59b5a36e878a04e51e87eb38c48c0992333656b24a4e671bfb3 -a012f6d166cd1d98098544bcddfbdfa956ce60011694b640b012da3a0a22ac8a054a9e205aa9fae4df764ad60c65a6f2 -b8225afd6e4d45520678e243d97bf48f87c2b8d2cbc24b43f94bf6e7f60b7768d4c3b30d28a490e7c8a1c3a104ac8317 -8437fc2ab6d90716419f544a1d16c607173fae5bdc242d8224d7714c115cc54f2246d1062ecd77d5a9cd3ebed3a8adc9 -b113c6c63125930882c18f548c1baa69a26f9f3dcfbedf5be41aecd61adb896ff9622ce038f0ed27a5ac602b6020740e -b893aee6291a3962fe17ea41322de7edbea6ebd51d2c564fe23ba8a4cf4b6270b7ac72c87f2cbca209be1ba607ecab75 -92e6a7494114cb4dcf2b86ba61f57f6db7e4d52895ba6c896433139eb2ec9c9604f3e9100c690e1949e32f5b7e29de93 -881a323e772a639553cbb401e2b6a255094412addcece2c99ec9e1346aea2f4e9eb247552435eab74799ee4c7a927b6b -8d5d3ec378922311374fcb998fe5a42176448b629a6475abe494fa56abd5faa5835af37624c138beeba649f7803a4855 -b1a082ba449e93cc15fb4dc5114351437599fbd4d28eb6b4746d1bd242172518f94b2ca8b1f76c08d9f6ef260d9cfbb2 -8fd2b7728a3c61cd8e0c607cf40e935dc45d52d040ef1259f62e3eeb30bd3a6cd030fcf407fa0b21423b23a795a02b90 -9214aee5787f4666c3e2aff70949dd679d4203a2c3e7b6f88c548b80a3e52d7763f2bc2b7df714eef053f60eda4db331 -b15df25b62c6f4ac9edc414ecacfe8eec055bb07a1220e327bf35c5e452da7620df03416a449197bfc8d948445c5f734 -b41ff69731e7f4308fa18ad286d3ecd7be21afef3d32f5133a0bae877a347f8773c6e9d9b3b850d054236a6f186e6913 -8d9d13d1b7d9df41cf5d30dd62b9d1d2c4933d62b6cf8d1830bd1ae4dd5fa3de36bfa1fc4d57681ae13996f85ad2551e -8011a7fd7534b248db40050edd9752c960ffd89b0300a91520759ad51da1698454affb4aa8907946605a02ca09a7f340 -9159054fbc10164fa19f68736c2a683d374681e6e9d5e56f7496aeebb0969b8eb1a91e377b3a2928879147a7fb60b3e2 -afd4980aa4661fe05bf9040f6551d980af562da69ec5072104d8ea34a8ebd28baa0b70e0fe3c11f631005693fb99213e -a92879cac7940c6d363ab3d0ba7f7f24bad0b16142c78969a737c27ebb09a62071540bec1822ae6224d943d02804da50 -89338d27ba29343279dd83827ae17a53e7d634bc77bbd848f3b6a352fe92f6021dc1c81ea6693b3cbcb1f24188edc757 -a2490a856c273b6eb5242672f817e60a157a1dfdf25b1d32e0f4836a9c2371fae72c93b94d78267b3cb142b4f4d7148b -8efcf5d06107554f896084e32e8dc95c49fc5da3f8c4be4ef6f2ed89914233eaacfea886040bfff14759ce28a1eeaf3b -a3516280b169a6832e997a4a45daf46aeaec1d8953387f493cacc2835a5791d4dcb24a0c0ad5de79988d76f843d79994 -95eb7531a46bdc51acacf7fd9e7210bf6d5ca59b0efe58f79422394447adcca6f4ea991600e8558da8e19e029701c5d7 -b1fcb4177f16187c76b421c29f715f1551ff365bdce9fe17b74425f76dd90fb4ebe828ffff3d20f75ac620abeb9381a8 -886246027be4062258b232926cc82b6a51591138561ddd0173ec6e4b7ff750e15d9ba175f569c266148c653ac905d498 -952c089dd09dbe531f2fd4137c971622fc1d85a78ff07de634f63853f62110dbae3646564addef8f2a070f5a16396ef4 -812ed85f4559fb28732d17c8fd7c6b09a70da454a2318a0276949df0a5dd2714b14096656b7b5b6398f54c74eb9ca49a -9340db62e43e43144e1afb1da748e81a1b00f7b0600e8eed117e92ffcf801b9d89b494ffb003b4ebd5bb4e0eb96c9374 -9287c0745b4bbe24b56784ac28bec43ed2abb6bb15bf11ba2b18b01801da7d162aef88e967d2f10fb9f52f6645d7702e -9615bc232ba6053fe86c6328eead899bd62c4f975273f72595407fe36ea43e30eeac7524bc17dbe78b4692d42ae81c04 -a387899b521b1a89e860756bd0986b302f3c06271ece653425d6c697e0b330a3ed7789efe0e5a1b32e60257a12fa0147 -b4c99909fbb92b1f39e9b2fabe05abf58af834b6c15ab0f62304ccfc5047f187a3ce35388ef293d2857b777f9938bd55 -97dcb90d2dd9291366b557936931550d665cd05bb1b19a7a53a31c2a39d264789477a47ae14f6bdeb171e78941a9d9e2 -81417b4a3e61ab9b48e0ff1afa8b523bf63ef95a6d6980092408b61f4293fb202395b10a5d12dcc54961370c134d5b0d -9135da893ef0a9d45a719207659cad4a0590218303d0e02016bcc5d14f54de5fb8de642efc7826b3b3212f714114600e -a00d0f8e2ea06b13f5a75a6dbd1f2ba7ce3f3bb3e62cd3b53f8b6ab39431fd2ce156a1aa4a1988613d4a2b6d91550147 -a3f8f17dfdda07166a7e5503366dbef45ea6b6eaa1dbe02b8051dff58453f1ac24762c82f6db6de4370869f9b25d6d51 -847c2b79076f9284d9a866a72f74f62fd73cccbe2df18c0fe34a35416d4825d364e24f95f728bc0e6a5215b08b6f0d2a -9816284cd6b8b35e1f5409d3a5899af5f4524a4826470fd164fcfe863994ee3aac77cbc16831f0866b9f0ae561903d61 -8ab1f9feaa8ba2e1691acbfbd5460a4bab531344ce4accbabdbe5ba8cedb5d5fc0967def4365d755ecb62d83b7ffa4bc -b0cb477aee9bd113959ff7b7675f81ef251b76cccbb67cf68ba571fc08561736e32c18aae93fc8d1912e7eb2fc0ecca2 -8cc41304caf0357d13a25ecf66336bece67d5d319bc5a50328a96199d7ca4fad05dbd7b5edda58be73141bb06e269c8e -a7b4d91a884abad5337925c34d7fd5f2aea5a09ff3c027cac98c646b5058f7fe2cbf47208930509e2a4eef1468f64c89 -97d942e97efe46594e8fc86828ad3ed1c9133a8067f9b11bc0f4ee3815affbc0c7c46a91c40f989d50f1d8df96982ada -95a7d369f3ce7f7ad7ddf85bc994667ca25a0c2f11b9312d06654599410d5325ca3ea74f33f21b5aeedfb582a9e40c62 -b0a05b564a754b46fc7aa4f5289f02bd9f19708b5ecb9db5c36bb7505c8b56ec22b53fedefc1df289c0f636c97e8ec47 -ab6e2801ea8bc600f9159d05a3b39e8b0973fb9c2696b3f2685424757a6953a9f8ddf5e29c97399c4821b8d7fd9f1bc4 -a6fbbad2ad3ce8e4f9b939080e9e7049eba9f76b8ffb57f7cac2aa46793a064743239ce287e156d49cf4936517632290 -a606632b62194aec737403ce5a9b6316178c1d27baffdac83981baab63e75d51caa414ea92465ef37d6d687b4fd90141 -a5a99b7bf8f4c109af04c31af9b5f3148370319c8483796cbb5ef555ee1d4858b2c1acb82ab5e26180254399fd7a0625 -ab2b00f64355ad294436339636e7764403b821d4dd4fd74a6bbdc2aae450f14d7dbe8423336e793a393f4580f1b9e35b -a6c98a6ad7f36f16633fc216c12ca34e596b292524753ca1067eb75ab52facd28ed3a7c55e0a0cf1d3c9115a2a0d6524 -84acda31e618eaf0424a37cb3c386585a3870b2c24020550a16134ad8802d427c918e2854c98e5def58a2363a8e1a314 -9911ec15af39af1a18003ae120da8d909ad4bd43ff03078091d54de71de70e19786b2aaebaa5d55d9b2877004da2c271 -8cb5a148f065e36b67a219bdb347a625a7a4be8f20dfb1cffbb38fd4d843c2b1b1886c1f015793bbcb02af04ed91b170 -815d9adf22a36533fd4a3efae3c4326213ba2aad48724ef958cdd6f0dd5059b519e12d91ed5d92f1418a07b62b108bfe -ae5c244f309467ada13e2fcd8942886f563bd996a5c65aee73a364c2ecab49be3ba6bc8a387f3baad44776f4f1042eb8 -a47d93b35f57ad890239a6f2f69ef8760268adbe614d5877802db4b6cc75cc093baf101f75be0f7b4d71ad8724dbb9f7 -a0d089701b965df9fea938e337016ab20e0e567e736e6652955f1a93760b4a9f128be5a594e71df8e7db47c3f88c2fa7 -a9d9a7170a860e2860f785edbe18ad909ecfa489cd3a2abc580869c7eb8e9a2db93c1c473a5f1474ec0d51dfdedf95e1 -b665abdd084abd292548c336e3e6fa1c5ed1a53d2e61a10ad6a4c66487d8a9e101632ff468b012506135907f0896156e -a10ccb363b26beb9622e1d91021d08a3bf02bec96a059ead01961ad51610992ef03558c5f77e074442836c9d2ff44e0a -96d6476066264eb3090ba3544dbfec7c8a0d90985a1697985db0d04773f6d37d5899a9d4fb5a3207c320ca78c37492e6 -b4290ff9213e2ecd30d303b2b4ecc66c2614b8df246e70ece4e55bea9a1f5a0bae9df6dcbd8efdcf8c4b0f2f4cb44d48 -8ef10b2e53e6770a36b6403678ffb86f5d85e3e87bb1b3ce9f1f0cb0cf32f1fe991c565595389ad83d8c8d54a47dcc82 -91f950ef60014e3dd28f7661e6275ab6f085c803988b7d6dbb2cab25f10b0372e271267245761e1af97da6f48c230205 -97c626e7114396daa337ada4f08da5129464d8e8c68a407c8798949817337578733fbcabf454a22b57926485c28d9d62 -b596984b609a9858b1adefd15a546d4b8a417c8b54504efadffcc805caf8935b9c7f55d9e6b34592241195f513453572 -a3fdd36f3eefffe0cd2a9e6cbfc4eb9c3a499eec25230df8786b23f5eb71efddde062940ac23d5b2885081da48d3c1c1 -aa1822db9ee136d0a51910f0a59bf0d2af6819e4ec0b859b790e01bb08c1def87e9613b355525d4ab7d088b520a6a3dc -a9089edfa96fdb7204a68c4ffcb7e0a875106886a0c589dbc57a6709e7822747affb07035b99d056baf11d0852720489 -85664ab9d32ab0cc2d2e61901b2682f88a7259c2da4ae6263b917ae8afc232614b4ee56539a868a24940eab74142198f -b90e06a1a117659b52b364359e2265daaa8981954e9a9c37e3256cbabf133dd4900974a895dde6ec6b394fb36b5bc1c8 -b414aefaa4833283dce85add23d1cfd776567735f2ba9018cd791d652bab55bb0cc0cb38b88fe47e3b4b877e63edbd75 -ae579eae9c0b09c906cc2824eeebe5b4ea031547055c8ad635194f3e864c7a184dc21a3eca9c43c01d9a2f272cb2ce81 -a7b1d13997c283c13f770d5203cb09b5d3ca7d45324ec89c069928e1ed1a17c57510e0ebaaf54a21d27b0f9f057bccec -b15d4555520565b76ec21d87e094ece2e04c7c4bbbf560264da37604f1a484ecc3ce8143b04759fe716411293876d0a6 -810bb0773c06caae8cc06ffc92303d51eadca1e1b0acd57ed23f5feda70378e180619f68b8db98e61d792568f49a8316 -87dee32807e2e5f2c884822b31098e5be2a4d950ae728e3281a39e661937c4b7e9fc025b50f437f01d69e5c33dd751a0 -b46810bd73d077a6b73757d22b5939c02a3632e81287073b00ebee30cdd402e89c318e0b03d01fa331193842f3a1ae53 -95a136a7bdca77f764d2c2d4795a8fc9e5b9097d73bb3956b7a45b42185a99c949db8ac5627ca263206cab9cbecbc31c -967eee3c3afc138a482bd120050dcb9b45a9fe258e5e4b678b1d67b4691f4c5d89cd260210fb50f9cf2d3e2e2802968b -b2d59a9ed0448b88f8eb26d8017a129ebaf27f11e0a031130266796e5f777bce93cf2c7e0fba8f8ccc997315db9aeb9a -aec708d3093b12caf29efbd8afe3ace1de24496cee72270223aeaefe4f0ba3a7acea7f2f5f85c1f274aaf5188616133f -8563ec52704c1c7ab515451a8f89f87201d30a12c95812ac95fde2af033e5019615a07f28b540a92781ed35786b5614b -b1c8f819a4ceb17d35ab997c14f81ae2af9d4510caffc61d4a19e9129e0bf7264482a10f329054908f99909999b6f538 -8a65668637ba24358800076d8edc90979d6e614e6a683dff7859ce7d686014e6de85298f523ab060c9a9a4c4b8862cfd -b4df02dd6f4d3908142654a42af60fef034379b1526c12be66afcfc4f1177991811646495aa85702f3461060732cce80 -8991bef253f0bb9b86e68e81f78116c51097004b0309e199025e45ac7ea55f8f6b2bdc58886899d275424ebd405ffac0 -a74f1048548fb41e57f679d632280fd2e4cc6ab88c81675c59fe143b74dc7ccf050db53dac5611ed6b45b6a0b1b7f3dc -92011c668bff7ea995a71e4774e3fb5d521ee2552bdc33d9a65afd9677572c2a303a940751ffea470af898b01b9285ad -881a0e6042771492633b46b6101f96a48a93aa3860533dc207cdc90783fbe52b4a9ade1eea9117cea004bae802cd3fbd -b3e578bfd77a3a13368ecf8139b69f729cc720aab25853cc9e2f505c2e03e75cb779d685698af8cc4aba8d1c17f5ec29 -a025b6e8dbeb68e7ac4a595b34089fed0d24eb29a7be235048205e35a97634d6015ab24c21a017b5012c3175677fd0bb -b751acd86ead936ed0f22d770872cdb5aeca3b1ec75a5a1e65748b665f8d1c859b5620d761d5f0a2a86331188e82b2a7 -a05faf0bdb81caada6c662ed2fd145eff5db5c423258d6609bfd4c467edf3ddba6480ab95ac9f4dbc932f4887b070c82 -8fd1faccaa7cf1d59be37bad69b7a99b7641cbfe930d778e0f712ae1fe9e78d53f37d7d5d3aafde48452eaeb65d980b8 -86042bc710953f0042940625d8b69ef57c615f9631fc49aae169ca595446e9d55e149c92994d4bce7b544877d7b6f22a -b396047f716c5fa8ca9234c7026f1772d83f41be03410b4a32a376e5a038d252b8f36cb813bc3684f1b50326994c31cb -a2eece2d76db005f5d95f5f480bb3353ec67a9c27896fe54a2cd5cc7f802507d8d518596601bb3d2798842b96fc03df2 -b738c1264d094f7b7edd27b0ddd8e29716c73bcf7b450ad7715fd21e1052998675873ccbec486fe45a8f72d9b006f239 -826c4c5fea1596e353f6c15d91a9bbacd9ea592aba4d22e735263062eac44f073e5defb794f8ae4afb7d4dbcd1ace959 -a8f1d170f63ae3b05ca9996347a1b3987136e7bafd02774698829986d48da3d421d269d31743bfd3e7917c5ace7ce729 -ae6871a8278f24d816657889ccdef509df0fb941fe6c5839cbfb704e81b942ea2a324fe0ac9881b385bc97410fd94b0f -8aa6bb564b6a0354be89c4ac10309f941162fb3a546259c5d789d4608cc628f69ecf814b59bb8bce364162f7552e628e -8ed85481cdc58fc540384213dd1b86f80af8908683d7d2c63ef5f8c4ac2e90f0e5f4e07b1b841eaecaab1f7e091423bf -88741d9c9d875e2c1ee5b95bafa4d8a22d72a728260297d048e4f0cd1c5f1eaa94fc233be3fa15a69163f218d62ab17a -8a99655974ad5c0f27b49d88a9c52a5375e16b9ac4f22b1e1bde53ce0a21589022c0ea926a4c2d7c432a53656ccffa37 -8e2628878858764824471fd613cf40d1bbb3fa84ed081a762da0d6d491d54688723273d87a587ed1d3067976ab74fe1b -8f1a6162bd6cbd2353265bb348311073bcfca5a86f41cd0c63ab91b14aabbeffade5ae8a94f8e91faa386223fc2bf849 -aabe8cd92f0193d12b032a9bab4bf4f02ebc0b24d1ac09f8ca8906621d6c7d4bb436b2dd879a1a1cca2b44ebb5642995 -91cd27988ae8100d48ace10ac9cac4cf1cc8539bb492521a8a6489f8575a737f2a1d37fcdbe88dd651179145a59af920 -8baefbda554bc0a0b425f2e132c7de061fdd120ebd452ecff0d78cc5bc5b15401997231727a37e9bc4abf1a553a4cbd8 -971b12e25b989511477c04602f48f584485a0a0773b46643190263c0288c2434969bdddb1e55dc1f5b1b028c1c53eb32 -a0e47f42444a16e51323af6f519c0dd2271a85746882818d02373ba33c2e2f7bd6a1c321497377e4781f72427fa34224 -b52bc02de867d7b20cd247cbf496e03d940be2d7ca5755145e9a0168889db345fa9ab17c41635ab275a459fc9d02ff16 -b01db7077e9f01e675c62f5095400cdc68a059e1a5005027033ac535a0505f45f89faae4fb9831f7ff9cbad3b55db02d -81ae065f1d55f4643a2ee120bc1245b9730455ad9e5402df8d6fcbb1bec71e40f1bfe7b8e67f96fff76d1478cd3973ca -a1be3723920044be80f398279e2f8432aaed45a36cc4fc71c87f5dbfd52225379e94600793f40aedaac2391caa57d155 -b682f74fe46d4b647196b7c14804dc0b35e36cdff59671d7164ece874107964ff9f76c29b23c190796a9a3aa2df822fb -b8152e458970ab53f6b5bf6101008c5c31d2f58993474eed6bccda074555f7ad2351810d78676b62612e7eba2d86247d -9132a8fab2010360ca80adcc08b3a01658dc8ba8f60bbc45e1144c1219f69b985436c36c65cd7910a8aebd91ea1d3d38 -805cd373a0919de801b6bb7a6ebf55530037fa41a1993c159e90213c492165c42b5642dda5fe7283ac4e3ade6e63a155 -91f20d77fb7a8276174989faed41fa6da841d35b074c4a756c2b4730a7efb9b124ea6c7d5eb150a8b1126636cdb2ff0b -8cda3ffbd0ab6846dbee6cb8c0360842837a65f83b6ba17085161a7371a4466172354e494a8614cf2f1f4726d0a7262b -adc603e61dc36ee605dd7f2761ed568bf91b9dd3d40903eb7d77b11d10e4f762694fbbbcece72a7ec26976054139c768 -a6accdb3df5029f19273a39bc30cb622f87522ca5a63372dfe61d993dd783ca5e918218b5c519d25e535d8b8238339a2 -a188897269053f2494bd0de8cf098e41010fdd01f5a49d7ddd7b294ea748f1139e0d92fa7841dda9f8dc923ed6f02615 -b26ad5dde632259293d91109fad4f742ab74de91f68ed2416ff53c060d1ea4377a875b2ce960cb7962c37a5fd47e85c8 -82cfa86a17b27f375172d66b389df727734480a224b91585fb4782401d6c49d4dd347b8d1e8df6b9c0c1d2f8ae658de6 -82911748e1471bf5d7fe3ff111ac06dcaf5b8a43c76f6583ca491e0aa845b61cdd443613c5728863c163952d86bfd482 -b7b0d4ff87df02b5481183066f6ac0d1636718fbddc19889e92a71a168fbe338ffe780a792ec5642aaa4024d0964db69 -8ec21f08594ad38e9ac365e5246aa5c2c8e34ae66382ac483b47771c33390ccace4d906695b1ac0f1c9204c46576946b -b9617d746596b26b84f2709a03b64fe77e9a10d0c85535d92d28dae9de3bbf6455a247f775dd9f67061792cb924e3925 -abb2ff3f16309fcfe0a3b1bc928ca5cf618706cad3645b029bd54e5305682754e6ca47e364ff21b1750f45041eeeb358 -867abcb8029b35a54552c57346024ae7eea38e9ae4bdbd68bb3c1de3935126880f237d9aa95d6644dba8ddce67e343e7 -86eb4283147a9e595d639f29a967310acbed9ff09d9043868fd18f0b735d8619eb4ee0250764f35a51e00b58543bcc66 -af1779d2115ca7021533bcf55a100b4d3ff4e45f8ce6a6d98df22881526a429d97818fa1867ede09918a438957a03534 -b10b36d0b69b0dbecb6f7efb6c612b0462c346079109970a26541a21aa2b5b81c1e121ed0d5c81af00ea8eb709a83dfd -911f81ed75fed55f1fabc5f86f9f38490e006820e5380963a739ebc0f87a1dd3b7da8c69dff1e580c5ad2246bc08e2cc -8379449499da9159cac2c09c61777955e61c63378d051bd28b59c78409ee5d09c43e7a6c246572bf34233a314511bbdf -84b48ec8895049bd03dc3256bd0d63f6e9abb178221f7d47703b447c709fc5fda47b19a3439f30f10d2670194f390915 -ab3bb5afe824d8aa20f97ead4c40aaa93350f33d980b5783cf56c8552a4298c989b7b188d023711a2eb79631f3a8c317 -ababba2722186a3b2272feebaf2ff46c93883b7265a6a4fba039d5fc0e7fe81b7d4dc2cef7738406f156f693ba3a55eb -ad50302a51eeebe63085d3c1705eee9142bf8717d07c5d87e0e4ef5a12207dd5432994c72b9493f9ceb558a20929c9f6 -8bcc3d83a6b8998e1a1066347c647ab122eac80c9c505d5cfbc370f466349671d8da4d500201226c15c1f62162efc62f -aad6946b5d5df34ee6f7422fbefc6de33dcf4461868ed7ee7f47fe9b8eb2f7a89759c73b7a029d422b02afd0f550e722 -b0fe1d9a30759d83084b4c567b586e5a8f5a080bfa93b4a3feba59edaec33b6a2ebc98ccd82aa9d8cf0bd254d5f03baa -b993c4c2b77fcfbdb213bfd5f8d655d1d41a52583de63b432e2732df2f9d88c4c6779f314848417c06a089fcb970c0f2 -842ea3aa645e5852695405b6ff2184e55bdfcf50be2319761e717b7b52d904ec47ad3abf986850c643003442e302ef30 -8093b0ef1f6c84a8253d086a6fda6be8376f925f416a9d1f44ea72489f60fbd8b53cee616cc5ece43e2a202653c0640d -8c75f10b6aa848d84baa4120e75d3edb7f8471473851326cbd9ed7b29b22c5403028f49430bfe4320c3f4227827e667c -b4fde4f20ab98f76f55afd533f1b09ee4ffbac9486399714514fd694fecd0ad1fdafe13b2b80721829c7a59e4c951a76 -843b2ed867cd8edc2eee84497dbd49f3dc481e7ece69310d06225325ef032a4e72907e16e7b6215ca775f88983d55e5c -9881e5caa9706e4d7ba6ab81525090e29ecdf1808931f3f2b11ff9ff5cc97f83f3e14fcf18abf18159c3fcf4cbc27042 -b6c4acc868c05c955eb36a24652314be37004bfc14283600523729d466c56018c99a45a41ec0389449fcc3f8aa745638 -b6820864d07715dcf4a9ece336464aeef9ce381ca7dba25acd48f60af056a3405c22792cdc57c641e782896c0ea05b25 -a1bb482e35f71772486675cb4ee0fa5709b757083d18a29d4f4344e6ce901b2edb2889b7eac92c498b90c7d3844c450c -8cd8d8d47de859d0c68bdbe1834a1c9a34e92636600fc592a08f96d66426c5f41f388138f42c9b8ad72c596f4bf85496 -801cc0631310656864b25d980c9e99a98fec2316414819afeaf182d3e7ff93b32a989e2ce63f5ea9301745080854188c -8fcc6b2b656f7960d9ad48c091c1ea71b6f0f61553f7695049c770afd509ee58ca8e1dcb403aa2c5acfbbba58676bd44 -b997b9a6b994e3eb2de8723ec485d8181fd674de19ac9c2f50704785d9f5a28fe3ad194eb052b5ce122ab5e6e6968a70 -a909e7002b82b371952ca9d0832f531db15882180e97c12c56da649fd65334904fbbc3f097b6a954469221d181e718bf -acfc712e1a61504814e37b3aad0d7a5cafce5901ffa43c13bc5f70507800ff03ed261367ccd09db7429cc5dbb892a7e6 -8d634a07b69ad87e41d941aca08550ae9cd72fe31f3075511d030c364fd6578a36f3f0f3785d19305a1e772486ca097a -9746ce2d890248002c1bfb755e06f4f4570cefa7636e10319bf491c654b83608766e95fe9c77f1a6a630f5add77b71f8 -a9dfa56bf82297f709f1b4bdbe4bc194bf22c0424815bafa6c1a536f2d15f35bfdebe0867ff20781a49274075622861e -a723af2702c6b473caa4a64142464f201bd1e2f765454fb0236082fe3ad77f22b4353e5981e6bc37e974c7ef797f875e -a42a1a0c50befa6864fa35c25a17f5309684c53257376f8111fe96c84a5e09376fad9c8545e1946f360e16e1e4c941e3 -84231f6bc3038320dc13f3ac014977326dd13e5b2ba112c084d366b5255729b2abe665aca8a41d7aa6645412765887ca -a64e21d651bed6dce8dcfcb4caa60791b9345cd7b6a100f5bb78f7423fba5ea0d0cb3668f3415c27af29ac35e5dab0ae -b8eeb2128ea14d81fec5b1103d8511a3dfdab925212363c75c5cc01515fd94be8db2335bb84e221654380e58e9f2be67 -a92e9cb287981b33a5e697eb1e757bd44f45efdda1759122fb27dd4bd4ce3694f1b6b2082ce4e6e3919d9d7a0b7c8a12 -88f22b83fd9dad63e800b0bef709759f380c6dd9af7058100413e7b09c7517eba258d6367e0cb1a41b7762b86b2ef137 -8353d45a2096fb4bde82ca22381bd2ed93fb58b236b16e68bb37df3024672067c4378d7f04a4da4d116e7d57a2211f7d -9076205bf231de091fcba7f5a4fe1d4a359f07236efa39f5715f206e5cb7eb3d9adb56af8181f63a9d3e965dc909556c -93ab7f56e8d37b47d3a8cbd222f2dab4bdbf94a1152302752f0a731294f4dc214fdba17977f11aaff2eea9517fdd5789 -96d9883ee108c88342befc358325356dfe5d72c521d71e4b3a58d6773ea3d1a1de1a20572aa96ca0e8483eba62466504 -950e0d61ce4e76fe0cdc3d59c5bf23d8e1cfa9d6ee13b9fe41e6ddc0fd52081bb16bcdd973d319c20709ec517fe15626 -88809c1e272b552d46137165e5396917d107547b65059fa646b742489e8892acebeccbb3eb8f2d676e3836c985cb1756 -945f13ff081b74403a19dbb04173780f04766f7624ac6b77f46464df5f4f3b547c459f41fb1842164d8f1c126ad6be65 -abfbadc599bcab1c2b7cf1fc5aac7798d9f617d6afa0469ee23230c0d004fcd3de0ea645feddc74e676ecab1fcdcd8a2 -83ea1571b064d05e1b7f4527b20ada121024a4b2dd8f7d551945488ccfddd671ed2ed3895578afcb3cf958f9a2c75c29 -8fa75050bda001409f2bc0a275d8dc0fefaa47b3a0ae132758bd711eaed0851d6bf3e4b7f355377a93fb8eb02b3ac6f5 -b2fff49083bb30e2661e2d8978149e0d0588dc972222f46d5d120d01dc5c9978830c442827c8fa295f6b8e6d8c786198 -a352c2dbe4f18b311bf0690d77fbc9439a1b8088c806a9d89071b3ea04ff387325cdc04a091d2bde5fd087bcd0f4f482 -948ea89408826ded81549cce823dfd7605ffc2279ca7d0964b1ab3d5f35f4b174e81575291edeb9eaa4baad3610ba3a4 -998073b618140b04ec394ffe4af02df044d923a5cbc8f06f26c9eb4ece17abedd4f72e10c9738bd16863327c0f6ee20b -b3bfdda0d6960af897ab508bd9312d9c166157f78b45157b46fd2e38ab2e430e8a19335d8a611366cf74642bda77bc78 -b8dae3e2ec5eb97ce3b5e9be719bb747e6e8f28dfb1a6b7bf5063822b502a5422cd586bacd87ef83c0af081ea4d30a57 -859713ddf0ae843ba690fd8177ce6c08e2fe5fc1c8893d829d39a199e04758719bd3046034926de40973a992ecbfeda2 -866f150d4b6a015b03ce8ad93a70644b55ca1818a0f50d24795698c62f3abe59d3b8abe4c11ffcbef20127d3b7afb970 -9145367ce9e2a5a6140db58cb097767b5a6e19eb36d1c03acadef612af95eba80048f2b02c6fb46eaf38c75288e3e4eb -8c298aee778f4af13329975754e9b428e127680f26be139307d43268dc63892ac98284d78ced0ecd384301e26d5b63e2 -b4c2cc9256fc33ed09531abd7c3e34f8f24830a8a2cf2d684cdde46155f43ff2715c94e7dfc7377765ec0cdefb21cd2d -b9193113b81bba4ebfe40e97be436515254bc67a94939220e5e69a197765bba40dac3369e5cde115d1bbb65e1c826038 -8474d72b7cb52768c484ff92d014d7733003b511c0c915649f65dfceced47ecd933ce876eae254cdf2f6357ea865580e -808e9a59f947b2b39af51deab4c164878e02d95773dddf1123091e27de87cfffc07aecd7c9cf3e08c0b9f525bd87fff8 -a8e0049eec8eb70c12446596ba5c8a29823704be3753312c34cb271000b6c154b1022812dd02d1352cd263b655437d6d -ab7894a75e40d888a4d0539582cfd6b458da009a5017e561c14d312335a75745ce134b57466fd30c250ca07e0529c8a4 -b30c5c0abfd35ded7a3da8f9c95e3e1c320857be1af317f6ff5e35101d3f31de3735ff8741f6460ae1e63cee543081fc -b15557ec268b4eba9628ccec0a5f3c947e624b61edc876e2ad8c36ada061fda76f69c8afb95270b85f4672171678d078 -b7ec103d6695fa64107f66622148902019ff3acbff7b77ad80993bdf209b73990b0fef92dddc5fb66aed77cdb59af9d3 -b3d002f0a35808e3785d58d0074be620416ee9381bdbdc889805ec2acfd169e1ccb60045d87cae3e90d5da94cd58bf80 -a17c44ade6eca0942742edd237661ed406a129a968fdab28a58d19308d207a1e7853099a4a3c1c181695fcf265107a55 -91fe5c0d672fce368e229e735eef43868e31265502e2876e54aa44470a257d1c126ed73d6df860f42d8e1dd425d8987c -8434fa331278fcdff2c8c07596a051847425fd7cf09af31bb235d208ef6e282cae173d6ffb73c0475307453d6133ae7e -940188d6c20924edf1d9343ea85ef9e08d9d87d2a188f8b69514a22cae10aa2d3ea8e662d43d60b8b77183b3c6e8cb1e -a89f57a730437fc511e1873830b300df7a417493a468afeed2f837f31641cba04924effe11be92d3bfabbad0bbb7d04c -a561550cb347fc9178c875ebd8dbf5d14c0afbefa79f7b93b893a25ca8fcdeb0293de5a350ef63413aa70745cbce9a5e -89fe7dcaa6a10cdbeee9d0d3bc8dfeacd47e1490a6c3b591f66d3a64ed668e6034381e0ea9f5f04fd2a5d9ad5044b8b4 -aac54b334514d41665b80b2cf18285391f47be820446e2272d69edce022f6d7689c8e137e2e9579d0846bf5440d768c8 -a231a04b942d471b32cdd12eac3eba00b8910fca0812c9470802246c479050d6c860f64bcdc6b6e39ed0e9609df9239c -a6bf6eca52b5f3ffd89b79be6edc4f517fe9c9bc67051179157734689fd63649e321d1fabda916a9c4666b64ed60bb4c -a7c4f791a1d77cfcdf34c3b73ec7a43aa1c8ec81c39ce81d12c51973ddb0bfacc79e1a128ce17afc5838982f66cede6a -a1644b337c4398f00e9ebfed20d9b2c900ccb667be036abba0c4d372939f881df2bdb5d40b64354f65c8f2ad9ffcd656 -84f6e86481d3322de791ad01d8c1556e5480534e52970fa601b295a40270882476779301d78bc2ebc323323ad0b62253 -b32eb2beaaeab27e190c9d381b9f3446038391da552db5ded0f5b58d070694f07c737315a465175da29e2a236c539e9b -857029d97cb9fcbb67e194d9aeadf5b25cf8184b3b704ff5da424fb4b39abdf3f7f317b3f79c762605bd9bdd5823e7aa -883926170997ba84cf45691c117912f6be5c691abab77fd18fe114577e6dcba18f8c0a6641ef59affcba1b2c92e093cf -945be3febcff77b4238500054a053c983add7a96ef43cd91921dad908c20d4ae08857fb93a5bb588e9b441aa9a536567 -b9efb8be322722302d1c06640f772596fc362586d8f2e49c41810f4bd2b59e8e9abf3d5369b2421e1ce6949c067f07be -920ad6d5cacbdb46af424141391817da2fe3d463bab8db760026f98e50bb51aa4f3668520c133ccf9622d66eb8a60e86 -a1a9ca07d8d3a44fe372aceda194f15a2dc3d29267aedcfc3fdbadff0bab1c4397da1049bc0feb9097afdcf1cd1ab603 -935eb5fe97d580c10766bfc2fbff71d8584e00e1a321018540c25f6b04791b63a0d6992257fe110b0d17712f334c9b49 -9530bde6dc33e48e05d98b77844766afc0d5581922e382a2fc1c183adf998c8137df29e56b868c7892b2c1af56edeeac -a8cd3698276c2bb8d39ebf7fb5fec139580755adbf81bf362e1cc19f4a8be750707bdf4e1fde3064873495cce5cf5171 -ac5a83c82004728b34677bc6b1fa507687992b5b78745e5820de08f3fd99e35c905608936ccab62ae39f0408334b3c6c -927b0077386a5055b499cb5a597ec3c9934767343fd91214fbbb5487faa4339837eab52c75a627d7addc5cda5ee35108 -a8acc2ea4a548d9a2fc2738abcf75cc0efa189b92a99296c0635d53f2c0d7ee40ccc8ae410d2779f95ac6f2027c81d06 -a74c24b8c695920b12a86ed6da6ecff72f8e19fb06fdfee9cd1c1e8e5f1c202d26fbf2fbedc9a5deaeb2d986425477ce -871251e8d69de5c3117f364bb95d876fb89974428bc167666088d5ff1b83328b675ac2efa2d0e215831e69ee254623fa -946f7a6d3d6700f65088c817636ed3c1349e4f5122fbc22723d131d8ccd055931dec977cd0cb8dd888c6abc51a5f4194 -82f7c1dc3f133725570c7b64e31b0397fc3a82cb4966948803de210182b9716ccd19e59c0e0382c0c970d05c5e13509e -8bc45b43102e0df4767156b1e8ec635cc07fd629793d289be1f2470297e8a084bc9af0d76566cc485a8ac898c0493fc5 -85000f8c8130abca642ae94b4feb3448390745decb1f443c34fd06575f1d0de35bbe649b46251df0a4bdc7a8bc133b2b -ad1ef07d34c59afa37fd5147646c24c03622ae4884c163b80d45ebfb5fa994699ad9166ce1ef727c22be3c28e0838cbf -8d1dd5500229f463f94c611bb2674640d20f2d34dd40b28c4d2a21d3e64ba7355fae55228f1c70095d1b288828a1950e -834cf56a4f2c2eb04b89383213b84bc6ba554a4715c3c1547278e5501102f6ff2af27cce0f876a2aa2da57b5ac6f3b3f -a468d06083d770bb4e484718d1c147b49770757b5b296fc6d6035ecb3c2f5c4155176f12ccbe6616184789350403f387 -8abe730d80ea895705bf67ac4f6b6a36fef7403702d8458a383d04e4859b4c8c7a75598721cc75793d29276afea27ccc -a3890145fa43e6b5c7b8aa0a73a62c39d623c9a75d17c5a05bdddec08d114ab5b0a865c9edb2be6ef31c3dc9544119ea -b2b7c1cd0aed6b776515a12a0f3a86353fa3d3a3b6027422bf7f2c21e6917dab543e189e860c8fd3aab65484b77efbe5 -95215b7d3d504ff83ae2bff789feb6b5919287d354d567141bae68a0f0d27b3e898edd8a9be5a51c04dd28ce9d4ab937 -a93a3da0e101797c690c38a5bf5bc14e10842e48a18c9888807b2233809ea8a34a76d20a8ece0b682d36c086853cee40 -849a7fee901a9279dcc36fe8f276ea6dfc37c30f75b679ddca2cae9c283de19c4df56790e6ae12c4bde33e837fcbc324 -b5c1587d84b0826e64438d8ee7c103119b164bede8d243a0256b5b798240259dd63281b81bfc613a4874a6732d05e143 -97600c536388c942e0a72ba3bc33b3af48045994a3ad0948fe0741391c1eb99693d072d1efdb644abcb08e10474b7885 -94c2120a5b4743496e7ab9bb2e474580ed27d7cf5b6fb132efcdd7bf934434d2be8d6f0af009c637b31727b3ad5d2280 -8a5ff1e7f552fa8b34b22a220eb1cb018c9c9430f0f14a634121923497cdb4a69fbb8b60eb33e5fdf9b0feb3e9f5afe6 -8b4c9032f25181e6fb9f60eb07e3d6cfa2b14ffdd6a0fc1b309b078f8290901e229a5a6ed96dda74e1a9a894224ff588 -a5e04e164ffc46da1dfe026ffdcd99332874a110cd168c44762c461a5560b5c098ec71673d509fc053f6d9064d4ba255 -97d21cf8327a81385fd3915c7e8efac7662f4b39a9785b4a936fe1b581d630678f42a3e9ea7e02bb4413da7ca9a6f35f -806d8462bbf148eb4cff812cab11b3d819669ef5f0d76b228fa166b83727c92fdac98ff3afe946855685b050d9d4c6aa -8a9899b0ddbcf4ba3f16bb006218022efca867a5b32e1de9c7efe1d7039c8e200a406bfd09ebb8921bf1997185e9266c -8fad2d8629c546c5de443b36927b068cfa333c8c4c1328e1221a1f6af7be5363ab8981fee54307532f239eda7656e6f2 -930146a1f6c3decf40198955059f70c98de7c5bb1b25bdc97fc72de3a84db1b121430cf7a7456a692d8bbb6b325b6001 -82987887016fdb90f79f045c16629c5b2b17b1b4702cd89d06b70086e5922cd10c5763cba6f3d30a2c33bc84be36c6f5 -a6fd7e4834f7f29da41170c13d29acbba86c74d5924cd361588cdda26a3ea7f11ec34c31869537ff7ee0b57a24555e9c -97b2474cbfb632148869a6b911c2ab91e4af9eff6c181566a1eb34a05d2ef3fa9da4fdf14e8fd8746a7c3123e20d572e -99ea177bb7d98dce25d300b09bf6ce08a7061360c4ed9a54e30c1aa5a467be6225737b62ae921e91547b5b9d39b800d9 -b9dae836e37d51c9611e6522aa6aa8bccf2644f23113584c74c963d79af0a7ae533af823215fdcbbd8df62f00ec1505a -b1a7165aa1ac480b4eb1f0b3d4284c69907d1b5056a343a2da84b3863c9a2ec4d757493f5daf9ef252a253bb3b2b6745 -a1322eec41b38b8bf3f4566bd12f9c230dd04d085e0526218489e986d59895d471bd8bb08351edf40021efab1d29b2d7 -96d559df46015e62d8876f4d8679f9a9867dff31eb151238cd75b3a10bbb2ab0f51c804a2f5adec1decbfa355042a6c6 -ab55e38cd273bffaa94400bf4913ce0ec1c1c848e8c53be1808d4ce5338ec92b4a4160b8faf0d1d8ee8b71ae751d0ae7 -b61c2987e2b402a52670abe305f8a9976efa9720ad0d7c5c1d0d6d9ec6f1569f51621b6edae84d9bb3fef32bae31a088 -b5234aa19fd9e714c7a9f3ea33d39a5c49f42e7a8edabd8f306083669df4898711d4b50b049dfb91815588ca60052673 -8e98a7b90baa4693c6a1e1c2e556d018c3408bbbb5dcf2c32d120f797fd8ed1373f1f112dbca114863801ec6efc1a5d0 -a7e1e77cbd6274f8c74b37a607cc20596bb7fc35ff1ab4358de15b07952aea397e409b30188c8516676cdd05d4919f3b -a5f2336ed9338772b71e490b1b3916d33df8b013e4d38dd57185b7314ec9aedaa34eda2733c38e06e656a8cec74080ab -b5de079ec867af3a3910fe47628c7d793c7d70b79e25a9a436e0a75405e2c58b740c1b86e1b073842d475e0b717d0bd9 -abcadb7a09173f1eda179ab7e3a5722f020402eaeafb9d604641645c21f1e009b758f2a6fd262f115d80e23f8baf7328 -8694ad59d4cc328b064884d147f66095605d9bf339d09e45652d68de765f2b09d45558d45daf9b4b36dcf881df8d4fb8 -a2cc7b2e812041f17b450b5fa7429cf62e2da06a7bb3c08a63d6f802ddf13e8b73d2056bcd6407476dd322fa35b9b065 -a97b0e7e22214f329fc57b6d7ba882ca563f863c06f1afcb60c0bbc81ef08ec866d39c81a80a7843889fc957d532cc0e -a8a809392dbf35911df8566dc20e2373e2fb3272bd9eaf9f474588a9132f06b5a1433ba9f36a738c6cd3fee403188fca -a3fb0038f83116eef1d6b023e2e17ba2795f7f90ed7c857d9f04337cb4e0c2e7d691bcea54aa72ac5e4383125b74b755 -a80ada835fede8d121162aabfc8c349f685775406693d599e3c288364097b02d96c10ddc20e72fd308fc882e5b70c064 -b6e6c4b24731a2895b7513ad97c0928efeeb0c645dac9fc8cbb0a6419221807073f6996f2b778e1dcdde63acc3a6b2cd -880a2e8fc2eb57f44b08cf4db5cf1751bf9f4aa688708039007d2a198f4e7f0f808aa566b36b15b971e804835102400c -8b3baeb4e1c1d7493bd885dde7873afdc235b58e45b515cf51ebcd02a9b81911c5ca182a9e340575585186c99e71d2bd -a6248e1bef3c6c6ddc155dfe95631a3f00308fa77b1c1779935e76401e750f151b7377f9376c08e8273680e924382af1 -800133df4ea65de3935d98b0249e335a918c44167a34a16c0a4adaa4654f458c376eaa76ef088672d39aec4c7d951833 -8317a6e0667fb524f35672e070f047db29450b06348604319765e4db09f966ad995098cf38acd30346c7fef5dd62528a -81fc2ef2ee0e6f21f406c51f02b9b7be8d99d30a054df918cf89c708d64c34d8b0dd060dff4383de858c0dbff25d71d3 -a28611f96138fe6974e3e1925b582cba76166259c32b39e95702fa0c4957ef2ca32d575b1c08cc8dbe96ddc0eb56a9f2 -86c6773f4e0261413d6d3944e0f7e498a6dae518120e3940d2f45054a912e706b3b615fd160e6143a7e54942406f9af5 -ae91e3db099d165b198d80b6d9af894203949d87cb980f4db97dd43ee55fbe1a45df156b72e3c3e9306975f9e5e62d77 -ad00ceaea52dcef616be9f9815548f8e9b800bc9c1a8832a4d8acca6c8779317d1951e5700e54db070a23db41266c934 -94426f78470aea2d82eded320b45bea09b7cbdf02a3d7c2af4ae4567a3493b352b36f43c3669237879910dcefcc82fe0 -8aad924eb1a30d2844654c9829d82c65fefe964d815572b6c9f902c6a826c247257a7d0d4967e2bae331d52fb3b7c0ed -ac9489ec928e4f43f8d194b8f3ab83382b66b045f18efdfcb05c1d4e67af7b3745ffbb7f52cab4b8895550d10132e2a8 -af8f390c7cc40a08c0143b467634c10e8046ce40466006a4b4297c76a6c16309b50f41a4a022fc838738c4c72edfb34e -923b0384e87a2ddfb7a2c47f628172e8dee76fe812c44a756c67cb20527d8e9029a561bd4ef446a013d4be7db7259f6b -856316b53f09a90af770bafb5c9ea7deb921687fdfcf512840e96fb83df08820c42263c9ccf51465da33f1b03db04d09 -92e8823b523f90ab75ac6e30869dcb257d232b55a3e167769ab5b54cbb83be94cf5d84eed4b1653db17f3f1350ab5e53 -8d0d05fac92079a3df86a72fa399e606fec7e56f81d3443cdf0cd373b3330235b76890197ae61f24d17de39dd1aadd06 -8a801fc71b9b6988a829044060679a7cc3d40630fba81f72bcd15c0e5728867f4bfe938066e68cbb54b042a39600fde2 -b40a6a786ca1a21159b72990b4d3ae8729722cdace4e8124f8cbcc3fa96005563535d28e9d92cda02e91d979d27f8f97 -914f30250d79829919c8ed184c2e471c0d9835f2348e628164dbfe39a51dcdc3f8bf99c945b1f413e65fc5424014e5c2 -8ab8b347b7846fbc7ffe69c89ff67dafd522bec708b7ffea312b3a7eac47fb9d6006cb9038962a07dd89d4688ee6a18b -8e755f8cde0750700252e41f6d16b825e7f02748a13744c004a52b19e52d58c42d1ac32cd5ed1d6ad14cee5174b4ddf4 -88d6192d72e1fefbbc9ab400e5b0018bd300839cf604cfc1034657f62fe8fcfc52acd86c207dad0fa6383361d338b2bc -971fa2ab593578b341076d98c49c71dc7d9eb4ca706efe252441499037cc86fea49af681d8a4d324d302526b2a3e5c18 -b2deac648501d7e284a85c19f514f8744c48d2b5516c993c2111128a9fa042aed34dc371a0cc3f00e918531dbf16c0fb -b63fab8600fa531d7f48f8d207298544d2e03d4da23cfb43d99b0612f1a20441526de63b7609f5969429e763147ee5e2 -a8f30d9b4ac3675d61199e8e624f88b9dc52658a2ba26a2bda5f9cd3780f0b1e32b56c825d9dbc3a059d6c61fd37e261 -8a6f8e963dccbf1db9c839c21a4e832c7a218b00fc31400346b5379fdb8394142bf8f8b981fca3f4d3c43d4e34dd3e31 -b4883e6a4213c799abb2a9b6998ebd4c89aeadfbabbe4c363b22beaff46939dfbe4dd20d113688a293a41daf5cd82c8d -aedb55058fb467ee9556a3b601af86962f99fc06f7eaf837b4deda030b1899f565da07ddc7108e9f5e7024e11c723ed0 -a8185aafdbd22a2df2ea0f0cf67fc88c4c3f8e64040da08cfa9e8075b792406c20d3155d6ea6fdcbe9f5502c44125545 -b2b27ff20d24cff756e8edbd6f8686d202d687016c561e56dcffebc78f404ff544c4d3ae8802b91bed0487792d6dfd05 -b6fba06a70d8b1000555b8c6d791b1db3fb7f57a0f8b1fa8dd00b2ee14242877e1e836cef89be3f9e0565e61a6b4c275 -92b3dd6e18600ab856c276bc787429d42b8c02abf5243f7919625aa1f4e8cc3eca61cbe106b81d0e4909393a5efc021a -a508e1a1d4375f5130c95a169fd1d4df51cecd84822dc28b18e464c2189d464e6dc6a5855e0cbb94500d041319749ef7 -84b3e9a6b5d1a7bc7df44ce760b5b686fba006945f6e1f3f67ea2c90dfa6ed70bc1f021828a0461fe158ece87deb1e30 -add83e686118fc5eb56d79199d33cf0c90fb2a5996c6f453fcd9b9eb3a273a466776adba1cccd6be62a4ea154480fe17 -a1fb58d9a323dcd7862ad4bc6359ab2bae35a608276a3053d40bb3abdaf3e8827027284d964e51ae7b61dbf299f2bea3 -ac901ece7cf087c782f75f1c61371f77ba061bb752ad680c9b1012768e5ebb6241b492bafd9e016e989cea1ff51aaf5c -961b9ef616b7faa3befd807772893c7c66ab6990a9405cf4345ec29cf13d75dbb6da41ec87af5b5c4bddc8787b88b480 -b386f7ba0b94ced118691d883549d70ecd28d1c0d1b718cb82a92a246e61de4ba80b6a76d6039c261e342f9ac136941c -b6415848092dd93da62b5a5307d356d968bd7c935d3626f40e9446573e5794f37a23ca072fe8af2a9355a4b04ad35e58 -843b3e3221bb08122a1e649e81759297d985c7f393c36cc3bc707a7aaf2f53b9cdd449e7a4384981c5976fb3955871d4 -94083ab99a73dc5cd463b5259a0f4e99847bf32ae03739a440f8f48e12f078602c76b3fe4e7ecd31d52a7aa31168c5ee -b6f994b5482aabe833e388b24b9445c01e47fd6e354c3684094237189001290aa77a327181e7e7e756682a04b8b3c56a -8366f418a3fb2dbc9ffb5b798adb968aab991fa689ec24a4c4bde6f046989b1815e1bce5e846f3554028e16799e17281 -b8e5680915eb37153daa9a3a977b47c88b4f30fd358901888a1056e07d2a7070d28a47acac7aa7856ede16bd0c93ff2a -871cc7a122cd7b9ae2199801e6a0974ba8cea64e5866a5130ee0ec926adda24f91b3ff2785932cb55537030bb5ad811e -9370ff1ba27d33080efb22836147f766c60f0a8ca250ac6b2a82bb464ffa543da056284b712dc3cac53dfd1680a4cf87 -8614d8029df5058f5a072716489f734131b228972ea9b2b952ab1150bc50b6637543aec1c35763f8dc578275f7c9df3d -b8efd01dd0016a27a0e2df65b571d405be4dc8e0df5dc0d8354fb187b96589e95847ba0c2856613924125d21193753ca -a86e524431247115ee497c07ca2a73387eb820d293e8bb74e1ef1ae7ffdb21a9dd8ef1a6e3f391e6f02ee0b51fae2a06 -9151e2dcc0b928573421ffbe43b1761b6ccefa4ecd58be7fbc8ea8e975e18d52c264f682104480d590e6f8c0b8b9f63d -85ac8cb79fb8916f7eb5431b7e81606b38afba15895909873f85d9577c87ed2c1d0fd489fe058362f20ac05626681346 -a076dd75ed807bb7afcae8bb9821ed46758c1a8d00e7f3d3c91a18e6b95dff3958ed70441a1f4691ac3268d95e243614 -89d8dbe170b9804de3fff5b6512d04643ea0041c3f9bedd7432b171ced1577b0c0a7bb911852c6bafe154ba36cd30320 -809a63ba788e618a281804ef97a75df39c7115900078a6bdb203bd79d3df87e863c631e934dcee62e28a16cb8735acfd -9727e6720f8b73b6ccad519d8ca1d4f90c2db33ab536f399e2c4ce269be15d99e22504ef153aa26c40d4cfbc450f25f6 -83e77918ba6e28ee01ba6b8dbdd84c53faf65446a90bcef46f262f341dace2e237b1ff8f8d566fdfefc6973deafde716 -b5a4d3fff76905bbb229d579b8433e76f2f070108230f20a30e4f974f12f29ed017aa66e9b298a4de0fd535a0e1a44dd -876d3a0bb439e7da26539b98abd0f7e0b7e8035eafed08df623a77fdac30ac85ab4d58984396319a88e072dd7a5149a9 -98923e83be5b2877ac18415f9391ea792933db718b29b6970001682cc8434ae9fc640427c0a27f6d62af5f78f3901bcc -805c675a34443a14c0098613d11b4c015264e038a8d1adf083844f2e3e3f2414689788423dd0ff77c02130331d511068 -8d8cd51d4146bfa48492e9d3f3e4b845d4ad1442ce6bbd95979f9778ffeb108c641c9ffc2ebbba532f922237e5849222 -839862454707a99eef931335e5c5ed80805ba06bab0337c5301fe9fb92fd59c9ff6620e66de7369352b079dc52bf2113 -b3cf3bd867f60b345a0b91314b34ce1c02e64dfbaabd70782614208d32fcb5d4448102bd54728fb05d1ed18a750e88e1 -8207a421d010e1c5854b8e41460c6a13035ee77f7add0df83c5c31bb00d7acdbb676478a7dfc738b9aef5c29d345ab63 -ad2b14f87281ad6e1d2b713e6e8303f1a45cefe097820d6a1bdf4652364e70d28ca92193e2bc3d0a1e69da5a51c90ff2 -98025be2d7e59ffd3f6c3c2b28b27ec42206968c0f96d09330598fe17a207baa6574aa22cc26555139766cc284224fe7 -8e80fe898b7fee849f7dc8e5eac668c76f1fe18d159c51eaf4ddd8d4d600c852dbf6c2abcb878c64f37db7fba3d56968 -871c0e2dd929ba4e157ed606741a6301aef759e10a3f919166faab23e599d3409b232240e3afe9c0e1622a11cd453c1a -919f7e465b399e2819ec17aacc199421d267ff2979ea8dc8962542ddbae51e2bbdf6cac92f8a35e05e4d95a4a8315cd4 -a6e6667e6127ee4f0224a9a94be3c22831a1ab3b16f57462562b11473c425e7112b33bbbb6af860c81bd6e84bdbd3b86 -87eaa9e3515f2d94acf113d77dc085609d06cb038f5e8e90ed29bd04bd4814e95ed0d6db5a1d65572dfaf73ab2e50ba9 -90b30c66ebc16f767f3f0bc1d8bb17ca1951a616292297ca8dd06d54cc53e5fb5fd6321ce158c04cb4c91a04c01f7fbb -b5fda3715566188630f96207c4253315a9cd166ef96651afa0ae1d6f0aa8856e7642e2f8ef3b1fb1eb2c14a7331f6592 -a54143f662a6946da901ddaa9e514a0e96bd6397020cf5d88084a1e1edc092b94facc150b1c029a508fb3995acee50b7 -8dfdb813296bd105d5813657c98337a24c8bea19bf0d119efca052c018ff5c88f31e05e110fa12f306ae4b0a8498f113 -8b7429599915ffec755060d9cfc2c445df9184ba6bf298bfff5b54c2ec8747a9b65bdc6c73746a94a54b0a62d93b6a28 -8a1d1108174d383465a57ab4b1a6811ab86dc007de4f342d37f4cd311650382e0352d3664ef09cf1626c0b74e2f21ace -98cb860aee0b7251da2d114b2253daf977badf82027a018c956fd59c6c93b716bfe69a132a4778ee4b7168fbfe390ad2 -94d5a0d33a0aa590fe76c71e80b21246dd9bd8c2f5ecc647e47a423c2dddd743010484cf2fa363ea73bb217247429066 -a082b7a109fad08e2c01dd7322625c18f47497b32269ae4e529b1681aeeb3c4a813cc6088ebb4427b486320fbc4b7872 -86c23e2d3b23244c7763c123ad67a41a2dad8e4556cac23696906d1acf5f4cd7f661281b8ab2027d268405b08eee6771 -801522a5c211e49eb96294a9113022d86c84bb8741e44fa7328122836a39ba7e11e27d0d6773550b234531400ba1e7eb -9683d154b18ed641867fe67b2dc70e8b8afba79f73fdeafdf9015d85aa0c74d270b290952683c3667c0202a83626687e -994febc16f8d216a20774955523262966e955cf964950b4b2831a3483f818c20ee6f51cd24f499dda0d3191910a9fd35 -aaa8f12184525e89ce980468fd24e1a9af846246297546655763ecabf0b5b5047394543f1791ba1c70e21637cd815877 -9193a37d5692ff1bacb0265bd7825c479624d2adf33a419b0a71c8a744ca1b0c9828127831302ffea4fcceb1a53ccd54 -b9f3213d5d588ad73b86365cbcf0fabcec5c30cddad418281ff2408dc140e3f6a25afcb6bb569605191665706c675e35 -96aa280b2f0ae5c3ac51edaea4435ecff8ecf8f2536a3400d8c4c9b12c64d16418838dd7ffc1b815656109ca63261050 -8486373d67804e9832bddca04a0084d1976d324d85c22a52ce2bcf7518f014ad00e4795e61c71e0dcad1f23316288dcc -b4f2e7f7e2ed7917e7c5036681e1ceff18b688c1abbd203c2bda0731ab56701a847cef4f753f68119110680913c2dd4c -87dc2336d88edd81b94ef78e7bcb6d3876257c326d28b3f4484465d6c65faa6c17aa7a2f85c6b94ddece39f6736751aa -b4b3502ebe175820f53da8e3fa28160579c4150d79d932923739aab545af537b3301d5b21f5138ab4100e737fb61a084 -88063af42d5845267d979df07be0735cbb42d9b57d3625eb5d0aa7e4ee90ca88fa52aed480a4d60eaf0ab8dbc4f444fe -85cb81247c09e21de6deec42e668b72f513c7b105f60ed478b08b85fdc8a886a97bb7e39eca0cab09b294e4b1490b0c1 -9920fcfcf836faafd211fa1ca78302aa6feffcda98aadb6302300c250fe8621b60d9c214ea92087c44996ae0999eae78 -a1f91af5b378d61ea277e5dac81cb71d71a4ac35322aaf42b3a8aab1641fd51d8da1783bae0e8ccb66d73db8e1003478 -87507b427d381ce3906e372a12f4e61514ad7a102334826266df14542adcbc8bb7c8450a1fe110069d9dc2e9bf0687c7 -b7581b0cb549d71201583e0987e9e9bc6cd36585c96664f836e1b7326e5375ce8d0a450343fe0b106dcc581b77de88f9 -b26504a6a7a64c44d7f97d0402bf752740934ea4c6e101ec131666deaf574d55fd7f96c8807473722b6629dbda2ca3b5 -b90accb5c6b78322ef88d017fee2ae1cf87194f4b3f6f4ba6510c0adf4c11b20870043cdaf45372844f5e801464bb682 -a904dfa6e1f813b4aa0b242f3eaaf893da7ea854efe514487a237a01fe244721482476b81ed75ef1a951fc54802b29a1 -a00373aa8d98f4dedf9cec4d227b5fab00f3af2a7bb4c8b0dcedecb5a04244321d5f25a81d57ed0ddcf293c701d290f5 -91bedcb316698e73f43e9dbe0229772c856f34901fa4c1e018e96eb898e4ae02b19d900e87d01501099163be56db57ae -b84dd6b9a61cfc0817da422380b0dcc5221deb600b4b6a6f6c5ad934110a3b66c59f7407ad68bf8642b2bcb5427e8050 -8507c172e499856675ba69fc1b0389a08e58f8e5658c9268172b926dabb4a67b7c836a44d865f736e8fcb14aa2809529 -86609a1d82d90a971786da9ad342035ae4865136e513559069b6dc8ba82ec0bd1ac695fe8afa5f61f85c2310194014ed -94914f127a645594ed372855550ec0817663224208c127a08bff3d5c4f463b7939cf13a45dee68586b678ae453c6d60d -80b55565972213814afd6ad9b1884a4d8143ae90c148ba730ca77b0937c2faabb23a6f985dd0bbbe05705fada4cb1a00 -930f5fe58dabae91c26c6fcbb61c3e336678dcc35d028e5c958d2ee7d50b80e1693c0693b82d719dfd9fbe2c03b52c10 -a45053c493da932896d95d5fb158869c1051e1bf99658b183c9cf4415fc8d4fa1b6a8752b8bb26e8b706a03a57fc05d2 -af7434b48d2ebe639c8082be09060422f662317bdc136d534b76ee3e3aba5ea8f234cd4936aa2b928f6eafdbe5165a6b -a57a073bbbb3020a92497f0ce854666997a182f2b437e7b06c9888db8acb2fd2128e3959f45c391f0548a3de49e37e76 -a0ea8131b2d8cfb799e806d8cb92cb02d32de37869cf2ac3c82f7c5d9a963d562755b16d25c4b60f4ca214e323790a9c -82f920aed42eb630281919b9c1fa4acc02b05ef34020cad3583a29375bdaee167a47ca3366ef065cd8e658301942dbfd -8415ef32a93820618abb91329224bc46d478ee8749ef42e372ae4ea29b6c05a65d5ef515ffc7d720b2f41ccbc040f176 -a0fbbb0113daceaa05478163fa835b070be5898dd9bbfa9abc582409a7b671c0e41a5070de4cb6dd2072888b11825acf -adfc99221d7f044b57ed40f4ef8a9e47e57265ef8eac654043cf5e777950af6fbdc2c2d5a5b916048fab1c19acd69dbb -b3d8e85fccf623fb3848e4886d580469bd41ec0533975298bfbedc7a1a9b4e554714991ec4238d8ff976a83cab6383b7 -8b09702f3789ae1f7799ce58a0ffc2327b3ebf2b56cd870f2be66c0d6781cc1f34c2d721d0de63e0fe9db85bee842fbe -a935864851b73676cb49f509a198caab467e5dfe4358e7088d2a76e9b8c13e5d20b01eb7c0cb9e51ee98c90cfc393c71 -b5035d76a5a8251bcb18f33968b077d43403c69492b809eaa3e202eef174a5649aee30f701ef0be050ba5026957093ab -b1cedb563cfb09713009b2263975a56abb9932b8cdebf10f7836c5c34785149e9875ff590fe1414ad2d21da977b7ba26 -98a718c23d44b24ac295b328d91ab7a40b23ffbccaa90bc5888efbd32b6a95c530bf5e999ccbd4f1c85263104f336ce9 -8d9d2ee952d5b135eac2f06f0478faaac175f23cb3789144f3a490f2ed34c885ae4d8ad7ed48db85cc6c2bd70b38c6c2 -8155763582ff6c68d7071ba842b6543361cd5f65b7c70d5bb838da2dab2c02f3363e2324307e7d2149b12700d96bde38 -b18b277334ef7f24706b7d48fb764a487bc4e21fcbfb01627b7524e9a5d3253be99d84c417084fea769b550b3ecb4574 -b80db9d83cb1ae861a3f61197a1f14b6c5004a2b3d031fb207adda94d725f3e265535ed7b69b9c801f2e95e1d64c1901 -82cb673ac9c0c124fc546c59505fe4fdbc05a1fece0fa579f6a6df96f74bfa877ad82b6fa768cb678ff04ae4cec58d1e -b2e190b785a4a882939489b86d0a06cb637b7be8b14204645bdd9d6c37626e8623e35e1e4eab5c8fdec0f8349ede8918 -a82237c64f15d306365be19085e1c725cd148702fb66658c7974b02051b685715fb9e35fd4a596ec24d532df4711f82d -ad6f7e3992518ba04b510b705fa6b28e3733e0000a5480e8a3c30fe71394de2bfa43333c69e750bdc3e7092b9e0f7ffe -8c0ee358f37c28f3b80cb9ad5487c342fab734886e31e30c667e616f3aba737a3a07bac4da552d8405ad8b00c03e09f0 -b7851e0b88486b0a858a218f4307e0c0c8c314fc69e2b90cce8ba86d3fdb796b572e50eb4e82f83f73c7f048484b45ac -a7c35abc2e15723a9f395d16d2484b798d098be5414ddef083c8283b0c29823226fbc4727d9cccf96e33b27fc40e032a -8ec5ff2ba7c3ca8a2d18df81d46e93a3bc94ceca88134ea75cc8ec2ec4b1ba3d0de49dcd4d385083c648a63483377fdd -80ca7ee722c3253e7b534b42a8947e38741c542dee1d671b603a9a743f5ba2fa95f193ace46c01000ed20ea05ad0639b -ac14edc2d803b28a169154364dac5360cf0926d911a615077a94858fb4cbbe31bae2f30a6a68b248cd8bed015e0f3b29 -a4bdb63e91fa72995316d03cd117347cbefd14eb1b19a0adea1c9d39f49d82ca1ceeb2a4184187e1dade109d10b83090 -ac8f528e9e8fafde00e66a75d4bb68c99029456ae9b3b7cc76ea4816e89aca2b8b7d094db214bad1e87dd4e84d1c1a5e -8a8d090a01aff14383419735840fc5286e71a5feefb98c563b2d7ee593b518c3aef6654f10da8a77f40feb52e1d31fac -ac4259562982b355fe5e57e1cef574a6a40a7144598c13a6bf07cdd8000bfda95b0b0b44f215e9dbc71be114a1857441 -b53741dc30b11fdc6c9778555c1f714fde60890c191a0effe419fe2b6100228d07cd0738d0dd73057cfc7e340c75f0c4 -80ff52fdfae53dd2410ea556ea6504696439919687d2dcce1e952d9d17b6e3699816ee623b0153bb0e0588e36b6f56b1 -a92b34d785a71d10e6796ad07df788c6878717cef4f1f0623898370725006d46fa00a0a22a3934fc5cf323be85fc7767 -ac1cc08cd1a8fd6c946bbe14662b18e89725933a79965c663b73ae3cf5f5ab87e794559ed579564884e430e108385e18 -88b8b2264d84106d38c321c3a4927b9b41cac172ae27f6292ea44cd9ce11d185d0061a59148e50474d4dad3c9e940476 -b7ac9f257b4f676d69899a181b45f40358dcaa70fa2dad38870d52838aad9001f3a3145f6550fa2826018952431e4cd4 -ade67b3d1602ab0af6a256f25a65b621dded7a0adca65c526ab34c5ca3088a549b7ccf76c586993cef0d2d38af541617 -8fcd8bdc44ab42a70c174682a1e8b929004834d4962a902de460eaf8649883c868cde1cd660d14d7d3ce589fe3aa83ab -b914f6ec60f1767a12fa34a4b400ce102564dac4c1c42f1497c7bb824bfb9000c9e23ed7cadaa16ad79d5ac906070710 -abb1683b313612b583e87228384eddc3e2e7539e0aa26e825f5c27da222941b6a37ec47127cb0f11b6b8e0d02a6f66e9 -b01efb31962345a2fc71b7c370e7d3117bb1d1e1a9b6984ce11bd83c898dc127fec2e821669deca7c74d406e4678a736 -92439394c6c811d908b05c626f1afeda3a0f8c925747bedf66a4a5895ee76e7445a1982e99d8658117128df5866eb64e -956bfdcb00837be56d44f159bab9bcc2292295ec1ca7424615e3b163b5d14f7143e214609c0b65ab74a0dbddbed4d782 -880b9a8dc9bf6499f1f71828e6c906e2ae59660c9aaa824a6f36116746406351b4e364b6fa26c45e9d90018555bc7dd4 -83f4a0dcf523d414e023075ce0dde10161d65c0abdba522c811f0e446980cbc21eb0bb42737136bce30fcaae3c673b6a -abfc5593e02dff15161c4da67a806af3170bb2bbc65e3a0457b4bd994ecf5e001d02bdd417655c2b4433dec270a6273c -99c6d8bab7d937a4cb5c272c4bc3856a3cb8295cd77ec9e2fcc6a50e0545999cac4c413c3ca8e5408afdb60388c82ae9 -b08f5d230713639ec98a7afcb2a25b9b2d1c48820447d28b6a3ef448aedc4b9a90b6c5ffc6613a70ff1766b51992074f -99d4b54e35dd3f844088155f114ef93507372ed32a6898b9954d5a6d0743e55d8e7de20d67671454d26561ed5e4fb05c -b7cad70deba1622c79f1ecfdb2612e380e9048fb6146760ba61cb62e98cef129d3944c5f442b15fc11c102fcc6e2adb4 -95feea870c86525ed214e3e0ecca9f66c5e0babf6da8473e5cc5e2f305c26939f6afda0207bf5855b6a6c928815577ea -ad6e77ec226053ab331f3f871d7fb770ae78227a85096d263bb42915299147a7a7b57a4f8f929765cfb323267b94865d -82339f53ab7344f8dad554fd0270c2aedb34f7b0c630f0a56ca9217c04f0e4a38781eec769354a44fa90f556b388ad01 -837d4672d73588f19b872d81b7993e5e0628139f5685d0520b1b766d40e71b9d83a8d2bd65a03987eef89b3d5c254683 -b3c27e19f579133f1ded8c066dbc3e4edaf449a1edcb1aaf215939d63a7f2b250b9b7afb62d4cd7cf37c28da81898a67 -91f669f9db8fbc6d7a5ee92cb67c2fc1ccef6dde622efa455dd7535b11f506f4e309a8878b859d6605a3917f6d7d67e8 -8332dc636222829a83501a8312904096c2984cc0c5dc077e067d8962bd87666226e3324a9e5057c1cbc3ba700a3b22f3 -97e81e20bf33baa4412d6b81c5fbd406dccbe70973bd73e956d8ce85c99d2199daee5fa6e99fc6d40071b352b5044865 -b716066fb9e470cca4546a401048c0e6c6408c8c9f4cd80aca6778d3f4121378e11cccf8a005845fcc8dea2e1b9f16df -a7b340eb603da43f2aa542dfad1ef3d3357f583c46040f2dab234c8246d7c55d6885f9f7a14f319e22355ad498c22a04 -8281ea97a28ade9a0cdc73a077c72a92810b70912006611a00df8e7d2ee1036af73c0f062b367f3d4d75be4b9bf78aa4 -a481ffa0813a4f2110c6ac535fb446282dce73c182eb99baf786ad42b804ef12df078b2f534e3cd8210973880bba6a63 -b71a581ae08eda0437f9e9274c1f9431d6b357e4866e40d4c2470252f0888978497af823dbf464785479e5f35eb89aa8 -a07c9010308bcfb0c97a1059d5213980000841ca0565697d45aa46e82fb36494e4940aa435ede417856d24f73d374757 -8fc353fa8733947ba067ca2bf5e14a6c334e4ff30efdfa67829dc86f49424f4548e879b153e79dc75f1ec00afd6693c6 -a663faca50e1fe5d00f62abb0b7828d6b761fde9f5a54f27c0b726d8d53281f83ac165b3d3db87f970913350a7dd07f2 -970535269744905640d6ab238930dff375ea7efb2f391db324724166f0c436e7a3eab7ef6eb2e5d6724c58d588a4c592 -800f33f5936498e16fd0f58210a5a5c104074039db7d9d5d92dc62cc00d796ea0a3a22e5d368fe269cedcf30bf6149fd -b4b921cc901a7775df7ae73e97cdd108d98c54534015a1469f0ca6b07989827e0d3f9bea2ec015fabe9d309054aef802 -93295c8a7e5c0bd9decd99ee2d704d814cb6bd0061404fe00984a8afc337e78af11965a8560288529c2a722e8b54b488 -af43d382ff7951bea94f4540a3a2dbb53ed527e966d0dcd117d5212f36112976e1fa00a47bb9870d3841cb01621c5d7e -b4d106b21e4676556bedc6e7f5a7eb5c2ad0d5fe8004a1d968bc7806ba871e241d38892b1fa73e9648b23158802ab57b -a96cbe38f86165288a365efa796b0e2076ae9fa94bb6377cb80c7d5db9d376e9c18164a8a3667dddb3f5b847f52fd319 -a0bde83e1f3e925561c481ceb58c7575027f9641e69f14242b886e7fbc532a2bc54aeeb94ca39bd7da3ac984bfe8cced -8211c4a70d08fe052246d3ccda60c9e9677910a93d9262d572606d99e273c1ade353eeeadf5b1e3c1ac3c4b9019d5f61 -954ba6744e3f991580b6633e5d184550e44400f20f00149d899d97bc4b51b01d09bb4f82ad975cd55189320523fd60f6 -b7e3f17ae79c2faaf5f3cbe0dc528c6aab0035eb3f38954820556bdf7c3546585fb9814717302c5f45fde7170748ff63 -880446589f33ffe7ff5e105fa1c380d401d6c46e80526948fbf4edcb779753a594f3891461f52eeb3f5f2f6051c361b2 -a26c06cf79c412d49f39e0e27e37c82c4cf0c8648638ee66a97d22d822e064a9a7cbb0b1ede46806ea0430639769cb88 -a968341c5e4a3e6d2a2116222e3c58c2e558f5bb0a2877a27c69fdbd38dc3892f9ed7d7c114f557e52a351c73614fedb -ae9b8bf4774ce3b84185be77723ec62b9a415e21cd60e86513c1500916c96d62519ee8cc061d81ac9db9709d6e191649 -83a30c1ebc046c9a1ba911ecf6f147644f58f54e32357dc395388e6bab66d71fb9b691754b11bf414d43816af8058828 -ab5b804fcfb68b6439f311d0420005b083a84da15a8415cc4013898806e67c47698a9d594263fd9be42bf48efdfbe2fd -a41c18185f8111ddd551ecc8f6dcb87036cebb6eabbce7faba40c6c5c8af2ab59ef027c6fb2dc523eb0159335a1ab189 -b24cd94b7c6e161e651107769d863fe5a3d7a847b9c60c7c803846bd782cec0bd54e6278a318ed23b90cd7ad25933fa2 -a5ba23ead78d1678414d4e986b448e7a24b23a5c0f529ba604a51e4ee0f87baee450fd121b43a954be50bff6c0d7908a -b89c17de4809e722527832b90b810d9691b437f19db9cb88ca5cdb67bbc6946ec1d454dc0990b66093ebeb6eeb6896a6 -914f436fe0ac7540129c3deb04d51bc61192ab5d0d16eda77ef70ecf8cab5f55a13492f54e8052f2f214186a113d8949 -8e0b3d1dd756a9008894028d0443083c21e99de69b8d8f4e7eb3ca7fc52ad540355d4a1081774a6d51a093110f4bc838 -a9c1730eb5c0a42deda9d9b39390661717479e29007f5f8499d0645b8b85bc0ff12cea2ac4328f6588a12126f56284ee -a2318a42c99f7613ac78cb110656c6e470cac6903a5bfdc1bb182af21e0f0f409bd39324a13e2790f0facba04459d3c0 -a11ba34521434cb718f1b2015bbf451ba1a7c60e59b1620ea843835c7e75bb42b6ad29263cd3705f7f6f1e40a0ebdfe7 -90705112b625973e1cb35e30f9e15e3c752b2e972231b4caf53518f44b4a40b8a6bd15c4af2adbce5dc194169b860cba -828035b0e70af8db1294379b4b70e56624e1138ef49f7be81d938e8b25aa5dcc03655e045a95a79e0143c23a77407004 -a7abb1836282917d1eb9886c79b6a36d720612e3b823d9420a4a705e8add6c6bfff2f682e6f992a6af10ae2f71ca8828 -81e97c7f980dbbe93df9efdd9c0a8172ba0f00378e9375c926b9e24758e8b827037ba67e06e994fa9d05942320353d71 -afa640b2a7fb997cffc5db74a91dece901be4a36415786190dfd17a77ac837a2fb2d73e973b8e60582e71824c57104cc -ae860a6850068f2b0e1e5a03afbd08b667f44c4f06e431f1f83269e754f37e18a764b00e100dcdbd1c1d18af9d6304a5 -9443fd7e1263d5ab9baa8b1a3c893765da1dbed0bdf62ac9c886425ea9f05876df1920889b707a2cf248e7a029883588 -acb38feff88de8db3477ea9ae3b33e0c5715cfc91cc71926dce26f4f290dc4f437461a186cf1bdcfcd6d121e087bba33 -942882666a9f49ac24d9099facbf1e65484ee76cfdd2eacef25e0f30260654a7b5c0cb7dc37aa1601980877f945c51dc -ab2c9035b2ee9c5e57d8de70b24329cfbd247324309eb30ac78c404ced268dbe2aaea8d417300c90d87924a48702b793 -80aedcea9c5a9911731ebb444500eb95b519e2d4650c1d465afc61f4997879d60750ae3fe049e54654a06eaa2db7d8c2 -a63e1ba5fac918c8bc0f4364b5fc8d26214deee825aa1bff111e03c0ed43baad47e8bae154ad580b851a0f66be85c88e -aea7f5f8c387c21cf671246803cd5baac61cd6359848ad4fd685b1350ed6298a129ed74dace279fe7846001bd6577dfb -906ad36bbec72813b368bd2b79c1c9624966dcbe94ca9dbacc297d0d8af86edbd80cd702ed04f0adebb913a6a7bc1a62 -a46201c20560ef2ded1ed3047fc196bfaef445c4a716890d9235f3a06d6993a8ab29e816eba54c6a2e2590dc8dd61216 -b37eb2c0d765b044ed2fa2923160a19e11509e764025e43a62b4ccbe38e534ab59e68c2cc92cc5aff9d97154b8210c50 -91f93b1404a4bfd3fc8ea019d76230637ceee315da0faf366c712c3ba19088cd3efa2dd30172dcdac11e636f8473a26d -b6b905abc4a795bf95d055ea09c3f9d0a8a9ba0014e288492a3751d2aef60cd3b7846e1ca8366635a94988b2e197191f -847529bf842d7623150a3bb91fc4ccbdc66010bf008179a32359f98bd007330bbfabfdc487f4b98691ad65680af67a8e -b3d37a8098d02b5ee69ed060527f3d924c727016fd92b21d6a52fb1c1ca18c7eaf0caf8144e9e6bb5b6a039ca85cb1e8 -98cef893dbcec865cceae01138613de146d563f13853ae34bed5f142da716673c105ecbf4f2aa7d187bdee20702d8582 -97f60078d18928c4d7dee1ab244b2b7540928e20cf7ccbbf6684148611afdd9cce60dbf412c1fc544ab8c356fda8fe11 -872a6758004e6c87c3788c5c11bcc74db78f076efaeb75127f0baec28febd02528c65b227b7619fb8c29cc92d7c8e799 -8d72cf1191629440d7af8daf3b76b6b1bcdaa8d6ddcde52603dc8b092c2ac78d6e24bec32e1223eeda15dd17ba2c26d5 -89dcc8c10be08277a1e394de336bb1b135bcc5131dee5eece80973ef364a305235936a3b6dc40f2eeec2aaf227a86376 -972c4ee3b4b3b028ab683415bdfecb2454d326a19d274f499e48bb2cfd55165b928bdfa7f97c4fb6d27082cb88b73dd5 -ab5438a8af3acf2eb75bea0ae71d8aeae363d6644c54e3b020082c80809ef86faf5811808adc8240c7693515ed8bf199 -b594133dc9f71f72e448796316ff3ce2f8a03c21ef9c54e551d23723d5f197f7fb0bf1c33e9cb3f51188db7dca51bf49 -aee981b45d570a666d0d0b2c7aeaca3cc22d4873812b4424d1f91144142393fd64c49401dfb970c7d5ae91233676cacd -8f978d21de1e264178f88cad7213463a5efd139c30dfce81a7eecb46942870a3c1971f6e6e6a50e0a8b20c379ac084e6 -9153701c8b82ab43fa4635cf677789c9c9911efcf23250bd393301c0be51f14fd0acc4e467ec9682acc89085b94641d7 -8681989a1be217d77cc8e012c95128557de70b362442e7f1e6162bd52ec6e4ebb0ab28f9ad3f67c1d35ff00216ceeb74 -8e85421256fc71a82d35de9645a6da9cbe4dabb9670758c4eafbcf42b26fb99866bb2b4c374601749738ad34e51dba6a -976774296281bbe1e8dabaee7453613d0a615cc6abaeffd8e15ca4484b5a743e298522b2dfbdcaa697e1eea2b2bff736 -a585501faf955b6acfb328d801cfec5b59be8ff2fe46ef0bd73b86ba4c19c1dbfcc1df844d61a5acc64bb5e8a68f6cc5 -a776217e5073714b36bd2ff0621246a48799eb5ae3ca438d1efff6f9f9beb13779bc18ae5ddb77c838732e8925018118 -992d726bd4889f4e7565bcdc31c7b4a58ba44da5f361e3b46e0a67a6e4f00c25e3503c94e7b2bece737d7efd47ff9beb -b277f124d5dd8dd669ef1f6840276c0bb0b60379ca3a0aaf00ca337c40f478d511b1a73e73df6c3b600e6bfaf37a8fa9 -b037e78617c235e6528e535bf13bf5e82c70588d1d0bd08de754d089bd47a4fdcfee79b5666b95698cd98c0e32164afb -aefef9e398e0edb60615713d7c1334005b21844d3f1401903e09af2db20d7b342b8d80796fccab583c8607c533c9b735 -aad20eec7cf4f0b518007ec1df7dbf4935f6f9ecb36a11d148dbf9e5281aab43feebcc8ce9001374be40776c5ffde825 -a4ebd6018e004ac8b5d022cfbb7c5b3833456faff4f198a3d9dbbd077c8752087bda1ea060466fde4a5f31cb8a50a7b0 -a56ebb8ac9901915400234c1c6c8502905765a7224de56b084f9b0a3468a065e78b4daea27d9887b4f44a72fa61a15fa -b0269890863c63203dd4da3a08a1bf06621cca212acb49799bfc48be7e41c951d807f85dd4171ed57c372914dbd2ffee -ae11fc0f5fd5ba488104bfc07fed50799f51ceab4768afdab300325e9a913b1f257fea067d357e54950c8d08af5ecf59 -aefce65396c61e835ffa38857df426f64508de6e93f966cc46b54dcbc5e2bfd72df927b00489fc4460414569ce99e610 -a5a1fed75677dc956c000b9135c4b6138e0cff53770399ffbc3b12ff0c1677ace264aef2058aea535ee1a7195afb034d -8071def0890d01f0d10dab3afb13125f0194e79608b9ff129572b5daffb49cde5bf6d9f24da3f84483612aaac3cb8eb1 -b5e5bb8c0be22349ea51e249cf2159189fb9aee615dd62c5f67cc9f43745676e703abfa6561df4f5f1d79b86c459b11c -978dfc57cf0d3538ef336a25ca7a2cf373f84b71bc06d1c74907464e3e816d834087ee126bbbbd5090a09ed063f87a46 -a2ff4b59b3e7fef169835e67d47218eff5368aed3e6e2f1cacd29a5efe6c1c2e7e1839d87759bad8ad1871b39c481bf3 -96de49b44bcd2f5ac3d07d6f5270af081776d8631fefbaf9fec6771e13d40a4e5158767067297029bd38e8c6847971b6 -8f2f820e8e3645f2ab9a27b3c23b5f656b681264d08e298ec546c5aaf51119893e0dc8e04d6f64fef48d3cece89692f0 -8de2eeac7dd4b53119d02f0ec99f127cbd8f6a57120d94a9a554c04467fa74ecbdfebbb111d9f15cdc1be2be8c2396db -b6616f68b00ea0fb78a25ecd51d3018b9ef13664a7da42663d1bfd6fe71fab615624af863f3b41e625b36a607bb42dc4 -abab5be2ab033afd6d110a340c658fb512bb53368886d8a5ea29e3c916a6b1bc46decb2cd0f508b5667f9dd88033ef7d -8872d0cb09df44c2a75895d46588316a4c9c743080f7a03a384bf4d4be80d341f8dcf0e208383bf3587a3509f3324fe5 -a3f57fda2e8c06fa7ce9de223f5ff56d53ce9fbc48486d88d2845e7011dc038b6f2f270dcfd46ef5222ae9a1557070f8 -a82c4e46f0d1962cb48d6c3d8ed3976c4fd4c174d119470479d9770619a45e6e16e30693b2804a82b516ccdd400508c5 -b53188c6b2907abcfe47fab98f23ac602525e05a5ac6b4421c437025819c80529e9d2d63f8a3c10cb9dced196e572506 -951934cad4c2772aa0ffdfc4f12a55f490824e104f669e4dffc70d9c14239570c87eb998dbb2a6d423bdfe1ab50f4377 -a276bddb27d86e1e70ebb96103a239ae4848ad20c4c5b7de85f480c3f293c934ebe35792361d9767de4333ac6de11643 -b9c8eccc03d7270779a87dd7c52a42c7bd632b9bdf94274b1dc864bc7a59e13eb30870ab740066040aff0beeefe14d2a -8e0908e4d15aaa582dc028e015c4b2bd97c82b8086737cdd1f2820641e65d88166d1fc763bc483f8fb4643339182473a -810c6c46945ad5b4f699c51130bf204e47c62066fbe54fd099c3567ca79aa8aa8b04dc5321c09e03df4bb7c9b93857ad -916d4b23adf202ccfaea7dd124d28573c73b39ebd74bf4dfe32a366f9dd48f4160b8cb0e687e7dca887c4b4f19570cb8 -b1b8fff52dbbd5b9bc6915ba20f3185fa8e23fe52c026a41cdedea5301dfcf6c79c4fe1058f3abf280a00c7b2cbb20a0 -95f9623510e12ddc6f4ae59d06448f496cc911c99a4d5f5c6ff7e434b807fcd4b35ec1ec976a40208ee1a505a892e38d -ac7217596d42d40380fddef22e83db9e6d6b2d0d2e912f868d7fc07bacfb83e8e6f01af544e8f450d31db014fb094c9a -b10855b8ff1a81ac32d81773ce8a6391169902290af0637038b58ab59fc84e3403d515ba7c99e26b7382c2e2d0edcedc -89eebe9789a333f5db0aa9e8604798b15a934ff45e19699c2e7fdb46b6863ce02defcef9f6dbd0cb799ffe2b669428c8 -b9cc540b405c5ec78a2d8fc17ee4a08690e347cc1d860885205bc19cba09e62f25b94ffc2cab1f638c87caf217f7b6e3 -b16d06b120906f085cb183a96a2b635334afda4272ac650259f23059407fdcc8b83e91f2521223f79769ba45428c04bb -83e0a2d9d9f6654d916a822ab1725d58a10efd64e889a17f44860db4d2c77ec1bdde7d0ec8deabc12f8ffa5af879d4e5 -98cef31d7ee167d9c4248e29402ea8d5546288d1b7ca54a5370e80a9ce371bc4aa3f5c7a24c2e4805d8c99af059b4156 -8fd55a0dc38b65c2b0b45c9127c14b9396db4898f14e1559e428a2951cb5076bff9e3f202a83236f15c1d2530539e5ad -b3252594c3060118acb12eb91d002a74c068c0b8f9bd735a9ecb082f787c7e046dd6e40ddf4b3ba56bf89f223bb5d76b -a88446262600f605fc4f067dca855ebc56990a9ea050c708961e486fe685707d9e9ca734068b92778a144c0f3c23b4bf -97beed96ba821515996045a40f17ad46f8f4d927cd9a2c7ce134a60d19ec4a5819a19aab1bb0df886d9cafcff872bcea -98ce98dc7908161ceefa0ac132b63c860ec2e53f7ba28e66c6c5e45c5945e459797c65668e58c0a5b8a26811f17c3f41 -b0419cef96d4d44fff0338132d53d2c03e7e9b4618dc2c6b9f4475368e21700fc08b844a2f140158fff81f56aef83b7e -ae1eba4a4a715f6d077e90e9efb59852b7025adced47fd9f705c2745e6734f2fd2f2f86f07ce24695a06e24e63f00b03 -86db2fd15dd3cef1e504fb057136f0405758f6fcadc391e6f64b3080f92bfbd4537a0d8f59cd1a0e913b2b188093feb6 -b418cff26800f8793b083a879c8b1823285f7a3cac6fa34cf48ac5355f04f6ba74255eaf436739c4d26d0d80d2607129 -8eda3c25b5699569c03b85bc585acf25bc3f9539e9dc3e8707b34520ae5ac53920f45528f0870d93f84647cae36b6aeb -a2622af11642fb6cd60cddcd4c242cf13045f4ce20539d11727e8942b4f9a7fd1ea2192e83596a35c096fec3658c0c2a -80735f92d09dc0af19f593ea118bf52146143c1d2a7343f6e2ab95e00debfbd329d4e887f7421e4a361d815dc1a27973 -a7eff30a31db635e239c8632f7f84263c9a9d82511422f49077823aeb124e6ee3c995ceb846902fcd2cff0f5f219db51 -99129aedaac32b3ec18d689a2589e35fc9715fb3f1a72d28a09ad95e39a68ea939ec5721c501a9e35c60cecb3f4379df -b9995d65636ce1e70967a8ffdf45e50eb264eb64f15ee887781455c5472459cbb309ab58b1645bd6e8f2bd29e69d81b0 -b8049f4c3ddc22405880bf55b5d5d94a6dbb071485f25a49a6457db0446663f8d4fabcf14106b9cabb1b3222d8786773 -b581027c7d9bf7b97f6eb085934b9caa43a46368cc6740139e33e4cb2c94683411710a52d5933a27c9d12a43e75163ae -b5dfce672e670158c259f36fa549aaacb0699da2f13702c81f5a93afb00361f9ca22d02dcebeaceaee6813a3c9bf7aa5 -b8184f3eb809be1986530dffd7464d84750df02196274955769a0afa02b65e87686d915ecdc7e75a0a76be8b7ad8d064 -b7ab837f300f4aa2ebd2d770f7a36dedaaa68e1d601eb36a28fada4dc73dbd55e7f31c88ab2835aeb57ff113a14c5f32 -a72013c811ca674c3e909064777df1484190fffb0643b6b1435892f5dd0f1d09579189fe00c862bcd18d03309b958b72 -87fb528e03f1b6a000141f4a6ee24a9738d9d2efa795cc262203fec10d76adcd0f89968a46fdebac99af8d048300b8ee -b2a1ca5d5d16c7addb73341ebed1f8e832250c2f8e03915a417064750d7deec3289e646c06a09c6a3ae40ea2817636a4 -a90cba4d0928da2a5d8c6935790e1a1f026073632a4c1460fe686d06c3f2933661c2b3c49bb0bbeef386f2bcc4d08485 -a5b684d544500be25136b0b5b95d9f363103a6d08cf49f4934d6c96d43720a79cdffe66698de0ffe5b02bb3c2e30286f -b246952dcdc38a500e64ccf4f312bc7c690d33a3a951fde5f839f6eec77ac78147f1fcf26ff7b990e8868f5cefe1c4eb -981ed33458e8ead67d4adeb884153bb0fee0ad98ebd9010ee706ea1da7975c290f82c492cf16fb42d1b739632e66e50e -88bdec223786c894fbd8f964ab2c92c5ad7fa7ed2b97a6bf31423a6ad5bbb5a946ae3cebccce8cc97af9e788d03f547b -ae852b074e5716e3190593e11fb17f1135d7a5d888986d2be53973fa14c1d4a9887381e648a10a4725291ff062c9d88b -b87050f914c4f09e2dfef845ace5a06504b6fdb815f685921710c7e82a9fac11f864e3e6023ed5807256d6269271d051 -8cbd11617ab819680cfa68e70e205f3ffecf6e469d88dbdb1d9b0c9c7c38746dd6e64bd526306a8ab59cb7e66841a757 -a1c51cbc1a91618b1ede5cdd77fce26b04971081e5cbf83be20c22b9b30cc9197b9bfd5998fd9ade9b665c8218afe94c -b5cdb2091d114847dc14a4c922bfe944021549df2d75cfc08ccacc2d740726e90e20a0bc2bb73303e9f0bbb5192fb982 -8e60327955c5de97f56838cdebd24c2ed4021d9e3d74ab9eefd4543a286c1be82a1e8455f8cfc0a17f03358c4648683b -87f9c1c0987493c631279112fbc79c5f5d7dbf46544119492785f444d063fcb0da4f2d1129735ab77663a9000d9e18ee -a970df3d50c4ef3d76d53dd2b887e9274fdedced7a83560eb1950fed2075879d9fe1d5af811f04ec92d557a0be0380f7 -95a69bf4092567f5b55a401329d5a08220ae65825f05d56043974fb7b7090372e941a85e2d197c46c9165031b3bd36fd -8e62c98171e54ff549ccac5d6d381291d0861439dd24e584d356a862d22942e0ff17cdc0d1faab07e496374a547ee812 -ab62d0eed8422a3172269de0e325eae9294914fa67f1ed8e5d0609afa2991a26b1e1b9a04ccda8436d04ec085957b110 -a3292bc88e2a9dec7b55ae4c27a3a8ea46a7b2dfe3a817675eb3712f95264c08668703771b65afcdf6d305e396d5f005 -afbaf9cc19adf63a0716cb868a970a372d7a1e24a4c78718a114ced412a12fda6fdf42f701ca1492a8f8c1ef0466f7a3 -b41a5f064f9d900d1534a68c74796927e4018e23f949d86eb76dd5b26e5b686115d63d858a49b545924b3941bcec2341 -b4e1ef520119f9a238fc4988ab2f1266606f53079744b92c1039541aee78b67ac570d7839fc9b2331244d734ad4637ed -b0ce754a33a506174d5feaff4e9a79295c743b2a122c8a1788c1427482585b398a750b7bd93cc53c38bd3e557caed172 -9842cd13ee9490d9ca7ddc83d1f7d79495afb7301d1f51f4b007dd2b2eaf15abbff18666126adc25df5ae26b98a80f41 -a976af142268d20a248c4b71304a878efec29b5022199cfc88bf82c081f55d06a89f178606d50bd3f8576f0c5c01a6ad -985ac6f315ab1d2db1b4f2b107eb1652810e63e36b8c14e8852f072d2c8b14922f20d1374a57d75cec62db0d050a0c7c -8c1be9e8317fdf847a8131ac14cedda922bbfbe15cf95537493c4e7eccc7f2f1a56ddd1a8832e6300734d6019d8b128b -b55d129c88d252556fe688f84982becce253736ef3b1fb88328e41300ed0713465c8bd15918386844c725fe7a94e8364 -a96384d2d81cf6a79614c7fd6bb68fec6e74064435a1a79dd8b1533e9c7e578da5ecf03e979969d983da893f42adcd84 -8c2b3c06b7249ef5ecedeb4f2c65c0925cda8877bb4b672afb7a15bb5a7b5818748d6b022c6ab8fe9c5a1499e2037c69 -91c8b2b8b204897741124a37f85ddc45c3ef94ceb5dff681b13771e712f2ba5ac95cb1bd2d3e94a84625d384b51b099b -8bf852945910e9a773120c5ad975f080c07c8fa37c2158e1138162a82983211da70f27e22876741d58c20a6c9dd770da -b9e907d9176a0fcba87a2797651765c814df756bbd1d0a86a9b7b06d9d886d1908d4e74ab27d618129dcde81e7d969d1 -ac4d3b156db2570c349e21f07fd17df935872f9687842035b533c6e4773ad5752f4ba8f9ea4501953f6b8c4232a4562d -ad91c4a7ea0a314d7d1ed7a69a74adf6ad810586c1bf907ae9878ee5f6528437c048c6ae785cc255707ea3e58a4b452b -8013b76604bda0c429e37006b01750999414100d0ff59ff5ab7b233399adaacb34906ee65054abb94db80fc92ac6d2e8 -b26a2a660af34a4b9b8910463d0dd439a3dc563494f5ec280dd5eec0b14b0e9426a0422f3c75370201299d394c4d90ad -8e1c7ea11dd513fb8527fa99b899444bf89a1188089d3bb65e3eb87025de9a48e8b4a3068a955fe752f2416de282ca20 -b6cbdbf2b143330db09841aa0e7d22d32772ee62006e7cee13d8c4ac911ff4a59a9dba3d84bc46ace1760353d847bbd3 -b8f5aa3ee213a44c41f63c11f685e754997cac37b27e91d07bcb69947344d94f3b86284b3b1655e168befc01c880d550 -89f93b37bda703494263b10768118ce998ac1f395d422c0ae840e47c6d649a3ec59b404c164a1ad5ed14ccc2408fc662 -97255607a1aaae89530a3bdbb7f2b7ba3fb9d5dc93509991021152dde08a638bb3152503cf0c896c9c19d61f8eea36d7 -909c7ecafb798e6aa45867976f59cdc9d219aca6fd0881f82f296a83a2a3cc5ed47f08794e6e3009f8847f16345f5f4b -9560fbc2c531571eee5b7389855117644f156ddb00b23a7c2189205d4cc613ec83952b96e941cc1e725c2b574c46ee9c -aaa69f68b6086bd369fd92355f3a0bc632c1b1b4284529c18a7cd4d71d827291bc997ce74bc92dcd6900419be68efb37 -af9ab7e6a27e61a99f37b89fc816974ff916b6a24ec3aa31d76579204bdd5ff01a2eea26e76188976c033db4af167db5 -b026dc8850af970d2ffd300dce6ae07db0ca2d21978e4f3a6797b6e3e81f1d9680465080a983c31d473a77ffb62acb5c -8f82f92ca992ac352ed1e8fe31d24f8090ce6a7f02d6086720422b9bab20f3e3c38a5f63c7fdb193e30d63f08e53c900 -8b896a2ae84c66109c8501cf6070c4da65c43ca8ef9b6b06fc85b6cd92bf2e5397d492796c528c7b2cf29ba93341a87b -961bf4c0b8068c8406a864595e156004d427138e06b390519cef53af8eb00c748bdfdd480521c6aa0d53a78e8f806217 -a6fa456250d20c6842dde55d3884eaecfe8a39f546cc5e4a77f57907192e849a956a33a81369b0f2633c55bd6608eb63 -b1d1d2f3e3e058ee97c9b6246cf073236438ed5e782bb21c68cd0d77b44f29745dc24d01edbce4437d93071b6fa6e0a4 -81a0bec80ecd1b1e72256ed5be7de8deb11046ead7a96e1d150573f4d896e642b4af095735343f6831bb6b7f4037cfca -b48d8e15fa8e0b46937637de3c727157f8073eb8a9a04bf127e68977758385a791da2e9c69fedb89b334fc638ece78d3 -afdee0774369653bf371b8820e285e1b48b40745a44d22cf2098b630b8ac95796a74f79337cb97fc60b6d6b903a61321 -8fcd9ff2991902149db29cd4674d60387d4f65397891fbf91b7699a42f579f6b0afdaccec70e5e82d1abd81de859183a -8af5c73367a8439b2e3e5f1b65e00ebef2eda640bfba2eae48582cdfb244e1b1cc540bc0ef72f9e24399affce1c3e222 -b58cad4da101363bb8d6e8cd0ec7c078f7719462856d7ea573e2bf95e00cc23020031901bd1f2112ffb90d847241e5a1 -a671f7fe2ad81e9e0d5e3260a9dd7808125dcebd970877b000bdaa3207ca45ae1e5458d5ab7bd69b2adfca8b6abd88d0 -a8411cde9eefe73fbceec3e5e3628b159ca4e4c19385ab50b8d7a482f4258f405c47051a89f11dbedb2b15e84d8bfcc9 -b5dd09d5ebb26e341b6df80e836c6de2305ce4941238e3e96da549857ec314b1658f8b03ef069633625b6e4bc13b531c -81bc9bc924039fcca8892b40aa9fe8f5d6f305343f6054e36647d5f14cad3e4d754dd6ce9ded67ae65825adb4e16df31 -935ec74c2dba94b1c5ef2060c31bb5c1426965f68d9f4125cdd891f20495da9d5dca513f65bf3e8c599f1562e81a0c1b -b9581e11f361097620130e753d134cce6d40ddc7c516388fe4c881fceadf738f314d241dc14d4f87be8ff0481e898c4b -b7be50ea49e09d10cbcf21b6f717e0cdca582d57935d72d17e62cdd7bf2071e5d5c91ad7bea79476537e515f0d2fa5af -ab467b7fd32a795411e991417be57af8b62ca199983efc1f744799136ae5339173111465e91083dbce60e77f9f2c0fc6 -b99afb338f747ae89e7cebf069612e22f9704f247d66548d305aacdfae395609a57d4d5405ff0f1eb1045dca4c3827ce -99a5e52374e1c55f65e44951f68cc3d607157e60d52cd088125a81bc60f2009d1b894eff8e1efb175509aa4b57af7276 -87e3323cf6f11b595ed745a9475a6d99d11333043d512bb61d5f9d8c3f0cb6957aa8c3f041688f63ac13a51df29fa061 -96a5f9ed28056138439eedba186b754f5f7693c09422f42ef82a315b7413b418c4971112f4261e1b9793ec9066c3641c -b9b5fd36d2d861d40b947c3c879a42fff24b9ee346163e544ce6c3301d0003cdb47218644fd5f1f7f0d6f19bf647ceed -a8899296b58e5d56d7da438ea48bd76310364ffe666d698c86f20683343663d742a0b3f8c1255e33f1d424cbf61bf1e6 -ac4be82ca78df2a367f13c8bd1cb73a28015853f2745e025626c325a10b778cf4bd9942439e35015cb38504bc02993c8 -ae5d6b99ef56cebd5e25a9c002e9e80c1d3e8e5fb5dcefc8ea7b7798c7e09b02147da2ba14e42e2b6db2b2a6a738f598 -8c94abefc71d245b0bf04f34085da0a9b8d4d798ee7441596c5166ac353425175dfcab0f76bdabab8f0ef5a2b453255d -960ab6939b1185806e9f985c9381206c7032ea8a7a99eae5a66f276ad5cf450e654a6f1e956a2a63f33d6f715064d051 -a4c7c7d0fce514db07bae5582f5e4f7a05d79f7605b33fe2a1ae980bc388b31c056438616bc8391ddc7dd5f98810c74e -ad5df00f96ee6e9e1ee65b562d6311c38bc2a0a25aa9ee36f39766a2a03141e95285dd2850a598385f45b9935d63b78c -b051de656e37ccdf3844a6e095d3b42ea9c5a545e0dc2a5234e2016570375bff6b55ee0dff04ece5713ba8e85629a7da -ac01fad1ac299567a22da6949a011f429bd9775de956dcdc247d5c186ec577fbc12a482ebff3a4ab18a8e35f3e2218c2 -9654db9c6b5e58e0b68fc49718773d44129a0e77bfeee3fb56d27c282de6b75fe9c10f4f3b5d3374443a9fad45c400ce -a556631390e6cecc2ebe390e605e6fd754f1961e4bbc063c31c08812e0993eff5b5b7449b9732bfd3a22c87f9c528743 -b41b7abb971e253dfec3aaec4443e875d73373c70c33e9ea19c1176f8cf1278c7716a76a4eeb641c142b2c6c1ace5db7 -8bf37cbe29245c5e217a48140d7f0374f46596f2e82c1144ceb41c9801211869b96d7f1d0f7345233abcfead0309cc3e -a380a799b80f1309ba326f26ee46ba3081b12b5a1143f8289b2fa067aa3ba80c3690fcefded8534a80368799b71ee9c1 -93dce0a2aee4d67efec1b284142d890d1e0d7abdbbfac82f90dcbaea94eef829645675cf17050af7b2e504a46d1bd288 -b8e90f54bc57ff52b84fa3fc3c3047f379c5587ca18d9988c613a3bfe614fd5fc381106729bd62eda298faaf17b10210 -8d8e4f508c284c52a6f907ec39950235c9443c5c6046762911f4818b98293d7d60a2c3f94c5cf60ccfeaeb8f283d8ce1 -a513b66299ba5104ba633cd68121b9ec848e0c8c5252d04a0bdbab5e3bfe6ceac93ebb1ee6f0274920d84eae27df1520 -80e2db8b919dd2ca33e833270738b1f437ae312b1c53a73106b6d12672a395fc3b941292fbb019d40e31b8e96bcb85c5 -a4c28fba416985d47c947b0669cc22153ce887ec54535a18cf457622d03120b6aca71a45fd8704166f6f7a9ea2e9d608 -850b05b9c7e168a83b0e0e77d16181a52d78aa96f4026c4420824cbd44dea9f27f3336b1736bd545bfdf548eb3f4276c -8efabbd63f3b9ae6111dceb1cffe45dd23f1500f87382816d4192161a77dd0776da2a4463d32da85b802ba7299fa726b -9426e75c6f7fb77072773a2ee03e1e3f1d90878fdb5d8c294265262f5c1cdd74a7aca339b46af8a5c43823dac7e57edd -a1c4d2ed335a3c92d867c5cb999b2b807dfb1d45e35b3960dfab19da43e2d1ca9a8748738380cefd137088d8b80d3006 -987a7e22092931f39f05f5a6b38f419750370a71157d4443510b61fe07ac5aa31cd7f88ea04121947b1c0d0419d2a25f -ae73cbce7cda7cd90404302388d41b49ed7d7f505a9a406f0317fccb29e32a5be61a6eb0951657f2d93abbb497be62ad -a1c7cb4056984c22a57ce76272428a50fd33f0f7a68c29c9438af05a87bec23d8de72062fb4829adafe597a278de0c01 -b72c81a9a747a83a650b58ee01015a8882789983b67ac4f2fbedbbf47dbe30f04f686877d8f118b4634289866aecf9da -91ba1797d6913270ac1cb9c87d9d8440a651e294c45b2301ff8c40416e58126318f0f2d411b7d9c09c8e19f4da8ca0ef -864107657717124339cb2ec06cdfa75fb9c4a7ad5155cbdd03d155a7f9e9026e237d7cf5f4cbf07239e7bfbd79900957 -87af853a334b8cdd10bf5f78753b27a0c9aac9f55db7570e2d9d42f13d0e2f8bfc4ca64b77b21e478f23385f17eb4f6d -8658227bb8733d6c7608d66a748caba761f28da4d95e70506dcfdc18300a559b4a84d11a9a048e82b292eb1b5d88bbf9 -b078413570ead3243b9666c109a17678fe60dd1240caf01d1d344de09e346015cba7a40560b0d68b18df82a0a37ca529 -af6dd12875a891eea9d846aa660a207a527d08f5959976f6cb7585a98b1133f341f4ae29157f6ea8e0500fb6b49fb9c1 -abc0fb42239fa531cf09f7288fb00f1d1587f2a86503593d481bb19b1159a6a9d6f4794565fe923a545d45b058d3a74b -b95966d42c59bb12029aef1da7fd50e9e8aa9ea287649ec3ba44247b185b485260af077e0d755f322ee4ecf8e2c8137b -8b1a2350f9bb0d6de377c00f0897081bfbaac5d47cac852a22dd8a427fd2e3029a1708f452e958a07236c7f35ddeb565 -acaff21e9740b831fee42d80a9a80cffa6673e39f85b815b4f546f538dcd803320f90f4f25436796721c8a11f5a1b25e -a0dd42f019eedba19f4345553965508aa9d2eb1499a363056d95e27f7083c2343e74a0e7dfb101567250148ee1bec1d7 -a08d1b1863e594bfcfa2e21ef4edee8535c8ee69490a4113787899ad8cf2f2ebbdea54de193ded85af82fde074ccd0fc -960912b621ff08e27781a4f9b80ef1014a4064fa3c96f534b67e5a094a5c11d9cadb2b69cd2011cdddb463f2936c7ff5 -b3437f1e0872f6b9ec071a951f26120f27425789e00c1a8d3183879ed02e3b017406c051f32580b78b4d0f090474b42a -a90e6d1b11ebd1f1dec54d7b3fb336b9a53c821f295a592e147d5fd453d66e63295a96ce827c4ad64c37d4bc0df2c7e7 -b357a785f3dc1f9bc1034da77033c0c64b29b78c7381ca59ef81e24ab14448d67dbf84756ea233b9e3539b5ed517d9c3 -9360adb42210abb9d7644bb95532e1f461464446e94cb5047bf8ed5513398414130630866b6980b6afec5401e608f6f5 -9145a7f8b2cf1bdd90b9a860051eacdb937189e8d68793e52bed202fa1e23a87db9c51a18f0bc050dfc3c600780099c3 -ae086e289e16608f02281bbde5a6fb2479e3151a2464b86ea737f8a43e15af4fe781312d0e5620a42a096cfbec885b0a -92b57fb14a0c567a16567f83e72b03b8b564ff6d830a5776014167cea06205579dd10715071097710dbf50b660b9143b -83e6a3f027163e635c2a1a397d2661a2d6c72c25082df129572082db29b1587c78dc3d2e5999112983a040ca46bc983c -b1667d022c8099dac5af4ce3b4ed6f524819240275725c7580a2386f067fdc9b3a49b74195cc6f661212fb07ff133463 -aa2eb0c44df0a80047eec28a80440ed5f363e3d42908506bf8418bf04e9c17a5e9f550bec9c8ab8dc9979736ce325780 -a2c1d257de1a55e4c10879eadd49af8950b0cf25121e8d7de30049360470aeecfbef263739262bf1f97020c6b025f9cd -af29d1afc9f76417e4396c54300773fd283f1bc2cb00308da5e6b1deac7a48cb117c0e8c87b03076c7a1b8414d25dc97 -a44d4f2186f5d728fdb224f10b496c9b57d96204325c452842423cbd29bbb2d07e98013a3880c7dfd63ede725d15953a -a30c45d1cdc68a5d5ab65b57d60c8b386be836c5bfda7e2f0347229b7807f6a97b632bf54ba3711066bcbd5e0831e5bb -a8c3c93d6a3526270ae47bc2628da82bbdb8b2c8e4d6a4cb5e9cf70b49999a963f3e856ff9db12cfd2575187bec668c7 -a03566f1a99f5b82e8243678d0bb033441cb8a2f160c0c66dcebd0b6922a56f895a69b94a9c65f4adc9ed73420fd30dd -a4e3c839a6f4f4317e7bd06f25c5236e42fb0e54bb975f18f0240bdc214780049f0258dae24fba6301aad508ef9abf69 -b7e0349d89616156679d06d1626f45dbc9683ad73ed91f0d92f8f82cb0ea2ae8d3ba3a752e73a39da70569d41e84015e -8c9ec5ff6be4b0d9337c5336b467c6d4f552af691bf083a23f1f9856e18b5a13852143dabf03869009febc443b2edbef -a12ff782575aca7b48844f0402a311bcb3e19514dd4d2ba5b39694c66846b22dc9ba25ea39c3c1bc325eda3afa1f00b1 -b55bb586ebf5c9a3c83a04bae254e22547f37b9090151d96f5d8aa81be17bb38d2763a08cf0519a91878633ced6ce0f4 -b3957203932032fe180ba9cb5347c2c1865a3094d03f6611148af4094fa6a8eae522f2651780d9bc49b41f5c36054eab -a0c865b498e30180c48fcab93342a50ca1cddd8759d6e0bb54e9f92e7b60c51c373f7ab1432aeb5e5c2d3ffcd79e8180 -9503ffb3529c3415c07247211c2a4f35d8ecef98ce9f921e67438ffd538caa54520fc6d248a081f46221a0f1165011bb -906deaabf6e8dd0c24a4b22757b7681bf88268d9b4ff97f2844f9de825af511155d0bbc48dc4c03b87007be94f835d92 -96c2a7f48990ecffccbefe128a28cd5b26c664b8dc9bbae16d857f7efc1b7711c734ba7d1476945d09ace569297ea96b -a37ea083b0a61f400b498ac5ba2360c22e40b688428ff4a02e3cc80206b61061bde037cd52d97eeca175394dc675e216 -89b15c3af439769829ca930fa83c47afe070f6e2d7a7df88e5a4f3a2c0630f9d143bb3cc43ebf9bbc1b91be03d35ffda -8eca6996ba407886d3b9d2e4b1aae1983023dbb1c9ae47b6637458c73ffb7f422b0a893eb0b07fea2c5172ba335595b4 -81df4d7f576930b2865af5ee1525718a09b65d9a013feafd19cad335e4e425485531807078b9564c8db3bad95d23bb0f -b6635aa3ca31c851a0283c0c6356235a5d8de9d1db9780e62087be32089c1c081bdc642f067224e88c14252efb960e3d -a0120e81025ba07848ef24ca9a94699db5274a8c85eb9c2f3b41a81f630d09d100127154ddc3270525961613a41ed81e -aaa8dd063f9f4f73f5a7c440671e1375ca8c224f8f869af736edcc435329487902249c68ef646fbf71c33a8bd1a04d9d -a36bfb14bbf3956c317e01fe744bd9c6c6f526a3881f6800592501ca1d9caba7f81b3b54f53b2ee1b13aa6de42ba06ec -819cd123fd793c0c9aba75aa96293268a4731c68c0a26a52561a695fc4acc409752de84ebd19494bae70849ce538138a -ad4e50ce325477621b6eb4d453b087c3d7df6e3d019ab41239f2ad0615c6030aeaf85e0e020f3e6c89e46b8586b4a347 -a4327072fbcf33be1e57ee4bd5db4c079c5ec11694a25fa2fb30932f8a2a35a63183b24d3ded7f6c8a8d0ad111586dbf -9454f17aa8fbdd2b15dfa6600ad305936a37b205eb554c915adc43aceb4dff6b0d1414e61584d5b15265f2ec0c85abea -80eed3725282c83dde575620bc0d86e50412df5dac3b3556d1e3bd9e7ef6f56dab202f4dfe4ce542babd49c1fa7dea5a -b90d1a07ff760daa23b7408b067c322f126023389beb7bf373f0c68b85ba0ea8a2c03e77e6d3339a01ed3ff8ba51f1f6 -92789ad894995ba07f36a0814fc3289810136f9dbc6c70c57ea80db464772d760b57d5b059d4ed458f256af7603fa2c3 -96a4ae1ca46d3b26029767e02fcf2f623d32c952712badf2a2af721226473f4875c40d5b14e66bf961a5a56aaced3aeb -8c5073f4846df9a0e057f52fdefe01a9b8c9ace91ef5ac253e823e165ae698e733eb936ad9cb04d2c54cd8570f328c4e -a9f36450b5ca66a20e52bc196620852a41f1f40262a2e12c278818b6071e6972c3cc6fdf83a9ccf586db6cc177173cae -8f101df23aa7e353ac1034c38adab8f20b8753aacabd10d70acb41d0fd0b1f34277546b30f64d0a861f448f112e38acf -b45b0779ef1ffbfa86d7e02e89bba0316c5ce60742b350296eff0d04246f1c8b1bf5bff68bc97792c85f1e5d4dcabacf -b7e89d015f6c7122a2f35f1c48b43eb0076ac4269158d52e38bf2a11de11cf2928175f717ee5c1bf543ea38945658558 -ade2a57ebd7600929dcdacc290168443437bc288371ef40580df515012350f3453b09aad8ae9e64bbc3fe6a3456f2c31 -91c2f8de02bd8dfed1eeebc40a422d444e3459f9c33476b55de3e950d2c38d8463c4edf4d4f95347b0599a48cb2d47e5 -8f6e77d9ceec539e0407a8d75d4e855e376838c0f886b36615a9c7715bce56a8669586f6d7cef75812d84b8be91380bd -87637da91b051ad92081e682e289bb904c51d95ee1a6ae2b8956982093a7bb4f8a66d91874265dc32229f9db5bd51ba0 -94691811eb74f2970a95e9a2d64435952145f1d0caa76040f9811c9ea1ed7327750d57d6e8dd63c6378f336421d11093 -884cff4ebea1bb48c0d651bcf0a710ebccab9062c96364aa64aa1275e9364a4c261e40a4b9f7e1e135572681a5a7a965 -93f21d4b6b53cdc1dd41cb1b80ff73c0f1620db41c35aeccc059128704e9d1d7da5fd3240e7d075a2503273e7525664c -b9afe0a9b64dc43fa78f607cdcfe337ac952fccfde41c2e88abe3a8dbb36a51b3445d724908e552ba74bf67ea2cab56d -910280ba145bcb6a99d89d1526f10632206d2ca9e1a8596e5d181dfa37e5f407e1264b9c71c39530caa59894c10b371b -a5f583c9fbed59f99cf5e21b9a734de6d5685b9c33931325dd4b581bcf5aa4764c2a250924e7b6f7931dc5278bd17152 -a87267f2ad292572a1cfc89308c96aec0d12e5f0fc2b4135ff8df7cf83bb1e71d619906d415db5841bbbeb173868ca82 -899d7ff8d7f8d0daf62ec8d28adbfe4e7856582a23e62dee175e3bb9461f38bf8e4f73dffe10654a046573896f6de690 -a8f3601e6787e788d46a9d7592dd4bdd8ea8b5136e3c897d79ce560e9511f6236e67a85a35c59295428c1f9c019a0841 -b180a16448f085227a6f3e363b0dbcab285bf419d438a13be2cac1ac9f97973ff6b8aee38294f70a8d72bb4ff474577f -869038341a2f68ba85f5b2de58d2d794584a3c00a76ad0dda5aec31d4e3ee433be20c197b40618f89f7c8f1692ea3cc9 -8366f825dabdf4f7714c5d089443d0de315198e23fb93c3ed063c4b8fca0727b05665c04beca145dc4c02f333e300c18 -93291da32b501cdfa3624b39f6e38ed982c75c1209cd85630cf83288204032c0a90f013f1dfb4dcedee7aaf0fd95566a -96c95a1e73016fecc3483fc94dfaceea376ac700fd4804b24e9eda7135048e521daf96f8f63d5a1439950a64296d8124 -866429fba47fb691a4c39460031a7e614096abbca3073e9246babd23075e8e5f6051e424e47d860296ac8ac646f8a283 -b817f3d9985cf9f9657fa800ebd36a9622566697ce68f91c509d9ad7df8146532e24ad85c07f399908f87d1206c7642c -8761c3755cf5440775fe00081f79dbf59829f8d400adf7448188b97f756ad35658295649294ac9626c2569ab21a5df86 -aad65ace72ef89783507c9feb5555275d70a421a95f306b7613c894bc24e978be809410b519e9314ac56fdae0c71d326 -8ed16ed07d0e989061db5087d50cebfcd6983fd54be5062e333bfb8f6f609bf1b7b840c91ffe4b66fd674eeae2dd1558 -af3919bbc0df42b1e2e8f62e931701f7c35cfefe3ac3f1985ddb70212476112e8a19d51c673da931777ffa28944306f2 -99a364d8819b5ea0f6d900167b60063f40f9afcf291ded7adaa2d0e46f344751cb312df1c2113bad8d84a028f680b41b -8d970bad8f95ced0b0323f4b7b087efd0624ce21834b3c9ed435dc0a394cc2c7ce58f1741c1a64265c81654eeb6801ee -a5f96a4d794f6f844b38f9b82ee15c2441cce293b6b2ba26b25643165236db05ffa918ebbe20aa89ed2a8ffc8df393fa -8ca69e0006f6a72e5abcc32c3961aeeebb8c0a76d877fdd8a093467485c19662b75f2ad8c750acc9cc12c8fcbfbe9b0c -b5378b855f6ed3eec19546cc21c947dd12e98783164d95a95d3cac36c89a840bcb9f7c99b191fa7730ec28d57e7326dc -884e50d5e20bebca96dda539daeb0e15edaac7fc88bca254a7239f30aaec47a64f29b69fb2d90041b82f8ad8e3f13d3c -abcce1f6149037ac8d27497831acb867cd5e05f637b7579736ba5c384b8145f127c56b82b1876881b782b94a84d32d04 -8747985d53fac369c4a23224d50bdc556c00f406e7ab3e38427aec317ae7c0feee5b48b9386c5764de883cf296ed1daa -a153c77887f271316d5a7185fe0d2bb7359cad86ba80b03434bee8f21b3a5e52263d28cb9d3d2e6d5b7443196e03cf80 -a77b16b2b7b6e999144af6c919e0a74b9a6ff70de41a133f7f820befc1261bf261142717133dd4a99e168a5cca4791e5 -b89beb83489db9fb62fa32d1a8ecb66fe9ed41d318820d13c3e07e1c97802dfd7b05d34652a478a1deb3b17b4243a499 -a80200902da696d0d3974ab29676f0eb67d15166b173fd63b247a17cc49f56b6ffa28d9690841ed4865229248650601f -8210103eccfd1f4be55e33991a831c50260bbabc1f311564fc1c52c3b2755d3e4a11ad69cd95e398dffdb9a0f5b77df0 -9958745d00d8f29d05d97875746d863007b1c05d3ae920794e6c65adb47ec208734fdaed1b49982c4f4cdd1d3043c369 -94a4f28dc7a9d2dd01ebc2f3ed11a5bb01a2095e7c772d2753c022d991da7b2e4c80c2170209bcc4771d68ef8cf007c0 -a6b5c5543ae3de57e074fac82221590a8d771e93e22fffc2029b44e8a1c2c8c9cb0362416de54d00fd5420e5b1375eb3 -875e801265871509c71dce38005ad6423fd027206e6ab4c58d2978ab4812d5720401c1310b56ce9ecd95241a17ce0e7a -b6819bc6497ed57feb41bd82f56216b513085b6d1a560a958adcc06a6da304424ee34ab2580604b0e59f6b0091ffe6ad -93bef0806f21f8bac88a5d6e2e6d1adda06f9daad5cc3c8de61162495d8fcc3889b767a3e2f3380f162166ce40a0ce80 -a1f699cd7446cdb1321a05f970bc70cc98593aaf0145a0d097e60e5897aa311b00d019e09cd533d0c0b7cc5c00a753e5 -89ae140ad75a83db2903a93a3711be90986d08dcfe962aec5ea4ee69656026dce77821993c1defc4464442bfe7d44734 -a4110c80ba92f545a1a7545cbeef997d6c0242fd4d771977192269d626b35c88c361df53bb36dfa8ea7e40da68e45f81 -906786f38eb7e98c431fa2464048ac3f1f1df8f908a25262978327224bc82168f564b2f3e6da77f49457ce49c1a72c2b -b28d92b3228547f03a3f489e09070ad9a1e20a73e49f7ada96ce41c19cd6416ad809b3a3a01f141b3698e85c641d795d -a25b9df9b377baafc8c735a772e0ed9ac007c0b6ebac2cc0f8f2e799e5e6038a616968c9896cea862e99b1750224ffe7 -8085eaabc79a2faf1ed0b9fdd017fba1e46c671c6d8ed78fb089494f792765b0617f790016d8f55697dd0f45d17de4b1 -a0e81b557af74efb95cf94054264d30396121312c643052070ab53eac8e75075f1fd0b384cdf1d96bd39cc98681b2d92 -b8e0ffc7548969ae28beaa9d8bd65872840a03150e2140dd799d9924249f92d962a0089171bf4b311520ab527198668f -a6188827a500b99af6eb91094a0e464e394c8c0a6d80cfcc5d8be89e8810732a03ca75b2befd00d07d1dfbe7dbe89be5 -a4e5a47c656e74107e6007199b940d8381f706d5bb4226a0b2fb13eda725a556530b8d4876dc49c5f9631dc6bfcc4c9f -90330a50442db9a9c459e06d42cf7a69e009332976c3950ae7d9981d99066fd2af22f22ac429850b998f1ec929c82bfd -89dcc51fb717212b2dcbd0fa0da189e194b4ad5bf7f43ab2cc2c96f11c186d0872bd930aeaae01661ce2dd9f94eefce9 -adee914ece15575cc34ab485f2dbdf3979406ce7cd8cd82197f156f373beee6d80e5e3623d79a2fef14b0b4ed1678a51 -87e97e8866002364bbe9b49c5f2b5eb729c7018ec61dff7b8bcee1c1ea349e5e04a3f3781617d46d8fe0e62afe55d62b -b6b7bd0bc652a0bf79aeeea1767f0f17dd543b9de582531bb3e14ba2bfe1b720a6c6b613cfc295372eab9202f5e2d340 -a6f9cd96d8e422d9897d50bf36288bf4c09d28cb0f5c4e13ef7f76cef6c75bb594d0ca954ff7339590cdece16414fdba -b9bc319dc5e55630d1ee8cb48978a256b69c96aaabb5269bed8c5366add03a2c38da11cb03a44e150a5c7f34bb49bcd5 -868c36924f0056b3464bff8831543a280ced62be748d60f82ac860c32025c4589e9354984e1cedf24678374c959383a8 -a6244602362c09b382926dabae5793ca4fc50600193c69e645fe229a471f7cf9e58c4a59124d6d2dabaecf50f1e1fd1d -b42df58ee9e20fce589837d5ed8a938eb83a00c6ffe2f6afc973f6ce26559b8d220976ea1fc18ffbafe739c92dda6618 -90c0b2ed8ed7cd6f6ff812c84ed297b3231f6e2106f2df6d5e4b4bbf5378231025582cf39f35dc9344d9fad3adf04685 -a968386bf1221425cee0d0b926689426fd77e8e8bca5ad3bd07298fbbeef4fc676e0cf7a4f29cf981c682a78a54a2d1e -a3a46bb7db36e0294b509036a40875850ea5ce4e8853cc0a7d85e8455fc2bd7d5b593879408ef2f3b2b2bfa44aca2276 -af825963207f046b23534896086a3e56247d752982417047f850bf306d0cce285b537508747afc700dff6472fe3b5569 -8022af88981249b5da08ccc19e4ffbc35feb2cb5308b34064de4d5bfc8ff2b933363988c833ec70723e3b5107f8fbd67 -89687fe6e424c7f0d2751e5f7838e9a3fca4c0bca043806fe511442bbf41cb67d01165ecb662b1ece1b2adede5a9537e -99c925763420fdac4149a02131831449c1df8be4867a6d2d09e6b14abb821d46bc1fc4fc9aacfa4e9de1a93f9b56fbcc -b819ee6a0724de9c944ce2ca51ffd3f1d93c77ff25e39de8be2a612abe732dddbf2219e839686a4373609a560041291f -b5eabf12513e91139025f1236c7ec235368eb8586522dce04d370acd3d854c1e6676d92014b60ea3e4e21e9d6f063f2a -b82e94f1013db6cc682032c7760aca2a1082826d280801aad9c6564704362e61a61cb52c6f35f769bd8ca191e68e0b0a -95dcb02a676b17f20b75632c7a9060f990e44b0c1fba84ec8e633554f875ebcf6e54caeb9816267e84a11808d68728af -b0c7c401dcc019d2108eab7e87d6494e06399f6eb4fd95b8ff9ba4a56e549a3d3a4aff13771229f4c456283fc3cbc53c -b1a8e3e500e3ed74bacf91a82b39f2b870963dec0b98b7d5ccefa3212fc9f3ef923101887572e14d08145aaafa8da5ba -b2caf72c47870ce9f0524c4b3df6ab3eb3695765c010a27c0f3cda0ee1c1f5bee64e5392ef8b3f0f11e66bd8c9d4630d -a8fb4864bce5f1c48d681eb37efe7d9ed1a83ed36bdc1f2627539b92c90e100d4dd64ab664e404b0eb7b645a8f95642e -a1b6164a4f0467444fd56a1f4668c8d1f295f6e6f5191355dcfd004c34153317202823d72162b621f677c970a3f0bfd0 -b2cc59a2f6f3b7e18064720f93b28801fb684d98ee808ec5c04a5235dc40372aa0e0521410d8f736161470443bd97ed7 -b5d9a823649c09151b214406189d75d7f1ca150cc7431d79b7d60348b6d7405014a44bb7840e35f9c0a634b4c6785561 -af6b8229fe035cbd6a5da3a3aad93e7ca5ed233dea5fe4477dce46ed17bac9243ebf25a8439ac2896c41baa671c0fdfc -b42d9023551d999d2be3ee51f6ca82c3b2d41fce51e1dab52095af6d4b59edcad70a1f9b1e71eddff894e3fe35a1f11c -b868543c09fa9b9b990b276ddc5b68a2415965d3de71b9ac538c26a6333543a7c33d0b432f57756ac0077d0021878944 -846577a8c877461a58a94c5829f2ed9d7ed107fa63a48ee77a1ef1f1d1f940b2605fc742cb5ef849e3cbfc86942488fc -967ca22cc8c21382b15d73b4dd4f6f0a0bdb2056c21e3c75eb3d9c13dd41336672ceca03065d8cd1062389afa4726974 -8e0b872d766c439f3f868f18ef0c173896eac883783dcc58917f76d5a2e8c291967a032d254450fa7f9a12fa7d7a4cf9 -a0236eb36a4ce3b7d649ff02de9279d364ecd5059932328230314ecdce3278c42cb836f547bb9da9de0fc96cda2fbc7c -92eac5a5a88648e6d821d3bb51b280fc106f751d85a1742a6a1ceed071eaaa215a0a0238492ddbefbdcdf2e38e4149fc -88e1036f9b20a2c4b3534175c93d59c1ade3fa6652a4c5c490f21f6c3340769c7f8147d53a92fbfd84c23d7c4295cdd2 -8b094165ad429a339f12696bc8967ca89ec47a4778f387e42e273a1863a38199dd795d120d198d3cbd93203604c6914c -8f8013229eb6bc6a8f93c17d3b4a1b206c258f14091c6dc39cb1ec492d403cdf5f696070ef5a6c0ab9ed4ec141b08d73 -81c7ad27bd7a48b444b2be3d4b5d4845743d6ac4857b061e659d7ed48ebacdeac29cabd0cd163f3fe6c5cc28753148cc -91c8a92749183e3e6f3499d3b0e9b080109d5e88ce8acb03b35f3d04591e13b4c489ae323a149def1edaaf62f93bbbe4 -a6a2d69f012d877460c33095924771065fdcdddc30670ea84576b72dd3f7769f90d1735f8914b6841c7d938a2046ff4d -a8ad4b976a5e4477a97d48a3cfcce16b358fd3dc1ed1df301fad6d6f0e188782c518796faf1465e52312b47bd713e2d4 -afa2bab9363187473a85f7020106b176903bc3a3e3df1f4938feed5145b79b66db8aa608cdda554166ec47e60fb34b95 -af691bf473160cfb84ea517702f3c01daa6155f31393d807c897b39523448c5af09be581ad713c76aba194f90895cd9e -b74f3cbc198c9e4b2c7316fffd57fc749e367b7d1cf81b3f5311d266c9a3ab9598075ffb9230dceee230d5f1bbe3f796 -8c28d21c49a15299f7ff3eff7568b8450e6404a168554b8965a291c03fdbbd3dae9ea6b9760869cb1f2e8c7206183195 -a496a0df4e79827cf3bec117b92b5b248dfe129d783841935363362aee4822399974e6c03a92797b3ecde80b207fd7c0 -b39fa07fc8f4be41588ff5560ed68a33c3020bceaf172fd11e0c1288ea885c6dcfb56a151e4773e57d864dce06fdbea0 -990cd050ab056ea447c114217219d9c0c7526803f63952e22ae60a3996608bfa3c6119a56befc597592761e3a90ef448 -b6f02dff3dc330daf82d1edbd4e6964d2e9c38481e74cde8d9d85a9e602ed22c4fe6c9b6f41ec76582f0a4e4414bf300 -84440e4a7146ec2f34e8099e85c09b8d7bf505a15638aa34cd2b42a20f1f335cbc9f0e4fdaf2e53fa0ebb2dcb00519e7 -af389aed116fe58580810fc474eb15518dcd9746f04a7efd2de44c9774824db79f8ce4c4fa108e7396e1fc016132a402 -b202985e01c62d0de1f6807fe600a3b81fd11f30f5aa033b1e7baf7a62f34fa5342d42ad6a6e309560e3e9ebc662920c -8a07641140db9701c676b2c094c24cd663a5a34d3534fd4f5f1e38ca0c46772d141679730b5d0cd71d056c257d9a125c -99dc01e76174370a741e8e9ef5654a3a7769a010da85de41dd315b674ba8786e6a697b74a79ea782a1fcf74a48e51775 -93fc897841609670a1eb88d4e4498c54e286e25238309fc95389b16e4edfb82b8ee8447a436893c7180827a996b9a0f7 -8e2dd561acc8954a53635c0108ff964774fe98d12b28a0c6ea8b5ec5ea3523a45b81ec642c1453e3b2a1c0e0749562be -a95b0b7f9e53720f4b0394bb6ae8222aa5be00a2050f59ccb595d50e0dd9100e397af9ea77b0335be02d1713c361357c -8e21dcb67da3eaff5b950f989939237e3735a31e346e1bec8e6ca11edff5223e33c1c6f2f79da975de2fd86dea286e1c -ac02cadeba36143767bdb8cd4e1caf8cb287296b53955f33ed07f771a1fea521fd64b7e153c90d5e270c12ab959cfd24 -af95bca4016b2ddbca61c9c854cf999ed59ab4b5d619dd55460f20cde5ecc86081a2586a7eb37f15c20280dd06b65809 -b7d7c81261e8c6a8983442e1e801f5072bbada1eb2e49b8e90759dcad653c52c0afdff9cbec41bf21cfe832e49ef8db8 -97fe8c6d071dc80355bf2a74c15ecb16c59bc042eff323e999f4fdc39e1209803d32622c642ad25673c84761f0d357bf -b37da716119c00a0955a7fee59b93185a6e325bc5cb2a7fb35681fca0688d0ad2d25a0e40dfdbec1a11deadb1cc69d47 -afb8091548179fd2a17d95ca47909d97866e4fe54099736e6414682ad083fce300e0a20dfe3a017c1ee4ee7d271bc470 -9306ba1f3f2f74964dfcbcf9b87bafa44b5e013853c46cb501e10409f3c2af7269aa17c8cab261fe82e52a188ce0d18a -82430e3c25970411f40aa72ef1cda5b2b51bbc7e243a1b4951e92cb56a2f5b200a039f5554d0d1bb44330d89d1ef8840 -aabfccb8f3dfbd4012b9d196448e83f17bd1ddb8c857dbf98e80ffc60c1af3493ac5c70e3a2f1f26352b1ead143dee87 -832cd6dc83380d068c068d815ad0f4677de0ef602890835b8d32b73223490a6f753092d651968cb3d798cbf2a227960d -80e3e7f0c46fe5d962322f3fb2535de40dc078db80e7ef57923d46b742a8e4d6dd35ef74234f2b1637a317364d57abbf -9306bcc29d6f8a478ec085b144161850afa29d282cec756d0d3fcce6f4860f4a4b8c8a5952cce54ea893cf84abd6c4fb -9234c03bebfe6b47aedc7c5452058ca6a8def3c368bdbc9019ef121ad44171d6b31d9bda9c82300b5b396187324684ec -abc2ec6016ee252f5693558b694eeeddeabf4579b7e03d37504c26ecc29263e455ce8f0158fbfc54135600b72dc54315 -b46fe7b51df64cf46888a810365f891d43db5b34ac4d3505f0692603adef04b1d08eadb3e31d039817e7b89bf0789802 -988e0dd101bba7d7e4094cde99eeeb6d4411341e684fc06ae78d163d30c4b585375a868eda7ba1e5495ee7f0a7d509e1 -94d3033ee1926aef656b31192653d3da96d5c533ac2436d68fcbaebf827475778689ecf14fc53042a523e4652fb9d713 -993b598555bd2a35e9a03f99950d09f55a48ba63f9e0e65802ecb95602d045001f82f25c3bb60221adcb8ab4e2709ba1 -a0acd921ea7db9870716acb595c65a934a5a06a07c6e54cd26efc86c97eadaae1522a4a26c8f93b7b7cbc4746ecfc21d -8dbd8f492764bee920e0224dbe39d650be6732b56976a5e1b636b2e7371c1509431175b66c6ca879ba8f915f9df8fa36 -a01b24c1e3aa044cd2598032950755763345534f95f6f71d50565d25cbbbdf9c42e35253e35b683f6c3156f5c998ca4d -b895522dee1ec9c5289e6fec652093519cbbdca7a2936fd1df3ef956eb404f1a24272c9ae6ce58eceeceff36d76d34d5 -b91cea120e200858457a64a60aa876f167b1b88c1dacd9988700b9f0f0d1bd1dfdd8dab56c2e7197a174b7b8bb8422e0 -8406767e4f7cee2e12431b093ce82f633ffc76b451ac8414716fc74fbadff30c52a22869607d5de465d0f4df8a740343 -a2cf431d18b2fa526291c7027d59b18cbd73a9b48d68cfd6e4b745d27774941af809edba06c8534b1864045d6fc1bc20 -ab3fe23aa8c45ab2efb2ca0c593c8644d3f47f748c2f753626289b0b9c761add755e3b52521ef37fd609429b2f8770ff -af4530dfc5b3f37888900d9fd08554bef4e47c4c09a8c82bb48c4b9c6c9089465f98762d81ba4272b6861121b65f3c5d -80f61d086511b9b8b2033921336a68adde99cd25fac71d8f8fd0e476dd30cdfba49363784f0d0578c1f648f93ae23f8f -82ca682cc254952330d1be8c0e53da24aa943ffe0209b00bbf046e1e4f9425886a01d6582e2853137a9c256316e6f737 -ad1d508d2ea2806c351d5bd1098c46ae7ef83f4e49e4e87f83fa2c63f715ec56109996284a541c2005693687b4813623 -9061817ee94bd2895064f4af04777b499a1fedd9688ed64bdba848202c3cf9286b699c92400ed456db926ee23a34f90a -a8bda55cf6f3f9edb78b43a52b7fe76e5cc2cde21e08487ea597cc266e54700ddcea1a287ec6d8f16b738b67caa27152 -b605576e55d1fa4fd9d7fac2ce549dfe23fd6ade41fa859bf809baa3f1497d078cab06a257ccfd6cd59f67f17eb22f5f -a92d22ff5b5ec6dbb1d57db1b740521e82b4bef84dec3e130cab63d0641c3a8fec1f6f86141fb1918dc0f3fcfcbd8cb6 -a0165df8dfd7b3cb58883768471cf485b886ece529d5bb78b26acf9ef6c44314cf9f34914233c93b10b1918533dcb8c7 -88b79c9c721c1936fdbe22d68459d1033fdc986d3e52f39341ab06cc85a3f230ecf0965ee8d2dd54496981fd08a02657 -939b77fcd53a523240bee730c2d7b8dae0b32bc3dbbd31428c7b5fdb4c3d34afe7f2a377b2918497574606bc06cac750 -abbf82d0156439761b36a913b661e3d452dfa57e443ddb61613f80e110acf52765139fe3d1dd59c9e7773b262140cb90 -aba28324844cd19b2d5d07a87e6f3180a3c02c7326bca846c1e7a7c131c7ddbefeabbd6787b4e1e910449f3cd1249ed6 -ab2f71af8596c10351f7ce9c3a9bec08a5c7837cee92a7400826284752c98531a0199e2a7f9ba7ccccc8fa0a2207aa43 -a71d5a4f8af3a16ec9c3c110ca2135c68103109d4384a299cb7ed09d96231c90b04ce34ce12de02a40924d84947f7f31 -b9dd79bf3286ea08c9b779910c84fdd02a33dbff7adc2d6612cd58e81aaff3f64ba021f875ea9e1201243ce353510350 -9838fce2f70e7c47dca7239883229c1573ea97d469f120e4af659b18bca31cb68d12220fbd6e4e9e952b28eb29c1e5ee -8dd341e67e4c567a4ea95252854cfff8a7631c228ac852b33b2ea9211b2a6c606e4b0db28afec61a1a55e6b5f0a6604f -ae9b02d60441859e3e6f3866a9bab8895f0cd6168f8e84dda7c9b1cd7917f1c454f10aff9a8de39909e36576bc0b4828 -89fba7834469a06cb0da39c39a288245e577fd956c241707c432c2590e18e956e8ea3f67e4bee5a5562377617af53334 -b7ab26d79ee65eb9612e54f41f75e22abd83db45010e1a94ce5026a24675bdf670e806c71f0964a33d6ed277d464732b -8a25bae10ef86d7e91a7d686965d17fe16ed635d787d4d6ca337b10ea32082938f4354620a72b5aa43ae62c7a0e751b9 -b18fd9213bf3b2d7d191266c7bc1c31f683fc7da7dc5ddb4c600e1ebf5fa80a399af9e31b4ae747581a07ccb736b4b32 -9968346d8a867eb57f628e2ba00f69e9d6aa8e713377a69413323b1b9b26218f527c0e719dcc1027daf10c3392f59733 -831ee266686776eae4e3de1f2bc37761a5e1b918d4bf0bbeeb20b490902ae97722bcb1c98c485407491f248eecb841fd -b0e949d7c50b852055f38f3542a974bbfe7a33409d67c557d70c1204f87265bd7478e1751251792435fa22097d1762e4 -8b0bee83715e20f2ef832347c926249b5b168e4ad87b2e5a9149ea4e07513e4790f60b1769ddd1816d7126a0f6fdbac3 -84edc35061dbe8f3de90c2f9ace94be5ab4170b66c42583a0643ff776256217bbc6fa31612e68bfb9ab678f8e8e49457 -afb4ca7a4781dd31a7d81ba8a739eb65c43f3374e76b4ffeb2c7048b055f837e6853b14ed2d3224a40dea35799f0e4a4 -9945fd5ecdda5ac952785310e87917126917fd4f504fc5565c236db9b96f9666934766f46a1989c1aa176e543c6e33af -a6d4466b53c48d7facb9cc33ced1bec98897e545b10586857e896d35c850f2cdda65e19bb934a8c74f6def805b1df4f2 -81e3fe4330948c279d99a8a1a4e4e141a039b3ccb7287aaba6f9041c3a8a41db1a4763fe04a36bdadd3d3295becb9d41 -b6be2ef16b60a78b17991d27463e401eca731129843021e302830c2fd665726547240ec3a3240586b01a05ca8206dba1 -b9d7fe5671b220a3da83bfccdc16c0b6f5e9e5c87810db14f070dfee582fa190a360c62acff13cd877c818d705a8a872 -86867f22bf6b859e7f0ae7724a1174a65c4902cdcf74bdb22415875d72b67f49c62ea8bf9ed0d6883ab76512ebb951f1 -ab728a8167b9e82d608d4939a0712f82843f624d08d4013dfd3de41bc526e9d495cbfd40c443f67ac59dc4b5f30ff217 -a5c4d10a04452c1ad12c18ce8ed7eadea1f3cdb34fa5ce0cbd804f5dd92eae2551b771523e711e8037770cb66d1951e4 -8808f69b975f363bc08f8578729a6e68445138dada78d5818d33fb83a7af6cc6e7030f7b76286829861a4534e0b30248 -a280773d32e1ce3544d3ba5025896d21e358592504737de72ae76d164009fdad05c8a1e5e1f8658ca6374b347d47c29b -ace91a3971be87b1ca8e737802918d86375088e74380c444751c65978afba2b017cbd8fdcd3f9a0c19c0782b0034a589 -b5445d816d65ea36c9bc6a3d5ec44ce6b76dcc18343d7084567dcf2603d2af93fa8469a1c493e19f1853c96f89621fce -a238867fce5b09e8695240f936a3f3cb12a715511b7516de995543b2e15aed8860a12754ac8d1c5ca2364e4471a9c5ac -9467528341f5b93b89c7f37c5dac8bafd0af620230a9f7de3e809f01cf73b8ddf70c38c5023a631a1978ac05ca35c318 -8e5f1c3c411f0939ce4b6a5ced42172fc5c3774f596a114e7c5c8ba433c4efd94ca84affc0bfa89a1c5ace5090276a43 -a6351818f7553d446cbe8d3a318841b0607d1f1890ebf9c6220a092bad3ece9ef8acad4d17935e437377af8f9309606e -86630d0fb2bc104d8cf840b0e545c0c149c1a8e4dd6d460dd15a52a5935c8ea5c934ef099653d783894a6d1f68414a84 -b357b5d9cc645b645fbce2020db583cdb68772751d6d11d635f1e3ecf995a55bc374be7750b6e8bd4968a55600ca9806 -a9b659b8cacb73a81093eeec42dd7f4fc5d955f9fc543037f31bbcf456af6476f303aaf0ef960a2df88365c2704bb61a -8b6ff5201c15cffe64bdeb818422fa10dc503ef2a6a4d686364afd0f35b6473e4463719173550d234639f6077e19542d -98efe45bca5ac679cadc25ad0bdb1f8deffba13d2d7eb14c6149d5addfac06b82fbba6d24b323d615eeee1465b3cc30d -8c2329c976d78f1d5e30ac34a3fab1f96436947d85f0dd190301a1868e5dcbe4ce60f48fdeffc3e6a05ee34a461d7dd9 -aec012ad25d99ce014101d7da512fe032673399526435f6e1faca4b63759e8f6694a46ad01672da9eaaa4634f61ce89b -b8d52e530c942c3c7a67bbd0366f4cfdc6a1a075471878516b7a2258aa073eba50a113cf433879a0e15462e82087d17b -b40c5ce16f94837c86e81d98e2130a9e1dd229da5aea52e79cb42217d3b5908a53d76782cbe3934fa8769db58b00dee8 -877300304eb69720f7cfb4f907b4a7e238920fda129a38516dffcbdaae2e46633d31080590d6df05756781224d532fe8 -973632dc791a5214516c3e59b2b48169470678b7dab66d513e35a0fd1df86b992e27ffe6050a5233af20b5d4998d283c -a8ae0e723a8ea6e95d721337465a388b60b92b1d9b1deb0b9f59ea30842de356184fd55d9b8331d8a29ef473c1ac2315 -92ed6cca30f76135c4b7e7893c3460501e92592f7d2d6409c1e1d80074120243a5b9ec14d801991204f5ec4f94ff1daa -a9f575b8518dacdbc5cae766389ab2ec01c876038414b7796f640f633367a5281cb49b48b5e80f6416a33b401c21309a -b9793588283cfdd47cc4547cecfd987f9f8f92c2b408725f39c1d879199d695e87675fa7e5a190ab3bbc97683a0b9587 -8329a844dd67dfd48546791c4330af65501baf9524ecf8ed4fec9ea87067d0afbd33099052c1c2df819ca1afcf25dfc6 -b908eba1b40edc300b63ff6e20e87b17e6dfe975c37ca63c92e8866968070a2c07204264646bbc9318145fcb90c23555 -8123871ed78f46e9eff4fc7af9f490594fd7c20fb814e505481ac5c7bc7588c1706a79b14b85d29bd7b97d7c82b2ae79 -833ed8928f154fe0a88ae98e5d8c74f816e3ad679c1c4ac1322604093e85ed4b9b9c4361ac188f0da5443c72ee4bf3d4 -b9fcbb8a422bd8d996e713d176b7e63edcc6d73b3d1fe3f2c4b59da637a168accb5fb4d227b709f979742cc0af8c0ea8 -ad3759a6a6bac3047935443347e3c63819905f6c01f58f0ba76aab422d723cee10c769663be9554473e668bffde1d500 -a60c1909703211a93d7b5e8b8ec1cf4ca06ada653c27696a7dc9a2ff75cb712918888c6b61b8f792ce9b413aac09f48d -91f05985ff17f9ae20498185f6558f9f38b67966876dcc6981af4d179cd055661adc63155f4afa6167ad61b7038ac49f -95c5add9bab6b9792517772f9f8b21bf7cc325dfd13a43177b0bd982d0f620185d8596c2cba46a5e10aae597129870ce -ac0b4b6e2b3e417166ad9b17de0b3ba775df6ad3a78ad13a1892c0992735ae54c06b1e6123b0c0bc90544441630c6a1b -b0135c25f74ae776c241faa6c91a3f7ed6138d19a2100928b7ede64b79e177d92c5cf921dcce3c614e32de34975fa6ca -b2215b560d5a36f045de7257098e9d75a40122919d4726990b4395eb2bf1ec789cd0c64c46b775f6a8be28f23958e17a -870dc7f7a513728f2b428a3c08b15a6af88a288824e790f41b1190fbe02b59dce2914a1339f7203cdb7f2f9c98d8d721 -8e3895f03952cdab36f602418cd746bc0b6a07629eab0a20bbd8de6c993030c5287fc146fc45fe97a06c992e0a9ddf02 -a4cea15ebc0dfad9feb3d18168fd33768e8ac69e263263ceffcdfa35e8638711c2971697b7d5b2aaa0fd8c5440f3e164 -8cfaf5369781a59f4117283fd3f290b81816abd3124a9486ab1faf7018d36a73c1630efc4ad648ce462e541827d51975 -82b420eb25736126ef18d91e91ca2ecaea8983b8091df88343e8e54ca5ea7a3da6918c97695cc0cd5c2df95afb1e3cb7 -b3c13923a3d46d990aaa6a1eff3ad32f162ccc5186e16a549dc29ad4d63de6287cd05579452785cab32e2485636d568a -ad8a43ad6195e08a36f755dd536842ec88a7d920bc302451c860444a3fdaf294e5b5dc5a122423474d322af5de8cd8a1 -ae40d1a90a77965366b5b5ce87d6fe86eb255cc3d127526930d128ef7763455adb82475ebfb7be31f9c512394f2a22fb -9763bb9459fd4c0de2534767bd99f98b859030b6af5739a7081d889d6875f5c23f0154c30d00b7240baf6450b4459987 -94aace9e9318d79d3c7ab533baca31724bfec839b01187e326b1fdef846968b1b29882f2520a9e237dc41ada01bc3761 -b6084f9e0051be76244ead401e8d2758717e93c4cdac58443261b3603cfee0eaec7d758b2e4357650d2c1f5391edf798 -8c656a798fea470163e70869a13edd30d138bc148460d122a2275df8cb43f2b45a14e0d8a8a49eeb7c1afd02484b6ffe -8ec317e63df2881f49401eb2f6a82e261b07474006fc293bbb54e0fb7437697b16ec1d6ea101fcd56543bf4d69374cf4 -b27d9b3b8c3cc59d08159c765d24fd4660bd0a54b2b7fa9fa00b47e6770e6e8d3ca353d305fd772c8171e20765c8a66c -863ca045abc38ceee09c4a21a3dd18f1c0f70c0289437957aaa39ff764760bc422b748bef8ef133ee28d88c46e6be1c3 -b0de194caa68f5288dc365faf9e9ca3c69b0a8376cdb532cd6f1cc3478671a1e755d0e8afbde4e3a88440fd9cff4e8f6 -8a259f48cf5a45773522f3c5f283a6c01a0febdae09f873e009e4635c57fe5060b01243b2e5e1c9d2ff7490f2dd3b334 -8c4398e1e579778c88976ba12feaeac0c96fc97b4e26a133ae74fca1b9c315c1112ce3977d20fbe9ae5866ca6544fdcf -b54b25aeebf1917bb4981b43f39491918773bacce37e994b74f877d4a636f1b3f4a2f164b858f95259f285ca0c294f24 -a9db33b15331e852da3693f6328bde30b8cdd79c9b9b63107cf78dedcf14da68446c462720b9ffa5a1bfdaa68f5d931e -9966b6bea54405df1dc4edfde9f8c3ed7c0733d5a73bcd8b349035744d5eabbad0d19801a678d48cec84c0335346af33 -a3d0c32b5e3036c4a4b222c13f7db23924bc2b2f724bd908a38db3b8f9c95cf5034c4cda0c5083c0967d34061a216b57 -92ca6b883b2b20015fbb56cac4c4b5ef22e555a9b75f4f020822fba9167eebff8f9fe5c729c574cfa5ac27bae1a83fdd -b72b58d6ddf54c2d37bdc1599ac966c54cb4926c8d2f70d1bd4cdc383c6eec5e4b87efc59466682f8db964d80a4b740a -89ba63ee57a1e6f13d7c66150a8d6721329b385eed92be3ea784eed89c76a1ea88595725612b109a9e4aae41d3f6c972 -8727bb53bb62fb714e4e5de461c6cb298730641e38a0b49b3b3d4a29fa24167c7c6f4ff47f4f3b91e464a581a4181853 -816699bc7c3ed65747d34786b7fca4e35e79907f459f2df0918669adee54a70c03580c4e7d2e410ceb45c71fcadd44e5 -979688c14ce623dd17344e67373e5852bc1d3ea12d37f7b28095e5d578d8c9c646e4b97a3a69a97764ed0a88f62c99c7 -b4539a9eb6578ed3b8dd54cbf57419e99b69c0ae1ca3ae3b4a21f204813b2a78438d6c72f86c13dfa06a0b9244b98688 -a5d957181c30701fe6eabe3e65a53a33dc43df364c45f0c4d882ab88a069024bf04b71015f1c2fbf03f368e63bd82fe9 -b9ce9a54d9b17d4da41ba3135d077c546cf39dc83230506a4ee88cfe39e76f7e35664ff1b571e231054cf1b764b9267f -ae6bf2eec8046137016ba94442a7a0aaed0924ec1558885135fd339d2996aeff31ac29f1de07e84f7b7391fc5355f429 -85c7c247766a4ca44278be81752f4170dcc069f76992b236b40e71e31e08f30de6a5ecaddc44debe4f94151cdd8d735f -a19d41fcac394b750248e575c300b9a96dfc5b3dca07ad6e1d68dd3f8ab94d10aaf8edf500e3fc7774e7ee52935f73ea -b3c959a22fddce5a2e199bc8724e825a6d9776455c033299b5cdc9a9d184be169d807829d5df5e747476d172b5701cca -916aa7bc58f34bb8f32808858cecd3e90ea26c3ec1f80a40e863ba18fe9af6e67c0b2664a2274eca6d36ed72e59a9341 -864d945b7be551926f747406d72057c7a141110f5d269fb6657cf347cfad7178670dd294f6a98c19dc0943a68d7ed45f -b3480f8a42ba0e8eb020c2e1c1284a8a9102fa68b43f6eaf28e031621b9f68bc399899e35a1a283fb52530c8574484a3 -a8cd1cb93974d1a6072ed51f356449ac19b04539517cde34bb7b2ba55949d213ee07d387ce7b5534175bd8a044556ff3 -8e81fcc5fa5579f2479011caaa393f47a4e12828e2e82072736d85ba1bf70ffef9fe3b2c22fd11ce8eaeccdfa2579758 -897f935b4542b9ccf8c0660c8fb1a570a8ba108fe8440e17e6c50e01affc2a8597b7f7cde5244c7026013b52c7331b5d -b9a20f612c74821da05f48d8bcfa7a4a550979e35b49d52031be8bc9cf717fff21db0142b633465c5edafc42b7c73c84 -b88caeb2157d636fe26d3b221143443940427e8722596746bc337679e10ae6e5a9b33c456ac271f8b01db2f5d1b00a62 -b23bbd978725aae647ca2778e801235f605dde17897d4d56914b0d2241eb31f930028904a6555581ad5b2b74ec3c9587 -97a331ffcd02eda1d6e0e15deb110ad6106d3159ea641cfbf424d2e3065bf65c9b14f72a27ff3f576dc51eb068bfb22f -a9317840cd8f437ea97d80a3f445a99eef463a5e2beba3c986da8fa67def4ae9a0e8d1a675a35e5616ee90986366bb70 -8c26dd7451b12c65351d5ede6a00ac7b9316f9e28be8c692d20709c3b4a5dbc76fb914667a2f1e9a654f8d2850b7dc3a -8bf4aa18a988f82dfc54668bd4ad5161f276e31567c949b7857cec331c74c6b68849afe852892816c802736cf7c547c4 -836fd166bb9689520cefd6f23905e4c1260f97167b17534930923107fe934d4afb1216e4b89679a564433dc952a77b0c -94d6a5a4a11f41887eb814acf9b5a031d013d614621642384504eb78e65b6a07c50326632af47b408d8ccf43faf8399a -a213812713128750bbc5311dc317992bfb5124fa067072891f452880183d64d6fdfac8825552cb809178a3f3a641c9b5 -976d1290308868c5e41dd3766447b29ab8c3b72047a0b7de85d3ee5b1e13d522147a02572cc0d1ed8976d411faff5b9a -82a4494a95738ebe56578e1e4c0e486eea66d5cc44141f478bfc5a6b3ebbae6f32063725284df81b438603aa564a2b6e -8a6f4dee79baf71a4a40843437c16b2f304785f3e56b32d9ab2474666fce2c7749c776bd898a65f4a4d542a497cb6d6d -a04a3484be07c2d60f1a90f9dd8d4170270a808cfdb863864377c2515dd71c152920b65fcd5f47004d27d14d7ee7eaf2 -a984f6633ce3d42c75083ef7732e5d0ea15d91e73cf893be3ebac5e56defb8db97088c5cb3acb661e26bbb354ad91ce8 -a5ab5b4b0dab86706d68c9ad921d4917215c4fbcadc8adacef7309c0c853bc3c2ea34b3868d8f03cda6f504793832594 -88f03e55eb028353b70352dbe91f298ade322951ca115972f1207744254fdd01ccf899aa40ca747da8812dda5bd5f985 -a4bab627f7de273f8085169cf05413bc368c5d9e5f58bf10995a8bbd95e511b1ce15d008405728ae8e8a83621efb56f1 -8ed518d0f225b90fe7f01b0fe4c451589390325044f0d18a8c47bf13e24eae8627feb0c9e9514397536f73f33f67a044 -97c73837e77d965f401b4e4f089ef4de7aed1126bef6be4e9002b2b68014b98997213e492f7aabfd2e47cd0917a11d6a -a99e8a55ed0385bd279e11a80255b375f2d59bf8b0879bf2337ab5e3be450a2ec05d1bd8867a633e359a02cece4dc1e4 -82a74b5efaf3c217ee2bb56c9b8e76b3eedfc553c73177e59d982f503a5b0572b5cc0d1292820823307eec956c42b28d -9800ad3e10e8a19d65d5963673c183bd536b65e14ec18dca45e881ff3bc74eac32bef2ef845515ac4fd6caf558a6926b -a2933c78a67cb40489ffb8096c021ca017b99feda1f9c5d702227d7f0a2ff66a539d68a47ad90ffdfb5c31c774946f87 -947b29715258ca20da5b17a8e3d99665b7e599aa5bcdc5d2d7830a2e3cd78364d51a3d7c0d8bce48a1992b27d1ac4980 -86f2e2d3e160d3ff979ca70c456785b4b2437eb64e58adcb78c4aebc96b470f1b8b999a3ce8ce20e3d3f030d163cd138 -958f4435d35932a91eaad0dc476bfc2761a85f336ad2ca6fe0c6830fe54e8f417434616df9e6f07a9454a4403b00b64d -8b1755af961e0f9f59651d56b538ea59af489e859a1c93726cee62649da0e304093d62db9a2c5854c8da1be61bde990b -a5e11042f73f979c8649592f6cd01dafb319344e379a65aa9200d3b636abc569edf822c2bc12b3db5c30b9ee74f2c981 -92ac5584de1adcd38a2ebe361225f224e9b498344521be519faff77f87c1f22fe8e112f9df7cf960b16e358efca0db08 -81db84f05f75a218045d7d5fd4620648bd4a95cf468cbd69787011d615778ba7300b729163e7c8abd1a5b0ea66fffbf7 -ac2f522e9f030a7c576fbe19041f5db3913af58da75b87e8ad64b93bb34850a79b852804dc68ad5e7de66d90878544cb -ade9763d1c7e9f68b5f817cdfeebf31bb3ec1391dad04576c55fbe4bb13cf0d45abced3d51b5512c73b2d0f403906340 -a0b431bdd9641595fe1eb8d96ba4fe86a447a31ccf36cd2f7d94c5c86a7d96bbc95b204fcfe7c69c1385997b1daea3b1 -b3b093bd8fbd84414609ec9a108507f97d7f77833b93b15439423d2a2928e40b192247c8471cdbc12891d83c765cc6e2 -8531a5ce8e0c44e887ebf4beac65352c8a9673c51b6a1edc439e08bda1354d359e1ab2e27b82636c6dc0daa3aade931a -b22c2f3a77ae4813a75004dc2c9593cb2a51c430c559bc7d07d83e95592883b99fbd0f9ad24d2d80d86c871cfaad2721 -8b6dc7d5b8cb6bf36352fb19e42aa37647505436e1442eb1f228b0804916d569643102b2282ef66bc9a4442520521dee -b29a811ab81dba820242a990dc774cd937cd299495cf721cd11971b9f1dd9441ac687dfff0e91656b9764963a56e4625 -805b280e31664008fdd874bc38e870db271027da70fc2246fa82c499742a9a8de1152275e0be61f307dc8f7a918e270c -929f690538a500d238208930b55caa9c489bfd3476f6be2d385c36df3159dc3d8bdeb24a1ffd7b028ff4d881551e2888 -a92bbf103ad851a41e5230e1e37ec7802e08f4610c0db9706806afc4a247679b9525f9a534c70d970a1acb47fec9bcdb -b9f2698a39d6d7aa8aca181fc5d95dec796ed6eec002557d4b63369bd90aa4438c27ab90da4f3ce81168cb42f7400070 -b08703bc97292c56833d8e61105f1431c334f98a7946850c6175f37f703ff790d9a1522c0003f08dd111eeb083235073 -9355141cfadf46f37afb73414c8803f9094b06952c9fccb24a1f8c18a13fa7b1197321b19cb832de3f83ebdf8deee53f -b7c23f7cd8e212108906b7809df90db58d2c2f3a8e1f775274181bd81c74fd7c2f8d68bc7d4aef639ff4e19f86243f98 -92728e009fc3faa08e81c36c268b3ac18627da7618c96c97598b13242286645789c15c99518a07e658d92eb8d2b89c79 -8fbe36d4f2f08cd6245e8999728884c636a264451e4ed894d2116375f3d9eafcaa72ee59cf7923ed8ddacb53cc478761 -a6b2bffd6bf8f54231fabe46ab2c1d014ddaa797d08e5914f13988140bf804019fff3ad07ac2cb31283fc3e74e28d0fb -886387540b5a7acc8b2bd107124bd17d6515697e09c85c4e932a6421965c872f014d11d1ddf321651e4b3564eed4f252 -8b81f3ebc962e9ecd13a11e919d86ce14dd89d373cffa158b807fc91555a4ec1d7164504fb67edd9599b10fac5e32aa5 -91e3213ded5f82e34389408e95d4f7fcd0f50ecbdef9726a289238e4159c6d3cd2f401479a1f785865e91ca213d2f8b3 -99154b88ca5462f62031300177e571708821348e1027cad4867eebe42a6fe92a58ee1dc21da9031002f1b051351b3785 -b5c2b7cfd87f2f65df07b39f8a26dccb16946fef6b89268b9300c8529d730a1469ba565a480d7c5ae9df8600ac50e90d -87df32def37370bf8c4c3a22a670bf5605c78f240eccf8dba13bf19c8a3a9d0560f8899259c4e51c6b0fa64d7d1e4c76 -980a20e5cd352786bffeca1b8a31930d8898eff9f4a6b2570829248410bbe1c78105b6a61cce7e3ed1642e5e2af127e9 -b18b8dbb9eda5cf333ea29fad7734235ac9e7234b49fd04f178136b15d97595d5b415a92455a319ab594b81200cb17d5 -b713a71be9bd22ef6a2747d0bc8f4d008cdf6182e287c1e0274689e915a68150d6083268188c1f4a7fc76d21a219ec85 -b86ff129a981359972bb793a81fd422e0b37f89e76fea70da012fad160b9eb7b029ced81c7e34679f6897a45b4e8da4e -a74a4cb9707156e21caa20b95a2a4b4eae8f773cf679e2073fca2cd3b1e502ef06de8a3c010833d525a7f8bb6bd24601 -b51f06da38a76c2728cd01f6073f402fc49cf4bc5c60113a2700b5bb0ca500e465e541c467013a2804bd7641604bd2d4 -9855dd73307d8671b6f9ebcf676de3ab7e37e7ac1544447c7ff34a213da46123b57ce23bb0f381da8fdefbcbe6c35645 -8fb382c63f4c935462d013a0d3e2321d72fb4781c10afe6e31ac51766832218a05addc6dbb1f644aa61b5da9bccfd5ae -855dcff23e0ebbaa3562fd27c43957cfb35d492837aa71f27cfd1bf65a59a12d2beded9d09f3ddb4f801aca8cc34d2af -b7e7b317f10cdd13bc879c2fb0bfcd137af23e0cb70917e48d53b2bcf8c157ed7e5f58cdb966383ece9d3a4c92012746 -80d2f84c39422afcb449aa68b34fa9d72e9de79a473c3ea5897f6f3576d2bb6fa2d49f0b44aebe5e68b11e85e066e028 -a35b083749f8a5551f0dcf529e845aee189cdcc6ba779f4e88765adc49cc4779cdc2290598908ccedd8dccfdce29d53f -a30c412f4bbc2de80fe5c577b4f94442255cb3061a40649b0ee5357977503c6fe54821ecc8cc92d5056b6977c4695e70 -a2ed0d90ab612fa3526f7450a43d45a2d9e886f2e5888ccb8405adeb8ca3e41c6a94d18a54b3cb1eab5b8f3851841ebf -8d4dd3f8f8a3d69bb217d338e757c814eb69e6a776f55cf51fa7c1b2f1ce5f8e9bce8353dd335e793d68eef676cf7c36 -880d1ca33d5d3bb47b788a7ec64b9130752610816facec99af53b6e58a7e414616e9c815b1bad870d426380085f6b5cd -a287578293da4354f2c3c46d637aa77b91526f9618799dec4bc602305ffd8336d373786eb67eef01dbaab88f07f292c6 -a86d3fad257a64c84954a7530822346da0215ebf4ad9c583f35cdbe16a02fd70d58ab34c93681fbf55d6075db6425cbc -a7bd884d343a6bde5f6c2512d81ba701fae7afa6389389e4776eacc0698a54c3ab1a0e1652c1a7a23d3a1d2a63cde8c6 -8e0653c8b7279d5c958ab1b53dd77b73fd30d9781630a870d0a75681d38cde4fb7c2183b9c5758596ac556578b43fef3 -b76a00c6f5093e7b28703df85bf968dffb70c455c91e75cc81189598df052244f7549d18e45dc70d98d3d86e0094ab2a -b270f2ad3dbc8b43ee2603c4e641be76820f07a4757cfa96be2be9c310b7e39b574572103253594a51fa9243298cbd94 -977b8b86841ab8be7d1d50da7369e2bf71f24360aab8448d7748d59e010ce81bfe79530ee6f6644b987fc0d83df3ed15 -8e18bc59841b7d56f8d9eff8818eee06288cd6ca86200eee7b5e6b230070debaf254a2198b4cd7dfbda8a1d55a916c8f -8e7a328ada969ed6289972b7f43eb5958d23688603ee6d118b6ccd8978378dce2d733ff64c30519b19007a78340fafa9 -98a0fea70a219292584c69546d6d242cebb2f1d84f69c5aa275a257a87de652e721078b983ed67410e3a5eb0cfbb2bdb -a09fbecfd05772a9989008281a9585accba3850831485802f042413da533b1c7ee45a8cc679804340bd9142b2f9e0069 -99890a6b273a2787fcfdd8e8500134efd60df99410e8432664a3e5325e55e78942f4bb11024c90e4c3618a70729a277b -a5f3eb1617a77f2d5c76bbd1bc3546ad1628be90fafa9a8b62c605d04e599ab2eb74b25afe0e68fd020daf4868dadcfb -8b53517d93f42b833f7669c131dc67f14c3b0639c46d3b02bfdb24cc9e642133e0c665236a7ba851c100ca733d673341 -849fd288217bdb154213e79abe1a78672903e15429e37f6846019986e1cc8dd2b3ed28e4cb52dee1762a4dddb9ca95de -954d839198c3dd2ea1ffddf98050e2c52ee81b89f38d967bd30c6863672e43bfc32e1030bb12f5aa424983bfa31dbf5b -b52fe86414a98d0896d7a427d57739da35cac4ee24be565956d15a5c1cf5b4b95e5425dd2607fb9f6d6024549b59a4ec -9586070415a6bf1e11304d2819330eda88e81a88b9347aa866692c163e1af772be9fb747d9281d7aabaf5c9934596934 -a5b78e5bea362df26a89df682df61287763ca1b87ab9618609c99e52e6ba047fba7ec828c0552ee26279aa8a48751334 -aabf36b9dd465ae03551dc82bed9cbf1d22a2236ded28964334f7ad474f317f4fb8515b853354bc06181fc9af82714a4 -910f0b2efc608cae8cdd39df7a5ef9e570592b31df2331baa7721708057188ae96e1b43e2f2f2c8cb360b961d687b60f -a5c5b131205c21ca68d6103f8499279621da337a743e4a08547c3b4507d52d2d6e5014fa5d920b351a6f53a195687766 -a6898dac2d8748b8bae155a7d8c169e7eded73cace1e382c4dae8633f19463151399c5cf877f8ba344a698a98228864e -92919d8be671b4f490efb49bae145f419c84a1e81d3ef78761fa326f67d749ff3530f5de04f984a018065f42e852e1e3 -81083de978e025f0b5995550fa17915d02489344cabf8a79248352d78dd6e893d28a5c5204a65a8873756a34ee3c0120 -a6de92ecef84d188cefe29a03b564b1e7bef2a6afd785b58897f7f97a958573a35aa0767bef12a49b352de30b4f0dc18 -985cb3475c7a9f582c11784cf61a1988240d74e49084a4c0f55f3f6068c4da0b08b136f8fa62e9001e0a265bf65fa3d4 -97e6d360b504991d51119a78c5b647f25d5fcc1298631209d82c2ca40ead0380835fe3cbf8b82148b0b01b8157e884e8 -b313df44b2c47126b58064599a0dd6ea49e5ace9ffa663de03ad30c1e95301cc68eed67d37ae6238469e45124c59bd39 -8a58f70545db2242cbdbb12492cc11ec4d2b2ab0ed8450d21ceb573558d7bda91ab03c98736e13d041bcab84fd8248b9 -9077880ac352a5ab0e5e15ac89b14d173cda0b41b6f7fa66bb357195f10cfcf491fad6bdb49d71cc20d99cc6c8e28d04 -a09b2930fb3b1a60af8c5214e8c3f6deecb3fd3d0a5662f3885948f48d1836b5ad3dc74affc54dbeb5b522b90a17dc4d -9163bd2e5f58fb1d81007422b91147685542fb1c7e2c8421af284c7cbfdcd2d2b399a37123b58a2a349f27b31bfa47ab -8a3d859f141457f9d63818634f81deb5c858ac48bfbf2e1da21f4f0dcd66b3e1d2d8fe99c4cad38206b1e15dad94934d -86d3fec476b59782d0477ff333fa79922fb9fe3d6d6b6c5be9da9e88b006b46b2a0f8f86ba4159c5085e66e32fba67a3 -8041cd57335bcdddd37651de2c3e92edc600ac23041d0e383baf55651b1b0960b6a601491608307160f0d7d48ce395f9 -805c284059f8c03b2bf006b1af95ef726874c5548e93ea965b402931f42b189f9f674b6b52ff09df35320085172973c5 -8acf781a0b40cc56b1013cc1fc3bc43036545ce35591f3b905543c09cb1ac1a70a074202b6d5ce3680be913200c58879 -ae670c448996156c80d063f1dfb03d7770201a35c71cf8e70b38d52dcb5e2bf73d5286d63ba2f561525d62cd67d43125 -b0fcd0150fc0005ca438d6b0fdd6a70b121d35ecd74e62bc119bb0187cdf6bf674ce9fe01eeac5d46a68ff4d4210ad09 -b752c6850985ab13a057028887bc84674697c012e9da0265dd5ce1e48f0aeddce5e07e3e7cb68ae17a648cd1207eef19 -a6a5c71915a980fd0225847b45e2e9f3731c6b2a627cefb1e2c6a0cd7f1d0555dd32b6b601a7ae9cfc4b9d06a56a578a -b7d96f59a988a7a810c25018f7f85cd6e81b335a84504ec76c97d7257f9cbfe88215ec89553f0dbf39507d990b3a7f84 -a7cea7b3ba43cf6ecc488c34511b17fc7b97150b2d265785c09c676ad3123b322db32e043c5961384ed6d90d20c63061 -809dc467b304e9bda732cd92b15c0f9b363cc707432788971508b8d60844911ed4edfca96d8cc20b9874f1e38a2d1685 -a5b6a089e022fe460d62c4c5228e1381902c9a796ad92c03211c855541a7fe27c5a39d9123b001b0b892ffdf0a1fa065 -95d67a21154a49bcdc79ed5f2773b651c81fba1ad82bd373239f09a67a50371a147310623fcbc1211ac57aa154e8b300 -a4a4f0ca8073407575dfd5d04ebf76f8bb467598824f2ce7fa74756803d9645d63c9eb3ed39aa202dabafa4ff0a0bf34 -8a77374f6e449d94a443f2d4593a0c3e4925527e0653e873dc20756396a9a4e5696fe44fc1b49e456711259deeb3f037 -82585a825011d6eefa85cd530685b103862aa0777510d22942d8f77a0a7f489f5d10e5b36ee38f66cc96dc57d13f5893 -98e24625c31d5d97c789eacb91c3d51cc6edb38cedcc474deee459f55de557c42e4d0754ca4ce472d0123638eeafb55b -ad4351c76d96c35ee37362f2384ffb809bf6a47213863330aeac1ff9be2c6cc7275f0f974e46bfb716a89ce1bdbd0710 -afc8f5af4f9c38ae672d20e7bc3796aba23a41eb033619b4c0a06e07884e1e0c7a7326f069068dd22e69fa5f672efece -983d5af05af31f9082f381378fca3526f88309bbe51d0cea5860813bb0fcf6b32a3be110336bd728952dcd6ff8a26361 -ad3b55b67b64b188447a1fb10d027bf7f86ce0a0fac966d709e8b6ccdbb7333964045f0c4719c45c36b7f3c9ff73944b -b410fde230d8dd24b9f1bdbce8338b05110b130591913f23a34c5fd092cdd3f747c383f6967cdb529ade1a264a3ece39 -b3e4f0a046f93c332be07058db00c5182a498987759315bcc3a58d9334e09a59333031c3144b59d03596925703491cd6 -b77e58619c8c471531d9b2e5dce8f82bb8794223bc9459599a911440e64e0b5be1d37e289807733ddbc2858bded1c34c -b450945bc3e290df96a196083a45aa929ee080bf45112e678eac0a939db2ba67334ef782c855b9b354caccd94b3babb4 -9794d81e968770a6e12add60b32ccbbe80cb2680b157d125461cc3db998691e836d98cb3b3cfff4f156b2800d426b955 -98d1284b4c035e93b4ea0431884d91d5a7855ac6c5b1ea2a994e653cf77f0ac1a771dc75899bd1485066da17e40ee341 -b1da89b14efc14d15b2bc967ffab85c41dc447b6a7922b619b5d5b06dcda725bc4530959b70355ee20eee7c1802601b9 -b8e50ae98515dbd9ccaf27192e58a5c34def86b1d0d181e63e64439107c30254267969f6069e0b863c254440c3480de3 -915f0c7dc95f630bf1114b02e7d9936b0911a69c932950ecb7f800cb1aa1a4e1f1b6bef6ff4a23301cfd904c39025863 -85392fe0edd316031c69d90b106b6685bed56a0d8d814db2cd5d77d07b18fadb632694a214a176ef60aa0f82ea14b00e -ae4cdff23859b7570179586549165c728de4ca254a5da29668cfda259d43a387b3caea8537888d43f713d458da6bd4e8 -aa0b6a3e0555d64a5cd1201fdff7ba7ff3019e9ada1d86c90c626a710df3d97d2ed62d2b63e5632963e09cfbedf83732 -add726d97dcff922dfd748eb897e540a2b4b8bdbb4eac1feb74717bf086b1760a957f83586a57b5345bf4c73d791ab9e -9721889b6fd55cf9a914e5aeefdfbfb94d379c6312001ba50ec4bb1dcd03f95fdb45041330da8871cf3dc3c6a6b5e330 -8eb9417573ec6af24a610da5260639efcdfc802a95aba8efa829dd70ff179dec061da9facac95b6af02cba6a8646f7bb -a477ad7d2885e1f081556a98b3904cd75a4ac7a8c27fb0ccf15d117feca59f891a677fb4ff4fbf38203055a9436ebd1d -95b3b2ff92e8a0bace130d165984966637a74280d0e056cebdefa6f825b1d55c9bc6e13cc8f263e657dba3dc7fa68627 -b096fc33c038b425a7a922a4274d01eb366a488fc969497a575587ada74b9452a607992aa2d8b9de66705fe20b4abb39 -a813ef1053ea6ae8a37f4da722f16b6ad0213b0ec7829998362292aef68c28357ee27a406b567a629592447db8ea6085 -84248425c3201ed389fa1b64b9e1d151b5a6f5fcb8f5e28ebd665db57156ecf9b2fa77bca857200df9f54383b7c5eae5 -86d0a3c7fa1e64111115469ed0373dc3dbd448e1098250e9e8c5c7e775fd1f267d49b4123c347af07a28e686d5f357fa -8340b2ef4fc2afab3a3d51b6c0361cef4aec3d5e1d0f779f9fcb258711cb79ba4083508644e2bd182fb25b21523557c1 -b840749c259b5af5874750853b4de6f4d7a274e18fb77f774f5f454c82efc5979a431e28bc8e43bb831715c7fda96db4 -b168d333cf20b053c1b2a915c3485200a7590c3c3661507990390800fb95d3772ec6815d53aec5e2964eaec19833e787 -8f1bb538dd5005384f38f88cd2588228aeb0c6313aede14ccc12affa9715cdb938ed4573c391572f0a7ba6e33a1ace89 -ae4a8ec2eb938eec00e6608c087471128b14a773d75a99634671f6fed95f7b24b14f04b3271d1c32faff7f0f2d98547c -a4ad66552924a6831b657f8b318f303225b2cf29b09790a48285b028bb1420c56dfa2ca0df2e823f694e8e3b27952a01 -8af4eed962eeff534234d7c34f1033c68e8cf798c99880a67eabf38b533570a3776399b883f8658265cd14277b060790 -ab2c6406132413cba89a951d919bbe123fe4f220364ec2282d8ee0c140ad8d48ded0df7ab56f8f18ec7526ea2f1cbbd4 -9154df8800e26020155b98f630e640be97a3ac41b182fcdbcf31a3e4f233810e34e224c97df8ef0f39ccca29a9921fb5 -8f306dfc5b8376a88a104cdf67eab54f93e478ca09036eb780050ba2e8112b400bcc09d49665ab37d21b5a2d8440b3c8 -b768260e94bbabaa527b2af8be423577cec3bf4aec3c569a4fb69e1fb997a2157c59f1169065d24a8aa3625d89d988fd -af06139ca7d240f2495314d941890c078d504b2bc09d98a6156c373de29781e7581f33adfc738650cad0da3f6e07af88 -849a6e458ab2f4101167cbf75bf47ec1f9e481f556b1b9d297a6b4737584011d7881695bbf3ba31e3e4180696fff6407 -b107e7aff27aa19a4a92d1a65679bf40e85ac6f08d4e5f14859d97c170ceb431858fa4c46d00131527c605164b5f7bfd -a00666055e18f34ce02e8b67b6f181327ec0a11547c0795bee61802aabef9a3a76ea138b905cebcff9c4c86391763e6c -a65cd8dec5166949696dcccf031c300895c5fdd53709a1897c61d795dc22bae2f7717e7ae52a9950f9d00471ba6257e7 -8b49aeac3550ef28b5de37576a5d4e2e43bcce82de09f491984171251e26c27fd0a884daa6f3d30dda107dde4544b34f -91666b88be09799c7de9a5d9a9d4c1bc1b6fbc44c664adb15a2eb27229be910226514c2ce22818fd38b850c89291a7fb -85abf4084c735b20333b1c2145571b793f96188850bae161160b47dea7c48b0f588adcbe9cf80e05d17851cfe3400f1d -aedaee73c52d71d7ac3854fa41199615ecf49cb0c35d8203f95175d1ddf565499a8e9cb8d31d89e7cd9cb75a9fb56f9d -9413589f0746d3b81e2f88b280e354fbd63ac164369dec353e6259a2c4acc6bbcc10f2a851901f39f90da7e523d77848 -826121abbcefe3ad431c713a1a2cef336a0f06f69980a14d0a8adae5640e9aeebf4eb82be4621165ba32ce5e16de4880 -adbff68221279985891e9f3fdb7b1dc71db3e20213b7c8e1931e6f75c6f02e7a1f6f05ec0687885de55ac85440f372ae -99ce8b064f874cf028e85281bbfa43145893f80a8b12813d047bedbf88699266652de6ae9e4ef9ce575e67065854fdb4 -a809a71a663b0a9719c0327d33215b63c6ebb12da3477da8534d7e8f79fb81e06adfdad79686e40efb2c75abde559a34 -b26c4cd057118f9b12c9b86e77d370b3fdbf2654a5d80a7763ae98c68cc2769a7cb293ea89b3a08250c2f699b8d76e22 -867c56da9a2ed672f47924cce82c9d7e801d6a1fd18cdfdbbe07c82091c70ba0ebc6008b0b9d505632a97aa23c45b8c2 -8cf14633888f2ba0b02fc8ca7536f39fa290678c7e0840c58c53a9d2fe10628be343a86acd74b2fc01b0c03af0996f59 -86696802e4f27928dd6b0287d0188f8067283496d154060383c5ee295a468df32a2e8e24648d93ba868120ac429b68cc -b15439762d0f7b6c98e6946b3c0a7ea0521845fc68b47fe9c673194d81a6cb375c79b0122e81a027f21a7fa4cd6bbf56 -b1bc19c9a3756098c02bfe36429c0f0d8166a5c9274edc7f80ce65ae7d6c67864a457f19cfde6924d204b81f2a195fe6 -997f1cc78d707f29e3eea0952b5514b34c2cf0720f33a3244cc466df62b13031bea13df2296270eed42b3667c53d6c26 -94f599c9995caffc9b47543b822dd8f84f921fe2a31e82d5d0fc79dd93a4da0b87a0906b82fe7c2a8c23c7829c21dc2d -a7fc8a6ed802660bcc07d3ca454c415da18d798719dc2688eeafeb8971910377ce909de68721fd97c4d9fe439f37a8d7 -ab16f93e6df2464018be01fe040fea08c67e0b032fe1950fa37c7593c8ecbca24dcf0fdb9e1209d5b0def622f3f6e92d -aeaf19b49843e3fac538075dccbb29a63d55d12f8c4150185b1ae62de778c983632542eb495808ba629cd4cbd629e07e -85614d537efaee823452d0427ea3a2f7d5a3c988b10cf7adef8715becaa519a9b5174b63e401946362176dc0d65667d4 -aa08d8365e78efc1919cbbe562be7b28c57eb05c36e8da89378cfcad9f21e134eed923559530aa3f62bec758b00c70ff -b4c2760454170276885d66f03e9fc4e6a4254547b04fea3c233c11dfbf71ab05dd755b9697b442ec419aca000152f2a8 -b814059b189c0ed46f9dab604fca25d881a12fdfaf834a75cc2c0e1d8454ce0ed9f2a79b34bc5e27004903a48c6ace90 -847707b0aeb4fe91c12ea8570cf0d16caece8946951360433c8a375a69fa4c01136172ff2acab6d5164ff6d3b5340858 -a7a9304ecc5ff6fdaaba6e774556bcd7c5dfe8ee7580a677301dece55c6a8564e7c64b60fc4efe89ff73954f3c3f5b0f -a1a86fc5648edd58cc7eb61cc30c62edb5314caca5551ffedf088fc9c1b92ec5b487f670c5bcd2127067e8fd5faff03c -9086a31715283fd525034d59d4ba3465d6c30059b967b1eeb7d537f3bf8caf6879481ada2849167e997212f3300f8ff3 -99c11903cebf722e1cfd63a46b0ae93312439ff2f014b6653fc61927ba430c432b4955b30b7f078c340f5aad4ae24313 -934b7a8b7bcf0108ed31d35a645d73f661c064a6fc6a5d1ad417ccf1b8864623b0cfb54707f10baa86643afb5c5ec980 -89d5a69ae8cc18ad77995ae92d30236d5a5ef00cc63274e318d18abcf9d936453d18a8e6392b52d2d66b51c18d904d6f -ad2448cea1948f0a4915ab054273bdae33a08c494203d11f46888f852d0abefa310b50367c80cacfb602cbc249b31a71 -807274fbe6f08c332a5d2e2ae12cfabccfb53511b8d83bdc875856cf15ab52c2d01cf706c9be428307ea62fbfd67f87a -b2f4fee9f32c0ea7fae306605b62d983b130e4d423e2de286bf9f4343b79e5c4545214250cd1348402d8278140c61c00 -8a36f79ab3ee0063098a39382061ec3e1234e67087b9519d0b762aa9cad54a7e0bd5d24e2b0a57a690993e3182f3e83c -86668e6743a7b6d1ee62e70e6031fc8639ecffed38afdb1afb41d64ec402a308fe0438a22387d9b0c130ed301c39acb4 -b816309d1730cb39b1ab00c5333c6962fd5f5d8b22f3c3ba987b1e0a0065334d206141dcf0e68eba717a4eea533aa6f0 -8754e190b8f751aaf9f8e7076d21bd31db8d9ebbee6b26517b190f624b3a892050312cee9d73cf3d7245446c6a376437 -87826589ac28f442c608faeaf3d63ff057af7724f9d412d1f2cce8c58fad0adde325aa496c6e4e8441775c02d8a74c2c -af30e5e32fcb17226edc54030f1eff8af619c207cd9e42a2ded7f15cd29fe52f140901f0925ebe4e997b56f34d3f406a -a62a4e5b6591d336744481a0797eb23ccd0f580d04cfacbb3e415ae3f273761042b8901b0312f93a6eafc42a50f81cc6 -968a9ccc95e8c124f4475c348a33ad2a52a42e191a93bab3d7f0d211df999aa081efa935391a8289cdc4a5a8f7433822 -93350cd99ab7d3e51756eb01c89172cb406c1debd3f0001d2fa8a01018be5609d73df671e1ff43e612ddbfe7076d9ecb -8df26dbc565ea7e758ce4c2656b65c1f0396761c9360d7092d12c121d3bc1c293ed28d82f1057f4eb5375b15443e9258 -80a0dc22fb4a12b06cf05ce39f76537eb3db9691ca466ca89b2585237c03d13fe3fcd311ce2b3dbd1b7382044b803782 -818b79cab08e11dff3d55bb0f55333f6340c5b462609d43334c14fd878b0f310b77c542c74d3674a94c692de704e88a9 -ad1bda19b1bc3f6d757fe4d189ca82bdcd0a9c1ef509c43e3f49700f84be33bb9b8b8e70f7a09bc6bc00a78cad0cf9e0 -a22ab44c676ba2b3889341fb137dfa14cfc5491ce4c3c1fbe2cb7103fdf720ff2b77806a40109dea9a68d8f072e1c167 -8eba6af1659b6145676d3663b04ebe58c199a1c24837ac4969793f07ed97165d20bb0410421e561cb9283faafd9eb51c -81b216cf08a29dfc3e16b2865e712e15f494b914cb24526a96799a3078f200a3fd403767119732ca4de07203b479ce8c -a023ac601c8e0c22553068ce4a7b8361b0b37bef5705fa68a71c3cfa80510041cef3640bec2cdb4f317904521e99443e -aaaab84c8aea75303fec31694114b3ee10fc1a67357cdd675ac9d0e33c3279e3117d389e9ab017882d517131b14e6088 -8bf9a44b3df3d7e0c776e7ea5eb76f16f1870960f32e7c5b63aee9b432a0adeebbd378c574ed60e15a3abadb409376f4 -a93faee621d930f336f4fd952954ffcbdb261c9dcc4e60cb848362223374010c555a73c0563e7933d1596b0526bf75cb -88753d0e35e87f7572f2012a40bb757364af5cf6e5dc0dfd16d082e698d3fedfab3c671bd58edbf11cedca247e9fa55a -b7de5f03681634991d2aa8a0ffdafd223b1a0d1ff70fbd9c00d03f228c6772d93c388c02045461d51326483af97bca37 -81f96d4fbef3cf00da423a1c48ab8acc222016c21f6be3df778342c1d1aa1a420faa8ce906bfcdf955be045efa4b447e -8dc75ec37122afaf0aafdbea333291ebb735792b4d5934fd16bf28b536fa759dd851e1de448c3efac3d2b0097e0b349c -9186f66655fc1c551d0233b761c6982a3b8539085ca9a2baebb826091e179026b90f7ba6a825f38c6a09b190a31bace1 -a1cf319c9ed31ffdb2108b684bc21cb495e77c853e6c502e03f2ea08e88a0c2b4e31958004d9879242df420b628acd8f -b3d3e5a75c34640bb2fbc7b62f8aced8dcb4b9b165992717fdffdf765bfc81fb4e67f3e737e6f70f24d3c24812ec0ed2 -86ee6ce0480f73cc89ce7959b4af52351317cb6406cc368e889472ee5567e8a98560dc1f13b87442c9a8c5d6b31fc446 -9478256948d960e3148acec3487da232fc2ae6818ac2c6eba491adf130c55badfe83f9a519379fc5ed0b63366de86a02 -898a8130718ac6f98ef673fa8b725af6012ef28be3f2320359a5c2c40e479969e5926f1864624ebec10f27594b24f618 -906f45d4ec3f647d0c49deb95884629a04fa65cf91a075bcde67940634cdc98f76fea8717fc1e714ecebb337e9fd6998 -874c5a55bca05fe52a5d1743b8254b642431b720eaa74f73b0faacff2225f448ef94e12585b2d3bcf12c140ee3e81510 -96f76cf34b14263a30df2135131dea00074f2ee853677b94fc32e04cd9872424dd93b32c55026b89c18bdb4e58bfd19d -b62e2ebd543f3e9a11b72f45275cadf77b1033713625c7374c4d2284d63acaeb64977fd2fdc90145066146c311a68737 -b1759d3b667af9f15da8d4e77440fba4193d0db159a0bf73df32215b2d292bfed7cbaf41c07c7a94ae1f04bab23cefb6 -88423607f005af97b5f8131bdb1fd6d7cdfc4c2da4a4a14bb818b3ecf50c2ae6d3b8cf55e23632354537f5c0dcb0f48a -8ba63acf22ffc1576935467af19f555a0c27a4b56e5bf752163038f0010fbdbff8a2131124f4cf36a326dfc188740e77 -8b1996a0cdac9c6d896111671ac4dfa84a3a3738c43db6d6788f1a7b8ccd6df16a31606db00cf0107eedab28af05cd7c -912a604a97457a6b46d48731fb44dbaca26e7cc70a4628dcf553b43a9efddc4e5fb040a1b89e31902888a7cbbf709333 -86eaf5b2fa873bb56b94eb7fc823527ae50364c1bce87e36fc13de149f1fc937af858a25cc477277dc6eddbf9efd5480 -a0169e6e915e7216b83b00b31eeda207a02c9db6825b5ea44134368eae5bd009b7c95005c621e0d258c33c59085cb66c -8c8ac664946b5e69b4e34ffaa486b745ac8afc8ac702e4a4cc36c59f420a81b31ebf8b875b1f572dad8e4ef1f547a1af -aa6fd75ca832fe60eda078fc81a1a529364cfa8a4b4fac071d89e33cdbafa7d88ff3df611720b48e6fcdca2e3eeea0da -8d30857ada34991ce6faa82b4326bc353691ca32aa25511cf3d52cebefb262d6db8d93521020a2d11b3ea085287ad54d -b78bd8ea8bd6a2fd5741228502b9777177039ac8f033071c82ae11fed7f0a51d8bc64fa9aee44df25eb4b3822d571144 -90904aeb1a99c4818ef21498a583848f4d1ee9253d70c10b03ed7d669b587f8712fd26d4409f00fafc3e26b5d72b4c5e -87cc8ebf78ff2ad752843792e11aeddbfdc628e03e13e0db598e08b496313f463f481f3a17ec889a3acfd128fb89aa81 -b4fd122c4830f339fc019da6372286d3a0565ac04d4f5ac4f28b2c066ed507316e1b7beb7b552f60060825977a2db9c5 -86e709d48d03738ca97d6140f13effa03137570c43ef00469eb0310909f66061d9fb933fbcf30bf04f13839e36d45a4d -b4a595cdd219aff5b8d0f80b679e58d9a7ab9cc389b47784484704e7d2c5249981b2b86be4c37ccb11b9afbcc8070214 -97c6bf26c8b28b982b7a56ff867b2f5785b37260b90e0ae680920f368478a3c88f4a47bc394c07bbe88fa1aa1776f255 -aa48418728684c9a10992d1851b69e54529dbc3548fe46721758ac6b33f82254d56738b351d146268fcc56a9b7f05df5 -962a282caf6f08a63aaaf7ed2146dd61d527144f3fdacf1beef36b34356df50302330598b8602f1447f6beb4439a1048 -b55d325499ce03c9b1c35e6aea30622841aff2a2c225276d677338579ce83177c0d64d78e7d11eac657a30648ef702c3 -8a91b9296e5633b3b9144f61e5436654cffaf04623a864ccbcdd21c8f981618a908e890f61c74df19ce5b6995bc358c2 -a7b6b32333377df24c0b0194393a1487a72a8783e06b1cd00ce6bc39337b34ff58ace57c8dee5b7f0ea2c9a54048a61f -97db4494e4208c9f297b484cb8159e8f600c61a44e1d878b07d29f0406fd32a0c12ebccd42ee7ac4c0bf33ff54a582e8 -8697bc039265f7b6e73c133823dcac9041d18634c68fe16412b4af41286a4164dc86f7e71ab7a493223a84e185cb6f1b -b18a66cf37f93ca0189201811e7de02ee029445132f0fd4209e5efbcef46ba6a28aaaee42b30cc7e97a25b08f4bbb43d -8b69f189f3cfc34cc3968a07e13d1cab0f5c7e093027a9fac38504acdf12e2defced4261a686a2fc850336187e017957 -96afba402124d9ff7048200acf329ccb4e35dabcd609e62d04d25140729e110a674849037e4b8aedfc99c889b132cfab -b75a809fa3b1c17139962bc22ddfce47d38d017d585a4e76ae1eb8f02849551ff7bdae178cb4546067bbab45b7041ddd -89196f1fe0869f2fd18f5c01118853503d71c4073aed8bd9cfaf694ca4a9e87974a9ad6e37449bafd391a2045ef5cd2b -ae52921b5d8eb5df7d4923aed1afb125cb98aa6606f8cbc2129cfee56ba3cdb7225a30d98ca9271cca67fe39c763d508 -99f1cfd27833fb64905f8678a532aa984329b2369ade3860025ad334131a9550214297bb2f7d3569eed7a9cc558a5922 -a77fabcb76e8c6ac2a5196666e0c75c7f6c73fd8a0a5fca32a454a9457870689c83f5821f90f28dfd91abc3bc62ee761 -92a4b97b7c14ec14c74e06363b0ab2e263d0d7d84125e2cfbf659bbee996a4d8561992e19789e507f4c24e5afbb91b2d -a2387e7857600a93de57faa0484650289c7553b9ae5fb001d011f43e5bf31c010c9c8b5bb82e7000465b546236e79066 -8641b6f2dbe9f0b83e0a7ad8098b0836af158fa2ee6ff1bcdf3e2ac8b3d25d2e5a24d515e9d549feab4e82b49e468fa3 -937306770a47ab2d5d2eec4bd6d9b3a8ffbb8c8067504571609a7e7a85c665b34ad2662701b67858e01530907172768f -b6b1b89f261e56b0cee15e2f5284c76789db26a6ca4762500745e260bda40b00b65add4826be6131775202c8c6c4247d -b1caac20a1b2aeaf287d38d42987e2c381e74495d9e880eda3ff59821d5974d01c7e3c611f4773a13ff41bef0f2ad44c -81ef049b849d7b0a732579299a86f1cfeb85f27ecee4280066dedf6024159fd47f311f1ebc46b58f63f71735a05480c9 -b3b6b657e64fc154eb33b6056b8279ef736839b56f2c8f8ca438cdaceeb5398b8d3625676cd393c196f664d7baa3a615 -a450678001e8db1ebd8fbd5c808c99945bb3549e834a346cdff316ef8d3b49b818cf9642e5b8097181cf40583ce901b0 -af3edcbfae3c8f368958cd11c95df4682ed10f894f770783e967fac1eed533ac427c1d4eee51f968ffdef080593ca262 -8348eee6ec1102884929736d6768477029961c3d6d09e9ebf84d2fbe55c0501165f274fc1c0549ab831388d431e051ef -8d799492659dc44aa38262f8a4ae37b6ba6eb10dd20481f652a1c77ee9a4529efe042ea873c13bb2ba3ec4792b167c14 -b4d3962f574c3298ffb0958ac999367db8207dacf2ca9d563cc1efb42fc889e19b7f00db15ffa91d145ff05eed97c3bf -a3a7c0e45dc8ae816d8765bbf097502b56651c0c11a03f476e362b64ddaee223128defbcec5629f4d7f1f9c3e4cb9f2f -951036c2878582d84d90dff79ecaca673df4760fbf9e09e63d35facf3e3257be6e1bd504f3c3daf8ac1e91d306e80d6a -8ae85094b13d349e60c8f303550cf4b01e96e24fa3a9f12d44c9822c004f1b3e9cbd772a2b4699e54023176074778993 -a7292b61d2667d74cf62a47aeb559499f19dfab2a9f41f16e7b8d6e77909457eb2aeefadd9d3d3f6db18a438ae53ea0d -804310f5d2ce8bcf9095945f931eecff79f999ffdd24abb9e91d92f6e405decccffe4a8d9e731c4553de79baf7a5dd98 -a77d3af0fb79b6f5b6cb640d04f4e13a28f8aaad1f60e732b88f86de547b33117386636d1afc7bfb7bd1d4e527812365 -a431f239ffc68f6b1ea13bbd45675f0323cacb279e11a14f664acbb15d1673b99cf3603b335a100a0e297c305d743383 -a64f4c28cc36b86dca65359cfdb50ed3dcc06fdb22ad567c7e0f833c880e76a53c330720fc2b96235cb0638394bae41e -b6fcd2c047de58003e9af3a416a2cdb143899441d82c691fa46d89045a12d3b087ee4603b401287a0f2629154bfc9bdc -a06e3b863bd183d8f91dea6d0211913663b3924f1e3476cfe0f328ff7c388aeb8e5c97757bcb56992c104ce0ab6ff27c -aea78204081cf5d24162686a824ff8e72fc0f88388525d646af7739265f60695b7d80b53cd1ddfd046bfcf59aa25f5cb -a89f556d42541a655864adcc1d5d67459ab488143e1b4eb48c67af30a8e753541fbcb479558ac26e1fa498f74a59025e -afc385b6b08c355a05fdc75e9360f4ffb384fcd74e8c9db34bbae9e0c67e0d1fa7efbff4160b387428ed58e129fcc027 -9428d05e17e5525fae515e1ba3f04742fad1a43baa2ee166d2f9431dabb46895b7345ad833d495c99939f0c57cbaf1c3 -b7a62d36ae55e681d48c911e1a433b568871c65a97916f939bfd638a054d6f1136a78c96640779ce1e3afcf90e3bb23f -a45b6d24930d91fc610e57ee78c6dc7557cb2ad976cb92e2157769447cd7c9a6a040f1008be9eb5dda2a7b8c9e524774 -8b24eddad804790df3ed82db7c0ba05082c61a81763c44c98ad436dcc7e1e89a2800ff9c2deaf350f6222cf4278fdf9b -895409dc0aba4d29ff322d2414b33c1458126c023a3d53b25b9038bb90372b7c20d3e9f6b791fcf8f76449fa0aafa758 -b22767ed218b575f397ad8306ec48fe07e8dc3a9f2f090fbaee411b6ba673a1258785d61adcba007d748cb019c458fd3 -ad4b9e4164010c4ba05a23f9a46957c8625fd4281a4e76f76ef7b4d6040d2228dbd2e6faf22b4a966ab42f32467a4655 -92340f1051f88c25a915d0504c1413146f37f709ab060e3859b14aff9be7f8c91352dcc3fc866910a84192d301029cc1 -b4e19bae926db3e1e295ba856984b32b796d86cbc81e81c6978e989f5331f27ce9004f90536a741ca996d19f998541c8 -91502e2a69aeac8e709553501311b4392dea3d5b6f14e7523bf780b8af246e1f2bdc4b29fc4ec3ceb725fafa31bf51e0 -b20607db1bdd6136130ba9683d581f5f45d8623ec4a2d35946723e0d8768654bdd9aeed55ba38303d8d1e312bc4f2442 -8fec23ac3b4cde8c18346dda1afb2b72d4af1a6c013dcea36cd8cbf7223626690ce933b920bd9137f673d0985b64d54f -996bba551ae3b76c5aafadfadfcf80fcb554ff26e6a9e14e60440b3864239129734115d11a89ba79c19e452525cb5a39 -a632f25ec68f02f7758103caf613511a1fa2e529e0861f286b4e490e8fca6874af2c13e3aa6ca97c63f3c621c197ae24 -b332292c6213c7216bb78612457de615da878619024626383914f9c28f835f1289818514038c30eb2bc3566d2da470b4 -b5bd5ed7e990ed8abf7de268aa1ef7ccf5562cf9c92486c2472051c1b5506bc9e72594380e7bd00c91771ed4e9707851 -8781393278ffd5c522ec450220698328e60294ae1e35f60b25baa290a125cc47fbf7435eaf9b22ea819d431de0656f38 -80a308c1acc4363f9bc54e6831c5aebca2b2af47d699a17ae2fba24495984acd4a25c7c95b96aeae3027f0fef9549284 -94a55b36389e05b848c6d0e6426a400d1596195c2cfb4a972b6bf8abde2cf86a932b769a90b62a65d0aaf388e66d516f -8d29a5db4ab3a1199946a79ebaee9de225284f0523637f90e4ac16fc609dd3dd5a71072c30e869fdf6f057b7806ec254 -99caa565547b13953b91f0468b78551784d947b5a3fe1b7278e4a45b294f074a93281e9ee084647d1b24c83b39a0cc90 -aeee1c88769e7bae12f163a056d19b0090c7fd866d451963bc855bda2736c41500bb97a8d72a1a077357419ca94bc3a5 -a94bd8b793a57b4fd79a84daf1f7fed5820bfeb44cfec0248f6aef130fb3219e1bbce68a6a55d332b124e1cc55224c51 -8528607774d780b31417bf85fa3e54a94e4ef6e8cc233ad2a1dc795c68c299abae209c46ba77c33ba74c6ae75ee004a1 -930f2c302a87d6bd159bd6b4db43212e7c806e17f572277ab14dd9715a435bd67b3624a9e72d9a2777f9b2080ef5cc36 -b50d97fd2fbe60105dd1dd44cd12d8ad62b8a3127329f969be917fbf10132f1c6c6fda8029deb990fa1ed26e8c220c39 -b685aea07aa1a45941f5eb2a593c0d97ecb5a803fd2977783488fb00fe6580c41ab83ab6cdd678704311c5542129c510 -8cec65b68f4b3b10d032d39ec4c448e6d76e7615560bb754a53c4c6929c2470a884e7d39d9f3e58a2a9f121ad4175a34 -96279388cc3e91dba49763ef50faa7550c3b4c277b2a0b0ae3541a2f990f9352748db75755a7b13efaffc9b8df40c74e -a7599c33614456b1b02b57921cb76b01109811a82f230f9e7e82675d57757f06021ac3f514d557ed9f2dec025364284c -869684197084f42dfd95350f8a54b0c7d940ceae2bbe49ec18fcfd178b6b0d21903447509e0ef356aa3d2aee83701bb3 -85e9ab73165878b93e0229e3384f048e9651ae29980f9c5e26492c45e180e09a3af9058fada434d1c398b43d99d13056 -a453a46ae96e6330c1b315d1b5f37d160731309d49d13d6c38c5d7f0b4f23ff1d18c985c471564afb54e4477c5d28d19 -a5999c704320d4468f94d647d83c9e8720c19782d2a03677143c7216dc434b3160d193389b0115dc638f6e2e12f2d441 -abc7a466cd848304616b2eca049c4b7509c5260c9236dc1432044ebe3e912afcc3a6ffe3e27d5d79d3ad4636ecda09a4 -89ca07faeef1118c6b840a2c328fd32a5709b31850057302a7e607891e11f3f9f62e4fafd420564ff10a35b9a44c0f06 -b0002f9d2a8aa850b9f22dd8d3b7881e8656cfc53e6c2ae6a913d88f6934e0062f30da2702dcebfbfafe36785203cefd -b8527c70bc791c87f5fbc67e2856e45b7254c5a0b673d4a5d3e9b79fe0715b608a2f35d88a61eb1d8d7cb615fea650bc -b9be558dbe778ba11fac7080789522fc004510f7b740c42023d850946933362a173267106aea046f338533e4cb29aea6 -b021f9e635e64d3c9b4ecc8075fb74cf0e5727ecbacad15f822c8608f0d981ad2c300fe6e47c6148a6b1a13cf920d85d -ae59f2a83a1384ef0b5613e8843cc9a934f7126430df7cd7f5a8508e3d83aba83bf3d18be7380570b24ba0e00e05e0e8 -b403e4d0495a0137a710c43393798593bf131cb8d49beb0f3b3d344554dfc3355ebee14e884f543bb94bf9aae40aac59 -a73b722287df7558c503f89d113fe0c017765c73181eeaa9ebe6de5c8a15ffe76fdb85ab93051a6f565653046624216a -a7d1a28fe1d36b17e37cf5eac7e27549ce9f6eddcb36203b58797d3372371f3b195cd3432db54aae4bf99768969f5b60 -a3447ece13c415c457b899d4a8b8ff388ba25bc920b5711f8687cc86e9c1b3f3af42c490ec6352fa8609b044e642e3f3 -b12f2ac1e033b6a627e7f7822317f629c896c8f8dd94ad91512855882dbb10b8e80a1e29c3e39138402f1f7e0de673bc -a7c65988996741bf59888415fc2264495050cb13500b6597d9d0e034898121b605784f681962cfdc80b0af291c316e7e -8c40cfc07dd7a4bcf514f2e87a1830c911e8168b0b8531a2838d2a14e790922b76c4642ae237b7547d8a3625decc7f0a -b480d70b57434467a40d6dd066f51b9e637abd2f49dcfa6450460aeec2bc895347e21aa82baa1bec7589b6a5a694fa73 -a919a033c24e96af1eb0cb1ede3684e9a3bc338c7ef37b67cc9e9982586f74072cc540981e2d1a2524e99144bb21a64c -921e0b350907e9993a596b80f827b2d40aad60e9c62f4b65a67d3fa4c0acfa924c93352dad6eb3e868264bb24904e3a9 -8d5419cea0bfebaa9c1509cd748c8af3869aedc3ae27fdbca3a0f08b3751a3b870e8dd3640f4abd4b46a2a1e745758bc -8b25e6eb600de81fdd03584fb9db9a7bf4c154ef1482553d7bef880bdc5baa7b64abac6db96fcfc4408329adf8fa351b -88cdb72bee7a6768b7c24d124dd5e8b29f0c866a0624e5a7c4759962ce1d71de7faa97f7baa56d5f51e35bca43862bee -af1d59add7df3b3ba234b0b4f758349225b9cee65691c102294eb7e6fb683d7588fca33ed97eda361060253acfdc36af -b19370b8fe123f1dd2ea6d5bc75e151b0d1514224f5824437166fce77ac41ac5ecc1e7c1e75b75e948acf04c420efea3 -a1ebfe84f1c012524cb475e68ae6c7cec79fb3372f1380321a0e306d15828613589567efe8bb5784360aed568e26db49 -a0f964e3cb594c359e2308defd3eaec476a638b6e1c216157009e11f7c7d0c33fb9e62c4243057cbca49ba315d4b508f -9391e5087374e45f03d36f6919463c473938a653adf3880571850374ef0a0e521b25ef84b6012a19a02ec88f0ca3891c -aeb86d4426d2836e6e10c3277583a37b6684ba35f4f30d2d073043f0a0148f763b99fc42c3935026b56c32e5cd0cecfe -aa98c07dcfb1b0a708486d83763511c7004896856e851bd83d25a9551efc28f059c3fb8752ece0296964e8c13ec829b0 -a466fd8dc1aea7022a86e12a119b16de35412a1b461680f6a1cec408e9b9c1418a8e406fd4a5656c73488adddf17dfba -8c9b0e18a033c27731fb3d22b7c83ba7a86fdc2234e8f2a19d7659aa67bad7a85ef25264e8eb81af529feb3fa9340ef3 -a371feccc2f1a1b96ad8a9a7d8db0c06fefb1f2800933134299027459b0eb8cd101b9a37c76c22dcbded01a74b13d465 -aeb34fc2758d8b68d17f15ab3c299344ed630f7351c498a5fe7986f7e14d62e74ac9a8f5d2de7c6289771210539383d2 -aff9e961d0acc71a077e3af52ced373bc694f9154302abc908710e500e908f33bdd10b3c41bb8fa8066758a18d64c667 -98bd5a8751e598896e9aec90649294934f81c36d2d0fb60070e9b96eb47d0988f71d9b68f4c475477eb4c996a9265c13 -b25a92c6260f389f6443a572960e0a52ab9c9250d8760ed148082584b2347ec7d103358c033266bec02374e69d0102fd -b876968bedba7f4712f5e5eea605c1e5fc40bc5773c61f08c32e0c0f3ec575eed3e13e48809983153beccdbca2123edb -8c4091ef8946c9b27490099d5c0b47c404b5a1113500592515deab1c3f2778bbe933b09c9824a3a7ccad2141f9b5dcc4 -ab85f95d318ce235929531e2e397d09b9906c58958fdff1209a514624a099d3b8c103a51b2fcfa0b17a8f008744b5d71 -9016714cbe49fac5e7b3e493574078c462e18f6363f413270c23da6327731f71e2dba5dbf1da6bbe0e29f57f0c33f869 -8c90df700c0e2d104ce7b76be7899209136498999f78195cd888aec6f069778d657e5032ad7db56381470dd1f519dcf9 -83dea8472e8418aa069a0837a5c44835aa1e00979a217f6295aa35548f509fbafc7db5b31b8767621e4f89957892e8f4 -80a1d673220144973ab70d977b94cd3d6b8fff7f82f23bd4b30ea393952951d2f07c24e6d411b2ec19f3bec13583d9fe -804864b58f9747bb3ae54c588dff46eb6e16b6d98e0f711828e97d9f019297b743aa2202f823e3153ef5bc4b95da3501 -b08eaae2eca2c64001e1da7d0e345f96dbd3e09888f9ab86f178718ea5a04321a8b8633e72dea68cc05687042808e3b3 -b962f91819dc570c2cf131b89882fb2a44a999b94fd1ea8b83f400e9b66075a35c89f0fe0e8dbc3a597cdd1aa3135888 -a5f33e8f04a2d7aab44e832f8ab4640519aa4ef88b58e0a398e45347492b040043e494de4b355f07cb4bc728b67f1ac9 -8ed80bfb4cd15bb87175cff427c6a1bfc3e6292bc5c2d04dd42b497bc068baac5602d41366448ee7f37d85a5d8437750 -83441e746afadf64583571a9918ba5122ca987e76a6e37f98514b1a8a178380366d10ded5c70d4feb08be6fa6d4bc25a -8807fb8adb2aaa6833960f435ace162c01a9cd0692a4cf038c89ef7405600868efe7bdb3e8a3db48901367ebafb0a1c0 -82c64b1f77fb78dec00cab089cb7a88ae16c72c94d0870bc92df11587feb62277eb941d2f7d3d2fb033d7bfee12013bb -ab2f1e3f1fcde3b8b2c07135acf3a492ae7675d9bc971ba57e06c99fdfb39e1f68d1c826cd9bba872749cab375e44009 -b4a25f1f5a2aeabc29870ab9a815721f3cc031ab1a55417b457ca6504e5e96e4fd0d2d364ae17738726c8f40cae9c36b -9519efa4774cb4de4ea834376d6213d946fe6882e2b36342f683762fe50d754765dc301569a836febb2c7c9dbcf44f64 -a75de0d0320e8cee962d6ed4b07db718615e75543fb25f0d28ec5e76f56d72b18d648ae42d7bd3da18f54ec1e4497a08 -a2a17aac11e732097b25c0b9f7b97d807dd78ecd33d88aea5ee0a46a42198d379a241e888ddba940b3307e9c560ec45e -936ebfc2234d46282ec4de88958553759d766f682d6f9669d2b77a2cb0cf9cea9b1ac02014ac3f5cd47dc5d8af2da314 -b33def3135e7ad61a660ef1266d61216220c7e0bdd867b727ff3deea904072e33a195e4febe64ee1e263349fc9096cdc -94337e4f14752676a703fab8544ea0ab7acea0ef924b85b05ffb84e4476f1087acc9a6d6250893a32b82f02651a179e2 -8f22942bbeca0118747a22d0aa13438e40bd6a383e310eafacbffa1490f5758504da4a11e6320e1c55b3daabc72c63f9 -86e3ed934fc613d0b3269cf368e32e67f4add59e4dc1ecb1f016fbdc6c53101c2435f95fc36625aa8c69c596acd9b0bc -86f04807460e1d93f8eea2a284119d889659b5a6b124d41dfb2825b31685361e8163fc3a253a49cf878e316463c9ace8 -b043b2a99b94661ef8b270842fe4d3c51891ec23ba749d9c999982553ecade6f658242b373982c9a3669a886889e4f33 -8b6a33a68ba7b5932ce11b3f0e23c3da580510fa37668f2154c59c3bf788dd2276a2a8c66a6bba1a68084e8b9bbf378e -b54581c88d4880fa4a0ec6d3c17b6f0ba339e8f7100242efd3b820ac942d75d1f898259d6f1e64a3870fc301d9dea2b5 -9449dc9bce23c7e3b41eb34789dc7765c2f7855f9670c1d145bbd1b2d1b47a9318862ef3738511b4f89cb16669c0af18 -926245ae9d4eb213ebcb88ab2d7e2a7d198557721051fef4cc966cd11be3490a3f83d4ff48f5fb60cbad9c5de4b98d1c -8518dab07ab15887c68d0de9fe3c0c09ea6bfddb99c145b3f6ff84659e7799da93e97bdd17884b228772398caa8c2ed3 -9969575cbd7953b6308391e9ce2cf4da466b3e730c9cec0e88522258639be35fd31abdedd94b445d7075919482513103 -8b1f28002c19b17d6ac1a6f50afc3448f390b3209b1a76a9a024ceaa274de4588ce82a891a03e878ea08747ae5d98211 -a611963d1bc45b60ffe6756a743ab379e4022bb3fb263f5f305a615c92432199c7e1060a79aa42f7662fa89a0812a4d3 -a3c7706ab74e976464fc341e5a9f7284264c1610fbff02fc36b88e15d6859fbf40fd8c5e93c8237b97acaa0900a03764 -aa623fb8892dbbf4fc02004a44e07c21a422e5553e4b02fcca24dc1f416a54eed36f2f7376dc1e66218e850772676e99 -8133cccf10b1686bf53143bd3520515ec72e7295f6945c43bcef7304de597b767265a3a9f7b281fa353acbc3cf6997f1 -852e4aaf4da9dafc988d0da13a7f31fe8403f6bdab88dec363eb8cb8d3e64c48ff34102f6660642749d11d69b613f8de -a616028c6cd54a6514fd9f7aa9ff13000eaaf39f582441f73a3ed8208a513b580eb7874b5cd0b1e9a542c40c5887bdef -a48ec58bc3bd4b512c21d3d55618e9c51836efa97cad42bf79e748542804114714db23d79ad03e410e0989055c9bd46b -ab480f3750420119ccfcf8d32c4a18ca580ce88bffe81433c1d6999c221c8aac482de5c0e41a5531806bd17897698d6c -8522bf3b7157cd29e948afc8f479d6192364a11f85dd5c58d4ea0443aa6b655f55a80e6a3152fc02a8eea4c0815fcf19 -86c91a6021e738103031c1ece906ff43227eb23088e5ce1b6a1cd58664d4a80d7bbcb0d56c3b0e02cba1e1c2ca22e058 -8ee51a59ce6becf098256e19c9aae5ef0c2c9e66c587d9a32cb4ba1ee0b64c13e2e008908e35f43314316508956654ce -b94766a0fb91c8de2338a68c4ab08ce5bcf62f6efa221067807dc647b595fe5a342d7122111540a1ca6ea7743b6ee772 -83f917b8f6aaeb9eb2eb742546e3f2dfc9cfe00cfec60051010113d55dba2421974098c157dc2601902d8f40bc84693b -996e489890dad3c4dc35faf53d870bf1cd76f1dc24e0cc8a1f899bdb44e89dbfc77fb11f7b33c270a1394c909f7a27f5 -a89936283190b2d1ce8d166b36694afddb4c3df01bfb1fa7bae69c55d1acb4e68e5e29867ea33eee8031029b3c6409b1 -b08e5a5d6797ca252d12428b2086e528a6e5c3965d2e5ff2bf83bc71ae9c0346a4ceb3bb2f2e3f8a1685fc343f36997e -a05bd12a7a6d52d234a1b3e9ddea7b18d6d41026a0d18251b1761f1cc863064dacf821707cfeef2dd1c02536f584ed94 -87c638feef9c88a9f89d10b56fe4bef6406c1d734cd1f01006e2f2b331196a49c7184c10786e855b3de8978927df42bb -aa194f3e4d0fc1d3107f9564b13e6274bbbfc7b8c1e73ce6677cc66d9319dc34b5a0e790d6d44c614c11feb50530a252 -b2ab7be7ee9d72d1015e94d006020e758b73f200dde81e89e52cd33f25aced0cd84b8c300413d32565c253edbcd2fb1f -8ec08b22265aaaf27a84a6cca5f0875a3ebc70fb36c4f5e59d60c55bdf2a4fe11ab7ba4b387f5d668e67682a0978fa46 -93643b9541db11b48e0c84caccc8da9ff7696717aa176ce6d863446ef8d887f3159b0ab6fe1f79fac883a371f6736e93 -8325654fd8388ac96935149165fa3238d0848151a04be57f2386c3304056013efb49febee0a871cfc2ee3c11bb029042 -a2c15cbe5d5167f55f2a454390b61d99601614037fd67fd198968531ca2f84f3c214b971ef300a20a114fabc6c67db0f -b40ed63b0367174b5b4b08396afe2385b0f75ec2569fa3cf60f87e1b17fdee888dd66057be2cfb185e9f32df59b7a8eb -a466d2c8052a115f121177979620385bb07148e202631979f4ffb01e7e0f6fbce28747df9bf70b2168653096aa704fbc -99395136290cd020cfba0ca896642c245182e2020ca2299be8ebb2f62e2fc62fe0be593838f62681f6632fbdffd640c9 -8e4f081d9a724bb54fafb66297a32f84687493464550c09259cc6f8abf770d076a514ae1d6726cb29349e27ef69a74b8 -a8d5c941e7c03dba0232c763590e93e3d99fa519b0a65996d20dd20deed1d0192738f3b339edac68ad42016223733582 -877baee9ee979be8ce3bef02422e57799dcadc34fefd8bf2baaf945f267883f67211ac5c06246f7b49f1ea5c99550a63 -b6fcc2a73dbbba54760d244bc13e1564a3c61097e9b525b247cc8687ca08625a7330fc6b15e45a3ee508b4d34853d852 -adf720dde6e9b5c63e361d69a2ab46ed73e0deb82f8e30f27ca2b19c2d8fc43e18ac04b4fa029f553f8d7dd79457ecda -8956c9038f3338f541bae9ef1f5bfad039d532dbbbe7814e3a3d5442d393ea6114aa666559d8a7e3a026c758a17c79d6 -8d6de7f95f30a5a4b3d441781c7f819a0265852ab78b8416227089b489787c8ae9dffbb0bf88acf1b4c4d6b8a29c1a53 -81d4efd71c9d08e9f6d7f7d7a2fa5089e80cc3f8dcc685686aabf3b4c8bd531b4aa07e328c0fde32b638f23eb78de588 -a30053b681ed8328b5d64587b0d38edef0e366a2762cf5068dae177e4f4084c4333f9a5fa5fede93db80f7a8fd5fbf57 -b340ddfaab2dcded58930e5dc2b72cbedd0e79ef652f34356fcf72054a87fc2373bd3aaf8a88af8d4633f73dfa7d9a28 -b9f3a7809be0bf834bd7affa2059d9371b848dd5e5fa93e83e90d9e078a2fd3aea64410a72457c32d33ff1ca11dc9300 -a9a8ce26a38dcf277ed66d75e111b07348101e93d03f446ea72bd903198122f8a08569f7125f6d4ecaeda8c093a00ec4 -81e78b705b44533e2e997f549f46723a5e6b88241d7a86ca20448ae3ab140e967347abaeb8700594a0cddf1e82285abe -84724094dae5b7ece30cc01b5f2acc8787de57dc0c37a437c3e8e26fc03069b6e8562302a0f1c95de85937f07fe63d3e -97a715861e5bb715a17a948d6b6a389b89744e8ccd3699fdea9ac3d890fad027b78d436f8012b0abeedd078a20ba91e1 -b710b2e7d87771416aa34ba2d93a044bb118f279fff62c1224c150ebc30f21abff212019f0f38c334daa5a96598ab900 -853034af5ad08c563ed096ab2d0590ea644d372cb400bfb03867092768d90b7432d35c5506378d001f986c59769d6d56 -b340ab52f751e9d516348faddb45f0115ba0619ec9db820f870007e3a4d305ba2bd0b2a58a7576296531fb78886b16f8 -b8ed8feff520009743ca3313899a118df025a61e6e03bd5fd27898a23beab472746ca3636c22ea3835e9526e17c06dc9 -87af435e3e4ef611d6da74c8d98e8d3f3de64ac8748105dc20287a7dc866f57d10a2b854f7e0e09235eee647dae1ab86 -84108b1f0f0ff73a179cb1be1b2ecb4268e7fd2fac3dfc7f6f99889c90a33b4310946909b9eef31b256b8d0e3ba56bf8 -a6b9fe966293e60bd384a1e4d472b0a72544aba41b31172ac8bfc3e19beaf51da54a66625d73a9ae22c7c4d1b0840a30 -92e82e92aa615e198ba3c83c039b0adcf4393b3fbf9721b2e47ab17a84bded2bc8bc2bfe257d2d76162a87e8bc7ce759 -b9286dd48800606b7ff9c3fe2abf5c49ef0a6b981711b5ba1f62952d6fc4a9999bfdf061c4664a019120f15e341925d0 -b5da5dbceaa7e82f30fa5fde88b03ea88e7003a50eeb53e3f3aeaa63aa586900525b42fe1b699451b5d915d1b83c3705 -b06072869fb8526d3077cc61a3c55d54a7a1197bbbcc875aeaf617d7d1eff3dd3ac243e2c76caf57dcdfe306edcab4d7 -b132db9ee3ed16e6d76db9e6e3dcdc2b142cd70b9582518bbdf5415b3bb476ad900d50004dc0ab6b87ba697c6314b4c9 -adca92336f3546ea50b034525fdf548a36049ca82d9d3cec10073e7cca186227cd662d4d66673e7214a6ed58cf75da6f -81bbb3fa241f9514575fb3f6cba8e34301187681354c94e7976a4205c0bb238dab52b29a76a5f0e0d4cb1bc82f8857c7 -91008dda2bb7dfffd6746e3544ef540d9a1ac7ee9c68ca9984a1d81041a18fa9f35b8c4bdb44ef3a860c37481d5e9a14 -8224195cf18ca0d8f01521a0ea92c9c598c556746c825a4dda49ecbe324d570a96775eb81dde1d3a14aa3660d50e27a4 -8b355eeadef5fc7cececee71aec3ed30349df8f43f25da1d75d62ab00fc73702b405fab6d422053c2b0fbc7469ace9a3 -a4d657dbf2bb30c1e57e0b63960663bd86ce17204979a9ab82624943ea370119f040b58b067a05ff6d1867a22a58698a -9379a367c918b2be61a9a42a495ec03f0168a4ec36f753dd37eac6e9f58a26c8510ae7b579a89afdee1d192edefb4bb3 -85b37bddc80754f0432573204a1a4b86a550bfe9689f6c710a61810aa94dedeb28763ece40f28fb3a6f3791ca4c86b8b -b41c3269b96e190e40cc16e6c7cc8054cd0b7902a43c69b79d8ce471a417d3096b2271badfcdc59deb6271ad3e5a35b4 -941185020a227b7a995f59805c8900f7f6ecff1e7b948a8b714f85a54449a0d41e28db5e17874e018eab72ade20eede0 -8a0795ce082f74e4633acb1649b52b46ea2b4360860fef6ec107910e245b30466bfee8ce59a6854f866f55ec5cc7bbd1 -931fa63550530af5a7ee24964b8b4d0c66c2bd59108131f375c7de86bce59cf52890191ec8540666c895e832dc312360 -8fb86918190a3455014a5cbd15c7b490d68c10cb7b505e9233b3eacdf52e63299d49ded75fd74f8c2bcb3632a9c29d14 -92c896826c9d871a83c4609f9988cec0db6fc980c8b88a7baeea2856ec2a0a56c3d5a846a87d03393dea966b534aa8c4 -a9d4c780c94384f5a13cab61c734836f5729482cde62f2888648a44317b749135b511668834d49296ed47c0a3b9fa8b8 -b7c26da09c3998367063fad19340f53217e8545535d376815773e201ef49e9e1b6bf1423b0b6bb363586f5f05307fc89 -8c445b3655f1f554c2a7f6f7d035121939a8987837dcb1a1663586614dcf2cf47f73633950d8803e2781baaac52c12c8 -8764f924f41d8c5c91fcd77de26ee3bbb86d5a5bfbcc45188be453c8dbe4b875fbc5ef5b01ea3a26b889d7b45417f173 -8605a8186d5716dd5f955a7125619bc72ff385cdecb187a9a646a4bdf6595d67f00e777836261f3a69c19d2e2cae27d6 -a97dca2185e4fcd7583b1e695333d55f54edd751da436b8982de8c344b5f57e35ddb61ad4a611dcde08e287c78c757c9 -b11c576a049f93e0731652f1a1ade62b0124cb7b4e2b13f6505206c27ebf7998ebdb3d887bed01e43ce5c24714903aff -a46dc516b8ab4aabe35f38af1236052564b01d66c558e7107175064a5226713e8550912867eafe4da133f56950df57c8 -a13e75bca5bd3b08030205cef4faa56a49e5d7da94bc41c708deb2f65343c1687aff26368915a490b89006185f18fda4 -8ef5135a6f1f635a4966aa540cb877dc98c6a88fe462be3226c1a270c82cad8e091aa49ad39862f012edb3c93d15fb4c -99158ace79ceed67b6d8e884050c6fb7c7a1509e41f0d2b9069ce8dea392f17f88303d0942cf3c0af3ea52d3194123a3 -8805c76ada9dc7e57545a5e1a874e6105592601213e22c1601b0b157b622e51f004a1da754a8fccc8f2a2241c14e21a6 -ac3dfe87e17ccda6196f621008716a14be4b983d187265eabb8f5eba7268cf770a70ffa19d1c7e77fab0373eca7a4045 -ad78a31ad6f2c84f6e5348f33631d876daa3d5978f6d1a77db80aa219e12c9ea656e9c18e6316f899bbf6c2469cdee37 -8c8726f8f6fdc40516bb64b6c624a6eb4caa931e3a9ca8ce2c31c282ad59f0624ea290b804ba84e339e83422070df419 -9303d1906cf416a184e15f13cf7dbdca5fb296b078079782c9044b9cbfdf06b0c965305a8d88678b53f0a10220e56f4f -99b9735a77cdc1c675988e613b3e8843e2b0469030a33f5c14383803a1b20e328d45d2fde6ff0d15f6bc2eb8da4f4d88 -892a18f4ceae3fe7cde8f32b84c6bd3d9ca867143a30fab4f939281cec12587929faf07225725bf33ddf154b90972214 -a100a35a2865bb465830ce2f68406d8a92bdeb21056bcba28c0ce8ce5ddfec6e293e926d764499e53facbbacd3f72994 -b797ab22a57520a0584edff499cd1aa1663d8b3f411faa542022c5f1a645a3f952f9164f61d200e4500673a8d95a938c -b1a457d100def2e26b2b30617ee866264a3ea649bcd9edc7be132f5cad02f3209f5dccb02b95a462b5af9a71fb88a341 -84c1f6d4f29869a359cf89118b1a80224cb574393fb557d1c61730a1fb1884895c4cb07f23c52165975b89fe9d6f5a77 -b6d53e49025bcd1d7960ce46d4f64ff8f29e4239fde1b19e5167d506b086152da3bc3b86fec8ea531a20afe1c785fa59 -9635b053c03d1be0bdf81e9876c63e8541b793ddeeb2a8f3ab0e44fb78f81a9e61f8c68ce393c7c959b62b67f9724409 -a19ca9ac5a345c96a607f979a958d83eef4350ebc9cea0e0aa11469dc554fcc39d9b22f8a3c92de599ca08ff4152ec23 -8e7d45d35f6fb95799846fab51b0ff2415857bb54b049694c1ebf93f45167b8497c3341b656f194edd5804195a7c96bd -87c05c7d5834394507ad3d363dd0ca5132a7763644e354c3b7a803fa594d951084d37942f59211660f10098cf49adcdd -b276246af578557aad38190878111e804db0f29846185d7033c913a31e7657d035114448ddfed2f3d75c04c79ee01e79 -868bbcf14f96547192053823e4f85b50fb988da5c4cf73f5cbf23953252b665ef7aea4421c8baec90522f58f027a2b19 -ac2be3dcb8082b64a3745ce0d2b97cf341483713e1bcbb37369123d6723968d3bad1410467aac7fcd3b623bfb1d90d9b -b1e5cf361e0857373814e8db7fc275ccc1dbac8559e8487cc892bf82d4c6be00d1b2ffe40289692a70072c5f80dbacf6 -98e16a5854635c72bce6e263bb57c071194df076e1ddd81e645884367b730d4d557ebb8c74b3c582e09046d2b9ad8078 -a0016bfaa348d44a3ef814b348f7d56fa83b78baeed4a7b58617b6f4772dfa990e912ebf91c2321307884be85dbf81fa -85690a2c5cec392b6f98cd2d03e4204cc51868612543c7a3112066ebeefd4304c5c8b21da44534224398648b413634f8 -a3a1d00d0fdd8c8cfee153347d590ed78cce48eeeb7ad42032a95baa73cc458d46882d0e9707f3dd519b1844f236bcdb -aaf2774fb26da59c115a28d86f0c6320368fc6d2c0bc2b7e4516cdfce3058cb423b0026b6c75030ddace9ccb7f058227 -af507cef7320bd003526fdf43c04af46beaaca5b6ddcad835ae14da60a2ce732b453d8164553e95f2b776df55ddb5efa -b2656c07a8ba2a2248d0313a7795b99f5acc120648c08e3a77fff5cb9b861827c94d4f2f99a2f2dec1d1667ca3ab26af -b426b97a51f0439f2da2d0d934693aaf52482bbb48893de12fbdbed1b2155e30791e7098baa18f93ecc45f8dea4f22aa -a71a7e08426518ef7307c2a1be7aaacd843794601c0d49f4f0e474098ea0faff74fb5ae2bee416aab849afe04be434cb -b6d510022dd3b9ca35e93ddd2ae77877967dd6966706f339b2197d2891bf523b5d55b7cdc80274368333f9249b62a7fb -95d2f6cec1b4038f56c571ee0f5aa14fe5fe7b9a2efab89eab4c51a696d2ada549a42095245bea14d7f7ffc69ade417b -89147eec9de685483d0a5e21b877cb550518a1bbcba0ee65e9519c294fb0c422a729bb0f5a8c8e3fe77070e1a89fcdb2 -a66e7116eb277ba900c06fa48baf274e2a6865977698a504dcc1d0c20f90a7030bb2a841fdbfaa5c8ef6d81aac4fced7 -815053a8483ce2a84a34f81909bc3eabefdce59140f0fda6da77ec005e5dcfdbc6f289d0f0513efbbeef0358daf94025 -b480d2b6320ebf29f3781f04dd88e835ad81d2c63b716f6f244fd2b113ba3781001a34189df586cd629e70c2baa0e5cb -a74281bddc3a93503a695f0375121b3bdf98db4b2b053eb2cf0773647f6f69d1d98a61efcf82e2a823035ce803b82001 -b84fb99a6943447cad21bfe2b34dd8da43d349e53e85b73fba8a5fd0fe3f41e7dc629960b3325d08af1544e5dc66de28 -a8d11ccfb0dec31b39efeee74c58536f29abb02d06dfa11acb7134cac626a17ff4e204d1d138a472c63c629b6f8406c4 -b5017d42a2388d90bcf4d0b6e015c63612a0864b2b379e9cebcf2e869e5fd45d2713bc549ea472d77e82fa8750f364b7 -83c8e090de4ab6ed169a033aa4ab84f7f3e2b54186106790b30741e9d87d9a5d61bd6a285447e0d1a8e1865ee618a91d -8db64f3a1680cf461f9afaed4e714709d37559071bcee52e13feb5627c1fa7c093fc8923ede3e70db07563d2d1eae69f -b6d20dce2f50b78b094949e64edc2ce1b077a3258692ecc2cdaa01ec19add246d0832a319bb0d4153198e3a35091d86e -a61e585ed55dedfad57352d2abbf8ab336a999a5abbaefeb5d0da9fb0d5bb791119e52034844ffeecca9655675d17228 -8ff58b27196f589ce0d3461e0c00d695da47a79809719b4bd4a229ea7bc9319469744f2254be4469092b1a27532439e8 -b5edaf7c3f9dad7a54908da0e7a153d69a6bdb99fde07fc42928a0dd38031e32dec81c864147066412a8ca240e7dfd0d -ade064bb3f87431a32b361074a89dd280cc1160a57fb3cf21eea5066e886c7bfc3655fe39099a1913b8b53242b23b2ff -9169621f97887db46384b43ca24b1447e23fcf5abf141e70fcd1834e9d691b9bfc6e8059d060bebdf9922608593bb972 -8727bb06fadf0633fb8137a54d6912cedda0bbeb0f93af97deef3490b1b47e58fdb37a972dbab1534a5172ff0c840114 -91991b98243bd7c138bcb60cf703a9d0828f6791eff5c2c1c5cc7e8edda258d3cf72680bff2c563c8e964f87450a3037 -a1bddb74f5892597ac687451b932449305d6deba20e97e10989bae311d532a7b72a3fab08dd832589e6a22c0fcb548dc -afc52ed64208e4beb029d1428697fea6add02210f613551d1e5ba6011c5d13f66ce26b3dd2a39b30186c566b1af66c06 -929bb88a9e30862be5f45c002c11537780d151f9836edeadcaa4a617b0bf958046ce331e15bee646f9eeb4d9ff854661 -b3376241793ab9f1732997cdf515b9114f88bb2c25c0bd3f3b22e5b665e1ae94fa3f6a9f88de37b7792c3aafddc682a2 -88fef7680a7fb665043264c9733dcbd23e20628909278711aad2e54f2eb8fa3d07011f593069b6ba7ed312d9ddc3a950 -b031434d514d0878b7011ce2840e23e94a4386034dce422f37fde539aa35cedad1511f9eec39fc23c7396f43ec22cf92 -a4a32f1e58c4ccb2cb4ac6c2dd8acafa292810c77126844f33287c8d522bb8c32dd89ce8f7c1dc9a273165b0879a45ba -82e5b11b9fad7c7d5e2a8abf03943aef271ffa43ed8127dfd85c7957b59d7cea56039116edd0b0b992262751c347f75f -a650327144db1806cefedd1daec1de3164b77c02a0aa652371ca0401b50ec3b7a392ef6a80de6d4724892d71cf48eb07 -a88d8370d88379b52bcaaf596c32faba155db4857bbc7eccf89b5d67a97ae481e53e81de6c9461a6719d179f3ffbaf16 -aae8b3d1b1bb0d71f19e37867885a1fd550f7805fd1306881515d77e5f6a990e0bb40c685e350ed09eb4a55298f3a393 -ac024fdd79688628ee188a7a9d39cd1306883c260dbda9e79eaf2d2f57051b5379834dccfc641302cd12a8a24fa2224b -90cda91b9e71b7bbc091b9e8e28d79f0fce42255e24a7a3bbf3348651405c46d3b6e2e33c5fb5e99fb4d0fbc326f77a7 -91325730bf7d71855ce0462a2fd0840f3753964b296f7901e1ad761f48fd133371fcb805c315c4d8cb2ffe34e98ab9cb -b9e1a298ce9efdc004903b21e573c113c771b1bb5b25e2e88baac6dd7bded130016b2f09e50a4346c59adee607a71760 -a703a60c430e365bdf9023c923a04fd9db427ca0da2da8dad6b0f0d5d352524943839d859c15dca64b590ace6cb1ca89 -995a5ef468a38caf66d58880245064a7c0ab520ebf3c9e9f956110a9dd68658baae22ae274a48d59464c8d37d2f8b643 -889c6e4516ece0e0fdb8c99aa482f367f2cef0ae2ce0987b6b602f6c856b02fab27114a6f4b82050738bc98a48ef5837 -b432ce5f638aa48ba952b9c2e06ce822d531c9a24011d14650cac0722a4c5ad1bf22109a2f429cbdd22a567ce6f03094 -86fe41234d309118d1256a9ac79b7bf01da1fdfcfd579b655f31b7c4cdab6f687d46855d56bb11bedd4b0be17e892b2d -905ec536f23dfdcc4f8128fc1c00daa877eb3caded7637dc911aff0e6279eab12f1748949e4bf015e4f8e30626d3177a -b6b9f47cb82244d7b1102b37cb52f5c9336e4c05e4c90f5e448fa92444bef12d2fbcfc39af9e1fd05811f5f864f12047 -ab56e7c534ee1f921351dfed3f3eaa127869849b44540b39b0dc021b3dc4dc94027e4161f7f3ed40bf42a1d08315264e -b9c62b4e679dbb3405733bbe0740450e72ccf39bf953142cce65fe014f132d5af5864ad96167027012c98dc8b8889e8f -82b8036a3fb6f648c6fb0492334fb3dc8f57c32779d4eef78ac2becb0b93f046dd68c2fea3b5039c21ce8e1efefcc685 -8525738182748d6f901650cc328ae498cc3c712300441042441f66c683e06dd741b644e8e98732552e55839b66f86b82 -b625cca7bf4ce510f21e8197b223dc49e7ce245c5a5d1e901438eecf7160a0bd37d0196191b1d934779f4b6a387b6db4 -b63d753d728670f3b63d4c24acc4a3d4859e5f15ad775e502fc50d7ca42b0d2484a8649eaaef9eb22cef28a23e10d5e3 -8e951028c0b4c5a691a219a6dbf348ef66edef60796094d5f6abaff1ad5802b53a5abec9b8b3b3b98f8b5858672847ee -b6b71004d898a3bddbcf7f730b8d5c0d8bba0f3b508155412446732ed9abbc1d03a90864f4689e6ab207aed495830e1b -98f33a74e36c035d9476b198dbf3a75573856264d45313e5bdd89db291dceaf4084917a2242b0a30d3b1ba4ee3016c42 -912fdb4358fe617d7981bf9a9986dade7fe279a0445d7b14951ed77eb88c77c4aff4162467e40fdaa9dafe78da0ab4f1 -b17bdf7a896480ae70b3696cffefbca468b57493d5db59362dd85a3da296e1162356358080c8b0a7f3fde798a3ad1d15 -b47ebba84e62bf453ab223496a892fea2244ba6c37615c3db31c2ecc16a5f9519dd79aa710ec1220a2cebd254f7690f2 -b3361190434ab75e46a40e0ce21ccc251fd0139bce90664bd33d9eb6400317c3210509e4ffeef604c7b05b260544e19f -966916b3966d7d33be49fa4eba925aa2f92adc2d0228d1144ef633dc5d67fd8231087c488b492688fa142a8cdb45ca70 -8ffb1491d4448af82b7cab5409ad26d99ef6ef08158c73a9ee9626c5a84d2fc6d852e2c786c94b47b5931c7194d5b82a -a2d4a5bb458688b8f593f39cce2b27fc05f8ee3985f4c5be453706e8f174d5a6585c2070c0bdbb54aa1d8e79b5ab40e9 -ac180389d0432699bafff42a4c3da59bd32ab1bd1c4b4a4829580577fb3c5eaf8aed4dc61a93262f23ac44255e6c2b11 -87f8fe99acc93080e2a2ae51eba24f0b146c1355855a202dedb7deb8e1cb5c6ad8664ba0e93ded5ce253597fe015fdc1 -a554d88dcef521dbf5e4823bcc9145c8ea98c598cab56c85f101ca7be82297dd7f361d457966bc69584adda6d40ecab5 -86ee126cc839d869c7e91f0f8d919929f66c1f67675ae8c5eaf6bc35866580c49d45ec8edf0891b546ec2fe7bebbd304 -970d74575be6cabcd2e33a8dacf25b378ce750478bb44086e1821c97b6b27055b7f00cc8ca189954f0150de7381c80c6 -963badd0cac713d8a23dabb8ac7da5e9a83ca7d580ec81dbbe3e5d53c5c9370b86222ca685215eb282c8f67a977b4b66 -8d2735c85136625b3f8c4196a8f892e276845ca7c876648498143f1897637807a9a5162bb90773099a7b0cdfaa292263 -a1a8507bb8a300e1df882651b0155e46a0f58399375f4e5f993251663b5935a76a02e60999a4851fa082a89d5cec2e63 -b712dd139d791a95486d8fe48e35bb8bbddf890435dbf8dbb670699dcfb143fc582d4bdc8a6751f6bf58a13dd8c2871c -8f108fcadbaa43dff904a23c89d809746a9f732be817c2c882ac3493624aa5e49af7dd9b46de7d9d01ae982bb78761cf -80e270c6620756d3d127457fa2e51592604f85479a1004d63c184d7d2ffe2eea4ff75faa436f24bd1494f4eaf90543be -81f039fce432a5d3bf9649ad0fc2d93de831f5b9c0d0e5fa92d35b5bf4a52c739d478289c2386efc964026134f91ac0a -89401011d51b6106855487a37459351f18c39f08ce90b15e52a876cf36e969a9c9fa6cad94a55b844ad45fcf1807f705 -ad66c149ad105ce8b53d38c410d73a3cb3ec910a9f0ae798f3aa5207501c7ee39b85f10e91b4cd91e6b280f3912c492d -b709445e56d02a558a1496bd2b9115d2635855b18984cfb908cbd54cd279d29ecab21cce704cd9ebcf34456dd1195d79 -851059069d9fef4eadf6ba508ca330ecb7436ccb91d09f5d0416874f9fbcdc56472d2adbaebc63a63f190b6abe7650d9 -a933c1b614e6d5a58c599b7189d06bfa3683995f449d636805c8307195d8e98b62ced873997898d6b1b01f6e6a52b743 -a692ba436613db22bc30c3f36a516971158d5489bf2c50c39d0627a74048a6d0b229606823f37a0832913425ddc30d06 -830999596d203b96329185c100bb7360189a50f7930286c36544d20e57b8418c71d8db331e4352a98f380c68a49b2005 -a56d7c262bb3d443fc0cacb2b61f24554ce35b8984fa3418bb4e271d5fe4f5378ef7b12c6cd02f537820040bcee95f98 -844a4e9a8c9eea0b6f929a80da9f4e4e273e999fbe182d3855b0a40577afaced6f8ea285595573e99e13b6a71b985c03 -b34df6205fc429c9b7cec189b2634d49a4877f22bb8060b9f7baf8c2eac4e1d476ed1f30fff1f4c019c65fce96abc554 -b3a97648b3b79cc513246d3d1722afdf7645e7216af233645fca6a2756686592635facec913d19acf99ee586436cb58f -b9cac906123f2a4aa13d5d7eaac84e84eeb0a1b7919526de5198b5475fb815ce556f8451c953bb0bc910c93c6fb3fab7 -a5e441019d492897de73d31a44a0055fd04e8cac894d626d0457ffe9de5394d0bf851dc5941790cba388b403b86864ab -8e3081cc7999d91d787e4c0937c9e22c959d2ba4be6fa04eb97471997ef150836a910ef28455f117dd54fa9ec655148d -98eb793d88faa691ecac3a7c78b25eb3a833ccfd0275186a63b1b1517bd2b984d9908c84e55f044b31c2dc5e251d0414 -b38b5454c2debaf1a4e9e467c6205cfe26d52d1c1dde5356c089abfd6a90dbae89525442419f108c7c8e82e34ec3d5a8 -942545089077b9f27304d2d6ceb3d549e983f100417e88332bf05bebfe8d42b75a96171ab3bcd049acc859f3cc9ad1fc -b9d444777403590be63076b5dbd9325ad58c1eb244dde2c9628234b62ba74f6b0e956642af2d08cc65f82a1b2e24bfbd -aee8deefc7ac67882ed7ee6c01c08d7739b6642deb2614064c69ea38c5c65e06cf609bcaf7db74545199cfa6122f23eb -b3e476268770abfe0cd64a4f878c58c027ff352569d8cf571bb067368e777eba6c003d344746fd006c8bbd474fc3360d -858137d63f90f66b9ef2a38d7ebfdae1bb89e5bc1d9032c96d699ef276aa2d7461366c00de8c47de9231d9ec436572b6 -a3dc8fe541c9cdf89d83753347d8c573c49e8471dc07b5d41bc48ad1b10a3fdc218adaeb72bda0f362c8af8e1194df45 -ac75940ae476a6ff07cacf70a379096786d10a5a5244fa5c466bdd8af69b1f98e97a3a27877739dd4b223627e0ce6d55 -8c6809f893c5fd03ca80d845147a82d8d54bb7dc6a688733b1404dafc360c45d5ea742f98f6a70ac2decfcead05d876e -b0818eee75f08ab207832c591aa783193aee5742147eebf75cf7f1eee6a6d8855b309db4f7ab51a16ab77bf619e14fef -b339ac167debc92cc9132dce076bce281e7f1b9c88978d36e1b5b9bdeabc974af318ff142f746319681764bc4db191e3 -a51dc040c75a8a8bc3b0ecef47ca313ae13d9560c782ee014257ee728a09432c4486a3f87b5ebab690231735fceadf80 -802500a52dc271c52f893b620952604b79d25ad243489dca7cd679b22907fa85947c88dc04463268d25dcccc8a6c34fd -97b136a881f500b07e5b0b79fccb84b93dd108074f92a1cd76e441239041ff389dbf03483fe76cf7c22a5f40b73b51f3 -9155dfb5d7f7915e50da7a715d1a5ac5b43d7093546d6d342ec8b69d47a86cfcb9dc11d8079f123854033b8d3e1ec928 -9423ac1e11f70b5d0cbbae48b7a5be8350387460631126ebda095b3b33a7ee2845776aa20ad60e2bfaf975722d43064d -afa907dc76e03d10cfbcc226e50e3bcee56baa4acd8db2cef8e484ee7b7bc536e1765e764180663710c4396e22fb4dc0 -8b6fb4bc641fe2147d3394322418e2e8e091718e3b54dab8d0d6bba687bc300d73cf1b17f81e2812f0943a8bbc1de538 -a8bb533bf42f56edf112b03d34eb64f6dccd57251244f39daeb6531af650d0368f6e4a0f9171aaf4f5a5b4a17debeb56 -8d763490dbc9a9b73bd571833afce20654348cd553a69678ec89454c4cdac044ed3ef0458cabdb60ff35af5e63405961 -8d3ebac80c55b7ce726f4cdac41c7e2f6a5ff4ffcd5f1803c463ae524243f136dcd15f9bc74f8b271ce90a4776c94868 -ab63cd85311fb9889041e692bc9d5c1153b26a805b511721154d28f11dc8ab84733387fd20cfa30c566ab2f8e066af4c -a506ba11063b14f25c26c92667dbd9eb67c8585d05d3980284aa19a09ae97599a1cf8d7cf45b70a32063f1fa3174d3bc -b834434632307602d9e046de6f625af5de673996108911c6b05d6bd3e2aee17246b2d860f01dc2d6415fa61c73110e13 -8248b69f51196ce1e15fcdc25d487153896d1f74818a5617500cf0bedd5180028e6567533536919156860e34ba275f1e -86a5ed8b6a1e9d8d17b69640220bb80c9065198c8f7610d4ee6a60d2d808508771a84d6bc679ee4db34f43f94315e0ff -8fde55abc106b2afdac3b8796f83c8ce1b90405532fd586d349340c4d7a4f4c46e2a56fe2663fba770a8004dc7b9d523 -82489db9dccdd13293499194068bb4ee8fff51f74f1b504d203c5deb5216287a6d614a2e0a769d4c929bc103582c92b8 -82b2d71281cf886e80e09ff907c1f9213dc444c058e965f964bd17fd36dc0382da2449fdbc3aa7b6d07004d6722a5848 -b0729dd38dd64c441e81a94fac0c8b5b3588081e43a5b0298bb576b16a9713acbdf09b9bc2499c677064619cb3a172c8 -97c4bd5c97182e80f55e82648e387c4a3362c6088381e96b67cf0f04bcdac3dc670890904180a5388b97002c70481235 -98d99f80ae9c59c921c6ff71ef01c2ba283f531ec32666cca1fe7dfd9bbfb09f197e9112af1761068cba8d6319af5d74 -b0569d892ce82d87a3d809f4c86a88ce627ed420dd106ae49b88b8c470ddb081a3dbdbd92d7fc032a7082650e4197ed2 -8ff68d42ec2dc5b13ff5c7ef506c619c4bbb0f62fd4c08e320953e5cddded2aa34624c6c5768b546cc2f00add0dda58f -8b53131206c80638dcff21d7f2dabdbc6faec545f19ab1f4f2bb858d6b01d87adf886072c3a744d58124b8a7a0c87573 -8b9c9aa127ddb950cad4fc21cd7c8eb802cef6db7290664b1773b9744836450e48af503009d4bb266ceac83d765b3b9c -ac61e051add512e749588e2549ff55f3e6fee5378443cbf64c80cfd7b260cfa63f16fc3e242aa140ea243435be28179b -9240700fdcde974f319a90ec4a9b92a0323424fe39e513c7412c621cb33072d193476118636bd2655867ed2816e03034 -b6b05975d0653079034f9792d5d8cf5743e1737e1b3860e431a1e159199efa5a55b2d3283f6d270c9ed3156a233e858c -a2ea8fc31294943a3a6d02509cf8b75a7b5d94de917ced468fa64a6c24ead4edef11c34782eed848792b0570219fb77b -ad0b54dc5dceb242c05a7f7c529289c8caed93ebe743f6609df653aedffbd7eaffceb53a18dfd109f28d14c80e1f7935 -81e4d4667900eb5a8434e2153503b2318f63708499534a8d58382931791eb0ad0522b41cecc7eb0e6ddf99002bd0127c -a4c5c329fe159bdeeaecbaf479c60c8f43a58ce613e135e9e9eed4af6bf5b6116bdbfea31c82bf0ba87c3f651e1464f8 -b95eaf48a9128df7f970754af926f9865c2078cabb4da4918d8b45e95d72748750ffd12f1d8d3f76cac0936ad0097d16 -8567385d52e6f6dceeee52f6b690781f7c05c26f0d20912bacc38c23afe8f64925ba18f8b6464d4a0557670ed0cea232 -8f7483cacd15fb7e49b2f8deb7ab05e64bac18ac9dba475666649c2cdbc5d6df0d5e789fdaaaa997a3b524521f0470ae -9252efa0698c0cb30dd431a72a0f5f2f14429f6ba50bb60f7039df45777557afe3ae732b9283b4a814d2146a8cd8b7b9 -a54da5287928a02cd5eedabe70cff80e56db252e2811842545beb14f25ab67788460a71ab8ee47cf0c1a5f8d01635256 -991a80279c622565a03929c94590f33cf0621a79b70a2168a41a4376bb3f0dd12a9ed9b16c0b6a4a59c50b5802449874 -924ff5d3a6f0ff4ee58c3674319971257543d2e19f0ce3fd0b0edb214faee920f8d6199ca794a173363a9fa06c96d7b4 -96b136b8df76ba24e4dcd68065c650fdc224fdfc9c1ab6410e008fa5b9580680c3c85801fa217917c620c86dcb5ce3eb -95934e64af642e7d45ada1bbe8b9fe972877a674252005afc34ec2e857f755ea0d77e7759ddb24255f21252d6c739305 -ab14c6bdd6d1ccaf69e0dfc6c832751afb70f89e4800c6fafd22db2e7e5d6f2addab8b1267c8f3fb85cee51c761e69f0 -87e2edb8dec1253547cece2a7e6934b0299715e634d599316af0f076c61726c7f2aec83eaddcc9add1c397cbc9fed0ca -91170baea88ba00fe00db375e8d948f58061f9e7b36a4573031b9996757afcc2c7e9c2d9642bc51402aa586569f0a398 -89d99b120e4565b0538b2ef4f8d8c05997cdbdf61840e068054e7f21677cdc1dc2f63adab1b6814225d14275c737b0e0 -880c2b79bff714665e9b3a0a647773a212ec5f0dea37ee6b29ed6850692055013e108a86affbe44d1abd0ae80a748950 -b564181f9ea65ca25b1ae7f25eee84b73f9db109ad1939e6b9351663ac0b083fc13e6518ad8eaafa3caba9ab959bf7c5 -93cd91391deaa726320574bb46706fd8e30ffc2308290c79abfe2d234d0f0f59ee4c38791e3bbd8c3f840a920489ebaf -8e846d48e7b120b59c6556a0394d25f744dfda0cd58d4e70029837753a82afb63a015e79157fe8c810cc68bb481d19d6 -b36904e7dd71bada7c9b9172e4a6748287cfa0cb6960ccfb7202a36c57bc28d351e1f5371c2b449437cd266f2d22e7f7 -8947c11af34a42f314983ba9c673e62fcf44c6c1f733a697351e1b8422a75338a85bb19149fc130d01492ee18b3c9492 -905afc0103e34fa9787102fbb80967b8c917bd03abb02731fe49ba1acff1e96059227616cd21080563e92dd021117a84 -88c7acdc65e6373e4c8ac6a13d1bce1d534aeef2965a4d9f887b2e823c7ee7921db1397df5cb5e7f12030e310172d6e7 -b028c19082411efe8a46c8abfb9936c005e766e2ad3120be774172f16419e2b04ba3f31132ed2bc209e7214c2d7b2b61 -b6b3a561d583870193226391ebf51ef47185ab6efb3556ae59106b6f266776064e5cdb66f0c93748e60d557db64e8f84 -93732aa1473dc2e50610eab2c8152f2d96992fea840ac2d82c6e2c5760d8c1c05e8ecbd69e14d03713f43e77ced9d3bd -9734c433ad41a8fd91e161de033a2a55189ae31e2af406d1fae443a182bf1977dddff93f6fe2ac7d9c4fb955c26ed59e -a1f305d17c36c06c515d30fdfb560f899e80a2e2461d0bd947032e5ec764116c7ccbd528ea42a3b9351e3c9b45904431 -b517f46b582655e551f766930637e8dc2a762dd7a2c54fce429fdc4cd503e9fe4bfbf323f50860be2c18b3a17d528654 -b395b5c48b1cb0daa8c156188b390a78441c8f16ecc8650520f9f2914bd1d992b83849bb11ec17a47f9f2d40d138e3d1 -9147b715b62fd50e59bc96d210e10f1062c87a90263b5586746325deeea89e759464be55a09b0548766e13bc910c4d3f -a7dfe5e7a39767d14d531d371b92fc4979d326ed0f966eeb7b4b4252d78117bf5295b3c17d1fd636dc2c0097cac901c2 -aa3f9fb858b30675e9e57170a1835717521eafe4bd0a0690b10020c7a753951576b4c7dc80cf9f042894fd5741b41b1a -a1f11dec034733e862cdd4aefaf0252a9e8175b6d4c834b7a7d30ab884bb6ed6a1d92bb0e958f0082085cd80157a0e40 -a1751d7452b7c5596fb801466d8d07a70831e568b8ca66fdd75e5898739709795a5768726ebe13c469b1d51092d86a60 -80acf49051b7caa6efe78318792d05401f5246c5b3bef25170b2a49adfeec8048ad5a5e6d50cc498b23896176a9d9669 -94156df9959c678578ec6e12ac068f3a28d69a981443fc35161d14b1f0327b8424746d62869ea9377a86ca6fd2c95b5e -95dd91b1e9b457de913a65f198dcdceb1fca75692853bd5ed44eda6343f32126e6aa2a309411e019dbdb9519c865b96d -b2516bc36a726cf2dd5553e319c64fc508682c7446a2a5ae696e43f1a8c129ca9602f5a41bfbb57865a9dad1d56728d3 -90cd63b4f9216fb70635e4dcbc9a6c5874cabeabe4f9ea83bb923146d03366d9befa48b20a64f3a2cfdb0c3a84007ab2 -a55bfe9b33781501f10d5632e8f5330841eba2d0a64b0aaaa92db56f014b5e44dbeda3b1f5b2e4c17eb6a243977b2a82 -b9e84b3c617708971f5e174fb8718906f9bd353f8b0fec8fa03d1a6e4bec20430212396a5406595343cd15777c5a3f8b -97deb79dd82185555442f91fb9a70cbd30a564751528fa0df0a681315b8a71bab5073716908ee0546d70dc41efa3b53c -ac77c2fe555584b9cba7438a4e3904958f671c49536f185cf1f3b25c5a57ea65e15554de22def94c5c623e8c99e47a9a -a27c62d39508552d79d2899bac6138783f308e3befab65a96a1ae4ab108b799628cf37db1ec72859a0ce1ac68f68b106 -a2aa287741f03e31f2c87fc37e228279b1acb886f32c6438b3e9807b8126da875fca7f194295c45531e939a13048a882 -84df8999c4c5ecc807819248957d68909d16ef64d94a820dd0d266cddb6775c9c7464f0b2385b7bdde8fc0f2169a4177 -8388e1a1babb941e03806b392fdc1bbe1a01438292ea1db4087b010de0805be78cfa56d20e9ef7c8b6be5a04bab1b1e0 -8cb6ec409cec27e7c4537ee2e5bcf82a33e7cd4761d19059e902b6068a9744e897a6010e2ab42ce72625cbc433892ec5 -b6e71cf74455b0f506e03eecc0976831ec9a56eb8fd0e39e5e12ae199180a4c6e5123174ddea6ce6cfd7a414cf0afc5f -815dd267d9f67b4d229a798a499b70ea2a611f3bf2a9d3698d1105890a2b6462fcc7c6ebff0d5d709707ee4ffa981689 -b4e5b7fbab4d8a66d1b167a5acaa4d53949e1fbdb00107e62b727b4b4b2cc70e2685cd4a16266e8d13ab176f9be09c10 -8d1bae7566ff551f06baacd8c640d0d04accdd49fbfedda0841914aa1bceaf9f3f27344b80bdf5f9b93ada438a4e6d68 -adb054123e27afd4a691d2cd808a3232ab58f56fbd514935caf47b8193b4c64aaafed4d08a7a10ec4deb66be8c292e64 -8ab5255246e01478ba7dc6807c84850308a719f8f8433eb049d5b11cbc361c08930722e7e5878ad99fe1586b3d11cb1f -90e862be1e3d0824106da33aec437a87dbd2599aeb58d46b4a39a5f651097d49943c3248a154e09e309eaa7abff3d500 -abf16f35e3b2b29a72cd96802c900fbc54100484299198b2d40cc6071945781cc9bb3eb43f6ebe433a14c1aeb172929c -867a0f396374cca7303845d8a1e4bcebaa53cc0fc2e790dd58cdd0b5ff2b9a99e18ad4e57aa2b061826545935a5607b5 -a6b6a2e22932d7c9ba8f27b1e1de8559631a81effc77ed2cd7c45c48e49ea7d2f68c59d07a155757493ad82f733d93ee -885e4c3904c545c0eecc9cd02e16d359ce69a78e3a355e7fbe6485762d4523f2604f2f663a4521152a8bdb6fd4a9d4be -a668f417391b07a35c5d40ee5212cb7bdaffcf040a4f20a3d7e70e9d715bd908d4f8fca87a7dbf7b676e088ac8651ee8 -a70d67f3379e1ee0708c34c4c7a7f552267ff679460b9d8891549077c724becb99ff79b35bd80420a4290f293ed4133f -a523cca782ced0d8a3f7e19707f9c64ff38495f739e035bcfb5483f202b209c07c50c764eb28d3bd8cf68ae093c46f19 -8ce98e5f96889ebada090449ae198208cae5c247cc5f6fe7800b4c2254b0e7f2475b632cbd5021a0871b466c5b943dc8 -a69cfdeb27ce1163ae6b6b4b5d46b49507c7e62789f2f90f7f5a0fdce79de988c755cc9afd8397b1c02976e03589f985 -acbffc94dc0445f7797a0d83e5107ad3ec8bf61620fa83e73a999ce4f9b6bbabb00245a619aa6f9b082a2711bad5ce8a -b64162794503c86e478c23f060228105bab4f3f5d46582bd455a94526aa6d71f4c9630d8d63854c8c67aff3904681e0c -b1288073c012a0b2b7e31708e874106031a8cc98b2c94ad0ef1d7b9df42f429f58caef5494f6d581baf12970cded2a17 -8d7ad217c3c1cb74cc301540a0e43be6d74d5a3c0383ab7c9dae57e25f8725781735b58301ebc014476171725299782a -924a33c759249af270617767101385910494724a51fc63600836ca00d06f0ca86a4a0a85e5e87cc29e404ff8e04d036c -a7b21ad39bcacc96cd857328a83e5d26cddd0a5bb2326da9a8f593927ae7b5927704acda9ee217176618c964d0452d54 -a5c3616c308bef98807a852e16f146859b0b1f31ea8a721941d90abcbe37eeacb4403c6568480b6d6e773bbb94a89307 -aefaa1033e47673ca2b68e4c945e6ed892e223146d4fd24219304c2667777c1b18a19488b73053cf7b0e6e09ba1278e3 -b308c690176bc43051f51839d3ae1636f6de5a57c626e8def464820ce2f96ca09ff26294a3dbc9b4573cfc42dd03bbb0 -8f7b1253ea9e257195ee92c54de41f2e7a310c90602a628ba3180e059e5bba79d6bb8110d1964c59daf4b65cd9735704 -a387f003f7731b81bace54c8501a3a2a25d8a910cbb28dd603ed16ce61ef1df34e233dc8579071856d7198a071efedf6 -955ad5523828c0fbe8ad6a77a191661ee9c8005b741b7b0439b76711b6992795758d76133399d266df5e494e4f86cd67 -a44441964f5cad7b54d0105f162ed3ec40d12870fe8c5c30bf16238440143b330ba986d6adb00c9626747e99449f765c -a52df726de07cccbc77e81abf4f1712657c9261f65feee8815ef0e8a4ca61b8e470503801f1da8a23fe6d52f3306807c -b5d239222c3d852f2c49997e76d97b70bcfe73d85e81258d9781f5f7de87f9c81648bcf58cfffd554e4685b2f860e6d8 -96f0193aecbeb1540678f1a3369401e916ee75d2a85f7124c555466a3def91a5d8b5f774e3156a163e1010690d457c5d -886b9f4965120d942b076d053571837780232e139c3efcc6bd6c64eabddbed2d55c3a9a06001bd7a2ccebb36135edf4b -897a1e4e9f4eaf755807bed984ef0bfea251740386a168061f4386819acaa337fa6d3f038b4cff9a11926e68f7888f90 -989d9706f8396ba422a34b55897b9e261ac1ba0c7a7a11a30562ebfab92473b9e9b604ea8baa6067137a4ded070fda10 -96376812651020f68c6a1f0aecd04591fdb628051f01daae179f7008ae33af5abb42e8f304662c9b6e2584e8b02ba6a6 -9344e6f3ce42ada6281d0fff654f408e61f0acce81e23ce47466bf1145a99cf60dfba9a22304efbb1f428c92357d644e -b90c5463445156c8de69d8c35db656a76f3e195c325808396a829c11c06a7503f3c092816b3f23a263d56d3f2c075ff7 -b4dc6d948f4b67b513ce27fd12bc8efe43813c119d01b2da391d01c1cb0abb7d51350a5446e0a72a6f8bbbde2ee4b0c4 -84d208ab983941bde208fd71d58c7f9335e14db237cec42df453155a3a8dcb21dec8696a1334cfe5d035c192fc44e88f -9577996c78372d2d6c9de27d497afb29c918bd894bfefad9059bd85cf2ab520ce1d517994724e1567f12e385c126f26a -b778b9054776a2b8ee81be356050b977bc8aca0d0a202be91d56ba89d8a384bd29c5c652ea084709d4fb365b107962b9 -b7ea99f8c841678dc854527ad0c8ffc700b43b5b36b3d18303e51175b3901b144c53e22eea6ce7cd500f6879a80a8c21 -b466aa7d1a5ae3d9aea240c8114b3dc3af38f7d8f1e323800a6382de5766f19626d07cd6ca6eddfc4d71a43d2d49a07a -8a72b1ee7993f16400396982b6a5198f0de08821431bc66489189d5b364b0e36daff5077b48aff1d55c9a88580cd1dc2 -a7c4dd6095f8cf61f42c5901ab67e9d1ad21a42d1eae9ca5e147a9396507c7a21747c2794f71ac66002840f4fa4e1dd0 -abe40e33cca787e7c521e2e97fb5f95cd4ca7ad6148a505afdc94e0c003e4903b1524164a1df2b2a1330fd800ac33b7d -ab8e1930b1e592aa2379cff636e7fda9fd7f05b358f47d9cbadcfe35fbdee5bf06469fefc052f62159c10942ea2bc5af -b28edfbfdcc27c3892d64e7e05a2aebb173808c020186c225590b03d91dacb866108370f2c14ac97a6d20d95a8e32f8a -97d4841704bacb06bce2778104e4437c930fdd9320d85cac383d11ce9246525ad5167cbd63ef04a8ea39c8fbe3d88169 -b4b178a1c3ccd3344831936b784203919cffb611cd18def1a52ffa2a8e4286f9f9681bd48dff9b2abfe62da5fd619fa7 -afb01a4777a128b02fc22e282e0c4ab1d86246d8e0813a7e85c51907bce079766ae40c31d3c440d5f99c92e89d3a683e -91cd070a607c20140c1f35b25057bfa20290b1435e99c5b33068c4e5755ff8f1aa2be61fba28dcfc131cf881aa1c39ec -aaac82ccda92c6090970f60a56668c011ac20dcab26347ad40585a60b5a9b5a9af883307c55526d4eca1b110a079fd3d -a7480de83b4cbb2eedece3d3b27b8d934e9183f448d56d5f49e0b63e24575014a94e09d406d7ca5afda08da9f4eafbc1 -8e568ae356775b06d963b440f75bad9b5977b7bcfb8fbd1dbb4daad5192521bd189674654d4ab86ded4a6be5fee27ef7 -a501a84cd0b4138383572fdd09242e3a748e593f55400fa7600698d4f916a2fc1feb96557a34f4ef0f13eee580fe9f54 -8be0f6b98d52b83e9deccf09d05fc4a7b4ae1cb11972f01baee4fabdb804cee2b0e9b44a1385238f755d2c1ce395cfa5 -afd01e3658ed9204d39fcdda2d79239b8c45dcf80fda8a680a8797b6be294e7e8bf56ce345896c3f08446e9a2a053a61 -851f0def025a50910bfb6c2fbe5ca62a31426747d9cf4634c8faa714a014fa22586c3eabde84e23ca77371ae25d720d9 -90a1aa7bbe7842cd361d0ab2e16203a56318885d2d32409370ffb64ef0ffd3c8c57658573a0714b04dd1595aabfc8f21 -af56f30bbd796de5cbf6f3d041c2f649d0f36e0a1335ba923eb1487e0b29d0ab307a1143e6cabb79674ddc01dd9a5cd9 -8429afa5476d0f3a4eed4104fdeafb79f80e94e709b59aa44b4caf0a94bf75fb3efadf76e96389179eafc389fe896efa -91d8399bcc3b82f0044b9a697b2bc402285f6d2e7b76eec25ffecab769f3fbdd45d20897d28a8676f090edf847eb3c70 -a06f8d37404ae58c35732db58c4c6270e4311c691ecaa7d89b3e9b2bb1421ee3c3cde555d066340c0f2479faea1ae162 -8011fcbb711ba6511960245c69a73fa99167eeb4d238426bc31ce359a90a2339d5936042b281f3ff3eb976357db96885 -8dff2bc19830b4a58d2cc3c1598d060da34c8fde11635062dd4222c96dcbf2bef79b339c63fefdb1653153ef9af79c48 -84ae7869e2405e326bd167249f89c2e018817d3edf59f3db8adc25f64836ea4606c78158cb30020a54551283bcd9f39e -b7be6cfbb7cbb7788fd60fbfcae3504d441b0af3b46317944e00a23079c605c08fd116311432be5b378ed8a11da219e7 -a3656ce4a79484e365b6b7f81a9dd72a09746da16175a61794bc5fcc0c3dd608751ea2cfcf7bb0c14421e0b05d94df75 -929d5603a936bedc69ede2d1277692012d0c820a23915ac6e776b832b9f4e0e6276fb3b257c7abbca32ea166d4482149 -82d47138de8b6ed4bdaf69526ace4f6fdc50fe5abee63f1c6d4447fe4948a84a63b7963c8a65858442856e282fabaf26 -8f8b2d05e77e9e4e2cc5229ea98c5c02ef9d9b6939ce6663d98d8e2dbed73af3d41628662c354972c1b48157f8d3c459 -9353ee31f477b51558f4ba5ca437d801f59d01ed995a8801552f8c578d1937997bd76c31aedab99fb5532789e72469b0 -941f777fc9115fe948f3a979e1ab87f133238935acdc19d33e1d86a1a64924eb9008e91bdff8d650f5e3ad06db931234 -8ee79ecb7d07e3a5fb80ec15c085898e97876448685891e09ebee9aacd5cd0147715dc60b6f75b601fbe83598f1a939b -a96a50de4fa25367706c99abe9dba95ce1717483f50692bde7c8c3a6b427d02d59ef6e8bee82762fe774f5afa528f0d0 -a451ff58246340157fd94d028ce1ebe5ce49e5ed87d9b61884c8ad903ef9b697c4ab9e5acf66180a89a17749046c99fe -b12739d77fb96e9e93065fe279307eafb11c795da2b9efba4cb239425faf687b9762235700d9f2cd5df9cd9fb2b36e3f -a665e34895d02e68f1dee7ad8090558514720ff3e809cf46cc06d1e1274d219fd08781fd430367a3f09e2c591dfd7cf4 -a262410cb60409720ce68935e91c743aed5eccb4a0427449f32a4acca103f9d65413290ffe2cbc895e2e1cef96ba7c6e -9597cf4d49db896796132aed4bdfbec71ebba08a617a611d1fece75bbfcce902e8ba228b662d0ec5fb927429f082eb38 -80a045d2bd30aff2267a5385be12c646b65b24a586c4f5cb1bdb81387e3ff8edd2358cc8e3c4c5c60cab88d4dce61d90 -80323f4a9fc78bc89aaa172f739bbd4f57f9321a7b8e9eddb74ee5c99d6c7b8dfe847f7103110f0a44d4e7c20ed29114 -943b749ab77112be7593bb2ac11094c66c94bb89d5ee2cc05316ad623a3997a38aec741ec93c24770adc670b6ad12e91 -a8e1b4935aad8a84112a99fd5a4d3786ccf1c985aca0b256c46d52a8801a132024391431cc2cfee760c25eb18289041e -8abbe403bf13bad914a4d5bb0c8709f5b264a7a81ba0542850cb89c3c45bc294f62b22a36d7f829ca80830a3be5832aa -9084defe85d170967c08d1f5e74ad1dd592c2b013b01b84b5fe3f2ceb260bde2e52ca22e4006b07f01e3dc7a36774e94 -a34cf1cfca622dda528589b5e5e36a4a68cee7e18cc621736e3e165b06a5df9a8e9f3ddc406838c1fe94ebdc44bfaa18 -8c5f5d7e98828d0a063d90d5f78bc493c46316fec3245d47ef8900241fffd5316e0d6d6f1653cb3b22bbf05286736c06 -ae7f2beef46b6645a6d0b3ca664c826be205ca6de35bd2809a4871f19368bd2c009ad7de0cb4c269c2934357e87c7f64 -abae2cd1ff7320d0803b6b5345ef9dd364fcc001d91fa456199dde24f474ff3d0ce94d460be9659caffe7ae0a6814217 -b86710fd69a6eeca8a813c7c1d643b487a32cadd70013a4aff4b7331ec08d1469fb17a06d06926e68f546e7f5238e1f5 -b42e9dd8d0f12f95a16112ef7ea60e6f4c76a39cb64e7f6bb4fde6ed1fc54fe8317e93160d736d97d87ff7af69ac2a41 -86e5561a7b621e68afda9d63945dc69bcd615cc099c84ac51ebf6350b25c9c07ab371ed5b160a86488e8213d143335fe -831c730524214b8368bdc619e5c7e55a0731b6c5ddd035e9d7cd90577a472a429e779efb0ce47320c8d3b62997eec0de -a3bcbb6c321b329ea2bb944f48ac984f8bb6cbcd38a5f80e8780257765756cd902d252a51804879104527bc7b251c1b5 -8b1a0ee0219a010653f816de88b05116269325c42811d717544468b3bf477953900394a71d56b6dea13e4e6ef9c9c5cf -a5d06e2a43d965e47d400343c093d64bd5d4adcbe3928093c80439f815938b9e952bf59da7fb26f459a5439fe60fd49c -b92df54cd0515bb9868a8dadb2a808d3e62fec12be3c708fa6c845c833c3321017e2f8d71f10b064fdde02b098e22962 -afd8fb1d8ced274650ecb6c370c5bbe8f09d263391af7c2f2290b5c99196ddeaeedc8b9b6173b6fa349872f58c83149e -b359418883d3425b1bb896a9a9e2a3068c19abbb18ebaccadb85dee713b14bca5b83992cf239cfbb73adbe2f07c63f04 -b8cb045dcb0735b02d6e81d9aa9906ab2f19df2e2adb5bff0533022c03a9a530bb27fcd45173faac63a8d13bf0f41565 -b8b8ed443891d3ecd807d3f92d8c2afe714a423b97019cec3690c24002cd0444548ba6b454e1f9934f01a419206896b8 -a3c28de7e71c54dfba701b7e1053a1719032bf48d0e520bf8d513d155d588d08d14af3cf1e9ba3083f8e59dc947ef99b -a94d1569107e659db2ca58864eb8feb03c83ca083c75a6d949805faaf7095a4f981cbd1f89a464aa46107a891ba758f7 -a9c98b0501a8c5102ec0daffddce83ab40bd097c4ccce66a8f8a61a3fc28564ce5dec37940092640b36a0ef6efbea4a2 -a473b784935b52ce73755894177ead52cd9f2a10521e9c034298fc0461aa6cfb03d499812189eddbce4b3cfb58774a3f -8c7a7984739a3db7b28b7ef10f081e2cbec93e1da39738d082898fc73e83db206fb52cbec476c9809c7de61ff5871b71 -88b87148a573e576d0a8fa912858b7a9876001d8364bdaa7dd2759dd908555119f6f580c0d3a663ff5c2a2bcb05fef99 -b169b58fa10256b2753221aa33dc4f0f3308a294b98300528347ea4e89128a1a1da502990c9f2d266fcc10031b3c5a07 -85b1f0e49528ec8e51112771686b5b9f18e4cab091f6f97dc9a327221fde48be87f59cb46e6caac6e1af1a8c70135e66 -954021598c24f5889a642b9d20488a04e3c78c5b04bafcd0a01f377cf24b49f64b1d820ee8a73f8cc193e1de9a106a6f -8954b280ae11638d6e9c27f826fe66c0ec584fccefda8665f75e0699ed640e8e74fb1945753f84baf606d2fcc804b1a4 -899303d3bfcf48d28aa49e915ddfe263117ab87384f611bf7d555ed141dd728a39b97eca74b6b623a20d44458f35a157 -8d792116aaba18c94069cbaf0da373c4e61662189e8bd0f24dd675531ee6f99d574f91844ace86e3d018c4603ff0e2c6 -876c457846f27161c796f2d063aac7f73c2197ce707872c828af81ffabe91a6f353c6e887464c921718425d046c0a722 -a0382a36d4f8007d444643bd5d85d0b6c3c892c7ef8158f51c878b13af6a5b7c8b098ac7a6e3241a6e13b4ae987addc9 -81d668e292ae20a5a39b55e6798255c39368d9b83ca46e986c343ff9cf4f3140e3f07115995b8fc2554dc0372e4acfdf -85e58c950d8089ebd5d0a9d852c9e78d1e066c4cf1f1e64b4e76356745d3eddc13f1abf177dd32f0aede2f190053f8c9 -9420d1c470588085057549b7e6544aca2ca329ac9b232187d8ac894b7a878d6d3ea351357174089943b43a83f057ab8e -b6ea12644c6ae73b8b9752f8eb8bf06312ca14d93fddeb5f79b92167ed78338964d620379387ffc9e12ac0e323f3500e -82767d1ca19c7672d38216bf17a8ca0a52aed5dca77684da56419430f9129ed25b6c547fce50c834746cab666ddd43cc -b1864c611fdb1b641708a5be8140ca0ac52d59d7c3fa3eaa10bd815f7f5e34413751f829f5fc0faa259064b73d43f4c8 -92f67f02d17a1ead3b01478687cf26b40fb32f055f3b34feff21de083852460e02afb834f61c37fb91100709891379ac -b640a52bf00e4b29623c9b150635391b4dd42f0016e827daaad7aeff6e6a64fae4d67193664bc5bb368c72b138c76efe -941c8aed9a85a005059b83d35f6a70dae2e2b5f645719b567de0da3bbf1d2b85704ac977970a7206bd98609182090160 -aa976af6c9809550721103fc8bb8359cc4313f672421a4ddd760bc4ddd86a036c1b4145049d9c8165335309fb608d6e4 -afb11dfe01bb6a9d2cc2c040e18152645b4aa972fa01b6cb4285312bcb11a317107e743efb53aeb4bb6f8a7fb7741f50 -95f8f780fae2878792aa3f60eab8954ecb107942bf07f0e2854173595eb2d4b914f4aa208f98a63b0ebcfbca46840123 -b1dbec7871209fea98676e68d7a02dd82179a74e389bb9dc0eaeb2ac2d446d26810146586b637869ddec4caac8281bcb -931c9d571e50dfd2e1bee0c36f42085e4aa4e7d80a1c3bf99573d9d09ff710f6fa27f30712daba107d43d263b226d130 -b080bc730ed34724851d00be3bba84093a296d6320fe7671a83364ab1faf922189ffe997eca0e1ce4ac2c4435d7b7f10 -8dbbdb4f82398c891d16dbd4169716e078de5d677d3d550fd3853ff6ac8d15d278f17a2950333545bab823fad09a4922 -a71bb5b71699082cc45037805fcd95e410c29575d229a556a7c5f2969fb6f957f0c63861048c65d5b73fc4680a5c3c70 -b5bc06a742016a20c60d61cf55006cd7c2c7b8f367968f279815087b2bda7009c1773b9c91b8a4b78717b2bdf6a5e96e -91aa31c68634a81c9784d0d6adf4dc85c981e122635d4e1f25604c8184da860b1292d65324d4bb9bd8a002572cc96bff -85484fa47e235410e2ebc49f4dbbea9847ea064f6f6776dceb0d868280fe88bf6c5bb72e24c0ed3cb0a3f1d96ef8c9ce -88ab35f32986f0bbd8502dc81506cb18638298e856934fa374480dc455463482ca780385537e7ea73c4c863107b74f7a -b3022847a668b6d5d52d0af14d594c3e842afaab5416e3ffef21224bede0e1bbecb0799ddb7e095623a3a6f28b6d5f43 -8802d0e6e5203d0018d243301c57934ca85a002f91e5763b2f7372816c7b3ddf719c3b743f2530d9b7330f4f35d69d83 -85709fddeaaddead7a27d3f75e5ac568b0c9691c797f1505f5b33678158f5dff96ab98b921bfbc83368c6763420bf949 -a45ddf8ed1c273d61578bf6830fabd4927f82e3efe7732d64a1c82887b9693dcabdad1e7a65f09bde459fef89c0eef82 -970fb837063e059b1c2b4ec88011131e8cdc459daa1e704095bd327b7c94115c57cc1d9e8b4a29d6cc4f20895e309c61 -b789aabda019356bc5c5dcb015f8e7c5da25150988af0d44cfb11d8702da22fbb43f69c4af889dddc0647745d162d91e -8ccd44696d8c52454c833b0b256ed0073527616ce49ef25a113cb9f16d41f39d27e3bf169ef0d3b2fe78f2a5910ec83a -9846a3ae6a2c339b09f53b6cb1262114d1ce2fa3ea43d77b04816eea6451e8620f0030ba428eff80d72d8e907c8f9e3d -80c18de89a31e2c8309353be974e42ca97dcebefc1a914e76b57609b9cb7c1c6298e2ee1bb35ab9d587f195010d24337 -a43ac7ac3798af0923ef5bcf2342550aef8551c198a31b0bc9015ecb24fd2633bdcffd84a2c84f9eb72b4e67084caed4 -8cc1551213a33114c8e6b3e00c68dd26b9cb3728376b498c95aeec60e7506a3346641ed5297fd4ead33c0e42b85079be -afb54536b43e311eef9f584b8f1074866f6d33cfc75a3294aad5aea870cdbc3c97ab6e849ef719e2e1e4386a8a360fe2 -a2c5a2240256c64673372b63359b646dcadb108d785b4fb16a165f4b3b0ab3dc3dd5058582b25ed7b728d56d5aa45649 -b35e3e4407b63edf3eb567fdbe03eef00dadddcf41b799c80a9c9e26ddcf0c6b0b9dc4df0a0c5d54bf31ac8273740a32 -a3ce737baa7e1c1c69931a5b2fe1493a06fa0dcfc0b819ef8242b4fdae8d63bec8d15561d4fa24ef6d6c3a326d0abafa -910a67b377fb17d3f9cd1f994db52eb5f35a4aa002bc1b7208b259b12c64c095e4dd65ffe54772f8e2773923a890bc97 -908c5ee131dea3f444a9ee2052c93a657d28f2f58e604bf08e51500a306decb2db964f68e87d5ac2f8207cc4e92adb09 -8f3de5e756409b575ac2786590fc85de506f0adb51450f5c24669bb3a688f080c1cc37cb8e7a3c8db8e25c49a4bd76cc -aa62ceaef91fdf09d2ac2edbc07fcc651584a7e7d7d93e7bd4bb4c42105144c2da32326b3ae320b36a2df8aed07e5610 -959fc29ce63dcac2b4dbe8180577cecf9bfbb6db6505d76aada43ddfde5f48ec8f6fed14fac19389f6c9ed3555ef7882 -984cbe54156763d6ae078d6a8205cb6f9d63eee390dc5990f5d8e85b9a19fef563653d3dcc190c9b18c2232a916b1409 -923b448808d9ac04488e8345d3fbf9aa57cc3b3f375af138b674daa0e5a864faaeabed08f94010478543f3e1248c699c -8c0823bf2706d9aa4c074673e9d221eb021de2baffe8b703e64e676b6801da73440b7793254fe4c8c48d2ff395e44bfd -93c9cb050494824aba0d57320e2d1dfc95c988bec46dc8d73f7036be9ce0d7de02e56ad1ea3dd8fc129100800aa639bd -9339fa01caba0f4837efca7a3d983fda1f6a479f63890db7f7beb837e3f6535b1f1d0788884dbeb73fa657410a4ad308 -953f213ec904d4540b356d53eb88f646a98581a6deeebdf99a6646cf612e5b07110839d46c57b76545f6879f12371b10 -99a4576f12de20fbecd3906e48dcc784cdbdf7fa0843c570c6f59f13cf3a559cc1f4882fc1d31015304090f83306280b -b07fb8b73793a236e58b7181df5a0a2e8d50c1d3069c475c6e178e32d14b6e75c45af60a8b54823c23ffbb316bd4a98e -98781507866499ce396730ee91a08e91d3be337690f7195750bd43a601a8f78e9475d5ebb43e347934429a4ff3db58b3 -972a5a21354beadf80d8a6e449cc4f072d6b747de293f075b8e0925c89660db9195a30188dfc8b73dba02467ae02913f -827dd2e21ca88891b9b37e10f0d6b6304438cd6aaf9cb125ea7ed822078a233f3e1b49a8bc65f843e9551691b46cf91f -ad3a4ebaccc157a7b880db6990a937e2d230875f509ce864fb0b7ba5febc7f4668191bf3aa55b85f3c17ce8b7d75b349 -976672c981d106fe1835188e202adf6ce77314f8d7c8f797aacf25f00d57f8cfea31b057f6afcb40b9f97df6ea387979 -8c77ba87e3e8fd5de85802a764b719d67f4edbdace75433af7fe966d3d18a94778c4414572b84f98bc6b5993a3225212 -84ca9b0435001c246143e50487a55349bf38300cde86219d29199e2e9137e262a1619ee7d6f6c44b9551319f1ea8526f -ab06e3313800a7dbb970145c1e89b7849db8a1e3169560fe2c64956a1f9d1d3157d531713a8d7c2213356b22fd3014ed -a0d04163ae987227aaba1ae82f74fd1b44387501fa47fa61b66728a0697155f48bb44b9eb5e87050a5bdb7605038db12 -8e76d3e50853ba5945610251dd18736b8541bf72bd643f6b561cab1c028dd044c820fcf79a5b45882e7dde0ba6db164d -967ec8fdee2e6d61f0ca2cc255f4e72c41a9c1a62150318be0fa508b424487d9254ad135fbe8dcda55caa51b9901eda1 -ae25c496f872f7380d9c64fc9bee0dfdc0f05cc1d2d6ea7747e166cae7e67c17a72a24a9e351de15f52baad355625d7c -b8a95f3bc67ad2a2d3cfbbf2de2003b7bc894b3f99f0364fd181eb11d154a7193b1df9b671a3a8eb8bbabafeee2d1a86 -b79996f818d94842175b06650a1e7819cb12c96b6ba37e61fa14b67684c2879e7d3884fa6bae06faba009329db2b0d1c -856e1478ef99338f144757fe4be68d935f0069a05b0a6209be2fac9ebc5cc669c6a80825d3c74801a54ff8b1a3777da8 -8024798b150aa722dc599f288cdf455479763a9bf776da74d5f9cf76026500e5a0282d840e5ae5451a0e28d507b397a5 -97cb767ebfc0a6cfe25666089f85e5a3705c108096a38151baa22308276ebf7cb3c04079ecd130cb8cae1689508d4bcb -874ff07def0f8d32f2ffce7cf31a43e8bc5e633b279acd7138ae938e46889e486c092ac34924aed9a4e1f93a91994211 -ab5b6bec8c81133b6edddcd048fbd526d59fc8a1f5acd7aa72d07852696faf5e8d305e85077450188cddd43d6c1aad27 -8402f5173327a95438797cee3b107407e8b277759c942bf1b1f975dc63ab89b8c43f0f4ce2a11de6e5727e9952b8923b -a5179a16297f7a0913ba61d69879014b9adb5e41813ac33acb8973e2b43cbc17a2f9a7d98210b39471a47b534f0eea23 -8f7cf3928b51b0b1bce18a34da935e7e2558595e4ebc50cc1cb698f0bf3c1ea0050aadbcec33786118d791218e1734b1 -81552a8927942591572429892e5a1572c8bc4fa7901395a5a2de3ce9f1ead122e4e5ffef6cc8434b3b18af1aa62e45b3 -8999a1bf4f22fdc884f9310e7a3f5baa0d32c04e887c51a20736cff3216f3dac5bbede43632d29704536d7f275b0be9b -85d9952816412a890a3e479025d1c0c8858337498ae28731ae23332c16a788cfe51fa9836bee73d03b253803096100a9 -b6a736447acaa6f4d83998973cd2bc3e12d34c6c076880e6765513c04087eeee5b5dfe9394c120a85bec8fbe127f1f54 -89302db4ea39662024c748ff5b22108c0f34850f0fda476051a89a3eba0e02a2294a4511666987d89f3b3bbcc334fdf3 -88ef018d32e6b379cea9ce35d1c12af698d8241c4c7468a5d558099f5101f04ac8e49d09b6bf031a811970faf02ed0ac -b33afb11f73195a7132430dc3961252251aef42150e9aa63a8c7cae724f467543a4afec289bf27e10ccabcad2f7f812a -b706315deef0529725fa6c4520e5d320a028b4607d47fa6c4c8ca3558afd68ed65dc072a354d263d20405bb13ca119f0 -8ba035d75939c1a3cfc72a9ad3aa4ade105880345eaad9286a182950368e688a182f6175357a2e62d977ff7ae08959cf -b47ca04b80107eefd3a596be2e990f5f021cafc6b7fb64cbb78802f9bb7bd2cec4f37755c451bb1fc8786a076e90bad9 -b6fb1676fbdf6cf95add7173c264b820042511e34dbcafa76273ef5e4500ad1208b274855985f0eff5196e7200e5a8b5 -8c7493894853f4e9fef5a0143dc134f03eeeaa10c80c5a72afb12f10ca5207df1c7bcefba6728d61f3f89d3978902629 -97d14d9debd4228be04f2352e57d9c8138d4e40228c269100930e2a3f6eb6e66f2f99807be0c9857082ff8b9a089049e -86e327360a19f6ddc8d0362cf92fa84677737064a94d9d0c1031bae92b85abed36193428199b0f66720be0d6edb0d28c -ac79bf758fe91d47d1ddfba62bba87f5e64d93f82309d4d07b62d78ad6ae95908e1989299db99ec52c5ad8c8f3d7132f -804712afd93328864a52a9f9ca1ae148de26fdec7d9f51d1bf8c0385959ddfb639ae0904c855180dd418ac21f9a8a7d0 -a789e15cf3c1e911fca7f6759a2c5d0a281c6ab744f29709b8d0623c1fc197ed9bf56b89fb0953baf261ffc4bd8d1552 -b738474bd1788f326c5145ca2a468d914ead6dbc338680f62ee21b1e5fed49fa501236d70dce5363a72147b0a8974c8c -a34019db5e8d5cb680a78c1692978ce0f3f8b21c1615ff65f3d103ed5a1e32884680c90d1dc18f0edcd8a506b1003806 -b1b1f26ed57a7bf77257e2ab1bf314b22e47f8a4f4c5cd154beaafdc34b257e9b976b26c8d9f1508498b6e8c9e9fd2ff -a5f645d7a75741f536e5218d4a38ac75f5f2d759e62bde2c9b628a4cac299b477a833bca98010b6c2a8f30b85f407250 -b3947ca7df831d68107713bbd52fa300411bc14362c37c2617780f5d621e211b8bcf5fb7099d903748420818d840234a -ad16157ac24899485e7eae71eabf9e4262d01b8f8bde30d7c79fd00ffb4c347d765bf2b4a30c260c9fe2e5153a3e1c69 -b1bcde4588570576872430e704a64d7130f921667c13101c3fb771efc1e0bd72c4ad4b8e35cbb98d709062257f0ef59f -ab45dce0e29201e79cb1da61cc4353840eb8b47db99319ff7802d2e18f00e3fa8d5e70aa6a797684b4a6741277ae033e -b6977424f2f5b968a4eaa9dc1ac1018ca51e6158a6a4c189f0adc94ea1c2f30bb33c57960a5c972a1800cca2650e2f6e -899f48fedeee4badd5b69632f78a244756458529f27c75d05e9c54cb29579abcbe4ff7567445ccef96274c8cf5b7d31e -a8225095071acb2610d28d9ce2645280a84c702f5f5040df7a4134de1144fe1a1b07d3e28d4ff5e2517b4b2bbae674f9 -b48316873f8245854568a37ad9c5fe9d5e6d9ebd60c9cbbf9e6f63c512bd8568e3a736039422d21d383378c77d8f10b7 -8b40afa65e47ba365e723b9e24bd4a13335455e059346187356ff9abe99cf71eae383ee33bc184a9ec17b32d0800f158 -96c3b7ad1e31b8d4ac0e14358655e21e687beac6f6b7b48dd3750641315ac7088352976e9804b9c625a712f9d4fcfc4e -914dcb36d621753286340077d16b36bdaa1414eac7a8e7ee84404a37f8fadda837bf4c5a932e8b0f3e8e673832e9b3f6 -b20a438985a4bdaea41b98e831537027f4bf19ea9c1ac5fd37546eef117cd3d41b9c1b125d2302ae3d41176ab5d9e9dd -94a4cf3cc42d7055b55cf58959a7715232a273e66ec6f83fbcdb79d01769f7e6b1e328f6b0a910d1f8cf7a5ba4934779 -a62b07dc466c2f83dcac7fa98215ce5bece548164e32b4bb3aac055b3c0aa68ef5cad58bf7d392e3b1d54ea6f0d9f0d7 -9870784890da6cb0223daa367163cdd41ead23c300d246d62debe980fc3e7de0b42576309ae35da914474b8ed2c5acdf -b0f28a74169391fbb179ffe8647f3e6228e75b409c49ba81d34ce780b12d408d2db5968e9664b9de6a7416d2f6d1c1cc -857697b0222cce1458ff591e1add39f5632cb3aa2e589a64166738d8c00855e354c2ed44c4cee8dd707188790fffe6b1 -b3566bb224742d0871ec5d15ee890755d7e6727aa7e2f374abe965ef8380b49422897545e2cf8fd3f58bc81f05abf173 -88271995f9c647da82820b042e59011121ac723b4d0a2e461cfc1351d89cc10eb7d18830adf1c7b9fca55ed3e910aedf -863a43548db29c9cf35f24c1d5f7aa984ba21bb924dd9e09210a1feadb1e0ddca98df47e970c230879faa5e7434b118b -af5c71b27157a2391247622a5029ba11d17ab4329001b01b3236f38d67ddd6b8902aebb48ee9c963983c16f6d8c53d26 -97abbcd4fff0d1ee2ea777788cc146c1b32601fd93a5ff9908fdc2de225b954d8fc0c9874c258dcb90ecc7fd169823c3 -94129bc418ff5d00ba3a3389b62986fcda5714ad25d25091db12a66e138a35a9e38999c4cf38fe7cdb1340c099c467ab -8a785f303473e763578a5bff75a069764e346224fa2dd8ee3105ca779cccd5939ed8c21f7369bab9947a4ca92d3b605e -b37d1644a00401b213f29191a238f4c9c32ba550db2ab3b4c9d1f02021a8f6972ab0fc76d0bc5b9c6291d5edb9632658 -8e42a2c87d7feadf1a2dad9dc822b40029eeb8afb785ce574a340929c4c6ddfe4d750bd3a482e62bfef1bdfdc36f5bd9 -8837b0408f48c8b975ae777b0516c569dad0daf607da51f187bc2c67d3f67315340848fabf7ca78dfa46b05e3fe33005 -96d53e8e9b14e602dec666fcbff8ac2a7ca0474605b294365bab5f5228d8cf0a17a772cf2f37f7de3607f7ea6127d0e0 -b286888ab9afd161a714fcb1954f6046754c1e3e398cf639bc215327057ae68ed69113481da88627839b551cb9660be3 -ae5747c882d3ad685e481b0b42907f0934a717ef5b0bcf110fe3125d40628959b879186464f95bc4a69d90754034c141 -b1ca38e7b1f87e4c878d4b878afbca750fdc2509f625a06871da830c1f68a6cb20dde7d51ec73a78454ffdf54451ed47 -82225700e9b32f416618b074479302629114761fc721ff492d792d4d1a4d6fec887185aa81395703fc8d07a67fa4d87d -a132ead3cac6087bc7bf5153f29ea858a115249d779419e5c52f4d1f2180f4631caf45ab7cf90129af68bf67665b8dd6 -afd4778ab2921b6c9c3d3e2d8ab7e33882f7fde3c8f66d6704f0859f3bec468178eb25a103b78ab092de5b694f2d2ff6 -aa0123ab3e8af146e974c9fc72dce94554cbab212336c8aebe618ea082c15ef02c6b47b6c575d262d1cc6b0cf2d11f47 -a5e35113393e82c0ff3a39afc99a60f90993d5e4995e5d21a9a395ae31074ed5e2244214d4dd877c3d89e52fac6c4252 -b2f476cd5d9df15e624713f22716ff01790f2fe16957b526677bdd3d203fa8af98ae58daaffca10f84a7c61e29ba1d79 -82d6d062828337677ae19ce13d27ef45ee55270a27e674946c7c1c762bf43af6391d77454dda4dc613b519f4cde43636 -8e86b1803d4ee07791269ec9175dc3d3b595197c089551e5bec3edc55c77532235e64848aba62e43936d3e9438635f5a -845b7233e40eab725c241853013d1884d782457ec188ff7ea535926c36da0893882fea2c9609f96b6d85392471b71d2c -a2090ef73e125c0809f2bddcdd7b74b4f4eae452d76afebdf47691d2afacd1db7c6a3032e9a4c4ca744bb496258b8ead -98e759616bf468bb4feedbebaa8df381d01cb4b0009a5ca5fc980426e160698abd6fcd2095cf964eca6f8d92fe1bfc42 -8a29df48ccec0ecb8b3d904078897d996ecea1d2db6b40b79fe51bc5dad04358d7f7edb6543d7d1cf0c1f54544c3d85e -9422e88414d88e5d84b17f9d2f1c50fb48e9c5b8de215dcd7c52bb26a6ea71cf92c90f3004c4fcb34040eacf5b60b06b -a643123915445bf0e528d36dd7f2da9a3b993f93a7fc9f6148049fe14eb5a0063575d971ec955aeffbdce069d0bc2937 -81741f92a157bfe12aaabf0d81121e5a8c7df2dae86f5fdba826167c4558103363c653a928babf4ad7e3e80634d26375 -904fe8e258be2500bc5566c3890a9372c9404935ba19396e8cd30289cf02bda13ff3d776bef56dd87ce57aba0a8539bf -811997c1d70feed33ae3684eee512a46ea91400b39638d405a8bd6f1d0169706f48d1c04beb1c5afc5b10879390a1a0f -a4fff30378dcf1f04eb97951b85abc0f5257b9e53b7bee814a5acf060919d73504db14d55edaf54e4030b4c1d7278c57 -ac84f2568084ee7a715b2387e3fa3b15e6940a27ea99b4fc9889c828179c55f29992b68d719323c2ede8ded3a4e16553 -8fa542c15bd29bcf72a34b3c56eac1e7d4e4f3b15b82672cd956d23a9b9863233816ffbcc6738a225c86d9dd13d1c3d8 -90d94517e7f1236e49ed6903db72c0de3098b42fbc76afae7abc1b09a903cf92cb1bb6a6ec8c29331e05b8946c2e9e2b -916c0d6b1fb7c74c0001599211ca37812f30c309cb6cae529c876221c5e7187876d37268776451df2aa44f91a3a17a11 -b9ae0c4f0c00e8b07b489e015711346caedfc7cbbcb36acf3a2ffadf2a8f11118f93cb70181c27443d42634b2f2f6d90 -97a51eb35da8b67e82d55fed968ac9aa42cf2d1348ac146d534344c4c7535c29ce25dacf9901abcd7e8c43a83e34e25f -b2f035822c552cfe3325da99f28aa31b847477a644402d43379947ee219fed751497cfffd3536c91f2474a94bf758203 -aa2fc0777c208a2efb2884dff33c459f2f6c9dd4cba360a65918c8604cb02fd493c8e5d26069953bba56039f8bb694ea -84c63bbbea15e06775bd39f39995afc613586fcbaf32c9ada1410dfdeff09b8e7f3dd0c99b23c678ee72e44543ee6443 -8259332662ff222d4d2f817bb94033d458e650e5f6e2c31ca84c6f3a4b3d2e8d1f40593083337a17193cddd960ea86c7 -899fc292aafc17d01c06cac50a78edf1f11c8c3253f4b32116625537351a1e82ee3cac67725973e3563fdd73781985b1 -92d3b9aab29854556666588d94c3b49d159c9ba9046487583469ace7a6b8ffa61164839dee24d28dc2fd36b9387b6225 -b54f62077e1e42e18586a03b3d3fbe3fd680dda6988bee8aadc95dcde46c215167b261433d6cfaad8e2b3b6207662af8 -a6c021aa10019319f944f8a77455ad5b153a502dc9eabd9d306be3830a4fa2539e3cb380355953c3581f12348b919214 -8cdbc2c995699cc83768dd23383fe492a1bebcdfa55fc4b9d1113e510a6f4432ae55fd57db732eb56265dba6ad452c46 -aa474f1710bf6556538fe389694b4fb737713dbbc9c93d8a879dd3aee8e004c2441dd14b5f4cdd4a98e804d031ce00ca -95448d62b1503e71d47ef4f5a01c60c938fc3cfd9280d7b6d3490ef331131130630425adcc53c9c96f262a80c3251e4e -a4535757aedbf6d7b9bbea99f4bb7bdfd1c99d5d976bd8d4f8c69ee09c9902ea81884d8b6f4fc084e12702fcbb9e4b3d -87796bbc38d5c2d9a56a65ca91a40530b57fc2a768e9e08a2081734bde163f39e069edc99e87a84b539606164993f30b -8cb7647e60f023066c4835c956186b9e997a7425cc38465e95be568ab448b7303977c7ddaca73b78f6bc137f25e5e020 -90584dbd8f672a349682effe2f775f2bccb1911b06d20cd02f3a6e30311c6678e5082ab87ee47af72e0c064a43592bea -8886147e87a552c74767faa64516438d6473ae275e72b4cdc174825696a4d7878297b1ecd0fe1a62fa4559ed232e9e26 -b739745959c324a62943a225140daa51faa8e41c8e20ebd68d6f000351101a89341641933dcb2ac5b3a45ebbbf7fb26c -814f858b4c709694472eae1c82cfb7370191ad6d0cc5aad69084fb8e9d81e90ac2fae52b4051af25f1b806c273f61e0c -a00426131acb84ee08684f2fc2a3ef01290e48e6b5f96bcb0459adb62f4190a4b2616eff2a2712991c48adc551ddaf64 -b37a1e92b72e3ba42b79dd997bbeb031a392e42606254965597ea4b8a2ca51f8c324619fc2b9f886e17b632ea3bee629 -90817db93eed264f49445d1d3a14ddc0d5ca93191b6baae278b4c48231a56b25725ba6f7ac0e9c7326755f0082b79587 -95b7f470ef1630dee768698a31398e8cb407df3b651a15493c38f6be6c7eb387148124a2cb1fe1237117617017c12203 -ac49be639391aa5dc08e8678cc690ff617e9a0ab40166285f90c2d889c87ac70c455a972e61cfc339db59be4394a0ad1 -a6f5a698508f8047edc45bd605ad4e88245de20013e7a4e51994e99fc60d81dc945504b24f23f7241f28059f4b5d6756 -a4d30a6db06153074871c6adb0ef4e562c1491c1f9841c110359dc41a3bc0bfcba3b49fa53c29b8258a814b8ba1ba328 -b25a500efa7d38f797395cbec660250f4a00d104459cdf7a15b541db3917e26bb7568526444d469d363040fd094680ab -8444d11f8a0c686e2b22642ba1b28cc556ab7311686028e3fb4040fcce22959b7b6cf244b77c711ba86e350e17411823 -8ce90bfdfa93cbe58421be78e30e471b2c6e6beb1f9b3f85031cbe269305e18d25a2170819f2699346bdd735b6f5d664 -b73970a3dc993e28b71bc236b3391acbd85a8cc622b79e669109f9d3ad7ce7a01a8686e75d85408c54bb70ff9771ca80 -a64cebe05fd027069a18f152a18be155ed65b6b563696e395e045c8b2f0455fa75c2ff41c1247e596451b36ddf258460 -afec84a7a480b09cecdeafd025ee3ee02e3b3338b02d26cb3b7575ecb895057650f0955978d1d732ca2e6b391ed97728 -8caaf53038bfad6e0651e61e9a44a39027d456ff3ea46ee9d8e190698d5a66938d5c5723dd7bc75f0ddab660e178383f -a91607e39108d2540b4b5c9d33d96328f56ce9574ac9d1d4a81ab5c938443c3d7014e19f77cd55ef7be0a408e44efa43 -a3f4c6629a3c0f34ea060a8b976096e6fd3a91c24d2b056e9b6b60088bb0c706e25dfb31079f42e0ec031aa840f46afa -96b9c7d3f47ec35ab0270cc57841e9f3b3f5bce3d26faf6abf6cf657b6e949ce0bd1ccdcf9d490beebce722aea48caef -abd2433b4003b7d861b35e99b51e2eedaea4831776e7c289beae2b561ad69a771233e3d6bc4a7f869d0744c5be61b5a9 -a989e5080d39d4031aea86c03b77abe069ea9b7fbc515c6a79c825eedd6a9bf6a0ced1891eed20edc605f9e25a691f74 -93ca5b311d28e4dfbf4de84a1e1530a9153599e0853c9abd3671a1ce04995e00f7d3092895461137fd78c72d24a99494 -8acebb0309595f4eeb990b7a1543f0633690b7469ce89884d5654a7bd2d2543f09232693a04e1e1b445e6e0041c8b242 -abe3858cea5a873a7576d641571965736d55d46f9040fec219803740dc2a5b43c72689e94c9b61d3c3c44dd3a821b694 -947cd395aef4faeca9b78b6cfcc8b2f8f361de884b29181266fd95b21ca6176e7944058e20cc77c7757fbca4fe445394 -8c2e50234c75d645f3c887693e2439ef42433eff328111b9c37aa3ad5a3b21678ee44ee2959a91610006b27a0f5363b2 -967253e02e34069ac676063aae9a493bc6d52b8bcbf1da6243bfeaa9fe05f8c840ada0a282df9c0180d05eb866402441 -a16a4c9a11686a5294d8329983c8a4aa0e6e5ad0003ab319b493842e8d072aaef45c3335d9a64bfde6bba120a48a72a3 -85187b866fbc72e5b42b91d76e7ec2647b93bedecb060b7475236d7d152d17f901c778b704f7c2c1d3d269341890c233 -83b192d925e3f4a1fafcf22cb48083b2f88632ba93c1d498539bbc4997f61f74a0a3b8d4947253a0daaca8999c407b87 -8338eb3e7f549988435f4f618f4ae1942c6756bdc28a80dba7ccc530bef161c0bbd20f77c8c4d63c94e60bc12f7cd387 -adc869c5acec5e58459eb804c2141e03e3582ce1fef7d40fc1dffa3ca0f923919e291a2ca4a60129e2a470cdb395be31 -9279068c28840f2c34e48e9a7e7e9406907ac14bdf4eec7b8c28ebcfe16a18fcb047015e4309f19e6fd73d6e6c454157 -98c4fb637a868f161f2f4222f93f3bdf13a61ec1f4e4c20435c150fca1bc0c01c790da91afb6227ed2a6aa540d70366c -9209fc7b307f40294bd9cce166277a7ade9c64277c600b3ff09579fbfffa471a887061e9cb5fac97c423eada30a8a52c -b1d63569d5d47d052f3a6e8b2c390bfac1e92098291a2adb209f20af875ebb2a8669533155b1d15b232690e26d399ab2 -a2c975c004e69e7b0f22636141d34adfb2dd1396c7355e95fcd0493e931eb7eb99b4df0f0f202945d7bf837809a29ed2 -818f48e65e337913c52e9256af134f4311be84dc332e3ac4cb5ef659b9c6e9cb34f04b0bcc0e2a3a574c9c3cc51d7368 -b92b63d0b363a368a348a4abb10661c38ced99a3132afa6cf002b81e6cac26f862c9d0a6886aede555d7bc453753cd37 -b4051275cef361cdebd254115275b0b86692d3802241cae5e2c75accee7df98d3165cd1de86226f382e736b12d9dbac3 -ad89d85749c23e045bcb95c3433eb8038139a51c8edaf06b5cb235549a2f9ad17589097ff8a350e934c8662a8879a3d4 -802010e6dbf4265cdb5b5362c0b197317f2435253237561a3a7bc6766f98b129ee06d370382998ae70080624fd65831e -8ed6a5b601a5ee11e983035f3109075444b063aff693b3601f87c0d76d2ac253459de48d0fee32330c3785d38eab5cc2 -a6c8bee787c4b87137f70c2c54ad3ad0955269c7ea57ddabb1a215e613e250944cada7f241430c0ef09f8eee29fadaa7 -a3fc6a643e1ce110b08344f8913ea7f8c9e44bdf1a02978df8dcd3671d9b357397df9857fb11ba220521d1ce40064ee5 -94089626bd9c81247f45e25e573bd6bf727a0e1a7dcd630dd5e661f65d4b6f35bdc16b64da648dfda404b5eab39d9152 -88362a160a95f01026a2e52aee3521e8496340f96a35351892034198740d8b6159175c60b910a4ee05af488dfa578c8b -b55a5b875f5594bf41949c212543517bb1ce34db3a896f93d0216813261aa95f73663c789ea0ceb2bf8815255bd328ca -8f9acdca0158df5ecea4d574e0ef0c256ab271d9d3d3bb4100761f5062f0a1a5d2b8a23685097a1a2b2a08287a2e2c94 -b6d4e3bd49a17fe7d929b41fb223eaf93141453f7dc233eaa74424290014a63ca6a099174b687048d59cefd41fc720db -ac0fa8aeca20a0b4189e96c57c85a2174338550855f9d0ff0c553e773a1a1c32fe3f8db7c8362bddf601e41380c9177a -82f05710f08f12b206b2ad6a2d06161c884b2511ad90b43fbfcdf54933c2360b7c85dfa4f598b5bdce8809a803d483a0 -a2ca711642fd498cfeb897e4072d13e43b5cdb2480449975188fdfbd4b471070cad941af03a2dd8938d3c376366fd199 -90c27a1df934339bd0821cacaac41fa70496900044aadfccf6e5fe28ceaebae5cbc500fd6f2f88c5552b7fafea79d06e -818651b7c7a6f691fc47a61ae4960bba7239007e14930f3a8cc9c95dcc0b03643047671f819e30d89c2d1891640fc13e -a88f01062ded714e7f2f1523644222cd8e8cb8e535eda88738f4b4b19079f4f7be664abedcdb618ad1de3e74689042df -8174282a183f3f393667352fdd60460d2199de16752c372a44465f8b71ca134c410d1d81f15afac839748447875f8643 -a358c3e53dd70e1a608f36a1fdbe225e28c13b5817dba890ed8e82adcb7ae86fa68ff6cbda7e02e8116c11587ae1ded1 -8aa0bc208a84d5a58b0206a8fe5ee3c8d224ccb86b11b7c9d924e16b2853a6c3623502dd60b94f8d720810e0079078b8 -8bca870eb6cc5f7b5f6b84f88b49d9a3994e61ca3f2ad963f28f925e58430887f5362ed4bdc2a2a38b5fb9e774a75cbb -ab86840fe84b1eab81675eeee17f85a500dfcc95dc4872e57b39919ccc71b702585ab9ac66146d264d2bc8fa39338a72 -87c46966a4bbf2523dde607852a40b26cf3431d0bde9b2c609997c0f29c5932d28014026862abb7d4107b28ab8e2ba70 -a91666a8c846a9944ee7ab243ab535e4124ca8bbb756777609aad848527b354060c484acc19c333459c09012670f03f7 -b7145784894c6df87d2ce6a06cbaa713e46097b5f83db60e5449e62ed5bf382a7fc3136e5599226a2fe7951847527c4c -951bdbaaa06ba8b427fc4ec6bb44e93e70692bcef6369fa06c7a6882227d27f09465f37f0a5868ce43ade188a5f37f8c -b69662dd5dcc9ce7bf24be8a0e85e80c8e5af9b030e740796f91de548569bafa2fbcb19d98e13900c76cae3fb601a8ca -9630a7eb15718a2324518f78f26a71e3c801a8e2eab3236be7623807321c128ccd79c74ab657ea8e115d6ff3078a6887 -a2f98c2084f8cd556cc1bab19398e98921ef56f6445f63444384efe5d7c895690c57d0d94cfd24e99f63f5e31859e34c -8c3994d3cb76fc6ac22ba2049ea4547db92ef78f009d24f08695b282c95e395f2c1477bd52d3f569d64551aa5e259b5b -b58571076faaaa547df9522b48c684b310500850339d79d2349dd8211bc2c8307d13cd5bb7571e0b5baaa013b502e410 -93e07feb14f691e66be756b37467f290da9a6677b8ff565964f010fc20ed9c58d8c712c4abaf012c787bbb22cd1473d9 -b4bc6159db1578111190b19aa678281eb2fcf7a82c7f699da7473720493e66e0ab54429da7af24315ed9f7399863c954 -93cfc98563f25b45c15a07780ae0a38c4ada52ffc1350233a3b45417c16cef92e7926354b761d0e0de55aea4c1314406 -820c37c923807790d77d2cec39f0eca63fa3ac6eaf0a1978522f0b1d293a5c46af3a0b4ca542cf39e796afc1fb3d7195 -b87fec722faec6a739355fd30a2757e5d184c07b5bbab8581b74eabc2da413faa6d11ccd65cc93f886c788239b1eefb7 -a183bac7f647a0c15b14089879a8aadb712f079bcf2078d3c65851137a00dd3ed7e47263c064feb19362f98180aa425b -996233b2010c20e0246295735b6d5b3e932f2aeaf0b35aa3dee66b6296f39e2e7ee95a7e1a15838ff3389ecc8052e315 -85c943e09a6c77e15d49ef4fe57d89744fcdb705ca370cdf70b3d84aeeccbf2155868f6790333f88fe36e08042ce195d -b88f82b35ae14a3e6fb972c47123236bb7db08b9f9f3828033fbf5a895b09b9b0de423f1caa04b3e8e754409b21f3a52 -a12c957409b6dd335964532ce3c045aabd280188b4d6ee809cef479e51dba030cbecc86b0ea8777cc8828c087006c5ec -87227fb4299efa535240793cf0079e952e971a18ee62cd71a62d6a5db921da669c5d8eb1bbda318ed5f3b03b38798a73 -84b5c7585fb1c98d031a0bf6fa8ad5484c7766025af552cdd72e7ae59247deb845f8678862c44ebe640a7333cef8391b -a94cdb0f42ae3afb4b1878f960669bd99008c7ddc24f2fed45ca521c60472e5587fa9bf97b315efee1f74619a4d9b762 -969a9bd21a6a90aa30fea44e397cc88118fd5abeb68839556194f9ab0076806aa320928a8ec94a47c4eade15498f5175 -b2fb215bbe7acc3baa04b0aa9be654afdc450faabe2702a0c9fa760c9e9389a58aa5e3a4c6af4f6f5c934640d90b59d0 -8be6a43071464e6c7dfb0e9a791a658214c1a95adc88f144d8349ecaa0e76b8ea5f88cfe95e82694bc170e49a43ec4cd -b75d56cfa1f3b61428d24784d51dd65b78b977bbb52cd71401ac7d3c2643f3dc097d6e7668104af402cf7e7e6ddfbaaf -811005c49d1be377ebd2fd3bea9771089a0f5675c55e9da5f31fe13cfc9d1ff8520f085918279ccbdb0363eda16f8056 -a487f7000c16429f2b7bd7e8bf4990bf26f666f8aeb11a99114d33e24f946cb0e3e025ec8c0b0721f9be101504c8a1ca -99b72e711ba7b97083976b2db7b97346000a78bff9b20ed910eaad02f6c03b45fb3f0f1217b328c3e2d87b481eaab52b -828429d387a0b83ac8e377b32db1c893a4555ca253b8e3159399cd053c5de726655a2ad39348c8e7ef11b37b0bca78e6 -835de10c73da7f0c07295a3306ffb18991334c86e5fa4c6df2d8091e8989f6454c8b43721b13696e1f665480a64284de -a4ea48f0cc5915993c83309df99247dcd7df4c15c723d168759175010fbe8d84adab8393707cb338fb90a6a77b69745e -9976bc842b06ffbc5afb309eef8964908802e9a5c733de4a8292d5d5773ecafb6daeecc63a8dc8847d76b77d4c3915ef -aae89156b013e4adb4bd8e7b6007937f0ece09af077fd407798e4155dc09a129d44fe8f8b5f6cf6b3c84746181d7f4a3 -81891cf2d70a8c326c6870a8158edb79babf302b4f9d51229bbafdf038cee39b97f01694eb719df99a62478bbf909a85 -97bdcb526108ef3cc2205aac074ef3001d528f56b4889573e0f4a3a2504232adf23880f7fa2f57bb787ff30b89599da9 -9778949a95fc663c742e70596faf91ccaf8b5b93b78bc2d4993480722ffe10bab3c8df3ae50535d258b6e749a0abb86e -88bffdb927dd88c1ba3eefe7da3fd6a42ae494bf282e094893e144330cf08e3f518f47aa1dd76d6f249cf83e6bb9d4a7 -b53effa345fe59917f4f1ae754e9f6b8fec9bd34cee85872b3fc47e52fee29c418b9406aa50c8d5a2e853d6f2056a49c -a616775e7e77e846066fcea413f0023dd491d8176dc450b0941368680571cdd236f0f83883d268842fa61dcbf3e4864a -8b5ae13dbbd07ad19bd2c7bdb48eb3c760244fe0caa73d28df3f0c31f5418f8b06862526f5a84bb16b2a92eb2c7ebc28 -a62294830750dbf43ea497155b185d611d75e767aafa8c2c30256f8a4875b6fdadaac429e8363848b39e964cab2aaabb -94b6973fb87c2efef5efc0e7dd7ecff5ffbe76320fed8a20d730f9e3751efe9e5db39981f45477ddfe037e18cb971930 -b931b6f789947b5298c258c8f0b221ca927c447f190f0d8afe2f18ce9b90979eb3247e77e128a1d6c57d3bf5523e787c -968259d9d001a08c0329bc19b2438b48dceb5942bc6ff9892d78fc36014f1b60a5ce7deecc7a808e41aeb4e26143aa41 -a52c1906f103e3fbee8c12fecd93f7b7d6f37eb733147bed841b32caabc880fd6e72884380a3cf93129d9800ee7877a7 -969dd12f0f6ef0b868e21539dcba5dc7327033eb546570f5bbf91b13f9c2ba6070da430538c40bc53a2ace4794514038 -a853a74380d78710c212bcfa92d3f9c433b8ccc6936356f3bdf923b8e420e1017bc530ce73bb8d04bf7a25b20594c753 -a84dfbbd3d9f409badc8ac2da5a0db98124df9d01bd71b1cf5b2b9c32866309304848a4bc1fcad1130bddfb9636c1b56 -a9599f55173e77dad54cfce6ddc77bc48588f36b79a98c156963a2f5397262ae07634a98ab9bfe1aa6357f78aaf89d89 -91e429b5ad0bafc09b5eefe600e179ef56f1ee045765ab3d5ecbd73eb201305a6de4382038b1350abc70bd1435151a0d -8785056b83a726622c565985e815847b63745fb66b138d24c985d6f42d5762c61ccd5172d4a3237222c881e5f036b98d -85869796ef180f500dae84f669b76a9b245e2ff4614a58d74820c22e439837b7d9866f480b72d88f44682be54c6dafb8 -a118baf9c17d85e22ac3315f5ba9aa4e230ca2a031906f99bc43fc750a0f96aaa5e6774d1cf16b492726a37db7b51327 -ac8e33f32c1cd14c6de14e75f83b8518bf1bf6f0a70e23ea0e5a29f096e2992f1259a121bbccc5252b9668c605240435 -97babe93e2016d29af74f776e167d82f1cf2242202bdcbaac4a1eba2b3fbd9e7ce57cdfbfe799a0f6a06a0e6838c4e99 -a70acd7e1f159adf7381d3f3ec2cc42b56232601f18ee62fb650e13a80954cd06d39a57217ebf4d8927e28c910671ae0 -b33ef5c10d0588df0b9d2d963912b294a2375a26bd25225f002cdc206a1cc058465c64180d348cccc899baf3d677033f -93086926eb1be21ab929b0098767611bdf1a853b6b67045c14f00714f806f8655be37150be1da05c5d2e6d9c66057bf9 -8890aad532a6c9b818ddb9f1ea12d627010b4120fd4969bd239a9654a05116272d4cf783ff8256de337bc01f9b4154d5 -b878977630f647a5ed7c99f59ca5eb653cd647277b899b918e5f667eb17b6dc433b56c2f3a2a18a785a4b5a9ae95f372 -975582fadbc276c9afc4d8ef767a66684df5f56e898d2a8749cbc2763982c013e5fd0ad0ca7ebc67758124a609b59663 -ac45e154a651857f0464db38afb2fb25853e8bb1eb476df31908b13b4fc86491d4f831c0a15ed6bed0c873b3dcff55e3 -a778d373e361753964a7fe4e1d28702c62a919e5203b941b04b0e74cdd3b4e838cd9b6dac3c39dd523f3227f1b5e6766 -b1bab7994941f8de4235e2e188b302bba847c1618ebdec7fb782241e9eca8d32dd506d254d865e0319c66396535cc484 -8c4ae5b346325f1d1609328e41d20108c4388bbe021361a86a1f9681caf1e6fd64896d72641ba8c984e153537317420a -8cd312c6a23e56657624d21f230a2c22d102badbfb2e38a8c067186abc5a459d0c78433ae7b54334591862c18864d7fd -8739d71181c5a657c6fcfee1df71756c3b6b8c48e8d97460fb64eb891abfd23433ccd08574a677fff600ffa5519a2363 -ad3c8d1e9eaa6f9122fb14d323318bb0338c5f9f29c719715cbeb15a2738493930542769b596098a5f505359c0314381 -a6d78b78227f8c1203e502caab1213092f320e77a6e9729e1659cf81e981cf905170e99b56c4eed1326320acc6aa60fe -8e5ba0e69e0f08a49ea4fa28ce0792f7ff6c032844ceef11be90b2215940d4b0f3e4acd5e4b189b189b0a0ef8045aa26 -b7b31957e7a85a640b851d4241c7b2f6af64f59ac221783b88c1b51cc4185f5ae6446a3c7137ee072c2eeb97c929d7ce -b066bb41c5818d6008349dc6015ab780633cd961b5d947062e14618c1ee1abfe42139c86b77e7f5be0c275fc3f5b8909 -a6597158957e1a0af153183151fbc4c73bbf8156c77f7b409d0f97470b5e127beee6d9246bde770127d3e3ad400cddd4 -82a6de6344e5bd0c5ca95f3be1ccd42fc974403269874603944c08ae1cd3ca887e66fc51ed61da8b7af3cce02f152e6a -89fd363aea11ddb2dc71288bb534a4a6e32feb5b9e4b88d132f4181f2579f8f8f39d19fcdb3d3d7ea118b9f4431520ba -b70c945986c8227d239201857e12cc7cebc932c3bda8913c82b62c872b18f866313738788e11bddd630bb5953492fec4 -b4e3a1e8f82d988c85cbb58d9cec69bc63fadb4c1c9a09f36b5a61f1ee96baac1a9458bfd0f3250e1734ab3fc6c0a0d6 -8d01d1eff496e8bdad1e6fb4b60e4bef0ada39a378c8b57cce2c115e611e0c4fa54f9b599e4c34dac925bc06e940eceb -90857123505746f7bff08e03b1a90f67051a71ba47b49e7bc63f1a8ec30e02a98aecf56465d3b4746aae166081099da8 -98b9d3b7fe1d5449bf6498c30036e3f60c8b90962fe04ede9ebf605d07497f617d99d51f0f0c0c14381377de765ecfd4 -891e7867e70582ade85730a21c19f6fc239760f76f8bbd8c6dafeddfaabd6fa4845f62d649b454fd3af8ae7028ee5f9c -945136f71f290d8cc6bf282b554cdf8ff92200feb7901987a1348f2d2edd3bd7b7bff6f57ec25fa302a27121a1a959af -b574d8379842467c5f3cdabc2da9a45e5a6083efd7298b077ccef2c4c3bab03abf1dc11507f4c896d745ffd41e4dd319 -946fea5c1b1d840c10a5a732c7dc23c2bc5eeeedba6956f85ad78fc1ee4a95b309c0d4a4919d1f7155814e3f36fe322e -98befb2f7d0a860de662f28968fb6200cee5a33cd7a6c376405a9cc6f0718b90fcc5cd5b9142e84e95223a3dfbd10f29 -8c5f208ca23aeae44a056bc21e04b570c13bfd49b14681cc085d5b318e62e4c088f0bea9dde52376967649919b59829b -b14478442f8e985618272d4c56d43a28e10112ea200b52fbb32b19a4d1eae965fd5ee1e9772416d52dc0e2db57d3ecd6 -aa308b19a57159ff702bceeb69a385f91339db7e683db991b1414bf3af9916d8e52dec4c492d7e8b5a5a011680defc1b -a8ac18a1adeeaadc192e15b7e92b611c936ba9cc9aee01f03c2a236827ba527039c719f16149d7aa5fb297cd63878766 -aa09af54f9a5fab6a61552421c13ca62f99fae212a9606f8a5a050997271ab6dbc763390bb98d90b1af3bbe9e8d9513f -96b8ce26b346a0d3fc99b6e463f0c619196cd85340b795fe1c1c0cd4f1b3a9f2bef5454e0bc7d51d75ce26f217460602 -a3efa46273c392704ba0718a44f306edfea03b1a6be0bc1e5c67c62c89671c650eb8ac9bacc35372ade6bed12321f1ff -b484881108a43a1dbc16a6e7369a04286f896aaa1dae847b4019fa287c18e9d82c8ba4ad22cea2837bc220524a9a7a17 -827b63d83e15ef61d54dfc365ed8a4f9e200d526884ec4b1d35032227245410ad7e1b1dd3c1d0ad48ddc4720f0fb5e1c -b513c3ddafb01b6189590b74d20348db74e400c106202dacd9ea9552ee2c642909a7a73ed7ab45a986eda3a0701be79d -831f4030463c84cc6cced28dfce0b3e6b6ead01afa200ddffd807f31ddd4ab93a8699ccc9d26970407628d521118ba6c -86312e006a800720329b82f6feb2934e2cc156958ba394278caa6766ee10800d2fb8907aa92346dcf6d389c4f66f5e1f -ab6841da372a286fde1dbbc57cfe967cb4bebd6fe2ab9e317cb9f9eda04a4db0d5844ffa8db72eb9cc6bf311667ff6e5 -b8238dca3f2be29bfc4aa65a9f59bd4e2c17fae78114a69bba1170782b993afacee3755e768317a923fd32d860f6a74f -923c1b60c052a3ed4736da7e84e52b0e9e154627cd90cae335dbdf05af109ceeaa016954d6e47fbfc40d9d5649c198d9 -96a69d18c838512d95d97735263a8cde752b2bc790b3827ce048e177a063dd11e2a69b86b3184873503a68170b2ec255 -aed7c3af469a93c22afb47a904bc70b7d88262ecdad48ea6a6c07eba7398410bf5a97a786beb11843cf40ddea9a37098 -a6b50f6369ae558dda3ceb8cc9d99382a1e62d0d9804b903086845479b9381fadf8d4595c2f342307c94d09e02e0ba2c -89fd703d457580a76544bbaecf65f93d3335d7a22e93d14afbaa61e5236d9c8d8b005e403e9f5e7a103b0386971a5e65 -8e909a3638208c8f885820af8bca6ae839128ce0d902a2b7b6f9713d21da8c943a7984d9aeee7fb104df4cbd1092967d -b41e2d7a1a0082eef43e886eab5e781bd961a83155d6a14d62756ab7144a208f4e4574d47d2ea094a7fb50d0ddd7a241 -acc6c63450d124014a1db846bf578c44e910436c83190fae428fc3125ff2065d4c6a1165aea799b46093a86126d4c483 -8dc63127435cf2f269a83024b562b3f4da18aee3399ed5255c295e6b80c357cd8f1887de94bcea29f84db3193570c417 -8c4cc72a98d42b9c5807322f596ac0b48b08b16ec956ea4a70c641a16a70895644e5b14aee85a4046673849249115abf -992afaccf05d79a3147d2985970c1793459130ddfb18a9d31f3036c260790109c9ee6a19a812f5d55779c2facf87785c -91394d3e84649cbfe018d9c709604f6aeed53e91cd57e2b29d0e84aca3c413f1e0135c6bcbc70784dc8985a30b9f3fb5 -a33fc126a8f9652c6905b1f522bee45848ce42d7f4c3a4cb3f6ce0e6e64c82de74e175c2ab6b5a867a8d42322d257ea8 -962d5fb816010a14140767c2486cd629f7793b304a96cb82ab85a867bd9a407bc8ed44131f87238c34a1e4ba41adb1f4 -b09048879ce26a34f56e1d4b2cbd6eb2a55d4ddcf3738c462329ba6726fc0a21b8c1bb55169cb8338b2debf20dc0927f -a9f9ddcb86b7427e268973bc7f3239212716df394394fa535b9fa5225b6191d234a44a126766eb470ade18c469a2d166 -87cba6afb115c0b3a515b08cc842e7cc2c705880c82184174837c0a06e1687ef668609c2ca080840fff80282caec7390 -ada109548c449990dd8f1bd42c9cbf194a62625d165416ca469c334222446fad7a743b1f584ec3f20526c3c44d870696 -a69a0c58fdfac715311dbd37c4464f0475120362234f5366ffc65227e8178e037ae91efa5a52cda5fe28243f47390175 -98e726cf884c6f706fa25fe25be154afaecc0c3bcfe682a85afed225bb44ea07cd1767b4d9f2201358ef19770330f0bb -988ad5bc57f0621e3ce1256720f1161e785371fd478c467c39e554e2de27df5ab8176508658aa90ed7179bc212ed0dac -ad0ff6dbfb397da51fa4d9d959ba5819adbf1a1ee31f68fbd62ae07a9cbce0641588cb1008dcd0056c17d74e83c7114b -94c703cd32b9f52c41b07aee3e3c19b8c2b4182da80487ed7991d568ea8827f0cdbd1e977d482dbc102c4de2058903c9 -906fc2a06cda5d82445e50bf475dc4ff2c17e64c982539c26545798f9e4dce0bd4daa8d55b027cc0a8e1b26c3e45cb08 -b09a51f22a9a24cde25f805cb18754e27d3d168e64db4ff13a202839a81c69dee8372b5872faa0d23fea283609cf4391 -93c908f514e97502d170310bc495d02948d99eca51e71f9a4779ebabae1431e1f7ba465af485546a9fc97c025877df50 -8337859db710ed7e276a47e90cb3912c829151cc2bd3dbbd4dd04acc90c9cb4870c44f4233b407db8240a93aaaf7302a -b13b16ea0943e235f8cb064d6dfaba9bd8dac67e9b6275a4c3f54a1770b9c905d8855517415ef6489843848108dc85ff -b28489f0de1a76839a898b8d2f302c95610f17e893a6e7f2e824fec773cde6f2b219038a3f1fa212bed98c97daa66d5d -af13afb48d56caffa32f941ac5542ec2b7fc0d6dbc3b16e51bd2a8b633f0a041ba1e098d9a68c470da00e630f08f24bc -81465afadc45ec24825cba7c9edbb36858bd2ca8f8b0b9d7240152b58a411b08503b530932e7b6ec3b0f8612869cb244 -b2e6b7438fb6f70b52b8726aa870f18191920bcb213a375817d100297b507908d79567d0c1780b3f25be807a8ddcb853 -aa7ed2b0b2bb2070b5f001578efb3d1085950c19f9d06584a2d31e1c235e6d6d1d7f081ca6fa2b0b0616b01b9a467005 -91a245f1aa8c8ffe03f7db1412e5466f0345196727eb8e6f98b80c01672e4260e90724a538d26b094e678a3d85f2dda6 -b9ecde963c8176d6a726b129f229d803d1a6259533e432eecd7404703c972ec7296ba35015acb1f4b5ab2653a3991902 -8cf535bff6e98f75d98c5d2a691a5d1aa645c7ea18d677d07d3a11a9cfa222a7b8edd048529d163120a5aca411161314 -ad2e51afe96dd0e942a7da5a37587ca1359fc17cf66ab70cf37ab70ea34f90054fa52503d6527e89e464f8058f5cde79 -97337d62f83ecbaa1f402c3964dabfaeb279b916ca08430a61fad6c31d60087c7e3a9decd541651a2b6e68fb2816bf45 -898b7581288bc7f97987138b7481d29e2cfd5255ebef133177d9060790a0973ba07de62cdf38568c336c237cb084b7c5 -ab53c0759663bd976de62f9f98fc82fa4f58c146b8a6a3053d4dad836c762063ad69a54d51b5499e9def86f8d4bd7ce5 -b35ba58109d44c14be159333b999c1e471fb61f5ed48f9d2a6bc689eb045864f3fe88a6ecae12315183703e2b1fc1ae3 -858a20e233f2860c24c5a3f4a820cac7544eb3ce91a2d8284f12013b13120121fea3c4f25427c3524a1e883aead429e6 -965be1a56adffa51f5d80761327cf69656e6c37577225b36a34afc2f8a959d8799ad0ecc3eff4470d49eb22ebf8f198b -8e575ee39077bd865d70fca2d93473f51dbc99ef4f715f4a3b1d9eb21deb2afcd0873b4dc53035b77e05f52029f069e0 -a5c670a73da241f5888c5cb44c27eff2b8ad3f491e0b128e5f1d498aa6d76640c9e625f3c5399ad8e99b666e4b2a9759 -920e1524255b03cbe500edb230696c55b7774963535c063121c9e9987ab74d504f2f1cfa14ba7ca82a6f66745fb0b392 -8a0bb7cb267b8e1e0cddee208734632b28313b3ad89f9c2168f341be5390bea3f09eaa51f8923b87697799a53201dc26 -859ab9b3cd602e78dbee8d8d5c3a9eb4270f130ea4a1b417ca5612be753d20106cb2724097840ca8919a9a96e73f96b9 -a76126d9a997fb0e7e2b27ac682dda1c6b99067313371387084be1f6e7a9a59bfac395e91f089e14cecafd151674a446 -8aeb466c58e2829790975fa08dd31f18a51a63777070d2e24605adb1a77b5e0e5c5e0bcb483076d23a6fddee5f402f8d -a8959f312f2ce0d7d974a4998bb709bb98ff6456413ef4ae9bcaa8d687b8b5ecad91414bce8f704aa44a83d8a0c86462 -b9545c8567827fb28d070624579702ab96af4f06fce515ad880893b97ad9a374c4c91d6288e2a584ef14b1ce4930a6bc -ace41f9c2756ced611da16e21704a367b122ee1c2feb83145103203ace1a5cce0ebd3bf295caaeff05281672c92574cf -93b90e75f56601191e3b568368bf1d24f97512cd42cac1da8b42f0019e07fa04cd5f835b7e9503fe4702632df27ddc19 -973c8feba289eb473448c32b141ab4a6f861222626b3f2fa265a431a54675dfe5eb479100a33c172ff935464d6e85f90 -a6b0798ce89512644490d65ce3d0441ad950f9a25f6fe2c9a766a58b9c8222fa6cba753f314cc7ad6b6e3da881c67abf -a79c560dfa179075e0d1506adf5082318915c15048328b15ddca5748ebc6ed8b10fc5d7a50bfaf8942cf9ddc6912be0b -8841b34df170519d07edffc4d33a0e70c518dcf53ea8d0a9f13563822312a65d16f99cf596bb95eb0daf85435d4bc0a9 -88527539258323edc2c296dc742cc26b9a4a984ca299a81705c702a425ebc7345a79b4df84b2d440a1e73a09fa18b5d4 -88026753926a068e1cbf49a9a0fa545846cc7ca9abc0778e44f5b7510c1b6b73e9a9b1aff754199379522b2a985c0881 -aa2c306ccf91f967b5cdcb50808771ede36acb9a6cd84fa15c6de4c873cc2d0a64e79778a2822a109b41f5205fccc30f -9751fd8bc2a07ffe0566e5587e652d3d8d5250517278bcf8754e14717b8941c07c194f14fa757f9a2f3461ca6376bdee -919746e5eaa18b734ef59c0de09ee8ec65e348efa659219d9eb6a3a77b8edd9449a6dab727e9860ca0d3837b161c0352 -a271c146794d6a65c6fb87797262c22b1d938ecb2624e03809233469296d33ac0de6909183c8efa438b5f3971c8c3eed -82fbadd9049248914a15755dff692bf689eb2650fdc6e44e8f3ae003b8f15a0f2858c7a2a8dd137b3448420c5f434229 -b90992cad6df98d2fd1c75bf90978205280d993d439c44d6721cb95d52eb042e01b418e45c3c48ed667aad577f3fd1c1 -a0c3d1e8b80ed4a979a22d6a9647bd57f22ac8d73c37ec3d56d06dc178a5c9d5ad3ffd6dba9eb7844c1f40b8c89d3d33 -b513aaf2f0a07fff3543d8687426d07773677ca4d23554ca517e50bcb891164d1f5651944a2f6e0a634475f6d33bf0dc -a0b179aa2ecf572ac4a3ed898aa34679be3cf3d8d9bc74e33609345cf1743e915124a59ffcff41bec012ed2a99447e6a -8e991c5549126d64e0b515a03d266e19097eee38d08121d942973d568f8ae23a15b037337cead0686f7c944b9fda3e39 -93cab29e1bb116a39ce1a82897776da1bcac06ea131a7dd141a688ecd4089c5a0b8616d6721b1c6d92309ae0820a367a -8d4e0159fd3534172b2481764cae7746b1a47e9b7b9465fcec0824ef234674fc567c16ca7116dc90ba9b2ac3eef28d60 -88cbd9ff6ca551a7efca30b5f59fedaca8f9efaacd4e9bdd17ef0dcfe4f3449b52c7d3066716f3e7fd478f264d10714e -873c71b2feef5230c31f13d8425f8b0eb0171eacb9225f484a36da3cc796d62594fa4771af9ce1e7ba951f5377e5db76 -939eb99d7fefc9fd5b3dabaaa5b331365121374a4ced862b8cbe0cb3c574fb1f0cf4932106088a1d87522acc31ba7f77 -b283f1d54bcc72e31ef572498821ded40485f38d2ffc67f70bac68a100612b020a538b36001d94228a4dc97da8fdaf17 -b2e4c2be605c8ab3038b4e91bca7e77e127c5c3106913ec1341102e138bc8aa1d218c3d3c2ec1d36fb8e044b4bc211a5 -82e73cb5b2cfd78c17131e871e92026643bb56916ae64f009a009555903df878fa3a2019b82f7e71a3ef7eb503c792d1 -a6d828a5b7de0e7818975b65244f6efeefc712c29f2f17b27f3264e19856d869c350ab39750ba63d6d46afa3aeb369fd -865b17027e9d5bdf2de0afa2f524f67b6defed87b14e0af5f4b6b1966c2de45550fd2b6b39b1be88ee9cb06e755f917d -ac8b47f9b7e675b556445d103271e6bd3b39b94d15ee1f3108fd1b777d439c75437c78ec3b281f7104af6d0efbf0ecbd -85c2f71ae18105fe499aa4da0a835de3e92ce05d0f28ccbcffdd2860898ae9909e1c05831ca4fed96545133bb3170302 -8bdb4a72b06562591ee44799bd7400ebe71f6737290420dd4ba2bffe0050d8ea4d586b7e329541a52611e945ff1b16b8 -aee4843c9ab02026ae723531112170bc7464f51460bd4ba5166fed54ecda0f53342cdf94f4354a5bc1b941e8ab085a80 -84de368006db07c89a7a43b7de54a63637ed72379a41d029430f6b4ebe404866896d2e84996998f7b2c20324143649f8 -a8375f69c01289cebbc97843f417d0146f68c6416981032bc1f42d3e09845d5131eb9b4d68fd0ba7f5b1223b83e51bab -b1ae126dda1a88fee9265ed8e5bccb810014044d83c70e01e7f80059a685067f4204cd15809b230caf5dd77738a64e38 -8177544c7b1f77181735c660102da20fbf9a2ca4efa79b21c92f1cd2b912630aa6c830b7513980656bd275097be59d1b -874fe8038905065ff3b77f1e53904854fa4fcbdc4c8959fd2df2e3967b3b84100c6f63fc44338c01fb26c042c454991a -b19324d737364cabef3d2ee4785e8f19cae399afc06fedff8fdc120e0ce525b3755161183a1f5ad11ee758104081a49b -8e7525bffe35c1f5c2db63ee911e7e0197951ebd25868660e6672a3e7d4fb309738268b36677921be3be2f323ca718cd -846c51c7d22e7d43f6e2addb7fb25113c25ddaa51252a898fc1d7d5b510f772534c4f5d37ed3074d124cb259e2bf8110 -aafe2a16cbc901730178841c39803ed84d3a78f92f42f84a1c01be4aa3b63ed7ad9d054ceaa8a2d56eadddecb287e8b2 -8781c9810ffe3d93fbee3b576a15b8786c3efd6b5a96b75819b1f93daf413d4fd0f56d1ec277e8f5adcb784b17f08371 -ad66011f0e2927ee1924725bcf8a296069f74df78ec66ef6aa8792f68425e48e9d7f717d022f68a079501770ce192fce -acd0ef46fafb06f336565d86e0b22f9e5500d2f73d047c827d6a207af40b706440afdaceb32e6571deaa1a79f5e6fe27 -8f65bb98baaae22e84a3ff375e7598b5c61ebec676fbb5a4f79c8463c427eaa96ebc51b1fb504840b7b0206ca6c2c72c -a4078341325d7debf766e43679b8b68331dc13651455a73912afe062525d2ea909d8829ac08771d9b32f2eea28b64022 -88eb29841b022f2ec9029ecd1a137173cfb79addde1c7cd4be425e5806ea6ee295b11a0459a940ba79f789689a8fdb81 -b762b9923a40a1965847bc7d046723c3b8f0d63323303aa3b25e93b4af8e527f1afb3dafda831f50baaf79926d1b1e78 -a21551dffcdb069cb8f30b625c8404dfe5efec83227e3a1a67ef0c9c9b49c658bbb31240c3ff6f8c68e02f67974c732c -b4735a6610c371754001425772aa5314b759c24da50b38a9390969c27e215ad9d463a76762323b7954756a8d5ee7936f -81bd78e545938f8a3e53ecc2e88dc26bfbc30941cbfd009572d9b38f8eee47a85209a318cafe8cbe055eccd5e62d50e4 -82ea5495db9dd48da97723bcfce02788549c6006773eb9f4aa4f0f3ae13414430edfecb5cd095259179ec2014b6ee1d9 -8493147b8f0818c2d5e75acda498139f95fa6f904b47f87a8c07e258c60f39bb1faa1d29cf0834c8a1ef1d6015d37b42 -a491233ab353f9daad86e60fd48b6f70dce60dbe36775958d8e270725cbbda96578b17a0c4925ba1298e630c6b9ca9a3 -a8c148b9e1373afa54778b6d4f76cb12f40eb6e07404a7f27b271fbce0d18d621675f1dfcb30e3908d7df1d962de2e5f -9826a45c29ee22cc26ae399be25cabd16180a291669fc822a44d14cfac81aa7ce85112d7f2c30effc7e83d131c9937cf -a793c75e716aed4048a2893f11eeba78ec565ac250bdae16594d056f06f4aa7d2a156e1617fc26def4e39984fb28936d -b6c454d822343cd1b1ef7161cd2ddc28145134d4e59e6d69634c010ad1bd44120aa8458eafc28f6103ece7e34b368e1f -a3340a0edc3fa82fe4f31ca2d19d295aa09c74cda3bfc3534c66eb71bbb7903843bafa92f7120de4505c7ec819a89664 -a18e5218cd4349985f412ffc7741b5db21bb14c6e00431daba194771300e740f75fd46aef1876543967e8719bc6517de -885ce63a88617bee05144bc67d08f1c7072d8c4e09b23b7359f020995aa8cc9654378d382de6340ddf0803717687eddf -8d8a0b614be7df01a12e534bac102b1881905a9d084146b3d0cf2086dc7d400129e0de8e48fc966adf9d8ec8c1336429 -8baad19f604bad656398a4010b20ffb6ec6131681d120220dbf2cc5779de1ee146d0b773bdbdf4e8e30aa0f464f2b18b -a39ae3d204491871c2e88d7772055b35af341ba66531ce3575f47c749eb8e380d63a7939d3408cd51356cca29c76d4b3 -813afd593876667ebf0fff2b8a8a5bfd0f42a4fe2e4a0b7c78b6183605706c97dfc40b627340e1d9527f618719d60e88 -a013e458d678fb302bcb6f002a52e3e0ace443009eecc9113ab5b78f4663acadb8ca9cd757a7cab1e850aa23f09ed698 -b6e14f351fc47b9e46a83984756812cfac795cac5ebbc6f00d673ee23209d0d91a6bd7d576c7d35ec3c7e7cafb758a46 -b94246a346966caf6fc1e0081a211f27b38f058dbb9dff915e3e65391dd36d66c51324667e3d7469a865c0cc064589ab -a1bf4bcc7420bd17acba90ee67af96e73502777e1723255a73b1ae3e92fc77e80a287ce7c3d4088040e0edd64577c8c7 -8b6f5eb9b6bc7320349b19876864baa6cd8e07da4f70653d7369740184ad416c40b4395c04750f5d8b54b3b3ba68295f -83250b957d920b1b738f4d0f44f9eefc01b5b0582128f5ddb5a282a11ee207ba1ea7867f00588f8b891bbde2e56b4c43 -8eab312cac9de78c9fece9d67a6b26d58c4e15d5e0668ca2cca2d9c51636eea5210a893f9321c2fb232e09f9d0b40fa6 -b4d1e5f284d50360dffd2a0d21c4b31d81f521158aa21bf333a525cc68e690ce8ce4f0eff8e71a0c2d5853e2fed18231 -b1f194c28bbe217a2c98ca8212fdca744f0806d60e51f9da81548155cfb97a39e2a98e753be8b2196c83f7db8caad2e9 -a7905cbb59722d9463c6317ae59adc10d5bcd6e9788f2a54f4ff4a4de03df3f830d6b8faebcda541d429a7e42d158c9b -8a3b31d0d0b33e7011dafe25ba5c3b7629cdb5dd5b31385d786fd80888fb8409812b96d28fedf6a401a93310b045c620 -86e4990bf50b27bac76926dbc65a1ca34a759d005e56eca56fd0e00ce82635dffed6f3052740cac2f1f37204699bba9d -8f0b6a0b66f1f5fa3d12af444963c6a45785a36dbd9e1a5f42830b5534ca8773a05fb618292e718cfe8a066b8fea7980 -b7f206827d715b33989de5c02f0886d3a457d0ae34931ddfdfe2dbab121b69ccb560a71fdafcc3ff204217611674f5d3 -a6e2ffb0c5f29043984c54f5fe6449ac4b7a86f2982c909606b88316ef1f0a54638d565f44d2fe8cf00279e0eee435a9 -8cdde76212e73f9430cac210b52507583e81aae0bea491f6cbe27e5e2c8fdda373ce8c7a5f16bcf8c6238b282d06639d -8030955eecc9b8e2161d40f1f514d58024d25e07c6710916824ed8982b8bcf7ebebc5643f0260e1ef6150b6901dc2dbc -8938fc90e836d7bdf1cfefb2716cc25aff34e7c4dcf66b349d1fc6681580de7f58665faac29494b30bfa0c743d6f33e3 -b182f9b4a5d838e9d534e41ecbf06330c56a8a64800eee561de1fc2dd9486565ae6099f40d0f1901066f45047641bd65 -81f98b85de7b6c581613f4a42e0cb0dd9e6336399b39d38a4751c2a9f195b65c9e5592fa1728b91d83cac0ebfec7d675 -94681572da95137ce41d913360cd567b570a87c9a439f2b67b90d623561b75bd3dd0486a90a63d49eaeb412cb97768da -8e64922606ce05375556901b8c042d4f41a18fafeca24c1d56998e0bc9054bcee7ab079c3729a67d908d0d7967a85edb -8e10e8952b24125321d0cd9ba922affc93908b3abdce47eed22fb2d44cd556842c31c36de6d4c28b4a1b5dd84e07df81 -b6d464020a51bbb53670c81d5f1474ef439e006851d5d5a3fcf74219614a2a9c983737f20b254d38a2fc7333b35fb3a6 -91801712ba264cc2eb65e8a3d5a032674a89f4c2dff95ef9d80d3a9285f3c2cc108e775dc326881484756814c2a03637 -986e5a00f13326735bfc6b41b086623101f01dd55f2a88bf995a3b81054da86bb2f97fcf647d58e90428e8e9555eb020 -b2875b4ebbab678fcafd270a0238a208b19803012fdb3c23f06c74bfd45929a9856b7a0f9881b75c7e97fa9d35e49d1a -b3d1acb9c844d8d2232834a81862c59548cfa849e8e5408ee66b4c8b86ddac0fc231b2538a752eb6c1ceee92ca443d1f -ad0b1b5d6bb50c43f5f3b692c5d3569d2117b01caa7f0ffff502d5ab727f7702a2d458b89d77d218d3f92351b4c2b92c -95b1b99dc260ae6ac7c387bedd43fba793274b15768d93df13c88ff6cf637732cb6b1719467919b444c3b5166f4f0107 -a0c3c8b59016056742145e7f4ca6568d4393124efac6540645152bf71173dea3d0058bb11b3093228ca4729cdd5b3033 -9278afba60643257d9f21a4033df3b57743c3b43d66d96ccf413154a63db054fbc3a36f2ef378169f4f19987964c0bce -b558754c97f9824a72644de1725127dd36e284fc07ce89006b990f09db77c48ad6728e5c1891a691460bd5416ad65faa -833a02af76172f868a25e850d35f4d164889bab8381fa9c8d9880ab0564a3769ce3961cde72bc94ed73a1723daa35cef -aca496f3e528a2e3eceee138291107ddddd68bb088b2e49ea76d0c4136c6924b3251d7661ff467a36dff29f07ed09102 -a9367961ae88a19038c446df3eadb280da005d120c16f48ffeabbe4cb8e5e2784902cfa1192876ab934bc90606baf2cf -b43feb49373dc36cb46e050e3cea43e636a64289efa3af790dd3fe960446492b858f51b3be62c6b75b510d8e2b985573 -8cf24955965468125fba2c5a5799672845ea6ce97cd307b09236ef1a3cfe55c88958ffa311e8bc8335bf261a84275d93 -88ceac98b512e5bb915554af92318a5d07a494e0b8734c4415e192e7405d6b06d170fbbe254e3bf387759f6d4961c34c -8a9044ddde945daf3e0cb3f897ca00d0d4e6a5f7c99aaa3929f0beb9a44d2ed23c191e37c57140ebf3ec759f50f84d57 -8b2a2c0fb51e7c5fa51e8c593bcf118696b8411bc93e35cfe5de6c5465c6e80bba64398d7c6b71badda616b918bcc7d0 -ad8bba2b7d5577f971a1a561b17a9d8f6b7c35fba55e3e421a0d8d77b520eccd52122f02afaf3899218b652980986a92 -a8d743b56896d44bec838e10ac1ba5a43f58c26655c71be0a5417d936260453a8e91752c87334676c5dd1dcdeef4fbd7 -b0b0540f8d2d1ebdcd74d6e4007324de8f8bdea0531880520d79773c0b8eda65ed49e672c5a294fca6b4560442085829 -96da830d1c1625d002008e9a364005b2ef16cf56f5aa4a758ee963388493cbf90aa75c25dd67d496af17212537ad44ab -89e819577a95195056b872f8f790d001fde3253a23120e2c41b3ced7fe8e9bae0df74907b7d65ddf9bbd6d2efa18eba3 -90a139ffc7dc0992c023651517db4c195aa2f618dc3002f4a0a43013b6c6022d8d9844a49cfbaca543c9cf5d9b2210f3 -a2061f543b216fc9c801d885ed681f9253f67cac40528b23aa8a709f24e0992fa42a10f1bddc7f10af2c22209343ca26 -b5f53715b9146966f386f214477743e2fd2b771bcf90b192a5863c06d7225be34edb6bf71389085edf344e60afd88561 -9634ce27272f3c687035789fa4eaea2aaa71db5b5531b21b8e029645827b40561a5901b33afd80a3aeb5777aa89850f8 -9674736cdb4a823bf982d54876794e99c7672eaea7455be90e815abd03ac06ce1fd9e73bb987a515863c6cb4ae597835 -90379303e285b19fd7816a6d02c0b8f94e6291b56c196d76aa389cbf813dee7ebf64e45555ebe8a281daeecfd7aa5b00 -8a1f759f6cd6e5134f67b96e0edce7170e4be1b39afaa7af1c2de989116a6ec9d38a2c077c8e6e65ce0bdf729f20f1c7 -b416f9937a51a298548e91cbe8fff71585335c00e69602423adc9cd72d18821987b8fb5ede32fd8bd2166e2ba9aaa792 -a423073148046c81f840a481d57909f7ef621a51827e44706da9e1f0e27fccb8f88652097a9880ca64c41f6386aa9069 -a173305a5aa2a17349eca704fee25593f5c2fdc5cd8cb932a1bbc0ef34bf54ec2f867ca93d8e6aa33679cbb71fe11083 -87c6756d14d815ac8237ed4a75fb11206f615585ed527ad582841526371366ab19f602c7448a21722adbf2d987d89b81 -8a1a6f06d6375d2bfbdc7531e9177a45330458da2581f65ad129367c400cd77f548aa748bb470bc560c0b02ee5b802ab -a24a05c30d0fcc8334f6974c30d13a5593bd3b388e2146ba006f232bcd6886edffaf7e48ed6126efd3e651997dcceb12 -b35c5f8a5842d97cbe19105305cae1f971da5662c52eb979975efa0753bb60a050206fc0babac5b5083799e9ce8a68e0 -939ca5532c922d00d08ec5914e6c58f8a1302a1214a1cbd5c844b334ddc84e694768edaf1a2af02289ad74970800198a -911d6104a240f84e0f6502597405b47a7faf5e68717f6d389baca62bf82fbb7207ce8d0c584fd9d57d3afe1f957b7cc6 -88777ba7a4bdaecee78d42687cb4fd6dcf04402b43524e2ae67506d93acfdc29d9dae640c05d01c90caee1d04cf3d35a -9226e684606f8169e38dc21a14911d0306b1c9ce5244500e4b108eb1a0c0783486acaafd2e0b3b60c413bb003448ff21 -b2f527adbb9feef9553bf508f192b5ca211d0e491925a2331bb294fcde7d8e0fd72b441e9f07c838640dd35fba03e1a7 -b474e6d6ce22ea272a93a3c078197f40c01b9121c6f3083a8e587c367200b8c97ad94e156883475603f0a66d0340fa52 -95c4d9896df11d2b5a8205a19d6331ea02a2de038aded8e6fea6d79bf5a6648d5d986bd29430e4cb5a6afde8b07a9a48 -a12bc53ba6b6f8350b400fde04518a741a1d755123a6ad1d435c7642492c7df28f7091f17b254e793561923de781eae8 -8a0578ac03070bc920a3b5a7a33d976b3133501309af5339b0cc70536965465b4f7288af70db3d5be16bc2a1e5c26a86 -a66e27284ce6114e48ab56d7f623dc37a6e79cc5f487cb2bdf0acee099cae744cf3a9de53b111492b5ef99b0deaae0a7 -832a338951022c80444ad8c6d0285e86db54254d2689defecac2ed87f5eb4d876373af6d76e3d613523e32c3966142f2 -81e83f01bac3ac3fb67e780b28de30b32247a774aaaae118db3d45c8e74d1d4f1defbf9c2a7ffdf176f5c1cf4ae4167e -a1b214ba7265f692b4637352c6139bae8bcaf3e7db5806fad0014ded93048fa4a36ac9c9e0b7cca0a86cd45bbbba2fe1 -a7ab6f470a421e72fb703a9d153362056ce80c40264a3ee5698168130cab8e827df5ce3e6321ce9a669c87a2e5c67499 -aefafd219f2d062a378474c48d2650b51901b6bce00e4ba0b509395a6fb39699037577da353cbde187e65de87ad01575 -93db16a0a77d1b181f33ef10300112fd8db5b2eea26732bffa3b1fbebb792c6ecdf2899cf6f26b505dfb46deb81b217d -a63b6d9d1cc2f31ac5f836133ae66bc9de3e07ced5026f5bc90116599461dbdc03cd7680c1bb43dade9218ebfe1bc1fc -984b49ca86d38a486f6315f4f9e6ad521901a06f8862ce1fc095d9c66bb2164e334718c71d7472ed765367db5fede105 -ab49ae93955a38f45f756afc4248a37773ba8d0a19779253fca3b744854715b9c9b10c09a37d3426614ffd3a8ced7bcb -b22166dd64c83fe16feecc09d4b1df2d967ce7f4ab526ae39799dd5a5a4a9ebb1d4a432c5efb90e0875a4eb6b079e2fd -aabad619d887b69b9562066fba2179c69c684b8cc9318c9e39646f4a5381535c024ab277a0f0be46abc95283b337212a -99f5d484db149e9f8dc9c6758647c4e3702d88986600a3226874d612bb4b5e92a76b1dfbdb0909b8f21afc773ec67c7b -adc8bb04eb8c56dc4ce97c3fc1670da10db134cff2edc214ee3221079251b968e2dbc087c56c01c9260b49506958a6ac -ad625ddf5cd211102543e0943a7770a9b45cf3550d12dbb484cb5522b70cb626f9ac795b07a305be3e6949d7ad475f66 -8f9f5b2b43624e89e8535dc73fc54b744f247572b2920679bdf6a3ef346e654ec40fe8f81a0f7c7ce7cd5b48f3975359 -b70b1642f28bad56bb24b342eeddf5c3782e0cf6e0d5007c252413bb44b32586da1e3b4d8b45a72c91e44e07334da68b -81b0311e557c47ec22c5f5d1f757c6193cfffae357dd2460019247178b13733484dc8630fe2e13037a1a3d681c69066d -951c9f1504b19acdac1c04aaf535d3cd3e39c431b2b5d9def9b374468e93d378ecc3f5aa02c91ddb93eea431b327ca4b -a85e1f4c292723d18a49cc9323dc7af12bb5a8d0c95d71881ae235ce123c50018907f46bfc846dda1a01b14ec45dce14 -8a46c8b86bf9890df60de4c210cd7865892d0c11fdf2747620289d73bad597e6b482c208dc310c25955dae8392d8f278 -ab65408622c63b67842a80c4ed665258ab617ccd07871fa3f0fde2e5ddfeec49f01d7501790a60b3a05d7579b087b787 -8706913d42b557d9ea4d7b70697069281504b3c4e1172a2291e3b3e0a0305c8d0bff6b7721356d971d2fe58e32d4556f -8d9b8f3c113ca1215dcd15d4c37913d023c8c5d04f617319af76bb7bab72fb756c5bd992db6b9e765cd7695c316360f3 -942d4d3351b2a9bfaab2500b27d24fc2d7237e791993a7d0335f36fe6456c5a1a8bd28dde9228fb139e95288d6de5bbb -ab014e9cc7d3ca08f1d3d24473ddbd693331f4bf21ebdee0fc997aa2faadb43db6a1195644c459b52a969f3d98a85b8b -8b679da80561955990c91da9093837953f4ff7fdc658b51639c462b578a2b31443421712c6b7742fddbe0ced48c21cb9 -a9132ac18b1bce93e815f6d2f8a0d2f433ae4d6fa04269eb0f5f25864a8009b01531c7c3ebe87f07454927a010ab6dbc -8ab02c113149efc877967c92621a8ef618bf423017e78b9cd30cbb13c51200c6ce27c46be75e19ba843d64a3050d4467 -a881043298341efc28c60d850d90d90279fa6d8428953337ba57b74eefd858e362c6118a82ebb025c9c102c91b4aeafc -92e4a587479c64b8df955c6bf1abf1d7979a978e45d96f05bc1b9648f10428d77890be9ee03bc1b1982f5ae7b926f0a3 -90c21a22826e2e9978dd7522f51353fb33224cb65603779de41db3ba41e01d664e131233bf873e28d6c71294b565c533 -88e8ccbdc54ff06380c2243203d3f8c8a75fcfe638d6e6a010c0b3a39d5cda31f8d2cc416ee5264267aad2b457c94e50 -a256198394b458f6468dc91c35f579da0ef02a55fd93e98b25e43b1bcb650ff889df4899236765c1a6b35cf49da940bb -b5c7d9c03c36cbca068abc6778053727e77d9b58c5dc33b11629f1ade1c228b1c964f5a7d8dea16057e76662c4d79f18 -9588e133517f0d49622222b4de5c124b1aa4260971e43e4aa767fba8055540f2848954886b7f245583ea527fe2fd1de7 -b66025d75169bfc7ea366cd32419e24fbff829709e3e9587d7d59620b3a7b72034d3303106f965f5f7a71d66b7f314f8 -891357bbe44e60627b975c10c872a34b78d6b264380e351f3a86dbf99abf8e2dd8d20c52dd6073086e48e1ca782e2ac1 -8a066a3482526a92476bb8c3e5caf07575c725d72203d67ce98f654f5ee8b7f979187416fe3d7ae0128800b253d7209d -80a9e3d8900046b71fcd5b7034d1e0f57d95d2756da8307a11aec0553e5715518a125a653d356f399409545256a1984c -924a13fb2da7a899cebf2ac09c8c0a183491777100de1aa056a6c2bceffd5a63e255f16a9066e4ed89ef28096a1230bd -866cfc8116d2e0216d8049d5ae2ef0e3fffd377028850716a4bc2cfe16c5a6be023334bd6ddafa0c77913dd4ff0a34ff -95eb74bebbbc59d793e3fbae8e98c258451bf9bc5097df4edd832e9f1c30a1446a59e1f75a44832d0658d5ecc13dfc86 -972517b2d72ab53193db5d682db2de7790a418ce4952c29d64e1f9107d51a782f4084591b7c775648f103445b797e8e5 -a14ad2cb69da568f2f958ef4253d7a6daf574c6976f4f5d771ae7673853ca22eca81e20400092bac84453b6eedf5aea2 -ad95bfcec6c06cdc11d316b7ad33fe65555e985bb33b15c9f481a09caba1e5990601ed6a88038c0ae2e04b1607e2da48 -b7e3bf3a585af1029d83f12cf75acda894fc4441cd7b3d56efb6991ea91b07512bcd7d6d68738557a48f0446b2cb21af -a57efb1e2d2e10e41f356768385375a21d9f78bdb34d618117581bf7a15024eba43570c3956ddb85a025d39476f831d2 -a66d3622b1cdd472a2a4491881de035c2eb4f1c94927902a3bb9f10739f900130907c6b002982e03785c43ac30b8109d -a79f2417d32fd772e46f3bca61ac788af8fab174e1e1e48a84ac557f7e80a9cb4e2d7b467365ad18f9777f4cb5bb2b8f -b952b976e3b6660326c0ed357ff25ee1291b74891f3eb7bcea39dec2ebb11e287d6e26ae0506425a20e5e445273cc63b -8c23929e9740ab51d9b82c6b7840067e7163e6c7b9b9441e1bf867ca2e532926981c98641e6c798ef12d35108abc1dd6 -a519578772c9ed2d691a8c423d360e4bad76afa422f1a5218a7a08ed52c9a5935ce2ae4c0be182eac0712259a43f849d -b1529dd189cbf3bcca50e97199bfb85b42f2b26edd95b35758d988d1d3740f5d0d2e249763874fdfadcefad9ea1b3d02 -aa3fed8d14a4f38df75b9eed7f187a31cbb7a748bd3225dacd8325a71dfb680729fcc91ad8cf0b67ce314e1fa8ba02c4 -b77c28abce17732a08e682491182f63fb55640e60384932f6a9c6d3d7886508c9e67a841cb93e59448d2d59fceec4620 -b7a24c58e3b85d60d654ed14d78993a9cc78c130442c8cca42921ade8ec94bbd0653c9fe5c69ad1fb2aa46ffba04da39 -b7d08f3ce97901261514a5dbae582848e75515c5f9f41f5e70ec17a8d0db3067ddb19aa1c86803bdbb757230b148bb21 -a5b8a6818be4d59079d88f72d7aa4957c48ff5898f3fd01def48ff6bc7aaf9840aa91f2f05617d340092dd9299115c2e -8e548db6b871fb23ca1cb8538d44b77ad02f4cae4d33c8c43228b820abee1aa913ff9acf2483725b195b4e65e2e92063 -9509189e063812fa04f4e26f87b33a2289a05c229ed1038fde0dacecd87aa55ae0fdc678a1c86bf13b81f4b3a872426a -b355f24a5dfb7a8f3ea717111a038487632bf00d67cc2cfa2ab61e1cace7bc7f5bc9e04b190aa6be0652627ee219bf76 -a9b335f235df51b92f40f44f19150e182a938b9abb3bdd8e8c447b2b128050d228e0115a268af4c1bc2ca49552b4e0a6 -b306d3e6cd7ab56f5f7572fe51175ac6b29b189220fe2d380b959d131a35804da5ce95adcfa51d799f18e27d8d5eee0c -aa49cd2bd34c37ce1f05e192fa6837f964c068170ab97989e1cb22ea7e13c2400417a51282519e74d8fb6983ba89a549 -b1d4fff41d95613e30427ae2ae1d3df8c9d06389e1e0f404f8cd40199d6c4277b7a898d06f1579be107fc5744247c36f -99d220454889f476931b0cba3570eb1a8eae30b4c3617513833a551aab0a2630125f72dafc64a766b1a322dd42dc385a -8267ae38c9c8532c7d4ec4455279a5ed4f2e48746cb0f2619937157534b0e5466c5f4b99b7c342c095f71f3b77fd5882 -8bba0794cc4ca00eac50309a92878084a6a22e4c23206c68b8d7268f9e7f615da4b9d0f3e006d9dd84bc3dcf32261e27 -adc965bd7c7bb2a52cd3f4d2cd3fbd72a196876a678863c6a67a25b4a2330d1d3be603220de22c8c3f60c1411df57b7d -a7d5f38a3c4ca0541d5ab101af9c27b04c5bfaa42a1715e882c5e7715e460c4666aac4b6272b9fc54514346fc49d0560 -af94b91ad9b0f01df1d41a459f16ffbe30710325617651cf1da000eec43876161957f079a27b70018ba34d1d5d68cf6f -a0e2a492da4614f41741157d3a1d19a2370ecc8e178d813e22b902cf7454b8237f1ce3c16270eb6f3ead1f92797e36f2 -8dfcd39155d7b8073b0a1a9a617fa75218f569520d4817f3ead375850ea8a3e3dca64c44e83f54afc37173d927070601 -98302358e5b740b73e1a6c568b99affc6de3c7245ae96d9c712d377fd363d8b8f49dbb714aa8d39b5b947b6de341ece7 -a2fe0f9fad663cbbf4bb05f61edfc90716564d5ee5a9529ac3cb8f06f96329248cda85c43f24a2382a9056e9a53520ac -ac50b0727ca2ba80692c0b7f564417916695ea3760ce9fd71593050912bb97366d29ae5ed05ce52984e52218854b8e3e -86f56bea946a4516336a90328fb4b24cc7f82d8710d0d1e34c2e27b6af73c4f4a9d6a848dcc56a87d6259a99ac444557 -b33d0244948c430a58b210943e41aa3cfecc9a823dd3e160634ccc45ea2680987db2912ab2a173ab6cb9cc2b7e16f7d5 -8808f8c2c2377cf52e7314820d88234d7819a6108fe9e1c6a675dc47cd59f81f95594ba2f5fa10e3719580f53edda641 -ad34a814be6019931972a76b3300a4fc9ce763d6f4fa1ea131a67d575c00c827b9ae7260d88577b4b3689e90a845137e -9370abc67ad0fedf30b929d1613e336c6e99e4bf83ce969e61e5d77061b48a1a493f28fe2eff436d4a979af700a83b5d -b0db136c8f4ba2fb7148b1451b18f694769f5e53650d68342f15817b04734ef8ae59681a5754df617d755a687b6ee45e -9149909d24382054a05fc0b057613d059721f132a19017a92198b30e48fbbc5f8f0b5f5db55347dbd9d190ca88f9a28e -883d1d170fb0fa95b55b10b32ebed24b1232dbfb5c783148a63a765fda200e796aaec52747441704967914433a01a323 -8f55fd5ea11c4fac277112d72489ac1de28fe163a756b125f27acb78aa6651c70d1cd8c45e0daae417bf894149ed2d57 -8d08685f99aa8525b008b868f5486e24a08568a5afba9b729f7d26370fb1b162937db28b935d67e4d22f7fda69a3a6a4 -b1882e23d784ab48b2f9e58114c5920bc9d0c4c01d2d7fa5111561df0cf2d738e31a32963cfa58939af87e79428659da -a3eba902d376063e48634c9436802cdc6b89d3a7c7cd03b26a3fccc7218dca85a3ed939eb53956d2e001805aa5c2d63c -b97330c40d51a4b71f91f56292b628379ba735509a66c7df054112578b9df40d3aa32598bc64c03c78a3311a17997bd1 -b84f3d2af2aae2aefdfec9a0693f6bd71eaf4d477cd72d80f4919235a471607c5483b354c9d46628a76d6b6fe7c586af -8a1c39bea7fa580de967d8ced7e3860a9031b07842d71f8c5941b8877cd55ba15ef7aec6116ba38ba290b887b4530685 -b120fccf939e7d7959c2c1e70d7a7aa3b84684dd1ca8e5cfa9d281fd06d23eb67a629b1a27052614c3ba639ff9c90dde -827a8e0dc841af0e2c4a9ca36c84a0ea60099aecfa40294344f82878b6909f5581f7b34fa9510883113795bd09b5e4bb -88c24cc54dac5a2982be5ac49684d99f95574bb8cc44afae4f6e18231ebea0f2ab65b49870840bd3e8f2c9247f62c7c0 -b91fc3f2cf743f4ed42e49007514d43dea1d7bab388a18de6f71367fb8f2e9b8e88ed9f7492b647e548396ef3e3d7765 -a175000c4765a57c57b219b21f8302cfd85aedbc3340fa1690119bbe7cd93dac4fd0ba676b1784ebac83efe3e78d4bf6 -881a373630ebc24dfe17e27b3f176de6651347ae741d55675675e9e6904ebf157e787d86eec42ecebfe4eb8f28de6fc7 -a47c8b155c8ce8e16f38deb345a051fe0c9b217cb7a266fce78d7694134247887789645a82c0ac24341f51da8ee6ef00 -adfa5bcc682d4449adcc436649b444dc61157154e24d68615b0ceab50eced1ab55e15b45562dd8e00785806e9ef2b7e7 -b7d2ecddf47e9fd25dcb283eb80e323300bf5c3ee3344abbc3a1f2a3296c631577a1fadfbf685abb336d5d7059d17166 -8833f6b388e46e1f8fef1086777466277cd418051ac0323e2cdac5902d7ae45eefef93ce90b088bbd618e0381c1ada78 -b6abf44c5aee5d0fbfdbcbf1e77354d5a2ccc239b894e1e06d7ffa76584683f707384319ab0e0d17afd93a854d7d26b2 -a8c61859a9553a83bac398c14c987b20c8dc27d63112115b8aad26bca275cf98913783c802ebe3b7c3d878c130407b34 -a5de7a519f8de4daad9137f2c2838544219834cd70457ef09467d869f4dc32098b7a8d4fa85e1eb283632f6d09971318 -98c33a315a66cd8ab9ca8a58c87e5ec588107a6416c4ea498d0b91bf7597f53a405e437ca0a9d9c6acea27ad0ddbf4cf -b2909b1f8752f4eec25180a17163ab215fc20c4a931d4471d3be0ab64207a65c7e462fc0707791286a92ff2f2b7dcb0f -8b96c2fec34cda02e98510a3ed80a980b0cbf4ec03e3c4260f84027cc7453acfedb5f708c401d26db137032c6cb4a31b -aff645dd6ffe8b5076c83a823daca4149f0769bea3293b61330ebd97a17fe16758e4fbbcb5bea7449595c6e261127b34 -a45f8b3b7196449f9952cadc8d87a787a28b4ed89f8c7599e7db361cd0f0aac6bfa464024ded5c0ffc660e417594fd41 -85016b5f7ea9863557eccb0e742cfbf0b09630f0bad3de55aec92b95d4645055cac60d03602586b34f774bd356dd5554 -94fd89dff2fc6099e5ab90149458a4c794eb1857f1dd9a2c84b88099412477dccfc2996cca2abee68d23a05265dcf271 -945a52621ec19d26f7c8abb5d01e4f5630924b75a349ce74219377a137f4a0d386172da523edaa522d27902444023cd9 -afbd452dcc57f5db6b3fdd55368807320459c16559d944ee8ecd1af6acfe9d58c13f37961f78030883f8ad7dbfac66e7 -8ce96b3be871a1f33d559a6e55e4d86a0b92ec3954417f8d98676264596c3296296532097b9b20c83c341527a0c929b6 -ac6a4dcd58486d25a4db1751a60ca4d02b80c939b39ca165a37d9a0a52d8675b3753719f136a59ac400bde3efd036c8c -ac87a37a14a5d48842d30432935929a0e9dce5642142a8c5b95e377ad1bf52120dc64697f0508b7c258af24a0ef484ae -859f0ba02d496861455d9c39c269a1ae5bd224319918fdc3648311c93303c0e13301ae7f3f77eab4ae43f1184a912b64 -96d9b1d2d2fe70b8fcac136a65b62a4ded85aad9d350c19bb955750a0b24f93174e9cd00c0e0a1987793e1180dfdf66c -a7f5135873a1c08c7c8d46adfed19d0ed0e33168d463ca74f75116168355318ad588ebcca1946d7669c5106bc9f5a8f1 -830b0587587b80df078ecfe0857a4b4cfc05b722c0f4f3e1217048ee18749e9940cd0200c1f7a0f60de832a5a44e9f1a -b6625ed0199097acc9aae20611f02d2fb837e4695762cdeeb4dd722517ba5a344e5011f14d5076783f3c32bb5c4a027f -a17be2e528c463aa4ce4bba2df5b005f88e363b87be7324239413ecd5bd68e350d290370e1080ab9911a0d54856536da -834064460f0e5f38950cf5ec197818712f01950ee1f32b1987dcf7f4098d20e1d91fae6d48e8a054390693a2e572f888 -86217b9bd269408ac92b5cffda5716bb3bf8674b7e222668d72939a626f4ab64f30efddf85108c0764127cdbcbad7d69 -8d7cf47b0648be0bcbd3ad1062d90010e5ee84e397895ce98160d5a568d60a19582c985944ec27bb284459789ad8f6eb -ac056e3ed3487427142b3a4e4f9db53f1a752e1994f178577c46dad71be5fad4d03d24ae7019804c41232705a4bffaa1 -94b83d67af6735e81b2e392e6af8ee4dbafb0071d84486389f36f222dfd015da718c621acdc4360630403762dffcbe3f -8ad27bb51c6cb860c21954f5d09dfefcbe3a9a0bff3e24fd1f74850edcbcc76b5b389a616ea0c0796b239b0c22357a44 -af9990dc4c9f536385811528f207a8352b083a4abe6dc016eb5eece0ad74da65b2c6c475a78cd0ecce0b2b550e4412cc -816dcb8ff8556540b54dcc1efbd2242dada0acc1e3d3da13ae581d905a9106bdfb8c138eee93992a23e7740593e8ad80 -b8fcf8e11e5924d3d38643b2a4bed4b54e69f816f40d4020e76655eba8ffee758c16cdc2d970d3c8c1163cf501044c03 -a50e0ef4ddfba6d969e7dd864a20cafc7fa6aa232fa7a806c3d53c3e029cf110828c5a9c354ea42aca5688896f27e6fb -a560435900c48879ff3f89067daa8e512482f061c68474d951c608ebb5a69c7863a28fd1e216eb4b140e32124e50fc73 -b9202d152b7b708ee61c4fde6cf423b481854538d2580bc43462610f12141b89ce779c7398a35c27ea6ed0afa5332bb2 -a9b3f8be28f9546bc70f680dfb9b08c1eea6fc381cb6f3ebfbe33bcab48294347d4e64004c11dde5eb409ecb19941ad1 -8cb3086d265060f8e52a96fcecddfd261886002c1821a8f59a1ddde19a6bb1354b17cd19a9cbec19149dc219a4c394c5 -906e8dea406ba0f0ef43ff623f8521039a9455a2290cae4ca9bb6494ee0aa812528267d1349bd5d339113dc9d1616b28 -b9b5212b76d5824d66b8df7cdd5effcb05ccab5df6ce67558872c99d1e484ab8d21037bc0e22f5c4082b192972b80acc -a1fe817596bbb5bed93a5dc4c03e14eab627484cdc7ab7e4fba569ad0aaa93b34c4fc8680c4f8180d8190113218d26fc -82fe7a20fe93564cfaf7eade8d4d1394d1b4e36048cb8632bf366d3d8084ee52c74d65c4c69d9d24208f7916278aa592 -81f42f9a3b8007e5f02c26770947f884c715bce1e600f38f164a390f159e2e5b6f8522ef566bf36422b14340bb6d3556 -b53d3c89bf2a4b29bdd8f1bfc001c2533f86d869fbdb383fe9cd93ef0c49da0692361baa9f537094e1af662a3461f8af -8fbeee613823ebfd514e991d81babc05176d5c115907ec36dbf83a69eaaacd622f1f36be2e47b984cd6ac66a6b35816d -a9068ba463ac13d4dba25f9bbe3c93baa35828563f357c53a7009cf0c809a23502e023a32f651e29f14424c5daab2884 -87468aa4c942476b3ac3000e740c4dc72d320884357dd99eb25e81d7b52a859b9ebeb55f3070022bcea3855a9a198e9a -a5f1219eb902234ffe8ba809df590080ce8329ee574eb346f6b4372892d66b0725f048465221655b70b3d4c2deba9fa0 -8d9663d4b48cb86201d343b20a8e7a6ec47a4bce0e85a905be31121a01fbef95d9f29d83530faf79dda163c6c76ec514 -9921ea9176744e15f64b20ac6e95ec132052eb853ef47e9334108778fee60d9d9b53fa0b8011c6a4aaae472eb11cc61f -a04c2c5e2c5a7673652919aecbc5fe09a636fcae2d06003ca6775018112b606e50bd2d6ae6ec6131d2a9999837186bd0 -a00ddb29776d2747e3a6e68eb51a7cb00ca0066a9aac5a2da632f355db515b32e2c441fde870c9731a9dcc8d9834557b -85afeeae8bfd92c51522320cded430c2fef57b1950f9f966f47ce6354e492e9c40f950a7ef6d5202fc79fc020f7a6260 -b047d214201744cf7e675af5fbd29579c3b26020c5e0a53e2ce078778b3d3a673f0fd87eae8af8f0fba3bf0f8341b63c -b8aa5364d914020158d11fe82c2b77197ed2b1a12492435200204e20a9209d3c0b4fdb6fd3f0b1db71ee3b986400ff46 -a59a903fcafaa8b5876a3eb1d79a7db17c37457dca018e393324d8db3be7c2aa3ed2303eb3530d6fe1612fd75dd92e08 -b1929c1711ce44465daada15808099234c0c5c8f43b050b2792b6ef9b77825996a74abdcd84d6ef08d648e77cf804357 -85bdc33f8dda0d853074e0657688899befb6356c38f0ec2ac27c46c39fff06617edbb1c5cd220314335bd1b792f1e240 -862047e51f9119f5a0a607469496c0574b0087d566bc58cb5b61a9a841a3cb693b89837a7c927c542ca03d0106055438 -84ba54c002150e5989f59064b68989413abb5f289f3ccba215b923f86f76c19718be51d503ce3bcec68322a7c7d5446d -adc9ea06c11bf3f0d704b321005020917e731e6706f18a5aeb1b56dab3de39a94fe8aca3c248a47565ca5ce82face9f8 -868324c4ef80bae55510316f3a8b13aa40e60c8a3d55f4994439d1dca6f5928c4cb202769d78c21597d8737e391536d2 -a6e3b57e9909b5fbea2114c352b34235a4d4147417e480580c291308b4b9cd696b36278480893667e8ba01fe3bce571f -b92e1d6ba0a2a244ac5ae2e7b20e152591c1c466c9b4c658c72cc5985ded0392b04ec00e32291f1652d21dcb633919a6 -a3e2bb4dc07ffb1e8dc9055ab45bf22864980f64b612548ca7feac85ecdc426f773d6d48bb7e6c7a578025bfe99307e8 -af764cdb70d5afdbb49dddd519451218db4e97ef3ee622585880425c3d85a8df88613f4b51ad40a1f6635e45b2efa5f5 -a426230b8ed77eca3d1ef7f4735fcfe0e51ae37efea5b96ea3bf313c241bd703b91a592f035e98056315c9822ffe8c26 -96a3ae7f1b80690f97372d086d2d13ea2b40802bd053980f73cddfd37045364ebe38064a8cf3531e9bcbfed421040f20 -8cdfbf0663bde624b703d7e6c36c5753282487147e10e5a24fdec75836f7034e4c38f3fa3df373476af969a4f835cec9 -b7f7a549cdfcca30b78349b831ea5173bf5b91d56dbb999b2dbf6b85d8c22ca8a9a62b38e37dcad7ee5136a32edd5743 -82ca90321c43d616670a7d85447afaa9034459b796b51792c970fd5b8f124e47a13ef661291a4ea58a495e68aa36dd87 -a824a36e4e2db2bbc513d39e4e2a841fa81106437eeb4fca9ebd78050667d0b284b7217a35ee3eac67d8be58c0af317a -9370dd0c0f9c7585761eb5f06e7899d75eac07e13c140c64d4c506b90495fb8ea914f222608c478708d4b47163dc9907 -88c07e19252e905faf129e3e877dff8dfe93e81b3903b150aa33a93a7eda2820a8471be935825d709dc662d06c9f99b7 -81e936c00425f7db8f0dd88b16c3c5208e8d95a5072e69524f3b5de45f4e2dd25f0aba8ef17016bd914bc8f5a42fcb6b -b23227dceec18d6dda92a15b7dc8623d9928d545db93b3547fb068c99cacb3fcf3d7f88e4357801de8a652b919dd907a -b23f1627219587773c17070bbb190e1280ab27c5d7e98b43adea0e1f5017790149b71f90c3691301bd514d20238c5e6c -821b7bff6349c204ce50e00e296982536baff68031165ae4c639122195e7295ea0c82ce66fe32a1b762f6a311aec384c -a26c15bf1ef4d5543c4a006e4ad2a450d44c93c62c0f0b035698530cbbf925f6705d375e1dc8b2c6fd9a2c69f4126b77 -b5c5bfff4697fe13a5177fd87a8e293fd1c6782cfb3d1f95c5ddcb13c309dd1ddbeb14cd359c9f3029b57ba52996c9a1 -87a0d37f04155bc22ade44f567dd8a81445facff15d643886cbe6534aa44505e331bb75c9ea2f27624154a5890aaa2cf -ad85c0e6345e2333a0ff76b769592f2b24fd0661984498dec6fbd2d9b0cec5f139bd71331a28b13aa490baa7fe27b635 -a9e6298b90aa8d3f4385858e08f393b3bd61376ac3dc44a0907ccfb372813bbfab1388d544c1a4907aac38a87dab2abc -b5cfc8bbe4cd3ac1a66b1c8138c5c68e643f7f4c310cbf1483f6e48d4f7e2d1cf24b2704fc687032eb03978f18239072 -9493895ce0c815b60b0ab3a989f63c6ba4c752976160f3e52290a724ddaac9075e07dfa913e113807e0e57725b1cd593 -b1e800c2aa32d34d34b24dcf890f6ccde7da60b98c4646a5471fea7cc6df8862b7a9c4c40f38d0554e33e2984fd564ae -90a18f877f149a314767f5dc15c8726efe5d20a8e15ad4922c6042420a2cd82018be813debf02c6d69b96e8a27c0c5dc -8fe35142442c103e7bca602445b87cb017c76befc83d66894d4f810e343b3a571f3fba14d94521340ee7c5ccb13338dc -b43547cfaaae899fc6295f496f213916e5adf9b0d75805c32df0f969fbc1b4f8584759b2a06b81546b48004d72f2e8d9 -9410d55865098325c7b559eb4e84fef8a3ae890e1d6053b3f173ce22e60ec6563041ad8cedaa2dedbb59f3dd645dd1b1 -b127d9e4b8280e10434d53207a7191782464ae83b4463cd8a32026e5d8a7a8c5306ba43ed9b7ea637d65f64d6a08bcec -87de8fe67524c7d107d7033d4107659206c347c47cbbdf85e3441b53c933417feedcfb049465c67f4c4156219a4f63ac -a582f976e77b861731595ea8450c6b525e371c6548cbf7911f05560d4c7a4b62a425d5c785190628d1aa1f8f27c43b51 -a195e358742d924fe2a7f955eb21ced7b211cfcd5dc3e598e0d2713c3639b72f986aa586b7a22a75f8547bfb46cd52a4 -97c249b70ca2f9da728a256d18d600bb923005ebad3e1d541ebd580af3fe07123fdf87f4e8f98fdf9dc8ddd826ab7344 -8fc7891e2f540d8f20464a36056f227ac2ef3bcf2b6edd4cd2d9024a48fce19480fba36afc7f5c4bd7234787b8d17f31 -9047512fa27e2d8d901516b5714133c1845494b6f2aeb2a0570dd8533852f00a8d9a8ca64979310e83ac73fbeccc33ef -a1be9cba454617af0dd38865ec29e7d0777d7c68968c856f90b5bd63a7cc4274fd8b179be54143bed972b921864424df -b086ccc8a705999184f51e9b45c76975ca8b108b32a3955e122711fc1ee007d8417a85c9cef217f28d6c7799b60aae4a -ab0938a72118ee2980b28dbea9f7100c6f54fa82d93fba8bfa81b6bc34f9d2033a987e5d6d3816fe0bad53cb88bb8c2b -90fca0bddc14f70282f11998fb4c289fad5c0e78c8e8f9e7a811f20413459a05c9d107ae771e9da501854022d827f2b8 -84cc69b7200f63c2214375a7a0a5ccc14bc02ae45bb6f3b27f67ac538d01e628c66b40e5c40cee38bc8634f1a3c3cc6d -8a07a1cc0a96e6c6da0d27a540e235c2ab6a95d087e624c90cdccd781a9bea6abc0456d896574950a9e21e7d87fdc582 -87f2084a2f2218d7f9eb7725617ea37db0a19fb0bcfd7c95501f62fec0bb6bde3950690420a40d93e26f426fc622c825 -8c9fc9b470dcf8e576af943edaad28c29f53ac7e24657618c21d910eeba6d7b16f16c418bdd5cea3d639c3919e93b7dc -8f026883d9d8c7c2a5c04e4c7220ba7061a48392a8a7794a3e290a94967d14caf040a3da3513fd9b4e695376e706006b -83bef852b9f387a2aed0d3537e77c895799c639310cac98e7b699e9f5d74b2b21cbca58ef910c6583e0b849d665ad379 -b08a03accdc64474490706edce9df7853b78b719ee731c195f70871b7586ed274778d99b84ec3cb8cc0b5e38c102bce0 -99fada688669b2ea8d9b7cd730b057292ec3fabd30cb733ea3f7cb76f756b244cfb26df03b9c087b6d9c58f5233dd1b1 -8eb0fc7ab6b4238f2317620191dbe835d4ebaad0882e22e8f0857053d25d6d9077754251202472d875303669dbb806ef -8fac2cb38c3a1e361aae5313ebdc1c7e0b7d1a440482fbbe24389a7fcd381169fb325c79e430be170452326cd4931732 -92bacde1472436209032f0592973a5a40d505a9b2c9de648eed1ce392d0c18e23aed9114a9634ad3a7e6afc4ea80ff21 -a28b394018434be07323a2356fcfd6c70b3a4b1c6b6ea44da1da66c389a659235e0dc941019bc5053ca41f10d9b6db2e -a6d23d7fe7ef475bfe6486ad4a99ea376c6a6db3e70a0a7af421ef6e6c4d6b9cff68d03a7239a56eac784769f63b2bf0 -a1232e6747573e19df98a088fdba57116745612cfdd4ff21f8df82a66c7d5df7e0a6c0cd73117121a516dfaabd0f5016 -8dc574376016b73f6730103cc45c952c5df5d047d0b4ab3da0303f66f43f7d147b5eba5300750e885c621e72b4a64b43 -a66e9eaec79c958e624655fc2adb7b89ff3da0393898e028bb07cbd6511ca8d9318e1d60dc11cf0265a498290e756ecb -8e5299b661dc0e088527904d2c2fc0256613a1fc2b92bb92c633acf145edbeeb053e82b468a3877f6f14f0878fab57b6 -969943ce7b54f6e728724b26cfdf4df90faf9f9796bafb910ba66d96cf34062fee6ed9121abd193c9e322950c8eadbcb -ad29ce021d7fc875d1e61ad3a99e112ff092ffd7900a608bad30517e50e2270e0f8dc7fb5cd42f1bb995c17d86268f48 -a55fd82520f4d35434066bf93a9601c96549cb4714d9ac05c32e16803daf8763e23c3125d2005eb229bf5d7e2a91ec3e -a95eccc21af531c5e1a36ce88eda6b87732f5fa680e851bdeaef73421c1c87c8e66bc314b07ab472ecb67a08ec53cd4c -8f48b5a0636bd89a1ee259223065449523984cf3bd9be78c9242276c848d2140bd94d1a6670e446b51b178ff694b5c7f -8a58b340e30f0cbabcba1c565b68eae66405fa2242b43a7f7d3bdce279af42fcb4ef58c85fe89cc2dc56a41a51f058b9 -99103a659e26c9a4d19404db4220dcc5defbfacfdd969eb7d70b4fbf9b2c91c92112c0097e8f0c32ddcfc35741da21ee -a088cc15a45094cffac52c38df427b7144d621cd1d12ae87d74c00a039d757e36fe3cc2fb35fda9b33b375553585497c -a0f1d15bc388f6602c975b4b9cb23ab83fe31124acd946195b999620c3c20c6610157a891114a43e3af551d7b8c3e4be -a571057592f3a9008bdf726254c364975705a71bce4e084a37915c5317f635528088a2f50afdbe7240c14d813e8e979e -a31e425feee58f8372e2bd4c21c48c299850df34044f27db3e4df55fc5e7c042cd19be59500acb375fd3478379f06053 -94645ca6400f80d9a90f5b1c5b515816d6049ab04a552109c9c16b41366a7f3931d49338d944ee8eaf2ef5c77062c362 -a61fba865027b7ccb03a4ea966081325eb64db5a64c5d765d2893f6a19411d40dd957d8a0b34733aeb3f002a4e0279bf -8199b89ea13ef8eb2f54d27bdcc781a5a7fe5bfef4ba4444bd651ac6021f4d90250b2f2cd8c63fa3ef237ac6eb1bab36 -b39e1e98d07c95a4fc19ab175147547e5a20e66c044f29e4855818db4a7d0e7e2c24192aa8c89fe378f8d8ab3e9f0e1b -b807bb0069474e190b40bb2b34165351e73a392ffb0de83879ddb181989a22bccaebfdc90748f54de81c41ea244e7ebd -8b058266df90032a1a9befc7abb759b64a23ab628edd051da8b81db4211c72fd63093dbd94796b0690ff2b0c0fe16cd9 -865decd95200fe45947a4249d2d8551ca5d7b3d7955adf10f94ada3e69d684e5c5b8939fee9a4457f22d21bbd3ce9670 -95fb5ce7af13976320b36422b5cd9dd46379d13110fce619969308ed6a250cf3eb84c73e8ba1d32edc01aa2f6e367707 -a1a176350aed82d5ac01a072ac7f3cc1535e20fb597ebc7e417921537f9bfc4cfc0d490d4df831f0f8ecedb6be970a15 -974ddd091c1aaab7ed356b65c244748a713e98b133c5606436e531c31b31f6ccdcad2037b12c68fb54af4b19bd1d82ab -8ae9b7a8cd856087300ca90799ec3265b92f84da8ee9e98c6ede1be378dc040d0fe68b8ffc94b146f2521b9fe3d19e54 -ae17df60b83e4530af584991b545bf4b3cc1045416dc15250a6b75a9a04defae4c0f60b8bfbeb54c8a21fa84fee58e69 -aca1e75d4a05282b0cbe6256925c0f269a4a8323888bece4a48aa0b5e7bde7fbf1d3e4f5cc38fe6a38aaa091ccbba4f6 -ac19171d3ee2f2e5021418c37a0eb25c083de6a6396290ed35b4771abcd07fda745fd082e3c32c117bbab7d9fec2b67c -ad8a35eebd3bb28e08b9ef64bf2d8b75ead69db29c96544d71686ccc0819ebc6823e49b3b879ce0e5ee3131153900632 -9479f12dab191269b020b70132996cb32059ac087e2a3f3e559d297494189e1d6849c340ace032946e12bd4923a3908e -8885e680de6c158cd67d66c142b2b4ac42b96e97eab8e2dcb90c3b454dd214bc530fbab6b5d5746064b9813775b6d5a0 -a16d8d27d9b2fa04c7eb8436062a53ee0a4d679bb205d7d7cfc24e5f28e3752a9959847e9e31496bb0cb1c11caadc30d -951b00c69dfd9fc80b17733b843c440c58095989bb8744fc9db63a4a6116f24d5f224a279478fba8cf57753261bde217 -8a693564994a1dd298f0b279e618b46bed349c53236fed9d8e05ad9383ce55fed02b8a361fb8c09ec5ffa8a271cee015 -a09fbd62995a33904b4a34ac55c80f6d4cbd39a902f5db1038d909f1a2d385c3f5eab04b157b5662558bf35ed29cabc4 -8662373988373409a4b31d45c5110afc32aa008bccbeab39d5b09a0e10370dd879684e722a8856b0da278e2bb91d67a2 -8980d3cb8a82b3a827ba65f44e50efed0a6f37d6c150d70e4dafb67b1db173b46ca29d487ef9db92d37ca8312d246008 -a279558faa11850aa4f0dd9ca8bddf69cb98bcd4edfbb0c19f22d1bff85d808e8f2cc026d95afd09fec2d15c116bcf73 -a3fadf9c3066c93aa6a31d2346ad0a1d012c12ca7a24630aee46a087eafe5fa518d20647856d44ac03576bb3a9f81a76 -8a8a19b09417e1b1607aeb54841fa69f58e094b46971c6a5cd0fbeb2aaa98c56599ac242272e6973ca0a9d2c09ff8d77 -858a636f510b494edc76e86b1718228f076b8a21306b02abd086dc2a96c7a034704d743ca5d89b17903fe7b2e43e6fe7 -b031b789e4073b82bb8c78f9d3fc2b901d75278733a4fa0a5aaf985a298269a735217e85eacc0dd554375d610a425359 -b8603ce7cff755f5e07eaeb4d74dff179cde405234bbd7b3f62fd903054aaa34a9b868b04617d7d407c2b8e377227f07 -aa41829c941acb3f9f0e2008e852fe855e153960cd3c85c4b8ab9f97ca91b7a5aa18f997cd023ba9e03a653f238a4f46 -a35639f920619dff592176aad2b4b071d5c960f149c3a75311b16841d1872f29aeeb7c155cc9bff41ea7ee56f799de78 -b252195aaa52e9a34936ccd1aeb40d28fc262cc4570d4f9685da8c591080e97438edf64d4d4d074491344bb5e86b6b23 -abe2e52d10620b503dd1aa584e005d857294565ad90dd89217a77fcce4bea7b0c72d54dca7a1c31b5a9042a9602557cb -818085f2f1b525d9b2322c8785bf27a6759af9aeb231b0977cdcc7d7e77cab5de056e522dc791e72b8d9b93a9c41e833 -930f64d40ab26be006e91deb854c5b22bf6951308dc406b2c7c7791d5dcec470529957fbcfd6a3c9655d544d974de7ad -92b28bdbea8c7588ad3a27992c19d73bd3a478b276f0e11c4e82ee2482e4e167cbcfddd17a1ac6bebdd862be65f54098 -afa6a85fb906f5ffe52b6e9715435dcdf9f7892a396d740d67560fc42248d23bef470989663a73190ac9da442cfe6a82 -82d3338e58fb316d66694ff4674a5d99bf0b13204dd251fdec95d48382f2d2ac60176a19e5ecbaab5e00af2a39a338b9 -b30cd35eb15b3910b8b8f91cf04c223d79d587a7ef713030f0ab93f446caeef52c60ada365f8d3d645b477e7fca61d94 -89554d2a9a11dd7e56f0b568f2a50c72d86362d95eab5d94a2386397012e18bef7c9e01a2d71fd325c0692e4d316dd16 -ad58326fea1c00e0f8aa92923661be4b3ecc79164d68e91c4d1366c9894b6d049a4f31c9bef6e5f21466ec014ba6b94a -8915a16afb0e68a84fd12a9203f8f348954920126d88136ec027a81f541b67c421b84ebb3d6e8f085c38c2499c28ea61 -8e246e1acf655572863481367da007e94bc1bdc1f28aeaa1fb163dc05a51c3526a2bb9bda0a14fc6d658d85a9322e44d -af83f9ad3c7c1504fcf60084e0948624fccfe3a9892dbcba8f166d0d67b475ce57ba008f286069da20a0da0cffe3b4ae -aec86d2d803612e8d27a01e3382e0a876164baaf2f3b8c4e9455ea00bc2e525378018e6a41ed9686c6408148e852bec7 -871bdd8c84abeb1456ef73595360de6cf9f92ca9e6a8b6b816ec7497be60a9f509ef2c91332d17cb5fbd347bb0113d2d -9503ce513df28b61d721fd5e8667272a28f210ef787bee58538f786acd16f04a412387c6f5e6313c43f426a70aab65b3 -b2cb0526e7e524ca9fe918e951c19460aca911d2b5ebf97c2bc74aeb69778a28316dec8916a4e3628b46bc51586c1bd9 -98f52ee1896b632dff5153e3d1fe389c6200b14cdda6b27e12d4a4182763b63e0f587386aed78c97a32114dc286b975b -abbea974929c9ba70551231e3833d5cecc71c60988826771f792f190ca77c80efee7607dc1d6bf01a53796d8d9b73017 -a4cfea1d06cf840bd599b14c011b6b204b2cf6f57fc7d7f310052062a4fe8870f02504e6c837c2b556c925921e543556 -b957529d7e5d1fc45c5a822a6e0e480e46af2f5cc3801c31996b9b1acacfdd8d142265148b3e1453a0df0c5e6cffc5e6 -b7411aaebb1b6a6a75568f81d052e60fa7752a64c20dd7cd5457f999f0185807987de8fb72ed94ca9d1148c19ecbe1d6 -84be67a5ca80a1fd0f43cce4c00a465f167445e42232c2d2cad5e1097a62d3ad564041a55f0c76a340387503f15e0ac4 -98803688f8e7b445c7ad14277b9f5f12acfba4f9a4ba6df9e2b7dadb726f1bee5098fd15e0b5308b6686a38864f84912 -b085eaa421e566276bcd45d8b9fb71475c4530d63e90914eb2a33c17333d5628c1ec8a45691cbae82ccad97d4addcc94 -a08ff7dc59dadb183dd0b5d336b6174464604bb2b49315e0c42f34ea08a8bca9dc9207750638bb7ebb6387257411956a -94d72607cd8a75b2fe2e9333959bb9d5b54d74ec36fb8c123c157b19a17f01f310b3311116b34bcfac305e9deabc79db -85fa61a796226ce555f8195c792ff6f3d483f62dac41c17b7e8295bd49ae6039574896548728fad4ce966be84a62a6ca -829ab1087ebb61db05c59e3c9d03e7010f8c546db117a6409bb813f6fa04061833771c8aa4c5e2981bd1ee551df0ea59 -97f5c5261db0b130bb8352fbcf65002327bd6d8a7d4fee2a9bc293173c8c54be37ae229c5488c1983bc1f7857c66188c -8756439e5978ba19e2cef95dc55f706d53a05d1fa964c64d89b0e95470b5344b2f8d44680080626c37c77a00ff0e6b00 -915d33f90980089c33f403ba4fc5c689ea7f1656f5c4e1110db987c59eb981b6a46dd9fe82c8efe7d1e3504f1d2c4d2b -ab5bbb84884ef036c9b00a84f7d5ffa2931854e2afa5a63121fe64d548531af4203495b977bfb9301bb1e4679d42665a -9830b846a9041e4539eb858a179b4db6da89b507424e6d858ca4334d973ddae255bbfb04ae25c3276ccbe97c46f5816d -8e35f4563b8a5c9a76cc1da87ab21cd894de393dd61bc977cf22d3de454de350836e032ccf7d6ea55e2e6b83c4424146 -b6338ced0f05806c625905cc51b7e772c5db3bac144e897339f67b6949f4d648d41b7d23bd3f299f4879507951ec031a -b3afa470fc71b92f415b879a814feb0702b6adfa08e395cee4f7d8b0e3537288f16c83b28ad4e2db02c1fd6d39e6afad -b4fcf7af3196bec84fe1f6e3bbebb8abadbcd46de02a37966d0ebe20972fd890803d570e4a201f2a89f479e09f19191d -a21fe1f8f57691165d0c7d8436765562cc935288f24fe765351be335f906c6c4dd1d0714b134c51255b14511c957319e -880a3a8f6b4ba410be06628a011e6bfd38d86919cf8014b4b4e1c930f8e3035749579389690f21bddc4d4699de8a4b1c -907d93a7666d847a140367c0a0ff80a96d6a8295b07cc4ee52d3be987f431d8dcb95d3717dfd248a5643c5395ec2891a -b8f38c78b8a2c487874c1a6a92d15cf0dcfd26319d4cf65c2f4fa9432203ba5ffefb02b7324022c34bfe0da369d96d65 -8bd4ebb6d720fe52d626a621670a06c8a304faefca3846df1f619f4d456e14f8bdc547fa7210b8639b89c6584ea5c5d3 -8ebdaa288a71a2d3188d6294ad0948a4f72c1eb6a2e921ec82cecda4d315a86e3e6233b5ffdc7219f34a99e9b4555317 -83320fb9dc62119655bb0055192471ae06b7641dd4af64670a4d9475155733555ad06a93ad2fae72e029049601780654 -80b3d022738318238dd32f122bd88cf2f734a61e315ece521e9e038f4a9bd7b54b5e67784f5949fbcc5fa911dd4b048a -891a23b4bf5cb8558b4540b66fb6b9fa54e9d0b2c084f660c8bc77af5ddb97cb5d8042b538f61330d9fa8ccbee6c8a41 -8e5651d9c95aee23835bb1a06eea76efc9d5c881cf87ee847ee5149fdbf3d67dcd8ad0675dec8fca6cef25368348abaa -86bf1d094bc4fc7c21b21cfc7adbc750db0b27c35bb160d306b26fefb2699cbbb1fe624df1b9e7f6f895f1b81a829361 -aebc3cb2623344315875029378c71ab7ed3cdc9d3d42d4b835b373c8420adefd177a44e532f3f06f74f0a40d53713e5a -9527f659e93a740b4c50d0d3d9aaf1a85936f04866ffde1aed30ab2fa1c1d565b46bec5fdfa510fc3ea934137bbd46df -8488673a4bc29c3ce9133cbf41c546fab4ff28c5d46048a21e710a8df4f2bd1c77d0ee242dfd962a30d646e5ebee8c01 -8cf29773c0e0fdb75bf6f52d7066e7d6e9a3ef056bbb70a98026464b32316189addb5766822f57df63bb68b78c85e1de -810c6c1aa53f9c3fd0018651b1bf25215fe24687b568f21a121e0bebee576a75e5f0d08ac9c6c21085e52228b314c6f8 -b529a87fe47402aa9ddaceac63a060a6640418891f931036c6e4098a1b308821a6f1a244fd5c1c22a6ed5f72f6bcf825 -ace9284ce89b5c81049d329db2376a85feeacdd9f735cf00038adc51865bb78bd9bd5d060efd0b727c509ec19988f99b -a2e7a949c951bddc99e68d80b3f3fc4ab960b682229fdd794f9eadc80bee91dfd5eda0052149d05c74fa33bb40d75ecb -86bac22daefca9143e0b1d25534900b1f7711ade4437642043c4a8c65f0d963cd1f0f958c7391e5a663dd3c59ed9de60 -b7d2a6e2d44edcaad19498ab3368bfb87f9ab039cf2249d6e76091dc3db0c3bf45012779c02811cc818e95796e6ad9c3 -ab474f74e1ebb3dc696e7a6bfd8845ef15fb6411fa28426c486f7b0f789a6af3016ed5f7da2a36215729f5cca0b36b4d -86616a1a9dcb50d1896f3eb937bde67f213558feb401aae9898e41cf1fe33b443170c7c2dbd1648c9e3cdd0c24289286 -a466169a2d95a5fadb6a69c7061cd2911c3eabc0b1a2488e216f8cdbd2c5bd87e80908b002b9efa51a67f02d7af2155b -8368af8b7c0f55f3c4f7036fbefc9d6a0ee9ff61197cea8ce48546753bdbc0b61eab604b8fe2c1aa91ced7a879e5899c -996c91779ff9767232ae603c5b1da5bbe0e303c4c2c72ad2d5944ee1297af3535f6bb3548fd1fe8a92cf4b281e1d83ab -ad4a93d1ceecedd27389c658b38dd71cb13c729b27e490381d8c3ed4815b11ecbc37b1f82c0656e0ebf77e5bc35196b1 -a3538c7ea3dddfbae80d67caa9fc547938bf77114559f9fc5180d9d0ab837d7fb1b27bc37405686f212f2e98b0028e59 -8abc9fe135fbd48414f2ba28344d9f49ec2d5ce94fcb314ab8dc31c754f3ab7e6ab268184a67dafe8b1fb811a762c112 -99ace100d8db88a83f1727b7b48baa1cf45b971d08112e452f5003566815ccba0ac3f8b1df6504f55a392efac8e3e70a -91ff50978ce629651f1501708908d75b490c18615e933191cd37613a83d4b605b0b48d024d27807637e662056d76276e -8e4104331ff1a40cbee9f489a814cf5bbd6fe4eaa1cbe1e13625fc3e6697b27d933265e5ef8728cfa8fc4ba5b19a614d -a442360d49bc9ce3e75eb40bf2ba05e9437fa594e8b8de34bbc822cc7b706dfa0dd10bd6bccb702d8556cd1320924821 -b6ed6cb0aa34d5793e929e0d9b9651e41da3457a0b20c1bfa93a8f65bbb65bc07c7507482d71c1c285f5f663ae60019e -86d64df2dcd36d0c7348c77480c8af33dfd889bae7bb045888eecbd317cf3e4731b96ac18f410a99ed33a3f22d448f77 -b8dd25415275d5ef8260bf5195ddb9b15b78a8799e4d15cca7d6317a18eab7bcb8fc759be61360915a28a8fcb5d6ddfe -a325a334c84dc1d9acc0a9315b399d4be93351c7049f474702ab58b4cccfd69aa50b8731ffd598ef0144ca96477c273a -9012a2dfedda5147cb9ceac681fa9e75e2901eeb3c94d87465a44d11250de4bc66d1e00ff674f2da1d800b43f686df9e -a1049d59da2a942d4d2aabfc0d972ebf3babef9c5d8fc5598ea23a048c2e58f7f17b4d860e437276bdae221d9e41e3b5 -8c9d9a8826c812943d74c4d4f0fd2f1c8087135c37bcd9647b722b59801b01775a644e38c24b43e8e70f83bccc4afa27 -b9cebd7bc7b041c18bd35b970f87e9b5183e4ace034e21117001fff8a05b2a7f9ab65cf6ab8b818b8192d1db5649312c -826710d6432ef97625db25104fc8dc3225bea594a10cdd4473d5ab72be57b74928ff356d210032a61ca590bc68509880 -a18422ceb8c61af305277628e154d3a9c49f47e230a44c6216128d73db7c3ca9eca9f87e29cb2126f1c312f423c61463 -919d357886de9eaddcfc46cd43e2b3dda3f82e926a3aedf02ebda9159faa00736bd2cd7aa044c76ae238a3a95a5bef38 -a822d5a726f5c38e9d4a750ddec80bb965a6e5374a3d87757e2e48a18421f3142c3985450d1833f3ff4ca36e3b838c89 -86bfb86eece6f6ea8f51985e312171b9bc821e0c3ab4cace556da28dd7bf89cfd5be3fbdadcacc19f2371c6a11c564d5 -91b42643b297d8eb2c1bb3f16b57ab2964de99dd22bcfa07db1d0010715ebde94d11851df575f4f1ae602644e454fe0b -a5e444ed3d5fb3c5afd2c9c24d676adbf396f5d1d47bd532edbc72c83845970582ec49ed026b3b982c9c1ea725192cfd -8448387a14d84aac6afef682a27be67e5b05d31b59346748d2940072eec771adb53339f335daf4463f555da2d8543f18 -a5034b66a26bad0f753be56dec722fc98a072bcdaeab0bb9cf35a56a573d9424cfbadbbaa8ae30690f7c6c6495331fc8 -9317ac32da1772099f41564ddd8247e3532528b240db753a1fa6fb35cc039c6a4ac4546597bb2fb28721684bdfebdb88 -8b4b0001a6234335502c8b17c4de274b83b0610960b5c46b9075c6e41f357ef0d8c94e9b14bff8be7849435512626ce7 -b1aa903511fe4219acabf8761a8e4316cc4f8955ac8640c68a7b547cfc65365a8fe0843a4098f9f17a4c9beb75624393 -8384f4953395aba4939b24b0669853df78f2fcc01b2145c08d3fc333ee2a7d4adc12f2d81c37d0cc187ef45b5f69f59d -92beb5a3c14637f84ee7a3c9b4d9b305b10af8963c087b86047e9fa959f41ff362d56eaccfe887bad1ccbedc488abe2e -8c60e16dbdfed2d1c8cf3f1bb0b0f462489293892f9d2e0221b1691321a771b163fbb599daec4cbd917da75f5f662de7 -a8a6e3041a0c2a12c76f51139b221b03ccd1afaea3b72ba2c3533b797d5f67d8b90d3474b4f6f8e19a77894fb90842e4 -966aaf74560bd4d164ee46c7d393b2c628e307019ca4289dbfb6a9a991608ad80efc1ee6e9847a19382ff8f3004aac8e -adeaec475d4bfb6075be90cc37d61d45ce14da77f8a9a508b9f829ddf2abf91683aa2fd0372d3025a660c94b0f612685 -b3392bd1ad0c202d4a95912e0e06d8c64d7e2a8818dba8f895abcd0f6932efa9a0bff8a2aac107046d3478782fe42d33 -ab38804443da16d32f11c0e364449ed351dd36b7c82b5c7ababcc33a930acefe09fdb5261da04f6dfab29421fb1cc017 -a34e0df9e953841bc44c09e16d69235a26ff390a6d128339ac97aaae5616865f86153d8d7466519dec6c52ad592dd3ad -99581db106391e6816403b1e9d13747aa05bfbfa5b46696cdfdedd1627b60e1ddb92215d138e007770512e93bc6184f7 -ae60c3b1ae3594aa4e3f08eeba3951157921aa6511148c6d32003d42157654d4a3a39efb1bb317135620f09729d134d0 -adab0bc35ca3fefb14729259b16907a34e10ddb6d78a23f28596d3d9b244709651be7719537df33bcf003c0e43bb1a66 -a31b7b2f3411f986b3415870ae42f90bb678a9fc44c942f6613cc4f90f3dbffa4b5fb8bf3abfa4361dd8e396d9a3c5ab -a69b188a8662eee48fc98201fde6f0d14f6b54db83ab79c2ec2f4b6be809773231704fae2cb281fed8b05107c63f2fda -b79e1e7a9045af6537981f54dfeed0a1335606301b73eff001880798f01ae9c0fef6e427e171afbb1d0a78135ba912cc -b1b883fbe379995b3741836a849516a0f21b18f42a34db2c8cba01f86711a2baa5d14910a110f1058e36431dec163cbf -87bc463b90123cd9e177f2284d72a7f4a1d4151659e1e4e8900bc21986f641af2f9a3386aba56601e6fb64da630b84a1 -97a51bb7d717495f943db162837d3bf700ee0653da9a94b36153443584602156e168fde97d77407d0861641d8d373094 -8b02561709564d0721b5247775dc66c6c09cf68a8ea62fd7dd361905ebcd98bdbb2c554fa272de71c6d22b04d33e6902 -a914b9406e71c09deae875bbd628af3f54de5ccf811365cf229dfc69541d996689d05679eb02d42a0adda02be6e32d2d -85dcc5f3f77f72cf0818bd04c037cef560f0b0eece3191e06fcbb54228d11f7afbb8d9f8675b404bb39ffd04a3b65bae -b15bcb96a98bc6cc7b802dc29b79a903223b1712a10a22e776f45c530a4f767665dab1a3c6d1b52157f4b79055d5ac81 -965e353e665b3734042b61951e105c1800718eb3c46759952755321ff5c639327d045c58fe90befa896e96b826910298 -96776a5cd26b69f08a68af0201b2f739cdfb9553b466271063a6c8b8307f2a3f51294ea12c7e8118c0e6b884886e1bd9 -a369453bfbe7ef0b2445231704abba25527b073bf735a968758975fad789c74110a573bc7ec50001368209a0ff385500 -8e54dc4f2a557703b2d8bdb74ff107bbb239034ed363818197b2569c03572c14cff21273e94802159563d50205edd651 -a1c66a1a82c60dcbd139b8ef4de62be423e7641a6b94ce0d0468e60bb1b000d268755946a028d3961d8b4d3722016ad1 -b14b3c26dd9d17d6fd8eeefc7f706c177ebbee9b8d05f9b01174deb37649f77f97ef1a1abc0cd4ca7a13618a4036067d -8fe8f9754c5ee102bf96ba6b6f29a14fbf83cfe3c5f81b5358ccd4db87fd8c5d88760172373bdfaba7eaac98ab1fa863 -a8c308c15242bd9c7b28e110715315a1f9818ebe03662027a6f1feac13a5dc9bb111d29444d13546d8e441e49960b0a6 -85d87035d74a1f4662f42a8c6d26782daceded0aecee9232b78139b1b50fb764e87cdc5d1ca9d6905735dd9c3dd00dbb -986c31370f594d4c8a9096c091cb1484c1c0755804819a9462ad1b67937c6b378d97f1e4c27900405b21de2646be70ca -832b4b427f3347b0073c24f54e17ac16d5a80d04261c1d464f89dce89f42750d69dc8a83ee0481e410f94cf1d108c0ab -b13e54d91d5d414223caf43a7fad36930300594b8cb3ba97c0c873cfefedc165d05f05deec8d74a0412d5f0932813088 -89c931d595849c8e54f50d550ae4a5d71c4bc74af436965bc32adbfe829a48ab15c856a69070b4a4602e0113131ce4cf -b03731793db466b74112a1b9dec3344fa952e81bfcc7fb2bef3cb20f566c3b2bf60c16a93f84f77f4c83d8f2a535a2d2 -92e8fc80d49001139363e3201c93db8326c41322db51937ab641ee7f1b2f7d03089e20eab19afd27abc23de039ab4b0f -b27d95c90dfa91886aa91c9c8c85ce09fc875279028bef49abfeaf44437a0528ade620c8c2b3d712ab594e73c5c032f5 -a42e2598731a792975feb5b24bf00b1e7cba1620922f8c2319dd5878419ce6099663b448299c0623ce400875c48e12a1 -b062840f63b555a254e3bc36e9075d57c816ed2e9cb0e262f9de0f3692456d94eef702489e5b11c9746b949b5e84c06b -886226745d906664c476615dd41deef6c338ee10380657fdb75cf9ef28b4d9f56e69c8d0ef01e9cb80eeb42f3e5773ba -854a3649dd5b22def4f246eb0d1f1a206d3dfe42b5e44b5fa963a7c5b8bdaaf7f35b542b3e9cc53187e66a2315ed9f9e -b5a48cef68a056955ef4c080c85e4044e9f8a562f2beac9fbb5e19f8d618718c86794338c6dae8f94b6f5e9f8e98404b -8f8bea7304cab80d0009b417c198bfffd166eed6f6db19f28b7616e8b0733cf0a4d54d204361d7f8f179985c8c3a16ad -8af81f10339e2f75f6b6fe22a641298bf90c8676260abeeef90bcd52f46ef013f5aa4bd9d0b5ec15be61b7c3e0f32350 -b0397c64034598c825f9ef653ff16f680325546695ee6e9c2957d3c87593161a063c5219304ce6a16b7db75f1a2c5f7f -8d2e7677ab6fbe2b0f5ab6dc356190bb3ecd7fc468c698d512a6c69f22ea97b71fa961c88635897a5b539ea51b70b4a0 -b4e91a693cca1007fdaeb7e679c6837bb8eae0bf61aae447560ca6eb5ba918cbd9952b41769657978413106b359e169d -a8331a907ba7d95a5e4090a7680d1bce3cd803db49fb84a48996e96514701de1602c4eeb4b5e0b1c2a106c4f678a72a7 -b54dd28a97a5f934a34c2817af91a41e57f88d7eb5fb584d3b6692f2d1c4b2a4e273c4de5fa33a0fd1fa02c9d7cd1fb1 -b8b780e0f6059ea27aec9f3693ac9adf0b93f75fe7fac5230deee1e7471df0bce9b5b2f260a6a0a346afa723860471b2 -980e9847ec83d61442a86cf8c7464b357694dbe67aa5de3a8c88ccd1a038256453101366dcdfe11a565065d78ce89807 -9350a17e397bdc3d2bfbb84ddc79a48bdc6ef5c3d8c1ea39251e762fddf9962b69cdd42c563d03f64615b72c9dab07bd -a34d24b69089cb5ffc5f06eb2acfeba13c96a1096d1af9620aea28753baf3d0aad0bcb30037ef3a5ac36b178816e878d -a7c8b9108fceb4e0377eed48af9846530114df986cbdd35f6d54026104fe6bfb3b58e57fa2b3a750225528f8dcb8bb9b -b0f71f6a04cc7119db96033f89530853d58a445565de2efd269b1e3956397c35a49c328102325b780fa5d0cf5adc2a4a -92be082f04722fdf3abca7ebfd162b7062939c3410ec204d5478dc8de2bae2b25e2654441d29fe2c350895512d333ab0 -95e7afbcac22dc2d04c5635d7a8c6293f6ce29bc6c932850d24ab5216b449251bdf7aaea838ef40e0e4eee1de8f63bfe -ae0a877b488865f21194470677e12ea7e357c5d63f6bc454f608e33df9a3b20e9aaea5b6aa42e8999779b8b445831c39 -98df977479667e23b897b91f2db8f4cdee7ece7fc3ecf8a07d752efae090d8bd34d781353ec1394550d8a207bffe582c -aaa0f1bfece62a63f3bc76862b8789e2593b4bb40b3c413956e9e5c4eec604e39d722cbe1db210396eca7c2293489099 -b362703d2b72909d06407d139531fc144e68ba94e55643cc3cbb9ed24145223aff460b1627b41eb9a3b709978aee5a58 -b020025128804bd642fdb1d2b70b07d181e5ba30a5ee16f6bd00d7e2d0c6af782e454cec107304823be61647e65221fd -a409894c0030081a2c7f8fba27bd0ac53997a31b35a33498d78bbcfa0b7ec0a89b9efa99dc1b8770ba889060f39d56e2 -862f9eace3f54288749ca8402c22ddd7829f0454d17ff4891727c86eace899cbf72d302065f5f581169f00186c23b4dc -91432f2a823c3ce95bdeb5854e8dc7faea5031fd65c82dc69e4adbc5ead2e5a5b58a9cd1428d3f526cf94a217f37d7de -9543a9038fdecaffecc4d3023fd67f7976dcdbc7014e82edb4573479b1789b4c610c3964643e031f69ac7a3e3dfbe241 -b4f31d580987f47c550eabd2d276678a294a612ac26806a06634b8812a571391151d84c29b6b82218cd84dac85bdcc88 -8d922ae4eecb45ebc23eb1a8404aa1524b281d0f0ceda58ea93a0cfd4184efb894c047f0a46e2d007704f5506544907e -98973979672d1d52e561cae7331b730a577c422258c22720edc344aae35ce071be1b017816d58bb29b9cf5c433fd64b4 -a46be974ea72c5e5bd16de591bf27087d97b9030fb4a74743bde5e480052a0de58bd962dbbf0e0fbb0559566c3d9780b -b2b4464973322d865207949afa4dadbd888c9b0230737561c3b76a1953a85ea9439fbb1db9d0d42083c62419db512450 -ae811a9eac5f4ee6cb3a4dab456a3e5d95cb1ab303c19e76fc4b36ef6b4c83ec0b2803ab8680ad1663bdec0ea2f19aaf -95a426f3d2ae6c6069f888010bb20c392bcbb65d0986125e0f0066d4206f4f443f70dcba8a789da042b57a36980e75be -a9ec01a5777d10275153ba7441f2e27ba3d6f1a875f204469220ad999bb8a0372369278bf5a11640ac0709771b814a31 -adf1091e24bdf10d848f1a0920eabca0a2087220fa0c3f8e5b4c72ca0424ff3e0c77ad4c259c12c3cd1c0eb0cf32c67f -b9a57eb8642729541088164b9974775934d7a4c56a3a3ff2a190d549b294fa87002810f31251170b0407c7e9695cfba2 -8625501e5c56948812b72b3495747412e03ede90096be089cb8040069e49cddfe697766ee72505bf715802fc77c08fa3 -8a745aeeddd1be100474d96aedc737208ef19a93a8ad72c10bdc0218073fde6209510048eb46e271553b04d8e6529f46 -8b8d9ac3b91ac0333094c85e81fe2b8cd5c2207073a33f66bb1939e8f1c84ef064a8b2ee984a9f450f0a6e54bb56ccc4 -8cace31444da99fa5dadc7c46f689fa427949d8c089af3d90c604fbdbe0dab052392fbad4b5aeab707e4caa9e739f366 -8750c8bd1f1abe5acfb29ecab0923008cb4455ae8a1db01bf3317df05e1e02f9df3c74e879d9c57b8f59877591939ab4 -8904a39ad86cb42c06692d4801b3718bb63a07a2dc5ef13de16f668b08968db34966457ff2e4cb770dc61a216f4abc5e -967d1750b0db53e977bb9ba65aa820d7970f8c75d5355cf12a3f4c509dee7e9b6c0f7a828474b167c25b15d74f0e9cb3 -b37297bb6c2d9175e0a7654c5bc6d248f47f7183c3b10375f07e21e9f3e66f6581caebfcf468dc0f8c04132a2a0ede55 -803862e6fbca945cb6c0ba202257df5c7e1e1fadd78b842970206575f70c9757d4a54e9b1a0a269dd37c4f830a40d2d6 -a7a27f2fc7a1e6d276522177f0ae6630dcf5205d08c19319c315bacb165b687d125832d97ed689960885bb7cf42fdf36 -87fbc08506fdf980cdd534d4ecc4dcfbd381f3937dafa09db402e07a67e1cde579e680d3f77865b5669f35fc00901530 -8fab8bd57f76d187f1cc22e40b51736b1b0234e70813ca02559ded9c7835cb3dc71a24c8f679081510c32f330d6ca45b -8fb917b7dd71e1728bbf32fcb55343890aa6fc890740f41f42e9620b5bc3ef8b1ec67d9c047e4a9de0863a5eec18e5f9 -b7429e758850bb7f69db000d49763df43d18af11460ee0f158b741dd6b7575527c5c8068cf54f7f78098f9ddb92a82db -8bd3c73c1b6f88ed2696d53d2a0617f74bfada964d2eef2afb5e1cf00bfb646f552643c55d5453cc622c9ecfb23ad492 -8e025e91b30b0f328cd6b79df9603698f1715eb6209e64ef8705cdde5ee1c4ec737a61d9b8a4e72e83b2157c621e1590 -ac0b91bbb5ce5bbc8e8d6c0d9d4e51b3960169c608b6220a352aeb13072133aa9d934b4e69d7c5c39fde68d467fa8069 -88255d08bde3b967dfb1dd338dfbdec12a2079851aa796be070a1d70204048c34f2739b7461840136b03429a8b83b1f8 -97a83477e765f3f17eef0d3243ba9bbdcc50fc581f904e92a853a076adeba917279fc0e01aeca42de1aed8af9579bca1 -b0d9f1afb807e0e6f839632393edef25731ab2141cfa1cd965e986940a4916c8788733a39def0cf67afedc516dcc6ce4 -b563e9ed9ba2134011d7bea6314af5d71f63caa1bcbf878c26d7162dfc76343c38308955215252962fd0c9c87200f1f7 -838d4e97bd67822c22cda558f0d35f971a0ab7debd3da3f15c27f7d4b3301b2c17b60cdbca0da8e067f23fc97d136ae7 -a7bccea326cccbbc4773de402fdf2cbc21a028197be98cebf6e691a7679fc948e6bc4981a14fbf493a254eedc444dd7a -8b2687732f7aebb153bd6030dfca0b6d257b8f2945eb8221ffd36ede50d463172cfc4bb17dc30bd21d8572aae2540d6f -a4a3e87ec5984c3a755cb39fb04472583a0d2c771552b0701788f03b4618c87690a13a905420358701777e8b5ff2d190 -904c4dee5dfff129de3fb8cd0a6e0576c18ed3d77f49b8f0601997013cdd4ecadb86690389555ebe8a436d8084024f2f -ad1d9c7a6236b22474fe8d45fde2e1f072101b5cb7018ac73c0541c0f9ebec4d5c4469e0570cc188cb5f5ba1d8958be1 -87fc8ca6f737cfdedee973f1586b94d971564a1fada0e4d65894222edcca6552764f1ca0b02782066f19f871ba5842d8 -851829a8b39eb6b91523548ad600bb876408cabed98d30958056367c686bdedbc876e1903b8af8ffa3d3618e3580e3db -b99270859bfe7d8a4c1a22e2d88a644dfd2f100c54070ffd9c4e1044140fc0d21d62c61214a2b81a9cfadf944327ef8e -b89a2ddc91c59dc2ed9b8d11e4838002e731b0bcc576e0e18106238cd3282264b14cebebd8a64f004521cbdc690c4182 -8be96bb11a025d265b7b3ff3151e9e227a8416e6118595ac29bf836ef751504eaa3a9cc05bbdcdeabde11f2dc3d20c3d -87185ed410be571fb532e32d0ff4ef68e98ba2d3d5fbe92180cf1fe8ddfbcc89fd1e03694a9fde1a12ab905db89323d6 -97ef023f71850ddb282f244b3f39579eab69ce5bf3fe5dd2159329b7def4982cdbdb4e71476471acfea0f7ba5a7fd061 -9944324d804fd3978e7e137e6e65348d7473ea23c591136d55779b5a31f45f9e4d866d8a18c76a3a0e8cf2ee61cdd041 -b9930c9aff260105d4d15fb749aa33436f6fb52cf9d50e39dca19d9cc7938d752773f06756af86369e1f5fd5aa71d5ea -a85ac6bc027ade2a9bbbab2b231241cbbe56e562fe621ea19208a8ea36e1baced89ec9ab8e2f83b602539e5c053f5764 -9917d40d37549caae646848e18ffcb49f5c6c4e396ebe7e74129a41b0cfe2726b4dad34d51f4bc706063e654da898824 -a25f8a4d8ab34724a732dacd2b316c80a6544d4b8c1f45115c4f55c3efae6129b83623ffb31da80e2601f70ca51ead16 -932b54b2bd26670936843a92346d231f2f3e3659542f4d4def73fb36ac0350733853130a5e5e9d8e386d34f817f5a91d -871bf29d7263bce62a02690681d4e1c3c2f9c2751de4e35810ece13c9480eab93b80a00230ef0ffb858a829ee6bd96e2 -ab9643bb1c32dc2e8c05ef49bbde9937072af214c19c3932be137b7b75268edbcdd81d1370089be44462b8032bba3c57 -b67d510c460a2f14b7cebaf9a15642a14b2542c13ebb1d1690596447ddfce6a86327ffa377c28891f6bbd8febc2c17ca -93a5ad5019a8e680bd053a524e0ffaf8cb18adfcdb22ccb6cbed67012316bcebed65294bcc0cf4f4e2915dbf19ff0948 -ac7a7fc1140b1197f2aa424b053e8ceaf48abf41819efaff87a2e63cd6e962c278942c2b97742ffbbedc5cd426a8df50 -af0115d9c2f887ff97ee15a1116ab06af1920f2f42700b75cc010d4c8038eea941c9bcc8e7cf4a41036813143ab3e8eb -90c768d880b6ac17ed7ff9bcf76cbd5c1c4879247a757d8cc8b31c4c7bb0ec763d746e6e06e361afa8ee158e36ccaffc -b3f10561432a97c95d02c1a6f317bb1ab5b98cc88cf5d56e1492ca84eb2ae1db92e9e31fa454de562e719b71442e69f0 -8d94729b5fb0afc196064991f9b3c8e04c0858199aa951f49421ab890079804179fe00707978f15637b8d16246794001 -968515d07a0f0eb52adf439d8f70ecd1f6655072abbeea45431dad26c8937f4aaeda552a22a420598d2136f576a966d9 -91f50e6f292e2bbbe226b221cedb9db36bcd459bfd74fd6356b0620766d96869266315e8503435af1719d8ff765467ea -968b328d79e183ec560e8f0de113298755cb23a893a631406defdd26ecd52e4b6f28934ad2e219382837fbb8f87f4360 -94c126a9035059d2d817c4fb16cb13fe6047c356fc495aeb369acb1c45e89306554631f50d313707e82624b6107d2fa0 -90ee85deb494043a1cb280d687e3f55345085e576484308755df1bdb6f734e7dd25fd2489cea746be5d2c6384e7986e0 -92a4f64d98e7e633271bdafb1eb88474013b5ed2c65137c243729df0d79ccdc6b210118ed3587ad00d3f0f757400e47b -af31031fcc867a53760216cc1f467901aeaa3b28438fb3ec90d6a1c8a46590062c40fac939bc3c7e7a7deff8f83c262f -94306afe09f20d5de9ea26f37f5fc8df1e29b3a6963caa94df031efd428545493d53e0d8d7af12ee525e2e21cba23324 -ab6285371b981d5443ecea699af9da916f9320b3ed0a11c15503f3b10eada3ff5dc95d24a54f5aaab97d3312de5b985b -8e9735364ae128f790dfcbedcfe0e11b991602dce0c90ab3cfd4aac74526c30a798fcb51a8ebcc5528d88c724e9c2b02 -89a3c12bcc68129b14fdc1d9b5db8d26d11c6c9467f5bff7c40abb8ec23b193746697421ea4400d5ebe53bb3fbfe59d9 -8368e44144947f9ecfa5d126f4a57bb1d3728fe3c5d3bf83310174d638a10cea02ae79fca91d5489ecc9fa679feab49c -a0474ff532e1a6a3dc8f16ae27e77d6ab72b62535ba0d3ed09da5c692c6fd34424141cd68470922e1e147fb7f7479d5e -b9ae0e47fa8d999135f78c733cdcad786b96087a340f86e4cc2bdf019b07fd4a76f9b4b041eb397f61bda20c31d27838 -a7262ca18a7179924d28161d64e6b6cec5da35b7eaf695642dbc127a7bf4a52bffad82b8d3fcd010b308dd72eb567f26 -a23ecfac8a3f978f9ca8810458973f528846de6bb92fa6422b9547d55d29d7db7d8bdc5181e9ee2257a458466f714449 -b04c32403400f82677d831314956acd3cb507520ff14d856cf8ec4fab37a4428a5d24ecfabfd2c6086e4ea6d26b005e5 -9669b2725cd5965305c6ea48331e693086f4c1c4ca7dec26bc6290e9a8e70f9f0bedca6e36985c39ea35b412abc7f4b5 -a6f68cecace45317a758658463c5fc1f005283d8c3d3de9364e7dea453007d8d4bc849a21205d61ef81019e0d25858fa -8ee19ccc1c83b2c4d7c7b712bb370c129201bfb340c5b49d991207c995f870de2d0efaa88e05bc9eac567c4c36e20175 -8a530ece1992d1de92c4e845e71a1ab24e53a8a0679aa5bdeefc60fd890ca3cee2121f66c6f4b29c437440e7644e65d0 -924338d7f356da9b8477b3aeaad6f754a8d8f6a791d70c3ff23c2a6d4488efde9b9fc351319f3ea1f545dd11cd23ab76 -8eb76f86e057cfe9f655ba29bac89cc97db07f0487c86e7b41555b5549897bd3d042cd2ede35e312cbea357df622c6c2 -a2c0da965489d15ced574f5e27cd4781a1dce8fa4f17762a25fef1320096b9eddd92a007d58a194ef57def3aaf4e925b -a3fc89753e8896d796859c9e5a00d184be7d37c4d5741ae8a60cae9a7a30c5d840325d6479701e1f61e37065fce81870 -8b2f90cdb3add567b94f4c7fc89a8a57a0f06877639c33df2697f7c39e52c1869aadc98a2f8b85a58fbb02bb1bc1a441 -aeb2c22d9186725ea40d3a4bf551482bddeef42c0ad33801e35361d3695769429449c2a13955cccab55778d3ff29b664 -80bce007abd8ebe2238d465a312c2d125d1a695184b93108d728075595c7716786f9188e90ae37fea89009d087e71b07 -86f5df2b83383c737bb6db4e435f496ebfd56b51300612c402bea9ac2f439ee7e98cbc2655d31646472ef983aa6ccbbe -880e8a19af5ad76f14cdf94396b8dacf061e02eeaba02d4c29ddf0d07c6d2a737c987d69ea2eee52f0db5a4dec318932 -8b82368968f9b5bb175c95862ad403beee68d199a20d5dd618395daf11ff0c2e1fbf3a31c23d3e582556276b44e70b99 -94a062abbdc5ba740077fb9de722ad2ccf3f6ffc8b4a9dfbb0bf2ff789bd529e7b9d8da520d0342af91808fc00431638 -890b4ee1e9837a4c215616819dadbd3c6ed7586ad391498012a54d735c6df0b72c2dc3969d1b24cf6fe822f37f9c10e7 -a7dfcf43c9c22fd22f47db490e8f0b8f42597a5b4ae3e7bc4a9b12252b32f89412a2aed946eec19b133cee89b4a70322 -acbd9e85b9d9c3b068220f893d7b6368984f6cdb1cd06a784cc9571f0c632775ef890dbd51371e8701894cbf667d04f2 -a9b1f84f053ef6f41c59b1758836a82d53932cc4b8ee9c2cafe705150e1c717e3f5c15fc21a2532c071e9dd9bccb4dac -b2c63345748a28d04680e3e451d1f7d430bc8ff2031b6bd4237a1f55dfadaec20d1854ac158cd6a1466dae525c1b9b06 -a23e7b2e5b8f3e3b0e350e1a461708be9c1434d49fe2e51473e2e360bb0be140a96f8ddac99e3b804557cc25d3e44776 -a4c4729a38f5f32f155ca4d1994b61802ee418b276486e2dcd681fec13316f3b6d4a8e76eb9f48e2df0339543b11326c -93be67dbdec2655edfe40dcdcc0a7e761b7259a9d909ebb12fd7c9a5d4efa10de065d2eb049660ed01ede2f26388d43e -932480849f97e32fb14d4a69af4073c377e949af7293951b3ca371a306d9e2096157f51c8e5036a44eb73c7c842c5aa9 -8b5e79ddafd675ff88d8f65176321a08183429d42d7fc1e7cc3cfccdef0dc5824ee40f279a05edbf4d50418a4cab2126 -962bd6fcf7c7f2a9c569d584658a735bd16440de2ffae236c68ccbf2ddc5e13836efb163690062537d52f7d8bbb24222 -af80793655c0b3ec3029673c50a7f212d297f9f80d7d1c7cb1409d292f3bd7dbb8b24581017d9f3964e3432f46e79ca1 -94c8cf3c737c102e9e91216752c82b17e4e42074e08ce44e701c2f8ac7c08902b911cabf38c4c5bd41400eeb1fc97acb -8708ea7af8c86b2a1964edf64a9e9c56c7febffa742c3ff2e3088a61d3ccd63e135811212878ba7ad8a819e1859f4e95 -ab8e726d468417c168c892c10c7e2297e50c67e4283e5b48c3f3b014981ec482e211374f779faa0c1ead906f5dd4114d -a93911e672aa3d8dd686280cf062f128bd8eefc058fbaea52cc0a9bb255fda84e65ea546f662fc75fee4c5b24bdc61fd -8aae6d9289d8adf0f81e7990cc79cb704d0a975f03b9ec02be66089d62954fd9a8b005c5ba8179cede366d25ccf40869 -91e44ca55de8ad3ab42816504813cd9ed9c6d64abf6373e8891f909cb49c8a951ee823cd1f947058d542f0bf6290a11c -a377f97e075b66e740b8476f085d50ce8ac21f206802384e2e072f6b9700a5f9cf0e6f2236307775c0e0d6ae8459d864 -953c08d9f2a9d6ccb22cab906efda69ec1c228aa5c2ab93822b6f71c007fa3bced68c6a70ac605c6145e4af770b60de0 -86d8dcf5a9ba81cf6a3149b2fff96e36639767e9de461bbd3ccc870634e8db331b98a888d7e8d3d70b6ed241d8ce54da -88db73952866ec07c49b484c6b18de70d439e67d971c1b436684d489253cb96d793cc4d9a4362b51dffce837dbd03bf6 -970b7aa9070334b0649bea1f0b4e53fded64665f87e055e3527e0e567cb57a0e97d369aa16a005155cb69000073d7695 -928c8aaf72b3f51e38c866ab457f75cbd7131b676817a3c6d522fb8f876b01a9ab3a84238eaadaa0a095ccd6c1ac060b -9561e78d16061b5361ba0be11387c3f6029415f83bcc8477b8729e88c55f4bfe74b59c1b24bec0eebd9779cdfcfbc96c -aef133788d1e04ac64f573f3ffab473209dfdcaf2c675fddcff83724d17b91d6340830409b391a94405d6ade005cd01b -b8ad4ab0a1ad6383e4cb12d479cde732f202687ebf886184507371ac277446b3bd1648c49c89343920e5d57fa6b255c3 -a8d00257e331f342b79b3d25b74d300b070326b358f690edbaad5e325293d8b55078605a43ecd9dfd27206013db4c286 -aa71abee2720052cce7a5a0c3968e64c2c540cc852dfe08b742fefe005dbfd10397f66386744c9bfbbaa40779c2ae190 -80c6680857b88afd3ae8801677720100f0fdcb9e49c82f74b8ca5a27aef34e6df03462cf9ef5f80169c72da15be567b2 -8c2f2865e132869fca5232ba5e6844ac0540a53a66971ad54ff91f186e011e5412450df9099fbe0b987be443867dfdb6 -89cf681e0506baaa528043a15ab3bae09b8817853e889f0b3de138992e52612fa3e50d54b3686cbca6428a7644f58208 -89ddf69b72b9ddf7d535f742bd3c942000061a5a54987f2ccc7a09e035be978cb32f653df9568526c5857a5df4321f59 -9908a3288b9a9972c3f3f0d5923d9840756b74f31ae0b24ef2188465efaa5247b1ed13b774991bbe4c065c7e71b487ea -9454ea9a664390fb1ba79fbb5c0cc765d8ccd32a02d946a14353290fa2a1ba911605ff2e302c340e9ed6fbe8543ee6a9 -aa4f4d9ef843ca3ba334d73af634a0ee800b3393f8f7701cd152274f4296eb79d63869d452b5e83976eca246203d6f03 -8fce1e2e59dfc4fb46f3741d27772579fbf2f48acf1a38c49b0e5dae7d35f2624af3a46a48b89bd835b7d452ab0cec80 -810ec0e58504ed556e788e23067296a8e4b4ef31257d508f05e5245bfe6d2c2f658fca8c81538c6c9ea6ed05a8f249a9 -b6667bad0a7d49cd2dc60af85e373fdaac2af0d34fdee51a9fbc1fe8b77470c162a04da38228fe68b7d5247d43026734 -8982971d57bdf35e0f34e867fecbe0c140d94101484ef4ea01b796633beba184f980c3ced28b24ff42de1dc504dbc854 -86d8d1f3edef9e61058a58d966169a05f07fed0d93bd4f4a7cfca5a872b2aad0d1a78f8ec7784828e5813c8da577469c -b491624c3d5e517c9019258db6284d7533778e44b1a0060dec5f655a7b79057141079115f5cb1d8d97a90af33cd7563e -856e1cd4f9ab7cf323f5988bb5d272857d2fa90527f800362569a39defd93e37be2a60c11f498c482654f55560356f7c -a08884d0e642c479fc8e5a9837d1babbe63f3165c02a57b19d0547fa1fdc18ee382ea82a86cfd3135dec8f2aff793f53 -b1a4de5ea703fa5ac8a70ec515bc65203a9415f6da109b67fa32843a39d7fa6232c9c13920d78c0f16e99fa5f6a27e83 -931a2ee3220ac7888157c426d1b33b8a56f8879fecf1461af4cd6c85f94e193bd6ae6f8dc3946fc689e42bee213f0027 -a844a78e65ea6f75bb55a5db1e78b88896caa1d54b624f218eeb302397dc98a084a2ff4b964acd0650667160928ceea4 -b9c214280a15b423654a36b11646c928fb42ed2a692aedc01441c67522760df29c6ae7bbcb9237938a823188ad4d83f4 -a19575f9bbdfccf970bb3754818e49c709d1bf0af015541182fc7203f7aab51cad31544072d52c0234a3b649d03d9a52 -8cd1127b7485ea7f349e2c89a4b78fab3e5fabe5a95ff0cee10a3f4fd48940e431ca5e526f6342f7da93e32e8eaa1448 -9906abc725e445092dd7dd0aef90f989e3c78aee96f3c0a67ccb62fb2a51363c71d783490fa5fdda0ff9ea69f5b9233b -8996df92e014c226e5ac724075c19d19a9204b2e086ed5e75a9bfa1f8391c4c77fd5c0b85a29f28b302a4af29d38735e -90225c9490b39d151a80a9f4d9a7f2595961c44779a54d5e195ec95096f77e30157c6c629cb1c36d995f6c3ee129ad20 -85925b1dfe3884ae3a0e993b67b6c49685deeab6cf0d9997309961b7f727cd6133797bf04d21ef7b620d1d6392450b64 -88a6c518e577a820d83f87e9d5f236f43d262756b1bae0fde72af241fcc192417ca9724428d17a3f9dd813712a772cac -8f501fd5634fddd00a8411c0e9c6947bab0dded26339821bc3543a64c519d9575c3129f6619c6079d5e95237c11cfeac -af2b42945d7c81bc422a1bcdeb80027a1a243f89c65c173294d6c92e4cb3cd650740cac17408e7ba1a34d37d865b9bc5 -abfa5e76f1112602ddf152aceaa9f588beda3aba1115d0823d6a6b074d28389fd4c8178e8a845262200b9af024a33a88 -9732a0e3efcef5ad4d43811bcaffaa1418c791d3fd6ca4489d6cbbb7c44b55156d218f0fe86f2ec96ac306fefab2e694 -8837a6c4e60839ffb0b59e94b37d81bf1ea392d44cc81717c1c9104468d31fb5fc3c35b1efd9991b5e7e9819c66a7221 -b6545fd0b455748ac3482e0ead3b0157563cea7bf6bdd5ae2af7afe1ade921e5ba80466885ba73a89657a735c92658a2 -b72fc49fd3be541bc26cb968ba4eb3078ce7c71fe0ac06340f7ac25c0befb86af03c4cf8f31c857f9e5d946401e86bb0 -929f424548e29c3b47fbbd59ec00d17b00ee1c4f6b966c1fa7e0f8528d52078278f2852da976b8931fe813b0c3b71ac9 -b37861ba981001aa6192cff06c13f041410aa60f965ea03dd48068b4295d61d2fa276c3f477f985f50189e33308c1876 -a73c7cdffd646cffb255d2519d8e08dd8d9a9eca0610211177e259230b8f8c7ec8727015853197a0f11eec8b59d4f2bc -8da1260ce51220ad107c3127e871715bd738639cd90824d1c9f5b6181304f363b8bdbdb42c21e4e360cbdee496b573a9 -aac6bbc35bce8b54820ef8d7219a4092c49aa5d4fbb187968cb91ac04bc44fa119766f8c630a727ba184cad19278d9c8 -b964de0bd31847ada13dc3f6e1bdc679f421e262c03353e39f0ef1df720ba05e6d806dba15b6e10df559519ca125fc39 -a62e4336b61f85eaa415f57e21cebc7d54c68f6febab02de76bc04a69658ab1d2f7cf0104da79448e32e2b7c92b684c8 -897c6ca595bb2884b643ce8e69078431979d7e6e1b2dcc6effaf5a62fc906db6466f85020bf5930597adbd99e2ff90d3 -932956e0ba09f6499f1ed231732a444b0adf17080237d9345d06d4262fe8a5fb0f704c919513ed42473751069c57dafe -a24b9cb4ea9c2203a95b0056bb95342c4fa0d91bcc25595fea0161e7d6f45595f7ea171e0ac1bbde13a6d8ca6ad10bf5 -a7714728bc3318f6ac005e350de94f59495ef3972b328c673c5e608fa9059be3277b48f03a5a9634c3d03397af7d089f -b98732aec7a0a9a7998ba51e2b76e5232379482d0047f4876cd39918119776ae2683590f7fe5e44d12b3b3efdd916e8a -87700c3fe20cad8fa3041976c87ee761941d323f2d64a9818f20fcdf0259f796a11e55cdee31446bd19307cbe8becf09 -a37cd03fd348694b2ea5cf081696d12dc4ae108da8d48695bf74c921b90612d18c1aa71b1071bbcc02829e05ba1363ab -830e4e7ac24fb3f64294e5c64563ab5708ebf0e133540b35b985390d68c420a6d680d779fc87245bb1f5c58e59c5ff39 -b5922242a82565753dd2c1438008462d531f820af1b565756d4d27a30e3406ecc503b1e5b628012ea0329fd75561dd7b -91068438d2bfbb0666824d3cc2be488f2eaf3a8a9f21805838f9f2d582ca6bcb103b2f0f313b57bc86f87704aad7c7d1 -a9a2133fe55e99114e526904f5fb3e2e141f31963562887a9fe6a262496dc405c756bf6dfdd6acb8853ef5a0a5146037 -8e48e79f9eb1f8757b4c4afc4e3d6da4d368bb25b4d54e3a1f34f3af13d8037b0d465b29894f68272b79cc60fa676071 -9378b90495b0e6468dce3102a97e9965a5d21fa4a6494d401888b8777bd58616b99d49177f2eb2796476ae84d20b67b7 -b0aea247d7d7c7767519b87dd66f56c306d9eec88b0db8060bb97370099892957e2c950fa2e05f24f8ad097889cab087 -89d0d48769ad81699d5b83f26ac49a29c3e835caee03469e93c11e5f4b8470eb02b52290bb2c37f06afb0746630803fb -94de42d8554583b24317d9ea283dad5849e2f124f659d0afa11414898ffdc4347a9c4ebe783dded21679337b58b67f4d -b76c3047eaecaf4a4e6fb6176c7f4a1d393fec3a360f4c711d6293a993aee39d5aea654fc6429c2e4d4955b12fea5c8e -a307fcef0915e3e3a27b94ddb9561e5d210a091714b73afbc0b3fa5e8140e8c3818f4914903975e8f78d0492d7784c25 -95079c4a5008fb6ae0d653c00ad901a108df0b8c442a68492740eacd15048106b7c4cb5ee88bc6b1dc089987935bdba1 -b65a354aa8e92d6ca2e11f4ed3c1ed011852bab8f0e5b8157a10c26db2748be688512423c11d582b3dc1da57b9d6a826 -a32c2fc62c38eb19dea24b545d2537dfe596423f8ae530e562ba7eaac34139fb443d88f18f39d65d36a65ed1277973ef -81b83b37927e9a6a7c34cfe587dc9cfbd560db3ac57a8a88161fe4ae9a7c66843d32f6f568c927e2ff8f21d8b4299475 -8b6993ef73c2021842060ec0424464412242aeb711da2c43d3985f9d15e4d936eb7a1b5098bfe892fcd3b6ba8bf42369 -965535b46a18f94a1203fafa4dee5963742511ab77e98e471e03376847850357d543dc6ef2dbb765cbc1f03f66ebbc14 -a9386ef496b4f96bd591847baf6dcf8520f7cb5aaf1713025ee894b40b10f243aef06c553376663488377fb8b1b0a022 -a6bae4486fc16ec1f12817f2d47871c8bb61f5f1a2db5f828c6e2c06bca64b1ff7cf4c059a10d6bc2f561fc3a12aa38d -a2b6cda6a75fac16f324935cc1820bfdf013ae02c209802befecac0288d90263a7f84762dfb7c9aa1351415c03288714 -aac87216619a8c50b5d54432ed5681b1cbb2c7084f33e9a91889bfbb94fd18c8071b79ebdb403ad81fea495bc1e37dcc -8bb3b3a7ceca82e4268ab52c00322d5d0822427e43c1d8b88b2f43c3dfae7100f6a29832d16454e093579cbaa1074062 -a2363b4506b1464391a194412a73d47d0cd4ea1ffa541cf8b936c97a46bfeaebd1fec409c6aa2109d277bfae0ea7f0fb -b56911be2bbf1e564715191a526c2ae73bb6e85c45e3dc22bd9dd87cde620de93875c48b11e02ea66eebb68f533f353e -81609eacf4b2e78a9d7f469e0882ad24c86ad98dd18f466d321aa32a762171cfc334dcc049962ef5e63248ef48244229 -866b26d3dbab7837edec84217c85653c6abaa617e0ba2657d67757fd1c7dfc0c7f83f6198fb85a49b402108d6fedeea6 -9771f5796d5d47d22100c7ff7d191795677d53796f4a1e1aada949b372ec12decb6c49e28f2662e729d44f0e09eac063 -a9fdfbfbe114c7f93806b988c50f8ae4e13a4d433f2e40c72b81d0ed7fe879db5e89216a0b0c8392a6d9d54f57760ecc -965336222244229fac41336464c36dac8700d5289c0aba78016db76e436289a0797af8c96d52583618f8c6dbe7b3562d -99719ac482b72d54fa515395847e9a65b733da84f7d10a0be82f34afc20159d64411aacca15041726251fd90ae06a9f4 -ab96b7ac88842ad0ab61f7550b7b4697d6a3b651cfa3c10ad404e7505c742e2c1364bbfd08ad0039ca3b81ffa9d6a6e5 -ae96088cf12f76140888582f6f6404b6f2666c048950166e37bbe46c1398fec343fcacd3e8f332f7afa222ca13fbdb87 -b5b5c1ad493b2e72ce8ba698351f596cb85841f7f7055e31325cadbb4fec3e8045b335643190d6b97c3049d10551764c -85f066c7ffd2bfc4519f42f0778ce0e46195466768322a22673a073ebb66cd77c7b8b3a14157845cdb369d3f40911421 -99f4f10397cb7ff47a2d9d2f29021d1ca96f0da01f8afd76f72457cba6e6376f925fcee28ce77475b90c9466042ac414 -85116606b18f6e5404e9176570bf6d7a9d86116e5a29721a1b20d6b28a733886e2085a7563cbff45d1f11bf3d552ea12 -a17d81b236fb138ed820d335dde2640ac3a44cccb5f11fc6bea5fe3132c4a9247b874e75fba55bdf8093f0f56310a999 -8a16a5cfe10c5dbecb4fd9f4b0c370162071f88198e016111937199b87d006d1b24f3f412d853d7c6541e1c68076b70a -8cb83fd2b1afbad7c454430fb9dbf6530230b782c7dfb01443c2c16563e833c5b230f4c4268dc37a55a681a5f0bef420 -b8851a8dd6a3a17619e7c84b18f29ac9680b456c03e8c8489376e6de9a22ea75d1730787ca5d269af44eeae47f87bc24 -a8f990c9290456e849ae4cc0c320580fcfd50263af8945d01b00baddf801aa0a7bef2ac119d4d1b4be6290615c781656 -b0fa1c28c8c67ff87427691047c362aa35de0be9b0121d83b116b23170ad2b712a0b5bdf6a57a25c59201ba165d5f0d6 -afcd2f5e66a277cef775b636abb598ee9d7e3bc1b48b521da787dc561cea8d7ad963f593c3ac6f23a66a27c15876b775 -92888863568ef01b40d51f467e8364cb1b09808238644bbee5ed118b392475e90c6a1e03a0ef826dff5ada8d10be716c -a8ddad388f2dc94294371d0ebbce02016c463a65bcf3a5366419a7a910d3d24748fb5716ddd81cbab44a2362ee3c077e -8b8ef4f818ca3de1683064ea7e968edc8d9fe2675b8bb2ae637a5784a20cd909d18eed45140189eb9f080c53c06376fd -a52d9c49db4819cf6280c220a6cd306a5851b771de3032f28c7f8750c20e80cbfda57323a55a8c03085b41f4f236b5ba -b01fbfa0f80ef574a1d6733899002a8672cc309e1014fec8e81ea1e96a7be9c247a570f825b7862e814e1f006a8227ac -b07e163eb0f96a51d74aa8a7fab5d23e44e37b1b1027ae9c4155280d8d159f0cdeecd3258c098a7358c5bf2fcf1eb7e2 -80c4512a5bb5e8255488fed7b7e297988732473f0ccc1192cab716a88d035e23cc374a937fca7da87e18048ab026d9f7 -b3e343b13c1d4c98b7706edbf362eab12b1fa87510d5cf168e510844b24c8a9624f1e7e0babf455c6d425741c23e1ca6 -83e4b53953ef683c512756b3fea37756b3c562c88a15cddd902eeecf0de82d0345fb05feeba511e8a6de91aa1f722ef7 -922512dd5ce444df62fded2c53a73385570804e7305cde401116c06dff5ec7812b776b8cccdfdafe422f1ba53b2b56f5 -8d1f7feee880abfe9f09708ccf72f376013b2910886edcceb76018759b88b95cab9c0e8f176faf042729b405a10242f5 -abb7cd087d0cea2cdbb47cdf9be2c6a0c6ec113e1ad5fac083f66a027697d477ec69f46b9aff40c239ad9959b9854e11 -b10592443daa8708f8c882da795da07465efb9829305170bc3bdd781cb6651b503d3b21eca027486d413f1748f40f068 -b14dcb895ab22335373d2b736628c1ed0e815072fd3844867ae24638aec60f8591c6885869ad0bfe509fa3fa3101a5f0 -89631708996651bba6b2113626a2fe1ef0f2ea2f21857b2a1e5544ad31e8a53e755b6d611546ebbba4b2213acde65e72 -82e9436700fcc5b842ac2f0482de4248ec9d1f206db3dd36917c00c7749bda257fedaec513d8a9ef3765057bf5aff25e -b1c2b26d93658451fb4e9cfcd77209dbfea909b2212c000fcc576ef29b808061c9f58827682cfa09e357c1722c3215b1 -8be32f59768777a785d8b257f941215f37db8912183aef4a39a856b88cc680ae7124789c58cb3c6c6f06a951dc96a1ce -8cb60a3d0c9a1efb89f89f78e6f0e4bcf5eabeae6cb215e98cd7f9eb58699ed70dabed73a8b95daf32a5e4bf0d411d3f -8ec7156d6b672e631ebd88467f40caa9ba5411ab727602f3146b468bc00ae54fe44b3228572670215a0dbd59feb66e2d -97b7162101d740aedc894bd5f74b8cfa7ca7e7fe8363b05491c15e8cd54f21b0b09eb41f756b9089c379ea0ab189c468 -8524c9de6be47cb6808df761ed03c505932ba715e757dfb3c97b6deb462433d98953ee6cbc7a576b6837e68eb16d3188 -b024c8fc3fa4f602ab73448418548d9896200065a95e8a001f6c8d4cc3f53f18ec8b85524377fd93e2d2a18eb4c48b57 -b344dc93d3057465592460b7f35dc015f4f8025fbcb44a645dcc3dfb37044d5681d8abd81bd544272dc57cd50048f29a -a7b270b94d9870f8afec3bf2ed58afb76f4ea576a2175502630d0d3f92f9152c1ab0c019f175f566eed29713dd97712d -b86dd953c40d4f5574bc7489323d71e9798f7c6f2dff8d41f6295655c5a275179ffb4bb8d2408b88226c98583a7c26b1 -b73074289a5b08aa695de03ce2f5b106107c6cf2bee8061e3195056e799b0bd8b4172deff7f413ce8e477391ee6294cd -98b801a58ac7e083da541ba058c64b00ba709d4d0ba1683e5d83dfb80a29272fc2a33a18f32351b103b227abd5123da1 -a7cf232c6ec6b9dfb32d729b9d4216688f6d2b6e68053ddfb293ebd5774218c69133baaccec7ba3da9b221af619c2ed1 -8cc1d33ffedcea05f3c593e5b63dbfebdf26d05a5719cbf642997be929336b92457fd9df0d6be6c063918ada8fa2d322 -8d273497dd9f822984f1d8dffd471cc703d03c342f022b2bb24492209a3889f010c4f7ec124f9fb9f884a1a11f84a414 -b62cd013944d8d9d72fbe54897a94e804c93eb84a24beb0880cd98fd5d48fccf5dedf5076abcb1b857adcc986b729cb1 -a1bc703a67ee709f7776b2871f2a88d8574c9e2910690c9242c162ad926ef2263d5260f5c19015ddd5ee1c8ad1a444ae -87de434e8ab5b1d067188cb9c12ed936c26ddb0ee76c4c9cee9bd1ea916e411a354bfab2ce77ed8c8ab5d8c62038f933 -ab128e9de30bad31dc2eaad851da1e39741ea61bd203b48e5671e37f7b4e3db86687574d3cea1f561bbea84f68cd17c2 -b54576c9c4bc3b43270b83b89eb75cb7e89057c99e14021ca42237dce393dc6a8614c5af5c2f69160001b2ecbb407c9f -93adf38f161ea886f41e4af8e42c69c53a51074db9ecd7b7e4e36c858426237167aa49b79737625c9f9826dfd22f39ed -a6907c8dc4073d3d4d40df8302c1637c15f9197aad8511dc95c210f6a60b06f3aab2622b826d16596af27e42f2c9d5b2 -a8b0c4a3a5d3dd5b6a85802039f48fc80350f6f0be2e55bdf75e3197a22f6547ff4a7dce38ef3667006128141364625b -8a5f4c17c729509309b2ac7e0dbadfbf0baabbcfb1fab02f91d055238faa3b66aae850ac9b8d7b7245f0a26bc5253c99 -8bfc5d594700287da2a85a78630c616af8e555cbd7864ea604ba38eb75742fabf6aca12ed99a2439e2e046d8f048a29d -b0f91b7546613341cd95ea112e04b0963fbf7795f118c393fbdc37e37dc25244d10d987c13d6fa6eff3c4721fd0a328c -a70b6fdc66ce4c2e7f1d830b7765b7f0640ceb7306cc85778488964cbcc336ac378b74b9c4ec27358f27378380b3dec1 -87387cd6b643721aac8e1a8533c27602d9632168d3a3532059163dc5e4613838bb4f07803e6852b23c58f7103d134f92 -888722a5a56f5b6b00daba53991ab6fccc32a029a7f1748f779b57732285e56e09ecdb7d4848abb3dbf3e167cf8033c7 -b7f5b9ffa8ba66f54cac387c197058eb9025cb3761550c78429db95f9e1e3b49c208ce86b6126c162a62939e1080895a -a53f38c068233b584211157c66d9d2452c811bcd340d8cfafd32b070c326169306975e558745d63e1617f4b4528a2399 -b1c3e9b0f19993f973f038bc45be6a834b1cd3d56f112c857711c8e6c30303eeb0b205bd5dfe75e46b1f4d4bbb68fabb -a81fc28620e640ccb57dedd40c79b73b0c51565dc61097527b2341bbaa3e1c9ccf20f9d8da1c16704e881b24df0b7335 -910a7f4960a0ec2aae66cbe2ac98f43646b017de84ef3d486c19b7809aa16813400bc2dccfc80e09c63422a9d4d88f56 -a463868e3a8c2d2a7c49850be2740e01c7892c83063d381f405282b4c521cb6e3317361abaa92042c38bb68695c10bb9 -991957100ea0f66cd4ebd23d9f6bc7aa62220f6ecb71ac947cbffc6f36f7891173670977bc58a6f57b9a1e8766100c2c -961dcbd2e6cb94574a33fd48b5d87e0623411574666d5d37f4ff7dc587980e2644cf056e002746088c3c3b0ee7044510 -a27cdb374cdbff217370015d78c7f5c4674ec9948339475cc80a5805979a4c6a2614b6904f943374e96bb838549ea517 -a567bd4a59f9df9f5f30a70cd9f6cea7dc0e19b7fca37fef5846aeb1697dcf7925a4735367be0828f2ded5007f711f03 -823937a900e3b8705b657d40470357d91eeb339324f0fed58695ad72dda7c64f2a6b7bb7ae4a20cd1b2016cb9edbdd1a -b07f2248802ba7dce15b2698a60a4896323d37ecae6666a71cdf85878094bbd4e9c0e4733bd8bc6e9c850e57727e1d86 -adfcdea69c5608f02630db045e5679f9f0768fbfa9c8e97bc9cf9cafe1f747d3813e7bb1adc6085cd57102afd71db133 -908153d3eb2eb2b93c15aa606531b08981bcfc8b76684c2483bf869f335f9d8773a9aa3986ee54d9392856daaf82b684 -8fbb2acf533e7d6e96e9b68e77f7a1df2ea6c652cd8862b946c93c084436d7349ef4a0c453197a9769e986322e9174b5 -b83cf4ddee6140c9df0a08a39bfda79c0d55516fd799c1c24b59397b87a33ea5a0885b2998dadc354cb6f65a4bd946a5 -957a52cb24f19106d80d4115a8a0843d047d157c4a8535775593c1dba9be24318dd434bf43a82aa7755897f895d2ed15 -ad93dbc2c055f9d7e42717391cfae64962a78bddbb9fd102a05cea520654d4a9cb6634234d3a188693c87c5b4c78959e -8dc4b8e49de9b05c33d2a98973e223c01ed5745eeaada3a4c0e474cc22430644a53a60c3d6efb1212ca298c4331763f7 -948b0172df27db83e70fbfdc896ed82696876ac4c51842d270d9ce1e7f1fcc9487d781eab97f40074861401b809dd7a0 -ace190f75cc102a79412fceebc013bda8cf329798db4b4dba658e63228ca7f141bf0849d30139ffdededf98986f3066e -8f968dd6d7e06008a1374743b965a6204c11a610ad92705e8dbe6df3c58baf36b47c5d9988e4a417c80ffd5e7725da7f -b8ba0d5b36cc41f6839543d43166a08bf512f7b56040891ab80efefc774db28c833ecd444a703c75547fa1404fa1ec22 -a29944dd0e5c861eb37c744c429a0dce596cdb2e5b0b2d2438a259a0faaf3d261faee1434bd28ebb2e6adab59ff3951d -85c70422fde0ac6e7a0574512eff2a19df8049757bf78b5a7d7870848626850f17e8b0a5661e5292f3df0f613886306e -a5ff5c3ca2c70b88d15633f9c38d2e065bcfb0e447adca33301a0d4f05b761049c8f795444f11e39357fe6bc0d7f1880 -a2167cdb114d7707f1010e0be9cad488fe56cef65941c35a5878a100adbe522a8abdf7eab7bc689b8727fafb174032c2 -ad3f526ef9ed367b2a25c95453135510472581a758760d47eb9f9b57b04f8c061152e5a792584d6ca7124dfeb7e21703 -86443033ece13fd386485115765aa95673be72b0543fac2138e1488d22419591176423213ec06e5e4549a025eb6aafd8 -887e4ccd58603e6c9cc99bd2740bb1db2fc4127e8d3ec9cf41bcfa3589b0fe1931ed2a6140ae1199d323d2870882ef6b -b701f7d7637662ea7024d31e94245a5f745c7ca889f4f7a8362537df82b0164eae83da5a107a21c0ca889926aa50de49 -ab6bc11d6049cc5945011d3973eb2dbd5a3d786b3824bc125786e734887254a6ed61fdc2a97ea34e6b37b13cd97eb781 -9901a1f44122bf5aec7cea28e9405c33567eb118752edc60f3cf6c80642370f86557cbd76478d6b0ea33be92a22c746f -b9f453650996f14629642bef8fea66c90105c8523f3875d86694100f8022d4fff2915ac9f9b9efd6f425751b113d5623 -a5bf9385a1c94c09ec326c49b6b603f2de987b2878faf0263ed109410536543095c07320f762fb6fe56ee72a082daed6 -ab003c86dd62c801cb16b727fbd1037aeacbec0f76e8abda4c6d87066cf0a33dc1c61721f2134c3b78975efe013cddb7 -8dd8c580c288168f896fd7ffbcf5c8167a55d34f17b2c362d0ada0f33a08cc0568b37b01cf0cef1fd5e2c2e250fcdf7b -acfe675aca83a774d3f526ad461f0deeebfc73a15ab3d37b224f8740ac2d9df238373e6cd1f03ca78a9daa0a796c96f0 -a45cf3242600fb9733dd5e0dda1994e8d37fc483885a34a76cc16bd245f6d9c8d15bef360ef59d0a2c3cd59114280b87 -b64097145d97cdc8b7a84edd1da7e84f8aa44c3c2a4823e6e8485fc3a44d94cde7d7ce8bfb3da5d583386461ccb42afe -a10ec5859c274c0972ec39ac80e461c29995b35d03603dc97dc30ff826ef24c5e52d5dc9296319ffc672b9e1d57d7936 -9702ee805b70a1bfac7318e8470667ee20739e3db3030bbcb9a08568e96c9c8d2af2cbeb26837c43e04997457c623486 -acb3f5a663333d1b4d54dd76a23c6601fd4540e2b050ec2a7fbf0b850b6f592837155e6bee5ca942406643f98bb2ca83 -a577b96723f64d2671f1253fca72df86ef3247006c92cedcfb26eba4b4f4ba71bfffe1d5eb87b0192378d0303177fdba -8c397ac56cb723df015d0ef202fe486d1acb42f8129d3e4b37125a7ff9e81aefb1e19f477d528be1e6b18e7bced27ba3 -a7a6e6994324a80ee0a85e8e8cf818f5f8d16d299f21b2fca8a9f65231982584afe921e76723701abea873275ce0c15f -82c8ee7a39e49528efa60ce1cbcb3017904de6beaeb751c406b64a94aa73af72932e32b63c1d3fa22619498fc46de6bf -a1d0193ac8bdd44ffcd37092a5dcf6e775824e5dee4c0aea5bd46f2e25b312fe58e1e6b9dccf9dd14f240d7ced4fe071 -82c48967f22b8aa1dc63dbda0f66ff2f40f3ca9a7b3e752e1a950dd7daadf9afd81ae1fe3d0e440259dccbc1520d4e22 -a69d43e6f962b728d223f6d474a923dd13c04eb8858f7fdd2df2c25dd4d13a0a69e71132f450613e8e2d9a65938f31f5 -a613b731fe0d23ebf376cb1f3707ab9b2d428d1ea3a95faca9988a1ff4fcbde0a077b38b5942590e594307acf88c9db8 -a7d2f249ec666f59dc51f9c31db6168f33a94b17ab95123d4b19aa00dbe9e1cdf340dc6f64bffc6dabb11912e10edbba -8e64b8f99ada5f317c6e2fd64ac17c4d6e5314c82848efe1eb97a5a52e6bf08923360dcb44c05d3fa59a82119610a898 -865d9512ec4a18ab31e4062b2ea6c43ef32c7c58d89bb0afdad9fe57dadaddd2150f78a0e85086454812855bf09f31ef -b2d23f01a0d182abcd6862ab6f4bf924ccaac399ec143fe2614908dddec102e2feb8555479bfb71ec3476cbdd71b1137 -b50d176e628e06258b518be78c6dcbc3c9b2b4a1ed4ba10ee822b3ebfeaedc4fa69c61c1985e1bb20ea9f3d6df7a27e5 -8174953f4023e31e39f1cc3bad674bf2f1605ec9fc053948bb60dbf2cabade885376f8c76f45b638c95fdb14f5bc562c -92b95a12d1fb1ec489943b3a2a1c8e3c8c6a30d0767125b87fb491f9d4f8de0629afa39fb5c8a84078b08bcc26e88c4c -93f4b80d76689d5936aff6cf195d579ff5328ccd0f04db42522a225f96b0bde2088706356675f185186548006940898e -a5f7f4577943741def19df611c2ad3d459c386a5e3c765eaa5a0cb6c192873675cccbe62845418dbe47d7a9822e4038b -b59bdb196d59928326572807b2ff2edfc93a28632542b270ed462567d32bc36cefc40300619aafe4cd1e91c38d6c9c30 -90df4b921e13ca1e63e8a5c9968ff64bbcc5b829e3421d74bf7f678aa1dccc1db9ed9dfe5aff05539bcc5379dd59e575 -837b0b6813249c456631b2f2fea9402a2303a454a114149bc35efb400813397366eabeb4477f2cfe037f722d78a5849a -ab5b33ae561312d9791bcafc8faf6d65f2c4260f126f11ab5c20c7626d88f2c00177588ec62ca763a7ca44c6ed60eb0f -b0ed2e48cf650a4267c3da1378b8164cf6b774200a5898155716f85f7abda093a60b802ce549811644e5f075d2b26067 -8d47a4e27f448773fa2d592f052bbdbdf30cbef152db6d8cbeb3d7b1a0dc0f2c820ed7572eacddcb51c19a8268426b33 -a56ccd0961bf238ccd197e5bbf430d7c637ff6e01590febab3529776403682ee32d0a776c3dbc6581f60002dac86c38a -9163bbdbf468be88a391698ab1f40a919517beb6c780062d4bab3bf8fd42eed6546a8c743e249fd61c3c347ea60ee185 -8d59f46606f063e68198457917004ae50ebb99cccb07755825782ddb25b96c3cf8973a6c5092c9db71a4b8ed075876af -8ebffeae4fef7a83d81f31a88589e05f885dd0c0b4360545b22a18369a3e6762f187ea6a173f25419e70031861936463 -96013c6b47119e017c8bf473b3d643d0bea1cc12d84d412c2b9f6f55f22543a6e15ff7e818e9799af43984ca2ec3bfb3 -af46ef7696d9908fb343a6754de37e31cbb41dc1a4ab8203d2a2483d1cb0dd3183e5015d8048ff146ec34a6c3f2eae21 -ae047ec4584a962a7ae9359292c98f4d8e0916dd98a414e2e15429ff30ffadb3e0296282f0f7e257495e8ec4bc0e5328 -a16de787896a056d31e3f174418aa3882c03c879a292246a43dafb81f8e0e05564f1cd3ecfa251cdb159f63777fc6346 -97d1c4a94182ada88aa3cac95520711802cd3889e3e057e99a72a69589fd222b241d35a54b04f42503756ec3c1a3d701 -86be4ebe8b92f5bfceba757e1e2eb649f9803c8cb10130b88b13caab6bc04dac4e26d538b7adef68413b047ab9031252 -95d4c0b08caa283ffa9e307f78db15470fca5b577189a33bcdf14c36d4ae3f571d004c5aa1e69172a4068e72b7dc25d3 -965b7053a1d14f9091de5df8bf033a07b9f8d39a6d66979ab5424bbfa32b803075afc2d74e71235a0f881bacb6704689 -a93e72836e2efc704f87065dac0463ddd4b063eab125d834df583d8833873f575a0179781b72aeb2a35533a34a395481 -a2997d7c377060d910654550316ea7374a0329fcf30e743d613e2ebaa15b1bc6c936c2529f5466ef0e60ff53aa2b709f -af5259d4d08617d9be068d1b79a8209497972910938831a435487395512187691d0cb021bd57eff0f694f32efc1487ab -a78b8318838b1049f308200782c4409fc6c97ca5bb6af28996eb191027c8935b7a43a41961ec046e6c8539376c1aa293 -a4a6a9ec652d1c95883d21d3767b13a7e1dee73be907dacad197cfee025755db3cc7a8fb9f40146912f8a3f4c2c49c14 -a8a8ab62334a3c67793fa0691a0d2e80ac1681ce64a02df93b78e4a2f6fbf3af9b160d9ca6b4e835d58ed60d8ce627d1 -980c32e492464a6f36ce12ed06541e3b2eb098934c0ebccdcc984cdbfee4a506d15afe1a30a84d642322c2987d9d51a6 -8ea8c1adfd73747db98705e9fe1aec441484d2e4862b84817cdf1262fcce91f56cd26073d4dd23b04f836e0962428593 -b0f20edb8552d2b08613cb574e9de1c4dce1eae55ba9ab05dd7f2ca3590a7496d63d55af88b3dff881e16d8bf9147037 -915af4e9a28b12ea126668db7de6ff0c2cc9935b138022fadbb1f385f327fdc927388c945b93d252cb51803c242f7e1f -a553e08f67c61ecc5c8955f7251cfe18cde02e6170845e70db1761bc00f42a31cc10de26d4c904200166311f32a3e56a -99f4b066a805512e16addb0bcb08d76f017213ca6aa6afb5c2fc621805c4e123bbe0aa85eb5a0f89d3112635905093e0 -9236c5b0f4d2e58033735d7bd5d53ccbe82c05aa290149286a16a318043ffedfdca9d2d07817601d4216fed50c1082f0 -90a4c7898c58c9af83f94095f6afd5ca65664f16c0af4c8121407cf0864fdeb09958500b2bd0b78950aa9051e3480928 -a589666688e6e7f8e4d99b84d21a1f9ebfe681fad346a237de20a11a2b210eb99c4d3e2f645b23a85c93bcccd51f63f8 -a010849ed4df0e3a8eb61f7fd114d05a8669bfa36cb95d089bb1964ea8f5fa26be0cd10fcd9b38b259722c5a14ba3a1f -b21f974a10a2dfe9987370ef4b6af294cbe8f4bbe35ce9400d0538c5f71287498054d73606e26f93e2f19584aa18e285 -81fea77bad05c3bfa8d5d8409b189fd5c759613cd69ddb19b2d46673d4df944b2c7293989f79580d229d20959c74b18f -ac962b0819a03d2a2fa42c492f54c3d293c6d5ead403c50f7a1ccc2faad58beeb0dfe888a928e505fea9e09807e13a23 -b78b913f2ad9622d20c175ed23f80f235b5336343b0353f82383fa6aab99aef77cb489df822bb168e56496c1854f623d -8c06abf72913ffcb6b59bb8201c00034b447011880733aa6b563acc423e90bdae19f2a7a286943b55488fc863d09269c -b34168972fcd90c78286bfc6078ce559e3c216d8d1885ecd5044bf9f23a4ad15bfc9830aabb4273472c43e2980048586 -88350e0ffe9b5576dd0afabc6d8445d25b2b9a0945c71e6b9a5587649ac5d95cbd722db5ea1e65d3fb8230c794fda5fc -a3bec1fc362a33f38795158f1b869e9ee857a7f2e1acb92c6a7dcfffa64443a5b7f6dffb656452e7f855051ae849be3e -a21f64c49334720883e1243a27575648f53637a644c308ff24f5c26bfe65cc690a5e46b8e432171f31c4229aff4db416 -85dcd8ebef8f7f44372912b4a3a0dfe66a56f16c3757a8ec01b71aa81eeda9f8e5082f92e3ae8cbf3c1eddf5e6ffed03 -af3c1a770f34f2acc504f38ffa7a18cc4b38f8f84f310cdf2d7346b18824ebc7c7663cc0e00b44cfb5494fe6081aff84 -a5dc7c5989fb5cea87c2d878d8436d858458171b667ab5200dc2cafd8af2d9c2bfe2515b0c002cdc9c3e61e4cfe4b444 -b136dcd4577ef3a3a8bc946cf2ec79d3fab301114ee2a692a6c219e252c9128db63fedebc6bd6695a8ae58e7d28501e8 -91d3a1ba625632d59dc963ed54c0310d0447df3e1d9151299722d10f8b26161bb73e0020d408b748fa6fd1db51adabd3 -b89f1a2497b04b3f1b018dc88b52133e1d7470f97f846965fbc934d34dbc8d38f2d8b07d218e62c609de33b61831cc9c -92fec43fc5af23fda5dfab78234f5ea7813d8de34f8ec269c5fa35dd916b9143ff0033d35e7a284c0ef4f41047e98fe4 -8a0b89cd35ecf5b6db26c39705b416a4b950aafaf3b00a9d75f864955e9074aac03826ff9393456871107563eacc024a -b04db63ebce71161fd42bb878e89155bc9e887329e164481077c6a1db092477370a362810d291444f5463437e0ec5906 -88ecd5275592f8b133928770e2273a0e0c23424d72b9e505130b0599ba28d1c11eceb2318a49dee054a8ba0971874357 -8eb0271197fb9f1eeedaadd8eb603b8753ada11abf04ce90950034f51f756ed6ec6a6182a47e1f3ae51e3a1f3ecdf467 -81cc996bc6b12ac56a1ae3add4483ae4f2e2284e9d304f5fa1723231d0e5b196813b6dbbc20b70f5d51fcbb65bf284bd -8e1d94ecca2928c4c68fbc13199b6281f8782c75c119b763e0eb122f81c35f8fd079d1bd76b498393371a08dac95dd1d -a92f98bc09f8a91fd165bb8d05e3b5ec50121d760b353d7e4ea23c0e04ff29614ad9028a4a16bdfe323f2af647e515ce -82e8dc99a14da065200699e458150dc6d49ec0e098bbd91ab8f1fc1767e8732f53855499c8f24da7b9dd681100633be0 -a67b6cb4eeab4fe5f4ebdf5649b7d61bf5fbf7b6cd2d357fdf348ba32dbfa9d6830b1265ea76a1c666b266e30d119182 -a64e3af1d0e600bde18d7f53a4e8d89d296eab4bcd9cc3a9f476c5b8425e6e8082066948fbf40689f626e27e4830edfd -8f66b59782cbccdb31cb1bb2d6385307633ba4db31c375c0a8424a497b2fdf309e7ec1c95490324b9a909bb43041998d -b93f4817eb1d91ac78eb650c110f7c29df40df47ed1d5d3209c3abe5cf59a5e7aee3d1cd232bcce77e157b1a9daa2557 -864b6cd72029640fc041fd3efa71bb210edb40589a26981724b944192c3c2543352b4b757836a7b0b13bf830f22b8374 -9064a0ac94f2f133e287b796363f6d27e9646a8b531cd9ac0eb45b99fa73f327238161a43f7c4fc914036d69abd1473f -a40e60d4aaf9f50f7bfebd0e714fcfeba64e0f7ccaa0f4829144a7efeaf15a7cda2d62d771a76f98a45cda9196b0522b -93e02b6052719f607dacd3a088274f65596bd0d09920b61ab5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7e024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02b4510b647ae3d1770bac0326a805bbefd48056c8c121bdb8 -99aca9fb2f7760cecb892bf7262c176b334824f5727f680bba701a33e322cb6667531410dfc7c8e4321a3f0ea8af48cb1436638a2093123f046f0f504cc2a864825542873edbbc5d7ed17af125a4f2cf6433c6f4f61b81173726981dd989761d -88e2e982982bf8231e747e9dfcd14c05bd02623d1332734d2af26246c6869fb56ee6c994843f593178a040495ba61f4a083b0e18110b1d9f5224783d8f9a895e8ee744e87929430e9ba96bd29251cbf61240b256d1525600f3d562894d93d659 -a2d33775e3d9e6af0d1b27d389e6c021a578e617a3d6627686db6288d4b3dffd7a847a00f7ef01828b7f42885b660e4204923402aca18fbae74ccd4e9c50dd8c2281b38dc09c022342ed1ac695d53f7081cb21f05fdfc0a3508c04759196fcd3 -af565445d2ad54c83a75c40e8895f5ad7219a8c728bce9d58d7a83716e095432993ebbd3f6911c66415a6f920d1a4d171478509b54a114308a020b33bf4487a7a8d0aa76ae4676a9b54e765a680f562d3a4fcb2e92c58b14b49b5b2917cc258f -8aa99cfaf514cef4801599cadd780d222194ca1ad69a34779c2bcfda93e5dbeb931e13914421b5809a6c81f12cf7038b04a35257cc9e94c33761e68565b1274aa6a6f9d66477229747a66b308b138f92aa4326a3bf23df65a1fe33b3b289bfe1 -99ba36d8b4f56bde026099278548b1afc0a987cbd7c9baa51fc8e6cbb8237a17636f1a44a385cec69b05a5802059956a11fe793cabb939c38800f9c239ca2518e898ade1ec2513c9ee492071a35aabd78182392a09123d28dbc233313c9120c4 -a7dc40c36afccb30a2eaff250860b28b227c195cf05674704c567d77d6655c446ae835f8fc8667e71147ab02afcb2dad0babe60cbfa37d7c2cddc68d2dec54f28a4142f8353590a3902d5ddaa22066ab563dd1435dda83f276387b9767d69120 -939e6cc97a8b88572852a5b7f25e4838556307f60aeafb5d2b6961edbcafd4b48cb6ac980ffbacf4be963f324ba81e3d12de4f1459d8c746d0762c66ae1b166027f7fbe641d9c48f3c7d97b06d956b0be51dcc9aab65f3e99e1388e63bdd79f9 -b391e156541dfd4003d1697cdb7ec815b309807320574906b2e652ef0175828b356d215cd374b1b34d9f470b3fa0e643113e67b2273268f922f04f072cfb89008358185b25cd631f82911a3f20f90f75758ffb99bebb8076458ae1e9d1ae898c -b9ac9c84934cc2a85c876eff65577e1dfce1935cd6392c877dd881a7d2f5c3e9344f28c04f90c62a6db4237ca00f9e0d00cb5f63e3f060fc7303916e19273b6fe455f331cabbe2fe5a22d584484f0d4176120fec9819fbb0a01e6d38695acfcd -88209eb030c5d78734bf2c2a5c539653fd3c24b4c08e624f9ddc4a6550efbdc1054a56eb0c807595aad6de56fda326aa196d032a8b4b48d40140a2d77df3c7243eda6507936389a321a5811eb38e32ee433c788deeae1eb928b00940e2944bcc -a8632ddc9cf7cbc1e8b74a05b7d4a89618c64afe30367ca0c9550ae7d320bf4e51c5a69e1501a1d8bee4240d13d7835501aa39fdc401a74f4d5734e268a7ce29a1fcfdb0a8bc64e0dd4a9e8578d6985bc2bc6a3764ce7a3703f6fb2e52557a2b -a037ac67e8bb6f4193ac967e05d080a489f58ef8d3d30a89798246f3e4936121ee445b03e410a09e8ebc0db2e2477d110aad0ade99b0887f1eb016e750f42135866907f150bd6f4f99a8cb94281474166874808ebe03b118c5daab16dafdc38b -a50d9143116bffa3b237da8e1805327e81e9cd25e658289bd727d5f9e0020172cc8690dcfe31a240e5cbc48353b88c4908baa1dd7320165556e0aa633f62fcbe7870222d345a3bbcdb7ab6c07f0fd86be559964afabf56f0a8cbc0b4b91d477e -afa988ea6fa4f40c5ad07d2d580d29025ddf56d6ef1171a8b8de3464203f70b97d6f5ace72747345204b35150e06154d1477516a989ce8eea7871cc0d0de00a077c0fb23ad4837e409d0b885bf3f2dde11a30fa6273d662e68e09f461e52932f -97fa1a943ed8b81574304a3d03f4f15907f6e6e0cd36a66bd2ad2c75afafc70a61d3ff69b77ebe4dae9ca0fcedef80081062705e60bbb6ea0f1f398c84d2f8e4a3ac142ac66426c21ad5e9994ebbcc406af474c4aec5e32fadcb21875af7c9f1 -b30a564614493886f14a5dd71c89457504f8c59a7ac01b665ed167e9a8f9ee5832198fd319ecd234196ee57031bdf3840bd5a923e203a1938bc795c704b5285389750e1fd10d7050061ba19db00a60a2c0384a7d661d7d48ebe6962272230859 -84c8dea942cfae71cb02e705ec496d967425793ce8812e7ee53c2f23713abeaff566a658cd1c73dfd18187d16253a6ee0a623e82cd18e31cd1a1875d19c078835dc9292e141686150a88065226ada264740143e87c03a0f6c4da8c187438ebf4 -8c3abae8aed60338f8c4ff80aab22f8a2ae56756a93566c906f490a97151d34a1c3318054e1c494c60cc53327ad86a2d02c6c76a406726ce4f88635bc32eff0db0b61762dc518b95fa8da82e87e4bf3de54f1d72180ef53ed7bc5413e6a9a510 -a328230c92a6b1cef6a444bcb64edb992f71e3d7b93f0b6b8b408ba7c908db746d92ddb2c7588bab438ef3bc61be1c2f0dfc86ba2ff514b42b35c80f89b2e780f813ea1dfb977fbded2cd9b553b747fa952e227ebd8f071163d421fc337f04c9 -b482cab423cd5f1c5df036070aade7aa016283d69619d664025c3feab866a0a5691d344b2ee2bedc5dedd1f9a73eae16003a3827c9e5bbe22ded32d848fba840ffad1141ad158f5c40bc8ae0d03781b9705d851a7f1391b096c576c0f4f2a6b0 -919ee1df27fabcb21237a1b7b98f53d41d849e1b6a8f9e28c3fae2841c6b5a250e4041c737e6725476e5cd715e34d3880f58d80f61efaabc261bdc703e8750f48a923e9bf8980931b9fd9e40014c66c54b3e7c98241d76d1aa47af43313a65a1 -ac94830145dbe9a8f7e6e0fc1f5fb454502d22abcafdc2dd96c6933c604461fa83b2b37385f4bc454875a02a6d4157841250956783515d11c7456e7f11b745f12856d89f5feedaf6a61a483a6c33a21cd2ba0c18eb41a1a2e7fc33bb53e4c570 -b209c699f1233735c5bb4bce848e4365fd76651ae2184d2279a90df0c2f69ffa2a24d84a9b9f274021072953c0d65e1a0202d490d6c37186af240114e445d87bff754b4824937e4f2c90a574061b1c4910fed88d90f698025a2a264e656cb8a4 -93320dc0576b0d069de63c40e5582b4486d9adf5e69e77e3ebaf3da26976fe42147a65051501bc8383f99e7ba75479c70a6726c2cd08bf98c7481f1f819712292d833a879f21a1221a9610bc748fb5e911055122fdb4055cdc84e8bfe0f4df9b -a4380b240e998cdf668591f71a0c88ed143b0185a920787627ce65095f8223dc606fa5bce93377af100de92d663e675c0736d7f1973603a84a5c4162fb5e01c88c7493503ae1d7e9fbe8ece9b418397d68c21eeb88dae226e09875d372c646dd -aab48517d69135a16b36b685adfe9b2544a709135a21ba3e75981a2cba4ec81d1fe28ac0f72fde0c0001c15300ed6a810f58d3117bdd58d0149751d6508cf8a1a1ff7b63dd02d2730a9d6fe96c77c502fe8ed46d50a181ec4bb35e37dfbd6af4 -8277265fe75ab89ce4ec65b33fb4084bec0a56d81faf2f7a9070d2ca3065678e03a790350eba56323a54e0285bc32fe8007d5259740fde226e16cbde8354eacd562294eb9b7f727ed72ffbdad86f467cf057c737b34b80a41deb92634ed866f5 -aa40a24cb2ebe606d969392c03020070f044c95088d80f57f771b837c048342d2cd3474600d7660441090ffb8d2ffb7f0eddd67eb378e3e1477a6ba0bc38096d5d2d3355bc8b60f605f57f0c1899da591457440352381d2b38c0aa9acc7fe419 -80815d10685808cb630820629bcd2fa9041c9b74433630c0b9c1b7f7e8edf1440b520217f76ec9a50c125cf4438aa66006a1928a9ed2321da7ea325c3d56b65462b72118ca2c99a0ea733aa11da9abbeda6cc71ffeed301ae70213a29e697dcd -ac235d079f91b00b1fead7523da8f73a5409fa8970907af0c5d5e4c6a0996dccfcdb0d822d08c7fbc0c24799457d011d04312d20831825f23cf988141056a6814c8a1cac9efe37bdcbfa272aed24cd92810fea7c49b0d07683a5c53643872179 -b8aa59534d75fa5ac1c2c3f963bf73899aff5210059dbde8a8635561c6249e5143affee3bd2fd57575213b52d9a73d5702525867a7dcbb1d0a49b98c2925556fc5463ff0209742046a24ab29e74257d6419401093cc4371944d811cc300b6a67 -80bbfc5b816eea29a6d84e2217dee4d547306994d39e5592515e1b0807b67fe960d1d5addb0ff1a20c158bdb294c04bf093d28996121845a2c9268e2c9ac0f4067e889c6aaca62f8535d35b45036954bd069e3afa84f04721538c26003304c20 -a535c17d0e151d0e03d42dd58ba8c715bee3fabca2890e0e016071d34184b6b34e770d2be29c8ec76b69bcc471d50f4d043c2c240e9b93a81cff7ee2724e02018dfd9b534e40be641fdb4884abcd83b76f517557ffba508f1ba2f56313f4de94 -b237eb7465df0d325a3aa58269be2627e4978f9863f4f100ed4c303cb1f6549e606f2e3c9180824d8049191965c8dacd0a0c76cc56cb22cf1bcfdb39372c8aa29b4f7b34582b1719e6bd59c930d87d5ccd838743b585d6e229d5ed42337315c0 -805c335a2a9d2de30809cf30808ef836d88e9453c510716f01696f14c72dd60505eca8f128970edc8e63a9aa1f8792ac0dd50dcc84fbf4cc8b32349c682a6a27bc7551c7aa273a94c1606d07710188d93579afe3be1781bded15a34ed6047922 -b25dadf385ddd3c39bcb0a014d3d4f66127946b1aceae8809e3a03d66cc25e27142ca108316391f857fe82fdea4db2520cc73793b695eafbf3ade00ef7ec747b0457e49303f5e1a370f5263b436566fe24a0876e5fe088238c7be37a0718d65f -b0f753081cabe2c8fce73aba82ff67dbc9842598b3e7fa3ce2a1f534536f8ac63c532fe66552ac6b7adb28c73ed4c8a4184849be7c1756a4681ce29ebf5e1c3aa806b667ee6bd68f6397aba3215dc1caec6742f21d681e32cd1160d6a3b1d7ee -b798771eeb3d7a17c62ba5916cc034bba870da6b1ac14c2e1cae71af3ad4e0c0d1ff983f691e0e55289d5a33b131f2ec12430c9566dd71f4d8be9c79155357a5c30c5efcfd75bbe1bb6d5ada4d50604ea49ed838d3641f268ca6e25c9c4b6b72 -b52554c017388b099804abbe565346591a086d9979e10140ddaccc0a3680e506db775d7cbeafde67563adf0f09f5c2420caf19629f4e8f03e6fe02e9416ecd5269989e482b90004a083967d1141387eb74865bac6bd17e7a6d5f58225e52d4b7 -b520ff694520919023d44d53f98a7de2f78ff37b2d9193dcaa35556a6a0febf767781a4c961dce7c804bfdf81935f8f0082865253da52e79dfa1c5ff74d61495b2da76e167d46114709e877a7791a3a95e33a42f56b83f5f5afe271c67ae997c -b721401983440797a03d5b99f2088a0b249aa911969c34dd6c615b0060325da555d2ad99d931170c0868b0488a2234a4114cc0013d5163b833f5c45c5eb536421c016cf85788390176bb2dc4c196d6be26bbbfceae048b82f0d8039222e71c94 -acd9d833ba0a8cbd8d1ba939a11ea0fa5607e1bc6e693ec318bdb097aedd042d76e695dcebebd142e2e4ac30b1905dff03ec36d9cc70577e4dbe5e9ed7c20c7afb13a7f0155f203c6b83b9f1ad3d20a0d4aef0fbbbcf466ffc1bcd482bc2f5e0 -8cc1795de015f2b0e72116f169f3b4624b7738ceebea354e0bd9051c27b86f647ea36cad57ea6884c1a8adf9b45cd83514fa687e68878bbd613d793aa10986d5a0411f081689229e0d72133b3667b9f3f1a02211d0e680564eb1ea43393e1f36 -aa9281c61113c343a108de1036570feefc72fb7a96ff11f73024de12b83f29631f5a8a5900e6f10b15227c6f7462881511271bf785ebdf95ce288100e5dab391f664f6ff76c72b65b34479a4f43e5e8eba292209d6654157286ad3242ac342db -aaf16866275082e59d415db317aa874267d048ee405a553e852e6d175711d31a1fee99912345915bce121f43bc3e00d81338e5fcd3c8a1012fb4f172a9fe15622dd368b4d9d5cb60d189f423b071791fe26cea7676aca8df07965cacf80b0cd0 -accc80b3d8a6ffa648487a3d3c0ce1aeeb5401edf3cf2e385ea4a6d5fc110054fcce38f01f1da7141bbed30eb7a0a6810c82212bbb9da75d6033082dbcf6bc6a5791f85aa0f045a10da5de015edbf369b4d23b32b0c058962d2ee88e6911f994 -83f1089395a16077738cc7c9a6d6a3dc9033aac4abc508af5a1f007ca92e1a80b2e6f2dbda7fdcf0d5646de790a6201d0a9cfbcb6620a1426600e3a6a425ec004384f49fb9dcd166691a47177d45dcbcb761a11d46220b0aa09fc946131f7aa5 -9246bb586d43cb817c2e15ed609156e9f1cd284ba2f4797bbfa51c0341e1ba382eaac059aa9f63fb88d228a1a932839a171e7c7d00199dc7c4d6c5ea038a02cbc3cc5297c70401520e70ebbcffacd6a703f62896f3c788f94dde3c33ab0ecbdb -a316cb7c74feb0563c56cc79015e2774fbeca458bf8e9fb07894f9d6bcd73f7fb9428e87c816e5629e4bf7f3ec567fbc091549471b75492dde08217cb334b716b4582b24384586e53388873a78a90ec01bd7c3bace9cfc52161467df16e27c33 -ade18c74bbe60d1d69f4a570f8e5fd8696c26cc9e02829040b6b14cb9c49a4b3263b5bd5e16ec0b29010b4be054c16ab09304e23442af7d7f5fcc60bc6c5634ab6e4aed7ef334b2785e4c7672d59a687278e42d310342db5e5975d716e6d1595 -b7728800bb2039acf228fa3d8028569c426cb85d28b2b5820bbef938d5ca8c4df981d3e01a309e26ca101e8295d0f6990c03b8c239798323575874a4ee5bfe46cfe99b9657189142aacd8f8d1f26cf4c0e73c6397c31ba8f18102b9ea315b638 -8fb14f2a9be193f54977ecd3021663108ea143627b9a9d9faff85d1a86b855f6c437eab435fad3304f245bd7732af07f1173494cdb802fb96e85d2db89e1643206e183f3b228ca8d3f586e71aa9308eaf0223100bf07942fc39e465016d1f775 -ac1e025e53d98fdb3380489dce82d9d4bd3a6c98f0a523b841cb09a6f26ddd4d22efd98776e78d10fd996995fd00e81e08d3c25dd14a54b25a9d483677a24bbb8d1cb41a443b2c71038e6893b1b30f70758424e0f2039a48060191389033ef55 -a4c017311b9e930868132527a9849072b91db04fd36c619ae39c98da9e2174e6201d3c2ff1246c06b1b6815bbf3ea4a1116564f55ee2fe4c4d655e2294c0ded842cba209c255ca3d7b7f82d162f97890dfdeed087aa2f87cbfc61d61815da39d -89516315a3956b455843c2555248bd94dcb19993060fe75fdd51f7aa9c9147ab13997d8a98036a8f04bee5c91d78d2990907e35a52537a8ab3ed15f1a71afdcd38044a5b6e93f662b9d36c16933a881927cacae668c4c06ee6f004c9e3989bad -a1e78a011e210400c68ca76045f7da74119bff3cbe382efd2bd2ac76567c52d68d75536a91999d084043e1ce2d07d02e0b69fb99924101d2543521747536fbc51b0454aa9a4cbbec101121f597863a5c0fee2ca5eab35dff9b9085bef8b2b0d0 -830fd8d083e39153ecab43cabb22e29d7b44a55fba467af4ddd3f069439d2972ef53c3518de788f96b3f4f64963987d0155ba27afc28643af3de8e476ff515a68285728167408f45d99e574680bda6bacdd4322e587e4aa99386e035c0e931ad -b89584da22237e3061d991b1a55a5e55dc637b8b671130d304587729348138ef87885180310efe9f9f6d3580b9d7fdcf0649e8a79d2dec8c25a9f53df0fac5d517db999029cbfdd7c2cbd3e9a5503e5d267d3d8ad752335915c92b850b14bafb -959b8030733799882c5e3735479924b013756e57b893f9792bab4043e2d362d77cf308166d782e3989caa771b8a0c0a01302cb7b5e8ca12e2d6cebd59d4cd173c9dc25f438bac597fab17b4ff44997a489c168e7204b7d7c21d0938f0a2e3b51 -a0a9e5503d9afe0027891dab890c687fd5f5fac5741418490c64d7c15f59533dd603a50163c79402afa61bd02de486761983c94501da17e6bbe78c497f2122210071602f578adc0ebe7a4679f87fe77e09c8c122de69105f13455fea25f08e6f -9811487283ad620cd7c9b303ae2f348d0e6f5ee17b504baaa817ae207adb912a00d3cc36dbf48745eb899e6b6e22f09f0f9ba29d949ecd7350fbbfe87a8c7cdd5d0e687fc807751d07634aaf7c38baf3b24a0670c38fa6ccd7431436fc95525f -8a13aa5071c526e560def7d8583393942f07d88c9d8d26c98738fd65f57af2e3326dbb1edff0f39fe98eda4a13ed4fd71844254b954690154c4804e1c4a53df9dc4643f4b7b09d0860070f6b2318d0d63d28fb56bf5b6ff456a18dfc72fdfbbe -b9c90ff6bff5dd97d90aee27ea1c61c1afe64b054c258b097709561fe00710e9e616773fc4bdedcbf91fbd1a6cf139bf14d20db07297418694c12c6c9b801638eeb537cb3741584a686d69532e3b6c12d8a376837f712032421987f1e770c258 diff --git a/infrastructure/logging/build.gradle b/infrastructure/logging/build.gradle index 3c5d07970de..7687836b6ee 100644 --- a/infrastructure/logging/build.gradle +++ b/infrastructure/logging/build.gradle @@ -1,6 +1,6 @@ dependencies { - api 'org.apache.tuweni:tuweni-bytes' - api 'org.apache.tuweni:tuweni-units' + api 'io.tmio:tuweni-bytes' + api 'io.tmio:tuweni-units' implementation 'org.web3j:utils' implementation 'org.apache.logging.log4j:log4j-core' diff --git a/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/Converter.java b/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/Converter.java index 8b71a4b94d1..595566b2e9a 100644 --- a/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/Converter.java +++ b/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/Converter.java @@ -14,22 +14,27 @@ package tech.pegasys.teku.infrastructure.logging; import java.math.BigDecimal; +import java.math.BigInteger; import java.math.RoundingMode; import org.apache.tuweni.units.bigints.UInt256; import org.web3j.utils.Convert; +import org.web3j.utils.Convert.Unit; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; public class Converter { - static BigDecimal gweiToEthFactor = BigDecimal.TEN.pow(18); - public static String weiToEth(final UInt256 wei) { - final BigDecimal result = Convert.fromWei(wei.toDecimalString(), Convert.Unit.ETHER); - return result.setScale(6, RoundingMode.HALF_UP).toString(); + final BigDecimal eth = Convert.fromWei(wei.toDecimalString(), Convert.Unit.ETHER); + return eth.setScale(6, RoundingMode.HALF_UP).toString(); + } + + public static String gweiToEth(final UInt64 gwei) { + final BigDecimal wei = Convert.toWei(gwei.toString(), Unit.GWEI); + return weiToEth(UInt256.valueOf(wei.toBigInteger())); } - public static String gweiToEth(final UInt256 gwei) { - return new BigDecimal(gwei.toBigInteger()) - .divide(gweiToEthFactor, 6, RoundingMode.HALF_UP) - .toString(); + public static UInt64 weiToGwei(final UInt256 wei) { + final BigInteger gwei = Convert.fromWei(wei.toDecimalString(), Unit.GWEI).toBigInteger(); + return UInt64.valueOf(gwei); } } diff --git a/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/EventLogger.java b/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/EventLogger.java index d085443406b..087d1472317 100644 --- a/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/EventLogger.java +++ b/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/EventLogger.java @@ -162,11 +162,13 @@ public void executionClientRecovered() { info("Execution Client is responding to requests again after a previous failure", Color.GREEN); } - public void missingEngineApiCapabilities(final List missingCapabilities) { + // TODO remove the isOptional param when all ELs implement the engine_getBlob + public void missingEngineApiCapabilities( + final List missingCapabilities, final boolean isOptional) { warn( String.format( - "Execution Client does not support required Engine API methods: %s. Make sure it is upgraded to a compatible version.", - missingCapabilities), + "Execution Client does not support %s Engine API methods: %s. Make sure it is upgraded to a compatible version.", + isOptional ? "optional" : "required", missingCapabilities), Color.YELLOW); } @@ -174,11 +176,11 @@ public void logExecutionClientVersion(final String name, final String version) { log.info("Execution Client version: {} {}", name, version); } - public void logDefaultGraffiti(final String graffiti) { + public void logGraffitiWatermark(final String graffitiWatermark) { log.info( - "Default graffiti to use when building block without external VC: \"{}\". " - + "To change check validator graffiti options.", - graffiti); + "Using graffiti watermark: \"{}\". This will be appended to any user-defined graffiti or used if none is defined. " + + "Refer to validator graffiti options to customize.", + graffitiWatermark); } public void builderIsNotAvailable(final String errorMessage) { diff --git a/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/LoggingConfig.java b/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/LoggingConfig.java index fe4c955a9d3..a0823ea7186 100644 --- a/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/LoggingConfig.java +++ b/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/LoggingConfig.java @@ -187,23 +187,23 @@ private void validateValues() { "LoggingConfig error: dbOpAlertThreshold must be a positive value"); } - public LoggingConfigBuilder logLevel(Level logLevel) { + public LoggingConfigBuilder logLevel(final Level logLevel) { this.logLevel = Optional.ofNullable(logLevel); return this; } - public LoggingConfigBuilder colorEnabled(boolean colorEnabled) { + public LoggingConfigBuilder colorEnabled(final boolean colorEnabled) { this.colorEnabled = colorEnabled; return this; } - public LoggingConfigBuilder includeEventsEnabled(boolean includeEventsEnabled) { + public LoggingConfigBuilder includeEventsEnabled(final boolean includeEventsEnabled) { this.includeEventsEnabled = includeEventsEnabled; return this; } public LoggingConfigBuilder includeValidatorDutiesEnabled( - boolean includeValidatorDutiesEnabled) { + final boolean includeValidatorDutiesEnabled) { this.includeValidatorDutiesEnabled = includeValidatorDutiesEnabled; return this; } @@ -213,47 +213,47 @@ public LoggingConfigBuilder includeP2pWarningsEnabled(final boolean includeP2pWa return this; } - public LoggingConfigBuilder destination(LoggingDestination destination) { + public LoggingConfigBuilder destination(final LoggingDestination destination) { this.destination = destination; return this; } - public LoggingConfigBuilder dataDirectory(String dataDirectory) { + public LoggingConfigBuilder dataDirectory(final String dataDirectory) { this.dataDirectory = dataDirectory; return this; } - public LoggingConfigBuilder logDirectory(String logDirectory) { + public LoggingConfigBuilder logDirectory(final String logDirectory) { this.logDirectory = logDirectory; return this; } - public LoggingConfigBuilder logFileNamePrefix(String logFileNamePrefix) { + public LoggingConfigBuilder logFileNamePrefix(final String logFileNamePrefix) { this.logFileNamePrefix = logFileNamePrefix; return this; } - public LoggingConfigBuilder logFileName(String logFileName) { + public LoggingConfigBuilder logFileName(final String logFileName) { this.logFileName = logFileName; return this; } - public LoggingConfigBuilder logFileNamePattern(String logFileNamePattern) { + public LoggingConfigBuilder logFileNamePattern(final String logFileNamePattern) { this.logFileNamePattern = logFileNamePattern; return this; } - public LoggingConfigBuilder logPath(String logPath) { + public LoggingConfigBuilder logPath(final String logPath) { this.logPath = logPath; return this; } - public LoggingConfigBuilder logPathPattern(String logPathPattern) { + public LoggingConfigBuilder logPathPattern(final String logPathPattern) { this.logPathPattern = logPathPattern; return this; } - public LoggingConfigBuilder dbOpAlertThresholdMillis(int dbOpAlertThresholdMillis) { + public LoggingConfigBuilder dbOpAlertThresholdMillis(final int dbOpAlertThresholdMillis) { this.dbOpAlertThresholdMillis = dbOpAlertThresholdMillis; return this; } diff --git a/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/LoggingConfigurator.java b/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/LoggingConfigurator.java index 342d5a0744e..a4465d47f7e 100644 --- a/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/LoggingConfigurator.java +++ b/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/LoggingConfigurator.java @@ -51,16 +51,31 @@ public class LoggingConfigurator { private static final String FILE_MESSAGE_FORMAT = "%d{yyyy-MM-dd HH:mm:ss.SSSZZZ} | %t | %-5level | %c{1} | %msg%n"; private static final AtomicBoolean COLOR = new AtomicBoolean(); + private static final StatusLogger STATUS_LOG = StatusLogger.getLogger(); + @SuppressWarnings("NonFinalStaticField") private static LoggingDestination destination; + + @SuppressWarnings("NonFinalStaticField") private static boolean includeEvents; + + @SuppressWarnings("NonFinalStaticField") private static boolean includeValidatorDuties; + + @SuppressWarnings("NonFinalStaticField") private static boolean includeP2pWarnings; + + @SuppressWarnings("NonFinalStaticField") private static String file; + + @SuppressWarnings("NonFinalStaticField") private static String filePattern; + + @SuppressWarnings("NonFinalStaticField") private static Level rootLogLevel = Level.INFO; + + @SuppressWarnings("NonFinalStaticField") private static int dbOpAlertThresholdMillis; - private static final StatusLogger STATUS_LOG = StatusLogger.getLogger(); public static boolean isColorEnabled() { return COLOR.get(); @@ -162,9 +177,9 @@ private static void addLoggers(final AbstractConfiguration configuration) { break; default: displayUnknownDestinationConfigured(); - // fall through + // fall through case DEFAULT_BOTH: - // fall through + // fall through case BOTH: consoleAppender = consoleAppender(configuration, true); final LoggerConfig eventsLogger = setUpEventsLogger(consoleAppender); @@ -196,9 +211,9 @@ private static void displayProgrammaticLoggingConfiguration() { STATUS_LOG.info("Logging file location: {}", file); break; default: - // fall through + // fall through case DEFAULT_BOTH: - // fall through + // fall through case BOTH: STATUS_LOG.info("Configuring logging for destination: console and file"); STATUS_LOG.info("Logging file location: {}", file); @@ -296,7 +311,7 @@ private static LoggerConfig setUpDbLogger(final Appender appender) { @VisibleForTesting static PatternLayout consoleAppenderLayout( - AbstractConfiguration configuration, final boolean omitStackTraces) { + final AbstractConfiguration configuration, final boolean omitStackTraces) { final Pattern logReplacement = Pattern.compile(isColorEnabled() ? COLOR_LOG_REGEX : NO_COLOR_LOG_REGEX); return PatternLayout.newBuilder() @@ -324,7 +339,7 @@ private static Appender consoleAppender( } @VisibleForTesting - static PatternLayout fileAppenderLayout(AbstractConfiguration configuration) { + static PatternLayout fileAppenderLayout(final AbstractConfiguration configuration) { final Pattern logReplacement = Pattern.compile(isColorEnabled() ? COLOR_LOG_REGEX : NO_COLOR_LOG_REGEX); return PatternLayout.newBuilder() diff --git a/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/StartupLogConfig.java b/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/StartupLogConfig.java index e1094992f43..e4a787d0906 100644 --- a/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/StartupLogConfig.java +++ b/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/StartupLogConfig.java @@ -119,58 +119,58 @@ public StartupLogConfig build() { validatorRestApiAllow); } - public Builder network(String network) { + public Builder network(final String network) { checkNotNull(network); this.network = network; return this; } - public Builder storageMode(String storageMode) { + public Builder storageMode(final String storageMode) { checkNotNull(storageMode); this.storageMode = storageMode; return this; } - public Builder hardwareInfo(HardwareAbstractionLayer hardwareInfo) { + public Builder hardwareInfo(final HardwareAbstractionLayer hardwareInfo) { checkNotNull(hardwareInfo); this.hardwareInfo = hardwareInfo; return this; } - public Builder beaconChainRestApiEnabled(boolean beaconChainRestApiEnabled) { + public Builder beaconChainRestApiEnabled(final boolean beaconChainRestApiEnabled) { this.beaconChainRestApiEnabled = beaconChainRestApiEnabled; return this; } - public Builder beaconChainRestApiInterface(String beaconChainRestApiInterface) { + public Builder beaconChainRestApiInterface(final String beaconChainRestApiInterface) { checkNotNull(beaconChainRestApiInterface); this.beaconChainRestApiInterface = beaconChainRestApiInterface; return this; } - public Builder beaconChainRestApiPort(int beaconChainRestApiPort) { + public Builder beaconChainRestApiPort(final int beaconChainRestApiPort) { this.beaconChainRestApiPort = beaconChainRestApiPort; return this; } - public Builder beaconChainRestApiAllow(List beaconChainRestApiAllow) { + public Builder beaconChainRestApiAllow(final List beaconChainRestApiAllow) { checkNotNull(beaconChainRestApiAllow); this.beaconChainRestApiAllow = beaconChainRestApiAllow; return this; } - public Builder validatorRestApiInterface(String validatorRestApiInterface) { + public Builder validatorRestApiInterface(final String validatorRestApiInterface) { checkNotNull(validatorRestApiInterface); this.validatorRestApiInterface = validatorRestApiInterface; return this; } - public Builder validatorRestApiPort(int validatorRestApiPort) { + public Builder validatorRestApiPort(final int validatorRestApiPort) { this.validatorRestApiPort = validatorRestApiPort; return this; } - public Builder validatorRestApiAllow(List validatorRestApiAllow) { + public Builder validatorRestApiAllow(final List validatorRestApiAllow) { checkNotNull(validatorRestApiAllow); this.validatorRestApiAllow = validatorRestApiAllow; return this; diff --git a/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/StatusLogger.java b/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/StatusLogger.java index dab59faf64c..863e7d4af1e 100644 --- a/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/StatusLogger.java +++ b/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/StatusLogger.java @@ -142,8 +142,8 @@ public void unexpectedFailure(final String description, final Throwable cause) { log.error("PLEASE FIX OR REPORT | Unexpected exception thrown for {}", description, cause); } - public void listeningForLibP2P(final String address) { - log.info("Listening for connections on: {}", address); + public void listeningForLibP2P(final List addresses) { + log.info("Listening for connections on: {}", String.join(",", addresses)); } public void listeningForDiscv5PreGenesis(final String enr) { @@ -203,7 +203,7 @@ public void doppelgangerDetectionEnd( } } - public void doppelgangerCheck(long epoch, Set publicKeys) { + public void doppelgangerCheck(final long epoch, final Set publicKeys) { log.info( "Performing doppelganger check. Epoch {}, Public keys {}", epoch, @@ -266,7 +266,7 @@ public void failedToStartValidatorClient(final String message) { log.fatal("Please check the logs for details."); } - public void fatalErrorInitialisingStorage(Throwable err) { + public void fatalErrorInitialisingStorage(final Throwable err) { log.debug("Failed to initialize storage", err); log.fatal( "Failed to initialize storage. " @@ -367,7 +367,8 @@ public void loadingGenesisFromEth1Chain() { log.info("No genesis state available. Loading deposits from ETH1 chain"); } - public void genesisValidatorsActivated(int activeValidatorCount, int requiredValidatorCount) { + public void genesisValidatorsActivated( + final int activeValidatorCount, final int requiredValidatorCount) { log.info( "Activated {} of {} validators required for genesis ({}%)", activeValidatorCount, @@ -432,7 +433,7 @@ public void performance(final String performance) { } public void eth1DepositChainIdMismatch( - long expectedChainId, long eth1ChainId, String endpointId) { + final long expectedChainId, final long eth1ChainId, final String endpointId) { log.log( Level.ERROR, "PLEASE CHECK YOUR ETH1 NODE (endpoint {})| Wrong Eth1 chain id (expected={}, actual={})", @@ -441,7 +442,7 @@ public void eth1DepositChainIdMismatch( eth1ChainId); } - public void externalSignerStatus(final URL externalSignerUrl, boolean isReachable) { + public void externalSignerStatus(final URL externalSignerUrl, final boolean isReachable) { if (isReachable) { log.info("External signer is reachable at {}", externalSignerUrl); } else { @@ -456,23 +457,24 @@ public void unableToRetrieveValidatorStatusesFromBeaconNode() { log.error("Unable to retrieve validator statuses from BeaconNode."); } - public void validatorStatus(String publicKey, String validatorStatus) { + public void validatorStatus(final String publicKey, final String validatorStatus) { log.info("Validator {} status is {}.", publicKey, validatorStatus); } - public void unableToRetrieveValidatorStatus(String publicKey) { + public void unableToRetrieveValidatorStatus(final String publicKey) { log.warn("Unable to retrieve status for validator {}.", publicKey); } - public void unableToRetrieveValidatorStatusSummary(int n) { + public void unableToRetrieveValidatorStatusSummary(final int n) { log.warn("Unable to retrieve status for {} validators.", n); } - public void validatorStatusSummary(int n, String validatorStatus) { + public void validatorStatusSummary(final int n, final String validatorStatus) { log.info("{} validators are in {} state.", n, validatorStatus); } - public void validatorStatusChange(String oldStatus, String newStatus, String publicKey) { + public void validatorStatusChange( + final String oldStatus, final String newStatus, final String publicKey) { log.warn("Validator {} has changed status from {} to {}.", publicKey, oldStatus, newStatus); } @@ -530,6 +532,15 @@ public void warnIgnoringWeakSubjectivityPeriod() { Color.YELLOW)); } + public void warnUsageOfImplicitPruneDataStorageMode() { + log.warn( + print( + "Prune mode being used as default without a explicit --data-storage-mode option. This will NOT be " + + "supported in future Teku versions. Please add --data-storage-mode=prune to your CLI arguments" + + " or config file if you want to keep using PRUNE.", + Color.YELLOW)); + } + private void logWithColorIfLevelGreaterThanInfo( final Level level, final String msg, final ColorConsolePrinter.Color color) { final boolean useColor = level.compareTo(Level.INFO) < 0; diff --git a/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/SubCommandLogger.java b/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/SubCommandLogger.java index 18f55369a02..ba89a49b7d7 100644 --- a/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/SubCommandLogger.java +++ b/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/SubCommandLogger.java @@ -25,7 +25,7 @@ public class SubCommandLogger { LoggingConfigurator.setColorEnabled(true); } - public void exit(int exitCode, final String message) { + public void exit(final int exitCode, final String message) { if (!StringUtils.isEmpty(message)) { if (exitCode == 0) { display(message); @@ -44,7 +44,7 @@ public void commandIsNotSafeForProduction() { ColorConsolePrinter.Color.RED)); } - public void displayDeprecationWarning(String message) { + public void displayDeprecationWarning(final String message) { error( print(String.format("DEPRECATION WARNING: %s", message), ColorConsolePrinter.Color.YELLOW)); } diff --git a/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/ValidatorLogger.java b/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/ValidatorLogger.java index 15aca572d3d..31ef97f3e52 100644 --- a/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/ValidatorLogger.java +++ b/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/ValidatorLogger.java @@ -170,7 +170,7 @@ private String formatBlockRoots(final Set blockRoots) { return blockRoots.stream().map(LogFormatter::formatHashRoot).collect(Collectors.joining(", ")); } - public void aggregationSkipped(final UInt64 slot, final int committeeIndex) { + public void aggregationSkipped(final UInt64 slot, final UInt64 committeeIndex) { log.warn( ColorConsolePrinter.print( PREFIX diff --git a/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/WeakSubjectivityLogger.java b/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/WeakSubjectivityLogger.java index 108078722d4..39291e2ef9f 100644 --- a/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/WeakSubjectivityLogger.java +++ b/infrastructure/logging/src/main/java/tech/pegasys/teku/infrastructure/logging/WeakSubjectivityLogger.java @@ -57,7 +57,7 @@ public void warnWeakSubjectivityFinalizedCheckpointValidationDeferred( } public void finalizedCheckpointOutsideOfWeakSubjectivityPeriod( - Level level, final UInt64 latestFinalizedCheckpointEpoch) { + final Level level, final UInt64 latestFinalizedCheckpointEpoch) { final String msg = String.format( "The latest finalized checkpoint at epoch %s is outside of the weak subjectivity period. Please supply a recent weak subjectivity checkpoint using --ws-checkpoint=:.", diff --git a/infrastructure/logging/src/test/java/tech/pegasys/teku/infrastructure/logging/ConverterTest.java b/infrastructure/logging/src/test/java/tech/pegasys/teku/infrastructure/logging/ConverterTest.java index aada49e6276..2bef5b65f3b 100644 --- a/infrastructure/logging/src/test/java/tech/pegasys/teku/infrastructure/logging/ConverterTest.java +++ b/infrastructure/logging/src/test/java/tech/pegasys/teku/infrastructure/logging/ConverterTest.java @@ -20,21 +20,49 @@ import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; class ConverterTest { @ParameterizedTest - @MethodSource("getUInt256Values") - void test(final UInt256 wei, final String expected) { + @MethodSource("getWeiToEthArguments") + void testWeiToEth(final UInt256 wei, final String expected) { String output = Converter.weiToEth(wei); assertThat(output).isEqualTo(expected); } - private static Stream getUInt256Values() { + @ParameterizedTest + @MethodSource("getWeiToGweiArguments") + void testWeiToGwei(final UInt256 wei, final UInt64 expected) { + UInt64 output = Converter.weiToGwei(wei); + assertThat(output).isEqualTo(expected); + } + + @ParameterizedTest + @MethodSource("getGweiToEthArguments") + void testGweiToEth(final UInt64 gwei, final String expected) { + String output = Converter.gweiToEth(gwei); + assertThat(output).isEqualTo(expected); + } + + private static Stream getWeiToEthArguments() { return Stream.of( Arguments.of(UInt256.valueOf(1), "0.000000"), Arguments.of(UInt256.valueOf(1000), "0.000000"), Arguments.of(UInt256.valueOf(3401220000000000L), "0.003401"), Arguments.of(UInt256.valueOf(889999203452340000L), "0.889999")); } + + private static Stream getWeiToGweiArguments() { + return Stream.of( + Arguments.of(UInt256.valueOf(1), UInt64.valueOf(0)), + Arguments.of(UInt256.valueOf(1000), UInt64.valueOf(0)), + Arguments.of(UInt256.valueOf(3401220000000000L), UInt64.valueOf(3401220)), + Arguments.of(UInt256.valueOf(889999203452340000L), UInt64.valueOf(889999203)), + Arguments.of(UInt256.valueOf(424242424242424242L), UInt64.valueOf(424242424))); + } + + private static Stream getGweiToEthArguments() { + return Stream.of(Arguments.of(UInt64.valueOf(424242424), "0.424242")); + } } diff --git a/infrastructure/logging/src/test/java/tech/pegasys/teku/infrastructure/logging/StartupLogConfigTest.java b/infrastructure/logging/src/test/java/tech/pegasys/teku/infrastructure/logging/StartupLogConfigTest.java index 08e7bf40c38..d80e27d3259 100644 --- a/infrastructure/logging/src/test/java/tech/pegasys/teku/infrastructure/logging/StartupLogConfigTest.java +++ b/infrastructure/logging/src/test/java/tech/pegasys/teku/infrastructure/logging/StartupLogConfigTest.java @@ -17,7 +17,9 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import java.text.DecimalFormatSymbols; import java.util.List; +import java.util.regex.Pattern; import org.junit.jupiter.api.Test; import oshi.hardware.CentralProcessor; import oshi.hardware.GlobalMemory; @@ -61,11 +63,23 @@ private void testReport(final boolean restApiEnabled, final String restApiReport .validatorRestApiAllow(List.of("127.0.0.1", "localhost")) .build(); - assertThat(config.getReport()) + List report = config.getReport(); + + assertThat(report) + .elements(0, 2, 3) .containsExactly( "Configuration | Network: mainnet, Storage Mode: PRUNE", - "Host Configuration | Maximum Heap Size: 4.00 GB, Total Memory: 16.00 GB, CPU Cores: 10", restApiReport, "Validator Api Configuration | Listen Address: 127.0.0.1, Port 6789, Allow: [127.0.0.1, localhost]"); + String escapedDecimalSeparator = + Pattern.quote("" + DecimalFormatSymbols.getInstance().getDecimalSeparator()); + assertThat(report.get(1)) + .matches( + Pattern.compile( + "Host Configuration \\| Maximum Heap Size: \\d+" + + escapedDecimalSeparator + + "\\d+ GB, Total Memory: 16" + + escapedDecimalSeparator + + "00 GB, CPU Cores: 10")); } } diff --git a/infrastructure/metrics/build.gradle b/infrastructure/metrics/build.gradle index 48464631b65..f300d1146e7 100644 --- a/infrastructure/metrics/build.gradle +++ b/infrastructure/metrics/build.gradle @@ -8,7 +8,7 @@ dependencies { implementation 'io.prometheus:simpleclient' implementation 'io.vertx:vertx-core' implementation 'io.vertx:vertx-web' - implementation 'org.apache.tuweni:tuweni-units' + implementation 'io.tmio:tuweni-units' implementation 'org.hdrhistogram:HdrHistogram' implementation 'org.hyperledger.besu.internal:metrics-core' diff --git a/infrastructure/metrics/src/main/java/tech/pegasys/teku/infrastructure/metrics/MetricsConfig.java b/infrastructure/metrics/src/main/java/tech/pegasys/teku/infrastructure/metrics/MetricsConfig.java index 83d921f596f..dce7d7df86f 100644 --- a/infrastructure/metrics/src/main/java/tech/pegasys/teku/infrastructure/metrics/MetricsConfig.java +++ b/infrastructure/metrics/src/main/java/tech/pegasys/teku/infrastructure/metrics/MetricsConfig.java @@ -40,9 +40,13 @@ public class MetricsConfig { public static final int DEFAULT_METRICS_PUBLICATION_INTERVAL = 60; public static final boolean DEFAULT_BLOCK_PERFORMANCE_ENABLED = true; public static final boolean DEFAULT_TICK_PERFORMANCE_ENABLED = false; + public static final boolean DEFAULT_BLOCK_PRODUCTION_AND_PUBLISHING_PERFORMANCE_ENABLED = true; - public static final int DEFAULT_BLOCK_PRODUCTION_PERFORMANCE_WARNING_THRESHOLD = 300; - public static final int DEFAULT_BLOCK_PUBLISHING_PERFORMANCE_WARNING_THRESHOLD = 1000; + public static final int DEFAULT_BLOCK_PRODUCTION_PERFORMANCE_WARNING_LOCAL_THRESHOLD = 600; + public static final int DEFAULT_BLOCK_PRODUCTION_PERFORMANCE_WARNING_BUILDER_THRESHOLD = 1000; + public static final int DEFAULT_BLOCK_PUBLISHING_PERFORMANCE_WARNING_LOCAL_THRESHOLD = 750; + public static final int DEFAULT_BLOCK_PUBLISHING_PERFORMANCE_WARNING_BUILDER_THRESHOLD = 1500; + public static final boolean DEFAULT_BLOB_SIDECARS_STORAGE_COUNTERS_ENABLED = false; private final boolean metricsEnabled; @@ -57,8 +61,10 @@ public class MetricsConfig { private final boolean tickPerformanceEnabled; private final boolean blobSidecarsStorageCountersEnabled; private final boolean blockProductionAndPublishingPerformanceEnabled; - private final int blockProductionPerformanceWarningThreshold; - private final int blockPublishingPerformanceWarningThreshold; + private final int blockProductionPerformanceWarningLocalThreshold; + private final int blockProductionPerformanceWarningBuilderThreshold; + private final int blockPublishingPerformanceWarningLocalThreshold; + private final int blockPublishingPerformanceWarningBuilderThreshold; private MetricsConfig( final boolean metricsEnabled, @@ -73,8 +79,10 @@ private MetricsConfig( final boolean tickPerformanceEnabled, final boolean blobSidecarsStorageCountersEnabled, final boolean blockProductionAndPublishingPerformanceEnabled, - final int blockProductionPerformanceWarningThreshold, - final int blockPublishingPerformanceWarningThreshold) { + final int blockProductionPerformanceWarningLocalThreshold, + final int blockProductionPerformanceWarningBuilderThreshold, + final int blockPublishingPerformanceWarningLocalThreshold, + final int blockPublishingPerformanceWarningBuilderThreshold) { this.metricsEnabled = metricsEnabled; this.metricsPort = metricsPort; this.metricsInterface = metricsInterface; @@ -88,8 +96,14 @@ private MetricsConfig( this.blobSidecarsStorageCountersEnabled = blobSidecarsStorageCountersEnabled; this.blockProductionAndPublishingPerformanceEnabled = blockProductionAndPublishingPerformanceEnabled; - this.blockProductionPerformanceWarningThreshold = blockProductionPerformanceWarningThreshold; - this.blockPublishingPerformanceWarningThreshold = blockPublishingPerformanceWarningThreshold; + this.blockProductionPerformanceWarningLocalThreshold = + blockProductionPerformanceWarningLocalThreshold; + this.blockProductionPerformanceWarningBuilderThreshold = + blockProductionPerformanceWarningBuilderThreshold; + this.blockPublishingPerformanceWarningLocalThreshold = + blockPublishingPerformanceWarningLocalThreshold; + this.blockPublishingPerformanceWarningBuilderThreshold = + blockPublishingPerformanceWarningBuilderThreshold; } public static MetricsConfigBuilder builder() { @@ -136,12 +150,20 @@ public boolean isBlockProductionAndPublishingPerformanceEnabled() { return blockProductionAndPublishingPerformanceEnabled; } - public int getBlockProductionPerformanceWarningThreshold() { - return blockProductionPerformanceWarningThreshold; + public int getBlockProductionPerformanceWarningLocalThreshold() { + return blockProductionPerformanceWarningLocalThreshold; + } + + public int getBlockProductionPerformanceWarningBuilderThreshold() { + return blockProductionPerformanceWarningBuilderThreshold; + } + + public int getBlockPublishingPerformanceWarningLocalThreshold() { + return blockPublishingPerformanceWarningLocalThreshold; } - public int getBlockPublishingPerformanceWarningThreshold() { - return blockPublishingPerformanceWarningThreshold; + public int getBlockPublishingPerformanceWarningBuilderThreshold() { + return blockPublishingPerformanceWarningBuilderThreshold; } public boolean isTickPerformanceEnabled() { @@ -165,22 +187,26 @@ public static final class MetricsConfigBuilder { private boolean blockPerformanceEnabled = DEFAULT_BLOCK_PERFORMANCE_ENABLED; private boolean blockProductionAndPublishingPerformanceEnabled = DEFAULT_BLOCK_PRODUCTION_AND_PUBLISHING_PERFORMANCE_ENABLED; - private int blockProductionPerformanceWarningThreshold = - DEFAULT_BLOCK_PRODUCTION_PERFORMANCE_WARNING_THRESHOLD; - private int blockPublishingPerformanceWarningThreshold = - DEFAULT_BLOCK_PUBLISHING_PERFORMANCE_WARNING_THRESHOLD; + private int blockProductionPerformanceWarningLocalThreshold = + DEFAULT_BLOCK_PRODUCTION_PERFORMANCE_WARNING_LOCAL_THRESHOLD; + private int blockProductionPerformanceWarningBuilderThreshold = + DEFAULT_BLOCK_PRODUCTION_PERFORMANCE_WARNING_BUILDER_THRESHOLD; + private int blockPublishingPerformanceWarningLocalThreshold = + DEFAULT_BLOCK_PUBLISHING_PERFORMANCE_WARNING_LOCAL_THRESHOLD; + private int blockPublishingPerformanceWarningBuilderThreshold = + DEFAULT_BLOCK_PUBLISHING_PERFORMANCE_WARNING_BUILDER_THRESHOLD; private boolean tickPerformanceEnabled = DEFAULT_TICK_PERFORMANCE_ENABLED; private boolean blobSidecarsStorageCountersEnabled = DEFAULT_BLOB_SIDECARS_STORAGE_COUNTERS_ENABLED; private MetricsConfigBuilder() {} - public MetricsConfigBuilder metricsEnabled(boolean metricsEnabled) { + public MetricsConfigBuilder metricsEnabled(final boolean metricsEnabled) { this.metricsEnabled = metricsEnabled; return this; } - public MetricsConfigBuilder metricsPort(int metricsPort) { + public MetricsConfigBuilder metricsPort(final int metricsPort) { if (!PortAvailability.isPortValid(metricsPort)) { throw new InvalidConfigurationException( String.format("Invalid metricsPort: %d", metricsPort)); @@ -189,27 +215,27 @@ public MetricsConfigBuilder metricsPort(int metricsPort) { return this; } - public MetricsConfigBuilder metricsInterface(String metricsInterface) { + public MetricsConfigBuilder metricsInterface(final String metricsInterface) { this.metricsInterface = metricsInterface; return this; } - public MetricsConfigBuilder metricsCategories(Set metricsCategories) { + public MetricsConfigBuilder metricsCategories(final Set metricsCategories) { this.metricsCategories = metricsCategories; return this; } - public MetricsConfigBuilder metricsHostAllowlist(List metricsHostAllowlist) { + public MetricsConfigBuilder metricsHostAllowlist(final List metricsHostAllowlist) { this.metricsHostAllowlist = metricsHostAllowlist; return this; } - public MetricsConfigBuilder metricsPublishEndpoint(URL metricsPublishEndpoint) { + public MetricsConfigBuilder metricsPublishEndpoint(final URL metricsPublishEndpoint) { this.metricsPublishEndpoint = metricsPublishEndpoint; return this; } - public MetricsConfigBuilder metricsPublishInterval(int metricsPublishInterval) { + public MetricsConfigBuilder metricsPublishInterval(final int metricsPublishInterval) { if (metricsPublishInterval < 0) { throw new InvalidConfigurationException( String.format("Invalid metricsPublishInterval: %d", metricsPublishInterval)); @@ -239,15 +265,31 @@ public MetricsConfigBuilder blockProductionAndPublishingPerformanceEnabled( return this; } - public MetricsConfigBuilder blockProductionPerformanceWarningThreshold( - final int blockProductionPerformanceWarningThreshold) { - this.blockProductionPerformanceWarningThreshold = blockProductionPerformanceWarningThreshold; + public MetricsConfigBuilder blockProductionPerformanceWarningLocalThreshold( + final int blockProductionPerformanceWarningLocalThreshold) { + this.blockProductionPerformanceWarningLocalThreshold = + blockProductionPerformanceWarningLocalThreshold; + return this; + } + + public MetricsConfigBuilder blockProductionPerformanceWarningBuilderThreshold( + final int blockProductionPerformanceWarningBuilderThreshold) { + this.blockProductionPerformanceWarningBuilderThreshold = + blockProductionPerformanceWarningBuilderThreshold; + return this; + } + + public MetricsConfigBuilder blockPublishingPerformanceWarningLocalThreshold( + final int blockPublishingPerformanceWarningLocalThreshold) { + this.blockPublishingPerformanceWarningLocalThreshold = + blockPublishingPerformanceWarningLocalThreshold; return this; } - public MetricsConfigBuilder blockPublishingPerformanceWarningThreshold( - final int blockPublishingPerformanceWarningThreshold) { - this.blockPublishingPerformanceWarningThreshold = blockPublishingPerformanceWarningThreshold; + public MetricsConfigBuilder blockPublishingPerformanceWarningBuilderThreshold( + final int blockPublishingPerformanceWarningBuilderThreshold) { + this.blockPublishingPerformanceWarningBuilderThreshold = + blockPublishingPerformanceWarningBuilderThreshold; return this; } @@ -276,8 +318,10 @@ public MetricsConfig build() { tickPerformanceEnabled, blobSidecarsStorageCountersEnabled, blockProductionAndPublishingPerformanceEnabled, - blockProductionPerformanceWarningThreshold, - blockPublishingPerformanceWarningThreshold); + blockProductionPerformanceWarningLocalThreshold, + blockProductionPerformanceWarningBuilderThreshold, + blockPublishingPerformanceWarningLocalThreshold, + blockPublishingPerformanceWarningBuilderThreshold); } } } diff --git a/infrastructure/metrics/src/main/java/tech/pegasys/teku/infrastructure/metrics/MetricsHistogram.java b/infrastructure/metrics/src/main/java/tech/pegasys/teku/infrastructure/metrics/MetricsHistogram.java index f386849bd02..38dd89ed000 100644 --- a/infrastructure/metrics/src/main/java/tech/pegasys/teku/infrastructure/metrics/MetricsHistogram.java +++ b/infrastructure/metrics/src/main/java/tech/pegasys/teku/infrastructure/metrics/MetricsHistogram.java @@ -37,9 +37,9 @@ public class MetricsHistogram { public MetricsHistogram( final MetricsSystem metricsSystem, final MetricCategory category, - String name, - String help, - double... buckets) { + final String name, + final String help, + final double... buckets) { this.histogram = Histogram.build() .name(category.getName().toLowerCase(Locale.ROOT) + "_" + name) diff --git a/infrastructure/metrics/src/main/java/tech/pegasys/teku/infrastructure/metrics/MetricsPublishCategories.java b/infrastructure/metrics/src/main/java/tech/pegasys/teku/infrastructure/metrics/MetricsPublishCategories.java index c252acfd1be..894006d36fd 100644 --- a/infrastructure/metrics/src/main/java/tech/pegasys/teku/infrastructure/metrics/MetricsPublishCategories.java +++ b/infrastructure/metrics/src/main/java/tech/pegasys/teku/infrastructure/metrics/MetricsPublishCategories.java @@ -20,7 +20,7 @@ public enum MetricsPublishCategories { private final String displayName; - MetricsPublishCategories(String displayName) { + MetricsPublishCategories(final String displayName) { this.displayName = displayName; } diff --git a/infrastructure/metrics/src/main/java/tech/pegasys/teku/infrastructure/metrics/MetricsQuantileHistogram.java b/infrastructure/metrics/src/main/java/tech/pegasys/teku/infrastructure/metrics/MetricsQuantileHistogram.java index f98c6c3d5b3..03caf7a00a7 100644 --- a/infrastructure/metrics/src/main/java/tech/pegasys/teku/infrastructure/metrics/MetricsQuantileHistogram.java +++ b/infrastructure/metrics/src/main/java/tech/pegasys/teku/infrastructure/metrics/MetricsQuantileHistogram.java @@ -212,7 +212,7 @@ private MetricFamilySamples.Sample createSample( final String metricName, final String quantileLabelValue, final List labelValues, - double percentile, + final double percentile, final SynchronizedHistogram histogram) { return new MetricFamilySamples.Sample( metricName, diff --git a/infrastructure/metrics/src/main/java/tech/pegasys/teku/infrastructure/metrics/SettableGauge.java b/infrastructure/metrics/src/main/java/tech/pegasys/teku/infrastructure/metrics/SettableGauge.java index f697420a4e2..d24f1916889 100644 --- a/infrastructure/metrics/src/main/java/tech/pegasys/teku/infrastructure/metrics/SettableGauge.java +++ b/infrastructure/metrics/src/main/java/tech/pegasys/teku/infrastructure/metrics/SettableGauge.java @@ -21,18 +21,21 @@ public class SettableGauge { private final AtomicDouble valueHolder; - private SettableGauge(AtomicDouble valueHolder) { + private SettableGauge(final AtomicDouble valueHolder) { this.valueHolder = valueHolder; } public static SettableGauge create( - MetricsSystem metricsSystem, MetricCategory category, String name, String help) { + final MetricsSystem metricsSystem, + final MetricCategory category, + final String name, + final String help) { AtomicDouble valueHolder = new AtomicDouble(); metricsSystem.createGauge(category, name, help, valueHolder::get); return new SettableGauge(valueHolder); } - public void set(double value) { + public void set(final double value) { valueHolder.set(value); } } diff --git a/infrastructure/metrics/src/main/java/tech/pegasys/teku/infrastructure/metrics/SettableLabelledGauge.java b/infrastructure/metrics/src/main/java/tech/pegasys/teku/infrastructure/metrics/SettableLabelledGauge.java index f28379a9e0d..6eb0855f936 100644 --- a/infrastructure/metrics/src/main/java/tech/pegasys/teku/infrastructure/metrics/SettableLabelledGauge.java +++ b/infrastructure/metrics/src/main/java/tech/pegasys/teku/infrastructure/metrics/SettableLabelledGauge.java @@ -41,7 +41,7 @@ public static SettableLabelledGauge create( return new SettableLabelledGauge(labelledGauge); } - public void set(double value, String... labels) { + public void set(final double value, final String... labels) { final AtomicDouble valueHolder = valueHolders.computeIfAbsent( List.of(labels), diff --git a/infrastructure/metrics/src/test/java/tech/pegasys/teku/infrastructure/metrics/StubMetricSystemTest.java b/infrastructure/metrics/src/test/java/tech/pegasys/teku/infrastructure/metrics/StubMetricSystemTest.java index a4fbf9815bf..7e3b4d3a884 100644 --- a/infrastructure/metrics/src/test/java/tech/pegasys/teku/infrastructure/metrics/StubMetricSystemTest.java +++ b/infrastructure/metrics/src/test/java/tech/pegasys/teku/infrastructure/metrics/StubMetricSystemTest.java @@ -48,13 +48,13 @@ public Optional getApplicationPrefix() { "correct_name__", "correct_name::123" }) - public void mustAcceptValidMetricNames(String input) { + public void mustAcceptValidMetricNames(final String input) { metricsSystem.createLabelledCounter(metricCategory, input, "", "correct_label"); } @ParameterizedTest @ValueSource(strings = {"1incorrect_name", "$incorrect_name", "incorrect-name"}) - public void mustRejectInvalidMetricNames(String input) { + public void mustRejectInvalidMetricNames(final String input) { Assertions.assertThrows( IllegalArgumentException.class, () -> metricsSystem.createLabelledCounter(metricCategory, input, "", "correct_label")); @@ -62,7 +62,7 @@ public void mustRejectInvalidMetricNames(String input) { @ParameterizedTest @ValueSource(strings = {"correctlabel", "correctLabel", "correct_label", "_correct_label"}) - public void mustAcceptValidLabelNames(String input) { + public void mustAcceptValidLabelNames(final String input) { metricsSystem.createLabelledCounter(metricCategory, "correct_name", "", input); } diff --git a/infrastructure/metrics/src/testFixtures/java/tech/pegasys/teku/infrastructure/metrics/StubLabelledOperationTimer.java b/infrastructure/metrics/src/testFixtures/java/tech/pegasys/teku/infrastructure/metrics/StubLabelledOperationTimer.java index 8c009d48be2..e0a5fae5c72 100644 --- a/infrastructure/metrics/src/testFixtures/java/tech/pegasys/teku/infrastructure/metrics/StubLabelledOperationTimer.java +++ b/infrastructure/metrics/src/testFixtures/java/tech/pegasys/teku/infrastructure/metrics/StubLabelledOperationTimer.java @@ -41,7 +41,7 @@ protected StubLabelledOperationTimer( final MetricCategory category, final String name, final String help, - Supplier timeProvider) { + final Supplier timeProvider) { super(category, name, help); this.timeProvider = timeProvider; } diff --git a/infrastructure/metrics/src/testFixtures/java/tech/pegasys/teku/infrastructure/metrics/StubMetricsSystem.java b/infrastructure/metrics/src/testFixtures/java/tech/pegasys/teku/infrastructure/metrics/StubMetricsSystem.java index f84c0fc24ad..0016785f19d 100644 --- a/infrastructure/metrics/src/testFixtures/java/tech/pegasys/teku/infrastructure/metrics/StubMetricsSystem.java +++ b/infrastructure/metrics/src/testFixtures/java/tech/pegasys/teku/infrastructure/metrics/StubMetricsSystem.java @@ -50,19 +50,6 @@ public LabelledMetric createLabelledCounter( .computeIfAbsent(name, __ -> new StubCounter()); } - @Override - public LabelledMetric createSimpleLabelledTimer( - final MetricCategory category, - final String name, - final String help, - final String... labelNames) { - validateMetricName(name); - validateLabelName(labelNames); - return labelledOperationTimers - .computeIfAbsent(category, __ -> new ConcurrentHashMap<>()) - .computeIfAbsent(name, __ -> new StubLabelledOperationTimer(category, name, help)); - } - @Override public LabelledGauge createLabelledGauge( final MetricCategory category, @@ -105,6 +92,15 @@ public LabelledMetric createLabelledTimer( .computeIfAbsent(name, __ -> new StubLabelledOperationTimer(category, name, help)); } + @Override + public LabelledMetric createSimpleLabelledTimer( + final MetricCategory category, + final String name, + final String help, + final String... labelNames) { + return createLabelledTimer(category, name, help, labelNames); + } + public StubGauge getGauge(final MetricCategory category, final String name) { validateMetricName(name); return Optional.ofNullable(gauges.get(category)) @@ -137,7 +133,7 @@ public StubLabelledOperationTimer getLabelledOperationTimer( () -> new IllegalArgumentException("Unknown labelled timer: " + category + " " + name)); } - private void validateMetricName(String metricName) { + private void validateMetricName(final String metricName) { if (!METRIC_NAME_PATTERN.matcher(metricName).matches()) { throw new IllegalArgumentException( String.format( @@ -146,7 +142,7 @@ private void validateMetricName(String metricName) { } } - private void validateLabelName(String... labelNames) { + private void validateLabelName(final String... labelNames) { for (String labelName : labelNames) { if (!LABEL_NAME_PATTERN.matcher(labelName).matches()) { throw new IllegalArgumentException( diff --git a/infrastructure/restapi/src/main/java/tech/pegasys/teku/infrastructure/restapi/endpoints/EndpointMetadata.java b/infrastructure/restapi/src/main/java/tech/pegasys/teku/infrastructure/restapi/endpoints/EndpointMetadata.java index 5fa1f5f1cc5..c6af6eaeaac 100644 --- a/infrastructure/restapi/src/main/java/tech/pegasys/teku/infrastructure/restapi/endpoints/EndpointMetadata.java +++ b/infrastructure/restapi/src/main/java/tech/pegasys/teku/infrastructure/restapi/endpoints/EndpointMetadata.java @@ -61,6 +61,7 @@ import tech.pegasys.teku.infrastructure.restapi.openapi.OpenApiResponse; import tech.pegasys.teku.infrastructure.restapi.openapi.request.MilestoneSpecificOctetStreamRequestContentTypeDefinition; import tech.pegasys.teku.infrastructure.restapi.openapi.request.OctetStreamRequestContentTypeDefinition; +import tech.pegasys.teku.infrastructure.restapi.openapi.request.OneOfArrayJsonRequestContentTypeDefinition; import tech.pegasys.teku.infrastructure.restapi.openapi.request.OneOfJsonRequestContentTypeDefinition; import tech.pegasys.teku.infrastructure.restapi.openapi.request.OneOfJsonRequestContentTypeDefinition.BodyTypeSelector; import tech.pegasys.teku.infrastructure.restapi.openapi.request.RequestContentTypeDefinition; @@ -85,6 +86,7 @@ public class EndpointMetadata { private final Map> pathParams; private final Map> requiredQueryParams; private final Map> queryParams; + private final Map> queryParamsAllowEmpty; private final Map> queryListParams; private final Map> requiredHeaders; private final Map> headers; @@ -105,6 +107,7 @@ private EndpointMetadata( final List tags, final Map> pathParams, final Map> queryParams, + final Map> queryParamsAllowEmpty, final Map> requiredQueryParams, final Map> queryListParams, final Map> requiredHeaders, @@ -124,6 +127,7 @@ private EndpointMetadata( this.tags = tags; this.pathParams = pathParams; this.queryParams = queryParams; + this.queryParamsAllowEmpty = queryParamsAllowEmpty; this.requiredQueryParams = requiredQueryParams; this.queryListParams = queryListParams; this.requiredHeaders = requiredHeaders; @@ -223,12 +227,15 @@ public StringValueTypeDefinition getQueryParameterDefinition(final String par checkArgument( requiredQueryParams.containsKey(parameterName) || queryParams.containsKey(parameterName) + || queryParamsAllowEmpty.containsKey(parameterName) || queryListParams.containsKey(parameterName), "Query parameter " + parameterName + " was not found in endpoint metadata"); if (requiredQueryParams.containsKey(parameterName)) { return requiredQueryParams.get(parameterName); } else if (queryParams.containsKey(parameterName)) { return queryParams.get(parameterName); + } else if (queryParamsAllowEmpty.containsKey(parameterName)) { + return queryParamsAllowEmpty.get(parameterName); } return queryListParams.get(parameterName); @@ -308,19 +315,21 @@ public void writeOpenApi(final JsonGenerator gen) throws IOException { if (deprecated) { gen.writeBooleanField("deprecated", true); } - if (pathParams.size() > 0 - || queryParams.size() > 0 - || requiredQueryParams.size() > 0 - || queryListParams.size() > 0 - || requiredHeaders.size() > 0 - || headers.size() > 0) { + if (!pathParams.isEmpty() + || !queryParams.isEmpty() + || !queryParamsAllowEmpty.isEmpty() + || !requiredQueryParams.isEmpty() + || !queryListParams.isEmpty() + || !requiredHeaders.isEmpty() + || !headers.isEmpty()) { gen.writeArrayFieldStart("parameters"); - writeParameters(gen, pathParams, "path", true, false); - writeParameters(gen, requiredQueryParams, "query", true, false); - writeParameters(gen, queryParams, "query", false, false); - writeParameters(gen, queryListParams, "query", false, true); - writeParameters(gen, requiredHeaders, "header", true, false); - writeParameters(gen, headers, "header", false, false); + writeParameters(gen, pathParams, "path", true, false, false); + writeParameters(gen, requiredQueryParams, "query", true, false, false); + writeParameters(gen, queryParams, "query", false, false, false); + writeParameters(gen, queryParamsAllowEmpty, "query", false, false, true); + writeParameters(gen, queryListParams, "query", false, true, false); + writeParameters(gen, requiredHeaders, "header", true, false, false); + writeParameters(gen, headers, "header", false, false, false); gen.writeEndArray(); } @@ -364,7 +373,8 @@ private void writeParameters( final Map> fields, final String parameterUsedIn, final boolean isMandatoryField, - final boolean isList) + final boolean isList, + final boolean allowEmptyValue) throws IOException { for (Map.Entry> entry : fields.entrySet()) { gen.writeStartObject(); @@ -372,6 +382,9 @@ private void writeParameters( if (isMandatoryField) { gen.writeObjectField("required", true); } + if (allowEmptyValue) { + gen.writeObjectField("allowEmptyValue", true); + } gen.writeObjectField("in", parameterUsedIn); gen.writeFieldName("schema"); if (isList) { // Handle list parameter @@ -384,6 +397,7 @@ private void writeParameters( } else { // Handle regular parameter entry.getValue().serializeOpenApiTypeOrReference(gen); } + gen.writeEndObject(); } } @@ -430,6 +444,8 @@ public static class EndpointMetaDataBuilder { private boolean requiredRequestBody = true; private final Map> pathParams = new LinkedHashMap<>(); private final Map> queryParams = new LinkedHashMap<>(); + private final Map> queryParamsAllowEmpty = + new LinkedHashMap<>(); private final Map> requiredQueryParams = new LinkedHashMap<>(); private final Map> queryListParams = new LinkedHashMap<>(); @@ -464,21 +480,27 @@ public EndpointMetaDataBuilder pathParam(final ParameterMetadata parameterMet public EndpointMetaDataBuilder queryParam(final ParameterMetadata parameterMetadata) { final String param = parameterMetadata.getName(); - if (queryParams.containsKey(param) - || requiredQueryParams.containsKey(param) - || queryListParams.containsKey(param)) { + if (queryParamAlreadyAdded(param)) { throw new IllegalStateException("Query parameters already contains " + param); } queryParams.put(parameterMetadata.getName(), parameterMetadata.getType()); return this; } + public EndpointMetaDataBuilder queryParamAllowsEmpty( + final ParameterMetadata parameterMetadata) { + final String param = parameterMetadata.getName(); + if (queryParamAlreadyAdded(param)) { + throw new IllegalStateException("Query parameters already contains " + param); + } + queryParamsAllowEmpty.put(parameterMetadata.getName(), parameterMetadata.getType()); + return this; + } + public EndpointMetaDataBuilder queryParamRequired( final ParameterMetadata parameterMetadata) { final String param = parameterMetadata.getName(); - if (queryParams.containsKey(param) - || requiredQueryParams.containsKey(param) - || queryListParams.containsKey(param)) { + if (queryParamAlreadyAdded(param)) { throw new IllegalStateException("Query parameters already contains " + param); } requiredQueryParams.put(parameterMetadata.getName(), parameterMetadata.getType()); @@ -487,15 +509,20 @@ public EndpointMetaDataBuilder queryParamRequired( public EndpointMetaDataBuilder queryListParam(final ParameterMetadata parameterMetadata) { final String param = parameterMetadata.getName(); - if (queryParams.containsKey(param) - || requiredQueryParams.containsKey(param) - || queryListParams.containsKey(param)) { + if (queryParamAlreadyAdded(param)) { throw new IllegalStateException("Query parameters already contains " + param); } queryListParams.put(parameterMetadata.getName(), parameterMetadata.getType()); return this; } + private boolean queryParamAlreadyAdded(final String param) { + return queryParams.containsKey(param) + || queryParamsAllowEmpty.containsKey(param) + || requiredQueryParams.containsKey(param) + || queryListParams.containsKey(param); + } + public EndpointMetaDataBuilder headerRequired(final ParameterMetadata headerMetadata) { checkRequestHeader(headerMetadata); requiredHeaders.put(headerMetadata.getName(), headerMetadata.getType()); @@ -550,7 +577,7 @@ public EndpointMetaDataBuilder deprecated(final boolean deprecated) { } public EndpointMetaDataBuilder response(final int responseCode, final String description) { - return response(responseCode, description, emptyList()); + return response(responseCode, description, emptyList(), emptyList()); } public EndpointMetaDataBuilder defaultResponseType(final String defaultContentType) { @@ -595,6 +622,15 @@ public EndpointMetaDataBuilder requestBodyType( return this; } + public EndpointMetaDataBuilder requestBodyType( + final SerializableTypeDefinition> requestBodyType, + final OneOfArrayJsonRequestContentTypeDefinition.BodyTypeSelector bodyTypeSelector) { + this.requestBodyTypes.put( + ContentTypes.JSON, + new OneOfArrayJsonRequestContentTypeDefinition<>(requestBodyType, bodyTypeSelector)); + return this; + } + public EndpointMetaDataBuilder requestBodyType( final SerializableOneOfTypeDefinition requestBodyType, final BodyTypeSelector bodyTypeSelector, @@ -635,7 +671,22 @@ public EndpointMetaDataBuilder response( final String description, final SerializableTypeDefinition content) { return response( - responseCode, description, List.of(new JsonResponseContentTypeDefinition<>(content))); + responseCode, + description, + List.of(new JsonResponseContentTypeDefinition<>(content)), + emptyList()); + } + + public EndpointMetaDataBuilder response( + final int responseCode, + final String description, + final SerializableTypeDefinition content, + final SerializableTypeDefinition header) { + return response( + responseCode, + description, + List.of(new JsonResponseContentTypeDefinition<>(content)), + List.of(new JsonResponseContentTypeDefinition<>(header))); } public EndpointMetaDataBuilder response( @@ -646,14 +697,43 @@ public EndpointMetaDataBuilder response( return response( responseCode, description, - List.of(new JsonResponseContentTypeDefinition<>(content), octetStreamTypeDefinition)); + List.of(new JsonResponseContentTypeDefinition<>(content), octetStreamTypeDefinition), + emptyList()); + } + + public EndpointMetaDataBuilder response( + final int responseCode, + final String description, + final SerializableTypeDefinition content, + final ResponseContentTypeDefinition octetStreamTypeDefinition, + final SerializableTypeDefinition header) { + return response( + responseCode, + description, + List.of(new JsonResponseContentTypeDefinition<>(content), octetStreamTypeDefinition), + List.of(new JsonResponseContentTypeDefinition<>(header))); + } + + public EndpointMetaDataBuilder response( + final int responseCode, + final String description, + final SerializableTypeDefinition content, + final ResponseContentTypeDefinition octetStreamTypeDefinition, + final List> headers) { + return response( + responseCode, + description, + List.of(new JsonResponseContentTypeDefinition<>(content), octetStreamTypeDefinition), + headers.stream() + .map(JsonResponseContentTypeDefinition::new) + .collect(Collectors.toList())); } public EndpointMetaDataBuilder response( final int responseCode, final String description, final ResponseContentTypeDefinition octetStreamTypeDefinition) { - return response(responseCode, description, List.of(octetStreamTypeDefinition)); + return response(responseCode, description, List.of(octetStreamTypeDefinition), emptyList()); } public EndpointMetaDataBuilder withUnauthorizedResponse() { @@ -701,7 +781,7 @@ public EndpointMetaDataBuilder withNotImplementedResponse() { return this; } - public EndpointMetaDataBuilder withBadRequestResponse(Optional maybeMessage) { + public EndpointMetaDataBuilder withBadRequestResponse(final Optional maybeMessage) { response( SC_BAD_REQUEST, maybeMessage.orElse( @@ -714,7 +794,16 @@ public EndpointMetaDataBuilder response( final int responseCode, final String description, final List> content) { - this.responses.put(Integer.toString(responseCode), new OpenApiResponse(description, content)); + return response(responseCode, description, content, emptyList()); + } + + public EndpointMetaDataBuilder response( + final int responseCode, + final String description, + final List> content, + final List> header) { + this.responses.put( + Integer.toString(responseCode), new OpenApiResponse(description, header, content)); return this; } @@ -752,6 +841,7 @@ public EndpointMetadata build() { tags, pathParams, queryParams, + queryParamsAllowEmpty, requiredQueryParams, queryListParams, requiredHeaders, diff --git a/infrastructure/restapi/src/main/java/tech/pegasys/teku/infrastructure/restapi/endpoints/JavalinRestApiRequest.java b/infrastructure/restapi/src/main/java/tech/pegasys/teku/infrastructure/restapi/endpoints/JavalinRestApiRequest.java index 37b566e9bc7..073e33235bf 100644 --- a/infrastructure/restapi/src/main/java/tech/pegasys/teku/infrastructure/restapi/endpoints/JavalinRestApiRequest.java +++ b/infrastructure/restapi/src/main/java/tech/pegasys/teku/infrastructure/restapi/endpoints/JavalinRestApiRequest.java @@ -282,12 +282,12 @@ public T getRequestHeader(final ParameterMetadata parameterMetadata) { } @Override - public void header(String name, String value) { + public void header(final String name, final String value) { context.header(name, value); } @Override - public void startEventStream(Consumer clientConsumer) { + public void startEventStream(final Consumer clientConsumer) { SseHandler sseHandler = new SseHandler( client -> { diff --git a/infrastructure/restapi/src/main/java/tech/pegasys/teku/infrastructure/restapi/openapi/OpenApiResponse.java b/infrastructure/restapi/src/main/java/tech/pegasys/teku/infrastructure/restapi/openapi/OpenApiResponse.java index 3c9e1064e12..bebb4b51dd2 100644 --- a/infrastructure/restapi/src/main/java/tech/pegasys/teku/infrastructure/restapi/openapi/OpenApiResponse.java +++ b/infrastructure/restapi/src/main/java/tech/pegasys/teku/infrastructure/restapi/openapi/OpenApiResponse.java @@ -24,11 +24,15 @@ public class OpenApiResponse { private final String description; + private final List> header; private final List> content; public OpenApiResponse( - final String description, final List> content) { + final String description, + final List> header, + final List> content) { this.description = description; + this.header = header; this.content = content; } @@ -42,6 +46,14 @@ public ResponseContentTypeDefinition getType(final String contentType) { public void writeOpenApi(final JsonGenerator gen) throws IOException { gen.writeStartObject(); gen.writeStringField("description", description); + if (!header.isEmpty()) { + gen.writeObjectFieldStart("headers"); + for (var headerEntry : header) { + headerEntry.serializeOpenApiTypeOrReference(gen); + } + gen.writeEndObject(); + } + gen.writeObjectFieldStart("content"); for (ResponseContentTypeDefinition contentEntry : content) { gen.writeObjectFieldStart(contentEntry.getContentType()); diff --git a/infrastructure/restapi/src/main/java/tech/pegasys/teku/infrastructure/restapi/openapi/request/OneOfArrayJsonRequestContentTypeDefinition.java b/infrastructure/restapi/src/main/java/tech/pegasys/teku/infrastructure/restapi/openapi/request/OneOfArrayJsonRequestContentTypeDefinition.java new file mode 100644 index 00000000000..8776ee47294 --- /dev/null +++ b/infrastructure/restapi/src/main/java/tech/pegasys/teku/infrastructure/restapi/openapi/request/OneOfArrayJsonRequestContentTypeDefinition.java @@ -0,0 +1,84 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.infrastructure.restapi.openapi.request; + +import java.io.IOException; +import java.io.InputStream; +import java.nio.charset.StandardCharsets; +import java.util.List; +import java.util.Map; +import org.apache.commons.io.IOUtils; +import tech.pegasys.teku.infrastructure.json.JsonUtil; +import tech.pegasys.teku.infrastructure.json.exceptions.MissingRequestBodyException; +import tech.pegasys.teku.infrastructure.json.types.DelegatingOpenApiTypeDefinition; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition; + +public class OneOfArrayJsonRequestContentTypeDefinition extends DelegatingOpenApiTypeDefinition + implements RequestContentTypeDefinition> { + + private final BodyTypeSelector bodyTypeSelector; + + public OneOfArrayJsonRequestContentTypeDefinition( + final SerializableTypeDefinition> typeDefinition, + final BodyTypeSelector bodyTypeSelector) { + super(typeDefinition); + this.bodyTypeSelector = bodyTypeSelector; + } + + @Override + public List deserialize(final InputStream in) throws IOException { + return deserialize(in, Map.of()); + } + + @Override + public List deserialize(final InputStream in, final Map headers) + throws IOException { + final String json = IOUtils.toString(in, StandardCharsets.UTF_8); + final DeserializableTypeDefinition type = + bodyTypeSelector.selectType(new BodyTypeSelectorContext(json, headers)); + + if (type == null) { + throw new MissingRequestBodyException(); + } + + if (!openApiTypeDefinition.getReferencedTypeDefinitions().contains(type)) { + throw new IllegalStateException( + "Schema determined for parsing request body is not listed in requestBodyTypes"); + } + return JsonUtil.parse(json, DeserializableTypeDefinition.listOf(type)); + } + + public interface BodyTypeSelector { + DeserializableTypeDefinition selectType(final BodyTypeSelectorContext context); + } + + public static class BodyTypeSelectorContext { + final String body; + final Map headers; + + public BodyTypeSelectorContext(final String body, final Map headers) { + this.body = body; + this.headers = headers; + } + + public String getBody() { + return body; + } + + public Map getHeaders() { + return headers; + } + } +} diff --git a/infrastructure/restapi/src/main/java/tech/pegasys/teku/infrastructure/restapi/openapi/request/RequestContentTypeDefinition.java b/infrastructure/restapi/src/main/java/tech/pegasys/teku/infrastructure/restapi/openapi/request/RequestContentTypeDefinition.java index 53e2382b866..30bc8cf07cb 100644 --- a/infrastructure/restapi/src/main/java/tech/pegasys/teku/infrastructure/restapi/openapi/request/RequestContentTypeDefinition.java +++ b/infrastructure/restapi/src/main/java/tech/pegasys/teku/infrastructure/restapi/openapi/request/RequestContentTypeDefinition.java @@ -22,7 +22,8 @@ public interface RequestContentTypeDefinition extends OpenApiTypeDefinition { T deserialize(InputStream in) throws IOException; - default T deserialize(InputStream in, final Map headers) throws IOException { + default T deserialize(final InputStream in, final Map headers) + throws IOException { return deserialize(in); } } diff --git a/infrastructure/restapi/src/main/java/tech/pegasys/teku/infrastructure/restapi/openapi/request/SimpleJsonRequestContentTypeDefinition.java b/infrastructure/restapi/src/main/java/tech/pegasys/teku/infrastructure/restapi/openapi/request/SimpleJsonRequestContentTypeDefinition.java index 4e8db865311..5c60bdffd26 100644 --- a/infrastructure/restapi/src/main/java/tech/pegasys/teku/infrastructure/restapi/openapi/request/SimpleJsonRequestContentTypeDefinition.java +++ b/infrastructure/restapi/src/main/java/tech/pegasys/teku/infrastructure/restapi/openapi/request/SimpleJsonRequestContentTypeDefinition.java @@ -22,7 +22,7 @@ public class SimpleJsonRequestContentTypeDefinition extends DelegatingOpenApiTypeDefinition implements RequestContentTypeDefinition { - private DeserializableTypeDefinition typeDefinition; + private final DeserializableTypeDefinition typeDefinition; public SimpleJsonRequestContentTypeDefinition( final DeserializableTypeDefinition typeDefinition) { diff --git a/infrastructure/restapi/src/testFixtures/java/tech/pegasys/teku/infrastructure/restapi/MetadataTestUtil.java b/infrastructure/restapi/src/testFixtures/java/tech/pegasys/teku/infrastructure/restapi/MetadataTestUtil.java index 58897af77c9..12713572162 100644 --- a/infrastructure/restapi/src/testFixtures/java/tech/pegasys/teku/infrastructure/restapi/MetadataTestUtil.java +++ b/infrastructure/restapi/src/testFixtures/java/tech/pegasys/teku/infrastructure/restapi/MetadataTestUtil.java @@ -20,6 +20,7 @@ import java.io.IOException; import java.io.OutputStream; import java.nio.charset.StandardCharsets; +import java.util.Map; import org.apache.commons.io.IOUtils; import org.assertj.core.api.AssertionsForClassTypes; import tech.pegasys.teku.infrastructure.http.ContentTypes; @@ -72,6 +73,15 @@ public static Object getRequestBodyFromMetadata(final RestApiEndpoint handler, f IOUtils.toInputStream(json, StandardCharsets.UTF_8)); } + public static Object getRequestBodyFromMetadata( + final RestApiEndpoint handler, final Map headers, final String json) + throws IOException { + final RequestContentTypeDefinition requestContentTypeDefinition = + handler.getMetadata().getRequestBodyType(); + return requestContentTypeDefinition.deserialize( + IOUtils.toInputStream(json, StandardCharsets.UTF_8), headers); + } + private static byte[] toBytes(final Serializer func) throws JsonProcessingException { final ByteArrayOutputStream out = new ByteArrayOutputStream(); func.serialize(out); diff --git a/infrastructure/restapi/src/testFixtures/java/tech/pegasys/teku/infrastructure/restapi/OpenApiTestUtil.java b/infrastructure/restapi/src/testFixtures/java/tech/pegasys/teku/infrastructure/restapi/OpenApiTestUtil.java index 7eb2645211b..cbf357dfb55 100644 --- a/infrastructure/restapi/src/testFixtures/java/tech/pegasys/teku/infrastructure/restapi/OpenApiTestUtil.java +++ b/infrastructure/restapi/src/testFixtures/java/tech/pegasys/teku/infrastructure/restapi/OpenApiTestUtil.java @@ -22,6 +22,7 @@ import com.fasterxml.jackson.databind.MapperFeature; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.SerializationFeature; +import com.fasterxml.jackson.databind.json.JsonMapper; import com.google.common.collect.ImmutableList; import com.google.common.io.Resources; import java.io.IOException; @@ -44,12 +45,13 @@ public class OpenApiTestUtil { private final String path; public OpenApiTestUtil(final Class clazz) { - this.mapper = new ObjectMapper(); - mapper - .configure(SerializationFeature.INDENT_OUTPUT, true) - .configure(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS, true) - .configure(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY, true) - .configure(DeserializationFeature.FAIL_ON_READING_DUP_TREE_KEY, true); + this.mapper = + JsonMapper.builder() + .configure(SerializationFeature.INDENT_OUTPUT, true) + .configure(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS, true) + .configure(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY, true) + .configure(DeserializationFeature.FAIL_ON_READING_DUP_TREE_KEY, true) + .build(); this.clazz = clazz; this.path = clazz.getPackageName().replaceAll("\\.", "/"); } diff --git a/infrastructure/restapi/src/testFixtures/java/tech/pegasys/teku/infrastructure/restapi/StubRestApiRequest.java b/infrastructure/restapi/src/testFixtures/java/tech/pegasys/teku/infrastructure/restapi/StubRestApiRequest.java index b4512f9f487..9e40c061875 100644 --- a/infrastructure/restapi/src/testFixtures/java/tech/pegasys/teku/infrastructure/restapi/StubRestApiRequest.java +++ b/infrastructure/restapi/src/testFixtures/java/tech/pegasys/teku/infrastructure/restapi/StubRestApiRequest.java @@ -78,7 +78,7 @@ public CacheLength getCacheLength() { return cacheLength; } - public void setRequestBody(T requestBody) { + public void setRequestBody(final T requestBody) { assertThat(this.requestBody).isNull(); this.requestBody = requestBody; } @@ -223,7 +223,7 @@ public T getQueryParameter(final ParameterMetadata parameterMetadata) { } @Override - public List getQueryParameterList(ParameterMetadata parameterMetadata) { + public List getQueryParameterList(final ParameterMetadata parameterMetadata) { if (!this.listQueryParameters.containsKey(parameterMetadata.getName())) { return List.of(); } @@ -242,14 +242,14 @@ public void setRequestHeader(final String parameter, final String value) { } @Override - public Optional getOptionalRequestHeader(ParameterMetadata parameterMetadata) { + public Optional getOptionalRequestHeader(final ParameterMetadata parameterMetadata) { final Optional param = Optional.ofNullable(requestHeaders.get(parameterMetadata.getName())); return param.map(p -> parameterMetadata.getType().deserializeFromString(p)); } @Override - public T getRequestHeader(ParameterMetadata parameterMetadata) { + public T getRequestHeader(final ParameterMetadata parameterMetadata) { assertThat(this.requestHeaders.containsKey(parameterMetadata.getName())).isTrue(); final String param = requestHeaders.get(parameterMetadata.getName()); return parameterMetadata.getType().deserializeFromString(param); @@ -260,12 +260,12 @@ public void header(final String name, final String value) { responseHeaders.put(name, value); } - public String getResponseHeaders(String name) { + public String getResponseHeaders(final String name) { return responseHeaders.get(name); } @Override - public void startEventStream(Consumer clientConsumer) { + public void startEventStream(final Consumer clientConsumer) { throw new UnsupportedOperationException(); } diff --git a/infrastructure/serviceutils/src/main/java/tech/pegasys/teku/service/serviceutils/layout/DataConfig.java b/infrastructure/serviceutils/src/main/java/tech/pegasys/teku/service/serviceutils/layout/DataConfig.java index e6205489dac..b33ff46ef47 100644 --- a/infrastructure/serviceutils/src/main/java/tech/pegasys/teku/service/serviceutils/layout/DataConfig.java +++ b/infrastructure/serviceutils/src/main/java/tech/pegasys/teku/service/serviceutils/layout/DataConfig.java @@ -20,21 +20,23 @@ public class DataConfig { - public static Path defaultDataPath() { - return Path.of(VersionProvider.defaultStoragePath()); - } + public static final Path DEFAULT_DATA_PATH = Path.of(VersionProvider.defaultStoragePath()); + public static final boolean DEFAULT_DEBUG_DATA_DUMPING_ENABLED = false; private final Path dataBasePath; private final Optional beaconDataPath; private final Optional validatorDataPath; + private final boolean debugDataDumpingEnabled; private DataConfig( final Path dataBasePath, final Optional beaconDataPath, - final Optional validatorDataPath) { + final Optional validatorDataPath, + final boolean debugDataDumpingEnabled) { this.dataBasePath = dataBasePath; this.beaconDataPath = beaconDataPath; this.validatorDataPath = validatorDataPath; + this.debugDataDumpingEnabled = debugDataDumpingEnabled; } public static DataConfig.Builder builder() { @@ -53,34 +55,45 @@ public Optional getValidatorDataPath() { return validatorDataPath; } + public boolean isDebugDataDumpingEnabled() { + return debugDataDumpingEnabled; + } + public static final class Builder { - private Path dataBasePath = defaultDataPath(); + private Path dataBasePath = DEFAULT_DATA_PATH; private Optional beaconDataPath = Optional.empty(); private Optional validatorDataPath = Optional.empty(); + private boolean debugDataDumpingEnabled = DEFAULT_DEBUG_DATA_DUMPING_ENABLED; private Builder() {} - public Builder dataBasePath(Path dataBasePath) { + public Builder dataBasePath(final Path dataBasePath) { this.dataBasePath = dataBasePath; return this; } - public Builder beaconDataPath(Path beaconDataPath) { + public Builder beaconDataPath(final Path beaconDataPath) { this.beaconDataPath = Optional.ofNullable(beaconDataPath); return this; } - public Builder validatorDataPath(Path validatorDataPath) { + public Builder validatorDataPath(final Path validatorDataPath) { this.validatorDataPath = Optional.ofNullable(validatorDataPath); return this; } + public Builder debugDataDumpingEnabled(final boolean debugDataDumpingEnabled) { + this.debugDataDumpingEnabled = debugDataDumpingEnabled; + return this; + } + public DataConfig build() { if (dataBasePath == null) { throw new InvalidConfigurationException("data-base-path must be specified"); } - return new DataConfig(dataBasePath, beaconDataPath, validatorDataPath); + return new DataConfig( + dataBasePath, beaconDataPath, validatorDataPath, debugDataDumpingEnabled); } } } diff --git a/infrastructure/serviceutils/src/main/java/tech/pegasys/teku/service/serviceutils/layout/DataDirLayout.java b/infrastructure/serviceutils/src/main/java/tech/pegasys/teku/service/serviceutils/layout/DataDirLayout.java index 2ea3e24299f..3f055f083fe 100644 --- a/infrastructure/serviceutils/src/main/java/tech/pegasys/teku/service/serviceutils/layout/DataDirLayout.java +++ b/infrastructure/serviceutils/src/main/java/tech/pegasys/teku/service/serviceutils/layout/DataDirLayout.java @@ -17,16 +17,18 @@ public interface DataDirLayout { static DataDirLayout createFrom(final DataConfig dataConfig) { - final SeparateServiceDataDirLayout layout = - new SeparateServiceDataDirLayout( - dataConfig.getDataBasePath(), - dataConfig.getBeaconDataPath(), - dataConfig.getValidatorDataPath()); - - return layout; + return new SeparateServiceDataDirLayout( + dataConfig.getDataBasePath(), + dataConfig.getBeaconDataPath(), + dataConfig.getValidatorDataPath(), + dataConfig.isDebugDataDumpingEnabled()); } Path getBeaconDataDirectory(); Path getValidatorDataDirectory(); + + Path getDebugDataDirectory(); + + boolean isDebugDataDumpingEnabled(); } diff --git a/infrastructure/serviceutils/src/main/java/tech/pegasys/teku/service/serviceutils/layout/SeparateServiceDataDirLayout.java b/infrastructure/serviceutils/src/main/java/tech/pegasys/teku/service/serviceutils/layout/SeparateServiceDataDirLayout.java index 602b6b8d3ef..62d066cf2ff 100644 --- a/infrastructure/serviceutils/src/main/java/tech/pegasys/teku/service/serviceutils/layout/SeparateServiceDataDirLayout.java +++ b/infrastructure/serviceutils/src/main/java/tech/pegasys/teku/service/serviceutils/layout/SeparateServiceDataDirLayout.java @@ -19,16 +19,22 @@ public class SeparateServiceDataDirLayout implements DataDirLayout { static final String BEACON_DATA_DIR_NAME = "beacon"; static final String VALIDATOR_DATA_DIR_NAME = "validator"; + static final String DEBUG_DIR_NAME = "debug"; private final Path beaconNodeDataDir; private final Path validatorDataDir; + private final Path debugDataDir; + private final boolean debugDataDumpingEnabled; public SeparateServiceDataDirLayout( final Path baseDir, final Optional beaconDataDirectory, - final Optional validatorDataDirectory) { + final Optional validatorDataDirectory, + final boolean debugDataDumpingEnabled) { beaconNodeDataDir = beaconDataDirectory.orElseGet(() -> baseDir.resolve(BEACON_DATA_DIR_NAME)); validatorDataDir = validatorDataDirectory.orElseGet(() -> baseDir.resolve(VALIDATOR_DATA_DIR_NAME)); + debugDataDir = baseDir.resolve(DEBUG_DIR_NAME); + this.debugDataDumpingEnabled = debugDataDumpingEnabled; } @Override @@ -40,4 +46,14 @@ public Path getBeaconDataDirectory() { public Path getValidatorDataDirectory() { return validatorDataDir; } + + @Override + public Path getDebugDataDirectory() { + return debugDataDir; + } + + @Override + public boolean isDebugDataDumpingEnabled() { + return debugDataDumpingEnabled; + } } diff --git a/infrastructure/serviceutils/src/test/java/tech/pegasys/teku/service/serviceutils/layout/SeparateServiceDataDirLayoutTest.java b/infrastructure/serviceutils/src/test/java/tech/pegasys/teku/service/serviceutils/layout/SeparateServiceDataDirLayoutTest.java index a0f1e492678..99969785084 100644 --- a/infrastructure/serviceutils/src/test/java/tech/pegasys/teku/service/serviceutils/layout/SeparateServiceDataDirLayoutTest.java +++ b/infrastructure/serviceutils/src/test/java/tech/pegasys/teku/service/serviceutils/layout/SeparateServiceDataDirLayoutTest.java @@ -30,7 +30,7 @@ class SeparateServiceDataDirLayoutTest { @BeforeEach void setUp() { - layout = new SeparateServiceDataDirLayout(tempDir, Optional.empty(), Optional.empty()); + layout = new SeparateServiceDataDirLayout(tempDir, Optional.empty(), Optional.empty(), false); } @Test diff --git a/infrastructure/serviceutils/src/testFixtures/java/tech/pegasys/techu/service/serviceutils/layout/SimpleDataDirLayout.java b/infrastructure/serviceutils/src/testFixtures/java/tech/pegasys/techu/service/serviceutils/layout/SimpleDataDirLayout.java index 74a087be1e6..84b79c4d830 100644 --- a/infrastructure/serviceutils/src/testFixtures/java/tech/pegasys/techu/service/serviceutils/layout/SimpleDataDirLayout.java +++ b/infrastructure/serviceutils/src/testFixtures/java/tech/pegasys/techu/service/serviceutils/layout/SimpleDataDirLayout.java @@ -32,4 +32,14 @@ public Path getBeaconDataDirectory() { public Path getValidatorDataDirectory() { return path; } + + @Override + public Path getDebugDataDirectory() { + return path; + } + + @Override + public boolean isDebugDataDumpingEnabled() { + return false; + } } diff --git a/infrastructure/ssz/build.gradle b/infrastructure/ssz/build.gradle index 856f5dc971e..c48f6db72a6 100644 --- a/infrastructure/ssz/build.gradle +++ b/infrastructure/ssz/build.gradle @@ -8,13 +8,13 @@ dependencies { implementation 'it.unimi.dsi:fastutil' implementation 'org.apache.commons:commons-lang3' - implementation 'org.apache.tuweni:tuweni-units' + implementation 'io.tmio:tuweni-units' testImplementation testFixtures(project(':infrastructure:collections')) testImplementation testFixtures(project(':infrastructure:serviceutils')) - testFixturesApi 'org.apache.tuweni:tuweni-bytes' - testFixturesApi 'org.apache.tuweni:tuweni-units' + testFixturesApi 'io.tmio:tuweni-bytes' + testFixturesApi 'io.tmio:tuweni-units' testFixturesApi project(':infrastructure:unsigned') testFixturesImplementation project(':infrastructure:bytes') testFixturesImplementation 'it.unimi.dsi:fastutil' diff --git a/infrastructure/ssz/generator/build.gradle b/infrastructure/ssz/generator/build.gradle index 5cf5f4435d3..5503820a404 100644 --- a/infrastructure/ssz/generator/build.gradle +++ b/infrastructure/ssz/generator/build.gradle @@ -1,8 +1,5 @@ dependencies { - // for some reasons, if gradle 8.4 builds using java 21, build fails if we specify - // implementation project(':infrastructure:bytes') - // so we use the following instead - implementation 'org.apache.tuweni:tuweni-bytes' + compileOnly 'io.tmio:tuweni-bytes' implementation project(':infrastructure:ssz') } diff --git a/infrastructure/ssz/generator/src/main/java/tech/pegasys/teku/infrastructure/ssz/ContainersGenerator.java b/infrastructure/ssz/generator/src/main/java/tech/pegasys/teku/infrastructure/ssz/ContainersGenerator.java index 5a53fbf060b..05e8405ba75 100644 --- a/infrastructure/ssz/generator/src/main/java/tech/pegasys/teku/infrastructure/ssz/ContainersGenerator.java +++ b/infrastructure/ssz/generator/src/main/java/tech/pegasys/teku/infrastructure/ssz/ContainersGenerator.java @@ -23,7 +23,7 @@ public class ContainersGenerator { - private final int maxFields = 19; + private final int maxFields = 20; private final Path templateSrcPath; private final Path targetSrcPath; private final String typePackagePath = "tech/pegasys/teku/infrastructure/ssz/containers/"; @@ -31,7 +31,7 @@ public class ContainersGenerator { private final String containerTypeTemplateFile = "ContainerSchemaTemplate.java"; private final String containerViewTemplateFile = "ContainerTemplate.java"; - public ContainersGenerator(Path templateSourcePath, Path destinationSourcePath) { + public ContainersGenerator(final Path templateSourcePath, final Path destinationSourcePath) { templateSrcPath = templateSourcePath; targetSrcPath = destinationSourcePath; } @@ -40,7 +40,7 @@ public ContainersGenerator(Path templateSourcePath, Path destinationSourcePath) * Available generation from Gradle with {@code * :infrastructure:ssz:generator:generateAndFormatContainers} task */ - public static void main(String[] args) { + public static void main(final String[] args) { final Path templateSourcePath; final Path targetSourcePath; if (args.length < 1) { @@ -70,7 +70,7 @@ public void generateAll() { } } - public void generateContainerClasses(int fieldsCount) { + public void generateContainerClasses(final int fieldsCount) { String typeClassName = "ContainerSchema" + fieldsCount; String viewClassName = "Container" + fieldsCount; Map vars = @@ -90,12 +90,12 @@ public void generateContainerClasses(int fieldsCount) { Map.entry( "FieldsDeclarations", IntStream.range(0, fieldsCount) - .mapToObj(i -> "SszSchema fieldSchema" + i) + .mapToObj(i -> "final SszSchema fieldSchema" + i) .collect(Collectors.joining(", "))), Map.entry( "NamedFieldsDeclarations", IntStream.range(0, fieldsCount) - .mapToObj(i -> "NamedSchema fieldNamedSchema" + i) + .mapToObj(i -> "final NamedSchema fieldNamedSchema" + i) .collect(Collectors.joining(", "))), Map.entry( "Fields", @@ -110,7 +110,7 @@ public void generateContainerClasses(int fieldsCount) { Map.entry( "ViewParams", IntStream.range(0, fieldsCount) - .mapToObj(i -> "V" + i + " arg" + i) + .mapToObj(i -> "final V" + i + " arg" + i) .collect(Collectors.joining(", "))), Map.entry( "ViewArgs", @@ -150,7 +150,8 @@ public void generateContainerClasses(int fieldsCount) { vars); } - public void generateFromTemplate(Path templateSrc, Path destSrc, Map varToVal) { + public void generateFromTemplate( + final Path templateSrc, final Path destSrc, final Map varToVal) { try { String src = Files.readString(templateSrc); String res = replacePlaceholders(src, varToVal); @@ -161,7 +162,7 @@ public void generateFromTemplate(Path templateSrc, Path destSrc, Map varToVal) { + public String replacePlaceholders(final String src, final Map varToVal) { String res = src; for (Map.Entry entry : varToVal.entrySet()) { res = diff --git a/infrastructure/ssz/generator/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchemaTemplate.java b/infrastructure/ssz/generator/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchemaTemplate.java index 2a632852706..1ca40334eec 100644 --- a/infrastructure/ssz/generator/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchemaTemplate.java +++ b/infrastructure/ssz/generator/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchemaTemplate.java @@ -31,9 +31,9 @@ public abstract class /*$$TypeClassName*/ ContainerSchemaTemplate /*$$*/< /*$$TypeClassName*/ ContainerSchemaTemplate /*$$*/ create( /*$$FieldsDeclarations*/ - SszSchema fieldSchema1, - SszSchema fieldSchema2 /*$$*/, - BiFunction< + final SszSchema fieldSchema1, + final SszSchema fieldSchema2 /*$$*/, + final BiFunction< /*$$TypeClassName*/ ContainerSchemaTemplate /*$$*/< C, /*$$ViewTypeNames*/ V0, V1 /*$$*/>, TreeNode, @@ -42,22 +42,23 @@ public abstract class /*$$TypeClassName*/ ContainerSchemaTemplate /*$$*/< return new /*$$TypeClassName*/ ContainerSchemaTemplate /*$$*/<>( /*$$Fields*/ fieldSchema1, fieldSchema2 /*$$*/) { @Override - public C createFromBackingNode(TreeNode node) { + public C createFromBackingNode(final TreeNode node) { return instanceCtor.apply(this, node); } }; } protected /*$$TypeClassName*/ ContainerSchemaTemplate /*$$*/( - /*$$FieldsDeclarations*/ SszSchema fieldSchema1, SszSchema fieldSchema2 /*$$*/) { + /*$$FieldsDeclarations*/ final SszSchema fieldSchema1, + final SszSchema fieldSchema2 /*$$*/) { super(List.of(/*$$Fields*/ fieldSchema1, fieldSchema2 /*$$*/)); } protected /*$$TypeClassName*/ ContainerSchemaTemplate /*$$*/( - String containerName, - /*$$NamedFieldsDeclarations*/ NamedSchema fieldNamedSchema0, - NamedSchema fieldNamedSchema1 /*$$*/) { + final String containerName, + /*$$NamedFieldsDeclarations*/ final NamedSchema fieldNamedSchema0, + final NamedSchema fieldNamedSchema1 /*$$*/) { super(containerName, List.of(/*$$NamedFields*/ fieldNamedSchema0, fieldNamedSchema1 /*$$*/)); } diff --git a/infrastructure/ssz/generator/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerTemplate.java b/infrastructure/ssz/generator/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerTemplate.java index 7c313d3217a..0ed47bbde9d 100644 --- a/infrastructure/ssz/generator/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerTemplate.java +++ b/infrastructure/ssz/generator/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerTemplate.java @@ -26,23 +26,23 @@ public class /*$$ViewClassName*/ ContainerTemplate /*$$*/< extends AbstractSszImmutableContainer { protected /*$$ViewClassName*/ ContainerTemplate /*$$*/( - /*$$TypeClassName*/ ContainerSchemaTemplate /*$$*/ + final /*$$TypeClassName*/ ContainerSchemaTemplate /*$$*/ schema) { super(schema); } protected /*$$ViewClassName*/ ContainerTemplate /*$$*/( - /*$$TypeClassName*/ ContainerSchemaTemplate /*$$*/ + final /*$$TypeClassName*/ ContainerSchemaTemplate /*$$*/ schema, - TreeNode backingNode) { + final TreeNode backingNode) { super(schema, backingNode); } protected /*$$ViewClassName*/ ContainerTemplate /*$$*/( - /*$$TypeClassName*/ ContainerSchemaTemplate /*$$*/ + final /*$$TypeClassName*/ ContainerSchemaTemplate /*$$*/ schema, /*$$ViewParams*/ - V0 arg1, - V1 arg2 /*$$*/) { + final V0 arg1, + final V1 arg2 /*$$*/) { super(schema, /*$$ViewArgs*/ arg1, arg2 /*$$*/); } diff --git a/infrastructure/ssz/generator/src/test/java/tech/pegasys/teku/ssz/infrastructure/containers/GeneratedClassesNotModifiedTest.java b/infrastructure/ssz/generator/src/test/java/tech/pegasys/teku/ssz/infrastructure/containers/GeneratedClassesNotModifiedTest.java index e8f794479d8..da1c9145976 100644 --- a/infrastructure/ssz/generator/src/test/java/tech/pegasys/teku/ssz/infrastructure/containers/GeneratedClassesNotModifiedTest.java +++ b/infrastructure/ssz/generator/src/test/java/tech/pegasys/teku/ssz/infrastructure/containers/GeneratedClassesNotModifiedTest.java @@ -47,7 +47,7 @@ public class GeneratedClassesNotModifiedTest { */ @Test @EnabledIfSystemProperty(named = PROJECT_PROPERTY_NAME, matches = ".*") - void checkGeneratesSszClassesWasNotModified(@TempDir Path tmpDir) throws IOException { + void checkGeneratesSszClassesWasNotModified(@TempDir final Path tmpDir) throws IOException { Path sszProjectSource = Path.of(System.getProperty(PROJECT_PROPERTY_NAME)); Path committedSrcRoot = sszProjectSource.resolve(Path.of("src", "main", "java")); Path templatesSrcRoot = sszProjectSource.resolve(Path.of("generator", "src", "main", "java")); @@ -70,7 +70,7 @@ void checkGeneratesSszClassesWasNotModified(@TempDir Path tmpDir) throws IOExcep } } - private void compareJavaSrc(String committedSrc, String generatedSrc) { + private void compareJavaSrc(final String committedSrc, final String generatedSrc) { String canonicalCommittedSrc = comparableSrc(committedSrc); String canonicalGeneratedSrc = comparableSrc(generatedSrc); if (!canonicalCommittedSrc.equals(canonicalGeneratedSrc)) { @@ -83,15 +83,15 @@ private void compareJavaSrc(String committedSrc, String generatedSrc) { } } - private String comparableSrc(String src) { + private String comparableSrc(final String src) { return removeSpaces(removeComments(src)); } - private String removeSpaces(String src) { + private String removeSpaces(final String src) { return SPACES_PATTERN.matcher(src).replaceAll(""); } - private String removeComments(String src) { + private String removeComments(final String src) { String s1 = MULTILINE_LINE_COMMENT_PATTERN.matcher(src).replaceAll(""); return ONE_LINE_COMMENT_PATTERN.matcher(s1).replaceAll(""); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/InvalidValueSchemaException.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/InvalidValueSchemaException.java index 06848115f96..c5442601a1a 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/InvalidValueSchemaException.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/InvalidValueSchemaException.java @@ -15,7 +15,7 @@ public class InvalidValueSchemaException extends RuntimeException { - public InvalidValueSchemaException(String message) { + public InvalidValueSchemaException(final String message) { super(message); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszContainer.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszContainer.java index 0f53b235f33..39d8b6e091c 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszContainer.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszContainer.java @@ -27,7 +27,7 @@ public interface SszContainer extends SszComposite { @SuppressWarnings({"unchecked", "TypeParameterUnusedInFormals"}) // container is heterogeneous by its nature so making unsafe cast here // is more convenient and is not less safe - default C getAny(int index) { + default C getAny(final int index) { return (C) get(index); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszData.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszData.java index 4eab82f56cd..90178d3534e 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszData.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszData.java @@ -59,12 +59,12 @@ default Bytes sszSerialize() { } @Override - default int sszSerialize(SszWriter writer) { + default int sszSerialize(final SszWriter writer) { return getSchema().sszSerializeTree(getBackingNode(), writer); } @Override - default int sszSerialize(OutputStream out) { + default int sszSerialize(final OutputStream out) { return sszSerialize(new SszOutputStreamWriter(out)); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszMutableCollection.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszMutableCollection.java index 3c7dafe5c98..136cd4466fc 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszMutableCollection.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszMutableCollection.java @@ -25,7 +25,7 @@ public interface SszMutableCollection * @param startIndex The first index in the range to be modified (inclusive) * @param endIndex The last index in the range to be modified (exclusive) */ - default void setAll(SszElementT value, int startIndex, int endIndex) { + default void setAll(final SszElementT value, final int startIndex, final int endIndex) { checkArgument( startIndex <= endIndex, "Start index must be less than or equal to the end index"); for (int i = startIndex; i < endIndex; i++) { @@ -39,7 +39,7 @@ default void setAll(SszElementT value, int startIndex, int endIndex) { * @param value The value to set * @param endIndex The index defining the end of the range to set (exclusive) */ - default void setAll(SszElementT value, int endIndex) { + default void setAll(final SszElementT value, final int endIndex) { setAll(value, 0, endIndex); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszMutableComposite.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszMutableComposite.java index 4b6175c5268..9b88bebeec3 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszMutableComposite.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszMutableComposite.java @@ -50,11 +50,11 @@ public interface SszMutableComposite * Similar to {@link #set(int, SszData)} but using modifier function which may consider old value * to calculate new value. The implementation may potentially optimize this case. */ - default void update(int index, Function mutator) { + default void update(final int index, final Function mutator) { set(index, mutator.apply(get(index))); } - default void setAll(Iterable newChildren) { + default void setAll(final Iterable newChildren) { clear(); int idx = 0; for (SszChildT newChild : newChildren) { diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszMutableList.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszMutableList.java index f40f1356432..08d4f1f1276 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszMutableList.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszMutableList.java @@ -33,11 +33,11 @@ public interface SszMutableList * * @throws IndexOutOfBoundsException if size would exceed maxLength */ - default void append(SszElementT value) { + default void append(final SszElementT value) { set(size(), value); } - default void appendAll(Iterable elements) { + default void appendAll(final Iterable elements) { elements.forEach(this::append); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszMutableRefContainer.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszMutableRefContainer.java index 1a8b421f716..eb48e0fa8d8 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszMutableRefContainer.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszMutableRefContainer.java @@ -22,7 +22,7 @@ public interface SszMutableRefContainer @SuppressWarnings({"unchecked", "TypeParameterUnusedInFormals"}) // container is heterogeneous by its nature so making unsafe cast here // is more convenient and is not less safe - default W getAnyByRef(int index) { + default W getAnyByRef(final int index) { return (W) getByRef(index); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszMutableRefList.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszMutableRefList.java index 7cb2112008c..b876ab2d9e8 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszMutableRefList.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszMutableRefList.java @@ -45,7 +45,7 @@ default SszMutableElementT append() { } /** Just a functional style helper for {@link #append()} */ - default void append(Consumer mutator) { + default void append(final Consumer mutator) { mutator.accept(append()); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszMutableVector.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszMutableVector.java index 79f4b1a805b..c99255dbfda 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszMutableVector.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszMutableVector.java @@ -27,7 +27,7 @@ public interface SszMutableVector * * @param value The value to set */ - default void setAll(ElementType value) { + default void setAll(final ElementType value) { setAll(value, 0, size()); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszPrimitive.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszPrimitive.java index cbb0d550f5e..49c8a6dc6db 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszPrimitive.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/SszPrimitive.java @@ -18,8 +18,7 @@ /** * A wrapper class for SSZ primitive values. {@link SszPrimitive} classes has no mutable versions */ -public interface SszPrimitive> - extends SszData { +public interface SszPrimitive extends SszData { /** Returns wrapped primitive value */ ValueType get(); @@ -36,5 +35,5 @@ default boolean isWritableSupported() { } @Override - SszPrimitiveSchema getSchema(); + SszPrimitiveSchema getSchema(); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/cache/ArrayIntCache.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/cache/ArrayIntCache.java index 6d8e711c7a0..f31cf582ff9 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/cache/ArrayIntCache.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/cache/ArrayIntCache.java @@ -35,22 +35,22 @@ public ArrayIntCache() { this(DEFAULT_INITIAL_CACHE_SIZE); } - public ArrayIntCache(int initialSize) { + public ArrayIntCache(final int initialSize) { this.initSize = initialSize; this.values = createArray(initialSize); } - private ArrayIntCache(V[] values, int initSize) { + private ArrayIntCache(final V[] values, final int initSize) { this.values = values; this.initSize = initSize; } @SuppressWarnings("unchecked") - private V[] createArray(int size) { + private V[] createArray(final int size) { return (V[]) new Object[size]; } - private V[] extend(int index) { + private V[] extend(final int index) { V[] valuesLocal = this.values; int newSize = valuesLocal.length; if (index >= newSize) { @@ -65,7 +65,7 @@ private V[] extend(int index) { } @Override - public V getInt(int key, IntFunction fallback) { + public V getInt(final int key, final IntFunction fallback) { V[] valuesLocal = this.values; V val = key >= valuesLocal.length ? null : valuesLocal[key]; if (val == null) { @@ -76,7 +76,7 @@ public V getInt(int key, IntFunction fallback) { } @Override - public Optional getCached(Integer key) { + public Optional getCached(final Integer key) { V[] valuesLocal = this.values; return key >= valuesLocal.length ? Optional.empty() : Optional.ofNullable(valuesLocal[key]); } @@ -95,12 +95,12 @@ public IntCache transfer() { } @Override - public void invalidateWithNewValueInt(int key, V newValue) { + public void invalidateWithNewValueInt(final int key, final V newValue) { extend(key)[key] = newValue; } @Override - public void invalidateInt(int key) { + public void invalidateInt(final int key) { V[] valuesLocal = this.values; if (key < valuesLocal.length) { valuesLocal[key] = null; diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/cache/Cache.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/cache/Cache.java index d091ace55c5..612d7d703de 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/cache/Cache.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/cache/Cache.java @@ -50,7 +50,7 @@ default Cache transfer() { void invalidate(K key); /** Replace cached entry with a new value * */ - default void invalidateWithNewValue(K key, V newValue) { + default void invalidateWithNewValue(final K key, final V newValue) { invalidate(key); get(key, k -> newValue); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/cache/IntCache.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/cache/IntCache.java index c22f519e0b7..0e38685acfb 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/cache/IntCache.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/cache/IntCache.java @@ -39,7 +39,7 @@ static IntCache noop() { V getInt(int key, IntFunction fallback); @Override - default V get(Integer key, Function fallback) { + default V get(final Integer key, final Function fallback) { return getInt(key, value -> fallback.apply(key)); } @@ -55,17 +55,17 @@ default IntCache transfer() { void invalidateInt(int key); @Override - default void invalidate(Integer key) { + default void invalidate(final Integer key) { invalidateInt(key); } - default void invalidateWithNewValueInt(int key, V newValue) { + default void invalidateWithNewValueInt(final int key, final V newValue) { invalidateInt(key); getInt(key, k -> newValue); } @Override - default void invalidateWithNewValue(Integer key, V newValue) { + default void invalidateWithNewValue(final Integer key, final V newValue) { invalidateWithNewValueInt(key, newValue); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/cache/NoopIntCache.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/cache/NoopIntCache.java index 0fdb8ff0e0e..484e80158a5 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/cache/NoopIntCache.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/cache/NoopIntCache.java @@ -23,7 +23,7 @@ public class NoopIntCache implements IntCache { private NoopIntCache() {} @Override - public V getInt(int key, IntFunction fallback) { + public V getInt(final int key, final IntFunction fallback) { return fallback.apply(key); } @@ -33,13 +33,13 @@ public IntCache copy() { } @Override - public void invalidateInt(int key) {} + public void invalidateInt(final int key) {} @Override public void clear() {} @Override - public Optional getCached(Integer key) { + public Optional getCached(final Integer key) { return Optional.empty(); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/cache/SoftRefIntCache.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/cache/SoftRefIntCache.java index fecf3b20827..15e3bc8a99d 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/cache/SoftRefIntCache.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/cache/SoftRefIntCache.java @@ -30,12 +30,13 @@ public class SoftRefIntCache implements IntCache { private final Supplier> cacheCtor; private volatile SoftReference> delegate; - private SoftRefIntCache(IntCache initialDelegate, Supplier> cacheCtor) { + private SoftRefIntCache( + final IntCache initialDelegate, final Supplier> cacheCtor) { this.cacheCtor = cacheCtor; delegate = new SoftReference<>(initialDelegate); } - public SoftRefIntCache(Supplier> cacheCtor) { + public SoftRefIntCache(final Supplier> cacheCtor) { this(cacheCtor.get(), cacheCtor); } @@ -49,12 +50,12 @@ public IntCache getDelegate() { } @Override - public V getInt(int key, IntFunction fallback) { + public V getInt(final int key, final IntFunction fallback) { return getDelegate().getInt(key, fallback); } @Override - public V get(Integer key, Function fallback) { + public V get(final Integer key, final Function fallback) { return getDelegate().get(key, fallback); } @@ -69,22 +70,22 @@ public IntCache transfer() { } @Override - public void invalidateInt(int key) { + public void invalidateInt(final int key) { getDelegate().invalidateInt(key); } @Override - public void invalidate(Integer key) { + public void invalidate(final Integer key) { getDelegate().invalidate(key); } @Override - public void invalidateWithNewValueInt(int key, V newValue) { + public void invalidateWithNewValueInt(final int key, final V newValue) { getDelegate().invalidateWithNewValueInt(key, newValue); } @Override - public void invalidateWithNewValue(Integer key, V newValue) { + public void invalidateWithNewValue(final Integer key, final V newValue) { getDelegate().invalidateWithNewValue(key, newValue); } @@ -94,7 +95,7 @@ public void clear() { } @Override - public Optional getCached(Integer key) { + public Optional getCached(final Integer key) { return getDelegate().getCached(key); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszBitlist.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszBitlist.java index 02464cb7083..01bbd6336f6 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszBitlist.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszBitlist.java @@ -24,7 +24,7 @@ public interface SszBitlist extends SszPrimitiveList, SszBitSet { static SszBitlist nullableOr( - @Nullable SszBitlist bitlist1OrNull, @Nullable SszBitlist bitlist2OrNull) { + final @Nullable SszBitlist bitlist1OrNull, final @Nullable SszBitlist bitlist2OrNull) { return SszBitlistImpl.nullableOr(bitlist1OrNull, bitlist2OrNull); } @@ -81,7 +81,7 @@ default boolean isSet(final int i) { IntStream streamAllSetBits(); @Override - default Boolean getElement(int index) { + default Boolean getElement(final int index) { return getBit(index); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszBitvector.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszBitvector.java index 856ee8bfcfe..a2e2dbae237 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszBitvector.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszBitvector.java @@ -38,6 +38,10 @@ default boolean isWritableSupported() { SszBitvector withBit(int i); + SszBitvector or(SszBitvector other); + + SszBitvector and(SszBitvector other); + /** Returns individual bit value */ boolean getBit(int i); @@ -55,12 +59,15 @@ default boolean isSet(final int i) { /** Returns indices of all bits set in this {@link SszBitvector} */ IntList getAllSetBits(); + /** Returns last bit set index, -1 if no bits are set * */ + int getLastSetBitIndex(); + /** Streams indices of all bits set in this {@link SszBitvector} */ @Override IntStream streamAllSetBits(); @Override - default Boolean getElement(int index) { + default Boolean getElement(final int index) { return getBit(index); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszByteVector.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszByteVector.java index 2b663fd6ae1..d2446a0f7fe 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszByteVector.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszByteVector.java @@ -20,11 +20,11 @@ public interface SszByteVector extends SszPrimitiveVector { - static SszByteVector fromBytes(Bytes byteVector) { + static SszByteVector fromBytes(final Bytes byteVector) { return SszByteVectorSchema.create(byteVector.size()).fromBytes(byteVector); } - static Bytes32 computeHashTreeRoot(Bytes byteVector) { + static Bytes32 computeHashTreeRoot(final Bytes byteVector) { return fromBytes(byteVector).hashTreeRoot(); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszMutablePrimitiveCollection.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszMutablePrimitiveCollection.java index 8ce79742609..2dec2b082b8 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszMutablePrimitiveCollection.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszMutablePrimitiveCollection.java @@ -17,8 +17,7 @@ import tech.pegasys.teku.infrastructure.ssz.SszPrimitive; import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchema; -public interface SszMutablePrimitiveCollection< - ElementT, SszElementT extends SszPrimitive> +public interface SszMutablePrimitiveCollection> extends SszPrimitiveCollection, SszMutableComposite { @SuppressWarnings("unchecked") @@ -26,12 +25,12 @@ default SszPrimitiveSchema getPrimitiveElementSchema() { return (SszPrimitiveSchema) getSchema().getElementSchema(); } - default void setElement(int index, ElementT primitiveValue) { + default void setElement(final int index, final ElementT primitiveValue) { SszElementT sszData = getPrimitiveElementSchema().boxed(primitiveValue); set(index, sszData); } - default void setAllElements(Iterable newChildren) { + default void setAllElements(final Iterable newChildren) { clear(); int idx = 0; for (ElementT newChild : newChildren) { diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszMutablePrimitiveList.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszMutablePrimitiveList.java index 6232f840f8e..0552644182c 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszMutablePrimitiveList.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszMutablePrimitiveList.java @@ -16,17 +16,16 @@ import tech.pegasys.teku.infrastructure.ssz.SszMutableList; import tech.pegasys.teku.infrastructure.ssz.SszPrimitive; -public interface SszMutablePrimitiveList< - ElementT, SszElementT extends SszPrimitive> +public interface SszMutablePrimitiveList> extends SszMutablePrimitiveCollection, SszMutableList, SszPrimitiveList { - default void appendElement(ElementT newElement) { + default void appendElement(final ElementT newElement) { append(getPrimitiveElementSchema().boxed(newElement)); } - default void appendAllElements(Iterable newElements) { + default void appendAllElements(final Iterable newElements) { newElements.forEach(this::appendElement); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszMutablePrimitiveVector.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszMutablePrimitiveVector.java index b35497fefe2..931b72fe1ed 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszMutablePrimitiveVector.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszMutablePrimitiveVector.java @@ -16,8 +16,7 @@ import tech.pegasys.teku.infrastructure.ssz.SszMutableVector; import tech.pegasys.teku.infrastructure.ssz.SszPrimitive; -public interface SszMutablePrimitiveVector< - ElementT, SszElementT extends SszPrimitive> +public interface SszMutablePrimitiveVector> extends SszMutablePrimitiveCollection, SszMutableVector, SszPrimitiveVector { diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszPrimitiveCollection.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszPrimitiveCollection.java index ffddaa0078f..c78e3c8d04c 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszPrimitiveCollection.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszPrimitiveCollection.java @@ -20,11 +20,10 @@ import tech.pegasys.teku.infrastructure.ssz.SszPrimitive; import tech.pegasys.teku.infrastructure.ssz.schema.SszCollectionSchema; -public interface SszPrimitiveCollection< - ElementT, SszElementT extends SszPrimitive> +public interface SszPrimitiveCollection> extends SszCollection { - default ElementT getElement(int index) { + default ElementT getElement(final int index) { return get(index).get(); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszPrimitiveList.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszPrimitiveList.java index 74befbf4071..63860171715 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszPrimitiveList.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszPrimitiveList.java @@ -16,7 +16,7 @@ import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.ssz.SszPrimitive; -public interface SszPrimitiveList> +public interface SszPrimitiveList> extends SszPrimitiveCollection, SszList { @Override diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszPrimitiveVector.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszPrimitiveVector.java index 2ccbf7bcec0..5b19557bb56 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszPrimitiveVector.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/SszPrimitiveVector.java @@ -16,8 +16,7 @@ import tech.pegasys.teku.infrastructure.ssz.SszPrimitive; import tech.pegasys.teku.infrastructure.ssz.SszVector; -public interface SszPrimitiveVector< - ElementT, SszElementT extends SszPrimitive> +public interface SszPrimitiveVector> extends SszPrimitiveCollection, SszVector { @Override diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/AbstractSszMutablePrimitiveCollection.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/AbstractSszMutablePrimitiveCollection.java index 430559acd56..dc8635e8fc7 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/AbstractSszMutablePrimitiveCollection.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/AbstractSszMutablePrimitiveCollection.java @@ -34,7 +34,7 @@ import tech.pegasys.teku.infrastructure.ssz.tree.TreeUpdates; public abstract class AbstractSszMutablePrimitiveCollection< - ElementT, SszElementT extends SszPrimitive> + ElementT, SszElementT extends SszPrimitive> extends AbstractSszMutableCollection implements SszMutablePrimitiveCollection { @@ -42,7 +42,7 @@ public abstract class AbstractSszMutablePrimitiveCollection< @SuppressWarnings("unchecked") protected AbstractSszMutablePrimitiveCollection( - AbstractSszComposite backingImmutableData) { + final AbstractSszComposite backingImmutableData) { super(backingImmutableData); elementSchemaCache = (SszPrimitiveSchema) getSchema().getElementSchema(); } @@ -53,7 +53,7 @@ public SszPrimitiveSchema getPrimitiveElementSchema() { } @Override - protected void validateChildSchema(int index, SszElementT value) { + protected void validateChildSchema(final int index, final SszElementT value) { // no need to check primitive value schema } @@ -63,7 +63,7 @@ protected void validateChildSchema(int index, SszElementT value) { */ @Override protected TreeUpdates changesToNewNodes( - Stream> newChildValues, TreeNode original) { + final Stream> newChildValues, final TreeNode original) { SszCollectionSchema type = getSchema(); int elementsPerChunk = type.getElementsPerChunk(); @@ -116,17 +116,16 @@ public SszMutablePrimitiveCollection createWritableCopy() throw new UnsupportedOperationException(); } - private static class NodeUpdate< - ElementT, SszElementT extends SszPrimitive> { + private static class NodeUpdate> { private final List> updates; private final long nodeGIndex; - public NodeUpdate(long nodeGIndex, int maxElementsPerChunk) { + public NodeUpdate(final long nodeGIndex, final int maxElementsPerChunk) { this.updates = new ArrayList<>(maxElementsPerChunk); this.nodeGIndex = nodeGIndex; } - public void addUpdate(int internalNodeIndex, SszElementT newValue) { + public void addUpdate(final int internalNodeIndex, final SszElementT newValue) { updates.add(new PackedNodeUpdate<>(internalNodeIndex, newValue)); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/BitlistImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/BitlistImpl.java index 427cb88c228..289fad8436e 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/BitlistImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/BitlistImpl.java @@ -29,7 +29,7 @@ public static int sszSerializationLength(final int size) { return (size / 8) + 1; } - public static BitlistImpl fromSszBytes(Bytes bytes, long maxSize) { + public static BitlistImpl fromSszBytes(final Bytes bytes, final long maxSize) { int bitlistSize = SszBitlistImpl.sszGetLengthAndValidate(bytes); BitSet bitSet = BitSet.valueOf(bytes.toArrayUnsafe()).get(0, bitlistSize); return new BitlistImpl(bitlistSize, bitSet, maxSize); @@ -39,7 +39,7 @@ public static BitlistImpl fromSszBytes(Bytes bytes, long maxSize) { private final int size; private final long maxSize; - public BitlistImpl(int size, long maxSize, int... bitIndices) { + public BitlistImpl(final int size, final long maxSize, final int... bitIndices) { checkArgument(size >= 0, "Negative size"); checkArgument(maxSize >= size, "maxSize should be >= size"); this.size = size; @@ -51,7 +51,15 @@ public BitlistImpl(int size, long maxSize, int... bitIndices) { } } - private BitlistImpl(int size, BitSet data, long maxSize) { + public BitlistImpl(final int size, final long maxSize, final BitSet bitSet) { + checkArgument(size >= 0, "Negative size"); + checkArgument(maxSize >= size, "maxSize should be >= size"); + this.size = size; + this.data = bitSet; + this.maxSize = maxSize; + } + + private BitlistImpl(final int size, final BitSet data, final long maxSize) { this.size = size; this.data = data; this.maxSize = maxSize; @@ -63,7 +71,7 @@ private BitlistImpl(int size, BitSet data, long maxSize) { * @throws IllegalArgumentException if the size of the other BitlistImpl is greater than the size * of this BitlistImpl */ - public BitlistImpl or(BitlistImpl other) { + public BitlistImpl or(final BitlistImpl other) { if (other.getCurrentSize() > getCurrentSize()) { throw new IllegalArgumentException( "Argument bitfield size is greater: " @@ -76,7 +84,7 @@ public BitlistImpl or(BitlistImpl other) { return new BitlistImpl(size, newData, maxSize); } - public boolean getBit(int i) { + public boolean getBit(final int i) { checkElementIndex(i, size); return data.get(i); } @@ -85,7 +93,7 @@ public int getBitCount() { return data.cardinality(); } - public boolean intersects(BitlistImpl other) { + public boolean intersects(final BitlistImpl other) { return data.intersects(other.data); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/BitvectorImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/BitvectorImpl.java index f07e784cc9e..3ef294ac532 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/BitvectorImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/BitvectorImpl.java @@ -26,7 +26,7 @@ class BitvectorImpl { - public static BitvectorImpl fromBytes(Bytes bytes, int size) { + public static BitvectorImpl fromBytes(final Bytes bytes, final int size) { checkArgument( bytes.size() == sszSerializationLength(size), "Incorrect data size (%s) for Bitvector of size %s", @@ -50,17 +50,17 @@ public static int sszSerializationLength(final int size) { private final BitSet data; private final int size; - private BitvectorImpl(BitSet bitSet, int size) { + private BitvectorImpl(final BitSet bitSet, final int size) { this.data = bitSet; this.size = size; } - public BitvectorImpl(int size) { + public BitvectorImpl(final int size) { this.data = new BitSet(size); this.size = size; } - public BitvectorImpl(int size, Iterable indicesToSet) { + public BitvectorImpl(final int size, final Iterable indicesToSet) { this(size); for (int i : indicesToSet) { checkElementIndex(i, size); @@ -68,7 +68,7 @@ public BitvectorImpl(int size, Iterable indicesToSet) { } } - public BitvectorImpl(int size, int... indicesToSet) { + public BitvectorImpl(final int size, final int... indicesToSet) { this(size, Arrays.stream(indicesToSet).boxed().toList()); } @@ -76,7 +76,27 @@ public List getSetBitIndices() { return data.stream().boxed().toList(); } - public BitvectorImpl withBit(int i) { + public BitvectorImpl or(final BitvectorImpl other) { + if (other.getSize() != getSize()) { + throw new IllegalArgumentException( + "Argument bitfield size is different: " + other.getSize() + " != " + getSize()); + } + final BitSet newData = (BitSet) this.data.clone(); + newData.or(other.data); + return new BitvectorImpl(newData, size); + } + + public BitvectorImpl and(final BitvectorImpl other) { + if (other.getSize() != getSize()) { + throw new IllegalArgumentException( + "Argument bitfield size is different: " + other.getSize() + " != " + getSize()); + } + final BitSet newData = (BitSet) this.data.clone(); + newData.and(other.data); + return new BitvectorImpl(newData, size); + } + + public BitvectorImpl withBit(final int i) { checkElementIndex(i, size); BitSet newSet = (BitSet) data.clone(); newSet.set(i); @@ -87,7 +107,7 @@ public int getBitCount() { return data.cardinality(); } - public boolean getBit(int i) { + public boolean getBit(final int i) { checkElementIndex(i, size); return data.get(i); } @@ -96,6 +116,10 @@ public int getSize() { return size; } + public int getLastSetBitIndex() { + return data.length() - 1; + } + public IntStream streamAllSetBits() { return data.stream(); } @@ -107,19 +131,18 @@ public Bytes serialize() { return Bytes.wrap(array); } - public BitvectorImpl rightShift(int i) { - int length = this.getSize(); - BitSet newData = new BitSet(getSize()); - for (int j = 0; j < length - i; j++) { + public BitvectorImpl rightShift(final int i) { + final BitSet newData = new BitSet(size); + for (int j = 0; j < size - i; j++) { if (this.getBit(j)) { newData.set(j + i); } } - return new BitvectorImpl(newData, getSize()); + return new BitvectorImpl(newData, size); } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszBitlistImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszBitlistImpl.java index 40e8288fdce..135f6450067 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszBitlistImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszBitlistImpl.java @@ -16,6 +16,7 @@ import static com.google.common.base.Preconditions.checkArgument; import it.unimi.dsi.fastutil.ints.IntList; +import java.util.BitSet; import java.util.stream.IntStream; import javax.annotation.Nullable; import org.apache.tuweni.bytes.Bytes; @@ -32,7 +33,7 @@ public class SszBitlistImpl extends SszListImpl implements SszBitlist { - public static Bytes sszTruncateLeadingBit(Bytes bytes, int length) { + public static Bytes sszTruncateLeadingBit(final Bytes bytes, final int length) { Bytes bytesWithoutLast = bytes.slice(0, bytes.size() - 1); if (length % 8 == 0) { return bytesWithoutLast; @@ -44,7 +45,7 @@ public static Bytes sszTruncateLeadingBit(Bytes bytes, int length) { } } - public static int sszGetLengthAndValidate(Bytes bytes) { + public static int sszGetLengthAndValidate(final Bytes bytes) { int numBytes = bytes.size(); checkArgument(numBytes > 0, "BitlistImpl must contain at least one byte"); checkArgument(bytes.get(numBytes - 1) != 0, "BitlistImpl data must contain end marker bit"); @@ -54,7 +55,7 @@ public static int sszGetLengthAndValidate(Bytes bytes) { } public static SszBitlist nullableOr( - @Nullable SszBitlist bitlist1OrNull, @Nullable SszBitlist bitlist2OrNull) { + final @Nullable SszBitlist bitlist1OrNull, final @Nullable SszBitlist bitlist2OrNull) { checkArgument( bitlist1OrNull != null || bitlist2OrNull != null, "At least one argument should be non-null"); @@ -67,18 +68,24 @@ public static SszBitlist nullableOr( } } - public static SszBitlistImpl ofBits(SszBitlistSchema schema, int size, int... bits) { + public static SszBitlistImpl ofBits( + final SszBitlistSchema schema, final int size, final int... bits) { return new SszBitlistImpl(schema, new BitlistImpl(size, schema.getMaxLength(), bits)); } + public static SszBitlistImpl wrapBitSet( + final SszBitlistSchema schema, final int size, final BitSet bitSet) { + return new SszBitlistImpl(schema, new BitlistImpl(size, schema.getMaxLength(), bitSet)); + } + private final BitlistImpl value; - public SszBitlistImpl(SszListSchema schema, TreeNode backingNode) { + public SszBitlistImpl(final SszListSchema schema, final TreeNode backingNode) { super(schema, backingNode); value = getBitlist(this); } - public SszBitlistImpl(SszListSchema schema, BitlistImpl value) { + public SszBitlistImpl(final SszListSchema schema, final BitlistImpl value) { super(schema, () -> toSszBitList(schema, value).getBackingNode()); this.value = value; } @@ -95,17 +102,17 @@ protected IntCache createCache() { return IntCache.noop(); } - private BitlistImpl toBitlistImpl(SszBitlist bl) { + private BitlistImpl toBitlistImpl(final SszBitlist bl) { return ((SszBitlistImpl) bl).value; } @Override - public SszBitlist or(SszBitlist other) { + public SszBitlist or(final SszBitlist other) { return new SszBitlistImpl(getSchema(), value.or(toBitlistImpl(other))); } @Override - public boolean getBit(int i) { + public boolean getBit(final int i) { return value.getBit(i); } @@ -115,12 +122,12 @@ public int getBitCount() { } @Override - public boolean intersects(SszBitlist other) { + public boolean intersects(final SszBitlist other) { return value.intersects(toBitlistImpl(other)); } @Override - public boolean isSuperSetOf(SszBitlist other) { + public boolean isSuperSetOf(final SszBitlist other) { return value.isSuperSetOf(toBitlistImpl(other)); } @@ -140,11 +147,11 @@ protected int sizeImpl() { } private static SszList toSszBitList( - SszListSchema schema, BitlistImpl bitlist) { + final SszListSchema schema, final BitlistImpl bitlist) { return schema.sszDeserialize(SszReader.fromBytes(bitlist.serialize())); } - private static BitlistImpl getBitlist(SszList bitlistView) { + private static BitlistImpl getBitlist(final SszList bitlistView) { return BitlistImpl.fromSszBytes( bitlistView.sszSerialize(), bitlistView.getSchema().getMaxLength()); } @@ -163,4 +170,8 @@ public boolean isWritableSupported() { public String toString() { return "SszBitlist{size=" + this.size() + ", " + value.toString() + "}"; } + + public static SszBitlist fromBytes(final SszBitlistSchema schema, final Bytes value) { + return new SszBitlistImpl(schema, BitlistImpl.fromSszBytes(value, schema.getMaxLength())); + } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszBitvectorImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszBitvectorImpl.java index 93e10b6a052..16e3ba5eb31 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszBitvectorImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszBitvectorImpl.java @@ -18,6 +18,7 @@ import it.unimi.dsi.fastutil.ints.IntArrayList; import it.unimi.dsi.fastutil.ints.IntList; import java.util.stream.IntStream; +import org.apache.tuweni.bytes.Bytes; import tech.pegasys.teku.infrastructure.ssz.cache.IntCache; import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; import tech.pegasys.teku.infrastructure.ssz.collections.SszMutablePrimitiveVector; @@ -30,18 +31,28 @@ public class SszBitvectorImpl extends SszVectorImpl implements SszBitvector { - public static SszBitvectorImpl ofBits(SszBitvectorSchema schema, int... bits) { + public static SszBitvectorImpl ofBits(final SszBitvectorSchema schema, final int... bits) { return new SszBitvectorImpl(schema, new BitvectorImpl(schema.getLength(), bits)); } + public static SszBitvector fromBytes( + final SszBitvectorSchema schema, final Bytes value, final int size) { + return new SszBitvectorImpl(schema, BitvectorImpl.fromBytes(value, size)); + } + + public static SszBitvector fromHexString( + final SszBitvectorSchema schema, final String hexString, final int size) { + return fromBytes(schema, Bytes.fromHexString(hexString), size); + } + private final BitvectorImpl value; - public SszBitvectorImpl(SszVectorSchema schema, TreeNode backingNode) { + public SszBitvectorImpl(final SszVectorSchema schema, final TreeNode backingNode) { super(schema, backingNode); value = BitvectorImpl.fromBytes(sszSerialize(), size()); } - public SszBitvectorImpl(SszBitvectorSchema schema, BitvectorImpl value) { + public SszBitvectorImpl(final SszBitvectorSchema schema, final BitvectorImpl value) { super(schema, () -> schema.sszDeserializeTree(SszReader.fromBytes(value.serialize()))); checkNotNull(value); this.value = value; @@ -60,7 +71,7 @@ protected IntCache createCache() { } @Override - public boolean getBit(int i) { + public boolean getBit(final int i) { return value.getBit(i); } @@ -70,7 +81,7 @@ public int getBitCount() { } @Override - public SszBitvector rightShift(int n) { + public SszBitvector rightShift(final int n) { return new SszBitvectorImpl(getSchema(), value.rightShift(n)); } @@ -79,16 +90,31 @@ public IntList getAllSetBits() { return IntArrayList.toList(value.streamAllSetBits()); } + @Override + public int getLastSetBitIndex() { + return value.getLastSetBitIndex(); + } + @Override public IntStream streamAllSetBits() { return value.streamAllSetBits(); } @Override - public SszBitvector withBit(int i) { + public SszBitvector withBit(final int i) { return new SszBitvectorImpl(getSchema(), value.withBit(i)); } + @Override + public SszBitvector or(final SszBitvector other) { + return new SszBitvectorImpl(getSchema(), value.or(toBitvectorImpl(other))); + } + + @Override + public SszBitvector and(final SszBitvector other) { + return new SszBitvectorImpl(getSchema(), value.and(toBitvectorImpl(other))); + } + @Override protected int sizeImpl() { return getSchema().getLength(); @@ -108,4 +134,8 @@ public boolean isWritableSupported() { public String toString() { return "SszBitvector{size=" + this.size() + ", " + value.toString() + "}"; } + + private BitvectorImpl toBitvectorImpl(final SszBitvector bv) { + return ((SszBitvectorImpl) bv).value; + } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszByteListImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszByteListImpl.java index c6fb7658de6..07393e861a2 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszByteListImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszByteListImpl.java @@ -25,7 +25,7 @@ public class SszByteListImpl extends SszPrimitiveListImpl implements SszByteList { - public SszByteListImpl(SszByteListSchema schema, TreeNode backingTree) { + public SszByteListImpl(final SszByteListSchema schema, final TreeNode backingTree) { super(schema, backingTree); } @@ -37,7 +37,7 @@ public Bytes getBytes() { } @Override - public Byte getElement(int index) { + public Byte getElement(final int index) { return elementType.createFromPackedNodeUnboxed(getTreeNode(index), index % elementsPerChunk); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszByteVectorImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszByteVectorImpl.java index 90ab80a3a49..53459de6d81 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszByteVectorImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszByteVectorImpl.java @@ -27,12 +27,12 @@ public class SszByteVectorImpl extends SszPrimitiveVectorImpl private final Bytes data; - public SszByteVectorImpl(SszByteVectorSchema schema, Bytes bytes) { + public SszByteVectorImpl(final SszByteVectorSchema schema, final Bytes bytes) { super(schema, () -> SszByteVectorSchemaImpl.fromBytesToTree(schema, bytes)); this.data = bytes; } - public SszByteVectorImpl(SszByteVectorSchema schema, TreeNode backingTree) { + public SszByteVectorImpl(final SszByteVectorSchema schema, final TreeNode backingTree) { super(schema, backingTree); this.data = SszByteVectorSchemaImpl.fromTreeToBytes(schema, backingTree); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszBytes32VectorImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszBytes32VectorImpl.java index 5fa4258218a..9826fa029ee 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszBytes32VectorImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszBytes32VectorImpl.java @@ -24,11 +24,12 @@ public class SszBytes32VectorImpl extends SszPrimitiveVectorImpl implements SszBytes32Vector { - public SszBytes32VectorImpl(SszCompositeSchema schema, Supplier lazyBackingNode) { + public SszBytes32VectorImpl( + final SszCompositeSchema schema, final Supplier lazyBackingNode) { super(schema, lazyBackingNode); } - public SszBytes32VectorImpl(SszCompositeSchema schema, TreeNode backingNode) { + public SszBytes32VectorImpl(final SszCompositeSchema schema, final TreeNode backingNode) { super(schema, backingNode); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszMutableBytes32VectorImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszMutableBytes32VectorImpl.java index 7dd9696f267..f404eb70277 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszMutableBytes32VectorImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszMutableBytes32VectorImpl.java @@ -24,7 +24,7 @@ public class SszMutableBytes32VectorImpl extends SszMutablePrimitiveVectorImpl implements SszMutableBytes32Vector { - public SszMutableBytes32VectorImpl(AbstractSszComposite backingImmutableData) { + public SszMutableBytes32VectorImpl(final AbstractSszComposite backingImmutableData) { super(backingImmutableData); } @@ -35,7 +35,7 @@ public SszBytes32Vector commitChanges() { @Override protected SszBytes32VectorImpl createImmutableSszComposite( - TreeNode backingNode, IntCache childrenCache) { + final TreeNode backingNode, final IntCache childrenCache) { return new SszBytes32VectorImpl(getSchema(), backingNode); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszMutablePrimitiveListImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszMutablePrimitiveListImpl.java index f66f88d9e27..31b8ba7a0d5 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszMutablePrimitiveListImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszMutablePrimitiveListImpl.java @@ -24,8 +24,7 @@ import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -public class SszMutablePrimitiveListImpl< - ElementT, SszElementT extends SszPrimitive> +public class SszMutablePrimitiveListImpl> extends AbstractSszMutablePrimitiveCollection implements SszMutablePrimitiveList { @@ -34,14 +33,14 @@ public class SszMutablePrimitiveListImpl< @SuppressWarnings("unchecked") public SszMutablePrimitiveListImpl( - SszPrimitiveListImpl backingImmutableList) { + final SszPrimitiveListImpl backingImmutableList) { super(backingImmutableList); cachedSize = backingImmutableList.size(); cachedMaxLength = getSchema().getMaxLength(); } @Override - protected void checkIndex(int index, boolean set) { + protected void checkIndex(final int index, final boolean set) { if (index < 0 || (!set && index >= size()) || (set && (index > size() || index >= cachedMaxLength))) { @@ -51,7 +50,7 @@ protected void checkIndex(int index, boolean set) { } @Override - protected TreeNode doFinalTreeUpdates(TreeNode updatedTree) { + protected TreeNode doFinalTreeUpdates(final TreeNode updatedTree) { return updateSize(updatedTree); } @@ -60,7 +59,7 @@ public int size() { return cachedSize; } - private TreeNode updateSize(TreeNode root) { + private TreeNode updateSize(final TreeNode root) { return BranchNode.create(root.get(GIndexUtil.LEFT_CHILD_G_INDEX), createSizeNode()); } @@ -69,7 +68,7 @@ private TreeNode createSizeNode() { } @Override - public void set(int index, SszElementT value) { + public void set(final int index, final SszElementT value) { super.set(index, value); if (index == size()) { cachedSize++; @@ -96,7 +95,7 @@ public SszPrimitiveList commitChanges() { @Override protected SszPrimitiveListImpl createImmutableSszComposite( - TreeNode backingNode, IntCache childrenCache) { + final TreeNode backingNode, final IntCache childrenCache) { return new SszPrimitiveListImpl<>(getSchema(), backingNode, childrenCache); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszMutablePrimitiveVectorImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszMutablePrimitiveVectorImpl.java index f8d4cac81c3..16a3772f52f 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszMutablePrimitiveVectorImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszMutablePrimitiveVectorImpl.java @@ -21,18 +21,18 @@ import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszPrimitiveVectorSchema; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; -public class SszMutablePrimitiveVectorImpl< - ElementT, SszElementT extends SszPrimitive> +public class SszMutablePrimitiveVectorImpl> extends AbstractSszMutablePrimitiveCollection implements SszMutablePrimitiveVector { @SuppressWarnings("unchecked") - public SszMutablePrimitiveVectorImpl(AbstractSszComposite backingImmutableData) { + public SszMutablePrimitiveVectorImpl( + final AbstractSszComposite backingImmutableData) { super(backingImmutableData); } @Override - protected void checkIndex(int index, boolean set) { + protected void checkIndex(final int index, final boolean set) { if (index < 0 || index >= size()) { throw new IndexOutOfBoundsException( "Invalid index " + index + " for vector with size " + size()); @@ -53,7 +53,7 @@ public SszPrimitiveVector commitChanges() { @Override protected AbstractSszComposite createImmutableSszComposite( - TreeNode backingNode, IntCache childrenCache) { + final TreeNode backingNode, final IntCache childrenCache) { return new SszPrimitiveVectorImpl<>(getSchema(), backingNode, childrenCache); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszMutableUInt64ListImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszMutableUInt64ListImpl.java index 6af9a90d229..c394f07ef38 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszMutableUInt64ListImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszMutableUInt64ListImpl.java @@ -24,7 +24,7 @@ public class SszMutableUInt64ListImpl extends SszMutablePrimitiveListImpl implements SszMutableUInt64List { - public SszMutableUInt64ListImpl(SszUInt64ListImpl backingImmutableData) { + public SszMutableUInt64ListImpl(final SszUInt64ListImpl backingImmutableData) { super(backingImmutableData); } @@ -35,7 +35,7 @@ public SszUInt64List commitChanges() { @Override protected SszUInt64ListImpl createImmutableSszComposite( - TreeNode backingNode, IntCache childrenCache) { + final TreeNode backingNode, final IntCache childrenCache) { return new SszUInt64ListImpl(getSchema(), backingNode, childrenCache); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszPrimitiveListImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszPrimitiveListImpl.java index 0565880b969..d11786c8c5a 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszPrimitiveListImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszPrimitiveListImpl.java @@ -23,7 +23,7 @@ import tech.pegasys.teku.infrastructure.ssz.tree.CachingTreeAccessor; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; -public class SszPrimitiveListImpl> +public class SszPrimitiveListImpl> extends SszListImpl implements SszPrimitiveList { protected final int elementsPerChunk; @@ -31,7 +31,8 @@ public class SszPrimitiveListImpl schema, TreeNode backingNode) { + public SszPrimitiveListImpl( + final SszListSchema schema, final TreeNode backingNode) { super(schema, backingNode); this.elementsPerChunk = schema.getElementsPerChunk(); this.elementType = (SszPrimitiveSchema) schema.getElementSchema(); @@ -41,7 +42,9 @@ public SszPrimitiveListImpl(SszListSchema schema, TreeNode backi @SuppressWarnings("unchecked") public SszPrimitiveListImpl( - SszListSchema schema, TreeNode backingNode, IntCache cache) { + final SszListSchema schema, + final TreeNode backingNode, + final IntCache cache) { super(schema, backingNode, cache); this.elementsPerChunk = schema.getElementsPerChunk(); this.elementType = (SszPrimitiveSchema) schema.getElementSchema(); @@ -50,11 +53,11 @@ public SszPrimitiveListImpl( } @Override - protected SszElementT getImpl(int index) { + protected SszElementT getImpl(final int index) { return elementType.createFromPackedNode(getTreeNode(index), index % elementsPerChunk); } - protected TreeNode getTreeNode(int index) { + protected TreeNode getTreeNode(final int index) { int nodeIndex = index / elementsPerChunk; return cachingTreeAccessor.getNodeByVectorIndex(nodeIndex); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszPrimitiveVectorImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszPrimitiveVectorImpl.java index 3e74a973d80..0e0d5adeb1a 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszPrimitiveVectorImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszPrimitiveVectorImpl.java @@ -22,20 +22,22 @@ import tech.pegasys.teku.infrastructure.ssz.schema.SszCompositeSchema; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; -public class SszPrimitiveVectorImpl< - ElementT, SszElementT extends SszPrimitive> +public class SszPrimitiveVectorImpl> extends SszVectorImpl implements SszPrimitiveVector { - SszPrimitiveVectorImpl(SszCompositeSchema schema, Supplier lazyBackingNode) { + SszPrimitiveVectorImpl( + final SszCompositeSchema schema, final Supplier lazyBackingNode) { super(schema, lazyBackingNode); } SszPrimitiveVectorImpl( - SszCompositeSchema schema, TreeNode backingNode, IntCache cache) { + final SszCompositeSchema schema, + final TreeNode backingNode, + final IntCache cache) { super(schema, backingNode, cache); } - public SszPrimitiveVectorImpl(SszCompositeSchema schema, TreeNode backingNode) { + public SszPrimitiveVectorImpl(final SszCompositeSchema schema, final TreeNode backingNode) { super(schema, backingNode); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszUInt64ListImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszUInt64ListImpl.java index 8ca8981c145..c56e45baecf 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszUInt64ListImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/SszUInt64ListImpl.java @@ -25,12 +25,14 @@ public class SszUInt64ListImpl extends SszPrimitiveListImpl implements SszUInt64List { - public SszUInt64ListImpl(SszUInt64ListSchema schema, TreeNode backingNode) { + public SszUInt64ListImpl(final SszUInt64ListSchema schema, final TreeNode backingNode) { super(schema, backingNode); } SszUInt64ListImpl( - SszListSchema schema, TreeNode backingNode, IntCache cache) { + final SszListSchema schema, + final TreeNode backingNode, + final IntCache cache) { super(schema, backingNode, cache); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container1.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container1.java index 678b063b944..65d82fb29ec 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container1.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container1.java @@ -21,15 +21,15 @@ public class Container1, V0 extends SszData> extends AbstractSszImmutableContainer { - protected Container1(ContainerSchema1 schema) { + protected Container1(final ContainerSchema1 schema) { super(schema); } - protected Container1(ContainerSchema1 schema, TreeNode backingNode) { + protected Container1(final ContainerSchema1 schema, final TreeNode backingNode) { super(schema, backingNode); } - protected Container1(ContainerSchema1 schema, V0 arg0) { + protected Container1(final ContainerSchema1 schema, final V0 arg0) { super(schema, arg0); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container10.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container10.java index 9c7f093c4cf..0487abeddb1 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container10.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container10.java @@ -32,27 +32,28 @@ public class Container10< V9 extends SszData> extends AbstractSszImmutableContainer { - protected Container10(ContainerSchema10 schema) { + protected Container10(final ContainerSchema10 schema) { super(schema); } protected Container10( - ContainerSchema10 schema, TreeNode backingNode) { + final ContainerSchema10 schema, + final TreeNode backingNode) { super(schema, backingNode); } protected Container10( - ContainerSchema10 schema, - V0 arg0, - V1 arg1, - V2 arg2, - V3 arg3, - V4 arg4, - V5 arg5, - V6 arg6, - V7 arg7, - V8 arg8, - V9 arg9) { + final ContainerSchema10 schema, + final V0 arg0, + final V1 arg1, + final V2 arg2, + final V3 arg3, + final V4 arg4, + final V5 arg5, + final V6 arg6, + final V7 arg7, + final V8 arg8, + final V9 arg9) { super(schema, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container11.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container11.java index edf14765eeb..bc23fdc69fd 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container11.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container11.java @@ -33,29 +33,30 @@ public class Container11< V10 extends SszData> extends AbstractSszImmutableContainer { - protected Container11(ContainerSchema11 schema) { + protected Container11( + final ContainerSchema11 schema) { super(schema); } protected Container11( - ContainerSchema11 schema, - TreeNode backingNode) { + final ContainerSchema11 schema, + final TreeNode backingNode) { super(schema, backingNode); } protected Container11( - ContainerSchema11 schema, - V0 arg0, - V1 arg1, - V2 arg2, - V3 arg3, - V4 arg4, - V5 arg5, - V6 arg6, - V7 arg7, - V8 arg8, - V9 arg9, - V10 arg10) { + final ContainerSchema11 schema, + final V0 arg0, + final V1 arg1, + final V2 arg2, + final V3 arg3, + final V4 arg4, + final V5 arg5, + final V6 arg6, + final V7 arg7, + final V8 arg8, + final V9 arg9, + final V10 arg10) { super(schema, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container12.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container12.java index ac35a77f563..5031d305ec6 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container12.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container12.java @@ -35,30 +35,30 @@ public class Container12< extends AbstractSszImmutableContainer { protected Container12( - ContainerSchema12 schema) { + final ContainerSchema12 schema) { super(schema); } protected Container12( - ContainerSchema12 schema, - TreeNode backingNode) { + final ContainerSchema12 schema, + final TreeNode backingNode) { super(schema, backingNode); } protected Container12( - ContainerSchema12 schema, - V0 arg0, - V1 arg1, - V2 arg2, - V3 arg3, - V4 arg4, - V5 arg5, - V6 arg6, - V7 arg7, - V8 arg8, - V9 arg9, - V10 arg10, - V11 arg11) { + final ContainerSchema12 schema, + final V0 arg0, + final V1 arg1, + final V2 arg2, + final V3 arg3, + final V4 arg4, + final V5 arg5, + final V6 arg6, + final V7 arg7, + final V8 arg8, + final V9 arg9, + final V10 arg10, + final V11 arg11) { super(schema, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container13.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container13.java index 86f59dee97f..ffb38a5a476 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container13.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container13.java @@ -36,31 +36,31 @@ public class Container13< extends AbstractSszImmutableContainer { protected Container13( - ContainerSchema13 schema) { + final ContainerSchema13 schema) { super(schema); } protected Container13( - ContainerSchema13 schema, - TreeNode backingNode) { + final ContainerSchema13 schema, + final TreeNode backingNode) { super(schema, backingNode); } protected Container13( - ContainerSchema13 schema, - V0 arg0, - V1 arg1, - V2 arg2, - V3 arg3, - V4 arg4, - V5 arg5, - V6 arg6, - V7 arg7, - V8 arg8, - V9 arg9, - V10 arg10, - V11 arg11, - V12 arg12) { + final ContainerSchema13 schema, + final V0 arg0, + final V1 arg1, + final V2 arg2, + final V3 arg3, + final V4 arg4, + final V5 arg5, + final V6 arg6, + final V7 arg7, + final V8 arg8, + final V9 arg9, + final V10 arg10, + final V11 arg11, + final V12 arg12) { super(schema, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container14.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container14.java index 995d6293580..4fac016d05b 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container14.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container14.java @@ -37,32 +37,33 @@ public class Container14< extends AbstractSszImmutableContainer { protected Container14( - ContainerSchema14 schema) { + final ContainerSchema14 + schema) { super(schema); } protected Container14( - ContainerSchema14 schema, - TreeNode backingNode) { + final ContainerSchema14 schema, + final TreeNode backingNode) { super(schema, backingNode); } protected Container14( - ContainerSchema14 schema, - V0 arg0, - V1 arg1, - V2 arg2, - V3 arg3, - V4 arg4, - V5 arg5, - V6 arg6, - V7 arg7, - V8 arg8, - V9 arg9, - V10 arg10, - V11 arg11, - V12 arg12, - V13 arg13) { + final ContainerSchema14 schema, + final V0 arg0, + final V1 arg1, + final V2 arg2, + final V3 arg3, + final V4 arg4, + final V5 arg5, + final V6 arg6, + final V7 arg7, + final V8 arg8, + final V9 arg9, + final V10 arg10, + final V11 arg11, + final V12 arg12, + final V13 arg13) { super( schema, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13); diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container15.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container15.java index cea62a8a4bc..560062d0a41 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container15.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container15.java @@ -38,34 +38,36 @@ public class Container15< extends AbstractSszImmutableContainer { protected Container15( - ContainerSchema15 + final ContainerSchema15 schema) { super(schema); } protected Container15( - ContainerSchema15 schema, - TreeNode backingNode) { + final ContainerSchema15 + schema, + final TreeNode backingNode) { super(schema, backingNode); } protected Container15( - ContainerSchema15 schema, - V0 arg0, - V1 arg1, - V2 arg2, - V3 arg3, - V4 arg4, - V5 arg5, - V6 arg6, - V7 arg7, - V8 arg8, - V9 arg9, - V10 arg10, - V11 arg11, - V12 arg12, - V13 arg13, - V14 arg14) { + final ContainerSchema15 + schema, + final V0 arg0, + final V1 arg1, + final V2 arg2, + final V3 arg3, + final V4 arg4, + final V5 arg5, + final V6 arg6, + final V7 arg7, + final V8 arg8, + final V9 arg9, + final V10 arg10, + final V11 arg11, + final V12 arg12, + final V13 arg13, + final V14 arg14) { super( schema, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14); diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container16.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container16.java index 70329001c81..71d2ebf70c7 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container16.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container16.java @@ -40,37 +40,40 @@ public class Container16< extends AbstractSszImmutableContainer { protected Container16( - ContainerSchema16 + final ContainerSchema16< + C, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15> schema) { super(schema); } protected Container16( - ContainerSchema16 + final ContainerSchema16< + C, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15> schema, - TreeNode backingNode) { + final TreeNode backingNode) { super(schema, backingNode); } protected Container16( - ContainerSchema16 + final ContainerSchema16< + C, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15> schema, - V0 arg0, - V1 arg1, - V2 arg2, - V3 arg3, - V4 arg4, - V5 arg5, - V6 arg6, - V7 arg7, - V8 arg8, - V9 arg9, - V10 arg10, - V11 arg11, - V12 arg12, - V13 arg13, - V14 arg14, - V15 arg15) { + final V0 arg0, + final V1 arg1, + final V2 arg2, + final V3 arg3, + final V4 arg4, + final V5 arg5, + final V6 arg6, + final V7 arg7, + final V8 arg8, + final V9 arg9, + final V10 arg10, + final V11 arg11, + final V12 arg12, + final V13 arg13, + final V14 arg14, + final V15 arg15) { super( schema, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15); diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container17.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container17.java index 49af3d018c2..ba37808aae3 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container17.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container17.java @@ -42,41 +42,41 @@ public class Container17< extends AbstractSszImmutableContainer { protected Container17( - ContainerSchema17< + final ContainerSchema17< C, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16> schema) { super(schema); } protected Container17( - ContainerSchema17< + final ContainerSchema17< C, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16> schema, - TreeNode backingNode) { + final TreeNode backingNode) { super(schema, backingNode); } protected Container17( - ContainerSchema17< + final ContainerSchema17< C, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16> schema, - V0 arg0, - V1 arg1, - V2 arg2, - V3 arg3, - V4 arg4, - V5 arg5, - V6 arg6, - V7 arg7, - V8 arg8, - V9 arg9, - V10 arg10, - V11 arg11, - V12 arg12, - V13 arg13, - V14 arg14, - V15 arg15, - V16 arg16) { + final V0 arg0, + final V1 arg1, + final V2 arg2, + final V3 arg3, + final V4 arg4, + final V5 arg5, + final V6 arg6, + final V7 arg7, + final V8 arg8, + final V9 arg9, + final V10 arg10, + final V11 arg11, + final V12 arg12, + final V13 arg13, + final V14 arg14, + final V15 arg15, + final V16 arg16) { super( schema, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16); diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container18.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container18.java index 2b14f2f70da..e1f0ecfa03f 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container18.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container18.java @@ -61,42 +61,42 @@ public class Container18< extends AbstractSszImmutableContainer { protected Container18( - ContainerSchema18< + final ContainerSchema18< C, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17> schema) { super(schema); } protected Container18( - ContainerSchema18< + final ContainerSchema18< C, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17> schema, - TreeNode backingNode) { + final TreeNode backingNode) { super(schema, backingNode); } protected Container18( - ContainerSchema18< + final ContainerSchema18< C, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17> schema, - V0 arg0, - V1 arg1, - V2 arg2, - V3 arg3, - V4 arg4, - V5 arg5, - V6 arg6, - V7 arg7, - V8 arg8, - V9 arg9, - V10 arg10, - V11 arg11, - V12 arg12, - V13 arg13, - V14 arg14, - V15 arg15, - V16 arg16, - V17 arg17) { + final V0 arg0, + final V1 arg1, + final V2 arg2, + final V3 arg3, + final V4 arg4, + final V5 arg5, + final V6 arg6, + final V7 arg7, + final V8 arg8, + final V9 arg9, + final V10 arg10, + final V11 arg11, + final V12 arg12, + final V13 arg13, + final V14 arg14, + final V15 arg15, + final V16 arg16, + final V17 arg17) { super( schema, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17); diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container19.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container19.java index 85dcd9dda21..412ee1a0905 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container19.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container19.java @@ -63,7 +63,7 @@ public class Container19< extends AbstractSszImmutableContainer { protected Container19( - ContainerSchema19< + final ContainerSchema19< C, V0, V1, @@ -89,7 +89,7 @@ protected Container19( } protected Container19( - ContainerSchema19< + final ContainerSchema19< C, V0, V1, @@ -111,12 +111,12 @@ protected Container19( V17, V18> schema, - TreeNode backingNode) { + final TreeNode backingNode) { super(schema, backingNode); } protected Container19( - ContainerSchema19< + final ContainerSchema19< C, V0, V1, @@ -138,25 +138,25 @@ protected Container19( V17, V18> schema, - V0 arg0, - V1 arg1, - V2 arg2, - V3 arg3, - V4 arg4, - V5 arg5, - V6 arg6, - V7 arg7, - V8 arg8, - V9 arg9, - V10 arg10, - V11 arg11, - V12 arg12, - V13 arg13, - V14 arg14, - V15 arg15, - V16 arg16, - V17 arg17, - V18 arg18) { + final V0 arg0, + final V1 arg1, + final V2 arg2, + final V3 arg3, + final V4 arg4, + final V5 arg5, + final V6 arg6, + final V7 arg7, + final V8 arg8, + final V9 arg9, + final V10 arg10, + final V11 arg11, + final V12 arg12, + final V13 arg13, + final V14 arg14, + final V15 arg15, + final V16 arg16, + final V17 arg17, + final V18 arg18) { super( schema, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18); diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container2.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container2.java index e1e5059935f..7cd01078e5f 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container2.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container2.java @@ -21,15 +21,15 @@ public class Container2, V0 extends SszData, V1 extends SszData> extends AbstractSszImmutableContainer { - protected Container2(ContainerSchema2 schema) { + protected Container2(final ContainerSchema2 schema) { super(schema); } - protected Container2(ContainerSchema2 schema, TreeNode backingNode) { + protected Container2(final ContainerSchema2 schema, final TreeNode backingNode) { super(schema, backingNode); } - protected Container2(ContainerSchema2 schema, V0 arg0, V1 arg1) { + protected Container2(final ContainerSchema2 schema, final V0 arg0, final V1 arg1) { super(schema, arg0, arg1); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container20.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container20.java new file mode 100644 index 00000000000..d7ff6bc634b --- /dev/null +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container20.java @@ -0,0 +1,250 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.infrastructure.ssz.containers; + +import tech.pegasys.teku.infrastructure.ssz.SszData; +import tech.pegasys.teku.infrastructure.ssz.impl.AbstractSszImmutableContainer; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; + +/** Autogenerated by tech.pegasys.teku.ssz.backing.ContainersGenerator */ +public class Container20< + C extends + Container20< + C, + V0, + V1, + V2, + V3, + V4, + V5, + V6, + V7, + V8, + V9, + V10, + V11, + V12, + V13, + V14, + V15, + V16, + V17, + V18, + V19>, + V0 extends SszData, + V1 extends SszData, + V2 extends SszData, + V3 extends SszData, + V4 extends SszData, + V5 extends SszData, + V6 extends SszData, + V7 extends SszData, + V8 extends SszData, + V9 extends SszData, + V10 extends SszData, + V11 extends SszData, + V12 extends SszData, + V13 extends SszData, + V14 extends SszData, + V15 extends SszData, + V16 extends SszData, + V17 extends SszData, + V18 extends SszData, + V19 extends SszData> + extends AbstractSszImmutableContainer { + + protected Container20( + final ContainerSchema20< + C, + V0, + V1, + V2, + V3, + V4, + V5, + V6, + V7, + V8, + V9, + V10, + V11, + V12, + V13, + V14, + V15, + V16, + V17, + V18, + V19> + schema) { + super(schema); + } + + protected Container20( + final ContainerSchema20< + C, + V0, + V1, + V2, + V3, + V4, + V5, + V6, + V7, + V8, + V9, + V10, + V11, + V12, + V13, + V14, + V15, + V16, + V17, + V18, + V19> + schema, + final TreeNode backingNode) { + super(schema, backingNode); + } + + protected Container20( + final ContainerSchema20< + C, + V0, + V1, + V2, + V3, + V4, + V5, + V6, + V7, + V8, + V9, + V10, + V11, + V12, + V13, + V14, + V15, + V16, + V17, + V18, + V19> + schema, + final V0 arg0, + final V1 arg1, + final V2 arg2, + final V3 arg3, + final V4 arg4, + final V5 arg5, + final V6 arg6, + final V7 arg7, + final V8 arg8, + final V9 arg9, + final V10 arg10, + final V11 arg11, + final V12 arg12, + final V13 arg13, + final V14 arg14, + final V15 arg15, + final V16 arg16, + final V17 arg17, + final V18 arg18, + final V19 arg19) { + super( + schema, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, + arg13, arg14, arg15, arg16, arg17, arg18, arg19); + } + + protected V0 getField0() { + return getAny(0); + } + + protected V1 getField1() { + return getAny(1); + } + + protected V2 getField2() { + return getAny(2); + } + + protected V3 getField3() { + return getAny(3); + } + + protected V4 getField4() { + return getAny(4); + } + + protected V5 getField5() { + return getAny(5); + } + + protected V6 getField6() { + return getAny(6); + } + + protected V7 getField7() { + return getAny(7); + } + + protected V8 getField8() { + return getAny(8); + } + + protected V9 getField9() { + return getAny(9); + } + + protected V10 getField10() { + return getAny(10); + } + + protected V11 getField11() { + return getAny(11); + } + + protected V12 getField12() { + return getAny(12); + } + + protected V13 getField13() { + return getAny(13); + } + + protected V14 getField14() { + return getAny(14); + } + + protected V15 getField15() { + return getAny(15); + } + + protected V16 getField16() { + return getAny(16); + } + + protected V17 getField17() { + return getAny(17); + } + + protected V18 getField18() { + return getAny(18); + } + + protected V19 getField19() { + return getAny(19); + } +} diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container3.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container3.java index 60ca2c1fe37..21a1ff22106 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container3.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container3.java @@ -25,15 +25,16 @@ public class Container3< V2 extends SszData> extends AbstractSszImmutableContainer { - protected Container3(ContainerSchema3 schema) { + protected Container3(final ContainerSchema3 schema) { super(schema); } - protected Container3(ContainerSchema3 schema, TreeNode backingNode) { + protected Container3(final ContainerSchema3 schema, final TreeNode backingNode) { super(schema, backingNode); } - protected Container3(ContainerSchema3 schema, V0 arg0, V1 arg1, V2 arg2) { + protected Container3( + final ContainerSchema3 schema, final V0 arg0, final V1 arg1, final V2 arg2) { super(schema, arg0, arg1, arg2); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container4.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container4.java index 30c5d0e19bd..59656bde943 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container4.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container4.java @@ -26,16 +26,21 @@ public class Container4< V3 extends SszData> extends AbstractSszImmutableContainer { - protected Container4(ContainerSchema4 schema) { + protected Container4(final ContainerSchema4 schema) { super(schema); } - protected Container4(ContainerSchema4 schema, TreeNode backingNode) { + protected Container4( + final ContainerSchema4 schema, final TreeNode backingNode) { super(schema, backingNode); } protected Container4( - ContainerSchema4 schema, V0 arg0, V1 arg1, V2 arg2, V3 arg3) { + final ContainerSchema4 schema, + final V0 arg0, + final V1 arg1, + final V2 arg2, + final V3 arg3) { super(schema, arg0, arg1, arg2, arg3); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container5.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container5.java index 3dd83e220a5..5118d866eb7 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container5.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container5.java @@ -27,16 +27,22 @@ public class Container5< V4 extends SszData> extends AbstractSszImmutableContainer { - protected Container5(ContainerSchema5 schema) { + protected Container5(final ContainerSchema5 schema) { super(schema); } - protected Container5(ContainerSchema5 schema, TreeNode backingNode) { + protected Container5( + final ContainerSchema5 schema, final TreeNode backingNode) { super(schema, backingNode); } protected Container5( - ContainerSchema5 schema, V0 arg0, V1 arg1, V2 arg2, V3 arg3, V4 arg4) { + final ContainerSchema5 schema, + final V0 arg0, + final V1 arg1, + final V2 arg2, + final V3 arg3, + final V4 arg4) { super(schema, arg0, arg1, arg2, arg3, arg4); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container6.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container6.java index 889e3907270..8210f0ba768 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container6.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container6.java @@ -28,22 +28,23 @@ public class Container6< V5 extends SszData> extends AbstractSszImmutableContainer { - protected Container6(ContainerSchema6 schema) { + protected Container6(final ContainerSchema6 schema) { super(schema); } - protected Container6(ContainerSchema6 schema, TreeNode backingNode) { + protected Container6( + final ContainerSchema6 schema, final TreeNode backingNode) { super(schema, backingNode); } protected Container6( - ContainerSchema6 schema, - V0 arg0, - V1 arg1, - V2 arg2, - V3 arg3, - V4 arg4, - V5 arg5) { + final ContainerSchema6 schema, + final V0 arg0, + final V1 arg1, + final V2 arg2, + final V3 arg3, + final V4 arg4, + final V5 arg5) { super(schema, arg0, arg1, arg2, arg3, arg4, arg5); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container7.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container7.java index 1f2529ae79f..82b6bf5e327 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container7.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container7.java @@ -29,24 +29,24 @@ public class Container7< V6 extends SszData> extends AbstractSszImmutableContainer { - protected Container7(ContainerSchema7 schema) { + protected Container7(final ContainerSchema7 schema) { super(schema); } protected Container7( - ContainerSchema7 schema, TreeNode backingNode) { + final ContainerSchema7 schema, final TreeNode backingNode) { super(schema, backingNode); } protected Container7( - ContainerSchema7 schema, - V0 arg0, - V1 arg1, - V2 arg2, - V3 arg3, - V4 arg4, - V5 arg5, - V6 arg6) { + final ContainerSchema7 schema, + final V0 arg0, + final V1 arg1, + final V2 arg2, + final V3 arg3, + final V4 arg4, + final V5 arg5, + final V6 arg6) { super(schema, arg0, arg1, arg2, arg3, arg4, arg5, arg6); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container8.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container8.java index f4368264a03..84fd82efb20 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container8.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container8.java @@ -30,25 +30,26 @@ public class Container8< V7 extends SszData> extends AbstractSszImmutableContainer { - protected Container8(ContainerSchema8 schema) { + protected Container8(final ContainerSchema8 schema) { super(schema); } protected Container8( - ContainerSchema8 schema, TreeNode backingNode) { + final ContainerSchema8 schema, + final TreeNode backingNode) { super(schema, backingNode); } protected Container8( - ContainerSchema8 schema, - V0 arg0, - V1 arg1, - V2 arg2, - V3 arg3, - V4 arg4, - V5 arg5, - V6 arg6, - V7 arg7) { + final ContainerSchema8 schema, + final V0 arg0, + final V1 arg1, + final V2 arg2, + final V3 arg3, + final V4 arg4, + final V5 arg5, + final V6 arg6, + final V7 arg7) { super(schema, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container9.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container9.java index a814334bde0..7bcc4a9d9ef 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container9.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/Container9.java @@ -31,26 +31,27 @@ public class Container9< V8 extends SszData> extends AbstractSszImmutableContainer { - protected Container9(ContainerSchema9 schema) { + protected Container9(final ContainerSchema9 schema) { super(schema); } protected Container9( - ContainerSchema9 schema, TreeNode backingNode) { + final ContainerSchema9 schema, + final TreeNode backingNode) { super(schema, backingNode); } protected Container9( - ContainerSchema9 schema, - V0 arg0, - V1 arg1, - V2 arg2, - V3 arg3, - V4 arg4, - V5 arg5, - V6 arg6, - V7 arg7, - V8 arg8) { + final ContainerSchema9 schema, + final V0 arg0, + final V1 arg1, + final V2 arg2, + final V3 arg3, + final V4 arg4, + final V5 arg5, + final V6 arg6, + final V7 arg7, + final V8 arg8) { super(schema, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema1.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema1.java index 27bdcd71b74..95ccb477fef 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema1.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema1.java @@ -26,21 +26,22 @@ public abstract class ContainerSchema1 { public static ContainerSchema1 create( - SszSchema fieldSchema0, BiFunction, TreeNode, C> instanceCtor) { + final SszSchema fieldSchema0, + final BiFunction, TreeNode, C> instanceCtor) { return new ContainerSchema1<>(fieldSchema0) { @Override - public C createFromBackingNode(TreeNode node) { + public C createFromBackingNode(final TreeNode node) { return instanceCtor.apply(this, node); } }; } - protected ContainerSchema1(SszSchema fieldSchema0) { + protected ContainerSchema1(final SszSchema fieldSchema0) { super(List.of(fieldSchema0)); } - protected ContainerSchema1(String containerName, NamedSchema fieldNamedSchema0) { + protected ContainerSchema1(final String containerName, final NamedSchema fieldNamedSchema0) { super(containerName, List.of(fieldNamedSchema0)); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema10.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema10.java index ad46c73e3da..6bbff23a5f3 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema10.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema10.java @@ -49,17 +49,18 @@ public abstract class ContainerSchema10< V8 extends SszData, V9 extends SszData> ContainerSchema10 create( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - SszSchema fieldSchema7, - SszSchema fieldSchema8, - SszSchema fieldSchema9, - BiFunction, TreeNode, C> + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final SszSchema fieldSchema8, + final SszSchema fieldSchema9, + final BiFunction< + ContainerSchema10, TreeNode, C> instanceCtor) { return new ContainerSchema10<>( fieldSchema0, @@ -73,23 +74,23 @@ ContainerSchema10 create( fieldSchema8, fieldSchema9) { @Override - public C createFromBackingNode(TreeNode node) { + public C createFromBackingNode(final TreeNode node) { return instanceCtor.apply(this, node); } }; } protected ContainerSchema10( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - SszSchema fieldSchema7, - SszSchema fieldSchema8, - SszSchema fieldSchema9) { + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final SszSchema fieldSchema8, + final SszSchema fieldSchema9) { super( List.of( @@ -106,17 +107,17 @@ protected ContainerSchema10( } protected ContainerSchema10( - String containerName, - NamedSchema fieldNamedSchema0, - NamedSchema fieldNamedSchema1, - NamedSchema fieldNamedSchema2, - NamedSchema fieldNamedSchema3, - NamedSchema fieldNamedSchema4, - NamedSchema fieldNamedSchema5, - NamedSchema fieldNamedSchema6, - NamedSchema fieldNamedSchema7, - NamedSchema fieldNamedSchema8, - NamedSchema fieldNamedSchema9) { + final String containerName, + final NamedSchema fieldNamedSchema0, + final NamedSchema fieldNamedSchema1, + final NamedSchema fieldNamedSchema2, + final NamedSchema fieldNamedSchema3, + final NamedSchema fieldNamedSchema4, + final NamedSchema fieldNamedSchema5, + final NamedSchema fieldNamedSchema6, + final NamedSchema fieldNamedSchema7, + final NamedSchema fieldNamedSchema8, + final NamedSchema fieldNamedSchema9) { super( containerName, diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema11.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema11.java index 688a46a7426..ff677381972 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema11.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema11.java @@ -51,18 +51,19 @@ public abstract class ContainerSchema11< V9 extends SszData, V10 extends SszData> ContainerSchema11 create( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - SszSchema fieldSchema7, - SszSchema fieldSchema8, - SszSchema fieldSchema9, - SszSchema fieldSchema10, - BiFunction, TreeNode, C> + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final SszSchema fieldSchema8, + final SszSchema fieldSchema9, + final SszSchema fieldSchema10, + final BiFunction< + ContainerSchema11, TreeNode, C> instanceCtor) { return new ContainerSchema11<>( fieldSchema0, @@ -77,24 +78,24 @@ ContainerSchema11 create( fieldSchema9, fieldSchema10) { @Override - public C createFromBackingNode(TreeNode node) { + public C createFromBackingNode(final TreeNode node) { return instanceCtor.apply(this, node); } }; } protected ContainerSchema11( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - SszSchema fieldSchema7, - SszSchema fieldSchema8, - SszSchema fieldSchema9, - SszSchema fieldSchema10) { + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final SszSchema fieldSchema8, + final SszSchema fieldSchema9, + final SszSchema fieldSchema10) { super( List.of( @@ -112,18 +113,18 @@ protected ContainerSchema11( } protected ContainerSchema11( - String containerName, - NamedSchema fieldNamedSchema0, - NamedSchema fieldNamedSchema1, - NamedSchema fieldNamedSchema2, - NamedSchema fieldNamedSchema3, - NamedSchema fieldNamedSchema4, - NamedSchema fieldNamedSchema5, - NamedSchema fieldNamedSchema6, - NamedSchema fieldNamedSchema7, - NamedSchema fieldNamedSchema8, - NamedSchema fieldNamedSchema9, - NamedSchema fieldNamedSchema10) { + final String containerName, + final NamedSchema fieldNamedSchema0, + final NamedSchema fieldNamedSchema1, + final NamedSchema fieldNamedSchema2, + final NamedSchema fieldNamedSchema3, + final NamedSchema fieldNamedSchema4, + final NamedSchema fieldNamedSchema5, + final NamedSchema fieldNamedSchema6, + final NamedSchema fieldNamedSchema7, + final NamedSchema fieldNamedSchema8, + final NamedSchema fieldNamedSchema9, + final NamedSchema fieldNamedSchema10) { super( containerName, diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema12.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema12.java index 61988df76d5..f56f773665e 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema12.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema12.java @@ -53,19 +53,19 @@ public abstract class ContainerSchema12< V10 extends SszData, V11 extends SszData> ContainerSchema12 create( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - SszSchema fieldSchema7, - SszSchema fieldSchema8, - SszSchema fieldSchema9, - SszSchema fieldSchema10, - SszSchema fieldSchema11, - BiFunction< + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final SszSchema fieldSchema8, + final SszSchema fieldSchema9, + final SszSchema fieldSchema10, + final SszSchema fieldSchema11, + final BiFunction< ContainerSchema12, TreeNode, C> @@ -84,25 +84,25 @@ ContainerSchema12 create( fieldSchema10, fieldSchema11) { @Override - public C createFromBackingNode(TreeNode node) { + public C createFromBackingNode(final TreeNode node) { return instanceCtor.apply(this, node); } }; } protected ContainerSchema12( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - SszSchema fieldSchema7, - SszSchema fieldSchema8, - SszSchema fieldSchema9, - SszSchema fieldSchema10, - SszSchema fieldSchema11) { + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final SszSchema fieldSchema8, + final SszSchema fieldSchema9, + final SszSchema fieldSchema10, + final SszSchema fieldSchema11) { super( List.of( @@ -121,19 +121,19 @@ protected ContainerSchema12( } protected ContainerSchema12( - String containerName, - NamedSchema fieldNamedSchema0, - NamedSchema fieldNamedSchema1, - NamedSchema fieldNamedSchema2, - NamedSchema fieldNamedSchema3, - NamedSchema fieldNamedSchema4, - NamedSchema fieldNamedSchema5, - NamedSchema fieldNamedSchema6, - NamedSchema fieldNamedSchema7, - NamedSchema fieldNamedSchema8, - NamedSchema fieldNamedSchema9, - NamedSchema fieldNamedSchema10, - NamedSchema fieldNamedSchema11) { + final String containerName, + final NamedSchema fieldNamedSchema0, + final NamedSchema fieldNamedSchema1, + final NamedSchema fieldNamedSchema2, + final NamedSchema fieldNamedSchema3, + final NamedSchema fieldNamedSchema4, + final NamedSchema fieldNamedSchema5, + final NamedSchema fieldNamedSchema6, + final NamedSchema fieldNamedSchema7, + final NamedSchema fieldNamedSchema8, + final NamedSchema fieldNamedSchema9, + final NamedSchema fieldNamedSchema10, + final NamedSchema fieldNamedSchema11) { super( containerName, diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema13.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema13.java index 83499525654..a6cff09024d 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema13.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema13.java @@ -55,20 +55,20 @@ public abstract class ContainerSchema13< V11 extends SszData, V12 extends SszData> ContainerSchema13 create( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - SszSchema fieldSchema7, - SszSchema fieldSchema8, - SszSchema fieldSchema9, - SszSchema fieldSchema10, - SszSchema fieldSchema11, - SszSchema fieldSchema12, - BiFunction< + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final SszSchema fieldSchema8, + final SszSchema fieldSchema9, + final SszSchema fieldSchema10, + final SszSchema fieldSchema11, + final SszSchema fieldSchema12, + final BiFunction< ContainerSchema13, TreeNode, C> @@ -88,26 +88,26 @@ ContainerSchema13 crea fieldSchema11, fieldSchema12) { @Override - public C createFromBackingNode(TreeNode node) { + public C createFromBackingNode(final TreeNode node) { return instanceCtor.apply(this, node); } }; } protected ContainerSchema13( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - SszSchema fieldSchema7, - SszSchema fieldSchema8, - SszSchema fieldSchema9, - SszSchema fieldSchema10, - SszSchema fieldSchema11, - SszSchema fieldSchema12) { + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final SszSchema fieldSchema8, + final SszSchema fieldSchema9, + final SszSchema fieldSchema10, + final SszSchema fieldSchema11, + final SszSchema fieldSchema12) { super( List.of( @@ -127,20 +127,20 @@ protected ContainerSchema13( } protected ContainerSchema13( - String containerName, - NamedSchema fieldNamedSchema0, - NamedSchema fieldNamedSchema1, - NamedSchema fieldNamedSchema2, - NamedSchema fieldNamedSchema3, - NamedSchema fieldNamedSchema4, - NamedSchema fieldNamedSchema5, - NamedSchema fieldNamedSchema6, - NamedSchema fieldNamedSchema7, - NamedSchema fieldNamedSchema8, - NamedSchema fieldNamedSchema9, - NamedSchema fieldNamedSchema10, - NamedSchema fieldNamedSchema11, - NamedSchema fieldNamedSchema12) { + final String containerName, + final NamedSchema fieldNamedSchema0, + final NamedSchema fieldNamedSchema1, + final NamedSchema fieldNamedSchema2, + final NamedSchema fieldNamedSchema3, + final NamedSchema fieldNamedSchema4, + final NamedSchema fieldNamedSchema5, + final NamedSchema fieldNamedSchema6, + final NamedSchema fieldNamedSchema7, + final NamedSchema fieldNamedSchema8, + final NamedSchema fieldNamedSchema9, + final NamedSchema fieldNamedSchema10, + final NamedSchema fieldNamedSchema11, + final NamedSchema fieldNamedSchema12) { super( containerName, diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema14.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema14.java index 62aebea6bbd..6cbb3482bf1 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema14.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema14.java @@ -57,21 +57,21 @@ public abstract class ContainerSchema14< V12 extends SszData, V13 extends SszData> ContainerSchema14 create( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - SszSchema fieldSchema7, - SszSchema fieldSchema8, - SszSchema fieldSchema9, - SszSchema fieldSchema10, - SszSchema fieldSchema11, - SszSchema fieldSchema12, - SszSchema fieldSchema13, - BiFunction< + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final SszSchema fieldSchema8, + final SszSchema fieldSchema9, + final SszSchema fieldSchema10, + final SszSchema fieldSchema11, + final SszSchema fieldSchema12, + final SszSchema fieldSchema13, + final BiFunction< ContainerSchema14, TreeNode, C> @@ -92,27 +92,27 @@ ContainerSchema14 fieldSchema12, fieldSchema13) { @Override - public C createFromBackingNode(TreeNode node) { + public C createFromBackingNode(final TreeNode node) { return instanceCtor.apply(this, node); } }; } protected ContainerSchema14( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - SszSchema fieldSchema7, - SszSchema fieldSchema8, - SszSchema fieldSchema9, - SszSchema fieldSchema10, - SszSchema fieldSchema11, - SszSchema fieldSchema12, - SszSchema fieldSchema13) { + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final SszSchema fieldSchema8, + final SszSchema fieldSchema9, + final SszSchema fieldSchema10, + final SszSchema fieldSchema11, + final SszSchema fieldSchema12, + final SszSchema fieldSchema13) { super( List.of( @@ -133,21 +133,21 @@ protected ContainerSchema14( } protected ContainerSchema14( - String containerName, - NamedSchema fieldNamedSchema0, - NamedSchema fieldNamedSchema1, - NamedSchema fieldNamedSchema2, - NamedSchema fieldNamedSchema3, - NamedSchema fieldNamedSchema4, - NamedSchema fieldNamedSchema5, - NamedSchema fieldNamedSchema6, - NamedSchema fieldNamedSchema7, - NamedSchema fieldNamedSchema8, - NamedSchema fieldNamedSchema9, - NamedSchema fieldNamedSchema10, - NamedSchema fieldNamedSchema11, - NamedSchema fieldNamedSchema12, - NamedSchema fieldNamedSchema13) { + final String containerName, + final NamedSchema fieldNamedSchema0, + final NamedSchema fieldNamedSchema1, + final NamedSchema fieldNamedSchema2, + final NamedSchema fieldNamedSchema3, + final NamedSchema fieldNamedSchema4, + final NamedSchema fieldNamedSchema5, + final NamedSchema fieldNamedSchema6, + final NamedSchema fieldNamedSchema7, + final NamedSchema fieldNamedSchema8, + final NamedSchema fieldNamedSchema9, + final NamedSchema fieldNamedSchema10, + final NamedSchema fieldNamedSchema11, + final NamedSchema fieldNamedSchema12, + final NamedSchema fieldNamedSchema13) { super( containerName, diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema15.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema15.java index 494fcaf4ae1..5cadc27711e 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema15.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema15.java @@ -59,22 +59,22 @@ public abstract class ContainerSchema15< V13 extends SszData, V14 extends SszData> ContainerSchema15 create( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - SszSchema fieldSchema7, - SszSchema fieldSchema8, - SszSchema fieldSchema9, - SszSchema fieldSchema10, - SszSchema fieldSchema11, - SszSchema fieldSchema12, - SszSchema fieldSchema13, - SszSchema fieldSchema14, - BiFunction< + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final SszSchema fieldSchema8, + final SszSchema fieldSchema9, + final SszSchema fieldSchema10, + final SszSchema fieldSchema11, + final SszSchema fieldSchema12, + final SszSchema fieldSchema13, + final SszSchema fieldSchema14, + final BiFunction< ContainerSchema15< C, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14>, TreeNode, @@ -97,28 +97,28 @@ ContainerSchema15 fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - SszSchema fieldSchema7, - SszSchema fieldSchema8, - SszSchema fieldSchema9, - SszSchema fieldSchema10, - SszSchema fieldSchema11, - SszSchema fieldSchema12, - SszSchema fieldSchema13, - SszSchema fieldSchema14) { + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final SszSchema fieldSchema8, + final SszSchema fieldSchema9, + final SszSchema fieldSchema10, + final SszSchema fieldSchema11, + final SszSchema fieldSchema12, + final SszSchema fieldSchema13, + final SszSchema fieldSchema14) { super( List.of( @@ -140,22 +140,22 @@ protected ContainerSchema15( } protected ContainerSchema15( - String containerName, - NamedSchema fieldNamedSchema0, - NamedSchema fieldNamedSchema1, - NamedSchema fieldNamedSchema2, - NamedSchema fieldNamedSchema3, - NamedSchema fieldNamedSchema4, - NamedSchema fieldNamedSchema5, - NamedSchema fieldNamedSchema6, - NamedSchema fieldNamedSchema7, - NamedSchema fieldNamedSchema8, - NamedSchema fieldNamedSchema9, - NamedSchema fieldNamedSchema10, - NamedSchema fieldNamedSchema11, - NamedSchema fieldNamedSchema12, - NamedSchema fieldNamedSchema13, - NamedSchema fieldNamedSchema14) { + final String containerName, + final NamedSchema fieldNamedSchema0, + final NamedSchema fieldNamedSchema1, + final NamedSchema fieldNamedSchema2, + final NamedSchema fieldNamedSchema3, + final NamedSchema fieldNamedSchema4, + final NamedSchema fieldNamedSchema5, + final NamedSchema fieldNamedSchema6, + final NamedSchema fieldNamedSchema7, + final NamedSchema fieldNamedSchema8, + final NamedSchema fieldNamedSchema9, + final NamedSchema fieldNamedSchema10, + final NamedSchema fieldNamedSchema11, + final NamedSchema fieldNamedSchema12, + final NamedSchema fieldNamedSchema13, + final NamedSchema fieldNamedSchema14) { super( containerName, diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema16.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema16.java index 900b794c265..a5be24bd238 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema16.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema16.java @@ -62,23 +62,23 @@ public abstract class ContainerSchema16< V15 extends SszData> ContainerSchema16 create( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - SszSchema fieldSchema7, - SszSchema fieldSchema8, - SszSchema fieldSchema9, - SszSchema fieldSchema10, - SszSchema fieldSchema11, - SszSchema fieldSchema12, - SszSchema fieldSchema13, - SszSchema fieldSchema14, - SszSchema fieldSchema15, - BiFunction< + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final SszSchema fieldSchema8, + final SszSchema fieldSchema9, + final SszSchema fieldSchema10, + final SszSchema fieldSchema11, + final SszSchema fieldSchema12, + final SszSchema fieldSchema13, + final SszSchema fieldSchema14, + final SszSchema fieldSchema15, + final BiFunction< ContainerSchema16< C, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15>, TreeNode, @@ -102,29 +102,29 @@ public abstract class ContainerSchema16< fieldSchema14, fieldSchema15) { @Override - public C createFromBackingNode(TreeNode node) { + public C createFromBackingNode(final TreeNode node) { return instanceCtor.apply(this, node); } }; } protected ContainerSchema16( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - SszSchema fieldSchema7, - SszSchema fieldSchema8, - SszSchema fieldSchema9, - SszSchema fieldSchema10, - SszSchema fieldSchema11, - SszSchema fieldSchema12, - SszSchema fieldSchema13, - SszSchema fieldSchema14, - SszSchema fieldSchema15) { + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final SszSchema fieldSchema8, + final SszSchema fieldSchema9, + final SszSchema fieldSchema10, + final SszSchema fieldSchema11, + final SszSchema fieldSchema12, + final SszSchema fieldSchema13, + final SszSchema fieldSchema14, + final SszSchema fieldSchema15) { super( List.of( @@ -147,23 +147,23 @@ protected ContainerSchema16( } protected ContainerSchema16( - String containerName, - NamedSchema fieldNamedSchema0, - NamedSchema fieldNamedSchema1, - NamedSchema fieldNamedSchema2, - NamedSchema fieldNamedSchema3, - NamedSchema fieldNamedSchema4, - NamedSchema fieldNamedSchema5, - NamedSchema fieldNamedSchema6, - NamedSchema fieldNamedSchema7, - NamedSchema fieldNamedSchema8, - NamedSchema fieldNamedSchema9, - NamedSchema fieldNamedSchema10, - NamedSchema fieldNamedSchema11, - NamedSchema fieldNamedSchema12, - NamedSchema fieldNamedSchema13, - NamedSchema fieldNamedSchema14, - NamedSchema fieldNamedSchema15) { + final String containerName, + final NamedSchema fieldNamedSchema0, + final NamedSchema fieldNamedSchema1, + final NamedSchema fieldNamedSchema2, + final NamedSchema fieldNamedSchema3, + final NamedSchema fieldNamedSchema4, + final NamedSchema fieldNamedSchema5, + final NamedSchema fieldNamedSchema6, + final NamedSchema fieldNamedSchema7, + final NamedSchema fieldNamedSchema8, + final NamedSchema fieldNamedSchema9, + final NamedSchema fieldNamedSchema10, + final NamedSchema fieldNamedSchema11, + final NamedSchema fieldNamedSchema12, + final NamedSchema fieldNamedSchema13, + final NamedSchema fieldNamedSchema14, + final NamedSchema fieldNamedSchema15) { super( containerName, diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema17.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema17.java index 1e90ec03feb..31ade77fa42 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema17.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema17.java @@ -65,24 +65,24 @@ public abstract class ContainerSchema17< ContainerSchema17< C, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16> create( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - SszSchema fieldSchema7, - SszSchema fieldSchema8, - SszSchema fieldSchema9, - SszSchema fieldSchema10, - SszSchema fieldSchema11, - SszSchema fieldSchema12, - SszSchema fieldSchema13, - SszSchema fieldSchema14, - SszSchema fieldSchema15, - SszSchema fieldSchema16, - BiFunction< + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final SszSchema fieldSchema8, + final SszSchema fieldSchema9, + final SszSchema fieldSchema10, + final SszSchema fieldSchema11, + final SszSchema fieldSchema12, + final SszSchema fieldSchema13, + final SszSchema fieldSchema14, + final SszSchema fieldSchema15, + final SszSchema fieldSchema16, + final BiFunction< ContainerSchema17< C, V0, @@ -124,30 +124,30 @@ public abstract class ContainerSchema17< fieldSchema15, fieldSchema16) { @Override - public C createFromBackingNode(TreeNode node) { + public C createFromBackingNode(final TreeNode node) { return instanceCtor.apply(this, node); } }; } protected ContainerSchema17( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - SszSchema fieldSchema7, - SszSchema fieldSchema8, - SszSchema fieldSchema9, - SszSchema fieldSchema10, - SszSchema fieldSchema11, - SszSchema fieldSchema12, - SszSchema fieldSchema13, - SszSchema fieldSchema14, - SszSchema fieldSchema15, - SszSchema fieldSchema16) { + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final SszSchema fieldSchema8, + final SszSchema fieldSchema9, + final SszSchema fieldSchema10, + final SszSchema fieldSchema11, + final SszSchema fieldSchema12, + final SszSchema fieldSchema13, + final SszSchema fieldSchema14, + final SszSchema fieldSchema15, + final SszSchema fieldSchema16) { super( List.of( @@ -171,24 +171,24 @@ protected ContainerSchema17( } protected ContainerSchema17( - String containerName, - NamedSchema fieldNamedSchema0, - NamedSchema fieldNamedSchema1, - NamedSchema fieldNamedSchema2, - NamedSchema fieldNamedSchema3, - NamedSchema fieldNamedSchema4, - NamedSchema fieldNamedSchema5, - NamedSchema fieldNamedSchema6, - NamedSchema fieldNamedSchema7, - NamedSchema fieldNamedSchema8, - NamedSchema fieldNamedSchema9, - NamedSchema fieldNamedSchema10, - NamedSchema fieldNamedSchema11, - NamedSchema fieldNamedSchema12, - NamedSchema fieldNamedSchema13, - NamedSchema fieldNamedSchema14, - NamedSchema fieldNamedSchema15, - NamedSchema fieldNamedSchema16) { + final String containerName, + final NamedSchema fieldNamedSchema0, + final NamedSchema fieldNamedSchema1, + final NamedSchema fieldNamedSchema2, + final NamedSchema fieldNamedSchema3, + final NamedSchema fieldNamedSchema4, + final NamedSchema fieldNamedSchema5, + final NamedSchema fieldNamedSchema6, + final NamedSchema fieldNamedSchema7, + final NamedSchema fieldNamedSchema8, + final NamedSchema fieldNamedSchema9, + final NamedSchema fieldNamedSchema10, + final NamedSchema fieldNamedSchema11, + final NamedSchema fieldNamedSchema12, + final NamedSchema fieldNamedSchema13, + final NamedSchema fieldNamedSchema14, + final NamedSchema fieldNamedSchema15, + final NamedSchema fieldNamedSchema16) { super( containerName, diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema18.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema18.java index 3349f9f37c9..d3e320203c5 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema18.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema18.java @@ -67,25 +67,25 @@ public abstract class ContainerSchema18< ContainerSchema18< C, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17> create( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - SszSchema fieldSchema7, - SszSchema fieldSchema8, - SszSchema fieldSchema9, - SszSchema fieldSchema10, - SszSchema fieldSchema11, - SszSchema fieldSchema12, - SszSchema fieldSchema13, - SszSchema fieldSchema14, - SszSchema fieldSchema15, - SszSchema fieldSchema16, - SszSchema fieldSchema17, - BiFunction< + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final SszSchema fieldSchema8, + final SszSchema fieldSchema9, + final SszSchema fieldSchema10, + final SszSchema fieldSchema11, + final SszSchema fieldSchema12, + final SszSchema fieldSchema13, + final SszSchema fieldSchema14, + final SszSchema fieldSchema15, + final SszSchema fieldSchema16, + final SszSchema fieldSchema17, + final BiFunction< ContainerSchema18< C, V0, @@ -129,31 +129,31 @@ public abstract class ContainerSchema18< fieldSchema16, fieldSchema17) { @Override - public C createFromBackingNode(TreeNode node) { + public C createFromBackingNode(final TreeNode node) { return instanceCtor.apply(this, node); } }; } protected ContainerSchema18( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - SszSchema fieldSchema7, - SszSchema fieldSchema8, - SszSchema fieldSchema9, - SszSchema fieldSchema10, - SszSchema fieldSchema11, - SszSchema fieldSchema12, - SszSchema fieldSchema13, - SszSchema fieldSchema14, - SszSchema fieldSchema15, - SszSchema fieldSchema16, - SszSchema fieldSchema17) { + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final SszSchema fieldSchema8, + final SszSchema fieldSchema9, + final SszSchema fieldSchema10, + final SszSchema fieldSchema11, + final SszSchema fieldSchema12, + final SszSchema fieldSchema13, + final SszSchema fieldSchema14, + final SszSchema fieldSchema15, + final SszSchema fieldSchema16, + final SszSchema fieldSchema17) { super( List.of( @@ -178,25 +178,25 @@ protected ContainerSchema18( } protected ContainerSchema18( - String containerName, - NamedSchema fieldNamedSchema0, - NamedSchema fieldNamedSchema1, - NamedSchema fieldNamedSchema2, - NamedSchema fieldNamedSchema3, - NamedSchema fieldNamedSchema4, - NamedSchema fieldNamedSchema5, - NamedSchema fieldNamedSchema6, - NamedSchema fieldNamedSchema7, - NamedSchema fieldNamedSchema8, - NamedSchema fieldNamedSchema9, - NamedSchema fieldNamedSchema10, - NamedSchema fieldNamedSchema11, - NamedSchema fieldNamedSchema12, - NamedSchema fieldNamedSchema13, - NamedSchema fieldNamedSchema14, - NamedSchema fieldNamedSchema15, - NamedSchema fieldNamedSchema16, - NamedSchema fieldNamedSchema17) { + final String containerName, + final NamedSchema fieldNamedSchema0, + final NamedSchema fieldNamedSchema1, + final NamedSchema fieldNamedSchema2, + final NamedSchema fieldNamedSchema3, + final NamedSchema fieldNamedSchema4, + final NamedSchema fieldNamedSchema5, + final NamedSchema fieldNamedSchema6, + final NamedSchema fieldNamedSchema7, + final NamedSchema fieldNamedSchema8, + final NamedSchema fieldNamedSchema9, + final NamedSchema fieldNamedSchema10, + final NamedSchema fieldNamedSchema11, + final NamedSchema fieldNamedSchema12, + final NamedSchema fieldNamedSchema13, + final NamedSchema fieldNamedSchema14, + final NamedSchema fieldNamedSchema15, + final NamedSchema fieldNamedSchema16, + final NamedSchema fieldNamedSchema17) { super( containerName, diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema19.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema19.java index 13635008ca2..27bb6036fe2 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema19.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema19.java @@ -88,26 +88,26 @@ public abstract class ContainerSchema19< V17, V18> create( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - SszSchema fieldSchema7, - SszSchema fieldSchema8, - SszSchema fieldSchema9, - SszSchema fieldSchema10, - SszSchema fieldSchema11, - SszSchema fieldSchema12, - SszSchema fieldSchema13, - SszSchema fieldSchema14, - SszSchema fieldSchema15, - SszSchema fieldSchema16, - SszSchema fieldSchema17, - SszSchema fieldSchema18, - BiFunction< + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final SszSchema fieldSchema8, + final SszSchema fieldSchema9, + final SszSchema fieldSchema10, + final SszSchema fieldSchema11, + final SszSchema fieldSchema12, + final SszSchema fieldSchema13, + final SszSchema fieldSchema14, + final SszSchema fieldSchema15, + final SszSchema fieldSchema16, + final SszSchema fieldSchema17, + final SszSchema fieldSchema18, + final BiFunction< ContainerSchema19< C, V0, @@ -153,32 +153,32 @@ public abstract class ContainerSchema19< fieldSchema17, fieldSchema18) { @Override - public C createFromBackingNode(TreeNode node) { + public C createFromBackingNode(final TreeNode node) { return instanceCtor.apply(this, node); } }; } protected ContainerSchema19( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - SszSchema fieldSchema7, - SszSchema fieldSchema8, - SszSchema fieldSchema9, - SszSchema fieldSchema10, - SszSchema fieldSchema11, - SszSchema fieldSchema12, - SszSchema fieldSchema13, - SszSchema fieldSchema14, - SszSchema fieldSchema15, - SszSchema fieldSchema16, - SszSchema fieldSchema17, - SszSchema fieldSchema18) { + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final SszSchema fieldSchema8, + final SszSchema fieldSchema9, + final SszSchema fieldSchema10, + final SszSchema fieldSchema11, + final SszSchema fieldSchema12, + final SszSchema fieldSchema13, + final SszSchema fieldSchema14, + final SszSchema fieldSchema15, + final SszSchema fieldSchema16, + final SszSchema fieldSchema17, + final SszSchema fieldSchema18) { super( List.of( @@ -204,26 +204,26 @@ protected ContainerSchema19( } protected ContainerSchema19( - String containerName, - NamedSchema fieldNamedSchema0, - NamedSchema fieldNamedSchema1, - NamedSchema fieldNamedSchema2, - NamedSchema fieldNamedSchema3, - NamedSchema fieldNamedSchema4, - NamedSchema fieldNamedSchema5, - NamedSchema fieldNamedSchema6, - NamedSchema fieldNamedSchema7, - NamedSchema fieldNamedSchema8, - NamedSchema fieldNamedSchema9, - NamedSchema fieldNamedSchema10, - NamedSchema fieldNamedSchema11, - NamedSchema fieldNamedSchema12, - NamedSchema fieldNamedSchema13, - NamedSchema fieldNamedSchema14, - NamedSchema fieldNamedSchema15, - NamedSchema fieldNamedSchema16, - NamedSchema fieldNamedSchema17, - NamedSchema fieldNamedSchema18) { + final String containerName, + final NamedSchema fieldNamedSchema0, + final NamedSchema fieldNamedSchema1, + final NamedSchema fieldNamedSchema2, + final NamedSchema fieldNamedSchema3, + final NamedSchema fieldNamedSchema4, + final NamedSchema fieldNamedSchema5, + final NamedSchema fieldNamedSchema6, + final NamedSchema fieldNamedSchema7, + final NamedSchema fieldNamedSchema8, + final NamedSchema fieldNamedSchema9, + final NamedSchema fieldNamedSchema10, + final NamedSchema fieldNamedSchema11, + final NamedSchema fieldNamedSchema12, + final NamedSchema fieldNamedSchema13, + final NamedSchema fieldNamedSchema14, + final NamedSchema fieldNamedSchema15, + final NamedSchema fieldNamedSchema16, + final NamedSchema fieldNamedSchema17, + final NamedSchema fieldNamedSchema18) { super( containerName, diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema2.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema2.java index 9943defe138..e2f53db9d4f 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema2.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema2.java @@ -28,24 +28,26 @@ public abstract class ContainerSchema2< public static ContainerSchema2 create( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - BiFunction, TreeNode, C> instanceCtor) { + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final BiFunction, TreeNode, C> instanceCtor) { return new ContainerSchema2<>(fieldSchema0, fieldSchema1) { @Override - public C createFromBackingNode(TreeNode node) { + public C createFromBackingNode(final TreeNode node) { return instanceCtor.apply(this, node); } }; } - protected ContainerSchema2(SszSchema fieldSchema0, SszSchema fieldSchema1) { + protected ContainerSchema2(final SszSchema fieldSchema0, final SszSchema fieldSchema1) { super(List.of(fieldSchema0, fieldSchema1)); } protected ContainerSchema2( - String containerName, NamedSchema fieldNamedSchema0, NamedSchema fieldNamedSchema1) { + final String containerName, + final NamedSchema fieldNamedSchema0, + final NamedSchema fieldNamedSchema1) { super(containerName, List.of(fieldNamedSchema0, fieldNamedSchema1)); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema20.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema20.java new file mode 100644 index 00000000000..ee745725552 --- /dev/null +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema20.java @@ -0,0 +1,361 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.infrastructure.ssz.containers; + +import java.util.List; +import java.util.function.BiFunction; +import tech.pegasys.teku.infrastructure.ssz.SszContainer; +import tech.pegasys.teku.infrastructure.ssz.SszData; +import tech.pegasys.teku.infrastructure.ssz.schema.SszSchema; +import tech.pegasys.teku.infrastructure.ssz.schema.impl.AbstractSszContainerSchema; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; + +/** Autogenerated by tech.pegasys.teku.ssz.backing.ContainersGenerator */ +public abstract class ContainerSchema20< + C extends SszContainer, + V0 extends SszData, + V1 extends SszData, + V2 extends SszData, + V3 extends SszData, + V4 extends SszData, + V5 extends SszData, + V6 extends SszData, + V7 extends SszData, + V8 extends SszData, + V9 extends SszData, + V10 extends SszData, + V11 extends SszData, + V12 extends SszData, + V13 extends SszData, + V14 extends SszData, + V15 extends SszData, + V16 extends SszData, + V17 extends SszData, + V18 extends SszData, + V19 extends SszData> + extends AbstractSszContainerSchema { + + public static < + C extends SszContainer, + V0 extends SszData, + V1 extends SszData, + V2 extends SszData, + V3 extends SszData, + V4 extends SszData, + V5 extends SszData, + V6 extends SszData, + V7 extends SszData, + V8 extends SszData, + V9 extends SszData, + V10 extends SszData, + V11 extends SszData, + V12 extends SszData, + V13 extends SszData, + V14 extends SszData, + V15 extends SszData, + V16 extends SszData, + V17 extends SszData, + V18 extends SszData, + V19 extends SszData> + ContainerSchema20< + C, + V0, + V1, + V2, + V3, + V4, + V5, + V6, + V7, + V8, + V9, + V10, + V11, + V12, + V13, + V14, + V15, + V16, + V17, + V18, + V19> + create( + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final SszSchema fieldSchema8, + final SszSchema fieldSchema9, + final SszSchema fieldSchema10, + final SszSchema fieldSchema11, + final SszSchema fieldSchema12, + final SszSchema fieldSchema13, + final SszSchema fieldSchema14, + final SszSchema fieldSchema15, + final SszSchema fieldSchema16, + final SszSchema fieldSchema17, + final SszSchema fieldSchema18, + final SszSchema fieldSchema19, + final BiFunction< + ContainerSchema20< + C, + V0, + V1, + V2, + V3, + V4, + V5, + V6, + V7, + V8, + V9, + V10, + V11, + V12, + V13, + V14, + V15, + V16, + V17, + V18, + V19>, + TreeNode, + C> + instanceCtor) { + return new ContainerSchema20<>( + fieldSchema0, + fieldSchema1, + fieldSchema2, + fieldSchema3, + fieldSchema4, + fieldSchema5, + fieldSchema6, + fieldSchema7, + fieldSchema8, + fieldSchema9, + fieldSchema10, + fieldSchema11, + fieldSchema12, + fieldSchema13, + fieldSchema14, + fieldSchema15, + fieldSchema16, + fieldSchema17, + fieldSchema18, + fieldSchema19) { + @Override + public C createFromBackingNode(final TreeNode node) { + return instanceCtor.apply(this, node); + } + }; + } + + protected ContainerSchema20( + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final SszSchema fieldSchema8, + final SszSchema fieldSchema9, + final SszSchema fieldSchema10, + final SszSchema fieldSchema11, + final SszSchema fieldSchema12, + final SszSchema fieldSchema13, + final SszSchema fieldSchema14, + final SszSchema fieldSchema15, + final SszSchema fieldSchema16, + final SszSchema fieldSchema17, + final SszSchema fieldSchema18, + final SszSchema fieldSchema19) { + + super( + List.of( + fieldSchema0, + fieldSchema1, + fieldSchema2, + fieldSchema3, + fieldSchema4, + fieldSchema5, + fieldSchema6, + fieldSchema7, + fieldSchema8, + fieldSchema9, + fieldSchema10, + fieldSchema11, + fieldSchema12, + fieldSchema13, + fieldSchema14, + fieldSchema15, + fieldSchema16, + fieldSchema17, + fieldSchema18, + fieldSchema19)); + } + + protected ContainerSchema20( + final String containerName, + final NamedSchema fieldNamedSchema0, + final NamedSchema fieldNamedSchema1, + final NamedSchema fieldNamedSchema2, + final NamedSchema fieldNamedSchema3, + final NamedSchema fieldNamedSchema4, + final NamedSchema fieldNamedSchema5, + final NamedSchema fieldNamedSchema6, + final NamedSchema fieldNamedSchema7, + final NamedSchema fieldNamedSchema8, + final NamedSchema fieldNamedSchema9, + final NamedSchema fieldNamedSchema10, + final NamedSchema fieldNamedSchema11, + final NamedSchema fieldNamedSchema12, + final NamedSchema fieldNamedSchema13, + final NamedSchema fieldNamedSchema14, + final NamedSchema fieldNamedSchema15, + final NamedSchema fieldNamedSchema16, + final NamedSchema fieldNamedSchema17, + final NamedSchema fieldNamedSchema18, + final NamedSchema fieldNamedSchema19) { + + super( + containerName, + List.of( + fieldNamedSchema0, + fieldNamedSchema1, + fieldNamedSchema2, + fieldNamedSchema3, + fieldNamedSchema4, + fieldNamedSchema5, + fieldNamedSchema6, + fieldNamedSchema7, + fieldNamedSchema8, + fieldNamedSchema9, + fieldNamedSchema10, + fieldNamedSchema11, + fieldNamedSchema12, + fieldNamedSchema13, + fieldNamedSchema14, + fieldNamedSchema15, + fieldNamedSchema16, + fieldNamedSchema17, + fieldNamedSchema18, + fieldNamedSchema19)); + } + + @SuppressWarnings("unchecked") + public SszSchema getFieldSchema0() { + return (SszSchema) getChildSchema(0); + } + + @SuppressWarnings("unchecked") + public SszSchema getFieldSchema1() { + return (SszSchema) getChildSchema(1); + } + + @SuppressWarnings("unchecked") + public SszSchema getFieldSchema2() { + return (SszSchema) getChildSchema(2); + } + + @SuppressWarnings("unchecked") + public SszSchema getFieldSchema3() { + return (SszSchema) getChildSchema(3); + } + + @SuppressWarnings("unchecked") + public SszSchema getFieldSchema4() { + return (SszSchema) getChildSchema(4); + } + + @SuppressWarnings("unchecked") + public SszSchema getFieldSchema5() { + return (SszSchema) getChildSchema(5); + } + + @SuppressWarnings("unchecked") + public SszSchema getFieldSchema6() { + return (SszSchema) getChildSchema(6); + } + + @SuppressWarnings("unchecked") + public SszSchema getFieldSchema7() { + return (SszSchema) getChildSchema(7); + } + + @SuppressWarnings("unchecked") + public SszSchema getFieldSchema8() { + return (SszSchema) getChildSchema(8); + } + + @SuppressWarnings("unchecked") + public SszSchema getFieldSchema9() { + return (SszSchema) getChildSchema(9); + } + + @SuppressWarnings("unchecked") + public SszSchema getFieldSchema10() { + return (SszSchema) getChildSchema(10); + } + + @SuppressWarnings("unchecked") + public SszSchema getFieldSchema11() { + return (SszSchema) getChildSchema(11); + } + + @SuppressWarnings("unchecked") + public SszSchema getFieldSchema12() { + return (SszSchema) getChildSchema(12); + } + + @SuppressWarnings("unchecked") + public SszSchema getFieldSchema13() { + return (SszSchema) getChildSchema(13); + } + + @SuppressWarnings("unchecked") + public SszSchema getFieldSchema14() { + return (SszSchema) getChildSchema(14); + } + + @SuppressWarnings("unchecked") + public SszSchema getFieldSchema15() { + return (SszSchema) getChildSchema(15); + } + + @SuppressWarnings("unchecked") + public SszSchema getFieldSchema16() { + return (SszSchema) getChildSchema(16); + } + + @SuppressWarnings("unchecked") + public SszSchema getFieldSchema17() { + return (SszSchema) getChildSchema(17); + } + + @SuppressWarnings("unchecked") + public SszSchema getFieldSchema18() { + return (SszSchema) getChildSchema(18); + } + + @SuppressWarnings("unchecked") + public SszSchema getFieldSchema19() { + return (SszSchema) getChildSchema(19); + } +} diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema3.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema3.java index 5adb9a04bf2..9d5bfef2847 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema3.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema3.java @@ -28,29 +28,31 @@ public abstract class ContainerSchema3< public static ContainerSchema3 create( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - BiFunction, TreeNode, C> instanceCtor) { + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final BiFunction, TreeNode, C> instanceCtor) { return new ContainerSchema3<>(fieldSchema0, fieldSchema1, fieldSchema2) { @Override - public C createFromBackingNode(TreeNode node) { + public C createFromBackingNode(final TreeNode node) { return instanceCtor.apply(this, node); } }; } protected ContainerSchema3( - SszSchema fieldSchema0, SszSchema fieldSchema1, SszSchema fieldSchema2) { + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2) { super(List.of(fieldSchema0, fieldSchema1, fieldSchema2)); } protected ContainerSchema3( - String containerName, - NamedSchema fieldNamedSchema0, - NamedSchema fieldNamedSchema1, - NamedSchema fieldNamedSchema2) { + final String containerName, + final NamedSchema fieldNamedSchema0, + final NamedSchema fieldNamedSchema1, + final NamedSchema fieldNamedSchema2) { super(containerName, List.of(fieldNamedSchema0, fieldNamedSchema1, fieldNamedSchema2)); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema4.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema4.java index 1fa84b20020..a4841091709 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema4.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema4.java @@ -37,34 +37,34 @@ public abstract class ContainerSchema4< V2 extends SszData, V3 extends SszData> ContainerSchema4 create( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - BiFunction, TreeNode, C> instanceCtor) { + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final BiFunction, TreeNode, C> instanceCtor) { return new ContainerSchema4<>(fieldSchema0, fieldSchema1, fieldSchema2, fieldSchema3) { @Override - public C createFromBackingNode(TreeNode node) { + public C createFromBackingNode(final TreeNode node) { return instanceCtor.apply(this, node); } }; } protected ContainerSchema4( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3) { + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3) { super(List.of(fieldSchema0, fieldSchema1, fieldSchema2, fieldSchema3)); } protected ContainerSchema4( - String containerName, - NamedSchema fieldNamedSchema0, - NamedSchema fieldNamedSchema1, - NamedSchema fieldNamedSchema2, - NamedSchema fieldNamedSchema3) { + final String containerName, + final NamedSchema fieldNamedSchema0, + final NamedSchema fieldNamedSchema1, + final NamedSchema fieldNamedSchema2, + final NamedSchema fieldNamedSchema3) { super( containerName, diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema5.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema5.java index d8a98dca394..e8b4f355e1c 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema5.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema5.java @@ -39,38 +39,38 @@ public abstract class ContainerSchema5< V3 extends SszData, V4 extends SszData> ContainerSchema5 create( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - BiFunction, TreeNode, C> instanceCtor) { + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final BiFunction, TreeNode, C> instanceCtor) { return new ContainerSchema5<>( fieldSchema0, fieldSchema1, fieldSchema2, fieldSchema3, fieldSchema4) { @Override - public C createFromBackingNode(TreeNode node) { + public C createFromBackingNode(final TreeNode node) { return instanceCtor.apply(this, node); } }; } protected ContainerSchema5( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4) { + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4) { super(List.of(fieldSchema0, fieldSchema1, fieldSchema2, fieldSchema3, fieldSchema4)); } protected ContainerSchema5( - String containerName, - NamedSchema fieldNamedSchema0, - NamedSchema fieldNamedSchema1, - NamedSchema fieldNamedSchema2, - NamedSchema fieldNamedSchema3, - NamedSchema fieldNamedSchema4) { + final String containerName, + final NamedSchema fieldNamedSchema0, + final NamedSchema fieldNamedSchema1, + final NamedSchema fieldNamedSchema2, + final NamedSchema fieldNamedSchema3, + final NamedSchema fieldNamedSchema4) { super( containerName, diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema6.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema6.java index 4596fd79ba5..62f65265fcd 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema6.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema6.java @@ -41,29 +41,29 @@ public abstract class ContainerSchema6< V4 extends SszData, V5 extends SszData> ContainerSchema6 create( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - BiFunction, TreeNode, C> instanceCtor) { + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final BiFunction, TreeNode, C> instanceCtor) { return new ContainerSchema6<>( fieldSchema0, fieldSchema1, fieldSchema2, fieldSchema3, fieldSchema4, fieldSchema5) { @Override - public C createFromBackingNode(TreeNode node) { + public C createFromBackingNode(final TreeNode node) { return instanceCtor.apply(this, node); } }; } protected ContainerSchema6( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5) { + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5) { super( List.of( @@ -71,13 +71,13 @@ protected ContainerSchema6( } protected ContainerSchema6( - String containerName, - NamedSchema fieldNamedSchema0, - NamedSchema fieldNamedSchema1, - NamedSchema fieldNamedSchema2, - NamedSchema fieldNamedSchema3, - NamedSchema fieldNamedSchema4, - NamedSchema fieldNamedSchema5) { + final String containerName, + final NamedSchema fieldNamedSchema0, + final NamedSchema fieldNamedSchema1, + final NamedSchema fieldNamedSchema2, + final NamedSchema fieldNamedSchema3, + final NamedSchema fieldNamedSchema4, + final NamedSchema fieldNamedSchema5) { super( containerName, diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema7.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema7.java index 715f2027ff9..f82ce2672e9 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema7.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema7.java @@ -43,14 +43,15 @@ public abstract class ContainerSchema7< V5 extends SszData, V6 extends SszData> ContainerSchema7 create( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - BiFunction, TreeNode, C> instanceCtor) { + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final BiFunction, TreeNode, C> + instanceCtor) { return new ContainerSchema7<>( fieldSchema0, fieldSchema1, @@ -60,20 +61,20 @@ ContainerSchema7 create( fieldSchema5, fieldSchema6) { @Override - public C createFromBackingNode(TreeNode node) { + public C createFromBackingNode(final TreeNode node) { return instanceCtor.apply(this, node); } }; } protected ContainerSchema7( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6) { + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6) { super( List.of( @@ -87,14 +88,14 @@ protected ContainerSchema7( } protected ContainerSchema7( - String containerName, - NamedSchema fieldNamedSchema0, - NamedSchema fieldNamedSchema1, - NamedSchema fieldNamedSchema2, - NamedSchema fieldNamedSchema3, - NamedSchema fieldNamedSchema4, - NamedSchema fieldNamedSchema5, - NamedSchema fieldNamedSchema6) { + final String containerName, + final NamedSchema fieldNamedSchema0, + final NamedSchema fieldNamedSchema1, + final NamedSchema fieldNamedSchema2, + final NamedSchema fieldNamedSchema3, + final NamedSchema fieldNamedSchema4, + final NamedSchema fieldNamedSchema5, + final NamedSchema fieldNamedSchema6) { super( containerName, diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema8.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema8.java index 5c54b784a18..043d703314e 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema8.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema8.java @@ -45,15 +45,15 @@ public abstract class ContainerSchema8< V6 extends SszData, V7 extends SszData> ContainerSchema8 create( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - SszSchema fieldSchema7, - BiFunction, TreeNode, C> + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final BiFunction, TreeNode, C> instanceCtor) { return new ContainerSchema8<>( fieldSchema0, @@ -65,21 +65,21 @@ ContainerSchema8 create( fieldSchema6, fieldSchema7) { @Override - public C createFromBackingNode(TreeNode node) { + public C createFromBackingNode(final TreeNode node) { return instanceCtor.apply(this, node); } }; } protected ContainerSchema8( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - SszSchema fieldSchema7) { + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7) { super( List.of( @@ -94,15 +94,15 @@ protected ContainerSchema8( } protected ContainerSchema8( - String containerName, - NamedSchema fieldNamedSchema0, - NamedSchema fieldNamedSchema1, - NamedSchema fieldNamedSchema2, - NamedSchema fieldNamedSchema3, - NamedSchema fieldNamedSchema4, - NamedSchema fieldNamedSchema5, - NamedSchema fieldNamedSchema6, - NamedSchema fieldNamedSchema7) { + final String containerName, + final NamedSchema fieldNamedSchema0, + final NamedSchema fieldNamedSchema1, + final NamedSchema fieldNamedSchema2, + final NamedSchema fieldNamedSchema3, + final NamedSchema fieldNamedSchema4, + final NamedSchema fieldNamedSchema5, + final NamedSchema fieldNamedSchema6, + final NamedSchema fieldNamedSchema7) { super( containerName, diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema9.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema9.java index 187e0deb78b..acf42d48ec8 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema9.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/containers/ContainerSchema9.java @@ -47,16 +47,16 @@ public abstract class ContainerSchema9< V7 extends SszData, V8 extends SszData> ContainerSchema9 create( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - SszSchema fieldSchema7, - SszSchema fieldSchema8, - BiFunction, TreeNode, C> + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final SszSchema fieldSchema8, + final BiFunction, TreeNode, C> instanceCtor) { return new ContainerSchema9<>( fieldSchema0, @@ -69,22 +69,22 @@ ContainerSchema9 create( fieldSchema7, fieldSchema8) { @Override - public C createFromBackingNode(TreeNode node) { + public C createFromBackingNode(final TreeNode node) { return instanceCtor.apply(this, node); } }; } protected ContainerSchema9( - SszSchema fieldSchema0, - SszSchema fieldSchema1, - SszSchema fieldSchema2, - SszSchema fieldSchema3, - SszSchema fieldSchema4, - SszSchema fieldSchema5, - SszSchema fieldSchema6, - SszSchema fieldSchema7, - SszSchema fieldSchema8) { + final SszSchema fieldSchema0, + final SszSchema fieldSchema1, + final SszSchema fieldSchema2, + final SszSchema fieldSchema3, + final SszSchema fieldSchema4, + final SszSchema fieldSchema5, + final SszSchema fieldSchema6, + final SszSchema fieldSchema7, + final SszSchema fieldSchema8) { super( List.of( @@ -100,16 +100,16 @@ protected ContainerSchema9( } protected ContainerSchema9( - String containerName, - NamedSchema fieldNamedSchema0, - NamedSchema fieldNamedSchema1, - NamedSchema fieldNamedSchema2, - NamedSchema fieldNamedSchema3, - NamedSchema fieldNamedSchema4, - NamedSchema fieldNamedSchema5, - NamedSchema fieldNamedSchema6, - NamedSchema fieldNamedSchema7, - NamedSchema fieldNamedSchema8) { + final String containerName, + final NamedSchema fieldNamedSchema0, + final NamedSchema fieldNamedSchema1, + final NamedSchema fieldNamedSchema2, + final NamedSchema fieldNamedSchema3, + final NamedSchema fieldNamedSchema4, + final NamedSchema fieldNamedSchema5, + final NamedSchema fieldNamedSchema6, + final NamedSchema fieldNamedSchema7, + final NamedSchema fieldNamedSchema8) { super( containerName, diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/AbstractSszCollection.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/AbstractSszCollection.java index 3115771b4c6..d898d763b5b 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/AbstractSszCollection.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/AbstractSszCollection.java @@ -27,16 +27,18 @@ public abstract class AbstractSszCollection extends AbstractSszComposite implements SszCollection { protected AbstractSszCollection( - SszCompositeSchema schema, Supplier lazyBackingNode) { + final SszCompositeSchema schema, final Supplier lazyBackingNode) { super(schema, lazyBackingNode); } - protected AbstractSszCollection(SszCompositeSchema schema, TreeNode backingNode) { + protected AbstractSszCollection(final SszCompositeSchema schema, final TreeNode backingNode) { super(schema, backingNode); } protected AbstractSszCollection( - SszCompositeSchema schema, TreeNode backingNode, IntCache cache) { + final SszCompositeSchema schema, + final TreeNode backingNode, + final IntCache cache) { super(schema, backingNode, cache); } @@ -48,7 +50,7 @@ protected AbstractSszCollection( @SuppressWarnings("unchecked") @Override - protected SszElementT getImpl(int index) { + protected SszElementT getImpl(final int index) { SszCollectionSchema type = this.getSchema(); SszSchema elementType = type.getElementSchema(); if (elementType.isPrimitive()) { diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/AbstractSszComposite.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/AbstractSszComposite.java index 0940aadec30..3569b49d89b 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/AbstractSszComposite.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/AbstractSszComposite.java @@ -45,11 +45,12 @@ public abstract class AbstractSszComposite private final Supplier backingNode; /** Creates an instance from a schema and a backing node */ - protected AbstractSszComposite(SszCompositeSchema schema, Supplier lazyBackingNode) { + protected AbstractSszComposite( + final SszCompositeSchema schema, final Supplier lazyBackingNode) { this(schema, lazyBackingNode, Optional.empty()); } - protected AbstractSszComposite(SszCompositeSchema schema, TreeNode backingNode) { + protected AbstractSszComposite(final SszCompositeSchema schema, final TreeNode backingNode) { this(schema, () -> backingNode, Optional.empty()); } @@ -60,14 +61,16 @@ protected AbstractSszComposite(SszCompositeSchema schema, TreeNode backingNod * from backing nodes. The cache should correspond to the supplied backing tree. */ protected AbstractSszComposite( - SszCompositeSchema schema, TreeNode backingNode, IntCache cache) { + final SszCompositeSchema schema, + final TreeNode backingNode, + final IntCache cache) { this(schema, () -> backingNode, Optional.of(cache)); } protected AbstractSszComposite( - SszCompositeSchema schema, - Supplier lazyBackingNode, - Optional> cache) { + final SszCompositeSchema schema, + final Supplier lazyBackingNode, + final Optional> cache) { this.schema = schema; this.backingNode = Suppliers.memoize(lazyBackingNode::get); this.childrenViewCache = cache.orElseGet(this::createCache); @@ -92,11 +95,11 @@ protected IntCache createCache() { } @Override - public final SszChildT get(int index) { + public final SszChildT get(final int index) { return childrenViewCache.getInt(index, this::getImplWithIndexCheck); } - private SszChildT getImplWithIndexCheck(int index) { + private SszChildT getImplWithIndexCheck(final int index) { checkIndex(index); return getImpl(index); } @@ -133,7 +136,7 @@ public final int size() { protected abstract void checkIndex(int index); @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/AbstractSszImmutableContainer.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/AbstractSszImmutableContainer.java index 018ad18f086..24814aee630 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/AbstractSszImmutableContainer.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/AbstractSszImmutableContainer.java @@ -30,17 +30,19 @@ public abstract class AbstractSszImmutableContainer extends SszContainerImpl { protected AbstractSszImmutableContainer( - AbstractSszContainerSchema schema) { + final AbstractSszContainerSchema schema) { this(schema, schema.getDefaultTree()); } protected AbstractSszImmutableContainer( - SszContainerSchema schema, TreeNode backingNode) { + final SszContainerSchema schema, + final TreeNode backingNode) { super(schema, backingNode); } protected AbstractSszImmutableContainer( - SszContainerSchema schema, SszData... memberValues) { + final SszContainerSchema schema, + final SszData... memberValues) { super( schema, schema.createTreeFromFieldValues(Arrays.asList(memberValues)), @@ -59,7 +61,7 @@ protected AbstractSszImmutableContainer( } } - private static IntCache createCache(SszData... memberValues) { + private static IntCache createCache(final SszData... memberValues) { ArrayIntCache cache = new ArrayIntCache<>(memberValues.length); for (int i = 0; i < memberValues.length; i++) { cache.invalidateWithNewValue(i, memberValues[i]); @@ -79,7 +81,7 @@ public boolean isWritableSupported() { } @Override - public boolean equals(Object obj) { + public boolean equals(final Object obj) { if (Objects.isNull(obj)) { return false; } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/AbstractSszMutableCollection.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/AbstractSszMutableCollection.java index 5149ce13e63..03fbb16672a 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/AbstractSszMutableCollection.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/AbstractSszMutableCollection.java @@ -24,7 +24,8 @@ public abstract class AbstractSszMutableCollection< private final SszSchema elementSchema; - protected AbstractSszMutableCollection(AbstractSszComposite backingImmutableData) { + protected AbstractSszMutableCollection( + final AbstractSszComposite backingImmutableData) { super(backingImmutableData); elementSchema = getSchema().getElementSchema(); } @@ -40,7 +41,7 @@ private SszSchema getElementSchema() { } @Override - protected void validateChildSchema(int index, SszElementT value) { + protected void validateChildSchema(final int index, final SszElementT value) { if (!value.getSchema().equals(getElementSchema())) { throw new InvalidValueSchemaException( "Expected element to have schema " diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/AbstractSszMutableComposite.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/AbstractSszMutableComposite.java index 13a79b5fbda..55d499128bf 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/AbstractSszMutableComposite.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/AbstractSszMutableComposite.java @@ -58,17 +58,18 @@ public abstract class AbstractSszMutableComposite< private final SszCompositeSchema cachedSchema; private ChildChangeRecord createChangeRecordByValue( - SszChildT newValue) { + final SszChildT newValue) { return new ChildChangeRecord<>(newValue, null); } private ChildChangeRecord createChangeRecordByRef( - SszMutableChildT childRef) { + final SszMutableChildT childRef) { return new ChildChangeRecord<>(null, childRef); } /** Creates a new mutable instance with backing immutable data */ - protected AbstractSszMutableComposite(AbstractSszComposite backingImmutableData) { + protected AbstractSszMutableComposite( + final AbstractSszComposite backingImmutableData) { this.backingImmutableData = backingImmutableData; sizeCache = backingImmutableData.size(); cachedSchema = backingImmutableData.getSchema(); @@ -76,7 +77,7 @@ protected AbstractSszMutableComposite(AbstractSszComposite backingImm @Override @SuppressWarnings("unchecked") - public void set(int index, SszChildT value) { + public void set(final int index, final SszChildT value) { checkIndex(index, true); checkNotNull(value); validateChildSchema(index, value); @@ -94,7 +95,7 @@ public void set(int index, SszChildT value) { invalidate(); } - protected void validateChildSchema(int index, SszChildT value) { + protected void validateChildSchema(final int index, final SszChildT value) { if (!value.getSchema().equals(getSchema().getChildSchema(index))) { throw new InvalidValueSchemaException( "Expected child to have schema " @@ -105,7 +106,7 @@ protected void validateChildSchema(int index, SszChildT value) { } @Override - public SszChildT get(int index) { + public SszChildT get(final int index) { checkIndex(index, false); ChildChangeRecord changeRecord = childrenChanges.get(index); if (changeRecord == null) { @@ -118,7 +119,7 @@ public SszChildT get(int index) { } @Override - public SszMutableChildT getByRef(int index) { + public SszMutableChildT getByRef(final int index) { ChildChangeRecord changeRecord = childrenChanges.get(index); if (changeRecord != null && changeRecord.isByRef()) { return changeRecord.getRefValue(); @@ -186,13 +187,13 @@ public SszComposite commitChanges() { } } - protected TreeNode doFinalTreeUpdates(TreeNode updatedTree) { + protected TreeNode doFinalTreeUpdates(final TreeNode updatedTree) { return updatedTree; } /** Converts a set of changed view with their indices to the {@link TreeUpdates} instance */ protected TreeUpdates changesToNewNodes( - Stream> newChildValues, TreeNode original) { + final Stream> newChildValues, final TreeNode original) { SszCompositeSchema type = getSchema(); if (type.getElementsPerChunk() > 1) { throw new IllegalStateException( @@ -214,7 +215,7 @@ protected abstract AbstractSszComposite createImmutableSszComposite( TreeNode backingNode, IntCache viewCache); @Override - public void setInvalidator(Consumer listener) { + public void setInvalidator(final Consumer listener) { invalidator = listener; } @@ -244,7 +245,7 @@ private static final class ChildChangeRecord< private final SszChildT newValue; private final SszMutableChildT refValue; - private ChildChangeRecord(SszChildT newValue, SszMutableChildT refValue) { + private ChildChangeRecord(final SszChildT newValue, final SszMutableChildT refValue) { this.newValue = newValue; this.refValue = refValue; } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/AbstractSszPrimitive.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/AbstractSszPrimitive.java index 29772376a07..16e9408c903 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/AbstractSszPrimitive.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/AbstractSszPrimitive.java @@ -18,12 +18,11 @@ import tech.pegasys.teku.infrastructure.ssz.schema.impl.AbstractSszPrimitiveSchema; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; -public abstract class AbstractSszPrimitive> - implements SszPrimitive { - private final AbstractSszPrimitiveSchema schema; +public abstract class AbstractSszPrimitive implements SszPrimitive { + private final AbstractSszPrimitiveSchema schema; private final C value; - protected AbstractSszPrimitive(C value, AbstractSszPrimitiveSchema schema) { + protected AbstractSszPrimitive(final C value, final AbstractSszPrimitiveSchema schema) { this.schema = schema; this.value = value; } @@ -34,29 +33,24 @@ public C get() { } @Override - public AbstractSszPrimitiveSchema getSchema() { + public AbstractSszPrimitiveSchema getSchema() { return schema; } @Override public TreeNode getBackingNode() { - return getSchema().createBackingNode(getThis()); - } - - @SuppressWarnings("unchecked") - protected V getThis() { - return (V) this; + return getSchema().createBackingNode(this); } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } - AbstractSszPrimitive that = (AbstractSszPrimitive) o; + AbstractSszPrimitive that = (AbstractSszPrimitive) o; return Objects.equals(get(), that.get()); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszContainerImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszContainerImpl.java index fd6abdaca32..1429b6bf768 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszContainerImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszContainerImpl.java @@ -27,21 +27,21 @@ public class SszContainerImpl extends AbstractSszComposite implements SszContainer { - public SszContainerImpl(SszContainerSchema type) { + public SszContainerImpl(final SszContainerSchema type) { this(type, type.getDefaultTree()); } - public SszContainerImpl(SszContainerSchema type, TreeNode backingNode) { + public SszContainerImpl(final SszContainerSchema type, final TreeNode backingNode) { super(type, backingNode); } public SszContainerImpl( - SszCompositeSchema type, TreeNode backingNode, IntCache cache) { + final SszCompositeSchema type, final TreeNode backingNode, final IntCache cache) { super(type, backingNode, cache); } @Override - protected SszData getImpl(int index) { + protected SszData getImpl(final int index) { SszCompositeSchema type = this.getSchema(); TreeNode node = getBackingNode().get(type.getChildGeneralizedIndex(index)); return type.getChildSchema(index).createFromBackingNode(node); @@ -68,7 +68,7 @@ protected IntCache createCache() { } @Override - protected void checkIndex(int index) { + protected void checkIndex(final int index) { if (index >= size()) { throw new IndexOutOfBoundsException( "Invalid index " + index + " for container with size " + size()); diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszListImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszListImpl.java index e5e574c00f7..bca9aaa0981 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszListImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszListImpl.java @@ -32,16 +32,19 @@ public class SszListImpl extends AbstractSszCollection implements SszList { - protected SszListImpl(SszListSchema schema, Supplier lazyBackingNode) { + protected SszListImpl( + final SszListSchema schema, final Supplier lazyBackingNode) { super(schema, lazyBackingNode); } - public SszListImpl(SszListSchema schema, TreeNode backingNode) { + public SszListImpl(final SszListSchema schema, final TreeNode backingNode) { super(schema, backingNode); } public SszListImpl( - SszListSchema schema, TreeNode backingNode, IntCache cache) { + final SszListSchema schema, + final TreeNode backingNode, + final IntCache cache) { super(schema, backingNode, cache); } @@ -66,7 +69,7 @@ public SszMutableList createWritableCopy() { } @Override - protected void checkIndex(int index) { + protected void checkIndex(final int index) { if (index < 0 || index >= size()) { throw new IndexOutOfBoundsException( "Invalid index " + index + " for list with size " + size()); diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszMutableContainerImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszMutableContainerImpl.java index ca6178b0159..f1536658c91 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszMutableContainerImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszMutableContainerImpl.java @@ -25,13 +25,13 @@ public class SszMutableContainerImpl extends AbstractSszMutableComposite implements SszMutableRefContainer { - public SszMutableContainerImpl(SszContainerImpl backingImmutableView) { + public SszMutableContainerImpl(final SszContainerImpl backingImmutableView) { super(backingImmutableView); } @Override protected SszContainerImpl createImmutableSszComposite( - TreeNode backingNode, IntCache viewCache) { + final TreeNode backingNode, final IntCache viewCache) { return new SszContainerImpl(getSchema(), backingNode, viewCache); } @@ -52,7 +52,7 @@ public SszMutableContainer createWritableCopy() { } @Override - protected void checkIndex(int index, boolean set) { + protected void checkIndex(final int index, final boolean set) { if (index >= size()) { throw new IndexOutOfBoundsException( "Invalid index " + index + " for container with size " + size()); diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszMutableListImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszMutableListImpl.java index df6a8a53ddf..88ab58c6cbd 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszMutableListImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszMutableListImpl.java @@ -32,7 +32,7 @@ public class SszMutableListImpl backingImmutableList) { + public SszMutableListImpl(final SszListImpl backingImmutableList) { super(backingImmutableList); cachedSize = backingImmutableList.size(); cachedMaxLength = getSchema().getMaxLength(); @@ -40,12 +40,12 @@ public SszMutableListImpl(SszListImpl backingImmutableList) { @Override protected SszListImpl createImmutableSszComposite( - TreeNode backingNode, IntCache childrenCache) { + final TreeNode backingNode, final IntCache childrenCache) { return new SszListImpl<>(getSchema(), backingNode, childrenCache); } @Override - protected TreeNode doFinalTreeUpdates(TreeNode updatedTree) { + protected TreeNode doFinalTreeUpdates(final TreeNode updatedTree) { return updateSize(updatedTree); } @@ -54,7 +54,7 @@ public int size() { return cachedSize; } - private TreeNode updateSize(TreeNode root) { + private TreeNode updateSize(final TreeNode root) { return BranchNode.create(root.get(GIndexUtil.LEFT_CHILD_G_INDEX), createSizeNode()); } @@ -63,7 +63,7 @@ private TreeNode createSizeNode() { } @Override - public void set(int index, SszElementT value) { + public void set(final int index, final SszElementT value) { super.set(index, value); if (index == size()) { cachedSize++; @@ -77,7 +77,7 @@ public void clear() { } @Override - protected void checkIndex(int index, boolean set) { + protected void checkIndex(final int index, final boolean set) { if (index < 0 || (!set && index >= size()) || (set && (index > size() || index >= cachedMaxLength))) { diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszMutableVectorImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszMutableVectorImpl.java index 9be62fc5d32..695e14b412f 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszMutableVectorImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszMutableVectorImpl.java @@ -26,13 +26,13 @@ public class SszMutableVectorImpl< extends AbstractSszMutableCollection implements SszMutableRefVector { - public SszMutableVectorImpl(AbstractSszComposite backingImmutableData) { + public SszMutableVectorImpl(final AbstractSszComposite backingImmutableData) { super(backingImmutableData); } @Override protected AbstractSszComposite createImmutableSszComposite( - TreeNode backingNode, IntCache childrenCache) { + final TreeNode backingNode, final IntCache childrenCache) { return new SszVectorImpl<>(getSchema(), backingNode, childrenCache); } @@ -49,7 +49,7 @@ public SszVector commitChanges() { } @Override - protected void checkIndex(int index, boolean set) { + protected void checkIndex(final int index, final boolean set) { if (index < 0 || index >= size()) { throw new IndexOutOfBoundsException( "Invalid index " + index + " for vector with size " + size()); diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszOptionalImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszOptionalImpl.java index 13502571091..b1bfbc8af7b 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszOptionalImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszOptionalImpl.java @@ -62,7 +62,7 @@ private Optional createValue() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszUnionImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszUnionImpl.java index 41b556e918b..b1bc927d255 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszUnionImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszUnionImpl.java @@ -29,7 +29,7 @@ public class SszUnionImpl implements SszUnion { private final Supplier value = Suppliers.memoize(this::createValue); private final Supplier selector = Suppliers.memoize(this::createSelector); - public SszUnionImpl(SszUnionSchemaImpl schema, TreeNode backingNode) { + public SszUnionImpl(final SszUnionSchemaImpl schema, final TreeNode backingNode) { this.schema = schema; this.backingNode = backingNode; } @@ -65,7 +65,7 @@ private int createSelector() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszUtils.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszUtils.java index 956e77995eb..9435f6675c3 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszUtils.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszUtils.java @@ -32,24 +32,26 @@ public class SszUtils { public static SszList toSszList( - SszSchema> type, Iterable list, Function converter) { + final SszSchema> type, + final Iterable list, + final Function converter) { return toSszList(type, Streams.stream(list).map(converter).toList()); } public static SszList toSszList( - SszSchema> type, Iterable list) { + final SszSchema> type, final Iterable list) { SszMutableList ret = type.getDefault().createWritableCopy(); list.forEach(ret::append); return ret.commitChanges(); } public static SszVector toSszVector( - SszVectorSchema type, Iterable list, Function converter) { + final SszVectorSchema type, final Iterable list, final Function converter) { return toSszVector(type, Streams.stream(list).map(converter).toList()); } public static SszVector toSszVector( - SszVectorSchema type, Iterable list) { + final SszVectorSchema type, final Iterable list) { SszMutableVector ret = type.getDefault().createWritableCopy(); int idx = 0; for (V v : list) { @@ -62,12 +64,13 @@ public static SszVector toSszVector( return ret.commitChanges(); } - public static SszList toSszByteList(SszListSchema type, Bytes bytes) { + public static SszList toSszByteList( + final SszListSchema type, final Bytes bytes) { return type.sszDeserialize(SszReader.fromBytes(bytes)); } /** Retrieve bytes from vector of bytes to a {@link Bytes} instance */ - public static Bytes getAllBytes(SszCollection vector) { + public static Bytes getAllBytes(final SszCollection vector) { return vector.sszSerialize(); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszVectorImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszVectorImpl.java index 720433bc223..ad9fb510ef9 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszVectorImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/impl/SszVectorImpl.java @@ -27,16 +27,19 @@ public class SszVectorImpl extends AbstractSszCollection implements SszVector { - public SszVectorImpl(SszCompositeSchema schema, Supplier lazyBackingNode) { + public SszVectorImpl( + final SszCompositeSchema schema, final Supplier lazyBackingNode) { super(schema, lazyBackingNode); } - public SszVectorImpl(SszCompositeSchema schema, TreeNode backingNode) { + public SszVectorImpl(final SszCompositeSchema schema, final TreeNode backingNode) { super(schema, backingNode); } public SszVectorImpl( - SszCompositeSchema schema, TreeNode backingNode, IntCache cache) { + final SszCompositeSchema schema, + final TreeNode backingNode, + final IntCache cache) { super(schema, backingNode, cache); } @@ -62,7 +65,7 @@ protected IntCache createCache() { } @Override - protected void checkIndex(int index) { + protected void checkIndex(final int index) { if (index < 0 || index >= size()) { throw new IndexOutOfBoundsException( "Invalid index " + index + " for vector with size " + size()); diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszBit.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszBit.java index 89f4d9e8013..e151178f30b 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszBit.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszBit.java @@ -16,16 +16,16 @@ import tech.pegasys.teku.infrastructure.ssz.impl.AbstractSszPrimitive; import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; -public class SszBit extends AbstractSszPrimitive { +public class SszBit extends AbstractSszPrimitive { private static final SszBit TRUE_VIEW = new SszBit(true); private static final SszBit FALSE_VIEW = new SszBit(false); - public static SszBit of(boolean value) { + public static SszBit of(final boolean value) { return value ? TRUE_VIEW : FALSE_VIEW; } - private SszBit(Boolean value) { + private SszBit(final Boolean value) { super(value, SszPrimitiveSchemas.BIT_SCHEMA); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszByte.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszByte.java index 14aea6880cd..c3988cb8f87 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszByte.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszByte.java @@ -17,27 +17,27 @@ import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; import tech.pegasys.teku.infrastructure.ssz.schema.impl.AbstractSszPrimitiveSchema; -public class SszByte extends AbstractSszPrimitive { +public class SszByte extends AbstractSszPrimitive { public static final SszByte ZERO = SszByte.of(0); - public static SszByte of(int value) { + public static SszByte of(final int value) { return new SszByte((byte) value); } - public static SszByte asUInt8(int value) { + public static SszByte asUInt8(final int value) { return new SszByte((byte) value, SszPrimitiveSchemas.UINT8_SCHEMA); } - public static SszByte of(byte value) { + public static SszByte of(final byte value) { return new SszByte(value); } - private SszByte(Byte value) { + private SszByte(final Byte value) { this(value, SszPrimitiveSchemas.BYTE_SCHEMA); } - private SszByte(Byte value, AbstractSszPrimitiveSchema schema) { + private SszByte(final Byte value, final AbstractSszPrimitiveSchema schema) { super(value, schema); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszBytes32.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszBytes32.java index 1f854c0647b..a37cf210753 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszBytes32.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszBytes32.java @@ -17,13 +17,13 @@ import tech.pegasys.teku.infrastructure.ssz.impl.AbstractSszPrimitive; import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; -public class SszBytes32 extends AbstractSszPrimitive { +public class SszBytes32 extends AbstractSszPrimitive { - public static SszBytes32 of(Bytes32 val) { + public static SszBytes32 of(final Bytes32 val) { return new SszBytes32(val); } - private SszBytes32(Bytes32 val) { + private SszBytes32(final Bytes32 val) { super(val, SszPrimitiveSchemas.BYTES32_SCHEMA); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszBytes4.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszBytes4.java index 0245843a54f..e64a624a3e1 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszBytes4.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszBytes4.java @@ -17,13 +17,13 @@ import tech.pegasys.teku.infrastructure.ssz.impl.AbstractSszPrimitive; import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; -public class SszBytes4 extends AbstractSszPrimitive { +public class SszBytes4 extends AbstractSszPrimitive { - public static SszBytes4 of(Bytes4 val) { + public static SszBytes4 of(final Bytes4 val) { return new SszBytes4(val); } - private SszBytes4(Bytes4 val) { + private SszBytes4(final Bytes4 val) { super(val, SszPrimitiveSchemas.BYTES4_SCHEMA); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszNone.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszNone.java index 8096b09f0db..e8f53d56813 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszNone.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszNone.java @@ -16,7 +16,7 @@ import tech.pegasys.teku.infrastructure.ssz.impl.AbstractSszPrimitive; import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; -public class SszNone extends AbstractSszPrimitive { +public class SszNone extends AbstractSszPrimitive { public static final SszNone INSTANCE = new SszNone(); diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszUInt256.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszUInt256.java index 2972b7617cd..ac5d0e66843 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszUInt256.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszUInt256.java @@ -17,15 +17,15 @@ import tech.pegasys.teku.infrastructure.ssz.impl.AbstractSszPrimitive; import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; -public class SszUInt256 extends AbstractSszPrimitive { +public class SszUInt256 extends AbstractSszPrimitive { public static final SszUInt256 ZERO = SszUInt256.of(UInt256.ZERO); - public static SszUInt256 of(UInt256 val) { + public static SszUInt256 of(final UInt256 val) { return new SszUInt256(val); } - private SszUInt256(UInt256 val) { + private SszUInt256(final UInt256 val) { super(val, SszPrimitiveSchemas.UINT256_SCHEMA); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszUInt64.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszUInt64.java index 39a2b77aead..6b7e1a772ce 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszUInt64.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/primitive/SszUInt64.java @@ -15,9 +15,10 @@ import tech.pegasys.teku.infrastructure.ssz.impl.AbstractSszPrimitive; import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; +import tech.pegasys.teku.infrastructure.ssz.schema.impl.AbstractSszUInt64Schema; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -public class SszUInt64 extends AbstractSszPrimitive { +public class SszUInt64 extends AbstractSszPrimitive { public static final SszUInt64 ZERO = new SszUInt64(UInt64.ZERO); public static final SszUInt64 THIRTY_TWO_ETH = new SszUInt64(UInt64.THIRTY_TWO_ETH); @@ -40,6 +41,10 @@ private SszUInt64(final UInt64 val) { super(val, SszPrimitiveSchemas.UINT64_SCHEMA); } + protected SszUInt64(final UInt64 val, final AbstractSszUInt64Schema schema) { + super(val, schema); + } + public long longValue() { return get().longValue(); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszCollectionSchema.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszCollectionSchema.java index 91d2c7dfbfb..3b672c40c10 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszCollectionSchema.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszCollectionSchema.java @@ -32,29 +32,33 @@ public interface SszCollectionSchema< @Override default void storeChildNode( - TreeNodeStore nodeStore, int maxBranchLevelsSkipped, long gIndex, TreeNode node) { + final TreeNodeStore nodeStore, + final int maxBranchLevelsSkipped, + final long gIndex, + final TreeNode node) { getElementSchema().storeBackingNodes(nodeStore, maxBranchLevelsSkipped, gIndex, node); } @SuppressWarnings("unchecked") - default SszCollectionT of(SszElementT... elements) { + default SszCollectionT of(final SszElementT... elements) { return createFromElements(List.of(elements)); } - @SuppressWarnings("unchecked") - default SszCollectionT createFromElements(List elements) { + default SszCollectionT createFromElements(final List elements) { + return createFromBackingNode(createTreeFromElements(elements)); + } + + default TreeNode createTreeFromElements(final List elements) { + // TODO: probably suboptimal method implementation: + // This is a generic implementation which works for both Vector and List but it potentially + // could do better if construct the tree directly in List/Vector subclasses checkArgument(elements.size() <= getMaxLength(), "Too many elements for this collection type"); SszMutableComposite writableCopy = getDefault().createWritableCopy(); int idx = 0; for (SszElementT element : elements) { writableCopy.set(idx++, element); } - return (SszCollectionT) writableCopy.commitChanges(); - } - - default TreeNode createTreeFromElements(List elements) { - // TODO: suboptimal - return createFromElements(elements).getBackingNode(); + return writableCopy.commitChanges().getBackingNode(); } default Collector collector() { diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszCompositeSchema.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszCompositeSchema.java index 502e69ca352..4b13f2bc5ca 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszCompositeSchema.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszCompositeSchema.java @@ -60,7 +60,7 @@ default long maxChunks() { * Returns then number of chunks (i.e. leaf nodes) to store {@code elementCount} child elements * Returns a number lower than {@code elementCode} only in case of packed basic types collection */ - default int getChunks(int elementCount) { + default int getChunks(final int elementCount) { return (elementCount - 1) / getElementsPerChunk() + 1; } @@ -79,7 +79,7 @@ default long treeWidth() { * * @see TreeNode#get(long) */ - default long getChildGeneralizedIndex(long elementIndex) { + default long getChildGeneralizedIndex(final long elementIndex) { return GIndexUtil.gIdxChildGIndex(GIndexUtil.SELF_G_INDEX, elementIndex, treeDepth()); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszContainerSchema.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszContainerSchema.java index dc12fede765..1667ccadc4a 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszContainerSchema.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszContainerSchema.java @@ -38,8 +38,8 @@ public interface SszContainerSchema extends SszComposite * constructor */ static SszContainerSchema create( - List> childrenSchemas, - BiFunction, TreeNode, C> instanceCtor) { + final List> childrenSchemas, + final BiFunction, TreeNode, C> instanceCtor) { return new AbstractSszContainerSchema(childrenSchemas) { @Override public C createFromBackingNode(TreeNode node) { @@ -49,9 +49,9 @@ public C createFromBackingNode(TreeNode node) { } static SszContainerSchema create( - String containerName, - List> childrenSchemas, - BiFunction, TreeNode, C> instanceCtor) { + final String containerName, + final List> childrenSchemas, + final BiFunction, TreeNode, C> instanceCtor) { return new AbstractSszContainerSchema(containerName, childrenSchemas) { @Override public C createFromBackingNode(TreeNode node) { @@ -74,7 +74,7 @@ public C createFromBackingNode(TreeNode node) { * @param fieldName * @return The index if it exists, otherwise -1 */ - default int getFieldIndex(SszFieldName fieldName) { + default int getFieldIndex(final SszFieldName fieldName) { return getFieldIndex(fieldName.getSszFieldName()); } @@ -90,7 +90,7 @@ default int getFieldIndex(SszFieldName fieldName) { * * @throws IllegalArgumentException if value types doesn't match this scheme field types */ - default C createFromFieldValues(List fieldValues) { + default C createFromFieldValues(final List fieldValues) { return createFromBackingNode(createTreeFromFieldValues(fieldValues)); } @@ -111,7 +111,8 @@ default void storeChildNode( } @Override - default TreeNode loadBackingNodes(TreeNodeSource nodeSource, Bytes32 rootHash, long rootGIndex) { + default TreeNode loadBackingNodes( + final TreeNodeSource nodeSource, final Bytes32 rootHash, final long rootGIndex) { final long lastUsefulGIndex = GIndexUtil.gIdxChildGIndex(rootGIndex, maxChunks() - 1, treeDepth()); return LoadingUtil.loadNodesToDepth( diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszListSchema.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszListSchema.java index 1e567f6226e..4585be7b4b8 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszListSchema.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszListSchema.java @@ -29,14 +29,16 @@ public interface SszListSchema SszListSchema> create( - SszSchema elementSchema, long maxLength) { + final SszSchema elementSchema, final long maxLength) { return create(elementSchema, maxLength, SszSchemaHints.none()); } @SuppressWarnings("unchecked") static SszListSchema> create( - SszSchema elementSchema, long maxLength, SszSchemaHints hints) { + final SszSchema elementSchema, + final long maxLength, + final SszSchemaHints hints) { checkArgument(maxLength >= 0 && maxLength <= MAX_LIST_MAX_LENGTH); if (elementSchema instanceof SszPrimitiveSchema) { return (SszListSchema) diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszPrimitiveSchema.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszPrimitiveSchema.java index a30002d8acb..37ad7d1e12a 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszPrimitiveSchema.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszPrimitiveSchema.java @@ -17,7 +17,7 @@ import tech.pegasys.teku.infrastructure.ssz.SszPrimitive; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; -public interface SszPrimitiveSchema> +public interface SszPrimitiveSchema> extends SszSchema { int getBitsSize(); @@ -34,7 +34,7 @@ default boolean isPrimitive() { * index'. For example in `Bitvector(512)` the bit value at index `300` is stored at the second * leaf node and it's 'internal index' in this node would be `45` */ - default SszDataT createFromPackedNode(TreeNode node, int internalIndex) { + default SszDataT createFromPackedNode(final TreeNode node, final int internalIndex) { return boxed(createFromPackedNodeUnboxed(node, internalIndex)); } @@ -47,12 +47,12 @@ default SszDataT createFromPackedNode(TreeNode node, int internalIndex) { */ TreeNode updatePackedNode(TreeNode srcNode, List> updates); - final class PackedNodeUpdate> { + final class PackedNodeUpdate> { private final int internalIndex; private final SszDataT newValue; - public PackedNodeUpdate(int internalIndex, SszDataT newValue) { + public PackedNodeUpdate(final int internalIndex, final SszDataT newValue) { this.internalIndex = internalIndex; this.newValue = newValue; } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszPrimitiveSchemas.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszPrimitiveSchemas.java index 9223e9d1317..fd78242bcab 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszPrimitiveSchemas.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszPrimitiveSchemas.java @@ -19,14 +19,9 @@ import static tech.pegasys.teku.infrastructure.ssz.schema.json.SszPrimitiveTypeDefinitions.SSZ_BYTES4_TYPE_DEFINITION; import static tech.pegasys.teku.infrastructure.ssz.schema.json.SszPrimitiveTypeDefinitions.SSZ_NONE_TYPE_DEFINITION; import static tech.pegasys.teku.infrastructure.ssz.schema.json.SszPrimitiveTypeDefinitions.SSZ_UINT256_TYPE_DEFINITION; -import static tech.pegasys.teku.infrastructure.ssz.schema.json.SszPrimitiveTypeDefinitions.SSZ_UINT64_TYPE_DEFINITION; -import java.nio.ByteOrder; -import java.util.Arrays; -import java.util.List; import org.apache.tuweni.bytes.Bytes; import org.apache.tuweni.bytes.Bytes32; -import org.apache.tuweni.bytes.MutableBytes; import org.apache.tuweni.units.bigints.UInt256; import tech.pegasys.teku.infrastructure.bytes.Bytes4; import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; @@ -39,6 +34,7 @@ import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt256; import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; import tech.pegasys.teku.infrastructure.ssz.schema.impl.AbstractSszPrimitiveSchema; +import tech.pegasys.teku.infrastructure.ssz.schema.impl.AbstractSszUInt64Schema; import tech.pegasys.teku.infrastructure.ssz.schema.json.SszPrimitiveTypeDefinitions; import tech.pegasys.teku.infrastructure.ssz.sos.SszDeserializeException; import tech.pegasys.teku.infrastructure.ssz.tree.LeafDataNode; @@ -52,18 +48,18 @@ public final class SszPrimitiveSchemas { public static final AbstractSszPrimitiveSchema NONE_SCHEMA = new AbstractSszPrimitiveSchema<>(0) { @Override - public Void createFromLeafBackingNode(LeafDataNode node, int internalIndex) { + public Void createFromLeafBackingNode(final LeafDataNode node, final int internalIndex) { return null; } @Override protected TreeNode updateBackingNode( - TreeNode srcNode, int internalIndex, SszData newValue) { + final TreeNode srcNode, final int internalIndex, final SszData newValue) { return srcNode; } @Override - public SszNone boxed(Void rawValue) { + public SszNone boxed(final Void rawValue) { return SszNone.INSTANCE; } @@ -86,12 +82,13 @@ public String toString() { public static final AbstractSszPrimitiveSchema BIT_SCHEMA = new AbstractSszPrimitiveSchema<>(1) { @Override - public Boolean createFromLeafBackingNode(LeafDataNode node, int idx) { + public Boolean createFromLeafBackingNode(final LeafDataNode node, final int idx) { return (node.getData().get(idx / 8) & (1 << (idx % 8))) != 0; } @Override - public TreeNode updateBackingNode(TreeNode srcNode, int idx, SszData newValue) { + public TreeNode updateBackingNode( + final TreeNode srcNode, final int idx, final SszData newValue) { int byteIndex = idx / 8; int bitIndex = idx % 8; Bytes originalBytes = ((LeafNode) srcNode).getData(); @@ -107,7 +104,7 @@ public TreeNode updateBackingNode(TreeNode srcNode, int idx, SszData newValue) { } @Override - public SszBit boxed(Boolean rawValue) { + public SszBit boxed(final Boolean rawValue) { return SszBit.of(rawValue); } @@ -162,103 +159,33 @@ public String toString() { } }; - public static final AbstractSszPrimitiveSchema UINT64_SCHEMA = - new AbstractSszPrimitiveSchema<>(64) { - @Override - public UInt64 createFromLeafBackingNode(LeafDataNode node, int internalIndex) { - Bytes leafNodeBytes = node.getData(); - try { - Bytes elementBytes = leafNodeBytes.slice(internalIndex * 8, 8); - return UInt64.fromLongBits(elementBytes.toLong(ByteOrder.LITTLE_ENDIAN)); - } catch (Exception e) { - // additional info to track down the bug https://github.com/PegaSysEng/teku/issues/2579 - String info = - "Refer to https://github.com/PegaSysEng/teku/issues/2579 if see this exception. "; - info += "internalIndex = " + internalIndex; - info += ", leafNodeBytes: " + leafNodeBytes.getClass().getSimpleName(); - try { - info += ", leafNodeBytes = " + leafNodeBytes.copy(); - } catch (Exception ex) { - info += "(" + ex + ")"; - } - try { - info += ", leafNodeBytes[] = " + Arrays.toString(leafNodeBytes.toArray()); - } catch (Exception ex) { - info += "(" + ex + ")"; - } - throw new RuntimeException(info, e); - } - } - - @Override - public TreeNode updateBackingNode(TreeNode srcNode, int index, SszData newValue) { - Bytes uintBytes = - Bytes.ofUnsignedLong(((SszUInt64) newValue).longValue(), ByteOrder.LITTLE_ENDIAN); - Bytes curVal = ((LeafNode) srcNode).getData(); - Bytes newBytes = updateExtending(curVal, index * 8, uintBytes); - return LeafNode.create(newBytes); - } - - @Override - public TreeNode updatePackedNode( - TreeNode srcNode, List> updates) { - if (updates.size() == 4) { - byte[] data = new byte[32]; - for (int i = 0; i < 4; i++) { - long longValue = updates.get(i).getNewValue().longValue(); - int off = i * 8; - data[off + 0] = (byte) longValue; - data[off + 1] = (byte) (longValue >> 8); - data[off + 2] = (byte) (longValue >> 16); - data[off + 3] = (byte) (longValue >> 24); - data[off + 4] = (byte) (longValue >> 32); - data[off + 5] = (byte) (longValue >> 40); - data[off + 6] = (byte) (longValue >> 48); - data[off + 7] = (byte) (longValue >> 56); - } - return LeafNode.create(Bytes.wrap(data)); - } else { - return super.updatePackedNode(srcNode, updates); - } - } + ; + public static final AbstractSszPrimitiveSchema UINT64_SCHEMA = + new AbstractSszUInt64Schema<>() { @Override - public SszUInt64 boxed(UInt64 rawValue) { + public SszUInt64 boxed(final UInt64 rawValue) { return SszUInt64.of(rawValue); } - - @Override - public TreeNode getDefaultTree() { - return LeafNode.ZERO_LEAVES[8]; - } - - @Override - public DeserializableTypeDefinition getJsonTypeDefinition() { - return SSZ_UINT64_TYPE_DEFINITION; - } - - @Override - public String toString() { - return "UInt64"; - } }; public static final AbstractSszPrimitiveSchema UINT256_SCHEMA = new AbstractSszPrimitiveSchema<>(256) { @Override - public UInt256 createFromLeafBackingNode(LeafDataNode node, int internalIndex) { + public UInt256 createFromLeafBackingNode(final LeafDataNode node, final int internalIndex) { // reverse() is due to LE -> BE conversion return UInt256.fromBytes(node.getData().reverse()); } @Override - public TreeNode updateBackingNode(TreeNode srcNode, int internalIndex, SszData newValue) { + public TreeNode updateBackingNode( + final TreeNode srcNode, final int internalIndex, final SszData newValue) { // reverse() is due to BE -> LE conversion return LeafNode.create(((SszUInt256) newValue).get().toBytes().reverse()); } @Override - public SszUInt256 boxed(UInt256 rawValue) { + public SszUInt256 boxed(final UInt256 rawValue) { return SszUInt256.of(rawValue); } @@ -281,12 +208,13 @@ public String toString() { public static final AbstractSszPrimitiveSchema BYTES4_SCHEMA = new AbstractSszPrimitiveSchema<>(32) { @Override - public Bytes4 createFromLeafBackingNode(LeafDataNode node, int internalIndex) { + public Bytes4 createFromLeafBackingNode(final LeafDataNode node, final int internalIndex) { return new Bytes4(node.getData().slice(internalIndex * 4, 4)); } @Override - public TreeNode updateBackingNode(TreeNode srcNode, int internalIndex, SszData newValue) { + public TreeNode updateBackingNode( + final TreeNode srcNode, final int internalIndex, final SszData newValue) { checkArgument( internalIndex >= 0 && internalIndex < 8, "Invalid internal index: %s", internalIndex); Bytes bytes = ((SszBytes4) newValue).get().getWrappedBytes(); @@ -296,7 +224,7 @@ public TreeNode updateBackingNode(TreeNode srcNode, int internalIndex, SszData n } @Override - public SszBytes4 boxed(Bytes4 rawValue) { + public SszBytes4 boxed(final Bytes4 rawValue) { return SszBytes4.of(rawValue); } @@ -319,17 +247,18 @@ public String toString() { public static final AbstractSszPrimitiveSchema BYTES32_SCHEMA = new AbstractSszPrimitiveSchema<>(256) { @Override - public Bytes32 createFromLeafBackingNode(LeafDataNode node, int internalIndex) { + public Bytes32 createFromLeafBackingNode(final LeafDataNode node, final int internalIndex) { return node.hashTreeRoot(); } @Override - public TreeNode updateBackingNode(TreeNode srcNode, int internalIndex, SszData newValue) { + public TreeNode updateBackingNode( + final TreeNode srcNode, final int internalIndex, final SszData newValue) { return LeafNode.create(((SszBytes32) newValue).get()); } @Override - public SszBytes32 boxed(Bytes32 rawValue) { + public SszBytes32 boxed(final Bytes32 rawValue) { return SszBytes32.of(rawValue); } @@ -349,22 +278,6 @@ public String toString() { } }; - private static Bytes updateExtending(Bytes origBytes, int origOff, Bytes newBytes) { - if (origOff == origBytes.size()) { - return Bytes.wrap(origBytes, newBytes); - } else { - final MutableBytes dest; - if (origOff + newBytes.size() > origBytes.size()) { - dest = MutableBytes.create(origOff + newBytes.size()); - origBytes.copyTo(dest, 0); - } else { - dest = origBytes.mutableCopy(); - } - newBytes.copyTo(dest, origOff); - return dest; - } - } - abstract static class SszByteSchema extends AbstractSszPrimitiveSchema { private SszByteSchema() { @@ -372,12 +285,13 @@ private SszByteSchema() { } @Override - public Byte createFromLeafBackingNode(LeafDataNode node, int internalIndex) { + public Byte createFromLeafBackingNode(final LeafDataNode node, final int internalIndex) { return node.getData().get(internalIndex); } @Override - public TreeNode updateBackingNode(TreeNode srcNode, int index, SszData newValue) { + public TreeNode updateBackingNode( + final TreeNode srcNode, final int index, final SszData newValue) { byte aByte = ((SszByte) newValue).get(); Bytes curVal = ((LeafNode) srcNode).getData(); Bytes newBytes = updateExtending(curVal, index, Bytes.of(aByte)); @@ -385,7 +299,7 @@ public TreeNode updateBackingNode(TreeNode srcNode, int index, SszData newValue) } @Override - public SszByte boxed(Byte rawValue) { + public SszByte boxed(final Byte rawValue) { return SszByte.of(rawValue); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszSchema.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszSchema.java index c1f9f3506d6..98704e1c51a 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszSchema.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszSchema.java @@ -68,19 +68,19 @@ default SszDataT getDefault() { boolean isPrimitive(); - default Bytes sszSerialize(SszDataT view) { + default Bytes sszSerialize(final SszDataT view) { return sszSerializeTree(view.getBackingNode()); } - default int sszSerialize(SszDataT view, SszWriter writer) { + default int sszSerialize(final SszDataT view, final SszWriter writer) { return sszSerializeTree(view.getBackingNode(), writer); } - default SszDataT sszDeserialize(SszReader reader) throws SszDeserializeException { + default SszDataT sszDeserialize(final SszReader reader) throws SszDeserializeException { return createFromBackingNode(sszDeserializeTree(reader)); } - default SszDataT sszDeserialize(Bytes ssz) throws SszDeserializeException { + default SszDataT sszDeserialize(final Bytes ssz) throws SszDeserializeException { return sszDeserialize(SszReader.fromBytes(ssz)); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszSchemaHints.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszSchemaHints.java index d91a090459a..3a6ad18a01c 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszSchemaHints.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszSchemaHints.java @@ -45,7 +45,7 @@ public String toString() { public static final class SszSuperNodeHint extends SszSchemaHint { private final int depth; - public SszSuperNodeHint(int depth) { + public SszSuperNodeHint(final int depth) { this.depth = depth; } @@ -54,7 +54,7 @@ public int getDepth() { } } - public static SszSchemaHints of(SszSchemaHint... hints) { + public static SszSchemaHints of(final SszSchemaHint... hints) { return new SszSchemaHints(Arrays.asList(hints)); } @@ -62,18 +62,18 @@ public static SszSchemaHints none() { return of(); } - public static SszSchemaHints sszSuperNode(int superNodeDepth) { + public static SszSchemaHints sszSuperNode(final int superNodeDepth) { return of(new SszSuperNodeHint(superNodeDepth)); } private final List hints; - private SszSchemaHints(List hints) { + private SszSchemaHints(final List hints) { this.hints = hints; } @SuppressWarnings("unchecked") - public Optional getHint(Class hintClass) { + public Optional getHint(final Class hintClass) { return (Optional) hints.stream().filter(h -> h.getClass() == hintClass).findFirst(); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszType.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszType.java index 94ade29e6be..9d373aad2b2 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszType.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszType.java @@ -29,12 +29,12 @@ public interface SszType { int SSZ_LENGTH_SIZE = 4; // serializes int length to SSZ 4 bytes - static Bytes sszLengthToBytes(int length) { + static Bytes sszLengthToBytes(final int length) { return Bytes.ofUnsignedInt(length, ByteOrder.LITTLE_ENDIAN); } // deserializes int length from SSZ 4 bytes - static int sszBytesToLength(Bytes bytes) { + static int sszBytesToLength(final Bytes bytes) { if (!bytes.slice(SSZ_LENGTH_SIZE).isZero()) { throw new SszDeserializeException("Invalid length bytes: " + bytes); } @@ -55,12 +55,12 @@ static int sszBytesToLength(Bytes bytes) { int getSszVariablePartSize(TreeNode node); /** Calculates the full SSZ size in bytes for this type and specified backing subtree */ - default int getSszSize(TreeNode node) { + default int getSszSize(final TreeNode node) { return getSszFixedPartSize() + getSszVariablePartSize(node); } /** SSZ serializes the backing tree instance of this type */ - default Bytes sszSerializeTree(TreeNode node) { + default Bytes sszSerializeTree(final TreeNode node) { SszByteArrayWriter writer = new SszByteArrayWriter(getSszSize(node)); sszSerializeTree(node, writer); return writer.toBytes(); diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszUnionSchema.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszUnionSchema.java index 42cfeeef5e6..47337c9e51e 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszUnionSchema.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszUnionSchema.java @@ -23,11 +23,11 @@ public interface SszUnionSchema extends SszSchema create(SszSchema... childrenSchemas) { + static SszUnionSchema create(final SszSchema... childrenSchemas) { return create(Arrays.asList(childrenSchemas)); } - static SszUnionSchema create(List> childrenSchemas) { + static SszUnionSchema create(final List> childrenSchemas) { return SszUnionSchemaImpl.createGenericSchema(childrenSchemas); } @@ -38,7 +38,7 @@ static SszUnionSchema create(List> childrenSchemas) { * * @throws IndexOutOfBoundsException if selector >= getTypesCount */ - default SszSchema getChildSchema(int selector) { + default SszSchema getChildSchema(final int selector) { return getChildrenSchemas().get(selector); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszVectorSchema.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszVectorSchema.java index c793f994d43..c244cb301e1 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszVectorSchema.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/SszVectorSchema.java @@ -36,13 +36,13 @@ default int getLength() { } static SszVectorSchema create( - SszSchema elementSchema, long length) { + final SszSchema elementSchema, final long length) { return create(elementSchema, length, SszSchemaHints.none()); } @SuppressWarnings("unchecked") static SszVectorSchema create( - SszSchema elementSchema, long length, SszSchemaHints hints) { + final SszSchema elementSchema, final long length, final SszSchemaHints hints) { checkArgument(length > 0 && length <= MAX_VECTOR_LENGTH); if (elementSchema instanceof SszPrimitiveSchema) { return (SszVectorSchema) diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszBitlistSchema.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszBitlistSchema.java index f32aa631506..71e0a70b4fb 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszBitlistSchema.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszBitlistSchema.java @@ -13,6 +13,8 @@ package tech.pegasys.teku.infrastructure.ssz.schema.collections; +import java.util.BitSet; +import org.apache.tuweni.bytes.Bytes; import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; import tech.pegasys.teku.infrastructure.ssz.primitive.SszBit; import tech.pegasys.teku.infrastructure.ssz.schema.collections.impl.SszBitlistSchemaImpl; @@ -20,7 +22,7 @@ public interface SszBitlistSchema extends SszPrimitiveListSchema { - static SszBitlistSchema create(long maxLength) { + static SszBitlistSchema create(final long maxLength) { return new SszBitlistSchemaImpl(maxLength); } @@ -29,4 +31,33 @@ default SszBitlistT empty() { } SszBitlistT ofBits(int size, int... setBitIndices); + + /** + * Creates a SszBitlist by wrapping a given bitSet. This is an optimized constructor that DOES NOT + * clone the bitSet. It used in aggregating attestation pool. DO NOT MUTATE the after the + * wrapping!! SszBitlist is supposed to be immutable. + * + * @param size size of the SszBitlist + * @param bitSet data backing the ssz + * @return SszBitlist instance + */ + SszBitlistT wrapBitSet(int size, BitSet bitSet); + + /** + * Creates a SszBitlist from bytes. + * + * @param bytes The bytes to create the SszBitlist from + * @return A new SszBitlist instance + */ + SszBitlistT fromBytes(Bytes bytes); + + /** + * Creates a SszBitlist from a hexadecimal string. + * + * @param hexString The hexadecimal string to create the SszBitlist from + * @return A new SszBitlist instance + */ + default SszBitlistT fromHexString(final String hexString) { + return fromBytes(Bytes.fromHexString(hexString)); + } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszBitvectorSchema.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszBitvectorSchema.java index c676462caf2..4a2a3aa0dcc 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszBitvectorSchema.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszBitvectorSchema.java @@ -22,17 +22,17 @@ public interface SszBitvectorSchema extends SszPrimitiveVectorSchema { - static SszBitvectorSchema create(long length) { + static SszBitvectorSchema create(final long length) { return new SszBitvectorSchemaImpl(length); } SszBitvectorT ofBits(int... setBitIndices); - default SszBitvectorT fromBytes(Bytes bitvectorBytes) { + default SszBitvectorT fromBytes(final Bytes bitvectorBytes) { return sszDeserialize(bitvectorBytes); } - default SszBitvectorT ofBits(Iterable setBitIndices) { + default SszBitvectorT ofBits(final Iterable setBitIndices) { int[] indicesArray = StreamSupport.stream(setBitIndices.spliterator(), false).mapToInt(i -> i).toArray(); return ofBits(indicesArray); diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszByteListSchema.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszByteListSchema.java index 550ecfba927..a03c156e6ef 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszByteListSchema.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszByteListSchema.java @@ -24,11 +24,11 @@ public interface SszByteListSchema SszListT fromBytes(Bytes bytes); - static SszByteListSchema create(long maxLength) { + static SszByteListSchema create(final long maxLength) { return new SszByteListSchemaImpl<>(SszPrimitiveSchemas.BYTE_SCHEMA, maxLength); } - static SszByteListSchema createUInt8(long maxLength) { + static SszByteListSchema createUInt8(final long maxLength) { return new SszByteListSchemaImpl<>(SszPrimitiveSchemas.UINT8_SCHEMA, maxLength); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszByteVectorSchema.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszByteVectorSchema.java index 11b02193f1b..166935db95e 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszByteVectorSchema.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszByteVectorSchema.java @@ -24,11 +24,11 @@ public interface SszByteVectorSchema SszVectorT fromBytes(Bytes bytes); - static SszByteVectorSchema create(int length) { + static SszByteVectorSchema create(final int length) { return new SszByteVectorSchemaImpl<>(SszPrimitiveSchemas.BYTE_SCHEMA, length); } - static SszByteVectorSchema createUInt8(int length) { + static SszByteVectorSchema createUInt8(final int length) { return new SszByteVectorSchemaImpl<>(SszPrimitiveSchemas.UINT8_SCHEMA, length); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszBytes32VectorSchema.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszBytes32VectorSchema.java index a9b8309131e..143f8735270 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszBytes32VectorSchema.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszBytes32VectorSchema.java @@ -21,7 +21,7 @@ public interface SszBytes32VectorSchema extends SszPrimitiveVectorSchema { - static SszBytes32VectorSchema create(int length) { + static SszBytes32VectorSchema create(final int length) { return new SszBytes32VectorSchemaImpl<>(length); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszPrimitiveCollectionSchema.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszPrimitiveCollectionSchema.java index 7e4baf96675..0d78a3a4a1f 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszPrimitiveCollectionSchema.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszPrimitiveCollectionSchema.java @@ -24,16 +24,16 @@ public interface SszPrimitiveCollectionSchema< ElementT, - SszElementT extends SszPrimitive, + SszElementT extends SszPrimitive, SszCollectionT extends SszPrimitiveCollection> extends SszCollectionSchema { @SuppressWarnings("unchecked") - default SszCollectionT of(ElementT... rawElements) { + default SszCollectionT of(final ElementT... rawElements) { return of(Arrays.asList(rawElements)); } - default SszCollectionT of(List rawElements) { + default SszCollectionT of(final List rawElements) { SszPrimitiveSchema elementSchema = getPrimitiveElementSchema(); return createFromElements(rawElements.stream().map(elementSchema::boxed).toList()); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszPrimitiveListSchema.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszPrimitiveListSchema.java index edb499d41fc..5b95a4a0e37 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszPrimitiveListSchema.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszPrimitiveListSchema.java @@ -23,21 +23,23 @@ public interface SszPrimitiveListSchema< ElementT, - SszElementT extends SszPrimitive, + SszElementT extends SszPrimitive, SszListT extends SszPrimitiveList> extends SszListSchema, SszPrimitiveCollectionSchema { - static > + static > SszPrimitiveListSchema create( - SszPrimitiveSchema elementSchema, int maxLength) { + final SszPrimitiveSchema elementSchema, final int maxLength) { return create(elementSchema, maxLength, SszSchemaHints.none()); } @SuppressWarnings("unchecked") - static > + static > SszPrimitiveListSchema create( - SszPrimitiveSchema elementSchema, long maxLength, SszSchemaHints hints) { + final SszPrimitiveSchema elementSchema, + final long maxLength, + final SszSchemaHints hints) { if (elementSchema.equals(SszPrimitiveSchemas.BIT_SCHEMA)) { return (SszPrimitiveListSchema) SszBitlistSchema.create(maxLength); } else if (elementSchema.equals(SszPrimitiveSchemas.UINT64_SCHEMA)) { diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszPrimitiveVectorSchema.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszPrimitiveVectorSchema.java index 43fd28e4460..61650c59ed4 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszPrimitiveVectorSchema.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszPrimitiveVectorSchema.java @@ -23,21 +23,23 @@ public interface SszPrimitiveVectorSchema< ElementT, - SszElementT extends SszPrimitive, + SszElementT extends SszPrimitive, SszVectorT extends SszPrimitiveVector> extends SszPrimitiveCollectionSchema, SszVectorSchema { - static > + static > SszPrimitiveVectorSchema create( - SszPrimitiveSchema elementSchema, int length) { + final SszPrimitiveSchema elementSchema, final int length) { return create(elementSchema, length, SszSchemaHints.none()); } @SuppressWarnings("unchecked") - static > + static > SszPrimitiveVectorSchema create( - SszPrimitiveSchema elementSchema, long length, SszSchemaHints hints) { + final SszPrimitiveSchema elementSchema, + final long length, + final SszSchemaHints hints) { if (elementSchema.equals(SszPrimitiveSchemas.BIT_SCHEMA)) { return (SszPrimitiveVectorSchema) SszBitvectorSchema.create(length); } else if (elementSchema.equals(SszPrimitiveSchemas.BYTE_SCHEMA)) { diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszUInt64ListSchema.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszUInt64ListSchema.java index d68c3516a39..8759e61810c 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszUInt64ListSchema.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszUInt64ListSchema.java @@ -21,7 +21,7 @@ public interface SszUInt64ListSchema extends SszPrimitiveListSchema { - static SszUInt64ListSchema create(long maxLength) { + static SszUInt64ListSchema create(final long maxLength) { return new SszUInt64ListSchemaImpl<>(maxLength); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SchemaUtils.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SchemaUtils.java index 574863a19a0..e4ad8ec9197 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SchemaUtils.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SchemaUtils.java @@ -22,12 +22,12 @@ class SchemaUtils { - public static TreeNode createTreeFromBytes(Bytes bytes, int treeDepth) { + public static TreeNode createTreeFromBytes(final Bytes bytes, final int treeDepth) { return TreeUtil.createTree( split(bytes, LeafNode.MAX_BYTE_SIZE).stream().map(LeafNode::create).toList(), treeDepth); } - public static List split(Bytes bytes, int chunkSize) { + public static List split(final Bytes bytes, final int chunkSize) { List ret = new ArrayList<>(); int off = 0; int size = bytes.size(); diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszBitlistSchemaImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszBitlistSchemaImpl.java index f101ac5140a..67f7783854b 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszBitlistSchemaImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszBitlistSchemaImpl.java @@ -17,6 +17,7 @@ import com.google.common.base.Preconditions; import java.util.ArrayList; +import java.util.BitSet; import java.util.List; import java.util.stream.IntStream; import org.apache.tuweni.bytes.Bytes; @@ -36,7 +37,7 @@ public class SszBitlistSchemaImpl extends SszPrimitiveListSchemaImpl implements SszBitlistSchema { - public SszBitlistSchemaImpl(long maxLength) { + public SszBitlistSchemaImpl(final long maxLength) { super(SszPrimitiveSchemas.BIT_SCHEMA, maxLength); } @@ -46,25 +47,31 @@ public DeserializableTypeDefinition getJsonTypeDefinition() { } @Override - public SszBitlist createFromBackingNode(TreeNode node) { + public SszBitlist createFromBackingNode(final TreeNode node) { return new SszBitlistImpl(this, node); } @Override - public SszBitlist ofBits(int size, int... setBitIndices) { + public SszBitlist ofBits(final int size, final int... setBitIndices) { Preconditions.checkArgument(size <= getMaxLength(), "size > maxLength"); return SszBitlistImpl.ofBits(this, size, setBitIndices); } @Override - public SszBitlist createFromElements(List elements) { + public SszBitlist wrapBitSet(final int size, final BitSet bitSet) { + Preconditions.checkArgument(size <= getMaxLength(), "size > maxLength"); + return SszBitlistImpl.wrapBitSet(this, size, bitSet); + } + + @Override + public SszBitlist createFromElements(final List elements) { return ofBits( elements.size(), IntStream.range(0, elements.size()).filter(i -> elements.get(i).get()).toArray()); } @Override - public int sszSerializeTree(TreeNode node, SszWriter writer) { + public int sszSerializeTree(final TreeNode node, final SszWriter writer) { int elementsCount = getLength(node); BytesCollector bytesCollector = new BytesCollector(); getCompatibleVectorSchema() @@ -73,7 +80,7 @@ public int sszSerializeTree(TreeNode node, SszWriter writer) { } @Override - public TreeNode sszDeserializeTree(SszReader reader) { + public TreeNode sszDeserializeTree(final SszReader reader) { int availableBytes = reader.getAvailableBytes(); // preliminary rough check checkSsz( @@ -103,7 +110,7 @@ private static class UnsafeBytes { private final int offset; private final int length; - public UnsafeBytes(byte[] bytes, int offset, int length) { + public UnsafeBytes(final byte[] bytes, final int offset, final int length) { this.bytes = bytes; this.offset = offset; this.length = length; @@ -114,7 +121,7 @@ public UnsafeBytes(byte[] bytes, int offset, int length) { private int size; @Override - public void write(byte[] bytes, int offset, int length) { + public void write(final byte[] bytes, final int offset, final int length) { if (length == 0) { return; } @@ -122,7 +129,7 @@ public void write(byte[] bytes, int offset, int length) { size += length; } - public int flushWithBoundaryBit(SszWriter writer, int boundaryBitOffset) { + public int flushWithBoundaryBit(final SszWriter writer, final int boundaryBitOffset) { int bitIdx = boundaryBitOffset % 8; checkArgument( TreeUtil.bitsCeilToBytes(boundaryBitOffset) == size, "Invalid boundary bit offset"); @@ -131,7 +138,7 @@ public int flushWithBoundaryBit(SszWriter writer, int boundaryBitOffset) { writer.write(new byte[] {1}); return size + 1; } else { - UnsafeBytes lastBytes = bytesList.get(bytesList.size() - 1); + UnsafeBytes lastBytes = bytesList.getLast(); byte lastByte = lastBytes.bytes[lastBytes.offset + lastBytes.length - 1]; byte lastByteWithBoundaryBit = (byte) (lastByte ^ (1 << bitIdx)); @@ -147,4 +154,13 @@ public int flushWithBoundaryBit(SszWriter writer, int boundaryBitOffset) { } } } + + @Override + public SszBitlist fromBytes(final Bytes bytes) { + checkArgument(bytes != null, "Input bytes cannot be null"); + try (final SszReader reader = SszReader.fromBytes(bytes)) { + final TreeNode node = sszDeserializeTree(reader); + return createFromBackingNode(node); + } + } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszBitvectorSchemaImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszBitvectorSchemaImpl.java index 7c5971ab924..48e88cf1cc5 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszBitvectorSchemaImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszBitvectorSchemaImpl.java @@ -34,7 +34,7 @@ public class SszBitvectorSchemaImpl extends AbstractSszVectorSchema implements SszBitvectorSchema { - public SszBitvectorSchemaImpl(long length) { + public SszBitvectorSchemaImpl(final long length) { super(SszPrimitiveSchemas.BIT_SCHEMA, length); checkArgument(length > 0, "Invalid Bitlist length"); } @@ -45,27 +45,27 @@ protected DeserializableTypeDefinition createTypeDefinition() { } @Override - public SszBitvector createFromBackingNode(TreeNode node) { + public SszBitvector createFromBackingNode(final TreeNode node) { return new SszBitvectorImpl(this, node); } @Override - public SszBitvector ofBits(int... setBitIndices) { + public SszBitvector ofBits(final int... setBitIndices) { return SszBitvectorImpl.ofBits(this, setBitIndices); } @Override - public SszBitvector createFromElements(List elements) { + public SszBitvector createFromElements(final List elements) { return ofBits(IntStream.range(0, elements.size()).filter(i -> elements.get(i).get()).toArray()); } @Override - public int sszSerializeTree(TreeNode node, SszWriter writer) { + public int sszSerializeTree(final TreeNode node, final SszWriter writer) { return sszSerializeVector(node, writer, getLength()); } @Override - public TreeNode sszDeserializeTree(SszReader reader) { + public TreeNode sszDeserializeTree(final SszReader reader) { checkSsz( reader.getAvailableBytes() == TreeUtil.bitsCeilToBytes(getLength()), "SSZ length doesn't match Bitvector size"); diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszByteListSchemaImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszByteListSchemaImpl.java index 364b4c61e0e..bfed8be1cb9 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszByteListSchemaImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszByteListSchemaImpl.java @@ -46,12 +46,12 @@ public SszByteListSchemaImpl( @Override @SuppressWarnings("unchecked") - public SszListT createFromBackingNode(TreeNode node) { + public SszListT createFromBackingNode(final TreeNode node) { return (SszListT) new SszByteListImpl(this, node); } @Override - public SszListT fromBytes(Bytes bytes) { + public SszListT fromBytes(final Bytes bytes) { checkArgument(bytes.size() <= getMaxLength(), "Bytes size greater than list max length"); TreeNode dataTreeNode = SchemaUtils.createTreeFromBytes(bytes, treeDepth()); TreeNode listTreeNode = createTree(dataTreeNode, bytes.size()); @@ -59,7 +59,7 @@ public SszListT fromBytes(Bytes bytes) { } @Override - public SszListT createFromElements(List elements) { + public SszListT createFromElements(final List elements) { Bytes bytes = Bytes.of(elements.stream().mapToInt(sszByte -> 0xFF & sszByte.get()).toArray()); return fromBytes(bytes); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszByteVectorSchemaImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszByteVectorSchemaImpl.java index c7d0abdc539..dd012d8809e 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszByteVectorSchemaImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszByteVectorSchemaImpl.java @@ -51,30 +51,29 @@ protected DeserializableTypeDefinition createTypeDefinition() { @Override @SuppressWarnings("unchecked") - public SszVectorT createFromBackingNode(TreeNode node) { + public SszVectorT createFromBackingNode(final TreeNode node) { return (SszVectorT) new SszByteVectorImpl(this, node); } @Override - @SuppressWarnings("unchecked") - public SszVectorT fromBytes(Bytes bytes) { - return (SszVectorT) new SszByteVectorImpl(this, bytes); + public SszVectorT fromBytes(final Bytes bytes) { + return createFromBackingNode(fromBytesToTree(this, bytes)); } - public static TreeNode fromBytesToTree(SszByteVectorSchema schema, Bytes bytes) { + public static TreeNode fromBytesToTree(final SszByteVectorSchema schema, final Bytes bytes) { checkArgument(bytes.size() == schema.getLength(), "Bytes size doesn't match vector length"); return SchemaUtils.createTreeFromBytes(bytes, schema.treeDepth()); } - public static Bytes fromTreeToBytes(SszByteVectorSchema schema, TreeNode tree) { + public static Bytes fromTreeToBytes(final SszByteVectorSchema schema, final TreeNode tree) { Bytes bytes = TreeUtil.concatenateLeavesData(tree); checkArgument(bytes.size() == schema.getLength(), "Tree doesn't match vector schema"); return bytes; } @Override - public SszVectorT createFromElements(List elements) { + public TreeNode createTreeFromElements(final List elements) { Bytes bytes = Bytes.of(elements.stream().mapToInt(sszByte -> 0xFF & sszByte.get()).toArray()); - return fromBytes(bytes); + return fromBytesToTree(this, bytes); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszBytes32VectorSchemaImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszBytes32VectorSchemaImpl.java index 7ca7b975c11..4bdcc989160 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszBytes32VectorSchemaImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszBytes32VectorSchemaImpl.java @@ -25,13 +25,13 @@ public class SszBytes32VectorSchemaImpl extends AbstractSszVectorSchema implements SszBytes32VectorSchema { - public SszBytes32VectorSchemaImpl(long vectorLength) { + public SszBytes32VectorSchemaImpl(final long vectorLength) { super(SszPrimitiveSchemas.BYTES32_SCHEMA, vectorLength); } @Override @SuppressWarnings("unchecked") - public SszVectorT createFromBackingNode(TreeNode node) { + public SszVectorT createFromBackingNode(final TreeNode node) { return (SszVectorT) new SszBytes32VectorImpl(this, node); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszPrimitiveListSchemaImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszPrimitiveListSchemaImpl.java index db45da1f21a..a86cee90254 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszPrimitiveListSchemaImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszPrimitiveListSchemaImpl.java @@ -23,19 +23,19 @@ public class SszPrimitiveListSchemaImpl< ElementT, - SszElementT extends SszPrimitive, + SszElementT extends SszPrimitive, SszListT extends SszPrimitiveList> extends AbstractSszListSchema implements SszPrimitiveListSchema { public SszPrimitiveListSchemaImpl( - SszPrimitiveSchema elementSchema, long maxLength) { + final SszPrimitiveSchema elementSchema, final long maxLength) { super(elementSchema, maxLength); } @Override @SuppressWarnings("unchecked") - public SszListT createFromBackingNode(TreeNode node) { + public SszListT createFromBackingNode(final TreeNode node) { return (SszListT) new SszPrimitiveListImpl<>(this, node); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszPrimitiveVectorSchemaImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszPrimitiveVectorSchemaImpl.java index 0300b326883..54911cdc31d 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszPrimitiveVectorSchemaImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszPrimitiveVectorSchemaImpl.java @@ -23,19 +23,19 @@ public class SszPrimitiveVectorSchemaImpl< ElementT, - SszElementT extends SszPrimitive, + SszElementT extends SszPrimitive, SszVectorT extends SszPrimitiveVector> extends AbstractSszVectorSchema implements SszPrimitiveVectorSchema { public SszPrimitiveVectorSchemaImpl( - SszPrimitiveSchema elementSchema, long vectorLength) { + final SszPrimitiveSchema elementSchema, final long vectorLength) { super(elementSchema, vectorLength); } @Override @SuppressWarnings("unchecked") - public SszVectorT createFromBackingNode(TreeNode node) { + public SszVectorT createFromBackingNode(final TreeNode node) { return (SszVectorT) new SszPrimitiveVectorImpl(this, node); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszUInt64ListSchemaImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszUInt64ListSchemaImpl.java index 58b7fac4a6e..bc033dfe9b7 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszUInt64ListSchemaImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/impl/SszUInt64ListSchemaImpl.java @@ -25,13 +25,13 @@ public class SszUInt64ListSchemaImpl extends SszPrimitiveListSchemaImpl implements SszUInt64ListSchema { - public SszUInt64ListSchemaImpl(long maxLength) { + public SszUInt64ListSchemaImpl(final long maxLength) { super(SszPrimitiveSchemas.UINT64_SCHEMA, maxLength); } @Override @SuppressWarnings("unchecked") - public SszListT createFromBackingNode(TreeNode node) { + public SszListT createFromBackingNode(final TreeNode node) { return (SszListT) new SszUInt64ListImpl(this, node); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/AbstractSszCollectionSchema.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/AbstractSszCollectionSchema.java index ff87f87ccb2..1e6980a8e04 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/AbstractSszCollectionSchema.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/AbstractSszCollectionSchema.java @@ -57,7 +57,9 @@ public abstract class AbstractSszCollectionSchema< private volatile TreeNode defaultTree; protected AbstractSszCollectionSchema( - long maxLength, SszSchema elementSchema, SszSchemaHints hints) { + final long maxLength, + final SszSchema elementSchema, + final SszSchemaHints hints) { checkArgument(maxLength >= 0); this.maxLength = maxLength; this.elementSchema = elementSchema; @@ -90,7 +92,7 @@ public SszSchema getElementSchema() { } @Override - public SszSchema getChildSchema(int index) { + public SszSchema getChildSchema(final int index) { if (index >= maxLength) { throw new IndexOutOfBoundsException("Child index " + index + " >= maxLength " + maxLength); } @@ -112,7 +114,7 @@ protected int getSszElementBitSize() { : elementSchema.getSszFixedPartSize() * 8; } - protected int getVariablePartSize(TreeNode vectorNode, int length) { + protected int getVariablePartSize(final TreeNode vectorNode, final int length) { if (isFixedSize()) { return 0; } else { @@ -135,7 +137,8 @@ protected int getVariablePartSize(TreeNode vectorNode, int length) { * @param vectorNode for a {@link SszVectorSchemaImpl} type - the node itself, for a {@link * SszListSchemaImpl} - the left sibling node of list size node */ - public int sszSerializeVector(TreeNode vectorNode, SszWriter writer, int elementsCount) { + public int sszSerializeVector( + final TreeNode vectorNode, final SszWriter writer, final int elementsCount) { if (getElementSchema().isFixedSize()) { return sszSerializeFixedVectorFast(vectorNode, writer, elementsCount); } else { @@ -144,7 +147,7 @@ public int sszSerializeVector(TreeNode vectorNode, SszWriter writer, int element } private int sszSerializeFixedVectorFast( - TreeNode vectorNode, SszWriter writer, int elementsCount) { + final TreeNode vectorNode, final SszWriter writer, final int elementsCount) { if (elementsCount == 0) { return 0; } @@ -161,7 +164,8 @@ private int sszSerializeFixedVectorFast( return bytesCnt[0]; } - private int sszSerializeVariableVector(TreeNode vectorNode, SszWriter writer, int elementsCount) { + private int sszSerializeVariableVector( + final TreeNode vectorNode, final SszWriter writer, final int elementsCount) { SszSchema elementType = getElementSchema(); int variableOffset = SSZ_LENGTH_SIZE * elementsCount; for (int i = 0; i < elementsCount; i++) { @@ -177,7 +181,7 @@ private int sszSerializeVariableVector(TreeNode vectorNode, SszWriter writer, in return variableOffset; } - protected DeserializedData sszDeserializeVector(SszReader reader) { + protected DeserializedData sszDeserializeVector(final SszReader reader) { if (getElementSchema().isFixedSize()) { Optional sszSuperNodeHint = getHints().getHint(SszSuperNodeHint.class); return sszSuperNodeHint @@ -188,7 +192,8 @@ protected DeserializedData sszDeserializeVector(SszReader reader) { } } - private DeserializedData sszDeserializeSupernode(SszReader reader, int supernodeDepth) { + private DeserializedData sszDeserializeSupernode( + final SszReader reader, final int supernodeDepth) { SszNodeTemplate template = elementSszSupernodeTemplate.get(); int sszSize = reader.getAvailableBytes(); if (sszSize % template.getSszLength() != 0) { @@ -213,7 +218,7 @@ private DeserializedData sszDeserializeSupernode(SszReader reader, int supernode return new DeserializedData(tree, elementsCount); } - private DeserializedData sszDeserializeFixed(SszReader reader) { + private DeserializedData sszDeserializeFixed(final SszReader reader) { int bytesSize = reader.getAvailableBytes(); checkSsz( bytesSize % getElementSchema().getSszFixedPartSize() == 0, @@ -244,7 +249,7 @@ private DeserializedData sszDeserializeFixed(SszReader reader) { if (childNodes.isEmpty()) { lastByte = Optional.empty(); } else { - Bytes lastNodeData = childNodes.get(childNodes.size() - 1).getData(); + Bytes lastNodeData = childNodes.getLast().getData(); lastByte = Optional.of(lastNodeData.get(lastNodeData.size() - 1)); } return new DeserializedData( @@ -262,7 +267,7 @@ private DeserializedData sszDeserializeFixed(SszReader reader) { } } - private DeserializedData sszDeserializeVariable(SszReader reader) { + private DeserializedData sszDeserializeVariable(final SszReader reader) { final int endOffset = reader.getAvailableBytes(); final List childNodes = new ArrayList<>(); if (endOffset > 0) { @@ -295,7 +300,7 @@ private DeserializedData sszDeserializeVariable(SszReader reader) { return new DeserializedData(TreeUtil.createTree(childNodes, treeDepth()), childNodes.size()); } - protected static void checkSsz(boolean condition, String error) { + protected static void checkSsz(final boolean condition, final String error) { if (!condition) { throw new SszDeserializeException(error); } @@ -306,7 +311,7 @@ public SszSchemaHints getHints() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } @@ -328,11 +333,12 @@ protected static class DeserializedData { private final int childrenCount; private final Optional lastSszByte; - public DeserializedData(TreeNode dataTree, int childrenCount) { + public DeserializedData(final TreeNode dataTree, final int childrenCount) { this(dataTree, childrenCount, Optional.empty()); } - public DeserializedData(TreeNode dataTree, int childrenCount, Optional lastSszByte) { + public DeserializedData( + final TreeNode dataTree, final int childrenCount, final Optional lastSszByte) { this.dataTree = dataTree; this.childrenCount = childrenCount; this.lastSszByte = lastSszByte; diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/AbstractSszContainerSchema.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/AbstractSszContainerSchema.java index 471d86a4838..a735b09e141 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/AbstractSszContainerSchema.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/AbstractSszContainerSchema.java @@ -50,11 +50,12 @@ public static class NamedSchema { private final String name; private final SszSchema schema; - public static NamedSchema of(String name, SszSchema schema) { + public static NamedSchema of( + final String name, final SszSchema schema) { return new NamedSchema<>(name, schema); } - private NamedSchema(String name, SszSchema schema) { + private NamedSchema(final String name, final SszSchema schema) { this.name = name; this.schema = schema; } @@ -69,12 +70,12 @@ public SszSchema getSchema() { } protected static NamedSchema namedSchema( - SszFieldName fieldName, SszSchema schema) { + final SszFieldName fieldName, final SszSchema schema) { return namedSchema(fieldName.getSszFieldName(), schema); } protected static NamedSchema namedSchema( - String fieldName, SszSchema schema) { + final String fieldName, final SszSchema schema) { return new NamedSchema<>(fieldName, schema); } @@ -90,7 +91,7 @@ protected static NamedSchema namedSchema( private final DeserializableTypeDefinition jsonTypeDefinition; protected AbstractSszContainerSchema( - String name, List> childrenSchemas) { + final String name, final List> childrenSchemas) { this.containerName = name; for (int i = 0; i < childrenSchemas.size(); i++) { final NamedSchema childSchema = childrenSchemas.get(i); @@ -108,7 +109,7 @@ protected AbstractSszContainerSchema( this.jsonTypeDefinition = SszContainerTypeDefinition.createFor(this); } - protected AbstractSszContainerSchema(List> childrenSchemas) { + protected AbstractSszContainerSchema(final List> childrenSchemas) { this.containerName = ""; for (int i = 0; i < childrenSchemas.size(); i++) { final String name = "field-" + i; @@ -123,7 +124,7 @@ protected AbstractSszContainerSchema(List> childrenSchemas) { } @Override - public TreeNode createTreeFromFieldValues(List fieldValues) { + public TreeNode createTreeFromFieldValues(final List fieldValues) { checkArgument(fieldValues.size() == getFieldsCount(), "Wrong number of filed values"); return TreeUtil.createTree(fieldValues.stream().map(SszData::getBackingNode).toList()); } @@ -162,7 +163,7 @@ private TreeNode createDefaultTree() { } @Override - public SszSchema getChildSchema(int index) { + public SszSchema getChildSchema(final int index) { return childrenSchemas.get(index); } @@ -173,7 +174,7 @@ public SszSchema getChildSchema(int index) { * @return The index if it exists, otherwise -1 */ @Override - public int getFieldIndex(String fieldName) { + public int getFieldIndex(final String fieldName) { return childrenNamesToFieldIndex.getOrDefault(fieldName, -1); } @@ -186,7 +187,7 @@ public long getMaxLength() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } @@ -227,7 +228,7 @@ protected int calcSszFixedPartSize() { } @Override - public int getSszVariablePartSize(TreeNode node) { + public int getSszVariablePartSize(final TreeNode node) { if (isFixedSize()) { return 0; } else { @@ -248,7 +249,7 @@ public List> getFieldSchemas() { } @Override - public int sszSerializeTree(TreeNode node, SszWriter writer) { + public int sszSerializeTree(final TreeNode node, final SszWriter writer) { int variableChildOffset = getSszFixedPartSize(); int[] variableSizes = new int[getFieldsCount()]; for (int i = 0; i < getFieldsCount(); i++) { @@ -276,7 +277,7 @@ public int sszSerializeTree(TreeNode node, SszWriter writer) { } @Override - public TreeNode sszDeserializeTree(SszReader reader) { + public TreeNode sszDeserializeTree(final SszReader reader) { int endOffset = reader.getAvailableBytes(); int childCount = getFieldsCount(); Queue fixedChildrenSubtrees = new ArrayDeque<>(childCount); diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/AbstractSszListSchema.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/AbstractSszListSchema.java index 026f523a15e..373f4aff076 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/AbstractSszListSchema.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/AbstractSszListSchema.java @@ -51,12 +51,15 @@ public abstract class AbstractSszListSchema< private final SszLengthBounds sszLengthBounds; private final DeserializableTypeDefinition jsonTypeDefinition; - protected AbstractSszListSchema(SszSchema elementSchema, long maxLength) { + protected AbstractSszListSchema( + final SszSchema elementSchema, final long maxLength) { this(elementSchema, maxLength, SszSchemaHints.none()); } protected AbstractSszListSchema( - SszSchema elementSchema, long maxLength, SszSchemaHints hints) { + final SszSchema elementSchema, + final long maxLength, + final SszSchemaHints hints) { super(maxLength, elementSchema, hints); this.compatibleVectorSchema = new SszVectorSchemaImpl<>(elementSchema, getMaxLength(), true, getHints()); @@ -71,7 +74,7 @@ protected TreeNode createDefaultTree() { return createTree(getCompatibleVectorSchema().getDefaultTree(), 0); } - protected TreeNode createTree(TreeNode dataNode, int length) { + protected TreeNode createTree(final TreeNode dataNode, final int length) { return BranchNode.create(dataNode, toLengthNode(length)); } @@ -88,7 +91,7 @@ public SszListT getDefault() { } @Override - public long getChildGeneralizedIndex(long elementIndex) { + public long getChildGeneralizedIndex(final long elementIndex) { return GIndexUtil.gIdxCompose( GIndexUtil.LEFT_CHILD_G_INDEX, super.getChildGeneralizedIndex(elementIndex)); } @@ -99,7 +102,7 @@ public int getSszFixedPartSize() { } @Override - public int getSszVariablePartSize(TreeNode node) { + public int getSszVariablePartSize(final TreeNode node) { int length = getLength(node); SszSchema elementSchema = getElementSchema(); if (elementSchema.isFixedSize()) { @@ -121,7 +124,7 @@ public boolean isFixedSize() { } @Override - public int sszSerializeTree(TreeNode node, SszWriter writer) { + public int sszSerializeTree(final TreeNode node, final SszWriter writer) { int elementsCount = getLength(node); if (getElementSchema().equals(SszPrimitiveSchemas.BIT_SCHEMA)) { throw new UnsupportedOperationException( @@ -133,7 +136,7 @@ public int sszSerializeTree(TreeNode node, SszWriter writer) { } @Override - public TreeNode sszDeserializeTree(SszReader reader) { + public TreeNode sszDeserializeTree(final SszReader reader) { if (getElementSchema().equals(SszPrimitiveSchemas.BIT_SCHEMA)) { throw new UnsupportedOperationException( "BitlistImpl deserialization is only supported by SszBitlistSchema"); @@ -277,24 +280,24 @@ public TreeNode loadBackingNodes( return BranchNode.create(vectorNode, toLengthNode(length)); } - private static TreeNode toLengthNode(int length) { + private static TreeNode toLengthNode(final int length) { return length == 0 ? LeafNode.ZERO_LEAVES[8] : LeafNode.create(Bytes.ofUnsignedLong(length, ByteOrder.LITTLE_ENDIAN)); } - private static long fromLengthNode(TreeNode lengthNode) { + private static long fromLengthNode(final TreeNode lengthNode) { assert lengthNode instanceof LeafNode; return ((LeafNode) lengthNode).getData().toLong(ByteOrder.LITTLE_ENDIAN); } - protected static int getLength(TreeNode listNode) { + protected static int getLength(final TreeNode listNode) { long longLength = fromLengthNode(listNode.get(GIndexUtil.RIGHT_CHILD_G_INDEX)); assert longLength < Integer.MAX_VALUE; return (int) longLength; } - protected static TreeNode getVectorNode(TreeNode listNode) { + protected static TreeNode getVectorNode(final TreeNode listNode) { return listNode.get(GIndexUtil.LEFT_CHILD_G_INDEX); } @@ -323,7 +326,7 @@ public DeserializableTypeDefinition getJsonTypeDefinition() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/AbstractSszPrimitiveSchema.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/AbstractSszPrimitiveSchema.java index 7d39d34d905..ee3480cd5ac 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/AbstractSszPrimitiveSchema.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/AbstractSszPrimitiveSchema.java @@ -19,6 +19,7 @@ import java.util.List; import org.apache.tuweni.bytes.Bytes; import org.apache.tuweni.bytes.Bytes32; +import org.apache.tuweni.bytes.MutableBytes; import tech.pegasys.teku.infrastructure.ssz.SszData; import tech.pegasys.teku.infrastructure.ssz.SszPrimitive; import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchema; @@ -37,15 +38,31 @@ * * @param Class of the basic view of this type */ -public abstract class AbstractSszPrimitiveSchema< - DataT, SszDataT extends SszPrimitive> +public abstract class AbstractSszPrimitiveSchema> implements SszPrimitiveSchema { + protected static Bytes updateExtending( + final Bytes origBytes, final int origOff, final Bytes newBytes) { + if (origOff == origBytes.size()) { + return Bytes.wrap(origBytes, newBytes); + } else { + final MutableBytes dest; + if (origOff + newBytes.size() > origBytes.size()) { + dest = MutableBytes.create(origOff + newBytes.size()); + origBytes.copyTo(dest, 0); + } else { + dest = origBytes.mutableCopy(); + } + newBytes.copyTo(dest, origOff); + return dest; + } + } + private final int bitsSize; private final int sszSize; private final SszLengthBounds sszLengthBounds; - protected AbstractSszPrimitiveSchema(int bitsSize) { + protected AbstractSszPrimitiveSchema(final int bitsSize) { checkArgument( bitsSize == 0 || (bitsSize > 0 && bitsSize <= 256 && 256 % bitsSize == 0), "Invalid bitsize: %s", @@ -61,7 +78,7 @@ public int getBitsSize() { } @Override - public SszDataT createFromBackingNode(TreeNode node) { + public SszDataT createFromBackingNode(final TreeNode node) { return createFromPackedNode(node, 0); } @@ -86,20 +103,20 @@ public TreeNode loadBackingNodes( } @Override - public final DataT createFromPackedNodeUnboxed(TreeNode node, int internalIndex) { + public final DataT createFromPackedNodeUnboxed(final TreeNode node, final int internalIndex) { assert node instanceof LeafDataNode; return createFromLeafBackingNode((LeafDataNode) node, internalIndex); } protected abstract DataT createFromLeafBackingNode(LeafDataNode node, int internalIndex); - public TreeNode createBackingNode(SszDataT newValue) { + public TreeNode createBackingNode(final SszData newValue) { return updateBackingNode(LeafNode.EMPTY_LEAF, 0, newValue); } @Override public TreeNode updatePackedNode( - TreeNode srcNode, List> updates) { + final TreeNode srcNode, final List> updates) { TreeNode res = srcNode; for (PackedNodeUpdate update : updates) { res = updateBackingNode(res, update.getInternalIndex(), update.getNewValue()); @@ -125,12 +142,12 @@ public int getSszFixedPartSize() { } @Override - public int getSszVariablePartSize(TreeNode node) { + public int getSszVariablePartSize(final TreeNode node) { return 0; } @Override - public int sszSerializeTree(TreeNode node, SszWriter writer) { + public int sszSerializeTree(final TreeNode node, final SszWriter writer) { final Bytes nodeData; if (node instanceof LeafDataNode) { // small perf optimization @@ -143,7 +160,7 @@ public int sszSerializeTree(TreeNode node, SszWriter writer) { } @Override - public TreeNode sszDeserializeTree(SszReader reader) { + public TreeNode sszDeserializeTree(final SszReader reader) { Bytes bytes = reader.read(sszSize); if (reader.getAvailableBytes() > 0) { throw new SszDeserializeException("Extra " + reader.getAvailableBytes() + " bytes found"); diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/AbstractSszUInt64Schema.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/AbstractSszUInt64Schema.java new file mode 100644 index 00000000000..37bfdf0795e --- /dev/null +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/AbstractSszUInt64Schema.java @@ -0,0 +1,119 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.infrastructure.ssz.schema.impl; + +import static tech.pegasys.teku.infrastructure.ssz.schema.json.SszPrimitiveTypeDefinitions.createUInt64Definition; + +import com.google.common.base.Supplier; +import com.google.common.base.Suppliers; +import java.nio.ByteOrder; +import java.util.Arrays; +import java.util.List; +import org.apache.tuweni.bytes.Bytes; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.ssz.SszData; +import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; +import tech.pegasys.teku.infrastructure.ssz.tree.LeafDataNode; +import tech.pegasys.teku.infrastructure.ssz.tree.LeafNode; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; + +public abstract class AbstractSszUInt64Schema + extends AbstractSszPrimitiveSchema { + + private final Supplier> typeDefinition = + Suppliers.memoize(this::createJsonTypeDefinition); + + protected AbstractSszUInt64Schema() { + super(64); + } + + @Override + public UInt64 createFromLeafBackingNode(final LeafDataNode node, final int internalIndex) { + final Bytes leafNodeBytes = node.getData(); + try { + final Bytes elementBytes = leafNodeBytes.slice(internalIndex * 8, 8); + return UInt64.fromLongBits(elementBytes.toLong(ByteOrder.LITTLE_ENDIAN)); + } catch (final Exception e) { + // additional info to track down the bug https://github.com/PegaSysEng/teku/issues/2579 + String info = + "Refer to https://github.com/PegaSysEng/teku/issues/2579 if see this exception. "; + info += "internalIndex = " + internalIndex; + info += ", leafNodeBytes: " + leafNodeBytes.getClass().getSimpleName(); + try { + info += ", leafNodeBytes = " + leafNodeBytes.copy(); + } catch (Exception ex) { + info += "(" + ex + ")"; + } + try { + info += ", leafNodeBytes[] = " + Arrays.toString(leafNodeBytes.toArray()); + } catch (Exception ex) { + info += "(" + ex + ")"; + } + throw new RuntimeException(info, e); + } + } + + @Override + public TreeNode updateBackingNode( + final TreeNode srcNode, final int index, final SszData newValue) { + final Bytes uintBytes = + Bytes.ofUnsignedLong(((SszUInt64) newValue).longValue(), ByteOrder.LITTLE_ENDIAN); + final Bytes curVal = ((LeafNode) srcNode).getData(); + final Bytes newBytes = updateExtending(curVal, index * 8, uintBytes); + return LeafNode.create(newBytes); + } + + @Override + public TreeNode updatePackedNode( + final TreeNode srcNode, final List> updates) { + if (updates.size() == 4) { + final byte[] data = new byte[32]; + for (int i = 0; i < 4; i++) { + final long longValue = updates.get(i).getNewValue().longValue(); + final int off = i * 8; + data[off + 0] = (byte) longValue; + data[off + 1] = (byte) (longValue >> 8); + data[off + 2] = (byte) (longValue >> 16); + data[off + 3] = (byte) (longValue >> 24); + data[off + 4] = (byte) (longValue >> 32); + data[off + 5] = (byte) (longValue >> 40); + data[off + 6] = (byte) (longValue >> 48); + data[off + 7] = (byte) (longValue >> 56); + } + return LeafNode.create(Bytes.wrap(data)); + } else { + return super.updatePackedNode(srcNode, updates); + } + } + + @Override + public TreeNode getDefaultTree() { + return LeafNode.ZERO_LEAVES[8]; + } + + private DeserializableTypeDefinition createJsonTypeDefinition() { + return createUInt64Definition(this); + } + + @Override + public DeserializableTypeDefinition getJsonTypeDefinition() { + return typeDefinition.get(); + } + + @Override + public String toString() { + return "UInt64"; + } +} diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/AbstractSszVectorSchema.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/AbstractSszVectorSchema.java index 0f9efb940e1..4116de5b953 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/AbstractSszVectorSchema.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/AbstractSszVectorSchema.java @@ -49,25 +49,28 @@ public abstract class AbstractSszVectorSchema< private final boolean isListBacking; private final int fixedPartSize; - private SszLengthBounds sszLengthBounds; + private final SszLengthBounds sszLengthBounds; private final Supplier> jsonTypeDefinition = Suppliers.memoize(this::createTypeDefinition); - protected AbstractSszVectorSchema(SszSchema elementType, long vectorLength) { + protected AbstractSszVectorSchema( + final SszSchema elementType, final long vectorLength) { this(elementType, vectorLength, false); } protected AbstractSszVectorSchema( - SszSchema elementType, long vectorLength, boolean isListBacking) { + final SszSchema elementType, + final long vectorLength, + final boolean isListBacking) { this(elementType, vectorLength, isListBacking, SszSchemaHints.none()); } protected AbstractSszVectorSchema( - SszSchema elementSchema, - long vectorLength, - boolean isListBacking, - SszSchemaHints hints) { + final SszSchema elementSchema, + final long vectorLength, + final boolean isListBacking, + final SszSchemaHints hints) { super(vectorLength, elementSchema, hints); this.isListBacking = isListBacking; this.fixedPartSize = calcSszFixedPartSize(); @@ -140,7 +143,7 @@ public boolean isFixedSize() { } @Override - public int getSszVariablePartSize(TreeNode node) { + public int getSszVariablePartSize(final TreeNode node) { return getVariablePartSize(node, getLength()); } @@ -159,12 +162,12 @@ private int calcSszFixedPartSize() { } @Override - public int sszSerializeTree(TreeNode node, SszWriter writer) { + public int sszSerializeTree(final TreeNode node, final SszWriter writer) { return sszSerializeVector(node, writer, getLength()); } @Override - public TreeNode sszDeserializeTree(SszReader reader) { + public TreeNode sszDeserializeTree(final SszReader reader) { if (getElementSchema().equals(SszPrimitiveSchemas.BIT_SCHEMA)) { throw new UnsupportedOperationException( "Bitvector deserialization is only supported by SszBitvectorSchema"); @@ -178,7 +181,8 @@ public TreeNode sszDeserializeTree(SszReader reader) { } @Override - public TreeNode loadBackingNodes(TreeNodeSource nodeSource, Bytes32 rootHash, long rootGIndex) { + public TreeNode loadBackingNodes( + final TreeNodeSource nodeSource, final Bytes32 rootHash, final long rootGIndex) { final long lastUsefulGIndex = GIndexUtil.gIdxChildGIndex(rootGIndex, maxChunks() - 1, treeDepth()); return LoadingUtil.loadNodesToDepth( @@ -224,7 +228,7 @@ public DeserializableTypeDefinition getJsonTypeDefinition() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/SszListSchemaImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/SszListSchemaImpl.java index 2198d700e6a..f05f59da1cf 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/SszListSchemaImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/SszListSchemaImpl.java @@ -24,12 +24,14 @@ public class SszListSchemaImpl extends AbstractSszListSchema> { public SszListSchemaImpl( - SszSchema elementSchema, long maxLength, SszSchemaHints hints) { + final SszSchema elementSchema, + final long maxLength, + final SszSchemaHints hints) { super(elementSchema, maxLength, hints); } @Override - public SszList createFromBackingNode(TreeNode node) { + public SszList createFromBackingNode(final TreeNode node) { return new SszListImpl<>(this, node); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/SszOptionalSchemaImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/SszOptionalSchemaImpl.java index 62f6716a4ab..fc6a3c5ffc9 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/SszOptionalSchemaImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/SszOptionalSchemaImpl.java @@ -250,7 +250,7 @@ public SszLengthBounds getSszLengthBounds() { } private SszLengthBounds calcSszLengthBounds() { - return childSchema.getSszLengthBounds().addBytes(PREFIX_SIZE_BYTES).ceilToBytes(); + return SszLengthBounds.ZERO.or(childSchema.getSszLengthBounds().addBytes(PREFIX_SIZE_BYTES)); } @Override diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/SszUnionSchemaImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/SszUnionSchemaImpl.java index 691e909c4c5..a60e0f671c6 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/SszUnionSchemaImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/SszUnionSchemaImpl.java @@ -54,15 +54,16 @@ public abstract class SszUnionSchemaImpl private static final int MAX_SELECTOR = 127; private static final int DEFAULT_SELECTOR = 0; - private static LeafNode createSelectorNode(int selector) { + private static LeafNode createSelectorNode(final int selector) { assert selector <= MAX_SELECTOR; return LeafNode.create(Bytes.of((byte) selector)); } - public static SszUnionSchema createGenericSchema(List> childrenSchemas) { + public static SszUnionSchema createGenericSchema( + final List> childrenSchemas) { return new SszUnionSchemaImpl<>(childrenSchemas) { @Override - public SszUnion createFromBackingNode(TreeNode node) { + public SszUnion createFromBackingNode(final TreeNode node) { return new SszUnionImpl(this, node); } }; @@ -73,7 +74,7 @@ public SszUnion createFromBackingNode(TreeNode node) { private final Supplier lengthBounds = Suppliers.memoize(this::calcSszLengthBounds); - public SszUnionSchemaImpl(List> childrenSchemas) { + public SszUnionSchemaImpl(final List> childrenSchemas) { // Because of zero indexing, the max selector is one less than the maximum list size. checkArgument(childrenSchemas.size() <= MAX_SELECTOR + 1, "Too many child types"); checkArgument( @@ -150,7 +151,7 @@ public TreeNode getDefaultTree() { public abstract SszUnionT createFromBackingNode(TreeNode node); @Override - public SszUnionT createFromValue(int selector, SszData value) { + public SszUnionT createFromValue(final int selector, final SszData value) { checkArgument(selector < getTypesCount(), "Selector is out of bounds"); checkArgument( getChildSchema(selector).equals(value.getSchema()), @@ -159,13 +160,13 @@ public SszUnionT createFromValue(int selector, SszData value) { } @Override - public int getSszVariablePartSize(TreeNode node) { + public int getSszVariablePartSize(final TreeNode node) { int selector = getSelector(node); return childrenSchemas.get(selector).getSszSize(getValueNode(node)); } @Override - public int sszSerializeTree(TreeNode node, SszWriter writer) { + public int sszSerializeTree(final TreeNode node, final SszWriter writer) { int selector = getSelector(node); writer.write(Bytes.of(selector)); SszSchema valueSchema = childrenSchemas.get(selector); @@ -174,7 +175,7 @@ public int sszSerializeTree(TreeNode node, SszWriter writer) { } @Override - public TreeNode sszDeserializeTree(SszReader reader) throws SszDeserializeException { + public TreeNode sszDeserializeTree(final SszReader reader) throws SszDeserializeException { int selector = reader.read(1).get(0) & 0xFF; if (selector >= getTypesCount()) { throw new SszDeserializeException( @@ -186,7 +187,7 @@ public TreeNode sszDeserializeTree(SszReader reader) throws SszDeserializeExcept return createUnionNode(valueNode, selector); } - public int getSelectorFromSelectorNode(TreeNode selectorNode) { + public int getSelectorFromSelectorNode(final TreeNode selectorNode) { checkArgument(selectorNode instanceof LeafDataNode, "Invalid selector node"); LeafDataNode dataNode = (LeafDataNode) selectorNode; Bytes bytes = dataNode.getData(); @@ -196,27 +197,30 @@ public int getSelectorFromSelectorNode(TreeNode selectorNode) { return selector; } - public TreeNode getValueNode(TreeNode unionNode) { + public final TreeNode getValueNode(final TreeNode unionNode) { return unionNode.get(GIndexUtil.LEFT_CHILD_G_INDEX); } - private TreeNode getSelectorNode(TreeNode unionNode) { + private TreeNode getSelectorNode(final TreeNode unionNode) { return unionNode.get(GIndexUtil.RIGHT_CHILD_G_INDEX); } - public int getSelector(TreeNode unionNode) { + public int getSelector(final TreeNode unionNode) { int selector = getSelectorFromSelectorNode(getSelectorNode(unionNode)); checkArgument(selector < getTypesCount(), "Selector is out of bounds"); return selector; } - private TreeNode createUnionNode(TreeNode valueNode, int selector) { + private TreeNode createUnionNode(final TreeNode valueNode, final int selector) { return BranchNode.create(valueNode, createSelectorNode(selector)); } @Override public void storeBackingNodes( - TreeNodeStore nodeStore, int maxBranchLevelsSkipped, long rootGIndex, TreeNode node) { + final TreeNodeStore nodeStore, + final int maxBranchLevelsSkipped, + final long rootGIndex, + final TreeNode node) { TreeNode selectorNode = getSelectorNode(node); TreeNode valueNode = getValueNode(node); int selector = getSelectorFromSelectorNode(selectorNode); @@ -234,7 +238,8 @@ public void storeBackingNodes( } @Override - public TreeNode loadBackingNodes(TreeNodeSource nodeSource, Bytes32 rootHash, long rootGIndex) { + public TreeNode loadBackingNodes( + final TreeNodeSource nodeSource, final Bytes32 rootHash, final long rootGIndex) { if (TreeUtil.ZERO_TREES_BY_ROOT.containsKey(rootHash) || rootHash.equals(Bytes32.ZERO)) { return getDefaultTree(); } @@ -272,7 +277,7 @@ private SszLengthBounds calcSszLengthBounds() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/SszVectorSchemaImpl.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/SszVectorSchemaImpl.java index e18b8f4d025..88aab304a82 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/SszVectorSchemaImpl.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/impl/SszVectorSchemaImpl.java @@ -23,20 +23,20 @@ public class SszVectorSchemaImpl extends AbstractSszVectorSchema> { - SszVectorSchemaImpl(SszSchema elementType, long vectorLength) { + SszVectorSchemaImpl(final SszSchema elementType, final long vectorLength) { this(elementType, vectorLength, false, SszSchemaHints.none()); } public SszVectorSchemaImpl( - SszSchema elementSchema, - long vectorLength, - boolean isListBacking, - SszSchemaHints hints) { + final SszSchema elementSchema, + final long vectorLength, + final boolean isListBacking, + final SszSchemaHints hints) { super(elementSchema, vectorLength, isListBacking, hints); } @Override - public SszVector createFromBackingNode(TreeNode node) { + public SszVector createFromBackingNode(final TreeNode node) { return new SszVectorImpl<>(this, node); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/json/SszContainerTypeDefinition.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/json/SszContainerTypeDefinition.java index 4c223913756..c70d57defe7 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/json/SszContainerTypeDefinition.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/json/SszContainerTypeDefinition.java @@ -61,7 +61,7 @@ public ContainerBuilder(final SszContainerSchema schema) { this.values = new SszData[schema.getFieldsCount()]; } - public void setValue(int childIndex, final SszData value) { + public void setValue(final int childIndex, final SszData value) { values[childIndex] = value; } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/json/SszPrimitiveTypeDefinitions.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/json/SszPrimitiveTypeDefinitions.java index 4481a1befca..9e6c181dda5 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/json/SszPrimitiveTypeDefinitions.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/json/SszPrimitiveTypeDefinitions.java @@ -29,8 +29,10 @@ import tech.pegasys.teku.infrastructure.ssz.primitive.SszNone; import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt256; import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; +import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchema; import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; import tech.pegasys.teku.infrastructure.ssz.schema.SszSchema; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; public final class SszPrimitiveTypeDefinitions { public static final DeserializableTypeDefinition SSZ_NONE_TYPE_DEFINITION = @@ -61,12 +63,14 @@ public final class SszPrimitiveTypeDefinitions { public static final DeserializableTypeDefinition SSZ_BYTES4_TYPE_DEFINITION = new SszTypeDefinitionWrapper<>(SszPrimitiveSchemas.BYTES4_SCHEMA, CoreTypes.BYTES4_TYPE); - public static final DeserializableTypeDefinition SSZ_UINT64_TYPE_DEFINITION = - new SszTypeDefinitionWrapper<>(SszPrimitiveSchemas.UINT64_SCHEMA, CoreTypes.UINT64_TYPE); - public static final DeserializableTypeDefinition SSZ_UINT256_TYPE_DEFINITION = new SszTypeDefinitionWrapper<>(SszPrimitiveSchemas.UINT256_SCHEMA, CoreTypes.UINT256_TYPE); + public static DeserializableTypeDefinition createUInt64Definition( + final SszPrimitiveSchema schema) { + return new SszTypeDefinitionWrapper<>(schema, CoreTypes.UINT64_TYPE); + } + public static DeserializableTypeDefinition sszSerializedType( final SszSchema schema, final String description) { return new StringTypeBuilder() diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/json/SszTypeDefinitionWrapper.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/json/SszTypeDefinitionWrapper.java index b737282ab36..74625ab8834 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/json/SszTypeDefinitionWrapper.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/schema/json/SszTypeDefinitionWrapper.java @@ -24,7 +24,7 @@ import tech.pegasys.teku.infrastructure.ssz.SszPrimitive; import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchema; -public class SszTypeDefinitionWrapper> +public class SszTypeDefinitionWrapper> implements DeserializableTypeDefinition { private final SszPrimitiveSchema schema; diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SimpleSszReader.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SimpleSszReader.java index 9d017462284..ceb591387d4 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SimpleSszReader.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SimpleSszReader.java @@ -20,7 +20,7 @@ public class SimpleSszReader implements SszReader { private final Bytes bytes; protected int offset = 0; - public SimpleSszReader(Bytes bytes) { + public SimpleSszReader(final Bytes bytes) { this.bytes = bytes; } @@ -30,7 +30,7 @@ public int getAvailableBytes() { } @Override - public SszReader slice(int size) { + public SszReader slice(final int size) { checkIfAvailable(size); SimpleSszReader ret = new SimpleSszReader(bytes.slice(offset, size)); offset += size; @@ -38,14 +38,14 @@ public SszReader slice(int size) { } @Override - public Bytes read(int length) { + public Bytes read(final int length) { checkIfAvailable(length); Bytes ret = bytes.slice(offset, length); offset += length; return ret; } - private void checkIfAvailable(int size) { + private void checkIfAvailable(final int size) { if (getAvailableBytes() < size) { throw new SszDeserializeException("Invalid SSZ: trying to read more bytes than available"); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SszByteArrayWriter.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SszByteArrayWriter.java index 77210908f40..f8ade94cc92 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SszByteArrayWriter.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SszByteArrayWriter.java @@ -19,12 +19,12 @@ public class SszByteArrayWriter implements SszWriter { private final byte[] bytes; private int size = 0; - public SszByteArrayWriter(int maxSize) { + public SszByteArrayWriter(final int maxSize) { bytes = new byte[maxSize]; } @Override - public void write(byte[] bytes, int offset, int length) { + public void write(final byte[] bytes, final int offset, final int length) { System.arraycopy(bytes, offset, this.bytes, this.size, length); this.size += length; } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SszDeserializeException.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SszDeserializeException.java index bfb319dd908..4c9cab30240 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SszDeserializeException.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SszDeserializeException.java @@ -15,7 +15,7 @@ public class SszDeserializeException extends IllegalArgumentException { - public SszDeserializeException(String s) { + public SszDeserializeException(final String s) { super(s); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SszField.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SszField.java index ecb0e81d330..931ab56d336 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SszField.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SszField.java @@ -22,27 +22,27 @@ public class SszField { private final String name; private final Supplier> viewType; - public SszField(int index, SszSchema sszSchema) { + public SszField(final int index, final SszSchema sszSchema) { this(index, () -> sszSchema); } - public SszField(int index, Supplier> viewType) { + public SszField(final int index, final Supplier> viewType) { this(index, "field-" + index, viewType); } - public SszField(int index, SszFieldName name, SszSchema sszSchema) { + public SszField(final int index, final SszFieldName name, final SszSchema sszSchema) { this(index, name.getSszFieldName(), sszSchema); } - public SszField(int index, String name, SszSchema sszSchema) { + public SszField(final int index, final String name, final SszSchema sszSchema) { this(index, name, () -> sszSchema); } - public SszField(int index, SszFieldName name, Supplier> viewType) { + public SszField(final int index, final SszFieldName name, final Supplier> viewType) { this(index, name.getSszFieldName(), viewType); } - public SszField(int index, String name, Supplier> viewType) { + public SszField(final int index, final String name, final Supplier> viewType) { this.index = index; this.name = name; this.viewType = viewType; diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SszLengthBounds.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SszLengthBounds.java index 8872636744f..e1516003369 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SszLengthBounds.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SszLengthBounds.java @@ -22,19 +22,19 @@ public class SszLengthBounds { private final long min; private final long max; - public static SszLengthBounds ofBits(long fixedSize) { + public static SszLengthBounds ofBits(final long fixedSize) { return new SszLengthBounds(fixedSize, fixedSize); } - public static SszLengthBounds ofBits(long min, long max) { + public static SszLengthBounds ofBits(final long min, final long max) { return new SszLengthBounds(min, max); } - public static SszLengthBounds ofBytes(long fixedSize) { + public static SszLengthBounds ofBytes(final long fixedSize) { return new SszLengthBounds(fixedSize * 8, fixedSize * 8); } - public static SszLengthBounds ofBytes(long min, long max) { + public static SszLengthBounds ofBytes(final long min, final long max) { return new SszLengthBounds(min * 8, max * 8); } @@ -112,7 +112,7 @@ public String toString() { .toString(); } - private static String fromBits(long bits) { + private static String fromBits(final long bits) { long bytes = bits / 8; return "" + bytes + ((bits & 7) == 0 ? "" : "(+" + (bits - bytes * 8) + " bits)"); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SszReader.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SszReader.java index 1c0e3465911..77039642703 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SszReader.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SszReader.java @@ -20,7 +20,7 @@ public interface SszReader extends Closeable { /** Creates an instance from {@link Bytes} */ - static SszReader fromBytes(Bytes bytes) { + static SszReader fromBytes(final Bytes bytes) { return new SimpleSszReader(bytes); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SszWriter.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SszWriter.java index 2ecdc157d1e..33a68e3ba3e 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SszWriter.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/sos/SszWriter.java @@ -17,11 +17,11 @@ public interface SszWriter { - default void write(Bytes bytes) { + default void write(final Bytes bytes) { write(bytes.toArrayUnsafe()); } - default void write(byte[] bytes) { + default void write(final byte[] bytes) { write(bytes, 0, bytes.length); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/BranchNode.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/BranchNode.java index 17bf57744f7..6d8669a0eeb 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/BranchNode.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/BranchNode.java @@ -34,7 +34,7 @@ public interface BranchNode extends TreeNode { * @param left Non-null left child * @param right Non-null right child */ - static BranchNode create(TreeNode left, TreeNode right) { + static BranchNode create(final TreeNode left, final TreeNode right) { checkNotNull(left); checkNotNull(right); return new SimpleBranchNode(left, right); @@ -69,7 +69,7 @@ default Bytes32 hashTreeRoot(final Sha256 sha256) { @NotNull @Override - default TreeNode get(long target) { + default TreeNode get(final long target) { checkArgument(target >= 1, "Invalid index: %s", target); if (GIndexUtil.gIdxIsSelf(target)) { return this; @@ -83,7 +83,9 @@ default TreeNode get(long target) { @Override default boolean iterate( - long thisGeneralizedIndex, long startGeneralizedIndex, TreeVisitor visitor) { + final long thisGeneralizedIndex, + final long startGeneralizedIndex, + final TreeVisitor visitor) { if (GIndexUtil.gIdxCompare(thisGeneralizedIndex, startGeneralizedIndex) == NodeRelation.LEFT) { return true; @@ -99,7 +101,7 @@ && right() } @Override - default TreeNode updated(long target, Function nodeUpdater) { + default TreeNode updated(final long target, final Function nodeUpdater) { if (GIndexUtil.gIdxIsSelf(target)) { return nodeUpdater.apply(this); } else { diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/CachingTreeAccessor.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/CachingTreeAccessor.java index 78243c9dc9b..872df5d3d9a 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/CachingTreeAccessor.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/CachingTreeAccessor.java @@ -60,7 +60,7 @@ private static class CachedTreeNode { private final long nodeIndex; private final TreeNode node; - public CachedTreeNode(long nodeIndex, TreeNode node) { + public CachedTreeNode(final long nodeIndex, final TreeNode node) { this.nodeIndex = nodeIndex; this.node = node; } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/GIndexUtil.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/GIndexUtil.java index bf976711d59..6e5594d07e2 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/GIndexUtil.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/GIndexUtil.java @@ -89,7 +89,7 @@ public NodeRelation inverse() { * * @see #SELF_G_INDEX */ - public static boolean gIdxIsSelf(long generalizedIndex) { + public static boolean gIdxIsSelf(final long generalizedIndex) { checkGIndex(generalizedIndex); return generalizedIndex == SELF_G_INDEX; } @@ -106,7 +106,7 @@ public static boolean gIdxIsSelf(long generalizedIndex) { *
  • {@link NodeRelation#SAME}: idx1 is equal to idx2 * */ - public static NodeRelation gIdxCompare(long idx1, long idx2) { + public static NodeRelation gIdxCompare(final long idx1, final long idx2) { checkGIndex(idx1); checkGIndex(idx2); long anchor1 = Long.highestOneBit(idx1); @@ -137,7 +137,7 @@ public static NodeRelation gIdxCompare(long idx1, long idx2) { * Returns the depth of the node denoted by the supplied generalized index. E.g. the depth of the * {@link #SELF_G_INDEX} would be 0 */ - public static int gIdxGetDepth(long generalizedIndex) { + public static int gIdxGetDepth(final long generalizedIndex) { checkGIndex(generalizedIndex); long anchor = Long.highestOneBit(generalizedIndex); return Long.bitCount(anchor - 1); @@ -147,7 +147,7 @@ public static int gIdxGetDepth(long generalizedIndex) { * Returns the generalized index of the left child of the node with specified generalized index * E.g. the result when passing {@link #SELF_G_INDEX} would be 10 */ - public static long gIdxLeftGIndex(long generalizedIndex) { + public static long gIdxLeftGIndex(final long generalizedIndex) { return gIdxChildGIndex(generalizedIndex, 0, 1); } @@ -155,7 +155,7 @@ public static long gIdxLeftGIndex(long generalizedIndex) { * Returns the generalized index of the right child of the node with specified generalized index * E.g. the result when passing {@link #SELF_G_INDEX} would be 11 */ - public static long gIdxRightGIndex(long generalizedIndex) { + public static long gIdxRightGIndex(final long generalizedIndex) { return gIdxChildGIndex(generalizedIndex, 1, 1); } @@ -178,7 +178,8 @@ public static long gIdxRightGIndex(long generalizedIndex) { *
  • gIdxChildGIndex(anyIndex, 1, 1) == gIdxRightGIndex(anyIndex) * */ - public static long gIdxChildGIndex(long generalizedIndex, long childIdx, int childDepth) { + public static long gIdxChildGIndex( + final long generalizedIndex, final long childIdx, final int childDepth) { checkGIndex(generalizedIndex); assert childDepth >= 0 && childDepth <= MAX_DEPTH; assert childIdx >= 0 && childIdx < (1L << childDepth); @@ -195,7 +196,8 @@ public static long gIdxChildGIndex(long generalizedIndex, long childIdx, int chi * @return the zero-based index number of the child at {@code childGeneralizedIndex} in a list of * children {@code childDepth} */ - public static int gIdxChildIndexFromGIndex(long childGeneralizedIndex, int childDepth) { + public static int gIdxChildIndexFromGIndex( + final long childGeneralizedIndex, final int childDepth) { checkGIndex(childGeneralizedIndex); assert childDepth >= 0 && childDepth <= MAX_DEPTH; final long rootGIndex = childGeneralizedIndex >>> childDepth; @@ -215,7 +217,8 @@ public static int gIdxChildIndexFromGIndex(long childGeneralizedIndex, int child *
  • gIdxCompose(0b1000, 0b1111) == 0b1000111 * */ - public static long gIdxCompose(long parentGeneralizedIndex, long childGeneralizedIndex) { + public static long gIdxCompose( + final long parentGeneralizedIndex, final long childGeneralizedIndex) { checkGIndex(parentGeneralizedIndex); checkGIndex(childGeneralizedIndex); assert gIdxGetDepth(parentGeneralizedIndex) + gIdxGetDepth(childGeneralizedIndex) <= MAX_DEPTH; @@ -255,7 +258,7 @@ public static LongList gIdxComposeAll( *
  • gIdxLeftmostFrom(0b1101) == 0b110100000...00L * */ - public static long gIdxLeftmostFrom(long fromGeneralizedIndex) { + public static long gIdxLeftmostFrom(final long fromGeneralizedIndex) { checkGIndex(fromGeneralizedIndex); long highestOneBit = Long.highestOneBit(fromGeneralizedIndex); if (highestOneBit < 0) { @@ -277,7 +280,7 @@ public static long gIdxLeftmostFrom(long fromGeneralizedIndex) { *
  • gIdxRightmostFrom(0b1101) == 0b110111111...11L * */ - public static long gIdxRightmostFrom(long fromGeneralizedIndex) { + public static long gIdxRightmostFrom(final long fromGeneralizedIndex) { checkGIndex(fromGeneralizedIndex); long highestOneBit = Long.highestOneBit(fromGeneralizedIndex); if (highestOneBit < 0) { @@ -305,7 +308,7 @@ public static long gIdxRightmostFrom(long fromGeneralizedIndex) { * is at depth 1 * */ - public static int gIdxGetChildIndex(long generalizedIndex, int childDepth) { + public static int gIdxGetChildIndex(final long generalizedIndex, final int childDepth) { checkGIndex(generalizedIndex); assert childDepth >= 0 && childDepth <= MAX_DEPTH; @@ -329,7 +332,7 @@ public static int gIdxGetChildIndex(long generalizedIndex, int childDepth) { * is at depth 1 * */ - public static long gIdxGetRelativeGIndex(long generalizedIndex, int childDepth) { + public static long gIdxGetRelativeGIndex(final long generalizedIndex, final int childDepth) { checkGIndex(generalizedIndex); assert childDepth >= 0 && childDepth <= MAX_DEPTH; @@ -340,12 +343,12 @@ public static long gIdxGetRelativeGIndex(long generalizedIndex, int childDepth) } @VisibleForTesting - static long gIdxGetParent(long generalizedIndex) { + static long gIdxGetParent(final long generalizedIndex) { checkGIndex(generalizedIndex); return generalizedIndex >>> 1; } - private static void checkGIndex(long index) { + private static void checkGIndex(final long index) { assert index != 0; } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/LeafNode.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/LeafNode.java index 5f6f63e64ff..bb5be51c59e 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/LeafNode.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/LeafNode.java @@ -46,7 +46,7 @@ public interface LeafNode extends TreeNode, LeafDataNode { LeafNode EMPTY_LEAF = ZERO_LEAVES[0]; /** Creates a basic Leaf node instance with the data {@literal <= } 32 bytes */ - static LeafNode create(Bytes data) { + static LeafNode create(final Bytes data) { return new SimpleLeafNode(data); } @@ -73,14 +73,16 @@ default Bytes32 hashTreeRoot() { */ @NotNull @Override - default TreeNode get(long target) { + default TreeNode get(final long target) { checkArgument(target == 1, "Invalid root index: %s", target); return this; } @Override default boolean iterate( - long thisGeneralizedIndex, long startGeneralizedIndex, TreeVisitor visitor) { + final long thisGeneralizedIndex, + final long startGeneralizedIndex, + final TreeVisitor visitor) { if (GIndexUtil.gIdxCompare(thisGeneralizedIndex, startGeneralizedIndex) == NodeRelation.LEFT) { return true; } else { @@ -89,7 +91,7 @@ default boolean iterate( } @Override - default TreeNode updated(long target, Function nodeUpdater) { + default TreeNode updated(final long target, final Function nodeUpdater) { checkArgument(target == 1, "Invalid root index: %s", target); return nodeUpdater.apply(this); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/SimpleBranchNode.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/SimpleBranchNode.java index 3d2e4139c4a..381422d3b38 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/SimpleBranchNode.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/SimpleBranchNode.java @@ -23,7 +23,7 @@ class SimpleBranchNode implements BranchNode, TreeNode { private final TreeNode right; private volatile Bytes32 cachedHash = null; - public SimpleBranchNode(TreeNode left, TreeNode right) { + public SimpleBranchNode(final TreeNode left, final TreeNode right) { this.left = left; this.right = right; } @@ -39,7 +39,7 @@ public TreeNode right() { } @Override - public BranchNode rebind(boolean left, TreeNode newNode) { + public BranchNode rebind(final boolean left, final TreeNode newNode) { return left ? new SimpleBranchNode(newNode, right()) : new SimpleBranchNode(left(), newNode); } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/SimpleLeafNode.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/SimpleLeafNode.java index 6e7537732ef..c216e0a035d 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/SimpleLeafNode.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/SimpleLeafNode.java @@ -26,7 +26,7 @@ class SimpleLeafNode implements LeafNode, TreeNode { private final Bytes data; private volatile Bytes32 cachedHash; - public SimpleLeafNode(Bytes data) { + public SimpleLeafNode(final Bytes data) { checkArgument(data.size() <= MAX_BYTE_SIZE); if (data.size() == MAX_BYTE_SIZE) { // if data is Bytes32, it will pass throw with no object creation @@ -77,7 +77,7 @@ public TreeNode updated(final TreeUpdates newNodes) { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/SszNodeTemplate.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/SszNodeTemplate.java index 9b7c13e6b35..d6ad2e65010 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/SszNodeTemplate.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/SszNodeTemplate.java @@ -44,13 +44,13 @@ static final class Location { private final int length; private final boolean leaf; - public Location(int offset, int length, boolean leaf) { + public Location(final int offset, final int length, final boolean leaf) { this.offset = offset; this.length = length; this.leaf = leaf; } - public Location withAddedOffset(int addOffset) { + public Location withAddedOffset(final int addOffset) { return new Location(getOffset() + addOffset, getLength(), isLeaf()); } @@ -67,21 +67,21 @@ public boolean isLeaf() { } } - public static SszNodeTemplate createFromType(SszSchema sszSchema) { + public static SszNodeTemplate createFromType(final SszSchema sszSchema) { checkArgument(sszSchema.isFixedSize(), "Only fixed size types supported"); return createFromTree(sszSchema.getDefaultTree()); } // This should be CANONICAL binary tree - private static SszNodeTemplate createFromTree(TreeNode defaultTree) { + private static SszNodeTemplate createFromTree(final TreeNode defaultTree) { Map gIdxToLoc = binaryTraverse( GIndexUtil.SELF_G_INDEX, defaultTree, new BinaryVisitor<>() { @Override - public Map visitLeaf(long gIndex, LeafNode node) { + public Map visitLeaf(final long gIndex, final LeafNode node) { Long2ObjectMap ret = new Long2ObjectOpenHashMap(); ret.put(gIndex, new Location(0, node.getData().size(), true)); return ret; @@ -89,10 +89,10 @@ public Map visitLeaf(long gIndex, LeafNode node) { @Override public Map visitBranch( - long gIndex, - TreeNode node, - Map leftVisitResult, - Map rightVisitResult) { + final long gIndex, + final TreeNode node, + final Map leftVisitResult, + final Map rightVisitResult) { Location leftChildLoc = leftVisitResult.get(gIdxLeftGIndex(gIndex)); Location rightChildLoc = rightVisitResult.get(gIdxRightGIndex(gIndex)); rightVisitResult.replaceAll( @@ -107,7 +107,7 @@ public Map visitBranch( return new SszNodeTemplate(gIdxToLoc, defaultTree); } - private static List nodeSsz(TreeNode node) { + private static List nodeSsz(final TreeNode node) { List sszBytes = new ArrayList<>(); TreeUtil.iterateLeavesData(node, LEFTMOST_G_INDEX, RIGHTMOST_G_INDEX, sszBytes::add); return sszBytes; @@ -117,12 +117,12 @@ private static List nodeSsz(TreeNode node) { private final TreeNode defaultTree; private final Map subTemplatesCache = new ConcurrentHashMap<>(); - public SszNodeTemplate(Map gIdxToLoc, TreeNode defaultTree) { + public SszNodeTemplate(final Map gIdxToLoc, final TreeNode defaultTree) { this.gIdxToLoc = gIdxToLoc; this.defaultTree = defaultTree; } - public Location getNodeSszLocation(long generalizedIndex) { + public Location getNodeSszLocation(final long generalizedIndex) { return gIdxToLoc.get(generalizedIndex); } @@ -130,11 +130,11 @@ public int getSszLength() { return gIdxToLoc.get(SELF_G_INDEX).getLength(); } - public SszNodeTemplate getSubTemplate(long generalizedIndex) { + public SszNodeTemplate getSubTemplate(final long generalizedIndex) { return subTemplatesCache.computeIfAbsent(generalizedIndex, this::calcSubTemplate); } - private SszNodeTemplate calcSubTemplate(long generalizedIndex) { + private SszNodeTemplate calcSubTemplate(final long generalizedIndex) { if (gIdxIsSelf(generalizedIndex)) { return this; } @@ -142,11 +142,12 @@ private SszNodeTemplate calcSubTemplate(long generalizedIndex) { return createFromTree(subTree); } - public void update(long generalizedIndex, TreeNode newNode, MutableBytes dest) { + public void update(final long generalizedIndex, final TreeNode newNode, final MutableBytes dest) { update(generalizedIndex, nodeSsz(newNode), dest); } - private void update(long generalizedIndex, List nodeSsz, MutableBytes dest) { + private void update( + final long generalizedIndex, final List nodeSsz, final MutableBytes dest) { Location leafPos = getNodeSszLocation(generalizedIndex); int off = 0; for (int i = 0; i < nodeSsz.size(); i++) { @@ -163,21 +164,24 @@ public Bytes32 calculateHashTreeRoot(final Bytes ssz, final int offset, final Sh defaultTree, new BinaryVisitor<>() { @Override - public Bytes32 visitLeaf(long gIndex, LeafNode node) { + public Bytes32 visitLeaf(final long gIndex, final LeafNode node) { Location location = gIdxToLoc.get(gIndex); return Bytes32.rightPad(ssz.slice(offset + location.getOffset(), location.getLength())); } @Override public Bytes32 visitBranch( - long gIndex, TreeNode node, Bytes32 leftVisitResult, Bytes32 rightVisitResult) { + final long gIndex, + final TreeNode node, + final Bytes32 leftVisitResult, + final Bytes32 rightVisitResult) { return Bytes32.wrap(sha256.digest(leftVisitResult, rightVisitResult)); } }); } private static T binaryTraverse( - long gIndex, final TreeNode node, final BinaryVisitor visitor) { + final long gIndex, final TreeNode node, final BinaryVisitor visitor) { if (node instanceof LeafNode) { return visitor.visitLeaf(gIndex, (LeafNode) node); } else if (node instanceof BranchNode branchNode) { diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/SszSuperNode.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/SszSuperNode.java index 8f5cfeb208c..9fed2d98e39 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/SszSuperNode.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/SszSuperNode.java @@ -50,7 +50,7 @@ public class SszSuperNode implements TreeNode, LeafDataNode { private final Bytes ssz; private volatile Bytes32 cachedHash; - public SszSuperNode(int depth, SszNodeTemplate elementTemplate, Bytes ssz) { + public SszSuperNode(final int depth, final SszNodeTemplate elementTemplate, final Bytes ssz) { this.depth = depth; this.elementTemplate = elementTemplate; this.ssz = ssz; @@ -112,7 +112,7 @@ private Bytes32 hashTreeRoot(final int curDepth, final int offset, final Sha256 @NotNull @Override - public TreeNode get(long generalizedIndex) { + public TreeNode get(final long generalizedIndex) { if (GIndexUtil.gIdxIsSelf(generalizedIndex)) { return this; } @@ -135,7 +135,9 @@ public TreeNode get(long generalizedIndex) { @Override public boolean iterate( - long thisGeneralizedIndex, long startGeneralizedIndex, TreeVisitor visitor) { + final long thisGeneralizedIndex, + final long startGeneralizedIndex, + final TreeVisitor visitor) { if (GIndexUtil.gIdxCompare(thisGeneralizedIndex, startGeneralizedIndex) == NodeRelation.LEFT) { return true; } else { diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/TillIndexVisitor.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/TillIndexVisitor.java index ef2df2ede03..f6ed5ce118e 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/TillIndexVisitor.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/TillIndexVisitor.java @@ -17,7 +17,7 @@ class TillIndexVisitor implements TreeVisitor { - static TreeVisitor create(TreeVisitor delegate, long tillGeneralizedIndex) { + static TreeVisitor create(final TreeVisitor delegate, final long tillGeneralizedIndex) { return new TillIndexVisitor(delegate, tillGeneralizedIndex, true); } @@ -25,14 +25,15 @@ static TreeVisitor create(TreeVisitor delegate, long tillGeneralizedIndex) { private final long tillGIndex; private final boolean inclusive; - public TillIndexVisitor(TreeVisitor delegate, long tillGIndex, boolean inclusive) { + public TillIndexVisitor( + final TreeVisitor delegate, final long tillGIndex, final boolean inclusive) { this.delegate = delegate; this.tillGIndex = tillGIndex; this.inclusive = inclusive; } @Override - public boolean visit(TreeNode node, long generalizedIndex) { + public boolean visit(final TreeNode node, final long generalizedIndex) { NodeRelation compareRes = GIndexUtil.gIdxCompare(generalizedIndex, tillGIndex); if (inclusive && compareRes == NodeRelation.RIGHT) { return false; diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/TreeNode.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/TreeNode.java index 2ef02908498..7d16b264554 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/TreeNode.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/TreeNode.java @@ -88,7 +88,9 @@ default Bytes32 hashTreeRoot() { * endGeneralizedIndexInclusive equal to {@link GIndexUtil#RIGHTMOST_G_INDEX} */ default void iterateRange( - long startGeneralizedIndex, long endGeneralizedIndexInclusive, TreeVisitor visitor) { + final long startGeneralizedIndex, + final long endGeneralizedIndexInclusive, + final TreeVisitor visitor) { iterate( GIndexUtil.SELF_G_INDEX, startGeneralizedIndex, @@ -96,12 +98,12 @@ default void iterateRange( } /** Iterates all tree nodes in the order Self -> Left subtree -> Right subtree */ - default void iterateAll(TreeVisitor visitor) { + default void iterateAll(final TreeVisitor visitor) { iterate(GIndexUtil.SELF_G_INDEX, GIndexUtil.LEFTMOST_G_INDEX, visitor); } /** Iterates all tree nodes in the order Self -> Left subtree -> Right subtree */ - default void iterateAll(Consumer simpleVisitor) { + default void iterateAll(final Consumer simpleVisitor) { iterateAll( (node, __) -> { simpleVisitor.accept(node); @@ -120,7 +122,8 @@ default void iterateAll(Consumer simpleVisitor) { * @see #updated(long, TreeNode) * @see #updated(long, Function) */ - default TreeNode updated(long generalizedIndex, Function nodeUpdater) { + default TreeNode updated( + final long generalizedIndex, final Function nodeUpdater) { TreeNode newNode = nodeUpdater.apply(get(generalizedIndex)); return updated( new TreeUpdates(singletonList(new TreeUpdates.Update(generalizedIndex, newNode)))); @@ -158,7 +161,7 @@ default TreeNode updated(final TreeUpdates newNodes) { * @see #updated(long, TreeNode) * @see #updated(long, Function) */ - default TreeNode updated(long generalizedIndex, TreeNode node) { + default TreeNode updated(final long generalizedIndex, final TreeNode node) { return updated(generalizedIndex, oldNode -> node); } } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/TreeUpdates.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/TreeUpdates.java index de05e01898d..faa24ff4ab3 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/TreeUpdates.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/TreeUpdates.java @@ -33,7 +33,7 @@ public static class Update { private final long generalizedIndex; private final TreeNode newNode; - public Update(long generalizedIndex, TreeNode newNode) { + public Update(final long generalizedIndex, final TreeNode newNode) { this.generalizedIndex = generalizedIndex; this.newNode = newNode; } @@ -72,27 +72,34 @@ public TreeNode getNewNode() { * * @throws IllegalArgumentException if the list doesn't conform to above restrictions */ - public TreeUpdates(List updates) { + public TreeUpdates(final List updates) { this( updates.stream().map(Update::getGeneralizedIndex).toList(), updates.stream().map(Update::getNewNode).toList()); } - public TreeUpdates(List gIndices, List nodes) { + public TreeUpdates(final List gIndices, final List nodes) { this(gIndices, nodes, 1, getDepthAndValidate(gIndices)); } - public TreeUpdates(List gIndices, List nodes, int depth) { + public TreeUpdates(final List gIndices, final List nodes, final int depth) { this(gIndices, nodes, 1, depth); assert depth == getDepthAndValidate(gIndices); } private static TreeUpdates create( - List gIndices, List nodes, long prefix, int heightFromLeaf) { + final List gIndices, + final List nodes, + final long prefix, + final int heightFromLeaf) { return new TreeUpdates(gIndices, nodes, prefix, heightFromLeaf); } - private TreeUpdates(List gIndices, List nodes, long prefix, int heightFromLeaf) { + private TreeUpdates( + final List gIndices, + final List nodes, + final long prefix, + final int heightFromLeaf) { assert gIndices.size() == nodes.size(); this.gIndices = gIndices; @@ -138,21 +145,21 @@ public boolean isEmpty() { /** Gets generalized index for update at position [index] */ @VisibleForTesting - long getGIndex(int index) { + long getGIndex(final int index) { return gIndices.get(index); } /** Calculates and returns relative generalized index */ - public long getRelativeGIndex(int index) { + public long getRelativeGIndex(final int index) { return GIndexUtil.gIdxGetRelativeGIndex(gIndices.get(index), GIndexUtil.gIdxGetDepth(prefix)); } /** Gets new tree node for update at position [index] */ - public TreeNode getNode(int index) { + public TreeNode getNode(final int index) { return nodes.get(index); } - private static int getDepthAndValidate(List gIndices) { + private static int getDepthAndValidate(final List gIndices) { if (gIndices.isEmpty()) { return 0; } diff --git a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/TreeUtil.java b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/TreeUtil.java index 01a13855f94..b05c7e9bafd 100644 --- a/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/TreeUtil.java +++ b/infrastructure/ssz/src/main/java/tech/pegasys/teku/infrastructure/ssz/tree/TreeUtil.java @@ -27,7 +27,7 @@ public class TreeUtil { public static class ZeroLeafNode extends SimpleLeafNode { - public ZeroLeafNode(int size) { + public ZeroLeafNode(final int size) { super(Bytes.wrap(new byte[size])); } @@ -40,7 +40,7 @@ public String toString() { public static class ZeroBranchNode extends SimpleBranchNode { private final int height; - public ZeroBranchNode(TreeNode left, TreeNode right, int height) { + public ZeroBranchNode(final TreeNode left, final TreeNode right, final int height) { super(left, right); this.height = height; } @@ -66,11 +66,11 @@ public String toString() { ZERO_TREES_BY_ROOT = mapBuilder.build(); } - public static int bitsCeilToBytes(int bits) { + public static int bitsCeilToBytes(final int bits) { return (bits + 7) / 8; } - public static long bitsCeilToBytes(long bits) { + public static long bitsCeilToBytes(final long bits) { return (bits + 7) / 8; } @@ -83,17 +83,18 @@ public static long bitsCeilToBytes(long bits) { * @param defaultNode default leaf element. For complex vectors it could be default vector element * struct subtree */ - public static TreeNode createDefaultTree(long maxLength, TreeNode defaultNode) { + public static TreeNode createDefaultTree(final long maxLength, final TreeNode defaultNode) { return createTree( defaultNode, LeafNode.EMPTY_LEAF.equals(defaultNode) ? 0 : maxLength, treeDepth(maxLength)); } /** Creates a binary tree of width `nextPowerOf2(leafNodes.size())` with specific leaf nodes */ - public static TreeNode createTree(List children) { + public static TreeNode createTree(final List children) { return createTree(children, treeDepth(children.size())); } - private static TreeNode createTree(TreeNode defaultNode, long defaultNodesCount, int depth) { + private static TreeNode createTree( + final TreeNode defaultNode, final long defaultNodesCount, final int depth) { if (defaultNodesCount == 0) { return ZERO_TREES[depth]; } else if (depth == 0) { @@ -111,7 +112,7 @@ private static TreeNode createTree(TreeNode defaultNode, long defaultNodesCount, } } - public static TreeNode createTree(List leafNodes, int depth) { + public static TreeNode createTree(final List leafNodes, final int depth) { if (leafNodes.isEmpty()) { return ZERO_TREES[depth]; } else if (depth == 0) { @@ -129,7 +130,7 @@ public static TreeNode createTree(List leafNodes, int depth) } public static TreeNode createTree( - List leafNodes, TreeNode defaultNode, int depth) { + final List leafNodes, final TreeNode defaultNode, final int depth) { if (leafNodes.isEmpty()) { if (depth > 0) { TreeNode defaultChild = createTree(leafNodes, defaultNode, depth - 1); @@ -152,11 +153,11 @@ public static TreeNode createTree( } } - public static long nextPowerOf2(long x) { + public static long nextPowerOf2(final long x) { return x <= 1 ? 1 : Long.highestOneBit(x - 1) << 1; } - public static int treeDepth(long maxChunks) { + public static int treeDepth(final long maxChunks) { return Long.bitCount(nextPowerOf2(maxChunks) - 1); } @@ -168,7 +169,10 @@ public static int treeDepth(long maxChunks) { */ @VisibleForTesting static void iterateLeaves( - TreeNode node, long fromGeneralIndex, long toGeneralIndex, Consumer visitor) { + final TreeNode node, + final long fromGeneralIndex, + final long toGeneralIndex, + final Consumer visitor) { node.iterateRange( fromGeneralIndex, toGeneralIndex, @@ -181,7 +185,10 @@ static void iterateLeaves( } public static void iterateLeavesData( - TreeNode node, long fromGeneralIndex, long toGeneralIndex, Consumer visitor) { + final TreeNode node, + final long fromGeneralIndex, + final long toGeneralIndex, + final Consumer visitor) { node.iterateRange( fromGeneralIndex, toGeneralIndex, @@ -193,7 +200,7 @@ public static void iterateLeavesData( }); } - public static Bytes concatenateLeavesData(TreeNode tree) { + public static Bytes concatenateLeavesData(final TreeNode tree) { List leavesData = new ArrayList<>(); iterateLeavesData( tree, GIndexUtil.LEFTMOST_G_INDEX, GIndexUtil.RIGHTMOST_G_INDEX, leavesData::add); diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/AbstractSszImmutableContainerTest.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/AbstractSszImmutableContainerTest.java index 8a9fbe8b7ed..255175d9809 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/AbstractSszImmutableContainerTest.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/AbstractSszImmutableContainerTest.java @@ -32,7 +32,8 @@ public Stream sszData() { @MethodSource("sszDataArguments") @ParameterizedTest - void createWritableCopy_throwsUnsupportedOperation(AbstractSszImmutableContainer container) { + void createWritableCopy_throwsUnsupportedOperation( + final AbstractSszImmutableContainer container) { assertThatThrownBy(container::createWritableCopy) .isInstanceOf(UnsupportedOperationException.class); } diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszCollectionTestBase.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszCollectionTestBase.java index 890d95ec76c..89d8ee66925 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszCollectionTestBase.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszCollectionTestBase.java @@ -24,7 +24,7 @@ public interface SszCollectionTestBase extends SszCompositeTestBase { @MethodSource("sszDataArguments") @ParameterizedTest - default void size_matchesReturnedData(SszCollection data) { + default void size_matchesReturnedData(final SszCollection data) { assertThat(data.asList()).hasSize(data.size()); assertThat(data.stream()).hasSize(data.size()); assertThat(data).hasSize(data.size()); @@ -32,13 +32,13 @@ default void size_matchesReturnedData(SszCollection data) { @MethodSource("sszDataArguments") @ParameterizedTest - default void stream_returnsSameData(SszCollection data) { + default void stream_returnsSameData(final SszCollection data) { assertThat(data.stream()).containsExactlyElementsOf(data); } @MethodSource("sszDataArguments") @ParameterizedTest - default void asList_returnsSameData(SszCollection data) { + default void asList_returnsSameData(final SszCollection data) { List list = data.asList(); assertThat(list.size()).isEqualTo(data.size()); for (int i = 0; i < list.size(); i++) { @@ -48,7 +48,7 @@ default void asList_returnsSameData(SszCollection data) { @MethodSource("sszDataArguments") @ParameterizedTest - default void asList_isUnmodifiable(SszCollection data) { + default void asList_isUnmodifiable(final SszCollection data) { List list = data.asList(); C newElement = data.getSchema().getElementSchema().getDefault(); assertThatThrownBy(() -> list.add(newElement)) diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszCompositeListTest.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszCompositeListTest.java index 813afe36e0f..377b08ff7fe 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszCompositeListTest.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszCompositeListTest.java @@ -35,7 +35,7 @@ public class SszCompositeListTest { - static SszSchema testType = + static final SszSchema TEST_TYPE = new SszSchema<>() { @Override @@ -49,7 +49,7 @@ public TestView getDefault() { } @Override - public TestView createFromBackingNode(TreeNode node) { + public TestView createFromBackingNode(final TreeNode node) { return new TestView(node); } @@ -90,17 +90,17 @@ public int getSszFixedPartSize() { } @Override - public int getSszVariablePartSize(TreeNode node) { + public int getSszVariablePartSize(final TreeNode node) { return 0; } @Override - public int sszSerializeTree(TreeNode node, SszWriter writer) { + public int sszSerializeTree(final TreeNode node, final SszWriter writer) { return 0; } @Override - public TreeNode sszDeserializeTree(SszReader reader) { + public TreeNode sszDeserializeTree(final SszReader reader) { return null; } @@ -115,18 +115,18 @@ static class TestView implements SszData { TreeNode node; public final int v; - public TestView(int v) { + public TestView(final int v) { this.v = v; } - public TestView(TreeNode node) { + public TestView(final TreeNode node) { this.node = node; this.v = node.hashTreeRoot().trimLeadingZeros().toInt(); } @Override public SszSchema getSchema() { - return testType; + return TEST_TYPE; } @Override @@ -145,7 +145,7 @@ public SszMutableData createWritableCopy() { @Test public void simpleTest1() { - SszListSchema listType = SszListSchema.create(testType, 3); + SszListSchema listType = SszListSchema.create(TEST_TYPE, 3); SszMutableList list = listType.getDefault().createWritableCopy(); TreeNode n0 = list.commitChanges().getBackingNode(); list.set(0, new TestView(0x111)); diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszCompositeTestBase.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszCompositeTestBase.java index c918b890c76..7b216dec86d 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszCompositeTestBase.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszCompositeTestBase.java @@ -26,7 +26,7 @@ public interface SszCompositeTestBase extends SszDataTestBase { @MethodSource("sszDataArguments") @ParameterizedTest - default void get_childSchemaMatches(SszComposite data) { + default void get_childSchemaMatches(final SszComposite data) { SszCompositeSchema schema = data.getSchema(); for (int i = 0; i < data.size(); i++) { SszData child = data.get(i); @@ -39,7 +39,7 @@ default void get_childSchemaMatches(SszComposite data) { @MethodSource("sszDataArguments") @ParameterizedTest - default void get_throwsOutOfBounds(SszComposite data) { + default void get_throwsOutOfBounds(final SszComposite data) { assertThatThrownBy(() -> data.get(-1)).isInstanceOf(IndexOutOfBoundsException.class); assertThatThrownBy(() -> data.get(data.size())).isInstanceOf(IndexOutOfBoundsException.class); assertThatThrownBy( @@ -49,7 +49,7 @@ default void get_throwsOutOfBounds(SszComposite data) { @MethodSource("sszDataArguments") @ParameterizedTest - default void size_shouldBeLessOrEqualThanMaxLength(SszComposite data) { + default void size_shouldBeLessOrEqualThanMaxLength(final SszComposite data) { Assertions.assertThat((long) data.size()).isLessThanOrEqualTo(data.getSchema().getMaxLength()); } } diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszDataTestBase.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszDataTestBase.java index c8507d89546..3b2439d9251 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszDataTestBase.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszDataTestBase.java @@ -17,7 +17,6 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy; import java.util.List; -import java.util.stream.Collectors; import java.util.stream.Stream; import org.apache.tuweni.bytes.Bytes; import org.assertj.core.api.Assertions; @@ -33,8 +32,8 @@ public interface SszDataTestBase { // workaround for https://github.com/junit-team/junit5/issues/1477 - static Stream passWhenEmpty(Stream args) { - List list = args.collect(Collectors.toList()); + static Stream passWhenEmpty(final Stream args) { + List list = args.toList(); Assumptions.assumeFalse(list.isEmpty()); return list.stream(); } @@ -63,7 +62,7 @@ default Stream sszDataArguments() { @MethodSource("sszDataArguments") @ParameterizedTest - default void sszSerialize_testSszRoundtrip(SszData data) { + default void sszSerialize_testSszRoundtrip(final SszData data) { Bytes ssz = data.sszSerialize(); SszData data1 = data.getSchema().sszDeserialize(ssz); SszDataAssert.assertThatSszData(data1).isEqualByAllMeansTo(data); @@ -71,7 +70,7 @@ default void sszSerialize_testSszRoundtrip(SszData data) { @MethodSource("sszDataArguments") @ParameterizedTest - default void getBackingNode_testTreeRoundtrip(SszData data) { + default void getBackingNode_testTreeRoundtrip(final SszData data) { TreeNode tree = data.getBackingNode(); SszData data1 = data.getSchema().createFromBackingNode(tree); SszDataAssert.assertThatSszData(data1).isEqualByAllMeansTo(data); @@ -79,7 +78,7 @@ default void getBackingNode_testTreeRoundtrip(SszData data) { @MethodSource("sszWritableDataArguments") @ParameterizedTest - default void createWritableCopy_commitShouldReturnEqualInstance(SszData data) { + default void createWritableCopy_commitShouldReturnEqualInstance(final SszData data) { SszMutableData writableCopy = data.createWritableCopy(); SszData data1 = writableCopy.commitChanges(); SszDataAssert.assertThatSszData(data1).isEqualByAllMeansTo(data); @@ -87,7 +86,7 @@ default void createWritableCopy_commitShouldReturnEqualInstance(SszData data) { @MethodSource("sszWritableDataArguments") @ParameterizedTest - default void createWritableCopy_shouldBeSszEqualToOriginal(SszData data) { + default void createWritableCopy_shouldBeSszEqualToOriginal(final SszData data) { SszMutableData writableCopy = data.createWritableCopy(); SszDataAssert.assertThatSszData((SszData) writableCopy) .isEqualBySszTo(data) @@ -97,25 +96,25 @@ default void createWritableCopy_shouldBeSszEqualToOriginal(SszData data) { @MethodSource("sszNonWritableDataArguments") @ParameterizedTest - default void createWritableCopy_shouldThrowUnsupported(SszData data) { + default void createWritableCopy_shouldThrowUnsupported(final SszData data) { assertThatThrownBy(data::createWritableCopy).isInstanceOf(UnsupportedOperationException.class); } @MethodSource("sszNonWritableDataArguments") @ParameterizedTest - default void isWritableSupported_shouldReturnFalse(SszData data) { + default void isWritableSupported_shouldReturnFalse(final SszData data) { assertThat(data.isWritableSupported()).isFalse(); } @MethodSource("sszWritableDataArguments") @ParameterizedTest - default void isWritableSupported_shouldReturnTrue(SszData data) { + default void isWritableSupported_shouldReturnTrue(final SszData data) { assertThat(data.isWritableSupported()).isTrue(); } @MethodSource("sszDataArguments") @ParameterizedTest - default void getSchema_shouldBeTheSame(SszData data) { + default void getSchema_shouldBeTheSame(final SszData data) { Assertions.assertThat(data.getSchema()).isSameAs(data.getSchema()); Assertions.assertThat(data.getSchema().getDefault().getSchema()).isSameAs(data.getSchema()); if (data.isWritableSupported()) { @@ -127,7 +126,7 @@ default void getSchema_shouldBeTheSame(SszData data) { @MethodSource("sszDataArguments") @ParameterizedTest - default void hashTreeRoot_shouldBeEqual(SszData data) { + default void hashTreeRoot_shouldBeEqual(final SszData data) { assertThat(data.hashTreeRoot()).isEqualTo(data.hashTreeRoot()); if (data.isWritableSupported()) { assertThat(data.createWritableCopy().hashTreeRoot()).isEqualTo(data.hashTreeRoot()); @@ -138,7 +137,7 @@ default void hashTreeRoot_shouldBeEqual(SszData data) { @MethodSource("sszWritableDataArguments") @ParameterizedTest - default void clear_shouldYieldDefault(SszData data) { + default void clear_shouldYieldDefault(final SszData data) { SszMutableData mutableData = data.createWritableCopy(); mutableData.clear(); SszData data1 = mutableData.commitChanges(); diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszListHintsTest.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszListHintsTest.java index a3a62c34701..8753c94e99c 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszListHintsTest.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszListHintsTest.java @@ -43,7 +43,7 @@ public class SszListHintsTest { List> createListVariants( - SszListSchema type, SszList list0) { + final SszListSchema type, final SszList list0) { List> ret = new ArrayList<>(); ret.add(list0); if (!(list0 instanceof SszMutableData)) { @@ -54,12 +54,12 @@ List> createListVariants( } void assertEmptyListVariants( - SszListSchema type, SszList list0) { + final SszListSchema type, final SszList list0) { createListVariants(type, list0).forEach(l -> assertEmptyList(type, l)); } void assertEmptyList( - SszListSchema type, SszList list) { + final SszListSchema type, final SszList list) { if (!(list instanceof SszMutableData)) { assertThat(list.hashTreeRoot()).isEqualTo(type.getDefaultTree().hashTreeRoot()); @@ -74,12 +74,16 @@ void assertEmptyList( } void assertListElementsVariants( - SszListSchema type, SszList list0, List expectedElements) { + final SszListSchema type, + final SszList list0, + final List expectedElements) { createListVariants(type, list0).forEach(l -> assertListElements(type, l, expectedElements)); } void assertListElements( - SszListSchema type, SszList list, List expectedElements) { + final SszListSchema type, + final SszList list, + final List expectedElements) { assertThat(list.isEmpty()).isFalse(); assertThat(list.size()).isEqualTo(expectedElements.size()); @@ -93,18 +97,19 @@ void assertListElements( } void assertListEqualsVariants( - SszListSchema type, SszList list1, SszList list2) { + final SszListSchema type, + final SszList list1, + final SszList list2) { List> listVariants1 = createListVariants(type, list1); List> listVariants2 = createListVariants(type, list2); listVariants1.forEach( listVariant1 -> - listVariants2.forEach( - listVariant2 -> assertListEquals(type, listVariant1, listVariant2))); + listVariants2.forEach(listVariant2 -> assertListEquals(listVariant1, listVariant2))); } void assertListEquals( - SszListSchema type, SszList list1, SszList list2) { + final SszList list1, final SszList list2) { assertThat(list1.size()).isEqualTo(list2.size()); assertThat(list1).isEqualTo(list2); @@ -180,7 +185,7 @@ static Stream listTypesTestParameters() { } static List> generateTypesWithHints( - SszListSchema originalType) { + final SszListSchema originalType) { return Stream.concat( Stream.of(originalType), IntStream.of(0, 1, 2, 4, 8, 10) @@ -199,9 +204,9 @@ static Stream listTypesTestParameters() { @ParameterizedTest @MethodSource("listTypesTestParameters") void testIdenticalTypes( - SszSchema listElementType, - long maxListSize, - Supplier listElementsFactory) { + final SszSchema listElementType, + final long maxListSize, + final Supplier listElementsFactory) { List> types = generateTypesWithHints(SszListSchema.create(listElementType, maxListSize)); @@ -227,9 +232,9 @@ void testIdenticalTypes( @SuppressWarnings("JavaCase") void testList( - SszListSchema type, - Supplier listElementsFactory, - Consumer> results) { + final SszListSchema type, + final Supplier listElementsFactory, + final Consumer> results) { SszList def = type.getDefault(); assertEmptyListVariants(type, def); @@ -339,7 +344,7 @@ private static class RewindingSupplier implements Supplier { private final List memory = new ArrayList<>(); private int memoryPos = 0; - public RewindingSupplier(Supplier origin) { + public RewindingSupplier(final Supplier origin) { this.origin = origin; } diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszListTestBase.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszListTestBase.java index 1dac347ec87..1f879d0f299 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszListTestBase.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszListTestBase.java @@ -28,7 +28,7 @@ public interface SszListTestBase extends SszCollectionTestBase { @MethodSource("sszDataArguments") @ParameterizedTest - default void sszSerialize_emptyNonBitListShouldResultInEmptySsz(SszList data) { + default void sszSerialize_emptyNonBitListShouldResultInEmptySsz(final SszList data) { Assumptions.assumeTrue(data.isEmpty()); Assumptions.assumeTrue( !data.getSchema().getElementSchema().equals(SszPrimitiveSchemas.BIT_SCHEMA)); @@ -37,7 +37,7 @@ default void sszSerialize_emptyNonBitListShouldResultInEmptySsz(SszList data) @MethodSource("sszDataArguments") @ParameterizedTest - default void hashTreeRoot_testEmptyListHash(SszList data) { + default void hashTreeRoot_testEmptyListHash(final SszList data) { Assumptions.assumeTrue(data.isEmpty()); assertThat(data.hashTreeRoot()) diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszMutableCompositeTestBase.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszMutableCompositeTestBase.java index 3d8216e3997..88aa9e62e99 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszMutableCompositeTestBase.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszMutableCompositeTestBase.java @@ -39,7 +39,7 @@ public interface SszMutableCompositeTestBase extends SszCompositeTestBase { SszData NON_EXISTING_SCHEMA_DATA = NON_EXISTING_SCHEMA.getDefault(); RandomSszDataGenerator GENERATOR = new RandomSszDataGenerator(); - static SszData getSomeNewChild(SszCompositeSchema schema) { + static SszData getSomeNewChild(final SszCompositeSchema schema) { final SszSchema childSchema; if (schema instanceof SszListSchema) { childSchema = ((SszListSchema) schema).getElementSchema(); @@ -88,7 +88,7 @@ default Stream sszMutableCompositeWithUpdateIndicesArguments() { @MethodSource("sszMutableCompositeArguments") @ParameterizedTest - default void set_throwsIndexOutOfBounds(SszMutableComposite data) { + default void set_throwsIndexOutOfBounds(final SszMutableComposite data) { SszData someData = getSomeNewChild(data.getSchema()); assertThatThrownBy(() -> data.set(data.size() + 1, someData)) .isInstanceOf(IndexOutOfBoundsException.class); @@ -97,7 +97,7 @@ default void set_throwsIndexOutOfBounds(SszMutableComposite data) { @MethodSource("sszMutableCompositeArguments") @ParameterizedTest - default void set_throwsNPE(SszMutableComposite data) { + default void set_throwsNPE(final SszMutableComposite data) { if (data.getSchema().getMaxLength() == 0) { return; } @@ -106,7 +106,7 @@ default void set_throwsNPE(SszMutableComposite data) { @MethodSource("sszMutableCompositeArguments") @ParameterizedTest - default void set_shouldThrowWhenSchemaMismatch(SszMutableComposite data) { + default void set_shouldThrowWhenSchemaMismatch(final SszMutableComposite data) { Assumptions.assumeThat(data).isNotInstanceOf(SszMutablePrimitiveCollection.class); for (int i = 0; i < data.size(); i++) { @@ -117,7 +117,8 @@ default void set_shouldThrowWhenSchemaMismatch(SszMutableComposite data @MethodSource("sszMutableCompositeWithUpdateIndicesArguments") @ParameterizedTest - default void set_shouldMatchGet(SszMutableComposite data, List updateIndices) { + default void set_shouldMatchGet( + final SszMutableComposite data, final List updateIndices) { SszComposite origData = data.commitChanges(); SszCompositeSchema> schema = data.getSchema(); @@ -171,13 +172,13 @@ default void set_shouldMatchGet(SszMutableComposite data, List @MethodSource("sszMutableCompositeArguments") @ParameterizedTest - default void set_shouldNotHaveSideEffects(SszMutableComposite data) { + default void set_shouldNotHaveSideEffects(final SszMutableComposite data) { List updatedIndices = IntStream.concat(IntStream.range(0, 2), IntStream.of(data.size() - 1)) .distinct() .filter(i -> i >= 0 && i < data.size()) .boxed() - .collect(Collectors.toList()); + .toList(); SszComposite origData = data.commitChanges(); @@ -215,7 +216,7 @@ default void set_shouldNotHaveSideEffects(SszMutableComposite data) { @MethodSource("sszMutableCompositeArguments") @ParameterizedTest - default void set_shouldAppendOnExtendableStructures(SszMutableComposite data) { + default void set_shouldAppendOnExtendableStructures(final SszMutableComposite data) { if (data.size() < data.getSchema().getMaxLength()) { // the structure could be extended (just a List for now) int origSize = data.size(); @@ -235,7 +236,7 @@ default void set_shouldAppendOnExtendableStructures(SszMutableComposite @MethodSource("sszMutableCompositeArguments") @ParameterizedTest default void set_shouldThrowWhenSetAboveSizeForExtendableStructures( - SszMutableComposite data) { + final SszMutableComposite data) { if (data.size() < data.getSchema().getMaxLength()) { // the structure could be extended (just a List case for now) assertThatThrownBy( @@ -249,7 +250,7 @@ default void set_shouldThrowWhenSetAboveSizeForExtendableStructures( @MethodSource("sszMutableCompositeArguments") @ParameterizedTest - default void set_shouldThrowWhenAppendingAboveMaxLen(SszMutableComposite data) { + default void set_shouldThrowWhenAppendingAboveMaxLen(final SszMutableComposite data) { long maxLengthLong = data.getSchema().getMaxLength(); if (maxLengthLong <= 1024) { final int maxLength = (int) maxLengthLong; @@ -265,7 +266,7 @@ default void set_shouldThrowWhenAppendingAboveMaxLen(SszMutableComposite data) { + default void setInvalidator_shouldBeNotifiedOnSet(final SszMutableComposite data) { if (data.size() == 0) { return; } diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszMutableRefCompositeTestBase.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszMutableRefCompositeTestBase.java index 96764906b72..cc5011067d5 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszMutableRefCompositeTestBase.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszMutableRefCompositeTestBase.java @@ -53,7 +53,7 @@ default Stream sszMutableByRefCompositeArguments() { @MethodSource("sszMutableByRefCompositeArguments") @ParameterizedTest default void getByRef_childUpdatedByRefShouldCommit( - SszMutableRefComposite data, int updateChildIndex) { + final SszMutableRefComposite data, final int updateChildIndex) { SszComposite origData = data.commitChanges(); SszMutableData mutableChild = data.getByRef(updateChildIndex); @@ -90,7 +90,7 @@ default void getByRef_childUpdatedByRefShouldCommit( @MethodSource("sszMutableByRefCompositeArguments") @ParameterizedTest default void getByRef_invalidatorShouldBeCalledWhenChildUpdated( - SszMutableRefComposite data, int updateChildIndex) { + final SszMutableRefComposite data, final int updateChildIndex) { AtomicInteger counter = new AtomicInteger(); data.setInvalidator(__ -> counter.incrementAndGet()); SszMutableData mutableChild = data.getByRef(updateChildIndex); @@ -102,7 +102,7 @@ default void getByRef_invalidatorShouldBeCalledWhenChildUpdated( @MethodSource("sszMutableByRefCompositeArguments") @ParameterizedTest default void getByRef_childSetThenUpdatedByRefShouldWork( - SszMutableRefComposite data, int updateChildIndex) { + final SszMutableRefComposite data, final int updateChildIndex) { SszComposite origData = data.commitChanges(); SszSchema childSchema = data.getSchema().getChildSchema(updateChildIndex); @@ -123,7 +123,7 @@ default void getByRef_childSetThenUpdatedByRefShouldWork( @MethodSource("sszMutableByRefCompositeArguments") @ParameterizedTest default void set_mutableValueShouldNotBeShared( - SszMutableRefComposite data, int updateChildIndex) { + final SszMutableRefComposite data, final int updateChildIndex) { SszSchema childSchema = data.getSchema().getChildSchema(updateChildIndex); SszData newChildValue = GENERATOR.randomData(childSchema); @@ -162,7 +162,7 @@ default void set_mutableValueShouldNotBeShared( @MethodSource("sszMutableByRefCompositeArguments") @ParameterizedTest default void getByRef_childUpdateByRefThenSetShouldWork( - SszMutableRefComposite data, int updateChildIndex) { + final SszMutableRefComposite data, final int updateChildIndex) { SszSchema childSchema = data.getSchema().getChildSchema(updateChildIndex); SszMutableData byRef = data.getByRef(updateChildIndex); @@ -179,7 +179,7 @@ default void getByRef_childUpdateByRefThenSetShouldWork( } @SuppressWarnings("unchecked") - static SszData updateSomething(SszMutableData mutableData) { + static SszData updateSomething(final SszMutableData mutableData) { Assumptions.assumeTrue(mutableData instanceof SszMutableComposite); SszMutableComposite mutableComposite = (SszMutableComposite) mutableData; Assumptions.assumeTrue(mutableComposite.size() > 0); diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszPrimitiveTest.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszPrimitiveTest.java index 312818bd2a4..dd9b6adadca 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszPrimitiveTest.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszPrimitiveTest.java @@ -26,6 +26,7 @@ import tech.pegasys.teku.infrastructure.ssz.primitive.SszBytes4; import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt256; import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; +import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchema; import tech.pegasys.teku.infrastructure.unsigned.UInt64; public class SszPrimitiveTest implements SszDataTestBase { @@ -61,15 +62,17 @@ public Stream sszData() { "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"))); } + @SuppressWarnings("unchecked") @MethodSource("sszDataArguments") @ParameterizedTest - > void get_roundtrip(S data) { - V rawVal = data.get(); - S data1 = data.getSchema().boxed(rawVal); + > void get_roundtrip(final S data) { + final V rawVal = data.get(); + final SszPrimitiveSchema schema = (SszPrimitiveSchema) data.getSchema(); + final S data1 = schema.boxed(rawVal); SszDataAssert.assertThatSszData(data1).isEqualByAllMeansTo(data); - V rawVal1 = data1.get(); + final V rawVal1 = data1.get(); Assertions.assertThat(rawVal1).isEqualTo(rawVal); } diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszUnionTest.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszUnionTest.java index 490177060c0..76bec51d28e 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszUnionTest.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszUnionTest.java @@ -49,7 +49,7 @@ public Stream sszData() { @MethodSource("sszDataArguments") @ParameterizedTest - void getSelector_matchesDataSchema(SszUnion data) { + void getSelector_matchesDataSchema(final SszUnion data) { int selector = data.getSelector(); SszSchema expectedValueSchema = data.getSchema().getChildSchema(selector); diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszVectorTest.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszVectorTest.java index 9e2da8bd3c6..80fe29cef65 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszVectorTest.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszVectorTest.java @@ -35,7 +35,7 @@ public Stream> sszData() { @MethodSource("sszDataArguments") @ParameterizedTest - void size_shouldMatchSchemaLength(SszVector data) { + void size_shouldMatchSchemaLength(final SszVector data) { assertThat(data.size()).isEqualTo(data.getSchema().getLength()); } } diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszVectorTestBase.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszVectorTestBase.java index d678906835f..a7c694e642d 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszVectorTestBase.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/SszVectorTestBase.java @@ -21,7 +21,7 @@ public interface SszVectorTestBase extends SszCollectionTestBase { @MethodSource("sszDataArguments") @ParameterizedTest - default void size_shouldBeEqualToSchemaLength(SszVector data) { + default void size_shouldBeEqualToSchemaLength(final SszVector data) { Assertions.assertThat(data.size()).isEqualTo(data.getSchema().getLength()); } } diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/TestContainers.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/TestContainers.java index 0d4087e5340..cedaa2bccda 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/TestContainers.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/TestContainers.java @@ -68,11 +68,11 @@ default UInt64 getLong2() { public interface WritableMutableSubContainer extends WritableSubContainer, SszMutableRefContainer { - default void setLong1(UInt64 val) { + default void setLong1(final UInt64 val) { set(0, SszUInt64.of(val)); } - default void setLong2(UInt64 val) { + default void setLong2(final UInt64 val) { set(1, SszUInt64.of(val)); } } @@ -157,11 +157,12 @@ public static class TestSubContainer extends AbstractSszImmutableContainer { NamedSchema.of("bytes1", SszPrimitiveSchemas.BYTES32_SCHEMA)), TestSubContainer::new); - private TestSubContainer(SszContainerSchema type, TreeNode backingNode) { + private TestSubContainer( + final SszContainerSchema type, final TreeNode backingNode) { super(type, backingNode); } - public TestSubContainer(UInt64 long1, Bytes32 bytes1) { + public TestSubContainer(final UInt64 long1, final Bytes32 bytes1) { super(SSZ_SCHEMA, SszUInt64.of(long1), SszBytes32.of(bytes1)); } @@ -192,7 +193,8 @@ public static class TestLargeContainer extends AbstractSszImmutableContainer { NamedSchema.of("long10", SszPrimitiveSchemas.UINT64_SCHEMA)), TestLargeContainer::new); - private TestLargeContainer(SszContainerSchema type, TreeNode backingNode) { + private TestLargeContainer( + final SszContainerSchema type, final TreeNode backingNode) { super(type, backingNode); } } @@ -207,11 +209,12 @@ public static class TestContainer extends AbstractSszImmutableContainer { NamedSchema.of("long", SszPrimitiveSchemas.UINT64_SCHEMA)), TestContainer::new); - private TestContainer(SszContainerSchema type, TreeNode backingNode) { + private TestContainer( + final SszContainerSchema type, final TreeNode backingNode) { super(type, backingNode); } - public TestContainer(TestSubContainer subContainer, UInt64 long1) { + public TestContainer(final TestSubContainer subContainer, final UInt64 long1) { super(SSZ_SCHEMA, subContainer, SszUInt64.of(long1)); } @@ -232,11 +235,12 @@ public static class TestSmallContainer extends AbstractSszImmutableContainer { List.of(NamedSchema.of("bit", SszPrimitiveSchemas.BIT_SCHEMA)), TestSmallContainer::new); - private TestSmallContainer(SszContainerSchema type, TreeNode backingNode) { + private TestSmallContainer( + final SszContainerSchema type, final TreeNode backingNode) { super(type, backingNode); } - public TestSmallContainer(boolean val) { + public TestSmallContainer(final boolean val) { super(SSZ_SCHEMA, SszBit.of(val)); } } @@ -253,17 +257,17 @@ public static class TestByteVectorContainer extends AbstractSszImmutableContaine NamedSchema.of("long2", SszPrimitiveSchemas.UINT64_SCHEMA)), TestByteVectorContainer::new); - public static TestByteVectorContainer random(Random random) { + public static TestByteVectorContainer random(final Random random) { return new TestByteVectorContainer( random.nextLong(), Bytes.random(64, random), random.nextLong()); } private TestByteVectorContainer( - SszContainerSchema type, TreeNode backingNode) { + final SszContainerSchema type, final TreeNode backingNode) { super(type, backingNode); } - public TestByteVectorContainer(long l1, Bytes b1, long l2) { + public TestByteVectorContainer(final long l1, final Bytes b1, final long l2) { super( SSZ_SCHEMA, SszUInt64.of(UInt64.fromLongBits(l1)), @@ -286,12 +290,16 @@ public static class TestDoubleSuperContainer extends AbstractSszImmutableContain TestDoubleSuperContainer::new); private TestDoubleSuperContainer( - SszContainerSchema type, TreeNode backingNode) { + final SszContainerSchema type, final TreeNode backingNode) { super(type, backingNode); } public TestDoubleSuperContainer( - long l1, TestByteVectorContainer c1, long l2, TestByteVectorContainer c2, long l3) { + final long l1, + final TestByteVectorContainer c1, + final long l2, + final TestByteVectorContainer c2, + final long l3) { super( SSZ_SCHEMA, SszUInt64.of(UInt64.fromLongBits(l1)), @@ -314,15 +322,16 @@ public static class VariableSizeContainer NamedSchema.of("list", SszListSchema.create(SszPrimitiveSchemas.UINT64_SCHEMA, 10)), NamedSchema.of("long", SszPrimitiveSchemas.UINT64_SCHEMA)) { @Override - public VariableSizeContainer createFromBackingNode(TreeNode node) { + public VariableSizeContainer createFromBackingNode(final TreeNode node) { return new VariableSizeContainer(this, node); } }; private VariableSizeContainer( - ContainerSchema3, SszUInt64> + final ContainerSchema3< + VariableSizeContainer, TestSubContainer, SszList, SszUInt64> type, - TreeNode backingNode) { + final TreeNode backingNode) { super(type, backingNode); } } @@ -339,11 +348,11 @@ public static class ImmutableSubContainerImpl extends AbstractSszImmutableContai ImmutableSubContainerImpl::new); private ImmutableSubContainerImpl( - SszContainerSchema type, TreeNode backingNode) { + final SszContainerSchema type, final TreeNode backingNode) { super(type, backingNode); } - public ImmutableSubContainerImpl(UInt64 long1, Bytes32 bytes1) { + public ImmutableSubContainerImpl(final UInt64 long1, final Bytes32 bytes1) { super(SSZ_SCHEMA, SszUInt64.of(long1), SszBytes32.of(bytes1)); } @@ -361,12 +370,12 @@ public Bytes32 getBytes1() { public static class SubContainerReadImpl extends SszContainerImpl implements WritableSubContainer { - public SubContainerReadImpl(TreeNode backingNode, IntCache cache) { + public SubContainerReadImpl(final TreeNode backingNode, final IntCache cache) { super(SSZ_SCHEMA, backingNode, cache); } private SubContainerReadImpl( - SszContainerSchema type, TreeNode backingNode) { + final SszContainerSchema type, final TreeNode backingNode) { super(type, backingNode); } @@ -379,13 +388,13 @@ public WritableMutableSubContainer createWritableCopy() { public static class SubContainerWriteImpl extends SszMutableContainerImpl implements WritableMutableSubContainer { - public SubContainerWriteImpl(SubContainerReadImpl backingImmutableView) { + public SubContainerWriteImpl(final SubContainerReadImpl backingImmutableView) { super(backingImmutableView); } @Override protected SubContainerReadImpl createImmutableSszComposite( - TreeNode backingNode, IntCache viewCache) { + final TreeNode backingNode, final IntCache viewCache) { return new SubContainerReadImpl(backingNode, viewCache); } @@ -397,12 +406,14 @@ public WritableSubContainer commitChanges() { public static class ContainerReadImpl extends SszContainerImpl implements WritableContainer { - public ContainerReadImpl(SszContainerSchema type, TreeNode backingNode) { + public ContainerReadImpl(final SszContainerSchema type, final TreeNode backingNode) { super(type, backingNode); } public ContainerReadImpl( - SszCompositeSchema type, TreeNode backingNode, IntCache cache) { + final SszCompositeSchema type, + final TreeNode backingNode, + final IntCache cache) { super(type, backingNode, cache); } @@ -415,13 +426,13 @@ public WritableMutableContainer createWritableCopy() { public static class ContainerWriteImpl extends SszMutableContainerImpl implements WritableMutableContainer { - public ContainerWriteImpl(ContainerReadImpl backingImmutableView) { + public ContainerWriteImpl(final ContainerReadImpl backingImmutableView) { super(backingImmutableView); } @Override protected ContainerReadImpl createImmutableSszComposite( - TreeNode backingNode, IntCache viewCache) { + final TreeNode backingNode, final IntCache viewCache) { return new ContainerReadImpl(getSchema(), backingNode, viewCache); } @@ -459,12 +470,12 @@ public SszMutableVector getVector1() { } @Override - public void setLong1(UInt64 val) { + public void setLong1(final UInt64 val) { set(0, SszUInt64.of(val)); } @Override - public void setLong2(UInt64 val) { + public void setLong2(final UInt64 val) { set(1, SszUInt64.of(val)); } } diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/TestUtil.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/TestUtil.java index 504eae33104..994eaadd920 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/TestUtil.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/TestUtil.java @@ -24,7 +24,7 @@ public class TestUtil { - public static List waitAll(List> futures) { + public static List waitAll(final List> futures) { return futures.stream() .map( f -> { @@ -37,7 +37,7 @@ public static List waitAll(List> futures) { .collect(Collectors.toList()); } - public static List> executeParallel(Callable task, int threadNum) { + public static List> executeParallel(final Callable task, final int threadNum) { ExecutorService threadPool = Executors.newFixedThreadPool(threadNum); CountDownLatch latch = new CountDownLatch(threadNum); try { diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/SszBitlistTest.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/SszBitlistTest.java index 85bdc4c7c39..bfa64d46f41 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/SszBitlistTest.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/SszBitlistTest.java @@ -17,6 +17,7 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy; import static tech.pegasys.teku.infrastructure.collections.PrimitiveCollectionAssert.assertThatIntCollection; +import java.util.BitSet; import java.util.OptionalInt; import java.util.Random; import java.util.stream.IntStream; @@ -29,6 +30,7 @@ import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; import tech.pegasys.teku.infrastructure.crypto.Hash; +import tech.pegasys.teku.infrastructure.ssz.SszCollection; import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.ssz.SszTestUtils; import tech.pegasys.teku.infrastructure.ssz.impl.AbstractSszPrimitive; @@ -39,46 +41,46 @@ public class SszBitlistTest implements SszPrimitiveListTestBase { - static Random random = new Random(1); - static SszBitlistSchema emptySchema = SszBitlistSchema.create(0); - static SszBitlistSchema schema = SszBitlistSchema.create(500); - static SszBitlistSchema hugeSchema = SszBitlistSchema.create(1L << 62); + static final Random RANDOM = new Random(1); + static final SszBitlistSchema EMPTY_SCHEMA = SszBitlistSchema.create(0); + static final SszBitlistSchema SCHEMA = SszBitlistSchema.create(500); + static final SszBitlistSchema HUGE_SCHEMA = SszBitlistSchema.create(1L << 62); - static SszBitlist random(SszBitlistSchema schema, int size) { + static SszBitlist random(final SszBitlistSchema schema, final int size) { return schema.ofBits( - size, IntStream.range(0, size).filter(__ -> random.nextBoolean()).toArray()); + size, IntStream.range(0, size).filter(__ -> RANDOM.nextBoolean()).toArray()); } @Override public Stream sszData() { return Stream.of( - emptySchema.empty(), - schema.empty(), - hugeSchema.empty(), - random(schema, 1), - random(hugeSchema, 1), - random(schema, 2), - random(hugeSchema, 2), - random(schema, 254), - schema.ofBits(254), - schema.ofBits(254, IntStream.range(0, 254).toArray()), - random(hugeSchema, 254), - random(schema, 255), - schema.ofBits(255), - schema.ofBits(255, IntStream.range(0, 255).toArray()), - random(hugeSchema, 255), - random(schema, 256), - schema.ofBits(256), - schema.ofBits(256, IntStream.range(0, 256).toArray()), - random(hugeSchema, 256), - random(schema, 257), - random(hugeSchema, 257), - random(schema, 499), - random(schema, 500), - random(hugeSchema, 511), - random(hugeSchema, 512), - random(hugeSchema, 513), - random(hugeSchema, 10000)); + EMPTY_SCHEMA.empty(), + SCHEMA.empty(), + HUGE_SCHEMA.empty(), + random(SCHEMA, 1), + random(HUGE_SCHEMA, 1), + random(SCHEMA, 2), + random(HUGE_SCHEMA, 2), + random(SCHEMA, 254), + SCHEMA.ofBits(254), + SCHEMA.ofBits(254, IntStream.range(0, 254).toArray()), + random(HUGE_SCHEMA, 254), + random(SCHEMA, 255), + SCHEMA.ofBits(255), + SCHEMA.ofBits(255, IntStream.range(0, 255).toArray()), + random(HUGE_SCHEMA, 255), + random(SCHEMA, 256), + SCHEMA.ofBits(256), + SCHEMA.ofBits(256, IntStream.range(0, 256).toArray()), + random(HUGE_SCHEMA, 256), + random(SCHEMA, 257), + random(HUGE_SCHEMA, 257), + random(SCHEMA, 499), + random(SCHEMA, 500), + random(HUGE_SCHEMA, 511), + random(HUGE_SCHEMA, 512), + random(HUGE_SCHEMA, 513), + random(HUGE_SCHEMA, 10000)); } public Stream bitlistArgs() { @@ -86,16 +88,24 @@ public Stream bitlistArgs() { } public Stream nonEmptyBitlistArgs() { - return sszData().filter(b -> b.size() > 0).map(Arguments::of); + return sszData().filter(b -> !b.isEmpty()).map(Arguments::of); } public Stream emptyBitlistArgs() { - return sszData().filter(b -> b.size() == 0).map(Arguments::of); + return sszData().filter(SszCollection::isEmpty).map(Arguments::of); + } + + public Stream fromBytesTestCases() { + return sszData().map(bitlist -> Arguments.of(bitlist, bitlist.sszSerialize())); + } + + public Stream fromHexStringTestCases() { + return sszData().map(bitlist -> Arguments.of(bitlist, bitlist.sszSerialize().toHexString())); } @ParameterizedTest @MethodSource("bitlistArgs") - void testSszRoundtrip(SszBitlist bitlist1) { + void testSszRoundtrip(final SszBitlist bitlist1) { Bytes ssz1 = bitlist1.sszSerialize(); SszBitlist bitlist2 = bitlist1.getSchema().sszDeserialize(ssz1); @@ -115,7 +125,49 @@ void testSszRoundtrip(SszBitlist bitlist1) { @ParameterizedTest @MethodSource("bitlistArgs") - void testTreeRoundtrip(SszBitlist bitlist1) { + void testWrapBitSet(final SszBitlist bitlist1) { + final BitSet bits = new BitSet(bitlist1.size()); + + bitlist1.streamAllSetBits().forEach(bits::set); + + final SszBitlist bitlist2 = bitlist1.getSchema().wrapBitSet(bitlist1.size(), bits); + + for (int i = 0; i < bitlist1.size(); i++) { + assertThat(bitlist2.getBit(i)).isEqualTo(bitlist1.getBit(i)); + assertThat(bitlist2.get(i)).isEqualTo(bitlist1.get(i)); + } + + assertThat(bitlist2).isEqualTo(bitlist1); + assertThat(bitlist2.hashCode()).isEqualTo(bitlist1.hashCode()); + assertThat(bitlist2.hashTreeRoot()).isEqualTo(bitlist1.hashTreeRoot()); + assertThat(bitlist2.sszSerialize()).isEqualTo(bitlist1.sszSerialize()); + } + + @Test + void wrapBitSet_shouldDropBitsIfBitSetIsLarger() { + final BitSet bitSet = new BitSet(100); + bitSet.set(99); + assertThat(bitSet.stream().count()).isEqualTo(1); + + final SszBitlist sszBitlist = SCHEMA.wrapBitSet(10, bitSet); + final SszBitlist expectedSszBitlist = SCHEMA.ofBits(10); + + assertThat(sszBitlist).isEqualTo(expectedSszBitlist); + assertThat(sszBitlist.hashCode()).isEqualTo(expectedSszBitlist.hashCode()); + assertThat(sszBitlist.hashTreeRoot()).isEqualTo(expectedSszBitlist.hashTreeRoot()); + assertThat(sszBitlist.sszSerialize()).isEqualTo(expectedSszBitlist.sszSerialize()); + } + + @Test + void wrapBitSet_shouldThrowIfSizeIsLargerThanSchemaMaxLength() { + assertThatThrownBy( + () -> SCHEMA.wrapBitSet(Math.toIntExact(SCHEMA.getMaxLength() + 1), new BitSet())) + .isInstanceOf(IllegalArgumentException.class); + } + + @ParameterizedTest + @MethodSource("bitlistArgs") + void testTreeRoundtrip(final SszBitlist bitlist1) { TreeNode tree = bitlist1.getBackingNode(); SszBitlist bitlist2 = bitlist1.getSchema().createFromBackingNode(tree); @@ -133,14 +185,14 @@ void testTreeRoundtrip(SszBitlist bitlist1) { @ParameterizedTest @MethodSource("bitlistArgs") - void or_testEqualList(SszBitlist bitlist) { + void or_testEqualList(final SszBitlist bitlist) { SszBitlist res = bitlist.or(bitlist); assertThat(res).isEqualTo(bitlist); } @ParameterizedTest @MethodSource("bitlistArgs") - void or_shouldThrowIfBitlistSizeIsLarger(SszBitlist bitlist) { + void or_shouldThrowIfBitlistSizeIsLarger(final SszBitlist bitlist) { SszBitlistSchema largerSchema = SszBitlistSchema.create(bitlist.getSchema().getMaxLength() + 1); SszBitlist largerBitlist = largerSchema.ofBits(bitlist.size() + 1, bitlist.size()); @@ -150,20 +202,20 @@ void or_shouldThrowIfBitlistSizeIsLarger(SszBitlist bitlist) { @ParameterizedTest @MethodSource("bitlistArgs") - void getBitCount_shouldReturnCorrectCount(SszBitlist bitlist) { + void getBitCount_shouldReturnCorrectCount(final SszBitlist bitlist) { long bitCount = bitlist.stream().filter(AbstractSszPrimitive::get).count(); assertThat(bitlist.getBitCount()).isEqualTo(bitCount); } @ParameterizedTest @MethodSource("bitlistArgs") - void intersects_shouldNotIntersectWithEmpty(SszBitlist bitlist) { + void intersects_shouldNotIntersectWithEmpty(final SszBitlist bitlist) { assertThat(bitlist.intersects(bitlist.getSchema().empty())).isFalse(); } @ParameterizedTest @MethodSource("nonEmptyBitlistArgs") - void intersects_shouldIntersectWithSelf(SszBitlist bitlist) { + void intersects_shouldIntersectWithSelf(final SszBitlist bitlist) { if (bitlist.getBitCount() == 0) { return; } @@ -172,19 +224,19 @@ void intersects_shouldIntersectWithSelf(SszBitlist bitlist) { @ParameterizedTest @MethodSource("nonEmptyBitlistArgs") - void intersects_shouldNotIntersectWithZeroes(SszBitlist bitlist) { + void intersects_shouldNotIntersectWithZeroes(final SszBitlist bitlist) { assertThat(bitlist.intersects(bitlist.getSchema().ofBits(bitlist.size()))).isFalse(); } @ParameterizedTest @MethodSource("nonEmptyBitlistArgs") - void intersects_shouldNotIntersectWithNotSelf(SszBitlist bitlist) { + void intersects_shouldNotIntersectWithNotSelf(final SszBitlist bitlist) { assertThat(bitlist.intersects(SszTestUtils.not(bitlist))).isFalse(); } @ParameterizedTest @MethodSource("nonEmptyBitlistArgs") - void intersects_shouldIntersectWithLargerBitlist(SszBitlist bitlist) { + void intersects_shouldIntersectWithLargerBitlist(final SszBitlist bitlist) { if (bitlist.getBitCount() == 0) { return; } @@ -199,7 +251,7 @@ void intersects_shouldIntersectWithLargerBitlist(SszBitlist bitlist) { @ParameterizedTest @MethodSource("nonEmptyBitlistArgs") - void intersects_shouldIntersectWithFirstBit(SszBitlist bitlist) { + void intersects_shouldIntersectWithFirstBit(final SszBitlist bitlist) { OptionalInt maybeFirstBit = bitlist.streamAllSetBits().findFirst(); if (maybeFirstBit.isEmpty()) { return; @@ -210,7 +262,7 @@ void intersects_shouldIntersectWithFirstBit(SszBitlist bitlist) { @ParameterizedTest @MethodSource("nonEmptyBitlistArgs") - void intersects_shouldIntersectWithLastBit(SszBitlist bitlist) { + void intersects_shouldIntersectWithLastBit(final SszBitlist bitlist) { OptionalInt maybeLastBit = bitlist.streamAllSetBits().max(); if (maybeLastBit.isEmpty()) { return; @@ -221,19 +273,19 @@ void intersects_shouldIntersectWithLastBit(SszBitlist bitlist) { @ParameterizedTest @MethodSource("bitlistArgs") - void isSupersetOf_shouldReturnTrueForSelf(SszBitlist bitlist) { + void isSupersetOf_shouldReturnTrueForSelf(final SszBitlist bitlist) { assertThat(bitlist.isSuperSetOf(bitlist)).isTrue(); } @ParameterizedTest @MethodSource("bitlistArgs") - void isSupersetOf_shouldReturnTrueForEmpty(SszBitlist bitlist) { + void isSupersetOf_shouldReturnTrueForEmpty(final SszBitlist bitlist) { assertThat(bitlist.isSuperSetOf(bitlist.getSchema().empty())).isTrue(); } @ParameterizedTest @MethodSource("bitlistArgs") - void isSupersetOf_shouldReturnFalseForLarger(SszBitlist bitlist) { + void isSupersetOf_shouldReturnFalseForLarger(final SszBitlist bitlist) { SszBitlist largerBitlist = SszBitlistSchema.create(bitlist.size() + 1).ofBits(bitlist.size() + 1, bitlist.size()); assertThat(bitlist.isSuperSetOf(largerBitlist)).isFalse(); @@ -241,7 +293,7 @@ void isSupersetOf_shouldReturnFalseForLarger(SszBitlist bitlist) { @ParameterizedTest @MethodSource("nonEmptyBitlistArgs") - void isSupersetOf_shouldReturnFalseForNotSelf(SszBitlist bitlist) { + void isSupersetOf_shouldReturnFalseForNotSelf(final SszBitlist bitlist) { if (bitlist.getBitCount() == bitlist.size()) { return; } @@ -250,7 +302,7 @@ void isSupersetOf_shouldReturnFalseForNotSelf(SszBitlist bitlist) { @ParameterizedTest @MethodSource("bitlistArgs") - void testOr(SszBitlist bitlist) { + void testOr(final SszBitlist bitlist) { IntStream.of(1, 2, bitlist.size() - 1, bitlist.size()) .filter(i -> i >= 0 && i < bitlist.size()) .distinct() @@ -272,19 +324,19 @@ void testOr(SszBitlist bitlist) { @ParameterizedTest @MethodSource("bitlistArgs") - void testOrWithEmptyBitlist(SszBitlist bitlist) { + void testOrWithEmptyBitlist(final SszBitlist bitlist) { SszBitlist empty = bitlist.getSchema().empty(); assertThat(bitlist.or(empty)).isEqualTo(bitlist); } @Test void testEmptyHashTreeRoot() { - assertThat(emptySchema.empty().hashTreeRoot()) + assertThat(EMPTY_SCHEMA.empty().hashTreeRoot()) .isEqualTo(Hash.sha256(Bytes.concatenate(Bytes32.ZERO, Bytes32.ZERO))); - assertThat(schema.empty().hashTreeRoot()) + assertThat(SCHEMA.empty().hashTreeRoot()) .isEqualTo( Hash.sha256(Bytes.concatenate(TreeUtil.ZERO_TREES[1].hashTreeRoot(), Bytes32.ZERO))); - assertThat(hugeSchema.empty().hashTreeRoot()) + assertThat(HUGE_SCHEMA.empty().hashTreeRoot()) .isEqualTo( Hash.sha256( Bytes.concatenate(TreeUtil.ZERO_TREES[62 - 8].hashTreeRoot(), Bytes32.ZERO))); @@ -292,7 +344,7 @@ void testEmptyHashTreeRoot() { @ParameterizedTest @MethodSource("bitlistArgs") - void nullableOr_test(SszBitlist bitlist) { + void nullableOr_test(final SszBitlist bitlist) { assertThatThrownBy(() -> SszBitlist.nullableOr(null, null)) .isInstanceOf(IllegalArgumentException.class); assertThat(SszBitlist.nullableOr(bitlist, null)).isEqualTo(bitlist); @@ -303,7 +355,7 @@ void nullableOr_test(SszBitlist bitlist) { @ParameterizedTest @MethodSource("bitlistArgs") - void createWritableCopy_shouldThrow(SszBitlist bitlist) { + void createWritableCopy_shouldThrow(final SszBitlist bitlist) { assertThatThrownBy(bitlist::createWritableCopy) .isInstanceOf(UnsupportedOperationException.class); } @@ -343,11 +395,72 @@ public void tuweniBytesIssue() { @ParameterizedTest @MethodSource("emptyBitlistArgs") - void testBitEmptyListSsz(SszBitlist bitlist) { + void testBitEmptyListSsz(final SszBitlist bitlist) { assertThat(bitlist.sszSerialize()).isEqualTo(Bytes.of(1)); SszBitlist emptyList1 = bitlist.getSchema().sszDeserialize(Bytes.of(1)); assertThat(emptyList1).isEmpty(); } + + @ParameterizedTest + @MethodSource("fromBytesTestCases") + void testFromBytes(final SszBitlist bitlist, final Bytes serialized) { + SszBitlist deserialized = bitlist.getSchema().fromBytes(serialized); + + assertThat(deserialized).isEqualTo(bitlist); + assertThat(deserialized.size()).isEqualTo(bitlist.size()); + assertThatIntCollection(deserialized.getAllSetBits()).isEqualTo(bitlist.getAllSetBits()); + assertThat(deserialized.hashTreeRoot()).isEqualTo(bitlist.hashTreeRoot()); + } + + @ParameterizedTest + @MethodSource("fromHexStringTestCases") + void testFromHexString(final SszBitlist bitlist, final String hexString) { + SszBitlist deserialized = bitlist.getSchema().fromHexString(hexString); + + assertThat(deserialized).isEqualTo(bitlist); + assertThat(deserialized.size()).isEqualTo(bitlist.size()); + assertThatIntCollection(deserialized.getAllSetBits()).isEqualTo(bitlist.getAllSetBits()); + assertThat(deserialized.hashTreeRoot()).isEqualTo(bitlist.hashTreeRoot()); + } + + private static final SszBitlistSchema FROM_HEX_STRING_TEST_SCHEMA = + SszBitlistSchema.create(100); + + @Test + public void fromHexString_shouldHandleMinimalValidHexString() { + String minimalHex = "0x01"; + SszBitlist validResult = FROM_HEX_STRING_TEST_SCHEMA.fromHexString(minimalHex); + assertThat(validResult).isNotNull(); + assertThat(validResult.sszSerialize()).isEqualTo(Bytes.fromHexString(minimalHex)); + assertThat(validResult.size()).isZero(); + } + + @Test + public void fromHexString_shouldHandleComplexValidHexString() { + String complexHex = "0x01020304"; + SszBitlist complexResult = FROM_HEX_STRING_TEST_SCHEMA.fromHexString(complexHex); + assertThat(complexResult).isNotNull(); + assertThat(complexResult.sszSerialize()).isEqualTo(Bytes.fromHexString(complexHex)); + } + + @Test + public void fromHexString_shouldThrowForEmptyString() { + assertThatThrownBy(() -> FROM_HEX_STRING_TEST_SCHEMA.fromHexString("")) + .isInstanceOf(IllegalArgumentException.class); + } + + @Test + public void fromHexString_shouldThrowForOnlyPrefix() { + assertThatThrownBy(() -> FROM_HEX_STRING_TEST_SCHEMA.fromHexString("0x")) + .isInstanceOf(IllegalArgumentException.class); + } + + @Test + public void fromHexString_shouldThrowForInvalidHexString() { + String invalidHex = "i am a string, not a valid hex string"; + assertThatThrownBy(() -> FROM_HEX_STRING_TEST_SCHEMA.fromHexString(invalidHex)) + .isInstanceOf(IllegalArgumentException.class); + } } diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/SszBitvectorTest.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/SszBitvectorTest.java index 0d3a801d16b..9dd175d723c 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/SszBitvectorTest.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/SszBitvectorTest.java @@ -28,6 +28,7 @@ import org.junit.jupiter.params.provider.MethodSource; import tech.pegasys.teku.infrastructure.ssz.SszDataAssert; import tech.pegasys.teku.infrastructure.ssz.SszVectorTestBase; +import tech.pegasys.teku.infrastructure.ssz.collections.impl.SszBitvectorImpl; import tech.pegasys.teku.infrastructure.ssz.impl.AbstractSszPrimitive; import tech.pegasys.teku.infrastructure.ssz.schema.collections.SszBitvectorSchema; import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; @@ -36,7 +37,7 @@ public class SszBitvectorTest implements SszPrimitiveCollectionTestBase, SszVect private static final Random RANDOM = new Random(1); - private static SszBitvector random(SszBitvectorSchema schema) { + private static SszBitvector random(final SszBitvectorSchema schema) { return schema.ofBits( IntStream.range(0, schema.getLength()).filter(__ -> RANDOM.nextBoolean()).toArray()); } @@ -69,9 +70,9 @@ public Stream bitvectorArgs() { @ParameterizedTest @MethodSource("bitvectorArgs") - void testSszRoundtrip(SszBitvector bitvector1) { - Bytes ssz1 = bitvector1.sszSerialize(); - SszBitvector bitvector2 = bitvector1.getSchema().sszDeserialize(ssz1); + void testSszRoundtrip(final SszBitvector bitvector1) { + final Bytes ssz1 = bitvector1.sszSerialize(); + final SszBitvector bitvector2 = bitvector1.getSchema().sszDeserialize(ssz1); assertThatIntCollection(bitvector2.getAllSetBits()).isEqualTo(bitvector1.getAllSetBits()); Assertions.assertThat(bitvector2.size()).isEqualTo(bitvector1.size()); @@ -84,9 +85,9 @@ void testSszRoundtrip(SszBitvector bitvector1) { @ParameterizedTest @MethodSource("bitvectorArgs") - void testTreeRoundtrip(SszBitvector bitvector1) { - TreeNode tree = bitvector1.getBackingNode(); - SszBitvector bitvector2 = bitvector1.getSchema().createFromBackingNode(tree); + void testTreeRoundtrip(final SszBitvector bitvector1) { + final TreeNode tree = bitvector1.getBackingNode(); + final SszBitvector bitvector2 = bitvector1.getSchema().createFromBackingNode(tree); assertThatIntCollection(bitvector2.getAllSetBits()).isEqualTo(bitvector1.getAllSetBits()); Assertions.assertThat(bitvector2.size()).isEqualTo(bitvector1.size()); @@ -99,34 +100,65 @@ void testTreeRoundtrip(SszBitvector bitvector1) { @ParameterizedTest @MethodSource("bitvectorArgs") - void getBitCount_shouldReturnCorrectCount(SszBitvector bitvector) { - long bitCount = bitvector.stream().filter(AbstractSszPrimitive::get).count(); + void or_testEqualList(final SszBitvector bitvector) { + final SszBitvector res = bitvector.or(bitvector); + assertThat(res).isEqualTo(bitvector); + } + + @ParameterizedTest + @MethodSource("bitvectorArgs") + void or_shouldThrowIfBitvectorSizeIsLarger(final SszBitvector bitvector) { + final SszBitvectorSchema largerSchema = + SszBitvectorSchema.create(bitvector.getSchema().getMaxLength() + 1); + final SszBitvector largerBitvector = + largerSchema.ofBits(bitvector.size() - 1, bitvector.size()); + assertThatThrownBy(() -> bitvector.or(largerBitvector)) + .isInstanceOf(IllegalArgumentException.class); + } + + @ParameterizedTest + @MethodSource("bitvectorArgs") + void or_shouldThrowIfBitvectorSizeIsSmaller(final SszBitvector bitvector) { + if (bitvector.getSchema().getMaxLength() == 1) { + return; + } + final SszBitvectorSchema smallerSchema = + SszBitvectorSchema.create(bitvector.getSchema().getMaxLength() - 1); + final SszBitvector smallerBitvector = smallerSchema.ofBits(); + assertThatThrownBy(() -> bitvector.or(smallerBitvector)) + .isInstanceOf(IllegalArgumentException.class); + } + + @ParameterizedTest + @MethodSource("bitvectorArgs") + void getBitCount_shouldReturnCorrectCount(final SszBitvector bitvector) { + final long bitCount = bitvector.stream().filter(AbstractSszPrimitive::get).count(); assertThat(bitvector.getBitCount()).isEqualTo(bitCount); } @ParameterizedTest @MethodSource("bitvectorArgs") - void createWritableCopy_shouldThrow(SszBitvector bitvector) { + void createWritableCopy_shouldThrow(final SszBitvector bitvector) { assertThatThrownBy(bitvector::createWritableCopy) .isInstanceOf(UnsupportedOperationException.class); } @ParameterizedTest @MethodSource("bitvectorArgs") - void rightShift_shouldYieldAllZeroesWhenShiftingByVectorLength(SszBitvector bitvector) { + void rightShift_shouldYieldAllZeroesWhenShiftingByVectorLength(final SszBitvector bitvector) { assertThat(bitvector.rightShift(bitvector.size()).getBitCount()).isZero(); } @ParameterizedTest @MethodSource("bitvectorArgs") - void rightShift_zeroShiftShouldYieldTheSameVector(SszBitvector bitvector) { + void rightShift_zeroShiftShouldYieldTheSameVector(final SszBitvector bitvector) { SszDataAssert.assertThatSszData(bitvector.rightShift(0)).isEqualByAllMeansTo(bitvector); } @ParameterizedTest @MethodSource("bitvectorArgs") - void rightShift_test(SszBitvector vector) { - SszBitvectorSchema schema = vector.getSchema(); + void rightShift_test(final SszBitvector vector) { + final SszBitvectorSchema schema = vector.getSchema(); IntStream.of( 1, 2, @@ -153,8 +185,8 @@ void rightShift_test(SszBitvector vector) { schema.getLength() + 1) .forEach( i -> { - SszBitvector shiftedVector = vector.rightShift(i); - SszBitvector vectorExpected = + final SszBitvector shiftedVector = vector.rightShift(i); + final SszBitvector vectorExpected = schema.ofBits( vector .streamAllSetBits() @@ -167,10 +199,10 @@ void rightShift_test(SszBitvector vector) { @ParameterizedTest @MethodSource("bitvectorArgs") - void testBitMethodsAreConsistent(SszBitvector vector) { + void testBitMethodsAreConsistent(final SszBitvector vector) { assertThat(vector.streamAllSetBits()) .containsExactlyInAnyOrderElementsOf(vector.getAllSetBits()); - List bitsIndices = vector.getAllSetBits(); + final List bitsIndices = vector.getAllSetBits(); for (int i = 0; i < vector.size(); i++) { assertThat(vector.getBit(i)).isEqualTo(bitsIndices.contains(i)); } @@ -179,7 +211,54 @@ void testBitMethodsAreConsistent(SszBitvector vector) { @ParameterizedTest @MethodSource("bitvectorArgs") - void get_shouldThrowIndexOutOfBounds(SszBitvector vector) { + void testOr(final SszBitvector bitvector) { + final SszBitvector orVector = random(bitvector.getSchema()); + final SszBitvector res = bitvector.or(orVector); + assertThat(res.size()).isEqualTo(bitvector.size()); + assertThat(res.getSchema()).isEqualTo(bitvector.getSchema()); + for (int i = 0; i < bitvector.size(); i++) { + assertThat(res.getBit(i)).isEqualTo(bitvector.getBit(i) || orVector.getBit(i)); + } + } + + @ParameterizedTest + @MethodSource("bitvectorArgs") + void testOrWithEmptyBitvector(final SszBitvector bitvector) { + final SszBitvector empty = bitvector.getSchema().ofBits(); + assertThat(bitvector.or(empty)).isEqualTo(bitvector); + } + + @ParameterizedTest + @MethodSource("bitvectorArgs") + void testGetLastSetBitIndex(final SszBitvector bitvector) { + final int result = bitvector.getLastSetBitIndex(); + final int expected = bitvector.streamAllSetBits().reduce((first, second) -> second).orElse(-1); + assertThat(result).isEqualTo(expected); + } + + @ParameterizedTest + @MethodSource("bitvectorArgs") + void get_shouldThrowIndexOutOfBounds(final SszBitvector vector) { assertThatThrownBy(() -> vector.get(-1)).isInstanceOf(IndexOutOfBoundsException.class); } + + @ParameterizedTest + @MethodSource("bitvectorArgs") + void testFromBytes(final SszBitvector bitvector) { + final Bytes bytes = bitvector.sszSerialize(); + final long size = bitvector.getSchema().getMaxLength(); + final SszBitvector result = + SszBitvectorImpl.fromBytes(bitvector.getSchema(), bytes, (int) size); + SszDataAssert.assertThatSszData(result).isEqualByAllMeansTo(bitvector); + } + + @ParameterizedTest + @MethodSource("bitvectorArgs") + void testFromHexString(final SszBitvector bitvector) { + final String hexString = bitvector.sszSerialize().toHexString(); + final long size = bitvector.getSchema().getMaxLength(); + final SszBitvector result = + SszBitvectorImpl.fromHexString(bitvector.getSchema(), hexString, (int) size); + SszDataAssert.assertThatSszData(result).isEqualByAllMeansTo(bitvector); + } } diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/SszByteVectorTestBase.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/SszByteVectorTestBase.java index 2372cd44c1d..6e10d15dbe8 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/SszByteVectorTestBase.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/SszByteVectorTestBase.java @@ -23,7 +23,7 @@ public interface SszByteVectorTestBase extends SszPrimitiveCollectionTestBase { @MethodSource("sszDataArguments") @ParameterizedTest - default void getBytes_shouldReturnAllBytes(SszByteVector vector) { + default void getBytes_shouldReturnAllBytes(final SszByteVector vector) { Bytes bytes = vector.getBytes(); assertThat(bytes.size()).isEqualTo(vector.size()); diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/SszMutablePrimitiveCollectionTestBase.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/SszMutablePrimitiveCollectionTestBase.java index 52ef0ff805f..8b73f1a7b0f 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/SszMutablePrimitiveCollectionTestBase.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/SszMutablePrimitiveCollectionTestBase.java @@ -26,8 +26,8 @@ public interface SszMutablePrimitiveCollectionTestBase @MethodSource("sszMutableCompositeArguments") @ParameterizedTest - default > void setElement_throwsIndexOutOfBounds( - SszMutablePrimitiveCollection collection) { + default > void setElement_throwsIndexOutOfBounds( + final SszMutablePrimitiveCollection collection) { assertThatThrownBy( () -> collection.setElement( @@ -38,8 +38,8 @@ default > void setElement_throwsIndexO @MethodSource("sszMutableCompositeArguments") @ParameterizedTest - default > void setElement_extendsExtendableCollection( - SszMutablePrimitiveCollection collection) { + default > void setElement_extendsExtendableCollection( + final SszMutablePrimitiveCollection collection) { if (collection.size() < collection.getSchema().getMaxLength()) { // collection is extendable (List effectively) int origSize = collection.size(); diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/SszMutablePrimitiveListTestBase.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/SszMutablePrimitiveListTestBase.java index 4c9c111045d..cc23f63340f 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/SszMutablePrimitiveListTestBase.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/SszMutablePrimitiveListTestBase.java @@ -32,8 +32,8 @@ public interface SszMutablePrimitiveListTestBase @MethodSource("sszMutableCompositeArguments") @ParameterizedTest - default > void append_extendsExtendableCollection( - SszMutablePrimitiveList collection) { + default > void append_extendsExtendableCollection( + final SszMutablePrimitiveList collection) { if (collection.size() < collection.getSchema().getMaxLength()) { // collection is extendable (List effectively) int origSize = collection.size(); @@ -52,9 +52,8 @@ default > void append_extendsExtendabl @MethodSource("sszMutableCompositeArguments") @ParameterizedTest - default > - void appendAllElements_extendsExtendableCollection( - SszMutablePrimitiveList collection) { + default > void appendAllElements_extendsExtendableCollection( + final SszMutablePrimitiveList collection) { if (collection.size() < collection.getSchema().getMaxLength()) { // collection is extendable (List effectively) int origSize = collection.size(); diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/SszPrimitiveCollectionTestBase.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/SszPrimitiveCollectionTestBase.java index 9336d6234c6..8475ef0ae10 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/SszPrimitiveCollectionTestBase.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/SszPrimitiveCollectionTestBase.java @@ -26,8 +26,8 @@ public interface SszPrimitiveCollectionTestBase extends SszCollectionTestBase { @MethodSource("sszDataArguments") @ParameterizedTest - default > void getElement_shouldReturnUnboxedElement( - SszPrimitiveCollection collection) { + default > void getElement_shouldReturnUnboxedElement( + final SszPrimitiveCollection collection) { for (int i = 0; i < collection.size(); i++) { assertThat(collection.getElement(i)).isEqualTo(collection.get(i).get()); } @@ -35,7 +35,7 @@ default > void getElement_shouldReturn @MethodSource("sszDataArguments") @ParameterizedTest - default void getElement_shouldThrowIndexOfBounds(SszPrimitiveCollection collection) { + default void getElement_shouldThrowIndexOfBounds(final SszPrimitiveCollection collection) { assertThatThrownBy(() -> collection.getElement(-1)) .isInstanceOf(IndexOutOfBoundsException.class); assertThatThrownBy(() -> collection.getElement(collection.size())) @@ -49,8 +49,8 @@ default void getElement_shouldThrowIndexOfBounds(SszPrimitiveCollection co @MethodSource("sszDataArguments") @ParameterizedTest - default > void asListUnboxed_shouldReturnAllElements( - SszPrimitiveCollection collection) { + default > void asListUnboxed_shouldReturnAllElements( + final SszPrimitiveCollection collection) { List listUnboxed = collection.asListUnboxed(); assertThat(listUnboxed.size()).isEqualTo(collection.size()); for (int i = 0; i < collection.size(); i++) { @@ -60,8 +60,8 @@ default > void asListUnboxed_shouldRet @MethodSource("sszDataArguments") @ParameterizedTest - default > void asListUnboxed_isUnmodifiable( - SszPrimitiveCollection collection) { + default > void asListUnboxed_isUnmodifiable( + final SszPrimitiveCollection collection) { List list = collection.asListUnboxed(); ElT newElement = collection.getSchema().getElementSchema().getDefault().get(); assertThatThrownBy(() -> list.set(0, newElement)) @@ -70,8 +70,8 @@ default > void asListUnboxed_isUnmodif @MethodSource("sszDataArguments") @ParameterizedTest - default > void streamUnboxed_shouldReturnAllElements( - SszPrimitiveCollection collection) { + default > void streamUnboxed_shouldReturnAllElements( + final SszPrimitiveCollection collection) { assertThat(collection.streamUnboxed()).containsExactlyElementsOf(collection.asListUnboxed()); } } diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/BitlistImplTest.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/BitlistImplTest.java index 15b58ea8375..b24ea3cca5f 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/BitlistImplTest.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/collections/impl/BitlistImplTest.java @@ -161,7 +161,7 @@ void deserializationShouldRejectDataWhenEndMarkerBitNotSet() { .hasMessageContaining("marker bit"); } - private static BitlistImpl create(int... bits) { + private static BitlistImpl create(final int... bits) { return new BitlistImpl(18, BITLIST_MAX_SIZE, bits); } @@ -195,7 +195,7 @@ static Stream sszBitlistCases() { @ParameterizedTest @MethodSource("sszBitlistCases") - void testSszMethods(Bytes bitlistSsz) { + void testSszMethods(final Bytes bitlistSsz) { int length = SszBitlistImpl.sszGetLengthAndValidate(bitlistSsz); Bytes truncBytes = SszBitlistImpl.sszTruncateLeadingBit(bitlistSsz, length); Bytes bitlistSsz1 = sszAppendLeadingBit(truncBytes, length); @@ -215,14 +215,14 @@ static Stream sszInvalidBitlistCases() { @ParameterizedTest @MethodSource("sszInvalidBitlistCases") - void testSszMethodsInvalid(Bytes bitlistSsz) { + void testSszMethodsInvalid(final Bytes bitlistSsz) { assertThatThrownBy(() -> SszBitlistImpl.sszGetLengthAndValidate(bitlistSsz)) .isInstanceOf(IllegalArgumentException.class); assertThatThrownBy(() -> BitlistImpl.fromSszBytes(bitlistSsz, 1024)) .isInstanceOf(IllegalArgumentException.class); } - public static Bytes sszAppendLeadingBit(Bytes bytes, int length) { + public static Bytes sszAppendLeadingBit(final Bytes bytes, final int length) { checkArgument(length <= bytes.size() * 8 && length > (bytes.size() - 1) * 8); if (length % 8 == 0) { return Bytes.wrap(bytes, Bytes.of(1)); diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/SszCompositeSchemaTestBase.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/SszCompositeSchemaTestBase.java index 5d36a05254b..c71dbffc3a9 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/SszCompositeSchemaTestBase.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/SszCompositeSchemaTestBase.java @@ -24,13 +24,13 @@ public abstract class SszCompositeSchemaTestBase extends SszSchemaTestBase { @MethodSource("testSchemaArguments") @ParameterizedTest - void isPrimitive_shouldReturnFalse(SszCompositeSchema schema) { + void isPrimitive_shouldReturnFalse(final SszCompositeSchema schema) { assertThat(schema.isPrimitive()).isFalse(); } @MethodSource("testSchemaArguments") @ParameterizedTest - void getChildSchema_shouldThrowIndexOutOfBounds(SszCompositeSchema schema) { + void getChildSchema_shouldThrowIndexOutOfBounds(final SszCompositeSchema schema) { Assumptions.assumeThat(schema.getMaxLength()).isLessThan(Integer.MAX_VALUE); assertThatThrownBy(() -> schema.getChildSchema((int) schema.getMaxLength())) .isInstanceOf(IndexOutOfBoundsException.class); diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/SszOptionalSchemaTest.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/SszOptionalSchemaTest.java index 7f9ee241a32..c1299d56a54 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/SszOptionalSchemaTest.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/SszOptionalSchemaTest.java @@ -21,6 +21,7 @@ import java.util.stream.Stream; import org.apache.tuweni.bytes.Bytes; import org.apache.tuweni.units.bigints.UInt256; +import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; @@ -54,6 +55,18 @@ public static Stream> testContainerOptionalSchemas() { return Stream.of(ContainerWithOptionals.SSZ_SCHEMA); } + @Test + void verifySszLengthBounds() { + assertThat(SszOptionalSchema.create(SszPrimitiveSchemas.BIT_SCHEMA).getSszLengthBounds()) + .matches(bound -> bound.getMinBytes() == 0) + .matches(bound -> bound.getMaxBytes() == 2) + .matches(bound -> bound.getMaxBits() == 9); + + assertThat(SszOptionalSchema.create(SszPrimitiveSchemas.BYTES32_SCHEMA).getSszLengthBounds()) + .matches(bound -> bound.getMinBytes() == 0) + .matches(bound -> bound.getMaxBytes() == 33); + } + @Override public Stream> testSchemas() { return Streams.concat(testOptionalSchemas(), testContainerOptionalSchemas()); diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/SszPrimitiveSchemaTest.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/SszPrimitiveSchemaTest.java index 4fe2d0f0c94..e8fd71f1616 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/SszPrimitiveSchemaTest.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/SszPrimitiveSchemaTest.java @@ -47,19 +47,19 @@ public class SszPrimitiveSchemaTest extends SszSchemaTestBase { @MethodSource("testSchemaArguments") @ParameterizedTest - void isPrimitive_shouldReturnTrue(SszPrimitiveSchema schema) { + void isPrimitive_shouldReturnTrue(final SszPrimitiveSchema schema) { assertThat(schema.isPrimitive()).isTrue(); } @MethodSource("testSchemaArguments") @ParameterizedTest - void getDefaultTree_shouldReturnLeaf(SszPrimitiveSchema schema) { + void getDefaultTree_shouldReturnLeaf(final SszPrimitiveSchema schema) { assertThat(schema.getDefaultTree()).isInstanceOf(LeafNode.class); } @MethodSource("testSchemaArguments") @ParameterizedTest - > void boxed_roundtrip(SszPrimitiveSchema schema) { + > void boxed_roundtrip(final SszPrimitiveSchema schema) { SszV d = randomSsz.randomData(schema); V v = d.get(); SszV d1 = schema.boxed(v); diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/SszSchemaTestBase.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/SszSchemaTestBase.java index 87acd6208c5..b67f5d19117 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/SszSchemaTestBase.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/SszSchemaTestBase.java @@ -25,6 +25,7 @@ import tech.pegasys.teku.infrastructure.ssz.RandomSszDataGenerator; import tech.pegasys.teku.infrastructure.ssz.SszData; import tech.pegasys.teku.infrastructure.ssz.SszDataAssert; +import tech.pegasys.teku.infrastructure.ssz.SszOptional; import tech.pegasys.teku.infrastructure.ssz.schema.SszSchemaHints.SszSuperNodeHint; import tech.pegasys.teku.infrastructure.ssz.schema.impl.AbstractSszCollectionSchema; import tech.pegasys.teku.infrastructure.ssz.sos.SimpleSszReader; @@ -37,32 +38,33 @@ public abstract class SszSchemaTestBase extends SszTypeTestBase { @MethodSource("testSchemaArguments") @ParameterizedTest - void getDefaultTree_shouldBeEqualToDefaultStructure(SszSchema schema) { + void getDefaultTree_shouldBeEqualToDefaultStructure(final SszSchema schema) { SszData defaultTreeData = schema.createFromBackingNode(schema.getDefaultTree()); SszDataAssert.assertThatSszData(defaultTreeData).isEqualByAllMeansTo(schema.getDefault()); } @MethodSource("testSchemaArguments") @ParameterizedTest - void sszDeserialize_tooLongSszShouldFailFastWithoutReadingWholeInput(SszSchema schema) { - if (schema instanceof SszOptionalSchema) { - // empty SszOptional couldn't pass this test - return; - } + void sszDeserialize_tooLongSszShouldFailFastWithoutReadingWholeInput( + final SszSchema schema) { long maxSszLength = schema.getSszLengthBounds().getMaxBytes(); // ignore too large and degenerative structs assumeThat(maxSszLength).isLessThan(32 * 1024 * 1024).isGreaterThan(0); // ignore lists using SszSuperNode as many validations are skipped - if (schema instanceof AbstractSszCollectionSchema) { - assumeThat( - ((AbstractSszCollectionSchema) schema) - .getHints() - .getHint(SszSuperNodeHint.class)) + if (schema instanceof AbstractSszCollectionSchema collectionSchema) { + assumeThat(collectionSchema.getHints().getHint(SszSuperNodeHint.class)) .describedAs("uses SszSuperNode") .isEmpty(); } SszData data = randomSsz.randomData(schema); + + if (data instanceof SszOptional optionalData) { + assumeThat(optionalData.getValue()) + .describedAs("optional can't be empty to pass the test") + .isPresent(); + } + Bytes ssz = data.sszSerialize(); Bytes sszWithExtraData = Bytes.wrap(ssz, Bytes.random((int) (maxSszLength - ssz.size() + 1))); @@ -70,7 +72,7 @@ void sszDeserialize_tooLongSszShouldFailFastWithoutReadingWholeInput(SszSchema schema) { + void loadBackingNodes_shouldRestoreTree_singleBranchStep(final SszSchema schema) { // Up to 32768 child nodes can be included in a single step which is enough for all sane values // Bigger than this requires too much memory to load and we'd use multiple steps in reality final int maxBranchLevelsSkipped = 15; @@ -91,14 +93,14 @@ void loadBackingNodes_shouldRestoreTree_singleBranchStep(SszSchema schema) { @MethodSource("testSchemaArguments") @ParameterizedTest - void loadBackingNodes_shouldRestoreTree_multipleBranchSteps(SszSchema schema) { + void loadBackingNodes_shouldRestoreTree_multipleBranchSteps(final SszSchema schema) { final int maxBranchLevelsSkipped = 1; assertTreeRoundtrip(schema, maxBranchLevelsSkipped); } @MethodSource("testSchemaArguments") @ParameterizedTest - void loadBackingNodes_shouldRestoreTree_normalBranchSkipLevel(SszSchema schema) { + void loadBackingNodes_shouldRestoreTree_normalBranchSkipLevel(final SszSchema schema) { final int maxBranchLevelsSkipped = 5; assertTreeRoundtrip(schema, maxBranchLevelsSkipped); } @@ -129,7 +131,7 @@ protected void assertTreeRoundtrip( @MethodSource("testSchemaArguments") @ParameterizedTest - void loadBackingNodes_shouldRestoreDefaultTree(SszSchema schema) { + void loadBackingNodes_shouldRestoreDefaultTree(final SszSchema schema) { final InMemoryStoringTreeNodeStore nodeStore = new InMemoryStoringTreeNodeStore(); final TreeNode node = schema.getDefault().getBackingNode(); final long rootGIndex = 67; diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/SszTypeTestBase.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/SszTypeTestBase.java index 69fa7bd4c8a..b1fb19d1cc0 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/SszTypeTestBase.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/SszTypeTestBase.java @@ -34,7 +34,7 @@ Stream testSchemaArguments() { @MethodSource("testSchemaArguments") @ParameterizedTest - void getFixedPartSize_shouldBeNonZeroForFixed(SszType type) { + void getFixedPartSize_shouldBeNonZeroForFixed(final SszType type) { Assumptions.assumeTrue(type.isFixedSize()); assertThat(type.getSszFixedPartSize()).isNotZero(); } diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszBitvectorSchemaTest.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszBitvectorSchemaTest.java index 84abe264ec8..dd37d1743ed 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszBitvectorSchemaTest.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszBitvectorSchemaTest.java @@ -85,7 +85,7 @@ void ofBits_test() { assertThat(schema.ofBits(0, 2)).isEqualTo(schema.ofBits(2, 0)); } - private static Bytes rightPad(Bytes bb, int targetLen) { + private static Bytes rightPad(final Bytes bb, final int targetLen) { return Bytes.wrap(bb, Bytes.wrap(new byte[targetLen - bb.size()])); } diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszByteVectorSchemaTest.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszByteVectorSchemaTest.java new file mode 100644 index 00000000000..834ed50de4c --- /dev/null +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszByteVectorSchemaTest.java @@ -0,0 +1,71 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.infrastructure.ssz.schema.collections; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +import java.util.List; +import java.util.Random; +import java.util.stream.Stream; +import org.apache.tuweni.bytes.Bytes; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +import tech.pegasys.teku.infrastructure.ssz.collections.SszByteVector; +import tech.pegasys.teku.infrastructure.ssz.custom.SszCustomBytes48Schema; +import tech.pegasys.teku.infrastructure.ssz.schema.SszSchema; + +public class SszByteVectorSchemaTest extends SszVectorSchemaTestBase { + + private final Random random = new Random(1); + + @Override + public Stream> testSchemas() { + return Stream.of( + SszByteVectorSchema.create(1), + SszByteVectorSchema.create(31), + SszByteVectorSchema.create(32), + SszByteVectorSchema.create(33), + SszByteVectorSchema.create(63), + SszByteVectorSchema.create(64), + SszByteVectorSchema.create(65), + SszCustomBytes48Schema.INSTANCE); + } + + @MethodSource("testSchemaArguments") + @ParameterizedTest + void fromBytes_shouldCreateCorrectClassInstance( + final SszByteVectorSchema schema) { + List byteList = + Stream.generate(() -> Bytes.of(random.nextInt(256))).limit(schema.getLength()).toList(); + Bytes bytes = Bytes.wrap(byteList); + T vector = schema.fromBytes(bytes); + assertThat(vector.getBytes()).isEqualTo(bytes); + assertThat(vector.getClass()).isEqualTo(schema.getDefault().getClass()); + } + + @MethodSource("testSchemaArguments") + @ParameterizedTest + void fromBytes_shouldThrowWhenWrongSize( + final SszByteVectorSchema schema) { + List byteList = + Stream.generate(() -> Bytes.of(random.nextInt(256))).limit(schema.getLength()).toList(); + Bytes correctBytes = Bytes.wrap(byteList); + + assertThatThrownBy(() -> schema.fromBytes(Bytes.wrap(correctBytes, Bytes.of(111)))) + .isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> schema.fromBytes(correctBytes.slice(0, correctBytes.size() - 1))) + .isInstanceOf(IllegalArgumentException.class); + } +} diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszCollectionSchemaTestBase.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszCollectionSchemaTestBase.java index 03c5b83c9b9..173075b1e1e 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszCollectionSchemaTestBase.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszCollectionSchemaTestBase.java @@ -13,8 +13,17 @@ package tech.pegasys.teku.infrastructure.ssz.schema.collections; +import static org.assertj.core.api.Assertions.assertThat; + +import java.util.List; import java.util.function.Function; import java.util.stream.Stream; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +import tech.pegasys.teku.infrastructure.ssz.RandomSszDataGenerator; +import tech.pegasys.teku.infrastructure.ssz.SszCollection; +import tech.pegasys.teku.infrastructure.ssz.SszData; +import tech.pegasys.teku.infrastructure.ssz.schema.SszCollectionSchema; import tech.pegasys.teku.infrastructure.ssz.schema.SszCompositeSchemaTestBase; import tech.pegasys.teku.infrastructure.ssz.schema.SszContainerSchemaTest; import tech.pegasys.teku.infrastructure.ssz.schema.SszSchema; @@ -22,6 +31,8 @@ public abstract class SszCollectionSchemaTestBase extends SszCompositeSchemaTestBase { + final RandomSszDataGenerator sszDataGenerator = new RandomSszDataGenerator(); + static Stream> complexElementSchemas() { return Stream.of( SszContainerSchemaTest.testContainerSchemas(), @@ -40,4 +51,14 @@ static Stream> complexElementSchemas() { SszUInt64ListSchema.create(3))) .flatMap(Function.identity()); } + + @MethodSource("testSchemaArguments") + @ParameterizedTest + void createFromElements_shouldCreateCorrectListOfTheSameClass( + final SszCollectionSchema> schema) { + List elements = sszDataGenerator.randomData(schema).asList(); + SszCollection collection = schema.createFromElements(elements); + assertThat(collection).containsExactlyElementsOf(elements); + assertThat(collection.getClass()).isEqualTo(schema.getDefault().getClass()); + } } diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszListSchemaTest.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszListSchemaTest.java index ec6a14c5524..0b6c813c7ed 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszListSchemaTest.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszListSchemaTest.java @@ -18,6 +18,7 @@ import org.junit.jupiter.api.Test; import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; +import tech.pegasys.teku.infrastructure.ssz.custom.SszCustomListSchema; import tech.pegasys.teku.infrastructure.ssz.schema.SszListSchema; import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; import tech.pegasys.teku.infrastructure.ssz.schema.SszSchema; @@ -26,7 +27,8 @@ public class SszListSchemaTest extends SszListSchemaTestBase { @Override public Stream> testSchemas() { - return SszListSchemaTestBase.complexListSchemas(); + return Stream.concat( + SszListSchemaTestBase.complexListSchemas(), Stream.of(new SszCustomListSchema())); } @Test diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszListSchemaTestBase.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszListSchemaTestBase.java index e0f4f66d2b7..223ea4d24f4 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszListSchemaTestBase.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszListSchemaTestBase.java @@ -47,5 +47,5 @@ public abstract class SszListSchemaTestBase extends SszCollectionSchemaTestBase @MethodSource("testSchemaArguments") @ParameterizedTest - void getChildSchema_shouldThrowIndexOutOfBounds(SszListSchema schema) {} + void getChildSchema_shouldThrowIndexOutOfBounds(final SszListSchema schema) {} } diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszVectorSchemaTestBase.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszVectorSchemaTestBase.java index 6f5d290a7cd..8c702f2cfe3 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszVectorSchemaTestBase.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/schema/collections/SszVectorSchemaTestBase.java @@ -14,10 +14,9 @@ package tech.pegasys.teku.infrastructure.ssz.schema.collections; import java.util.stream.Stream; -import tech.pegasys.teku.infrastructure.ssz.schema.SszCompositeSchemaTestBase; import tech.pegasys.teku.infrastructure.ssz.schema.SszVectorSchema; -public abstract class SszVectorSchemaTestBase extends SszCompositeSchemaTestBase { +public abstract class SszVectorSchemaTestBase extends SszCollectionSchemaTestBase { public static Stream> complexVectorSchemas() { return SszCollectionSchemaTestBase.complexElementSchemas() diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/tree/GIndexUtilTest.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/tree/GIndexUtilTest.java index 03a3ec8b712..bdc1487afa1 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/tree/GIndexUtilTest.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/tree/GIndexUtilTest.java @@ -59,7 +59,7 @@ static Stream compareCases() { @ParameterizedTest @MethodSource("compareCases") - void testCompare(long idx1, long idx2, NodeRelation expected) { + void testCompare(final long idx1, final long idx2, final NodeRelation expected) { if (expected != null) { assertThat(GIndexUtil.gIdxCompare(idx1, idx2)).isEqualTo(expected); assertThat(GIndexUtil.gIdxCompare(idx2, idx1)).isEqualTo(expected.inverse()); @@ -243,7 +243,7 @@ void testRelativeGIndex() { @ParameterizedTest @ValueSource( ints = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 50, 51, 52, 53, 54, 55, 100, 101, 102, 103, 104}) - void shouldReverseChildIndex(long rootGIndex) { + void shouldReverseChildIndex(final long rootGIndex) { final int treeDepth = 4; final int childIndex = 9; final long childGIndex = GIndexUtil.gIdxChildGIndex(rootGIndex, childIndex, treeDepth); diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/tree/TreeTest.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/tree/TreeTest.java index ed44546f92b..e4e4f277d29 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/tree/TreeTest.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/tree/TreeTest.java @@ -33,7 +33,7 @@ public class TreeTest { - public static LeafNode newTestLeaf(long l) { + public static LeafNode newTestLeaf(final long l) { return LeafNode.create(Bytes32.leftPad(Bytes.ofUnsignedLong(l, ByteOrder.BIG_ENDIAN))); } @@ -243,7 +243,7 @@ void testTreeNodeIteratorWithEqualStartEndNodes() { assertThatLongCollection(iteratedIndices).containsExactly(0b1L, 0b11L, 0b110L, 0b111L); } - static List collectLeaves(TreeNode n, long from, long to) { + static List collectLeaves(final TreeNode n, final long from, final long to) { List ret = new ArrayList<>(); TreeUtil.iterateLeaves(n, from, to, ret::add); return ret; diff --git a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/tree/TreeUpdatesTest.java b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/tree/TreeUpdatesTest.java index 3b141d8e905..f0b342dda1a 100644 --- a/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/tree/TreeUpdatesTest.java +++ b/infrastructure/ssz/src/test/java/tech/pegasys/teku/infrastructure/ssz/tree/TreeUpdatesTest.java @@ -26,7 +26,7 @@ public class TreeUpdatesTest { - public static TreeNode newTestLeaf(long l) { + public static TreeNode newTestLeaf(final long l) { return LeafNode.create(Bytes32.leftPad(Bytes.ofUnsignedLong(l, ByteOrder.BIG_ENDIAN))); } diff --git a/infrastructure/ssz/src/testFixtures/java/tech/pegasys/teku/infrastructure/ssz/RandomSszDataGenerator.java b/infrastructure/ssz/src/testFixtures/java/tech/pegasys/teku/infrastructure/ssz/RandomSszDataGenerator.java index 6535f873ef8..02d87211ba3 100644 --- a/infrastructure/ssz/src/testFixtures/java/tech/pegasys/teku/infrastructure/ssz/RandomSszDataGenerator.java +++ b/infrastructure/ssz/src/testFixtures/java/tech/pegasys/teku/infrastructure/ssz/RandomSszDataGenerator.java @@ -55,7 +55,7 @@ public RandomSszDataGenerator() { this(new Random(1), 16 * 1024); } - public RandomSszDataGenerator(Random random, final int maxListSize) { + public RandomSszDataGenerator(final Random random, final int maxListSize) { this.random = random; this.maxListSize = maxListSize; bitSupplier = () -> SszBit.of(random.nextBoolean()); @@ -66,16 +66,16 @@ public RandomSszDataGenerator(Random random, final int maxListSize) { bytes32Supplier = () -> SszBytes32.of(Bytes32.random(random)); } - public RandomSszDataGenerator withMaxListSize(int maxListSize) { + public RandomSszDataGenerator withMaxListSize(final int maxListSize) { return new RandomSszDataGenerator(random, maxListSize); } - public T randomData(SszSchema schema) { + public T randomData(final SszSchema schema) { return randomDataStream(schema).findFirst().orElseThrow(); } @SuppressWarnings("unchecked") - public Stream randomDataStream(SszSchema schema) { + public Stream randomDataStream(final SszSchema schema) { if (schema instanceof AbstractSszPrimitiveSchema) { if (schema.equals(SszPrimitiveSchemas.NONE_SCHEMA)) { return (Stream) Stream.generate(() -> SszNone.INSTANCE); diff --git a/infrastructure/ssz/src/testFixtures/java/tech/pegasys/teku/infrastructure/ssz/SszDataAssert.java b/infrastructure/ssz/src/testFixtures/java/tech/pegasys/teku/infrastructure/ssz/SszDataAssert.java index d0c7ad96e9f..6f950ef5c02 100644 --- a/infrastructure/ssz/src/testFixtures/java/tech/pegasys/teku/infrastructure/ssz/SszDataAssert.java +++ b/infrastructure/ssz/src/testFixtures/java/tech/pegasys/teku/infrastructure/ssz/SszDataAssert.java @@ -25,16 +25,16 @@ public class SszDataAssert extends AbstractAssert, T> { - public static SszDataAssert assertThatSszData(T sszData) { + public static SszDataAssert assertThatSszData(final T sszData) { return new SszDataAssert<>(sszData, SszDataAssert.class); } - private SszDataAssert(T t, Class selfType) { + private SszDataAssert(final T t, final Class selfType) { super(t, selfType); } /** Compares two views by their getters recursively (if views are composite) */ - public SszDataAssert isEqualByGettersTo(T expected) { + public SszDataAssert isEqualByGettersTo(final T expected) { List res = compareByGetters(actual, expected); if (!res.isEmpty()) { String errMessage = @@ -49,17 +49,17 @@ public SszDataAssert isEqualByGettersTo(T expected) { return this; } - public SszDataAssert isEqualBySszTo(T expected) { + public SszDataAssert isEqualBySszTo(final T expected) { assertThat(actual.sszSerialize()).isEqualTo(expected.sszSerialize()); return this; } - public SszDataAssert isEqualByHashTreeRootTo(T expected) { + public SszDataAssert isEqualByHashTreeRootTo(final T expected) { assertThat(actual.hashTreeRoot()).isEqualTo(expected.hashTreeRoot()); return this; } - public SszDataAssert isEqualByHashCodeTo(T expected) { + public SszDataAssert isEqualByHashCodeTo(final T expected) { assertThat(actual.hashCode()).isEqualTo(expected.hashCode()); return this; } @@ -74,7 +74,7 @@ public SszDataAssert isEqualByHashCodeTo(T expected) { *
  • {@link #isEqualByHashTreeRootTo(SszData)} * */ - public SszDataAssert isNotEqualByAllMeansTo(T expected) { + public SszDataAssert isNotEqualByAllMeansTo(final T expected) { assertNot(() -> isEqualTo(expected), "isEqualTo"); assertNot(() -> isEqualByGettersTo(expected), "isEqualByGettersTo"); assertNot(() -> isEqualBySszTo(expected), "isEqualBySszTo"); @@ -93,7 +93,7 @@ public SszDataAssert isNotEqualByAllMeansTo(T expected) { *
  • {@link #isEqualByHashTreeRootTo(SszData)} * */ - public SszDataAssert isEqualByAllMeansTo(T expected) { + public SszDataAssert isEqualByAllMeansTo(final T expected) { isEqualTo(expected); isEqualByHashCodeTo(expected); isEqualByGettersTo(expected); @@ -103,7 +103,7 @@ public SszDataAssert isEqualByAllMeansTo(T expected) { } @SuppressWarnings("EmptyCatch") - private void assertNot(Runnable assertion, String error) { + private void assertNot(final Runnable assertion, final String error) { try { assertion.run(); failWithMessage("Expecting negative assertion: " + error); @@ -111,11 +111,11 @@ private void assertNot(Runnable assertion, String error) { } } - public static boolean isEqualByGetters(SszData actual, SszData expected) { + public static boolean isEqualByGetters(final SszData actual, final SszData expected) { return compareByGetters(actual, expected).isEmpty(); } - private static List compareByGetters(SszData actual, SszData expected) { + private static List compareByGetters(final SszData actual, final SszData expected) { if (!actual.getSchema().equals(expected.getSchema())) { return List.of( "Schemas don't match. Expected: " @@ -154,7 +154,7 @@ private static List compareByGetters(SszData actual, SszData expected) { } @SuppressWarnings("unchecked") - private static List prepend(List list, T... args) { + private static List prepend(final List list, final T... args) { return Stream.concat(Stream.of(args), list.stream()).collect(Collectors.toList()); } } diff --git a/infrastructure/ssz/src/testFixtures/java/tech/pegasys/teku/infrastructure/ssz/SszTestUtils.java b/infrastructure/ssz/src/testFixtures/java/tech/pegasys/teku/infrastructure/ssz/SszTestUtils.java index 2eca4710a16..88595a5b376 100644 --- a/infrastructure/ssz/src/testFixtures/java/tech/pegasys/teku/infrastructure/ssz/SszTestUtils.java +++ b/infrastructure/ssz/src/testFixtures/java/tech/pegasys/teku/infrastructure/ssz/SszTestUtils.java @@ -17,7 +17,6 @@ import it.unimi.dsi.fastutil.ints.IntList; import java.util.List; import java.util.function.Consumer; -import java.util.stream.Collectors; import java.util.stream.IntStream; import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; import tech.pegasys.teku.infrastructure.ssz.schema.SszContainerSchema; @@ -28,7 +27,7 @@ public class SszTestUtils { - public static IntList getVectorLengths(SszContainerSchema sszContainerSchema) { + public static IntList getVectorLengths(final SszContainerSchema sszContainerSchema) { IntList vectorLengths = new IntArrayList(); sszContainerSchema.getFieldSchemas().stream() .filter(t -> t instanceof SszVectorSchema) @@ -37,14 +36,14 @@ public static IntList getVectorLengths(SszContainerSchema sszContainerSchema) return vectorLengths; } - public static SszBitlist not(SszBitlist bitlist) { - List notList = bitlist.stream().map(b -> !b.get()).collect(Collectors.toList()); + public static SszBitlist not(final SszBitlist bitlist) { + List notList = bitlist.stream().map(b -> !b.get()).toList(); int[] notBitIndices = IntStream.range(0, notList.size()).filter(notList::get).toArray(); return bitlist.getSchema().ofBits(bitlist.size(), notBitIndices); } /** Dumps the tree to stdout */ - public static String dumpBinaryTree(TreeNode node) { + public static String dumpBinaryTree(final TreeNode node) { StringBuilder ret = new StringBuilder(); dumpBinaryTreeRec(node, "", false, s -> ret.append(s).append('\n')); return ret.toString(); diff --git a/data/serializer/src/main/java/tech/pegasys/teku/provider/BLSPubKeyDeserializer.java b/infrastructure/ssz/src/testFixtures/java/tech/pegasys/teku/infrastructure/ssz/custom/SszCustomBytes48.java similarity index 50% rename from data/serializer/src/main/java/tech/pegasys/teku/provider/BLSPubKeyDeserializer.java rename to infrastructure/ssz/src/testFixtures/java/tech/pegasys/teku/infrastructure/ssz/custom/SszCustomBytes48.java index 06f3216d697..09eb2eb71c0 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/provider/BLSPubKeyDeserializer.java +++ b/infrastructure/ssz/src/testFixtures/java/tech/pegasys/teku/infrastructure/ssz/custom/SszCustomBytes48.java @@ -11,18 +11,24 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.provider; +package tech.pegasys.teku.infrastructure.ssz.custom; -import com.fasterxml.jackson.core.JsonParser; -import com.fasterxml.jackson.databind.DeserializationContext; -import com.fasterxml.jackson.databind.JsonDeserializer; -import java.io.IOException; -import org.apache.tuweni.bytes.Bytes; -import tech.pegasys.teku.api.schema.BLSPubKey; +import org.apache.tuweni.bytes.Bytes48; +import tech.pegasys.teku.infrastructure.ssz.collections.impl.SszByteVectorImpl; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; + +public class SszCustomBytes48 extends SszByteVectorImpl { + + public SszCustomBytes48(final Bytes48 bytes) { + super(SszCustomBytes48Schema.INSTANCE, bytes); + } + + SszCustomBytes48(final TreeNode backingNode) { + super(SszCustomBytes48Schema.INSTANCE, backingNode); + } -public class BLSPubKeyDeserializer extends JsonDeserializer { @Override - public BLSPubKey deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { - return new BLSPubKey(Bytes.fromHexString(p.getValueAsString())); + public SszCustomBytes48Schema getSchema() { + return (SszCustomBytes48Schema) super.getSchema(); } } diff --git a/infrastructure/ssz/src/testFixtures/java/tech/pegasys/teku/infrastructure/ssz/custom/SszCustomBytes48Schema.java b/infrastructure/ssz/src/testFixtures/java/tech/pegasys/teku/infrastructure/ssz/custom/SszCustomBytes48Schema.java new file mode 100644 index 00000000000..dfc9c5a1e29 --- /dev/null +++ b/infrastructure/ssz/src/testFixtures/java/tech/pegasys/teku/infrastructure/ssz/custom/SszCustomBytes48Schema.java @@ -0,0 +1,36 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.infrastructure.ssz.custom; + +import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; +import tech.pegasys.teku.infrastructure.ssz.schema.collections.impl.SszByteVectorSchemaImpl; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; + +public class SszCustomBytes48Schema extends SszByteVectorSchemaImpl { + public static final SszCustomBytes48Schema INSTANCE = new SszCustomBytes48Schema(); + + private SszCustomBytes48Schema() { + super(SszPrimitiveSchemas.BYTE_SCHEMA, 48); + } + + @Override + public SszCustomBytes48 createFromBackingNode(final TreeNode node) { + return new SszCustomBytes48(node); + } + + @Override + public String toString() { + return "CustomBytes48"; + } +} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/validator/GetAttestationDataResponse.java b/infrastructure/ssz/src/testFixtures/java/tech/pegasys/teku/infrastructure/ssz/custom/SszCustomList.java similarity index 57% rename from data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/validator/GetAttestationDataResponse.java rename to infrastructure/ssz/src/testFixtures/java/tech/pegasys/teku/infrastructure/ssz/custom/SszCustomList.java index e06f646819f..bb33d1df2fd 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/validator/GetAttestationDataResponse.java +++ b/infrastructure/ssz/src/testFixtures/java/tech/pegasys/teku/infrastructure/ssz/custom/SszCustomList.java @@ -11,19 +11,16 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.api.response.v1.validator; +package tech.pegasys.teku.infrastructure.ssz.custom; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import tech.pegasys.teku.api.schema.AttestationData; +import tech.pegasys.teku.infrastructure.ssz.SszList; +import tech.pegasys.teku.infrastructure.ssz.impl.SszListImpl; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; -public class GetAttestationDataResponse { +public class SszCustomList extends SszListImpl + implements SszList { - @JsonProperty("data") - public final AttestationData data; - - @JsonCreator - public GetAttestationDataResponse(@JsonProperty("data") final AttestationData data) { - this.data = data; + SszCustomList(final SszCustomListSchema schema, final TreeNode node) { + super(schema, node); } } diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/validator/GetNewBlockV2Test.java b/infrastructure/ssz/src/testFixtures/java/tech/pegasys/teku/infrastructure/ssz/custom/SszCustomListSchema.java similarity index 52% rename from data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/validator/GetNewBlockV2Test.java rename to infrastructure/ssz/src/testFixtures/java/tech/pegasys/teku/infrastructure/ssz/custom/SszCustomListSchema.java index 0f8dd62efa5..0c1170a5981 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v2/validator/GetNewBlockV2Test.java +++ b/infrastructure/ssz/src/testFixtures/java/tech/pegasys/teku/infrastructure/ssz/custom/SszCustomListSchema.java @@ -1,5 +1,5 @@ /* - * Copyright Consensys Software Inc., 2022 + * Copyright Consensys Software Inc., 2023 * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at @@ -11,19 +11,19 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.beaconrestapi.handlers.v2.validator; +package tech.pegasys.teku.infrastructure.ssz.custom; -import tech.pegasys.teku.beaconrestapi.AbstractGetNewBlockTest; -import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; +import tech.pegasys.teku.infrastructure.ssz.schema.impl.AbstractSszListSchema; +import tech.pegasys.teku.infrastructure.ssz.tree.TreeNode; -public class GetNewBlockV2Test extends AbstractGetNewBlockTest { - @Override - public RestApiEndpoint getHandler() { - return new GetNewBlock(validatorDataProvider, spec, schemaDefinitionCache); +public class SszCustomListSchema extends AbstractSszListSchema { + + public SszCustomListSchema() { + super(SszCustomBytes48Schema.INSTANCE, 1024); } @Override - public boolean isBlindedBlocks() { - return false; + public SszCustomList createFromBackingNode(final TreeNode node) { + return new SszCustomList(this, node); } } diff --git a/infrastructure/subscribers/src/main/java/tech/pegasys/teku/infrastructure/subscribers/ObservableValue.java b/infrastructure/subscribers/src/main/java/tech/pegasys/teku/infrastructure/subscribers/ObservableValue.java index 92096cbddcc..7ef9de85043 100644 --- a/infrastructure/subscribers/src/main/java/tech/pegasys/teku/infrastructure/subscribers/ObservableValue.java +++ b/infrastructure/subscribers/src/main/java/tech/pegasys/teku/infrastructure/subscribers/ObservableValue.java @@ -47,7 +47,7 @@ private static final class Subscription { private final ValueObserver subscriber; private final long subscriptionId; - public Subscription(ValueObserver subscriber, long subscriptionId) { + public Subscription(final ValueObserver subscriber, final long subscriptionId) { this.subscriber = subscriber; this.subscriptionId = subscriptionId; } @@ -72,7 +72,7 @@ public long getSubscriptionId() { * @param suppressCallbackExceptions if true then any exceptions thrown from a subscriber update * callback are just printed to the log */ - public ObservableValue(boolean suppressCallbackExceptions) { + public ObservableValue(final boolean suppressCallbackExceptions) { this.suppressCallbackExceptions = suppressCallbackExceptions; } @@ -83,7 +83,7 @@ public ObservableValue(boolean suppressCallbackExceptions) { * * @return subscription ID to be used for {@link #unsubscribe(long)} */ - public synchronized long subscribe(ValueObserver subscriber) { + public synchronized long subscribe(final ValueObserver subscriber) { Subscription subscription = new Subscription<>(subscriber, idCounter++); subscriptions.add(subscription); if (curValue != null) { @@ -97,7 +97,7 @@ public synchronized long subscribe(ValueObserver subscriber) { * * @param subscriptionId ID return by the {@link #subscribe(ValueObserver)} method */ - public synchronized void unsubscribe(long subscriptionId) { + public synchronized void unsubscribe(final long subscriptionId) { subscriptions.removeIf(s -> s.getSubscriptionId() == subscriptionId); } @@ -106,7 +106,7 @@ public synchronized void unsubscribe(long subscriptionId) { * * @param c the non-null value */ - public void set(C c) { + public void set(final C c) { Iterator> iterator; synchronized (this) { curValue = c; @@ -116,7 +116,7 @@ public void set(C c) { iterator.forEachRemaining(l -> notify(l, c)); } - private void notify(Subscription subscription, C value) { + private void notify(final Subscription subscription, final C value) { try { subscription.getSubscriber().onValueChanged(value); } catch (Throwable throwable) { diff --git a/infrastructure/subscribers/src/test/java/tech/pegasys/teku/infrastructure/subscribers/ObservableValueTest.java b/infrastructure/subscribers/src/test/java/tech/pegasys/teku/infrastructure/subscribers/ObservableValueTest.java index 54d3a55ca57..0e325c88abc 100644 --- a/infrastructure/subscribers/src/test/java/tech/pegasys/teku/infrastructure/subscribers/ObservableValueTest.java +++ b/infrastructure/subscribers/src/test/java/tech/pegasys/teku/infrastructure/subscribers/ObservableValueTest.java @@ -18,7 +18,6 @@ import java.util.List; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; -import java.util.stream.Collectors; import java.util.stream.Stream; import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; @@ -32,7 +31,7 @@ class Listener implements ValueObserver { int val; @Override - public void onValueChanged(Integer newValue) { + public void onValueChanged(final Integer newValue) { if (newValue <= val) { Assertions.fail("newValue <= val: " + newValue + " <= " + val); } @@ -61,7 +60,7 @@ public void onValueChanged(Integer newValue) { .map(Thread::new) .peek(Thread::start) .limit(threadCnt) - .collect(Collectors.toList()); + .toList(); startLatch.await(5, TimeUnit.SECONDS); observableValue.set(777); diff --git a/infrastructure/time/src/main/java/tech/pegasys/teku/infrastructure/time/PerformanceTracker.java b/infrastructure/time/src/main/java/tech/pegasys/teku/infrastructure/time/PerformanceTracker.java index e6d9dee576c..da671e493cc 100644 --- a/infrastructure/time/src/main/java/tech/pegasys/teku/infrastructure/time/PerformanceTracker.java +++ b/infrastructure/time/src/main/java/tech/pegasys/teku/infrastructure/time/PerformanceTracker.java @@ -14,6 +14,7 @@ package tech.pegasys.teku.infrastructure.time; import java.util.ArrayList; +import java.util.Collections; import java.util.List; import java.util.function.Consumer; import org.apache.commons.lang3.tuple.Pair; @@ -22,7 +23,8 @@ public class PerformanceTracker { private final TimeProvider timeProvider; - protected final List> events = new ArrayList<>(); + protected final List> events = + Collections.synchronizedList(new ArrayList<>()); public PerformanceTracker(final TimeProvider timeProvider) { this.timeProvider = timeProvider; @@ -63,7 +65,7 @@ public void report( } final UInt64 totalProcessingDuration = - events.get(events.size() - 1).getRight().minusMinZero(events.get(0).getRight()); + events.getLast().getRight().minusMinZero(events.getFirst().getRight()); totalDurationReporter.accept(totalProcessingDuration); if (isLateEvent) { diff --git a/infrastructure/time/src/main/java/tech/pegasys/teku/infrastructure/time/SystemTimeProvider.java b/infrastructure/time/src/main/java/tech/pegasys/teku/infrastructure/time/SystemTimeProvider.java index 81bd57b201d..1dfa477390e 100644 --- a/infrastructure/time/src/main/java/tech/pegasys/teku/infrastructure/time/SystemTimeProvider.java +++ b/infrastructure/time/src/main/java/tech/pegasys/teku/infrastructure/time/SystemTimeProvider.java @@ -17,6 +17,7 @@ import tech.pegasys.teku.infrastructure.unsigned.UInt64; public class SystemTimeProvider implements TimeProvider { + public static final SystemTimeProvider SYSTEM_TIME_PROVIDER = new SystemTimeProvider(); private final Clock clock; diff --git a/infrastructure/time/src/main/java/tech/pegasys/teku/infrastructure/time/Throttler.java b/infrastructure/time/src/main/java/tech/pegasys/teku/infrastructure/time/Throttler.java index a059bc6c702..949d2591bb7 100644 --- a/infrastructure/time/src/main/java/tech/pegasys/teku/infrastructure/time/Throttler.java +++ b/infrastructure/time/src/main/java/tech/pegasys/teku/infrastructure/time/Throttler.java @@ -13,6 +13,8 @@ package tech.pegasys.teku.infrastructure.time; +import static com.google.common.base.Preconditions.checkNotNull; + import java.util.concurrent.atomic.AtomicReference; import java.util.function.Consumer; import tech.pegasys.teku.infrastructure.unsigned.UInt64; @@ -24,11 +26,13 @@ public class Throttler { private final AtomicReference lastInvoked = new AtomicReference<>(null); public Throttler(final TResource resource, final UInt64 throttlingPeriod) { + checkNotNull(throttlingPeriod, "Missing throttling period"); this.resource = resource; this.throttlingPeriod = throttlingPeriod; } - public void invoke(final UInt64 currentTime, Consumer invocation) { + public void invoke(final UInt64 currentTime, final Consumer invocation) { + checkNotNull(currentTime, "Missing current time"); if (updateLastInvoked(currentTime)) { invocation.accept(resource); } diff --git a/infrastructure/time/src/test/java/tech/pegasys/teku/infrastructure/time/ThrottlerTest.java b/infrastructure/time/src/test/java/tech/pegasys/teku/infrastructure/time/ThrottlerTest.java index d6028311e98..cec34889f42 100644 --- a/infrastructure/time/src/test/java/tech/pegasys/teku/infrastructure/time/ThrottlerTest.java +++ b/infrastructure/time/src/test/java/tech/pegasys/teku/infrastructure/time/ThrottlerTest.java @@ -14,6 +14,7 @@ package tech.pegasys.teku.infrastructure.time; import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; import java.util.concurrent.atomic.AtomicInteger; import org.junit.jupiter.api.Test; @@ -24,6 +25,21 @@ public class ThrottlerTest { private final UInt64 throttingPeriod = UInt64.valueOf(10); private final Throttler throttler = new Throttler<>(resource, throttingPeriod); + @Test + public void init_mustThrowWhenThrottlingPeriodIsNull() { + assertThatThrownBy(() -> new Throttler<>(resource, null)) + .isInstanceOf(NullPointerException.class) + .hasMessageContaining("Missing throttling period"); + } + + @Test + public void invoke_mustThrowWhenCurrentTimeIsNull() { + assertThatThrownBy(() -> throttler.invoke(null, AtomicInteger::incrementAndGet)) + .isInstanceOf(NullPointerException.class) + .hasMessageContaining("Missing current time"); + assertThat(resource.get()).isEqualTo(0); + } + @Test public void invoke_initialInvocationShouldRun_atTimeZero() { throttler.invoke(UInt64.ZERO, AtomicInteger::incrementAndGet); diff --git a/infrastructure/unsigned/src/test/java/tech/pegasys/teku/infrastructure/unsigned/UInt64Test.java b/infrastructure/unsigned/src/test/java/tech/pegasys/teku/infrastructure/unsigned/UInt64Test.java index c3b11aba9ae..11044b58f73 100644 --- a/infrastructure/unsigned/src/test/java/tech/pegasys/teku/infrastructure/unsigned/UInt64Test.java +++ b/infrastructure/unsigned/src/test/java/tech/pegasys/teku/infrastructure/unsigned/UInt64Test.java @@ -625,7 +625,7 @@ void minLong_shouldThrowWhenValueIsNegative() { @ParameterizedTest @MethodSource("rangeNumbers") - void range_shouldCreateStreamIncludingStartAndExcludingEnd(int from, int to) { + void range_shouldCreateStreamIncludingStartAndExcludingEnd(final int from, final int to) { assertThat(UInt64.range(UInt64.valueOf(from), UInt64.valueOf(to))) .containsExactlyElementsOf( IntStream.range(from, to).mapToObj(UInt64::valueOf).collect(toList())); diff --git a/infrastructure/version/src/main/java/tech/pegasys/teku/infrastructure/version/VersionProvider.java b/infrastructure/version/src/main/java/tech/pegasys/teku/infrastructure/version/VersionProvider.java index a5b65cf862d..ca06276cc4e 100644 --- a/infrastructure/version/src/main/java/tech/pegasys/teku/infrastructure/version/VersionProvider.java +++ b/infrastructure/version/src/main/java/tech/pegasys/teku/infrastructure/version/VersionProvider.java @@ -74,7 +74,7 @@ static Optional getCommitHash(final InputStream gitPropertiesStream) { } static String defaultStoragePathForNormalizedOS( - final String detectedOS, Map env) { + final String detectedOS, final Map env) { if (detectedOS.equals("windows")) { return env.get(ENV_LOCALAPPDATA) + "\\teku"; } else if (detectedOS.equals("osx")) { diff --git a/infrastructure/version/src/test/java/tech/pegasys/teku/infrastructure/version/VersionProviderTest.java b/infrastructure/version/src/test/java/tech/pegasys/teku/infrastructure/version/VersionProviderTest.java index 8148f337a47..37e70e7dcbe 100644 --- a/infrastructure/version/src/test/java/tech/pegasys/teku/infrastructure/version/VersionProviderTest.java +++ b/infrastructure/version/src/test/java/tech/pegasys/teku/infrastructure/version/VersionProviderTest.java @@ -45,7 +45,7 @@ void getCommitHashIsEmpty_whenGitPropertiesFileDoesNotExist() { } @Test - void getCommitHashIsEmpty_whenGitCommitIdPropertyDoesNotExist(@TempDir Path tempDir) + void getCommitHashIsEmpty_whenGitCommitIdPropertyDoesNotExist(@TempDir final Path tempDir) throws IOException { final Path gitPropertiesFile = tempDir.resolve("git.properties"); diff --git a/infrastructure/yaml/build.gradle b/infrastructure/yaml/build.gradle index 90a59dbdeb6..e184a680e03 100644 --- a/infrastructure/yaml/build.gradle +++ b/infrastructure/yaml/build.gradle @@ -1,6 +1,6 @@ dependencies { implementation project(':infrastructure:jackson') - implementation 'org.apache.tuweni:tuweni-bytes' + implementation 'io.tmio:tuweni-bytes' implementation 'com.fasterxml.jackson.core:jackson-databind' implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-yaml' } diff --git a/infrastructure/yaml/src/main/java/tech/pegasys/teku/data/yaml/YamlProvider.java b/infrastructure/yaml/src/main/java/tech/pegasys/teku/data/yaml/YamlProvider.java index 1a0d7807df0..b3f2fe47ff7 100644 --- a/infrastructure/yaml/src/main/java/tech/pegasys/teku/data/yaml/YamlProvider.java +++ b/infrastructure/yaml/src/main/java/tech/pegasys/teku/data/yaml/YamlProvider.java @@ -58,19 +58,19 @@ private void addTekuMappers() { objectMapper.registerModule(module).writer(new DefaultPrettyPrinter()); } - public T read(InputStream data, Class clazz) throws IOException { + public T read(final InputStream data, final Class clazz) throws IOException { return objectMapper.readValue(data, clazz); } - public T read(Bytes data, Class clazz) throws IOException { + public T read(final Bytes data, final Class clazz) throws IOException { return objectMapper.readValue(data.toArrayUnsafe(), clazz); } - public void write(final OutputStream out, T object) throws IOException { + public void write(final OutputStream out, final T object) throws IOException { objectMapper.writerWithDefaultPrettyPrinter().writeValue(out, object); } - public Bytes write(T object) { + public Bytes write(final T object) { try (final ByteArrayOutputStream out = new ByteArrayOutputStream()) { objectMapper.writerWithDefaultPrettyPrinter().writeValue(out, object); return Bytes.wrap(out.toByteArray()); @@ -81,7 +81,7 @@ public Bytes write(T object) { } } - public String writeString(T object) { + public String writeString(final T object) { try (final StringWriter out = new StringWriter()) { objectMapper.writerWithDefaultPrettyPrinter().writeValue(out, object); return out.toString(); @@ -99,14 +99,16 @@ public ObjectMapper getObjectMapper() { public static class UInt64Deserializer extends JsonDeserializer { @Override - public UInt64 deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { + public UInt64 deserialize(final JsonParser p, final DeserializationContext ctxt) + throws IOException { return UInt64.valueOf(p.getValueAsString()); } } public static class UInt64Serializer extends JsonSerializer { @Override - public void serialize(UInt64 value, JsonGenerator gen, SerializerProvider serializers) + public void serialize( + final UInt64 value, final JsonGenerator gen, final SerializerProvider serializers) throws IOException { gen.writeNumber(value.bigIntegerValue()); } diff --git a/interop-keys/import_keys.sh b/interop-keys/import_keys.sh index c759d859ffa..88f5fb40bba 100755 --- a/interop-keys/import_keys.sh +++ b/interop-keys/import_keys.sh @@ -20,9 +20,11 @@ done TEMP=`mktemp -d` function cleanup() { + echo "Cleaning up temp folder ${TEMP}." rm -rf "${TEMP}" } trap cleanup EXIT +echo "TEMP: ${TEMP}" DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )" @@ -67,12 +69,20 @@ done echo "] }" >> "${TEMP}/payload.json" +# annoying but AUTHORIZATION_HEADER below seems to be a problem if its empty, so coding with and without echo "Sending payload.json to ${SIGNER_URL}/eth/v1/keystores..." - -curl --fail -q -X POST ${SIGNER_URL}/eth/v1/keystores \ - "${AUTHORIZATION_HEADER:-}" \ - -H "Content-Type: application/json" \ - -d "@${TEMP}/payload.json" \ - -o "${TEMP}/result.json" +if [ ! -z "${AUTHORIZATION_HEADER:-}" ] +then + curl --fail -q -X POST ${SIGNER_URL}/eth/v1/keystores \ + "${AUTHORIZATION_HEADER:-}" \ + -H "Content-Type: application/json" \ + -d "@${TEMP}/payload.json" \ + -o "${TEMP}/result.json" +else + curl --fail -q -X POST ${SIGNER_URL}/eth/v1/keystores \ + -H "Content-Type: application/json" \ + -d "@${TEMP}/payload.json" \ + -o "${TEMP}/result.json" +fi echo "Wrote result to ${TEMP}/result.json." diff --git a/networking/eth2/build.gradle b/networking/eth2/build.gradle index a001b17005d..9f1ccd3082d 100644 --- a/networking/eth2/build.gradle +++ b/networking/eth2/build.gradle @@ -19,7 +19,7 @@ dependencies { implementation 'io.libp2p:jvm-libp2p' implementation 'io.netty:netty-codec-http' - implementation 'org.apache.tuweni:tuweni-ssz' + implementation 'io.tmio:tuweni-ssz' implementation 'org.xerial.snappy:snappy-java' testImplementation testFixtures(project(':infrastructure:metrics')) diff --git a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/AbstractRpcMethodIntegrationTest.java b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/AbstractRpcMethodIntegrationTest.java index c2ee0cec9bf..3f3fa221ae2 100644 --- a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/AbstractRpcMethodIntegrationTest.java +++ b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/AbstractRpcMethodIntegrationTest.java @@ -35,7 +35,7 @@ import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.bellatrix.BeaconBlockBodyBellatrix; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.capella.BeaconBlockBodyCapella; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.deneb.BeaconBlockBodyDeneb; -import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.eip7594.BeaconBlockBodyEip7594; +import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.electra.BeaconBlockBodyElectra; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.versions.phase0.BeaconBlockBodyPhase0; import tech.pegasys.teku.storage.storageSystem.InMemoryStorageSystemBuilder; import tech.pegasys.teku.storage.storageSystem.StorageSystem; @@ -81,10 +81,11 @@ private void setUpNextSpec(final SpecMilestone nextSpecMilestone) { nextSpec = Optional.of(TestSpecFactory.createMinimalWithDenebForkEpoch(nextSpecEpoch)); } case DENEB -> { - checkState(nextSpecMilestone.equals(SpecMilestone.EIP7594), "next spec should be eip7594"); - nextSpec = Optional.of(TestSpecFactory.createMinimalWithEip7594ForkEpoch(nextSpecEpoch)); + checkState(nextSpecMilestone.equals(SpecMilestone.ELECTRA), "next spec should be electra"); + nextSpec = Optional.of(TestSpecFactory.createMinimalWithElectraForkEpoch(nextSpecEpoch)); } - case EIP7594 -> throw new RuntimeException("Base spec is already latest supported milestone"); + case ELECTRA, FULU -> + throw new RuntimeException("Base spec is already latest supported milestone"); } nextSpecSlot = nextSpec.orElseThrow().computeStartSlotAtEpoch(nextSpecEpoch); } @@ -261,7 +262,7 @@ protected static Class milestoneToBeaconBlockBodyClass(final SpecMilestone mi case BELLATRIX -> BeaconBlockBodyBellatrix.class; case CAPELLA -> BeaconBlockBodyCapella.class; case DENEB -> BeaconBlockBodyDeneb.class; - case EIP7594 -> BeaconBlockBodyEip7594.class; + case ELECTRA, FULU -> BeaconBlockBodyElectra.class; }; } } diff --git a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/AttesterSlashingGossipIntegrationTest.java b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/AttesterSlashingGossipIntegrationTest.java index b4c1d5bf835..5e5ac9e59a7 100644 --- a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/AttesterSlashingGossipIntegrationTest.java +++ b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/AttesterSlashingGossipIntegrationTest.java @@ -24,6 +24,8 @@ import org.junit.jupiter.api.Test; import tech.pegasys.teku.bls.BLSKeyGenerator; import tech.pegasys.teku.bls.BLSKeyPair; +import tech.pegasys.teku.infrastructure.async.AsyncRunner; +import tech.pegasys.teku.infrastructure.async.DelayedExecutorAsyncRunner; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.async.Waiter; import tech.pegasys.teku.networking.eth2.Eth2P2PNetworkFactory.Eth2P2PNetworkBuilder; @@ -35,7 +37,7 @@ import tech.pegasys.teku.statetransition.validation.InternalValidationResult; public class AttesterSlashingGossipIntegrationTest { - + private final AsyncRunner asyncRunner = DelayedExecutorAsyncRunner.create(); private final List validatorKeys = BLSKeyGenerator.generateKeyPairs(3); private final Eth2P2PNetworkFactory networkFactory = new Eth2P2PNetworkFactory(); private final DataStructureUtil dataStructureUtil = @@ -91,6 +93,6 @@ public void shouldGossipToPeers() throws Exception { private NodeManager createNodeManager(final Consumer networkBuilder) throws Exception { - return NodeManager.create(networkFactory, validatorKeys, networkBuilder); + return NodeManager.create(asyncRunner, networkFactory, validatorKeys, networkBuilder); } } diff --git a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/BeaconBlocksByRangeIntegrationTest.java b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/BeaconBlocksByRangeIntegrationTest.java index 24fd0b00463..c22c4b674df 100644 --- a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/BeaconBlocksByRangeIntegrationTest.java +++ b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/BeaconBlocksByRangeIntegrationTest.java @@ -61,6 +61,20 @@ public void shouldSendEmptyResponseWhenNoBlocksAreAvailable() throws Exception { assertThat(response).isEmpty(); } + @Test + public void shouldSendEmptyResponseWhenCountIsZero() throws Exception { + final Eth2Peer peer = createPeer(); + + final SignedBlockAndState block = peerStorage.chainUpdater().advanceChain(); + peerStorage.chainUpdater().updateBestBlock(block); + + final List blocks = new ArrayList<>(); + waitFor( + peer.requestBlocksByRange(UInt64.ONE, UInt64.ZERO, RpcResponseListener.from(blocks::add))); + assertThat(peer.getOutstandingRequests()).isEqualTo(0); + assertThat(blocks).isEmpty(); + } + @Test public void shouldRespondWithBlocksFromCanonicalChain() throws Exception { final Eth2Peer peer = createPeer(); @@ -74,7 +88,7 @@ public void shouldRespondWithBlocksFromCanonicalChain() throws Exception { } @Test - public void requestBlocksByRangeAfterPeerDisconnectedImmediately() throws Exception { + public void requestBlocksByRangeAfterPeerDisconnectedImmediately() { final Eth2Peer peer = createPeer(); // Setup chain @@ -116,7 +130,7 @@ public void requestBlocksByRangeAfterPeerDisconnected() throws Exception { } @Test - public void requestBlockBySlotAfterPeerDisconnectedImmediately() throws Exception { + public void requestBlockBySlotAfterPeerDisconnectedImmediately() { final Eth2Peer peer = createPeer(); // Setup chain diff --git a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/BlobSidecarsByRangeIntegrationTest.java b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/BlobSidecarsByRangeIntegrationTest.java index d46292f5f62..c727ad45b78 100644 --- a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/BlobSidecarsByRangeIntegrationTest.java +++ b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/BlobSidecarsByRangeIntegrationTest.java @@ -15,62 +15,80 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.assertj.core.api.Assumptions.assumeThat; import static tech.pegasys.teku.infrastructure.async.Waiter.waitFor; +import static tech.pegasys.teku.spec.SpecMilestone.CAPELLA; +import static tech.pegasys.teku.spec.SpecMilestone.DENEB; +import static tech.pegasys.teku.spec.SpecMilestone.ELECTRA; import java.util.ArrayList; import java.util.List; import java.util.Optional; import java.util.concurrent.ExecutionException; import java.util.concurrent.TimeoutException; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.networking.eth2.peers.Eth2Peer; import tech.pegasys.teku.networking.p2p.rpc.RpcResponseListener; -import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockAndState; import tech.pegasys.teku.spec.datastructures.state.Checkpoint; import tech.pegasys.teku.spec.generator.ChainBuilder; +@TestSpecContext(milestone = {CAPELLA, DENEB, ELECTRA}) public class BlobSidecarsByRangeIntegrationTest extends AbstractRpcMethodIntegrationTest { - @Test + private Eth2Peer peer; + private SpecMilestone specMilestone; + + @BeforeEach + public void setUp(final TestSpecInvocationContextProvider.SpecContext specContext) { + peer = createPeer(specContext.getSpec()); + specMilestone = specContext.getSpecMilestone(); + } + + @TestTemplate public void requestBlobSidecars_shouldFailBeforeDenebMilestone() { - final Eth2Peer peer = createPeer(TestSpecFactory.createMinimalCapella()); + assumeThat(specMilestone).isLessThan(SpecMilestone.DENEB); assertThatThrownBy(() -> requestBlobSidecarsByRange(peer, UInt64.ONE, UInt64.valueOf(10))) .hasRootCauseInstanceOf(UnsupportedOperationException.class) .hasMessageContaining("BlobSidecarsByRange method is not supported"); } - @Test - public void requestBlobSidecars_shouldReturnEmptyBlobSidecarsOnDenebMilestone() + @TestTemplate + public void requestBlobSidecars_shouldReturnEmptyBlobSidecarsAfterDenebMilestone() throws ExecutionException, InterruptedException, TimeoutException { - final Eth2Peer peer = createPeer(TestSpecFactory.createMinimalDeneb()); + assumeThat(specMilestone).isGreaterThanOrEqualTo(DENEB); final List blobSidecars = requestBlobSidecarsByRange(peer, UInt64.ONE, UInt64.valueOf(10)); assertThat(blobSidecars).isEmpty(); } - @Test - public void requestBlobSidecars_shouldReturnCanonicalBlobSidecarsOnDenebMilestone() + @TestTemplate + public void requestBlobSidecars_shouldReturnEmptyBlobSidecarsWhenCountIsZero() throws ExecutionException, InterruptedException, TimeoutException { - final Eth2Peer peer = createPeer(TestSpecFactory.createMinimalDeneb()); + assumeThat(specMilestone).isGreaterThanOrEqualTo(DENEB); // finalize chain 2 blobs per block - peerStorage.chainUpdater().blockOptions.setGenerateRandomBlobs(true); - peerStorage.chainUpdater().blockOptions.setGenerateRandomBlobsCount(Optional.of(2)); + finalizeChainWithBlobs(2); - final List finalizedBlocksAndStates = - peerStorage - .chainBuilder() - .finalizeCurrentChain(Optional.of(peerStorage.chainUpdater().blockOptions)); - finalizedBlocksAndStates.forEach( - blockAndState -> { - final List blobSidecars = - peerStorage.chainBuilder().getBlobSidecars(blockAndState.getRoot()); - peerStorage.chainUpdater().saveBlock(blockAndState, blobSidecars); - peerStorage.chainUpdater().updateBestBlock(blockAndState); - }); + final List blobSidecars = + requestBlobSidecarsByRange(peer, UInt64.ONE, UInt64.ZERO); + + assertThat(blobSidecars).isEmpty(); + } + + @TestTemplate + public void requestBlobSidecars_shouldReturnCanonicalBlobSidecarsOnDenebMilestone() + throws ExecutionException, InterruptedException, TimeoutException { + assumeThat(specMilestone).isGreaterThanOrEqualTo(DENEB); + + // finalize chain 2 blobs per block + finalizeChainWithBlobs(2); final ChainBuilder fork = peerStorage.chainBuilder().fork(); @@ -118,6 +136,23 @@ public void requestBlobSidecars_shouldReturnCanonicalBlobSidecarsOnDenebMileston assertThat(blobSidecars).doesNotContainAnyElementsOf(nonCanonicalBlobSidecars); } + private void finalizeChainWithBlobs(final int blobsPerBlock) { + peerStorage.chainUpdater().blockOptions.setGenerateRandomBlobs(true); + peerStorage.chainUpdater().blockOptions.setGenerateRandomBlobsCount(Optional.of(blobsPerBlock)); + + final List finalizedBlocksAndStates = + peerStorage + .chainBuilder() + .finalizeCurrentChain(Optional.of(peerStorage.chainUpdater().blockOptions)); + finalizedBlocksAndStates.forEach( + blockAndState -> { + final List blobSidecars = + peerStorage.chainBuilder().getBlobSidecars(blockAndState.getRoot()); + peerStorage.chainUpdater().saveBlock(blockAndState, blobSidecars); + peerStorage.chainUpdater().updateBestBlock(blockAndState); + }); + } + private List requestBlobSidecarsByRange( final Eth2Peer peer, final UInt64 from, final UInt64 count) throws InterruptedException, ExecutionException, TimeoutException { diff --git a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/BlobSidecarsByRootIntegrationTest.java b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/BlobSidecarsByRootIntegrationTest.java index 85e37518598..3ed1ccd442a 100644 --- a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/BlobSidecarsByRootIntegrationTest.java +++ b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/BlobSidecarsByRootIntegrationTest.java @@ -15,7 +15,11 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.assertj.core.api.Assumptions.assumeThat; import static tech.pegasys.teku.infrastructure.async.Waiter.waitFor; +import static tech.pegasys.teku.spec.SpecMilestone.CAPELLA; +import static tech.pegasys.teku.spec.SpecMilestone.DENEB; +import static tech.pegasys.teku.spec.SpecMilestone.ELECTRA; import java.util.ArrayList; import java.util.List; @@ -24,46 +28,59 @@ import java.util.concurrent.TimeoutException; import java.util.stream.Stream; import org.apache.tuweni.bytes.Bytes32; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.networking.eth2.peers.Eth2Peer; import tech.pegasys.teku.networking.p2p.rpc.RpcResponseListener; -import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.BlobIdentifier; +@TestSpecContext(milestone = {CAPELLA, DENEB, ELECTRA}) public class BlobSidecarsByRootIntegrationTest extends AbstractRpcMethodIntegrationTest { - @Test + private Eth2Peer peer; + private SpecMilestone specMilestone; + + @BeforeEach + public void setUp(final TestSpecInvocationContextProvider.SpecContext specContext) { + peer = createPeer(specContext.getSpec()); + specMilestone = specContext.getSpecMilestone(); + } + + @TestTemplate public void requestBlobSidecars_shouldFailBeforeDenebMilestone() { - final Eth2Peer peer = createPeer(TestSpecFactory.createMinimalCapella()); + assumeThat(specMilestone).isLessThan(SpecMilestone.DENEB); assertThatThrownBy(() -> requestBlobSidecarsByRoot(peer, List.of())) .hasRootCauseInstanceOf(UnsupportedOperationException.class) .hasMessageContaining("BlobSidecarsByRoot method is not supported"); } - @Test + @TestTemplate public void requestBlobSidecar_shouldFailBeforeDenebMilestone() { - final Eth2Peer peer = createPeer(TestSpecFactory.createMinimalCapella()); + assumeThat(specMilestone).isLessThan(SpecMilestone.DENEB); assertThatThrownBy( () -> requestBlobSidecarByRoot(peer, new BlobIdentifier(Bytes32.ZERO, UInt64.ZERO))) .hasRootCauseInstanceOf(UnsupportedOperationException.class) .hasMessageContaining("BlobSidecarsByRoot method is not supported"); } - @Test - public void requestBlobSidecars_shouldReturnEmptyBlobSidecarsOnDenebMilestone() + @TestTemplate + public void requestBlobSidecars_shouldReturnEmptyBlobSidecarsAfterDenebMilestone() throws ExecutionException, InterruptedException, TimeoutException { - final Eth2Peer peer = createPeer(TestSpecFactory.createMinimalDeneb()); + assumeThat(specMilestone).isGreaterThanOrEqualTo(DENEB); final Optional blobSidecar = requestBlobSidecarByRoot(peer, new BlobIdentifier(Bytes32.ZERO, UInt64.ZERO)); assertThat(blobSidecar).isEmpty(); } - @Test + @TestTemplate public void requestBlobSidecars_shouldReturnBlobSidecarsOnDenebMilestone() throws ExecutionException, InterruptedException, TimeoutException { - final Eth2Peer peer = createPeer(TestSpecFactory.createMinimalDeneb()); + assumeThat(specMilestone).isGreaterThanOrEqualTo(DENEB); // generate 4 blobs per block peerStorage.chainUpdater().blockOptions.setGenerateRandomBlobs(true); diff --git a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/BlsToExecutionChangeGossipIntegrationTest.java b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/BlsToExecutionChangeGossipIntegrationTest.java index 672164db7e7..b19fee24735 100644 --- a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/BlsToExecutionChangeGossipIntegrationTest.java +++ b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/BlsToExecutionChangeGossipIntegrationTest.java @@ -24,6 +24,8 @@ import org.junit.jupiter.api.Test; import tech.pegasys.teku.bls.BLSKeyGenerator; import tech.pegasys.teku.bls.BLSKeyPair; +import tech.pegasys.teku.infrastructure.async.AsyncRunner; +import tech.pegasys.teku.infrastructure.async.DelayedExecutorAsyncRunner; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.async.Waiter; import tech.pegasys.teku.networking.eth2.Eth2P2PNetworkFactory.Eth2P2PNetworkBuilder; @@ -33,10 +35,13 @@ import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChange; import tech.pegasys.teku.spec.util.DataStructureUtil; +import tech.pegasys.teku.statetransition.BeaconChainUtil; import tech.pegasys.teku.statetransition.validation.InternalValidationResult; +import tech.pegasys.teku.storage.client.MemoryOnlyRecentChainData; +import tech.pegasys.teku.storage.client.RecentChainData; public class BlsToExecutionChangeGossipIntegrationTest { - + private final AsyncRunner asyncRunner = DelayedExecutorAsyncRunner.create(); private final Spec spec = TestSpecFactory.createMinimalCapella(); private final List validatorKeys = BLSKeyGenerator.generateKeyPairs(3); private final Eth2P2PNetworkFactory networkFactory = new Eth2P2PNetworkFactory(); @@ -91,8 +96,15 @@ public void shouldGossipBlsToExecutionChangesToPeers() throws Exception { .containsExactly(signedBlsToExecutionChange)); } + @SuppressWarnings("deprecation") private NodeManager createNodeManager(final Consumer networkBuilder) throws Exception { - return NodeManager.create(spec, networkFactory, validatorKeys, networkBuilder); + final RecentChainData storageClient = MemoryOnlyRecentChainData.create(spec); + final BeaconChainUtil chainUtil = BeaconChainUtil.create(spec, storageClient, validatorKeys); + chainUtil.initializeStorage(); + // Advancing chain to bypass "optimistic genesis" issue that prevents some gossip subscriptions + chainUtil.createAndImportBlockAtSlot(1); + return NodeManager.create( + spec, asyncRunner, networkFactory, networkBuilder, storageClient, chainUtil); } } diff --git a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/GetMetadataIntegrationTest.java b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/GetMetadataIntegrationTest.java index 92370fc65df..c329ce9a154 100644 --- a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/GetMetadataIntegrationTest.java +++ b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/GetMetadataIntegrationTest.java @@ -33,6 +33,7 @@ import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.metadata.versions.eip7594.MetadataMessageEip7594; import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.metadata.versions.phase0.MetadataMessagePhase0; +// TODO: Eip7594 correct testing public class GetMetadataIntegrationTest extends AbstractRpcMethodIntegrationTest { @ParameterizedTest(name = "{0}") @@ -155,7 +156,7 @@ public void requestMetadata_withDisparateVersionsEnabled( final MetadataMessage metadata = safeJoin(res); assertThat(metadata).isInstanceOf(expectedType); // There will be update of custody_subnet_count in this case - assumeThat(nextMilestone == SpecMilestone.EIP7594 && nextSpecEnabledRemotely).isFalse(); + assumeThat(nextMilestone == SpecMilestone.ELECTRA && nextSpecEnabledRemotely).isFalse(); assertThat(metadata.getSeqNumber()).isEqualTo(UInt64.ZERO); } @@ -163,7 +164,7 @@ private static Class milestoneToMetadataClass(final SpecMilestone milestone) return switch (milestone) { case PHASE0 -> MetadataMessagePhase0.class; case ALTAIR, BELLATRIX, CAPELLA, DENEB -> MetadataMessageAltair.class; - case EIP7594 -> MetadataMessageEip7594.class; + case ELECTRA, FULU -> MetadataMessageEip7594.class; }; } } diff --git a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/GossipMessageHandlerIntegrationTest.java b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/GossipMessageHandlerIntegrationTest.java index d99ba1963e8..fbf9bf87c55 100644 --- a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/GossipMessageHandlerIntegrationTest.java +++ b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/GossipMessageHandlerIntegrationTest.java @@ -27,6 +27,8 @@ import org.junit.jupiter.api.Test; import tech.pegasys.teku.bls.BLSKeyGenerator; import tech.pegasys.teku.bls.BLSKeyPair; +import tech.pegasys.teku.infrastructure.async.AsyncRunner; +import tech.pegasys.teku.infrastructure.async.DelayedExecutorAsyncRunner; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.async.Waiter; import tech.pegasys.teku.infrastructure.subscribers.Subscribers; @@ -44,7 +46,7 @@ import tech.pegasys.teku.statetransition.validation.InternalValidationResult; public class GossipMessageHandlerIntegrationTest { - + private final AsyncRunner asyncRunner = DelayedExecutorAsyncRunner.create(); private final Spec spec = TestSpecFactory.createMinimalPhase0(); private final List validatorKeys = BLSKeyGenerator.generateKeyPairs(3); private final Eth2P2PNetworkFactory networkFactory = new Eth2P2PNetworkFactory(); @@ -371,6 +373,7 @@ private NodeManager createNodeManager(final Consumer netw throws Exception { return NodeManager.create( spec, + asyncRunner, networkFactory, validatorKeys, c -> { diff --git a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/PeerStatusIntegrationTest.java b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/PeerStatusIntegrationTest.java index 62efdb5379f..97ecf2f0c13 100644 --- a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/PeerStatusIntegrationTest.java +++ b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/PeerStatusIntegrationTest.java @@ -85,7 +85,7 @@ public void shouldExchangeStatusMessagesOnConnection() throws Exception { .recentChainData(recentChainData2) .startNetwork(); - waitFor(network1.connect(network1.createPeerAddress(network2.getNodeAddress()))); + waitFor(network1.connect(network1.createPeerAddress(network2.getNodeAddresses().get(0)))); waitFor( () -> { assertThat(network1.getPeerCount()).isEqualTo(1); @@ -134,7 +134,7 @@ public void shouldExchangeStatusMessagesOnConnectionAfterFinalization() throws E .recentChainData(recentChainData2) .startNetwork(); - waitFor(network1.connect(network1.createPeerAddress(network2.getNodeAddress()))); + waitFor(network1.connect(network1.createPeerAddress(network2.getNodeAddresses().get(0)))); waitFor( () -> { assertThat(network1.getPeerCount()).isEqualTo(1); diff --git a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/PingIntegrationTest.java b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/PingIntegrationTest.java index 2dd17949b2a..b7057f5f8ae 100644 --- a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/PingIntegrationTest.java +++ b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/PingIntegrationTest.java @@ -43,7 +43,7 @@ public class PingIntegrationTest { private final Spec spec = TestSpecFactory.createDefault(); private final int attestationSubnetCount = spec.getNetworkingConfig().getAttestationSubnetCount(); - public void setUp(Duration pingInterval) throws Exception { + public void setUp(final Duration pingInterval) throws Exception { network1 = networkFactory.builder().eth2RpcPingInterval(pingInterval).startNetwork(); network2 = networkFactory.builder().eth2RpcPingInterval(pingInterval).peer(network1).startNetwork(); @@ -159,7 +159,7 @@ public void testManualPingTimeout() throws Exception { waitFor(() -> assertThat(peer1.isConnected()).isFalse()); } - private Eth2PeerManager getPeerManager(Eth2P2PNetwork eth2P2PNetwork) { + private Eth2PeerManager getPeerManager(final Eth2P2PNetwork eth2P2PNetwork) { return ((ActiveEth2P2PNetwork) eth2P2PNetwork).getPeerManager(); } } diff --git a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/ProposerSlashingGossipIntegrationTest.java b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/ProposerSlashingGossipIntegrationTest.java index 4fd806e7d45..fcf6b62354c 100644 --- a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/ProposerSlashingGossipIntegrationTest.java +++ b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/ProposerSlashingGossipIntegrationTest.java @@ -24,6 +24,8 @@ import org.junit.jupiter.api.Test; import tech.pegasys.teku.bls.BLSKeyGenerator; import tech.pegasys.teku.bls.BLSKeyPair; +import tech.pegasys.teku.infrastructure.async.AsyncRunner; +import tech.pegasys.teku.infrastructure.async.DelayedExecutorAsyncRunner; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.async.Waiter; import tech.pegasys.teku.networking.eth2.Eth2P2PNetworkFactory.Eth2P2PNetworkBuilder; @@ -36,7 +38,7 @@ import tech.pegasys.teku.statetransition.validation.InternalValidationResult; public class ProposerSlashingGossipIntegrationTest { - + private final AsyncRunner asyncRunner = DelayedExecutorAsyncRunner.create(); private final Spec spec = TestSpecFactory.createDefault(); private final List validatorKeys = BLSKeyGenerator.generateKeyPairs(3); private final Eth2P2PNetworkFactory networkFactory = new Eth2P2PNetworkFactory(); @@ -89,6 +91,6 @@ public void shouldGossipToPeers() throws Exception { private NodeManager createNodeManager(final Consumer networkBuilder) throws Exception { - return NodeManager.create(spec, networkFactory, validatorKeys, networkBuilder); + return NodeManager.create(spec, asyncRunner, networkFactory, validatorKeys, networkBuilder); } } diff --git a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/VoluntaryExitGossipIntegrationTest.java b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/VoluntaryExitGossipIntegrationTest.java index 6896c859f8f..31f93828a33 100644 --- a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/VoluntaryExitGossipIntegrationTest.java +++ b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/VoluntaryExitGossipIntegrationTest.java @@ -26,6 +26,8 @@ import org.junit.jupiter.api.Test; import tech.pegasys.teku.bls.BLSKeyGenerator; import tech.pegasys.teku.bls.BLSKeyPair; +import tech.pegasys.teku.infrastructure.async.AsyncRunner; +import tech.pegasys.teku.infrastructure.async.DelayedExecutorAsyncRunner; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.async.Waiter; import tech.pegasys.teku.infrastructure.unsigned.UInt64; @@ -42,7 +44,7 @@ import tech.pegasys.teku.statetransition.validation.InternalValidationResult; public class VoluntaryExitGossipIntegrationTest { - + private final AsyncRunner asyncRunner = DelayedExecutorAsyncRunner.create(); private final Spec spec = TestSpecFactory.createMinimalPhase0(); private final List validatorKeys = BLSKeyGenerator.generateKeyPairs(3); private final Eth2P2PNetworkFactory networkFactory = new Eth2P2PNetworkFactory(); @@ -108,6 +110,6 @@ public void shouldGossipVoluntaryExitToPeers() throws Exception { private NodeManager createNodeManager(final Consumer networkBuilder) throws Exception { - return NodeManager.create(networkFactory, validatorKeys, networkBuilder); + return NodeManager.create(asyncRunner, networkFactory, validatorKeys, networkBuilder); } } diff --git a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/peers/Eth2PeerManagerAccess.java b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/peers/Eth2PeerManagerAccess.java index 737991eb053..b550fe3f244 100644 --- a/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/peers/Eth2PeerManagerAccess.java +++ b/networking/eth2/src/integration-test/java/tech/pegasys/teku/networking/eth2/peers/Eth2PeerManagerAccess.java @@ -14,7 +14,8 @@ package tech.pegasys.teku.networking.eth2.peers; public class Eth2PeerManagerAccess { - public static void invokeSendPeriodicPing(Eth2PeerManager peerManager, Eth2Peer peer) { + public static void invokeSendPeriodicPing( + final Eth2PeerManager peerManager, final Eth2Peer peer) { peerManager.sendPeriodicPing(peer); } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/ActiveEth2P2PNetwork.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/ActiveEth2P2PNetwork.java index c108c3d8754..6706d10ac82 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/ActiveEth2P2PNetwork.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/ActiveEth2P2PNetwork.java @@ -158,7 +158,7 @@ private synchronized void startGossip() { discoveryNetworkSyncCommitteeSubnetsSubscription = syncCommitteeSubnetService.subscribeToUpdates( discoveryNetwork::setSyncCommitteeSubnetSubscriptions); - if (spec.isMilestoneSupported(SpecMilestone.EIP7594)) { + if (spec.isMilestoneSupported(SpecMilestone.ELECTRA)) { LOG.info("Using custody sidecar subnets count: {}", dasTotalCustodySubnetCount); discoveryNetwork.setDASTotalCustodySubnetCount(dasTotalCustodySubnetCount); } @@ -346,13 +346,13 @@ public void unsubscribeFromSyncCommitteeSubnetId(final int subnetId) { } @Override - public void subscribeToDataColumnSidecarSubnetId(int subnetId) { + public void subscribeToDataColumnSidecarSubnetId(final int subnetId) { gossipForkManager.subscribeToDataColumnSidecarSubnetId(subnetId); dataColumnSidecarSubnetService.addSubscription(subnetId); } @Override - public void unsubscribeFromDataColumnSidecarSubnetId(int subnetId) { + public void unsubscribeFromDataColumnSidecarSubnetId(final int subnetId) { gossipForkManager.unsubscribeFromDataColumnSidecarSubnetId(subnetId); dataColumnSidecarSubnetService.removeSubscription(subnetId); } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/Eth2P2PNetworkBuilder.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/Eth2P2PNetworkBuilder.java index d26b34ac25f..2d6bde300a0 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/Eth2P2PNetworkBuilder.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/Eth2P2PNetworkBuilder.java @@ -16,6 +16,7 @@ import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkState; +import static tech.pegasys.teku.spec.config.SpecConfig.FAR_FUTURE_EPOCH; import java.time.Duration; import java.util.ArrayList; @@ -39,7 +40,8 @@ import tech.pegasys.teku.networking.eth2.gossip.forks.versions.GossipForkSubscriptionsBellatrix; import tech.pegasys.teku.networking.eth2.gossip.forks.versions.GossipForkSubscriptionsCapella; import tech.pegasys.teku.networking.eth2.gossip.forks.versions.GossipForkSubscriptionsDeneb; -import tech.pegasys.teku.networking.eth2.gossip.forks.versions.GossipForkSubscriptionsEip7594; +import tech.pegasys.teku.networking.eth2.gossip.forks.versions.GossipForkSubscriptionsElectra; +import tech.pegasys.teku.networking.eth2.gossip.forks.versions.GossipForkSubscriptionsElectraEip7594; import tech.pegasys.teku.networking.eth2.gossip.forks.versions.GossipForkSubscriptionsPhase0; import tech.pegasys.teku.networking.eth2.gossip.subnets.AttestationSubnetTopicProvider; import tech.pegasys.teku.networking.eth2.gossip.subnets.DataColumnSidecarSubnetTopicProvider; @@ -72,8 +74,11 @@ import tech.pegasys.teku.networking.p2p.reputation.ReputationManager; import tech.pegasys.teku.networking.p2p.rpc.RpcMethod; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecFeature; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.config.Constants; +import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.config.features.Eip7594; import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSidecar; @@ -85,11 +90,13 @@ import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SignedContributionAndProof; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.ValidatableSyncCommitteeMessage; import tech.pegasys.teku.spec.datastructures.state.Checkpoint; +import tech.pegasys.teku.spec.datastructures.state.Fork; import tech.pegasys.teku.spec.datastructures.util.ForkAndSpecMilestone; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsSupplier; import tech.pegasys.teku.statetransition.datacolumns.DataColumnSidecarByRootCustody; import tech.pegasys.teku.statetransition.datacolumns.log.gossip.DasGossipLogger; import tech.pegasys.teku.statetransition.datacolumns.log.rpc.DasReqRespLogger; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.client.CombinedChainDataClient; import tech.pegasys.teku.storage.store.KeyValueStore; @@ -136,6 +143,7 @@ public class Eth2P2PNetworkBuilder { protected StatusMessageFactory statusMessageFactory; protected KZG kzg; protected boolean recordMessageArrival; + protected DebugDataDumper debugDataDumper; private DasGossipLogger dasGossipLogger; private DasReqRespLogger dasReqRespLogger; @@ -161,10 +169,10 @@ public Eth2P2PNetwork build() { } final Optional dasTotalCustodySubnetCount = - spec.isMilestoneSupported(SpecMilestone.EIP7594) + spec.isMilestoneSupported(SpecMilestone.ELECTRA) ? Optional.of( UInt64.valueOf( - config.getTotalCustodySubnetCount(spec.forMilestone(SpecMilestone.EIP7594)))) + config.getTotalCustodySubnetCount(spec.forMilestone(SpecMilestone.ELECTRA)))) : Optional.empty(); final Eth2PeerManager eth2PeerManager = @@ -230,6 +238,27 @@ private GossipForkManager buildGossipForkManager( forkAndSpecMilestone -> createSubscriptions(forkAndSpecMilestone, network, gossipEncoding)) .forEach(gossipForkManagerBuilder::fork); + // TODO: fix ELECTRA and EIP7594 hardcode + if (spec.isFeatureScheduled(SpecFeature.EIP7594)) { + final UInt64 activationEpoch = + Eip7594.required(spec.forMilestone(SpecMilestone.ELECTRA).getConfig()) + .getEip7594FeatureEpoch(); + final Fork fork = spec.getForkSchedule().getFork(activationEpoch); + spec.getEnabledFeatures().stream() + .map( + specFeature -> + createFeatureSubscriptions( + spec.getEnabledMilestones().stream() + .filter( + forkAndSpecMilestone -> forkAndSpecMilestone.getFork().equals(fork)) + .findFirst() + .orElseThrow(), + specFeature, + spec.forMilestone(SpecMilestone.ELECTRA).getConfig(), + network, + gossipEncoding)) + .forEach(gossipForkManagerBuilder::fork); + } return gossipForkManagerBuilder.build(); } @@ -238,106 +267,152 @@ private GossipForkSubscriptions createSubscriptions( final DiscoveryNetwork network, final GossipEncoding gossipEncoding) { return switch (forkAndSpecMilestone.getSpecMilestone()) { - case PHASE0 -> new GossipForkSubscriptionsPhase0( - forkAndSpecMilestone.getFork(), - spec, - asyncRunner, - metricsSystem, - network, - combinedChainDataClient.getRecentChainData(), - gossipEncoding, - gossipedBlockProcessor, - gossipedAttestationConsumer, - gossipedAggregateProcessor, - gossipedAttesterSlashingConsumer, - gossipedProposerSlashingConsumer, - gossipedVoluntaryExitConsumer); - case ALTAIR -> new GossipForkSubscriptionsAltair( - forkAndSpecMilestone.getFork(), - spec, - asyncRunner, - metricsSystem, - network, - combinedChainDataClient.getRecentChainData(), - gossipEncoding, - gossipedBlockProcessor, - gossipedAttestationConsumer, - gossipedAggregateProcessor, - gossipedAttesterSlashingConsumer, - gossipedProposerSlashingConsumer, - gossipedVoluntaryExitConsumer, - gossipedSignedContributionAndProofProcessor, - gossipedSyncCommitteeMessageProcessor); - case BELLATRIX -> new GossipForkSubscriptionsBellatrix( - forkAndSpecMilestone.getFork(), - spec, - asyncRunner, - metricsSystem, - network, - combinedChainDataClient.getRecentChainData(), - gossipEncoding, - gossipedBlockProcessor, - gossipedAttestationConsumer, - gossipedAggregateProcessor, - gossipedAttesterSlashingConsumer, - gossipedProposerSlashingConsumer, - gossipedVoluntaryExitConsumer, - gossipedSignedContributionAndProofProcessor, - gossipedSyncCommitteeMessageProcessor); - case CAPELLA -> new GossipForkSubscriptionsCapella( - forkAndSpecMilestone.getFork(), - spec, - asyncRunner, - metricsSystem, - network, - combinedChainDataClient.getRecentChainData(), - gossipEncoding, - gossipedBlockProcessor, - gossipedAttestationConsumer, - gossipedAggregateProcessor, - gossipedAttesterSlashingConsumer, - gossipedProposerSlashingConsumer, - gossipedVoluntaryExitConsumer, - gossipedSignedContributionAndProofProcessor, - gossipedSyncCommitteeMessageProcessor, - gossipedSignedBlsToExecutionChangeProcessor); - case DENEB -> new GossipForkSubscriptionsDeneb( - forkAndSpecMilestone.getFork(), - spec, - asyncRunner, - metricsSystem, - network, - combinedChainDataClient.getRecentChainData(), - gossipEncoding, - gossipedBlockProcessor, - gossipedBlobSidecarProcessor, - gossipedAttestationConsumer, - gossipedAggregateProcessor, - gossipedAttesterSlashingConsumer, - gossipedProposerSlashingConsumer, - gossipedVoluntaryExitConsumer, - gossipedSignedContributionAndProofProcessor, - gossipedSyncCommitteeMessageProcessor, - gossipedSignedBlsToExecutionChangeProcessor); - case EIP7594 -> new GossipForkSubscriptionsEip7594( - forkAndSpecMilestone.getFork(), - spec, - asyncRunner, - metricsSystem, - network, - combinedChainDataClient.getRecentChainData(), - gossipEncoding, - gossipedBlockProcessor, - gossipedAttestationConsumer, - gossipedAggregateProcessor, - gossipedAttesterSlashingConsumer, - gossipedProposerSlashingConsumer, - gossipedVoluntaryExitConsumer, - gossipedSignedContributionAndProofProcessor, - gossipedSyncCommitteeMessageProcessor, - gossipedSignedBlsToExecutionChangeProcessor, - dataColumnSidecarOperationProcessor, - dasGossipLogger); + case PHASE0 -> + new GossipForkSubscriptionsPhase0( + forkAndSpecMilestone.getFork(), + spec, + asyncRunner, + metricsSystem, + network, + combinedChainDataClient.getRecentChainData(), + gossipEncoding, + gossipedBlockProcessor, + gossipedAttestationConsumer, + gossipedAggregateProcessor, + gossipedAttesterSlashingConsumer, + gossipedProposerSlashingConsumer, + gossipedVoluntaryExitConsumer, + debugDataDumper); + case ALTAIR -> + new GossipForkSubscriptionsAltair( + forkAndSpecMilestone.getFork(), + spec, + asyncRunner, + metricsSystem, + network, + combinedChainDataClient.getRecentChainData(), + gossipEncoding, + gossipedBlockProcessor, + gossipedAttestationConsumer, + gossipedAggregateProcessor, + gossipedAttesterSlashingConsumer, + gossipedProposerSlashingConsumer, + gossipedVoluntaryExitConsumer, + gossipedSignedContributionAndProofProcessor, + gossipedSyncCommitteeMessageProcessor, + debugDataDumper); + case BELLATRIX -> + new GossipForkSubscriptionsBellatrix( + forkAndSpecMilestone.getFork(), + spec, + asyncRunner, + metricsSystem, + network, + combinedChainDataClient.getRecentChainData(), + gossipEncoding, + gossipedBlockProcessor, + gossipedAttestationConsumer, + gossipedAggregateProcessor, + gossipedAttesterSlashingConsumer, + gossipedProposerSlashingConsumer, + gossipedVoluntaryExitConsumer, + gossipedSignedContributionAndProofProcessor, + gossipedSyncCommitteeMessageProcessor, + debugDataDumper); + case CAPELLA -> + new GossipForkSubscriptionsCapella( + forkAndSpecMilestone.getFork(), + spec, + asyncRunner, + metricsSystem, + network, + combinedChainDataClient.getRecentChainData(), + gossipEncoding, + gossipedBlockProcessor, + gossipedAttestationConsumer, + gossipedAggregateProcessor, + gossipedAttesterSlashingConsumer, + gossipedProposerSlashingConsumer, + gossipedVoluntaryExitConsumer, + gossipedSignedContributionAndProofProcessor, + gossipedSyncCommitteeMessageProcessor, + gossipedSignedBlsToExecutionChangeProcessor, + debugDataDumper); + case DENEB -> + new GossipForkSubscriptionsDeneb( + forkAndSpecMilestone.getFork(), + spec, + asyncRunner, + metricsSystem, + network, + combinedChainDataClient.getRecentChainData(), + gossipEncoding, + gossipedBlockProcessor, + gossipedBlobSidecarProcessor, + gossipedAttestationConsumer, + gossipedAggregateProcessor, + gossipedAttesterSlashingConsumer, + gossipedProposerSlashingConsumer, + gossipedVoluntaryExitConsumer, + gossipedSignedContributionAndProofProcessor, + gossipedSyncCommitteeMessageProcessor, + gossipedSignedBlsToExecutionChangeProcessor, + debugDataDumper); + case ELECTRA, FULU -> + new GossipForkSubscriptionsElectra( + forkAndSpecMilestone.getFork(), + spec, + asyncRunner, + metricsSystem, + network, + combinedChainDataClient.getRecentChainData(), + gossipEncoding, + gossipedBlockProcessor, + gossipedBlobSidecarProcessor, + gossipedAttestationConsumer, + gossipedAggregateProcessor, + gossipedAttesterSlashingConsumer, + gossipedProposerSlashingConsumer, + gossipedVoluntaryExitConsumer, + gossipedSignedContributionAndProofProcessor, + gossipedSyncCommitteeMessageProcessor, + gossipedSignedBlsToExecutionChangeProcessor, + debugDataDumper); + }; + } + + private GossipForkSubscriptions createFeatureSubscriptions( + final ForkAndSpecMilestone forkAndSpecMilestone, + final SpecFeature specFeature, + final SpecConfig specConfig, + final DiscoveryNetwork network, + final GossipEncoding gossipEncoding) { + + return switch (specFeature) { + case EIP7594 -> + new GossipForkSubscriptionsElectraEip7594( + forkAndSpecMilestone.getFork(), + Eip7594.required(specConfig).getEip7594FeatureEpoch(), + // TODO + FAR_FUTURE_EPOCH, + spec, + asyncRunner, + metricsSystem, + network, + combinedChainDataClient.getRecentChainData(), + gossipEncoding, + gossipedBlockProcessor, + gossipedAttestationConsumer, + gossipedAggregateProcessor, + gossipedAttesterSlashingConsumer, + gossipedProposerSlashingConsumer, + gossipedVoluntaryExitConsumer, + gossipedSignedContributionAndProofProcessor, + gossipedSyncCommitteeMessageProcessor, + gossipedSignedBlsToExecutionChangeProcessor, + debugDataDumper, + dataColumnSidecarOperationProcessor, + dasGossipLogger); }; } @@ -464,7 +539,7 @@ private void validate() { "gossipedSignedBlsToExecutionChangeProcessor", gossipedSignedBlsToExecutionChangeProcessor); } - private void assertNotNull(String fieldName, Object fieldValue) { + private void assertNotNull(final String fieldName, final Object fieldValue) { checkState(fieldValue != null, "Field " + fieldName + " must be set."); } @@ -488,7 +563,7 @@ public Eth2P2PNetworkBuilder combinedChainDataClient( } public Eth2P2PNetworkBuilder dataColumnSidecarCustody( - DataColumnSidecarByRootCustody dataColumnSidecarCustody) { + final DataColumnSidecarByRootCustody dataColumnSidecarCustody) { checkNotNull(dataColumnSidecarCustody); this.dataColumnSidecarCustody = dataColumnSidecarCustody; return this; @@ -581,7 +656,7 @@ public Eth2P2PNetworkBuilder gossipedSignedBlsToExecutionChangeProcessor( } public Eth2P2PNetworkBuilder gossipedDataColumnSidecarOperationProcessor( - OperationProcessor dataColumnSidecarOperationProcessor) { + final OperationProcessor dataColumnSidecarOperationProcessor) { checkNotNull(dataColumnSidecarOperationProcessor); this.dataColumnSidecarOperationProcessor = dataColumnSidecarOperationProcessor; return this; @@ -659,7 +734,12 @@ public Eth2P2PNetworkBuilder recordMessageArrival(final boolean recordMessageArr return this; } - public Eth2P2PNetworkBuilder gossipDasLogger(DasGossipLogger dasGossipLogger) { + public Eth2P2PNetworkBuilder p2pDebugDataDumper(final DebugDataDumper debugDataDumper) { + this.debugDataDumper = debugDataDumper; + return this; + } + + public Eth2P2PNetworkBuilder gossipDasLogger(final DasGossipLogger dasGossipLogger) { this.dasGossipLogger = dasGossipLogger; return this; } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/P2PConfig.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/P2PConfig.java index 25927c4093f..087ba4ed2e1 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/P2PConfig.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/P2PConfig.java @@ -14,6 +14,7 @@ package tech.pegasys.teku.networking.eth2; import static com.google.common.base.Preconditions.checkNotNull; +import static tech.pegasys.teku.networking.p2p.gossip.config.GossipConfig.DEFAULT_FLOOD_PUBLISH_MAX_MESSAGE_SIZE_THRESHOLD; import java.time.Duration; import java.util.OptionalInt; @@ -28,7 +29,7 @@ import tech.pegasys.teku.spec.SpecVersion; import tech.pegasys.teku.spec.config.NetworkingSpecConfig; import tech.pegasys.teku.spec.config.SpecConfig; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.features.Eip7594; import tech.pegasys.teku.spec.logic.common.helpers.MathHelpers; public class P2PConfig { @@ -40,6 +41,7 @@ public class P2PConfig { public static final int DEFAULT_P2P_TARGET_SUBNET_SUBSCRIBER_COUNT = 2; public static final boolean DEFAULT_SUBSCRIBE_ALL_SUBNETS_ENABLED = false; public static final boolean DEFAULT_GOSSIP_SCORING_ENABLED = true; + public static final boolean DEFAULT_GOSSIP_BLOBS_AFTER_BLOCK_ENABLED = false; public static final int DEFAULT_BATCH_VERIFY_MAX_THREADS = Math.max(2, Runtime.getRuntime().availableProcessors() / 2); public static final int DEFAULT_BATCH_VERIFY_QUEUE_CAPACITY = 15_000; @@ -65,7 +67,7 @@ public class P2PConfig { private final int batchVerifyQueueCapacity; private final int batchVerifyMaxBatchSize; private final boolean batchVerifyStrictThreadLimitEnabled; - + private final boolean isGossipBlobsAfterBlockEnabled; private final boolean allTopicsFilterEnabled; private P2PConfig( @@ -84,7 +86,8 @@ private P2PConfig( final int batchVerifyQueueCapacity, final int batchVerifyMaxBatchSize, final boolean batchVerifyStrictThreadLimitEnabled, - boolean allTopicsFilterEnabled) { + final boolean allTopicsFilterEnabled, + final boolean isGossipBlobsAfterBlockEnabled) { this.spec = spec; this.networkConfig = networkConfig; this.discoveryConfig = discoveryConfig; @@ -102,6 +105,7 @@ private P2PConfig( this.batchVerifyStrictThreadLimitEnabled = batchVerifyStrictThreadLimitEnabled; this.networkingSpecConfig = spec.getNetworkingConfig(); this.allTopicsFilterEnabled = allTopicsFilterEnabled; + this.isGossipBlobsAfterBlockEnabled = isGossipBlobsAfterBlockEnabled; } public static Builder builder() { @@ -136,8 +140,8 @@ public boolean isSubscribeAllSubnetsEnabled() { return subscribeAllSubnetsEnabled; } - public int getTotalCustodySubnetCount(SpecVersion specVersion) { - SpecConfigEip7594 configEip7594 = SpecConfigEip7594.required(specVersion.getConfig()); + public int getTotalCustodySubnetCount(final SpecVersion specVersion) { + Eip7594 configEip7594 = Eip7594.required(specVersion.getConfig()); int minCustodyRequirement = configEip7594.getCustodyRequirement(); int maxSubnets = configEip7594.getDataColumnSidecarSubnetCount(); return Integer.min( @@ -177,6 +181,10 @@ public boolean isAllTopicsFilterEnabled() { return allTopicsFilterEnabled; } + public boolean isGossipBlobsAfterBlockEnabled() { + return isGossipBlobsAfterBlockEnabled; + } + public boolean isDasLossySamplerEnabled() { return dasLossySamplerEnabled; } @@ -187,7 +195,7 @@ public static class Builder { private Spec spec; private Boolean isGossipScoringEnabled = DEFAULT_GOSSIP_SCORING_ENABLED; - private GossipEncoding gossipEncoding = GossipEncoding.SSZ_SNAPPY; + private final GossipEncoding gossipEncoding = GossipEncoding.SSZ_SNAPPY; private Integer targetSubnetSubscriberCount = DEFAULT_P2P_TARGET_SUBNET_SUBSCRIBER_COUNT; private Boolean subscribeAllSubnetsEnabled = DEFAULT_SUBSCRIBE_ALL_SUBNETS_ENABLED; private Boolean subscribeAllCustodySubnetsEnabled = DEFAULT_SUBSCRIBE_ALL_SUBNETS_ENABLED; @@ -196,11 +204,14 @@ public static class Builder { private Integer peerRateLimit = DEFAULT_PEER_RATE_LIMIT; private Integer peerRequestLimit = DEFAULT_PEER_REQUEST_LIMIT; private int batchVerifyMaxThreads = DEFAULT_BATCH_VERIFY_MAX_THREADS; - private int batchVerifyQueueCapacity = DEFAULT_BATCH_VERIFY_QUEUE_CAPACITY; + private OptionalInt batchVerifyQueueCapacity = OptionalInt.empty(); private int batchVerifyMaxBatchSize = DEFAULT_BATCH_VERIFY_MAX_BATCH_SIZE; private boolean batchVerifyStrictThreadLimitEnabled = DEFAULT_BATCH_VERIFY_STRICT_THREAD_LIMIT_ENABLED; private boolean allTopicsFilterEnabled = DEFAULT_PEER_ALL_TOPIC_FILTER_ENABLED; + private int floodPublishMaxMessageSizeThreshold = + DEFAULT_FLOOD_PUBLISH_MAX_MESSAGE_SIZE_THRESHOLD; + private boolean gossipBlobsAfterBlockEnabled = DEFAULT_GOSSIP_BLOBS_AFTER_BLOCK_ENABLED; private Builder() {} @@ -223,11 +234,15 @@ public P2PConfig build() { builder.seenTTL( Duration.ofSeconds( (long) specConfig.getSecondsPerSlot() * specConfig.getSlotsPerEpoch() * 2)); + builder.floodPublishMaxMessageSizeThreshold(floodPublishMaxMessageSizeThreshold); }); final NetworkConfig networkConfig = this.networkConfig.build(); discoveryConfig.listenUdpPortDefault(networkConfig.getListenPort()); + discoveryConfig.listenUdpPortIpv6Default(networkConfig.getListenPortIpv6()); discoveryConfig.advertisedUdpPortDefault(OptionalInt.of(networkConfig.getAdvertisedPort())); + discoveryConfig.advertisedUdpPortIpv6Default( + OptionalInt.of(networkConfig.getAdvertisedPortIpv6())); if (subscribeAllCustodySubnetsEnabled) { dasExtraCustodySubnetCount = Integer.MAX_VALUE; @@ -246,10 +261,11 @@ public P2PConfig build() { peerRateLimit, peerRequestLimit, batchVerifyMaxThreads, - batchVerifyQueueCapacity, + batchVerifyQueueCapacity.orElse(DEFAULT_BATCH_VERIFY_QUEUE_CAPACITY), batchVerifyMaxBatchSize, batchVerifyStrictThreadLimitEnabled, - allTopicsFilterEnabled); + allTopicsFilterEnabled, + gossipBlobsAfterBlockEnabled); } private void validate() { @@ -299,7 +315,7 @@ public Builder dasLossySamplerEnabled(final boolean dasLossySamplerEnabled) { return this; } - public Builder dasExtraCustodySubnetCount(int dasExtraCustodySubnetCount) { + public Builder dasExtraCustodySubnetCount(final int dasExtraCustodySubnetCount) { this.dasExtraCustodySubnetCount = dasExtraCustodySubnetCount; return this; } @@ -331,6 +347,17 @@ public Builder peerRequestLimit(final Integer peerRequestLimit) { return this; } + public Builder floodPublishMaxMessageSizeThreshold( + final int floodPublishMaxMessageSizeThreshold) { + this.floodPublishMaxMessageSizeThreshold = floodPublishMaxMessageSizeThreshold; + return this; + } + + public Builder gossipBlobsAfterBlockEnabled(final boolean gossipBlobsAfterBlockEnabled) { + this.gossipBlobsAfterBlockEnabled = gossipBlobsAfterBlockEnabled; + return this; + } + public Builder batchVerifyMaxThreads(final int batchVerifyMaxThreads) { if (batchVerifyMaxThreads < 0) { throw new InvalidConfigurationException( @@ -340,12 +367,19 @@ public Builder batchVerifyMaxThreads(final int batchVerifyMaxThreads) { return this; } + public Builder batchVerifyQueueCapacityIfDefault(final int batchVerifyQueueCapacity) { + if (this.batchVerifyQueueCapacity.isEmpty()) { + return this.batchVerifyQueueCapacity(batchVerifyQueueCapacity); + } + return this; + } + public Builder batchVerifyQueueCapacity(final int batchVerifyQueueCapacity) { if (batchVerifyQueueCapacity < 0) { throw new InvalidConfigurationException( String.format("Invalid batchVerifyQueueCapacity: %d", batchVerifyQueueCapacity)); } - this.batchVerifyQueueCapacity = batchVerifyQueueCapacity; + this.batchVerifyQueueCapacity = OptionalInt.of(batchVerifyQueueCapacity); return this; } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/SubnetSubscriptionService.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/SubnetSubscriptionService.java index a9d433bf0e7..d0e0f601752 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/SubnetSubscriptionService.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/SubnetSubscriptionService.java @@ -42,11 +42,11 @@ public synchronized void removeSubscription(final int subnet) { subnetSubscriptions.set(values); } - public synchronized long subscribeToUpdates(ValueObserver> observer) { + public synchronized long subscribeToUpdates(final ValueObserver> observer) { return subnetSubscriptions.subscribe(observer); } - public void unsubscribe(long subscriptionId) { + public void unsubscribe(final long subscriptionId) { subnetSubscriptions.unsubscribe(subscriptionId); } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/AbstractGossipManager.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/AbstractGossipManager.java index b6850a68017..7dc70810b8f 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/AbstractGossipManager.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/AbstractGossipManager.java @@ -16,7 +16,10 @@ import com.google.common.annotations.VisibleForTesting; import java.util.Optional; import java.util.function.Function; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; import tech.pegasys.teku.infrastructure.async.AsyncRunner; +import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.ssz.SszData; import tech.pegasys.teku.infrastructure.ssz.schema.SszSchema; import tech.pegasys.teku.infrastructure.unsigned.UInt64; @@ -29,9 +32,11 @@ import tech.pegasys.teku.networking.p2p.gossip.TopicChannel; import tech.pegasys.teku.spec.config.NetworkingSpecConfig; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.client.RecentChainData; public abstract class AbstractGossipManager implements GossipManager { + private static final Logger LOG = LogManager.getLogger(); private final GossipNetwork gossipNetwork; private final GossipEncoding gossipEncoding; @@ -39,6 +44,8 @@ public abstract class AbstractGossipManager implements Gossip private final Eth2TopicHandler topicHandler; private Optional channel = Optional.empty(); + private final GossipFailureLogger gossipFailureLogger; + private final Function> getSlotForMessage; protected AbstractGossipManager( final RecentChainData recentChainData, @@ -49,8 +56,11 @@ protected AbstractGossipManager( final ForkInfo forkInfo, final OperationProcessor processor, final SszSchema gossipType, + final Function> getSlotForMessage, final Function getEpochForMessage, - final NetworkingSpecConfig networkingConfig) { + final NetworkingSpecConfig networkingConfig, + final GossipFailureLogger gossipFailureLogger, + final DebugDataDumper debugDataDumper) { this.gossipNetwork = gossipNetwork; this.topicHandler = new Eth2TopicHandler<>( @@ -63,8 +73,11 @@ protected AbstractGossipManager( new OperationMilestoneValidator<>( recentChainData.getSpec(), forkInfo.getFork(), getEpochForMessage), gossipType, - networkingConfig); + networkingConfig, + debugDataDumper); this.gossipEncoding = gossipEncoding; + this.gossipFailureLogger = gossipFailureLogger; + this.getSlotForMessage = getSlotForMessage; } @VisibleForTesting @@ -72,8 +85,30 @@ public Eth2TopicHandler getTopicHandler() { return topicHandler; } - protected void publishMessage(T message) { - channel.ifPresent(c -> c.gossip(gossipEncoding.encode(message))); + protected void publishMessage(final T message) { + publishMessageWithFeedback(message).ifExceptionGetsHereRaiseABug(); + } + + /** + * This method is designed to return a future that only completes successfully whenever the gossip + * was succeeded (sent to at least one peer) or failed. + */ + protected SafeFuture publishMessageWithFeedback(final T message) { + return channel + .map(c -> c.gossip(gossipEncoding.encode(message))) + .orElse(SafeFuture.failedFuture(new IllegalStateException("Gossip channel not available"))) + .handle( + (__, err) -> { + if (err != null) { + gossipFailureLogger.log(err, getSlotForMessage.apply(message)); + } else { + LOG.trace( + "Successfully gossiped message with root {} on {}", + message::hashTreeRoot, + topicHandler::getTopic); + } + return null; + }); } @Override diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/AggregateGossipManager.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/AggregateGossipManager.java index cb0737a6db0..59eae100efe 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/AggregateGossipManager.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/AggregateGossipManager.java @@ -13,6 +13,7 @@ package tech.pegasys.teku.networking.eth2.gossip; +import java.util.Optional; import tech.pegasys.teku.infrastructure.async.AsyncRunner; import tech.pegasys.teku.networking.eth2.gossip.encoding.GossipEncoding; import tech.pegasys.teku.networking.eth2.gossip.topics.GossipTopicName; @@ -22,6 +23,7 @@ import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.client.RecentChainData; public class AggregateGossipManager extends AbstractGossipManager { @@ -33,7 +35,8 @@ public AggregateGossipManager( final GossipNetwork gossipNetwork, final GossipEncoding gossipEncoding, final ForkInfo forkInfo, - final OperationProcessor processor) { + final OperationProcessor processor, + final DebugDataDumper debugDataDumper) { super( recentChainData, GossipTopicName.BEACON_AGGREGATE_AND_PROOF, @@ -49,8 +52,12 @@ public AggregateGossipManager( spec.atEpoch(forkInfo.getFork().getEpoch()) .getSchemaDefinitions() .getSignedAggregateAndProofSchema(), + message -> Optional.of(message.getMessage().getAggregate().getData().getSlot()), message -> spec.computeEpochAtSlot(message.getMessage().getAggregate().getData().getSlot()), - spec.getNetworkingConfig()); + spec.getNetworkingConfig(), + GossipFailureLogger.createSuppressing( + GossipTopicName.BEACON_AGGREGATE_AND_PROOF.toString()), + debugDataDumper); } public void onNewAggregate(final ValidatableAttestation validatableAttestation) { diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/AttestationGossipManager.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/AttestationGossipManager.java index 5f93c7c288c..3e9dfa6ba60 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/AttestationGossipManager.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/AttestationGossipManager.java @@ -13,6 +13,7 @@ package tech.pegasys.teku.networking.eth2.gossip; +import java.util.Optional; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.hyperledger.besu.plugin.services.MetricsSystem; @@ -31,7 +32,8 @@ public class AttestationGossipManager implements GossipManager { private final Counter attestationPublishSuccessCounter; private final Counter attestationPublishFailureCounter; - private final GossipFailureLogger gossipFailureLogger = new GossipFailureLogger("attestation"); + private final GossipFailureLogger gossipFailureLogger = + GossipFailureLogger.createSuppressing("attestation"); public AttestationGossipManager( final MetricsSystem metricsSystem, @@ -62,18 +64,18 @@ public void onNewAttestation(final ValidatableAttestation validatableAttestation attestationPublishSuccessCounter.inc(); }, error -> { - gossipFailureLogger.logWithSuppression(error, attestation.getData().getSlot()); + gossipFailureLogger.log(error, Optional.of(attestation.getData().getSlot())); attestationPublishFailureCounter.inc(); }); } public void subscribeToSubnetId(final int subnetId) { - LOG.trace("Subscribing to subnet ID {}", subnetId); + LOG.trace("Subscribing to attestation subnet {}", subnetId); subnetSubscriptions.subscribeToSubnetId(subnetId); } public void unsubscribeFromSubnetId(final int subnetId) { - LOG.trace("Unsubscribing to subnet ID {}", subnetId); + LOG.trace("Unsubscribing to attestation subnet {}", subnetId); subnetSubscriptions.unsubscribeFromSubnetId(subnetId); } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/AttesterSlashingGossipManager.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/AttesterSlashingGossipManager.java index 49a865d1843..adeabe716b8 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/AttesterSlashingGossipManager.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/AttesterSlashingGossipManager.java @@ -13,6 +13,7 @@ package tech.pegasys.teku.networking.eth2.gossip; +import java.util.Optional; import tech.pegasys.teku.infrastructure.async.AsyncRunner; import tech.pegasys.teku.networking.eth2.gossip.encoding.GossipEncoding; import tech.pegasys.teku.networking.eth2.gossip.topics.GossipTopicName; @@ -21,6 +22,7 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.client.RecentChainData; public class AttesterSlashingGossipManager extends AbstractGossipManager { @@ -32,7 +34,8 @@ public AttesterSlashingGossipManager( final GossipNetwork gossipNetwork, final GossipEncoding gossipEncoding, final ForkInfo forkInfo, - final OperationProcessor processor) { + final OperationProcessor processor, + final DebugDataDumper debugDataDumper) { super( recentChainData, GossipTopicName.ATTESTER_SLASHING, @@ -44,8 +47,11 @@ public AttesterSlashingGossipManager( spec.atEpoch(forkInfo.getFork().getEpoch()) .getSchemaDefinitions() .getAttesterSlashingSchema(), + message -> Optional.of(message.getAttestation1().getData().getSlot()), message -> spec.computeEpochAtSlot(message.getAttestation1().getData().getSlot()), - spec.getNetworkingConfig()); + spec.getNetworkingConfig(), + GossipFailureLogger.createNonSuppressing(GossipTopicName.ATTESTER_SLASHING.toString()), + debugDataDumper); } public void publishAttesterSlashing(final AttesterSlashing message) { diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/BlobSidecarGossipChannel.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/BlobSidecarGossipChannel.java index 40b3b63181f..596b63829bd 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/BlobSidecarGossipChannel.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/BlobSidecarGossipChannel.java @@ -14,16 +14,17 @@ package tech.pegasys.teku.networking.eth2.gossip; import java.util.List; -import tech.pegasys.teku.infrastructure.events.VoidReturningChannelInterface; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.events.ChannelInterface; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; -public interface BlobSidecarGossipChannel extends VoidReturningChannelInterface { +public interface BlobSidecarGossipChannel extends ChannelInterface { - BlobSidecarGossipChannel NOOP = blobSidecar -> {}; + BlobSidecarGossipChannel NOOP = blobSidecar -> SafeFuture.COMPLETE; - default void publishBlobSidecars(final List blobSidecars) { - blobSidecars.forEach(this::publishBlobSidecar); + default SafeFuture publishBlobSidecars(final List blobSidecars) { + return SafeFuture.allOf(blobSidecars.stream().map(this::publishBlobSidecar)); } - void publishBlobSidecar(BlobSidecar blobSidecar); + SafeFuture publishBlobSidecar(BlobSidecar blobSidecar); } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/BlobSidecarGossipManager.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/BlobSidecarGossipManager.java index dec9c6a8807..d020566f0ff 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/BlobSidecarGossipManager.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/BlobSidecarGossipManager.java @@ -13,16 +13,19 @@ package tech.pegasys.teku.networking.eth2.gossip; +import static tech.pegasys.teku.networking.eth2.gossip.topics.GossipTopicName.getBlobSidecarSubnetTopicName; + import com.google.common.annotations.VisibleForTesting; import it.unimi.dsi.fastutil.ints.Int2ObjectMap; import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap; import java.util.Optional; import java.util.stream.IntStream; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; import tech.pegasys.teku.infrastructure.async.AsyncRunner; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.networking.eth2.gossip.encoding.GossipEncoding; -import tech.pegasys.teku.networking.eth2.gossip.topics.GossipTopicName; import tech.pegasys.teku.networking.eth2.gossip.topics.OperationMilestoneValidator; import tech.pegasys.teku.networking.eth2.gossip.topics.OperationProcessor; import tech.pegasys.teku.networking.eth2.gossip.topics.topichandlers.Eth2TopicHandler; @@ -35,15 +38,18 @@ import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecarSchema; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsDeneb; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.statetransition.validation.InternalValidationResult; import tech.pegasys.teku.storage.client.RecentChainData; public class BlobSidecarGossipManager implements GossipManager { + private static final Logger LOG = LogManager.getLogger(); private final Spec spec; private final GossipNetwork gossipNetwork; private final GossipEncoding gossipEncoding; private final Int2ObjectMap> subnetIdToTopicHandler; + private final GossipFailureLogger gossipFailureLogger; private final Int2ObjectMap subnetIdToChannel = new Int2ObjectOpenHashMap<>(); @@ -54,15 +60,19 @@ public static BlobSidecarGossipManager create( final GossipNetwork gossipNetwork, final GossipEncoding gossipEncoding, final ForkInfo forkInfo, - final OperationProcessor processor) { + final OperationProcessor processor, + final DebugDataDumper debugDataDumper) { final SpecVersion forkSpecVersion = spec.atEpoch(forkInfo.getFork().getEpoch()); final BlobSidecarSchema gossipType = SchemaDefinitionsDeneb.required(forkSpecVersion.getSchemaDefinitions()) .getBlobSidecarSchema(); final Int2ObjectMap> subnetIdToTopicHandler = new Int2ObjectOpenHashMap<>(); - final SpecConfigDeneb specConfigDeneb = SpecConfigDeneb.required(forkSpecVersion.getConfig()); - IntStream.range(0, specConfigDeneb.getBlobSidecarSubnetCount()) + final int blobSidecarSubnetCount = + SpecConfigDeneb.required(spec.atEpoch(forkInfo.getFork().getEpoch()).getConfig()) + .getBlobSidecarSubnetCount(); + + IntStream.range(0, blobSidecarSubnetCount) .forEach( subnetId -> { final Eth2TopicHandler topicHandler = @@ -74,28 +84,52 @@ public static BlobSidecarGossipManager create( processor, gossipEncoding, forkInfo, - gossipType); + gossipType, + debugDataDumper); subnetIdToTopicHandler.put(subnetId, topicHandler); }); return new BlobSidecarGossipManager( - spec, gossipNetwork, gossipEncoding, subnetIdToTopicHandler); + spec, + gossipNetwork, + gossipEncoding, + subnetIdToTopicHandler, + GossipFailureLogger.createNonSuppressing("blob_sidecar")); } private BlobSidecarGossipManager( final Spec spec, final GossipNetwork gossipNetwork, final GossipEncoding gossipEncoding, - final Int2ObjectMap> subnetIdToTopicHandler) { + final Int2ObjectMap> subnetIdToTopicHandler, + final GossipFailureLogger gossipFailureLogger) { this.spec = spec; this.gossipNetwork = gossipNetwork; this.gossipEncoding = gossipEncoding; this.subnetIdToTopicHandler = subnetIdToTopicHandler; + this.gossipFailureLogger = gossipFailureLogger; } - public void publishBlobSidecar(final BlobSidecar message) { + /** + * This method is designed to return a future that only completes successfully whenever the gossip + * was succeeded (sent to at least one peer) or failed. + */ + public SafeFuture publishBlobSidecar(final BlobSidecar message) { final int subnetId = spec.computeSubnetForBlobSidecar(message).intValue(); - Optional.ofNullable(subnetIdToChannel.get(subnetId)) - .ifPresent(channel -> channel.gossip(gossipEncoding.encode(message))); + return Optional.ofNullable(subnetIdToChannel.get(subnetId)) + .map(channel -> channel.gossip(gossipEncoding.encode(message))) + .orElse(SafeFuture.failedFuture(new IllegalStateException("Gossip channel not available"))) + .handle( + (__, err) -> { + if (err != null) { + gossipFailureLogger.log(err, Optional.of(message.getSlot())); + } else { + LOG.trace( + "Successfully gossiped blob sidecar {} on {}", + () -> message.getSlotAndBlockRoot().toLogString(), + () -> subnetIdToTopicHandler.get(subnetId).getTopic()); + } + return null; + }); } @VisibleForTesting @@ -135,20 +169,22 @@ private static Eth2TopicHandler createBlobSidecarTopicHandler( final OperationProcessor processor, final GossipEncoding gossipEncoding, final ForkInfo forkInfo, - final BlobSidecarSchema gossipType) { + final BlobSidecarSchema gossipType, + final DebugDataDumper debugDataDumper) { return new Eth2TopicHandler<>( recentChainData, asyncRunner, new TopicSubnetIdAwareOperationProcessor(spec, subnetId, processor), gossipEncoding, forkInfo.getForkDigest(spec), - GossipTopicName.getBlobSidecarSubnetTopicName(subnetId), + getBlobSidecarSubnetTopicName(subnetId), new OperationMilestoneValidator<>( spec, forkInfo.getFork(), blobSidecar -> spec.computeEpochAtSlot(blobSidecar.getSlot())), gossipType, - spec.getNetworkingConfig()); + spec.getNetworkingConfig(), + debugDataDumper); } private record TopicSubnetIdAwareOperationProcessor( diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/BlockGossipChannel.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/BlockGossipChannel.java index 9c892af9219..7bfa362ff2b 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/BlockGossipChannel.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/BlockGossipChannel.java @@ -13,9 +13,10 @@ package tech.pegasys.teku.networking.eth2.gossip; -import tech.pegasys.teku.infrastructure.events.VoidReturningChannelInterface; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.events.ChannelInterface; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; -public interface BlockGossipChannel extends VoidReturningChannelInterface { - void publishBlock(SignedBeaconBlock block); +public interface BlockGossipChannel extends ChannelInterface { + SafeFuture publishBlock(SignedBeaconBlock block); } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/BlockGossipManager.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/BlockGossipManager.java index 0502c0b5df5..7865b7d1adc 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/BlockGossipManager.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/BlockGossipManager.java @@ -13,7 +13,9 @@ package tech.pegasys.teku.networking.eth2.gossip; +import java.util.Optional; import tech.pegasys.teku.infrastructure.async.AsyncRunner; +import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.networking.eth2.gossip.encoding.GossipEncoding; import tech.pegasys.teku.networking.eth2.gossip.topics.GossipTopicName; import tech.pegasys.teku.networking.eth2.gossip.topics.OperationProcessor; @@ -21,6 +23,7 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.client.RecentChainData; public class BlockGossipManager extends AbstractGossipManager { @@ -32,7 +35,8 @@ public BlockGossipManager( final GossipNetwork gossipNetwork, final GossipEncoding gossipEncoding, final ForkInfo forkInfo, - final OperationProcessor processor) { + final OperationProcessor processor, + final DebugDataDumper debugDataDumper) { super( recentChainData, GossipTopicName.BEACON_BLOCK, @@ -44,12 +48,15 @@ public BlockGossipManager( spec.atEpoch(forkInfo.getFork().getEpoch()) .getSchemaDefinitions() .getSignedBeaconBlockSchema(), + block -> Optional.of(block.getSlot()), block -> spec.computeEpochAtSlot(block.getSlot()), - spec.getNetworkingConfig()); + spec.getNetworkingConfig(), + GossipFailureLogger.createNonSuppressing(GossipTopicName.BEACON_BLOCK.toString()), + debugDataDumper); } - public void publishBlock(final SignedBeaconBlock message) { - publishMessage(message); + public SafeFuture publishBlock(final SignedBeaconBlock message) { + return publishMessageWithFeedback(message); } @Override diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/DataColumnSidecarGossipManager.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/DataColumnSidecarGossipManager.java index 289717a9ace..8c8a4ea9251 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/DataColumnSidecarGossipManager.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/DataColumnSidecarGossipManager.java @@ -24,7 +24,7 @@ public class DataColumnSidecarGossipManager implements GossipManager { public DataColumnSidecarGossipManager( final DataColumnSidecarSubnetSubscriptions dataColumnSidecarSubnetSubscriptions, - DasGossipLogger dasGossipLogger) { + final DasGossipLogger dasGossipLogger) { subnetSubscriptions = dataColumnSidecarSubnetSubscriptions; this.dasGossipLogger = dasGossipLogger; } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/GossipFailureLogger.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/GossipFailureLogger.java index 70f2eb8bce1..09479b5c5a1 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/GossipFailureLogger.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/GossipFailureLogger.java @@ -17,6 +17,7 @@ import io.libp2p.core.SemiDuplexNoOutboundStreamException; import io.libp2p.pubsub.MessageAlreadySeenException; import io.libp2p.pubsub.NoPeersForOutboundMessageException; +import java.util.Optional; import org.apache.logging.log4j.Level; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; @@ -25,12 +26,71 @@ public class GossipFailureLogger { private static final Logger LOG = LogManager.getLogger(); + private final boolean shouldSuppress; private final String messageType; - private UInt64 lastErroredSlot; + private Optional lastErroredSlot; private Throwable lastRootCause; - public GossipFailureLogger(final String messageType) { - this.messageType = messageType; + public static GossipFailureLogger createSuppressing(final String messageType) { + return new GossipFailureLogger(messageType, true); + } + + public static GossipFailureLogger createNonSuppressing(final String messageType) { + return new GossipFailureLogger(messageType, false); + } + + private GossipFailureLogger(final String messageType, final boolean shouldSuppress) { + this.messageType = shouldSuppress ? messageType + "(s)" : messageType; + this.shouldSuppress = shouldSuppress; + } + + public synchronized void log(final Throwable error, final Optional maybeSlot) { + final Throwable rootCause = Throwables.getRootCause(error); + + final boolean suppress; + + // can only try to suppress if we have a slot to compare + if (shouldSuppress && maybeSlot.isPresent()) { + suppress = + maybeSlot.equals(lastErroredSlot) + && rootCause.getClass().equals(lastRootCause.getClass()); + + } else { + suppress = false; + } + + lastErroredSlot = maybeSlot; + lastRootCause = rootCause; + + final String slotLog = maybeSlot.map(slot -> " for slot " + slot).orElse(""); + + switch (lastRootCause) { + case MessageAlreadySeenException ignored -> + LOG.debug( + "Failed to publish {}{} because the message has already been seen", + messageType, + slotLog); + case NoPeersForOutboundMessageException ignored -> + LOG.log( + suppress ? Level.DEBUG : Level.WARN, + "Failed to publish {}{}; {}", + messageType, + slotLog, + lastRootCause.getMessage()); + case SemiDuplexNoOutboundStreamException ignored -> + LOG.log( + suppress ? Level.DEBUG : Level.WARN, + "Failed to publish {}{} because no active outbound stream for the required gossip topic", + messageType, + slotLog); + default -> + LOG.log( + suppress ? Level.DEBUG : Level.ERROR, + "Failed to publish {}{}", + messageType, + slotLog, + error); + } } public void logWithSuppression(final Throwable error, final UInt64 slot) { @@ -38,14 +98,18 @@ public void logWithSuppression(final Throwable error, final UInt64 slot) { } public synchronized void logWithSuppression( - final Throwable error, final UInt64 slot, String details) { + final Throwable error, final UInt64 slot, final String details) { final String appendDetails = details.isEmpty() ? "" : ": " + details; final Throwable rootCause = Throwables.getRootCause(error); final boolean suppress = - slot.equals(lastErroredSlot) && rootCause.getClass().equals(lastRootCause.getClass()); + lastErroredSlot + .filter( + uInt64 -> + slot.equals(uInt64) && rootCause.getClass().equals(lastRootCause.getClass())) + .isPresent(); - lastErroredSlot = slot; + lastErroredSlot = Optional.of(slot); lastRootCause = rootCause; if (lastRootCause instanceof MessageAlreadySeenException) { diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/ProposerSlashingGossipManager.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/ProposerSlashingGossipManager.java index 48965957713..22b79506038 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/ProposerSlashingGossipManager.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/ProposerSlashingGossipManager.java @@ -13,6 +13,7 @@ package tech.pegasys.teku.networking.eth2.gossip; +import java.util.Optional; import tech.pegasys.teku.infrastructure.async.AsyncRunner; import tech.pegasys.teku.networking.eth2.gossip.encoding.GossipEncoding; import tech.pegasys.teku.networking.eth2.gossip.topics.GossipTopicName; @@ -21,6 +22,7 @@ import tech.pegasys.teku.spec.config.NetworkingSpecConfig; import tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.client.RecentChainData; public class ProposerSlashingGossipManager extends AbstractGossipManager { @@ -32,7 +34,8 @@ public ProposerSlashingGossipManager( final GossipEncoding gossipEncoding, final ForkInfo forkInfo, final OperationProcessor processor, - final NetworkingSpecConfig networkingConfig) { + final NetworkingSpecConfig networkingConfig, + final DebugDataDumper debugDataDumper) { super( recentChainData, GossipTopicName.PROPOSER_SLASHING, @@ -42,11 +45,14 @@ public ProposerSlashingGossipManager( forkInfo, processor, ProposerSlashing.SSZ_SCHEMA, + message -> Optional.of(message.getHeader1().getMessage().getSlot()), message -> recentChainData .getSpec() .computeEpochAtSlot(message.getHeader1().getMessage().getSlot()), - networkingConfig); + networkingConfig, + GossipFailureLogger.createNonSuppressing(GossipTopicName.PROPOSER_SLASHING.toString()), + debugDataDumper); } public void publishProposerSlashing(final ProposerSlashing message) { diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/SignedBlsToExecutionChangeGossipManager.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/SignedBlsToExecutionChangeGossipManager.java index a57b45e7bbc..454de6be327 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/SignedBlsToExecutionChangeGossipManager.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/SignedBlsToExecutionChangeGossipManager.java @@ -13,6 +13,7 @@ package tech.pegasys.teku.networking.eth2.gossip; +import java.util.Optional; import tech.pegasys.teku.infrastructure.async.AsyncRunner; import tech.pegasys.teku.networking.eth2.gossip.encoding.GossipEncoding; import tech.pegasys.teku.networking.eth2.gossip.topics.GossipTopicName; @@ -22,6 +23,7 @@ import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChange; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsCapella; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.client.RecentChainData; public class SignedBlsToExecutionChangeGossipManager @@ -35,7 +37,8 @@ public SignedBlsToExecutionChangeGossipManager( final GossipEncoding gossipEncoding, final ForkInfo forkInfo, final OperationProcessor processor, - final NetworkingSpecConfig networkingConfig) { + final NetworkingSpecConfig networkingConfig, + final DebugDataDumper debugDataDumper) { super( recentChainData, GossipTopicName.BLS_TO_EXECUTION_CHANGE, @@ -45,10 +48,13 @@ public SignedBlsToExecutionChangeGossipManager( forkInfo, processor, schemaDefinitions.getSignedBlsToExecutionChangeSchema(), + message -> Optional.empty(), // BLS changes don't have a fork they apply to so are always considered to match the fork // of the topic they arrived on (ie disable fork checking at this level) message -> forkInfo.getFork().getEpoch(), - networkingConfig); + networkingConfig, + GossipFailureLogger.createSuppressing(GossipTopicName.BLS_TO_EXECUTION_CHANGE.toString()), + debugDataDumper); } public void publish(final SignedBlsToExecutionChange message) { diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/SignedContributionAndProofGossipManager.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/SignedContributionAndProofGossipManager.java index aaedb081eed..7f79b999d29 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/SignedContributionAndProofGossipManager.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/SignedContributionAndProofGossipManager.java @@ -13,6 +13,7 @@ package tech.pegasys.teku.networking.eth2.gossip; +import java.util.Optional; import tech.pegasys.teku.infrastructure.async.AsyncRunner; import tech.pegasys.teku.networking.eth2.gossip.encoding.GossipEncoding; import tech.pegasys.teku.networking.eth2.gossip.topics.GossipTopicName; @@ -22,6 +23,7 @@ import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SignedContributionAndProof; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsAltair; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.client.RecentChainData; public class SignedContributionAndProofGossipManager @@ -35,7 +37,8 @@ public SignedContributionAndProofGossipManager( final GossipEncoding gossipEncoding, final ForkInfo forkInfo, final OperationProcessor processor, - final NetworkingSpecConfig networkingConfig) { + final NetworkingSpecConfig networkingConfig, + final DebugDataDumper debugDataDumper) { super( recentChainData, GossipTopicName.SYNC_COMMITTEE_CONTRIBUTION_AND_PROOF, @@ -45,11 +48,15 @@ public SignedContributionAndProofGossipManager( forkInfo, processor, schemaDefinitions.getSignedContributionAndProofSchema(), + message -> Optional.of(message.getMessage().getContribution().getSlot()), message -> recentChainData .getSpec() .computeEpochAtSlot(message.getMessage().getContribution().getSlot()), - networkingConfig); + networkingConfig, + GossipFailureLogger.createSuppressing( + GossipTopicName.SYNC_COMMITTEE_CONTRIBUTION_AND_PROOF.toString()), + debugDataDumper); } public void publishContribution(final SignedContributionAndProof message) { diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/SyncCommitteeMessageGossipManager.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/SyncCommitteeMessageGossipManager.java index 3c1692e90dc..dd1568dee55 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/SyncCommitteeMessageGossipManager.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/SyncCommitteeMessageGossipManager.java @@ -39,7 +39,7 @@ public class SyncCommitteeMessageGossipManager implements GossipManager { private final Counter publishFailureCounter; private final GossipFailureLogger gossipFailureLogger = - new GossipFailureLogger("sync committee message"); + GossipFailureLogger.createSuppressing("sync_committee_message"); public SyncCommitteeMessageGossipManager( final MetricsSystem metricsSystem, @@ -109,18 +109,18 @@ private void publish(final SyncCommitteeMessage message, final int subnetId) { publishSuccessCounter.inc(); }, error -> { - gossipFailureLogger.logWithSuppression(error, message.getSlot()); + gossipFailureLogger.log(error, Optional.of(message.getSlot())); publishFailureCounter.inc(); }); } public void subscribeToSubnetId(final int subnetId) { - LOG.trace("Subscribing to subnet ID {}", subnetId); + LOG.trace("Subscribing to sync committee subnet {}", subnetId); subnetSubscriptions.subscribeToSubnetId(subnetId); } public void unsubscribeFromSubnetId(final int subnetId) { - LOG.trace("Unsubscribing to subnet ID {}", subnetId); + LOG.trace("Unsubscribing to sync committee subnet {}", subnetId); subnetSubscriptions.unsubscribeFromSubnetId(subnetId); } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/VoluntaryExitGossipManager.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/VoluntaryExitGossipManager.java index 4bcb2da4863..1e822443e25 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/VoluntaryExitGossipManager.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/VoluntaryExitGossipManager.java @@ -13,6 +13,7 @@ package tech.pegasys.teku.networking.eth2.gossip; +import java.util.Optional; import tech.pegasys.teku.infrastructure.async.AsyncRunner; import tech.pegasys.teku.networking.eth2.gossip.encoding.GossipEncoding; import tech.pegasys.teku.networking.eth2.gossip.topics.GossipTopicName; @@ -21,6 +22,7 @@ import tech.pegasys.teku.spec.config.NetworkingSpecConfig; import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.client.RecentChainData; public class VoluntaryExitGossipManager extends AbstractGossipManager { @@ -32,7 +34,8 @@ public VoluntaryExitGossipManager( final GossipEncoding gossipEncoding, final ForkInfo forkInfo, final OperationProcessor processor, - final NetworkingSpecConfig networkingConfig) { + final NetworkingSpecConfig networkingConfig, + final DebugDataDumper debugDataDumper) { super( recentChainData, GossipTopicName.VOLUNTARY_EXIT, @@ -42,8 +45,11 @@ public VoluntaryExitGossipManager( forkInfo, processor, SignedVoluntaryExit.SSZ_SCHEMA, + exit -> Optional.empty(), exit -> exit.getMessage().getEpoch(), - networkingConfig); + networkingConfig, + GossipFailureLogger.createNonSuppressing(GossipTopicName.VOLUNTARY_EXIT.toString()), + debugDataDumper); } public void publishVoluntaryExit(final SignedVoluntaryExit message) { diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/config/GossipConfigurator.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/config/GossipConfigurator.java index f8510edd2d8..48c5f3997bf 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/config/GossipConfigurator.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/config/GossipConfigurator.java @@ -35,7 +35,7 @@ public void configureDynamicTopics( final Eth2Context eth2Context) {} }; - static GossipConfigurator scoringEnabled(Spec spec) { + static GossipConfigurator scoringEnabled(final Spec spec) { return new GossipScoringConfigurator(spec); } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/encoding/SszSnappyEncoding.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/encoding/SszSnappyEncoding.java index 7280afe9108..e9fa486cd0a 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/encoding/SszSnappyEncoding.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/encoding/SszSnappyEncoding.java @@ -39,8 +39,8 @@ public Bytes encode(final T value) { } @Override - public T decodeMessage(PreparedGossipMessage message, SszSchema valueType) - throws DecodingException { + public T decodeMessage( + final PreparedGossipMessage message, final SszSchema valueType) throws DecodingException { try { return sszCodec.decode(message.getDecodedMessage().getDecodedMessageOrElseThrow(), valueType); } catch (GossipDecodingException e) { @@ -50,7 +50,7 @@ public T decodeMessage(PreparedGossipMessage message, SszSch @Override public Eth2PreparedGossipMessageFactory createPreparedGossipMessageFactory( - ForkDigestToMilestone forkDigestToMilestone) { + final ForkDigestToMilestone forkDigestToMilestone) { return new SnappyPreparedGossipMessageFactory(snappyCompressor, forkDigestToMilestone); } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/GossipForkManager.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/GossipForkManager.java index 99229b78a62..d226d580cd4 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/GossipForkManager.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/GossipForkManager.java @@ -26,12 +26,14 @@ import java.util.Set; import java.util.TreeMap; import java.util.function.BiConsumer; +import java.util.function.BiFunction; import java.util.stream.Collectors; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; -import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSidecar; @@ -57,7 +59,7 @@ public class GossipForkManager { private static final Logger LOG = LogManager.getLogger(); private static final int EPOCHS_PRIOR_TO_FORK_TO_ACTIVATE = 2; private final Spec spec; - private final Bytes32 genesisValidatorsRoot; + private final RecentChainData recentChainData; private final NavigableMap forksByActivationEpoch; private final Set activeSubscriptions = new HashSet<>(); private final IntSet currentAttestationSubnets = new IntOpenHashSet(); @@ -69,13 +71,12 @@ public class GossipForkManager { private GossipForkManager( final Spec spec, - final Bytes32 genesisValidatorsRoot, - final boolean isHeadOptimistic, + final RecentChainData recentChainData, final NavigableMap forksByActivationEpoch) { this.spec = spec; - this.genesisValidatorsRoot = genesisValidatorsRoot; - this.isHeadOptimistic = isHeadOptimistic; + this.recentChainData = recentChainData; this.forksByActivationEpoch = forksByActivationEpoch; + this.isHeadOptimistic = recentChainData.isChainHeadOptimistic(); } public static GossipForkManager.Builder builder() { @@ -151,11 +152,14 @@ public synchronized void onOptimisticHeadChanged(final boolean isHeadOptimistic) activeSubscriptions.forEach(GossipForkSubscriptions::stopGossipForOptimisticSync); } else { activeSubscriptions.forEach( - subscriptions -> subscriptions.startGossip(genesisValidatorsRoot, false)); + subscriptions -> + subscriptions.startGossip( + recentChainData.getGenesisData().orElseThrow().getGenesisValidatorsRoot(), + false)); } } - public synchronized void publishAttestation(final ValidatableAttestation attestation) { + public void publishAttestation(final ValidatableAttestation attestation) { publishMessage( attestation.getData().getSlot(), attestation, @@ -163,12 +167,13 @@ public synchronized void publishAttestation(final ValidatableAttestation attesta GossipForkSubscriptions::publishAttestation); } - public synchronized void publishBlock(final SignedBeaconBlock block) { - publishMessage(block.getSlot(), block, "block", GossipForkSubscriptions::publishBlock); + public SafeFuture publishBlock(final SignedBeaconBlock block) { + return publishMessageWithFeedback( + block.getSlot(), block, "block", GossipForkSubscriptions::publishBlock); } - public synchronized void publishBlobSidecar(final BlobSidecar blobSidecar) { - publishMessage( + public SafeFuture publishBlobSidecar(final BlobSidecar blobSidecar) { + return publishMessageWithFeedback( blobSidecar.getSlot(), blobSidecar, "blob sidecar", @@ -183,8 +188,7 @@ public synchronized void publishDataColumnSidecar(final DataColumnSidecar dataCo GossipForkSubscriptions::publishDataColumnSidecar); } - public synchronized void publishSyncCommitteeMessage( - final ValidatableSyncCommitteeMessage message) { + public void publishSyncCommitteeMessage(final ValidatableSyncCommitteeMessage message) { publishMessage( message.getSlot(), message, @@ -217,11 +221,17 @@ public void publishAttesterSlashing(final AttesterSlashing message) { } public void publishVoluntaryExit(final SignedVoluntaryExit message) { + final SpecMilestone currentMilestone = + spec.atEpoch(spec.getCurrentEpoch(recentChainData.getStore())).getMilestone(); + final UInt64 publishingSlot; + if (currentMilestone.isGreaterThanOrEqualTo(SpecMilestone.CAPELLA)) { + publishingSlot = + spec.computeStartSlotAtEpoch(spec.getCurrentEpoch(recentChainData.getStore())); + } else { + publishingSlot = spec.computeStartSlotAtEpoch(message.getMessage().getEpoch()); + } publishMessage( - spec.computeStartSlotAtEpoch(message.getMessage().getEpoch()), - message, - "voluntary exit", - GossipForkSubscriptions::publishVoluntaryExit); + publishingSlot, message, "voluntary exit", GossipForkSubscriptions::publishVoluntaryExit); } public void publishSignedBlsToExecutionChanges(final SignedBlsToExecutionChange message) { @@ -232,15 +242,7 @@ public void publishSignedBlsToExecutionChanges(final SignedBlsToExecutionChange GossipForkSubscriptions::publishSignedBlsToExecutionChangeMessage); } - public synchronized void publishDataColumnSidecarMessage(final DataColumnSidecar message) { - publishMessage( - message.getSlot(), - message, - "data column sidecar message", - GossipForkSubscriptions::publishDataColumnSidecar); - } - - private void publishMessage( + private synchronized void publishMessage( final UInt64 slot, final T message, final String type, @@ -256,6 +258,23 @@ private void publishMessage( slot)); } + private synchronized SafeFuture publishMessageWithFeedback( + final UInt64 slot, + final T message, + final String type, + final BiFunction> publisher) { + final Optional gossipForkSubscriptions = + getSubscriptionActiveAtSlot(slot).filter(this::isActive); + + if (gossipForkSubscriptions.isEmpty()) { + LOG.warn( + "Not publishing {} because no gossip subscriptions are active for slot {}", type, slot); + return SafeFuture.COMPLETE; + } + + return publisher.apply(gossipForkSubscriptions.get(), message); + } + public synchronized void subscribeToAttestationSubnetId(final int subnetId) { if (currentAttestationSubnets.add(subnetId)) { activeSubscriptions.forEach( @@ -263,21 +282,21 @@ public synchronized void subscribeToAttestationSubnetId(final int subnetId) { } } - public void unsubscribeFromAttestationSubnetId(final int subnetId) { + public synchronized void unsubscribeFromAttestationSubnetId(final int subnetId) { if (currentAttestationSubnets.remove(subnetId)) { activeSubscriptions.forEach( subscription -> subscription.unsubscribeFromAttestationSubnetId(subnetId)); } } - public void subscribeToSyncCommitteeSubnetId(final int subnetId) { + public synchronized void subscribeToSyncCommitteeSubnetId(final int subnetId) { if (currentSyncCommitteeSubnets.add(subnetId)) { activeSubscriptions.forEach( subscription -> subscription.subscribeToSyncCommitteeSubnet(subnetId)); } } - public void unsubscribeFromSyncCommitteeSubnetId(final int subnetId) { + public synchronized void unsubscribeFromSyncCommitteeSubnetId(final int subnetId) { if (currentSyncCommitteeSubnets.remove(subnetId)) { activeSubscriptions.forEach( subscription -> subscription.unsubscribeFromSyncCommitteeSubnet(subnetId)); @@ -304,7 +323,9 @@ private boolean isActive(final GossipForkSubscriptions subscriptions) { private void startSubscriptions(final GossipForkSubscriptions subscription) { if (activeSubscriptions.add(subscription)) { - subscription.startGossip(genesisValidatorsRoot, isHeadOptimistic); + subscription.startGossip( + recentChainData.getGenesisData().orElseThrow().getGenesisValidatorsRoot(), + isHeadOptimistic); currentAttestationSubnets.forEach(subscription::subscribeToAttestationSubnetId); currentSyncCommitteeSubnets.forEach(subscription::subscribeToSyncCommitteeSubnet); currentDataColumnSidecarSubnets.forEach(subscription::subscribeToDataColumnSidecarSubnet); @@ -345,9 +366,16 @@ public Builder recentChainData(final RecentChainData recentChainData) { public Builder fork(final GossipForkSubscriptions forkSubscriptions) { final UInt64 activationEpoch = forkSubscriptions.getActivationEpoch(); - checkState( - !forksByActivationEpoch.containsKey(activationEpoch), - "Can not schedule two forks to activate at the same epoch"); + final GossipForkSubscriptions removed = forksByActivationEpoch.remove(activationEpoch); + if (removed != null) { + LOG.info( + "Fork {} removed for gossip schedule as {} starts at the same epoch", + removed, + forkSubscriptions); + } + // TODO: Refactor, we are by epoch here, all good, but we are not sure which main fork is it + // topics are by hard fork digests so we need to continue tracking it + // but it would be good if it is separately forksByActivationEpoch.put(activationEpoch, forkSubscriptions); return this; } @@ -356,11 +384,7 @@ public GossipForkManager build() { checkNotNull(spec, "Must supply spec"); checkNotNull(recentChainData, "Must supply recentChainData"); checkState(!forksByActivationEpoch.isEmpty(), "Must specify at least one fork"); - return new GossipForkManager( - spec, - recentChainData.getGenesisData().orElseThrow().getGenesisValidatorsRoot(), - recentChainData.isChainHeadOptimistic(), - forksByActivationEpoch); + return new GossipForkManager(spec, recentChainData, forksByActivationEpoch); } } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/GossipForkSubscriptions.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/GossipForkSubscriptions.java index e8b5e84516f..9da3e3b856c 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/GossipForkSubscriptions.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/GossipForkSubscriptions.java @@ -14,6 +14,7 @@ package tech.pegasys.teku.networking.eth2.gossip.forks; import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; @@ -38,21 +39,21 @@ public interface GossipForkSubscriptions { void publishAttestation(ValidatableAttestation attestation); - void publishBlock(SignedBeaconBlock block); + SafeFuture publishBlock(SignedBeaconBlock block); - default void publishBlobSidecar(BlobSidecar blobSidecar) { - // since Deneb + default SafeFuture publishBlobSidecar(final BlobSidecar blobSidecar) { + return SafeFuture.COMPLETE; } void subscribeToAttestationSubnetId(int subnetId); void unsubscribeFromAttestationSubnetId(int subnetId); - default void publishSyncCommitteeMessage(ValidatableSyncCommitteeMessage message) { + default void publishSyncCommitteeMessage(final ValidatableSyncCommitteeMessage message) { // since Altair } - default void publishSyncCommitteeContribution(SignedContributionAndProof message) { + default void publishSyncCommitteeContribution(final SignedContributionAndProof message) { // since Altair } @@ -62,25 +63,25 @@ default void publishSyncCommitteeContribution(SignedContributionAndProof message void publishVoluntaryExit(SignedVoluntaryExit message); - default void subscribeToSyncCommitteeSubnet(int subnetId) { + default void subscribeToSyncCommitteeSubnet(final int subnetId) { // since Altair } - default void unsubscribeFromSyncCommitteeSubnet(int subnetId) { + default void unsubscribeFromSyncCommitteeSubnet(final int subnetId) { // since Altair } - default void publishSignedBlsToExecutionChangeMessage(SignedBlsToExecutionChange message) {} + default void publishSignedBlsToExecutionChangeMessage(final SignedBlsToExecutionChange message) {} - default void publishDataColumnSidecar(DataColumnSidecar blobSidecar) { + default void publishDataColumnSidecar(final DataColumnSidecar blobSidecar) { // since EIP7594 } - default void subscribeToDataColumnSidecarSubnet(int subnetId) { + default void subscribeToDataColumnSidecarSubnet(final int subnetId) { // since EIP7594 } - default void unsubscribeFromDataColumnSidecarSubnet(int subnetId) { + default void unsubscribeFromDataColumnSidecarSubnet(final int subnetId) { // since EIP7594 } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsAltair.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsAltair.java index aa7a0a4a082..018f97ef9ed 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsAltair.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsAltair.java @@ -34,6 +34,7 @@ import tech.pegasys.teku.spec.datastructures.state.ForkInfo; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsAltair; import tech.pegasys.teku.statetransition.synccommittee.SyncCommitteeStateUtils; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.client.RecentChainData; public class GossipForkSubscriptionsAltair extends GossipForkSubscriptionsPhase0 { @@ -62,7 +63,8 @@ public GossipForkSubscriptionsAltair( final OperationProcessor signedContributionAndProofOperationProcessor, final OperationProcessor - syncCommitteeMessageOperationProcessor) { + syncCommitteeMessageOperationProcessor, + final DebugDataDumper debugDataDumper) { super( fork, spec, @@ -76,7 +78,8 @@ public GossipForkSubscriptionsAltair( aggregateProcessor, attesterSlashingProcessor, proposerSlashingProcessor, - voluntaryExitProcessor); + voluntaryExitProcessor, + debugDataDumper); this.signedContributionAndProofOperationProcessor = signedContributionAndProofOperationProcessor; this.syncCommitteeMessageOperationProcessor = syncCommitteeMessageOperationProcessor; @@ -95,7 +98,8 @@ void addSignedContributionAndProofGossipManager(final ForkInfo forkInfo) { gossipEncoding, forkInfo, signedContributionAndProofOperationProcessor, - specConfig.getNetworkingConfig()); + specConfig.getNetworkingConfig(), + debugDataDumper); addGossipManager(syncCommitteeContributionGossipManager); } @@ -111,7 +115,8 @@ void addSyncCommitteeMessageGossipManager(final ForkInfo forkInfo) { schemaDefinitions, asyncRunner, syncCommitteeMessageOperationProcessor, - forkInfo); + forkInfo, + debugDataDumper); syncCommitteeMessageGossipManager = new SyncCommitteeMessageGossipManager( metricsSystem, diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsBellatrix.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsBellatrix.java index 8ec2f8d46b4..f7ebdbba8c7 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsBellatrix.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsBellatrix.java @@ -27,6 +27,7 @@ import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SignedContributionAndProof; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.ValidatableSyncCommitteeMessage; import tech.pegasys.teku.spec.datastructures.state.Fork; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.client.RecentChainData; public class GossipForkSubscriptionsBellatrix extends GossipForkSubscriptionsAltair { @@ -48,7 +49,8 @@ public GossipForkSubscriptionsBellatrix( final OperationProcessor signedContributionAndProofOperationProcessor, final OperationProcessor - syncCommitteeMessageOperationProcessor) { + syncCommitteeMessageOperationProcessor, + final DebugDataDumper debugDataDumper) { super( fork, spec, @@ -64,6 +66,7 @@ public GossipForkSubscriptionsBellatrix( proposerSlashingProcessor, voluntaryExitProcessor, signedContributionAndProofOperationProcessor, - syncCommitteeMessageOperationProcessor); + syncCommitteeMessageOperationProcessor, + debugDataDumper); } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsCapella.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsCapella.java index ea6eea41786..38ffb2ea1ee 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsCapella.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsCapella.java @@ -33,6 +33,7 @@ import tech.pegasys.teku.spec.datastructures.state.Fork; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsCapella; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.client.RecentChainData; public class GossipForkSubscriptionsCapella extends GossipForkSubscriptionsBellatrix { @@ -61,7 +62,8 @@ public GossipForkSubscriptionsCapella( final OperationProcessor syncCommitteeMessageOperationProcessor, final OperationProcessor - signedBlsToExecutionChangeOperationProcessor) { + signedBlsToExecutionChangeOperationProcessor, + final DebugDataDumper debugDataDumper) { super( fork, spec, @@ -77,7 +79,8 @@ public GossipForkSubscriptionsCapella( proposerSlashingProcessor, voluntaryExitProcessor, signedContributionAndProofOperationProcessor, - syncCommitteeMessageOperationProcessor); + syncCommitteeMessageOperationProcessor, + debugDataDumper); this.signedBlsToExecutionChangeOperationProcessor = signedBlsToExecutionChangeOperationProcessor; @@ -97,7 +100,8 @@ void addSignedBlsToExecutionChangeGossipManager(final ForkInfo forkInfo) { gossipEncoding, forkInfo, signedBlsToExecutionChangeOperationProcessor, - spec.getNetworkingConfig()); + spec.getNetworkingConfig(), + debugDataDumper); addGossipManager(gossipManager); this.signedBlsToExecutionChangeGossipManager = Optional.of(gossipManager); diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsDeneb.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsDeneb.java index 5b6b3ac71e4..7c91003db04 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsDeneb.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsDeneb.java @@ -15,6 +15,7 @@ import org.hyperledger.besu.plugin.services.MetricsSystem; import tech.pegasys.teku.infrastructure.async.AsyncRunner; +import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.networking.eth2.gossip.BlobSidecarGossipManager; import tech.pegasys.teku.networking.eth2.gossip.encoding.GossipEncoding; import tech.pegasys.teku.networking.eth2.gossip.topics.OperationProcessor; @@ -31,6 +32,7 @@ import tech.pegasys.teku.spec.datastructures.operations.versions.altair.ValidatableSyncCommitteeMessage; import tech.pegasys.teku.spec.datastructures.state.Fork; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.client.RecentChainData; public class GossipForkSubscriptionsDeneb extends GossipForkSubscriptionsCapella { @@ -59,7 +61,8 @@ public GossipForkSubscriptionsDeneb( final OperationProcessor syncCommitteeMessageOperationProcessor, final OperationProcessor - signedBlsToExecutionChangeOperationProcessor) { + signedBlsToExecutionChangeOperationProcessor, + final DebugDataDumper debugDataDumper) { super( fork, spec, @@ -76,7 +79,8 @@ public GossipForkSubscriptionsDeneb( voluntaryExitProcessor, signedContributionAndProofOperationProcessor, syncCommitteeMessageOperationProcessor, - signedBlsToExecutionChangeOperationProcessor); + signedBlsToExecutionChangeOperationProcessor, + debugDataDumper); this.blobSidecarProcessor = blobSidecarProcessor; } @@ -95,12 +99,13 @@ void addBlobSidecarGossipManager(final ForkInfo forkInfo) { discoveryNetwork, gossipEncoding, forkInfo, - blobSidecarProcessor); + blobSidecarProcessor, + debugDataDumper); addGossipManager(blobSidecarGossipManager); } @Override - public void publishBlobSidecar(final BlobSidecar blobSidecar) { - blobSidecarGossipManager.publishBlobSidecar(blobSidecar); + public SafeFuture publishBlobSidecar(final BlobSidecar blobSidecar) { + return blobSidecarGossipManager.publishBlobSidecar(blobSidecar); } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsElectra.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsElectra.java new file mode 100644 index 00000000000..1c8e81d2b94 --- /dev/null +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsElectra.java @@ -0,0 +1,79 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.networking.eth2.gossip.forks.versions; + +import org.hyperledger.besu.plugin.services.MetricsSystem; +import tech.pegasys.teku.infrastructure.async.AsyncRunner; +import tech.pegasys.teku.networking.eth2.gossip.encoding.GossipEncoding; +import tech.pegasys.teku.networking.eth2.gossip.topics.OperationProcessor; +import tech.pegasys.teku.networking.p2p.discovery.DiscoveryNetwork; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; +import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; +import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; +import tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing; +import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChange; +import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; +import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SignedContributionAndProof; +import tech.pegasys.teku.spec.datastructures.operations.versions.altair.ValidatableSyncCommitteeMessage; +import tech.pegasys.teku.spec.datastructures.state.Fork; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; +import tech.pegasys.teku.storage.client.RecentChainData; + +public class GossipForkSubscriptionsElectra extends GossipForkSubscriptionsDeneb { + + public GossipForkSubscriptionsElectra( + final Fork fork, + final Spec spec, + final AsyncRunner asyncRunner, + final MetricsSystem metricsSystem, + final DiscoveryNetwork discoveryNetwork, + final RecentChainData recentChainData, + final GossipEncoding gossipEncoding, + final OperationProcessor blockProcessor, + final OperationProcessor blobSidecarProcessor, + final OperationProcessor attestationProcessor, + final OperationProcessor aggregateProcessor, + final OperationProcessor attesterSlashingProcessor, + final OperationProcessor proposerSlashingProcessor, + final OperationProcessor voluntaryExitProcessor, + final OperationProcessor + signedContributionAndProofOperationProcessor, + final OperationProcessor + syncCommitteeMessageOperationProcessor, + final OperationProcessor + signedBlsToExecutionChangeOperationProcessor, + final DebugDataDumper debugDataDumper) { + super( + fork, + spec, + asyncRunner, + metricsSystem, + discoveryNetwork, + recentChainData, + gossipEncoding, + blockProcessor, + blobSidecarProcessor, + attestationProcessor, + aggregateProcessor, + attesterSlashingProcessor, + proposerSlashingProcessor, + voluntaryExitProcessor, + signedContributionAndProofOperationProcessor, + syncCommitteeMessageOperationProcessor, + signedBlsToExecutionChangeOperationProcessor, + debugDataDumper); + } +} diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsEip7594.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsElectraEip7594.java similarity index 76% rename from networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsEip7594.java rename to networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsElectraEip7594.java index cd44bbb0a53..c5e50641b5d 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsEip7594.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsElectraEip7594.java @@ -15,6 +15,7 @@ import org.hyperledger.besu.plugin.services.MetricsSystem; import tech.pegasys.teku.infrastructure.async.AsyncRunner; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.networking.eth2.gossip.DataColumnSidecarGossipManager; import tech.pegasys.teku.networking.eth2.gossip.encoding.GossipEncoding; import tech.pegasys.teku.networking.eth2.gossip.subnets.DataColumnSidecarSubnetSubscriptions; @@ -33,16 +34,22 @@ import tech.pegasys.teku.spec.datastructures.state.Fork; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; import tech.pegasys.teku.statetransition.datacolumns.log.gossip.DasGossipLogger; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.client.RecentChainData; -public class GossipForkSubscriptionsEip7594 extends GossipForkSubscriptionsCapella { +// Capella because we don't need blobSidecar subscriptions +public class GossipForkSubscriptionsElectraEip7594 extends GossipForkSubscriptionsCapella { private final OperationProcessor dataColumnSidecarOperationProcessor; + private final UInt64 eip7594ActivationEpoch; + private final UInt64 eip7594EndEpoch; private DataColumnSidecarGossipManager dataColumnSidecarGossipManager; public DasGossipLogger dasGossipLogger; - public GossipForkSubscriptionsEip7594( + public GossipForkSubscriptionsElectraEip7594( final Fork fork, + final UInt64 eip7594ActivationEpoch, + final UInt64 eip7594EndEpoch, final Spec spec, final AsyncRunner asyncRunner, final MetricsSystem metricsSystem, @@ -61,8 +68,9 @@ public GossipForkSubscriptionsEip7594( syncCommitteeMessageOperationProcessor, final OperationProcessor signedBlsToExecutionChangeOperationProcessor, + final DebugDataDumper debugDataDumper, final OperationProcessor dataColumnSidecarOperationProcessor, - DasGossipLogger dasGossipLogger) { + final DasGossipLogger dasGossipLogger) { super( fork, spec, @@ -79,19 +87,27 @@ public GossipForkSubscriptionsEip7594( voluntaryExitProcessor, signedContributionAndProofOperationProcessor, syncCommitteeMessageOperationProcessor, - signedBlsToExecutionChangeOperationProcessor); + signedBlsToExecutionChangeOperationProcessor, + debugDataDumper); this.dataColumnSidecarOperationProcessor = dataColumnSidecarOperationProcessor; + this.eip7594ActivationEpoch = eip7594ActivationEpoch; + this.eip7594EndEpoch = eip7594EndEpoch; this.dasGossipLogger = dasGossipLogger; } @Override - protected void addGossipManagers(ForkInfo forkInfo) { - super.addGossipManagers(forkInfo); + public UInt64 getActivationEpoch() { + return eip7594ActivationEpoch; + } - addDataColumnSidecarGossipManager(forkInfo); + @Override + protected void addGossipManagers(final ForkInfo forkInfo) { + super.addGossipManagers(forkInfo); + addDataColumnSidecarGossipManager(forkInfo, eip7594ActivationEpoch, eip7594EndEpoch); } - void addDataColumnSidecarGossipManager(final ForkInfo forkInfo) { + void addDataColumnSidecarGossipManager( + final ForkInfo forkInfo, final UInt64 startEpoch, final UInt64 endEpoch) { DataColumnSidecarSubnetSubscriptions dataColumnSidecarSubnetSubscriptions = new DataColumnSidecarSubnetSubscriptions( spec, @@ -100,26 +116,29 @@ void addDataColumnSidecarGossipManager(final ForkInfo forkInfo) { gossipEncoding, recentChainData, dataColumnSidecarOperationProcessor, - forkInfo); + debugDataDumper, + forkInfo, + startEpoch, + endEpoch); - dataColumnSidecarGossipManager = + this.dataColumnSidecarGossipManager = new DataColumnSidecarGossipManager(dataColumnSidecarSubnetSubscriptions, dasGossipLogger); addGossipManager(dataColumnSidecarGossipManager); } @Override - public void publishDataColumnSidecar(DataColumnSidecar blobSidecar) { + public void publishDataColumnSidecar(final DataColumnSidecar blobSidecar) { dataColumnSidecarGossipManager.publish(blobSidecar); } @Override - public void subscribeToDataColumnSidecarSubnet(int subnetId) { + public void subscribeToDataColumnSidecarSubnet(final int subnetId) { dataColumnSidecarGossipManager.subscribeToSubnetId(subnetId); } @Override - public void unsubscribeFromDataColumnSidecarSubnet(int subnetId) { + public void unsubscribeFromDataColumnSidecarSubnet(final int subnetId) { dataColumnSidecarGossipManager.unsubscribeFromSubnetId(subnetId); } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsPhase0.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsPhase0.java index 8758eed7d3a..e26cf4aecc8 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsPhase0.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsPhase0.java @@ -13,11 +13,13 @@ package tech.pegasys.teku.networking.eth2.gossip.forks.versions; +import com.google.common.base.MoreObjects; import java.util.ArrayList; import java.util.List; import org.apache.tuweni.bytes.Bytes32; import org.hyperledger.besu.plugin.services.MetricsSystem; import tech.pegasys.teku.infrastructure.async.AsyncRunner; +import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.networking.eth2.gossip.AggregateGossipManager; import tech.pegasys.teku.networking.eth2.gossip.AttestationGossipManager; @@ -39,6 +41,7 @@ import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; import tech.pegasys.teku.spec.datastructures.state.Fork; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.client.RecentChainData; public class GossipForkSubscriptionsPhase0 implements GossipForkSubscriptions { @@ -65,6 +68,7 @@ public class GossipForkSubscriptionsPhase0 implements GossipForkSubscriptions { private VoluntaryExitGossipManager voluntaryExitGossipManager; private ProposerSlashingGossipManager proposerSlashingGossipManager; private AttesterSlashingGossipManager attesterSlashingGossipManager; + protected DebugDataDumper debugDataDumper; public GossipForkSubscriptionsPhase0( final Fork fork, @@ -79,7 +83,8 @@ public GossipForkSubscriptionsPhase0( final OperationProcessor aggregateProcessor, final OperationProcessor attesterSlashingProcessor, final OperationProcessor proposerSlashingProcessor, - final OperationProcessor voluntaryExitProcessor) { + final OperationProcessor voluntaryExitProcessor, + final DebugDataDumper debugDataDumper) { this.fork = fork; this.spec = spec; this.asyncRunner = asyncRunner; @@ -93,6 +98,7 @@ public GossipForkSubscriptionsPhase0( this.attesterSlashingProcessor = attesterSlashingProcessor; this.proposerSlashingProcessor = proposerSlashingProcessor; this.voluntaryExitProcessor = voluntaryExitProcessor; + this.debugDataDumper = debugDataDumper; } @Override @@ -121,7 +127,8 @@ void addAttestationGossipManager(final ForkInfo forkInfo) { gossipEncoding, recentChainData, attestationProcessor, - forkInfo); + forkInfo, + debugDataDumper); attestationGossipManager = new AttestationGossipManager(metricsSystem, attestationSubnetSubscriptions); @@ -137,7 +144,8 @@ void addBlockGossipManager(final ForkInfo forkInfo) { discoveryNetwork, gossipEncoding, forkInfo, - blockProcessor); + blockProcessor, + debugDataDumper); addGossipManager(blockGossipManager); } @@ -150,7 +158,8 @@ void addAggregateGossipManager(final ForkInfo forkInfo) { discoveryNetwork, gossipEncoding, forkInfo, - aggregateProcessor); + aggregateProcessor, + debugDataDumper); addGossipManager(aggregateGossipManager); } @@ -163,7 +172,8 @@ void addVoluntaryExitGossipManager(final ForkInfo forkInfo) { gossipEncoding, forkInfo, voluntaryExitProcessor, - spec.getNetworkingConfig()); + spec.getNetworkingConfig(), + debugDataDumper); addGossipManager(voluntaryExitGossipManager); } @@ -176,7 +186,8 @@ void addProposerSlashingGossipManager(final ForkInfo forkInfo) { gossipEncoding, forkInfo, proposerSlashingProcessor, - spec.getNetworkingConfig()); + spec.getNetworkingConfig(), + debugDataDumper); addGossipManager(proposerSlashingGossipManager); } @@ -189,7 +200,8 @@ void addAttesterSlashingGossipManager(final ForkInfo forkInfo) { discoveryNetwork, gossipEncoding, forkInfo, - attesterSlashingProcessor); + attesterSlashingProcessor, + debugDataDumper); addGossipManager(attesterSlashingGossipManager); } @@ -225,8 +237,8 @@ public void publishAttestation(final ValidatableAttestation attestation) { } @Override - public void publishBlock(final SignedBeaconBlock block) { - blockGossipManager.publishBlock(block); + public SafeFuture publishBlock(final SignedBeaconBlock block) { + return blockGossipManager.publishBlock(block); } @Override @@ -253,4 +265,12 @@ public void subscribeToAttestationSubnetId(final int subnetId) { public void unsubscribeFromAttestationSubnetId(final int subnetId) { attestationGossipManager.unsubscribeFromSubnetId(subnetId); } + + @Override + public String toString() { + return MoreObjects.toStringHelper(this) + .add("fork", fork) + .add("activationEpoch", getActivationEpoch()) + .toString(); + } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/AttestationSubnetSubscriptions.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/AttestationSubnetSubscriptions.java index 79d47422724..de1231d38c0 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/AttestationSubnetSubscriptions.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/AttestationSubnetSubscriptions.java @@ -28,8 +28,9 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.client.RecentChainData; public class AttestationSubnetSubscriptions extends CommitteeSubnetSubscriptions { @@ -39,7 +40,8 @@ public class AttestationSubnetSubscriptions extends CommitteeSubnetSubscriptions private final RecentChainData recentChainData; private final OperationProcessor processor; private final ForkInfo forkInfo; - private final AttestationSchema attestationSchema; + private final AttestationSchema attestationSchema; + private final DebugDataDumper debugDataDumper; public AttestationSubnetSubscriptions( final Spec spec, @@ -48,7 +50,8 @@ public AttestationSubnetSubscriptions( final GossipEncoding gossipEncoding, final RecentChainData recentChainData, final OperationProcessor processor, - final ForkInfo forkInfo) { + final ForkInfo forkInfo, + final DebugDataDumper debugDataDumper) { super(gossipNetwork, gossipEncoding); this.spec = spec; this.asyncRunner = asyncRunner; @@ -57,6 +60,7 @@ public AttestationSubnetSubscriptions( this.forkInfo = forkInfo; attestationSchema = spec.atEpoch(forkInfo.getFork().getEpoch()).getSchemaDefinitions().getAttestationSchema(); + this.debugDataDumper = debugDataDumper; } public SafeFuture gossip(final Attestation attestation) { @@ -85,6 +89,7 @@ SafeFuture> getChannel(final Attestation attestation) { @Override protected Eth2TopicHandler createTopicHandler(final int subnetId) { final String topicName = GossipTopicName.getAttestationSubnetTopicName(subnetId); + return SingleAttestationTopicHandler.createHandler( recentChainData, asyncRunner, @@ -93,7 +98,8 @@ protected Eth2TopicHandler createTopicHandler(final int subnetId) { forkInfo, topicName, attestationSchema, - subnetId); + subnetId, + debugDataDumper); } private SafeFuture> computeSubnetForAttestation(final Attestation attestation) { diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/AttestationTopicSubscriber.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/AttestationTopicSubscriber.java index b2375ba643b..ccf785f92c8 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/AttestationTopicSubscriber.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/AttestationTopicSubscriber.java @@ -96,16 +96,16 @@ public synchronized void subscribeToPersistentSubnets( boolean shouldUpdateENR = false; for (SubnetSubscription subnetSubscription : newSubscriptions) { - int subnetId = subnetSubscription.getSubnetId(); + int subnetId = subnetSubscription.subnetId(); shouldUpdateENR = persistentSubnetIdSet.add(subnetId) || shouldUpdateENR; LOG.trace( "Subscribing to persistent subnet {} with unsubscribe due at slot {}", subnetId, - subnetSubscription.getUnsubscriptionSlot()); + subnetSubscription.unsubscriptionSlot()); if (subnetIdToUnsubscribeSlot.containsKey(subnetId)) { UInt64 existingUnsubscriptionSlot = subnetIdToUnsubscribeSlot.get(subnetId); UInt64 unsubscriptionSlot = - existingUnsubscriptionSlot.max(subnetSubscription.getUnsubscriptionSlot()); + existingUnsubscriptionSlot.max(subnetSubscription.unsubscriptionSlot()); LOG.trace( "Already subscribed to subnet {}, updating unsubscription slot to {}", subnetId, @@ -116,7 +116,7 @@ public synchronized void subscribeToPersistentSubnets( eth2P2PNetwork.subscribeToAttestationSubnetId(subnetId); togglePersistentSubscriptionMetric(subnetId, false); LOG.trace("Subscribed to new persistent subnet {}", subnetId); - subnetIdToUnsubscribeSlot.put(subnetId, subnetSubscription.getUnsubscriptionSlot()); + subnetIdToUnsubscribeSlot.put(subnetId, subnetSubscription.unsubscriptionSlot()); } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/DataColumnSidecarSubnetBackboneSubscriber.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/DataColumnSidecarSubnetBackboneSubscriber.java index 8168288f9f2..40d9361c2fb 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/DataColumnSidecarSubnetBackboneSubscriber.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/DataColumnSidecarSubnetBackboneSubscriber.java @@ -33,7 +33,10 @@ public class DataColumnSidecarSubnetBackboneSubscriber implements SlotEventsChan private UInt64 lastEpoch = UInt64.MAX_VALUE; public DataColumnSidecarSubnetBackboneSubscriber( - final Spec spec, final Eth2P2PNetwork eth2P2PNetwork, UInt256 nodeId, int totalSubnetCount) { + final Spec spec, + final Eth2P2PNetwork eth2P2PNetwork, + final UInt256 nodeId, + final int totalSubnetCount) { this.spec = spec; this.eth2P2PNetwork = eth2P2PNetwork; this.nodeId = nodeId; @@ -62,7 +65,7 @@ private void subscribeToSubnets(final Collection newSubscriptions) { private void onEpoch(final UInt64 epoch) { spec.atEpoch(epoch) .miscHelpers() - .toVersionEip7594() + .getEip7594Helpers() .ifPresent( eip7594Spec -> { List subnets = diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/DataColumnSidecarSubnetSubscriptions.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/DataColumnSidecarSubnetSubscriptions.java index 7896cf18a63..a3dca56e7c7 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/DataColumnSidecarSubnetSubscriptions.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/DataColumnSidecarSubnetSubscriptions.java @@ -17,6 +17,7 @@ import java.util.Optional; import tech.pegasys.teku.infrastructure.async.AsyncRunner; import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.networking.eth2.gossip.encoding.GossipEncoding; import tech.pegasys.teku.networking.eth2.gossip.topics.GossipTopicName; import tech.pegasys.teku.networking.eth2.gossip.topics.GossipTopics; @@ -28,11 +29,12 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.SpecVersion; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.features.Eip7594; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSidecar; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSidecarSchema; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsEip7594; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.client.RecentChainData; public class DataColumnSidecarSubnetSubscriptions extends CommitteeSubnetSubscriptions { @@ -42,8 +44,11 @@ public class DataColumnSidecarSubnetSubscriptions extends CommitteeSubnetSubscri private final RecentChainData recentChainData; private final OperationProcessor processor; private final ForkInfo forkInfo; + private final UInt64 eip7594ActivationEpoch; + private final UInt64 eip7594EndEpoch; private final int subnetCount; private final DataColumnSidecarSchema dataColumnSidecarSchema; + private final DebugDataDumper debugDataDumper; public DataColumnSidecarSubnetSubscriptions( final Spec spec, @@ -52,19 +57,24 @@ public DataColumnSidecarSubnetSubscriptions( final GossipEncoding gossipEncoding, final RecentChainData recentChainData, final OperationProcessor processor, - final ForkInfo forkInfo) { + final DebugDataDumper debugDataDumper, + final ForkInfo forkInfo, + final UInt64 eip7594ActivationEpoch, + final UInt64 eip7594EndEpoch) { super(gossipNetwork, gossipEncoding); this.spec = spec; this.asyncRunner = asyncRunner; this.recentChainData = recentChainData; this.processor = processor; + this.debugDataDumper = debugDataDumper; this.forkInfo = forkInfo; - SpecVersion specVersion = spec.forMilestone(SpecMilestone.EIP7594); + final SpecVersion specVersion = spec.forMilestone(SpecMilestone.getHighestMilestone()); this.dataColumnSidecarSchema = SchemaDefinitionsEip7594.required(specVersion.getSchemaDefinitions()) .getDataColumnSidecarSchema(); - this.subnetCount = - SpecConfigEip7594.required(specVersion.getConfig()).getDataColumnSidecarSubnetCount(); + this.subnetCount = Eip7594.required(specVersion.getConfig()).getDataColumnSidecarSubnetCount(); + this.eip7594ActivationEpoch = eip7594ActivationEpoch; + this.eip7594EndEpoch = eip7594EndEpoch; } public SafeFuture gossip(final DataColumnSidecar sidecar) { @@ -89,7 +99,10 @@ protected Eth2TopicHandler createTopicHandler(final int subnetId) { asyncRunner, processor, gossipEncoding, + debugDataDumper, forkInfo, + eip7594ActivationEpoch, + eip7594EndEpoch, topicName, dataColumnSidecarSchema, subnetId); diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/NodeBasedStableSubnetSubscriber.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/NodeBasedStableSubnetSubscriber.java index 367fca19dfc..3aa00e47f78 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/NodeBasedStableSubnetSubscriber.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/NodeBasedStableSubnetSubscriber.java @@ -54,7 +54,7 @@ public void onSlot(final UInt64 slot) { final Iterator iterator = subnetSubscriptions.iterator(); while (iterator.hasNext()) { final SubnetSubscription subnetSubscription = iterator.next(); - if (subnetSubscription.getUnsubscriptionSlot().isGreaterThan(slot)) { + if (subnetSubscription.unsubscriptionSlot().isGreaterThan(slot)) { break; } iterator.remove(); @@ -109,7 +109,7 @@ private SubnetSubscription subscribeToSubnet( final int subnetId, final UInt64 unsubscriptionSlot) { final SubnetSubscription subnetSubscription = new SubnetSubscription(subnetId, unsubscriptionSlot); - subnetSubscriptions.removeIf(subscription -> subscription.getSubnetId() == subnetId); + subnetSubscriptions.removeIf(subscription -> subscription.subnetId() == subnetId); subnetSubscriptions.add(subnetSubscription); return subnetSubscription; } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/NodeIdToDataColumnSidecarSubnetsCalculator.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/NodeIdToDataColumnSidecarSubnetsCalculator.java index ce3effe3c52..f397543e4ec 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/NodeIdToDataColumnSidecarSubnetsCalculator.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/NodeIdToDataColumnSidecarSubnetsCalculator.java @@ -23,8 +23,9 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.SpecVersion; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; -import tech.pegasys.teku.spec.logic.versions.eip7594.helpers.MiscHelpersEip7594; +import tech.pegasys.teku.spec.config.features.Eip7594; +import tech.pegasys.teku.spec.logic.common.helpers.MiscHelpers; +import tech.pegasys.teku.spec.logic.versions.feature.eip7594.helpers.MiscHelpersEip7594; @FunctionalInterface public interface NodeIdToDataColumnSidecarSubnetsCalculator { @@ -35,14 +36,15 @@ public interface NodeIdToDataColumnSidecarSubnetsCalculator { /** Creates a calculator instance for the specific slot */ private static NodeIdToDataColumnSidecarSubnetsCalculator createAtSlot( - SpecConfigEip7594 config, MiscHelpersEip7594 miscHelpers, UInt64 currentSlot) { + final Eip7594 config, final MiscHelpers miscHelpers, final UInt64 currentSlot) { UInt64 currentEpoch = miscHelpers.computeEpochAtSlot(currentSlot); SszBitvectorSchema bitvectorSchema = SszBitvectorSchema.create(config.getDataColumnSidecarSubnetCount()); return (nodeId, subnetCount) -> { List nodeSubnets = - miscHelpers.computeDataColumnSidecarBackboneSubnets( - nodeId, currentEpoch, subnetCount.orElse(config.getCustodyRequirement())); + MiscHelpersEip7594.required(miscHelpers) + .computeDataColumnSidecarBackboneSubnets( + nodeId, currentEpoch, subnetCount.orElse(config.getCustodyRequirement())); return Optional.of( bitvectorSchema.ofBits(nodeSubnets.stream().map(UInt64::intValue).toList())); }; @@ -50,20 +52,20 @@ private static NodeIdToDataColumnSidecarSubnetsCalculator createAtSlot( /** Create an instance base on the current slot */ static NodeIdToDataColumnSidecarSubnetsCalculator create( - Spec spec, Supplier> currentSlotSupplier) { + final Spec spec, final Supplier> currentSlotSupplier) { return (nodeId, subnetCount) -> currentSlotSupplier .get() .flatMap( slot -> { - SpecVersion specVersion = spec.atSlot(slot); + final SpecVersion specVersion = spec.atSlot(slot); final NodeIdToDataColumnSidecarSubnetsCalculator calculatorAtSlot; - if (specVersion.getMilestone().isGreaterThanOrEqualTo(SpecMilestone.EIP7594)) { + if (specVersion.getMilestone().isGreaterThanOrEqualTo(SpecMilestone.ELECTRA)) { calculatorAtSlot = createAtSlot( - SpecConfigEip7594.required(specVersion.getConfig()), - MiscHelpersEip7594.required(specVersion.miscHelpers()), + Eip7594.required(specVersion.getConfig()), + specVersion.miscHelpers(), slot); } else { calculatorAtSlot = NOOP; diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/PeerSubnetSubscriptions.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/PeerSubnetSubscriptions.java index 2747b13d56b..7525e886682 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/PeerSubnetSubscriptions.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/PeerSubnetSubscriptions.java @@ -37,7 +37,7 @@ import tech.pegasys.teku.networking.p2p.gossip.GossipNetwork; import tech.pegasys.teku.networking.p2p.peer.NodeId; import tech.pegasys.teku.spec.SpecVersion; -import tech.pegasys.teku.spec.config.NetworkingSpecConfigEip7594; +import tech.pegasys.teku.spec.config.features.Eip7594; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsSupplier; public class PeerSubnetSubscriptions { @@ -79,9 +79,10 @@ public static PeerSubnetSubscriptions create( Integer dataColumnSidecarSubnetCount = currentVersion .getConfig() - .toVersionEip7594() - .map(NetworkingSpecConfigEip7594::getDataColumnSidecarSubnetCount) - .orElse(0); + .getOptionalEip7594Config() + .map(Eip7594::getDataColumnSidecarSubnetCount) + // SszBitvectorSchema.create will throw with 0 + .orElse(1); final PeerSubnetSubscriptions subscriptions = builder(currentSchemaDefinitions, SszBitvectorSchema.create(dataColumnSidecarSubnetCount)) @@ -246,7 +247,7 @@ private OptionalInt getMinSubscriberCount() { dataColumnSidecarSubnetSubscriptions.getMinSubscriberCount())); } - private static OptionalInt optionalMin(List optionalInts) { + private static OptionalInt optionalMin(final List optionalInts) { return optionalInts.stream().flatMapToInt(OptionalInt::stream).min(); } @@ -279,7 +280,7 @@ private SubnetSubscriptions( this.subscriptionsByPeer = subscriptionsByPeer; } - public static Builder builder(SszBitvectorSchema subscriptionSchema) { + public static Builder builder(final SszBitvectorSchema subscriptionSchema) { return new Builder(subscriptionSchema); } @@ -401,7 +402,8 @@ public Builder dataColumnSidecarSubnetSubscriptions( } public Builder nodeIdToDataColumnSidecarSubnetsCalculator( - NodeIdToDataColumnSidecarSubnetsCalculator nodeIdToDataColumnSidecarSubnetsCalculator) { + final NodeIdToDataColumnSidecarSubnetsCalculator + nodeIdToDataColumnSidecarSubnetsCalculator) { this.nodeIdToDataColumnSidecarSubnetsCalculator = nodeIdToDataColumnSidecarSubnetsCalculator; return this; } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/SubnetScorer.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/SubnetScorer.java index e74a4c5a022..ee5d0b777c6 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/SubnetScorer.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/SubnetScorer.java @@ -49,7 +49,7 @@ public int scoreExistingPeer(final NodeId peerId) { } @Override - public int scoreCandidatePeer(DiscoveryPeer candidate) { + public int scoreCandidatePeer(final DiscoveryPeer candidate) { return scoreCandidatePeer( candidate.getPersistentAttestationSubnets(), candidate.getSyncCommitteeSubnets(), diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/SyncCommitteeSubnetSubscriptions.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/SyncCommitteeSubnetSubscriptions.java index e044761b363..5bd63e3ac62 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/SyncCommitteeSubnetSubscriptions.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/subnets/SyncCommitteeSubnetSubscriptions.java @@ -27,6 +27,7 @@ import tech.pegasys.teku.spec.datastructures.operations.versions.altair.ValidatableSyncCommitteeMessage; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsAltair; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.client.RecentChainData; public class SyncCommitteeSubnetSubscriptions extends CommitteeSubnetSubscriptions { @@ -37,6 +38,7 @@ public class SyncCommitteeSubnetSubscriptions extends CommitteeSubnetSubscriptio private final AsyncRunner asyncRunner; private final OperationProcessor processor; private final ForkInfo forkInfo; + private final DebugDataDumper debugDataDumper; public SyncCommitteeSubnetSubscriptions( final Spec spec, @@ -46,7 +48,8 @@ public SyncCommitteeSubnetSubscriptions( final SchemaDefinitionsAltair schemaDefinitions, final AsyncRunner asyncRunner, final OperationProcessor processor, - final ForkInfo forkInfo) { + final ForkInfo forkInfo, + final DebugDataDumper debugDataDumper) { super(gossipNetwork, gossipEncoding); this.spec = spec; this.recentChainData = recentChainData; @@ -54,6 +57,7 @@ public SyncCommitteeSubnetSubscriptions( this.asyncRunner = asyncRunner; this.processor = processor; this.forkInfo = forkInfo; + this.debugDataDumper = debugDataDumper; } public SafeFuture gossip(final SyncCommitteeMessage message, final int subnetId) { @@ -81,6 +85,7 @@ protected Eth2TopicHandler createTopicHandler(final int subnetId) { forkInfo.getFork(), message -> spec.computeEpochAtSlot(message.getSlot())), schemaDefinitions.getSyncCommitteeMessageSchema(), - spec.getNetworkingConfig()); + spec.getNetworkingConfig(), + debugDataDumper); } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/Eth2GossipTopicFilter.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/Eth2GossipTopicFilter.java index 260beb80296..1aa08b34474 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/Eth2GossipTopicFilter.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/Eth2GossipTopicFilter.java @@ -24,6 +24,7 @@ import tech.pegasys.teku.networking.eth2.gossip.encoding.GossipEncoding; import tech.pegasys.teku.networking.p2p.libp2p.gossip.GossipTopicFilter; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; import tech.pegasys.teku.storage.client.RecentChainData; @@ -52,7 +53,9 @@ private Set computeRelevantTopics( final RecentChainData recentChainData, final GossipEncoding gossipEncoding) { final ForkInfo forkInfo = recentChainData.getCurrentForkInfo().orElseThrow(); final Bytes4 forkDigest = forkInfo.getForkDigest(spec); - final Set topics = getAllTopics(gossipEncoding, forkDigest, spec); + final SpecMilestone specMilestone = + recentChainData.getMilestoneByForkDigest(forkDigest).orElseThrow(); + final Set topics = getAllTopics(gossipEncoding, forkDigest, spec, specMilestone); spec.getForkSchedule().getForks().stream() .filter(fork -> fork.getEpoch().isGreaterThanOrEqualTo(forkInfo.getFork().getEpoch())) .forEach( @@ -62,7 +65,7 @@ private Set computeRelevantTopics( .miscHelpers() .computeForkDigest( futureFork.getCurrentVersion(), forkInfo.getGenesisValidatorsRoot()); - topics.addAll(getAllTopics(gossipEncoding, futureForkDigest, spec)); + topics.addAll(getAllTopics(gossipEncoding, futureForkDigest, spec, specMilestone)); }); return topics; } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/GossipSubValidationUtil.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/GossipSubValidationUtil.java index 9da5c209484..d41715b350e 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/GossipSubValidationUtil.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/GossipSubValidationUtil.java @@ -18,7 +18,8 @@ public class GossipSubValidationUtil { - public static ValidationResult fromInternalValidationResult(InternalValidationResult result) { + public static ValidationResult fromInternalValidationResult( + final InternalValidationResult result) { switch (result.code()) { case ACCEPT: return ValidationResult.Valid; diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/GossipTopics.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/GossipTopics.java index cc2a0097ac7..e11e3797e50 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/GossipTopics.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/GossipTopics.java @@ -21,6 +21,7 @@ import tech.pegasys.teku.infrastructure.bytes.Bytes4; import tech.pegasys.teku.networking.eth2.gossip.encoding.GossipEncoding; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.constants.NetworkConstants; /** @@ -75,17 +76,20 @@ public static String getDataColumnSidecarSubnetTopic( public static Set getAllDataColumnSidecarSubnetTopics( final GossipEncoding gossipEncoding, final Bytes4 forkDigest, final Spec spec) { - return spec.getNetworkingConfigEip7594() + return spec.getNumberOfDataColumnSubnets() .map( - eip7594NetworkConfig -> - IntStream.range(0, eip7594NetworkConfig.getDataColumnSidecarSubnetCount()) + subnetCount -> + IntStream.range(0, subnetCount) .mapToObj(i -> getDataColumnSidecarSubnetTopic(forkDigest, i, gossipEncoding)) .collect(Collectors.toSet())) .orElse(Collections.emptySet()); } public static Set getAllTopics( - final GossipEncoding gossipEncoding, final Bytes4 forkDigest, final Spec spec) { + final GossipEncoding gossipEncoding, + final Bytes4 forkDigest, + final Spec spec, + final SpecMilestone specMilestone) { final Set topics = new HashSet<>(); for (int i = 0; i < spec.getNetworkingConfig().getAttestationSubnetCount(); i++) { @@ -94,11 +98,13 @@ public static Set getAllTopics( for (int i = 0; i < NetworkConstants.SYNC_COMMITTEE_SUBNET_COUNT; i++) { topics.add(getSyncCommitteeSubnetTopic(forkDigest, i, gossipEncoding)); } - if (spec.getNetworkingConfigDeneb().isPresent()) { - for (int i = 0; i < spec.getNetworkingConfigDeneb().get().getBlobSidecarSubnetCount(); i++) { - topics.add(getBlobSidecarSubnetTopic(forkDigest, i, gossipEncoding)); - } - } + spec.forMilestone(specMilestone) + .getConfig() + .toVersionDeneb() + .ifPresent( + config -> + addBlobSidecarSubnetTopics( + config.getBlobSidecarSubnetCount(), topics, forkDigest, gossipEncoding)); topics.addAll(getAllDataColumnSidecarSubnetTopics(gossipEncoding, forkDigest, spec)); @@ -122,4 +128,14 @@ public static Bytes4 extractForkDigest(final String topic) throws IllegalArgumen return Bytes4.fromHexString(forkDigest); } + + private static void addBlobSidecarSubnetTopics( + final int blobSidecarSubnetCount, + final Set topics, + final Bytes4 forkDigest, + final GossipEncoding gossipEncoding) { + for (int i = 0; i < blobSidecarSubnetCount; i++) { + topics.add(getBlobSidecarSubnetTopic(forkDigest, i, gossipEncoding)); + } + } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/OperationEpochValidator.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/OperationEpochValidator.java new file mode 100644 index 00000000000..ffddebb8988 --- /dev/null +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/OperationEpochValidator.java @@ -0,0 +1,40 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.networking.eth2.gossip.topics; + +import java.util.function.Function; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; + +public class OperationEpochValidator implements OperationValidator { + + private final UInt64 startEpoch; + private final UInt64 endEpoch; + private final Function getEpochForMessage; + + public OperationEpochValidator( + final UInt64 startEpoch, + final UInt64 endEpoch, + final Function getEpochForMessage) { + this.startEpoch = startEpoch; + this.endEpoch = endEpoch; + this.getEpochForMessage = getEpochForMessage; + } + + @Override + public boolean isValid(final T message) { + final UInt64 messageEpoch = getEpochForMessage.apply(message); + return messageEpoch.isGreaterThanOrEqualTo(startEpoch) + && messageEpoch.isLessThanOrEqualTo(endEpoch); + } +} diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/OperationMilestoneValidator.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/OperationMilestoneValidator.java index 0353b3160d1..ff30c394e55 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/OperationMilestoneValidator.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/OperationMilestoneValidator.java @@ -18,7 +18,7 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.state.Fork; -public class OperationMilestoneValidator { +public class OperationMilestoneValidator implements OperationValidator { private final Spec spec; private final Fork expectedFork; @@ -31,7 +31,8 @@ public OperationMilestoneValidator( this.getEpochForMessage = getEpochForMessage; } - public boolean isValid(T message) { + @Override + public boolean isValid(final T message) { final UInt64 messageEpoch = getEpochForMessage.apply(message); final Fork actualFork = spec.getForkSchedule().getFork(messageEpoch); return expectedFork.equals(actualFork); diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/beacon/GetAttestationsResponse.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/OperationValidator.java similarity index 56% rename from data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/beacon/GetAttestationsResponse.java rename to networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/OperationValidator.java index 741afd4c669..e855603df36 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/beacon/GetAttestationsResponse.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/OperationValidator.java @@ -11,19 +11,9 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.api.response.v1.beacon; +package tech.pegasys.teku.networking.eth2.gossip.topics; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import java.util.List; -import tech.pegasys.teku.api.schema.Attestation; +public interface OperationValidator { -public class GetAttestationsResponse { - @JsonProperty("data") - public final List data; - - @JsonCreator - public GetAttestationsResponse(@JsonProperty("data") final List data) { - this.data = data; - } + boolean isValid(final T message); } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/topichandlers/DataColumnSidecarTopicHandler.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/topichandlers/DataColumnSidecarTopicHandler.java index e959f4d41a0..f956a0acbc5 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/topichandlers/DataColumnSidecarTopicHandler.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/topichandlers/DataColumnSidecarTopicHandler.java @@ -18,23 +18,27 @@ import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.networking.eth2.gossip.encoding.GossipEncoding; -import tech.pegasys.teku.networking.eth2.gossip.topics.OperationMilestoneValidator; +import tech.pegasys.teku.networking.eth2.gossip.topics.OperationEpochValidator; import tech.pegasys.teku.networking.eth2.gossip.topics.OperationProcessor; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSidecar; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSidecarSchema; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.statetransition.validation.InternalValidationResult; import tech.pegasys.teku.storage.client.RecentChainData; public class DataColumnSidecarTopicHandler { - public static Eth2TopicHandler createHandler( + public static Eth2TopicHandler createHandler( final RecentChainData recentChainData, final AsyncRunner asyncRunner, final OperationProcessor operationProcessor, final GossipEncoding gossipEncoding, + final DebugDataDumper debugDataDumper, final ForkInfo forkInfo, + final UInt64 startEpoch, + final UInt64 endEpoch, final String topicName, final DataColumnSidecarSchema dataColumnSidecarSchema, final int subnetId) { @@ -48,10 +52,11 @@ public static Eth2TopicHandler createHandler( gossipEncoding, forkInfo.getForkDigest(spec), topicName, - new OperationMilestoneValidator<>( - spec, forkInfo.getFork(), message -> spec.computeEpochAtSlot(message.getSlot())), + new OperationEpochValidator<>( + startEpoch, endEpoch, message -> spec.computeEpochAtSlot(message.getSlot())), dataColumnSidecarSchema, - spec.getNetworkingConfig()); + spec.getNetworkingConfig(), + debugDataDumper); } private record TopicSubnetIdAwareOperationProcessor( diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/topichandlers/Eth2TopicHandler.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/topichandlers/Eth2TopicHandler.java index 3aa03596cc8..f75710ee3e9 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/topichandlers/Eth2TopicHandler.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/topichandlers/Eth2TopicHandler.java @@ -34,12 +34,13 @@ import tech.pegasys.teku.networking.eth2.gossip.topics.GossipSubValidationUtil; import tech.pegasys.teku.networking.eth2.gossip.topics.GossipTopicName; import tech.pegasys.teku.networking.eth2.gossip.topics.GossipTopics; -import tech.pegasys.teku.networking.eth2.gossip.topics.OperationMilestoneValidator; import tech.pegasys.teku.networking.eth2.gossip.topics.OperationProcessor; +import tech.pegasys.teku.networking.eth2.gossip.topics.OperationValidator; import tech.pegasys.teku.networking.p2p.gossip.PreparedGossipMessage; import tech.pegasys.teku.networking.p2p.gossip.TopicHandler; import tech.pegasys.teku.service.serviceutils.ServiceCapacityExceededException; import tech.pegasys.teku.spec.config.NetworkingSpecConfig; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.statetransition.validation.InternalValidationResult; import tech.pegasys.teku.storage.client.RecentChainData; @@ -49,11 +50,12 @@ public class Eth2TopicHandler implements TopicHandler private final OperationProcessor processor; private final GossipEncoding gossipEncoding; private final Bytes4 forkDigest; - private final String topicName; private final SszSchema messageType; private final Eth2PreparedGossipMessageFactory preparedGossipMessageFactory; - private final OperationMilestoneValidator forkValidator; + private final OperationValidator forkValidator; private final NetworkingSpecConfig networkingConfig; + private final DebugDataDumper debugDataDumper; + private final String topic; public Eth2TopicHandler( final RecentChainData recentChainData, @@ -62,20 +64,22 @@ public Eth2TopicHandler( final GossipEncoding gossipEncoding, final Bytes4 forkDigest, final String topicName, - final OperationMilestoneValidator forkValidator, + final OperationValidator forkValidator, final SszSchema messageType, - final NetworkingSpecConfig networkingConfig) { + final NetworkingSpecConfig networkingConfig, + final DebugDataDumper debugDataDumper) { this.asyncRunner = asyncRunner; this.processor = processor; this.gossipEncoding = gossipEncoding; this.forkDigest = forkDigest; - this.topicName = topicName; this.messageType = messageType; this.forkValidator = forkValidator; this.networkingConfig = networkingConfig; this.preparedGossipMessageFactory = gossipEncoding.createPreparedGossipMessageFactory( recentChainData::getMilestoneByForkDigest); + this.debugDataDumper = debugDataDumper; + this.topic = GossipTopics.getTopic(forkDigest, topicName, gossipEncoding); } public Eth2TopicHandler( @@ -85,9 +89,10 @@ public Eth2TopicHandler( final GossipEncoding gossipEncoding, final Bytes4 forkDigest, final GossipTopicName topicName, - final OperationMilestoneValidator forkValidator, + final OperationValidator forkValidator, final SszSchema messageType, - final NetworkingSpecConfig networkingConfig) { + final NetworkingSpecConfig networkingConfig, + final DebugDataDumper debugDataDumper) { this( recentChainData, asyncRunner, @@ -97,11 +102,12 @@ public Eth2TopicHandler( topicName.toString(), forkValidator, messageType, - networkingConfig); + networkingConfig, + debugDataDumper); } @Override - public SafeFuture handleMessage(PreparedGossipMessage message) { + public SafeFuture handleMessage(final PreparedGossipMessage message) { return SafeFuture.of(() -> deserialize(message)) .thenCompose( deserialized -> { @@ -129,6 +135,11 @@ private void processMessage( final PreparedGossipMessage message) { switch (internalValidationResult.code()) { case REJECT: + debugDataDumper.saveGossipRejectedMessage( + getTopic(), + message.getArrivalTimestamp(), + () -> message.getDecodedMessage().getDecodedMessage().orElse(Bytes.EMPTY), + internalValidationResult.getDescription()); P2P_LOG.onGossipRejected( getTopic(), message.getDecodedMessage().getDecodedMessage().orElse(Bytes.EMPTY), @@ -148,10 +159,6 @@ private void processMessage( } } - private String getTopicName() { - return topicName; - } - private SszSchema getMessageType() { return messageType; } @@ -160,6 +167,9 @@ protected ValidationResult handleMessageProcessingError( final PreparedGossipMessage message, final Throwable err) { final ValidationResult response; if (ExceptionUtil.hasCause(err, DecodingException.class)) { + + debugDataDumper.saveGossipMessageDecodingError( + getTopic(), message.getArrivalTimestamp(), message::getOriginalMessage, err); P2P_LOG.onGossipMessageDecodingError(getTopic(), message.getOriginalMessage(), err); response = ValidationResult.Invalid; } else if (ExceptionUtil.hasCause(err, RejectedExecutionException.class)) { @@ -191,7 +201,7 @@ public int getMaxMessageSize() { return networkingConfig.getGossipMaxSize(); } - protected MessageT deserialize(PreparedGossipMessage message) throws DecodingException { + protected MessageT deserialize(final PreparedGossipMessage message) throws DecodingException { return getGossipEncoding().decodeMessage(message, getMessageType()); } @@ -200,7 +210,7 @@ public OperationProcessor getProcessor() { } public String getTopic() { - return GossipTopics.getTopic(getForkDigest(), getTopicName(), getGossipEncoding()); + return topic; } public GossipEncoding getGossipEncoding() { diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/topichandlers/SingleAttestationTopicHandler.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/topichandlers/SingleAttestationTopicHandler.java index f88a7d6ee9c..002b3de3d0f 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/topichandlers/SingleAttestationTopicHandler.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/topics/topichandlers/SingleAttestationTopicHandler.java @@ -20,8 +20,9 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.client.RecentChainData; public class SingleAttestationTopicHandler { @@ -33,8 +34,9 @@ public static Eth2TopicHandler createHandler( final GossipEncoding gossipEncoding, final ForkInfo forkInfo, final String topicName, - final AttestationSchema attestationSchema, - final int subnetId) { + final AttestationSchema attestationSchema, + final int subnetId, + final DebugDataDumper debugDataDumper) { final Spec spec = recentChainData.getSpec(); OperationProcessor convertingProcessor = @@ -53,7 +55,8 @@ public static Eth2TopicHandler createHandler( spec, forkInfo.getFork(), message -> spec.computeEpochAtSlot(message.getData().getSlot())), - attestationSchema, - spec.getNetworkingConfig()); + attestationSchema.castTypeToAttestationSchema(), + spec.getNetworkingConfig(), + debugDataDumper); } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/mock/NoOpEth2P2PNetwork.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/mock/NoOpEth2P2PNetwork.java index 6cd42842e8e..d2489ef27ba 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/mock/NoOpEth2P2PNetwork.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/mock/NoOpEth2P2PNetwork.java @@ -55,10 +55,10 @@ public void subscribeToSyncCommitteeSubnetId(final int subnetId) {} public void unsubscribeFromSyncCommitteeSubnetId(final int subnetId) {} @Override - public void subscribeToDataColumnSidecarSubnetId(int subnetId) {} + public void subscribeToDataColumnSidecarSubnetId(final int subnetId) {} @Override - public void unsubscribeFromDataColumnSidecarSubnetId(int subnetId) {} + public void unsubscribeFromDataColumnSidecarSubnetId(final int subnetId) {} @Override public MetadataMessage getMetadata() { diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/DataColumnPeerManagerImpl.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/DataColumnPeerManagerImpl.java index 53fcfb609ce..8e089db0a31 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/DataColumnPeerManagerImpl.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/DataColumnPeerManagerImpl.java @@ -36,41 +36,42 @@ public class DataColumnPeerManagerImpl BatchDataColumnsByRangeReqResp { private final Subscribers listeners = Subscribers.create(true); - private Map connectedPeers = new ConcurrentHashMap<>(); + private final Map connectedPeers = new ConcurrentHashMap<>(); @Override - public void onConnected(Eth2Peer peer) { + public void onConnected(final Eth2Peer peer) { peerConnected(peer); } - private void peerConnected(Eth2Peer peer) { - UInt256 nodeId = peer.getDiscoveryNodeId().orElseThrow(); + private void peerConnected(final Eth2Peer peer) { + final UInt256 nodeId = peer.getDiscoveryNodeId().orElseThrow(); connectedPeers.put(nodeId, peer); listeners.forEach(l -> l.peerConnected(nodeId)); peer.subscribeDisconnect((__, ___) -> peerDisconnected(peer)); } - private void peerDisconnected(Eth2Peer peer) { - UInt256 nodeId = peer.getDiscoveryNodeId().orElseThrow(); + private void peerDisconnected(final Eth2Peer peer) { + final UInt256 nodeId = peer.getDiscoveryNodeId().orElseThrow(); listeners.forEach(l -> l.peerDisconnected(nodeId)); connectedPeers.remove(nodeId); } @Override - public void addPeerListener(PeerListener listener) { + public void addPeerListener(final PeerListener listener) { listeners.subscribe(listener); } @Override - public void banNode(UInt256 node) { + public void banNode(final UInt256 node) { // TODO } @Override public AsyncStream requestDataColumnSidecarsByRoot( - UInt256 nodeId, List columnIdentifiers) { - Eth2Peer eth2Peer = connectedPeers.get(nodeId); - AsyncStreamPublisher ret = AsyncStream.createPublisher(Integer.MAX_VALUE); + final UInt256 nodeId, final List columnIdentifiers) { + final Eth2Peer eth2Peer = connectedPeers.get(nodeId); + final AsyncStreamPublisher ret = + AsyncStream.createPublisher(Integer.MAX_VALUE); if (eth2Peer == null) { ret.onError(new DataColumnReqResp.DasPeerDisconnectedException()); } else { @@ -83,9 +84,13 @@ public AsyncStream requestDataColumnSidecarsByRoot( @Override public AsyncStream requestDataColumnSidecarsByRange( - UInt256 nodeId, UInt64 startSlot, int slotCount, List columnIndexes) { - Eth2Peer eth2Peer = connectedPeers.get(nodeId); - AsyncStreamPublisher ret = AsyncStream.createPublisher(Integer.MAX_VALUE); + final UInt256 nodeId, + final UInt64 startSlot, + final int slotCount, + final List columnIndexes) { + final Eth2Peer eth2Peer = connectedPeers.get(nodeId); + final AsyncStreamPublisher ret = + AsyncStream.createPublisher(Integer.MAX_VALUE); if (eth2Peer == null) { ret.onError(new DataColumnReqResp.DasPeerDisconnectedException()); } else { @@ -98,8 +103,8 @@ public AsyncStream requestDataColumnSidecarsByRange( } @Override - public int getCurrentRequestLimit(UInt256 nodeId) { - Eth2Peer eth2Peer = connectedPeers.get(nodeId); + public int getCurrentRequestLimit(final UInt256 nodeId) { + final Eth2Peer eth2Peer = connectedPeers.get(nodeId); if (eth2Peer == null) { return 0; } else { diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/DefaultEth2Peer.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/DefaultEth2Peer.java index cdebcd1f940..3e90caffd0e 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/DefaultEth2Peer.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/DefaultEth2Peer.java @@ -54,7 +54,7 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.config.SpecConfigDeneb; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.features.Eip7594; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSidecar; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; @@ -109,7 +109,6 @@ class DefaultEth2Peer extends DelegatingPeer implements Eth2Peer { private final Supplier< DataColumnSidecarsByRangeRequestMessage.DataColumnSidecarsByRangeRequestMessageSchema> dataColumnSidecarsByRangeRequestMessageSchema; - private final Supplier maxBlobsPerBlock; DefaultEth2Peer( final Spec spec, @@ -151,23 +150,21 @@ class DefaultEth2Peer extends DelegatingPeer implements Eth2Peer { this.firstSlotSupportingDataColumnSidecarsByRange = Suppliers.memoize( () -> { - final UInt64 eip7594ForkEpoch = getSpecConfigEip7594().getEip7594ForkEpoch(); + final UInt64 eip7594ForkEpoch = getSpecConfigEip7594().getEip7594FeatureEpoch(); return spec.computeStartSlotAtEpoch(eip7594ForkEpoch); }); this.dataColumnSidecarsByRootRequestMessageSchema = Suppliers.memoize( () -> SchemaDefinitionsEip7594.required( - spec.forMilestone(SpecMilestone.EIP7594).getSchemaDefinitions()) + spec.forMilestone(SpecMilestone.ELECTRA).getSchemaDefinitions()) .getDataColumnSidecarsByRootRequestMessageSchema()); this.dataColumnSidecarsByRangeRequestMessageSchema = Suppliers.memoize( () -> SchemaDefinitionsEip7594.required( - spec.forMilestone(SpecMilestone.EIP7594).getSchemaDefinitions()) + spec.forMilestone(SpecMilestone.ELECTRA).getSchemaDefinitions()) .getDataColumnSidecarsByRangeRequestMessageSchema()); - - this.maxBlobsPerBlock = Suppliers.memoize(() -> getSpecConfigDeneb().getMaxBlobsPerBlock()); } @Override @@ -222,7 +219,7 @@ public void subscribeStatusUpdates(final PeerStatusSubscriber subscriber) { } @Override - public void subscribeMetadataUpdates(PeerMetadataUpdateSubscriber subscriber) { + public void subscribeMetadataUpdates(final PeerMetadataUpdateSubscriber subscriber) { metadataSubscribers.subscribe(subscriber); remoteMetadata.ifPresent(metadata -> subscriber.onPeerMetadataUpdate(this, metadata)); } @@ -390,6 +387,7 @@ public SafeFuture requestBlobSidecarsByRange( method -> { final UInt64 firstSupportedSlot = firstSlotSupportingBlobSidecarsByRange.get(); final BlobSidecarsByRangeRequestMessage request; + final int maxBlobsPerBlock = calculateMaxBlobsPerBlock(startSlot.plus(count)); if (startSlot.isLessThan(firstSupportedSlot)) { LOG.debug( @@ -403,10 +401,9 @@ public SafeFuture requestBlobSidecarsByRange( } request = new BlobSidecarsByRangeRequestMessage( - firstSupportedSlot, updatedCount, maxBlobsPerBlock.get()); + firstSupportedSlot, updatedCount, maxBlobsPerBlock); } else { - request = - new BlobSidecarsByRangeRequestMessage(startSlot, count, maxBlobsPerBlock.get()); + request = new BlobSidecarsByRangeRequestMessage(startSlot, count, maxBlobsPerBlock); } return requestStream( method, @@ -415,7 +412,7 @@ public SafeFuture requestBlobSidecarsByRange( spec, this, listener, - maxBlobsPerBlock.get(), + maxBlobsPerBlock, kzg, request.getStartSlot(), request.getCount())); @@ -423,6 +420,10 @@ public SafeFuture requestBlobSidecarsByRange( .orElse(failWithUnsupportedMethodException("BlobSidecarsByRange")); } + private int calculateMaxBlobsPerBlock(final UInt64 endSlot) { + return SpecConfigDeneb.required(spec.atSlot(endSlot).getConfig()).getMaxBlobsPerBlock(); + } + @Override public SafeFuture requestDataColumnSidecarsByRange( final UInt64 startSlot, @@ -478,7 +479,7 @@ public SafeFuture requestMetadata() { @Override public Optional approveBlocksRequest( - final ResponseCallback callback, long blocksCount) { + final ResponseCallback callback, final long blocksCount) { return approveObjectsRequest("blocks", blockRequestTracker, blocksCount, callback); } @@ -490,7 +491,7 @@ public void adjustBlocksRequest( @Override public Optional approveBlobSidecarsRequest( - final ResponseCallback callback, long blobSidecarsCount) { + final ResponseCallback callback, final long blobSidecarsCount) { return approveObjectsRequest( "blob sidecars", blobSidecarsRequestTracker, blobSidecarsCount, callback); } @@ -509,7 +510,7 @@ public long getAvailableDataColumnSidecarsRequestCount() { @Override public Optional approveDataColumnSidecarsRequest( - final ResponseCallback callback, long dataColumnSidecarsCount) { + final ResponseCallback callback, final long dataColumnSidecarsCount) { return approveObjectsRequest( "data column sidecars", dataColumnSidecarsRequestTracker, @@ -617,8 +618,8 @@ private SpecConfigDeneb getSpecConfigDeneb() { return SpecConfigDeneb.required(spec.forMilestone(SpecMilestone.DENEB).getConfig()); } - private SpecConfigEip7594 getSpecConfigEip7594() { - return SpecConfigEip7594.required(spec.forMilestone(SpecMilestone.EIP7594).getConfig()); + private Eip7594 getSpecConfigEip7594() { + return Eip7594.required(spec.forMilestone(SpecMilestone.ELECTRA).getConfig()); } private SafeFuture failWithUnsupportedMethodException(final String method) { diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/Eth2PeerFactory.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/Eth2PeerFactory.java index 92d19a92e73..5ebc07360c5 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/Eth2PeerFactory.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/Eth2PeerFactory.java @@ -79,7 +79,7 @@ public Eth2Peer create(final Peer peer, final BeaconChainMethods rpcMethods) { RateTracker.create( peerRateLimit * BLOCK_RATE_LIMIT_BOOST, TIME_OUT, timeProvider, "blocks"), RateTracker.create( - peerRateLimit * spec.getMaxBlobsPerBlock().orElse(1), + peerRateLimit * spec.getMaxBlobsPerBlockForHighestMilestone().orElse(1), TIME_OUT, timeProvider, "blobSidecars"), diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/Eth2PeerManager.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/Eth2PeerManager.java index 62cda71a8cb..d8edf404bb1 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/Eth2PeerManager.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/Eth2PeerManager.java @@ -173,7 +173,7 @@ public MetadataMessage getMetadataMessage() { return metadataMessagesFactory.createMetadataMessage(schema); } - private void setUpPeriodicTasksForPeer(Eth2Peer peer) { + private void setUpPeriodicTasksForPeer(final Eth2Peer peer) { Cancellable periodicStatusUpdateTask = periodicallyUpdatePeerStatus(peer); Cancellable periodicPingTask = periodicallyPingPeer(peer); peer.subscribeDisconnect( @@ -183,7 +183,7 @@ private void setUpPeriodicTasksForPeer(Eth2Peer peer) { }); } - Cancellable periodicallyUpdatePeerStatus(Eth2Peer peer) { + Cancellable periodicallyUpdatePeerStatus(final Eth2Peer peer) { return asyncRunner.runWithFixedDelay( () -> peer.sendStatus() @@ -194,7 +194,7 @@ Cancellable periodicallyUpdatePeerStatus(Eth2Peer peer) { err -> LOG.debug("Exception calling runnable for updating peer status.", err)); } - Cancellable periodicallyPingPeer(Eth2Peer peer) { + Cancellable periodicallyPingPeer(final Eth2Peer peer) { return asyncRunner.runWithFixedDelay( () -> sendPeriodicPing(peer), eth2RpcPingInterval, @@ -263,7 +263,7 @@ private void ensureStatusReceived(final Eth2Peer peer) { } @VisibleForTesting - void sendPeriodicPing(Eth2Peer peer) { + void sendPeriodicPing(final Eth2Peer peer) { if (peer.getUnansweredPingCount() >= eth2RpcOutstandingPingThreshold) { LOG.debug("Disconnecting the peer {} due to PING timeout.", peer.getId()); peer.disconnectCleanly(DisconnectReason.UNRESPONSIVE).ifExceptionGetsHereRaiseABug(); @@ -306,11 +306,11 @@ public BeaconChainMethods getBeaconChainMethods() { * @return the peer corresponding to this node id. */ @Override - public Optional getConnectedPeer(NodeId nodeId) { + public Optional getConnectedPeer(final NodeId nodeId) { return Optional.ofNullable(connectedPeerMap.get(nodeId)); } - public Optional getPeer(NodeId peerId) { + public Optional getPeer(final NodeId peerId) { return Optional.ofNullable(connectedPeerMap.get(peerId)).filter(this::peerIsReady); } @@ -318,7 +318,7 @@ public Stream streamPeers() { return connectedPeerMap.values().stream().filter(this::peerIsReady); } - private boolean peerIsReady(Eth2Peer peer) { + private boolean peerIsReady(final Eth2Peer peer) { return peer.hasStatus(); } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/Eth2PeerSelectionStrategy.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/Eth2PeerSelectionStrategy.java index d0c7b251af8..1a0bd0ed93b 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/Eth2PeerSelectionStrategy.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/Eth2PeerSelectionStrategy.java @@ -107,7 +107,7 @@ private List selectAndRemoveRandomPeers( final List selectedPeers = new ArrayList<>(); shuffler.shuffle(allCandidatePeers); while (!allCandidatePeers.isEmpty() && selectedPeers.size() < randomlySelectedPeersToAdd) { - final DiscoveryPeer candidate = allCandidatePeers.remove(0); + final DiscoveryPeer candidate = allCandidatePeers.removeFirst(); checkCandidate(candidate, network) .ifPresent( peerAddress -> { diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/GossipTopicDasPeerCustodyTracker.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/GossipTopicDasPeerCustodyTracker.java index 66c10f46a29..d0ebdc536f1 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/GossipTopicDasPeerCustodyTracker.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/GossipTopicDasPeerCustodyTracker.java @@ -49,11 +49,11 @@ public class GossipTopicDasPeerCustodyTracker private final Map connectedPeerSubnets = new ConcurrentHashMap<>(); public GossipTopicDasPeerCustodyTracker( - Spec spec, - GossipNetwork gossipNetwork, - GossipEncoding gossipEncoding, - Supplier> currentForkInfoSupplier, - AsyncRunner asyncRunner) { + final Spec spec, + final GossipNetwork gossipNetwork, + final GossipEncoding gossipEncoding, + final Supplier> currentForkInfoSupplier, + final AsyncRunner asyncRunner) { this.spec = spec; this.gossipNetwork = gossipNetwork; this.gossipEncoding = gossipEncoding; @@ -65,14 +65,14 @@ public GossipTopicDasPeerCustodyTracker( } @Override - public void onConnected(Eth2Peer peer) { + public void onConnected(final Eth2Peer peer) { connectedPeerSubnets.put( peer.getDiscoveryNodeId().orElseThrow(), new Entry(peer.getId(), NO_SUBNET_COUNT_INFO)); peer.subscribeDisconnect((__, ___) -> peerDisconnected(peer)); refreshExistingSubscriptions(); } - private void peerDisconnected(Eth2Peer peer) { + private void peerDisconnected(final Eth2Peer peer) { connectedPeerSubnets.remove(peer.getDiscoveryNodeId().orElseThrow()); } @@ -107,13 +107,13 @@ record NodeTopic(NodeId nodeId, String topic) {} } @Override - public int getCustodyCountForPeer(UInt256 nodeId) { + public int getCustodyCountForPeer(final UInt256 nodeId) { Entry entry = connectedPeerSubnets.get(nodeId); return entry != null ? entry.subnetCount() : 0; } private record Entry(NodeId libp2pPeerId, Integer subnetCount) { - public Entry withSubnetCount(int newCount) { + public Entry withSubnetCount(final int newCount) { return newCount == subnetCount ? this : new Entry(libp2pPeerId, newCount); } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/MetadataDasPeerCustodyTracker.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/MetadataDasPeerCustodyTracker.java index 8b803c3c9b9..e65359238c7 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/MetadataDasPeerCustodyTracker.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/MetadataDasPeerCustodyTracker.java @@ -26,16 +26,16 @@ public class MetadataDasPeerCustodyTracker private final Map connectedPeerSubnetCount = new ConcurrentHashMap<>(); @Override - public void onConnected(Eth2Peer peer) { + public void onConnected(final Eth2Peer peer) { peer.subscribeDisconnect((__, ___) -> peerDisconnected(peer)); peer.subscribeMetadataUpdates(this::onPeerMetadataUpdate); } - private void peerDisconnected(Eth2Peer peer) { + private void peerDisconnected(final Eth2Peer peer) { connectedPeerSubnetCount.remove(peer.getDiscoveryNodeId().orElseThrow()); } - private void onPeerMetadataUpdate(Eth2Peer peer, MetadataMessage metadata) { + private void onPeerMetadataUpdate(final Eth2Peer peer, final MetadataMessage metadata) { metadata .getOptionalCustodySubnetCount() .ifPresent( @@ -45,7 +45,7 @@ private void onPeerMetadataUpdate(Eth2Peer peer, MetadataMessage metadata) { } @Override - public int getCustodyCountForPeer(UInt256 nodeId) { + public int getCustodyCountForPeer(final UInt256 nodeId) { return connectedPeerSubnetCount.getOrDefault(nodeId, 0); } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/PeerChainValidator.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/PeerChainValidator.java index 21193ff0a16..ee30fe881ab 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/PeerChainValidator.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/PeerChainValidator.java @@ -59,7 +59,7 @@ private PeerChainValidator( final LabelledMetric validationCounter = metricsSystem.createLabelledCounter( TekuMetricCategory.NETWORK, - "peer_chain_validation_attempts", + "peer_chain_validation_attempts_total", "Number of peers chain verification has been performed on", "status"); validationStartedCounter = validationCounter.labels("started"); @@ -253,7 +253,7 @@ private boolean remoteEpochIsInvalid( } private SafeFuture verifyFinalizedCheckpointsAreTheSame( - AnchorPoint finalizedCheckpoint, final PeerStatus status) { + final AnchorPoint finalizedCheckpoint, final PeerStatus status) { final boolean chainsAreConsistent = Objects.equals(finalizedCheckpoint.getRoot(), status.getFinalizedRoot()); return SafeFuture.completedFuture(chainsAreConsistent); @@ -285,7 +285,7 @@ private SafeFuture verifyPeersFinalizedCheckpointIsCanonical( } private SafeFuture verifyPeerAgreesWithOurFinalizedCheckpoint( - final Eth2Peer peer, AnchorPoint finalized) { + final Eth2Peer peer, final AnchorPoint finalized) { final UInt64 finalizedEpochSlot = finalized.getEpochStartSlot(); if (finalizedEpochSlot.equals(SpecConfig.GENESIS_SLOT)) { // Assume that our genesis blocks match because we've already verified the fork diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/RequestApproval.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/RequestApproval.java index 94455725fdd..67b54ca2e9f 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/RequestApproval.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/RequestApproval.java @@ -21,7 +21,7 @@ public class RequestApproval { private final RequestsKey requestKey; private final long objectsCount; - private RequestApproval(RequestsKey requestKey, long objectsCount) { + private RequestApproval(final RequestsKey requestKey, final long objectsCount) { this.requestKey = requestKey; this.objectsCount = objectsCount; } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/RequestsKey.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/RequestsKey.java index 626e5517f90..950a531bc34 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/RequestsKey.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/peers/RequestsKey.java @@ -14,48 +14,15 @@ package tech.pegasys.teku.networking.eth2.peers; import java.util.Comparator; -import java.util.Objects; import org.jetbrains.annotations.NotNull; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -public class RequestsKey implements Comparable { - private final UInt64 timeSeconds; - private final int requestId; - - public RequestsKey(final UInt64 timeSeconds, final int requestId) { - this.timeSeconds = timeSeconds; - this.requestId = requestId; - } - - public UInt64 getTimeSeconds() { - return timeSeconds; - } - - public int getRequestId() { - return requestId; - } - - @Override - public int hashCode() { - return Objects.hash(timeSeconds, requestId); - } - - @Override - public boolean equals(final Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - final RequestsKey that = (RequestsKey) o; - return Objects.equals(this.timeSeconds, that.timeSeconds) && this.requestId == that.requestId; - } +public record RequestsKey(UInt64 timeSeconds, int requestId) implements Comparable { @Override - public int compareTo(@NotNull RequestsKey other) { - return Comparator.comparing(RequestsKey::getTimeSeconds) - .thenComparingInt(RequestsKey::getRequestId) + public int compareTo(final @NotNull RequestsKey other) { + return Comparator.comparing(RequestsKey::timeSeconds) + .thenComparingInt(RequestsKey::requestId) .compare(this, other); } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/BeaconChainMethods.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/BeaconChainMethods.java index 05a2670c584..bfb6622ff59 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/BeaconChainMethods.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/BeaconChainMethods.java @@ -43,9 +43,9 @@ import tech.pegasys.teku.networking.eth2.rpc.core.methods.VersionedEth2RpcMethod; import tech.pegasys.teku.networking.p2p.rpc.RpcMethod; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecFeature; import tech.pegasys.teku.spec.SpecMilestone; -import tech.pegasys.teku.spec.config.SpecConfigDeneb; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.features.Eip7594; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSidecar; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; @@ -327,8 +327,7 @@ private static Eth2RpcMethod createGoodBye( RpcContextCodec.forkDigest(spec, recentChainData, ForkDigestPayloadContext.BLOB_SIDECAR); final BlobSidecarsByRootMessageHandler blobSidecarsByRootHandler = - new BlobSidecarsByRootMessageHandler( - spec, getSpecConfigDeneb(spec), metricsSystem, combinedChainDataClient); + new BlobSidecarsByRootMessageHandler(spec, metricsSystem, combinedChainDataClient); final BlobSidecarsByRootRequestMessageSchema blobSidecarsByRootRequestMessageSchema = SchemaDefinitionsDeneb.required( spec.forMilestone(SpecMilestone.DENEB).getSchemaDefinitions()) @@ -369,8 +368,7 @@ private static Eth2RpcMethod createGoodBye( RpcContextCodec.forkDigest(spec, recentChainData, ForkDigestPayloadContext.BLOB_SIDECAR); final BlobSidecarsByRangeMessageHandler blobSidecarsByRangeHandler = - new BlobSidecarsByRangeMessageHandler( - spec, getSpecConfigDeneb(spec), metricsSystem, combinedChainDataClient); + new BlobSidecarsByRangeMessageHandler(spec, metricsSystem, combinedChainDataClient); return Optional.of( new SingleProtocolEth2RpcMethod<>( @@ -397,7 +395,7 @@ private static Eth2RpcMethod createGoodBye( final RpcEncoding rpcEncoding, final RecentChainData recentChainData, final DasReqRespLogger dasLogger) { - if (!spec.isMilestoneSupported(SpecMilestone.EIP7594)) { + if (!spec.isFeatureScheduled(SpecFeature.EIP7594)) { return Optional.empty(); } @@ -411,7 +409,7 @@ private static Eth2RpcMethod createGoodBye( final DataColumnSidecarsByRootRequestMessageSchema dataColumnSidecarsByRootRequestMessageSchema = SchemaDefinitionsEip7594.required( - spec.forMilestone(SpecMilestone.EIP7594).getSchemaDefinitions()) + spec.forMilestone(SpecMilestone.ELECTRA).getSchemaDefinitions()) .getDataColumnSidecarsByRootRequestMessageSchema(); return Optional.of( @@ -439,14 +437,14 @@ private static Eth2RpcMethod createGoodBye( final RecentChainData recentChainData, final DasReqRespLogger dasLogger) { - if (!spec.isMilestoneSupported(SpecMilestone.EIP7594)) { + if (!spec.isFeatureScheduled(SpecFeature.EIP7594)) { return Optional.empty(); } final DataColumnSidecarsByRangeRequestMessage.DataColumnSidecarsByRangeRequestMessageSchema requestType = SchemaDefinitionsEip7594.required( - spec.forMilestone(SpecMilestone.EIP7594).getSchemaDefinitions()) + spec.forMilestone(SpecMilestone.ELECTRA).getSchemaDefinitions()) .getDataColumnSidecarsByRangeRequestMessageSchema(); final RpcContextCodec forkDigestContextCodec = @@ -506,12 +504,12 @@ private static Eth2RpcMethod createMetadata( final List> versionedMethods = new ArrayList<>(); - if (spec.isMilestoneSupported(SpecMilestone.EIP7594)) { + if (spec.isFeatureScheduled(SpecFeature.EIP7594)) { final SszSchema eip7594MetadataSchema = SszSchema.as( MetadataMessage.class, - spec.forMilestone(SpecMilestone.EIP7594) - .getSchemaDefinitions() + SchemaDefinitionsEip7594.required( + spec.forMilestone(SpecMilestone.ELECTRA).getSchemaDefinitions()) .getMetadataMessageSchema()); final RpcContextCodec eip7594ContextCodec = RpcContextCodec.noop(eip7594MetadataSchema); @@ -584,12 +582,8 @@ private static Eth2RpcMethod createPing( spec.getNetworkingConfig()); } - private static SpecConfigDeneb getSpecConfigDeneb(final Spec spec) { - return SpecConfigDeneb.required(spec.forMilestone(SpecMilestone.DENEB).getConfig()); - } - - private static SpecConfigEip7594 getSpecConfigEip7594(final Spec spec) { - return SpecConfigEip7594.required(spec.forMilestone(SpecMilestone.EIP7594).getConfig()); + private static Eip7594 getSpecConfigEip7594(final Spec spec) { + return Eip7594.required(spec.forMilestone(SpecMilestone.ELECTRA).getConfig()); } public Collection> all() { diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/AbstractBlobSidecarsValidator.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/AbstractBlobSidecarsValidator.java index 51a4748c941..368f50d5e32 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/AbstractBlobSidecarsValidator.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/AbstractBlobSidecarsValidator.java @@ -13,6 +13,7 @@ package tech.pegasys.teku.networking.eth2.rpc.beaconchain.methods; +import static tech.pegasys.teku.networking.eth2.rpc.beaconchain.methods.BlobSidecarsResponseInvalidResponseException.InvalidResponseType.BLOB_SIDECAR_INCLUSION_PROOF_VERIFICATION_FAILED; import static tech.pegasys.teku.networking.eth2.rpc.beaconchain.methods.BlobSidecarsResponseInvalidResponseException.InvalidResponseType.BLOB_SIDECAR_KZG_VERIFICATION_FAILED; import org.apache.logging.log4j.LogManager; @@ -21,6 +22,7 @@ import tech.pegasys.teku.networking.p2p.peer.Peer; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; +import tech.pegasys.teku.spec.logic.versions.deneb.helpers.MiscHelpersDeneb; public class AbstractBlobSidecarsValidator { @@ -43,6 +45,13 @@ protected void verifyKzg(final BlobSidecar blobSidecar) { } } + protected void verifyInclusionProof(final BlobSidecar blobSidecar) { + if (!verifyBlobSidecarInclusionProof(blobSidecar)) { + throw new BlobSidecarsResponseInvalidResponseException( + peer, BLOB_SIDECAR_INCLUSION_PROOF_VERIFICATION_FAILED); + } + } + private boolean verifyBlobKzgProof(final BlobSidecar blobSidecar) { try { return spec.atSlot(blobSidecar.getSlot()).miscHelpers().verifyBlobKzgProof(kzg, blobSidecar); @@ -52,4 +61,17 @@ private boolean verifyBlobKzgProof(final BlobSidecar blobSidecar) { peer, BLOB_SIDECAR_KZG_VERIFICATION_FAILED, ex); } } + + private boolean verifyBlobSidecarInclusionProof(final BlobSidecar blobSidecar) { + try { + return MiscHelpersDeneb.required(spec.atSlot(blobSidecar.getSlot()).miscHelpers()) + .verifyBlobSidecarMerkleProof(blobSidecar); + } catch (final Exception ex) { + LOG.debug( + "Block inclusion proof verification failed for BlobSidecar {}", + blobSidecar.toLogString()); + throw new BlobSidecarsResponseInvalidResponseException( + peer, BLOB_SIDECAR_INCLUSION_PROOF_VERIFICATION_FAILED, ex); + } + } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/AbstractDataColumnSidecarValidator.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/AbstractDataColumnSidecarValidator.java index 5f41ae8b173..af43c493668 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/AbstractDataColumnSidecarValidator.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/AbstractDataColumnSidecarValidator.java @@ -21,6 +21,7 @@ import tech.pegasys.teku.networking.p2p.peer.Peer; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSidecar; +import tech.pegasys.teku.spec.logic.versions.feature.eip7594.helpers.MiscHelpersEip7594; public abstract class AbstractDataColumnSidecarValidator { @@ -45,8 +46,7 @@ void verifyKzgProof(final DataColumnSidecar dataColumnSidecar) { private boolean verifyDataColumnSidecarKzgProof(final DataColumnSidecar dataColumnSidecar) { try { - return spec.atSlot(dataColumnSidecar.getSlot()) - .miscHelpers() + return MiscHelpersEip7594.required(spec.atSlot(dataColumnSidecar.getSlot()).miscHelpers()) .verifyDataColumnSidecarKzgProof(kzg, dataColumnSidecar); } catch (final Exception ex) { LOG.debug( @@ -65,8 +65,7 @@ void verifyInclusionProof(final DataColumnSidecar dataColumnSidecar) { private boolean verifyDataColumnSidecarInclusionProof(final DataColumnSidecar dataColumnSidecar) { try { - return spec.atSlot(dataColumnSidecar.getSlot()) - .miscHelpers() + return MiscHelpersEip7594.required(spec.atSlot(dataColumnSidecar.getSlot()).miscHelpers()) .verifyDataColumnSidecarInclusionProof(dataColumnSidecar); } catch (final Exception ex) { LOG.debug( diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BeaconBlocksByRangeMessageHandler.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BeaconBlocksByRangeMessageHandler.java index 07d9d1c0cf7..b84454074d7 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BeaconBlocksByRangeMessageHandler.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BeaconBlocksByRangeMessageHandler.java @@ -165,7 +165,6 @@ private SafeFuture sendMatchingBlocks( final UInt64 startSlot = message.getStartSlot(); final UInt64 count = message.getCount(); final UInt64 step = message.getStep(); - final UInt64 endSlot = startSlot.plus(step.times(count)).minus(ONE); return combinedChainDataClient .getEarliestAvailableBlockSlot() @@ -183,7 +182,7 @@ private SafeFuture sendMatchingBlocks( .map(MinimalBeaconBlockSummary::getSlot) .orElse(ZERO); final NavigableMap hotRoots; - if (combinedChainDataClient.isFinalized(endSlot)) { + if (combinedChainDataClient.isFinalized(message.getMaxSlot())) { // All blocks are finalized so skip scanning the protoarray hotRoots = new TreeMap<>(); } else { @@ -195,8 +194,12 @@ private SafeFuture sendMatchingBlocks( // finalized // so we don't need to worry about inconsistent blocks final UInt64 headSlot = hotRoots.isEmpty() ? headBlockSlot : hotRoots.lastKey(); - return sendNextBlock( - new RequestState(startSlot, step, count, headSlot, hotRoots, callback)); + final RequestState initialState = + new RequestState(startSlot, step, count, headSlot, hotRoots, callback); + if (initialState.isComplete()) { + return SafeFuture.completedFuture(initialState); + } + return sendNextBlock(initialState); }); } @@ -220,7 +223,11 @@ private SafeFuture processNextBlock(final RequestState requestState) { // Ensure blocks are loaded off of the event thread return requestState .loadNextBlock() - .thenCompose(block -> handleLoadedBlock(requestState, block)); + .thenCompose( + block -> { + requestState.decrementRemainingBlocks(); + return handleLoadedBlock(requestState, block); + }); } /** Sends the block and returns true if the request is now complete. */ @@ -241,12 +248,14 @@ private SafeFuture handleLoadedBlock( } private class RequestState { + private final UInt64 headSlot; private final ResponseCallback callback; private final UInt64 step; private final NavigableMap knownBlockRoots; private UInt64 currentSlot; private UInt64 remainingBlocks; + private final AtomicInteger sentBlocks = new AtomicInteger(0); RequestState( @@ -258,9 +267,7 @@ private class RequestState { final ResponseCallback callback) { this.currentSlot = startSlot; this.knownBlockRoots = knownBlockRoots; - // Minus 1 to account for sending the block at startSlot. - // We only decrement this when moving to the next slot but we're already at the first slot - this.remainingBlocks = count.minus(ONE); + this.remainingBlocks = count; this.step = step; this.headSlot = headSlot; this.callback = callback; @@ -287,8 +294,11 @@ SafeFuture sendBlock(final SignedBeaconBlock block) { return callback.respond(block).thenRun(sentBlocks::incrementAndGet); } + void decrementRemainingBlocks() { + remainingBlocks = remainingBlocks.minusMinZero(1); + } + void incrementCurrentSlot() { - remainingBlocks = remainingBlocks.minus(ONE); currentSlot = currentSlot.plus(step); } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BeaconBlocksByRootMessageHandler.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BeaconBlocksByRootMessageHandler.java index 9a29eff193d..f254a81ca7a 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BeaconBlocksByRootMessageHandler.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BeaconBlocksByRootMessageHandler.java @@ -71,26 +71,29 @@ public BeaconBlocksByRootMessageHandler( } @Override - public void onIncomingMessage( - final String protocolId, - final Eth2Peer peer, - final BeaconBlocksByRootRequestMessage message, - final ResponseCallback callback) { - LOG.trace( - "Peer {} requested {} BeaconBlocks with roots: {}", peer.getId(), message.size(), message); - + public Optional validateRequest( + final String protocolId, final BeaconBlocksByRootRequestMessage request) { final UInt64 maxRequestBlocks = getMaxRequestBlocks(); - if (message.size() > maxRequestBlocks.intValue()) { + if (request.size() > maxRequestBlocks.intValue()) { requestCounter.labels("count_too_big").inc(); - callback.completeWithErrorResponse( + return Optional.of( new RpcException( INVALID_REQUEST_CODE, "Only a maximum of " + maxRequestBlocks + " blocks can be requested per request")); - return; } - SafeFuture future = SafeFuture.COMPLETE; + return Optional.empty(); + } + + @Override + public void onIncomingMessage( + final String protocolId, + final Eth2Peer peer, + final BeaconBlocksByRootRequestMessage message, + final ResponseCallback callback) { + LOG.trace( + "Peer {} requested {} BeaconBlocks with roots: {}", peer.getId(), message.size(), message); final Optional blocksRequestApproval = peer.approveBlocksRequest(callback, message.size()); @@ -104,7 +107,9 @@ public void onIncomingMessage( totalBlocksRequestedCounter.inc(message.size()); final AtomicInteger sentBlocks = new AtomicInteger(0); - for (SszBytes32 blockRoot : message) { + SafeFuture future = SafeFuture.COMPLETE; + + for (final SszBytes32 blockRoot : message) { future = future.thenCompose( __ -> diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRangeListenerValidatingProxy.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRangeListenerValidatingProxy.java index 4faad1e3cf6..e697b9564d5 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRangeListenerValidatingProxy.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRangeListenerValidatingProxy.java @@ -71,6 +71,7 @@ public SafeFuture onResponse(final BlobSidecar blobSidecar) { final BlobSidecarSummary blobSidecarSummary = BlobSidecarSummary.create(blobSidecar); verifyBlobSidecarIsAfterLast(blobSidecarSummary); + verifyInclusionProof(blobSidecar); verifyKzg(blobSidecar); maybeLastBlobSidecarSummary = Optional.of(blobSidecarSummary); diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRangeMessageHandler.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRangeMessageHandler.java index ab4d0797110..55ba2e5a484 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRangeMessageHandler.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRangeMessageHandler.java @@ -58,18 +58,15 @@ public class BlobSidecarsByRangeMessageHandler private static final Logger LOG = LogManager.getLogger(); private final Spec spec; - private final SpecConfigDeneb specConfigDeneb; private final CombinedChainDataClient combinedChainDataClient; private final LabelledMetric requestCounter; private final Counter totalBlobSidecarsRequestedCounter; public BlobSidecarsByRangeMessageHandler( final Spec spec, - final SpecConfigDeneb specConfigDeneb, final MetricsSystem metricsSystem, final CombinedChainDataClient combinedChainDataClient) { this.spec = spec; - this.specConfigDeneb = specConfigDeneb; this.combinedChainDataClient = combinedChainDataClient; requestCounter = metricsSystem.createLabelledCounter( @@ -84,6 +81,31 @@ public BlobSidecarsByRangeMessageHandler( "Total number of blob sidecars requested in accepted blob sidecars by range requests from peers"); } + @Override + public Optional validateRequest( + final String protocolId, final BlobSidecarsByRangeRequestMessage request) { + + final SpecConfigDeneb specConfig = + SpecConfigDeneb.required(spec.atSlot(request.getMaxSlot()).getConfig()); + + final int maxRequestBlobSidecars = specConfig.getMaxRequestBlobSidecars(); + final int maxBlobsPerBlock = specConfig.getMaxBlobsPerBlock(); + + final long requestedCount = calculateRequestedCount(request, maxBlobsPerBlock); + + if (requestedCount > maxRequestBlobSidecars) { + requestCounter.labels("count_too_big").inc(); + return Optional.of( + new RpcException( + INVALID_REQUEST_CODE, + String.format( + "Only a maximum of %s blob sidecars can be requested per request", + maxRequestBlobSidecars))); + } + + return Optional.empty(); + } + @Override public void onIncomingMessage( final String protocolId, @@ -99,24 +121,11 @@ public void onIncomingMessage( message.getCount(), startSlot); - final UInt64 maxBlobsPerBlock = UInt64.valueOf(specConfigDeneb.getMaxBlobsPerBlock()); - final UInt64 maxRequestBlobSidecars = - UInt64.valueOf(specConfigDeneb.getMaxRequestBlobSidecars()); - final UInt64 requestedCount = message.getCount().times(maxBlobsPerBlock); - - if (requestedCount.isGreaterThan(maxRequestBlobSidecars)) { - requestCounter.labels("count_too_big").inc(); - callback.completeWithErrorResponse( - new RpcException( - INVALID_REQUEST_CODE, - String.format( - "Only a maximum of %s blob sidecars can be requested per request", - maxRequestBlobSidecars))); - return; - } + final SpecConfigDeneb specConfig = SpecConfigDeneb.required(spec.atSlot(endSlot).getConfig()); + final long requestedCount = calculateRequestedCount(message, specConfig.getMaxBlobsPerBlock()); final Optional blobSidecarsRequestApproval = - peer.approveBlobSidecarsRequest(callback, requestedCount.longValue()); + peer.approveBlobSidecarsRequest(callback, requestedCount); if (!peer.approveRequest() || blobSidecarsRequestApproval.isEmpty()) { requestCounter.labels("rate_limited").inc(); @@ -158,12 +167,12 @@ public void onIncomingMessage( final RequestState initialState = new RequestState( callback, - maxRequestBlobSidecars, startSlot, endSlot, canonicalHotRoots, - finalizedSlot); - if (initialState.isComplete()) { + finalizedSlot, + specConfig.getMaxRequestBlobSidecars()); + if (message.getCount().isZero()) { return SafeFuture.completedFuture(initialState); } return sendBlobSidecars(initialState); @@ -171,7 +180,7 @@ public void onIncomingMessage( .finish( requestState -> { final int sentBlobSidecars = requestState.sentBlobSidecars.get(); - if (sentBlobSidecars != requestedCount.longValue()) { + if (sentBlobSidecars != requestedCount) { peer.adjustBlobSidecarsRequest(blobSidecarsRequestApproval.get(), sentBlobSidecars); } LOG.trace("Sent {} blob sidecars to peer {}.", sentBlobSidecars, peer.getId()); @@ -183,6 +192,11 @@ public void onIncomingMessage( }); } + private long calculateRequestedCount( + final BlobSidecarsByRangeRequestMessage message, final int maxBlobsPerBlock) { + return maxBlobsPerBlock * message.getCount().longValue(); + } + private boolean checkBlobSidecarsAreAvailable( final Optional earliestAvailableSidecarSlot, final UInt64 requestSlot) { return earliestAvailableSidecarSlot @@ -226,13 +240,14 @@ private void handleProcessingRequestError( @VisibleForTesting class RequestState { - private final AtomicInteger sentBlobSidecars = new AtomicInteger(0); private final ResponseCallback callback; - private final UInt64 maxRequestBlobSidecars; private final UInt64 startSlot; private final UInt64 endSlot; private final UInt64 finalizedSlot; private final Map canonicalHotRoots; + private final int maxRequestBlobSidecars; + + private final AtomicInteger sentBlobSidecars = new AtomicInteger(0); // since our storage stores hot and finalized blobs on the same "table", this iterator can span // over hot and finalized blobs @@ -241,17 +256,17 @@ class RequestState { RequestState( final ResponseCallback callback, - final UInt64 maxRequestBlobSidecars, final UInt64 startSlot, final UInt64 endSlot, final Map canonicalHotRoots, - final UInt64 finalizedSlot) { + final UInt64 finalizedSlot, + final int maxRequestBlobSidecars) { this.callback = callback; - this.maxRequestBlobSidecars = maxRequestBlobSidecars; this.startSlot = startSlot; this.endSlot = endSlot; this.finalizedSlot = finalizedSlot; this.canonicalHotRoots = canonicalHotRoots; + this.maxRequestBlobSidecars = maxRequestBlobSidecars; } SafeFuture sendBlobSidecar(final BlobSidecar blobSidecar) { @@ -302,8 +317,7 @@ private boolean isCanonicalHotBlobSidecar( } boolean isComplete() { - return endSlot.isLessThan(startSlot) - || blobSidecarKeysIterator.map(iterator -> !iterator.hasNext()).orElse(false); + return blobSidecarKeysIterator.map(iterator -> !iterator.hasNext()).orElse(false); } } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRootMessageHandler.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRootMessageHandler.java index 0ca9071724c..29f1d8ee320 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRootMessageHandler.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRootMessageHandler.java @@ -52,7 +52,6 @@ public class BlobSidecarsByRootMessageHandler private static final Logger LOG = LogManager.getLogger(); private final Spec spec; - private final SpecConfigDeneb specConfigDeneb; private final CombinedChainDataClient combinedChainDataClient; private final LabelledMetric requestCounter; @@ -60,11 +59,9 @@ public class BlobSidecarsByRootMessageHandler public BlobSidecarsByRootMessageHandler( final Spec spec, - final SpecConfigDeneb specConfigDeneb, final MetricsSystem metricsSystem, final CombinedChainDataClient combinedChainDataClient) { this.spec = spec; - this.specConfigDeneb = specConfigDeneb; this.combinedChainDataClient = combinedChainDataClient; requestCounter = metricsSystem.createLabelledCounter( @@ -82,7 +79,7 @@ public BlobSidecarsByRootMessageHandler( @Override public Optional validateRequest( final String protocolId, final BlobSidecarsByRootRequestMessage request) { - final int maxRequestBlobSidecars = specConfigDeneb.getMaxRequestBlobSidecars(); + final int maxRequestBlobSidecars = getMaxRequestBlobSidecars(); if (request.size() > maxRequestBlobSidecars) { requestCounter.labels("count_too_big").inc(); return Optional.of( @@ -156,6 +153,12 @@ public void onIncomingMessage( }); } + private int getMaxRequestBlobSidecars() { + final UInt64 epoch = + combinedChainDataClient.getRecentChainData().getCurrentEpoch().orElse(UInt64.ZERO); + return SpecConfigDeneb.required(spec.atEpoch(epoch).getConfig()).getMaxRequestBlobSidecars(); + } + private UInt64 getFinalizedEpoch() { return combinedChainDataClient .getFinalizedBlock() diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRootValidator.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRootValidator.java index 709fe1ac029..ea4e96fe2b0 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRootValidator.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRootValidator.java @@ -45,6 +45,7 @@ public void validate(final BlobSidecar blobSidecar) { peer, InvalidResponseType.BLOB_SIDECAR_UNEXPECTED_IDENTIFIER); } + verifyInclusionProof(blobSidecar); verifyKzg(blobSidecar); } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsResponseInvalidResponseException.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsResponseInvalidResponseException.java index fca4a3cde7e..6644ad36608 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsResponseInvalidResponseException.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsResponseInvalidResponseException.java @@ -35,6 +35,8 @@ public BlobSidecarsResponseInvalidResponseException( public enum InvalidResponseType { BLOB_SIDECAR_KZG_VERIFICATION_FAILED("KZG verification for BlobSidecar has failed"), + BLOB_SIDECAR_INCLUSION_PROOF_VERIFICATION_FAILED( + "Block inclusion proof verification for BlobSidecar has failed"), BLOB_SIDECAR_SLOT_NOT_IN_RANGE("BlobSidecar slot not in requested range"), BLOB_SIDECAR_UNEXPECTED_INDEX("BlobSidecar with unexpected index"), BLOB_SIDECAR_UNKNOWN_PARENT( @@ -44,7 +46,7 @@ public enum InvalidResponseType { private final String description; - InvalidResponseType(String description) { + InvalidResponseType(final String description) { this.description = description; } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlocksByRangeListenerWrapper.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlocksByRangeListenerWrapper.java index 3a565118153..8c2795cbeaa 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlocksByRangeListenerWrapper.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlocksByRangeListenerWrapper.java @@ -36,10 +36,10 @@ public class BlocksByRangeListenerWrapper implements RpcResponseListener maybeSlotOfLastBlock = Optional.empty(); public BlocksByRangeListenerWrapper( - Peer peer, - RpcResponseListener blockResponseListener, - UInt64 startSlot, - UInt64 count) { + final Peer peer, + final RpcResponseListener blockResponseListener, + final UInt64 startSlot, + final UInt64 count) { this.peer = peer; this.blockResponseListener = blockResponseListener; this.startSlot = startSlot; @@ -47,7 +47,7 @@ public BlocksByRangeListenerWrapper( } @Override - public SafeFuture onResponse(SignedBeaconBlock response) { + public SafeFuture onResponse(final SignedBeaconBlock response) { return SafeFuture.of( () -> { UInt64 blockSlot = response.getSlot(); @@ -71,11 +71,11 @@ public SafeFuture onResponse(SignedBeaconBlock response) { }); } - private boolean blockSlotIsInRange(UInt64 blockSlot) { + private boolean blockSlotIsInRange(final UInt64 blockSlot) { return blockSlot.isGreaterThanOrEqualTo(startSlot) && blockSlot.isLessThanOrEqualTo(endSlot); } - private boolean blockSlotGreaterThanPreviousBlockSlot(UInt64 blockSlot) { + private boolean blockSlotGreaterThanPreviousBlockSlot(final UInt64 blockSlot) { if (maybeSlotOfLastBlock.isEmpty()) { return true; } @@ -84,7 +84,7 @@ private boolean blockSlotGreaterThanPreviousBlockSlot(UInt64 blockSlot) { return blockSlot.isGreaterThan(lastBlockSlot); } - private boolean blockParentRootMatches(Bytes32 blockParentRoot) { + private boolean blockParentRootMatches(final Bytes32 blockParentRoot) { if (maybeRootOfLastBlock.isEmpty()) { return true; } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlocksByRangeResponseInvalidResponseException.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlocksByRangeResponseInvalidResponseException.java index 4e8d5244736..da2d51497b8 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlocksByRangeResponseInvalidResponseException.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlocksByRangeResponseInvalidResponseException.java @@ -38,7 +38,7 @@ public enum InvalidResponseType { private final String description; - InvalidResponseType(String description) { + InvalidResponseType(final String description) { this.description = description; } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/DataColumnSidecarsByRangeMessageHandler.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/DataColumnSidecarsByRangeMessageHandler.java index e56ce2e35a0..747bf6e6a75 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/DataColumnSidecarsByRangeMessageHandler.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/DataColumnSidecarsByRangeMessageHandler.java @@ -42,7 +42,7 @@ import tech.pegasys.teku.networking.eth2.rpc.core.RpcException.ResourceUnavailableException; import tech.pegasys.teku.networking.p2p.rpc.StreamClosedException; import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.features.Eip7594; import tech.pegasys.teku.spec.datastructures.blobs.versions.eip7594.DataColumnSidecar; import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.DataColumnSidecarsByRangeRequestMessage; import tech.pegasys.teku.spec.datastructures.util.DataColumnSlotAndIdentifier; @@ -63,7 +63,7 @@ public class DataColumnSidecarsByRangeMessageHandler private static final Logger LOG = LogManager.getLogger(); private final Spec spec; - private final SpecConfigEip7594 specConfigEip7594; + private final Eip7594 specConfigEip7594; private final CombinedChainDataClient combinedChainDataClient; private final LabelledMetric requestCounter; private final Counter totalDataColumnSidecarsRequestedCounter; @@ -71,7 +71,7 @@ public class DataColumnSidecarsByRangeMessageHandler public DataColumnSidecarsByRangeMessageHandler( final Spec spec, - final SpecConfigEip7594 specConfigEip7594, + final Eip7594 specConfigEip7594, final MetricsSystem metricsSystem, final CombinedChainDataClient combinedChainDataClient, final DasReqRespLogger dasLogger) { diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/DataColumnSidecarsResponseInvalidResponseException.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/DataColumnSidecarsResponseInvalidResponseException.java index c441d8d487f..84d678428ee 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/DataColumnSidecarsResponseInvalidResponseException.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/DataColumnSidecarsResponseInvalidResponseException.java @@ -44,7 +44,7 @@ public enum InvalidResponseType { private final String description; - InvalidResponseType(String description) { + InvalidResponseType(final String description) { this.description = description; } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/LoggingResponseCallback.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/LoggingResponseCallback.java index 7ba5984b843..c25f4d94fca 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/LoggingResponseCallback.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/LoggingResponseCallback.java @@ -22,13 +22,13 @@ public record LoggingResponseCallback( ResponseCallback callback, ReqRespResponseLogger logger) implements ResponseCallback { @Override - public SafeFuture respond(T data) { + public SafeFuture respond(final T data) { logger.onNextItem(data); return callback.respond(data); } @Override - public void respondAndCompleteSuccessfully(T data) { + public void respondAndCompleteSuccessfully(final T data) { logger.onNextItem(data); logger.onComplete(); callback.respondAndCompleteSuccessfully(data); @@ -41,13 +41,13 @@ public void completeSuccessfully() { } @Override - public void completeWithErrorResponse(RpcException error) { + public void completeWithErrorResponse(final RpcException error) { logger.onError(error); callback.completeWithErrorResponse(error); } @Override - public void completeWithUnexpectedError(Throwable error) { + public void completeWithUnexpectedError(final Throwable error) { logger.onError(error); callback.completeWithUnexpectedError(error); } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/MetadataMessageHandler.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/MetadataMessageHandler.java index 651a3c999fc..c968404a96f 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/MetadataMessageHandler.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/MetadataMessageHandler.java @@ -28,7 +28,8 @@ public class MetadataMessageHandler private final Spec spec; private final MetadataMessagesFactory metadataMessagesFactory; - public MetadataMessageHandler(final Spec spec, MetadataMessagesFactory metadataMessagesFactory) { + public MetadataMessageHandler( + final Spec spec, final MetadataMessagesFactory metadataMessagesFactory) { this.spec = spec; this.metadataMessagesFactory = metadataMessagesFactory; } @@ -36,9 +37,9 @@ public MetadataMessageHandler(final Spec spec, MetadataMessagesFactory metadataM @Override public void onIncomingMessage( final String protocolId, - Eth2Peer peer, - EmptyMessage message, - ResponseCallback callback) { + final Eth2Peer peer, + final EmptyMessage message, + final ResponseCallback callback) { if (!peer.approveRequest()) { return; } @@ -48,9 +49,9 @@ public void onIncomingMessage( switch (protocolVersion) { case 1 -> SpecMilestone.PHASE0; case 2 -> SpecMilestone.ALTAIR; - case 3 -> SpecMilestone.EIP7594; - default -> throw new IllegalStateException( - "Unexpected protocol version: " + protocolVersion); + case 3 -> SpecMilestone.ELECTRA; + default -> + throw new IllegalStateException("Unexpected protocol version: " + protocolVersion); }; final MetadataMessageSchema schema = spec.forMilestone(milestone).getSchemaDefinitions().getMetadataMessageSchema(); diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/MetadataMessagesFactory.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/MetadataMessagesFactory.java index 0965c3f298d..bafd5bfb82e 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/MetadataMessagesFactory.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/MetadataMessagesFactory.java @@ -28,17 +28,19 @@ public class MetadataMessagesFactory { private Iterable syncCommitteeSubnetIds = Collections.emptyList(); private Optional custodySubnetCount = Optional.empty(); - public synchronized void updateAttestationSubnetIds(Iterable attestationSubnetIds) { + public synchronized void updateAttestationSubnetIds( + final Iterable attestationSubnetIds) { this.attestationSubnetIds = attestationSubnetIds; handleUpdate(); } - public synchronized void updateSyncCommitteeSubnetIds(Iterable syncCommitteeSubnetIds) { + public synchronized void updateSyncCommitteeSubnetIds( + final Iterable syncCommitteeSubnetIds) { this.syncCommitteeSubnetIds = syncCommitteeSubnetIds; handleUpdate(); } - public synchronized void updateCustodySubnetCount(UInt64 custodySubnetCount) { + public synchronized void updateCustodySubnetCount(final UInt64 custodySubnetCount) { this.custodySubnetCount = Optional.of(custodySubnetCount); handleUpdate(); } @@ -47,7 +49,7 @@ private void handleUpdate() { seqNumberGenerator.incrementAndGet(); } - public synchronized MetadataMessage createMetadataMessage(MetadataMessageSchema schema) { + public synchronized MetadataMessage createMetadataMessage(final MetadataMessageSchema schema) { return schema.create( getCurrentSeqNumber(), attestationSubnetIds, syncCommitteeSubnetIds, custodySubnetCount); } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/PingMessageHandler.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/PingMessageHandler.java index 5ea4a6b27bb..31157ef803f 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/PingMessageHandler.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/PingMessageHandler.java @@ -24,7 +24,7 @@ public class PingMessageHandler extends PeerRequiredLocalMessageHandler peer = peerLookup.getConnectedPeer(nodeId); requestDecoder @@ -96,10 +96,12 @@ public void readComplete(NodeId nodeId, RpcStream rpcStream) { } @Override - public void closed(NodeId nodeId, RpcStream rpcStream) {} + public void closed(final NodeId nodeId, final RpcStream rpcStream) {} private void handleRequest( - Optional peer, TRequest request, ResponseCallback callback) { + final Optional peer, + final TRequest request, + final ResponseCallback callback) { try { requestHandled.set(true); final Optional requestValidationError = @@ -127,7 +129,7 @@ private void ensureRequestReceivedWithinTimeLimit(final RpcStream stream) { if (!requestHandled.get()) { LOG.debug( "Failed to receive incoming request data within {} sec for protocol {}. Close stream.", - timeout.getSeconds(), + timeout.toSeconds(), protocolId); stream.closeAbruptly().ifExceptionGetsHereRaiseABug(); } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/Eth2OutgoingRequestHandler.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/Eth2OutgoingRequestHandler.java index b35e5e8f686..b39e2f70ad2 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/Eth2OutgoingRequestHandler.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/Eth2OutgoingRequestHandler.java @@ -110,7 +110,7 @@ public void handleInitialPayloadSent(final RpcStream stream) { } @Override - public void active(NodeId nodeId, RpcStream rpcStream) {} + public void active(final NodeId nodeId, final RpcStream rpcStream) {} @Override public void processData(final NodeId nodeId, final RpcStream rpcStream, final ByteBuf data) { @@ -166,7 +166,7 @@ private AsyncResponseProcessor getResponseProcessor(final RpcStream r }); } - private String bufToString(ByteBuf buf) { + private String bufToString(final ByteBuf buf) { final int contentSize = Integer.min(buf.readableBytes(), 1024); String bufContent = ""; if (contentSize > 0) { @@ -182,7 +182,7 @@ private String bufToString(ByteBuf buf) { } @Override - public void readComplete(NodeId nodeId, RpcStream rpcStream) { + public void readComplete(final NodeId nodeId, final RpcStream rpcStream) { if (!transferToState(READ_COMPLETE, List.of(DATA_COMPLETED, EXPECT_DATA))) { abortRequest(rpcStream, new IllegalStateException("Unexpected state: " + state)); return; @@ -197,7 +197,7 @@ public void readComplete(NodeId nodeId, RpcStream rpcStream) { } @Override - public void closed(NodeId nodeId, RpcStream rpcStream) { + public void closed(final NodeId nodeId, final RpcStream rpcStream) { if (!transferToState(CLOSED, List.of(READ_COMPLETE))) { abortRequest(rpcStream, new IllegalStateException("Unexpected state: " + state)); } @@ -207,7 +207,7 @@ public SafeFuture getCompletedFuture() { return responseHandler.getCompletedFuture(); } - private boolean transferToState(State toState, Collection fromStates) { + private boolean transferToState(final State toState, final Collection fromStates) { for (State fromState : fromStates) { if (state.compareAndSet(fromState, toState)) { return true; @@ -244,11 +244,11 @@ private void completeRequest(final RpcStream rpcStream) { .ifExceptionGetsHereRaiseABug(); } - private void abortRequest(final RpcStream rpcStream, Throwable error) { + private void abortRequest(final RpcStream rpcStream, final Throwable error) { abortRequest(rpcStream, error, false); } - private void abortRequest(final RpcStream rpcStream, Throwable error, final boolean force) { + private void abortRequest(final RpcStream rpcStream, final Throwable error, final boolean force) { if (!transferToState(ABORTED, List.of(EXPECT_DATA, DATA_COMPLETED, READ_COMPLETE)) && !force) { return; } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/Eth2RpcResponseHandler.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/Eth2RpcResponseHandler.java index e4b038518a6..07d089303f2 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/Eth2RpcResponseHandler.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/Eth2RpcResponseHandler.java @@ -78,7 +78,8 @@ public static Eth2RpcResponseHandler expectSingleResponse() { @SuppressWarnings("VoidUsed") private static SafeFuture applyError( - SafeFuture future, AtomicReference errorCapture) { + final SafeFuture future, + final AtomicReference errorCapture) { return future.thenApply( res -> { InvalidRpcResponseException error = errorCapture.get(); @@ -90,7 +91,8 @@ private static SafeFuture applyError( } private static RpcResponseListener createSingleResponseListener( - AtomicReference firstResponse, AtomicReference errorCapture) { + final AtomicReference firstResponse, + final AtomicReference errorCapture) { return response -> { if (!firstResponse.compareAndSet(null, response)) { final InvalidRpcResponseException error = @@ -112,7 +114,7 @@ public SafeFuture getResult() { } @Override - public void onCompleted(Optional error) { + public void onCompleted(final Optional error) { error.ifPresentOrElse(completed::completeExceptionally, () -> completed.complete(null)); } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/LocalMessageHandler.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/LocalMessageHandler.java index 3fe627bb504..167adac0151 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/LocalMessageHandler.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/LocalMessageHandler.java @@ -20,7 +20,7 @@ public interface LocalMessageHandler { void onIncomingMessage( final String protocolId, Optional peer, I message, ResponseCallback callback); - default Optional validateRequest(String protocolId, I request) { + default Optional validateRequest(final String protocolId, final I request) { return Optional.empty(); } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcException.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcException.java index 016049bea36..611cd103948 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcException.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcException.java @@ -65,7 +65,7 @@ public ExtraDataAppendedException() { super(INVALID_REQUEST_CODE, "Extra data appended to end of message"); } - public ExtraDataAppendedException(String details) { + public ExtraDataAppendedException(final String details) { super(INVALID_REQUEST_CODE, "Extra data appended to end of message: " + details); } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcRequestEncoder.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcRequestEncoder.java index e1feb9f2ab0..20ada283c19 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcRequestEncoder.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcRequestEncoder.java @@ -30,7 +30,7 @@ public RpcRequestEncoder(final RpcEncoding encoding) { * @param request the payload of the request * @return the encoded RPC message */ - public Bytes encodeRequest(T request) { + public Bytes encodeRequest(final T request) { return encoding.encodePayload(request); } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcResponseCallback.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcResponseCallback.java index 4b0f964b15f..6fbc488e7f0 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcResponseCallback.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcResponseCallback.java @@ -41,7 +41,7 @@ public SafeFuture respond(final TResponse data) { } @Override - public void respondAndCompleteSuccessfully(TResponse data) { + public void respondAndCompleteSuccessfully(final TResponse data) { respond(data) .thenRun(this::completeSuccessfully) .finish( diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcResponseDecoder.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcResponseDecoder.java index d7b18c47c60..e79a8317d19 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcResponseDecoder.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcResponseDecoder.java @@ -170,7 +170,7 @@ public void complete() throws RpcException { } private Optional completeDecoder( - Optional> decoder) { + final Optional> decoder) { try { if (decoder.isPresent()) { decoder.get().complete(); diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcResponseEncoder.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcResponseEncoder.java index 0a78fe20ab5..365ba46cf10 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcResponseEncoder.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcResponseEncoder.java @@ -30,13 +30,13 @@ public RpcResponseEncoder( this.contextCodec = contextCodec; } - public Bytes encodeSuccessfulResponse(TPayload response) { + public Bytes encodeSuccessfulResponse(final TPayload response) { final Bytes context = contextCodec.encodeContext(response); return Bytes.concatenate( Bytes.of(SUCCESS_RESPONSE_CODE), context, encoding.encodePayload(response)); } - public Bytes encodeErrorResponse(RpcException error) { + public Bytes encodeErrorResponse(final RpcException error) { return Bytes.concatenate( Bytes.of(error.getResponseCode()), encoding.encodePayload(error.getErrorMessage())); } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcTimeoutException.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcTimeoutException.java index 071956651f6..5a5af8f1fa8 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcTimeoutException.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcTimeoutException.java @@ -23,6 +23,6 @@ public RpcTimeoutException(final String message, final Duration timeout) { } private static String generateMessage(final String message, final Duration timeout) { - return String.format("Rpc request timed out after %d sec: %s", timeout.getSeconds(), message); + return String.format("Rpc request timed out after %d sec: %s", timeout.toSeconds(), message); } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcTimeouts.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcTimeouts.java index 1f9a592f07b..0fce1e93fd1 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcTimeouts.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcTimeouts.java @@ -34,7 +34,7 @@ public RpcTimeoutException(final String message, final Duration timeout) { } private static String generateMessage(final String message, final Duration timeout) { - return String.format("Rpc request timed out after %d sec: %s", timeout.getSeconds(), message); + return String.format("Rpc request timed out after %d sec: %s", timeout.toSeconds(), message); } } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/AbstractByteBufDecoder.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/AbstractByteBufDecoder.java index 0b118fc21e1..9581d184153 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/AbstractByteBufDecoder.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/AbstractByteBufDecoder.java @@ -33,7 +33,7 @@ public abstract class AbstractByteBufDecoder decodeOneMessage(ByteBuf in) throws TException { + public Optional decodeOneMessage(final ByteBuf in) throws TException { if (!in.isReadable()) { return Optional.empty(); } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/LengthPrefixedEncoding.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/LengthPrefixedEncoding.java index 6d6fd50ead2..a2b67375e48 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/LengthPrefixedEncoding.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/LengthPrefixedEncoding.java @@ -29,7 +29,7 @@ public class LengthPrefixedEncoding implements RpcEncoding { private static final RpcByteBufDecoder EMPTY_MESSAGE_DECODER = new RpcByteBufDecoder<>() { @Override - public Optional decodeOneMessage(ByteBuf input) { + public Optional decodeOneMessage(final ByteBuf input) { return Optional.of(EmptyMessage.EMPTY_MESSAGE); } @@ -77,7 +77,7 @@ public Bytes encodePayload(final T message) { } @Override - public RpcByteBufDecoder createDecoder(SszSchema payloadType) { + public RpcByteBufDecoder createDecoder(final SszSchema payloadType) { if (payloadType.equals(EmptyMessage.SSZ_SCHEMA)) { return getEmptyMessageDecoder(); } else { diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/LengthPrefixedPayloadDecoder.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/LengthPrefixedPayloadDecoder.java index b5dd22f021a..3ae6af92055 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/LengthPrefixedPayloadDecoder.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/LengthPrefixedPayloadDecoder.java @@ -164,7 +164,7 @@ private Optional readLengthPrefixHeader(final ByteBuf in) throws RpcExc private static class VarIntDecoder extends AbstractByteBufDecoder { @Override - protected Optional decodeOneImpl(ByteBuf in) { + protected Optional decodeOneImpl(final ByteBuf in) { long length = ByteBufExtKt.readUvarint(in); if (length < 0) { // wait for more byte to read length field @@ -174,7 +174,7 @@ protected Optional decodeOneImpl(ByteBuf in) { } @Override - protected void throwUnprocessedDataException(int dataLeft) throws RuntimeException { + protected void throwUnprocessedDataException(final int dataLeft) throws RuntimeException { // Do nothing, exceptional case is handled upstream } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/RpcEncoding.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/RpcEncoding.java index ecd7ff9d209..dc2c2d7d985 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/RpcEncoding.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/RpcEncoding.java @@ -19,7 +19,7 @@ import tech.pegasys.teku.networking.eth2.rpc.core.encodings.compression.snappy.SnappyFramedCompressor; public interface RpcEncoding { - static RpcEncoding createSszSnappyEncoding(int maxChunkSize) { + static RpcEncoding createSszSnappyEncoding(final int maxChunkSize) { return new LengthPrefixedEncoding( "ssz_snappy", RpcPayloadEncoders.createSszEncoders(), diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/compression/noop/NoopCompressor.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/compression/noop/NoopCompressor.java index 7ba39b299c7..dd076277b43 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/compression/noop/NoopCompressor.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/compression/noop/NoopCompressor.java @@ -28,13 +28,13 @@ private static class NoopDecompressor implements Decompressor { private final int uncompressedPayloadSize; private boolean disposed = false; - public NoopDecompressor(int uncompressedPayloadSize) { + public NoopDecompressor(final int uncompressedPayloadSize) { this.decoder = new NoopDecoder(uncompressedPayloadSize); this.uncompressedPayloadSize = uncompressedPayloadSize; } @Override - public Optional decodeOneMessage(ByteBuf input) throws CompressionException { + public Optional decodeOneMessage(final ByteBuf input) throws CompressionException { if (disposed) { throw new DisposedDecompressorException(); } @@ -64,7 +64,7 @@ public Bytes compress(final Bytes data) { } @Override - public Decompressor createDecompressor(int uncompressedPayloadSize) { + public Decompressor createDecompressor(final int uncompressedPayloadSize) { return new NoopDecompressor(uncompressedPayloadSize); } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/compression/noop/NoopDecoder.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/compression/noop/NoopDecoder.java index dddb4aa88d5..0283e2952af 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/compression/noop/NoopDecoder.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/compression/noop/NoopDecoder.java @@ -22,12 +22,12 @@ public class NoopDecoder extends AbstractByteBufDecoder { private final int expectedBytes; - public NoopDecoder(int expectedBytes) { + public NoopDecoder(final int expectedBytes) { this.expectedBytes = expectedBytes; } @Override - protected Optional decodeOneImpl(ByteBuf in) { + protected Optional decodeOneImpl(final ByteBuf in) { if (in.readableBytes() < expectedBytes) { return Optional.empty(); } @@ -35,7 +35,7 @@ protected Optional decodeOneImpl(ByteBuf in) { } @Override - protected void throwUnprocessedDataException(int dataLeft) throws CompressionException { + protected void throwUnprocessedDataException(final int dataLeft) throws CompressionException { throw new PayloadSmallerThanExpectedException( "The stream complete, but unprocessed data left: " + dataLeft); } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/compression/snappy/SnappyFrameDecoder.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/compression/snappy/SnappyFrameDecoder.java index f86e3484602..4e4dc45ec8c 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/compression/snappy/SnappyFrameDecoder.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/compression/snappy/SnappyFrameDecoder.java @@ -72,12 +72,12 @@ public SnappyFrameDecoder() { * uncompressed data, and if the checksums do not match, a suitable {@link * CompressionException} will be thrown */ - public SnappyFrameDecoder(boolean validateChecksums) { + public SnappyFrameDecoder(final boolean validateChecksums) { this.validateChecksums = validateChecksums; } @Override - protected Optional decodeOneImpl(ByteBuf in) throws CompressionException { + protected Optional decodeOneImpl(final ByteBuf in) throws CompressionException { if (corrupted) { in.skipBytes(in.readableBytes()); return Optional.empty(); @@ -216,12 +216,12 @@ protected Optional decodeOneImpl(ByteBuf in) throws CompressionExceptio } @Override - protected void throwUnprocessedDataException(int dataLeft) throws CompressionException { + protected void throwUnprocessedDataException(final int dataLeft) throws CompressionException { throw new PayloadSmallerThanExpectedException( "Snappy stream complete, but unprocessed data left: " + dataLeft); } - private static void checkByte(byte actual, byte expect) throws CompressionException { + private static void checkByte(final byte actual, final byte expect) throws CompressionException { if (actual != expect) { throw new CompressionException( "Unexpected stream identifier contents. Mismatched snappy protocol version?"); @@ -234,7 +234,7 @@ private static void checkByte(byte actual, byte expect) throws CompressionExcept * @param type The tag byte extracted from the stream * @return The appropriate {@link ChunkType}, defaulting to {@link ChunkType#RESERVED_UNSKIPPABLE} */ - private static ChunkType mapChunkType(byte type) { + private static ChunkType mapChunkType(final byte type) { if (type == 0) { return ChunkType.COMPRESSED_DATA; } else if (type == 1) { diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/compression/snappy/SnappyFrameEncoder.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/compression/snappy/SnappyFrameEncoder.java index c4ec31d3187..58017380991 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/compression/snappy/SnappyFrameEncoder.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/compression/snappy/SnappyFrameEncoder.java @@ -47,7 +47,7 @@ public class SnappyFrameEncoder { private final Snappy snappy = new Snappy(); private boolean started; - public Bytes encode(Bytes in) { + public Bytes encode(final Bytes in) { ByteBuf inBuf = Unpooled.wrappedBuffer(in.toArrayUnsafe()); ByteBuf outBuf = Unpooled.buffer(in.size() / 2); try { @@ -61,7 +61,7 @@ public Bytes encode(Bytes in) { } } - public void encode(ByteBuf in, ByteBuf out) { + public void encode(final ByteBuf in, final ByteBuf out) { if (!in.isReadable()) { return; } @@ -101,14 +101,15 @@ public void encode(ByteBuf in, ByteBuf out) { } } - private static void writeUnencodedChunk(ByteBuf in, ByteBuf out, int dataLength) { + private static void writeUnencodedChunk( + final ByteBuf in, final ByteBuf out, final int dataLength) { out.writeByte(1); writeChunkLength(out, dataLength + 4); calculateAndWriteChecksum(in, out); out.writeBytes(in, dataLength); } - private static void setChunkLength(ByteBuf out, int lengthIdx) { + private static void setChunkLength(final ByteBuf out, final int lengthIdx) { int chunkLength = out.writerIndex() - lengthIdx - 3; if (chunkLength >>> 24 != 0) { throw new IllegalArgumentException("compressed data too large: " + chunkLength); @@ -122,7 +123,7 @@ private static void setChunkLength(ByteBuf out, int lengthIdx) { * @param out The buffer to write to * @param chunkLength The length to write */ - private static void writeChunkLength(ByteBuf out, int chunkLength) { + private static void writeChunkLength(final ByteBuf out, final int chunkLength) { out.writeMediumLE(chunkLength); } @@ -132,7 +133,7 @@ private static void writeChunkLength(ByteBuf out, int chunkLength) { * @param slice The data to calculate the checksum for * @param out The output buffer to write the checksum to */ - private static void calculateAndWriteChecksum(ByteBuf slice, ByteBuf out) { + private static void calculateAndWriteChecksum(final ByteBuf slice, final ByteBuf out) { out.writeIntLE(calculateChecksum(slice)); } } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/compression/snappy/SnappyFramedCompressor.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/compression/snappy/SnappyFramedCompressor.java index 9219fdd0e8c..900bf0a0dc4 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/compression/snappy/SnappyFramedCompressor.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/compression/snappy/SnappyFramedCompressor.java @@ -37,12 +37,12 @@ private class SnappyFramedDecompressor implements Decompressor { private boolean broken = false; private boolean disposed = false; - public SnappyFramedDecompressor(int uncompressedPayloadSize) { + public SnappyFramedDecompressor(final int uncompressedPayloadSize) { this.uncompressedPayloadSize = uncompressedPayloadSize; } @Override - public Optional decodeOneMessage(ByteBuf input) throws CompressionException { + public Optional decodeOneMessage(final ByteBuf input) throws CompressionException { if (broken) { throw new CompressionException("Compressed stream is broken"); } @@ -129,7 +129,7 @@ public Bytes compress(final Bytes data) { } @Override - public Decompressor createDecompressor(int uncompressedPayloadSize) { + public Decompressor createDecompressor(final int uncompressedPayloadSize) { return new SnappyFramedDecompressor(uncompressedPayloadSize); } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/compression/snappy/SnappyUtil.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/compression/snappy/SnappyUtil.java index 5f0989077b5..f35de86f8a9 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/compression/snappy/SnappyUtil.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/compression/snappy/SnappyUtil.java @@ -19,11 +19,11 @@ class SnappyUtil { - static int calculateChecksum(ByteBuf data) { + static int calculateChecksum(final ByteBuf data) { return calculateChecksum(data, data.readerIndex(), data.readableBytes()); } - static int calculateChecksum(ByteBuf data, int offset, int length) { + static int calculateChecksum(final ByteBuf data, final int offset, final int length) { CRC32C crc32 = new CRC32C(); try { for (int i = offset; i < offset + length; i++) { @@ -35,11 +35,12 @@ static int calculateChecksum(ByteBuf data, int offset, int length) { } } - static int maskChecksum(int checksum) { + static int maskChecksum(final int checksum) { return (checksum >>> 15 | checksum << 17) + 0xa282ead8; } - static void validateChecksum(int expectedChecksum, ByteBuf data, int offset, int length) { + static void validateChecksum( + final int expectedChecksum, final ByteBuf data, final int offset, final int length) { final int actualChecksum = calculateChecksum(data, offset, length); if (actualChecksum != expectedChecksum) { throw new DecompressionException( diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/context/ForkDigestRpcContextCodec.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/context/ForkDigestRpcContextCodec.java index 2a2ea339e27..c09b6406faf 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/context/ForkDigestRpcContextCodec.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/context/ForkDigestRpcContextCodec.java @@ -46,7 +46,7 @@ public RpcByteBufDecoder getContextDecoder() { } @Override - public Bytes encodeContext(TPayload responsePayload) { + public Bytes encodeContext(final TPayload responsePayload) { final UInt64 slot = payloadContext.getSlotFromPayload(responsePayload); final SpecMilestone specMilestone = spec.getForkSchedule().getSpecMilestoneAtSlot(slot); return recentChainData diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/context/RpcContextCodec.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/context/RpcContextCodec.java index aaddecbbcf2..aad86727225 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/context/RpcContextCodec.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/context/RpcContextCodec.java @@ -31,7 +31,7 @@ static RpcContextCodec noop(final SszSchema sch static RpcContextCodec forkDigest( final Spec spec, final RecentChainData recentChainData, - ForkDigestPayloadContext payloadContext) { + final ForkDigestPayloadContext payloadContext) { return new ForkDigestRpcContextCodec(spec, recentChainData, payloadContext); } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/ssz/DefaultRpcPayloadEncoder.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/ssz/DefaultRpcPayloadEncoder.java index b63001c38f9..20ca6968ab5 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/ssz/DefaultRpcPayloadEncoder.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/encodings/ssz/DefaultRpcPayloadEncoder.java @@ -27,7 +27,7 @@ public class DefaultRpcPayloadEncoder implements RpcPayloadEn private static final Logger LOG = LogManager.getLogger(); private final SszSchema type; - public DefaultRpcPayloadEncoder(SszSchema type) { + public DefaultRpcPayloadEncoder(final SszSchema type) { this.type = type; } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/methods/AbstractEth2RpcMethod.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/methods/AbstractEth2RpcMethod.java index 07acd8affff..1dc1a04f412 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/methods/AbstractEth2RpcMethod.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/methods/AbstractEth2RpcMethod.java @@ -40,7 +40,7 @@ protected AbstractEth2RpcMethod( } @Override - public Bytes encodeRequest(TRequest request) { + public Bytes encodeRequest(final TRequest request) { return requestEncoder.encodeRequest(request); } diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/methods/SingleProtocolEth2RpcMethod.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/methods/SingleProtocolEth2RpcMethod.java index b4c084e7cf5..fd3224e848d 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/methods/SingleProtocolEth2RpcMethod.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/methods/SingleProtocolEth2RpcMethod.java @@ -97,9 +97,9 @@ public Eth2IncomingRequestHandler createIncomingRequestHand @Override public Eth2OutgoingRequestHandler createOutgoingRequestHandler( - String protocolId, + final String protocolId, final TRequest request, - Eth2RpcResponseHandler responseHandler) { + final Eth2RpcResponseHandler responseHandler) { return new Eth2OutgoingRequestHandler<>( asyncRunner, asyncRunner, diff --git a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/methods/VersionedEth2RpcMethod.java b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/methods/VersionedEth2RpcMethod.java index f6d86542e4b..f5b102c8d82 100644 --- a/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/methods/VersionedEth2RpcMethod.java +++ b/networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/rpc/core/methods/VersionedEth2RpcMethod.java @@ -106,9 +106,9 @@ public Eth2IncomingRequestHandler createIncomingRequestHand @Override public Eth2OutgoingRequestHandler createOutgoingRequestHandler( - String protocolId, + final String protocolId, final TRequest request, - Eth2RpcResponseHandler responseHandler) { + final Eth2RpcResponseHandler responseHandler) { final Eth2RpcMethod method = protocolToMethod.get(protocolId); return method.createOutgoingRequestHandler(protocolId, request, responseHandler); } diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/AbstractGossipManagerTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/AbstractGossipManagerTest.java index 45c3128500a..305346b40f1 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/AbstractGossipManagerTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/AbstractGossipManagerTest.java @@ -20,10 +20,13 @@ import static org.mockito.Mockito.never; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoInteractions; +import static org.mockito.Mockito.when; +import java.util.Optional; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import tech.pegasys.teku.infrastructure.async.AsyncRunner; +import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.async.StubAsyncRunner; import tech.pegasys.teku.infrastructure.ssz.primitive.SszUInt64; import tech.pegasys.teku.infrastructure.ssz.schema.SszPrimitiveSchemas; @@ -39,6 +42,7 @@ import tech.pegasys.teku.spec.config.NetworkingSpecConfig; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; import tech.pegasys.teku.spec.util.DataStructureUtil; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.client.RecentChainData; import tech.pegasys.teku.storage.storageSystem.InMemoryStorageSystemBuilder; import tech.pegasys.teku.storage.storageSystem.StorageSystem; @@ -66,6 +70,8 @@ class AbstractGossipManagerTest { @BeforeEach void setUp() { storageSystem.chainUpdater().initializeGenesis(); + when(topicChannel1.gossip(any())).thenReturn(SafeFuture.COMPLETE); + when(topicChannel2.gossip(any())).thenReturn(SafeFuture.COMPLETE); doReturn(topicChannel1, topicChannel2) .when(gossipNetwork) .subscribe(contains(TOPIC_NAME.toString()), any()); @@ -175,8 +181,11 @@ protected TestGossipManager( forkInfo, processor, gossipType, + message -> Optional.of(UInt64.ZERO), message -> UInt64.ZERO, - networkingConfig); + networkingConfig, + GossipFailureLogger.createSuppressing(TOPIC_NAME.toString()), + DebugDataDumper.NOOP); } } } diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/AggregateGossipManagerTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/AggregateGossipManagerTest.java index ffd2053721b..81c169cf65a 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/AggregateGossipManagerTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/AggregateGossipManagerTest.java @@ -18,10 +18,12 @@ import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; import org.apache.tuweni.bytes.Bytes; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.async.StubAsyncRunner; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.networking.eth2.gossip.encoding.GossipEncoding; @@ -35,6 +37,7 @@ import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; import tech.pegasys.teku.spec.util.DataStructureUtil; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.storageSystem.InMemoryStorageSystemBuilder; import tech.pegasys.teku.storage.storageSystem.StorageSystem; @@ -59,6 +62,7 @@ public class AggregateGossipManagerTest { @BeforeEach public void setup() { storageSystem.chainUpdater().initializeGenesis(); + when(topicChannel.gossip(any())).thenReturn(SafeFuture.COMPLETE); doReturn(topicChannel) .when(gossipNetwork) .subscribe(contains(GossipTopicName.BEACON_AGGREGATE_AND_PROOF.toString()), any()); @@ -70,7 +74,8 @@ public void setup() { gossipNetwork, gossipEncoding, forkInfo, - processor); + processor, + DebugDataDumper.NOOP); gossipManager.subscribe(); } diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/AttestationGossipManagerTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/AttestationGossipManagerTest.java index 933a63c6183..94e562b650c 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/AttestationGossipManagerTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/AttestationGossipManagerTest.java @@ -41,6 +41,7 @@ import tech.pegasys.teku.spec.datastructures.state.ForkInfo; import tech.pegasys.teku.spec.util.DataStructureUtil; import tech.pegasys.teku.statetransition.BeaconChainUtil; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.client.MemoryOnlyRecentChainData; import tech.pegasys.teku.storage.client.RecentChainData; @@ -69,7 +70,8 @@ public class AttestationGossipManagerTest { gossipEncoding, recentChainData, gossipedAttestationProcessor, - forkInfo); + forkInfo, + DebugDataDumper.NOOP); @BeforeEach public void setup() { @@ -82,13 +84,14 @@ public void setup() { public void onNewAttestation_afterMatchingAssignment() { // Create a new DataStructureUtil so that generated attestations are not subject to change // when access to the global DataStructureUtil changes - DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); - final Attestation attestation = dataStructureUtil.randomAttestation(3); + final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); + final UInt64 slot = UInt64.valueOf(3); + final Attestation attestation = dataStructureUtil.randomAttestation(slot); final Attestation attestation2 = spec.getGenesisSchemaDefinitions() .getAttestationSchema() .create( - dataStructureUtil.randomBitlist(), + dataStructureUtil.randomBitlist(slot), dataStructureUtil.randomAttestationData(UInt64.valueOf(13)), dataStructureUtil.randomSignature()); final int subnetId = computeSubnetId(attestation); diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/BlobSidecarGossipManagerTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/BlobSidecarGossipManagerTest.java index 4bd85f91b0a..90cea8d4e65 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/BlobSidecarGossipManagerTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/BlobSidecarGossipManagerTest.java @@ -20,6 +20,7 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoInteractions; import static org.mockito.Mockito.when; +import static tech.pegasys.teku.infrastructure.async.SafeFutureAssert.safeJoin; import java.util.HashMap; import java.util.Map; @@ -29,9 +30,8 @@ import org.apache.tuweni.bytes.Bytes; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestTemplate; import tech.pegasys.teku.infrastructure.async.SafeFuture; -import tech.pegasys.teku.infrastructure.async.SafeFutureAssert; import tech.pegasys.teku.infrastructure.async.StubAsyncRunner; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.networking.eth2.gossip.encoding.GossipEncoding; @@ -41,41 +41,41 @@ import tech.pegasys.teku.networking.p2p.gossip.TopicChannel; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; -import tech.pegasys.teku.spec.TestSpecFactory; -import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider.SpecContext; import tech.pegasys.teku.spec.config.SpecConfigDeneb; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; import tech.pegasys.teku.spec.util.DataStructureUtil; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.statetransition.validation.InternalValidationResult; import tech.pegasys.teku.storage.storageSystem.InMemoryStorageSystemBuilder; import tech.pegasys.teku.storage.storageSystem.StorageSystem; +@TestSpecContext(milestone = {SpecMilestone.DENEB, SpecMilestone.ELECTRA}) public class BlobSidecarGossipManagerTest { private static final Pattern BLOB_SIDECAR_TOPIC_PATTERN = Pattern.compile("blob_sidecar_(\\d+)"); - private final Spec spec = TestSpecFactory.createMainnetDeneb(); - private final StorageSystem storageSystem = InMemoryStorageSystemBuilder.buildDefault(spec); - private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); - @SuppressWarnings("unchecked") private final OperationProcessor processor = mock(OperationProcessor.class); private final GossipNetwork gossipNetwork = mock(GossipNetwork.class); private final GossipEncoding gossipEncoding = GossipEncoding.SSZ_SNAPPY; - private final Map topicChannels = new HashMap<>(); - private final StubAsyncRunner asyncRunner = new StubAsyncRunner(); - private final ForkInfo forkInfo = - new ForkInfo(spec.fork(UInt64.ZERO), dataStructureUtil.randomBytes32()); - + private Spec spec; + private DataStructureUtil dataStructureUtil; private BlobSidecarGossipManager blobSidecarGossipManager; + private SpecMilestone specMilestone; @BeforeEach - public void setup() { + public void setup(final SpecContext specContext) { + spec = specContext.getSpec(); + dataStructureUtil = specContext.getDataStructureUtil(); + specMilestone = specContext.getSpecMilestone(); + final StorageSystem storageSystem = InMemoryStorageSystemBuilder.buildDefault(spec); storageSystem.chainUpdater().initializeGenesis(); // return TopicChannel mock for each blob_sidecar_ topic doAnswer( @@ -95,6 +95,8 @@ public void setup() { .subscribe(any(), any()); when(processor.process(any(), any())) .thenReturn(SafeFuture.completedFuture(InternalValidationResult.ACCEPT)); + final ForkInfo forkInfo = + new ForkInfo(spec.fork(UInt64.ZERO), dataStructureUtil.randomBytes32()); blobSidecarGossipManager = BlobSidecarGossipManager.create( storageSystem.recentChainData(), @@ -103,17 +105,18 @@ public void setup() { gossipNetwork, gossipEncoding, forkInfo, - processor); + processor, + DebugDataDumper.NOOP); blobSidecarGossipManager.subscribe(); } - @Test + @TestTemplate public void testGossipingBlobSidecarPublishesToCorrectSubnet() { final BlobSidecar blobSidecar = dataStructureUtil.createRandomBlobSidecarBuilder().index(UInt64.ONE).build(); final Bytes serialized = gossipEncoding.encode(blobSidecar); - blobSidecarGossipManager.publishBlobSidecar(blobSidecar); + safeJoin(blobSidecarGossipManager.publishBlobSidecar(blobSidecar)); topicChannels.forEach( (subnetId, channel) -> { @@ -125,19 +128,20 @@ public void testGossipingBlobSidecarPublishesToCorrectSubnet() { }); } - @Test + @TestTemplate public void testGossipingBlobSidecarWithLargeIndexGossipToCorrectSubnet() { final BlobSidecar blobSidecar = dataStructureUtil.createRandomBlobSidecarBuilder().index(UInt64.valueOf(10)).build(); final Bytes serialized = gossipEncoding.encode(blobSidecar); - blobSidecarGossipManager.publishBlobSidecar(blobSidecar); - final SpecConfig config = spec.forMilestone(SpecMilestone.DENEB).getConfig(); - final SpecConfigDeneb specConfigDeneb = SpecConfigDeneb.required(config); + safeJoin(blobSidecarGossipManager.publishBlobSidecar(blobSidecar)); + final int blobSidecarSubnetCount = + SpecConfigDeneb.required(spec.forMilestone(specMilestone).getConfig()) + .getBlobSidecarSubnetCount(); topicChannels.forEach( (subnetId, channel) -> { - if (subnetId == 10 % specConfigDeneb.getBlobSidecarSubnetCount()) { + if (subnetId == 10 % blobSidecarSubnetCount) { verify(channel).gossip(serialized); } else { verifyNoInteractions(channel); @@ -145,7 +149,7 @@ public void testGossipingBlobSidecarWithLargeIndexGossipToCorrectSubnet() { }); } - @Test + @TestTemplate public void testUnsubscribingClosesAllChannels() { blobSidecarGossipManager.unsubscribe(); @@ -157,7 +161,7 @@ public void testUnsubscribingClosesAllChannels() { }); } - @Test + @TestTemplate public void testAcceptingSidecarGossipIfOnTheCorrectTopic() { // topic handler for blob sidecars with subnet_id 1 final Eth2TopicHandler topicHandler = blobSidecarGossipManager.getTopicHandler(1); @@ -168,13 +172,12 @@ public void testAcceptingSidecarGossipIfOnTheCorrectTopic() { System.out.println(blobSidecar); final InternalValidationResult validationResult = - SafeFutureAssert.safeJoin( - topicHandler.getProcessor().process(blobSidecar, Optional.empty())); + safeJoin(topicHandler.getProcessor().process(blobSidecar, Optional.empty())); assertThat(validationResult).isEqualTo(InternalValidationResult.ACCEPT); } - @Test + @TestTemplate public void testRejectingSidecarGossipIfNotOnTheCorrectTopic() { // topic handler for blob sidecars with subnet_id 1 final Eth2TopicHandler topicHandler = blobSidecarGossipManager.getTopicHandler(1); @@ -183,8 +186,7 @@ public void testRejectingSidecarGossipIfNotOnTheCorrectTopic() { final BlobSidecar blobSidecar = dataStructureUtil.createRandomBlobSidecarBuilder().index(UInt64.valueOf(2)).build(); final InternalValidationResult validationResult = - SafeFutureAssert.safeJoin( - topicHandler.getProcessor().process(blobSidecar, Optional.empty())); + safeJoin(topicHandler.getProcessor().process(blobSidecar, Optional.empty())); assertThat(validationResult.isReject()).isTrue(); assertThat(validationResult.getDescription()) diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/BlockGossipManagerTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/BlockGossipManagerTest.java index 01efd8afb8b..bbcc2bebb0a 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/BlockGossipManagerTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/BlockGossipManagerTest.java @@ -18,6 +18,7 @@ import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; +import static tech.pegasys.teku.infrastructure.async.SafeFutureAssert.safeJoin; import org.apache.tuweni.bytes.Bytes; import org.junit.jupiter.api.BeforeEach; @@ -34,6 +35,7 @@ import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; import tech.pegasys.teku.spec.util.DataStructureUtil; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.storageSystem.InMemoryStorageSystemBuilder; import tech.pegasys.teku.storage.storageSystem.StorageSystem; @@ -68,7 +70,8 @@ public void setup() { gossipNetwork, gossipEncoding, forkInfo, - processor); + processor, + DebugDataDumper.NOOP); blockGossipManager.subscribe(); } @@ -77,7 +80,7 @@ public void onBlockProposed() { // Should gossip new blocks received from event bus SignedBeaconBlock block = dataStructureUtil.randomSignedBeaconBlock(1); Bytes serialized = gossipEncoding.encode(block); - blockGossipManager.publishBlock(block); + safeJoin(blockGossipManager.publishBlock(block)); verify(topicChannel).gossip(serialized); } diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/GossipFailureLoggerTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/GossipFailureLoggerTest.java index 6f87429ba32..c4fdc49a5f1 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/GossipFailureLoggerTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/GossipFailureLoggerTest.java @@ -13,8 +13,13 @@ package tech.pegasys.teku.networking.eth2.gossip; +import static tech.pegasys.teku.networking.eth2.gossip.GossipFailureLogger.createNonSuppressing; +import static tech.pegasys.teku.networking.eth2.gossip.GossipFailureLogger.createSuppressing; + +import io.libp2p.core.SemiDuplexNoOutboundStreamException; import io.libp2p.pubsub.MessageAlreadySeenException; import io.libp2p.pubsub.NoPeersForOutboundMessageException; +import java.util.Optional; import org.junit.jupiter.api.Test; import tech.pegasys.infrastructure.logging.LogCaptor; import tech.pegasys.teku.infrastructure.unsigned.UInt64; @@ -23,17 +28,19 @@ class GossipFailureLoggerTest { public static final String ALREADY_SEEN_MESSAGE = "Failed to publish thingy(s) for slot 1 because the message has already been seen"; - public static final UInt64 SLOT = UInt64.ONE; - public static final String NO_PEERS_MESSAGE = noPeersMessage(SLOT.intValue()); - - public static final String GENERIC_FAILURE_MESSAGE = "Failed to publish thingy(s) for slot 1"; + public static final Optional SLOT = Optional.of(UInt64.ONE); + public static final SemiDuplexNoOutboundStreamException NO_ACTIVE_STREAM_EXCEPTION = + new SemiDuplexNoOutboundStreamException("So Lonely"); + public static final NoPeersForOutboundMessageException NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION = + new NoPeersForOutboundMessageException("no peers"); - private final GossipFailureLogger logger = new GossipFailureLogger("thingy"); + private final GossipFailureLogger loggerSuppressing = createSuppressing("thingy"); + private final GossipFailureLogger loggerNoSuppression = createNonSuppressing("thingy"); @Test void shouldLogAlreadySeenErrorsAtDebugLevel() { try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) { - logger.logWithSuppression( + loggerSuppressing.log( new RuntimeException("Foo", new MessageAlreadySeenException("Dupe")), SLOT); logCaptor.assertDebugLog(ALREADY_SEEN_MESSAGE); } @@ -42,100 +49,170 @@ void shouldLogAlreadySeenErrorsAtDebugLevel() { @Test void shouldLogFirstNoPeersErrorsAtWarningLevel() { try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) { - logger.logWithSuppression( - new RuntimeException("Foo", new NoPeersForOutboundMessageException("So Lonely")), SLOT); - logCaptor.assertWarnLog(NO_PEERS_MESSAGE); + loggerSuppressing.log( + new RuntimeException("Foo", NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION), SLOT); + logCaptor.assertWarnLog(noPeersMessage(SLOT, true)); + } + } + + @Test + void shouldLogFirstNoActiveStreamErrorsAtWarningLevel() { + try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) { + loggerSuppressing.log(new RuntimeException("Foo", NO_ACTIVE_STREAM_EXCEPTION), SLOT); + logCaptor.assertWarnLog(noActiveStreamMessage(SLOT, true)); } } @Test void shouldLogRepeatedNoPeersErrorsAtDebugLevel() { try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) { - logger.logWithSuppression( - new RuntimeException("Foo", new NoPeersForOutboundMessageException("So Lonely")), SLOT); + loggerSuppressing.log( + new RuntimeException("Foo", NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION), SLOT); logCaptor.clearLogs(); - logger.logWithSuppression( - new IllegalStateException( - "Foo", new NoPeersForOutboundMessageException("Not a friend in the world")), - SLOT); - logCaptor.assertDebugLog(NO_PEERS_MESSAGE); + loggerSuppressing.log( + new IllegalStateException("Foo", NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION), SLOT); + logCaptor.assertDebugLog(noPeersMessage(SLOT, true)); + } + } + + @Test + void shouldLogRepeatedNoPeersErrorsWhenNoSuppression() { + try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) { + loggerNoSuppression.log( + new RuntimeException("Foo", NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION), SLOT); + logCaptor.clearLogs(); + + loggerNoSuppression.log( + new IllegalStateException("Foo", NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION), SLOT); + logCaptor.assertWarnLog(noPeersMessage(SLOT, false)); } } @Test void shouldLogNoPeersErrorsWithDifferentSlotsAtWarnLevel() { try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) { - logger.logWithSuppression( - new RuntimeException("Foo", new NoPeersForOutboundMessageException("So Lonely")), SLOT); - logCaptor.assertWarnLog(NO_PEERS_MESSAGE); - - logger.logWithSuppression( - new IllegalStateException( - "Foo", new NoPeersForOutboundMessageException("Not a friend in the world")), - UInt64.valueOf(2)); - logCaptor.assertWarnLog(noPeersMessage(2)); + loggerSuppressing.log( + new RuntimeException("Foo", NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION), SLOT); + logCaptor.assertWarnLog(noPeersMessage(SLOT, true)); + + loggerSuppressing.log( + new IllegalStateException("Foo", NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION), + Optional.of(UInt64.valueOf(2))); + logCaptor.assertWarnLog(noPeersMessage(Optional.of(UInt64.valueOf(2)), true)); } } @Test void shouldLogNoPeersErrorsAtWarnLevelWhenSeparatedByADifferentException() { try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) { - logger.logWithSuppression( - new RuntimeException("Foo", new NoPeersForOutboundMessageException("So Lonely")), SLOT); - logCaptor.assertWarnLog(NO_PEERS_MESSAGE); + loggerSuppressing.log( + new RuntimeException("Foo", NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION), SLOT); + logCaptor.assertWarnLog(noPeersMessage(SLOT, true)); logCaptor.clearLogs(); - logger.logWithSuppression(new MessageAlreadySeenException("Dupe"), SLOT); + loggerSuppressing.log(new MessageAlreadySeenException("Dupe"), SLOT); - logger.logWithSuppression( - new IllegalStateException( - "Foo", new NoPeersForOutboundMessageException("Not a friend in the world")), - SLOT); - logCaptor.assertWarnLog(NO_PEERS_MESSAGE); + loggerSuppressing.log( + new IllegalStateException("Foo", NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION), SLOT); + logCaptor.assertWarnLog(noPeersMessage(SLOT, true)); } } @Test void shouldLogFirstGenericErrorAtErrorLevel() { try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) { - logger.logWithSuppression( - new RuntimeException("Foo", new IllegalStateException("Boom")), SLOT); - logCaptor.assertErrorLog(GENERIC_FAILURE_MESSAGE); + loggerSuppressing.log(new RuntimeException("Foo", new IllegalStateException("Boom")), SLOT); + logCaptor.assertErrorLog(genericError(SLOT, true)); } } @Test void shouldLogRepeatedGenericErrorsAtDebugLevel() { try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) { - logger.logWithSuppression( - new RuntimeException("Foo", new IllegalStateException("Boom")), SLOT); + loggerSuppressing.log(new RuntimeException("Foo", new IllegalStateException("Boom")), SLOT); logCaptor.clearLogs(); - logger.logWithSuppression( + loggerSuppressing.log( new IllegalStateException("Foo", new IllegalStateException("goes the dynamite")), SLOT); - logCaptor.assertDebugLog(GENERIC_FAILURE_MESSAGE); + logCaptor.assertDebugLog(genericError(SLOT, true)); } } @Test void shouldLogMultipleGenericErrorsWithDifferentCausesAtErrorLevel() { try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) { - logger.logWithSuppression( - new RuntimeException("Foo", new IllegalStateException("Boom")), SLOT); - logCaptor.assertErrorLog(GENERIC_FAILURE_MESSAGE); + loggerSuppressing.log(new RuntimeException("Foo", new IllegalStateException("Boom")), SLOT); + logCaptor.assertErrorLog(genericError(SLOT, true)); logCaptor.clearLogs(); - logger.logWithSuppression( + loggerSuppressing.log( new IllegalStateException("Foo", new IllegalArgumentException("goes the dynamite")), SLOT); - logCaptor.assertErrorLog(GENERIC_FAILURE_MESSAGE); + logCaptor.assertErrorLog(genericError(SLOT, true)); } } - private static String noPeersMessage(final int slot) { - return "Failed to publish thingy(s) for slot " - + slot - + " because no peers were available on the required gossip topic"; + @Test + void shouldLogGenericErrorsWithoutSuppression() { + try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) { + loggerSuppressing.log( + new RuntimeException("Foo", new IllegalStateException("Boom")), Optional.empty()); + logCaptor.clearLogs(); + + loggerSuppressing.log( + new IllegalStateException("Foo", new IllegalStateException("goes the dynamite")), + Optional.empty()); + logCaptor.assertErrorLog(genericError(Optional.empty(), true)); + } + } + + @Test + void shouldLogNoPeersErrorsAtWarnLevelWithoutSuppression() { + try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) { + loggerSuppressing.log( + new RuntimeException("Foo", NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION), Optional.empty()); + logCaptor.clearLogs(); + + loggerSuppressing.log( + new IllegalStateException("Foo", NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION), + Optional.empty()); + logCaptor.assertWarnLog(noPeersMessage(Optional.empty(), true)); + } + } + + @Test + void shouldLogNoActiveStreamErrorsWithoutSuppression() { + try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) { + loggerSuppressing.log( + new RuntimeException("Foo", NO_ACTIVE_STREAM_EXCEPTION), Optional.empty()); + logCaptor.clearLogs(); + + loggerSuppressing.log( + new IllegalStateException("Foo", NO_ACTIVE_STREAM_EXCEPTION), Optional.empty()); + logCaptor.assertWarnLog(noActiveStreamMessage(Optional.empty(), true)); + } + } + + private static String noPeersMessage(final Optional slot, final boolean shouldSuppress) { + return "Failed to publish thingy" + + (shouldSuppress ? "(s)" : "") + + slot.map(s -> " for slot " + s).orElse("") + + "; " + + NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION.getMessage(); + } + + private static String noActiveStreamMessage( + final Optional slot, final boolean shouldSuppress) { + return "Failed to publish thingy" + + (shouldSuppress ? "(s)" : "") + + slot.map(s -> " for slot " + s).orElse("") + + " because no active outbound stream for the required gossip topic"; + } + + private static String genericError(final Optional slot, final boolean shouldSuppress) { + return "Failed to publish thingy" + + (shouldSuppress ? "(s)" : "") + + slot.map(s -> " for slot " + s).orElse(""); } } diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/encoding/SszSnappyGossipEncodingTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/encoding/SszSnappyGossipEncodingTest.java index 4a074f896ad..ba8611b658e 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/encoding/SszSnappyGossipEncodingTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/encoding/SszSnappyGossipEncodingTest.java @@ -48,7 +48,10 @@ public class SszSnappyGossipEncodingTest { GossipTopics.getTopic(Bytes4.fromHexStringLenient("0x01"), "testing", encoding); private T decode( - final String topic, GossipEncoding encoding, Bytes data, SszSchema valueType) + final String topic, + final GossipEncoding encoding, + final Bytes data, + final SszSchema valueType) throws DecodingException { return encoding.decodeMessage( encoding diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/forks/GossipForkManagerTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/forks/GossipForkManagerTest.java index 05596025a86..6bfa413fe78 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/forks/GossipForkManagerTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/forks/GossipForkManagerTest.java @@ -13,14 +13,18 @@ package tech.pegasys.teku.networking.eth2.gossip.forks; +import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyBoolean; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; +import static org.mockito.Mockito.reset; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import static tech.pegasys.teku.infrastructure.async.SafeFutureAssert.safeJoin; import java.util.Optional; import java.util.function.BiConsumer; @@ -30,15 +34,20 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; +import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.genesis.GenesisData; +import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; +import tech.pegasys.teku.spec.datastructures.operations.VoluntaryExit; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.ValidatableSyncCommitteeMessage; import tech.pegasys.teku.spec.util.DataStructureUtil; import tech.pegasys.teku.storage.client.RecentChainData; +import tech.pegasys.teku.storage.store.UpdatableStore; class GossipForkManagerTest { private static final Bytes32 GENESIS_VALIDATORS_ROOT = Bytes32.fromHexString("0x12345678446687"); @@ -49,6 +58,7 @@ class GossipForkManagerTest { @BeforeEach void setUp() { + reset(recentChainData); when(recentChainData.getGenesisData()) .thenReturn( Optional.of(new GenesisData(UInt64.valueOf(134234134L), GENESIS_VALIDATORS_ROOT))); @@ -277,17 +287,17 @@ void shouldPublishBlockToForkForBlockSlot() { final SignedBeaconBlock thirdForkBlock = dataStructureUtil.randomSignedBeaconBlock(spec.computeStartSlotAtEpoch(UInt64.valueOf(2))); - manager.publishBlock(firstForkBlock); + safeJoin(manager.publishBlock(firstForkBlock)); verify(firstFork).publishBlock(firstForkBlock); verify(secondFork, never()).publishBlock(firstForkBlock); verify(thirdFork, never()).publishBlock(firstForkBlock); - manager.publishBlock(secondForkBlock); + safeJoin(manager.publishBlock(secondForkBlock)); verify(firstFork, never()).publishBlock(secondForkBlock); verify(secondFork).publishBlock(secondForkBlock); verify(thirdFork, never()).publishBlock(secondForkBlock); - manager.publishBlock(thirdForkBlock); + safeJoin(manager.publishBlock(thirdForkBlock)); verify(firstFork, never()).publishBlock(thirdForkBlock); verify(secondFork, never()).publishBlock(thirdForkBlock); verify(thirdFork).publishBlock(thirdForkBlock); @@ -348,6 +358,62 @@ void shouldNotPublishSyncCommitteeMessagesToForksThatAreNotActive() { verify(secondFork, never()).publishSyncCommitteeMessage(message); } + @Test + void shouldPublishVoluntaryExitOnCapella() { + final Spec specCapella = TestSpecFactory.createMinimalCapella(); + final GossipForkSubscriptions capellaFork = forkAtEpoch(0); + final GossipForkManager.Builder builder = + GossipForkManager.builder().recentChainData(recentChainData).spec(specCapella); + Stream.of(capellaFork).forEach(builder::fork); + final GossipForkManager manager = builder.build(); + + final UpdatableStore store = mock(UpdatableStore.class); + when(recentChainData.getStore()).thenReturn(store); + when(store.getGenesisTime()).thenReturn(UInt64.ZERO); + when(store.getTimeSeconds()).thenReturn(UInt64.ONE); + + final VoluntaryExit voluntaryExit = new VoluntaryExit(UInt64.ZERO, UInt64.ONE); + final SignedVoluntaryExit capellaVoluntaryExit = + new SignedVoluntaryExit(voluntaryExit, dataStructureUtil.randomSignature()); + + manager.configureGossipForEpoch(UInt64.ZERO); + + manager.publishVoluntaryExit(capellaVoluntaryExit); + verify(capellaFork).publishVoluntaryExit(capellaVoluntaryExit); + } + + @Test + void shouldPublishCapellaVoluntaryExitAfterCapella() { + final Spec specDeneb = TestSpecFactory.createMinimalWithDenebForkEpoch(UInt64.ONE); + final GossipForkSubscriptions capellaFork = forkAtEpoch(0); + final GossipForkSubscriptions denebFork = forkAtEpoch(1); + final GossipForkManager.Builder builder = + GossipForkManager.builder().recentChainData(recentChainData).spec(specDeneb); + Stream.of(capellaFork, denebFork).forEach(builder::fork); + final GossipForkManager manager = builder.build(); + + final UpdatableStore store = mock(UpdatableStore.class); + when(recentChainData.getStore()).thenReturn(store); + when(store.getGenesisTime()).thenReturn(UInt64.ZERO); + when(store.getTimeSeconds()).thenReturn(UInt64.valueOf(9000)); + assertThat(specDeneb.getCurrentEpoch(store)).isGreaterThanOrEqualTo(UInt64.valueOf(3)); + + final VoluntaryExit voluntaryExit = new VoluntaryExit(UInt64.ZERO, UInt64.ONE); + final SignedVoluntaryExit capellaVoluntaryExit = + new SignedVoluntaryExit(voluntaryExit, dataStructureUtil.randomSignature()); + assertEquals( + SpecMilestone.CAPELLA, + specDeneb.atEpoch(capellaVoluntaryExit.getMessage().getEpoch()).getMilestone()); + + // Deneb + // Previous subscriptions are stopped in 2 epochs after fork transition + manager.configureGossipForEpoch(UInt64.valueOf(3)); + + manager.publishVoluntaryExit(capellaVoluntaryExit); + verify(capellaFork, never()).publishVoluntaryExit(capellaVoluntaryExit); + verify(denebFork).publishVoluntaryExit(capellaVoluntaryExit); + } + @ParameterizedTest @MethodSource("subnetSubscriptionTypes") void shouldSubscribeToAttestationSubnetsPriorToStarting(final SubscriptionType subscriptionType) { @@ -521,6 +587,8 @@ private GossipForkSubscriptions forkAtEpoch(final long epoch) { final GossipForkSubscriptions subscriptions = mock(GossipForkSubscriptions.class, "subscriptionsForEpoch" + epoch); when(subscriptions.getActivationEpoch()).thenReturn(UInt64.valueOf(epoch)); + when(subscriptions.publishBlock(any())).thenReturn(SafeFuture.COMPLETE); + when(subscriptions.publishBlobSidecar(any())).thenReturn(SafeFuture.COMPLETE); return subscriptions; } diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsCapellaTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsCapellaTest.java index 76b9fb572e4..84cf794a13b 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsCapellaTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsCapellaTest.java @@ -31,6 +31,7 @@ import tech.pegasys.teku.spec.datastructures.operations.SignedBlsToExecutionChange; import tech.pegasys.teku.spec.datastructures.state.Fork; import tech.pegasys.teku.spec.util.DataStructureUtil; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.client.MemoryOnlyRecentChainData; import tech.pegasys.teku.storage.client.RecentChainData; @@ -81,6 +82,7 @@ private GossipForkSubscriptionsCapella createGossipForkSubscriptionCapella() { noopOperationProcessor, noopOperationProcessor, noopOperationProcessor, - noopOperationProcessor); + noopOperationProcessor, + DebugDataDumper.NOOP); } } diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsDenebTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsDenebTest.java index 78d04e8e7e3..8d5803a3abc 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsDenebTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/forks/versions/GossipForkSubscriptionsDenebTest.java @@ -32,6 +32,7 @@ import tech.pegasys.teku.spec.datastructures.state.Fork; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; import tech.pegasys.teku.spec.util.DataStructureUtil; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.client.MemoryOnlyRecentChainData; import tech.pegasys.teku.storage.client.RecentChainData; @@ -81,6 +82,7 @@ private GossipForkSubscriptionsDeneb createGossipForkSubscriptionDeneb() { noopOperationProcessor, noopOperationProcessor, noopOperationProcessor, - noopOperationProcessor); + noopOperationProcessor, + DebugDataDumper.NOOP); } } diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/subnets/AllSubnetsSubscriberTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/subnets/AllSubnetsSubscriberTest.java index 37c4f24ba43..eed17e9433a 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/subnets/AllSubnetsSubscriberTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/subnets/AllSubnetsSubscriberTest.java @@ -44,12 +44,12 @@ void shouldSubscribeToAllSubnetsWhenCreated() { final Set actual = captor.getValue(); // Should subscribe to all subnets with a far future unsubscription slot assertThat(actual).hasSize(spec.getNetworkingConfig().getAttestationSubnetCount()); - assertThat(actual.stream().mapToInt(SubnetSubscription::getSubnetId)) + assertThat(actual.stream().mapToInt(SubnetSubscription::subnetId)) .containsExactlyInAnyOrderElementsOf( IntStream.range(0, spec.getNetworkingConfig().getAttestationSubnetCount()) .boxed() .collect(toSet())); - assertThat(actual.stream().map(SubnetSubscription::getUnsubscriptionSlot)) + assertThat(actual.stream().map(SubnetSubscription::unsubscriptionSlot)) .containsOnly(UInt64.MAX_VALUE); stableSubnetSubscriber.onSlot(UInt64.ONE); diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/subnets/AttestationSubnetSubscriptionsTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/subnets/AttestationSubnetSubscriptionsTest.java index b9e40ea6172..4f9d5256248 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/subnets/AttestationSubnetSubscriptionsTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/subnets/AttestationSubnetSubscriptionsTest.java @@ -38,6 +38,7 @@ import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.util.DataStructureUtil; import tech.pegasys.teku.statetransition.BeaconChainUtil; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.client.MemoryOnlyRecentChainData; import tech.pegasys.teku.storage.client.RecentChainData; @@ -67,7 +68,8 @@ void setUp() { gossipEncoding, recentChainData, processor, - recentChainData.getCurrentForkInfo().orElseThrow()); + recentChainData.getCurrentForkInfo().orElseThrow(), + DebugDataDumper.NOOP); subnetSubscriptions.subscribe(); when(gossipNetwork.subscribe(any(), any())).thenReturn(mock(TopicChannel.class)); diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/subnets/PeerSubnetSubscriptionsTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/subnets/PeerSubnetSubscriptionsTest.java index f5d7e9746da..0df92ad2bda 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/subnets/PeerSubnetSubscriptionsTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/subnets/PeerSubnetSubscriptionsTest.java @@ -218,7 +218,7 @@ private PeerSubnetSubscriptions createPeerSubnetSubscriptions() { subnetPeerCountGauge); } - private void withSubscriberCountForAllSubnets(int subscriberCount) { + private void withSubscriberCountForAllSubnets(final int subscriberCount) { // Set up subscribers final List subscribers = new ArrayList<>(); IntStream.range(0, subscriberCount).mapToObj(MockNodeId::new).forEach(subscribers::add); diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/subnets/StableSubnetSubscriberTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/subnets/StableSubnetSubscriberTest.java index 9fd65f508f2..11dacc88a81 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/subnets/StableSubnetSubscriberTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/subnets/StableSubnetSubscriberTest.java @@ -62,8 +62,7 @@ void shouldSubscribeToSubnetsPerNodeAtStart() { .getValue() .forEach( subnetSubscription -> - assertThat(subnetSubscription.getUnsubscriptionSlot()) - .isEqualTo(unsubscriptionSlot)); + assertThat(subnetSubscription.unsubscriptionSlot()).isEqualTo(unsubscriptionSlot)); assertSubnetsAreDistinct(subnetSubscriptions.getValue()); } @@ -85,7 +84,7 @@ void shouldReplaceExpiredSubscriptionsWithNewOnes() { .hasSize(spec.getNetworkingConfig().getSubnetsPerNode()); UInt64 firstUnsubscriptionSlot = - firstSubscriptionUpdate.getValue().stream().findFirst().get().getUnsubscriptionSlot(); + firstSubscriptionUpdate.getValue().stream().findFirst().get().unsubscriptionSlot(); stableSubnetSubscriber.onSlot(firstUnsubscriptionSlot.minus(UInt64.ONE)); @@ -99,7 +98,7 @@ void shouldReplaceExpiredSubscriptionsWithNewOnes() { .isNotEqualTo(secondSubscriptionUpdate.getValue()); UInt64 secondUnsubscriptionSlot = - secondSubscriptionUpdate.getValue().stream().findFirst().get().getUnsubscriptionSlot(); + secondSubscriptionUpdate.getValue().stream().findFirst().get().unsubscriptionSlot(); assertThat(firstUnsubscriptionSlot).isNotEqualByComparingTo(secondUnsubscriptionSlot); assertThat( @@ -109,11 +108,11 @@ void shouldReplaceExpiredSubscriptionsWithNewOnes() { .isEqualTo(UInt64.valueOf(spec.getNetworkingConfig().getEpochsPerSubnetSubscription())); } - private void assertSubnetsAreDistinct(Set subnetSubscriptions) { + private void assertSubnetsAreDistinct(final Set subnetSubscriptions) { IntSet subnetIds = IntOpenHashSet.toSet( subnetSubscriptions.stream() - .map(SubnetSubscription::getSubnetId) + .map(SubnetSubscription::subnetId) .mapToInt(Integer::intValue)); assertThat(subnetSubscriptions).hasSameSizeAs(subnetIds); } diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/subnets/SubnetScorerTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/subnets/SubnetScorerTest.java index 9827c45d56e..8d635311515 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/subnets/SubnetScorerTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/subnets/SubnetScorerTest.java @@ -203,7 +203,8 @@ private void assertCandidatePeerScores( assertThat(actual).contains(expected); } - private DiscoveryPeer createDiscoveryPeer(SszBitvector attSubnets, SszBitvector syncSubnets) { + private DiscoveryPeer createDiscoveryPeer( + final SszBitvector attSubnets, final SszBitvector syncSubnets) { try { Bytes pubKey = Bytes.fromHexString( @@ -222,7 +223,7 @@ private DiscoveryPeer createDiscoveryPeer(SszBitvector attSubnets, SszBitvector } private Pair candidateWithSubnets( - final List attnets, List syncnets) { + final List attnets, final List syncnets) { return Pair.of( schemaDefinitions.getAttnetsENRFieldSchema().ofBits(attnets), schemaDefinitions.getSyncnetsENRFieldSchema().ofBits(syncnets)); diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/AggregateTopicHandlerTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/AggregateTopicHandlerTest.java index ca276059c89..16ae1409ba6 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/AggregateTopicHandlerTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/AggregateTopicHandlerTest.java @@ -24,6 +24,7 @@ import tech.pegasys.teku.networking.eth2.gossip.AggregateGossipManager; import tech.pegasys.teku.networking.eth2.gossip.topics.topichandlers.Eth2TopicHandler; import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.statetransition.validation.InternalValidationResult; public class AggregateTopicHandlerTest extends AbstractTopicHandlerTest { @@ -31,7 +32,14 @@ public class AggregateTopicHandlerTest extends AbstractTopicHandlerTest createHandler() { return new AggregateGossipManager( - spec, recentChainData, asyncRunner, gossipNetwork, gossipEncoding, forkInfo, processor) + spec, + recentChainData, + asyncRunner, + gossipNetwork, + gossipEncoding, + forkInfo, + processor, + DebugDataDumper.NOOP) .getTopicHandler(); } diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/AttesterSlashingTopicHandlerTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/AttesterSlashingTopicHandlerTest.java index b2954d77c7e..3143eafe234 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/AttesterSlashingTopicHandlerTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/AttesterSlashingTopicHandlerTest.java @@ -25,6 +25,7 @@ import tech.pegasys.teku.networking.eth2.gossip.AttesterSlashingGossipManager; import tech.pegasys.teku.networking.eth2.gossip.topics.topichandlers.Eth2TopicHandler; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.statetransition.validation.InternalValidationResult; public class AttesterSlashingTopicHandlerTest extends AbstractTopicHandlerTest { @@ -33,7 +34,14 @@ public class AttesterSlashingTopicHandlerTest extends AbstractTopicHandlerTest createHandler() { final AttesterSlashingGossipManager gossipManager = new AttesterSlashingGossipManager( - spec, recentChainData, asyncRunner, null, gossipEncoding, forkInfo, processor); + spec, + recentChainData, + asyncRunner, + null, + gossipEncoding, + forkInfo, + processor, + DebugDataDumper.NOOP); return gossipManager.getTopicHandler(); } diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/BlockTopicHandlerTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/BlockTopicHandlerTest.java index 9bde5f5cec3..43c175c3bed 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/BlockTopicHandlerTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/BlockTopicHandlerTest.java @@ -29,6 +29,7 @@ import tech.pegasys.teku.networking.eth2.gossip.topics.topichandlers.Eth2TopicHandler; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.generator.ChainBuilder.BlockOptions; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.statetransition.validation.InternalValidationResult; public class BlockTopicHandlerTest extends AbstractTopicHandlerTest { @@ -36,7 +37,14 @@ public class BlockTopicHandlerTest extends AbstractTopicHandlerTest createHandler() { return new BlockGossipManager( - recentChainData, spec, asyncRunner, gossipNetwork, gossipEncoding, forkInfo, processor) + recentChainData, + spec, + asyncRunner, + gossipNetwork, + gossipEncoding, + forkInfo, + processor, + DebugDataDumper.NOOP) .getTopicHandler(); } diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/Eth2GossipTopicFilterTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/Eth2GossipTopicFilterTest.java index 8dd30549a36..870c9cd5626 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/Eth2GossipTopicFilterTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/Eth2GossipTopicFilterTest.java @@ -27,12 +27,14 @@ import java.util.Optional; import org.apache.tuweni.bytes.Bytes32; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestTemplate; import tech.pegasys.teku.infrastructure.bytes.Bytes4; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecContext; import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider; import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.config.SpecConfigDeneb; import tech.pegasys.teku.spec.datastructures.state.Fork; @@ -40,47 +42,70 @@ import tech.pegasys.teku.spec.util.DataStructureUtil; import tech.pegasys.teku.storage.client.RecentChainData; +@TestSpecContext(milestone = {SpecMilestone.DENEB, SpecMilestone.ELECTRA}) class Eth2GossipTopicFilterTest { - private final UInt64 denebForkEpoch = UInt64.valueOf(10); - private final Spec spec = TestSpecFactory.createMinimalWithDenebForkEpoch(denebForkEpoch); - private final List forks = spec.getForkSchedule().getForks(); - private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); - private final Bytes32 genesisValidatorsRoot = dataStructureUtil.randomBytes32(); - private final ForkInfo forkInfo = new ForkInfo(forks.get(0), genesisValidatorsRoot); - private final Fork nextFork = forks.get(1); private final RecentChainData recentChainData = mock(RecentChainData.class); - private final Bytes4 nextForkDigest = - spec.atEpoch(nextFork.getEpoch()) - .miscHelpers() - .computeForkDigest(nextFork.getCurrentVersion(), genesisValidatorsRoot); - - private final Eth2GossipTopicFilter filter = - new Eth2GossipTopicFilter(recentChainData, SSZ_SNAPPY, spec); + private final UInt64 currentForkEpoch = UInt64.valueOf(10); + private Spec spec; + private SpecMilestone specMilestone; + private DataStructureUtil dataStructureUtil; + private ForkInfo forkInfo; + private Eth2GossipTopicFilter filter; + private Bytes4 currentForkDigest; + private Bytes4 nextForkDigest; @BeforeEach - void setUp() { + void setUp(final TestSpecInvocationContextProvider.SpecContext specContext) { + specMilestone = specContext.getSpecMilestone(); + spec = + switch (specContext.getSpecMilestone()) { + case PHASE0 -> throw new IllegalArgumentException("Phase0 is an unsupported milestone"); + case ALTAIR -> throw new IllegalArgumentException("Altair is an unsupported milestone"); + case BELLATRIX -> + throw new IllegalArgumentException("Bellatrix is an unsupported milestone"); + case CAPELLA -> throw new IllegalArgumentException("Capella is an unsupported milestone"); + case DENEB -> TestSpecFactory.createMinimalWithDenebForkEpoch(currentForkEpoch); + case ELECTRA -> TestSpecFactory.createMinimalWithElectraForkEpoch(currentForkEpoch); + case FULU -> TestSpecFactory.createMinimalWithFuluForkEpoch(currentForkEpoch); + }; + dataStructureUtil = new DataStructureUtil(spec); + filter = new Eth2GossipTopicFilter(recentChainData, SSZ_SNAPPY, spec); + + final Bytes32 genesisValidatorsRoot = dataStructureUtil.randomBytes32(); + final List forks = spec.getForkSchedule().getForks(); + forkInfo = new ForkInfo(forks.get(0), genesisValidatorsRoot); + currentForkDigest = forkInfo.getForkDigest(spec); + + final Fork nextFork = forks.get(1); + nextForkDigest = + spec.atEpoch(nextFork.getEpoch()) + .miscHelpers() + .computeForkDigest(nextFork.getCurrentVersion(), genesisValidatorsRoot); + when(recentChainData.getCurrentForkInfo()).thenReturn(Optional.of(forkInfo)); when(recentChainData.getNextFork(forkInfo.getFork())).thenReturn(Optional.of(nextFork)); + when(recentChainData.getMilestoneByForkDigest(currentForkDigest)) + .thenReturn(Optional.of(specMilestone)); } - @Test + @TestTemplate void shouldNotAllowIrrelevantTopics() { assertThat(filter.isRelevantTopic("abc")).isFalse(); } - @Test + @TestTemplate void shouldNotRequireNextForkToBePresent() { when(recentChainData.getNextFork(any())).thenReturn(Optional.empty()); assertThat(filter.isRelevantTopic(getTopicName(GossipTopicName.BEACON_BLOCK))).isTrue(); } - @Test + @TestTemplate void shouldConsiderTopicsForNextForkRelevant() { assertThat(filter.isRelevantTopic(getNextForkTopicName(GossipTopicName.BEACON_BLOCK))).isTrue(); } - @Test + @TestTemplate void shouldConsiderTopicsForSignedContributionAndProofRelevant() { assertThat( filter.isRelevantTopic( @@ -88,7 +113,7 @@ void shouldConsiderTopicsForSignedContributionAndProofRelevant() { .isTrue(); } - @Test + @TestTemplate void shouldConsiderAllAttestationSubnetsRelevant() { for (int i = 0; i < spec.getNetworkingConfig().getAttestationSubnetCount(); i++) { assertThat(filter.isRelevantTopic(getTopicName(getAttestationSubnetTopicName(i)))).isTrue(); @@ -97,14 +122,14 @@ void shouldConsiderAllAttestationSubnetsRelevant() { } } - @Test + @TestTemplate void shouldConsiderAllSyncCommitteeSubnetsRelevant() { for (int i = 0; i < SYNC_COMMITTEE_SUBNET_COUNT; i++) { assertThat(filter.isRelevantTopic(getTopicName(getSyncCommitteeSubnetTopicName(i)))).isTrue(); } } - @Test + @TestTemplate void shouldConsiderAllBlobSidecarSubnetsRelevant() { final SpecConfig config = spec.forMilestone(SpecMilestone.DENEB).getConfig(); final SpecConfigDeneb specConfigDeneb = SpecConfigDeneb.required(config); @@ -113,24 +138,23 @@ void shouldConsiderAllBlobSidecarSubnetsRelevant() { } } - @Test + @TestTemplate void shouldNotConsiderBlobSidecarWithIncorrectSubnetIdRelevant() { - final SpecConfig config = spec.forMilestone(SpecMilestone.DENEB).getConfig(); - final SpecConfigDeneb specConfigDeneb = SpecConfigDeneb.required(config); + final int blobSidecarSubnetCount = + SpecConfigDeneb.required(spec.forMilestone(specMilestone).getConfig()) + .getBlobSidecarSubnetCount(); assertThat( filter.isRelevantTopic( - getTopicName( - getBlobSidecarSubnetTopicName( - specConfigDeneb.getBlobSidecarSubnetCount() + 1)))) + getTopicName(getBlobSidecarSubnetTopicName(blobSidecarSubnetCount + 1)))) .isFalse(); } - @Test + @TestTemplate void shouldNotConsiderBlobSidecarWithoutIndexTopicRelevant() { assertThat(filter.isRelevantTopic(getTopicName("blob_sidecar"))).isFalse(); } - @Test + @TestTemplate void shouldNotAllowTopicsWithUnknownForkDigest() { final String irrelevantTopic = GossipTopics.getTopic( diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/Eth2TopicHandlerTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/Eth2TopicHandlerTest.java index e7cd99dcabd..5e5514303c6 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/Eth2TopicHandlerTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/Eth2TopicHandlerTest.java @@ -13,6 +13,10 @@ package tech.pegasys.teku.networking.eth2.gossip.topics; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; import static tech.pegasys.teku.infrastructure.async.SafeFutureAssert.assertThatSafeFuture; import io.libp2p.core.pubsub.ValidationResult; @@ -37,6 +41,7 @@ import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.util.DataStructureUtil; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.statetransition.validation.InternalValidationResult; import tech.pegasys.teku.storage.client.RecentChainData; import tech.pegasys.teku.storage.storageSystem.InMemoryStorageSystemBuilder; @@ -50,6 +55,7 @@ public class Eth2TopicHandlerTest { private final SignedBeaconBlock block = dataStructureUtil.randomSignedBeaconBlock(1); private final Bytes blockBytes = GossipEncoding.SSZ_SNAPPY.encode(block); private final StubAsyncRunner asyncRunner = new StubAsyncRunner(); + private final DebugDataDumper debugDataDumper = mock(DebugDataDumper.class); @BeforeEach public void setup() { @@ -63,7 +69,8 @@ public void handleMessage_valid() { recentChainData, spec, asyncRunner, - (b, __) -> SafeFuture.completedFuture(InternalValidationResult.ACCEPT)); + (b, __) -> SafeFuture.completedFuture(InternalValidationResult.ACCEPT), + debugDataDumper); final SafeFuture result = topicHandler.handleMessage(topicHandler.prepareMessage(blockBytes, Optional.empty())); @@ -78,11 +85,14 @@ public void handleMessage_invalid() { recentChainData, spec, asyncRunner, - (b, __) -> SafeFuture.completedFuture(InternalValidationResult.reject("Nope"))); + (b, __) -> SafeFuture.completedFuture(InternalValidationResult.reject("Nope")), + debugDataDumper); final SafeFuture result = topicHandler.handleMessage(topicHandler.prepareMessage(blockBytes, Optional.empty())); asyncRunner.executeQueuedActions(); + verify(debugDataDumper) + .saveGossipRejectedMessage(eq(topicHandler.getTopic()), any(), any(), any()); assertThatSafeFuture(result).isCompletedWithValue(ValidationResult.Invalid); } @@ -93,7 +103,8 @@ public void handleMessage_ignore() { recentChainData, spec, asyncRunner, - (b, __) -> SafeFuture.completedFuture(InternalValidationResult.IGNORE)); + (b, __) -> SafeFuture.completedFuture(InternalValidationResult.IGNORE), + debugDataDumper); final SafeFuture result = topicHandler.handleMessage(topicHandler.prepareMessage(blockBytes, Optional.empty())); @@ -108,10 +119,13 @@ public void handleMessage_invalidBytes() { recentChainData, spec, asyncRunner, - (b, __) -> SafeFuture.completedFuture(InternalValidationResult.ACCEPT)); + (b, __) -> SafeFuture.completedFuture(InternalValidationResult.ACCEPT), + debugDataDumper); final Bytes invalidBytes = Bytes.fromHexString("0x0102"); final SafeFuture result = topicHandler.handleMessage(topicHandler.prepareMessage(invalidBytes, Optional.empty())); + verify(debugDataDumper) + .saveGossipMessageDecodingError(eq(topicHandler.getTopic()), any(), any(), any()); asyncRunner.executeQueuedActions(); assertThatSafeFuture(result).isCompletedWithValue(ValidationResult.Invalid); @@ -124,7 +138,8 @@ public void handleMessage_errorWhileProcessing_decodingException() { recentChainData, spec, asyncRunner, - (b, __) -> SafeFuture.completedFuture(InternalValidationResult.ACCEPT)); + (b, __) -> SafeFuture.completedFuture(InternalValidationResult.ACCEPT), + debugDataDumper); topicHandler.setDeserializer( (b) -> { throw new DecodingException("oops"); @@ -132,6 +147,8 @@ public void handleMessage_errorWhileProcessing_decodingException() { final SafeFuture result = topicHandler.handleMessage(topicHandler.prepareMessage(blockBytes, Optional.empty())); + verify(debugDataDumper) + .saveGossipMessageDecodingError(eq(topicHandler.getTopic()), any(), any(), any()); asyncRunner.executeQueuedActions(); assertThatSafeFuture(result).isCompletedWithValue(ValidationResult.Invalid); @@ -144,7 +161,8 @@ public void handleMessage_errorWhileProcessing_wrappedDecodingException() { recentChainData, spec, asyncRunner, - (b, __) -> SafeFuture.completedFuture(InternalValidationResult.ACCEPT)); + (b, __) -> SafeFuture.completedFuture(InternalValidationResult.ACCEPT), + debugDataDumper); topicHandler.setDeserializer( (b) -> { throw new CompletionException(new DecodingException("oops")); @@ -152,6 +170,8 @@ public void handleMessage_errorWhileProcessing_wrappedDecodingException() { final SafeFuture result = topicHandler.handleMessage(topicHandler.prepareMessage(blockBytes, Optional.empty())); + verify(debugDataDumper) + .saveGossipMessageDecodingError(eq(topicHandler.getTopic()), any(), any(), any()); asyncRunner.executeQueuedActions(); assertThatSafeFuture(result).isCompletedWithValue(ValidationResult.Invalid); @@ -164,7 +184,8 @@ public void handleMessage_errorWhileProcessing_decodingExceptionWithCause() { recentChainData, spec, asyncRunner, - (b, __) -> SafeFuture.completedFuture(InternalValidationResult.ACCEPT)); + (b, __) -> SafeFuture.completedFuture(InternalValidationResult.ACCEPT), + debugDataDumper); topicHandler.setDeserializer( (b) -> { throw new DecodingException("oops", new RuntimeException("oops")); @@ -172,6 +193,8 @@ public void handleMessage_errorWhileProcessing_decodingExceptionWithCause() { final SafeFuture result = topicHandler.handleMessage(topicHandler.prepareMessage(blockBytes, Optional.empty())); + verify(debugDataDumper) + .saveGossipMessageDecodingError(eq(topicHandler.getTopic()), any(), any(), any()); asyncRunner.executeQueuedActions(); assertThatSafeFuture(result).isCompletedWithValue(ValidationResult.Invalid); @@ -186,7 +209,8 @@ public void handleMessage_errorWhileProcessing_rejectedExecution() { asyncRunner, (b, __) -> { throw new RejectedExecutionException("No more capacity"); - }); + }, + debugDataDumper); final SafeFuture result = topicHandler.handleMessage(topicHandler.prepareMessage(blockBytes, Optional.empty())); @@ -204,7 +228,8 @@ public void handleMessage_errorWhileProcessing_wrappedRejectedExecution() { asyncRunner, (b, __) -> { throw new CompletionException(new RejectedExecutionException("No more capacity")); - }); + }, + debugDataDumper); final SafeFuture result = topicHandler.handleMessage(topicHandler.prepareMessage(blockBytes, Optional.empty())); @@ -222,7 +247,8 @@ public void handleMessage_errorWhileProcessing_rejectedExecutionWithRootCause() asyncRunner, (b, __) -> { throw new RejectedExecutionException("No more capacity", new NullPointerException()); - }); + }, + debugDataDumper); final SafeFuture result = topicHandler.handleMessage(topicHandler.prepareMessage(blockBytes, Optional.empty())); @@ -240,7 +266,8 @@ public void handleMessage_errorWhileProcessing_serviceCapacityExceededExecution( asyncRunner, (b, __) -> { throw new ServiceCapacityExceededException("No more capacity"); - }); + }, + debugDataDumper); final SafeFuture result = topicHandler.handleMessage(topicHandler.prepareMessage(blockBytes, Optional.empty())); @@ -259,7 +286,8 @@ public void handleMessage_errorWhileProcessing_wrappedServiceCapacityExceededExe (b, __) -> { throw new CompletionException( new ServiceCapacityExceededException("No more capacity")); - }); + }, + debugDataDumper); final SafeFuture result = topicHandler.handleMessage(topicHandler.prepareMessage(blockBytes, Optional.empty())); @@ -277,7 +305,8 @@ public void handleMessage_errorWhileProcessing_unknownError() { asyncRunner, (b, __) -> { throw new NullPointerException(); - }); + }, + debugDataDumper); final SafeFuture result = topicHandler.handleMessage(topicHandler.prepareMessage(blockBytes, Optional.empty())); @@ -295,7 +324,8 @@ protected MockEth2TopicHandler( final RecentChainData recentChainData, final Spec spec, final AsyncRunner asyncRunner, - final OperationProcessor processor) { + final OperationProcessor processor, + final DebugDataDumper debugDataDumper) { super( recentChainData, asyncRunner, @@ -306,7 +336,8 @@ protected MockEth2TopicHandler( new OperationMilestoneValidator<>( spec, spec.getForkSchedule().getFork(UInt64.ZERO), message -> UInt64.ZERO), spec.getGenesisSchemaDefinitions().getSignedBeaconBlockSchema(), - spec.getNetworkingConfig()); + spec.getNetworkingConfig(), + debugDataDumper); this.forkDigest = recentChainData.getForkDigestByMilestone(SpecMilestone.PHASE0).orElseThrow(); deserializer = @@ -321,7 +352,8 @@ public void setDeserializer(final Deserializer deserializer) } @Override - public SignedBeaconBlock deserialize(PreparedGossipMessage message) throws DecodingException { + public SignedBeaconBlock deserialize(final PreparedGossipMessage message) + throws DecodingException { return deserializer.deserialize(message); } diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/ProposerSlashingTopicHandlerTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/ProposerSlashingTopicHandlerTest.java index 32b80a67a17..46c5c35a335 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/ProposerSlashingTopicHandlerTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/ProposerSlashingTopicHandlerTest.java @@ -26,6 +26,7 @@ import tech.pegasys.teku.networking.eth2.gossip.ProposerSlashingGossipManager; import tech.pegasys.teku.networking.eth2.gossip.topics.topichandlers.Eth2TopicHandler; import tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.statetransition.validation.InternalValidationResult; public class ProposerSlashingTopicHandlerTest extends AbstractTopicHandlerTest { @@ -39,7 +40,8 @@ protected Eth2TopicHandler createHandler() { gossipEncoding, forkInfo, processor, - spec.getNetworkingConfig()) + spec.getNetworkingConfig(), + DebugDataDumper.NOOP) .getTopicHandler(); } diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/SingleAttestationTopicHandlerTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/SingleAttestationTopicHandlerTest.java index 3f9607898d9..c796c72b810 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/SingleAttestationTopicHandlerTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/SingleAttestationTopicHandlerTest.java @@ -30,6 +30,7 @@ import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; import tech.pegasys.teku.spec.datastructures.blocks.StateAndBlockSummary; import tech.pegasys.teku.spec.generator.AttestationGenerator; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.statetransition.validation.InternalValidationResult; public class SingleAttestationTopicHandlerTest @@ -48,7 +49,8 @@ protected Eth2TopicHandler createHandler() { forkInfo, GossipTopicName.getAttestationSubnetTopicName(SUBNET_ID), spec.getGenesisSchemaDefinitions().getAttestationSchema(), - SUBNET_ID); + SUBNET_ID, + DebugDataDumper.NOOP); } @Test diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/VoluntaryExitTopicHandlerTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/VoluntaryExitTopicHandlerTest.java index b45c6561293..d1163adab52 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/VoluntaryExitTopicHandlerTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/topics/VoluntaryExitTopicHandlerTest.java @@ -28,6 +28,7 @@ import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.spec.generator.VoluntaryExitGenerator; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.statetransition.validation.InternalValidationResult; import tech.pegasys.teku.storage.storageSystem.InMemoryStorageSystemBuilder; import tech.pegasys.teku.storage.storageSystem.StorageSystem; @@ -47,7 +48,8 @@ protected Eth2TopicHandler createHandler() { gossipEncoding, forkInfo, processor, - spec.getNetworkingConfig()) + spec.getNetworkingConfig(), + DebugDataDumper.NOOP) .getTopicHandler(); } diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/peers/PeerChainValidatorTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/peers/PeerChainValidatorTest.java index 6430023124d..5b87b84c845 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/peers/PeerChainValidatorTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/peers/PeerChainValidatorTest.java @@ -362,7 +362,7 @@ public void remoteChainIsBehindLocalAnchorPoint_disallow() { } private void assertPeerChainRejected( - final SafeFuture result, DisconnectReason goodbyeReason) { + final SafeFuture result, final DisconnectReason goodbyeReason) { assertThat(result).isCompletedWithValue(false); verify(peer).disconnectCleanly(goodbyeReason); } @@ -478,7 +478,7 @@ private void remoteChainIsBehindOnDifferentChain() { .thenReturn(blockResult); } - private SignedBeaconBlock randomBlock(UInt64 slot) { + private SignedBeaconBlock randomBlock(final UInt64 slot) { return dataStructureUtil.randomSignedBeaconBlock(slot.longValue()); } diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BeaconBlocksByRangeMessageHandlerTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BeaconBlocksByRangeMessageHandlerTest.java index 738ebb2198a..ea2ac1af31c 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BeaconBlocksByRangeMessageHandlerTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BeaconBlocksByRangeMessageHandlerTest.java @@ -79,7 +79,7 @@ class BeaconBlocksByRangeMessageHandlerTest { blocksWStates.stream() .map(StateAndBlockSummary::getSignedBeaconBlock) .flatMap(Optional::stream) - .collect(Collectors.toList()); + .toList(); private final Eth2Peer peer = mock(Eth2Peer.class); diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BeaconBlocksByRootMessageHandlerTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BeaconBlocksByRootMessageHandlerTest.java index a140ad371be..2d1903f7c86 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BeaconBlocksByRootMessageHandlerTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BeaconBlocksByRootMessageHandlerTest.java @@ -95,7 +95,7 @@ public void setup() { } @Test - public void onIncomingMessage_shouldRejectRequestWhenCountIsTooBig() { + public void validateRequest_shouldRejectRequestWhenCountIsTooBig() { final UInt64 denebForkEpoch = UInt64.valueOf(4); // Testing for Deneb since can't initialize BeaconBlocksByRootMessageHandler with size more // than MAX_REQUEST_BLOCKS @@ -115,18 +115,15 @@ public void onIncomingMessage_shouldRejectRequestWhenCountIsTooBig() { .map(__ -> Bytes32.ZERO) .collect(Collectors.toList()); - handler.onIncomingMessage( - V2_PROTOCOL_ID, - peer, - new BeaconBlocksByRootRequestMessage( - spec.getGenesisSchemaDefinitions().getBeaconBlocksByRootRequestMessageSchema(), roots), - callback); - - // Rate limiter not invoked - verify(peer, never()).approveBlocksRequest(any(), anyLong()); - - verify(callback) - .completeWithErrorResponse( + final Optional result = + handler.validateRequest( + V2_PROTOCOL_ID, + new BeaconBlocksByRootRequestMessage( + spec.getGenesisSchemaDefinitions().getBeaconBlocksByRootRequestMessageSchema(), + roots)); + + assertThat(result) + .hasValue( new RpcException( INVALID_REQUEST_CODE, "Only a maximum of 128 blocks can be requested per request")); } diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRangeListenerValidatingProxyTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRangeListenerValidatingProxyTest.java index 384ee3c096c..5c3557bf086 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRangeListenerValidatingProxyTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRangeListenerValidatingProxyTest.java @@ -20,52 +20,76 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.async.SafeFutureAssert.safeJoin; -import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ONE; -import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ZERO; +import static tech.pegasys.teku.networking.eth2.rpc.beaconchain.methods.BlobSidecarsByRootValidatorTest.breakInclusionProof; +import static tech.pegasys.teku.spec.SpecMilestone.CAPELLA; +import static tech.pegasys.teku.spec.SpecMilestone.DENEB; +import static tech.pegasys.teku.spec.SpecMilestone.ELECTRA; +import java.util.stream.IntStream; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestTemplate; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.kzg.KZG; import tech.pegasys.teku.networking.eth2.peers.Eth2Peer; import tech.pegasys.teku.networking.p2p.rpc.RpcResponseListener; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.TestSpecContext; import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider.SpecContext; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.util.DataStructureUtil; @SuppressWarnings("JavaCase") +@TestSpecContext(milestone = {DENEB, ELECTRA}) public class BlobSidecarsByRangeListenerValidatingProxyTest { - private final Spec spec = TestSpecFactory.createMainnetDeneb(); - private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); + + private final UInt64 currentForkEpoch = UInt64.valueOf(1); + private Spec spec; + private DataStructureUtil dataStructureUtil; + private UInt64 currentForkFirstSlot; private BlobSidecarsByRangeListenerValidatingProxy listenerWrapper; + private Integer maxBlobsPerBlock; private final Eth2Peer peer = mock(Eth2Peer.class); - private final Integer maxBlobsPerBlock = spec.getMaxBlobsPerBlock().orElseThrow(); private final KZG kzg = mock(KZG.class); @SuppressWarnings("unchecked") private final RpcResponseListener listener = mock(RpcResponseListener.class); @BeforeEach - void setUp() { + void setUp(final SpecContext specContext) { + spec = + switch (specContext.getSpecMilestone()) { + case PHASE0 -> throw new IllegalArgumentException("Phase0 is an unsupported milestone"); + case ALTAIR -> throw new IllegalArgumentException("Altair is an unsupported milestone"); + case BELLATRIX -> + throw new IllegalArgumentException("Bellatrix is an unsupported milestone"); + case CAPELLA -> throw new IllegalArgumentException("Capella is an unsupported milestone"); + case DENEB -> TestSpecFactory.createMinimalWithDenebForkEpoch(currentForkEpoch); + case ELECTRA -> TestSpecFactory.createMinimalWithElectraForkEpoch(currentForkEpoch); + case FULU -> TestSpecFactory.createMinimalWithFuluForkEpoch(currentForkEpoch); + }; + currentForkFirstSlot = spec.computeStartSlotAtEpoch(currentForkEpoch); + dataStructureUtil = new DataStructureUtil(spec); + maxBlobsPerBlock = spec.getMaxBlobsPerBlockForHighestMilestone().orElseThrow(); + when(listener.onResponse(any())).thenReturn(SafeFuture.completedFuture(null)); when(kzg.verifyBlobKzgProof(any(), any(), any())).thenReturn(true); } - @Test + @TestTemplate void blobSidecarFailsKzgVerification() { when(kzg.verifyBlobKzgProof(any(), any(), any())).thenReturn(false); - final UInt64 startSlot = UInt64.valueOf(1); + final UInt64 startSlot = currentForkFirstSlot; final UInt64 count = UInt64.valueOf(4); listenerWrapper = new BlobSidecarsByRangeListenerValidatingProxy( spec, peer, listener, maxBlobsPerBlock, kzg, startSlot, count); final BlobSidecar blobSidecar1_0 = - dataStructureUtil.randomBlobSidecarForBlock( - dataStructureUtil.randomSignedBeaconBlock(ONE), 0); + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock( + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot), 0); final SafeFuture result = listenerWrapper.onResponse(blobSidecar1_0); assertThat(result).isCompletedExceptionally(); @@ -78,17 +102,41 @@ void blobSidecarFailsKzgVerification() { .describe()); } - @Test + @TestTemplate + void blobSidecarFailsInclusionProofVerification() { + final UInt64 startSlot = currentForkFirstSlot; + final UInt64 count = UInt64.valueOf(4); + listenerWrapper = + new BlobSidecarsByRangeListenerValidatingProxy( + spec, peer, listener, maxBlobsPerBlock, kzg, startSlot, count); + + final BlobSidecar blobSidecar1_0 = + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock( + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot), 0); + final BlobSidecar blobSidecar1_0_modified = breakInclusionProof(blobSidecar1_0); + + final SafeFuture result = listenerWrapper.onResponse(blobSidecar1_0_modified); + assertThat(result).isCompletedExceptionally(); + assertThatThrownBy(result::get) + .hasCauseExactlyInstanceOf(BlobSidecarsResponseInvalidResponseException.class); + assertThatThrownBy(result::get) + .hasMessageContaining( + BlobSidecarsResponseInvalidResponseException.InvalidResponseType + .BLOB_SIDECAR_INCLUSION_PROOF_VERIFICATION_FAILED + .describe()); + } + + @TestTemplate void blobSidecarSlotSmallerThanFromSlot() { - final UInt64 startSlot = UInt64.valueOf(1); + final UInt64 startSlot = currentForkFirstSlot.plus(1); final UInt64 count = UInt64.valueOf(4); listenerWrapper = new BlobSidecarsByRangeListenerValidatingProxy( spec, peer, listener, maxBlobsPerBlock, kzg, startSlot, count); final BlobSidecar blobSidecar0_0 = - dataStructureUtil.randomBlobSidecarForBlock( - dataStructureUtil.randomSignedBeaconBlock(ZERO), 0); + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock( + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot), 0); final SafeFuture result = listenerWrapper.onResponse(blobSidecar0_0); assertThat(result).isCompletedExceptionally(); @@ -101,26 +149,35 @@ void blobSidecarSlotSmallerThanFromSlot() { .describe()); } - @Test + @TestTemplate void blobSidecarsSlotsAreCorrect() { - final UInt64 startSlot = UInt64.valueOf(1); + final UInt64 startSlot = currentForkFirstSlot; final UInt64 count = UInt64.valueOf(4); listenerWrapper = new BlobSidecarsByRangeListenerValidatingProxy( spec, peer, listener, maxBlobsPerBlock, kzg, startSlot, count); - final SignedBeaconBlock block1 = dataStructureUtil.randomSignedBeaconBlock(ONE); - final BlobSidecar blobSidecar1_0 = dataStructureUtil.randomBlobSidecarForBlock(block1, 0); - final BlobSidecar blobSidecar1_1 = dataStructureUtil.randomBlobSidecarForBlock(block1, 1); + final SignedBeaconBlock block1 = + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot); + final BlobSidecar blobSidecar1_0 = + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock(block1, 0); + final BlobSidecar blobSidecar1_1 = + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock(block1, 1); final BlobSidecar blobSidecar2_0 = - dataStructureUtil.randomBlobSidecarForBlock( - dataStructureUtil.randomSignedBeaconBlock(2, block1.getRoot()), 0); + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock( + dataStructureUtil.randomSignedBeaconBlock( + currentForkFirstSlot.plus(1).longValue(), block1.getRoot()), + 0); final BlobSidecar blobSidecar3_0 = - dataStructureUtil.randomBlobSidecarForBlock( - dataStructureUtil.randomSignedBeaconBlock(3, blobSidecar2_0.getBlockRoot()), 0); + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock( + dataStructureUtil.randomSignedBeaconBlock( + currentForkFirstSlot.plus(2).longValue(), blobSidecar2_0.getBlockRoot()), + 0); final BlobSidecar blobSidecar4_0 = - dataStructureUtil.randomBlobSidecarForBlock( - dataStructureUtil.randomSignedBeaconBlock(4, blobSidecar3_0.getBlockRoot()), 0); + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock( + dataStructureUtil.randomSignedBeaconBlock( + currentForkFirstSlot.plus(3).longValue(), blobSidecar3_0.getBlockRoot()), + 0); assertDoesNotThrow(() -> listenerWrapper.onResponse(blobSidecar1_0).join()); assertDoesNotThrow(() -> listenerWrapper.onResponse(blobSidecar1_1).join()); @@ -129,9 +186,9 @@ void blobSidecarsSlotsAreCorrect() { assertDoesNotThrow(() -> listenerWrapper.onResponse(blobSidecar4_0).join()); } - @Test + @TestTemplate void blobSidecarSlotGreaterThanToSlot() { - final UInt64 startSlot = UInt64.valueOf(1); + final UInt64 startSlot = currentForkFirstSlot; final UInt64 count = UInt64.valueOf(8); // This requests 8 slots (1, 2, 3, 4, 5, 6, 7, 8) so 9 will be unexpected. listenerWrapper = @@ -139,20 +196,22 @@ void blobSidecarSlotGreaterThanToSlot() { spec, peer, listener, maxBlobsPerBlock, kzg, startSlot, count); final BlobSidecar blobSidecar1_0 = - dataStructureUtil.randomBlobSidecarForBlock( - dataStructureUtil.randomSignedBeaconBlock(1), 0); + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock( + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot), 0); final BlobSidecar blobSidecar3_0 = - dataStructureUtil.randomBlobSidecarForBlock( - dataStructureUtil.randomSignedBeaconBlock(3), 0); + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock( + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot.plus(2)), 0); final BlobSidecar blobSidecar5_0 = - dataStructureUtil.randomBlobSidecarForBlock( - dataStructureUtil.randomSignedBeaconBlock(5), 0); + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock( + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot.plus(4)), 0); final BlobSidecar blobSidecar8_0 = - dataStructureUtil.randomBlobSidecarForBlock( - dataStructureUtil.randomSignedBeaconBlock(8), 0); + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock( + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot.plus(7)), 0); final BlobSidecar blobSidecar9_0 = - dataStructureUtil.randomBlobSidecarForBlock( - dataStructureUtil.randomSignedBeaconBlock(9, blobSidecar8_0.getBlockRoot()), 0); + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock( + dataStructureUtil.randomSignedBeaconBlock( + currentForkFirstSlot.plus(8).longValue(), blobSidecar8_0.getBlockRoot()), + 0); safeJoin(listenerWrapper.onResponse(blobSidecar1_0)); safeJoin(listenerWrapper.onResponse(blobSidecar3_0)); @@ -170,20 +229,20 @@ void blobSidecarSlotGreaterThanToSlot() { .describe()); } - @Test + @TestTemplate void blobSidecarParentRootDoesNotMatch() { - final UInt64 startSlot = UInt64.valueOf(1); + final UInt64 startSlot = currentForkFirstSlot; final UInt64 count = UInt64.valueOf(4); listenerWrapper = new BlobSidecarsByRangeListenerValidatingProxy( spec, peer, listener, maxBlobsPerBlock, kzg, startSlot, count); final BlobSidecar blobSidecar1_0 = - dataStructureUtil.randomBlobSidecarForBlock( - dataStructureUtil.randomSignedBeaconBlock(1), 0); + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock( + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot), 0); final BlobSidecar blobSidecar2_0 = - dataStructureUtil.randomBlobSidecarForBlock( - dataStructureUtil.randomSignedBeaconBlock(2), 0); + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock( + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot.plus(1)), 0); safeJoin(listenerWrapper.onResponse(blobSidecar1_0)); @@ -198,32 +257,31 @@ void blobSidecarParentRootDoesNotMatch() { .describe()); } - @Test + @TestTemplate void blobSidecarIndexIsGreaterOrEqualThanMaxBlobs() { - final UInt64 startSlot = UInt64.valueOf(1); + final UInt64 startSlot = currentForkFirstSlot; final UInt64 count = UInt64.valueOf(4); listenerWrapper = new BlobSidecarsByRangeListenerValidatingProxy( spec, peer, listener, maxBlobsPerBlock, kzg, startSlot, count); - final SignedBeaconBlock block1 = dataStructureUtil.randomSignedBeaconBlock(ONE); - final BlobSidecar blobSidecar1_0 = dataStructureUtil.randomBlobSidecarForBlock(block1, 0); - final BlobSidecar blobSidecar1_1 = dataStructureUtil.randomBlobSidecarForBlock(block1, 1); - final BlobSidecar blobSidecar1_2 = dataStructureUtil.randomBlobSidecarForBlock(block1, 2); - final BlobSidecar blobSidecar1_3 = dataStructureUtil.randomBlobSidecarForBlock(block1, 3); - final BlobSidecar blobSidecar1_4 = dataStructureUtil.randomBlobSidecarForBlock(block1, 4); - final BlobSidecar blobSidecar1_5 = dataStructureUtil.randomBlobSidecarForBlock(block1, 5); - final BlobSidecar blobSidecar1_6 = dataStructureUtil.randomBlobSidecarForBlock(block1, 6); + final int exceedingBlobCount = spec.getMaxBlobsPerBlockForHighestMilestone().orElseThrow() + 1; + final int exceedingBlobIndex = exceedingBlobCount - 1; + final SignedBeaconBlock block1 = + dataStructureUtil.randomSignedBeaconBlockWithCommitments( + currentForkFirstSlot, exceedingBlobCount); - safeJoin(listenerWrapper.onResponse(blobSidecar1_0)); - safeJoin(listenerWrapper.onResponse(blobSidecar1_1)); - safeJoin(listenerWrapper.onResponse(blobSidecar1_2)); - safeJoin(listenerWrapper.onResponse(blobSidecar1_3)); - safeJoin(listenerWrapper.onResponse(blobSidecar1_4)); - safeJoin(listenerWrapper.onResponse(blobSidecar1_5)); + IntStream.range(0, exceedingBlobCount - 1) + .mapToObj( + i -> dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock(block1, i)) + .forEach(blobSidecar -> safeJoin(listenerWrapper.onResponse(blobSidecar))); + + final SafeFuture result = + listenerWrapper.onResponse( + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock( + block1, exceedingBlobIndex)); - final SafeFuture result = listenerWrapper.onResponse(blobSidecar1_6); assertThat(result).isCompletedExceptionally(); assertThatThrownBy(result::get) .hasCauseExactlyInstanceOf(BlobSidecarsResponseInvalidResponseException.class); @@ -234,18 +292,21 @@ void blobSidecarIndexIsGreaterOrEqualThanMaxBlobs() { .describe()); } - @Test + @TestTemplate void blobSidecarIndexIsInTheSameBlockButNotNext() { - final UInt64 startSlot = UInt64.valueOf(1); + final UInt64 startSlot = currentForkFirstSlot; final UInt64 count = UInt64.valueOf(4); listenerWrapper = new BlobSidecarsByRangeListenerValidatingProxy( spec, peer, listener, maxBlobsPerBlock, kzg, startSlot, count); - final SignedBeaconBlock block1 = dataStructureUtil.randomSignedBeaconBlock(ONE); - final BlobSidecar blobSidecar1_0 = dataStructureUtil.randomBlobSidecarForBlock(block1, 0); - final BlobSidecar blobSidecar1_2 = dataStructureUtil.randomBlobSidecarForBlock(block1, 2); + final SignedBeaconBlock block1 = + dataStructureUtil.randomSignedBeaconBlockWithCommitments(currentForkFirstSlot, 3); + final BlobSidecar blobSidecar1_0 = + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock(block1, 0); + final BlobSidecar blobSidecar1_2 = + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock(block1, 2); safeJoin(listenerWrapper.onResponse(blobSidecar1_0)); @@ -260,38 +321,41 @@ void blobSidecarIndexIsInTheSameBlockButNotNext() { .describe()); } - @Test + @TestTemplate void isFirstBlobSidecarAfterAnEmptyBlobsBlock() { - final UInt64 startSlot = UInt64.valueOf(1); + final UInt64 startSlot = currentForkFirstSlot; final UInt64 count = UInt64.valueOf(4); listenerWrapper = new BlobSidecarsByRangeListenerValidatingProxy( spec, peer, listener, maxBlobsPerBlock, kzg, startSlot, count); - final SignedBeaconBlock block1 = dataStructureUtil.randomSignedBeaconBlock(ONE); - final BlobSidecar blobSidecar1_0 = dataStructureUtil.randomBlobSidecarForBlock(block1, 0); - final BlobSidecar blobSidecar1_1 = dataStructureUtil.randomBlobSidecarForBlock(block1, 1); + final SignedBeaconBlock block1 = + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot); + final BlobSidecar blobSidecar1_0 = + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock(block1, 0); + final BlobSidecar blobSidecar1_1 = + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock(block1, 1); final BlobSidecar blobSidecar3_0 = - dataStructureUtil.randomBlobSidecarForBlock( - dataStructureUtil.randomSignedBeaconBlock(3), 0); + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock( + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot.plus(3)), 0); safeJoin(listenerWrapper.onResponse(blobSidecar1_0)); safeJoin(listenerWrapper.onResponse(blobSidecar1_1)); safeJoin(listenerWrapper.onResponse(blobSidecar3_0)); } - @Test + @TestTemplate void firstBlobSidecarIndexIsINotZero() { - final UInt64 startSlot = UInt64.valueOf(1); + final UInt64 startSlot = currentForkFirstSlot; final UInt64 count = UInt64.valueOf(4); listenerWrapper = new BlobSidecarsByRangeListenerValidatingProxy( spec, peer, listener, maxBlobsPerBlock, kzg, startSlot, count); final BlobSidecar blobSidecar1_1 = - dataStructureUtil.randomBlobSidecarForBlock( - dataStructureUtil.randomSignedBeaconBlock(2), 1); + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock( + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot.plus(1)), 1); final SafeFuture result = listenerWrapper.onResponse(blobSidecar1_1); assertThat(result).isCompletedExceptionally(); @@ -304,20 +368,22 @@ void firstBlobSidecarIndexIsINotZero() { .describe()); } - @Test + @TestTemplate void firstBlobSidecarIndexInNextBlockIsNotZero() { - final UInt64 startSlot = UInt64.valueOf(1); + final UInt64 startSlot = currentForkFirstSlot; final UInt64 count = UInt64.valueOf(4); listenerWrapper = new BlobSidecarsByRangeListenerValidatingProxy( spec, peer, listener, maxBlobsPerBlock, kzg, startSlot, count); final BlobSidecar blobSidecar1_0 = - dataStructureUtil.randomBlobSidecarForBlock( - dataStructureUtil.randomSignedBeaconBlock(1), 0); + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock( + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot), 0); final BlobSidecar blobSidecar2_1 = - dataStructureUtil.randomBlobSidecarForBlock( - dataStructureUtil.randomSignedBeaconBlock(2, blobSidecar1_0.getBlockRoot()), 1); + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock( + dataStructureUtil.randomSignedBeaconBlock( + currentForkFirstSlot.plus(1).longValue(), blobSidecar1_0.getBlockRoot(), true), + 1); assertDoesNotThrow(() -> listenerWrapper.onResponse(blobSidecar1_0).join()); @@ -332,20 +398,20 @@ void firstBlobSidecarIndexInNextBlockIsNotZero() { .describe()); } - @Test + @TestTemplate void blobSidecarUnexpectedSlot() { - final UInt64 startSlot = UInt64.valueOf(1); + final UInt64 startSlot = currentForkFirstSlot; final UInt64 count = UInt64.valueOf(4); listenerWrapper = new BlobSidecarsByRangeListenerValidatingProxy( spec, peer, listener, maxBlobsPerBlock, kzg, startSlot, count); final BlobSidecar blobSidecar2_0 = - dataStructureUtil.randomBlobSidecarForBlock( - dataStructureUtil.randomSignedBeaconBlock(2), 0); + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock( + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot.plus(1)), 0); final BlobSidecar blobSidecar1_0 = - dataStructureUtil.randomBlobSidecarForBlock( - dataStructureUtil.randomSignedBeaconBlock(1), 0); + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock( + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot), 0); safeJoin(listenerWrapper.onResponse(blobSidecar2_0)); final SafeFuture result = listenerWrapper.onResponse(blobSidecar1_0); diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRangeMessageHandlerTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRangeMessageHandlerTest.java index 3d03e20071e..8ce0692477a 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRangeMessageHandlerTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRangeMessageHandlerTest.java @@ -34,10 +34,9 @@ import java.util.Optional; import java.util.stream.Collectors; import org.apache.commons.lang3.tuple.Pair; -import org.apache.tuweni.bytes.Bytes32; import org.assertj.core.api.AssertionsForInterfaceTypes; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestTemplate; import org.mockito.ArgumentCaptor; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.metrics.StubMetricsSystem; @@ -51,7 +50,9 @@ import tech.pegasys.teku.networking.eth2.rpc.core.encodings.RpcEncoding; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecContext; import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider; import tech.pegasys.teku.spec.config.SpecConfigDeneb; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; @@ -59,73 +60,75 @@ import tech.pegasys.teku.spec.datastructures.blocks.SlotAndBlockRoot; import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.BlobSidecarsByRangeRequestMessage; import tech.pegasys.teku.spec.datastructures.util.SlotAndBlockRootAndBlobIndex; -import tech.pegasys.teku.spec.logic.versions.deneb.helpers.MiscHelpersDeneb; import tech.pegasys.teku.spec.util.DataStructureUtil; import tech.pegasys.teku.storage.client.CombinedChainDataClient; import tech.pegasys.teku.storage.store.UpdatableStore; +@TestSpecContext(milestone = {SpecMilestone.DENEB, SpecMilestone.ELECTRA}) public class BlobSidecarsByRangeMessageHandlerTest { private static final RequestApproval ZERO_OBJECTS_REQUEST_APPROVAL = new RequestApproval.RequestApprovalBuilder().timeSeconds(ZERO).objectsCount(0).build(); - private static final RpcEncoding RPC_ENCODING = RpcEncoding.createSszSnappyEncoding( TestSpecFactory.createDefault().getNetworkingConfig().getMaxChunkSize()); - private final UInt64 genesisTime = UInt64.valueOf(1982239L); - private final UInt64 denebForkEpoch = UInt64.valueOf(1); - - private final Spec spec = TestSpecFactory.createMinimalWithDenebForkEpoch(denebForkEpoch); - - private final SpecConfigDeneb specConfigDeneb = - SpecConfigDeneb.required(spec.forMilestone(SpecMilestone.DENEB).getConfig()); - - private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); - - private final int maxBlobsPerBlock = specConfigDeneb.getMaxBlobsPerBlock(); - - private final int slotsPerEpoch = spec.getSlotsPerEpoch(ZERO); - - private final UInt64 startSlot = denebForkEpoch.increment().times(slotsPerEpoch); - - private final Bytes32 headBlockRoot = dataStructureUtil.randomBytes32(); - + private final UInt64 currentForkEpoch = UInt64.valueOf(1); private final UInt64 count = UInt64.valueOf(5); - private final StubMetricsSystem metricsSystem = new StubMetricsSystem(); - private final Eth2Peer peer = mock(Eth2Peer.class); - private final MiscHelpersDeneb miscHelpers = - spec.forMilestone(SpecMilestone.DENEB).miscHelpers().toVersionDeneb().orElseThrow(); - @SuppressWarnings("unchecked") private final ResponseCallback listener = mock(ResponseCallback.class); private final CombinedChainDataClient combinedChainDataClient = mock(CombinedChainDataClient.class); private final UpdatableStore store = mock(UpdatableStore.class); - private final String protocolId = BeaconChainMethodIds.getBlobSidecarsByRangeMethodId(1, RPC_ENCODING); - - private final BlobSidecarsByRangeMessageHandler handler = - new BlobSidecarsByRangeMessageHandler( - spec, specConfigDeneb, metricsSystem, combinedChainDataClient); private final Optional allowedObjectsRequest = Optional.of( new RequestApproval.RequestApprovalBuilder().objectsCount(100).timeSeconds(ZERO).build()); + private SpecMilestone specMilestone; + private Spec spec; + private BlobSidecarsByRangeMessageHandler handler; + private DataStructureUtil dataStructureUtil; + private int maxBlobsPerBlock; + private int slotsPerEpoch; + private UInt64 startSlot; + @BeforeEach - public void setUp() { + public void setUp(final TestSpecInvocationContextProvider.SpecContext specContext) { + specMilestone = specContext.getSpecMilestone(); + spec = + switch (specContext.getSpecMilestone()) { + case PHASE0 -> throw new IllegalArgumentException("Phase0 is an unsupported milestone"); + case ALTAIR -> throw new IllegalArgumentException("Altair is an unsupported milestone"); + case BELLATRIX -> + throw new IllegalArgumentException("Bellatrix is an unsupported milestone"); + case CAPELLA -> throw new IllegalArgumentException("Capella is an unsupported milestone"); + case DENEB -> TestSpecFactory.createMinimalWithDenebForkEpoch(currentForkEpoch); + case ELECTRA -> TestSpecFactory.createMinimalWithElectraForkEpoch(currentForkEpoch); + case FULU -> TestSpecFactory.createMinimalWithFuluForkEpoch(currentForkEpoch); + }; + + dataStructureUtil = new DataStructureUtil(spec); + maxBlobsPerBlock = + SpecConfigDeneb.required(spec.forMilestone(specMilestone).getConfig()) + .getMaxBlobsPerBlock(); + slotsPerEpoch = spec.getSlotsPerEpoch(ZERO); + startSlot = currentForkEpoch.increment().times(slotsPerEpoch); + handler = new BlobSidecarsByRangeMessageHandler(spec, metricsSystem, combinedChainDataClient); + when(peer.approveRequest()).thenReturn(true); when(peer.approveBlobSidecarsRequest(eq(listener), anyLong())) .thenReturn(allowedObjectsRequest); when(combinedChainDataClient.getEarliestAvailableBlobSidecarSlot()) .thenReturn(SafeFuture.completedFuture(Optional.of(ZERO))); when(combinedChainDataClient.getStore()).thenReturn(store); - when(combinedChainDataClient.getBestBlockRoot()).thenReturn(Optional.of(headBlockRoot)); + when(combinedChainDataClient.getBestBlockRoot()) + .thenReturn(Optional.of(dataStructureUtil.randomBytes32())); // everything is finalized by default when(combinedChainDataClient.getFinalizedBlockSlot()) .thenReturn(Optional.of(startSlot.plus(count))); @@ -133,10 +136,10 @@ public void setUp() { // mock store when(store.getGenesisTime()).thenReturn(genesisTime); - setCurrentEpoch(denebForkEpoch.increment()); + setCurrentEpoch(currentForkEpoch.increment()); } - @Test + @TestTemplate public void validateRequest_validRequest() { final Optional result = handler.validateRequest( @@ -144,18 +147,25 @@ public void validateRequest_validRequest() { assertThat(result).isEmpty(); } - @Test - public void shouldNotSendBlobSidecarsIfCountIsTooBig() { + @TestTemplate + public void validateRequest_shouldRejectRequestWhenCountIsTooBig() { final UInt64 maxRequestBlobSidecars = - UInt64.valueOf(specConfigDeneb.getMaxRequestBlobSidecars()); + UInt64.valueOf( + SpecConfigDeneb.required(spec.forMilestone(specMilestone).getConfig()) + .getMaxRequestBlobSidecars()); final BlobSidecarsByRangeRequestMessage request = new BlobSidecarsByRangeRequestMessage( startSlot, maxRequestBlobSidecars.increment(), maxBlobsPerBlock); - handler.onIncomingMessage(protocolId, peer, request, listener); + final Optional result = handler.validateRequest(protocolId, request); - // Rate limiter not invoked - verify(peer, never()).approveBlobSidecarsRequest(any(), anyLong()); + assertThat(result) + .hasValue( + new RpcException( + INVALID_REQUEST_CODE, + String.format( + "Only a maximum of %s blob sidecars can be requested per request", + maxRequestBlobSidecars))); final long rateLimitedCount = metricsSystem @@ -163,17 +173,9 @@ public void shouldNotSendBlobSidecarsIfCountIsTooBig() { .getValue("count_too_big"); assertThat(rateLimitedCount).isOne(); - - verify(listener) - .completeWithErrorResponse( - new RpcException( - INVALID_REQUEST_CODE, - String.format( - "Only a maximum of %s blob sidecars can be requested per request", - maxRequestBlobSidecars))); } - @Test + @TestTemplate public void shouldNotSendBlobSidecarsIfPeerIsRateLimited() { when(peer.approveBlobSidecarsRequest(listener, count.times(maxBlobsPerBlock).longValue())) @@ -200,7 +202,7 @@ public void shouldNotSendBlobSidecarsIfPeerIsRateLimited() { verifyNoInteractions(listener); } - @Test + @TestTemplate public void shouldSendResourceUnavailableIfBlobSidecarsAreNotAvailable() { // current epoch is 5020 @@ -210,7 +212,7 @@ public void shouldSendResourceUnavailableIfBlobSidecarsAreNotAvailable() { when(combinedChainDataClient.getEarliestAvailableBlobSidecarSlot()) .thenReturn( SafeFuture.completedFuture( - Optional.of(denebForkEpoch.plus(5009).times(slotsPerEpoch)))); + Optional.of(currentForkEpoch.plus(5009).times(slotsPerEpoch)))); // start slot in epoch 5000 within MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS range final BlobSidecarsByRangeRequestMessage request = @@ -234,12 +236,13 @@ public void shouldSendResourceUnavailableIfBlobSidecarsAreNotAvailable() { "Requested blob sidecars are not available.")); } - @Test + @TestTemplate public void shouldCompleteSuccessfullyIfNoBlobSidecarsInRange() { - when(combinedChainDataClient.getBlobSidecarKeys(any(), any(), any())) + when(combinedChainDataClient.getBlobSidecarKeys(any(), any(), anyLong())) .thenReturn(SafeFuture.completedFuture(Collections.emptyList())); final BlobSidecarsByRangeRequestMessage request = - new BlobSidecarsByRangeRequestMessage(ZERO, count, maxBlobsPerBlock); + new BlobSidecarsByRangeRequestMessage( + currentForkEpoch.plus(1).times(slotsPerEpoch), count, maxBlobsPerBlock); handler.onIncomingMessage(protocolId, peer, request, listener); @@ -257,7 +260,7 @@ public void shouldCompleteSuccessfullyIfNoBlobSidecarsInRange() { verify(listener).completeSuccessfully(); } - @Test + @TestTemplate public void shouldSendToPeerRequestedNumberOfFinalizedBlobSidecars() { final BlobSidecarsByRangeRequestMessage request = @@ -286,7 +289,7 @@ public void shouldSendToPeerRequestedNumberOfFinalizedBlobSidecars() { AssertionsForInterfaceTypes.assertThat(actualSent).containsExactlyElementsOf(expectedSent); } - @Test + @TestTemplate public void shouldSendToPeerRequestedNumberOfCanonicalBlobSidecars() { final UInt64 latestFinalizedSlot = startSlot.plus(count).minus(3); @@ -302,7 +305,7 @@ public void shouldSendToPeerRequestedNumberOfCanonicalBlobSidecars() { // we simulate that the canonical non-finalized chain only contains blobs from last // slotAndBlockRoot final SlotAndBlockRoot canonicalSlotAndBlockRoot = - allAvailableBlobs.get(allAvailableBlobs.size() - 1).getSlotAndBlockRoot(); + allAvailableBlobs.getLast().getSlotAndBlockRoot(); final List expectedSent = allAvailableBlobs.stream() @@ -344,7 +347,7 @@ public void shouldSendToPeerRequestedNumberOfCanonicalBlobSidecars() { AssertionsForInterfaceTypes.assertThat(actualSent).containsExactlyElementsOf(expectedSent); } - @Test + @TestTemplate public void shouldIgnoreRequestWhenCountIsZero() { final BlobSidecarsByRangeRequestMessage request = @@ -370,7 +373,7 @@ public void shouldIgnoreRequestWhenCountIsZero() { AssertionsForInterfaceTypes.assertThat(actualSent).isEmpty(); } - @Test + @TestTemplate public void shouldIgnoreRequestWhenCountIsZeroAndHotSlotRequested() { // not finalized final UInt64 hotStartSlot = startSlot.plus(7); @@ -407,15 +410,13 @@ private void setCurrentEpoch(final UInt64 currentEpoch) { private List setUpBlobSidecarsData(final UInt64 startSlot, final UInt64 maxSlot) { final List> headerAndKeys = setupKeyAndHeaderList(startSlot, maxSlot); - when(combinedChainDataClient.getBlobSidecarKeys(eq(startSlot), eq(maxSlot), any())) + when(combinedChainDataClient.getBlobSidecarKeys(eq(startSlot), eq(maxSlot), anyLong())) .thenAnswer( args -> SafeFuture.completedFuture( headerAndKeys .subList( - 0, - Math.min( - headerAndKeys.size(), ((UInt64) args.getArgument(2)).intValue())) + 0, Math.min(headerAndKeys.size(), Math.toIntExact(args.getArgument(2)))) .stream() .map(Pair::getValue) .toList())); @@ -435,7 +436,10 @@ private List> setupK UInt64.rangeClosed( ZERO, dataStructureUtil - .randomUInt64(miscHelpers.getBlobKzgCommitmentsCount(block)) + .randomUInt64( + spec.forMilestone(specMilestone) + .miscHelpers() + .getBlobKzgCommitmentsCount(block)) .minusMinZero(1)) .forEach( index -> diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRootListenerValidatingProxyTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRootListenerValidatingProxyTest.java index 679cb76387c..22c0bba0ad2 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRootListenerValidatingProxyTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRootListenerValidatingProxyTest.java @@ -19,45 +19,72 @@ import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import static tech.pegasys.teku.networking.eth2.rpc.beaconchain.methods.BlobSidecarsByRootValidatorTest.breakInclusionProof; +import static tech.pegasys.teku.spec.SpecMilestone.DENEB; +import static tech.pegasys.teku.spec.SpecMilestone.ELECTRA; import java.util.List; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestTemplate; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.kzg.KZG; import tech.pegasys.teku.networking.eth2.peers.Eth2Peer; import tech.pegasys.teku.networking.p2p.rpc.RpcResponseListener; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.TestSpecContext; import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.BlobIdentifier; import tech.pegasys.teku.spec.util.DataStructureUtil; @SuppressWarnings("JavaCase") +@TestSpecContext(milestone = {DENEB, ELECTRA}) public class BlobSidecarsByRootListenerValidatingProxyTest { - private final Spec spec = TestSpecFactory.createMainnetDeneb(); - private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); - private BlobSidecarsByRootListenerValidatingProxy listenerWrapper; + + private final UInt64 currentForkEpoch = UInt64.valueOf(1); private final Eth2Peer peer = mock(Eth2Peer.class); private final KZG kzg = mock(KZG.class); @SuppressWarnings("unchecked") private final RpcResponseListener listener = mock(RpcResponseListener.class); + private Spec spec; + private DataStructureUtil dataStructureUtil; + private UInt64 currentForkFirstSlot; + private BlobSidecarsByRootListenerValidatingProxy listenerWrapper; + @BeforeEach - void setUp() { + void setUp(final TestSpecInvocationContextProvider.SpecContext specContext) { + spec = + switch (specContext.getSpecMilestone()) { + case PHASE0 -> throw new IllegalArgumentException("Phase0 is an unsupported milestone"); + case ALTAIR -> throw new IllegalArgumentException("Altair is an unsupported milestone"); + case BELLATRIX -> + throw new IllegalArgumentException("Bellatrix is an unsupported milestone"); + case CAPELLA -> throw new IllegalArgumentException("Capella is an unsupported milestone"); + case DENEB -> TestSpecFactory.createMinimalWithDenebForkEpoch(currentForkEpoch); + case ELECTRA -> TestSpecFactory.createMinimalWithElectraForkEpoch(currentForkEpoch); + case FULU -> TestSpecFactory.createMinimalWithFuluForkEpoch(currentForkEpoch); + }; + dataStructureUtil = new DataStructureUtil(spec); + currentForkFirstSlot = spec.computeStartSlotAtEpoch(currentForkEpoch); when(listener.onResponse(any())).thenReturn(SafeFuture.completedFuture(null)); when(kzg.verifyBlobKzgProof(any(), any(), any())).thenReturn(true); } - @Test + @TestTemplate void blobSidecarsAreCorrect() { - final SignedBeaconBlock block1 = dataStructureUtil.randomSignedBeaconBlock(UInt64.ONE); - final SignedBeaconBlock block2 = dataStructureUtil.randomSignedBeaconBlock(UInt64.valueOf(2)); - final SignedBeaconBlock block3 = dataStructureUtil.randomSignedBeaconBlock(UInt64.valueOf(3)); - final SignedBeaconBlock block4 = dataStructureUtil.randomSignedBeaconBlock(UInt64.valueOf(4)); + final SignedBeaconBlock block1 = + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot); + final SignedBeaconBlock block2 = + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot.plus(1)); + final SignedBeaconBlock block3 = + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot.plus(2)); + final SignedBeaconBlock block4 = + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot.plus(3)); final List blobIdentifiers = List.of( new BlobIdentifier(block1.getRoot(), UInt64.ZERO), @@ -69,11 +96,16 @@ void blobSidecarsAreCorrect() { listenerWrapper = new BlobSidecarsByRootListenerValidatingProxy(peer, spec, listener, kzg, blobIdentifiers); - final BlobSidecar blobSidecar1_0 = dataStructureUtil.randomBlobSidecarForBlock(block1, 0); - final BlobSidecar blobSidecar1_1 = dataStructureUtil.randomBlobSidecarForBlock(block1, 1); - final BlobSidecar blobSidecar2_0 = dataStructureUtil.randomBlobSidecarForBlock(block2, 0); - final BlobSidecar blobSidecar3_0 = dataStructureUtil.randomBlobSidecarForBlock(block3, 0); - final BlobSidecar blobSidecar4_0 = dataStructureUtil.randomBlobSidecarForBlock(block4, 0); + final BlobSidecar blobSidecar1_0 = + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock(block1, 0); + final BlobSidecar blobSidecar1_1 = + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock(block1, 1); + final BlobSidecar blobSidecar2_0 = + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock(block2, 0); + final BlobSidecar blobSidecar3_0 = + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock(block3, 0); + final BlobSidecar blobSidecar4_0 = + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock(block4, 0); assertDoesNotThrow(() -> listenerWrapper.onResponse(blobSidecar1_0).join()); assertDoesNotThrow(() -> listenerWrapper.onResponse(blobSidecar1_1).join()); @@ -82,10 +114,12 @@ void blobSidecarsAreCorrect() { assertDoesNotThrow(() -> listenerWrapper.onResponse(blobSidecar4_0).join()); } - @Test + @TestTemplate void blobSidecarIdentifierNotRequested() { - final SignedBeaconBlock block1 = dataStructureUtil.randomSignedBeaconBlock(UInt64.ONE); - final SignedBeaconBlock block2 = dataStructureUtil.randomSignedBeaconBlock(UInt64.valueOf(2)); + final SignedBeaconBlock block1 = + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot); + final SignedBeaconBlock block2 = + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot.plus(1)); final List blobIdentifiers = List.of( new BlobIdentifier(block1.getRoot(), UInt64.ZERO), @@ -93,9 +127,12 @@ void blobSidecarIdentifierNotRequested() { listenerWrapper = new BlobSidecarsByRootListenerValidatingProxy(peer, spec, listener, kzg, blobIdentifiers); - final BlobSidecar blobSidecar1_0 = dataStructureUtil.randomBlobSidecarForBlock(block1, 0); - final BlobSidecar blobSidecar1_1 = dataStructureUtil.randomBlobSidecarForBlock(block1, 1); - final BlobSidecar blobSidecar2_0 = dataStructureUtil.randomBlobSidecarForBlock(block2, 0); + final BlobSidecar blobSidecar1_0 = + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock(block1, 0); + final BlobSidecar blobSidecar1_1 = + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock(block1, 1); + final BlobSidecar blobSidecar2_0 = + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock(block2, 0); assertDoesNotThrow(() -> listenerWrapper.onResponse(blobSidecar1_0).join()); assertDoesNotThrow(() -> listenerWrapper.onResponse(blobSidecar1_1).join()); @@ -110,16 +147,20 @@ void blobSidecarIdentifierNotRequested() { .describe()); } - @Test + @TestTemplate void blobSidecarFailsKzgVerification() { when(kzg.verifyBlobKzgProof(any(), any(), any())).thenReturn(false); - final SignedBeaconBlock block1 = dataStructureUtil.randomSignedBeaconBlock(UInt64.ONE); - final BlobIdentifier blobIdentifier = new BlobIdentifier(block1.getRoot(), UInt64.ZERO); + final SignedBeaconBlock block1 = + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot); + final BlobIdentifier blobIdentifier = + new BlobIdentifier( + block1.getRoot(), spec.computeStartSlotAtEpoch(currentForkEpoch.minus(1))); listenerWrapper = new BlobSidecarsByRootListenerValidatingProxy( peer, spec, listener, kzg, List.of(blobIdentifier)); - final BlobSidecar blobSidecar1_0 = dataStructureUtil.randomBlobSidecarForBlock(block1, 0); + final BlobSidecar blobSidecar1_0 = + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock(block1, 0); final SafeFuture result = listenerWrapper.onResponse(blobSidecar1_0); assertThat(result).isCompletedExceptionally(); @@ -131,4 +172,30 @@ void blobSidecarFailsKzgVerification() { .BLOB_SIDECAR_KZG_VERIFICATION_FAILED .describe()); } + + @TestTemplate + void blobSidecarFailsInclusionProofVerification() { + final SignedBeaconBlock block1 = + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot); + final BlobIdentifier blobIdentifier = + new BlobIdentifier( + block1.getRoot(), spec.computeStartSlotAtEpoch(currentForkEpoch.minus(1))); + listenerWrapper = + new BlobSidecarsByRootListenerValidatingProxy( + peer, spec, listener, kzg, List.of(blobIdentifier)); + + final BlobSidecar blobSidecar1_0 = + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock(block1, 0); + final BlobSidecar blobSidecar1_0_modified = breakInclusionProof(blobSidecar1_0); + + final SafeFuture result = listenerWrapper.onResponse(blobSidecar1_0_modified); + assertThat(result).isCompletedExceptionally(); + assertThatThrownBy(result::get) + .hasCauseExactlyInstanceOf(BlobSidecarsResponseInvalidResponseException.class); + assertThatThrownBy(result::get) + .hasMessageContaining( + BlobSidecarsResponseInvalidResponseException.InvalidResponseType + .BLOB_SIDECAR_INCLUSION_PROOF_VERIFICATION_FAILED + .describe()); + } } diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRootMessageHandlerTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRootMessageHandlerTest.java index 8ab1801777e..a760f6cfe3a 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRootMessageHandlerTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRootMessageHandlerTest.java @@ -32,7 +32,7 @@ import java.util.stream.IntStream; import org.apache.tuweni.bytes.Bytes32; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestTemplate; import org.mockito.ArgumentCaptor; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.metrics.StubMetricsSystem; @@ -46,66 +46,83 @@ import tech.pegasys.teku.networking.eth2.rpc.core.encodings.RpcEncoding; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecContext; import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider; import tech.pegasys.teku.spec.config.SpecConfigDeneb; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.BlobIdentifier; import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.BlobSidecarsByRootRequestMessage; import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.BlobSidecarsByRootRequestMessageSchema; -import tech.pegasys.teku.spec.schemas.SchemaDefinitionsDeneb; import tech.pegasys.teku.spec.util.DataStructureUtil; import tech.pegasys.teku.storage.client.CombinedChainDataClient; +import tech.pegasys.teku.storage.client.RecentChainData; import tech.pegasys.teku.storage.store.UpdatableStore; +@TestSpecContext(milestone = {SpecMilestone.DENEB, SpecMilestone.ELECTRA}) public class BlobSidecarsByRootMessageHandlerTest { private final UInt64 genesisTime = UInt64.valueOf(1982239L); - private final UInt64 denebForkEpoch = UInt64.valueOf(1); - - private final Spec spec = TestSpecFactory.createMinimalWithDenebForkEpoch(denebForkEpoch); - private final SpecConfigDeneb specConfigDeneb = - SpecConfigDeneb.required(spec.forMilestone(SpecMilestone.DENEB).getConfig()); - private final int maxChunkSize = spec.getNetworkingConfig().getMaxChunkSize(); - private final BlobSidecarsByRootRequestMessageSchema messageSchema = - SchemaDefinitionsDeneb.required(spec.forMilestone(SpecMilestone.DENEB).getSchemaDefinitions()) - .getBlobSidecarsByRootRequestMessageSchema(); - private final RpcEncoding rpcEncoding = RpcEncoding.createSszSnappyEncoding(maxChunkSize); - - private final String protocolId = - BeaconChainMethodIds.getBlobSidecarsByRootMethodId(1, rpcEncoding); - - private final UInt64 denebFirstSlot = spec.computeStartSlotAtEpoch(denebForkEpoch); - - private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); - + private final UInt64 currentForkEpoch = UInt64.valueOf(1); + private BlobSidecarsByRootRequestMessageSchema messageSchema; private final ArgumentCaptor blobSidecarCaptor = ArgumentCaptor.forClass(BlobSidecar.class); - private final ArgumentCaptor rpcExceptionCaptor = ArgumentCaptor.forClass(RpcException.class); + private final Optional allowedObjectsRequest = + Optional.of( + new RequestApproval.RequestApprovalBuilder().objectsCount(100).timeSeconds(ZERO).build()); @SuppressWarnings("unchecked") private final ResponseCallback callback = mock(ResponseCallback.class); private final CombinedChainDataClient combinedChainDataClient = mock(CombinedChainDataClient.class); + private final RecentChainData recentChainData = mock(RecentChainData.class); private final UpdatableStore store = mock(UpdatableStore.class); - private final Eth2Peer peer = mock(Eth2Peer.class); - private final StubMetricsSystem metricsSystem = new StubMetricsSystem(); - - private final BlobSidecarsByRootMessageHandler handler = - new BlobSidecarsByRootMessageHandler( - spec, specConfigDeneb, metricsSystem, combinedChainDataClient); - - private final Optional allowedObjectsRequest = - Optional.of( - new RequestApproval.RequestApprovalBuilder().objectsCount(100).timeSeconds(ZERO).build()); + private String protocolId; + private UInt64 currentForkFirstSlot; + private DataStructureUtil dataStructureUtil; + private BlobSidecarsByRootMessageHandler handler; + private SpecMilestone specMilestone; + private Spec spec; @BeforeEach - public void setup() { + public void setup(final TestSpecInvocationContextProvider.SpecContext specContext) { + specMilestone = specContext.getSpecMilestone(); + spec = + switch (specContext.getSpecMilestone()) { + case PHASE0 -> throw new IllegalArgumentException("Phase0 is an unsupported milestone"); + case ALTAIR -> throw new IllegalArgumentException("Altair is an unsupported milestone"); + case BELLATRIX -> + throw new IllegalArgumentException("Bellatrix is an unsupported milestone"); + case CAPELLA -> throw new IllegalArgumentException("Capella is an unsupported milestone"); + case DENEB -> TestSpecFactory.createMinimalWithDenebForkEpoch(currentForkEpoch); + case ELECTRA -> TestSpecFactory.createMinimalWithElectraForkEpoch(currentForkEpoch); + case FULU -> TestSpecFactory.createMinimalWithFuluForkEpoch(currentForkEpoch); + }; + dataStructureUtil = new DataStructureUtil(spec); + messageSchema = + specMilestone.equals(SpecMilestone.DENEB) + ? spec.atEpoch(currentForkEpoch) + .getSchemaDefinitions() + .toVersionDeneb() + .orElseThrow() + .getBlobSidecarsByRootRequestMessageSchema() + : spec.atEpoch(currentForkEpoch) + .getSchemaDefinitions() + .toVersionElectra() + .orElseThrow() + .getBlobSidecarsByRootRequestMessageSchema(); + currentForkFirstSlot = spec.computeStartSlotAtEpoch(currentForkEpoch); + final int maxChunkSize = spec.getNetworkingConfig().getMaxChunkSize(); + final RpcEncoding rpcEncoding = RpcEncoding.createSszSnappyEncoding(maxChunkSize); + protocolId = BeaconChainMethodIds.getBlobSidecarsByRootMethodId(1, rpcEncoding); + handler = new BlobSidecarsByRootMessageHandler(spec, metricsSystem, combinedChainDataClient); + when(peer.approveRequest()).thenReturn(true); when(peer.approveBlobSidecarsRequest(eq(callback), anyLong())) .thenReturn(allowedObjectsRequest); @@ -113,11 +130,12 @@ public void setup() { when(combinedChainDataClient.getBlockByBlockRoot(any())) .thenReturn( SafeFuture.completedFuture( - Optional.of(dataStructureUtil.randomSignedBeaconBlock(denebFirstSlot)))); + Optional.of(dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot)))); // deneb fork epoch is finalized when(combinedChainDataClient.getFinalizedBlock()) - .thenReturn(Optional.of(dataStructureUtil.randomSignedBeaconBlock(denebFirstSlot))); + .thenReturn(Optional.of(dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot))); when(combinedChainDataClient.getStore()).thenReturn(store); + when(combinedChainDataClient.getRecentChainData()).thenReturn(recentChainData); when(callback.respond(any())).thenReturn(SafeFuture.COMPLETE); // mock store @@ -126,12 +144,16 @@ public void setup() { when(store.getTimeSeconds()) .thenReturn( spec.getSlotStartTime( - denebForkEpoch.increment().times(spec.getSlotsPerEpoch(ZERO)), genesisTime)); + currentForkEpoch.increment().times(spec.getSlotsPerEpoch(ZERO)), genesisTime)); } - @Test + @TestTemplate public void validateRequest_shouldNotAllowRequestLargerThanMaximumAllowed() { - final int maxRequestBlobSidecars = specConfigDeneb.getMaxRequestBlobSidecars(); + final int maxRequestBlobSidecars = + SpecConfigDeneb.required(spec.forMilestone(specMilestone).getConfig()) + .getMaxRequestBlobSidecars(); + when(recentChainData.getCurrentEpoch()) + .thenReturn(Optional.of(dataStructureUtil.randomEpoch())); final BlobSidecarsByRootRequestMessage request = new BlobSidecarsByRootRequestMessage( messageSchema, dataStructureUtil.randomBlobIdentifiers(maxRequestBlobSidecars + 1)); @@ -156,7 +178,7 @@ public void validateRequest_shouldNotAllowRequestLargerThanMaximumAllowed() { assertThat(countTooBigCount).isOne(); } - @Test + @TestTemplate public void shouldNotSendBlobSidecarsIfPeerIsRateLimited() { when(peer.approveBlobSidecarsRequest(callback, 5)).thenReturn(Optional.empty()); @@ -182,7 +204,7 @@ public void shouldNotSendBlobSidecarsIfPeerIsRateLimited() { verifyNoInteractions(callback); } - @Test + @TestTemplate public void shouldSendAvailableOnlyResources() { final List blobIdentifiers = prepareBlobIdentifiers(4); @@ -223,7 +245,7 @@ public void shouldSendAvailableOnlyResources() { .containsExactlyInAnyOrderElementsOf(blobIdentifiersBlockRoots); } - @Test + @TestTemplate public void shouldSendResourceUnavailableIfBlockRootReferencesBlockEarlierThanTheMinimumRequestEpoch() { final List blobIdentifiers = prepareBlobIdentifiers(3); @@ -264,7 +286,7 @@ public void shouldSendAvailableOnlyResources() { blobIdentifiers.get(0).getBlockRoot()); } - @Test + @TestTemplate public void shouldSendResourceUnavailableIfBlobSidecarBlockRootReferencesBlockEarlierThanTheMinimumRequestEpoch() { final List blobIdentifiers = prepareBlobIdentifiers(3); @@ -301,7 +323,7 @@ public void shouldSendAvailableOnlyResources() { blobIdentifiers.get(0).getBlockRoot()); } - @Test + @TestTemplate public void shouldSendToPeerRequestedBlobSidecars() { final List blobIdentifiers = prepareBlobIdentifiers(5); diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRootValidatorTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRootValidatorTest.java index ce012053897..dca60616c36 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRootValidatorTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/BlobSidecarsByRootValidatorTest.java @@ -18,49 +18,75 @@ import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import static tech.pegasys.teku.spec.SpecMilestone.DENEB; +import static tech.pegasys.teku.spec.SpecMilestone.ELECTRA; import java.util.List; +import java.util.stream.IntStream; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestTemplate; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.kzg.KZG; import tech.pegasys.teku.networking.eth2.peers.Eth2Peer; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.TestSpecContext; import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.BlobIdentifier; import tech.pegasys.teku.spec.util.DataStructureUtil; @SuppressWarnings("JavaCase") +@TestSpecContext(milestone = {DENEB, ELECTRA}) public class BlobSidecarsByRootValidatorTest { - private final Spec spec = TestSpecFactory.createMainnetDeneb(); - private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); - private BlobSidecarsByRootValidator validator; + + private final UInt64 currentForkEpoch = UInt64.valueOf(1); private final Eth2Peer peer = mock(Eth2Peer.class); private final KZG kzg = mock(KZG.class); + private Spec spec; + private DataStructureUtil dataStructureUtil; + private BlobSidecarsByRootValidator validator; + private UInt64 currentForkFirstSlot; @BeforeEach - void setUp() { + void setUp(final TestSpecInvocationContextProvider.SpecContext specContext) { + spec = + switch (specContext.getSpecMilestone()) { + case PHASE0 -> throw new IllegalArgumentException("Phase0 is an unsupported milestone"); + case ALTAIR -> throw new IllegalArgumentException("Altair is an unsupported milestone"); + case BELLATRIX -> + throw new IllegalArgumentException("Bellatrix is an unsupported milestone"); + case CAPELLA -> throw new IllegalArgumentException("Capella is an unsupported milestone"); + case DENEB -> TestSpecFactory.createMinimalWithDenebForkEpoch(currentForkEpoch); + case ELECTRA -> TestSpecFactory.createMinimalWithElectraForkEpoch(currentForkEpoch); + case FULU -> TestSpecFactory.createMinimalWithFuluForkEpoch(currentForkEpoch); + }; + currentForkFirstSlot = spec.computeStartSlotAtEpoch(currentForkEpoch); + dataStructureUtil = new DataStructureUtil(spec); when(kzg.verifyBlobKzgProof(any(), any(), any())).thenReturn(true); } - @Test + @TestTemplate void blobSidecarIsCorrect() { - final SignedBeaconBlock block1 = dataStructureUtil.randomSignedBeaconBlock(UInt64.ONE); + final SignedBeaconBlock block1 = + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot); final BlobIdentifier blobIdentifier1_0 = new BlobIdentifier(block1.getRoot(), UInt64.ZERO); - final BlobSidecar blobSidecar1_0 = dataStructureUtil.randomBlobSidecarForBlock(block1, 0); + final BlobSidecar blobSidecar1_0 = + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock(block1, 0); validator = new BlobSidecarsByRootValidator(peer, spec, kzg, List.of(blobIdentifier1_0)); assertDoesNotThrow(() -> validator.validate(blobSidecar1_0)); } - @Test + @TestTemplate void blobSidecarIdentifierNotRequested() { - final SignedBeaconBlock block1 = dataStructureUtil.randomSignedBeaconBlock(UInt64.ONE); + final SignedBeaconBlock block1 = + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot); final BlobIdentifier blobIdentifier2_0 = new BlobIdentifier(dataStructureUtil.randomBytes32(), UInt64.ZERO); - final BlobSidecar blobSidecar1_0 = dataStructureUtil.randomBlobSidecarForBlock(block1, 0); + final BlobSidecar blobSidecar1_0 = + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock(block1, 0); validator = new BlobSidecarsByRootValidator(peer, spec, kzg, List.of(blobIdentifier2_0)); assertThatThrownBy(() -> validator.validate(blobSidecar1_0)) @@ -71,12 +97,14 @@ void blobSidecarIdentifierNotRequested() { .describe()); } - @Test + @TestTemplate void blobSidecarFailsKzgVerification() { when(kzg.verifyBlobKzgProof(any(), any(), any())).thenReturn(false); - final SignedBeaconBlock block1 = dataStructureUtil.randomSignedBeaconBlock(UInt64.ONE); + final SignedBeaconBlock block1 = + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot); final BlobIdentifier blobIdentifier1_0 = new BlobIdentifier(block1.getRoot(), UInt64.ZERO); - final BlobSidecar blobSidecar1_0 = dataStructureUtil.randomBlobSidecarForBlock(block1, 0); + final BlobSidecar blobSidecar1_0 = + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock(block1, 0); validator = new BlobSidecarsByRootValidator(peer, spec, kzg, List.of(blobIdentifier1_0)); assertThatThrownBy(() -> validator.validate(blobSidecar1_0)) @@ -87,11 +115,31 @@ void blobSidecarFailsKzgVerification() { .describe()); } - @Test + @TestTemplate + void blobSidecarFailsInclusionProofVerification() { + final SignedBeaconBlock block1 = + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot); + final BlobIdentifier blobIdentifier1_0 = new BlobIdentifier(block1.getRoot(), UInt64.ZERO); + final BlobSidecar blobSidecar1_0 = + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock(block1, 0); + final BlobSidecar blobSidecar1_0_modified = breakInclusionProof(blobSidecar1_0); + + validator = new BlobSidecarsByRootValidator(peer, spec, kzg, List.of(blobIdentifier1_0)); + assertThatThrownBy(() -> validator.validate(blobSidecar1_0_modified)) + .isExactlyInstanceOf(BlobSidecarsResponseInvalidResponseException.class) + .hasMessageContaining( + BlobSidecarsResponseInvalidResponseException.InvalidResponseType + .BLOB_SIDECAR_INCLUSION_PROOF_VERIFICATION_FAILED + .describe()); + } + + @TestTemplate void blobSidecarResponseWithDuplicateSidecar() { - final SignedBeaconBlock block1 = dataStructureUtil.randomSignedBeaconBlock(UInt64.ONE); + final SignedBeaconBlock block1 = + dataStructureUtil.randomSignedBeaconBlock(currentForkFirstSlot); final BlobIdentifier blobIdentifier1_0 = new BlobIdentifier(block1.getRoot(), UInt64.ZERO); - final BlobSidecar blobSidecar1_0 = dataStructureUtil.randomBlobSidecarForBlock(block1, 0); + final BlobSidecar blobSidecar1_0 = + dataStructureUtil.randomBlobSidecarWithValidInclusionProofForBlock(block1, 0); validator = new BlobSidecarsByRootValidator(peer, spec, kzg, List.of(blobIdentifier1_0)); assertDoesNotThrow(() -> validator.validate(blobSidecar1_0)); @@ -102,4 +150,25 @@ void blobSidecarResponseWithDuplicateSidecar() { .BLOB_SIDECAR_UNEXPECTED_IDENTIFIER .describe()); } + + public static BlobSidecar breakInclusionProof(final BlobSidecar blobSidecar) { + return blobSidecar + .getSchema() + .create( + blobSidecar.getIndex(), + blobSidecar.getBlob(), + blobSidecar.getKZGCommitment(), + blobSidecar.getKZGProof(), + blobSidecar.getSignedBeaconBlockHeader(), + IntStream.range(0, blobSidecar.getKzgCommitmentInclusionProof().size()) + .mapToObj( + index -> { + if (index == 0) { + return blobSidecar.getKzgCommitmentInclusionProof().get(index).get().not(); + } else { + return blobSidecar.getKzgCommitmentInclusionProof().get(index).get(); + } + }) + .toList()); + } } diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/DataColumnSidecarsByRootListenerValidatingProxyTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/DataColumnSidecarsByRootListenerValidatingProxyTest.java index b82d8d44bd3..97a81fc0b9d 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/DataColumnSidecarsByRootListenerValidatingProxyTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/beaconchain/methods/DataColumnSidecarsByRootListenerValidatingProxyTest.java @@ -39,11 +39,12 @@ import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockHeader; import tech.pegasys.teku.spec.datastructures.networking.libp2p.rpc.DataColumnIdentifier; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsEip7594; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; import tech.pegasys.teku.spec.util.DataStructureUtil; @SuppressWarnings("JavaCase") public class DataColumnSidecarsByRootListenerValidatingProxyTest { - private final Spec spec = TestSpecFactory.createMainnetEip7594(); + private final Spec spec = TestSpecFactory.createMainnetElectraEip7594(); private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); private DataColumnSidecarsByRootListenerValidatingProxy listenerWrapper; private final Eth2Peer peer = mock(Eth2Peer.class); @@ -154,14 +155,16 @@ void dataColumnSidecarFailsKzgVerification() { @Test void dataColumnSidecarFailsInclusionProofVerification() { - final SchemaDefinitionsEip7594 schemaDefinitionsEip7594 = - SchemaDefinitionsEip7594.required(spec.getGenesisSchemaDefinitions()); + final SchemaDefinitionsElectra schemaDefinitionsElectra = + SchemaDefinitionsElectra.required(spec.getGenesisSchemaDefinitions()); final DataColumnSidecar dataColumnSidecar = - schemaDefinitionsEip7594 + SchemaDefinitionsEip7594.required(schemaDefinitionsElectra) .getDataColumnSidecarSchema() .create( UInt64.ZERO, - schemaDefinitionsEip7594.getDataColumnSchema().create(List.of()), + SchemaDefinitionsEip7594.required(schemaDefinitionsElectra) + .getDataColumnSchema() + .create(List.of()), List.of(), List.of(), new SignedBeaconBlockHeader( diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/core/Eth2OutgoingRequestHandlerTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/core/Eth2OutgoingRequestHandlerTest.java index d7986ea1cd9..ce83a72a55c 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/core/Eth2OutgoingRequestHandlerTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/core/Eth2OutgoingRequestHandlerTest.java @@ -362,7 +362,7 @@ public void shouldCompleteExceptionallyWhenClosedWithTruncatedMessage() { sendInitialPayload(); timeProvider.advanceTimeByMillis(100); - final Bytes chunkBytes = chunks.get(0); + final Bytes chunkBytes = chunks.getFirst(); deliverBytes(chunkBytes.slice(0, chunkBytes.size() - 1)); asyncRequestRunner.executeQueuedActions(); @@ -424,7 +424,7 @@ public void shouldWorkWhenInitialPayloadEventAfterReadCompleteWithEmptyResponse( assertAllReceivedSuccessfully(0); } - private void assertAllReceivedSuccessfully(int chunkCount) throws InterruptedException { + private void assertAllReceivedSuccessfully(final int chunkCount) throws InterruptedException { asyncRequestRunner.waitForExactly(chunkCount); timeoutRunner.executeUntilDone(); Waiter.waitFor(() -> assertThat(finishedProcessingFuture).isDone()); diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/core/Eth2ResponseHandlerTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/core/Eth2ResponseHandlerTest.java index b541056def1..1daded87069 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/core/Eth2ResponseHandlerTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/core/Eth2ResponseHandlerTest.java @@ -192,14 +192,14 @@ public void expectOptionalResponse_tooManyResponses() throws Exception { .hasMessageContaining("Received multiple responses when single response expected"); } - private void assertFailedWithDefaultError(Eth2RpcResponseHandler handler) { + private void assertFailedWithDefaultError(final Eth2RpcResponseHandler handler) { AssertionsForClassTypes.assertThat(handler.getCompletedFuture()).isCompletedExceptionally(); AssertionsForClassTypes.assertThat(handler.getResult()).isCompletedExceptionally(); assertThatThrownBy(() -> handler.getCompletedFuture().get()).hasCause(error); assertThatThrownBy(() -> handler.getResult().get()).hasCause(error); } - private void assertNotDone(Eth2RpcResponseHandler handler) { + private void assertNotDone(final Eth2RpcResponseHandler handler) { assertThat(handler.getCompletedFuture()).isNotDone(); assertThat(handler.getResult()).isNotDone(); } diff --git a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcResponseDecoderTest.java b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcResponseDecoderTest.java index 445abd648d5..c9ae237d82d 100644 --- a/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcResponseDecoderTest.java +++ b/networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/rpc/core/RpcResponseDecoderTest.java @@ -277,7 +277,7 @@ private BeaconState beaconState(final boolean usePhase0State) { : dataStructureUtil.stateBuilderAltair().build(); } - private void completeIgnoringUnprocessedData(RpcResponseDecoder decoder) { + private void completeIgnoringUnprocessedData(final RpcResponseDecoder decoder) { try { decoder.complete(); } catch (Exception e) { diff --git a/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/Eth2P2PNetworkFactory.java b/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/Eth2P2PNetworkFactory.java index 4345c9b37a8..69bb49fb80d 100644 --- a/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/Eth2P2PNetworkFactory.java +++ b/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/Eth2P2PNetworkFactory.java @@ -56,7 +56,7 @@ import tech.pegasys.teku.networking.eth2.gossip.forks.versions.GossipForkSubscriptionsBellatrix; import tech.pegasys.teku.networking.eth2.gossip.forks.versions.GossipForkSubscriptionsCapella; import tech.pegasys.teku.networking.eth2.gossip.forks.versions.GossipForkSubscriptionsDeneb; -import tech.pegasys.teku.networking.eth2.gossip.forks.versions.GossipForkSubscriptionsEip7594; +import tech.pegasys.teku.networking.eth2.gossip.forks.versions.GossipForkSubscriptionsElectra; import tech.pegasys.teku.networking.eth2.gossip.forks.versions.GossipForkSubscriptionsPhase0; import tech.pegasys.teku.networking.eth2.gossip.subnets.AttestationSubnetTopicProvider; import tech.pegasys.teku.networking.eth2.gossip.subnets.DataColumnSidecarSubnetTopicProvider; @@ -106,8 +106,8 @@ import tech.pegasys.teku.statetransition.BeaconChainUtil; import tech.pegasys.teku.statetransition.block.VerifiedBlockOperationsListener; import tech.pegasys.teku.statetransition.datacolumns.DataColumnSidecarByRootCustody; -import tech.pegasys.teku.statetransition.datacolumns.log.gossip.DasGossipLogger; import tech.pegasys.teku.statetransition.datacolumns.log.rpc.DasReqRespLogger; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; import tech.pegasys.teku.storage.api.StorageQueryChannel; import tech.pegasys.teku.storage.api.StubStorageQueryChannel; import tech.pegasys.teku.storage.client.CombinedChainDataClient; @@ -167,6 +167,7 @@ public class Eth2P2PNetworkBuilder { protected Duration eth2StatusUpdateInterval; protected Spec spec = TestSpecFactory.createMinimalPhase0(); private int earliestAvailableBlockSlotFrequency = 0; + protected DebugDataDumper debugDataDumper; public Eth2P2PNetwork startNetwork() throws Exception { setDefaults(); @@ -226,11 +227,11 @@ protected Eth2P2PNetwork buildNetwork(final P2PConfig config) { RpcEncoding.createSszSnappyEncoding(spec.getNetworkingConfig().getMaxChunkSize()); } final Optional dasTotalCustodySubnetCount = - spec.isMilestoneSupported(SpecMilestone.EIP7594) + spec.isMilestoneSupported(SpecMilestone.ELECTRA) ? Optional.of( UInt64.valueOf( config.getTotalCustodySubnetCount( - spec.forMilestone(SpecMilestone.EIP7594)))) + spec.forMilestone(SpecMilestone.ELECTRA)))) : Optional.empty(); final Eth2PeerManager eth2PeerManager = Eth2PeerManager.create( @@ -383,112 +384,123 @@ private GossipForkSubscriptions createSubscriptions( final DiscoveryNetwork network, final GossipEncoding gossipEncoding) { return switch (forkAndSpecMilestone.getSpecMilestone()) { - case PHASE0 -> new GossipForkSubscriptionsPhase0( - forkAndSpecMilestone.getFork(), - spec, - asyncRunner, - metricsSystem, - network, - recentChainData, - gossipEncoding, - gossipedBlockProcessor, - gossipedAttestationProcessor, - gossipedAggregateProcessor, - attesterSlashingProcessor, - proposerSlashingProcessor, - voluntaryExitProcessor); - case ALTAIR -> new GossipForkSubscriptionsAltair( - forkAndSpecMilestone.getFork(), - spec, - asyncRunner, - metricsSystem, - network, - recentChainData, - gossipEncoding, - gossipedBlockProcessor, - gossipedAttestationProcessor, - gossipedAggregateProcessor, - attesterSlashingProcessor, - proposerSlashingProcessor, - voluntaryExitProcessor, - signedContributionAndProofProcessor, - syncCommitteeMessageProcessor); - case BELLATRIX -> new GossipForkSubscriptionsBellatrix( - forkAndSpecMilestone.getFork(), - spec, - asyncRunner, - metricsSystem, - network, - recentChainData, - gossipEncoding, - gossipedBlockProcessor, - gossipedAttestationProcessor, - gossipedAggregateProcessor, - attesterSlashingProcessor, - proposerSlashingProcessor, - voluntaryExitProcessor, - signedContributionAndProofProcessor, - syncCommitteeMessageProcessor); - case CAPELLA -> new GossipForkSubscriptionsCapella( - forkAndSpecMilestone.getFork(), - spec, - asyncRunner, - metricsSystem, - network, - recentChainData, - gossipEncoding, - gossipedBlockProcessor, - gossipedAttestationProcessor, - gossipedAggregateProcessor, - attesterSlashingProcessor, - proposerSlashingProcessor, - voluntaryExitProcessor, - signedContributionAndProofProcessor, - syncCommitteeMessageProcessor, - signedBlsToExecutionChangeProcessor); - case DENEB -> new GossipForkSubscriptionsDeneb( - forkAndSpecMilestone.getFork(), - spec, - asyncRunner, - metricsSystem, - network, - recentChainData, - gossipEncoding, - gossipedBlockProcessor, - gossipedBlobSidecarProcessor, - gossipedAttestationProcessor, - gossipedAggregateProcessor, - attesterSlashingProcessor, - proposerSlashingProcessor, - voluntaryExitProcessor, - signedContributionAndProofProcessor, - syncCommitteeMessageProcessor, - signedBlsToExecutionChangeProcessor); - case EIP7594 -> new GossipForkSubscriptionsEip7594( - forkAndSpecMilestone.getFork(), - spec, - asyncRunner, - metricsSystem, - network, - recentChainData, - gossipEncoding, - gossipedBlockProcessor, - gossipedAttestationProcessor, - gossipedAggregateProcessor, - attesterSlashingProcessor, - proposerSlashingProcessor, - voluntaryExitProcessor, - signedContributionAndProofProcessor, - syncCommitteeMessageProcessor, - signedBlsToExecutionChangeProcessor, - dataColumnSidecarOperationProcessor, - DasGossipLogger.NOOP); + case PHASE0 -> + new GossipForkSubscriptionsPhase0( + forkAndSpecMilestone.getFork(), + spec, + asyncRunner, + metricsSystem, + network, + recentChainData, + gossipEncoding, + gossipedBlockProcessor, + gossipedAttestationProcessor, + gossipedAggregateProcessor, + attesterSlashingProcessor, + proposerSlashingProcessor, + voluntaryExitProcessor, + debugDataDumper); + case ALTAIR -> + new GossipForkSubscriptionsAltair( + forkAndSpecMilestone.getFork(), + spec, + asyncRunner, + metricsSystem, + network, + recentChainData, + gossipEncoding, + gossipedBlockProcessor, + gossipedAttestationProcessor, + gossipedAggregateProcessor, + attesterSlashingProcessor, + proposerSlashingProcessor, + voluntaryExitProcessor, + signedContributionAndProofProcessor, + syncCommitteeMessageProcessor, + debugDataDumper); + case BELLATRIX -> + new GossipForkSubscriptionsBellatrix( + forkAndSpecMilestone.getFork(), + spec, + asyncRunner, + metricsSystem, + network, + recentChainData, + gossipEncoding, + gossipedBlockProcessor, + gossipedAttestationProcessor, + gossipedAggregateProcessor, + attesterSlashingProcessor, + proposerSlashingProcessor, + voluntaryExitProcessor, + signedContributionAndProofProcessor, + syncCommitteeMessageProcessor, + debugDataDumper); + case CAPELLA -> + new GossipForkSubscriptionsCapella( + forkAndSpecMilestone.getFork(), + spec, + asyncRunner, + metricsSystem, + network, + recentChainData, + gossipEncoding, + gossipedBlockProcessor, + gossipedAttestationProcessor, + gossipedAggregateProcessor, + attesterSlashingProcessor, + proposerSlashingProcessor, + voluntaryExitProcessor, + signedContributionAndProofProcessor, + syncCommitteeMessageProcessor, + signedBlsToExecutionChangeProcessor, + debugDataDumper); + case DENEB -> + new GossipForkSubscriptionsDeneb( + forkAndSpecMilestone.getFork(), + spec, + asyncRunner, + metricsSystem, + network, + recentChainData, + gossipEncoding, + gossipedBlockProcessor, + gossipedBlobSidecarProcessor, + gossipedAttestationProcessor, + gossipedAggregateProcessor, + attesterSlashingProcessor, + proposerSlashingProcessor, + voluntaryExitProcessor, + signedContributionAndProofProcessor, + syncCommitteeMessageProcessor, + signedBlsToExecutionChangeProcessor, + debugDataDumper); + case ELECTRA, FULU -> + new GossipForkSubscriptionsElectra( + forkAndSpecMilestone.getFork(), + spec, + asyncRunner, + metricsSystem, + network, + recentChainData, + gossipEncoding, + gossipedBlockProcessor, + gossipedBlobSidecarProcessor, + gossipedAttestationProcessor, + gossipedAggregateProcessor, + attesterSlashingProcessor, + proposerSlashingProcessor, + voluntaryExitProcessor, + signedContributionAndProofProcessor, + syncCommitteeMessageProcessor, + signedBlsToExecutionChangeProcessor, + debugDataDumper); }; } private P2PConfig generateConfig() { final List peerAddresses = - peers.stream().map(P2PNetwork::getNodeAddress).collect(toList()); + peers.stream().flatMap(peer -> peer.getNodeAddresses().stream()).collect(toList()); final Random random = new Random(); final int port = MIN_PORT + random.nextInt(MAX_PORT - MIN_PORT); @@ -705,7 +717,7 @@ public Eth2P2PNetworkBuilder gossipedSignedBlsToExecutionChangeProcessor( } public Eth2P2PNetworkBuilder gossipedDataColumnSidecarOperationProcessor( - OperationProcessor dataColumnSidecarOperationProcessor) { + final OperationProcessor dataColumnSidecarOperationProcessor) { checkNotNull(dataColumnSidecarOperationProcessor); this.dataColumnSidecarOperationProcessor = dataColumnSidecarOperationProcessor; return this; @@ -728,7 +740,7 @@ public Eth2P2PNetworkBuilder verifiedBlockAttestationsSubscriptionProvider( } public Eth2P2PNetworkBuilder rpcMethodsModifier( - Function, Stream>> rpcMethodsModifier) { + final Function, Stream>> rpcMethodsModifier) { checkNotNull(rpcMethodsModifier); this.rpcMethodsModifier = rpcMethodsModifier; return this; @@ -740,29 +752,35 @@ public Eth2P2PNetworkBuilder peerHandler(final PeerHandler peerHandler) { return this; } - public Eth2P2PNetworkBuilder asyncRunner(AsyncRunner asyncRunner) { + public Eth2P2PNetworkBuilder asyncRunner(final AsyncRunner asyncRunner) { checkNotNull(asyncRunner); this.asyncRunner = asyncRunner; return this; } - public Eth2P2PNetworkBuilder eth2RpcPingInterval(Duration eth2RpcPingInterval) { + public Eth2P2PNetworkBuilder eth2RpcPingInterval(final Duration eth2RpcPingInterval) { checkNotNull(eth2RpcPingInterval); this.eth2RpcPingInterval = eth2RpcPingInterval; return this; } public Eth2P2PNetworkBuilder eth2RpcOutstandingPingThreshold( - int eth2RpcOutstandingPingThreshold) { + final int eth2RpcOutstandingPingThreshold) { checkArgument(eth2RpcOutstandingPingThreshold > 0); this.eth2RpcOutstandingPingThreshold = eth2RpcOutstandingPingThreshold; return this; } - public Eth2P2PNetworkBuilder eth2StatusUpdateInterval(Duration eth2StatusUpdateInterval) { + public Eth2P2PNetworkBuilder eth2StatusUpdateInterval(final Duration eth2StatusUpdateInterval) { checkNotNull(eth2StatusUpdateInterval); this.eth2StatusUpdateInterval = eth2StatusUpdateInterval; return this; } + + public Eth2P2PNetworkBuilder p2pDebugDataDumper(final DebugDataDumper debugDataDumper) { + checkNotNull(debugDataDumper); + this.debugDataDumper = debugDataDumper; + return this; + } } } diff --git a/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/NodeManager.java b/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/NodeManager.java index 58b07f3e371..aa3599941de 100644 --- a/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/NodeManager.java +++ b/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/NodeManager.java @@ -17,6 +17,7 @@ import java.util.function.Consumer; import org.hyperledger.besu.metrics.noop.NoOpMetricsSystem; import tech.pegasys.teku.bls.BLSKeyPair; +import tech.pegasys.teku.infrastructure.async.AsyncRunner; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.events.ChannelExceptionHandler; import tech.pegasys.teku.infrastructure.events.EventChannels; @@ -51,33 +52,48 @@ private NodeManager( } public static NodeManager create( - final Spec spec, Eth2P2PNetworkFactory networkFactory, final List validatorKeys) + final Spec spec, + final AsyncRunner asyncRunner, + final Eth2P2PNetworkFactory networkFactory, + final List validatorKeys) throws Exception { - return create(spec, networkFactory, validatorKeys, c -> {}); + return create(spec, asyncRunner, networkFactory, validatorKeys, c -> {}); } @Deprecated public static NodeManager create( - Eth2P2PNetworkFactory networkFactory, + final AsyncRunner asyncRunner, + final Eth2P2PNetworkFactory networkFactory, final List validatorKeys, - Consumer configureNetwork) + final Consumer configureNetwork) throws Exception { - return create(DEFAULT_SPEC, networkFactory, validatorKeys, configureNetwork); + return create(DEFAULT_SPEC, asyncRunner, networkFactory, validatorKeys, configureNetwork); } public static NodeManager create( final Spec spec, - Eth2P2PNetworkFactory networkFactory, + final AsyncRunner asyncRunner, + final Eth2P2PNetworkFactory networkFactory, final List validatorKeys, - Consumer configureNetwork) + final Consumer configureNetwork) throws Exception { - final EventChannels eventChannels = - EventChannels.createSyncChannels( - ChannelExceptionHandler.THROWING_HANDLER, new NoOpMetricsSystem()); final RecentChainData storageClient = MemoryOnlyRecentChainData.create(spec); - final BeaconChainUtil chainUtil = BeaconChainUtil.create(spec, storageClient, validatorKeys); chainUtil.initializeStorage(); + return create(spec, asyncRunner, networkFactory, configureNetwork, storageClient, chainUtil); + } + + public static NodeManager create( + final Spec spec, + final AsyncRunner asyncRunner, + final Eth2P2PNetworkFactory networkFactory, + final Consumer configureNetwork, + final RecentChainData storageClient, + final BeaconChainUtil chainUtil) + throws Exception { + final EventChannels eventChannels = + EventChannels.createSyncChannels( + ChannelExceptionHandler.THROWING_HANDLER, new NoOpMetricsSystem()); final Eth2P2PNetworkBuilder networkBuilder = networkFactory @@ -89,7 +105,7 @@ public static NodeManager create( configureNetwork.accept(networkBuilder); final BlockGossipChannel blockGossipChannel = - eventChannels.getPublisher(BlockGossipChannel.class); + eventChannels.getPublisher(BlockGossipChannel.class, asyncRunner); final Eth2P2PNetwork eth2P2PNetwork = networkBuilder.startNetwork(); return new NodeManager(blockGossipChannel, storageClient, chainUtil, eth2P2PNetwork); @@ -97,7 +113,7 @@ public static NodeManager create( public SafeFuture connect(final NodeManager peer) { final PeerAddress peerAddress = - eth2P2PNetwork.createPeerAddress(peer.network().getNodeAddress()); + eth2P2PNetwork.createPeerAddress(peer.network().getNodeAddresses().get(0)); return eth2P2PNetwork.connect(peerAddress); } @@ -114,6 +130,6 @@ public RecentChainData storageClient() { } public void gossipBlock(final SignedBeaconBlock block) { - blockGossipChannel.publishBlock(block); + blockGossipChannel.publishBlock(block).ifExceptionGetsHereRaiseABug(); } } diff --git a/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/peers/PeerStatusFactory.java b/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/peers/PeerStatusFactory.java index 7abed1965a8..c123ef01628 100644 --- a/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/peers/PeerStatusFactory.java +++ b/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/peers/PeerStatusFactory.java @@ -44,17 +44,17 @@ public PeerStatus random() { return new PeerStatus(fork, finalizedRoot, finalizedEpoch, headRoot, headSlot); } - private final UInt64 randomLong(final long min, final long max) { + private UInt64 randomLong(final long min, final long max) { final int range = Math.toIntExact(max - min); final long randomLong = random.nextInt(range) + min; return UInt64.valueOf(randomLong); } - private final Bytes32 randomBytes32() { + private Bytes32 randomBytes32() { return Bytes32.wrap(randomBytes(32)); } - private final byte[] randomBytes(final int numBytes) { + private byte[] randomBytes(final int numBytes) { final byte[] bytes = new byte[numBytes]; random.nextBytes(bytes); return bytes; diff --git a/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/peers/RespondingEth2Peer.java b/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/peers/RespondingEth2Peer.java index c0f2d2b2d82..5b3894e678a 100644 --- a/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/peers/RespondingEth2Peer.java +++ b/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/peers/RespondingEth2Peer.java @@ -138,7 +138,7 @@ public void completePendingRequests() { } public void setBlockRequestFilter( - Function, List> filter) { + final Function, List> filter) { this.blockRequestFilter = filter; } @@ -162,7 +162,7 @@ public void subscribeStatusUpdates(final PeerStatusSubscriber subscriber) { } @Override - public void subscribeMetadataUpdates(PeerMetadataUpdateSubscriber subscriber) {} + public void subscribeMetadataUpdates(final PeerMetadataUpdateSubscriber subscriber) {} @Override public PeerStatus getStatus() { @@ -433,7 +433,7 @@ public SafeFuture disconnectCleanly(final DisconnectReason reason) { return SafeFuture.COMPLETE; } - private void disconnect(Optional reason, boolean locallyInitiated) { + private void disconnect(final Optional reason, final boolean locallyInitiated) { disconnected = true; disconnectSubscribers.forEach(s -> s.onDisconnected(reason, locallyInitiated)); } diff --git a/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/peers/StubPeerScorer.java b/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/peers/StubPeerScorer.java index 9e16e1c9cb1..01dc80d095e 100644 --- a/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/peers/StubPeerScorer.java +++ b/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/peers/StubPeerScorer.java @@ -53,7 +53,7 @@ public int scoreExistingPeer(final NodeId peerId) { } @Override - public int scoreCandidatePeer(DiscoveryPeer candidate) { + public int scoreCandidatePeer(final DiscoveryPeer candidate) { return scoreCandidatePeer( candidate.getPersistentAttestationSubnets(), candidate.getSyncCommitteeSubnets()); } diff --git a/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/rpc/IntRange.java b/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/rpc/IntRange.java index 593465eb2d1..e81347b5724 100644 --- a/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/rpc/IntRange.java +++ b/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/rpc/IntRange.java @@ -14,18 +14,18 @@ package tech.pegasys.teku.networking.eth2.rpc; public class IntRange { - public static IntRange ofLength(int startIndex, int length) { + public static IntRange ofLength(final int startIndex, final int length) { return new IntRange(startIndex, length); } - public static IntRange ofIndices(int startIndex, int endIndex) { + public static IntRange ofIndices(final int startIndex, final int endIndex) { return new IntRange(startIndex, endIndex - startIndex); } private final int startIndex; private final int length; - public IntRange(int startIndex, int length) { + public IntRange(final int startIndex, final int length) { this.startIndex = startIndex; this.length = length; } diff --git a/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/rpc/Utils.java b/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/rpc/Utils.java index d9ca12e94ff..0d9f801ce76 100644 --- a/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/rpc/Utils.java +++ b/networking/eth2/src/testFixtures/java/tech/pegasys/teku/networking/eth2/rpc/Utils.java @@ -35,7 +35,7 @@ public class Utils { * of test {@code ByteBuf}'s which are different combinations of slicing and sticking of the * original chunks. Zero-length {@code ByteBuf}s are also mixed up to the resulting lists */ - public static List> generateTestSlices(Bytes... chunks) { + public static List> generateTestSlices(final Bytes... chunks) { int totalLen = Arrays.stream(chunks).mapToInt(Bytes::size).sum(); List> splits = List.of( @@ -87,7 +87,7 @@ public static List> generateTestSlices(Bytes... chunks) { * @param chunks The original chunks * @return */ - private static List splitIntoEvenChunks(int chunkSize, Bytes... chunks) { + private static List splitIntoEvenChunks(final int chunkSize, final Bytes... chunks) { final Bytes allBytes = Bytes.concatenate(chunks); final List evenChunks = new ArrayList<>(); for (int i = 0; i < allBytes.size(); i += chunkSize) { @@ -97,7 +97,7 @@ private static List splitIntoEvenChunks(int chunkSize, Bytes... chunks) { return evenChunks; } - private static List> addZeroLenBuffers(List> bufSets) { + private static List> addZeroLenBuffers(final List> bufSets) { return bufSets.stream() .map( set -> @@ -107,7 +107,7 @@ private static List> addZeroLenBuffers(List> bufSets .collect(Collectors.toList()); } - private static List shiftedSlices(int shift, Bytes... chunks) { + private static List shiftedSlices(final int shift, final Bytes... chunks) { AtomicInteger sum = new AtomicInteger(0); IntStream pos = IntStream.concat( @@ -121,7 +121,7 @@ private static List shiftedSlices(int shift, Bytes... chunks) { return slice(toByteBuf(chunks), pos.toArray()); } - private static List slice(ByteBuf src, int... pos) { + private static List slice(final ByteBuf src, final int... pos) { int[] pos1 = Arrays.stream(pos) .map(i -> i >= 0 ? i : src.readableBytes() + i) diff --git a/networking/nat/src/main/java/tech/pegasys/teku/networking/nat/NatService.java b/networking/nat/src/main/java/tech/pegasys/teku/networking/nat/NatService.java index bb313377191..3a78f984a28 100644 --- a/networking/nat/src/main/java/tech/pegasys/teku/networking/nat/NatService.java +++ b/networking/nat/src/main/java/tech/pegasys/teku/networking/nat/NatService.java @@ -13,7 +13,9 @@ package tech.pegasys.teku.networking.nat; +import java.util.HashSet; import java.util.Optional; +import java.util.Set; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.service.serviceutils.Service; @@ -22,12 +24,15 @@ public class NatService extends Service { private final Optional maybeNatManager; private final boolean isDiscoveryEnabled; private final int p2pPort; + private final Optional p2pPortIpv6; NatService( final int p2pPort, + final Optional p2pPortIpv6, final boolean isDiscoveryEnabled, final Optional maybeNatManager) { this.p2pPort = p2pPort; + this.p2pPortIpv6 = p2pPortIpv6; this.isDiscoveryEnabled = isDiscoveryEnabled; this.maybeNatManager = maybeNatManager; } @@ -35,9 +40,11 @@ public class NatService extends Service { public NatService( final NatConfiguration natConfiguration, final int p2pPort, + final Optional p2pPortIpv6, final boolean isDiscoveryEnabled) { this( p2pPort, + p2pPortIpv6, isDiscoveryEnabled, natConfiguration.getNatMethod().equals(NatMethod.UPNP) ? Optional.of(new NatManager()) @@ -54,11 +61,10 @@ protected SafeFuture doStart() { .start() .thenRun( () -> { - natManager.requestPortForward(p2pPort, NetworkProtocol.TCP, NatServiceType.TEKU_P2P); - if (isDiscoveryEnabled) { - natManager.requestPortForward( - p2pPort, NetworkProtocol.UDP, NatServiceType.TEKU_DISCOVERY); - } + final Set p2pPorts = new HashSet<>(); + p2pPorts.add(p2pPort); + p2pPortIpv6.ifPresent(p2pPorts::add); + p2pPorts.forEach(port -> requestPortForward(natManager, port)); }); } @@ -66,4 +72,11 @@ protected SafeFuture doStart() { protected SafeFuture doStop() { return maybeNatManager.map(NatManager::stop).orElse(SafeFuture.completedFuture(null)); } + + private void requestPortForward(final NatManager natManager, final int port) { + natManager.requestPortForward(port, NetworkProtocol.TCP, NatServiceType.TEKU_P2P); + if (isDiscoveryEnabled) { + natManager.requestPortForward(port, NetworkProtocol.UDP, NatServiceType.TEKU_DISCOVERY); + } + } } diff --git a/networking/nat/src/main/java/tech/pegasys/teku/networking/nat/UpnpClient.java b/networking/nat/src/main/java/tech/pegasys/teku/networking/nat/UpnpClient.java index c6bb7fc8937..2ce9934fd8e 100644 --- a/networking/nat/src/main/java/tech/pegasys/teku/networking/nat/UpnpClient.java +++ b/networking/nat/src/main/java/tech/pegasys/teku/networking/nat/UpnpClient.java @@ -90,7 +90,7 @@ public SafeFuture releasePortForward(final NatPortMapping portMapping) { @SuppressWarnings("unchecked") public SafeFuture requestPortForward( - final int port, NetworkProtocol protocol, NatServiceType serviceType) { + final int port, final NetworkProtocol protocol, final NatServiceType serviceType) { return requestPortForward( new PortMapping( true, diff --git a/networking/nat/src/test/java/tech/pegasys/teku/networking/nat/NatServiceTest.java b/networking/nat/src/test/java/tech/pegasys/teku/networking/nat/NatServiceTest.java index bd5b7590488..88b2ff7475b 100644 --- a/networking/nat/src/test/java/tech/pegasys/teku/networking/nat/NatServiceTest.java +++ b/networking/nat/src/test/java/tech/pegasys/teku/networking/nat/NatServiceTest.java @@ -26,23 +26,25 @@ import tech.pegasys.teku.infrastructure.async.SafeFuture; public class NatServiceTest { - private NatManager natManager = mock(NatManager.class); - private Optional maybeNatManager = Optional.of(natManager); + private final NatManager natManager = mock(NatManager.class); + private final Optional maybeNatManager = Optional.of(natManager); @Test public void shouldRequestPortsBeMappedOnServiceStart() { - final NatService natService = new NatService(9000, true, maybeNatManager); + final NatService natService = new NatService(9000, Optional.of(9090), true, maybeNatManager); when(natManager.start()).thenReturn(SafeFuture.completedFuture(null)); assertThat(natService.start()).isCompleted(); verify(natManager).start(); verify(natManager).requestPortForward(eq(9000), eq(NetworkProtocol.UDP), any()); verify(natManager).requestPortForward(eq(9000), eq(NetworkProtocol.TCP), any()); + verify(natManager).requestPortForward(eq(9090), eq(NetworkProtocol.UDP), any()); + verify(natManager).requestPortForward(eq(9090), eq(NetworkProtocol.TCP), any()); verifyNoMoreInteractions(natManager); } @Test public void shouldShutdownNatManager() { - final NatService natService = new NatService(9000, true, maybeNatManager); + final NatService natService = new NatService(9000, Optional.empty(), true, maybeNatManager); when(natManager.start()).thenReturn(SafeFuture.completedFuture(null)); assertThat(natService.start()).isCompleted(); diff --git a/networking/nat/src/test/java/tech/pegasys/teku/networking/nat/UpnpClientTest.java b/networking/nat/src/test/java/tech/pegasys/teku/networking/nat/UpnpClientTest.java index 7ec7a5a80ce..fbf7481aef9 100644 --- a/networking/nat/src/test/java/tech/pegasys/teku/networking/nat/UpnpClientTest.java +++ b/networking/nat/src/test/java/tech/pegasys/teku/networking/nat/UpnpClientTest.java @@ -38,8 +38,8 @@ import tech.pegasys.teku.infrastructure.async.SafeFuture; public class UpnpClientTest { - private UpnpService natService = mock(UpnpService.class); - private Registry registry = mock(Registry.class); + private final UpnpService natService = mock(UpnpService.class); + private final Registry registry = mock(Registry.class); private UpnpClient upnpClient; @BeforeEach diff --git a/networking/p2p/build.gradle b/networking/p2p/build.gradle index 3117d70ee21..249e25c194c 100644 --- a/networking/p2p/build.gradle +++ b/networking/p2p/build.gradle @@ -20,8 +20,8 @@ dependencies { implementation 'io.libp2p:jvm-libp2p' implementation 'io.netty:netty-handler' implementation 'io.projectreactor:reactor-core' - implementation 'org.apache.tuweni:tuweni-units' - implementation 'org.apache.tuweni:tuweni-crypto' + implementation 'io.tmio:tuweni-units' + implementation 'io.tmio:tuweni-crypto' implementation 'tech.pegasys.discovery:discovery' testImplementation testFixtures(project(':ethereum:statetransition')) @@ -32,7 +32,7 @@ dependencies { testImplementation 'org.hyperledger.besu.internal:metrics-core' - testFixturesApi 'org.apache.tuweni:tuweni-bytes' + testFixturesApi 'io.tmio:tuweni-bytes' testFixturesCompileOnly 'org.jetbrains.kotlin:kotlin-stdlib' diff --git a/networking/p2p/src/integration-test/java/tech/pegasys/teku/networking/p2p/DiscoveryNetworkIntegrationTest.java b/networking/p2p/src/integration-test/java/tech/pegasys/teku/networking/p2p/DiscoveryNetworkIntegrationTest.java index 477561cddbe..4f138890bf4 100644 --- a/networking/p2p/src/integration-test/java/tech/pegasys/teku/networking/p2p/DiscoveryNetworkIntegrationTest.java +++ b/networking/p2p/src/integration-test/java/tech/pegasys/teku/networking/p2p/DiscoveryNetworkIntegrationTest.java @@ -24,6 +24,7 @@ import org.junit.jupiter.api.Test; import tech.pegasys.teku.infrastructure.async.Waiter; import tech.pegasys.teku.network.p2p.DiscoveryNetworkFactory; +import tech.pegasys.teku.network.p2p.DiscoveryNetworkFactory.DiscoveryTestNetworkBuilder; import tech.pegasys.teku.networking.p2p.discovery.DiscoveryNetwork; public class DiscoveryNetworkIntegrationTest { @@ -37,16 +38,14 @@ public void tearDown() throws InterruptedException, ExecutionException, TimeoutE @Test public void shouldConnectToStaticPeers() throws Exception { final DiscoveryNetwork network1 = discoveryNetworkFactory.builder().buildAndStart(); - final DiscoveryNetwork network2 = - discoveryNetworkFactory.builder().staticPeer(network1.getNodeAddress()).buildAndStart(); + final DiscoveryNetwork network2 = buildAndStartNetworkWithStaticPeers(network1); assertConnected(network1, network2); } @Test public void shouldReconnectToStaticPeersAfterDisconnection() throws Exception { final DiscoveryNetwork network1 = discoveryNetworkFactory.builder().buildAndStart(); - final DiscoveryNetwork network2 = - discoveryNetworkFactory.builder().staticPeer(network1.getNodeAddress()).buildAndStart(); + final DiscoveryNetwork network2 = buildAndStartNetworkWithStaticPeers(network1); assertConnected(network1, network2); // Peers disconnect @@ -62,13 +61,11 @@ public void shouldReconnectToStaticPeersAfterDisconnection() throws Exception { @Test public void shouldReconnectToStaticPeersWhenAlreadyConnected() throws Exception { final DiscoveryNetwork network1 = discoveryNetworkFactory.builder().buildAndStart(); - final DiscoveryNetwork network2 = - discoveryNetworkFactory.builder().staticPeer(network1.getNodeAddress()).buildAndStart(); + final DiscoveryNetwork network2 = buildAndStartNetworkWithStaticPeers(network1); assertConnected(network1, network2); // Already connected, but now tell network1 to maintain a persistent connection to network2. - network1.addStaticPeer(network2.getNodeAddress()); - + network2.getNodeAddresses().forEach(network1::addStaticPeer); network1 .getPeer(network2.getNodeId()) .orElseThrow() @@ -103,6 +100,13 @@ public void shouldDiscoverPeers() throws Exception { assertConnected(network2, network3); } + private DiscoveryNetwork buildAndStartNetworkWithStaticPeers(final DiscoveryNetwork network) + throws Exception { + final DiscoveryTestNetworkBuilder builder = discoveryNetworkFactory.builder(); + network.getNodeAddresses().forEach(builder::staticPeer); + return builder.buildAndStart(); + } + private void assertConnected( final DiscoveryNetwork network1, final DiscoveryNetwork network2) { Waiter.waitFor( diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/connection/ConnectionManager.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/connection/ConnectionManager.java index ac6c5f276f0..ac485309a4c 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/connection/ConnectionManager.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/connection/ConnectionManager.java @@ -78,7 +78,7 @@ public ConnectionManager( final LabelledMetric connectionAttemptCounter = metricsSystem.createLabelledCounter( TekuMetricCategory.NETWORK, - "peer_connection_attempt_count", + "peer_connection_attempt_count_total", "Total number of outbound connection attempts made", "status"); attemptedConnectionCounter = connectionAttemptCounter.labels("attempted"); @@ -258,7 +258,7 @@ public void addPeerPredicate(final Predicate predicate) { peerPredicates.add(predicate); } - private boolean isPeerValid(DiscoveryPeer peer) { + private boolean isPeerValid(final DiscoveryPeer peer) { return !peer.getNodeAddress().getAddress().isAnyLocalAddress() && peerPredicates.stream().allMatch(predicate -> predicate.test(peer)); } diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/DiscoveryConfig.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/DiscoveryConfig.java index e797ef9c62c..f29c7bd16f0 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/DiscoveryConfig.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/DiscoveryConfig.java @@ -15,23 +15,30 @@ import static com.google.common.base.Preconditions.checkNotNull; import static tech.pegasys.teku.networking.p2p.network.config.NetworkConfig.DEFAULT_P2P_PORT; +import static tech.pegasys.teku.networking.p2p.network.config.NetworkConfig.DEFAULT_P2P_PORT_IPV6; import java.util.Collections; import java.util.List; import java.util.OptionalInt; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; import tech.pegasys.teku.infrastructure.exceptions.InvalidConfigurationException; import tech.pegasys.teku.infrastructure.io.PortAvailability; public class DiscoveryConfig { - + private static final Logger LOG = LogManager.getLogger(); public static final boolean DEFAULT_P2P_DISCOVERY_ENABLED = true; public static final int DEFAULT_P2P_PEERS_LOWER_BOUND = 64; public static final int DEFAULT_P2P_PEERS_UPPER_BOUND = 100; + public static final int DEFAULT_P2P_PEERS_LOWER_BOUND_ALL_SUBNETS = 60; + public static final int DEFAULT_P2P_PEERS_UPPER_BOUND_ALL_SUBNETS = 80; public static final boolean DEFAULT_SITE_LOCAL_ADDRESSES_ENABLED = false; private final boolean isDiscoveryEnabled; private final int listenUdpPort; + private final int listenUpdPortIpv6; private final OptionalInt advertisedUdpPort; + private final OptionalInt advertisedUdpPortIpv6; private final List staticPeers; private final List bootnodes; private final int minPeers; @@ -42,7 +49,9 @@ public class DiscoveryConfig { private DiscoveryConfig( final boolean isDiscoveryEnabled, final int listenUdpPort, + final int listenUpdPortIpv6, final OptionalInt advertisedUdpPort, + final OptionalInt advertisedUdpPortIpv6, final List staticPeers, final List bootnodes, final int minPeers, @@ -51,13 +60,17 @@ private DiscoveryConfig( final boolean siteLocalAddressesEnabled) { this.isDiscoveryEnabled = isDiscoveryEnabled; this.listenUdpPort = listenUdpPort; + this.listenUpdPortIpv6 = listenUpdPortIpv6; this.advertisedUdpPort = advertisedUdpPort; + this.advertisedUdpPortIpv6 = advertisedUdpPortIpv6; this.staticPeers = staticPeers; this.bootnodes = bootnodes; this.minPeers = minPeers; this.maxPeers = maxPeers; this.minRandomlySelectedPeers = minRandomlySelectedPeers; this.siteLocalAddressesEnabled = siteLocalAddressesEnabled; + + LOG.debug("Peer limits - Minimum {}, Maximum {}", minPeers, maxPeers); } public static Builder builder() { @@ -72,10 +85,18 @@ public int getListenUdpPort() { return listenUdpPort; } + public int getListenUpdPortIpv6() { + return listenUpdPortIpv6; + } + public int getAdvertisedUdpPort() { return advertisedUdpPort.orElse(listenUdpPort); } + public int getAdvertisedUdpPortIpv6() { + return advertisedUdpPortIpv6.orElse(listenUpdPortIpv6); + } + public List getStaticPeers() { return staticPeers; } @@ -104,11 +125,13 @@ public static class Builder { private Boolean isDiscoveryEnabled = DEFAULT_P2P_DISCOVERY_ENABLED; private List staticPeers = Collections.emptyList(); private List bootnodes; - private int minPeers = DEFAULT_P2P_PEERS_LOWER_BOUND; - private int maxPeers = DEFAULT_P2P_PEERS_UPPER_BOUND; + private OptionalInt minPeers = OptionalInt.empty(); + private OptionalInt maxPeers = OptionalInt.empty(); private OptionalInt minRandomlySelectedPeers = OptionalInt.empty(); private OptionalInt listenUdpPort = OptionalInt.empty(); + private OptionalInt listenUdpPortIpv6 = OptionalInt.empty(); private OptionalInt advertisedUdpPort = OptionalInt.empty(); + private OptionalInt advertisedUdpPortIpv6 = OptionalInt.empty(); private boolean siteLocalAddressesEnabled = DEFAULT_SITE_LOCAL_ADDRESSES_ENABLED; private Builder() {} @@ -119,26 +142,32 @@ public DiscoveryConfig build() { return new DiscoveryConfig( isDiscoveryEnabled, listenUdpPort.orElseThrow(), + listenUdpPortIpv6.orElseThrow(), advertisedUdpPort, + advertisedUdpPortIpv6, staticPeers, bootnodes == null ? Collections.emptyList() : bootnodes, - minPeers, - maxPeers, + minPeers.orElse(DEFAULT_P2P_PEERS_LOWER_BOUND), + maxPeers.orElse(DEFAULT_P2P_PEERS_UPPER_BOUND), minRandomlySelectedPeers.orElseThrow(), siteLocalAddressesEnabled); } private void initMissingDefaults() { if (minRandomlySelectedPeers.isEmpty()) { - if (maxPeers == 0) { + if (maxPeers.isPresent() && maxPeers.getAsInt() == 0) { minRandomlySelectedPeers = OptionalInt.of(0); } else { - minRandomlySelectedPeers = OptionalInt.of(Math.max(1, minPeers * 2 / 10)); + minRandomlySelectedPeers = + OptionalInt.of(Math.max(1, minPeers.orElse(DEFAULT_P2P_PEERS_LOWER_BOUND) * 2 / 10)); } } if (listenUdpPort.isEmpty()) { listenUdpPort = OptionalInt.of(DEFAULT_P2P_PORT); } + if (listenUdpPortIpv6.isEmpty()) { + listenUdpPortIpv6 = OptionalInt.of(DEFAULT_P2P_PORT_IPV6); + } } public Builder isDiscoveryEnabled(final Boolean discoveryEnabled) { @@ -148,32 +177,37 @@ public Builder isDiscoveryEnabled(final Boolean discoveryEnabled) { } public Builder listenUdpPort(final int listenUdpPort) { - if (!PortAvailability.isPortValid(listenUdpPort)) { - throw new InvalidConfigurationException( - String.format("Invalid listenUdpPort: %d", listenUdpPort)); - } + validatePort(listenUdpPort, "--p2p-udp-port"); this.listenUdpPort = OptionalInt.of(listenUdpPort); return this; } public Builder listenUdpPortDefault(final int listenUdpPort) { - if (!PortAvailability.isPortValid(listenUdpPort)) { - throw new InvalidConfigurationException( - String.format("Invalid listenUdpPortDefault: %d", listenUdpPort)); - } + validatePort(listenUdpPort, "--p2p-udp-port"); if (this.listenUdpPort.isEmpty()) { this.listenUdpPort = OptionalInt.of(listenUdpPort); } return this; } + public Builder listenUdpPortIpv6(final int listenUdpPortIpv6) { + validatePort(listenUdpPortIpv6, "--p2p-udp-port-ipv6"); + this.listenUdpPortIpv6 = OptionalInt.of(listenUdpPortIpv6); + return this; + } + + public Builder listenUdpPortIpv6Default(final int listenUdpPortIpv6) { + validatePort(listenUdpPortIpv6, "--p2p-udp-port-ipv6"); + if (this.listenUdpPortIpv6.isEmpty()) { + this.listenUdpPortIpv6 = OptionalInt.of(listenUdpPortIpv6); + } + return this; + } + public Builder advertisedUdpPort(final OptionalInt advertisedUdpPort) { checkNotNull(advertisedUdpPort); if (advertisedUdpPort.isPresent()) { - if (!PortAvailability.isPortValid(advertisedUdpPort.getAsInt())) { - throw new InvalidConfigurationException( - String.format("Invalid advertisedUdpPort: %d", advertisedUdpPort.getAsInt())); - } + validatePort(advertisedUdpPort.getAsInt(), "--p2p-advertised-udp-port"); } this.advertisedUdpPort = advertisedUdpPort; return this; @@ -182,10 +216,7 @@ public Builder advertisedUdpPort(final OptionalInt advertisedUdpPort) { public Builder advertisedUdpPortDefault(final OptionalInt advertisedUdpPort) { checkNotNull(advertisedUdpPort); if (advertisedUdpPort.isPresent()) { - if (!PortAvailability.isPortValid(advertisedUdpPort.getAsInt())) { - throw new InvalidConfigurationException( - String.format("Invalid advertisedUdpPortDefault: %d", advertisedUdpPort.getAsInt())); - } + validatePort(advertisedUdpPort.getAsInt(), "--p2p-advertised-udp-port"); } if (this.advertisedUdpPort.isEmpty()) { this.advertisedUdpPort = advertisedUdpPort; @@ -193,6 +224,26 @@ public Builder advertisedUdpPortDefault(final OptionalInt advertisedUdpPort) { return this; } + public Builder advertisedUdpPortIpv6(final OptionalInt advertisedUdpPortIpv6) { + checkNotNull(advertisedUdpPortIpv6); + if (advertisedUdpPortIpv6.isPresent()) { + validatePort(advertisedUdpPortIpv6.getAsInt(), "--p2p-advertised-udp-port-ipv6"); + } + this.advertisedUdpPortIpv6 = advertisedUdpPortIpv6; + return this; + } + + public Builder advertisedUdpPortIpv6Default(final OptionalInt advertisedUdpPortIpv6) { + checkNotNull(advertisedUdpPortIpv6); + if (advertisedUdpPortIpv6.isPresent()) { + validatePort(advertisedUdpPortIpv6.getAsInt(), "--p2p-advertised-udp-port-ipv6"); + } + if (this.advertisedUdpPortIpv6.isEmpty()) { + this.advertisedUdpPortIpv6 = advertisedUdpPortIpv6; + } + return this; + } + public Builder staticPeers(final List staticPeers) { checkNotNull(staticPeers); this.staticPeers = staticPeers; @@ -213,12 +264,26 @@ public Builder bootnodesDefault(final List bootnodes) { return this; } + public Builder minPeersIfDefault(final Integer minPeers) { + if (this.minPeers.isEmpty()) { + return minPeers(minPeers); + } + return this; + } + public Builder minPeers(final Integer minPeers) { checkNotNull(minPeers); if (minPeers < 0) { throw new InvalidConfigurationException(String.format("Invalid minPeers: %d", minPeers)); } - this.minPeers = minPeers; + this.minPeers = OptionalInt.of(minPeers); + return this; + } + + public Builder maxPeersIfDefault(final Integer maxPeers) { + if (this.maxPeers.isEmpty()) { + return maxPeers(maxPeers); + } return this; } @@ -227,7 +292,7 @@ public Builder maxPeers(final Integer maxPeers) { if (maxPeers < 0) { throw new InvalidConfigurationException(String.format("Invalid maxPeers: %d", maxPeers)); } - this.maxPeers = maxPeers; + this.maxPeers = OptionalInt.of(maxPeers); return this; } @@ -245,5 +310,11 @@ public Builder siteLocalAddressesEnabled(final boolean siteLocalAddressesEnabled this.siteLocalAddressesEnabled = siteLocalAddressesEnabled; return this; } + + private void validatePort(final int port, final String cliOption) { + if (!PortAvailability.isPortValid(port)) { + throw new InvalidConfigurationException(String.format("Invalid %s: %d", cliOption, port)); + } + } } } diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/DiscoveryNetwork.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/DiscoveryNetwork.java index 9d84f3a90ab..49fa14fd622 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/DiscoveryNetwork.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/DiscoveryNetwork.java @@ -14,6 +14,7 @@ package tech.pegasys.teku.networking.p2p.discovery; import java.math.BigInteger; +import java.util.List; import java.util.Optional; import java.util.stream.Stream; import org.apache.logging.log4j.LogManager; @@ -116,11 +117,11 @@ public Optional getDiscoveryNodeId() { } @Override - public Optional getDiscoveryAddress() { - return discoveryService.getDiscoveryAddress(); + public Optional> getDiscoveryAddresses() { + return discoveryService.getDiscoveryAddresses(); } - public void setLongTermAttestationSubnetSubscriptions(Iterable subnetIds) { + public void setLongTermAttestationSubnetSubscriptions(final Iterable subnetIds) { discoveryService.updateCustomENRField( ATTESTATION_SUBNET_ENR_FIELD, currentSchemaDefinitionsSupplier @@ -129,7 +130,7 @@ public void setLongTermAttestationSubnetSubscriptions(Iterable subnetId .sszSerialize()); } - public void setSyncCommitteeSubnetSubscriptions(Iterable subnetIds) { + public void setSyncCommitteeSubnetSubscriptions(final Iterable subnetIds) { discoveryService.updateCustomENRField( SYNC_COMMITTEE_SUBNET_ENR_FIELD, currentSchemaDefinitionsSupplier @@ -138,7 +139,7 @@ public void setSyncCommitteeSubnetSubscriptions(Iterable subnetIds) { .sszSerialize()); } - public void setDASTotalCustodySubnetCount(int count) { + public void setDASTotalCustodySubnetCount(final int count) { if (count < 0) { throw new IllegalArgumentException( String.format("Custody subnet count should be a positive number, but was %s", count)); @@ -177,7 +178,7 @@ public void setForkInfo(final ForkInfo currentForkInfo, final Optional nex this.enrForkId = Optional.of(enrForkId); } - private boolean dontConnectPeersWithDifferentForkDigests(DiscoveryPeer peer) { + private boolean dontConnectPeersWithDifferentForkDigests(final DiscoveryPeer peer) { return enrForkId .map(EnrForkId::getForkDigest) .flatMap( diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/DiscoveryNetworkBuilder.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/DiscoveryNetworkBuilder.java index 71efafd3f49..51287ce8d75 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/DiscoveryNetworkBuilder.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/DiscoveryNetworkBuilder.java @@ -125,64 +125,64 @@ protected DiscoveryService createDiscoveryService() { return discoveryService; } - public DiscoveryNetworkBuilder metricsSystem(MetricsSystem metricsSystem) { + public DiscoveryNetworkBuilder metricsSystem(final MetricsSystem metricsSystem) { this.metricsSystem = metricsSystem; return this; } - public DiscoveryNetworkBuilder asyncRunner(AsyncRunner asyncRunner) { + public DiscoveryNetworkBuilder asyncRunner(final AsyncRunner asyncRunner) { this.asyncRunner = asyncRunner; return this; } - public DiscoveryNetworkBuilder kvStore(KeyValueStore kvStore) { + public DiscoveryNetworkBuilder kvStore(final KeyValueStore kvStore) { this.kvStore = kvStore; return this; } - public DiscoveryNetworkBuilder p2pNetwork(P2PNetwork p2pNetwork) { + public DiscoveryNetworkBuilder p2pNetwork(final P2PNetwork p2pNetwork) { this.p2pNetwork = p2pNetwork; return this; } - public DiscoveryNetworkBuilder peerPools(PeerPools peerPools) { + public DiscoveryNetworkBuilder peerPools(final PeerPools peerPools) { this.peerPools = peerPools; return this; } public DiscoveryNetworkBuilder peerSelectionStrategy( - PeerSelectionStrategy peerSelectionStrategy) { + final PeerSelectionStrategy peerSelectionStrategy) { this.peerSelectionStrategy = peerSelectionStrategy; return this; } - public DiscoveryNetworkBuilder discoveryConfig(DiscoveryConfig discoveryConfig) { + public DiscoveryNetworkBuilder discoveryConfig(final DiscoveryConfig discoveryConfig) { this.discoveryConfig = discoveryConfig; return this; } - public DiscoveryNetworkBuilder p2pConfig(NetworkConfig p2pConfig) { + public DiscoveryNetworkBuilder p2pConfig(final NetworkConfig p2pConfig) { this.p2pConfig = p2pConfig; return this; } - public DiscoveryNetworkBuilder spec(Spec spec) { + public DiscoveryNetworkBuilder spec(final Spec spec) { this.spec = spec; return this; } public DiscoveryNetworkBuilder currentSchemaDefinitionsSupplier( - SchemaDefinitionsSupplier currentSchemaDefinitionsSupplier) { + final SchemaDefinitionsSupplier currentSchemaDefinitionsSupplier) { this.currentSchemaDefinitionsSupplier = currentSchemaDefinitionsSupplier; return this; } - public DiscoveryNetworkBuilder discoveryService(DiscoveryService discoveryService) { + public DiscoveryNetworkBuilder discoveryService(final DiscoveryService discoveryService) { this.discoveryService = discoveryService; return this; } - public DiscoveryNetworkBuilder connectionManager(ConnectionManager connectionManager) { + public DiscoveryNetworkBuilder connectionManager(final ConnectionManager connectionManager) { this.connectionManager = connectionManager; return this; } diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/DiscoveryPeer.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/DiscoveryPeer.java index 7ef9d01e597..69fa902c255 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/DiscoveryPeer.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/DiscoveryPeer.java @@ -76,7 +76,7 @@ public Optional getDasCustodySubnetCount() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/DiscoveryService.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/DiscoveryService.java index 82f76cd12dc..1ff95b2ab07 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/DiscoveryService.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/DiscoveryService.java @@ -14,6 +14,7 @@ package tech.pegasys.teku.networking.p2p.discovery; import java.util.Collection; +import java.util.List; import java.util.Optional; import java.util.stream.Stream; import org.apache.tuweni.bytes.Bytes; @@ -37,7 +38,7 @@ public interface DiscoveryService { Optional getNodeId(); - Optional getDiscoveryAddress(); + Optional> getDiscoveryAddresses(); void updateCustomENRField(String fieldName, Bytes value); diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/discv5/DiscV5Service.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/discv5/DiscV5Service.java index 5fb4ac78b2e..5b114159cab 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/discv5/DiscV5Service.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/discv5/DiscV5Service.java @@ -15,7 +15,10 @@ import static java.util.Collections.emptyList; +import com.google.common.base.Preconditions; +import java.net.InetSocketAddress; import java.time.Duration; +import java.util.ArrayList; import java.util.Collection; import java.util.List; import java.util.Optional; @@ -38,6 +41,8 @@ import tech.pegasys.teku.infrastructure.async.AsyncRunner; import tech.pegasys.teku.infrastructure.async.Cancellable; import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.io.IPVersionResolver; +import tech.pegasys.teku.infrastructure.io.IPVersionResolver.IPVersion; import tech.pegasys.teku.infrastructure.metrics.TekuMetricCategory; import tech.pegasys.teku.networking.p2p.discovery.DiscoveryConfig; import tech.pegasys.teku.networking.p2p.discovery.DiscoveryPeer; @@ -66,6 +71,7 @@ public static DiscoverySystemBuilder createDefaultDiscoverySystemBuilder() { private final DiscoverySystem discoverySystem; private final KeyValueStore kvStore; + private final boolean supportsIpv6; private final List bootnodes; private volatile Cancellable bootnodeRefreshTask; @@ -83,26 +89,70 @@ public DiscV5Service( this.localNodePrivateKey = SecretKeyParser.fromLibP2pPrivKey(privateKey); this.currentSchemaDefinitionsSupplier = currentSchemaDefinitionsSupplier; this.nodeRecordConverter = nodeRecordConverter; - final String listenAddress = p2pConfig.getNetworkInterface(); - final int listenUdpPort = discoConfig.getListenUdpPort(); - final String advertisedAddress = p2pConfig.getAdvertisedIp(); - final int advertisedTcpPort = p2pConfig.getAdvertisedPort(); - final int advertisedUdpPort = discoConfig.getAdvertisedUdpPort(); + final List networkInterfaces = p2pConfig.getNetworkInterfaces(); + Preconditions.checkState( + networkInterfaces.size() == 1 || networkInterfaces.size() == 2, + "The configured network interfaces must be either 1 or 2"); + if (networkInterfaces.size() == 1) { + final String listenAddress = networkInterfaces.get(0); + discoverySystemBuilder.listen(listenAddress, discoConfig.getListenUdpPort()); + this.supportsIpv6 = IPVersionResolver.resolve(listenAddress) == IPVersion.IP_V6; + } else { + // IPv4 and IPv6 (dual-stack) + final InetSocketAddress[] listenAddresses = + networkInterfaces.stream() + .map( + networkInterface -> { + final int listenUdpPort = + switch (IPVersionResolver.resolve(networkInterface)) { + case IP_V4 -> discoConfig.getListenUdpPort(); + case IP_V6 -> discoConfig.getListenUpdPortIpv6(); + }; + return new InetSocketAddress(networkInterface, listenUdpPort); + }) + .toArray(InetSocketAddress[]::new); + discoverySystemBuilder.listen(listenAddresses); + this.supportsIpv6 = true; + } final UInt64 seqNo = kvStore.get(SEQ_NO_STORE_KEY).map(UInt64::fromBytes).orElse(UInt64.ZERO).add(1); - final NewAddressHandler maybeUpdateNodeRecordHandler = - maybeUpdateNodeRecord(p2pConfig.hasUserExplicitlySetAdvertisedIp(), advertisedTcpPort); + final NewAddressHandler maybeUpdateNodeRecordHandler = maybeUpdateNodeRecord(p2pConfig); this.bootnodes = discoConfig.getBootnodes().stream().map(NodeRecordFactory.DEFAULT::fromEnr).toList(); final NodeRecordBuilder nodeRecordBuilder = new NodeRecordBuilder().secretKey(localNodePrivateKey).seq(seqNo); - if (p2pConfig.hasUserExplicitlySetAdvertisedIp()) { - nodeRecordBuilder.address(advertisedAddress, advertisedUdpPort, advertisedTcpPort); + if (p2pConfig.hasUserExplicitlySetAdvertisedIps()) { + final List advertisedIps = p2pConfig.getAdvertisedIps(); + Preconditions.checkState( + advertisedIps.size() == 1 || advertisedIps.size() == 2, + "The configured advertised IPs must be either 1 or 2"); + if (advertisedIps.size() == 1) { + nodeRecordBuilder.address( + advertisedIps.get(0), + discoConfig.getAdvertisedUdpPort(), + p2pConfig.getAdvertisedPort()); + } else { + // IPv4 and IPv6 (dual-stack) + advertisedIps.forEach( + advertisedIp -> { + final IPVersion ipVersion = IPVersionResolver.resolve(advertisedIp); + final int advertisedUdpPort = + switch (ipVersion) { + case IP_V4 -> discoConfig.getAdvertisedUdpPort(); + case IP_V6 -> discoConfig.getAdvertisedUdpPortIpv6(); + }; + final int advertisedTcpPort = + switch (ipVersion) { + case IP_V4 -> p2pConfig.getAdvertisedPort(); + case IP_V6 -> p2pConfig.getAdvertisedPortIpv6(); + }; + nodeRecordBuilder.address(advertisedIp, advertisedUdpPort, advertisedTcpPort); + }); + } } final NodeRecord localNodeRecord = nodeRecordBuilder.build(); this.discoverySystem = discoverySystemBuilder - .listen(listenAddress, listenUdpPort) .secretKey(localNodePrivateKey) .bootnodes(bootnodes) .localNodeRecord(localNodeRecord) @@ -121,19 +171,29 @@ public DiscV5Service( () -> discoverySystem.getBucketStats().getTotalLiveNodeCount()); } - private NewAddressHandler maybeUpdateNodeRecord( - boolean userExplicitlySetAdvertisedIpOrPort, final int advertisedTcpPort) { - if (userExplicitlySetAdvertisedIpOrPort) { + private NewAddressHandler maybeUpdateNodeRecord(final NetworkConfig p2pConfig) { + if (p2pConfig.hasUserExplicitlySetAdvertisedIps()) { return (oldRecord, newAddress) -> Optional.of(oldRecord); } else { - return (oldRecord, newAddress) -> - Optional.of( - oldRecord.withNewAddress( - newAddress, Optional.of(advertisedTcpPort), localNodePrivateKey)); + return (oldRecord, newAddress) -> { + final int newTcpPort; + if (p2pConfig.getNetworkInterfaces().size() == 1) { + newTcpPort = p2pConfig.getAdvertisedPort(); + } else { + // IPv4 and IPv6 (dual-stack) + newTcpPort = + switch (IPVersionResolver.resolve(newAddress)) { + case IP_V4 -> p2pConfig.getAdvertisedPort(); + case IP_V6 -> p2pConfig.getAdvertisedPortIpv6(); + }; + } + return Optional.of( + oldRecord.withNewAddress(newAddress, Optional.of(newTcpPort), localNodePrivateKey)); + }; } } - private void localNodeRecordUpdated(NodeRecord oldRecord, NodeRecord newRecord) { + private void localNodeRecordUpdated(final NodeRecord oldRecord, final NodeRecord newRecord) { kvStore.put(SEQ_NO_STORE_KEY, newRecord.getSeq().toBytes()); } @@ -173,7 +233,10 @@ public Stream streamKnownPeers() { currentSchemaDefinitionsSupplier.getSchemaDefinitions(); return activeNodes() .flatMap( - node -> nodeRecordConverter.convertToDiscoveryPeer(node, schemaDefinitions).stream()); + node -> + nodeRecordConverter + .convertToDiscoveryPeer(node, supportsIpv6, schemaDefinitions) + .stream()); } @Override @@ -191,7 +254,9 @@ private List convertToDiscoveryPeers(final Collection return foundNodes.stream() .flatMap( nodeRecord -> - nodeRecordConverter.convertToDiscoveryPeer(nodeRecord, schemaDefinitions).stream()) + nodeRecordConverter + .convertToDiscoveryPeer(nodeRecord, supportsIpv6, schemaDefinitions) + .stream()) .toList(); } @@ -206,26 +271,35 @@ public Optional getNodeId() { } @Override - public Optional getDiscoveryAddress() { + public Optional> getDiscoveryAddresses() { final NodeRecord nodeRecord = discoverySystem.getLocalNodeRecord(); - if (nodeRecord.getUdpAddress().isEmpty()) { + final List updAddresses = new ArrayList<>(); + nodeRecord.getUdpAddress().ifPresent(updAddresses::add); + nodeRecord.getUdp6Address().ifPresent(updAddresses::add); + if (updAddresses.isEmpty()) { return Optional.empty(); } - final DiscoveryPeer discoveryPeer = - new DiscoveryPeer( - (Bytes) nodeRecord.get(EnrField.PKEY_SECP256K1), - nodeRecord.getNodeId(), - nodeRecord.getUdpAddress().get(), - Optional.empty(), - currentSchemaDefinitionsSupplier.getAttnetsENRFieldSchema().getDefault(), - currentSchemaDefinitionsSupplier.getSyncnetsENRFieldSchema().getDefault(), - Optional.empty()); - - return Optional.of(MultiaddrUtil.fromDiscoveryPeerAsUdp(discoveryPeer).toString()); + final List discoveryAddresses = + updAddresses.stream() + .map( + updAddress -> { + final DiscoveryPeer discoveryPeer = + new DiscoveryPeer( + (Bytes) nodeRecord.get(EnrField.PKEY_SECP256K1), + nodeRecord.getNodeId(), + updAddress, + Optional.empty(), + currentSchemaDefinitionsSupplier.getAttnetsENRFieldSchema().getDefault(), + currentSchemaDefinitionsSupplier.getSyncnetsENRFieldSchema().getDefault(), + Optional.empty()); + return MultiaddrUtil.fromDiscoveryPeerAsUdp(discoveryPeer).toString(); + }) + .toList(); + return Optional.of(discoveryAddresses); } @Override - public void updateCustomENRField(String fieldName, Bytes value) { + public void updateCustomENRField(final String fieldName, final Bytes value) { discoverySystem.updateCustomFieldValue(fieldName, value); } diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/discv5/NodeRecordConverter.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/discv5/NodeRecordConverter.java index ce342dd3e1b..96526037298 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/discv5/NodeRecordConverter.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/discv5/NodeRecordConverter.java @@ -42,10 +42,18 @@ public Bytes convertPublicKeyToNodeId(final Bytes publicKey) { } public Optional convertToDiscoveryPeer( - final NodeRecord nodeRecord, final SchemaDefinitions schemaDefinitions) { - return nodeRecord - .getTcpAddress() - .map(address -> socketAddressToDiscoveryPeer(schemaDefinitions, nodeRecord, address)); + final NodeRecord nodeRecord, + final boolean supportsIpv6, + final SchemaDefinitions schemaDefinitions) { + final Optional tcpAddress; + if (supportsIpv6) { + // prefer IPv6 address + tcpAddress = nodeRecord.getTcp6Address().or(nodeRecord::getTcpAddress); + } else { + tcpAddress = nodeRecord.getTcpAddress(); + } + return tcpAddress.map( + address -> socketAddressToDiscoveryPeer(schemaDefinitions, nodeRecord, address)); } private static DiscoveryPeer socketAddressToDiscoveryPeer( diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/noop/NoOpDiscoveryService.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/noop/NoOpDiscoveryService.java index 4af56cf2956..32c6f38630f 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/noop/NoOpDiscoveryService.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/discovery/noop/NoOpDiscoveryService.java @@ -16,6 +16,7 @@ import java.math.BigInteger; import java.util.Collection; import java.util.Collections; +import java.util.List; import java.util.Optional; import java.util.stream.Stream; import org.apache.tuweni.bytes.Bytes; @@ -57,7 +58,7 @@ public Optional getNodeId() { } @Override - public Optional getDiscoveryAddress() { + public Optional> getDiscoveryAddresses() { return Optional.empty(); } diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/gossip/TopicChannel.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/gossip/TopicChannel.java index 581cc2479e5..aff796b8f5f 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/gossip/TopicChannel.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/gossip/TopicChannel.java @@ -14,9 +14,10 @@ package tech.pegasys.teku.networking.p2p.gossip; import org.apache.tuweni.bytes.Bytes; +import tech.pegasys.teku.infrastructure.async.SafeFuture; public interface TopicChannel { - void gossip(Bytes data); + SafeFuture gossip(Bytes data); void close(); } diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/gossip/config/GossipConfig.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/gossip/config/GossipConfig.java index ec42e2268e1..ce82d57b529 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/gossip/config/GossipConfig.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/gossip/config/GossipConfig.java @@ -36,6 +36,7 @@ public class GossipConfig { // After EIP-7045, attestations are valid for up to 2 full epochs, so TTL is 65 // slots 1115 * HEARTBEAT = 1115 * 0.7 / 12 = 65.125 static final Duration DEFAULT_SEEN_TTL = DEFAULT_HEARTBEAT_INTERVAL.multipliedBy(1115); + public static final int DEFAULT_FLOOD_PUBLISH_MAX_MESSAGE_SIZE_THRESHOLD = 1 << 14; // 16KiB private final int d; private final int dLow; @@ -46,18 +47,20 @@ public class GossipConfig { private final int history; private final Duration heartbeatInterval; private final Duration seenTTL; + private final int floodPublishMaxMessageSizeThreshold; private final GossipScoringConfig scoringConfig; private GossipConfig( - int d, - int dLow, - int dHigh, - int dLazy, - Duration fanoutTTL, - int advertise, - int history, - Duration heartbeatInterval, - Duration seenTTL, + final int d, + final int dLow, + final int dHigh, + final int dLazy, + final Duration fanoutTTL, + final int advertise, + final int history, + final Duration heartbeatInterval, + final Duration seenTTL, + final int floodPublishMaxMessageSizeThreshold, final GossipScoringConfig scoringConfig) { this.d = d; this.dLow = dLow; @@ -68,6 +71,7 @@ private GossipConfig( this.history = history; this.heartbeatInterval = heartbeatInterval; this.seenTTL = seenTTL; + this.floodPublishMaxMessageSizeThreshold = floodPublishMaxMessageSizeThreshold; this.scoringConfig = scoringConfig; } @@ -115,6 +119,10 @@ public Duration getSeenTTL() { return seenTTL; } + public int getFloodPublishMaxMessageSizeThreshold() { + return floodPublishMaxMessageSizeThreshold; + } + public GossipScoringConfig getScoringConfig() { return scoringConfig; } @@ -131,6 +139,8 @@ public static class Builder { private Integer history = DEFAULT_HISTORY; private Duration heartbeatInterval = DEFAULT_HEARTBEAT_INTERVAL; private Duration seenTTL = DEFAULT_SEEN_TTL; + private int floodPublishMaxMessageSizeThreshold = + DEFAULT_FLOOD_PUBLISH_MAX_MESSAGE_SIZE_THRESHOLD; private Builder() {} @@ -145,6 +155,7 @@ public GossipConfig build() { history, heartbeatInterval, seenTTL, + floodPublishMaxMessageSizeThreshold, scoringConfigBuilder.build()); } @@ -217,6 +228,12 @@ public Builder seenTTL(final Duration seenTTL) { return this; } + public Builder floodPublishMaxMessageSizeThreshold( + final int floodPublishMaxMessageSizeThreshold) { + this.floodPublishMaxMessageSizeThreshold = floodPublishMaxMessageSizeThreshold; + return this; + } + public Builder directPeerManager(final DirectPeerManager directPeerManager) { checkNotNull(directPeerManager); this.scoringConfigBuilder.directPeerManager(directPeerManager); diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/Firewall.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/Firewall.java index a1b7a4f021c..066eab6e691 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/Firewall.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/Firewall.java @@ -35,26 +35,27 @@ public class Firewall extends ChannelInboundHandlerAdapter { private final Duration writeTimeout; - public Firewall(Duration writeTimeout) { + public Firewall(final Duration writeTimeout) { this.writeTimeout = writeTimeout; } @Override - public void handlerAdded(ChannelHandlerContext ctx) { + public void handlerAdded(final ChannelHandlerContext ctx) { ctx.channel().config().setWriteBufferWaterMark(new WriteBufferWaterMark(100, 1024)); ctx.pipeline().addLast(new WriteTimeoutHandler(writeTimeout.toMillis(), TimeUnit.MILLISECONDS)); ctx.pipeline().addLast(new FirewallExceptionHandler()); } @Override - public void channelWritabilityChanged(ChannelHandlerContext ctx) { + public void channelWritabilityChanged(final ChannelHandlerContext ctx) { ctx.channel().config().setAutoRead(ctx.channel().isWritable()); ctx.fireChannelWritabilityChanged(); } class FirewallExceptionHandler extends ChannelInboundHandlerAdapter { @Override - public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { + public void exceptionCaught(final ChannelHandlerContext ctx, final Throwable cause) + throws Exception { if (cause instanceof WriteTimeoutException) { LOG.debug("Firewall closed channel by write timeout. No writes during " + writeTimeout); } else { diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/LibP2PNetwork.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/LibP2PNetwork.java index 597d63cc801..b13f73fd6ad 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/LibP2PNetwork.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/LibP2PNetwork.java @@ -21,6 +21,7 @@ import io.libp2p.core.crypto.PrivKey; import io.libp2p.core.multiformats.Multiaddr; import java.util.Collection; +import java.util.List; import java.util.Map; import java.util.Optional; import java.util.concurrent.atomic.AtomicReference; @@ -50,30 +51,29 @@ public class LibP2PNetwork implements P2PNetwork { private final PrivKey privKey; private final NodeId nodeId; - private final Host host; private final PeerManager peerManager; - private final Multiaddr advertisedAddr; + private final List advertisedAddresses; private final GossipNetwork gossipNetwork; + private final List listenPorts; private final AtomicReference state = new AtomicReference<>(State.IDLE); - private final int listenPort; protected LibP2PNetwork( - PrivKey privKey, - NodeId nodeId, - Host host, - PeerManager peerManager, - Multiaddr advertisedAddr, - GossipNetwork gossipNetwork, - int listenPort) { + final PrivKey privKey, + final NodeId nodeId, + final Host host, + final PeerManager peerManager, + final List advertisedAddresses, + final GossipNetwork gossipNetwork, + final List listenPorts) { this.privKey = privKey; this.nodeId = nodeId; this.host = host; this.peerManager = peerManager; - this.advertisedAddr = advertisedAddr; + this.advertisedAddresses = advertisedAddresses; this.gossipNetwork = gossipNetwork; - this.listenPort = listenPort; + this.listenPorts = listenPorts; } @Override @@ -85,14 +85,14 @@ public SafeFuture start() { return SafeFuture.of(host.start()) .thenApply( i -> { - STATUS_LOG.listeningForLibP2P(getNodeAddress()); + STATUS_LOG.listeningForLibP2P(getNodeAddresses()); return null; }); } @Override - public String getNodeAddress() { - return advertisedAddr.toString(); + public List getNodeAddresses() { + return advertisedAddresses.stream().map(Multiaddr::toString).toList(); } @Override @@ -157,8 +157,8 @@ public int getPeerCount() { } @Override - public int getListenPort() { - return listenPort; + public List getListenPorts() { + return listenPorts; } @Override @@ -186,7 +186,7 @@ public Optional getDiscoveryNodeId() { } @Override - public Optional getDiscoveryAddress() { + public Optional> getDiscoveryAddresses() { return Optional.empty(); } diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/LibP2PNetworkBuilder.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/LibP2PNetworkBuilder.java index 374a6fddfd7..5b809f77d14 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/LibP2PNetworkBuilder.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/LibP2PNetworkBuilder.java @@ -16,6 +16,7 @@ import static tech.pegasys.teku.networking.p2p.libp2p.LibP2PNetwork.REMOTE_OPEN_STREAMS_RATE_LIMIT; import static tech.pegasys.teku.networking.p2p.libp2p.LibP2PNetwork.REMOTE_PARALLEL_OPEN_STREAMS_COUNT_LIMIT; +import com.google.common.base.Preconditions; import identify.pb.IdentifyOuterClass; import io.libp2p.core.Host; import io.libp2p.core.PeerId; @@ -34,9 +35,11 @@ import io.netty.handler.logging.LogLevel; import java.net.InetSocketAddress; import java.time.Duration; +import java.util.Collections; import java.util.List; import org.hyperledger.besu.plugin.services.MetricsSystem; import tech.pegasys.teku.infrastructure.async.AsyncRunner; +import tech.pegasys.teku.infrastructure.io.IPVersionResolver; import tech.pegasys.teku.infrastructure.time.TimeProvider; import tech.pegasys.teku.infrastructure.version.VersionProvider; import tech.pegasys.teku.networking.p2p.gossip.PreparedGossipMessageFactory; @@ -101,21 +104,51 @@ public P2PNetwork build() { // Setup peers peerManager = createPeerManager(); - host = createHost(); - - NodeId nodeId = new LibP2PNodeId(host.getPeerId()); - Multiaddr advertisedAddr = - MultiaddrUtil.fromInetSocketAddress( - new InetSocketAddress(config.getAdvertisedIp(), config.getAdvertisedPort()), nodeId); + final PrivKey privKey = privateKeyProvider.get(); + final NodeId nodeId = new LibP2PNodeId(PeerId.fromPubKey(privKey.publicKey())); + + final List advertisedAddresses; + final List advertisedIps = config.getAdvertisedIps(); + Preconditions.checkState( + advertisedIps.size() == 1 || advertisedIps.size() == 2, + "The configured advertised IPs must be either 1 or 2"); + if (advertisedIps.size() == 1) { + advertisedAddresses = + Collections.singletonList( + MultiaddrUtil.fromInetSocketAddress( + new InetSocketAddress(advertisedIps.get(0), config.getAdvertisedPort()), nodeId)); + } else { + // IPv4 and IPv6 (dual-stack) + advertisedAddresses = + advertisedIps.stream() + .map( + advertisedIp -> { + final int advertisedPort = + switch (IPVersionResolver.resolve(advertisedIp)) { + case IP_V4 -> config.getAdvertisedPort(); + case IP_V6 -> config.getAdvertisedPortIpv6(); + }; + return MultiaddrUtil.fromInetSocketAddress( + new InetSocketAddress(advertisedIp, advertisedPort), nodeId); + }) + .toList(); + } + + host = createHost(privKey, advertisedAddresses); + + final List listenPorts = + advertisedAddresses.size() == 2 + ? List.of(config.getListenPort(), config.getListenPortIpv6()) + : List.of(config.getListenPort()); return new LibP2PNetwork( host.getPrivKey(), nodeId, host, peerManager, - advertisedAddr, + advertisedAddresses, gossipNetwork, - config.getListenPort()); + listenPorts); } protected List> createRpcHandlers() { @@ -145,16 +178,35 @@ protected PeerManager createPeerManager() { } @SuppressWarnings("AddressSelection") - protected Host createHost() { - PrivKey privKey = privateKeyProvider.get(); - NodeId nodeId = new LibP2PNodeId(PeerId.fromPubKey(privKey.publicKey())); - - Multiaddr advertisedAddr = - MultiaddrUtil.fromInetSocketAddress( - new InetSocketAddress(config.getAdvertisedIp(), config.getAdvertisedPort()), nodeId); - final Multiaddr listenAddr = - MultiaddrUtil.fromInetSocketAddress( - new InetSocketAddress(config.getNetworkInterface(), config.getListenPort())); + protected Host createHost(final PrivKey privKey, final List advertisedAddresses) { + final String[] listenAddrs; + final List networkInterfaces = config.getNetworkInterfaces(); + Preconditions.checkState( + networkInterfaces.size() == 1 || networkInterfaces.size() == 2, + "The configured network interfaces must be either 1 or 2"); + if (networkInterfaces.size() == 1) { + final Multiaddr addr = + MultiaddrUtil.fromInetSocketAddress( + new InetSocketAddress(networkInterfaces.get(0), config.getListenPort())); + listenAddrs = new String[] {addr.toString()}; + } else { + // IPv4 and IPv6 (dual-stack) + listenAddrs = + networkInterfaces.stream() + .map( + networkInterface -> { + final int listenPort = + switch (IPVersionResolver.resolve(networkInterface)) { + case IP_V4 -> config.getListenPort(); + case IP_V6 -> config.getListenPortIpv6(); + }; + final Multiaddr addr = + MultiaddrUtil.fromInetSocketAddress( + new InetSocketAddress(networkInterface, listenPort)); + return addr.toString(); + }) + .toArray(String[]::new); + } return BuilderJKt.hostJ( hostBuilderDefaults, @@ -171,9 +223,11 @@ protected Host createHost() { } b.getMuxers().add(StreamMuxerProtocol.getMplex()); - b.getNetwork().listen(listenAddr.toString()); - - b.getProtocols().addAll(getDefaultProtocols(privKey.publicKey(), advertisedAddr)); + b.getNetwork().listen(listenAddrs); + advertisedAddresses.forEach( + advertisedAddr -> + b.getProtocols() + .addAll(getDefaultProtocols(privKey.publicKey(), advertisedAddr))); b.getProtocols().add(gossipNetwork.getGossip()); b.getProtocols().addAll(rpcHandlers); @@ -196,9 +250,9 @@ protected Host createHost() { } protected List> getDefaultProtocols( - PubKey nodePubKey, Multiaddr advertisedAddr) { + final PubKey nodePubKey, final Multiaddr advertisedAddr) { final Ping ping = new Ping(); - IdentifyOuterClass.Identify identifyMsg = + final IdentifyOuterClass.Identify identifyMsg = IdentifyOuterClass.Identify.newBuilder() .setProtocolVersion("ipfs/0.1.0") .setAgentVersion(VersionProvider.CLIENT_IDENTITY + "/" + VersionProvider.VERSION) @@ -216,12 +270,12 @@ protected LibP2PGossipNetworkBuilder createLibP2PGossipNetworkBuilder() { return LibP2PGossipNetworkBuilder.create(); } - public LibP2PNetworkBuilder asyncRunner(AsyncRunner asyncRunner) { + public LibP2PNetworkBuilder asyncRunner(final AsyncRunner asyncRunner) { this.asyncRunner = asyncRunner; return this; } - public LibP2PNetworkBuilder config(NetworkConfig config) { + public LibP2PNetworkBuilder config(final NetworkConfig config) { this.config = config; return this; } @@ -232,53 +286,53 @@ public LibP2PNetworkBuilder networkingSpecConfig( return this; } - public LibP2PNetworkBuilder privateKeyProvider(PrivateKeyProvider privateKeyProvider) { + public LibP2PNetworkBuilder privateKeyProvider(final PrivateKeyProvider privateKeyProvider) { this.privateKeyProvider = privateKeyProvider; return this; } - public LibP2PNetworkBuilder reputationManager(ReputationManager reputationManager) { + public LibP2PNetworkBuilder reputationManager(final ReputationManager reputationManager) { this.reputationManager = reputationManager; return this; } - public LibP2PNetworkBuilder metricsSystem(MetricsSystem metricsSystem) { + public LibP2PNetworkBuilder metricsSystem(final MetricsSystem metricsSystem) { this.metricsSystem = metricsSystem; return this; } - public LibP2PNetworkBuilder rpcMethods(List> rpcMethods) { + public LibP2PNetworkBuilder rpcMethods(final List> rpcMethods) { this.rpcMethods = rpcMethods; return this; } - public LibP2PNetworkBuilder peerHandlers(List peerHandlers) { + public LibP2PNetworkBuilder peerHandlers(final List peerHandlers) { this.peerHandlers = peerHandlers; return this; } public LibP2PNetworkBuilder preparedGossipMessageFactory( - PreparedGossipMessageFactory preparedGossipMessageFactory) { + final PreparedGossipMessageFactory preparedGossipMessageFactory) { this.preparedGossipMessageFactory = preparedGossipMessageFactory; return this; } - public LibP2PNetworkBuilder gossipTopicFilter(GossipTopicFilter gossipTopicFilter) { + public LibP2PNetworkBuilder gossipTopicFilter(final GossipTopicFilter gossipTopicFilter) { this.gossipTopicFilter = gossipTopicFilter; return this; } - public LibP2PNetworkBuilder hostBuilderDefaults(Defaults hostBuilderDefaults) { + public LibP2PNetworkBuilder hostBuilderDefaults(final Defaults hostBuilderDefaults) { this.hostBuilderDefaults = hostBuilderDefaults; return this; } - public LibP2PNetworkBuilder firewall(Firewall firewall) { + public LibP2PNetworkBuilder firewall(final Firewall firewall) { this.firewall = firewall; return this; } - public LibP2PNetworkBuilder muxFirewall(MuxFirewall muxFirewall) { + public LibP2PNetworkBuilder muxFirewall(final MuxFirewall muxFirewall) { this.muxFirewall = muxFirewall; return this; } diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/LibP2PPeer.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/LibP2PPeer.java index 4379ded98d8..f47e1b1c8ce 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/LibP2PPeer.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/LibP2PPeer.java @@ -146,6 +146,7 @@ public void disconnectImmediately( SafeFuture.of(connection.close()) .finish( () -> + // TODO: LOG.trace in prod LOG.info( "Disconnected forcibly {} because {} from {}", locallyInitiated ? "locally" : "remotely", @@ -178,6 +179,7 @@ private SafeFuture getIdentify() { @Override public SafeFuture disconnectCleanly(final DisconnectReason reason) { if (connected.getAndSet(false)) { + // TODO: LOG.trace in prod LOG.info("Disconnecting cleanly because {} from {}", reason, connection.remoteAddress()); connected.set(false); disconnectReason = Optional.of(reason); @@ -214,7 +216,7 @@ public void subscribeDisconnect(final PeerDisconnectedSubscriber subscriber) { TRequest, RespHandler extends RpcResponseHandler> SafeFuture> sendRequest( - RpcMethod rpcMethod, + final RpcMethod rpcMethod, final TRequest request, final RespHandler responseHandler) { @SuppressWarnings("unchecked") diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/PeerManager.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/PeerManager.java index e4992942fe5..654bd4efd0f 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/PeerManager.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/PeerManager.java @@ -63,7 +63,7 @@ public PeerManager( final ReputationManager reputationManager, final List peerHandlers, final List> rpcHandlers, - Function peerScoreFunction) { + final Function peerScoreFunction) { this.reputationManager = reputationManager; this.peerHandlers = peerHandlers; this.rpcHandlers = rpcHandlers; @@ -157,12 +157,12 @@ private CompletionStage handleConcurrentConnectionInitiation(final Throwab : SafeFuture.failedFuture(error); } - public Optional getPeer(NodeId id) { + public Optional getPeer(final NodeId id) { return Optional.ofNullable(connectedPeerMap.get(id)); } @VisibleForTesting - void onConnectedPeer(Peer peer) { + void onConnectedPeer(final Peer peer) { final boolean wasAdded = connectedPeerMap.putIfAbsent(peer.getId(), peer) == null; if (wasAdded) { LOG.debug("onConnectedPeer() {}", peer.getId()); diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/config/LibP2PParamsFactory.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/config/LibP2PParamsFactory.java index 9ad76de4a14..c24629cd897 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/config/LibP2PParamsFactory.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/config/LibP2PParamsFactory.java @@ -47,10 +47,10 @@ private static void addGossipParamsMiscValues( final GossipConfig gossipConfig, final GossipParamsBuilder builder) { builder .fanoutTTL(gossipConfig.getFanoutTTL()) + .floodPublishMaxMessageSizeThreshold(gossipConfig.getFloodPublishMaxMessageSizeThreshold()) .gossipSize(gossipConfig.getAdvertise()) .gossipHistoryLength(gossipConfig.getHistory()) .heartbeatInterval(gossipConfig.getHeartbeatInterval()) - .floodPublish(true) .seenTTL(gossipConfig.getSeenTTL()); } diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/GossipHandler.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/GossipHandler.java index 47f2166d428..9c1b76387b1 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/GossipHandler.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/GossipHandler.java @@ -73,20 +73,17 @@ public SafeFuture apply(final MessageApi message) { } LOG.trace("Received message for topic {}", topic); - PubsubMessage pubsubMessage = message.getOriginalMessage(); - if (!(pubsubMessage instanceof PreparedPubsubMessage)) { + final PubsubMessage pubsubMessage = message.getOriginalMessage(); + if (!(pubsubMessage instanceof PreparedPubsubMessage gossipPubsubMessage)) { throw new IllegalArgumentException( "Don't know this PubsubMessage implementation: " + pubsubMessage.getClass()); } - PreparedPubsubMessage gossipPubsubMessage = (PreparedPubsubMessage) pubsubMessage; return handler.handleMessage(gossipPubsubMessage.getPreparedMessage()); } - public void gossip(Bytes bytes) { + public SafeFuture gossip(final Bytes bytes) { LOG.trace("Gossiping {}: {} bytes", topic, bytes.size()); - SafeFuture.of(publisher.publish(Unpooled.wrappedBuffer(bytes.toArrayUnsafe()), topic)) - .finish( - () -> LOG.trace("Successfully gossiped message on {}", topic), - err -> LOG.debug("Failed to gossip message on " + topic, err)); + return SafeFuture.of(publisher.publish(Unpooled.wrappedBuffer(bytes.toArrayUnsafe()), topic)) + .thenRun(() -> LOG.trace("Successfully gossiped message on {}", topic)); } } diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/GossipTopicHandlers.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/GossipTopicHandlers.java index 31905e73c6e..4ff3c45bf6a 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/GossipTopicHandlers.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/GossipTopicHandlers.java @@ -22,11 +22,11 @@ public class GossipTopicHandlers { private final Map topicToHandlerMap = new ConcurrentHashMap<>(); - public void add(String topic, TopicHandler handler) { + public void add(final String topic, final TopicHandler handler) { topicToHandlerMap.put(topic, handler); } - public Optional getHandlerForTopic(String topic) { + public Optional getHandlerForTopic(final String topic) { return Optional.ofNullable(topicToHandlerMap.get(topic)); } } diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/GossipWireValidator.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/GossipWireValidator.java index 86d0ceebb42..81507cff59a 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/GossipWireValidator.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/GossipWireValidator.java @@ -25,13 +25,13 @@ public class GossipWireValidator implements PubsubRouterMessageValidator { public static class InvalidGossipMessageException extends IllegalArgumentException { - public InvalidGossipMessageException(String s) { + public InvalidGossipMessageException(final String s) { super(s); } } @Override - public void validate(@NotNull PubsubMessage pubsubMessage) { + public void validate(final @NotNull PubsubMessage pubsubMessage) { Rpc.Message message = pubsubMessage.getProtobufMessage(); if (message.hasFrom()) { throw new InvalidGossipMessageException("The message has prohibited 'from' field: "); diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/LibP2PGossipNetwork.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/LibP2PGossipNetwork.java index 094f68cc0cc..b43e25feb0b 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/LibP2PGossipNetwork.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/LibP2PGossipNetwork.java @@ -54,10 +54,10 @@ public class LibP2PGossipNetwork implements GossipNetwork { private final GossipTopicHandlers topicHandlers; LibP2PGossipNetwork( - MetricsSystem metricsSystem, - Gossip gossip, - PubsubPublisherApi publisher, - GossipTopicHandlers topicHandlers) { + final MetricsSystem metricsSystem, + final Gossip gossip, + final PubsubPublisherApi publisher, + final GossipTopicHandlers topicHandlers) { this.metricsSystem = metricsSystem; this.gossip = gossip; this.publisher = publisher; diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/LibP2PGossipNetworkBuilder.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/LibP2PGossipNetworkBuilder.java index 9d17e1f3e36..38fab38a0c2 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/LibP2PGossipNetworkBuilder.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/LibP2PGossipNetworkBuilder.java @@ -122,7 +122,7 @@ protected GossipRouter createGossipRouter( builder.setParams(gossipParams); builder.setScoreParams(scoreParams); - builder.setProtocol(PubsubProtocol.Gossip_V_1_1); + builder.setProtocol(PubsubProtocol.Gossip_V_1_2); builder.setSubscriptionTopicSubscriptionFilter(subscriptionFilter); builder.setSeenCache(seenCache); builder.setMessageFactory( diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/LibP2PTopicChannel.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/LibP2PTopicChannel.java index a2f94b7072a..aebdbc68efa 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/LibP2PTopicChannel.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/LibP2PTopicChannel.java @@ -16,6 +16,7 @@ import io.libp2p.core.pubsub.PubsubSubscription; import java.util.concurrent.atomic.AtomicBoolean; import org.apache.tuweni.bytes.Bytes; +import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.networking.p2p.gossip.TopicChannel; public class LibP2PTopicChannel implements TopicChannel { @@ -30,11 +31,11 @@ public LibP2PTopicChannel( } @Override - public void gossip(final Bytes data) { + public SafeFuture gossip(final Bytes data) { if (closed.get()) { - return; + return SafeFuture.failedFuture(new IllegalStateException("Topic channel is closed")); } - topicHandler.gossip(data); + return topicHandler.gossip(data); } @Override diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/PreparedPubsubMessage.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/PreparedPubsubMessage.java index 745f25aabca..9ee21cd8adf 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/PreparedPubsubMessage.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/PreparedPubsubMessage.java @@ -38,7 +38,8 @@ public class PreparedPubsubMessage extends AbstractPubsubMessage { private final PreparedGossipMessage preparedMessage; private final Supplier cachedMessageId; - public PreparedPubsubMessage(Message protobufMessage, PreparedGossipMessage preparedMessage) { + public PreparedPubsubMessage( + final Message protobufMessage, final PreparedGossipMessage preparedMessage) { this.protobufMessage = protobufMessage; this.preparedMessage = preparedMessage; cachedMessageId = diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/rpc/LibP2PRpcStream.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/rpc/LibP2PRpcStream.java index 96cf43633de..4786058a984 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/rpc/LibP2PRpcStream.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/rpc/LibP2PRpcStream.java @@ -62,7 +62,7 @@ public SafeFuture closeWriteStream() { return toSafeFuture(ctx.channel().disconnect()); } - private SafeFuture toSafeFuture(ChannelFuture channelFuture) { + private SafeFuture toSafeFuture(final ChannelFuture channelFuture) { final SafeFuture future = new SafeFuture<>(); channelFuture.addListener( (f) -> { diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/rpc/RpcHandler.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/rpc/RpcHandler.java index a11e5092b47..9de93c7765b 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/rpc/RpcHandler.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/libp2p/rpc/RpcHandler.java @@ -64,7 +64,7 @@ public class RpcHandler< public RpcHandler( final AsyncRunner asyncRunner, - RpcMethod rpcMethod) { + final RpcMethod rpcMethod) { this.asyncRunner = asyncRunner; this.rpcMethod = rpcMethod; } @@ -74,7 +74,7 @@ public RpcMethod getRpcMethod() { } public SafeFuture> sendRequest( - Connection connection, TRequest request, TRespHandler responseHandler) { + final Connection connection, final TRequest request, final TRespHandler responseHandler) { final Bytes initialPayload; try { @@ -127,7 +127,7 @@ public SafeFuture> sendRequest( }); } - private void closeStreamAbruptly(Stream stream) { + private void closeStreamAbruptly(final Stream stream) { SafeFuture.of(stream.close()).ifExceptionGetsHereRaiseABug(); } @@ -171,7 +171,7 @@ private Controller(final NodeId nodeId, final P2PChannel p2pChannel) { } @Override - public void channelActive(ChannelHandlerContext ctx) { + public void channelActive(final ChannelHandlerContext ctx) { rpcStream = new LibP2PRpcStream(nodeId, p2pChannel, ctx); activeFuture.complete(this); } @@ -197,14 +197,14 @@ public void setOutgoingRequestHandler(final TOutgoingHandler requestHandler) { setFullyActive(requestHandler); } - private void setRequestHandler(RpcRequestHandler rpcRequestHandler) { + private void setRequestHandler(final RpcRequestHandler rpcRequestHandler) { if (this.rpcRequestHandler.isPresent()) { throw new IllegalStateException("Attempt to set an already set data handler"); } this.rpcRequestHandler = Optional.of(rpcRequestHandler); } - private void setFullyActive(RpcRequestHandler rpcRequestHandler) { + private void setFullyActive(final RpcRequestHandler rpcRequestHandler) { activeFuture.finish( () -> { rpcRequestHandler.active(nodeId, rpcStream); @@ -226,7 +226,7 @@ public Optional getOutgoingRequestHandler() { } @Override - public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { + public void exceptionCaught(final ChannelHandlerContext ctx, final Throwable cause) { LOG.error("Unhandled error while processes req/response", cause); final IllegalStateException exception = new IllegalStateException("Channel exception", cause); activeFuture.completeExceptionally(exception); @@ -234,12 +234,12 @@ public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { } @Override - public void handlerRemoved(ChannelHandlerContext ctx) { + public void handlerRemoved(final ChannelHandlerContext ctx) { onChannelClosed(); } @Override - public void userEventTriggered(ChannelHandlerContext ctx, Object evt) { + public void userEventTriggered(final ChannelHandlerContext ctx, final Object evt) { if (evt instanceof RemoteWriteClosed) { onRemoteWriteClosed(); } diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/mock/MockP2PNetwork.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/mock/MockP2PNetwork.java index 07df042a375..ba0348855d5 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/mock/MockP2PNetwork.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/mock/MockP2PNetwork.java @@ -16,6 +16,7 @@ import io.libp2p.core.PeerId; import java.util.Collection; import java.util.Collections; +import java.util.List; import java.util.Map; import java.util.Optional; import java.util.stream.Stream; @@ -38,7 +39,7 @@ public class MockP2PNetwork

    implements P2PNetwork

    { private final NodeId nodeId = new MockNodeId(); @Override - public SafeFuture connect(PeerAddress peer) { + public SafeFuture connect(final PeerAddress peer) { return SafeFuture.failedFuture(new UnsupportedOperationException()); } @@ -94,8 +95,8 @@ public int getPeerCount() { } @Override - public String getNodeAddress() { - return "/ip4/127.0.0.1/tcp/" + port + "/p2p/" + nodeId.toBase58(); + public List getNodeAddresses() { + return List.of("/ip4/127.0.0.1/tcp/" + port + "/p2p/" + nodeId.toBase58()); } @Override @@ -114,13 +115,13 @@ public Optional getDiscoveryNodeId() { } @Override - public Optional getDiscoveryAddress() { + public Optional> getDiscoveryAddresses() { return Optional.empty(); } @Override - public int getListenPort() { - return 0; + public List getListenPorts() { + return Collections.singletonList(0); } /** Stops the P2P network layer. */ diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/mock/MockTopicChannel.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/mock/MockTopicChannel.java index 225d3360dda..ef5ca70b146 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/mock/MockTopicChannel.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/mock/MockTopicChannel.java @@ -14,13 +14,14 @@ package tech.pegasys.teku.networking.p2p.mock; import org.apache.tuweni.bytes.Bytes; +import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.networking.p2p.gossip.TopicChannel; public class MockTopicChannel implements TopicChannel { @Override - public void gossip(final Bytes data) { - // Do nothing + public SafeFuture gossip(final Bytes data) { + return SafeFuture.COMPLETE; } @Override diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/network/DelegatingP2PNetwork.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/network/DelegatingP2PNetwork.java index e3308bcee69..cb121827b21 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/network/DelegatingP2PNetwork.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/network/DelegatingP2PNetwork.java @@ -14,6 +14,7 @@ package tech.pegasys.teku.networking.p2p.network; import java.util.Collection; +import java.util.List; import java.util.Map; import java.util.Optional; import org.apache.tuweni.bytes.Bytes; @@ -70,8 +71,8 @@ public int getPeerCount() { } @Override - public String getNodeAddress() { - return network.getNodeAddress(); + public List getNodeAddresses() { + return network.getNodeAddresses(); } @Override @@ -90,13 +91,13 @@ public Optional getDiscoveryNodeId() { } @Override - public Optional getDiscoveryAddress() { - return network.getDiscoveryAddress(); + public Optional> getDiscoveryAddresses() { + return network.getDiscoveryAddresses(); } @Override - public int getListenPort() { - return network.getListenPort(); + public List getListenPorts() { + return network.getListenPorts(); } @Override diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/network/P2PNetwork.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/network/P2PNetwork.java index d4bb530181b..76bc518fdd0 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/network/P2PNetwork.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/network/P2PNetwork.java @@ -13,6 +13,7 @@ package tech.pegasys.teku.networking.p2p.network; +import java.util.List; import java.util.Optional; import java.util.stream.Stream; import org.apache.tuweni.bytes.Bytes; @@ -82,11 +83,11 @@ enum State { int getPeerCount(); - String getNodeAddress(); + List getNodeAddresses(); NodeId getNodeId(); - int getListenPort(); + List getListenPorts(); /** * Get the Ethereum Node Record (ENR) for the local node, if one exists. @@ -97,7 +98,7 @@ enum State { Optional getDiscoveryNodeId(); - Optional getDiscoveryAddress(); + Optional> getDiscoveryAddresses(); Optional> getDiscoveryNetwork(); diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/network/config/FilePrivateKeySource.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/network/config/FilePrivateKeySource.java index 2cf0d05e7ad..33e3676b933 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/network/config/FilePrivateKeySource.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/network/config/FilePrivateKeySource.java @@ -29,7 +29,7 @@ public class FilePrivateKeySource implements PrivateKeySource { private final String fileName; - public FilePrivateKeySource(String fileName) { + public FilePrivateKeySource(final String fileName) { this.fileName = fileName; } @@ -79,7 +79,7 @@ public String getFileName() { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/network/config/NetworkConfig.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/network/config/NetworkConfig.java index 69816bc4210..90ff953252b 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/network/config/NetworkConfig.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/network/config/NetworkConfig.java @@ -14,20 +14,27 @@ package tech.pegasys.teku.networking.p2p.network.config; import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.base.Preconditions.checkState; import static com.google.common.net.InetAddresses.isInetAddress; import java.net.InetAddress; import java.net.NetworkInterface; import java.net.SocketException; import java.net.UnknownHostException; +import java.util.Collections; import java.util.Enumeration; import java.util.List; import java.util.Optional; import java.util.OptionalInt; +import java.util.Set; import java.util.function.Consumer; +import java.util.stream.Collectors; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; +import org.web3j.utils.Strings; import tech.pegasys.teku.infrastructure.exceptions.InvalidConfigurationException; +import tech.pegasys.teku.infrastructure.io.IPVersionResolver; +import tech.pegasys.teku.infrastructure.io.IPVersionResolver.IPVersion; import tech.pegasys.teku.infrastructure.io.PortAvailability; import tech.pegasys.teku.networking.p2p.gossip.config.GossipConfig; import tech.pegasys.teku.networking.p2p.gossip.config.GossipPeerScoringConfig.DirectPeerManager; @@ -37,8 +44,9 @@ public class NetworkConfig { private static final Logger LOG = LogManager.getLogger(); - public static final String DEFAULT_P2P_INTERFACE = "0.0.0.0"; + public static final List DEFAULT_P2P_INTERFACE = List.of("0.0.0.0"); public static final int DEFAULT_P2P_PORT = 9000; + public static final int DEFAULT_P2P_PORT_IPV6 = 9090; public static final boolean DEFAULT_YAMUX_ENABLED = false; private final GossipConfig gossipConfig; @@ -46,10 +54,12 @@ public class NetworkConfig { private final boolean isEnabled; private final Optional privateKeySource; - private final String networkInterface; - private final Optional advertisedIp; + private final List networkInterfaces; + private final Optional> advertisedIps; private final int listenPort; + private final int listenPortIpv6; private final OptionalInt advertisedPort; + private final OptionalInt advertisedPortIpv6; private final boolean yamuxEnabled; private NetworkConfig( @@ -57,25 +67,21 @@ private NetworkConfig( final GossipConfig gossipConfig, final WireLogsConfig wireLogsConfig, final Optional privateKeySource, - final String networkInterface, - final Optional advertisedIp, + final List networkInterfaces, + final Optional> advertisedIps, final int listenPort, + final int listenPortIpv6, final OptionalInt advertisedPort, + final OptionalInt advertisedPortIpv6, final boolean yamuxEnabled) { - this.privateKeySource = privateKeySource; - this.networkInterface = networkInterface; - - this.advertisedIp = advertisedIp.filter(ip -> !ip.isBlank()); + this.networkInterfaces = networkInterfaces; + this.advertisedIps = advertisedIps; this.isEnabled = isEnabled; - if (this.advertisedIp.map(ip -> !isInetAddress(ip)).orElse(false)) { - throw new InvalidConfigurationException( - String.format( - "Advertised ip (%s) is set incorrectly.", this.advertisedIp.orElse("EMPTY"))); - } - this.listenPort = listenPort; + this.listenPortIpv6 = listenPortIpv6; this.advertisedPort = advertisedPort; + this.advertisedPortIpv6 = advertisedPortIpv6; this.yamuxEnabled = yamuxEnabled; this.gossipConfig = gossipConfig; this.wireLogsConfig = wireLogsConfig; @@ -93,26 +99,36 @@ public Optional getPrivateKeySource() { return privateKeySource; } - public String getNetworkInterface() { - return networkInterface; + public List getNetworkInterfaces() { + return networkInterfaces; } - public String getAdvertisedIp() { - return resolveAnyLocalAddress(advertisedIp.orElse(networkInterface)); + public List getAdvertisedIps() { + return advertisedIps.orElse(networkInterfaces).stream() + .map(this::resolveAnyLocalAddress) + .toList(); } - public boolean hasUserExplicitlySetAdvertisedIp() { - return advertisedIp.isPresent(); + public boolean hasUserExplicitlySetAdvertisedIps() { + return advertisedIps.isPresent(); } public int getListenPort() { return listenPort; } + public int getListenPortIpv6() { + return listenPortIpv6; + } + public int getAdvertisedPort() { return advertisedPort.orElse(listenPort); } + public int getAdvertisedPortIpv6() { + return advertisedPortIpv6.orElse(listenPortIpv6); + } + public boolean isYamuxEnabled() { return yamuxEnabled; } @@ -130,40 +146,64 @@ private String resolveAnyLocalAddress(final String ipAddress) { try { final InetAddress advertisedAddress = InetAddress.getByName(ipAddress); if (advertisedAddress.isAnyLocalAddress()) { - return getSiteLocalAddress(); + final IPVersion ipVersion = IPVersionResolver.resolve(advertisedAddress); + return getLocalAddress(ipVersion); } else { return ipAddress; } - } catch (UnknownHostException err) { - LOG.error( - "Unable to start LibP2PNetwork due to failed attempt at obtaining host address", err); + } catch (final UnknownHostException ex) { + LOG.error("Failed resolving local address: {}. Trying to use {}", ex.getMessage(), ipAddress); return ipAddress; } } - private String getSiteLocalAddress() throws UnknownHostException { + private String getLocalAddress(final IPVersion ipVersion) throws UnknownHostException { try { - final InetAddress address = InetAddress.getLocalHost(); - if (address.isAnyLocalAddress()) { - return address.getHostAddress(); + final InetAddress localHostAddress = InetAddress.getLocalHost(); + if (localHostAddress.isAnyLocalAddress() + && IPVersionResolver.resolve(localHostAddress) == ipVersion) { + return localHostAddress.getHostAddress(); } final Enumeration networkInterfaces = NetworkInterface.getNetworkInterfaces(); while (networkInterfaces.hasMoreElements()) { - NetworkInterface n = networkInterfaces.nextElement(); - final Enumeration inetAddresses = n.getInetAddresses(); + final NetworkInterface networkInterface = networkInterfaces.nextElement(); + final Enumeration inetAddresses = networkInterface.getInetAddresses(); while (inetAddresses.hasMoreElements()) { - InetAddress i = inetAddresses.nextElement(); - if (i.isSiteLocalAddress()) { - return i.getHostAddress(); + final InetAddress inetAddress = inetAddresses.nextElement(); + if (IPVersionResolver.resolve(inetAddress) != ipVersion) { + // incompatible IP version + continue; + } + switch (ipVersion) { + case IP_V4 -> { + // IPv4 (include only site local addresses) + if (inetAddress.isSiteLocalAddress()) { + return inetAddress.getHostAddress(); + } + } + case IP_V6 -> { + // IPv6 (include site local or unique local addresses) + if (inetAddress.isSiteLocalAddress() || isUniqueLocalAddress(inetAddress)) { + return inetAddress.getHostAddress(); + } + } } } } - } catch (SocketException e) { - LOG.error("Failed to find site local address", e); - throw new UnknownHostException(e.getMessage()); + } catch (final SocketException ex) { + LOG.error("Failed to find local address", ex); + throw new UnknownHostException(ex.getMessage()); } - throw new UnknownHostException("Unable to determine local IP Address"); + throw new UnknownHostException( + String.format("Unable to determine local %s Address", ipVersion.getName())); + } + + private boolean isUniqueLocalAddress(final InetAddress inetAddress) { + // Check the first byte to determine if it's in the fc00::/7 range + // Unique local IPv6 addresses start with 0xfc or 0xfd + final int firstByte = inetAddress.getAddress()[0] & 0xff; // Convert to unsigned + return (firstByte == 0xfc || firstByte == 0xfd); } public static class Builder { @@ -174,10 +214,12 @@ public static class Builder { private Boolean isEnabled = true; private Optional privateKeyFile = Optional.empty(); private Optional privateKeySource = Optional.empty(); - private String networkInterface = DEFAULT_P2P_INTERFACE; - private Optional advertisedIp = Optional.empty(); + private List networkInterfaces = DEFAULT_P2P_INTERFACE; + private Optional> advertisedIps = Optional.empty(); private int listenPort = DEFAULT_P2P_PORT; + private int listenPortIpv6 = DEFAULT_P2P_PORT_IPV6; private OptionalInt advertisedPort = OptionalInt.empty(); + private OptionalInt advertisedPortIpv6 = OptionalInt.empty(); private boolean yamuxEnabled = DEFAULT_YAMUX_ENABLED; private Builder() {} @@ -188,10 +230,12 @@ public NetworkConfig build() { gossipConfigBuilder.build(), wireLogsConfig.build(), privateKeySource.or(this::createFileKeySource), - networkInterface, - advertisedIp, + networkInterfaces, + advertisedIps, listenPort, + listenPortIpv6, advertisedPort, + advertisedPortIpv6, yamuxEnabled); } @@ -221,45 +265,73 @@ public Builder privateKeyFile(final String privateKeyFile) { return this; } - public Builder setPrivateKeySource(PrivateKeySource privateKeySource) { + public Builder setPrivateKeySource(final PrivateKeySource privateKeySource) { checkNotNull(privateKeySource); this.privateKeySource = Optional.of(privateKeySource); return this; } public Builder networkInterface(final String networkInterface) { - checkNotNull(networkInterface); - this.networkInterface = networkInterface; + return networkInterfaces(Collections.singletonList(networkInterface)); + } + + public Builder networkInterfaces(final List networkInterfaces) { + checkNotNull(networkInterfaces); + validateAddresses(networkInterfaces, "--p2p-interface"); + this.networkInterfaces = networkInterfaces; return this; } public Builder advertisedIp(final Optional advertisedIp) { - checkNotNull(advertisedIp); - this.advertisedIp = advertisedIp; + return advertisedIps(advertisedIp.map(Collections::singletonList)); + } + + public Builder advertisedIps(final Optional> advertisedIps) { + checkNotNull(advertisedIps); + advertisedIps.ifPresent( + ips -> { + ips.forEach( + ip -> { + if (Strings.isBlank(ip)) { + throw new InvalidConfigurationException("Advertised ip is blank"); + } + if (!isInetAddress(ip)) { + throw new InvalidConfigurationException( + String.format("Advertised ip (%s) is set incorrectly", ip)); + } + }); + validateAddresses(ips, "--p2p-advertised-ip"); + }); + this.advertisedIps = advertisedIps; return this; } public Builder listenPort(final int listenPort) { - if (!PortAvailability.isPortValid(listenPort)) { - throw new InvalidConfigurationException( - String.format("Invalid listenPort: %d", listenPort)); - } + validatePort(listenPort, "--p2p-port"); this.listenPort = listenPort; return this; } + public Builder listenPortIpv6(final int listenPortIpv6) { + validatePort(listenPortIpv6, "--p2p-port-ipv6"); + this.listenPortIpv6 = listenPortIpv6; + return this; + } + public Builder advertisedPort(final OptionalInt advertisedPort) { checkNotNull(advertisedPort); - if (advertisedPort.isPresent()) { - if (!PortAvailability.isPortValid(advertisedPort.getAsInt())) { - throw new InvalidConfigurationException( - String.format("Invalid advertisedPort: %d", advertisedPort.getAsInt())); - } - } + advertisedPort.ifPresent(port -> validatePort(port, "--p2p-advertised-port")); this.advertisedPort = advertisedPort; return this; } + public Builder advertisedPortIpv6(final OptionalInt advertisedPortIpv6) { + checkNotNull(advertisedPortIpv6); + advertisedPortIpv6.ifPresent(port -> validatePort(port, "--p2p-advertised-port-ipv6")); + this.advertisedPortIpv6 = advertisedPortIpv6; + return this; + } + public Builder yamuxEnabled(final boolean yamuxEnabled) { this.yamuxEnabled = yamuxEnabled; return this; @@ -271,5 +343,29 @@ public Builder directPeers(final List directPeers) { this.gossipConfigBuilder.directPeerManager(directPeerManager); return this; } + + private void validateAddresses(final List addresses, final String cliOption) { + checkState( + addresses.size() == 1 || addresses.size() == 2, + "Invalid number of %s. It should be either 1 or 2, but it was %s", + cliOption, + addresses.size()); + if (addresses.size() == 2) { + final Set ipVersions = + addresses.stream().map(IPVersionResolver::resolve).collect(Collectors.toSet()); + if (ipVersions.size() != 2) { + throw new InvalidConfigurationException( + String.format( + "Expected an IPv4 and an IPv6 address for %s but only %s was set", + cliOption, ipVersions)); + } + } + } + + private void validatePort(final int port, final String cliOption) { + if (!PortAvailability.isPortValid(port)) { + throw new InvalidConfigurationException(String.format("Invalid %s: %d", cliOption, port)); + } + } } } diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/network/config/WireLogsConfig.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/network/config/WireLogsConfig.java index f06cbb72eb8..0654016a2d0 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/network/config/WireLogsConfig.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/network/config/WireLogsConfig.java @@ -22,10 +22,10 @@ public class WireLogsConfig { private final boolean logWireGossip; private WireLogsConfig( - boolean logWireCipher, - boolean logWirePlain, - boolean logWireMuxFrames, - boolean logWireGossip) { + final boolean logWireCipher, + final boolean logWirePlain, + final boolean logWireMuxFrames, + final boolean logWireGossip) { this.logWireCipher = logWireCipher; this.logWirePlain = logWirePlain; this.logWireMuxFrames = logWireMuxFrames; diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/peer/DelegatingPeer.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/peer/DelegatingPeer.java index 0046052c5e6..eaa62212d6f 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/peer/DelegatingPeer.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/peer/DelegatingPeer.java @@ -61,7 +61,7 @@ public void checkPeerIdentity() { TRequest, RespHandler extends RpcResponseHandler> SafeFuture> sendRequest( - RpcMethod rpcMethod, + final RpcMethod rpcMethod, final TRequest request, final RespHandler responseHandler) { return peer.sendRequest(rpcMethod, request, responseHandler); diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/peer/PeerDisconnectedException.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/peer/PeerDisconnectedException.java index 6cad0258dd1..e725ad2ef89 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/peer/PeerDisconnectedException.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/peer/PeerDisconnectedException.java @@ -17,7 +17,7 @@ public class PeerDisconnectedException extends RuntimeException { public PeerDisconnectedException() {} - public PeerDisconnectedException(Throwable cause) { + public PeerDisconnectedException(final Throwable cause) { super(cause); } } diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/rpc/RpcResponseHandler.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/rpc/RpcResponseHandler.java index dc65b48c0bd..a0b1b94c4e4 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/rpc/RpcResponseHandler.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/rpc/RpcResponseHandler.java @@ -24,7 +24,7 @@ default void onCompleted() { onCompleted(Optional.empty()); } - default void onCompleted(Throwable t) { + default void onCompleted(final Throwable t) { onCompleted(Optional.of(t)); } } diff --git a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/rpc/RpcResponseListener.java b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/rpc/RpcResponseListener.java index a8f21f03525..84ddbdefa27 100644 --- a/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/rpc/RpcResponseListener.java +++ b/networking/p2p/src/main/java/tech/pegasys/teku/networking/p2p/rpc/RpcResponseListener.java @@ -18,7 +18,7 @@ @FunctionalInterface public interface RpcResponseListener { - static RpcResponseListener from(Consumer listener) { + static RpcResponseListener from(final Consumer listener) { return (T response) -> SafeFuture.fromRunnable(() -> listener.accept(response)); } diff --git a/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/connection/ConnectionManagerTest.java b/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/connection/ConnectionManagerTest.java index 271103ea3c7..457acce8f92 100644 --- a/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/connection/ConnectionManagerTest.java +++ b/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/connection/ConnectionManagerTest.java @@ -431,17 +431,17 @@ public void shouldSwitchToLongDelayAfterFirstPeerIsFound() { advanceTimeByWarmupSearchInterval(); verify(discoveryService, times(3)).searchForPeers(); - timeProvider.advanceTimeBySeconds(ConnectionManager.DISCOVERY_INTERVAL.getSeconds()); + timeProvider.advanceTimeBySeconds(ConnectionManager.DISCOVERY_INTERVAL.toSeconds()); asyncRunner.executeDueActionsRepeatedly(); verify(discoveryService, times(4)).searchForPeers(); - timeProvider.advanceTimeBySeconds(ConnectionManager.DISCOVERY_INTERVAL.getSeconds()); + timeProvider.advanceTimeBySeconds(ConnectionManager.DISCOVERY_INTERVAL.toSeconds()); asyncRunner.executeDueActionsRepeatedly(); verify(discoveryService, times(5)).searchForPeers(); } private void advanceTimeByWarmupSearchInterval() { - timeProvider.advanceTimeBySeconds(ConnectionManager.WARMUP_DISCOVERY_INTERVAL.getSeconds()); + timeProvider.advanceTimeBySeconds(ConnectionManager.WARMUP_DISCOVERY_INTERVAL.toSeconds()); asyncRunner.executeDueActionsRepeatedly(); } diff --git a/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/discovery/DiscoveryNetworkTest.java b/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/discovery/DiscoveryNetworkTest.java index 292ffb6f98a..1f599ae7c28 100644 --- a/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/discovery/DiscoveryNetworkTest.java +++ b/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/discovery/DiscoveryNetworkTest.java @@ -282,7 +282,7 @@ public void setForkInfoAtInitialization() { @ParameterizedTest @MethodSource("provideNodeIds") - public void nodeIdMustBeWrappedInUint256(String nodeIdValue) { + public void nodeIdMustBeWrappedInUint256(final String nodeIdValue) { final Optional nodeId = Optional.of(Bytes.wrap(new BigInteger(nodeIdValue).toByteArray())); when(discoveryService.getNodeId()).thenReturn(nodeId); @@ -299,7 +299,7 @@ public void cscIsCorrectlyEncoded(final String hexString, final Integer csc) { .updateCustomENRField(DAS_CUSTODY_SUBNET_COUNT_ENR_FIELD, Bytes.fromHexString(hexString)); } - public DiscoveryPeer createDiscoveryPeer(Optional maybeForkId) { + public DiscoveryPeer createDiscoveryPeer(final Optional maybeForkId) { final SszBitvector syncCommitteeSubnets = schemaDefinitions.getSyncnetsENRFieldSchema().getDefault(); return new DiscoveryPeer( diff --git a/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/discovery/discv5/NodeRecordConverterTest.java b/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/discovery/discv5/NodeRecordConverterTest.java index 2777feffab1..04b7061fa37 100644 --- a/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/discovery/discv5/NodeRecordConverterTest.java +++ b/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/discovery/discv5/NodeRecordConverterTest.java @@ -31,7 +31,6 @@ import org.ethereum.beacon.discovery.schema.IdentitySchema; import org.ethereum.beacon.discovery.schema.NodeRecord; import org.ethereum.beacon.discovery.schema.NodeRecordFactory; -import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; @@ -83,20 +82,20 @@ public void shouldConvertRealEnrToDiscoveryPeer() throws Exception { ATTNETS, SYNCNETS, Optional.empty()); - assertThat(CONVERTER.convertToDiscoveryPeer(nodeRecord, SCHEMA_DEFINITIONS)) + assertThat(CONVERTER.convertToDiscoveryPeer(nodeRecord, false, SCHEMA_DEFINITIONS)) .contains(expectedPeer); } @Test public void shouldNotConvertRecordWithNoIp() { - assertThat(convertNodeRecordWithFields()).isEmpty(); + assertThat(convertNodeRecordWithFields(false)).isEmpty(); } @Test public void shouldNotConvertRecordWithIpButNoPort() { assertThat( convertNodeRecordWithFields( - new EnrField(EnrField.IP_V4, Bytes.wrap(new byte[] {127, 0, 0, 1})))) + false, new EnrField(EnrField.IP_V4, Bytes.wrap(new byte[] {127, 0, 0, 1})))) .isEmpty(); } @@ -104,17 +103,19 @@ public void shouldNotConvertRecordWithIpButNoPort() { public void shouldNotConvertRecordWithIpAndUdpPortButNoTcpPort() { assertThat( convertNodeRecordWithFields( + false, new EnrField(EnrField.IP_V4, Bytes.wrap(new byte[] {127, 0, 0, 1})), new EnrField(EnrField.UDP, 30303))) .isEmpty(); } @Test - @Disabled("Needs IPv6 update from master") public void shouldUseV4PortIfV6PortSpecifiedWithNoV6Ip() { assertThat( convertNodeRecordWithFields( - new EnrField(EnrField.IP_V6, IPV6_LOCALHOST), new EnrField(EnrField.TCP, 30303))) + true, + new EnrField(EnrField.IP_V6, IPV6_LOCALHOST), + new EnrField(EnrField.TCP, 30303))) .contains( new DiscoveryPeer( PUB_KEY, @@ -130,13 +131,15 @@ public void shouldUseV4PortIfV6PortSpecifiedWithNoV6Ip() { public void shouldNotConvertRecordWithV4IpAndV6Port() { assertThat( convertNodeRecordWithFields( - new EnrField(EnrField.IP_V4, IPV6_LOCALHOST), new EnrField(EnrField.TCP_V6, 30303))) + false, + new EnrField(EnrField.IP_V4, IPV6_LOCALHOST), + new EnrField(EnrField.TCP_V6, 30303))) .isEmpty(); } @Test public void shouldNotConvertRecordWithPortButNoIp() { - assertThat(convertNodeRecordWithFields(new EnrField(EnrField.TCP, 30303))).isEmpty(); + assertThat(convertNodeRecordWithFields(false, new EnrField(EnrField.TCP, 30303))).isEmpty(); } @Test @@ -144,6 +147,7 @@ public void shouldConvertIpV4Record() { // IP address bytes are unsigned. Make sure we handle that correctly. final Optional result = convertNodeRecordWithFields( + true, new EnrField(EnrField.IP_V4, Bytes.wrap(new byte[] {-127, 24, 31, 22})), new EnrField(EnrField.TCP, 1234)); assertThat(result) @@ -159,11 +163,22 @@ public void shouldConvertIpV4Record() { } @Test - @Disabled("Needs IPv6 update from master") + public void shouldNotConvertIpV6RecordIfIpV6IsNotSupported() { + assertThat( + convertNodeRecordWithFields( + false, + new EnrField(EnrField.IP_V6, IPV6_LOCALHOST), + new EnrField(EnrField.TCP_V6, 1234))) + .isEmpty(); + } + + @Test public void shouldConvertIpV6Record() { final Optional result = convertNodeRecordWithFields( - new EnrField(EnrField.IP_V6, IPV6_LOCALHOST), new EnrField(EnrField.TCP_V6, 1234)); + true, + new EnrField(EnrField.IP_V6, IPV6_LOCALHOST), + new EnrField(EnrField.TCP_V6, 1234)); assertThat(result) .contains( new DiscoveryPeer( @@ -177,12 +192,33 @@ public void shouldConvertIpV6Record() { } @Test - @Disabled("Needs IPv6 update from master") + public void shouldConvertDualStackRecordIfIpV6IsNotSupported() { + final Optional result = + convertNodeRecordWithFields( + false, + new EnrField(EnrField.IP_V4, Bytes.wrap(new byte[] {127, 0, 0, 1})), + new EnrField(EnrField.TCP, 1234), + new EnrField(EnrField.IP_V6, IPV6_LOCALHOST), + new EnrField(EnrField.TCP_V6, 1235)); + assertThat(result) + .contains( + new DiscoveryPeer( + PUB_KEY, + NODE_ID, + new InetSocketAddress("127.0.0.1", 1234), + ENR_FORK_ID, + ATTNETS, + SYNCNETS, + Optional.empty())); + } + + @Test public void shouldConvertAttnets() { SszBitvector persistentSubnets = ATT_SUBNET_SCHEMA.ofBits(1, 8, 14, 32); Bytes encodedPersistentSubnets = persistentSubnets.sszSerialize(); final Optional result = convertNodeRecordWithFields( + true, new EnrField(EnrField.IP_V6, IPV6_LOCALHOST), new EnrField(EnrField.TCP_V6, 1234), new EnrField(ATTESTATION_SUBNET_ENR_FIELD, encodedPersistentSubnets)); @@ -199,12 +235,12 @@ public void shouldConvertAttnets() { } @Test - @Disabled("Needs IPv6 update from master") public void shouldUseEmptyAttnetsWhenFieldValueIsInvalid() { SszBitvector persistentSubnets = SszBitvectorSchema.create(4).ofBits(1, 2); // Incorrect length Bytes encodedPersistentSubnets = persistentSubnets.sszSerialize(); final Optional result = convertNodeRecordWithFields( + true, new EnrField(EnrField.IP_V6, IPV6_LOCALHOST), new EnrField(EnrField.TCP_V6, 1234), new EnrField(ATTESTATION_SUBNET_ENR_FIELD, encodedPersistentSubnets)); @@ -221,12 +257,12 @@ public void shouldUseEmptyAttnetsWhenFieldValueIsInvalid() { } @Test - @Disabled("Needs IPv6 update from master") public void shouldConvertSyncnets() { SszBitvector syncnets = SYNCNETS_SCHEMA.ofBits(1, 3); Bytes encodedSyncnets = syncnets.sszSerialize(); final Optional result = convertNodeRecordWithFields( + true, new EnrField(EnrField.IP_V6, IPV6_LOCALHOST), new EnrField(EnrField.TCP_V6, 1234), new EnrField(SYNC_COMMITTEE_SUBNET_ENR_FIELD, encodedSyncnets)); @@ -243,7 +279,6 @@ public void shouldConvertSyncnets() { } @Test - @Disabled("Needs IPv6 update from master") public void shouldUseEmptySyncnetsFieldValueIsInvalid() { SszBitvector syncnets = SszBitvectorSchema.create(SYNCNETS_SCHEMA.getLength() * 2L) @@ -251,6 +286,7 @@ public void shouldUseEmptySyncnetsFieldValueIsInvalid() { Bytes encodedSyncnets = syncnets.sszSerialize(); final Optional result = convertNodeRecordWithFields( + true, new EnrField(EnrField.IP_V6, IPV6_LOCALHOST), new EnrField(EnrField.TCP_V6, 1234), new EnrField(SYNC_COMMITTEE_SUBNET_ENR_FIELD, encodedSyncnets)); @@ -267,12 +303,12 @@ public void shouldUseEmptySyncnetsFieldValueIsInvalid() { } @Test - @Disabled("Needs IPv6 update from master") public void shouldConvertEnrForkId() { EnrForkId enrForkId = new DataStructureUtil(SPEC).randomEnrForkId(); Bytes encodedForkId = enrForkId.sszSerialize(); final Optional result = convertNodeRecordWithFields( + true, new EnrField(EnrField.IP_V6, IPV6_LOCALHOST), new EnrField(EnrField.TCP_V6, 1234), new EnrField(ETH2_ENR_FIELD, encodedForkId)); @@ -289,11 +325,11 @@ public void shouldConvertEnrForkId() { } @Test - @Disabled("Needs IPv6 update from master") public void shouldNotHaveEnrForkIdWhenValueIsInvalid() { Bytes encodedForkId = Bytes.fromHexString("0x1234"); final Optional result = convertNodeRecordWithFields( + true, new EnrField(EnrField.IP_V6, IPV6_LOCALHOST), new EnrField(EnrField.TCP_V6, 1234), new EnrField(ETH2_ENR_FIELD, encodedForkId)); @@ -314,22 +350,25 @@ public void shouldNotHaveEnrForkIdWhenValueIsInvalid() { public void shouldDecodeCscCorrectly(final String hexString, final Integer csc) { assertThat( convertNodeRecordWithFields( - new EnrField(EnrField.IP_V4, Bytes.wrap(new byte[] {-127, 24, 31, 22})), + false, + new EnrField(EnrField.IP_V4, Bytes.wrap(new byte[] {127, 0, 0, 1})), new EnrField(EnrField.TCP, 1234), new EnrField(DAS_CUSTODY_SUBNET_COUNT_ENR_FIELD, Bytes.fromHexString(hexString)))) .contains( new DiscoveryPeer( PUB_KEY, NODE_ID, - new InetSocketAddress("129.24.31.22", 1234), + new InetSocketAddress("127.0.0.1", 1234), Optional.empty(), ATTNETS, SYNCNETS, Optional.of(csc))); } - private Optional convertNodeRecordWithFields(final EnrField... fields) { - return CONVERTER.convertToDiscoveryPeer(createNodeRecord(fields), SCHEMA_DEFINITIONS); + private Optional convertNodeRecordWithFields( + final boolean supportsIpv6, final EnrField... fields) { + return CONVERTER.convertToDiscoveryPeer( + createNodeRecord(fields), supportsIpv6, SCHEMA_DEFINITIONS); } private NodeRecord createNodeRecord(final EnrField... fields) { diff --git a/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/libp2p/FirewallTest.java b/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/libp2p/FirewallTest.java index c48c83c2f3b..a01f1611a50 100644 --- a/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/libp2p/FirewallTest.java +++ b/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/libp2p/FirewallTest.java @@ -32,7 +32,7 @@ void testFirewallNotPropagateTimeoutExceptionUpstream() throws Exception { firewall, new ChannelInboundHandlerAdapter() { @Override - public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) + public void exceptionCaught(final ChannelHandlerContext ctx, final Throwable cause) throws Exception { super.exceptionCaught(ctx, cause); } @@ -43,7 +43,7 @@ public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) Assertions.assertThat(channel.isOpen()).isFalse(); } - private void executeAllScheduledTasks(EmbeddedChannel channel, long maxWaitSeconds) + private void executeAllScheduledTasks(final EmbeddedChannel channel, final long maxWaitSeconds) throws TimeoutException, InterruptedException { long waitTime = 0; while (waitTime < maxWaitSeconds * 1000) { diff --git a/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/libp2p/MuxFirewallTest.java b/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/libp2p/MuxFirewallTest.java index 691d43b99f1..a83de82ef7b 100644 --- a/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/libp2p/MuxFirewallTest.java +++ b/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/libp2p/MuxFirewallTest.java @@ -64,7 +64,7 @@ void init() { .addLast( new ChannelInboundHandlerAdapter() { @Override - public void channelRead(ChannelHandlerContext ctx, Object msg) { + public void channelRead(final ChannelHandlerContext ctx, final Object msg) { passedMessages.add(msg.toString()); } }); @@ -75,7 +75,7 @@ private enum MuxType { YAMUX } - private void writeOneInbound(Object message) { + private void writeOneInbound(final Object message) { try { boolean res = channel.writeOneInbound(message).await(1000L); assertThat(res).isTrue(); @@ -242,26 +242,29 @@ void testThatDisconnectsOnLocalClose(final MuxType muxType) throws InterruptedEx private Object createNewStreamFrame(final MuxType muxType, final long id) { return switch (muxType) { case MPLEX -> new MplexFrame(createMplexId(id), MplexFlag.NewStream, Unpooled.EMPTY_BUFFER); - case YAMUX -> new YamuxFrame( - createYamuxId(id), YamuxType.DATA, Set.of(YamuxFlag.ACK), 0, Unpooled.EMPTY_BUFFER); + case YAMUX -> + new YamuxFrame( + createYamuxId(id), YamuxType.DATA, Set.of(YamuxFlag.ACK), 0, Unpooled.EMPTY_BUFFER); }; } private Object createCloseInitiatorFrame(final MuxType muxType, final long id) { return switch (muxType) { - case MPLEX -> new MplexFrame( - createMplexId(id), MplexFlag.CloseInitiator, Unpooled.EMPTY_BUFFER); - case YAMUX -> new YamuxFrame( - createYamuxId(id), YamuxType.DATA, Set.of(YamuxFlag.FIN), 0, Unpooled.EMPTY_BUFFER); + case MPLEX -> + new MplexFrame(createMplexId(id), MplexFlag.CloseInitiator, Unpooled.EMPTY_BUFFER); + case YAMUX -> + new YamuxFrame( + createYamuxId(id), YamuxType.DATA, Set.of(YamuxFlag.FIN), 0, Unpooled.EMPTY_BUFFER); }; } private Object createCloseReceiverFrame(final MuxType muxType, final long id) { return switch (muxType) { - case MPLEX -> new MplexFrame( - createMplexId(id), MplexFlag.CloseReceiver, Unpooled.EMPTY_BUFFER); - case YAMUX -> new YamuxFrame( - createYamuxId(id), YamuxType.DATA, Set.of(YamuxFlag.FIN), 0, Unpooled.EMPTY_BUFFER); + case MPLEX -> + new MplexFrame(createMplexId(id), MplexFlag.CloseReceiver, Unpooled.EMPTY_BUFFER); + case YAMUX -> + new YamuxFrame( + createYamuxId(id), YamuxType.DATA, Set.of(YamuxFlag.FIN), 0, Unpooled.EMPTY_BUFFER); }; } @@ -269,30 +272,33 @@ private Object createDataFrame(final MuxType muxType, final long id) { final ByteBuf slicedByteBuf = data1K.slice(); return switch (muxType) { case MPLEX -> new MplexFrame(createMplexId(id), MplexFlag.MessageReceiver, slicedByteBuf); - case YAMUX -> new YamuxFrame( - createYamuxId(id), - YamuxType.DATA, - Set.of(), - slicedByteBuf.readableBytes(), - slicedByteBuf); + case YAMUX -> + new YamuxFrame( + createYamuxId(id), + YamuxType.DATA, + Set.of(), + slicedByteBuf.readableBytes(), + slicedByteBuf); }; } private Object createResetInitiatorFrame(final MuxType muxType, final long id) { return switch (muxType) { - case MPLEX -> new MplexFrame( - createMplexId(id), MplexFlag.ResetInitiator, Unpooled.EMPTY_BUFFER); - case YAMUX -> new YamuxFrame( - createYamuxId(id), YamuxType.DATA, Set.of(YamuxFlag.RST), 0, Unpooled.EMPTY_BUFFER); + case MPLEX -> + new MplexFrame(createMplexId(id), MplexFlag.ResetInitiator, Unpooled.EMPTY_BUFFER); + case YAMUX -> + new YamuxFrame( + createYamuxId(id), YamuxType.DATA, Set.of(YamuxFlag.RST), 0, Unpooled.EMPTY_BUFFER); }; } private Object createResetReceiverFrame(final MuxType muxType, final long id) { return switch (muxType) { - case MPLEX -> new MplexFrame( - createMplexId(id), MplexFlag.ResetReceiver, Unpooled.EMPTY_BUFFER); - case YAMUX -> new YamuxFrame( - createYamuxId(id), YamuxType.DATA, Set.of(YamuxFlag.RST), 0, Unpooled.EMPTY_BUFFER); + case MPLEX -> + new MplexFrame(createMplexId(id), MplexFlag.ResetReceiver, Unpooled.EMPTY_BUFFER); + case YAMUX -> + new YamuxFrame( + createYamuxId(id), YamuxType.DATA, Set.of(YamuxFlag.RST), 0, Unpooled.EMPTY_BUFFER); }; } diff --git a/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/GossipHandlerTest.java b/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/GossipHandlerTest.java index 0124a31fe27..0731285a23b 100644 --- a/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/GossipHandlerTest.java +++ b/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/libp2p/gossip/GossipHandlerTest.java @@ -20,12 +20,14 @@ import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import static tech.pegasys.teku.infrastructure.async.SafeFutureAssert.assertThatSafeFuture; import io.libp2p.core.pubsub.PubsubPublisherApi; import io.libp2p.core.pubsub.Topic; import io.libp2p.core.pubsub.ValidationResult; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; +import kotlin.Unit; import org.apache.tuweni.bytes.Bytes; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -96,15 +98,15 @@ public void apply_bufferCapacityExceedsMaxSize() { @Test public void gossip_newMessage() { final Bytes message = Bytes.fromHexString("0x01"); - gossipHandler.gossip(message); + assertThatSafeFuture(gossipHandler.gossip(message)).isCompleted(); verify(publisher).publish(toByteBuf(message), topic); } @Test public void gossip_duplicateMessage() { // Deduplication is done a libp2p level. final Bytes message = Bytes.fromHexString("0x01"); - gossipHandler.gossip(message); - gossipHandler.gossip(message); + assertThatSafeFuture(gossipHandler.gossip(message)).isCompleted(); + assertThatSafeFuture(gossipHandler.gossip(message)).isCompleted(); verify(publisher, times(2)).publish(toByteBuf(message), topic); } @@ -112,12 +114,44 @@ public void gossip_duplicateMessage() { // Deduplication is done a libp2p level. public void gossip_distinctMessages() { final Bytes message1 = Bytes.fromHexString("0x01"); final Bytes message2 = Bytes.fromHexString("0x02"); - gossipHandler.gossip(message1); - gossipHandler.gossip(message2); + assertThatSafeFuture(gossipHandler.gossip(message1)).isCompleted(); + assertThatSafeFuture(gossipHandler.gossip(message2)).isCompleted(); verify(publisher).publish(toByteBuf(message1), topic); verify(publisher).publish(toByteBuf(message2), topic); } + @Test + public void gossip_forwardsGossipFailures() { + final Bytes message = Bytes.fromHexString("0x01"); + final SafeFuture result = new SafeFuture<>(); + when(publisher.publish(any(), any())).thenReturn(result); + final SafeFuture gossipResult = gossipHandler.gossip(message); + + verify(publisher).publish(toByteBuf(message), topic); + assertThat(gossipResult).isNotCompleted(); + + result.completeExceptionally(new RuntimeException("Failed to gossip")); + assertThatSafeFuture(gossipResult) + .isCompletedExceptionallyWith(RuntimeException.class) + .hasMessage("Failed to gossip"); + } + + @Test + public void + gossip_returnFutureCompletingOnSuccessfulPublishing() { // Deduplication is done a libp2p + // level. + final Bytes message = Bytes.fromHexString("0x01"); + final SafeFuture result = new SafeFuture<>(); + when(publisher.publish(any(), any())).thenReturn(result); + final SafeFuture gossipResult = gossipHandler.gossip(message); + + verify(publisher).publish(toByteBuf(message), topic); + assertThat(gossipResult).isNotCompleted(); + + result.complete(Unit.INSTANCE); + assertThat(gossipResult).isCompleted(); + } + private ByteBuf toByteBuf(final Bytes bytes) { return Unpooled.wrappedBuffer(bytes.toArrayUnsafe()); } diff --git a/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/network/config/FilePrivateKeySourceTest.java b/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/network/config/FilePrivateKeySourceTest.java index 1fc1775cf26..99094ea2eae 100644 --- a/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/network/config/FilePrivateKeySourceTest.java +++ b/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/network/config/FilePrivateKeySourceTest.java @@ -27,7 +27,7 @@ class FilePrivateKeySourceTest { @Test - void shouldCreateKeyAndSaveToFile(@TempDir Path tempDir) throws IOException { + void shouldCreateKeyAndSaveToFile(@TempDir final Path tempDir) throws IOException { final Path file = tempDir.resolve("file.txt"); final PrivateKeySource privateKeySource = new FilePrivateKeySource(file.toString()); final Bytes generatedBytes = privateKeySource.getOrGeneratePrivateKeyBytes(); @@ -37,7 +37,7 @@ void shouldCreateKeyAndSaveToFile(@TempDir Path tempDir) throws IOException { } @Test - void shouldGetKeyFromSavedTextFile(@TempDir Path tempDir) throws IOException { + void shouldGetKeyFromSavedTextFile(@TempDir final Path tempDir) throws IOException { final Path file = tempDir.resolve("file.txt"); final Bytes privateKey = Bytes.wrap(PrivateKeyGenerator.generate().bytes()); Files.writeString(file, privateKey.toHexString()); @@ -47,7 +47,7 @@ void shouldGetKeyFromSavedTextFile(@TempDir Path tempDir) throws IOException { } @Test - void shouldGetKeyFromBinaryFile(@TempDir Path tempDir) throws IOException { + void shouldGetKeyFromBinaryFile(@TempDir final Path tempDir) throws IOException { final Path file = tempDir.resolve("file.dat"); final Bytes privateKey = Bytes.wrap(PrivateKeyGenerator.generate().bytes()); Files.write(file, privateKey.toArray()); @@ -57,7 +57,7 @@ void shouldGetKeyFromBinaryFile(@TempDir Path tempDir) throws IOException { } @Test - void shouldThrowExceptionIfInvalidFileName(@TempDir Path tempDir) { + void shouldThrowExceptionIfInvalidFileName(@TempDir final Path tempDir) { final PrivateKeySource privateKeySource = new FilePrivateKeySource(tempDir + "/invalid file name!!\0"); assertThatThrownBy(privateKeySource::getOrGeneratePrivateKeyBytes) @@ -66,7 +66,7 @@ void shouldThrowExceptionIfInvalidFileName(@TempDir Path tempDir) { } @Test - void shouldThrowExceptionIfProvideDirectory(@TempDir Path tempDir) { + void shouldThrowExceptionIfProvideDirectory(@TempDir final Path tempDir) { final PrivateKeySource privateKeySource = new FilePrivateKeySource(tempDir.toString()); assertThatThrownBy(privateKeySource::getOrGeneratePrivateKeyBytes) .isInstanceOf(RuntimeException.class) diff --git a/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/network/config/NetworkConfigTest.java b/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/network/config/NetworkConfigTest.java index 2b0678d738a..a7606949d20 100644 --- a/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/network/config/NetworkConfigTest.java +++ b/networking/p2p/src/test/java/tech/pegasys/teku/networking/p2p/network/config/NetworkConfigTest.java @@ -14,11 +14,15 @@ package tech.pegasys.teku.networking.p2p.network.config; import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; import io.libp2p.core.multiformats.Multiaddr; +import java.net.Inet6Address; +import java.net.InetAddress; import java.util.List; import java.util.Optional; import org.junit.jupiter.api.Test; +import tech.pegasys.teku.infrastructure.exceptions.InvalidConfigurationException; import tech.pegasys.teku.networking.p2p.gossip.config.GossipPeerScoringConfig.DirectPeerManager; import tech.pegasys.teku.networking.p2p.libp2p.LibP2PNodeId; import tech.pegasys.teku.networking.p2p.peer.NodeId; @@ -30,36 +34,44 @@ class NetworkConfigTest { private String listenIp = "0.0.0.0"; @Test - void getAdvertisedIp_shouldUseAdvertisedAddressWhenSet() { + void getAdvertisedIps_shouldUseAdvertisedAddressWhenSet() { final String expected = "1.2.3.4"; advertisedIp = Optional.of(expected); - assertThat(createConfig().getAdvertisedIp()).isEqualTo(expected); + assertThat(createConfig().getAdvertisedIps()).containsExactly(expected); } @Test - void getAdvertisedIp_shouldResolveAnyLocalAdvertisedAddress() { + void getAdvertisedIps_shouldResolveAnyLocalAdvertisedAddress() { advertisedIp = Optional.of("0.0.0.0"); - assertThat(createConfig().getAdvertisedIp()).isNotEqualTo("0.0.0.0"); + assertThat(createConfig().getAdvertisedIps()).hasSize(1).doesNotContain("0.0.0.0"); } @Test - void getAdvertisedIp_shouldReturnInterfaceIpWhenNotSet() { + void getAdvertisedIps_shouldReturnInterfaceIpWhenNotSet() { listenIp = "127.0.0.1"; - assertThat(createConfig().getAdvertisedIp()).isEqualTo(listenIp); + assertThat(createConfig().getAdvertisedIps()).containsExactly(listenIp); } @Test - void getAdvertisedIp_shouldResolveLocalhostIpWhenInterfaceIpIsAnyLocal() { + void getAdvertisedIps_shouldResolveLocalhostIpWhenInterfaceIpIsAnyLocal() { listenIp = "0.0.0.0"; - assertThat(createConfig().getAdvertisedIp()).isNotEqualTo("0.0.0.0"); + assertThat(createConfig().getAdvertisedIps()).hasSize(1).doesNotContain("0.0.0.0"); } @Test - void getAdvertisedIp_shouldResolveLocalhostIpWhenInterfaceIpIsAnyLocalIpv6() { + void getAdvertisedIps_shouldResolveLocalhostIpWhenInterfaceIpIsAnyLocalIpv6() { listenIp = "::0"; - final String result = createConfig().getAdvertisedIp(); - assertThat(result).isNotEqualTo("::0"); - assertThat(result).isNotEqualTo("0.0.0.0"); + final List result = createConfig().getAdvertisedIps(); + assertThat(result) + .hasSize(1) + .first() + .asString() + .isNotBlank() + .satisfies( + ip -> { + // check the advertised IP is IPv6 + assertThat(InetAddress.getByName(ip)).isInstanceOf(Inet6Address.class); + }); } @Test @@ -105,7 +117,55 @@ void checkDirectPeersConfigCreatedCorrectly() { final DirectPeerManager manager = optionalDirectPeerManager.get(); - assert manager.isDirectPeer(peerId1); - assert !manager.isDirectPeer(peerId2); + assertThat(manager.isDirectPeer(peerId1)).isTrue(); + assertThat(manager.isDirectPeer(peerId2)).isFalse(); + } + + @Test + void checkSetBothIPv4andIPv6() { + final NetworkConfig config = + NetworkConfig.builder() + .networkInterfaces(List.of("192.0.2.146", "2a01:4b00:875c:9500:d55c:71df:3af7:9f1f")) + .advertisedIps( + Optional.of(List.of("1.2.3.4", "2001:db8:3333:4444:5555:6666:7777:8888"))) + .build(); + + assertThat(config.getNetworkInterfaces()) + .containsExactly("192.0.2.146", "2a01:4b00:875c:9500:d55c:71df:3af7:9f1f"); + assertThat(config.getAdvertisedIps()) + .containsExactly("1.2.3.4", "2001:db8:3333:4444:5555:6666:7777:8888"); + } + + @Test + void failsIfInvalidNumberOfNetworkInterfacesAreSet() { + assertThatThrownBy( + () -> + NetworkConfig.builder() + .networkInterfaces(List.of("0.0.0.0", "::", "1.2.3.4")) + .build()) + .isInstanceOf(IllegalStateException.class) + .hasMessage("Invalid number of --p2p-interface. It should be either 1 or 2, but it was 3"); + } + + @Test + void failsIfTwoIPv4NetworkInterfacesAreSet() { + assertThatThrownBy( + () -> NetworkConfig.builder().networkInterfaces(List.of("0.0.0.0", "1.2.3.4")).build()) + .isInstanceOf(InvalidConfigurationException.class) + .hasMessage( + "Expected an IPv4 and an IPv6 address for --p2p-interface but only [IP_V4] was set"); + } + + @Test + void failsIfTwoIPv6AdvertisedIpsAreSet() { + assertThatThrownBy( + () -> + NetworkConfig.builder() + .advertisedIps( + Optional.of(List.of("::", "2001:db8:3333:4444:5555:6666:7777:8888"))) + .build()) + .isInstanceOf(InvalidConfigurationException.class) + .hasMessage( + "Expected an IPv4 and an IPv6 address for --p2p-advertised-ip but only [IP_V6] was set"); } } diff --git a/networking/p2p/src/testFixtures/java/tech/pegasys/teku/network/p2p/DiscoveryNetworkFactory.java b/networking/p2p/src/testFixtures/java/tech/pegasys/teku/network/p2p/DiscoveryNetworkFactory.java index 5fef5f9be3a..4ba182a5375 100644 --- a/networking/p2p/src/testFixtures/java/tech/pegasys/teku/network/p2p/DiscoveryNetworkFactory.java +++ b/networking/p2p/src/testFixtures/java/tech/pegasys/teku/network/p2p/DiscoveryNetworkFactory.java @@ -68,7 +68,7 @@ public class DiscoveryTestNetworkBuilder { private final List staticPeers = new ArrayList<>(); private final List bootnodes = new ArrayList<>(); - private Spec spec = TestSpecFactory.createMinimalPhase0(); + private final Spec spec = TestSpecFactory.createMinimalPhase0(); private DiscoveryTestNetworkBuilder() {} diff --git a/scripts/fetch-blocks.sh b/scripts/fetch-blocks.sh index e7b59670c73..e3f9eb74f83 100755 --- a/scripts/fetch-blocks.sh +++ b/scripts/fetch-blocks.sh @@ -11,7 +11,7 @@ OUT="$(cd "${OUT}" &>/dev/null && pwd)" FIRST_BLOCK=$(($START + 1)) echo "Starting state download" -curl --fail -H 'Accept: application/octet-stream' http://localhost:$PORT/eth/v2/debug/beacon/states/{$START} -o "${OUT}/state.ssz" & +curl --fail -H 'Accept: application/octet-stream' http://localhost:$PORT/eth/v2/debug/beacon/states/${START} -o "${OUT}/state.ssz" & BLOCK_ARGS="" for i in $(seq -f "%0.f" ${FIRST_BLOCK} ${END}) diff --git a/services/beaconchain/src/main/java/tech/pegasys/teku/services/beaconchain/BeaconChainController.java b/services/beaconchain/src/main/java/tech/pegasys/teku/services/beaconchain/BeaconChainController.java index 5a46535647d..64673906b95 100644 --- a/services/beaconchain/src/main/java/tech/pegasys/teku/services/beaconchain/BeaconChainController.java +++ b/services/beaconchain/src/main/java/tech/pegasys/teku/services/beaconchain/BeaconChainController.java @@ -34,6 +34,7 @@ import java.util.Optional; import java.util.function.Function; import java.util.function.IntSupplier; +import java.util.stream.Collectors; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.apache.tuweni.bytes.Bytes; @@ -95,11 +96,13 @@ import tech.pegasys.teku.networks.StateBoostrapConfig; import tech.pegasys.teku.service.serviceutils.Service; import tech.pegasys.teku.service.serviceutils.ServiceConfig; +import tech.pegasys.teku.service.serviceutils.layout.DataDirLayout; import tech.pegasys.teku.services.executionlayer.ExecutionLayerBlockManagerFactory; import tech.pegasys.teku.services.timer.TimerService; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecFeature; import tech.pegasys.teku.spec.SpecMilestone; -import tech.pegasys.teku.spec.config.SpecConfigEip7594; +import tech.pegasys.teku.spec.config.features.Eip7594; import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation; import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; @@ -114,14 +117,14 @@ import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; import tech.pegasys.teku.spec.datastructures.state.AnchorPoint; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; -import tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel; import tech.pegasys.teku.spec.executionlayer.ExecutionLayerBlockProductionManager; import tech.pegasys.teku.spec.executionlayer.ExecutionLayerChannel; import tech.pegasys.teku.spec.logic.common.statetransition.availability.AvailabilityCheckerFactory; import tech.pegasys.teku.spec.logic.common.statetransition.results.BlockImportResult; import tech.pegasys.teku.spec.logic.common.util.BlockRewardCalculatorUtil; import tech.pegasys.teku.spec.logic.versions.deneb.helpers.MiscHelpersDeneb; -import tech.pegasys.teku.spec.logic.versions.eip7594.helpers.MiscHelpersEip7594; +import tech.pegasys.teku.spec.logic.versions.feature.eip7594.helpers.MiscHelpersEip7594; +import tech.pegasys.teku.spec.networks.Eth2Network; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsEip7594; import tech.pegasys.teku.statetransition.EpochCachePrimer; import tech.pegasys.teku.statetransition.LocalOperationAcceptedFilter; @@ -188,6 +191,8 @@ import tech.pegasys.teku.statetransition.synccommittee.SyncCommitteeMessageValidator; import tech.pegasys.teku.statetransition.synccommittee.SyncCommitteeStateUtils; import tech.pegasys.teku.statetransition.util.BlockBlobSidecarsTrackersPoolImpl; +import tech.pegasys.teku.statetransition.util.DebugDataDumper; +import tech.pegasys.teku.statetransition.util.DebugDataFileDumper; import tech.pegasys.teku.statetransition.util.FutureItems; import tech.pegasys.teku.statetransition.util.PendingPool; import tech.pegasys.teku.statetransition.util.PoolFactory; @@ -237,7 +242,7 @@ import tech.pegasys.teku.validator.coordinator.Eth1DataProvider; import tech.pegasys.teku.validator.coordinator.Eth1VotingPeriod; import tech.pegasys.teku.validator.coordinator.GraffitiBuilder; -import tech.pegasys.teku.validator.coordinator.MilestoneBasedBlockFactory; +import tech.pegasys.teku.validator.coordinator.MilestoneWithFeaturesBlockFactory; import tech.pegasys.teku.validator.coordinator.ValidatorApiHandler; import tech.pegasys.teku.validator.coordinator.ValidatorIndexCacheTracker; import tech.pegasys.teku.validator.coordinator.performance.DefaultPerformanceTracker; @@ -245,6 +250,7 @@ import tech.pegasys.teku.validator.coordinator.performance.PerformanceTracker; import tech.pegasys.teku.validator.coordinator.performance.SyncCommitteePerformanceTracker; import tech.pegasys.teku.validator.coordinator.performance.ValidatorPerformanceMetrics; +import tech.pegasys.teku.validator.coordinator.publisher.MilestoneBasedBlockPublisher; import tech.pegasys.teku.weaksubjectivity.WeakSubjectivityCalculator; import tech.pegasys.teku.weaksubjectivity.WeakSubjectivityValidator; @@ -258,6 +264,7 @@ public class BeaconChainController extends Service implements BeaconChainControllerFacade { private static final Logger LOG = LogManager.getLogger(); + private final EphemerySlotValidationService ephemerySlotValidationService; protected static final String KEY_VALUE_STORE_SUBDIRECTORY = "kvstore"; @@ -317,6 +324,7 @@ public class BeaconChainController extends Service implements BeaconChainControl protected volatile DasReqRespLogger dasReqRespLogger; protected volatile KZG kzg; protected volatile BlobSidecarManager blobSidecarManager; + protected volatile BlobSidecarGossipValidator blobSidecarValidator; protected volatile DataColumnSidecarManager dataColumnSidecarManager; protected volatile LateInitDataColumnSidecarCustody dataColumnSidecarCustody = new LateInitDataColumnSidecarCustody(); @@ -338,17 +346,19 @@ public class BeaconChainController extends Service implements BeaconChainControl protected PoolFactory poolFactory; protected SettableLabelledGauge futureItemsMetric; protected IntSupplier rejectedExecutionCountSupplier; + protected DebugDataDumper debugDataDumper; protected volatile UInt256 nodeId; protected volatile BlobSidecarReconstructionProvider blobSidecarReconstructionProvider; public BeaconChainController( final ServiceConfig serviceConfig, final BeaconChainConfiguration beaconConfig) { final Eth2NetworkConfiguration eth2NetworkConfig = beaconConfig.eth2NetworkConfig(); + final DataDirLayout dataDirLayout = serviceConfig.getDataDirLayout(); this.beaconConfig = beaconConfig; this.spec = beaconConfig.getSpec(); this.beaconBlockSchemaSupplier = slot -> spec.atSlot(slot).getSchemaDefinitions().getBeaconBlockBodySchema(); - this.beaconDataDirectory = serviceConfig.getDataDirLayout().getBeaconDataDirectory(); + this.beaconDataDirectory = dataDirLayout.getBeaconDataDirectory(); this.asyncRunnerFactory = serviceConfig.getAsyncRunnerFactory(); this.beaconAsyncRunner = serviceConfig.createAsyncRunner( @@ -371,6 +381,10 @@ public BeaconChainController( this.receivedBlockEventsChannelPublisher = eventChannels.getPublisher(ReceivedBlockEventsChannel.class); this.forkChoiceExecutor = new AsyncRunnerEventThread("forkchoice", asyncRunnerFactory); + this.debugDataDumper = + dataDirLayout.isDebugDataDumpingEnabled() + ? new DebugDataFileDumper(dataDirLayout.getDebugDataDirectory()) + : DebugDataDumper.NOOP; this.futureItemsMetric = SettableLabelledGauge.create( metricsSystem, @@ -380,6 +394,7 @@ public BeaconChainController( "type"); this.dasGossipLogger = new DasGossipBatchLogger(operationPoolAsyncRunner, timeProvider); this.dasReqRespLogger = DasReqRespLogger.create(timeProvider); + this.ephemerySlotValidationService = new EphemerySlotValidationService(); } @Override @@ -397,8 +412,7 @@ protected void startServices() { recentBlocksFetcher.subscribeBlockFetched( (block) -> blockManager - .importBlock( - block, BroadcastValidationLevel.NOT_REQUIRED, Optional.of(RemoteOrigin.RPC)) + .importBlock(block, RemoteOrigin.RPC) .thenCompose(BlockImportAndBroadcastValidationResults::blockImportResult) .finish(err -> LOG.error("Failed to process recently fetched block.", err))); eventChannels.subscribe(ReceivedBlockEventsChannel.class, recentBlocksFetcher); @@ -410,6 +424,12 @@ protected void startServices() { blobSidecar -> recentBlobSidecarsFetcher.cancelRecentBlobSidecarRequest( new BlobIdentifier(blobSidecar.getBlockRoot(), blobSidecar.getIndex()))); + + final Optional network = beaconConfig.eth2NetworkConfig().getEth2Network(); + if (network.isPresent() && network.get() == Eth2Network.EPHEMERY) { + LOG.debug("BeaconChainController: subscribing to slot events"); + eventChannels.subscribe(SlotEventsChannel.class, ephemerySlotValidationService); + } SafeFuture.allOfFailFast( attestationManager.start(), p2pNetwork.start(), @@ -423,7 +443,11 @@ protected void startServices() { Throwable rootCause = Throwables.getRootCause(error); if (rootCause instanceof BindException) { final String errorWhilePerformingDescription = - "starting P2P services on port " + this.p2pNetwork.getListenPort() + "."; + "starting P2P services on port(s) " + + p2pNetwork.getListenPorts().stream() + .map(Object::toString) + .collect(Collectors.joining(",")) + + "."; STATUS_LOG.fatalError(errorWhilePerformingDescription, rootCause); System.exit(FATAL_EXIT_CODE); } else { @@ -444,6 +468,7 @@ protected SafeFuture doStop() { attestationManager.stop(), p2pNetwork.stop(), timerService.stop(), + ephemerySlotValidationService.doStop(), SafeFuture.fromRunnable( () -> terminalPowBlockMonitor.ifPresent(TerminalPowBlockMonitor::stop))) .thenRun(forkChoiceExecutor::stop); @@ -619,7 +644,7 @@ protected void initBlobSidecarManager() { LimitedMap.createSynchronizedLRU(500); final MiscHelpersDeneb miscHelpers = MiscHelpersDeneb.required(spec.forMilestone(SpecMilestone.DENEB).miscHelpers()); - final BlobSidecarGossipValidator blobSidecarValidator = + blobSidecarValidator = BlobSidecarGossipValidator.create( spec, invalidBlockRoots, gossipValidationHelper, miscHelpers, kzg); final BlobSidecarManagerImpl blobSidecarManagerImpl = @@ -641,7 +666,7 @@ protected void initBlobSidecarManager() { } private void initDasSamplerManager() { - if (spec.isMilestoneSupported(SpecMilestone.EIP7594)) { + if (spec.isFeatureScheduled(SpecFeature.EIP7594)) { LOG.info("Activated DAS Sampler Manager for EIP7594"); this.dasSamplerManager = new DasSamplerManager(() -> dataAvailabilitySampler, kzg, spec); } else { @@ -651,13 +676,13 @@ private void initDasSamplerManager() { } protected void initDataColumnSidecarManager() { - if (spec.isMilestoneSupported(SpecMilestone.EIP7594)) { + if (spec.isFeatureScheduled(SpecFeature.EIP7594)) { final DataColumnSidecarGossipValidator dataColumnSidecarGossipValidator = DataColumnSidecarGossipValidator.create( spec, invalidBlockRoots, gossipValidationHelper, - MiscHelpersEip7594.required(spec.forMilestone(SpecMilestone.EIP7594).miscHelpers()), + MiscHelpersEip7594.required(spec.forMilestone(SpecMilestone.ELECTRA).miscHelpers()), kzg, metricsSystem); dataColumnSidecarManager = @@ -672,14 +697,14 @@ protected void initDataColumnSidecarManager() { } protected void initDasCustody() { - if (!spec.isMilestoneSupported(SpecMilestone.EIP7594)) { + if (!spec.isFeatureScheduled(SpecFeature.EIP7594)) { return; } - SpecConfigEip7594 configEip7594 = - SpecConfigEip7594.required(spec.forMilestone(SpecMilestone.EIP7594).getConfig()); + LOG.info("Activating DAS Custody for EIP7594"); + Eip7594 configEip7594 = Eip7594.required(spec.forMilestone(SpecMilestone.ELECTRA).getConfig()); MinCustodyPeriodSlotCalculator minCustodyPeriodSlotCalculator = MinCustodyPeriodSlotCalculator.createFromSpec(spec); - int slotsPerEpoch = configEip7594.getSlotsPerEpoch(); + int slotsPerEpoch = spec.getGenesisSpec().getSlotsPerEpoch(); final DataColumnSidecarDbAccessor dbAccessor; { @@ -707,7 +732,7 @@ protected void initDasCustody() { int totalMyCustodySubnets = beaconConfig .p2pConfig() - .getTotalCustodySubnetCount(spec.forMilestone(SpecMilestone.EIP7594)); + .getTotalCustodySubnetCount(spec.forMilestone(SpecMilestone.ELECTRA)); final UpdatableDataColumnSidecarCustody custody; { @@ -771,10 +796,10 @@ protected void initDasCustody() { operationPoolAsyncRunner, Duration.ofSeconds(1)); MiscHelpersEip7594 miscHelpersEip7594 = - MiscHelpersEip7594.required(spec.forMilestone(SpecMilestone.EIP7594).miscHelpers()); + MiscHelpersEip7594.required(spec.forMilestone(SpecMilestone.ELECTRA).miscHelpers()); SchemaDefinitionsEip7594 schemaDefinitionsEip7594 = SchemaDefinitionsEip7594.required( - spec.forMilestone(SpecMilestone.EIP7594).getSchemaDefinitions()); + spec.forMilestone(SpecMilestone.ELECTRA).getSchemaDefinitions()); RecoveringSidecarRetriever recoveringSidecarRetriever = new RecoveringSidecarRetriever( sidecarRetriever, @@ -841,9 +866,18 @@ protected void initBlockBlobSidecarsTrackersPool() { if (spec.isMilestoneSupported(SpecMilestone.DENEB)) { final BlockImportChannel blockImportChannel = eventChannels.getPublisher(BlockImportChannel.class, beaconAsyncRunner); + final BlobSidecarGossipChannel blobSidecarGossipChannel = + eventChannels.getPublisher(BlobSidecarGossipChannel.class, beaconAsyncRunner); final BlockBlobSidecarsTrackersPoolImpl pool = poolFactory.createPoolForBlockBlobSidecarsTrackers( - blockImportChannel, spec, timeProvider, beaconAsyncRunner, recentChainData); + blockImportChannel, + spec, + timeProvider, + beaconAsyncRunner, + recentChainData, + executionLayer, + () -> blobSidecarValidator, + blobSidecarGossipChannel::publishBlobSidecar); eventChannels.subscribe(FinalizedCheckpointChannel.class, pool); blockBlobSidecarsTrackersPool = pool; @@ -995,7 +1029,7 @@ protected void initDataProvider() { .build(); } - private boolean getLivenessTrackingEnabled(BeaconChainConfiguration beaconConfig) { + private boolean getLivenessTrackingEnabled(final BeaconChainConfiguration beaconConfig) { return beaconConfig.beaconRestApiConfig().isBeaconLivenessTrackingEnabled() || beaconConfig.validatorConfig().isDoppelgangerDetectionEnabled(); } @@ -1036,6 +1070,7 @@ protected void initForkChoice() { new TickProcessor(spec, recentChainData), new MergeTransitionBlockValidator(spec, recentChainData, executionLayer), beaconConfig.eth2NetworkConfig().isForkChoiceLateBlockReorgEnabled(), + debugDataDumper, metricsSystem); forkChoiceTrigger = new ForkChoiceTrigger(forkChoice); } @@ -1058,6 +1093,11 @@ public void initMetrics() { .subscribe(ChainHeadChannel.class, syncCommitteeMetrics); } + protected void initEth1DataCache() { + LOG.debug("BeaconChainController.initEth1DataCache"); + eth1DataCache = new Eth1DataCache(spec, metricsSystem, new Eth1VotingPeriod(spec)); + } + public void initDepositProvider() { LOG.debug("BeaconChainController.initDepositProvider()"); depositProvider = @@ -1076,11 +1116,6 @@ public void initDepositProvider() { .subscribe(SlotEventsChannel.class, depositProvider); } - protected void initEth1DataCache() { - LOG.debug("BeaconChainController.initEth1DataCache"); - eth1DataCache = new Eth1DataCache(metricsSystem, new Eth1VotingPeriod(spec)); - } - protected void initAttestationTopicSubscriber() { LOG.debug("BeaconChainController.initAttestationTopicSubscriber"); final SettableLabelledGauge subnetSubscriptionsGauge = @@ -1119,7 +1154,7 @@ protected void initSubnetSubscriber() { } protected void initDataColumnSidecarSubnetBackboneSubscriber() { - if (!spec.isMilestoneSupported(SpecMilestone.EIP7594)) { + if (!spec.isFeatureScheduled(SpecFeature.EIP7594)) { return; } LOG.debug("BeaconChainController.initDataColumnSidecarSubnetBackboneSubscriber"); @@ -1130,7 +1165,7 @@ protected void initDataColumnSidecarSubnetBackboneSubscriber() { nodeId, beaconConfig .p2pConfig() - .getTotalCustodySubnetCount(spec.forMilestone(SpecMilestone.EIP7594))); + .getTotalCustodySubnetCount(spec.forMilestone(SpecMilestone.ELECTRA))); eventChannels.subscribe(SlotEventsChannel.class, subnetBackboneSubscriber); } @@ -1149,15 +1184,13 @@ public void initRewardCalculator() { public void initValidatorApiHandler() { LOG.debug("BeaconChainController.initValidatorApiHandler()"); final GraffitiBuilder graffitiBuilder = - new GraffitiBuilder( - beaconConfig.validatorConfig().getClientGraffitiAppendFormat(), - beaconConfig.validatorConfig().getGraffitiProvider().get()); + new GraffitiBuilder(beaconConfig.validatorConfig().getClientGraffitiAppendFormat()); + eventChannels.subscribe(ExecutionClientVersionChannel.class, graffitiBuilder); final ExecutionClientVersionProvider executionClientVersionProvider = new ExecutionClientVersionProvider( executionLayer, eventChannels.getPublisher(ExecutionClientVersionChannel.class), graffitiBuilder.getConsensusClientVersion()); - eventChannels.subscribe(ExecutionClientVersionChannel.class, graffitiBuilder); final BlockOperationSelectorFactory operationSelector = new BlockOperationSelectorFactory( spec, @@ -1172,7 +1205,8 @@ public void initValidatorApiHandler() { graffitiBuilder, forkChoiceNotifier, executionLayerBlockProductionManager); - final BlockFactory blockFactory = new MilestoneBasedBlockFactory(spec, operationSelector, kzg); + final BlockFactory blockFactory = + new MilestoneWithFeaturesBlockFactory(spec, operationSelector, kzg); SyncCommitteeSubscriptionManager syncCommitteeSubscriptionManager = beaconConfig.p2pConfig().isSubscribeAllSubnetsEnabled() ? new AllSyncCommitteeSubscriptions(p2pNetwork, spec) @@ -1180,15 +1214,16 @@ public void initValidatorApiHandler() { final BlockImportChannel blockImportChannel = eventChannels.getPublisher(BlockImportChannel.class, beaconAsyncRunner); final BlockGossipChannel blockGossipChannel = - eventChannels.getPublisher(BlockGossipChannel.class); + eventChannels.getPublisher(BlockGossipChannel.class, beaconAsyncRunner); final BlobSidecarGossipChannel blobSidecarGossipChannel; if (spec.isMilestoneSupported(SpecMilestone.DENEB)) { - blobSidecarGossipChannel = eventChannels.getPublisher(BlobSidecarGossipChannel.class); + blobSidecarGossipChannel = + eventChannels.getPublisher(BlobSidecarGossipChannel.class, beaconAsyncRunner); } else { blobSidecarGossipChannel = BlobSidecarGossipChannel.NOOP; } final DataColumnSidecarGossipChannel dataColumnSidecarGossipChannel; - if (spec.isMilestoneSupported(SpecMilestone.EIP7594)) { + if (spec.isFeatureScheduled(SpecFeature.EIP7594)) { dataColumnSidecarGossipChannel = eventChannels.getPublisher(DataColumnSidecarGossipChannel.class); } else { @@ -1200,8 +1235,26 @@ public void initValidatorApiHandler() { timeProvider, (slot) -> secondsToMillis(recentChainData.computeTimeAtSlot(slot)), beaconConfig.getMetricsConfig().isBlockProductionAndPublishingPerformanceEnabled(), - beaconConfig.getMetricsConfig().getBlockProductionPerformanceWarningThreshold(), - beaconConfig.getMetricsConfig().getBlockPublishingPerformanceWarningThreshold()); + beaconConfig.getMetricsConfig().getBlockProductionPerformanceWarningLocalThreshold(), + beaconConfig.getMetricsConfig().getBlockProductionPerformanceWarningBuilderThreshold(), + beaconConfig.getMetricsConfig().getBlockPublishingPerformanceWarningLocalThreshold(), + beaconConfig.getMetricsConfig().getBlockPublishingPerformanceWarningBuilderThreshold()); + + final DutyMetrics dutyMetrics = + DutyMetrics.create(metricsSystem, timeProvider, recentChainData, spec); + + final MilestoneBasedBlockPublisher blockPublisher = + new MilestoneBasedBlockPublisher( + beaconAsyncRunner, + spec, + blockFactory, + blockImportChannel, + blockGossipChannel, + blockBlobSidecarsTrackersPool, + blobSidecarGossipChannel, + dataColumnSidecarGossipChannel, + dutyMetrics, + beaconConfig.p2pConfig().isGossipBlobsAfterBlockEnabled()); final ValidatorApiHandler validatorApiHandler = new ValidatorApiHandler( @@ -1212,19 +1265,15 @@ public void initValidatorApiHandler() { rewardCalculator, blobSidecarReconstructionProvider), dataProvider.getNodeDataProvider(), + dataProvider.getNetworkDataProvider(), combinedChainDataClient, syncService, blockFactory, - blockImportChannel, - blockGossipChannel, - blockBlobSidecarsTrackersPool, - blobSidecarGossipChannel, - dataColumnSidecarGossipChannel, attestationPool, attestationManager, attestationTopicSubscriber, activeValidatorTracker, - DutyMetrics.create(metricsSystem, timeProvider, recentChainData, spec), + dutyMetrics, performanceTracker, spec, forkChoiceTrigger, @@ -1232,7 +1281,8 @@ public void initValidatorApiHandler() { syncCommitteeMessagePool, syncCommitteeContributionPool, syncCommitteeSubscriptionManager, - blockProductionPerformanceFactory); + blockProductionPerformanceFactory, + blockPublisher); eventChannels .subscribe(SlotEventsChannel.class, activeValidatorTracker) .subscribe(ExecutionClientEventsChannel.class, executionClientVersionProvider) @@ -1386,6 +1436,7 @@ protected void initP2PNetwork() { .specProvider(spec) .kzg(kzg) .recordMessageArrival(true) + .p2pDebugDataDumper(debugDataDumper) .build(); syncCommitteeMessagePool.subscribeOperationAdded( @@ -1401,7 +1452,7 @@ protected void initP2PNetwork() { blsToExecutionChangePool.subscribeOperationAdded( new LocalOperationAcceptedFilter<>(p2pNetwork::publishSignedBlsToExecutionChange)); - nodeId = + this.nodeId = p2pNetwork .getDiscoveryNodeId() .orElseThrow(() -> new InvalidConfigurationException("NodeID is required")); @@ -1427,7 +1478,8 @@ protected void initSlotProcessor() { public void initAttestationPool() { LOG.debug("BeaconChainController.initAttestationPool()"); attestationPool = - new AggregatingAttestationPool(spec, metricsSystem, DEFAULT_MAXIMUM_ATTESTATION_COUNT); + new AggregatingAttestationPool( + spec, recentChainData, metricsSystem, DEFAULT_MAXIMUM_ATTESTATION_COUNT); eventChannels.subscribe(SlotEventsChannel.class, attestationPool); blockImporter.subscribeToVerifiedBlockAttestations( attestationPool::onAttestationsIncludedInBlock); @@ -1469,6 +1521,7 @@ public void initBlockImporter() { LOG.debug("BeaconChainController.initBlockImporter()"); blockImporter = new BlockImporter( + beaconAsyncRunner, spec, receivedBlockEventsChannelPublisher, recentChainData, diff --git a/services/beaconchain/src/main/java/tech/pegasys/teku/services/beaconchain/BeaconChainMetrics.java b/services/beaconchain/src/main/java/tech/pegasys/teku/services/beaconchain/BeaconChainMetrics.java index 82f69fc4afb..843b74c5e68 100644 --- a/services/beaconchain/src/main/java/tech/pegasys/teku/services/beaconchain/BeaconChainMetrics.java +++ b/services/beaconchain/src/main/java/tech/pegasys/teku/services/beaconchain/BeaconChainMetrics.java @@ -197,7 +197,7 @@ public BeaconChainMetrics( final LabelledMetric versionCounter = metricsSystem.createLabelledCounter( TekuMetricCategory.BEACON, - VersionProvider.CLIENT_IDENTITY + "_version", + VersionProvider.CLIENT_IDENTITY + "_version_total", "Teku version in use", "version"); versionCounter.labels(version).inc(); @@ -281,7 +281,7 @@ private Bytes32 getCorrectTargetRoot( : spec.getBlockRootAtSlot(stateAndBlock.getState(), epochStartSlot); } - static long getLongFromRoot(Bytes32 root) { + static long getLongFromRoot(final Bytes32 root) { return root.getLong(24, ByteOrder.LITTLE_ENDIAN); } diff --git a/services/beaconchain/src/main/java/tech/pegasys/teku/services/beaconchain/EphemeryLifecycleException.java b/services/beaconchain/src/main/java/tech/pegasys/teku/services/beaconchain/EphemeryLifecycleException.java new file mode 100644 index 00000000000..66fc67919f3 --- /dev/null +++ b/services/beaconchain/src/main/java/tech/pegasys/teku/services/beaconchain/EphemeryLifecycleException.java @@ -0,0 +1,20 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.services.beaconchain; + +public class EphemeryLifecycleException extends RuntimeException { + public EphemeryLifecycleException(final String format) { + super(format); + } +} diff --git a/services/beaconchain/src/main/java/tech/pegasys/teku/services/beaconchain/EphemerySlotValidationService.java b/services/beaconchain/src/main/java/tech/pegasys/teku/services/beaconchain/EphemerySlotValidationService.java new file mode 100644 index 00000000000..e2113cfe62b --- /dev/null +++ b/services/beaconchain/src/main/java/tech/pegasys/teku/services/beaconchain/EphemerySlotValidationService.java @@ -0,0 +1,44 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.services.beaconchain; + +import static tech.pegasys.teku.networks.EphemeryNetwork.MAX_EPHEMERY_SLOT; + +import tech.pegasys.teku.ethereum.events.SlotEventsChannel; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.service.serviceutils.Service; + +public class EphemerySlotValidationService extends Service implements SlotEventsChannel { + + @Override + public void onSlot(final UInt64 slot) { + if (slot.isGreaterThan(MAX_EPHEMERY_SLOT)) { + throw new EphemeryLifecycleException( + String.format( + "Slot %s exceeds maximum allowed slot %s for ephemery network", + slot, MAX_EPHEMERY_SLOT)); + } + } + + @Override + protected SafeFuture doStart() { + return SafeFuture.COMPLETE; + } + + @Override + protected SafeFuture doStop() { + return SafeFuture.COMPLETE; + } +} diff --git a/services/beaconchain/src/main/java/tech/pegasys/teku/services/beaconchain/ValidatorIsConnectedProviderImpl.java b/services/beaconchain/src/main/java/tech/pegasys/teku/services/beaconchain/ValidatorIsConnectedProviderImpl.java index 3dfe174e6f8..c13630c1cbc 100644 --- a/services/beaconchain/src/main/java/tech/pegasys/teku/services/beaconchain/ValidatorIsConnectedProviderImpl.java +++ b/services/beaconchain/src/main/java/tech/pegasys/teku/services/beaconchain/ValidatorIsConnectedProviderImpl.java @@ -21,12 +21,12 @@ public class ValidatorIsConnectedProviderImpl implements ValidatorIsConnectedProvider { private final Supplier forkChoiceNotifier; - public ValidatorIsConnectedProviderImpl(Supplier forkChoiceNotifier) { + public ValidatorIsConnectedProviderImpl(final Supplier forkChoiceNotifier) { this.forkChoiceNotifier = forkChoiceNotifier; } @Override - public boolean isValidatorConnected(int validatorId, UInt64 slot) { + public boolean isValidatorConnected(final int validatorId, final UInt64 slot) { return forkChoiceNotifier.get().validatorIsConnected(UInt64.valueOf(validatorId), slot); } } diff --git a/services/beaconchain/src/main/java/tech/pegasys/teku/services/beaconchain/WeakSubjectivityInitializer.java b/services/beaconchain/src/main/java/tech/pegasys/teku/services/beaconchain/WeakSubjectivityInitializer.java index e1d0c9d35a7..9520ca17711 100644 --- a/services/beaconchain/src/main/java/tech/pegasys/teku/services/beaconchain/WeakSubjectivityInitializer.java +++ b/services/beaconchain/src/main/java/tech/pegasys/teku/services/beaconchain/WeakSubjectivityInitializer.java @@ -82,7 +82,8 @@ public Optional loadInitialAnchorPoint( } @NotNull - private AnchorPoint getAnchorPoint(Spec spec, String stateResource, String sanitizedResource) + private AnchorPoint getAnchorPoint( + final Spec spec, final String stateResource, final String sanitizedResource) throws IOException { STATUS_LOG.loadingInitialStateResource(sanitizedResource); final BeaconState state = ChainDataLoader.loadState(spec, stateResource); @@ -102,8 +103,8 @@ private AnchorPoint getAnchorPoint(Spec spec, String stateResource, String sanit public SafeFuture finalizeAndStoreConfig( final WeakSubjectivityConfig config, - StorageQueryChannel storageQueryChannel, - StorageUpdateChannel storageUpdateChannel) { + final StorageQueryChannel storageQueryChannel, + final StorageUpdateChannel storageUpdateChannel) { return storageQueryChannel .getWeakSubjectivityState() .thenCompose( diff --git a/services/beaconchain/src/test/java/tech/pegasys/teku/services/beaconchain/BeaconChainMetricsTest.java b/services/beaconchain/src/test/java/tech/pegasys/teku/services/beaconchain/BeaconChainMetricsTest.java index 156d887dd5c..f5c9c65a105 100644 --- a/services/beaconchain/src/test/java/tech/pegasys/teku/services/beaconchain/BeaconChainMetricsTest.java +++ b/services/beaconchain/src/test/java/tech/pegasys/teku/services/beaconchain/BeaconChainMetricsTest.java @@ -111,7 +111,7 @@ private void updateState( chainHead = dataStructureUtil.randomSignedBlockAndState(updatedState); } - private void setBlockRoots(List newBlockRoots) { + private void setBlockRoots(final List newBlockRoots) { updateState(s -> s.getBlockRoots().setAllElements(newBlockRoots)); } diff --git a/services/beaconchain/src/test/java/tech/pegasys/teku/services/beaconchain/EphemerySlotValidationServiceTest.java b/services/beaconchain/src/test/java/tech/pegasys/teku/services/beaconchain/EphemerySlotValidationServiceTest.java new file mode 100644 index 00000000000..beec1565876 --- /dev/null +++ b/services/beaconchain/src/test/java/tech/pegasys/teku/services/beaconchain/EphemerySlotValidationServiceTest.java @@ -0,0 +1,63 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.services.beaconchain; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static tech.pegasys.teku.networks.EphemeryNetwork.MAX_EPHEMERY_SLOT; + +import java.util.Optional; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.networks.Eth2Network; + +class EphemerySlotValidationServiceTest { + private EphemerySlotValidationService ephemerySlotValidationService; + + @BeforeEach + void setUp() { + ephemerySlotValidationService = new EphemerySlotValidationService(); + } + + @Test + public void onSlot_shouldNotThrow_whenSlotIsValid() { + ephemerySlotValidationService.onSlot(UInt64.valueOf(MAX_EPHEMERY_SLOT)); + } + + @Test + public void onSlot_shouldThrowException_whenSlotExceedsMaxEphemerySlot_forEphemeryNetwork() { + final Eth2Network network = Eth2Network.EPHEMERY; + final Optional ephemeryNetwork = Optional.of(network); + final UInt64 invalidSlot = UInt64.valueOf(MAX_EPHEMERY_SLOT + 1); + + assertThat(ephemeryNetwork).contains(Eth2Network.EPHEMERY); + assertThatThrownBy(() -> ephemerySlotValidationService.onSlot(invalidSlot)) + .isInstanceOf(EphemeryLifecycleException.class) + .hasMessageContaining( + String.format( + "Slot %s exceeds maximum allowed slot %s for ephemery network", + invalidSlot, MAX_EPHEMERY_SLOT)); + } + + @Test + void shouldCompleteWhenServiceStartsAndStops() { + final SafeFuture startFuture = ephemerySlotValidationService.doStart(); + assertTrue(startFuture.isDone()); + final SafeFuture stopFuture = ephemerySlotValidationService.doStop(); + assertTrue(stopFuture.isDone()); + } +} diff --git a/services/beaconchain/src/test/java/tech/pegasys/teku/services/beaconchain/SlotProcessorTest.java b/services/beaconchain/src/test/java/tech/pegasys/teku/services/beaconchain/SlotProcessorTest.java index 1bdd3fa95a9..ea3c2fdeb9b 100644 --- a/services/beaconchain/src/test/java/tech/pegasys/teku/services/beaconchain/SlotProcessorTest.java +++ b/services/beaconchain/src/test/java/tech/pegasys/teku/services/beaconchain/SlotProcessorTest.java @@ -79,7 +79,7 @@ public class SlotProcessorTest { private final UInt64 genesisTimeMillis = secondsToMillis(genesisTime); private final UInt64 desiredSlot = UInt64.valueOf(100L); - private SlotProcessor createSlotProcessor(Spec spec) { + private SlotProcessor createSlotProcessor(final Spec spec) { return new SlotProcessor( spec, recentChainData, @@ -261,7 +261,7 @@ public void onTick_shouldSkipForward() { @EnumSource( value = Eth2Network.class, names = {"MAINNET", "MINIMAL", "GNOSIS"}) - public void onTick_shouldRunAttestationsDuringProcessing(Eth2Network eth2Network) { + public void onTick_shouldRunAttestationsDuringProcessing(final Eth2Network eth2Network) { Spec spec = TestSpecFactory.create(SpecMilestone.PHASE0, eth2Network); int millisPerSlot = spec.getGenesisSpecConfig().getSecondsPerSlot() * 1000; @@ -316,7 +316,7 @@ public void setNodeSlot_shouldAlterNodeSlotValue() { @EnumSource( value = Eth2Network.class, names = {"MAINNET", "MINIMAL", "GNOSIS"}) - void shouldProgressThroughMultipleSlots(Eth2Network eth2Network) { + void shouldProgressThroughMultipleSlots(final Eth2Network eth2Network) { when(syncStateProvider.getCurrentSyncState()).thenReturn(SyncState.IN_SYNC); when(p2pNetwork.getPeerCount()).thenReturn(1); @@ -345,7 +345,8 @@ void shouldProgressThroughMultipleSlots(Eth2Network eth2Network) { @EnumSource( value = Eth2Network.class, names = {"MAINNET", "MINIMAL", "GNOSIS"}) - void shouldPrecomputeEpochTransitionJustBeforeFirstSlotOfNextEpoch(Eth2Network eth2Network) { + void shouldPrecomputeEpochTransitionJustBeforeFirstSlotOfNextEpoch( + final Eth2Network eth2Network) { final RecentChainData recentChainData = mock(RecentChainData.class); when(recentChainData.getGenesisTimeMillis()).thenReturn(genesisTimeMillis); final Optional headBlock = @@ -404,7 +405,7 @@ void shouldPrecomputeEpochTransitionJustBeforeFirstSlotOfNextEpoch(Eth2Network e verify(recentChainData, atMostOnce()).retrieveStateAtSlot(any()); } - private long oneThirdMillis(long millis) { + private long oneThirdMillis(final long millis) { return millis / 3L; } } diff --git a/services/chainstorage/build.gradle b/services/chainstorage/build.gradle index c338497010e..d147836fa60 100644 --- a/services/chainstorage/build.gradle +++ b/services/chainstorage/build.gradle @@ -12,4 +12,7 @@ dependencies { implementation project(':infrastructure:events') implementation 'org.hyperledger.besu:plugin-api' + + testImplementation testFixtures(project(':infrastructure:async')) + testImplementation testFixtures(project(':ethereum:execution-types')) } diff --git a/services/chainstorage/src/main/java/tech/pegasys/teku/services/chainstorage/EphemeryDatabaseReset.java b/services/chainstorage/src/main/java/tech/pegasys/teku/services/chainstorage/EphemeryDatabaseReset.java new file mode 100644 index 00000000000..92de802252b --- /dev/null +++ b/services/chainstorage/src/main/java/tech/pegasys/teku/services/chainstorage/EphemeryDatabaseReset.java @@ -0,0 +1,74 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.services.chainstorage; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import tech.pegasys.teku.infrastructure.exceptions.InvalidConfigurationException; +import tech.pegasys.teku.service.serviceutils.ServiceConfig; +import tech.pegasys.teku.storage.server.Database; +import tech.pegasys.teku.storage.server.VersionedDatabaseFactory; + +public class EphemeryDatabaseReset { + + /** This method is called only on Ephemery network when reset is due. */ + Database resetDatabaseAndCreate( + final ServiceConfig serviceConfig, final VersionedDatabaseFactory dbFactory) { + try { + final Path beaconDataDir = serviceConfig.getDataDirLayout().getBeaconDataDirectory(); + final Path dbDataDir = beaconDataDir.resolve("db"); + final Path networkFile = beaconDataDir.resolve("network.yml"); + final Path validatorDataDir = serviceConfig.getDataDirLayout().getValidatorDataDirectory(); + final Path slashProtectionDir; + if (validatorDataDir.endsWith("slashprotection")) { + slashProtectionDir = validatorDataDir; + } else { + slashProtectionDir = validatorDataDir.resolve("slashprotection"); + } + deleteDirectoryRecursively(dbDataDir); + deleteDirectoryRecursively(networkFile); + deleteDirectoryRecursively(slashProtectionDir); + return dbFactory.createDatabase(); + } catch (final Exception ex) { + throw new InvalidConfigurationException( + "The existing ephemery database was old, and was unable to reset it.", ex); + } + } + + void deleteDirectoryRecursively(final Path path) throws IOException { + if (Files.exists(path)) { + if (Files.isDirectory(path)) { + try (var stream = Files.walk(path)) { + stream + .sorted((o1, o2) -> o2.compareTo(o1)) + .forEach( + p -> { + try { + Files.delete(p); + } catch (IOException e) { + throw new RuntimeException("Failed to delete file/directory: " + p, e); + } + }); + } + } else { + try { + Files.delete(path); + } catch (IOException e) { + throw new RuntimeException("Failed to delete file: " + path, e); + } + } + } + } +} diff --git a/services/chainstorage/src/main/java/tech/pegasys/teku/services/chainstorage/StorageService.java b/services/chainstorage/src/main/java/tech/pegasys/teku/services/chainstorage/StorageService.java index 6892e18d091..282fffa9010 100644 --- a/services/chainstorage/src/main/java/tech/pegasys/teku/services/chainstorage/StorageService.java +++ b/services/chainstorage/src/main/java/tech/pegasys/teku/services/chainstorage/StorageService.java @@ -16,33 +16,47 @@ import static tech.pegasys.teku.infrastructure.async.AsyncRunnerFactory.DEFAULT_MAX_QUEUE_SIZE; import static tech.pegasys.teku.spec.config.Constants.STORAGE_QUERY_CHANNEL_PARALLELISM; +import com.google.common.annotations.VisibleForTesting; +import java.nio.file.Path; +import java.time.Duration; import java.util.Optional; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; import tech.pegasys.teku.ethereum.pow.api.Eth1EventsChannel; import tech.pegasys.teku.infrastructure.async.AsyncRunner; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.async.eventthread.AsyncRunnerEventThread; import tech.pegasys.teku.infrastructure.events.EventChannels; +import tech.pegasys.teku.infrastructure.exceptions.InvalidConfigurationException; import tech.pegasys.teku.infrastructure.metrics.SettableLabelledGauge; import tech.pegasys.teku.infrastructure.metrics.TekuMetricCategory; import tech.pegasys.teku.service.serviceutils.Service; import tech.pegasys.teku.service.serviceutils.ServiceConfig; import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.networks.Eth2Network; import tech.pegasys.teku.storage.api.CombinedStorageChannel; import tech.pegasys.teku.storage.api.Eth1DepositStorageChannel; import tech.pegasys.teku.storage.api.SidecarUpdateChannel; import tech.pegasys.teku.storage.api.VoteUpdateChannel; +import tech.pegasys.teku.storage.archive.DataArchive; +import tech.pegasys.teku.storage.archive.fsarchive.FileSystemArchive; +import tech.pegasys.teku.storage.archive.nooparchive.NoopDataArchive; import tech.pegasys.teku.storage.server.BatchingVoteUpdateChannel; import tech.pegasys.teku.storage.server.ChainStorage; import tech.pegasys.teku.storage.server.CombinedStorageChannelSplitter; import tech.pegasys.teku.storage.server.Database; +import tech.pegasys.teku.storage.server.DatabaseVersion; import tech.pegasys.teku.storage.server.DepositStorage; import tech.pegasys.teku.storage.server.RetryingStorageUpdateChannel; import tech.pegasys.teku.storage.server.StorageConfiguration; import tech.pegasys.teku.storage.server.VersionedDatabaseFactory; +import tech.pegasys.teku.storage.server.network.EphemeryException; import tech.pegasys.teku.storage.server.pruner.BlobSidecarPruner; import tech.pegasys.teku.storage.server.pruner.BlockPruner; +import tech.pegasys.teku.storage.server.pruner.StatePruner; public class StorageService extends Service implements StorageServiceFacade { + public static final Duration STATE_PRUNING_INTERVAL = Duration.ofMinutes(1); private final StorageConfiguration config; private volatile ChainStorage chainStorage; private final ServiceConfig serviceConfig; @@ -50,18 +64,23 @@ public class StorageService extends Service implements StorageServiceFacade { private volatile BatchingVoteUpdateChannel batchingVoteUpdateChannel; private volatile Optional blockPruner = Optional.empty(); private volatile Optional blobsPruner = Optional.empty(); + private volatile Optional statePruner = Optional.empty(); private final boolean depositSnapshotStorageEnabled; private final boolean blobSidecarsStorageCountersEnabled; + private static final Logger LOG = LogManager.getLogger(); + private final Optional maybeNetwork; public StorageService( final ServiceConfig serviceConfig, final StorageConfiguration storageConfiguration, final boolean depositSnapshotStorageEnabled, - final boolean blobSidecarsStorageCountersEnabled) { + final boolean blobSidecarsStorageCountersEnabled, + final Optional eth2Network) { this.serviceConfig = serviceConfig; this.config = storageConfiguration; this.depositSnapshotStorageEnabled = depositSnapshotStorageEnabled; this.blobSidecarsStorageCountersEnabled = blobSidecarsStorageCountersEnabled; + this.maybeNetwork = eth2Network; } @Override @@ -78,10 +97,16 @@ protected SafeFuture doStart() { new VersionedDatabaseFactory( serviceConfig.getMetricsSystem(), serviceConfig.getDataDirLayout().getBeaconDataDirectory(), - config); - database = dbFactory.createDatabase(); - - database.migrate(); + config, + maybeNetwork); + try { + database = dbFactory.createDatabase(); + } catch (EphemeryException e) { + final EphemeryDatabaseReset ephemeryDatabaseReset = new EphemeryDatabaseReset(); + LOG.warn( + "Ephemery network deposit contract id has updated, resetting the stored database and slashing protection data."); + database = ephemeryDatabaseReset.resetDatabaseAndCreate(serviceConfig, dbFactory); + } final SettableLabelledGauge pruningTimingsLabelledGauge = SettableLabelledGauge.create( @@ -112,12 +137,42 @@ protected SafeFuture doStart() { pruningTimingsLabelledGauge, pruningActiveLabelledGauge)); } + if (config.getDataStorageMode().storesFinalizedStates() + && config.getRetainedSlots() > 0) { + configureStatePruner( + config.getRetainedSlots(), + storagePrunerAsyncRunner, + config.getStatePruningInterval(), + pruningTimingsLabelledGauge, + pruningActiveLabelledGauge); + } else if (!config.getDataStorageMode().storesFinalizedStates()) { + final Duration statePruningInterval = + config + .getStatePruningInterval() + .equals(StorageConfiguration.DEFAULT_STATE_PRUNING_INTERVAL) + ? STATE_PRUNING_INTERVAL + : config.getStatePruningInterval(); + configureStatePruner( + StorageConfiguration.DEFAULT_STORAGE_RETAINED_SLOTS, + storagePrunerAsyncRunner, + statePruningInterval, + pruningTimingsLabelledGauge, + pruningActiveLabelledGauge); + } + + final DataArchive dataArchive = + config + .getBlobsArchivePath() + .map(path -> new FileSystemArchive(Path.of(path))) + .orElse(new NoopDataArchive()); + if (config.getSpec().isMilestoneSupported(SpecMilestone.DENEB)) { blobsPruner = Optional.of( new BlobSidecarPruner( config.getSpec(), database, + dataArchive, serviceConfig.getMetricsSystem(), storagePrunerAsyncRunner, serviceConfig.getTimeProvider(), @@ -172,9 +227,50 @@ protected SafeFuture doStart() { __ -> blobsPruner .map(BlobSidecarPruner::start) + .orElseGet(() -> SafeFuture.completedFuture(null))) + .thenCompose( + __ -> + statePruner + .map(StatePruner::start) .orElseGet(() -> SafeFuture.completedFuture(null))); } + void configureStatePruner( + final long slotsToRetain, + final AsyncRunner storagePrunerAsyncRunner, + final Duration pruningInterval, + final SettableLabelledGauge pruningTimingsLabelledGauge, + final SettableLabelledGauge pruningActiveLabelledGauge) { + if (config.getDataStorageCreateDbVersion() == DatabaseVersion.LEVELDB_TREE) { + throw new InvalidConfigurationException( + "State pruning is not supported with leveldb_tree database."); + } + + LOG.info( + "State pruner will run every: {} minute(s), retaining states for the last {} finalized slots. Limited to {} state prune per execution.", + config.getStatePruningInterval().toMinutes(), + slotsToRetain, + config.getStatePruningLimit()); + + statePruner = + Optional.of( + new StatePruner( + config.getSpec(), + database, + storagePrunerAsyncRunner, + pruningInterval, + slotsToRetain, + config.getStatePruningLimit(), + "state", + pruningTimingsLabelledGauge, + pruningActiveLabelledGauge)); + } + + @VisibleForTesting + public Optional getStatePruner() { + return statePruner; + } + @Override protected SafeFuture doStop() { return blockPruner diff --git a/services/chainstorage/src/test/java/tech/pegasys/teku/services/chainstorage/EphemeryDatabaseResetTest.java b/services/chainstorage/src/test/java/tech/pegasys/teku/services/chainstorage/EphemeryDatabaseResetTest.java new file mode 100644 index 00000000000..1121926ce0c --- /dev/null +++ b/services/chainstorage/src/test/java/tech/pegasys/teku/services/chainstorage/EphemeryDatabaseResetTest.java @@ -0,0 +1,135 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.services.chainstorage; + +import static java.nio.file.Files.createTempDirectory; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoMoreInteractions; +import static org.mockito.Mockito.when; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import tech.pegasys.teku.infrastructure.exceptions.InvalidConfigurationException; +import tech.pegasys.teku.service.serviceutils.ServiceConfig; +import tech.pegasys.teku.service.serviceutils.layout.DataDirLayout; +import tech.pegasys.teku.storage.server.Database; +import tech.pegasys.teku.storage.server.VersionedDatabaseFactory; + +class EphemeryDatabaseResetTest { + + @Mock private ServiceConfig serviceConfig; + + @Mock private VersionedDatabaseFactory dbFactory; + + @Mock private DataDirLayout dataDirLayout; + private Path beaconDataDir; + private Path dbDataDir; + private Path resolvedSlashProtectionDir; + private Path networkFilePath; + @Mock private Database database; + + @Mock private EphemeryDatabaseReset ephemeryDatabaseReset; + + @BeforeEach + void setUp() throws IOException { + MockitoAnnotations.openMocks(this); + ephemeryDatabaseReset = spy(new EphemeryDatabaseReset()); + beaconDataDir = createTempDirectory("beacon"); + dbDataDir = beaconDataDir.resolve("db"); + Files.createDirectory(dbDataDir); + Path networkFile = beaconDataDir.resolve("network.yml"); + Files.createFile(networkFile); + networkFilePath = networkFile; + + final Path validatorDataDir = createTempDirectory("validator"); + resolvedSlashProtectionDir = validatorDataDir.resolve("slashprotection"); + + when(serviceConfig.getDataDirLayout()).thenReturn(dataDirLayout); + when(dataDirLayout.getBeaconDataDirectory()).thenReturn(beaconDataDir); + when(dataDirLayout.getValidatorDataDirectory()).thenReturn(validatorDataDir); + when(dataDirLayout.getValidatorDataDirectory().resolve("slashprotection")) + .thenReturn(resolvedSlashProtectionDir); + } + + @Test + void shouldResetSpecificDirectoriesAndCreateDatabase() throws IOException { + final Path kvStoreDir = beaconDataDir.resolve("kvstore"); + Files.createDirectory(kvStoreDir); + final Path dbVersion = beaconDataDir.resolve("db.version"); + Files.createFile(dbVersion); + + when(dbFactory.createDatabase()).thenReturn(database); + + final Database result = ephemeryDatabaseReset.resetDatabaseAndCreate(serviceConfig, dbFactory); + verify(ephemeryDatabaseReset).deleteDirectoryRecursively(dbDataDir); + verify(ephemeryDatabaseReset).deleteDirectoryRecursively(networkFilePath); + verify(ephemeryDatabaseReset).deleteDirectoryRecursively(resolvedSlashProtectionDir); + + verify(dbFactory).createDatabase(); + verifyNoMoreInteractions(dbFactory); + + assertTrue(Files.exists(kvStoreDir)); + assertTrue(Files.exists(dbVersion)); + assertEquals(database, result); + } + + @Test + void shouldThrowInvalidConfigurationExceptionWhenDirectoryDeletionFails() throws IOException { + doThrow(new IOException("Failed to delete directory")) + .when(ephemeryDatabaseReset) + .deleteDirectoryRecursively(dbDataDir); + final InvalidConfigurationException exception = + assertThrows( + InvalidConfigurationException.class, + () -> { + ephemeryDatabaseReset.resetDatabaseAndCreate(serviceConfig, dbFactory); + }); + assertEquals( + "The existing ephemery database was old, and was unable to reset it.", + exception.getMessage()); + verify(dbFactory, never()).createDatabase(); + verify(ephemeryDatabaseReset, never()).deleteDirectoryRecursively(resolvedSlashProtectionDir); + } + + @Test + void shouldThrowInvalidConfigurationExceptionWhenDatabaseCreationFails() throws IOException { + doNothing().when(ephemeryDatabaseReset).deleteDirectoryRecursively(dbDataDir); + doNothing().when(ephemeryDatabaseReset).deleteDirectoryRecursively(resolvedSlashProtectionDir); + when(dbFactory.createDatabase()).thenThrow(new RuntimeException("Database creation failed")); + final InvalidConfigurationException exception = + assertThrows( + InvalidConfigurationException.class, + () -> { + ephemeryDatabaseReset.resetDatabaseAndCreate(serviceConfig, dbFactory); + }); + assertEquals( + "The existing ephemery database was old, and was unable to reset it.", + exception.getMessage()); + verify(ephemeryDatabaseReset).deleteDirectoryRecursively(dbDataDir); + verify(ephemeryDatabaseReset).deleteDirectoryRecursively(resolvedSlashProtectionDir); + verify(dbFactory).createDatabase(); + } +} diff --git a/services/chainstorage/src/test/java/tech/pegasys/teku/services/chainstorage/StorageServiceTest.java b/services/chainstorage/src/test/java/tech/pegasys/teku/services/chainstorage/StorageServiceTest.java new file mode 100644 index 00000000000..e51cb1a6f3b --- /dev/null +++ b/services/chainstorage/src/test/java/tech/pegasys/teku/services/chainstorage/StorageServiceTest.java @@ -0,0 +1,141 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.services.chainstorage; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.anyInt; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import java.nio.file.Path; +import java.time.Duration; +import java.util.Optional; +import org.hyperledger.besu.plugin.services.MetricsSystem; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; +import tech.pegasys.teku.ethereum.execution.types.Eth1Address; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.async.StubAsyncRunner; +import tech.pegasys.teku.infrastructure.async.StubAsyncRunnerFactory; +import tech.pegasys.teku.infrastructure.events.EventChannels; +import tech.pegasys.teku.service.serviceutils.ServiceConfig; +import tech.pegasys.teku.service.serviceutils.layout.DataDirLayout; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.storage.server.DatabaseVersion; +import tech.pegasys.teku.storage.server.StateStorageMode; +import tech.pegasys.teku.storage.server.StorageConfiguration; +import tech.pegasys.teku.storage.server.pruner.StatePruner; + +class StorageServiceTest { + + private final ServiceConfig serviceConfig = mock(ServiceConfig.class); + private final StorageConfiguration storageConfiguration = mock(StorageConfiguration.class); + private final MetricsSystem metricsSystem = mock(MetricsSystem.class); + private final DataDirLayout dataDirLayout = mock(DataDirLayout.class); + private final Eth1Address eth1DepositContract = mock(Eth1Address.class); + private final Spec spec = mock(Spec.class); + private final EventChannels eventChannels = mock(EventChannels.class); + private StorageService storageService; + + @BeforeEach + void setUp(@TempDir final Path tempDir) { + when(serviceConfig.getMetricsSystem()).thenReturn(metricsSystem); + when(dataDirLayout.getBeaconDataDirectory()).thenReturn(tempDir); + when(serviceConfig.getDataDirLayout()).thenReturn(dataDirLayout); + when(storageConfiguration.getDataStorageCreateDbVersion()).thenReturn(DatabaseVersion.NOOP); + when(storageConfiguration.getMaxKnownNodeCacheSize()) + .thenReturn(StorageConfiguration.DEFAULT_MAX_KNOWN_NODE_CACHE_SIZE); + when(storageConfiguration.getDataStorageFrequency()) + .thenReturn(StorageConfiguration.DEFAULT_STORAGE_FREQUENCY); + when(storageConfiguration.getStatePruningLimit()) + .thenReturn(StorageConfiguration.DEFAULT_STATE_PRUNING_LIMIT); + when(storageConfiguration.getStatePruningInterval()) + .thenReturn(StorageConfiguration.DEFAULT_STATE_PRUNING_INTERVAL); + when(storageConfiguration.getEth1DepositContract()).thenReturn(eth1DepositContract); + when(storageConfiguration.isStoreNonCanonicalBlocksEnabled()).thenReturn(false); + when(storageConfiguration.getSpec()).thenReturn(spec); + + when(eventChannels.subscribe(any(), any())).thenReturn(eventChannels); + when(serviceConfig.getEventChannels()).thenReturn(eventChannels); + + final StubAsyncRunnerFactory asyncRunnerFactory = new StubAsyncRunnerFactory(); + when(serviceConfig.getAsyncRunnerFactory()).thenReturn(asyncRunnerFactory); + + final StubAsyncRunner stubAsyncRunner = new StubAsyncRunner(); + when(serviceConfig.createAsyncRunner(any(), anyInt(), anyInt(), anyInt())) + .thenReturn(stubAsyncRunner); + + storageService = + new StorageService(serviceConfig, storageConfiguration, false, false, Optional.empty()); + } + + @Test + void shouldNotSetupStatePrunerWhenArchiveMode() { + when(storageConfiguration.getDataStorageMode()).thenReturn(StateStorageMode.ARCHIVE); + final SafeFuture future = storageService.doStart(); + final Optional maybeStatePruner = storageService.getStatePruner(); + assertThat(future).isCompleted(); + assertThat(maybeStatePruner).isEmpty(); + } + + @Test + void shouldSetupStatePrunerWhenArchiveModeAndRetentionSlotsEnabled() { + when(storageConfiguration.getDataStorageMode()).thenReturn(StateStorageMode.ARCHIVE); + when(storageConfiguration.getRetainedSlots()).thenReturn(5L); + final SafeFuture future = storageService.doStart(); + final Optional maybeStatePruner = storageService.getStatePruner(); + assertThat(future).isCompleted(); + assertThat(maybeStatePruner).isPresent(); + final StatePruner statePruner = maybeStatePruner.get(); + assertThat(statePruner.isRunning()).isTrue(); + assertThat(statePruner.getPruneInterval()) + .isEqualTo(StorageConfiguration.DEFAULT_STATE_PRUNING_INTERVAL); + } + + @ParameterizedTest + @EnumSource( + value = StateStorageMode.class, + names = {"PRUNE", "MINIMAL"}) + void shouldSetupStatePrunerWhenPruneMode(final StateStorageMode stateStorageMode) { + when(storageConfiguration.getDataStorageMode()).thenReturn(stateStorageMode); + final SafeFuture future = storageService.doStart(); + final Optional maybeStatePruner = storageService.getStatePruner(); + assertThat(future).isCompleted(); + assertThat(maybeStatePruner).isPresent(); + final StatePruner statePruner = maybeStatePruner.get(); + assertThat(statePruner.isRunning()).isTrue(); + assertThat(statePruner.getPruneInterval()).isEqualTo(StorageService.STATE_PRUNING_INTERVAL); + } + + @ParameterizedTest + @EnumSource( + value = StateStorageMode.class, + names = {"PRUNE", "MINIMAL"}) + void shouldSetupStatePrunerWithCustomInterval(final StateStorageMode stateStorageMode) { + when(storageConfiguration.getDataStorageMode()).thenReturn(stateStorageMode); + final Duration customPruningInterval = Duration.ofSeconds(8); + when(storageConfiguration.getStatePruningInterval()).thenReturn(customPruningInterval); + final SafeFuture future = storageService.doStart(); + final Optional maybeStatePruner = storageService.getStatePruner(); + assertThat(future).isCompleted(); + assertThat(maybeStatePruner).isPresent(); + final StatePruner statePruner = maybeStatePruner.get(); + assertThat(statePruner.isRunning()).isTrue(); + assertThat(statePruner.getPruneInterval()).isEqualTo(customPruningInterval); + } +} diff --git a/services/executionlayer/build.gradle b/services/executionlayer/build.gradle index e8514d86122..3561b902efe 100644 --- a/services/executionlayer/build.gradle +++ b/services/executionlayer/build.gradle @@ -14,7 +14,7 @@ dependencies { implementation project(':infrastructure:serviceutils') implementation project(':validator:client') - implementation 'org.apache.tuweni:tuweni-units' + implementation 'io.tmio:tuweni-units' testImplementation testFixtures(project(':ethereum:spec')) } \ No newline at end of file diff --git a/services/executionlayer/src/main/java/tech/pegasys/teku/services/executionlayer/ExecutionLayerService.java b/services/executionlayer/src/main/java/tech/pegasys/teku/services/executionlayer/ExecutionLayerService.java index 226a91a95a8..c6c469a335a 100644 --- a/services/executionlayer/src/main/java/tech/pegasys/teku/services/executionlayer/ExecutionLayerService.java +++ b/services/executionlayer/src/main/java/tech/pegasys/teku/services/executionlayer/ExecutionLayerService.java @@ -201,7 +201,6 @@ private static ExecutionLayerManager createRealExecutionLayerManager( EVENT_LOG, executionClientHandler, builderClient, - config.getSpec(), metricsSystem, new BuilderBidValidatorImpl(config.getSpec(), EVENT_LOG), builderCircuitBreaker, diff --git a/services/powchain/build.gradle b/services/powchain/build.gradle index c5ca21cc020..942c2219abe 100644 --- a/services/powchain/build.gradle +++ b/services/powchain/build.gradle @@ -18,10 +18,9 @@ dependencies { implementation project(':infrastructure:serviceutils') implementation project(':validator:client') - implementation 'org.apache.tuweni:tuweni-units' + implementation 'io.tmio:tuweni-units' testImplementation project(':ethereum:pow:merkletree') - testImplementation project(':data:serializer') testImplementation testFixtures(project(':ethereum:spec')) testImplementation testFixtures(project(':infrastructure:async')) diff --git a/services/powchain/src/main/java/tech/pegasys/teku/services/powchain/Eth1ProviderMonitor.java b/services/powchain/src/main/java/tech/pegasys/teku/services/powchain/Eth1ProviderMonitor.java index 1d6c2808685..d282867e9b8 100644 --- a/services/powchain/src/main/java/tech/pegasys/teku/services/powchain/Eth1ProviderMonitor.java +++ b/services/powchain/src/main/java/tech/pegasys/teku/services/powchain/Eth1ProviderMonitor.java @@ -29,7 +29,8 @@ public class Eth1ProviderMonitor { private final AsyncRunner asyncRunner; private final AtomicBoolean stopped = new AtomicBoolean(false); - public Eth1ProviderMonitor(Eth1ProviderSelector eth1ProviderSelector, AsyncRunner asyncRunner) { + public Eth1ProviderMonitor( + final Eth1ProviderSelector eth1ProviderSelector, final AsyncRunner asyncRunner) { this.eth1ProviderSelector = eth1ProviderSelector; this.asyncRunner = asyncRunner; } diff --git a/services/powchain/src/main/java/tech/pegasys/teku/services/powchain/PowchainService.java b/services/powchain/src/main/java/tech/pegasys/teku/services/powchain/PowchainService.java index 243c6279c58..7124710b8fb 100644 --- a/services/powchain/src/main/java/tech/pegasys/teku/services/powchain/PowchainService.java +++ b/services/powchain/src/main/java/tech/pegasys/teku/services/powchain/PowchainService.java @@ -15,6 +15,7 @@ import static com.google.common.base.Preconditions.checkArgument; import static tech.pegasys.teku.beacon.pow.api.Eth1DataCachePeriodCalculator.calculateEth1DataCacheDurationPriorToCurrentTime; +import static tech.pegasys.teku.infrastructure.logging.StatusLogger.STATUS_LOG; import com.google.common.annotations.VisibleForTesting; import java.util.Collections; @@ -22,6 +23,7 @@ import java.util.Optional; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; +import java.util.function.Supplier; import java.util.stream.IntStream; import java.util.stream.Stream; import okhttp3.OkHttpClient; @@ -56,6 +58,7 @@ import tech.pegasys.teku.service.serviceutils.ServiceConfig; import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.datastructures.state.Checkpoint; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.storage.api.CombinedStorageChannel; import tech.pegasys.teku.storage.api.Eth1DepositStorageChannel; import tech.pegasys.teku.storage.api.FinalizedCheckpointChannel; @@ -70,6 +73,7 @@ public class PowchainService extends Service implements FinalizedCheckpointChann private final ServiceConfig serviceConfig; private final PowchainConfiguration powConfig; private final Optional maybeExecutionWeb3jClientProvider; + private final Supplier> finalizedStateSupplier; private List web3js; private Eth1Providers eth1Providers; @@ -79,15 +83,21 @@ public class PowchainService extends Service implements FinalizedCheckpointChann public PowchainService( final ServiceConfig serviceConfig, final PowchainConfiguration powConfig, - final Optional maybeExecutionWeb3jClientProvider) { + final Optional maybeExecutionWeb3jClientProvider, + final Supplier> finalizedStateSupplier) { checkArgument(powConfig.isEnabled() || maybeExecutionWeb3jClientProvider.isPresent()); this.serviceConfig = serviceConfig; this.powConfig = powConfig; this.maybeExecutionWeb3jClientProvider = maybeExecutionWeb3jClientProvider; + this.finalizedStateSupplier = finalizedStateSupplier; } @Override protected SafeFuture doStart() { + if (isFormerDepositMechanismDisabled()) { + // no need to initialize and start services if Eth1 polling has already been disabled + return SafeFuture.COMPLETE; + } return SafeFuture.fromRunnable(this::initialize) .thenPeek(__ -> hasInitialized.set(true)) .thenCompose( @@ -118,6 +128,25 @@ public void onNewFinalizedCheckpoint( if (!isRunning()) { return; } + if (isFormerDepositMechanismDisabled()) { + // stop Eth1 polling + stop() + .finish( + () -> { + if (hasInitialized.get()) { + // only log if polling has been enabled and now stopped + STATUS_LOG.eth1PollingHasBeenDisabled(); + } + }, + LOG::error); + } + } + + private boolean isFormerDepositMechanismDisabled() { + return finalizedStateSupplier + .get() + .map(powConfig.getSpec()::isFormerDepositMechanismDisabled) + .orElse(false); } @VisibleForTesting diff --git a/services/powchain/src/main/resources/tech/pegasys/teku/services/powchain/gnosis.ssz b/services/powchain/src/main/resources/tech/pegasys/teku/services/powchain/gnosis.ssz index 56ff8a0f298..f85ebf090af 100644 Binary files a/services/powchain/src/main/resources/tech/pegasys/teku/services/powchain/gnosis.ssz and b/services/powchain/src/main/resources/tech/pegasys/teku/services/powchain/gnosis.ssz differ diff --git a/services/powchain/src/main/resources/tech/pegasys/teku/services/powchain/goerli.ssz b/services/powchain/src/main/resources/tech/pegasys/teku/services/powchain/goerli.ssz deleted file mode 100644 index a5c56a9d60e..00000000000 Binary files a/services/powchain/src/main/resources/tech/pegasys/teku/services/powchain/goerli.ssz and /dev/null differ diff --git a/services/powchain/src/main/resources/tech/pegasys/teku/services/powchain/holesky.ssz b/services/powchain/src/main/resources/tech/pegasys/teku/services/powchain/holesky.ssz index 42efedf03a8..e7f69a23b1b 100644 Binary files a/services/powchain/src/main/resources/tech/pegasys/teku/services/powchain/holesky.ssz and b/services/powchain/src/main/resources/tech/pegasys/teku/services/powchain/holesky.ssz differ diff --git a/services/powchain/src/main/resources/tech/pegasys/teku/services/powchain/mainnet.ssz b/services/powchain/src/main/resources/tech/pegasys/teku/services/powchain/mainnet.ssz index 9f339922fdc..0984ecd89a2 100644 Binary files a/services/powchain/src/main/resources/tech/pegasys/teku/services/powchain/mainnet.ssz and b/services/powchain/src/main/resources/tech/pegasys/teku/services/powchain/mainnet.ssz differ diff --git a/services/powchain/src/main/resources/tech/pegasys/teku/services/powchain/sepolia.ssz b/services/powchain/src/main/resources/tech/pegasys/teku/services/powchain/sepolia.ssz index 6a6bf397558..24979f36b04 100644 Binary files a/services/powchain/src/main/resources/tech/pegasys/teku/services/powchain/sepolia.ssz and b/services/powchain/src/main/resources/tech/pegasys/teku/services/powchain/sepolia.ssz differ diff --git a/services/powchain/src/test/java/tech/pegasys/teku/services/powchain/DepositSnapshotsBundleTest.java b/services/powchain/src/test/java/tech/pegasys/teku/services/powchain/DepositSnapshotsBundleTest.java index a0ec195b5dc..cbacf601a60 100644 --- a/services/powchain/src/test/java/tech/pegasys/teku/services/powchain/DepositSnapshotsBundleTest.java +++ b/services/powchain/src/test/java/tech/pegasys/teku/services/powchain/DepositSnapshotsBundleTest.java @@ -150,8 +150,9 @@ public void shouldValidateSnapshotViaRemoteAPI( public static Stream getSupportedNetworks() { return Stream.of( Arguments.of(Eth2Network.GNOSIS, "https://rpc.ankr.com/gnosis"), - Arguments.of(Eth2Network.PRATER, "https://goerli.infura.io/v3/%INFURA_KEY%"), Arguments.of(Eth2Network.MAINNET, "https://mainnet.infura.io/v3/%INFURA_KEY%"), - Arguments.of(Eth2Network.SEPOLIA, "https://sepolia.infura.io/v3/%INFURA_KEY%")); + Arguments.of(Eth2Network.SEPOLIA, "https://sepolia.infura.io/v3/%INFURA_KEY%"), + Arguments.of(Eth2Network.HOLESKY, "https://holesky.infura.io/v3/%INFURA_KEY%"), + Arguments.of(Eth2Network.EPHEMERY, "https://otter.bordel.wtf/erigon")); } } diff --git a/services/powchain/src/test/java/tech/pegasys/teku/services/powchain/PowchainServiceTest.java b/services/powchain/src/test/java/tech/pegasys/teku/services/powchain/PowchainServiceTest.java index 4c593f963fc..190b108d453 100644 --- a/services/powchain/src/test/java/tech/pegasys/teku/services/powchain/PowchainServiceTest.java +++ b/services/powchain/src/test/java/tech/pegasys/teku/services/powchain/PowchainServiceTest.java @@ -23,6 +23,7 @@ import java.util.List; import java.util.Optional; +import java.util.function.Supplier; import org.hyperledger.besu.plugin.services.MetricsSystem; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -39,6 +40,8 @@ import tech.pegasys.teku.service.serviceutils.ServiceConfig; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.datastructures.state.Checkpoint; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.storage.api.Eth1DepositStorageChannel; public class PowchainServiceTest { @@ -50,6 +53,7 @@ public class PowchainServiceTest { mock(ExecutionWeb3jClientProvider.class); private final Web3JClient web3JClient = mock(Web3JClient.class); private final Spec spec = TestSpecFactory.createMinimalPhase0(); + private Supplier> latestFinalizedState; @BeforeEach public void setup() { @@ -69,6 +73,7 @@ public void setup() { when(eventChannels.getPublisher(eq(Eth1DepositStorageChannel.class), any(AsyncRunner.class))) .thenReturn(mock(Eth1DepositStorageChannel.class)); when(serviceConfig.getEventChannels()).thenReturn(eventChannels); + latestFinalizedState = Optional::empty; } @Test @@ -213,10 +218,52 @@ public void shouldHaveNoDepositSnapshotPathWhenNoneIsAvailable() { .isEmpty(); } + @Test + public void shouldNotInitializeIfEth1PollingHasBeenDisabled() { + final Spec spec = mock(Spec.class); + when(powConfig.getSpec()).thenReturn(spec); + final BeaconState finalizedState = mock(BeaconState.class); + when(spec.isFormerDepositMechanismDisabled(finalizedState)).thenReturn(true); + + latestFinalizedState = () -> Optional.of(finalizedState); + + final PowchainService powchainService = + new PowchainService( + serviceConfig, powConfig, Optional.of(engineWeb3jClientProvider), latestFinalizedState); + + powchainService.start().join(); + + assertThat(powchainService.isRunning()).isTrue(); + assertThat(powchainService.getEth1DepositManager()).isNull(); + } + + @Test + public void shouldStopServiceIfEth1PollingHasBeenDisabledOnFinalizedCheckpoint() { + final Spec spec = mock(Spec.class); + when(powConfig.getSpec()).thenReturn(spec); + final BeaconState finalizedState = mock(BeaconState.class); + when(spec.isFormerDepositMechanismDisabled(finalizedState)).thenReturn(true); + + latestFinalizedState = () -> Optional.of(finalizedState); + + final PowchainService powchainService = + new PowchainService( + serviceConfig, powConfig, Optional.of(engineWeb3jClientProvider), latestFinalizedState); + + powchainService.start().join(); + + assertThat(powchainService.isRunning()).isTrue(); + + powchainService.onNewFinalizedCheckpoint(mock(Checkpoint.class), false); + + assertThat(powchainService.isRunning()).isFalse(); + } + private PowchainService createAndInitializePowchainService( final Optional maybeExecutionWeb3jClientProvider) { final PowchainService powchainService = - new PowchainService(serviceConfig, powConfig, maybeExecutionWeb3jClientProvider); + new PowchainService( + serviceConfig, powConfig, maybeExecutionWeb3jClientProvider, latestFinalizedState); powchainService.initialize(); return powchainService; } diff --git a/services/timer/src/main/java/tech/pegasys/teku/services/timer/ScheduledTimeEvent.java b/services/timer/src/main/java/tech/pegasys/teku/services/timer/ScheduledTimeEvent.java index 6587340583c..a3afa3cc40b 100644 --- a/services/timer/src/main/java/tech/pegasys/teku/services/timer/ScheduledTimeEvent.java +++ b/services/timer/src/main/java/tech/pegasys/teku/services/timer/ScheduledTimeEvent.java @@ -33,7 +33,7 @@ public class ScheduledTimeEvent implements Job { * @param context the job execution context */ @Override - public void execute(JobExecutionContext context) { + public void execute(final JobExecutionContext context) { JobDataMap data = context.getJobDetail().getJobDataMap(); TimeTickHandler timeTickHandler = (TimeTickHandler) data.get(TimerService.TICK_HANDLER); timeTickHandler.onTick(); diff --git a/storage/api/build.gradle b/storage/api/build.gradle index 7be498e6d10..cc0a791e2be 100644 --- a/storage/api/build.gradle +++ b/storage/api/build.gradle @@ -4,7 +4,7 @@ dependencies { implementation project(':ethereum:pow:api') implementation project(':ethereum:spec') - implementation 'org.apache.tuweni:tuweni-bytes' + implementation 'io.tmio:tuweni-bytes' } publishing { diff --git a/storage/api/src/main/java/tech/pegasys/teku/storage/api/StorageQueryChannel.java b/storage/api/src/main/java/tech/pegasys/teku/storage/api/StorageQueryChannel.java index ebe91e463ee..5c3b67d9515 100644 --- a/storage/api/src/main/java/tech/pegasys/teku/storage/api/StorageQueryChannel.java +++ b/storage/api/src/main/java/tech/pegasys/teku/storage/api/StorageQueryChannel.java @@ -105,7 +105,7 @@ SafeFuture> getBlobSidecarsBySlotAndBlockRoot( SafeFuture> getAllBlobSidecarKeys(UInt64 slot); SafeFuture> getBlobSidecarKeys( - UInt64 startSlot, UInt64 endSlot, UInt64 limit); + UInt64 startSlot, UInt64 endSlot, long limit); SafeFuture> getBlobSidecarKeys( SlotAndBlockRoot slotAndBlockRoot); diff --git a/storage/api/src/main/java/tech/pegasys/teku/storage/api/WeakSubjectivityState.java b/storage/api/src/main/java/tech/pegasys/teku/storage/api/WeakSubjectivityState.java index a68d15e24fc..a1e83335e29 100644 --- a/storage/api/src/main/java/tech/pegasys/teku/storage/api/WeakSubjectivityState.java +++ b/storage/api/src/main/java/tech/pegasys/teku/storage/api/WeakSubjectivityState.java @@ -20,11 +20,11 @@ public class WeakSubjectivityState { private final Optional checkpoint; - private WeakSubjectivityState(Optional checkpoint) { + private WeakSubjectivityState(final Optional checkpoint) { this.checkpoint = checkpoint; } - public static WeakSubjectivityState create(Optional checkpoint) { + public static WeakSubjectivityState create(final Optional checkpoint) { return new WeakSubjectivityState(checkpoint); } diff --git a/storage/api/src/main/java/tech/pegasys/teku/storage/api/WeakSubjectivityUpdate.java b/storage/api/src/main/java/tech/pegasys/teku/storage/api/WeakSubjectivityUpdate.java index 6702ecd4c0e..7a8d006e29f 100644 --- a/storage/api/src/main/java/tech/pegasys/teku/storage/api/WeakSubjectivityUpdate.java +++ b/storage/api/src/main/java/tech/pegasys/teku/storage/api/WeakSubjectivityUpdate.java @@ -20,7 +20,7 @@ public class WeakSubjectivityUpdate { private final Optional weakSubjectivityCheckpoint; - private WeakSubjectivityUpdate(Optional weakSubjectivityCheckpoint) { + private WeakSubjectivityUpdate(final Optional weakSubjectivityCheckpoint) { this.weakSubjectivityCheckpoint = weakSubjectivityCheckpoint; } diff --git a/storage/build.gradle b/storage/build.gradle index fd19d858348..2f5febe79ed 100644 --- a/storage/build.gradle +++ b/storage/build.gradle @@ -22,7 +22,7 @@ dependencies { implementation 'com.fasterxml.jackson.core:jackson-databind' implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-yaml' implementation 'io.prometheus:simpleclient' - implementation 'org.apache.tuweni:tuweni-ssz' + implementation 'io.tmio:tuweni-ssz' implementation 'org.hyperledger.besu.internal:metrics-core' implementation 'org.hyperledger.besu:plugin-api' implementation 'org.rocksdb:rocksdbjni' @@ -64,7 +64,7 @@ dependencies { testFixturesImplementation 'org.junit.jupiter:junit-jupiter-api' testFixturesImplementation 'org.junit.jupiter:junit-jupiter-params' testFixturesImplementation 'com.google.guava:guava' - testFixturesImplementation 'org.apache.tuweni:tuweni-bytes' + testFixturesImplementation 'io.tmio:tuweni-bytes' testFixturesImplementation 'org.hyperledger.besu.internal:metrics-core' testFixturesImplementation 'org.hyperledger.besu:plugin-api' diff --git a/storage/src/integration-test/java/tech/pegasys/teku/storage/server/kvstore/DatabaseTest.java b/storage/src/integration-test/java/tech/pegasys/teku/storage/server/kvstore/DatabaseTest.java index 7904b8eebfd..54b144f3b8f 100644 --- a/storage/src/integration-test/java/tech/pegasys/teku/storage/server/kvstore/DatabaseTest.java +++ b/storage/src/integration-test/java/tech/pegasys/teku/storage/server/kvstore/DatabaseTest.java @@ -85,6 +85,7 @@ import tech.pegasys.teku.storage.api.OnDiskStoreData; import tech.pegasys.teku.storage.api.StorageUpdate; import tech.pegasys.teku.storage.api.WeakSubjectivityUpdate; +import tech.pegasys.teku.storage.archive.fsarchive.FileSystemArchive; import tech.pegasys.teku.storage.client.RecentChainData; import tech.pegasys.teku.storage.server.Database; import tech.pegasys.teku.storage.server.DatabaseContext; @@ -124,20 +125,24 @@ public class DatabaseTest { private StateStorageMode storageMode; private StorageSystem storageSystem; private Database database; + private FileSystemArchive fileSystemDataArchive; private RecentChainData recentChainData; private UpdatableStore store; private final List storageSystems = new ArrayList<>(); @BeforeEach - public void setup() { + public void setup() throws IOException { setupWithSpec(TestSpecFactory.createMinimalDeneb()); } - private void setupWithSpec(final Spec spec) { + private void setupWithSpec(final Spec spec) throws IOException { this.spec = spec; this.dataStructureUtil = new DataStructureUtil(spec); this.chainBuilder = ChainBuilder.create(spec, VALIDATOR_KEYS); this.chainProperties = new ChainProperties(spec); + final Path blobsArchive = Files.createTempDirectory("blobs"); + tmpDirectories.add(blobsArchive.toFile()); + this.fileSystemDataArchive = new FileSystemArchive(blobsArchive); genesisBlockAndState = chainBuilder.generateGenesis(genesisTime, true); genesisCheckpoint = getCheckpointForBlock(genesisBlockAndState.getBlock()); genesisAnchor = AnchorPoint.fromGenesisState(spec, genesisBlockAndState.getState()); @@ -298,7 +303,10 @@ public void verifyBlobsLifecycle(final DatabaseContext context) throws IOExcepti List.of(blobSidecar5_0))); // let's prune with limit to 1 - assertThat(database.pruneOldestBlobSidecars(UInt64.MAX_VALUE, 1)).isTrue(); + assertThat( + database.pruneOldestBlobSidecars( + UInt64.MAX_VALUE, 1, fileSystemDataArchive.getBlobSidecarWriter())) + .isTrue(); assertBlobSidecarKeys( blobSidecar2_0.getSlot(), blobSidecar5_0.getSlot(), @@ -314,8 +322,14 @@ public void verifyBlobsLifecycle(final DatabaseContext context) throws IOExcepti assertThat(database.getEarliestBlobSidecarSlot()).contains(UInt64.valueOf(2)); assertThat(database.getBlobSidecarColumnCount()).isEqualTo(4L); + // check if the pruned blob was written to disk. Not validating contents here. + assertThat(getSlotBlobsArchiveFile(blobSidecar1_0)).exists(); + assertThat(getSlotBlobsArchiveFile(blobSidecar2_0)).doesNotExist(); + // let's prune up to slot 1 (nothing will be pruned) - assertThat(database.pruneOldestBlobSidecars(ONE, 10)).isFalse(); + assertThat( + database.pruneOldestBlobSidecars(ONE, 10, fileSystemDataArchive.getBlobSidecarWriter())) + .isFalse(); assertBlobSidecarKeys( blobSidecar2_0.getSlot(), blobSidecar5_0.getSlot(), @@ -332,19 +346,37 @@ public void verifyBlobsLifecycle(final DatabaseContext context) throws IOExcepti assertThat(database.getBlobSidecarColumnCount()).isEqualTo(4L); // let's prune all from slot 4 excluded - assertThat(database.pruneOldestBlobSidecars(UInt64.valueOf(3), 10)).isFalse(); + assertThat( + database.pruneOldestBlobSidecars( + UInt64.valueOf(3), 10, fileSystemDataArchive.getBlobSidecarWriter())) + .isFalse(); assertBlobSidecarKeys( blobSidecar1_0.getSlot(), blobSidecar5_0.getSlot(), blobSidecarToKey(blobSidecar5_0)); assertBlobSidecars(Map.of(blobSidecar5_0.getSlot(), List.of(blobSidecar5_0))); assertThat(database.getEarliestBlobSidecarSlot()).contains(UInt64.valueOf(4)); assertThat(database.getBlobSidecarColumnCount()).isEqualTo(1L); + // check if the pruned blob was written to disk. Not validating contents here. + assertThat(getSlotBlobsArchiveFile(blobSidecar2_0)).exists(); + assertThat(getSlotBlobsArchiveFile(blobSidecar3_0)).exists(); + assertThat(getSlotBlobsArchiveFile(blobSidecar5_0)).doesNotExist(); + // let's prune all - assertThat(database.pruneOldestBlobSidecars(UInt64.valueOf(5), 1)).isTrue(); + assertThat( + database.pruneOldestBlobSidecars( + UInt64.valueOf(5), 1, fileSystemDataArchive.getBlobSidecarWriter())) + .isTrue(); // all empty now assertBlobSidecarKeys(ZERO, UInt64.valueOf(10)); assertThat(database.getEarliestBlobSidecarSlot()).contains(UInt64.valueOf(6)); assertThat(database.getBlobSidecarColumnCount()).isEqualTo(0L); + + // check if the pruned blob was written to disk. Not validating contents here. + assertThat(getSlotBlobsArchiveFile(blobSidecar5_0)).exists(); + } + + private File getSlotBlobsArchiveFile(final BlobSidecar blobSidecar) { + return fileSystemDataArchive.resolve(blobSidecar.getSlotAndBlockRoot()); } @TestTemplate @@ -443,7 +475,10 @@ public void verifyNonCanonicalBlobsLifecycle(final DatabaseContext context) thro List.of(blobSidecar5_0))); // Pruning with a prune limit set to 1: Only blobSidecar1 will be pruned - assertThat(database.pruneOldestNonCanonicalBlobSidecars(UInt64.MAX_VALUE, 1)).isTrue(); + assertThat( + database.pruneOldestNonCanonicalBlobSidecars( + UInt64.MAX_VALUE, 1, fileSystemDataArchive.getBlobSidecarWriter())) + .isTrue(); assertNonCanonicalBlobSidecarKeys( blobSidecar2_0.getSlot(), blobSidecar5_0.getSlot(), @@ -458,8 +493,15 @@ public void verifyNonCanonicalBlobsLifecycle(final DatabaseContext context) thro blobSidecar5_0.getSlot(), List.of(blobSidecar5_0))); assertThat(database.getNonCanonicalBlobSidecarColumnCount()).isEqualTo(4L); + // check if the pruned blob was written to disk. Not validating contents here. + assertThat(getSlotBlobsArchiveFile(blobSidecar1_0)).exists(); + assertThat(getSlotBlobsArchiveFile(blobSidecar2_0)).doesNotExist(); + // Pruning up to slot 1: No blobs pruned - assertThat(database.pruneOldestNonCanonicalBlobSidecars(ONE, 10)).isFalse(); + assertThat( + database.pruneOldestNonCanonicalBlobSidecars( + ONE, 10, fileSystemDataArchive.getBlobSidecarWriter())) + .isFalse(); assertNonCanonicalBlobSidecarKeys( blobSidecar2_0.getSlot(), blobSidecar5_0.getSlot(), @@ -474,18 +516,36 @@ public void verifyNonCanonicalBlobsLifecycle(final DatabaseContext context) thro blobSidecar5_0.getSlot(), List.of(blobSidecar5_0))); assertThat(database.getNonCanonicalBlobSidecarColumnCount()).isEqualTo(4L); + // check if the pruned blob was written to disk. Not validating contents here. + assertThat(getSlotBlobsArchiveFile(blobSidecar1_0)).exists(); + assertThat(getSlotBlobsArchiveFile(blobSidecar2_0)).doesNotExist(); + // Prune blobs up to slot 3 - assertThat(database.pruneOldestNonCanonicalBlobSidecars(UInt64.valueOf(3), 10)).isFalse(); + assertThat( + database.pruneOldestNonCanonicalBlobSidecars( + UInt64.valueOf(3), 10, fileSystemDataArchive.getBlobSidecarWriter())) + .isFalse(); assertNonCanonicalBlobSidecarKeys( blobSidecar1_0.getSlot(), blobSidecar5_0.getSlot(), blobSidecarToKey(blobSidecar5_0)); assertNonCanonicalBlobSidecars(Map.of(blobSidecar5_0.getSlot(), List.of(blobSidecar5_0))); assertThat(database.getNonCanonicalBlobSidecarColumnCount()).isEqualTo(1L); + // check if the pruned blob was written to disk. Not validating contents here. + assertThat(getSlotBlobsArchiveFile(blobSidecar2_0)).exists(); + assertThat(getSlotBlobsArchiveFile(blobSidecar3_0)).exists(); + assertThat(getSlotBlobsArchiveFile(blobSidecar5_0)).doesNotExist(); + // Pruning all blobs - assertThat(database.pruneOldestNonCanonicalBlobSidecars(UInt64.valueOf(5), 1)).isTrue(); + assertThat( + database.pruneOldestNonCanonicalBlobSidecars( + UInt64.valueOf(5), 1, fileSystemDataArchive.getBlobSidecarWriter())) + .isTrue(); // No blobs should be left assertNonCanonicalBlobSidecarKeys(ZERO, UInt64.valueOf(10)); assertThat(database.getNonCanonicalBlobSidecarColumnCount()).isEqualTo(0L); + + // check if the pruned blob was written to disk. Not validating contents here. + assertThat(getSlotBlobsArchiveFile(blobSidecar5_0)).exists(); } @TestTemplate @@ -2154,7 +2214,8 @@ public void pruneFinalizedBlocks_shouldRemoveFinalizedBlocks(final DatabaseConte spec.computeEpochAtSlot(finalizedBlock.getSlot()).plus(1), finalizedBlock); assertThat(database.getFinalizedBlockAtSlot(UInt64.valueOf(6))).isPresent(); - final UInt64 lastPrunedSlot1 = database.pruneFinalizedBlocks(UInt64.valueOf(3), 100); + final UInt64 lastPrunedSlot1 = + database.pruneFinalizedBlocks(UInt64.valueOf(3), 100, UInt64.valueOf(10)); assertThat(lastPrunedSlot1).isEqualTo(UInt64.valueOf(3)); assertThat(database.getFinalizedBlockAtSlot(UInt64.valueOf(0))).isEmpty(); assertThat(database.getFinalizedBlockAtSlot(UInt64.valueOf(1))).isEmpty(); @@ -2164,19 +2225,92 @@ public void pruneFinalizedBlocks_shouldRemoveFinalizedBlocks(final DatabaseConte assertThat(database.getFinalizedBlockAtSlot(UInt64.valueOf(5))).isPresent(); assertThat(database.getFinalizedBlockAtSlot(UInt64.valueOf(6))).isPresent(); - final UInt64 lastPrunedSlot2 = database.pruneFinalizedBlocks(UInt64.valueOf(5), 1); + final UInt64 lastPrunedSlot2 = + database.pruneFinalizedBlocks(UInt64.valueOf(5), 1, UInt64.valueOf(10)); assertThat(lastPrunedSlot2).isEqualTo(UInt64.valueOf(4)); assertThat(database.getFinalizedBlockAtSlot(UInt64.valueOf(4))).isEmpty(); assertThat(database.getFinalizedBlockAtSlot(UInt64.valueOf(5))).isPresent(); assertThat(database.getFinalizedBlockAtSlot(UInt64.valueOf(6))).isPresent(); - final UInt64 lastPrunedSlot3 = database.pruneFinalizedBlocks(UInt64.valueOf(4), 1); + final UInt64 lastPrunedSlot3 = + database.pruneFinalizedBlocks(UInt64.valueOf(4), 1, UInt64.valueOf(10)); assertThat(lastPrunedSlot3).isEqualTo(UInt64.valueOf(4)); } + @TestTemplate + public void pruneFinalizedBlocks_UpdatesEarliestAvailableBlockSlot(final DatabaseContext context) + throws Exception { + initialize(context, StateStorageMode.ARCHIVE); + final List blockAndStates = chainBuilder.generateBlocksUpToSlot(5); + addBlocks(blockAndStates); + // Block 7 skipped simulating it was an empty block + final SignedBlockAndState finalizedBlock = chainBuilder.generateBlockAtSlot(7); + addBlocks(finalizedBlock); + justifyAndFinalizeEpoch( + spec.computeEpochAtSlot(finalizedBlock.getSlot()).plus(1), finalizedBlock); + assertThat(database.getFinalizedBlockAtSlot(UInt64.valueOf(6))).isEmpty(); + + final UInt64 lastPrunedSlot1 = + database.pruneFinalizedBlocks(UInt64.valueOf(3), 100, UInt64.valueOf(10)); + assertThat(lastPrunedSlot1).isEqualTo(UInt64.valueOf(3)); + assertThat(database.getEarliestAvailableBlockSlot()).isEqualTo(Optional.of(UInt64.valueOf(4))); + + final UInt64 lastPrunedSlot2 = + database.pruneFinalizedBlocks(UInt64.valueOf(5), 10, UInt64.valueOf(10)); + assertThat(lastPrunedSlot2).isEqualTo(UInt64.valueOf(5)); + // there's no slot 6 because that was purposely skipped so we expect the earliest available + // block slot to be 7 + assertThat(database.getEarliestAvailableBlockSlot()).isEqualTo(Optional.of(UInt64.valueOf(7))); + } + + @TestTemplate + public void pruneFinalizedBlocks_UpdatesEarliestAvailableBlockSlotWhenLimited( + final DatabaseContext context) throws Exception { + initialize(context, StateStorageMode.ARCHIVE); + final List blockAndStates = chainBuilder.generateBlocksUpToSlot(5); + addBlocks(blockAndStates); + // Block 7 skipped simulating it was an empty block + final SignedBlockAndState finalizedBlock = chainBuilder.generateBlockAtSlot(7); + addBlocks(finalizedBlock); + justifyAndFinalizeEpoch( + spec.computeEpochAtSlot(finalizedBlock.getSlot()).plus(1), finalizedBlock); + assertThat(database.getFinalizedBlockAtSlot(UInt64.valueOf(6))).isEmpty(); + + final UInt64 lastPrunedSlot1 = + database.pruneFinalizedBlocks(UInt64.valueOf(3), 2, UInt64.valueOf(10)); + assertThat(lastPrunedSlot1).isEqualTo(UInt64.valueOf(1)); + assertThat(database.getEarliestAvailableBlockSlot()).isEqualTo(Optional.of(UInt64.valueOf(2))); + + final UInt64 lastPrunedSlot2 = + database.pruneFinalizedBlocks(UInt64.valueOf(5), 10, UInt64.valueOf(10)); + assertThat(lastPrunedSlot2).isEqualTo(UInt64.valueOf(5)); + // there's no slot 6 because that was purposely skipped so we expect the earliest available + // block slot to be 7 + assertThat(database.getEarliestAvailableBlockSlot()).isEqualTo(Optional.of(UInt64.valueOf(7))); + } + + @TestTemplate + public void + pruneFinalizedBlocks_ClearEarliestAvailableBlockSlotVariableWhenNoBlocksLeftAfterPrune( + final DatabaseContext context) throws Exception { + initialize(context, StateStorageMode.ARCHIVE); + final List blockAndStates = chainBuilder.generateBlocksUpToSlot(5); + addBlocks(blockAndStates); + // Block 7 skipped simulating it was an empty block + final SignedBlockAndState finalizedBlock = chainBuilder.generateBlockAtSlot(7); + addBlocks(finalizedBlock); + justifyAndFinalizeEpoch( + spec.computeEpochAtSlot(finalizedBlock.getSlot()).plus(1), finalizedBlock); + + final UInt64 lastPrunedSlot1 = + database.pruneFinalizedBlocks(UInt64.valueOf(7), 10, UInt64.valueOf(10)); + assertThat(lastPrunedSlot1).isEqualTo(UInt64.valueOf(7)); + assertThat(database.getEarliestAvailableBlockSlot()).isEqualTo(Optional.empty()); + } + @TestTemplate public void addSidecar_isOperative(final DatabaseContext context) throws IOException { - setupWithSpec(TestSpecFactory.createMinimalEip7594()); + setupWithSpec(TestSpecFactory.createMinimalElectraEip7594()); initialize(context); final DataColumnSidecar dataColumnSidecar = dataStructureUtil.randomDataColumnSidecar(); final DataColumnSlotAndIdentifier columnSlotAndIdentifier = @@ -2190,7 +2324,7 @@ public void addSidecar_isOperative(final DatabaseContext context) throws IOExcep @TestTemplate public void setFirstCustodyIncompleteSlot_isOperative(final DatabaseContext context) throws IOException { - setupWithSpec(TestSpecFactory.createMinimalEip7594()); + setupWithSpec(TestSpecFactory.createMinimalElectraEip7594()); initialize(context); assertThat(database.getFirstCustodyIncompleteSlot().isEmpty()).isTrue(); @@ -2202,7 +2336,7 @@ public void setFirstCustodyIncompleteSlot_isOperative(final DatabaseContext cont @TestTemplate public void setFirstSamplerIncompleteSlot_isOperative(final DatabaseContext context) throws IOException { - setupWithSpec(TestSpecFactory.createMinimalEip7594()); + setupWithSpec(TestSpecFactory.createMinimalElectraEip7594()); initialize(context); assertThat(database.getFirstSamplerIncompleteSlot().isEmpty()).isTrue(); @@ -2215,7 +2349,7 @@ public void setFirstSamplerIncompleteSlot_isOperative(final DatabaseContext cont @SuppressWarnings("JavaCase") public void streamDataColumnIdentifiers_isOperative(final DatabaseContext context) throws IOException { - setupWithSpec(TestSpecFactory.createMinimalEip7594()); + setupWithSpec(TestSpecFactory.createMinimalElectraEip7594()); initialize(context); final SignedBeaconBlockHeader blockHeader1 = dataStructureUtil.randomSignedBeaconBlockHeader(); @@ -2261,7 +2395,7 @@ public void streamDataColumnIdentifiers_isOperative(final DatabaseContext contex @TestTemplate @SuppressWarnings("JavaCase") public void pruneAllSidecars_isOperative(final DatabaseContext context) throws IOException { - setupWithSpec(TestSpecFactory.createMinimalEip7594()); + setupWithSpec(TestSpecFactory.createMinimalElectraEip7594()); initialize(context); final SignedBeaconBlockHeader blockHeader1 = @@ -2492,7 +2626,7 @@ private void assertGetLatestFinalizedRootAtSlotReturnsFinalizedBlocks( } // Check that last block - final SignedBeaconBlock lastFinalizedBlock = finalizedBlocks.get(finalizedBlocks.size() - 1); + final SignedBeaconBlock lastFinalizedBlock = finalizedBlocks.getLast(); for (int i = 0; i < 10; i++) { final UInt64 slot = lastFinalizedBlock.getSlot().plus(i); assertThat(database.getLatestFinalizedBlockAtSlot(slot)) @@ -2753,7 +2887,7 @@ private void setDefaultStorage(final StorageSystem storageSystem) { } private void assertBlobSidecarKeys( - final UInt64 from, final UInt64 to, SlotAndBlockRootAndBlobIndex... keys) { + final UInt64 from, final UInt64 to, final SlotAndBlockRootAndBlobIndex... keys) { try (final Stream blobSidecarsStream = database.streamBlobSidecarKeys(from, to)) { final List keysFromDb = blobSidecarsStream.collect(toList()); @@ -2762,7 +2896,7 @@ private void assertBlobSidecarKeys( } private void assertNonCanonicalBlobSidecarKeys( - final UInt64 from, final UInt64 to, SlotAndBlockRootAndBlobIndex... keys) { + final UInt64 from, final UInt64 to, final SlotAndBlockRootAndBlobIndex... keys) { try (final Stream blobSidecarsStream = database.streamNonCanonicalBlobSidecarKeys(from, to)) { final List keysFromDb = blobSidecarsStream.collect(toList()); @@ -2778,7 +2912,7 @@ private void assertBlobSidecars(final Map> blobSidecar final Map> blobSidecarsDb = new HashMap<>(); try (final Stream blobSidecarsStream = - database.streamBlobSidecarKeys(slots.get(0), slots.get(slots.size() - 1))) { + database.streamBlobSidecarKeys(slots.getFirst(), slots.getLast())) { for (final Iterator iterator = blobSidecarsStream.iterator(); iterator.hasNext(); ) { diff --git a/storage/src/main/java/tech/pegasys/teku/storage/archive/DataArchive.java b/storage/src/main/java/tech/pegasys/teku/storage/archive/DataArchive.java new file mode 100644 index 00000000000..2cad69228e3 --- /dev/null +++ b/storage/src/main/java/tech/pegasys/teku/storage/archive/DataArchive.java @@ -0,0 +1,35 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.storage.archive; + +import java.io.IOException; +import java.util.List; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; + +/** + * Interface for a data archive which stores prunable BlobSidecars outside the data availability + * window and could be extended later to include other data types. It is expected that the + * DataArchive is on disk or externally stored with slow write and recovery times. Initial interface + * is write only, but may be expanded to include read operations later. + */ +public interface DataArchive { + + /** + * Returns the archive writer capable of storing BlobSidecars. + * + * @return a closeable DataArchiveWriter for writing BlobSidecars + * @throws IOException throw exception if it fails to get a writer. + */ + DataArchiveWriter> getBlobSidecarWriter() throws IOException; +} diff --git a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/AttestationContainer.java b/storage/src/main/java/tech/pegasys/teku/storage/archive/DataArchiveWriter.java similarity index 53% rename from ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/AttestationContainer.java rename to storage/src/main/java/tech/pegasys/teku/storage/archive/DataArchiveWriter.java index 125bad285d6..1598c9b8d76 100644 --- a/ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/operations/AttestationContainer.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/archive/DataArchiveWriter.java @@ -11,19 +11,17 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.spec.datastructures.operations; +package tech.pegasys.teku.storage.archive; -import tech.pegasys.teku.infrastructure.ssz.SszContainer; -import tech.pegasys.teku.infrastructure.ssz.SszData; -import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; +import java.io.Closeable; /** - * Interface used to represent different types of attestations ({@link Attestation} and {@link - * tech.pegasys.teku.spec.datastructures.state.PendingAttestation}) + * An interface to allow storing data that is to be pruned from the Database. If the store function + * is successful it returns true, signalling the data can be pruned. If the store function fails, + * the data was not stored and the data should not be pruned. + * + * @param the data to be stored. */ -public interface AttestationContainer extends SszData, SszContainer { - - AttestationData getData(); - - SszBitlist getAggregationBits(); +public interface DataArchiveWriter extends Closeable { + boolean archive(final T data); } diff --git a/storage/src/main/java/tech/pegasys/teku/storage/archive/fsarchive/BlobSidecarJsonWriter.java b/storage/src/main/java/tech/pegasys/teku/storage/archive/fsarchive/BlobSidecarJsonWriter.java new file mode 100644 index 00000000000..ee361c2b1bc --- /dev/null +++ b/storage/src/main/java/tech/pegasys/teku/storage/archive/fsarchive/BlobSidecarJsonWriter.java @@ -0,0 +1,44 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.storage.archive.fsarchive; + +import static java.nio.charset.StandardCharsets.UTF_8; +import static tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition.listOf; + +import java.io.IOException; +import java.io.OutputStream; +import java.util.List; +import java.util.Objects; +import tech.pegasys.teku.infrastructure.json.JsonUtil; +import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; + +public class BlobSidecarJsonWriter { + + public void writeSlotBlobSidecars(final OutputStream out, final List blobSidecars) + throws IOException { + Objects.requireNonNull(out); + Objects.requireNonNull(blobSidecars); + + // Technically not possible as pruner prunes sidecars and not slots. + if (blobSidecars.isEmpty()) { + out.write("[]".getBytes(UTF_8)); + return; + } + + final SerializableTypeDefinition> type = + listOf(blobSidecars.getFirst().getSchema().getJsonTypeDefinition()); + JsonUtil.serializeToBytes(blobSidecars, type, out); + } +} diff --git a/storage/src/main/java/tech/pegasys/teku/storage/archive/fsarchive/FileSystemArchive.java b/storage/src/main/java/tech/pegasys/teku/storage/archive/fsarchive/FileSystemArchive.java new file mode 100644 index 00000000000..f731a1c081e --- /dev/null +++ b/storage/src/main/java/tech/pegasys/teku/storage/archive/fsarchive/FileSystemArchive.java @@ -0,0 +1,137 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.storage.archive.fsarchive; + +import java.io.BufferedWriter; +import java.io.Closeable; +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.OutputStreamWriter; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.List; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; +import tech.pegasys.teku.spec.datastructures.blocks.SlotAndBlockRoot; +import tech.pegasys.teku.storage.archive.DataArchive; +import tech.pegasys.teku.storage.archive.DataArchiveWriter; + +/** + * A file system based implementations of the DataArchive. Writes to a directory using the + * PathResolver method to decide where to write the files. + */ +public class FileSystemArchive implements DataArchive { + static final String INDEX_FILE = "index.dat"; + private static final Logger LOG = LogManager.getLogger(); + + private final Path baseDirectory; + private final BlobSidecarJsonWriter jsonWriter; + + public FileSystemArchive(final Path baseDirectory) { + this.baseDirectory = baseDirectory; + this.jsonWriter = new BlobSidecarJsonWriter(); + } + + @Override + public DataArchiveWriter> getBlobSidecarWriter() throws IOException { + + try { + final File indexFile = baseDirectory.resolve(INDEX_FILE).toFile(); + return new FileSystemBlobSidecarWriter(indexFile); + } catch (IOException e) { + LOG.warn("Unable to create BlobSidecar archive writer", e); + throw e; + } + } + + private class FileSystemBlobSidecarWriter + implements DataArchiveWriter>, Closeable { + final BufferedWriter indexWriter; + + public FileSystemBlobSidecarWriter(final File indexFile) throws IOException { + indexWriter = + new BufferedWriter( + new OutputStreamWriter( + new FileOutputStream(indexFile, true), StandardCharsets.UTF_8)); + } + + @Override + public boolean archive(final List blobSidecars) { + if (blobSidecars == null || blobSidecars.isEmpty()) { + return true; + } + + final SlotAndBlockRoot slotAndBlockRoot = blobSidecars.getFirst().getSlotAndBlockRoot(); + final File file = resolve(slotAndBlockRoot); + if (file.exists()) { + LOG.error("Failed to write BlobSidecar. File exists: {}", file.toString()); + return false; + } + + try { + Files.createDirectories(file.toPath().getParent()); + } catch (IOException e) { + LOG.error( + "Failed to write BlobSidecar. Could not make directories to: {}", + file.getParentFile().toString()); + return false; + } + + try (FileOutputStream output = new FileOutputStream(file)) { + jsonWriter.writeSlotBlobSidecars(output, blobSidecars); + indexWriter.write(formatIndexOutput(slotAndBlockRoot)); + indexWriter.newLine(); + return true; + } catch (IOException | NullPointerException e) { + LOG.error("Failed to write BlobSidecar.", e); + return false; + } + } + + private String formatIndexOutput(final SlotAndBlockRoot slotAndBlockRoot) { + return slotAndBlockRoot.getSlot() + + " " + + slotAndBlockRoot.getBlockRoot().toUnprefixedHexString(); + } + + @Override + public void close() throws IOException { + indexWriter.flush(); + indexWriter.close(); + } + } + + /** + * Given a basePath, slot and block root, return where to store/find the BlobSidecar. Initial + * implementation uses blockRoot as a hex string in the directory of the first two characters. + * + * @param slotAndBlockRoot The slot and block root. + * @return a path of where to store or find the BlobSidecar + */ + public File resolve(final SlotAndBlockRoot slotAndBlockRoot) { + // For blockroot 0x1a2bcd... the directory is basePath/1a/2b/1a2bcd... + // 256 * 256 directories = 65,536. + // Assume 8000 to 10000 blobs per day. With perfect hash distribution, + // all directories have one file after a week. After 1 year, expect 50 files in each directory. + String blockRootString = slotAndBlockRoot.getBlockRoot().toUnprefixedHexString(); + final String dir1 = blockRootString.substring(0, 2); + final String dir2 = blockRootString.substring(2, 4); + final String blobSidecarFilename = + dir1 + File.separator + dir2 + File.separator + blockRootString; + return baseDirectory.resolve(blobSidecarFilename).toFile(); + } +} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/request/v1/beacon/PostStateValidatorsRequest.java b/storage/src/main/java/tech/pegasys/teku/storage/archive/nooparchive/DataArchiveNoopWriter.java similarity index 56% rename from data/serializer/src/main/java/tech/pegasys/teku/api/request/v1/beacon/PostStateValidatorsRequest.java rename to storage/src/main/java/tech/pegasys/teku/storage/archive/nooparchive/DataArchiveNoopWriter.java index 73a94e1154b..0e05ec7b7e5 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/request/v1/beacon/PostStateValidatorsRequest.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/archive/nooparchive/DataArchiveNoopWriter.java @@ -1,5 +1,5 @@ /* - * Copyright Consensys Software Inc., 2023 + * Copyright Consensys Software Inc., 2024 * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at @@ -11,19 +11,18 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.api.request.v1.beacon; +package tech.pegasys.teku.storage.archive.nooparchive; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import java.util.List; +import java.io.IOException; +import tech.pegasys.teku.storage.archive.DataArchiveWriter; -public class PostStateValidatorsRequest { +public class DataArchiveNoopWriter implements DataArchiveWriter { - @JsonProperty("ids") - public final List ids; - - @JsonCreator - public PostStateValidatorsRequest(@JsonProperty("ids") final List ids) { - this.ids = ids; + @Override + public boolean archive(final T data) { + return true; } + + @Override + public void close() throws IOException {} } diff --git a/storage/src/main/java/tech/pegasys/teku/storage/archive/nooparchive/NoopDataArchive.java b/storage/src/main/java/tech/pegasys/teku/storage/archive/nooparchive/NoopDataArchive.java new file mode 100644 index 00000000000..11efeccdcb1 --- /dev/null +++ b/storage/src/main/java/tech/pegasys/teku/storage/archive/nooparchive/NoopDataArchive.java @@ -0,0 +1,30 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.storage.archive.nooparchive; + +import java.util.List; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; +import tech.pegasys.teku.storage.archive.DataArchive; +import tech.pegasys.teku.storage.archive.DataArchiveWriter; + +public class NoopDataArchive implements DataArchive { + + private static final DataArchiveWriter> BLOB_SIDECAR_WRITER = + new DataArchiveNoopWriter<>(); + + @Override + public DataArchiveWriter> getBlobSidecarWriter() { + return BLOB_SIDECAR_WRITER; + } +} diff --git a/storage/src/main/java/tech/pegasys/teku/storage/client/ChainHead.java b/storage/src/main/java/tech/pegasys/teku/storage/client/ChainHead.java index 1539832d807..b37ea2f5043 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/client/ChainHead.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/client/ChainHead.java @@ -43,7 +43,7 @@ private ChainHead( this.stateAndBlockSummaryFuture = stateAndBlockSummaryFuture; } - public static ChainHead create(ChainHead chainHead) { + public static ChainHead create(final ChainHead chainHead) { return new ChainHead( chainHead.blockData, chainHead.executionPayloadBlockHash, @@ -51,15 +51,15 @@ public static ChainHead create(ChainHead chainHead) { chainHead.stateAndBlockSummaryFuture); } - public static ChainHead create(StateAndBlockSummary blockAndState) { + public static ChainHead create(final StateAndBlockSummary stateAndBlockSummary) { return new ChainHead( - blockAndState.getBlockSummary(), - blockAndState.getExecutionBlockHash().orElse(Bytes32.ZERO), + stateAndBlockSummary.getBlockSummary(), + stateAndBlockSummary.getExecutionBlockHash().orElse(Bytes32.ZERO), false, - SafeFuture.completedFuture(blockAndState)); + SafeFuture.completedFuture(stateAndBlockSummary)); } - public static ChainHead create(SignedBlockAndState blockAndState) { + public static ChainHead create(final SignedBlockAndState blockAndState) { return new ChainHead( blockAndState.getBlockSummary(), blockAndState.getExecutionBlockHash().orElse(Bytes32.ZERO), diff --git a/storage/src/main/java/tech/pegasys/teku/storage/client/CombinedChainDataClient.java b/storage/src/main/java/tech/pegasys/teku/storage/client/CombinedChainDataClient.java index 1168b5b2deb..e6f1629d9a9 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/client/CombinedChainDataClient.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/client/CombinedChainDataClient.java @@ -536,7 +536,8 @@ public boolean isChainDataFullyAvailable() { return !recentChainData.isPreGenesis() && !recentChainData.isPreForkChoice(); } - public List getCommitteesFromState(BeaconState state, UInt64 epoch) { + public List getCommitteesFromState( + final BeaconState state, final UInt64 epoch) { List result = new ArrayList<>(); final int slotsPerEpoch = spec.slotsPerEpoch(epoch); final UInt64 startingSlot = spec.computeStartSlotAtEpoch(epoch); @@ -667,7 +668,7 @@ public SafeFuture> getBlobSidecarByKey( } public SafeFuture> getBlobSidecarKeys( - final UInt64 startSlot, final UInt64 endSlot, final UInt64 limit) { + final UInt64 startSlot, final UInt64 endSlot, final long limit) { return historicalChainData.getBlobSidecarKeys(startSlot, endSlot, limit); } diff --git a/storage/src/main/java/tech/pegasys/teku/storage/client/EarliestAvailableBlockSlot.java b/storage/src/main/java/tech/pegasys/teku/storage/client/EarliestAvailableBlockSlot.java index cac44fd685e..a68c5e97191 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/client/EarliestAvailableBlockSlot.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/client/EarliestAvailableBlockSlot.java @@ -34,9 +34,9 @@ public class EarliestAvailableBlockSlot { SafeFuture.completedFuture(Optional.empty()); public EarliestAvailableBlockSlot( - StorageQueryChannel historicalChainData, - TimeProvider timeProvider, - int earliestAvailableBlockSlotFrequency) { + final StorageQueryChannel historicalChainData, + final TimeProvider timeProvider, + final int earliestAvailableBlockSlotFrequency) { this.historicalChainData = historicalChainData; this.timeProvider = timeProvider; this.earliestAvailableBlockSlotFrequency = earliestAvailableBlockSlotFrequency; diff --git a/storage/src/main/java/tech/pegasys/teku/storage/client/LateBlockReorgLogic.java b/storage/src/main/java/tech/pegasys/teku/storage/client/LateBlockReorgLogic.java index c114737f632..3a0ceee2125 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/client/LateBlockReorgLogic.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/client/LateBlockReorgLogic.java @@ -311,7 +311,8 @@ boolean isForkChoiceStableAndFinalizationOk(final UInt64 slot) { && forkChoiceUtil.isFinalizationOk(getStore(), slot); } - boolean isMissingData(Optional maybeHead, Optional maybeCurrentSlot) { + boolean isMissingData( + final Optional maybeHead, final Optional maybeCurrentSlot) { if (maybeHead.isEmpty() || maybeCurrentSlot.isEmpty()) { LOG.debug( "shouldOverrideForkChoiceUpdate head {}, currentSlot {}", diff --git a/storage/src/main/java/tech/pegasys/teku/storage/client/RecentChainData.java b/storage/src/main/java/tech/pegasys/teku/storage/client/RecentChainData.java index a4499d50a89..a372518b4ca 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/client/RecentChainData.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/client/RecentChainData.java @@ -147,11 +147,11 @@ public abstract class RecentChainData implements StoreUpdateHandler { this.spec = spec; } - public void subscribeStoreInitialized(Runnable runnable) { + public void subscribeStoreInitialized(final Runnable runnable) { storeInitializedFuture.always(runnable); } - public void subscribeBestBlockInitialized(Runnable runnable) { + public void subscribeBestBlockInitialized(final Runnable runnable) { bestBlockInitialized.always(runnable); } @@ -192,7 +192,7 @@ public UInt64 getGenesisTimeMillis() { return secondsToMillis(genesisTime); } - public UInt64 computeTimeAtSlot(UInt64 slot) { + public UInt64 computeTimeAtSlot(final UInt64 slot) { return genesisTime.plus(slot.times(spec.getSecondsPerSlot(slot))); } @@ -219,7 +219,7 @@ public boolean isPreForkChoice() { return chainHead.isEmpty(); } - boolean setStore(UpdatableStore store) { + boolean setStore(final UpdatableStore store) { if (!storeInitialized.compareAndSet(false, true)) { return false; } @@ -266,7 +266,8 @@ public NavigableMap getAncestorRootsOnHeadChain( .orElseGet(TreeMap::new); } - public NavigableMap getAncestorsOnFork(final UInt64 startSlot, Bytes32 root) { + public NavigableMap getAncestorsOnFork( + final UInt64 startSlot, final Bytes32 root) { return spec.getAncestorsOnFork(store.getForkChoiceStrategy(), root, startSlot); } @@ -294,7 +295,7 @@ public VoteUpdater startVoteUpdate() { * @param root The new head block root * @param currentSlot The current slot - the slot at which the new head was selected */ - public void updateHead(Bytes32 root, UInt64 currentSlot) { + public void updateHead(final Bytes32 root, final UInt64 currentSlot) { synchronized (this) { if (chainHead.map(head -> head.getRoot().equals(root)).orElse(false)) { LOG.trace("Skipping head update because new head is same as previous head"); @@ -664,7 +665,7 @@ public void setBlockTimelinessFromArrivalTime( lateBlockReorgLogic.setBlockTimelinessFromArrivalTime(block, arrivalTime); } - public void setBlockTimelinessIfEmpty(SignedBeaconBlock block) { + public void setBlockTimelinessIfEmpty(final SignedBeaconBlock block) { lateBlockReorgLogic.setBlockTimelinessFromArrivalTime(block, store.getTimeInMillis()); } } diff --git a/storage/src/main/java/tech/pegasys/teku/storage/client/StorageBackedRecentChainData.java b/storage/src/main/java/tech/pegasys/teku/storage/client/StorageBackedRecentChainData.java index 6b46ac0b421..d3f09c7ad64 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/client/StorageBackedRecentChainData.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/client/StorageBackedRecentChainData.java @@ -169,7 +169,7 @@ private SafeFuture initializeFromStorageWithRetry( } private SafeFuture processStoreFuture( - SafeFuture> storeFuture) { + final SafeFuture> storeFuture) { return storeFuture.thenApply( maybeData -> { if (maybeData.isEmpty()) { diff --git a/storage/src/main/java/tech/pegasys/teku/storage/protoarray/ForkChoiceStrategy.java b/storage/src/main/java/tech/pegasys/teku/storage/protoarray/ForkChoiceStrategy.java index 6658a606c02..019f774db91 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/protoarray/ForkChoiceStrategy.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/protoarray/ForkChoiceStrategy.java @@ -54,7 +54,8 @@ public class ForkChoiceStrategy implements BlockMetadataStore, ReadOnlyForkChoic private Optional proposerBoostRoot = Optional.empty(); private UInt64 proposerBoostAmount = UInt64.ZERO; - private ForkChoiceStrategy(Spec spec, ProtoArray protoArray, List balances) { + private ForkChoiceStrategy( + final Spec spec, final ProtoArray protoArray, final List balances) { this.spec = spec; this.protoArray = protoArray; this.balances = balances; @@ -227,7 +228,10 @@ public Optional getOptimisticallySyncedTransitionBlockRoot(final Bytes3 } void processAttestation( - VoteUpdater voteUpdater, UInt64 validatorIndex, Bytes32 blockRoot, UInt64 targetEpoch) { + final VoteUpdater voteUpdater, + final UInt64 validatorIndex, + final Bytes32 blockRoot, + final UInt64 targetEpoch) { VoteTracker vote = voteUpdater.getVote(validatorIndex); // Not updating anything for equivocated validators if (vote.isEquivocating()) { @@ -240,7 +244,7 @@ void processAttestation( } } - public void setPruneThreshold(int pruneThreshold) { + public void setPruneThreshold(final int pruneThreshold) { protoArrayLock.writeLock().lock(); try { protoArray.setPruneThreshold(pruneThreshold); @@ -259,7 +263,7 @@ public int getTotalTrackedNodeCount() { } @Override - public boolean contains(Bytes32 blockRoot) { + public boolean contains(final Bytes32 blockRoot) { protoArrayLock.readLock().lock(); try { return protoArray.contains(blockRoot); @@ -269,7 +273,7 @@ public boolean contains(Bytes32 blockRoot) { } @Override - public Optional blockSlot(Bytes32 blockRoot) { + public Optional blockSlot(final Bytes32 blockRoot) { protoArrayLock.readLock().lock(); try { return getProtoNode(blockRoot).map(ProtoNode::getBlockSlot); @@ -299,7 +303,7 @@ public Optional executionBlockHash(final Bytes32 blockRoot) { } @Override - public Optional blockParentRoot(Bytes32 blockRoot) { + public Optional blockParentRoot(final Bytes32 blockRoot) { protoArrayLock.readLock().lock(); try { return getProtoNode(blockRoot).map(ProtoNode::getParentRoot); @@ -394,7 +398,7 @@ public List getBlockRootsAtSlot(final UInt64 slot) { * @param processor The callback to invoke for each child-parent pair */ @Override - public void processHashesInChain(final Bytes32 head, NodeProcessor processor) { + public void processHashesInChain(final Bytes32 head, final NodeProcessor processor) { processHashesInChainWhile(head, HaltableNodeProcessor.fromNodeProcessor(processor)); } @@ -407,7 +411,8 @@ public void processHashesInChain(final Bytes32 head, NodeProcessor processor) { * processing */ @Override - public void processHashesInChainWhile(final Bytes32 head, HaltableNodeProcessor nodeProcessor) { + public void processHashesInChainWhile( + final Bytes32 head, final HaltableNodeProcessor nodeProcessor) { protoArrayLock.readLock().lock(); try { final Optional startingNode = getProtoNode(head); @@ -522,13 +527,13 @@ public Optional findCommonAncestor(final Bytes32 root1, final @VisibleForTesting void processBlock( - UInt64 blockSlot, - Bytes32 blockRoot, - Bytes32 parentRoot, - Bytes32 stateRoot, - BlockCheckpoints checkpoints, - UInt64 executionBlockNumber, - Bytes32 executionBlockHash) { + final UInt64 blockSlot, + final Bytes32 blockRoot, + final Bytes32 parentRoot, + final Bytes32 stateRoot, + final BlockCheckpoints checkpoints, + final UInt64 executionBlockNumber, + final Bytes32 executionBlockHash) { protoArray.onBlock( blockSlot, blockRoot, @@ -540,7 +545,7 @@ void processBlock( spec.isBlockProcessorOptimistic(blockSlot)); } - private Optional getProtoNode(Bytes32 blockRoot) { + private Optional getProtoNode(final Bytes32 blockRoot) { return protoArray.getProtoNode(blockRoot); } diff --git a/storage/src/main/java/tech/pegasys/teku/storage/protoarray/ProtoArray.java b/storage/src/main/java/tech/pegasys/teku/storage/protoarray/ProtoArray.java index d3edb9bcded..7e8b8e4dd1c 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/protoarray/ProtoArray.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/protoarray/ProtoArray.java @@ -117,7 +117,7 @@ public List getNodes() { return nodes; } - public void setPruneThreshold(int pruneThreshold) { + public void setPruneThreshold(final int pruneThreshold) { this.pruneThreshold = pruneThreshold; } @@ -126,14 +126,14 @@ public void setPruneThreshold(int pruneThreshold) { * genesis block. */ public void onBlock( - UInt64 blockSlot, - Bytes32 blockRoot, - Bytes32 parentRoot, - Bytes32 stateRoot, - BlockCheckpoints checkpoints, - UInt64 executionBlockNumber, - Bytes32 executionBlockHash, - boolean optimisticallyProcessed) { + final UInt64 blockSlot, + final Bytes32 blockRoot, + final Bytes32 parentRoot, + final Bytes32 stateRoot, + final BlockCheckpoints checkpoints, + final UInt64 executionBlockNumber, + final Bytes32 executionBlockHash, + final boolean optimisticallyProcessed) { if (indices.contains(blockRoot)) { return; } @@ -442,7 +442,7 @@ public int getTotalTrackedNodeCount() { *

  • The number of nodes in `this` is at least `this.pruneThreshold`. * */ - public void maybePrune(Bytes32 finalizedRoot) { + public void maybePrune(final Bytes32 finalizedRoot) { int finalizedIndex = indices .get(finalizedRoot) @@ -520,7 +520,7 @@ public void maybePrune(Bytes32 finalizedRoot) { * */ @SuppressWarnings("StatementWithEmptyBody") - private void maybeUpdateBestChildAndDescendant(int parentIndex, int childIndex) { + private void maybeUpdateBestChildAndDescendant(final int parentIndex, final int childIndex) { ProtoNode child = getNodeByIndex(childIndex); ProtoNode parent = getNodeByIndex(parentIndex); @@ -582,14 +582,14 @@ private void maybeUpdateBestChildAndDescendant(int parentIndex, int childIndex) } /** Helper for maybeUpdateBestChildAndDescendant */ - private void changeToChild(ProtoNode parent, int childIndex) { + private void changeToChild(final ProtoNode parent, final int childIndex) { ProtoNode child = getNodeByIndex(childIndex); parent.setBestChildIndex(Optional.of(childIndex)); parent.setBestDescendantIndex(Optional.of(child.getBestDescendantIndex().orElse(childIndex))); } /** Helper for maybeUpdateBestChildAndDescendant */ - private void changeToNone(ProtoNode parent) { + private void changeToNone(final ProtoNode parent) { parent.setBestChildIndex(Optional.empty()); parent.setBestDescendantIndex(Optional.empty()); } @@ -617,7 +617,7 @@ private boolean nodeLeadsToViableHead(final ProtoNode node) { *

    Any node that has a different finalized or justified epoch should not be viable for the * head. */ - public boolean nodeIsViableForHead(ProtoNode node) { + public boolean nodeIsViableForHead(final ProtoNode node) { if (node.isInvalid()) { return false; } diff --git a/storage/src/main/java/tech/pegasys/teku/storage/protoarray/ProtoArrayScoreCalculator.java b/storage/src/main/java/tech/pegasys/teku/storage/protoarray/ProtoArrayScoreCalculator.java index 715545db2b1..bb518d7530e 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/protoarray/ProtoArrayScoreCalculator.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/protoarray/ProtoArrayScoreCalculator.java @@ -46,15 +46,15 @@ class ProtoArrayScoreCalculator { * */ static LongList computeDeltas( - VoteUpdater store, - int protoArraySize, - Function> getIndexByRoot, - List oldBalances, - List newBalances, - Optional previousProposerBoostRoot, - Optional newProposerBoostRoot, - UInt64 previousBoostAmount, - UInt64 newBoostAmount) { + final VoteUpdater store, + final int protoArraySize, + final Function> getIndexByRoot, + final List oldBalances, + final List newBalances, + final Optional previousProposerBoostRoot, + final Optional newProposerBoostRoot, + final UInt64 previousBoostAmount, + final UInt64 newBoostAmount) { LongList deltas = new LongArrayList(Collections.nCopies(protoArraySize, 0L)); UInt64.rangeClosed(UInt64.ZERO, store.getHighestVotedValidatorIndex()) diff --git a/storage/src/main/java/tech/pegasys/teku/storage/protoarray/ProtoNode.java b/storage/src/main/java/tech/pegasys/teku/storage/protoarray/ProtoNode.java index 55d39db21be..96c8fa18c1f 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/protoarray/ProtoNode.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/protoarray/ProtoNode.java @@ -89,7 +89,7 @@ public class ProtoNode { this.validationStatus = validationStatus; } - public void adjustWeight(long delta) { + public void adjustWeight(final long delta) { if (delta < 0) { UInt64 deltaAbsoluteValue = UInt64.valueOf(Math.abs(delta)); if (deltaAbsoluteValue.isGreaterThan(weight)) { @@ -161,7 +161,7 @@ public void pullUpCheckpoints() { checkpoints = checkpoints.realizeNextEpoch(); } - public void setParentIndex(Optional parentIndex) { + public void setParentIndex(final Optional parentIndex) { this.parentIndex = parentIndex; } @@ -169,7 +169,7 @@ public Optional getBestChildIndex() { return bestChildIndex; } - public void setBestChildIndex(Optional bestChildIndex) { + public void setBestChildIndex(final Optional bestChildIndex) { this.bestChildIndex = bestChildIndex; } @@ -177,7 +177,7 @@ public Optional getBestDescendantIndex() { return bestDescendantIndex; } - public void setBestDescendantIndex(Optional bestDescendantIndex) { + public void setBestDescendantIndex(final Optional bestDescendantIndex) { this.bestDescendantIndex = bestDescendantIndex; } diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/ChainStorage.java b/storage/src/main/java/tech/pegasys/teku/storage/server/ChainStorage.java index edfd27afec9..b6051c332c4 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/ChainStorage.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/ChainStorage.java @@ -80,7 +80,7 @@ public static ChainStorage create( final Database database, final Spec spec, final StateStorageMode dataStorageMode, - int stateRebuildTimeoutSeconds) { + final int stateRebuildTimeoutSeconds) { final int finalizedStateCacheSize = spec.getSlotsPerEpoch(SpecConfig.GENESIS_EPOCH) * 3; return new ChainStorage( database, @@ -139,7 +139,7 @@ public SafeFuture onFinalizedBlocks( @Override public SafeFuture onReconstructedFinalizedState( - BeaconState finalizedState, Bytes32 blockRoot) { + final BeaconState finalizedState, final Bytes32 blockRoot) { return SafeFuture.fromRunnable( () -> database.storeReconstructedFinalizedState(finalizedState, blockRoot)); } @@ -150,7 +150,8 @@ public void onChainInitialized(final AnchorPoint initialAnchor) { } @Override - public SafeFuture onWeakSubjectivityUpdate(WeakSubjectivityUpdate weakSubjectivityUpdate) { + public SafeFuture onWeakSubjectivityUpdate( + final WeakSubjectivityUpdate weakSubjectivityUpdate) { return SafeFuture.fromRunnable( () -> database.updateWeakSubjectivityState(weakSubjectivityUpdate)); } @@ -249,7 +250,7 @@ public SafeFuture> getLatestFinalizedStateAtSlot(final UIn } @Override - public SafeFuture> getLatestAvailableFinalizedState(UInt64 slot) { + public SafeFuture> getLatestAvailableFinalizedState(final UInt64 slot) { if (dataStorageMode.storesFinalizedStates()) { return SafeFuture.of(() -> getLatestAvailableFinalizedStateSync(slot)); } @@ -349,15 +350,13 @@ public SafeFuture> getAllBlobSidecarKeys(fina @Override public SafeFuture> getBlobSidecarKeys( - final UInt64 startSlot, final UInt64 endSlot, final UInt64 limit) { + final UInt64 startSlot, final UInt64 endSlot, final long limit) { return SafeFuture.of( () -> { - final List result; try (final Stream blobSidecars = database.streamBlobSidecarKeys(startSlot, endSlot)) { - result = blobSidecars.limit(limit.longValue()).toList(); + return blobSidecars.limit(limit).toList(); } - return result; }); } diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/CombinedStorageChannelSplitter.java b/storage/src/main/java/tech/pegasys/teku/storage/server/CombinedStorageChannelSplitter.java index 3662a1ff17a..febcd3d3a05 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/CombinedStorageChannelSplitter.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/CombinedStorageChannelSplitter.java @@ -81,7 +81,7 @@ public SafeFuture onFinalizedBlocks( @Override public SafeFuture onReconstructedFinalizedState( - BeaconState finalizedState, Bytes32 blockRoot) { + final BeaconState finalizedState, final Bytes32 blockRoot) { return updateDelegate.onReconstructedFinalizedState(finalizedState, blockRoot); } @@ -237,7 +237,7 @@ public SafeFuture> getAllBlobSidecarKeys(fina @Override public SafeFuture> getBlobSidecarKeys( - UInt64 startSlot, UInt64 endSlot, UInt64 limit) { + final UInt64 startSlot, final UInt64 endSlot, final long limit) { return asyncRunner.runAsync(() -> queryDelegate.getBlobSidecarKeys(startSlot, endSlot, limit)); } diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/Database.java b/storage/src/main/java/tech/pegasys/teku/storage/server/Database.java index 4ac82b23aee..30dc696610e 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/Database.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/Database.java @@ -42,6 +42,7 @@ import tech.pegasys.teku.storage.api.UpdateResult; import tech.pegasys.teku.storage.api.WeakSubjectivityState; import tech.pegasys.teku.storage.api.WeakSubjectivityUpdate; +import tech.pegasys.teku.storage.archive.DataArchiveWriter; public interface Database extends AutoCloseable { @@ -74,12 +75,17 @@ void storeFinalizedBlocks( * of pruneLimit is to softly cap DB operation time. * * @param lastSlotToPrune inclusive, not reached if limit happens first - * @param pruneLimit soft BlobSidecars (not slots) limit + * @param pruneLimit maximum number of slots to prune. + * @param archiveWriter write BlobSidecars to archive when pruning. * @return true if number of pruned blobs reached the pruneLimit, false otherwise */ - boolean pruneOldestBlobSidecars(UInt64 lastSlotToPrune, int pruneLimit); + boolean pruneOldestBlobSidecars( + UInt64 lastSlotToPrune, + int pruneLimit, + final DataArchiveWriter> archiveWriter); - boolean pruneOldestNonCanonicalBlobSidecars(UInt64 lastSlotToPrune, int pruneLimit); + boolean pruneOldestNonCanonicalBlobSidecars( + UInt64 lastSlotToPrune, int pruneLimit, DataArchiveWriter> archiveWriter); @MustBeClosed Stream streamBlobSidecarKeys(UInt64 startSlot, UInt64 endSlot); @@ -215,8 +221,6 @@ default Stream streamBlobSidecarKeys(final UInt64 long getNonCanonicalBlobSidecarColumnCount(); - void migrate(); - Optional getAnchor(); Optional getJustifiedCheckpoint(); @@ -235,9 +239,14 @@ default Stream streamBlobSidecarKeys(final UInt64 * * @param lastSlotToPrune inclusive, not reached if limit happens first * @param pruneLimit slots limit + * @param checkpointInitialSlot * @return actual last pruned slot */ - UInt64 pruneFinalizedBlocks(UInt64 lastSlotToPrune, int pruneLimit); + UInt64 pruneFinalizedBlocks( + UInt64 lastSlotToPrune, int pruneLimit, final UInt64 checkpointInitialSlot); + + Optional pruneFinalizedStates( + Optional lastPrunedSlot, UInt64 lastSlotToPruneStateFor, long pruneLimit); // Sidecars Optional getFirstCustodyIncompleteSlot(); diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/DatabaseStorageModeFileHelper.java b/storage/src/main/java/tech/pegasys/teku/storage/server/DatabaseStorageModeFileHelper.java new file mode 100644 index 00000000000..56147650ec8 --- /dev/null +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/DatabaseStorageModeFileHelper.java @@ -0,0 +1,48 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.storage.server; + +import java.io.IOException; +import java.io.UncheckedIOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.Optional; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +public class DatabaseStorageModeFileHelper { + + private static final Logger LOG = LogManager.getLogger(); + + public static Optional readStateStorageMode(final Path path) { + if (!Files.exists(path)) { + return Optional.empty(); + } + + try { + final StateStorageMode dbStorageMode = + StateStorageMode.valueOf(Files.readString(path).trim()); + LOG.debug("Read previous storage mode as {}", dbStorageMode); + return Optional.of(dbStorageMode); + } catch (final IllegalArgumentException ex) { + throw DatabaseStorageException.unrecoverable( + "Invalid database storage mode file (" + + path + + "). Run your node using '--data-storage-mode' option to configure the correct storage mode.", + ex); + } catch (final IOException ex) { + throw new UncheckedIOException("Failed to read storage mode from file", ex); + } + } +} diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/DatabaseVersion.java b/storage/src/main/java/tech/pegasys/teku/storage/server/DatabaseVersion.java index 6f5df74034a..35a2e81e387 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/DatabaseVersion.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/DatabaseVersion.java @@ -30,7 +30,7 @@ public enum DatabaseVersion { private static final Logger LOG = LogManager.getLogger(); public static final DatabaseVersion DEFAULT_VERSION; - private String value; + private final String value; static { if (isLevelDbSupported()) { diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/StorageConfiguration.java b/storage/src/main/java/tech/pegasys/teku/storage/server/StorageConfiguration.java index c7034371dfe..3a28619081b 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/StorageConfiguration.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/StorageConfiguration.java @@ -13,14 +13,13 @@ package tech.pegasys.teku.storage.server; +import static tech.pegasys.teku.infrastructure.logging.StatusLogger.STATUS_LOG; import static tech.pegasys.teku.storage.server.StateStorageMode.MINIMAL; import static tech.pegasys.teku.storage.server.StateStorageMode.NOT_SET; import static tech.pegasys.teku.storage.server.StateStorageMode.PRUNE; import static tech.pegasys.teku.storage.server.VersionedDatabaseFactory.STORAGE_MODE_PATH; -import java.io.IOException; -import java.io.UncheckedIOException; -import java.nio.file.Files; +import java.io.File; import java.nio.file.Path; import java.time.Duration; import java.util.Optional; @@ -33,7 +32,6 @@ import tech.pegasys.teku.spec.Spec; public class StorageConfiguration { - public static final boolean DEFAULT_STORE_NON_CANONICAL_BLOCKS_ENABLED = false; public static final int DEFAULT_STATE_REBUILD_TIMEOUT_SECONDS = 120; public static final long DEFAULT_STORAGE_FREQUENCY = 2048L; @@ -41,10 +39,16 @@ public class StorageConfiguration { public static final Duration DEFAULT_BLOCK_PRUNING_INTERVAL = Duration.ofMinutes(15); public static final int DEFAULT_BLOCK_PRUNING_LIMIT = 5000; public static final Duration DEFAULT_BLOBS_PRUNING_INTERVAL = Duration.ofMinutes(1); + public static final Duration DEFAULT_STATE_PRUNING_INTERVAL = Duration.ofMinutes(5); + public static final long DEFAULT_STORAGE_RETAINED_SLOTS = 0; + public static final int DEFAULT_STATE_PRUNING_LIMIT = 1; + + // 60/12 = 5 blocks/slots per minute * 6 max blobs per block = 30 blobs per minute at maximum, + // This value prunes blobs by slots, using 12 to allow for catch up. + public static final int DEFAULT_BLOBS_PRUNING_LIMIT = 12; - // 60/12 = 5 blocks per minute * 6 max blobs per block = 30 blobs per minute at maximum, 15 as - // target. Let's configure 48 pruning per minute, so we have some room for catching up. - public static final int DEFAULT_BLOBS_PRUNING_LIMIT = 48; + // Max limit we have tested so far without seeing perf degradation + public static final int MAX_STATE_PRUNE_LIMIT = 100; private final Eth1Address eth1DepositContract; @@ -56,8 +60,12 @@ public class StorageConfiguration { private final int maxKnownNodeCacheSize; private final Duration blockPruningInterval; private final int blockPruningLimit; + private final Duration statePruningInterval; private final Duration blobsPruningInterval; private final int blobsPruningLimit; + private final String blobsArchivePath; + private final long retainedSlots; + private final int statePruningLimit; private final int stateRebuildTimeoutSeconds; @@ -72,7 +80,11 @@ private StorageConfiguration( final int blockPruningLimit, final Duration blobsPruningInterval, final int blobsPruningLimit, - int stateRebuildTimeoutSeconds, + final String blobsArchivePath, + final int stateRebuildTimeoutSeconds, + final long retainedSlots, + final Duration statePruningInterval, + final int statePruningLimit, final Spec spec) { this.eth1DepositContract = eth1DepositContract; this.dataStorageMode = dataStorageMode; @@ -84,7 +96,11 @@ private StorageConfiguration( this.blockPruningLimit = blockPruningLimit; this.blobsPruningInterval = blobsPruningInterval; this.blobsPruningLimit = blobsPruningLimit; + this.blobsArchivePath = blobsArchivePath; this.stateRebuildTimeoutSeconds = stateRebuildTimeoutSeconds; + this.retainedSlots = retainedSlots; + this.statePruningInterval = statePruningInterval; + this.statePruningLimit = statePruningLimit; this.spec = spec; } @@ -136,6 +152,22 @@ public int getBlobsPruningLimit() { return blobsPruningLimit; } + public Optional getBlobsArchivePath() { + return Optional.ofNullable(blobsArchivePath); + } + + public long getRetainedSlots() { + return retainedSlots; + } + + public Duration getStatePruningInterval() { + return statePruningInterval; + } + + public int getStatePruningLimit() { + return statePruningLimit; + } + public Spec getSpec() { return spec; } @@ -154,28 +186,32 @@ public static final class Builder { private int blockPruningLimit = DEFAULT_BLOCK_PRUNING_LIMIT; private Duration blobsPruningInterval = DEFAULT_BLOBS_PRUNING_INTERVAL; private int blobsPruningLimit = DEFAULT_BLOBS_PRUNING_LIMIT; + private String blobsArchivePath = null; private int stateRebuildTimeoutSeconds = DEFAULT_STATE_REBUILD_TIMEOUT_SECONDS; + private Duration statePruningInterval = DEFAULT_STATE_PRUNING_INTERVAL; + private long retainedSlots = DEFAULT_STORAGE_RETAINED_SLOTS; + private int statePruningLimit = DEFAULT_STATE_PRUNING_LIMIT; private Builder() {} - public Builder eth1DepositContract(Eth1Address eth1DepositContract) { + public Builder eth1DepositContract(final Eth1Address eth1DepositContract) { this.eth1DepositContract = eth1DepositContract; return this; } - public Builder eth1DepositContractDefault(Eth1Address eth1DepositContract) { + public Builder eth1DepositContractDefault(final Eth1Address eth1DepositContract) { if (this.eth1DepositContract == null) { this.eth1DepositContract = eth1DepositContract; } return this; } - public Builder dataStorageMode(StateStorageMode dataStorageMode) { + public Builder dataStorageMode(final StateStorageMode dataStorageMode) { this.dataStorageMode = dataStorageMode; return this; } - public Builder dataStorageFrequency(long dataStorageFrequency) { + public Builder dataStorageFrequency(final long dataStorageFrequency) { if (dataStorageFrequency < 0) { throw new InvalidConfigurationException( String.format("Invalid dataStorageFrequency: %d", dataStorageFrequency)); @@ -184,7 +220,7 @@ public Builder dataStorageFrequency(long dataStorageFrequency) { return this; } - public Builder dataStorageCreateDbVersion(DatabaseVersion dataStorageCreateDbVersion) { + public Builder dataStorageCreateDbVersion(final DatabaseVersion dataStorageCreateDbVersion) { this.dataStorageCreateDbVersion = dataStorageCreateDbVersion; return this; } @@ -194,7 +230,7 @@ public Builder dataConfig(final DataConfig dataConfig) { return this; } - public Builder specProvider(Spec spec) { + public Builder specProvider(final Spec spec) { this.spec = spec; return this; } @@ -247,8 +283,52 @@ public Builder blobsPruningLimit(final int blobsPruningLimit) { return this; } + public Builder blobsArchivePath(final String blobsArchivePath) { + if (blobsArchivePath != null) { + File file = Path.of(blobsArchivePath).toFile(); + if (!file.exists()) { + throw new InvalidConfigurationException( + String.format("Blobs archive path does not exist: '%s'", blobsArchivePath)); + } + } + this.blobsArchivePath = blobsArchivePath; + return this; + } + + public Builder retainedSlots(final long retainedSlots) { + if (retainedSlots < 0) { + throw new InvalidConfigurationException( + "Invalid number of slots to retain finalized states for"); + } + this.retainedSlots = retainedSlots; + return this; + } + + public Builder statePruningInterval(final Duration statePruningInterval) { + if (statePruningInterval.isNegative() || statePruningInterval.isZero()) { + throw new InvalidConfigurationException("Block pruning interval must be positive"); + } + if (statePruningInterval.toSeconds() < 30L + || statePruningInterval.toSeconds() > Duration.ofDays(1).toSeconds()) { + throw new InvalidConfigurationException( + "Block pruning interval must be a value between 30 seconds and 1 day"); + } + this.statePruningInterval = statePruningInterval; + return this; + } + + public Builder statePruningLimit(final int statePruningLimit) { + if (statePruningLimit < 0 || statePruningLimit > MAX_STATE_PRUNE_LIMIT) { + throw new InvalidConfigurationException( + String.format("Invalid statePruningLimit: %d", statePruningLimit)); + } + this.statePruningLimit = statePruningLimit; + return this; + } + public StorageConfiguration build() { determineDataStorageMode(); + validateStatePruningConfiguration(); return new StorageConfiguration( eth1DepositContract, dataStorageMode, @@ -260,18 +340,35 @@ public StorageConfiguration build() { blockPruningLimit, blobsPruningInterval, blobsPruningLimit, + blobsArchivePath, stateRebuildTimeoutSeconds, + retainedSlots, + statePruningInterval, + statePruningLimit, spec); } private void determineDataStorageMode() { if (dataConfig != null) { final DataDirLayout dataDirLayout = DataDirLayout.createFrom(dataConfig); + final Path beaconDataDirectory = dataDirLayout.getBeaconDataDirectory(); + + Optional storageModeFromStoredFile; + try { + storageModeFromStoredFile = + DatabaseStorageModeFileHelper.readStateStorageMode( + beaconDataDirectory.resolve(STORAGE_MODE_PATH)); + } catch (final DatabaseStorageException e) { + if (dataStorageMode == NOT_SET) { + throw e; + } else { + storageModeFromStoredFile = Optional.empty(); + } + } + this.dataStorageMode = determineStorageDefault( - dataDirLayout.getBeaconDataDirectory().toFile().exists(), - getStorageModeFromPersistedDatabase(dataDirLayout), - dataStorageMode); + beaconDataDirectory.toFile().exists(), storageModeFromStoredFile, dataStorageMode); } else { if (dataStorageMode.equals(NOT_SET)) { dataStorageMode = PRUNE; @@ -279,27 +376,19 @@ private void determineDataStorageMode() { } } - private Optional getStorageModeFromPersistedDatabase( - final DataDirLayout dataDirLayout) { - final Path dbStorageModeFile = - dataDirLayout.getBeaconDataDirectory().resolve(STORAGE_MODE_PATH); - if (!Files.exists(dbStorageModeFile)) { - return Optional.empty(); - } - try { - final StateStorageMode dbStorageMode = - StateStorageMode.valueOf(Files.readString(dbStorageModeFile).trim()); - LOG.debug("Read previous storage mode as {}", dbStorageMode); - return Optional.of(dbStorageMode); - } catch (final IOException ex) { - throw new UncheckedIOException("Failed to read storage mode from file", ex); + private void validateStatePruningConfiguration() { + if (dataStorageFrequency == 1 && retainedSlots > 0) { + // If we are in tree mode, we don't want to allow the state pruner to run + throw new InvalidConfigurationException( + "State pruner cannot be enabled using tree mode storage"); } } - public Builder stateRebuildTimeoutSeconds(int stateRebuildTimeoutSeconds) { + public Builder stateRebuildTimeoutSeconds(final int stateRebuildTimeoutSeconds) { if (stateRebuildTimeoutSeconds < 10 || stateRebuildTimeoutSeconds > 300) { LOG.warn( - "State rebuild timeout is set outside of sensible defaults of 10 -> 300, {} was defined. Cannot be below 1, will allow the value to exceed 300.", + "State rebuild timeout is set outside of sensible defaults of 10 -> 300, {} was defined. Cannot be below " + + "1, will allow the value to exceed 300.", stateRebuildTimeoutSeconds); } this.stateRebuildTimeoutSeconds = Math.max(stateRebuildTimeoutSeconds, 1); @@ -315,6 +404,20 @@ static StateStorageMode determineStorageDefault( if (modeRequested != NOT_SET) { return modeRequested; } - return maybeHistoricStorageMode.orElse(isExistingStore ? PRUNE : MINIMAL); + + if (maybeHistoricStorageMode.isPresent()) { + final StateStorageMode stateStorageMode = maybeHistoricStorageMode.get(); + if (stateStorageMode == PRUNE) { + STATUS_LOG.warnUsageOfImplicitPruneDataStorageMode(); + } + return stateStorageMode; + } + + if (isExistingStore) { + STATUS_LOG.warnUsageOfImplicitPruneDataStorageMode(); + return PRUNE; + } else { + return MINIMAL; + } } } diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/VersionedDatabaseFactory.java b/storage/src/main/java/tech/pegasys/teku/storage/server/VersionedDatabaseFactory.java index 07d748b60b5..f9c6daddd05 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/VersionedDatabaseFactory.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/VersionedDatabaseFactory.java @@ -23,9 +23,12 @@ import java.util.Optional; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; +import org.apache.tuweni.bytes.Bytes; import org.hyperledger.besu.plugin.services.MetricsSystem; import tech.pegasys.teku.ethereum.execution.types.Eth1Address; +import tech.pegasys.teku.infrastructure.io.SyncDataAccessor; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.networks.Eth2Network; import tech.pegasys.teku.storage.server.kvstore.KvStoreConfiguration; import tech.pegasys.teku.storage.server.kvstore.schema.V6SchemaCombinedSnapshot; import tech.pegasys.teku.storage.server.leveldb.LevelDbDatabaseFactory; @@ -45,14 +48,12 @@ public class VersionedDatabaseFactory implements DatabaseFactory { @VisibleForTesting static final String STORAGE_MODE_PATH = "data-storage-mode.txt"; @VisibleForTesting static final String METADATA_FILENAME = "metadata.yml"; @VisibleForTesting static final String NETWORK_FILENAME = "network.yml"; - private final MetricsSystem metricsSystem; private final File dataDirectory; private final int maxKnownNodeCacheSize; private final File dbDirectory; private final File v5ArchiveDirectory; private final File dbVersionFile; - private final File dbStorageModeFile; private final StateStorageMode stateStorageMode; private final DatabaseVersion createDatabaseVersion; @@ -60,12 +61,18 @@ public class VersionedDatabaseFactory implements DatabaseFactory { private final Eth1Address eth1Address; private final Spec spec; private final boolean storeNonCanonicalBlocks; + private final SyncDataAccessor dbSettingFileSyncDataAccessor; + private final Optional maybeNetwork; public VersionedDatabaseFactory( - final MetricsSystem metricsSystem, final Path dataPath, final StorageConfiguration config) { + final MetricsSystem metricsSystem, + final Path dataPath, + final StorageConfiguration config, + final Optional maybeNetwork) { this.metricsSystem = metricsSystem; this.dataDirectory = dataPath.toFile(); + this.maybeNetwork = maybeNetwork; this.createDatabaseVersion = config.getDataStorageCreateDbVersion(); this.maxKnownNodeCacheSize = config.getMaxKnownNodeCacheSize(); @@ -79,29 +86,8 @@ public VersionedDatabaseFactory( this.dbVersionFile = this.dataDirectory.toPath().resolve(DB_VERSION_PATH).toFile(); this.dbStorageModeFile = this.dataDirectory.toPath().resolve(STORAGE_MODE_PATH).toFile(); - this.stateStorageMode = - getStateStorageModeFromConfigOrDisk(Optional.of(config.getDataStorageMode())); - } - - private StateStorageMode getStateStorageModeFromConfigOrDisk( - final Optional maybeConfiguredStorageMode) { - try { - final File storageModeFile = this.dataDirectory.toPath().resolve(STORAGE_MODE_PATH).toFile(); - if (storageModeFile.exists() && maybeConfiguredStorageMode.isPresent()) { - final StateStorageMode storageModeFromFile = - StateStorageMode.valueOf(Files.readString(storageModeFile.toPath()).trim()); - if (!storageModeFromFile.equals(maybeConfiguredStorageMode.get())) { - LOG.info( - "Storage mode that was persisted differs from the command specified option; file: {}, CLI: {}", - () -> storageModeFromFile, - maybeConfiguredStorageMode::get); - } - } - } catch (IOException e) { - LOG.error("Failed to read storage mode file", e); - } - - return maybeConfiguredStorageMode.orElse(StateStorageMode.DEFAULT_MODE); + dbSettingFileSyncDataAccessor = SyncDataAccessor.create(dataDirectory.toPath()); + this.stateStorageMode = config.getDataStorageMode(); } @Override @@ -186,7 +172,11 @@ public StateStorageMode getStateStorageMode() { private Database createV4Database() { try { DatabaseNetwork.init( - getNetworkFile(), spec.getGenesisSpecConfig().getGenesisForkVersion(), eth1Address); + getNetworkFile(), + spec.getGenesisSpecConfig().getGenesisForkVersion(), + eth1Address, + spec.getGenesisSpecConfig().getDepositChainId(), + maybeNetwork); return RocksDbDatabaseFactory.createV4( metricsSystem, KvStoreConfiguration.v4Settings(dbDirectory.toPath()), @@ -210,7 +200,11 @@ private Database createV5Database() { final V5DatabaseMetadata metaData = V5DatabaseMetadata.init(getMetadataFile(), V5DatabaseMetadata.v5Defaults()); DatabaseNetwork.init( - getNetworkFile(), spec.getGenesisSpecConfig().getGenesisForkVersion(), eth1Address); + getNetworkFile(), + spec.getGenesisSpecConfig().getGenesisForkVersion(), + eth1Address, + spec.getGenesisSpecConfig().getDepositChainId(), + maybeNetwork); return RocksDbDatabaseFactory.createV4( metricsSystem, metaData.getHotDbConfiguration().withDatabaseDir(dbDirectory.toPath()), @@ -253,7 +247,11 @@ private Database createLevelDbV1Database() { final V5DatabaseMetadata metaData = V5DatabaseMetadata.init(getMetadataFile(), V5DatabaseMetadata.v5Defaults()); DatabaseNetwork.init( - getNetworkFile(), spec.getGenesisSpecConfig().getGenesisForkVersion(), eth1Address); + getNetworkFile(), + spec.getGenesisSpecConfig().getGenesisForkVersion(), + eth1Address, + spec.getGenesisSpecConfig().getDepositChainId(), + maybeNetwork); return LevelDbDatabaseFactory.createLevelDb( metricsSystem, metaData.getHotDbConfiguration().withDatabaseDir(dbDirectory.toPath()), @@ -304,7 +302,11 @@ private KvStoreConfiguration initV6Configuration() throws IOException { V6DatabaseMetadata.init(getMetadataFile(), V6DatabaseMetadata.singleDBDefault()); DatabaseNetwork.init( - getNetworkFile(), spec.getGenesisSpecConfig().getGenesisForkVersion(), eth1Address); + getNetworkFile(), + spec.getGenesisSpecConfig().getGenesisForkVersion(), + eth1Address, + spec.getGenesisSpecConfig().getDepositChainId(), + maybeNetwork); return metaData.getSingleDbConfiguration().getConfiguration(); } @@ -326,7 +328,7 @@ private void validateDataPaths() { } } - private void createDirectories(DatabaseVersion dbVersion) { + private void createDirectories(final DatabaseVersion dbVersion) { if (!dbDirectory.mkdirs() && !dbDirectory.isDirectory()) { throw DatabaseStorageException.unrecoverable( String.format( @@ -383,7 +385,9 @@ private void saveDatabaseVersion(final DatabaseVersion version) { private void saveStorageMode(final StateStorageMode storageMode) { try { - Files.writeString(dbStorageModeFile.toPath(), storageMode.name(), StandardCharsets.UTF_8); + dbSettingFileSyncDataAccessor.syncedWrite( + dbStorageModeFile.toPath(), + Bytes.of(storageMode.name().getBytes(StandardCharsets.UTF_8))); } catch (IOException e) { throw DatabaseStorageException.unrecoverable( "Failed to write database storage mode to file " + dbStorageModeFile.getAbsolutePath(), diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/KvStoreConfiguration.java b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/KvStoreConfiguration.java index 2bc0aad71ef..f921f8dbcfa 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/KvStoreConfiguration.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/KvStoreConfiguration.java @@ -38,23 +38,31 @@ * be loaded providing a simple way to experiment with different values without it being fixed at * database creation. */ -@SuppressWarnings("FieldMayBeFinal") +@SuppressWarnings("FieldCanBeFinal") @JsonIgnoreProperties(ignoreUnknown = true) public class KvStoreConfiguration { - public static final int DEFAULT_MAX_OPEN_FILES = 128; + public static final int DEFAULT_MAX_OPEN_FILES = 1024; public static final int DEFAULT_LEVELDB_BLOCK_SIZE = 4096; - public static final int DEFAULT_LEVELDB_WRITE_BUFFER_SIZE = 4194304; + public static final int DEFAULT_LEVELDB_WRITE_BUFFER_SIZE = 4_194_304; public static final int DEFAULT_LEVELDB_MAX_OPEN_FILES = 1000; public static final int DEFAULT_MAX_BACKGROUND_JOBS = 6; public static final int DEFAULT_BACKGROUND_THREAD_COUNT = 6; - public static final long DEFAULT_CACHE_CAPACITY = 8 << 20; + public static final long DEFAULT_CACHE_CAPACITY = 8 << 20; // 8MB public static final long DEFAULT_WRITE_BUFFER_CAPACITY = 128 << 20; private static final boolean DEFAULT_OPTIMISE_FOR_SMALL_DB = false; + /** RocksDb number of log files to keep on disk */ + public static final long NUMBER_OF_LOG_FILES_TO_KEEP = 5; + + /** RocksDb Time to roll a log file (1 day = 3600 * 24 seconds) */ + public static final long TIME_TO_ROLL_LOG_FILE = 86_400L; + + public static final long ROCKSDB_BLOCK_SIZE = 32_768; + /* --------------- Safe to Change Properties ------------ */ @JsonProperty(value = "maxOpenFiles", access = Access.WRITE_ONLY) @@ -88,7 +96,7 @@ public class KvStoreConfiguration { /* --------------- Fixed Properties ------------ */ @JsonProperty("compressionType") - private CompressionType compressionType = CompressionType.NO_COMPRESSION; + private CompressionType compressionType = CompressionType.LZ4_COMPRESSION; @JsonProperty("bottomMostCompressionType") private CompressionType bottomMostCompressionType = CompressionType.NO_COMPRESSION; diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/KvStoreDatabase.java b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/KvStoreDatabase.java index 51ff5f6a595..da6c32295bc 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/KvStoreDatabase.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/KvStoreDatabase.java @@ -14,10 +14,10 @@ package tech.pegasys.teku.storage.server.kvstore; import static com.google.common.base.Preconditions.checkNotNull; +import static java.util.stream.Collectors.groupingBy; import static tech.pegasys.teku.infrastructure.logging.DbLogger.DB_LOGGER; import static tech.pegasys.teku.infrastructure.logging.StatusLogger.STATUS_LOG; import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ONE; -import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ZERO; import com.google.common.annotations.VisibleForTesting; import com.google.errorprone.annotations.MustBeClosed; @@ -73,6 +73,7 @@ import tech.pegasys.teku.storage.api.UpdateResult; import tech.pegasys.teku.storage.api.WeakSubjectivityState; import tech.pegasys.teku.storage.api.WeakSubjectivityUpdate; +import tech.pegasys.teku.storage.archive.DataArchiveWriter; import tech.pegasys.teku.storage.server.Database; import tech.pegasys.teku.storage.server.StateStorageMode; import tech.pegasys.teku.storage.server.kvstore.dataaccess.CombinedKvStoreDao; @@ -324,12 +325,34 @@ protected void storeFinalizedBlocksToDao( .forEach(updater::addBlobSidecar); }); + needToUpdateEarliestBlockSlot(blocks.stream().findFirst()) + .ifPresent(updater::setEarliestBlockSlot); needToUpdateEarliestBlobSidecarSlot(maybeEarliestBlobSidecar) .ifPresent(updater::setEarliestBlobSidecarSlot); updater.commit(); } } + private Optional needToUpdateEarliestBlockSlot( + final Optional maybeNewEarliestBlockSlot) { + // New value is absent - not updating + if (maybeNewEarliestBlockSlot.isEmpty()) { + return Optional.empty(); + } + // New value is present, value from DB is absent - updating + final Optional maybeEarliestFinalizedBlockSlotDb = dao.getEarliestFinalizedBlockSlot(); + if (maybeEarliestFinalizedBlockSlotDb.isEmpty()) { + return maybeNewEarliestBlockSlot.map(SignedBeaconBlock::getSlot); + } + // New value is smaller than value from DB - updating + final UInt64 newEarliestBlockSlot = maybeNewEarliestBlockSlot.get().getSlot(); + if (newEarliestBlockSlot.isLessThan(maybeEarliestFinalizedBlockSlotDb.get())) { + return maybeNewEarliestBlockSlot.map(SignedBeaconBlock::getSlot); + } else { + return Optional.empty(); + } + } + private Optional needToUpdateEarliestBlobSidecarSlot( final Optional maybeNewEarliestBlobSidecarSlot) { // New value is absent - not updating @@ -369,9 +392,6 @@ public long getNonCanonicalBlobSidecarColumnCount() { return dao.getNonCanonicalBlobSidecarColumnCount(); } - @Override - public void migrate() {} - @Override public void deleteHotBlocks(final Set blockRootsToDelete) { try (final HotUpdater updater = hotUpdater()) { @@ -381,7 +401,8 @@ public void deleteHotBlocks(final Set blockRootsToDelete) { } @Override - public UInt64 pruneFinalizedBlocks(final UInt64 lastSlotToPrune, final int pruneLimit) { + public UInt64 pruneFinalizedBlocks( + final UInt64 lastSlotToPrune, final int pruneLimit, final UInt64 checkpointInitialSlot) { final Optional earliestBlockSlot = dao.getEarliestFinalizedBlock().map(SignedBeaconBlock::getSlot); LOG.debug( @@ -390,14 +411,18 @@ public UInt64 pruneFinalizedBlocks(final UInt64 lastSlotToPrune, final int prune if (earliestBlockSlot.isEmpty()) { return lastSlotToPrune; } - return pruneToBlock(lastSlotToPrune, pruneLimit); + return pruneToBlock(lastSlotToPrune, pruneLimit, checkpointInitialSlot); } - private UInt64 pruneToBlock(final UInt64 lastSlotToPrune, final int pruneLimit) { + private UInt64 pruneToBlock( + final UInt64 lastSlotToPrune, final int pruneLimit, final UInt64 checkpointInitialSlot) { final List> blocksToPrune; + final Optional earliestSlotAvailableAfterPrune; LOG.debug("Pruning finalized blocks to slot {} (included)", lastSlotToPrune); try (final Stream stream = dao.streamFinalizedBlocks(UInt64.ZERO, lastSlotToPrune)) { + // get an extra block to set earliest finalized block slot available after pruning runs + // ensuring it is an existing block in the DB blocksToPrune = stream.limit(pruneLimit).map(block -> Pair.of(block.getSlot(), block.getRoot())).toList(); } @@ -406,17 +431,30 @@ private UInt64 pruneToBlock(final UInt64 lastSlotToPrune, final int pruneLimit) LOG.debug("No finalized blocks to prune up to {} slot", lastSlotToPrune); return lastSlotToPrune; } - final UInt64 lastPrunedBlockSlot = blocksToPrune.get(blocksToPrune.size() - 1).getKey(); + + try (final Stream stream = + dao.streamFinalizedBlocks(UInt64.ZERO, checkpointInitialSlot)) { + + earliestSlotAvailableAfterPrune = + stream + .map(SignedBeaconBlock::getSlot) + .filter(slot -> slot.isGreaterThan(blocksToPrune.getLast().getLeft())) + .findFirst(); + } + + final UInt64 lastPrunedBlockSlot = blocksToPrune.getLast().getKey(); LOG.debug( "Pruning {} finalized blocks, last block slot is {}", blocksToPrune.size(), lastPrunedBlockSlot); - deleteFinalizedBlocks(blocksToPrune); + deleteFinalizedBlocks(blocksToPrune, earliestSlotAvailableAfterPrune); return blocksToPrune.size() < pruneLimit ? lastSlotToPrune : lastPrunedBlockSlot; } - private void deleteFinalizedBlocks(final List> blocksToPrune) { + private void deleteFinalizedBlocks( + final List> blocksToPrune, + final Optional earliestSlotAvailableAfterPrune) { if (blocksToPrune.size() > 0) { if (blocksToPrune.size() < 20) { LOG.debug( @@ -429,7 +467,86 @@ private void deleteFinalizedBlocks(final List> blocksToPru try (final FinalizedUpdater updater = finalizedUpdater()) { blocksToPrune.forEach( pair -> updater.deleteFinalizedBlock(pair.getLeft(), pair.getRight())); + earliestSlotAvailableAfterPrune.ifPresentOrElse( + updater::setEarliestBlockSlot, updater::deleteEarliestBlockSlot); + updater.commit(); + } + } + } + + @Override + public Optional pruneFinalizedStates( + final Optional lastPrunedSlot, final UInt64 lastSlotToPrune, final long pruneLimit) { + final Optional earliestFinalizedStateSlot; + + if (lastPrunedSlot.isEmpty()) { + earliestFinalizedStateSlot = dao.getEarliestFinalizedStateSlot(); + } else { + earliestFinalizedStateSlot = lastPrunedSlot; + } + + LOG.debug( + "Earliest finalized state stored is for slot {}", + () -> + earliestFinalizedStateSlot.isEmpty() + ? "EMPTY" + : earliestFinalizedStateSlot.get().toString()); + return earliestFinalizedStateSlot + .map(uInt64 -> pruneFinalizedStateForSlots(uInt64, lastSlotToPrune, pruneLimit)) + .or(() -> Optional.of(lastSlotToPrune)); + } + + private UInt64 pruneFinalizedStateForSlots( + final UInt64 earliestFinalizedStateSlot, + final UInt64 lastSlotToPrune, + final long pruneLimit) { + final List>> slotsToPruneStateFor; + + try (final Stream stream = + dao.streamFinalizedStateSlots(earliestFinalizedStateSlot, lastSlotToPrune)) { + slotsToPruneStateFor = + stream + .limit(pruneLimit) + .map( + slot -> + Pair.of( + slot, + dao.getFinalizedBlockAtSlot(slot).map(SignedBeaconBlock::getStateRoot))) + .toList(); + } + if (slotsToPruneStateFor.isEmpty()) { + LOG.debug("No finalized state to prune up to {} slot", lastSlotToPrune); + return lastSlotToPrune; + } + + final UInt64 lastPrunedSlot = slotsToPruneStateFor.getLast().getLeft(); + + deleteFinalizedStatesForSlot(slotsToPruneStateFor); + + return slotsToPruneStateFor.size() < pruneLimit ? lastSlotToPrune : lastPrunedSlot; + } + + private void deleteFinalizedStatesForSlot( + final List>> slotsToPruneStateFor) { + if (!slotsToPruneStateFor.isEmpty()) { + if (slotsToPruneStateFor.size() < 20) { + LOG.debug( + "Received finalized slots ({}) to delete state", + () -> slotsToPruneStateFor.stream().map(Pair::getLeft).toList()); + } else { + LOG.debug("Received {} finalized slots to delete state", slotsToPruneStateFor.size()); + } + + try (final FinalizedUpdater updater = finalizedUpdater()) { + slotsToPruneStateFor.forEach( + pair -> { + updater.deleteFinalizedState(pair.getLeft()); + pair.getRight().ifPresent(updater::deleteFinalizedStateRoot); + }); + updater.commit(); + } catch (Exception e) { + LOG.error("Failed to prune finalized states", e); } } } @@ -505,6 +622,7 @@ public void storeInitialAnchor(final AnchorPoint initialAnchor) { && spec.atSlot(initialAnchor.getSlot()) .getMilestone() .isGreaterThanOrEqualTo(SpecMilestone.DENEB)) { + updater.setEarliestBlockSlot(initialAnchor.getSlot()); updater.setEarliestBlobSidecarSlot(initialAnchor.getSlot()); } @@ -568,7 +686,7 @@ public void storeFinalizedBlocks( } @Override - public void updateWeakSubjectivityState(WeakSubjectivityUpdate weakSubjectivityUpdate) { + public void updateWeakSubjectivityState(final WeakSubjectivityUpdate weakSubjectivityUpdate) { try (final HotUpdater updater = hotUpdater()) { Optional checkpoint = weakSubjectivityUpdate.getWeakSubjectivityCheckpoint(); checkpoint.ifPresentOrElse( @@ -578,14 +696,15 @@ public void updateWeakSubjectivityState(WeakSubjectivityUpdate weakSubjectivityU } @Override - public void storeReconstructedFinalizedState(BeaconState state, Bytes32 blockRoot) { + public void storeReconstructedFinalizedState(final BeaconState state, final Bytes32 blockRoot) { try (final FinalizedUpdater updater = finalizedUpdater()) { updater.addReconstructedFinalizedState(blockRoot, state); handleAddFinalizedStateRoot(state, updater); } } - private void handleAddFinalizedStateRoot(BeaconState state, FinalizedUpdater updater) { + private void handleAddFinalizedStateRoot( + final BeaconState state, final FinalizedUpdater updater) { final Optional maybeLastState = getLatestAvailableFinalizedState(state.getSlot().minusMinZero(ONE)); maybeLastState.ifPresentOrElse( @@ -801,21 +920,27 @@ public Optional getNonCanonicalBlobSidecar(final SlotAndBlockRootAn } @Override - public boolean pruneOldestBlobSidecars(final UInt64 lastSlotToPrune, final int pruneLimit) { + public boolean pruneOldestBlobSidecars( + final UInt64 lastSlotToPrune, + final int pruneLimit, + final DataArchiveWriter> archiveWriter) { try (final Stream prunableBlobKeys = streamBlobSidecarKeys(UInt64.ZERO, lastSlotToPrune); final FinalizedUpdater updater = finalizedUpdater()) { - return pruneBlobSidecars(pruneLimit, prunableBlobKeys, updater, false); + return pruneBlobSidecars(pruneLimit, prunableBlobKeys, updater, archiveWriter, false); } } @Override public boolean pruneOldestNonCanonicalBlobSidecars( - final UInt64 lastSlotToPrune, final int pruneLimit) { + final UInt64 lastSlotToPrune, + final int pruneLimit, + final DataArchiveWriter> archiveWriter) { try (final Stream prunableNoncanonicalBlobKeys = streamNonCanonicalBlobSidecarKeys(UInt64.ZERO, lastSlotToPrune); final FinalizedUpdater updater = finalizedUpdater()) { - return pruneBlobSidecars(pruneLimit, prunableNoncanonicalBlobKeys, updater, true); + return pruneBlobSidecars( + pruneLimit, prunableNoncanonicalBlobKeys, updater, archiveWriter, true); } } @@ -823,35 +948,64 @@ private boolean pruneBlobSidecars( final int pruneLimit, final Stream prunableBlobKeys, final FinalizedUpdater updater, - final boolean nonCanonicalblobSidecars) { - int remaining = pruneLimit; + final DataArchiveWriter> archiveWriter, + final boolean nonCanonicalBlobSidecars) { + int pruned = 0; Optional earliestBlobSidecarSlot = Optional.empty(); - for (final Iterator it = prunableBlobKeys.iterator(); - it.hasNext(); ) { - --remaining; - final boolean finished = remaining < 0; - final SlotAndBlockRootAndBlobIndex key = it.next(); - // Before we finish we should check that there are no BlobSidecars left in the same slot - if (finished && key.getBlobIndex().equals(ZERO)) { + + // Group the BlobSidecars by slot. Potential for higher memory usage + // if it hasn't been pruned in a while + final Map> prunableMap = + prunableBlobKeys.collect(groupingBy(SlotAndBlockRootAndBlobIndex::getSlot)); + + // pruneLimit is the number of slots to prune, not the number of BlobSidecars + final List slots = prunableMap.keySet().stream().sorted().limit(pruneLimit).toList(); + for (final UInt64 slot : slots) { + final List keys = prunableMap.get(slot); + + // Retrieve the BlobSidecars for archiving. + final List blobSidecars = + keys.stream() + .map( + nonCanonicalBlobSidecars + ? this::getNonCanonicalBlobSidecar + : this::getBlobSidecar) + .filter(Optional::isPresent) + .map(Optional::get) + .toList(); + + // Just warn if we failed to find all the BlobSidecars. + if (keys.size() != blobSidecars.size()) { + LOG.warn("Failed to retrieve BlobSidecars for keys: {}", keys); + } + + // Attempt to archive the BlobSidecars. + final boolean blobSidecarArchived = archiveWriter.archive(blobSidecars); + if (!blobSidecarArchived) { + LOG.error("Failed to archive and prune BlobSidecars. Stopping pruning"); break; } - if (nonCanonicalblobSidecars) { - updater.removeNonCanonicalBlobSidecar(key); - } else { - earliestBlobSidecarSlot = Optional.of(key.getSlot().plus(1)); - updater.removeBlobSidecar(key); + + // Remove the BlobSidecars from the database. + for (final SlotAndBlockRootAndBlobIndex key : keys) { + if (nonCanonicalBlobSidecars) { + updater.removeNonCanonicalBlobSidecar(key); + } else { + updater.removeBlobSidecar(key); + earliestBlobSidecarSlot = Optional.of(slot.plus(1)); + } } + ++pruned; } - if (!nonCanonicalblobSidecars) { + if (!nonCanonicalBlobSidecars) { earliestBlobSidecarSlot.ifPresent(updater::setEarliestBlobSidecarSlot); } updater.commit(); - // `pruned` will be greater when we reach pruneLimit not on the latest BlobSidecar - // in a slot + // `pruned` will be greater when we reach pruneLimit not on the latest BlobSidecar in a slot return pruned >= pruneLimit; } @@ -917,7 +1071,7 @@ public Optional getFinalizedDepositSnapshot() { } @Override - public void setFinalizedDepositSnapshot(DepositTreeSnapshot finalizedDepositSnapshot) { + public void setFinalizedDepositSnapshot(final DepositTreeSnapshot finalizedDepositSnapshot) { try (final HotUpdater updater = hotUpdater()) { updater.setFinalizedDepositSnapshot(finalizedDepositSnapshot); updater.commit(); @@ -1206,7 +1360,7 @@ private void removeNonCanonicalSidecars( } private void updateFinalizedDataArchiveMode( - Map finalizedChildToParentMap, + final Map finalizedChildToParentMap, final Map finalizedBlocks, final Map finalizedStates) { @@ -1259,7 +1413,7 @@ private void updateFinalizedDataArchiveMode( } private void updateFinalizedDataPruneMode( - Map finalizedChildToParentMap, + final Map finalizedChildToParentMap, final Map finalizedBlocks) { final Optional initialBlockRoot = dao.getAnchor().map(Checkpoint::getRoot); @@ -1324,7 +1478,7 @@ private BeaconBlockSummary getLatestFinalizedBlockSummary() { } private void putFinalizedState( - FinalizedUpdater updater, final Bytes32 blockRoot, final BeaconState state) { + final FinalizedUpdater updater, final Bytes32 blockRoot, final BeaconState state) { if (stateStorageMode.storesFinalizedStates()) { updater.addFinalizedState(blockRoot, state); updater.addFinalizedStateRoot(state.hashTreeRoot(), state.getSlot()); diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/CombinedKvStoreDao.java b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/CombinedKvStoreDao.java index 78e99b83784..f2f0941ca73 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/CombinedKvStoreDao.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/CombinedKvStoreDao.java @@ -269,7 +269,10 @@ public Optional getFinalizedBlockAtSlot(final UInt64 slot) { @Override public Optional getEarliestFinalizedBlockSlot() { - return db.getFirstEntry(schema.getColumnFinalizedBlocksBySlot()).map(ColumnEntry::getKey); + return db.get(schema.getVariableEarliestBlockSlot()) + .or( + () -> + db.getFirstEntry(schema.getColumnFinalizedBlocksBySlot()).map(ColumnEntry::getKey)); } @Override @@ -277,6 +280,11 @@ public Optional getEarliestFinalizedBlock() { return db.getFirstEntry(schema.getColumnFinalizedBlocksBySlot()).map(ColumnEntry::getValue); } + @Override + public Optional getEarliestFinalizedStateSlot() { + return stateStorageLogic.getEarliestAvailableFinalizedStateSlot(db, schema); + } + @Override public Optional getLatestFinalizedBlockAtSlot(final UInt64 slot) { return db.getFloorEntry(schema.getColumnFinalizedBlocksBySlot(), slot) @@ -338,16 +346,12 @@ public Optional getOptimisticTransitionBlockSlot() { @Override public Optional getBlobSidecar(final SlotAndBlockRootAndBlobIndex key) { - return db.get( - schema.getColumnBlobSidecarBySlotRootBlobIndex(), - new SlotAndBlockRootAndBlobIndex(key.getSlot(), key.getBlockRoot(), key.getBlobIndex())); + return db.get(schema.getColumnBlobSidecarBySlotRootBlobIndex(), key); } @Override public Optional getNonCanonicalBlobSidecar(final SlotAndBlockRootAndBlobIndex key) { - return db.get( - schema.getColumnNonCanonicalBlobSidecarBySlotRootBlobIndex(), - new SlotAndBlockRootAndBlobIndex(key.getSlot(), key.getBlockRoot(), key.getBlobIndex())); + return db.get(schema.getColumnNonCanonicalBlobSidecarBySlotRootBlobIndex(), key); } @MustBeClosed @@ -535,7 +539,7 @@ public Optional getSidecar(final DataColumnSlotAndIdentifier identifier) @Override @MustBeClosed public Stream streamDataColumnIdentifiers( - UInt64 startSlot, UInt64 endSlot) { + final UInt64 startSlot, final UInt64 endSlot) { return db.streamKeys( schema.getColumnSidecarByColumnSlotAndIdentifier(), new DataColumnSlotAndIdentifier(startSlot, MIN_BLOCK_ROOT, UInt64.ZERO), @@ -544,7 +548,7 @@ public Stream streamDataColumnIdentifiers( @Override public List getDataColumnIdentifiers( - SlotAndBlockRoot slotAndBlockRoot) { + final SlotAndBlockRoot slotAndBlockRoot) { try (final Stream columnSlotAndIdentifierStream = db.streamKeys( schema.getColumnSidecarByColumnSlotAndIdentifier(), @@ -571,7 +575,9 @@ static class V4CombinedUpdater implements CombinedUpda private final FinalizedStateUpdater stateStorageUpdater; V4CombinedUpdater( - final KvStoreAccessor db, final S schema, FinalizedStateUpdater stateStorageUpdater) { + final KvStoreAccessor db, + final S schema, + final FinalizedStateUpdater stateStorageUpdater) { this.transaction = db.startTransaction(); this.db = db; this.schema = schema; @@ -604,7 +610,7 @@ public void setFinalizedCheckpoint(final Checkpoint checkpoint) { } @Override - public void setWeakSubjectivityCheckpoint(Checkpoint checkpoint) { + public void setWeakSubjectivityCheckpoint(final Checkpoint checkpoint) { transaction.put(schema.getVariableWeakSubjectivityCheckpoint(), checkpoint); } @@ -694,6 +700,16 @@ public void setEarliestBlobSidecarSlot(final UInt64 slot) { transaction.put(schema.getVariableEarliestBlobSidecarSlot(), slot); } + @Override + public void setEarliestBlockSlot(final UInt64 slot) { + transaction.put(schema.getVariableEarliestBlockSlot(), slot); + } + + @Override + public void deleteEarliestBlockSlot() { + transaction.delete(schema.getVariableEarliestBlockSlot()); + } + @Override public void commit() { // Commit db updates @@ -762,7 +778,12 @@ public void addFinalizedState(final Bytes32 blockRoot, final BeaconState state) } @Override - public void addReconstructedFinalizedState(Bytes32 blockRoot, BeaconState state) { + public void deleteFinalizedState(final UInt64 slot) { + stateStorageUpdater.deleteFinalizedState(transaction, schema, slot); + } + + @Override + public void addReconstructedFinalizedState(final Bytes32 blockRoot, final BeaconState state) { stateStorageUpdater.addReconstructedFinalizedState(db, transaction, schema, state); } @@ -771,6 +792,11 @@ public void addFinalizedStateRoot(final Bytes32 stateRoot, final UInt64 slot) { transaction.put(schema.getColumnSlotsByFinalizedStateRoot(), stateRoot, slot); } + @Override + public void deleteFinalizedStateRoot(final Bytes32 stateRoot) { + transaction.delete(schema.getColumnSlotsByFinalizedStateRoot(), stateRoot); + } + @Override public void setOptimisticTransitionBlockSlot(final Optional transitionBlockSlot) { if (transitionBlockSlot.isPresent()) { diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/KvStoreCombinedDao.java b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/KvStoreCombinedDao.java index ea6236442eb..6f8f2f9ab08 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/KvStoreCombinedDao.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/KvStoreCombinedDao.java @@ -69,6 +69,8 @@ public interface KvStoreCombinedDao extends AutoCloseable { Optional getEarliestFinalizedBlock(); + Optional getEarliestFinalizedStateSlot(); + Optional getLatestFinalizedBlockAtSlot(UInt64 slot); List getNonCanonicalBlocksAtSlot(UInt64 slot); @@ -249,10 +251,14 @@ interface FinalizedUpdater extends AutoCloseable { void addFinalizedState(final Bytes32 blockRoot, final BeaconState state); + void deleteFinalizedState(final UInt64 slot); + void addReconstructedFinalizedState(final Bytes32 blockRoot, final BeaconState state); void addFinalizedStateRoot(final Bytes32 stateRoot, final UInt64 slot); + void deleteFinalizedStateRoot(final Bytes32 stateRoot); + void setOptimisticTransitionBlockSlot(final Optional transitionBlockSlot); void addNonCanonicalRootAtSlot(final UInt64 slot, final Set blockRoots); @@ -269,6 +275,10 @@ interface FinalizedUpdater extends AutoCloseable { void setEarliestBlobSidecarSlot(UInt64 slot); + void setEarliestBlockSlot(UInt64 slot); + + void deleteEarliestBlockSlot(); + void setFirstCustodyIncompleteSlot(UInt64 slot); void setFirstSamplerIncompleteSlot(UInt64 slot); diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/KvStoreCombinedDaoAdapter.java b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/KvStoreCombinedDaoAdapter.java index fa3d2868fbd..5167accd098 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/KvStoreCombinedDaoAdapter.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/KvStoreCombinedDaoAdapter.java @@ -169,6 +169,11 @@ public Optional getEarliestFinalizedBlock() { return finalizedDao.getEarliestFinalizedBlock(); } + @Override + public Optional getEarliestFinalizedStateSlot() { + return finalizedDao.getEarliestFinalizedStateSlot(); + } + @Override public Optional getLatestFinalizedBlockAtSlot(final UInt64 slot) { return finalizedDao.getLatestFinalizedBlockAtSlot(slot); @@ -589,7 +594,12 @@ public void addFinalizedState(final Bytes32 blockRoot, final BeaconState state) } @Override - public void addReconstructedFinalizedState(Bytes32 blockRoot, BeaconState state) { + public void deleteFinalizedState(final UInt64 slot) { + finalizedUpdater.deleteFinalizedState(slot); + } + + @Override + public void addReconstructedFinalizedState(final Bytes32 blockRoot, final BeaconState state) { finalizedUpdater.addReconstructedFinalizedState(blockRoot, state); } @@ -598,6 +608,11 @@ public void addFinalizedStateRoot(final Bytes32 stateRoot, final UInt64 slot) { finalizedUpdater.addFinalizedStateRoot(stateRoot, slot); } + @Override + public void deleteFinalizedStateRoot(final Bytes32 stateRoot) { + finalizedUpdater.deleteFinalizedStateRoot(stateRoot); + } + @Override public void setOptimisticTransitionBlockSlot(final Optional transitionBlockSlot) { finalizedUpdater.setOptimisticTransitionBlockSlot(transitionBlockSlot); @@ -608,6 +623,16 @@ public void setEarliestBlobSidecarSlot(final UInt64 slot) { finalizedUpdater.setEarliestBlobSidecarSlot(slot); } + @Override + public void setEarliestBlockSlot(final UInt64 slot) { + finalizedUpdater.setEarliestBlockSlot(slot); + } + + @Override + public void deleteEarliestBlockSlot() { + finalizedUpdater.deleteEarliestBlockSlot(); + } + @Override public void setFirstCustodyIncompleteSlot(final UInt64 slot) { finalizedUpdater.setFirstCustodyIncompleteSlot(slot); diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/V4FinalizedKvStoreDao.java b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/V4FinalizedKvStoreDao.java index 7ca26a7229e..3d172f41190 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/V4FinalizedKvStoreDao.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/V4FinalizedKvStoreDao.java @@ -67,7 +67,14 @@ public Optional getFinalizedBlockAtSlot(final UInt64 slot) { } public Optional getEarliestFinalizedBlockSlot() { - return db.getFirstEntry(schema.getColumnFinalizedBlocksBySlot()).map(ColumnEntry::getKey); + return db.get(schema.getVariableEarliestBlockSlot()) + .or( + () -> + db.getFirstEntry(schema.getColumnFinalizedBlocksBySlot()).map(ColumnEntry::getKey)); + } + + public Optional getEarliestFinalizedStateSlot() { + return stateStorageLogic.getEarliestAvailableFinalizedStateSlot(db, schema); } public Optional getEarliestFinalizedBlock() { @@ -379,6 +386,11 @@ public void addFinalizedState(final Bytes32 blockRoot, final BeaconState state) stateStorageUpdater.addFinalizedState(db, transaction, schema, state); } + @Override + public void deleteFinalizedState(final UInt64 slot) { + transaction.delete(schema.getColumnFinalizedStatesBySlot(), slot); + } + @Override public void addReconstructedFinalizedState(final Bytes32 blockRoot, final BeaconState state) { stateStorageUpdater.addReconstructedFinalizedState(db, transaction, schema, state); @@ -389,6 +401,11 @@ public void addFinalizedStateRoot(final Bytes32 stateRoot, final UInt64 slot) { transaction.put(schema.getColumnSlotsByFinalizedStateRoot(), stateRoot, slot); } + @Override + public void deleteFinalizedStateRoot(final Bytes32 stateRoot) { + transaction.delete(schema.getColumnSlotsByFinalizedStateRoot(), stateRoot); + } + @Override public void setOptimisticTransitionBlockSlot(final Optional transitionBlockSlot) { if (transitionBlockSlot.isPresent()) { @@ -440,6 +457,16 @@ public void setEarliestBlobSidecarSlot(final UInt64 slot) { transaction.put(schema.getVariableEarliestBlobSidecarSlot(), slot); } + @Override + public void setEarliestBlockSlot(final UInt64 slot) { + transaction.put(schema.getVariableEarliestBlockSlot(), slot); + } + + @Override + public void deleteEarliestBlockSlot() { + transaction.delete(schema.getVariableEarliestBlockSlot()); + } + @Override public void setFirstCustodyIncompleteSlot(final UInt64 slot) { transaction.put(schema.getVariableFirstCustodyIncompleteSlot(), slot); diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/V4FinalizedStateSnapshotStorageLogic.java b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/V4FinalizedStateSnapshotStorageLogic.java index 0d02b753711..cbcd70f3800 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/V4FinalizedStateSnapshotStorageLogic.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/V4FinalizedStateSnapshotStorageLogic.java @@ -39,6 +39,12 @@ public Optional getLatestAvailableFinalizedState( .map(ColumnEntry::getValue); } + @Override + public Optional getEarliestAvailableFinalizedStateSlot( + final KvStoreAccessor db, final S schema) { + return db.getFirstEntry(schema.getColumnFinalizedStatesBySlot()).map(ColumnEntry::getKey); + } + @Override public FinalizedStateUpdater updater() { return new FinalizedStateSnapshotUpdater<>(stateStorageFrequency); @@ -91,7 +97,10 @@ public void addFinalizedState( @Override public void addReconstructedFinalizedState( - KvStoreAccessor db, KvStoreTransaction transaction, S schema, BeaconState state) { + final KvStoreAccessor db, + final KvStoreTransaction transaction, + final S schema, + final BeaconState state) { if (!loadedLastReconstructedStoreState) { lastReconstructedStateStoredSlot = db.getFloorEntry(schema.getColumnFinalizedStatesBySlot(), state.getSlot()) @@ -108,6 +117,12 @@ public void addReconstructedFinalizedState( } } + @Override + public void deleteFinalizedState( + final KvStoreTransaction transaction, final S schema, final UInt64 slot) { + transaction.delete(schema.getColumnFinalizedStatesBySlot(), slot); + } + @Override public void commit() {} diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/V4FinalizedStateStorageLogic.java b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/V4FinalizedStateStorageLogic.java index 9b9286cabd3..7bf883455ec 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/V4FinalizedStateStorageLogic.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/V4FinalizedStateStorageLogic.java @@ -25,6 +25,8 @@ public interface V4FinalizedStateStorageLogic { Optional getLatestAvailableFinalizedState( KvStoreAccessor db, S schema, UInt64 maxSlot); + Optional getEarliestAvailableFinalizedStateSlot(KvStoreAccessor db, S schema); + FinalizedStateUpdater updater(); @MustBeClosed @@ -38,6 +40,8 @@ void addFinalizedState( void addReconstructedFinalizedState( KvStoreAccessor db, KvStoreTransaction transaction, S schema, BeaconState state); + void deleteFinalizedState(KvStoreTransaction transaction, S schema, UInt64 slot); + void commit(); } } diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/V4FinalizedStateTreeStorageLogic.java b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/V4FinalizedStateTreeStorageLogic.java index 448b5f8d03d..da10acdff09 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/V4FinalizedStateTreeStorageLogic.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/V4FinalizedStateTreeStorageLogic.java @@ -49,18 +49,18 @@ public V4FinalizedStateTreeStorageLogic( this.branchNodeStoredCounter = metricsSystem.createLabelledCounter( TekuMetricCategory.STORAGE_FINALIZED_DB, - "state_branch_nodes", + "state_branch_nodes_total", "Number of finalized state tree branch nodes stored vs skipped", "type"); this.leafNodeStoredCounter = metricsSystem.createCounter( TekuMetricCategory.STORAGE_FINALIZED_DB, - "state_leaf_nodes", + "state_leaf_nodes_total", "Number of finalized state tree leaf nodes stored"); statesStoredCounter = metricsSystem.createCounter( TekuMetricCategory.STORAGE_FINALIZED_DB, - "states_stored", + "states_stored_total", "Number of finalized states stored"); } @@ -79,6 +79,12 @@ public Optional getLatestAvailableFinalizedState( GIndexUtil.SELF_G_INDEX)); } + @Override + public Optional getEarliestAvailableFinalizedStateSlot( + final KvStoreAccessor db, final SchemaCombinedTreeState dbSchema) { + return db.getFirstEntry(dbSchema.getColumnFinalizedStateRootsBySlot()).map(ColumnEntry::getKey); + } + @Override public FinalizedStateUpdater updater() { return new StateTreeUpdater( @@ -142,13 +148,21 @@ public void addFinalizedState( @Override public void addReconstructedFinalizedState( - KvStoreAccessor db, - KvStoreTransaction transaction, - SchemaCombinedTreeState schema, - BeaconState state) { + final KvStoreAccessor db, + final KvStoreTransaction transaction, + final SchemaCombinedTreeState schema, + final BeaconState state) { addFinalizedState(db, transaction, schema, state); } + @Override + public void deleteFinalizedState( + final KvStoreTransaction transaction, + final SchemaCombinedTreeState schema, + final UInt64 slot) { + throw new RuntimeException("Tree mode does not support deleting finalized states"); + } + @Override public void commit() { if (nodeStore != null) { diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/V4HotKvStoreDao.java b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/V4HotKvStoreDao.java index eb4d6fed011..567ad9120e5 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/V4HotKvStoreDao.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/V4HotKvStoreDao.java @@ -223,7 +223,7 @@ public void setFinalizedCheckpoint(final Checkpoint checkpoint) { } @Override - public void setWeakSubjectivityCheckpoint(Checkpoint checkpoint) { + public void setWeakSubjectivityCheckpoint(final Checkpoint checkpoint) { transaction.put(schema.getVariableWeakSubjectivityCheckpoint(), checkpoint); } @@ -304,7 +304,7 @@ public void addDepositsFromBlockEvent(final DepositsFromBlockEvent event) { } @Override - public void removeDepositsFromBlockEvent(UInt64 blockNumber) { + public void removeDepositsFromBlockEvent(final UInt64 blockNumber) { transaction.delete(schema.getColumnDepositsFromBlockEvents(), blockNumber); } diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/schema/SchemaCombined.java b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/schema/SchemaCombined.java index 571baf318d2..d97624a9824 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/schema/SchemaCombined.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/schema/SchemaCombined.java @@ -86,6 +86,8 @@ public interface SchemaCombined extends Schema { KvStoreVariable getVariableEarliestBlobSidecarSlot(); + KvStoreVariable getVariableEarliestBlockSlot(); + KvStoreVariable getVariableFinalizedDepositSnapshot(); KvStoreVariable getVariableFirstCustodyIncompleteSlot(); diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/schema/SchemaFinalizedSnapshotStateAdapter.java b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/schema/SchemaFinalizedSnapshotStateAdapter.java index c5a6903f8f1..b561848e961 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/schema/SchemaFinalizedSnapshotStateAdapter.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/schema/SchemaFinalizedSnapshotStateAdapter.java @@ -113,6 +113,10 @@ public KvStoreVariable getVariableEarliestBlobSidecarSlot() { return delegate.getVariableEarliestBlobSidecarSlot(); } + public KvStoreVariable getVariableEarliestBlockSlot() { + return delegate.getVariableEarliestBlockSlot(); + } + public KvStoreVariable getVariableFirstCustodyIncompleteSlot() { return delegate.getVariableFirstCustodyIncompleteSlot(); } @@ -127,6 +131,8 @@ public Map> getVariableMap() { getOptimisticTransitionBlockSlot(), "EARLIEST_BLOB_SIDECAR_SLOT", getVariableEarliestBlobSidecarSlot(), + "EARLIEST_BLOCK_SLOT_AVAILABLE", + getVariableEarliestBlockSlot(), "FIRST_CUSTODY_INCOMPLETE_SLOT", getVariableFirstCustodyIncompleteSlot(), "FIRST_SAMPLER_INCOMPLETE_SLOT", diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/schema/V6SchemaCombined.java b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/schema/V6SchemaCombined.java index fbd9a7c6b11..61e9242bbaf 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/schema/V6SchemaCombined.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/schema/V6SchemaCombined.java @@ -84,6 +84,7 @@ public abstract class V6SchemaCombined implements SchemaCombined { private final KvStoreVariable optimisticTransitionBlockSlot; private final KvStoreVariable earliestBlobSidecarSlot; + private final KvStoreVariable earliestBlockSlot; private final KvStoreVariable firstCustodyIncompleteSlot; private final KvStoreVariable firstSamplerIncompleteSlot; @@ -102,8 +103,9 @@ protected V6SchemaCombined(final Spec spec, final int finalizedOffset) { optimisticTransitionBlockSlot = KvStoreVariable.create(finalizedOffset + 1, UINT64_SERIALIZER); earliestBlobSidecarSlot = KvStoreVariable.create(finalizedOffset + 2, UINT64_SERIALIZER); - firstCustodyIncompleteSlot = KvStoreVariable.create(finalizedOffset + 3, UINT64_SERIALIZER); - firstSamplerIncompleteSlot = KvStoreVariable.create(finalizedOffset + 4, UINT64_SERIALIZER); + earliestBlockSlot = KvStoreVariable.create(finalizedOffset + 3, UINT64_SERIALIZER); + firstCustodyIncompleteSlot = KvStoreVariable.create(finalizedOffset + 4, UINT64_SERIALIZER); + firstSamplerIncompleteSlot = KvStoreVariable.create(finalizedOffset + 5, UINT64_SERIALIZER); } @Override @@ -196,6 +198,11 @@ public KvStoreVariable getVariableEarliestBlobSidecarSlot() { return earliestBlobSidecarSlot; } + @Override + public KvStoreVariable getVariableEarliestBlockSlot() { + return earliestBlockSlot; + } + @Override public KvStoreVariable getVariableFirstCustodyIncompleteSlot() { return firstCustodyIncompleteSlot; @@ -241,6 +248,7 @@ public Map> getVariableMap() { .put("OPTIMISTIC_TRANSITION_BLOCK_SLOT", getOptimisticTransitionBlockSlot()) .put("FINALIZED_DEPOSIT_SNAPSHOT", getVariableFinalizedDepositSnapshot()) .put("EARLIEST_BLOB_SIDECAR_SLOT", getVariableEarliestBlobSidecarSlot()) + .put("EARLIEST_BLOCK_SLOT_AVAILABLE", getVariableEarliestBlockSlot()) .put("FIRST_CUSTODY_INCOMPLETE_SLOT", getVariableFirstCustodyIncompleteSlot()) .put("FIRST_SAMPLER_INCOMPLETE_SLOT", getVariableFirstSamplerIncompleteSlot()) .build(); diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/schema/V6SchemaCombinedTreeState.java b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/schema/V6SchemaCombinedTreeState.java index 43624a7b793..e7f6f8f5e68 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/schema/V6SchemaCombinedTreeState.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/schema/V6SchemaCombinedTreeState.java @@ -175,6 +175,7 @@ public Map> getVariableMap() { .put("OPTIMISTIC_TRANSITION_BLOCK_SLOT", getOptimisticTransitionBlockSlot()) .put("FINALIZED_DEPOSIT_SNAPSHOT", getVariableFinalizedDepositSnapshot()) .put("EARLIEST_BLOB_SIDECAR_SLOT", getVariableEarliestBlobSidecarSlot()) + .put("EARLIEST_BLOCK_SLOT", getVariableEarliestBlockSlot()) .put("FIRST_CUSTODY_INCOMPLETE_SLOT", getVariableFirstCustodyIncompleteSlot()) .put("FIRST_SAMPLER_INCOMPLETE_SLOT", getVariableFirstSamplerIncompleteSlot()) .build(); diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/serialization/DepositsFromBlockEventSerializer.java b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/serialization/DepositsFromBlockEventSerializer.java index d4df9e9a8a5..f0698c576db 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/serialization/DepositsFromBlockEventSerializer.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/serialization/DepositsFromBlockEventSerializer.java @@ -53,7 +53,7 @@ public byte[] serialize(final DepositsFromBlockEvent value) { return bytes.toArrayUnsafe(); } - private Bytes encodeDeposit(Deposit deposit) { + private Bytes encodeDeposit(final Deposit deposit) { return SSZ.encode( depositWriter -> { depositWriter.writeFixedBytes(deposit.getPubkey().toBytesCompressed()); diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/serialization/UInt64Serializer.java b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/serialization/UInt64Serializer.java index 05a13209347..cd21248a90c 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/serialization/UInt64Serializer.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/serialization/UInt64Serializer.java @@ -35,7 +35,7 @@ public byte[] serialize(final UInt64 value) { * @param offset The offset to the UInt64 data. * @return The deserialized UInt64 value. */ - public static UInt64 deserialize(final byte[] data, int offset) { + public static UInt64 deserialize(final byte[] data, final int offset) { return UInt64.fromLongBits( Longs.fromBytes( data[offset], diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/serialization/VoidSerializer.java b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/serialization/VoidSerializer.java index 1faa5f222b9..97b237ddbd7 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/serialization/VoidSerializer.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/serialization/VoidSerializer.java @@ -18,12 +18,12 @@ public class VoidSerializer implements KvStoreSerializer { private static final byte[] VOID_VALUE = new byte[0]; @Override - public Void deserialize(byte[] data) { + public Void deserialize(final byte[] data) { return null; } @Override - public byte[] serialize(Void value) { + public byte[] serialize(final Void value) { return VOID_VALUE; } } diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/leveldb/LevelDbInstance.java b/storage/src/main/java/tech/pegasys/teku/storage/server/leveldb/LevelDbInstance.java index a2a1a5ec867..ef92af2c47b 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/leveldb/LevelDbInstance.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/leveldb/LevelDbInstance.java @@ -75,7 +75,7 @@ public class LevelDbInstance implements KvStoreAccessor { private final Counter closedIteratorsCounter; public LevelDbInstance( - final DB db, final MetricsSystem metricsSystem, MetricCategory metricCategory) { + final DB db, final MetricsSystem metricsSystem, final MetricCategory metricCategory) { this.db = db; openedTransactionsCounter = metricsSystem.createCounter( @@ -268,7 +268,7 @@ public , V> Stream> stream( @Override @MustBeClosed public , V> Stream streamKeys( - KvStoreColumn column, K from, K to) { + final KvStoreColumn column, final K from, final K to) { final byte[] fromBytes = getColumnKey(column, from); final byte[] toBytes = getColumnKey(column, to); return streamKeys(column, fromBytes, toBytes); diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/metadata/V6DatabaseMetadata.java b/storage/src/main/java/tech/pegasys/teku/storage/server/metadata/V6DatabaseMetadata.java index 7ffe5e87ec2..e9fe75ddc59 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/metadata/V6DatabaseMetadata.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/metadata/V6DatabaseMetadata.java @@ -56,7 +56,7 @@ public static class SingleDBMetadata { public SingleDBMetadata() {} - public SingleDBMetadata(KvStoreConfiguration configuration) { + public SingleDBMetadata(final KvStoreConfiguration configuration) { this.configuration = configuration; } @@ -75,7 +75,7 @@ public String toString() { public V6DatabaseMetadata() {} - private V6DatabaseMetadata(KvStoreConfiguration singleDbConfiguration) { + private V6DatabaseMetadata(final KvStoreConfiguration singleDbConfiguration) { this.singleDb = new SingleDBMetadata(singleDbConfiguration); } diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/network/DatabaseNetwork.java b/storage/src/main/java/tech/pegasys/teku/storage/server/network/DatabaseNetwork.java index 5aae6987a00..4f87e6d0001 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/network/DatabaseNetwork.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/network/DatabaseNetwork.java @@ -17,6 +17,7 @@ import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.dataformat.yaml.YAMLFactory; @@ -25,30 +26,49 @@ import java.io.IOException; import java.util.Locale; import java.util.Objects; +import java.util.Optional; import tech.pegasys.teku.ethereum.execution.types.Eth1Address; import tech.pegasys.teku.infrastructure.bytes.Bytes4; +import tech.pegasys.teku.spec.networks.Eth2Network; import tech.pegasys.teku.storage.server.DatabaseStorageException; +@JsonInclude(JsonInclude.Include.NON_NULL) @JsonIgnoreProperties(ignoreUnknown = true) public class DatabaseNetwork { - @JsonProperty("fork_version") + @JsonProperty(value = "fork_version", required = true) @VisibleForTesting final String forkVersion; - @JsonProperty("deposit_contract") + @JsonProperty(value = "deposit_contract", required = true) @VisibleForTesting final String depositContract; + @JsonProperty("deposit_chain_id") + @VisibleForTesting + final Long depositChainId; + @JsonCreator DatabaseNetwork( - @JsonProperty("fork_version") final String forkVersion, - @JsonProperty("deposit_contract") final String depositContract) { + @JsonProperty(value = "fork_version") final String forkVersion, + @JsonProperty(value = "deposit_contract") final String depositContract, + @JsonProperty("deposit_chain_id") final Long depositChainId) { this.forkVersion = forkVersion; this.depositContract = depositContract; + this.depositChainId = depositChainId; + } + + @VisibleForTesting + DatabaseNetwork(final String forkVersion, final String depositContract) { + this(forkVersion, depositContract, null); } public static DatabaseNetwork init( - final File source, Bytes4 forkVersion, Eth1Address depositContract) throws IOException { + final File source, + final Bytes4 forkVersion, + final Eth1Address depositContract, + final Long depositChainId, + final Optional maybeNetwork) + throws IOException { final String forkVersionString = forkVersion.toHexString().toLowerCase(Locale.ROOT); final String depositContractString = depositContract.toHexString().toLowerCase(Locale.ROOT); final ObjectMapper objectMapper = @@ -67,16 +87,35 @@ public static DatabaseNetwork init( formatMessage( "deposit contract", depositContractString, databaseNetwork.depositContract)); } + if (databaseNetwork.depositChainId != null + && maybeNetwork.map(n -> !n.equals(Eth2Network.EPHEMERY)).orElse(true) + && !databaseNetwork.depositChainId.equals(depositChainId)) { + throw DatabaseStorageException.unrecoverable( + formatMessage( + "deposit chain id", + String.valueOf(depositChainId), + String.valueOf(databaseNetwork.depositChainId))); + } + if (databaseNetwork.depositChainId != null + && maybeNetwork.map(n -> n.equals(Eth2Network.EPHEMERY)).orElse(false) + && !databaseNetwork.depositChainId.equals(depositChainId)) { + throw new EphemeryException(); + } return databaseNetwork; } else { DatabaseNetwork databaseNetwork = - new DatabaseNetwork(forkVersionString, depositContractString); + new DatabaseNetwork(forkVersionString, depositContractString, depositChainId); objectMapper.writerFor(DatabaseNetwork.class).writeValue(source, databaseNetwork); return databaseNetwork; } } - private static String formatMessage(String fieldName, String expected, String actual) { + public Long getDepositChainId() { + return depositChainId; + } + + private static String formatMessage( + final String fieldName, final String expected, final String actual) { return String.format( "Supplied %s (%s) does not match the stored database (%s). " + "Check that the existing database matches the current network settings.", @@ -93,7 +132,8 @@ public boolean equals(final Object o) { } final DatabaseNetwork that = (DatabaseNetwork) o; return Objects.equals(forkVersion, that.forkVersion) - && Objects.equals(depositContract, that.depositContract); + && Objects.equals(depositContract, that.depositContract) + && Objects.equals(depositChainId, that.depositChainId); } @Override diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/network/EphemeryException.java b/storage/src/main/java/tech/pegasys/teku/storage/server/network/EphemeryException.java new file mode 100644 index 00000000000..394aad3a064 --- /dev/null +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/network/EphemeryException.java @@ -0,0 +1,16 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.storage.server.network; + +public class EphemeryException extends RuntimeException {} diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/noop/NoOpDatabase.java b/storage/src/main/java/tech/pegasys/teku/storage/server/noop/NoOpDatabase.java index 9197e4b3959..3c1ac50d02d 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/noop/NoOpDatabase.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/noop/NoOpDatabase.java @@ -45,6 +45,7 @@ import tech.pegasys.teku.storage.api.UpdateResult; import tech.pegasys.teku.storage.api.WeakSubjectivityState; import tech.pegasys.teku.storage.api.WeakSubjectivityUpdate; +import tech.pegasys.teku.storage.archive.DataArchiveWriter; import tech.pegasys.teku.storage.server.Database; public class NoOpDatabase implements Database { @@ -224,13 +225,22 @@ public Optional getFinalizedDepositSnapshot() { } @Override - public void setFinalizedDepositSnapshot(DepositTreeSnapshot finalizedDepositSnapshot) {} + public void setFinalizedDepositSnapshot(final DepositTreeSnapshot finalizedDepositSnapshot) {} @Override - public UInt64 pruneFinalizedBlocks(UInt64 lastSlotToPrune, int pruneLimit) { + public UInt64 pruneFinalizedBlocks( + final UInt64 lastSlotToPrune, final int pruneLimit, final UInt64 checkpointInitialSlot) { return lastSlotToPrune; } + @Override + public Optional pruneFinalizedStates( + final Optional lastPrunedSlot, + final UInt64 lastSlotToPruneStateFor, + final long pruneLimit) { + return Optional.of(lastSlotToPruneStateFor); + } + @Override public void addMinGenesisTimeBlock(final MinGenesisTimeBlockEvent event) {} @@ -238,7 +248,7 @@ public void addMinGenesisTimeBlock(final MinGenesisTimeBlockEvent event) {} public void addDepositsFromBlockEvent(final DepositsFromBlockEvent event) {} @Override - public void removeDepositsFromBlockEvents(List blockNumbers) {} + public void removeDepositsFromBlockEvents(final List blockNumbers) {} @Override public void storeVotes(final Map votes) {} @@ -258,9 +268,6 @@ public long getNonCanonicalBlobSidecarColumnCount() { return 0L; } - @Override - public void migrate() {} - @Override public Optional getAnchor() { return Optional.empty(); @@ -319,13 +326,18 @@ public Optional getEarliestBlobSidecarSlot() { } @Override - public boolean pruneOldestBlobSidecars(final UInt64 lastSlotToPrune, final int pruneLimit) { + public boolean pruneOldestBlobSidecars( + final UInt64 lastSlotToPrune, + final int pruneLimit, + final DataArchiveWriter> archiveWriter) { return false; } @Override public boolean pruneOldestNonCanonicalBlobSidecars( - final UInt64 lastSlotToPrune, final int pruneLimit) { + final UInt64 lastSlotToPrune, + final int pruneLimit, + final DataArchiveWriter> archiveWriter) { return false; } @@ -357,16 +369,16 @@ public Optional getEarliestDataColumnSidecarSlot() { } @Override - public void setFirstCustodyIncompleteSlot(UInt64 slot) {} + public void setFirstCustodyIncompleteSlot(final UInt64 slot) {} @Override - public void setFirstSamplerIncompleteSlot(UInt64 slot) {} + public void setFirstSamplerIncompleteSlot(final UInt64 slot) {} @Override - public void addSidecar(DataColumnSidecar sidecar) {} + public void addSidecar(final DataColumnSidecar sidecar) {} @Override - public void pruneAllSidecars(UInt64 tillSlotInclusive) {} + public void pruneAllSidecars(final UInt64 tillSlotInclusive) {} @Override public void close() {} diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/pruner/BlobSidecarPruner.java b/storage/src/main/java/tech/pegasys/teku/storage/server/pruner/BlobSidecarPruner.java index 6c0bf8ee126..30e7020d60e 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/pruner/BlobSidecarPruner.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/pruner/BlobSidecarPruner.java @@ -13,7 +13,9 @@ package tech.pegasys.teku.storage.server.pruner; +import java.io.IOException; import java.time.Duration; +import java.util.List; import java.util.Optional; import java.util.concurrent.RejectedExecutionException; import java.util.concurrent.atomic.AtomicLong; @@ -30,8 +32,10 @@ import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.service.serviceutils.Service; import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.config.SpecConfigDeneb; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; +import tech.pegasys.teku.storage.archive.DataArchive; +import tech.pegasys.teku.storage.archive.DataArchiveWriter; import tech.pegasys.teku.storage.server.Database; import tech.pegasys.teku.storage.server.ShuttingDownException; @@ -55,10 +59,12 @@ public class BlobSidecarPruner extends Service { private final AtomicLong blobColumnSize = new AtomicLong(0); private final AtomicLong earliestBlobSidecarSlot = new AtomicLong(-1); private final boolean storeNonCanonicalBlobSidecars; + private final DataArchive dataArchive; public BlobSidecarPruner( final Spec spec, final Database database, + final DataArchive dataArchive, final MetricsSystem metricsSystem, final AsyncRunner asyncRunner, final TimeProvider timeProvider, @@ -71,6 +77,7 @@ public BlobSidecarPruner( final boolean storeNonCanonicalBlobSidecars) { this.spec = spec; this.database = database; + this.dataArchive = dataArchive; this.asyncRunner = asyncRunner; this.pruneInterval = pruneInterval; this.pruneLimit = pruneLimit; @@ -141,14 +148,14 @@ private void pruneBlobsPriorToAvailabilityWindow() { final UInt64 latestPrunableSlot = getLatestPrunableSlot(currentSlot); if (latestPrunableSlot.isZero()) { - LOG.debug("Not pruning as slots to keep include genesis."); + LOG.debug("Not pruning as slots to keep include genesis or Deneb activation epoch"); return; } LOG.debug("Pruning blobs up to slot {}, limit {}", latestPrunableSlot, pruneLimit); - try { + try (DataArchiveWriter> archiveWriter = dataArchive.getBlobSidecarWriter()) { final long blobsPruningStart = System.currentTimeMillis(); final boolean blobsPruningLimitReached = - database.pruneOldestBlobSidecars(latestPrunableSlot, pruneLimit); + database.pruneOldestBlobSidecars(latestPrunableSlot, pruneLimit, archiveWriter); logPruningResult( "Blobs pruning finished in {} ms. Limit reached: {}", blobsPruningStart, @@ -157,12 +164,15 @@ private void pruneBlobsPriorToAvailabilityWindow() { if (storeNonCanonicalBlobSidecars) { final long nonCanonicalBlobsPruningStart = System.currentTimeMillis(); final boolean nonCanonicalBlobsLimitReached = - database.pruneOldestNonCanonicalBlobSidecars(latestPrunableSlot, pruneLimit); + database.pruneOldestNonCanonicalBlobSidecars( + latestPrunableSlot, pruneLimit, archiveWriter); logPruningResult( "Non canonical Blobs pruning finished in {} ms. Limit reached: {}", nonCanonicalBlobsPruningStart, nonCanonicalBlobsLimitReached); } + } catch (IOException ex) { + LOG.error("Failed to get the BlobSidecar archive writer", ex); } catch (ShuttingDownException | RejectedExecutionException ex) { LOG.debug("Shutting down", ex); } @@ -202,10 +212,14 @@ private UInt64 getLatestPrunableSlot(final UInt64 currentSlot) { // DA_boundary: 64 // latest_prunable_slot = 31 - final SpecConfig config = spec.atSlot(currentSlot).getConfig(); - final SpecConfigDeneb specConfigDeneb = SpecConfigDeneb.required(config); + final Optional denebSpecConfig = + spec.atSlot(currentSlot).getConfig().toVersionDeneb(); + if (denebSpecConfig.isEmpty()) { + return UInt64.ZERO; + } + final long slotsToKeep = - (((long) specConfigDeneb.getEpochsStoreBlobs() + 1) + (((long) denebSpecConfig.get().getEpochsStoreBlobs() + 1) * spec.atSlot(currentSlot).getSlotsPerEpoch()) + 1; return currentSlot.minusMinZero(slotsToKeep); diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/pruner/BlockPruner.java b/storage/src/main/java/tech/pegasys/teku/storage/server/pruner/BlockPruner.java index 316be0143a3..3635f6c24a5 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/pruner/BlockPruner.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/pruner/BlockPruner.java @@ -97,24 +97,22 @@ private void pruneBlocks() { final UInt64 earliestEpochToKeep = finalizedEpoch.minusMinZero(spec.getNetworkingConfig().getMinEpochsForBlockRequests()); final UInt64 earliestSlotToKeep = spec.computeStartSlotAtEpoch(earliestEpochToKeep); + final UInt64 checkpointEarliestSlot = spec.computeStartSlotAtEpoch(finalizedEpoch); if (earliestSlotToKeep.isZero()) { LOG.debug("Pruning is not performed as the epochs to retain include the genesis epoch."); return; } - LOG.info("Initiating pruning of finalized blocks prior to slot {}.", earliestSlotToKeep); + LOG.debug("Initiating pruning of finalized blocks prior to slot {}.", earliestSlotToKeep); try { final UInt64 lastPrunedSlot = - database.pruneFinalizedBlocks(earliestSlotToKeep.decrement(), pruneLimit); - if (lastPrunedSlot.equals(earliestEpochToKeep.decrement())) { - LOG.info("Successfully pruned finalized blocks prior to slot {}.", earliestSlotToKeep); - } else { - LOG.info( - "Pruned {} finalized blocks prior to slot {}, last pruned slot was {}.", - pruneLimit, - earliestSlotToKeep, - lastPrunedSlot); - } - } catch (ShuttingDownException | RejectedExecutionException ex) { + database.pruneFinalizedBlocks( + earliestSlotToKeep.decrement(), pruneLimit, checkpointEarliestSlot); + LOG.debug( + "Pruned {} finalized blocks prior to slot {}, last pruned slot was {}.", + pruneLimit, + earliestSlotToKeep, + lastPrunedSlot); + } catch (final ShuttingDownException | RejectedExecutionException ex) { LOG.debug("Shutting down", ex); } } diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/pruner/StatePruner.java b/storage/src/main/java/tech/pegasys/teku/storage/server/pruner/StatePruner.java new file mode 100644 index 00000000000..2a6536822b0 --- /dev/null +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/pruner/StatePruner.java @@ -0,0 +1,123 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.storage.server.pruner; + +import com.google.common.annotations.VisibleForTesting; +import java.time.Duration; +import java.util.Optional; +import java.util.concurrent.RejectedExecutionException; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import tech.pegasys.teku.infrastructure.async.AsyncRunner; +import tech.pegasys.teku.infrastructure.async.Cancellable; +import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.metrics.SettableLabelledGauge; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.service.serviceutils.Service; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.datastructures.state.Checkpoint; +import tech.pegasys.teku.storage.server.Database; +import tech.pegasys.teku.storage.server.ShuttingDownException; + +public class StatePruner extends Service { + private static final Logger LOG = LogManager.getLogger(); + + private final Spec spec; + private final Database database; + private final AsyncRunner asyncRunner; + private final Duration pruneInterval; + private final long pruneLimit; + private final long slotsToRetain; + private final SettableLabelledGauge pruningTimingsLabelledGauge; + private final SettableLabelledGauge pruningActiveLabelledGauge; + private final String pruningMetricsType; + // caching last pruned slot to avoid hitting the db multiple times + private Optional maybeLastPrunedSlot = Optional.empty(); + + private Optional scheduledPruner = Optional.empty(); + + public StatePruner( + final Spec spec, + final Database database, + final AsyncRunner asyncRunner, + final Duration pruneInterval, + final long slotsToRetain, + final long pruneLimit, + final String pruningMetricsType, + final SettableLabelledGauge pruningTimingsLabelledGauge, + final SettableLabelledGauge pruningActiveLabelledGauge) { + this.spec = spec; + this.database = database; + this.asyncRunner = asyncRunner; + this.pruneInterval = pruneInterval; + this.pruningMetricsType = pruningMetricsType; + this.pruningTimingsLabelledGauge = pruningTimingsLabelledGauge; + this.pruningActiveLabelledGauge = pruningActiveLabelledGauge; + this.slotsToRetain = slotsToRetain; + this.pruneLimit = pruneLimit; + } + + @Override + protected synchronized SafeFuture doStart() { + scheduledPruner = + Optional.of( + asyncRunner.runWithFixedDelay( + () -> { + pruningActiveLabelledGauge.set(1, pruningMetricsType); + final long start = System.currentTimeMillis(); + pruneStates(); + pruningTimingsLabelledGauge.set( + System.currentTimeMillis() - start, pruningMetricsType); + pruningActiveLabelledGauge.set(0, pruningMetricsType); + }, + Duration.ZERO, + pruneInterval, + error -> LOG.error("Failed to prune old states", error))); + return SafeFuture.COMPLETE; + } + + @Override + protected synchronized SafeFuture doStop() { + scheduledPruner.ifPresent(Cancellable::cancel); + return SafeFuture.COMPLETE; + } + + private void pruneStates() { + final Optional finalizedCheckpoint = database.getFinalizedCheckpoint(); + if (finalizedCheckpoint.isEmpty()) { + LOG.debug("Not pruning as no finalized checkpoint is available."); + return; + } + final UInt64 finalizedEpoch = finalizedCheckpoint.get().getEpoch(); + final UInt64 earliestSlotToKeep = + spec.computeStartSlotAtEpoch(finalizedEpoch).minusMinZero(slotsToRetain); + if (earliestSlotToKeep.isZero()) { + LOG.debug("Pruning is not performed as the epochs to retain include the genesis epoch."); + return; + } + LOG.debug("Initiating pruning of finalized states prior to slot {}.", earliestSlotToKeep); + try { + maybeLastPrunedSlot = + database.pruneFinalizedStates( + maybeLastPrunedSlot, earliestSlotToKeep.decrement(), pruneLimit); + } catch (final ShuttingDownException | RejectedExecutionException ex) { + LOG.debug("Shutting down", ex); + } + } + + @VisibleForTesting + public Duration getPruneInterval() { + return pruneInterval; + } +} diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/rocksdb/RocksDbInstance.java b/storage/src/main/java/tech/pegasys/teku/storage/server/rocksdb/RocksDbInstance.java index e486a39a52b..8ed14e3ab5d 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/rocksdb/RocksDbInstance.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/rocksdb/RocksDbInstance.java @@ -59,7 +59,7 @@ public class RocksDbInstance implements KvStoreAccessor { } @Override - public Optional get(KvStoreVariable variable) { + public Optional get(final KvStoreVariable variable) { return getRaw(variable).map(data -> variable.getSerializer().deserialize(data.toArrayUnsafe())); } @@ -75,7 +75,7 @@ public Optional getRaw(final KvStoreVariable variable) { } @Override - public Optional get(KvStoreColumn column, K key) { + public Optional get(final KvStoreColumn column, final K key) { assertOpen(); final ColumnFamilyHandle handle = columnHandles.get(column); final byte[] keyBytes = column.getKeySerializer().serialize(key); @@ -96,7 +96,7 @@ public long size(final KvStoreColumn column) { } @Override - public Map getAll(KvStoreColumn column) { + public Map getAll(final KvStoreColumn column) { assertOpen(); try (final Stream> stream = stream(column)) { return stream.collect(Collectors.toMap(ColumnEntry::getKey, ColumnEntry::getValue)); @@ -104,7 +104,8 @@ public Map getAll(KvStoreColumn column) { } @Override - public Optional> getFloorEntry(KvStoreColumn column, final K key) { + public Optional> getFloorEntry( + final KvStoreColumn column, final K key) { assertOpen(); final byte[] keyBytes = column.getKeySerializer().serialize(key); final Consumer setupIterator = it -> it.seekForPrev(keyBytes); @@ -136,14 +137,14 @@ public Optional getLastKey(final KvStoreColumn column) { @Override @MustBeClosed - public Stream> stream(KvStoreColumn column) { + public Stream> stream(final KvStoreColumn column) { assertOpen(); return createStream(column, RocksIterator::seekToFirst); } @Override @MustBeClosed - public Stream streamKeys(KvStoreColumn column) { + public Stream streamKeys(final KvStoreColumn column) { assertOpen(); return createKeyStream(column, RocksIterator::seekToFirst); } @@ -188,7 +189,7 @@ public , V> Stream> stream( @Override @MustBeClosed public , V> Stream streamKeys( - KvStoreColumn column, K from, K to) { + final KvStoreColumn column, final K from, final K to) { assertOpen(); return createKeyStream( column, @@ -208,21 +209,21 @@ public synchronized KvStoreTransaction startTransaction() { @MustBeClosed private Stream> createStream( - KvStoreColumn column, Consumer setupIterator) { + final KvStoreColumn column, final Consumer setupIterator) { return createStream(column, setupIterator, key -> true); } @MustBeClosed private Stream createKeyStream( - KvStoreColumn column, Consumer setupIterator) { + final KvStoreColumn column, final Consumer setupIterator) { return createKeyStream(column, setupIterator, key -> true); } @MustBeClosed private Stream> createStream( - KvStoreColumn column, - Consumer setupIterator, - Predicate continueTest) { + final KvStoreColumn column, + final Consumer setupIterator, + final Predicate continueTest) { return createStreamRaw(column, setupIterator, continueTest) .map( @@ -234,9 +235,9 @@ private Stream> createStream( @MustBeClosed private Stream createKeyStream( - KvStoreColumn column, - Consumer setupIterator, - Predicate continueTest) { + final KvStoreColumn column, + final Consumer setupIterator, + final Predicate continueTest) { return createStreamKeyRaw(column, setupIterator, continueTest) .map(entry -> column.getKeySerializer().deserialize(entry)); @@ -245,9 +246,9 @@ private Stream createKeyStream( @SuppressWarnings("MustBeClosedChecker") @MustBeClosed private Stream> createStreamRaw( - KvStoreColumn column, - Consumer setupIterator, - Predicate continueTest) { + final KvStoreColumn column, + final Consumer setupIterator, + final Predicate continueTest) { final ColumnFamilyHandle handle = columnHandles.get(column); final RocksIterator rocksDbIterator = db.newIterator(handle); setupIterator.accept(rocksDbIterator); @@ -257,9 +258,9 @@ private Stream> createStreamRaw( @SuppressWarnings("MustBeClosedChecker") @MustBeClosed private Stream createStreamKeyRaw( - KvStoreColumn column, - Consumer setupIterator, - Predicate continueTest) { + final KvStoreColumn column, + final Consumer setupIterator, + final Predicate continueTest) { final ColumnFamilyHandle handle = columnHandles.get(column); final RocksIterator rocksDbIterator = db.newIterator(handle); setupIterator.accept(rocksDbIterator); diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/rocksdb/RocksDbInstanceFactory.java b/storage/src/main/java/tech/pegasys/teku/storage/server/rocksdb/RocksDbInstanceFactory.java index 4f64f452aa8..fc352ac1b69 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/rocksdb/RocksDbInstanceFactory.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/rocksdb/RocksDbInstanceFactory.java @@ -14,6 +14,9 @@ package tech.pegasys.teku.storage.server.rocksdb; import static com.google.common.base.Preconditions.checkArgument; +import static tech.pegasys.teku.storage.server.kvstore.KvStoreConfiguration.NUMBER_OF_LOG_FILES_TO_KEEP; +import static tech.pegasys.teku.storage.server.kvstore.KvStoreConfiguration.ROCKSDB_BLOCK_SIZE; +import static tech.pegasys.teku.storage.server.kvstore.KvStoreConfiguration.TIME_TO_ROLL_LOG_FILE; import com.google.common.collect.ImmutableMap; import java.util.ArrayList; @@ -28,6 +31,7 @@ import org.hyperledger.besu.plugin.services.MetricsSystem; import org.hyperledger.besu.plugin.services.metrics.MetricCategory; import org.rocksdb.BlockBasedTableConfig; +import org.rocksdb.BloomFilter; import org.rocksdb.Cache; import org.rocksdb.ColumnFamilyDescriptor; import org.rocksdb.ColumnFamilyHandle; @@ -117,7 +121,7 @@ public static KvStoreAccessor create( } } - private static ColumnFamilyHandle getDefaultHandle(List columnHandles) { + private static ColumnFamilyHandle getDefaultHandle(final List columnHandles) { return columnHandles.stream() .filter( handle -> { @@ -137,18 +141,23 @@ private static DBOptions createDBOptions( final DBOptions options = new DBOptions() .setCreateIfMissing(true) - .setBytesPerSync(1048576L) - .setWalBytesPerSync(1048576L) .setIncreaseParallelism(Runtime.getRuntime().availableProcessors()) .setMaxBackgroundJobs(configuration.getMaxBackgroundJobs()) .setDbWriteBufferSize(configuration.getWriteBufferCapacity()) .setMaxOpenFiles(configuration.getMaxOpenFiles()) + .setBytesPerSync(1_048_576L) // 1MB + .setWalBytesPerSync(1_048_576L) .setCreateMissingColumnFamilies(true) + .setLogFileTimeToRoll(TIME_TO_ROLL_LOG_FILE) + .setKeepLogFileNum(NUMBER_OF_LOG_FILES_TO_KEEP) .setEnv(Env.getDefault().setBackgroundThreads(configuration.getBackgroundThreadCount())) .setStatistics(stats); + + // Java docs suggests this if db is under 1GB, nearly impossible atm if (configuration.optimizeForSmallDb()) { options.optimizeForSmallDb(); } + return options; } @@ -157,6 +166,7 @@ private static ColumnFamilyOptions createColumnFamilyOptions( return new ColumnFamilyOptions() .setCompressionType(configuration.getCompressionType()) .setBottommostCompressionType(configuration.getBottomMostCompressionType()) + .setTtl(0) .setTableFormatConfig(createBlockBasedTableConfig(cache)); } @@ -175,8 +185,11 @@ private static List createColumnFamilyDescriptors( private static BlockBasedTableConfig createBlockBasedTableConfig(final Cache cache) { return new BlockBasedTableConfig() + .setFormatVersion(5) .setBlockCache(cache) + .setFilterPolicy(new BloomFilter(10, false)) + .setPartitionFilters(true) .setCacheIndexAndFilterBlocks(true) - .setFormatVersion(4); // Use the latest format version (only applies to new tables) + .setBlockSize(ROCKSDB_BLOCK_SIZE); } } diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/rocksdb/RocksDbStats.java b/storage/src/main/java/tech/pegasys/teku/storage/server/rocksdb/RocksDbStats.java index 315dbdf33a9..5909b91a84a 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/rocksdb/RocksDbStats.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/rocksdb/RocksDbStats.java @@ -52,12 +52,10 @@ public class RocksDbStats implements AutoCloseable { TickerType.BLOCK_CACHE_INDEX_HIT, TickerType.BLOCK_CACHE_INDEX_ADD, TickerType.BLOCK_CACHE_INDEX_BYTES_INSERT, - TickerType.BLOCK_CACHE_INDEX_BYTES_EVICT, TickerType.BLOCK_CACHE_FILTER_MISS, TickerType.BLOCK_CACHE_FILTER_HIT, TickerType.BLOCK_CACHE_FILTER_ADD, TickerType.BLOCK_CACHE_FILTER_BYTES_INSERT, - TickerType.BLOCK_CACHE_FILTER_BYTES_EVICT, TickerType.BLOCK_CACHE_DATA_MISS, TickerType.BLOCK_CACHE_DATA_HIT, TickerType.BLOCK_CACHE_DATA_ADD, @@ -91,7 +89,6 @@ public class RocksDbStats implements AutoCloseable { TickerType.NUMBER_DB_NEXT_FOUND, TickerType.NUMBER_DB_PREV_FOUND, TickerType.ITER_BYTES_READ, - TickerType.NO_FILE_CLOSES, TickerType.NO_FILE_OPENS, TickerType.NO_FILE_ERRORS, // TickerType.STALL_L0_SLOWDOWN_MICROS, @@ -99,26 +96,18 @@ public class RocksDbStats implements AutoCloseable { // TickerType.STALL_L0_NUM_FILES_MICROS, TickerType.STALL_MICROS, TickerType.DB_MUTEX_WAIT_MICROS, - TickerType.RATE_LIMIT_DELAY_MILLIS, - TickerType.NO_ITERATORS, TickerType.NUMBER_MULTIGET_BYTES_READ, TickerType.NUMBER_MULTIGET_KEYS_READ, TickerType.NUMBER_MULTIGET_CALLS, - TickerType.NUMBER_FILTERED_DELETES, TickerType.NUMBER_MERGE_FAILURES, TickerType.BLOOM_FILTER_PREFIX_CHECKED, TickerType.BLOOM_FILTER_PREFIX_USEFUL, TickerType.NUMBER_OF_RESEEKS_IN_ITERATION, TickerType.GET_UPDATES_SINCE_CALLS, - TickerType.BLOCK_CACHE_COMPRESSED_MISS, - TickerType.BLOCK_CACHE_COMPRESSED_HIT, - TickerType.BLOCK_CACHE_COMPRESSED_ADD, - TickerType.BLOCK_CACHE_COMPRESSED_ADD_FAILURES, TickerType.WAL_FILE_SYNCED, TickerType.WAL_FILE_BYTES, TickerType.WRITE_DONE_BY_SELF, TickerType.WRITE_DONE_BY_OTHER, - TickerType.WRITE_TIMEDOUT, TickerType.WRITE_WITH_WAL, TickerType.COMPACT_READ_BYTES, TickerType.COMPACT_WRITE_BYTES, @@ -129,7 +118,6 @@ public class RocksDbStats implements AutoCloseable { TickerType.NUMBER_SUPERVERSION_CLEANUPS, TickerType.NUMBER_BLOCK_COMPRESSED, TickerType.NUMBER_BLOCK_DECOMPRESSED, - TickerType.NUMBER_BLOCK_NOT_COMPRESSED, TickerType.MERGE_OPERATION_TOTAL_TIME, TickerType.FILTER_OPERATION_TOTAL_TIME, TickerType.ROW_CACHE_HIT, @@ -156,11 +144,6 @@ public class RocksDbStats implements AutoCloseable { HistogramType.READ_BLOCK_COMPACTION_MICROS, HistogramType.READ_BLOCK_GET_MICROS, HistogramType.WRITE_RAW_BLOCK_MICROS, - HistogramType.STALL_L0_SLOWDOWN_COUNT, - HistogramType.STALL_MEMTABLE_COMPACTION_COUNT, - HistogramType.STALL_L0_NUM_FILES_COUNT, - HistogramType.HARD_RATE_LIMIT_DELAY_COUNT, - HistogramType.SOFT_RATE_LIMIT_DELAY_COUNT, HistogramType.NUM_FILES_IN_SINGLE_COMPACTION, HistogramType.DB_SEEK, HistogramType.WRITE_STALL, @@ -169,8 +152,6 @@ public class RocksDbStats implements AutoCloseable { HistogramType.BYTES_PER_READ, HistogramType.BYTES_PER_WRITE, HistogramType.BYTES_PER_MULTIGET, - HistogramType.BYTES_COMPRESSED, - HistogramType.BYTES_DECOMPRESSED, HistogramType.COMPRESSION_TIMES_NANOS, HistogramType.DECOMPRESSION_TIMES_NANOS, HistogramType.READ_NUM_MERGE_OPERANDS, diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/rocksdb/RocksDbTransaction.java b/storage/src/main/java/tech/pegasys/teku/storage/server/rocksdb/RocksDbTransaction.java index 467c3c885bb..c3b1b3c969d 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/rocksdb/RocksDbTransaction.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/rocksdb/RocksDbTransaction.java @@ -53,7 +53,7 @@ public class RocksDbTransaction implements KvStoreTransaction { } @Override - public void put(KvStoreVariable variable, T value) { + public void put(final KvStoreVariable variable, final T value) { final Bytes serialized = Bytes.wrap(variable.getSerializer().serialize(value)); putRaw(variable, serialized); } @@ -71,7 +71,7 @@ public void putRaw(final KvStoreVariable variable, final Bytes value) { } @Override - public void put(KvStoreColumn column, K key, V value) { + public void put(final KvStoreColumn column, final K key, final V value) { final Bytes keyBytes = Bytes.wrap(column.getKeySerializer().serialize(key)); final Bytes valueBytes = Bytes.wrap(column.getValueSerializer().serialize(value)); putRaw(column, keyBytes, valueBytes); @@ -92,7 +92,7 @@ public void putRaw( } @Override - public void put(KvStoreColumn column, Map data) { + public void put(final KvStoreColumn column, final Map data) { applyUpdate( () -> { final ColumnFamilyHandle handle = columnHandles.get(column); @@ -109,7 +109,7 @@ public void put(KvStoreColumn column, Map data) { } @Override - public void delete(KvStoreColumn column, K key) { + public void delete(final KvStoreColumn column, final K key) { applyUpdate( () -> { final ColumnFamilyHandle handle = columnHandles.get(column); @@ -122,7 +122,7 @@ public void delete(KvStoreColumn column, K key) { } @Override - public void delete(KvStoreVariable variable) { + public void delete(final KvStoreVariable variable) { applyUpdate( () -> { try { diff --git a/storage/src/main/java/tech/pegasys/teku/storage/server/state/FinalizedStateCache.java b/storage/src/main/java/tech/pegasys/teku/storage/server/state/FinalizedStateCache.java index fc3a9e6e794..4a37c3c9d14 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/server/state/FinalizedStateCache.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/server/state/FinalizedStateCache.java @@ -60,7 +60,7 @@ public FinalizedStateCache( final Database database, final int maximumCacheSize, final boolean useSoftReferences, - int stateRebuildTimeoutSeconds, + final int stateRebuildTimeoutSeconds, final long maxRegenerateSlots) { final CacheBuilder cacheBuilder = CacheBuilder.newBuilder() diff --git a/storage/src/main/java/tech/pegasys/teku/storage/store/FileKeyValueStore.java b/storage/src/main/java/tech/pegasys/teku/storage/store/FileKeyValueStore.java index e45019a9997..58103f5e001 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/store/FileKeyValueStore.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/store/FileKeyValueStore.java @@ -34,19 +34,19 @@ public class FileKeyValueStore implements KeyValueStore { private final Path dataDir; private final ConcurrentMap keyMutexes = new ConcurrentHashMap<>(); - public FileKeyValueStore(Path dataDir) { + public FileKeyValueStore(final Path dataDir) { this.dataDir = dataDir; this.syncDataAccessor = SyncDataAccessor.create(dataDir); } - private Object keyMutex(String key) { + private Object keyMutex(final String key) { // there supposed to be a very limited number of keys so // we don't clean up the map for the sake of simplicity return keyMutexes.computeIfAbsent(key, __ -> new Object()); } @Override - public void put(@NotNull String key, @NotNull Bytes value) { + public void put(final @NotNull String key, final @NotNull Bytes value) { Path file = dataDir.resolve(key + ".dat"); try { synchronized (keyMutex(key)) { @@ -58,7 +58,7 @@ public void put(@NotNull String key, @NotNull Bytes value) { } @Override - public void remove(@NotNull String key) { + public void remove(@NotNull final String key) { Path file = dataDir.resolve(key + ".dat"); synchronized (keyMutex(key)) { file.toFile().delete(); @@ -66,7 +66,7 @@ public void remove(@NotNull String key) { } @Override - public Optional get(@NotNull String key) { + public Optional get(@NotNull final String key) { Path file = dataDir.resolve(key + ".dat"); try { synchronized (keyMutex(key)) { diff --git a/storage/src/main/java/tech/pegasys/teku/storage/store/KeyValueStore.java b/storage/src/main/java/tech/pegasys/teku/storage/store/KeyValueStore.java index e572960306d..cc3a3d0073d 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/store/KeyValueStore.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/store/KeyValueStore.java @@ -42,7 +42,7 @@ public interface KeyValueStore { *

    The implementation may override this default method and declare it to be an atomic store * update. Though this generic interface makes no restrictions on atomicity of this method */ - default void updateAll(Iterable> data) { + default void updateAll(final Iterable> data) { data.forEach( update -> { if (update.getType() == UpdateType.UPDATE) { @@ -66,15 +66,15 @@ class EntryUpdate { private final K key; private final V value; - public static EntryUpdate update(K key, V value) { + public static EntryUpdate update(final K key, final V value) { return new EntryUpdate<>(UpdateType.UPDATE, key, value); } - public static EntryUpdate remove(K key) { + public static EntryUpdate remove(final K key) { return new EntryUpdate<>(UpdateType.REMOVE, key, null); } - private EntryUpdate(UpdateType type, K key, V value) { + private EntryUpdate(final UpdateType type, final K key, final V value) { this.type = type; this.key = key; this.value = value; diff --git a/storage/src/main/java/tech/pegasys/teku/storage/store/MemKeyValueStore.java b/storage/src/main/java/tech/pegasys/teku/storage/store/MemKeyValueStore.java index 2c661fe89b9..0b3340964e6 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/store/MemKeyValueStore.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/store/MemKeyValueStore.java @@ -24,17 +24,17 @@ public class MemKeyValueStore implements KeyValueStore { private final Map store = new ConcurrentHashMap<>(); @Override - public void put(@NotNull K key, @NotNull V value) { + public void put(@NotNull final K key, @NotNull final V value) { store.put(key, value); } @Override - public void remove(@NotNull K key) { + public void remove(@NotNull final K key) { store.remove(key); } @Override - public Optional get(@NotNull K key) { + public Optional get(@NotNull final K key) { return Optional.ofNullable(store.get(key)); } } diff --git a/storage/src/main/java/tech/pegasys/teku/storage/store/Store.java b/storage/src/main/java/tech/pegasys/teku/storage/store/Store.java index fd69c162f1b..ac833bd6d6e 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/store/Store.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/store/Store.java @@ -517,7 +517,7 @@ public Optional getProposerBoostRoot() { } @Override - public boolean containsBlock(Bytes32 blockRoot) { + public boolean containsBlock(final Bytes32 blockRoot) { readLock.lock(); try { return forkChoiceStrategy.contains(blockRoot); @@ -607,7 +607,7 @@ public void computeBalanceThresholds(final BeaconState justifiedState) { } @Override - public Optional isFfgCompetitive(Bytes32 headRoot, Bytes32 parentRoot) { + public Optional isFfgCompetitive(final Bytes32 headRoot, final Bytes32 parentRoot) { final Optional maybeHeadData = getBlockDataFromForkChoiceStrategy(headRoot); final Optional maybeParentData = getBlockDataFromForkChoiceStrategy(parentRoot); if (maybeParentData.isEmpty() || maybeHeadData.isEmpty()) { diff --git a/storage/src/main/java/tech/pegasys/teku/storage/store/StoreConfig.java b/storage/src/main/java/tech/pegasys/teku/storage/store/StoreConfig.java index b28e9b06241..1b02e40014e 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/store/StoreConfig.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/store/StoreConfig.java @@ -158,7 +158,7 @@ public Builder checkpointStateCacheSize(final int checkpointStateCacheSize) { } public Builder earliestAvailableBlockSlotFrequency( - int earliestAvailableBlockSlotQueryFrequency) { + final int earliestAvailableBlockSlotQueryFrequency) { this.earliestAvailableBlockSlotFrequency = earliestAvailableBlockSlotQueryFrequency; return this; } diff --git a/storage/src/main/java/tech/pegasys/teku/storage/store/StoreTransaction.java b/storage/src/main/java/tech/pegasys/teku/storage/store/StoreTransaction.java index 5ed31e8afda..2cc3fbbd864 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/store/StoreTransaction.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/store/StoreTransaction.java @@ -96,9 +96,8 @@ public void putBlockAndState( final Optional> blobSidecars, final Optional maybeEarliestBlobSidecarSlot) { blockData.put(block.getRoot(), new TransactionBlockData(block, state, blockCheckpoints)); - if (!blobSidecars.isEmpty()) { - this.blobSidecars.put(block.getSlotAndBlockRoot(), blobSidecars.get()); - } + blobSidecars.ifPresent( + sidecars -> this.blobSidecars.put(block.getSlotAndBlockRoot(), sidecars)); if (needToUpdateEarliestBlobSidecarSlot(maybeEarliestBlobSidecarSlot)) { this.maybeEarliestBlobSidecarTransactionSlot = maybeEarliestBlobSidecarSlot; } @@ -135,7 +134,7 @@ public void pullUpBlockCheckpoints(final Bytes32 blockRoot) { } @Override - public void setTimeMillis(UInt64 timeMillis) { + public void setTimeMillis(final UInt64 timeMillis) { final UInt64 storeTimeMillis = store.getTimeInMillis(); checkArgument( timeMillis.isGreaterThanOrEqualTo(storeTimeMillis), @@ -146,23 +145,24 @@ public void setTimeMillis(UInt64 timeMillis) { } @Override - public void setGenesisTime(UInt64 genesisTime) { + public void setGenesisTime(final UInt64 genesisTime) { this.genesisTime = Optional.of(genesisTime); } @Override - public void setJustifiedCheckpoint(Checkpoint justifiedCheckpoint) { + public void setJustifiedCheckpoint(final Checkpoint justifiedCheckpoint) { this.justifiedCheckpoint = Optional.of(justifiedCheckpoint); } @Override - public void setFinalizedCheckpoint(Checkpoint finalizedCheckpoint, boolean fromOptimisticBlock) { + public void setFinalizedCheckpoint( + final Checkpoint finalizedCheckpoint, final boolean fromOptimisticBlock) { this.finalizedCheckpoint = Optional.of(finalizedCheckpoint); this.finalizedCheckpointOptimistic = fromOptimisticBlock; } @Override - public void setBestJustifiedCheckpoint(Checkpoint bestJustifiedCheckpoint) { + public void setBestJustifiedCheckpoint(final Checkpoint bestJustifiedCheckpoint) { this.bestJustifiedCheckpoint = Optional.of(bestJustifiedCheckpoint); } @@ -354,7 +354,7 @@ public Optional getBlockStateIfAvailable(final Bytes32 blockRoot) { } @Override - public SafeFuture> retrieveSignedBlock(Bytes32 blockRoot) { + public SafeFuture> retrieveSignedBlock(final Bytes32 blockRoot) { if (blockData.containsKey(blockRoot)) { return SafeFuture.completedFuture( Optional.of(blockData.get(blockRoot)).map(SignedBlockAndState::getBlock)); @@ -363,7 +363,7 @@ public SafeFuture> retrieveSignedBlock(Bytes32 block } @Override - public SafeFuture> retrieveBlockAndState(Bytes32 blockRoot) { + public SafeFuture> retrieveBlockAndState(final Bytes32 blockRoot) { if (blockData.containsKey(blockRoot)) { final TransactionBlockData result = blockData.get(blockRoot); return SafeFuture.completedFuture(Optional.of(result.toSignedBlockAndState())); @@ -382,7 +382,7 @@ public SafeFuture> retrieveStateAndBlockSummary( } @Override - public SafeFuture> retrieveBlockState(Bytes32 blockRoot) { + public SafeFuture> retrieveBlockState(final Bytes32 blockRoot) { if (blockData.containsKey(blockRoot)) { return SafeFuture.completedFuture( Optional.of(blockData.get(blockRoot)).map(SignedBlockAndState::getState)); @@ -391,7 +391,7 @@ public SafeFuture> retrieveBlockState(Bytes32 blockRoot) { } @Override - public SafeFuture> retrieveCheckpointState(Checkpoint checkpoint) { + public SafeFuture> retrieveCheckpointState(final Checkpoint checkpoint) { SignedBlockAndState inMemoryCheckpointBlockState = blockData.get(checkpoint.getRoot()); if (inMemoryCheckpointBlockState != null) { // Not executing the task via the task queue to avoid caching the result before the tx is @@ -406,7 +406,8 @@ public SafeFuture> retrieveCheckpointState(Checkpoint chec } @Override - public SafeFuture> retrieveStateAtSlot(SlotAndBlockRoot slotAndBlockRoot) { + public SafeFuture> retrieveStateAtSlot( + final SlotAndBlockRoot slotAndBlockRoot) { SignedBlockAndState inMemoryCheckpointBlockState = blockData.get(slotAndBlockRoot.getBlockRoot()); if (inMemoryCheckpointBlockState != null) { @@ -467,7 +468,7 @@ public void computeBalanceThresholds(final BeaconState justifiedState) { } @Override - public Optional isFfgCompetitive(Bytes32 headRoot, Bytes32 parentRoot) { + public Optional isFfgCompetitive(final Bytes32 headRoot, final Bytes32 parentRoot) { return store.isFfgCompetitive(headRoot, parentRoot); } diff --git a/storage/src/main/java/tech/pegasys/teku/storage/store/StoreTransactionUpdatesFactory.java b/storage/src/main/java/tech/pegasys/teku/storage/store/StoreTransactionUpdatesFactory.java index c8e87ee061a..ed5dcc16e61 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/store/StoreTransactionUpdatesFactory.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/store/StoreTransactionUpdatesFactory.java @@ -259,6 +259,6 @@ private StoreTransactionUpdates createStoreTransactionUpdates( optimisticTransitionBlockRoot, // FIXME: suboptimal criteria, doesn't fade out when blobs are over spec.isMilestoneSupported(SpecMilestone.DENEB), - spec.isMilestoneSupported(SpecMilestone.EIP7594)); + spec.isMilestoneSupported(SpecMilestone.ELECTRA)); } } diff --git a/storage/src/main/java/tech/pegasys/teku/storage/store/StoreVoteUpdater.java b/storage/src/main/java/tech/pegasys/teku/storage/store/StoreVoteUpdater.java index 58eec61c5fb..12ecf46885e 100644 --- a/storage/src/main/java/tech/pegasys/teku/storage/store/StoreVoteUpdater.java +++ b/storage/src/main/java/tech/pegasys/teku/storage/store/StoreVoteUpdater.java @@ -41,7 +41,7 @@ public class StoreVoteUpdater implements VoteUpdater { } @Override - public VoteTracker getVote(UInt64 validatorIndex) { + public VoteTracker getVote(final UInt64 validatorIndex) { VoteTracker txVote = votes.get(validatorIndex); if (txVote != null) { return txVote; @@ -57,7 +57,7 @@ public UInt64 getHighestVotedValidatorIndex() { } @Override - public void putVote(UInt64 validatorIndex, VoteTracker vote) { + public void putVote(final UInt64 validatorIndex, final VoteTracker vote) { votes.put(validatorIndex, vote); highestVotedValidatorIndex = highestVotedValidatorIndex.max(validatorIndex); } diff --git a/storage/src/property-test/java/tech/pegasys/teku/storage/server/kvstore/serialization/BeaconStateSerializerPropertyTest.java b/storage/src/property-test/java/tech/pegasys/teku/storage/server/kvstore/serialization/BeaconStateSerializerPropertyTest.java index 20ad309be2d..79ebce5463c 100644 --- a/storage/src/property-test/java/tech/pegasys/teku/storage/server/kvstore/serialization/BeaconStateSerializerPropertyTest.java +++ b/storage/src/property-test/java/tech/pegasys/teku/storage/server/kvstore/serialization/BeaconStateSerializerPropertyTest.java @@ -27,7 +27,7 @@ public class BeaconStateSerializerPropertyTest { @Property(tries = 10) public boolean roundTrip( @ForAll final int seed, - @ForAll(supplier = SpecSupplier.class) Spec spec, + @ForAll(supplier = SpecSupplier.class) final Spec spec, @ForAll @IntRange(max = 1000) final int validatorCount) { final DataStructureUtil dataStructureUtil = new DataStructureUtil(seed, spec); final KvStoreSerializer serializer = createStateSerializer(spec); diff --git a/storage/src/property-test/java/tech/pegasys/teku/storage/server/kvstore/serialization/DepositsFromBlockSerializerPropertyTest.java b/storage/src/property-test/java/tech/pegasys/teku/storage/server/kvstore/serialization/DepositsFromBlockSerializerPropertyTest.java index 44880d77e44..a03f01c33c0 100644 --- a/storage/src/property-test/java/tech/pegasys/teku/storage/server/kvstore/serialization/DepositsFromBlockSerializerPropertyTest.java +++ b/storage/src/property-test/java/tech/pegasys/teku/storage/server/kvstore/serialization/DepositsFromBlockSerializerPropertyTest.java @@ -33,7 +33,7 @@ public class DepositsFromBlockSerializerPropertyTest { @Property(tries = 100) public boolean roundTrip( @ForAll final int seed, - @ForAll(supplier = SpecSupplier.class) Spec spec, + @ForAll(supplier = SpecSupplier.class) final Spec spec, @ForAll final long blockNumber, @ForAll @Size(32) final byte[] blockHash, @ForAll final long blockTimestamp, diff --git a/storage/src/property-test/java/tech/pegasys/teku/storage/server/kvstore/serialization/SignedBeaconBlockSerializerPropertyTest.java b/storage/src/property-test/java/tech/pegasys/teku/storage/server/kvstore/serialization/SignedBeaconBlockSerializerPropertyTest.java index fb832f61648..075ed12f9c6 100644 --- a/storage/src/property-test/java/tech/pegasys/teku/storage/server/kvstore/serialization/SignedBeaconBlockSerializerPropertyTest.java +++ b/storage/src/property-test/java/tech/pegasys/teku/storage/server/kvstore/serialization/SignedBeaconBlockSerializerPropertyTest.java @@ -27,7 +27,7 @@ public class SignedBeaconBlockSerializerPropertyTest { @Property public boolean roundTrip( @ForAll final int seed, - @ForAll(supplier = SpecSupplier.class) Spec spec, + @ForAll(supplier = SpecSupplier.class) final Spec spec, @ForAll @Positive final long slotNum) { final DataStructureUtil dataStructureUtil = new DataStructureUtil(seed, spec); final KvStoreSerializer serializer = createSignedBlockSerializer(spec); diff --git a/storage/src/test/java/tech/pegasys/teku/storage/archive/fsarchive/BlobSidecarJsonWriterTest.java b/storage/src/test/java/tech/pegasys/teku/storage/archive/fsarchive/BlobSidecarJsonWriterTest.java new file mode 100644 index 00000000000..3073f9af907 --- /dev/null +++ b/storage/src/test/java/tech/pegasys/teku/storage/archive/fsarchive/BlobSidecarJsonWriterTest.java @@ -0,0 +1,99 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.storage.archive.fsarchive; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.List; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +public class BlobSidecarJsonWriterTest { + private static final Spec SPEC = TestSpecFactory.createMinimalDeneb(); + + BlobSidecarJsonWriter blobSidecarJsonWriter; + private DataStructureUtil dataStructureUtil; + + @BeforeEach + public void test() { + this.blobSidecarJsonWriter = new BlobSidecarJsonWriter(); + this.dataStructureUtil = new DataStructureUtil(SPEC); + } + + @Test + void testWriteSlotBlobSidecarsWithEmptyList() throws IOException { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + List blobSidecars = new ArrayList<>(); + blobSidecarJsonWriter.writeSlotBlobSidecars(out, blobSidecars); + String json = out.toString(StandardCharsets.UTF_8); + assertEquals("[]", json); + } + + @Test + void testWriteSlotBlobSidecarsWithSingleElement() throws IOException { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + List blobSidecars = new ArrayList<>(); + final BlobSidecar blobSidecar = + dataStructureUtil.randomBlobSidecarForBlock( + dataStructureUtil.randomSignedBeaconBlock(1), 0); + blobSidecars.add(blobSidecar); + blobSidecarJsonWriter.writeSlotBlobSidecars(out, blobSidecars); + String json = out.toString(StandardCharsets.UTF_8); + assertTrue(json.contains("index")); + assertTrue(json.contains("blob")); + assertTrue(json.contains("kzg_commitment")); + assertTrue(json.contains("kzg_proof")); + assertTrue(json.contains("signed_block_header")); + assertTrue(json.contains("parent_root")); + assertTrue(json.contains("state_root")); + assertTrue(json.contains("body_root")); + assertTrue(json.contains("signature")); + } + + @Test + void testWriteSlotBlobSidecarsNulls() { + assertThrows( + NullPointerException.class, () -> blobSidecarJsonWriter.writeSlotBlobSidecars(null, null)); + } + + @Test + void testWriteSlotBlobSidecarsNullOut() { + assertThrows( + NullPointerException.class, + () -> { + List blobSidecars = new ArrayList<>(); + blobSidecarJsonWriter.writeSlotBlobSidecars(null, blobSidecars); + }); + } + + @Test + void testWriteSlotBlobSidecarsNullList() { + assertThrows( + NullPointerException.class, + () -> { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + blobSidecarJsonWriter.writeSlotBlobSidecars(out, null); + }); + } +} diff --git a/storage/src/test/java/tech/pegasys/teku/storage/archive/fsarchive/FileSystemArchiveTest.java b/storage/src/test/java/tech/pegasys/teku/storage/archive/fsarchive/FileSystemArchiveTest.java new file mode 100644 index 00000000000..f804651c245 --- /dev/null +++ b/storage/src/test/java/tech/pegasys/teku/storage/archive/fsarchive/FileSystemArchiveTest.java @@ -0,0 +1,153 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.storage.archive.fsarchive; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Stream; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.Blob; +import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar; +import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; +import tech.pegasys.teku.spec.datastructures.type.SszKZGProof; +import tech.pegasys.teku.spec.datastructures.util.SlotAndBlockRootAndBlobIndex; +import tech.pegasys.teku.spec.logic.common.helpers.Predicates; +import tech.pegasys.teku.spec.logic.versions.deneb.helpers.MiscHelpersDeneb; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsDeneb; +import tech.pegasys.teku.spec.util.DataStructureUtil; +import tech.pegasys.teku.storage.archive.DataArchiveWriter; + +public class FileSystemArchiveTest { + private static final Spec SPEC = TestSpecFactory.createMinimalDeneb(); + private final Predicates predicates = new Predicates(SPEC.getGenesisSpecConfig()); + private final SchemaDefinitionsDeneb schemaDefinitionsDeneb = + SchemaDefinitionsDeneb.required(SPEC.getGenesisSchemaDefinitions()); + private final MiscHelpersDeneb miscHelpersDeneb = + new MiscHelpersDeneb( + SPEC.getGenesisSpecConfig().toVersionDeneb().orElseThrow(), + predicates, + schemaDefinitionsDeneb); + private final DataStructureUtil dataStructureUtil = new DataStructureUtil(SPEC); + + static Path testTempDir; + static FileSystemArchive dataArchive; + + @BeforeAll + static void beforeEach() throws IOException { + testTempDir = Files.createTempDirectory("blobs"); + dataArchive = new FileSystemArchive(testTempDir); + } + + @AfterEach + public void tearDown() throws IOException { + // Delete the temporary directory after each test + if (Files.exists(testTempDir)) { + try (Stream walk = Files.walk(testTempDir)) { + walk.map(Path::toFile) + .forEach( + file -> { + if (!file.delete()) { + file.deleteOnExit(); + } + }); + } + } + } + + BlobSidecar createBlobSidecar() { + final SignedBeaconBlock signedBeaconBlock = + dataStructureUtil.randomSignedBeaconBlockWithCommitments(1); + final Blob blob = dataStructureUtil.randomValidBlob(); + final SszKZGProof proof = dataStructureUtil.randomSszKZGProof(); + + return miscHelpersDeneb.constructBlobSidecar(signedBeaconBlock, UInt64.ZERO, blob, proof); + } + + @Test + void testResolve() { + SlotAndBlockRootAndBlobIndex slotAndBlockRootAndBlobIndex = + new SlotAndBlockRootAndBlobIndex( + UInt64.ONE, dataStructureUtil.randomBytes32(), UInt64.ZERO); + File file = dataArchive.resolve(slotAndBlockRootAndBlobIndex.getSlotAndBlockRoot()); + + // Check if the file path is correct. Doesn't check the intermediate directories. + assertTrue(file.toString().startsWith(testTempDir.toString())); + assertTrue( + file.toString() + .endsWith(slotAndBlockRootAndBlobIndex.getBlockRoot().toUnprefixedHexString())); + } + + @Test + void testArchiveWithEmptyList() throws IOException { + DataArchiveWriter> blobWriter = dataArchive.getBlobSidecarWriter(); + ArrayList list = new ArrayList<>(); + assertTrue(blobWriter.archive(list)); + blobWriter.close(); + } + + @Test + void testArchiveWithNullList() throws IOException { + DataArchiveWriter> blobWriter = dataArchive.getBlobSidecarWriter(); + assertTrue(blobWriter.archive(null)); + blobWriter.close(); + } + + @Test + void testWriteBlobSidecar() throws IOException { + DataArchiveWriter> blobWriter = dataArchive.getBlobSidecarWriter(); + ArrayList list = new ArrayList<>(); + BlobSidecar blobSidecar = createBlobSidecar(); + list.add(blobSidecar); + assertTrue(blobWriter.archive(list)); + blobWriter.close(); + + // Check if the file was written + try (FileInputStream fis = + new FileInputStream(testTempDir.resolve(FileSystemArchive.INDEX_FILE).toFile())) { + String content = new String(fis.readAllBytes(), StandardCharsets.UTF_8); + String expected = + blobSidecar.getSlot().toString() + + " " + + blobSidecar.getSlotAndBlockRoot().getBlockRoot().toUnprefixedHexString(); + + // Windows new lines are different, so don't include new lines in the comparison. + assertTrue(content.contains(expected)); + } + } + + @Test + void testFileAlreadyExists() throws IOException { + DataArchiveWriter> blobWriter = dataArchive.getBlobSidecarWriter(); + ArrayList list = new ArrayList<>(); + list.add(createBlobSidecar()); + assertTrue(blobWriter.archive(list)); + // Try to write the same file again + assertFalse(blobWriter.archive(list)); + blobWriter.close(); + } +} diff --git a/storage/src/test/java/tech/pegasys/teku/storage/client/BlobSidecarReconstructionProviderTest.java b/storage/src/test/java/tech/pegasys/teku/storage/client/BlobSidecarReconstructionProviderTest.java index a14e5a86d33..da2994e8372 100644 --- a/storage/src/test/java/tech/pegasys/teku/storage/client/BlobSidecarReconstructionProviderTest.java +++ b/storage/src/test/java/tech/pegasys/teku/storage/client/BlobSidecarReconstructionProviderTest.java @@ -53,13 +53,14 @@ import tech.pegasys.teku.spec.datastructures.blocks.SlotAndBlockRoot; import tech.pegasys.teku.spec.datastructures.blocks.blockbody.BeaconBlockBody; import tech.pegasys.teku.spec.datastructures.util.DataColumnSlotAndIdentifier; -import tech.pegasys.teku.spec.logic.versions.eip7594.helpers.MiscHelpersEip7594; +import tech.pegasys.teku.spec.logic.versions.feature.eip7594.helpers.MiscHelpersEip7594; import tech.pegasys.teku.spec.schemas.SchemaDefinitionsEip7594; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsElectra; import tech.pegasys.teku.spec.util.DataStructureUtil; public class BlobSidecarReconstructionProviderTest { private final CombinedChainDataClient client = mock(CombinedChainDataClient.class); - private final Spec spec = TestSpecFactory.createMinimalEip7594(); + private final Spec spec = TestSpecFactory.createMinimalElectraEip7594(); private final KZG kzg = mock(KZG.class); private final BlobSidecarReconstructionProvider blobSidecarReconstructionProvider = @@ -205,7 +206,7 @@ public void shouldReturnBlobs() { final BlobsAndMatrix blobsAndMatrix = loadBlobsAndMatrixFixture(); final MiscHelpersEip7594 miscHelpersEip7594 = - MiscHelpersEip7594.required(spec.forMilestone(SpecMilestone.EIP7594).miscHelpers()); + MiscHelpersEip7594.required(spec.forMilestone(SpecMilestone.ELECTRA).miscHelpers()); final List dataColumnSidecars = miscHelpersEip7594.constructDataColumnSidecars( @@ -256,7 +257,7 @@ public void shouldReturnBlobsFiltered() { final BlobsAndMatrix blobsAndMatrix = loadBlobsAndMatrixFixture(); final MiscHelpersEip7594 miscHelpersEip7594 = - MiscHelpersEip7594.required(spec.forMilestone(SpecMilestone.EIP7594).miscHelpers()); + MiscHelpersEip7594.required(spec.forMilestone(SpecMilestone.ELECTRA).miscHelpers()); final List dataColumnSidecars = miscHelpersEip7594.constructDataColumnSidecars( @@ -289,12 +290,15 @@ private BlobsAndMatrix loadBlobsAndMatrixFixture() { final List cellData = loadJson(); final SchemaDefinitionsEip7594 schemaDefinitionsEip7594 = SchemaDefinitionsEip7594.required( - spec.forMilestone(SpecMilestone.EIP7594).getSchemaDefinitions()); + spec.forMilestone(SpecMilestone.ELECTRA).getSchemaDefinitions()); + final SchemaDefinitionsElectra schemaDefinitionsElectra = + SchemaDefinitionsElectra.required( + spec.forMilestone(SpecMilestone.ELECTRA).getSchemaDefinitions()); final List blobs = cellData.stream() .map( blobAndCells -> - schemaDefinitionsEip7594 + schemaDefinitionsElectra .getBlobSchema() .create(Bytes.fromHexString(blobAndCells.blob))) .toList(); diff --git a/storage/src/test/java/tech/pegasys/teku/storage/client/ChainHeadTest.java b/storage/src/test/java/tech/pegasys/teku/storage/client/ChainHeadTest.java index 2072c7cf455..0614d17dfed 100644 --- a/storage/src/test/java/tech/pegasys/teku/storage/client/ChainHeadTest.java +++ b/storage/src/test/java/tech/pegasys/teku/storage/client/ChainHeadTest.java @@ -53,10 +53,9 @@ public void equals_shouldBNotBeEqualWhenBlocksDiffer() { } @SuppressWarnings("unchecked") - private ChainHead copy(SignedBlockAndState original) { + private ChainHead copy(final SignedBlockAndState original) { final SignedBeaconBlock originalBlock = original.getSignedBeaconBlock().orElseThrow(); - final SignedBeaconBlock blockCopy = - copy(originalBlock, (SszSchema) originalBlock.getSchema()); + final SignedBeaconBlock blockCopy = copy(originalBlock, originalBlock.getSchema()); final BeaconState stateCopy = copy( original.getState(), diff --git a/storage/src/test/java/tech/pegasys/teku/storage/client/LateBlockReorgLogicTest.java b/storage/src/test/java/tech/pegasys/teku/storage/client/LateBlockReorgLogicTest.java index 53c8ff33577..e4aad091a82 100644 --- a/storage/src/test/java/tech/pegasys/teku/storage/client/LateBlockReorgLogicTest.java +++ b/storage/src/test/java/tech/pegasys/teku/storage/client/LateBlockReorgLogicTest.java @@ -269,7 +269,7 @@ void isForkChoiceStableAndFinalizationOk(final int slot, final boolean expectati @MethodSource("isMissingDataTests") void isMissingData( final Optional maybeBlock, - Optional maybeCurrentSlot, + final Optional maybeCurrentSlot, final boolean expectedResult) { assertThat(reorgLogicInstrumented.isMissingData(maybeBlock, maybeCurrentSlot)) .isEqualTo(expectedResult); @@ -521,7 +521,9 @@ public static Stream stableForkChoiceTests() { static class LateBlockReorgLogicInstrumented extends LateBlockReorgLogic { public LateBlockReorgLogicInstrumented( - Spec spec, RecentChainData recentChainData, Supplier timeProviderSupplier) { + final Spec spec, + final RecentChainData recentChainData, + final Supplier timeProviderSupplier) { super(spec, recentChainData, timeProviderSupplier); } diff --git a/storage/src/test/java/tech/pegasys/teku/storage/client/RecentChainDataTest.java b/storage/src/test/java/tech/pegasys/teku/storage/client/RecentChainDataTest.java index 6867e398877..c040f5e291b 100644 --- a/storage/src/test/java/tech/pegasys/teku/storage/client/RecentChainDataTest.java +++ b/storage/src/test/java/tech/pegasys/teku/storage/client/RecentChainDataTest.java @@ -13,7 +13,6 @@ package tech.pegasys.teku.storage.client; -import static java.util.stream.Collectors.toList; import static org.assertj.core.api.Assertions.assertThat; import static tech.pegasys.teku.infrastructure.async.SafeFutureAssert.assertThatSafeFuture; import static tech.pegasys.teku.infrastructure.time.TimeUtilities.secondsToMillis; @@ -475,7 +474,7 @@ public void updateHead_reorgEventWhenChainSwitchesToNewBlockAtSameSlot() { .streamValidAttestationsForBlockAtSlot(ONE) .map(attestation -> BlockOptions.create().addAttestation(attestation)) .limit(2) - .collect(toList()); + .toList(); final ChainBuilder forkBuilder = chainBuilder.fork(); final SignedBlockAndState latestBlockAndState = chainBuilder.generateBlockAtSlot(UInt64.valueOf(2), blockOptions.get(0)); @@ -520,7 +519,7 @@ public void updateHead_reorgEventWhenChainSwitchesToNewBlockAtLaterSlot() { .streamValidAttestationsForBlockAtSlot(ONE) .map(attestation -> BlockOptions.create().addAttestation(attestation)) .limit(2) - .collect(toList()); + .toList(); final ChainBuilder forkBuilder = chainBuilder.fork(); final SignedBlockAndState latestBlockAndState = chainBuilder.generateBlockAtSlot(UInt64.valueOf(2), blockOptions.get(0)); @@ -871,7 +870,7 @@ public void getAncestorsOnFork() { .streamValidAttestationsForBlockAtSlot(ONE) .map(attestation -> BlockOptions.create().addAttestation(attestation)) .limit(2) - .collect(toList()); + .toList(); final ChainBuilder forkBuilder = chainBuilder.fork(); final SignedBlockAndState firstBlockAndState = @@ -965,9 +964,7 @@ private void testCommitPruningOfParallelBlocks(final boolean pruneNewBlocks) { // Check that only recent, canonical blocks at or after the latest finalized block are left in // the store final List expectedBlocks = - chainBuilder - .streamBlocksAndStates(finalizedCheckpoint.getEpochStartSlot(spec)) - .collect(Collectors.toList()); + chainBuilder.streamBlocksAndStates(finalizedCheckpoint.getEpochStartSlot(spec)).toList(); final Set blockRoots = expectedBlocks.stream().map(SignedBlockAndState::getRoot).collect(Collectors.toSet()); // Collect blocks that should be pruned @@ -1006,14 +1003,15 @@ private void importBlocksAndStates( transaction.commit().join(); } - private SignedBlockAndState addNewBestBlock(RecentChainData recentChainData) { + private SignedBlockAndState addNewBestBlock(final RecentChainData recentChainData) { final SignedBlockAndState nextBlock = chainBuilder.generateNextBlock(); updateHead(recentChainData, nextBlock); return nextBlock; } - private void updateHead(RecentChainData recentChainData, final SignedBlockAndState bestBlock) { + private void updateHead( + final RecentChainData recentChainData, final SignedBlockAndState bestBlock) { saveBlock(recentChainData, bestBlock); this.recentChainData.updateHead(bestBlock.getRoot(), bestBlock.getSlot()); @@ -1026,7 +1024,7 @@ private SignedBlockAndState advanceBestBlock(final RecentChainData recentChainDa } private void finalizeBlock( - RecentChainData recentChainData, + final RecentChainData recentChainData, final UInt64 epoch, final SignedBlockAndState finalizedBlock) { saveBlock(recentChainData, finalizedBlock); diff --git a/storage/src/test/java/tech/pegasys/teku/storage/protoarray/ProtoArrayScoreCalculatorTest.java b/storage/src/test/java/tech/pegasys/teku/storage/protoarray/ProtoArrayScoreCalculatorTest.java index 8a4a109818d..af0d89a4d7d 100644 --- a/storage/src/test/java/tech/pegasys/teku/storage/protoarray/ProtoArrayScoreCalculatorTest.java +++ b/storage/src/test/java/tech/pegasys/teku/storage/protoarray/ProtoArrayScoreCalculatorTest.java @@ -33,14 +33,14 @@ public class ProtoArrayScoreCalculatorTest { - private Object2IntMap indices = new Object2IntOpenHashMap<>(); + private final Object2IntMap indices = new Object2IntOpenHashMap<>(); private List oldBalances = new ArrayList<>(); private List newBalances = new ArrayList<>(); private Optional oldProposerBoostRoot = Optional.empty(); private Optional newProposerBoostRoot = Optional.empty(); private UInt64 oldProposerBoostAmount = ZERO; private UInt64 newProposerBoostAmount = ZERO; - private VoteUpdater store = createStoreToManipulateVotes(); + private final VoteUpdater store = createStoreToManipulateVotes(); private Optional getIndex(final Bytes32 root) { return Optional.ofNullable(indices.get(root)); @@ -581,7 +581,7 @@ void computeDeltas_validatorEquivocatesChain() { } } - private void votesShouldBeUpdated(VoteUpdater store) { + private void votesShouldBeUpdated(final VoteUpdater store) { UInt64.rangeClosed(ZERO, store.getHighestVotedValidatorIndex()) .forEach( i -> { diff --git a/storage/src/test/java/tech/pegasys/teku/storage/server/ChainStorageTest.java b/storage/src/test/java/tech/pegasys/teku/storage/server/ChainStorageTest.java index 16a97ef1fcb..b5b512f49aa 100644 --- a/storage/src/test/java/tech/pegasys/teku/storage/server/ChainStorageTest.java +++ b/storage/src/test/java/tech/pegasys/teku/storage/server/ChainStorageTest.java @@ -186,9 +186,7 @@ public void testOnFinalized( assertThatSafeFuture(blockResult).isCompletedWithEmptyOptional(); final SafeFuture> sidecarKeysResult = chainStorage.getBlobSidecarKeys( - missingHistoricalBlock.getSlot(), - missingHistoricalBlock.getSlot(), - UInt64.valueOf(Long.MAX_VALUE)); + missingHistoricalBlock.getSlot(), missingHistoricalBlock.getSlot(), Long.MAX_VALUE); assertThatSafeFuture(sidecarKeysResult).isCompletedWithValueMatching(List::isEmpty); } @@ -233,7 +231,7 @@ public void testOnFinalized( .getBlobSidecarKeys( missingHistoricalBlock.getSlot(), missingHistoricalBlock.getSlot(), - UInt64.valueOf(Long.MAX_VALUE)) + Long.MAX_VALUE) .thenCompose( list -> SafeFuture.collectAll( @@ -308,9 +306,7 @@ public void testOverrideEarliestBlobSidecarSlot( assertThatSafeFuture(blockResult).isCompletedWithEmptyOptional(); final SafeFuture> sidecarKeysResult = chainStorage.getBlobSidecarKeys( - missingHistoricalBlock.getSlot(), - missingHistoricalBlock.getSlot(), - UInt64.valueOf(Long.MAX_VALUE)); + missingHistoricalBlock.getSlot(), missingHistoricalBlock.getSlot(), Long.MAX_VALUE); assertThatSafeFuture(sidecarKeysResult).isCompletedWithValueMatching(List::isEmpty); } @@ -447,7 +443,7 @@ public void onFinalizedBlocks_gapBetweenBatchAndEarliestKnownBlock( .map(SignedBlockAndState::getBlock) .collect(Collectors.toList()); // Remove a block from the end - blocks.remove(blocks.size() - 1); + blocks.removeLast(); final SafeFuture result = chainStorage.onFinalizedBlocks(blocks, Map.of(), Optional.empty()); diff --git a/storage/src/test/java/tech/pegasys/teku/storage/server/CombinedStorageChannelSplitterTest.java b/storage/src/test/java/tech/pegasys/teku/storage/server/CombinedStorageChannelSplitterTest.java index c3cd8be5d47..9a10cd9594d 100644 --- a/storage/src/test/java/tech/pegasys/teku/storage/server/CombinedStorageChannelSplitterTest.java +++ b/storage/src/test/java/tech/pegasys/teku/storage/server/CombinedStorageChannelSplitterTest.java @@ -66,12 +66,12 @@ private Object[] prepareArgs(final Method method) { .map( parameter -> { if (parameter.getType().isPrimitive()) { - switch (parameter.getType().getName()) { - case "int": - return 0; - default: - throw new RuntimeException("unsupported primitive type"); - } + final String type = parameter.getType().getName(); + return switch (type) { + case "int" -> 0; + case "long" -> 0L; + default -> throw new RuntimeException("unsupported primitive type: " + type); + }; } else { return null; } diff --git a/storage/src/test/java/tech/pegasys/teku/storage/server/DatabaseStorageModeFileHelperTest.java b/storage/src/test/java/tech/pegasys/teku/storage/server/DatabaseStorageModeFileHelperTest.java new file mode 100644 index 00000000000..d0bd3c2c88d --- /dev/null +++ b/storage/src/test/java/tech/pegasys/teku/storage/server/DatabaseStorageModeFileHelperTest.java @@ -0,0 +1,65 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.storage.server; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.api.Assertions.fail; +import static tech.pegasys.teku.storage.server.VersionedDatabaseFactory.STORAGE_MODE_PATH; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; + +class DatabaseStorageModeFileHelperTest { + + @Test + public void shouldReadValidStorageModeFile(@TempDir final Path tempDir) { + final Path dbStorageModeFile = + createDatabaseStorageModeFile(tempDir, StateStorageMode.MINIMAL.toString()); + assertThat(DatabaseStorageModeFileHelper.readStateStorageMode(dbStorageModeFile)) + .hasValue(StateStorageMode.MINIMAL); + } + + @Test + public void shouldReadEmptyWhenFileDoesNotExist(@TempDir final Path tempDir) { + final Path dbStorageModeFile = tempDir.resolve("foo"); + assertThat(DatabaseStorageModeFileHelper.readStateStorageMode(dbStorageModeFile)).isEmpty(); + } + + @Test + public void shouldThrowErrorIfFileHasInvalidValue(@TempDir final Path tempDir) { + final Path dbStorageModeFile = createDatabaseStorageModeFile(tempDir, "hello"); + assertThatThrownBy(() -> DatabaseStorageModeFileHelper.readStateStorageMode(dbStorageModeFile)) + .isInstanceOf(DatabaseStorageException.class); + } + + @Test + public void shouldThrowErrorIfFileIsEmpty(@TempDir final Path tempDir) { + final Path dbStorageModeFile = createDatabaseStorageModeFile(tempDir, ""); + assertThatThrownBy(() -> DatabaseStorageModeFileHelper.readStateStorageMode(dbStorageModeFile)) + .isInstanceOf(DatabaseStorageException.class); + } + + private Path createDatabaseStorageModeFile(final Path path, final String value) { + try { + return Files.writeString(path.resolve(STORAGE_MODE_PATH), value); + } catch (IOException e) { + fail(e); + return null; + } + } +} diff --git a/storage/src/test/java/tech/pegasys/teku/storage/server/MultiThreadedStoreTest.java b/storage/src/test/java/tech/pegasys/teku/storage/server/MultiThreadedStoreTest.java index a26bb36b9c5..2bac0453075 100644 --- a/storage/src/test/java/tech/pegasys/teku/storage/server/MultiThreadedStoreTest.java +++ b/storage/src/test/java/tech/pegasys/teku/storage/server/MultiThreadedStoreTest.java @@ -98,7 +98,7 @@ private void tryToClose() { } } - private Runnable createStoreTaskForSlot(long slotNumber) { + private Runnable createStoreTaskForSlot(final long slotNumber) { return () -> { final StoreTransaction transaction = recentChainData.startStoreTransaction(); final SignedBlockAndState block = chainBuilder.generateBlockAtSlot(slotNumber); diff --git a/storage/src/test/java/tech/pegasys/teku/storage/server/StorageConfigurationTest.java b/storage/src/test/java/tech/pegasys/teku/storage/server/StorageConfigurationTest.java index 63de8a8ca57..f6755b87bfa 100644 --- a/storage/src/test/java/tech/pegasys/teku/storage/server/StorageConfigurationTest.java +++ b/storage/src/test/java/tech/pegasys/teku/storage/server/StorageConfigurationTest.java @@ -13,21 +13,38 @@ package tech.pegasys.teku.storage.server; +import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy; import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat; import static tech.pegasys.teku.storage.server.StateStorageMode.ARCHIVE; import static tech.pegasys.teku.storage.server.StateStorageMode.MINIMAL; import static tech.pegasys.teku.storage.server.StateStorageMode.NOT_SET; import static tech.pegasys.teku.storage.server.StateStorageMode.PRUNE; +import static tech.pegasys.teku.storage.server.VersionedDatabaseFactory.STORAGE_MODE_PATH; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.time.Duration; import java.util.ArrayList; import java.util.Optional; import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; +import tech.pegasys.teku.ethereum.execution.types.Eth1Address; +import tech.pegasys.teku.infrastructure.exceptions.InvalidConfigurationException; +import tech.pegasys.teku.service.serviceutils.layout.DataConfig; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.TestSpecFactory; public class StorageConfigurationTest { + final Spec spec = TestSpecFactory.createMinimalPhase0(); + final Eth1Address eth1Address = + Eth1Address.fromHexString("0x77f7bED277449F51505a4C54550B074030d989bC"); + public static Stream getStateStorageDefaultScenarios() { ArrayList args = new ArrayList<>(); args.add(Arguments.of(false, Optional.empty(), NOT_SET, MINIMAL)); @@ -58,4 +75,98 @@ void shouldDetermineCorrectStorageModeGivenInputs( isExistingStore, maybePreviousStorageMode, requestedMode)) .isEqualTo(expectedResult); } + + @Test + public void shouldFailIfDatabaseStorageModeFileIsInvalidAndNoExplicitOptionIsSet( + @TempDir final Path dir) throws IOException { + createInvalidStorageModeFile(dir); + final DataConfig dataConfig = DataConfig.builder().beaconDataPath(dir).build(); + + final StorageConfiguration.Builder storageConfigBuilder = + StorageConfiguration.builder() + .specProvider(spec) + .dataConfig(dataConfig) + .eth1DepositContract(eth1Address); + + assertThatThrownBy(storageConfigBuilder::build).isInstanceOf(DatabaseStorageException.class); + } + + @Test + public void shouldSucceedIfDatabaseStorageModeFileIsInvalidAndExplicitOptionIsSet( + @TempDir final Path dir) throws IOException { + createInvalidStorageModeFile(dir); + final DataConfig dataConfig = DataConfig.builder().beaconDataPath(dir).build(); + + final StorageConfiguration storageConfig = + StorageConfiguration.builder() + .specProvider(spec) + .dataConfig(dataConfig) + .eth1DepositContract(eth1Address) + .dataStorageMode(ARCHIVE) + .build(); + + assertThat(storageConfig.getDataStorageMode()).isEqualTo(ARCHIVE); + } + + @Test + public void shouldFailIfUserConfiguresStatePruneSlotsRetainedLowerThanAllowed() { + + assertThatThrownBy( + () -> StorageConfiguration.builder().dataStorageMode(ARCHIVE).retainedSlots(-1)) + .isInstanceOf(InvalidConfigurationException.class) + .hasMessageContaining("Invalid number of slots to retain finalized states for"); + } + + @Test + public void shouldFailIfUserConfiguresStatePrunerLowerThanAllowed() { + + assertThatThrownBy( + () -> + StorageConfiguration.builder() + .dataStorageMode(ARCHIVE) + .statePruningInterval(Duration.ofSeconds(1))) + .isInstanceOf(InvalidConfigurationException.class) + .hasMessageContaining( + "Block pruning interval must be a value between 30 seconds and 1 day"); + } + + @Test + public void shouldFailIfUserConfiguresStatePrunerIntervalGreaterThanAllowed() { + + assertThatThrownBy( + () -> + StorageConfiguration.builder() + .dataStorageMode(ARCHIVE) + .statePruningInterval(Duration.ofDays(2))) + .isInstanceOf(InvalidConfigurationException.class) + .hasMessageContaining( + "Block pruning interval must be a value between 30 seconds and 1 day"); + } + + @Test + public void shouldFailIfUserConfiguresStatePrunerLimitGreaterThanAllowed() { + + assertThatThrownBy( + () -> StorageConfiguration.builder().dataStorageMode(ARCHIVE).statePruningLimit(101)) + .isInstanceOf(InvalidConfigurationException.class) + .hasMessageContaining("Invalid statePruningLimit:"); + } + + private static void createInvalidStorageModeFile(final Path dir) throws IOException { + // An empty storage mode path is invalid + Files.createFile(dir.resolve(STORAGE_MODE_PATH)); + } + + @Test + public void shouldFailIfUserEnableStatePrunerUsingTreeMode() { + assertThatThrownBy( + () -> + StorageConfiguration.builder() + .dataStorageMode(ARCHIVE) + .dataStorageFrequency(1) + .retainedSlots(2048) + .build()) + .isInstanceOf(InvalidConfigurationException.class) + .hasMessageContaining("State pruner cannot be enabled using tree mode storage"); + } } diff --git a/storage/src/test/java/tech/pegasys/teku/storage/server/VersionedDatabaseFactoryTest.java b/storage/src/test/java/tech/pegasys/teku/storage/server/VersionedDatabaseFactoryTest.java index fd256b787b8..991c77334db 100644 --- a/storage/src/test/java/tech/pegasys/teku/storage/server/VersionedDatabaseFactoryTest.java +++ b/storage/src/test/java/tech/pegasys/teku/storage/server/VersionedDatabaseFactoryTest.java @@ -22,6 +22,7 @@ import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; +import java.util.Optional; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.io.TempDir; import org.junit.jupiter.params.ParameterizedTest; @@ -50,7 +51,8 @@ public void createDatabase_fromEmptyDataDir() throws Exception { StorageConfiguration.builder() .specProvider(spec) .eth1DepositContract(eth1Address) - .build()); + .build(), + Optional.empty()); try (final Database db = dbFactory.createDatabase()) { assertThat(db).isNotNull(); @@ -76,7 +78,8 @@ public void createDatabase_fromExistingDataDir() throws Exception { StorageConfiguration.builder() .specProvider(spec) .eth1DepositContract(eth1Address) - .build()); + .build(), + Optional.empty()); try (final Database db = dbFactory.createDatabase()) { assertThat(db).isNotNull(); @@ -97,7 +100,8 @@ public void createDatabase_invalidVersionFile() throws Exception { StorageConfiguration.builder() .specProvider(spec) .eth1DepositContract(eth1Address) - .build()); + .build(), + Optional.empty()); assertThatThrownBy(dbFactory::createDatabase) .isInstanceOf(DatabaseStorageException.class) @@ -115,7 +119,8 @@ public void createDatabase_dbExistsButNoVersionIsSaved() { StorageConfiguration.builder() .specProvider(spec) .eth1DepositContract(eth1Address) - .build()); + .build(), + Optional.empty()); assertThatThrownBy(dbFactory::createDatabase) .isInstanceOf(DatabaseStorageException.class) @@ -135,7 +140,8 @@ public void createDatabase_shouldAllowAllSupportedDatabases(final DatabaseVersio .eth1DepositContract(eth1Address) .dataStorageMode(DATA_STORAGE_MODE) .dataStorageCreateDbVersion(version) - .build()); + .build(), + Optional.empty()); assertThat(dbFactory.getDatabaseVersion()).isEqualTo(version); } diff --git a/storage/src/test/java/tech/pegasys/teku/storage/server/network/DatabaseNetworkTest.java b/storage/src/test/java/tech/pegasys/teku/storage/server/network/DatabaseNetworkTest.java index d2ffefe2636..e37e7dcc8c5 100644 --- a/storage/src/test/java/tech/pegasys/teku/storage/server/network/DatabaseNetworkTest.java +++ b/storage/src/test/java/tech/pegasys/teku/storage/server/network/DatabaseNetworkTest.java @@ -13,13 +13,22 @@ package tech.pegasys.teku.storage.server.network; +import static com.fasterxml.jackson.dataformat.yaml.YAMLGenerator.Feature.WRITE_DOC_START_MARKER; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.dataformat.yaml.YAMLFactory; import java.io.File; import java.io.IOException; +import java.nio.file.Files; import java.util.Locale; +import java.util.Optional; +import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.io.TempDir; import tech.pegasys.teku.ethereum.execution.types.Eth1Address; @@ -30,56 +39,147 @@ public class DatabaseNetworkTest { DataStructureUtil dataStructureUtil = new DataStructureUtil(TestSpecFactory.createDefault()); + private ObjectMapper objectMapper; + private static final String NETWORK_FILENAME = "network.yml"; + + @BeforeEach + void setUp() { + objectMapper = new ObjectMapper(new YAMLFactory().disable(WRITE_DOC_START_MARKER)); + } @Test public void shouldCreateNetworkFile(@TempDir final File tempDir) throws IOException { - final File networkFile = new File(tempDir, "network.yml"); + final File networkFile = new File(tempDir, NETWORK_FILENAME); assertThat(networkFile).doesNotExist(); final Bytes4 fork = dataStructureUtil.randomFork().getCurrentVersion(); final Eth1Address eth1Address = dataStructureUtil.randomEth1Address(); - assertThat(DatabaseNetwork.init(networkFile, fork, eth1Address)) + final Long depositChainId = dataStructureUtil.randomLong(); + assertThat( + DatabaseNetwork.init(networkFile, fork, eth1Address, depositChainId, Optional.empty())) .isEqualTo( new DatabaseNetwork( fork.toHexString().toLowerCase(Locale.ROOT), - eth1Address.toHexString().toLowerCase(Locale.ROOT))); + eth1Address.toHexString().toLowerCase(Locale.ROOT), + depositChainId)); assertThat(networkFile).exists(); } @Test public void shouldThrowIfForkDiffers(@TempDir final File tempDir) throws IOException { - final File networkFile = new File(tempDir, "network.yml"); + final File networkFile = new File(tempDir, NETWORK_FILENAME); assertThat(networkFile).doesNotExist(); final Bytes4 fork = dataStructureUtil.randomFork().getCurrentVersion(); final Eth1Address eth1Address = dataStructureUtil.randomEth1Address(); + final Long depositChainId = dataStructureUtil.randomLong(); DatabaseNetwork.init( - networkFile, dataStructureUtil.randomFork().getCurrentVersion(), eth1Address); + networkFile, + dataStructureUtil.randomFork().getCurrentVersion(), + eth1Address, + depositChainId, + Optional.empty()); - assertThatThrownBy(() -> DatabaseNetwork.init(networkFile, fork, eth1Address)) + assertThatThrownBy( + () -> + DatabaseNetwork.init( + networkFile, fork, eth1Address, depositChainId, Optional.empty())) .isInstanceOf(DatabaseStorageException.class) .hasMessageStartingWith("Supplied fork version"); } @Test public void shouldThrowIfDepositContractDiffers(@TempDir final File tempDir) throws IOException { - final File networkFile = new File(tempDir, "network.yml"); + final File networkFile = new File(tempDir, NETWORK_FILENAME); assertThat(networkFile).doesNotExist(); final Bytes4 fork = dataStructureUtil.randomFork().getCurrentVersion(); final Eth1Address eth1Address = dataStructureUtil.randomEth1Address(); - DatabaseNetwork.init(networkFile, fork, dataStructureUtil.randomEth1Address()); + final Long depositChainId = dataStructureUtil.randomLong(); - assertThatThrownBy(() -> DatabaseNetwork.init(networkFile, fork, eth1Address)) + DatabaseNetwork.init( + networkFile, fork, dataStructureUtil.randomEth1Address(), depositChainId, Optional.empty()); + + assertThatThrownBy( + () -> + DatabaseNetwork.init( + networkFile, fork, eth1Address, depositChainId, Optional.empty())) .isInstanceOf(DatabaseStorageException.class) .hasMessageStartingWith("Supplied deposit contract"); } @Test public void shouldNotThrowIfForkAndContractMatch(@TempDir final File tempDir) throws IOException { - final File networkFile = new File(tempDir, "network.yml"); + final File networkFile = new File(tempDir, NETWORK_FILENAME); assertThat(networkFile).doesNotExist(); final Bytes4 fork = dataStructureUtil.randomFork().getCurrentVersion(); final Eth1Address eth1Address = dataStructureUtil.randomEth1Address(); - DatabaseNetwork.init(networkFile, fork, eth1Address); + final Long depositChainId = dataStructureUtil.randomLong(); + + DatabaseNetwork.init(networkFile, fork, eth1Address, depositChainId, Optional.empty()); + + assertDoesNotThrow( + () -> + DatabaseNetwork.init(networkFile, fork, eth1Address, depositChainId, Optional.empty())); + } + + @Test + void shouldWriteAndReadDatabaseNetworkWithDepositChainId(@TempDir final File tempDir) + throws IOException { + final File networkFile = new File(tempDir, NETWORK_FILENAME); + + final Bytes4 fork = dataStructureUtil.randomFork().getCurrentVersion(); + final Eth1Address eth1Address = dataStructureUtil.randomEth1Address(); + final Long depositChainId = dataStructureUtil.randomLong(); + final DatabaseNetwork databaseNetwork = + new DatabaseNetwork(fork.toHexString(), eth1Address.toHexString(), depositChainId); + + objectMapper.writerFor(DatabaseNetwork.class).writeValue(networkFile, databaseNetwork); + final DatabaseNetwork readDatabaseNetwork = + objectMapper.readerFor(DatabaseNetwork.class).readValue(networkFile); + + assertEquals(fork.toHexString(), readDatabaseNetwork.forkVersion); + assertEquals(eth1Address.toHexString(), readDatabaseNetwork.depositContract); + assertEquals(depositChainId, readDatabaseNetwork.depositChainId); + } + + @Test + void shouldWriteAndReadDatabaseNetworkWithoutDepositChainId(@TempDir final File tempDir) + throws IOException { + final File networkFile = new File(tempDir, NETWORK_FILENAME); + + final Bytes4 fork = dataStructureUtil.randomFork().getCurrentVersion(); + final Eth1Address eth1Address = dataStructureUtil.randomEth1Address(); + + final DatabaseNetwork databaseNetwork = + new DatabaseNetwork(fork.toHexString(), eth1Address.toHexString()); + + objectMapper.writerFor(DatabaseNetwork.class).writeValue(networkFile, databaseNetwork); + String networkContent = Files.readString(networkFile.toPath()); + + final DatabaseNetwork readDatabaseNetwork = + objectMapper.readerFor(DatabaseNetwork.class).readValue(networkFile); + + assertFalse(networkContent.contains("deposit_chain_id")); + assertEquals(fork.toHexString(), readDatabaseNetwork.forkVersion); + assertEquals(eth1Address.toHexString(), readDatabaseNetwork.depositContract); + assertNull(readDatabaseNetwork.depositChainId); + } + + @Test + void shouldNotIncludeDepositChainIdWhenNull(@TempDir final File tempDir) throws IOException { + final File networkFile = new File(tempDir, NETWORK_FILENAME); + + final Bytes4 fork = dataStructureUtil.randomFork().getCurrentVersion(); + final Eth1Address eth1Address = dataStructureUtil.randomEth1Address(); + + final DatabaseNetwork databaseNetwork = + new DatabaseNetwork(fork.toHexString(), eth1Address.toHexString(), null); + + objectMapper.writerFor(DatabaseNetwork.class).writeValue(networkFile, databaseNetwork); + String networkContent = Files.readString(networkFile.toPath()); + + final DatabaseNetwork readDatabaseNetwork = + objectMapper.readerFor(DatabaseNetwork.class).readValue(networkFile); - assertDoesNotThrow(() -> DatabaseNetwork.init(networkFile, fork, eth1Address)); + assertFalse(networkContent.contains("deposit_chain_id")); + assertNull(readDatabaseNetwork.depositChainId); } } diff --git a/storage/src/test/java/tech/pegasys/teku/storage/server/pruner/BlobSidecarPrunerTest.java b/storage/src/test/java/tech/pegasys/teku/storage/server/pruner/BlobSidecarPrunerTest.java index d13ee5fe9c8..e4bca263f2f 100644 --- a/storage/src/test/java/tech/pegasys/teku/storage/server/pruner/BlobSidecarPrunerTest.java +++ b/storage/src/test/java/tech/pegasys/teku/storage/server/pruner/BlobSidecarPrunerTest.java @@ -23,6 +23,7 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import java.io.IOException; import java.time.Duration; import java.util.Optional; import org.junit.jupiter.api.BeforeEach; @@ -37,6 +38,8 @@ import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.config.SpecConfigDeneb; +import tech.pegasys.teku.storage.archive.DataArchive; +import tech.pegasys.teku.storage.archive.nooparchive.NoopDataArchive; import tech.pegasys.teku.storage.server.Database; public class BlobSidecarPrunerTest { @@ -48,17 +51,19 @@ public class BlobSidecarPrunerTest { private final int slotsPerEpoch = spec.getGenesisSpecConfig().getSlotsPerEpoch(); private final int secondsPerSlot = spec.getGenesisSpecConfig().getSecondsPerSlot(); - private UInt64 genesisTime = UInt64.valueOf(0); + private final UInt64 genesisTime = UInt64.valueOf(0); private final StubTimeProvider timeProvider = StubTimeProvider.withTimeInSeconds(0); private final StubAsyncRunner asyncRunner = new StubAsyncRunner(timeProvider); private final Database database = mock(Database.class); private final StubMetricsSystem stubMetricsSystem = new StubMetricsSystem(); + private final DataArchive dataArchive = new NoopDataArchive(); private final BlobSidecarPruner blobsPruner = new BlobSidecarPruner( spec, database, + dataArchive, stubMetricsSystem, asyncRunner, timeProvider, @@ -83,8 +88,8 @@ void shouldNotPruneWhenGenesisNotAvailable() { asyncRunner.executeDueActions(); verify(database).getGenesisTime(); - verify(database, never()).pruneOldestBlobSidecars(any(), anyInt()); - verify(database, never()).pruneOldestNonCanonicalBlobSidecars(any(), anyInt()); + verify(database, never()).pruneOldestBlobSidecars(any(), anyInt(), any()); + verify(database, never()).pruneOldestNonCanonicalBlobSidecars(any(), anyInt(), any()); } @Test @@ -92,8 +97,8 @@ void shouldNotPrunePriorGenesis() { asyncRunner.executeDueActions(); verify(database).getGenesisTime(); - verify(database, never()).pruneOldestBlobSidecars(any(), anyInt()); - verify(database, never()).pruneOldestNonCanonicalBlobSidecars(any(), anyInt()); + verify(database, never()).pruneOldestBlobSidecars(any(), anyInt(), any()); + verify(database, never()).pruneOldestNonCanonicalBlobSidecars(any(), anyInt(), any()); } @Test @@ -108,12 +113,12 @@ void shouldNotPruneWhenLatestPrunableIncludeGenesis() { timeProvider.advanceTimeBy(Duration.ofSeconds(currentTime.longValue())); asyncRunner.executeDueActions(); - verify(database, never()).pruneOldestBlobSidecars(any(), anyInt()); - verify(database, never()).pruneOldestNonCanonicalBlobSidecars(any(), anyInt()); + verify(database, never()).pruneOldestBlobSidecars(any(), anyInt(), any()); + verify(database, never()).pruneOldestNonCanonicalBlobSidecars(any(), anyInt(), any()); } @Test - void shouldPruneWhenLatestPrunableSlotIsGreaterThanOldestDAEpoch() { + void shouldPruneWhenLatestPrunableSlotIsGreaterThanOldestDAEpoch() throws IOException { final SpecConfig config = spec.forMilestone(SpecMilestone.DENEB).getConfig(); final SpecConfigDeneb specConfigDeneb = SpecConfigDeneb.required(config); // set current slot to MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS + 1 epoch + half epoch @@ -126,13 +131,20 @@ void shouldPruneWhenLatestPrunableSlotIsGreaterThanOldestDAEpoch() { timeProvider.advanceTimeBy(Duration.ofSeconds(currentTime.longValue())); asyncRunner.executeDueActions(); - verify(database).pruneOldestBlobSidecars(UInt64.valueOf((slotsPerEpoch / 2) - 1), PRUNE_LIMIT); verify(database) - .pruneOldestNonCanonicalBlobSidecars(UInt64.valueOf((slotsPerEpoch / 2) - 1), PRUNE_LIMIT); + .pruneOldestBlobSidecars( + UInt64.valueOf((slotsPerEpoch / 2) - 1), + PRUNE_LIMIT, + dataArchive.getBlobSidecarWriter()); + verify(database) + .pruneOldestNonCanonicalBlobSidecars( + UInt64.valueOf((slotsPerEpoch / 2) - 1), + PRUNE_LIMIT, + dataArchive.getBlobSidecarWriter()); } @Test - void shouldUseEpochsStoreBlobs() { + void shouldUseEpochsStoreBlobs() throws IOException { final SpecConfig config = spec.forMilestone(SpecMilestone.DENEB).getConfig(); final SpecConfigDeneb specConfigDeneb = SpecConfigDeneb.required(config); final int defaultValue = specConfigDeneb.getMinEpochsForBlobSidecarsRequests(); @@ -152,6 +164,7 @@ void shouldUseEpochsStoreBlobs() { new BlobSidecarPruner( specOverride, databaseOverride, + dataArchive, stubMetricsSystem, asyncRunner, timeProvider, @@ -175,7 +188,7 @@ void shouldUseEpochsStoreBlobs() { timeProvider.advanceTimeBy(Duration.ofSeconds(timeForSlotOne.longValue())); asyncRunner.executeDueActions(); - verify(databaseOverride, never()).pruneOldestBlobSidecars(any(), anyInt()); + verify(databaseOverride, never()).pruneOldestBlobSidecars(any(), anyInt(), any()); // move more to open pruning zone near genesis final UInt64 slotDelta = @@ -186,9 +199,15 @@ void shouldUseEpochsStoreBlobs() { asyncRunner.executeDueActions(); verify(databaseOverride) - .pruneOldestBlobSidecars(UInt64.valueOf((slotsPerEpoch / 2) - 1), PRUNE_LIMIT); + .pruneOldestBlobSidecars( + UInt64.valueOf((slotsPerEpoch / 2) - 1), + PRUNE_LIMIT, + dataArchive.getBlobSidecarWriter()); verify(databaseOverride) - .pruneOldestNonCanonicalBlobSidecars(UInt64.valueOf((slotsPerEpoch / 2) - 1), PRUNE_LIMIT); + .pruneOldestNonCanonicalBlobSidecars( + UInt64.valueOf((slotsPerEpoch / 2) - 1), + PRUNE_LIMIT, + dataArchive.getBlobSidecarWriter()); } @Test @@ -209,6 +228,7 @@ void shouldNotPruneWhenEpochsStoreBlobsIsMax() { new BlobSidecarPruner( specOverride, databaseOverride, + dataArchive, stubMetricsSystem, asyncRunner, timeProvider, @@ -230,7 +250,7 @@ void shouldNotPruneWhenEpochsStoreBlobsIsMax() { timeProvider.advanceTimeBy(Duration.ofSeconds(currentTime.longValue())); asyncRunner.executeDueActions(); - verify(databaseOverride, never()).pruneOldestBlobSidecars(any(), anyInt()); - verify(databaseOverride, never()).pruneOldestNonCanonicalBlobSidecars(any(), anyInt()); + verify(databaseOverride, never()).pruneOldestBlobSidecars(any(), anyInt(), any()); + verify(databaseOverride, never()).pruneOldestNonCanonicalBlobSidecars(any(), anyInt(), any()); } } diff --git a/storage/src/test/java/tech/pegasys/teku/storage/server/pruner/BlockPrunerTest.java b/storage/src/test/java/tech/pegasys/teku/storage/server/pruner/BlockPrunerTest.java index a9a2eb4137f..7af5b301857 100644 --- a/storage/src/test/java/tech/pegasys/teku/storage/server/pruner/BlockPrunerTest.java +++ b/storage/src/test/java/tech/pegasys/teku/storage/server/pruner/BlockPrunerTest.java @@ -72,7 +72,7 @@ class BlockPrunerTest { void setUp() { epochsToKeep = spec.getNetworkingConfig().getMinEpochsForBlockRequests(); assertThat(pruner.start()).isCompleted(); - when(database.pruneFinalizedBlocks(any(), anyInt())).thenReturn(UInt64.ZERO); + when(database.pruneFinalizedBlocks(any(), anyInt(), any())).thenReturn(UInt64.ZERO); } @Test @@ -80,7 +80,7 @@ void shouldPruneWhenFirstStarted() { when(database.getFinalizedCheckpoint()) .thenReturn(Optional.of(dataStructureUtil.randomCheckpoint(UInt64.valueOf(50)))); asyncRunner.executeDueActions(); - verify(database).pruneFinalizedBlocks(any(), eq(PRUNE_SLOTS)); + verify(database).pruneFinalizedBlocks(any(), eq(PRUNE_SLOTS), any()); verify(pruningActiveLabelledGauge).set(eq(0.), any()); } @@ -88,12 +88,12 @@ void shouldPruneWhenFirstStarted() { void shouldPruneAfterInterval() { when(database.getFinalizedCheckpoint()).thenReturn(Optional.empty()); asyncRunner.executeDueActions(); - verify(database, never()).pruneFinalizedBlocks(any(), eq(PRUNE_SLOTS)); + verify(database, never()).pruneFinalizedBlocks(any(), eq(PRUNE_SLOTS), any()); when(database.getFinalizedCheckpoint()) .thenReturn(Optional.of(dataStructureUtil.randomCheckpoint(UInt64.valueOf(52)))); triggerNextPruning(); - verify(database).pruneFinalizedBlocks(any(), eq(PRUNE_SLOTS)); + verify(database).pruneFinalizedBlocks(any(), eq(PRUNE_SLOTS), any()); verify(pruningActiveLabelledGauge, times(2)).set(eq(0.), any()); } @@ -101,7 +101,7 @@ void shouldPruneAfterInterval() { void shouldNotPruneWhenFinalizedCheckpointNotSet() { when(database.getFinalizedCheckpoint()).thenReturn(Optional.empty()); triggerNextPruning(); - verify(database, never()).pruneFinalizedBlocks(any(), eq(PRUNE_SLOTS)); + verify(database, never()).pruneFinalizedBlocks(any(), eq(PRUNE_SLOTS), any()); verify(pruningActiveLabelledGauge).set(eq(0.), any()); } @@ -110,32 +110,35 @@ void shouldNotPruneWhenFinalizedCheckpointBelowEpochsToKeep() { when(database.getFinalizedCheckpoint()) .thenReturn(Optional.of(dataStructureUtil.randomCheckpoint(epochsToKeep))); triggerNextPruning(); - verify(database, never()).pruneFinalizedBlocks(any(), eq(PRUNE_SLOTS)); + verify(database, never()).pruneFinalizedBlocks(any(), eq(PRUNE_SLOTS), any()); verify(pruningActiveLabelledGauge).set(eq(0.), any()); } @Test void shouldPruneBlocksMoreThanEpochsToKeepBeforeFinalizedCheckpoint() { final UInt64 finalizedEpoch = UInt64.valueOf(50); + final UInt64 checkpointEarliestSlot = spec.computeStartSlotAtEpoch(finalizedEpoch); when(database.getFinalizedCheckpoint()) .thenReturn(Optional.of(dataStructureUtil.randomCheckpoint(finalizedEpoch))); triggerNextPruning(); // SlotToKeep = FinalizedEpoch (50) * SlotsPerEpoch(10) - EpochsToKeep(5) * SlotsPerEpoch(10) // = 500 - 50 = 450, last slot to prune = 450 - 1 = 449. final UInt64 lastSlotToPrune = UInt64.valueOf(449); - verify(database).pruneFinalizedBlocks(lastSlotToPrune, PRUNE_SLOTS); + verify(database).pruneFinalizedBlocks(lastSlotToPrune, PRUNE_SLOTS, checkpointEarliestSlot); verify(pruningActiveLabelledGauge).set(eq(0.), any()); } @Test void shouldPruneBlocksWhenFirstEpochIsPrunable() { final int finalizedEpoch = epochsToKeep + 1; + final UInt64 checkpointEarliestSlot = + spec.computeStartSlotAtEpoch(UInt64.valueOf(finalizedEpoch)); when(database.getFinalizedCheckpoint()) .thenReturn(Optional.of(dataStructureUtil.randomCheckpoint(finalizedEpoch))); triggerNextPruning(); // Should prune all blocks in the first epoch (ie blocks 0 - 9) final UInt64 lastSlotToPrune = UInt64.valueOf(SLOTS_PER_EPOCH - 1); - verify(database).pruneFinalizedBlocks(lastSlotToPrune, PRUNE_SLOTS); + verify(database).pruneFinalizedBlocks(lastSlotToPrune, PRUNE_SLOTS, checkpointEarliestSlot); verify(pruningActiveLabelledGauge).set(eq(0.), any()); } diff --git a/storage/src/test/java/tech/pegasys/teku/storage/server/pruner/StatePrunerTest.java b/storage/src/test/java/tech/pegasys/teku/storage/server/pruner/StatePrunerTest.java new file mode 100644 index 00000000000..a132ab1435d --- /dev/null +++ b/storage/src/test/java/tech/pegasys/teku/storage/server/pruner/StatePrunerTest.java @@ -0,0 +1,142 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.storage.server.pruner; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.time.Duration; +import java.util.Optional; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.infrastructure.async.StubAsyncRunner; +import tech.pegasys.teku.infrastructure.metrics.SettableLabelledGauge; +import tech.pegasys.teku.infrastructure.time.StubTimeProvider; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.util.DataStructureUtil; +import tech.pegasys.teku.storage.server.Database; + +public class StatePrunerTest { + + public static final Duration PRUNE_INTERVAL = Duration.ofSeconds(26); + private static final long SLOTS_RETAINED = 10; + private static final long PRUNE_LIMIT = 10; + public static final int SLOTS_PER_EPOCH = 10; + private final Spec spec = + TestSpecFactory.createDefault( + builder -> builder.slotsPerEpoch(SLOTS_PER_EPOCH).minEpochsForBlockRequests(5)); + private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); + private final StubTimeProvider timeProvider = StubTimeProvider.withTimeInSeconds(1000); + private final StubAsyncRunner asyncRunner = new StubAsyncRunner(timeProvider); + private final Database database = mock(Database.class); + private final SettableLabelledGauge pruningActiveLabelledGauge = + mock(SettableLabelledGauge.class); + + private final StatePruner pruner = + new StatePruner( + spec, + database, + asyncRunner, + PRUNE_INTERVAL, + SLOTS_RETAINED, + PRUNE_LIMIT, + "test", + mock(SettableLabelledGauge.class), + pruningActiveLabelledGauge); + + @BeforeEach + void setUp() { + assertThat(pruner.start()).isCompleted(); + when(database.pruneFinalizedStates(any(), any(), anyInt())) + .thenReturn(Optional.of(UInt64.ZERO)); + } + + @Test + void shouldPruneWhenFirstStarted() { + when(database.getFinalizedCheckpoint()) + .thenReturn(Optional.of(dataStructureUtil.randomCheckpoint(UInt64.valueOf(50)))); + asyncRunner.executeDueActions(); + verify(database).pruneFinalizedStates(any(), any(), eq(PRUNE_LIMIT)); + verify(pruningActiveLabelledGauge).set(eq(0.), any()); + } + + @Test + void shouldPruneAfterInterval() { + when(database.getFinalizedCheckpoint()).thenReturn(Optional.empty()); + asyncRunner.executeDueActions(); + verify(database, never()).pruneFinalizedStates(any(), any(), eq(PRUNE_LIMIT)); + + when(database.getFinalizedCheckpoint()) + .thenReturn(Optional.of(dataStructureUtil.randomCheckpoint(UInt64.valueOf(52)))); + triggerNextPruning(); + verify(database).pruneFinalizedStates(any(), any(), eq(PRUNE_LIMIT)); + verify(pruningActiveLabelledGauge, times(2)).set(eq(0.), any()); + } + + @Test + void shouldNotPruneWhenFinalizedCheckpointNotSet() { + when(database.getFinalizedCheckpoint()).thenReturn(Optional.empty()); + triggerNextPruning(); + verify(database, never()).pruneFinalizedStates(any(), any(), eq(PRUNE_LIMIT)); + verify(pruningActiveLabelledGauge).set(eq(0.), any()); + } + + @Test + void shouldNotPruneWhenFinalizedCheckpointBelowEpochsToKeep() { + when(database.getFinalizedCheckpoint()) + .thenReturn(Optional.of(dataStructureUtil.randomCheckpoint(1))); + triggerNextPruning(); + verify(database, never()).pruneFinalizedStates(any(), any(), eq(PRUNE_LIMIT)); + verify(pruningActiveLabelledGauge).set(eq(0.), any()); + } + + @Test + void shouldPruneStatesMoreThanEpochsToKeepBeforeFinalizedCheckpoint() { + final UInt64 finalizedEpoch = UInt64.valueOf(50); + when(database.getFinalizedCheckpoint()) + .thenReturn(Optional.of(dataStructureUtil.randomCheckpoint(finalizedEpoch))); + triggerNextPruning(); + // SlotToKeep = FinalizedEpoch (50) * SlotsPerEpoch(10) - SlotsToKeep(10) + // = 500 - 100 = 490, last slot to prune = 490 - 1 = 489. + final UInt64 lastSlotToPrune = UInt64.valueOf(489); + verify(database).pruneFinalizedStates(any(), eq(lastSlotToPrune), eq(PRUNE_LIMIT)); + verify(pruningActiveLabelledGauge).set(eq(0.), any()); + } + + @Test + void shouldPruneStatesWhenFirstEpochIsPrunable() { + + when(database.getFinalizedCheckpoint()) + .thenReturn(Optional.of(dataStructureUtil.randomCheckpoint(SLOTS_RETAINED + 1))); + triggerNextPruning(); + // Should prune all states from slots that are past the last 10 finalized slots + final UInt64 lastSlotToPrune = UInt64.valueOf(SLOTS_PER_EPOCH * SLOTS_RETAINED - 1); + verify(database).pruneFinalizedStates(any(), eq(lastSlotToPrune), eq(PRUNE_LIMIT)); + verify(pruningActiveLabelledGauge).set(eq(0.), any()); + } + + private void triggerNextPruning() { + timeProvider.advanceTimeBy(PRUNE_INTERVAL); + asyncRunner.executeDueActions(); + } +} diff --git a/storage/src/test/java/tech/pegasys/teku/storage/store/AbstractStoreTest.java b/storage/src/test/java/tech/pegasys/teku/storage/store/AbstractStoreTest.java index a84eaa28587..370759f967d 100644 --- a/storage/src/test/java/tech/pegasys/teku/storage/store/AbstractStoreTest.java +++ b/storage/src/test/java/tech/pegasys/teku/storage/store/AbstractStoreTest.java @@ -130,7 +130,7 @@ protected void processChainHeadWithMockForkChoiceStrategy( addBlocks(store, blocks); - chainProcessor.accept(store, blocks.get(blocks.size() - 1)); + chainProcessor.accept(store, blocks.getLast()); } protected void addBlock(final UpdatableStore store, final SignedBlockAndState block) { diff --git a/storage/src/test/java/tech/pegasys/teku/storage/store/FileKeyValueStoreTest.java b/storage/src/test/java/tech/pegasys/teku/storage/store/FileKeyValueStoreTest.java index 89ec4d05417..c51cb3a318f 100644 --- a/storage/src/test/java/tech/pegasys/teku/storage/store/FileKeyValueStoreTest.java +++ b/storage/src/test/java/tech/pegasys/teku/storage/store/FileKeyValueStoreTest.java @@ -85,7 +85,7 @@ void testConcurrent() { checkAllBytesEqual(finalVal.get()); } - private static void checkAllBytesEqual(Bytes bb) { + private static void checkAllBytesEqual(final Bytes bb) { byte b = bb.get(0); for (int i = 1; i < bb.size(); i++) { if (bb.get(i) != b) { diff --git a/storage/src/test/java/tech/pegasys/teku/storage/store/StoreTest.java b/storage/src/test/java/tech/pegasys/teku/storage/store/StoreTest.java index c3371f0c7d4..78a7a957dd0 100644 --- a/storage/src/test/java/tech/pegasys/teku/storage/store/StoreTest.java +++ b/storage/src/test/java/tech/pegasys/teku/storage/store/StoreTest.java @@ -51,6 +51,7 @@ import tech.pegasys.teku.spec.generator.ChainBuilder; import tech.pegasys.teku.storage.api.StubStorageUpdateChannel; import tech.pegasys.teku.storage.api.StubStorageUpdateChannelWithDelays; +import tech.pegasys.teku.storage.archive.nooparchive.DataArchiveNoopWriter; import tech.pegasys.teku.storage.storageSystem.InMemoryStorageSystemBuilder; import tech.pegasys.teku.storage.storageSystem.StorageSystem; import tech.pegasys.teku.storage.store.UpdatableStore.StoreTransaction; @@ -392,7 +393,9 @@ public void retrieveEarliestBlobSidecarSlot_shouldReturnUpdatedValue() { maybeEarliestBlobSidecarSlot.isPresent() && maybeEarliestBlobSidecarSlot.get().equals(UInt64.ZERO)); - storageSystem.database().pruneOldestBlobSidecars(UInt64.valueOf(5), 5); + storageSystem + .database() + .pruneOldestBlobSidecars(UInt64.valueOf(5), 3, new DataArchiveNoopWriter<>()); assertThat(store.retrieveEarliestBlobSidecarSlot()) .isCompletedWithValueMatching( @@ -402,9 +405,9 @@ public void retrieveEarliestBlobSidecarSlot_shouldReturnUpdatedValue() { } private void setProtoNodeDataForBlock( - SignedBlockAndState blockAndState, - BlockCheckpoints headCheckpoint, - BlockCheckpoints parentCheckpoint) { + final SignedBlockAndState blockAndState, + final BlockCheckpoints headCheckpoint, + final BlockCheckpoints parentCheckpoint) { final Bytes32 root = blockAndState.getRoot(); final Bytes32 parentRoot = blockAndState.getParentRoot(); final ProtoNodeData protoNodeData = @@ -434,7 +437,7 @@ private void setProtoNodeDataForBlock( } private void setProtoNodeDataForBlock( - SignedBlockAndState blockAndState, final UInt64 headValue, final UInt64 parentValue) { + final SignedBlockAndState blockAndState, final UInt64 headValue, final UInt64 parentValue) { final Bytes32 root = blockAndState.getRoot(); final Bytes32 parentRoot = blockAndState.getParentRoot(); final ProtoNodeData protoNodeData = diff --git a/storage/src/test/java/tech/pegasys/teku/storage/store/StoreTransactionTest.java b/storage/src/test/java/tech/pegasys/teku/storage/store/StoreTransactionTest.java index ae2a6969c05..e129fe75f0c 100644 --- a/storage/src/test/java/tech/pegasys/teku/storage/store/StoreTransactionTest.java +++ b/storage/src/test/java/tech/pegasys/teku/storage/store/StoreTransactionTest.java @@ -258,10 +258,10 @@ public void getCheckpointState_fromBlockInTx() { final SignedBlockAndState blockAndState = chainBuilder.generateBlockAtSlot(epochStartSlot); final Checkpoint checkpoint = new Checkpoint(epoch, blockAndState.getRoot()); - UpdatableStore.StoreTransaction tx = store.startTransaction(storageUpdateChannel); + final UpdatableStore.StoreTransaction tx = store.startTransaction(storageUpdateChannel); tx.putBlockAndState(blockAndState, spec.calculateBlockCheckpoints(blockAndState.getState())); - SafeFuture> result = tx.retrieveCheckpointState(checkpoint); + final SafeFuture> result = tx.retrieveCheckpointState(checkpoint); assertThat(result).isCompletedWithValue(Optional.of(blockAndState.getState())); } @@ -415,7 +415,7 @@ public void getOrderedBlockRoots_withNewBlocks() { mainChainBlock4.getRoot()); } - private void setTime(UpdatableStore store, final UInt64 newTime) { + private void setTime(final UpdatableStore store, final UInt64 newTime) { final StoreTransaction tx = store.startTransaction(storageUpdateChannel); tx.setTimeMillis(newTime); assertThat(tx.commit()).isCompleted(); diff --git a/storage/src/testFixtures/java/tech/pegasys/teku/storage/api/StubSidecarUpdateChannel.java b/storage/src/testFixtures/java/tech/pegasys/teku/storage/api/StubSidecarUpdateChannel.java index 8c1d5cca8ba..154c2ce9292 100644 --- a/storage/src/testFixtures/java/tech/pegasys/teku/storage/api/StubSidecarUpdateChannel.java +++ b/storage/src/testFixtures/java/tech/pegasys/teku/storage/api/StubSidecarUpdateChannel.java @@ -19,22 +19,22 @@ public class StubSidecarUpdateChannel implements SidecarUpdateChannel { @Override - public SafeFuture onFirstCustodyIncompleteSlot(UInt64 slot) { + public SafeFuture onFirstCustodyIncompleteSlot(final UInt64 slot) { return SafeFuture.COMPLETE; } @Override - public SafeFuture onFirstSamplerIncompleteSlot(UInt64 slot) { + public SafeFuture onFirstSamplerIncompleteSlot(final UInt64 slot) { return SafeFuture.COMPLETE; } @Override - public SafeFuture onNewSidecar(DataColumnSidecar sidecar) { + public SafeFuture onNewSidecar(final DataColumnSidecar sidecar) { return SafeFuture.COMPLETE; } @Override - public SafeFuture onSidecarsAvailabilitySlot(UInt64 earliestSlotRequired) { + public SafeFuture onSidecarsAvailabilitySlot(final UInt64 earliestSlotRequired) { return SafeFuture.COMPLETE; } } diff --git a/storage/src/testFixtures/java/tech/pegasys/teku/storage/api/StubStorageQueryChannel.java b/storage/src/testFixtures/java/tech/pegasys/teku/storage/api/StubStorageQueryChannel.java index a9f16989364..adc87855e0b 100644 --- a/storage/src/testFixtures/java/tech/pegasys/teku/storage/api/StubStorageQueryChannel.java +++ b/storage/src/testFixtures/java/tech/pegasys/teku/storage/api/StubStorageQueryChannel.java @@ -57,17 +57,17 @@ public SafeFuture> getEarliestAvailableBlock() { } @Override - public SafeFuture> getFinalizedBlockAtSlot(UInt64 slot) { + public SafeFuture> getFinalizedBlockAtSlot(final UInt64 slot) { return SafeFuture.completedFuture(Optional.empty()); } @Override - public SafeFuture> getLatestFinalizedBlockAtSlot(UInt64 slot) { + public SafeFuture> getLatestFinalizedBlockAtSlot(final UInt64 slot) { return SafeFuture.completedFuture(Optional.empty()); } @Override - public SafeFuture> getBlockByBlockRoot(Bytes32 blockRoot) { + public SafeFuture> getBlockByBlockRoot(final Bytes32 blockRoot) { return SafeFuture.completedFuture(Optional.empty()); } @@ -96,12 +96,12 @@ public SafeFuture> getSlotAndBlockRootByStateRoot( } @Override - public SafeFuture> getLatestFinalizedStateAtSlot(UInt64 slot) { + public SafeFuture> getLatestFinalizedStateAtSlot(final UInt64 slot) { return SafeFuture.completedFuture(Optional.empty()); } @Override - public SafeFuture> getLatestAvailableFinalizedState(UInt64 slot) { + public SafeFuture> getLatestAvailableFinalizedState(final UInt64 slot) { return SafeFuture.completedFuture(Optional.empty()); } @@ -111,7 +111,7 @@ public SafeFuture> getFinalizedSlotByBlockRoot(final Bytes32 bl } @Override - public SafeFuture> getFinalizedStateByBlockRoot(Bytes32 blockRoot) { + public SafeFuture> getFinalizedStateByBlockRoot(final Bytes32 blockRoot) { return SafeFuture.completedFuture(Optional.empty()); } @@ -163,7 +163,7 @@ public SafeFuture> getAllBlobSidecarKeys(fina @Override public SafeFuture> getBlobSidecarKeys( - final UInt64 startSlot, final UInt64 endSlot, final UInt64 limit) { + final UInt64 startSlot, final UInt64 endSlot, final long limit) { return SafeFuture.completedFuture(List.of()); } diff --git a/storage/src/testFixtures/java/tech/pegasys/teku/storage/client/ChainUpdater.java b/storage/src/testFixtures/java/tech/pegasys/teku/storage/client/ChainUpdater.java index c870c3ae96c..882107473ff 100644 --- a/storage/src/testFixtures/java/tech/pegasys/teku/storage/client/ChainUpdater.java +++ b/storage/src/testFixtures/java/tech/pegasys/teku/storage/client/ChainUpdater.java @@ -149,7 +149,7 @@ public SignedBlockAndState finalizeEpoch(final UInt64 epoch) { public SignedBlockAndState finalizeCurrentChain() { final List newBlocks = chainBuilder.finalizeCurrentChain(Optional.empty()); newBlocks.forEach(this::saveBlock); - final SignedBlockAndState newHead = newBlocks.get(newBlocks.size() - 1); + final SignedBlockAndState newHead = newBlocks.getLast(); updateBestBlock(newHead); return newHead; } @@ -157,7 +157,7 @@ public SignedBlockAndState finalizeCurrentChain() { public SignedBlockAndState finalizeCurrentChainOptimistically() { final List newBlocks = chainBuilder.finalizeCurrentChain(Optional.empty()); newBlocks.forEach(this::saveOptimisticBlock); - final SignedBlockAndState newHead = newBlocks.get(newBlocks.size() - 1); + final SignedBlockAndState newHead = newBlocks.getLast(); updateBestBlock(newHead); return newHead; } diff --git a/storage/src/testFixtures/java/tech/pegasys/teku/storage/protoarray/ProtoArrayTestUtil.java b/storage/src/testFixtures/java/tech/pegasys/teku/storage/protoarray/ProtoArrayTestUtil.java index 7b2ea62c3a6..57cedb37296 100644 --- a/storage/src/testFixtures/java/tech/pegasys/teku/storage/protoarray/ProtoArrayTestUtil.java +++ b/storage/src/testFixtures/java/tech/pegasys/teku/storage/protoarray/ProtoArrayTestUtil.java @@ -27,16 +27,16 @@ public class ProtoArrayTestUtil { // Gives a deterministic hash for a given integer - public static Bytes32 getHash(int i) { + public static Bytes32 getHash(final int i) { return MathHelpers.uintToBytes32(Integer.toUnsignedLong(i + 1)); } public static ForkChoiceStrategy createProtoArrayForkChoiceStrategy( - Spec spec, - Bytes32 finalizedBlockRoot, - UInt64 finalizedBlockSlot, - UInt64 finalizedCheckpointEpoch, - UInt64 justifiedCheckpointEpoch) { + final Spec spec, + final Bytes32 finalizedBlockRoot, + final UInt64 finalizedBlockSlot, + final UInt64 finalizedCheckpointEpoch, + final UInt64 justifiedCheckpointEpoch) { final ProtoArray protoArray = ProtoArray.builder() diff --git a/storage/src/testFixtures/java/tech/pegasys/teku/storage/server/kvstore/InMemoryKvStoreDatabaseFactory.java b/storage/src/testFixtures/java/tech/pegasys/teku/storage/server/kvstore/InMemoryKvStoreDatabaseFactory.java index 8c8f18e4264..436caada48a 100644 --- a/storage/src/testFixtures/java/tech/pegasys/teku/storage/server/kvstore/InMemoryKvStoreDatabaseFactory.java +++ b/storage/src/testFixtures/java/tech/pegasys/teku/storage/server/kvstore/InMemoryKvStoreDatabaseFactory.java @@ -24,8 +24,8 @@ public class InMemoryKvStoreDatabaseFactory { public static Database createV4( - MockKvStoreInstance hotDb, - MockKvStoreInstance coldDb, + final MockKvStoreInstance hotDb, + final MockKvStoreInstance coldDb, final StateStorageMode storageMode, final long stateStorageFrequency, final boolean storeNonCanonicalBlocks, @@ -46,7 +46,7 @@ public static Database createV4( } public static Database createV6( - MockKvStoreInstance db, + final MockKvStoreInstance db, final StateStorageMode storageMode, final long stateStorageFrequency, final boolean storeNonCanonicalBlocks, @@ -57,7 +57,7 @@ public static Database createV6( } public static Database createTree( - MockKvStoreInstance db, + final MockKvStoreInstance db, final StateStorageMode storageMode, final boolean storeNonCanonicalBlocks, final Spec spec) { diff --git a/storage/src/testFixtures/java/tech/pegasys/teku/storage/server/kvstore/MockKvStoreInstance.java b/storage/src/testFixtures/java/tech/pegasys/teku/storage/server/kvstore/MockKvStoreInstance.java index 96529efa23c..5c54c615a65 100644 --- a/storage/src/testFixtures/java/tech/pegasys/teku/storage/server/kvstore/MockKvStoreInstance.java +++ b/storage/src/testFixtures/java/tech/pegasys/teku/storage/server/kvstore/MockKvStoreInstance.java @@ -40,11 +40,11 @@ public class MockKvStoreInstance implements KvStoreAccessor { private final Map, NavigableMap> columnData; private final Map, Bytes> variableData; - private AtomicBoolean closed = new AtomicBoolean(false); + private final AtomicBoolean closed = new AtomicBoolean(false); public MockKvStoreInstance( - Collection> columns, - Collection> variables, + final Collection> columns, + final Collection> variables, final Map, NavigableMap> columnData, final Map, Bytes> variableData) { this.columns = new HashSet<>(columns); @@ -62,7 +62,8 @@ public MockKvStoreInstance reopen() { } public static MockKvStoreInstance createEmpty( - final Collection> columns, Collection> variables) { + final Collection> columns, + final Collection> variables) { checkArgument(columns.size() > 0, "No columns attached to schema"); final Map, NavigableMap> columnData = @@ -148,7 +149,7 @@ public Stream> stream(final KvStoreColumn column) } @Override - public Stream streamKeys(KvStoreColumn column) { + public Stream streamKeys(final KvStoreColumn column) { return streamKeysRaw(column) .map(entry -> column.getKeySerializer().deserialize(entry.toArrayUnsafe())); } @@ -163,7 +164,7 @@ public Stream> streamRaw(final KvStoreColumn col } @Override - public Stream streamKeysRaw(KvStoreColumn column) { + public Stream streamKeysRaw(final KvStoreColumn column) { assertOpen(); assertValidColumn(column); return columnData.get(column).keySet().stream(); @@ -190,7 +191,7 @@ public , V> Stream> stream( @Override public , V> Stream streamKeys( - KvStoreColumn column, K from, K to) { + final KvStoreColumn column, final K from, final K to) { assertOpen(); return columnData .get(column) @@ -228,11 +229,11 @@ private ColumnEntry columnEntry(final Map.Entry entr return ColumnEntry.create(entry.getKey(), entry.getValue()); } - private Bytes keyToBytes(final KvStoreColumn column, K key) { + private Bytes keyToBytes(final KvStoreColumn column, final K key) { return Bytes.wrap(column.getKeySerializer().serialize(key)); } - private Bytes valueToBytes(final KvStoreColumn column, V value) { + private Bytes valueToBytes(final KvStoreColumn column, final V value) { return Bytes.wrap(column.getValueSerializer().serialize(value)); } @@ -241,11 +242,11 @@ public void close() { closed.set(true); } - private void assertValidVariable(KvStoreVariable variable) { + private void assertValidVariable(final KvStoreVariable variable) { checkArgument(variables.contains(variable), "Unknown RocksDbVariable supplied"); } - private void assertValidColumn(KvStoreColumn column) { + private void assertValidColumn(final KvStoreColumn column) { checkArgument(columns.contains(column), "Unknown RocksDbColumn %s supplied", column.getId()); } @@ -320,7 +321,7 @@ public void delete(final KvStoreColumn column, final K key) { } @Override - public void delete(KvStoreVariable variable) { + public void delete(final KvStoreVariable variable) { assertOpen(); dbInstance.assertValidVariable(variable); variableUpdates.put(variable, Optional.empty()); @@ -341,7 +342,7 @@ public void commit() { columnUpdates.forEach( (col, updates) -> { final NavigableMap targetColumn = dbInstance.columnData.get(col); - updates.forEach(targetColumn::put); + targetColumn.putAll(updates); }); deletedColumnKeys.forEach( (col, deletedKeys) -> { diff --git a/storage/src/testFixtures/java/tech/pegasys/teku/storage/storageSystem/StorageSystemArgumentsProvider.java b/storage/src/testFixtures/java/tech/pegasys/teku/storage/storageSystem/StorageSystemArgumentsProvider.java index f2566562696..b7a9e282f2b 100644 --- a/storage/src/testFixtures/java/tech/pegasys/teku/storage/storageSystem/StorageSystemArgumentsProvider.java +++ b/storage/src/testFixtures/java/tech/pegasys/teku/storage/storageSystem/StorageSystemArgumentsProvider.java @@ -47,7 +47,7 @@ protected boolean includeInMemory() { } @Override - public Stream provideArguments(ExtensionContext context) { + public Stream provideArguments(final ExtensionContext context) { final Map storageSystems = new HashMap<>(); for (StateStorageMode mode : getStorageModes()) { for (long storageFrequency : stateStorageFrequencyOptions) { diff --git a/teku/build.gradle b/teku/build.gradle index 475d195a664..8efcf968ceb 100644 --- a/teku/build.gradle +++ b/teku/build.gradle @@ -1,7 +1,6 @@ dependencies { implementation project(':beacon:pow') implementation project(':beacon:validator') - implementation project(':data:serializer') implementation project(':data:publisher') implementation project(':data:beaconrestapi') implementation project(':ethereum:signingrecord') @@ -19,6 +18,7 @@ dependencies { implementation project(':ethereum:weaksubjectivity') implementation project(':infrastructure:crypto') implementation project(':infrastructure:events') + implementation project(':infrastructure:http') implementation project(':infrastructure:async') implementation project(':infrastructure:io') implementation project(':infrastructure:logging') @@ -52,8 +52,8 @@ dependencies { implementation 'io.vertx:vertx-core' implementation 'org.apache.logging.log4j:log4j-slf4j-impl' implementation 'org.apache.logging.log4j:log4j-slf4j2-impl' - implementation 'org.apache.tuweni:tuweni-ssz' - implementation 'org.apache.tuweni:tuweni-units' + implementation 'io.tmio:tuweni-ssz' + implementation 'io.tmio:tuweni-units' implementation 'org.hyperledger.besu.internal:metrics-core' implementation 'com.fasterxml.jackson.core:jackson-databind' implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-yaml' diff --git a/teku/src/integration-test/java/tech/pegasys/teku/cli/subcommand/ValidatorClientCommandTest.java b/teku/src/integration-test/java/tech/pegasys/teku/cli/subcommand/ValidatorClientCommandTest.java index ad7272acf61..c6ecdf5611a 100644 --- a/teku/src/integration-test/java/tech/pegasys/teku/cli/subcommand/ValidatorClientCommandTest.java +++ b/teku/src/integration-test/java/tech/pegasys/teku/cli/subcommand/ValidatorClientCommandTest.java @@ -75,7 +75,7 @@ public class ValidatorClientCommandTest { outputWriter, errorWriter, Collections.emptyMap(), startAction, loggingConfigurator); @BeforeEach - public void setup(ClientAndServer server) { + public void setup(final ClientAndServer server) { this.mockBeaconServer = server; this.failoverMockBeaconServer = ClientAndServer.startClientAndServer(PortFactory.findFreePort()); @@ -84,22 +84,31 @@ public void setup(ClientAndServer server) { getMockBeaconServerEndpoint(failoverMockBeaconServer); argsNetworkOptDefault = - new String[] {"vc", "--beacon-node-api-endpoint", mockBeaconServerEndpoint}; + new String[] { + "vc", "--validator-keys=keys:pass", "--beacon-node-api-endpoint", mockBeaconServerEndpoint + }; argsNetworkOptAuto = new String[] { - "vc", "--network", "auto", "--beacon-node-api-endpoint", mockBeaconServerEndpoint + "vc", + "--network", + "auto", + "--validator-keys=keys:pass", + "--beacon-node-api-endpoint", + mockBeaconServerEndpoint }; argsNetworkOptAutoWithFailover = new String[] { "vc", "--network", "auto", + "--validator-keys=keys:pass", "--beacon-node-api-endpoints", mockBeaconServerEndpoint + "," + failoverMockBeaconServerEndpoint }; argsNetworkOptAutoInConfig = new String[] { "vc", + "--validator-keys=keys:pass", "--config-file", networkAutoConfigFile, "--beacon-node-api-endpoint", diff --git a/teku/src/integration-test/java/tech/pegasys/teku/cli/subcommand/VoluntaryExitCommandTest.java b/teku/src/integration-test/java/tech/pegasys/teku/cli/subcommand/VoluntaryExitCommandTest.java index 0f4362d8339..f0d626e8459 100644 --- a/teku/src/integration-test/java/tech/pegasys/teku/cli/subcommand/VoluntaryExitCommandTest.java +++ b/teku/src/integration-test/java/tech/pegasys/teku/cli/subcommand/VoluntaryExitCommandTest.java @@ -37,6 +37,7 @@ import java.util.Collections; import java.util.List; import java.util.function.Supplier; +import java.util.stream.Collectors; import org.apache.commons.lang3.StringUtils; import org.apache.tuweni.bytes.Bytes; import org.apache.tuweni.bytes.Bytes32; @@ -49,20 +50,25 @@ import org.junit.jupiter.api.io.TempDir; import org.mockserver.integration.ClientAndServer; import org.mockserver.junit.jupiter.MockServerExtension; -import org.mockserver.model.Parameter; import tech.pegasys.teku.api.ConfigProvider; import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.bls.BLSSignatureVerifier; import tech.pegasys.teku.bls.BLSTestUtil; import tech.pegasys.teku.cli.BeaconNodeCommand; import tech.pegasys.teku.infrastructure.json.JsonUtil; import tech.pegasys.teku.infrastructure.logging.LoggingConfigurator; +import tech.pegasys.teku.infrastructure.time.SystemTimeProvider; +import tech.pegasys.teku.infrastructure.time.TimeProvider; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.config.SpecConfig; import tech.pegasys.teku.spec.constants.Domain; import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; import tech.pegasys.teku.spec.logic.common.helpers.MiscHelpers; +import tech.pegasys.teku.spec.util.DataStructureUtil; @ExtendWith(MockServerExtension.class) public class VoluntaryExitCommandTest { @@ -73,7 +79,7 @@ public class VoluntaryExitCommandTest { private final PrintWriter outputWriter = new PrintWriter(stringWriter, true); private final PrintWriter errorWriter = new PrintWriter(stringWriter, true); - private ClientAndServer mockBeaconServer; + private ClientAndServer server; private final BeaconNodeCommand beaconNodeCommand = new BeaconNodeCommand( @@ -108,11 +114,9 @@ public class VoluntaryExitCommandTest { private List commandArgs; @BeforeEach - public void setup(ClientAndServer server) throws IOException { - this.mockBeaconServer = server; - configureSuccessfulHeadResponse(mockBeaconServer); - configureSuccessfulGenesisResponse(mockBeaconServer); - configureSuccessfulValidatorResponses(mockBeaconServer); + public void setup(final ClientAndServer server) throws IOException { + this.server = server; + configureSuccessfulValidatorResponses(); originalSystemIn = System.in; originalSystemOut = System.out; originalSytstemErr = System.err; @@ -123,7 +127,7 @@ public void setup(ClientAndServer server) throws IOException { List.of( "voluntary-exit", "--beacon-node-api-endpoint", - getMockBeaconServerEndpoint(mockBeaconServer), + getMockBeaconServerEndpoint(), "--data-validator-path", Resources.getResource("tech/pegasys/teku/cli/subcommand/voluntary-exit/validator") .getPath(), @@ -139,7 +143,7 @@ public void setup(ClientAndServer server) throws IOException { @AfterEach public void tearDown() { - mockBeaconServer.reset(); + server.reset(); System.setOut(originalSystemOut); System.setIn(originalSystemIn); System.setErr(originalSytstemErr); @@ -147,8 +151,9 @@ public void tearDown() { @Test public void shouldExitAllLoadedValidators() throws JsonProcessingException { - configureSuccessfulSpecResponse(mockBeaconServer); - configureSuccessfulVoluntaryExitResponse(mockBeaconServer); + configureSuccessfulSpecResponse(); + configureSuccessfulGenesisResponse(); + configureSuccessfulVoluntaryExitResponse(); final List args = getCommandArguments(true, false, List.of()); int parseResult = beaconNodeCommand.parse(args.toArray(new String[0])); @@ -161,8 +166,9 @@ public void shouldExitAllLoadedValidators() throws JsonProcessingException { @Test public void shouldExitLoadedValidatorsUsingConfirmationMessage() throws JsonProcessingException { setUserInput("yes"); - configureSuccessfulSpecResponse(mockBeaconServer); - configureSuccessfulVoluntaryExitResponse(mockBeaconServer); + configureSuccessfulSpecResponse(); + configureSuccessfulGenesisResponse(); + configureSuccessfulVoluntaryExitResponse(); final List args = getCommandArguments(true, true, List.of()); int parseResult = beaconNodeCommand.parse(args.toArray(new String[0])); @@ -174,8 +180,9 @@ public void shouldExitLoadedValidatorsUsingConfirmationMessage() throws JsonProc @Test public void shouldExitValidatorWithPubKeyFromKeyManagerOnly() throws JsonProcessingException { - configureSuccessfulSpecResponse(mockBeaconServer); - configureSuccessfulVoluntaryExitResponse(mockBeaconServer); + configureSuccessfulSpecResponse(); + configureSuccessfulGenesisResponse(); + configureSuccessfulVoluntaryExitResponse(); final List args = getCommandArguments( @@ -192,7 +199,8 @@ public void shouldExitValidatorWithPubKeyFromKeyManagerOnly() throws JsonProcess @Test public void shouldAcceptNetworkOnCommandLine() { - configureSuccessfulVoluntaryExitResponse(mockBeaconServer); + configureSuccessfulVoluntaryExitResponse(); + configureSuccessfulGenesisResponse(); // No beacon-api offered by spec, so would need to be loaded from local network option final List args = @@ -209,7 +217,8 @@ public void shouldAcceptNetworkOnCommandLine() { @Test public void shouldReturnRejectedReasonWhenExitIsRejectedByBeaconNode() throws IOException { - configureRejectedVoluntaryExitResponse(mockBeaconServer); + configureRejectedVoluntaryExitResponse(); + configureSuccessfulGenesisResponse(); final List args = getCommandArguments( @@ -238,8 +247,9 @@ public void shouldFailToRunExitWithoutASpec() { @Test public void shouldExitValidatorWithPubKeyFromPathOnly() throws JsonProcessingException { - configureSuccessfulSpecResponse(mockBeaconServer); - configureSuccessfulVoluntaryExitResponse(mockBeaconServer); + configureSuccessfulSpecResponse(); + configureSuccessfulGenesisResponse(); + configureSuccessfulVoluntaryExitResponse(); final List args = getCommandArguments( @@ -256,8 +266,9 @@ public void shouldExitValidatorWithPubKeyFromPathOnly() throws JsonProcessingExc @Test public void shouldSkipKeyManagerKeys() throws JsonProcessingException { - configureSuccessfulSpecResponse(mockBeaconServer); - configureSuccessfulVoluntaryExitResponse(mockBeaconServer); + configureSuccessfulSpecResponse(); + configureSuccessfulGenesisResponse(); + configureSuccessfulVoluntaryExitResponse(); final List args = getCommandArguments( @@ -274,7 +285,8 @@ public void shouldSkipKeyManagerKeys() throws JsonProcessingException { @Test void shouldNotWarn_NotWithdrawableIfCapellaEnabled() throws JsonProcessingException { - configureSuccessfulSpecResponse(mockBeaconServer, TestSpecFactory.createMinimalCapella()); + configureSuccessfulSpecResponse(TestSpecFactory.createMinimalCapella()); + configureSuccessfulGenesisResponse(); final List args = getCommandArguments(false, true, List.of()); setUserInput("no"); @@ -289,7 +301,8 @@ void shouldNotWarn_NotWithdrawableIfCapellaEnabled() throws JsonProcessingExcept @Test void shouldGenerateExitWithoutSendingToNode(@TempDir final Path tempDir) throws IOException { - configureSuccessfulSpecResponse(mockBeaconServer, TestSpecFactory.createMinimalCapella()); + configureSuccessfulSpecResponse(TestSpecFactory.createMinimalCapella()); + configureSuccessfulGenesisResponse(); final Path outputFolder = tempDir.resolve("out"); final List args = new ArrayList<>(); args.addAll(commandArgs); @@ -316,7 +329,9 @@ void shouldGenerateExitWithoutSendingToNode(@TempDir final Path tempDir) throws @Test void shouldFailIfSaveFolderCannotBeCreated(@TempDir final Path tempDir) throws IOException { - configureSuccessfulSpecResponse(mockBeaconServer, TestSpecFactory.createMinimalCapella()); + configureSuccessfulSpecResponse(TestSpecFactory.createMinimalCapella()); + configureSuccessfulGenesisResponse(); + final Path invalidOutputDestination = tempDir.resolve("testFile"); Files.writeString(invalidOutputDestination, "test"); final List args = new ArrayList<>(); @@ -336,7 +351,9 @@ void shouldFailIfSaveFolderCannotBeCreated(@TempDir final Path tempDir) throws I @Test @DisabledOnOs(OS.WINDOWS) // can't set permissions on windows void shouldFailIfSaveFolderHasInsufficientAccess(@TempDir final Path tempDir) throws IOException { - configureSuccessfulSpecResponse(mockBeaconServer, TestSpecFactory.createMinimalCapella()); + configureSuccessfulSpecResponse(TestSpecFactory.createMinimalCapella()); + configureSuccessfulGenesisResponse(); + final Path invalidOutputDestination = tempDir.resolve("testFile"); tempDir.toFile().mkdir(); tempDir.toFile().setWritable(false); @@ -353,9 +370,79 @@ void shouldFailIfSaveFolderHasInsufficientAccess(@TempDir final Path tempDir) th assertThat(stdErr.toString(UTF_8)).contains("Failed to store exit for a756543"); } + @Test + void shouldFailIfGenesisDataNotAvailableAndNoEpochSpecified() throws JsonProcessingException { + configureSuccessfulSpecResponse(TestSpecFactory.createMinimalCapella()); + final List args = + getCommandArguments(false, true, List.of("--validator-public-keys", validatorPubKey1)); + final int parseResult = beaconNodeCommand.parse(args.toArray(new String[0])); + assertThat(parseResult).isEqualTo(1); + assertThat(stdErr.toString(UTF_8)).contains("Could not calculate epoch from genesis data"); + } + + @Test + void shouldFailToGenerateExitWithoutBeaconNodeAvailable() { + final List args = + List.of("voluntary-exit", "--validator-public-keys", validatorPubKey1); + final int parseResult = beaconNodeCommand.parse(args.toArray(new String[0])); + assertThat(parseResult).isEqualTo(1); + assertThat(stdErr.toString(UTF_8)).contains("Failed to connect to beacon node."); + } + + @Test + void shouldFailToGenerateIfExternalSignerNotAvailable() throws IOException { + configureSuccessfulSpecResponse(TestSpecFactory.createMinimalCapella()); + setUserInput("yes"); + configureSuccessfulGenesisResponse(); + final String validator2 = validatorResourceFile("aa51616_response.json"); + setupValidatorStatusResponse(validatorPubKey2, validator2); + + final List args = + List.of( + "voluntary-exit", + commandArgs.get(1), + commandArgs.get(2), + "--validators-external-signer-url=" + getMockSignerEndpoint(), + "--validators-external-signer-public-keys=" + validatorPubKey2); + final int parseResult = beaconNodeCommand.parse(args.toArray(new String[0])); + assertThat(parseResult).isEqualTo(1); + // this is not a perfect error, but it does demonstrate it's not saying spec wasn't available, + // which is a good start + assertThat(stdErr.toString(UTF_8)).contains("ExternalSignerException"); + } + + @Test + void canProcessExitForExternalSource(@TempDir final Path tempDir) throws IOException { + final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); + final List keys = List.of(validatorPubKey2); + setUserInput("yes"); + configureSuccessfulSpecResponse(TestSpecFactory.createMinimalCapella()); + configureExternalSignerUpcheck(); + configureSuccessfulGenesisResponse(); + configureExternalSignerPublicKeys(keys); + + final String validator2 = validatorResourceFile("aa51616_response.json"); + configureExternalSignerResponse(validatorPubKey2, dataStructureUtil.randomSignature()); + setupValidatorStatusResponse(validatorPubKey2, validator2); + + final List args = + List.of( + "voluntary-exit", + commandArgs.get(1), + commandArgs.get(2), + "--save-exits-path", + tempDir.toAbsolutePath().toString(), + "--validators-external-signer-url=" + getMockSignerEndpoint(), + "--validators-external-signer-public-keys=" + keys.get(0)); + final int parseResult = beaconNodeCommand.parse(args.toArray(new String[0])); + assertThat(parseResult).isEqualTo(0); + assertThat(stdOut.toString(UTF_8)).contains("Writing signed exit for aa51616"); + } + @Test void shouldExitFailureWithNoValidatorKeysFound() throws JsonProcessingException { - configureSuccessfulSpecResponse(mockBeaconServer); + configureSuccessfulSpecResponse(); + configureSuccessfulGenesisResponse(); final List args = commandArgs.subList(0, 5); int parseResult = beaconNodeCommand.parse(args.toArray(new String[0])); @@ -365,8 +452,9 @@ void shouldExitFailureWithNoValidatorKeysFound() throws JsonProcessingException } @Test - void shouldExitFailureFutureEpoch() throws JsonProcessingException { - configureSuccessfulSpecResponse(mockBeaconServer); + void shouldExitFailureFutureEpoch() throws IOException { + configureSuccessfulSpecResponse(); + configureSuccessfulGenesisResponse(); final List args = getCommandArguments(false, true, List.of("--epoch=1024")); int parseResult = beaconNodeCommand.parse(args.toArray(new String[0])); @@ -376,12 +464,35 @@ void shouldExitFailureFutureEpoch() throws JsonProcessingException { .contains("The specified epoch 1024 is greater than current epoch"); } + @Test + void shouldCreateExitForFutureEpochIfOutputFolderDefined(@TempDir final Path tempDir) + throws IOException { + configureSuccessfulSpecResponse(TestSpecFactory.createMinimalCapella()); + configureSuccessfulGenesisResponse(); + final List args = new ArrayList<>(); + args.addAll(commandArgs); + args.addAll( + List.of( + "--epoch", + "1024", + "--validator-public-keys", + validatorPubKey1, + "--save-exits-path", + tempDir.toAbsolutePath().toString())); + + beaconNodeCommand.parse(args.toArray(new String[0])); + final String outString = stdOut.toString(UTF_8); + assertThat(StringUtils.countMatches(outString, "Writing signed exit for")).isEqualTo(1); + } + @Test void shouldUseCurrentForkDomainForSignatureBeforeDeneb() throws JsonProcessingException { setUserInput("yes"); - configureSuccessfulSpecResponse(mockBeaconServer); + configureSuccessfulSpecResponse(); + configureSuccessfulGenesisResponse(); + final Supplier> exitsCapture = - configureSuccessfulVoluntaryExitResponseWithCapture(mockBeaconServer); + configureSuccessfulVoluntaryExitResponseWithCapture(); final List args = getCommandArguments(false, true, List.of("--validator-public-keys", validatorPubKey1)); @@ -403,9 +514,11 @@ void shouldUseCurrentForkDomainForSignatureBeforeDeneb() throws JsonProcessingEx @Test void shouldUseCapellaForkDomainForSignatureAfterCapella() throws JsonProcessingException { setUserInput("yes"); - configureSuccessfulDenebSpecResponse(mockBeaconServer); + configureSuccessfulDenebSpecResponse(); + configureSuccessfulGenesisResponse(); + final Supplier> exitsCapture = - configureSuccessfulVoluntaryExitResponseWithCapture(mockBeaconServer); + configureSuccessfulVoluntaryExitResponseWithCapture(); final List args = getCommandArguments(false, true, List.of("--validator-public-keys", validatorPubKey1)); @@ -443,135 +556,106 @@ private List getCommandArguments( return args; } - private String getMockBeaconServerEndpoint(final ClientAndServer mockBeaconServer) { - return String.format("http://127.0.0.1:%s/", mockBeaconServer.getLocalPort()); + private String getMockBeaconServerEndpoint() { + return String.format("http://127.0.0.1:%s/beacon", server.getLocalPort()); + } + + private String getMockSignerEndpoint() { + return String.format("http://127.0.0.1:%s/signer", server.getLocalPort()); } - private void configureSuccessfulSpecResponse(final ClientAndServer mockBeaconServer) - throws JsonProcessingException { - configureSuccessfulSpecResponse(mockBeaconServer, spec); + private void configureSuccessfulSpecResponse() throws JsonProcessingException { + configureSuccessfulSpecResponse(spec); } - private void configureSuccessfulDenebSpecResponse(final ClientAndServer mockBeaconServer) - throws JsonProcessingException { - configureSuccessfulSpecResponse(mockBeaconServer, specDeneb); + private void configureSuccessfulDenebSpecResponse() throws JsonProcessingException { + configureSuccessfulSpecResponse(specDeneb); } - private void configureSuccessfulSpecResponse( - final ClientAndServer mockBeaconServer, final Spec spec) throws JsonProcessingException { - mockBeaconServer + private void configureSuccessfulSpecResponse(final Spec spec) throws JsonProcessingException { + server .when(request().withPath("/eth/v1/config/spec")) .respond(response().withStatusCode(200).withBody(getTestSpecJsonString(spec))); } - private void configureSuccessfulHeadResponse(final ClientAndServer mockBeaconServer) - throws IOException { - final String testHead = - Resources.toString( - Resources.getResource("tech/pegasys/teku/cli/subcommand/voluntary-exit/head.json"), - UTF_8); - mockBeaconServer - .when(request().withPath("/eth/v1/beacon/headers/head")) - .respond(response().withStatusCode(200).withBody(testHead)); - } + private void configureSuccessfulGenesisResponse() { + final TimeProvider timeProvider = new SystemTimeProvider(); + final SpecConfig config = spec.getGenesisSpec().getConfig(); + final UInt64 genesisTime = + timeProvider + .getTimeInSeconds() + .minus(1020L * config.getSecondsPerSlot() * config.getSlotsPerEpoch()); - private void configureSuccessfulGenesisResponse(final ClientAndServer mockBeaconServer) - throws IOException { final String testHead = - Resources.toString( - Resources.getResource("tech/pegasys/teku/cli/subcommand/voluntary-exit/genesis.json"), - UTF_8); - mockBeaconServer + String.format( + "{ \"data\": {\"genesis_time\": \"%s\"," + + "\"genesis_validators_root\": \"0xf03f804ff1c97ada13050eb617e66e88e1199c2ce1be0b6b27e36fafb8d3ee48\"," + + "\"genesis_fork_version\": \"0x00004105\"}}", + genesisTime); + + server .when(request().withPath("/eth/v1/beacon/genesis")) .respond(response().withStatusCode(200).withBody(testHead)); } - private void configureSuccessfulValidatorResponses(final ClientAndServer mockBeaconServer) - throws IOException { - final String keyManagerValidator1 = - Resources.toString( - Resources.getResource( - "tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/8b0f19f_response.json"), - UTF_8); - - final String keyManagerValidator2 = - Resources.toString( - Resources.getResource( - "tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/82c2a92_response.json"), - UTF_8); - - final String validator1 = - Resources.toString( - Resources.getResource( - "tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/a756543_response.json"), - UTF_8); - - final String validator2 = - Resources.toString( - Resources.getResource( - "tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/aa51616_response.json"), - UTF_8); - - final String validators = - Resources.toString( - Resources.getResource( - "tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/validators_response.json"), - UTF_8); + private void configureSuccessfulValidatorResponses() throws IOException { + final String keyManagerValidator1 = validatorResourceFile("8b0f19f_response.json"); + final String keyManagerValidator2 = validatorResourceFile("82c2a92_response.json"); + final String validator1 = validatorResourceFile("a756543_response.json"); + final String validator2 = validatorResourceFile("aa51616_response.json"); - mockBeaconServer - .when( - request() - .withPath("/eth/v1/beacon/states/head/validators") - .withQueryStringParameters(Parameter.param("id", keyManagerPubKey1))) - .respond(response().withStatusCode(200).withBody(keyManagerValidator1)); + final String validators = validatorResourceFile("validators_response.json"); - mockBeaconServer - .when( - request() - .withPath("/eth/v1/beacon/states/head/validators") - .withQueryStringParameters(Parameter.param("id", keyManagerPubKey2))) - .respond(response().withStatusCode(200).withBody(keyManagerValidator2)); + setupValidatorStatusResponse(keyManagerPubKey1, keyManagerValidator1); + setupValidatorStatusResponse(keyManagerPubKey2, keyManagerValidator2); + setupValidatorStatusResponse(validatorPubKey1, validator1); + setupValidatorStatusResponse(validatorPubKey2, validator2); - mockBeaconServer + server .when( request() + .withMethod("POST") .withPath("/eth/v1/beacon/states/head/validators") - .withQueryStringParameters(Parameter.param("id", validatorPubKey1))) - .respond(response().withStatusCode(200).withBody(validator1)); + .withBody( + "{\"ids\":[" + + String.join( + ",", + quoted(validatorPubKey1), + quoted(keyManagerPubKey1), + quoted(keyManagerPubKey2), + quoted(validatorPubKey2)) + + "]}")) + .respond(response().withStatusCode(200).withBody(validators)); + } - mockBeaconServer + private void setupValidatorStatusResponse(final String publicKey, final String responseString) { + server .when( request() + .withMethod("POST") .withPath("/eth/v1/beacon/states/head/validators") - .withQueryStringParameters(Parameter.param("id", validatorPubKey2))) - .respond(response().withStatusCode(200).withBody(validator2)); + .withBody("{\"ids\":[" + String.join(",", "\"" + publicKey + "\"") + "]}")) + .respond(response().withStatusCode(200).withBody(responseString)); + } - mockBeaconServer - .when( - request() - .withPath("/eth/v1/beacon/states/head/validators") - .withQueryStringParameters( - Parameter.param( - "id", - String.join( - ",", - validatorPubKey1, - keyManagerPubKey1, - keyManagerPubKey2, - validatorPubKey2)))) - .respond(response().withStatusCode(200).withBody(validators)); + private String validatorResourceFile(final String validatorStatusFile) throws IOException { + return Resources.toString( + Resources.getResource( + "tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/" + + validatorStatusFile), + UTF_8); } - private void configureSuccessfulVoluntaryExitResponse(final ClientAndServer mockBeaconServer) { - mockBeaconServer + private void configureSuccessfulVoluntaryExitResponse() { + server .when(request().withPath("/eth/v1/beacon/pool/voluntary_exits")) .respond(response().withStatusCode(200)); } - private Supplier> configureSuccessfulVoluntaryExitResponseWithCapture( - final ClientAndServer mockBeaconServer) { + private Supplier> + configureSuccessfulVoluntaryExitResponseWithCapture() { final List responses = new ArrayList<>(); - mockBeaconServer + server .when(request().withPath("/eth/v1/beacon/pool/voluntary_exits")) .respond( httpRequest -> { @@ -592,28 +676,70 @@ private Supplier> configureSuccessfulVoluntaryExitResp .toList(); } - private void configureRejectedVoluntaryExitResponse(final ClientAndServer mockBeaconServer) - throws IOException { + private void configureExternalSignerUpcheck() { + server + .when(request().withMethod("GET").withPath("/upcheck")) + .respond(response().withStatusCode(200)); + } + + private void configureExternalSignerResponse( + final String validatorPubKey2, final BLSSignature blsSignature) { + server + .when(request().withMethod("POST").withPath("/api/v1/eth2/sign/" + validatorPubKey2)) + .respond(response().withStatusCode(200).withBody(blsSignature.toString())); + } + + private void configureExternalSignerPublicKeys(final List keys) { + final String body = + "{[" + + keys.stream() + .map( + k -> + "{" + + quotedFieldName("validating_pubkey") + + quoted(k) + + "," + + quotedFieldName("derivation_path") + + quoted("") + + "," + + quotedFieldName("readonly") + + "false}") + .collect(Collectors.joining(",")) + + "]}"; + server + .when(request().withMethod("GET").withPath("/eth/v1/keystores")) + .respond(response().withStatusCode(200).withBody(body)); + } + + private void configureRejectedVoluntaryExitResponse() throws IOException { final String rejectedExitResponseBody = Resources.toString( Resources.getResource( "tech/pegasys/teku/cli/subcommand/voluntary-exit/rejected-exit.json"), UTF_8); - mockBeaconServer + server .when(request().withMethod("POST").withPath("/eth/v1/beacon/pool/voluntary_exits")) .respond(response().withStatusCode(400).withBody(rejectedExitResponseBody)); } + private String quoted(final String unquotedString) { + return "\"" + unquotedString + "\""; + } + + private String quotedFieldName(final String unquotedString) { + return "\"" + unquotedString + "\":"; + } + private String getTestSpecJsonString(final Spec spec) throws JsonProcessingException { return JsonUtil.serialize(new ConfigProvider(spec).getConfig(), GET_SPEC_RESPONSE_TYPE); } - private String extractValidatorId(String pubKey) { + private String extractValidatorId(final String pubKey) { return pubKey.substring(2, 9); } - private void assertValidatorsExited(String... args) { + private void assertValidatorsExited(final String... args) { Arrays.stream(args) .forEach( arg -> { @@ -622,7 +748,7 @@ private void assertValidatorsExited(String... args) { }); } - private void assertValidatorsNotExited(String... args) { + private void assertValidatorsNotExited(final String... args) { Arrays.stream(args) .forEach( arg -> { diff --git a/teku/src/integration-test/resources/tech/pegasys/teku/cli/subcommand/voluntary-exit/genesis.json b/teku/src/integration-test/resources/tech/pegasys/teku/cli/subcommand/voluntary-exit/genesis.json deleted file mode 100644 index 889497930b1..00000000000 --- a/teku/src/integration-test/resources/tech/pegasys/teku/cli/subcommand/voluntary-exit/genesis.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "data": { - "genesis_time": "1663181025", - "genesis_validators_root": "0xf03f804ff1c97ada13050eb617e66e88e1199c2ce1be0b6b27e36fafb8d3ee48", - "genesis_fork_version": "0x00004105" - } -} \ No newline at end of file diff --git a/teku/src/integration-test/resources/tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/82c2a92_response.json b/teku/src/integration-test/resources/tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/82c2a92_response.json index a34d4bf3240..c161d514ca7 100644 --- a/teku/src/integration-test/resources/tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/82c2a92_response.json +++ b/teku/src/integration-test/resources/tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/82c2a92_response.json @@ -1,5 +1,6 @@ { "execution_optimistic": false, + "finalized": false, "data": [ { "index": "2", diff --git a/teku/src/integration-test/resources/tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/8b0f19f_response.json b/teku/src/integration-test/resources/tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/8b0f19f_response.json index a9fad311738..c9d37a37006 100644 --- a/teku/src/integration-test/resources/tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/8b0f19f_response.json +++ b/teku/src/integration-test/resources/tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/8b0f19f_response.json @@ -1,5 +1,6 @@ { "execution_optimistic": false, + "finalized": false, "data": [ { "index": "1", diff --git a/teku/src/integration-test/resources/tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/a756543_response.json b/teku/src/integration-test/resources/tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/a756543_response.json index c02a74dd54d..aea602a01ee 100644 --- a/teku/src/integration-test/resources/tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/a756543_response.json +++ b/teku/src/integration-test/resources/tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/a756543_response.json @@ -1,5 +1,6 @@ { "execution_optimistic": false, + "finalized": false, "data": [ { "index": "3", diff --git a/teku/src/integration-test/resources/tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/aa51616_response.json b/teku/src/integration-test/resources/tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/aa51616_response.json index df5b80423e5..cbd88d57f2a 100644 --- a/teku/src/integration-test/resources/tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/aa51616_response.json +++ b/teku/src/integration-test/resources/tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/aa51616_response.json @@ -1,5 +1,6 @@ { "execution_optimistic": false, + "finalized": false, "data": [ { "index": "4", diff --git a/teku/src/integration-test/resources/tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/validators_response.json b/teku/src/integration-test/resources/tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/validators_response.json index a4672152f5e..c7df320b1cb 100644 --- a/teku/src/integration-test/resources/tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/validators_response.json +++ b/teku/src/integration-test/resources/tech/pegasys/teku/cli/subcommand/voluntary-exit/validator-responses/validators_response.json @@ -1,5 +1,6 @@ { "execution_optimistic": false, + "finalized": false, "data": [ { "index": "1", diff --git a/teku/src/main/java/tech/pegasys/teku/AbstractNode.java b/teku/src/main/java/tech/pegasys/teku/AbstractNode.java index 84a650d7f3e..cb98c043b0d 100644 --- a/teku/src/main/java/tech/pegasys/teku/AbstractNode.java +++ b/teku/src/main/java/tech/pegasys/teku/AbstractNode.java @@ -14,6 +14,7 @@ package tech.pegasys.teku; import static tech.pegasys.teku.infrastructure.logging.StatusLogger.STATUS_LOG; +import static tech.pegasys.teku.infrastructure.time.SystemTimeProvider.SYSTEM_TIME_PROVIDER; import static tech.pegasys.teku.networks.Eth2NetworkConfiguration.MAX_EPOCHS_STORE_BLOBS; import com.google.common.util.concurrent.ThreadFactoryBuilder; @@ -37,7 +38,6 @@ import tech.pegasys.teku.infrastructure.events.EventChannels; import tech.pegasys.teku.infrastructure.logging.StartupLogConfig; import tech.pegasys.teku.infrastructure.metrics.MetricsEndpoint; -import tech.pegasys.teku.infrastructure.time.SystemTimeProvider; import tech.pegasys.teku.infrastructure.version.VersionProvider; import tech.pegasys.teku.service.serviceutils.ServiceConfig; import tech.pegasys.teku.service.serviceutils.layout.DataDirLayout; @@ -110,7 +110,7 @@ protected AbstractNode(final TekuConfiguration tekuConfig) { serviceConfig = new ServiceConfig( asyncRunnerFactory, - new SystemTimeProvider(), + SYSTEM_TIME_PROVIDER, eventChannels, metricsSystem, dataDirLayout, diff --git a/teku/src/main/java/tech/pegasys/teku/Teku.java b/teku/src/main/java/tech/pegasys/teku/Teku.java index 2dc1ec19f20..cf4cecff13c 100644 --- a/teku/src/main/java/tech/pegasys/teku/Teku.java +++ b/teku/src/main/java/tech/pegasys/teku/Teku.java @@ -23,6 +23,7 @@ import tech.pegasys.teku.cli.BeaconNodeCommand; import tech.pegasys.teku.cli.BeaconNodeCommand.StartAction; import tech.pegasys.teku.config.TekuConfiguration; +import tech.pegasys.teku.infrastructure.io.JemallocDetector; import tech.pegasys.teku.infrastructure.logging.LoggingConfigurator; public final class Teku { @@ -33,7 +34,7 @@ public final class Teku { Security.addProvider(new BouncyCastleProvider()); } - public static void main(String[] args) { + public static void main(final String[] args) { Thread.setDefaultUncaughtExceptionHandler(new TekuDefaultExceptionHandler()); try { @@ -54,7 +55,7 @@ public static void main(String[] args) { } } - private static int start(StartAction startAction, final String... args) { + private static int start(final StartAction startAction, final String... args) { final PrintWriter outputWriter = new PrintWriter(System.out, true, Charset.defaultCharset()); final PrintWriter errorWriter = new PrintWriter(System.err, true, Charset.defaultCharset()); final LoggingConfigurator loggingConfigurator = new LoggingConfigurator(); @@ -74,13 +75,14 @@ private static Node start(final TekuConfiguration config, final boolean validato if (BlstLoader.INSTANCE.isEmpty()) { throw new UnsupportedOperationException("BLS native library unavailable for this platform"); } + JemallocDetector.logJemallocPresence(); node.start(); return node; } - static Optional startFromCLIArgs(String[] cliArgs) throws CLIException { + static Optional startFromCLIArgs(final String[] cliArgs) throws CLIException { AtomicReference nodeRef = new AtomicReference<>(); int result = start((config, validatorClient) -> nodeRef.set(start(config, validatorClient)), cliArgs); @@ -90,18 +92,18 @@ static Optional startFromCLIArgs(String[] cliArgs) throws CLIException { return Optional.ofNullable(nodeRef.get()); } - static BeaconNode startBeaconNode(TekuConfiguration config) { + static BeaconNode startBeaconNode(final TekuConfiguration config) { return (BeaconNode) start(config, false); } - static ValidatorNode startValidatorNode(TekuConfiguration config) { + static ValidatorNode startValidatorNode(final TekuConfiguration config) { return (ValidatorNode) start(config, true); } private static class CLIException extends RuntimeException { private final int resultCode; - public CLIException(int resultCode) { + public CLIException(final int resultCode) { super("Unable to start Teku. Exit code: " + resultCode); this.resultCode = resultCode; } diff --git a/teku/src/main/java/tech/pegasys/teku/TekuDefaultExceptionHandler.java b/teku/src/main/java/tech/pegasys/teku/TekuDefaultExceptionHandler.java index 7dd85615e62..5ed2d93d177 100644 --- a/teku/src/main/java/tech/pegasys/teku/TekuDefaultExceptionHandler.java +++ b/teku/src/main/java/tech/pegasys/teku/TekuDefaultExceptionHandler.java @@ -29,6 +29,7 @@ import tech.pegasys.teku.infrastructure.exceptions.ExceptionUtil; import tech.pegasys.teku.infrastructure.exceptions.FatalServiceFailureException; import tech.pegasys.teku.infrastructure.logging.StatusLogger; +import tech.pegasys.teku.services.beaconchain.EphemeryLifecycleException; import tech.pegasys.teku.storage.server.DatabaseStorageException; import tech.pegasys.teku.storage.server.ShuttingDownException; @@ -85,6 +86,9 @@ private void handleException(final Throwable exception, final String subscriberD } else if (exception instanceof OutOfMemoryError) { statusLog.fatalError(subscriberDescription, exception); System.exit(ERROR_EXIT_CODE); + } else if (exception instanceof EphemeryLifecycleException) { + statusLog.fatalError(subscriberDescription, exception); + System.exit(ERROR_EXIT_CODE); } else if (exception instanceof ShuttingDownException) { LOG.debug("Shutting down", exception); } else if (isExpectedNettyError(exception)) { diff --git a/teku/src/main/java/tech/pegasys/teku/TekuFacade.java b/teku/src/main/java/tech/pegasys/teku/TekuFacade.java index 9b5787664c4..aecdfbabc97 100644 --- a/teku/src/main/java/tech/pegasys/teku/TekuFacade.java +++ b/teku/src/main/java/tech/pegasys/teku/TekuFacade.java @@ -31,15 +31,15 @@ public final class TekuFacade { * start a Node (e.g. --help command) * @throws RuntimeException if invalid args supplied or an internal error while starting a Node */ - public static Optional startFromCLIArgs(String[] cliArgs) { + public static Optional startFromCLIArgs(final String[] cliArgs) { return Teku.startFromCLIArgs(cliArgs); } - public static BeaconNodeFacade startBeaconNode(TekuConfiguration config) { + public static BeaconNodeFacade startBeaconNode(final TekuConfiguration config) { return Teku.startBeaconNode(config); } - public static ValidatorNodeFacade startValidatorNode(TekuConfiguration config) { + public static ValidatorNodeFacade startValidatorNode(final TekuConfiguration config) { return Teku.startValidatorNode(config); } } diff --git a/teku/src/main/java/tech/pegasys/teku/cli/BeaconNodeCommand.java b/teku/src/main/java/tech/pegasys/teku/cli/BeaconNodeCommand.java index 5cc19ea8801..0611a0e88be 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/BeaconNodeCommand.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/BeaconNodeCommand.java @@ -138,31 +138,31 @@ private static class ConfigFileCommand { private File configFile; @Mixin(name = "Network") - private Eth2NetworkOptions eth2NetworkOptions = new Eth2NetworkOptions(); + private final Eth2NetworkOptions eth2NetworkOptions = new Eth2NetworkOptions(); @Mixin(name = "P2P") - private P2POptions p2POptions = new P2POptions(); + private final P2POptions p2POptions = new P2POptions(); @Mixin(name = "Validator") - private ValidatorOptions validatorOptions = new ValidatorOptions(); + private final ValidatorOptions validatorOptions = new ValidatorOptions(); @Mixin(name = "Execution Layer") - private ExecutionLayerOptions executionLayerOptions = new ExecutionLayerOptions(); + private final ExecutionLayerOptions executionLayerOptions = new ExecutionLayerOptions(); @Mixin(name = "Data Storage") - private BeaconNodeDataOptions beaconNodeDataOptions = new BeaconNodeDataOptions(); + private final BeaconNodeDataOptions beaconNodeDataOptions = new BeaconNodeDataOptions(); @Mixin(name = "Beacon REST API") - private BeaconRestApiOptions beaconRestApiOptions = new BeaconRestApiOptions(); + private final BeaconRestApiOptions beaconRestApiOptions = new BeaconRestApiOptions(); @Mixin(name = "Validator REST API") - private ValidatorRestApiOptions validatorRestApiOptions = new ValidatorRestApiOptions(); + private final ValidatorRestApiOptions validatorRestApiOptions = new ValidatorRestApiOptions(); @Mixin(name = "Weak Subjectivity") - private WeakSubjectivityOptions weakSubjectivityOptions = new WeakSubjectivityOptions(); + private final WeakSubjectivityOptions weakSubjectivityOptions = new WeakSubjectivityOptions(); @Mixin(name = "Interop") - private InteropOptions interopOptions = new InteropOptions(); + private final InteropOptions interopOptions = new InteropOptions(); @Mixin(name = "Store") private final StoreOptions storeOptions = new StoreOptions(); @@ -171,7 +171,7 @@ private static class ConfigFileCommand { private final LoggingOptions loggingOptions = new LoggingOptions(); @Mixin(name = "Metrics") - private MetricsOptions metricsOptions = new MetricsOptions(); + private final MetricsOptions metricsOptions = new MetricsOptions(); @CommandLine.Spec private CommandLine.Model.CommandSpec spec; @@ -212,7 +212,7 @@ private CommandLine getConfigFileCommandLine(final ConfigFileCommand configFileC } private CommandLine getCommandLine() { - return configureCommandLine(new CommandLine(this)).addSubcommand(validatorClientSubcommand); + return configureCommandLine(new CommandLine(this).addSubcommand(validatorClientSubcommand)); } public int parse(final String[] args) { @@ -319,13 +319,13 @@ private int handleParseException(final CommandLine.ParameterException ex, final return ex.getCommandLine().getCommandSpec().exitCodeOnInvalidInput(); } - private void printUsage(PrintWriter outputWriter) { + private void printUsage(final PrintWriter outputWriter) { outputWriter.println(); outputWriter.println("To display full help:"); outputWriter.println("teku [COMMAND] --help"); } - public boolean isOptionSpecified(String optionLongName) { + public boolean isOptionSpecified(final String optionLongName) { var parseResult = spec.commandLine().getParseResult(); var option = spec.findOption(optionLongName); return option != null && parseResult.hasMatchedOption(option); diff --git a/teku/src/main/java/tech/pegasys/teku/cli/converter/LogTypeConverter.java b/teku/src/main/java/tech/pegasys/teku/cli/converter/LogTypeConverter.java index 6827643ca34..054fbeaa60b 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/converter/LogTypeConverter.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/converter/LogTypeConverter.java @@ -20,7 +20,7 @@ public class LogTypeConverter implements ITypeConverter { @Override - public Level convert(String value) { + public Level convert(final String value) { switch (value.toUpperCase(Locale.ROOT)) { case "OFF": return Level.OFF; diff --git a/teku/src/main/java/tech/pegasys/teku/cli/converter/OptionalIntConverter.java b/teku/src/main/java/tech/pegasys/teku/cli/converter/OptionalIntConverter.java new file mode 100644 index 00000000000..0025a267336 --- /dev/null +++ b/teku/src/main/java/tech/pegasys/teku/cli/converter/OptionalIntConverter.java @@ -0,0 +1,25 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.cli.converter; + +import java.util.OptionalInt; +import picocli.CommandLine; + +public class OptionalIntConverter implements CommandLine.ITypeConverter { + + @Override + public OptionalInt convert(final String s) throws Exception { + return OptionalInt.of(Integer.parseInt(s)); + } +} diff --git a/teku/src/main/java/tech/pegasys/teku/cli/options/BeaconNodeDataOptions.java b/teku/src/main/java/tech/pegasys/teku/cli/options/BeaconNodeDataOptions.java index 954eda886ce..8ce5d876600 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/options/BeaconNodeDataOptions.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/options/BeaconNodeDataOptions.java @@ -13,6 +13,7 @@ package tech.pegasys.teku.cli.options; +import static tech.pegasys.teku.service.serviceutils.layout.DataConfig.DEFAULT_DEBUG_DATA_DUMPING_ENABLED; import static tech.pegasys.teku.storage.server.StorageConfiguration.DEFAULT_STATE_REBUILD_TIMEOUT_SECONDS; import java.nio.file.Path; @@ -54,6 +55,37 @@ public class BeaconNodeDataOptions extends ValidatorClientDataOptions { arity = "1") private long dataStorageFrequency = StorageConfiguration.DEFAULT_STORAGE_FREQUENCY; + @CommandLine.Option( + names = {"--Xdata-storage-archive-finalized-states-retained"}, + paramLabel = "", + description = + "Sets the period of retained finalized states in disk, in slots. " + + "This option is ignored if --data-storage-mode is set to PRUNE or MINIMAL", + arity = "1", + hidden = true) + private long dataStorageRetainedSlots = StorageConfiguration.DEFAULT_STORAGE_RETAINED_SLOTS; + + @CommandLine.Option( + names = {"--Xdata-storage-state-pruning-interval"}, + hidden = true, + paramLabel = "", + description = "Interval in seconds between finalized state pruning", + fallbackValue = "true", + showDefaultValue = Visibility.ALWAYS, + arity = "0..1") + private long statePruningIntervalSeconds = + StorageConfiguration.DEFAULT_STATE_PRUNING_INTERVAL.toSeconds(); + + @CommandLine.Option( + names = {"--Xdata-storage-state-pruning-limit"}, + hidden = true, + paramLabel = "", + description = "Maximum number of finalized states that can be pruned in each pruning session", + fallbackValue = "true", + showDefaultValue = Visibility.ALWAYS, + arity = "0..1") + private int statePruningLimit = StorageConfiguration.DEFAULT_STATE_PRUNING_LIMIT; + @CommandLine.Option( names = {"--Xdata-storage-create-db-version"}, paramLabel = "", @@ -132,12 +164,23 @@ public class BeaconNodeDataOptions extends ValidatorClientDataOptions { names = {"--Xdata-storage-blobs-pruning-limit"}, hidden = true, paramLabel = "", - description = "Maximum number of blob sidecars that can be pruned in each pruning session", + description = + "Maximum number of blocks of blob sidecars that can be pruned in each pruning session", fallbackValue = "true", showDefaultValue = Visibility.ALWAYS, arity = "0..1") private int blobsPruningLimit = StorageConfiguration.DEFAULT_BLOBS_PRUNING_LIMIT; + @CommandLine.Option( + names = {"--Xdata-storage-blobs-archive-path"}, + hidden = true, + paramLabel = "", + description = "Path to write pruned blobs", + fallbackValue = "true", + showDefaultValue = Visibility.ALWAYS, + arity = "0..1") + private String blobsArchivePath = null; + @Option( names = {"--Xdata-storage-state-rebuild-timeout-seconds"}, hidden = true, @@ -147,9 +190,22 @@ public class BeaconNodeDataOptions extends ValidatorClientDataOptions { arity = "1") private int stateRebuildTimeoutSeconds = DEFAULT_STATE_REBUILD_TIMEOUT_SECONDS; + @Option( + names = {"--Xdebug-data-dumping-enabled"}, + paramLabel = "", + showDefaultValue = Visibility.ALWAYS, + description = + "Enable saving objects to files that cause problems when processing, for example rejected blocks or invalid gossip.\n Default: /debug", + fallbackValue = "true", + hidden = true, + arity = "0..1") + private boolean debugDataDumpingEnabled = DEFAULT_DEBUG_DATA_DUMPING_ENABLED; + @Override protected DataConfig.Builder configureDataConfig(final DataConfig.Builder config) { - return super.configureDataConfig(config).beaconDataPath(dataBeaconPath); + return super.configureDataConfig(config) + .beaconDataPath(dataBeaconPath) + .debugDataDumpingEnabled(debugDataDumpingEnabled); } @Override @@ -166,7 +222,11 @@ public void configure(final TekuConfiguration.Builder builder) { .blockPruningLimit(blockPruningLimit) .stateRebuildTimeoutSeconds(stateRebuildTimeoutSeconds) .blobsPruningInterval(Duration.ofSeconds(blobsPruningIntervalSeconds)) - .blobsPruningLimit(blobsPruningLimit)); + .blobsPruningLimit(blobsPruningLimit) + .blobsArchivePath(blobsArchivePath) + .retainedSlots(dataStorageRetainedSlots) + .statePruningInterval(Duration.ofSeconds(statePruningIntervalSeconds)) + .statePruningLimit(statePruningLimit)); builder.sync( b -> b.fetchAllHistoricBlocks(dataStorageMode.storesAllBlocks()) diff --git a/teku/src/main/java/tech/pegasys/teku/cli/options/BeaconRestApiOptions.java b/teku/src/main/java/tech/pegasys/teku/cli/options/BeaconRestApiOptions.java index 75a0cc8fc6e..16e8e44267f 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/options/BeaconRestApiOptions.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/options/BeaconRestApiOptions.java @@ -101,7 +101,7 @@ public class BeaconRestApiOptions { defaultValue = "65535", showDefaultValue = Visibility.ALWAYS, hidden = true) - public void setMaxUrlLength(int maxUrlLength) { + public void setMaxUrlLength(final int maxUrlLength) { if (maxUrlLength < 4096 || maxUrlLength > 1052672) { throw new CommandLine.ParameterException( cliSpec.commandLine(), diff --git a/teku/src/main/java/tech/pegasys/teku/cli/options/DataOptions.java b/teku/src/main/java/tech/pegasys/teku/cli/options/DataOptions.java index 0fb7573ad03..55969696179 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/options/DataOptions.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/options/DataOptions.java @@ -13,6 +13,8 @@ package tech.pegasys.teku.cli.options; +import static tech.pegasys.teku.service.serviceutils.layout.DataConfig.DEFAULT_DATA_PATH; + import java.nio.file.Path; import picocli.CommandLine.Option; import tech.pegasys.teku.config.TekuConfiguration; @@ -25,7 +27,7 @@ public abstract class DataOptions { paramLabel = "", description = "Path to the base directory for storage", arity = "1") - private Path dataBasePath = DataConfig.defaultDataPath(); + private Path dataBasePath = DEFAULT_DATA_PATH; public DataConfig getDataConfig() { return configureDataConfig(DataConfig.builder()).build(); @@ -35,7 +37,7 @@ public String getDataPath() { return getDataConfig().getDataBasePath().toString(); } - public void configure(TekuConfiguration.Builder builder) { + public void configure(final TekuConfiguration.Builder builder) { builder.data(this::configureDataConfig); } diff --git a/teku/src/main/java/tech/pegasys/teku/cli/options/Eth2NetworkOptions.java b/teku/src/main/java/tech/pegasys/teku/cli/options/Eth2NetworkOptions.java index 4cc6c402ada..4f264da06f4 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/options/Eth2NetworkOptions.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/options/Eth2NetworkOptions.java @@ -13,12 +13,11 @@ package tech.pegasys.teku.cli.options; -import static tech.pegasys.teku.networks.Eth2NetworkConfiguration.DEFAULT_ASYNC_BEACON_CHAIN_MAX_QUEUE; import static tech.pegasys.teku.networks.Eth2NetworkConfiguration.DEFAULT_ASYNC_BEACON_CHAIN_MAX_THREADS; -import static tech.pegasys.teku.networks.Eth2NetworkConfiguration.DEFAULT_ASYNC_P2P_MAX_QUEUE; import static tech.pegasys.teku.networks.Eth2NetworkConfiguration.DEFAULT_ASYNC_P2P_MAX_THREADS; import static tech.pegasys.teku.spec.constants.NetworkConstants.DEFAULT_SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY; +import java.util.OptionalInt; import java.util.function.Consumer; import org.apache.commons.lang3.StringUtils; import org.apache.tuweni.bytes.Bytes32; @@ -27,8 +26,10 @@ import picocli.CommandLine.Help.Visibility; import picocli.CommandLine.Option; import tech.pegasys.teku.cli.converter.Bytes32Converter; +import tech.pegasys.teku.cli.converter.OptionalIntConverter; import tech.pegasys.teku.cli.converter.UInt256Converter; import tech.pegasys.teku.config.TekuConfiguration; +import tech.pegasys.teku.infrastructure.exceptions.InvalidConfigurationException; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.networks.Eth2NetworkConfiguration; @@ -45,7 +46,8 @@ public class Eth2NetworkOptions { names = {"--initial-state"}, paramLabel = "", description = - "The initial state. This value should be a file or URL pointing to an SSZ-encoded finalized checkpoint state.", + "The initial state. This value should be a file or URL pointing to an SSZ-encoded finalized checkpoint " + + "state.", arity = "1") private String initialState; @@ -62,7 +64,8 @@ public class Eth2NetworkOptions { names = {"--genesis-state"}, paramLabel = "", description = - "The genesis state. This value should be a file or URL pointing to an SSZ-encoded finalized checkpoint state.", + "The genesis state. This value should be a file or URL pointing to an SSZ-encoded finalized checkpoint " + + "state.", arity = "1") private String genesisState; @@ -86,7 +89,8 @@ public class Eth2NetworkOptions { hidden = true, paramLabel = "", description = - "The trusted setup which is needed for KZG commitments. Only required when creating a custom network. This value should be a file or URL pointing to a trusted setup.", + "The trusted setup which is needed for KZG commitments. Only required when creating a custom network. This " + + "value should be a file or URL pointing to a trusted setup.", arity = "1") private String trustedSetup = null; // Depends on network configuration @@ -116,7 +120,8 @@ public class Eth2NetworkOptions { names = {"--Xfork-choice-updated-always-send-payload-attributes"}, paramLabel = "", description = - "Calculate and send payload attributes on every forkChoiceUpdated regardless if a connected validator is due to be a block proposer or not.", + "Calculate and send payload attributes on every forkChoiceUpdated regardless if a connected validator is " + + "due to be a block proposer or not.", arity = "0..1", fallbackValue = "true", showDefaultValue = Visibility.ALWAYS, @@ -156,6 +161,14 @@ public class Eth2NetworkOptions { arity = "1") private UInt64 denebForkEpoch; + @Option( + names = {"--Xnetwork-electra-fork-epoch"}, + hidden = true, + paramLabel = "", + description = "Override the electra fork activation epoch.", + arity = "1") + private UInt64 electraForkEpoch; + @Option( names = {"--Xnetwork-das-fork-epoch"}, hidden = true, @@ -178,7 +191,8 @@ public class Eth2NetworkOptions { hidden = true, paramLabel = "", description = - "Override terminal block hash for The Merge. To be used in conjunction with --Xnetwork-bellatrix-terminal-block-hash-epoch-override", + "Override terminal block hash for The Merge. To be used in conjunction with " + + "--Xnetwork-bellatrix-terminal-block-hash-epoch-override", arity = "1", converter = Bytes32Converter.class) private Bytes32 terminalBlockHashOverride; @@ -188,7 +202,8 @@ public class Eth2NetworkOptions { hidden = true, paramLabel = "", description = - "Override terminal block hash for The Merge. To be used in conjunction with --Xnetwork-bellatrix-terminal-block-hash-override", + "Override terminal block hash for The Merge. To be used in conjunction with " + + "--Xnetwork-bellatrix-terminal-block-hash-override", arity = "1") private UInt64 terminalBlockHashEpochOverride; @@ -197,7 +212,8 @@ public class Eth2NetworkOptions { hidden = true, paramLabel = "", description = - "Override the the number of slots that must pass before it is considered safe to optimistically import a block", + "Override the the number of slots that must pass before it is considered safe to optimistically import a " + + "block", arity = "1") private Integer safeSlotsToImportOptimistically = DEFAULT_SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY; @@ -214,8 +230,9 @@ public class Eth2NetworkOptions { hidden = true, paramLabel = "", description = "Override the queue size of the p2p async runner", + converter = OptionalIntConverter.class, arity = "1") - private Integer asyncP2pMaxQueue = DEFAULT_ASYNC_P2P_MAX_QUEUE; + private OptionalInt asyncP2pMaxQueue = OptionalInt.empty(); @Option( names = {"--Xnetwork-async-beaconchain-max-threads"}, @@ -230,8 +247,9 @@ public class Eth2NetworkOptions { hidden = true, paramLabel = "", description = "Override the queue size of the beaconchain queue", + converter = OptionalIntConverter.class, arity = "1") - private Integer asyncBeaconChainMaxQueue = DEFAULT_ASYNC_BEACON_CHAIN_MAX_QUEUE; + private OptionalInt asyncBeaconChainMaxQueue = OptionalInt.empty(); @Option( names = {"--Xstartup-target-peer-count"}, @@ -244,7 +262,8 @@ public class Eth2NetworkOptions { names = {"--Xstartup-timeout-seconds"}, paramLabel = "", description = - "Timeout in seconds to allow the node to be in sync even if startup target peer count has not yet been reached.", + "Timeout in seconds to allow the node to be in sync even if startup target peer count has not yet been " + + "reached.", hidden = true) private Integer startupTimeoutSeconds; @@ -261,7 +280,9 @@ public class Eth2NetworkOptions { hidden = true, paramLabel = "", description = - "Sets the number of epochs blob sidecars are stored and requested during the sync. Use MAX to store all blob sidecars. The value cannot be set to be lower than the spec's MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS.", + "Sets the number of epochs blob sidecars are stored and requested during the sync. Use MAX to store all " + + "blob sidecars. The value cannot be set to be lower than the spec's " + + "MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS.", fallbackValue = "", showDefaultValue = Visibility.ALWAYS, arity = "0..1") @@ -288,7 +309,13 @@ private Eth2NetworkConfiguration createEth2NetworkConfig( return builder.build(); } - private void configureEth2Network(Eth2NetworkConfiguration.Builder builder) { + private void configureEth2Network(final Eth2NetworkConfiguration.Builder builder) { + if (network.equals("goerli")) { + throw new InvalidConfigurationException( + "Goerli support has been removed. Please choose another network (see https://docs.teku.consensys" + + ".io/get-started/connect)."); + } + builder.applyNetworkDefaults(network); if (startupTargetPeerCount != null) { builder.startupTargetPeerCount(startupTargetPeerCount); @@ -320,6 +347,9 @@ private void configureEth2Network(Eth2NetworkConfiguration.Builder builder) { if (denebForkEpoch != null) { builder.denebForkEpoch(denebForkEpoch); } + if (electraForkEpoch != null) { + builder.electraForkEpoch(electraForkEpoch); + } if (eip7594ForkEpoch != null) { builder.eip7594ForkEpoch(eip7594ForkEpoch); } @@ -342,13 +372,13 @@ private void configureEth2Network(Eth2NetworkConfiguration.Builder builder) { .ignoreWeakSubjectivityPeriodEnabled(ignoreWeakSubjectivityPeriodEnabled) .safeSlotsToImportOptimistically(safeSlotsToImportOptimistically) .asyncP2pMaxThreads(asyncP2pMaxThreads) - .asyncP2pMaxQueue(asyncP2pMaxQueue) .asyncBeaconChainMaxThreads(asyncBeaconChainMaxThreads) - .asyncBeaconChainMaxQueue(asyncBeaconChainMaxQueue) .forkChoiceLateBlockReorgEnabled(forkChoiceLateBlockReorgEnabled) .epochsStoreBlobs(epochsStoreBlobs) .forkChoiceUpdatedAlwaysSendPayloadAttributes(forkChoiceUpdatedAlwaysSendPayloadAttributes) .rustKzgEnabled(rustKzgEnabled); + asyncP2pMaxQueue.ifPresent(builder::asyncP2pMaxQueue); + asyncBeaconChainMaxQueue.ifPresent(builder::asyncBeaconChainMaxQueue); } public String getNetwork() { diff --git a/teku/src/main/java/tech/pegasys/teku/cli/options/ExecutionLayerOptions.java b/teku/src/main/java/tech/pegasys/teku/cli/options/ExecutionLayerOptions.java index 77d5d7402e0..8613ded0fbb 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/options/ExecutionLayerOptions.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/options/ExecutionLayerOptions.java @@ -30,7 +30,7 @@ public class ExecutionLayerOptions { - @Mixin private DepositOptions depositOptions = new DepositOptions(); + @Mixin private final DepositOptions depositOptions = new DepositOptions(); @Option( names = {"--ee-endpoint"}, diff --git a/teku/src/main/java/tech/pegasys/teku/cli/options/LoggingOptions.java b/teku/src/main/java/tech/pegasys/teku/cli/options/LoggingOptions.java index 60b9a9cc71b..6491f8173b2 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/options/LoggingOptions.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/options/LoggingOptions.java @@ -149,7 +149,7 @@ public class LoggingOptions { arity = "1") private int dbOpAlertThresholdMillis = LoggingConfig.DEFAULT_DB_OP_ALERT_THRESHOLD_MILLIS; - private boolean containsPath(String file) { + private boolean containsPath(final String file) { return file.contains(LINUX_SEP) || file.contains(WINDOWS_SEP); } diff --git a/teku/src/main/java/tech/pegasys/teku/cli/options/MetricsOptions.java b/teku/src/main/java/tech/pegasys/teku/cli/options/MetricsOptions.java index 16c3fbafcf7..9804fb9f340 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/options/MetricsOptions.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/options/MetricsOptions.java @@ -121,28 +121,56 @@ public class MetricsOptions { MetricsConfig.DEFAULT_BLOCK_PRODUCTION_AND_PUBLISHING_PERFORMANCE_ENABLED; @Option( - names = {"--Xmetrics-block-production-timing-tracking-warning-threshold"}, + names = {"--Xmetrics-block-production-timing-tracking-warning-local-threshold"}, hidden = true, showDefaultValue = Visibility.ALWAYS, paramLabel = "", description = - "The time (in ms) at which block production is to be considered 'slow'. If set to 100, block production taking at least 100ms would raise a warning.", - fallbackValue = "true", - arity = "0..1") - private int blockProductionPerformanceWarningThreshold = - MetricsConfig.DEFAULT_BLOCK_PRODUCTION_PERFORMANCE_WARNING_THRESHOLD; + """ + The time (in ms) taken from the beginning of the slot at which block production using a local flow is to be considered 'slow'. + If set to 100, block production taking at least 100ms into the slot would raise a warning.""", + arity = "1") + private int blockProductionPerformanceWarningLocalThreshold = + MetricsConfig.DEFAULT_BLOCK_PRODUCTION_PERFORMANCE_WARNING_LOCAL_THRESHOLD; @Option( - names = {"--Xmetrics-block-publishing-timing-tracking-warning-threshold"}, + names = {"--Xmetrics-block-production-timing-tracking-warning-builder-threshold"}, hidden = true, showDefaultValue = Visibility.ALWAYS, paramLabel = "", description = - "The time (in ms) at which block publishing is to be considered 'slow'. If set to 100, block publishing taking at least 100ms would raise a warning.", - fallbackValue = "true", - arity = "0..1") - private int blockPublishingPerformanceWarningThreshold = - MetricsConfig.DEFAULT_BLOCK_PUBLISHING_PERFORMANCE_WARNING_THRESHOLD; + """ + The time (in ms) taken from the beginning of the slot at which block production using a builder flow is to be considered 'slow'. + If set to 100, block production taking at least 100ms into the slot would raise a warning.""", + arity = "1") + private int blockProductionPerformanceWarningBuilderThreshold = + MetricsConfig.DEFAULT_BLOCK_PRODUCTION_PERFORMANCE_WARNING_BUILDER_THRESHOLD; + + @Option( + names = {"--Xmetrics-block-publishing-timing-tracking-warning-local-threshold"}, + hidden = true, + showDefaultValue = Visibility.ALWAYS, + paramLabel = "", + description = + """ + The time (in ms) taken from the beginning of the slot at which block publishing using a local flow is to be considered 'slow'. + If set to 100, block publishing taking at least 100ms into the slot would raise a warning.""", + arity = "1") + private int blockPublishingPerformanceWarningLocalThreshold = + MetricsConfig.DEFAULT_BLOCK_PUBLISHING_PERFORMANCE_WARNING_LOCAL_THRESHOLD; + + @Option( + names = {"--Xmetrics-block-publishing-timing-tracking-warning-builder-threshold"}, + hidden = true, + showDefaultValue = Visibility.ALWAYS, + paramLabel = "", + description = + """ + The time (in ms) taken from the beginning of the slot at which block publishing using a builder flow is to be considered 'slow'. + If set to 100, block publishing taking at least 100ms into the slot would raise a warning.""", + arity = "1") + private int blockPublishingPerformanceWarningBuilderThreshold = + MetricsConfig.DEFAULT_BLOCK_PUBLISHING_PERFORMANCE_WARNING_BUILDER_THRESHOLD; @Option( names = {"--Xmetrics-blob-sidecars-storage-enabled"}, @@ -155,7 +183,7 @@ public class MetricsOptions { private boolean blobSidecarsStorageCountersEnabled = MetricsConfig.DEFAULT_BLOB_SIDECARS_STORAGE_COUNTERS_ENABLED; - public void configure(TekuConfiguration.Builder builder) { + public void configure(final TekuConfiguration.Builder builder) { builder.metrics( b -> b.metricsEnabled(metricsEnabled) @@ -171,10 +199,14 @@ public void configure(TekuConfiguration.Builder builder) { .blobSidecarsStorageCountersEnabled(blobSidecarsStorageCountersEnabled) .blockProductionAndPublishingPerformanceEnabled( blockProductionAndPublishingPerformanceEnabled) - .blockProductionPerformanceWarningThreshold( - blockProductionPerformanceWarningThreshold) - .blockPublishingPerformanceWarningThreshold( - blockPublishingPerformanceWarningThreshold)); + .blockProductionPerformanceWarningLocalThreshold( + blockProductionPerformanceWarningLocalThreshold) + .blockProductionPerformanceWarningBuilderThreshold( + blockProductionPerformanceWarningBuilderThreshold) + .blockPublishingPerformanceWarningLocalThreshold( + blockPublishingPerformanceWarningLocalThreshold) + .blockPublishingPerformanceWarningBuilderThreshold( + blockPublishingPerformanceWarningBuilderThreshold)); } private URL parseMetricsEndpointUrl() { diff --git a/teku/src/main/java/tech/pegasys/teku/cli/options/P2POptions.java b/teku/src/main/java/tech/pegasys/teku/cli/options/P2POptions.java index 4c6611fa352..0d7a2352d50 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/options/P2POptions.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/options/P2POptions.java @@ -13,7 +13,12 @@ package tech.pegasys.teku.cli.options; -import static tech.pegasys.teku.infrastructure.logging.StatusLogger.STATUS_LOG; +import static tech.pegasys.teku.infrastructure.async.AsyncRunnerFactory.DEFAULT_MAX_QUEUE_SIZE_ALL_SUBNETS; +import static tech.pegasys.teku.networking.p2p.discovery.DiscoveryConfig.DEFAULT_P2P_PEERS_LOWER_BOUND; +import static tech.pegasys.teku.networking.p2p.discovery.DiscoveryConfig.DEFAULT_P2P_PEERS_LOWER_BOUND_ALL_SUBNETS; +import static tech.pegasys.teku.networking.p2p.discovery.DiscoveryConfig.DEFAULT_P2P_PEERS_UPPER_BOUND; +import static tech.pegasys.teku.networking.p2p.discovery.DiscoveryConfig.DEFAULT_P2P_PEERS_UPPER_BOUND_ALL_SUBNETS; +import static tech.pegasys.teku.validator.api.ValidatorConfig.DEFAULT_EXECUTOR_MAX_QUEUE_SIZE_ALL_SUBNETS; import java.util.ArrayList; import java.util.List; @@ -23,15 +28,17 @@ import picocli.CommandLine.Mixin; import picocli.CommandLine.Option; import tech.pegasys.teku.beacon.sync.SyncConfig; +import tech.pegasys.teku.cli.converter.OptionalIntConverter; import tech.pegasys.teku.config.TekuConfiguration; import tech.pegasys.teku.networking.eth2.P2PConfig; import tech.pegasys.teku.networking.p2p.discovery.DiscoveryConfig; +import tech.pegasys.teku.networking.p2p.gossip.config.GossipConfig; import tech.pegasys.teku.networking.p2p.libp2p.MultiaddrPeerAddress; import tech.pegasys.teku.networking.p2p.network.config.NetworkConfig; public class P2POptions { - @Mixin private NatOptions natOptions = new NatOptions(); + @Mixin private final NatOptions natOptions = new NatOptions(); @Option( names = {"--p2p-enabled"}, @@ -43,11 +50,15 @@ public class P2POptions { private boolean p2pEnabled = true; @Option( - names = {"--p2p-interface"}, + names = {"--p2p-interface", "--p2p-interfaces"}, paramLabel = "", - description = "P2P network interface", - arity = "1") - private String p2pInterface = NetworkConfig.DEFAULT_P2P_INTERFACE; + description = + """ + The network interface(s) on which the node listens for P2P communication. + You can define up to 2 interfaces, with one being IPv4 and the other IPv6. (Default: 0.0.0.0)""", + split = ",", + arity = "1..2") + private List p2pInterfaces = NetworkConfig.DEFAULT_P2P_INTERFACE; @Option( names = {"--p2p-port"}, @@ -56,6 +67,13 @@ public class P2POptions { arity = "1") private int p2pPort = NetworkConfig.DEFAULT_P2P_PORT; + @Option( + names = {"--p2p-port-ipv6"}, + paramLabel = "", + description = "P2P IPv6 port. This port is only used when listening over both IPv4 and IPv6.", + arity = "1") + private int p2pPortIpv6 = NetworkConfig.DEFAULT_P2P_PORT_IPV6; + @Option( names = {"--p2p-udp-port"}, paramLabel = "", @@ -63,6 +81,14 @@ public class P2POptions { arity = "1") private Integer p2pUdpPort; + @Option( + names = {"--p2p-udp-port-ipv6"}, + paramLabel = "", + description = + "IPv6 UDP port used for discovery. This port is only used when listening over both IPv4 and IPv6. The default is the port specified in --p2p-port-ipv6", + arity = "1") + private Integer p2pUdpPortIpv6; + @Option( names = {"--p2p-discovery-enabled"}, paramLabel = "", @@ -81,11 +107,13 @@ public class P2POptions { private List p2pDiscoveryBootnodes = null; @Option( - names = {"--p2p-advertised-ip"}, + names = {"--p2p-advertised-ip", "--p2p-advertised-ips"}, paramLabel = "", - description = "P2P advertised IP (Default: 127.0.0.1)", - arity = "1") - private String p2pAdvertisedIp; + description = + "P2P advertised IP address(es). You can define up to 2 addresses, with one being IPv4 and the other IPv6. (Default: 127.0.0.1)", + split = ",", + arity = "1..2") + private List p2pAdvertisedIps; @Option( names = {"--p2p-advertised-port"}, @@ -94,6 +122,16 @@ public class P2POptions { arity = "1") private Integer p2pAdvertisedPort; + @Option( + names = {"--p2p-advertised-port-ipv6"}, + paramLabel = "", + description = + """ + P2P advertised IPv6 port. This port is only used when advertising both IPv4 and IPv6 addresses. + The default is the port specified in --p2p-port-ipv6.""", + arity = "1") + private Integer p2pAdvertisedPortIpv6; + @Option( names = {"--p2p-advertised-udp-port"}, paramLabel = "", @@ -102,6 +140,16 @@ public class P2POptions { arity = "1") private Integer p2pAdvertisedUdpPort; + @Option( + names = {"--p2p-advertised-udp-port-ipv6"}, + paramLabel = "", + description = + """ + Advertised IPv6 UDP port to external peers. This port is only used when advertising both IPv4 and IPv6 addresses. + The default is the port specified in --p2p-advertised-port-ipv6.""", + arity = "1") + private Integer p2pAdvertisedUdpPortIpv6; + @Option( names = {"--p2p-private-key-file"}, paramLabel = "", @@ -114,15 +162,17 @@ public class P2POptions { names = {"--p2p-peer-lower-bound"}, paramLabel = "", description = "Lower bound on the target number of peers", + converter = OptionalIntConverter.class, arity = "1") - private int p2pLowerBound = DiscoveryConfig.DEFAULT_P2P_PEERS_LOWER_BOUND; + private OptionalInt p2pLowerBound = OptionalInt.empty(); @Option( names = {"--p2p-peer-upper-bound"}, paramLabel = "", description = "Upper bound on the target number of peers", + converter = OptionalIntConverter.class, arity = "1") - private int p2pUpperBound = DiscoveryConfig.DEFAULT_P2P_PEERS_UPPER_BOUND; + private OptionalInt p2pUpperBound = OptionalInt.empty(); @Option( names = {"--Xp2p-target-subnet-subscriber-count"}, @@ -251,6 +301,17 @@ public class P2POptions { hidden = true) private Integer peerRateLimit = P2PConfig.DEFAULT_PEER_RATE_LIMIT; + @Option( + names = {"--Xp2p-gossip-blobs-after-block-enabled"}, + paramLabel = "", + showDefaultValue = Visibility.ALWAYS, + description = + "Enables experimental behaviour in which blobs are gossiped after the block has been gossiped to at least one peer.", + hidden = true, + arity = "0..1", + fallbackValue = "true") + private boolean gossipBlobsAfterBlockEnabled = P2PConfig.DEFAULT_GOSSIP_BLOBS_AFTER_BLOCK_ENABLED; + @Option( names = {"--Xpeer-all-topics-filter-enabled"}, paramLabel = "", @@ -283,8 +344,9 @@ public class P2POptions { paramLabel = "", description = "Maximum queue size for pending aggregated signature verification", arity = "1", + converter = OptionalIntConverter.class, hidden = true) - private int batchVerifyQueueCapacity = P2PConfig.DEFAULT_BATCH_VERIFY_QUEUE_CAPACITY; + private OptionalInt batchVerifyQueueCapacity = OptionalInt.empty(); @Option( names = {"--Xp2p-batch-verify-signatures-max-batch-size"}, @@ -326,6 +388,19 @@ public class P2POptions { fallbackValue = "true") private boolean yamuxEnabled = NetworkConfig.DEFAULT_YAMUX_ENABLED; + // More about flood publishing + // https://github.com/libp2p/specs/blob/master/pubsub/gossipsub/gossipsub-v1.1.md#flood-publishing + @Option( + names = {"--Xp2p-flood-max-message-size-threshold"}, + paramLabel = "", + showDefaultValue = Visibility.ALWAYS, + description = "Maximum size (in bytes) of a message that will be flood published", + arity = "0..1", + hidden = true, + fallbackValue = "true") + private int floodPublishMaxMessageSizeThreshold = + GossipConfig.DEFAULT_FLOOD_PUBLISH_MAX_MESSAGE_SIZE_THRESHOLD; + @Option( names = {"--Xdas-extra-custody-subnet-count"}, paramLabel = "", @@ -345,22 +420,18 @@ public class P2POptions { fallbackValue = "true") private boolean dasLossySamplerEnabled = P2PConfig.DEFAULT_DAS_LOSSY_SAMPLER_ENABLED; - private int getP2pLowerBound() { - if (p2pLowerBound > p2pUpperBound) { - STATUS_LOG.adjustingP2pLowerBoundToUpperBound(p2pUpperBound); - return p2pUpperBound; - } else { - return p2pLowerBound; + private OptionalInt getP2pLowerBound() { + if (p2pUpperBound.isPresent() && p2pLowerBound.isPresent()) { + return p2pLowerBound.getAsInt() < p2pUpperBound.getAsInt() ? p2pLowerBound : p2pUpperBound; } + return p2pLowerBound; } - private int getP2pUpperBound() { - if (p2pUpperBound < p2pLowerBound) { - STATUS_LOG.adjustingP2pUpperBoundToLowerBound(p2pLowerBound); - return p2pLowerBound; - } else { - return p2pUpperBound; + private OptionalInt getP2pUpperBound() { + if (p2pUpperBound.isPresent() && p2pLowerBound.isPresent()) { + return p2pLowerBound.getAsInt() > p2pUpperBound.getAsInt() ? p2pLowerBound : p2pUpperBound; } + return p2pUpperBound; } public void configure(final TekuConfiguration.Builder builder) { @@ -369,20 +440,23 @@ public void configure(final TekuConfiguration.Builder builder) { builder .p2p( - b -> - b.subscribeAllSubnetsEnabled(subscribeAllSubnetsEnabled) - .subscribeAllCustodySubnetsEnabled(subscribeAllCustodySubnetsEnabled) - .batchVerifyMaxThreads(batchVerifyMaxThreads) - .batchVerifyQueueCapacity(batchVerifyQueueCapacity) - .batchVerifyMaxBatchSize(batchVerifyMaxBatchSize) - .batchVerifyStrictThreadLimitEnabled(batchVerifyStrictThreadLimitEnabled) - .targetSubnetSubscriberCount(p2pTargetSubnetSubscriberCount) - .isGossipScoringEnabled(gossipScoringEnabled) - .peerRateLimit(peerRateLimit) - .allTopicsFilterEnabled(allTopicsFilterEnabled) - .peerRequestLimit(peerRequestLimit) - .dasExtraCustodySubnetCount(dasExtraCustodySubnetCount) - .dasLossySamplerEnabled(dasLossySamplerEnabled)) + b -> { + b.subscribeAllSubnetsEnabled(subscribeAllSubnetsEnabled) + .subscribeAllCustodySubnetsEnabled(subscribeAllCustodySubnetsEnabled) + .batchVerifyMaxThreads(batchVerifyMaxThreads) + .batchVerifyMaxBatchSize(batchVerifyMaxBatchSize) + .batchVerifyStrictThreadLimitEnabled(batchVerifyStrictThreadLimitEnabled) + .targetSubnetSubscriberCount(p2pTargetSubnetSubscriberCount) + .isGossipScoringEnabled(gossipScoringEnabled) + .peerRateLimit(peerRateLimit) + .allTopicsFilterEnabled(allTopicsFilterEnabled) + .peerRequestLimit(peerRequestLimit) + .floodPublishMaxMessageSizeThreshold(floodPublishMaxMessageSizeThreshold) + .gossipBlobsAfterBlockEnabled(gossipBlobsAfterBlockEnabled) + .dasExtraCustodySubnetCount(dasExtraCustodySubnetCount) + .dasLossySamplerEnabled(dasLossySamplerEnabled); + batchVerifyQueueCapacity.ifPresent(b::batchVerifyQueueCapacity); + }) .discovery( d -> { if (p2pDiscoveryBootnodes != null) { @@ -394,13 +468,29 @@ public void configure(final TekuConfiguration.Builder builder) { if (p2pUdpPort != null) { d.listenUdpPort(p2pUdpPort); } + if (p2pUdpPortIpv6 != null) { + d.listenUdpPortIpv6(p2pUdpPortIpv6); + } if (p2pAdvertisedUdpPort != null) { d.advertisedUdpPort(OptionalInt.of(p2pAdvertisedUdpPort)); } + final OptionalInt maybeUpperBound = getP2pUpperBound(); + final OptionalInt maybeLowerBound = getP2pLowerBound(); + d.minPeers( + maybeLowerBound.orElse( + subscribeAllSubnetsEnabled + ? DEFAULT_P2P_PEERS_LOWER_BOUND_ALL_SUBNETS + : DEFAULT_P2P_PEERS_LOWER_BOUND)); + d.maxPeers( + maybeUpperBound.orElse( + subscribeAllSubnetsEnabled + ? DEFAULT_P2P_PEERS_UPPER_BOUND_ALL_SUBNETS + : DEFAULT_P2P_PEERS_UPPER_BOUND)); + if (p2pAdvertisedUdpPortIpv6 != null) { + d.advertisedUdpPortIpv6(OptionalInt.of(p2pAdvertisedPortIpv6)); + } d.isDiscoveryEnabled(p2pDiscoveryEnabled) .staticPeers(p2pStaticPeers) - .minPeers(getP2pLowerBound()) - .maxPeers(getP2pUpperBound()) .siteLocalAddressesEnabled(siteLocalAddressesEnabled); }) .network( @@ -411,6 +501,9 @@ public void configure(final TekuConfiguration.Builder builder) { if (p2pAdvertisedPort != null) { n.advertisedPort(OptionalInt.of(p2pAdvertisedPort)); } + if (p2pAdvertisedPortIpv6 != null) { + n.advertisedPortIpv6(OptionalInt.of(p2pAdvertisedPortIpv6)); + } if (!p2pDirectPeers.isEmpty()) { n.directPeers( p2pDirectPeers.stream() @@ -418,10 +511,11 @@ public void configure(final TekuConfiguration.Builder builder) { .map(MultiaddrPeerAddress::getId) .toList()); } - n.networkInterface(p2pInterface) + n.networkInterfaces(p2pInterfaces) .isEnabled(p2pEnabled) .listenPort(p2pPort) - .advertisedIp(Optional.ofNullable(p2pAdvertisedIp)) + .listenPortIpv6(p2pPortIpv6) + .advertisedIps(Optional.ofNullable(p2pAdvertisedIps)) .yamuxEnabled(yamuxEnabled); }) .sync( @@ -431,6 +525,17 @@ public void configure(final TekuConfiguration.Builder builder) { .forwardSyncMaxBlocksPerMinute(forwardSyncRateLimit) .forwardSyncBatchSize(forwardSyncBatchSize) .forwardSyncMaxPendingBatches(forwardSyncMaxPendingBatches)); + + if (subscribeAllSubnetsEnabled) { + builder + .validator( + v -> v.executorMaxQueueSizeIfDefault(DEFAULT_EXECUTOR_MAX_QUEUE_SIZE_ALL_SUBNETS)) + .eth2NetworkConfig( + eth -> + eth.asyncP2pMaxQueueIfDefault(DEFAULT_MAX_QUEUE_SIZE_ALL_SUBNETS) + .asyncBeaconChainMaxQueueIfDefault(DEFAULT_MAX_QUEUE_SIZE_ALL_SUBNETS)) + .p2p(p2p -> p2p.batchVerifyQueueCapacityIfDefault(DEFAULT_MAX_QUEUE_SIZE_ALL_SUBNETS)); + } natOptions.configure(builder); } } diff --git a/teku/src/main/java/tech/pegasys/teku/cli/options/ValidatorClientOptions.java b/teku/src/main/java/tech/pegasys/teku/cli/options/ValidatorClientOptions.java index 67ef75abbc3..f96f77a1b4a 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/options/ValidatorClientOptions.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/options/ValidatorClientOptions.java @@ -27,7 +27,7 @@ public class ValidatorClientOptions { @ArgGroup(multiplicity = "0..1") - private ExclusiveParams exclusiveParams = new ExclusiveParams(); + private final ExclusiveParams exclusiveParams = new ExclusiveParams(); @Option( names = {"--Xfailovers-send-subnet-subscriptions-enabled"}, @@ -86,7 +86,18 @@ public class ValidatorClientOptions { private boolean obolDvtSelectionsEndpointEnabled = ValidatorConfig.DEFAULT_OBOL_DVT_SELECTIONS_ENDPOINT_ENABLED; - public void configure(TekuConfiguration.Builder builder) { + @Option( + names = {"--Xattestations-v2-apis-enabled"}, + paramLabel = "", + description = + "Enable the attestations V2 APIs (attestations/attester slashings pools and attestations aggregation)", + hidden = true, + showDefaultValue = CommandLine.Help.Visibility.ALWAYS, + arity = "0..1", + fallbackValue = "true") + private boolean attestationsV2ApisEnabled = ValidatorConfig.DEFAULT_ATTESTATIONS_V2_APIS_ENABLED; + + public void configure(final TekuConfiguration.Builder builder) { configureBeaconNodeApiEndpoints(); builder.validator( @@ -99,7 +110,8 @@ public void configure(TekuConfiguration.Builder builder) { .failoversSendSubnetSubscriptionsEnabled(failoversSendSubnetSubscriptionsEnabled) .failoversPublishSignedDutiesEnabled(failoversPublishSignedDutiesEnabled) .sentryNodeConfigurationFile(exclusiveParams.sentryConfigFile) - .obolDvtSelectionsEndpointEnabled(obolDvtSelectionsEndpointEnabled)); + .obolDvtSelectionsEndpointEnabled(obolDvtSelectionsEndpointEnabled) + .attestationsV2ApisEnabled(attestationsV2ApisEnabled)); } private void configureBeaconNodeApiEndpoints() { diff --git a/teku/src/main/java/tech/pegasys/teku/cli/options/ValidatorKeysOptions.java b/teku/src/main/java/tech/pegasys/teku/cli/options/ValidatorKeysOptions.java index e11b478d1fc..191e99afcbc 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/options/ValidatorKeysOptions.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/options/ValidatorKeysOptions.java @@ -104,7 +104,7 @@ public class ValidatorKeysOptions { private int validatorExternalSignerConcurrentRequestLimit = ValidatorConfig.DEFAULT_VALIDATOR_EXTERNAL_SIGNER_CONCURRENT_REQUEST_LIMIT; - public void configure(TekuConfiguration.Builder builder) { + public void configure(final TekuConfiguration.Builder builder) { builder.validator( config -> config diff --git a/teku/src/main/java/tech/pegasys/teku/cli/options/ValidatorOptions.java b/teku/src/main/java/tech/pegasys/teku/cli/options/ValidatorOptions.java index f0788cbe715..7fa276d1996 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/options/ValidatorOptions.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/options/ValidatorOptions.java @@ -20,12 +20,14 @@ import java.nio.file.Path; import java.util.Optional; +import java.util.OptionalInt; import org.apache.tuweni.bytes.Bytes32; import picocli.CommandLine; import picocli.CommandLine.Help.Visibility; import picocli.CommandLine.Mixin; import picocli.CommandLine.Option; import tech.pegasys.teku.cli.converter.GraffitiConverter; +import tech.pegasys.teku.cli.converter.OptionalIntConverter; import tech.pegasys.teku.config.TekuConfiguration; import tech.pegasys.teku.validator.api.ClientGraffitiAppendFormat; import tech.pegasys.teku.validator.api.FileBackedGraffitiProvider; @@ -34,9 +36,10 @@ public class ValidatorOptions { - @Mixin private ValidatorKeysOptions validatorKeysOptions = new ValidatorKeysOptions(); + @Mixin private final ValidatorKeysOptions validatorKeysOptions = new ValidatorKeysOptions(); - @Mixin private ValidatorProposerOptions validatorProposerOptions = new ValidatorProposerOptions(); + @Mixin + private final ValidatorProposerOptions validatorProposerOptions = new ValidatorProposerOptions(); @Option( names = {"--validators-graffiti"}, @@ -113,8 +116,9 @@ public class ValidatorOptions { showDefaultValue = Visibility.ALWAYS, description = "Set the maximum queue size of the validator executor", hidden = true, + converter = OptionalIntConverter.class, arity = "1") - private int executorMaxQueueSize = ValidatorConfig.DEFAULT_EXECUTOR_MAX_QUEUE_SIZE; + private OptionalInt executorMaxQueueSize = OptionalInt.empty(); @Option( names = {"--doppelganger-detection-enabled"}, @@ -134,16 +138,6 @@ public class ValidatorOptions { arity = "1") private int executorThreads = DEFAULT_VALIDATOR_EXECUTOR_THREADS; - @Option( - names = {"--Xblock-v3-enabled"}, - paramLabel = "", - description = "Enable the Block V3 API for block production", - hidden = true, - showDefaultValue = CommandLine.Help.Visibility.ALWAYS, - arity = "0..1", - fallbackValue = "true") - private boolean blockV3Enabled = ValidatorConfig.DEFAULT_BLOCK_V3_ENABLED; - @Option( names = {"--exit-when-no-validator-keys-enabled"}, paramLabel = "", @@ -174,27 +168,27 @@ public class ValidatorOptions { fallbackValue = "true") private boolean shutdownWhenValidatorSlashed = DEFAULT_SHUTDOWN_WHEN_VALIDATOR_SLASHED_ENABLED; - public void configure(TekuConfiguration.Builder builder) { + public void configure(final TekuConfiguration.Builder builder) { builder.validator( - config -> - config - .validatorKeystoreLockingEnabled(validatorKeystoreLockingEnabled) - .validatorPerformanceTrackingMode(validatorPerformanceTrackingMode) - .validatorExternalSignerSlashingProtectionEnabled( - validatorExternalSignerSlashingProtectionEnabled) - .isLocalSlashingProtectionSynchronizedModeEnabled( - isLocalSlashingProtectionSynchronizedEnabled) - .graffitiProvider( - new FileBackedGraffitiProvider( - Optional.ofNullable(graffiti), Optional.ofNullable(graffitiFile))) - .clientGraffitiAppendFormat(clientGraffitiAppendFormat) - .generateEarlyAttestations(generateEarlyAttestations) - .executorMaxQueueSize(executorMaxQueueSize) - .doppelgangerDetectionEnabled(doppelgangerDetectionEnabled) - .executorThreads(executorThreads) - .blockV3enabled(blockV3Enabled) - .exitWhenNoValidatorKeysEnabled(exitWhenNoValidatorKeysEnabled) - .shutdownWhenValidatorSlashedEnabled(shutdownWhenValidatorSlashed)); + config -> { + config + .validatorKeystoreLockingEnabled(validatorKeystoreLockingEnabled) + .validatorPerformanceTrackingMode(validatorPerformanceTrackingMode) + .validatorExternalSignerSlashingProtectionEnabled( + validatorExternalSignerSlashingProtectionEnabled) + .isLocalSlashingProtectionSynchronizedModeEnabled( + isLocalSlashingProtectionSynchronizedEnabled) + .graffitiProvider( + new FileBackedGraffitiProvider( + Optional.ofNullable(graffiti), Optional.ofNullable(graffitiFile))) + .clientGraffitiAppendFormat(clientGraffitiAppendFormat) + .generateEarlyAttestations(generateEarlyAttestations) + .doppelgangerDetectionEnabled(doppelgangerDetectionEnabled) + .executorThreads(executorThreads) + .exitWhenNoValidatorKeysEnabled(exitWhenNoValidatorKeysEnabled) + .shutdownWhenValidatorSlashedEnabled(shutdownWhenValidatorSlashed); + executorMaxQueueSize.ifPresent(config::executorMaxQueueSize); + }); validatorProposerOptions.configure(builder); validatorKeysOptions.configure(builder); } diff --git a/teku/src/main/java/tech/pegasys/teku/cli/options/ValidatorProposerOptions.java b/teku/src/main/java/tech/pegasys/teku/cli/options/ValidatorProposerOptions.java index 5aa50a64c87..ddfa860b4df 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/options/ValidatorProposerOptions.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/options/ValidatorProposerOptions.java @@ -111,7 +111,7 @@ public class ValidatorProposerOptions { arity = "0..1") private boolean blindedBlocksEnabled = DEFAULT_VALIDATOR_BLINDED_BLOCKS_ENABLED; - public void configure(TekuConfiguration.Builder builder) { + public void configure(final TekuConfiguration.Builder builder) { builder.validator( config -> config diff --git a/teku/src/main/java/tech/pegasys/teku/cli/options/WeakSubjectivityOptions.java b/teku/src/main/java/tech/pegasys/teku/cli/options/WeakSubjectivityOptions.java index d98ed49ccd3..6c28e57f4e9 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/options/WeakSubjectivityOptions.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/options/WeakSubjectivityOptions.java @@ -44,7 +44,7 @@ public class WeakSubjectivityOptions { hidden = true) private UInt64 suppressWSPeriodChecksUntilEpoch = null; - public TekuConfiguration.Builder configure(TekuConfiguration.Builder builder) { + public TekuConfiguration.Builder configure(final TekuConfiguration.Builder builder) { return builder.weakSubjectivity( wsBuilder -> { getWeakSubjectivityCheckpoint().ifPresent(wsBuilder::weakSubjectivityCheckpoint); diff --git a/teku/src/main/java/tech/pegasys/teku/cli/slashingprotection/RepairCommand.java b/teku/src/main/java/tech/pegasys/teku/cli/slashingprotection/RepairCommand.java index 806e88dee87..e784e9768f0 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/slashingprotection/RepairCommand.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/slashingprotection/RepairCommand.java @@ -13,6 +13,8 @@ package tech.pegasys.teku.cli.slashingprotection; +import static tech.pegasys.teku.infrastructure.time.SystemTimeProvider.SYSTEM_TIME_PROVIDER; + import java.nio.charset.Charset; import java.nio.file.Path; import java.util.Optional; @@ -25,7 +27,6 @@ import tech.pegasys.teku.cli.util.SlashingProtectionCommandUtils; import tech.pegasys.teku.data.SlashingProtectionRepairer; import tech.pegasys.teku.infrastructure.logging.SubCommandLogger; -import tech.pegasys.teku.infrastructure.time.SystemTimeProvider; import tech.pegasys.teku.infrastructure.time.TimeProvider; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.networks.Eth2NetworkConfiguration; @@ -115,7 +116,7 @@ public void run() { } private UInt64 getComputedSlot(final Optional initialAnchor, final Spec spec) { - final TimeProvider timeProvider = new SystemTimeProvider(); + final TimeProvider timeProvider = SYSTEM_TIME_PROVIDER; if (suppliedSlot != null) { displaySlotUpdateMessage(suppliedSlot, spec, "WARNING: using a supplied slot"); diff --git a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/GenesisCommand.java b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/GenesisCommand.java index 603baa45ab9..1b078a5efa2 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/GenesisCommand.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/GenesisCommand.java @@ -54,7 +54,8 @@ public class GenesisCommand { footerHeading = "%n", footer = "Teku is licensed under the Apache License 2.0") public void generate( - @Mixin MockGenesisParams genesisParams, @Mixin MinimalEth2NetworkOptions networkOptions) + @Mixin final MockGenesisParams genesisParams, + @Mixin final MinimalEth2NetworkOptions networkOptions) throws IOException { // Output to stdout if no file is specified final Spec spec = networkOptions.getSpec(); diff --git a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/PeerCommand.java b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/PeerCommand.java index d949a393164..61131d8ba75 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/PeerCommand.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/PeerCommand.java @@ -72,13 +72,13 @@ public class PeerCommand { footerHeading = "%n", footer = "Teku is licensed under the Apache License 2.0") public void generate( - @Mixin PeerGenerationParams params, + @Mixin final PeerGenerationParams params, @Option( names = {"-n", "--number"}, arity = "1", required = true, description = "number of peerIDs to generate") - int number) { + final int number) { try { validateParamsAndGenerate(params.outputFile, number); spec.commandLine().getOut().println("Generated file " + params.outputFile); @@ -87,7 +87,7 @@ public void generate( } } - void validateParamsAndGenerate(String outputFile, int number) throws IOException { + void validateParamsAndGenerate(final String outputFile, final int number) throws IOException { try { File f = new File(outputFile); if (f.exists()) { diff --git a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/RemoteSpecLoader.java b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/RemoteSpecLoader.java index 81548cc3acd..8eb468379f9 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/RemoteSpecLoader.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/RemoteSpecLoader.java @@ -26,7 +26,6 @@ import tech.pegasys.teku.spec.config.SpecConfigLoader; import tech.pegasys.teku.storage.server.ShuttingDownException; import tech.pegasys.teku.validator.remote.apiclient.OkHttpClientAuth; -import tech.pegasys.teku.validator.remote.apiclient.OkHttpValidatorRestApiClient; import tech.pegasys.teku.validator.remote.typedef.OkHttpValidatorMinimalTypeDefClient; class RemoteSpecLoader { @@ -54,14 +53,15 @@ static Spec getSpec(final OkHttpValidatorMinimalTypeDefClient apiClient) { } catch (final Throwable ex) { final String errMsg = String.format( - "Failed to retrieve network spec from beacon node endpoint '%s'.\nDetails: %s", + "Failed to retrieve network spec from beacon node endpoint '%s'.\nDetails: %s." + + "\nEnsure local and remote software versions are up-to-date.", apiClient.getBaseEndpoint(), ex.getMessage()); throw new InvalidConfigurationException(errMsg, ex); } } - static OkHttpValidatorRestApiClient createApiClient(final URI endpoint) { - return createApiClients(List.of(endpoint)).get(0); + static OkHttpValidatorMinimalTypeDefClient createTypeDefClient(final URI endpoint) { + return createTypeDefClients(List.of(endpoint)).get(0); } private static Spec getSpecWithFailovers( @@ -100,24 +100,6 @@ private static void logError(final Throwable ex) { SubCommandLogger.SUB_COMMAND_LOG.error(ex.getMessage()); } - private static List createApiClients( - final List baseEndpoints) { - final OkHttpClient.Builder httpClientBuilder = - new OkHttpClient.Builder().readTimeout(30, TimeUnit.SECONDS); - List apiEndpoints = baseEndpoints.stream().map(HttpUrl::get).toList(); - if (apiEndpoints.size() > 1) { - OkHttpClientAuth.addAuthInterceptorForMultipleEndpoints(apiEndpoints, httpClientBuilder); - } else { - OkHttpClientAuth.addAuthInterceptor(apiEndpoints.get(0), httpClientBuilder); - } - // Strip any authentication info from the URL(s) to ensure it doesn't get logged. - apiEndpoints = stripAuthentication(apiEndpoints); - final OkHttpClient okHttpClient = httpClientBuilder.build(); - return apiEndpoints.stream() - .map(apiEndpoint -> new OkHttpValidatorRestApiClient(apiEndpoint, okHttpClient)) - .toList(); - } - private static List createTypeDefClients( final List baseEndpoints) { final OkHttpClient.Builder httpClientBuilder = @@ -132,7 +114,7 @@ private static List createTypeDefClients( apiEndpoints = stripAuthentication(apiEndpoints); final OkHttpClient okHttpClient = httpClientBuilder.build(); return apiEndpoints.stream() - .map(apiEndpoint -> new OkHttpValidatorMinimalTypeDefClient(okHttpClient, apiEndpoint)) + .map(apiEndpoint -> new OkHttpValidatorMinimalTypeDefClient(apiEndpoint, okHttpClient)) .toList(); } diff --git a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/TransitionCommand.java b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/TransitionCommand.java index 8d38b6c8616..2ceb4ac3bbd 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/TransitionCommand.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/TransitionCommand.java @@ -76,9 +76,9 @@ public class TransitionCommand implements Runnable { footerHeading = "%n", footer = "Teku is licensed under the Apache License 2.0") public int blocks( - @Mixin InAndOutParams params, + @Mixin final InAndOutParams params, @Parameters(paramLabel = "block", description = "Files to read blocks from (ssz or hex)") - List blockPaths) { + final List blockPaths) { return processStateTransition( params, (spec, state) -> { @@ -110,15 +110,15 @@ public int blocks( footerHeading = "%n", footer = "Teku is licensed under the Apache License 2.0") public int slots( - @Mixin InAndOutParams params, + @Mixin final InAndOutParams params, @Option( names = {"--delta", "-d"}, showDefaultValue = Visibility.ALWAYS, fallbackValue = "true", description = "to interpret the slot number as a delta from the pre-state") - boolean delta, + final boolean delta, @Parameters(paramLabel = "", description = "Number of slots to process") - long number) { + final long number) { return processStateTransition( params, (specProvider, state) -> { @@ -200,7 +200,7 @@ private SignedBeaconBlock deserializeSignedBeaconBlockFromHex( final Spec spec, final String path, final byte[] hexBlockData, - RuntimeException sszSerializationException) { + final RuntimeException sszSerializationException) { try { final Bytes blockData = Bytes.wrap(Hex.decode(hexBlockData)); return spec.deserializeSignedBeaconBlock(blockData); diff --git a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/ValidatorClientCommand.java b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/ValidatorClientCommand.java index b59f067741e..94bac7225f6 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/ValidatorClientCommand.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/ValidatorClientCommand.java @@ -35,6 +35,7 @@ import tech.pegasys.teku.infrastructure.logging.LoggingConfig; import tech.pegasys.teku.infrastructure.logging.LoggingConfigurator; import tech.pegasys.teku.networks.Eth2NetworkConfiguration; +import tech.pegasys.teku.validator.api.ValidatorConfig; @Command( name = "validator-client", @@ -95,6 +96,7 @@ public Integer call() { try { startLogging(); final TekuConfiguration globalConfiguration = tekuConfiguration(); + checkValidatorKeysConfig(globalConfiguration); parentCommand.getStartAction().start(globalConfiguration, true); return 0; } catch (final Throwable t) { @@ -119,11 +121,11 @@ private void configureWithSpecFromBeaconNode(final Eth2NetworkConfiguration.Buil } } - private boolean isAutoDetectNetworkOption(String option) { + private boolean isAutoDetectNetworkOption(final String option) { return AUTO_NETWORK_OPTION.equalsIgnoreCase(option); } - private void configureEth2Network(TekuConfiguration.Builder builder) { + private void configureEth2Network(final TekuConfiguration.Builder builder) { if (parentCommand.isOptionSpecified("--network")) { throw new InvalidConfigurationException( "--network option should not be specified before the validator-client command"); @@ -136,6 +138,25 @@ private void configureEth2Network(TekuConfiguration.Builder builder) { } } + private static void checkValidatorKeysConfig(final TekuConfiguration globalConfiguration) { + if (!globalConfiguration.validatorClient().getInteropConfig().isInteropEnabled()) { + final ValidatorConfig validatorConfig = + globalConfiguration.validatorClient().getValidatorConfig(); + final boolean localValidatorKeysProvided = + validatorConfig.getValidatorKeys() != null + && !validatorConfig.getValidatorKeys().isEmpty(); + final boolean validatorRestApiEnabled = + globalConfiguration.validatorRestApiConfig().isRestApiEnabled(); + final boolean externalSignerUrlProvided = + validatorConfig.getValidatorExternalSignerUrl() != null; + if (!localValidatorKeysProvided && !validatorRestApiEnabled && !externalSignerUrlProvided) { + throw new InvalidConfigurationException( + "No validator keys source provided, should provide local or remote keys otherwise enable the key-manager" + + " api to start the validator client"); + } + } + } + public TekuConfiguration tekuConfiguration() { final TekuConfiguration.Builder builder = TekuConfiguration.builder(); configureEth2Network(builder); diff --git a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/VoluntaryExitCommand.java b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/VoluntaryExitCommand.java index 1f5db3b36ec..97774bd18b5 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/VoluntaryExitCommand.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/VoluntaryExitCommand.java @@ -36,13 +36,10 @@ import java.util.function.Supplier; import java.util.stream.Collectors; import org.apache.tuweni.bytes.Bytes32; -import org.apache.tuweni.bytes.Bytes48; import org.hyperledger.besu.metrics.noop.NoOpMetricsSystem; import org.hyperledger.besu.plugin.services.MetricsSystem; import picocli.CommandLine; import picocli.CommandLine.Help.Visibility; -import tech.pegasys.teku.api.response.v1.beacon.PostDataFailureResponse; -import tech.pegasys.teku.api.schema.SignedVoluntaryExit; import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.cli.converter.PicoCliVersionProvider; @@ -57,13 +54,18 @@ import tech.pegasys.teku.infrastructure.exceptions.ExceptionUtil; import tech.pegasys.teku.infrastructure.exceptions.InvalidConfigurationException; import tech.pegasys.teku.infrastructure.json.JsonUtil; +import tech.pegasys.teku.infrastructure.json.exceptions.BadRequestException; import tech.pegasys.teku.infrastructure.logging.SubCommandLogger; import tech.pegasys.teku.infrastructure.logging.ValidatorLogger; +import tech.pegasys.teku.infrastructure.time.SystemTimeProvider; +import tech.pegasys.teku.infrastructure.time.TimeProvider; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.service.serviceutils.layout.DataDirLayout; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecFactory; import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.datastructures.genesis.GenesisData; +import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; import tech.pegasys.teku.spec.datastructures.operations.VoluntaryExit; import tech.pegasys.teku.spec.datastructures.state.Fork; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; @@ -74,7 +76,7 @@ import tech.pegasys.teku.validator.client.loader.PublicKeyLoader; import tech.pegasys.teku.validator.client.loader.SlashingProtectionLogger; import tech.pegasys.teku.validator.client.loader.ValidatorLoader; -import tech.pegasys.teku.validator.remote.apiclient.OkHttpValidatorRestApiClient; +import tech.pegasys.teku.validator.remote.typedef.OkHttpValidatorMinimalTypeDefClient; @CommandLine.Command( name = "voluntary-exit", @@ -91,14 +93,14 @@ public class VoluntaryExitCommand implements Callable { public static final SubCommandLogger SUB_COMMAND_LOG = new SubCommandLogger(); - private static final int MAX_PUBLIC_KEY_BATCH_SIZE = 50; - private OkHttpValidatorRestApiClient apiClient; + private OkHttpValidatorMinimalTypeDefClient typeDefClient; private Fork fork; private Bytes32 genesisRoot; private Map validatorsMap; private TekuConfiguration config; private final MetricsSystem metricsSystem = new NoOpMetricsSystem(); private Spec spec; + private final TimeProvider timeProvider = new SystemTimeProvider(); static final String WITHDRAWALS_PERMANENT_MESASGE = "These validators won't be able to be re-activated once this operation is complete."; @@ -262,51 +264,38 @@ private Object2IntMap getValidatorIndices( final Object2IntMap validatorIndices = new Object2IntOpenHashMap<>(); final List publicKeys = validatorsMap.keySet().stream().map(BLSPublicKey::toString).toList(); - for (int i = 0; i < publicKeys.size(); i += MAX_PUBLIC_KEY_BATCH_SIZE) { - final List batch = - publicKeys.subList(i, Math.min(publicKeys.size(), i + MAX_PUBLIC_KEY_BATCH_SIZE)); - apiClient - .getValidators(batch) - .ifPresent( - validatorResponses -> - validatorResponses.forEach( - response -> - validatorIndices.put( - response.validator.pubkey.asBLSPublicKey(), - response.index.intValue()))); - - batch.forEach( - key -> { - if (!validatorIndices.containsKey( - BLSPublicKey.fromBytesCompressed(Bytes48.fromHexString(key)))) { - SUB_COMMAND_LOG.error("Validator not found: " + key); - } - }); - } + typeDefClient + .postStateValidators(publicKeys) + .ifPresent( + validatorList -> + validatorList.forEach( + validator -> + validatorIndices.put( + validator.getPublicKey(), validator.getIntegerIndex().intValue()))); + + publicKeys.forEach( + key -> { + if (!validatorIndices.containsKey(BLSPublicKey.fromHexString(key))) { + SUB_COMMAND_LOG.error("Validator not found: " + key); + } + }); return validatorIndices; } private void submitExitForValidator(final BLSPublicKey publicKey, final int validatorIndex) { try { - final tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit exit = - generateSignedExit(publicKey, validatorIndex); - final Optional response = - apiClient.sendVoluntaryExit(new SignedVoluntaryExit(exit)); - if (response.isPresent()) { - SUB_COMMAND_LOG.error(response.get().message); - } else { - SUB_COMMAND_LOG.display( - "Exit for validator " + publicKey.toAbbreviatedString() + " submitted."); - } - - } catch (IllegalArgumentException ex) { + final SignedVoluntaryExit exit = generateSignedExit(publicKey, validatorIndex); + typeDefClient.sendVoluntaryExit(exit); + SUB_COMMAND_LOG.display( + "Exit for validator " + publicKey.toAbbreviatedString() + " submitted."); + } catch (BadRequestException ex) { SUB_COMMAND_LOG.error( "Failed to submit exit for validator " + publicKey.toAbbreviatedString()); SUB_COMMAND_LOG.error(ex.getMessage()); } } - private tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit generateSignedExit( + private SignedVoluntaryExit generateSignedExit( final BLSPublicKey publicKey, final int validatorIndex) { final ForkInfo forkInfo = new ForkInfo(fork, genesisRoot); final VoluntaryExit message = new VoluntaryExit(epoch, UInt64.valueOf(validatorIndex)); @@ -316,14 +305,12 @@ private tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit gen .getSigner() .signVoluntaryExit(message, forkInfo) .join(); - return new tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit( - message, signature); + return new SignedVoluntaryExit(message, signature); } private boolean storeExitForValidator( final BLSPublicKey blsPublicKey, final Integer validatorIndex) { - final tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit exit = - generateSignedExit(blsPublicKey, validatorIndex); + final SignedVoluntaryExit exit = generateSignedExit(blsPublicKey, validatorIndex); try { SUB_COMMAND_LOG.display("Writing signed exit for " + blsPublicKey.toAbbreviatedString()); Files.writeString( @@ -336,9 +323,7 @@ private boolean storeExitForValidator( } } - private String prettyExitMessage( - final tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit - signedVoluntaryExit) + private String prettyExitMessage(final SignedVoluntaryExit signedVoluntaryExit) throws JsonProcessingException { final PrettyPrintCommand.OutputFormat json = PrettyPrintCommand.OutputFormat.JSON; return JsonUtil.serialize( @@ -352,14 +337,12 @@ private String prettyExitMessage( }); } - private Optional getEpoch() { - return apiClient - .getBlockHeader("head") - .map(response -> spec.computeEpochAtSlot(response.data.header.message.slot)); - } - - private Optional getGenesisRoot() { - return apiClient.getGenesis().map(response -> response.getData().getGenesisValidatorsRoot()); + private UInt64 getEpochFromGenesisData(final GenesisData genesisData) { + final UInt64 genesisTime = genesisData.getGenesisTime(); + final UInt64 currentTime = timeProvider.getTimeInSeconds(); + final UInt64 slot = + spec.getGenesisSpec().miscHelpers().computeSlotAtTime(genesisTime, currentTime); + return spec.computeEpochAtSlot(slot); } private void initialise() { @@ -372,27 +355,29 @@ private void initialise() { AsyncRunnerFactory.createDefault(new MetricTrackingExecutorFactory(metricsSystem)); final AsyncRunner asyncRunner = asyncRunnerFactory.create("voluntary_exits", 8); - apiClient = + typeDefClient = config .validatorClient() .getValidatorConfig() .getPrimaryBeaconNodeApiEndpoint() - .map(RemoteSpecLoader::createApiClient) + .map(RemoteSpecLoader::createTypeDefClient) .orElseThrow(); if (network == null) { - SUB_COMMAND_LOG.display(" - Loading network settings from " + apiClient.getBaseEndpoint()); - spec = getSpec(List.of(apiClient.getBaseEndpoint())); + SUB_COMMAND_LOG.display( + " - Loading network settings from " + typeDefClient.getBaseEndpoint()); + spec = getSpec(typeDefClient); } else { SUB_COMMAND_LOG.display(" - Loading local settings for " + network + " network"); spec = SpecFactory.create(network); } - validateOrDefaultEpoch(); + final Optional maybeGenesisData = typeDefClient.getGenesis(); + validateOrDefaultEpoch(maybeGenesisData); fork = spec.getForkSchedule().getFork(epoch); // get genesis time - final Optional maybeRoot = getGenesisRoot(); + final Optional maybeRoot = maybeGenesisData.map(GenesisData::getGenesisValidatorsRoot); if (maybeRoot.isEmpty()) { throw new InvalidConfigurationException( "Unable to fetch genesis data, cannot generate an exit."); @@ -426,7 +411,8 @@ private void initialise() { externalSignerHttpClientFactory, validatorConfig.getValidatorExternalSignerUrl()), asyncRunner, metricsSystem, - dataDirLayout); + dataDirLayout, + (publicKey) -> Optional.empty()); validatorLoader.loadValidators(); final Map ownedValidators = @@ -449,13 +435,13 @@ private void initialise() { } } - private void validateOrDefaultEpoch() { - final Optional maybeEpoch = getEpoch(); + private void validateOrDefaultEpoch(final Optional maybeGenesisData) { + final Optional maybeEpoch = maybeGenesisData.map(this::getEpochFromGenesisData); if (epoch == null) { if (maybeEpoch.isEmpty()) { throw new InvalidConfigurationException( - "Could not calculate epoch from latest block header, please specify --epoch"); + "Could not calculate epoch from genesis data, please specify --epoch"); } epoch = maybeEpoch.orElseThrow(); } else if (maybeEpoch.isPresent() @@ -484,7 +470,7 @@ private TekuConfiguration tekuConfiguration() { private String getFailedToConnectMessage() { return String.format( - "Failed to connect to beacon node. Check that %s is available.", + "Failed to connect to beacon node. Check that %s is available and REST API is enabled.", config .validatorClient() .getValidatorConfig() diff --git a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/admin/WeakSubjectivityCommand.java b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/admin/WeakSubjectivityCommand.java index feb35863445..2623e890b89 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/admin/WeakSubjectivityCommand.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/admin/WeakSubjectivityCommand.java @@ -15,6 +15,7 @@ import static tech.pegasys.teku.infrastructure.logging.SubCommandLogger.SUB_COMMAND_LOG; +import java.util.Optional; import org.hyperledger.besu.metrics.noop.NoOpMetricsSystem; import picocli.CommandLine; import tech.pegasys.teku.cli.converter.PicoCliVersionProvider; @@ -115,7 +116,8 @@ private Database createDatabase( StorageConfiguration.builder() .eth1DepositContract(networkConfiguration.getEth1DepositContractAddress()) .specProvider(spec) - .build()); + .build(), + Optional.empty()); return databaseFactory.createDatabase(); } diff --git a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/debug/DebugDbCommand.java b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/debug/DebugDbCommand.java index 4dec9e32a9d..aa32be3ba42 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/debug/DebugDbCommand.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/debug/DebugDbCommand.java @@ -142,6 +142,49 @@ public int getFinalizedState( } } + @Command( + name = "get-earliest-available-block-slot", + description = "Get the earliest available block slot in the database", + mixinStandardHelpOptions = true, + showDefaultValues = true, + abbreviateSynopsis = true, + versionProvider = PicoCliVersionProvider.class, + synopsisHeading = "%n", + descriptionHeading = "%nDescription:%n%n", + optionListHeading = "%nOptions:%n", + footerHeading = "%n", + footer = "Teku is licensed under the Apache License 2.0") + public int getEarliestAvailableBlockSlot( + @Mixin final BeaconNodeDataOptions beaconNodeDataOptions, + @Mixin final Eth2NetworkOptions eth2NetworkOptions, + @Option( + names = {"--timed", "-t"}, + description = "Prints the time taken to retrieve the earliest available block slot", + defaultValue = "true", + fallbackValue = "true", + showDefaultValue = Visibility.ALWAYS) + final boolean verbose) + throws Exception { + try (final Database database = createDatabase(beaconNodeDataOptions, eth2NetworkOptions)) { + if (verbose) { + final long startTime = System.currentTimeMillis(); + final Optional earliestAvailableBlockSlot = + database.getEarliestAvailableBlockSlot(); + final long endTime = System.currentTimeMillis(); + earliestAvailableBlockSlot.ifPresent(System.out::println); + System.out.println( + "Time taken to retrieve the earliest available block slot: " + + (endTime - startTime) + + "ms"); + } else { + final Optional earliestAvailableBlockSlot = + database.getEarliestAvailableBlockSlot(); + earliestAvailableBlockSlot.ifPresent(System.out::println); + } + return 0; + } + } + @Command( name = "get-finalized-state-indices", description = "Display the slots of finalized states that are stored.", @@ -216,6 +259,7 @@ public int getLatestFinalizedState( .map( storeData -> StoreBuilder.create() + .asyncRunner(asyncRunner) .onDiskStoreData(storeData) .metricsSystem(new NoOpMetricsSystem()) .specProvider(eth2NetworkOptions.getNetworkConfiguration().getSpec()) @@ -837,7 +881,8 @@ private Database createDatabase( StorageConfiguration.builder() .eth1DepositContract(networkConfiguration.getEth1DepositContractAddress()) .specProvider(spec) - .build()); + .build(), + Optional.empty()); return databaseFactory.createDatabase(); } diff --git a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/debug/DebugToolsCommand.java b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/debug/DebugToolsCommand.java index bc13f304a32..20478f15dd0 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/debug/DebugToolsCommand.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/debug/DebugToolsCommand.java @@ -13,11 +13,17 @@ package tech.pegasys.teku.cli.subcommand.debug; +import static tech.pegasys.teku.infrastructure.time.SystemTimeProvider.SYSTEM_TIME_PROVIDER; + +import io.libp2p.core.PeerId; +import io.libp2p.core.crypto.KeyKt; +import io.libp2p.core.crypto.PrivKey; import java.io.FileWriter; import java.io.IOException; import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.Path; +import java.nio.file.Paths; import java.util.Optional; import org.apache.tuweni.bytes.Bytes; import org.hyperledger.besu.metrics.noop.NoOpMetricsSystem; @@ -33,7 +39,6 @@ import tech.pegasys.teku.infrastructure.async.MetricTrackingExecutorFactory; import tech.pegasys.teku.infrastructure.exceptions.InvalidConfigurationException; import tech.pegasys.teku.infrastructure.restapi.RestApi; -import tech.pegasys.teku.infrastructure.time.SystemTimeProvider; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.infrastructure.version.VersionProvider; import tech.pegasys.teku.service.serviceutils.layout.DataDirLayout; @@ -42,6 +47,7 @@ import tech.pegasys.teku.spec.datastructures.state.CommitteeAssignment; import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.validator.api.ValidatorApiChannel; +import tech.pegasys.teku.validator.api.noop.NoOpGraffitiManager; import tech.pegasys.teku.validator.beaconnode.GenesisDataProvider; import tech.pegasys.teku.validator.client.KeyManager; import tech.pegasys.teku.validator.client.NoOpKeyManager; @@ -146,7 +152,7 @@ public int generateSwaggerDocs( tempDir.toFile().deleteOnExit(); DataDirLayout dataDirLayout = - new SeparateServiceDataDirLayout(tempDir, Optional.empty(), Optional.empty()); + new SeparateServiceDataDirLayout(tempDir, Optional.empty(), Optional.empty(), false); final KeyManager keyManager = new NoOpKeyManager(); final AsyncRunnerFactory asyncRunnerFactory = @@ -163,9 +169,10 @@ public int generateSwaggerDocs( Optional.empty(), keyManager, dataDirLayout, - new SystemTimeProvider(), + SYSTEM_TIME_PROVIDER, Optional.empty(), - new DoppelgangerDetectionAlert()); + new DoppelgangerDetectionAlert(), + new NoOpGraffitiManager()); if (api.getRestApiDocs().isPresent()) { final String docs = api.getRestApiDocs().get(); @@ -231,9 +238,38 @@ public int printCommittees( System.out.printf( "Validator %s assigned to attest at slot %s in committee index %s, position %s%n", validatorIndex, - assignment.getSlot(), - assignment.getCommitteeIndex(), - assignment.getCommittee().indexOf(validatorIndex)); + assignment.slot(), + assignment.committeeIndex(), + assignment.committee().indexOf(validatorIndex)); + return 0; + } + + @Command( + name = "get-peer-id", + description = "Gets the peerID from private key file.", + mixinStandardHelpOptions = true, + showDefaultValues = true, + abbreviateSynopsis = true, + versionProvider = PicoCliVersionProvider.class, + synopsisHeading = "%n", + descriptionHeading = "%nDescription:%n%n", + optionListHeading = "%nOptions:%n", + footerHeading = "%n", + footer = "Teku is licensed under the Apache License 2.0") + public int getPeerID( + @Option( + names = {"--input", "-i"}, + description = "File to read the privateKey from", + required = true) + final Path input) { + try { + final Bytes privateKeyBytes = Bytes.wrap(Files.readAllBytes(Paths.get(input.toUri()))); + final PrivKey privKey = KeyKt.unmarshalPrivateKey(privateKeyBytes.toArrayUnsafe()); + System.out.print("Peer ID: " + PeerId.fromPubKey(privKey.publicKey())); + } catch (IOException e) { + System.err.println("Failed to read private key file: " + e.getMessage()); + return 1; + } return 0; } } diff --git a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/debug/PrettyPrintCommand.java b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/debug/PrettyPrintCommand.java index c261c350a18..46de01d5577 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/debug/PrettyPrintCommand.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/debug/PrettyPrintCommand.java @@ -38,6 +38,7 @@ import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.SpecVersion; import tech.pegasys.teku.spec.config.SpecConfigLoader; +import tech.pegasys.teku.spec.schemas.registry.SchemaRegistryBuilder; @Command( name = "pretty-print", @@ -59,7 +60,7 @@ public class PrettyPrintCommand implements Callable { paramLabel = "", description = "Output format to use", arity = "1") - @SuppressWarnings("FieldMayBeFinal") + @SuppressWarnings("FieldCanBeFinal") private OutputFormat format = OutputFormat.JSON; @Option( @@ -67,7 +68,7 @@ public class PrettyPrintCommand implements Callable { paramLabel = "", description = "Network config to use when decoding objects.", arity = "1") - @SuppressWarnings("FieldMayBeFinal") + @SuppressWarnings("FieldCanBeFinal") private String network = "mainnet"; @Parameters( @@ -75,7 +76,7 @@ public class PrettyPrintCommand implements Callable { paramLabel = "", description = "Milestone to use when decoding objects.", arity = "1") - @SuppressWarnings("FieldMayBeFinal") + @SuppressWarnings("FieldCanBeFinal") private SpecMilestone milestone = SpecMilestone.ALTAIR; @Parameters( @@ -95,7 +96,11 @@ public class PrettyPrintCommand implements Callable { @Override public Integer call() throws IOException { final SpecVersion spec = - SpecVersion.create(milestone, SpecConfigLoader.loadConfig(network)).orElseThrow(); + SpecVersion.create( + milestone, + SpecConfigLoader.loadConfig(network).specConfig(), + SchemaRegistryBuilder.create()) + .orElseThrow(); final Bytes inputData; try (final InputStream in = openStream()) { inputData = Bytes.wrap(IOUtils.toByteArray(in)); diff --git a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/debug/SszObjectType.java b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/debug/SszObjectType.java index f8601419621..739745dc57c 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/debug/SszObjectType.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/debug/SszObjectType.java @@ -26,9 +26,7 @@ import tech.pegasys.teku.spec.datastructures.operations.Deposit.DepositSchema; import tech.pegasys.teku.spec.datastructures.operations.DepositData.DepositDataSchema; import tech.pegasys.teku.spec.datastructures.operations.DepositMessage.DepositMessageSchema; -import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestation.IndexedAttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing.ProposerSlashingSchema; -import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof.SignedAggregateAndProofSchema; import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit.SignedVoluntaryExitSchema; import tech.pegasys.teku.spec.datastructures.operations.VoluntaryExit.VoluntaryExitSchema; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncAggregatorSelectionDataSchema; @@ -66,7 +64,7 @@ public enum SszObjectType { VoluntaryExit(new VoluntaryExitSchema()), Eth1Data(new Eth1DataSchema()), Fork(new ForkSchema()), - IndexedAttestation(config(IndexedAttestationSchema::new)), + IndexedAttestation(schemas(SchemaDefinitions::getIndexedAttestationSchema)), PendingAttestation(config(PendingAttestationSchema::new)), BeaconBlockHeader(new BeaconBlockHeaderSchema()), Deposit(new DepositSchema()), @@ -83,7 +81,7 @@ public enum SszObjectType { SyncAggregatorSelectionData(SyncAggregatorSelectionDataSchema.INSTANCE), SyncCommittee(altairConfig(SyncCommitteeSchema::new)), SyncAggregate(altairConfig(c -> SyncAggregateSchema.create(c.getSyncCommitteeSize()))), - SignedAggregateAndProof(config(SignedAggregateAndProofSchema::new)), + SignedAggregateAndProof(schemas(SchemaDefinitions::getSignedAggregateAndProofSchema)), Validator(new ValidatorSchema()), HistoricalBatch(config(c -> new HistoricalBatchSchema(c.getSlotsPerHistoricalRoot()))), ExecutionPayload(bellatrixSchemas(SchemaDefinitionsBellatrix::getExecutionPayloadSchema)), diff --git a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/internal/validator/tools/ConsoleAdapter.java b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/internal/validator/tools/ConsoleAdapter.java index 24e848060a2..9ea5dd52406 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/internal/validator/tools/ConsoleAdapter.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/internal/validator/tools/ConsoleAdapter.java @@ -16,10 +16,18 @@ import java.io.Console; public class ConsoleAdapter { - private Console console = System.console(); + private final Console console = System.console(); + @SuppressWarnings("SystemConsoleNull") // https://errorprone.info/bugpattern/SystemConsoleNull public boolean isConsoleAvailable() { - return console != null; + if (Runtime.version().feature() < 22) { + return console != null; + } + try { + return (Boolean) Console.class.getMethod("isTerminal").invoke(console); + } catch (ReflectiveOperationException e) { + throw new LinkageError(e.getMessage(), e); + } } public char[] readPassword(final String fmt, final Object... args) { diff --git a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/internal/validator/tools/DepositTransactionSender.java b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/internal/validator/tools/DepositTransactionSender.java index 2d591ecaa04..d6ee2a8dd6a 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/subcommand/internal/validator/tools/DepositTransactionSender.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/subcommand/internal/validator/tools/DepositTransactionSender.java @@ -59,7 +59,7 @@ public DepositTransactionSender( } public SafeFuture sendDepositTransaction( - BLSKeyPair validatorKeyPair, + final BLSKeyPair validatorKeyPair, final BLSPublicKey withdrawalPublicKey, final UInt64 amountInGwei, final Consumer commandStdOutput, diff --git a/teku/src/main/java/tech/pegasys/teku/cli/util/DatabaseMigrater.java b/teku/src/main/java/tech/pegasys/teku/cli/util/DatabaseMigrater.java index 197ea1d91d3..e41c8fd9892 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/util/DatabaseMigrater.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/util/DatabaseMigrater.java @@ -20,6 +20,7 @@ import java.nio.file.Files; import java.nio.file.Path; import java.util.List; +import java.util.Optional; import java.util.function.Consumer; import org.apache.commons.io.FileUtils; import org.hyperledger.besu.metrics.noop.NoOpMetricsSystem; @@ -176,7 +177,7 @@ void migrateData() throws DatabaseMigraterError { } @VisibleForTesting - KvStoreDatabase createDatabase(final Path databasePath, DatabaseVersion databaseVersion) + KvStoreDatabase createDatabase(final Path databasePath, final DatabaseVersion databaseVersion) throws DatabaseMigraterError { final Eth2NetworkConfiguration config = Eth2NetworkConfiguration.builder(network).build(); final VersionedDatabaseFactory databaseFactory = @@ -189,7 +190,8 @@ KvStoreDatabase createDatabase(final Path databasePath, DatabaseVersion database .storeNonCanonicalBlocks(true) .eth1DepositContract(config.getEth1DepositContractAddress()) .dataStorageCreateDbVersion(databaseVersion) - .build()); + .build(), + Optional.empty()); final Database database = databaseFactory.createDatabase(); if (!(database instanceof KvStoreDatabase)) { throw new DatabaseMigraterError( diff --git a/teku/src/main/java/tech/pegasys/teku/cli/util/EnvironmentVariableParamsProvider.java b/teku/src/main/java/tech/pegasys/teku/cli/util/EnvironmentVariableParamsProvider.java index f2b0f781422..9e087c77f0c 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/util/EnvironmentVariableParamsProvider.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/util/EnvironmentVariableParamsProvider.java @@ -33,7 +33,7 @@ public EnvironmentVariableParamsProvider(final Map environment) } @Override - public Map getAdditionalParams(List potentialParams) { + public Map getAdditionalParams(final List potentialParams) { return getAdditionalParams(potentialParams, environment); } @@ -64,7 +64,7 @@ protected Optional> translateEntry( @Override protected Map.Entry translateToArg( - OptionSpec matchedOption, Map.Entry envEntry) { + final OptionSpec matchedOption, final Map.Entry envEntry) { return Map.entry(matchedOption.longestName(), envEntry.getValue()); } } diff --git a/teku/src/main/java/tech/pegasys/teku/cli/util/YamlConfigFileParamsProvider.java b/teku/src/main/java/tech/pegasys/teku/cli/util/YamlConfigFileParamsProvider.java index 37f45fdb035..80718a29fb1 100644 --- a/teku/src/main/java/tech/pegasys/teku/cli/util/YamlConfigFileParamsProvider.java +++ b/teku/src/main/java/tech/pegasys/teku/cli/util/YamlConfigFileParamsProvider.java @@ -85,7 +85,7 @@ protected Optional> translateEntry( @Override protected Map.Entry translateToArg( - OptionSpec matchedOption, Map.Entry yamlEntry) { + final OptionSpec matchedOption, final Map.Entry yamlEntry) { final Object value = yamlEntry.getValue(); final String translatedValue; @@ -160,7 +160,7 @@ private void checkUnknownOptions(final Map result) { } } - private void checkConfigurationValidity(boolean isEmpty) { + private void checkConfigurationValidity(final boolean isEmpty) { if (isEmpty) { throw new ParameterException( commandLine, String.format("Empty yaml configuration file: %s", configFile)); diff --git a/teku/src/main/java/tech/pegasys/teku/config/TekuConfiguration.java b/teku/src/main/java/tech/pegasys/teku/config/TekuConfiguration.java index 984819b06e1..86c3add63a7 100644 --- a/teku/src/main/java/tech/pegasys/teku/config/TekuConfiguration.java +++ b/teku/src/main/java/tech/pegasys/teku/config/TekuConfiguration.java @@ -271,6 +271,34 @@ public TekuConfiguration build() { } } + if (syncConfig.isReconstructHistoricStatesEnabled()) { + if (storageConfiguration.getRetainedSlots() > 0) { + throw new InvalidConfigurationException( + "Cannot reconstruct historic states with state pruning enabled"); + } + } + + if (storageConfiguration.getRetainedSlots() > 0) { + if (!storageConfiguration.getDataStorageMode().storesFinalizedStates()) { + throw new InvalidConfigurationException( + "Cannot enable state pruning without using ARCHIVE data storage mode"); + } + } + + if (syncConfig.isReconstructHistoricStatesEnabled()) { + if (storageConfiguration.getRetainedSlots() > 0) { + throw new InvalidConfigurationException( + "Cannot reconstruct historic states with state pruning enabled"); + } + } + + if (storageConfiguration.getRetainedSlots() > 0 + && storageConfiguration.getRetainedSlots() + < storageConfiguration.getDataStorageFrequency()) { + throw new InvalidConfigurationException( + "Frequency of storing finalized states must be less than or equal to the number of retained slots"); + } + return new TekuConfiguration( eth2NetworkConfiguration, spec, @@ -386,7 +414,7 @@ public Builder store(final Consumer storeConfigBuilderConsu } public Builder beaconChainControllerFactory( - BeaconChainControllerFactory beaconChainControllerFactory) { + final BeaconChainControllerFactory beaconChainControllerFactory) { this.beaconChainControllerFactory = beaconChainControllerFactory; return this; } diff --git a/teku/src/main/java/tech/pegasys/teku/services/BeaconNodeServiceController.java b/teku/src/main/java/tech/pegasys/teku/services/BeaconNodeServiceController.java index 5c8cb4d16fc..5f128bbf74b 100644 --- a/teku/src/main/java/tech/pegasys/teku/services/BeaconNodeServiceController.java +++ b/teku/src/main/java/tech/pegasys/teku/services/BeaconNodeServiceController.java @@ -16,15 +16,19 @@ import static tech.pegasys.teku.infrastructure.logging.EventLogger.EVENT_LOG; import java.util.Optional; +import java.util.function.Supplier; import tech.pegasys.teku.config.TekuConfiguration; import tech.pegasys.teku.ethereum.executionclient.web3j.ExecutionWeb3jClientProvider; import tech.pegasys.teku.networking.nat.NatService; +import tech.pegasys.teku.networking.p2p.network.config.NetworkConfig; import tech.pegasys.teku.service.serviceutils.ServiceConfig; import tech.pegasys.teku.services.beaconchain.BeaconChainService; import tech.pegasys.teku.services.chainstorage.StorageService; import tech.pegasys.teku.services.executionlayer.ExecutionLayerService; import tech.pegasys.teku.services.powchain.PowchainService; +import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState; import tech.pegasys.teku.storage.api.FinalizedCheckpointChannel; +import tech.pegasys.teku.storage.client.RecentChainData; import tech.pegasys.teku.validator.client.ValidatorClientService; import tech.pegasys.teku.validator.client.slashingriskactions.DoppelgangerDetectionShutDown; import tech.pegasys.teku.validator.client.slashingriskactions.SlashedValidatorShutDown; @@ -43,7 +47,8 @@ public BeaconNodeServiceController( .powchain() .getDepositTreeSnapshotConfiguration() .isBundledDepositSnapshotEnabled(), - tekuConfig.metricsConfig().isBlobSidecarsStorageCountersEnabled())); + tekuConfig.metricsConfig().isBlobSidecarsStorageCountersEnabled(), + tekuConfig.beaconChain().eth2NetworkConfig().getEth2Network())); Optional maybeExecutionWeb3jClientProvider = Optional.empty(); if (tekuConfig.executionLayer().isEnabled()) { // Need to make sure the execution engine is listening before starting the beacon chain @@ -55,12 +60,29 @@ public BeaconNodeServiceController( final BeaconChainService beaconChainService = new BeaconChainService(serviceConfig, tekuConfig.beaconChain()); services.add(beaconChainService); + final NetworkConfig networkConfig = tekuConfig.network(); services.add( new NatService( tekuConfig.natConfiguration(), - tekuConfig.network().getListenPort(), + networkConfig.getListenPort(), + networkConfig.getNetworkInterfaces().size() == 2 + // IPv4 and IPv6 (dual-stack) + ? Optional.of(networkConfig.getListenPortIpv6()) + : Optional.empty(), tekuConfig.discovery().isDiscoveryEnabled())); - powchainService(tekuConfig, serviceConfig, maybeExecutionWeb3jClientProvider) + // making it a Supplier ensures that BeaconChainService has been started and RecentChainData has + // been initialized when `get()` is called + final Supplier> finalizedStateSupplier = + () -> { + final RecentChainData recentChainData = + beaconChainService.getBeaconChainController().getRecentChainData(); + if (recentChainData.isPreGenesis()) { + return Optional.empty(); + } + return Optional.of(recentChainData.getStore().getLatestFinalized().getState()); + }; + powchainService( + tekuConfig, serviceConfig, maybeExecutionWeb3jClientProvider, finalizedStateSupplier) .ifPresent(services::add); final Optional maybeValidatorSlashedAction = @@ -79,7 +101,8 @@ public BeaconNodeServiceController( private Optional powchainService( final TekuConfiguration tekuConfig, final ServiceConfig serviceConfig, - final Optional maybeExecutionWeb3jClientProvider) { + final Optional maybeExecutionWeb3jClientProvider, + final Supplier> finalizedStateSupplier) { if (tekuConfig.beaconChain().interopConfig().isInteropEnabled() || (!tekuConfig.powchain().isEnabled() && maybeExecutionWeb3jClientProvider.isEmpty())) { return Optional.empty(); @@ -92,7 +115,10 @@ private Optional powchainService( } final PowchainService powchainService = new PowchainService( - serviceConfig, tekuConfig.powchain(), maybeExecutionWeb3jClientProvider); + serviceConfig, + tekuConfig.powchain(), + maybeExecutionWeb3jClientProvider, + finalizedStateSupplier); serviceConfig.getEventChannels().subscribe(FinalizedCheckpointChannel.class, powchainService); return Optional.of(powchainService); } diff --git a/teku/src/main/scripts/unixStartScript.txt b/teku/src/main/scripts/unixStartScript.txt new file mode 100644 index 00000000000..75025cca5a3 --- /dev/null +++ b/teku/src/main/scripts/unixStartScript.txt @@ -0,0 +1,304 @@ +#!/bin/sh + +# +# Copyright © 2015-2021 the original authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# SPDX-License-Identifier: Apache-2.0 +# + +############################################################################## +# +# ${applicationName} start up script for POSIX generated by Gradle. +# +# Important for running: +# +# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is +# noncompliant, but you have some other compliant shell such as ksh or +# bash, then to run this script, type that shell name before the whole +# command line, like: +# +# ksh ${applicationName} +# +# Busybox and similar reduced shells will NOT work, because this script +# requires all of these POSIX shell features: +# * functions; +# * expansions «\$var», «\${var}», «\${var:-default}», «\${var+SET}», +# «\${var#prefix}», «\${var%suffix}», and «\$( cmd )»; +# * compound commands having a testable exit status, especially «case»; +# * various built-in commands including «command», «set», and «ulimit». +# +# Important for patching: +# +# (2) This script targets any POSIX shell, so it avoids extensions provided +# by Bash, Ksh, etc; in particular arrays are avoided. +# +# The "traditional" practice of packing multiple parameters into a +# space-separated string is a well documented source of bugs and security +# problems, so this is (mostly) avoided, by progressively accumulating +# options in "\$@", and eventually passing that to Java. +# +# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, +# and ${optsEnvironmentVar}) rely on word-splitting, this is performed explicitly; +# see the in-line comments for details. +# +# There are tweaks for specific operating systems such as AIX, CygWin, +# Darwin, MinGW, and NonStop. +# +# (3) This script is generated from the Groovy template +# https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt +# within the Gradle project. +#<% /* +# ... and if you're reading this, this IS the template just mentioned. +# +# This template is processed by +# https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/java/org/gradle/api/internal/plugins/UnixStartScriptGenerator.java +# +# Gradle is a meta-build system used by the project that you're building +# or installing. It's like autoconf but for projects that are written in +# Java and related languages. It's also used to build parts of the Gradle +# project itself. +# +# The Groovy template language is run in two phases. +# +# 1. Any character following \ is passed unmodified through to the +# next phase, while the \ is removed. Any other $ followed by +# varName or {varName} is replaced by the value of that variable. +# +# 2. The result of the first phase is parsed and run in a similar +# manner to JSP or MASON or PHP: anything within < % ... % > is a +# code block, anything else is sent as output, subject to the +# flow imposed by any code segments. +# +# 3. The "output" is a POSIX shell script, which has its own ideas about +# escaping with backslashes, so to get «\» you need to write «\\\\» +# and to get «$» you need to write «\\\$». +# +# For more details about the Groovy Template Engine, see +# https://docs.groovy-lang.org/next/html/documentation/ section §3.15 +# (Template Engines) for details. +# +# (An example invocation of this template is from +# https://github.com/gradle/gradle/blob/HEAD/subprojects/build-init/src/main/java/org/gradle/api/tasks/wrapper/Wrapper.java +# within the Gradle project, which builds "gradlew".) +# */ %> +# You can find Gradle at https://github.com/gradle/gradle/. +# +############################################################################## + +# Attempt to set APP_HOME + +# Resolve links: \$0 may be a link +app_path=\$0 + +# Need this for daisy-chained symlinks. +while + APP_HOME=\${app_path%"\${app_path##*/}"} # leaves a trailing /; empty if no leading path + [ -h "\$app_path" ] +do + ls=\$( ls -ld "\$app_path" ) + link=\${ls#*' -> '} + case \$link in #( + /*) app_path=\$link ;; #( + *) app_path=\$APP_HOME\$link ;; + esac +done + +# This is normally unused +# shellcheck disable=SC2034 +APP_BASE_NAME=\${0##*/} +# Discard cd standard output in case \$CDPATH is set (https://github.com/gradle/gradle/issues/25036) +APP_HOME=\$( cd -P "\${APP_HOME:-./}${appHomeRelativePath}" > /dev/null && printf '%s\n' "\$PWD" ) || exit + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD=maximum + +warn () { + echo "\$*" +} >&2 + +die () { + echo + echo "\$*" + echo + exit 1 +} >&2 + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "\$( uname )" in #( + CYGWIN* ) cygwin=true ;; #( + Darwin* ) darwin=true ;; #( + MSYS* | MINGW* ) msys=true ;; #( + NONSTOP* ) nonstop=true ;; +esac + +CLASSPATH=$classpath +<% if ( mainClassName.startsWith('--module ') ) { %> +MODULE_PATH=$modulePath +<% } %> + +# Determine the Java command to use to start the JVM. +if [ -n "\$JAVA_HOME" ] ; then + if [ -x "\$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD=\$JAVA_HOME/jre/sh/java + else + JAVACMD=\$JAVA_HOME/bin/java + fi + if [ ! -x "\$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: \$JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD=java + if ! command -v java >/dev/null 2>&1 + then + die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +fi + +# Increase the maximum file descriptors if we can. +if ! "\$cygwin" && ! "\$darwin" && ! "\$nonstop" ; then + case \$MAX_FD in #( + max*) + # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + MAX_FD=\$( ulimit -H -n ) || + warn "Could not query maximum file descriptor limit" + esac + case \$MAX_FD in #( + '' | soft) :;; #( + *) + # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + ulimit -n "\$MAX_FD" || + warn "Could not set maximum file descriptor limit to \$MAX_FD" + esac +fi + +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and ${optsEnvironmentVar} environment variables. + +# For Cygwin or MSYS, switch paths to Windows format before running java +if "\$cygwin" || "\$msys" ; then + APP_HOME=\$( cygpath --path --mixed "\$APP_HOME" ) + CLASSPATH=\$( cygpath --path --mixed "\$CLASSPATH" ) +<% if ( mainClassName.startsWith('--module ') ) { %> MODULE_PATH=\$( cygpath --path --mixed "\$MODULE_PATH" )<% } %> + JAVACMD=\$( cygpath --unix "\$JAVACMD" ) + + # Now convert the arguments - kludge to limit ourselves to /bin/sh + for arg do + if + case \$arg in #( + -*) false ;; # don't mess with options #( + /?*) t=\${arg#/} t=/\${t%%/*} # looks like a POSIX filepath + [ -e "\$t" ] ;; #( + *) false ;; + esac + then + arg=\$( cygpath --path --ignore --mixed "\$arg" ) + fi + # Roll the args list around exactly as many times as the number of + # args, so each arg winds up back in the position where it started, but + # possibly modified. + # + # NB: a `for` loop captures its iteration list before it begins, so + # changing the positional parameters here affects neither the number of + # iterations, nor the values presented in `arg`. + shift # remove old arg + set -- "\$@" "\$arg" # push replacement arg + done +fi + +<% /* +# The DEFAULT_JVM_OPTS variable is intentionally defined here to allow using cygwin-processed APP_HOME. +# So far the only way to inject APP_HOME reference into DEFAULT_JVM_OPTS is to post-process the start script; the declaration is a good anchor to do that. +*/ %> +# Add default JVM options here. You can also use JAVA_OPTS and ${optsEnvironmentVar} to pass JVM options to this script. +DEFAULT_JVM_OPTS=${defaultJvmOpts} + +# Collect all arguments for the java command: +# * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments, +# and any embedded shellness will be escaped. +# * For example: A user cannot expect \${Hostname} to be expanded, as it is an environment variable and will be +# treated as '\${Hostname}' itself on the command line. + +set -- \\ +<% if ( appNameSystemProperty ) { + %> "-D${appNameSystemProperty}=\$APP_BASE_NAME" \\ +<% } %> -classpath "\$CLASSPATH" \\ +<% if ( mainClassName.startsWith('--module ') ) { + %> --module-path "\$MODULE_PATH" \\ +<% } %> ${mainClassName} \\ + "\$@" + +# Stop when "xargs" is not available. +if ! command -v xargs >/dev/null 2>&1 +then + die "xargs is not available" +fi + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"\$var" ) && +# set -- "\${ARGS[@]}" "\$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- \$( + printf '%s\\n' "\$DEFAULT_JVM_OPTS \$JAVA_OPTS \$${optsEnvironmentVar}" | + xargs -n1 | + sed ' s~[^-[:alnum:]+,./:=@_]~\\\\&~g; ' | + tr '\\n' ' ' + )" '"\$@"' + +unset TEKU_USING_JEMALLOC +if [ "\$darwin" = "false" -a "\$msys" = "false" ]; then + # check if jemalloc is available + TEST_JEMALLOC=\$(LD_PRELOAD=libjemalloc.so sh -c true 2>&1) + + # if jemalloc is available the output is empty, otherwise the output has an error line + if [ -z "\$TEST_JEMALLOC" ]; then + export LD_PRELOAD=libjemalloc.so + export TEKU_USING_JEMALLOC=true + fi +fi + +exec "\$JAVACMD" "\$@" \ No newline at end of file diff --git a/teku/src/test/java/tech/pegasys/teku/cli/AbstractBeaconNodeCommandTest.java b/teku/src/test/java/tech/pegasys/teku/cli/AbstractBeaconNodeCommandTest.java index 6a13cafaeb1..934bf8dbfb6 100644 --- a/teku/src/test/java/tech/pegasys/teku/cli/AbstractBeaconNodeCommandTest.java +++ b/teku/src/test/java/tech/pegasys/teku/cli/AbstractBeaconNodeCommandTest.java @@ -88,18 +88,18 @@ public LoggingConfig getResultingLoggingConfiguration() { BeaconNodeCommand.LOG_FILE_PREFIX); } - public TekuConfiguration getTekuConfigurationFromArguments(String... arguments) { + public TekuConfiguration getTekuConfigurationFromArguments(final String... arguments) { beaconNodeCommand.parse(arguments); return getResultingTekuConfiguration(); } - public LoggingConfig getLoggingConfigurationFromArguments(String... arguments) { + public LoggingConfig getLoggingConfigurationFromArguments(final String... arguments) { beaconNodeCommand.parse(arguments); return getResultingLoggingConfiguration(); } public TekuConfiguration getTekuConfigurationFromFile( - String resourceFilename, Optional subcommand) { + final String resourceFilename, final Optional subcommand) { final String configFile = this.getClass().getResource("/" + resourceFilename).getPath(); final String[] args = Stream.concat(subcommand.stream(), Stream.of(CONFIG_FILE_OPTION_NAME, configFile)) @@ -113,7 +113,7 @@ public TekuConfiguration getTekuConfigurationFromFile(final String resourceFilen return getTekuConfigurationFromFile(resourceFilename, Optional.empty()); } - public LoggingConfig getLoggingConfigFromFile(String resourceFilename) { + public LoggingConfig getLoggingConfigFromFile(final String resourceFilename) { final String configFile = this.getClass().getResource("/" + resourceFilename).getPath(); final String[] args = {CONFIG_FILE_OPTION_NAME, configFile}; beaconNodeCommand.parse(args); diff --git a/teku/src/test/java/tech/pegasys/teku/cli/BeaconNodeCommandTest.java b/teku/src/test/java/tech/pegasys/teku/cli/BeaconNodeCommandTest.java index 0c2263bf504..f347901ab8e 100644 --- a/teku/src/test/java/tech/pegasys/teku/cli/BeaconNodeCommandTest.java +++ b/teku/src/test/java/tech/pegasys/teku/cli/BeaconNodeCommandTest.java @@ -189,13 +189,12 @@ void developerHelpShouldNotShowSupportedOptions() { final String[] args = {"-X"}; beaconNodeCommand.parse(args); - String str = getCommandLineOutput(); - final Pattern p = Pattern.compile("--[^X][^ ]+"); - final Matcher matcher = p.matcher(str); + final Pattern p = Pattern.compile("--[^X][^ ]+="); + final Matcher matcher = p.matcher(getCommandLineOutput()); final List errors = new ArrayList<>(); while (matcher.find()) { - MatchResult current = matcher.toMatchResult(); + final MatchResult current = matcher.toMatchResult(); LOG.debug("found {} at position {}", current.group().trim(), current.start()); errors.add(current.group().trim()); } @@ -240,12 +239,13 @@ private Stream allOptions() { } private Stream addSubCommandOptions( - final CommandLine commandLine, Stream stream) { + final CommandLine commandLine, final Stream stream) { + Stream mutableStream = stream; for (CommandLine subCommand : commandLine.getSubcommands().values()) { - stream = Stream.concat(stream, subCommand.getCommandSpec().options().stream()); - stream = addSubCommandOptions(subCommand, stream); + mutableStream = Stream.concat(mutableStream, subCommand.getCommandSpec().options().stream()); + mutableStream = addSubCommandOptions(subCommand, mutableStream); } - return stream; + return mutableStream; } @Test diff --git a/teku/src/test/java/tech/pegasys/teku/cli/options/BeaconNodeDataOptionsTest.java b/teku/src/test/java/tech/pegasys/teku/cli/options/BeaconNodeDataOptionsTest.java index 6ba18ce3251..022e004abfc 100644 --- a/teku/src/test/java/tech/pegasys/teku/cli/options/BeaconNodeDataOptionsTest.java +++ b/teku/src/test/java/tech/pegasys/teku/cli/options/BeaconNodeDataOptionsTest.java @@ -22,6 +22,7 @@ import java.nio.file.Path; import java.time.Duration; import java.util.function.Supplier; +import org.assertj.core.util.Files; import org.junit.jupiter.api.Test; import tech.pegasys.teku.cli.AbstractBeaconNodeCommandTest; import tech.pegasys.teku.config.TekuConfiguration; @@ -189,6 +190,19 @@ void shouldSetBlobsPruningOptions() { assertThat(config.storageConfiguration().getBlobsPruningLimit()).isEqualTo(10); } + @Test + void shouldSetBlobsPruningArchivePath() { + // path needs to exist. + String someTempPath = Files.temporaryFolderPath(); + final TekuConfiguration config = + getTekuConfigurationFromArguments("--Xdata-storage-blobs-archive-path=" + someTempPath); + + assertThat(config.storageConfiguration().getBlobsArchivePath()) + .isPresent() + .get() + .isEqualTo(someTempPath); + } + @Test void shouldNotAllowPruningBlocksAndReconstructingStates() { assertThatThrownBy( @@ -200,4 +214,17 @@ void shouldNotAllowPruningBlocksAndReconstructingStates() { .isInstanceOf(InvalidConfigurationException.class) .hasMessage("Cannot reconstruct historic states without using ARCHIVE data storage mode"); } + + @Test + void debugDataDumpingEnabled_shouldDefaultFalse() { + final TekuConfiguration tekuConfig = getTekuConfigurationFromArguments(); + assertThat(tekuConfig.dataConfig().isDebugDataDumpingEnabled()).isEqualTo(false); + } + + @Test + void shouldSetDebugDataDumpingEnabled() { + final TekuConfiguration tekuConfig = + getTekuConfigurationFromArguments("--Xdebug-data-dumping-enabled=true"); + assertThat(tekuConfig.dataConfig().isDebugDataDumpingEnabled()).isEqualTo(true); + } } diff --git a/teku/src/test/java/tech/pegasys/teku/cli/options/DepositOptionsTest.java b/teku/src/test/java/tech/pegasys/teku/cli/options/DepositOptionsTest.java index 94ae661e94a..f7b20475188 100644 --- a/teku/src/test/java/tech/pegasys/teku/cli/options/DepositOptionsTest.java +++ b/teku/src/test/java/tech/pegasys/teku/cli/options/DepositOptionsTest.java @@ -93,7 +93,7 @@ public void multiple_eth1Endpoints_areSupported_mixedParams() { } @ParameterizedTest(name = "{0}") - @ValueSource(strings = {"mainnet", "goerli", "prater", "gnosis", "sepolia"}) + @ValueSource(strings = {"mainnet", "holesky", "gnosis", "sepolia"}) public void shouldSetDefaultBundleSnapshotPathForSupportedNetwork(final String network) { final String[] args = {"--network=" + network, "--deposit-snapshot-enabled"}; final TekuConfiguration config = getTekuConfigurationFromArguments(args); diff --git a/teku/src/test/java/tech/pegasys/teku/cli/options/Eth2NetworkOptionsTest.java b/teku/src/test/java/tech/pegasys/teku/cli/options/Eth2NetworkOptionsTest.java index 798d89cc115..d90f2eb03e0 100644 --- a/teku/src/test/java/tech/pegasys/teku/cli/options/Eth2NetworkOptionsTest.java +++ b/teku/src/test/java/tech/pegasys/teku/cli/options/Eth2NetworkOptionsTest.java @@ -14,6 +14,7 @@ package tech.pegasys.teku.cli.options; import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.junit.jupiter.api.Assertions.assertThrows; import static tech.pegasys.teku.networks.Eth2NetworkConfiguration.FINALIZED_STATE_URL_PATH; import static tech.pegasys.teku.networks.Eth2NetworkConfiguration.GENESIS_STATE_URL_PATH; @@ -92,7 +93,8 @@ void shouldUseCustomSafeSlotsToImportOptimistically() { "256"); final Spec spec = config.eth2NetworkConfiguration().getSpec(); assertThat( - spec.getGenesisSpecConfig() + spec.forMilestone(SpecMilestone.BELLATRIX) + .getConfig() .toVersionBellatrix() .orElseThrow() .getSafeSlotsToImportOptimistically()) @@ -216,4 +218,11 @@ public void checkpointSyncUrlOptionShouldSetInitialAndGenesisStateOptions( assertThat(networkConfiguration.getNetworkBoostrapConfig().getInitialState()) .hasValue("http://foo:9000/" + FINALIZED_STATE_URL_PATH); } + + @Test + public void shouldShowGoerliDeprecationWarning() { + assertThatThrownBy(() -> getTekuConfigurationFromArguments("--network", "goerli")) + .isInstanceOf(AssertionError.class) // thrown because we had an error + .hasMessageContaining("Goerli support has been removed"); + } } diff --git a/teku/src/test/java/tech/pegasys/teku/cli/options/Eth2P2PNetworkOptionsTest.java b/teku/src/test/java/tech/pegasys/teku/cli/options/Eth2P2PNetworkOptionsTest.java index 5fc8b28cd90..2bec62ab205 100644 --- a/teku/src/test/java/tech/pegasys/teku/cli/options/Eth2P2PNetworkOptionsTest.java +++ b/teku/src/test/java/tech/pegasys/teku/cli/options/Eth2P2PNetworkOptionsTest.java @@ -35,14 +35,14 @@ public class Eth2P2PNetworkOptionsTest extends AbstractBeaconNodeCommandTest { @Test public void shouldReadFromConfigurationFile() { final Eth2NetworkConfiguration eth2NetworkConfig = - Eth2NetworkConfiguration.builder("prater").build(); + Eth2NetworkConfiguration.builder("holesky").build(); final TekuConfiguration config = getTekuConfigurationFromFile("networkOptions_config.yaml"); assertThat(config.eth2NetworkConfiguration().getConstants()) .isEqualTo(eth2NetworkConfig.getConstants()); } @ParameterizedTest(name = "{0}") - @ValueSource(strings = {"mainnet", "minimal", "swift", "prater"}) + @ValueSource(strings = {"mainnet", "minimal", "swift", "holesky"}) public void useDefaultsFromNetworkDefinition(final String networkName) { final Eth2NetworkConfiguration eth2NetworkConfig = Eth2NetworkConfiguration.builder(networkName).build(); @@ -110,7 +110,7 @@ public void overrideDepositContractDeployBlock() { @Test public void overrideDefaultBootnodesWithEmptyList() { - beaconNodeCommand.parse(new String[] {"--network", "prater", "--p2p-discovery-bootnodes"}); + beaconNodeCommand.parse(new String[] {"--network", "holesky", "--p2p-discovery-bootnodes"}); TekuConfiguration tekuConfiguration = getResultingTekuConfiguration(); final List bootnodes = tekuConfiguration.discovery().getBootnodes(); @@ -164,7 +164,7 @@ public void initialState_shouldAcceptValue() { @Test public void initialState_shouldDefaultToNetworkValue() { - final String network = "prater"; + final String network = "holesky"; final Eth2NetworkConfiguration networkConfig = Eth2NetworkConfiguration.builder(network).build(); assertThat(networkConfig.getNetworkBoostrapConfig().getInitialState()).isPresent(); @@ -183,7 +183,7 @@ public void initialState_shouldDefaultToNetworkValue() { @Test public void initialState_shouldOverrideNetworkValue() { final String state = "state.ssz"; - final String network = "prater"; + final String network = "holesky"; final Eth2NetworkConfiguration networkConfig = Eth2NetworkConfiguration.builder(network).build(); assertThat(networkConfig.getNetworkBoostrapConfig().getInitialState()).isPresent(); diff --git a/teku/src/test/java/tech/pegasys/teku/cli/options/LoggingOptionsTest.java b/teku/src/test/java/tech/pegasys/teku/cli/options/LoggingOptionsTest.java index d7d2cb3da9b..46a91865269 100644 --- a/teku/src/test/java/tech/pegasys/teku/cli/options/LoggingOptionsTest.java +++ b/teku/src/test/java/tech/pegasys/teku/cli/options/LoggingOptionsTest.java @@ -156,7 +156,7 @@ public void shouldSetLogPatternOnWithoutPath() { "OFF", "FATAL", "ERROR", "WARN", "INFO", "DEBUG", "TRACE", "ALL", "off", "fatal", "error", "warn", "info", "debug", "trace", "all" }) - public void loglevel_shouldAcceptValues(String level) { + public void loglevel_shouldAcceptValues(final String level) { final String[] args = {"--logging", level}; final LoggingConfig config = getLoggingConfigurationFromArguments(args); assertThat(config.getLogLevel().orElseThrow().toString()).isEqualToIgnoringCase(level); @@ -164,7 +164,7 @@ public void loglevel_shouldAcceptValues(String level) { @ParameterizedTest(name = "{0}") @ValueSource(strings = {"Off", "Fatal", "eRRoR", "WaRN", "InfO", "DebUG", "trACE", "All"}) - public void loglevel_shouldAcceptValuesMixedCase(String level) { + public void loglevel_shouldAcceptValuesMixedCase(final String level) { final String[] args = {"--logging", level}; final LoggingConfig config = getLoggingConfigurationFromArguments(args); assertThat(config.getLogLevel().orElseThrow().toString()) diff --git a/teku/src/test/java/tech/pegasys/teku/cli/options/MetricsOptionsTest.java b/teku/src/test/java/tech/pegasys/teku/cli/options/MetricsOptionsTest.java index 298e0693bca..688e24c7d45 100644 --- a/teku/src/test/java/tech/pegasys/teku/cli/options/MetricsOptionsTest.java +++ b/teku/src/test/java/tech/pegasys/teku/cli/options/MetricsOptionsTest.java @@ -21,11 +21,15 @@ import static tech.pegasys.teku.infrastructure.metrics.TekuMetricCategory.NETWORK; import java.util.Set; +import java.util.function.Function; +import java.util.stream.Stream; import org.hyperledger.besu.metrics.StandardMetricCategory; import org.hyperledger.besu.plugin.services.metrics.MetricCategory; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.EnumSource; +import org.junit.jupiter.params.provider.MethodSource; import tech.pegasys.teku.cli.AbstractBeaconNodeCommandTest; import tech.pegasys.teku.config.TekuConfiguration; import tech.pegasys.teku.infrastructure.metrics.MetricsConfig; @@ -46,7 +50,7 @@ public void shouldReadFromConfigurationFile() { @ParameterizedTest(name = "{0}") @EnumSource(TekuMetricCategory.class) - public void metricsCategories_shouldAcceptValues(MetricCategory category) { + public void metricsCategories_shouldAcceptValues(final MetricCategory category) { TekuConfiguration tekuConfiguration = getTekuConfigurationFromArguments("--metrics-categories", category.toString()); final MetricsConfig config = tekuConfiguration.metricsConfig(); @@ -55,7 +59,8 @@ public void metricsCategories_shouldAcceptValues(MetricCategory category) { @ParameterizedTest(name = "{0}") @EnumSource(StandardMetricCategory.class) - public void metricsCategories_shouldAcceptStandardMetricCategories(MetricCategory category) { + public void metricsCategories_shouldAcceptStandardMetricCategories( + final MetricCategory category) { TekuConfiguration tekuConfiguration = getTekuConfigurationFromArguments("--metrics-categories", category.toString()); final MetricsConfig config = tekuConfiguration.metricsConfig(); @@ -115,4 +120,33 @@ public void metricsHostAllowlist_shouldDefaultToLocalhost() { assertThat(getTekuConfigurationFromArguments().metricsConfig().getMetricsHostAllowlist()) .containsOnly("localhost", "127.0.0.1"); } + + @ParameterizedTest(name = "{0}") + @MethodSource("provideArgumentsForShouldSetWarningThresholds") + public void shouldSetWarningThresholds( + final String option, final Function configValueFunction) { + final TekuConfiguration tekuConfiguration = getTekuConfigurationFromArguments(option, "100"); + final MetricsConfig config = tekuConfiguration.metricsConfig(); + assertThat(configValueFunction.apply(config)).isEqualTo(100); + } + + private static Stream provideArgumentsForShouldSetWarningThresholds() { + return Stream.of( + Arguments.of( + "--Xmetrics-block-production-timing-tracking-warning-local-threshold", + (Function) + MetricsConfig::getBlockProductionPerformanceWarningLocalThreshold), + Arguments.of( + "--Xmetrics-block-production-timing-tracking-warning-builder-threshold", + (Function) + MetricsConfig::getBlockProductionPerformanceWarningBuilderThreshold), + Arguments.of( + "--Xmetrics-block-publishing-timing-tracking-warning-local-threshold", + (Function) + MetricsConfig::getBlockPublishingPerformanceWarningLocalThreshold), + Arguments.of( + "--Xmetrics-block-publishing-timing-tracking-warning-builder-threshold", + (Function) + MetricsConfig::getBlockPublishingPerformanceWarningBuilderThreshold)); + } } diff --git a/teku/src/test/java/tech/pegasys/teku/cli/options/P2POptionsTest.java b/teku/src/test/java/tech/pegasys/teku/cli/options/P2POptionsTest.java index 9f7c3aca6c4..766dec5453c 100644 --- a/teku/src/test/java/tech/pegasys/teku/cli/options/P2POptionsTest.java +++ b/teku/src/test/java/tech/pegasys/teku/cli/options/P2POptionsTest.java @@ -15,6 +15,14 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static tech.pegasys.teku.infrastructure.async.AsyncRunnerFactory.DEFAULT_MAX_QUEUE_SIZE_ALL_SUBNETS; +import static tech.pegasys.teku.networking.eth2.P2PConfig.DEFAULT_GOSSIP_BLOBS_AFTER_BLOCK_ENABLED; +import static tech.pegasys.teku.networking.p2p.discovery.DiscoveryConfig.DEFAULT_P2P_PEERS_LOWER_BOUND_ALL_SUBNETS; +import static tech.pegasys.teku.networking.p2p.discovery.DiscoveryConfig.DEFAULT_P2P_PEERS_UPPER_BOUND_ALL_SUBNETS; +import static tech.pegasys.teku.networking.p2p.gossip.config.GossipConfig.DEFAULT_FLOOD_PUBLISH_MAX_MESSAGE_SIZE_THRESHOLD; +import static tech.pegasys.teku.networking.p2p.network.config.NetworkConfig.DEFAULT_P2P_PORT; +import static tech.pegasys.teku.networking.p2p.network.config.NetworkConfig.DEFAULT_P2P_PORT_IPV6; +import static tech.pegasys.teku.validator.api.ValidatorConfig.DEFAULT_EXECUTOR_MAX_QUEUE_SIZE_ALL_SUBNETS; import java.util.List; import org.junit.jupiter.api.Test; @@ -47,8 +55,8 @@ public void shouldReadFromConfigurationFile() { final NetworkConfig networkConfig = tekuConfig.network(); assertThat(networkConfig.isEnabled()).isTrue(); - assertThat(networkConfig.getAdvertisedIp()).isEqualTo("127.200.0.1"); - assertThat(networkConfig.getNetworkInterface()).isEqualTo("127.100.0.1"); + assertThat(networkConfig.getAdvertisedIps()).containsExactly("127.200.0.1"); + assertThat(networkConfig.getNetworkInterfaces()).containsExactly("127.100.0.1"); assertThat(networkConfig.getListenPort()).isEqualTo(4321); assertThat(networkConfig.getPrivateKeySource()).containsInstanceOf(FilePrivateKeySource.class); assertThat(((FilePrivateKeySource) networkConfig.getPrivateKeySource().get()).getFileName()) @@ -107,17 +115,18 @@ void p2pUdpPort_shouldOverrideP2pPortWhenBothSet() { } @Test - public void advertisedIp_shouldDefaultToEmpty() { + public void advertisedIps_shouldDefaultToEmpty() { final NetworkConfig config = getTekuConfigurationFromArguments().network(); - assertThat(config.hasUserExplicitlySetAdvertisedIp()).isFalse(); + assertThat(config.hasUserExplicitlySetAdvertisedIps()).isFalse(); } @Test - public void advertisedIp_shouldAcceptValue() { + public void advertisedIps_shouldAcceptValue() { final String ip = "10.0.1.200"; TekuConfiguration tekuConfiguration = getTekuConfigurationFromArguments("--p2p-advertised-ip", ip); - assertThat(tekuConfiguration.network().getAdvertisedIp()).contains(ip); + assertThat(tekuConfiguration.network().getAdvertisedIps()) + .allMatch(advertisedIp -> advertisedIp.contains(ip)); } @Test @@ -257,4 +266,137 @@ public void historicalSyncBatchSize_greaterThanMessageSizeShouldThrowException() .isInstanceOf(InvalidConfigurationException.class) .hasMessage("Historical sync batch size cannot be greater than 128"); } + + @Test + public void allSubnetsShouldOverrideQueueSizesAndPeers() { + final TekuConfiguration tekuConfiguration = + getTekuConfigurationFromArguments("--p2p-subscribe-all-subnets-enabled", "true"); + + assertThat(tekuConfiguration.discovery().getMaxPeers()) + .isEqualTo(DEFAULT_P2P_PEERS_UPPER_BOUND_ALL_SUBNETS); + assertThat(tekuConfiguration.discovery().getMinPeers()) + .isEqualTo(DEFAULT_P2P_PEERS_LOWER_BOUND_ALL_SUBNETS); + assertThat(tekuConfiguration.eth2NetworkConfiguration().getAsyncBeaconChainMaxQueue()) + .isEqualTo(DEFAULT_MAX_QUEUE_SIZE_ALL_SUBNETS); + assertThat(tekuConfiguration.eth2NetworkConfiguration().getAsyncP2pMaxQueue()) + .isEqualTo(DEFAULT_MAX_QUEUE_SIZE_ALL_SUBNETS); + assertThat(tekuConfiguration.validatorClient().getValidatorConfig().getExecutorMaxQueueSize()) + .isEqualTo(DEFAULT_EXECUTOR_MAX_QUEUE_SIZE_ALL_SUBNETS); + assertThat(tekuConfiguration.p2p().getBatchVerifyQueueCapacity()) + .isEqualTo(DEFAULT_MAX_QUEUE_SIZE_ALL_SUBNETS); + } + + @Test + public void allSubnetsShouldNotOverridePeersIfExplicitlySet() { + final TekuConfiguration tekuConfiguration = + getTekuConfigurationFromArguments( + "--p2p-subscribe-all-subnets-enabled", + "true", + "--p2p-peer-lower-bound", + "20", + "--p2p-peer-upper-bound", + "21"); + + assertThat(tekuConfiguration.discovery().getMaxPeers()).isEqualTo(21); + assertThat(tekuConfiguration.discovery().getMinPeers()).isEqualTo(20); + } + + @Test + public void allSubnetsShouldNotOverridePeersIfExplicitlySetWithDefaults() { + final TekuConfiguration tekuConfiguration = + getTekuConfigurationFromArguments( + "--p2p-peer-lower-bound", + "64", + "--p2p-peer-upper-bound", + "100", + "--p2p-subscribe-all-subnets-enabled", + "true"); + + assertThat(tekuConfiguration.discovery().getMinPeers()).isEqualTo(64); + assertThat(tekuConfiguration.discovery().getMaxPeers()).isEqualTo(100); + } + + @Test + public void allSubnetsShouldNotOverrideQueuesIfExplicitlySet() { + final TekuConfiguration tekuConfiguration = + getTekuConfigurationFromArguments( + "--p2p-subscribe-all-subnets-enabled", + "true", + "--Xnetwork-async-p2p-max-queue", + "15000", + "--Xnetwork-async-beaconchain-max-queue", + "15020", + "--Xvalidator-executor-max-queue-size", + "15120", + "--Xp2p-batch-verify-signatures-queue-capacity", + "15220"); + + assertThat(tekuConfiguration.eth2NetworkConfiguration().getAsyncP2pMaxQueue()) + .isEqualTo(15_000); + assertThat(tekuConfiguration.eth2NetworkConfiguration().getAsyncBeaconChainMaxQueue()) + .isEqualTo(15_020); + assertThat(tekuConfiguration.validatorClient().getValidatorConfig().getExecutorMaxQueueSize()) + .isEqualTo(15_120); + assertThat(tekuConfiguration.p2p().getBatchVerifyQueueCapacity()).isEqualTo(15_220); + } + + @Test + public void floodPublishMaxMessageSizeThreshold_defaultIsSetCorrectly() { + final TekuConfiguration config = getTekuConfigurationFromArguments(); + assertThat(config.network().getGossipConfig().getFloodPublishMaxMessageSizeThreshold()) + .isEqualTo(DEFAULT_FLOOD_PUBLISH_MAX_MESSAGE_SIZE_THRESHOLD); + } + + @Test + public void floodPublishMaxMessageSizeThreshold_isSetCorrectly() { + final TekuConfiguration config = + getTekuConfigurationFromArguments("--Xp2p-flood-max-message-size-threshold=1000"); + assertThat(config.network().getGossipConfig().getFloodPublishMaxMessageSizeThreshold()) + .isEqualTo(1000); + } + + @Test + public void gossipBlobsAfterBlockEnabled_defaultIsSetCorrectly() { + final TekuConfiguration config = getTekuConfigurationFromArguments(); + assertThat(config.p2p().isGossipBlobsAfterBlockEnabled()) + .isEqualTo(DEFAULT_GOSSIP_BLOBS_AFTER_BLOCK_ENABLED); + } + + @Test + public void gossipBlobsAfterBlockEnabled_shouldNotRequireAValue() { + final TekuConfiguration config = + getTekuConfigurationFromArguments("--Xp2p-gossip-blobs-after-block-enabled"); + assertThat(config.p2p().isGossipBlobsAfterBlockEnabled()).isTrue(); + } + + @Test + public void gossipBlobsAfterBlockEnabled_true() { + final TekuConfiguration config = + getTekuConfigurationFromArguments("--Xp2p-gossip-blobs-after-block-enabled=true"); + assertThat(config.p2p().isGossipBlobsAfterBlockEnabled()).isTrue(); + } + + @Test + public void gossipBlobsAfterBlockEnabled_false() { + final TekuConfiguration config = + getTekuConfigurationFromArguments("--Xp2p-gossip-blobs-after-block-enabled=false"); + assertThat(config.p2p().isGossipBlobsAfterBlockEnabled()).isFalse(); + } + + @Test + public void defaultPortsAreSetCorrectly() { + final TekuConfiguration tekuConfiguration = getTekuConfigurationFromArguments(); + + final DiscoveryConfig discoveryConfig = tekuConfiguration.discovery(); + assertThat(discoveryConfig.getListenUdpPort()).isEqualTo(DEFAULT_P2P_PORT); + assertThat(discoveryConfig.getListenUpdPortIpv6()).isEqualTo(DEFAULT_P2P_PORT_IPV6); + assertThat(discoveryConfig.getAdvertisedUdpPort()).isEqualTo(DEFAULT_P2P_PORT); + assertThat(discoveryConfig.getAdvertisedUdpPortIpv6()).isEqualTo(DEFAULT_P2P_PORT_IPV6); + + final NetworkConfig networkConfig = tekuConfiguration.network(); + assertThat(networkConfig.getListenPort()).isEqualTo(DEFAULT_P2P_PORT); + assertThat(networkConfig.getListenPortIpv6()).isEqualTo(DEFAULT_P2P_PORT_IPV6); + assertThat(networkConfig.getAdvertisedPort()).isEqualTo(DEFAULT_P2P_PORT); + assertThat(networkConfig.getAdvertisedPortIpv6()).isEqualTo(DEFAULT_P2P_PORT_IPV6); + } } diff --git a/teku/src/test/java/tech/pegasys/teku/cli/subcommand/RemoteSpecLoaderTest.java b/teku/src/test/java/tech/pegasys/teku/cli/subcommand/RemoteSpecLoaderTest.java index c5a78b04542..a6818600c2c 100644 --- a/teku/src/test/java/tech/pegasys/teku/cli/subcommand/RemoteSpecLoaderTest.java +++ b/teku/src/test/java/tech/pegasys/teku/cli/subcommand/RemoteSpecLoaderTest.java @@ -70,7 +70,7 @@ void shouldDefaultNetworkConfigThatMovedFromConstants() throws IOException { final ObjectMapper objectMapper = new ObjectMapper(); TypeReference> typeReference = new TypeReference<>() {}; Map data = objectMapper.readValue(jsonConfig, typeReference); - final SpecConfig specConfig = SpecConfigLoader.loadRemoteConfig(data); + final SpecConfig specConfig = SpecConfigLoader.loadRemoteConfig(data).specConfig(); // Check values not assigned, using default values assertThat(specConfig.getGossipMaxSize()).isEqualTo(10485760); diff --git a/teku/src/test/java/tech/pegasys/teku/cli/subcommand/ValidatorClientCommandTest.java b/teku/src/test/java/tech/pegasys/teku/cli/subcommand/ValidatorClientCommandTest.java index 097b380e452..4754a381a7f 100644 --- a/teku/src/test/java/tech/pegasys/teku/cli/subcommand/ValidatorClientCommandTest.java +++ b/teku/src/test/java/tech/pegasys/teku/cli/subcommand/ValidatorClientCommandTest.java @@ -17,11 +17,15 @@ import static tech.pegasys.teku.networks.Eth2NetworkConfiguration.DEFAULT_VALIDATOR_EXECUTOR_THREADS; import com.google.common.io.Resources; +import java.io.IOException; import java.net.URI; +import java.nio.file.Path; import java.util.List; import java.util.Optional; +import org.assertj.core.api.AssertionsForClassTypes; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; import tech.pegasys.teku.cli.AbstractBeaconNodeCommandTest; import tech.pegasys.teku.config.TekuConfiguration; import tech.pegasys.teku.infrastructure.logging.LoggingConfig; @@ -37,9 +41,7 @@ void setUp() { @Test public void networkOption_ShouldFail_IfSpecifiedOnParentCommand() { final String[] argsNetworkOptOnParent = - new String[] { - "--network", "auto", "vc", - }; + new String[] {"--network", "auto", "vc", "--validator-keys=keys:pass"}; int parseResult = beaconNodeCommand.parse(argsNetworkOptOnParent); assertThat(parseResult).isEqualTo(2); String cmdOutput = getCommandLineOutput(); @@ -51,7 +53,7 @@ public void networkOption_ShouldFail_IfSpecifiedOnParentCommand() { void loggingOptions_shouldUseLoggingOptionsFromBeforeSubcommand() { final LoggingConfig config = getLoggingConfigurationFromArguments( - "--log-destination=console", "vc", "--network=mainnet"); + "--log-destination=console", "vc", "--network=mainnet", "--validator-keys=keys:pass"); assertThat(config.getDestination()).isEqualTo(LoggingDestination.CONSOLE); } @@ -59,7 +61,7 @@ void loggingOptions_shouldUseLoggingOptionsFromBeforeSubcommand() { void loggingOptions_shouldUseLoggingOptionsFromAfterSubcommand() { final LoggingConfig config = getLoggingConfigurationFromArguments( - "vc", "--network=mainnet", "--log-destination=console"); + "vc", "--validator-keys=keys:pass", "--network=mainnet", "--log-destination=console"); assertThat(config.getDestination()).isEqualTo(LoggingDestination.CONSOLE); } @@ -77,7 +79,12 @@ public void sentryConfigOption_shouldBuildExpectedConfigWhenOptionHasFileNamePar final String sentryConfigPath = pathFor("sentry_node_config.json"); final String[] argsWithSentryConfig = new String[] { - "vc", "--network", "minimal", "--sentry-config-file", sentryConfigPath, + "vc", + "--network", + "minimal", + "--validator-keys=keys:pass", + "--sentry-config-file", + sentryConfigPath, }; final TekuConfiguration tekuConfig = getTekuConfigurationFromArguments(argsWithSentryConfig); @@ -89,9 +96,7 @@ public void sentryConfigOption_shouldBuildExpectedConfigWhenOptionHasFileNamePar @Test public void sentryConfigOption_emptyConfigWhenMissingSentryConfigFileParam() { final String[] argsWithoutSentryConfig = - new String[] { - "vc", "--network", "minimal", - }; + new String[] {"vc", "--network", "minimal", "--validator-keys=keys:pass"}; final TekuConfiguration tekuConfig = getTekuConfigurationFromArguments(argsWithoutSentryConfig); @@ -103,7 +108,7 @@ public void sentryConfigOption_emptyConfigWhenMissingSentryConfigFileParam() { public void sentryConfigOption_shouldFailWhenOptionIsMissingRequiredFileNameParam() { final String[] argsWithSentryConfigMissingParam = new String[] { - "vc", "--network", "minimal", "--sentry-config-file", + "vc", "--network", "minimal", "--validator-keys=keys:pass", "--sentry-config-file", }; int parseResult = beaconNodeCommand.parse(argsWithSentryConfigMissingParam); @@ -119,6 +124,7 @@ public void shouldThrowErrorWhenUsingBeaconNodeEndpointAndSentryNodesConfig() { "vc", "--network", "minimal", + "--validator-keys=keys:pass", "--beacon-node-api-endpoint", "http://127.0.0.1:1234", "--sentry-config-file", @@ -141,7 +147,12 @@ public void dutiesProviderSentryNodeEndpointIsUsedAsMainBeaconNodeApiEndpoint() final URI expectedBeaconNodeApiEndpoint = URI.create("http://duties:5051"); final String[] args = { - "vc", "--network", "minimal", "--sentry-config-file", pathFor("sentry_node_config.json") + "vc", + "--network", + "minimal", + "--validator-keys=keys:pass", + "--sentry-config-file", + pathFor("sentry_node_config.json") }; final TekuConfiguration tekuConfig = getTekuConfigurationFromArguments(args); @@ -153,7 +164,7 @@ public void dutiesProviderSentryNodeEndpointIsUsedAsMainBeaconNodeApiEndpoint() @Test public void doppelgangerDetectionShouldBeDisabledByDefault() { - final String[] args = {"vc", "--network", "minimal"}; + final String[] args = {"vc", "--network", "minimal", "--validator-keys=keys:pass"}; final TekuConfiguration tekuConfig = getTekuConfigurationFromArguments(args); @@ -165,7 +176,12 @@ public void doppelgangerDetectionShouldBeDisabledByDefault() { public void shouldEnableDoppelgangerDetection() { final String[] args = { - "vc", "--network", "minimal", "--doppelganger-detection-enabled", "true" + "vc", + "--network", + "minimal", + "--validator-keys=keys:pass", + "--doppelganger-detection-enabled", + "true" }; final TekuConfiguration tekuConfig = getTekuConfigurationFromArguments(args); @@ -177,7 +193,7 @@ public void shouldEnableDoppelgangerDetection() { @Test public void clientExecutorThreadsShouldBeDefaultValue() { - final String[] args = {"vc", "--network", "minimal"}; + final String[] args = {"vc", "--network", "minimal", "--validator-keys=keys:pass"}; final TekuConfiguration tekuConfig = getTekuConfigurationFromArguments(args); @@ -190,7 +206,12 @@ public void clientExecutorThreadsShouldBeDefaultValue() { public void clientExecutorThreadsShouldBeSetValue() { final String[] args = { - "vc", "--network", "minimal", "--Xvalidator-client-executor-threads", "1000" + "vc", + "--validator-keys=keys:pass", + "--network", + "minimal", + "--Xvalidator-client-executor-threads", + "1000" }; final TekuConfiguration tekuConfig = getTekuConfigurationFromArguments(args); @@ -202,7 +223,12 @@ public void clientExecutorThreadsShouldBeSetValue() { @Test public void clientExecutorThreadsShouldThrowOverLimit() { final String[] args = { - "vc", "--network", "minimal", "--Xvalidator-client-executor-threads", "6000" + "vc", + "--network", + "minimal", + "--validator-keys=keys:pass", + "--Xvalidator-client-executor-threads", + "6000" }; int parseResult = beaconNodeCommand.parse(args); @@ -215,7 +241,9 @@ public void clientExecutorThreadsShouldThrowOverLimit() { @Test public void shouldSetUseObolDvtSelectionsEndpoint() { - final String[] args = {"vc", "--network", "minimal", "--Xobol-dvt-integration-enabled"}; + final String[] args = { + "vc", "--network", "minimal", "--validator-keys=keys:pass", "--Xobol-dvt-integration-enabled" + }; final TekuConfiguration config = getTekuConfigurationFromArguments(args); assertThat(config.validatorClient().getValidatorConfig().isDvtSelectionsEndpointEnabled()) @@ -224,12 +252,55 @@ public void shouldSetUseObolDvtSelectionsEndpoint() { @Test public void shouldNotUseObolDvtSelectionsEndpointByDefault() { - final String[] args = {"vc", "--network", "minimal"}; + final String[] args = {"vc", "--network", "minimal", "--validator-keys=keys:pass"}; final TekuConfiguration config = getTekuConfigurationFromArguments(args); assertThat(config.validatorClient().getValidatorConfig().isDvtSelectionsEndpointEnabled()) .isFalse(); } + @Test + public void shouldFail_IfNoValidatorKeysSourceProvided() { + final String[] argsNetworkOptOnParent = new String[] {"vc", "--network", "minimal"}; + int parseResult = beaconNodeCommand.parse(argsNetworkOptOnParent); + assertThat(parseResult).isEqualTo(2); + String cmdOutput = getCommandLineOutput(); + assertThat(cmdOutput) + .contains( + "No validator keys source provided, should provide local or remote keys otherwise enable the key-manager" + + " api to start the validator client"); + } + + @Test + public void shouldNotFail_IfNoLocalValidatorKeys_ValidatorRestApiEnabled( + @TempDir final Path tempPath) throws IOException { + AssertionsForClassTypes.assertThat(tempPath.resolve("keystore").toFile().createNewFile()) + .isTrue(); + AssertionsForClassTypes.assertThat(tempPath.resolve("pass").toFile().createNewFile()).isTrue(); + final String[] argsNetworkOptOnParent = + new String[] { + "vc", + "--network", + "minimal", + "--validator-api-enabled=true", + "--validator-api-keystore-file", + tempPath.resolve("keystore").toString(), + "--validator-api-keystore-password-file", + tempPath.resolve("pass").toString() + }; + int parseResult = beaconNodeCommand.parse(argsNetworkOptOnParent); + assertThat(parseResult).isEqualTo(0); + } + + @Test + public void shouldNotFail_IfNoLocalValidatorKeys_ExternalSignerUrlProvided() { + final String[] argsNetworkOptOnParent = + new String[] { + "vc", "--network", "minimal", "--validators-external-signer-url=http://localhost" + }; + int parseResult = beaconNodeCommand.parse(argsNetworkOptOnParent); + assertThat(parseResult).isEqualTo(0); + } + private String pathFor(final String filename) { return Resources.getResource(ValidatorClientCommandTest.class, filename).toString(); } diff --git a/teku/src/test/java/tech/pegasys/teku/cli/subcommand/internal/validator/options/DepositOptionsTest.java b/teku/src/test/java/tech/pegasys/teku/cli/subcommand/internal/validator/options/DepositOptionsTest.java index 88626559ee6..adb7de8a4ad 100644 --- a/teku/src/test/java/tech/pegasys/teku/cli/subcommand/internal/validator/options/DepositOptionsTest.java +++ b/teku/src/test/java/tech/pegasys/teku/cli/subcommand/internal/validator/options/DepositOptionsTest.java @@ -158,8 +158,9 @@ public void shouldUseMaxEffectiveBalanceAsDefaultAmount() { final SpecConfig config = SpecConfigLoader.loadConfig( - Eth2Network.MAINNET.configName(), - builder -> builder.maxEffectiveBalance(expectedAmount)); + Eth2Network.MAINNET.configName(), + builder -> builder.maxEffectiveBalance(expectedAmount)) + .specConfig(); assertThat(depositOptions.getAmount(config)).isEqualTo(expectedAmount); } } diff --git a/teku/src/test/java/tech/pegasys/teku/cli/util/DatabaseMigraterTest.java b/teku/src/test/java/tech/pegasys/teku/cli/util/DatabaseMigraterTest.java index 201b56b3c6c..17942c004d0 100644 --- a/teku/src/test/java/tech/pegasys/teku/cli/util/DatabaseMigraterTest.java +++ b/teku/src/test/java/tech/pegasys/teku/cli/util/DatabaseMigraterTest.java @@ -60,7 +60,7 @@ void setUp() { } @Test - void shouldSupplyOriginalDatabasePath(@TempDir Path tmpDir) throws IOException { + void shouldSupplyOriginalDatabasePath(@TempDir final Path tmpDir) throws IOException { final DataDirLayout dataDirLayout = prepareTempDir(tmpDir, "leveldb1"); final DatabaseMigrater migrater = getDatabaseMigrater(dataDirLayout); @@ -68,7 +68,7 @@ void shouldSupplyOriginalDatabasePath(@TempDir Path tmpDir) throws IOException { } @Test - void shouldSupplyNewDatabasePath(@TempDir Path tmpDir) throws IOException { + void shouldSupplyNewDatabasePath(@TempDir final Path tmpDir) throws IOException { final DataDirLayout dataDirLayout = prepareTempDir(tmpDir, "leveldb1"); final DatabaseMigrater migrater = getDatabaseMigrater(dataDirLayout); @@ -76,7 +76,7 @@ void shouldSupplyNewDatabasePath(@TempDir Path tmpDir) throws IOException { } @Test - void shouldCreateNewDatabaseFolderStructure(@TempDir Path tmpDir) throws IOException { + void shouldCreateNewDatabaseFolderStructure(@TempDir final Path tmpDir) throws IOException { final DataDirLayout dataDirLayout = prepareTempDir(tmpDir, "leveldb1"); final Path generatedDatabase = tmpDir.resolve("beacon.new"); final DatabaseMigrater migrater = getDatabaseMigrater(dataDirLayout); @@ -90,7 +90,7 @@ void shouldCreateNewDatabaseFolderStructure(@TempDir Path tmpDir) throws IOExcep } @Test - void shouldOpenDatabases(@TempDir Path tmpDir) throws IOException, DatabaseMigraterError { + void shouldOpenDatabases(@TempDir final Path tmpDir) throws IOException, DatabaseMigraterError { final DataDirLayout dataDirLayout = prepareTempDir(tmpDir, "5"); final DatabaseMigrater migrater = getDatabaseMigrater(dataDirLayout); @@ -105,7 +105,8 @@ void shouldOpenDatabases(@TempDir Path tmpDir) throws IOException, DatabaseMigra } @Test - void shouldSwapActiveDatabase(@TempDir Path tmpDir) throws IOException, DatabaseMigraterError { + void shouldSwapActiveDatabase(@TempDir final Path tmpDir) + throws IOException, DatabaseMigraterError { final DataDirLayout dataDirLayout = prepareTempDir(tmpDir, "5"); final DatabaseMigrater migrater = getDatabaseMigrater(dataDirLayout); @@ -121,7 +122,7 @@ void shouldSwapActiveDatabase(@TempDir Path tmpDir) throws IOException, Database } @Test - void shouldCopyColumnData(@TempDir Path tmpDir) throws IOException, DatabaseMigraterError { + void shouldCopyColumnData(@TempDir final Path tmpDir) throws IOException, DatabaseMigraterError { final DataDirLayout dataDirLayout = prepareTempDir(tmpDir, "5"); DatabaseMigrater migrater = getDatabaseMigrater(dataDirLayout); final BeaconBlockAndState blockAndState = dataStructureUtil.randomBlockAndState(1_000_000); @@ -140,7 +141,7 @@ void shouldCopyColumnData(@TempDir Path tmpDir) throws IOException, DatabaseMigr } @Test - void shouldCopyVariablesFromHotDb(@TempDir Path tmpDir) throws Exception { + void shouldCopyVariablesFromHotDb(@TempDir final Path tmpDir) throws Exception { final DataDirLayout dataDirLayout = prepareTempDir(tmpDir, "5"); DatabaseMigrater migrater = getDatabaseMigrater(dataDirLayout); final UInt64 genesis = dataStructureUtil.randomUInt64(); diff --git a/teku/src/test/java/tech/pegasys/teku/cli/util/MixinSectionOptionRendererTest.java b/teku/src/test/java/tech/pegasys/teku/cli/util/MixinSectionOptionRendererTest.java index 20a75d9a0f6..478317fbcad 100644 --- a/teku/src/test/java/tech/pegasys/teku/cli/util/MixinSectionOptionRendererTest.java +++ b/teku/src/test/java/tech/pegasys/teku/cli/util/MixinSectionOptionRendererTest.java @@ -71,13 +71,13 @@ private static class TestOptions { private String configFile; @ArgGroup(heading = "%nActual Arg Group", multiplicity = "0..1") - private TestArgGroup argGroup = new TestArgGroup(); + private final TestArgGroup argGroup = new TestArgGroup(); @Mixin(name = "First Mixin") - private Mixin1 mixin1 = new Mixin1(); + private final Mixin1 mixin1 = new Mixin1(); @Mixin(name = "Second Mixin") - private AllHiddenOptions allHiddenOptions = new AllHiddenOptions(); + private final AllHiddenOptions allHiddenOptions = new AllHiddenOptions(); } private static class Mixin1 { diff --git a/teku/src/test/resources/networkOptions_config.yaml b/teku/src/test/resources/networkOptions_config.yaml index a0d836a918c..f6edb44fda8 100644 --- a/teku/src/test/resources/networkOptions_config.yaml +++ b/teku/src/test/resources/networkOptions_config.yaml @@ -1,2 +1,2 @@ # network -network: "prater" \ No newline at end of file +network: "holesky" \ No newline at end of file diff --git a/teku/src/test/resources/tech/pegasys/teku/cli/subcommand/deneb_config.yaml b/teku/src/test/resources/tech/pegasys/teku/cli/subcommand/deneb_config.yaml index da66fcfb737..9a15730dcdc 100644 --- a/teku/src/test/resources/tech/pegasys/teku/cli/subcommand/deneb_config.yaml +++ b/teku/src/test/resources/tech/pegasys/teku/cli/subcommand/deneb_config.yaml @@ -138,4 +138,11 @@ MAX_REQUEST_BLOB_SIDECARS: 768 # `2**12` (= 4096 epochs, ~18 days) MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS: 4096 # `6` -BLOB_SIDECAR_SUBNET_COUNT: 6 \ No newline at end of file +BLOB_SIDECAR_SUBNET_COUNT: 6 + +# Electra +MAX_BLOBS_PER_BLOCK_ELECTRA: 6 +# MAX_REQUEST_BLOCKS_DENEB * MAX_BLOBS_PER_BLOCK_ELECTRA +MAX_REQUEST_BLOB_SIDECARS_ELECTRA: 768 +BLOB_SIDECAR_SUBNET_COUNT_ELECTRA: 6 +TARGET_BLOBS_PER_BLOCK_ELECTRA: 3 \ No newline at end of file diff --git a/validator/api/build.gradle b/validator/api/build.gradle index 81089327886..35259afdf27 100644 --- a/validator/api/build.gradle +++ b/validator/api/build.gradle @@ -5,6 +5,7 @@ dependencies { implementation project(':infrastructure:events') implementation project(':infrastructure:exceptions') implementation project(':infrastructure:http') + implementation project(':infrastructure:serviceutils') implementation project(':ethereum:execution-types') implementation project(':ethereum:json-types') implementation project(':ethereum:spec') @@ -13,6 +14,7 @@ dependencies { testImplementation testFixtures(project(':infrastructure:bls')) testImplementation testFixtures(project(':infrastructure:logging')) + testImplementation testFixtures(project(':infrastructure:serviceutils')) testImplementation testFixtures(project(':ethereum:spec')) } diff --git a/validator/api/src/main/java/tech/pegasys/teku/validator/api/CommitteeSubscriptionData.java b/validator/api/src/main/java/tech/pegasys/teku/validator/api/CommitteeSubscriptionData.java new file mode 100644 index 00000000000..a6d8ae43c0c --- /dev/null +++ b/validator/api/src/main/java/tech/pegasys/teku/validator/api/CommitteeSubscriptionData.java @@ -0,0 +1,130 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.api; + +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.BOOLEAN_TYPE; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.INTEGER_TYPE; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; + +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; + +public record CommitteeSubscriptionData( + int validatorIndex, + int committeeIndex, + UInt64 committeesAtSlot, + UInt64 slot, + boolean isAggregator) { + public static final DeserializableTypeDefinition SSZ_DATA = + DeserializableTypeDefinition.object( + CommitteeSubscriptionData.class, CommitteeSubscriptionDataBuilder.class) + .name("CommitteeSubscriptionData") + .initializer(CommitteeSubscriptionDataBuilder::new) + .finisher(CommitteeSubscriptionDataBuilder::build) + .withField( + "validator_index", + INTEGER_TYPE, + CommitteeSubscriptionData::validatorIndex, + CommitteeSubscriptionDataBuilder::validatorIndex) + .withField( + "committee_index", + INTEGER_TYPE, + CommitteeSubscriptionData::committeeIndex, + CommitteeSubscriptionDataBuilder::committeeIndex) + .withField( + "committees_at_slot", + UINT64_TYPE, + CommitteeSubscriptionData::committeesAtSlot, + CommitteeSubscriptionDataBuilder::committeesAtSlot) + .withField( + "slot", + UINT64_TYPE, + CommitteeSubscriptionData::slot, + CommitteeSubscriptionDataBuilder::slot) + .withField( + "is_aggregator", + BOOLEAN_TYPE, + CommitteeSubscriptionData::isAggregator, + CommitteeSubscriptionDataBuilder::isAggregator) + .build(); + + public static CommitteeSubscriptionData create( + final CommitteeSubscriptionRequest committeeSubscriptionRequest) { + return new CommitteeSubscriptionData( + committeeSubscriptionRequest.getValidatorIndex(), + committeeSubscriptionRequest.getCommitteeIndex(), + committeeSubscriptionRequest.getCommitteesAtSlot(), + committeeSubscriptionRequest.getSlot(), + committeeSubscriptionRequest.isAggregator()); + } + + public CommitteeSubscriptionRequest toCommitteeSubscriptionRequest() { + return new CommitteeSubscriptionRequest( + validatorIndex, committeeIndex, committeesAtSlot, slot, isAggregator); + } + + @Override + public String toString() { + return "CommitteeSubscriptionData{" + + "validatorIndex=" + + validatorIndex + + ", committeeIndex=" + + committeeIndex + + ", committeesAtSlot=" + + committeesAtSlot + + ", slot=" + + slot + + ", isAggregator=" + + isAggregator + + '}'; + } + + static class CommitteeSubscriptionDataBuilder { + private int validatorIndex; + private int committeeIndex; + private UInt64 committeesAtSlot; + private UInt64 slot; + private boolean isAggregator; + + public CommitteeSubscriptionDataBuilder validatorIndex(final int validatorIndex) { + this.validatorIndex = validatorIndex; + return this; + } + + public CommitteeSubscriptionDataBuilder committeeIndex(final int committeeIndex) { + this.committeeIndex = committeeIndex; + return this; + } + + public CommitteeSubscriptionDataBuilder committeesAtSlot(final UInt64 committeesAtSlot) { + this.committeesAtSlot = committeesAtSlot; + return this; + } + + public CommitteeSubscriptionDataBuilder slot(final UInt64 slot) { + this.slot = slot; + return this; + } + + public CommitteeSubscriptionDataBuilder isAggregator(final boolean isAggregator) { + this.isAggregator = isAggregator; + return this; + } + + public CommitteeSubscriptionData build() { + return new CommitteeSubscriptionData( + validatorIndex, committeeIndex, committeesAtSlot, slot, isAggregator); + } + } +} diff --git a/validator/api/src/main/java/tech/pegasys/teku/validator/api/GraffitiLoaderException.java b/validator/api/src/main/java/tech/pegasys/teku/validator/api/GraffitiLoaderException.java index 87c85e4fb3b..671e8694031 100644 --- a/validator/api/src/main/java/tech/pegasys/teku/validator/api/GraffitiLoaderException.java +++ b/validator/api/src/main/java/tech/pegasys/teku/validator/api/GraffitiLoaderException.java @@ -14,7 +14,7 @@ package tech.pegasys.teku.validator.api; public class GraffitiLoaderException extends Exception { - public GraffitiLoaderException(String message) { + public GraffitiLoaderException(final String message) { super(message); } diff --git a/validator/api/src/main/java/tech/pegasys/teku/validator/api/GraffitiManagementException.java b/validator/api/src/main/java/tech/pegasys/teku/validator/api/GraffitiManagementException.java new file mode 100644 index 00000000000..d4eccf60f60 --- /dev/null +++ b/validator/api/src/main/java/tech/pegasys/teku/validator/api/GraffitiManagementException.java @@ -0,0 +1,25 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.api; + +public class GraffitiManagementException extends RuntimeException { + + public GraffitiManagementException(final String message) { + super(message); + } + + public GraffitiManagementException(final String message, final Throwable cause) { + super(message, cause); + } +} diff --git a/validator/api/src/main/java/tech/pegasys/teku/validator/api/GraffitiManager.java b/validator/api/src/main/java/tech/pegasys/teku/validator/api/GraffitiManager.java new file mode 100644 index 00000000000..cb670958119 --- /dev/null +++ b/validator/api/src/main/java/tech/pegasys/teku/validator/api/GraffitiManager.java @@ -0,0 +1,97 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.api; + +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.Optional; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.service.serviceutils.layout.DataDirLayout; + +public class GraffitiManager { + private static final Logger LOG = LogManager.getLogger(); + static final String GRAFFITI_DIR = "graffiti"; + private final Path directory; + + public GraffitiManager(final DataDirLayout dataDirLayout) { + this(dataDirLayout.getValidatorDataDirectory().resolve(GRAFFITI_DIR)); + } + + public GraffitiManager(final Path directory) { + this.directory = directory; + if (!directory.toFile().exists() && !directory.toFile().mkdirs()) { + throw new IllegalStateException("Unable to create directory for graffiti management."); + } + } + + public synchronized void setGraffiti(final BLSPublicKey publicKey, final String graffiti) + throws GraffitiManagementException { + final String strippedGraffiti = graffiti.strip(); + final int graffitiSize = strippedGraffiti.getBytes(StandardCharsets.UTF_8).length; + if (graffitiSize > 32) { + throw new IllegalArgumentException( + String.format( + "'%s' converts to %s bytes. Input must be 32 bytes or less.", + strippedGraffiti, graffitiSize)); + } + + try { + final Path file = directory.resolve(resolveFileName(publicKey)); + Files.writeString(file, strippedGraffiti); + } catch (IOException e) { + throw new GraffitiManagementException( + "Unable to update graffiti for validator " + publicKey, e); + } + } + + public synchronized void deleteGraffiti(final BLSPublicKey publicKey) + throws GraffitiManagementException { + final Path file = directory.resolve(resolveFileName(publicKey)); + if (!file.toFile().exists()) { + return; + } + + try { + Files.delete(file); + } catch (IOException e) { + throw new GraffitiManagementException( + "Unable to delete graffiti for validator " + publicKey, e); + } + } + + public synchronized Optional getGraffiti(final BLSPublicKey publicKey) + throws GraffitiManagementException { + final Path filePath = directory.resolve(resolveFileName(publicKey)); + if (!filePath.toFile().exists()) { + return Optional.empty(); + } + + try { + return Optional.of(GraffitiParser.loadFromFile(filePath)); + } catch (GraffitiLoaderException | IllegalArgumentException e) { + LOG.error("Loading graffiti from graffiti storage failed.", e); + throw new GraffitiManagementException( + "Unable to retrieve stored graffiti for validator " + publicKey, e); + } + } + + private String resolveFileName(final BLSPublicKey publicKey) { + return publicKey.toSSZBytes().toUnprefixedHexString() + ".txt"; + } +} diff --git a/validator/api/src/main/java/tech/pegasys/teku/validator/api/InteropConfig.java b/validator/api/src/main/java/tech/pegasys/teku/validator/api/InteropConfig.java index 8c1807182d9..546dfdda747 100644 --- a/validator/api/src/main/java/tech/pegasys/teku/validator/api/InteropConfig.java +++ b/validator/api/src/main/java/tech/pegasys/teku/validator/api/InteropConfig.java @@ -88,7 +88,7 @@ public static final class InteropConfigBuilder { private InteropConfigBuilder() {} - public InteropConfigBuilder interopGenesisTime(Integer interopGenesisTime) { + public InteropConfigBuilder interopGenesisTime(final Integer interopGenesisTime) { if (interopGenesisTime < 0) { throw new InvalidConfigurationException( String.format("Invalid interopGenesisTime: %d", interopGenesisTime)); @@ -103,13 +103,13 @@ public InteropConfigBuilder interopGenesisPayloadHeader( return this; } - public InteropConfigBuilder specProvider(Spec spec) { + public InteropConfigBuilder specProvider(final Spec spec) { this.spec = spec; return this; } public InteropConfigBuilder interopOwnedValidatorStartIndex( - int interopOwnedValidatorStartIndex) { + final int interopOwnedValidatorStartIndex) { if (interopOwnedValidatorStartIndex < 0) { throw new InvalidConfigurationException( String.format( @@ -119,7 +119,7 @@ public InteropConfigBuilder interopOwnedValidatorStartIndex( return this; } - public InteropConfigBuilder interopOwnedValidatorCount(int interopOwnedValidatorCount) { + public InteropConfigBuilder interopOwnedValidatorCount(final int interopOwnedValidatorCount) { if (interopOwnedValidatorCount < 0) { throw new InvalidConfigurationException( String.format("Invalid interopOwnedValidatorCount: %d", interopOwnedValidatorCount)); @@ -128,7 +128,7 @@ public InteropConfigBuilder interopOwnedValidatorCount(int interopOwnedValidator return this; } - public InteropConfigBuilder interopNumberOfValidators(int interopNumberOfValidators) { + public InteropConfigBuilder interopNumberOfValidators(final int interopNumberOfValidators) { if (interopNumberOfValidators < 0) { throw new InvalidConfigurationException( String.format("Invalid interopNumberOfValidators: %d", interopNumberOfValidators)); @@ -137,7 +137,7 @@ public InteropConfigBuilder interopNumberOfValidators(int interopNumberOfValidat return this; } - public InteropConfigBuilder interopEnabled(boolean interopEnabled) { + public InteropConfigBuilder interopEnabled(final boolean interopEnabled) { this.interopEnabled = interopEnabled; return this; } diff --git a/validator/api/src/main/java/tech/pegasys/teku/validator/api/KeyStoreFilesLocator.java b/validator/api/src/main/java/tech/pegasys/teku/validator/api/KeyStoreFilesLocator.java index 8e0a5be5847..4e721e03361 100644 --- a/validator/api/src/main/java/tech/pegasys/teku/validator/api/KeyStoreFilesLocator.java +++ b/validator/api/src/main/java/tech/pegasys/teku/validator/api/KeyStoreFilesLocator.java @@ -59,7 +59,7 @@ public List> parse() { } private void parseEntry( - final String keyFileName, final String passwordFileName, Map pathMap) { + final String keyFileName, final String passwordFileName, final Map pathMap) { final File keyFile = new File(keyFileName); final File passwordFile = new File(passwordFileName); @@ -114,7 +114,7 @@ private boolean hasDepositDataFileContents(final File keyFile) { } private void parseDirectory( - final File keyDirectory, final File passwordDirectory, Map pathMap) { + final File keyDirectory, final File passwordDirectory, final Map pathMap) { try (Stream walk = Files.walk(keyDirectory.toPath(), FileVisitOption.FOLLOW_LINKS)) { walk.filter(Files::isRegularFile) .filter( @@ -149,7 +149,7 @@ private void parseDirectory( } } - private List> getFilePairs(Map pathMap) { + private List> getFilePairs(final Map pathMap) { return pathMap.entrySet().stream() .map(entry -> Pair.of(entry.getKey(), entry.getValue())) .toList(); diff --git a/validator/api/src/main/java/tech/pegasys/teku/validator/api/SubmitDataError.java b/validator/api/src/main/java/tech/pegasys/teku/validator/api/SubmitDataError.java index b950c05adbb..8cf5dc30e99 100644 --- a/validator/api/src/main/java/tech/pegasys/teku/validator/api/SubmitDataError.java +++ b/validator/api/src/main/java/tech/pegasys/teku/validator/api/SubmitDataError.java @@ -16,49 +16,19 @@ import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.STRING_TYPE; import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; -import java.util.Objects; -import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -public class SubmitDataError { - private final UInt64 index; - private final String message; +public record SubmitDataError(UInt64 index, String message) { - public SubmitDataError(final UInt64 index, final String message) { - this.index = index; - this.message = message; - } - - @Override - public boolean equals(final Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - final SubmitDataError that = (SubmitDataError) o; - return Objects.equals(index, that.index) && Objects.equals(message, that.message); - } - - @Override - public int hashCode() { - return Objects.hash(index, message); - } - - public UInt64 getIndex() { - return index; - } - - public String getMessage() { - return message; - } - - public static SerializableTypeDefinition getJsonTypeDefinition() { - return SerializableTypeDefinition.object(SubmitDataError.class) + public static DeserializableTypeDefinition getJsonTypeDefinition() { + return DeserializableTypeDefinition.object(SubmitDataError.class, SubmitDataErrorBuilder.class) .name("SubmitDataError") - .withField("index", UINT64_TYPE, SubmitDataError::getIndex) - .withField("message", STRING_TYPE, SubmitDataError::getMessage) + .initializer(SubmitDataErrorBuilder::new) + .finisher(SubmitDataErrorBuilder::build) + .withField("index", UINT64_TYPE, SubmitDataError::index, SubmitDataErrorBuilder::index) + .withField( + "message", STRING_TYPE, SubmitDataError::message, SubmitDataErrorBuilder::message) .build(); } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/validator/GetAggregatedAttestationResponse.java b/validator/api/src/main/java/tech/pegasys/teku/validator/api/SubmitDataErrorBuilder.java similarity index 51% rename from data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/validator/GetAggregatedAttestationResponse.java rename to validator/api/src/main/java/tech/pegasys/teku/validator/api/SubmitDataErrorBuilder.java index 99b5bb68408..b81f62712e9 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v1/validator/GetAggregatedAttestationResponse.java +++ b/validator/api/src/main/java/tech/pegasys/teku/validator/api/SubmitDataErrorBuilder.java @@ -1,5 +1,5 @@ /* - * Copyright Consensys Software Inc., 2022 + * Copyright Consensys Software Inc., 2024 * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at @@ -11,22 +11,25 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.api.response.v1.validator; +package tech.pegasys.teku.validator.api; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import tech.pegasys.teku.api.schema.Attestation; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; -public class GetAggregatedAttestationResponse { - @JsonProperty("data") - public final Attestation data; +public class SubmitDataErrorBuilder { + private String message; + private UInt64 index; - @JsonCreator - public GetAggregatedAttestationResponse(@JsonProperty("data") final Attestation data) { - this.data = data; + public SubmitDataErrorBuilder index(final UInt64 index) { + this.index = index; + return this; } - public Attestation getData() { - return data; + public SubmitDataErrorBuilder message(final String message) { + this.message = message; + return this; + } + + public SubmitDataError build() { + return new SubmitDataError(index, message); } } diff --git a/validator/api/src/main/java/tech/pegasys/teku/validator/api/SyncCommitteeSubnetSubscription.java b/validator/api/src/main/java/tech/pegasys/teku/validator/api/SyncCommitteeSubnetSubscription.java deleted file mode 100644 index 511b92ceb5b..00000000000 --- a/validator/api/src/main/java/tech/pegasys/teku/validator/api/SyncCommitteeSubnetSubscription.java +++ /dev/null @@ -1,62 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.validator.api; - -import it.unimi.dsi.fastutil.ints.IntSet; -import java.util.Objects; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; - -public class SyncCommitteeSubnetSubscription { - private final int validatorIndex; - private final IntSet syncCommitteeIndices; - private final UInt64 untilEpoch; - - public SyncCommitteeSubnetSubscription( - final int validatorIndex, final IntSet syncCommitteeIndices, final UInt64 untilEpoch) { - this.validatorIndex = validatorIndex; - this.syncCommitteeIndices = syncCommitteeIndices; - this.untilEpoch = untilEpoch; - } - - public int getValidatorIndex() { - return validatorIndex; - } - - public IntSet getSyncCommitteeIndices() { - return syncCommitteeIndices; - } - - public UInt64 getUntilEpoch() { - return untilEpoch; - } - - @Override - public boolean equals(final Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - final SyncCommitteeSubnetSubscription that = (SyncCommitteeSubnetSubscription) o; - return validatorIndex == that.validatorIndex - && Objects.equals(syncCommitteeIndices, that.syncCommitteeIndices) - && Objects.equals(untilEpoch, that.untilEpoch); - } - - @Override - public int hashCode() { - return Objects.hash(validatorIndex, syncCommitteeIndices, untilEpoch); - } -} diff --git a/validator/api/src/main/java/tech/pegasys/teku/validator/api/UpdatableGraffitiProvider.java b/validator/api/src/main/java/tech/pegasys/teku/validator/api/UpdatableGraffitiProvider.java new file mode 100644 index 00000000000..fe54d2bc7f6 --- /dev/null +++ b/validator/api/src/main/java/tech/pegasys/teku/validator/api/UpdatableGraffitiProvider.java @@ -0,0 +1,49 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.api; + +import java.util.Optional; +import java.util.function.Supplier; +import org.apache.tuweni.bytes.Bytes32; + +public class UpdatableGraffitiProvider implements GraffitiProvider { + private final Supplier> storageProvider; + private final GraffitiProvider defaultProvider; + + public UpdatableGraffitiProvider( + final Supplier> storageProvider, final GraffitiProvider defaultProvider) { + this.storageProvider = storageProvider; + this.defaultProvider = defaultProvider; + } + + @Override + public Optional get() { + return getFromStorage().or(defaultProvider::get); + } + + private Optional getFromStorage() { + try { + return storageProvider.get(); + } catch (Exception e) { + return Optional.empty(); + } + } + + /** + * @return graffiti without checking for thrown Exceptions. + */ + public Optional getUnsafe() { + return storageProvider.get().or(defaultProvider::get); + } +} diff --git a/validator/api/src/main/java/tech/pegasys/teku/validator/api/ValidatorApiChannel.java b/validator/api/src/main/java/tech/pegasys/teku/validator/api/ValidatorApiChannel.java index 0b4dcf18981..680153a8ed4 100644 --- a/validator/api/src/main/java/tech/pegasys/teku/validator/api/ValidatorApiChannel.java +++ b/validator/api/src/main/java/tech/pegasys/teku/validator/api/ValidatorApiChannel.java @@ -24,11 +24,13 @@ import tech.pegasys.teku.api.response.v1.beacon.ValidatorStatus; import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.bls.BLSSignature; +import tech.pegasys.teku.ethereum.json.types.node.PeerCount; import tech.pegasys.teku.ethereum.json.types.validator.AttesterDuties; import tech.pegasys.teku.ethereum.json.types.validator.BeaconCommitteeSelectionProof; import tech.pegasys.teku.ethereum.json.types.validator.ProposerDuties; import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeDuties; import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSelectionProof; +import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.events.ChannelInterface; import tech.pegasys.teku.infrastructure.ssz.SszList; @@ -43,7 +45,7 @@ import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SignedContributionAndProof; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeContribution; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeMessage; -import tech.pegasys.teku.spec.datastructures.operations.versions.bellatrix.BeaconPreparableProposer; +import tech.pegasys.teku.spec.datastructures.validator.BeaconPreparableProposer; import tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel; import tech.pegasys.teku.spec.datastructures.validator.SubnetSubscription; @@ -57,125 +59,131 @@ public SafeFuture> getGenesisData() { @Override public SafeFuture> getValidatorIndices( - Collection publicKeys) { + final Collection publicKeys) { return SafeFuture.completedFuture(Map.of()); } @Override public SafeFuture>> getValidatorStatuses( - Collection validatorIdentifiers) { + final Collection validatorIdentifiers) { return SafeFuture.completedFuture(Optional.empty()); } @Override public SafeFuture> getAttestationDuties( - UInt64 epoch, IntCollection validatorIndices) { + final UInt64 epoch, final IntCollection validatorIndices) { return SafeFuture.completedFuture(Optional.empty()); } @Override public SafeFuture> getSyncCommitteeDuties( - UInt64 epoch, IntCollection validatorIndices) { + final UInt64 epoch, final IntCollection validatorIndices) { return SafeFuture.completedFuture(Optional.empty()); } @Override - public SafeFuture> getProposerDuties(UInt64 epoch) { + public SafeFuture> getProposerDuties(final UInt64 epoch) { + return SafeFuture.completedFuture(Optional.empty()); + } + + @Override + public SafeFuture> getPeerCount() { return SafeFuture.completedFuture(Optional.empty()); } @Override public SafeFuture> createUnsignedBlock( - UInt64 slot, - BLSSignature randaoReveal, - Optional graffiti, - Optional requestedBlinded, - Optional requestedBuilderBoostFactor) { + final UInt64 slot, + final BLSSignature randaoReveal, + final Optional graffiti, + final Optional requestedBuilderBoostFactor) { return SafeFuture.completedFuture(Optional.empty()); } @Override public SafeFuture> createAttestationData( - UInt64 slot, int committeeIndex) { + final UInt64 slot, final int committeeIndex) { return SafeFuture.completedFuture(Optional.empty()); } @Override public SafeFuture> createAggregate( - UInt64 slot, Bytes32 attestationHashTreeRoot) { + final UInt64 slot, + final Bytes32 attestationHashTreeRoot, + final Optional committeeIndex) { return SafeFuture.completedFuture(Optional.empty()); } @Override public SafeFuture> createSyncCommitteeContribution( - UInt64 slot, int subcommitteeIndex, Bytes32 beaconBlockRoot) { + final UInt64 slot, final int subcommitteeIndex, final Bytes32 beaconBlockRoot) { return SafeFuture.completedFuture(Optional.empty()); } @Override public SafeFuture subscribeToBeaconCommittee( - List requests) { + final List requests) { return SafeFuture.COMPLETE; } @Override public SafeFuture subscribeToSyncCommitteeSubnets( - Collection subscriptions) { + final Collection subscriptions) { return SafeFuture.COMPLETE; } @Override public SafeFuture subscribeToPersistentSubnets( - Set subnetSubscriptions) { + final Set subnetSubscriptions) { return SafeFuture.COMPLETE; } @Override public SafeFuture> sendSignedAttestations( - List attestations) { + final List attestations) { return SafeFuture.completedFuture(List.of()); } @Override public SafeFuture> sendAggregateAndProofs( - List aggregateAndProofs) { + final List aggregateAndProofs) { return SafeFuture.completedFuture(List.of()); } @Override public SafeFuture sendSignedBlock( - SignedBlockContainer blockContainer, - BroadcastValidationLevel broadcastValidationLevel) { + final SignedBlockContainer blockContainer, + final BroadcastValidationLevel broadcastValidationLevel) { return SafeFuture.completedFuture(SendSignedBlockResult.rejected("NO OP Implementation")); } @Override public SafeFuture> sendSyncCommitteeMessages( - List syncCommitteeMessages) { + final List syncCommitteeMessages) { return SafeFuture.completedFuture(List.of()); } @Override public SafeFuture sendSignedContributionAndProofs( - Collection signedContributionAndProofs) { + final Collection signedContributionAndProofs) { return SafeFuture.COMPLETE; } @Override public SafeFuture prepareBeaconProposer( - Collection beaconPreparableProposers) { + final Collection beaconPreparableProposers) { return SafeFuture.COMPLETE; } @Override public SafeFuture registerValidators( - SszList validatorRegistrations) { + final SszList validatorRegistrations) { return SafeFuture.COMPLETE; } @Override public SafeFuture>> getValidatorsLiveness( - List validatorIndices, UInt64 epoch) { + final List validatorIndices, final UInt64 epoch) { return SafeFuture.completedFuture(Optional.empty()); } @@ -209,20 +217,18 @@ SafeFuture> getSyncCommitteeDuties( SafeFuture> getProposerDuties(UInt64 epoch); - /** - * @param requestedBlinded can be removed once block creation V2 APIs are removed in favour of V3 - * only - */ + SafeFuture> getPeerCount(); + SafeFuture> createUnsignedBlock( UInt64 slot, BLSSignature randaoReveal, Optional graffiti, - Optional requestedBlinded, Optional requestedBuilderBoostFactor); SafeFuture> createAttestationData(UInt64 slot, int committeeIndex); - SafeFuture> createAggregate(UInt64 slot, Bytes32 attestationHashTreeRoot); + SafeFuture> createAggregate( + UInt64 slot, Bytes32 attestationHashTreeRoot, Optional committeeIndex); SafeFuture> createSyncCommitteeContribution( UInt64 slot, int subcommitteeIndex, Bytes32 beaconBlockRoot); diff --git a/validator/api/src/main/java/tech/pegasys/teku/validator/api/ValidatorConfig.java b/validator/api/src/main/java/tech/pegasys/teku/validator/api/ValidatorConfig.java index 379ee28c3e6..059d5487435 100644 --- a/validator/api/src/main/java/tech/pegasys/teku/validator/api/ValidatorConfig.java +++ b/validator/api/src/main/java/tech/pegasys/teku/validator/api/ValidatorConfig.java @@ -18,6 +18,7 @@ import java.net.MalformedURLException; import java.net.URI; +import java.net.URISyntaxException; import java.net.URL; import java.nio.file.Path; import java.time.Duration; @@ -25,6 +26,7 @@ import java.util.List; import java.util.Locale; import java.util.Optional; +import java.util.OptionalInt; import org.apache.commons.lang3.tuple.Pair; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; @@ -45,7 +47,6 @@ public class ValidatorConfig { List.of(URI.create("http://127.0.0.1:" + DEFAULT_REST_API_PORT)); public static final boolean DEFAULT_FAILOVERS_SEND_SUBNET_SUBSCRIPTIONS_ENABLED = true; public static final boolean DEFAULT_FAILOVERS_PUBLISH_SIGNED_DUTIES_ENABLED = true; - public static final boolean DEFAULT_BLOCK_V3_ENABLED = false; public static final boolean DEFAULT_EXIT_WHEN_NO_VALIDATOR_KEYS_ENABLED = false; public static final boolean DEFAULT_VALIDATOR_CLIENT_SSZ_BLOCKS_ENABLED = true; public static final boolean DEFAULT_VALIDATOR_CLIENT_USE_POST_VALIDATORS_ENDPOINT_ENABLED = true; @@ -54,6 +55,7 @@ public class ValidatorConfig { public static final boolean DEFAULT_VALIDATOR_IS_LOCAL_SLASHING_PROTECTION_SYNCHRONIZED_ENABLED = true; public static final int DEFAULT_EXECUTOR_MAX_QUEUE_SIZE = 40_000; + public static final int DEFAULT_EXECUTOR_MAX_QUEUE_SIZE_ALL_SUBNETS = 60_000; public static final Duration DEFAULT_VALIDATOR_EXTERNAL_SIGNER_TIMEOUT = Duration.ofSeconds(5); public static final int DEFAULT_VALIDATOR_EXTERNAL_SIGNER_CONCURRENT_REQUEST_LIMIT = 32; public static final boolean DEFAULT_VALIDATOR_KEYSTORE_LOCKING_ENABLED = true; @@ -68,6 +70,7 @@ public class ValidatorConfig { public static final int DEFAULT_VALIDATOR_REGISTRATION_SENDING_BATCH_SIZE = 100; public static final UInt64 DEFAULT_BUILDER_REGISTRATION_GAS_LIMIT = UInt64.valueOf(30_000_000); public static final boolean DEFAULT_OBOL_DVT_SELECTIONS_ENDPOINT_ENABLED = false; + public static final boolean DEFAULT_ATTESTATIONS_V2_APIS_ENABLED = false; private final List validatorKeys; private final List validatorExternalSignerPublicKeySources; @@ -96,7 +99,6 @@ public class ValidatorConfig { private final boolean doppelgangerDetectionEnabled; private final boolean failoversSendSubnetSubscriptionsEnabled; private final boolean failoversPublishSignedDutiesEnabled; - private final boolean blockV3Enabled; private final boolean exitWhenNoValidatorKeysEnabled; private final boolean shutdownWhenValidatorSlashedEnabled; private final UInt64 builderRegistrationDefaultGasLimit; @@ -110,6 +112,7 @@ public class ValidatorConfig { private final boolean isLocalSlashingProtectionSynchronizedModeEnabled; private final boolean dvtSelectionsEndpointEnabled; + private final boolean attestationsV2ApisEnabled; private ValidatorConfig( final List validatorKeys, @@ -139,7 +142,6 @@ private ValidatorConfig( final boolean doppelgangerDetectionEnabled, final boolean failoversSendSubnetSubscriptionsEnabled, final boolean failoversPublishSignedDutiesEnabled, - final boolean blockV3Enabled, final boolean exitWhenNoValidatorKeysEnabled, final boolean shutdownWhenValidatorSlashedEnabled, final UInt64 builderRegistrationDefaultGasLimit, @@ -149,8 +151,9 @@ private ValidatorConfig( final int executorMaxQueueSize, final int executorThreads, final Optional sentryNodeConfigurationFile, - boolean isLocalSlashingProtectionSynchronizedModeEnabled, - boolean dvtSelectionsEndpointEnabled) { + final boolean isLocalSlashingProtectionSynchronizedModeEnabled, + final boolean dvtSelectionsEndpointEnabled, + final boolean attestationsV2ApisEnabled) { this.validatorKeys = validatorKeys; this.validatorExternalSignerPublicKeySources = validatorExternalSignerPublicKeySources; this.validatorExternalSignerUrl = validatorExternalSignerUrl; @@ -182,7 +185,6 @@ private ValidatorConfig( this.doppelgangerDetectionEnabled = doppelgangerDetectionEnabled; this.failoversSendSubnetSubscriptionsEnabled = failoversSendSubnetSubscriptionsEnabled; this.failoversPublishSignedDutiesEnabled = failoversPublishSignedDutiesEnabled; - this.blockV3Enabled = blockV3Enabled; this.exitWhenNoValidatorKeysEnabled = exitWhenNoValidatorKeysEnabled; this.shutdownWhenValidatorSlashedEnabled = shutdownWhenValidatorSlashedEnabled; this.builderRegistrationDefaultGasLimit = builderRegistrationDefaultGasLimit; @@ -195,6 +197,10 @@ private ValidatorConfig( this.isLocalSlashingProtectionSynchronizedModeEnabled = isLocalSlashingProtectionSynchronizedModeEnabled; this.dvtSelectionsEndpointEnabled = dvtSelectionsEndpointEnabled; + this.attestationsV2ApisEnabled = attestationsV2ApisEnabled; + + LOG.debug( + "Executor queue - {} threads, max queue size {} ", executorThreads, executorMaxQueueSize); } public static Builder builder() { @@ -320,10 +326,6 @@ public boolean isFailoversPublishSignedDutiesEnabled() { return failoversPublishSignedDutiesEnabled; } - public boolean isBlockV3Enabled() { - return blockV3Enabled; - } - public boolean isExitWhenNoValidatorKeysEnabled() { return exitWhenNoValidatorKeysEnabled; } @@ -365,6 +367,10 @@ public boolean isDvtSelectionsEndpointEnabled() { return dvtSelectionsEndpointEnabled; } + public boolean isAttestationsV2ApisEnabled() { + return attestationsV2ApisEnabled; + } + public static final class Builder { private List validatorKeys = new ArrayList<>(); private List validatorExternalSignerPublicKeySources = new ArrayList<>(); @@ -403,7 +409,6 @@ public static final class Builder { DEFAULT_FAILOVERS_SEND_SUBNET_SUBSCRIPTIONS_ENABLED; private boolean failoversPublishSignedDutiesEnabled = DEFAULT_FAILOVERS_PUBLISH_SIGNED_DUTIES_ENABLED; - private boolean blockV3Enabled = DEFAULT_BLOCK_V3_ENABLED; private boolean exitWhenNoValidatorKeysEnabled = DEFAULT_EXIT_WHEN_NO_VALIDATOR_KEYS_ENABLED; private boolean shutdownWhenValidatorSlashedEnabled = DEFAULT_SHUTDOWN_WHEN_VALIDATOR_SLASHED_ENABLED; @@ -412,22 +417,23 @@ public static final class Builder { DEFAULT_VALIDATOR_REGISTRATION_SENDING_BATCH_SIZE; private Optional builderRegistrationTimestampOverride = Optional.empty(); private Optional builderRegistrationPublicKeyOverride = Optional.empty(); - private int executorMaxQueueSize = DEFAULT_EXECUTOR_MAX_QUEUE_SIZE; + private OptionalInt executorMaxQueueSize = OptionalInt.empty(); private Optional sentryNodeConfigurationFile = Optional.empty(); private int executorThreads = DEFAULT_VALIDATOR_EXECUTOR_THREADS; private boolean isLocalSlashingProtectionSynchronizedModeEnabled = DEFAULT_VALIDATOR_IS_LOCAL_SLASHING_PROTECTION_SYNCHRONIZED_ENABLED; private boolean dvtSelectionsEndpointEnabled = DEFAULT_OBOL_DVT_SELECTIONS_ENDPOINT_ENABLED; + private boolean attestationsV2ApisEnabled = DEFAULT_ATTESTATIONS_V2_APIS_ENABLED; private Builder() {} - public Builder validatorKeys(List validatorKeys) { + public Builder validatorKeys(final List validatorKeys) { this.validatorKeys = validatorKeys; return this; } public Builder validatorExternalSignerPublicKeySources( - List validatorExternalSignerPublicKeySources) { + final List validatorExternalSignerPublicKeySources) { checkNotNull(validatorExternalSignerPublicKeySources); this.validatorExternalSignerPublicKeySources = validatorExternalSignerPublicKeySources; return this; @@ -460,7 +466,7 @@ public Builder validatorExternalSignerTimeout(final Duration validatorExternalSi } public Builder validatorExternalSignerConcurrentRequestLimit( - int validatorExternalSignerConcurrentRequestLimit) { + final int validatorExternalSignerConcurrentRequestLimit) { if (validatorExternalSignerConcurrentRequestLimit < 0) { throw new InvalidConfigurationException( String.format( @@ -604,11 +610,6 @@ public Builder failoversPublishSignedDutiesEnabled( return this; } - public Builder blockV3enabled(final boolean useBlockV3) { - this.blockV3Enabled = useBlockV3; - return this; - } - public Builder exitWhenNoValidatorKeysEnabled(final boolean exitWhenNoValidatorKeysEnabled) { this.exitWhenNoValidatorKeysEnabled = exitWhenNoValidatorKeysEnabled; return this; @@ -648,7 +649,14 @@ public Builder builderRegistrationPublicKeyOverride( } public Builder executorMaxQueueSize(final int executorMaxQueueSize) { - this.executorMaxQueueSize = executorMaxQueueSize; + this.executorMaxQueueSize = OptionalInt.of(executorMaxQueueSize); + return this; + } + + public Builder executorMaxQueueSizeIfDefault(final int executorMaxQueueSize) { + if (this.executorMaxQueueSize.isEmpty()) { + this.executorMaxQueueSize(executorMaxQueueSize); + } return this; } @@ -669,6 +677,11 @@ public Builder obolDvtSelectionsEndpointEnabled(final boolean dvtSelectionsEndpo return this; } + public Builder attestationsV2ApisEnabled(final boolean attestationsV2ApisEnabled) { + this.attestationsV2ApisEnabled = attestationsV2ApisEnabled; + return this; + } + public ValidatorConfig build() { validateExternalSignerUrlAndPublicKeys(); validateExternalSignerKeystoreAndPasswordFileConfig(); @@ -703,18 +716,18 @@ public ValidatorConfig build() { doppelgangerDetectionEnabled, failoversSendSubnetSubscriptionsEnabled, failoversPublishSignedDutiesEnabled, - blockV3Enabled, exitWhenNoValidatorKeysEnabled, shutdownWhenValidatorSlashedEnabled, builderRegistrationDefaultGasLimit, builderRegistrationSendingBatchSize, builderRegistrationTimestampOverride, builderRegistrationPublicKeyOverride, - executorMaxQueueSize, + executorMaxQueueSize.orElse(DEFAULT_EXECUTOR_MAX_QUEUE_SIZE), executorThreads, sentryNodeConfigurationFile, isLocalSlashingProtectionSynchronizedModeEnabled, - dvtSelectionsEndpointEnabled); + dvtSelectionsEndpointEnabled, + attestationsV2ApisEnabled); } private void validateExternalSignerUrlAndPublicKeys() { @@ -732,12 +745,12 @@ private void validateExternalSignerUrlAndPublicKeys() { source -> { if (source.contains(":")) { try { - final URL url = new URL(source); + final URL url = new URI(source).toURL(); if (hostAndPortMatching(url, validatorExternalSignerUrl)) { LOG.warn( "'--validators-external-signer-public-keys' contains an URL matching the external-signer-url host and port. Use 'external-signer' instead if you want to use all public keys exposed by the external signer"); } - } catch (MalformedURLException e) { + } catch (MalformedURLException | URISyntaxException e) { throw new InvalidConfigurationException( "Invalid configuration. '--validators-external-signer-public-keys' contains a malformed URL: " + source); diff --git a/validator/api/src/main/java/tech/pegasys/teku/validator/api/noop/NoOpGraffitiManager.java b/validator/api/src/main/java/tech/pegasys/teku/validator/api/noop/NoOpGraffitiManager.java new file mode 100644 index 00000000000..cf553f6707a --- /dev/null +++ b/validator/api/src/main/java/tech/pegasys/teku/validator/api/noop/NoOpGraffitiManager.java @@ -0,0 +1,37 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.api.noop; + +import java.nio.file.Path; +import java.util.Optional; +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.validator.api.GraffitiManager; + +public class NoOpGraffitiManager extends GraffitiManager { + public NoOpGraffitiManager() { + super(Path.of(".")); + } + + @Override + public void setGraffiti(final BLSPublicKey publicKey, final String graffiti) {} + + @Override + public void deleteGraffiti(final BLSPublicKey publicKey) {} + + @Override + public Optional getGraffiti(final BLSPublicKey publicKey) { + return Optional.empty(); + } +} diff --git a/validator/api/src/main/java/tech/pegasys/teku/validator/api/signer/AggregationSlotWrapper.java b/validator/api/src/main/java/tech/pegasys/teku/validator/api/signer/AggregationSlotWrapper.java new file mode 100644 index 00000000000..a5aa76aeb54 --- /dev/null +++ b/validator/api/src/main/java/tech/pegasys/teku/validator/api/signer/AggregationSlotWrapper.java @@ -0,0 +1,42 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.api.signer; + +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; + +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; + +public record AggregationSlotWrapper(UInt64 slot) { + public static DeserializableTypeDefinition getJsonTypeDefinition() { + return DeserializableTypeDefinition.object(AggregationSlotWrapper.class, Builder.class) + .initializer(Builder::new) + .finisher(Builder::build) + .withField("slot", UINT64_TYPE, AggregationSlotWrapper::slot, Builder::slot) + .build(); + } + + static class Builder { + private UInt64 slot; + + Builder slot(final UInt64 slot) { + this.slot = slot; + return this; + } + + AggregationSlotWrapper build() { + return new AggregationSlotWrapper(slot); + } + } +} diff --git a/validator/api/src/main/java/tech/pegasys/teku/validator/api/signer/BlockWrapper.java b/validator/api/src/main/java/tech/pegasys/teku/validator/api/signer/BlockWrapper.java new file mode 100644 index 00000000000..6c5e7db082e --- /dev/null +++ b/validator/api/src/main/java/tech/pegasys/teku/validator/api/signer/BlockWrapper.java @@ -0,0 +1,47 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.api.signer; + +import static tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition.enumOf; + +import java.util.Optional; +import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock; +import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlockHeader; + +public record BlockWrapper( + SpecMilestone milestone, Optional block, Optional blockHeader) { + public SerializableTypeDefinition getJsonTypeDefinition() { + return SerializableTypeDefinition.object(BlockWrapper.class) + .withField("version", enumOf(SpecMilestone.class), BlockWrapper::milestone) + .withOptionalField(SignType.BLOCK.getName(), getMaybeBlockSchema(), BlockWrapper::block) + .withOptionalField("block_header", getMaybeBlockHeaderSchema(), BlockWrapper::blockHeader) + .build(); + } + + private SerializableTypeDefinition getMaybeBlockSchema() { + return block + .>map( + beaconBlock -> beaconBlock.getSchema().getJsonTypeDefinition()) + .orElse(null); + } + + private SerializableTypeDefinition getMaybeBlockHeaderSchema() { + return blockHeader + .>map( + beaconBlockHeader -> beaconBlockHeader.getSchema().getJsonTypeDefinition()) + .orElse(null); + } +} diff --git a/validator/api/src/main/java/tech/pegasys/teku/validator/api/signer/RandaoRevealWrapper.java b/validator/api/src/main/java/tech/pegasys/teku/validator/api/signer/RandaoRevealWrapper.java new file mode 100644 index 00000000000..c50cb21a82e --- /dev/null +++ b/validator/api/src/main/java/tech/pegasys/teku/validator/api/signer/RandaoRevealWrapper.java @@ -0,0 +1,43 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.api.signer; + +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; + +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; + +public record RandaoRevealWrapper(UInt64 epoch) { + + public static DeserializableTypeDefinition getJsonTypeDefinition() { + return DeserializableTypeDefinition.object(RandaoRevealWrapper.class, Builder.class) + .initializer(Builder::new) + .finisher(Builder::build) + .withField("epoch", UINT64_TYPE, RandaoRevealWrapper::epoch, Builder::epoch) + .build(); + } + + static class Builder { + private UInt64 epoch; + + public Builder epoch(final UInt64 epoch) { + this.epoch = epoch; + return this; + } + + public RandaoRevealWrapper build() { + return new RandaoRevealWrapper(epoch); + } + } +} diff --git a/validator/api/src/main/java/tech/pegasys/teku/validator/api/signer/SignType.java b/validator/api/src/main/java/tech/pegasys/teku/validator/api/signer/SignType.java new file mode 100644 index 00000000000..0fd6843c1b5 --- /dev/null +++ b/validator/api/src/main/java/tech/pegasys/teku/validator/api/signer/SignType.java @@ -0,0 +1,42 @@ +/* + * Copyright Consensys Software Inc., 2022 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.api.signer; + +public enum SignType { + RANDAO_REVEAL("randao_reveal"), + BLOCK("block"), + BLOCK_V2("block_v2"), + ATTESTATION("attestation"), + AGGREGATION_SLOT("aggregation_slot"), + AGGREGATE_AND_PROOF("aggregate_and_proof"), + VOLUNTARY_EXIT("voluntary_exit"), + SYNC_COMMITTEE_MESSAGE("sync_committee_message"), + SYNC_AGGREGATOR_SELECTION_DATA("sync_aggregator_selection_data"), + SYNC_COMMITTEE_SELECTION_PROOF("sync_committee_selection_proof"), + SYNC_COMMITTEE_CONTRIBUTION_AND_PROOF("sync_committee_contribution_and_proof"), + VALIDATOR_REGISTRATION("validator_registration"), + CONTRIBUTION_AND_PROOF("contribution_and_proof"), + BEACON_BLOCK("beacon_block"), + BLOB_SIDECAR("blob_sidecar"); + + private final String name; + + SignType(final String name) { + this.name = name; + } + + public String getName() { + return name; + } +} diff --git a/validator/api/src/main/java/tech/pegasys/teku/validator/api/signer/SyncAggregatorSelectionDataWrapper.java b/validator/api/src/main/java/tech/pegasys/teku/validator/api/signer/SyncAggregatorSelectionDataWrapper.java new file mode 100644 index 00000000000..33a26dc6c4a --- /dev/null +++ b/validator/api/src/main/java/tech/pegasys/teku/validator/api/signer/SyncAggregatorSelectionDataWrapper.java @@ -0,0 +1,55 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.api.signer; + +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; + +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; + +public record SyncAggregatorSelectionDataWrapper(UInt64 slot, UInt64 subcommitteeIndex) { + public static DeserializableTypeDefinition + getJsonTypefinition() { + return DeserializableTypeDefinition.object( + SyncAggregatorSelectionDataWrapper.class, Builder.class) + .initializer(Builder::new) + .finisher(Builder::build) + .withField("slot", UINT64_TYPE, SyncAggregatorSelectionDataWrapper::slot, Builder::slot) + .withField( + "subcommittee_index", + UINT64_TYPE, + SyncAggregatorSelectionDataWrapper::subcommitteeIndex, + Builder::subcommitteeIndex) + .build(); + } + + static class Builder { + private UInt64 slot; + private UInt64 subcommitteeIndex; + + Builder slot(final UInt64 slot) { + this.slot = slot; + return this; + } + + Builder subcommitteeIndex(final UInt64 subcommitteeIndex) { + this.subcommitteeIndex = subcommitteeIndex; + return this; + } + + SyncAggregatorSelectionDataWrapper build() { + return new SyncAggregatorSelectionDataWrapper(slot, subcommitteeIndex); + } + } +} diff --git a/validator/api/src/main/java/tech/pegasys/teku/validator/api/signer/SyncCommitteeMessageWrapper.java b/validator/api/src/main/java/tech/pegasys/teku/validator/api/signer/SyncCommitteeMessageWrapper.java new file mode 100644 index 00000000000..038f39e99c0 --- /dev/null +++ b/validator/api/src/main/java/tech/pegasys/teku/validator/api/signer/SyncCommitteeMessageWrapper.java @@ -0,0 +1,56 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.api.signer; + +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.BYTES32_TYPE; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; + +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; + +public record SyncCommitteeMessageWrapper(Bytes32 blockRoot, UInt64 slot) { + + public static DeserializableTypeDefinition getJsonTypeDefinition() { + return DeserializableTypeDefinition.object(SyncCommitteeMessageWrapper.class, Builder.class) + .initializer(Builder::new) + .finisher(Builder::build) + .withField("slot", UINT64_TYPE, SyncCommitteeMessageWrapper::slot, Builder::slot) + .withField( + "beacon_block_root", + BYTES32_TYPE, + SyncCommitteeMessageWrapper::blockRoot, + Builder::blockRoot) + .build(); + } + + static class Builder { + private Bytes32 blockRoot; + private UInt64 slot; + + Builder blockRoot(final Bytes32 blockRoot) { + this.blockRoot = blockRoot; + return this; + } + + Builder slot(final UInt64 slot) { + this.slot = slot; + return this; + } + + SyncCommitteeMessageWrapper build() { + return new SyncCommitteeMessageWrapper(blockRoot, slot); + } + } +} diff --git a/validator/api/src/test/java/tech/pegasys/teku/validator/api/GraffitiManagerTest.java b/validator/api/src/test/java/tech/pegasys/teku/validator/api/GraffitiManagerTest.java new file mode 100644 index 00000000000..8d6720e3614 --- /dev/null +++ b/validator/api/src/test/java/tech/pegasys/teku/validator/api/GraffitiManagerTest.java @@ -0,0 +1,263 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.api; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.assertj.core.api.Assertions.fail; +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static tech.pegasys.teku.validator.api.GraffitiManager.GRAFFITI_DIR; + +import java.io.File; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import org.apache.tuweni.bytes.Bytes32; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.condition.DisabledOnOs; +import org.junit.jupiter.api.condition.OS; +import org.junit.jupiter.api.io.TempDir; +import tech.pegasys.techu.service.serviceutils.layout.SimpleDataDirLayout; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.service.serviceutils.layout.DataDirLayout; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +class GraffitiManagerTest { + private final DataStructureUtil dataStructureUtil = + new DataStructureUtil(TestSpecFactory.createDefault()); + private final BLSPublicKey publicKey = dataStructureUtil.randomPublicKey(); + private final String graffiti = "Test graffiti"; + private GraffitiManager manager; + private DataDirLayout dataDirLayout; + + @Test + @DisabledOnOs(OS.WINDOWS) // Can't set permissions on Windows + void shouldThrowExceptionWhenUnableToCreateManagementDirectory(@TempDir final Path tempDir) { + assertThat(tempDir.toFile().setWritable(false)).isTrue(); + dataDirLayout = new SimpleDataDirLayout(tempDir); + + assertThatThrownBy(() -> new GraffitiManager(dataDirLayout)) + .isInstanceOf(IllegalStateException.class) + .hasMessage("Unable to create directory for graffiti management."); + } + + @Test + void setGraffiti_shouldSetGraffitiWhenFileNotExist(@TempDir final Path tempDir) + throws GraffitiManagementException { + dataDirLayout = new SimpleDataDirLayout(tempDir); + manager = new GraffitiManager(dataDirLayout); + assertThat(getGraffitiManagementDir().toFile().exists()).isTrue(); + + manager.setGraffiti(publicKey, graffiti); + checkStoredGraffitiFile(publicKey); + } + + @Test + void setGraffiti_shouldSetGraffitiWhenFileExist(@TempDir final Path tempDir) + throws IOException, GraffitiManagementException { + dataDirLayout = new SimpleDataDirLayout(tempDir); + manager = new GraffitiManager(dataDirLayout); + assertThat(getGraffitiManagementDir().resolve(getFileName(publicKey)).toFile().createNewFile()) + .isTrue(); + + manager.setGraffiti(publicKey, graffiti); + checkStoredGraffitiFile(publicKey); + } + + @Test + @DisabledOnOs(OS.WINDOWS) // Can't set permissions on Windows + void setGraffiti_shouldReturnErrorMessageWhenUnableToWriteFile(@TempDir final Path tempDir) + throws IOException { + dataDirLayout = new SimpleDataDirLayout(tempDir); + manager = new GraffitiManager(dataDirLayout); + assertThat(getGraffitiManagementDir().toFile().exists()).isTrue(); + + final File file = getGraffitiManagementDir().resolve(getFileName(publicKey)).toFile(); + assertThat(file.createNewFile()).isTrue(); + assertThat(file.setWritable(false)).isTrue(); + + assertThatThrownBy(() -> manager.setGraffiti(publicKey, graffiti)) + .isInstanceOf(GraffitiManagementException.class) + .hasMessage("Unable to update graffiti for validator " + publicKey); + } + + @Test + void setGraffiti_shouldThrowExceptionWhenGraffitiTooBig(@TempDir final Path tempDir) { + final String invalidGraffiti = "This graffiti is a bit too long!!"; + dataDirLayout = new SimpleDataDirLayout(tempDir); + manager = new GraffitiManager(dataDirLayout); + assertThat(getGraffitiManagementDir().toFile().exists()).isTrue(); + + assertThatThrownBy(() -> manager.setGraffiti(publicKey, invalidGraffiti)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage( + "'This graffiti is a bit too long!!' converts to 33 bytes. Input must be 32 bytes or less."); + } + + @Test + void deleteGraffiti_shouldSucceedWhenNoGraffitiToDelete(@TempDir final Path tempDir) { + dataDirLayout = new SimpleDataDirLayout(tempDir); + manager = new GraffitiManager(dataDirLayout); + assertThat(getGraffitiManagementDir().toFile().exists()).isTrue(); + + assertDoesNotThrow(() -> manager.deleteGraffiti(publicKey)); + checkNoGraffitiFile(publicKey); + } + + @Test + void deleteGraffiti_shouldDeleteGraffitiWhenFileExist(@TempDir final Path tempDir) + throws IOException, GraffitiManagementException { + dataDirLayout = new SimpleDataDirLayout(tempDir); + manager = new GraffitiManager(dataDirLayout); + assertThat(getGraffitiManagementDir().resolve(getFileName(publicKey)).toFile().createNewFile()) + .isTrue(); + + manager.deleteGraffiti(publicKey); + checkNoGraffitiFile(publicKey); + } + + @Test + @DisabledOnOs(OS.WINDOWS) // Can't set permissions on Windows + void deleteGraffiti_shouldReturnErrorMessageWhenUnableToDeleteFile(@TempDir final Path tempDir) + throws IOException { + dataDirLayout = new SimpleDataDirLayout(tempDir); + manager = new GraffitiManager(dataDirLayout); + + final File file = getGraffitiManagementDir().resolve(getFileName(publicKey)).toFile(); + assertThat(file.createNewFile()).isTrue(); + assertThat(file.getParentFile().setWritable(false)).isTrue(); + + assertThatThrownBy(() -> manager.deleteGraffiti(publicKey)) + .isInstanceOf(GraffitiManagementException.class) + .hasMessage("Unable to delete graffiti for validator " + publicKey); + assertThat(file.exists()).isTrue(); + } + + @Test + void shouldSetAndDeleteGraffitiWhenManagementPreexisting(@TempDir final Path tempDir) + throws GraffitiManagementException { + dataDirLayout = new SimpleDataDirLayout(tempDir); + final Path managementDir = getGraffitiManagementDir(); + assertThat(managementDir.toFile().mkdirs()).isTrue(); + manager = new GraffitiManager(dataDirLayout); + + manager.setGraffiti(publicKey, graffiti); + checkStoredGraffitiFile(publicKey); + + manager.deleteGraffiti(publicKey); + checkNoGraffitiFile(publicKey); + } + + private void checkStoredGraffitiFile(final BLSPublicKey publicKey) { + final Path filePath = getGraffitiManagementDir().resolve(getFileName(publicKey)); + try { + final byte[] readBytes = Files.readAllBytes(filePath); + assertThat(readBytes).isEqualTo(graffiti.getBytes(StandardCharsets.UTF_8)); + } catch (IOException e) { + fail("Unable to check graffiti file.", e); + } + } + + private void checkNoGraffitiFile(final BLSPublicKey publicKey) { + final Path filePath = getGraffitiManagementDir().resolve(getFileName(publicKey)); + assertThat(filePath.toFile().exists()).isFalse(); + } + + @Test + void getGraffiti_shouldGetGraffitiFromStorage(@TempDir final Path tempDir) + throws IOException, GraffitiManagementException { + dataDirLayout = new SimpleDataDirLayout(tempDir); + manager = new GraffitiManager(dataDirLayout); + final Path filePath = getGraffitiManagementDir().resolve(getFileName(publicKey)); + Files.writeString(filePath, graffiti); + + final Bytes32 expectedBytes = Bytes32Parser.toBytes32(graffiti); + assertThat(manager.getGraffiti(publicKey)).hasValue(expectedBytes); + } + + @Test + void getGraffiti_shouldReturnEmptyWhenFileNotExist(@TempDir final Path tempDir) + throws GraffitiManagementException { + dataDirLayout = new SimpleDataDirLayout(tempDir); + manager = new GraffitiManager(dataDirLayout); + + assertThat(manager.getGraffiti(publicKey)).isEmpty(); + } + + @Test + void getGraffiti_shouldThrowExceptionWhenGraffitiOver32Bytes(@TempDir final Path tempDir) + throws IOException { + dataDirLayout = new SimpleDataDirLayout(tempDir); + manager = new GraffitiManager(dataDirLayout); + + final String invalidGraffiti = "This graffiti is a bit too long!!"; + final Path filePath = getGraffitiManagementDir().resolve(getFileName(publicKey)); + Files.writeString(filePath, invalidGraffiti); + + assertThatThrownBy(() -> manager.getGraffiti(publicKey)) + .isInstanceOf(GraffitiManagementException.class) + .hasMessage("Unable to retrieve stored graffiti for validator " + publicKey); + } + + @Test + void getGraffiti_shouldThrowExceptionWhenFileOver40Bytes(@TempDir final Path tempDir) + throws IOException { + dataDirLayout = new SimpleDataDirLayout(tempDir); + manager = new GraffitiManager(dataDirLayout); + + final String invalidGraffiti = "This graffiti is a bit too long to get from file!!"; + final Path filePath = getGraffitiManagementDir().resolve(getFileName(publicKey)); + Files.writeString(filePath, invalidGraffiti); + + assertThatThrownBy(() -> manager.getGraffiti(publicKey)) + .isInstanceOf(GraffitiManagementException.class) + .hasMessage("Unable to retrieve stored graffiti for validator " + publicKey); + } + + @Test + @DisabledOnOs(OS.WINDOWS) // Can't set permissions on Windows + void getGraffiti_shouldThrowExceptionWhenNotReadableFile(@TempDir final Path tempDir) + throws IOException { + dataDirLayout = new SimpleDataDirLayout(tempDir); + manager = new GraffitiManager(dataDirLayout); + final Path filePath = getGraffitiManagementDir().resolve(getFileName(publicKey)); + Files.writeString(filePath, graffiti); + assertThat(filePath.toFile().setReadable(false)).isTrue(); + + assertThatThrownBy(() -> manager.getGraffiti(publicKey)) + .isInstanceOf(GraffitiManagementException.class) + .hasMessage("Unable to retrieve stored graffiti for validator " + publicKey); + } + + @Test + void getGraffiti_shouldReturnEmptyBytesWhenFileEmpty(@TempDir final Path tempDir) + throws IOException, GraffitiManagementException { + dataDirLayout = new SimpleDataDirLayout(tempDir); + manager = new GraffitiManager(dataDirLayout); + final Path filePath = getGraffitiManagementDir().resolve(getFileName(publicKey)); + assertThat(filePath.toFile().createNewFile()).isTrue(); + + assertThat(manager.getGraffiti(publicKey)).hasValue(Bytes32Parser.toBytes32(new byte[0])); + } + + private Path getGraffitiManagementDir() { + return dataDirLayout.getValidatorDataDirectory().resolve(GRAFFITI_DIR); + } + + private String getFileName(final BLSPublicKey publicKey) { + return publicKey.toSSZBytes().toUnprefixedHexString() + ".txt"; + } +} diff --git a/validator/api/src/test/java/tech/pegasys/teku/validator/api/KeyStoreFilesLocatorTest.java b/validator/api/src/test/java/tech/pegasys/teku/validator/api/KeyStoreFilesLocatorTest.java index d5370909fe0..cea39b87d35 100644 --- a/validator/api/src/test/java/tech/pegasys/teku/validator/api/KeyStoreFilesLocatorTest.java +++ b/validator/api/src/test/java/tech/pegasys/teku/validator/api/KeyStoreFilesLocatorTest.java @@ -217,7 +217,7 @@ public void shouldHandleSymlinkedDirectories(@TempDir final Path tempDir) throws tempDir, Path.of("key", "a.json").toString(), Path.of("pass", "a.txt").toString())); } - private void createFolders(final Path tempDir, String... paths) { + private void createFolders(final Path tempDir, final String... paths) { for (String path : paths) { File file = tempDir.resolve(path).toFile(); if (!file.mkdirs() && !file.isDirectory()) { @@ -226,7 +226,7 @@ private void createFolders(final Path tempDir, String... paths) { } } - private void createFolders(final Path tempDir, Path... paths) { + private void createFolders(final Path tempDir, final Path... paths) { for (Path path : paths) { File file = tempDir.resolve(path).toFile(); if (!file.mkdirs() && !file.isDirectory()) { @@ -235,7 +235,7 @@ private void createFolders(final Path tempDir, Path... paths) { } } - private void createFiles(final Path tempDir, Path... paths) throws IOException { + private void createFiles(final Path tempDir, final Path... paths) throws IOException { for (Path path : paths) { File file = tempDir.resolve(path).toFile(); assertThat(file.createNewFile()).isTrue(); diff --git a/validator/api/src/test/java/tech/pegasys/teku/validator/api/UpdatableGraffitiProviderTest.java b/validator/api/src/test/java/tech/pegasys/teku/validator/api/UpdatableGraffitiProviderTest.java new file mode 100644 index 00000000000..f9b10295389 --- /dev/null +++ b/validator/api/src/test/java/tech/pegasys/teku/validator/api/UpdatableGraffitiProviderTest.java @@ -0,0 +1,107 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.api; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +import java.util.Optional; +import java.util.function.Supplier; +import org.apache.tuweni.bytes.Bytes32; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.util.DataStructureUtil; + +class UpdatableGraffitiProviderTest { + private final DataStructureUtil dataStructureUtil = + new DataStructureUtil(TestSpecFactory.createDefault()); + private final Bytes32 storageGraffiti = dataStructureUtil.randomBytes32(); + private final Bytes32 defaultGraffiti = dataStructureUtil.randomBytes32(); + private UpdatableGraffitiProvider provider; + + @Test + void get_shouldGetStorageGraffitiWhenAvailable() { + provider = new UpdatableGraffitiProvider(() -> Optional.of(storageGraffiti), Optional::empty); + assertThat(provider.get()).hasValue(storageGraffiti); + } + + @Test + void get_shouldGetStorageGraffitiWhenBothAvailable() { + provider = + new UpdatableGraffitiProvider( + () -> Optional.of(storageGraffiti), () -> Optional.of(defaultGraffiti)); + assertThat(provider.get()).hasValue(storageGraffiti); + } + + @Test + void get_shouldGetDefaultGraffitiWhenStorageEmpty() { + provider = new UpdatableGraffitiProvider(Optional::empty, () -> Optional.of(defaultGraffiti)); + assertThat(provider.get()).hasValue(defaultGraffiti); + } + + @Test + void get_shouldBeEmptyWhenBothEmpty() { + provider = new UpdatableGraffitiProvider(Optional::empty, Optional::empty); + assertThat(provider.get()).isEmpty(); + } + + @Test + public void get_shouldDelegateToDefaultProviderWhenStorageProviderFails() { + final Supplier> storageProvider = + () -> { + throw new RuntimeException("Error"); + }; + + provider = new UpdatableGraffitiProvider(storageProvider, () -> Optional.of(defaultGraffiti)); + assertThat(provider.get()).hasValue(defaultGraffiti); + } + + @Test + void getUnsafe_shouldGetStorageGraffitiWhenAvailable() { + provider = new UpdatableGraffitiProvider(() -> Optional.of(storageGraffiti), Optional::empty); + assertThat(provider.getUnsafe()).hasValue(storageGraffiti); + } + + @Test + void getUnsafe_shouldGetStorageGraffitiWhenBothAvailable() { + provider = + new UpdatableGraffitiProvider( + () -> Optional.of(storageGraffiti), () -> Optional.of(defaultGraffiti)); + assertThat(provider.getUnsafe()).hasValue(storageGraffiti); + } + + @Test + void getUnsafe_shouldGetDefaultGraffitiWhenStorageEmpty() { + provider = new UpdatableGraffitiProvider(Optional::empty, () -> Optional.of(defaultGraffiti)); + assertThat(provider.getUnsafe()).hasValue(defaultGraffiti); + } + + @Test + void getUnsafe_shouldBeEmptyWhenBothEmpty() { + provider = new UpdatableGraffitiProvider(Optional::empty, Optional::empty); + assertThat(provider.getUnsafe()).isEmpty(); + } + + @Test + public void getUnsafe_shouldThrowExceptionWhenStorageProviderFails() { + final RuntimeException exception = new RuntimeException("Error"); + final Supplier> storageProvider = + () -> { + throw exception; + }; + + provider = new UpdatableGraffitiProvider(storageProvider, () -> Optional.of(defaultGraffiti)); + assertThatThrownBy(() -> provider.getUnsafe()).isEqualTo(exception); + } +} diff --git a/validator/beaconnode/build.gradle b/validator/beaconnode/build.gradle index 0fef9cf2e57..ff770ea9be7 100644 --- a/validator/beaconnode/build.gradle +++ b/validator/beaconnode/build.gradle @@ -8,7 +8,7 @@ dependencies { implementation project(':validator:api') implementation project(':data:serializer') - implementation 'org.apache.tuweni:tuweni-bytes' + implementation 'io.tmio:tuweni-bytes' implementation 'com.google.guava:guava' implementation 'org.apache.logging.log4j:log4j-api' diff --git a/validator/beaconnode/src/main/java/tech/pegasys/teku/validator/beaconnode/metrics/BeaconNodeRequestLabels.java b/validator/beaconnode/src/main/java/tech/pegasys/teku/validator/beaconnode/metrics/BeaconNodeRequestLabels.java index 2e86794a95e..9e9253e5ac3 100644 --- a/validator/beaconnode/src/main/java/tech/pegasys/teku/validator/beaconnode/metrics/BeaconNodeRequestLabels.java +++ b/validator/beaconnode/src/main/java/tech/pegasys/teku/validator/beaconnode/metrics/BeaconNodeRequestLabels.java @@ -20,6 +20,7 @@ public class BeaconNodeRequestLabels { public static final String GET_VALIDATOR_STATUSES_METHOD = "get_validator_statuses"; public static final String GET_ATTESTATION_DUTIES_METHOD = "get_attestation_duties"; public static final String GET_PROPOSER_DUTIES_REQUESTS_METHOD = "get_proposer_duties"; + public static final String GET_PEER_COUNT_METHOD = "get_peer_count"; public static final String GET_SYNC_COMMITTEE_DUTIES_METHOD = "get_sync_committee_duties"; public static final String CREATE_UNSIGNED_BLOCK_METHOD = "create_unsigned_block"; public static final String CREATE_ATTESTATION_METHOD = "create_attestation"; diff --git a/validator/beaconnode/src/main/java/tech/pegasys/teku/validator/beaconnode/metrics/MetricRecordingValidatorApiChannel.java b/validator/beaconnode/src/main/java/tech/pegasys/teku/validator/beaconnode/metrics/MetricRecordingValidatorApiChannel.java index 430502a48c5..81d17480b9a 100644 --- a/validator/beaconnode/src/main/java/tech/pegasys/teku/validator/beaconnode/metrics/MetricRecordingValidatorApiChannel.java +++ b/validator/beaconnode/src/main/java/tech/pegasys/teku/validator/beaconnode/metrics/MetricRecordingValidatorApiChannel.java @@ -32,11 +32,13 @@ import tech.pegasys.teku.api.response.v1.beacon.ValidatorStatus; import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.bls.BLSSignature; +import tech.pegasys.teku.ethereum.json.types.node.PeerCount; import tech.pegasys.teku.ethereum.json.types.validator.AttesterDuties; import tech.pegasys.teku.ethereum.json.types.validator.BeaconCommitteeSelectionProof; import tech.pegasys.teku.ethereum.json.types.validator.ProposerDuties; import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeDuties; import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSelectionProof; +import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.metrics.TekuMetricCategory; import tech.pegasys.teku.infrastructure.metrics.Validator.ValidatorDutyMetricUtils; @@ -52,13 +54,12 @@ import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SignedContributionAndProof; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeContribution; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeMessage; -import tech.pegasys.teku.spec.datastructures.operations.versions.bellatrix.BeaconPreparableProposer; +import tech.pegasys.teku.spec.datastructures.validator.BeaconPreparableProposer; import tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel; import tech.pegasys.teku.spec.datastructures.validator.SubnetSubscription; import tech.pegasys.teku.validator.api.CommitteeSubscriptionRequest; import tech.pegasys.teku.validator.api.SendSignedBlockResult; import tech.pegasys.teku.validator.api.SubmitDataError; -import tech.pegasys.teku.validator.api.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.validator.api.ValidatorApiChannel; public class MetricRecordingValidatorApiChannel implements ValidatorApiChannel { @@ -127,16 +128,20 @@ public SafeFuture> getProposerDuties(final UInt64 epoch BeaconNodeRequestLabels.GET_PROPOSER_DUTIES_REQUESTS_METHOD); } + @Override + public SafeFuture> getPeerCount() { + return countOptionalDataRequest( + delegate.getPeerCount(), BeaconNodeRequestLabels.GET_PEER_COUNT_METHOD); + } + @Override public SafeFuture> createUnsignedBlock( final UInt64 slot, final BLSSignature randaoReveal, final Optional graffiti, - final Optional requestedBlinded, final Optional requestedBuilderBoostFactor) { return countOptionalDataRequest( - delegate.createUnsignedBlock( - slot, randaoReveal, graffiti, requestedBlinded, requestedBuilderBoostFactor), + delegate.createUnsignedBlock(slot, randaoReveal, graffiti, requestedBuilderBoostFactor), BeaconNodeRequestLabels.CREATE_UNSIGNED_BLOCK_METHOD); } @@ -150,9 +155,11 @@ public SafeFuture> createAttestationData( @Override public SafeFuture> createAggregate( - final UInt64 slot, final Bytes32 attestationHashTreeRoot) { + final UInt64 slot, + final Bytes32 attestationHashTreeRoot, + final Optional committeeIndex) { return countOptionalDataRequest( - delegate.createAggregate(slot, attestationHashTreeRoot), + delegate.createAggregate(slot, attestationHashTreeRoot, committeeIndex), BeaconNodeRequestLabels.CREATE_AGGREGATE_METHOD); } @@ -242,7 +249,7 @@ public SafeFuture prepareBeaconProposer( @Override public SafeFuture registerValidators( - SszList validatorRegistrations) { + final SszList validatorRegistrations) { return countDataRequest( delegate.registerValidators(validatorRegistrations), BeaconNodeRequestLabels.REGISTER_VALIDATORS_METHOD); @@ -250,7 +257,7 @@ public SafeFuture registerValidators( @Override public SafeFuture>> getValidatorsLiveness( - List validatorIndices, UInt64 epoch) { + final List validatorIndices, final UInt64 epoch) { return countOptionalDataRequest( delegate.getValidatorsLiveness(validatorIndices, epoch), BeaconNodeRequestLabels.GET_VALIDATORS_LIVENESS); diff --git a/validator/beaconnode/src/test/java/tech/pegasys/teku/validator/beaconnode/metrics/MetricRecordingValidatorApiChannelTest.java b/validator/beaconnode/src/test/java/tech/pegasys/teku/validator/beaconnode/metrics/MetricRecordingValidatorApiChannelTest.java index ea2664a4d14..e72db7fad81 100644 --- a/validator/beaconnode/src/test/java/tech/pegasys/teku/validator/beaconnode/metrics/MetricRecordingValidatorApiChannelTest.java +++ b/validator/beaconnode/src/test/java/tech/pegasys/teku/validator/beaconnode/metrics/MetricRecordingValidatorApiChannelTest.java @@ -184,6 +184,10 @@ public static Stream getDataRequestArguments() { dataStructureUtil.randomUInt64(), dataStructureUtil.randomUInt64()); final UInt64 epoch = dataStructureUtil.randomEpoch(); + final Function>> createAggregateMethod = + channel -> + channel.createAggregate( + attestationData.getSlot(), attestationData.hashTreeRoot(), Optional.empty()); return Stream.of( requestDataTest( "getGenesisData", @@ -193,8 +197,7 @@ public static Stream getDataRequestArguments() { requestDataTest( "createUnsignedBlock", channel -> - channel.createUnsignedBlock( - slot, signature, Optional.empty(), Optional.of(false), Optional.empty()), + channel.createUnsignedBlock(slot, signature, Optional.empty(), Optional.empty()), BeaconNodeRequestLabels.CREATE_UNSIGNED_BLOCK_METHOD, dataStructureUtil.randomBlockContainerAndMetaData(slot)), requestDataTest( @@ -202,10 +205,8 @@ public static Stream getDataRequestArguments() { channel -> channel.createAttestationData(slot, 4), BeaconNodeRequestLabels.CREATE_ATTESTATION_METHOD, dataStructureUtil.randomAttestationData()), - requestDataTest( - "createAggregate", - channel -> - channel.createAggregate(attestationData.getSlot(), attestationData.hashTreeRoot()), + Arguments.of( + Named.named("createAggregate", createAggregateMethod), BeaconNodeRequestLabels.CREATE_AGGREGATE_METHOD, dataStructureUtil.randomAttestation()), requestDataTest( diff --git a/validator/client/build.gradle b/validator/client/build.gradle index 006b812f4fa..64cc30b7181 100644 --- a/validator/client/build.gradle +++ b/validator/client/build.gradle @@ -4,7 +4,7 @@ dependencies { implementation project(':infrastructure:crypto') implementation project(':infrastructure:exceptions') implementation project(':infrastructure:io') - implementation project(':infrastructure:json') + implementation project(':infrastructure:jackson') implementation project(':infrastructure:metrics') implementation project(':infrastructure:http') implementation project(':ethereum:json-types') @@ -28,7 +28,7 @@ dependencies { implementation project(':infrastructure:bls-keystore') implementation project(':infrastructure:subscribers') - implementation 'org.apache.tuweni:tuweni-bytes' + implementation 'io.tmio:tuweni-bytes' implementation 'commons-io:commons-io' implementation 'com.fasterxml.jackson.core:jackson-databind' diff --git a/validator/client/src/integration-test/java/tech/pegasys/teku/validator/client/signer/ExternalSignerAltairIntegrationTest.java b/validator/client/src/integration-test/java/tech/pegasys/teku/validator/client/signer/ExternalSignerAltairIntegrationTest.java index cfd54a9a9c3..c84aa1543ea 100644 --- a/validator/client/src/integration-test/java/tech/pegasys/teku/validator/client/signer/ExternalSignerAltairIntegrationTest.java +++ b/validator/client/src/integration-test/java/tech/pegasys/teku/validator/client/signer/ExternalSignerAltairIntegrationTest.java @@ -16,7 +16,7 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.mockserver.model.HttpRequest.request; import static org.mockserver.model.HttpResponse.response; -import static tech.pegasys.teku.validator.client.signer.ExternalSignerTestUtil.createForkInfo; +import static tech.pegasys.teku.validator.client.signer.ExternalSigner.FORK_INFO; import static tech.pegasys.teku.validator.client.signer.ExternalSignerTestUtil.validateMetrics; import static tech.pegasys.teku.validator.client.signer.ExternalSignerTestUtil.verifySignRequest; @@ -36,6 +36,9 @@ import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncAggregatorSelectionData; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeContribution; import tech.pegasys.teku.spec.logic.common.util.SyncCommitteeUtil; +import tech.pegasys.teku.validator.api.signer.SignType; +import tech.pegasys.teku.validator.api.signer.SyncAggregatorSelectionDataWrapper; +import tech.pegasys.teku.validator.api.signer.SyncCommitteeMessageWrapper; public class ExternalSignerAltairIntegrationTest extends AbstractExternalSignerIntegrationTest { @@ -79,10 +82,13 @@ void shouldSignAltairBlock() throws Exception { new SigningRequestBody( signingRootUtil.signingRootForSignBlock(block, forkInfo), externalSignerBlockRequestProvider.getSignType(), - externalSignerBlockRequestProvider.getBlockMetadata( - Map.of("fork_info", createForkInfo(forkInfo)))); + externalSignerBlockRequestProvider.getBlockMetadata(Map.of("fork_info", forkInfo))); - verifySignRequest(client, KEYPAIR.getPublicKey().toString(), signingRequestBody); + verifySignRequest( + client, + KEYPAIR.getPublicKey().toString(), + signingRequestBody, + getSpec().getGenesisSchemaDefinitions()); validateMetrics(metricsSystem, 1, 0, 0); } @@ -109,12 +115,16 @@ public void shouldSignSyncCommitteeMessage() throws Exception { expectedSigningRoot, SignType.SYNC_COMMITTEE_MESSAGE, Map.of( - "fork_info", - createForkInfo(forkInfo), + FORK_INFO, + forkInfo, "sync_committee_message", - Map.of("beacon_block_root", beaconBlockRoot, "slot", slot))); + new SyncCommitteeMessageWrapper(beaconBlockRoot, slot))); - verifySignRequest(client, KEYPAIR.getPublicKey().toString(), signingRequestBody); + verifySignRequest( + client, + KEYPAIR.getPublicKey().toString(), + signingRequestBody, + getSpec().getGenesisSchemaDefinitions()); validateMetrics(metricsSystem, 1, 0, 0); } @@ -139,16 +149,17 @@ public void shouldSignSyncCommitteeSelectionProof() throws Exception { expectedSigningRoot, SignType.SYNC_COMMITTEE_SELECTION_PROOF, Map.of( - "fork_info", - createForkInfo(forkInfo), - "sync_aggregator_selection_data", - Map.of( - "slot", - selectionData.getSlot(), - "subcommittee_index", - selectionData.getSubcommitteeIndex()))); - - verifySignRequest(client, KEYPAIR.getPublicKey().toString(), signingRequestBody); + FORK_INFO, + forkInfo, + SignType.SYNC_AGGREGATOR_SELECTION_DATA.getName(), + new SyncAggregatorSelectionDataWrapper( + selectionData.getSlot(), selectionData.getSubcommitteeIndex()))); + + verifySignRequest( + client, + KEYPAIR.getPublicKey().toString(), + signingRequestBody, + getSpec().getGenesisSchemaDefinitions()); validateMetrics(metricsSystem, 1, 0, 0); } @@ -172,14 +183,13 @@ public void shouldSignContributionAndProof() throws Exception { new SigningRequestBody( expectedSigningRoot, SignType.SYNC_COMMITTEE_CONTRIBUTION_AND_PROOF, - Map.of( - "fork_info", - createForkInfo(forkInfo), - "contribution_and_proof", - new tech.pegasys.teku.api.schema.altair.ContributionAndProof( - contributionAndProof))); + Map.of(FORK_INFO, forkInfo, "contribution_and_proof", contributionAndProof)); - verifySignRequest(client, KEYPAIR.getPublicKey().toString(), signingRequestBody); + verifySignRequest( + client, + KEYPAIR.getPublicKey().toString(), + signingRequestBody, + getSpec().getGenesisSchemaDefinitions()); validateMetrics(metricsSystem, 1, 0, 0); } diff --git a/validator/client/src/integration-test/java/tech/pegasys/teku/validator/client/signer/ExternalSignerBellatrixIntegrationTest.java b/validator/client/src/integration-test/java/tech/pegasys/teku/validator/client/signer/ExternalSignerBellatrixIntegrationTest.java index 26d9171445a..b22771da705 100644 --- a/validator/client/src/integration-test/java/tech/pegasys/teku/validator/client/signer/ExternalSignerBellatrixIntegrationTest.java +++ b/validator/client/src/integration-test/java/tech/pegasys/teku/validator/client/signer/ExternalSignerBellatrixIntegrationTest.java @@ -16,7 +16,6 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.mockserver.model.HttpRequest.request; import static org.mockserver.model.HttpResponse.response; -import static tech.pegasys.teku.validator.client.signer.ExternalSignerTestUtil.createForkInfo; import static tech.pegasys.teku.validator.client.signer.ExternalSignerTestUtil.validateMetrics; import static tech.pegasys.teku.validator.client.signer.ExternalSignerTestUtil.verifySignRequest; @@ -58,10 +57,13 @@ void shouldSignBellatrixBlock() throws Exception { new SigningRequestBody( blockHeaderSigningRoot, externalSignerBlockRequestProvider.getSignType(), - externalSignerBlockRequestProvider.getBlockMetadata( - Map.of("fork_info", createForkInfo(forkInfo)))); + externalSignerBlockRequestProvider.getBlockMetadata(Map.of("fork_info", forkInfo))); - verifySignRequest(client, KEYPAIR.getPublicKey().toString(), signingRequestBody); + verifySignRequest( + client, + KEYPAIR.getPublicKey().toString(), + signingRequestBody, + getSpec().getGenesisSchemaDefinitions()); validateMetrics(metricsSystem, 1, 0, 0); } diff --git a/validator/client/src/integration-test/java/tech/pegasys/teku/validator/client/signer/ExternalSignerIntegrationTest.java b/validator/client/src/integration-test/java/tech/pegasys/teku/validator/client/signer/ExternalSignerIntegrationTest.java index 234c468f579..cfa36882f88 100644 --- a/validator/client/src/integration-test/java/tech/pegasys/teku/validator/client/signer/ExternalSignerIntegrationTest.java +++ b/validator/client/src/integration-test/java/tech/pegasys/teku/validator/client/signer/ExternalSignerIntegrationTest.java @@ -22,7 +22,6 @@ import static tech.pegasys.teku.validator.client.signer.ExternalSigner.slashableAttestationMessage; import static tech.pegasys.teku.validator.client.signer.ExternalSigner.slashableBlockMessage; import static tech.pegasys.teku.validator.client.signer.ExternalSigner.slashableGenericMessage; -import static tech.pegasys.teku.validator.client.signer.ExternalSignerTestUtil.createForkInfo; import static tech.pegasys.teku.validator.client.signer.ExternalSignerTestUtil.validateMetrics; import static tech.pegasys.teku.validator.client.signer.ExternalSignerTestUtil.verifySignRequest; @@ -40,6 +39,9 @@ import tech.pegasys.teku.spec.datastructures.operations.AggregateAndProof; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; import tech.pegasys.teku.spec.datastructures.operations.VoluntaryExit; +import tech.pegasys.teku.validator.api.signer.AggregationSlotWrapper; +import tech.pegasys.teku.validator.api.signer.RandaoRevealWrapper; +import tech.pegasys.teku.validator.api.signer.SignType; public class ExternalSignerIntegrationTest extends AbstractExternalSignerIntegrationTest { @@ -141,10 +143,13 @@ void shouldSignsBlock() throws Exception { new SigningRequestBody( signingRootUtil.signingRootForSignBlock(block, forkInfo), externalSignerBlockRequestProvider.getSignType(), - externalSignerBlockRequestProvider.getBlockMetadata( - Map.of("fork_info", createForkInfo(forkInfo)))); + externalSignerBlockRequestProvider.getBlockMetadata(Map.of("fork_info", forkInfo))); - verifySignRequest(client, KEYPAIR.getPublicKey().toString(), signingRequestBody); + verifySignRequest( + client, + KEYPAIR.getPublicKey().toString(), + signingRequestBody, + getSpec().getGenesisSchemaDefinitions()); validateMetrics(metricsSystem, 1, 0, 0); } @@ -166,13 +171,13 @@ void shouldSignAttestationData() throws Exception { new SigningRequestBody( signingRootUtil.signingRootForSignAttestationData(attestationData, forkInfo), SignType.ATTESTATION, - Map.of( - "fork_info", - createForkInfo(forkInfo), - "attestation", - new tech.pegasys.teku.api.schema.AttestationData(attestationData))); + Map.of("fork_info", forkInfo, "attestation", attestationData)); - verifySignRequest(client, KEYPAIR.getPublicKey().toString(), signingRequestBody); + verifySignRequest( + client, + KEYPAIR.getPublicKey().toString(), + signingRequestBody, + getSpec().getGenesisSchemaDefinitions()); validateMetrics(metricsSystem, 1, 0, 0); } @@ -193,8 +198,12 @@ void shouldSignRandaoReveal() throws Exception { new SigningRequestBody( signingRootUtil.signingRootForRandaoReveal(epoch, forkInfo), SignType.RANDAO_REVEAL, - Map.of("fork_info", createForkInfo(forkInfo), "randao_reveal", Map.of("epoch", epoch))); - verifySignRequest(client, KEYPAIR.getPublicKey().toString(), signingRequestBody); + Map.of("fork_info", forkInfo, "randao_reveal", new RandaoRevealWrapper(epoch))); + verifySignRequest( + client, + KEYPAIR.getPublicKey().toString(), + signingRequestBody, + getSpec().getGenesisSchemaDefinitions()); validateMetrics(metricsSystem, 1, 0, 0); } @@ -216,9 +225,12 @@ public void shouldSignAggregationSlot() throws Exception { new SigningRequestBody( signingRootUtil.signingRootForSignAggregationSlot(slot, forkInfo), SignType.AGGREGATION_SLOT, - Map.of( - "fork_info", createForkInfo(forkInfo), "aggregation_slot", Map.of("slot", slot))); - verifySignRequest(client, KEYPAIR.getPublicKey().toString(), signingRequestBody); + Map.of("fork_info", forkInfo, "aggregation_slot", new AggregationSlotWrapper(slot))); + verifySignRequest( + client, + KEYPAIR.getPublicKey().toString(), + signingRequestBody, + getSpec().getGenesisSchemaDefinitions()); validateMetrics(metricsSystem, 1, 0, 0); } @@ -240,12 +252,12 @@ public void shouldSignAggregateAndProof() throws Exception { new SigningRequestBody( signingRootUtil.signingRootForSignAggregateAndProof(aggregateAndProof, forkInfo), SignType.AGGREGATE_AND_PROOF, - Map.of( - "fork_info", - createForkInfo(forkInfo), - "aggregate_and_proof", - new tech.pegasys.teku.api.schema.AggregateAndProof(aggregateAndProof))); - verifySignRequest(client, KEYPAIR.getPublicKey().toString(), signingRequestBody); + Map.of("fork_info", forkInfo, "aggregate_and_proof", aggregateAndProof)); + verifySignRequest( + client, + KEYPAIR.getPublicKey().toString(), + signingRequestBody, + getSpec().getGenesisSchemaDefinitions()); validateMetrics(metricsSystem, 1, 0, 0); } @@ -264,12 +276,12 @@ public void shouldSignVoluntaryExit() throws Exception { new SigningRequestBody( signingRootUtil.signingRootForSignVoluntaryExit(voluntaryExit, forkInfo), SignType.VOLUNTARY_EXIT, - Map.of( - "fork_info", - createForkInfo(forkInfo), - "voluntary_exit", - new tech.pegasys.teku.api.schema.VoluntaryExit(voluntaryExit))); - verifySignRequest(client, KEYPAIR.getPublicKey().toString(), signingRequestBody); + Map.of("fork_info", forkInfo, "voluntary_exit", voluntaryExit)); + verifySignRequest( + client, + KEYPAIR.getPublicKey().toString(), + signingRequestBody, + getSpec().getGenesisSchemaDefinitions()); validateMetrics(metricsSystem, 1, 0, 0); } @@ -290,18 +302,12 @@ public void shouldSignValidatorRegistration() throws Exception { new SigningRequestBody( signingRootUtil.signingRootForValidatorRegistration(validatorRegistration), SignType.VALIDATOR_REGISTRATION, - Map.of( - "validator_registration", - Map.of( - "fee_recipient", - validatorRegistration.getFeeRecipient().toHexString(), - "gas_limit", - validatorRegistration.getGasLimit(), - "timestamp", - validatorRegistration.getTimestamp(), - "pubkey", - validatorRegistration.getPublicKey().toString()))); - verifySignRequest(client, KEYPAIR.getPublicKey().toString(), signingRequestBody); + Map.of(SignType.VALIDATOR_REGISTRATION.getName(), validatorRegistration)); + verifySignRequest( + client, + KEYPAIR.getPublicKey().toString(), + signingRequestBody, + getSpec().getGenesisSchemaDefinitions()); validateMetrics(metricsSystem, 1, 0, 0); } } diff --git a/validator/client/src/integration-test/java/tech/pegasys/teku/validator/client/signer/ExternalSignerTestUtil.java b/validator/client/src/integration-test/java/tech/pegasys/teku/validator/client/signer/ExternalSignerTestUtil.java index 3c3867d6b1f..80e6ecf27db 100644 --- a/validator/client/src/integration-test/java/tech/pegasys/teku/validator/client/signer/ExternalSignerTestUtil.java +++ b/validator/client/src/integration-test/java/tech/pegasys/teku/validator/client/signer/ExternalSignerTestUtil.java @@ -19,47 +19,42 @@ import static org.mockserver.model.JsonBody.json; import com.fasterxml.jackson.core.JsonProcessingException; -import java.util.Map; import org.mockserver.integration.ClientAndServer; -import org.mockserver.model.MediaType; -import tech.pegasys.teku.api.schema.Fork; +import org.mockserver.model.JsonBody; +import tech.pegasys.teku.infrastructure.json.JsonUtil; import tech.pegasys.teku.infrastructure.metrics.StubCounter; import tech.pegasys.teku.infrastructure.metrics.StubMetricsSystem; import tech.pegasys.teku.infrastructure.metrics.TekuMetricCategory; -import tech.pegasys.teku.provider.JsonProvider; -import tech.pegasys.teku.spec.datastructures.state.ForkInfo; +import tech.pegasys.teku.spec.schemas.SchemaDefinitions; class ExternalSignerTestUtil { - private static final JsonProvider JSON_PROVIDER = new JsonProvider(); static void verifySignRequest( final ClientAndServer client, final String publicKey, - final SigningRequestBody signingRequestBody) + final SigningRequestBody signingRequestBody, + final SchemaDefinitions schemaDefinitions) throws JsonProcessingException { + final JsonBody body = + json( + JsonUtil.serialize( + signingRequestBody, signingRequestBody.getJsonTypeDefinition(schemaDefinitions)), + STRICT); client.verify( request() .withMethod("POST") - .withContentType(MediaType.APPLICATION_JSON) - .withBody(json(JSON_PROVIDER.objectToJSON(signingRequestBody), STRICT)) + .withBody(body) + .withHeader("Content-Type", "application/json") .withPath(ExternalSigner.EXTERNAL_SIGNER_ENDPOINT + "/" + publicKey)); } - static Map createForkInfo(final ForkInfo forkInfo) { - return Map.of( - "genesis_validators_root", - forkInfo.getGenesisValidatorsRoot(), - "fork", - new Fork(forkInfo.getFork())); - } - static void validateMetrics( final StubMetricsSystem metricsSystem, final long successCount, final long failCount, final long timeoutCount) { final StubCounter labelledCounter = - metricsSystem.getCounter(TekuMetricCategory.VALIDATOR, "external_signer_requests"); + metricsSystem.getCounter(TekuMetricCategory.VALIDATOR, "external_signer_requests_total"); assertThat(labelledCounter.getValue("success")).isEqualTo(successCount); assertThat(labelledCounter.getValue("failed")).isEqualTo(failCount); assertThat(labelledCounter.getValue("timeout")).isEqualTo(timeoutCount); diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/BeaconProposerPreparer.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/BeaconProposerPreparer.java index 72c378da4bc..2aba20e4c83 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/BeaconProposerPreparer.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/BeaconProposerPreparer.java @@ -28,7 +28,7 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; import tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing; -import tech.pegasys.teku.spec.datastructures.operations.versions.bellatrix.BeaconPreparableProposer; +import tech.pegasys.teku.spec.datastructures.validator.BeaconPreparableProposer; import tech.pegasys.teku.validator.api.ValidatorApiChannel; import tech.pegasys.teku.validator.api.ValidatorTimingChannel; diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/DvtAttestationAggregations.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/DvtAttestationAggregations.java index ef668b388cb..78457dd82d8 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/DvtAttestationAggregations.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/DvtAttestationAggregations.java @@ -37,7 +37,7 @@ public class DvtAttestationAggregations { private final int expectedDutiesCount; public DvtAttestationAggregations( - final ValidatorApiChannel validatorApiChannel, int expectedDutiesCount) { + final ValidatorApiChannel validatorApiChannel, final int expectedDutiesCount) { this.validatorApiChannel = validatorApiChannel; this.expectedDutiesCount = expectedDutiesCount; } diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/NoOpKeyManager.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/NoOpKeyManager.java index b1298690445..9d225ff8c08 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/NoOpKeyManager.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/NoOpKeyManager.java @@ -39,7 +39,7 @@ public List getRemoteValidatorKeys() { } @Override - public Optional getValidatorByPublicKey(BLSPublicKey publicKey) { + public Optional getValidatorByPublicKey(final BLSPublicKey publicKey) { return Optional.empty(); } @@ -50,7 +50,7 @@ public DeleteKeysResponse deleteValidators( } @Override - public DeleteRemoteKeysResponse deleteExternalValidators(List validators) { + public DeleteRemoteKeysResponse deleteExternalValidators(final List validators) { return new DeleteRemoteKeysResponse(Collections.emptyList()); } @@ -66,7 +66,7 @@ public List importValidators( @Override public List importExternalValidators( - List validators, + final List validators, final Optional maybeDoppelgangerDetector, final SlashingRiskAction doppelgangerDetectionAction) { return Collections.emptyList(); diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/OwnedKeyManager.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/OwnedKeyManager.java index 6ff96a1161e..3e77a8282bd 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/OwnedKeyManager.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/OwnedKeyManager.java @@ -73,7 +73,7 @@ public List getRemoteValidatorKeys() { } @Override - public Optional getValidatorByPublicKey(BLSPublicKey publicKey) { + public Optional getValidatorByPublicKey(final BLSPublicKey publicKey) { return validatorLoader.getOwnedValidators().getValidator(publicKey); } @@ -392,7 +392,7 @@ public List importExternalValidators( importResults.add( validatorLoader.loadExternalMutableValidator( externalValidator.getPublicKey(), externalValidator.getUrl(), false)); - if (importResults.get(importResults.size() - 1).getPostKeyResult().getImportStatus() + if (importResults.getLast().getPostKeyResult().getImportStatus() == ImportStatus.IMPORTED) { reloadRequired = true; } @@ -427,7 +427,7 @@ public List importExternalValidators( importResults.add( validatorLoader.loadExternalMutableValidator( externalValidator.getPublicKey(), externalValidator.getUrl(), true)); - if (importResults.get(importResults.size() - 1).getPostKeyResult().getImportStatus() + if (importResults.getLast().getPostKeyResult().getImportStatus() == ImportStatus.IMPORTED) { reloadRequired = true; } diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/OwnedValidatorStatusProvider.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/OwnedValidatorStatusProvider.java index 6f087c91bde..b99e8815a06 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/OwnedValidatorStatusProvider.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/OwnedValidatorStatusProvider.java @@ -88,7 +88,7 @@ public SafeFuture start() { } @Override - public void onSlot(UInt64 slot) { + public void onSlot(final UInt64 slot) { final UInt64 epoch = spec.computeEpochAtSlot(slot); currentEpoch.set(epoch); final UInt64 firstSlotOfEpoch = spec.computeStartSlotAtEpoch(epoch); @@ -99,10 +99,10 @@ public void onSlot(UInt64 slot) { @Override public void onHeadUpdate( - UInt64 slot, - Bytes32 previousDutyDependentRoot, - Bytes32 currentDutyDependentRoot, - Bytes32 headBlockRoot) {} + final UInt64 slot, + final Bytes32 previousDutyDependentRoot, + final Bytes32 currentDutyDependentRoot, + final Bytes32 headBlockRoot) {} @Override public void onPossibleMissedEvents() { @@ -115,19 +115,19 @@ public void onValidatorsAdded() { } @Override - public void onBlockProductionDue(UInt64 slot) {} + public void onBlockProductionDue(final UInt64 slot) {} @Override - public void onAttestationCreationDue(UInt64 slot) {} + public void onAttestationCreationDue(final UInt64 slot) {} @Override - public void onAttestationAggregationDue(UInt64 slot) {} + public void onAttestationAggregationDue(final UInt64 slot) {} @Override - public void onAttesterSlashing(AttesterSlashing attesterSlashing) {} + public void onAttesterSlashing(final AttesterSlashing attesterSlashing) {} @Override - public void onProposerSlashing(ProposerSlashing proposerSlashing) {} + public void onProposerSlashing(final ProposerSlashing proposerSlashing) {} @Override public void onUpdatedValidatorStatuses( diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/PendingDuties.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/PendingDuties.java index 8384845f185..efe650fe585 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/PendingDuties.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/PendingDuties.java @@ -54,7 +54,7 @@ private PendingDuties( dutiesPerformedCounter = metricsSystem.createLabelledCounter( TekuMetricCategory.VALIDATOR, - "duties_performed", + "duties_performed_total", "Count of the failed duties, by duty type", "type", "result"); diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/ProposerConfig.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/ProposerConfig.java index f3d09c47bb9..8517f646d4f 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/ProposerConfig.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/ProposerConfig.java @@ -30,10 +30,10 @@ public class ProposerConfig { @JsonProperty(value = "proposer_config") - private Map proposerConfig; + private final Map proposerConfig; @JsonProperty(value = "default_config") - private Config defaultConfig; + private final Config defaultConfig; @JsonCreator public ProposerConfig( @@ -94,10 +94,10 @@ public int hashCode() { @JsonIgnoreProperties(ignoreUnknown = true) public static class Config { @JsonProperty(value = "fee_recipient") - private Eth1Address feeRecipient; + private final Eth1Address feeRecipient; @JsonProperty(value = "builder") - private BuilderConfig builder; + private final BuilderConfig builder; @JsonCreator public Config( @@ -141,13 +141,13 @@ public int hashCode() { @JsonIgnoreProperties(ignoreUnknown = true) public static class BuilderConfig { @JsonProperty(value = "enabled") - private Boolean enabled; + private final Boolean enabled; @JsonProperty(value = "gas_limit") - private UInt64 gasLimit; + private final UInt64 gasLimit; @JsonProperty(value = "registration_overrides") - private RegistrationOverrides registrationOverrides; + private final RegistrationOverrides registrationOverrides; @JsonCreator public BuilderConfig( @@ -194,10 +194,10 @@ public int hashCode() { public static class RegistrationOverrides { @JsonProperty(value = "timestamp") - private UInt64 timestamp; + private final UInt64 timestamp; @JsonProperty(value = "public_key") - private BLSPublicKey publicKey; + private final BLSPublicKey publicKey; @JsonCreator public RegistrationOverrides( diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/RuntimeProposerConfig.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/RuntimeProposerConfig.java index d0a6894dcb2..986df00db2e 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/RuntimeProposerConfig.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/RuntimeProposerConfig.java @@ -13,7 +13,7 @@ package tech.pegasys.teku.validator.client; -import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.ETH1ADDRESS_TYPE; +import static tech.pegasys.teku.ethereum.execution.types.Eth1Address.ETH1ADDRESS_TYPE; import com.google.common.base.Preconditions; import java.io.FileInputStream; diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/SetGasLimitException.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/SetGasLimitException.java index 4ab3c05d34e..815255b6ae4 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/SetGasLimitException.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/SetGasLimitException.java @@ -15,7 +15,7 @@ public class SetGasLimitException extends IllegalArgumentException { - public SetGasLimitException(String message) { + public SetGasLimitException(final String message) { super(message); } } diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/SyncCommitteeDutyLoader.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/SyncCommitteeDutyLoader.java index 4493f909c5d..b2b52843a09 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/SyncCommitteeDutyLoader.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/SyncCommitteeDutyLoader.java @@ -48,7 +48,7 @@ public SyncCommitteeDutyLoader( final ChainHeadTracker chainHeadTracker, final ForkProvider forkProvider, final MetricsSystem metricsSystem, - boolean useDvtEndpoint) { + final boolean useDvtEndpoint) { super(validators, validatorIndexProvider); this.spec = spec; this.validatorApiChannel = validatorApiChannel; diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/Validator.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/Validator.java index ddcdd1532e4..63252a306c9 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/Validator.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/Validator.java @@ -57,6 +57,10 @@ public boolean isReadOnly() { return readOnly; } + public GraffitiProvider getGraffitiProvider() { + return graffitiProvider; + } + @Override public String toString() { return "Validator{" + "publicKey=" + publicKey + '}'; diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/ValidatorClientService.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/ValidatorClientService.java index 2ea4f366f57..e5659fa220c 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/ValidatorClientService.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/ValidatorClientService.java @@ -23,10 +23,13 @@ import java.util.List; import java.util.Optional; import java.util.Random; +import java.util.function.Function; import java.util.function.Supplier; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; +import org.apache.tuweni.bytes.Bytes32; import org.hyperledger.besu.plugin.services.MetricsSystem; +import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.infrastructure.async.AsyncRunner; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.events.EventChannels; @@ -38,7 +41,6 @@ import tech.pegasys.teku.infrastructure.metrics.TekuMetricCategory; import tech.pegasys.teku.infrastructure.restapi.RestApi; import tech.pegasys.teku.infrastructure.time.TimeProvider; -import tech.pegasys.teku.provider.JsonProvider; import tech.pegasys.teku.service.serviceutils.Service; import tech.pegasys.teku.service.serviceutils.ServiceConfig; import tech.pegasys.teku.service.serviceutils.layout.DataDirLayout; @@ -47,6 +49,7 @@ import tech.pegasys.teku.spec.signatures.LocalSlashingProtector; import tech.pegasys.teku.spec.signatures.LocalSlashingProtectorConcurrentAccess; import tech.pegasys.teku.spec.signatures.SlashingProtector; +import tech.pegasys.teku.validator.api.GraffitiManager; import tech.pegasys.teku.validator.api.ValidatorApiChannel; import tech.pegasys.teku.validator.api.ValidatorConfig; import tech.pegasys.teku.validator.api.ValidatorTimingChannel; @@ -153,8 +156,17 @@ public static ValidatorClientService create( new GenesisDataProvider(asyncRunner, validatorApiChannel); final ForkProvider forkProvider = new ForkProvider(config.getSpec(), genesisDataProvider); - final ValidatorLoader validatorLoader = createValidatorLoader(services, config, asyncRunner); final ValidatorRestApiConfig validatorApiConfig = config.getValidatorRestApiConfig(); + final Optional graffitiManager = + Optional.ofNullable( + validatorApiConfig.isRestApiEnabled() + ? new GraffitiManager(services.getDataDirLayout()) + : null); + final Function> updatableGraffitiProvider = + (publicKey) -> graffitiManager.flatMap(manager -> manager.getGraffiti(publicKey)); + + final ValidatorLoader validatorLoader = + createValidatorLoader(services, config, asyncRunner, updatableGraffitiProvider); final ValidatorStatusProvider validatorStatusProvider = new OwnedValidatorStatusProvider( services.getMetricsSystem(), @@ -171,7 +183,7 @@ public static ValidatorClientService create( ProposerConfigProvider.create( asyncRunner, validatorConfig.getRefreshProposerConfigFromSource(), - new ProposerConfigLoader(new JsonProvider().getObjectMapper()), + new ProposerConfigLoader(), services.getTimeProvider(), validatorConfig.getProposerConfigSource()); @@ -200,7 +212,8 @@ public static ValidatorClientService create( new SignedValidatorRegistrationFactory( proposerConfigManager.get(), services.getTimeProvider()), validatorApiChannel, - validatorConfig.getBuilderRegistrationSendingBatchSize()); + validatorConfig.getBuilderRegistrationSendingBatchSize(), + asyncRunner); validatorStatusProvider.subscribeValidatorStatusesUpdates( validatorRegistratorImpl::onUpdatedValidatorStatuses); validatorRegistrator = Optional.of(validatorRegistratorImpl); @@ -253,7 +266,8 @@ public static ValidatorClientService create( services.getEventChannels().getPublisher(ValidatorTimingChannel.class)), services.getDataDirLayout(), services.getTimeProvider(), - validatorClientService.maybeDoppelgangerDetector); + validatorClientService.maybeDoppelgangerDetector, + graffitiManager.orElseThrow()); } else { LOG.info("validator-api-enabled is false, not starting rest api."); } @@ -329,7 +343,8 @@ private void initializeValidatorRestApi( final OwnedKeyManager keyManager, final DataDirLayout dataDirLayout, final TimeProvider timeProvider, - final Optional maybeDoppelgangerDetector) { + final Optional maybeDoppelgangerDetector, + final GraffitiManager graffitiManager) { final RestApi validatorRestApi = ValidatorRestApi.create( spec, @@ -341,7 +356,8 @@ private void initializeValidatorRestApi( dataDirLayout, timeProvider, maybeDoppelgangerDetector, - new DoppelgangerDetectionAlert()); + new DoppelgangerDetectionAlert(), + graffitiManager); maybeValidatorRestApi = Optional.of(validatorRestApi); } @@ -391,7 +407,8 @@ private static BeaconNodeApi createBeaconNodeApi( private static ValidatorLoader createValidatorLoader( final ServiceConfig services, final ValidatorClientConfiguration config, - final AsyncRunner asyncRunner) { + final AsyncRunner asyncRunner, + final Function> updatableGraffitiProvider) { final Path slashingProtectionPath = getSlashingProtectionPath(services.getDataDirLayout()); final SlashingProtector slashingProtector = config.getValidatorConfig().isLocalSlashingProtectionSynchronizedModeEnabled() @@ -418,7 +435,8 @@ private static ValidatorLoader createValidatorLoader( services.getMetricsSystem(), config.getValidatorRestApiConfig().isRestApiEnabled() ? Optional.of(services.getDataDirLayout()) - : Optional.empty()); + : Optional.empty(), + updatableGraffitiProvider); } private void initializeValidators( @@ -430,22 +448,16 @@ private void initializeValidators( } private void scheduleValidatorsDuties( - ValidatorClientConfiguration config, - ValidatorApiChannel validatorApiChannel, - AsyncRunner asyncRunner) { + final ValidatorClientConfiguration config, + final ValidatorApiChannel validatorApiChannel, + final AsyncRunner asyncRunner) { validatorTimingChannels.add(validatorStatusProvider); final OwnedValidators validators = validatorLoader.getOwnedValidators(); final BlockContainerSigner blockContainerSigner = new MilestoneBasedBlockContainerSigner(spec); final ValidatorDutyMetrics validatorDutyMetrics = ValidatorDutyMetrics.create(metricsSystem); final BlockDutyFactory blockDutyFactory = new BlockDutyFactory( - forkProvider, - validatorApiChannel, - blockContainerSigner, - config.getValidatorConfig().isBlindedBeaconBlocksEnabled(), - config.getValidatorConfig().isBlockV3Enabled(), - spec, - validatorDutyMetrics); + forkProvider, validatorApiChannel, blockContainerSigner, spec, validatorDutyMetrics); final AttestationDutyFactory attestationDutyFactory = new AttestationDutyFactory(spec, forkProvider, validatorApiChannel, validatorDutyMetrics); final BeaconCommitteeSubscriptions beaconCommitteeSubscriptions = diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/ValidatorIndexProvider.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/ValidatorIndexProvider.java index 16dc14d1172..fb331fcf30c 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/ValidatorIndexProvider.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/ValidatorIndexProvider.java @@ -107,7 +107,7 @@ public Optional getPublicKey(final Integer index) { .map(Map.Entry::getKey); } - public boolean containsPublicKey(BLSPublicKey publicKey) { + public boolean containsPublicKey(final BLSPublicKey publicKey) { return validatorIndicesByPublicKey.containsKey(publicKey); } diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/ValidatorRegistrator.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/ValidatorRegistrator.java index 7f8f8aba3bb..632f21f0c18 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/ValidatorRegistrator.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/ValidatorRegistrator.java @@ -17,6 +17,7 @@ import com.google.common.collect.Lists; import com.google.common.collect.Maps; +import java.time.Duration; import java.util.HashSet; import java.util.Iterator; import java.util.List; @@ -34,6 +35,7 @@ import org.apache.tuweni.bytes.Bytes32; import tech.pegasys.teku.api.response.v1.beacon.ValidatorStatus; import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.infrastructure.async.AsyncRunner; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.ssz.impl.SszUtils; @@ -59,13 +61,14 @@ public class ValidatorRegistrator implements ValidatorTimingChannel { private static final Logger LOG = LogManager.getLogger(); + private static final Duration RETRY_DELAY = Duration.ofSeconds(30); + private final Map cachedValidatorRegistrations = Maps.newConcurrentMap(); - private final AtomicBoolean firstCallDone = new AtomicBoolean(false); private final AtomicBoolean registrationInProgress = new AtomicBoolean(false); private final AtomicReference currentEpoch = new AtomicReference<>(); - private final AtomicReference lastRunEpoch = new AtomicReference<>(); + private final AtomicReference lastSuccessfulRunEpoch = new AtomicReference<>(); private final Spec spec; private final OwnedValidators ownedValidators; @@ -73,6 +76,7 @@ public class ValidatorRegistrator implements ValidatorTimingChannel { private final SignedValidatorRegistrationFactory signedValidatorRegistrationFactory; private final ValidatorApiChannel validatorApiChannel; private final int batchSize; + private final AsyncRunner asyncRunner; public ValidatorRegistrator( final Spec spec, @@ -80,13 +84,15 @@ public ValidatorRegistrator( final ProposerConfigPropertiesProvider proposerConfigPropertiesProvider, final SignedValidatorRegistrationFactory signedValidatorRegistrationFactory, final ValidatorApiChannel validatorApiChannel, - final int batchSize) { + final int batchSize, + final AsyncRunner asyncRunner) { this.spec = spec; this.ownedValidators = ownedValidators; this.proposerConfigPropertiesProvider = proposerConfigPropertiesProvider; this.signedValidatorRegistrationFactory = signedValidatorRegistrationFactory; this.validatorApiChannel = validatorApiChannel; this.batchSize = batchSize; + this.asyncRunner = asyncRunner; } @Override @@ -129,6 +135,7 @@ public void onAttesterSlashing(final AttesterSlashing attesterSlashing) {} public void onProposerSlashing(final ProposerSlashing proposerSlashing) {} @Override + @SuppressWarnings("FutureReturnValueIgnored") public void onUpdatedValidatorStatuses( final Map newValidatorStatuses, final boolean possibleMissingEvents) { @@ -160,7 +167,14 @@ public void onUpdatedValidatorStatuses( return registerValidators(newValidators, false); } }) - .finish(VALIDATOR_LOGGER::registeringValidatorsFailed); + .finish( + error -> { + VALIDATOR_LOGGER.registeringValidatorsFailed(error); + LOG.info("Will retry to register validators in {} seconds", RETRY_DELAY.toSeconds()); + asyncRunner.runAfterDelay( + () -> onUpdatedValidatorStatuses(newValidatorStatuses, possibleMissingEvents), + RETRY_DELAY); + }); } public int getNumberOfCachedRegistrations() { @@ -202,29 +216,31 @@ private List getValidatorsRequiringRegistration( } private boolean registrationNeedsToBeRun(final boolean possibleMissingEvents) { - final boolean isFirstCall = firstCallDone.compareAndSet(false, true); - if (isFirstCall || possibleMissingEvents) { + if (lastSuccessfulRunEpoch.get() == null || possibleMissingEvents) { return true; } return currentEpoch .get() - .minus(lastRunEpoch.get()) + .minus(lastSuccessfulRunEpoch.get()) .isGreaterThanOrEqualTo(Constants.EPOCHS_PER_VALIDATOR_REGISTRATION_SUBMISSION); } private SafeFuture registerValidators( - final List validators, final boolean updateLastRunEpoch) { + final List validators, final boolean updateLastSuccessfulRunEpoch) { if (!registrationInProgress.compareAndSet(false, true)) { LOG.warn( "Validator registration(s) is still in progress. Will skip sending registration(s)."); return SafeFuture.COMPLETE; } - if (updateLastRunEpoch) { - lastRunEpoch.set(currentEpoch.get()); - } return processInBatches(validators) + .whenSuccess( + () -> { + if (updateLastSuccessfulRunEpoch) { + lastSuccessfulRunEpoch.set(currentEpoch.get()); + } + }) .alwaysRun( () -> { registrationInProgress.set(false); diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/doppelganger/DoppelgangerDetector.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/doppelganger/DoppelgangerDetector.java index a451a1e189a..bb4e3b9fc41 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/doppelganger/DoppelgangerDetector.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/doppelganger/DoppelgangerDetector.java @@ -117,7 +117,7 @@ private class DoppelgangerDetectionTask { private final Set pubKeys; private Optional epochAtStart = Optional.empty(); private final Map detectedDoppelgangers = new HashMap<>(); - private AtomicBoolean firstCheck = new AtomicBoolean(true); + private final AtomicBoolean firstCheck = new AtomicBoolean(true); public DoppelgangerDetectionTask(final UInt64 startTime, final Set pubKeys) { this.startTime = startTime; @@ -286,7 +286,7 @@ private SafeFuture checkValidatorsLivenessAtEpoch( } private void logMissingIndices( - final Set pubKeys, Map validatorIndicesByPubKey) { + final Set pubKeys, final Map validatorIndicesByPubKey) { Set publicKeysWithoutIndices = pubKeys.stream() .filter(publicKey -> !validatorIndicesByPubKey.containsKey(publicKey)) @@ -313,7 +313,7 @@ private void checkValidatorDoppelgangers( doppelgangers.forEach( doppelganger -> detectedDoppelgangers.putIfAbsent( - doppelganger.getRight().getIndex(), doppelganger.getLeft())); + doppelganger.getRight().index(), doppelganger.getLeft())); if (allKeysAreActive()) { statusLog.doppelgangerDetectionEnd( mapToAbbreviatedKeys(pubKeys).collect(Collectors.toSet()), @@ -327,7 +327,7 @@ private void checkValidatorDoppelgangers( private Map mapLivenessAtEpochToIndicesByPubKeyStrings( final List> doppelgangers) { return doppelgangers.stream() - .collect(Collectors.toMap(e -> e.getRight().getIndex(), e -> e.getLeft().toString())); + .collect(Collectors.toMap(e -> e.getRight().index(), e -> e.getLeft().toString())); } private Stream mapToAbbreviatedKeys(final Set pubKeys) { @@ -344,7 +344,7 @@ private List> filterLiveValidators( .filter( validatorLivenessAtEpoch -> validatorPubKeysByIndices.containsValue( - validatorLivenessAtEpoch.getIndex()) + validatorLivenessAtEpoch.index()) && validatorLivenessAtEpoch.isLive()) .map( validatorLivenessAtEpoch -> @@ -352,8 +352,7 @@ private List> filterLiveValidators( validatorPubKeysByIndices.entrySet().stream() .filter( e -> - e.getValue() - .equals(validatorLivenessAtEpoch.getIndex())) + e.getValue().equals(validatorLivenessAtEpoch.index())) .findFirst() .get() .getKey(), diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/BlockDutyFactory.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/BlockDutyFactory.java index 521a0d6ae4f..d04622e5e08 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/BlockDutyFactory.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/BlockDutyFactory.java @@ -26,23 +26,17 @@ public class BlockDutyFactory implements DutyFactory private final ValidatorApiChannel validatorApiChannel; private final BlockContainerSigner blockContainerSigner; private final Spec spec; - private final boolean useBlindedBlock; - private final boolean blockV3Enabled; private final ValidatorDutyMetrics validatorDutyMetrics; public BlockDutyFactory( final ForkProvider forkProvider, final ValidatorApiChannel validatorApiChannel, final BlockContainerSigner blockContainerSigner, - final boolean useBlindedBlock, - final boolean blockV3Enabled, final Spec spec, final ValidatorDutyMetrics validatorDutyMetrics) { this.forkProvider = forkProvider; this.validatorApiChannel = validatorApiChannel; this.blockContainerSigner = blockContainerSigner; - this.useBlindedBlock = useBlindedBlock; - this.blockV3Enabled = blockV3Enabled; this.spec = spec; this.validatorDutyMetrics = validatorDutyMetrics; } @@ -55,8 +49,6 @@ public BlockProductionDuty createProductionDuty(final UInt64 slot, final Validat forkProvider, validatorApiChannel, blockContainerSigner, - useBlindedBlock, - blockV3Enabled, spec, validatorDutyMetrics); } diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/BlockProductionDuty.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/BlockProductionDuty.java index 5e5513f5699..23b2e985449 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/BlockProductionDuty.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/BlockProductionDuty.java @@ -14,7 +14,7 @@ package tech.pegasys.teku.validator.client.duties; import static com.google.common.base.Preconditions.checkArgument; -import static tech.pegasys.teku.infrastructure.logging.Converter.gweiToEth; +import static tech.pegasys.teku.infrastructure.logging.Converter.weiToEth; import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ZERO; import com.google.common.annotations.VisibleForTesting; @@ -50,8 +50,6 @@ public class BlockProductionDuty implements Duty { private final ForkProvider forkProvider; private final ValidatorApiChannel validatorApiChannel; private final BlockContainerSigner blockContainerSigner; - private final boolean useBlindedBlock; - private final boolean blockV3Enabled; private final Spec spec; private final ValidatorDutyMetrics validatorDutyMetrics; @@ -61,8 +59,6 @@ public BlockProductionDuty( final ForkProvider forkProvider, final ValidatorApiChannel validatorApiChannel, final BlockContainerSigner blockContainerSigner, - final boolean useBlindedBlock, - final boolean blockV3Enabled, final Spec spec, final ValidatorDutyMetrics validatorDutyMetrics) { this.validator = validator; @@ -70,8 +66,6 @@ public BlockProductionDuty( this.forkProvider = forkProvider; this.validatorApiChannel = validatorApiChannel; this.blockContainerSigner = blockContainerSigner; - this.useBlindedBlock = useBlindedBlock; - this.blockV3Enabled = blockV3Enabled; this.spec = spec; this.validatorDutyMetrics = validatorDutyMetrics; } @@ -113,17 +107,8 @@ private SafeFuture createRandaoReveal(final ForkInfo forkInfo) { private SafeFuture> createUnsignedBlock( final BLSSignature randaoReveal) { - if (blockV3Enabled) { - return validatorApiChannel.createUnsignedBlock( - slot, randaoReveal, validator.getGraffiti(), Optional.empty(), Optional.empty()); - } else { - return validatorApiChannel.createUnsignedBlock( - slot, - randaoReveal, - validator.getGraffiti(), - Optional.of(useBlindedBlock), - Optional.empty()); - } + return validatorApiChannel.createUnsignedBlock( + slot, randaoReveal, validator.getGraffiti(), Optional.empty()); } private SafeFuture validateBlock( @@ -142,8 +127,8 @@ private SafeFuture validateBlock( LOG.info( "Received block for slot {}, block rewards {} ETH, execution payload value {} ETH", slot, - gweiToEth(blockContainerAndMetaData.consensusBlockValue()), - gweiToEth(blockContainerAndMetaData.executionPayloadValue())); + weiToEth(blockContainerAndMetaData.consensusBlockValue()), + weiToEth(blockContainerAndMetaData.executionPayloadValue())); } return SafeFuture.completedFuture(unsignedBlockContainer); } @@ -155,7 +140,7 @@ private SafeFuture signBlockContainer( private SafeFuture sendBlock(final SignedBlockContainer signedBlockContainer) { return validatorApiChannel - .sendSignedBlock(signedBlockContainer, BroadcastValidationLevel.NOT_REQUIRED) + .sendSignedBlock(signedBlockContainer, BroadcastValidationLevel.GOSSIP) .thenApply( result -> { if (result.isPublished()) { diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/ProductionResult.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/ProductionResult.java index aefcf661baf..e54670e3d6d 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/ProductionResult.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/ProductionResult.java @@ -95,21 +95,21 @@ public static SafeFuture send( private static void replaceResult( final List> sentResults, final SubmitDataError error) { - if (error.getIndex().isGreaterThanOrEqualTo(sentResults.size())) { + if (error.index().isGreaterThanOrEqualTo(sentResults.size())) { LOG.error( "Beacon node reported an error at index {} with message '{}' but only {} messages were sent", - error.getIndex(), - error.getMessage(), + error.index(), + error.message(), sentResults.size()); return; } - final int index = error.getIndex().intValue(); + final int index = error.index().intValue(); final ProductionResult originalResult = sentResults.get(index); sentResults.set( index, ProductionResult.failure( originalResult.getValidatorPublicKeys(), - new RestApiReportedException(error.getMessage()))); + new RestApiReportedException(error.message()))); } private static DutyResult combineResults(final List> results) { diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/attestations/AggregationDuty.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/attestations/AggregationDuty.java index 143d06cce55..d2d0419c8b5 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/attestations/AggregationDuty.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/attestations/AggregationDuty.java @@ -97,7 +97,7 @@ public void addValidator( new CommitteeAggregator( validator, UInt64.valueOf(validatorIndex), - attestationCommitteeIndex, + UInt64.valueOf(attestationCommitteeIndex), proof, unsignedAttestationFuture)); } @@ -135,7 +135,11 @@ public SafeFuture> createAggregate( final SafeFuture> createAggregationFuture = validatorDutyMetrics.record( - () -> validatorApiChannel.createAggregate(slot, attestationData.hashTreeRoot()), + () -> + validatorApiChannel.createAggregate( + slot, + attestationData.hashTreeRoot(), + Optional.of(aggregator.attestationCommitteeIndex)), this, ValidatorDutyMetricsSteps.CREATE); @@ -184,14 +188,14 @@ private static class CommitteeAggregator { private final Validator validator; private final UInt64 validatorIndex; - private final int attestationCommitteeIndex; + private final UInt64 attestationCommitteeIndex; private final BLSSignature proof; private final SafeFuture> unsignedAttestationFuture; private CommitteeAggregator( final Validator validator, final UInt64 validatorIndex, - final int attestationCommitteeIndex, + final UInt64 attestationCommitteeIndex, final BLSSignature proof, final SafeFuture> unsignedAttestationFuture) { this.validator = validator; diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/attestations/AttestationProductionDuty.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/attestations/AttestationProductionDuty.java index 303a739ac80..c6d97eab41e 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/attestations/AttestationProductionDuty.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/attestations/AttestationProductionDuty.java @@ -20,6 +20,7 @@ import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap; import java.util.List; import java.util.Optional; +import java.util.function.Supplier; import java.util.stream.Stream; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; @@ -28,11 +29,12 @@ import tech.pegasys.teku.infrastructure.metrics.Validator.DutyType; import tech.pegasys.teku.infrastructure.metrics.Validator.ValidatorDutyMetricsSteps; import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; import tech.pegasys.teku.validator.api.ValidatorApiChannel; import tech.pegasys.teku.validator.client.ForkProvider; @@ -92,7 +94,8 @@ public SafeFuture> addValidator( final ScheduledCommittee committee = validatorsByCommitteeIndex.computeIfAbsent( attestationCommitteeIndex, key -> new ScheduledCommittee()); - committee.addValidator(validator, committeePosition, validatorIndex, committeeSize); + committee.addValidator( + validator, attestationCommitteeIndex, committeePosition, validatorIndex, committeeSize); return committee.getAttestationDataFuture(); } @@ -145,7 +148,7 @@ private SafeFuture> signAttestationForValidatorInC final UInt64 slot, final ForkInfo forkInfo, final int committeeIndex, - final ValidatorWithCommitteePositionAndIndex validator, + final ValidatorWithAttestationDutyInfo validator, final SafeFuture> attestationDataFuture) { return attestationDataFuture .thenCompose( @@ -164,14 +167,14 @@ private SafeFuture> signAttestationForValidatorInC () -> SafeFuture.completedFuture( ProductionResult.failure( - validator.getPublicKey(), + validator.publicKey(), new IllegalStateException( "Unable to produce attestation for slot " + slot + " with committee " + committeeIndex + " because chain data was unavailable"))))) - .exceptionally(error -> ProductionResult.failure(validator.getPublicKey(), error)); + .exceptionally(error -> ProductionResult.failure(validator.publicKey(), error)); } private static void validateAttestationData( @@ -186,27 +189,35 @@ private static void validateAttestationData( private SafeFuture> signAttestationForValidator( final ForkInfo forkInfo, final AttestationData attestationData, - final ValidatorWithCommitteePositionAndIndex validator) { + final ValidatorWithAttestationDutyInfo validator) { return validator - .getSigner() + .signer() .signAttestationData(attestationData, forkInfo) .thenApply(signature -> createSignedAttestation(attestationData, validator, signature)) .thenApply( attestation -> ProductionResult.success( - validator.getPublicKey(), attestationData.getBeaconBlockRoot(), attestation)); + validator.publicKey(), attestationData.getBeaconBlockRoot(), attestation)); } private Attestation createSignedAttestation( final AttestationData attestationData, - final ValidatorWithCommitteePositionAndIndex validator, + final ValidatorWithAttestationDutyInfo validator, final BLSSignature signature) { - final AttestationSchema attestationSchema = + final AttestationSchema attestationSchema = spec.atSlot(attestationData.getSlot()).getSchemaDefinitions().getAttestationSchema(); - SszBitlist aggregationBits = + final SszBitlist aggregationBits = attestationSchema .getAggregationBitsSchema() - .ofBits(validator.getCommitteeSize(), validator.getCommitteePosition()); - return attestationSchema.create(aggregationBits, attestationData, signature); + .ofBits(validator.committeeSize(), validator.committeePosition()); + + final Supplier committeeBitsSupplier = + attestationSchema + .getCommitteeBitsSchema() + .>map( + committeeBitsSchema -> () -> committeeBitsSchema.ofBits(validator.committeeIndex())) + .orElse(() -> null); + return attestationSchema.create( + aggregationBits, attestationData, signature, committeeBitsSupplier); } } diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/attestations/ScheduledCommittee.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/attestations/ScheduledCommittee.java index 126fa4a0369..11d2cdbc904 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/attestations/ScheduledCommittee.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/attestations/ScheduledCommittee.java @@ -27,32 +27,31 @@ class ScheduledCommittee { - private final List validators = new ArrayList<>(); + private final List validators = new ArrayList<>(); private final SafeFuture> attestationDataFuture = new SafeFuture<>(); public synchronized void addValidator( final Validator validator, + final int committeeIndex, final int committeePosition, final int validatorIndex, final int committeeSize) { validators.add( - new ValidatorWithCommitteePositionAndIndex( - validator, committeePosition, validatorIndex, committeeSize)); + new ValidatorWithAttestationDutyInfo( + validator, committeeIndex, committeePosition, validatorIndex, committeeSize)); } public synchronized List> forEach( - final Function> action) { + final Function> action) { return validators.stream().map(action).toList(); } - public List getValidators() { + public List getValidators() { return validators; } public Set getValidatorPublicKeys() { - return validators.stream() - .map(ValidatorWithCommitteePositionAndIndex::getPublicKey) - .collect(toSet()); + return validators.stream().map(ValidatorWithAttestationDutyInfo::publicKey).collect(toSet()); } public SafeFuture> getAttestationDataFuture() { diff --git a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetNewBlindedBlockTest.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/attestations/ValidatorWithAttestationDutyInfo.java similarity index 54% rename from data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetNewBlindedBlockTest.java rename to validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/attestations/ValidatorWithAttestationDutyInfo.java index 0a78ef8573b..18afecb8f06 100644 --- a/data/beaconrestapi/src/test/java/tech/pegasys/teku/beaconrestapi/handlers/v1/validator/GetNewBlindedBlockTest.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/attestations/ValidatorWithAttestationDutyInfo.java @@ -11,20 +11,24 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.beaconrestapi.handlers.v1.validator; +package tech.pegasys.teku.validator.client.duties.attestations; -import tech.pegasys.teku.beaconrestapi.AbstractGetNewBlockTest; -import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.spec.signatures.Signer; +import tech.pegasys.teku.validator.client.Validator; -public class GetNewBlindedBlockTest extends AbstractGetNewBlockTest { +record ValidatorWithAttestationDutyInfo( + Validator validator, + int committeeIndex, + int committeePosition, + int validatorIndex, + int committeeSize) { - @Override - public RestApiEndpoint getHandler() { - return new GetNewBlindedBlock(validatorDataProvider, spec, schemaDefinitionCache); + public Signer signer() { + return validator.getSigner(); } - @Override - public boolean isBlindedBlocks() { - return true; + public BLSPublicKey publicKey() { + return validator.getPublicKey(); } } diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/attestations/ValidatorWithCommitteePositionAndIndex.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/attestations/ValidatorWithCommitteePositionAndIndex.java deleted file mode 100644 index c3455996963..00000000000 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/attestations/ValidatorWithCommitteePositionAndIndex.java +++ /dev/null @@ -1,69 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.validator.client.duties.attestations; - -import tech.pegasys.teku.bls.BLSPublicKey; -import tech.pegasys.teku.spec.signatures.Signer; -import tech.pegasys.teku.validator.client.Validator; - -class ValidatorWithCommitteePositionAndIndex { - - private final Validator validator; - private final int committeePosition; - private final int validatorIndex; - private final int committeeSize; - - ValidatorWithCommitteePositionAndIndex( - final Validator validator, - final int committeePosition, - final int validatorIndex, - final int committeeSize) { - this.validator = validator; - this.committeePosition = committeePosition; - this.validatorIndex = validatorIndex; - this.committeeSize = committeeSize; - } - - public Signer getSigner() { - return validator.getSigner(); - } - - public int getCommitteePosition() { - return committeePosition; - } - - public int getValidatorIndex() { - return validatorIndex; - } - - public int getCommitteeSize() { - return committeeSize; - } - - public BLSPublicKey getPublicKey() { - return validator.getPublicKey(); - } - - @Override - public String toString() { - return "ValidatorWithCommitteePositionAndIndex{" - + "validator=" - + validator - + ", committeePosition=" - + committeePosition - + ", validatorIndex=" - + validatorIndex - + '}'; - } -} diff --git a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v2/debug/GetChainHeadsResponseV2.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/synccommittee/ChainHeadTooOldException.java similarity index 61% rename from data/serializer/src/main/java/tech/pegasys/teku/api/response/v2/debug/GetChainHeadsResponseV2.java rename to validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/synccommittee/ChainHeadTooOldException.java index 83557d0ca64..c10990bf957 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/api/response/v2/debug/GetChainHeadsResponseV2.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/synccommittee/ChainHeadTooOldException.java @@ -11,17 +11,13 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.api.response.v2.debug; +package tech.pegasys.teku.validator.client.duties.synccommittee; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import java.util.List; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; -public class GetChainHeadsResponseV2 { - public final List data; +public class ChainHeadTooOldException extends RuntimeException { - @JsonCreator - public GetChainHeadsResponseV2(@JsonProperty("data") final List data) { - this.data = data; + public ChainHeadTooOldException(final UInt64 headSlot, final UInt64 slot) { + super("Chain head too old. Head slot: " + headSlot + ", requested slot: " + slot); } } diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/synccommittee/ChainHeadTracker.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/synccommittee/ChainHeadTracker.java index 8a623f4a963..93f80da3d02 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/synccommittee/ChainHeadTracker.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/synccommittee/ChainHeadTracker.java @@ -24,6 +24,7 @@ import tech.pegasys.teku.validator.api.ValidatorTimingChannel; public class ChainHeadTracker implements ValidatorTimingChannel { + public static final int HEAD_TOO_OLD_THRESHOLD = 32; private UInt64 headBlockSlot = UInt64.ZERO; private Optional headBlockRoot = Optional.empty(); @@ -33,6 +34,10 @@ public synchronized Optional getCurrentChainHead(final UInt64 atSlot) { // We've moved on and no longer have a reference to what the head block was at that slot throw new ChainHeadBeyondSlotException(atSlot); } + if (headBlockRoot.isPresent() + && atSlot.minusMinZero(headBlockSlot).isGreaterThan(HEAD_TOO_OLD_THRESHOLD)) { + throw new ChainHeadTooOldException(headBlockSlot, atSlot); + } return headBlockRoot; } diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/synccommittee/ObolDvtSyncAggregatorSelectionProofProvider.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/synccommittee/ObolDvtSyncAggregatorSelectionProofProvider.java index 9fc10df7859..edc377eb0b4 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/synccommittee/ObolDvtSyncAggregatorSelectionProofProvider.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/synccommittee/ObolDvtSyncAggregatorSelectionProofProvider.java @@ -35,7 +35,8 @@ public class ObolDvtSyncAggregatorSelectionProofProvider private final ValidatorApiChannel validatorApiChannel; - public ObolDvtSyncAggregatorSelectionProofProvider(ValidatorApiChannel validatorApiChannel) { + public ObolDvtSyncAggregatorSelectionProofProvider( + final ValidatorApiChannel validatorApiChannel) { this.validatorApiChannel = validatorApiChannel; } diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/synccommittee/SyncAggregatorSelectionProofProvider.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/synccommittee/SyncAggregatorSelectionProofProvider.java index e131a122ffb..896d0702add 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/synccommittee/SyncAggregatorSelectionProofProvider.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/synccommittee/SyncAggregatorSelectionProofProvider.java @@ -73,7 +73,7 @@ protected SafeFuture createAndSignSelectionData( } public Optional> getSelectionProofFuture( - int validatorIndex, int subcommitteeIndex) { + final int validatorIndex, final int subcommitteeIndex) { return Optional.ofNullable( selectionProofFutures.get(Pair.of(validatorIndex, subcommitteeIndex))); } diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/synccommittee/SyncCommitteeScheduledDuties.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/synccommittee/SyncCommitteeScheduledDuties.java index ca816afb4d0..44769f3d2ca 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/synccommittee/SyncCommitteeScheduledDuties.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/duties/synccommittee/SyncCommitteeScheduledDuties.java @@ -27,11 +27,11 @@ import org.apache.logging.log4j.Logger; import org.apache.tuweni.bytes.Bytes32; import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.logging.ValidatorLogger; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.validator.api.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.validator.api.ValidatorApiChannel; import tech.pegasys.teku.validator.client.ForkProvider; import tech.pegasys.teku.validator.client.Validator; @@ -88,8 +88,8 @@ public SafeFuture performProductionDuty(final UInt64 slot) { } try { lastSignatureBlockRoot = chainHeadTracker.getCurrentChainHead(slot); - } catch (ChainHeadBeyondSlotException ex) { - return chainHeadBeyondSlotFailure(ex); + } catch (final ChainHeadBeyondSlotException | ChainHeadTooOldException ex) { + return chainHeadSlotCheckFailure(ex); } lastSignatureSlot = Optional.of(slot); return lastSignatureBlockRoot @@ -97,7 +97,7 @@ public SafeFuture performProductionDuty(final UInt64 slot) { .orElse(SafeFuture.completedFuture(DutyResult.NODE_SYNCING)); } - private SafeFuture chainHeadBeyondSlotFailure(final ChainHeadBeyondSlotException ex) { + private SafeFuture chainHeadSlotCheckFailure(final RuntimeException ex) { return SafeFuture.completedFuture(DutyResult.forError(getAllValidatorKeys(), ex)); } diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/AbstractValidatorSource.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/AbstractValidatorSource.java index fb1b65930fd..728d06ec49d 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/AbstractValidatorSource.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/AbstractValidatorSource.java @@ -25,7 +25,8 @@ abstract class AbstractValidatorSource implements ValidatorSource { protected final boolean readOnly; protected final Optional maybeDataDirLayout; - protected AbstractValidatorSource(boolean readOnly, Optional maybeDataDirLayout) { + protected AbstractValidatorSource( + final boolean readOnly, final Optional maybeDataDirLayout) { this.readOnly = readOnly; this.maybeDataDirLayout = maybeDataDirLayout; } diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/ExternalValidatorSource.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/ExternalValidatorSource.java index 81fc3974a56..baaae766f59 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/ExternalValidatorSource.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/ExternalValidatorSource.java @@ -140,7 +140,7 @@ private List getValidatorFiles() { return files == null ? List.of() : Arrays.asList(files); } - private ValidatorProvider getValidatorProvider(File file) { + private ValidatorProvider getValidatorProvider(final File file) { try { String content = Files.readString(file.toPath()); ExternalValidator externalValidator = parse(content, ValidatorTypes.EXTERNAL_VALIDATOR_STORE); @@ -177,7 +177,7 @@ public DeleteKeyResult deleteValidator(final BLSPublicKey publicKey) { return delete(publicKey); } - private DeleteKeyResult delete(BLSPublicKey publicKey) { + private DeleteKeyResult delete(final BLSPublicKey publicKey) { final DataDirLayout dataDirLayout = maybeDataDirLayout.orElseThrow(); final String fileName = publicKey.toBytesCompressed().toUnprefixedHexString(); final Path path = diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/KeystoreLocker.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/KeystoreLocker.java index 1f60e008348..9109b6dd3d9 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/KeystoreLocker.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/KeystoreLocker.java @@ -37,7 +37,7 @@ public class KeystoreLocker { private static final Logger LOG = LogManager.getLogger(); private final byte[] processPID = getProcessPID(); - public void lockKeystore(Path keystoreFile) { + public void lockKeystore(final Path keystoreFile) { Path lockfilePath = Path.of(keystoreFile.toString() + ".lock"); try { if (lockfilePath.toFile().exists()) { diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/LocalValidatorSource.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/LocalValidatorSource.java index 181f9ec9b94..9ec6a25583f 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/LocalValidatorSource.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/LocalValidatorSource.java @@ -136,7 +136,8 @@ public AddValidatorResult addValidator( } @Override - public AddValidatorResult addValidator(BLSPublicKey publicKey, Optional signerUrl) { + public AddValidatorResult addValidator( + final BLSPublicKey publicKey, final Optional signerUrl) { throw new UnsupportedOperationException(); } diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/MockStartValidatorSource.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/MockStartValidatorSource.java index 294aa7d1eab..80f1eac7811 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/MockStartValidatorSource.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/MockStartValidatorSource.java @@ -50,7 +50,7 @@ public class MockStartValidatorSource implements ValidatorSource { private final ThrottlingTaskQueueWithPriority externalSignerTaskQueue; private final MetricsSystem metricsSystem; - private MockStartValidatorSource(Builder builder) { + private MockStartValidatorSource(final Builder builder) { this.spec = builder.spec; this.interopConfig = builder.interopConfig; this.asyncRunner = builder.asyncRunner; @@ -108,7 +108,8 @@ public AddValidatorResult addValidator( } @Override - public AddValidatorResult addValidator(BLSPublicKey publicKey, Optional signerUrl) { + public AddValidatorResult addValidator( + final BLSPublicKey publicKey, final Optional signerUrl) { throw new UnsupportedOperationException(); } @@ -145,35 +146,36 @@ public static class Builder { private ThrottlingTaskQueueWithPriority externalSignerTaskQueue; private MetricsSystem metricsSystem; - public Builder(Spec spec, InteropConfig interopConfig, AsyncRunner asyncRunner) { + public Builder( + final Spec spec, final InteropConfig interopConfig, final AsyncRunner asyncRunner) { this.spec = spec; this.interopConfig = interopConfig; this.asyncRunner = asyncRunner; } - public Builder useExternalSigner(boolean useExternalSigner) { + public Builder useExternalSigner(final boolean useExternalSigner) { this.useExternalSigner = useExternalSigner; return this; } - public Builder config(ValidatorConfig config) { + public Builder config(final ValidatorConfig config) { this.config = config; return this; } public Builder externalSignerHttpClientFactory( - Supplier externalSignerHttpClientFactory) { + final Supplier externalSignerHttpClientFactory) { this.externalSignerHttpClientFactory = externalSignerHttpClientFactory; return this; } public Builder externalSignerTaskQueue( - ThrottlingTaskQueueWithPriority externalSignerTaskQueue) { + final ThrottlingTaskQueueWithPriority externalSignerTaskQueue) { this.externalSignerTaskQueue = externalSignerTaskQueue; return this; } - public Builder metricsSystem(MetricsSystem metricsSystem) { + public Builder metricsSystem(final MetricsSystem metricsSystem) { this.metricsSystem = metricsSystem; return this; } diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/MultithreadedValidatorLoader.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/MultithreadedValidatorLoader.java index fbc7f7a3daa..ee8e29e2491 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/MultithreadedValidatorLoader.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/MultithreadedValidatorLoader.java @@ -18,14 +18,19 @@ import java.util.ArrayList; import java.util.List; import java.util.Map; +import java.util.Optional; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.atomic.AtomicInteger; +import java.util.function.Function; +import org.apache.tuweni.bytes.Bytes32; import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.service.serviceutils.layout.DataDirLayout; import tech.pegasys.teku.spec.signatures.DeletableSigner; import tech.pegasys.teku.validator.api.GraffitiProvider; +import tech.pegasys.teku.validator.api.UpdatableGraffitiProvider; import tech.pegasys.teku.validator.client.Validator; import tech.pegasys.teku.validator.client.loader.ValidatorSource.ValidatorProvider; @@ -43,7 +48,9 @@ public class MultithreadedValidatorLoader { public static void loadValidators( final OwnedValidators ownedValidators, final Map providers, - final GraffitiProvider graffitiProvider) { + final GraffitiProvider defaultGraffitiProvider, + final Function> updatableGraffitiProvider, + final Optional maybeDataDirLayout) { final int totalValidatorCount = providers.size(); STATUS_LOG.loadingValidators(totalValidatorCount); @@ -57,9 +64,18 @@ public static void loadValidators( provider -> executorService.submit( () -> { + final BLSPublicKey publicKey = provider.getPublicKey(); + final GraffitiProvider graffitiProvider = + maybeDataDirLayout + .map( + dataDirLayout -> + new UpdatableGraffitiProvider( + () -> updatableGraffitiProvider.apply(publicKey), + defaultGraffitiProvider)) + .orElse(defaultGraffitiProvider); final Validator validator = new Validator( - provider.getPublicKey(), + publicKey, new DeletableSigner(provider.createSigner()), graffitiProvider, provider.isReadOnly()); diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/SlashingProtectedValidatorSource.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/SlashingProtectedValidatorSource.java index dbea9d5bec0..08abd012b6e 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/SlashingProtectedValidatorSource.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/SlashingProtectedValidatorSource.java @@ -66,7 +66,8 @@ public AddValidatorResult addValidator( } @Override - public AddValidatorResult addValidator(BLSPublicKey publicKey, Optional signerUrl) { + public AddValidatorResult addValidator( + final BLSPublicKey publicKey, final Optional signerUrl) { return delegate.addValidator(publicKey, signerUrl); } diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/SlashingProtectionLogger.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/SlashingProtectionLogger.java index df0bb42cfa7..78583f08380 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/SlashingProtectionLogger.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/SlashingProtectionLogger.java @@ -100,7 +100,7 @@ private void logSlashingProtection(final List validators, final UInt6 } private void logLoadedProtectionValidators( - List> validatorRecords) { + final List> validatorRecords) { if (validatorRecords.isEmpty()) { return; } @@ -111,7 +111,7 @@ private void logLoadedProtectionValidators( } private void logOutdatedProtectedValidators( - List> validatorRecords) { + final List> validatorRecords) { if (validatorRecords.isEmpty()) { return; } @@ -123,7 +123,7 @@ private void logOutdatedProtectedValidators( } private void filterAndLogNotLoadedProtectionValidators( - List>> validatorRecords) { + final List>> validatorRecords) { Set unprotectedValidatorSet = validatorRecords.stream() .filter(pair -> pair.getRight().isEmpty()) @@ -153,7 +153,7 @@ private List>> getValidatorSign private Function createOutdatedSigningRecordClassifier( final UInt64 currentSlot) { return signingRecord -> { - final UInt64 attestationTargetEpoch = signingRecord.getAttestationTargetEpoch(); + final UInt64 attestationTargetEpoch = signingRecord.attestationTargetEpoch(); return spec.computeEpochAtSlot(currentSlot) .minusMinZero( Objects.equals(attestationTargetEpoch, NEVER_SIGNED) @@ -164,29 +164,29 @@ private Function createOutdatedSigningRecordCla } @Override - public synchronized void onSlot(UInt64 slot) { + public synchronized void onSlot(final UInt64 slot) { this.currentSlot = Optional.of(slot); tryToLog(); } @Override public void onHeadUpdate( - UInt64 slot, - Bytes32 previousDutyDependentRoot, - Bytes32 currentDutyDependentRoot, - Bytes32 headBlockRoot) {} + final UInt64 slot, + final Bytes32 previousDutyDependentRoot, + final Bytes32 currentDutyDependentRoot, + final Bytes32 headBlockRoot) {} @Override public void onPossibleMissedEvents() {} @Override - public void onBlockProductionDue(UInt64 slot) {} + public void onBlockProductionDue(final UInt64 slot) {} @Override - public void onAttestationCreationDue(UInt64 slot) {} + public void onAttestationCreationDue(final UInt64 slot) {} @Override - public void onAttestationAggregationDue(UInt64 slot) {} + public void onAttestationAggregationDue(final UInt64 slot) {} @Override public void onValidatorsAdded() {} diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/ValidatorLoader.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/ValidatorLoader.java index 5ab4a6c38dc..90b6f95816d 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/ValidatorLoader.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/ValidatorLoader.java @@ -20,9 +20,11 @@ import java.util.List; import java.util.Map; import java.util.Optional; +import java.util.function.Function; import java.util.function.Supplier; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; +import org.apache.tuweni.bytes.Bytes32; import org.apache.tuweni.bytes.Bytes48; import org.hyperledger.besu.plugin.services.MetricsSystem; import tech.pegasys.teku.bls.BLSPublicKey; @@ -36,6 +38,7 @@ import tech.pegasys.teku.spec.signatures.SlashingProtector; import tech.pegasys.teku.validator.api.GraffitiProvider; import tech.pegasys.teku.validator.api.InteropConfig; +import tech.pegasys.teku.validator.api.UpdatableGraffitiProvider; import tech.pegasys.teku.validator.api.ValidatorConfig; import tech.pegasys.teku.validator.client.ExternalValidatorImportResult; import tech.pegasys.teku.validator.client.LocalValidatorImportResult; @@ -51,7 +54,8 @@ public class ValidatorLoader { private final Optional mutableLocalValidatorSource; private final Optional mutableExternalValidatorSource; private final OwnedValidators ownedValidators = new OwnedValidators(); - private final GraffitiProvider graffitiProvider; + private final GraffitiProvider defaultGraffitiProvider; + private final Function> updatableGraffitiProvider; private final Optional maybeDataDirLayout; private final SlashingProtectionLogger slashingProtectionLogger; @@ -59,13 +63,15 @@ private ValidatorLoader( final List validatorSources, final Optional mutableLocalValidatorSource, final Optional mutableExternalValidatorSource, - final GraffitiProvider graffitiProvider, + final GraffitiProvider defaultGraffitiProvider, + final Function> updatableGraffitiProvider, final Optional maybeDataDirLayout, final SlashingProtectionLogger slashingProtectionLogger) { this.validatorSources = validatorSources; this.mutableLocalValidatorSource = mutableLocalValidatorSource; this.mutableExternalValidatorSource = mutableExternalValidatorSource; - this.graffitiProvider = graffitiProvider; + this.defaultGraffitiProvider = defaultGraffitiProvider; + this.updatableGraffitiProvider = updatableGraffitiProvider; this.maybeDataDirLayout = maybeDataDirLayout; this.slashingProtectionLogger = slashingProtectionLogger; } @@ -75,7 +81,11 @@ public synchronized void loadValidators() { final Map validatorProviders = new HashMap<>(); validatorSources.forEach(source -> addValidatorsFromSource(validatorProviders, source)); MultithreadedValidatorLoader.loadValidators( - ownedValidators, validatorProviders, graffitiProvider); + ownedValidators, + validatorProviders, + defaultGraffitiProvider, + updatableGraffitiProvider, + maybeDataDirLayout); slashingProtectionLogger.protectionSummary(ownedValidators.getValidators()); } @@ -198,6 +208,13 @@ public ExternalValidatorImportResult addExternalValidator( } private void addToOwnedValidators(final Signer signer, final BLSPublicKey publicKey) { + final GraffitiProvider graffitiProvider = + maybeDataDirLayout + .map( + dataDirLayout -> + new UpdatableGraffitiProvider( + () -> updatableGraffitiProvider.apply(publicKey), defaultGraffitiProvider)) + .orElse(defaultGraffitiProvider); ownedValidators.addValidator( new Validator(publicKey, new DeletableSigner(signer), graffitiProvider, false)); LOG.info("Added validator: {}", publicKey.toString()); @@ -223,7 +240,8 @@ public static ValidatorLoader create( final PublicKeyLoader publicKeyLoader, final AsyncRunner asyncRunner, final MetricsSystem metricsSystem, - final Optional maybeMutableDir) { + final Optional maybeMutableDir, + final Function> updatableGraffitiProvider) { final ValidatorSourceFactory validatorSources = new ValidatorSourceFactory( spec, @@ -242,6 +260,7 @@ public static ValidatorLoader create( validatorSources.getMutableLocalValidatorSource(), validatorSources.getMutableExternalValidatorSource(), config.getGraffitiProvider(), + updatableGraffitiProvider, maybeMutableDir, slashingProtectionLogger); } @@ -259,6 +278,7 @@ static ValidatorLoader create( mutableLocalValidatorSource, mutableExternalValidatorSource, graffitiProvider, + (publicKey) -> Optional.empty(), maybeDataDirLayout, slashingProtectionLogger); } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/provider/BLSPublicKeyDeserializer.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/proposerconfig/loader/BLSPublicKeyDeserializer.java similarity index 78% rename from data/serializer/src/main/java/tech/pegasys/teku/provider/BLSPublicKeyDeserializer.java rename to validator/client/src/main/java/tech/pegasys/teku/validator/client/proposerconfig/loader/BLSPublicKeyDeserializer.java index d660e907127..d859f3ef5a3 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/provider/BLSPublicKeyDeserializer.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/proposerconfig/loader/BLSPublicKeyDeserializer.java @@ -11,7 +11,7 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.provider; +package tech.pegasys.teku.validator.client.proposerconfig.loader; import com.fasterxml.jackson.core.JsonParser; import com.fasterxml.jackson.databind.DeserializationContext; @@ -19,9 +19,10 @@ import java.io.IOException; import tech.pegasys.teku.bls.BLSPublicKey; -public class BLSPublicKeyDeserializer extends JsonDeserializer { +class BLSPublicKeyDeserializer extends JsonDeserializer { @Override - public BLSPublicKey deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { + public BLSPublicKey deserialize(final JsonParser p, final DeserializationContext ctxt) + throws IOException { return BLSPublicKey.fromHexString(p.getValueAsString()); } } diff --git a/data/serializer/src/main/java/tech/pegasys/teku/provider/BLSPublicKeySerializer.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/proposerconfig/loader/BLSPublicKeySerializer.java similarity index 81% rename from data/serializer/src/main/java/tech/pegasys/teku/provider/BLSPublicKeySerializer.java rename to validator/client/src/main/java/tech/pegasys/teku/validator/client/proposerconfig/loader/BLSPublicKeySerializer.java index 8e4e9059fb4..d7d48bea2dd 100644 --- a/data/serializer/src/main/java/tech/pegasys/teku/provider/BLSPublicKeySerializer.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/proposerconfig/loader/BLSPublicKeySerializer.java @@ -11,7 +11,7 @@ * specific language governing permissions and limitations under the License. */ -package tech.pegasys.teku.provider; +package tech.pegasys.teku.validator.client.proposerconfig.loader; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.JsonSerializer; @@ -20,9 +20,10 @@ import java.util.Locale; import tech.pegasys.teku.bls.BLSPublicKey; -public class BLSPublicKeySerializer extends JsonSerializer { +class BLSPublicKeySerializer extends JsonSerializer { @Override - public void serialize(BLSPublicKey value, JsonGenerator gen, SerializerProvider serializers) + public void serialize( + final BLSPublicKey value, final JsonGenerator gen, final SerializerProvider serializers) throws IOException { gen.writeString(value.toHexString().toLowerCase(Locale.ROOT)); } diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/proposerconfig/loader/ProposerConfigLoader.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/proposerconfig/loader/ProposerConfigLoader.java index 42af7e784a0..543025c9317 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/proposerconfig/loader/ProposerConfigLoader.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/proposerconfig/loader/ProposerConfigLoader.java @@ -14,27 +14,42 @@ package tech.pegasys.teku.validator.client.proposerconfig.loader; import com.fasterxml.jackson.core.JsonLocation; +import com.fasterxml.jackson.core.Version; import com.fasterxml.jackson.databind.JsonMappingException; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.exc.ValueInstantiationException; +import com.fasterxml.jackson.databind.module.SimpleModule; import java.io.IOException; import java.net.URL; import java.util.Optional; +import org.apache.tuweni.bytes.Bytes48; +import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.infrastructure.exceptions.ExceptionUtil; import tech.pegasys.teku.infrastructure.exceptions.InvalidConfigurationException; import tech.pegasys.teku.infrastructure.http.UrlSanitizer; -import tech.pegasys.teku.provider.JsonProvider; +import tech.pegasys.teku.infrastructure.jackson.deserializers.bytes.Bytes48KeyDeserializer; import tech.pegasys.teku.validator.client.ProposerConfig; public class ProposerConfigLoader { - final ObjectMapper objectMapper; + private final ObjectMapper objectMapper; public ProposerConfigLoader() { - this(new JsonProvider().getObjectMapper()); + this.objectMapper = new ObjectMapper(); + addTekuMappers(); } - public ProposerConfigLoader(final ObjectMapper objectMapper) { - this.objectMapper = objectMapper; + private void addTekuMappers() { + SimpleModule module = + new SimpleModule("ProposerConfigLoader", new Version(1, 0, 0, null, null, null)); + module.addDeserializer(BLSPublicKey.class, new BLSPublicKeyDeserializer()); + module.addSerializer(BLSPublicKey.class, new BLSPublicKeySerializer()); + module.addKeyDeserializer(Bytes48.class, new Bytes48KeyDeserializer()); + + objectMapper.registerModule(module); + } + + public ObjectMapper getObjectMapper() { + return this.objectMapper; } public ProposerConfig getProposerConfig(final URL source) { @@ -58,7 +73,7 @@ public ProposerConfig getProposerConfig(final URL source) { } private static String getErrorMessage( - final URL source, final String exceptionMessage, Optional maybeLocation) { + final URL source, final String exceptionMessage, final Optional maybeLocation) { return String.format( "Failed to load proposer config from '%s' - %s%s", UrlSanitizer.sanitizePotentialUrl(source.toString()), diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/ValidatorRestApi.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/ValidatorRestApi.java index a910a23906c..7f4f4219dab 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/ValidatorRestApi.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/ValidatorRestApi.java @@ -29,6 +29,7 @@ import tech.pegasys.teku.infrastructure.version.VersionProvider; import tech.pegasys.teku.service.serviceutils.layout.DataDirLayout; import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.validator.api.GraffitiManager; import tech.pegasys.teku.validator.api.ValidatorApiChannel; import tech.pegasys.teku.validator.beaconnode.GenesisDataProvider; import tech.pegasys.teku.validator.client.KeyManager; @@ -38,10 +39,12 @@ import tech.pegasys.teku.validator.client.doppelganger.DoppelgangerDetector; import tech.pegasys.teku.validator.client.restapi.apis.DeleteFeeRecipient; import tech.pegasys.teku.validator.client.restapi.apis.DeleteGasLimit; +import tech.pegasys.teku.validator.client.restapi.apis.DeleteGraffiti; import tech.pegasys.teku.validator.client.restapi.apis.DeleteKeys; import tech.pegasys.teku.validator.client.restapi.apis.DeleteRemoteKeys; import tech.pegasys.teku.validator.client.restapi.apis.GetFeeRecipient; import tech.pegasys.teku.validator.client.restapi.apis.GetGasLimit; +import tech.pegasys.teku.validator.client.restapi.apis.GetGraffiti; import tech.pegasys.teku.validator.client.restapi.apis.GetKeys; import tech.pegasys.teku.validator.client.restapi.apis.GetRemoteKeys; import tech.pegasys.teku.validator.client.restapi.apis.PostKeys; @@ -49,6 +52,7 @@ import tech.pegasys.teku.validator.client.restapi.apis.PostVoluntaryExit; import tech.pegasys.teku.validator.client.restapi.apis.SetFeeRecipient; import tech.pegasys.teku.validator.client.restapi.apis.SetGasLimit; +import tech.pegasys.teku.validator.client.restapi.apis.SetGraffiti; import tech.pegasys.teku.validator.client.slashingriskactions.SlashingRiskAction; public class ValidatorRestApi { @@ -57,6 +61,7 @@ public class ValidatorRestApi { public static final String TAG_KEY_MANAGEMENT = "Key Management"; public static final String TAG_FEE_RECIPIENT = "Fee Recipient"; public static final String TAG_GAS_LIMIT = "Gas Limit"; + public static final String TAG_GRAFFITI = "Graffiti"; public static RestApi create( final Spec spec, @@ -68,7 +73,8 @@ public static RestApi create( final DataDirLayout dataDirLayout, final TimeProvider timeProvider, final Optional maybeDoppelgangerDetector, - final SlashingRiskAction doppelgangerDetectionAction) { + final SlashingRiskAction doppelgangerDetectionAction, + final GraffitiManager graffitiManager) { final VoluntaryExitDataProvider voluntaryExitDataProvider = new VoluntaryExitDataProvider( spec, keyManager, validatorApiChannel, genesisDataProvider, timeProvider); @@ -128,6 +134,9 @@ public static RestApi create( .endpoint(new DeleteFeeRecipient(proposerConfigManager)) .endpoint(new DeleteGasLimit(proposerConfigManager)) .endpoint(new PostVoluntaryExit(voluntaryExitDataProvider)) + .endpoint(new GetGraffiti(keyManager)) + .endpoint(new SetGraffiti(keyManager, graffitiManager)) + .endpoint(new DeleteGraffiti(keyManager, graffitiManager)) .sslCertificate(config.getRestApiKeystoreFile(), config.getRestApiKeystorePasswordFile()) .passwordFilePath(validatorApiBearerFile) .build(); diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/DeleteGasLimit.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/DeleteGasLimit.java index 1b1295e1794..00a97f32e33 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/DeleteGasLimit.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/DeleteGasLimit.java @@ -53,7 +53,7 @@ public DeleteGasLimit(final Optional proposerConfigManage } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final BLSPublicKey publicKey = request.getPathParameter(PARAM_PUBKEY_TYPE); final ProposerConfigManager manager = proposerConfigManager.orElseThrow( diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/DeleteGraffiti.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/DeleteGraffiti.java new file mode 100644 index 00000000000..7cc00c6d580 --- /dev/null +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/DeleteGraffiti.java @@ -0,0 +1,73 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.client.restapi.apis; + +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; +import static tech.pegasys.teku.validator.client.restapi.ValidatorRestApi.TAG_GRAFFITI; +import static tech.pegasys.teku.validator.client.restapi.ValidatorTypes.PARAM_PUBKEY_TYPE; + +import com.fasterxml.jackson.core.JsonProcessingException; +import java.util.Optional; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.infrastructure.restapi.endpoints.EndpointMetadata; +import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; +import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiRequest; +import tech.pegasys.teku.validator.api.GraffitiManagementException; +import tech.pegasys.teku.validator.api.GraffitiManager; +import tech.pegasys.teku.validator.client.KeyManager; +import tech.pegasys.teku.validator.client.Validator; + +public class DeleteGraffiti extends RestApiEndpoint { + private final KeyManager keyManager; + private final GraffitiManager graffitiManager; + + public DeleteGraffiti(final KeyManager keyManager, final GraffitiManager graffitiManager) { + super( + EndpointMetadata.delete(GetGraffiti.ROUTE) + .operationId("deleteGraffiti") + .summary("Delete Configured Graffiti") + .description("Delete the configured graffiti for the specified public key.") + .tags(TAG_GRAFFITI) + .withBearerAuthSecurity() + .pathParam(PARAM_PUBKEY_TYPE) + .response( + SC_NO_CONTENT, + "Successfully removed the graffiti, or there was no graffiti set for the requested public key.") + .withAuthenticationResponses() + .withNotFoundResponse() + .build()); + this.keyManager = keyManager; + this.graffitiManager = graffitiManager; + } + + @Override + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { + final BLSPublicKey publicKey = request.getPathParameter(PARAM_PUBKEY_TYPE); + + final Optional maybeValidator = keyManager.getValidatorByPublicKey(publicKey); + if (maybeValidator.isEmpty()) { + request.respondError(SC_NOT_FOUND, "Validator not found"); + return; + } + + try { + graffitiManager.deleteGraffiti(publicKey); + request.respondWithCode(SC_NO_CONTENT); + } catch (GraffitiManagementException e) { + request.respondError(SC_INTERNAL_SERVER_ERROR, e.getMessage()); + } + } +} diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/GetFeeRecipient.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/GetFeeRecipient.java index 417c72ef41b..a8214f3b816 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/GetFeeRecipient.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/GetFeeRecipient.java @@ -13,7 +13,7 @@ package tech.pegasys.teku.validator.client.restapi.apis; -import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.ETH1ADDRESS_TYPE; +import static tech.pegasys.teku.ethereum.execution.types.Eth1Address.ETH1ADDRESS_TYPE; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.PUBKEY; diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/GetGasLimit.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/GetGasLimit.java index 0f718a9a0df..66e30d112a3 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/GetGasLimit.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/GetGasLimit.java @@ -72,7 +72,7 @@ public GetGasLimit(final Optional proposerConfigManager) } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final BLSPublicKey publicKey = request.getPathParameter(PARAM_PUBKEY_TYPE); final ProposerConfigManager manager = proposerConfigManager.orElseThrow( diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/GetGraffiti.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/GetGraffiti.java new file mode 100644 index 00000000000..cc306c0b66b --- /dev/null +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/GetGraffiti.java @@ -0,0 +1,108 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.client.restapi.apis; + +import static tech.pegasys.teku.ethereum.json.types.SharedApiTypes.PUBKEY_API_TYPE; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.validator.client.restapi.ValidatorRestApi.TAG_GRAFFITI; +import static tech.pegasys.teku.validator.client.restapi.ValidatorTypes.PARAM_PUBKEY_TYPE; + +import com.fasterxml.jackson.core.JsonProcessingException; +import java.nio.charset.StandardCharsets; +import java.util.Optional; +import java.util.function.Function; +import org.apache.tuweni.bytes.Bytes; +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition; +import tech.pegasys.teku.infrastructure.restapi.endpoints.EndpointMetadata; +import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; +import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiRequest; +import tech.pegasys.teku.validator.api.Bytes32Parser; +import tech.pegasys.teku.validator.api.GraffitiManagementException; +import tech.pegasys.teku.validator.api.UpdatableGraffitiProvider; +import tech.pegasys.teku.validator.client.KeyManager; +import tech.pegasys.teku.validator.client.Validator; + +public class GetGraffiti extends RestApiEndpoint { + static final String ROUTE = "/eth/v1/validator/{pubkey}/graffiti"; + private final KeyManager keyManager; + + public static final DeserializableTypeDefinition GRAFFITI_TYPE = + DeserializableTypeDefinition.string(Bytes32.class) + .formatter(GetGraffiti::processGraffitiString) + .parser(Bytes32Parser::toBytes32) + .example("Example graffiti") + .description("Bytes32 string") + .format("byte") + .build(); + + private static final SerializableTypeDefinition> GRAFFITI_RESPONSE_TYPE = + SerializableTypeDefinition.>object() + .withOptionalField("pubkey", PUBKEY_API_TYPE, value -> Optional.empty()) + .withField( + "graffiti", + GRAFFITI_TYPE, + graffiti -> graffiti.orElse(Bytes32Parser.toBytes32(Bytes.EMPTY.toArray()))) + .build(); + + private static final SerializableTypeDefinition> RESPONSE_TYPE = + SerializableTypeDefinition.>object() + .name("GraffitiResponse") + .withField("data", GRAFFITI_RESPONSE_TYPE, Function.identity()) + .build(); + + public GetGraffiti(final KeyManager keyManager) { + super( + EndpointMetadata.get(ROUTE) + .operationId("getGraffiti") + .summary("Get Graffiti") + .description( + "Get the graffiti for an individual validator. If no graffiti is set explicitly, returns the process-wide default.") + .tags(TAG_GRAFFITI) + .withBearerAuthSecurity() + .pathParam(PARAM_PUBKEY_TYPE) + .response(SC_OK, "Success response", RESPONSE_TYPE) + .withAuthenticationResponses() + .withNotFoundResponse() + .build()); + this.keyManager = keyManager; + } + + @Override + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { + final BLSPublicKey publicKey = request.getPathParameter(PARAM_PUBKEY_TYPE); + + final Optional maybeValidator = keyManager.getValidatorByPublicKey(publicKey); + if (maybeValidator.isEmpty()) { + request.respondError(SC_NOT_FOUND, "Validator not found"); + return; + } + + try { + final UpdatableGraffitiProvider provider = + (UpdatableGraffitiProvider) maybeValidator.get().getGraffitiProvider(); + request.respondOk(provider.getUnsafe()); + } catch (GraffitiManagementException e) { + request.respondError(SC_INTERNAL_SERVER_ERROR, e.getMessage()); + } + } + + private static String processGraffitiString(final Bytes32 graffiti) { + return new String(graffiti.toArrayUnsafe(), StandardCharsets.UTF_8).strip().replace("\0", ""); + } +} diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/PostVoluntaryExit.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/PostVoluntaryExit.java index f95c9d9c764..391f34846d8 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/PostVoluntaryExit.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/PostVoluntaryExit.java @@ -69,7 +69,7 @@ public PostVoluntaryExit(final VoluntaryExitDataProvider provider) { } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final BLSPublicKey publicKey = request.getPathParameter(PARAM_PUBKEY_TYPE); final Optional maybeEpoch = request.getOptionalQueryParameter(EPOCH_QUERY_TYPE); final SafeFuture future = diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/SetFeeRecipient.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/SetFeeRecipient.java index 86297106f2b..aa23449859e 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/SetFeeRecipient.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/SetFeeRecipient.java @@ -13,7 +13,7 @@ package tech.pegasys.teku.validator.client.restapi.apis; -import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.ETH1ADDRESS_TYPE; +import static tech.pegasys.teku.ethereum.execution.types.Eth1Address.ETH1ADDRESS_TYPE; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_ACCEPTED; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/SetGasLimit.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/SetGasLimit.java index 289633cacad..e31280b0ab3 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/SetGasLimit.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/SetGasLimit.java @@ -72,7 +72,7 @@ public SetGasLimit(final Optional proposerConfigManager) } @Override - public void handleRequest(RestApiRequest request) throws JsonProcessingException { + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { final BLSPublicKey publicKey = request.getPathParameter(PARAM_PUBKEY_TYPE); final SetGasLimit.SetGasLimitBody body = request.getRequestBody(); if (body.gasLimit.equals(UInt64.ZERO)) { diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/SetGraffiti.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/SetGraffiti.java new file mode 100644 index 00000000000..a3ef88f10a1 --- /dev/null +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/SetGraffiti.java @@ -0,0 +1,88 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.client.restapi.apis; + +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.STRING_TYPE; +import static tech.pegasys.teku.validator.client.restapi.ValidatorRestApi.TAG_GRAFFITI; +import static tech.pegasys.teku.validator.client.restapi.ValidatorTypes.PARAM_PUBKEY_TYPE; + +import com.fasterxml.jackson.core.JsonProcessingException; +import java.util.Optional; +import java.util.function.Function; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.restapi.endpoints.EndpointMetadata; +import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint; +import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiRequest; +import tech.pegasys.teku.validator.api.GraffitiManagementException; +import tech.pegasys.teku.validator.api.GraffitiManager; +import tech.pegasys.teku.validator.client.KeyManager; +import tech.pegasys.teku.validator.client.Validator; + +public class SetGraffiti extends RestApiEndpoint { + private final KeyManager keyManager; + private final GraffitiManager graffitiManager; + + public static final DeserializableTypeDefinition GRAFFITI_REQUEST_TYPE = + DeserializableTypeDefinition.object(String.class, StringBuilder.class) + .initializer(StringBuilder::new) + .finisher(StringBuilder::toString) + .withField( + "graffiti", + STRING_TYPE.withDescription( + "Arbitrary data to set in the graffiti field of BeaconBlockBody"), + Function.identity(), + StringBuilder::append) + .build(); + + public SetGraffiti(final KeyManager keyManager, final GraffitiManager graffitiManager) { + super( + EndpointMetadata.post(GetGraffiti.ROUTE) + .operationId("setGraffiti") + .summary("Set Graffiti") + .description("Set the graffiti for an individual validator.") + .tags(TAG_GRAFFITI) + .withBearerAuthSecurity() + .pathParam(PARAM_PUBKEY_TYPE) + .requestBodyType(GRAFFITI_REQUEST_TYPE) + .response(SC_NO_CONTENT, "Successfully updated graffiti.") + .withAuthenticationResponses() + .withNotFoundResponse() + .build()); + this.keyManager = keyManager; + this.graffitiManager = graffitiManager; + } + + @Override + public void handleRequest(final RestApiRequest request) throws JsonProcessingException { + final BLSPublicKey publicKey = request.getPathParameter(PARAM_PUBKEY_TYPE); + final String graffiti = request.getRequestBody(); + + final Optional maybeValidator = keyManager.getValidatorByPublicKey(publicKey); + if (maybeValidator.isEmpty()) { + request.respondError(SC_NOT_FOUND, "Validator not found"); + return; + } + + try { + graffitiManager.setGraffiti(publicKey, graffiti); + request.respondWithCode(SC_NO_CONTENT); + } catch (GraffitiManagementException e) { + request.respondError(SC_INTERNAL_SERVER_ERROR, e.getMessage()); + } + } +} diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/schema/ExternalValidator.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/schema/ExternalValidator.java index 1ec59daf82e..222558ce1f9 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/schema/ExternalValidator.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/schema/ExternalValidator.java @@ -26,18 +26,19 @@ public class ExternalValidator { public ExternalValidator() {} - public ExternalValidator(BLSPublicKey publicKey, Optional url) { + public ExternalValidator(final BLSPublicKey publicKey, final Optional url) { this.publicKey = publicKey; this.url = url; } - public ExternalValidator(BLSPublicKey publicKey, Optional url, boolean readOnly) { + public ExternalValidator( + final BLSPublicKey publicKey, final Optional url, final boolean readOnly) { this.publicKey = publicKey; this.url = url; this.readOnly = readOnly; } - public static ExternalValidator create(Validator validator) { + public static ExternalValidator create(final Validator validator) { return new ExternalValidator( validator.getPublicKey(), validator.getSigner().getSigningServiceUrl(), @@ -48,7 +49,7 @@ public BLSPublicKey getPublicKey() { return publicKey; } - public void setPublicKey(BLSPublicKey publicKey) { + public void setPublicKey(final BLSPublicKey publicKey) { this.publicKey = publicKey; } @@ -56,7 +57,7 @@ public Optional getUrl() { return url; } - public void setUrl(Optional url) { + public void setUrl(final Optional url) { this.url = url; } @@ -64,12 +65,12 @@ public boolean isReadOnly() { return readOnly; } - public void setReadOnly(boolean readOnly) { + public void setReadOnly(final boolean readOnly) { this.readOnly = readOnly; } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/schema/PostRemoteKeysRequest.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/schema/PostRemoteKeysRequest.java index 87e72f4efc5..d0cb2a33b13 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/schema/PostRemoteKeysRequest.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/schema/PostRemoteKeysRequest.java @@ -21,7 +21,7 @@ public class PostRemoteKeysRequest { public PostRemoteKeysRequest() {} - public PostRemoteKeysRequest(List externalValidators) { + public PostRemoteKeysRequest(final List externalValidators) { this.externalValidators = externalValidators; } @@ -29,7 +29,7 @@ public List getExternalValidators() { return externalValidators; } - public void setExternalValidators(List externalValidators) { + public void setExternalValidators(final List externalValidators) { this.externalValidators = externalValidators; } } diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/BlockRequestBody.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/BlockRequestBody.java deleted file mode 100644 index 8063791f587..00000000000 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/BlockRequestBody.java +++ /dev/null @@ -1,61 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.validator.client.signer; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonInclude; -import com.fasterxml.jackson.annotation.JsonProperty; -import tech.pegasys.teku.api.schema.BeaconBlock; -import tech.pegasys.teku.api.schema.BeaconBlockHeader; -import tech.pegasys.teku.spec.SpecMilestone; - -@JsonInclude(JsonInclude.Include.NON_NULL) -public class BlockRequestBody { - private final SpecMilestone version; - private final BeaconBlock beaconBlock; - private final BeaconBlockHeader beaconBlockHeader; - - @JsonCreator - public BlockRequestBody( - @JsonProperty("version") final SpecMilestone version, - @JsonProperty("block") final BeaconBlock beaconBlock, - @JsonProperty("block_header") final BeaconBlockHeader beaconBlockHeader) { - this.version = version; - this.beaconBlock = beaconBlock; - this.beaconBlockHeader = beaconBlockHeader; - } - - public BlockRequestBody(final SpecMilestone version, final BeaconBlock beaconBlock) { - this(version, beaconBlock, null); - } - - public BlockRequestBody(final SpecMilestone version, final BeaconBlockHeader beaconBlockHeader) { - this(version, null, beaconBlockHeader); - } - - @JsonProperty("version") - public SpecMilestone getVersion() { - return version; - } - - @JsonProperty("block") - public BeaconBlock getBeaconBlock() { - return beaconBlock; - } - - @JsonProperty("block_header") - public BeaconBlockHeader getBeaconBlockHeader() { - return beaconBlockHeader; - } -} diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/ExternalSigner.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/ExternalSigner.java index ad66438de1a..24ca83fb596 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/ExternalSigner.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/ExternalSigner.java @@ -37,14 +37,14 @@ import org.hyperledger.besu.plugin.services.MetricsSystem; import org.hyperledger.besu.plugin.services.metrics.Counter; import org.hyperledger.besu.plugin.services.metrics.LabelledMetric; -import tech.pegasys.teku.api.schema.Fork; import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.async.ThrottlingTaskQueueWithPriority; +import tech.pegasys.teku.infrastructure.bytes.Bytes4; +import tech.pegasys.teku.infrastructure.json.JsonUtil; import tech.pegasys.teku.infrastructure.metrics.TekuMetricCategory; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.provider.JsonProvider; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock; import tech.pegasys.teku.spec.datastructures.builder.ValidatorRegistration; @@ -55,13 +55,19 @@ import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncAggregatorSelectionData; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; import tech.pegasys.teku.spec.logic.common.util.SyncCommitteeUtil; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; +import tech.pegasys.teku.spec.schemas.SchemaDefinitions; import tech.pegasys.teku.spec.signatures.Signer; import tech.pegasys.teku.spec.signatures.SigningRootUtil; +import tech.pegasys.teku.validator.api.signer.AggregationSlotWrapper; +import tech.pegasys.teku.validator.api.signer.RandaoRevealWrapper; +import tech.pegasys.teku.validator.api.signer.SignType; +import tech.pegasys.teku.validator.api.signer.SyncAggregatorSelectionDataWrapper; +import tech.pegasys.teku.validator.api.signer.SyncCommitteeMessageWrapper; public class ExternalSigner implements Signer { public static final String EXTERNAL_SIGNER_ENDPOINT = "/api/v1/eth2/sign"; - private static final String FORK_INFO = "fork_info"; - private final JsonProvider jsonProvider = new JsonProvider(); + public static final String FORK_INFO = "fork_info"; private final URL signingServiceUrl; private final BLSPublicKey blsPublicKey; private final Duration timeout; @@ -69,6 +75,7 @@ public class ExternalSigner implements Signer { private final HttpClient httpClient; private final ThrottlingTaskQueueWithPriority taskQueue; private final SigningRootUtil signingRootUtil; + private final SchemaDefinitionCache schemaDefinitionCache; private final Counter successCounter; private final Counter failedCounter; @@ -93,12 +100,13 @@ public ExternalSigner( final LabelledMetric labelledCounter = metricsSystem.createLabelledCounter( TekuMetricCategory.VALIDATOR, - "external_signer_requests", + "external_signer_requests_total", "Completed external signer counts", "result"); successCounter = labelledCounter.labels("success"); failedCounter = labelledCounter.labels("failed"); timeoutCounter = labelledCounter.labels("timeout"); + this.schemaDefinitionCache = new SchemaDefinitionCache(spec); } @Override @@ -109,7 +117,8 @@ public SafeFuture createRandaoReveal(final UInt64 epoch, final For return sign( signingRootUtil.signingRootForRandaoReveal(epoch, forkInfo), SignType.RANDAO_REVEAL, - Map.of("randao_reveal", Map.of("epoch", epoch), FORK_INFO, forkInfo(forkInfo)), + Map.of( + SignType.RANDAO_REVEAL.getName(), new RandaoRevealWrapper(epoch), FORK_INFO, forkInfo), slashableGenericMessage("randao reveal")); } @@ -121,7 +130,7 @@ public SafeFuture signBlock(final BeaconBlock block, final ForkInf return sign( signingRootUtil.signingRootForSignBlock(block, forkInfo), blockRequestProvider.getSignType(), - blockRequestProvider.getBlockMetadata(Map.of(FORK_INFO, forkInfo(forkInfo))), + blockRequestProvider.getBlockMetadata(Map.of(FORK_INFO, forkInfo)), slashableBlockMessage(block.getSlot())); } @@ -131,11 +140,7 @@ public SafeFuture signAttestationData( return sign( signingRootUtil.signingRootForSignAttestationData(attestationData, forkInfo), SignType.ATTESTATION, - Map.of( - "attestation", - new tech.pegasys.teku.api.schema.AttestationData(attestationData), - FORK_INFO, - forkInfo(forkInfo)), + Map.of(SignType.ATTESTATION.getName(), attestationData, FORK_INFO, forkInfo), slashableAttestationMessage(attestationData)); } @@ -158,7 +163,11 @@ public SafeFuture signAggregationSlot(final UInt64 slot, final For sign( signingRootUtil.signingRootForSignAggregationSlot(slot, forkInfo), SignType.AGGREGATION_SLOT, - Map.of("aggregation_slot", Map.of("slot", slot), FORK_INFO, forkInfo(forkInfo)), + Map.of( + SignType.AGGREGATION_SLOT.getName(), + new AggregationSlotWrapper(slot), + FORK_INFO, + forkInfo), slashableGenericMessage("aggregation slot")), true); } @@ -169,11 +178,7 @@ public SafeFuture signAggregateAndProof( return sign( signingRootUtil.signingRootForSignAggregateAndProof(aggregateAndProof, forkInfo), SignType.AGGREGATE_AND_PROOF, - Map.of( - "aggregate_and_proof", - new tech.pegasys.teku.api.schema.AggregateAndProof(aggregateAndProof), - FORK_INFO, - forkInfo(forkInfo)), + Map.of(SignType.AGGREGATE_AND_PROOF.getName(), aggregateAndProof, FORK_INFO, forkInfo), slashableGenericMessage("aggregate and proof")); } @@ -183,11 +188,7 @@ public SafeFuture signVoluntaryExit( return sign( signingRootUtil.signingRootForSignVoluntaryExit(voluntaryExit, forkInfo), SignType.VOLUNTARY_EXIT, - Map.of( - "voluntary_exit", - new tech.pegasys.teku.api.schema.VoluntaryExit(voluntaryExit), - FORK_INFO, - forkInfo(forkInfo)), + Map.of(SignType.VOLUNTARY_EXIT.getName(), voluntaryExit, FORK_INFO, forkInfo), slashableGenericMessage("voluntary exit")); } @@ -205,10 +206,10 @@ public SafeFuture signSyncCommitteeMessage( signingRoot, SignType.SYNC_COMMITTEE_MESSAGE, Map.of( - "sync_committee_message", - Map.of("beacon_block_root", beaconBlockRoot, "slot", slot), + SignType.SYNC_COMMITTEE_MESSAGE.getName(), + new SyncCommitteeMessageWrapper(beaconBlockRoot, slot), FORK_INFO, - forkInfo(forkInfo)), + forkInfo), slashableGenericMessage("sync committee message"))); } @@ -224,14 +225,11 @@ public SafeFuture signSyncCommitteeSelectionProof( signingRoot, SignType.SYNC_COMMITTEE_SELECTION_PROOF, Map.of( - "sync_aggregator_selection_data", - Map.of( - "slot", - selectionData.getSlot(), - "subcommittee_index", - selectionData.getSubcommitteeIndex()), + SignType.SYNC_AGGREGATOR_SELECTION_DATA.getName(), + new SyncAggregatorSelectionDataWrapper( + selectionData.getSlot(), selectionData.getSubcommitteeIndex()), FORK_INFO, - forkInfo(forkInfo)), + forkInfo), slashableGenericMessage("sync committee selection proof"))); } @@ -247,11 +245,10 @@ public SafeFuture signContributionAndProof( signingRoot, SignType.SYNC_COMMITTEE_CONTRIBUTION_AND_PROOF, Map.of( - "contribution_and_proof", - new tech.pegasys.teku.api.schema.altair.ContributionAndProof( - contributionAndProof), + SignType.CONTRIBUTION_AND_PROOF.getName(), + contributionAndProof, FORK_INFO, - forkInfo(forkInfo)), + forkInfo), slashableGenericMessage("sync committee contribution and proof"))); } @@ -263,17 +260,7 @@ public SafeFuture signValidatorRegistration( sign( signingRootUtil.signingRootForValidatorRegistration(validatorRegistration), SignType.VALIDATOR_REGISTRATION, - Map.of( - "validator_registration", - Map.of( - "fee_recipient", - validatorRegistration.getFeeRecipient().toHexString(), - "gas_limit", - validatorRegistration.getGasLimit(), - "timestamp", - validatorRegistration.getTimestamp(), - "pubkey", - validatorRegistration.getPublicKey().toString())), + Map.of(SignType.VALIDATOR_REGISTRATION.getName(), validatorRegistration), slashableGenericMessage("validator registration"))); } @@ -287,14 +274,6 @@ private SafeFuture signingRootFromSyncCommitteeUtils( return SafeFuture.of(() -> createSigningRoot.apply(spec.getSyncCommitteeUtilRequired(slot))); } - private Map forkInfo(final ForkInfo forkInfo) { - return Map.of( - "fork", - new Fork(forkInfo.getFork()), - "genesis_validators_root", - forkInfo.getGenesisValidatorsRoot()); - } - private SafeFuture sign( final Bytes signingRoot, final SignType type, @@ -326,12 +305,31 @@ private SafeFuture sign( private String createSigningRequestBody( final Bytes signingRoot, final SignType type, final Map metadata) { try { - return jsonProvider.objectToJSON(new SigningRequestBody(signingRoot, type, metadata)); + final SigningRequestBody request = new SigningRequestBody(signingRoot, type, metadata); + final SchemaDefinitions schemaDefinitions = + getSpecVersionFromForkInfo(Optional.ofNullable((ForkInfo) metadata.get(FORK_INFO))); + return JsonUtil.serialize(request, request.getJsonTypeDefinition(schemaDefinitions)); } catch (final JsonProcessingException e) { throw new ExternalSignerException("Unable to create external signing request", e); } } + private SchemaDefinitions getSpecVersionFromForkInfo(final Optional maybeForkInfo) { + final Optional maybeFork = maybeForkInfo.map(f -> f.getFork().getCurrentVersion()); + if (maybeFork.isEmpty()) { + return schemaDefinitionCache.getSchemaDefinition( + schemaDefinitionCache.getSupportedMilestones().getFirst()); + } + final Bytes4 currentFork = maybeFork.orElseThrow(); + return spec.getEnabledMilestones().stream() + .filter(f -> f.getFork().getCurrentVersion().equals(currentFork)) + .map(f -> schemaDefinitionCache.getSchemaDefinition(f.getSpecMilestone())) + .findFirst() + .orElse( + schemaDefinitionCache.getSchemaDefinition( + schemaDefinitionCache.getSupportedMilestones().getFirst())); + } + private BLSSignature getBlsSignatureResponder( final URI url, final SignType type, @@ -353,11 +351,11 @@ private BLSSignature getBlsSignatureResponder( try { final String returnedContentType = response.headers().firstValue("Content-Type").orElse(""); - final String signatureHexStr = - returnedContentType.startsWith("application/json") - ? jsonProvider.jsonToObject(response.body(), SigningResponseBody.class).getSignature() - : response.body(); - + if (returnedContentType.startsWith("application/json")) { + return JsonUtil.parse(response.body(), SigningResponseBody.getJsonTypeDefinition()) + .signature(); + } + final String signatureHexStr = response.body(); final Bytes signature = Bytes.fromHexString(signatureHexStr); return BLSSignature.fromBytesCompressed(signature); } catch (final IllegalArgumentException | JsonProcessingException e) { diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/ExternalSignerBlockRequestProvider.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/ExternalSignerBlockRequestProvider.java index f758df116ed..462a7dd1064 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/ExternalSignerBlockRequestProvider.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/ExternalSignerBlockRequestProvider.java @@ -15,15 +15,16 @@ import java.util.HashMap; import java.util.Map; -import tech.pegasys.teku.api.SchemaObjectProvider; +import java.util.Optional; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock; import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlockHeader; +import tech.pegasys.teku.validator.api.signer.BlockWrapper; +import tech.pegasys.teku.validator.api.signer.SignType; public class ExternalSignerBlockRequestProvider { private final Spec spec; - private final SchemaObjectProvider schemaObjectProvider; private final BeaconBlock block; private final BeaconBlockHeader blockHeader; @@ -33,7 +34,6 @@ public ExternalSignerBlockRequestProvider(final Spec spec, final BeaconBlock blo this.spec = spec; this.block = block; this.blockHeader = BeaconBlockHeader.fromBlock(block); - schemaObjectProvider = new SchemaObjectProvider(spec); // backward compatible with phase 0 if (spec.atSlot(block.getSlot()).getMilestone().equals(SpecMilestone.PHASE0)) { signType = SignType.BLOCK; @@ -45,24 +45,21 @@ public ExternalSignerBlockRequestProvider(final Spec spec, final BeaconBlock blo public Map getBlockMetadata(final Map additionalEntries) { final Map metadata = new HashMap<>(additionalEntries); - final tech.pegasys.teku.api.schema.BeaconBlock beaconBlock = - block.getBody().isBlinded() - ? schemaObjectProvider.getBlindedBlock(block) - : schemaObjectProvider.getBeaconBlock(block); - final tech.pegasys.teku.api.schema.BeaconBlockHeader beaconBlockHeader = - new tech.pegasys.teku.api.schema.BeaconBlockHeader(blockHeader); - final SpecMilestone milestone = spec.atSlot(block.getSlot()).getMilestone(); switch (milestone) { case PHASE0: - metadata.put("block", beaconBlock); // backward compatible with phase0 + metadata.put(SignType.BLOCK.getName(), block); // backward compatible with phase0 break; case ALTAIR: - metadata.put("beacon_block", new BlockRequestBody(milestone, beaconBlock)); + metadata.put( + SignType.BEACON_BLOCK.getName(), + new BlockWrapper(milestone, Optional.of(block), Optional.empty())); break; default: // use block header for BELLATRIX and onward milestones - metadata.put("beacon_block", new BlockRequestBody(milestone, beaconBlockHeader)); + metadata.put( + SignType.BEACON_BLOCK.getName(), + new BlockWrapper(milestone, Optional.empty(), Optional.of(blockHeader))); } return metadata; diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/ExternalSignerException.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/ExternalSignerException.java index 83e18f74bff..6c298bde38b 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/ExternalSignerException.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/ExternalSignerException.java @@ -15,6 +15,7 @@ import java.net.URI; import tech.pegasys.teku.infrastructure.http.UrlSanitizer; +import tech.pegasys.teku.validator.api.signer.SignType; public class ExternalSignerException extends RuntimeException { diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/MilestoneBasedBlockContainerSigner.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/MilestoneBasedBlockContainerSigner.java index 46b7528d514..968645238d0 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/MilestoneBasedBlockContainerSigner.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/MilestoneBasedBlockContainerSigner.java @@ -14,7 +14,7 @@ package tech.pegasys.teku.validator.client.signer; import com.google.common.base.Suppliers; -import java.util.HashMap; +import java.util.EnumMap; import java.util.Map; import java.util.function.Supplier; import tech.pegasys.teku.infrastructure.async.SafeFuture; @@ -28,7 +28,8 @@ public class MilestoneBasedBlockContainerSigner implements BlockContainerSigner { private final Spec spec; - private final Map registeredSigners = new HashMap<>(); + private final Map registeredSigners = + new EnumMap<>(SpecMilestone.class); public MilestoneBasedBlockContainerSigner(final Spec spec) { this.spec = spec; diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/SignType.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/SignType.java deleted file mode 100644 index 3cfab2e178c..00000000000 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/SignType.java +++ /dev/null @@ -1,43 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.validator.client.signer; - -import com.fasterxml.jackson.annotation.JsonProperty; - -public enum SignType { - @JsonProperty("randao_reveal") - RANDAO_REVEAL, - @JsonProperty("block") - BLOCK, - @JsonProperty("block_v2") - BLOCK_V2, - @JsonProperty("attestation") - ATTESTATION, - @JsonProperty("aggregation_slot") - AGGREGATION_SLOT, - @JsonProperty("aggregate_and_proof") - AGGREGATE_AND_PROOF, - @JsonProperty("voluntary_exit") - VOLUNTARY_EXIT, - @JsonProperty("sync_committee_message") - SYNC_COMMITTEE_MESSAGE, - @JsonProperty("sync_committee_selection_proof") - SYNC_COMMITTEE_SELECTION_PROOF, - @JsonProperty("sync_committee_contribution_and_proof") - SYNC_COMMITTEE_CONTRIBUTION_AND_PROOF, - @JsonProperty("validator_registration") - VALIDATOR_REGISTRATION, - @JsonProperty("blob_sidecar") - BLOB_SIDECAR -} diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/SigningRequestBody.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/SigningRequestBody.java index dd4ed9ba698..f98c071b339 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/SigningRequestBody.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/SigningRequestBody.java @@ -13,51 +13,145 @@ package tech.pegasys.teku.validator.client.signer; -import com.fasterxml.jackson.annotation.JsonAnyGetter; -import com.fasterxml.jackson.annotation.JsonAnySetter; -import com.fasterxml.jackson.annotation.JsonProperty; -import java.util.HashMap; +import static tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition.enumOf; +import static tech.pegasys.teku.validator.client.signer.ExternalSigner.FORK_INFO; + import java.util.Map; +import java.util.Optional; import org.apache.tuweni.bytes.Bytes; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition; +import tech.pegasys.teku.infrastructure.json.types.StringValueTypeDefinition; +import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock; +import tech.pegasys.teku.spec.datastructures.builder.ValidatorRegistration; +import tech.pegasys.teku.spec.datastructures.operations.AggregateAndProof; +import tech.pegasys.teku.spec.datastructures.operations.AttestationData; +import tech.pegasys.teku.spec.datastructures.operations.VoluntaryExit; +import tech.pegasys.teku.spec.datastructures.operations.versions.altair.ContributionAndProof; +import tech.pegasys.teku.spec.datastructures.state.ForkInfo; +import tech.pegasys.teku.spec.schemas.SchemaDefinitions; +import tech.pegasys.teku.validator.api.signer.AggregationSlotWrapper; +import tech.pegasys.teku.validator.api.signer.BlockWrapper; +import tech.pegasys.teku.validator.api.signer.RandaoRevealWrapper; +import tech.pegasys.teku.validator.api.signer.SignType; +import tech.pegasys.teku.validator.api.signer.SyncAggregatorSelectionDataWrapper; +import tech.pegasys.teku.validator.api.signer.SyncCommitteeMessageWrapper; + +public record SigningRequestBody(Bytes signingRoot, SignType type, Map metadata) { + private static final StringValueTypeDefinition BYTES_TYPE = + DeserializableTypeDefinition.string(Bytes.class) + .formatter(Bytes::toHexString) + .parser(Bytes::fromHexString) + .format("byte") + .build(); + + public SerializableTypeDefinition getJsonTypeDefinition( + final SchemaDefinitions schemaDefinitions) { + return SerializableTypeDefinition.object(SigningRequestBody.class) + .withField("signingRoot", BYTES_TYPE, SigningRequestBody::signingRoot) + .withField("type", enumOf(SignType.class), SigningRequestBody::type) + .withOptionalField( + SignType.VOLUNTARY_EXIT.getName(), + VoluntaryExit.SSZ_SCHEMA.getJsonTypeDefinition(), + SigningRequestBody::getVoluntaryExit) + .withOptionalField( + SignType.AGGREGATION_SLOT.getName(), + AggregationSlotWrapper.getJsonTypeDefinition(), + SigningRequestBody::getAggregationSlot) + .withOptionalField( + FORK_INFO, ForkInfo.getJsonTypeDefinition(), SigningRequestBody::getForkInfo) + .withOptionalField( + SignType.ATTESTATION.getName(), + AttestationData.SSZ_SCHEMA.getJsonTypeDefinition(), + SigningRequestBody::getAttestationData) + .withOptionalField( + SignType.SYNC_COMMITTEE_MESSAGE.getName(), + SyncCommitteeMessageWrapper.getJsonTypeDefinition(), + SigningRequestBody::getSyncCommitteeMessage) + .withOptionalField( + SignType.SYNC_AGGREGATOR_SELECTION_DATA.getName(), + SyncAggregatorSelectionDataWrapper.getJsonTypefinition(), + SigningRequestBody::getSyncAggregateSelectionData) + .withOptionalField( + SignType.BEACON_BLOCK.getName(), + getBlockWrapper().map(BlockWrapper::getJsonTypeDefinition).orElse(null), + SigningRequestBody::getBlockWrapper) + .withOptionalField( + SignType.VALIDATOR_REGISTRATION.getName(), + ValidatorRegistration.SSZ_SCHEMA.getJsonTypeDefinition(), + SigningRequestBody::getValidatorRegistration) + .withOptionalField( + SignType.CONTRIBUTION_AND_PROOF.getName(), + getContributionAndProof().map(z -> z.getSchema().getJsonTypeDefinition()).orElse(null), + SigningRequestBody::getContributionAndProof) + .withOptionalField( + SignType.AGGREGATE_AND_PROOF.getName(), + schemaDefinitions.getAggregateAndProofSchema().getJsonTypeDefinition(), + SigningRequestBody::getAggregateAndProof) + .withOptionalField( + SignType.BLOCK.getName(), + schemaDefinitions.getBeaconBlockSchema().getJsonTypeDefinition(), + SigningRequestBody::getBlock) + .withOptionalField( + SignType.RANDAO_REVEAL.getName(), + RandaoRevealWrapper.getJsonTypeDefinition(), + SigningRequestBody::getRandaoReveal) + .build(); + } -public class SigningRequestBody { - @JsonProperty("signingRoot") - private Bytes signingRoot; + private Optional getForkInfo() { + return Optional.ofNullable((ForkInfo) metadata.get(FORK_INFO)); + } - @JsonProperty("type") - private SignType type; + private Optional getVoluntaryExit() { + return Optional.ofNullable((VoluntaryExit) metadata.get(SignType.VOLUNTARY_EXIT.getName())); + } - @JsonAnySetter private final Map metadata = new HashMap<>(); + private Optional getContributionAndProof() { + return Optional.ofNullable( + (ContributionAndProof) metadata.get(SignType.CONTRIBUTION_AND_PROOF.getName())); + } + + private Optional getAttestationData() { + return Optional.ofNullable((AttestationData) metadata.get(SignType.ATTESTATION.getName())); + } + + private Optional getAggregateAndProof() { + return Optional.ofNullable( + (AggregateAndProof) metadata.get(SignType.AGGREGATE_AND_PROOF.getName())); + } - public SigningRequestBody() { - // keeps jackson happy + private Optional getBlock() { + return Optional.ofNullable((BeaconBlock) metadata.get(SignType.BLOCK.getName())); } - public SigningRequestBody( - final Bytes signingRoot, final SignType type, final Map metadata) { - this.signingRoot = signingRoot; - this.type = type; - this.metadata.putAll(metadata); + private Optional getBlockWrapper() { + return Optional.ofNullable((BlockWrapper) metadata.get(SignType.BEACON_BLOCK.getName())); } - @JsonAnyGetter - public Map getMetadata() { - return metadata; + private Optional getSyncCommitteeMessage() { + return Optional.ofNullable( + (SyncCommitteeMessageWrapper) metadata.get(SignType.SYNC_COMMITTEE_MESSAGE.getName())); } - public void setSigningRoot(final Bytes signingRoot) { - this.signingRoot = signingRoot; + private Optional getSyncAggregateSelectionData() { + return Optional.ofNullable( + (SyncAggregatorSelectionDataWrapper) + metadata.get(SignType.SYNC_AGGREGATOR_SELECTION_DATA.getName())); } - public Bytes getSigningRoot() { - return signingRoot; + private Optional getValidatorRegistration() { + return Optional.ofNullable( + (ValidatorRegistration) metadata.get(SignType.VALIDATOR_REGISTRATION.getName())); } - public SignType getType() { - return type; + private Optional getRandaoReveal() { + return Optional.ofNullable( + (RandaoRevealWrapper) metadata.get(SignType.RANDAO_REVEAL.getName())); } - public void setType(final SignType type) { - this.type = type; + private Optional getAggregationSlot() { + return Optional.ofNullable( + (AggregationSlotWrapper) metadata.get(SignType.AGGREGATION_SLOT.getName())); } } diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/SigningResponseBody.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/SigningResponseBody.java index 30aff5446a1..4c2a6e48eb1 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/SigningResponseBody.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/signer/SigningResponseBody.java @@ -13,21 +13,36 @@ package tech.pegasys.teku.validator.client.signer; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonProperty; - -@JsonIgnoreProperties(ignoreUnknown = true) -public class SigningResponseBody { - private final String signature; - - @JsonCreator - public SigningResponseBody( - @JsonProperty(value = "signature", required = true) final String signature) { - this.signature = signature; +import static tech.pegasys.teku.ethereum.json.types.EthereumTypes.SIGNATURE_TYPE; + +import tech.pegasys.teku.bls.BLSSignature; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; + +public record SigningResponseBody(BLSSignature signature) { + + static DeserializableTypeDefinition getJsonTypeDefinition() { + return DeserializableTypeDefinition.object( + SigningResponseBody.class, SigningResponseBodyBuilder.class) + .initializer(SigningResponseBodyBuilder::new) + .finisher(SigningResponseBodyBuilder::build) + .withField( + "signature", + SIGNATURE_TYPE, + SigningResponseBody::signature, + SigningResponseBodyBuilder::signature) + .build(); } - public String getSignature() { - return signature; + static class SigningResponseBodyBuilder { + private BLSSignature signature; + + SigningResponseBodyBuilder signature(final BLSSignature signature) { + this.signature = signature; + return this; + } + + SigningResponseBody build() { + return new SigningResponseBody(signature); + } } } diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/slashingriskactions/SlashedValidatorShutDown.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/slashingriskactions/SlashedValidatorShutDown.java index 294e7bb80e6..ef09ced34b2 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/slashingriskactions/SlashedValidatorShutDown.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/slashingriskactions/SlashedValidatorShutDown.java @@ -31,7 +31,7 @@ public SlashedValidatorShutDown(final StatusLogger statusLog) { } @Override - public void perform(List pubKeys) { + public void perform(final List pubKeys) { if (!pubKeys.isEmpty()) { statusLog.validatorSlashedAlert( pubKeys.stream().map(BLSPublicKey::toHexString).collect(Collectors.toSet())); diff --git a/validator/client/src/main/java/tech/pegasys/teku/validator/client/slashingriskactions/SlashingRiskAction.java b/validator/client/src/main/java/tech/pegasys/teku/validator/client/slashingriskactions/SlashingRiskAction.java index 95f659d5f71..d9630c066f4 100644 --- a/validator/client/src/main/java/tech/pegasys/teku/validator/client/slashingriskactions/SlashingRiskAction.java +++ b/validator/client/src/main/java/tech/pegasys/teku/validator/client/slashingriskactions/SlashingRiskAction.java @@ -22,7 +22,7 @@ public interface SlashingRiskAction { void perform(final List doppelgangers); - default void perform(BLSPublicKey pubKey) { + default void perform(final BLSPublicKey pubKey) { perform(List.of(pubKey)); } diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/BeaconProposerPreparerTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/BeaconProposerPreparerTest.java index 41f8bced8a2..f9f61e79a6e 100644 --- a/validator/client/src/test/java/tech/pegasys/teku/validator/client/BeaconProposerPreparerTest.java +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/BeaconProposerPreparerTest.java @@ -36,7 +36,7 @@ import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.TestSpecContext; import tech.pegasys.teku.spec.TestSpecInvocationContextProvider.SpecContext; -import tech.pegasys.teku.spec.datastructures.operations.versions.bellatrix.BeaconPreparableProposer; +import tech.pegasys.teku.spec.datastructures.validator.BeaconPreparableProposer; import tech.pegasys.teku.spec.signatures.Signer; import tech.pegasys.teku.validator.api.ValidatorApiChannel; @@ -57,7 +57,7 @@ public class BeaconProposerPreparerTest { private long slotsPerEpoch; @BeforeEach - void setUp(SpecContext specContext) { + void setUp(final SpecContext specContext) { final Spec spec = specContext.getSpec(); final Validator validator1 = diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/DoppelgangerDetectorTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/DoppelgangerDetectorTest.java index be96cb2befd..a1c75112871 100644 --- a/validator/client/src/test/java/tech/pegasys/teku/validator/client/DoppelgangerDetectorTest.java +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/DoppelgangerDetectorTest.java @@ -504,7 +504,7 @@ public void shouldCheckPreviousAndCurrentEpochAtFirstRun() { assertThat(doppelgangerDetectorFuture).isCompletedWithValue(doppelgangers); } - private Stream toAbbreviatedKeys(Set pubKeys) { + private Stream toAbbreviatedKeys(final Set pubKeys) { return pubKeys.stream().map(BLSPublicKey::toAbbreviatedString); } } diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/OwnedKeyManagerTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/OwnedKeyManagerTest.java index 23c4b70203d..f8bc291931b 100644 --- a/validator/client/src/test/java/tech/pegasys/teku/validator/client/OwnedKeyManagerTest.java +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/OwnedKeyManagerTest.java @@ -494,7 +494,7 @@ void shouldAddExternalKeysWhenDoppelgangerDetectionException() throws MalformedU doppelgangerPublicKey.toAbbreviatedString())); } - private String getKeystore(String fileName) throws IOException, URISyntaxException { + private String getKeystore(final String fileName) throws IOException, URISyntaxException { final URL resource = Resources.getResource(fileName); FileInputStream fis = new FileInputStream(new File(resource.toURI())); return IOUtils.toString(fis, "UTF-8"); diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/PendingDutiesTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/PendingDutiesTest.java index a71afd6fa8f..3617b474885 100644 --- a/validator/client/src/test/java/tech/pegasys/teku/validator/client/PendingDutiesTest.java +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/PendingDutiesTest.java @@ -245,7 +245,7 @@ void shouldReportTotalNumberOfSuccessesAndFailuresToMetrics() { private void validateMetrics(final String duty, final long successCount, final long failCount) { final StubCounter labelledCounter = - metricsSystem.getCounter(TekuMetricCategory.VALIDATOR, "duties_performed"); + metricsSystem.getCounter(TekuMetricCategory.VALIDATOR, "duties_performed_total"); assertThat(labelledCounter.getValue(duty, "success")).isEqualTo(successCount); assertThat(labelledCounter.getValue(duty, "failed")).isEqualTo(failCount); } diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/SyncCommitteeDutyLoaderTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/SyncCommitteeDutyLoaderTest.java index 63aad2b0c1f..1a136a602a9 100644 --- a/validator/client/src/test/java/tech/pegasys/teku/validator/client/SyncCommitteeDutyLoaderTest.java +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/SyncCommitteeDutyLoaderTest.java @@ -31,6 +31,7 @@ import org.junit.jupiter.api.Test; import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeDuties; import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeDuty; +import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.metrics.StubMetricsSystem; import tech.pegasys.teku.infrastructure.metrics.TekuMetricCategory; @@ -39,7 +40,6 @@ import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.signatures.Signer; import tech.pegasys.teku.spec.util.DataStructureUtil; -import tech.pegasys.teku.validator.api.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.validator.api.ValidatorApiChannel; import tech.pegasys.teku.validator.client.duties.synccommittee.ChainHeadTracker; import tech.pegasys.teku.validator.client.duties.synccommittee.SyncCommitteeScheduledDuties; diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/ValidatorRegistratorTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/ValidatorRegistratorTest.java index 096c9db45e6..0b3f915615e 100644 --- a/validator/client/src/test/java/tech/pegasys/teku/validator/client/ValidatorRegistratorTest.java +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/ValidatorRegistratorTest.java @@ -41,6 +41,7 @@ import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.ethereum.execution.types.Eth1Address; import tech.pegasys.teku.infrastructure.async.SafeFuture; +import tech.pegasys.teku.infrastructure.async.StubAsyncRunner; import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.SpecMilestone; @@ -66,6 +67,7 @@ class ValidatorRegistratorTest { mock(SignedValidatorRegistrationFactory.class); private final ValidatorApiChannel validatorApiChannel = mock(ValidatorApiChannel.class); private final Signer signer = mock(Signer.class); + private final StubAsyncRunner stubAsyncRunner = new StubAsyncRunner(); private SpecContext specContext; private DataStructureUtil dataStructureUtil; @@ -110,7 +112,8 @@ void setUp(final SpecContext specContext) { proposerConfigPropertiesProvider, signedValidatorRegistrationFactory, validatorApiChannel, - BATCH_SIZE); + BATCH_SIZE, + stubAsyncRunner); when(signedValidatorRegistrationFactory.createSignedValidatorRegistration(any(), any(), any())) .thenAnswer( @@ -403,7 +406,8 @@ void checksStatusesAndSendsRegistrationsInBatches() { proposerConfigPropertiesProvider, signedValidatorRegistrationFactory, validatorApiChannel, - 2); + 2, + stubAsyncRunner); setOwnedValidators(validator1, validator2, validator3); runRegistrationFlowWithSubscription(0); @@ -428,7 +432,8 @@ void stopsToSendBatchesOnFirstFailure() { proposerConfigPropertiesProvider, signedValidatorRegistrationFactory, validatorApiChannel, - 2); + 2, + stubAsyncRunner); setOwnedValidators(validator1, validator2, validator3); runRegistrationFlowWithSubscription(0); @@ -442,6 +447,30 @@ void stopsToSendBatchesOnFirstFailure() { verifyRegistrations(registrationCalls.get(0), List.of(validator1, validator2)); } + @TestTemplate + void schedulesRetryOnFailure() { + when(validatorApiChannel.registerValidators(any())) + .thenReturn(SafeFuture.failedFuture(new IllegalStateException("oopsy"))) + .thenReturn(SafeFuture.COMPLETE); + + setOwnedValidators(validator1, validator2, validator3); + + runRegistrationFlowWithSubscription(0); + + assertThat(stubAsyncRunner.countDelayedActions()).isOne(); + + // execute the delayed future + stubAsyncRunner.executeQueuedActions(); + + // no more retries + assertThat(stubAsyncRunner.countDelayedActions()).isZero(); + + final List> registrationCalls = captureRegistrationCalls(2); + + verifyRegistrations(registrationCalls.get(0), List.of(validator1, validator2, validator3)); + verifyRegistrations(registrationCalls.get(1), List.of(validator1, validator2, validator3)); + } + @TestTemplate void checksValidatorStatusWithPublicKeyOverride() { final BLSPublicKey validator2KeyOverride = dataStructureUtil.randomPublicKey(); diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/duties/AggregationDutyTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/duties/AggregationDutyTest.java index ab193432d7e..dd47c2ec23c 100644 --- a/validator/client/src/test/java/tech/pegasys/teku/validator/client/duties/AggregationDutyTest.java +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/duties/AggregationDutyTest.java @@ -28,13 +28,15 @@ import static tech.pegasys.teku.infrastructure.async.SafeFuture.completedFuture; import static tech.pegasys.teku.infrastructure.async.SafeFuture.failedFuture; import static tech.pegasys.teku.infrastructure.async.SafeFutureAssert.safeJoin; +import static tech.pegasys.teku.spec.SpecMilestone.ELECTRA; +import static tech.pegasys.teku.spec.SpecMilestone.PHASE0; import java.util.Collections; import java.util.List; import java.util.Optional; import java.util.Set; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestTemplate; import org.mockito.ArgumentCaptor; import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.infrastructure.async.SafeFuture; @@ -43,7 +45,8 @@ import tech.pegasys.teku.infrastructure.metrics.Validator.ValidatorDutyMetricsSteps; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider.SpecContext; import tech.pegasys.teku.spec.datastructures.operations.AggregateAndProof; import tech.pegasys.teku.spec.datastructures.operations.AggregateAndProof.AggregateAndProofSchema; import tech.pegasys.teku.spec.datastructures.operations.Attestation; @@ -60,53 +63,68 @@ import tech.pegasys.teku.validator.client.duties.attestations.AggregationDuty; import tech.pegasys.teku.validator.client.duties.attestations.BatchAttestationSendingStrategy; +@TestSpecContext(milestone = {PHASE0, ELECTRA}) class AggregationDutyTest { private static final String TYPE = "aggregate"; private static final UInt64 SLOT = UInt64.valueOf(2832); - private final Spec spec = TestSpecFactory.createDefault(); - private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); - private final AggregateAndProofSchema aggregateAndProofSchema = - spec.getGenesisSchemaDefinitions().getAggregateAndProofSchema(); - private final SignedAggregateAndProofSchema signedAggregateAndProofSchema = - spec.getGenesisSchemaDefinitions().getSignedAggregateAndProofSchema(); - private final ForkInfo forkInfo = dataStructureUtil.randomForkInfo(); + private final ValidatorApiChannel validatorApiChannel = mock(ValidatorApiChannel.class); private final ForkProvider forkProvider = mock(ForkProvider.class); private final Signer signer1 = mock(Signer.class); private final Signer signer2 = mock(Signer.class); - private final Validator validator1 = - new Validator(dataStructureUtil.randomPublicKey(), signer1, new FileBackedGraffitiProvider()); - private final Validator validator2 = - new Validator(dataStructureUtil.randomPublicKey(), signer2, new FileBackedGraffitiProvider()); private final ValidatorLogger validatorLogger = mock(ValidatorLogger.class); private final ValidatorDutyMetrics validatorDutyMetrics = spy(ValidatorDutyMetrics.create(new StubMetricsSystem())); - private final AggregationDuty duty = - new AggregationDuty( - spec, - SLOT, - validatorApiChannel, - forkProvider, - validatorLogger, - new BatchAttestationSendingStrategy<>(validatorApiChannel::sendAggregateAndProofs), - validatorDutyMetrics); + private Spec spec; + private DataStructureUtil dataStructureUtil; + private AggregateAndProofSchema aggregateAndProofSchema; + private SignedAggregateAndProofSchema signedAggregateAndProofSchema; + private ForkInfo forkInfo; + private Validator validator1; + private Validator validator2; + + private AggregationDuty duty; @BeforeEach - public void setUp() { + public void setUp(final SpecContext specContext) { + spec = specContext.getSpec(); + dataStructureUtil = specContext.getDataStructureUtil(); + aggregateAndProofSchema = spec.getGenesisSchemaDefinitions().getAggregateAndProofSchema(); + signedAggregateAndProofSchema = + spec.getGenesisSchemaDefinitions().getSignedAggregateAndProofSchema(); + forkInfo = dataStructureUtil.randomForkInfo(); + + validator1 = + new Validator( + dataStructureUtil.randomPublicKey(), signer1, new FileBackedGraffitiProvider()); + validator2 = + new Validator( + dataStructureUtil.randomPublicKey(), signer2, new FileBackedGraffitiProvider()); + + duty = + new AggregationDuty( + spec, + SLOT, + validatorApiChannel, + forkProvider, + validatorLogger, + new BatchAttestationSendingStrategy<>(validatorApiChannel::sendAggregateAndProofs), + validatorDutyMetrics); + when(forkProvider.getForkInfo(any())).thenReturn(SafeFuture.completedFuture(forkInfo)); when(validatorApiChannel.sendAggregateAndProofs(any())) .thenReturn(SafeFuture.completedFuture(Collections.emptyList())); } - @Test + @TestTemplate public void shouldBeCompleteWhenNoValidatorsAdded() { performAndReportDuty(); verifyNoInteractions(validatorApiChannel, validatorLogger); } - @Test + @TestTemplate public void shouldProduceAggregateAndProof() { final int validatorIndex = 1; final int attestationCommitteeIndex = 2; @@ -120,7 +138,10 @@ public void shouldProduceAggregateAndProof() { attestationCommitteeIndex, completedFuture(Optional.of(attestationData))); - when(validatorApiChannel.createAggregate(SLOT, attestationData.hashTreeRoot())) + when(validatorApiChannel.createAggregate( + SLOT, + attestationData.hashTreeRoot(), + Optional.of(UInt64.valueOf(attestationCommitteeIndex)))) .thenReturn(completedFuture(Optional.of(aggregate))); final AggregateAndProof expectedAggregateAndProof = @@ -144,7 +165,7 @@ public void shouldProduceAggregateAndProof() { } @SuppressWarnings("unchecked") - @Test + @TestTemplate public void shouldProduceAggregateAndProofForMultipleCommittees() { final int validator1Index = 1; final int validator1CommitteeIndex = 2; @@ -171,9 +192,15 @@ public void shouldProduceAggregateAndProofForMultipleCommittees() { validator2CommitteeIndex, completedFuture(Optional.of(committee2AttestationData))); - when(validatorApiChannel.createAggregate(SLOT, committee1AttestationData.hashTreeRoot())) + when(validatorApiChannel.createAggregate( + SLOT, + committee1AttestationData.hashTreeRoot(), + Optional.of(UInt64.valueOf(validator1CommitteeIndex)))) .thenReturn(completedFuture(Optional.of(committee1Aggregate))); - when(validatorApiChannel.createAggregate(SLOT, committee2AttestationData.hashTreeRoot())) + when(validatorApiChannel.createAggregate( + SLOT, + committee2AttestationData.hashTreeRoot(), + Optional.of(UInt64.valueOf(validator2CommitteeIndex)))) .thenReturn(completedFuture(Optional.of(committee2Aggregate))); final AggregateAndProof aggregateAndProof1 = @@ -207,7 +234,7 @@ public void shouldProduceAggregateAndProofForMultipleCommittees() { .record(any(), any(AggregationDuty.class), eq(ValidatorDutyMetricsSteps.SIGN)); } - @Test + @TestTemplate public void shouldProduceSingleAggregateAndProofWhenMultipleValidatorsAggregateSameCommittee() { final int committeeIndex = 2; @@ -232,7 +259,8 @@ public void shouldProduceSingleAggregateAndProofWhenMultipleValidatorsAggregateS committeeIndex, completedFuture(Optional.of(attestationData))); - when(validatorApiChannel.createAggregate(SLOT, attestationData.hashTreeRoot())) + when(validatorApiChannel.createAggregate( + SLOT, attestationData.hashTreeRoot(), Optional.of(UInt64.valueOf(committeeIndex)))) .thenReturn(completedFuture(Optional.of(aggregate))); when(validatorApiChannel.sendAggregateAndProofs(anyList())) .thenReturn(SafeFuture.completedFuture(Collections.emptyList())); @@ -262,7 +290,7 @@ public void shouldProduceSingleAggregateAndProofWhenMultipleValidatorsAggregateS .record(any(), any(AggregationDuty.class), eq(ValidatorDutyMetricsSteps.SIGN)); } - @Test + @TestTemplate public void shouldFailWhenAttestationDataNotCreated() { duty.addValidator( validator1, 1, dataStructureUtil.randomSignature(), 2, completedFuture(Optional.empty())); @@ -280,7 +308,7 @@ public void shouldFailWhenAttestationDataNotCreated() { verifyNoInteractions(validatorDutyMetrics); } - @Test + @TestTemplate public void shouldFailWhenAttestationDataCompletesExceptionally() { final RuntimeException exception = new RuntimeException("Doh!"); duty.addValidator( @@ -295,7 +323,7 @@ public void shouldFailWhenAttestationDataCompletesExceptionally() { verifyNoInteractions(validatorDutyMetrics); } - @Test + @TestTemplate public void shouldReportWhenAggregateNotCreated() { final AttestationData attestationData = dataStructureUtil.randomAttestationData(); duty.addValidator( @@ -304,12 +332,13 @@ public void shouldReportWhenAggregateNotCreated() { dataStructureUtil.randomSignature(), 2, completedFuture(Optional.of(attestationData))); - when(validatorApiChannel.createAggregate(SLOT, attestationData.hashTreeRoot())) + when(validatorApiChannel.createAggregate( + SLOT, attestationData.hashTreeRoot(), Optional.of(UInt64.valueOf(2)))) .thenReturn(completedFuture(Optional.empty())); assertThat(duty.performDuty()).isCompleted(); verify(validatorApiChannel, never()).sendAggregateAndProofs(anyList()); - verify(validatorLogger).aggregationSkipped(SLOT, 2); + verify(validatorLogger).aggregationSkipped(SLOT, UInt64.valueOf(2)); verifyNoMoreInteractions(validatorLogger); // Even when we fail creating the aggregation, we capture the time taken @@ -319,7 +348,7 @@ public void shouldReportWhenAggregateNotCreated() { verifyNoMoreInteractions(validatorDutyMetrics); } - @Test + @TestTemplate public void shouldFailWhenAggregateFails() { final Exception exception = new RuntimeException("Whoops"); final AttestationData attestationData = dataStructureUtil.randomAttestationData(); @@ -329,7 +358,8 @@ public void shouldFailWhenAggregateFails() { dataStructureUtil.randomSignature(), 2, completedFuture(Optional.of(attestationData))); - when(validatorApiChannel.createAggregate(SLOT, attestationData.hashTreeRoot())) + when(validatorApiChannel.createAggregate( + SLOT, attestationData.hashTreeRoot(), Optional.of(UInt64.valueOf(2)))) .thenReturn(failedFuture(exception)); performAndReportDuty(); diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/duties/AttestationProductionDutyTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/duties/AttestationProductionDutyTest.java index 1a0b1487510..6a2d0a9e215 100644 --- a/validator/client/src/test/java/tech/pegasys/teku/validator/client/duties/AttestationProductionDutyTest.java +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/duties/AttestationProductionDutyTest.java @@ -31,25 +31,30 @@ import static tech.pegasys.teku.infrastructure.async.SafeFutureAssert.safeJoin; import static tech.pegasys.teku.infrastructure.metrics.Validator.ValidatorDutyMetricsSteps.CREATE_TOTAL; import static tech.pegasys.teku.infrastructure.metrics.Validator.ValidatorDutyMetricsSteps.SIGN; +import static tech.pegasys.teku.spec.SpecMilestone.ELECTRA; +import static tech.pegasys.teku.spec.SpecMilestone.PHASE0; import java.util.Collections; import java.util.List; import java.util.Optional; import java.util.Set; +import java.util.function.Supplier; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestTemplate; import org.mockito.ArgumentCaptor; import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.logging.ValidatorLogger; import tech.pegasys.teku.infrastructure.metrics.StubMetricsSystem; import tech.pegasys.teku.infrastructure.ssz.collections.SszBitlist; +import tech.pegasys.teku.infrastructure.ssz.collections.SszBitvector; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.TestSpecInvocationContextProvider.SpecContext; import tech.pegasys.teku.spec.datastructures.operations.Attestation; -import tech.pegasys.teku.spec.datastructures.operations.Attestation.AttestationSchema; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; import tech.pegasys.teku.spec.datastructures.state.ForkInfo; import tech.pegasys.teku.spec.signatures.Signer; import tech.pegasys.teku.spec.util.DataStructureUtil; @@ -61,44 +66,51 @@ import tech.pegasys.teku.validator.client.duties.attestations.AttestationProductionDuty; import tech.pegasys.teku.validator.client.duties.attestations.BatchAttestationSendingStrategy; +@TestSpecContext(milestone = {PHASE0, ELECTRA}) class AttestationProductionDutyTest { private static final String TYPE = "attestation"; private static final UInt64 SLOT = UInt64.valueOf(1488); - private final Spec spec = TestSpecFactory.createDefault(); - private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); - private final ForkInfo fork = dataStructureUtil.randomForkInfo(); + private Spec spec; + private DataStructureUtil dataStructureUtil; + private ForkInfo fork; private final ForkProvider forkProvider = mock(ForkProvider.class); private final ValidatorApiChannel validatorApiChannel = mock(ValidatorApiChannel.class); private final ValidatorLogger validatorLogger = mock(ValidatorLogger.class); private final ValidatorDutyMetrics validatorDutyMetrics = spy(ValidatorDutyMetrics.create(new StubMetricsSystem())); - private final AttestationProductionDuty duty = - new AttestationProductionDuty( - spec, - SLOT, - forkProvider, - validatorApiChannel, - new BatchAttestationSendingStrategy<>(validatorApiChannel::sendSignedAttestations), - validatorDutyMetrics); + private AttestationProductionDuty duty; @BeforeEach - public void setUp() { + public void setUp(final SpecContext specContext) { + spec = specContext.getSpec(); + dataStructureUtil = specContext.getDataStructureUtil(); + fork = dataStructureUtil.randomForkInfo(); + + duty = + new AttestationProductionDuty( + spec, + SLOT, + forkProvider, + validatorApiChannel, + new BatchAttestationSendingStrategy<>(validatorApiChannel::sendSignedAttestations), + validatorDutyMetrics); + when(forkProvider.getForkInfo(any())).thenReturn(completedFuture(fork)); when(validatorApiChannel.sendSignedAttestations(any())) .thenReturn(SafeFuture.completedFuture(Collections.emptyList())); } - @Test + @TestTemplate public void shouldNotProduceAnyAttestationsWhenNoValidatorsAdded() { performAndReportDuty(); verifyNoInteractions(validatorApiChannel, validatorLogger, validatorDutyMetrics); } - @Test + @TestTemplate public void shouldFailWhenUnsignedAttestationCanNotBeCreated() { final Validator validator = createValidator(); when(validatorApiChannel.createAttestationData(SLOT, 0)) @@ -121,7 +133,7 @@ public void shouldFailWhenUnsignedAttestationCanNotBeCreated() { .record(any(), any(AttestationProductionDuty.class), eq(CREATE_TOTAL)); } - @Test + @TestTemplate public void shouldPublishProducedAttestationsWhenSomeUnsignedAttestationsCanNotBeCreated() { final Validator validator1 = createValidator(); final Validator validator2 = createValidator(); @@ -135,7 +147,11 @@ public void shouldPublishProducedAttestationsWhenSomeUnsignedAttestationsCanNotB final AttestationData attestationData = expectCreateAttestationData(validator2CommitteeIndex); final Attestation expectedAttestation = expectSignAttestation( - validator2, validator2CommitteePosition, validator2CommitteeSize, attestationData); + validator2, + validator2CommitteeIndex, + validator2CommitteePosition, + validator2CommitteeSize, + attestationData); final SafeFuture> attestationResult1 = duty.addValidator( @@ -170,7 +186,7 @@ public void shouldPublishProducedAttestationsWhenSomeUnsignedAttestationsCanNotB verify(validatorDutyMetrics).record(any(), any(AttestationProductionDuty.class), eq(SIGN)); } - @Test + @TestTemplate public void shouldPublishProducedAttestationsWhenSomeUnsignedAttestationsFail() { final Validator validator1 = createValidator(); final Validator validator2 = createValidator(); @@ -185,7 +201,11 @@ public void shouldPublishProducedAttestationsWhenSomeUnsignedAttestationsFail() final AttestationData attestationData = expectCreateAttestationData(validator2CommitteeIndex); final Attestation expectedAttestation = expectSignAttestation( - validator2, validator2CommitteePosition, validator2CommitteeSize, attestationData); + validator2, + validator2CommitteeIndex, + validator2CommitteePosition, + validator2CommitteeSize, + attestationData); final SafeFuture> attestationResult1 = duty.addValidator( @@ -218,7 +238,7 @@ public void shouldPublishProducedAttestationsWhenSomeUnsignedAttestationsFail() verify(validatorDutyMetrics).record(any(), any(AttestationProductionDuty.class), eq(SIGN)); } - @Test + @TestTemplate public void shouldPublishProducedAttestationsWhenSignerFailsForSomeAttestations() { final Validator validator1 = createValidator(); final Validator validator2 = createValidator(); @@ -233,7 +253,11 @@ public void shouldPublishProducedAttestationsWhenSignerFailsForSomeAttestations( .thenReturn(failedFuture(signingFailure)); final Attestation expectedAttestation = expectSignAttestation( - validator2, validator2CommitteePosition, validator2CommitteeSize, attestationData); + validator2, + committeeIndex, + validator2CommitteePosition, + validator2CommitteeSize, + attestationData); final SafeFuture> attestationResult1 = duty.addValidator( @@ -262,7 +286,7 @@ public void shouldPublishProducedAttestationsWhenSignerFailsForSomeAttestations( .record(any(), any(AttestationProductionDuty.class), eq(SIGN)); } - @Test + @TestTemplate public void shouldCreateAttestationForSingleValidator() { final int committeeIndex = 3; final int committeePosition = 6; @@ -271,7 +295,8 @@ public void shouldCreateAttestationForSingleValidator() { final AttestationData attestationData = expectCreateAttestationData(committeeIndex); final Attestation expectedAttestation = - expectSignAttestation(validator, committeePosition, committeeSize, attestationData); + expectSignAttestation( + validator, committeeIndex, committeePosition, committeeSize, attestationData); final SafeFuture> attestationResult = duty.addValidator(validator, committeeIndex, committeePosition, 10, committeeSize); @@ -289,7 +314,7 @@ public void shouldCreateAttestationForSingleValidator() { verify(validatorDutyMetrics).record(any(), any(AttestationProductionDuty.class), eq(SIGN)); } - @Test + @TestTemplate void shouldReportFailureWhenAttestationIsInvalid() { final int committeeIndex = 3; final int committeePosition = 6; @@ -298,7 +323,8 @@ void shouldReportFailureWhenAttestationIsInvalid() { final AttestationData attestationData = expectCreateAttestationData(committeeIndex); final Attestation expectedAttestation = - expectSignAttestation(validator, committeePosition, committeeSize, attestationData); + expectSignAttestation( + validator, committeeIndex, committeePosition, committeeSize, attestationData); when(validatorApiChannel.sendSignedAttestations(List.of(expectedAttestation))) .thenReturn( @@ -328,7 +354,7 @@ void shouldReportFailureWhenAttestationIsInvalid() { } @SuppressWarnings("unchecked") - @Test + @TestTemplate public void shouldCreateAttestationForMultipleValidatorsInSameCommittee() { final int committeeIndex = 3; final int committeeSize = 33; @@ -342,13 +368,25 @@ public void shouldCreateAttestationForMultipleValidatorsInSameCommittee() { final AttestationData attestationData = expectCreateAttestationData(committeeIndex); final Attestation expectedAttestation1 = expectSignAttestation( - validator1, validator1CommitteePosition, committeeSize, attestationData); + validator1, + committeeIndex, + validator1CommitteePosition, + committeeSize, + attestationData); final Attestation expectedAttestation2 = expectSignAttestation( - validator2, validator2CommitteePosition, committeeSize, attestationData); + validator2, + committeeIndex, + validator2CommitteePosition, + committeeSize, + attestationData); final Attestation expectedAttestation3 = expectSignAttestation( - validator3, validator3CommitteePosition, committeeSize, attestationData); + validator3, + committeeIndex, + validator3CommitteePosition, + committeeSize, + attestationData); final SafeFuture> attestationResult1 = duty.addValidator( @@ -384,10 +422,10 @@ public void shouldCreateAttestationForMultipleValidatorsInSameCommittee() { } @SuppressWarnings("unchecked") - @Test + @TestTemplate public void shouldCreateAttestationForMultipleValidatorsInDifferentCommittees() { final int committeeIndex1 = 3; - final int committeeIndex2 = 5; + final int committeeIndex2 = 1; final int committeeSize1 = 15; final int committeeSize2 = 20; final int validator1CommitteePosition = 6; @@ -401,13 +439,25 @@ public void shouldCreateAttestationForMultipleValidatorsInDifferentCommittees() final AttestationData unsignedAttestation2 = expectCreateAttestationData(committeeIndex2); final Attestation expectedAttestation1 = expectSignAttestation( - validator1, validator1CommitteePosition, committeeSize1, unsignedAttestation1); + validator1, + committeeIndex1, + validator1CommitteePosition, + committeeSize1, + unsignedAttestation1); final Attestation expectedAttestation2 = expectSignAttestation( - validator2, validator2CommitteePosition, committeeSize2, unsignedAttestation2); + validator2, + committeeIndex2, + validator2CommitteePosition, + committeeSize2, + unsignedAttestation2); final Attestation expectedAttestation3 = expectSignAttestation( - validator3, validator3CommitteePosition, committeeSize1, unsignedAttestation1); + validator3, + committeeIndex1, + validator3CommitteePosition, + committeeSize1, + unsignedAttestation1); final SafeFuture> attestationResult1 = duty.addValidator( @@ -449,40 +499,55 @@ public void shouldCreateAttestationForMultipleValidatorsInDifferentCommittees() .record(any(), any(AttestationProductionDuty.class), eq(SIGN)); } - public Validator createValidator() { + private Validator createValidator() { final Signer signer = mock(Signer.class); return new Validator( dataStructureUtil.randomPublicKey(), signer, new FileBackedGraffitiProvider()); } - public Attestation expectSignAttestation( + private Attestation expectSignAttestation( final Validator validator, + final int committeeIndex, final int committeePosition, final int committeeSize, final AttestationData attestationData) { final BLSSignature signature = dataStructureUtil.randomSignature(); when(validator.getSigner().signAttestationData(attestationData, fork)) .thenReturn(completedFuture(signature)); - return createExpectedAttestation(attestationData, committeePosition, committeeSize, signature); + + return createExpectedAttestation( + attestationData, committeeIndex, committeePosition, committeeSize, signature); } - public AttestationData expectCreateAttestationData(final int committeeIndex) { + private AttestationData expectCreateAttestationData(final int committeeIndex) { final AttestationData attestationData = dataStructureUtil.randomAttestationData(SLOT); when(validatorApiChannel.createAttestationData(SLOT, committeeIndex)) .thenReturn(completedFuture(Optional.of(attestationData))); return attestationData; } - public Attestation createExpectedAttestation( + private Attestation createExpectedAttestation( final AttestationData attestationData, + final int committeeIndex, final int committeePosition, final int committeeSize, final BLSSignature signature) { - final AttestationSchema attestationSchema = + final AttestationSchema attestationSchema = spec.atSlot(attestationData.getSlot()).getSchemaDefinitions().getAttestationSchema(); final SszBitlist expectedAggregationBits = attestationSchema.getAggregationBitsSchema().ofBits(committeeSize, committeePosition); - return attestationSchema.create(expectedAggregationBits, attestationData, signature); + + final Supplier committeeBits; + + if (spec.atSlot(attestationData.getSlot()).getMilestone().isGreaterThanOrEqualTo(ELECTRA)) { + committeeBits = + () -> attestationSchema.getCommitteeBitsSchema().orElseThrow().ofBits(committeeIndex); + } else { + committeeBits = () -> null; + } + + return attestationSchema.create( + expectedAggregationBits, attestationData, signature, committeeBits); } private void performAndReportDuty() { diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/duties/BlockProductionDutyTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/duties/BlockProductionDutyTest.java index 280816f0ebd..1e3c2edad06 100644 --- a/validator/client/src/test/java/tech/pegasys/teku/validator/client/duties/BlockProductionDutyTest.java +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/duties/BlockProductionDutyTest.java @@ -104,8 +104,6 @@ public void setUp() { forkProvider, validatorApiChannel, blockContainerSigner, - false, - false, spec, validatorDutyMetrics); when(forkProvider.getForkInfo(any())).thenReturn(completedFuture(fork)); @@ -121,8 +119,6 @@ public void shouldCreateAndPublishBlock(final boolean isBlindedBlocksEnabled) { forkProvider, validatorApiChannel, blockContainerSigner, - isBlindedBlocksEnabled, - false, spec, validatorDutyMetrics); final BLSSignature randaoReveal = dataStructureUtil.randomSignature(); @@ -141,21 +137,17 @@ public void shouldCreateAndPublishBlock(final boolean isBlindedBlocksEnabled) { when(signer.createRandaoReveal(spec.computeEpochAtSlot(CAPELLA_SLOT), fork)) .thenReturn(completedFuture(randaoReveal)); when(validatorApiChannel.createUnsignedBlock( - CAPELLA_SLOT, - randaoReveal, - Optional.of(graffiti), - Optional.of(isBlindedBlocksEnabled), - Optional.empty())) + CAPELLA_SLOT, randaoReveal, Optional.of(graffiti), Optional.empty())) .thenReturn(completedFuture(Optional.of(blockContainerAndMetaData))); when(signer.signBlock(unsignedBlock, fork)).thenReturn(completedFuture(blockSignature)); final SignedBeaconBlock signedBlock = dataStructureUtil.signedBlock(unsignedBlock, blockSignature); - when(validatorApiChannel.sendSignedBlock(signedBlock, BroadcastValidationLevel.NOT_REQUIRED)) + when(validatorApiChannel.sendSignedBlock(signedBlock, BroadcastValidationLevel.GOSSIP)) .thenReturn(completedFuture(SendSignedBlockResult.success(signedBlock.getRoot()))); performAndReportDuty(); - verify(validatorApiChannel).sendSignedBlock(signedBlock, BroadcastValidationLevel.NOT_REQUIRED); + verify(validatorApiChannel).sendSignedBlock(signedBlock, BroadcastValidationLevel.GOSSIP); verify(validatorLogger) .dutyCompleted( eq(TYPE), @@ -182,8 +174,6 @@ public void forDeneb_shouldCreateAndPublishBlockContents() { forkProvider, validatorApiChannel, blockContainerSigner, - false, - false, spec, validatorDutyMetrics); @@ -203,7 +193,7 @@ public void forDeneb_shouldCreateAndPublishBlockContents() { when(signer.signBlock(unsignedBlockContents.getBlock(), fork)) .thenReturn(completedFuture(blockSignature)); when(validatorApiChannel.createUnsignedBlock( - denebSlot, randaoReveal, Optional.of(graffiti), Optional.of(false), Optional.empty())) + denebSlot, randaoReveal, Optional.of(graffiti), Optional.empty())) .thenReturn(completedFuture(Optional.of(blockContainerAndMetaData))); when(validatorApiChannel.sendSignedBlock(any(), any())) .thenReturn(completedFuture(SendSignedBlockResult.success(unsignedBlock.getRoot()))); @@ -271,8 +261,6 @@ public void forDeneb_shouldCreateAndPublishBlindedBlock() { forkProvider, validatorApiChannel, blockContainerSigner, - true, - false, spec, validatorDutyMetrics); @@ -287,7 +275,7 @@ public void forDeneb_shouldCreateAndPublishBlindedBlock() { when(signer.signBlock(unsignedBlindedBlock.getBlock(), fork)) .thenReturn(completedFuture(blockSignature)); when(validatorApiChannel.createUnsignedBlock( - denebSlot, randaoReveal, Optional.of(graffiti), Optional.of(true), Optional.empty())) + denebSlot, randaoReveal, Optional.of(graffiti), Optional.empty())) .thenReturn(completedFuture(Optional.of(blockContainerAndMetaData))); when(validatorApiChannel.sendSignedBlock(any(), any())) .thenReturn(completedFuture(SendSignedBlockResult.success(unsignedBlindedBlock.getRoot()))); @@ -336,8 +324,6 @@ public void forDeneb_shouldFailWhenNoKzgProofs() { forkProvider, validatorApiChannel, blockContainerSigner, - false, - false, spec, validatorDutyMetrics); @@ -358,7 +344,7 @@ public void forDeneb_shouldFailWhenNoKzgProofs() { when(signer.signBlock(unsignedBlockContentsMock.getBlock(), fork)) .thenReturn(completedFuture(blockSignature)); when(validatorApiChannel.createUnsignedBlock( - denebSlot, randaoReveal, Optional.of(graffiti), Optional.of(false), Optional.empty())) + denebSlot, randaoReveal, Optional.of(graffiti), Optional.empty())) .thenReturn(completedFuture(Optional.of(blockContainerAndMetaData))); when(validatorApiChannel.sendSignedBlock(any(), any())) .thenReturn(completedFuture(SendSignedBlockResult.success(blockRoot))); @@ -381,8 +367,6 @@ public void forDeneb_shouldFailWhenNoBlobs() { forkProvider, validatorApiChannel, blockContainerSigner, - false, - false, spec, validatorDutyMetrics); @@ -404,7 +388,7 @@ public void forDeneb_shouldFailWhenNoBlobs() { when(signer.signBlock(unsignedBlockContentsMock.getBlock(), fork)) .thenReturn(completedFuture(blockSignature)); when(validatorApiChannel.createUnsignedBlock( - denebSlot, randaoReveal, Optional.of(graffiti), Optional.of(false), Optional.empty())) + denebSlot, randaoReveal, Optional.of(graffiti), Optional.empty())) .thenReturn(completedFuture(Optional.of(blockContainerAndMetaData))); when(validatorApiChannel.sendSignedBlock(any(), any())) .thenReturn(completedFuture(SendSignedBlockResult.success(blockRoot))); @@ -448,8 +432,8 @@ public void denebBlockSummary() { final BeaconBlockBody block = dataStructureUtil.randomBeaconBlockBody(denebSlot); assertThat(duty.getBlockSummary(block)) .containsExactly( - "Blobs: 1", - "4483248126065046120 (0%) gas, EL block: b736203ee72088edaf7eb5c7839744f5b1be69f748eea8fea77740914415c5b4 (4479943159631677864)"); + "Blobs: 5", + "4491510546443434056 (0%) gas, EL block: 58913d3ec8a62b95e52fb1ee60ebddf392af6e1db902dd5bc3f1eea7003130ff (4488205580010065800)"); } @Test @@ -459,11 +443,7 @@ public void shouldFailWhenCreateUnsignedBlockFails() { when(signer.createRandaoReveal(spec.computeEpochAtSlot(CAPELLA_SLOT), fork)) .thenReturn(completedFuture(randaoReveal)); when(validatorApiChannel.createUnsignedBlock( - CAPELLA_SLOT, - randaoReveal, - Optional.of(graffiti), - Optional.of(false), - Optional.empty())) + CAPELLA_SLOT, randaoReveal, Optional.of(graffiti), Optional.empty())) .thenReturn(failedFuture(error)); assertDutyFails(error); @@ -479,11 +459,7 @@ public void shouldFailWhenCreateUnsignedBlockReturnsEmpty() { when(signer.createRandaoReveal(spec.computeEpochAtSlot(CAPELLA_SLOT), fork)) .thenReturn(completedFuture(randaoReveal)); when(validatorApiChannel.createUnsignedBlock( - CAPELLA_SLOT, - randaoReveal, - Optional.of(graffiti), - Optional.of(false), - Optional.empty())) + CAPELLA_SLOT, randaoReveal, Optional.of(graffiti), Optional.empty())) .thenReturn(completedFuture(Optional.empty())); performAndReportDuty(); @@ -510,11 +486,7 @@ public void shouldFailWhenSigningBlockFails() { when(signer.createRandaoReveal(spec.computeEpochAtSlot(CAPELLA_SLOT), fork)) .thenReturn(completedFuture(randaoReveal)); when(validatorApiChannel.createUnsignedBlock( - CAPELLA_SLOT, - randaoReveal, - Optional.of(graffiti), - Optional.of(false), - Optional.empty())) + CAPELLA_SLOT, randaoReveal, Optional.of(graffiti), Optional.empty())) .thenReturn(completedFuture(Optional.of(blockContainerAndMetaData))); when(signer.signBlock(blockContainerAndMetaData.blockContainer().getBlock(), fork)) .thenReturn(failedFuture(error)); @@ -538,8 +510,6 @@ public void shouldUseBlockV3ToCreateAndPublishBlock(final boolean isBlindedBlock forkProvider, validatorApiChannel, blockContainerSigner, - isBlindedBlocksEnabled, - true, spec, validatorDutyMetrics); final BLSSignature randaoReveal = dataStructureUtil.randomSignature(); @@ -556,22 +526,21 @@ public void shouldUseBlockV3ToCreateAndPublishBlock(final boolean isBlindedBlock when(signer.createRandaoReveal(spec.computeEpochAtSlot(CAPELLA_SLOT), fork)) .thenReturn(completedFuture(randaoReveal)); when(validatorApiChannel.createUnsignedBlock( - CAPELLA_SLOT, randaoReveal, Optional.of(graffiti), Optional.empty(), Optional.empty())) + CAPELLA_SLOT, randaoReveal, Optional.of(graffiti), Optional.empty())) .thenReturn(completedFuture(Optional.of(blockContainerAndMetaData))); when(signer.signBlock(blockContainerAndMetaData.blockContainer().getBlock(), fork)) .thenReturn(completedFuture(blockSignature)); final SignedBeaconBlock signedBlock = dataStructureUtil.signedBlock( blockContainerAndMetaData.blockContainer().getBlock(), blockSignature); - when(validatorApiChannel.sendSignedBlock(signedBlock, BroadcastValidationLevel.NOT_REQUIRED)) + when(validatorApiChannel.sendSignedBlock(signedBlock, BroadcastValidationLevel.GOSSIP)) .thenReturn(completedFuture(SendSignedBlockResult.success(signedBlock.getRoot()))); performAndReportDuty(); verify(validatorApiChannel) - .createUnsignedBlock( - CAPELLA_SLOT, randaoReveal, Optional.of(graffiti), Optional.empty(), Optional.empty()); + .createUnsignedBlock(CAPELLA_SLOT, randaoReveal, Optional.of(graffiti), Optional.empty()); - verify(validatorApiChannel).sendSignedBlock(signedBlock, BroadcastValidationLevel.NOT_REQUIRED); + verify(validatorApiChannel).sendSignedBlock(signedBlock, BroadcastValidationLevel.GOSSIP); verify(validatorLogger) .dutyCompleted( eq(TYPE), @@ -598,8 +567,6 @@ public void forDeneb_shouldUseBlockV3ToCreateAndPublishBlockContents() { forkProvider, validatorApiChannel, blockContainerSigner, - false, - true, spec, validatorDutyMetrics); @@ -620,7 +587,7 @@ public void forDeneb_shouldUseBlockV3ToCreateAndPublishBlockContents() { when(signer.signBlock(unsignedBlockContents.getBlock(), fork)) .thenReturn(completedFuture(blockSignature)); when(validatorApiChannel.createUnsignedBlock( - denebSlot, randaoReveal, Optional.of(graffiti), Optional.empty(), Optional.empty())) + denebSlot, randaoReveal, Optional.of(graffiti), Optional.empty())) .thenReturn(completedFuture(Optional.of(blockContainerAndMetaData))); when(validatorApiChannel.sendSignedBlock(any(), any())) .thenReturn(completedFuture(SendSignedBlockResult.success(unsignedBlock.getRoot()))); @@ -628,15 +595,14 @@ public void forDeneb_shouldUseBlockV3ToCreateAndPublishBlockContents() { performAndReportDuty(denebSlot); verify(validatorApiChannel) - .createUnsignedBlock( - denebSlot, randaoReveal, Optional.of(graffiti), Optional.empty(), Optional.empty()); + .createUnsignedBlock(denebSlot, randaoReveal, Optional.of(graffiti), Optional.empty()); final ArgumentCaptor signedBlockContentsArgumentCaptor = ArgumentCaptor.forClass(SignedBlockContents.class); verify(validatorApiChannel) .sendSignedBlock( - signedBlockContentsArgumentCaptor.capture(), eq(BroadcastValidationLevel.NOT_REQUIRED)); + signedBlockContentsArgumentCaptor.capture(), eq(BroadcastValidationLevel.GOSSIP)); verify(validatorLogger) .dutyCompleted( eq(TYPE), diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/duties/ChainHeadTrackerTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/duties/ChainHeadTrackerTest.java index 3b9167d00b3..e6df0afc591 100644 --- a/validator/client/src/test/java/tech/pegasys/teku/validator/client/duties/ChainHeadTrackerTest.java +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/duties/ChainHeadTrackerTest.java @@ -15,6 +15,7 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertThrows; +import static tech.pegasys.teku.validator.client.duties.synccommittee.ChainHeadTracker.HEAD_TOO_OLD_THRESHOLD; import org.apache.tuweni.bytes.Bytes32; import org.junit.jupiter.api.Test; @@ -22,6 +23,7 @@ import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.util.DataStructureUtil; import tech.pegasys.teku.validator.client.duties.synccommittee.ChainHeadBeyondSlotException; +import tech.pegasys.teku.validator.client.duties.synccommittee.ChainHeadTooOldException; import tech.pegasys.teku.validator.client.duties.synccommittee.ChainHeadTracker; class ChainHeadTrackerTest { @@ -60,6 +62,17 @@ void shouldThrowCustomExceptionWhenHeadIsAfterRequestedSlot() { ChainHeadBeyondSlotException.class, () -> tracker.getCurrentChainHead(slot.minus(1))); } + @Test + void shouldThrowCustomExceptionWhenHeadSlotIsTooOld() { + final UInt64 slot = dataStructureUtil.randomUInt64(); + final Bytes32 headBlockRoot = dataStructureUtil.randomBytes32(); + updateHead(slot, headBlockRoot); + + assertThrows( + ChainHeadTooOldException.class, + () -> tracker.getCurrentChainHead(slot.plus(HEAD_TOO_OLD_THRESHOLD + 1))); + } + private void updateHead(final UInt64 slot, final Bytes32 headBlockRoot) { tracker.onHeadUpdate( slot, dataStructureUtil.randomBytes32(), dataStructureUtil.randomBytes32(), headBlockRoot); diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/duties/synccommittee/SyncCommitteeAggregationDutyTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/duties/synccommittee/SyncCommitteeAggregationDutyTest.java index 45cca3f8b14..0be37fd10e5 100644 --- a/validator/client/src/test/java/tech/pegasys/teku/validator/client/duties/synccommittee/SyncCommitteeAggregationDutyTest.java +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/duties/synccommittee/SyncCommitteeAggregationDutyTest.java @@ -43,6 +43,7 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.config.SpecConfig; +import tech.pegasys.teku.spec.config.SpecConfigAndParent; import tech.pegasys.teku.spec.config.SpecConfigLoader; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.ContributionAndProof; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SignedContributionAndProof; @@ -104,15 +105,13 @@ void setUp() { assertThat(syncCommitteeUtil.isSyncCommitteeAggregator(aggregatorSignature)).isTrue(); } - private static SpecConfig createSpecConfig() { + private static SpecConfigAndParent createSpecConfig() { return SpecConfigLoader.loadConfig( - "minimal", - modifier -> - modifier.altairBuilder( - altairModifier -> - altairModifier.altairForkEpoch(UInt64.ZERO).syncCommitteeSize(512))) - .toVersionAltair() - .orElseThrow(); + "minimal", + modifier -> + modifier.altairBuilder( + altairModifier -> + altairModifier.altairForkEpoch(UInt64.ZERO).syncCommitteeSize(512))); } @Test diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/duties/synccommittee/SyncCommitteeScheduledDutiesTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/duties/synccommittee/SyncCommitteeScheduledDutiesTest.java index 23cbddc5773..536901e89f8 100644 --- a/validator/client/src/test/java/tech/pegasys/teku/validator/client/duties/synccommittee/SyncCommitteeScheduledDutiesTest.java +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/duties/synccommittee/SyncCommitteeScheduledDutiesTest.java @@ -32,6 +32,7 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.EnumSource; +import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.logging.ValidatorLogger; import tech.pegasys.teku.infrastructure.unsigned.UInt64; @@ -39,7 +40,6 @@ import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.signatures.Signer; import tech.pegasys.teku.spec.util.DataStructureUtil; -import tech.pegasys.teku.validator.api.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.validator.api.ValidatorApiChannel; import tech.pegasys.teku.validator.client.ForkProvider; import tech.pegasys.teku.validator.client.Validator; diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/loader/ExternalValidatorSourceTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/loader/ExternalValidatorSourceTest.java index c42dff867e3..949802f002b 100644 --- a/validator/client/src/test/java/tech/pegasys/teku/validator/client/loader/ExternalValidatorSourceTest.java +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/loader/ExternalValidatorSourceTest.java @@ -78,7 +78,7 @@ public class ExternalValidatorSourceTest { public ExternalValidatorSourceTest() {} @BeforeEach - void setup(@TempDir Path tempDir) throws IOException, InterruptedException { + void setup(@TempDir final Path tempDir) throws IOException, InterruptedException { config = ValidatorConfig.builder() .validatorExternalSignerUrl(new URL("http://localhost:9000")) @@ -110,7 +110,7 @@ void shouldReturnErrorWhenDeleteReadOnlyValidator() { } @Test - void shouldDeleteValidator(@TempDir Path tempDir) throws IOException { + void shouldDeleteValidator(@TempDir final Path tempDir) throws IOException { final BLSPublicKey publicKey = dataStructureUtil.randomPublicKey(); final ExternalValidatorSource externalValidatorSource = newExternalValidatorSource(tempDir, false); @@ -131,7 +131,7 @@ void shouldDeleteValidator(@TempDir Path tempDir) throws IOException { } @Test - void shouldReturnErrorWhenDeleteNonExistentValidator(@TempDir Path tempDir) { + void shouldReturnErrorWhenDeleteNonExistentValidator(@TempDir final Path tempDir) { final BLSPublicKey publicKey = dataStructureUtil.randomPublicKey(); final ExternalValidatorSource externalValidatorSource = newExternalValidatorSource(tempDir, false); @@ -152,7 +152,8 @@ void shouldSayFalseToAddValidators() { } @Test - void addValidator_shouldGetConfigUrlWhenNotProvided(@TempDir Path tempDir) throws IOException { + void addValidator_shouldGetConfigUrlWhenNotProvided(@TempDir final Path tempDir) + throws IOException { final BLSPublicKey publicKey = dataStructureUtil.randomPublicKey(); final ExternalValidatorSource externalValidatorSource = newExternalValidatorSource(tempDir, false); @@ -164,7 +165,7 @@ void addValidator_shouldGetConfigUrlWhenNotProvided(@TempDir Path tempDir) throw } @Test - void addValidator_shouldGetUrlIfProvided(@TempDir Path tempDir) throws IOException { + void addValidator_shouldGetUrlIfProvided(@TempDir final Path tempDir) throws IOException { final BLSPublicKey publicKey = dataStructureUtil.randomPublicKey(); final URL url = new URL("http://host.com"); @@ -179,7 +180,7 @@ void addValidator_shouldGetUrlIfProvided(@TempDir Path tempDir) throws IOExcepti } @Test - void addValidator_shouldDetectDuplicate(@TempDir Path tempDir) throws IOException { + void addValidator_shouldDetectDuplicate(@TempDir final Path tempDir) throws IOException { final BLSPublicKey publicKey = dataStructureUtil.randomPublicKey(); final ExternalValidatorSource externalValidatorSource = @@ -197,7 +198,7 @@ void addValidator_shouldDetectDuplicate(@TempDir Path tempDir) throws IOExceptio } @Test - void shouldLoadExternalValidators(@TempDir Path tempDir) throws IOException { + void shouldLoadExternalValidators(@TempDir final Path tempDir) throws IOException { final DataDirLayout dataDirLayout = new SimpleDataDirLayout(tempDir); final ExternalValidatorSource externalValidatorSource = newExternalValidatorSource(tempDir, false); @@ -229,7 +230,7 @@ void shouldLoadExternalValidators(@TempDir Path tempDir) throws IOException { } @Test - void shouldGetAvailableReadOnlyValidators(@TempDir Path tempDir) throws IOException { + void shouldGetAvailableReadOnlyValidators(@TempDir final Path tempDir) throws IOException { final BLSPublicKey publicKey1 = dataStructureUtil.randomPublicKey(); final BLSPublicKey publicKey2 = dataStructureUtil.randomPublicKey(); when(publicKeyLoader.getPublicKeys(any())).thenReturn(List.of(publicKey1, publicKey2)); @@ -257,7 +258,8 @@ void shouldGetAvailableReadOnlyValidators(@TempDir Path tempDir) throws IOExcept } private void createRemoteKeyFile( - DataDirLayout dataDirLayout, BLSPublicKey publicKey, Optional url) throws IOException { + final DataDirLayout dataDirLayout, final BLSPublicKey publicKey, final Optional url) + throws IOException { final String urlContent = url.map(value -> ",\"url\":\"" + value + "\"").orElse(""); final String content = "{\"pubkey\":\"" + publicKey + "\"" + urlContent + "}"; @@ -269,7 +271,8 @@ private void createRemoteKeyFile( Files.writeString(tempFile, content, StandardCharsets.UTF_8); } - private void assertFileContent(Path tempDir, BLSPublicKey publicKey, String expectedContent) + private void assertFileContent( + final Path tempDir, final BLSPublicKey publicKey, final String expectedContent) throws IOException { final String fileName = publicKey.toBytesCompressed().toUnprefixedHexString() + ".json"; final Path path = @@ -279,7 +282,7 @@ private void assertFileContent(Path tempDir, BLSPublicKey publicKey, String expe assertThat(Files.readString(path, Charsets.UTF_8)).isEqualTo(expectedContent); } - private void assertImportedSuccessfully(AddValidatorResult result, URL expectedUrl) { + private void assertImportedSuccessfully(final AddValidatorResult result, final URL expectedUrl) { assertThat(result.getResult().getImportStatus()).isEqualTo(ImportStatus.IMPORTED); assertThat(result.getSigner()).isNotEmpty(); assertThat(result.getSigner().get().getSigningServiceUrl()).isNotEmpty(); @@ -304,13 +307,13 @@ static class ValidatorProviderInfo { private final BLSPublicKey publicKey; private final URL url; - ValidatorProviderInfo(BLSPublicKey publicKey, URL url) { + ValidatorProviderInfo(final BLSPublicKey publicKey, final URL url) { this.publicKey = publicKey; this.url = url; } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/loader/LocalValidatorSourceTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/loader/LocalValidatorSourceTest.java index 3e4b64050f3..af4b75f244e 100644 --- a/validator/client/src/test/java/tech/pegasys/teku/validator/client/loader/LocalValidatorSourceTest.java +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/loader/LocalValidatorSourceTest.java @@ -216,7 +216,7 @@ void shouldRejectAddingValidatorIfReadOnlySource() { } @Test - void shouldAddValidatorIfNotReadOnlySource(@TempDir Path tempDir) throws IOException { + void shouldAddValidatorIfNotReadOnlySource(@TempDir final Path tempDir) throws IOException { final AddValidatorResult result = getResultFromAddingValidator( tempDir, "pbkdf2TestVector.json", EXPECTED_PASSWORD, PBKDF2_PUBKEY); @@ -225,7 +225,7 @@ void shouldAddValidatorIfNotReadOnlySource(@TempDir Path tempDir) throws IOExcep } @Test - void shouldDetectDuplicatesOnAddValidator(@TempDir Path tempDir) throws IOException { + void shouldDetectDuplicatesOnAddValidator(@TempDir final Path tempDir) throws IOException { final AddValidatorResult result = getResultFromAddingValidator( tempDir, "pbkdf2TestVector.json", EXPECTED_PASSWORD, PBKDF2_PUBKEY); @@ -239,7 +239,8 @@ void shouldDetectDuplicatesOnAddValidator(@TempDir Path tempDir) throws IOExcept } @Test - void shouldErrorIfPasswordIsIncorrectOnAddValidator(@TempDir Path tempDir) throws IOException { + void shouldErrorIfPasswordIsIncorrectOnAddValidator(@TempDir final Path tempDir) + throws IOException { final AddValidatorResult result = getResultFromAddingValidator( tempDir, "pbkdf2TestVector.json", "zz", dataStructureUtil.randomPublicKey()); diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/loader/SlashingProtectionLoggerTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/loader/SlashingProtectionLoggerTest.java index b54a4f6eecc..52ab56f03ed 100644 --- a/validator/client/src/test/java/tech/pegasys/teku/validator/client/loader/SlashingProtectionLoggerTest.java +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/loader/SlashingProtectionLoggerTest.java @@ -101,7 +101,9 @@ public void shouldLogLoadedProtectionValidator() throws Exception { List protectedValidators = new ArrayList<>(); protectedValidators.add(validator); when(slashingProtector.getSigningRecord(validator.getPublicKey())) - .thenReturn(Optional.of(new ValidatorSigningRecord(Bytes32.ZERO, UInt64.ZERO, null, null))); + .thenReturn( + Optional.of( + new ValidatorSigningRecord(Optional.of(Bytes32.ZERO), UInt64.ZERO, null, null))); slashingProtectionLogger.protectionSummary(protectedValidators); asyncRunner.executeQueuedActions(); Set protectedValidatorKeys = new HashSet<>(); @@ -117,7 +119,9 @@ public void shouldLogLoadedButOutdatedProtectionValidator() throws Exception { List protectedValidators = new ArrayList<>(); protectedValidators.add(validator); when(slashingProtector.getSigningRecord(validator.getPublicKey())) - .thenReturn(Optional.of(new ValidatorSigningRecord(Bytes32.ZERO, UInt64.ZERO, null, null))); + .thenReturn( + Optional.of( + new ValidatorSigningRecord(Optional.of(Bytes32.ZERO), UInt64.ZERO, null, null))); slashingProtectionLogger.onSlot(spec.computeStartSlotAtEpoch(UInt64.valueOf(1000))); slashingProtectionLogger.protectionSummary(protectedValidators); asyncRunner.executeQueuedActions(); @@ -135,7 +139,10 @@ public void shouldNotLogObsoleteProtectionForValidatorWithNoBlockRecord() throws .thenReturn( Optional.of( new ValidatorSigningRecord( - Bytes32.ZERO, UInt64.ZERO, UInt64.valueOf(900), UInt64.valueOf(950)))); + Optional.of(Bytes32.ZERO), + UInt64.ZERO, + UInt64.valueOf(900), + UInt64.valueOf(950)))); List validators = List.of(validator); slashingProtectionLogger.onSlot(spec.computeStartSlotAtEpoch(UInt64.valueOf(1000))); @@ -148,13 +155,13 @@ public void shouldNotLogObsoleteProtectionForValidatorWithNoBlockRecord() throws verify(validatorLogger, never()).outdatedSlashingProtection(any(), any()); } - private Validator createProtectedValidator(BLSPublicKey publicKey) { + private Validator createProtectedValidator(final BLSPublicKey publicKey) { Signer localSigner = new NoOpLocalSigner(); Signer signer = new SlashingProtectedSigner(publicKey, slashingProtector, localSigner); return new Validator(publicKey, signer, mock(GraffitiProvider.class)); } - private Validator createUnProtectedValidator(BLSPublicKey publicKey) { + private Validator createUnProtectedValidator(final BLSPublicKey publicKey) { ExternalSigner externalSigner; try { externalSigner = diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/loader/ValidatorLoaderTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/loader/ValidatorLoaderTest.java index 66202273483..a3cc59adfa4 100644 --- a/validator/client/src/test/java/tech/pegasys/teku/validator/client/loader/ValidatorLoaderTest.java +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/loader/ValidatorLoaderTest.java @@ -36,6 +36,7 @@ import java.util.List; import java.util.Optional; import java.util.function.Supplier; +import java.util.stream.Stream; import org.apache.tuweni.bytes.Bytes; import org.hyperledger.besu.plugin.services.MetricsSystem; import org.junit.jupiter.api.BeforeEach; @@ -58,7 +59,10 @@ import tech.pegasys.teku.spec.signatures.DeletableSigner; import tech.pegasys.teku.spec.signatures.SlashingProtector; import tech.pegasys.teku.spec.util.DataStructureUtil; +import tech.pegasys.teku.validator.api.FileBackedGraffitiProvider; +import tech.pegasys.teku.validator.api.GraffitiProvider; import tech.pegasys.teku.validator.api.InteropConfig; +import tech.pegasys.teku.validator.api.UpdatableGraffitiProvider; import tech.pegasys.teku.validator.api.ValidatorConfig; import tech.pegasys.teku.validator.client.LocalValidatorImportResult; import tech.pegasys.teku.validator.client.Validator; @@ -139,7 +143,8 @@ void shouldLoadPublicKeysFromUrls() { publicKeyLoader, asyncRunner, metricsSystem, - Optional.empty()); + Optional.empty(), + (publicKey) -> Optional.empty()); validatorLoader.loadValidators(); final OwnedValidators validators = validatorLoader.getOwnedValidators(); @@ -155,6 +160,7 @@ void shouldLoadPublicKeysFromUrls() { assertThat(validator2).isNotNull(); assertThat(validator2.getPublicKey()).isEqualTo(PUBLIC_KEY2); assertThat(validator2.getSigner().isLocal()).isFalse(); + checkGraffitiProviderTypes(validators.getValidators(), FileBackedGraffitiProvider.class); } @Test @@ -177,7 +183,8 @@ void initializeValidatorsWithExternalSignerAndSlashingProtection() { publicKeyLoader, asyncRunner, metricsSystem, - Optional.empty()); + Optional.empty(), + (publicKey) -> Optional.empty()); validatorLoader.loadValidators(); final OwnedValidators validators = validatorLoader.getOwnedValidators(); @@ -199,6 +206,7 @@ void initializeValidatorsWithExternalSignerAndSlashingProtection() { assertThat(result).isNotDone(); verify(slashingProtector) .maySignBlock(PUBLIC_KEY1, forkInfo.getGenesisValidatorsRoot(), block.getSlot()); + assertThat(validator.getGraffitiProvider()).isInstanceOf(FileBackedGraffitiProvider.class); } @Test @@ -221,7 +229,8 @@ void initializeValidatorsWithExternalSignerAndNoSlashingProtection() { publicKeyLoader, asyncRunner, metricsSystem, - Optional.empty()); + Optional.empty(), + (publicKey) -> Optional.empty()); validatorLoader.loadValidators(); final OwnedValidators validators = validatorLoader.getOwnedValidators(); @@ -243,10 +252,12 @@ void initializeValidatorsWithExternalSignerAndNoSlashingProtection() { // Confirm request was sent without checking with the slashing protector verifyNoInteractions(slashingProtector); verify(httpClient).sendAsync(any(), any()); + assertThat(validator.getGraffitiProvider()).isInstanceOf(FileBackedGraffitiProvider.class); } @Test - void initializeValidatorsWithBothLocalAndExternalSigners(@TempDir Path tempDir) throws Exception { + void initializeValidatorsWithBothLocalAndExternalSigners(@TempDir final Path tempDir) + throws Exception { writeKeystore(tempDir); final ValidatorConfig config = ValidatorConfig.builder() @@ -267,7 +278,8 @@ void initializeValidatorsWithBothLocalAndExternalSigners(@TempDir Path tempDir) publicKeyLoader, asyncRunner, metricsSystem, - Optional.empty()); + Optional.empty(), + (publicKey) -> Optional.empty()); validatorLoader.loadValidators(); final OwnedValidators validators = validatorLoader.getOwnedValidators(); @@ -283,11 +295,12 @@ void initializeValidatorsWithBothLocalAndExternalSigners(@TempDir Path tempDir) assertThat(validator2).isNotNull(); assertThat(validator2.getPublicKey()).isEqualTo(PUBLIC_KEY2); assertThat(validator2.getSigner().isLocal()).isFalse(); + checkGraffitiProviderTypes(validators.getValidators(), FileBackedGraffitiProvider.class); } @Test void shouldInitializeLocalAndMutableValidators( - @TempDir Path tempDir, @TempDir Path tempDirMutable) throws Exception { + @TempDir final Path tempDir, @TempDir final Path tempDirMutable) throws Exception { final BLSPublicKey mutableValidatorPubKey = BLSPublicKey.fromSSZBytes( Bytes.fromHexString( @@ -312,7 +325,8 @@ void shouldInitializeLocalAndMutableValidators( publicKeyLoader, asyncRunner, metricsSystem, - Optional.of(dataDirLayout)); + Optional.of(dataDirLayout), + (publicKey) -> Optional.empty()); validatorLoader.loadValidators(); final OwnedValidators validators = validatorLoader.getOwnedValidators(); @@ -328,10 +342,11 @@ void shouldInitializeLocalAndMutableValidators( assertThat(validator2).isNotNull(); assertThat(validator2.getPublicKey()).isEqualTo(mutableValidatorPubKey); assertThat(validator2.isReadOnly()).isFalse(); + checkGraffitiProviderTypes(validators.getValidators(), UpdatableGraffitiProvider.class); } @Test - void shouldReturnErrorIfDeleteOnReadOnlySource(@TempDir Path tempDir) throws Exception { + void shouldReturnErrorIfDeleteOnReadOnlySource(@TempDir final Path tempDir) throws Exception { writeKeystore(tempDir); final ValidatorConfig config = @@ -350,7 +365,8 @@ void shouldReturnErrorIfDeleteOnReadOnlySource(@TempDir Path tempDir) throws Exc publicKeyLoader, asyncRunner, metricsSystem, - Optional.empty()); + Optional.empty(), + (publicKey) -> Optional.empty()); final DeleteKeyResult result = validatorLoader.deleteLocalMutableValidator(dataStructureUtil.randomPublicKey()); @@ -360,7 +376,7 @@ void shouldReturnErrorIfDeleteOnReadOnlySource(@TempDir Path tempDir) throws Exc @Test void shouldInitializeOnlyLocalValidatorsWhenRestDisabled( - @TempDir Path tempDir, @TempDir Path tempDirMutable) throws Exception { + @TempDir final Path tempDir, @TempDir final Path tempDirMutable) throws Exception { final DataDirLayout dataDirLayout = new SimpleDataDirLayout(tempDirMutable); writeKeystore(tempDir); writeMutableKeystore(dataDirLayout); @@ -380,7 +396,8 @@ void shouldInitializeOnlyLocalValidatorsWhenRestDisabled( publicKeyLoader, asyncRunner, metricsSystem, - Optional.empty()); + Optional.empty(), + (publicKey) -> Optional.empty()); validatorLoader.loadValidators(); final OwnedValidators validators = validatorLoader.getOwnedValidators(); @@ -391,6 +408,7 @@ void shouldInitializeOnlyLocalValidatorsWhenRestDisabled( assertThat(validator1).isNotNull(); assertThat(validator1.getPublicKey()).isEqualTo(PUBLIC_KEY1); assertThat(validator1.isReadOnly()).isTrue(); + assertThat(validator1.getGraffitiProvider()).isInstanceOf(FileBackedGraffitiProvider.class); } @Test @@ -414,7 +432,7 @@ void shouldCallMutableValidatorSourceToDelete(@TempDir final Path tempDir) { @Test void shouldNotInitializeMutableValidatorsWithoutDirectoryStructure( - @TempDir Path tempDir, @TempDir Path tempDirMutable) throws Exception { + @TempDir final Path tempDir, @TempDir final Path tempDirMutable) throws Exception { final DataDirLayout dataDirLayout = new SimpleDataDirLayout(tempDirMutable); writeKeystore(tempDir); @@ -434,7 +452,8 @@ void shouldNotInitializeMutableValidatorsWithoutDirectoryStructure( publicKeyLoader, asyncRunner, metricsSystem, - Optional.of(dataDirLayout)); + Optional.of(dataDirLayout), + (publicKey) -> Optional.empty()); validatorLoader.loadValidators(); final OwnedValidators validators = validatorLoader.getOwnedValidators(); @@ -445,11 +464,12 @@ void shouldNotInitializeMutableValidatorsWithoutDirectoryStructure( assertThat(validator1).isNotNull(); assertThat(validator1.getPublicKey()).isEqualTo(PUBLIC_KEY1); assertThat(validator1.isReadOnly()).isTrue(); + assertThat(validator1.getGraffitiProvider()).isInstanceOf(UpdatableGraffitiProvider.class); } @Test void initializeValidatorsWithDuplicateKeysInLocalAndExternalSignersTakesExternalAsPriority( - @TempDir Path tempDir) throws Exception { + @TempDir final Path tempDir) throws Exception { writeKeystore(tempDir); final ValidatorConfig config = ValidatorConfig.builder() @@ -470,7 +490,8 @@ void initializeValidatorsWithDuplicateKeysInLocalAndExternalSignersTakesExternal publicKeyLoader, asyncRunner, metricsSystem, - Optional.empty()); + Optional.empty(), + (publicKey) -> Optional.empty()); validatorLoader.loadValidators(); final OwnedValidators validators = validatorLoader.getOwnedValidators(); @@ -483,10 +504,12 @@ void initializeValidatorsWithDuplicateKeysInLocalAndExternalSignersTakesExternal assertThat(validator).isNotNull(); assertThat(validator.getPublicKey()).isEqualTo(PUBLIC_KEY1); assertThat(validator.getSigner().isLocal()).isFalse(); + assertThat(validator.getGraffitiProvider()).isInstanceOf(FileBackedGraffitiProvider.class); } @Test - void shouldEnableSlashingProtectionForLocalValidators(@TempDir Path tempDir) throws Exception { + void shouldEnableSlashingProtectionForLocalValidators(@TempDir final Path tempDir) + throws Exception { writeKeystore(tempDir); final ValidatorConfig config = @@ -505,7 +528,8 @@ void shouldEnableSlashingProtectionForLocalValidators(@TempDir Path tempDir) thr publicKeyLoader, asyncRunner, metricsSystem, - Optional.empty()); + Optional.empty(), + (publicKey) -> Optional.empty()); validatorLoader.loadValidators(); final OwnedValidators validators = validatorLoader.getOwnedValidators(); @@ -520,6 +544,7 @@ void shouldEnableSlashingProtectionForLocalValidators(@TempDir Path tempDir) thr verify(slashingProtector) .maySignBlock( validator.getPublicKey(), forkInfo.getGenesisValidatorsRoot(), block.getSlot()); + assertThat(validator.getGraffitiProvider()).isInstanceOf(FileBackedGraffitiProvider.class); } @Test @@ -546,7 +571,8 @@ void shouldLoadAdditionalExternalValidatorsOnReload() { publicKeyLoader, asyncRunner, metricsSystem, - Optional.empty()); + Optional.empty(), + (publicKey) -> Optional.empty()); validatorLoader.loadValidators(); final OwnedValidators validators = validatorLoader.getOwnedValidators(); @@ -557,6 +583,7 @@ void shouldLoadAdditionalExternalValidatorsOnReload() { validatorLoader.loadValidators(); assertThat(validators.getPublicKeys()).containsExactlyInAnyOrder(PUBLIC_KEY1, PUBLIC_KEY2); + checkGraffitiProviderTypes(validators.getValidators(), FileBackedGraffitiProvider.class); } @Test @@ -583,7 +610,8 @@ void shouldNotRemoveExternalValidatorsOnReload() { publicKeyLoader, asyncRunner, metricsSystem, - Optional.empty()); + Optional.empty(), + (publicKey) -> Optional.empty()); validatorLoader.loadValidators(); final OwnedValidators validators = validatorLoader.getOwnedValidators(); @@ -594,6 +622,7 @@ void shouldNotRemoveExternalValidatorsOnReload() { validatorLoader.loadValidators(); assertThat(validators.getPublicKeys()).containsExactlyInAnyOrder(PUBLIC_KEY1, PUBLIC_KEY2); + checkGraffitiProviderTypes(validators.getValidators(), FileBackedGraffitiProvider.class); } @Test @@ -615,7 +644,8 @@ void shouldLoadAdditionalLocalValidatorsOnReload(final @TempDir Path tempDir) th publicKeyLoader, asyncRunner, metricsSystem, - Optional.empty()); + Optional.empty(), + (publicKey) -> Optional.empty()); // No validators initially validatorLoader.loadValidators(); @@ -627,6 +657,7 @@ void shouldLoadAdditionalLocalValidatorsOnReload(final @TempDir Path tempDir) th validatorLoader.loadValidators(); assertThat(validators.getPublicKeys()).containsExactlyInAnyOrder(PUBLIC_KEY1); + checkGraffitiProviderTypes(validators.getValidators(), FileBackedGraffitiProvider.class); } @Test @@ -650,11 +681,13 @@ void initializeInteropValidatorsWhenInteropIsEnabled() { publicKeyLoader, asyncRunner, metricsSystem, - Optional.empty()); + Optional.empty(), + (publicKey) -> Optional.empty()); validatorLoader.loadValidators(); final OwnedValidators validators = validatorLoader.getOwnedValidators(); assertThat(validators.getValidatorCount()).isEqualTo(ownedValidatorCount); + checkGraffitiProviderTypes(validators.getValidators(), FileBackedGraffitiProvider.class); } @Test @@ -671,7 +704,8 @@ void shouldNotLoadMutableValidatorIfNotEnabled() { publicKeyLoader, asyncRunner, metricsSystem, - Optional.empty()); + Optional.empty(), + (publicKey) -> Optional.empty()); validatorLoader.loadValidators(); final LocalValidatorImportResult result = validatorLoader.loadLocalMutableValidator(null, "", Optional.empty(), true); @@ -696,7 +730,8 @@ void shouldLoadMutableValidatorIfEnabled(@TempDir final Path tempDir) throws Exc publicKeyLoader, asyncRunner, metricsSystem, - Optional.of(new SimpleDataDirLayout(tempDir))); + Optional.of(new SimpleDataDirLayout(tempDir)), + (publicKey) -> Optional.empty()); validatorLoader.loadValidators(); final String keystoreString = @@ -710,6 +745,7 @@ void shouldLoadMutableValidatorIfEnabled(@TempDir final Path tempDir) throws Exc validatorLoader.getOwnedValidators().getValidator(PUBLIC_KEY1); assertThat(validator).isPresent(); assertThat(validator.orElseThrow().getSigner()).isInstanceOf(DeletableSigner.class); + assertThat(validator.get().getGraffitiProvider()).isInstanceOf(UpdatableGraffitiProvider.class); } @Test @@ -733,7 +769,8 @@ void doNotInitializeInteropValidatorsWhenInteropIsDisabled() { publicKeyLoader, asyncRunner, metricsSystem, - Optional.empty()); + Optional.empty(), + (publicKey) -> Optional.empty()); validatorLoader.loadValidators(); final OwnedValidators validators = validatorLoader.getOwnedValidators(); @@ -741,32 +778,43 @@ void doNotInitializeInteropValidatorsWhenInteropIsDisabled() { } @Test - void shouldThrowWhenAnyErrorOccurs(@TempDir Path tempDir) throws Exception { - writeKeystore(tempDir); - writeBadKeystore(tempDir); - final ValidatorConfig config = - ValidatorConfig.builder() - .validatorKeys( - List.of(tempDir.toAbsolutePath() + File.pathSeparator + tempDir.toAbsolutePath())) - .build(); - final ValidatorLoader validatorLoader = - ValidatorLoader.create( - spec, - config, - disabledInteropConfig, - httpClientFactory, - slashingProtector, - slashingProtectionLogger, - publicKeyLoader, - asyncRunner, - metricsSystem, - Optional.empty()); - - assertThatThrownBy(validatorLoader::loadValidators) - .isExactlyInstanceOf(InvalidConfigurationException.class); + void shouldThrowWhenAnyErrorOccurs(@TempDir final Path tempDir) throws Exception { + final ValidatorLoader validatorLoader; + try { + writeKeystore(tempDir); + writeBadKeystore(tempDir); + final ValidatorConfig config = + ValidatorConfig.builder() + .validatorKeys( + List.of(tempDir.toAbsolutePath() + File.pathSeparator + tempDir.toAbsolutePath())) + .build(); + validatorLoader = + ValidatorLoader.create( + spec, + config, + disabledInteropConfig, + httpClientFactory, + slashingProtector, + slashingProtectionLogger, + publicKeyLoader, + asyncRunner, + metricsSystem, + Optional.empty(), + (publicKey) -> Optional.empty()); + + assertThatThrownBy(validatorLoader::loadValidators) + .isExactlyInstanceOf(InvalidConfigurationException.class); + } finally { + // Ensure all files and directories within tempDir are deleted + // attempt to workaround issue related to @TempDir and Windows file system + // https://github.com/junit-team/junit5/issues/2811 + try (Stream stream = Files.walk(tempDir)) { + stream.map(Path::toFile).forEach(File::delete); + } + } final OwnedValidators validators = validatorLoader.getOwnedValidators(); - assertThat(validators.getValidatorCount()).isEqualTo(0); + checkGraffitiProviderTypes(validators.getValidators(), FileBackedGraffitiProvider.class); } static void writeKeystore(final Path tempDir) throws Exception { @@ -791,4 +839,11 @@ private void writeMutableKeystore(final DataDirLayout tempDir) throws Exception Files.copy(Path.of(resource.toURI()), keystore.resolve("key.json")); Files.writeString(keystorePassword.resolve("key.txt"), "testpassword"); } + + private void checkGraffitiProviderTypes( + final List validators, final Class expectedType) { + for (final Validator validator : validators) { + assertThat(validator.getGraffitiProvider()).isInstanceOf(expectedType); + } + } } diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/loader/ValidatorSourceFactoryTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/loader/ValidatorSourceFactoryTest.java index e6687b6bdd0..368428b58b3 100644 --- a/validator/client/src/test/java/tech/pegasys/teku/validator/client/loader/ValidatorSourceFactoryTest.java +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/loader/ValidatorSourceFactoryTest.java @@ -48,7 +48,7 @@ class ValidatorSourceFactoryTest { @Test void mutableValidatorShouldBeSlashingProtected(@TempDir final Path tempDir) { final DataDirLayout dataDirLayout = - new SeparateServiceDataDirLayout(tempDir, Optional.empty(), Optional.empty()); + new SeparateServiceDataDirLayout(tempDir, Optional.empty(), Optional.empty(), false); final ValidatorSourceFactory factory = new ValidatorSourceFactory( spec, diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/proposerconfig/loader/ProposerConfigLoaderTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/proposerconfig/loader/ProposerConfigLoaderTest.java index adc55bcf29c..21ed84da98f 100644 --- a/validator/client/src/test/java/tech/pegasys/teku/validator/client/proposerconfig/loader/ProposerConfigLoaderTest.java +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/proposerconfig/loader/ProposerConfigLoaderTest.java @@ -17,9 +17,15 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy; import com.fasterxml.jackson.core.JsonParseException; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.module.SimpleModule; import com.google.common.io.Resources; import java.net.URL; +import java.util.Map; import java.util.Optional; +import org.apache.tuweni.bytes.Bytes48; import org.junit.jupiter.api.Test; import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.ethereum.execution.types.Eth1Address; @@ -147,6 +153,40 @@ void shouldNotLoadBuilderOverridesWithPubKeyInDefaultConfig() { "\"publicKey\" is not allowed in \"default_config.builder.registrationOverrides\""); } + @Test + public void shouldRegisterRequiredSerializersAndDeserializers() throws JsonProcessingException { + final ProposerConfigLoader loader = new ProposerConfigLoader(); + final ObjectMapper objectMapper = loader.getObjectMapper(); + + final SimpleModule module = new SimpleModule("ProposerConfigLoader"); + assertThat(objectMapper.getRegisteredModuleIds()).contains(module.getTypeId()); + + // Can deserialize BLSPublicKey + final String pubKey = + "0xa057816155ad77931185101128655c0191bd0214c201ca48ed887f6c4c6adf334070efcd75140eada5ac83a92506dd7a"; + final String pubKeyJson = String.format("\"%s\"", pubKey); + final BLSPublicKey pubKeyFromJson = objectMapper.readValue(pubKeyJson, BLSPublicKey.class); + assertThat(pubKeyFromJson).isNotNull(); + assertThat(pubKeyFromJson.toString()).isEqualTo(pubKey); + + // Can serialize BLSPublicKey + final BLSPublicKey blsPubKey = BLSPublicKey.fromHexString(pubKey); + final String jsonFromPubKey = objectMapper.writeValueAsString(blsPubKey); + assertThat(jsonFromPubKey).isEqualTo(pubKeyJson); + + // Can deserialize Bytes48 map key + final Bytes48 key = Bytes48.fromHexString(pubKey); + final Map originalMap = Map.of(key, "value"); + // Serialize the map to JSON + final String json = objectMapper.writeValueAsString(originalMap); + // Deserialize the JSON back to a map + final Map deserializedMap = + objectMapper.readValue(json, new TypeReference<>() {}); + + // Verify that the deserialized map matches the original + assertThat(deserializedMap).isEqualTo(originalMap); + } + private void validateContent1(final ProposerConfig config) { final Optional theConfig = config.getConfigForPubKey( diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/ValidatorOpenApiTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/ValidatorOpenApiTest.java index 85cec2054a7..2872955c053 100644 --- a/validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/ValidatorOpenApiTest.java +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/ValidatorOpenApiTest.java @@ -32,6 +32,7 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecFactory; import tech.pegasys.teku.validator.api.ValidatorApiChannel; +import tech.pegasys.teku.validator.api.noop.NoOpGraffitiManager; import tech.pegasys.teku.validator.beaconnode.GenesisDataProvider; import tech.pegasys.teku.validator.client.OwnedKeyManager; import tech.pegasys.teku.validator.client.ProposerConfigManager; @@ -45,7 +46,7 @@ class ValidatorOpenApiTest { private final OpenApiTestUtil util = new OpenApiTestUtil<>(ValidatorOpenApiTest.class); private JsonNode jsonNode; - private SlashingRiskAction doppelgangerDetectionAction = mock(SlashingRiskAction.class); + private final SlashingRiskAction doppelgangerDetectionAction = mock(SlashingRiskAction.class); @BeforeEach void setup() throws IOException { @@ -69,7 +70,8 @@ void setup() throws IOException { dataDirLayout, new SystemTimeProvider(), Optional.empty(), - doppelgangerDetectionAction); + doppelgangerDetectionAction, + new NoOpGraffitiManager()); final Optional maybeJson = restApi.getRestApiDocs(); assertThat(maybeJson).isPresent(); jsonNode = util.parseSwagger(maybeJson.orElseThrow()); diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/ValidatorTypesTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/ValidatorTypesTest.java index 80f5019bbf1..15506210bc6 100644 --- a/validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/ValidatorTypesTest.java +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/ValidatorTypesTest.java @@ -236,7 +236,8 @@ void externalValidatorStore_noUrlProvided() throws JsonProcessingException { } private void checkExternalValidatorStoreRoundTrip( - BLSPublicKey publicKey, Optional url, String expected) throws JsonProcessingException { + final BLSPublicKey publicKey, final Optional url, final String expected) + throws JsonProcessingException { ExternalValidator value = new ExternalValidator(publicKey, url); String serializedValue = serialize(value, ValidatorTypes.EXTERNAL_VALIDATOR_STORE); diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/apis/DeleteGraffitiTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/apis/DeleteGraffitiTest.java new file mode 100644 index 00000000000..da79a918c12 --- /dev/null +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/apis/DeleteGraffitiTest.java @@ -0,0 +1,125 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.client.restapi.apis; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoInteractions; +import static org.mockito.Mockito.when; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_FORBIDDEN; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_UNAUTHORIZED; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; +import static tech.pegasys.teku.spec.generator.signatures.NoOpLocalSigner.NO_OP_SIGNER; + +import com.fasterxml.jackson.core.JsonProcessingException; +import java.io.IOException; +import java.util.Optional; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.infrastructure.http.HttpErrorResponse; +import tech.pegasys.teku.infrastructure.restapi.StubRestApiRequest; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.util.DataStructureUtil; +import tech.pegasys.teku.validator.api.GraffitiManagementException; +import tech.pegasys.teku.validator.api.GraffitiManager; +import tech.pegasys.teku.validator.client.OwnedKeyManager; +import tech.pegasys.teku.validator.client.Validator; + +class DeleteGraffitiTest { + private final DataStructureUtil dataStructureUtil = + new DataStructureUtil(TestSpecFactory.createDefault()); + private final BLSPublicKey publicKey = dataStructureUtil.randomPublicKey(); + + private final OwnedKeyManager keyManager = mock(OwnedKeyManager.class); + private final GraffitiManager graffitiManager = mock(GraffitiManager.class); + private final DeleteGraffiti handler = new DeleteGraffiti(keyManager, graffitiManager); + private final StubRestApiRequest request = + StubRestApiRequest.builder() + .metadata(handler.getMetadata()) + .pathParameter("pubkey", publicKey.toHexString()) + .build(); + + @Test + void shouldSuccessfullyDeleteGraffiti() throws JsonProcessingException { + final Validator validator = new Validator(publicKey, NO_OP_SIGNER, Optional::empty); + when(keyManager.getValidatorByPublicKey(any())).thenReturn(Optional.of(validator)); + + handler.handleRequest(request); + + verify(graffitiManager).deleteGraffiti(eq(publicKey)); + assertThat(request.getResponseCode()).isEqualTo(SC_NO_CONTENT); + assertThat(request.getResponseBody()).isNull(); + } + + @Test + void shouldReturnErrorWhenIssueDeletingGraffiti() + throws IOException, GraffitiManagementException { + final GraffitiManagementException exception = + new GraffitiManagementException("Unable to delete graffiti for validator " + publicKey); + final Validator validator = new Validator(publicKey, NO_OP_SIGNER, Optional::empty); + when(keyManager.getValidatorByPublicKey(any())).thenReturn(Optional.of(validator)); + doThrow(exception).when(graffitiManager).deleteGraffiti(any()); + + handler.handleRequest(request); + + verify(graffitiManager).deleteGraffiti(eq(publicKey)); + assertThat(request.getResponseCode()).isEqualTo(SC_INTERNAL_SERVER_ERROR); + assertThat(request.getResponseBody()) + .isEqualTo(new HttpErrorResponse(SC_INTERNAL_SERVER_ERROR, exception.getMessage())); + } + + @Test + void shouldRespondNotFoundWhenNoValidator() throws JsonProcessingException { + when(keyManager.getValidatorByPublicKey(any())).thenReturn(Optional.empty()); + + handler.handleRequest(request); + + verifyNoInteractions(graffitiManager); + assertThat(request.getResponseCode()).isEqualTo(SC_NOT_FOUND); + } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle400() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_BAD_REQUEST); + } + + @Test + void metadata_shouldHandle401() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_UNAUTHORIZED); + } + + @Test + void metadata_shouldHandle403() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_FORBIDDEN); + } + + @Test + void metadata_shouldHandle500() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_INTERNAL_SERVER_ERROR); + } +} diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/apis/GetGraffitiTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/apis/GetGraffitiTest.java new file mode 100644 index 00000000000..144e2db4d90 --- /dev/null +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/apis/GetGraffitiTest.java @@ -0,0 +1,143 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.client.restapi.apis; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_FORBIDDEN; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_UNAUTHORIZED; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; +import static tech.pegasys.teku.spec.generator.signatures.NoOpLocalSigner.NO_OP_SIGNER; + +import com.fasterxml.jackson.core.JsonProcessingException; +import java.io.IOException; +import java.util.Optional; +import org.apache.tuweni.bytes.Bytes32; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.infrastructure.http.HttpErrorResponse; +import tech.pegasys.teku.infrastructure.restapi.StubRestApiRequest; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.util.DataStructureUtil; +import tech.pegasys.teku.validator.api.Bytes32Parser; +import tech.pegasys.teku.validator.api.GraffitiManagementException; +import tech.pegasys.teku.validator.api.UpdatableGraffitiProvider; +import tech.pegasys.teku.validator.client.OwnedKeyManager; +import tech.pegasys.teku.validator.client.Validator; + +class GetGraffitiTest { + private final DataStructureUtil dataStructureUtil = + new DataStructureUtil(TestSpecFactory.createDefault()); + private final String stringGraffiti = "Test graffiti"; + private final Bytes32 bytesGraffiti = Bytes32Parser.toBytes32(stringGraffiti); + private final BLSPublicKey publicKey = dataStructureUtil.randomPublicKey(); + + private final OwnedKeyManager keyManager = mock(OwnedKeyManager.class); + private final GetGraffiti handler = new GetGraffiti(keyManager); + private final StubRestApiRequest request = + StubRestApiRequest.builder() + .metadata(handler.getMetadata()) + .pathParameter("pubkey", publicKey.toHexString()) + .build(); + + @Test + void shouldGetGraffiti() throws JsonProcessingException { + checkGraffiti(Optional.of(bytesGraffiti)); + } + + @Test + void shouldGetEmptyGraffiti() throws JsonProcessingException { + checkGraffiti(Optional.empty()); + } + + @Test + void shouldHandleGraffitiManagementException() throws JsonProcessingException { + final GraffitiManagementException exception = + new GraffitiManagementException("Unable to retrieve graffiti from storage"); + final UpdatableGraffitiProvider provider = mock(UpdatableGraffitiProvider.class); + doThrow(exception).when(provider).getUnsafe(); + final Validator validator = new Validator(publicKey, NO_OP_SIGNER, provider); + when(keyManager.getValidatorByPublicKey(eq(publicKey))).thenReturn(Optional.of(validator)); + + handler.handleRequest(request); + + assertThat(request.getResponseCode()).isEqualTo(SC_INTERNAL_SERVER_ERROR); + assertThat(request.getResponseBody()) + .isEqualTo(new HttpErrorResponse(SC_INTERNAL_SERVER_ERROR, exception.getMessage())); + verify(provider).getUnsafe(); + } + + @Test + void shouldHandleValidatorNotFound() throws IOException { + when(keyManager.getValidatorByPublicKey(any())).thenReturn(Optional.empty()); + + handler.handleRequest(request); + + assertThat(request.getResponseCode()).isEqualTo(SC_NOT_FOUND); + assertThat(request.getResponseBody()) + .isEqualTo(new HttpErrorResponse(SC_NOT_FOUND, "Validator not found")); + } + + @Test + void metadata_shouldHandle200() throws JsonProcessingException { + final String responseData = + getResponseStringFromMetadata(handler, SC_OK, Optional.of(bytesGraffiti)); + final String expectedResponse = + String.format("{\"data\":{\"graffiti\":\"%s\"}}", stringGraffiti); + assertThat(responseData).isEqualTo(expectedResponse); + } + + @Test + void metadata_shouldHandle400() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_BAD_REQUEST); + } + + @Test + void metadata_shouldHandle401() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_UNAUTHORIZED); + } + + @Test + void metadata_shouldHandle403() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_FORBIDDEN); + } + + @Test + void metadata_shouldHandle500() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_INTERNAL_SERVER_ERROR); + } + + private void checkGraffiti(final Optional graffiti) throws JsonProcessingException { + final UpdatableGraffitiProvider provider = mock(UpdatableGraffitiProvider.class); + when(provider.getUnsafe()).thenReturn(graffiti); + final Validator validator = new Validator(publicKey, NO_OP_SIGNER, provider); + when(keyManager.getValidatorByPublicKey(eq(publicKey))).thenReturn(Optional.of(validator)); + + handler.handleRequest(request); + + assertThat(request.getResponseCode()).isEqualTo(SC_OK); + assertThat(request.getResponseBody()).isEqualTo(graffiti); + verify(provider).getUnsafe(); + } +} diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/apis/PostKeysTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/apis/PostKeysTest.java index a39eeb9cfdf..4a656eb25ea 100644 --- a/validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/apis/PostKeysTest.java +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/apis/PostKeysTest.java @@ -92,6 +92,6 @@ void shouldRespondBadRequestIfSlashingProtectionImportFails(@TempDir final Path assertThatThrownBy(() -> endpoint.handleRequest(request)) .isInstanceOf(BadRequestException.class) - .hasMessageStartingWith("Import data does not appear to have metadata"); + .hasMessageStartingWith("Failed to load data. required fields:"); } } diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/apis/SetGraffitiTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/apis/SetGraffitiTest.java new file mode 100644 index 00000000000..d9a0d40c1ec --- /dev/null +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/apis/SetGraffitiTest.java @@ -0,0 +1,149 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.client.restapi.apis; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoInteractions; +import static org.mockito.Mockito.when; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_FORBIDDEN; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_UNAUTHORIZED; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataEmptyResponse; +import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse; +import static tech.pegasys.teku.spec.generator.signatures.NoOpLocalSigner.NO_OP_SIGNER; + +import com.fasterxml.jackson.core.JsonProcessingException; +import java.util.Optional; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.infrastructure.http.HttpErrorResponse; +import tech.pegasys.teku.infrastructure.restapi.StubRestApiRequest; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.util.DataStructureUtil; +import tech.pegasys.teku.validator.api.GraffitiManagementException; +import tech.pegasys.teku.validator.api.GraffitiManager; +import tech.pegasys.teku.validator.client.OwnedKeyManager; +import tech.pegasys.teku.validator.client.Validator; + +class SetGraffitiTest { + private final DataStructureUtil dataStructureUtil = + new DataStructureUtil(TestSpecFactory.createDefault()); + private final BLSPublicKey publicKey = dataStructureUtil.randomPublicKey(); + private final String graffiti = "Test graffiti"; + + private final OwnedKeyManager keyManager = mock(OwnedKeyManager.class); + private final GraffitiManager graffitiManager = mock(GraffitiManager.class); + private final SetGraffiti handler = new SetGraffiti(keyManager, graffitiManager); + private final StubRestApiRequest request = + StubRestApiRequest.builder() + .metadata(handler.getMetadata()) + .pathParameter("pubkey", publicKey.toHexString()) + .build(); + + @Test + void shouldSuccessfullySetGraffiti() throws JsonProcessingException { + request.setRequestBody(graffiti); + + final Validator validator = new Validator(publicKey, NO_OP_SIGNER, Optional::empty); + when(keyManager.getValidatorByPublicKey(any())).thenReturn(Optional.of(validator)); + + handler.handleRequest(request); + + verify(graffitiManager).setGraffiti(eq(publicKey), eq(graffiti)); + assertThat(request.getResponseCode()).isEqualTo(SC_NO_CONTENT); + assertThat(request.getResponseBody()).isNull(); + } + + @Test + void shouldReturnErrorWhenIssueSettingGraffiti() throws JsonProcessingException { + final GraffitiManagementException exception = + new GraffitiManagementException("Unable to update graffiti for validator " + publicKey); + request.setRequestBody(graffiti); + + final Validator validator = new Validator(publicKey, NO_OP_SIGNER, Optional::empty); + when(keyManager.getValidatorByPublicKey(any())).thenReturn(Optional.of(validator)); + doThrow(exception).when(graffitiManager).setGraffiti(any(), eq(graffiti)); + + handler.handleRequest(request); + + verify(graffitiManager).setGraffiti(eq(publicKey), eq(graffiti)); + assertThat(request.getResponseCode()).isEqualTo(SC_INTERNAL_SERVER_ERROR); + assertThat(request.getResponseBody()) + .isEqualTo(new HttpErrorResponse(SC_INTERNAL_SERVER_ERROR, exception.getMessage())); + } + + @Test + void shouldThrowExceptionWhenInvalidGraffitiInput() { + final String invalidGraffiti = "This graffiti is a bit too long!!"; + final String errorMessage = + String.format( + "'%s' converts to 33 bytes. Input must be 32 bytes or less.", invalidGraffiti); + request.setRequestBody(invalidGraffiti); + + final Validator validator = new Validator(publicKey, NO_OP_SIGNER, Optional::empty); + when(keyManager.getValidatorByPublicKey(any())).thenReturn(Optional.of(validator)); + doThrow(new IllegalArgumentException(errorMessage)) + .when(graffitiManager) + .setGraffiti(any(), eq(invalidGraffiti)); + + assertThatThrownBy(() -> handler.handleRequest(request)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage(errorMessage); + verify(graffitiManager).setGraffiti(eq(publicKey), eq(invalidGraffiti)); + } + + @Test + void shouldRespondNotFoundWhenNoValidator() throws JsonProcessingException { + when(keyManager.getValidatorByPublicKey(any())).thenReturn(Optional.empty()); + + handler.handleRequest(request); + + verifyNoInteractions(graffitiManager); + assertThat(request.getResponseCode()).isEqualTo(SC_NOT_FOUND); + } + + @Test + void metadata_shouldHandle204() { + verifyMetadataEmptyResponse(handler, SC_NO_CONTENT); + } + + @Test + void metadata_shouldHandle400() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_BAD_REQUEST); + } + + @Test + void metadata_shouldHandle401() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_UNAUTHORIZED); + } + + @Test + void metadata_shouldHandle403() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_FORBIDDEN); + } + + @Test + void metadata_shouldHandle500() throws JsonProcessingException { + verifyMetadataErrorResponse(handler, SC_INTERNAL_SERVER_ERROR); + } +} diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/signer/ExternalSignerBlockRequestProviderTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/signer/ExternalSignerBlockRequestProviderTest.java deleted file mode 100644 index 410038f49ba..00000000000 --- a/validator/client/src/test/java/tech/pegasys/teku/validator/client/signer/ExternalSignerBlockRequestProviderTest.java +++ /dev/null @@ -1,105 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.validator.client.signer; - -import static org.assertj.core.api.Assertions.assertThat; - -import java.util.Map; -import org.junit.jupiter.api.Test; -import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.SpecMilestone; -import tech.pegasys.teku.spec.TestSpecFactory; -import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock; -import tech.pegasys.teku.spec.util.DataStructureUtil; - -class ExternalSignerBlockRequestProviderTest { - - @Test - void phase0BlockGeneratesCorrectSignTypeAndMetadata() { - final Spec spec = TestSpecFactory.createMinimalPhase0(); - final BeaconBlock block = new DataStructureUtil(spec).randomBeaconBlock(10); - - final ExternalSignerBlockRequestProvider externalSignerBlockRequestProvider = - new ExternalSignerBlockRequestProvider(spec, block); - final SignType signType = externalSignerBlockRequestProvider.getSignType(); - final Map blockMetadata = - externalSignerBlockRequestProvider.getBlockMetadata(Map.of()); - - assertThat(signType).isEqualTo(SignType.BLOCK); - assertThat(blockMetadata).containsKey("block"); - } - - @Test - void altairBlockGeneratesCorrectSignTypeAndMetadata() { - final Spec spec = TestSpecFactory.createMinimalAltair(); - final BeaconBlock block = new DataStructureUtil(spec).randomBeaconBlock(10); - - final ExternalSignerBlockRequestProvider externalSignerBlockRequestProvider = - new ExternalSignerBlockRequestProvider(spec, block); - final SignType signType = externalSignerBlockRequestProvider.getSignType(); - final Map blockMetadata = - externalSignerBlockRequestProvider.getBlockMetadata(Map.of()); - - assertThat(signType).isEqualTo(SignType.BLOCK_V2); - assertThat(blockMetadata).containsKey("beacon_block"); - assertThat(blockMetadata.get("beacon_block")).isExactlyInstanceOf(BlockRequestBody.class); - - final BlockRequestBody blockRequestBody = (BlockRequestBody) blockMetadata.get("beacon_block"); - assertThat(blockRequestBody.getVersion()).isEqualTo(SpecMilestone.ALTAIR); - assertThat(blockRequestBody.getBeaconBlock()).isNotNull(); - assertThat(blockRequestBody.getBeaconBlockHeader()).isNull(); - } - - @Test - void bellatrixBlockGeneratesCorrectSignTypeAndMetadata() { - final Spec spec = TestSpecFactory.createMinimalBellatrix(); - final BeaconBlock block = new DataStructureUtil(spec).randomBeaconBlock(10); - - final ExternalSignerBlockRequestProvider externalSignerBlockRequestProvider = - new ExternalSignerBlockRequestProvider(spec, block); - final SignType signType = externalSignerBlockRequestProvider.getSignType(); - final Map blockMetadata = - externalSignerBlockRequestProvider.getBlockMetadata(Map.of()); - - assertThat(signType).isEqualTo(SignType.BLOCK_V2); - assertThat(blockMetadata).containsKey("beacon_block"); - assertThat(blockMetadata.get("beacon_block")).isExactlyInstanceOf(BlockRequestBody.class); - - final BlockRequestBody blockRequestBody = (BlockRequestBody) blockMetadata.get("beacon_block"); - assertThat(blockRequestBody.getVersion()).isEqualTo(SpecMilestone.BELLATRIX); - assertThat(blockRequestBody.getBeaconBlock()).isNull(); - assertThat(blockRequestBody.getBeaconBlockHeader()).isNotNull(); - } - - @Test - void bellatrixBlindedBlockGeneratesCorrectSignTypeAndMetadata() { - final Spec spec = TestSpecFactory.createMinimalBellatrix(); - final BeaconBlock block = new DataStructureUtil(spec).randomBlindedBeaconBlock(10); - - final ExternalSignerBlockRequestProvider externalSignerBlockRequestProvider = - new ExternalSignerBlockRequestProvider(spec, block); - final SignType signType = externalSignerBlockRequestProvider.getSignType(); - final Map blockMetadata = - externalSignerBlockRequestProvider.getBlockMetadata(Map.of()); - - assertThat(signType).isEqualTo(SignType.BLOCK_V2); - assertThat(blockMetadata).containsKey("beacon_block"); - assertThat(blockMetadata.get("beacon_block")).isExactlyInstanceOf(BlockRequestBody.class); - - final BlockRequestBody blockRequestBody = (BlockRequestBody) blockMetadata.get("beacon_block"); - assertThat(blockRequestBody.getVersion()).isEqualTo(SpecMilestone.BELLATRIX); - assertThat(blockRequestBody.getBeaconBlock()).isNull(); - assertThat(blockRequestBody.getBeaconBlockHeader()).isNotNull(); - } -} diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/signer/ExternalSignerExceptionTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/signer/ExternalSignerExceptionTest.java index fe4cbc10f3e..bec549c38b3 100644 --- a/validator/client/src/test/java/tech/pegasys/teku/validator/client/signer/ExternalSignerExceptionTest.java +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/signer/ExternalSignerExceptionTest.java @@ -19,6 +19,7 @@ import java.net.URISyntaxException; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import tech.pegasys.teku.validator.api.signer.SignType; class ExternalSignerExceptionTest { diff --git a/validator/client/src/test/java/tech/pegasys/teku/validator/client/signer/SigningRequestBodyTest.java b/validator/client/src/test/java/tech/pegasys/teku/validator/client/signer/SigningRequestBodyTest.java new file mode 100644 index 00000000000..2a421661188 --- /dev/null +++ b/validator/client/src/test/java/tech/pegasys/teku/validator/client/signer/SigningRequestBodyTest.java @@ -0,0 +1,238 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.client.signer; + +import static java.nio.charset.StandardCharsets.UTF_8; +import static org.assertj.core.api.Assertions.assertThat; +import static tech.pegasys.teku.validator.client.signer.ExternalSigner.FORK_INFO; + +import com.google.common.io.Resources; +import java.io.IOException; +import java.util.Map; +import org.junit.jupiter.api.Test; +import tech.pegasys.teku.infrastructure.json.JsonUtil; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.TestSpecFactory; +import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock; +import tech.pegasys.teku.spec.datastructures.state.ForkInfo; +import tech.pegasys.teku.spec.signatures.SigningRootUtil; +import tech.pegasys.teku.spec.util.DataStructureUtil; +import tech.pegasys.teku.validator.api.signer.AggregationSlotWrapper; +import tech.pegasys.teku.validator.api.signer.SignType; +import tech.pegasys.teku.validator.api.signer.SyncAggregatorSelectionDataWrapper; +import tech.pegasys.teku.validator.api.signer.SyncCommitteeMessageWrapper; + +class SigningRequestBodyTest { + private Spec spec; + private DataStructureUtil dataStructureUtil; + + @Test + void altairVoluntaryExitExternalSignerMessage() throws IOException { + spec = TestSpecFactory.createMinimalAltair(); + dataStructureUtil = new DataStructureUtil(spec); + checkSigningMessageStructure( + new SigningRequestBody( + dataStructureUtil.randomBytes32(), + SignType.VOLUNTARY_EXIT, + Map.of( + SignType.VOLUNTARY_EXIT.getName(), + dataStructureUtil.randomVoluntaryExit(), + FORK_INFO, + dataStructureUtil.randomForkInfo()))); + } + + @Test + void altairAggregationSlotExternalSignerMessage() throws IOException { + spec = TestSpecFactory.createMinimalAltair(); + dataStructureUtil = new DataStructureUtil(spec); + checkSigningMessageStructure( + new SigningRequestBody( + dataStructureUtil.randomBytes32(), + SignType.AGGREGATION_SLOT, + Map.of( + SignType.AGGREGATION_SLOT.getName(), + new AggregationSlotWrapper(dataStructureUtil.randomSlot()), + FORK_INFO, + dataStructureUtil.randomForkInfo()))); + } + + @Test + void altairAggregateAndProofExternalSignerMessage() throws IOException { + spec = TestSpecFactory.createMinimalAltair(); + dataStructureUtil = new DataStructureUtil(spec); + checkSigningMessageStructure( + new SigningRequestBody( + dataStructureUtil.randomBytes32(), + SignType.AGGREGATE_AND_PROOF, + Map.of( + SignType.AGGREGATE_AND_PROOF.getName(), + dataStructureUtil.randomAggregateAndProof(), + FORK_INFO, + dataStructureUtil.randomForkInfo()))); + } + + @Test + void altairSyncCommitteeSelectionProofExternalSignerMessage() throws IOException { + spec = TestSpecFactory.createMinimalAltair(); + dataStructureUtil = new DataStructureUtil(spec); + checkSigningMessageStructure( + new SigningRequestBody( + dataStructureUtil.randomBytes32(), + SignType.SYNC_COMMITTEE_SELECTION_PROOF, + Map.of( + SignType.SYNC_COMMITTEE_SELECTION_PROOF.getName(), + new SyncAggregatorSelectionDataWrapper( + dataStructureUtil.randomSlot(), dataStructureUtil.randomUInt64(64L)), + FORK_INFO, + dataStructureUtil.randomForkInfo()))); + } + + @Test + void altairSyncCommitteeContributionAndProofExternalSignerMessage() throws IOException { + spec = TestSpecFactory.createMinimalAltair(); + dataStructureUtil = new DataStructureUtil(spec); + checkSigningMessageStructure( + new SigningRequestBody( + dataStructureUtil.randomBytes32(), + SignType.SYNC_COMMITTEE_CONTRIBUTION_AND_PROOF, + Map.of( + SignType.SYNC_COMMITTEE_CONTRIBUTION_AND_PROOF.getName(), + dataStructureUtil.randomContributionAndProof(), + FORK_INFO, + dataStructureUtil.randomForkInfo()))); + } + + @Test + void altairSyncCommitteeMessageExternalSignerMessage() throws IOException { + spec = TestSpecFactory.createMinimalAltair(); + dataStructureUtil = new DataStructureUtil(spec); + checkSigningMessageStructure( + new SigningRequestBody( + dataStructureUtil.randomBytes32(), + SignType.SYNC_COMMITTEE_MESSAGE, + Map.of( + SignType.SYNC_COMMITTEE_MESSAGE.getName(), + new SyncCommitteeMessageWrapper( + dataStructureUtil.randomBytes32(), dataStructureUtil.randomSlot()), + FORK_INFO, + dataStructureUtil.randomForkInfo()))); + } + + @Test + void altairAggregationExternalSignerMessage() throws IOException { + spec = TestSpecFactory.createMinimalAltair(); + dataStructureUtil = new DataStructureUtil(spec); + checkSigningMessageStructure( + new SigningRequestBody( + dataStructureUtil.randomBytes32(), + SignType.AGGREGATION_SLOT, + Map.of( + SignType.AGGREGATION_SLOT.getName(), + new AggregationSlotWrapper(dataStructureUtil.randomSlot()), + FORK_INFO, + dataStructureUtil.randomForkInfo()))); + } + + @Test + void altairValidatorRegistrationExternalSignerMessage() throws IOException { + spec = TestSpecFactory.createMinimalAltair(); + dataStructureUtil = new DataStructureUtil(spec); + checkSigningMessageStructure( + new SigningRequestBody( + dataStructureUtil.randomBytes32(), + SignType.VALIDATOR_REGISTRATION, + Map.of( + SignType.VALIDATOR_REGISTRATION.getName(), + dataStructureUtil.randomValidatorRegistration()))); + } + + @Test + void phase0AttestationExternalSignerMessage() throws IOException { + spec = TestSpecFactory.createMinimalPhase0(); + dataStructureUtil = new DataStructureUtil(spec); + checkSigningMessageStructure( + new SigningRequestBody( + dataStructureUtil.randomBytes32(), + SignType.ATTESTATION, + Map.of( + SignType.ATTESTATION.getName(), + dataStructureUtil.randomAttestationData(), + FORK_INFO, + dataStructureUtil.randomForkInfo()))); + } + + @Test + void phase0BlockExternalSignerMessage() throws IOException { + spec = TestSpecFactory.createMinimalPhase0(); + dataStructureUtil = new DataStructureUtil(spec); + final BeaconBlock block = dataStructureUtil.randomBeaconBlock(); + final ExternalSignerBlockRequestProvider blockRequestProvider = + new ExternalSignerBlockRequestProvider(spec, block); + final SigningRootUtil signingRootUtil = new SigningRootUtil(spec); + final ForkInfo forkInfo = dataStructureUtil.randomForkInfo(); + checkSigningMessageStructure( + new SigningRequestBody( + signingRootUtil.signingRootForSignBlock(block, forkInfo), + blockRequestProvider.getSignType(), + blockRequestProvider.getBlockMetadata(Map.of(FORK_INFO, forkInfo)))); + } + + @Test + void altairBlockExternalSignerMessage() throws IOException { + spec = TestSpecFactory.createMinimalAltair(); + dataStructureUtil = new DataStructureUtil(spec); + final BeaconBlock block = dataStructureUtil.randomBeaconBlock(); + final ExternalSignerBlockRequestProvider blockRequestProvider = + new ExternalSignerBlockRequestProvider(spec, block); + final SigningRootUtil signingRootUtil = new SigningRootUtil(spec); + final ForkInfo forkInfo = dataStructureUtil.randomForkInfo(); + checkSigningMessageStructure( + new SigningRequestBody( + signingRootUtil.signingRootForSignBlock(block, forkInfo), + blockRequestProvider.getSignType(), + blockRequestProvider.getBlockMetadata(Map.of(FORK_INFO, forkInfo)))); + } + + @Test + void bellatrixBlockExternalSignerMessage() throws IOException { + spec = TestSpecFactory.createMinimalBellatrix(); + dataStructureUtil = new DataStructureUtil(spec); + final BeaconBlock block = dataStructureUtil.randomBeaconBlock(); + final ExternalSignerBlockRequestProvider blockRequestProvider = + new ExternalSignerBlockRequestProvider(spec, block); + final SigningRootUtil signingRootUtil = new SigningRootUtil(spec); + final ForkInfo forkInfo = dataStructureUtil.randomForkInfo(); + checkSigningMessageStructure( + new SigningRequestBody( + signingRootUtil.signingRootForSignBlock(block, forkInfo), + blockRequestProvider.getSignType(), + blockRequestProvider.getBlockMetadata(Map.of(FORK_INFO, forkInfo)))); + } + + private void checkSigningMessageStructure(final SigningRequestBody requestBody) + throws IOException { + final String expectedJsonFile = getCurrentMethod(1) + ".json"; + final String prettyBody = + JsonUtil.prettySerialize( + requestBody, requestBody.getJsonTypeDefinition(spec.getGenesisSchemaDefinitions())); + final String expected = + Resources.toString( + Resources.getResource(SigningRequestBodyTest.class, expectedJsonFile), UTF_8); + assertThat(prettyBody).isEqualToIgnoringNewLines(expected); + } + + private static String getCurrentMethod(final int skip) { + return Thread.currentThread().getStackTrace()[1 + 1 + skip].getMethodName(); + } +} diff --git a/validator/client/src/test/resources/tech/pegasys/teku/validator/client/restapi/paths/_eth_v1_validator_{pubkey}_graffiti.json b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/restapi/paths/_eth_v1_validator_{pubkey}_graffiti.json new file mode 100644 index 00000000000..7dd94662e85 --- /dev/null +++ b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/restapi/paths/_eth_v1_validator_{pubkey}_graffiti.json @@ -0,0 +1,249 @@ +{ + "get" : { + "tags" : [ "Graffiti" ], + "operationId" : "getGraffiti", + "summary" : "Get Graffiti", + "description" : "Get the graffiti for an individual validator. If no graffiti is set explicitly, returns the process-wide default.", + "parameters" : [ { + "name" : "pubkey", + "required" : true, + "in" : "path", + "schema" : { + "type" : "string", + "pattern" : "^0x[a-fA-F0-9]{96}$", + "example" : "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a" + } + } ], + "security" : [ { + "bearerAuth" : [ ] + } ], + "responses" : { + "200" : { + "description" : "Success response", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/GraffitiResponse" + } + } + } + }, + "401" : { + "description" : "Unauthorized, no token is found", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "403" : { + "description" : "Forbidden, a token is found but is invalid", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "404" : { + "description" : "Not found", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "400" : { + "description" : "The request could not be processed, check the response for more information.", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "500" : { + "description" : "Internal server error", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + } + } + }, + "post" : { + "tags" : [ "Graffiti" ], + "operationId" : "setGraffiti", + "summary" : "Set Graffiti", + "description" : "Set the graffiti for an individual validator.", + "parameters" : [ { + "name" : "pubkey", + "required" : true, + "in" : "path", + "schema" : { + "type" : "string", + "pattern" : "^0x[a-fA-F0-9]{96}$", + "example" : "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a" + } + } ], + "requestBody" : { + "content" : { + "application/json" : { + "schema" : { + "type" : "object", + "required" : [ "graffiti" ], + "properties" : { + "graffiti" : { + "type" : "string", + "description" : "Arbitrary data to set in the graffiti field of BeaconBlockBody" + } + } + } + } + } + }, + "security" : [ { + "bearerAuth" : [ ] + } ], + "responses" : { + "204" : { + "description" : "Successfully updated graffiti.", + "content" : { } + }, + "401" : { + "description" : "Unauthorized, no token is found", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "403" : { + "description" : "Forbidden, a token is found but is invalid", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "404" : { + "description" : "Not found", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "400" : { + "description" : "The request could not be processed, check the response for more information.", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "500" : { + "description" : "Internal server error", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + } + } + }, + "delete" : { + "tags" : [ "Graffiti" ], + "operationId" : "deleteGraffiti", + "summary" : "Delete Configured Graffiti", + "description" : "Delete the configured graffiti for the specified public key.", + "parameters" : [ { + "name" : "pubkey", + "required" : true, + "in" : "path", + "schema" : { + "type" : "string", + "pattern" : "^0x[a-fA-F0-9]{96}$", + "example" : "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a" + } + } ], + "security" : [ { + "bearerAuth" : [ ] + } ], + "responses" : { + "204" : { + "description" : "Successfully removed the graffiti, or there was no graffiti set for the requested public key.", + "content" : { } + }, + "401" : { + "description" : "Unauthorized, no token is found", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "403" : { + "description" : "Forbidden, a token is found but is invalid", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "404" : { + "description" : "Not found", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "400" : { + "description" : "The request could not be processed, check the response for more information.", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + }, + "500" : { + "description" : "Internal server error", + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/HttpErrorResponse" + } + } + } + } + } + } +} \ No newline at end of file diff --git a/validator/client/src/test/resources/tech/pegasys/teku/validator/client/restapi/schema/GraffitiResponse.json b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/restapi/schema/GraffitiResponse.json new file mode 100644 index 00000000000..2fa888454da --- /dev/null +++ b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/restapi/schema/GraffitiResponse.json @@ -0,0 +1,22 @@ +{ + "title" : "GraffitiResponse", + "type" : "object", + "required" : [ "data" ], + "properties" : { + "data" : { + "type" : "object", + "required" : [ "graffiti" ], + "properties" : { + "pubkey" : { + "$ref" : "#/components/schemas/Pubkey" + }, + "graffiti" : { + "type" : "string", + "description" : "Bytes32 string", + "example" : "Example graffiti", + "format" : "byte" + } + } + } + } +} \ No newline at end of file diff --git a/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairAggregateAndProofExternalSignerMessage.json b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairAggregateAndProofExternalSignerMessage.json new file mode 100644 index 00000000000..362dedda053 --- /dev/null +++ b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairAggregateAndProofExternalSignerMessage.json @@ -0,0 +1,33 @@ +{ + "signingRoot" : "0x235bc3400c2839fd856a524871200bd5e362db615fc4565e1870ed9a2a936464", + "type" : "AGGREGATE_AND_PROOF", + "fork_info" : { + "fork" : { + "previous_version" : "0x6b0ac13f", + "current_version" : "0x7e2bbb3f", + "epoch" : "4597269519555858506" + }, + "genesis_validators_root" : "0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1" + }, + "aggregate_and_proof" : { + "aggregator_index" : "4669978815449698508", + "aggregate" : { + "aggregation_bits" : "0xf222308f23fd4379911b8ed32c9edd6e5dcc54a1c8c60ff9b76abe8b7424bab6dc2d6a52647f3679db31417fe81adc8e918254e1d6824ba01812bc55517124259aaf397723a131f32e26a5bd5ee07e45cef65f229a5466940408a08475d310949f1df9ce99b1794e7d5492a0ddd68979272eb245e7af8120cda3e9cd634ad160377773aa602074207f68cf77c5397236f0d96959127eb3e6410064d81d9b14937839bdd1b6ba9aafeae4a8fd00af0ed404dc9415e27351b70eca0433acfbd873d536a730f3f32e1fd87be6802b7e01741c8bbacddc2331bc7d58c70657bd5fee190d46d1d627ba23483c1d44923d0aef3acef87d1965073b85caeac55056550e01", + "data" : { + "slot" : "4665021361504678828", + "index" : "4660063907559659148", + "beacon_block_root" : "0x8200a6402ca295554fb9562193cc71d60272d63beeaf2201fdf53e846e77f919", + "source" : { + "epoch" : "542887588", + "root" : "0x5cbeb140ec0ad7cb653388caecba483cf66bd817821ed18ca1f3b7f3b9b58a04" + }, + "target" : { + "epoch" : "535577359", + "root" : "0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b" + } + }, + "signature" : "0x992e2695a49aaedcb373280f375a08adaafafff0bab131d48674136f5e452c8bb0797618eeb99bc3a4835bca2bd6aec6067807e927604548997a795d7ba982a5274f0d1d55624a8c7b66973c6e717f3c46bd2d92bc1696d3173751a6b0bf6a63" + }, + "selection_proof" : "0xae757bc04a0f7ee8e8d1668c8de3fd4ca45ca7e8f7ad7d3323350213956386cfc97094f156a7d6ab2d3ebe6a7eb7ce2c10d0d32091ee4867224ef5856bff529e9f0c2cb9c0085a28f6a47d75aae926913f681a6b21e25b093b78e3cf188bb6be" + } +} \ No newline at end of file diff --git a/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairAggregationExternalSignerMessage.json b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairAggregationExternalSignerMessage.json new file mode 100644 index 00000000000..ecfe36eb807 --- /dev/null +++ b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairAggregationExternalSignerMessage.json @@ -0,0 +1,15 @@ +{ + "signingRoot" : "0x235bc3400c2839fd856a524871200bd5e362db615fc4565e1870ed9a2a936464", + "type" : "AGGREGATION_SLOT", + "aggregation_slot" : { + "slot" : "24752339414" + }, + "fork_info" : { + "fork" : { + "previous_version" : "0xfd18cf40", + "current_version" : "0x103ac940", + "epoch" : "4660063907559659148" + }, + "genesis_validators_root" : "0x8200a6402ca295554fb9562193cc71d60272d63beeaf2201fdf53e846e77f919" + } +} \ No newline at end of file diff --git a/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairAggregationSlotExternalSignerMessage.json b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairAggregationSlotExternalSignerMessage.json new file mode 100644 index 00000000000..ecfe36eb807 --- /dev/null +++ b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairAggregationSlotExternalSignerMessage.json @@ -0,0 +1,15 @@ +{ + "signingRoot" : "0x235bc3400c2839fd856a524871200bd5e362db615fc4565e1870ed9a2a936464", + "type" : "AGGREGATION_SLOT", + "aggregation_slot" : { + "slot" : "24752339414" + }, + "fork_info" : { + "fork" : { + "previous_version" : "0xfd18cf40", + "current_version" : "0x103ac940", + "epoch" : "4660063907559659148" + }, + "genesis_validators_root" : "0x8200a6402ca295554fb9562193cc71d60272d63beeaf2201fdf53e846e77f919" + } +} \ No newline at end of file diff --git a/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairBlockExternalSignerMessage.json b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairBlockExternalSignerMessage.json new file mode 100644 index 00000000000..0394266c91c --- /dev/null +++ b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairBlockExternalSignerMessage.json @@ -0,0 +1,157 @@ +{ + "signingRoot" : "0x080741014399de57e4572915e506f79f8a2c20d18f5d5d44f2333ddd0adb0c86", + "type" : "BLOCK_V2", + "fork_info" : { + "fork" : { + "previous_version" : "0x3624343f", + "current_version" : "0x49452e3f", + "epoch" : "4557609905175570249" + }, + "genesis_validators_root" : "0x23033a3fe9f2a903b4f058a4d4ef6a81852d9997184c0317133f980452ec62b2" + }, + "beacon_block" : { + "version" : "ALTAIR", + "block" : { + "slot" : "4666673844721362956", + "proposer_index" : "4665021361504678828", + "parent_root" : "0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e", + "state_root" : "0x103ac9406cdc59b89027eb1c9e97f607dd5fdccfa8fb2da4eaeea9d25032add9", + "body" : { + "randao_reveal" : "0x983e008a34dda42f0c8f857f66aa82212aff48250f9ac54b30ae622d0835bdb7609c9cac67e7d19be24ffe5c77d581230e25c0e72fdf4066618bb0df7e09e66562de35b1f751004ad1ec65089c19a56a8b120983c301dbbf03df5ba674712ab4", + "eth1_data" : { + "deposit_root" : "0x8200a6402ca295554fb9562193cc71d60272d63beeaf2201fdf53e846e77f919", + "deposit_count" : "4663368873993027404", + "block_hash" : "0x5cbeb140ec0ad7cb653388caecba483cf66bd817821ed18ca1f3b7f3b9b58a04" + }, + "graffiti" : "0x0000000000000000000000000000000000000000000000000000000000000000", + "proposer_slashings" : [ { + "signed_header_1" : { + "message" : { + "slot" : "4600574485989226763", + "proposer_index" : "4598922002772542634", + "parent_root" : "0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb", + "state_root" : "0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486", + "body_root" : "0x6b0ac13f8a279ad3abec11bed1a49214f6e7af79b643595df6a38706b338e93b" + }, + "signature" : "0x860cc33a81805835339f1598b95691556b6f4fc5ee6a25bb24d70c658dc69d3d2e5cd62a22e14e7d962a4095e0d93ea41240a49151f9bb2884bdd1cdefcff246969101fe377460d78d58ea47c2f270e9cc8ce4bc4e81e43314bda61076350d4d" + }, + "signed_header_2" : { + "message" : { + "slot" : "4600574485989226763", + "proposer_index" : "4598922002772542634", + "parent_root" : "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "state_root" : "0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1", + "body_root" : "0xb88ea93f0a5617e780f8ae6b1fc8e4480ff4abc18f66fc45ada895271cbcc666" + }, + "signature" : "0xb8f4f7eb7f1ff3eb3923e6bf36b3a0865c80f47fb8e5dbe8830751f66bd8a06a3a1e06b7b2dec66556b532721018ce940c982953c8c6176125c7dd2ba1e8cb944e10e4a14905f7135a477810872518cbac085dfc69c1759d64dab5e225a5f16c" + } + } ], + "attester_slashings" : [ { + "attestation_1" : { + "attesting_indices" : [ "4590659586689121994", "4589007099177470570", "4580744678799082634" ], + "data" : { + "slot" : "4666673844721362956", + "index" : "4579092195582398506", + "beacon_block_root" : "0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c", + "source" : { + "epoch" : "533461240", + "root" : "0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565" + }, + "target" : { + "epoch" : "538462976", + "root" : "0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650" + } + }, + "signature" : "0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc" + }, + "attestation_2" : { + "attesting_indices" : [ "4590659586689121994", "4589007099177470570", "4580744678799082634" ], + "data" : { + "slot" : "4666673844721362956", + "index" : "4620404293179370891", + "beacon_block_root" : "0x4d1a19402bb984ca4d0005336ba05e1098babeeb0781f5744712934ae78b2a1b", + "source" : { + "epoch" : "538270602", + "root" : "0x27d82440eb21c640637a36dcc38e35768bb4c0c79aefa300ec0f0cba32cabb05" + }, + "target" : { + "epoch" : "537116355", + "root" : "0x999e0140abe701de220ca2e0b9c3b044b1c6ba33e0a3985dfe16a16b510f0846" + } + }, + "signature" : "0xa5a2ff076e82a9a8d46ce076787166c4b906aa200ee04bf91900422b5a36f6328f8009dfc9d08990317dd0041521166a0d889ef4a74f44f9a746e8e5284b98f0b8424966b4a0dd02f594c87539dc37309c6f0e3d011cbaf69fe0019064aa31f5" + } + } ], + "attestations" : [ { + "aggregation_bits" : "0x6c5787d841227ecd34f1542db62abbf53aea97471b8325493478e082560c1e8387957d483e80cc1b499ad63aa9b7d70cb17ac0ddb8edf9eba6a2a57d42c6ce4c24f604767d967e1b3a4847754b219e6230af479ced3030d8b2b32bba7e4edc0a0494a06256f21028eb424bedc468ad5591b3f74606d1dd14cd9ba071a89bb8adf512159c2bbec02f5d9c9f4a97fa086cfe5d797098847eb06c9fbf7c88c5c7938ca83d014045a1b38bc7de6bfc99e09083d2d431dd087a2c708dc2b3674c37abf741fa0c9d04681e4e3063ba68d0ddd5d2561f96ddcb4bbf9903dd595637f3f01edf7d13b99f4599423eabd3f404a9b8257933723bd7b8ac0cdcaf5b7fcf06e201", + "data" : { + "slot" : "4666673844721362956", + "index" : "4607184423150930571", + "beacon_block_root" : "0xe622ea3f2b167ff1f7173f8e08e70279cad2b67bb9c63b46b51baf8cba92e570", + "source" : { + "epoch" : "536731606", + "root" : "0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b" + }, + "target" : { + "epoch" : "529421377", + "root" : "0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2" + } + }, + "signature" : "0xa2dc478b0d8ae94e0ae80a0a080cffa09ce8c6b04e585f6dafa3378ba2ea842b26b87e8c01b4b0b9b2cb27eb069e48451082d929f5c57d35ca98829f9786409785a6aae97016f34fa1009046758893aeebdf5ed1a5c64bf9ba8d105075b94ffa" + }, { + "aggregation_bits" : "0xb8170c02376e2616e3bf89fd01dddeaf95362e5081d185fa9adb69f5bec17e22840f28947369dcdf2269436a8ffdfe7b90995dac664172d05e4992d1d40e8c59a5fc24b8bcdcd436af3f4fa98c1d3ce3a706e03f3c56085c1cc79dbbb84081cff70d85f6acbc292291bd8a96de104b9eb8d9d2235f6299a563224628dd3650ce817ca853e56f60ebc3ab6b0b3de977a673e84a07a823aa64628753bf0345297e7bcb6830e95c8e42b77896fab98d0b7e82217680a3aece1b571fd3c9beb57795ad8cb4f084da376677f2a65ae2c54b0a3ff1e02d0be7e8fac52df9b5ea009d5304e3f8a8c09dd9ae7c61a5e6f82c52b1db4395c1bf2ecbb3fb1fcf9a3eea178301", + "data" : { + "slot" : "4666673844721362956", + "index" : "4541085068713761673", + "beacon_block_root" : "0xe24dff3e29e762b4488e615619483884c44b8f4b37239b5cdc4a3bd7d9b48c1d", + "source" : { + "epoch" : "529036628", + "root" : "0xbb0b0b3fe94fa42a5e0893ff71360feab7459127ca9149e88148b44625f31d08" + }, + "target" : { + "epoch" : "527882381", + "root" : "0x2ed2e73ea915e0c71d9afe03676b8ab8dd578b9311463e45934f49f843386a48" + } + }, + "signature" : "0x958ab38cce5390fd750e87806f32ed8993a175bc3ccdab7ce2a40c23ac6117b603d5ae98d44a9780cca1f32d28bf5176058ef667b17fd95f13e047cd9cdebbf19f5270ec5a154e2ce2283da513c9ad05c26f10b0a65755eab4b1ed6f42175027" + }, { + "aggregation_bits" : "0x24d1c5fab49851c7c201280b68c618fc6c3d452daca5f28842e6552d9c48dfaf885b20878b227941e893133cf36f522950c8b2d3d7b11535c206cbbca299003b02d1c6a0b5d45a36a8255231fb0608cb14446a3d1a5da98420bf0eb68ee8e89e5ce6217585fd542af2ded46060587884a8adfecfc166cb87ea68b6a1132d66e13035bad94855645f07e70cf03d2e1775104e9be6239bd3943f3ac6b0c0da5ed8ed92ec7ce0be8bc0ff1d3872f0724fcc4fba54ee8b8a6e252e896b49e165cd70180b0a15786d403ae831c4662f38fbbac52c46b9f1ff844ce10b497662ea713ab13421065af7a461dd06c2aa2bbdd273a7fbe4a2e3f0380ae6b608856aec798e01", + "data" : { + "slot" : "4666673844721362956", + "index" : "4527865190095386761", + "beacon_block_root" : "0x7a56d03e29445ddbf2a59bb1b68edcecf66387dbea68e12d4a545719acbb4773", + "source" : { + "epoch" : "527497632", + "root" : "0x5414dc3ee9ac9e510720cd5a0e7db352e95d89b77dd78fb9ef51d088f8f9d85d" + }, + "target" : { + "epoch" : "532499368", + "root" : "0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947" + } + }, + "signature" : "0xb3f850563b31ed187d7da97a27bba835daa8b0409bd0d0472c4ae6363aa6fd326d8f10ab0e1e37941989dccb09993caf17d53bd752cd8bcb6061fe9b9d91151332641d1fc461f8f18f1dc092ea6734e719764f881c1937b227bfbecdc3a43041" + } ], + "deposits" : [ { + "proof" : [ "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31" ], + "data" : { + "pubkey" : "0xaed83e77fbc39e3b1115994cf6cffb5e12c8a60d6e5a511b8f4176f74660db30cc9acedb53d3288806420f903ab69157", + "withdrawal_credentials" : "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "amount" : "32000000000", + "signature" : "0x8072a19269ae28b7a2a44f5c558b9255ad1deda4384b33ecff3f3bd7af54cdfb4eb36a476c7bab5d894c90a283056a230acb8dcb7bb53ed0b0bdfa9dc89a8b4ffa23860f78e45e737917546e012a23df1e08033a7d21a134f9ea39022726f3d9" + } + } ], + "voluntary_exits" : [ { + "message" : { + "epoch" : "4569177291987326442", + "validator_index" : "4570829775204010570" + }, + "signature" : "0x8ab48d0165e8cc8bfc6804760141896946c3be751af5f16d1a03ead456ebceab88a8168e1da194df56c512edc15ca6350c413cb819d31a7ef69b329d8cb9fa8e5d93ae66289a445f1465d57d97e72d4c0866e48a806df7f58ebcd060e2d03a72" + } ], + "sync_aggregate" : { + "sync_committee_bits" : "0x01000000", + "sync_committee_signature" : "0xaa0f4b876c4fc52ca19c4905d49e329a88f907c3a07bb22f61c50e8e4f577ef468f0d4a1c3b0ec0123646b5f040d2c910380e5955c2e42fdfdc087ac66ef6097e607575c0db6529df1b1a0dc786e63f5268463672fcf0dd4aac7c9cf3cc98a43" + } + } + } + } +} \ No newline at end of file diff --git a/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairSyncCommitteeContributionAndProofExternalSignerMessage.json b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairSyncCommitteeContributionAndProofExternalSignerMessage.json new file mode 100644 index 00000000000..17e2e2f764d --- /dev/null +++ b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairSyncCommitteeContributionAndProofExternalSignerMessage.json @@ -0,0 +1,12 @@ +{ + "signingRoot" : "0x235bc3400c2839fd856a524871200bd5e362db615fc4565e1870ed9a2a936464", + "type" : "SYNC_COMMITTEE_CONTRIBUTION_AND_PROOF", + "fork_info" : { + "fork" : { + "previous_version" : "0x1f86d83f", + "current_version" : "0x32a7d23f", + "epoch" : "4603879456717562315" + }, + "genesis_validators_root" : "0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486" + } +} \ No newline at end of file diff --git a/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairSyncCommitteeMessageExternalSignerMessage.json b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairSyncCommitteeMessageExternalSignerMessage.json new file mode 100644 index 00000000000..f7ff84b970e --- /dev/null +++ b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairSyncCommitteeMessageExternalSignerMessage.json @@ -0,0 +1,16 @@ +{ + "signingRoot" : "0x235bc3400c2839fd856a524871200bd5e362db615fc4565e1870ed9a2a936464", + "type" : "SYNC_COMMITTEE_MESSAGE", + "fork_info" : { + "fork" : { + "previous_version" : "0x103ac940", + "current_version" : "0x6fdfab40", + "epoch" : "4658411424342975020" + }, + "genesis_validators_root" : "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + }, + "sync_committee_message" : { + "slot" : "31724849254", + "beacon_block_root" : "0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef" + } +} \ No newline at end of file diff --git a/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairSyncCommitteeSelectionProofExternalSignerMessage.json b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairSyncCommitteeSelectionProofExternalSignerMessage.json new file mode 100644 index 00000000000..734c82ea2ae --- /dev/null +++ b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairSyncCommitteeSelectionProofExternalSignerMessage.json @@ -0,0 +1,12 @@ +{ + "signingRoot" : "0x235bc3400c2839fd856a524871200bd5e362db615fc4565e1870ed9a2a936464", + "type" : "SYNC_COMMITTEE_SELECTION_PROOF", + "fork_info" : { + "fork" : { + "previous_version" : "0x103ac940", + "current_version" : "0x6fdfab40", + "epoch" : "4658411424342975020" + }, + "genesis_validators_root" : "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + } +} \ No newline at end of file diff --git a/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairValidatorRegistrationExternalSignerMessage.json b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairValidatorRegistrationExternalSignerMessage.json new file mode 100644 index 00000000000..fa603ff6866 --- /dev/null +++ b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairValidatorRegistrationExternalSignerMessage.json @@ -0,0 +1,10 @@ +{ + "signingRoot" : "0x235bc3400c2839fd856a524871200bd5e362db615fc4565e1870ed9a2a936464", + "type" : "VALIDATOR_REGISTRATION", + "validator_registration" : { + "fee_recipient" : "0x367cbd40ac7318427aadb97345a91fa2e965daf3", + "gas_limit" : "4669978815449698508", + "timestamp" : "4668326327938047084", + "pubkey" : "0xb7d6cb9ce7397c33b89ec57de0de383c7c294687b8963f92cc60f59bb1de46c56623cd24c9cc1e407db92d1a79920887" + } +} \ No newline at end of file diff --git a/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairVoluntaryExitExternalSignerMessage.json b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairVoluntaryExitExternalSignerMessage.json new file mode 100644 index 00000000000..d5d17ca5e6d --- /dev/null +++ b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/altairVoluntaryExitExternalSignerMessage.json @@ -0,0 +1,16 @@ +{ + "signingRoot" : "0x235bc3400c2839fd856a524871200bd5e362db615fc4565e1870ed9a2a936464", + "type" : "VOLUNTARY_EXIT", + "voluntary_exit" : { + "epoch" : "4669978815449698508", + "validator_index" : "4665021361504678828" + }, + "fork_info" : { + "fork" : { + "previous_version" : "0x103ac940", + "current_version" : "0x6fdfab40", + "epoch" : "4658411424342975020" + }, + "genesis_validators_root" : "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + } +} \ No newline at end of file diff --git a/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/bellatrixBlockExternalSignerMessage.json b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/bellatrixBlockExternalSignerMessage.json new file mode 100644 index 00000000000..5d83f6b60cb --- /dev/null +++ b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/bellatrixBlockExternalSignerMessage.json @@ -0,0 +1,22 @@ +{ + "signingRoot" : "0x3f9c1cc3af54c94ee8a677aee350bb772b00c3864b7dfdd34ffaf6ab004d1f0a", + "type" : "BLOCK_V2", + "fork_info" : { + "fork" : { + "previous_version" : "0x003ea73e", + "current_version" : "0x135fa13e", + "epoch" : "4517950290795281992" + }, + "genesis_validators_root" : "0xed1cad3ee8099978b13707b6acc357bb1b768147301dd68a5d5beccacb0094b3" + }, + "beacon_block" : { + "version" : "BELLATRIX", + "block_header" : { + "slot" : "4666673844721362956", + "proposer_index" : "4665021361504678828", + "parent_root" : "0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e", + "state_root" : "0x103ac9406cdc59b89027eb1c9e97f607dd5fdccfa8fb2da4eaeea9d25032add9", + "body_root" : "0xada3b1be6d79e8300c701822a4358a8e8d323c74cf16dbd998db63273f032b34" + } + } +} \ No newline at end of file diff --git a/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/phase0AttestationExternalSignerMessage.json b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/phase0AttestationExternalSignerMessage.json new file mode 100644 index 00000000000..545df17e560 --- /dev/null +++ b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/phase0AttestationExternalSignerMessage.json @@ -0,0 +1,25 @@ +{ + "signingRoot" : "0x235bc3400c2839fd856a524871200bd5e362db615fc4565e1870ed9a2a936464", + "type" : "ATTESTATION", + "fork_info" : { + "fork" : { + "previous_version" : "0x1f86d83f", + "current_version" : "0x32a7d23f", + "epoch" : "4603879456717562315" + }, + "genesis_validators_root" : "0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486" + }, + "attestation" : { + "slot" : "4665021361504678828", + "index" : "4669978815449698508", + "beacon_block_root" : "0x103ac9406cdc59b89027eb1c9e97f607dd5fdccfa8fb2da4eaeea9d25032add9", + "source" : { + "epoch" : "542502839", + "root" : "0x8200a6402ca295554fb9562193cc71d60272d63beeaf2201fdf53e846e77f919" + }, + "target" : { + "epoch" : "542887588", + "root" : "0x5cbeb140ec0ad7cb653388caecba483cf66bd817821ed18ca1f3b7f3b9b58a04" + } + } +} \ No newline at end of file diff --git a/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/phase0BlockExternalSignerMessage.json b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/phase0BlockExternalSignerMessage.json new file mode 100644 index 00000000000..d2d05b425eb --- /dev/null +++ b/validator/client/src/test/resources/tech/pegasys/teku/validator/client/signer/phase0BlockExternalSignerMessage.json @@ -0,0 +1,150 @@ +{ + "signingRoot" : "0xc747a36df80fa5efd7ac834916c868c6b6cb8c7c55a875221af7380d100e0c4a", + "type" : "BLOCK", + "fork_info" : { + "fork" : { + "previous_version" : "0xfcc0453f", + "current_version" : "0xc35d573f", + "epoch" : "4562567354825622634" + }, + "genesis_validators_root" : "0x3624343f893e8948a933c0cfa8787f4e8c309829ce142cd140c0dbcc2c4d1a3d" + }, + "block" : { + "slot" : "4666673844721362956", + "proposer_index" : "4665021361504678828", + "parent_root" : "0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e", + "state_root" : "0x103ac9406cdc59b89027eb1c9e97f607dd5fdccfa8fb2da4eaeea9d25032add9", + "body" : { + "randao_reveal" : "0x983e008a34dda42f0c8f857f66aa82212aff48250f9ac54b30ae622d0835bdb7609c9cac67e7d19be24ffe5c77d581230e25c0e72fdf4066618bb0df7e09e66562de35b1f751004ad1ec65089c19a56a8b120983c301dbbf03df5ba674712ab4", + "eth1_data" : { + "deposit_root" : "0x8200a6402ca295554fb9562193cc71d60272d63beeaf2201fdf53e846e77f919", + "deposit_count" : "4663368873993027404", + "block_hash" : "0x5cbeb140ec0ad7cb653388caecba483cf66bd817821ed18ca1f3b7f3b9b58a04" + }, + "graffiti" : "0x0000000000000000000000000000000000000000000000000000000000000000", + "proposer_slashings" : [ { + "signed_header_1" : { + "message" : { + "slot" : "4600574485989226763", + "proposer_index" : "4598922002772542634", + "parent_root" : "0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb", + "state_root" : "0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486", + "body_root" : "0x6b0ac13f8a279ad3abec11bed1a49214f6e7af79b643595df6a38706b338e93b" + }, + "signature" : "0x860cc33a81805835339f1598b95691556b6f4fc5ee6a25bb24d70c658dc69d3d2e5cd62a22e14e7d962a4095e0d93ea41240a49151f9bb2884bdd1cdefcff246969101fe377460d78d58ea47c2f270e9cc8ce4bc4e81e43314bda61076350d4d" + }, + "signed_header_2" : { + "message" : { + "slot" : "4600574485989226763", + "proposer_index" : "4598922002772542634", + "parent_root" : "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "state_root" : "0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1", + "body_root" : "0xb88ea93f0a5617e780f8ae6b1fc8e4480ff4abc18f66fc45ada895271cbcc666" + }, + "signature" : "0xb8f4f7eb7f1ff3eb3923e6bf36b3a0865c80f47fb8e5dbe8830751f66bd8a06a3a1e06b7b2dec66556b532721018ce940c982953c8c6176125c7dd2ba1e8cb944e10e4a14905f7135a477810872518cbac085dfc69c1759d64dab5e225a5f16c" + } + } ], + "attester_slashings" : [ { + "attestation_1" : { + "attesting_indices" : [ "4590659586689121994", "4589007099177470570", "4580744678799082634" ], + "data" : { + "slot" : "4666673844721362956", + "index" : "4579092195582398506", + "beacon_block_root" : "0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c", + "source" : { + "epoch" : "533461240", + "root" : "0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565" + }, + "target" : { + "epoch" : "538462976", + "root" : "0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650" + } + }, + "signature" : "0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc" + }, + "attestation_2" : { + "attesting_indices" : [ "4590659586689121994", "4589007099177470570", "4580744678799082634" ], + "data" : { + "slot" : "4666673844721362956", + "index" : "4620404293179370891", + "beacon_block_root" : "0x4d1a19402bb984ca4d0005336ba05e1098babeeb0781f5744712934ae78b2a1b", + "source" : { + "epoch" : "538270602", + "root" : "0x27d82440eb21c640637a36dcc38e35768bb4c0c79aefa300ec0f0cba32cabb05" + }, + "target" : { + "epoch" : "537116355", + "root" : "0x999e0140abe701de220ca2e0b9c3b044b1c6ba33e0a3985dfe16a16b510f0846" + } + }, + "signature" : "0xa5a2ff076e82a9a8d46ce076787166c4b906aa200ee04bf91900422b5a36f6328f8009dfc9d08990317dd0041521166a0d889ef4a74f44f9a746e8e5284b98f0b8424966b4a0dd02f594c87539dc37309c6f0e3d011cbaf69fe0019064aa31f5" + } + } ], + "attestations" : [ { + "aggregation_bits" : "0x6c5787d841227ecd34f1542db62abbf53aea97471b8325493478e082560c1e8387957d483e80cc1b499ad63aa9b7d70cb17ac0ddb8edf9eba6a2a57d42c6ce4c24f604767d967e1b3a4847754b219e6230af479ced3030d8b2b32bba7e4edc0a0494a06256f21028eb424bedc468ad5591b3f74606d1dd14cd9ba071a89bb8adf512159c2bbec02f5d9c9f4a97fa086cfe5d797098847eb06c9fbf7c88c5c7938ca83d014045a1b38bc7de6bfc99e09083d2d431dd087a2c708dc2b3674c37abf741fa0c9d04681e4e3063ba68d0ddd5d2561f96ddcb4bbf9903dd595637f3f01edf7d13b99f4599423eabd3f404a9b8257933723bd7b8ac0cdcaf5b7fcf06e201", + "data" : { + "slot" : "4666673844721362956", + "index" : "4607184423150930571", + "beacon_block_root" : "0xe622ea3f2b167ff1f7173f8e08e70279cad2b67bb9c63b46b51baf8cba92e570", + "source" : { + "epoch" : "536731606", + "root" : "0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b" + }, + "target" : { + "epoch" : "529421377", + "root" : "0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2" + } + }, + "signature" : "0xa2dc478b0d8ae94e0ae80a0a080cffa09ce8c6b04e585f6dafa3378ba2ea842b26b87e8c01b4b0b9b2cb27eb069e48451082d929f5c57d35ca98829f9786409785a6aae97016f34fa1009046758893aeebdf5ed1a5c64bf9ba8d105075b94ffa" + }, { + "aggregation_bits" : "0xb8170c02376e2616e3bf89fd01dddeaf95362e5081d185fa9adb69f5bec17e22840f28947369dcdf2269436a8ffdfe7b90995dac664172d05e4992d1d40e8c59a5fc24b8bcdcd436af3f4fa98c1d3ce3a706e03f3c56085c1cc79dbbb84081cff70d85f6acbc292291bd8a96de104b9eb8d9d2235f6299a563224628dd3650ce817ca853e56f60ebc3ab6b0b3de977a673e84a07a823aa64628753bf0345297e7bcb6830e95c8e42b77896fab98d0b7e82217680a3aece1b571fd3c9beb57795ad8cb4f084da376677f2a65ae2c54b0a3ff1e02d0be7e8fac52df9b5ea009d5304e3f8a8c09dd9ae7c61a5e6f82c52b1db4395c1bf2ecbb3fb1fcf9a3eea178301", + "data" : { + "slot" : "4666673844721362956", + "index" : "4541085068713761673", + "beacon_block_root" : "0xe24dff3e29e762b4488e615619483884c44b8f4b37239b5cdc4a3bd7d9b48c1d", + "source" : { + "epoch" : "529036628", + "root" : "0xbb0b0b3fe94fa42a5e0893ff71360feab7459127ca9149e88148b44625f31d08" + }, + "target" : { + "epoch" : "527882381", + "root" : "0x2ed2e73ea915e0c71d9afe03676b8ab8dd578b9311463e45934f49f843386a48" + } + }, + "signature" : "0x958ab38cce5390fd750e87806f32ed8993a175bc3ccdab7ce2a40c23ac6117b603d5ae98d44a9780cca1f32d28bf5176058ef667b17fd95f13e047cd9cdebbf19f5270ec5a154e2ce2283da513c9ad05c26f10b0a65755eab4b1ed6f42175027" + }, { + "aggregation_bits" : "0x24d1c5fab49851c7c201280b68c618fc6c3d452daca5f28842e6552d9c48dfaf885b20878b227941e893133cf36f522950c8b2d3d7b11535c206cbbca299003b02d1c6a0b5d45a36a8255231fb0608cb14446a3d1a5da98420bf0eb68ee8e89e5ce6217585fd542af2ded46060587884a8adfecfc166cb87ea68b6a1132d66e13035bad94855645f07e70cf03d2e1775104e9be6239bd3943f3ac6b0c0da5ed8ed92ec7ce0be8bc0ff1d3872f0724fcc4fba54ee8b8a6e252e896b49e165cd70180b0a15786d403ae831c4662f38fbbac52c46b9f1ff844ce10b497662ea713ab13421065af7a461dd06c2aa2bbdd273a7fbe4a2e3f0380ae6b608856aec798e01", + "data" : { + "slot" : "4666673844721362956", + "index" : "4527865190095386761", + "beacon_block_root" : "0x7a56d03e29445ddbf2a59bb1b68edcecf66387dbea68e12d4a545719acbb4773", + "source" : { + "epoch" : "527497632", + "root" : "0x5414dc3ee9ac9e510720cd5a0e7db352e95d89b77dd78fb9ef51d088f8f9d85d" + }, + "target" : { + "epoch" : "532499368", + "root" : "0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947" + } + }, + "signature" : "0xb3f850563b31ed187d7da97a27bba835daa8b0409bd0d0472c4ae6363aa6fd326d8f10ab0e1e37941989dccb09993caf17d53bd752cd8bcb6061fe9b9d91151332641d1fc461f8f18f1dc092ea6734e719764f881c1937b227bfbecdc3a43041" + } ], + "deposits" : [ { + "proof" : [ "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31", "0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31" ], + "data" : { + "pubkey" : "0xaed83e77fbc39e3b1115994cf6cffb5e12c8a60d6e5a511b8f4176f74660db30cc9acedb53d3288806420f903ab69157", + "withdrawal_credentials" : "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "amount" : "32000000000", + "signature" : "0x8072a19269ae28b7a2a44f5c558b9255ad1deda4384b33ecff3f3bd7af54cdfb4eb36a476c7bab5d894c90a283056a230acb8dcb7bb53ed0b0bdfa9dc89a8b4ffa23860f78e45e737917546e012a23df1e08033a7d21a134f9ea39022726f3d9" + } + } ], + "voluntary_exits" : [ { + "message" : { + "epoch" : "4569177291987326442", + "validator_index" : "4570829775204010570" + }, + "signature" : "0x8ab48d0165e8cc8bfc6804760141896946c3be751af5f16d1a03ead456ebceab88a8168e1da194df56c512edc15ca6350c413cb819d31a7ef69b329d8cb9fa8e5d93ae66289a445f1465d57d97e72d4c0866e48a806df7f58ebcd060e2d03a72" + } ] + } + } +} \ No newline at end of file diff --git a/validator/eventadapter/build.gradle b/validator/eventadapter/build.gradle index 7548edfc9f9..400d88b2973 100644 --- a/validator/eventadapter/build.gradle +++ b/validator/eventadapter/build.gradle @@ -11,7 +11,7 @@ dependencies { implementation project(':validator:api') implementation project(':validator:beaconnode') - implementation 'org.apache.tuweni:tuweni-bytes' + implementation 'io.tmio:tuweni-bytes' implementation 'com.google.guava:guava' implementation 'org.apache.logging.log4j:log4j-api' diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/apiclient/OkHttpValidatorRestApiClientTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/apiclient/OkHttpValidatorRestApiClientTest.java deleted file mode 100644 index 02659f25a61..00000000000 --- a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/apiclient/OkHttpValidatorRestApiClientTest.java +++ /dev/null @@ -1,508 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.validator.remote.apiclient; - -import static java.util.Collections.emptyList; -import static java.util.Collections.emptyMap; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.assertThatThrownBy; -import static org.junit.jupiter.api.Assertions.fail; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; - -import com.fasterxml.jackson.core.JsonProcessingException; -import java.nio.charset.StandardCharsets; -import java.util.List; -import java.util.Optional; -import java.util.Set; -import okhttp3.HttpUrl; -import okhttp3.OkHttpClient; -import okhttp3.mockwebserver.MockResponse; -import okhttp3.mockwebserver.MockWebServer; -import okhttp3.mockwebserver.RecordedRequest; -import org.apache.tuweni.bytes.Bytes32; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import tech.pegasys.teku.api.response.v1.beacon.GetGenesisResponse; -import tech.pegasys.teku.api.response.v1.beacon.GetStateValidatorsResponse; -import tech.pegasys.teku.api.response.v1.beacon.PostDataFailure; -import tech.pegasys.teku.api.response.v1.beacon.PostDataFailureResponse; -import tech.pegasys.teku.api.response.v1.beacon.ValidatorResponse; -import tech.pegasys.teku.api.response.v1.validator.GetAggregatedAttestationResponse; -import tech.pegasys.teku.api.response.v1.validator.GetSyncCommitteeContributionResponse; -import tech.pegasys.teku.api.schema.Attestation; -import tech.pegasys.teku.api.schema.SignedAggregateAndProof; -import tech.pegasys.teku.api.schema.SignedVoluntaryExit; -import tech.pegasys.teku.api.schema.SubnetSubscription; -import tech.pegasys.teku.api.schema.altair.SyncCommitteeContribution; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.provider.JsonProvider; -import tech.pegasys.teku.validator.api.CommitteeSubscriptionRequest; - -class OkHttpValidatorRestApiClientTest { - - private final SchemaObjectsTestFixture schemaObjects = new SchemaObjectsTestFixture(); - private final JsonProvider jsonProvider = new JsonProvider(); - private final MockWebServer mockWebServer = new MockWebServer(); - private OkHttpValidatorRestApiClient apiClient; - private OkHttpClient okHttpClient; - - @BeforeEach - public void beforeEach() throws Exception { - mockWebServer.start(); - okHttpClient = new OkHttpClient(); - apiClient = new OkHttpValidatorRestApiClient(mockWebServer.url("/"), okHttpClient); - } - - @AfterEach - public void afterEach() throws Exception { - mockWebServer.shutdown(); - } - - @Test - public void getGenesis_MakesExpectedRequest() throws Exception { - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); - - apiClient.getGenesis(); - - RecordedRequest request = mockWebServer.takeRequest(); - - assertThat(request.getMethod()).isEqualTo("GET"); - assertThat(request.getPath()).contains(ValidatorApiMethod.GET_GENESIS.getPath(emptyMap())); - } - - @Test - public void getGenesis_WhenServerError_ThrowsRuntimeException() { - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); - - assertThatThrownBy(() -> apiClient.getGenesis()) - .isInstanceOf(RuntimeException.class) - .hasMessageContaining("Unexpected response from Beacon Node API"); - } - - @Test - public void getGenesis_WhenNoContent_ReturnsEmpty() { - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); - - assertThat(apiClient.getGenesis()).isEmpty(); - } - - @Test - public void getGenesis_WhenSuccess_ReturnsGenesisResponse() { - final GetGenesisResponse getGenesisResponse = schemaObjects.getGenesisResponse(); - - mockWebServer.enqueue( - new MockResponse().setResponseCode(SC_OK).setBody(asJson(getGenesisResponse))); - - Optional genesis = apiClient.getGenesis(); - - assertThat(genesis).isPresent(); - assertThat(genesis.get()).usingRecursiveComparison().isEqualTo(getGenesisResponse); - } - - @Test - void getValidators_MakesExpectedRequest() throws Exception { - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); - - apiClient.getValidators(List.of("1", "0x1234")); - - final RecordedRequest request = mockWebServer.takeRequest(); - assertThat(request.getMethod()).isEqualTo("GET"); - assertThat(request.getPath()).contains(ValidatorApiMethod.GET_VALIDATORS.getPath(emptyMap())); - assertThat(request.getPath()).contains("?id=1,0x1234"); - } - - @Test - public void getValidators_WhenNoContent_ReturnsEmpty() { - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); - - assertThat(apiClient.getValidators(List.of("1"))).isEmpty(); - } - - @Test - public void getValidators_WhenSuccess_ReturnsResponse() { - final List expected = - List.of(schemaObjects.validatorResponse(), schemaObjects.validatorResponse()); - final GetStateValidatorsResponse response = new GetStateValidatorsResponse(false, expected); - - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK).setBody(asJson(response))); - - Optional> result = apiClient.getValidators(List.of("1", "2")); - - assertThat(result).isPresent(); - assertThat(result.get()).usingRecursiveComparison().isEqualTo(expected); - } - - @Test - public void sendVoluntaryExit_makesExpectedRequest() throws Exception { - final SignedVoluntaryExit exit = schemaObjects.signedVoluntaryExit(); - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK)); - - apiClient.sendVoluntaryExit(exit); - RecordedRequest request = mockWebServer.takeRequest(); - - assertThat(request.getMethod()).isEqualTo("POST"); - assertThat(request.getPath()) - .contains(ValidatorApiMethod.SEND_SIGNED_VOLUNTARY_EXIT.getPath(emptyMap())); - assertThat(request.getBody().readString(StandardCharsets.UTF_8)).isEqualTo(asJson(exit)); - } - - @Test - public void sendSignedAttestation_MakesExpectedRequest() throws Exception { - final Attestation attestation = schemaObjects.attestation(); - - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK)); - - apiClient.sendSignedAttestations(List.of(attestation)); - - RecordedRequest request = mockWebServer.takeRequest(); - - assertThat(request.getMethod()).isEqualTo("POST"); - assertThat(request.getPath()) - .contains(ValidatorApiMethod.SEND_SIGNED_ATTESTATION.getPath(emptyMap())); - assertThat(request.getBody().readString(StandardCharsets.UTF_8)) - .isEqualTo(asJson(List.of(attestation))); - } - - @Test - public void sendSignedAttestation_WhenBadParameters_ThrowsIllegalArgumentException() { - final Attestation attestation = schemaObjects.attestation(); - - final PostDataFailureResponse response = - new PostDataFailureResponse( - SC_BAD_REQUEST, "Computer said no", List.of(new PostDataFailure(UInt64.ZERO, "Bad"))); - mockWebServer.enqueue( - new MockResponse().setResponseCode(SC_BAD_REQUEST).setBody(asJson(response))); - - assertThat(apiClient.sendSignedAttestations(List.of(attestation))) - .isPresent() - .get() - .usingRecursiveComparison() - .isEqualTo(response); - } - - @Test - public void sendSignedAttestation_WhenServerError_ThrowsRuntimeException() { - final Attestation attestation = schemaObjects.attestation(); - - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); - - assertThatThrownBy(() -> apiClient.sendSignedAttestations(List.of(attestation))) - .isInstanceOf(RuntimeException.class) - .hasMessageContaining("Unexpected response from Beacon Node API"); - } - - @Test - public void createAggregate_MakesExpectedRequest() throws Exception { - final UInt64 slot = UInt64.valueOf(323); - final Bytes32 attestationHashTreeRoot = Bytes32.random(); - - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); - - apiClient.createAggregate(slot, attestationHashTreeRoot); - - RecordedRequest request = mockWebServer.takeRequest(); - - assertThat(request.getMethod()).isEqualTo("GET"); - assertThat(request.getPath()).contains(ValidatorApiMethod.GET_AGGREGATE.getPath(emptyMap())); - assertThat(request.getRequestUrl().queryParameter("slot")).isEqualTo(slot.toString()); - assertThat(request.getRequestUrl().queryParameter("attestation_data_root")) - .isEqualTo(attestationHashTreeRoot.toHexString()); - } - - @Test - public void createAggregate_WhenBadParameters_ThrowsIllegalArgumentException() { - final Bytes32 attestationHashTreeRoot = Bytes32.random(); - - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); - - assertThatThrownBy(() -> apiClient.createAggregate(UInt64.ONE, attestationHashTreeRoot)) - .isInstanceOf(IllegalArgumentException.class); - } - - @Test - public void createAggregate_WhenNotFound_ReturnsEmpty() { - final Bytes32 attestationHashTreeRoot = Bytes32.random(); - - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NOT_FOUND)); - - assertThat(apiClient.createAggregate(UInt64.ONE, attestationHashTreeRoot)).isEmpty(); - } - - @Test - public void createAggregate_WhenServerError_ThrowsRuntimeException() { - final Bytes32 attestationHashTreeRoot = Bytes32.random(); - - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); - - assertThatThrownBy(() -> apiClient.createAggregate(UInt64.ONE, attestationHashTreeRoot)) - .isInstanceOf(RuntimeException.class) - .hasMessageContaining("Unexpected response from Beacon Node API"); - } - - @Test - public void createAggregate_WhenSuccess_ReturnsAttestation() { - final Bytes32 attestationHashTreeRoot = Bytes32.random(); - final Attestation expectedAttestation = schemaObjects.attestation(); - - mockWebServer.enqueue( - new MockResponse() - .setResponseCode(SC_OK) - .setBody(asJson(new GetAggregatedAttestationResponse(expectedAttestation)))); - - final Optional attestation = - apiClient.createAggregate(UInt64.ONE, attestationHashTreeRoot); - - assertThat(attestation).isPresent(); - assertThat(attestation.get()).usingRecursiveComparison().isEqualTo(expectedAttestation); - } - - @Test - public void createSyncCommitteeContribution_WhenSuccess_ReturnsContribution() { - final SyncCommitteeContribution contribution = - schemaObjects.syncCommitteeContribution(UInt64.ONE); - - mockWebServer.enqueue( - new MockResponse() - .setResponseCode(SC_OK) - .setBody(asJson(new GetSyncCommitteeContributionResponse(contribution)))); - - final Optional response = - apiClient.createSyncCommitteeContribution( - contribution.slot, - contribution.subcommitteeIndex.intValue(), - contribution.beaconBlockRoot); - - assertThat(response).isPresent(); - assertThat(response.get()).usingRecursiveComparison().isEqualTo(contribution); - } - - @Test - public void createSyncCommitteeContribution_WhenNotFound_ReturnsEmpty() { - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NOT_FOUND)); - - assertThat(apiClient.createSyncCommitteeContribution(UInt64.ONE, 0, Bytes32.ZERO)).isEmpty(); - } - - @Test - public void sendAggregateAndProofs_MakesExpectedRequest() throws Exception { - final SignedAggregateAndProof signedAggregateAndProof = schemaObjects.signedAggregateAndProof(); - - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK)); - - apiClient.sendAggregateAndProofs(List.of(signedAggregateAndProof)); - - RecordedRequest request = mockWebServer.takeRequest(); - - assertThat(request.getMethod()).isEqualTo("POST"); - assertThat(request.getPath()) - .contains(ValidatorApiMethod.SEND_SIGNED_AGGREGATE_AND_PROOF.getPath(emptyMap())); - assertThat(request.getBody().readString(StandardCharsets.UTF_8)) - .isEqualTo(asJson(List.of(signedAggregateAndProof))); - } - - @Test - public void sendAggregateAndProofs_WhenBadParameters_ReturnsErrorResponse() { - final SignedAggregateAndProof signedAggregateAndProof = schemaObjects.signedAggregateAndProof(); - - final PostDataFailureResponse response = - new PostDataFailureResponse( - SC_BAD_REQUEST, "Computer said no", List.of(new PostDataFailure(UInt64.ZERO, "Bad"))); - mockWebServer.enqueue( - new MockResponse().setResponseCode(SC_BAD_REQUEST).setBody(asJson(response))); - - assertThat(apiClient.sendAggregateAndProofs(List.of(signedAggregateAndProof))) - .isPresent() - .get() - .usingRecursiveComparison() - .isEqualTo(response); - } - - @Test - public void sendAggregateAndProofs_WhenServerError_ThrowsRuntimeException() { - final SignedAggregateAndProof signedAggregateAndProof = schemaObjects.signedAggregateAndProof(); - - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); - - assertThatThrownBy(() -> apiClient.sendAggregateAndProofs(List.of(signedAggregateAndProof))) - .isInstanceOf(RuntimeException.class) - .hasMessageContaining("Unexpected response from Beacon Node API"); - } - - @Test - public void subscribeToBeaconCommitteeForAggregation_MakesExpectedRequest() throws Exception { - final int committeeIndex1 = 1; - final int validatorIndex1 = 6; - final UInt64 committeesAtSlot1 = UInt64.valueOf(10); - final UInt64 slot1 = UInt64.valueOf(15); - final boolean aggregator1 = true; - - final int committeeIndex2 = 2; - final int validatorIndex2 = 7; - final UInt64 committeesAtSlot2 = UInt64.valueOf(11); - final UInt64 slot2 = UInt64.valueOf(16); - final boolean aggregator2 = false; - - final String expectedRequest = - "[{\"validator_index\":\"6\",\"committee_index\":\"1\",\"committees_at_slot\":\"10\",\"slot\":\"15\",\"is_aggregator\":true}," - + "{\"validator_index\":\"7\",\"committee_index\":\"2\",\"committees_at_slot\":\"11\",\"slot\":\"16\",\"is_aggregator\":false}]"; - - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK)); - - apiClient.subscribeToBeaconCommittee( - List.of( - new CommitteeSubscriptionRequest( - validatorIndex1, committeeIndex1, committeesAtSlot1, slot1, aggregator1), - new CommitteeSubscriptionRequest( - validatorIndex2, committeeIndex2, committeesAtSlot2, slot2, aggregator2))); - - RecordedRequest request = mockWebServer.takeRequest(); - - assertThat(request.getMethod()).isEqualTo("POST"); - assertThat(request.getPath()) - .contains(ValidatorApiMethod.SUBSCRIBE_TO_BEACON_COMMITTEE_SUBNET.getPath(emptyMap())); - assertThat(request.getBody().readUtf8()).isEqualTo(expectedRequest); - } - - @Test - public void - subscribeToBeaconCommitteeForAggregation_WhenBadRequest_ThrowsIllegalArgumentException() { - final int committeeIndex = 1; - final UInt64 aggregationSlot = UInt64.ONE; - - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); - - assertThatThrownBy( - () -> - apiClient.subscribeToBeaconCommittee( - List.of( - new CommitteeSubscriptionRequest( - 1, committeeIndex, UInt64.valueOf(10), aggregationSlot, true)))) - .isInstanceOf(IllegalArgumentException.class); - } - - @Test - public void subscribeToBeaconCommitteeForAggregation_WhenServerError_ThrowsRuntimeException() { - final int committeeIndex = 1; - final UInt64 aggregationSlot = UInt64.ONE; - - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); - - assertThatThrownBy( - () -> - apiClient.subscribeToBeaconCommittee( - List.of( - new CommitteeSubscriptionRequest( - 1, committeeIndex, UInt64.valueOf(10), aggregationSlot, true)))) - .isInstanceOf(RuntimeException.class) - .hasMessageContaining("Unexpected response from Beacon Node API"); - } - - @Test - public void subscribeToPersistentSubnets_MakesExpectedRequest() throws Exception { - final Set subnetSubscriptions = Set.of(schemaObjects.subnetSubscription()); - - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK)); - - apiClient.subscribeToPersistentSubnets(subnetSubscriptions); - - RecordedRequest request = mockWebServer.takeRequest(); - - assertThat(request.getMethod()).isEqualTo("POST"); - assertThat(request.getPath()) - .contains(ValidatorApiMethod.SUBSCRIBE_TO_PERSISTENT_SUBNETS.getPath(emptyMap())); - assertThat(request.getBody().readString(StandardCharsets.UTF_8)) - .isEqualTo(asJson(subnetSubscriptions)); - } - - @Test - public void subscribeToPersistentSubnets_WhenBadRequest_ThrowsIllegalArgumentException() { - final Set subnetSubscriptions = Set.of(schemaObjects.subnetSubscription()); - - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); - assertThatThrownBy(() -> apiClient.subscribeToPersistentSubnets(subnetSubscriptions)) - .isInstanceOf(IllegalArgumentException.class); - } - - @Test - public void subscribeToPersistentSubnets_WhenServerError_ThrowsRuntimeException() { - final Set subnetSubscriptions = Set.of(schemaObjects.subnetSubscription()); - - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); - - assertThatThrownBy(() -> apiClient.subscribeToPersistentSubnets(subnetSubscriptions)) - .isInstanceOf(RuntimeException.class) - .hasMessageContaining("Unexpected response from Beacon Node API"); - } - - @Test - void shouldIncludeAuthorizationHeaderWhenBaseUrlIncludesCredentialsForGetRequest() - throws Exception { - final HttpUrl url = - mockWebServer.url("/").newBuilder().username("user").password("password").build(); - apiClient = new OkHttpValidatorRestApiClient(url, okHttpClient); - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); - - apiClient.getGenesis(); - - RecordedRequest request = mockWebServer.takeRequest(); - - assertThat(request.getMethod()).isEqualTo("GET"); - final String authorization = request.getHeader("Authorization"); - // Base64 encoded version of credentials. - assertThat(authorization).isEqualTo("Basic dXNlcjpwYXNzd29yZA=="); - } - - @Test - void shouldThrowRateLimitedExceptionWhen429ResponseReceived() { - mockWebServer.enqueue(new MockResponse().setResponseCode(429)); - - assertThatThrownBy(() -> apiClient.getGenesis()).isInstanceOf(RateLimitedException.class); - } - - @Test - void sendSyncCommitteeMessages_shouldReturnEmptyWhenResponseIsOk() { - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK)); - - assertThat(apiClient.sendSyncCommitteeMessages(emptyList())).isEmpty(); - } - - @Test - void sendSyncCommitteeMessages_shouldReturnErrorsFromBadResponse() { - final PostDataFailureResponse response = - new PostDataFailureResponse( - SC_BAD_REQUEST, "Computer said no", List.of(new PostDataFailure(UInt64.ZERO, "Bad"))); - mockWebServer.enqueue( - new MockResponse().setResponseCode(SC_BAD_REQUEST).setBody(asJson(response))); - - assertThat(apiClient.sendSyncCommitteeMessages(emptyList())) - .isPresent() - .get() - .usingRecursiveComparison() - .isEqualTo(response); - } - - private String asJson(Object object) { - try { - return jsonProvider.objectToJSON(object); - } catch (JsonProcessingException e) { - fail("Error conversing object to json", e); - return ""; - } - } -} diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/AbstractTypeDefRequestTestBase.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/AbstractTypeDefRequestTestBase.java index 5adbac41c53..86aa2a861c0 100644 --- a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/AbstractTypeDefRequestTestBase.java +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/AbstractTypeDefRequestTestBase.java @@ -15,6 +15,7 @@ import static tech.pegasys.teku.ethereum.json.types.SharedApiTypes.withDataWrapper; +import com.fasterxml.jackson.databind.ObjectMapper; import com.google.common.io.Resources; import java.io.IOException; import java.io.UncheckedIOException; @@ -26,7 +27,6 @@ import tech.pegasys.teku.infrastructure.json.JsonUtil; import tech.pegasys.teku.infrastructure.ssz.SszData; import tech.pegasys.teku.infrastructure.ssz.schema.SszSchema; -import tech.pegasys.teku.provider.JsonProvider; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.TestSpecInvocationContextProvider.SpecContext; @@ -39,7 +39,7 @@ public class AbstractTypeDefRequestTestBase { protected static final String JSON_CONTENT_TYPE = "application/json; charset=utf-8"; protected static final String OCTET_STREAM_CONTENT_TYPE = "application/octet-stream"; - protected static final JsonProvider JSON_PROVIDER = new JsonProvider(); + protected static final ObjectMapper OBJECT_MAPPER = new ObjectMapper(); protected DataStructureUtil dataStructureUtil; protected SchemaDefinitions schemaDefinitions; diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/OkHttpValidatorTypeDefClientTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/OkHttpValidatorTypeDefClientTest.java index ce59452d114..f324a202205 100644 --- a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/OkHttpValidatorTypeDefClientTest.java +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/OkHttpValidatorTypeDefClientTest.java @@ -22,49 +22,77 @@ import static tech.pegasys.teku.ethereum.json.types.validator.AttesterDutiesBuilder.ATTESTER_DUTIES_RESPONSE_TYPE; import static tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeDutiesBuilder.SYNC_COMMITTEE_DUTIES_TYPE; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_METHOD_NOT_ALLOWED; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.BUILDER_BOOST_FACTOR; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.COMMITTEE_INDEX; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.EPOCH; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.GRAFFITI; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.PARAM_BROADCAST_VALIDATION; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.RANDAO_REVEAL; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.SLOT; import static tech.pegasys.teku.infrastructure.json.JsonUtil.serialize; import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ONE; +import static tech.pegasys.teku.spec.SpecMilestone.ALTAIR; +import static tech.pegasys.teku.spec.SpecMilestone.BELLATRIX; +import static tech.pegasys.teku.spec.SpecMilestone.ELECTRA; +import static tech.pegasys.teku.spec.SpecMilestone.PHASE0; import static tech.pegasys.teku.spec.config.SpecConfig.FAR_FUTURE_EPOCH; import com.fasterxml.jackson.core.JsonProcessingException; -import com.fasterxml.jackson.databind.ObjectMapper; import it.unimi.dsi.fastutil.ints.IntList; import it.unimi.dsi.fastutil.ints.IntSet; +import java.nio.charset.StandardCharsets; +import java.util.Collection; import java.util.List; import java.util.Locale; +import java.util.Map; import java.util.Optional; +import java.util.Set; import okhttp3.mockwebserver.MockResponse; import okhttp3.mockwebserver.RecordedRequest; import org.apache.tuweni.bytes.Bytes; +import org.apache.tuweni.bytes.Bytes32; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.TestTemplate; import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; import tech.pegasys.teku.api.response.v1.beacon.ValidatorStatus; +import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.ethereum.json.types.beacon.StateValidatorData; import tech.pegasys.teku.ethereum.json.types.validator.AttesterDuties; import tech.pegasys.teku.ethereum.json.types.validator.AttesterDuty; import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeDuties; import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeDuty; +import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSubnetSubscription; +import tech.pegasys.teku.infrastructure.http.RestApiConstants; +import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition; import tech.pegasys.teku.infrastructure.ssz.SszDataAssert; import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.TestSpecContext; import tech.pegasys.teku.spec.TestSpecInvocationContextProvider.SpecContext; -import tech.pegasys.teku.spec.datastructures.blocks.BlockContainer; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlock; import tech.pegasys.teku.spec.datastructures.builder.SignedValidatorRegistration; -import tech.pegasys.teku.spec.datastructures.metadata.BlockContainerAndMetaData; import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof; +import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SignedContributionAndProof; +import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeContribution; +import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeContributionSchema; +import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeMessage; +import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeMessageSchema; import tech.pegasys.teku.spec.datastructures.state.Validator; +import tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel; +import tech.pegasys.teku.spec.datastructures.validator.SubnetSubscription; import tech.pegasys.teku.spec.networks.Eth2Network; import tech.pegasys.teku.spec.schemas.ApiSchemas; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsAltair; +import tech.pegasys.teku.validator.api.CommitteeSubscriptionRequest; import tech.pegasys.teku.validator.api.SendSignedBlockResult; import tech.pegasys.teku.validator.api.required.SyncingStatus; import tech.pegasys.teku.validator.remote.apiclient.PostStateValidatorsNotExistingException; @@ -74,7 +102,8 @@ @TestSpecContext(allMilestones = true, network = Eth2Network.MINIMAL) class OkHttpValidatorTypeDefClientTest extends AbstractTypeDefRequestTestBase { - private OkHttpValidatorTypeDefClient okHttpValidatorTypeDefClient; + final String serverErrorFromApi = "Server error from Beacon Node API"; + private OkHttpValidatorTypeDefClient typeDefClient; private OkHttpValidatorTypeDefClient okHttpValidatorTypeDefClientWithPreferredSsz; private RegisterValidatorsRequest sszRegisterValidatorsRequest; @@ -82,56 +111,51 @@ class OkHttpValidatorTypeDefClientTest extends AbstractTypeDefRequestTestBase { @Override public void beforeEach(final SpecContext specContext) throws Exception { super.beforeEach(specContext); - okHttpValidatorTypeDefClient = + typeDefClient = new OkHttpValidatorTypeDefClient( - okHttpClient, mockWebServer.url("/"), specContext.getSpec(), false); + okHttpClient, mockWebServer.url("/"), specContext.getSpec(), false, false); okHttpValidatorTypeDefClientWithPreferredSsz = new OkHttpValidatorTypeDefClient( - okHttpClient, mockWebServer.url("/"), specContext.getSpec(), true); + okHttpClient, mockWebServer.url("/"), specContext.getSpec(), true, false); sszRegisterValidatorsRequest = new RegisterValidatorsRequest(mockWebServer.url("/"), okHttpClient, true); } @TestTemplate - void blockProductionFallbacksToNonBlindedFlowIfBlindedEndpointIsNotAvailable() - throws JsonProcessingException, InterruptedException { - assumeThat(specMilestone).isGreaterThanOrEqualTo(SpecMilestone.BELLATRIX); - // simulating blinded endpoint returning 404 Not Found - mockWebServer.enqueue(new MockResponse().setResponseCode(404)); - - final BlockContainer blockContainer; - if (specMilestone.isGreaterThanOrEqualTo(SpecMilestone.DENEB)) { - blockContainer = dataStructureUtil.randomBlockContents(ONE); - } else { - blockContainer = dataStructureUtil.randomBeaconBlock(ONE); - } + public void createSyncCommitteeContribution_whenSuccess_returnsContribution() + throws JsonProcessingException { + assumeThat(specMilestone).isGreaterThanOrEqualTo(ALTAIR); + final SyncCommitteeContribution contribution = + dataStructureUtil.randomSyncCommitteeContribution(); + final SyncCommitteeContributionSchema syncCommitteeContributionSchema = + SchemaDefinitionsAltair.required(spec.atSlot(contribution.getSlot()).getSchemaDefinitions()) + .getSyncCommitteeContributionSchema(); mockWebServer.enqueue( new MockResponse() - .setResponseCode(200) + .setResponseCode(SC_OK) .setBody( "{\"data\": " - + serializeBlockContainer(blockContainer) - + ", \"version\": \"" - + specMilestone - + "\"}")); + + serialize( + contribution, syncCommitteeContributionSchema.getJsonTypeDefinition()) + + "}")); - final Optional maybeBlockContainerAndMetaData = - okHttpValidatorTypeDefClient.createUnsignedBlock( - dataStructureUtil.randomUInt64(), - dataStructureUtil.randomSignature(), - Optional.empty(), - true); + final Optional response = + typeDefClient.createSyncCommitteeContribution( + contribution.getSlot(), + contribution.getSubcommitteeIndex().intValue(), + contribution.getBeaconBlockRoot()); - assertThat(maybeBlockContainerAndMetaData.map(BlockContainerAndMetaData::blockContainer)) - .hasValue(blockContainer); + assertThat(response).isPresent(); + assertThat(response.get()).isEqualTo(contribution); + } - assertThat(mockWebServer.getRequestCount()).isEqualTo(2); + @TestTemplate + public void createSyncCommitteeContribution_whenNotFound_returnsEmpty() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NOT_FOUND)); - final RecordedRequest firstRequest = mockWebServer.takeRequest(); - assertThat(firstRequest.getPath()).startsWith("/eth/v1/validator/blinded_blocks"); - final RecordedRequest secondRequest = mockWebServer.takeRequest(); - assertThat(secondRequest.getPath()).startsWith("/eth/v2/validator/blocks"); + assertThat(typeDefClient.createSyncCommitteeContribution(UInt64.ONE, 0, Bytes32.ZERO)) + .isEmpty(); } @TestTemplate @@ -140,14 +164,25 @@ void publishesBlindedBlockSszEncoded() throws InterruptedException { final SignedBeaconBlock signedBeaconBlock = dataStructureUtil.randomSignedBlindedBeaconBlock(); + final BroadcastValidationLevel broadcastValidationLevel = BroadcastValidationLevel.GOSSIP; final SendSignedBlockResult result = - okHttpValidatorTypeDefClientWithPreferredSsz.sendSignedBlock(signedBeaconBlock); + okHttpValidatorTypeDefClientWithPreferredSsz.sendSignedBlock( + signedBeaconBlock, broadcastValidationLevel); assertThat(result.isPublished()).isTrue(); final RecordedRequest recordedRequest = mockWebServer.takeRequest(); assertThat(recordedRequest.getBody().readByteArray()) .isEqualTo(signedBeaconBlock.sszSerialize().toArrayUnsafe()); + if (specMilestone.isLessThanOrEqualTo(ALTAIR)) { + assertThat(recordedRequest.getPath()) + .contains(ValidatorApiMethod.SEND_SIGNED_BLOCK_V2.getPath(emptyMap())); + } else { + assertThat(recordedRequest.getPath()) + .contains(ValidatorApiMethod.SEND_SIGNED_BLINDED_BLOCK_V2.getPath(emptyMap())); + } + assertThat(recordedRequest.getRequestUrl().queryParameter(PARAM_BROADCAST_VALIDATION)) + .isEqualTo("gossip"); assertThat(recordedRequest.getHeader(HEADER_CONSENSUS_VERSION)) .isEqualTo(specMilestone.name().toLowerCase(Locale.ROOT)); } @@ -159,7 +194,7 @@ void publishesBlindedBlockJsonEncoded() throws InterruptedException, JsonProcess final SignedBeaconBlock signedBeaconBlock = dataStructureUtil.randomSignedBlindedBeaconBlock(); final SendSignedBlockResult result = - okHttpValidatorTypeDefClient.sendSignedBlock(signedBeaconBlock); + typeDefClient.sendSignedBlock(signedBeaconBlock, BroadcastValidationLevel.GOSSIP); assertThat(result.isPublished()).isTrue(); @@ -173,13 +208,21 @@ void publishesBlindedBlockJsonEncoded() throws InterruptedException, JsonProcess .getSignedBlindedBlockContainerSchema() .getJsonTypeDefinition()); + if (specMilestone.isLessThanOrEqualTo(ALTAIR)) { + assertThat(recordedRequest.getPath()) + .contains(ValidatorApiMethod.SEND_SIGNED_BLOCK_V2.getPath(emptyMap())); + } else { + assertThat(recordedRequest.getPath()) + .contains(ValidatorApiMethod.SEND_SIGNED_BLINDED_BLOCK_V2.getPath(emptyMap())); + } + final String actualRequest = recordedRequest.getBody().readUtf8(); assertJsonEquals(actualRequest, expectedRequest); } @TestTemplate - void getsSyncingStatus() { + void getsSyncingStatus() throws InterruptedException { mockWebServer.enqueue( new MockResponse() .setResponseCode(200) @@ -193,7 +236,9 @@ void getsSyncingStatus() { + " }\n" + "}")); - final SyncingStatus result = okHttpValidatorTypeDefClient.getSyncingStatus(); + final SyncingStatus result = typeDefClient.getSyncingStatus(); + + final RecordedRequest request = mockWebServer.takeRequest(); assertThat(result) .satisfies( @@ -203,6 +248,33 @@ void getsSyncingStatus() { assertThat(syncingStatus.isSyncing()).isTrue(); assertThat(syncingStatus.getIsOptimistic()).hasValue(true); }); + assertThat(request.getPath()) + .contains(ValidatorApiMethod.GET_SYNCING_STATUS.getPath(emptyMap())); + } + + @TestTemplate + void getProposerDuties_shouldMakeExpectedRequest() throws InterruptedException { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); + + final UInt64 epoch = dataStructureUtil.randomEpoch(); + typeDefClient.getProposerDuties(epoch); + + final RecordedRequest request = mockWebServer.takeRequest(); + assertThat(request.getMethod()).isEqualTo("GET"); + assertThat(request.getPath()) + .isEqualTo( + "/" + ValidatorApiMethod.GET_PROPOSER_DUTIES.getPath(Map.of(EPOCH, epoch.toString()))); + } + + @TestTemplate + void getPeerCount_shouldMakeExpectedRequest() throws InterruptedException { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); + + typeDefClient.getPeerCount(); + + final RecordedRequest request = mockWebServer.takeRequest(); + assertThat(request.getMethod()).isEqualTo("GET"); + assertThat(request.getPath()).contains(ValidatorApiMethod.GET_PEER_COUNT.getPath(emptyMap())); } @TestTemplate @@ -210,8 +282,7 @@ void getsSyncingStatus_handlesFailure() { mockWebServer.enqueue(new MockResponse().setResponseCode(500)); Assertions.assertThrows( - RemoteServiceNotAvailableException.class, - () -> okHttpValidatorTypeDefClient.getSyncingStatus()); + RemoteServiceNotAvailableException.class, () -> typeDefClient.getSyncingStatus()); } @TestTemplate @@ -227,7 +298,7 @@ void registerValidators_makesJsonRequest() throws InterruptedException, JsonProc validatorRegistrations, ApiSchemas.SIGNED_VALIDATOR_REGISTRATIONS_SCHEMA.getJsonTypeDefinition()); - okHttpValidatorTypeDefClient.registerValidators(validatorRegistrations); + typeDefClient.registerValidators(validatorRegistrations); final RecordedRequest recordedRequest = mockWebServer.takeRequest(); @@ -249,7 +320,7 @@ void registerValidators_handlesFailures() { final IllegalArgumentException badRequestException = Assertions.assertThrows( IllegalArgumentException.class, - () -> okHttpValidatorTypeDefClient.registerValidators(validatorRegistrations)); + () -> typeDefClient.registerValidators(validatorRegistrations)); assertThat(badRequestException.getMessage()) .matches( @@ -263,11 +334,12 @@ void registerValidators_handlesFailures() { final RemoteServiceNotAvailableException serverException = Assertions.assertThrows( RemoteServiceNotAvailableException.class, - () -> okHttpValidatorTypeDefClient.registerValidators(validatorRegistrations)); + () -> typeDefClient.registerValidators(validatorRegistrations)); assertThat(serverException.getMessage()) .matches( - "Server error from Beacon Node API \\(url = (.*), status = 500, message = Internal server error\\)"); + serverErrorFromApi + + " \\(url = (.*), status = 500, message = Internal server error\\)"); } @TestTemplate @@ -278,7 +350,7 @@ void registerValidators_makesSszRequestIfSszEncodingPreferred() throws Interrupt final SszList validatorRegistrations = dataStructureUtil.randomSignedValidatorRegistrations(5); - sszRegisterValidatorsRequest.registerValidators(validatorRegistrations); + sszRegisterValidatorsRequest.submit(validatorRegistrations); final RecordedRequest recordedRequest = mockWebServer.takeRequest(); @@ -300,10 +372,10 @@ void registerValidators_fallbacksToJsonIfSszNotSupported() throws InterruptedExc mockWebServer.enqueue(new MockResponse().setResponseCode(200)); mockWebServer.enqueue(new MockResponse().setResponseCode(200)); - SszList validatorRegistrations = + final SszList validatorRegistrations = dataStructureUtil.randomSignedValidatorRegistrations(5); - sszRegisterValidatorsRequest.registerValidators(validatorRegistrations); + sszRegisterValidatorsRequest.submit(validatorRegistrations); assertThat(mockWebServer.getRequestCount()).isEqualTo(2); @@ -311,7 +383,7 @@ void registerValidators_fallbacksToJsonIfSszNotSupported() throws InterruptedExc verifyRegisterValidatorsPostRequest(mockWebServer.takeRequest(), JSON_CONTENT_TYPE); // subsequent requests default immediately to json - sszRegisterValidatorsRequest.registerValidators(validatorRegistrations); + sszRegisterValidatorsRequest.submit(validatorRegistrations); assertThat(mockWebServer.getRequestCount()).isEqualTo(3); @@ -319,45 +391,10 @@ void registerValidators_fallbacksToJsonIfSszNotSupported() throws InterruptedExc } @TestTemplate - void blockV3ShouldFallbacksToBlockV2WhenNotFound() - throws JsonProcessingException, InterruptedException { - mockWebServer.enqueue(new MockResponse().setResponseCode(404)); - - final BlockContainer blockContainer = dataStructureUtil.randomBlindedBeaconBlock(); - - mockWebServer.enqueue( - new MockResponse() - .setResponseCode(200) - .setBody( - "{\"data\": " - + serializeBlockContainer(blockContainer) - + ", \"version\": \"" - + specMilestone - + "\"}")); - - final Optional maybeBlockContainerAndMetaData = - okHttpValidatorTypeDefClient.createUnsignedBlock( - dataStructureUtil.randomUInt64(), - dataStructureUtil.randomSignature(), - Optional.empty(), - Optional.empty()); - - assertThat(maybeBlockContainerAndMetaData.map(BlockContainerAndMetaData::blockContainer)) - .hasValue(blockContainer); - - assertThat(mockWebServer.getRequestCount()).isEqualTo(2); - - final RecordedRequest firstRequest = mockWebServer.takeRequest(); - assertThat(firstRequest.getPath()).startsWith("/eth/v3/validator/blocks"); - final RecordedRequest secondRequest = mockWebServer.takeRequest(); - assertThat(secondRequest.getPath()).startsWith("/eth/v1/validator/blinded_blocks"); - } - - @TestTemplate - void postValidators_MakesExpectedRequest() throws Exception { + void postValidators_makesExpectedRequest() throws Exception { mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); - okHttpValidatorTypeDefClient.postStateValidators(List.of("1", "0x1234")); + typeDefClient.postStateValidators(List.of("1", "0x1234")); final RecordedRequest request = mockWebServer.takeRequest(); assertThat(request.getMethod()).isEqualTo("POST"); @@ -367,10 +404,10 @@ void postValidators_MakesExpectedRequest() throws Exception { } @TestTemplate - void getStateValidators_MakesExpectedRequest() throws Exception { + void getStateValidators_makesExpectedRequest() throws Exception { mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); - okHttpValidatorTypeDefClient.getStateValidators(List.of("1", "0x1234")); + typeDefClient.getStateValidators(List.of("1", "0x1234")); final RecordedRequest request = mockWebServer.takeRequest(); assertThat(request.getMethod()).isEqualTo("GET"); @@ -382,14 +419,14 @@ void getStateValidators_MakesExpectedRequest() throws Exception { } @TestTemplate - public void postValidators_WhenNoContent_ReturnsEmpty() { + public void postValidators_whenNoContent_returnsEmpty() { mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); - assertThat(okHttpValidatorTypeDefClient.postStateValidators(List.of("1"))).isEmpty(); + assertThat(typeDefClient.postStateValidators(List.of("1"))).isEmpty(); } @TestTemplate - public void postValidators_WhenNotExisting_ThrowsException() { + public void postValidators_whenNotExisting_throwsException() { final List responseCodes = List.of(SC_BAD_REQUEST, SC_NOT_FOUND, SC_METHOD_NOT_ALLOWED); for (int code : responseCodes) { @@ -399,12 +436,12 @@ public void postValidators_WhenNotExisting_ThrowsException() { private void checkThrowsExceptionForCode(final int responseCode) { mockWebServer.enqueue(new MockResponse().setResponseCode(responseCode)); - assertThatThrownBy(() -> okHttpValidatorTypeDefClient.postStateValidators(List.of("1"))) + assertThatThrownBy(() -> typeDefClient.postStateValidators(List.of("1"))) .isInstanceOf(PostStateValidatorsNotExistingException.class); } @TestTemplate - public void postValidators_WhenSuccess_ReturnsResponse() throws JsonProcessingException { + public void postValidators_whenSuccess_returnsResponse() throws JsonProcessingException { final List expected = List.of(generateStateValidatorData(), generateStateValidatorData()); final ObjectAndMetaData> response = @@ -413,8 +450,8 @@ public void postValidators_WhenSuccess_ReturnsResponse() throws JsonProcessingEx final String body = serialize(response, STATE_VALIDATORS_RESPONSE_TYPE); mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK).setBody(body)); - Optional> result = - okHttpValidatorTypeDefClient.postStateValidators(List.of("1", "2")); + final Optional> result = + typeDefClient.postStateValidators(List.of("1", "2")); assertThat(result).isPresent(); assertThat(result.get()).isEqualTo(expected); @@ -440,7 +477,7 @@ private StateValidatorData generateStateValidatorData() { } @TestTemplate - public void postSyncDuties_WhenSuccess_ReturnsResponse() + public void postSyncDuties_whenSuccess_returnsResponse() throws JsonProcessingException, InterruptedException { final List duties = List.of( @@ -455,8 +492,8 @@ public void postSyncDuties_WhenSuccess_ReturnsResponse() final UInt64 epoch = ONE; final IntList validatorIndices = IntList.of(1, 2); - Optional result = - okHttpValidatorTypeDefClient.postSyncDuties(epoch, validatorIndices); + final Optional result = + typeDefClient.postSyncDuties(epoch, validatorIndices); final RecordedRequest recordedRequest = mockWebServer.takeRequest(); assertThat(recordedRequest.getPath()).isEqualTo("/eth/v1/validator/duties/sync/" + epoch); @@ -470,7 +507,7 @@ public void postSyncDuties_WhenSuccess_ReturnsResponse() } @TestTemplate - public void postAttesterDuties_WhenSuccess_ReturnsResponse() + public void postAttesterDuties_whenSuccess_returnsResponse() throws JsonProcessingException, InterruptedException { final List duties = List.of(randomAttesterDuty(), randomAttesterDuty()); final AttesterDuties response = @@ -481,8 +518,8 @@ public void postAttesterDuties_WhenSuccess_ReturnsResponse() final UInt64 epoch = ONE; final IntList validatorIndices = IntList.of(1, 2); - Optional result = - okHttpValidatorTypeDefClient.postAttesterDuties(epoch, validatorIndices); + final Optional result = + typeDefClient.postAttesterDuties(epoch, validatorIndices); final RecordedRequest recordedRequest = mockWebServer.takeRequest(); assertThat(recordedRequest.getPath()).isEqualTo("/eth/v1/validator/duties/attester/" + epoch); @@ -495,6 +532,554 @@ public void postAttesterDuties_WhenSuccess_ReturnsResponse() assertThat(result.get()).isEqualTo(response); } + @TestTemplate + public void postSubscribeToSyncCommitteeSubnets_makesExpectedRequest() + throws InterruptedException { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); + + final Collection subscriptions = + List.of(new SyncCommitteeSubnetSubscription(0, IntSet.of(1), UInt64.ZERO)); + + typeDefClient.subscribeToSyncCommitteeSubnets(subscriptions); + final RecordedRequest recordedRequest = mockWebServer.takeRequest(); + assertThat(recordedRequest.getPath()) + .isEqualTo("/eth/v1/validator/sync_committee_subscriptions"); + assertThat(recordedRequest.getMethod()).isEqualTo("POST"); + assertThat(recordedRequest.getHeader("Content-Type")).isEqualTo(JSON_CONTENT_TYPE); + assertThat(recordedRequest.getBody().readUtf8()) + .isEqualTo( + "[{\"validator_index\":\"0\",\"sync_committee_indices\":[\"1\"],\"until_epoch\":\"0\"}]"); + } + + @TestTemplate + public void subscribeToPersistentSubnets_makesExpectedRequest() throws Exception { + final Set subnetSubscriptions = + Set.of( + new SubnetSubscription( + dataStructureUtil.randomPositiveInt(64), dataStructureUtil.randomSlot())); + + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK)); + + typeDefClient.subscribeToPersistentSubnets(subnetSubscriptions); + + final RecordedRequest request = mockWebServer.takeRequest(); + + assertThat(request.getMethod()).isEqualTo("POST"); + assertThat(request.getPath()) + .contains(ValidatorApiMethod.SUBSCRIBE_TO_PERSISTENT_SUBNETS.getPath(emptyMap())); + assertThat(request.getBody().readString(StandardCharsets.UTF_8)) + .isEqualTo("[{\"subnet_id\":\"35\",\"unsubscription_slot\":\"24752339414\"}]"); + } + + @TestTemplate + public void subscribeToPersistentSubnets_whenBadRequest_throwsIllegalArgumentException() { + final Set subnetSubscriptions = + Set.of( + new SubnetSubscription( + dataStructureUtil.randomPositiveInt(64), dataStructureUtil.randomSlot())); + + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); + assertThatThrownBy(() -> typeDefClient.subscribeToPersistentSubnets(subnetSubscriptions)) + .isInstanceOf(IllegalArgumentException.class); + } + + @TestTemplate + public void subscribeToPersistentSubnets_whenServerError_throwsRuntimeException() { + final Set subnetSubscriptions = + Set.of( + new SubnetSubscription( + dataStructureUtil.randomPositiveInt(64), dataStructureUtil.randomSlot())); + + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + + assertThatThrownBy(() -> typeDefClient.subscribeToPersistentSubnets(subnetSubscriptions)) + .isInstanceOf(RuntimeException.class) + .hasMessageContaining(serverErrorFromApi); + } + + @TestTemplate + public void subscribeToBeaconCommitteeForAggregation_makesExpectedRequest() throws Exception { + final int committeeIndex1 = 1; + final int validatorIndex1 = 6; + final UInt64 committeesAtSlot1 = UInt64.valueOf(10); + final UInt64 slot1 = UInt64.valueOf(15); + final boolean aggregator1 = true; + + final int committeeIndex2 = 2; + final int validatorIndex2 = 7; + final UInt64 committeesAtSlot2 = UInt64.valueOf(11); + final UInt64 slot2 = UInt64.valueOf(16); + final boolean aggregator2 = false; + + final String expectedRequest = + "[{\"validator_index\":\"6\",\"committee_index\":\"1\",\"committees_at_slot\":\"10\",\"slot\":\"15\",\"is_aggregator\":true}," + + "{\"validator_index\":\"7\",\"committee_index\":\"2\",\"committees_at_slot\":\"11\",\"slot\":\"16\",\"is_aggregator\":false}]"; + + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK)); + + typeDefClient.subscribeToBeaconCommittee( + List.of( + new CommitteeSubscriptionRequest( + validatorIndex1, committeeIndex1, committeesAtSlot1, slot1, aggregator1), + new CommitteeSubscriptionRequest( + validatorIndex2, committeeIndex2, committeesAtSlot2, slot2, aggregator2))); + + final RecordedRequest request = mockWebServer.takeRequest(); + + assertThat(request.getMethod()).isEqualTo("POST"); + assertThat(request.getPath()) + .contains(ValidatorApiMethod.SUBSCRIBE_TO_BEACON_COMMITTEE_SUBNET.getPath(emptyMap())); + assertThat(request.getBody().readUtf8()).isEqualTo(expectedRequest); + } + + @TestTemplate + public void + subscribeToBeaconCommitteeForAggregation_whenBadRequest_throwsIllegalArgumentException() { + final int committeeIndex = 1; + final UInt64 aggregationSlot = UInt64.ONE; + + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); + + assertThatThrownBy( + () -> + typeDefClient.subscribeToBeaconCommittee( + List.of( + new CommitteeSubscriptionRequest( + 1, committeeIndex, UInt64.valueOf(10), aggregationSlot, true)))) + .isInstanceOf(IllegalArgumentException.class); + } + + @TestTemplate + public void subscribeToBeaconCommitteeForAggregation_whenServerError_throwsRuntimeException() { + final int committeeIndex = 1; + final UInt64 aggregationSlot = UInt64.ONE; + + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + + assertThatThrownBy( + () -> + typeDefClient.subscribeToBeaconCommittee( + List.of( + new CommitteeSubscriptionRequest( + 1, committeeIndex, UInt64.valueOf(10), aggregationSlot, true)))) + .isInstanceOf(RuntimeException.class) + .hasMessageContaining(serverErrorFromApi); + } + + @TestTemplate + public void sendSignedContributionAndProof_emptyListIsNoop() { + assumeThat(specMilestone).isGreaterThanOrEqualTo(ALTAIR); + typeDefClient.sendContributionAndProofs(List.of()); + assertThat(mockWebServer.getRequestCount()).isEqualTo(0); + } + + @TestTemplate + public void sendSignedContributionAndProof_acceptsPopulatedList() throws InterruptedException { + assumeThat(specMilestone).isGreaterThanOrEqualTo(ALTAIR); + final SignedContributionAndProof proof = dataStructureUtil.randomSignedContributionAndProof(); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK)); + typeDefClient.sendContributionAndProofs(List.of(proof)); + + final RecordedRequest request = mockWebServer.takeRequest(); + assertThat(request.getMethod()).isEqualTo("POST"); + assertThat(request.getRequestUrl().encodedPath()) + .isEqualTo("/eth/v1/validator/contribution_and_proofs"); + assertThat(request.getBody().readUtf8()) + .contains("\"contribution\":{\"slot\":\"4666673844721362956\""); + } + + @TestTemplate + public void sendSignedContributionAndProof_canRespondFailure() { + assumeThat(specMilestone).isGreaterThanOrEqualTo(ALTAIR); + final SignedContributionAndProof proof = dataStructureUtil.randomSignedContributionAndProof(); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); + assertThatThrownBy(() -> typeDefClient.sendContributionAndProofs(List.of(proof))) + .isInstanceOf(IllegalArgumentException.class); + } + + @TestTemplate + public void prepareBeaconProposer_emptyListIsNoop() { + assumeThat(specMilestone).isGreaterThanOrEqualTo(BELLATRIX); + typeDefClient.prepareBeaconProposer(List.of()); + assertThat(mockWebServer.getRequestCount()).isEqualTo(0); + } + + @TestTemplate + public void prepareBeaconProposer_canRespondFailure() { + assumeThat(specMilestone).isGreaterThanOrEqualTo(BELLATRIX); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); + assertThatThrownBy( + () -> + typeDefClient.prepareBeaconProposer( + List.of(dataStructureUtil.randomBeaconPreparableProposer()))) + .isInstanceOf(IllegalArgumentException.class); + } + + @TestTemplate + public void prepareBeaconProposer_acceptsPopulatedList() throws InterruptedException { + assumeThat(specMilestone).isGreaterThanOrEqualTo(BELLATRIX); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK)); + typeDefClient.prepareBeaconProposer( + List.of(dataStructureUtil.randomBeaconPreparableProposer())); + + final RecordedRequest request = mockWebServer.takeRequest(); + assertThat(request.getMethod()).isEqualTo("POST"); + assertThat(request.getRequestUrl().encodedPath()) + .isEqualTo("/eth/v1/validator/prepare_beacon_proposer"); + assertThat(request.getBody().readUtf8()) + .isEqualTo( + "[{\"validator_index\":\"4666673844721362956\",\"fee_recipient\":\"0x367CbD40AC7318427aAdB97345a91FA2e965DAf3\"}]"); + } + + @TestTemplate + public void createAggregate_makesExpectedRequest_preElectra() throws Exception { + assumeThat(specMilestone).isLessThan(ELECTRA); + final UInt64 slot = UInt64.valueOf(323); + final Bytes32 attestationHashTreeRoot = Bytes32.random(); + + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); + + typeDefClient.createAggregate(slot, attestationHashTreeRoot, Optional.empty()); + + final RecordedRequest request = mockWebServer.takeRequest(); + + assertThat(request.getMethod()).isEqualTo("GET"); + assertThat(request.getPath()).contains(ValidatorApiMethod.GET_AGGREGATE.getPath(emptyMap())); + assertThat(request.getRequestUrl().queryParameter("slot")).isEqualTo(slot.toString()); + assertThat(request.getRequestUrl().queryParameter("attestation_data_root")) + .isEqualTo(attestationHashTreeRoot.toHexString()); + } + + @TestTemplate + public void createAggregate_makesExpectedRequest_postElectra() throws Exception { + assumeThat(specMilestone).isGreaterThanOrEqualTo(ELECTRA); + final UInt64 slot = UInt64.valueOf(323); + final Bytes32 attestationHashTreeRoot = Bytes32.random(); + + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); + + typeDefClient.createAggregate( + slot, attestationHashTreeRoot, Optional.of(dataStructureUtil.randomUInt64())); + + final RecordedRequest request = mockWebServer.takeRequest(); + + assertThat(request.getMethod()).isEqualTo("GET"); + assertThat(request.getPath()).contains(ValidatorApiMethod.GET_AGGREGATE_V2.getPath(emptyMap())); + assertThat(request.getRequestUrl().queryParameter("slot")).isEqualTo(slot.toString()); + assertThat(request.getRequestUrl().queryParameter("attestation_data_root")) + .isEqualTo(attestationHashTreeRoot.toHexString()); + } + + @TestTemplate + public void sendValidatorsLiveness_makesExpectedRequest() throws Exception { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); + + final UInt64 epoch = dataStructureUtil.randomEpoch(); + final List validatorIndices = + List.of(dataStructureUtil.randomValidatorIndex(), dataStructureUtil.randomValidatorIndex()); + + typeDefClient.sendValidatorsLiveness(epoch, validatorIndices); + + final RecordedRequest request = mockWebServer.takeRequest(); + + assertThat(request.getMethod()).isEqualTo("POST"); + assertThat(request.getPath()) + .contains( + ValidatorApiMethod.SEND_VALIDATOR_LIVENESS.getPath( + Map.of(RestApiConstants.EPOCH, epoch.toString()))); + assertThat(request.getBody().readUtf8()) + .isEqualTo("[\"" + validatorIndices.get(0) + "\",\"" + validatorIndices.get(1) + "\"]"); + } + + @TestTemplate + public void sendSyncCommitteeMessages_makesExpectedRequest() throws Exception { + assumeThat(specMilestone).isGreaterThan(PHASE0); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK)); + + final UInt64 epoch = dataStructureUtil.randomEpoch(); + final List syncCommitteeMessages = + List.of( + dataStructureUtil.randomSyncCommitteeMessage(), + dataStructureUtil.randomSyncCommitteeMessage()); + + typeDefClient.sendSyncCommitteeMessages(syncCommitteeMessages); + + final RecordedRequest request = mockWebServer.takeRequest(); + assertThat(request.getMethod()).isEqualTo("POST"); + assertThat(request.getPath()) + .contains( + ValidatorApiMethod.SEND_SYNC_COMMITTEE_MESSAGES.getPath( + Map.of(RestApiConstants.EPOCH, epoch.toString()))); + + final String expectedRequestPayloadBody = + serialize( + syncCommitteeMessages, + SerializableTypeDefinition.listOf( + SyncCommitteeMessageSchema.INSTANCE.getJsonTypeDefinition())); + assertThat(request.getBody().readString(StandardCharsets.UTF_8)) + .isEqualTo(expectedRequestPayloadBody); + } + + @TestTemplate + public void createAttestationData_makesExpectedRequest() throws Exception { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); + + final UInt64 slot = dataStructureUtil.randomSlot(); + final int committeeIndex = dataStructureUtil.randomPositiveInt(); + + typeDefClient.createAttestationData(slot, committeeIndex); + + final RecordedRequest request = mockWebServer.takeRequest(); + + assertThat(request.getMethod()).isEqualTo("GET"); + assertThat(request.getPath()) + .contains(ValidatorApiMethod.GET_ATTESTATION_DATA.getPath(emptyMap())); + assertThat(request.getRequestUrl().queryParameter(SLOT)).isEqualTo(slot.toString()); + assertThat(request.getRequestUrl().queryParameter(COMMITTEE_INDEX)) + .isEqualTo(String.valueOf(committeeIndex)); + } + + @TestTemplate + public void createUnsignedBlock_makesExpectedRequest() throws Exception { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); + + final UInt64 slot = dataStructureUtil.randomSlot(); + final BLSSignature randaoReveal = dataStructureUtil.randomSignature(); + final Bytes32 graffiti = dataStructureUtil.randomBytes32(); + final UInt64 boostFactor = dataStructureUtil.randomUInt64(); + + typeDefClient.createUnsignedBlock( + slot, randaoReveal, Optional.of(graffiti), Optional.of(boostFactor)); + + final RecordedRequest request = mockWebServer.takeRequest(); + + assertThat(request.getMethod()).isEqualTo("GET"); + assertThat(request.getPath()) + .contains(ValidatorApiMethod.GET_UNSIGNED_BLOCK_V3.getPath(Map.of(SLOT, slot.toString()))); + assertThat(request.getRequestUrl().queryParameter(RANDAO_REVEAL)) + .isEqualTo(randaoReveal.toString()); + assertThat(request.getRequestUrl().queryParameter(GRAFFITI)).isEqualTo(graffiti.toString()); + assertThat(request.getRequestUrl().queryParameter(BUILDER_BOOST_FACTOR)) + .isEqualTo(boostFactor.toString()); + } + + @TestTemplate + public void sendAggregate_makesExpectedRequest_preElectra() throws Exception { + assumeThat(specMilestone).isLessThan(ELECTRA); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK)); + + final List aggregateAndProofs = + List.of( + dataStructureUtil.randomSignedAggregateAndProof(), + dataStructureUtil.randomSignedAggregateAndProof()); + + typeDefClient.sendAggregateAndProofs(aggregateAndProofs); + final RecordedRequest request = mockWebServer.takeRequest(); + + assertThat(request.getMethod()).isEqualTo("POST"); + assertThat(request.getPath()) + .contains(ValidatorApiMethod.SEND_SIGNED_AGGREGATE_AND_PROOFS.getPath(emptyMap())); + + final String expectedRequestPayloadBody = + serialize( + aggregateAndProofs, + SerializableTypeDefinition.listOf( + spec.getGenesisSchemaDefinitions() + .getSignedAggregateAndProofSchema() + .getJsonTypeDefinition())); + + assertThat(request.getBody().readString(StandardCharsets.UTF_8)) + .isEqualTo(expectedRequestPayloadBody); + } + + @TestTemplate + public void sendAggregate_makesExpectedRequest_postElectra() throws Exception { + assumeThat(specMilestone).isGreaterThanOrEqualTo(ELECTRA); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); + + final List aggregateAndProofs = + List.of( + dataStructureUtil.randomSignedAggregateAndProof(), + dataStructureUtil.randomSignedAggregateAndProof()); + + typeDefClient.sendAggregateAndProofs(aggregateAndProofs); + final RecordedRequest request = mockWebServer.takeRequest(); + + assertThat(request.getMethod()).isEqualTo("POST"); + assertThat(request.getPath()) + .contains(ValidatorApiMethod.SEND_SIGNED_AGGREGATE_AND_PROOFS_V2.getPath(emptyMap())); + + final String expectedRequestPayloadBody = + serialize( + aggregateAndProofs, + SerializableTypeDefinition.listOf( + spec.getGenesisSchemaDefinitions() + .getSignedAggregateAndProofSchema() + .getJsonTypeDefinition())); + + assertThat(request.getBody().readString(StandardCharsets.UTF_8)) + .isEqualTo(expectedRequestPayloadBody); + assertThat(request.getHeader(HEADER_CONSENSUS_VERSION)) + .isEqualTo(specMilestone.name().toLowerCase(Locale.ROOT)); + } + + @TestTemplate + public void sendSignedAttestation_makesExpectedRequest_preElectra() throws Exception { + assumeThat(specMilestone).isLessThan(ELECTRA); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); + + final List attestations = + List.of(dataStructureUtil.randomAttestation(), dataStructureUtil.randomAttestation()); + + typeDefClient.sendSignedAttestations(attestations); + final RecordedRequest request = mockWebServer.takeRequest(); + + assertThat(request.getMethod()).isEqualTo("POST"); + assertThat(request.getPath()) + .contains(ValidatorApiMethod.SEND_SIGNED_ATTESTATION.getPath(emptyMap())); + + final String expectedRequestPayloadBody = + serialize( + attestations, + SerializableTypeDefinition.listOf( + spec.getGenesisSchemaDefinitions().getAttestationSchema().getJsonTypeDefinition())); + + assertThat(request.getBody().readString(StandardCharsets.UTF_8)) + .isEqualTo(expectedRequestPayloadBody); + } + + @TestTemplate + public void sendSignedAttestation_makesExpectedRequest_postElectra() throws Exception { + assumeThat(specMilestone).isGreaterThanOrEqualTo(ELECTRA); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); + + final List attestations = + List.of(dataStructureUtil.randomAttestation(), dataStructureUtil.randomAttestation()); + + typeDefClient.sendSignedAttestations(attestations); + final RecordedRequest request = mockWebServer.takeRequest(); + + assertThat(request.getMethod()).isEqualTo("POST"); + assertThat(request.getPath()) + .contains(ValidatorApiMethod.SEND_SIGNED_ATTESTATION_V2.getPath(emptyMap())); + + final String expectedRequestPayloadBody = + serialize( + attestations, + SerializableTypeDefinition.listOf( + spec.getGenesisSchemaDefinitions().getAttestationSchema().getJsonTypeDefinition())); + + assertThat(request.getBody().readString(StandardCharsets.UTF_8)) + .isEqualTo(expectedRequestPayloadBody); + assertThat(request.getHeader(HEADER_CONSENSUS_VERSION)) + .isEqualTo(specMilestone.name().toLowerCase(Locale.ROOT)); + } + + @TestTemplate + public void createAggregate_whenBadParameters_throwsIllegalArgumentException() { + final Bytes32 attestationHashTreeRoot = Bytes32.random(); + + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); + + assertThatThrownBy( + () -> + typeDefClient.createAggregate( + UInt64.ONE, + attestationHashTreeRoot, + Optional.of(dataStructureUtil.randomUInt64()))) + .isInstanceOf(IllegalArgumentException.class); + } + + @TestTemplate + public void createAggregate_whenNotFound_returnsEmpty() { + final Bytes32 attestationHashTreeRoot = Bytes32.random(); + + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NOT_FOUND)); + + assertThat( + typeDefClient.createAggregate( + UInt64.ONE, attestationHashTreeRoot, Optional.of(dataStructureUtil.randomUInt64()))) + .isEmpty(); + } + + @TestTemplate + public void createAggregate_whenServerError_throwsRuntimeException() { + final Bytes32 attestationHashTreeRoot = Bytes32.random(); + + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + + assertThatThrownBy( + () -> + typeDefClient.createAggregate( + UInt64.ONE, + attestationHashTreeRoot, + Optional.of(dataStructureUtil.randomUInt64()))) + .isInstanceOf(RuntimeException.class) + .hasMessageContaining("Server error from Beacon Node API"); + } + + @TestTemplate + public void createAggregate_whenSuccess_returnsAttestation_preElectra() + throws JsonProcessingException { + assumeThat(specMilestone).isLessThan(ELECTRA); + final Bytes32 attestationHashTreeRoot = Bytes32.random(); + final Attestation expectedAttestation = dataStructureUtil.randomAttestation(); + final String body = + serialize( + expectedAttestation, + spec.getGenesisSchemaDefinitions().getAttestationSchema().getJsonTypeDefinition()); + mockWebServer.enqueue( + new MockResponse().setResponseCode(SC_OK).setBody("{\"data\": " + body + "}")); + + final Optional> attestation = + typeDefClient.createAggregate(UInt64.ONE, attestationHashTreeRoot, Optional.empty()); + + assertThat(attestation).isPresent(); + assertThat(attestation.get().getData()).isEqualTo(expectedAttestation); + } + + @TestTemplate + public void createAggregate_whenSuccess_returnsAttestation_postElectra() + throws JsonProcessingException { + assumeThat(specMilestone).isGreaterThanOrEqualTo(ELECTRA); + final Bytes32 attestationHashTreeRoot = Bytes32.random(); + final Attestation expectedAttestation = dataStructureUtil.randomAttestation(); + final String body = + serialize( + expectedAttestation, + spec.getGenesisSchemaDefinitions().getAttestationSchema().getJsonTypeDefinition()); + mockWebServer.enqueue( + new MockResponse() + .setResponseCode(SC_OK) + .setBody( + "{ " + + "\"version\": \"" + + specMilestone.name().toLowerCase(Locale.ROOT) + + "\", " + + "\"data\": " + + body + + " }")); + + final Optional> attestation = + typeDefClient.createAggregate( + UInt64.ONE, attestationHashTreeRoot, Optional.of(dataStructureUtil.randomUInt64())); + + assertThat(attestation).isPresent(); + assertThat(attestation.get().getData()).isEqualTo(expectedAttestation); + } + + @TestTemplate + public void createAggregate_whenMissingCommitteeIndex_returnsEmpty_postElectra() { + assumeThat(specMilestone).isGreaterThanOrEqualTo(ELECTRA); + assertThatThrownBy( + () -> + typeDefClient.createAggregate( + UInt64.ONE, dataStructureUtil.randomBytes32(), Optional.empty())) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("Missing required parameter: committee index"); + assertThat(mockWebServer.getRequestCount()).isZero(); + } + private AttesterDuty randomAttesterDuty() { return new AttesterDuty( dataStructureUtil.randomPublicKey(), @@ -515,19 +1100,9 @@ private void verifyRegisterValidatorsPostRequest( private void assertJsonEquals(final String actual, final String expected) { try { - final ObjectMapper objectMapper = JSON_PROVIDER.getObjectMapper(); - assertThat(objectMapper.readTree(actual)).isEqualTo(objectMapper.readTree(expected)); + assertThat(OBJECT_MAPPER.readTree(actual)).isEqualTo(OBJECT_MAPPER.readTree(expected)); } catch (JsonProcessingException ex) { Assertions.fail(ex); } } - - private String serializeBlockContainer(final BlockContainer blockContainer) - throws JsonProcessingException { - return serialize( - blockContainer, - blockContainer.isBlinded() - ? schemaDefinitions.getBlindedBlockContainerSchema().getJsonTypeDefinition() - : schemaDefinitions.getBlockContainerSchema().getJsonTypeDefinition()); - } } diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/BeaconCommitteeSelectionsRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/BeaconCommitteeSelectionsRequestTest.java index e895a6483cd..08ad5989eb5 100644 --- a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/BeaconCommitteeSelectionsRequestTest.java +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/BeaconCommitteeSelectionsRequestTest.java @@ -62,8 +62,7 @@ public void correctResponseDeserialization() { "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505") .build(); - final Optional> response = - request.getSelectionProof(entries); + final Optional> response = request.submit(entries); assertThat(response).isPresent().contains(List.of(expectedBeaconCommitteeSelectionProof)); } @@ -72,7 +71,7 @@ public void expectedRequest() throws Exception { final String mockResponse = readResource("responses/beacon_committee_selections.json"); mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK).setBody(mockResponse)); - request.getSelectionProof(entries); + request.submit(entries); final RecordedRequest request = mockWebServer.takeRequest(); assertThat(request.getMethod()).isEqualTo("POST"); @@ -90,22 +89,21 @@ public void expectedRequest() throws Exception { public void handlingBadRequest() { mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); - assertThatThrownBy(() -> request.getSelectionProof(entries)) - .isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> request.submit(entries)).isInstanceOf(IllegalArgumentException.class); } @TestTemplate public void handlingNotImplemented() { mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NOT_IMPLEMENTED)); - assertThat(request.getSelectionProof(entries)).isEmpty(); + assertThat(request.submit(entries)).isEmpty(); } @TestTemplate public void handlingSyncing() { mockWebServer.enqueue(new MockResponse().setResponseCode(SC_SERVICE_UNAVAILABLE)); - assertThat(request.getSelectionProof(entries)).isEmpty(); + assertThat(request.submit(entries)).isEmpty(); } private BeaconCommitteeSelectionProof createBeaconCommitteeSelectionProof() { diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateAggregateAttestationRequestElectraTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateAggregateAttestationRequestElectraTest.java new file mode 100644 index 00000000000..5dd3e1be30e --- /dev/null +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateAggregateAttestationRequestElectraTest.java @@ -0,0 +1,135 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static java.util.Collections.emptyMap; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.ATTESTATION_DATA_ROOT; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.COMMITTEE_INDEX; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.SLOT; +import static tech.pegasys.teku.spec.SpecMilestone.ELECTRA; + +import java.util.Optional; +import okhttp3.mockwebserver.MockResponse; +import okhttp3.mockwebserver.RecordedRequest; +import org.apache.tuweni.bytes.Bytes32; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; +import tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod; +import tech.pegasys.teku.validator.remote.typedef.AbstractTypeDefRequestTestBase; + +@TestSpecContext( + milestone = {ELECTRA}, + network = Eth2Network.MINIMAL) +public class CreateAggregateAttestationRequestElectraTest extends AbstractTypeDefRequestTestBase { + + private CreateAggregateAttestationRequest createAggregateAttestationRequest; + private final UInt64 slot = UInt64.ONE; + + @TestTemplate + public void getAggregateAttestation_makesExpectedRequest() throws Exception { + final UInt64 committeeIndex = dataStructureUtil.randomUInt64(); + final Bytes32 attestationHashTreeRoot = dataStructureUtil.randomBytes32(); + + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); + + createAggregateAttestationRequest = + new CreateAggregateAttestationRequest( + mockWebServer.url("/"), + okHttpClient, + new SchemaDefinitionCache(spec), + slot, + attestationHashTreeRoot, + Optional.of(committeeIndex), + false, + spec); + + createAggregateAttestationRequest.submit(); + + final RecordedRequest request = mockWebServer.takeRequest(); + + assertThat(request.getMethod()).isEqualTo("GET"); + assertThat(request.getPath()).contains(ValidatorApiMethod.GET_AGGREGATE_V2.getPath(emptyMap())); + assertThat(request.getRequestUrl().queryParameter(SLOT)).isEqualTo(slot.toString()); + assertThat(request.getRequestUrl().queryParameter(ATTESTATION_DATA_ROOT)) + .isEqualTo(attestationHashTreeRoot.toHexString()); + assertThat(request.getRequestUrl().queryParameter(COMMITTEE_INDEX)) + .isEqualTo(committeeIndex.toString()); + } + + @TestTemplate + public void shouldGetAggregateAttestation() { + final Attestation attestation = dataStructureUtil.randomAttestation(); + final CreateAggregateAttestationRequest.GetAggregateAttestationResponseV2 + getAggregateAttestationResponse = + new CreateAggregateAttestationRequest.GetAggregateAttestationResponseV2(attestation); + + final String mockResponse = + readResource( + "responses/create_aggregate_attestation_responses/createAggregateAttestationResponseElectra.json"); + + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK).setBody(mockResponse)); + + final UInt64 committeeIndex = + specMilestone.isGreaterThanOrEqualTo(ELECTRA) + ? UInt64.valueOf( + attestation.getCommitteeBitsRequired().streamAllSetBits().findFirst().orElseThrow()) + : attestation.getData().getIndex(); + + createAggregateAttestationRequest = + new CreateAggregateAttestationRequest( + mockWebServer.url("/"), + okHttpClient, + new SchemaDefinitionCache(spec), + slot, + attestation.hashTreeRoot(), + Optional.of(committeeIndex), + false, + spec); + + final Optional> maybeAttestationAndMetaData = + createAggregateAttestationRequest.submit(); + assertThat(maybeAttestationAndMetaData).isPresent(); + assertThat(maybeAttestationAndMetaData.get().getData()) + .isEqualTo(getAggregateAttestationResponse.getData()); + assertThat(maybeAttestationAndMetaData.get().getMilestone()).isEqualTo(specMilestone); + } + + @TestTemplate + public void shouldThrowWhenCommitteeIndexIsMissing() { + final Attestation attestation = dataStructureUtil.randomAttestation(); + createAggregateAttestationRequest = + new CreateAggregateAttestationRequest( + mockWebServer.url("/"), + okHttpClient, + new SchemaDefinitionCache(spec), + slot, + attestation.hashTreeRoot(), + Optional.empty(), + false, + spec); + assertThatThrownBy(() -> createAggregateAttestationRequest.submit()) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("Missing required parameter: committee index"); + assertThat(mockWebServer.getRequestCount()).isZero(); + } +} diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateAggregateAttestationRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateAggregateAttestationRequestTest.java new file mode 100644 index 00000000000..033d061687e --- /dev/null +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateAggregateAttestationRequestTest.java @@ -0,0 +1,164 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.ATTESTATION_DATA_ROOT; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.SLOT; + +import java.util.Collections; +import java.util.Optional; +import okhttp3.mockwebserver.MockResponse; +import okhttp3.mockwebserver.RecordedRequest; +import org.apache.tuweni.bytes.Bytes32; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; +import tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod; +import tech.pegasys.teku.validator.remote.typedef.AbstractTypeDefRequestTestBase; + +@TestSpecContext(milestone = SpecMilestone.PHASE0, network = Eth2Network.MINIMAL) +public class CreateAggregateAttestationRequestTest extends AbstractTypeDefRequestTestBase { + + private CreateAggregateAttestationRequest request; + private UInt64 slot; + private Bytes32 attestationHashTreeRoot; + + @BeforeEach + public void setup() { + slot = dataStructureUtil.randomSlot(); + attestationHashTreeRoot = dataStructureUtil.randomBytes32(); + request = + new CreateAggregateAttestationRequest( + mockWebServer.url("/"), + okHttpClient, + new SchemaDefinitionCache(spec), + slot, + attestationHashTreeRoot, + Optional.empty(), + false, + spec); + } + + @TestTemplate + public void getAggregateAttestation_makesExpectedRequest() throws Exception { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); + request.submit(); + final RecordedRequest request = mockWebServer.takeRequest(); + assertThat(request.getMethod()).isEqualTo("GET"); + assertThat(request.getPath()) + .contains(ValidatorApiMethod.GET_AGGREGATE.getPath(Collections.emptyMap())); + assertThat(request.getRequestUrl().queryParameter(SLOT)).isEqualTo(slot.toString()); + assertThat(request.getRequestUrl().queryParameter(ATTESTATION_DATA_ROOT)) + .isEqualTo(attestationHashTreeRoot.toHexString()); + } + + @TestTemplate + public void shouldGetAggregateAttestation() { + final Attestation attestation = dataStructureUtil.randomAttestation(); + final CreateAggregateAttestationRequest.GetAggregateAttestationResponse + getAggregateAttestationResponse = + new CreateAggregateAttestationRequest.GetAggregateAttestationResponse(attestation); + final String mockResponse = + readResource( + "responses/create_aggregate_attestation_responses/createAggregateAttestationResponse.json"); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK).setBody(mockResponse)); + request = + new CreateAggregateAttestationRequest( + mockWebServer.url("/"), + okHttpClient, + new SchemaDefinitionCache(spec), + slot, + attestation.hashTreeRoot(), + Optional.empty(), + false, + spec); + final Optional> maybeAttestation = request.submit(); + assertThat(maybeAttestation).isPresent(); + assertThat(maybeAttestation.get().getData()) + .isEqualTo(getAggregateAttestationResponse.getData()); + } + + @TestTemplate + void handle400() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); + assertThatThrownBy(() -> request.submit()).isInstanceOf(IllegalArgumentException.class); + } + + @TestTemplate + void handle404() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NOT_FOUND)); + assertThat(request.submit()).isEmpty(); + } + + @TestTemplate + void handle500() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy(() -> request.submit()) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } + + @TestTemplate + void shouldUseV2ApiWhenUseAttestationsV2ApisEnabled() throws InterruptedException { + final Bytes32 attestationHashTreeRoot = dataStructureUtil.randomBytes32(); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); + request = + new CreateAggregateAttestationRequest( + mockWebServer.url("/"), + okHttpClient, + new SchemaDefinitionCache(spec), + slot, + attestationHashTreeRoot, + Optional.of(dataStructureUtil.randomUInt64()), + true, + spec); + request.submit(); + final RecordedRequest request = mockWebServer.takeRequest(); + assertThat(request.getMethod()).isEqualTo("GET"); + assertThat(request.getPath()) + .contains(ValidatorApiMethod.GET_AGGREGATE_V2.getPath(Collections.emptyMap())); + } + + @TestTemplate + public void shouldThrowWhenCommitteeIndexIsMissingAndUseAttestationsV2ApisEnabled() { + final Attestation attestation = dataStructureUtil.randomAttestation(); + request = + new CreateAggregateAttestationRequest( + mockWebServer.url("/"), + okHttpClient, + new SchemaDefinitionCache(spec), + slot, + attestation.hashTreeRoot(), + Optional.empty(), + true, + spec); + assertThatThrownBy(() -> request.submit()) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("Missing required parameter: committee index"); + assertThat(mockWebServer.getRequestCount()).isZero(); + } +} diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateAttestationDataRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateAttestationDataRequestTest.java index 5f0eb82132f..363409c48ed 100644 --- a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateAttestationDataRequestTest.java +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateAttestationDataRequestTest.java @@ -17,7 +17,7 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_FORBIDDEN; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; @@ -46,13 +46,13 @@ void setupRequest() { } @TestTemplate - public void createAttestationData_MakesExpectedRequest() throws Exception { + public void makesExpectedRequest() throws Exception { final UInt64 slot = UInt64.ONE; final int committeeIndex = 1; mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); - request.createAttestationData(slot, committeeIndex); + request.submit(slot, committeeIndex); RecordedRequest request = mockWebServer.takeRequest(); @@ -65,32 +65,31 @@ public void createAttestationData_MakesExpectedRequest() throws Exception { } @TestTemplate - public void createAttestationData_WhenBadRequest_ThrowsIllegalArgumentException() { + public void whenBadRequest_throwsIllegalArgumentException() { final UInt64 slot = UInt64.ONE; final int committeeIndex = 1; mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); - assertThatThrownBy(() -> request.createAttestationData(slot, committeeIndex)) + assertThatThrownBy(() -> request.submit(slot, committeeIndex)) .isInstanceOf(IllegalArgumentException.class); } @TestTemplate - public void createAttestationData_WhenNotFound_ThrowsError() { + public void whenInvalidResponse_throwsError() { final UInt64 slot = UInt64.ONE; final int committeeIndex = 1; - // An attestation could not be created for the specified slot - mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NOT_FOUND)); + // An unexpected response is returned, such as 403-forbidden + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_FORBIDDEN)); - assertThatThrownBy(() -> request.createAttestationData(slot, committeeIndex)) + assertThatThrownBy(() -> request.submit(slot, committeeIndex)) .isInstanceOf(RuntimeException.class) .hasMessageContaining("Unexpected response from Beacon Node API"); } @TestTemplate - public void createAttestationData_WhenSuccessWithNonData_ReturnsAttestationData() - throws Exception { + public void dataCanBeRead() throws Exception { final UInt64 slot = UInt64.ONE; final int committeeIndex = 1; final AttestationData expectedAttestationData = dataStructureUtil.randomAttestationData(); @@ -98,7 +97,7 @@ public void createAttestationData_WhenSuccessWithNonData_ReturnsAttestationData( new MockResponse() .setResponseCode(SC_OK) .setBody(serializeSszObjectToJsonWithDataWrapper(expectedAttestationData))); - Optional attestationData = request.createAttestationData(slot, committeeIndex); + Optional attestationData = request.submit(slot, committeeIndex); assertThat(attestationData).isPresent(); assertThat(attestationData.get()).isEqualTo(expectedAttestationData); diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateSyncCommitteeContributionRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateSyncCommitteeContributionRequestTest.java new file mode 100644 index 00000000000..217749e991a --- /dev/null +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateSyncCommitteeContributionRequestTest.java @@ -0,0 +1,133 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.assertj.core.api.Assumptions.assumeThat; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.BEACON_BLOCK_ROOT; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.SLOT; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.SUBCOMMITTEE_INDEX; +import static tech.pegasys.teku.infrastructure.json.JsonUtil.serialize; +import static tech.pegasys.teku.spec.SpecMilestone.PHASE0; + +import com.fasterxml.jackson.core.JsonProcessingException; +import java.util.Collections; +import java.util.Optional; +import okhttp3.mockwebserver.MockResponse; +import okhttp3.mockwebserver.RecordedRequest; +import org.apache.tuweni.bytes.Bytes32; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeContribution; +import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod; +import tech.pegasys.teku.validator.remote.typedef.AbstractTypeDefRequestTestBase; + +@TestSpecContext(allMilestones = true, network = Eth2Network.MINIMAL) +public class CreateSyncCommitteeContributionRequestTest extends AbstractTypeDefRequestTestBase { + + private CreateSyncCommitteeContributionRequest request; + private UInt64 slot; + private int subcommitteeIndex; + private Bytes32 root; + + @BeforeEach + public void setup() { + request = + new CreateSyncCommitteeContributionRequest(mockWebServer.url("/"), okHttpClient, spec); + slot = dataStructureUtil.randomSlot(); + subcommitteeIndex = dataStructureUtil.randomPositiveInt(); + root = dataStructureUtil.randomBytes32(); + } + + @TestTemplate + public void createSyncCommitteeContribution_noRequestAtPhase0() { + assumeThat(specMilestone).isLessThanOrEqualTo(PHASE0); + request.submit(slot, subcommitteeIndex, root); + assertThat(mockWebServer.getRequestCount()).isZero(); + } + + @TestTemplate + public void createSyncCommitteeContribution_makesExpectedRequest() throws Exception { + assumeThat(specMilestone).isGreaterThan(PHASE0); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); + request.submit(slot, subcommitteeIndex, root); + final RecordedRequest request = mockWebServer.takeRequest(); + assertThat(request.getMethod()).isEqualTo("GET"); + assertThat(request.getPath()) + .contains( + ValidatorApiMethod.GET_SYNC_COMMITTEE_CONTRIBUTION.getPath(Collections.emptyMap())); + assertThat(request.getRequestUrl().queryParameter(SLOT)).isEqualTo(slot.toString()); + assertThat(request.getRequestUrl().queryParameter(SUBCOMMITTEE_INDEX)) + .isEqualTo(String.valueOf(subcommitteeIndex)); + assertThat(request.getRequestUrl().queryParameter(BEACON_BLOCK_ROOT)) + .isEqualTo(String.valueOf(root.toHexString())); + } + + @TestTemplate + public void shouldGetSyncCommitteeContribution() throws JsonProcessingException { + assumeThat(specMilestone).isGreaterThan(PHASE0); + final SyncCommitteeContribution response = dataStructureUtil.randomSyncCommitteeContribution(); + final String jsonResponse = + serialize( + response, + spec.getGenesisSchemaDefinitions() + .toVersionAltair() + .orElseThrow() + .getSyncCommitteeContributionSchema() + .getJsonTypeDefinition()); + + mockWebServer.enqueue( + new MockResponse() + .setResponseCode(SC_OK) + .setBody(String.format("{\"data\":%s}", jsonResponse))); + + final Optional maybeSyncCommitteeContribution = + request.submit(slot, subcommitteeIndex, root); + assertThat(maybeSyncCommitteeContribution).isPresent(); + assertThat(maybeSyncCommitteeContribution.get()).isEqualTo(response); + } + + @TestTemplate + void handle400() { + assumeThat(specMilestone).isGreaterThan(PHASE0); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); + assertThatThrownBy(() -> request.submit(slot, subcommitteeIndex, root)) + .isInstanceOf(IllegalArgumentException.class); + } + + @TestTemplate + void handle404() { + assumeThat(specMilestone).isGreaterThan(PHASE0); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NOT_FOUND)); + assertThat(request.submit(slot, subcommitteeIndex, root)).isEmpty(); + } + + @TestTemplate + void handle500() { + assumeThat(specMilestone).isGreaterThan(PHASE0); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy(() -> request.submit(slot, subcommitteeIndex, root)) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } +} diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetGenesisRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetGenesisRequestTest.java new file mode 100644 index 00000000000..6ccb4276710 --- /dev/null +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetGenesisRequestTest.java @@ -0,0 +1,74 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static java.nio.charset.StandardCharsets.UTF_8; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; + +import com.google.common.io.Resources; +import java.io.IOException; +import java.util.Optional; +import okhttp3.mockwebserver.MockResponse; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; +import tech.pegasys.teku.ethereum.json.types.beacon.GetGenesisApiData; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.validator.remote.typedef.AbstractTypeDefRequestTestBase; + +@TestSpecContext(network = Eth2Network.MINIMAL) +public class GetGenesisRequestTest extends AbstractTypeDefRequestTestBase { + + private GetGenesisRequest getGenesisRequest; + + @BeforeEach + public void setupRequest() { + getGenesisRequest = new GetGenesisRequest(mockWebServer.url("/"), okHttpClient); + } + + @TestTemplate + void shouldHandleSuccessfulResponse() throws IOException { + final String mockResponse = + Resources.toString( + Resources.getResource(GetGenesisRequestTest.class, "getGenesisRequest_200.json"), + UTF_8); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK).setBody(mockResponse)); + final Optional response = getGenesisRequest.submit(); + assertThat(response).isPresent(); + assertThat(response.get().getGenesisTime()).isEqualTo(UInt64.valueOf(1590832934)); + } + + @TestTemplate + void shouldHandleNotFoundResponse() { + mockWebServer.enqueue( + new MockResponse() + .setResponseCode(SC_NOT_FOUND) + .setBody("{\"code\": 404, \"message\": \"Not Ready\"}")); + final Optional response = getGenesisRequest.submit(); + assertThat(response).isEmpty(); + } + + @TestTemplate + void shouldHandleErrorResponse() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy(() -> getGenesisRequest.submit()) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } +} diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetPeerCountRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetPeerCountRequestTest.java new file mode 100644 index 00000000000..544275d5118 --- /dev/null +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetPeerCountRequestTest.java @@ -0,0 +1,63 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; + +import java.util.Optional; +import okhttp3.mockwebserver.MockResponse; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; +import tech.pegasys.teku.ethereum.json.types.node.PeerCount; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.validator.remote.typedef.AbstractTypeDefRequestTestBase; + +@TestSpecContext(network = Eth2Network.MINIMAL) +public class GetPeerCountRequestTest extends AbstractTypeDefRequestTestBase { + + private GetPeerCountRequest request; + + @BeforeEach + public void setupRequest() { + request = new GetPeerCountRequest(mockWebServer.url("/"), okHttpClient); + } + + @TestTemplate + public void correctResponseDeserialization() { + final String mockResponse = readResource("responses/get_peer_count.json"); + + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK).setBody(mockResponse)); + + final Optional maybePeerCount = request.submit(); + assertThat(maybePeerCount).isPresent(); + + final PeerCount peerCount = maybePeerCount.get(); + assertThat(peerCount.getConnected().longValue()).isEqualTo(56); + assertThat(peerCount.getDisconnected().longValue()).isEqualTo(12); + assertThat(peerCount.getConnecting().longValue()).isEqualTo(0); + assertThat(peerCount.getDisconnecting().longValue()).isEqualTo(0); + } + + @TestTemplate + void handle500() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy(() -> request.submit()) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } +} diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetProposerDutiesRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetProposerDutiesRequestTest.java new file mode 100644 index 00000000000..2e97792a8d9 --- /dev/null +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetProposerDutiesRequestTest.java @@ -0,0 +1,78 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; + +import java.util.Optional; +import okhttp3.mockwebserver.MockResponse; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; +import tech.pegasys.teku.ethereum.json.types.validator.ProposerDuties; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.validator.remote.typedef.AbstractTypeDefRequestTestBase; + +@TestSpecContext(allMilestones = true, network = Eth2Network.MINIMAL) +public class GetProposerDutiesRequestTest extends AbstractTypeDefRequestTestBase { + private GetProposerDutiesRequest request; + + @BeforeEach + public void setupRequest() { + request = new GetProposerDutiesRequest(mockWebServer.url("/"), okHttpClient); + } + + @TestTemplate + void canDeserializeResponse() { + final String mockResponse = readResource("responses/get_proposer_duties_response.json"); + + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK).setBody(mockResponse)); + + final Optional response = request.submit(UInt64.ZERO); + assertThat(response).isPresent(); + assertThat(response.get().getDuties().size()).isEqualTo(1); + assertThat(response.get().getDuties().getFirst().getValidatorIndex()).isEqualTo(1); + } + + @TestTemplate + void handle503() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_SERVICE_UNAVAILABLE)); + assertThatThrownBy(() -> request.submit(UInt64.ZERO)) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } + + @TestTemplate + void handle500() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy(() -> request.submit(UInt64.ZERO)) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } + + @TestTemplate + void handle400() { + mockWebServer.enqueue( + new MockResponse() + .setResponseCode(SC_BAD_REQUEST) + .setBody("{\"code\": 400, \"message\": \"Bad Request\"}")); + assertThatThrownBy(() -> request.submit(UInt64.ZERO)) + .isInstanceOf(IllegalArgumentException.class); + } +} diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetSpecRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetSpecRequestTest.java new file mode 100644 index 00000000000..861702feab9 --- /dev/null +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetSpecRequestTest.java @@ -0,0 +1,56 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; + +import java.util.Map; +import java.util.Optional; +import okhttp3.mockwebserver.MockResponse; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.validator.remote.typedef.AbstractTypeDefRequestTestBase; + +@TestSpecContext(network = Eth2Network.MINIMAL) +public class GetSpecRequestTest extends AbstractTypeDefRequestTestBase { + private GetSpecRequest request; + + @BeforeEach + public void setupRequest() { + request = new GetSpecRequest(mockWebServer.url("/"), okHttpClient); + } + + @TestTemplate + void successfulRequest() { + mockWebServer.enqueue( + new MockResponse().setResponseCode(SC_OK).setBody("{ \"data\":{\"a\":\"b\"}}")); + + final Optional> response = request.submit(); + assertThat(response).isPresent(); + assertThat(response.get().size()).isGreaterThan(0); + } + + @TestTemplate + void handle500() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy(() -> request.submit()) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } +} diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetStateValidatorsRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetStateValidatorsRequestTest.java new file mode 100644 index 00000000000..d46b00546cf --- /dev/null +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetStateValidatorsRequestTest.java @@ -0,0 +1,133 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.assertj.core.api.Assumptions.assumeThat; +import static tech.pegasys.teku.ethereum.json.types.beacon.StateValidatorDataBuilder.STATE_VALIDATORS_RESPONSE_TYPE; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.PARAM_ID; +import static tech.pegasys.teku.infrastructure.json.JsonUtil.serialize; +import static tech.pegasys.teku.spec.SpecMilestone.PHASE0; +import static tech.pegasys.teku.spec.config.SpecConfig.FAR_FUTURE_EPOCH; + +import com.fasterxml.jackson.core.JsonProcessingException; +import java.util.Collections; +import java.util.List; +import java.util.Optional; +import okhttp3.mockwebserver.MockResponse; +import okhttp3.mockwebserver.RecordedRequest; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; +import tech.pegasys.teku.api.response.v1.beacon.ValidatorStatus; +import tech.pegasys.teku.ethereum.json.types.beacon.StateValidatorData; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; +import tech.pegasys.teku.spec.datastructures.state.Validator; +import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod; +import tech.pegasys.teku.validator.remote.typedef.AbstractTypeDefRequestTestBase; + +@TestSpecContext(allMilestones = true, network = Eth2Network.MINIMAL) +public class GetStateValidatorsRequestTest extends AbstractTypeDefRequestTestBase { + + private GetStateValidatorsRequest request; + private List validatorIds; + + @BeforeEach + public void setup() { + request = new GetStateValidatorsRequest(mockWebServer.url("/"), okHttpClient); + validatorIds = + List.of( + dataStructureUtil.randomPublicKey().toHexString(), + dataStructureUtil.randomPublicKey().toHexString()); + } + + @TestTemplate + public void getStateValidatorsRequest_makesExpectedRequest() throws Exception { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); + request.submit(validatorIds); + final RecordedRequest request = mockWebServer.takeRequest(); + assertThat(request.getMethod()).isEqualTo("GET"); + assertThat(request.getPath()) + .contains(ValidatorApiMethod.GET_VALIDATORS.getPath(Collections.emptyMap())); + assertThat(request.getRequestUrl().queryParameter(PARAM_ID)) + .isEqualTo(String.join(",", validatorIds)); + } + + @TestTemplate + public void shouldGetStateValidatorsData() throws JsonProcessingException { + final List expected = + List.of(generateStateValidatorData(), generateStateValidatorData()); + final ObjectAndMetaData> response = + new ObjectAndMetaData<>(expected, specMilestone, false, true, false); + + final String body = serialize(response, STATE_VALIDATORS_RESPONSE_TYPE); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK).setBody(body)); + + final Optional>> maybeStateValidatorsData = + request.submit(validatorIds); + assertThat(maybeStateValidatorsData).isPresent(); + assertThat(maybeStateValidatorsData.get().getData()).isEqualTo(expected); + } + + @TestTemplate + void handle400() { + assumeThat(specMilestone).isGreaterThan(PHASE0); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); + assertThatThrownBy(() -> request.submit(validatorIds)) + .isInstanceOf(IllegalArgumentException.class); + } + + @TestTemplate + void handle404() { + assumeThat(specMilestone).isGreaterThan(PHASE0); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NOT_FOUND)); + assertThat(request.submit(validatorIds)).isEmpty(); + } + + @TestTemplate + void handle500() { + assumeThat(specMilestone).isGreaterThan(PHASE0); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy(() -> request.submit(validatorIds)) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } + + private StateValidatorData generateStateValidatorData() { + final long index = dataStructureUtil.randomLong(); + final Validator validator = + new Validator( + dataStructureUtil.randomPublicKey(), + dataStructureUtil.randomBytes32(), + dataStructureUtil.randomUInt64(), + false, + UInt64.ZERO, + UInt64.ZERO, + FAR_FUTURE_EPOCH, + FAR_FUTURE_EPOCH); + return new StateValidatorData( + UInt64.valueOf(index), + dataStructureUtil.randomUInt64(), + ValidatorStatus.active_ongoing, + validator); + } +} diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetSyncingStatusRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetSyncingStatusRequestTest.java index 9ea4dec2ba9..3c064bc186a 100644 --- a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetSyncingStatusRequestTest.java +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetSyncingStatusRequestTest.java @@ -14,11 +14,14 @@ package tech.pegasys.teku.validator.remote.typedef.handlers; import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import okhttp3.mockwebserver.MockResponse; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; import tech.pegasys.teku.spec.TestSpecContext; import tech.pegasys.teku.spec.networks.Eth2Network; import tech.pegasys.teku.validator.api.required.SyncingStatus; @@ -31,17 +34,24 @@ public class GetSyncingStatusRequestTest extends AbstractTypeDefRequestTestBase @BeforeEach void setupRequest() { - request = new GetSyncingStatusRequest(okHttpClient, mockWebServer.url("/")); + request = new GetSyncingStatusRequest(mockWebServer.url("/"), okHttpClient); } @TestTemplate - public void getSyncingStatus_setsElOfflineToEmptyIfFieldDoesNotExist() { + public void setsElOfflineToEmptyIfFieldDoesNotExist() { final String mockResponse = readResource("responses/syncing_no_el_offline.json"); mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK).setBody(mockResponse)); - final SyncingStatus syncingStatus = request.getSyncingStatus(); + final SyncingStatus syncingStatus = request.submit(); assertThat(syncingStatus.isElOffline()).isNotNull().isEmpty(); } + + @TestTemplate + void handle500() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy(() -> request.submit()) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } } diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostAttesterDutiesRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostAttesterDutiesRequestTest.java new file mode 100644 index 00000000000..f01c87f9633 --- /dev/null +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostAttesterDutiesRequestTest.java @@ -0,0 +1,91 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.INTEGER_TYPE; + +import java.util.List; +import java.util.Map; +import okhttp3.mockwebserver.MockResponse; +import okhttp3.mockwebserver.RecordedRequest; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; +import tech.pegasys.teku.infrastructure.http.RestApiConstants; +import tech.pegasys.teku.infrastructure.json.JsonUtil; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod; +import tech.pegasys.teku.validator.remote.typedef.AbstractTypeDefRequestTestBase; + +@TestSpecContext(allMilestones = true, network = Eth2Network.MINIMAL) +public class PostAttesterDutiesRequestTest extends AbstractTypeDefRequestTestBase { + + private PostAttesterDutiesRequest request; + private UInt64 epoch; + private List validatorIndices; + + @BeforeEach + public void setup() { + request = new PostAttesterDutiesRequest(mockWebServer.url("/"), okHttpClient); + epoch = dataStructureUtil.randomEpoch(); + validatorIndices = + List.of( + dataStructureUtil.randomValidatorIndex().intValue(), + dataStructureUtil.randomValidatorIndex().intValue()); + } + + @TestTemplate + public void postAttesterDuties_makesExpectedRequest() throws Exception { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); + request.submit(epoch, validatorIndices); + final RecordedRequest request = mockWebServer.takeRequest(); + assertThat(request.getMethod()).isEqualTo("POST"); + assertThat(request.getPath()) + .contains( + ValidatorApiMethod.GET_ATTESTATION_DUTIES.getPath( + Map.of(RestApiConstants.EPOCH, epoch.toString()))); + final String requestBody = + JsonUtil.serialize(validatorIndices, DeserializableTypeDefinition.listOf(INTEGER_TYPE)); + assertThat(request.getBody().readUtf8()).isEqualTo(requestBody); + } + + @TestTemplate + void handle400() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); + assertThatThrownBy(() -> request.submit(epoch, validatorIndices)) + .isInstanceOf(IllegalArgumentException.class); + } + + @TestTemplate + void handle404() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NOT_FOUND)); + assertThat(request.submit(epoch, validatorIndices)).isEmpty(); + } + + @TestTemplate + void handle500() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy(() -> request.submit(epoch, validatorIndices)) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } +} diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostStateValidatorsRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostStateValidatorsRequestTest.java new file mode 100644 index 00000000000..5ede2f5adb9 --- /dev/null +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostStateValidatorsRequestTest.java @@ -0,0 +1,77 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; + +import java.util.List; +import java.util.Optional; +import okhttp3.mockwebserver.MockResponse; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; +import tech.pegasys.teku.ethereum.json.types.beacon.StateValidatorData; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; +import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.validator.remote.apiclient.PostStateValidatorsNotExistingException; +import tech.pegasys.teku.validator.remote.typedef.AbstractTypeDefRequestTestBase; + +@TestSpecContext(network = Eth2Network.MINIMAL) +public class PostStateValidatorsRequestTest extends AbstractTypeDefRequestTestBase { + private PostStateValidatorsRequest request; + + @BeforeEach + public void setupRequest() { + request = new PostStateValidatorsRequest(mockWebServer.url("/"), okHttpClient); + } + + @TestTemplate + void canHandleResponse() { + final String mockResponse = readResource("responses/state_validators_response.json"); + + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK).setBody(mockResponse)); + final Optional>> response = + request.submit(List.of("1")); + assertThat(response).isPresent(); + assertThat(response.get().getData().getFirst().getIndex()).isEqualTo(UInt64.ONE); + } + + @TestTemplate + void handle404() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NOT_FOUND)); + assertThatThrownBy(() -> request.submit(List.of("1"))) + .isInstanceOf(PostStateValidatorsNotExistingException.class); + } + + @TestTemplate + void handle400() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); + assertThatThrownBy(() -> request.submit(List.of("1"))) + .isInstanceOf(PostStateValidatorsNotExistingException.class); + } + + @TestTemplate + void handle500() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy(() -> request.submit(List.of("1"))) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } +} diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostSyncDutiesRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostSyncDutiesRequestTest.java new file mode 100644 index 00000000000..1b0db23b982 --- /dev/null +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostSyncDutiesRequestTest.java @@ -0,0 +1,90 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.INTEGER_TYPE; + +import java.util.List; +import java.util.Map; +import okhttp3.mockwebserver.MockResponse; +import okhttp3.mockwebserver.RecordedRequest; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; +import tech.pegasys.teku.infrastructure.http.RestApiConstants; +import tech.pegasys.teku.infrastructure.json.JsonUtil; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod; +import tech.pegasys.teku.validator.remote.typedef.AbstractTypeDefRequestTestBase; + +@TestSpecContext(allMilestones = true, network = Eth2Network.MINIMAL) +public class PostSyncDutiesRequestTest extends AbstractTypeDefRequestTestBase { + private PostSyncDutiesRequest request; + private UInt64 epoch; + private List validatorIndices; + + @BeforeEach + public void setup() { + request = new PostSyncDutiesRequest(mockWebServer.url("/"), okHttpClient); + epoch = dataStructureUtil.randomEpoch(); + validatorIndices = + List.of( + dataStructureUtil.randomValidatorIndex().intValue(), + dataStructureUtil.randomValidatorIndex().intValue()); + } + + @TestTemplate + public void postAttesterDuties_makesExpectedRequest() throws Exception { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); + request.submit(epoch, validatorIndices); + final RecordedRequest request = mockWebServer.takeRequest(); + assertThat(request.getMethod()).isEqualTo("POST"); + assertThat(request.getPath()) + .contains( + ValidatorApiMethod.GET_SYNC_COMMITTEE_DUTIES.getPath( + Map.of(RestApiConstants.EPOCH, epoch.toString()))); + final String requestBody = + JsonUtil.serialize(validatorIndices, DeserializableTypeDefinition.listOf(INTEGER_TYPE)); + assertThat(request.getBody().readUtf8()).isEqualTo(requestBody); + } + + @TestTemplate + void handle400() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); + assertThatThrownBy(() -> request.submit(epoch, validatorIndices)) + .isInstanceOf(IllegalArgumentException.class); + } + + @TestTemplate + void handle404() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NOT_FOUND)); + assertThat(request.submit(epoch, validatorIndices)).isEmpty(); + } + + @TestTemplate + void handle500() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy(() -> request.submit(epoch, validatorIndices)) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } +} diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostVoluntaryExitRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostVoluntaryExitRequestTest.java new file mode 100644 index 00000000000..316c85cb58a --- /dev/null +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostVoluntaryExitRequestTest.java @@ -0,0 +1,63 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static org.assertj.core.api.Assertions.assertThatNoException; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; + +import okhttp3.mockwebserver.MockResponse; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; +import tech.pegasys.teku.infrastructure.json.exceptions.BadRequestException; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; +import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.validator.remote.typedef.AbstractTypeDefRequestTestBase; + +@TestSpecContext(network = Eth2Network.MINIMAL) +public class PostVoluntaryExitRequestTest extends AbstractTypeDefRequestTestBase { + private PostVoluntaryExitRequest request; + + @BeforeEach + public void setupRequest() { + request = new PostVoluntaryExitRequest(mockWebServer.url("/"), okHttpClient); + } + + @TestTemplate + void handle200() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK)); + final SignedVoluntaryExit exit = dataStructureUtil.randomSignedVoluntaryExit(); + + assertThatNoException().isThrownBy(() -> request.submit(exit)); + } + + @TestTemplate + void handle400() { + final SignedVoluntaryExit exit = dataStructureUtil.randomSignedVoluntaryExit(); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); + assertThatThrownBy(() -> request.submit(exit)).isInstanceOf(BadRequestException.class); + } + + @TestTemplate + void handle500() { + final SignedVoluntaryExit exit = dataStructureUtil.randomSignedVoluntaryExit(); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy(() -> request.submit(exit)) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } +} diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/PrepareBeaconProposersRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/PrepareBeaconProposersRequestTest.java new file mode 100644 index 00000000000..0d1cf6dcec2 --- /dev/null +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/PrepareBeaconProposersRequestTest.java @@ -0,0 +1,85 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; + +import java.util.Collections; +import java.util.List; +import okhttp3.mockwebserver.MockResponse; +import okhttp3.mockwebserver.RecordedRequest; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; +import tech.pegasys.teku.infrastructure.json.JsonUtil; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.datastructures.validator.BeaconPreparableProposer; +import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod; +import tech.pegasys.teku.validator.remote.typedef.AbstractTypeDefRequestTestBase; + +@TestSpecContext(allMilestones = true, network = Eth2Network.MINIMAL) +public class PrepareBeaconProposersRequestTest extends AbstractTypeDefRequestTestBase { + private PrepareBeaconProposersRequest request; + private List beaconPreparableProposers; + + @BeforeEach + public void setup() { + request = new PrepareBeaconProposersRequest(mockWebServer.url("/"), okHttpClient); + beaconPreparableProposers = + List.of( + dataStructureUtil.randomBeaconPreparableProposer(), + dataStructureUtil.randomBeaconPreparableProposer()); + } + + @TestTemplate + public void postAttesterDuties_makesExpectedRequest() throws Exception { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK)); + request.submit(beaconPreparableProposers); + final RecordedRequest request = mockWebServer.takeRequest(); + assertThat(request.getMethod()).isEqualTo("POST"); + assertThat(request.getPath()) + .contains(ValidatorApiMethod.PREPARE_BEACON_PROPOSER.getPath(Collections.emptyMap())); + final String requestBody = + JsonUtil.serialize( + beaconPreparableProposers, + DeserializableTypeDefinition.listOf(BeaconPreparableProposer.SSZ_DATA)); + assertThat(request.getBody().readUtf8()).isEqualTo(requestBody); + } + + @TestTemplate + public void prepareBeaconProposer_noRequestWhenEmptyList() { + request.submit(List.of()); + assertThat(mockWebServer.getRequestCount()).isEqualTo(0); + } + + @TestTemplate + void handle400() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); + assertThatThrownBy(() -> request.submit(beaconPreparableProposers)) + .isInstanceOf(IllegalArgumentException.class); + } + + @TestTemplate + void handle500() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy(() -> request.submit(beaconPreparableProposers)) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } +} diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/ProduceBlockRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/ProduceBlockRequestTest.java index 0292b8eb8e3..40be9a20f3d 100644 --- a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/ProduceBlockRequestTest.java +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/ProduceBlockRequestTest.java @@ -16,6 +16,7 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.assertj.core.api.Assumptions.assumeThat; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_BLOCK_VALUE; @@ -35,6 +36,7 @@ import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.SpecMilestone; @@ -43,6 +45,7 @@ import tech.pegasys.teku.spec.datastructures.blocks.versions.deneb.BlockContents; import tech.pegasys.teku.spec.datastructures.metadata.BlockContainerAndMetaData; import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; import tech.pegasys.teku.validator.remote.typedef.AbstractTypeDefRequestTestBase; @TestSpecContext(allMilestones = true, network = Eth2Network.MINIMAL) @@ -54,7 +57,12 @@ public class ProduceBlockRequestTest extends AbstractTypeDefRequestTestBase { @BeforeEach void setupRequest() { request = - new ProduceBlockRequest(mockWebServer.url("/"), okHttpClient, spec, UInt64.ONE, false); + new ProduceBlockRequest( + mockWebServer.url("/"), + okHttpClient, + new SchemaDefinitionCache(spec), + UInt64.ONE, + false); responseBodyBuffer = new Buffer(); } @@ -82,7 +90,7 @@ public void shouldGetUnblindedBeaconBlockAsJson() { final BLSSignature signature = beaconBlock.getBlock().getBody().getRandaoReveal(); final Optional maybeBlockContainerAndMetaData = - request.createUnsignedBlock(signature, Optional.empty(), Optional.empty()); + request.submit(signature, Optional.empty(), Optional.empty()); assertThat(maybeBlockContainerAndMetaData).isPresent(); @@ -134,7 +142,7 @@ public void shouldGetUnblindedBeaconBlockAsSsz() { final BLSSignature signature = beaconBlock.getBlock().getBody().getRandaoReveal(); final Optional maybeBlockContainerAndMetaData = - request.createUnsignedBlock(signature, Optional.empty(), Optional.empty()); + request.submit(signature, Optional.empty(), Optional.empty()); assertThat(maybeBlockContainerAndMetaData).isPresent(); @@ -165,7 +173,7 @@ public void shouldGetBlindedBeaconBlockAsJson() { final BLSSignature signature = blindedBeaconBlock.getBlock().getBody().getRandaoReveal(); final Optional maybeBlockContainerAndMetaData = - request.createUnsignedBlock(signature, Optional.empty(), Optional.empty()); + request.submit(signature, Optional.empty(), Optional.empty()); assertThat(maybeBlockContainerAndMetaData.map(BlockContainerAndMetaData::blockContainer)) .hasValue(blockResponse.getData()); @@ -195,7 +203,7 @@ public void shouldGetBlindedBeaconBlockAsSsz() { final BLSSignature signature = blindedBeaconBlock.getBlock().getBody().getRandaoReveal(); final Optional maybeBlockContainerAndMetaData = - request.createUnsignedBlock(signature, Optional.empty(), Optional.empty()); + request.submit(signature, Optional.empty(), Optional.empty()); assertThat(maybeBlockContainerAndMetaData).isPresent(); @@ -221,7 +229,7 @@ public void shouldGetUnblindedBlockContentsPostDenebAsJson() { final BLSSignature signature = blockContents.getBlock().getBody().getRandaoReveal(); final Optional maybeBlockContainerAndMetaData = - request.createUnsignedBlock(signature, Optional.empty(), Optional.empty()); + request.submit(signature, Optional.empty(), Optional.empty()); assertThat(maybeBlockContainerAndMetaData).isPresent(); @@ -251,7 +259,7 @@ public void shouldGetUnblindedBlockContentsPostDenebAsSsz() { final BLSSignature signature = blockContents.getBlock().getBody().getRandaoReveal(); final Optional maybeBlockContainerAndMetaData = - request.createUnsignedBlock(signature, Optional.empty(), Optional.empty()); + request.submit(signature, Optional.empty(), Optional.empty()); assertThat(maybeBlockContainerAndMetaData).isPresent(); @@ -270,8 +278,7 @@ public void shouldPassUrlParameters() throws InterruptedException { mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NOT_FOUND)); // no optional parameters - assertThatThrownBy( - () -> request.createUnsignedBlock(signature, Optional.empty(), Optional.empty())); + assertThat(request.submit(signature, Optional.empty(), Optional.empty())).isEmpty(); recordedRequest = mockWebServer.takeRequest(); @@ -284,10 +291,9 @@ public void shouldPassUrlParameters() throws InterruptedException { mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NOT_FOUND)); // with all parameters - assertThatThrownBy( - () -> - request.createUnsignedBlock( - signature, Optional.of(Bytes32.ZERO), Optional.of(UInt64.valueOf(48)))); + assertThat( + request.submit(signature, Optional.of(Bytes32.ZERO), Optional.of(UInt64.valueOf(48)))) + .isEmpty(); recordedRequest = mockWebServer.takeRequest(); @@ -300,6 +306,18 @@ public void shouldPassUrlParameters() throws InterruptedException { .isEqualTo("48"); } + @TestTemplate + void handle500() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy( + () -> + request.submit( + BLSSignature.empty(), + Optional.of(Bytes32.ZERO), + Optional.of(UInt64.valueOf(48)))) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } + private String readExpectedJsonResource( final SpecMilestone specMilestone, final boolean blinded, final boolean blockContents) { final String fileName = diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/RegisterValidatorsRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/RegisterValidatorsRequestTest.java new file mode 100644 index 00000000000..306bac622c0 --- /dev/null +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/RegisterValidatorsRequestTest.java @@ -0,0 +1,93 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; + +import java.util.Collections; +import okhttp3.mockwebserver.MockResponse; +import okhttp3.mockwebserver.RecordedRequest; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; +import tech.pegasys.teku.infrastructure.json.JsonUtil; +import tech.pegasys.teku.infrastructure.ssz.SszList; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.datastructures.builder.SignedValidatorRegistration; +import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.spec.schemas.ApiSchemas; +import tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod; +import tech.pegasys.teku.validator.remote.typedef.AbstractTypeDefRequestTestBase; + +@TestSpecContext(allMilestones = true, network = Eth2Network.MINIMAL) +public class RegisterValidatorsRequestTest extends AbstractTypeDefRequestTestBase { + + private RegisterValidatorsRequest request; + private SszList validatorRegistrations; + + @BeforeEach + public void setup() { + request = new RegisterValidatorsRequest(mockWebServer.url("/"), okHttpClient, true); + validatorRegistrations = dataStructureUtil.randomSignedValidatorRegistrations(10); + } + + @TestTemplate + public void postAttesterDuties_makesExpectedRequestAsSsz() throws Exception { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK)); + request.submit(validatorRegistrations); + final RecordedRequest request = mockWebServer.takeRequest(); + assertThat(request.getMethod()).isEqualTo("POST"); + assertThat(request.getPath()) + .contains(ValidatorApiMethod.REGISTER_VALIDATOR.getPath(Collections.emptyMap())); + final byte[] requestBody = + ApiSchemas.SIGNED_VALIDATOR_REGISTRATIONS_SCHEMA + .sszSerialize(validatorRegistrations) + .toArray(); + assertThat(request.getBody().readByteArray()).isEqualTo(requestBody); + } + + @TestTemplate + public void postAttesterDuties_makesExpectedRequestAsJson() throws Exception { + request = new RegisterValidatorsRequest(mockWebServer.url("/"), okHttpClient, false); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK)); + request.submit(validatorRegistrations); + final RecordedRequest request = mockWebServer.takeRequest(); + assertThat(request.getMethod()).isEqualTo("POST"); + assertThat(request.getPath()) + .contains(ValidatorApiMethod.REGISTER_VALIDATOR.getPath(Collections.emptyMap())); + final String requestBody = + JsonUtil.serialize( + validatorRegistrations, + ApiSchemas.SIGNED_VALIDATOR_REGISTRATIONS_SCHEMA.getJsonTypeDefinition()); + assertThat(request.getBody().readUtf8()).isEqualTo(requestBody); + } + + @TestTemplate + void handle400() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); + assertThatThrownBy(() -> request.submit(validatorRegistrations)) + .isInstanceOf(IllegalArgumentException.class); + } + + @TestTemplate + void handle500() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy(() -> request.submit(validatorRegistrations)) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } +} diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendAggregatesAndProofsRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendAggregatesAndProofsRequestTest.java new file mode 100644 index 00000000000..7b2a269cd6b --- /dev/null +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendAggregatesAndProofsRequestTest.java @@ -0,0 +1,116 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static java.util.Collections.emptyMap; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; + +import com.fasterxml.jackson.core.JsonProcessingException; +import java.util.List; +import java.util.Locale; +import okhttp3.mockwebserver.MockResponse; +import okhttp3.mockwebserver.RecordedRequest; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; +import tech.pegasys.teku.infrastructure.http.RestApiConstants; +import tech.pegasys.teku.infrastructure.json.JsonUtil; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof; +import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.validator.api.SubmitDataError; +import tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod; +import tech.pegasys.teku.validator.remote.typedef.AbstractTypeDefRequestTestBase; + +@TestSpecContext( + milestone = {SpecMilestone.CAPELLA, SpecMilestone.ELECTRA}, + network = Eth2Network.MINIMAL) +public class SendAggregatesAndProofsRequestTest extends AbstractTypeDefRequestTestBase { + private SendAggregateAndProofsRequest request; + private List aggregateAndProofs; + + @BeforeEach + public void setup() { + this.request = + new SendAggregateAndProofsRequest(mockWebServer.url("/"), okHttpClient, false, spec); + this.aggregateAndProofs = List.of(dataStructureUtil.randomSignedAggregateAndProof()); + } + + @TestTemplate + void handle200() throws InterruptedException, JsonProcessingException { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK)); + final List response = request.submit(aggregateAndProofs); + assertThat(response).isEmpty(); + final RecordedRequest recordedRequest = mockWebServer.takeRequest(); + final List data = + JsonUtil.parse( + recordedRequest.getBody().readUtf8(), + DeserializableTypeDefinition.listOf( + spec.getGenesisSchemaDefinitions() + .getSignedAggregateAndProofSchema() + .getJsonTypeDefinition())); + assertThat(data).isEqualTo(aggregateAndProofs); + assertThat(recordedRequest.getMethod()).isEqualTo("POST"); + if (specMilestone.isGreaterThanOrEqualTo(SpecMilestone.ELECTRA)) { + assertThat(recordedRequest.getPath()) + .contains(ValidatorApiMethod.SEND_SIGNED_AGGREGATE_AND_PROOFS_V2.getPath(emptyMap())); + assertThat(recordedRequest.getHeader(RestApiConstants.HEADER_CONSENSUS_VERSION)) + .isEqualTo(specMilestone.name().toLowerCase(Locale.ROOT)); + assertThat(recordedRequest.getHeader(HEADER_CONSENSUS_VERSION)) + .isEqualTo(specMilestone.name().toLowerCase(Locale.ROOT)); + } else { + assertThat(recordedRequest.getPath()) + .contains(ValidatorApiMethod.SEND_SIGNED_AGGREGATE_AND_PROOFS.getPath(emptyMap())); + } + } + + @TestTemplate + void handle500() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy(() -> request.submit(aggregateAndProofs)) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } + + @TestTemplate + void handle400() { + mockWebServer.enqueue( + new MockResponse() + .setResponseCode(SC_BAD_REQUEST) + .setBody( + "{\"code\": 400,\"message\": \"z\",\"failures\": [{\"index\": 3,\"message\": \"a\"}]}")); + final List response = request.submit(aggregateAndProofs); + assertThat(response).containsExactly(new SubmitDataError(UInt64.valueOf(3), "a")); + } + + @TestTemplate + void shouldUseV2ApiWhenUseAttestationsV2ApisEnabled() throws InterruptedException { + this.request = + new SendAggregateAndProofsRequest(mockWebServer.url("/"), okHttpClient, true, spec); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK)); + final List response = request.submit(aggregateAndProofs); + assertThat(response).isEmpty(); + final RecordedRequest recordedRequest = mockWebServer.takeRequest(); + assertThat(recordedRequest.getMethod()).isEqualTo("POST"); + assertThat(recordedRequest.getPath()) + .contains(ValidatorApiMethod.SEND_SIGNED_AGGREGATE_AND_PROOFS_V2.getPath(emptyMap())); + } +} diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendContributionAndProofsRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendContributionAndProofsRequestTest.java new file mode 100644 index 00000000000..03fe13a5b2f --- /dev/null +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendContributionAndProofsRequestTest.java @@ -0,0 +1,88 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.assertj.core.api.Assumptions.assumeThat; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; +import static tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition.listOf; +import static tech.pegasys.teku.spec.SpecMilestone.PHASE0; + +import java.util.Collections; +import java.util.List; +import okhttp3.mockwebserver.MockResponse; +import okhttp3.mockwebserver.RecordedRequest; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; +import tech.pegasys.teku.infrastructure.json.JsonUtil; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SignedContributionAndProof; +import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod; +import tech.pegasys.teku.validator.remote.typedef.AbstractTypeDefRequestTestBase; + +@TestSpecContext(allMilestones = true, network = Eth2Network.MINIMAL) +public class SendContributionAndProofsRequestTest extends AbstractTypeDefRequestTestBase { + private SendContributionAndProofsRequest request; + private List contributionAndProofs; + + @BeforeEach + public void setup() { + assumeThat(specMilestone).isGreaterThan(PHASE0); + request = new SendContributionAndProofsRequest(mockWebServer.url("/"), okHttpClient); + contributionAndProofs = + List.of( + dataStructureUtil.randomSignedContributionAndProof(), + dataStructureUtil.randomSignedContributionAndProof()); + } + + @TestTemplate + public void postAttesterDuties_makesExpectedRequest() throws Exception { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); + request.submit(contributionAndProofs); + final RecordedRequest request = mockWebServer.takeRequest(); + assertThat(request.getMethod()).isEqualTo("POST"); + assertThat(request.getPath()) + .contains(ValidatorApiMethod.SEND_CONTRIBUTION_AND_PROOF.getPath(Collections.emptyMap())); + final String requestBody = + JsonUtil.serialize( + contributionAndProofs, + listOf(contributionAndProofs.getFirst().getSchema().getJsonTypeDefinition())); + assertThat(request.getBody().readUtf8()).isEqualTo(requestBody); + } + + @TestTemplate + void noRequestWhenEmptyList() { + request.submit(List.of()); + assertThat(mockWebServer.getRequestCount()).isZero(); + } + + @TestTemplate + void handle400() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); + assertThatThrownBy(() -> request.submit(contributionAndProofs)) + .isInstanceOf(IllegalArgumentException.class); + } + + @TestTemplate + void handle500() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy(() -> request.submit(contributionAndProofs)) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } +} diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSignedAttestationsRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSignedAttestationsRequestTest.java new file mode 100644 index 00000000000..6123a8dfe86 --- /dev/null +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSignedAttestationsRequestTest.java @@ -0,0 +1,123 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static java.util.Collections.emptyMap; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; + +import com.fasterxml.jackson.core.JsonProcessingException; +import java.util.Collections; +import java.util.List; +import java.util.Locale; +import okhttp3.mockwebserver.MockResponse; +import okhttp3.mockwebserver.RecordedRequest; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; +import tech.pegasys.teku.infrastructure.json.JsonUtil; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.validator.api.SubmitDataError; +import tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod; +import tech.pegasys.teku.validator.remote.typedef.AbstractTypeDefRequestTestBase; + +@TestSpecContext( + milestone = {SpecMilestone.CAPELLA, SpecMilestone.ELECTRA}, + network = Eth2Network.MINIMAL) +public class SendSignedAttestationsRequestTest extends AbstractTypeDefRequestTestBase { + private SendSignedAttestationsRequest request; + private List attestations; + + @BeforeEach + public void setup() { + this.request = + new SendSignedAttestationsRequest(mockWebServer.url("/"), okHttpClient, false, spec); + this.attestations = List.of(dataStructureUtil.randomAttestation()); + } + + @TestTemplate + void handle200() throws InterruptedException, JsonProcessingException { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK)); + final List response = request.submit(attestations); + assertThat(response).isEmpty(); + final RecordedRequest recordedRequest = mockWebServer.takeRequest(); + final List data = + JsonUtil.parse( + recordedRequest.getBody().readUtf8(), + DeserializableTypeDefinition.listOf( + spec.getGenesisSchemaDefinitions().getAttestationSchema().getJsonTypeDefinition())); + assertThat(data).isEqualTo(attestations); + assertThat(recordedRequest.getMethod()).isEqualTo("POST"); + if (specMilestone.isGreaterThanOrEqualTo(SpecMilestone.ELECTRA)) { + assertThat(recordedRequest.getPath()) + .contains(ValidatorApiMethod.SEND_SIGNED_ATTESTATION_V2.getPath(emptyMap())); + assertThat(recordedRequest.getRequestUrl().queryParameterNames()) + .isEqualTo(Collections.emptySet()); + assertThat(recordedRequest.getHeader(HEADER_CONSENSUS_VERSION)) + .isEqualTo(specMilestone.name().toLowerCase(Locale.ROOT)); + } else { + assertThat(recordedRequest.getPath()) + .contains(ValidatorApiMethod.SEND_SIGNED_ATTESTATION.getPath(emptyMap())); + } + } + + @TestTemplate + void shouldNoTMakeRequestIfEmptyAttestationsList() { + request.submit(Collections.emptyList()); + assertThat(mockWebServer.getRequestCount()).isZero(); + } + + @TestTemplate + void handle500() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy(() -> request.submit(attestations)) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } + + @TestTemplate + void handle400() { + mockWebServer.enqueue( + new MockResponse() + .setResponseCode(SC_BAD_REQUEST) + .setBody( + "{\"code\": 400,\"message\": \"z\",\"failures\": [{\"index\": 3,\"message\": \"a\"}]}")); + final List response = request.submit(attestations); + assertThat(response).containsExactly(new SubmitDataError(UInt64.valueOf(3), "a")); + } + + @TestTemplate + void shouldUseV2ApiWhenUseAttestationsV2ApisEnabled() + throws InterruptedException, JsonProcessingException { + this.request = + new SendSignedAttestationsRequest(mockWebServer.url("/"), okHttpClient, true, spec); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK)); + final List response = request.submit(attestations); + assertThat(response).isEmpty(); + final RecordedRequest recordedRequest = mockWebServer.takeRequest(); + assertThat(recordedRequest.getMethod()).isEqualTo("POST"); + assertThat(recordedRequest.getPath()) + .contains(ValidatorApiMethod.SEND_SIGNED_ATTESTATION_V2.getPath(emptyMap())); + assertThat(recordedRequest.getHeader(HEADER_CONSENSUS_VERSION)) + .isEqualTo(specMilestone.name().toLowerCase(Locale.ROOT)); + } +} diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSignedBlockRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSignedBlockRequestTest.java new file mode 100644 index 00000000000..fd5817d4a8e --- /dev/null +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSignedBlockRequestTest.java @@ -0,0 +1,107 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static java.util.Collections.emptyMap; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; + +import java.util.Locale; +import okhttp3.mockwebserver.MockResponse; +import okhttp3.mockwebserver.RecordedRequest; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockContainer; +import tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel; +import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod; +import tech.pegasys.teku.validator.remote.typedef.AbstractTypeDefRequestTestBase; + +@TestSpecContext( + milestone = { + SpecMilestone.BELLATRIX, + SpecMilestone.CAPELLA, + SpecMilestone.DENEB, + SpecMilestone.ELECTRA + }, + network = Eth2Network.MINIMAL) +public class SendSignedBlockRequestTest extends AbstractTypeDefRequestTestBase { + private SignedBlockContainer block; + private SendSignedBlockRequest request; + + @BeforeEach + public void setup() { + request = new SendSignedBlockRequest(spec, mockWebServer.url("/"), okHttpClient, true); + this.block = + specMilestone.isGreaterThanOrEqualTo(SpecMilestone.DENEB) + ? dataStructureUtil.randomSignedBlockContents() + : dataStructureUtil.randomSignedBeaconBlock(); + } + + @TestTemplate + public void shouldIncludeConsensusHeaderInJsonRequest() throws InterruptedException { + request = new SendSignedBlockRequest(spec, mockWebServer.url("/"), okHttpClient, false); + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK)); + + request.submit(block, BroadcastValidationLevel.NOT_REQUIRED); + + final RecordedRequest recordedRequest = mockWebServer.takeRequest(); + assertThat(recordedRequest.getMethod()).isEqualTo("POST"); + assertThat(recordedRequest.getPath()) + .contains(ValidatorApiMethod.SEND_SIGNED_BLOCK_V2.getPath(emptyMap())); + assertThat(recordedRequest.getHeader(HEADER_CONSENSUS_VERSION)) + .isEqualTo(specMilestone.name().toLowerCase(Locale.ROOT)); + assertThat(recordedRequest.getHeader("Content-Type")).contains("json"); + } + + @TestTemplate + public void shouldIncludeConsensusHeaderInSszRequest() throws InterruptedException { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK)); + + request.submit(block, BroadcastValidationLevel.NOT_REQUIRED); + + final RecordedRequest recordedRequest = mockWebServer.takeRequest(); + assertThat(recordedRequest.getMethod()).isEqualTo("POST"); + assertThat(recordedRequest.getPath()) + .contains(ValidatorApiMethod.SEND_SIGNED_BLOCK_V2.getPath(emptyMap())); + assertThat(recordedRequest.getHeader(HEADER_CONSENSUS_VERSION)) + .isEqualTo(specMilestone.name().toLowerCase(Locale.ROOT)); + assertThat(recordedRequest.getHeader("Content-Type")).contains("octet"); + } + + @TestTemplate + void handle500() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy(() -> request.submit(block, BroadcastValidationLevel.NOT_REQUIRED)) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } + + @TestTemplate + void handle400() { + mockWebServer.enqueue( + new MockResponse() + .setResponseCode(SC_BAD_REQUEST) + .setBody("{\"code\": 400,\"message\": \"z\"}")); + assertThatThrownBy(() -> request.submit(block, BroadcastValidationLevel.NOT_REQUIRED)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessageStartingWith("Invalid params response from Beacon Node API"); + } +} diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSubscribeToSyncCommitteeSubnetsRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSubscribeToSyncCommitteeSubnetsRequestTest.java new file mode 100644 index 00000000000..9e04a5b53b4 --- /dev/null +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSubscribeToSyncCommitteeSubnetsRequestTest.java @@ -0,0 +1,76 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; + +import it.unimi.dsi.fastutil.ints.IntSet; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import okhttp3.mockwebserver.MockResponse; +import okhttp3.mockwebserver.RecordedRequest; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; +import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSubnetSubscription; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod; +import tech.pegasys.teku.validator.remote.typedef.AbstractTypeDefRequestTestBase; + +@TestSpecContext(allMilestones = true, network = Eth2Network.MINIMAL) +public class SendSubscribeToSyncCommitteeSubnetsRequestTest extends AbstractTypeDefRequestTestBase { + private SendSubscribeToSyncCommitteeSubnetsRequest request; + final Collection subscriptions = + List.of(new SyncCommitteeSubnetSubscription(0, IntSet.of(1), UInt64.ZERO)); + + @BeforeEach + public void setup() { + request = new SendSubscribeToSyncCommitteeSubnetsRequest(mockWebServer.url("/"), okHttpClient); + } + + @TestTemplate + public void postAttesterDuties_makesExpectedRequest() throws Exception { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); + request.submit(subscriptions); + final RecordedRequest request = mockWebServer.takeRequest(); + assertThat(request.getMethod()).isEqualTo("POST"); + assertThat(request.getPath()) + .contains( + ValidatorApiMethod.SUBSCRIBE_TO_SYNC_COMMITTEE_SUBNET.getPath(Collections.emptyMap())); + assertThat(request.getBody().readUtf8()) + .isEqualTo( + "[{\"validator_index\":\"0\",\"sync_committee_indices\":[\"1\"],\"until_epoch\":\"0\"}]"); + } + + @TestTemplate + void handle400() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); + assertThatThrownBy(() -> request.submit(subscriptions)) + .isInstanceOf(IllegalArgumentException.class); + } + + @TestTemplate + void handle500() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy(() -> request.submit(subscriptions)) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } +} diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSyncCommitteeMessagesRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSyncCommitteeMessagesRequestTest.java new file mode 100644 index 00000000000..8fc75a6ba49 --- /dev/null +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSyncCommitteeMessagesRequestTest.java @@ -0,0 +1,100 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static java.util.Collections.emptyMap; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; + +import com.fasterxml.jackson.core.JsonProcessingException; +import java.util.List; +import okhttp3.mockwebserver.MockResponse; +import okhttp3.mockwebserver.RecordedRequest; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; +import tech.pegasys.teku.infrastructure.json.JsonUtil; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeMessage; +import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.validator.api.SubmitDataError; +import tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod; +import tech.pegasys.teku.validator.remote.typedef.AbstractTypeDefRequestTestBase; + +@TestSpecContext(milestone = SpecMilestone.CAPELLA, network = Eth2Network.MINIMAL) +public class SendSyncCommitteeMessagesRequestTest extends AbstractTypeDefRequestTestBase { + private SendSyncCommitteeMessagesRequest request; + private List syncCommitteeMessages; + + @BeforeEach + public void setup() { + request = new SendSyncCommitteeMessagesRequest(mockWebServer.url("/"), okHttpClient); + syncCommitteeMessages = List.of(dataStructureUtil.randomSyncCommitteeMessage()); + } + + @TestTemplate + void handle200() throws InterruptedException, JsonProcessingException { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK)); + final List response = request.submit(syncCommitteeMessages); + assertThat(response).isEmpty(); + final RecordedRequest recordedRequest = mockWebServer.takeRequest(); + final List data = + JsonUtil.parse( + recordedRequest.getBody().readUtf8(), + DeserializableTypeDefinition.listOf( + syncCommitteeMessages.getFirst().getSchema().getJsonTypeDefinition())); + assertThat(data).isEqualTo(syncCommitteeMessages); + assertThat(recordedRequest.getMethod()).isEqualTo("POST"); + assertThat(recordedRequest.getPath()) + .contains(ValidatorApiMethod.SEND_SYNC_COMMITTEE_MESSAGES.getPath(emptyMap())); + } + + @TestTemplate + void shouldNotMakeRequestWhenEmptyMessages() { + final List response = request.submit(List.of()); + assertThat(response).isEmpty(); + assertThat(mockWebServer.getRequestCount()).isZero(); + } + + @TestTemplate + void handle400() { + mockWebServer.enqueue( + new MockResponse() + .setResponseCode(SC_BAD_REQUEST) + .setBody( + "{\"code\": 400,\"message\": \"z\",\"failures\": [{\"index\": 3,\"message\": \"a\"}]}")); + final List response = request.submit(syncCommitteeMessages); + assertThat(response).containsExactly(new SubmitDataError(UInt64.valueOf(3), "a")); + } + + @TestTemplate + void handle400_notParsableMessage() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); + assertThatThrownBy(() -> request.submit(syncCommitteeMessages)) + .isInstanceOf(IllegalArgumentException.class); + } + + @TestTemplate + void handle500() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy(() -> request.submit(syncCommitteeMessages)) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } +} diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendValidatorLivenessRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendValidatorLivenessRequestTest.java new file mode 100644 index 00000000000..b96e2aa7625 --- /dev/null +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendValidatorLivenessRequestTest.java @@ -0,0 +1,82 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; + +import java.util.List; +import java.util.Map; +import java.util.Optional; +import okhttp3.mockwebserver.MockResponse; +import okhttp3.mockwebserver.RecordedRequest; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; +import tech.pegasys.teku.api.migrated.ValidatorLivenessAtEpoch; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod; +import tech.pegasys.teku.validator.remote.typedef.AbstractTypeDefRequestTestBase; + +@TestSpecContext(milestone = SpecMilestone.PHASE0, network = Eth2Network.MINIMAL) +public class SendValidatorLivenessRequestTest extends AbstractTypeDefRequestTestBase { + + private SendValidatorLivenessRequest request; + + @BeforeEach + void setupRequest() { + request = new SendValidatorLivenessRequest(mockWebServer.url("/"), okHttpClient); + } + + @TestTemplate + public void sendValidatorLiveness_makesExpectedRequest() throws Exception { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK)); + request.submit(UInt64.ONE, List.of(UInt64.valueOf(1))); + + final RecordedRequest request = mockWebServer.takeRequest(); + assertThat(request.getMethod()).isEqualTo("POST"); + assertThat(request.getPath()) + .contains(ValidatorApiMethod.SEND_VALIDATOR_LIVENESS.getPath(Map.of("epoch", "1"))); + } + + @TestTemplate + public void sendValidatorLiveness_readsResponse() throws Exception { + mockWebServer.enqueue( + new MockResponse() + .setResponseCode(SC_OK) + .setBody("{\"data\":[{\"index\":\"1\",\"is_live\":false}]}")); + final Optional> result = + request.submit(UInt64.ONE, List.of(UInt64.valueOf(1))); + + final RecordedRequest request = mockWebServer.takeRequest(); + assertThat(request.getMethod()).isEqualTo("POST"); + assertThat(request.getPath()) + .contains(ValidatorApiMethod.SEND_VALIDATOR_LIVENESS.getPath(Map.of("epoch", "1"))); + + assertThat(result).isPresent(); + assertThat(result.get()).containsExactly(new ValidatorLivenessAtEpoch(UInt64.ONE, false)); + } + + @TestTemplate + void handle500() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy(() -> request.submit(UInt64.ONE, List.of(UInt64.valueOf(1)))) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } +} diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SubscribeToBeaconCommitteeRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SubscribeToBeaconCommitteeRequestTest.java new file mode 100644 index 00000000000..345c4b86d1d --- /dev/null +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SubscribeToBeaconCommitteeRequestTest.java @@ -0,0 +1,92 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; + +import java.util.Collections; +import java.util.List; +import okhttp3.mockwebserver.MockResponse; +import okhttp3.mockwebserver.RecordedRequest; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.validator.api.CommitteeSubscriptionRequest; +import tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod; +import tech.pegasys.teku.validator.remote.typedef.AbstractTypeDefRequestTestBase; + +@TestSpecContext(allMilestones = true, network = Eth2Network.MINIMAL) +public class SubscribeToBeaconCommitteeRequestTest extends AbstractTypeDefRequestTestBase { + private SubscribeToBeaconCommitteeRequest request; + private List subscriptions; + final int committeeIndex1 = 1; + final int validatorIndex1 = 6; + final UInt64 committeesAtSlot1 = UInt64.valueOf(10); + final UInt64 slot1 = UInt64.valueOf(15); + final boolean aggregator1 = true; + + final int committeeIndex2 = 2; + final int validatorIndex2 = 7; + final UInt64 committeesAtSlot2 = UInt64.valueOf(11); + final UInt64 slot2 = UInt64.valueOf(16); + final boolean aggregator2 = false; + + @BeforeEach + public void setup() { + request = new SubscribeToBeaconCommitteeRequest(mockWebServer.url("/"), okHttpClient); + subscriptions = + List.of( + new CommitteeSubscriptionRequest( + validatorIndex1, committeeIndex1, committeesAtSlot1, slot1, aggregator1), + new CommitteeSubscriptionRequest( + validatorIndex2, committeeIndex2, committeesAtSlot2, slot2, aggregator2)); + } + + @TestTemplate + public void postAttesterDuties_makesExpectedRequest() throws Exception { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); + request.submit(subscriptions); + final RecordedRequest request = mockWebServer.takeRequest(); + assertThat(request.getMethod()).isEqualTo("POST"); + assertThat(request.getPath()) + .contains( + ValidatorApiMethod.SUBSCRIBE_TO_BEACON_COMMITTEE_SUBNET.getPath( + Collections.emptyMap())); + final String expectedBody = + "[{\"validator_index\":\"6\",\"committee_index\":\"1\",\"committees_at_slot\":\"10\",\"slot\":\"15\",\"is_aggregator\":true}," + + "{\"validator_index\":\"7\",\"committee_index\":\"2\",\"committees_at_slot\":\"11\",\"slot\":\"16\",\"is_aggregator\":false}]"; + assertThat(request.getBody().readUtf8()).isEqualTo(expectedBody); + } + + @TestTemplate + void handle400() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); + assertThatThrownBy(() -> request.submit(subscriptions)) + .isInstanceOf(IllegalArgumentException.class); + } + + @TestTemplate + void handle500() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy(() -> request.submit(subscriptions)) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } +} diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SubscribeToPersistentSubnetsRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SubscribeToPersistentSubnetsRequestTest.java new file mode 100644 index 00000000000..dfe564dab94 --- /dev/null +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SubscribeToPersistentSubnetsRequestTest.java @@ -0,0 +1,75 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; + +import java.util.Collections; +import java.util.List; +import okhttp3.mockwebserver.MockResponse; +import okhttp3.mockwebserver.RecordedRequest; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; +import tech.pegasys.teku.spec.TestSpecContext; +import tech.pegasys.teku.spec.datastructures.validator.SubnetSubscription; +import tech.pegasys.teku.spec.networks.Eth2Network; +import tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod; +import tech.pegasys.teku.validator.remote.typedef.AbstractTypeDefRequestTestBase; + +@TestSpecContext(allMilestones = true, network = Eth2Network.MINIMAL) +public class SubscribeToPersistentSubnetsRequestTest extends AbstractTypeDefRequestTestBase { + private SubscribeToPersistentSubnetsRequest request; + private List subnetSubscriptions; + + @BeforeEach + public void setup() { + request = new SubscribeToPersistentSubnetsRequest(mockWebServer.url("/"), okHttpClient); + subnetSubscriptions = + List.of( + new SubnetSubscription( + dataStructureUtil.randomPositiveInt(64), dataStructureUtil.randomSlot())); + } + + @TestTemplate + public void postAttesterDuties_makesExpectedRequest() throws Exception { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NO_CONTENT)); + request.submit(subnetSubscriptions); + final RecordedRequest request = mockWebServer.takeRequest(); + assertThat(request.getMethod()).isEqualTo("POST"); + assertThat(request.getPath()) + .contains( + ValidatorApiMethod.SUBSCRIBE_TO_PERSISTENT_SUBNETS.getPath(Collections.emptyMap())); + assertThat(request.getBody().readUtf8()) + .isEqualTo("[{\"subnet_id\":\"35\",\"unsubscription_slot\":\"24752339414\"}]"); + } + + @TestTemplate + void handle400() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); + assertThatThrownBy(() -> request.submit(subnetSubscriptions)) + .isInstanceOf(IllegalArgumentException.class); + } + + @TestTemplate + void handle500() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy(() -> request.submit(subnetSubscriptions)) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } +} diff --git a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SyncCommitteeSelectionsRequestTest.java b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SyncCommitteeSelectionsRequestTest.java index 294deded7fd..552a93175fb 100644 --- a/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SyncCommitteeSelectionsRequestTest.java +++ b/validator/remote/src/integration-test/java/tech/pegasys/teku/validator/remote/typedef/handlers/SyncCommitteeSelectionsRequestTest.java @@ -16,6 +16,7 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_IMPLEMENTED; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; @@ -28,6 +29,7 @@ import okhttp3.mockwebserver.RecordedRequest; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.TestTemplate; +import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSelectionProof; import tech.pegasys.teku.infrastructure.json.JsonUtil; import tech.pegasys.teku.infrastructure.unsigned.UInt64; @@ -63,7 +65,7 @@ public void correctResponseDeserialization() { "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505") .build(); - final Optional> response = request.getSelectionProof(entries); + final Optional> response = request.submit(entries); assertThat(response).isPresent().contains(List.of(expectedSyncCommitteeSelectionProof)); } @@ -72,7 +74,7 @@ public void expectedRequest() throws Exception { final String mockResponse = readResource("responses/sync_committee_selections.json"); mockWebServer.enqueue(new MockResponse().setResponseCode(SC_OK).setBody(mockResponse)); - request.getSelectionProof(entries); + request.submit(entries); final RecordedRequest request = mockWebServer.takeRequest(); assertThat(request.getMethod()).isEqualTo("POST"); @@ -90,22 +92,21 @@ public void expectedRequest() throws Exception { public void handlingBadRequest() { mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); - assertThatThrownBy(() -> request.getSelectionProof(entries)) - .isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> request.submit(entries)).isInstanceOf(IllegalArgumentException.class); } @TestTemplate public void handlingNotImplemented() { mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NOT_IMPLEMENTED)); - assertThat(request.getSelectionProof(entries)).isEmpty(); + assertThat(request.submit(entries)).isEmpty(); } @TestTemplate public void handlingSyncing() { mockWebServer.enqueue(new MockResponse().setResponseCode(SC_SERVICE_UNAVAILABLE)); - assertThat(request.getSelectionProof(entries)).isEmpty(); + assertThat(request.submit(entries)).isEmpty(); } private SyncCommitteeSelectionProof createSyncCommitteeSelectionProof() { @@ -116,4 +117,29 @@ private SyncCommitteeSelectionProof createSyncCommitteeSelectionProof() { .selectionProof(dataStructureUtil.randomSignature().toBytesCompressed().toHexString()) .build(); } + + @TestTemplate + void handle500() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_INTERNAL_SERVER_ERROR)); + assertThatThrownBy(() -> request.submit(entries)) + .isInstanceOf(RemoteServiceNotAvailableException.class); + } + + @TestTemplate + void handle503() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_SERVICE_UNAVAILABLE)); + assertThat(request.submit(entries)).isEmpty(); + } + + @TestTemplate + void handle501() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_NOT_IMPLEMENTED)); + assertThat(request.submit(entries)).isEmpty(); + } + + @TestTemplate + void handle400() { + mockWebServer.enqueue(new MockResponse().setResponseCode(SC_BAD_REQUEST)); + assertThatThrownBy(() -> request.submit(entries)).isInstanceOf(IllegalArgumentException.class); + } } diff --git a/validator/remote/src/integration-test/resources/responses/create_aggregate_attestation_responses/createAggregateAttestationResponse.json b/validator/remote/src/integration-test/resources/responses/create_aggregate_attestation_responses/createAggregateAttestationResponse.json new file mode 100644 index 00000000000..6da9fb46a78 --- /dev/null +++ b/validator/remote/src/integration-test/resources/responses/create_aggregate_attestation_responses/createAggregateAttestationResponse.json @@ -0,0 +1,19 @@ +{ + "data": { + "aggregation_bits": "0xf222308f23fd4379911b8ed32c9edd6e5dcc54a1c8c60ff9b76abe8b7424bab6dc2d6a52647f3679db31417fe81adc8e918254e1d6824ba01812bc55517124259aaf397723a131f32e26a5bd5ee07e45cef65f229a5466940408a08475d310949f1df9ce99b1794e7d5492a0ddd68979272eb245e7af8120cda3e9cd634ad160377773aa602074207f68cf77c5397236f0d96959127eb3e6410064d81d9b14937839bdd1b6ba9aafeae4a8fd00af0ed404dc9415e27351b70eca0433acfbd873d536a730f3f32e1fd87be6802b7e01741c8bbacddc2331bc7d58c70657bd5fee190d46d1d627ba23483c1d44923d0aef3acef87d1965073b85caeac55056550e01", + "data": { + "slot": "4660063907559659148", + "index": "4658411424342975020", + "beacon_block_root": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379", + "source": { + "epoch": "542695214", + "root": "0x1f86d83f0bf91cc0d7e07410828140e0dddbb331dc20b6743f9f79e549b50b11" + }, + "target": { + "epoch": "535384985", + "root": "0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb" + } + }, + "signature": "0xae757bc04a0f7ee8e8d1668c8de3fd4ca45ca7e8f7ad7d3323350213956386cfc97094f156a7d6ab2d3ebe6a7eb7ce2c10d0d32091ee4867224ef5856bff529e9f0c2cb9c0085a28f6a47d75aae926913f681a6b21e25b093b78e3cf188bb6be" + } +} \ No newline at end of file diff --git a/validator/remote/src/integration-test/resources/responses/create_aggregate_attestation_responses/createAggregateAttestationResponseElectra.json b/validator/remote/src/integration-test/resources/responses/create_aggregate_attestation_responses/createAggregateAttestationResponseElectra.json new file mode 100644 index 00000000000..0fd661fc7d7 --- /dev/null +++ b/validator/remote/src/integration-test/resources/responses/create_aggregate_attestation_responses/createAggregateAttestationResponseElectra.json @@ -0,0 +1,21 @@ +{ + "version": "electra", + "data": { + "aggregation_bits": "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", + "data": { + "slot": "4669978815449698508", + "index": "4668326327938047084", + "beacon_block_root": "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f", + "source": { + "epoch": "542310465", + "root": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + }, + "target": { + "epoch": "542695214", + "root": "0x1f86d83f0bf91cc0d7e07410828140e0dddbb331dc20b6743f9f79e549b50b11" + } + }, + "signature": "0xb3a22ab9ec46aec35a9dacfb9036375ea1528041a926cb9d2d315ab964e82be5d6990e7fef2343f2dbb4c2b7dd74687f11144beaeb5758ebe349762b4dbde5e67bbc8d89a95a803c6610631d178249917cbf0d8b11bd8740f3cb767c843aa88c", + "committee_bits": "0x04" + } +} \ No newline at end of file diff --git a/validator/remote/src/integration-test/resources/responses/get_peer_count.json b/validator/remote/src/integration-test/resources/responses/get_peer_count.json new file mode 100644 index 00000000000..cedb67f150b --- /dev/null +++ b/validator/remote/src/integration-test/resources/responses/get_peer_count.json @@ -0,0 +1,8 @@ +{ + "data": { + "disconnected": "12", + "connecting": "0", + "connected": "56", + "disconnecting": "0" + } +} \ No newline at end of file diff --git a/validator/remote/src/integration-test/resources/responses/get_proposer_duties_response.json b/validator/remote/src/integration-test/resources/responses/get_proposer_duties_response.json new file mode 100644 index 00000000000..f0c9f607db2 --- /dev/null +++ b/validator/remote/src/integration-test/resources/responses/get_proposer_duties_response.json @@ -0,0 +1,11 @@ +{ + "dependent_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", + "execution_optimistic": false, + "data": [ + { + "pubkey": "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a", + "validator_index": "1", + "slot": "1" + } + ] +} \ No newline at end of file diff --git a/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlindedBlockBELLATRIX.json b/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlindedBlockBELLATRIX.json index c0b40168761..64339eddd8a 100644 --- a/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlindedBlockBELLATRIX.json +++ b/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlindedBlockBELLATRIX.json @@ -1 +1,218 @@ -{"version":"bellatrix","execution_payload_blinded":true,"execution_payload_value":"12345","consensus_block_value":"123000000000","data":{"slot":"1","proposer_index":"4666673844721362956","parent_root":"0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef","state_root":"0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e","body":{"randao_reveal":"0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71","eth1_data":{"deposit_root":"0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f","deposit_count":"4658411424342975020","block_hash":"0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379"},"graffiti":"0x0000000000000000000000000000000000000000000000000000000000000000","proposer_slashings":[{"signed_header_1":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b","state_root":"0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb","body_root":"0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486"},"signature":"0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483"},"signed_header_2":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6","state_root":"0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26","body_root":"0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1"},"signature":"0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1"}}],"attester_slashings":[{"attestation_1":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4580744678799082634","index":"4579092195582398506","beacon_block_root":"0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c","source":{"epoch":"533461240","root":"0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565"},"target":{"epoch":"538462976","root":"0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650"}},"signature":"0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc"},"attestation_2":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4620404293179370891","index":"4618751809962686763","beacon_block_root":"0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b","source":{"epoch":"538078227","root":"0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb"},"target":{"epoch":"536923980","root":"0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5"}},"signature":"0xa32991816eb9f297553b4732309a4cdba7b33287264611715b0ab3319bca19e581da6e2659912a4e0e94aafc01c488e30ffc96ed14e2a726b9d3c618405ee0bf54bf6ae7f2097465cb27ab8132ec24eb93d3c9159475304082f7f0e452b93b65"}}],"attestations":[{"aggregation_bits":"0xfa79cdb89d0d51c5cdd001b7425c6d726750a9d5f89ade6ed9890ce3a706140c399a5e10c90a819094b65322dac7501f7c75471e69d4567358d8ca75f7c1b3133ebecf006b369a1f36efc5f2b706d5922ff98c58a1825a53a864376658f816600cf021cea843d4396502bb9c74d1510afe26036f89f783b4f5c7bacb6649c46f217a6af835f312d6fa253d2bbc83c07993f4f10de2ed2d952689379dbe4f794c1a1055a6b364d68e038deec9667f576b3b9eca5fcadd6298f181e1edb876efc3d0975ae14ae9a0ad2f1836d4c3f1080a96d8ab7c43b34bb2eda895ff66be698b363cfa4be33da3ec94a1a7a90672fd12c4a59916bb937e78476e4f08e4f4031001","data":{"slot":"4605531939934246443","index":"4610489389584298827","beacon_block_root":"0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b","source":{"epoch":"529421377","root":"0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2"},"target":{"epoch":"529806126","root":"0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd"}},"signature":"0x8f8d16b39e14569aab1b712e5c19ed51afe3600a6b017e8ab432f43a02ee720a733c33ef087d2f3653a9701e8d8a836301655b9195c0373b775c88ba1368e5d55354a70a3096bd26dee29dddbe7a4820e2b1653e84122beacbc01af7d93e6bdc"},{"aggregation_bits":"0x4ac567b296efbf7cf3209e87096a7a1a50fd523400113f917f6584a5a306f06b2d8da9ae858d47ff2594010089838efe41f19a78d9aae27c2ffde26f278b8681db9d091eb72e7cab3e449dfccd46a270693e1f88f197324e57bfd45573315cf9fb60d770937b32f7c0c6ce1581ec51e6b60f71acfde304dc917f2e0aa7872038b7d9140d15f7927c23a0490a74c2b0aca2773fed9217067e4444f9ca93874e4ff8407111c3efdb138b97c6d4957b6a70ec1debb283e3d0eb1cfef068adcffbf057d20fdc339eae03f0fa2613abdde8158a7fc40c3cfd1117eb6f8c4ae21d6b2ab4b57ae9a8653a34451aee6418c0c3609dc937293f5f5b346a7ab1a0d144185101","data":{"slot":"4544390030852162633","index":"4542737547635478505","beacon_block_root":"0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd","source":{"epoch":"527690007","root":"0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8"},"target":{"epoch":"528074756","root":"0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8"}},"signature":"0x90309dd491ae6ed51917dc305a3d4ae68d0a0d4792c7eb59c193bd03605bd94e61cab37502de0ad3e6162bc02427bba80a798b3670d5de82a854094016cc298b265371345c0e3ac49fd44bbb9ba0d4fcea0c1a80cecb60e93921d907e8c48120"},{"aggregation_bits":"0xe8c9759f0840f980ae956b15fc383d992e7d4420d12ba5bf32f669f446ac6fa388e20e5ce96e9266dd98840179d2cde3cabd9a8bafab5dec9c2e89f7f78c989e690548603984803b80c82d7b76443194576a1ce49da5cfe56f56e83b745fb01b5f18ccc86d88f5a22d927e64ff0b8e880893abcddec45b268531c4a0697537dae643a24b1a36432f37d42962553bd39af71f37e0429b81470c11316aa39db074aa3f1df4124e7cb203debed60b885ffb9b27e46a1434e81bbd56566632d0729c0822ac415cbb67f25973667d88e58df9c2f058a0ae7f118c98cc448453b6fbe590363bd17ed62c2f808df61f2a9e593235eeb56db74b9dd15980189a5271468301","data":{"slot":"4529517677607038185","index":"4574134745932346122","beacon_block_root":"0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947","source":{"epoch":"532884117","root":"0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31"},"target":{"epoch":"531729870","root":"0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672"}},"signature":"0x8c40f51a99fce6ebb9a4db5e80d715fff319e7ae523e46afb5d03c000d427e23c7a39e77e2af53851706283c8ca91d680997cb459386fbdff52c4d0ecf498e173717a838a792b210bdffaf476538628584a133899bf30dd5ce7056463b8cd683"}],"deposits":[{"proof":["0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c"],"data":{"pubkey":"0xb1f8f6e731dbf6b4e3265fb857c7190adbfc7e6cc95ce2e8bda72be8b6ea3459f862310a2484c3b0ee33b30920f18c1d","withdrawal_credentials":"0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c","amount":"32000000000","signature":"0xb594382214f5bdd375de66c45e1c61a526c7b73fb166c72433bbd9c2a7ad6881244e61cc6427e0206a50b762a129d8830e8708c55761d61ce9e3b19c1bee13bc55daa13bdb07118efdbf57a588b8a64e6392d14f935e53b68933e3355b35acdb"}}],"voluntary_exits":[{"message":{"epoch":"4562567354825622634","validator_index":"4564219838042306762"},"signature":"0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e"}],"sync_aggregate":{"sync_committee_bits":"0x01000000","sync_committee_signature":"0x919ee45cc18456f6e85da6bc21c2e40f44f9a887932c73ea9ad354f88e56d4ec0a8c396ed143082c8e31d697b877a2a215d2966d91c7beb156bf7ab5777e210012f70dcd5f7657808a82cba51e194be994f917150ebdb9e5c57476f1edb47206"},"execution_payload_header":{"parent_hash":"0xf8eb5a3ea82ccf3c1be1ac153e3f77f273a07343291711b9de6b9dbebc4c9b49","fee_recipient":"0xbf886c3ec849316e3b187793c3a4398b6097768d","state_root":"0xd2a9663e689510b3305bdebe972d4e58669a751fbc85bf448269162e078b2c34","receipts_root":"0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9","logs_bloom":"0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d078748f9069c96e9d6a2801cf607000a52447e46e1bef4e056ee30d4bd3517aaf7bf65ba04dd28c3a4a14b8dc72a300f051722a6814fa3931d90a82d23285d4c1127b6c67bbc4f8682ddbf9b31eb3114c26dccc5330109d6f17799339c2d7ed7e4e3a7de5d515106aaec7be6d78be3e21806d6d30c39b77c75dcf354b63033fb200b3b9dc023d948278f0956c0ee99323da0162f2a84b6a95749d2fa1d4e089af416d412ccd992683f7e41f7b496ca04f9f463806e3643d1c07f39d2a65f84e97b7dfaafac740d1e03f30923a4270fcf651ad2ca3737859a524e86e02229a55abd1a7","prev_randao":"0x0c0d553e4878ae811024144112c88bbf79a372d5dfdf39730cede08696ad52d4","block_number":"4489858063226749928","gas_limit":"4481595642848361992","gas_used":"4479943159631677864","timestamp":"4484900609281730248","extra_data":"0x6bb2373e68f20adada72181a3474f2c098b26daf6fcb0516f0723270da91e789","base_fee_per_gas":"91973405088222260025272995045243630915786868313949746451634391325697029602367","block_hash":"0xde78143e27b846779904841e2aa96d8fbec4671bb57ffa72037ac721f8d633ca","transactions_root":"0xa415263e48d5a8a8ba3b4e9caf0e3028abbb6a65922580447af6fcc869b40d2a"}}}} \ No newline at end of file +{ + "version": "bellatrix", + "execution_payload_blinded": true, + "execution_payload_value": "73092283800700793286468708950267523415056945357667839430375913972420161943176", + "consensus_block_value": "110698795530499877737280254001850075711411497370695181962707136225646562110", + "data": { + "slot": "1", + "proposer_index": "4666673844721362956", + "parent_root": "0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef", + "state_root": "0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e", + "body": { + "randao_reveal": "0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71", + "eth1_data": { + "deposit_root": "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f", + "deposit_count": "4658411424342975020", + "block_hash": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + }, + "graffiti": "0x0000000000000000000000000000000000000000000000000000000000000000", + "proposer_slashings": [ + { + "signed_header_1": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b", + "state_root": "0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb", + "body_root": "0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486" + }, + "signature": "0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483" + }, + "signed_header_2": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6", + "state_root": "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "body_root": "0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1" + }, + "signature": "0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1" + } + } + ], + "attester_slashings": [ + { + "attestation_1": { + "attesting_indices": [ + "4590659586689121994", + "4589007099177470570", + "4580744678799082634" + ], + "data": { + "slot": "4579092195582398506", + "index": "4584049649527418186", + "beacon_block_root": "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06", + "source": { + "epoch": "538655350", + "root": "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0" + }, + "target": { + "epoch": "539040099", + "root": "0xda533c406bf3482d8e6e992e756be34172a8c47fc1cc0018350bfe98c946deda" + } + }, + "signature": "0x8bfc6e1a1c76bdafb4d491ce02a35effde6d7362eb32c03f119c47c12fb2b49e7656bbd4702ba02560fd7fe117f2c74e02142ce46176ebf269d5b34a48a65525e35db6cc446965e86e22e9d8adf5abe92315690b6de5f4591769487539fed52a" + }, + "attestation_2": { + "attesting_indices": [ + "4590659586689121994", + "4589007099177470570", + "4580744678799082634" + ], + "data": { + "slot": "4618751809962686763", + "index": "4623709263907706443", + "beacon_block_root": "0x27d82440eb21c640637a36dcc38e35768bb4c0c79aefa300ec0f0cba32cabb05", + "source": { + "epoch": "537116355", + "root": "0x999e0140abe701de220ca2e0b9c3b044b1c6ba33e0a3985dfe16a16b510f0846" + }, + "target": { + "epoch": "537501104", + "root": "0x735c0d406b5043543786d38912b287aaa4c0bc0f731247e9a3141adb9c4d9930" + } + }, + "signature": "0xb2213ef588828a7c18cdc781d0ed2516fd3e11de625f191aae7ae4be8b1ad2cc217728c65a500aedea276d345f09fd3212b009568a6549f5f40ead6d7ec4d0f3f329c00a1b4bca59068ee0555c94aec91bebc18365ca0b2d6692557b4b0c4267" + } + } + ], + "attestations": [ + { + "aggregation_bits": "0x907c35a14e5afee2fffc1703230dbe923ea49766c5af5277f432d84b3c2323d8a5a8dc131a8cbb3c69aad1172537e0826b0f4ee1639f650b91bbeab0eaf337f9472742d6f8443c1eb7c62f5f876f5f154689fb6548800c39b12a8d1f2585230fc372dfe5bc46a4c4358fb1ebb547796df094800159f2c9d982d61666d8a188e3b665900ce8f564188f269b5265d345893085d41f43a030337dedcafbef1245fb43c6c44b9891c2ff5f157069435c52c7fc457d5ec218f5d2ca50e69cae88c863b56e53213d92d7f6357a56344a4c2b80b58249b494d992f3c78d7440fe6b69d32ff3c1c29dbea8d0aebc1347743dac65bb66529f27dcf476baa3774d1e5c69dd01", + "data": { + "slot": "4608836906367614699", + "index": "4547695001580498185", + "beacon_block_root": "0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2", + "source": { + "epoch": "529806126", + "root": "0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd" + }, + "target": { + "epoch": "528651879", + "root": "0xe24dff3e29e762b4488e615619483884c44b8f4b37239b5cdc4a3bd7d9b48c1d" + } + }, + "signature": "0x913ce44a60f20df0261b53d8031d13f3a8d51cf53ba5eb65735ae960623c48acd56286b31ecd74cdaf51f66b2b2331fa0e907e8cb9d4dde513ca29cc34ee9925301bb541055a8daef33bb3e1fb8442a4a033f93f86933bc35fd2ce34a569a6ef" + }, + { + "aggregation_bits": "0xae44a59e9b57b7141da75dba9d385b795ba84317f41948621bf98a34f92168838b72a9678bc58de000cf466104613975fb1490c591f0ee9055cce4aaa2ff0eb5a26c8b9e20b6a386d9e9f7964a3ebb957e3c6b0124271c279496235101a29fbf18ac7be6749a8b1f230bb5131e97b28c06683ca9a6cb6129b2a25b4f539f7f5e41cc1997c5b4a57d51dbce5ad4ab746a403e5270c785b76d47475c0ee6c309e33dad08193c3f8e40e9414096276bfb5708c84359dd51eb54ca67dd7a6eb5645801fb83811b4c11eb5b240e9d0bc0847ae7abfa235c7d6cc5f7eca53bce62b1b987b7c11ef54592399882d7983eb3c6a58ff636f52b4007afbc0d66bfe9d9276a01", + "data": { + "slot": "4532822644040406441", + "index": "4537780097985426121", + "beacon_block_root": "0x0890f33e697e213e331430adc059611ed0518d6fa4b4ecd0384dc2678e76fb32", + "source": { + "epoch": "527112883", + "root": "0x7a56d03e29445ddbf2a59bb1b68edcecf66387dbea68e12d4a545719acbb4773" + }, + "target": { + "epoch": "527497632", + "root": "0x5414dc3ee9ac9e510720cd5a0e7db352e95d89b77dd78fb9ef51d088f8f9d85d" + } + }, + "signature": "0xa3f0d1902ab93bc710c2af70da7699b79480ee062fc8add2cc1c6ddce56d54706ef91f581ec0f94cee95fc4be146005f174e2e77733d71ef59e53a12eb852e09e4334af2c27120e506ebab9c04e2b2f99045d40bd1372618173cf6df4ad21f86" + }, + { + "aggregation_bits": "0xe2e8a45105213f0f211443b26e3a23df7f899eb9b3ddd40b5f51905f90441f98eaa0d2b9ed7dddf5b4089188c41388cb5702236640399f914245bc085459f40d628a99fd663a4429e9b46e61dc8beb6ae3757aaeffc6db49c374cc93d1e663989d84fa7b4aa499a8b5d34ec5fea94bcdb33af829c6260d2a88a6be97e89baa6215949a4ef124436f685d4ee683c0c27f0ac7aefd77f4b305842d1cf2d08d9b7f4e501a38b81014fcbcec2156d5abbd1010afe4a596164e4659c6dd794639199119b4a3f2ec4f3b4d6a084bdedf66dfdcc1be1c522d9bf72663b7cc1a8746c3737e20ef7ee1b7863f89ab600a35772b4eede0424b8b69bcd27a6b354252a0147701", + "data": { + "slot": "4575787224854062954", + "index": "4567524808770642314", + "beacon_block_root": "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "source": { + "epoch": "532114619", + "root": "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c" + }, + "target": { + "epoch": "530960372", + "root": "0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c" + } + }, + "signature": "0x8166b2ed13e982e6b9f05d30f42681b826099135a533d2614ef5f4f59811714245db0e1821a644859559f97ec1e614bf08b2edb294fa2edc1527f46596399534af23c98613e1b74c01871bf1dd2af9618bc0ba23ddfce8026b897cdbba8c1bce" + } + ], + "deposits": [ + { + "proof": [ + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587" + ], + "data": { + "pubkey": "0x83b9036200e9e907c86ede7f98b23297389e8af19d403466e00f1946867db735d8620019e28aa42739f49c65b78a2806", + "withdrawal_credentials": "0x49452e3f298a688d9e7627fb7c01941b923397bb84dd548b6e411f9506aed1c7", + "amount": "32000000000", + "signature": "0x86e6ad7c26352727d310e10f7c745a0725636f63013f70c5a442489946dcd1c85665cd3539fe9d8fe6f6b49b5b7f13a50af2a2b98a7d385417c98e5d74273e67cc3bd8f8544dc3697124c8176835745659182eab37f3ebe0a881ff4e7f62bc31" + } + } + ], + "voluntary_exits": [ + { + "message": { + "epoch": "4555957421958886121", + "validator_index": "4557609905175570249" + }, + "signature": "0xaacffaf60c8253477ecad70de8589f2ef7670d0b0dc446d4baac3b465a901d3e64bb6d2c3d8bdb58aed45ac30466261416d152d5ae242204201bf6decfddde697ae0c5d44cf31ca3d43aa18f2799461fc1ee14dbf905b1e31f242fd31c083c5a" + } + ], + "sync_aggregate": { + "sync_committee_bits": "0x01000000", + "sync_committee_signature": "0x86e947b46923b26125a7dab3240481ddc1b910c1e6393b90df6e2de3809b8b35e450dc8264ecedd8f6bfc736e7114d841428b2469441d2d1d501015eb99e0d7090f11a1185b566dc42f94b79d0a08b22718a39b57e912a304419361108434ec8" + }, + "execution_payload_header": { + "parent_hash": "0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874", + "fee_recipient": "0x0c0d553e4878ae811024144112c88bbf79a372d5", + "state_root": "0x1f2e4f3ee8c38dc605677b6ce650a08c7fa6716795a8622d396e244f710e0a5f", + "receipts_root": "0x7ed3313e083eea1ecfb57f4508fd068e9fb56c4125942ed01ef47538b5f29e14", + "logs_bloom": "0x91f42b3ea889c963c4f8e670db851b5ba5b86bd3dc5c578a4c75b9008f53569fed0e82445821ecdf1e306d211dc4b3e042d5813f11ce16132211c523a92d723ffdaaf2175eaa77a1937f2e9f27b5e5b0f1bd3b77dbc94c7215fa1065d6066ea59bf2b95b8fe2ef820d9cf6a10c93f04f98db135751e1d8972d2427113953334f5634914e66e00af04d50d4de255bb0540ed3627a6f64073f81a28f777cba3a4ff145230e8103befc67e3ae2e8c72518ea18fa75495daac19c0f5c5094c84853de2b6ba4e2275c8a941cfb1a29f5a24ba911dd636080b0859abaa198dda14a860d4d29306b038ddd219c708ed837583079254b70c7095ac70984894735b79f7f9", + "prev_randao": "0x58913d3ec8a62b95e52fb1ee60ebddf392af6e1db902dd5bc3f1eea7003130ff", + "block_number": "4483248126065046120", + "gas_limit": "4474985709981625479", + "gas_used": "4473333226764941351", + "timestamp": "4478290672120026440", + "extra_data": "0xb736203ee72088edaf7eb5c7839744f5b1be69f748eea8fea77740914415c5b4", + "base_fee_per_gas": "81744492456258793280520536666094060462558404863190111969507816784424614128915", + "block_hash": "0xc7dab83ea972daeec7b1385f04b22e210f708323c38b84160159653a163f259e", + "transactions_root": "0x8e77ca3ec98f3c20e7e802dd8917f1b9fc66866da0310ae878d59ae1871cfffd" + } + } + } +} \ No newline at end of file diff --git a/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlindedBlockCAPELLA.json b/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlindedBlockCAPELLA.json index f3b297a109c..ffb467d49c7 100644 --- a/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlindedBlockCAPELLA.json +++ b/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlindedBlockCAPELLA.json @@ -1 +1,349 @@ -{"version":"capella","execution_payload_blinded":true,"execution_payload_value":"12345","consensus_block_value":"123000000000","data":{"slot":"1","proposer_index":"4666673844721362956","parent_root":"0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef","state_root":"0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e","body":{"randao_reveal":"0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71","eth1_data":{"deposit_root":"0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f","deposit_count":"4658411424342975020","block_hash":"0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379"},"graffiti":"0x0000000000000000000000000000000000000000000000000000000000000000","proposer_slashings":[{"signed_header_1":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b","state_root":"0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb","body_root":"0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486"},"signature":"0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483"},"signed_header_2":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6","state_root":"0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26","body_root":"0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1"},"signature":"0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1"}}],"attester_slashings":[{"attestation_1":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4580744678799082634","index":"4579092195582398506","beacon_block_root":"0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c","source":{"epoch":"533461240","root":"0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565"},"target":{"epoch":"538462976","root":"0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650"}},"signature":"0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc"},"attestation_2":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4620404293179370891","index":"4618751809962686763","beacon_block_root":"0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b","source":{"epoch":"538078227","root":"0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb"},"target":{"epoch":"536923980","root":"0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5"}},"signature":"0xa32991816eb9f297553b4732309a4cdba7b33287264611715b0ab3319bca19e581da6e2659912a4e0e94aafc01c488e30ffc96ed14e2a726b9d3c618405ee0bf54bf6ae7f2097465cb27ab8132ec24eb93d3c9159475304082f7f0e452b93b65"}}],"attestations":[{"aggregation_bits":"0xfa79cdb89d0d51c5cdd001b7425c6d726750a9d5f89ade6ed9890ce3a706140c399a5e10c90a819094b65322dac7501f7c75471e69d4567358d8ca75f7c1b3133ebecf006b369a1f36efc5f2b706d5922ff98c58a1825a53a864376658f816600cf021cea843d4396502bb9c74d1510afe26036f89f783b4f5c7bacb6649c46f217a6af835f312d6fa253d2bbc83c07993f4f10de2ed2d952689379dbe4f794c1a1055a6b364d68e038deec9667f576b3b9eca5fcadd6298f181e1edb876efc3d0975ae14ae9a0ad2f1836d4c3f1080a96d8ab7c43b34bb2eda895ff66be698b363cfa4be33da3ec94a1a7a90672fd12c4a59916bb937e78476e4f08e4f4031001","data":{"slot":"4605531939934246443","index":"4610489389584298827","beacon_block_root":"0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b","source":{"epoch":"529421377","root":"0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2"},"target":{"epoch":"529806126","root":"0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd"}},"signature":"0x8f8d16b39e14569aab1b712e5c19ed51afe3600a6b017e8ab432f43a02ee720a733c33ef087d2f3653a9701e8d8a836301655b9195c0373b775c88ba1368e5d55354a70a3096bd26dee29dddbe7a4820e2b1653e84122beacbc01af7d93e6bdc"},{"aggregation_bits":"0x4ac567b296efbf7cf3209e87096a7a1a50fd523400113f917f6584a5a306f06b2d8da9ae858d47ff2594010089838efe41f19a78d9aae27c2ffde26f278b8681db9d091eb72e7cab3e449dfccd46a270693e1f88f197324e57bfd45573315cf9fb60d770937b32f7c0c6ce1581ec51e6b60f71acfde304dc917f2e0aa7872038b7d9140d15f7927c23a0490a74c2b0aca2773fed9217067e4444f9ca93874e4ff8407111c3efdb138b97c6d4957b6a70ec1debb283e3d0eb1cfef068adcffbf057d20fdc339eae03f0fa2613abdde8158a7fc40c3cfd1117eb6f8c4ae21d6b2ab4b57ae9a8653a34451aee6418c0c3609dc937293f5f5b346a7ab1a0d144185101","data":{"slot":"4544390030852162633","index":"4542737547635478505","beacon_block_root":"0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd","source":{"epoch":"527690007","root":"0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8"},"target":{"epoch":"528074756","root":"0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8"}},"signature":"0x90309dd491ae6ed51917dc305a3d4ae68d0a0d4792c7eb59c193bd03605bd94e61cab37502de0ad3e6162bc02427bba80a798b3670d5de82a854094016cc298b265371345c0e3ac49fd44bbb9ba0d4fcea0c1a80cecb60e93921d907e8c48120"},{"aggregation_bits":"0xe8c9759f0840f980ae956b15fc383d992e7d4420d12ba5bf32f669f446ac6fa388e20e5ce96e9266dd98840179d2cde3cabd9a8bafab5dec9c2e89f7f78c989e690548603984803b80c82d7b76443194576a1ce49da5cfe56f56e83b745fb01b5f18ccc86d88f5a22d927e64ff0b8e880893abcddec45b268531c4a0697537dae643a24b1a36432f37d42962553bd39af71f37e0429b81470c11316aa39db074aa3f1df4124e7cb203debed60b885ffb9b27e46a1434e81bbd56566632d0729c0822ac415cbb67f25973667d88e58df9c2f058a0ae7f118c98cc448453b6fbe590363bd17ed62c2f808df61f2a9e593235eeb56db74b9dd15980189a5271468301","data":{"slot":"4529517677607038185","index":"4574134745932346122","beacon_block_root":"0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947","source":{"epoch":"532884117","root":"0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31"},"target":{"epoch":"531729870","root":"0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672"}},"signature":"0x8c40f51a99fce6ebb9a4db5e80d715fff319e7ae523e46afb5d03c000d427e23c7a39e77e2af53851706283c8ca91d680997cb459386fbdff52c4d0ecf498e173717a838a792b210bdffaf476538628584a133899bf30dd5ce7056463b8cd683"}],"deposits":[{"proof":["0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c"],"data":{"pubkey":"0xb1f8f6e731dbf6b4e3265fb857c7190adbfc7e6cc95ce2e8bda72be8b6ea3459f862310a2484c3b0ee33b30920f18c1d","withdrawal_credentials":"0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c","amount":"32000000000","signature":"0xb594382214f5bdd375de66c45e1c61a526c7b73fb166c72433bbd9c2a7ad6881244e61cc6427e0206a50b762a129d8830e8708c55761d61ce9e3b19c1bee13bc55daa13bdb07118efdbf57a588b8a64e6392d14f935e53b68933e3355b35acdb"}}],"voluntary_exits":[{"message":{"epoch":"4562567354825622634","validator_index":"4564219838042306762"},"signature":"0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e"}],"sync_aggregate":{"sync_committee_bits":"0x01000000","sync_committee_signature":"0x919ee45cc18456f6e85da6bc21c2e40f44f9a887932c73ea9ad354f88e56d4ec0a8c396ed143082c8e31d697b877a2a215d2966d91c7beb156bf7ab5777e210012f70dcd5f7657808a82cba51e194be994f917150ebdb9e5c57476f1edb47206"},"execution_payload_header":{"parent_hash":"0xf8eb5a3ea82ccf3c1be1ac153e3f77f273a07343291711b9de6b9dbebc4c9b49","fee_recipient":"0xbf886c3ec849316e3b187793c3a4398b6097768d","state_root":"0xd2a9663e689510b3305bdebe972d4e58669a751fbc85bf448269162e078b2c34","receipts_root":"0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9","logs_bloom":"0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d078748f9069c96e9d6a2801cf607000a52447e46e1bef4e056ee30d4bd3517aaf7bf65ba04dd28c3a4a14b8dc72a300f051722a6814fa3931d90a82d23285d4c1127b6c67bbc4f8682ddbf9b31eb3114c26dccc5330109d6f17799339c2d7ed7e4e3a7de5d515106aaec7be6d78be3e21806d6d30c39b77c75dcf354b63033fb200b3b9dc023d948278f0956c0ee99323da0162f2a84b6a95749d2fa1d4e089af416d412ccd992683f7e41f7b496ca04f9f463806e3643d1c07f39d2a65f84e97b7dfaafac740d1e03f30923a4270fcf651ad2ca3737859a524e86e02229a55abd1a7","prev_randao":"0x0c0d553e4878ae811024144112c88bbf79a372d5dfdf39730cede08696ad52d4","block_number":"4489858063226749928","gas_limit":"4481595642848361992","gas_used":"4479943159631677864","timestamp":"4484900609281730248","extra_data":"0x6bb2373e68f20adada72181a3474f2c098b26daf6fcb0516f0723270da91e789","base_fee_per_gas":"91973405088222260025272995045243630915786868313949746451634391325697029602367","block_hash":"0xde78143e27b846779904841e2aa96d8fbec4671bb57ffa72037ac721f8d633ca","transactions_root":"0xa415263e48d5a8a8ba3b4e9caf0e3028abbb6a65922580447af6fcc869b40d2a","withdrawals_root":"0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be"},"bls_to_execution_changes":[{"message":{"validator_index":"1728135","from_bls_pubkey":"0xb039b0181d6aa181417c62124db1c686d254153f7b6776cd37c10adc1debf0b71448548d1206f977f6eaa54f6d890ac2","to_execution_address":"0x003ea73e885578bda77a6ee17f4c6c88227980d9"},"signature":"0xb1fb6d05f91d3f90fc29c037776e0b5746fc39adefdd86b51b8a3b269be3d02366c644dc9126cda52f99041c691034f91141ef5110d064e5d583c644f4813c1aabc250021df9fe591214db995eacb0a1cba0a2b43f88b4aef2930d04bb99be3e"},{"message":{"validator_index":"2804390","from_bls_pubkey":"0x912c280adf321fbdcd522490a5431a7c2e0e716841b1a3819edf322fd46ab90681663c156f382055a914732e156d85dd","to_execution_address":"0x26809b3ec8ec364791003d38265e95222e7f7efd"},"signature":"0xa969744aa463b0294e265f1fa92f9c9ef277afeb7ed667017e0a914bc57382d94c52f4411a135094e52636b63942e86e184ce0dd10e22ec86abbabe23396063fa873ecfc0ee3e16a5535f6422cf3f134e4d2de39464f038dd9521bb9d9a1ec80"},{"message":{"validator_index":"2419641","from_bls_pubkey":"0x98192fd09a845d194a35781b711d801c9ce08060445a81cdb38d45bfb82c776d0e9b6083eedc0a106c9c922ee3bc906c","to_execution_address":"0x2fda834311b58db49107ebef3efd6ab3f5f751f2"},"signature":"0xa864cf37cc41e0ea0c8cd4ae1d6d0bb833ddc583b3e389808da50acd9a3c49c59a2d4b038446feece5a6083d251e45530622aa80cc6bb57d7df907a39e1fa40885ab29ce25f3788860dab9a97050a48079c20176d6bd7e11720790679ade7638"},{"message":{"validator_index":"1587773","from_bls_pubkey":"0xa5234d7dc8fe8544bcad85f8ca6548172425616038825239877450fa6144ba23923065a1c3d3a8fbd687ac593e11b4d9","to_execution_address":"0x551c7843514c4c3e7c8db946e50e944d01fe4f16"},"signature":"0x92ddc8deeee37b1eeb83436e230c4dbfbda6a26fcd4b046c7556fba6391650f7824e0355adfbd38b0ee232030feca3780dcb2990998184ec505207f3d4123bdc38ea5a8de44474bbec65e619b8a853670fd3ae4a08a50ca1c3bd2c81739b92a1"},{"message":{"validator_index":"1203025","from_bls_pubkey":"0xaf01ad2d54129b76339febd98494d79dc8dbace659dbeb3aeae85f9a2a94b23da0170f08f5233cdb136991686441e54c","to_execution_address":"0x14673d43914005ef102bc2f829676150401c46ca"},"signature":"0xa34f07f9c38b8cf4781d0d1bc1d204860500aaa70a1ec6b1ca9a73d3fdbaace7c56c6bd9edc5eaf5898324494060496c016d716d51dec591c1854e84470529bd98a6fecdd74d012c8d8b677f32bd2febf0677c238361bcaa39e32056dafcaf67"},{"message":{"validator_index":"2435262","from_bls_pubkey":"0xb508746a00c15709b84343dbc90c7033f121615b7ac2ebbb356adc69bc7dfdf1cc1607b1f5e577476b02a89043b0a6fb","to_execution_address":"0xd786ed43d263dadc5352a8e25d5ef94784c163ae"},"signature":"0x92806dee8cfa7784e16b97ea6b32613fe6c41bbb7d0f03838a6dbebc90961bffb9f67ae8046ac1b3fc19e477d76e26ac0d5e613a0c87ff18649a50d75a8b09f8d72f0f056aa0078eb99c68f00b08535e242cd0db5639223f9c3adb71183bd0bb"},{"message":{"validator_index":"2050514","from_bls_pubkey":"0x802775e14fda679e4594ca8ccda68a706957fe82c10e66d258eafd21fe5b2877c226092004f82874fb4022d73b74eea6","to_execution_address":"0x96d1b2431158938de8efb094a1b6c64ac3df5962"},"signature":"0xa2695a1a43803793a6a1e80b15798147d8a63da5c8a6ee3e18dabd190255f48cbe36c33e3ffa372e11b19605cd2282a3136a2662cd3c8f9d3d0345ec1593b4241a0ee66c0d626da3db5cc6bd7d1119063922633c1c2987d69839af6ac37eb675"},{"message":{"validator_index":"126769","from_bls_pubkey":"0xa1b20c565a67fc79e0dc4d8a335d9d3c7cba0865cec80a8f7f49bf610e20ab39afac693fe60778de840444b3ead514a2","to_execution_address":"0xbc13a74351ef5117d2757feb48c8efe4cfe55786"},"signature":"0x9113b44632e0dac2168c83f2be8634d2eabe9b81ab5d426c31ffc119f3fc577c16edb82f50b13be7174eca9adbc2dc560f1ad4bd15a414e44a5ce7b330e8645f58cb50204f6e4ab4bd7c9315b355c97a5862e05f5140c61bd1a4de061855f0db"},{"message":{"validator_index":"2586038","from_bls_pubkey":"0x83b8e297b2e5b17d8b30acc4586741cbe2f1f9de15b53add4e41cf23fd6f9034de02c5159eb4212e575a3255d681220b","to_execution_address":"0xdf80b0429057f4630e72700a013b4e8ad6642e7a"},"signature":"0x8ac01bb60be2b4f4ae1847cdd5f95d3af16fd4cff3fa9d0da17d72f31a2cce4251e51907a63cb8ab9842a784cda7c40e0a93c536c8321a8abd889e3ed438d8653b77d0d06d3fc61f38b235f0e4c57c9dca562593216d94bfaf903d109eeb3e84"},{"message":{"validator_index":"662293","from_bls_pubkey":"0xa9701b9f205890357cd0b75c121c25306bd409e007ad97323af8b41aa535a8227f82fa8537f8e1e9a89a216a53aeeab9","to_execution_address":"0x05c3a442cfeeb2edf8f73e61a84c7724e26a2c9e"},"signature":"0xa3779a97b60b64b43f1249ac6e49af7a02d87608ccbcca01b26cb226baf3d0a135b6d98d008f4417e714a1512ce07fbb18c6e491fa2e6cad5e1d9e29f56aedb856073cfa6f90cc9b21db6b3ea9cb35f3c9ec47ad48996650941b4b8d5e6355b7"},{"message":{"validator_index":"277544","from_bls_pubkey":"0xae86d94e3803aa062745028c91f9eaeb957af12e0d1e1c479c3ee78dfa76d792c8778507bbe0f1aded55e48d10b94a8f","to_execution_address":"0x61eb2543106f8202e5365fa6788ab38459284212"},"signature":"0x831796f518dd44cbddc77db8d223ab502edc7bab53c2795edb3879e4f79171f13e4b7d5c5f354e06314c6c1fec3988f703234fb99488ef541062ef7f8a89f77bd18b82f79db2328ec0cd6db498f5ab4412800e9e4a351fad3d609a192b0eae61"},{"message":{"validator_index":"1509782","from_bls_pubkey":"0x8c1cba560684965a1d17efcc10ac3e688808a44a655caef64fe19b0f11be06e324d48651b6d9663e33964737affaca25","to_execution_address":"0x872d1a435006418cd0bc2dfd1f9cdc1e652e4036"},"signature":"0x8b8974bfbed37e66501f80a64e0d81d27723e76fb46afb5e94398a6b956254aabd7e9af026d996dee341f804951284140ba20654abb8af117f23f4afa0144a7ea57076a4a0fbc727d1f1111edf829a8cdca542799d24a5021c103ba2a23c75de"},{"message":{"validator_index":"1125033","from_bls_pubkey":"0xa127dd51be074dce1f11b15a9040d935aae14a0b073a7ab906edc1327f477e8213d96f738690b3f650a479dac373cbed","to_execution_address":"0x4678df4290faf93c645a36af63f4a921a44c36ea"},"signature":"0x8657c885c3361cd4a58769798bf4baa0424238c9a2c5b20b79b6079ca67198cfdbc407cb9e4799663bc54543f1a74df8044006e589cfb7b5914cf77fb175cfb959b29861d42c3da17eb66102ad8afc8f20fb5e7f52934c385018e3db3bed9181"},{"message":{"validator_index":"2045306","from_bls_pubkey":"0xa67a1e9a2522bca1507faa25403c3ba020af65ffe839656e87f957438ceec07d5d8a91658e9fe6efe8703f1b5d24ffe3","to_execution_address":"0xcfdc1742cf05a262f63eed727f20645e78b3144e"},"signature":"0x8dc84218c00f49ed40442f962e7afeb1a8c2ef5f4ed0aa8eda187ace69d22cd62b759e44754a66edf611383434b0d7bb18ca3eace8402fdeaeb7a5ee16639ac7133defc018719cfdf5a771449cab814076545f41f6662202d42deda5857c93f2"},{"message":{"validator_index":"1660558","from_bls_pubkey":"0xa2cd1e8619ea096ad3130c8f2dfa725c44cc8aa06de4f186d87ecaa92251bee9bc08ae465d6ea48b145a4f70f0729e42","to_execution_address":"0x8e27dd410efa5a138adcf524c3783161b7d10a02"},"signature":"0x97f8c4c02c4241858c09d9f2926670619f01a2e88fe50b3f3456c7db24c1c470a30eb58790400f29abdb9a9db63e075315d7e7b359848e76d4c637247b6a2ae492bb237e4aad36764ebbc93a0836cc4962e51681e15f00dfa1429311b1140e4d"},{"message":{"validator_index":"2736813","from_bls_pubkey":"0x96057456506ff35b37222395a6cf87fec4386244d7ee0ecadd11c96e8f7975a312b6826bd69e069eed2e88fbae21439d","to_execution_address":"0xb469d1414e91199d7562c47b6a8a5afbc3d70826"},"signature":"0x8734759600f9bdcc5a05f0c70f90062f0d0056ed8af19e4777fe4d5b67267fb33d2617d4630fd75822d0f1b60c70650a17fe6d16ec4fe2d4fdd2fd3433c357470dd8276a069a5402372a83091f40217805da560122e3d9ba5a98034b21191439"}]}}} \ No newline at end of file +{ + "version": "capella", + "execution_payload_blinded": true, + "execution_payload_value": "7495532986413849817267215758148158394038672421876771029699707700121804844683", + "consensus_block_value": "16147741642076749126162712127389114255573229005697131290860120949861914404374", + "data": { + "slot": "1", + "proposer_index": "4666673844721362956", + "parent_root": "0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef", + "state_root": "0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e", + "body": { + "randao_reveal": "0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71", + "eth1_data": { + "deposit_root": "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f", + "deposit_count": "4658411424342975020", + "block_hash": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + }, + "graffiti": "0x0000000000000000000000000000000000000000000000000000000000000000", + "proposer_slashings": [ + { + "signed_header_1": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b", + "state_root": "0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb", + "body_root": "0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486" + }, + "signature": "0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483" + }, + "signed_header_2": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6", + "state_root": "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "body_root": "0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1" + }, + "signature": "0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1" + } + } + ], + "attester_slashings": [ + { + "attestation_1": { + "attesting_indices": [ + "4590659586689121994", + "4589007099177470570", + "4580744678799082634" + ], + "data": { + "slot": "4579092195582398506", + "index": "4584049649527418186", + "beacon_block_root": "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06", + "source": { + "epoch": "538655350", + "root": "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0" + }, + "target": { + "epoch": "539040099", + "root": "0xda533c406bf3482d8e6e992e756be34172a8c47fc1cc0018350bfe98c946deda" + } + }, + "signature": "0x8bfc6e1a1c76bdafb4d491ce02a35effde6d7362eb32c03f119c47c12fb2b49e7656bbd4702ba02560fd7fe117f2c74e02142ce46176ebf269d5b34a48a65525e35db6cc446965e86e22e9d8adf5abe92315690b6de5f4591769487539fed52a" + }, + "attestation_2": { + "attesting_indices": [ + "4590659586689121994", + "4589007099177470570", + "4580744678799082634" + ], + "data": { + "slot": "4618751809962686763", + "index": "4623709263907706443", + "beacon_block_root": "0x27d82440eb21c640637a36dcc38e35768bb4c0c79aefa300ec0f0cba32cabb05", + "source": { + "epoch": "537116355", + "root": "0x999e0140abe701de220ca2e0b9c3b044b1c6ba33e0a3985dfe16a16b510f0846" + }, + "target": { + "epoch": "537501104", + "root": "0x735c0d406b5043543786d38912b287aaa4c0bc0f731247e9a3141adb9c4d9930" + } + }, + "signature": "0xb2213ef588828a7c18cdc781d0ed2516fd3e11de625f191aae7ae4be8b1ad2cc217728c65a500aedea276d345f09fd3212b009568a6549f5f40ead6d7ec4d0f3f329c00a1b4bca59068ee0555c94aec91bebc18365ca0b2d6692557b4b0c4267" + } + } + ], + "attestations": [ + { + "aggregation_bits": "0x907c35a14e5afee2fffc1703230dbe923ea49766c5af5277f432d84b3c2323d8a5a8dc131a8cbb3c69aad1172537e0826b0f4ee1639f650b91bbeab0eaf337f9472742d6f8443c1eb7c62f5f876f5f154689fb6548800c39b12a8d1f2585230fc372dfe5bc46a4c4358fb1ebb547796df094800159f2c9d982d61666d8a188e3b665900ce8f564188f269b5265d345893085d41f43a030337dedcafbef1245fb43c6c44b9891c2ff5f157069435c52c7fc457d5ec218f5d2ca50e69cae88c863b56e53213d92d7f6357a56344a4c2b80b58249b494d992f3c78d7440fe6b69d32ff3c1c29dbea8d0aebc1347743dac65bb66529f27dcf476baa3774d1e5c69dd01", + "data": { + "slot": "4608836906367614699", + "index": "4547695001580498185", + "beacon_block_root": "0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2", + "source": { + "epoch": "529806126", + "root": "0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd" + }, + "target": { + "epoch": "528651879", + "root": "0xe24dff3e29e762b4488e615619483884c44b8f4b37239b5cdc4a3bd7d9b48c1d" + } + }, + "signature": "0x913ce44a60f20df0261b53d8031d13f3a8d51cf53ba5eb65735ae960623c48acd56286b31ecd74cdaf51f66b2b2331fa0e907e8cb9d4dde513ca29cc34ee9925301bb541055a8daef33bb3e1fb8442a4a033f93f86933bc35fd2ce34a569a6ef" + }, + { + "aggregation_bits": "0xae44a59e9b57b7141da75dba9d385b795ba84317f41948621bf98a34f92168838b72a9678bc58de000cf466104613975fb1490c591f0ee9055cce4aaa2ff0eb5a26c8b9e20b6a386d9e9f7964a3ebb957e3c6b0124271c279496235101a29fbf18ac7be6749a8b1f230bb5131e97b28c06683ca9a6cb6129b2a25b4f539f7f5e41cc1997c5b4a57d51dbce5ad4ab746a403e5270c785b76d47475c0ee6c309e33dad08193c3f8e40e9414096276bfb5708c84359dd51eb54ca67dd7a6eb5645801fb83811b4c11eb5b240e9d0bc0847ae7abfa235c7d6cc5f7eca53bce62b1b987b7c11ef54592399882d7983eb3c6a58ff636f52b4007afbc0d66bfe9d9276a01", + "data": { + "slot": "4532822644040406441", + "index": "4537780097985426121", + "beacon_block_root": "0x0890f33e697e213e331430adc059611ed0518d6fa4b4ecd0384dc2678e76fb32", + "source": { + "epoch": "527112883", + "root": "0x7a56d03e29445ddbf2a59bb1b68edcecf66387dbea68e12d4a545719acbb4773" + }, + "target": { + "epoch": "527497632", + "root": "0x5414dc3ee9ac9e510720cd5a0e7db352e95d89b77dd78fb9ef51d088f8f9d85d" + } + }, + "signature": "0xa3f0d1902ab93bc710c2af70da7699b79480ee062fc8add2cc1c6ddce56d54706ef91f581ec0f94cee95fc4be146005f174e2e77733d71ef59e53a12eb852e09e4334af2c27120e506ebab9c04e2b2f99045d40bd1372618173cf6df4ad21f86" + }, + { + "aggregation_bits": "0xe2e8a45105213f0f211443b26e3a23df7f899eb9b3ddd40b5f51905f90441f98eaa0d2b9ed7dddf5b4089188c41388cb5702236640399f914245bc085459f40d628a99fd663a4429e9b46e61dc8beb6ae3757aaeffc6db49c374cc93d1e663989d84fa7b4aa499a8b5d34ec5fea94bcdb33af829c6260d2a88a6be97e89baa6215949a4ef124436f685d4ee683c0c27f0ac7aefd77f4b305842d1cf2d08d9b7f4e501a38b81014fcbcec2156d5abbd1010afe4a596164e4659c6dd794639199119b4a3f2ec4f3b4d6a084bdedf66dfdcc1be1c522d9bf72663b7cc1a8746c3737e20ef7ee1b7863f89ab600a35772b4eede0424b8b69bcd27a6b354252a0147701", + "data": { + "slot": "4575787224854062954", + "index": "4567524808770642314", + "beacon_block_root": "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "source": { + "epoch": "532114619", + "root": "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c" + }, + "target": { + "epoch": "530960372", + "root": "0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c" + } + }, + "signature": "0x8166b2ed13e982e6b9f05d30f42681b826099135a533d2614ef5f4f59811714245db0e1821a644859559f97ec1e614bf08b2edb294fa2edc1527f46596399534af23c98613e1b74c01871bf1dd2af9618bc0ba23ddfce8026b897cdbba8c1bce" + } + ], + "deposits": [ + { + "proof": [ + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587" + ], + "data": { + "pubkey": "0x83b9036200e9e907c86ede7f98b23297389e8af19d403466e00f1946867db735d8620019e28aa42739f49c65b78a2806", + "withdrawal_credentials": "0x49452e3f298a688d9e7627fb7c01941b923397bb84dd548b6e411f9506aed1c7", + "amount": "32000000000", + "signature": "0x86e6ad7c26352727d310e10f7c745a0725636f63013f70c5a442489946dcd1c85665cd3539fe9d8fe6f6b49b5b7f13a50af2a2b98a7d385417c98e5d74273e67cc3bd8f8544dc3697124c8176835745659182eab37f3ebe0a881ff4e7f62bc31" + } + } + ], + "voluntary_exits": [ + { + "message": { + "epoch": "4555957421958886121", + "validator_index": "4557609905175570249" + }, + "signature": "0xaacffaf60c8253477ecad70de8589f2ef7670d0b0dc446d4baac3b465a901d3e64bb6d2c3d8bdb58aed45ac30466261416d152d5ae242204201bf6decfddde697ae0c5d44cf31ca3d43aa18f2799461fc1ee14dbf905b1e31f242fd31c083c5a" + } + ], + "sync_aggregate": { + "sync_committee_bits": "0x01000000", + "sync_committee_signature": "0x86e947b46923b26125a7dab3240481ddc1b910c1e6393b90df6e2de3809b8b35e450dc8264ecedd8f6bfc736e7114d841428b2469441d2d1d501015eb99e0d7090f11a1185b566dc42f94b79d0a08b22718a39b57e912a304419361108434ec8" + }, + "execution_payload_header": { + "parent_hash": "0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874", + "fee_recipient": "0x0c0d553e4878ae811024144112c88bbf79a372d5", + "state_root": "0x1f2e4f3ee8c38dc605677b6ce650a08c7fa6716795a8622d396e244f710e0a5f", + "receipts_root": "0x7ed3313e083eea1ecfb57f4508fd068e9fb56c4125942ed01ef47538b5f29e14", + "logs_bloom": "0x91f42b3ea889c963c4f8e670db851b5ba5b86bd3dc5c578a4c75b9008f53569fed0e82445821ecdf1e306d211dc4b3e042d5813f11ce16132211c523a92d723ffdaaf2175eaa77a1937f2e9f27b5e5b0f1bd3b77dbc94c7215fa1065d6066ea59bf2b95b8fe2ef820d9cf6a10c93f04f98db135751e1d8972d2427113953334f5634914e66e00af04d50d4de255bb0540ed3627a6f64073f81a28f777cba3a4ff145230e8103befc67e3ae2e8c72518ea18fa75495daac19c0f5c5094c84853de2b6ba4e2275c8a941cfb1a29f5a24ba911dd636080b0859abaa198dda14a860d4d29306b038ddd219c708ed837583079254b70c7095ac70984894735b79f7f9", + "prev_randao": "0x58913d3ec8a62b95e52fb1ee60ebddf392af6e1db902dd5bc3f1eea7003130ff", + "block_number": "4483248126065046120", + "gas_limit": "4474985709981625479", + "gas_used": "4473333226764941351", + "timestamp": "4478290672120026440", + "extra_data": "0xb736203ee72088edaf7eb5c7839744f5b1be69f748eea8fea77740914415c5b4", + "base_fee_per_gas": "81744492456258793280520536666094060462558404863190111969507816784424614128915", + "block_hash": "0xc7dab83ea972daeec7b1385f04b22e210f708323c38b84160159653a163f259e", + "transactions_root": "0x8e77ca3ec98f3c20e7e802dd8917f1b9fc66866da0310ae878d59ae1871cfffd", + "withdrawals_root": "0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9" + }, + "bls_to_execution_changes": [ + { + "message": { + "validator_index": "958637", + "from_bls_pubkey": "0x89ca6fbbaafb3c27a42f70699f42e3f79d3b7681b103e5b393042efa90512aa9e590fccb0b654a5c1590bbe675aa584e", + "to_execution_address": "0x4dc28f3e0884f5d07b860b8fce6fbebc3b857c21" + }, + "signature": "0xa207b627176533d6fc3670d6c4a48afff107ef6bf9d7520b0f77162bf7df5505aa3a17c08ee53067daad827b75ef333015a61a81b421ec8888ff31dc50994121420862d11926782bf6983aab5f6f39c17264a77943dd6618d85444c56d469c19" + }, + { + "message": { + "validator_index": "2034892", + "from_bls_pubkey": "0xb384518c8bde1118e66c725854a5919c4a5c0453e8eb822fed707aa5c636e6e2a2aa56c95966817ec67ebadf6c77b44a", + "to_execution_address": "0x7304843e481bb45a660cdae57581e756478b7a45" + }, + "signature": "0xaf85c50db6dad8c04b9a22611e3174fdc57a3cfe255164e0361897353984556c3e7b91b040ec3b59cc29d774aaacf4b204e4e1960b9dd5bf9b72f8c3e09bdd64753a65084567c10b229784fe46be3de016c8add60d84c970943d221882294028" + }, + { + "message": { + "validator_index": "2742020", + "from_bls_pubkey": "0xb2bffd7d93c4b1e46b3f4511f97de3ac70e2f9b2e3428b26ad7864d9f71bbca34904c81dbcc1dc2ffd1c02bfa016b096", + "to_execution_address": "0x7b5e6c4391e30ac86613889d8c20bde70e044e3a" + }, + "signature": "0xa2a6993708f79d7b3db30c3968aaf4b706400145cf70fded02b06d54922e54a4c1db14d63860cc632d0b2a8c15efc5280bc57ceed454838f2a0848e03e610e130309d8012aa5eddc1fa84b509fc8178a685baaa0413ec58709e738aae430491d" + }, + { + "message": { + "validator_index": "818276", + "from_bls_pubkey": "0x94e2d4cf94fb757578c496885af2075c26e2483eeffa6e894ac791f7c1945b0fbf9a6f7860736db93e03d511c4b08516", + "to_execution_address": "0xa2a06043d17ac951519956f43432e6811a0a4c5e" + }, + "signature": "0xa8b4b8e92e67565ec430f2fdda94ed0f6f06d8cb302770191d614b795d194e4728c11e72162f25e04d0f7dda1dcd54da0d8a7c39e71e945873168ffa294da70dd1acbc1902a2fb1598267df5d277a0f95592967ea222ab0706571001c315eb2b" + }, + { + "message": { + "validator_index": "433527", + "from_bls_pubkey": "0xa5041469fc5f6a944fda64e7ab422c1479ab9d0de12a2f3ac7292dfe368408cbc6d2b0ff519b521427da731e7378806e", + "to_execution_address": "0xfdc8e14312fb98663ed87639047022e291c761d2" + }, + "signature": "0xb66c9d2c80f5a12930f0899b9ff3d1a6a37e0f9edb279ced767eca8ef0380227681b15bd3850a00a383491ed1d8e869310f10edea2b912278e1e2ec1cfaaba8c0981af2e40fd233a9fd2f67ec56540c66e062212ee2781593a4714914e15cb52" + }, + { + "message": { + "validator_index": "1665765", + "from_bls_pubkey": "0x9105e2e35c7861d3fee37cb3bf07e8fdf3e0911d251cb11b956d4edbbd62a951c7ac9854677ce19a7748a503c307028c", + "to_execution_address": "0x240bd643529257f0285e4590ab814b7c9dcd5ff6" + }, + "signature": "0xb3b0b28bedcc6e28d433c2a577204a9f7ecfc2fd4e3067ddcb65caebf7fd32d0389dd1db836600b0ee19a2ac8b6d0a660788a42abfde02bd5bddfdbe8cdde83a890ce69ee178ea314cfd9c06e5507ffe5cc4a685004f955219fcbbbec6fdd144" + }, + { + "message": { + "validator_index": "1281016", + "from_bls_pubkey": "0xaae4f1779eb7e006a9d0195e39af1f14a05b017a4a351ee1f3c22929929fb510cae4ba8e01b6d2444a66e388e655d92c", + "to_execution_address": "0xe3559b43918610a1bdfb4d42efd9187fdceb55aa" + }, + "signature": "0xa3acdd589f44c5b4201ae54cd119add73b60bcaca91f9e5d028669dd9b52f3ce15c20bb0ec39ff9ddfe96d5c1ce979c10376d36f4840a04cd90ed9d4348fa4a53f0f00e35bfab055a102ce3b6306255ffba3ef9ce7e1548048139d574478ebbf" + }, + { + "message": { + "validator_index": "2201289", + "from_bls_pubkey": "0x842bb38ef27bafce4e8aa9abd3e31286da4d36eb87ff6a2fc4de272e4878230a7ac7a723bf3f76101ab2c2a642550eff", + "to_execution_address": "0x6cbad342d091b8c64ee004060b06d3bbb052340e" + }, + "signature": "0xabd643eedb5dfcc8f2db27bcfd59f6359517cec81ab4d5ff08bd5fd246ba120883c047e0cffc1d215104169a335628180df5779f128772f899546fd260328d4a4368a044c3e2037f4284624728dc94e05467b1559aad3077cf9557bf62fc56e2" + }, + { + "message": { + "validator_index": "1816540", + "from_bls_pubkey": "0x990cf4f3bf6ede0aaef3010026465f98f381860535ce007b87879afbf2c955c13d07d7c2d91e22fddd8ef5531f8bd22c", + "to_execution_address": "0x2b0599420f867177e37d0db84f5ea0beef702ac2" + }, + "signature": "0xac8ebc3beb6cfc97c27f286e0d2e582707cbcb972d0898a41831b2d1393a684ce54ce54dc9128dc3988930ae4d92b4ed0a51b2bf639d8fd8e62e40ceac222362d9bb67f9d1b8419f3123dac1bb2e4e0cccb5c7c0985c83bd0501ed610935aa96" + }, + { + "message": { + "validator_index": "2892795", + "from_bls_pubkey": "0xa0695f8f6f65e3d8401e144eb382eaed73f9ec56be6de71dadb917af79a08ff7b74967dd4f4766ed77f7bc2fc01cfa38", + "to_execution_address": "0x51478d424f1d3001cd03dc0ef66fc958fb7628e6" + }, + "signature": "0xa18c2c70d886e11a592393a7bef6fb3a515100e1436763854eb96fca9c031a959e4c105be367a10ea87c3d1a8bce821303470a1d6053cd89139bbd86fd7bbdd3e377b331884bedb0f9b10eafcb3272561fc5d71b96b219d7fe3aacd6e1558c97" + }, + { + "message": { + "validator_index": "2664029", + "from_bls_pubkey": "0x97e268878248299c9e4d2c86957935d6cddb83900dbb6d4e52a935bcda58978f6fd33e0dc891cea14da0feafd5173762", + "to_execution_address": "0xad6f0e43909dff15ba42fc53c6ad05b972343e5a" + }, + "signature": "0xa2010187045aa6d63130c7ff23464438af57c3e42eaa90823205936a94c47713b68bd93d3b6837947e277ece630a6d200d428979548f340f6f71ca33e8731e059a8c20f75d71d36caebbbf6fde28f37a919353dedb7b7c7e4dbcda553e5bbee5" + }, + { + "message": { + "validator_index": "740284", + "from_bls_pubkey": "0x8aec1b1f595063af33939f3c3322ad38d2e1de1b11fbc8a9d04235dc7fc9792e1c88e51452d337855d254a71f42816e8", + "to_execution_address": "0xd3b10243d034be9fa5c8caaa6ebf2e537e3a3c7e" + }, + "signature": "0xa0ba14bb9ce5877d9f9d607da9b2fd2d629a1de42d6d3beb5a8f4c1661aa1d6863e01de14c548be8a9df222efc6373be1290581da81c76d71bfada1d07481d7b7de94290efd640aadca41d6b4d4f81091f4c459b454bd6e333eaa35c60faacf5" + }, + { + "message": { + "validator_index": "355536", + "from_bls_pubkey": "0xa912f4ad989d87e777e45af7c265b430daf0b39345987506d4158cdee406847f294fc7745154eb52abf0934a5e1866ee", + "to_execution_address": "0xf51e0c420e9d60ece0c4bbc926328df885b91272" + }, + "signature": "0xa7f77c7fc98b1c3a364dcac68b5cff112f7745e6dd41918ba56a6fa6945507e0ce245334e22d4581f49bda913baa2a6b1176b44d52168151b3aff9a625dcdebad1899747c42c4a43cf31f49124fc0d4543e4485592c243c5300b79214398b770" + }, + { + "message": { + "validator_index": "1275809", + "from_bls_pubkey": "0xa77e90361be2a534a386cb689d6d763a98bea5f23f325b553a762648668e4adb4991fb5f41ad7ece1578f082a5c01b5e", + "to_execution_address": "0x1c6100424e341f76cb4a8a20cd43b69291bf1096" + }, + "signature": "0xad188010cb0db88e067c2699030353a1c215ae9adf083916ee2069a805e0f2cd00c76db9250a859106dbbff4430b4dd114d6293c4b3c2e9cfd31f07949f04e53f63423a08b56d7247772d07959d5d92b17bd8c7c0b294b71d3db903d56509177" + }, + { + "message": { + "validator_index": "891060", + "from_bls_pubkey": "0xb4582d56f8ad9dcc77eb5413558e63a6b562e42534c579a85384e7d7d6ff8974ff933d05a444c1d2784945f4cd1c952e", + "to_execution_address": "0xdbabc5418e28d8265fe892d2129c8395d0dd064a" + }, + "signature": "0xa7f07c5a20159b029b2dac119315a0d439c541e63b0d1f6d377fd2867e5559d6b6302eb609d5796fab97cbca121ddf400c840b9ffa60dbcd89c6d441f84aff2cca1f68fd9e258a969b0d511ad1d90c0c783dde3c093ee8cd56cf6f70a61fd77a" + }, + { + "message": { + "validator_index": "2123298", + "from_bls_pubkey": "0xa5849044acc283563bd9b40fe9b01a8c079093829fc3837cddf20a8f9c13e59629251481406f415c8e2df65285ddb41f", + "to_execution_address": "0x9ecb7542cf4bad14a20f79bc45931b8d1483242e" + }, + "signature": "0x81df97c3071aac41af79494001a1c4404b5121776a71d6cbe3b8eef000e803f59edd2fff33331d2ea037faa919ddd6a115e09bead88d7c8f23368628f306e3a244f2ce0a54e4472d29e4b79eced6da3e5ab40177e96fa0d94d97f5e07d2e6e95" + } + ] + } + } +} \ No newline at end of file diff --git a/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlindedBlockDENEB.json b/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlindedBlockDENEB.json index cc2478fcba0..28fc27d9620 100644 --- a/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlindedBlockDENEB.json +++ b/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlindedBlockDENEB.json @@ -1 +1,355 @@ -{"version":"deneb","execution_payload_blinded":true,"execution_payload_value":"12345","consensus_block_value":"123000000000","data":{"slot":"1","proposer_index":"4666673844721362956","parent_root":"0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef","state_root":"0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e","body":{"randao_reveal":"0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71","eth1_data":{"deposit_root":"0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f","deposit_count":"4658411424342975020","block_hash":"0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379"},"graffiti":"0x0000000000000000000000000000000000000000000000000000000000000000","proposer_slashings":[{"signed_header_1":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b","state_root":"0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb","body_root":"0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486"},"signature":"0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483"},"signed_header_2":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6","state_root":"0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26","body_root":"0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1"},"signature":"0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1"}}],"attester_slashings":[{"attestation_1":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4580744678799082634","index":"4579092195582398506","beacon_block_root":"0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c","source":{"epoch":"533461240","root":"0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565"},"target":{"epoch":"538462976","root":"0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650"}},"signature":"0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc"},"attestation_2":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4620404293179370891","index":"4618751809962686763","beacon_block_root":"0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b","source":{"epoch":"538078227","root":"0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb"},"target":{"epoch":"536923980","root":"0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5"}},"signature":"0xa32991816eb9f297553b4732309a4cdba7b33287264611715b0ab3319bca19e581da6e2659912a4e0e94aafc01c488e30ffc96ed14e2a726b9d3c618405ee0bf54bf6ae7f2097465cb27ab8132ec24eb93d3c9159475304082f7f0e452b93b65"}}],"attestations":[{"aggregation_bits":"0xfa79cdb89d0d51c5cdd001b7425c6d726750a9d5f89ade6ed9890ce3a706140c399a5e10c90a819094b65322dac7501f7c75471e69d4567358d8ca75f7c1b3133ebecf006b369a1f36efc5f2b706d5922ff98c58a1825a53a864376658f816600cf021cea843d4396502bb9c74d1510afe26036f89f783b4f5c7bacb6649c46f217a6af835f312d6fa253d2bbc83c07993f4f10de2ed2d952689379dbe4f794c1a1055a6b364d68e038deec9667f576b3b9eca5fcadd6298f181e1edb876efc3d0975ae14ae9a0ad2f1836d4c3f1080a96d8ab7c43b34bb2eda895ff66be698b363cfa4be33da3ec94a1a7a90672fd12c4a59916bb937e78476e4f08e4f4031001","data":{"slot":"4605531939934246443","index":"4610489389584298827","beacon_block_root":"0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b","source":{"epoch":"529421377","root":"0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2"},"target":{"epoch":"529806126","root":"0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd"}},"signature":"0x8f8d16b39e14569aab1b712e5c19ed51afe3600a6b017e8ab432f43a02ee720a733c33ef087d2f3653a9701e8d8a836301655b9195c0373b775c88ba1368e5d55354a70a3096bd26dee29dddbe7a4820e2b1653e84122beacbc01af7d93e6bdc"},{"aggregation_bits":"0x4ac567b296efbf7cf3209e87096a7a1a50fd523400113f917f6584a5a306f06b2d8da9ae858d47ff2594010089838efe41f19a78d9aae27c2ffde26f278b8681db9d091eb72e7cab3e449dfccd46a270693e1f88f197324e57bfd45573315cf9fb60d770937b32f7c0c6ce1581ec51e6b60f71acfde304dc917f2e0aa7872038b7d9140d15f7927c23a0490a74c2b0aca2773fed9217067e4444f9ca93874e4ff8407111c3efdb138b97c6d4957b6a70ec1debb283e3d0eb1cfef068adcffbf057d20fdc339eae03f0fa2613abdde8158a7fc40c3cfd1117eb6f8c4ae21d6b2ab4b57ae9a8653a34451aee6418c0c3609dc937293f5f5b346a7ab1a0d144185101","data":{"slot":"4544390030852162633","index":"4542737547635478505","beacon_block_root":"0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd","source":{"epoch":"527690007","root":"0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8"},"target":{"epoch":"528074756","root":"0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8"}},"signature":"0x90309dd491ae6ed51917dc305a3d4ae68d0a0d4792c7eb59c193bd03605bd94e61cab37502de0ad3e6162bc02427bba80a798b3670d5de82a854094016cc298b265371345c0e3ac49fd44bbb9ba0d4fcea0c1a80cecb60e93921d907e8c48120"},{"aggregation_bits":"0xe8c9759f0840f980ae956b15fc383d992e7d4420d12ba5bf32f669f446ac6fa388e20e5ce96e9266dd98840179d2cde3cabd9a8bafab5dec9c2e89f7f78c989e690548603984803b80c82d7b76443194576a1ce49da5cfe56f56e83b745fb01b5f18ccc86d88f5a22d927e64ff0b8e880893abcddec45b268531c4a0697537dae643a24b1a36432f37d42962553bd39af71f37e0429b81470c11316aa39db074aa3f1df4124e7cb203debed60b885ffb9b27e46a1434e81bbd56566632d0729c0822ac415cbb67f25973667d88e58df9c2f058a0ae7f118c98cc448453b6fbe590363bd17ed62c2f808df61f2a9e593235eeb56db74b9dd15980189a5271468301","data":{"slot":"4529517677607038185","index":"4574134745932346122","beacon_block_root":"0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947","source":{"epoch":"532884117","root":"0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31"},"target":{"epoch":"531729870","root":"0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672"}},"signature":"0x8c40f51a99fce6ebb9a4db5e80d715fff319e7ae523e46afb5d03c000d427e23c7a39e77e2af53851706283c8ca91d680997cb459386fbdff52c4d0ecf498e173717a838a792b210bdffaf476538628584a133899bf30dd5ce7056463b8cd683"}],"deposits":[{"proof":["0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c"],"data":{"pubkey":"0xb1f8f6e731dbf6b4e3265fb857c7190adbfc7e6cc95ce2e8bda72be8b6ea3459f862310a2484c3b0ee33b30920f18c1d","withdrawal_credentials":"0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c","amount":"32000000000","signature":"0xb594382214f5bdd375de66c45e1c61a526c7b73fb166c72433bbd9c2a7ad6881244e61cc6427e0206a50b762a129d8830e8708c55761d61ce9e3b19c1bee13bc55daa13bdb07118efdbf57a588b8a64e6392d14f935e53b68933e3355b35acdb"}}],"voluntary_exits":[{"message":{"epoch":"4562567354825622634","validator_index":"4564219838042306762"},"signature":"0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e"}],"sync_aggregate":{"sync_committee_bits":"0x01000000","sync_committee_signature":"0x919ee45cc18456f6e85da6bc21c2e40f44f9a887932c73ea9ad354f88e56d4ec0a8c396ed143082c8e31d697b877a2a215d2966d91c7beb156bf7ab5777e210012f70dcd5f7657808a82cba51e194be994f917150ebdb9e5c57476f1edb47206"},"execution_payload_header":{"parent_hash":"0xf8eb5a3ea82ccf3c1be1ac153e3f77f273a07343291711b9de6b9dbebc4c9b49","fee_recipient":"0xbf886c3ec849316e3b187793c3a4398b6097768d","state_root":"0xd2a9663e689510b3305bdebe972d4e58669a751fbc85bf448269162e078b2c34","receipts_root":"0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9","logs_bloom":"0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d078748f9069c96e9d6a2801cf607000a52447e46e1bef4e056ee30d4bd3517aaf7bf65ba04dd28c3a4a14b8dc72a300f051722a6814fa3931d90a82d23285d4c1127b6c67bbc4f8682ddbf9b31eb3114c26dccc5330109d6f17799339c2d7ed7e4e3a7de5d515106aaec7be6d78be3e21806d6d30c39b77c75dcf354b63033fb200b3b9dc023d948278f0956c0ee99323da0162f2a84b6a95749d2fa1d4e089af416d412ccd992683f7e41f7b496ca04f9f463806e3643d1c07f39d2a65f84e97b7dfaafac740d1e03f30923a4270fcf651ad2ca3737859a524e86e02229a55abd1a7","prev_randao":"0x0c0d553e4878ae811024144112c88bbf79a372d5dfdf39730cede08696ad52d4","block_number":"4489858063226749928","gas_limit":"4481595642848361992","gas_used":"4479943159631677864","timestamp":"4484900609281730248","extra_data":"0x6bb2373e68f20adada72181a3474f2c098b26daf6fcb0516f0723270da91e789","base_fee_per_gas":"91973405088222260025272995045243630915786868313949746451634391325697029602367","block_hash":"0xde78143e27b846779904841e2aa96d8fbec4671bb57ffa72037ac721f8d633ca","transactions_root":"0xa415263e48d5a8a8ba3b4e9caf0e3028abbb6a65922580447af6fcc869b40d2a","withdrawals_root":"0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be","blob_gas_used":"4476638188903342311","excess_blob_gas":"4521255257228650249"},"bls_to_execution_changes":[{"message":{"validator_index":"573888","from_bls_pubkey":"0xb8343e90edaecc9df1223293465ec067b3c9804f43e25817d27f1f4785bc5f554462032370781d9c65ab27bcc3d21415","to_execution_address":"0xdafbb23e48beb933bcf49f8ad83a43ee157382b5"},"signature":"0xa519e1354ad927358404a58bdc19113e5fd97d5cc19943888e22105ee943ca216a14898283fc3712500ba767de00022905e4198939b44a5f5a43fa0c87252969c56a26345135572101b257f87245a5e42fb2407a0ee67a6c2d039bf908b9aa8b"},{"message":{"validator_index":"189139","from_bls_pubkey":"0xa9ddce0cab5b51d3d2c710396b85e3fd7a87f1738fb5cfd5a7b25dbb483c167a80e785cb4ca7250c14a60cc282b1d9b8","to_execution_address":"0x9946783e88b272e45092a83c1c9310f154917869"},"signature":"0x8edfb3b9ed80067d0626019a1be330bac43c7ecd813f7ce781d0e6e34fb583803e9d2b047ad3294d6d3a54d020c68231085f7d9085d0afefb047def063a4698277e66d4a560f4b5bbd16586976f0bcf90177c00abd4a1b4cbd0ac393e5b904b5"},{"message":{"validator_index":"2357271","from_bls_pubkey":"0xa287d120292890ab1aa49bae1e3cd88bb160b5640f18c64f1aabae5990616e53099fe61698c3b812e2bc2ae6b6965960","to_execution_address":"0x09988f43d11dcf2aa7811c9997eb4119e8f153ce"},"signature":"0x8ca190827c66ff26c1fa594eae169b7efbd84c9456304f2194df7b0c204b0a29ac53034c9b20e4977b8e8b46d6b246da03a9337d3bf5e6f7ac941407a2a3437d7e2c0dcacda29b7623141833e02b4b12350ccaf8b27dbf96b3c520078f49efe2"},{"message":{"validator_index":"1972522","from_bls_pubkey":"0x8db8ee645b614f990839e4d98fdbf921263bb62cd917fb4eff9084dff23d7cc453f6cc645ad8b869aa9d31a6b9560630","to_execution_address":"0xc8e25443111288db3b1f254bdb430f1c27104a82"},"signature":"0xb0c3172e9bab8d04faa5d27f9818c36ad61a71b114f5bd9dbe77306be3edef2bcb56c215511ba76145006daec95f24be0f1f0dd24377cf7b440b5cdc7d0b520d6b64c539eaacaf14875d49c293af5974751bb0ce2daafde3bd01e097a466e75f"},{"message":{"validator_index":"48778","from_bls_pubkey":"0x8ba697cdd6f8c34a1fb96a4c88f03360d19515ccc4e1ea24aa5e80075d821059806a0047e6bbf5d908d312d1902aff5d","to_execution_address":"0xee24494351a9466526a5f3a1825538b6331648a6"},"signature":"0x87fadfd11bc5612e06c59d576c91599bc21095531fcc27a177967de7b521c377ee7a2b10d0fadf38779089929cfe136518757803c369b4ce94873e28d7d9cdf54c31a53ed86b07f76ea6104ee65d76de02267a4b736c949785ef233cbb73ad4a"},{"message":{"validator_index":"2820011","from_bls_pubkey":"0xa32a5f28ae7d36f888820160335232fc42ef994b4f93acf6a8659762b2ec52ca79354cc07c73a229b529bfcebc705eff","to_execution_address":"0x4a4dca439229167a13e413e752937416aad35d1a"},"signature":"0xa2089742415bdf32fa2dde853661a095ac24d273413687ae04fabb99ae2982700bcdb885d239e32543ffb95763a43e690cb1bf3a33df40d24e12c46d150e9c59dd63f960dec39712dabf74c08a55ba1bcb6db664ff9d5b2261da353e4374466c"},{"message":{"validator_index":"896267","from_bls_pubkey":"0xb679b4b686530827b2a201eb2b18454e9a5758d7257737b29bb215b9f354c2ff57e912b19d4a051556187aa24c97371b","to_execution_address":"0x708fbe43d1c0d403fd69e23dfaa49db0b6d95b3e"},"signature":"0x8da9cee45a3046b209da332512a6b4e4d7c89768f55998eb79ee236b4fb1fbcea87e0bba7b05d19ea7b8c5ea6dc0081e17a7ad0ec41566a0c6d9e127b87691e1d5b823fd178069e3f30091dcdbb44c36408656941755177c45bc976bf270289d"},{"message":{"validator_index":"511518","from_bls_pubkey":"0x83b8c61b63de768821cbd82ee3c67c81bb848163d6af0186ffe1ca3936d283bb4cab886f3fbc7f6336fec3da8d542c76","to_execution_address":"0x92fcc742102977503966d35cb217fc55bd583232"},"signature":"0x8c90298abaed4b5124cff46e41c9a4ed2b2baa0d2089add6b64c70dc7547f1a83bed76aba1fac6d36605beea72734b490b7b98994c7c65fdb436286b0df898731f6ad536e5a603da85ec8cc4488b94dc8c61e11363d1cc18733382dca51c7008"},{"message":{"validator_index":"1431791","from_bls_pubkey":"0xa532ee397fdd9e388888d90f712e13b085ad5043402debe1caf3dabbb514ed0d06f7c897e4e2795fd018cd672bfa8948","to_execution_address":"0xb83ebc4250c035da23eca1b3592925f0c95e3056"},"signature":"0x8fb8cb9373db269dd2a05fe0a07484db022a95b06c03807426a352499fcb65c55f8c388fd4cddbdd9936d5fe5ac5898e0d8b58ae09a73bdc7e584fe9940d3aa967607a0c4a1ad1ce5ccc0ad83f63a273e140ae0510f709cd0c214b645d68e3f4"},{"message":{"validator_index":"1047042","from_bls_pubkey":"0xb7d85608c3cf919ee72c0481283b468c2825850f6f6028c000cb19bff464556973909667d0353582d673e1049795f20c","to_execution_address":"0x778981428fb4ee8ab889aa659e81f2f2087d260a"},"signature":"0xa1079cff71763f60894927a0ac68cfff88642e5ec4e11d1f63ce7d7b15f2567842c80c0238a0f6e4d38ac2a9d09787c50c87daba460e05a0336332f1d37b65fed7526c5eb51a84d3a0169d09ddaf271d13710d22469e8dffde8859d50a2dd0a1"},{"message":{"validator_index":"2279280","from_bls_pubkey":"0xa46cb4c6f51759dd36e897cf8f5f8a774dbb5968defec8bcd85b9ec0f3d873a6569fabde6c6cf3fa5dc77e910bc39938","to_execution_address":"0x3aa93143d0d7c378fbb0904fd1788aea4c2244ee"},"signature":"0x988ea703ce8fcbd5bc7811c49e1eede7061ce461966a9a52f03afdecb157f065a1993fd71ea29c6769121610fc9e3e190eff938fb8c2f77dcf5f511208ad23cf427c05dd207b6c6004ba2a1ee3b6a84949e39db4ef1ee254635d3527010f7794"},{"message":{"validator_index":"1894531","from_bls_pubkey":"0xa18343c3306dae4ff3c78428069a4ae7876f0ad620219648b99b4bfaeea1d7898df50d508533e756f5903efbdf585076","to_execution_address":"0xf9f3f64210cc7c298f4e990115d157ed8b403aa2"},"signature":"0xa120e4f3144799db31e7487d25cbe6d8724f0076f23fdd7ff1f00b24b304a93a97862a3ebecb5e1b91018a0496a3c4020004b5d49571f4b9a3faf0f9d8f1f067d7005b5600db18872732313acf1350e1bec278384f3e0fe28d43f00203ae10e7"},{"message":{"validator_index":"2970787","from_bls_pubkey":"0xb23734206f673528ad12bad1b7815a9db722d7a5afffdfac97e17d453fcd2616a804619bd9f8db50b9547a357b1f5813","to_execution_address":"0x2036eb4250633bb379d46758bce28087974638c6"},"signature":"0x8de01f498b48fd1df0c20529228b7e8616c7bfc35457d392404110e394db4c884dad325363be1f2a83ac383486cdea460e78e89a728ac9464f71dfbc685ac8be3fb9ecb21d67a6c105354c58bfb78f2adf7ee65f5a4d7fbe5989e522b52daccf"},{"message":{"validator_index":"2430055","from_bls_pubkey":"0xb490d2df5759bb5115690df9aa805cddc1787b17fc3984ec400d03ccd5c6da6dbc54a724816ccf0c86b4b23e4daf0b17","to_execution_address":"0x42a3f4418ecbddffb5d058777555df2c9ec50eba"},"signature":"0x909ac7032213a33af76294ec19617f3fd9859bb22201e0502ae7187debe740c5cb0367ef03e944eab7fdc5ab23d303f916904a1ca5f7aadbcfbab89bdd82931dd7ff3e0efdd1135698f54774989ddd6d8ee07bebff863718c927072564a547bb"},{"message":{"validator_index":"506311","from_bls_pubkey":"0xa2810855686190fded08fbafafc427d3540a58c2b391c0d05a71be7a4d1aff2b4ea501c8e4c1ebb79cb49f1991ada976","to_execution_address":"0x68e5e841ce629c89a05627ce1c6708c7aacb0cde"},"signature":"0xa108770fd60463dfc982d8725440e47c54730329420bcf05a969e4937d06e468385b53c4a5f6c69e55a775f358fa0948171dedf3bb0ccc1679280251b7abe4cc644e10b46bcdaddd590951541bda68373c8a8dcbfb86d3cb97822a5dfc21f481"},{"message":{"validator_index":"121562","from_bls_pubkey":"0x8deafeba9f0184ffa1f3d1422b9d97d6975fc4d5a21df265b48b6e831d6aee5a6236b3d5fb9e03cab1e0795f3dd45206","to_execution_address":"0xc40d6a420fe36b9e8d954713eca4442721892252"},"signature":"0xb489851f8a8fd535ee14505b9ae32ab27cd8d5e637236f491f71bfc987316491ef3f1b7670378875580eb247993d82511128502ea093d108730e070bb8c5919b39e78893139b3f1a499e885b15d385073e227d6a4e85ba0413ab9e2481d0b8da"}],"blob_kzg_commitments":["0xb1ec6f426f978c599752e0e7181c305a1b8623c06088b5480b9aad7fe5f419d6c81a8f6862abe50a5e8cadf8649d347c","0x109252428f11e9b162a1e4c03bc8965b3a951e9aef7381ebf01fff6828d9ae8bbeb86d42469047b0c205fd55488427fc","0x23b34c422f5dc8f657e44bec0e51ab2840981d2ca63caaa51da14231033a661656d833a140f1279e0a1e40020f4c8be2","0xea4f5e424f7a2a28771b166a93b66dc12d8f207683e22f77941d78d8741740768f79e18451ce86d434d576fdbaf45f2f","0xfd705842efc5096d6c5e7d95673f828e34921f0839ab5831c29ebba04e78f7002799a7e34b2f67c27bedb9a981bcc315","0x5d163b420f4066c536ad816e89ebe88f53a11ae2c99624d4a7240d8a925c8cb61d3786bd2f14c967df66090765a3b695"]}}} \ No newline at end of file +{ + "version": "deneb", + "execution_payload_blinded": true, + "execution_payload_value": "50756583220288449835724789919752990744036228048165053817930899246206127260481", + "consensus_block_value": "24799950324699182119107049583125116496986047597328004586475399986067975839137", + "data": { + "slot": "1", + "proposer_index": "4666673844721362956", + "parent_root": "0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef", + "state_root": "0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e", + "body": { + "randao_reveal": "0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71", + "eth1_data": { + "deposit_root": "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f", + "deposit_count": "4658411424342975020", + "block_hash": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + }, + "graffiti": "0x0000000000000000000000000000000000000000000000000000000000000000", + "proposer_slashings": [ + { + "signed_header_1": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b", + "state_root": "0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb", + "body_root": "0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486" + }, + "signature": "0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483" + }, + "signed_header_2": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6", + "state_root": "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "body_root": "0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1" + }, + "signature": "0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1" + } + } + ], + "attester_slashings": [ + { + "attestation_1": { + "attesting_indices": [ + "4590659586689121994", + "4589007099177470570", + "4580744678799082634" + ], + "data": { + "slot": "4579092195582398506", + "index": "4584049649527418186", + "beacon_block_root": "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06", + "source": { + "epoch": "538655350", + "root": "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0" + }, + "target": { + "epoch": "539040099", + "root": "0xda533c406bf3482d8e6e992e756be34172a8c47fc1cc0018350bfe98c946deda" + } + }, + "signature": "0x8bfc6e1a1c76bdafb4d491ce02a35effde6d7362eb32c03f119c47c12fb2b49e7656bbd4702ba02560fd7fe117f2c74e02142ce46176ebf269d5b34a48a65525e35db6cc446965e86e22e9d8adf5abe92315690b6de5f4591769487539fed52a" + }, + "attestation_2": { + "attesting_indices": [ + "4590659586689121994", + "4589007099177470570", + "4580744678799082634" + ], + "data": { + "slot": "4618751809962686763", + "index": "4623709263907706443", + "beacon_block_root": "0x27d82440eb21c640637a36dcc38e35768bb4c0c79aefa300ec0f0cba32cabb05", + "source": { + "epoch": "537116355", + "root": "0x999e0140abe701de220ca2e0b9c3b044b1c6ba33e0a3985dfe16a16b510f0846" + }, + "target": { + "epoch": "537501104", + "root": "0x735c0d406b5043543786d38912b287aaa4c0bc0f731247e9a3141adb9c4d9930" + } + }, + "signature": "0xb2213ef588828a7c18cdc781d0ed2516fd3e11de625f191aae7ae4be8b1ad2cc217728c65a500aedea276d345f09fd3212b009568a6549f5f40ead6d7ec4d0f3f329c00a1b4bca59068ee0555c94aec91bebc18365ca0b2d6692557b4b0c4267" + } + } + ], + "attestations": [ + { + "aggregation_bits": "0x907c35a14e5afee2fffc1703230dbe923ea49766c5af5277f432d84b3c2323d8a5a8dc131a8cbb3c69aad1172537e0826b0f4ee1639f650b91bbeab0eaf337f9472742d6f8443c1eb7c62f5f876f5f154689fb6548800c39b12a8d1f2585230fc372dfe5bc46a4c4358fb1ebb547796df094800159f2c9d982d61666d8a188e3b665900ce8f564188f269b5265d345893085d41f43a030337dedcafbef1245fb43c6c44b9891c2ff5f157069435c52c7fc457d5ec218f5d2ca50e69cae88c863b56e53213d92d7f6357a56344a4c2b80b58249b494d992f3c78d7440fe6b69d32ff3c1c29dbea8d0aebc1347743dac65bb66529f27dcf476baa3774d1e5c69dd01", + "data": { + "slot": "4608836906367614699", + "index": "4547695001580498185", + "beacon_block_root": "0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2", + "source": { + "epoch": "529806126", + "root": "0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd" + }, + "target": { + "epoch": "528651879", + "root": "0xe24dff3e29e762b4488e615619483884c44b8f4b37239b5cdc4a3bd7d9b48c1d" + } + }, + "signature": "0x913ce44a60f20df0261b53d8031d13f3a8d51cf53ba5eb65735ae960623c48acd56286b31ecd74cdaf51f66b2b2331fa0e907e8cb9d4dde513ca29cc34ee9925301bb541055a8daef33bb3e1fb8442a4a033f93f86933bc35fd2ce34a569a6ef" + }, + { + "aggregation_bits": "0xae44a59e9b57b7141da75dba9d385b795ba84317f41948621bf98a34f92168838b72a9678bc58de000cf466104613975fb1490c591f0ee9055cce4aaa2ff0eb5a26c8b9e20b6a386d9e9f7964a3ebb957e3c6b0124271c279496235101a29fbf18ac7be6749a8b1f230bb5131e97b28c06683ca9a6cb6129b2a25b4f539f7f5e41cc1997c5b4a57d51dbce5ad4ab746a403e5270c785b76d47475c0ee6c309e33dad08193c3f8e40e9414096276bfb5708c84359dd51eb54ca67dd7a6eb5645801fb83811b4c11eb5b240e9d0bc0847ae7abfa235c7d6cc5f7eca53bce62b1b987b7c11ef54592399882d7983eb3c6a58ff636f52b4007afbc0d66bfe9d9276a01", + "data": { + "slot": "4532822644040406441", + "index": "4537780097985426121", + "beacon_block_root": "0x0890f33e697e213e331430adc059611ed0518d6fa4b4ecd0384dc2678e76fb32", + "source": { + "epoch": "527112883", + "root": "0x7a56d03e29445ddbf2a59bb1b68edcecf66387dbea68e12d4a545719acbb4773" + }, + "target": { + "epoch": "527497632", + "root": "0x5414dc3ee9ac9e510720cd5a0e7db352e95d89b77dd78fb9ef51d088f8f9d85d" + } + }, + "signature": "0xa3f0d1902ab93bc710c2af70da7699b79480ee062fc8add2cc1c6ddce56d54706ef91f581ec0f94cee95fc4be146005f174e2e77733d71ef59e53a12eb852e09e4334af2c27120e506ebab9c04e2b2f99045d40bd1372618173cf6df4ad21f86" + }, + { + "aggregation_bits": "0xe2e8a45105213f0f211443b26e3a23df7f899eb9b3ddd40b5f51905f90441f98eaa0d2b9ed7dddf5b4089188c41388cb5702236640399f914245bc085459f40d628a99fd663a4429e9b46e61dc8beb6ae3757aaeffc6db49c374cc93d1e663989d84fa7b4aa499a8b5d34ec5fea94bcdb33af829c6260d2a88a6be97e89baa6215949a4ef124436f685d4ee683c0c27f0ac7aefd77f4b305842d1cf2d08d9b7f4e501a38b81014fcbcec2156d5abbd1010afe4a596164e4659c6dd794639199119b4a3f2ec4f3b4d6a084bdedf66dfdcc1be1c522d9bf72663b7cc1a8746c3737e20ef7ee1b7863f89ab600a35772b4eede0424b8b69bcd27a6b354252a0147701", + "data": { + "slot": "4575787224854062954", + "index": "4567524808770642314", + "beacon_block_root": "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "source": { + "epoch": "532114619", + "root": "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c" + }, + "target": { + "epoch": "530960372", + "root": "0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c" + } + }, + "signature": "0x8166b2ed13e982e6b9f05d30f42681b826099135a533d2614ef5f4f59811714245db0e1821a644859559f97ec1e614bf08b2edb294fa2edc1527f46596399534af23c98613e1b74c01871bf1dd2af9618bc0ba23ddfce8026b897cdbba8c1bce" + } + ], + "deposits": [ + { + "proof": [ + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587" + ], + "data": { + "pubkey": "0x83b9036200e9e907c86ede7f98b23297389e8af19d403466e00f1946867db735d8620019e28aa42739f49c65b78a2806", + "withdrawal_credentials": "0x49452e3f298a688d9e7627fb7c01941b923397bb84dd548b6e411f9506aed1c7", + "amount": "32000000000", + "signature": "0x86e6ad7c26352727d310e10f7c745a0725636f63013f70c5a442489946dcd1c85665cd3539fe9d8fe6f6b49b5b7f13a50af2a2b98a7d385417c98e5d74273e67cc3bd8f8544dc3697124c8176835745659182eab37f3ebe0a881ff4e7f62bc31" + } + } + ], + "voluntary_exits": [ + { + "message": { + "epoch": "4555957421958886121", + "validator_index": "4557609905175570249" + }, + "signature": "0xaacffaf60c8253477ecad70de8589f2ef7670d0b0dc446d4baac3b465a901d3e64bb6d2c3d8bdb58aed45ac30466261416d152d5ae242204201bf6decfddde697ae0c5d44cf31ca3d43aa18f2799461fc1ee14dbf905b1e31f242fd31c083c5a" + } + ], + "sync_aggregate": { + "sync_committee_bits": "0x01000000", + "sync_committee_signature": "0x86e947b46923b26125a7dab3240481ddc1b910c1e6393b90df6e2de3809b8b35e450dc8264ecedd8f6bfc736e7114d841428b2469441d2d1d501015eb99e0d7090f11a1185b566dc42f94b79d0a08b22718a39b57e912a304419361108434ec8" + }, + "execution_payload_header": { + "parent_hash": "0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874", + "fee_recipient": "0x0c0d553e4878ae811024144112c88bbf79a372d5", + "state_root": "0x1f2e4f3ee8c38dc605677b6ce650a08c7fa6716795a8622d396e244f710e0a5f", + "receipts_root": "0x7ed3313e083eea1ecfb57f4508fd068e9fb56c4125942ed01ef47538b5f29e14", + "logs_bloom": "0x91f42b3ea889c963c4f8e670db851b5ba5b86bd3dc5c578a4c75b9008f53569fed0e82445821ecdf1e306d211dc4b3e042d5813f11ce16132211c523a92d723ffdaaf2175eaa77a1937f2e9f27b5e5b0f1bd3b77dbc94c7215fa1065d6066ea59bf2b95b8fe2ef820d9cf6a10c93f04f98db135751e1d8972d2427113953334f5634914e66e00af04d50d4de255bb0540ed3627a6f64073f81a28f777cba3a4ff145230e8103befc67e3ae2e8c72518ea18fa75495daac19c0f5c5094c84853de2b6ba4e2275c8a941cfb1a29f5a24ba911dd636080b0859abaa198dda14a860d4d29306b038ddd219c708ed837583079254b70c7095ac70984894735b79f7f9", + "prev_randao": "0x58913d3ec8a62b95e52fb1ee60ebddf392af6e1db902dd5bc3f1eea7003130ff", + "block_number": "4483248126065046120", + "gas_limit": "4474985709981625479", + "gas_used": "4473333226764941351", + "timestamp": "4478290672120026440", + "extra_data": "0xb736203ee72088edaf7eb5c7839744f5b1be69f748eea8fea77740914415c5b4", + "base_fee_per_gas": "81744492456258793280520536666094060462558404863190111969507816784424614128915", + "block_hash": "0xc7dab83ea972daeec7b1385f04b22e210f708323c38b84160159653a163f259e", + "transactions_root": "0x8e77ca3ec98f3c20e7e802dd8917f1b9fc66866da0310ae878d59ae1871cfffd", + "withdrawals_root": "0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9", + "blob_gas_used": "4522907744740301673", + "excess_blob_gas": "4514645320066946440" + }, + "bls_to_execution_changes": [ + { + "message": { + "validator_index": "2804390", + "from_bls_pubkey": "0x912c280adf321fbdcd522490a5431a7c2e0e716841b1a3819edf322fd46ab90681663c156f382055a914732e156d85dd", + "to_execution_address": "0x26809b3ec8ec364791003d38265e95222e7f7efd" + }, + "signature": "0xa969744aa463b0294e265f1fa92f9c9ef277afeb7ed667017e0a914bc57382d94c52f4411a135094e52636b63942e86e184ce0dd10e22ec86abbabe23396063fa873ecfc0ee3e16a5535f6422cf3f134e4d2de39464f038dd9521bb9d9a1ec80" + }, + { + "message": { + "validator_index": "2419641", + "from_bls_pubkey": "0x98192fd09a845d194a35781b711d801c9ce08060445a81cdb38d45bfb82c776d0e9b6083eedc0a106c9c922ee3bc906c", + "to_execution_address": "0x2fda834311b58db49107ebef3efd6ab3f5f751f2" + }, + "signature": "0xa864cf37cc41e0ea0c8cd4ae1d6d0bb833ddc583b3e389808da50acd9a3c49c59a2d4b038446feece5a6083d251e45530622aa80cc6bb57d7df907a39e1fa40885ab29ce25f3788860dab9a97050a48079c20176d6bd7e11720790679ade7638" + }, + { + "message": { + "validator_index": "1587773", + "from_bls_pubkey": "0xa5234d7dc8fe8544bcad85f8ca6548172425616038825239877450fa6144ba23923065a1c3d3a8fbd687ac593e11b4d9", + "to_execution_address": "0x551c7843514c4c3e7c8db946e50e944d01fe4f16" + }, + "signature": "0x92ddc8deeee37b1eeb83436e230c4dbfbda6a26fcd4b046c7556fba6391650f7824e0355adfbd38b0ee232030feca3780dcb2990998184ec505207f3d4123bdc38ea5a8de44474bbec65e619b8a853670fd3ae4a08a50ca1c3bd2c81739b92a1" + }, + { + "message": { + "validator_index": "1203025", + "from_bls_pubkey": "0xaf01ad2d54129b76339febd98494d79dc8dbace659dbeb3aeae85f9a2a94b23da0170f08f5233cdb136991686441e54c", + "to_execution_address": "0x14673d43914005ef102bc2f829676150401c46ca" + }, + "signature": "0xa34f07f9c38b8cf4781d0d1bc1d204860500aaa70a1ec6b1ca9a73d3fdbaace7c56c6bd9edc5eaf5898324494060496c016d716d51dec591c1854e84470529bd98a6fecdd74d012c8d8b677f32bd2febf0677c238361bcaa39e32056dafcaf67" + }, + { + "message": { + "validator_index": "2435262", + "from_bls_pubkey": "0xb508746a00c15709b84343dbc90c7033f121615b7ac2ebbb356adc69bc7dfdf1cc1607b1f5e577476b02a89043b0a6fb", + "to_execution_address": "0xd786ed43d263dadc5352a8e25d5ef94784c163ae" + }, + "signature": "0x92806dee8cfa7784e16b97ea6b32613fe6c41bbb7d0f03838a6dbebc90961bffb9f67ae8046ac1b3fc19e477d76e26ac0d5e613a0c87ff18649a50d75a8b09f8d72f0f056aa0078eb99c68f00b08535e242cd0db5639223f9c3adb71183bd0bb" + }, + { + "message": { + "validator_index": "2050514", + "from_bls_pubkey": "0x802775e14fda679e4594ca8ccda68a706957fe82c10e66d258eafd21fe5b2877c226092004f82874fb4022d73b74eea6", + "to_execution_address": "0x96d1b2431158938de8efb094a1b6c64ac3df5962" + }, + "signature": "0xa2695a1a43803793a6a1e80b15798147d8a63da5c8a6ee3e18dabd190255f48cbe36c33e3ffa372e11b19605cd2282a3136a2662cd3c8f9d3d0345ec1593b4241a0ee66c0d626da3db5cc6bd7d1119063922633c1c2987d69839af6ac37eb675" + }, + { + "message": { + "validator_index": "126769", + "from_bls_pubkey": "0xa1b20c565a67fc79e0dc4d8a335d9d3c7cba0865cec80a8f7f49bf610e20ab39afac693fe60778de840444b3ead514a2", + "to_execution_address": "0xbc13a74351ef5117d2757feb48c8efe4cfe55786" + }, + "signature": "0x9113b44632e0dac2168c83f2be8634d2eabe9b81ab5d426c31ffc119f3fc577c16edb82f50b13be7174eca9adbc2dc560f1ad4bd15a414e44a5ce7b330e8645f58cb50204f6e4ab4bd7c9315b355c97a5862e05f5140c61bd1a4de061855f0db" + }, + { + "message": { + "validator_index": "2586038", + "from_bls_pubkey": "0x83b8e297b2e5b17d8b30acc4586741cbe2f1f9de15b53add4e41cf23fd6f9034de02c5159eb4212e575a3255d681220b", + "to_execution_address": "0xdf80b0429057f4630e72700a013b4e8ad6642e7a" + }, + "signature": "0x8ac01bb60be2b4f4ae1847cdd5f95d3af16fd4cff3fa9d0da17d72f31a2cce4251e51907a63cb8ab9842a784cda7c40e0a93c536c8321a8abd889e3ed438d8653b77d0d06d3fc61f38b235f0e4c57c9dca562593216d94bfaf903d109eeb3e84" + }, + { + "message": { + "validator_index": "662293", + "from_bls_pubkey": "0xa9701b9f205890357cd0b75c121c25306bd409e007ad97323af8b41aa535a8227f82fa8537f8e1e9a89a216a53aeeab9", + "to_execution_address": "0x05c3a442cfeeb2edf8f73e61a84c7724e26a2c9e" + }, + "signature": "0xa3779a97b60b64b43f1249ac6e49af7a02d87608ccbcca01b26cb226baf3d0a135b6d98d008f4417e714a1512ce07fbb18c6e491fa2e6cad5e1d9e29f56aedb856073cfa6f90cc9b21db6b3ea9cb35f3c9ec47ad48996650941b4b8d5e6355b7" + }, + { + "message": { + "validator_index": "277544", + "from_bls_pubkey": "0xae86d94e3803aa062745028c91f9eaeb957af12e0d1e1c479c3ee78dfa76d792c8778507bbe0f1aded55e48d10b94a8f", + "to_execution_address": "0x61eb2543106f8202e5365fa6788ab38459284212" + }, + "signature": "0x831796f518dd44cbddc77db8d223ab502edc7bab53c2795edb3879e4f79171f13e4b7d5c5f354e06314c6c1fec3988f703234fb99488ef541062ef7f8a89f77bd18b82f79db2328ec0cd6db498f5ab4412800e9e4a351fad3d609a192b0eae61" + }, + { + "message": { + "validator_index": "1509782", + "from_bls_pubkey": "0x8c1cba560684965a1d17efcc10ac3e688808a44a655caef64fe19b0f11be06e324d48651b6d9663e33964737affaca25", + "to_execution_address": "0x872d1a435006418cd0bc2dfd1f9cdc1e652e4036" + }, + "signature": "0x8b8974bfbed37e66501f80a64e0d81d27723e76fb46afb5e94398a6b956254aabd7e9af026d996dee341f804951284140ba20654abb8af117f23f4afa0144a7ea57076a4a0fbc727d1f1111edf829a8cdca542799d24a5021c103ba2a23c75de" + }, + { + "message": { + "validator_index": "1125033", + "from_bls_pubkey": "0xa127dd51be074dce1f11b15a9040d935aae14a0b073a7ab906edc1327f477e8213d96f738690b3f650a479dac373cbed", + "to_execution_address": "0x4678df4290faf93c645a36af63f4a921a44c36ea" + }, + "signature": "0x8657c885c3361cd4a58769798bf4baa0424238c9a2c5b20b79b6079ca67198cfdbc407cb9e4799663bc54543f1a74df8044006e589cfb7b5914cf77fb175cfb959b29861d42c3da17eb66102ad8afc8f20fb5e7f52934c385018e3db3bed9181" + }, + { + "message": { + "validator_index": "2045306", + "from_bls_pubkey": "0xa67a1e9a2522bca1507faa25403c3ba020af65ffe839656e87f957438ceec07d5d8a91658e9fe6efe8703f1b5d24ffe3", + "to_execution_address": "0xcfdc1742cf05a262f63eed727f20645e78b3144e" + }, + "signature": "0x8dc84218c00f49ed40442f962e7afeb1a8c2ef5f4ed0aa8eda187ace69d22cd62b759e44754a66edf611383434b0d7bb18ca3eace8402fdeaeb7a5ee16639ac7133defc018719cfdf5a771449cab814076545f41f6662202d42deda5857c93f2" + }, + { + "message": { + "validator_index": "1660558", + "from_bls_pubkey": "0xa2cd1e8619ea096ad3130c8f2dfa725c44cc8aa06de4f186d87ecaa92251bee9bc08ae465d6ea48b145a4f70f0729e42", + "to_execution_address": "0x8e27dd410efa5a138adcf524c3783161b7d10a02" + }, + "signature": "0x97f8c4c02c4241858c09d9f2926670619f01a2e88fe50b3f3456c7db24c1c470a30eb58790400f29abdb9a9db63e075315d7e7b359848e76d4c637247b6a2ae492bb237e4aad36764ebbc93a0836cc4962e51681e15f00dfa1429311b1140e4d" + }, + { + "message": { + "validator_index": "2736813", + "from_bls_pubkey": "0x96057456506ff35b37222395a6cf87fec4386244d7ee0ecadd11c96e8f7975a312b6826bd69e069eed2e88fbae21439d", + "to_execution_address": "0xb469d1414e91199d7562c47b6a8a5afbc3d70826" + }, + "signature": "0x8734759600f9bdcc5a05f0c70f90062f0d0056ed8af19e4777fe4d5b67267fb33d2617d4630fd75822d0f1b60c70650a17fe6d16ec4fe2d4fdd2fd3433c357470dd8276a069a5402372a83091f40217805da560122e3d9ba5a98034b21191439" + }, + { + "message": { + "validator_index": "2508047", + "from_bls_pubkey": "0xa22369476f4df72eaf9b15045c8986378cfe5dc68d31bffe0ba6095277b0e3320eefdff2756b96a81b49486a6f82d75f", + "to_execution_address": "0x109252428f11e9b162a1e4c03bc8965b3a951e9a" + }, + "signature": "0x81e23861cdfd31d1421bef1f77bbf68ca5579fd9d2790637fb395458e46477f9e53d0426e0b3d15ad7854fcd9206007e0ab75fe079579775fe8420250a31c2214c316f398e1bc319aa0c3130fa6d80902d7f68954aa3a7c663569aaa0d9731ca" + } + ], + "blob_kzg_commitments": [ + "0xfd705842efc5096d6c5e7d95673f828e34921f0839ab5831c29ebba04e78f7002799a7e34b2f67c27bedb9a981bcc315", + "0x5d163b420f4066c536ad816e89ebe88f53a11ae2c99624d4a7240d8a925c8cb61d3786bd2f14c967df66090765a3b695" + ] + } + } +} \ No newline at end of file diff --git a/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlindedBlockEIP7594.json b/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlindedBlockEIP7594.json deleted file mode 100644 index 70a921be52b..00000000000 --- a/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlindedBlockEIP7594.json +++ /dev/null @@ -1 +0,0 @@ -{"version":"eip7594","execution_payload_blinded":true,"execution_payload_value":"42104374537666016842731412608176468386512470599052556672967227278486679620790","consensus_block_value":"50756583220288449835724789919752990744036228048165053817930899246206127260481","data":{"slot":"1","proposer_index":"4666673844721362956","parent_root":"0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef","state_root":"0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e","body":{"randao_reveal":"0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71","eth1_data":{"deposit_root":"0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f","deposit_count":"4658411424342975020","block_hash":"0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379"},"graffiti":"0x0000000000000000000000000000000000000000000000000000000000000000","proposer_slashings":[{"signed_header_1":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b","state_root":"0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb","body_root":"0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486"},"signature":"0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483"},"signed_header_2":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6","state_root":"0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26","body_root":"0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1"},"signature":"0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1"}}],"attester_slashings":[{"attestation_1":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4580744678799082634","index":"4579092195582398506","beacon_block_root":"0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c","source":{"epoch":"533461240","root":"0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565"},"target":{"epoch":"538462976","root":"0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650"}},"signature":"0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc"},"attestation_2":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4620404293179370891","index":"4618751809962686763","beacon_block_root":"0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b","source":{"epoch":"538078227","root":"0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb"},"target":{"epoch":"536923980","root":"0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5"}},"signature":"0xa32991816eb9f297553b4732309a4cdba7b33287264611715b0ab3319bca19e581da6e2659912a4e0e94aafc01c488e30ffc96ed14e2a726b9d3c618405ee0bf54bf6ae7f2097465cb27ab8132ec24eb93d3c9159475304082f7f0e452b93b65"}}],"attestations":[{"aggregation_bits":"0xfa79cdb89d0d51c5cdd001b7425c6d726750a9d5f89ade6ed9890ce3a706140c399a5e10c90a819094b65322dac7501f7c75471e69d4567358d8ca75f7c1b3133ebecf006b369a1f36efc5f2b706d5922ff98c58a1825a53a864376658f816600cf021cea843d4396502bb9c74d1510afe26036f89f783b4f5c7bacb6649c46f217a6af835f312d6fa253d2bbc83c07993f4f10de2ed2d952689379dbe4f794c1a1055a6b364d68e038deec9667f576b3b9eca5fcadd6298f181e1edb876efc3d0975ae14ae9a0ad2f1836d4c3f1080a96d8ab7c43b34bb2eda895ff66be698b363cfa4be33da3ec94a1a7a90672fd12c4a59916bb937e78476e4f08e4f4031001","data":{"slot":"4605531939934246443","index":"4610489389584298827","beacon_block_root":"0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b","source":{"epoch":"529421377","root":"0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2"},"target":{"epoch":"529806126","root":"0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd"}},"signature":"0x8f8d16b39e14569aab1b712e5c19ed51afe3600a6b017e8ab432f43a02ee720a733c33ef087d2f3653a9701e8d8a836301655b9195c0373b775c88ba1368e5d55354a70a3096bd26dee29dddbe7a4820e2b1653e84122beacbc01af7d93e6bdc"},{"aggregation_bits":"0x4ac567b296efbf7cf3209e87096a7a1a50fd523400113f917f6584a5a306f06b2d8da9ae858d47ff2594010089838efe41f19a78d9aae27c2ffde26f278b8681db9d091eb72e7cab3e449dfccd46a270693e1f88f197324e57bfd45573315cf9fb60d770937b32f7c0c6ce1581ec51e6b60f71acfde304dc917f2e0aa7872038b7d9140d15f7927c23a0490a74c2b0aca2773fed9217067e4444f9ca93874e4ff8407111c3efdb138b97c6d4957b6a70ec1debb283e3d0eb1cfef068adcffbf057d20fdc339eae03f0fa2613abdde8158a7fc40c3cfd1117eb6f8c4ae21d6b2ab4b57ae9a8653a34451aee6418c0c3609dc937293f5f5b346a7ab1a0d144185101","data":{"slot":"4544390030852162633","index":"4542737547635478505","beacon_block_root":"0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd","source":{"epoch":"527690007","root":"0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8"},"target":{"epoch":"528074756","root":"0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8"}},"signature":"0x90309dd491ae6ed51917dc305a3d4ae68d0a0d4792c7eb59c193bd03605bd94e61cab37502de0ad3e6162bc02427bba80a798b3670d5de82a854094016cc298b265371345c0e3ac49fd44bbb9ba0d4fcea0c1a80cecb60e93921d907e8c48120"},{"aggregation_bits":"0xe8c9759f0840f980ae956b15fc383d992e7d4420d12ba5bf32f669f446ac6fa388e20e5ce96e9266dd98840179d2cde3cabd9a8bafab5dec9c2e89f7f78c989e690548603984803b80c82d7b76443194576a1ce49da5cfe56f56e83b745fb01b5f18ccc86d88f5a22d927e64ff0b8e880893abcddec45b268531c4a0697537dae643a24b1a36432f37d42962553bd39af71f37e0429b81470c11316aa39db074aa3f1df4124e7cb203debed60b885ffb9b27e46a1434e81bbd56566632d0729c0822ac415cbb67f25973667d88e58df9c2f058a0ae7f118c98cc448453b6fbe590363bd17ed62c2f808df61f2a9e593235eeb56db74b9dd15980189a5271468301","data":{"slot":"4529517677607038185","index":"4574134745932346122","beacon_block_root":"0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947","source":{"epoch":"532884117","root":"0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31"},"target":{"epoch":"531729870","root":"0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672"}},"signature":"0x8c40f51a99fce6ebb9a4db5e80d715fff319e7ae523e46afb5d03c000d427e23c7a39e77e2af53851706283c8ca91d680997cb459386fbdff52c4d0ecf498e173717a838a792b210bdffaf476538628584a133899bf30dd5ce7056463b8cd683"}],"deposits":[{"proof":["0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c"],"data":{"pubkey":"0xb1f8f6e731dbf6b4e3265fb857c7190adbfc7e6cc95ce2e8bda72be8b6ea3459f862310a2484c3b0ee33b30920f18c1d","withdrawal_credentials":"0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c","amount":"32000000000","signature":"0xb594382214f5bdd375de66c45e1c61a526c7b73fb166c72433bbd9c2a7ad6881244e61cc6427e0206a50b762a129d8830e8708c55761d61ce9e3b19c1bee13bc55daa13bdb07118efdbf57a588b8a64e6392d14f935e53b68933e3355b35acdb"}}],"voluntary_exits":[{"message":{"epoch":"4562567354825622634","validator_index":"4564219838042306762"},"signature":"0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e"}],"sync_aggregate":{"sync_committee_bits":"0x01000000","sync_committee_signature":"0x919ee45cc18456f6e85da6bc21c2e40f44f9a887932c73ea9ad354f88e56d4ec0a8c396ed143082c8e31d697b877a2a215d2966d91c7beb156bf7ab5777e210012f70dcd5f7657808a82cba51e194be994f917150ebdb9e5c57476f1edb47206"},"execution_payload_header":{"parent_hash":"0xf8eb5a3ea82ccf3c1be1ac153e3f77f273a07343291711b9de6b9dbebc4c9b49","fee_recipient":"0xbf886c3ec849316e3b187793c3a4398b6097768d","state_root":"0xd2a9663e689510b3305bdebe972d4e58669a751fbc85bf448269162e078b2c34","receipts_root":"0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9","logs_bloom":"0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d078748f9069c96e9d6a2801cf607000a52447e46e1bef4e056ee30d4bd3517aaf7bf65ba04dd28c3a4a14b8dc72a300f051722a6814fa3931d90a82d23285d4c1127b6c67bbc4f8682ddbf9b31eb3114c26dccc5330109d6f17799339c2d7ed7e4e3a7de5d515106aaec7be6d78be3e21806d6d30c39b77c75dcf354b63033fb200b3b9dc023d948278f0956c0ee99323da0162f2a84b6a95749d2fa1d4e089af416d412ccd992683f7e41f7b496ca04f9f463806e3643d1c07f39d2a65f84e97b7dfaafac740d1e03f30923a4270fcf651ad2ca3737859a524e86e02229a55abd1a7","prev_randao":"0x0c0d553e4878ae811024144112c88bbf79a372d5dfdf39730cede08696ad52d4","block_number":"4489858063226749928","gas_limit":"4481595642848361992","gas_used":"4479943159631677864","timestamp":"4484900609281730248","extra_data":"0x6bb2373e68f20adada72181a3474f2c098b26daf6fcb0516f0723270da91e789","base_fee_per_gas":"91973405088222260025272995045243630915786868313949746451634391325697029602367","block_hash":"0xde78143e27b846779904841e2aa96d8fbec4671bb57ffa72037ac721f8d633ca","transactions_root":"0xa415263e48d5a8a8ba3b4e9caf0e3028abbb6a65922580447af6fcc869b40d2a","withdrawals_root":"0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be","blob_gas_used":"4476638188903342311","excess_blob_gas":"4521255257228650249"},"bls_to_execution_changes":[{"message":{"validator_index":"573888","from_bls_pubkey":"0xb8343e90edaecc9df1223293465ec067b3c9804f43e25817d27f1f4785bc5f554462032370781d9c65ab27bcc3d21415","to_execution_address":"0xdafbb23e48beb933bcf49f8ad83a43ee157382b5"},"signature":"0xa519e1354ad927358404a58bdc19113e5fd97d5cc19943888e22105ee943ca216a14898283fc3712500ba767de00022905e4198939b44a5f5a43fa0c87252969c56a26345135572101b257f87245a5e42fb2407a0ee67a6c2d039bf908b9aa8b"},{"message":{"validator_index":"189139","from_bls_pubkey":"0xa9ddce0cab5b51d3d2c710396b85e3fd7a87f1738fb5cfd5a7b25dbb483c167a80e785cb4ca7250c14a60cc282b1d9b8","to_execution_address":"0x9946783e88b272e45092a83c1c9310f154917869"},"signature":"0x8edfb3b9ed80067d0626019a1be330bac43c7ecd813f7ce781d0e6e34fb583803e9d2b047ad3294d6d3a54d020c68231085f7d9085d0afefb047def063a4698277e66d4a560f4b5bbd16586976f0bcf90177c00abd4a1b4cbd0ac393e5b904b5"},{"message":{"validator_index":"2357271","from_bls_pubkey":"0xa287d120292890ab1aa49bae1e3cd88bb160b5640f18c64f1aabae5990616e53099fe61698c3b812e2bc2ae6b6965960","to_execution_address":"0x09988f43d11dcf2aa7811c9997eb4119e8f153ce"},"signature":"0x8ca190827c66ff26c1fa594eae169b7efbd84c9456304f2194df7b0c204b0a29ac53034c9b20e4977b8e8b46d6b246da03a9337d3bf5e6f7ac941407a2a3437d7e2c0dcacda29b7623141833e02b4b12350ccaf8b27dbf96b3c520078f49efe2"},{"message":{"validator_index":"1972522","from_bls_pubkey":"0x8db8ee645b614f990839e4d98fdbf921263bb62cd917fb4eff9084dff23d7cc453f6cc645ad8b869aa9d31a6b9560630","to_execution_address":"0xc8e25443111288db3b1f254bdb430f1c27104a82"},"signature":"0xb0c3172e9bab8d04faa5d27f9818c36ad61a71b114f5bd9dbe77306be3edef2bcb56c215511ba76145006daec95f24be0f1f0dd24377cf7b440b5cdc7d0b520d6b64c539eaacaf14875d49c293af5974751bb0ce2daafde3bd01e097a466e75f"},{"message":{"validator_index":"48778","from_bls_pubkey":"0x8ba697cdd6f8c34a1fb96a4c88f03360d19515ccc4e1ea24aa5e80075d821059806a0047e6bbf5d908d312d1902aff5d","to_execution_address":"0xee24494351a9466526a5f3a1825538b6331648a6"},"signature":"0x87fadfd11bc5612e06c59d576c91599bc21095531fcc27a177967de7b521c377ee7a2b10d0fadf38779089929cfe136518757803c369b4ce94873e28d7d9cdf54c31a53ed86b07f76ea6104ee65d76de02267a4b736c949785ef233cbb73ad4a"},{"message":{"validator_index":"2820011","from_bls_pubkey":"0xa32a5f28ae7d36f888820160335232fc42ef994b4f93acf6a8659762b2ec52ca79354cc07c73a229b529bfcebc705eff","to_execution_address":"0x4a4dca439229167a13e413e752937416aad35d1a"},"signature":"0xa2089742415bdf32fa2dde853661a095ac24d273413687ae04fabb99ae2982700bcdb885d239e32543ffb95763a43e690cb1bf3a33df40d24e12c46d150e9c59dd63f960dec39712dabf74c08a55ba1bcb6db664ff9d5b2261da353e4374466c"},{"message":{"validator_index":"896267","from_bls_pubkey":"0xb679b4b686530827b2a201eb2b18454e9a5758d7257737b29bb215b9f354c2ff57e912b19d4a051556187aa24c97371b","to_execution_address":"0x708fbe43d1c0d403fd69e23dfaa49db0b6d95b3e"},"signature":"0x8da9cee45a3046b209da332512a6b4e4d7c89768f55998eb79ee236b4fb1fbcea87e0bba7b05d19ea7b8c5ea6dc0081e17a7ad0ec41566a0c6d9e127b87691e1d5b823fd178069e3f30091dcdbb44c36408656941755177c45bc976bf270289d"},{"message":{"validator_index":"511518","from_bls_pubkey":"0x83b8c61b63de768821cbd82ee3c67c81bb848163d6af0186ffe1ca3936d283bb4cab886f3fbc7f6336fec3da8d542c76","to_execution_address":"0x92fcc742102977503966d35cb217fc55bd583232"},"signature":"0x8c90298abaed4b5124cff46e41c9a4ed2b2baa0d2089add6b64c70dc7547f1a83bed76aba1fac6d36605beea72734b490b7b98994c7c65fdb436286b0df898731f6ad536e5a603da85ec8cc4488b94dc8c61e11363d1cc18733382dca51c7008"},{"message":{"validator_index":"1431791","from_bls_pubkey":"0xa532ee397fdd9e388888d90f712e13b085ad5043402debe1caf3dabbb514ed0d06f7c897e4e2795fd018cd672bfa8948","to_execution_address":"0xb83ebc4250c035da23eca1b3592925f0c95e3056"},"signature":"0x8fb8cb9373db269dd2a05fe0a07484db022a95b06c03807426a352499fcb65c55f8c388fd4cddbdd9936d5fe5ac5898e0d8b58ae09a73bdc7e584fe9940d3aa967607a0c4a1ad1ce5ccc0ad83f63a273e140ae0510f709cd0c214b645d68e3f4"},{"message":{"validator_index":"1047042","from_bls_pubkey":"0xb7d85608c3cf919ee72c0481283b468c2825850f6f6028c000cb19bff464556973909667d0353582d673e1049795f20c","to_execution_address":"0x778981428fb4ee8ab889aa659e81f2f2087d260a"},"signature":"0xa1079cff71763f60894927a0ac68cfff88642e5ec4e11d1f63ce7d7b15f2567842c80c0238a0f6e4d38ac2a9d09787c50c87daba460e05a0336332f1d37b65fed7526c5eb51a84d3a0169d09ddaf271d13710d22469e8dffde8859d50a2dd0a1"},{"message":{"validator_index":"2279280","from_bls_pubkey":"0xa46cb4c6f51759dd36e897cf8f5f8a774dbb5968defec8bcd85b9ec0f3d873a6569fabde6c6cf3fa5dc77e910bc39938","to_execution_address":"0x3aa93143d0d7c378fbb0904fd1788aea4c2244ee"},"signature":"0x988ea703ce8fcbd5bc7811c49e1eede7061ce461966a9a52f03afdecb157f065a1993fd71ea29c6769121610fc9e3e190eff938fb8c2f77dcf5f511208ad23cf427c05dd207b6c6004ba2a1ee3b6a84949e39db4ef1ee254635d3527010f7794"},{"message":{"validator_index":"1894531","from_bls_pubkey":"0xa18343c3306dae4ff3c78428069a4ae7876f0ad620219648b99b4bfaeea1d7898df50d508533e756f5903efbdf585076","to_execution_address":"0xf9f3f64210cc7c298f4e990115d157ed8b403aa2"},"signature":"0xa120e4f3144799db31e7487d25cbe6d8724f0076f23fdd7ff1f00b24b304a93a97862a3ebecb5e1b91018a0496a3c4020004b5d49571f4b9a3faf0f9d8f1f067d7005b5600db18872732313acf1350e1bec278384f3e0fe28d43f00203ae10e7"},{"message":{"validator_index":"2970787","from_bls_pubkey":"0xb23734206f673528ad12bad1b7815a9db722d7a5afffdfac97e17d453fcd2616a804619bd9f8db50b9547a357b1f5813","to_execution_address":"0x2036eb4250633bb379d46758bce28087974638c6"},"signature":"0x8de01f498b48fd1df0c20529228b7e8616c7bfc35457d392404110e394db4c884dad325363be1f2a83ac383486cdea460e78e89a728ac9464f71dfbc685ac8be3fb9ecb21d67a6c105354c58bfb78f2adf7ee65f5a4d7fbe5989e522b52daccf"},{"message":{"validator_index":"2430055","from_bls_pubkey":"0xb490d2df5759bb5115690df9aa805cddc1787b17fc3984ec400d03ccd5c6da6dbc54a724816ccf0c86b4b23e4daf0b17","to_execution_address":"0x42a3f4418ecbddffb5d058777555df2c9ec50eba"},"signature":"0x909ac7032213a33af76294ec19617f3fd9859bb22201e0502ae7187debe740c5cb0367ef03e944eab7fdc5ab23d303f916904a1ca5f7aadbcfbab89bdd82931dd7ff3e0efdd1135698f54774989ddd6d8ee07bebff863718c927072564a547bb"},{"message":{"validator_index":"506311","from_bls_pubkey":"0xa2810855686190fded08fbafafc427d3540a58c2b391c0d05a71be7a4d1aff2b4ea501c8e4c1ebb79cb49f1991ada976","to_execution_address":"0x68e5e841ce629c89a05627ce1c6708c7aacb0cde"},"signature":"0xa108770fd60463dfc982d8725440e47c54730329420bcf05a969e4937d06e468385b53c4a5f6c69e55a775f358fa0948171dedf3bb0ccc1679280251b7abe4cc644e10b46bcdaddd590951541bda68373c8a8dcbfb86d3cb97822a5dfc21f481"},{"message":{"validator_index":"121562","from_bls_pubkey":"0x8deafeba9f0184ffa1f3d1422b9d97d6975fc4d5a21df265b48b6e831d6aee5a6236b3d5fb9e03cab1e0795f3dd45206","to_execution_address":"0xc40d6a420fe36b9e8d954713eca4442721892252"},"signature":"0xb489851f8a8fd535ee14505b9ae32ab27cd8d5e637236f491f71bfc987316491ef3f1b7670378875580eb247993d82511128502ea093d108730e070bb8c5919b39e78893139b3f1a499e885b15d385073e227d6a4e85ba0413ab9e2481d0b8da"}],"blob_kzg_commitments":["0xb1ec6f426f978c599752e0e7181c305a1b8623c06088b5480b9aad7fe5f419d6c81a8f6862abe50a5e8cadf8649d347c","0x109252428f11e9b162a1e4c03bc8965b3a951e9aef7381ebf01fff6828d9ae8bbeb86d42469047b0c205fd55488427fc","0x23b34c422f5dc8f657e44bec0e51ab2840981d2ca63caaa51da14231033a661656d833a140f1279e0a1e40020f4c8be2","0xea4f5e424f7a2a28771b166a93b66dc12d8f207683e22f77941d78d8741740768f79e18451ce86d434d576fdbaf45f2f","0xfd705842efc5096d6c5e7d95673f828e34921f0839ab5831c29ebba04e78f7002799a7e34b2f67c27bedb9a981bcc315","0x5d163b420f4066c536ad816e89ebe88f53a11ae2c99624d4a7240d8a925c8cb61d3786bd2f14c967df66090765a3b695"]}}} \ No newline at end of file diff --git a/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlindedBlockELECTRA.json b/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlindedBlockELECTRA.json new file mode 100644 index 00000000000..3224d4c64ab --- /dev/null +++ b/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlindedBlockELECTRA.json @@ -0,0 +1,391 @@ +{ + "version": "electra", + "execution_payload_blinded": true, + "execution_payload_value": "52335047088093692175629908587741169571103578927521980677976976500308305025762", + "consensus_block_value": "60987255743756591490802410911397502078420277537860810465656654307850393571949", + "data": { + "slot": "1", + "proposer_index": "4666673844721362956", + "parent_root": "0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef", + "state_root": "0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e", + "body": { + "randao_reveal": "0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71", + "eth1_data": { + "deposit_root": "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f", + "deposit_count": "4658411424342975020", + "block_hash": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + }, + "graffiti": "0x0000000000000000000000000000000000000000000000000000000000000000", + "proposer_slashings": [ + { + "signed_header_1": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b", + "state_root": "0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb", + "body_root": "0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486" + }, + "signature": "0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483" + }, + "signed_header_2": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6", + "state_root": "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "body_root": "0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1" + }, + "signature": "0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1" + } + } + ], + "attester_slashings": [ + { + "attestation_1": { + "attesting_indices": [ + "4590659586689121994", + "4589007099177470570", + "4580744678799082634" + ], + "data": { + "slot": "4579092195582398506", + "index": "4584049649527418186", + "beacon_block_root": "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06", + "source": { + "epoch": "538655350", + "root": "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0" + }, + "target": { + "epoch": "539040099", + "root": "0xda533c406bf3482d8e6e992e756be34172a8c47fc1cc0018350bfe98c946deda" + } + }, + "signature": "0x8bfc6e1a1c76bdafb4d491ce02a35effde6d7362eb32c03f119c47c12fb2b49e7656bbd4702ba02560fd7fe117f2c74e02142ce46176ebf269d5b34a48a65525e35db6cc446965e86e22e9d8adf5abe92315690b6de5f4591769487539fed52a" + }, + "attestation_2": { + "attesting_indices": [ + "4590659586689121994", + "4589007099177470570", + "4580744678799082634" + ], + "data": { + "slot": "4618751809962686763", + "index": "4623709263907706443", + "beacon_block_root": "0x27d82440eb21c640637a36dcc38e35768bb4c0c79aefa300ec0f0cba32cabb05", + "source": { + "epoch": "537116355", + "root": "0x999e0140abe701de220ca2e0b9c3b044b1c6ba33e0a3985dfe16a16b510f0846" + }, + "target": { + "epoch": "537501104", + "root": "0x735c0d406b5043543786d38912b287aaa4c0bc0f731247e9a3141adb9c4d9930" + } + }, + "signature": "0xb2213ef588828a7c18cdc781d0ed2516fd3e11de625f191aae7ae4be8b1ad2cc217728c65a500aedea276d345f09fd3212b009568a6549f5f40ead6d7ec4d0f3f329c00a1b4bca59068ee0555c94aec91bebc18365ca0b2d6692557b4b0c4267" + } + } + ], + "attestations": [ + { + "aggregation_bits": "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", + "data": { + "slot": "4608836906367614699", + "index": "4547695001580498185", + "beacon_block_root": "0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2", + "source": { + "epoch": "529806126", + "root": "0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd" + }, + "target": { + "epoch": "528651879", + "root": "0xe24dff3e29e762b4488e615619483884c44b8f4b37239b5cdc4a3bd7d9b48c1d" + } + }, + "signature": "0x913ce44a60f20df0261b53d8031d13f3a8d51cf53ba5eb65735ae960623c48acd56286b31ecd74cdaf51f66b2b2331fa0e907e8cb9d4dde513ca29cc34ee9925301bb541055a8daef33bb3e1fb8442a4a033f93f86933bc35fd2ce34a569a6ef", + "committee_bits": "0x0c" + }, + { + "aggregation_bits": "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", + "data": { + "slot": "4537780097985426121", + "index": "4536127614768741993", + "beacon_block_root": "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8", + "source": { + "epoch": "526920509", + "root": "0x41f3e13e4961bf0c12dd652f3bf49e85e35a8a25c70e67ffc1d08cc01d9921d3" + }, + "target": { + "epoch": "527305258", + "root": "0x51977a3f0ab3110e2a10e9c6bd0e89b1410ca45142ac42171bb2b169efc281bc" + } + }, + "signature": "0xa17225b5e5319618e77f5b93350430acfadd8ae12a279f1a4176cc7ad1de7ecfc8670988519713fbac8f702cca29bddb14ff1463dae3abb53ddb0c025cd69c8cfb0f5298ab241c06ddb840c7a260f3dbd37120826b13b17e22d086148ebdbab1", + "committee_bits": "0x02" + }, + { + "aggregation_bits": "0xf8d3f62925333e71c92b5989e48786f9ea8582ce5679c63ca0dae6a3948750814066f18bdb3cc2fded5d81f2ed6c784e8c2e8c42fa6b0c3d1670b4069c78cd8594c1547facc8fdb19696b11475dc3dd1c7499aea330b9953f0ccc4fd30f3de2c71ea6c42d470865d80771c74e3110239efcf4108a58bb05efef3d73a2363dfa582352640000c12f848be2c6d52be43d4fa5cab16a2d0145bb687d29ec894d64b389bd2fc97a558570aa151b89194980ea7b2684b935b51e49b71f6cd0641fdb62abb914bfa03b7502414b5c792be5472d6be3c130e030f194fd234650e4f1f3f1ee6c722096fa58c3091e5119eebba839baab03347552015fe40ec788f2b52815cac78de375b46ce120ce3eab28e05810094a1a8b461829a28c89c55abd7e8a0d0a42c23e127da6bff2b17fb7bf6c7cf4c4d5cb2dfe9030c3d2b01dd8cfbc0a387f8309c9ca604eb42aa8105a78199bec145010ec3e8e7b7948a10105c1885561045a3c4449b516d2734d8764320e3670187797901ee459ba0c22bf44cb7975134eb59de969155812ca98fbd1a37ed645720a1fa76f565291b3bdde819dbc89fc2e7376b8945ff35bc69dee5e2f99d9568dccce8933b85f8ff52ee4134ff55d319814b6c4b9a89fd9471fd16e4f90cf6ebb3db3051cd0a08021eb8bf3b56698876d79ed5af7054d75a0e3affc78f84e041dad2045805d90764e34244a32620a2cec1c7983f541e1c7eef01f57f8dd4ce9efbb685910b0bb79cafb313cd33bbf03eafb006911d75e1da95c6a84b34ad6f2af08a27bfd27af4b355161362a3e9735175eed49de10158098dc86767aa7e64b77a9dc2b597ff61131d32acd2471af3140229c8b80831be7ff99724684ed7a348f28e55e9ab05cf80a96779c510ce6ed83da51d98f4baede14ab484100f343e5575e94765738b54768ed2e723cdfed7bec02d4eec688946a82bd59a6d21f7e52eb81edcecd680e217ae57ec734138832305149e67992faf46c0835d4befa0b29c48a2a651f289aa3f32417adcfdff9ac79e272abbe61321e11a3f28d6f34c929b5990c3543573bc8d4f8c28b9d350fe2b3a8490c3e5c66849baaee592d4adc83330b17ea4494aff7af5b793c94df8fd58b4ce2012d08a60146d7f7904d1607c989b791650cf34d91b4710a9a953a628098c96026eb949e0778407d0bb2d13f1162d4d99f8db17cfec40ff447434ba34dadc4f4172e1c5490afc529acf3c5fb2965836307bb0db66c1f50a6e8d6dfc874f7391f6dab98d37fb1380e3cec43a338f523b3e7337730fbad50f1dc399e6f61c47b93f65ff7d841308b2b82b2d72b744761e3c68202699e2848abd5b5e598ae8d0e8dc78418f5741239d79a62389e6a61802fe83998583ee089555cc1207b61b26dddcb2fdff3912a6d85ed4671bc71fef7e1260b8e11aae5c343796d5f64f01", + "data": { + "slot": "4565872325553958186", + "index": "4570829775204010570", + "beacon_block_root": "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", + "source": { + "epoch": "530960372", + "root": "0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c" + }, + "target": { + "epoch": "531345121", + "root": "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587" + } + }, + "signature": "0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e", + "committee_bits": "0x06" + } + ], + "deposits": [ + { + "proof": [ + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27" + ], + "data": { + "pubkey": "0xa56023832292eec3040299a0164c844769e854beba275c44e4960ab2da7ee11db36674e1e2fa2615bc5e247a2759a472", + "withdrawal_credentials": "0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be", + "amount": "32000000000", + "signature": "0xa9900942897c434e743c2b0210ec3266920ec6a624ed13b3637c640c7f79ba57a240a7e6a48cf587f71b9007616972821680ff0ca62c4cd47d50145bac76df28d9fbf3f56c98a5e8bd61b8cb41bdc02e3179ea961c2949c0803c108425dfa29d" + } + } + ], + "voluntary_exits": [ + { + "message": { + "epoch": "4498120483605137864", + "validator_index": "4493163029660118184" + }, + "signature": "0x86e947b46923b26125a7dab3240481ddc1b910c1e6393b90df6e2de3809b8b35e450dc8264ecedd8f6bfc736e7114d841428b2469441d2d1d501015eb99e0d7090f11a1185b566dc42f94b79d0a08b22718a39b57e912a304419361108434ec8" + } + ], + "sync_aggregate": { + "sync_committee_bits": "0x01000000", + "sync_committee_signature": "0xb2c1728d5efb4c0577aff84d84d5b0b2a89c22e1a97f2fb468442a8c2f84eb0912077b32ddd66ac5ce05168ab26168e40ddb8dadbed42b229c34e78cc757421908ab6159082952a43133f5333ad2f8382930bead6ab4f0e91c95ed9c66f634f1" + }, + "execution_payload_header": { + "parent_hash": "0x7ed3313e083eea1ecfb57f4508fd068e9fb56c4125942ed01ef47538b5f29e14", + "fee_recipient": "0x91f42b3ea889c963c4f8e670db851b5ba5b86bd3", + "state_root": "0x58913d3ec8a62b95e52fb1ee60ebddf392af6e1db902dd5bc3f1eea7003130ff", + "receipts_root": "0x6bb2373e68f20adada72181a3474f2c098b26daf6fcb0516f0723270da91e789", + "logs_bloom": "0xcb571a3e876c6732a4c11cf3562059c2b8c16889ffb6d1b8d5f883591e767c3fb46dd46047448da9f4783626721bdf9308a2cefba364d5b6b2653a014d0c2bf6f7722e4c3bbe594bb639fb9b0489d49f463e19d5547ce33fc497f70c977a3205fedaf8ccc0bdc1801c8a18154948c8e670813e0c98f6e92e20d4327c71f2de5e7aaf1df92739504e383a1977928614c2078d5a61289ac612f9e3b08ea9406604db94fb2a3424f245843ce722c6edaaf79085661b750ed7b62cf57a68de63b899dbde6c169f2a65bd5b0e808bdf22c850136f4c1421be8865b50aa17c03735c41f4b4ec5a973ad30c7db09d4a6894284b9f19eafb8189121738fda9d6e0d393f7", + "prev_randao": "0xde78143e27b846779904841e2aa96d8fbec4671bb57ffa72037ac721f8d633ca", + "block_number": "4478290672120026440", + "gas_limit": "4476638188903342311", + "gas_used": "4521255257228650249", + "timestamp": "4519602774011966121", + "extra_data": "0x8e77ca3ec98f3c20e7e802dd8917f1b9fc66866da0310ae878d59ae1871cfffd", + "base_fee_per_gas": "73092283800700793286468708950267523415056945357667839430375913972420161943176", + "block_hash": "0x003ea73e885578bda77a6ee17f4c6c88227980d9e6e5fe448bdc2f93a5614b3e", + "transactions_root": "0x135fa13e28a157029cbdd50c53d58055287c7f6b9dae27ffb95d735b7fc202c9", + "withdrawals_root": "0x1f2e4f3ee8c38dc605677b6ce650a08c7fa6716795a8622d396e244f710e0a5f", + "blob_gas_used": "4517950290795281992", + "excess_blob_gas": "4516297807578597864" + }, + "bls_to_execution_changes": [ + { + "message": { + "validator_index": "2996764", + "from_bls_pubkey": "0xa2cd8bc71b19dea2f97e5918a5ad8205b4937a07537f9d84206f15ad383c25e65249dbb53d559acb700bb4f59297896c", + "to_execution_address": "0xac67723e28fe512946d50f68f01b25be5a9477fb" + }, + "signature": "0x99f5bc997861976d73013dd4c06f42a2318912e5e075a2746840bb34134e7f4765ba88dec12f4bd5d2fa24d7bc2c17ce105bfb796108064499faaa4d4b3e17db6e62bc88f8e0a6243105b01c00302c3d9f81f5e790d6a6951532ac94c19d1114" + }, + { + "message": { + "validator_index": "2164897", + "from_bls_pubkey": "0xaa4811100ca7dc5c90d84205000ffd9d70eaa3c650ff0391ce7c3f5eed59f12e4ac5e080f4ee6e30354294ebca28c93d", + "to_execution_address": "0x1cb989437169ae6f9cc483c46a7456e6eff45260" + }, + "signature": "0x833c3424606fa52c035536e38b8c677a1b922a8d35cc38b55e6f057725893ff621d9f49153fcda3af9d7cde737ee0c830e3189e94a62a8d655c328f7b3c77142c53a3e9f6029e16d22ace761f8e60f4b28f2b487821be3272e1905598649f1a0" + }, + { + "message": { + "validator_index": "1780148", + "from_bls_pubkey": "0x98d6103215e3916a0cff3af6b6f29f22374a32d87d440a302e18a9e2daa80b32a2824798030f6a2e06ab612b07c41f74", + "to_execution_address": "0xdb034f43b15d672031628c76afcc23e92d134914" + }, + "signature": "0xa2f3dc0cbadf0807f2d864d0c98c2e474972419b1ef936d0c68976eb732a146c8bd86194e95381d1b9245530b1f138cc0de425bd6478bc56a394619e1192a114680c4e9f8b0278816bd4f5df9e24cc31ca73cf5eb26da54eebf958966d4a957f" + }, + { + "message": { + "validator_index": "2856403", + "from_bls_pubkey": "0xac60d2ec631e27b37f4f5541319b94c8cf82299d71ae4139039cbc1d0c30c71a075cb62166801ccd0a56f0bc29edcdae", + "to_execution_address": "0x01464343f1f425aa1be85acd56de4c833a194738" + }, + "signature": "0x818852c88a6e16f2294cb51803a155dcac4f6ec5ee0d095e8890be8907201ee1c8790abb6d5f05faa2b3d8d9a03972800a04fc1666d877c7cbfb62c387d6e119f8f827ea2ba94d5b6429b33d6f3770b79999da3cb8ed17f2c8977234bd2a1cdc" + }, + { + "message": { + "validator_index": "2627637", + "from_bls_pubkey": "0x92f00f85478ad1224c1be3a9b9230444411e9a2beeb6304e5c1fba1b7b54c9ecc3965abeb3385e4916040260544b2580", + "to_execution_address": "0x5d6ec4433175f5be08277b12261c89e3b0d65cac" + }, + "signature": "0x8b13ef837950d00a469eae427c1fea111ea85e0dfd63c09bdc02aec208523ec4c805595639d50e183dc893022f60abd8118d62c836b6d4de057967f80184532c1c3a25b26c51926a07e55d2ba264de6fd22eb0665668cc7280bbcdfdfdb3c0b6" + }, + { + "message": { + "validator_index": "703892", + "from_bls_pubkey": "0x8939b0ed4fd0659427739e525d6990c02614d703d12c5adaa5f8aeedf64fb9ce66e769d83f9ec61ec05c6074d5095955", + "to_execution_address": "0x83b0b843710cb448f2ac4969cd2db27dbddc5ad0" + }, + "signature": "0x8f65a298124021cf26323bea9328da795a7f2134f42c21e28617a1b663c568058fa3ddff9a71948362e7380cfb591ec9062f735067b1a32bd2b88e9c2d5c3404348a194098c30f55f8cc050b305bc4c2baeb2a6e4ab1d49833bd7ec4943367f0" + }, + { + "message": { + "validator_index": "319143", + "from_bls_pubkey": "0x8f5f289f8ae538eca9f393fd7ed1a5432ba4c145b700075d1a8ea9530ec8cba3b91511e78662d0f2bed026a1b86d6d2b", + "to_execution_address": "0xa51dc242b07456952ea93a8886a01023c35b31c4" + }, + "signature": "0xa23a1e6d9410ecb12fe95fbdb3b12962bd46855fa46ccd7b2fe75696cd4b1788302d6fc3bc1c1bc6f8080d0025b3fdc9139a3b141407213b8123563622773e9b385473bcd03f149b0ea21e52626382dba56b95a2204178c2c454001c79289afb" + }, + { + "message": { + "validator_index": "1239417", + "from_bls_pubkey": "0xace9988853ce03390f8d5c93fa51e3a5f5b056bef4ed1f437a86c59fb687be25d0e6f4be5beeec4bc04806e93c3eebf7", + "to_execution_address": "0xcb5fb642f00b151f192f09df2db239bdd0612fe8" + }, + "signature": "0xa0053dab17b7e0ba64416b1c95b6c56ecb7f39ccc272cd57a347054fab6781ab8d834eda1a4e57ac5b037d3b71945d1805216ba518aefad29922f57f1b3149151d4266ae944b579de5399a209e482a19d3fd7e9c02069e7a01ab2e9a59477326" + }, + { + "message": { + "validator_index": "854668", + "from_bls_pubkey": "0x85a2763ffc316d21106869ce72f88e6e5aa3ffcb84689aea186a7de5056f0fa98f50ce3bcfb8a96d33585c472748b014", + "to_execution_address": "0x8aaa7b422f00cecfadcc1191710a07c00e80259c" + }, + "signature": "0x84ff1208ba8c36a14bcf8c5d3c9d9e22dd6d69f7053eaba3ce96cf7ca324ec3c3a2bd097053788b7dc64d7dbccc30ebd07fbaf41e95ae397751f8aadbc4d84219038b55e1fb3785a8f7ceebe05d629ce2c9c407bb9be6c66c0d26c14b3a7c3c2" + }, + { + "message": { + "validator_index": "2086906", + "from_bls_pubkey": "0x8f220bb09673d250a17cdd562f33ca615e83e293a43e1313a9c3e9438c218cfa9a803426d29e9bffdd884daecf7e0ac6", + "to_execution_address": "0x4dca2b437023a3bdf0f3f77aa4019fb753254380" + }, + "signature": "0x81d6211b8ee9652820795832982520799ba2eab947083a2c6e56d9cdf1e678b1c1a6c8a108ece8b1c23b234a208e6e281477d55c41fc3d04027032277fa0922a0370e76db742037a0688697f618b8b7780cbfb3725f78bf9c5f94876d9d1957a" + }, + { + "message": { + "validator_index": "1702157", + "from_bls_pubkey": "0xb63a024e98bf28daf9bf8bdcb7c89d823f29e65e362a923afec6c78aef21559a12d2c5cdf81998630ac418034c0e58ed", + "to_execution_address": "0x0c15f142b0175c6e8491002de9596cba91433934" + }, + "signature": "0xa386f611424c8ec936f7ef72da9d526823e3bd03f3452131910b7c5ae646a989c276001faa9398ff3ce9050cc0282c5003ee9357b8485f4c52a4321e9c5150d39cebf18546badc0a22d7d881a08bfcd1e76c4a7c9c8cd7f85da5270877698c7a" + }, + { + "message": { + "validator_index": "2778412", + "from_bls_pubkey": "0x90961673ed2682e726960a035e0d1e050ff0754225f97fb7501110e474cee35f7ed1bdeb70eebc97a59abbd7217bc691", + "to_execution_address": "0x3357e542f0ae1af86f17cf83906b95549e493758" + }, + "signature": "0x9590d1d0c5216aeacaa19bb58a4a66a6430e554a0b020e2977be2421bcd089fb47bccbe10f2baac88dee33fc625dd5441217042918ac793c0aa2aba45a379decdb018b7bdd277f2a66b122a95aa1974cb05208e00801ed52f7f86b671c372e2f" + }, + { + "message": { + "validator_index": "2237681", + "from_bls_pubkey": "0xa63d491bd47a8f4caf987b7a22f228dc709f8f4a0d8ac25ed72a18cbe2b2da7662daafbe182b33c81e14eac70bc2f0d5", + "to_execution_address": "0x55c4ee412e17bd44aa13c0a248def3f9a4c80d4c" + }, + "signature": "0x8e4e43252f668d04559aa2ecf1ae7605a054c1fc2d5b0a9b77f9b091b8fd851ef5a02d54ed31a66053144d0319d8f4ac11185d05cd68099841cc554c99de314a291e83c4bd166b924240d4851d8ff63a05c62def40f8b839f087a60db6ef5172" + }, + { + "message": { + "validator_index": "313936", + "from_bls_pubkey": "0x856c75ede282fb092c2c5ce1511945d4eb5026a095e7ebb8ab6a231ef8884390141d100ecc904fdd58b1f2f0e07b1630", + "to_execution_address": "0x7b06e3416eae7bce95998ef9f0ef1c94b1ce0b70" + }, + "signature": "0xa31249a2500d0428a2b38100b6db1191f1014087af8e58cdc025e28fc9e2aa5f08c74036c1c99b5e6b9f96c250700e2505201e2d4657bff1de53e01ac3c28f2f6624da4e953c9d08b0011e547902197fc5317daa051526f68684f16e1608ff33" + }, + { + "message": { + "validator_index": "2929187", + "from_bls_pubkey": "0xaa842a4b0acf1250c953110bfa6025bc646043fc268749af5274dd0197f06eafd7f5ec00e2d21a01b8a420e8178bf74d", + "to_execution_address": "0xd72e6442af2e4be382d8ae3ec02d59f4278c21e4" + }, + "signature": "0xa29e82672b9b023ec4496bc5ba26cd0e12ae4e168591a2412dc2c62cfbf0466710810999921e34e7249e3a4700c837ec115bb6bee111a50c55a1af9d2f996bb6600a4767e23781cf4eb177845372b39df6156906f9e24c5b908920161a44d8fa" + }, + { + "message": { + "validator_index": "1161425", + "from_bls_pubkey": "0xaf50133072b8d7a0ab9318facb15087021cdde3205929004ecae6df99d4cc111517fb629146398eb345a028d413624ac", + "to_execution_address": "0xfd705842efc5096d6c5e7d95673f828e34921f08" + }, + "signature": "0xa34048285c5a03bac9edfcf306e845a8cc0f8e7f7b4c5590dce0146b30b5a4d6340855b4384b53cc72b4ac5bb9b372590a7f7eca40e78ef3ae9b0e9dfe020abc94d161627ff642df1386143f221aee8ba432f4e7affa7736c65a01e6f342cd4d" + } + ], + "blob_kzg_commitments": [ + "0x36d44642cfa8a73b4c27b317e2d9bff5469b1cbe5c05d35f4b2286f9dd9a1da1edf7f9ff3b52088c513683aed613efc8", + "0x49f540426ff48680416a1a43b562d4c24d9e1b5012cefb1979a3c9c1b8fbd42b8517c05e35b3e879984ec65a9ddb52af", + "0xa99a23428f6ee3d80bb91e1cd80e3bc46cad162aa2b9c7bc5e291babfcdf69e17bb59e3819984a1ffcc715b881c2452f" + ], + "execution_requests": { + "deposits": [ + { + "pubkey": "0x82265d267f8473b8b95581d5cff9b19c81ca410538259c96c7418ef433e3c0a89d8ce7f7b91dc0789ceddd7e5f8f1f45", + "withdrawal_credentials": "0x010000000000000000000000594150410d114a888823a4369a4c1e9b4d1af3b1", + "amount": "4704680975884967085", + "signature": "0xb710f44c80db8d91f996614df20b5e9293a578f28f55e4cd65f017063fa9e36eead8417ff871fda70f6f8238fa906376066788d928178215cf5b285a0630956453a2b53fd2ecdd614e247a7c89502de682385310134924ee896501d9a1a5265a", + "index": "4707985942318335341" + }, + { + "pubkey": "0xaacb0e7f3717c59e23c32cb07ce03be33c2bb8366da2d27a9954b77f2c9198a1b5f3aea585faffcdfa4800b592c4d5d8", + "withdrawal_credentials": "0x0100000000000000000000007f8344414da8081272a9728d415e47355920f1d5", + "amount": "4701376009451598829", + "signature": "0xa9bf2689fe47ca9ac1fb90da3b08259115adab480b4f387669f209ee7747f7451af8f61e4a9c057bc33ffc18f0b08c3407be0a59b8c61c741572f5d28e2a1f6af0fc17db7c3f48901c9267606c3d7831a3d3647b885946fc95fb5689d24f7b8d", + "index": "4691461101561559469" + } + ], + "withdrawals": [ + { + "source_address": "0x3ece09418d9cc1c206477b3f86b61438983ee789", + "validator_pubkey": "0xb7fbe0486f002e790bb3d674b4259c18c6bf66510576e381e128aee6c2de771d3d5c9dda65b4078b058b2667f30e1637", + "amount": "4689808622639842637" + } + ], + "consolidations": [ + { + "source_address": "0x3a51a841aea2347f293797ab3448ea96efec0124", + "source_pubkey": "0x88f8fa6c349ee56559e614799a5788c17fdcde24ea5922a7c7fe6bed8df5c0140aeebbb46d0cadc7a9107e98344194f1", + "target_pubkey": "0x97995c0a4cf28bb77bfea20753ecd1e3b3469492921c9542d99a1e81355f6d09ea4cbcb35e3b8f1240e8261d20da657b" + } + ] + } + } + } +} \ No newline at end of file diff --git a/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockALTAIR.json b/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockALTAIR.json index fd6245ccda5..812aa719ec4 100644 --- a/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockALTAIR.json +++ b/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockALTAIR.json @@ -1 +1,202 @@ -{"version":"altair","execution_payload_blinded":false,"execution_payload_value":"12345","consensus_block_value":"123000000000","data":{"slot":"1","proposer_index":"4666673844721362956","parent_root":"0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef","state_root":"0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e","body":{"randao_reveal":"0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71","eth1_data":{"deposit_root":"0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f","deposit_count":"4658411424342975020","block_hash":"0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379"},"graffiti":"0x0000000000000000000000000000000000000000000000000000000000000000","proposer_slashings":[{"signed_header_1":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b","state_root":"0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb","body_root":"0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486"},"signature":"0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483"},"signed_header_2":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6","state_root":"0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26","body_root":"0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1"},"signature":"0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1"}}],"attester_slashings":[{"attestation_1":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4580744678799082634","index":"4579092195582398506","beacon_block_root":"0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c","source":{"epoch":"533461240","root":"0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565"},"target":{"epoch":"538462976","root":"0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650"}},"signature":"0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc"},"attestation_2":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4620404293179370891","index":"4618751809962686763","beacon_block_root":"0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b","source":{"epoch":"538078227","root":"0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb"},"target":{"epoch":"536923980","root":"0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5"}},"signature":"0xa32991816eb9f297553b4732309a4cdba7b33287264611715b0ab3319bca19e581da6e2659912a4e0e94aafc01c488e30ffc96ed14e2a726b9d3c618405ee0bf54bf6ae7f2097465cb27ab8132ec24eb93d3c9159475304082f7f0e452b93b65"}}],"attestations":[{"aggregation_bits":"0xfa79cdb89d0d51c5cdd001b7425c6d726750a9d5f89ade6ed9890ce3a706140c399a5e10c90a819094b65322dac7501f7c75471e69d4567358d8ca75f7c1b3133ebecf006b369a1f36efc5f2b706d5922ff98c58a1825a53a864376658f816600cf021cea843d4396502bb9c74d1510afe26036f89f783b4f5c7bacb6649c46f217a6af835f312d6fa253d2bbc83c07993f4f10de2ed2d952689379dbe4f794c1a1055a6b364d68e038deec9667f576b3b9eca5fcadd6298f181e1edb876efc3d0975ae14ae9a0ad2f1836d4c3f1080a96d8ab7c43b34bb2eda895ff66be698b363cfa4be33da3ec94a1a7a90672fd12c4a59916bb937e78476e4f08e4f4031001","data":{"slot":"4605531939934246443","index":"4610489389584298827","beacon_block_root":"0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b","source":{"epoch":"529421377","root":"0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2"},"target":{"epoch":"529806126","root":"0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd"}},"signature":"0x8f8d16b39e14569aab1b712e5c19ed51afe3600a6b017e8ab432f43a02ee720a733c33ef087d2f3653a9701e8d8a836301655b9195c0373b775c88ba1368e5d55354a70a3096bd26dee29dddbe7a4820e2b1653e84122beacbc01af7d93e6bdc"},{"aggregation_bits":"0x4ac567b296efbf7cf3209e87096a7a1a50fd523400113f917f6584a5a306f06b2d8da9ae858d47ff2594010089838efe41f19a78d9aae27c2ffde26f278b8681db9d091eb72e7cab3e449dfccd46a270693e1f88f197324e57bfd45573315cf9fb60d770937b32f7c0c6ce1581ec51e6b60f71acfde304dc917f2e0aa7872038b7d9140d15f7927c23a0490a74c2b0aca2773fed9217067e4444f9ca93874e4ff8407111c3efdb138b97c6d4957b6a70ec1debb283e3d0eb1cfef068adcffbf057d20fdc339eae03f0fa2613abdde8158a7fc40c3cfd1117eb6f8c4ae21d6b2ab4b57ae9a8653a34451aee6418c0c3609dc937293f5f5b346a7ab1a0d144185101","data":{"slot":"4544390030852162633","index":"4542737547635478505","beacon_block_root":"0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd","source":{"epoch":"527690007","root":"0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8"},"target":{"epoch":"528074756","root":"0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8"}},"signature":"0x90309dd491ae6ed51917dc305a3d4ae68d0a0d4792c7eb59c193bd03605bd94e61cab37502de0ad3e6162bc02427bba80a798b3670d5de82a854094016cc298b265371345c0e3ac49fd44bbb9ba0d4fcea0c1a80cecb60e93921d907e8c48120"},{"aggregation_bits":"0xe8c9759f0840f980ae956b15fc383d992e7d4420d12ba5bf32f669f446ac6fa388e20e5ce96e9266dd98840179d2cde3cabd9a8bafab5dec9c2e89f7f78c989e690548603984803b80c82d7b76443194576a1ce49da5cfe56f56e83b745fb01b5f18ccc86d88f5a22d927e64ff0b8e880893abcddec45b268531c4a0697537dae643a24b1a36432f37d42962553bd39af71f37e0429b81470c11316aa39db074aa3f1df4124e7cb203debed60b885ffb9b27e46a1434e81bbd56566632d0729c0822ac415cbb67f25973667d88e58df9c2f058a0ae7f118c98cc448453b6fbe590363bd17ed62c2f808df61f2a9e593235eeb56db74b9dd15980189a5271468301","data":{"slot":"4529517677607038185","index":"4574134745932346122","beacon_block_root":"0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947","source":{"epoch":"532884117","root":"0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31"},"target":{"epoch":"531729870","root":"0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672"}},"signature":"0x8c40f51a99fce6ebb9a4db5e80d715fff319e7ae523e46afb5d03c000d427e23c7a39e77e2af53851706283c8ca91d680997cb459386fbdff52c4d0ecf498e173717a838a792b210bdffaf476538628584a133899bf30dd5ce7056463b8cd683"}],"deposits":[{"proof":["0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c"],"data":{"pubkey":"0xb1f8f6e731dbf6b4e3265fb857c7190adbfc7e6cc95ce2e8bda72be8b6ea3459f862310a2484c3b0ee33b30920f18c1d","withdrawal_credentials":"0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c","amount":"32000000000","signature":"0xb594382214f5bdd375de66c45e1c61a526c7b73fb166c72433bbd9c2a7ad6881244e61cc6427e0206a50b762a129d8830e8708c55761d61ce9e3b19c1bee13bc55daa13bdb07118efdbf57a588b8a64e6392d14f935e53b68933e3355b35acdb"}}],"voluntary_exits":[{"message":{"epoch":"4562567354825622634","validator_index":"4564219838042306762"},"signature":"0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e"}],"sync_aggregate":{"sync_committee_bits":"0x01000000","sync_committee_signature":"0x919ee45cc18456f6e85da6bc21c2e40f44f9a887932c73ea9ad354f88e56d4ec0a8c396ed143082c8e31d697b877a2a215d2966d91c7beb156bf7ab5777e210012f70dcd5f7657808a82cba51e194be994f917150ebdb9e5c57476f1edb47206"}}}} \ No newline at end of file +{ + "version": "altair", + "execution_payload_blinded": false, + "execution_payload_value": "12345", + "consensus_block_value": "123000000000", + "data": { + "slot": "1", + "proposer_index": "4666673844721362956", + "parent_root": "0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef", + "state_root": "0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e", + "body": { + "randao_reveal": "0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71", + "eth1_data": { + "deposit_root": "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f", + "deposit_count": "4658411424342975020", + "block_hash": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + }, + "graffiti": "0x0000000000000000000000000000000000000000000000000000000000000000", + "proposer_slashings": [ + { + "signed_header_1": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b", + "state_root": "0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb", + "body_root": "0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486" + }, + "signature": "0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483" + }, + "signed_header_2": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6", + "state_root": "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "body_root": "0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1" + }, + "signature": "0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1" + } + } + ], + "attester_slashings": [ + { + "attestation_1": { + "attesting_indices": [ + "4585702132744102314", + "4590659586689121994", + "4589007099177470570" + ], + "data": { + "slot": "1", + "index": "4580744678799082634", + "beacon_block_root": "0x17348c3f2ad0733f4b47b34442744b4a2e03a79b1f52c8e8922ee71060a05b1c", + "source": { + "epoch": "533653615", + "root": "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06" + }, + "target": { + "epoch": "538655350", + "root": "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0" + } + }, + "signature": "0xaffb36fe3e48b5c29794f85515b9a3adcd4206fec6dddac6926d0e985d96a9ade0e427f911d56dd90f2644af13e9740509147d149defa9b0763eecba616e0815e9a91c25178860be7d4196a9814781a4576ba7bc6398ef16b9bd5f88c4143bfb" + }, + "attestation_2": { + "attesting_indices": [ + "4585702132744102314", + "4590659586689121994", + "4589007099177470570" + ], + "data": { + "slot": "1", + "index": "4628666713557758827", + "beacon_block_root": "0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390", + "source": { + "epoch": "537693478", + "root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b" + }, + "target": { + "epoch": "538078227", + "root": "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb" + } + }, + "signature": "0xb7720f152c38d7172a82186892a68440bc4d285cc8aa92c1f017f93d5f61a29cf51670e4f944648bd8df82d4d6eae00615073d439389cdf35fbd7670a07ef8407c7c71a16be062fff16f351737ac99f006817ba43a295fe5286dfb4ba7116e07" + } + } + ], + "attestations": [ + { + "aggregation_bits": "0x88e3aeac2cb7509e753b73880be4e95da67b35193a1a8d916d3a5f3b61c59b6d90d866ae7ee81a10a9ea025ade39ad5b978bd20bd2d2031d61e8aa7b5090b08248dbcac0698c25ea7b858ae37e5347010aa764962e4f70513d9e2488a9808d0510dcb3dc9385cc9c28ba4a1eae314e5c3372b3d2387836dc0750553f84b1b490b7fffcb2824b614596050fa2ffed45b30b7db4e67cd782cf0446b5448ed43cb01991cde29c15b0a29dcafdbf29840045c4a3d7e58b93ff391e3ae281185e49aeeed12188548d0dc8e904edc1c8a9831577d08b0c708dbb1784cef981e8363efb46d26f039c2561792d1a2e81218eec593aefaa25bb280fbdd25f8103381a51c601", + "data": { + "slot": "1", + "index": "4615446843529318507", + "beacon_block_root": "0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6", + "source": { + "epoch": "536154483", + "root": "0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0" + }, + "target": { + "epoch": "536539231", + "root": "0x82a81c3f096d065c7e3f5d7df79bd182a53c9471a737cfb9f7c4e9ed95d0f767" + } + }, + "signature": "0xa9aef1e37252740dedc5fc9886810459f7484555aa59fb3876803fc4924149cb471ffbbd9be5324d952efafc3de4c5f705dd02134916b2afa02194fe90a8d1e8f58ebcfe0d33d0b8a97e71a3f7591cb82c37ba531c059a684b581d3857f05e3c" + }, + { + "aggregation_bits": "0x0aa2e4365aad4ec5115dbc42fc6bcda2a0739e4b8c6c07334b99338ec990c7dc93162171b1ed0afe8b1f151348438523b428076a646db8375993d417cd79f1854f796992a8aea702eb3180373e7ff4b4c53ef3b306a5af7f82ba3a4a362af88084e7d166dd0ed5026019cd4f2c4fad16566f927d0dceb14203e8abc293267466c487eb2b108ae043792ff8e8c56e9fbb26d98381ad35e70558cc74f74d1d5a7de764645e15298f90a9a4292e58188deba564756775d54bad38de697be7659cde395c60f403933083c4e71881c26d15c83a61359fbecd1c12d8f31c0d440c128c416e09ee2d3fe64b8a4c737c2f604756d08d8c1f77d4623404e031805797412b01", + "data": { + "slot": "1", + "index": "4549347484797182313", + "beacon_block_root": "0xcf2c053f899b836f534bfa2a45bf23b7be4890b9815a72a2aec9f70eff53d592", + "source": { + "epoch": "528459505", + "root": "0xa8ea103f4904c5e568c52bd49eadfa1cb142929514c9202e53c7707e4a92667d" + }, + "target": { + "epoch": "528844253", + "root": "0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd" + } + }, + "signature": "0x8f5c34de9e22ceaa7e8d165fc0553b32f02188539e89e2cc91e2eb9077645986550d872ee3403204ae5d554eae3cac12124e18d2324bccc814775316aaef352abc0450812b3ca9fde96ecafa911b3b8bfddca8db4027f08e29c22a9c370ad933" + }, + { + "aggregation_bits": "0xd664cfc4f928592f21ca9fae84cd2a15d4acf76e0d2cbb493324ae9cb25757559fc4b060414cbfd84de047d4f04da4aa6669e83b9b8418d348bfc46b3fef684ffbf0162da3c6258f690b14c94cf448280b646c140b24928defd2d12434dbbbd0afbea5e5661fcac8116699ec8a059acf084ab956ab0eaf508ab7d3e4bd352a80f6b8ff73b4b24753a865991c45c9d9f0e1675e7327ccaaeb146bc3d0a4db2d7e607930579fc38a41d5019f222166cea9ebebfe0dd7b875fa612ecb7bb80f83718702da59fd2687d445048ac99f25b5f088fe931ec4bbf9ecdfc169844c00bc69fe38c0110fc59105233b29f6ddecb7968065fd7ef787e41d3545fefe30314fa401", + "data": { + "slot": "1", + "index": "4536127614768741993", + "beacon_block_root": "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8", + "source": { + "epoch": "526920509", + "root": "0x41f3e13e4961bf0c12dd652f3bf49e85e35a8a25c70e67ffc1d08cc01d9921d3" + }, + "target": { + "epoch": "527305258", + "root": "0x51977a3f0ab3110e2a10e9c6bd0e89b1410ca45142ac42171bb2b169efc281bc" + } + }, + "signature": "0xa17225b5e5319618e77f5b93350430acfadd8ae12a279f1a4176cc7ad1de7ecfc8670988519713fbac8f702cca29bddb14ff1463dae3abb53ddb0c025cd69c8cfb0f5298ab241c06ddb840c7a260f3dbd37120826b13b17e22d086148ebdbab1" + } + ], + "deposits": [ + { + "proof": [ + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7" + ], + "data": { + "pubkey": "0x90b2ffa8992560bca2080afa9b3adc904ce9085a8c2cc897282f20378bdf3cdc0a74100f226ea698e07d4afe50d8ff54", + "withdrawal_credentials": "0x9d1b633f8ae18e21ff1b86740b32dbe55a18a0991bcfe5ffd2b6bf8a59465fe7", + "amount": "32000000000", + "signature": "0x978f1439422f6e539e93927a7754e7f9866fbe5832da066bb8fec5041a6818bbfe7e79747a963eec57f76924aeb591d0133ffae96de0793f02d13a13e1f7286a7940e48093ceb832b58e9d6bff9adfc1e8f59367d905633d743cd62ccbd2b27c" + } + } + ], + "voluntary_exits": [ + { + "message": { + "epoch": "4570829775204010570", + "validator_index": "4565872325553958186" + }, + "signature": "0x8c2c3b368bc00b3853e6df352e816dd910016db953ac77cc1565e3c22f1c0b24c59f24ea9e8ca406aa95b23368d163e80baa6de3f8f7ac19ee78c976d2ae5a21c86fa1762cc959bc734379055cb7aa1de36eae00541936b8c2ee908c770d41ff" + } + ], + "sync_aggregate": { + "sync_committee_bits": "0x01000000", + "sync_committee_signature": "0x8166b2ed13e982e6b9f05d30f42681b826099135a533d2614ef5f4f59811714245db0e1821a644859559f97ec1e614bf08b2edb294fa2edc1527f46596399534af23c98613e1b74c01871bf1dd2af9618bc0ba23ddfce8026b897cdbba8c1bce" + } + } + } +} \ No newline at end of file diff --git a/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockBELLATRIX.json b/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockBELLATRIX.json index ab6314d6651..8d14637067f 100644 --- a/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockBELLATRIX.json +++ b/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockBELLATRIX.json @@ -1 +1,229 @@ -{"version":"bellatrix","execution_payload_blinded":false,"execution_payload_value":"12345","consensus_block_value":"123000000000","data":{"slot":"1","proposer_index":"4666673844721362956","parent_root":"0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef","state_root":"0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e","body":{"randao_reveal":"0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71","eth1_data":{"deposit_root":"0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f","deposit_count":"4658411424342975020","block_hash":"0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379"},"graffiti":"0x0000000000000000000000000000000000000000000000000000000000000000","proposer_slashings":[{"signed_header_1":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b","state_root":"0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb","body_root":"0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486"},"signature":"0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483"},"signed_header_2":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6","state_root":"0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26","body_root":"0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1"},"signature":"0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1"}}],"attester_slashings":[{"attestation_1":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4580744678799082634","index":"4579092195582398506","beacon_block_root":"0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c","source":{"epoch":"533461240","root":"0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565"},"target":{"epoch":"538462976","root":"0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650"}},"signature":"0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc"},"attestation_2":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4620404293179370891","index":"4618751809962686763","beacon_block_root":"0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b","source":{"epoch":"538078227","root":"0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb"},"target":{"epoch":"536923980","root":"0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5"}},"signature":"0xa32991816eb9f297553b4732309a4cdba7b33287264611715b0ab3319bca19e581da6e2659912a4e0e94aafc01c488e30ffc96ed14e2a726b9d3c618405ee0bf54bf6ae7f2097465cb27ab8132ec24eb93d3c9159475304082f7f0e452b93b65"}}],"attestations":[{"aggregation_bits":"0xfa79cdb89d0d51c5cdd001b7425c6d726750a9d5f89ade6ed9890ce3a706140c399a5e10c90a819094b65322dac7501f7c75471e69d4567358d8ca75f7c1b3133ebecf006b369a1f36efc5f2b706d5922ff98c58a1825a53a864376658f816600cf021cea843d4396502bb9c74d1510afe26036f89f783b4f5c7bacb6649c46f217a6af835f312d6fa253d2bbc83c07993f4f10de2ed2d952689379dbe4f794c1a1055a6b364d68e038deec9667f576b3b9eca5fcadd6298f181e1edb876efc3d0975ae14ae9a0ad2f1836d4c3f1080a96d8ab7c43b34bb2eda895ff66be698b363cfa4be33da3ec94a1a7a90672fd12c4a59916bb937e78476e4f08e4f4031001","data":{"slot":"4605531939934246443","index":"4610489389584298827","beacon_block_root":"0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b","source":{"epoch":"529421377","root":"0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2"},"target":{"epoch":"529806126","root":"0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd"}},"signature":"0x8f8d16b39e14569aab1b712e5c19ed51afe3600a6b017e8ab432f43a02ee720a733c33ef087d2f3653a9701e8d8a836301655b9195c0373b775c88ba1368e5d55354a70a3096bd26dee29dddbe7a4820e2b1653e84122beacbc01af7d93e6bdc"},{"aggregation_bits":"0x4ac567b296efbf7cf3209e87096a7a1a50fd523400113f917f6584a5a306f06b2d8da9ae858d47ff2594010089838efe41f19a78d9aae27c2ffde26f278b8681db9d091eb72e7cab3e449dfccd46a270693e1f88f197324e57bfd45573315cf9fb60d770937b32f7c0c6ce1581ec51e6b60f71acfde304dc917f2e0aa7872038b7d9140d15f7927c23a0490a74c2b0aca2773fed9217067e4444f9ca93874e4ff8407111c3efdb138b97c6d4957b6a70ec1debb283e3d0eb1cfef068adcffbf057d20fdc339eae03f0fa2613abdde8158a7fc40c3cfd1117eb6f8c4ae21d6b2ab4b57ae9a8653a34451aee6418c0c3609dc937293f5f5b346a7ab1a0d144185101","data":{"slot":"4544390030852162633","index":"4542737547635478505","beacon_block_root":"0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd","source":{"epoch":"527690007","root":"0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8"},"target":{"epoch":"528074756","root":"0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8"}},"signature":"0x90309dd491ae6ed51917dc305a3d4ae68d0a0d4792c7eb59c193bd03605bd94e61cab37502de0ad3e6162bc02427bba80a798b3670d5de82a854094016cc298b265371345c0e3ac49fd44bbb9ba0d4fcea0c1a80cecb60e93921d907e8c48120"},{"aggregation_bits":"0xe8c9759f0840f980ae956b15fc383d992e7d4420d12ba5bf32f669f446ac6fa388e20e5ce96e9266dd98840179d2cde3cabd9a8bafab5dec9c2e89f7f78c989e690548603984803b80c82d7b76443194576a1ce49da5cfe56f56e83b745fb01b5f18ccc86d88f5a22d927e64ff0b8e880893abcddec45b268531c4a0697537dae643a24b1a36432f37d42962553bd39af71f37e0429b81470c11316aa39db074aa3f1df4124e7cb203debed60b885ffb9b27e46a1434e81bbd56566632d0729c0822ac415cbb67f25973667d88e58df9c2f058a0ae7f118c98cc448453b6fbe590363bd17ed62c2f808df61f2a9e593235eeb56db74b9dd15980189a5271468301","data":{"slot":"4529517677607038185","index":"4574134745932346122","beacon_block_root":"0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947","source":{"epoch":"532884117","root":"0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31"},"target":{"epoch":"531729870","root":"0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672"}},"signature":"0x8c40f51a99fce6ebb9a4db5e80d715fff319e7ae523e46afb5d03c000d427e23c7a39e77e2af53851706283c8ca91d680997cb459386fbdff52c4d0ecf498e173717a838a792b210bdffaf476538628584a133899bf30dd5ce7056463b8cd683"}],"deposits":[{"proof":["0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c"],"data":{"pubkey":"0xb1f8f6e731dbf6b4e3265fb857c7190adbfc7e6cc95ce2e8bda72be8b6ea3459f862310a2484c3b0ee33b30920f18c1d","withdrawal_credentials":"0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c","amount":"32000000000","signature":"0xb594382214f5bdd375de66c45e1c61a526c7b73fb166c72433bbd9c2a7ad6881244e61cc6427e0206a50b762a129d8830e8708c55761d61ce9e3b19c1bee13bc55daa13bdb07118efdbf57a588b8a64e6392d14f935e53b68933e3355b35acdb"}}],"voluntary_exits":[{"message":{"epoch":"4562567354825622634","validator_index":"4564219838042306762"},"signature":"0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e"}],"sync_aggregate":{"sync_committee_bits":"0x01000000","sync_committee_signature":"0x919ee45cc18456f6e85da6bc21c2e40f44f9a887932c73ea9ad354f88e56d4ec0a8c396ed143082c8e31d697b877a2a215d2966d91c7beb156bf7ab5777e210012f70dcd5f7657808a82cba51e194be994f917150ebdb9e5c57476f1edb47206"},"execution_payload":{"parent_hash":"0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be","fee_recipient":"0xf8eb5a3ea82ccf3c1be1ac153e3f77f273a07343","state_root":"0xbf886c3ec849316e3b187793c3a4398b6097768d06bd968a54e8d2652d2a75a9","receipts_root":"0xd2a9663e689510b3305bdebe972d4e58669a751fbc85bf448269162e078b2c34","logs_bloom":"0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9f770a36a743c8a3abab61dc439ddc0604dd5015b1ed3835787d9565dee0f3e64b25de4c097defe3001f483a4b6feac22b992cada114bfc709d483b4d94f07bb0a1c4fb9e93ca3c31f4b9683753ba33ffd971777e301367f1edfe6809da491535c711a7877b4c97fd1a756136c412b4f3c4471ba439607333623558a63030f2cb6bc2ba885822672de14ea697d44fbcde134b6909208466be0b4c981658ba30f999c991aca746c3331766af1ee10cbe69624066708ae086999a0a3853eb777b3f9f0455cfd98a98c7719710515b97c596d2b662d353a90206e470c523d4374853","prev_randao":"0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874","block_number":"4491510546443434056","gas_limit":"4489858063226749928","gas_used":"4481595642848361992","timestamp":"4479943159631677864","extra_data":"0x58913d3ec8a62b95e52fb1ee60ebddf392af6e1db902dd5bc3f1eea7003130ff","base_fee_per_gas":"48712354854557871613352262057776104244427151172201944877932608112921551169417","block_hash":"0xcb571a3e876c6732a4c11cf3562059c2b8c16889ffb6d1b8d5f883591e767c3f","transactions":["0xb736203ee72088","0xc7dab83ea972da","0xa198c43e69db1b","0x135fa13e28a157","0xed1cad3ee80999","0x60e3893ea8cfd4","0x39a1953e683816","0xac67723e28fe51"]}}}} \ No newline at end of file +{ + "version":"bellatrix", + "execution_payload_blinded":false, + "execution_payload_value":"12345", + "consensus_block_value":"123000000000", + "data": { + "slot": "1", + "proposer_index": "4666673844721362956", + "parent_root": "0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef", + "state_root": "0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e", + "body": { + "randao_reveal": "0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71", + "eth1_data": { + "deposit_root": "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f", + "deposit_count": "4658411424342975020", + "block_hash": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + }, + "graffiti": "0x0000000000000000000000000000000000000000000000000000000000000000", + "proposer_slashings": [ + { + "signed_header_1": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b", + "state_root": "0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb", + "body_root": "0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486" + }, + "signature": "0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483" + }, + "signed_header_2": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6", + "state_root": "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "body_root": "0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1" + }, + "signature": "0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1" + } + } + ], + "attester_slashings": [ + { + "attestation_1": { + "attesting_indices": [ + "4585702132744102314", + "4590659586689121994", + "4589007099177470570" + ], + "data": { + "slot": "1", + "index": "4580744678799082634", + "beacon_block_root": "0x17348c3f2ad0733f4b47b34442744b4a2e03a79b1f52c8e8922ee71060a05b1c", + "source": { + "epoch": "533653615", + "root": "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06" + }, + "target": { + "epoch": "538655350", + "root": "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0" + } + }, + "signature": "0xaffb36fe3e48b5c29794f85515b9a3adcd4206fec6dddac6926d0e985d96a9ade0e427f911d56dd90f2644af13e9740509147d149defa9b0763eecba616e0815e9a91c25178860be7d4196a9814781a4576ba7bc6398ef16b9bd5f88c4143bfb" + }, + "attestation_2": { + "attesting_indices": [ + "4585702132744102314", + "4590659586689121994", + "4589007099177470570" + ], + "data": { + "slot": "1", + "index": "4628666713557758827", + "beacon_block_root": "0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390", + "source": { + "epoch": "537693478", + "root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b" + }, + "target": { + "epoch": "538078227", + "root": "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb" + } + }, + "signature": "0xb7720f152c38d7172a82186892a68440bc4d285cc8aa92c1f017f93d5f61a29cf51670e4f944648bd8df82d4d6eae00615073d439389cdf35fbd7670a07ef8407c7c71a16be062fff16f351737ac99f006817ba43a295fe5286dfb4ba7116e07" + } + } + ], + "attestations": [ + { + "aggregation_bits": "0x88e3aeac2cb7509e753b73880be4e95da67b35193a1a8d916d3a5f3b61c59b6d90d866ae7ee81a10a9ea025ade39ad5b978bd20bd2d2031d61e8aa7b5090b08248dbcac0698c25ea7b858ae37e5347010aa764962e4f70513d9e2488a9808d0510dcb3dc9385cc9c28ba4a1eae314e5c3372b3d2387836dc0750553f84b1b490b7fffcb2824b614596050fa2ffed45b30b7db4e67cd782cf0446b5448ed43cb01991cde29c15b0a29dcafdbf29840045c4a3d7e58b93ff391e3ae281185e49aeeed12188548d0dc8e904edc1c8a9831577d08b0c708dbb1784cef981e8363efb46d26f039c2561792d1a2e81218eec593aefaa25bb280fbdd25f8103381a51c601", + "data": { + "slot": "1", + "index": "4615446843529318507", + "beacon_block_root": "0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6", + "source": { + "epoch": "536154483", + "root": "0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0" + }, + "target": { + "epoch": "536539231", + "root": "0x82a81c3f096d065c7e3f5d7df79bd182a53c9471a737cfb9f7c4e9ed95d0f767" + } + }, + "signature": "0xa9aef1e37252740dedc5fc9886810459f7484555aa59fb3876803fc4924149cb471ffbbd9be5324d952efafc3de4c5f705dd02134916b2afa02194fe90a8d1e8f58ebcfe0d33d0b8a97e71a3f7591cb82c37ba531c059a684b581d3857f05e3c" + }, + { + "aggregation_bits": "0x0aa2e4365aad4ec5115dbc42fc6bcda2a0739e4b8c6c07334b99338ec990c7dc93162171b1ed0afe8b1f151348438523b428076a646db8375993d417cd79f1854f796992a8aea702eb3180373e7ff4b4c53ef3b306a5af7f82ba3a4a362af88084e7d166dd0ed5026019cd4f2c4fad16566f927d0dceb14203e8abc293267466c487eb2b108ae043792ff8e8c56e9fbb26d98381ad35e70558cc74f74d1d5a7de764645e15298f90a9a4292e58188deba564756775d54bad38de697be7659cde395c60f403933083c4e71881c26d15c83a61359fbecd1c12d8f31c0d440c128c416e09ee2d3fe64b8a4c737c2f604756d08d8c1f77d4623404e031805797412b01", + "data": { + "slot": "1", + "index": "4549347484797182313", + "beacon_block_root": "0xcf2c053f899b836f534bfa2a45bf23b7be4890b9815a72a2aec9f70eff53d592", + "source": { + "epoch": "528459505", + "root": "0xa8ea103f4904c5e568c52bd49eadfa1cb142929514c9202e53c7707e4a92667d" + }, + "target": { + "epoch": "528844253", + "root": "0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd" + } + }, + "signature": "0x8f5c34de9e22ceaa7e8d165fc0553b32f02188539e89e2cc91e2eb9077645986550d872ee3403204ae5d554eae3cac12124e18d2324bccc814775316aaef352abc0450812b3ca9fde96ecafa911b3b8bfddca8db4027f08e29c22a9c370ad933" + }, + { + "aggregation_bits": "0xd664cfc4f928592f21ca9fae84cd2a15d4acf76e0d2cbb493324ae9cb25757559fc4b060414cbfd84de047d4f04da4aa6669e83b9b8418d348bfc46b3fef684ffbf0162da3c6258f690b14c94cf448280b646c140b24928defd2d12434dbbbd0afbea5e5661fcac8116699ec8a059acf084ab956ab0eaf508ab7d3e4bd352a80f6b8ff73b4b24753a865991c45c9d9f0e1675e7327ccaaeb146bc3d0a4db2d7e607930579fc38a41d5019f222166cea9ebebfe0dd7b875fa612ecb7bb80f83718702da59fd2687d445048ac99f25b5f088fe931ec4bbf9ecdfc169844c00bc69fe38c0110fc59105233b29f6ddecb7968065fd7ef787e41d3545fefe30314fa401", + "data": { + "slot": "1", + "index": "4536127614768741993", + "beacon_block_root": "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8", + "source": { + "epoch": "526920509", + "root": "0x41f3e13e4961bf0c12dd652f3bf49e85e35a8a25c70e67ffc1d08cc01d9921d3" + }, + "target": { + "epoch": "527305258", + "root": "0x51977a3f0ab3110e2a10e9c6bd0e89b1410ca45142ac42171bb2b169efc281bc" + } + }, + "signature": "0xa17225b5e5319618e77f5b93350430acfadd8ae12a279f1a4176cc7ad1de7ecfc8670988519713fbac8f702cca29bddb14ff1463dae3abb53ddb0c025cd69c8cfb0f5298ab241c06ddb840c7a260f3dbd37120826b13b17e22d086148ebdbab1" + } + ], + "deposits": [ + { + "proof": [ + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7" + ], + "data": { + "pubkey": "0x90b2ffa8992560bca2080afa9b3adc904ce9085a8c2cc897282f20378bdf3cdc0a74100f226ea698e07d4afe50d8ff54", + "withdrawal_credentials": "0x9d1b633f8ae18e21ff1b86740b32dbe55a18a0991bcfe5ffd2b6bf8a59465fe7", + "amount": "32000000000", + "signature": "0x978f1439422f6e539e93927a7754e7f9866fbe5832da066bb8fec5041a6818bbfe7e79747a963eec57f76924aeb591d0133ffae96de0793f02d13a13e1f7286a7940e48093ceb832b58e9d6bff9adfc1e8f59367d905633d743cd62ccbd2b27c" + } + } + ], + "voluntary_exits": [ + { + "message": { + "epoch": "4570829775204010570", + "validator_index": "4565872325553958186" + }, + "signature": "0x8c2c3b368bc00b3853e6df352e816dd910016db953ac77cc1565e3c22f1c0b24c59f24ea9e8ca406aa95b23368d163e80baa6de3f8f7ac19ee78c976d2ae5a21c86fa1762cc959bc734379055cb7aa1de36eae00541936b8c2ee908c770d41ff" + } + ], + "sync_aggregate": { + "sync_committee_bits": "0x01000000", + "sync_committee_signature": "0x8166b2ed13e982e6b9f05d30f42681b826099135a533d2614ef5f4f59811714245db0e1821a644859559f97ec1e614bf08b2edb294fa2edc1527f46596399534af23c98613e1b74c01871bf1dd2af9618bc0ba23ddfce8026b897cdbba8c1bce" + }, + "execution_payload": { + "parent_hash": "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "fee_recipient": "0x3624343f893e8948a933c0cfa8787f4e8c309829", + "state_root": "0x49452e3f298a688d9e7627fb7c01941b923397bb84dd548b6e411f9506aed1c7", + "receipts_root": "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "logs_bloom": "0x23033a3fe9f2a903b4f058a4d4ef6a81852d9997184c0317133f980452ec62b2b061e83c58b49a2152d35e2d52dec57a103ce8a251c901ef2fab683582825ff8b0b008f76d24edc9c1ae40d0e75942618263f7d7986e9bccf1329656466d543e00b24a93476cb3f928af4367c6625a9cf341db27bc452836499a1efdd2c9eb5e912927c2878fe39fe1a2b36a44c10572cd0437fa4fd7e83a9db691bfbf5b9fcaeb8b2ea9d2b89eeffc8cf98d5b66f53e527f376d29bf250544a9eeb288757962a5fc0eae509665d2b90702b12b5caa0913916a48e650fd430ceafdde0d71da95ee9ceba330c6cb0412771d5275464afa7adcac63634c91ceb521f22e12b844c9", + "prev_randao": "0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be", + "block_number": "4493163029660118184", + "gas_limit": "4498120483605137864", + "gas_used": "4496467996093486440", + "timestamp": "4488205580010065800", + "extra_data": "0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874", + "base_fee_per_gas": "5451311522429616772243425117521481983710813629341562216088296324789550535380", + "block_hash": "0x1f2e4f3ee8c38dc605677b6ce650a08c7fa6716795a8622d396e244f710e0a5f", + "transactions": [ + "0x58913d3ec8a62b", + "0xcb571a3e876c67", + "0xa415263e48d5a8", + "0xb4b9be3e0927fb", + "0x8e77ca3ec98f3c", + "0x003ea73e885578", + "0xdafbb23e48beb9", + "0x4dc28f3e0884f5", + "0x26809b3ec8ec36", + "0x9946783e88b272" + ] + } + } + } +} \ No newline at end of file diff --git a/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockCAPELLA.json b/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockCAPELLA.json index 2ba050a10f4..ea51c185959 100644 --- a/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockCAPELLA.json +++ b/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockCAPELLA.json @@ -1 +1,367 @@ -{"version":"capella","execution_payload_blinded":false,"execution_payload_value":"12345","consensus_block_value":"123000000000","data":{"slot":"1","proposer_index":"4666673844721362956","parent_root":"0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef","state_root":"0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e","body":{"randao_reveal":"0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71","eth1_data":{"deposit_root":"0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f","deposit_count":"4658411424342975020","block_hash":"0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379"},"graffiti":"0x0000000000000000000000000000000000000000000000000000000000000000","proposer_slashings":[{"signed_header_1":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b","state_root":"0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb","body_root":"0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486"},"signature":"0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483"},"signed_header_2":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6","state_root":"0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26","body_root":"0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1"},"signature":"0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1"}}],"attester_slashings":[{"attestation_1":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4580744678799082634","index":"4579092195582398506","beacon_block_root":"0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c","source":{"epoch":"533461240","root":"0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565"},"target":{"epoch":"538462976","root":"0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650"}},"signature":"0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc"},"attestation_2":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4620404293179370891","index":"4618751809962686763","beacon_block_root":"0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b","source":{"epoch":"538078227","root":"0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb"},"target":{"epoch":"536923980","root":"0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5"}},"signature":"0xa32991816eb9f297553b4732309a4cdba7b33287264611715b0ab3319bca19e581da6e2659912a4e0e94aafc01c488e30ffc96ed14e2a726b9d3c618405ee0bf54bf6ae7f2097465cb27ab8132ec24eb93d3c9159475304082f7f0e452b93b65"}}],"attestations":[{"aggregation_bits":"0xfa79cdb89d0d51c5cdd001b7425c6d726750a9d5f89ade6ed9890ce3a706140c399a5e10c90a819094b65322dac7501f7c75471e69d4567358d8ca75f7c1b3133ebecf006b369a1f36efc5f2b706d5922ff98c58a1825a53a864376658f816600cf021cea843d4396502bb9c74d1510afe26036f89f783b4f5c7bacb6649c46f217a6af835f312d6fa253d2bbc83c07993f4f10de2ed2d952689379dbe4f794c1a1055a6b364d68e038deec9667f576b3b9eca5fcadd6298f181e1edb876efc3d0975ae14ae9a0ad2f1836d4c3f1080a96d8ab7c43b34bb2eda895ff66be698b363cfa4be33da3ec94a1a7a90672fd12c4a59916bb937e78476e4f08e4f4031001","data":{"slot":"4605531939934246443","index":"4610489389584298827","beacon_block_root":"0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b","source":{"epoch":"529421377","root":"0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2"},"target":{"epoch":"529806126","root":"0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd"}},"signature":"0x8f8d16b39e14569aab1b712e5c19ed51afe3600a6b017e8ab432f43a02ee720a733c33ef087d2f3653a9701e8d8a836301655b9195c0373b775c88ba1368e5d55354a70a3096bd26dee29dddbe7a4820e2b1653e84122beacbc01af7d93e6bdc"},{"aggregation_bits":"0x4ac567b296efbf7cf3209e87096a7a1a50fd523400113f917f6584a5a306f06b2d8da9ae858d47ff2594010089838efe41f19a78d9aae27c2ffde26f278b8681db9d091eb72e7cab3e449dfccd46a270693e1f88f197324e57bfd45573315cf9fb60d770937b32f7c0c6ce1581ec51e6b60f71acfde304dc917f2e0aa7872038b7d9140d15f7927c23a0490a74c2b0aca2773fed9217067e4444f9ca93874e4ff8407111c3efdb138b97c6d4957b6a70ec1debb283e3d0eb1cfef068adcffbf057d20fdc339eae03f0fa2613abdde8158a7fc40c3cfd1117eb6f8c4ae21d6b2ab4b57ae9a8653a34451aee6418c0c3609dc937293f5f5b346a7ab1a0d144185101","data":{"slot":"4544390030852162633","index":"4542737547635478505","beacon_block_root":"0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd","source":{"epoch":"527690007","root":"0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8"},"target":{"epoch":"528074756","root":"0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8"}},"signature":"0x90309dd491ae6ed51917dc305a3d4ae68d0a0d4792c7eb59c193bd03605bd94e61cab37502de0ad3e6162bc02427bba80a798b3670d5de82a854094016cc298b265371345c0e3ac49fd44bbb9ba0d4fcea0c1a80cecb60e93921d907e8c48120"},{"aggregation_bits":"0xe8c9759f0840f980ae956b15fc383d992e7d4420d12ba5bf32f669f446ac6fa388e20e5ce96e9266dd98840179d2cde3cabd9a8bafab5dec9c2e89f7f78c989e690548603984803b80c82d7b76443194576a1ce49da5cfe56f56e83b745fb01b5f18ccc86d88f5a22d927e64ff0b8e880893abcddec45b268531c4a0697537dae643a24b1a36432f37d42962553bd39af71f37e0429b81470c11316aa39db074aa3f1df4124e7cb203debed60b885ffb9b27e46a1434e81bbd56566632d0729c0822ac415cbb67f25973667d88e58df9c2f058a0ae7f118c98cc448453b6fbe590363bd17ed62c2f808df61f2a9e593235eeb56db74b9dd15980189a5271468301","data":{"slot":"4529517677607038185","index":"4574134745932346122","beacon_block_root":"0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947","source":{"epoch":"532884117","root":"0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31"},"target":{"epoch":"531729870","root":"0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672"}},"signature":"0x8c40f51a99fce6ebb9a4db5e80d715fff319e7ae523e46afb5d03c000d427e23c7a39e77e2af53851706283c8ca91d680997cb459386fbdff52c4d0ecf498e173717a838a792b210bdffaf476538628584a133899bf30dd5ce7056463b8cd683"}],"deposits":[{"proof":["0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c"],"data":{"pubkey":"0xb1f8f6e731dbf6b4e3265fb857c7190adbfc7e6cc95ce2e8bda72be8b6ea3459f862310a2484c3b0ee33b30920f18c1d","withdrawal_credentials":"0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c","amount":"32000000000","signature":"0xb594382214f5bdd375de66c45e1c61a526c7b73fb166c72433bbd9c2a7ad6881244e61cc6427e0206a50b762a129d8830e8708c55761d61ce9e3b19c1bee13bc55daa13bdb07118efdbf57a588b8a64e6392d14f935e53b68933e3355b35acdb"}}],"voluntary_exits":[{"message":{"epoch":"4562567354825622634","validator_index":"4564219838042306762"},"signature":"0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e"}],"sync_aggregate":{"sync_committee_bits":"0x01000000","sync_committee_signature":"0x919ee45cc18456f6e85da6bc21c2e40f44f9a887932c73ea9ad354f88e56d4ec0a8c396ed143082c8e31d697b877a2a215d2966d91c7beb156bf7ab5777e210012f70dcd5f7657808a82cba51e194be994f917150ebdb9e5c57476f1edb47206"},"execution_payload":{"parent_hash":"0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be","fee_recipient":"0xf8eb5a3ea82ccf3c1be1ac153e3f77f273a07343","state_root":"0xbf886c3ec849316e3b187793c3a4398b6097768d06bd968a54e8d2652d2a75a9","receipts_root":"0xd2a9663e689510b3305bdebe972d4e58669a751fbc85bf448269162e078b2c34","logs_bloom":"0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9f770a36a743c8a3abab61dc439ddc0604dd5015b1ed3835787d9565dee0f3e64b25de4c097defe3001f483a4b6feac22b992cada114bfc709d483b4d94f07bb0a1c4fb9e93ca3c31f4b9683753ba33ffd971777e301367f1edfe6809da491535c711a7877b4c97fd1a756136c412b4f3c4471ba439607333623558a63030f2cb6bc2ba885822672de14ea697d44fbcde134b6909208466be0b4c981658ba30f999c991aca746c3331766af1ee10cbe69624066708ae086999a0a3853eb777b3f9f0455cfd98a98c7719710515b97c596d2b662d353a90206e470c523d4374853","prev_randao":"0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874","block_number":"4491510546443434056","gas_limit":"4489858063226749928","gas_used":"4481595642848361992","timestamp":"4479943159631677864","extra_data":"0x58913d3ec8a62b95e52fb1ee60ebddf392af6e1db902dd5bc3f1eea7003130ff","base_fee_per_gas":"48712354854557871613352262057776104244427151172201944877932608112921551169417","block_hash":"0xcb571a3e876c6732a4c11cf3562059c2b8c16889ffb6d1b8d5f883591e767c3f","transactions":["0xb736203ee72088","0xc7dab83ea972da","0xa198c43e69db1b","0x135fa13e28a157","0xed1cad3ee80999","0x60e3893ea8cfd4","0x39a1953e683816","0xac67723e28fe51"],"withdrawals":[{"index":"4864971916622804241","validator_index":"2164897","address":"0x09988f43d11dcf2aa7811c9997eb4119e8f153ce","amount":"4866624404134455665"}]},"bls_to_execution_changes":[{"message":{"validator_index":"1780148","from_bls_pubkey":"0x98d6103215e3916a0cff3af6b6f29f22374a32d87d440a302e18a9e2daa80b32a2824798030f6a2e06ab612b07c41f74","to_execution_address":"0xdb034f43b15d672031628c76afcc23e92d134914"},"signature":"0xa2f3dc0cbadf0807f2d864d0c98c2e474972419b1ef936d0c68976eb732a146c8bd86194e95381d1b9245530b1f138cc0de425bd6478bc56a394619e1192a114680c4e9f8b0278816bd4f5df9e24cc31ca73cf5eb26da54eebf958966d4a957f"},{"message":{"validator_index":"2856403","from_bls_pubkey":"0xac60d2ec631e27b37f4f5541319b94c8cf82299d71ae4139039cbc1d0c30c71a075cb62166801ccd0a56f0bc29edcdae","to_execution_address":"0x01464343f1f425aa1be85acd56de4c833a194738"},"signature":"0x818852c88a6e16f2294cb51803a155dcac4f6ec5ee0d095e8890be8907201ee1c8790abb6d5f05faa2b3d8d9a03972800a04fc1666d877c7cbfb62c387d6e119f8f827ea2ba94d5b6429b33d6f3770b79999da3cb8ed17f2c8977234bd2a1cdc"},{"message":{"validator_index":"2627637","from_bls_pubkey":"0x92f00f85478ad1224c1be3a9b9230444411e9a2beeb6304e5c1fba1b7b54c9ecc3965abeb3385e4916040260544b2580","to_execution_address":"0x5d6ec4433175f5be08277b12261c89e3b0d65cac"},"signature":"0x8b13ef837950d00a469eae427c1fea111ea85e0dfd63c09bdc02aec208523ec4c805595639d50e183dc893022f60abd8118d62c836b6d4de057967f80184532c1c3a25b26c51926a07e55d2ba264de6fd22eb0665668cc7280bbcdfdfdb3c0b6"},{"message":{"validator_index":"703892","from_bls_pubkey":"0x8939b0ed4fd0659427739e525d6990c02614d703d12c5adaa5f8aeedf64fb9ce66e769d83f9ec61ec05c6074d5095955","to_execution_address":"0x83b0b843710cb448f2ac4969cd2db27dbddc5ad0"},"signature":"0x8f65a298124021cf26323bea9328da795a7f2134f42c21e28617a1b663c568058fa3ddff9a71948362e7380cfb591ec9062f735067b1a32bd2b88e9c2d5c3404348a194098c30f55f8cc050b305bc4c2baeb2a6e4ab1d49833bd7ec4943367f0"},{"message":{"validator_index":"319143","from_bls_pubkey":"0x8f5f289f8ae538eca9f393fd7ed1a5432ba4c145b700075d1a8ea9530ec8cba3b91511e78662d0f2bed026a1b86d6d2b","to_execution_address":"0xa51dc242b07456952ea93a8886a01023c35b31c4"},"signature":"0xa23a1e6d9410ecb12fe95fbdb3b12962bd46855fa46ccd7b2fe75696cd4b1788302d6fc3bc1c1bc6f8080d0025b3fdc9139a3b141407213b8123563622773e9b385473bcd03f149b0ea21e52626382dba56b95a2204178c2c454001c79289afb"},{"message":{"validator_index":"1239417","from_bls_pubkey":"0xace9988853ce03390f8d5c93fa51e3a5f5b056bef4ed1f437a86c59fb687be25d0e6f4be5beeec4bc04806e93c3eebf7","to_execution_address":"0xcb5fb642f00b151f192f09df2db239bdd0612fe8"},"signature":"0xa0053dab17b7e0ba64416b1c95b6c56ecb7f39ccc272cd57a347054fab6781ab8d834eda1a4e57ac5b037d3b71945d1805216ba518aefad29922f57f1b3149151d4266ae944b579de5399a209e482a19d3fd7e9c02069e7a01ab2e9a59477326"},{"message":{"validator_index":"854668","from_bls_pubkey":"0x85a2763ffc316d21106869ce72f88e6e5aa3ffcb84689aea186a7de5056f0fa98f50ce3bcfb8a96d33585c472748b014","to_execution_address":"0x8aaa7b422f00cecfadcc1191710a07c00e80259c"},"signature":"0x84ff1208ba8c36a14bcf8c5d3c9d9e22dd6d69f7053eaba3ce96cf7ca324ec3c3a2bd097053788b7dc64d7dbccc30ebd07fbaf41e95ae397751f8aadbc4d84219038b55e1fb3785a8f7ceebe05d629ce2c9c407bb9be6c66c0d26c14b3a7c3c2"},{"message":{"validator_index":"2086906","from_bls_pubkey":"0x8f220bb09673d250a17cdd562f33ca615e83e293a43e1313a9c3e9438c218cfa9a803426d29e9bffdd884daecf7e0ac6","to_execution_address":"0x4dca2b437023a3bdf0f3f77aa4019fb753254380"},"signature":"0x81d6211b8ee9652820795832982520799ba2eab947083a2c6e56d9cdf1e678b1c1a6c8a108ece8b1c23b234a208e6e281477d55c41fc3d04027032277fa0922a0370e76db742037a0688697f618b8b7780cbfb3725f78bf9c5f94876d9d1957a"},{"message":{"validator_index":"1702157","from_bls_pubkey":"0xb63a024e98bf28daf9bf8bdcb7c89d823f29e65e362a923afec6c78aef21559a12d2c5cdf81998630ac418034c0e58ed","to_execution_address":"0x0c15f142b0175c6e8491002de9596cba91433934"},"signature":"0xa386f611424c8ec936f7ef72da9d526823e3bd03f3452131910b7c5ae646a989c276001faa9398ff3ce9050cc0282c5003ee9357b8485f4c52a4321e9c5150d39cebf18546badc0a22d7d881a08bfcd1e76c4a7c9c8cd7f85da5270877698c7a"},{"message":{"validator_index":"2778412","from_bls_pubkey":"0x90961673ed2682e726960a035e0d1e050ff0754225f97fb7501110e474cee35f7ed1bdeb70eebc97a59abbd7217bc691","to_execution_address":"0x3357e542f0ae1af86f17cf83906b95549e493758"},"signature":"0x9590d1d0c5216aeacaa19bb58a4a66a6430e554a0b020e2977be2421bcd089fb47bccbe10f2baac88dee33fc625dd5441217042918ac793c0aa2aba45a379decdb018b7bdd277f2a66b122a95aa1974cb05208e00801ed52f7f86b671c372e2f"},{"message":{"validator_index":"2237681","from_bls_pubkey":"0xa63d491bd47a8f4caf987b7a22f228dc709f8f4a0d8ac25ed72a18cbe2b2da7662daafbe182b33c81e14eac70bc2f0d5","to_execution_address":"0x55c4ee412e17bd44aa13c0a248def3f9a4c80d4c"},"signature":"0x8e4e43252f668d04559aa2ecf1ae7605a054c1fc2d5b0a9b77f9b091b8fd851ef5a02d54ed31a66053144d0319d8f4ac11185d05cd68099841cc554c99de314a291e83c4bd166b924240d4851d8ff63a05c62def40f8b839f087a60db6ef5172"},{"message":{"validator_index":"313936","from_bls_pubkey":"0x856c75ede282fb092c2c5ce1511945d4eb5026a095e7ebb8ab6a231ef8884390141d100ecc904fdd58b1f2f0e07b1630","to_execution_address":"0x7b06e3416eae7bce95998ef9f0ef1c94b1ce0b70"},"signature":"0xa31249a2500d0428a2b38100b6db1191f1014087af8e58cdc025e28fc9e2aa5f08c74036c1c99b5e6b9f96c250700e2505201e2d4657bff1de53e01ac3c28f2f6624da4e953c9d08b0011e547902197fc5317daa051526f68684f16e1608ff33"},{"message":{"validator_index":"2929187","from_bls_pubkey":"0xaa842a4b0acf1250c953110bfa6025bc646043fc268749af5274dd0197f06eafd7f5ec00e2d21a01b8a420e8178bf74d","to_execution_address":"0xd72e6442af2e4be382d8ae3ec02d59f4278c21e4"},"signature":"0xa29e82672b9b023ec4496bc5ba26cd0e12ae4e168591a2412dc2c62cfbf0466710810999921e34e7249e3a4700c837ec115bb6bee111a50c55a1af9d2f996bb6600a4767e23781cf4eb177845372b39df6156906f9e24c5b908920161a44d8fa"},{"message":{"validator_index":"1161425","from_bls_pubkey":"0xaf50133072b8d7a0ab9318facb15087021cdde3205929004ecae6df99d4cc111517fb629146398eb345a028d413624ac","to_execution_address":"0xfd705842efc5096d6c5e7d95673f828e34921f08"},"signature":"0xa34048285c5a03bac9edfcf306e845a8cc0f8e7f7b4c5590dce0146b30b5a4d6340855b4384b53cc72b4ac5bb9b372590a7f7eca40e78ef3ae9b0e9dfe020abc94d161627ff642df1386143f221aee8ba432f4e7affa7736c65a01e6f342cd4d"},{"message":{"validator_index":"776676","from_bls_pubkey":"0x8671285e05b25760c453c12261a1fe347a2cb3fface5eca837364a24da41645a547999b471acfac8f43989f4f1d7eaa4","to_execution_address":"0xbcbb1d422fbac21d01fc8547ab974f9172b015bc"},"signature":"0x91637965215d68f27949e164adb593958a4e7f451efdc129cf78dc59baba87086bfcd637a0490f2f6c556bb0ae2f39ec114f84c900cd874755732f64b889588ddb0fb445e031dbb708916fe0b23c38f3d465e3b55b0292d31096efe3ad6e556b"},{"message":{"validator_index":"1696950","from_bls_pubkey":"0xb6deeb8bd3ab7aac208e55e1657b6379313f7e77897e6f6f3882c2d84548c94a20fd1b23f4f4bb8a66fd7f5780ca6985","to_execution_address":"0x452056416dc56a4392e03c0bc7c309ce4717f41f"},"signature":"0xa6db392c592dfd0dbe1c60583888a00f93fe400e99d66c06c1b9aa7106f7ec1aeb1fcf6cdfd0cbe0fd22bc578ebe6a7b075676526dcdcd40118961c03b8721f92ca9d3123b21174d5f2d809b40d980593b4da522f95b9de9f4ff4856fb0f6d0e"}]}}} \ No newline at end of file +{ + "version":"capella", + "execution_payload_blinded":false, + "execution_payload_value":"12345", + "consensus_block_value":"123000000000", + "data": { + "slot": "1", + "proposer_index": "4666673844721362956", + "parent_root": "0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef", + "state_root": "0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e", + "body": { + "randao_reveal": "0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71", + "eth1_data": { + "deposit_root": "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f", + "deposit_count": "4658411424342975020", + "block_hash": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + }, + "graffiti": "0x0000000000000000000000000000000000000000000000000000000000000000", + "proposer_slashings": [ + { + "signed_header_1": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b", + "state_root": "0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb", + "body_root": "0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486" + }, + "signature": "0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483" + }, + "signed_header_2": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6", + "state_root": "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "body_root": "0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1" + }, + "signature": "0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1" + } + } + ], + "attester_slashings": [ + { + "attestation_1": { + "attesting_indices": [ + "4585702132744102314", + "4590659586689121994", + "4589007099177470570" + ], + "data": { + "slot": "1", + "index": "4580744678799082634", + "beacon_block_root": "0x17348c3f2ad0733f4b47b34442744b4a2e03a79b1f52c8e8922ee71060a05b1c", + "source": { + "epoch": "533653615", + "root": "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06" + }, + "target": { + "epoch": "538655350", + "root": "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0" + } + }, + "signature": "0xaffb36fe3e48b5c29794f85515b9a3adcd4206fec6dddac6926d0e985d96a9ade0e427f911d56dd90f2644af13e9740509147d149defa9b0763eecba616e0815e9a91c25178860be7d4196a9814781a4576ba7bc6398ef16b9bd5f88c4143bfb" + }, + "attestation_2": { + "attesting_indices": [ + "4585702132744102314", + "4590659586689121994", + "4589007099177470570" + ], + "data": { + "slot": "1", + "index": "4628666713557758827", + "beacon_block_root": "0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390", + "source": { + "epoch": "537693478", + "root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b" + }, + "target": { + "epoch": "538078227", + "root": "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb" + } + }, + "signature": "0xb7720f152c38d7172a82186892a68440bc4d285cc8aa92c1f017f93d5f61a29cf51670e4f944648bd8df82d4d6eae00615073d439389cdf35fbd7670a07ef8407c7c71a16be062fff16f351737ac99f006817ba43a295fe5286dfb4ba7116e07" + } + } + ], + "attestations": [ + { + "aggregation_bits": "0x88e3aeac2cb7509e753b73880be4e95da67b35193a1a8d916d3a5f3b61c59b6d90d866ae7ee81a10a9ea025ade39ad5b978bd20bd2d2031d61e8aa7b5090b08248dbcac0698c25ea7b858ae37e5347010aa764962e4f70513d9e2488a9808d0510dcb3dc9385cc9c28ba4a1eae314e5c3372b3d2387836dc0750553f84b1b490b7fffcb2824b614596050fa2ffed45b30b7db4e67cd782cf0446b5448ed43cb01991cde29c15b0a29dcafdbf29840045c4a3d7e58b93ff391e3ae281185e49aeeed12188548d0dc8e904edc1c8a9831577d08b0c708dbb1784cef981e8363efb46d26f039c2561792d1a2e81218eec593aefaa25bb280fbdd25f8103381a51c601", + "data": { + "slot": "1", + "index": "4615446843529318507", + "beacon_block_root": "0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6", + "source": { + "epoch": "536154483", + "root": "0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0" + }, + "target": { + "epoch": "536539231", + "root": "0x82a81c3f096d065c7e3f5d7df79bd182a53c9471a737cfb9f7c4e9ed95d0f767" + } + }, + "signature": "0xa9aef1e37252740dedc5fc9886810459f7484555aa59fb3876803fc4924149cb471ffbbd9be5324d952efafc3de4c5f705dd02134916b2afa02194fe90a8d1e8f58ebcfe0d33d0b8a97e71a3f7591cb82c37ba531c059a684b581d3857f05e3c" + }, + { + "aggregation_bits": "0x0aa2e4365aad4ec5115dbc42fc6bcda2a0739e4b8c6c07334b99338ec990c7dc93162171b1ed0afe8b1f151348438523b428076a646db8375993d417cd79f1854f796992a8aea702eb3180373e7ff4b4c53ef3b306a5af7f82ba3a4a362af88084e7d166dd0ed5026019cd4f2c4fad16566f927d0dceb14203e8abc293267466c487eb2b108ae043792ff8e8c56e9fbb26d98381ad35e70558cc74f74d1d5a7de764645e15298f90a9a4292e58188deba564756775d54bad38de697be7659cde395c60f403933083c4e71881c26d15c83a61359fbecd1c12d8f31c0d440c128c416e09ee2d3fe64b8a4c737c2f604756d08d8c1f77d4623404e031805797412b01", + "data": { + "slot": "1", + "index": "4549347484797182313", + "beacon_block_root": "0xcf2c053f899b836f534bfa2a45bf23b7be4890b9815a72a2aec9f70eff53d592", + "source": { + "epoch": "528459505", + "root": "0xa8ea103f4904c5e568c52bd49eadfa1cb142929514c9202e53c7707e4a92667d" + }, + "target": { + "epoch": "528844253", + "root": "0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd" + } + }, + "signature": "0x8f5c34de9e22ceaa7e8d165fc0553b32f02188539e89e2cc91e2eb9077645986550d872ee3403204ae5d554eae3cac12124e18d2324bccc814775316aaef352abc0450812b3ca9fde96ecafa911b3b8bfddca8db4027f08e29c22a9c370ad933" + }, + { + "aggregation_bits": "0xd664cfc4f928592f21ca9fae84cd2a15d4acf76e0d2cbb493324ae9cb25757559fc4b060414cbfd84de047d4f04da4aa6669e83b9b8418d348bfc46b3fef684ffbf0162da3c6258f690b14c94cf448280b646c140b24928defd2d12434dbbbd0afbea5e5661fcac8116699ec8a059acf084ab956ab0eaf508ab7d3e4bd352a80f6b8ff73b4b24753a865991c45c9d9f0e1675e7327ccaaeb146bc3d0a4db2d7e607930579fc38a41d5019f222166cea9ebebfe0dd7b875fa612ecb7bb80f83718702da59fd2687d445048ac99f25b5f088fe931ec4bbf9ecdfc169844c00bc69fe38c0110fc59105233b29f6ddecb7968065fd7ef787e41d3545fefe30314fa401", + "data": { + "slot": "1", + "index": "4536127614768741993", + "beacon_block_root": "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8", + "source": { + "epoch": "526920509", + "root": "0x41f3e13e4961bf0c12dd652f3bf49e85e35a8a25c70e67ffc1d08cc01d9921d3" + }, + "target": { + "epoch": "527305258", + "root": "0x51977a3f0ab3110e2a10e9c6bd0e89b1410ca45142ac42171bb2b169efc281bc" + } + }, + "signature": "0xa17225b5e5319618e77f5b93350430acfadd8ae12a279f1a4176cc7ad1de7ecfc8670988519713fbac8f702cca29bddb14ff1463dae3abb53ddb0c025cd69c8cfb0f5298ab241c06ddb840c7a260f3dbd37120826b13b17e22d086148ebdbab1" + } + ], + "deposits": [ + { + "proof": [ + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7" + ], + "data": { + "pubkey": "0x90b2ffa8992560bca2080afa9b3adc904ce9085a8c2cc897282f20378bdf3cdc0a74100f226ea698e07d4afe50d8ff54", + "withdrawal_credentials": "0x9d1b633f8ae18e21ff1b86740b32dbe55a18a0991bcfe5ffd2b6bf8a59465fe7", + "amount": "32000000000", + "signature": "0x978f1439422f6e539e93927a7754e7f9866fbe5832da066bb8fec5041a6818bbfe7e79747a963eec57f76924aeb591d0133ffae96de0793f02d13a13e1f7286a7940e48093ceb832b58e9d6bff9adfc1e8f59367d905633d743cd62ccbd2b27c" + } + } + ], + "voluntary_exits": [ + { + "message": { + "epoch": "4570829775204010570", + "validator_index": "4565872325553958186" + }, + "signature": "0x8c2c3b368bc00b3853e6df352e816dd910016db953ac77cc1565e3c22f1c0b24c59f24ea9e8ca406aa95b23368d163e80baa6de3f8f7ac19ee78c976d2ae5a21c86fa1762cc959bc734379055cb7aa1de36eae00541936b8c2ee908c770d41ff" + } + ], + "sync_aggregate": { + "sync_committee_bits": "0x01000000", + "sync_committee_signature": "0x8166b2ed13e982e6b9f05d30f42681b826099135a533d2614ef5f4f59811714245db0e1821a644859559f97ec1e614bf08b2edb294fa2edc1527f46596399534af23c98613e1b74c01871bf1dd2af9618bc0ba23ddfce8026b897cdbba8c1bce" + }, + "execution_payload": { + "parent_hash": "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "fee_recipient": "0x3624343f893e8948a933c0cfa8787f4e8c309829", + "state_root": "0x49452e3f298a688d9e7627fb7c01941b923397bb84dd548b6e411f9506aed1c7", + "receipts_root": "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "logs_bloom": "0x23033a3fe9f2a903b4f058a4d4ef6a81852d9997184c0317133f980452ec62b2b061e83c58b49a2152d35e2d52dec57a103ce8a251c901ef2fab683582825ff8b0b008f76d24edc9c1ae40d0e75942618263f7d7986e9bccf1329656466d543e00b24a93476cb3f928af4367c6625a9cf341db27bc452836499a1efdd2c9eb5e912927c2878fe39fe1a2b36a44c10572cd0437fa4fd7e83a9db691bfbf5b9fcaeb8b2ea9d2b89eeffc8cf98d5b66f53e527f376d29bf250544a9eeb288757962a5fc0eae509665d2b90702b12b5caa0913916a48e650fd430ceafdde0d71da95ee9ceba330c6cb0412771d5275464afa7adcac63634c91ceb521f22e12b844c9", + "prev_randao": "0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be", + "block_number": "4493163029660118184", + "gas_limit": "4498120483605137864", + "gas_used": "4496467996093486440", + "timestamp": "4488205580010065800", + "extra_data": "0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874", + "base_fee_per_gas": "5451311522429616772243425117521481983710813629341562216088296324789550535380", + "block_hash": "0x1f2e4f3ee8c38dc605677b6ce650a08c7fa6716795a8622d396e244f710e0a5f", + "transactions": [ + "0x58913d3ec8a62b", + "0xcb571a3e876c67", + "0xa415263e48d5a8", + "0xb4b9be3e0927fb", + "0x8e77ca3ec98f3c", + "0x003ea73e885578", + "0xdafbb23e48beb9", + "0x4dc28f3e0884f5", + "0x26809b3ec8ec36", + "0x9946783e88b272" + ], + "withdrawals": [ + { + "index": "4503077933255190248", + "validator_index": "2357271", + "address": "0x42fb7d43b1006df9874a521b12867f80fbfa5084", + "amount": "4868276887351139793" + } + ] + }, + "bls_to_execution_changes": [ + { + "message": { + "validator_index": "1972522", + "from_bls_pubkey": "0x8db8ee645b614f990839e4d98fdbf921263bb62cd917fb4eff9084dff23d7cc453f6cc645ad8b869aa9d31a6b9560630", + "to_execution_address": "0xc8e25443111288db3b1f254bdb430f1c27104a82" + }, + "signature": "0xb0c3172e9bab8d04faa5d27f9818c36ad61a71b114f5bd9dbe77306be3edef2bcb56c215511ba76145006daec95f24be0f1f0dd24377cf7b440b5cdc7d0b520d6b64c539eaacaf14875d49c293af5974751bb0ce2daafde3bd01e097a466e75f" + }, + { + "message": { + "validator_index": "48778", + "from_bls_pubkey": "0x8ba697cdd6f8c34a1fb96a4c88f03360d19515ccc4e1ea24aa5e80075d821059806a0047e6bbf5d908d312d1902aff5d", + "to_execution_address": "0xee24494351a9466526a5f3a1825538b6331648a6" + }, + "signature": "0x87fadfd11bc5612e06c59d576c91599bc21095531fcc27a177967de7b521c377ee7a2b10d0fadf38779089929cfe136518757803c369b4ce94873e28d7d9cdf54c31a53ed86b07f76ea6104ee65d76de02267a4b736c949785ef233cbb73ad4a" + }, + { + "message": { + "validator_index": "2820011", + "from_bls_pubkey": "0xa32a5f28ae7d36f888820160335232fc42ef994b4f93acf6a8659762b2ec52ca79354cc07c73a229b529bfcebc705eff", + "to_execution_address": "0x4a4dca439229167a13e413e752937416aad35d1a" + }, + "signature": "0xa2089742415bdf32fa2dde853661a095ac24d273413687ae04fabb99ae2982700bcdb885d239e32543ffb95763a43e690cb1bf3a33df40d24e12c46d150e9c59dd63f960dec39712dabf74c08a55ba1bcb6db664ff9d5b2261da353e4374466c" + }, + { + "message": { + "validator_index": "896267", + "from_bls_pubkey": "0xb679b4b686530827b2a201eb2b18454e9a5758d7257737b29bb215b9f354c2ff57e912b19d4a051556187aa24c97371b", + "to_execution_address": "0x708fbe43d1c0d403fd69e23dfaa49db0b6d95b3e" + }, + "signature": "0x8da9cee45a3046b209da332512a6b4e4d7c89768f55998eb79ee236b4fb1fbcea87e0bba7b05d19ea7b8c5ea6dc0081e17a7ad0ec41566a0c6d9e127b87691e1d5b823fd178069e3f30091dcdbb44c36408656941755177c45bc976bf270289d" + }, + { + "message": { + "validator_index": "511518", + "from_bls_pubkey": "0x83b8c61b63de768821cbd82ee3c67c81bb848163d6af0186ffe1ca3936d283bb4cab886f3fbc7f6336fec3da8d542c76", + "to_execution_address": "0x92fcc742102977503966d35cb217fc55bd583232" + }, + "signature": "0x8c90298abaed4b5124cff46e41c9a4ed2b2baa0d2089add6b64c70dc7547f1a83bed76aba1fac6d36605beea72734b490b7b98994c7c65fdb436286b0df898731f6ad536e5a603da85ec8cc4488b94dc8c61e11363d1cc18733382dca51c7008" + }, + { + "message": { + "validator_index": "1431791", + "from_bls_pubkey": "0xa532ee397fdd9e388888d90f712e13b085ad5043402debe1caf3dabbb514ed0d06f7c897e4e2795fd018cd672bfa8948", + "to_execution_address": "0xb83ebc4250c035da23eca1b3592925f0c95e3056" + }, + "signature": "0x8fb8cb9373db269dd2a05fe0a07484db022a95b06c03807426a352499fcb65c55f8c388fd4cddbdd9936d5fe5ac5898e0d8b58ae09a73bdc7e584fe9940d3aa967607a0c4a1ad1ce5ccc0ad83f63a273e140ae0510f709cd0c214b645d68e3f4" + }, + { + "message": { + "validator_index": "1047042", + "from_bls_pubkey": "0xb7d85608c3cf919ee72c0481283b468c2825850f6f6028c000cb19bff464556973909667d0353582d673e1049795f20c", + "to_execution_address": "0x778981428fb4ee8ab889aa659e81f2f2087d260a" + }, + "signature": "0xa1079cff71763f60894927a0ac68cfff88642e5ec4e11d1f63ce7d7b15f2567842c80c0238a0f6e4d38ac2a9d09787c50c87daba460e05a0336332f1d37b65fed7526c5eb51a84d3a0169d09ddaf271d13710d22469e8dffde8859d50a2dd0a1" + }, + { + "message": { + "validator_index": "2279280", + "from_bls_pubkey": "0xa46cb4c6f51759dd36e897cf8f5f8a774dbb5968defec8bcd85b9ec0f3d873a6569fabde6c6cf3fa5dc77e910bc39938", + "to_execution_address": "0x3aa93143d0d7c378fbb0904fd1788aea4c2244ee" + }, + "signature": "0x988ea703ce8fcbd5bc7811c49e1eede7061ce461966a9a52f03afdecb157f065a1993fd71ea29c6769121610fc9e3e190eff938fb8c2f77dcf5f511208ad23cf427c05dd207b6c6004ba2a1ee3b6a84949e39db4ef1ee254635d3527010f7794" + }, + { + "message": { + "validator_index": "1894531", + "from_bls_pubkey": "0xa18343c3306dae4ff3c78428069a4ae7876f0ad620219648b99b4bfaeea1d7898df50d508533e756f5903efbdf585076", + "to_execution_address": "0xf9f3f64210cc7c298f4e990115d157ed8b403aa2" + }, + "signature": "0xa120e4f3144799db31e7487d25cbe6d8724f0076f23fdd7ff1f00b24b304a93a97862a3ebecb5e1b91018a0496a3c4020004b5d49571f4b9a3faf0f9d8f1f067d7005b5600db18872732313acf1350e1bec278384f3e0fe28d43f00203ae10e7" + }, + { + "message": { + "validator_index": "2970787", + "from_bls_pubkey": "0xb23734206f673528ad12bad1b7815a9db722d7a5afffdfac97e17d453fcd2616a804619bd9f8db50b9547a357b1f5813", + "to_execution_address": "0x2036eb4250633bb379d46758bce28087974638c6" + }, + "signature": "0x8de01f498b48fd1df0c20529228b7e8616c7bfc35457d392404110e394db4c884dad325363be1f2a83ac383486cdea460e78e89a728ac9464f71dfbc685ac8be3fb9ecb21d67a6c105354c58bfb78f2adf7ee65f5a4d7fbe5989e522b52daccf" + }, + { + "message": { + "validator_index": "2430055", + "from_bls_pubkey": "0xb490d2df5759bb5115690df9aa805cddc1787b17fc3984ec400d03ccd5c6da6dbc54a724816ccf0c86b4b23e4daf0b17", + "to_execution_address": "0x42a3f4418ecbddffb5d058777555df2c9ec50eba" + }, + "signature": "0x909ac7032213a33af76294ec19617f3fd9859bb22201e0502ae7187debe740c5cb0367ef03e944eab7fdc5ab23d303f916904a1ca5f7aadbcfbab89bdd82931dd7ff3e0efdd1135698f54774989ddd6d8ee07bebff863718c927072564a547bb" + }, + { + "message": { + "validator_index": "506311", + "from_bls_pubkey": "0xa2810855686190fded08fbafafc427d3540a58c2b391c0d05a71be7a4d1aff2b4ea501c8e4c1ebb79cb49f1991ada976", + "to_execution_address": "0x68e5e841ce629c89a05627ce1c6708c7aacb0cde" + }, + "signature": "0xa108770fd60463dfc982d8725440e47c54730329420bcf05a969e4937d06e468385b53c4a5f6c69e55a775f358fa0948171dedf3bb0ccc1679280251b7abe4cc644e10b46bcdaddd590951541bda68373c8a8dcbfb86d3cb97822a5dfc21f481" + }, + { + "message": { + "validator_index": "121562", + "from_bls_pubkey": "0x8deafeba9f0184ffa1f3d1422b9d97d6975fc4d5a21df265b48b6e831d6aee5a6236b3d5fb9e03cab1e0795f3dd45206", + "to_execution_address": "0xc40d6a420fe36b9e8d954713eca4442721892252" + }, + "signature": "0xb489851f8a8fd535ee14505b9ae32ab27cd8d5e637236f491f71bfc987316491ef3f1b7670378875580eb247993d82511128502ea093d108730e070bb8c5919b39e78893139b3f1a499e885b15d385073e227d6a4e85ba0413ab9e2481d0b8da" + }, + { + "message": { + "validator_index": "1353800", + "from_bls_pubkey": "0x97e217a0c3c7827753099f05459884b90c0fcc97c4c7b8144b06a29c3787cb2672cc36437d19f5d1a07d175683d345ae", + "to_execution_address": "0xea4f5e424f7a2a28771b166a93b66dc12d8f2076" + }, + "signature": "0x90261b9bbd447453cb0f85f40b0a16dd1f39c09f48b866601f7f7f01a3b5fb3ba84c04b6d6708930c9d174891b68d2bc187b888dba79f8f85ffab9f786bf8f2fe79315714da578940bfaf09e181e3a784c95a906591cf4d6091a7ad45909cf83" + }, + { + "message": { + "validator_index": "969051", + "from_bls_pubkey": "0xb3520fa89ea41f471ce87dc8aed9b9f2c9999ea5c94f6ecbb925c4aa4d139883ddda3647424fdddacad7948e9015934e", + "to_execution_address": "0xa99a23428f6ee3d80bb91e1cd80e3bc46cad162a" + }, + "signature": "0x95365a7224ad80f38191cdc1b726ce0884b032e2acc86bb51019b70dbe7a2b176cb2938cfade8dc4d4e463f5ca125ff60a50f416e050c1dd4a7ddaabe5983052a12a0597bcf16adc1efb4091ebc57563389afd97af6b99bc5fbd805f59a8766f" + }, + { + "message": { + "validator_index": "1889324", + "from_bls_pubkey": "0x843c787e604d000e4415cf369a541fcf9b351327cbd0e56940ba071167c0bff9aaeb005105146152746a0ed76df62bff", + "to_execution_address": "0x32ff5b41cd798bfe9d9dd5dff33af5004014f58d" + }, + "signature": "0x8daefba6498ad8c68f592546366a9e21f0a3e7044297efa3162f7c171b46b73a03ba872e6c7801ab17f5a80f3bcaeaea0f1e0e11a7488603c9e40df1e2d56deb5d087c70e17a1bc626f113ed000514dc2a65857feec2e52539a00142ca88d0f7" + } + ] + } + } +} \ No newline at end of file diff --git a/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockContentsDENEB.json b/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockContentsDENEB.json index d4207a2ed04..928500fd404 100644 --- a/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockContentsDENEB.json +++ b/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockContentsDENEB.json @@ -1 +1,389 @@ -{"version":"deneb","execution_payload_blinded":false,"execution_payload_value":"12345","consensus_block_value":"123000000000","data":{"block":{"slot":"1","proposer_index":"4666673844721362956","parent_root":"0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef","state_root":"0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e","body":{"randao_reveal":"0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71","eth1_data":{"deposit_root":"0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f","deposit_count":"4658411424342975020","block_hash":"0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379"},"graffiti":"0x0000000000000000000000000000000000000000000000000000000000000000","proposer_slashings":[{"signed_header_1":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b","state_root":"0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb","body_root":"0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486"},"signature":"0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483"},"signed_header_2":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6","state_root":"0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26","body_root":"0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1"},"signature":"0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1"}}],"attester_slashings":[{"attestation_1":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4580744678799082634","index":"4579092195582398506","beacon_block_root":"0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c","source":{"epoch":"533461240","root":"0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565"},"target":{"epoch":"538462976","root":"0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650"}},"signature":"0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc"},"attestation_2":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4620404293179370891","index":"4618751809962686763","beacon_block_root":"0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b","source":{"epoch":"538078227","root":"0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb"},"target":{"epoch":"536923980","root":"0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5"}},"signature":"0xa32991816eb9f297553b4732309a4cdba7b33287264611715b0ab3319bca19e581da6e2659912a4e0e94aafc01c488e30ffc96ed14e2a726b9d3c618405ee0bf54bf6ae7f2097465cb27ab8132ec24eb93d3c9159475304082f7f0e452b93b65"}}],"attestations":[{"aggregation_bits":"0xfa79cdb89d0d51c5cdd001b7425c6d726750a9d5f89ade6ed9890ce3a706140c399a5e10c90a819094b65322dac7501f7c75471e69d4567358d8ca75f7c1b3133ebecf006b369a1f36efc5f2b706d5922ff98c58a1825a53a864376658f816600cf021cea843d4396502bb9c74d1510afe26036f89f783b4f5c7bacb6649c46f217a6af835f312d6fa253d2bbc83c07993f4f10de2ed2d952689379dbe4f794c1a1055a6b364d68e038deec9667f576b3b9eca5fcadd6298f181e1edb876efc3d0975ae14ae9a0ad2f1836d4c3f1080a96d8ab7c43b34bb2eda895ff66be698b363cfa4be33da3ec94a1a7a90672fd12c4a59916bb937e78476e4f08e4f4031001","data":{"slot":"4605531939934246443","index":"4610489389584298827","beacon_block_root":"0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b","source":{"epoch":"529421377","root":"0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2"},"target":{"epoch":"529806126","root":"0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd"}},"signature":"0x8f8d16b39e14569aab1b712e5c19ed51afe3600a6b017e8ab432f43a02ee720a733c33ef087d2f3653a9701e8d8a836301655b9195c0373b775c88ba1368e5d55354a70a3096bd26dee29dddbe7a4820e2b1653e84122beacbc01af7d93e6bdc"},{"aggregation_bits":"0x4ac567b296efbf7cf3209e87096a7a1a50fd523400113f917f6584a5a306f06b2d8da9ae858d47ff2594010089838efe41f19a78d9aae27c2ffde26f278b8681db9d091eb72e7cab3e449dfccd46a270693e1f88f197324e57bfd45573315cf9fb60d770937b32f7c0c6ce1581ec51e6b60f71acfde304dc917f2e0aa7872038b7d9140d15f7927c23a0490a74c2b0aca2773fed9217067e4444f9ca93874e4ff8407111c3efdb138b97c6d4957b6a70ec1debb283e3d0eb1cfef068adcffbf057d20fdc339eae03f0fa2613abdde8158a7fc40c3cfd1117eb6f8c4ae21d6b2ab4b57ae9a8653a34451aee6418c0c3609dc937293f5f5b346a7ab1a0d144185101","data":{"slot":"4544390030852162633","index":"4542737547635478505","beacon_block_root":"0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd","source":{"epoch":"527690007","root":"0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8"},"target":{"epoch":"528074756","root":"0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8"}},"signature":"0x90309dd491ae6ed51917dc305a3d4ae68d0a0d4792c7eb59c193bd03605bd94e61cab37502de0ad3e6162bc02427bba80a798b3670d5de82a854094016cc298b265371345c0e3ac49fd44bbb9ba0d4fcea0c1a80cecb60e93921d907e8c48120"},{"aggregation_bits":"0xe8c9759f0840f980ae956b15fc383d992e7d4420d12ba5bf32f669f446ac6fa388e20e5ce96e9266dd98840179d2cde3cabd9a8bafab5dec9c2e89f7f78c989e690548603984803b80c82d7b76443194576a1ce49da5cfe56f56e83b745fb01b5f18ccc86d88f5a22d927e64ff0b8e880893abcddec45b268531c4a0697537dae643a24b1a36432f37d42962553bd39af71f37e0429b81470c11316aa39db074aa3f1df4124e7cb203debed60b885ffb9b27e46a1434e81bbd56566632d0729c0822ac415cbb67f25973667d88e58df9c2f058a0ae7f118c98cc448453b6fbe590363bd17ed62c2f808df61f2a9e593235eeb56db74b9dd15980189a5271468301","data":{"slot":"4529517677607038185","index":"4574134745932346122","beacon_block_root":"0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947","source":{"epoch":"532884117","root":"0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31"},"target":{"epoch":"531729870","root":"0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672"}},"signature":"0x8c40f51a99fce6ebb9a4db5e80d715fff319e7ae523e46afb5d03c000d427e23c7a39e77e2af53851706283c8ca91d680997cb459386fbdff52c4d0ecf498e173717a838a792b210bdffaf476538628584a133899bf30dd5ce7056463b8cd683"}],"deposits":[{"proof":["0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c"],"data":{"pubkey":"0xb1f8f6e731dbf6b4e3265fb857c7190adbfc7e6cc95ce2e8bda72be8b6ea3459f862310a2484c3b0ee33b30920f18c1d","withdrawal_credentials":"0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c","amount":"32000000000","signature":"0xb594382214f5bdd375de66c45e1c61a526c7b73fb166c72433bbd9c2a7ad6881244e61cc6427e0206a50b762a129d8830e8708c55761d61ce9e3b19c1bee13bc55daa13bdb07118efdbf57a588b8a64e6392d14f935e53b68933e3355b35acdb"}}],"voluntary_exits":[{"message":{"epoch":"4562567354825622634","validator_index":"4564219838042306762"},"signature":"0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e"}],"sync_aggregate":{"sync_committee_bits":"0x01000000","sync_committee_signature":"0x919ee45cc18456f6e85da6bc21c2e40f44f9a887932c73ea9ad354f88e56d4ec0a8c396ed143082c8e31d697b877a2a215d2966d91c7beb156bf7ab5777e210012f70dcd5f7657808a82cba51e194be994f917150ebdb9e5c57476f1edb47206"},"execution_payload":{"parent_hash":"0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be","fee_recipient":"0xf8eb5a3ea82ccf3c1be1ac153e3f77f273a07343","state_root":"0xbf886c3ec849316e3b187793c3a4398b6097768d06bd968a54e8d2652d2a75a9","receipts_root":"0xd2a9663e689510b3305bdebe972d4e58669a751fbc85bf448269162e078b2c34","logs_bloom":"0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9f770a36a743c8a3abab61dc439ddc0604dd5015b1ed3835787d9565dee0f3e64b25de4c097defe3001f483a4b6feac22b992cada114bfc709d483b4d94f07bb0a1c4fb9e93ca3c31f4b9683753ba33ffd971777e301367f1edfe6809da491535c711a7877b4c97fd1a756136c412b4f3c4471ba439607333623558a63030f2cb6bc2ba885822672de14ea697d44fbcde134b6909208466be0b4c981658ba30f999c991aca746c3331766af1ee10cbe69624066708ae086999a0a3853eb777b3f9f0455cfd98a98c7719710515b97c596d2b662d353a90206e470c523d4374853","prev_randao":"0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874","block_number":"4491510546443434056","gas_limit":"4489858063226749928","gas_used":"4481595642848361992","timestamp":"4479943159631677864","extra_data":"0x58913d3ec8a62b95e52fb1ee60ebddf392af6e1db902dd5bc3f1eea7003130ff","base_fee_per_gas":"48712354854557871613352262057776104244427151172201944877932608112921551169417","block_hash":"0xcb571a3e876c6732a4c11cf3562059c2b8c16889ffb6d1b8d5f883591e767c3f","transactions":["0xb736203ee72088","0xc7dab83ea972da","0xa198c43e69db1b","0x135fa13e28a157","0xed1cad3ee80999","0x60e3893ea8cfd4","0x39a1953e683816","0xac67723e28fe51"],"withdrawals":[{"index":"4864971916622804241","validator_index":"2164897","address":"0x09988f43d11dcf2aa7811c9997eb4119e8f153ce","amount":"4866624404134455665"}],"blob_gas_used":"4858361979461100433","excess_blob_gas":"4856709496244416305"},"bls_to_execution_changes":[{"message":{"validator_index":"625901","from_bls_pubkey":"0x8b772ee4cbcc67f534f33102671346cc3d0ddecc1a81f0350f68dd3210681c9e4bf907b49211cbd390bfadc7f285214a","to_execution_address":"0xb5c15a4371c6a89646dcbd1f07bbfa4e210d4bf0"},"signature":"0x85cc5356a9646f0ffd512b7d2e7d3242c81303a415e61b490d28635896aef1f2db03ae8a1439908d03cc131515ef83f003dd7b36ce480c43f4495ffd339b2b9d1e5461309a02ce193202f27d216a4f0e13f7b47295f3e1a44c8f0e8ae8e1e5a8"},{"message":{"validator_index":"241152","from_bls_pubkey":"0x8183f3f5071394e20f83599fe297dfda37f77a040362da8f8fe926a451eb9cfd917e953c51b81619f8e4925fa6177b49","to_execution_address":"0x10eadb43b24678ab331bde64d7f836af97ca6064"},"signature":"0xa19b99131e621d31846245039e99d6540418acc08844a3996544cca2d9965f8a24cc49cf695bd78959a784e1b5646b480b88aec749a62ea934ed3001af50bb8babfb15bb9df1f3d57abd738f65de02b77398c82302f500218675cd96ee3b2357"},{"message":{"validator_index":"1473390","from_bls_pubkey":"0xa83cbdf40e5c4bdb4e9802d94d765c70150d9926521b0ec4d273e788b83a9f304694e75d2e381ce631b24121ffecc9d4","to_execution_address":"0x372cd043f2dd36351da1acbb7f0a6049a4d05e88"},"signature":"0x998cb975f863e95fd53ee74c5beb85c19b8b3858773432a371e6a3f229f67b653165adf3bbaa6015dec12a1d13cc9d5c080915c55c921fb056fd32e9da643d96dcbe83ccd456b3072dce2610d7b96e69488468c83d26b7251a466571a5424351"},{"message":{"validator_index":"1088641","from_bls_pubkey":"0xa7f8aff7b912b6363efb810f2b661643624ab914b034e78d72397ef84fa04862dee94c9b2f46b872fe852f197f558fce","to_execution_address":"0xf676954331d2efe5b23eb56dc3622d4ce2ee543c"},"signature":"0x94773ae9e3d605ba2612dbea934955e7af438154f7572136c97bc3f858144ab833aa7bf6caee2a2c4ad066d36b1d0c3501359ff577de486f81a5210258cf63ff45bb0cf91526eca949dfee984c6757a957f9c7ddfb8b599d3cfbec0b778e9396"},{"message":{"validator_index":"2008914","from_bls_pubkey":"0xa6c59055cc0bed5baf1a815f59d9d1cbd7aba1a4fb8d83de7310ad85640524318110a6a16f5bc141a81c34e103d9b7be","to_execution_address":"0x7fdbcd4270dd970b44236c31de8ee788b75533a0"},"signature":"0xa28a524424e49283f416545acfa1dc063866bfe9892c60370705cd8133fa949d724421b1ffff5a757d573391ab2cd9fb043022aa8354e4e93c91d126cb40f9ca7f7be8e8293be5a97b0eeb79df9c051f90e4d97c9157efd9b64125cddfc257f3"},{"message":{"validator_index":"1624165","from_bls_pubkey":"0x83190d18858cb148b28aa89911959562dca6653f220f8b4878a5d580958dbb3ca184d97880f7c2bf0fa970cd41b70dce","to_execution_address":"0x3e269342afd150bcd8c074e323e7b48bf5732954"},"signature":"0xb469d5c6626f1c42e7e914ecaf79388360d2ad196f2edc1f7b6088422b4f32f43f36b12898bcccc46c5ed15285ff0cd503f0ba5f6def9b4c1e523e941f1de95263bcdb014637c359464eb2cb974e06faa164827b21ee15dd68b2375b7e76a700"},{"message":{"validator_index":"2700421","from_bls_pubkey":"0xb7ff61729743df75a8b0b7e5b95617b9aa407e2e6a30cd8101c6a4c851b2cc366cb80e68a19a23e19625a596fdd1ec61","to_execution_address":"0x64688742ef680f46c246433acaf8dd25027a2778"},"signature":"0xb29e4c2b22ba8da0947be521fd1710125a95d9465632c3d2b5cffafe6e7070f4a6bd71385760b2b1670add9981225a18060be73e5f486535919fd3577b7ed850b3108dfa0fcc9215cd9d526295616e09619e07977ac7208edc5a2af93835a18a"},{"message":{"validator_index":"2471654","from_bls_pubkey":"0xab0a4039f2f00ce09018af228a696b7b87c7bfc111e7782bf7a3ffb423c681c04fe335152668abc7d20b6e9a9bc4933d","to_execution_address":"0xc090084330e9de5aaf85637f9a361a8678373dec"},"signature":"0x90f650befec00b055e261a38b4ea0bc65a0d71fd735b46f8387f565fb0d31494f90645c40dc07b0f3ee26d7807b82bd914d4d7c81b3ffeaf9a32730ab7cba7265dd09a0e0f94ccdf2ff3bc53d49fe99a488cf7238200ae12e6c59960e71d5877"},{"message":{"validator_index":"547910","from_bls_pubkey":"0x83e4d3825bf069cd0b19ca5072eda2f7d141de02c9e65f9c0733c18252c1552cda074eb613e1f435a880262de2a4672f","to_execution_address":"0xe6d2fc4270809de49a0b32d641484320853d3b10"},"signature":"0xb9b292bb598db604142750cb641cc511a9081656efb8271132d7e0de30554dfed4b16e418100d9085951c1502d6ab657179da8804cb08f1c69b1210ce94bdf6a0b66976233a34a0acfb4b947cdc192cdbb8576a3453e50143e7afecc8cbd264e"},{"message":{"validator_index":"163161","from_bls_pubkey":"0x86c03ea323e3551ef39c8c4e5355c4d3a2cceea3c8acb3d947b39e245d2ffcab53b4479c670d8b268828fd4fee89eae7","to_execution_address":"0x08400642aee83f31d60723f5fabaa1c58bbc1104"},"signature":"0xb58eaaba3ba51d7098d65fbec3829ace78576a2276fd9c97c293aabdb634a2c50f52611f48088da5d4a5b5fa2c5f4c0513d8dd91c8534b50a7b8ae0072583612610ada0c81a261641c66ac542428cedf20f1b954ad03505fc058b40ce0bf4182"},{"message":{"validator_index":"1083434","from_bls_pubkey":"0xb54bda7a570f90c2d38e836a3a256a6a2230a6384a29af7dacac3eff1a981d3f50918e2b546b3d78e72a545870b5ec9e","to_execution_address":"0x2f82fa41ee7ffebac08df14ba1ccca5f98c20f28"},"signature":"0xb851b39a32955a7f05acd7707c6859df4ee2b1472996d6a805a61e14415db550a92a7eaaff14a67e858a9d3633306efb12a62ed84f76387a84deefe726afcf2fb744f616f67d144411689343e6e0dea7a88b57449b2cdecb43cf0b5a80887550"},{"message":{"validator_index":"698685","from_bls_pubkey":"0xaa3588a5cb0b5d8eadd316046b661044c97559a4350464e338456c5b728880b4750b94af5fcaf478e3bbc86ac3e12d0b","to_execution_address":"0xeeccbf412e74b76b542bfafde5249862d6e005dc"},"signature":"0xb99cdab802f2f2683fabc52c8ea095386730c43694a9a5f7a42033e6dea53f4896092b207f56b1402c5c69937a3e2fb41958e001895bb43c2ee1e360da601e1ac56ffa8bd5371b1dcfe85518f297f94c02cd4981a5961201d2c2fb4d2a15c888"},{"message":{"validator_index":"1930923","from_bls_pubkey":"0xa55017fe14158ad9caf1d11f971b71b1941799466d063c6c77d7e41e20d5b74fd7fbf969243f3f507f8c04a5f76c3722","to_execution_address":"0xb1ec6f426f978c599752e0e7181c305a1b8623c0"},"signature":"0x917311e1a5f7a689ceee1af61f06519a3e4c6d68a4af6f4d24da0f57a2246c963c964d0e576607222856258c0e34b0b1014b68dfe481454ceaf521bc6f87c15e6a21f6db1c303b2042d5857ad4506f00dcfdfc5e65bbaf1b4ee9fe7ddf7b738e"},{"message":{"validator_index":"1546174","from_bls_pubkey":"0xaa865744dac51436c21adc2a1373eb6b8d407fda20bc67492d80a43812dd2aedee636192b1fa742570ffc2833ec58b29","to_execution_address":"0x70373542af8b450a2cf0e8995d74fd5c59a41974"},"signature":"0xb875609f4aa01bb03c08b4f13459fa7696b969fc5e8440c89f690478820b8b5b4ad75e7fbf03c4b0e919cdc80b07857604bd81f75128f2bbc61861d0b5a7744e21eb4ad008f05b46be2c2780900a7913abc2cd3591390f29e05e2d5b2dba570b"},{"message":{"validator_index":"2622430","from_bls_pubkey":"0x99c16f59ffb2e2138feb9b6f1804752cdbfe3796e20c52a3ae489f8348df4c1a9614cb6ce6860bed51544aaa1d22cc80","to_execution_address":"0x96792942ef2204941676b7f0048626f766aa1798"},"signature":"0xb9196e6383fe7a9eac1809c48fe10e45ddf57d6ee7946c22d48873b45064a39e66f861d7b36d82699f4b1858c3ef093f13fd758af1ff4deb2b7e1ffc7a7179306726cc556abddafee546ed2a6d7c4b17a1498494d994ff4188a2edf3c261a683"},{"message":{"validator_index":"2081698","from_bls_pubkey":"0x9786334738ef86988505249871273257e40b3e3c47995e751a40a52bc46f915fbaab7e2b1802ca3dcbf2db0567e8c9ae","to_execution_address":"0xb8e632412d8ba6e05272a80fbcf8849c6c29ee8b"},"signature":"0xafeb0dbcb7463673415ae2897857e5b13c4299ee60273bbc406c38f4e805cf7bc147ad40d7873740f3d261bd592574e618efe8f93cf439d13db8b86ff91918c57578b1080c6e51cf121d816eb3e5a2003ad57799d24f1ddbe495724d9e5a292d"}],"blob_kzg_commitments":["0xf14921410d6e44af323bde913793c2037f32eb41f938cabb3c5db5168485eeb88923ac822543db013af49d53be186cc8","0x046b1b41adb923f4277e45bd0b1cd7d08535ead3b001f37569def8de5fe6a543214372e11fa4bbef810ce1ff85e0cfae"]}},"kzg_proofs":["0x3ece09418d9cc1c206477b3f86b61438983ee789d35b6da4f361c337ee08cce3e8a1c4fd0fc75cb95755aa04da37fb61","0x51ef03412de8a007fc89e26a593f29059e41e61b8924965e21e30600c869836e7fc18a5c09283da79e6dedb0a2ff5e48"],"blobs":["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","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"]}} \ No newline at end of file +{ + "version": "deneb", + "execution_payload_blinded": false, + "execution_payload_value": "9074003755965027577898412849272089981780862548198517622930893380413065004589", + "consensus_block_value": "52335047088093692175629908587741169571103578927521980677976976500308305025762", + "data": { + "block": { + "slot": "1", + "proposer_index": "4666673844721362956", + "parent_root": "0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef", + "state_root": "0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e", + "body": { + "randao_reveal": "0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71", + "eth1_data": { + "deposit_root": "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f", + "deposit_count": "4658411424342975020", + "block_hash": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + }, + "graffiti": "0x0000000000000000000000000000000000000000000000000000000000000000", + "proposer_slashings": [ + { + "signed_header_1": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b", + "state_root": "0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb", + "body_root": "0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486" + }, + "signature": "0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483" + }, + "signed_header_2": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6", + "state_root": "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "body_root": "0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1" + }, + "signature": "0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1" + } + } + ], + "attester_slashings": [ + { + "attestation_1": { + "attesting_indices": [ + "4585702132744102314", + "4590659586689121994", + "4589007099177470570" + ], + "data": { + "slot": "1", + "index": "4580744678799082634", + "beacon_block_root": "0x17348c3f2ad0733f4b47b34442744b4a2e03a79b1f52c8e8922ee71060a05b1c", + "source": { + "epoch": "533653615", + "root": "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06" + }, + "target": { + "epoch": "538655350", + "root": "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0" + } + }, + "signature": "0xaffb36fe3e48b5c29794f85515b9a3adcd4206fec6dddac6926d0e985d96a9ade0e427f911d56dd90f2644af13e9740509147d149defa9b0763eecba616e0815e9a91c25178860be7d4196a9814781a4576ba7bc6398ef16b9bd5f88c4143bfb" + }, + "attestation_2": { + "attesting_indices": [ + "4585702132744102314", + "4590659586689121994", + "4589007099177470570" + ], + "data": { + "slot": "1", + "index": "4628666713557758827", + "beacon_block_root": "0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390", + "source": { + "epoch": "537693478", + "root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b" + }, + "target": { + "epoch": "538078227", + "root": "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb" + } + }, + "signature": "0xb7720f152c38d7172a82186892a68440bc4d285cc8aa92c1f017f93d5f61a29cf51670e4f944648bd8df82d4d6eae00615073d439389cdf35fbd7670a07ef8407c7c71a16be062fff16f351737ac99f006817ba43a295fe5286dfb4ba7116e07" + } + } + ], + "attestations": [ + { + "aggregation_bits": "0x88e3aeac2cb7509e753b73880be4e95da67b35193a1a8d916d3a5f3b61c59b6d90d866ae7ee81a10a9ea025ade39ad5b978bd20bd2d2031d61e8aa7b5090b08248dbcac0698c25ea7b858ae37e5347010aa764962e4f70513d9e2488a9808d0510dcb3dc9385cc9c28ba4a1eae314e5c3372b3d2387836dc0750553f84b1b490b7fffcb2824b614596050fa2ffed45b30b7db4e67cd782cf0446b5448ed43cb01991cde29c15b0a29dcafdbf29840045c4a3d7e58b93ff391e3ae281185e49aeeed12188548d0dc8e904edc1c8a9831577d08b0c708dbb1784cef981e8363efb46d26f039c2561792d1a2e81218eec593aefaa25bb280fbdd25f8103381a51c601", + "data": { + "slot": "1", + "index": "4615446843529318507", + "beacon_block_root": "0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6", + "source": { + "epoch": "536154483", + "root": "0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0" + }, + "target": { + "epoch": "536539231", + "root": "0x82a81c3f096d065c7e3f5d7df79bd182a53c9471a737cfb9f7c4e9ed95d0f767" + } + }, + "signature": "0xa9aef1e37252740dedc5fc9886810459f7484555aa59fb3876803fc4924149cb471ffbbd9be5324d952efafc3de4c5f705dd02134916b2afa02194fe90a8d1e8f58ebcfe0d33d0b8a97e71a3f7591cb82c37ba531c059a684b581d3857f05e3c" + }, + { + "aggregation_bits": "0x0aa2e4365aad4ec5115dbc42fc6bcda2a0739e4b8c6c07334b99338ec990c7dc93162171b1ed0afe8b1f151348438523b428076a646db8375993d417cd79f1854f796992a8aea702eb3180373e7ff4b4c53ef3b306a5af7f82ba3a4a362af88084e7d166dd0ed5026019cd4f2c4fad16566f927d0dceb14203e8abc293267466c487eb2b108ae043792ff8e8c56e9fbb26d98381ad35e70558cc74f74d1d5a7de764645e15298f90a9a4292e58188deba564756775d54bad38de697be7659cde395c60f403933083c4e71881c26d15c83a61359fbecd1c12d8f31c0d440c128c416e09ee2d3fe64b8a4c737c2f604756d08d8c1f77d4623404e031805797412b01", + "data": { + "slot": "1", + "index": "4549347484797182313", + "beacon_block_root": "0xcf2c053f899b836f534bfa2a45bf23b7be4890b9815a72a2aec9f70eff53d592", + "source": { + "epoch": "528459505", + "root": "0xa8ea103f4904c5e568c52bd49eadfa1cb142929514c9202e53c7707e4a92667d" + }, + "target": { + "epoch": "528844253", + "root": "0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd" + } + }, + "signature": "0x8f5c34de9e22ceaa7e8d165fc0553b32f02188539e89e2cc91e2eb9077645986550d872ee3403204ae5d554eae3cac12124e18d2324bccc814775316aaef352abc0450812b3ca9fde96ecafa911b3b8bfddca8db4027f08e29c22a9c370ad933" + }, + { + "aggregation_bits": "0xd664cfc4f928592f21ca9fae84cd2a15d4acf76e0d2cbb493324ae9cb25757559fc4b060414cbfd84de047d4f04da4aa6669e83b9b8418d348bfc46b3fef684ffbf0162da3c6258f690b14c94cf448280b646c140b24928defd2d12434dbbbd0afbea5e5661fcac8116699ec8a059acf084ab956ab0eaf508ab7d3e4bd352a80f6b8ff73b4b24753a865991c45c9d9f0e1675e7327ccaaeb146bc3d0a4db2d7e607930579fc38a41d5019f222166cea9ebebfe0dd7b875fa612ecb7bb80f83718702da59fd2687d445048ac99f25b5f088fe931ec4bbf9ecdfc169844c00bc69fe38c0110fc59105233b29f6ddecb7968065fd7ef787e41d3545fefe30314fa401", + "data": { + "slot": "1", + "index": "4536127614768741993", + "beacon_block_root": "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8", + "source": { + "epoch": "526920509", + "root": "0x41f3e13e4961bf0c12dd652f3bf49e85e35a8a25c70e67ffc1d08cc01d9921d3" + }, + "target": { + "epoch": "527305258", + "root": "0x51977a3f0ab3110e2a10e9c6bd0e89b1410ca45142ac42171bb2b169efc281bc" + } + }, + "signature": "0xa17225b5e5319618e77f5b93350430acfadd8ae12a279f1a4176cc7ad1de7ecfc8670988519713fbac8f702cca29bddb14ff1463dae3abb53ddb0c025cd69c8cfb0f5298ab241c06ddb840c7a260f3dbd37120826b13b17e22d086148ebdbab1" + } + ], + "deposits": [ + { + "proof": [ + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7" + ], + "data": { + "pubkey": "0x90b2ffa8992560bca2080afa9b3adc904ce9085a8c2cc897282f20378bdf3cdc0a74100f226ea698e07d4afe50d8ff54", + "withdrawal_credentials": "0x9d1b633f8ae18e21ff1b86740b32dbe55a18a0991bcfe5ffd2b6bf8a59465fe7", + "amount": "32000000000", + "signature": "0x978f1439422f6e539e93927a7754e7f9866fbe5832da066bb8fec5041a6818bbfe7e79747a963eec57f76924aeb591d0133ffae96de0793f02d13a13e1f7286a7940e48093ceb832b58e9d6bff9adfc1e8f59367d905633d743cd62ccbd2b27c" + } + } + ], + "voluntary_exits": [ + { + "message": { + "epoch": "4570829775204010570", + "validator_index": "4565872325553958186" + }, + "signature": "0x8c2c3b368bc00b3853e6df352e816dd910016db953ac77cc1565e3c22f1c0b24c59f24ea9e8ca406aa95b23368d163e80baa6de3f8f7ac19ee78c976d2ae5a21c86fa1762cc959bc734379055cb7aa1de36eae00541936b8c2ee908c770d41ff" + } + ], + "sync_aggregate": { + "sync_committee_bits": "0x01000000", + "sync_committee_signature": "0x8166b2ed13e982e6b9f05d30f42681b826099135a533d2614ef5f4f59811714245db0e1821a644859559f97ec1e614bf08b2edb294fa2edc1527f46596399534af23c98613e1b74c01871bf1dd2af9618bc0ba23ddfce8026b897cdbba8c1bce" + }, + "execution_payload": { + "parent_hash": "0xd67e513f6ac42cf0dfe4bbf686cc184d6c219d4f3e29602e5b3a8ae3e8688587", + "fee_recipient": "0x3624343f893e8948a933c0cfa8787f4e8c309829", + "state_root": "0x49452e3f298a688d9e7627fb7c01941b923397bb84dd548b6e411f9506aed1c7", + "receipts_root": "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "logs_bloom": "0x23033a3fe9f2a903b4f058a4d4ef6a81852d9997184c0317133f980452ec62b2b061e83c58b49a2152d35e2d52dec57a103ce8a251c901ef2fab683582825ff8b0b008f76d24edc9c1ae40d0e75942618263f7d7986e9bccf1329656466d543e00b24a93476cb3f928af4367c6625a9cf341db27bc452836499a1efdd2c9eb5e912927c2878fe39fe1a2b36a44c10572cd0437fa4fd7e83a9db691bfbf5b9fcaeb8b2ea9d2b89eeffc8cf98d5b66f53e527f376d29bf250544a9eeb288757962a5fc0eae509665d2b90702b12b5caa0913916a48e650fd430ceafdde0d71da95ee9ceba330c6cb0412771d5275464afa7adcac63634c91ceb521f22e12b844c9", + "prev_randao": "0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be", + "block_number": "4493163029660118184", + "gas_limit": "4498120483605137864", + "gas_used": "4496467996093486440", + "timestamp": "4488205580010065800", + "extra_data": "0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874", + "base_fee_per_gas": "5451311522429616772243425117521481983710813629341562216088296324789550535380", + "block_hash": "0x1f2e4f3ee8c38dc605677b6ce650a08c7fa6716795a8622d396e244f710e0a5f", + "transactions": [ + "0x58913d3ec8a62b", + "0xcb571a3e876c67", + "0xa415263e48d5a8", + "0xb4b9be3e0927fb", + "0x8e77ca3ec98f3c", + "0x003ea73e885578", + "0xdafbb23e48beb9", + "0x4dc28f3e0884f5", + "0x26809b3ec8ec36", + "0x9946783e88b272" + ], + "withdrawals": [ + { + "index": "4503077933255190248", + "validator_index": "2357271", + "address": "0x42fb7d43b1006df9874a521b12867f80fbfa5084", + "amount": "4868276887351139793" + } + ], + "blob_gas_used": "4866624404134455665", + "excess_blob_gas": "4858361979461100433" + }, + "bls_to_execution_changes": [ + { + "message": { + "validator_index": "818276", + "from_bls_pubkey": "0x94e2d4cf94fb757578c496885af2075c26e2483eeffa6e894ac791f7c1945b0fbf9a6f7860736db93e03d511c4b08516", + "to_execution_address": "0xa2a06043d17ac951519956f43432e6811a0a4c5e" + }, + "signature": "0xa8b4b8e92e67565ec430f2fdda94ed0f6f06d8cb302770191d614b795d194e4728c11e72162f25e04d0f7dda1dcd54da0d8a7c39e71e945873168ffa294da70dd1acbc1902a2fb1598267df5d277a0f95592967ea222ab0706571001c315eb2b" + }, + { + "message": { + "validator_index": "433527", + "from_bls_pubkey": "0xa5041469fc5f6a944fda64e7ab422c1479ab9d0de12a2f3ac7292dfe368408cbc6d2b0ff519b521427da731e7378806e", + "to_execution_address": "0xfdc8e14312fb98663ed87639047022e291c761d2" + }, + "signature": "0xb66c9d2c80f5a12930f0899b9ff3d1a6a37e0f9edb279ced767eca8ef0380227681b15bd3850a00a383491ed1d8e869310f10edea2b912278e1e2ec1cfaaba8c0981af2e40fd233a9fd2f67ec56540c66e062212ee2781593a4714914e15cb52" + }, + { + "message": { + "validator_index": "1665765", + "from_bls_pubkey": "0x9105e2e35c7861d3fee37cb3bf07e8fdf3e0911d251cb11b956d4edbbd62a951c7ac9854677ce19a7748a503c307028c", + "to_execution_address": "0x240bd643529257f0285e4590ab814b7c9dcd5ff6" + }, + "signature": "0xb3b0b28bedcc6e28d433c2a577204a9f7ecfc2fd4e3067ddcb65caebf7fd32d0389dd1db836600b0ee19a2ac8b6d0a660788a42abfde02bd5bddfdbe8cdde83a890ce69ee178ea314cfd9c06e5507ffe5cc4a685004f955219fcbbbec6fdd144" + }, + { + "message": { + "validator_index": "1281016", + "from_bls_pubkey": "0xaae4f1779eb7e006a9d0195e39af1f14a05b017a4a351ee1f3c22929929fb510cae4ba8e01b6d2444a66e388e655d92c", + "to_execution_address": "0xe3559b43918610a1bdfb4d42efd9187fdceb55aa" + }, + "signature": "0xa3acdd589f44c5b4201ae54cd119add73b60bcaca91f9e5d028669dd9b52f3ce15c20bb0ec39ff9ddfe96d5c1ce979c10376d36f4840a04cd90ed9d4348fa4a53f0f00e35bfab055a102ce3b6306255ffba3ef9ce7e1548048139d574478ebbf" + }, + { + "message": { + "validator_index": "2201289", + "from_bls_pubkey": "0x842bb38ef27bafce4e8aa9abd3e31286da4d36eb87ff6a2fc4de272e4878230a7ac7a723bf3f76101ab2c2a642550eff", + "to_execution_address": "0x6cbad342d091b8c64ee004060b06d3bbb052340e" + }, + "signature": "0xabd643eedb5dfcc8f2db27bcfd59f6359517cec81ab4d5ff08bd5fd246ba120883c047e0cffc1d215104169a335628180df5779f128772f899546fd260328d4a4368a044c3e2037f4284624728dc94e05467b1559aad3077cf9557bf62fc56e2" + }, + { + "message": { + "validator_index": "1816540", + "from_bls_pubkey": "0x990cf4f3bf6ede0aaef3010026465f98f381860535ce007b87879afbf2c955c13d07d7c2d91e22fddd8ef5531f8bd22c", + "to_execution_address": "0x2b0599420f867177e37d0db84f5ea0beef702ac2" + }, + "signature": "0xac8ebc3beb6cfc97c27f286e0d2e582707cbcb972d0898a41831b2d1393a684ce54ce54dc9128dc3988930ae4d92b4ed0a51b2bf639d8fd8e62e40ceac222362d9bb67f9d1b8419f3123dac1bb2e4e0cccb5c7c0985c83bd0501ed610935aa96" + }, + { + "message": { + "validator_index": "2892795", + "from_bls_pubkey": "0xa0695f8f6f65e3d8401e144eb382eaed73f9ec56be6de71dadb917af79a08ff7b74967dd4f4766ed77f7bc2fc01cfa38", + "to_execution_address": "0x51478d424f1d3001cd03dc0ef66fc958fb7628e6" + }, + "signature": "0xa18c2c70d886e11a592393a7bef6fb3a515100e1436763854eb96fca9c031a959e4c105be367a10ea87c3d1a8bce821303470a1d6053cd89139bbd86fd7bbdd3e377b331884bedb0f9b10eafcb3272561fc5d71b96b219d7fe3aacd6e1558c97" + }, + { + "message": { + "validator_index": "2664029", + "from_bls_pubkey": "0x97e268878248299c9e4d2c86957935d6cddb83900dbb6d4e52a935bcda58978f6fd33e0dc891cea14da0feafd5173762", + "to_execution_address": "0xad6f0e43909dff15ba42fc53c6ad05b972343e5a" + }, + "signature": "0xa2010187045aa6d63130c7ff23464438af57c3e42eaa90823205936a94c47713b68bd93d3b6837947e277ece630a6d200d428979548f340f6f71ca33e8731e059a8c20f75d71d36caebbbf6fde28f37a919353dedb7b7c7e4dbcda553e5bbee5" + }, + { + "message": { + "validator_index": "740284", + "from_bls_pubkey": "0x8aec1b1f595063af33939f3c3322ad38d2e1de1b11fbc8a9d04235dc7fc9792e1c88e51452d337855d254a71f42816e8", + "to_execution_address": "0xd3b10243d034be9fa5c8caaa6ebf2e537e3a3c7e" + }, + "signature": "0xa0ba14bb9ce5877d9f9d607da9b2fd2d629a1de42d6d3beb5a8f4c1661aa1d6863e01de14c548be8a9df222efc6373be1290581da81c76d71bfada1d07481d7b7de94290efd640aadca41d6b4d4f81091f4c459b454bd6e333eaa35c60faacf5" + }, + { + "message": { + "validator_index": "355536", + "from_bls_pubkey": "0xa912f4ad989d87e777e45af7c265b430daf0b39345987506d4158cdee406847f294fc7745154eb52abf0934a5e1866ee", + "to_execution_address": "0xf51e0c420e9d60ece0c4bbc926328df885b91272" + }, + "signature": "0xa7f77c7fc98b1c3a364dcac68b5cff112f7745e6dd41918ba56a6fa6945507e0ce245334e22d4581f49bda913baa2a6b1176b44d52168151b3aff9a625dcdebad1899747c42c4a43cf31f49124fc0d4543e4485592c243c5300b79214398b770" + }, + { + "message": { + "validator_index": "1275809", + "from_bls_pubkey": "0xa77e90361be2a534a386cb689d6d763a98bea5f23f325b553a762648668e4adb4991fb5f41ad7ece1578f082a5c01b5e", + "to_execution_address": "0x1c6100424e341f76cb4a8a20cd43b69291bf1096" + }, + "signature": "0xad188010cb0db88e067c2699030353a1c215ae9adf083916ee2069a805e0f2cd00c76db9250a859106dbbff4430b4dd114d6293c4b3c2e9cfd31f07949f04e53f63423a08b56d7247772d07959d5d92b17bd8c7c0b294b71d3db903d56509177" + }, + { + "message": { + "validator_index": "891060", + "from_bls_pubkey": "0xb4582d56f8ad9dcc77eb5413558e63a6b562e42534c579a85384e7d7d6ff8974ff933d05a444c1d2784945f4cd1c952e", + "to_execution_address": "0xdbabc5418e28d8265fe892d2129c8395d0dd064a" + }, + "signature": "0xa7f07c5a20159b029b2dac119315a0d439c541e63b0d1f6d377fd2867e5559d6b6302eb609d5796fab97cbca121ddf400c840b9ffa60dbcd89c6d441f84aff2cca1f68fd9e258a969b0d511ad1d90c0c783dde3c093ee8cd56cf6f70a61fd77a" + }, + { + "message": { + "validator_index": "2123298", + "from_bls_pubkey": "0xa5849044acc283563bd9b40fe9b01a8c079093829fc3837cddf20a8f9c13e59629251481406f415c8e2df65285ddb41f", + "to_execution_address": "0x9ecb7542cf4bad14a20f79bc45931b8d1483242e" + }, + "signature": "0x81df97c3071aac41af79494001a1c4404b5121776a71d6cbe3b8eef000e803f59edd2fff33331d2ea037faa919ddd6a115e09bead88d7c8f23368628f306e3a244f2ce0a54e4472d29e4b79eced6da3e5ab40177e96fa0d94d97f5e07d2e6e95" + }, + { + "message": { + "validator_index": "1738549", + "from_bls_pubkey": "0x9815cccaf23783a4b1bfa265d2d620e70c76b50b32e1975b909ddc3749fcca44d97e3e7e717a1f2979c3d1e4a70c1ccc", + "to_execution_address": "0x5d163b420f4066c536ad816e89ebe88f53a11ae2" + }, + "signature": "0xa4fb80ffdea501d608a5e79ed05fd3ff67d39963afeff1b2e0be94811c3497f8b615af4a16e438e23e8cc6c34376a514169ba117403d86a2ebeb85ca0bd638e63ca982ee45c8350d726f228ac03eb8fb584fcc56e8d3877a3756cbb06a7aad43" + }, + { + "message": { + "validator_index": "2814804", + "from_bls_pubkey": "0xa6e3b4975aa42a8e0f86af69da109dfc42eae539bc7bce0be20f733b1fb15107bc42eda74c8788c1feb0aae542a6fd17", + "to_execution_address": "0x83582f424fd7244f213350c530fd112a5fa71806" + }, + "signature": "0x8d5a3a8aded5a58f952ac7bae812991f1b285e1704e87ef9fd8a743aeca8dd30ed7710a1b6c31a1860768704e6ac709316d5e7002605470c7fcf4b2c691f8a897c900cc60e9618daf83af929b7e8474e7f71bd996427c256691c9b90581b1264" + }, + { + "message": { + "validator_index": "2274073", + "from_bls_pubkey": "0x8d2a58c4d8939845fbbdb04c560d5eb57cca82d7dfed86580867df9faffd4bf8139bffdd1dc92555e6325e18d57afaa3", + "to_execution_address": "0xa5c538418d3fc79b5d2f41e4e96f70cf6626eff9" + }, + "signature": "0xaead124a78a24d0bf0a4a7d20c8c4f34e92899d925eb47750d683c474093f4d5a5af0ab36598838b149c0c348bab313e0079198921f7df6009c7e02db76b077b2541c12b71c70cc93b80ee4e150b2ad10ec6ecf6086bb8f70e9b49e4f708946c" + } + ], + "blob_kzg_commitments": [ + "0x92a43e41edf3e75667ecd9b815e75b026023f067694dfe1857d7632d40a159039385cda8415e795cd67a4ef6da317948", + "0xf14921410d6e44af323bde913793c2037f32eb41f938cabb3c5db5168485eeb88923ac822543db013af49d53be186cc8", + "0x046b1b41adb923f4277e45bd0b1cd7d08535ead3b001f37569def8de5fe6a543214372e11fa4bbef810ce1ff85e0cfae", + "0xcb072d41cdd6852547b50f3b90819969722ced1d8ca77847e05a2e86cfc37fa35ae41fc530811a26acc317fb2f89a4fb" + ] + } + }, + "kzg_proofs": [ + "0x2bad0f41ed50e27d11041414b22d006b923be8f71c9344eac5e07f6f13a814595082fe9e14667ccb103d67581370977b", + "0x2730ae410e57553a34f42f8060bfd5c9e9e90292e167f747f14061500b71bdb7532d19a0aa2bd2b48dad532d115e112f", + "0x3a51a841aea2347f293797ab3448ea96efec0124973020021fc2a418e5d17442ea4cdffea58cb2a2d4c596d9d8257515", + "0x01eeb941cebf96b04a6e6129b9adac2fdce3046e74d6a5d3963edabf56af4ea224ee8ce2b56911d9fe7ccdd483ce4962" + ], + "blobs": [ + "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", + "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", + "0x51ef03412de8a007fc89e26a593f29059e41e61b8924965e21e30600c869836e7fc18a5c09283da79e6dedb0a2ff5e48f56f1b837b7ea64d92147eb7dbe598694d61f6a8eb1ff7881bc7752370d5001ddd5a784f494e4deb2c2f2a49acab6084ec17e71248296332a481d1b5a7fa714af16986c1881c6cde9bbbee1d0f9e7dc700a8e26ff68bd80cfee0b3f32a58d95581210e8573627db95d1031661abb3364228836bbb3665380038040c063e2de8b0e85d23d677adc0e47b88c14aac04e055eedf6659e277bd4219f0f0cbf0508bdd04966ca6820ebfeff283e8bdde088c3b6a5e412bc94cf21d9c2fdd03023851b30d984189b8236e882c9bd1e968663079dc243a674643e1b41a2e0e3a91c82f14e2399a9cae1fd03a04845a5fd29a42e7c13edc81366a37e83657b55a6f14bf77c415c51e3c1bce37b4339c8fc34e79f307024dd493af5885c344c2da16bdde8c0e8b54b79aa9af60c3cb1b1c3f7fa128ad3fdeaab9b20e19d140d429edaa49a56ac48824177e2779edf97fd44adf438ce455b392f37d40aae1802d5a0e194352c1054bd9738e369519d1d8bb78f319b3497cd1fb214bf9806de6e5e3153d272656bd686f7a3dc8a988c77e818fdb57c6beae11c758f0304b45bcdaade1d91a7d79a18ba8414d983bba32498a4ab9cc5110fa6639cdee044d900a001b948f2318c830d15841b97eb563e335c60ee87843cac6de2ae2dd5062c23f98fd6fff45f45652fa4e1a0e419d8f340099209475ef43a223c1845ba9874bd11baceb0cc39f2fcc48caa930d3205be2e2046972158b6d0a74caac29e87127e89483f372eb13b77b88c902a403d756fc392cafb7ac5f3b9209818e25d2974252a9f49196697fa326a8269b408a8137ab6a432eabfc58ee419747ad5373aa334484c12d44964bf532972b1f846f89e05ddcfd5f8cfab621aead0ccadec16b6eb1a49433856484b243cca04283f1b2b5673efcd4555dcba0bce486fd31b0b5c98a5348ad68c3c1549a219a55ca83da182bcbb7b2bbc2cd7298b81a60eeaa157340cac167ce2c2c8c2fa08fbaadab93b7b72cc0205bd906e51a3fc1a2030e5fb536da41ebf50d2c3c037280ec27e4a0a60c0edc702aaf02745632957e9b3fdb3649b535a9bdcf997430a0f0e1c615a7127c190f70ef3561ff855eb4d252eb57d3b4fc6881e241e8d8f2f61cdbe4afca794bc8501c2913f67a8e6cecfb01ef169f3adbbe92445551e6f0a83408c01d0387e9cfb18674fb882c93bd51763b15b1d1c3cbfc1252f4d7945322e0123d2db846454f5b210172debbe941740763516543898c3da0fb25800f1e1a0d04e452c3f5835030bbdc52f8d66b481cb7fe97e5a8c96b10136dcb7cb7d70d60d09e3ddf0306813a38a2a474973228a1bf91dca923c9878884b79f023a83d124009250f7213089abcfc28d574974d1ef857f06cf1bb372ec370c413082fbc0992e5fa1a75489726dd4f2f70567fd8ef10b7201e808aa4b48b4f9f9eacf6832551c38166fd62c8b952de72a0ac9b9bef710ec47fdd434830be47e039f6fa95a47097d1fee2b6d5d3a994a4cd26bc250a11fcd45abafd8e4ebcab890000123ce804f7013e4f1fe14036760f4eea79c528461ce5b35df6ec00ec0cfc199a7e2ed2c877c8b04415161e903153f40f7265114ef270e61f937bd835987566c452e9e99aa052801416886f12c52c2d2350c5fec9609862edaec79f858270b437a25bf1fc693db6e75907e45b33ffbaa6a8d9b13ab23d9fca38ab294e85b275dd845aac944eccca39da6511ce470e618ca35c4c8931cd504b224c8d046b1f3355e981e1acebc10f59a8e688136b9d5cbf76d97b83522ffb199e9a30a0aba00e70376d06b2317cb4eb93d1a09487645e9bb0bc5b596aa78373aee8132019b47ab7c2719cb9243652672165b501fe0cd3715233fc1df8a07da90375ca049c73efe20c45fef72c912998d0a0f0cca9a8ad04bbe2aa487dad8ba22a036dd3ff27cd62d8384245f7c77c1db3a15daef554930e61c3f137e63454570bdb9c94cfb8ccd80af7dfa2e52cbceb528b2920007c3bbc5da8bfa9829a3756b7c95e55428b569b5fe7fbb00fd68cc9e83679e3cf65142ec73d55438ed82b3f88fd2ea837a2d837eaa89535d3980bd2e2222879980bc0f8da87600c49d4df4a8ed72f214411bde968495a9cf4b610f7ba5c1aa90e5fc9a4f82c28f19fec8ec04e0cbfd9cd14f224672486724fdfa27b1d5f88ffcc77062e6c14c7426585bb7ed2ad0dee38610d0e309415e916643a755f1ed149c85878860824403319915d7504f99001247bf40391de7e58a6c8ef5145bdeb1bd43f1d129226a15c425bf02c600043b6b42a9c116c0753b8e108334f19a4874c37b11629f924833a5615313cf08db337f45be17b1a736e29263c330312f4467750b1b89964bcf5ac31e84dd39cd6dab23bfeb5379f82d56bca75b0d30891447b4ade93210c3b4a76218cbb32cad878d6b0b4dc70a993f4652f058c7c803b44fbe05b50f8e28d42c17aa9e52f47808d5ad2693604670ebea260770d8efb7480df34c33b451249df99c38374b48be91e7714183506276b0ccf44fc7ceba22807d1b088c0a44355676e6bb1f03e475e14698d595f3dcc59c13f5e11664c3c52fbc1fd8999a7bb0b4b9313e2235e3fe565f1b190f0a40f7556671b948fbc701ddf6207b6785344cb33c267f5b33c7e7f41d621bc89e8922bf762b79d781b63373faa1001049fe74fe89786e41b0fd16c105f844797edc2c8c66daacaf39c964cb556d81680f87957ad10fa3f54a6961178da746b88498ac7a86caacf4c4725ed3c64cd7c3cc0f45c7113404433e2dd578b197fee34c8d3d8bc643b7e3e78465143965316d9caa07461e8e2c6ca39d4a562f02b59d6e6dc47c3ffcf9ae15e25b8aff6173dc9e010937cbb217ed03584c339b81defc95858a6c90b7a26a77d075b5f4d75df0c3eecc8591c29656bf3e34904cf3cffe88360ead2fb2afe622cc32e35aae856f414893d9d7edb3e97a533752216f45ca5033a68a96484f1651886edeae195e8e70757f286bb2979ad10ac7481717d144026e651ac8138b3a8bfeb224609dc2198b019999d8efbf2880f7d91fb4b3eac606f85a635b0fa4413f6633431fdf982b01bf306b717a866280e1cc73d0f34850b138abb28f3ffc0fe64e99f7ddcc229224a3e0e875bfe7aa98fe2a6d1b0702c767fbac954700fa3290408ebc18a626e60b039c96cc2ddbcf4a9fca02b22a7af80d003289af222f378a733fcda2d32a475b7819f6d975e037984a70cc7dec746ab591c1e2c6597f30a706ed815b09c70aa3a5b902c8c8a00e3debf896a62ade43721f678dc5ded3452563fffeb43136a960bce8b3333a500d489a095a8afd880c762014b199019312aa5f8de89d911f1d46e8fe41386041a39ea506d91c93d2c2b0b3f82285765d0187d4e1b0ca83375459cbc24ba5f794f0a7c0397543b2043513f233e3832df793a523da07dad5798b24265cfd0014867e74be4ac4190ff4d2fd4470f0e415b91a86a40bb2525d5e1f7ffe5d8348db0783e7a374331db936349d5ee8a7acb03858462d8b4a215c0f341e912e04d8e077266bdc703e030da1d000155dc39bb79cc33aa61a4a2c43d74d1093272936e5e195edfa4582f2931741e49d43d951e857bc3043b78c93ce91cbddac5e3a7febb49ae3e32409062850c3956d683eca6554adc093c6c78cc47a28bce278838f2e46e444a852416fc8dd5500097234a2a53352aa47b68b8884d6522c9f2514263b481f80914d0d01e19fcd2d8b65f47247e169d9466027ec7f12072a43d26714b0407d896b3d9156f688d809f9d84d13160da71ee251adba4d3057faba56c0f0c26d33d9ee621539e9d5800cdac5ed4958c32869a554e777feef5dd2029a662eaea9334e17b3bdddb36e1dd0b425469b4b0e712d10ac0d5795ed284b6d114618c3c63a0b77cd9ed5b9b7480b989cded9a342d8ba52ae183fb340dd8162fbe637f45e431886b9cafd7b7b4356921d44e746b98097910474a2f5df1335da152d7b329ad3353d2d8c50dab29c3628a14eb15549d658584bbdd859052cc9c73c3f5fc4effd8282131383e82ac121e6caba772e9b2c65302065c305b97a157c69141923510d3aedc1c0bae05bd75cca668372603814c454f2715a7304f76074a20d391e064989e1cb717289514acce35721fefc5b92d0c6101bf2490c62498c991877ace01f8455a6ee6771408523ce270b72fa480813294a53628394b70eb84fec7b0817148068f6f69eee78a9b60c5b03e6cee80c19232c35ff56f1272555b0aeffc98e3c0d6a2e674e100e548389bdf22d0f315f5da49f0871352f30d1ec6254a0a78e650bf2a6ebc2afa6d92f8e452c0a9b2266010d2c6f0cc3a676f04a30353ea7f7d995d7748eea544df6085dbff36ea1897820a2410c9af37826bb5ce0d058fd7958064f33b3eb4630f88fa318f6aa9d4702ff4bf78ea108dd5c8588fe22153c41b3618d22c53bb3928e227a836e79fb42585ce638626864a6eda05cf24cf71923268d30dce13a564aa190d6d4230ab988d9aec71caca6def618f482629378a0d51d282b603405daacfa8635178f04ff281c674a78a49621f9b14a2b649bd218944492890d01d56751e1514cabe9f31d53882e3225aa1ca66d86a08d5eae51f795ce45a01e9c1046140b6bfc2b1749c97c10889ba5c334a0f0fdf62847a494f9a40eac25145a561d66d6736400fe4fc02450008a32e355004a4270dc0f4c8e3aa33b69d384d4a69b8005bffd225836614ebabd965aad089c72c055a96b6c1edb2c4e03cbb76ad9e2000e8d6d9aedd0d4d885fc72707516975aaa90d13aa2de7dc3095875b721e842bb7912994beb2ce927430713f0972a6d970d5def914742cdef72275963ee826d5a8b99a04b417a5a02d29cc1b3f03bd932b8dfb50942e7cef648995b2bcdf8fe5726481a352333607a7979f7a84966c4bb38884bb0e4d7c550ef188dea08952ed713a68e16f9e45bd696806ef45de36f5a4fe0ea4a7d234798dc5849fd709035238758d79defa3e40e5e2f0b73eb5e326ed3c2137fddc8f90f167d38fba77bc6a2abb639481fcae449485a1e6aa86fc7bb992ba2d3bc6ded6ae40526dae8399acd10211bab1f3c7f6d63231d527f3530a826cca67ccf956550c4ef37704943ce7b877f1945de3e0caa4590aedbc1b79e61c27b456b5828d3b522a3b2039a04a91e30212849050f3dd77476dbdc6f147b80d0bd337e17101c83aebc405ea1aeb243289b7fd48441ee6135bee61be47565f8315f21eecf991c0672abc451d2c4e8c452ad6c1c86b22b30a62f438172486a7b5b0d2d03385017bdefc6519b456239eb3ca9adcc8dee73e20053aeaac047b0d9541a76d391a7b75cc9d93c422651faa9efce2783bd6f64df0c951bd7b561b93fe7c9beb9d19097f161731d4c7227b1502eac0828589fd9f77da1c409d6211a4e5ca4a6143c01c707440bcac7cf87607463cfa195a7b4fb06275523dc3564d0a269a45205ddf08731b04c66839fcce25ec1c8cd4a1ba610644a4ff02abdc82f2ef6b8f9f78eb85dc38f67407e6644b61675323d117ff4f16149703f942e9a700008a2336c9da3094bff201ebb29c35d27034a499861455b19cce91877c09777415cf6ba5404a080d4aa339a7925dd8a46b8fa3d5ceba5506b211b24d0478f15d58a5ca733e08f1cd1285fe1faf5c0716aa06eccc21fc57325b03c0a75ab4d8e1a1621417e072348a4545c7f7f30a977fa547feb919fe05614c12eb850629338ed87611ef3b0ffdc92a101c4e08dadf747b688bec997d2b7d5464b792dcabcebed274fe0f115edc22f0bd1bce51463eef4148fabba0783d71a0527ca99448b81171da0bddb53945000f9ef60cdb9f958a0430e5497504d1f7f505e59c27d3c4ebe2a0dd724ff810fc93007338372dc9d17c1a9b14dbf120fc47c4714daf34080d470a0ee29b24f9c6c8826b15bdcc439bd7f89f5935ac8a8a468bf60fc34260351ad6a839d9de21a102934b4eb3a96f7519032748c4b30f51cca519648a36ecd82502ae6193de8b629795961148f44023f4a29e03662ed6af4b04d6faff858de4e08194c5629da0133b9360006eccaa281fd02276854daa599d42fe0c1ff76c9274e2c1cee569ab15485fd46cf8b8276785c506f320b37784d26fb401f541744ed7a5142f7f015edbb3b2b0e8901533cad9ce52a91293d2a9ecdef064d17bd3aaaf3b5cfba2d64c31b2cec42360dbd003658e3ee604096fd79c81fc2d0ed37d64f1e2df95bc586c1649d8771a840903591e83bb27bcfea88f6c90f9552ad8a977666bd468f7699c2457444294adbb557e61c7eafea009fd39f28d5bbe30ae524496c2e97074ae1c89ce5932f27eae5284d3f8a2c2b3d98e23f3046967a501b7c2bc73bd97b6870f8d26066a4d868a0dd448faee11542fa30f95bbbef67292dbc7c3c667de4f5efead45fe9fe5eccf9b3bbec88d2686d025580178cb8d9272055a70f6ed5719535446666c9adf35a6930ab7ec71f79fa1229e1bdd52f067d84115360acef37f90e2c5b739ba53a624953e9229402b88d84c0a2e58ecfa0b89de9f623c7918b03b5d7abe586fac30e1c0bfa8ecd6daf03c7b1dad928569ff6bef2e9379d40daa74dbe7b353c054fdb439ad46a6c123388b2711755ddbedffceca1aa672b63789eb5ab169c8c6b6eaaeabb9d1a6c48ad85aeec722950296f93d8b839aee6c208850391171692f8a9e1dc297ae52542e935c144e6a11e2824e989205108638538b4bbde18892bc720274af76b77f1ec9bd5ffee98c4bb7eeee39017e58b6cd063db78e35947cc3ee458ca78e55977f845e51b6bc500a9183fba33fdf4d46d597039337809ba3ad95bf7664bd8fa80a9bff526af21b0cd201ec0d77155e4b6bd35c7ea94e9aff79a64793a232a0ed06cb641aed82155ab23674ad1afb7eb9a1116897b88f1b4737e6e52ca32ce368ee988c0635826da9be42a150595dfc4cfb1fa9459d6ce6908fceec30acc43025ef61a7b9db002ff25530e91aab1052c9f3fb4dd172b13d50380cdce386cbf3556d3eee929e7c3d2d2ada26d34d1584fc735d81a6b9c573d5804da4a7feb58f0b7eb48316e0e05ffdc521bc35bdcba6b25d1194cbd634d532cb6026006599e7706d3ac82c27177be10276542b3f3989c90724076090c62ba40ca307041038188f3889cc259e275e7090a9019a585cb3e0b7dbc0f194275c5d4dbe3551d91db76413bfcb9891e9c1087219adc355912ab62c83f614f221e0f22db8b36d9ccc28b6e351d78af4435e52822317cac506ae1c150495f29e651f655d508a36bbf8df5cc4d11ec3ddfd36e7e9ecdefdfb415d9c97513270f0e0e83522aff59f9bd59703847b7dd6061f827ea9784c138db3fa3acba2d12b24a98ed5d6632a932572db2d259b373f4ce0c9fc130ed734d85b3c9d3d7d04c5db72662367b34b2745256c215fbe11c9322c2cdf51efa130797fdcae6e8f32d4999ab0b3d7366dcc6e0a59c81bb72bb55fafd991dd5f69abd56b5c43535b128045bd270bbac9b940158ed9eaf96d493c1b79366408fb9958924babadd5b09cd8abe0ba06bbc81951320a3d30cb847381d62b3ef7745a8cb41c0b23214ff804fefd2b343417a0f277c272812e18c9199aa2bd0d359a0c1fa3214d8dca134d80a14e30cef620aad965471263709a76210cb4c8b41a46db28a2156f22f4e567e59c16c1f9f0bb5d54614656f7c1c0498905e76bb0df15627df4af9db4337e596f35b15cd652e3ccff33c8ab24442d628d9c38bbb150fef47d476af978960a152d1de0241f5b2473b90cda6b89bf37f5749a4bc09185c6d670da05cb20faabcae76d46678e8e2054a3570dd8a36f69d073aee50a95748abf181c04c83447f4118aa7ebb5f9e70e6a1d0ef6264d0701ac496970d1604739b346082c67e40c6ee45133bd8fa88936640e6aafa0d9ff724d890d7aa143c01828604c0a45bb121668570c0a99a74676b5153954cb6f5ce479b11336a0b3703c7d135f6d98eed0dd8932f508641ab1c0f2804587a768ebafb8813cf95a24fc13c1b444e8b634642768c9114ec9cd3899811e6cedfccab7e4e5342fbe279624dcc7fcae51a9587e4d8d91d358d08c4b9c9647ffafb633cdc4948beca31581e82a92248445d0fb081bfacde50628fa56f583bb08fa4fbda84642d0d26a6dfd8b6503979ea19837ac5200942e1d2ff001e75726d57f50b8b195573f8af9c14b0148e8b2c30a40112f27eda008c58ca9f146cb6cf5f3d846dd90fc7cf4da901ec7644d576567a9f1b3c2834a91095934f5fe7f178b903f2d3049ba0225bb7247fd9c2534bf61419327c04714455ad5f17f8a8f774693bc692a87edae7bf0dba922a7401946eaf217d5b297b32c0cb524f27d695ef6bc2665484309e035ec6c95a99291bd2cb32b39f69c978c8bd8f5cf4cfd0183ead1bfcead2ea9c52dcbd2e9513bc5b8f6b4f0c34276ebf157594868944350eeb21b1175be2a74d10acc37a602d728a9afa802d3f6af41b1c48f081a541c1d09f8e7d7ade1cdce71d9cf43c6ae6ce0bf618e127983a5adb6ca5fc6a5696b21254006021fede15d80dbdbac8eab586d2dd42906cd212dd2d0f0105e1580a5749b784dbafabbe7580e669b57abc0c884286f814c8acc12dcdf86cfa0cb65534bda01168500488fac78ccdb07c124423689606042b7b88e4cf9282c8db0b89305fccebd6cd53141ededab10a1548b1c6232c1d6a60342d2934aa69b177c39988dc1e2253e85069719d065cef629630280c388b61fd163847bc456f482617526060a1531d53eb8e02c9c3a4f2d7c6674b54c9217ce17443c61d981f4489d5b16c921954a799db09f814142f3a9b1a8453cffd1d3f298090641d8b7ba92a7c2d8b5820edf49119b0b041372ba936d5f1d1914210ba31133e38faee64a410dd7eccfdfaee1ba38868d34bcfbcce320bff82163b2a18c5fe947e61a820d8631ec682d968d43213d4344fae393f1057d65a5546457bccac9529c7a9a4e4f0b7a2d7535dd1d804f84fa8445679a1a096af6497d953a48cadfc1be6b9b3dc0aca73cd22e5066144249c5528255b1d65f62c2d92c7e99733ea0b67edbbd50f4bf5de0501eabb102dcedbbeada180bdd305687a3ffcb553125da0c1fd92da9e3ec198453f5d44d4db317513a4a749b8937789fc63341eab9dbf95edc1b60bf69961e71581091b77fede901647e41625834963bb58f6f6d0743b498608dbb3ec7d2115669057242252cee5b408b183a6cedde98b89879d158f441f14ca4f92720f452e9aac2e7e550897e19d76c4bf00abf377c6a19547db0851c09b48e47acfda04830d0fc825915a4c29de959dfee1fbc839f3cf841b157de6fb3a22c72aaca7c293ca5edc7130ebd916968e66d6cb65e7e27f15d84e5579bb10792daa6d6576001fb86622a10d8e2cb3afbf517e983c80bab202c7977008410b4f50b935c5722f511e51a0d7a932efc677c7ef4ba5b9320cfb6c3a186650eae2daeb5ec3ae4ef0694c776de7b651056b27a1aa58fb931a3fc711b4cd8ddf3d3479788adaef934ddce4675ac7af7ab5f38b86bfa133bdfe83f6526d8f582d597effdfb8ac3f7144e551003caf7f644db6bac4dd2652321b0f37b8ad37eb5f09e45202875862173b1e5e6985f2b93bbc1ed01d8998fd8d6ba73eda665d598e3f313b57026661f8b3bc81e2a012c041960fb15311d1062da69b5cceac5e0928120aa63ff0d057f19e2c72263a320012ceaa77c308f5cf130fc4e7a7bb69ecfb7fd7d490e1f1f2f148ef6ef378a8b473514767bd1f25d56cb5328302b3da2be81eb8b77024f2d05f39b0397c20a3618a485058d75502687d661ca79bf146b91ed62557056cc1f3788ec09bf713aa6bae23670e2f6607d209c9c04b58790b6c0301489ae5438dfe36808612187e550f4320ca4db8a986fddf2206a9743ec8786cc02d41ea26d4488e5172b0ce666eb949a3f7d9074bbbd223f61faa85942ab63c25117a0989ddd8b92b10fdf313b5aebdf6ba64a8766e673038423c25da2e398d8b1428871ce26b460c1d1913c69ba4e964a4b09793586fb00d42e95e701caaeeea35f204004d3ae450a352cc519ed973a777bfe0471f609e8e31125b901a0ef6101ee24bc9e628a7404f64d86f8dda35fc9b212de6e658f9847914a35c1feeb817c8e44dcb58a3c261a6da6943876d2ea175d5e710d1fa2f2049c2e263a57f5140b1ca5407fe01df284d47d0d56cf8a607753b178f55efd361ec9d3d3deaea4ec6cc1606d06d367b64d0e2a15efc1b44045410e5d8bd17df7d7ea8b6a74e0538a404c02d5c13cbc1031369d254e5e3d7392972a69badba6979cbd7eb163eea0d357fb0bb3cebda0666a41d5ac7f3597c4be35f2cb03dd1c5d9fd22711faa0f0d63e4a6fb6dd9efa7da76c6afb0c9b35725736036b7be22b10a1f8d7e954c0ea9f26c8187c1a3497a5a63e0483b63012c78a5f31859cac412c788f313af1b6f81ba6dc61d99796a76d4174e164c71e2bc8c28e0125207d6ea03e65ac95194fc90e03799cf60a123ef0e5405350dc5400f138172e633fddeb1f47f6156bac8ad216f5188e39dfd3d4a9c0ec40b137101700957327790b7090023c2b0a9bf449c8c11422eeffec3fc6e11800a02efdad79d3e8da8fa3c5ef5bb509fb7f5e8e9327b168a5e9295dced3a2a1d90379ee8034559b41bcd460a8f0ba76a83d7d92d4aecec2c2a174837d9f43c1c3096983fbd777140f3a37971c143c8bad5ed4815de190df71a9a4b9b1337f115be76d7700f9423c5945803d0631282ac9d32cabb5864f79418b8085d47b1d9a5ee84b2695b2ef1ec75212be8dd6e57d0dde61051c28a8c1b0429b9323c72b88d0ea2a52821f15485486efe56734931a4098d7b7b197f2f223c0ee50e74bc563a4ddf42ca9e3e4a60e3d7c6d84a2d6f7566c41cb5766c5eb1869462db89e6b06164804bff3a1770d918511e71a193fa45f9ab8bc3e6c8a062d9679d0903fefd32ac42205d183299d6ca05ffd2eb83454a8b522ed8344239fb91476cc2a0be8f7cc7ed75f1eb606b2eb86a02b184179ae9425e826fecd9df848a21a968ac8bda966b9052e39eb471f99609a59349a387822a6fab387aaf874e976e1ceae9e40b9e14adbacb4d8decebe0e7205b04ea982c4c72bbea9c2f75071b95a290e99d1e5751a0f77d9b512169fa24de5390a3d7ce46cd3f389c1085619067772ee281bc2bea86f3da5c02c5184e3c62a8b2061870e4dc6aa6096373471efa189a6a159262885c1927ab93498e2cb2dd2e807cfb883759cfb8af332769478ac518cbb3373ded5ede41166bd9eaf0a9ba725d86cdfb2c3478f81d16041b39a87e4a612232716d480fd8510c110c580d2eb37d3bd37e16cfa189ae9025476c2ce933ca66c88ac4f78a387058efe99c6f5c228d8e2ec1e775db67e3b6bf3814f2280fb5ca965d9276238dd14c329e0a606d7feef2a897d4017b0b38b40bc5f1752d1ca7cde2ee8d2ca6a54145c459a9f39d848c033b860f5a15459dfd28663e257d9493126e9b4dafb57355dce7a106218c5171c9afcab1c72e7940280d1b3ee21aca10ce8bef75b0ab7174d35c6a05774248c723a3b820b6ddeb00528637a692df69482a12e408935e7b3c48efbc819299b945a013e466fafe711b8b11766faf01ba9693e1adf2895fbeaa80787f0f6ae871f0e4c908dc6a37193359f08133917ecda7f0139e512181eca62583a68707d8dccecd856c1e468afbb56b283a233896e90e3fcadc9b5d2e3be5f31b9cebe3d3a1ef547053b7288537c3aa181c8e7489a609a1ac542929d6c8b91b756884ccd2e47512b13c56afd7ae2c4da8ed8cb1bfcd80bb51859bf0368caec107641361076f1c9a7128a9d8a822d1c5b58e8470598a083bfa1c3668159fce900c082d193f3c94ca5caa62d61c0412c904ef238918f36b27e74294412b6280695bf362301142d6a8f36c613175c51234e10ff6fee56122dd12bfc2b10b51643e1b7a0665f290ddca58d689aedbee2f6d38fc030d9821aea07453c8061ee02a6ccc4ac89261d0efadcb3b8e2675611dadf23b6b455793ec64eee9ebdf71f80b8ed98b1ae2162dd434eb61d5e31a302ccd3f6e4a73a8f7e02a5093bf09db4e207776ab4ad215000d93835085654ce0e09ea856caa8b5cd5c26566193b17e62fa233e1ff907f53ae0292ddd566c03e09967922c3d2a351448d6073c2528d940aa0931767156f9acfa8255407fd20e96ab94aa7322730d7bcd081eb29004f2d8199c800de30212ae4da46346fdf0354dd7dfbd34126fa82be5b0b3f27a2de3af12bf2c52886b6856a49100473a44f8aca3374001340822b4ae25cbbffaa50786e765aec43f2015158cc3440f1370a7623ec6b1a65596ae4387d4cb3651dfa813ca1c256cf031b995adc5fe1e1576f5d83fffc1ed049b02d1d280f2ab6166f7df353bf73367cc0acde1926fd5019577c348949820a5eb8df9344b1c22c41d152d93a252b88d48aae57c38564e564ecf35ee82f3781d8279e51141ff63b606e51d287855cf1b4ee4ad041f761bf73b38ad83f0f49506c8fdb4841bdd135caae590d70ba00957b0f3c9b9e0df91d57e0f6a0f69b39b6c2e5b7fb5791c0f7e753e638ad83400dbd6185e007a749e373fdac1337c49470f7d1436c46fa205ab5068f9ffc321239c01d91d84eadf8c2fee16c3d72a46c0c1cc6f224e1f8a8ba4636de039e68301afd8199c16a66c09f84f80691d98baf19b5e945826208db1640469474d7df7b6fa5e507fff5548a5f65d5136ce5108a5c3ad4f9bde4860dd25b0db29b714b1a681a9bb35daca8b447551d9879cf35478c9917413be8adc670e7a3e43b3a42e44371a22a2bf33e65c5dabbce05189d60ebb29ad53ad11a6f4943822ca9813bf4f5f72b6ea94f330c60d26993c302ceb008dac3ea6c68e79c6867efd90a9d9b68e6a9eacc6be9ff7776ea8327591489f94559734ace585279ad5bbf381e66d0aac0ba36c554122e1d5127314b47992c3054eccd26ddb2f70271be618502ba7dcdd311001940b996730661d9e462222942b243d76a796b992ee140400550fab9d3eac8907ddff7328ba8c3ebb0260086435f84dc93b3da772897276d5c5d8a5af3aaae1f91f3847c3a354df5b397cb75395dc6ae5d643a3a38d6cea17a1f54502476c63200d63e5e88cc52076954ddfaf25597adcba62e67094f228db98146148f88c6d1043da9b433c3fa6de6abd89ba1af77a15835386d5a392372066dcf23ac879988a93b6a5e7a41c1b672471c2824a35b66573a403b5414691631f6668d2602dd397ac5cbdc8140f6064406528c35722a66ce5a13690c649d00ba54038dd36f66c18c673b8403e33dc26328e4b6f1af43e357a2e2eff350fb06ba54a4385119b9660b7ccb3c1e580e81f0ca828c62aaf612d17dbf723424d72dbdefca3c1eef921fabd8b1d26fb1345738059eec06680608e22123173e3a14d6aa99f9a83cc05ea2b7dbc9d6d7574e6a65abf1c585582e6da8916bed072bae3b15983bccb170c2489fc60f0f861451d8b6d8f43affcb980f0ff956e9c49532448a6b9e2175c812c22888267736f604ee7fe868d6ad8067399c35896a0f34419dbfebb14ca033da95bc73d4d0bcb482ad6772cecfc91a2fdcc0370b55cd96112bb4380b26f25459766ce683c44197bca4a233f05fe026778bf25dc9b94e35ebc6200cc4d7f69b0163a285c291d34bf513218c5625115b3e471a0a130f6945ae4dd247fa096728f99aa196c24f2c914464eb5bd298e327731622791df990294bfec6d64e1f90249b5f43e9dabdcf0d15ee269af591a64d7c71ab537fa23420472829186481d768f68699f304a4e231a80f7df497db8b17b07c3886b6a4d8453c2a811467fdaaaa4dde60075dc35d8b9193de2253d8f111dd1252aea180b9e957c0b8ae823070b1955c6dfda9567e863667dd6008378d8dc39f74d104a7f3aadca2c9db6804450cfb247a4ecc22962e54a116ab59b7640596cacd21081174d29e7431adcd3ba38b5c59075452179d257bd866f42efed08980f0144cb96833e4870185a3ea0e3952ccbc2f57e87e26b38dc9e283317af2a61c6f082987c17d7016cdbc4ffdd788a81026a026e0bf9b7d434ece1152584fd9fcbe59b4c5e048c4dcf014c3c6cf21df23c21a28b1acde3aa8a30b0744888b87255e12da2d16db35fe4a9aae0cda8373b526303d7564b5679c00bd77fdd06ca48e8abb025ba44471b6fcbe5c1662005ca734185e6ac3a1df527c120f3af59c90a5ccd2454db96d56d23890e033472ad790cad48072630601d2447e27f8e7db8fc95155d1eaf6bab0336267ef32d9a65b3b47083e922cbbe37825c9b7fc109429d1166c64778b8a4e507a30dbeae4714d27dc29a87675730a735dc1924da1021983e282b223da0bc5b1df9f0cb4d0e6ed06b001f5ecb397e147c67db4b4f765051e1054237db3337b745cf12decc820943ed196ec64bd74504b4a6ffd4315e416d129b3abf81dcf6cca840af073fc839b6bf8f88b7797e29b2cabbac8cb211ba14153206a6eaef6747b651af530e9819edb1a90ed5dd8c4db6898944064008e8807846e499a7064d55e8210f58ab8ea8310cddb537597064fd4159a30e9f35ebc3092062b9c5f6e1ee22485a1f0ab5d9d4275cc26c1edf3eb17325f5b79530a1abb0c9101796ea79189faec275199aa95da4d20cf670613a52c0dae05f84e13551ee610d49920699767033272a4773636f8376e9e31bfdefce42e307f8bc3d408c2eeb8d847b2c7e5a7d00b6f62fbb41aef5dc85d0ed904ad622d7ced2020e8ee821f06b635d1b2850613b1bc0743c942c4a520b08fb809589da3c183e459d45030b4e87ff5e444f95679bc0994935f11b2f3d8306bb67376e1778d9ecaf0f62f1016063681e78264fdde5e611025d2b1a83c291afbffdff24e7260f00b04d94a5b965d5fb3cd0ec073ca386102ff2a0bc968454abe07a33258231209a076621bbef8d9dece7f8ecbc73b7508f9e41462eb056db1d685d69a451a3a07ca239d25d8cd9943f361c9ab1bcbff6804534d8a19ca4e8e8a08f7fbb26b19308b23fa72bf9df8a6ad6cbede2417f0043a8aa91011e66961c21473b00e88be7f2a1f4be27ce2a2a166d53476ab83840b34ad0017c727572b8ed6cda41e625d00b3b5e1088ad23e00ef4689570e4846fa8eec8cb3e0ec235da06137f278e515dd75f086bd5bfb73a7fca9b995bfcd30606ac3958538e528ddcc81bc2e07bda2b182c73c0ad3ab5b86a67df1d8c45ef6a1ec4375d95da506a68f1b70188d69aa8d32b6fb2dcb2ea48de7bf182d3624bca7bf734a261109b2d0861c30cb1ca8ac7fa05fde8b8fd5f0602166277fc274e74d8eb8eae7cb65ba4df2fbe7429c28c6402b436de161d240df98653f872b73d64b8c54e4d7378d332d3bcb72864994c4c7f780fce1f4e266aef34bcfdbc5fc9d04edf2a350b29fed176ad67e7932e4441f6aae4d61f1cadbacbf673f70fce7265f6a440f36cfaee487add414febb07d6d7afbae78b759e758cec80ebcfcb924454c1ab2617d42f1261d6a8a4c01cdb59d436e3d64791dccddf4e216bfc46c19e5a33fa7f5c3d3e0ac7ddb1b9c3df6d1efc32b8c6bcc95960931d6d6af410cc8839053cac3f38ae0e6f5aabb882669969931a31a82e96faac22758b958ee51e2015ff94daf728ef81390b1e494d62e7709828d155cae43de6d8d79e588212074cb7f02c4a0023bee39054604c4f5dc8f787dddbe7bf9497f613a64d762ef8d17832272c5d9d74a8c1e7ba268493321a0e5a7b99aa0afb9ae6cfabdab6eb8d3b28fcfcc75ecd195e45b267a44a318ffea85c89abe89262f5edb792cd3180da2cb186455f4ea245d44a63aa3bfebf7a0110cf5371fbe98438b9996b2bf4957ecac832e1a6419adf37284874be021dc98f58c6687c53bd1275ae5e293f05ee29d3ae2a31e62fec02b09199db3e7a8ba8bd69f01a156b4132a53a9e26f20b67224e175a994338e77bf042bb9a6f1737175d424001cfd441fce671739db416d5c2892b3f0421b5724e9c586f8f94ab2d6a647b6b782dd837fc868c7f2ff64716f7693cc25e88ae75327883b53d0352f5c7a440661f584ec5b3da0aea5f2e69c6c206009b17a87d6c106d7f2948335bffabd039b857dfb03516eb89be1675a671b99a740ba65fb3bb885a78f7fb5e595a66d21d9ac9908c330def923f1fabf42c85c1c2e104dc935f6bb946e8c5b3f02f9a72ea48e05bcab4f595efa4ac32e4086506b9c32d44b96f420eae9ab7124dcdc04efae04a46803c1f224d43cf37e2e9aac2babfa375af8ec62b07ba08615f2fa21f73607b703cf54f53384a02892aef394c3c00ebd09ac5664500e69168444ee24fc625292afcd23d21bc1ca0ffebb70c7426480d163c7cc4d15c0a524877ad72e23d5cd11641e017462dc869786184b154bb8f1851e335383ddf18eb74b1081aa9cf4d3162f615fd98ec43025ce166c970d6b29cd6237c4b6cc67224499a4ff6cab07ecc0418a284382af473b725778a21a2a22e505be83d0e89d26526a884f59a63cc69184e4d3485f360a7e44e403e551cf6e7d85d8d81bfb8313e25d57d5bbe3987943ceec30aec1532efc26270c29d0406e529d91a3cfc36fae15509f83fa384a21c0b15e3f780a047807f4a26088f0dfac9d640f4c9e225cda3905ce80e47eea4939cc9ce5e690e36f0ed9019956d6b4e389a551d37c63e4d7fd69178064db4f7d11c5d829a166484bd70633d042d1a625ab2994ec99078a592416ea6bc64bf90726f78c07650c9c9c671976e81be748f5e4d44bc75f627f8a085cd0f9700d1b853e489c4b30f6a2fcf6ab6324eaff729f405861a6677037e8e00960f525c41dc19fc84db8528a8ea027e528c4117497dd16f30327b32b5dfe65aeef17ed307eaaa3c261616c5e7fa699e256f44d7df922fb412e9c587e43f56b856b0fd8707c2b1152d9b02b080d57548bd6cd427e4144a3e9df90d8be17e317887588958da981ed53dbcda6e9eb17acab4c88377231ee4779eb54b465c7cec8537fb2b279404a4ab5dd4a12c19d5301dc04177993128c1952a1830ccd17ea2392cc2c46f389b3ac13a235274919a344c0983e84311922c74001b9d1a997391c83497872edca89b59b24c58bb58e8856ea25fa5defd6a7183fdbb2acdb96d9b45f3977d16ae88c60847e014bcf076072f0eb090a1304661c4725fa09ff6a4c631956c00185f997ef778505aa02b9503e520e81d03bbddd1d46c447fc0b539bc9cdd794037a59aca37320ef4fb360fa53cbc41d776d0331a0c419079f3b02d4cd522d1c1b2d27e7629b9101e971b7d7d6f27a7dc7b19b39ba7f10ef5839754e7a921b3db79bb6091eedaee08097c84ff0c065e5cfbe98733073b268d070c7b2339c87439f3625bedef3fd258229c8803532fd21df7740dc7f95ba190f0a7a53c525a975a132c76a3711cfaa527fbda4516e8c5fa8757b3c219ebeb81f0ee148e6591ef13c385b58c37af36fddb0abee63a419b5f2c153190394b0a962a5cae1c059ac90b964da5c83940c35f5bcd72e9bc9c60cf665f3622e0901e3936f3850df510123ed1625f3b69912842c56319b7489bc85fac42086dd5ea908bf1fe8629cc61ae7bc123260b84f35d0db7d7639b63f43b38a392a4eabedf02dc23e8a560242959e661cf2724fa70339c96a9f94724fbc118b12f1618ccf20c34f04d98435b7c89765205e5b4e1c02bc2acedf14e7bd192d2d9ff9df6728166ce17cacb89e23826781ede01affbf350c10f02f9a70b8cc4c9edb435893cec7f970c0b378c20bd080ad355fe4cc80d3bd35d278e3093c8aa7908baba5ca15cc7b3d32dacc9e0ac9ca1e5027085abfb73a547864429e3782eef5ee2c0fbf5b9c8f9b781866454a33c846a53dc9b219ca0d7ea6b1ab568e4994b5eb3a577679f1972cc1fe9a1a2f4454e9bca3f9103c85a7dfcc6c85d452213451a64fee507658ade3e00476c09e13f70adf8a3acdb8f74a1c32f648cf78d45a60bece3dfea8d652e7a7798d28ddbdcacf826e3f9491f71bee304c81393f888ca1ebbf101522d9f0b194575863cc60e9b6df2ddc778f85b46f7660ba789982b2512f5046de914b64ea89e455dfa45e1285c4ef428a179cb1efa1caf5e03fa61ba244aeb4814deb08639e0dfd2e48f4f138aa988759fdec71d84ab4a36c771c6a514c7393a49201175c5cc33834252d570992fb1c797308490d3283e8eb3d43f936d3675f27e66cf935e8817b2039b0c25bf60007faad552b9a79755abc6759d4527ed8ea0a8b5728a33b6e5c4d2dd446fc9797bbeb8b2034bebd25935b7ac3411941c7a7942b61eb861645fc6b47ba15d76666aed3811e6f02e5442b71c6752619f034737eed203b097af2fe3396ef8541a38aa371bbbfcc3f35e1a22288661315c99c2961fdef4b9874882ef3df85b89965a900abefe8ed6c55ab34aec0a3d95e38a12d8d810064d2a4559df387ef48a9f013a9af28c25ae2666ed683653433183a626427774019bd0e7b14f1fe891b65388585e11632ec2476cb696f6e865bf3b0e229d8f092d06074613fbd22e26c021bd28911e33f7ff9447df5638a69f8d8fcb0fb6da3d57a547f9d44623f72c30ff5348b2fefb69470fbb8d0cab2ff1fca09e4fde31835ec17c4347b65d5cdee2eef88904bbc3fbed764c617fba074202a122296a9b1971595351e9756e4ced85d7bcbd0fd6a5893a4649585c37bc4aa98da1dc34675e12a15d8405d290177c1caad6a01db0a774ec7b8021b38ff0fa8e40315a185b328b7e05ef5ebe8f15e481d8f2ccbefb0429b2357bce789746a462cdf38078ef48cb0c4f6c16509682e7dd1b8b8c4542e661b11a3ec903e167916d309569b99b72e9196bfd904190f5e6318b00ef4878b3e60296dd8790a5b196064d60c8c4323461a71957f4711a12bed101725423a2743331e16eb7c03d45981c3c85e4864f3de46ddcc8c1600358fde4d588ee7688f279c0de1f7f172a7ff7b0ea6afb70d18f1657f9e732b55b3251e5deb560a37c89ada2c47f0b7cab165858082628f7686ad4024da83ebb16a80825cc98bf512de0d7c09642c9bbeb6733be456f10153448b141edcc98df3a50d846cb8bacec8af4c87771099606b6aa3e1fe3b2a9c66a87379b9bda9033a26b28c17e8d2f22bc305118a4f9b470bf17bfcd8e13628c1b8910ca07f670ee4a46776144033f67227a98679b2c84717f3e85ae937adaecf75ba53de257e0ea37429bc6cb0d9a726e6cd11d9c42c765980d6fba570f28ef3044f897be40d825e12dfae4fc69b7bec4327c664da2da0dd04ffe802ab044a263b26f2dc696ed4034c81d812e18100af2b0a864132f4a0c989fc7a26346ef96957b0b8c3a970c03259467baac43fad9afee2baa3980156a26133c54d10fbe60416405f2c74547d7cd5d087e8f249ef3f8f688c1ede262151e2396e176378e1a73502ed0a783024a2013ca11e1d54be26d9d61a609b1815cc78d80269b57cde0f4aa714e93f8a08f25d2ac8b145a9e76c9db9f4aaec6e372d838641527bf52558bd5c8c78537c6fbce4ed257cc47654265b92c11ae2025f1cd53283454949f1b42b490484fc96f8a56f2b4b5f0d8431cceeef554c7ed4f54d33c961bab2e665ec8a5a315f7066d572f563238165651a168b737dfae9c4a7b3bea80fa51422a4add7ad225eeed312786fc82483418ccae25837c73eab0c42b89da4510abb6a490cc3e57a111589cdf5168d3a0ab9a1de8467a88457b68068c07cd3b35434257e6fae2a4697d410609f4f6d4d19c5703353305737d587cbea9f2c4295110266584821f878f2e06eb54691d47be8e68ad415bca84b8b98548f32f19efe2ffa157a7df1aded975c178110aeb2b1e652509fa2dd40c8731d2edbe96921b7bd5fced11adaa61433a39a2b7daf314fea63b3b151dd143ee97b051c3c8da543f59397a87703fc07b0bffa85f6c04b83c15f88187b19f80e6c480919d9abd0c6ad6d2945277cd1d6404b1a2484d41c50d91bc550cb09875db1a10a04c0cff39c8e91a23bfc2446f937d842f540994ca7752dca2a34d49ea2ee10c0bb5d1c77b3ca012c59f046a6fd58f84738aba87cad86e58650f748f69b46e9aa81f6bea4d3be5d8c0c7ab22f2a7662e679229f70e5daf36c458164aa8352450a2b7cd82ba4e41086b9100862bbc6255bf3c7e2eaa8cb76c0748950ffdee362df20d9cb24394e89ddc5a5145187b0c79fff97f620bbb7b9968ef339c1d0f4b4bad95ee7b963d194480022f3d957fd6f6c460669f05960707cc209cea7a3ede596727acfcf510ca19a26fb941dc15b0c1fcab3991aa9d94aee4f172280113822c9180728c34e6a851b60afc770cc167898037c3c764a3f038233ffdf8b49ae6e5f3bf0e7f7e2c69427c405ace1cb9dd7b8b080e58cf5034351528d4b7a3d4b48951e8858d306562c27c020c661768060a924277fde2a0c9ff868ea9ade03539ffc264ad2772a67ee8a345aaffc4edbc5a4bb14e1c3362c213d09b1c69d527decea27f53305219798cdf83cbbcff996555264207481fbb7ec02e389eadff867624b3e9f7e5b27a6c20bd39b0c8bc75606ef788f72e10a0a37dfd9465aa532358e0b43614fa679db1bdfa67ffb97cba4b9f6738aa0d115f6157d9a3746bdd4246c1d45ef41888e60d7fe01393bf3a56163590adbe0b59170a2d869cacb6e81b2cf12a3d1f6419cf318200c654ea226ee25d3a645924a23af8bb7a7af2c6ea5ca77e08144fa1ee66872aad0d2a2650d6b7a06c81247c7d12c5b0837d6397a5a5628df506fa1fc1cc507f0ef9f0b3929b06a94b49e0462f3acf38daa699b0800a4047129c6a9751b716bf40a08c36c87af90fd7a6839efe2111ce5f3e00aadf9553d80342687fa0f066824f9901a59e66980db6a6eced4f8b47376e4f38d152c2adffb5c86fa51cd6e2073284a2b3b306bb3b1bfc20d1520f68f6cf298da9da02f6fe00e17b00fdda9d8326804c86e234cbd4c17e1e8d8699679f02df78351b38d5f2b2a75d05d901cc8bebb3b3bd397f57182aa53b81daea50d1d9c7383c483f30de9215a5fdf865c0fc5fc6bf3184aa75bf85101834ba13abcbf6fe71fdc76132f2b28c1923c6b43bee0266f8ea862bf5aa38011ddee6fe2fda4de2e50406e127ddce4fc28138af0a94a6c4012d17ad61356dde8d939ae5d21020963610b473282a82067fe21eadf4236a1629a4f38ed5d2feb1287013d916126581bb38c3bf91fbd93f3040a315fa1ab8140108dc619ce8e8a956664f3cb5d99dcf65d3b3e151aa24e86f897ce7e27b977c0ec5ba6ea5067b97ec93734794c56eefb4b876ec0114e9d7d9b0d4341de1178e847fd42dc6ecce727b3e14850d572c13bbe6fe62d0a19e42e44d08a2eb7b01901181d9cfcc0560d330d954568466bbb331afcebd3b52164748500be9e35a3b4bbb6365b562422f7a47b6a16d4cc3c20a9ee33fea9c4f8465fa876c58bd918b8ccb8bf1f6be7d91c707469753e079319785b102c981ddc001b303a8506f1c6ea4cc427fde28d6a141580585e2673a8a9eb22053aed7a6a6e30688b6c89f97c0e9958546694aa35413de7ddcca8e9939a58865b1e3e5b66bb60fa18ec86128ea3368d786cc52f4528aadf9c60fab257af768797d2418a7718ba4109aee432df85f1aac2fede8bf19988acc0e88338aee2427abb22199cb5056229bf8ecae92e1d0553b76e6ed2f5354b9548362863b277f8d1924ffbc68d170c474c70794e4c3e9e2ce96860fb303785e15019cff64be9ff14907d83b3b1d138dd18a9a6b77769405deefcf2abeefe26f8c51895f1392ded84c4e363cddb2e2bd594591834241bee9875d797e67921335a6285181d5e9ddac224f9c2dd28b5ee084bfef9d45ded81f3f3c6ead4518b357f09f6f614d02fe7f527afd724375715e1dff48df932d5829b8c14c913c150b84eeb134746b8ee9e1e46e43ddb7d2e7aa6ef5470d5e2d36156d6be6dc211789993262434c4e3b08c4348ec9f54fe1f0f9dff8291d96d86f2c481ac38e63ca406b1a71139100290a6e484ee2185119a089fdb44112068886ae47139e331a21651055b470458f976382a4ed5060097b707a32da722cf452fe9d2c85e4f830d0d3c4916ffb5d32bdcb12cbd7cd5d566bba37b5fcb866aeb5e19c8663398f8d818859fa52a5a781d7bbc4d8fd85a55843407068c09f4597753cd9ae5ff3dc614d26355b1738feef0ef305f2a29a281edea59eb2a5caf58d53a00984889d80116873e41a0aced206b1f75072a09f5f4d3ef2218e896ebacb9ea379f9a176235575d93a633d58021c9b8d810ff21e451bdd13e65331d4ab90235d26cb95ef9b859ce7021e7b18fc7b6c4039636e12201653589c0209dac53942eceae87631e0384dcd3ea78b2738423ce0538cec6d1e8fd2f583049173469a34f0bc6a7195c89a9ee4f856dbf0fd591c006cdabb94bfac5a81c2b5d6225cb2a80ff91fa929a22b5724a4440cb37a61a8776fb53ede0e70a17b4c2db983241de172bf0b793291cef5ad0ce68b0328693ce04333ae18ae3672c05d0aaac3facf7c466060bea4c351883fd86bd64882c934197b0d8803b083a516824810231605e13dd8cbd9ac73dab6c196fdab3e0f89c5c817e9ecd54219e6a52d5c7178786b010a5d27da27bade2ebd62371e74b40c8dd1612241b42aad2e79e5190bae2cf6ebe8f9dbd328319783e2118b06ce5d0c03e1ca8eb63e0cc24a01f8299740d5e40e143c8ec0766612ad81f5662804f4054ae7e2e60104876fac93c50a87c28adfa84eefe2620b1e548a112b44fc21a3a8b6955cca620a202398e698e325580a40345dea6e9296642a2eac7cfee20471f295e321905149fca3fe960faab33c34e2e788eb2304fa71a2498fd1174be223fa578d78549a2e6be35ca3125cbb3cda15991d85cc1bcd5b47ba9e2ec923c2789f4a9036f768184164a0f25e509c39de8b63ed196993da97941ddd4603d400aa9b7cb106fccddd01435ecb9ddf7ca9a0587dcee97fcd9f4e464ef89bc0cdca45ac36f6bc7e9046db28a2590de8a215bf6586182eb277d07d71dbbc2e4bc0a654d2b52abbadb58e6fb3392db9ed7c9c22ed73294628bbd2ea8ddc9cbf575eeacfdf765d657c02e76f1ba8bc42d97c6e5ed7f1e1f3a69841e5db002d9f18a74368cd7062a67fe0f50624dddc399743535e17b526a85f366ad9cf5baa0eaaa32f9c92105084267b50139d614b051a8322655dc362dfcdd5d1b26d3b70307a94821e7aa602c5c09e073202eb285b806a4a5bbb25008e33e0ad0ebe4883888e9ce58c2c3a97a205df1899002f784962664c6d14d5f29c86f8673ec74d080dc9125276eb67f28f0ccff9c1ed5ea2ce867d3efa71f02e76e1491f1ab43fc9c68ec39ab1b6fe3a0deaa012e478eaf30184984ad297762ca1c85927a31297b4017297df0356945c8c6257403f21081ccc0b912dc571cd6a6fd77d867654935c0dc2451a178129846565d054363b09af2fe7fbb880345be8b8a5b4760ffbc1768d22f496c09f45a8db415392398eaea521e23e52bf4b56aca8f809e6d919055e5a8ce67397dca6fd30c8f93381d589daf129aa75c66fba409990def814186090f159ad24db83c07fcbc83fe397adf78f43e0fa2d357c022f0126648485dc042f764191f1a9e8c66e69a34043b5b864e895e4e29c22e2df8b6f675e94f8cc7681415e5776874af5cb65d8ae68e803606c5c16f0788ccfa96a980ac2e6954b1c7003acd92233750fe00cce5d5a12f77388a791738b1566a76471421b6d029c420b73955ab9ce14deb5003c4a96b059de0c5da8d732149ba9175e2cbdd0525a6b038f78ecd354f8899badee698d773607ac009a29dff09aa2a46c069ceacdedb52e6e42c05a5fbc47a5ced42f23bda705800c4c7a98d4c9092fa2405c487fa15a08a084b0103e98ba2a02899d30b3d69884d9841f75a7bbe46257bb90ae994c782d1da6e8075d47d2456ec9ef0272b7ba19186bcd255fbd3eeaa4c45a92a9b4e8e0c7111a27fb48ad55758f6fdad24b5982d84bf66a9dc9b1f9dfa69e9f97136b887c844bab30f0357d7ab9b56a1a77d26823e9dc989e0265c326dac7347b6b372db2dcf0a445fec525b678bb5d73ac855722d34b1a780b8e01fd2aa8e33c92f8ffaa0da47558c119771af565cf38022e3fd88df2eea6da1371f86755f2081f3ed034188a5554f140e347d9d7d11074bef36985ff24eedf6a537d6809dd91a3b295f92a29d037c5089b91b8b7e7d65d29adf612ac62859723ed8a7ef0d222dbc5e85f4c3746abfa8f181281c6895679d3880014166397e4ed0998a5823382b90589fb2fb36be7c95293cf6b95a5d5e8710565d6f07310cd04727f007c18a48314d88d196bc5ebff018df01ce71b6f18ba87e55a4df5bc700f7a7c78c9ca2c5c055d96efef3205b9e54700e64b403d8099d73f30f8ddb7558577378fc649c3edeb4173dfd45fa475614a435cd55c5491a2a0d668b13729648d42e2b5f9c8331d97d21135065184836ce11bb5512c8d57fbf3e96cd19e542b20b664bb142b62edc1032f48f4e020f5769a7e9a5b601f9a61c55fabc3c5f749ef3799235f900cff80e927a149377da140c97669af1e0c85c76d1c6b1ef2f81335289979d8c35d56563f5ab7e5563ae69c05bb0ca37d5825a326eb3e057e65cf187319ef50c84f5020e314ebdf90fd25fba951e5510b18424a93f6ddf156c022c506d7da6e55def10b57189d680d273dd15445730a48475c9b36d162f57da08ea75013e8175509fbcd41a7857849d866b26a69b0cf2976dfc3f70d3302889f0c91c82009fd66a767a9eb26ad60934a4cf2902e4f4c9642cd2aa36811d520982d9966ff7e185c084835c34fa8778f75383133874f6aeba26d666b7e1ca2843451b6280988c5bc671b67dcedf952b505aa1302dc9bdd7b00ceaa6116bcc004cdd0f68fae87b9412f16226c31bc35cfa2bdb47010a0540822194efef9be2f879637281f43b98e5b09fe6e4c8ff39f7f862a1833970cae4de611d79f5d2bf10621e282e3d9bfc0abc3858b7b312d34b762cbfdc896378774ce3a8903d983eb0e269fa1e631a5f3890153339bf74a7b3f98edfdec1dceb2a0587489cfef823442a72ba6bbb2191e7ebe17e072079f6832bde0c22468c7ab652a1c850a2a8f67d75ca4ecf57807b8caa069416bedb8e2817380893632cce44b0bf73ca1bc69f017744619b072ca5edf1b41d8134d86ff6e8fb2cfae1e84e84eaf6f74e4c1d900de9d199d078c9f78e4624a759c21a914138e133d5a2a7b9b6151f48c0702563e206d5d079beb1c41332b72545d8e2537d95b4b5fcf309194e61d7d84a24bef126105d49a133fc550db3e58b34f3fc947016bc4c8e280256d376d8525325cfdf23b1944a7961708221edf910b9259ee331e1abf7d2f81701e21ce01f6965850d7dc38cc185256414ef4f6e58ce6fb7ba4996afb609564bdfd64e01cda92d5e8a18570e187f9a8893d871ded0e334f46ef2c07737eb7ee75ad34ffc46e4f7078210c3713d63f166accb568bf74012730c1689adda77d483265bbbb54d7d9f62cee5bacee0c5d9ac4fa910f9a680032b0a12f75f9d391e43e479427e018a0208868ef279bc591d3830fe3dca66882ba9b223a85d216e3734a1652eff024f7d645b959170ad99cbee3bca3714f59fcf65849949b81d625ea2d82f744bb64980d93cfc02cd479428365b98157c63489eada801c031e155092006f7d9a15ed1f2b17015edd1d22ce50c0f160e3affa66d5082e0867db451e33ea0d512cbd828a01921dff2f1df18b4a61f0d7e714b6773573d25d098e288d43655bd25bb13dc056107e85db1a2d4c844c57af37094bc156788378490f94622fe39ad7d9afe906fdf8d566b508a0e50e715168f8afc0ee733a5e887a3ceda3ab04b426a11b398b7b74522c70076eaf14c2b0b3c487e7cc66098b110a8a451c1bd8e9fec0d87ede46f1e2f4a975d60806a706f99e288fcee821556af664c1dc02d0408ef7e6ea7289c65bf04a6209d1d59464d3b3ddf98963e4d54095dcf3b58e630c7b1cc534217c3782e5337cdcee45e29a8fecc4df3851e5b411aa4e52bf258b895e5be735a64e59f7ae3cd9b3c94329bcb2515e1e392d7988b2cc0fc0d50e8b1f443eca3521a09d65b7822e64d054c763713db5248ef49d74ca1f4a771625bedc2c886c909787034b8207542df3124fbe365e8d475d3664c054578c41659c52098ddf39ef702c3138259f2d2d26b9fc9a21893d6c71b4393c210fc307ead52a36cd48b083f7eef762ca2e53d4e5bf7fdd845c22e4b693b77d5371963e8f445402ca704a92de2005f92f3b12f7ab89ab7f66b2d2e5c01cd627e42c66998461c6ed55c77823b74dc1b524c7a20e7a1fe1f201e37fcc450ca8b01dbc5dbbbcb05bf4b369b3df7c13a0dc0f82a91f56fd431945d72b299e73ff571ffb5a536ed536581bddeef2078b62df6b466184c9ee0b3f53eb9ebc4b299e4c5d0ea12c94b605f73a99fd529b400ea644e8058a61fb857402a147a46cc9d34f209991436fb3d4c1b162a8eb59bc9aa4bc535a6a2e6396695d226e5f4846ab810244e6da01e8637396758702cc9a97a88afb63ab45abcd73229465d5ca080a62739324e39181306def7fe69b5e354d8f7697b5583fba62b84538a530ffa0627d380e46c32b23a4b73a6c3dc9e0da19e3de32e3daba04a48b6b60f3359906ddade6b3ceb61e5a1c7ee8fb079106980db5358bf96ad7c9b1f770300cba6f6916546bc3cb827c22bc03dd31068fe98f06e67ebe1241ba5f9304e1306efbfb91da6c86d174389d7b39faf28c2f8383e4cf78d54962a60e90f9cb82b136f1dad178f34a2f69199c0c19587412e3c4362f0575e65752047e04409bcafb3713508496929fa0c376d8d80948a2281ef74689bc58745f8ce33dc37f666255b3bac11ea13fc1627e917504538f3241c4695a243915d411078f7fbbc497aad260fe39d141ffbf82e117d9a885d5cc53414bff7228196f9973b8fe61b8d534f9aed7e5b674bbfd83f5d82fb9e48b8d28112d25e12bf94428a40c765d53b547326472989625c6b35634ace7f634cf8672f564a01cb1dd63d6c51f2843686a5d0d0cc34733745d6b9ef25834f6e6823bbae483a8ed5afb73d0877a5b631973a552dae38d2c024987483b7e8c32cd102518fc72599f7c012dd689dad6a58bea82e5ed42286fec71b87217192c33d0ac30bffdc534f86998de08ace9687668a70a771d607a35522988a17c4c92bf52b83e57267a9cc29dbfe9091ac961c1008b8708b8b309988babd1465b7b012438e5a12763a75ae5f81943692bce1600236efa3de35affad71504498879a0086be04a51133a11a0c9cfcf56373b86055f6e893808151aa3d5ac3e4b576dddb489f02045bbca3ecdf1d639ef299791dba6ccb3af1c954fdfca88f88200a86218227697048e170c3cf1fc2ee27d860ae391e7c0a2bfc040e6218495c80e3ac247e3aef0c885d30f968830f2cdf311d783e9f9bd0d5d97f96031c9960bbfa4c7c5470fdf36b367dc93fc23db1bac69263eea33a9008d0787489fe84e85b70ba848cc2cbb0f407cad4672ad66b72d4f05e9782a9007cfac62a2d9d521a47d6f1dcd178b5c4abf82c9d7c01545b7244cfd92be7670c8d6a7c5ecae28b73c368dae5b847a5244e5e330d3ad06017c9de5b49cfc903500f5cdd5b7f64c342cff1aa4893d307b8465d94efa4581849667cc8a772fac6a1ef41f98dddc1e62cc7501e6f540987ddf80c7975c3f8082ea9d23cf180d3ea85a6d43a09aaaa1da65ce0090b86ffece4daea97b1e57bbb173fb287a89be5a9b57a8cff022eac6e7edc34358c4c51f19160a6901d7e9c2beb51d3ac5167aeefa293312a551728a553c5ec07ac7b25609cb58fcc148ab8c0a4068935f467ac96eedb6baffee8163e18ae8dbfe5ba53fe344833a7568a7a04cd4bf6dba0ed611deeb37c4ea1fb7773957ca764f6b959ca7723ecc9880b798b0bf89dc1e510197b2f748c03020e91d8e6ebb7a3627512befa197774b2be0e42913868e358bf7a45eebf35448d655f5bfa628803f08a610147c0d0e3bf21ed95aa4f77e613d84aa89ea738c2cf7edce9151b00b02c9e44925a37e82700b82bc333a365aa3258dbc8669b7f43fa4df86b4e96a435e5ccfcc224c7f07faad2d5e11d1bc7465797080fa12de019650f6b3d12664217ad33429309495cc453e9382ff0cf073b2694d0755ca541e80aa8c0d49f41781c5c82b3d56162c87c79827574430902a1ca50d775db6013ae07963fcf8a6c1e958da0f346fa8e68fffbab145a458ce5236e3f6a5414083d851d718d2b3a6dc4922062273894fbb65e9e03a4ee373a4a56c5bed4a1328ff21934fb32176a13bf46b64bc532643076f9894f9aa4f0fe87c383a6177a130916a7d5c06155abce80483867e907928b4d38c9a60692580faec1e2e355abcb49112dae499defdf54368551289f11ba8b8a63ce29cccaed77b39a1e26883d1f5951ac12d92993bf98e1feef60d3086fead082ec4a6c4441fbba1cf99a49f70bb5cd6777be62b857106d4ec645e0b6b486c3e7dba6a1d07940840238bbcf633d644597f6355a73854b7111cd82e5f5811ff05b386d4d62d05164ee23275f8e97d81b7cced864977ddaa609be5f5ee744de87e9025979fe126b5fe30993cf1fb0a1ff7ee09d72a947843eb99af4a7045db1aedd1d39707121183e41bac3f0ca54efc4d7346a57f73fcd99b4236e69b1a0766bf2d2082f1e74a3b7490b9be2fc00e41d447431650c95cd1db761621044d7f582854d98b00493d40b1e5634b29667b71a7d6ca6f9a5cb571ac61e35d30c3eabc7601ec5d5699cfea5f5f710ce0defa89b6e907be13c3a6fff516a8cebbf0562a8dfb942ec61c15ea307d05423b135c21eaf7633b3328d0e5b5317d5facbd29e072df6f215ddc8ca5642c612f6f885699359578183b4433e59d63dd7ca913cdaa5eb91ce12bb89af237541a9c6b762c41d369339956e317bc044b85adc26518ba8daab5d2fda745f4a02b02ed6ba04eaf3112ad2e63efe6ca403a5db7548110208ef47c0590b08b17f8703ee1be9d5e5be414373bf2ea6ec48a7e94e2469f011eee9ce469f535ded692d2ff3bd37f389298da9979d1df85aef14aaf6df4e588c4fab8b9a94e99b0e5d77aea75edbb211872d483d29b218478867d346478c258b4a5f30766aeb814ef07dfc7ed1f51794bb1cb5a50b58fd64835195d9a13b278b132c50eeb0e0df0447781bb308a05d46d0aca4a6ce4bf4d33703e1739dc6a3567b35e2490bb91cd6265910114e98748edd436f8a25f81bb59e52ee19f731d2bf57a2c46a561fb031350e63d5180d7de5342396804132e7115afeb9338258612b59cf36c603a7ab20f6a0a39812f54f8af453399e13359f12426b80c13fbdf0ea16025bedaa8f2d646612e04b1d25f6036f2ea06e9e95de84f22846a0772093675cbebca51399ece34a4b2f456cdd2e741075b413b9cc15b212df53de05d0541c0157c4913aa8b16c8fe42a5c02d7ecb9aba683f6e55c06865102b11f4ebfae60d572446912ccdbbe4edc6d1627f3d66359ffbf071f0d4a0550d5b01287cf14036e05f1c10387daec5d851ae4a48ec572529a4090b92bcc13f4c662f44f5568b3d8aae1676d20b5097520566ce2224aec704a7e91c34e4c8bdd342025c2d4843d836c1246a72785274f97cae9284f273d400a17b67c91dea1f7f503cd7021b593dfb4e3de4940f8a55bc32297a99cd26bc7574fd2cce068a060d66b90088c3aa98e9e9954bcc5cfd0da82912b1450f51a776b8bf4d98227e9215b7c54818bc91c1cdbdc014bd25fce7fa04c67d063f05be5fcd50520a82a4e72b99c13145c0bb3942437a248bc14def13a0ab02c56565141335bfaab7ed6b77ceaf7c166621ca1818c9b0afc29eae6c6ea8bbd13cf6ca1a872f0915cf2601be529fb41a0bd0ca71202dc715c73f255d15e0e561b41adb8c8f28aa84aff56c185fadc68565760fa80183349de26d34cdb87d91afe9148dc756ec216bb3d17dc1e02111388ec9100f56dbaa4d22c462029b6b464d286a00c22c757223c19566ef2a9d54815ff8bd97812f3331b3399265d3c6e309028cbb75d2aab7ed0f69b818677a772675b30bac1f542ca34c12dd69644571bb895143ccc2244dd4968c1ac077eca9d3be2d316dab16e77da92f933e785c46f2dbe7a3a36014d0e356d79ea051ec6d0c092bd9df6ff2430c39d049274718f4195562eb9a33512b1f9abc6bf8586e56f7c65ac0100c474063c75ee9de73f949acce81916a88388740f8080b29f0fb7b1a6644f949be252f2a09468bffb0035b7474753c94978c2e76ab4d10f28948e23f192cbb0bc04162af677b7c64c70d7526cd1adf72f2b7dda83c3ba021965033ee99d39f60803fc0a245035ebbbdb630439e728d5ff1f954d97808ffab84e6f09690d255299f2a591978ed01906d9c6aacba27cd713108df306207761b76c73d2c79d11dbe1b39562497a8a9365e171e9986e92b8f67f0c41f8aeeda2b93771eebcb6f07aca73b3626d7ef7db582bd9b466570a494c475b0d952c4282124c1090267dab6942c6cbdf4ce9c2f7e843f8ee5b09b612129de8c28fa118c19de6bbab26d2a077d8e00f490d6028fb08faca13b73f1dcb61cdc51fcdc4e815faf923ec47ae1d282203927765627be8e827d2f5fd0ef9951f79298655f67d729b0bb9b69cabe99bfb49cc8683d7a0de55c7928ab8d9b9173e23eedcef9b779a6fbd35400a3ebc4bea01193da5c39197818716c708f0005882da11000835ca090f0612b1310dc3922c0c3a0425f4dd36cbcb6a8cb1d22474f10136c1c2cd3c2bb49e0f5aa91f1d094011d271fda5236863941fa45ed2b0215295227861d3eade721baff8770b60aee80ae95f05e99acde552cbcc3f4ce2006cca3f2357aec3506a77ba0b042c14e402276d9566c88cbe411685d648152ebfee9a1b18b1f00b1feb9bba37e9f13638aa23adfe100fd7558cca6dcfa8bdb9092b96e943b559dad0cb8e7fbb65bdb7ff7e0cdc752cd56bd0958222404a36de4f0755fefbd7699b9c65819bf45158fbc014b0941bcbe1ce3b5ce24a786e0aad55da0d555e6bc48d7ef3eee7f3d3105b6ed33b503f5e529b74b5ca0eebb5cf679615110c42aa26459f4d56fc2141aaa370d52bf0d7afe7fe74ca579a9b27a70377e96ae5b7004e2a0a3be0bbf3dfd594818c23398c62ce3af33d1da29909aaad484d81c61ab4c1f8b3d370c6ae7ba963563753534b3ab72350184cd88d9ce5411b154939b04c163ed1ac37043efc95381a72c54975af99a4d5d21777560c19d45fff97edd862ebe07cc9cf211674b4b1b86b4f8c938e893b451c41bbb327c12c5be42c33d1b19695ae89650b2a56dc5cf889e571a1a69e78b630266604b11d43687142810192296a81112676efc5d9406586c5aee4c70b82c5de193d125ac4c80a1ae4f3de3c403dcae27059733347550b4e3ee15595289111940b89eebc059dd128c8c55b7cd442fea2e16f7eb50107012edd0999ea5f750b0bbc97dee3e05a091a25dae7a71f8269474db8c9d3ebb7c1166f0b86d8aa0e1474d338583282c93eaad33801117257b5213bf542b3b63a5800942e417a7ed1ea332f420ec152689142128a5441c8f2be86372f61d6b55859b9999fe324d94a6c91a60d0d7f6dead5ac699c6dacd0d5bd099b3089e3554eaeaaf2eeb3b36994a0ec56f6e6a9e7b6883986e3f7b60659ba8506088223ab4d2f5ae48feef2a1e3195941dff06eba6690c153f38e35822a546fe18af9a9b0f80db6f85a1e6be3faa2b5a4ad8ec7434ad02d4e061fc51cc6d8289dcc185a3dea0f73540c050fdcb53d9b08c98fe244e38a6ec37cd59e9801aa525dab2839682e990754c4138e968171bd5ea09bacfc68940cb755a1c98683f451ea4446c111c5860db886734db8dfe995f923ae497d4455be32b943cbc448b687807c27268c24d91439bc9d49e5e564755848a491a3959caa1270f03a8c1f15f2237aefbde8b32e3192af846248bcf153f287d8e127af4243c76b7ed7382c05329d271300454f0eccf0124cd4cc237ffa395dcfd517989be1193928031c673f2f2ab54dcc8dc801863f7891deabeab95f0fccf3b8a889b98ebc92dcc6ee1b88d43915a5eb93648030f1d944dc8f783b52b3d963c3ba737fa150d01ebfb567459e3f7f7efdf85aa92ac811114eb44608ca1b0dcd739577831c9b71779434c065f5c8eec2427058ceaa9561549918625e7b38f558985d6dc1f5d09774e1606d969083a113f90afecdbe13eca87d11edd38450a2a9d8855e1db240883aa89e0aca55d19c0e38cc613e0dcc3bfd82439dc552232ae6d2020ab6fe212ea4b9f2060f76db25a3828c8967a174ba3ce2563c1512e025d71d5c630732ff97f3afc125b6bdd347767e49f20d4c4b3988aa8327384c583013c2cb10dddeff76125f24fec852385257835a0f0d63bf6bfe246bcf95860b6d3bfc7deb14e356a062dc547dd05b7b59c4f4a6c2c1e9286a14b9913b36ffca02485aab84319c39901e803963eb4865b27e97e7e6446c63317ed33285c0e0bd95e485b79bbc2b11e549829dc134b9e57a2f5530c67517e221a7911659c9877fd7dc4db7a979f509df311539817a36cc0f1c207ca2d4d7397dba33877971b3eaf698c0c05868c1c0e57d1f45dd43410f94eae8b8312d892ded3b97823b54bbe528aa693007972b9001d0f7f8e62767dd7076d8dd1a1181ffff2f3cca09c6242d2767049f47c54bec62f5c3fafe735db1cfb43fea7a22fe2aa1d49682e06231abb098359b60d6be4dd9a65d7d5e225a071fa9ef47612e46afa9e9afa8d2ec406403361e5bcd137c685dd9de809120251f9569ebef54177dc54d8955c3847a20616631d981bb3f20ce879e376df7e59b6ba633a6dccd8f7e31ab905edbb0f5a049a25436c58e7798a616956f08435aa1ed8e903fc9b6a4445d4398c2f4a4e90e93842d44b85de656dd6de9749cfe0bb4bdcc896ff9f217a515777c88f8c2a1653f5d0a7b3f71477bfc10e69afa01b7a474a4ed14cad58a6f0e1276cd3dfe97572b83069b3bca3899f22b142aedff1a27f99ca39716a678364bbec266a6633386d2ce268fc89a5d062b0beca391f9213775ff10911324014d298cdddf918ed682421c86e705c750dab3a2159c08c7568cdb5d8d6c1bfe82c30e7047d7bf313e73aecd91bcbe6d670aa8073949e296ab957209e7f10d5a066db1c3dffb98922f73b647560d6f5a434bb7f45e2fb16590b74f99f7eb4f4f773780bfcc2c3c09770dff73dbea149135a27046e185368759c68a6a485d2c6ab060f807f47d1b853666263e9102f4c870d0e781eb3aae23f6f6361ac7f4542d5552971c0323eb0884f07d19cc59f2e90b02694a8bb6dab7f6bfdb0c8ab4838b7c2ea9e80783222658c9307a514c7d95d46a31ea50bf9291e3643de7a4fccb6e2b576b3799f6558bcc11a859f41ff69cf1ba8ed27f22be55e325c2170d6cfd329f7ad9398ff23d72aae20fb441bf7d8655955a11cf01e07ab14da64b8e49972768ee02024ca1562e49b3d80b3d6d970d017282e0b9e887cce4977ef5ce662f125463f50b942ca1a5bc4df2e42c8482a115962f17600b45ec85a93dcd64afdbac283c21aef63936cf53aa464877915be3b70b2eb5f65001cbf5950e4ff9d521222e119badc65b073c674cac448e600d2ac2c3645bc80bfc3324aadb387ed12c93892ac5aba278638b77fa2069ecc6da01474b8cd1c580f63e16f8450d721c8c9567fbbab18d6b90f49beb9e4d2143d2a6e3bed481a6a086dcbc5c279334e88cb1f6e74fab975e12bf40c44708eec0cc8de2e5d6f79894ee521bfa75586bb651e231e091e915a207cb35fcf1b87114b1dc2d9fff6783004ab6bd5f8529760a291a7b99879f6b0256080d885efd65fe95ec110aa027d41c5c747fdb2e9af32448be0571516562de44fdc8df7d7d6bcb04cecf14f030e209cccca1ac5f8255fbfa251141ebb712808543dbbc346166e00ec4ff5a9ca1ddfe26513213e97b85dd8e1cf3b28c755c7a9907732902d7eac520c3c37deb3c5036926bc1753366997bb965f2d70c65ef0cfd8c1bbbc18eb9847df8c95f22e72dbab0d66817a3e5973d0233f112bdace3d079a7aa12863d4c6515401fef912d7571e321221812e04c1fc0afe79ce659e22f8c417ffb301c7264fbaed166a4bb5f11b4306db9c0012e8292772e2e75dadd67d4d90fc4ff68fcee1409633253e322d4edbb462182374fa7d71a999660855a1d22ffc8a9bbe47ab6bf4b0bdda91c4017a1cd6e15b93767c3879d604e161147bec7da3b729f5308b11123cbb65d7f65431145ff68edf6e3de07f9dd497b1a653789a39c8b4cff269607744e190d4cde9f5658521660300ff4fb9a149a1da041bea728914e5b35ad6a6ed49e766c6393f34f0d393f09e542fddbe10ca4d488bdb1424a4f3b2bc7c1ed940ea69b82cc9b155abf818dd8d62de513a3fef85d1a26d3837f0b4c9988e8f8d9a080d0182f5dcf259fceade50c288bc2a94b197c81dd59d350b7b62bd31e25fd3da0c0ae5d3cb2ee30bcde7b52974dc02e4aacbb4e93a39edc0fb813050847af4dbe5495c5ddc247c957ce90b663cc7164dff64af60c831254fc411ffe299440689ee84efff51bad17e63f440c7cd50fefe99a3e4f7e6f887d3ca755a5398372dfa086f645aaea0b98f9337b6b6aad79687ce9351772164c31679e836177b9633325133bf580667c20d98c86aef8255bdbe751906d4212cdde38366ca01b97449cbc916e11e2a67b5836690af4e4346c4996b74c5621c746053295ad53d33403832cee44be27780d3a34af0820a6fcd327b5b83a39b1a866bc859ea9704ce4650841f320c83e925097bd810659407945ddaf2f5d632d6a7f2d58d6eb6fd2851b7d6f59391dd7d239912b9ac18b294340497a793c8522db65154d1f97cefa4421e84817734e245d5d213cc0cfe53d1afc39ab4a6e31b7722a46662b5f8e618e7d85bc5d89112ec1e69258dacf59c42aeaf4661dc86084cb802532ba72b37550b8422aeafec1b08c23042c508920833e63b2198288eefd91cc2c4afe84c755d9a84245985fdc8de74dea89b97333e44b0e1f02dd421c6ba7796921c4d557bce3295bc65d8c84cc1d978ca413a6d32915c7dc8b5a800e6f7b7bfe2234b175fca40497ee1927ff2939cc8693f61901b3c950fe7924d84b21de8d9f204a61340eeeebb7d9e2b6373a0c51472a85840650dbec8de121b840b6cc1717115cf430abb1b0aba0bac83b185198931e11c4eda6790206f4cb36bdb7fa5ec31e4a8d037b81f11b4cd623bca6bdb1027fad0604a8655fda99e10d76cd19111506322bd14fd466e196e02391602f017e79295b5f120f3feddc034d8315220612c4bff7bd7227968d80e26e33b950b4c9712d5355082e311823856ae00c1d85d594753471004d26e0afbb87420d5a16f56774ba01b44a2da738f517ee0735430a4285d09b55794751a55431fe22d073eaae5b2cc2fbe49cdb2a34a7f03a0bcb73c1148a6a8be1a18bbdf431ce3a62dae3f2427ebb462eea69f215dc8f5296f86723083f1504fd05ed0366c9bdaf49a3f18f768a5451872df9ede0bd579c0bbc4ed1aaba5407bca908d5d017f827cd6077389ee4b71134e8a82c315b38bf9464261cd2dee56e4516255179c65155c979acebe96554acf75686880a7a0504d449011b538008630d0abd9ec87ebf4561781c3c774c5d788acb199123ddf82d79c985d9e5af0427577bfefc4b1fdc4338d327e6a8de4a141ca8d845b31e2ce368346ad6cf71a0f573974da693296547d7c281b66a20578a530cb1a04b2022a53875ffd1ef17aaed5013bf821b97bef51f87b0c09b2d01857fff84f08ab63d5901f0a6ec048b740e26629eaaa71e6c32ef5a91e5183a8d93e8e7a603ae864661ca5954154bd15244586feab8bef6983f5136d4a9210d817e776b5f224d03e8430f0c12c8c6091d85e048d5ed2b4d936ee9697b5c110b29ac216a6cd9cd1435e521a77e1cdae4b3fcc9bf4621b3fe4c606f105f8da6851395cd9e7d9453411f4f6bac4b24fd5b7449996457856095dcd5634dabd352189348a197b8083917000acd17bc99b30bc6c8ae6dd7381e37fb105f525fe44c4b4001ed22356f5c341205a5e52dde191c93f3f505c9a979f987c49a2ecef85e9575c923027f8fc883f80e36e18a48a315c6ca733ae3c7c2020495997e2085ab19d12f94b0199a843234de760dd6c3e358d253863d1007effb17290e2cd13ee22bb70bd34ff7d2946baea98978a6bd7e312a25e7feef31ea990aca639030739fbacf510a58010c762233515e50a36495a5ca02c327510c3f704c948a76e1adef3c83f89d7e94ef9d12f415419d0c374e34ad8a7862bfc541d2ee37e9aa5caf31a583ecd861001bcaa103e3571d31e14faf54f1cf75f13b2643264996026bb3d028421594ec0b092882d925505af96b493c46cebd23580dacd8d0203b05b0079161766909116ccc9fc8d336bf385dbbe1548af802ec957b4affe84c42af1df2686a9c13456e519acbaab051f7eeeb5ca84c2e733bcbff1d06421191331479e71f1f71a6e6afd924663f151e538744a6e17dc4692ecf22645a1311775f03e2112e937a6124fc9bc5396b09c839d09e2348bfe03c71e13be8e017526f3c33462796297d8542901e78da9b79a85de242561d2e9b9eaf79bd91a01e638117e2e88fb37406b9f0bf5ea4b410b57df7330fc323a913bf2a01ce872ec6758cfa4ce2dc362ae37c3fe84eb93a3af1330086f5505c92e8884191caf30ac9df17ead79d8eca04a8b01f8b50973b26c53dabd67bf7a08ec1ed135fbf93e30e9bb3dc445a2b1a622c279eb4becaab07ae7ca3ea3abd7603c5429396f01ca6ebc6e80de1aca535c90a4b4dff65966ba78bb9ccec6006b10423ad919f536e8c6824ba8e22fc128b4a21d38e0905ced3f220ad8b1a2e33c03c8a9ea2c713938c0e99b435ca04b2f0d71587aff1d28013ec9698d6707a8ec51bb161de130e95d66cb18f504054417948cc13077bf673a8f7f96d90d42e8cc642d0b6da8d571f4a81195eb98cd1a50cb9f1ef8dd20d6d7ce1b988f03ec75799b125806ab7b5f00d3c234e31fd31e1fe5f74509b85a74c71fb2af6f80cd7b264b7717ef6f0231eb39246fa224780581fb7072dbd21c9f86566034e3daf8323cd06781d81864e258efa9c492eb49d6afa14a354dc206c17feede31a7c9d057329988550a7c71acf2fad63e01fb3bd56476b01921e39fd98b6dec7d2cc9f2b7c5835e37e30071de227cd7d2036f9e872bce522e038e4dc1211e5965f6435d64912a46580ff9e23a57b5cefb9d53977b2c391c8ae23f6dde9df539537321f7d85ce64dfa9761da8317af965cb0f5d9c7cc90cfa366367c94cfd26f305d8daa7359ae5aae9a0916196d881ad929b07dad21f7484df550bdefef6b63fe3bd2874cc76d924f4b183b3c93f0f38ad253989c7af7674b13ac74bf27859ec1d458e15861c1e2e80af873a6cb63b9ce816c05444f3759edce102b5b28019d4925b2350173a3bac935580445b903f14a33444ba20f118194c3978b59fa349b295f1e0fdab8b0f09e087985413ce45febbbcb390883591c14a273b58f7f1f1a66914148b3563b1b02ee2b19fe215475c14dff07db20017b33765cf9db04002b549af8f7b097ce194dd398792ebb0d6549fb6b77ce625cfd34a4c66fb25e4c0470135b5e4cf33b0a96b220a4af73590b00224d75ed454624969c6ead88f2525a714b472eec1821e6815c7921a18cc3f5fc72b01453ac70aff09d555134ffdab877917e357384d954f81ab51091c2f72f219baa92bdb8cc2252a60e27b07dcbc79df9553f189e8065f7c251351cfdfd4201beea459c5ef89ae513f1b558a8ce37788910f213aed6f9cc6a1cce10e2ab242c04e78f0e8aa72d0a7ae6ada9078fb5bb16a7a6277b03591ef059cdcaaeadfd7438b9c63feec398817a2c6b646dae7688a06adc0e9fe91c942c1d918193fab0126a93ffbbc61c01484a8518ba4a49bbfbf0c035ed1f2d457c45e9ea0f788a607bdc1715261bb9c770d514c6c9a2c03eb911dc2f074ffc64f3daaa4335f6fc2d155b108d883765af864447f620addd8567e824b42e08bde4a58bac1c205c8c56fe459f1523fd2b3a331845aea927f8dd1771b17aff2b64de6cd7144f630920b93445b1755a7363bc68482627529e43310af8a0caabd1e2644a1496ea7786d69120a6386cf8e8375765e0328e784f1ce2cebe0ad3933c5f1896c76df6659364466e175ea7f9e015c0842faf3195868781f724ced74246c295dbdba40f496b2232f80d41e78bbef9998dad584585ce3954b818c750b9002e26f8178adc96e7789ad255e0da2bde69e85afebb6e32bdeb8f4552ba3be40fde3ee82d3608e9a736a48ab92ba39768dccf2e8f5b570ecccd5c1c5c06ae2bbb42011f5f6f0a322c76d092596fc4c06579b4724d561a7c98e353f67bfeee37f22239110d0f39a00d3fe1e12d8053f85458faf5808e5a63fc5e35e4a8e95bc9297aa2ac0cf40ba91aa535a1d409e49f7ea3a98cb8c177b35da63f240f106806046171e5d85237dd950c4b26d02a0f793225c3515182dade7be2533b70196d5e9b9b1b17b24bb12946b32c1867d0fa75c3c53ff34de59b4a2ad8a3d1c3a437442941faec74773db1856cc45b9c3ef0e0395d230b6558d7c4d784991da55b0ab5f2e89e0f082faf00cbe299f23b2c7b31fd4a947e4ab1ee7c32da992e00716da36f30c9aa7955b9be5339b5742b7a571b84afd870fdb4a4801205809b9c989f92b901e30a951e6da3a59899610ab52f9162c0f77e194b0e81a959ca23345a811d054597cdc8565e1e996ebabb85a4e4eef9afd63c1728a840aad3b6d9d1a07beef5b1e5a7e80b79507853187d4a92247d6c47dd9481e44cd4846ba5d8905a7b4f157102b5efa3e11a36e75403e6b94100886a92ec8632be737eb8acc28a2fd37851c20562a7dca25589b719170533ba97e4f6af7da606aea5d1253f5335514a1a03f66c3cc9680d2b1487d5977a614665849e9900c412c646f3bb1796218a8e0cf6b775ed76b17cf5c7dc9187083b66d8eebb1988c3acad629b3d4db732d2cf5d23d3a9a007b1e072a2031759aefe33bfb86e173f3bc2232fe07c704c8f90f768cc786ebafa36919e1fc32baf802641fb178d3c71604c9648b797ebf878cae0c4012014b9ac1bcd7e2a0175680d828bea00137ffed808fc6e8ecaf3e5d91dcf6203ab1b66e6fafc79b39d85ada23058d8ffc60cb86ca0ba9c02fde93bcb11f8530fdd4ad92c260a5c6de16fdb38e695a5eecf89e090917d33a945338bca6389e6cd747b7ee11fbdf7ef25b189f3fe5c49f1cd62fce0cfafcb62f8a887d7dcf3b4e06a8dcca1938172381d7ab822c6fbe7ecefef87f83e8505746064325d0bfea970d1028bb0e0ea507cb18569b1ad010f5ab40ba52fdaaf05aadcd0e64f5b84c7497d52e9c716e13f96189e10b6edfd651fbc6f746b4db70482e76f18e68a497e4c93f829fb6879f8e84fcb4fd2aa7ff0f4d68777e47e65be8343cd747ec8a157f6b903e68114bbc4ca14e5f51caedcffc9d22c4a0dc0eab0f52b211b6297fa37d710c7e37f80f91972be414dfc3165dae2762ad4f5921513a5d61d44ece6a331cd1e9e428300f78752cd22847f0c4164a593cc7aba60db3f53e20b62d6a794a47ae29147f74178021399e9652242c389bb2bde7e830a2281bae0135fd9042829a416f39000b4eec6db9ce7be3a78958797bc6a9f214ca7eda6975306fffc209af0fd57f62d705b2f6a7f79b756acddd7e91b7ed20ae307594baa16c45c7aa21ba4b9b97c8bfb7fd23368bdb2e1718820fc65d54fc75f04285430910eac3849e7b7f4b364e74efacfcfd78c57f6a54d8ae861fc71268ff0d3f6f482998d9c16b7cd29695a4eb8fd1c8ab9107546bdcc1a6c96df1db5b5f73f400152714c1c0059d8ac5f2be262b328449b8f4d269cdf6fd78dec0ad06b5049394b15ef46181fef39f070e8f0d49cb20962501b0e56783bed523e8c097ccc6ad17b68679fdd07bfc7d57aed1766149991265490bbe9a468c8d495f4520bfb03785653cf7ab62b7144ce91bebacfd91d3ae3e0ae24ca3738b7c3de28639e0300e6ec87fccee757e4c5752a1d301ee37534073260f507e129755af6f219b57a653186b33ec5863b38377ad131444c007bc2c0da3dbc1bf7fc7aabfc945934ee6993feda1f58fa5cad8890245d226ac8024f2092b1f034aea4810ccf80d93e5badcbf88f5dc27bb4e675a2091edeefa5438774c8df0f846d58153e3c6e140ba5e4cb553bf231b8c5c5697e9532bf787ea2a4d1b3ae6ffb79989001242ebc2a202e8da4973a1e1d32737a7ce6d73dd57dc794de9c9e6d6ebe1eeafc4419b33674ce83118e9db676f72b37ccfc41c6b6c797f3dca7389e32b2cced6f2d83d72aed3f93b3dddef6854198cc1e9c0498aeb44d561c0970672fc4f3813a2e39ec107a547524f7009ed6588e7f248d054da6773862b0337b8d25df1e82e9782bee6f6c255e321a56cee4f42f048e7e44cb5997112697a7a2a77960e4d52b79795b92c9eaba111e50d67125bc3838ff181b81f5c3fa5ec28bc703075d921b149ea59a2a34eedf67bba48eaffaef758712122ee87bc9dca31cff2fe4ab1bf0283347a21ad0c021d19d121d5e9c072c8e0e295ecfa94fb142689ba32849ceb56759272e08c96b423528a7002eca4d5b940c41ae2ed71b794be237ebe704ebb8012cd0d3d856ac8e01dd1e6236ed3791796d6633751add38153cdc58e2cfca412916c424dd28e282d58ab20b4e80fbf2d6b1ab647473456bf6219d0622d43d6aaeddc49f11d1c8d0943328ff967375a1a4b6cfdf0a639ac060f016466ba5f119465a2c74e099857ad011b9ac10e5f3f704981e2d379b8e1b79e73b2066eb38a47fc9df220a91fb0e11bcf398e924241aa7af3f33c7fc65687fb76a9deba9b80b1fa61f21507622d82fc148c36bc02c06f755e3400aab6dcec33d85a01609887d76996e2859f6a911b754825c9eb330100d98b9fa8a00b650bf96b585bf9c1c4a4996d2e2ce13b65683b2320d58f3c0b52c7af783d3d3aacc322df275e7090902d9c283630b2397dda64152e1daf031e9864b573870f3c8ac7291730ab85f13bb1caab70b6eb63b077ee2d2a1e64ef22df599b0b30d9f1d2ceac22c2fd4caff1fd3f237b67d9604c0f3993f0c05c33ae7353e0974d1056f081edb91f26ab26ee9f58b7c8d6bb571035878b7c05586f6b8f83fff2ee617fa049524fa181df4d87723a51e476489bb87d83158f73ae9d0f931efdc301297381f6e5af5dfef70abfbe4b6f76d526246530b71060a3c7512abade02bd7efbc7541ed433f56257da5910b709812d74db64ff14f61b3fa24670c77f0c611f1e182520f27e624537c5b34fec8683fa41b52f626e203074503d59a143a422010c44b7fb34d1f2d522a8cd7b1ec0781b129b99d9fea4a7e9762b2b386fafed81f584f18b36e7c76578c94c95c415e140602688bedebb1af7ceb9cc57cc4a6e523a4f223fb46a855aecbf66e819944ad5172bb53a90b8f205a612f93826b7a632f204511b11f30b1306a9f3e89c27094c191248b2789204bd5f00afbed055a60d687802b8d395631ba1af204190e110c6b90350345dfdc3d4ef5bf54d1fb573319a3e1bda240738f06ee27c887d4c244941e2687fec11913860cb4e17eaac7b30bcd1c989534a887c705a5a56add0c8596c1415c73586e2674fd0767a118b1792b383a2cd51f26b6e7fb1bd07b028b3a4ec1f96ad2c764ee06d2642e6f34ffcd79b4057b135f20f7ac5c8559ed8e59d88e5134ed529bcb3b70172bc37f6faa4864221b5e1b8fd4ca443df3593be04bcbd70c3f30369d90574653edd2402e709cfaacdd1f2ba7979b84df84b55bb91390c19d023118a6e7d9c854c6eb0063737308baf9258bbfc581f0a92cd706f5d7cff628418c113442f766331fdfd725294e7cef4f734625f4b67f5ab140a3ec116c83e7e923beae24bdc9544f21dbc71ee4e1362d562fa5c1df05f1da76bce739e0a96293c06dbbc892ac5de2693db3a98572cf5e28ef0c31c57ea3b62e48b6dd92dc80a124918e57bbe30e89464cf6d302aa0574fc4573652720fd2041823ddf2d623d999aab458d7aa28b7f98617a1e19229213e8d647a02e4996591310b2caaa66c69f24027d7e8d5923e864b390e2d4a36eadbaaf15ad99128ce421cf712aef65b6806eccd4abde2698cf6493d6e925a6a2ef273fe176095b01b0d0565be954a1fe56bec67c1bef23998aaed32e6a6db1bff241c2c67a18df7cce4eb14032a64d6abbab198f4c783a4619a66a8036dfbd485448140041d941a5646f985a2f06e167063aa6962f06ce15e3f4035c9ffd6d3565c9fa6d16c7908f7b7a1819f2b8367c75156c5f59242383bcd49f1cae2f38b936a77eb883d5805e23f5e92a2bed4c7f3e2fcfe3e513887e553ccf95a894324dde80742fb7cff29b208e6886eac3e247efb2d463c15eec0eea444efc5e67af61691f101e2df2edf31ae62f5641e80e5a045a537b25373693816f8789f193012f90786213f21236671ec0db21a286c6282e23d4c1411321af37bc4bd1e84a0b9725749c04d9d79532dab0458fcb881673f186465fd6a6102edf37ceb8ae339e2dc6262a2022a050d859fe0c8026eddb5c5c6d94738a81563305cfeb3b73801b8fcbe11ac1c4fc85001fed6a477353b817eadb11a58110212f28ee7ca9193ba1ad6970969c53febabeaf6afd3c9f6c9f4c8cb1ce9e01387f8cfbd8a6abb13451a4e8e6c85c1372e02f0f6e70172b0e7a9446604250072b5935f863ed038b0f67f9db74c54311e0b0c1de6b01ce7bd7831ec7a7223d58085750c9aaebc2c98e3429328bf4ce18f73d620df56d8a2377192ffad799949b79fc446132df4a43ee514a7b6fb862ab3da3ee418c12c369f53c4bef9a4257a0fbab901d24ec07663e5d7dbd88b416377047870fc64d36d49dc33f4aaf6c6aefcbb2182794e6f2bab692172d23e5fdf21e68d25a106cc8638cd404f742561e3f790df7ce9cad2fc979cbc6a9174e7804abed740290fdb7258d2c08ea2153de0e4cf68854c77bce1f51828d9ea5381d8a96c87b3b816052d4fc27b7bbb8387e2d12345cc153c88aa0b8d18061facfdd55afc1f49007d181e5314aeb21175cfd4d3b0952d8819922d23e3f161cf94cc087245f81d97902191b93f8a40174a89170186888fa0d5bc833afd4e47d05a85700c85be659cd2f3372fdeb20a793d8dd9cc8be5907d20eb54f0397e8d80eb62dd37cdee815b59a7bfccd5c10a4db29800454485879e638834fde804eb90bbc0e056385f68ec3116757984c258ddf2c9a1f420d5ce93e1000ecc8d17286519a34de2ddb6590ae661f94de2b605dae8240a6d285866fa2444a1034f202179f62f49aaa0f0e79af86a06e9d412c6fbe61357b72323e0dcfe4a0f133a3e99737630ebf810dc4c9f405843e8793e6c61d3df9e3092609fd37d8a761312c5dcd0fd936e38c79e108a871729f702173332e13ba99230cb667e58819f9039ba334f0debf1fecd2e0033b5d6f625da6dd84e8fba372bf63837313f31b90ae7592487f2edc7a1ecd773e32087b67a2986871bd154de83090b7eee699f25433c90855939f457b2e5b8e534546251ee8c9993ac1de66bfc53be9308815456a60881611dd57e8e060746d8bba962b447aa5402e0a0aee2190a5e8a04b0ddb864f704a8b72bacdd2ebbc80cb9b6c60487a657e62df1d2008cb40f4c984b4cb30caa22b10688c6cd7b26da094b5c92e4d2f4b789397cda582b048409def4b4b0b7c89b8f4bfcb51df53bebf1d9b10bc719c77c686d5332fa710187f8168db03d1c6161337b688873e420bfa9b7b73f55d97c23fb2b21aaa930f67762979edd3417061b5ca12bef9cd527ed4e2ee67be2bdc81c515fd6f5a982c6c502b6185bfb7d01a35bbf02c35f2e2661fe763ad2f00bea4d7b710f2d14424c76b5d85d50cd4b9288a8d0ba7cdabf69dbea52589dc505438dc6f7464dc07eaea475f8ab651a7ca18d40dfa6b974f31d6fc340b4f60dbfc92ac69aabb6bdb99cfdab36d947f2239028db513ebc5f7582046a887f3b93104d642e05d6ab5be7cb42cd5d3727819cc104ecdde2eba67eefd5f9963c91ff9d4bef7ee3aad4c17911c94867323b9cd04c7f75c79050d02046f31d65775fb21f27757d3e6cbf18f6fefcc660e73b5effcf2dab58271a0d3515c0b7e11acfa462d21280ba5c5a42d6eed8b74a82e4d385ba5364bb0a1afad06d75d59a41505eb0b4d687855e7b22b9096f31caaa78b881806c5e9e1b47f0621c9df81e2d16f99061462bfea6587723e9661ec8a83c425f14a84f50643ae5d7bd98acd044993619f0dc505df70f42532378bc5733f9fea3b268c93a66b3db6cf2196d269a12a4363182b9ecc920bfe739f16a7e0d7cc08884c4eae6a512e40dc2a8dc907501cfabc01b5b948aedee5f1b33c9b6ad179934de05e3f5eedeac6420214b81dca989aef0fb8ac84041aeb1a53525492e1de8aae52b44b7cc42a3f860348c4ad6923f5adc69f82208c65e7b5efe39d3ad6976be3f672547df8ba30256e31dd672075a6881247730548d1f92e32f3e9918d8a29bf8a2155e08ab39d6c6069f673b96b4e09ddb993d438a95ee6c77427a0cca9ebb3df5dd3ce6b97102e5ca95e8c29321b432b41c2c3316443a171ce0a12aa5ba52a72f145eb66f388c692e86768094fe72f8c61f9b626c757f94793751b352c28bbf537dd784ab4be40d84582dfcf6d891c79e31eca72cb3bd4e7a3e59b9be69222e16409580eeba7a26f60f689b5722eef1be29ef2edace64fe215f20945bc92e6f65e7d867e0f7113fffd0f1061af584cf1ad33ebd5f7af83405664d789cea3344dd34a643ca7633bbee37e13ae6e88d4c9966983487705e62cec071487c64c31e51c307141adf67a767ff17cd27f76b1b9ad5b7e9822d9969ba0c4dc0f807489c497955a2e3cb141ae1f6a0dc8c6f26496ce482ed6437f1ef1bf58316909cc9ca7dcbe6695a1c22bd2849666987fc5b57d4148d95a6f6ce2fd761e411caacbb565dcfda6a5ad4c85bdc12fa88d0b7e1aa8b603e68a21ec73ee7f59058af6229f28c1de0c5e18c2d9af1486b0ae24e8012bec326101aa69b64d8ddad704c74d03d608426339174a84e2eef60a07d3781658c974821b14f33574dee68833320fd3c658ae4c130e0dc4eae9ef59522f4fdbd8cbc634a70c2c9ed7a127774f73939e5d7c01ad1286b02e5615c0d689a68239f44958b034332da23ab0a6149b34620ab2be67edd08a8018c8cbf1f5a703edb6bb3d091ea7a988612bb7a392d84a9ea0586d8b893016146034568b04272598deec80410c5497c7ddd9d4896960ae081c344585b9169686945f8c5ef58345ceb56e8181a8f484ba06ed74ae736ecce2faf739a42623bf9136fe52d3ec28c3cf8fe6c80e314f341ec4102478463511e3b7d55ab429396a7be2d9f418bfb17e8bd7c2045e1542ae467714c400c9a67a60226e2a04f263ae12de08ea5cbffb3f86202c6e1324fb30517a7f515f09adfeb69db439d894f0efecd2c6e07ff39037992d291ec5bf6b3623799d57142566faca88b58a1d6259ce05074ce7480e6efb8679baa9198ac39c8473bd50627904f7bcf74332ff4dc93262f3192019b84213250deafdd5618b3cc9bdc711f7bb3bd6d93a49bbc2a3244e9ee0672be9c5e887c95272fd89e2177187e033d7c91c279d732608af50cf0260e52fe79ffe1fbd95281bc2f6e73993c3e23f25d821bb749178558b0ceecd05327ce2d86f2928509a74d93a82c76639e23ef680bba99eb7673873eed67f09208e4efd7ce850dc4d4c652dc06cb57f99df9ce67149ded594d06f9c4dabef0c329118cdb589e35603a902520aa85dfc61ec5a9665bb5e693a0bad75b41318ca6ba29e02b7f9e2581fcb597fa6948932c697729bb550be55b4358d0faa1cf1695677704e9743cf9b32314ccc60ca94aeea9965ea88ce4eaac8fa0f31fab7f5272fdc2519bbaa8ac487a14d124ceb136726f7600e31dd2b7d2e17a42c0c7ee180bef949c06a8044af40f23731de17b287c30004c2b390fc7eb1c31e347905461c7d2056804ea28df95b63239cde9992000c20bc3fba72f4bd023bc11f054054cace11e72d601bcf5708651bdeb7f52713ee3474e32401e81e260201da195d41d7c79ca3b6dbe98870d594dd338afaafd9ab2b28307726bf4bd40da034f8a4755b49e546e30cb84a93250682fd57a405f8834a2139ebfeb8e14b55a813f9f974345757b40f12237661e4d1d7fd055f5fc6ed05c9ef23ba68d49b2939ef0f084d321c80f3dd193ae833278f425c3a9685cafd34174fa1013b583b3941767d2f8673185250d1243d82ccbbb67101e514238beee81024efda95e01323728844b78fcc03fd427f52886b9d946d74ef71e4d25e0b367eed1d3c0397233db91a29566f14bac87890c8eb50e2b0b8e6a7e5661d0391b302170f7b9d9fbb933ec229f172e5825e0d49f952551f643d6a6ef311f1fc103734618e4826b574e2393bf8bb2822c29237f13b03de46de71da0d15b79bd1aa91b7feda6622c287fa8c37831e4735bda3bea912744ef91372bfb84750fe29634f14abd5f187c435edab9a99b61da777e4b8e9096e4e270376116b29458534f2aafea99c549a424fff4e15f873a00ccffc9942d6c06b9572d14efecc19df7dff8adbcb8a241af2ffb756e5de9fb25976c3687cc6df3e83025eeacfb77c479526e1b568353fee7b7f048e54866a299287657f3ca31ce49766d63858827e9cc9c40c35a204a90ddf7fe03766bd95cc92af30b27a0a2585da71937e9abb7c99881866755978cc8034a4b342b08d11efc935fab653d820abd2a800f2ea8ffffd8b83ca9121934374bfa81ba48c611039afd56f6380ee377a3debd1a26644b0c3906c38040e4ee794afa4b3769e1107e2e961b97bf8aac07cc612fc357aedc2ff7495e4654b47ddad29adb872cd277608e7d15321be81bfa224bf973c716671758a8b64af9a6353d0a2f675289eaa5a9cb1d4c0660153ebfff1b826d85399455f59a57ff890a815f6426a7a213f12e2ae1fef01da8dd789de3b5f7a971a880ad701e31af55965e6615bc5996ca1e58f63fa6d30e2cba03a8f681c4d1e73e3b2d563617c7b423debcd7d3be193f039ca8a84eea4a83996805bd451f40458e4b1837b043ae2d1da7421ffd1ab425bb2b74faa7cf006ea30886bed57d177b3e28a24766d02e2c7f72ca13df3764a5956707e259428ccaca978a1a741b661eb2be7809413f6e0d748ce8ec80e28cf5bc653e92b7a37698d19b3a42ae765aa8f9ee1ecddef375824b581189fb6df11cb772a5f0ed7a072b3df10a53fad387d8250c171417b54b8bcbca075a222cc2e39b8bcbdff8f064ed9a4994cb29b83a6b5562dd1d87309a8c9fed9b009bf8b84aade36491d753445a60a5b9940471dd956eacb229f476e941f85fb931acaf451998613d0acb962a09a3de1e99048c6cfb509b36379779678e45d0c5bec5b1ca54021ffb41e5ce3cf3df1fef64375dfb0a7152d24f5593406e51874fdb6465e9b235ecb088d2b6a0510b68f387c07b48fa39ecf2a27eff878ae9dc0bfa80b2de58a4cb401c922c6db72c0cf9b3544162ce47f413ffed5db031b3bf25db1e86ef79be728e17c6b22a49dd3388d14a4e5b2487ea9971493294b6bb30dca50053e5a60fcc81255eeee3331859ea848d050fac8cc57c17b4650e78d5c47027ab8d9ae0e277d9a1a32ac6c5efcd80ddcc0ef686026cc26878c32213d8276691212d97bfbc47cd1119d451cae3336b29cdd30afddd3cc988117db68168940e51ca31bd42d3c1801e32ff1a0cc8037e279504be392c85626581a5d827045f6adae81905174ba1457ba4e1191e640789118b13fb02a90dbdae10b49a11a86c5680f96c4a6a6a54ae61f5538bce37e1ed3845b93c9cfe8b1ff26c0779e393b50ab40531289b217f708df25461e51982862ff06fb147822d7361985d533f56c7e845b877e557427617e2f8864310b9b4dbb6b1f66f177d139e11465bf59f86459a8192cd71fe7dc5862446b01f1e6192abef5cd0bb0095d1adb90c082fed4e647f3f24ca714fccab4c72163a4aecc80bc08321c45963b6f1d13c51517d4a2d6e6d4592865bc62b9ac460f9b42ea7176215c49c5ef476f26f2689e98642e2243fbd90071fa328c5b909ee9d4f9040c2b050f5d86c9050233b4e953fdb8eafeacba963e736f71d5c62b9ad4f625a3d5c61864454821172cabadd862be878887996fe2fb76f8de39ea485db82e6003df9b3501e1e77ce158b46954bd32a06ebde3a16b9c0f47e6c57c2973d18fb70dc463a36e276e635a8d5a96b2f9d80a34e00e528075ef33481b8b1c200756191d6185f602c23ae8221d6a66839aaae2dfc8ed8ea05ba1be5af019e85f825005384bbdca12fd17380317b704f595cdd89ae5ee97ae891231e207d66deec8860511e0341cdd9831a606f783119b02319ce7dd902a1ac2c44649b6a1decdfe1310362b8735bbcf4519cff79853f7d2dd2f9d6599f5c574fbadd5cc388617555c57a7cb52862f34204ee615cfcd67a965c3e82c954c3c46d460f7ae2a2c7e57c91b65cc06bda8412e950591f9b79b2716fd7f902452f25b9afa8f6051b9027abb081cff11e37f274f61720775b01154ca7739318acbd81f63c61d54cd4f7378660e40643734bf690e5115a53a9125fd4042d3ed3571de2383ce4b74e64b9ad4a82246fad7381a904b7bd766fe57614f66c11d77028adedb37ecddfa9968fffea1e56f3227760866a2e8f7504e3469c05243b56e893ea21ddd9b5a2ece987283fdd7b1387b163083f51433e006de5c7925b7956c02330f8faa54fa30f0f2594a48d376ebba420dfa1ec44ffbabec94e16a088b9d2f5c394124093614e6e517cc1a10aa0c4a8bdef120d2144ff081a09f666db6a2e3b36d9dd8bfbf38ba221239aae269a0667b89e58880bb65def15f34a87f282a6ba0ff4146bd2fb99f96692c9f0cdd29963fc1b327473b8310d51436bbe454d844cd0c7df488d26a8f511cb7ac343f1c46e49ab55aca753706cbd1d7a2bbcf23f5f3dc3b49039cedace648eb2294dd7b82fea22804f8b1f570f86ad25d3b4ca197500054435f98a87edf52a954b412ac7a4ba1a08415a205569b9af4b1e9f94eca295e44e2b8fc7de7282f796f0a9bd6d9b7e857ca87dc713e3c3b87357231c97118a3a75ebfbaad9b09065f1077481bb3788ae536f708a5a5bbabeed30db09ea7f0a0213f329e91bace2d54923b0d5c571aed594c6b3c1a3a074b2ea3b9ae21cbec12d4244aa4c19a1b89832fae2651f9593e3b3a0d3c19df77731147246776b3407caf5e3800b377ee3c311e6e5ed83c13bf08b337b607f99b19affb04047a3595dc6ec580139d166a7c80464578a3669f395827c99570b32011058355d97163d4000ec32bbe6042f6ef38a979b76e2d6854a63b995385a64932ec2256c3fa1ff4369488076c6dfe4493f1cc56c5a28a2c3386fec93e106420c884b0a5270295783624b59405f1e43472755d9fb88643d5954735fc9a625d58126af4eb0f44c0d5ea764568727f240905f0be0a0d3a46bf5a1731be1a1829b46a5d7c21daeb97f87616e13481661805ea0728c1bd236c4bfed9f6f70d9ff0384a8ce1aef50061f654081b1497db0dfbdec73b463c2b1331f6ad36f7b3290f2a4bdb86f8fa0bef3bcadf7576a3ef5eb1eff7cd20962e178d0f0d572095e384190ee93bb68aebc14b47948acfbad5366b9c55883276381a64ce0f294c934b33cb3912e605cddd62f1d98525f2fb4b1c7be18150be05e4ba57fcf3e32c732d324dc2033a2cbab600717c98ca093ff9dba5c1495ce706773b1ce9112702e057faee42035283086faf1fa464da49f5af79c8fc032d8d19b51d96e45d7b6205c33832c64627f4424b3569bd3062450766fffc4f0bd56e65ea1810b663c2f997248bee331db97bc328b34d2bee9ded3bb5c2c4e85391b3d1471e0bc1d564961fed571251cbb448e4b029e5fc0d01348f76e9ca278f31c618497834e4eef37157af420e28e8bbec97e723818bfc20785edc27e7262f7f4b94a46c8d50c907238fb46439a61302102eea5bb63df9b85fa2e8135895a6661fcee1a64988956345a062dc9e8f55dee453c40770b73a1599cb9acd77f65f2c52a8ce2de429ec5fb4913b890ddac4f88a7d44bcc58a4ddd3de3b06af3fd596a625271e116f7c190c5cb384ee27bdc4b8554979b083f6204ac30af1bb5447aa2ecc1638ae7a3688eebd8be32b11b4402a444d652c71f57097f41c172e102b92abac1f45b8ad1c11ebda955204472b2cee630a88dfc1ae7c96f39c21ef7af9b21045251e06b1282392d057232a767db9f86bd6467930ce68a953e43b191889b373d39299c454f16f37f3064fc1b483609f3188ff414077e63407f23e797727cd8db6ddadf2a6e0b57262c6e5e1bca55b2291efca903b361122bcad53139862ad3d5ec350e359a6299cad733a19f7c6cf1ee631225482a2015e488a929e1aac6105cc24f9c07a206c5588b3e8e754da2f19140d898e288c5b5b2659a7034440e08ba3a1c3037834a7018f301741fb26fcfb1e43ddd4e4ce5f8d0161c8e2cffa041acb545cfc775281461b3ee40fbd87348f53b0f1d04e2433ee5209600c9303441e9c54fa50ff9c148f2851bfae652fb40700cea9be6d8f1c7a0dada00aee7ce7aca3d8eb74e7eefb8c48018e6ed3bb3475bca3e0f2963b77b35a66da950f9e68f7f2266c36a539d5b0a783df15e2a1e553436904509ce8f41d67e5d21c07e357dcffaabe35dff54db221d21d5b253c5cfcd95a76d24a3e97c33ea48f41a73c535715d8d46454a0eb0c66f09f6c7306203049826c0639a177b1b909fb5c386abc0c54b9168b127d477f2c01bd693fd03d946576498de5620e77784d8df6fae63cbf425140c6fc1a628d791d84e7c3ef1b3028531c9e25672badf02eaa4f7a15a8dcee2aa804a25108fef21f896efdbf40ef566c4180e3983b6989d1b4daae9277f09cbead8963b3005c44d64afb74f3db22bd7cea132dc8c7cac74ff3bcf0daf02d098c806cebaddd76934a137eda85aafef353ab4892cb52718bd73b50baaafeea370ceb1af3d2dde10417d75d6f563c19bb4406a4d3fedd035b610da53ac5eb21d6dc4ed15903397250f584ef40b5b9f1e0d559c2e07864a8c05426feb70a78f029c789268b7696c565fc6a02336d0665bb777fce26938e8fb6abe351c208341993840d8035d82cb9203ed356da14873a3040e10a2f9cb8682367b3c9356eaa819b620e9a50f63af20db7bd2027b0dc974defca4c8dcf28e86666ad450d0da2b497284f0574b91c563fc2a988dfeca18972be407e1eedf949f6f3f5d60454ae5fd7e0baa37d613d903083b52bea83948007bcb41d9709d1c70899e5450c6a57d56567af2d88408d91bbf7f59968899cd0c6b589bb6172ee24540a128a89555e8c5ae095ae316eee091da4ced8a1b5d23195f3707ecdbe8a24d93f3c566bd9049db9772806322d41f2080b3cdfbcf0fd40ea44569e8c68ba12c009d88a0bf2cb47e40c8f6941fd5506cf63781c4babfffcc822bceb8285433a45b459bee11bcf6c99ab4edd4e9310448f401eefa2cd4d4948e81f44e47cea6cb58cb6bb05cebd1286f4e1bf0632746f7e16f12d0a48e870ab633c21a3d1bb807a598d0182d277e365d7b23fa91c278f3adabf9db08d2f9d0a42c70a2f5cc2cc37173c4276667cadb34018df301e386e2f226a7e7a84a0608b17941d838d6ab0f68cc0e5094cafe3e99cecf8c85e961b0b81ec009bb3c12d2906de8c84958c0a6389a1842e38721b53534c349401b96b420a7dc6feba7cdc0d45d71db186b8c217db466e3246b48e6a9a0d15c3446973a5322d6a865db6297a0a84a81dd1e840fb551626235b649ccc478d6dfa1d7f0f047f3af910a836353e9a549dc4ae30f0ab7764e2ffa2a645b77d7ee4098da55fe2b2337356ffd903c27ae87b245b55c5fc7cc70cbc9148b01a588576f21ee9443d715c4c921e93fc9d12e35a2e3082b481faa3c5111232a839fb86f23c5be8e75e8145eefd50fd6bc330c062840271342c4ada5d24ccfd1adaa5c37ca015fb33c32964351b701d0235412552085771c5f75f54dcf2ad759805a9010bf9dd8a560c538ff1ce7077544f3042fab94bb265a6d7d37d9a1f6cd959674aec8d0824440765ad674b89cd58a13e73c0e54d141c8d4dc82d698d4d36e9bdfc3da8087c34c00f8ad1ca39b5ed54477b1fa3f7907270542610c031d12fab7842737917c721a772bfd919c2ad50273b5c24a3aef8f4709a2ffdc54863e47cb448d451613c4ac453da22f2cd8aa7f1d109f04ede5eb3070fddfde9173e9db150f5fe263395b2fc5865bf2462d57ac1b4f03836e70ec4121c24d03573aa4333d2355e6ae2a8a0667553ba94543c3481a292c8cd1d4dc1f143a06770aa8be4325a6eba2f690421aefc558f01d94ca6305146fb7d727846b2b6426b10082e33699201a8a3f08181890e07aea1ec7285ad0d8045019d5a754cb089b5fe4b4a05e7b06414d2c371d63d4c75fc8caab0e70b5ce6aa12e59572efb169d428cc53d575f5b4bebc64db75330a8a52f7d292ca7e1adc446ce228e85de8828ae324724088424ebac1bdba7a9a6ff7fd3a0fa88ed0e817c015cef1835a51754f1da3fa8abab374ee51a9e2451f36d83cb3bc27756bd656e1023ff474247226cd60d2d818e353bd97f7495bf8aefbeec66648842af29836fc016ce5f003b19362a7d818f4b25484c4aceca7fa4b587f4182655c3768cdc97bfa4c2cb1e6a35ca1fb89b14de66969d9816f5d76f2290fcca2a89d8dea05875b7b3514730ce688d1eb5dbff3042a7d0e9466d7dd8cc8fa76f051b200f8a5c9ad99c26978c3462d6cccb09cdfb29684ee5379a760f813abc4085043c949cf39181f361b0535637ca1cafaa6a9902e7ad91bb28f77198e682fb9c56e023ce116550899bee341fd7ed3cee60b10ac2a3e8216ba755c00f33aa4899c522dc64c8eb2533f11df6ea128192f73ac7680c93971753bc2911d01010217ee71ae03bffe901f879d4ae16dbdbc3186ff6187c99381f7e30c568663f09f3d4ecb4c4ce445e518edb4796b0c86bb5fa0e0fc58757663bfc1ca3349f0f9c413406db4dc45fdbb39d0d546a9319f4aa79662935ce3d11a7af4f175d2ac222cb45ff5f60e04d9afd77e658d2c334a4e4e7e111b094bf77dd5ec2aa8604abe89d80aae06236f3173026760b0b98684e3b4348aa7b59164b946b43422890c9cff4392ed3c97c01e4c32844314943cd4d6e72cf1f4f97019cc20f79678cc4ba3a7fd3df1d5107774944664fba2dac6272c036d9dde9ed8d90bfbca99073b06110e5baead6fd4165839d45d1647f49f5f9964e53fe91e6ed39d676bc06c293084b3da63f591ce50253cc4d1d0740ca2980aae8beab9b64b36fdf966b10cf5b64a8cce77e5212cd2cf344292d39e9f21961c98e39d9a0561737c9df68b8dd867ed82d6cfbfec823ef9c9fac8a5bf171dbba294df6ef93d17fdbc3b79275bd02ccdf02a5639218a168039aaf6e4d37813da234143eae8e51a9936b34d9f248f51c028b700cad6628d62d5fae54e5c1d54c359a9f1159e276d8cb51d85da5c82c202ee03b1bb82708e6e85b3ab8adf82d9e1b359d153f5b11e2dd9662774bae67778fbf1368c81c1755e40360e6765260167d3413075ea2856af95320486b9ec7e357b4400b694073db0954eeef5fb70b27d1167d18021268455b2134a5d18ed527b8ffb3e1a5e201fbb26508b8532b4c6bdf7660e095fc9e6854a125e0d5bad78dfcc7e9016e82df4452785bcf99f36c4a0c4c9b6720ed9bea94d82ad2a47b48d1bba976fc71d3fc826e3ec79705c503e09e9249738bc72d824ff2974b46aae3d1b573cfb174f886e42374a4e6e85976c068e0dd20a9c4b492678b8b05990e2cf389129dc06b02b139915828c08bc1ccbdd0edb74a40381868d238cc1d24fb63e3dcf4d53f7da910deb034a62a4a6b7d50c7639f254ecf833a13fc963fe7c420ba56903bbfc485275e79a2622eb6c6330650a8c6c8675524fdf61c00eceb4f73edf2b1b05cedaab3bc407ba5e853babce9dc11ffafc606698c0f0a4e5d2d5524db8d7b6ff75558dcb958c62b107c426ecb3c42d4d26935759e3a893b96981a1c7e6a0f36ae4e12d72ba0029463dbd06e83ef3ad69949833f0b318e9d519a2d614bcaf64293b893512344bff86a55db1556a60f952a91e23bc5324e890b7e06e9f4fa15d1512be75e3d8ec4e808be46ed4a1d13cdb8c762a503183b0da402d652b17070d45f3d53141da73d7d8961126801a42bbfec0167a0d7f418544373a3746c3e466c70084f7c83e06dd7617aa280d4e61e0740c1a4f87773f633a70fff9026333df230c69074c93e0a62c96f80fe12b112361febe635229aee768f1377e74465ff42667834d5544ce4d066648a9ba3ce7b74d01e5ef215698868974e18497d3c989c55cb7e945c8b0da120b6bf2ba35b013dace953954cb57110f9bc0039f85461221904c484a00feb4c24c3626e17fe93dc71879b5507c1c8d6cafdc79d49a9e8af6766fcaa9fc406135b303d94b0945f34b675eb759916959f00e00547e890e4402c4b0fe329f958f10002f25d14d2b98da7fb6b2b38f97a66dfc39617e30c77e22dd8369c66c2d7abaec9ae7bfe436fbc222180b44ba513c2ea95d579adc6dd44268c1dd413dcf9311192a0cdc09b3e75991bd7409cc1790e6b68267a0a798725a9124654e5f5486fb9e48eae7872688901905e50f38bd2ba65282e2d96a562507ebceb8d2332a81653061b14c23c59825d7f012c22ce963fe4d7eed7d7aa7318fb2c2490c3bd2d78ffe66e5b323fb69daf5a687bab2985ed948584616a4000054cf6ad9900b61f0beea4ceba3e3e7b25503f03e76619969bb1337180876c996ff1c10a2bab10382aba98da5715dda339e4abcd78a4e10a168ef07e0b2aadfe4f66e640f418474234c94a6201985dd2857c69c54420ef5e52834f660d7ad12dcda42fc0600918529d2d9974fcfde298c28f2476cbed693242438f9a83897a85b2247cfc02f639dd5f3a766d85e2aac28fda6176a051909eb90014525a9a1d8ea16b2ba2f8f0a35d4dda79cf0a12b8b7c00398a9e9a2dcc4faf6ed6c6f5195043bee4fbf942f95b0b66dfc649ab909a6b8641c25f84042328ca02eb3661fdb0ab7afcb9016b8430b9599ff50d70b6e6c146da059ae122aa8eb874871ba1030d226cc5797db0916ae200a93eec04952c8696923df0709ad0b99970f26b8f9c6f56dcf6aaa04e42d310311e3b35c06c5f1c8912786cab115822c5bb37d5017e53753fc21bd4573ac86189208907d3e52638233369c05465dcf9280fa42e79ba29c293847f7e3979bae4b13d488c2b345b9f094ee515a3e645f190894cfe9afdd7012ad9f05cc096b049b8e79e43b2798dbc55aa686f60bb544f8f90880da77734b52064696b1f9ec4dfe341346134117f017a378e98a76f1d570254710d5b358e231c6a4b5dbbaea1e39a7bb7388da4a719603a9aa61e5b87fe6fed684bf61d253505b2d9a5bc000c1e33cc58bae0f0afec2a2cf208d115cdf4b1418f754f95ad1dd93cbc10aae958d2c7e34dfff8e3f87046cda0290bdbfff8ab604e6f2eccd0d6d3167fea8d03f0fc6e4e4ee6184e124eaf5ad39dd9628280061cce355c1daa6a7fe413b967a7d1e167d818c0d5bb464f9ce65ce60d6d8cad27f381d41a724b0e72d54d84ec810ceb1c7bee0bca2b0ca6f31032c0eaf2a995e43f9869f78c390cc55563aed72749d712bc1344333c95fc35bfee04dab639d8a4c48b3a2846eb7e8e2e735c4e353f381fb051bacc1c4258c9fe4f1bceb3ef84f25995d8e8384fdbe7c4fd6e17b23d418006758479092acccdefb8f730c05352b07e3655861d444b4bce630aaa2aa5e5af98d0788f5298fbe571adac8292412470fbaf860d1021d8512070af542c6b470cfdb83ad5ff8b6c9d4f5a8b093868e2a39e895ccd4f2d651c39cee3fe989a75af83055785eb35aa56d00cd435f8cd9ea2540f441f98247af1bc8e6a4795cf7a10d69470e8ca7d37ebebb5f69a91450cbc83cf9c270fb8ddd96ca50c01aabcbb472bc77c58fa7d5167d66c63a0b7fe44d4a11c3d80eb0e00460969f14f10a6a510a40310bf0a04828b3debea4bbaf6e0416e8f06ff5d3d35062b1887e905e8ace2ea31bae0fe1402fe5c0fafc74b825ce817828a0a01d3bf1f5c51fb38756e9bbba53f7307df65ec55015ca38569c9cec8dc93be2e0b4fab48a198436a333b2f75a09c17dec9e13f6aad779d228947f0825d28c1e3c6a8761434d6b59d94e308c0d7bef48ef126b28e58a9f56a4b4b7180f4e5adb85dc48e1b65d830c61c11ea1db6a06577040752a8a763b7222278a0c4dd378254d90299a77ccbd4f3a1034475e53c7f02590bfa4316b461738748619ae1cc11ff58b18daef7c64b0d4b0916181115cd7cd4ed921840d53721a084729a81190ba4de96a226ae41a23974091c58d5b11df3ec1a269f5e9e21ea63cd04c45cd30b82c26a05fd4696af7ca8fe4c02e3175f6e5636c0aa190e1cb0b117a1a19c76c5f7d05a6639dd870e488e74a95b0e558b1ee497232afdc6395107295fb4c2c1312152855218e1b7a502db0e5a799afca446e6c84a7d418e334fef1e6c9f1a38d736bf825e260f2fc0c81f011e0e93a2c3fbd508bb0817d088a898e6e0cd6aa11de1b5d720a6cedbb5e687960907705f300970c8a6f05018308577c6e88c3a88b2f1cd83fcca670b24d06fac94918f50928b7831e0251e9ad7983fd437d429bbfd345275bb9249f3b5951133f9644c182b15419c9b2e7bacb55c037cd13664cda54d8112f947062b7d1b62b2e168975a236db31702552a47e982c5fd1eb62d9724cce7b35cf7c42fda91a0c167130540e73b13e793254b8a6a4554ed5571e5b36bf49824a461a5dff4f20790621830f79236e1005b671d378b72d8b12e6b9f0099e387277e34fb01c586885f05442c306f9b4a8fedf7163407591c06ebdfa321bb0707ef349454baaaaf6d04ce9a85a17d1158714035370ca5f5307bace5b7fda51b80a62840f71997815a68c318f182153d9fb949df6d6c6604c2f41a511040d718cbe719dcde8dc4e5150a04aa6511909b922e739bfea648d71b295b1835d96ad1264444284e69ff4c357aa436cd0e0578abcadc8305319514a02455aee87a1f24bac14832b4677e32d3dfdddbde3f170b923c6f6ca426c2be28c74a105c1c6bfcb057e8c8fd224bf124728cacfceed0171867bec7ebc5e227a344be7f95789f907c728ebc6a9a3aaef101fe922066909752e1bb5545eea7b2fea3a822f58e1e907a74abb6a5b47558a26d102efd7904475f75390602a9f082653f000430229f334b30dfb12cb89102e12ca0c378fd38266ba13bb9af9fea7f97498f2eef3a81616a6ff35c0fd1381684c746a2914ab33d5f191cc7069ec2492a441adc7da13258346ea6f2a7906224d05d698c8cbe9e3a31427c7a9218e5046387d6f29668a3905a5e45503a6a1c54f11f9706073909b435b807e6b2a4ce1c59be304b6f60cacaf1e316555435e2b1ebd237a328a12f2bfac806c0397c6c60136ae3778fa03976ae9695d461af86e127508aa5b75fda181df6c02daffe0c1a5b5c5d0aed05c3e898837aa525f7abf42f07f39546e1c9995279afa83e2ce004133e788df8ad2c157fab9797b012cc6726789aa10916338c44ba7f67672b0842fa0a7fb0027bf5b3ad83825afe67d187ffb95bdf23f54b3045d9e5f4cec739afe590845c7097291007740e9f97443fc28bf402d465f6e79ddb283fdeffeeec40a4f509aeb2eb46ea615997fd7757eaa1efe6dbcf879724a109ae04a471311d42f52ff50cdda7312337041c6bfd35417a3c6090ffe3d825d0caa50d56f2469a9b318ad7dc00bd382109b92847d6d624037bca564a95bfe2ebb4fba1856d88e8848b25847f2b652a219cb0914cba1751679f9b7057a9d601ded1d55c771775b1401276f6a3009b78e50a97fdee393755878ce2f854c5a8c5e5c308dfbe362fc4c6f9c2881b709c6d75ff0f40ef165a1c7382c0025a364709c6049f51ae21fca57d00a67aaff36d70dedb2a84306809065c12ec077ee7c94c069958b84388c7b2652f91c7b0165459296bf4461842b08e81f82ea7ff20c6d198e026147ece9ccd579b474d3cc65cd6f5c6e72103bc1f88da0ae4b21445dcc77746b055440e2fa139405f426d0ed6df6d7a746598f20ae27cc1808f3df82b890b71d11f485356704989c6fcf775d33c838f81830616890206bc07e23544dae66b3d165a8ec68a76e39b3b08e71eab17a91fe64972aa98ae850d938edc4d9085ce3f439387ca6bd86204d08c743078a27b35efec22e09882ad06d306ad27fb49b4bbce33e27b392400f76f053ad39bcb0749dde13450ccfa46ac86e8a3234dd5a706628080a65b62cff0534630363702a5646589dd79dd0b320603eca8c8b9119f105e6c3c01dcb53f278bd339a8b10a930c2faa8913574b6ef9b522d838fbce515d543c636ee98cbede7a8731cf36e3cd5758bb60a22aa8f06d97854467cd6e17128af81212546160735a89b76a35b8c944f0fef6d129b34717bcd30df573a11ddc7cafe34a1409b198b49336dee1e808397d6c38b58e775055c9c0e3ee30320a5b588886fcc3960d18e98adbf2b01bbec6776bd67074e37d48797350edcee3596c80a544271eca291fad6379dfde62ec47ca5dc2ce5cc074631854644b1b5d0e2c0cd7877a8910a302865993a9eb70b79a57fa7ee1a93bfe79092b9d4066257dbf451dd76b8915c3325175076019ddd54e7277522d24ff928b418f22ac06b151072bfbf05e47e3d302be631385ef7757e06585a3c478d9004ec9a4b148d37d1426f198ed961493a7cdcf9bad3ab8af3130ec180b64b7f6ecca3f2bd2d1ab3fc9607bb692fbdf8d35f45dd56c6905054447b805e5e1d3a8343955dc2e5cef1c763fe76d4339c15c6f2d93cf7727278fc694ec68693426c06e99511a2bc403fba5fb01c635657209afa07167371ab6905445a3e398e8eb730f838cee0f9fd1da373bcd14d81ad00e614e4afec46a0d1c050468a58523c2daf0fdf3576a8c47450dce013290fa5fd9cb5c46304f2acbc74373bc46c32e30f3413a89e9741ed4c769a588793e8dc4d716f9e1daeeb053735bef937307201c3c1e77e3b8a6d1ef801584009e2ed3491bf39e6a73a6964d1be5b8d765456354dd4f6eaa9cc1b490bc94f63d4b60305d8887c385ad856323be8c79e42fcecd0660fe291dbbf973b5a006fbc49851fb11978212a9712bf98550de310ad73f6847f74b3f8c681073dfe97c60504cb5ae9ba373a6a3232005e5c10c030f3e4d4c8f582307de557c8392b7de4d51ecbea1d7cecde71239c280fc10e5f3aadfa8ca3b24b8940c0ff98cd868a89068a2ee35c16e3608e81fbf6043705fc409599c8c0ade7bd7a4c91730bf881a4ceded869cfc0e0162ef74521b7b7a801f4cc4168ca175898c4783ab03d6caa961692616b14e01fb5d428ac59926777cff07e33b8c075fc9612a702a8fb417c2731ccebde9217ee8e3cf3de97e0baf4ee4c418be33293b50f399b95e8d72a92eb478b42109045555c4dc1f8469b5d036917f358d095710ba19708c00542b38b9c7a4e82811282d9bfc7fe9eefef564ce612810a45bc5128456a07713768336d2e8fa7bfaf0e4553f30254359175c53a8eb25f1fe860bfda609b01a21d81d1e541b8914e08b32270a350cdb705ac276ac8dcdcc042fa6f8f3813924ab7624ccb3b3934ff8012ff27919c8cb64f8c241a1c2ed4dedb17516f6e769a06e10c3ed2fac10f4e2969f81739fc2527ff03b73958847b0ed8e3c575a79819752bfad7cd1422af5d02d662a52bfb4d6cf83d0da1bf30f6b36822444208957fc1b4c964b4f23bf44a215106cb9692e3e9f07692d8b0a6cab0bd23917153fd5ea40b2b7a226f0e275fbca4a21ca681596a848b0e9b36efd9e82a7eb735b1f783675da4eec7a565a2f7d6966409df31e085015954cbecf518ead548eaf01f9d148ca0b1c718ef8226e87c0dc2b264157215252cb5522346dc74019daa9e8f808507cf4e524e662e7973263c392de299f68a53248dceb2e4b58fa4d6b357d4454bdc674f3826af08d5d68965ce1ddb1294588c8c9b2bc9d559956de411006ae84135a87947a17faab6d46b388413e27fd34f52a4bdc3e42ee875b9f426c88ca79054dbc976b0def0af7346f4c2bf15a7753f7d793d0f88ee9f08461b40785efa9e4a2bcd33215fa29fb5a7e5485655cc62f99d1a8d0b54b106b1b93c3d50f659e5fc135a146e9a9bc705a306e55a10a6ef36730534bf4499e2180e70137046775906f5d5de3d5a929367efa0b01b1bfc7d8c48ba6510c3ec56e37bfe0c15766605b38f8e84782f80ad4c35dc11d8e557bf17ea5721b00f62a46bcfb3a9bcd59241d4a6d2902f532ad0f6b3acbd1dfc50c3d6f3bcf9b2893646f6681ca5e8cd39ca92dfc874b257a974df56d87c436b04c0f11bf982530208090ede8b09758ff349aee997175ab31fdc3be8bf79ea624e2c650f8ec1f0dd9800853c9f1c875a36eec8e54d6656256497d9b9b411cdf2accd30a46afcaeebed7993c92f50570bc61f0df5cad230c749b2a220d2faa26a0d80df54306134e9eeee40926081b505235871a006f734b5145c68e79b099d830295bec1adf779481a3b22e42d945fcb3a8b1d0eb988384414e06676155df4864b8a6e0a567fe0aa7c50e9c4bfd7dc75b8c6e121029a976acf09e4aced5632fecd126d9e291360375993242446d4d715e46e9df54292ca1c31b5599a489e4fcaa92f3cadc964f6c93583ff5850439186c51f842211f24c58df0e0d87bf063bb2e6fed3b58703c4646aec83e5e02b9e018b9eba9639a64166946a004082d2a5cb0b1f3eb115de8a4603d2fe6cd8cc15259a1ab5d64aa79ede42819317984559501f26afe4b627b35ac18cb397e29dbafdcbd262d2c64b40c5c544c2dbae0fab035a2135ebbc6ae776d48e6627546cbc335d810a8b26147ca08bed70b2250d6ef3b853055a492311dc14b874e32b3ccf19050f182583f73b1640be9bdff868b611433fd931a181d41eb900bf59f2458800c9581fe6b1fc36c8517002a62577654c297741fe669796955fc910abfb27c65a6ae5b6c9625590bd16f8168a23d0bbfa17167e283ddd184e4683562fc57c81519b3f82a1bfc4af3d3d7181081d8c7444fd4e2da158fd9558420178ee975c017ef54ffb2c14f0e133bc6ebbb1a68b3b8e4a8e61ddcdf1fff416539867450ea5d8b50e28f1d51f523f5e59b3593556f3fe6296c2bfdeed4a013ec2960ca8f63a9e2ffce5da836bb0f469419ed19a8d772de66bc4cf9259e3a775e7c61c8bf0a7728c9eb26cbb720cb276546a8d58f332952c316f721ae7a4367d614f73dd03739c0ade6b985929837ac9f679458ddf5c16677a76cd3f9b7a9bf66425b499604e059bbd3d3db0804de33bc682379870d1a500fce15fc39f62c1292a9f4c74925f23e9a5b37915e7f9435ebed5ecf28c6895de9b34cb2e53c4415d3feb72a0551b87b033a0b075c3e61038f369ba17e388e47ba329536371f024d159116fe4b3a3dbe430c1a3ed1782c71becfb3beea4a0032090b7bc5b0f0a84939a4431c7e17247bbd6fcd1a0d671382c2163c9ff441fbb0b16a90099209e1db949bdacf67bb97266670fe08654e6e499c8b4d2ac5e0d40063c346d3651bc3ea6ef42f24b23dd4154847f506b29ddbfc7cf3dda5ac19c98b22f19bf97295282c8410d73f6f330decff6832f0d219e2cc4a4bc7ad9a4e3bcac5b0d5eb4b19f4db87d026ed9277b24b3fe4da99261afc79218aeb87a521af847866c58941ff43b39bfec663728355e34c10e2f313d51dc4ce331ecf89d5da803b344e4deceac0ccd98890fd4e57b1d3808b4aeb81bc08c355bbbd39223e75ad616027ada86f7ad7cd8b4ac0c3f296dac889183b5feafded6cb52634f340a1f2130c15e612c503f6f82c0e8d575dc0a42773cfb21d9da119ffda6a22a2e518e7cb3911058e8bc2eb4f455b55f23ecc2632d294ba30c421fbaadbf55f79f679ccd9231f22c4a0a1c6badb27ed6008e4e393925206919cf1cf42000a7fe730565fe1e2c2381f049a07966f74f0d0abce96878f727a3e5daca14c9d3eddfd05e9395b6457f04dcbc36834132fba57e571c860720d3eb8f3f03d84556a5df2ea94c212b1bcf3c226e1c357566f996e13047d03e1a6d784d04862582ca3faa0398ae1a683182d34769548ba005549709f70476afcd0faaac36bcc6b683ef304a139030a2fa357206dba25889c132f1df6b0c0232f515e39e972d71246fa7dc125743f06d5bade44478505e2d0f4081a101c97cf4ba08bc1a5cc0eda79bb569eb25ad7b6ecb6ee230d6e405d8c5b886f8aee27a4fbdf19d7b203a8008388f303397f9e091936f184e80a7781ff11c8074f8ddbec7c9f2f943bab24f7cdacdd8061d94d434fe06bf38851574b676caf33cd444b84b1097817090276e6a62d7e47cc70317b4dd75d3f98f0adaba70a1a28c2868d5e7d56f1febe1edc27fcfaa7ade1de1b1e614fc5fa3eb38807b6420b7c91e8e3ff74991bf127b762caf0854dad320a0d6a7d0aecfdb8201bb7d37d4bad2d646c01dc47181892d44d103fa71a6469bd83f4a1af76e1f9c94a8698128d9a909d6592f30f3c9f3b0701f06aff1e96c9fb03229138f88661f74437cd659d08c42e0cf498db6d39cfeaeb95c43a50284135f6b2d6eff79080a843fe155c361e7a3c15fb33186f9af00dcfdd3ae36ea408bca5311eb9ede5ec17b4036d66bbe935d55092f59dd2fcd88e3cdcfda9c3b8d31dcf85d99db530263545e36cb38cd903dd0c3666d0f89b03ff8f57f1523eb79142e16437d860618ac6002e6b4fa242c287677944d2e039ea5fb94aefabba16be72ceda69d6172b5a2576ea623dd0dcf9a3de80b3e6ff9bd14a1f63da3993f040a70cc73cf0f585cdc5290eafd26b4446380f86b9599909a6958c8480853483dfc42e5ffcc8642a38fdf00895df09794e35c7570e8a42d2e70696444d3217b13ca552a8ab9782193eb89d389f6eb45f4d3e41d539ee57c6a7ea246fcc486280690f7aff8acf8b1518136273c724463f2acaa077022f29ba939adb82fc5e7a9a0502c794eee21525e805a081718c9045211f8bc52bb18b08134bd9307188edceeff07de9641a26151e976d9e35d59101fcea07dd8428540c73affadf45387f8d86d8a2562dbad4f4eb45f2fd7ad245e7d979aaf1460ef1a82347152be07e926e78480088feef3994ca9ee640e2428dcf88cd62c7c31401c00366d363824dd4aa24c869fe1c43d70e0e2ceb0280aa3d756d173c3864f249bfbd49c707aea9d2a08b36158bc1808d3b8a34204de749abfafb56bcb1f61de51134ce035056fa2052cf07f9d7cf5e743b47fa632404fce561c01e8fb54d56d1a7fd9209a8e2d8c4e7438237dedc4e96f2456be1fbc5047113f7c1a3582e0f5976f2a31f2d0110ea27105dc16f853ba886547625399a1a755cb56cedc58e1de7f8c7f63e3349b247025e6284ae142a52e3f275c5bdb6344beba1e881ba243df4a9bd4f90bfad7233091bf7ac927afa82374763bd5634e8c5563d10ea074449b18b595f1c0cc0a81bf348aabb6892bf967622c3104af95dce94ba3215130d43f3a2342bb60ac2aa031ade2d724eb969ccd7147fe5d0732bc18167ea8657eb7eaf79d71358da8867a9fb355be5b9b4bda455921c44962498765da52705e06393079ca60924532f6a2eba112554efe8d1492e2704e53bf919094d717242d133e37d1cdfc2f78098b1799b2899bd8edf8b0b68bccaf6d676123cd97ca4bedfbedc6c0ea3040e20c2050b8a485392031ed85247ecae956db416dc6cd69d5ed3cd48440c16517625e7b4a394060448144c962ad866bcc07f254c91d821b6090c9d4261b2898c443672e2fb6cffec0757aa73a26a6647f57b34a463cf60ecf1fa3ab38e22ba6b3a2cc0d1b6e7a7742bb8d82ddd1034b23d46ad00a06a4b170aa4366a5d811abd5498b2d6eb80ad33bcf7ecf79020bcae6cb9f78ae4a6389893239e2d8c7731df163c12d6e4d5e61db727d9fb1db6326e722122c8d9e396529b254d5ba9b305f6a68ec17f2628d4a8643122322432c87035bebb338563f4e9b36b8bf5f0659ab1cd38bfac71dfaf11b24fe609afb56de71c447f6b31d19788394bfb342bc37bb7b49af88a30040f251a91339ba2a9a9d9865ccd359fb7a8b0f12ed8f9f8845b01cf47ec80adc5112a565bae5d13367c81b824f7ec9106e8d9e71385b68c68bdc2ae831cf384f523d3c1e5879d96cd538f73ab5819d192f8ddfd0b6bad47aeb3a7accc5155fe894d5617bac42867a111483f76434468943775c5bb279c149bab7e2c4ead315c1d130feb39d3ee6e291eafa0feb84d45262546dedd0b2ea2fa499ffb6d8b0fbe6de64b1817728ce3a08d2ef130f5ce54ca5c4942bee9cfd09757a0bd3f3664e2dc262923dce6fd2885546f3febc853e3e41d84a0c233bfc0c3bd2e9c0f68f7f1f0b19b6d6184f11a1c8c53aa85c474593b645b24dc6a6eeed3921777dc9d6581d3030d00588174b2eac644f247321c607c9001ce16dd98b4a136d7a1d739aa20d4e72a90c41ef43a3c754891ece07f19b7a0c0ce0fb49f5c097f3fd4e975db23e4b8cc627c1ecdeea1598c8626be9962e0f8223278530a9f6df406542a2682cb1a3210a0ad89e3e06c0d5d26194129004fbb3c7b96074417321e53856b4b37962fcf0fb355c7fc8d3395b8abdea4873141b197c3c403f1b641df8f00ad75715003bdd458c902d64d5305effc02f3d86254c38357edb074b687e22504a8f6ab6a165a66142fe230216936031104de639f0f02cec1164c83d97517e29845e451390f4719d8058d5007da89bda7da6b1af4583e20b7d2d4d81f803e200824eb1605390780d69802a11a4cbea2926d709d29fc318b57cc4b6f23a2850a5317f1a73d01319f978ec082312bd440a118d8441c2a38fdca4141ce76d7348032a587ddb37a2e47a15db974a52502845f2dc2f67ff895a75383b34d4fa16a75c7882eda7bd98db53bd19a1630aeb90539706bd70cdd52948f773d66a885e8dd8b2f66befaf8e1df1d8a64bd827dbb87409ae81be935a1eec8189568d68cef74443d92dcaed7320a177b4e945a0d3c0dcfd7b089a3c1d6bfe2f2593630c32cf4ab08ac967417fe8a1d6dff83581d18446a48f86c3924f522a6a733d610bbb58b501bc54f657dc7de847a135ad1301930e682da0f7267c230f26e40fdf20915ada4b4591bf175396d7f92f2ea1f0e4a4a820e55fc50757126978fd3e7d1c7667b944773147f8cd5a17af9f627c0415b86d6e711937fa0da8873e8831b4c12857209f99a86b3f5343a56c7e3639f9917f0c0ff01c1551a4446c06b8aec3d8a4417a6259c527606d9ebf167ab3f9ba9e8d228bac7dd987dba18579d70e0aad5c0c2abdb1639f7b88bc30e1886f91d476b9d5870f1fc1e44f9aa24190f48d61bb9da6c5ce2f4382a50e00b6f5818241014f3e3f0033c444fe341e60bdcaa5c8bfc08e69f3f4f1f1de36b98d369adbce1e39d8bf854d786638becc8b689ddf8d5e64319d0db979779cbf20e006ba6425f2c5255beb50faea8cc7c7eeef4dd60afecb98dcba22a36c8fa7dd085cce922706476196aed2a972973cae29f63ce4f5138f2e7a561ed8eb6fd0fa046653700c00c611d9903192357f4025a4413aa63f855b4e52439efa197bc67b1fa68076b3ea4beecdc5a88c687b707a770178dee66f0882942e093f0e1cb2ad8adaee1309cac1189379b72ed6fee1c174988a93c609de529aeb6f432ad4cd9064047e77bd2be7e32a26c6cbaadfd6a86080144192fba55484aa761303a5d2d17e46388989baf56818b0142a9407514ef7a6e518e2058328daeda2bf16a19c8a7a38ca03cf6c310445271aa430d99e2ea822d90f30439bbc4a439245b442b4eb5d7267398a6f5a699cce21b665b79cacd95793663b1dba2c2aabf774d70eb5577b14b424fb347860cc1860a8a579bccc53c2b90937e985f61739dd37bbe11c9f3b3ee79b2e72a85066e621c2a9131f1ba95c625e6cbcdd36a662bfb9b9ff59bad3654a93f52f291d204ea1b9c7de46280d3d94636771c1ff81dac39f4aa5efccde5d7c46ec7570b85276bb3abf42aea45baab119268b4aafee8de59fc19e5592940036a535c10f58f6f473bd8b0324b1f233a529207b1c2b048620d8e49e2e98b1bf41f71ee707a7ceafe2457d35848e57e88d276c1854e1074e6ed143ef188cb1c13ce679b22713f980acde360324baa4b3ef685877a7a92d72f82491cff1b37401ae3ca46e7cde2ee86bdf4c124f67aa095bb6f4e3864fb8fe9f045afebd21d566be68a166e3dca54aeab25408e2029a6997b9d90651ca9f0474b2ee4b9ee5282b66dd6f73753ada723ba848d7eff6d1cb50369ca528f5dff7a99394e50edc4bcf0b03c178c007eb80ccaf83eff7cc6d390e22efcb62637f8f012a4a2c93c794f9a36296a7c45d6cafce4254aecff0a304202112c7c36f0c9682cf63b55d87f5a55528527fa4d3418af090c8e5c26eaadc9e907e39b86ad94d4651797a770bc52cc6f6949fa6c404d91e51b489a341c57e13f92ae0b8c9c310c02d7d7fa01b57ee8634d10aaa794091e45a49fab3a5b511b69eb9eb92262a94f12f0439ff9ef7a583e147db3c2016307454a186b32ea50505b33c998dae2bc997f11c41b4dceb56655a5d991031a62318eb5223098bb1e5e005bc7bd293e5cc2fb1d69de2438f21f86812ef617de837c26b98c0740161836c2f9358b15ee307104abe27cfce4cbc9e2e8cc3bd5c43660a008097c69edb03b1a6a35ee24dd12e061c108855a8229a949b2c6ecc1fa6155b3f8b3ee53ffebf23dacecaaadec926dcb0453dd817ecd189eeb73569ba2db1087e1857fd533e3fe429703b9ced570ff9bb362b5bec6cbef9db6ed2d4914f28d3b78e085b6a2467054d227b0a9872535c0627706315b0a388d9b9544f193e6e877dc0799d31fd563d3e88a44ad255b6a48f5f8a33634c53432b88d4c1dbf6b090a26a3284829e6f07c8d5fd3029170894812f0dbd6970cb9dbc63cad24fa2b1de1f53fa5239ae367efc961ff70f8f8adef468ba7d1a744ce6bf6ce674c7c42e2ececcc386b92c9e028694d5d4542389701169d6b34a3a3aaa0f1b20b4f35c0c1abf21f0f6a9baa19d96463301744acea1b711c499610b5f715411abb3eab2bba71e46e2e922d2ba5a07ee93675a48146717ba2fd5dc8da68b8687e3ff31bfa19b29dd7df6f6307699777a886d0f21b24e400ec53b3a0c5a1a5be192e76a11b0ad648daa771d38a6cb4896d7936fa918aabbf5d24fe4efe6cb2fe6a1c1fd56ee8698fd9ce864016f7f0df89a9ab932c91eb7d7ce514ed6142110bb5e451714772ab8f9f79d60fa1fe40cb52fe3945ecb1ebe771cc7c729d1dd31f80fa10bef0bec274d651113835e6ba5ba0c803cb03ecd45e8c7d5d5cb6a43cfc16cfd528240a302e8fbe1fad6f8c88d650efed3f57b62133bf4c0ab1849e292a07466144964e380abfac2e2101aa7b3ac52bb3fb04c229411f0e438632b9f898a639769168b05ae6bce75c5231805fa662567264d88c738966768e33bfa0b9368a0fb0ddb4b71840c4018b0257d761fd11c309e2d6c3b529740b50648065970f0d5de7b9075b9baf76cc0f25634d2d97bfadd1d9b475b20ec9a47b4f9c32b9c0d09bd685e0d9fe3c566153c454f48e22ddb687195c1556d20d7c08758f5413b935eef0d236674f904dba929fc240c122e16f7d606f4cc47c89cd8563a88fe2d7e4f39c6cefa3803328da4d875548b698c3f75bc6bd9d3c4aab0873328ac6cb7547ae45286ae9e9fc1485220d4b50fb7a80a70e97ced7002b86903d90aff0d9ca0d75f3bbf663114028891532f6ab0f989bcea6db5c57a76d4f0c067de060d4f0abfa5e3e58fdcf91dc968c5c3ceb4860977f4a30d71983e7e1478f0dbe5ba776d660b09f4a1718c48aa97a0515599edd7e6c80b7e09f0bfa3aa4f8db3dfed8960a5d5c5ef615e93cf4ff803a11caf5d05dd36af3ce9f6e07fc17261e237444a8066dd1f77fba39f3bda40649d0bacb85c57ac30d2c88b543edbff7b38e7e954d4e1be718784de32bee8688a487be506e4cbeaa9f38d2285377ffb2e16b4a3e3da853415e6a99d7877322a460823d56030aab9b5a6624dbd129313fd50097e1389fc7198953b52b149cb89e659c83a4b41d2c170cdc4486b334e71787622c6bf003632169229fc1d39d186bdcc81e94ef2547d855f3db2366eebb160200a2501a67d06b603ca69aa90ef86f2d8c8d0463c868a31cbc06ecc453b2769f1675b4ffa20d9752faa51ca26bdb9053813d0ab12fc1022078b9a3347f26b34e3b6f65184f10a1042910d458948e3b33d4d9edaf87b081651ff264b5354e2493d45cf4174d7a1d6f88c77c9f4f2d7c1bc8e9563582433922dbba4a515b497b7b9e135afa3f5ebd484dca5b9ac1bb599532bfbb27d3bfbf958afcaa127bc27f7928c9e7330c145b1ba1ac333df94efd2bfbb4703bb540cdd93f21c897441fb1aa56b97b25601dfc891fe35d7366c565e6a2bdf05165632702c086246d0841add4e01c345b2a1a7b0a59ddd2445b0faac1b84139eba403a6080ac1e1923bd57e12d06f1ae91ccdcb3953f02af992070c99614e537a360863e9c9acd5f4fa3535f20808816e2e300b1e0611e290a6db5d8fd91364b7653f6703e1513f2881da678cbafb0ce61c99cd1dde5e68ec97047c3bedb3de3a7e4b664ae8954575b45787f1ee57a66de3ed5c303d7ec99f4acfdd8f7e60b1c6529f5b16a9bea90d97f01d23ffa6c89e48e9d8cef6c2f4c007757eb302ca87a3b78a1a66a2c45755d6b661b11ec7ede4516f6b7ad22af0f5f9c3a0c803de7c610557233a8675be4c3e3bbaffce100d7dc9f102400e2880a7b1572fec9dd5d51c9a734f45bd66198042ce1b2566cd686ec0e4447edb3b0e84a461bb8e0494a02056b22691dfb7165a77505a5792fd23da0943aa56dd60d86da8015ca6fc544f622094efdb3da5825b1893d5d2d26f5a74bb22f89ead45b3867b2ef01e5fababda5fa5cc6658eae2848248213afa26b5d6b15986dc5757e94a3c2e855c9bcfba3181ea78a268f42b32b9848a7bb110b5a10a3206cfdd9b0094f09ee399313e6d8c775c75a9d6e4f9c3e2cd9c64f20b2e0fa92ebb54b25c71ebfe0e856b37a6338c3775b9bec263f7b4c7bc082e8d3facadb6df57fe3fa197ccb42574b5d727d3b939cc38187e425c25562d8e74a7c0bd791bc7f07c61796954c05bd9f0cee212a6fbc2cf1410eead7922ffcb4536895a6f074db730e917bc64b74336b4eed41c047d41699db4b12b65e165172286bee4fa6fc46e831bbd21709162910f9c08ace2c6826fd958c9909becc9bc16b6477b66887fcd652f71aafa2b981474521362f25df1d98e1f441671c2384c5e3cb4987d4ef43b3bd48e115bc417e08c1ee4dd78d0136a7edfb6dee28565d3465d72382601f1a3bba81d226f80f013a522e26d293089e9cca2be35dd7b392778b655fc9ba3e041d7c1fc5bc5e82552f5125b779d93157b1229534d188ef49e16b66d0c4f7b1faa7427dd233568583b79b941ed8f91be50f964e9628fcddde2a8212cab25945f74f5570c08fed0fda7bb743c7050c8f7586dfb657669e983b0198edbb7043e1d3fcac20ee44dd429a05eb503f21b59dfb43ec8dffc25b98db6a8ea6599108c23fd024b0aed7c8ce653028110f629688a09c15b323903b61aea1ff46a4b0dd520bfb4cd00f165f41c9694f39ac9469f61fe61756024df7fb3f72cbea687a1344b6b4293da52006d0d9c00b7e84cc4ab8d7a698dc60f4756cab15032a8450608151512de408dc83a5803ad8feb2764be7373164e1d6b05a2cb9e708bd70ad974f1e6fc6348469304966034d22f849f0c425e13174c58406bbe08b9d8ccc45ce028d0d3caeb3d1e5780d84ae81aa6594e8c96cd790bf726e17430287cf6277276bd68a73056a11123aa85d1cf79ff9b42f84b93bd57923ed64c86cdb08fccf5a65fbd1da6fd8c2b3bc8acae995f957328fac87b5cb3199c3f800a8200e783ffa272f504af8dc7fed9890120ec53d36846a12406843990b9b60537a1caf49fb3e320057ec6a1ff0418017ee280d125546674b10a9a805b22fb001514c24127f4a280dd8ed64f16c4799b8eb9a514f682535ebb13b34c9ce46fc35fd2711d2f4560c8cca7c082406d5faa9495ba39e13960aa66721912fb90975cd7d7b124d6a45e9300acd92409ac937b01d8b7ab44a2e010c26ccc4792959fba246e331899ec26365c59691a7e52c0018cf9a4e2791aafd35db2fe89e0ebd45af195f902fc8e002315802c0c122ff80c432520725bb1a7eaf9dc968cec64298a144cdcb0c1297e5ec756d501fd9f2d137e31db67ed4e2c401d23aedd045ab335f86107752b72f103f45b87cc2567b988eebd1bfa42ada1fda78a1578c52b2d4b97a27a40fb75f0d91ba25a41ded8d7c853243b86fbcdf1e7b2d9ce254dc475a9b70788083209d8f6e717dc43fcbe278e935728dff00907cc4d3c8fb2cc440da141d5597dc47d4775125a8da019312efb38c3e3ebf03155fbee1543eed9219b04d78a6910c06fa13801e161b70432d3329cbb01969c7851d8a5bd897f303569c90bbe074b9a858bc144e842f6ab19e48034152e08c606f47262f43286cab6e537e219d774a48173126d428c230eb28f12d707a53ce82c3935e4bcc60d7ba222ac6cf2508adde605a4e6678f78f974e93ee498badb911da49f21dd005074ca56e6b6153f839cc0b769d173118ca3876a5fa565506addfdb8153bb94ec763ba5aeb58c542e9ccd13ee6036ec90c64e86f385dcd63c850e280ba4a6852110e9a2d75550e4ebeb78d1750ac35e54b1cc2b7f1cc2880ffbdff075da3db63a1947171f325072ab392c1ffc5419c85971500e79e2ff34861fff0e07450b10d43cf8ced1b16d6f2ad4fc37b93b7c43d65600c0658ee86f1f5a8739f2ee9d28d6c633e090b51c494a0664f528524a7974cfe1901e28e56c43a09675d880852566183ee55f4410c56af93fc0d4e50ad8fd1607b28e79e58a030132a387efc0b8e247f3402632a844ea7c3517efad8b815ff064dafbf9db376ba0baed0467e7e913b91b5670a10c0e9c4a8173676e2878fd1432b2eca2695cb4b14b5cc9f85df6d4091a67d2664c865cab1740d208259547177c12254de8539e7ecbc532a89fa65447619646c060d56665dbf9e6e58e7323d45c06a12e379ed6c870793d7bd8d6f02d3b2dc8a85ce25ea23b8c8a40a46e8a4902fca29c6532b39460c3e6527e2b6e1b5fecd3abfd18c5071092e968e02add34a206bc74b8ec612005e08ea8b2118c8965fbfdf41d41b946981b87b7adea72a5b7959497647a86923bb2a729c7da8bc3c7d62b811e2b655717610d8cae1758b2cfa04f79df550e5928ee2abe4932d5ac52c089fb35f15d3b42c266cd014a672a994c04997a54f4315a1f1a3539aa2113806265a9f55432d27e0ad3b381940e2b0ef45c529bfca85721c1b926fc8b43c4f3fd77c7b4c20ffb34b9ba15f053a1c4e3a2f6059f3fb71984aabb58621470061ee59d7c4d3df439d23ad746659012d3d777e7c4426b05e60acec416f3cf1fe918b8d77c39e888d3ffee03bb1a1f745860f187098dccb52d01cb15aa8e57ddbbb617b39effd778bb693f972cd5eefe739ca439ddef2c073f1b6ce20ee806a8bb1a3cce7255ddbe01b12fedee916b3dd973e2b1b242b1ac4951d9cce92df6a79cb054eec5459384b5a81bbf254097e062b7562eebd6bf631a79579e42ed9e377e50e749078f2e618cfd63f43b3d883f0a3b35ad12b6085f5d91c46657a54718338cfd3cd12598fef33665c0ce0a464437c5eed8c5b8b8f3fdc47e72261966255ba4ea7ae7bd8b5e28ad22ac5a979bbfaac72d6e0cec0eb375d3cc61aa49d38c6eccf4c3ead6929da067f84c4dcab9470015936fc6568084c858c51e299092b0047f7c5096d8c95482ac589f54dbaf137d1bb0f86d0e668cdb9127823e08aa581a2023830f51ef43196e21c9cd78c45c72a97cc35e7021fe0c52d30291025c4ef557f6f037f0e148243a665297a77faf2b8f2b8fb6f2658b9c2e6f27bc898dbb8e758583851e51bb320624f20133ceb37ed9382b90ee7d02d599b3c8e9d25f18682ad87a7336dffc34d8b080a5c61ead5387ebf8a645a599036c00f79c37340829590af9d6ad70d7f70c0837a239a3bba5e46689d9f5659e0ce306fc882ddb7634ac72dbc9b1d6310dba2f924f2a3173a2815589afde64848c64ae757ca807957bb957d693e9975ec7e0c63008ef82b9d06b5cf9d02ea36ec9bc4023f70795caf12e7c2d179218c06e6b1027c0dea16786b2df2bf6605420870c8d3cdf3646b65fe75427792594257ac2cd8c36c45eed6e13d482dfcd9245fff5c6e99d2d8656e211ee852493c07b333c02c15d763bc3732823ecf0fa8a4f82d906c98c2c43bdc6c2ac184ce5a9ff08be70a2316a7fb541b28a48406632030bb276b4f63d296d08a477f9429b8a25fc9e0c18ad9b91dc069e62eea38890a13f9d58c0d38b44e3fc5bcf94139a4fb8e43f76358c890064c7854f5b24ff3680fa111f338fdfdf48012b1a9e5ac7b6a637643489b8e158f4763d8f390a23453f21fb94babaa9049b5318d2c6199bc027e7ff48b0a5999048878218aad5b147836f39a3f1eb5dcc5f500ffc69f8b71abf271fc8bb970a8a643ae8bfeb1611d9aa2f1d502a8603d115877bddba63a8fa14efa256cdce89c2bbc2ad8f65f4a410d3899c5c84736788dc0ecef77363b83f3ee0c2f949c905a39b9265effb9d7103d71bcd74b82eefbcb849906c7f956dc05a798812efd9af2eed2b43609bcc11a25d0283a470e63d211de77e59e4769a70eb77788aacfae895b8c37ede8a3ce97d9bc20c8fe905959dc2bf17df172e3d59b12196c3bb850bf043e90edd4c97ba9fcb3c200b46a39be580601575bab5ac50af79b375742d90162d05040e908b9164ac5b7183493fee8e820b80e9a6dc1c910d257043b0569ae61467a24a8b778a01062c36a4986fbfaa4fc489310842e6e34780acf65d88c98e21792bd743016beaf7b0ea446403cc6d66a08ad439753fa51ab2607181884993a5c185c16ead4cf1df2470a7f4a9caa7cdf0b765d4e05ad18f1fcbddbf95a13b1c4a8dd3a20fa9b6352f422cdd7e115ca934f87acff76068bb9b898faf04ae804675041f00b433920e586d40ff16f7ca5788ef623f10b6f84d56b4d04231343e457e2d32cacb95f040d1ed3a3b1610028f935bbd828e0812c3da2804bec3ab175155547451e2a7756f5fccbf1932025238d1fb484cd6a448426384e6774707cd0c1729f7a86baa06f901c4ce0cdc7dd971bfa520617dc9edf6b6ca5b35275e4812d661d688867673de66dcf5fbde6fc3b2d8de5e0ce187b664269e5cf424bd709b2ee3a954f67b9c1b2a7bfde64748cfaee3f90b860750a9340bdd41ce992095ddc4455e927b54a9154b96ad2f705dd73048e50d97a92d4b6b47e2343a74edd65e7f9de30a64787560b3d2234779a2b782a54c9b03efd5b734b1325af807b597e065ccf9960b3c94f8683c6035e8d958fa91e2e4f0175574206d6530e0f3291f97f298d3a373ca1cdc212f9bd5d82b27498e35ded9bf8b8ee81157ed386413d9a979cc1892c9790b53ab213ea2a5c9495eed220634cfdfd178d2431b7cb76f719491a58e4cdded401635eca9259901d94662688b025718eb00e77143495017ba4d20d6e0a2c7c723f7abd0fc1496a96c9301ba277106b42813c056c09a3a9895b0fbb1da06306fc10a7ef6c0a240f2abe757f0f7c5baa80a6216fe6b901c699d3a111deaeb55a45aa66d47e01e6547cb1a87d8b2bdc47ca0e759a300b5f283d94eecaa81f306f7b574b1fb4c07ebed915aa8f21119f3af2fdbfc4858b6e6e459be65c3744e6a1e7f40ad6b863fb2e9b11bac3a0602892b18ad44398085e6b06d9a18b6e52b986fb73dd11358cc32537ff3abdd66f4488c322946ebc145a9bbbb1c9a37fdfb07520592b1ea6dfe59522ee431b403868cc36030668348722d3017ed3a75d69e35b2c418c4e228774aa1321032f27d9a1aa2bc2bdc6d8fdae9d8a0b0bfae3cfee904b571526c9b0f109718ef02b9d1419f0c8c591521f53e3f9aa196d4d73d600b3a5ddf7a97a0acc6ab860d03b55ce1fafcbcaa152ae2e546a2bdc51e7d8a56fcb01a96ff9314deb8a6f7685202c93d244b85ead2540741b89cb7ee77b0b49e23d34a5018508af4cdcc2e1b34d121149425d67ba1e98d0bc913f9b7c2fa83209442f4e0a7f786faf784d6a33a42198561b0b9b0be0ae321a930ac49a8621b4e6f724369c5fee4e512ea60a5239e3a1dabc9d0667ae094d783b7cfcf04e4187a72e4883ae951a11bbb7356fe6d32c44a16c3788ac7665189370453e0ecbf5480ba65f6d9bbfbd009d708a7d320989c0d3945655bc7f7b4ec2258bf4ebaa61f65c468dc3ee04db6abb19d6cb9523d0f7f85cc273ad02abed2d221b81489bcd75fb7a6167846b551feb7d8222103d73ef8532a43f5423c0bb12a96ab9d175690e72e390cdf641fef41d0ad2029437fe52fea206e81803e6bc163653641f5cc2ed20df68805df903437faa511d297d80eea429dcf31de80ebdadbf15be7d4772a275b56d9e5b088268a07e79dadeb1df36bcd2a2b5b6b2c2cd8d3109fa87d7d4a1b35c63577eb1ab45b5363ad38ec192c056d6b3dc2d1b51be33117dba92697cc24c216071ebc6acbfe02b5d576ff3e6c6b78c50e7db71daa9777ec599e6c2b9c1c9af6ec75fc5e43e91858de975edbba5435e88a98ddb7e6731021aa1cad7c7bf4243b3c57de09131edfd98bf89d19660009125ca3a444918eddcecd55e7914bf67fafdee6bda5a884f17f74486de071da615e9460c8218a0afc7a4a946f4ad2a19953257c3c06738d4d4ed960d3fa1a73fb67fecb262de25cb582f8423ea144c901cf429cee8e2bbf447bb082bf028eb5a48c5e00d9d0993c37eb645dfef90d41738912216c5cc8d348503a1c5e9427bc9c41c1921e1d41843c3dfbbc6baad5854304415436e06b0ddd1629ce2f28b0ef166dee45b8082a81e48602c74e6b5cf1ce3776549f95729cd1c6ce6b7cb00fdab351f5f2f6841796ab05ccf899dd715e329e98ee8f400804f148ca48e9798c8b9975ffff46895889e6700523caf1e6aac742a9d79a812440d6b41aa75b02c8fbfd5000a2503a213cbf8f354addb96f3999b45b20dee6c85071edb04c44e239ad8abbb1edd34a41ddd67deec1561b8380129f685dcc1b758a4cd75716baed5d2b64cb4a8b6013deef2bee920c113b8a4149e3cdf02e11c57cb7b41e31a9c55455378326eedaeeb90c041576fd68a73091c74d91c9111d61e12413100319409a62e887606d6ed3b5304f98b48f42b79193ddc94b0e9edddcff8ca16a47edd91ca21939e5ca46eb9490b88a2909a1f1beed37f169f6f4d328f36b5d35dd9498c2cbe0a11308295afcb457e7b21657893825bc3760285a420071610bbee7d86176a3e746c95f54b19f2eb9679451617ff38e64da189d9f505e4e1a575cc42266ac5061f8e749728ea1fb298933f71155c5126d716f4082fc55761d1bba49acf6ca5b5fadb071a6707738dc729c2e4c1c778067e9a99890af89564f7ffd366380a13c4ee9f5e9f6adc57881a19780576ef37d229dde2ead0875861f5b4ec99d9d23eb655eddd5fc473f6a6a7da7cd8d1067feeb747cb6393ec5c1f173436aa84a5f7db7d3bbca0f862bedbf719e0ed259d2422f89a68b1b9cae37465662bd4444934a1519a86fa7ba4e30b3511284b165b5f6eb93a5d45fd073213603dfb2c3648906e89289aefa2b0dc236426cd25c0084a77699f64c42bba116374b707853ce6c919093dadd27dc3e43b1db9bc6dec3b677c0898cbd44a834f71c3a4661ac4c141e64a8746fdda427acc73ccd42719b51ae173bcf33cf7073ceb08a1631bf6877e15fa444156e9a4e1f2003d6c9863c12a4549aed251192e2e2bb5bffcf80a29ab071f8d4d28350da1c5417fca3d9dee442de48c72b548bbfc548c376589a42414ec7e9b6e48f91204b9bb76ad9a15fe783b384f706579bb86825cf383fa59d9ae0111f97b8cfec89a1399d2c3d0e249baf7898c7d19ccd12b009d4d7294df3d8c67ab58a191832cb572af80340bb3bf6228489be1f19b3650990865004c740d6b7d4901ded2e695ee5e223416b9702badba87d3f37523afe0f484682f257f3c27d48da9870f0da39ef013b1f69743cb393be430a2e2523cc701e9f0b765867d44ae61bac201be586684158b558eb80d8ddec685efc8b197767374ff8197eab96610d4080d6571e5a87f4a4828561aea8f1956f070fc65d6624e0a802d5b0fa5d9619a39b54c46850b256f6758f7447a0cca8f47cfd1b9b38584803e8d0adcfb0a9dd42a60ca1e84fb78359b40127e5c33ef4fc549adbb15dca19616282bbe950b10f7f284e419402636aaa932fa1beb1af2454830e1d057e78865c6b8b0972713adfb3deddce55b00d293c2f29f0587387e1a276adc55c82c3f5a33ac0f437cfcea3c143bc7a4054091fdcb394c5509e9e947b4efa8a58fb3c90d22a71f97f1c4359c60616f5d5461ac6018332aa8efee2e67404eba22e88b198c59ffcd143c0cefd5dd2890324322841d3602a2e4fdea72f39e290c1b284408dcea3fa0a8ce9cfe246daa59dabe06e6360c398381dfe61fc6efb490a19f7464dadda5062ac7ddf2973ad747108fd560814461ff97c9cd8ccdb53aefb6b5320ebad4a47e82eb5db1b97df348fba219a9b81777744a3ef135c01198925b019e23bb4f6485a6164fb76f171634c26ca20d2dec6c074ad98485ce4dc0076554573deb1a3d5aca6f08ea2fc8aa8fc88503fcfadba40e857c202c95c538ac30cf03bb001840917ce983f7ef3bf1a74dca1295fe23784c484b4009d29b98ac8d1dcb1fa306ae7590d1de4670b37df567786c51f5b0b4f95ca1c4a39d9d105378eedc7eb2257e3c02aedb78c4a4b6d396a3eeb57f7c19a0ed9a71322b29dfa58091e7f75f88db063f3e60783b475887647b3d18f52fdcc43bd16f3451ecdd55f665a14329c2a4b47a3bf71a09a1f294d2783f733b8f256370a7c9995cd5f2fc33714450091deb86fd5d4f51535767678a83a04b1582913611e2f07bf09e9caca3020cee6fe576929340b9e7843371460c854ea4972eb1d5e44a3966f4f56ecc56c5bb8bd277410288f6abd6070b199d56adfd02ba7b899c4fd25a2ed3568b484b001603e8a3fa29d68b4123c9784090bfe1a584327f116773f6f15c8c652f10b80f6675e1a984687a32b74f28a21ae5fa6bff0110ceb71b9c37fd255ab226e4fa52f837328e75da0c93f05b3413ae3786040b44c463dc05c30863f1ed92537501e49dd0b8c097dc0f92f25558985781f5c08c4890d7520033fa6a7385f62bd3476e2b025b1c6a5e9cde687ad9dd46efd9438a9684e4e46f97d33f555ae1372ac664fae86614a10456ca1fe5c887fd083dc9cfa287dccf0d00f2726d2e8a96d267a767274b7da11bd13d89d14a67d526ea4f6b44147b4182a3857788f6ea78aee561542278be055ad4173d6b556c7938002d3139a2b0e1ce6a3a27c1e5f3a4d81d8fa64d7c631c7320e9742e49f569db85cc37baea6b46898f6d3c695b76f3a24215c688adf26979a7c98ed8042878c1f93e5a207b1a7ee5d651d881754bd2e47ae0218bf1a723115ef78be856124f671979b79847968990334bffc34930c499cdbaa8607732b372100a93afee69e81a58d833e92f7adc5ad85918390750decf72e151f673dc383de5ca6ff12ee61352c093f544a863dfb205a47063827a4ae6e38094b63394061978290d158458f450393ee630f87b6fef1b0db6f6ed93c41b4552ee351326222ab65bffe41fda83206b643878c1bf5d6abc4f8020c2e0206d028e61ef3097c852e6f0fcdf3ca00ad5ba9ddc30c1dfec6a0340c560146fc2c3b948f210eaf8e64587835e194b4aab24191d0ad0fc4157e024b262f2e1042474cc182a58743d9e69edc0a3a9a8c7d84d9debbd4ecd9e49ecf50095c30ea9540c329496fe268ec889cab0edaec744d94d267c345e7af1633d2d5785fe1a13737266cf47b644646d5a098282dde3e94a677c3473ac57f8b93964adb721d10b37538d8753b6582d4dcaa6a54ca0a99799f8acddc038964c55f922e69aa86e0f69e0240b52d778945a2573ab59c970388ca29aaa26b83b2eb3108190fd43095068dfe145e1bffea13b07e5275cd2ecaebabefba8f509f27c432b25a193a2328da5078f8d23218ac3ca1d68e52aad74e50d2641fe40bca0faeb75ade076c91c1425b109ef3b035e7696bbd1c63f24440346471f475da002e182d9cae5a1fcc0a102d3b5c3d3216bbe623ae50b37cb5857798db3cd696fa907560599307537cbceea510349985899cca42d121c557fcc1a8c16800fc27e2154a749fd6335354c239e9edeccbb1f22370765d696ff77cfc6bdb9b7398b8427f22a4216a98a0974ee75a426c371180eefe9be6d2c3fe7a35c195e94d72b6c22de86500600ff48d784d60782c174a927aedecab9ac442a3da806a1b1ebce3a53a0dae6a2a085c10096c1b42df081abf4f02b3c8bcddf896438bacca512e2036db335a2d294f1c251e047bd9ef7d82589b04b2cb764078b8581c11e531a9ced86f51d35a46579f772a80e8811d4bf1a45f86e2da23555cf83627b5eabae71459aae0922680b3bccd7ffce4e6041ff63cf23f52c2bfd88853c0d9bc3df599da4fe2be7455750b7691614d6ecbaa2659fdf09f825201a036a9526a92c371b9f2496ac9732907c4f3c167787fd1963432ba998c0a3a60b4a573bcc81a50445bba39b5d6d597571ce0c578ed84a87ccec32f9704d14420289667210d23d782777194574b305b651dea8d21dd18b953d3bcb59ddd0ea61eb0da09966a02f444b1efbab0425278c72901b3b311073a1750d1fcc1a3292a1b2c83b446dc35550a440b0ad1273ecf899d975977c470db669c2abeb488c2f24efd1710a7d66f2f5313017b67dc22d0a7d0f2781abbb6f2eb5c08d8c7fad34b6d6e2da736588c57df78519a6d42ba7720870e583fcc7b66e42f0dc267898c29e1bd8609dcb7e73da14995048d33b03ff3c9b2662f457544e393f19a1f102dc4a4d37bf7cb06f3bd90c0dba054772b5b150142840eb6eae0d9a1ea74b75d8673c6fa493e3bed7fd42f3437ccc5cc4a48f54c587f7b3a00df12c035c1f6cb703e7bc69fea3230593a752e3ba5ae61ba667d6786c15a498dbda97e61a918372a664fcf4d278dc9c71cd16567b5ff9d2c61ed55e3e45d193317f7cc5808c3990122c555758939c16a5ffad4e9923673b674be58bef296fe4b60a7b20a16707cc18335bca99f09f3c14b4e03ccbacef1b25299377d4e7d66ecf56d67dd2e10b93aa26e22547d808af174494d9b68cbf29962fe67e0ce1e72d1a0540e58a7f4489bca237672527ad6360b1ca9e15cebb92d2d569617a661fad3f1c04654cd55e04f99396320f478b1e2eb1b64be9b15b78cf4c46c34c5ffb911000658fa193ea90422d014b85f678fed577a864c02e546e893ac3ad1629fa0ef4de79f629663d69061b321fcf4100f098feecaf0a6425fefebf050b7832d06da6ee4ab5b6f7a9045fde0039ab4fc939cabd76b77d73ae23fb53fa2d56123a8c471238e976adc386067a68cd8fe361f145154c4c897248cfaf3c2247a41d285eb9c3ef3234eb484b19db5a317bb7ad8337dd4401dc658d6620b26bf1bbbdde664e5a5d369ff2f561a8a7ae5e540fcd2f30d995adf778dc415cf352a745090d40c808ff1facaff20a1c5dc073db27d1898d0706ead5e3e02d89d84949b161c919a62c0518ff03c63e66e8d2322a6328f72f076f999c30dde9bdabca9d3e17da32c3c875d36863b9260522d782c4544636810d575c62d340abac528ac89555ae604545500673d35fa2d5d704eb380faed5ca26081b03461a9c1d13f5d9efdaf18fdbce56e9fc9f83c4b54e9b1d51552fb8dcba8580041a4c57397c803fcf3bb43b4cefb3b9e7561653f7653269d290d9960390267b8ab2076ea33e644d48b5b2f553392c39d3dcde49a2c64046ceb0e17c4fc666be5b98f4e564fdfabdd9cf71e4d321ed2ceaac895687c8dece82517a492a85ba41f69997b5a661632ad5547a41506053dcbe956f5a22f7583ecbcf67303e55c7bfb329014a3cfbf89457583bdabe7034963785dfee4c60d879202aec39ac606f38feab8606feb7e3e0d159c990a510502c8b35f8dcc016428629d180bf9213876e94a74ebcf3fb4b5621bdf0d988d18f714dcd26a36a92720edcc9b6f3e3d6e268de09c4354fa4b821381ed83eaa1aa4c18bc42ff48bd824df2cc37f588cdfa7f151f198af367fbbd25541bdde16345f76f9a03f37ae95286b50011545e94b7019e7afdd585f0258decfa12de90535e8742c5be107659305498b40ab668f09e0b39cf7d4d7774a7f1b6ae1792787ef809ee97ee0b2e033ceb392f1243b613dbdd60c639ac462ad93473f9a096f8133235e81580dba50ddad077d71fe98f5277c5d11cc642b416925813955a3300103ab213cc19156167fb347421fc2234ec0736778222a0e4d3a01ce1aa7b2ebd6919cd9d65c05f1c69a7398cc706cdadd7e9dd7c8b4aee083e1389515b614b6852ad6790f5ab8aafe7a60c698694a8adf12d8d4161d960a21e60424f5a9f9bb8152a77c4108bcd3028222bfe6140759fcfb214ae843e069e81b3e29d6c8f7b7bec7d75f12d4087334bacd147ae5ce3c42422668292b59ce40b8b4396f42837b8e3122232e7dc1c452128d7bea1caa816ac6c2213173e67d1e00da4ce9eb9b6fcf9e87cc1397fbb58def3e4f849c714770e4e4abd5cb49afbdd8083f486ea80a6b2baae4f1a6a56868ff890eb9c10b017762360291c3e3102dc5385163a9245b24670ef892701bb56b7324da1f30f1f800e69966b5a63e41a81a0ea66d4dff83b657bc1a5a44b9a6a81063f905ab53c6756963d8b160ad57c27509c70eed403843303a5e4f6047f90abda8568f60a3dbf86b8ea16691165a60ba0f200b0add441118445d3cb666a17b74fafd664899fb8fd5f0cc894818c78328a3817cde5b049b9af5b4d8a84046d3cfcea2ff775fbd99c98ea71b190d0fe54fed9e9ae461eaec9a528606929bc09c872b1b648eea0e94e1c046eb761f165eec288f135ff8fc53e43ef61e241e9fa79c46e1979919ac328ad3002b9084b424f51150f463e0525cb2fcae4ef8fba66a102c948717bcacc57c23f014152c37d568c142212c289b1fca3b5c02dc7d4c36575c7489f42ff5ef8e80759f9faedf4ca0c1a85ea9b099e3fe9b2f63afd83a37eef2e86da9e3c3ad52cdb241ad08615432372be9a44fa0083c475ee3e68dcf48bfa7fb1fdbaa24ab40670fc85cbc651ab2b1579ee8c01b486ef0a1da01219f973ce9dad51d7e7eea66e0b6386248087ed2961cb534a70843e615b6328845ef135e6057d1bdf007bbd5f817c8e27e5b29b8214d06047477600edfdd2361c93bb4ea6a69b0af614cff449364dd2a2be27b849f24e5602b0efc8d4e5d019567b187b77baa4d0aafabc3ab95162770a1154563e9bc874c9f88e433cbfd15cc5fb498c6dbd830acfdd824c44366bf1148e24ea51b96ff7aec312a42338b901c27599f6ffa548feef85c86b5a6d46008e629b8b13015c265b86c3df5c65980f9c6ed83fc55a6dc87c811195f02a4aa78863f1fd87502c1f6ee2d5d6038bbe154876db16309f7eaffdca7b1fc2d5c75990d6c9c4dc708134e848055f9178aba46510c380a37959b579d23ef1fe34837602f6d8cde1f392c640d008e6da6a446cbcfb1bfb7db721fc6f25bb137bbf678a554f22a1f5087a68ad860689acd69346ab4764a2610a6c7ada97bdf1fa1ba59b31f21fd24a04c9a0d8de6eec2a340f1d8ad2ac7d762e9652aa1827e73f12b2470ad110c13b6c386773febd25c651006ea8ed0731bbf1a3ddbccc6179b61a4f2966450ef025b8cca39565cbb0e43c7835bdc1e106d49ba81ca1e6c6fd10ac463b0205ea7149f2cacbb903ce3b9bad77f5678ffdf97b4716a9489f18a98a3ef5ebdca3048af6c8af211012008a973b4a0b16a117e47d688d02f6da4075907cae8c5fdad733cd2740de1ceb1a83ebf57ba48d5287ef0ac6e60faea29c125a9c207be2934a4e82818ce2b282e93bcf0be7afbfbc9df3a9c345aeacff7c7dd7386b872c3154732c68baf10dbe7c3feb7692625e8b050586010e207fedba726e789f2707413a7511545afb7b1c393438cdf649f974a3ff01bdee08f8073fef8f581bc18eae8a6c3cca3b5f2cfbb365bfd271da2d73cbd8bef9a7462c0b461b948eb504ed7c14b8173648e52005c8ad8724f6212e4da31abbce7f09ea06596170a84527bf8be17ae902d71b21449341d7ae96f12a4b0dcef118b6f8fa5a2162e53d110d26d7434c7af051a7c3cb7105b4589b6e4e4fd2703c1f1f045aa59e89ba098dc048c6a6d9ddad9712679f0f0e46648f8734433cb254aa50c8d13d0c39277656ce3579ffaa349f9c6b027d0a968254475129579bd901cdc310ee11d8a13870651903d021b5ed299951cec4b72ecfe1e28426429f811a6e977cf77ac0bd31e0f7a4038f97ef50a51e0272ae591a9117a1298f652098f4fc9fe6a83be1e81ca57cab68bdb8243319e18ca9c385f1e2b82990c7b377657cf98dfa1d5e4056c3d79bced647639d7a25f97358c728ef12e64f24a70cded70ad1aad2cbe8826ba7f5517a1338946c21a58a55f98d4cf8060cf9ed136414b47713384ebee640fb47b8cb2a9524b8936f9b213510c34be34db7af9f59270686ab36facd7a208cfd89e074b5da1e3963e907964c1347c1df42e9ed21c726ec043397bc85868589ab63f70676404ed041bd01d83be42296950a7771cba9e00e2ed53a996dfa10cc3c1deb74cb860fb830eb5f20c63d9ccb2453dc6a7e92e21b297f67141e8892ffea3258e02bb8712caa287b029dd838cd0a79452f0b261817e1d5cea3fc649a1fabdbdee679bb7294db057f3f347f7a3db96af62f9494f01e0c19e55c6db7c9547d5b3905777c7aecdb219bc711932ddfe9433443adf48386d305893c61e4c138b282475dcedd200b13475ee1c27411c951735ca9ad004f13c343baa800d28770864575f76133df52b5ba2d2fb82b0d697ad7fc87f4dbcab38cc9b44a37409f076304e556efa2e563dddab9349b374955d153a97e7bf2f183f87052ffca80b022856f6233b414a5f78ef09c3ae066776a8db9695968c1f9e165253deb81625057eaee9d7f55824409feed1d4090746ab045efba353fc26d92f2137e63648bda3b25da446de75439e0dd3a5a0c74c89f9764aa8a534600f173820c38264c6e15eed0e9585ef5bc212f3b625e2cb343e3b7bf67706fbc2a1da7b515110b174e507aa2c4770847974a95df9e4bbe93a91dd5227b83180b9b55a19c719928d4a48486f4f2c260c02606214c8cb2eecfa9d61a3257e193224bc0003e0e22e7d8cdf1cd55c378acefaa7b3411a5da32e1a9edd643615b29ff34cecd1327aaeb5e65851db1091c4c06b8c05ee659068c59b957b20d3507515424f7168101001500b5d0d90eb2abe6926fb334a9acd2b366129f97e3b9de049542b9364c822b808b6c84606bddaa8d6d4470fca282181c0d96227273aa2f4195316906219628a9037ad489c49f6759f4206dd0e27ed633622c26bec362db555d0ef540f77d6d06cea0b3392c01b5cfb11aed6a1d333ac641726404df0e0ae9c6859030b10a30968338a7bf0fef057e54ea3a77e07179c0b1dc0b24176da6a4a14a9739bbdec5892efad66bed828a750927bef6d5e4f58679b7fe4594014fc72f916af2e47cb01d2718c9288e20a4e6da7dbc42f202d6748751f8a2c79d178efd00f75ada3adef0372386c37750f93fce4152f76342c36bcf8456f15d9c4787a30e5b99d224531ac8fa5b935e6de82b5acc5abafab4395450cf6f143aaf798dc4b2d2015a7de79364a2a11e72d2869b9c200aaa1a6e038a59ae68019d0aef928ff03867b5e0c9cc690435f6e76505d186f5b10d3a6eb38327f3322d8ebacc2093407781d9da514994bbf63c44cf2b3659be8b6c6914e8fc27441f2a0f8399a1cf458bb8eca6d81f380fd301e6e80875c5e93e805f1309f23c99c9cc2f849305fba29c3dc872623a5f789aea36b253894a7abe8fa3887ac22d710e3578ef5b3abd54d3d91796c621779ea19769e26ea44fd43699b20a15d2589341c3699385b45ee2885845f8147ee1420800626a6021c7e0a14e3531a3f52662eb02b3494de7400cb308064110039080447bcea9cae20999b061e0bf04249ec809e8eabc2fb345e7284b1cf1460322a5ba5ebde4a5ba82de9500351853a6c3746f61a4725f3ee89c6fbeb812a5c910035271cf8283d5b0535769f010f5fb73b605f2101f50a47fc07c4bbe82a8f69dded2b9f9a9dca48da49f10ecc37cd2910c9920585880bf926214248513eb79ba8f5667671513f0c5b12ad08c1cb05be0e5ddc0c0f33c1c446fd8b06c57435d6364f5f8aec071a01df698b3838e26af2ca2ea07c07597f6ad6c9ea3bdab891255096f130df4b9e87bc06e069164cc5e120b3d308735899b7b4cf5d5022faf414c83ccd03f915525973aaf481be03c2ebded97e9292cce9a24f6117f11f97ad5e4999f50613d082ed1c58854a37fb71edcb7540364c854b7966f3ff02ef61ad2cb754421f8bbdbdedd42d410c50ecc6090c2dcaaa3744211a35d6306508160ae945bde0d827de55ba0ba24ff9cdbd1802268960ef67f2cf431a2d7783cbb8809ead88cd7d3ed6e2fef451c767eca7a61e2ba45e4a4c8b40f00ab3d8b8b729ebe817995d7c1544bf56844235dcb9810da7c35eb197426a5fc164920a827f1ace75ab6ab91dbd2f8b01aa711ae41b88d3ea21015ae7b4019f7df116f67f5fc2cf14d7e95b8cd8efaaa7c1d96bc0837ee0d91da7ef6bdc43749c2d493c4a63e33858be94932a11f3c22e659510e09d40002dfbdd1ab9832ed8e22392ad11822378c569f405392e5b3e9e15a6662a86bb621e9c68185262fcc70f705fd212bd4ea0959cac29cd0a3cce136cfcbe194bcc1cb222353a88eb77c3983a5f64d8a9d2e705729bca17e49de5c7c4c4dca5c9b0a48e422d67a9aacc50763f54d24d12a7273824c488fbb9173a2296a778fe2b8f5865c5b0997e86fd790032b2bea194e25da39e0a56f3bbf348dee5a0c0159517f7ea03385b1a86d749db0f2b80f86c6d2c14be17fc48fc54cd3f8e4ed4fac26a266055d252f7f0d153f33416a1eed29f5b3d6018969be3c24f5745194904b23feda9b7f2b166e4cd2b8a422261eb941c52d8a46b13b61ed492569868a7ca8ab937fa3143c34eb810eb522b133343dbe3a15502bfb6b5007023f54c26ebf2647e5508b4056539cd25af9ef6653c2a3d6d7a1d108999809342d1e4da3106c9a8667cd973df88b29d8d19990c94d77691933260284e258cd08c2e56ef085baa198c42190ccab4f62c41ce941d5813342540c476439c9cf3bb6f128d2cd64540d3962502dd4b80f12c1af667f6c63304420e4dd3ae358fde5b2e1885974b8f8ac3e504d671071b8c7521c0d8d3462d532e93918181746837c6a720a6652afab96b97a4e6ec27c64ba79edc1907702c5911927537f08ae2b1be77cb881c1ebadaf1862c2ebc2e58401385ff56fda90fed642683f5e2e68b219fc102cb359df94ecd08a977182db94242836251fce7e726dfda69376ea9492084a670f4b8d5531998918b1711826783b58b440c26417cd2fdb57ab411d5d204f8cc036b7d4859f7ce78263426ccf468ba266389953fc9b19d802bb0de8f3229962d6f77069a0e4c8ab8329eb3db85be6b3e8795a6aa7c8f47ee97dae7984981608dab592b4c6dda79e24c39ae1955323a5ff8a4ba4077211ddafcc09cda4b81c1ab716dfd87e14fad8173f475043024969802c00c4d52bb8f7e3ccef2d53e54742fc25e9edbca9ef3c78b52be1af8c39442787f6646d6d04a695ddb7d7c7f62cdca606ef8d3ff28dbb4dd82cfca2480aaee2f19c8ab8348fcef0950daf13d281de553c68aa647ba9cdb9509a2c23cc4d4b27e7c55240b9ee4150fd30a97fd5b275465debbb3df527b8c43f8964b5e07cdcfc47e1a80d5d45825e08aabb41465e855a6f06386f7c1626d5bb6ce32bc2a1f6ce21778977b3aa0bb13ee1c1330222308e87d81193510cf7cb559601d1c283dbfbdae4c2f4cf9d7a8e12308d2d0ff701043e2499930ba46110d8ff30d5610ea90be7529f8cb7ac6d0a9f4dedac75ece0493f90789f6baf1a684127f4fda59966251d726772e9ac82c6d4a395cbd4add69f5d37a33866617341db82def277f87f169f22927dfa6422a544132d6ae8058c94e7aa68f57148d4c4104ac6d55ede401fa26ad69ff363fe426c8266269c57078c4c24850d0995f933c5460568c42048c7eb25deedec92522d3d0770a118c0e23423564a8cd9441d9bd964ff98bdc8e76715c2011843ab398ec103239a0ec3116f9ff926b218688cd5a94b09a22b75a01d5324f4e2c029ea52852bd7e5feaea90d9fb13950ebcc2560ac86f09b89a10e6af564255c34a90a1e152f533700aa4181cc1c3ecce0c307fa9c725b4c69af9fc88d875716dd161ef95364ec5443ab9eabccb73750e61a760773c420259e48de5eca4defa0199bb226586e6c62506952af8af518c6e0eb3a2996b6ded94dc9ecbee80403e886c8ff399c1a84bae1fce58d35e50250202eeec974e62952c8f36e3a31697d6c1310d37197ede5b4d34fff4957ac55cd4baeb26dc3bc3ceea6c869ea211e4c0a00b00c2f518d7d1c81353e948bbacaa5f14357e3a1fab7b2d5a7ff28b4bf48bcb4cbdebdff68355b526ff833c63436015e123f26342fdd2650ded377d08eee51c3a0f64ac542caa0035265083c3edbcdb54a79471a5b59999bd2e589d43ba71229dc531d7a79a03697cdd1475d098d3883f3bc65ee7bbb7e220e7fd960b9b3e9f26d6fafe8e65a203174e9e2ec609ae69179c728dbefa7feeba3d7314ef80740ba1362a63523689b7b12cba0bddcd97c0d301bb3f01be797e7b8bb04879f1c710f3da226cf42eb7bf9201fe310ebc3e4097eb891f3e9977e7ac8cdf67be90100cf2807223d2d1f52bf0fa8206e83a63932ac643b7e4584e953272402bf89fed920434e2b6d30cf35f9643c0b672bc26d446f726f8fdbf8c84176cef503203bce994b255f82c4a1293de1712af2422a315b017f5b674142bc56c87821807a0418b531fa6dfada81952f5124925e7fa59db1f662e2aeebb47ff77f9d8c86b275aa749a80704a3bda2fb706ed28f2acd369dffbc7f6e326baceb3132be298d9ca1a0bb0d152646820043382ea7280bdf5348f394020425aa05d714503407bc2a918ddb324fa7be4e1eb1b872356f852e6dbe33de95504dae6c243bcf52b5691cc3b74b22ba0db204b6216d6be4a7ba8bf152b9bae519efcd21c9cd8da78834051b1d7130448264cb1d42b4a3a8584507ee4d3663af0cb30d1ccdc27ff15804715ff39525cf5569ffd718f7a35bcc9d26a46de1c06d39df8a60d0ebabdd0237aa6a1edc990677e337027a1f212f938e9077611086e2941fc4ea83544c28e8dc6878baffeca9ff5583ba955e34a1ffb823044ea2cfde75de024d2bf12b256f057d3e94e98393a6043e94674355cca929a9994d3a9945192d6716229d9b3b801bc66eb11136924ce42340452110cbeafc940eea498e811e3c587a56699853075209f9c5b1141d711b809d55c6b22c631387d7a6eb018f0b645babc93afd8a772079e3bdc7f504bd129c841582692575d67d95778d174ac6bd93d90fb9d9ca45cfffd836e86c8a7815d0bcd27b8639ca0cedd8436b66e81c4b6ccbd38c48fe69149f9c03e11baa1282d7ba3259eda0cabe2aac68d9a1643caf2e9552ee5ebde0bf7669aa2b85049d8a4af6ab34dd84272be493375f102a3c77880ade830f382c7844e7e82fca814e855fdf09e4928752cb8c1874a1db7c93f240235c901a0ed2866ec32956ffb4ffcc55c0ec8e7dba0368f997d81c83f39d9ba1b2c671658adbb4eb2e10eaff0db0312c204795ff44b53d99128fb0fbd41b10537fab6f536953379a79f5cceb1b02f9848ee3c5f5822731ffe3bbf84556b099b0ffaad9f9eaceabd7c362f8b87dba6ed91ad9e47e4fdc13addaef7885816546d4bcfa754973de246c4796d082a144055f1b1c82bd859cf852efb496e2072591dda4e53f87639e461a090247811e2e064052ed1f8e7ef197f4ef0764c15e429a34634976ae292a7366dcceccd148a8d209f265a96b77abc4a6cfd9391750eeefcb2b16fa95bb2407678355157c990bb4727cee38fc5b5cf0d6ef8e22e994c3e6a244d2fcf2d431a6af5ca4a85ca84f3cd9f8ca2e0061ddbf4ea47f143d283c820aff18ff92587a97a981ff45dfc093361f8a8b979d3cc7af656778fc07c039ed6ec0141f67262c32eb6f5d16b38d9827c2fd99e2418dfbc812b03a98e2407f82a73009b73a91f8596058e7aee2f2465e5388b0e8932d1b65d01ffa208f1036650fa2cb4b2f60930b56f77de3f9f02794b1855f4230c90e0384cae0c599e269a9e84d45cb57f137f9ba6831692357e71da6bd89ee2903802bdcae89f69df9890ccc0df51a0da4213727c4c948681ddaabc75fe84889e45f65d611867dfadeeb3d27d16bf6d52a11f87c6c41217b7b769ac4a3855043165f3a5f54db6afe4145b70b2cce1dfcc5cd5934e7473ab933d4d276bd413e639f774b3e0681ced8063525d00256d428b19e41a4bfbe664b15333b639e506b607d6275c06de442d58cba5f4684d3aea23fd148da723bb7906b76b786d0b987da711f05d2776547afdab9f2875a25b2063c37b9d3a08bfc3ceca1b99290d72036ce72fc7a08d96a06af79369b38c1c19621a59929c82b1ad5b85f62fb2fdb77d3da6166efef08463d6a27f872b1335e77ae75ca81a1ce2873337f3179b147a8d9b4b7bba55c2f464d6653b20a9396b3761f033257c8db68fcb97246e084741ed0228457257f7e4759987155a1d61ef8361f32f9eabeed0433d6cf306f410d5e80ed9afb7e389bff08475aa054958e1ad613e5d7708351a44d14d050f73f9218dabf1265a1181e38f737c8089f56c2c06cff8571c8dc8bcdfe7cd2c78000d693d36dc6f0fba513d9bcf5dd337a7c2796fe9881c1553dd11816a3d9f84b59826080c7d44f21e47bc362b79dfe27873eeab59cca97ca9a8e322550099952879060d8ca214c5c53ca7b44016f16e4681d9f84935325f3e1e1add21e2e50aa5ad01de91bd39c682f6aa4ad4ea0210028ed67847b9798d7bd1ba7c4bc35e96ae366706b28d6cac1873748bcf2df772c9c6d57b0cb12cac44145364d21b112fa354a75f74059253ae802f551e6c26aef296dbed146c7f80da698b142c157afde17c6d4503f4ec6cbac0ea61d68401e8dfd545abaf2b99699af02c0adab82b67da8fc588506eda6d5c7967e082b36f1e16c9bd3255272258b8aa83b3786b0a462635ed4d74631c436b645548f4ee275f1d5508cdcb07f229cd85ee47f93027cf52b3458b1745953f998bc09d3836bfa2b8694bef1eaf103f67331e2cb48c054c06c19bb12cf690680f00fb9699157a1acf41deb3699dd449fefde17ac7bd37da6b67e6f40a7a760674148ae3adf120af2dfb5973ef6dd81cd2e58458fdb4a2dafb626aaa2d81e1b8dffe331efd26e89d3adb95d88208ea5ae8446fa643ed5c045cba8d813851e99ef775123c28c1df2b4c29a48b09710257bae8258bc424d8e11fcf16717b7ba6c57167563b80339ed3a636084bbf3894ce3a19ba608ed2a44c799bfdab28048ebfc4f2a0f8c97bde2011a225cdcdea29b299a54b2f5300bda95552730e38ae5d19bb0ba89d4ed0a7219898f88474b08327c062303f6ca321111320f9ae8ceeff9a60368573557637a460568cef4b7ec4b5ffcb2dc74690585bb49b583e25f891d8e57e8c79d0871b34d5703ed641884ce3a99621156e88f4b920926e875c01aac47a5e270e32bbfd5c885cadcc69c88e45c4ec3a4ad4cfc253c28c8f8773dceae903a7278412a3e534898ba5d1629b5aa036b1d3ed9412041be54d113d72b13bd94a1abaf869ac39fc3dae5d50dc34dec3f58eb6a6514f185d851cd0a3cb51e01f0a40f7dfceb85099a46f07f05a095efc2e25bb1688a097a6bf51cb91d14644c3d3b1897503e9f21a65c95e919c55652e99ecf723e8425b0894d71ea40bd213ca299b38e0bd694b425ea22c2335d5ef694eb5e9ecb03a8c816ff5491def9d46d0b69c0295e44c55278e8f9f8ca01fcfda7585333b713190216cca14deae2c1c30a1e938d4fa8fd68f6e50e2c7f3486d8323ead93400ba0590a12074333836db989bf76399666e6e8622c6c66df30d65ea7219ea69dd68d3b0afb8a3f592326c8c1fc25d1a5549181b927b02efb0ec9ffa21e0dcb0a3fd2c3680e0232d06779db2c4f50b7bb9af3675b668ce596e8bffc21e9149af6a8848e16c89af06bf6bad55f091c78f47f62afdce946741d541eb62d278279f3615d181ce0514f2ece7f2401a0a303b4ea1c32f465364ba911cf0758d059fe58633dafcff57c86515925654d2e6fb8ea9ec00950794bb0be37bfb595f9511fbf61a5f2a86442e9c8864a19dc33033e012bd29750e2875d918660e849f45437bd1c3ae4d3221fecb1e5516b96cd522f75033c1eec2f7e6fefc925b994ef00d896254888e5ab617b6fd2e102123846957084c8e73c75dca32b5b09cf365b286cc0be3c165424aea1694266e9c13d3a31e66fa7007c14dce7a0e5090b9c2353aa650929b994147c7eaba08f7eaf4f8097fc05ed7e6accd136a989a544df7e3cd75b7144e00055988cd97ace7cad6bdd19d204125b6bd1a1c8215b6316d96a50d8292b681fe505a0383a73db0d379f0882e3b372d8cfe14490d6014cba8b2c331610a3939f5bb989c7ca0932ef6cea2e9c9f9ece7d18f34a0a6ff36ef67d193b2f3aef671fd446198d9a5390a6e2827191f1c8c99d2c4c525bb6575819d7b3f37984b2aa836b1a6d72e6a479c62dfa6412ccf76c6fca9e94be5829a1064eaa9a577f60c6f7743475ccae87b54269989151ff1ea3b6b1f85844708e61533d9da1569a7e4a9ed6777382c115cfd41e4ff3cde324befc4a337de07ab5b5726ea23125a15167d11b58808472f2957048057ceda3f3f158cddef3c893bc40f26d61a353f46173f35e7207927cad9bc85ba190672e3fd4c8248441240a4aa5c67a4a05e727646acf6c1e4850c44db8e29122887f1b7ee3181b7f0008af860ea862da9cbbf15e6889c38fd6b0f71f86bcdc4e310f0f53ff5c85a05dc7741ba87edd155cb7915a301f4fb01aa843aae6ff3cf74a61610bebf8773e9b9139ad24df396772cc1d81a8780579ce339ad37ac769980adc18e7cf38c3568f60d71238976cd1bbcb5b5a5b08c42e82b142e22a73fc29977b7e95b9793aee2237d32a1c4ad5fb4a0713b9f5fb10941a85aef2a08c92428f1cd7b018e287e5d3af45c70e1d4af2e6c4ff02cbfca1d24d0fcceccbbb975383960b0b3faa8e1232dbd69fce733c958980d2b75080ca9928f451cb60cba9a377a6494ce8f49d8b666ee79a22bd089ee2fee47ea1a833b18ab1bc3d54bdc8da64a9e7bbae37f6b7a8414108534fc3cbd42f8f8efbb47f09a685f84a63efc467b726150b913363e7c61ee998af541445f5e045f33f02bb2683a5f19f8d4f9dc2cf2a22a0767dece8a1dfebf805c8f47b1040ed17749bbc9a7fc384a293a0bf9382716730a596de56afdc40f12c815ee8a32d09f4455ad827c8e589367ece5c149860196e4995ae147aab1be17c5141bf625fb56f7f97840ee28cf35f195343904fd28f2ef45c7ac91e2d472f52304f63b2528fe0956bd5fa242a3c9272aaf1cdd6afccb4186727f8cfec630d917771ad2f0ffcfd1c7fef003ae69b8a5dd7d245d25b4bbb8e1b62b451ce23881c30f95226b9734e4f6bd419a4b7c007f1f7d67ddbec626f13b9ffd97e0cdd685d6edc9f1bf4bcda8caa2a9c36c9028f08ead9920038c5cfc6cd841ac4870edec1be9273451542e7d418e33e96304fb4c3ff89f53fabe4c6ac3fd22aa464af393aa262ef0d26ea8e4f04de4dc2f4420705c4c0a40ef84ae92ce53ad934fa6355bc1a328d93b61f5ec6cdf1da876430ddf3ce7fbbd58d2af794ad83da9e10f255c0472c662980ef772719f5df0abd08ad7aaa03fd71e4b41f925990aa9f6f8e98c312ce48d5d76862058eae7843206497c9c69e25b396ff8bbbc3bef309bddd8dc8eb2bded3f0a9521628cc957ddb2102d27e4e2bdf4c82e607b9328e41abc227d295828611ef41b4b31744ccd8fd5ae4ce2c3c452e77776b5361944ec17753486b0365c5b2c9d2b25b32c12ec73ea17cb64e9c854cd8a98dde37038a97b990512143190e8cfd1cc030f3fc709334c4b0caba9d0ddadf7862cc933f6be57fb78e037cf680aa0fdf6b780b29efd5da96430ee45a67edd41dd7a6c04cf35fc048b128fad5b2cadf32661d83ca9500696f62c82eff5d8dd07b28d8a60dc6d0152005284be9e7dfca52302e69a810d5785bc9045592c03788043632049eb195ce3350a16a8743909df0d25c14b019ec7c42e210db1bd85ce87b0f68346a35204bd88bb3fec24eb85688ec7ef3f03a328770d0009410fee07ea48c9289472c76aca0c684a4dbdfe4b9588d0dee11d9655f434f2b363cac9bb51ed5ac340f23b2d23687be4cdcdcd8b1eba1a854e2e59ae9f3a7acff9893dbdc047e17be7dd380abc4f90ca8f88b0a8358209261e82cb8dcb5c7e26ac7c3e1050e4a160e59b1a2d0c80aa0a37b2425cea9c72f490fc6fbc8a7acf0f217b15fad41a852051f766f767053b0f5581b886211048adad6dc716e4df53ee858f3003686c457a5be1d4faad064f4b9b336c5e0d375d2afa6a480638e5bf654daebe032945c15c91dd540e198902a1eeccb222d16acd9ee26055e0b734987f1591d108218935f6d6df154d618c7931e06ac1bb2f6df9499c04398dc19832629c9e414370faa6f898e2531b9b38373527b2ade729cdf9e6ea7b18cf79e16482e1f6e6455a1e4607709d18fac1a0a94c8c95acded25e4b4590f30ee0cf05f2a1fa934ee5a0fd0b3ec5972be94e867c4f3511900cfa1c03a746f2e4794c6f3493a8a1a929a72dacb8291fc1d3679c752a755b4c0727bb3b495f4a0715242b2ea225e27a5665f6d71cf920ea4a315a295232a120d3805274e74854f1c30de1693352f4a6f0bb2b9500d67d05bfdcf486532ef0119a30ad95555fac74d60b91890ec320fad9910017a547089e07ea80ca0535dfccb4f9434bc4d6a30dad66e936f54fe150f81eb70e1627ad8e6ddd507a7f97cfa3eb447249812b030ef0ef53d84902439bbfa0692dff4ebd4b0f84a2bded558303fb30c47a459882c8b2140aa666f71c4c843d7e6afad9a469ad4d3bc2f35fd69d2fee23bbec9eb11042ca0a5700f32cbc4a73992f18f039091ec63e3876c5681ad4a11ad687b86117f06169741933dac2f5b54c72a06eadc95cf6f385855c0e3bb4e18de48096fb1794a18263ce6af15fe25a752417b9fa53e0f6c9616da58669a9913c3a8307fcc41a982890991886619de96c30483759d347ecb85ba9267b81e337213f601f03a7b92a95b129e9f20dcb1fd9ca1921cb1b6be16bb42716c9bcc0e315d45a11b139e2accb5078ea2399a428a7a2d49f1cf1421f7112f7ea7a85f4e01d9cb9686ab77915ea25b5c0b7e158ff74720487ad935d24e5205a52bd4475404a361af92c9a478e6aac49343e508ae677ed79b982e125ab8d5ce90ce0d25a60707066d7db21a0a6463be7265aa9d586bdb11b42c14396a07d598988758519f6ac25c078c26a01e815a09204d39f744802c73ec314b4bfca4bef2bb0f7154f317792afc86a851c400c327efeb83aa50109904a592007ec0e07773afd4a46e003d1ed82fe7d51e152980dfb40f203e7b3b4cb1ea367d1bdc91d433f990ca11f2a8bcf69d56fe4a5d21fcbd2b10a2afb0f67ecaaf0fcd01f8a0e1501d1b6664b3fdddb599669bec917e548f681405f06349aa839420ea209f55d86bda3de1c1b11ccb6c9e9dc3701778f6e95ee29563f9b318743fcad6ffec80b12876ab6b376f790314b03e3616d87eb9a2756ac1620109251a46d778388cdf58b2195e8408e53b94cd4b6c2772aa30e4552b815cba42433454a50df5f6044d72343ef7662cb65c6b57e88886ea07e24ce1ca78762b9522dfe6c946c17d5ba27b6129f097cd31255e9a06f7123c1338f4ea2f8d8ce98b99cff92850a1a2fe59d7ed79ad92c925bd5d1ed29a35f5ee8c0d559b53001ef0558d996816494f0653f511c4c72c3381b03f9351bf3ffa631866d097a007650beed33618dd6c01c24d600b3e1b9ad2c696934b27416203d8168148ee95e851c27c1424f9849e4a97fbef9b7c701da14f463abbe1206a1b94688c70aaca38e47eb6731bd722754f30bcc0883fd0594d5d3dd6fedbde11225b6386412fbf0218ebc0ecb7f068224afa61db194ed4e8bafc2ab852ae42814b50d08a745b0f295a7b5740f9efa4c709f497a89d6387527fb8c19d982e70679e2d50420abe141b09c906ffc47254926dccc264e32ba6c3651b3e74d8006cf577ca9fdcc5daeaf2fcbc884c612392e6ed5077cac24f53e7eb024b53bbb771e105f276d3ac7e0761f9898bf1fb60dda3102ce01293919019c5c12d100f85bd85cc89fbf08b24d95d3f776df02478fedef6f3ac3cb2f90ec05912641c477aab1f230803ba70691d76fd7ab7184e6b0942d0886443001328f741d91ddef9584e2eb73a9c692f91e1aad8a46004534bc1a164c33492643712e9cbb73c545ef3dff1065d9b20df1a5f4a69582481ee1fde3d8a73998645eca1157c6ec3a2d51cad17e57e22c95b6526dbbd5775a74060f78fb1ae7448124f2a89880fdf17602a5fb0fb3a6073c363492fd39dd7c74cfb14835a6e7296ba914e815c01f4542503c5a844bdfe9df86178f92109abe67af0286c9c7ed1663487d64615d1588aeec07d1f8e19fdf123d942ca10d6b0b51878f3219fbceb65f93fd81306d5a81faae0261cfff1ec762e54ee2f7be9d5d9d4bb132121a5176d85b6c8b5369fd8b5ea02f05e8d6dce29496495cf34eb0bd3431f47bff432bd05d98b453bdf3f762b643cb639847e042e67a580b280303b0b5e18190f7e0db8edfcd3a965f157bf2e74f608a604791b85bed2ebae967697680098853b3707615b75f2bfc68cfb76f4965fba1581f95b574beba8c7236de13e690250d12eecd870d386226b8a64a5dded6bddcd411b645c4c66539ac8105fa2beb710a285a06ee725691eb2f374ab31bf6553f6e1fe40e0c47705789bd594ee862c3babf08e3a7d82b6277c86095495f70d4bead1a0c236fa64c190a2a109ca2e929eb13b67491883ed3329371ccd92a24c53c0d3ff032cfae800ae5b979f0f860f2310c12cf0e3c41a8bf8abb6b2597271e3728093612612a91c5537b04bcd4289c58ef59423e66715e23bbeb495d93e047b8cc312583b56b97dce1a2736f77bfa13f5ddb5ecab90cbcf77fd56a87c8025bbbc5c8a056e1e31cb7addb28d852b5dac71910455b5ea9eeffb2ca57a13d57e1b465ec346ab83cf8513cc909772b42280dec1a3633a20d142b5c2a0f0f581c31cc6b1f9aadce5afc3f0295fc6755a3cde5f2d0206bc6500a3fd6847dcf8e9c01a7491e2b798670efe31a7c7e167c4b385da2ac9fd94edb357f37e65e59a16ff1f950d03388c711c23b4eff988f37fd34243241b2e6871f820749638a9b639f15c8d89568db52ee55d131ef699947bdfd8d81622e2daaf0c492ff7e13b1b21b624aa3c4542f00c42469345a747f08c5d3aef13eee682e81d8f621ba975a7c6689179b3ea521c3edf6aace8cde83eeaed5111c1a392516114fdbd310eb6e7c20032474cace8613d50672a80bac9d7b1b3dde4d9fa120ee26ffa9a9cac06c1d3c2631fbc1f82af4334f839f9d78aee624d1f6aa90c9da23a342e2b71edc7675b41398d8a41c195ce6abf823406d638615d62e792725819b8e50184fd8951bbe0ec102191fb59112358aa6c86c4748274a29b0e89b41f27b495d7733ede30238c343db082fbdaa8c9392cfd382c112d4aa0a2b19a07700b04ff44de650bef35ad3660285fd94a810a8bbe4c05bb2b38f2d7c7a7605c225e87b2e5f45aea88c436015dc3018ed3b1757959719fed0fb56090c95d8fbdc71c9e53960237ce02613d6200639439f62b5f69d6de29aad179eb2e69e76bfec2eaade42aa7cc16c2197b48c3dd163a01035d8a6eaabe7a9d7dd21f23504eb979009f23f2511a9396eecfb34810db91c2bacb7bc7d2e997e587b24ecb56269e36b760f69781d8b39d77bb3579990b9eb08a480140aa2bc335c3112f10b6f41097f860e738d0f28d6951e5015e41231d033038c76ec579f1b753d754269a4e189e1916b2b81a04ad1525988e1d2d708576fe4137055cbbc5b348d09c1eeadd9bc6d27bdfad22e3b5338e41c5bb2c97abb35cce5c88de4edb921f2be5a899e0f2ae178b7274e214d9b9b3f2c27fa110b995be8fd9919f83e03396fe55454ea8c2378ac8a4396b53155d24e22821b6a672c87cf7e98ad31e8196b9bf3926411a2d3026b7b2128d0e4a016aeafc1ee4f9ce789ebd7913d6d7202af5cc65446d304fe98b60b870b9e81929d3091ae20bfcdc11c75b488798dc654966e43268c7780f4b01d29d8388369d8f24e2308db777fa3fff921d53594e93acdeac052974933c44da9d135e0a85e4554039589c7a855ab4fde40d0c48bfb3dccf2c6725aeb7fbaf7a569fec94124b6e537a2db6c217dc62e919cf7a86ba93f1d04fadf5542e870a8d16b8111050992fc5328550d87030344cbb1c0d0b3b8c248f66339bebd53c8f5afbf278d966f739f893ab0a40a8516612992c5f45331d02c1a6226e239efc996aa63ff339aeaf17e7f534df27294915004833cf0906584423a5cacbee0ed765b0bc346e0e38c143ca4f5e8f0d3546a6fb9df84c350c1aa09de189077dbf0b8397656cd8b645428040c2fde9555d040fe9347cd7ae13170f6d3946606fdf579e30d0f08495cc92a6e50f03d01e0b823397eda95ae8dbb360987275fc0cb0947399adb8df69f85e5bdf1b881830fa06d46d691edfc499b01b03b3b52e3a06a6057cb1338599a77150aa7271b691b87ac51f91fb3dd675a3fa2909f6847dccb8752a16e70e0bed56fe5dc29ec1f72b0b6ea210cdca380b438df3e42e646b7fd1136e181a278e8fceffaf5bab45e70923c010d47ca5efee80c80698aa3267b1aa82997992b5ec890e793bb63ef8305eb02ded9157a68820748fc8dddd52c787e308cffd6037a989d534f4ebec38210abb4d6b3d2116fb9c137f7850d0700f3c7e69b5efbd931e714d613839a7fc8e404b2e079539a428cdc086e4f014e4229caedd069bf5ff2dd8bd16a782bc86c509a08cb597d04c2414a217d2a15228078af8097fd264c4e78a0e12bdcc69111fbfb56d65062b216745cdf48aac5cae0c7a9e08ae6985f4a3041a4d3cc1fac708921cd160eaf623672a42eef23ddb87faf75fe31fb90a6cd0f9cf5e8e2f7ab412061f78570db0ab98ffb4102be483af271f881619210ea351cf27cda48af282a07338fb837e14fdbef428140e15e2ef42224cf7e1804b2bb422e3ba55653e3cca84dba76812a90f95af5a13c1a8afaae8c679173cbb6de89441209bd6fd685afeb988e016de4dae43c7fad52a59bd020ce67500263d6b5596acbcd4c1ae9ed800e534f9d0bee265ce4ab83763496b2aa7ee8adf8272f268f19c877f077bad20f5b0ffc91bd2fbf39c381b76137bb1d81c6187fd944be6ea307b44a5448a15f83a163a7202fba5278b052f6f4f58b8263353ac1b7bbdea4cee677db03fa6a9ce08e6bc0564633b66751bfd1aa72c015896f0eb0f0a41015877b425f3b3bcbf10d8438f1ea0f247460c55d7c90ea61e4f60f3773a6d5635411c670c6f295ef15eea27dd8cdcd97df2d58672f1c35cfdb0372fa0aef1fb58f785bb1e4a51436ccd68db3d9f6b0bba46a8f0d0928345bcf8370a01294135d1bbdca07a9842c5d28ce0814abd8fbf18d992cdfc823e3d15fef9fd012d1b8f7258b7375166fe61ac9e2a8a844ef6f0196124ca9220f78455b0c215a4e34b956d84c357992bd53b66771e408c27c9ddd52e33871c409b3fe6071475a09539584b4ad80b9213a397e3afc93da7f7228941a4d4183b597cf664709ad2d6dae2edf980ab1215c25b619e2849f29670083c83e2fb87a13e7f144c2db7f50bd990eee8a9b35eb98009a65740ca22bf22c500571d4c4fdfea3b6b2b7bb63df82bd2f735c6d796c5fd36195800ad649c47b024834607e2fa2b0dad706f161aa6508c2ae9f46e93f206b68f40603aa48af4eabd5c03a625dc377ff4bfd8219320ae12ac41ecb9e6fde9d8836a03e4a2db6f9e205c1e92ef8673a33adca188c171953b2512a070510c657f93d8118d713da29e6ac1e6b08d25f78ee21f798d52f1d25c442da7364adc50cb00b70eeefa70de19f84830e741e398b02d85bed607e3aaf239e231c97bc86eec326ccebf7750792cefefe484be9688bac63efaee36655b753989a381449a04363239eefbf825ecc3b5c85a92ae3cc69237e05d0748af7d8afe1f2158382c309c2f6a6f2be1517b3a76dfdf4d2c42fd1c7116129d3ca0e05044f6a6e99bdc1ccafa16586e6a419b79a02e2ec44b9f8eb748f05238239db6fe4d6a7725ebcf843d89737ba11eb58d3e67a3b9528dc1d3f4f5b69c9aa2bf306b5eb5f42d5403283777b0cbc95c57f15142320a0f6c46e47092566b577354e16540c837a93a2f23db826bd7b6d9a23d206cfb9382d48568a3a1564e01e4a97fefc037f635b379508f0cb054a01c196526647fbfe6a7ec4234866253cb562ee7802f3989f90af91b819c87db5c01c917136de3131138271aa9086209bdbfde6b8ee2ae27443e06763f5a1a32b2372560520f46b58bd01b0e39d4219e5d2905de5eb344a518805fcd80965fcc29c22a94f69423a9ea2db52133fa8bd8083147d71e7e9c48fdb91a3b80415e61c679d7d4968bca924afe7c23ab6e70f1f688042bd2a58a8adb01684ad872fdb7f189f095c849e0d90968061f1088dd8c5e750594668d62d0dc29240665e2640dfcf018e84e63f56c398428a1e6850856fe5279f9b31f537322323b368270edb69003387ff7362a92f6de08592003c6ffc90b45e5a748d3a6efd4daf6ed9fa1e195e82faf625fe377dbf8f5df718992ab6ca2a10533791e105cf87413b3134e91071de4d8a0438e77f8c511b296fd2af9d0ad0ad4d027c120ee3e92cfc118224180ef8f01a588753c542ecca1aa2cb540e5d67cbbaa4c35868c787407491be0c74b046d8e099aa540c5902d509f4578b9605a045869e48e400e2d89d2742e9e6113d2a95e8927e151133cf1735b5e258f648b9ba9bf7138325117ac11f38816016c25b0bddca3a510b4f66ff940eeaf27724e59549d78bf3a27a539938103884ad29dbbe75ec53f9b21775a45ae51b61b569eef47be02b12e9a7af1b6d49d26dae92dc01afe08f0d6beeb43248e487aa355077a68ff1c863effeca8bb58f71bb8279da06d7d2b1f097974fc303176697a222b9c127957a09e1286cd20abd9171c6a09b5e7fcb2a2b2daa5bbbb7ae4357bd741f094e1485682dc86b7c52cac70e26161a192116211df0f071b7ce27d7e768691c5f8220910bc7060ccb0b8fed3541ce77b8074c9275a7097e097eb930706aef92eb460b67394b23971a85e0287286eb3430075b43c7d804699c87858835e446b611fe3f2a1aa266ccd07fc0d37d47a32a77ae7b6c586fd7803aad466ea61e26d62c77f5f82ef84095d79b01a5a9f15a31ab13fa8ebad7686497b5c386474009706f81e29200e2d51538177471f0d44993e59e2232f64283c0cdd7aaebfd524184017f07c16d3d73bcd01a356ef84bb7c964e7f081d774b5b3d56078d7b815932bdabb7090d65e0f3d3228e2d7d5ace088fd472f91204ce18caa92efd5ed73dbad6286386446048552f48a3566697decbd4a2c1dd1370789b1547bf09a28e8e99ced9b72b33272a7608ffba80632817abfab54060acd5d481435f1422a6b50c4d5e86833531faa41c5c0dedfc0850de5f701edf70e79acb5b5269e19d3ec0426895aa2e6635a86e413d0d284017812ef1c847d5c15221cc2d061fcf3089e6c410085cf183a1ea1e94e73d47685b02c5425172b24a13c284f0a23c32795656307e4d3635d51ebef8f7a174e9b01ffedf86f658dec60988a110778d237722f95a7fcee8dfa98a4a6e027157fffb2bdf17c47c3d2a34075ac5ee350fe80f9dd0dbf6e33f5bd0f22bdc7f994be24f561dba5705d579581187f55f2236e788c22b525845c3301fa22e01ecf2c1c857a3dbed6fe5ce6137b7e6fb2b099c640f8436982ec743f8f03cd087fc09cb97e0f6f9d491ccefd69f75ffd78f0ba4d13400a65b9769f229a0ed178f16131d655c547cce133bfbad9d2be533bb39ddd26b4b836dc3b6da1d0fa19780d4acf57762af69f9a148e5b9049fc1f555fd2d048dc856787971da232353a8a98672813a2b4c8419bbba06cbed103973f553121e541136b292937028456b33fead5eb35817b07d09346b4daf31e21c80a7d9765de26e768e7b9cfdcbe2289b2380fdb53c262288f8b5fea298f1471e8e6ca3faf63be20569b72f4f2beb1f94626a6f603480bb67cb38eb03fc0f107357b9e9a1edc6bcaca35b0391d955c50167893b59ceee07651b8dce0011b2759e1af68243dcd0c8b9b3911efdb49a0b28c531f2d0685e36c377d814a496c605d041ff2d3b200802db2c1568e550370fc413679ffe7e62d99bc011eff56779938a6ca7ac2a5b04de24ecbb84f0a82cd3dd0a670dc8fdb23742ac829998b7c03c853631aed370bb248a24e705a4b27f0d657f1fd73fcba52c90ca4df2367fd07ef8c2d58954fd0a59463413e8952bb903eb43b14ae3b7bc98bea3e45fbfcca55ac90741c951bf2fb1fcd84d61dfb367770beff51bc2431862abe28f07a51c7e8944101583d698519f8d8eb6ffaadd9aa25648f4e6f9fcff04afd4e953a1dd5ec15bf36685f598f6e9e4a20418f85b6844cea46e822fc05bb463eb63cbaf8f8d0997053c5075f78a5442cf0084ede368bd47cc5522f0ce3a0a0057c0363ead161f2ce313e0100bdfd7bef509b155a53a3c4519504a24834f4827429717cbb247e9ed4a5e48170aa86a10f890fe1d78fdf917653990fe616f2851b2d56e6c2633fe0567ff1d74d4fc59ce7a9a6cf3fdd7865dfa9f2e1074163d2b9238d3f8753337aa0cd1b16a1dd931b8ce419a560071262a3845676d13e0e195f5d5d7ccdf615540b01f1b8e0a9f35c1273314c144783c72c8a1b50bd410bc1e3992c2665f1bb6a1472912c0c49168e2bf31f3b5e91dc9844c5ed1c3c50ccb1a39ad9252c486177118a69a40875826f58191cad72096f5a82ada80a112de08c27e335720af096db47c3d7e18707f4b185fbde65dc39bb030b8a93b6be7b59aeeeb89d55e2dcec324fc0a9768b4f8ed617fb2db82cfe95a9253109d8ba762916120e77fd4124437e6b420ea67e295a5df148263c656c3835b228ba6c6a8dc39af8dd9bb70fb9ff599f201921a8a906427b6d28c1cc66cb50e0f47d26416bcfd34f1bc78af165654fcfe28790bfd03e0facb5d3964baae513e53a8f5bd26c1d3bab54716697aa5f480ab7fe492d47188bfcb6fecbec4567e7652c5f34d814e40a290ff9a48c009f89ecfe9cd73953c12cdae6ae9a39bb521c8cae73fbd8ee7e5c488c13a621ec644bffbb90eda162c8ed45445a2c83621ef06680e30876fb8a564773c2da40064dafeec395a034aee11e2450876383d72830c976c1f28810e50cffd74d41b662e3637e225081d9f92f0ba9651bf35fe8591920ee760fdacdbe497dc413349eab2c7fece2daf208b0d839a88d232bee6bd1e76e39b01413736648793ceb3fa6f4375938d768fb9a1b5808fdbd08dcc067dcf7526565bcb67d92ea7331a3e6bd87a30e19c1acd7c4dc8e7fbb0a694b1c2af43bdf91b778431a1f606577a9e9c0eb19a16aca37afe6fe575f94940611e3e4083cfc4a03faff0123f2044153c28f487b9793194738d1a90b0a4e3a001ba67a17aa2adcf837873d16df95c671f006a5fbb6e8ee006a01fb37d90715d665ccd4887fdc548c973c3286b6a1cbe48dac4e0cbe2ce71713b74184ce4fc1fa1488a2d146d6cdeeeef9185d2240ec056407a76f88ce6a228e037f0cbe6fc247300b24d465d38169f4dbcfbb26160e37c7db8d024b76ac6f4c4c04f37f713be2b8b932bb92d69ab92c118bfdf56e8f4c9e4e8600f812b9fdb6a39ad2a373ad3d649124a4b50380da32c9facd0d5b491be29d1de65cfbbe7dad333660d67855cbbb21ab4fac49eddacf30cc012b694af33c525c5e958ebcb72e6153b0ab76be6298eea76d18416724201569d48ed481491a0e4d5a483726a00c869cf978e95149b8e7d21e2ada0572e5b9009bb7674dd5381bc8f2d04945ae837ec2b918c101a1e5ef04b5482e1cac5f58a6e796cbefae4ee1abcfb7044249135aa3bde41fc44177b150c818c733f0bafeb5a0af404adbf8c37e7cc3b7cc32d7b9e4fac68976d4e7ec8821f7aabdca09b8300ace0f10fe82299de18c3b4295897069b369aea884da4c54d8180e6fa8a0f84b6242dbc8bb1ce1d35966d35bb7baf16b71ec52b1b0fb4ec13df5b25aac20c627523af6361d51585c2ce01c2d00f35ca1f55e65bbffc9cdffdb43b262d9801815c30a63e24d9d5d722c4ab6f35a2174fb491c68ea23d66de382f2e687be500312d2d08433dc549cf33a462e2acb13df0395cbec20455499b76a6dc82be10de27cf65ad0f662ba089988da0f868584e73d7a4c22cbd1012836a2cab05d4ded65fca30be5b2f7ddb6f39649ef792c6159599ec3b63b6c71d9f4f288da1d015b531ce1f041d7cb2f62dc0b5859ec88c0eaff1fd69e06be893c7620321b978ef91932cc00068044088031cae4a2398b6d997313556eb70d7b15563e5e492c95ba5a05bebebc6d45d5d80021c20000ab5af7f13599614e91d44e7198196516f13cbf175a7fb86cb9dc7f56785b7a4131914e13203621a10e8a60dcbf00f874e7aa7d9b79797451bd29682074cbf92231e569d8e98bc35b2d3e7f3c7a233aefc51964a04fd59d9ce43f9a4e1e150299804a8030cd2b588b20ee320de55b918443ccd076346008d3f39bcaab90d4167483cd7d0f4d402a485c5757be625eee5a40d5cc67d31ad849dcca62d953f8438fc5eef2c71db71e0b5e11fa037a8b967cfeff40d207b1e106b12e90641f51877effa514b156dfa965f18af682f187af32d54a6fcbe1fb89e0390d9c9cb2e2aa4532d0d9952276c18b448cd3fae93897c56b6f08bee2b87040e027be307f35b82cc0c7b540116fea37b2a8c7b9a677e7e9b2ee298ea1c9ec10d7384f10be47326f3e37300df9b40828e4c48835d6c78ad7dd421bc10d16c07d4a1e5c0b4e3cfc7d43b9d640beb33d858637df662720d9b33f114f26208f64909b801a920c85c9670b69fb38a0d85bc5ee765639bbea6fe2902882e06750445a9501aa63220ff1f3cb94dffc37d3397b303805dfe9661987c8b853ac65bc17f84cea4aa1208a05ba0e7045a044f21da81d451ed03dfc4b57eba44a690c44e83bc02841caa0d50447a6dd4e3fbe54faf87f5066428c4dd3738d8592cf73a472b4a2360582a25320b981932893d41cb4f9660c1966d7a959ae38b929eb01e45b17911976284ad204b41484868c2d18554139cb766d80852e56eed27581684d35669f07ea2f0843e55ad9d26a967e3a67879397a44f325349dfc67303ca7a46adb8d0bf5a16a2de6a188905f146b950df3d4a3fa0d492484c9636c7b7a85df593e2e0d73502f01a9ad73c4dcdaf2620ac3463e2d40ecee1fdbadf340b0f649c1a6e58424364477500e8334f4d0853b910a85d260f6f215fccf9ad14e7de5cffcad25beb658ef771358c02d08d6902b66d65b4fa59af3ea093c1dd79d515ee422b3afe6dc503cc1717fa7193c41e394068325d7db7b8dad14f9dbc4780a15c278501b85c234795b67c0a91808f332f75043551e4ab7e0c7671faf0d9ff1e03bfe85563fe688ba1deab7aa6cb51a95482d2cf119cb04131b509129690dd4391d73ae1ef1165e5642e34883b30dd608deb78e11fef6fdcd5bcad30a365631bd1a78de88128d20680b171a80f1c690ece3b058648cdc69bc7ef026c9acb3f7af52addf7b6e5a614e77acf6e26b7670846632a9acb225f01235f8d011e23ddc755df0933229aa102e05471f5d53142979eaeec53d79c1570379d4564199ee211aee1b2fbe168b346c89e4a59c3e5a4d57957a2382416d1e482accedeae65c8dcb02eb5f82613e253512f142b974868d0ee660417854b7c79fba97c955a35a565aa5e132b58044bdf8db42aec5074e5e71fd08b131c154bb48ead70afbacdd23be3b5d34e47ea2b8e855f06a46bf0731ba76aabc538be4eb8994f7f90afbde8191682e196d9019b47b363221b3d259bd04d0d4c997297ac82c8ccaeae77f19cc917b5eff04fa4adaee9fc315fa73f4dbd0624bc14a54892cfc877b9da6dbd23b1f72022b32470252be54720afb29231981ec377ccf230d1b4b1f9b3194de17a2c3873dfdd1d01fee30fcd0d70bfb3e75e0a6f5741a7f04136fd661c8aedb165ba656d5c59193dd74ca763d5c72674bc098f0f6bf36da9db4403b77c327cb81321688f9f977566811d842adf0ed33489dbb85879fc144ac3f9c11d025e63c22440615214d59210728e8f0f16f2c0402813b486ddb6bc83f2de48f75fc051b095f8b161f2363034bd24ea8670155c56bef7298a9637b177bc77cab47dd533c04156026d1d4942901bea1bb3f447fe8cad19b3dddab498b002c4e750c7ad3c6436b634f094b4145e1063c4dd92c386d40ff56de109bc572909648865efe3b625914158e9585924232e8be03dae100bc78f82809e4e1efb0b22ad97b4c6f763afb361ee186be004fdfd08acef82acc508c66f8cc64075cab85b47884bb8b23d23408c7e919fcde2fb77948baac8f84355b2494e11183b8880c021dfcdebc13a5efea7f1ce30dcde8cf1a62d53118854ced782a60c9c83ebf9687c618577ece9afd595781202445b248c2882496bf1f6ba1b0cf0ba64142f31afbf4a6c8450f490f9d8504536a1340e41b2ca7c00917443572fb290dcba8259f732bd6ff594406402ce5568150d55735ae076ca4dc2722f0030beb6e7b6a3208637615f0390fcc21b1735ec67880b757af92b511b07a727a34be627b1a159fea71e0ff222cc7e972c7d2360d91db4b6f188e2ed763301f2cc2b910cef04cb936defb58684ff886e7fac8c11cbb01b7678c7d2e2590e0b9dbea03f951514405da7e5d19d90ddff5b002c0c75487e326aefb260e65f011767845894ce08447fcaff71f8b7f23eed5ace646a8bef0c47bdfab158cf69cbff3f8259ba1db8e311b5cfa5d7636824e06668d8f9a533bbbbea46f18418524ddd968936dbcc997f640e7a9b85d913c5868512dee7d9a0f34e83768c324e839cd401f4797e72da91a5d3a58d7cadf491b72f03e603affb06ff64a9fed21bd97e9ec674396dc25cc376ed0dde1aa9d65da90c3d801b185b600544b2531bb32effe58294f493c8b8a7bd039bd04bbe2848b5b36d1953cba3f4d8e3b256ebfb133cc90510b74979b4827dc4a1df204a35c5895ef9d00c2013a135c9d8c470e595987db1366400769eb11d40f665f6bd23b22002fabce50abece2f3257ba46c7da8593641e7b95595c62324e0f58446bd0cf9fe22d1ac5365ac9cb236ab2f699f1cde9e45b04fb619dad9ef2af59f1028a9a50860a0ed50f848fa115469d85089e1a62d9411560e1dffc7f0d6c8712208cd21eae379063b698207ef147e523387e5b6008c4686cd1ac111a54f04be7fe7db1ad94eca1151e594a32044a393f7eaa307f61f407b56dc46f2cd9905d0b3455d74563c4b4e8f19b5015e2eba58804ebf0636cb6536f706dd353e0997f5bd878cc5e0e5e09eafd728297556fe9fe045bf128e9cdb9a71406abff8710bfd0d4999d876798507ba2a8277d109dd2ba07349029b622bf0132c53039fee4abd901f3d2ceacdb633253d651a528fef0310317a9cc342266361c21a8c2f962f8ecc241c73015f06f086b22b9670ead2f3ae3c951f034573854ac5597714bb62ce0dd6fd136bbbbeb1d456aa42b76c3d099e2023ba839e86c8f5527ef6818da45da31d4ca87fce0c0b344558cb878fbf192543b41209c5ac0618d922ce243b09222b976e80d4afbe395be818af31d0123a47d3eec02a956bfadceab1d920e63f84ee60881d9ee274998176f4c35888b647670341d15e15bbc55fbb7a855f0d69f24e0cd7b7e22e162de0ca1caeabfcdf5ffc438d44d49f7e6ab33e50542e405b5b427f71b87c7e711bc2beb66bea1b706656706a901d7d36517b334b5a2d3776b6dfd86d3eed673c2d256402cb3ca8b682721f1e1bab3919c813974dc28dac4d7cfbaa859cfe500852eac3a6f1d8c4479edf8a4bc41540a37d4a467449a08d8629d41a28d936535b1b960118d4f9210eeab2bd6d5a39823205a7ccb9c1b35f3abfceba892f1a4cd53fa10649c0254111598cfd97221f3b735943a4ab9043f21542432faa8d3dc32c1759171cd5c48b1c21ab9fa355b8133a543468392e76b8313c59f077162990da2250f34f870736913f12bce69f6834e73682bb53abeb63533bf4ba32a00a6a7e835e63f91c1d2832f0bc70cba2600d9524b1e64626dc9ae14fb082ed3638cb617e3257f331ba67a639e3a62371c8df24a5d96d7b5786e3538deef6989782d201ff70f41136efbbc3614e8ce115ba51b22651218d06ee1e528ef1ec4fb4570c341266394fed4e857072bd32f10b0c971677e26a7791ea2c08f00941b735b54d4d6c45159aef640411bb59074cc4ebf8ea4d96d9eb6b85936bd4d20023f5ea0aade1fa176b277c8801503b14032448c6e9be0b2ec697a843525e7ef0da822dd432eb8a1bc454b5409488fd3de9040cf7a3c76069f7311dd5423932bd489ef8e16e2a0389ca8c6da9667e63efbab1280c41c9aaa02fe5d9d3d710746e12c141dbd1defa1abeb4f4cfa7920ce51c6a70f66508ff960476a1f86816a6e823947a3fbb6fa33fa80894e615e5380b90e5400e6f2b0b605139f1666e7f93927277631e09e6687cc29ae4e20ee09d9f84cafd65e0bf3d8d11973f4abb050d70d6fcad07b77122753cca75200dad4a090b375b014fb47ea7088e8a6c3e649543ac696f5c2de3d278bcd3c3414ebc9c183d3a78bb0cde77f71c3136a070dd1d89143b636c1d31f9b5af3e7ec92f4044a15e5ac9e58f756dde6a243b17fab7d25b8b9efd082af67078416d1e2602b058a0e00fd3e9e695a641bc20a50161b9f79845f54d7827f0e2129b12ce29b0467d60e645b47787bf65ca3d75610dc5b2d4d13758b1f17081c555e0b49d289e83154ea8de800b705771fc01835da1c4f2b1deeb11550ead2eedb536310b3791a9896d142d6cd3e1242c652040f5eda9cee424521e89d75d24ad840737d84244409ba5587bc340f0d23d6505b5b12ce71fece18bb3e25cc4ae87db97c930008e92c94f9785b8cdc273cb56d58157a9bac39c0d44b52efcf2c06e1d03c021e59f2ec6c0e2fcfbc1acfa3f129c54456e8c1b5ea58c3f34c5646f942f9f475fadf368f9bac00428002ebfa413607522ae388c76725e2147a31377cbcbd35f5b20f2d816fde2b5fa2587fe89c2163ddd4403fe679dc95caa36d2b4778e7859ac133bd7c15e769d6089ca577f9ee59af9e961605ca09da7c287a1a90ea2df5ec3e3bb05422d663d4fdc3a4f1c52128d2fee2322a26acfed18fed5fc272acdeaf2dc6ec647ba35876f8157ce98ee81ac599ebfb938c72ccd2c4522f71dd0bd4dc54eb3bfc04e9e6798db2da0f5d1ada1b3a5b61e6d58fc1917090a093e130929a343ab5ebcf3f337192266f4b4f982a86809144f86ba0157fcb4d143893e9ef7c916f15060c36f48d48309e022c4b6157297ffcd819ffd434f9dbbdc0426558292624409edb3e26029a32eda2d62baccc5e2431de0f5294be33f46ae9a0d0e690701833fd20e0037b0b49040cf7b9cc7d4266d47816c6211cf832ab6895b26a1cb18606fd30563f9c2ca94d203c9d69459acd85a91e5a1ed1e230c9766f819f25070d0573c18afc7d817683254a13bd47689a5e684aa3d6957a82918ac7e83755e81107a253aaf35b031b16bedc3f5be25d7f8802573cfc3c7a9dca1db9b0f1ce7067ea0c8ef23cd499fc56749dad299f4b57042ae910f6eac2c66c22d45622a30ff3b53e5ce048bb23b74786777df4515bcf248f8d5f891215a56add2a15eb7475cbd62351856609e373cd09495b1b3bba63b33b7f96f86e5efd9b7c2ccbc2dcbdcdf61f15a57b0d2c33708c5d49c68cc68b7aac5a7505ceb165bdb1ed05acefdc635286554bcd360ae189d7afb71ffdaf031d581703256bd892e37217c402b2f807a50947dd597b07c546e3f7c59a47840e2e0393d706aaf34798c9dfbdfae713af3b9eef809bc5acc0440ad01cf99d2ae2a7ea814fdc3e1b915c21148b711a132aa0715d2c877d304103a0643c2b4a0702a63814259401383046246df18e5b8380820adc123f0e4a3e5695da367df63bfe5c90d348bf2434bdc1a7f5c8c0d7b7c4daf46e799c4f9ae783d4f5d5198f4395becd89b57a2274ac43d3bd7e94066d8cfa54f2b358337132a0a4a3d006e6158568e6cae1448686bbc4086290d8afc14b2b2183b013369fe0388662c398a1d0d30741d8a5c95b83b5b3ed87fc0cb59defcd0e9500fcbb97afe54d00d13237fedf7e6e71b936ab675b47586d447361a669fb9263aaeb93ed7046dbeb0de098e7bb1335c13ac5f9d58cec7c338c9d490ebe26c834d3a5d52a71ab7fbd8c01b226b6a2b9bb7dd3dc932e73a310da8ff4da449ac4843ed8bbe624e7bff9f14d151fcefa362aff58408cacf78fe8bcbe7f5bea680a821620db7f01ee595b072b330c5d2f5290ed5e6be8bca509a46b310677a7ab522af151fa4a79885181f88dfdd84397d4e3831cad7aeb233f3782ed2308b4257f91c08f1bc8bb5cf36e0bd87e2d9bc1d507017ca88b1a9b8475485d859497c3cb5dbc82972d67b9b4e201071e0f526ba1d1fd935e4dc2c1887a3e5a276608b79bacba15ea810eda554fd5a7590a87bbc7129f78e3bb83fb2416bee0310fc94eaec3b4b9ec249170e4d65d003115c1e923ee45a0b52964b89296748a359aaa4af64688ee97c3581d9531b419a84dc442c2b7aab175fa66fc12287537d386f1da9326b80b3963ab96f352561520005277f1fd4d6d0e0324025e4cd136299c18e0135d18b664dbc061c97233653caab8405e156f5893ef85ea42733b275176d82a2fb4453dea6281c8faf566c5ce8672c3abf0788493bbde9cf6a6b18aef291bdbabc0194eb8b952f5e8f51653dfe09272050eab04b3897775d3fb76857563dbc3d590093d2b2f60e80f99d715d7ce20cbc3ca96d7c478440a82b1c5592ef53e46271104ccc59369cd1cbd2cc341e2fd3961ddc0c010e45162e1ba9a3d0d3c80924894f8e86d1ba9c91f7dea1d2b849113d677c0eae76a008105fa87f5bb75a63c23cb06da0d722efe5098b9357597256c1665b608f347bea963ee191cd7351fc3f8583f52ec142095544730378b34eaa374eab6f63156d70a8174b3c97def504e20c36d43a75ac174c45fc9701e078bb3951edd81c24be4c570fd4bf7befbd20b793b3cc3f374c379c4004504d6bb79063d1d697609bf57f52521d85133767f60d642216b041e408f7c752c9d0b3b8cad79aff780ba8641071e54e3b48a579d3f7d6e8766f30714d7723093d8e986ba5ba306b37abfb567e2e066502db9fec29cbe82ed4563bc151163a951ba1774ff1b5293f20022fd395271b9960df68e80ba5dd4d23b240c8ae370ae91fb67c552e749c384f88f414b29e34c8543cd5dd8ee5f5df26c29f7a4b1bb2f827903f2dcb2a9cb296e71a2b22f91cf9712e536e2cad3262253de3389c6d08c11e84b2164d0cc54fee7d5f632142f96392c540decc642a9ad3c93b16d3b7c458cafc6093cdd1d898d3dd106ec1a7799d5a63920b2435ed310185ca8313ea37ce5ef5fd90cc396b22604e816337fb99c77741c9226f91f93b3280bb2ac3da94d34c8042e7ce839e0bf94a49153834f2e93de9398c6ea94091343f30ffc0c0c87be1441c43a2f4efe763015a5573eb96d30dbda2cbacf53a3bec3bfad5a2b6e389f2fa2bd968571466bdd4df1cc9df8928b46f124cc0af0c5c06602507193e111501f09379c078e44546daf4bc8672ba7cc5871e523b58ba46fe9052e73ebc2083f28716df71a8596f3b5e2383d52a969ed5e1698e6a336db9e41ee221eef79d1bbeb58453163c9a3cf65eb87b873129734a2c7b0ad8c5c76ba554ee3d229c79b533847c030b0e1649620ee63b9ad6ce05756ce369c55b4a631bed15d818bb41414e91779bdafab2576e53b6dd1a0a72ad8d78b4b97584c7bf209b165b2248ea315b8e2908ff6209227e49cd9791e45d692a7c47482c93e8f1ea823741069b25069ec02e747eabb0220bbefb9abe1e9ed7c879533f3b1ec28d70bb832875f14c74fd810add6fbe9bac92b4a11f3d95ef660fc053fa5982782b4ad2d44342e9d8fab5bf75d9e48885e1a7e3e0cc94cc40a67b7b3e53c05cf4077c49adf204076ad7037bfd6a0f7a6d5980349fe35c6ac2d34d248b5f3111a757da13e389523461a6344cf1f4bb09248d9a4759d757b7870da40c895735475f7d46191a97f73c082d97daa1b2602fe7552deec43ed923b7c5e1d605a23f6a2d97d7b90e29774e4a104e63ef4615e80e14e8b043465bc04a5cb2f9433e632858131d41b0e69d80fc792038283fbeb7c94e2b47250ee4c360003041410685f5603f0e790bff2549b6ee014137a3991ee9de4922ba9ebe071c3bfa4e4d83b0881803e616053c40053ad6307522ed2229bef692e4355c168914c65113f04e515cc3391e48e4c155756d787963d901f6e40599dde3612437ed578fa158203a98304e5bfa2dad457d3ce27061ad5305f2e0e5500eaa1f808ff7f90c3739cab440889267955b4bc4ed63eedabd87ff235eb2f83c9877bb92151335424ea6a52f4029ab45335a8c0430d554b87c3c80ab3b746abf4abd0eb15acf1a1800e15c72a6a05809aa27ea6defe47d5438a9bc0c42432565d5a372ca6c5bd4eb130203201bbc75d013b325fe11c23fa681c13da13abf0dd64b84820da01073742f76dae3f1107c2a9e62b1672e0937f2ac07dd4d938e4fe09b6eae727ee65062627c6b00c472183c388deba28e34af2f5217c35c08d9b9f057a39d1666fc005a95a7ea3adb7fcf101500297cac231bf2a01db62837cc2b8a701a618ed214d02cf65fef5c7f14b2cc737c8fe87c9b1dd91d5cb873c41b118e77fe759fe814d570155f7ac664d621b0e336c02beec421c95da8f6828278ee67d02e98059f8691da0b384cca0faca51f46565218b4a9836ed9ec065aac1efe6dc0bc6430ca1822faa7cd8bcefd3fce21257a1df5dcbb48cd01a676afdc49dc08ab6ecc22641dff3d57d5bc6bca812a05913054d1b04f68df5466a974e0bb4374e54056dea40b4d5d375d060454234c209c7f6e510c1ba4834f52070be639da2a76e03104e3fbbc8b7f43c98c181ddcddb75fe43ebfbdf03ec0a57b80d30c0d4fc4311a96bf2cfd183bbc8684a02abf86aa3cb86476346e922c2c436dbf81fda2b3c90701d381b95d21cf164fd3494a7c9177d1825f65f0e7b0c70a4da1697de1e972b3dbecfe2b1831d72e727d3d87d467e526620597175701ee5d6d4f9a1b8a02ace802fb4e3d9a9704386c260e898ad54eb953d9f7f8c4f72965cbc96c4072462aa8fdd740356b56db751f9186d0b49fef5da47e1557206a97f47aa23c5aad14511ad39345fb3e0cb27c0be7b5c073eef958cf33656abcd968ea700dec199e8abc51bc45f4e6644035f8ce9b6e238ac10fc879a4c0390ceb63ddcac261bf4221badd5b1887201092e4c1ab8bc8bdd158ccdc8006e082407b611bee6704760ee6ce2c650d5b911b37924707b59df4fd093be7a4a3e7328a97d0f717a542c1e1ad2ebfdde874642b48e74121320e815ef95d309bd8d96e0390316a39660cf9f320462962cff6164e72dfba7ac5fd34946fa7a490211d2c81de99fc370758d6bfc632e61866ad187fc84a64a76091cf6912814e67030059cf9f340aee549e0f454947fa3cae86fcac994a3e838ab6e1421bc8a03880319519ecbe4d845d5b0531ff8a656a6914392562d78d066f9ac2d2c14c91e64c467a827108c0fe03917ec06c3766168f0c7987293e2332b031940d765383c52c36742b5279c6162c45756cd33c8bdd3ec97ba2e09ef0cdc4b35785301402a9afde292f6d8ab1bc1c00f3b318bb9691a6c985dc9c6af0f3ce1912a5143d4bdd0d7c7550e8498bda684ffd94448c3031862d6109e1ea5ba159a3007cdc6ea9d70437ed5f06d735324743928698b86833573deecf7db931c85954dd0a0abc9ea76695fb9914ead970c3f2b405c8ff09d19fe24301f6480c9b24743345a62fdf728502887f7f4ca5d19bf489072c53bc35a62b6083bd5a480dca0dc4386a441b86c3502febed5ad9e9efe683e2e25bf7c28ac968b11b867bc1676ffa0c8b6b9ac457320c65978529781eea9f80aef1c4cecb927b53f4b93ae095ad70cc0589a580c5bf0ff7e8d469515125b2ec0aa4538858010f903cb13091041e842a3478c1069ef5e903f2618dc43f40c28c673759eca3b4e2786b838410bedcf9b6a783b965e13482e200d7f40fa1e8779ba52045f39bed7f15c815909a4648b331c5eb793dbbbfff3f4dfb0cc2a14f97b2fe0a436304124a0d11a4e6a7008472f05d64ba9e673f628a8c203d1f70a88d783e530df0772e1f539c40ab33d1f7ae8891987845c33faae5d2b125e79cae0dc3ca8f8f923d6d8874b74b3706fdcd792f96a342b869b1916d31ab2e139f1ebcc04d03594233a37a6ec3fe103e9d757281a29551164b67d4c5181f66684238ecfbf52adf7a4ac6a62941e43191d621cba417f3739e529b083ba5b5aef629426c482834903676705a00c65d9d0034495df73637c8380e6707f69f243edfd80562ee2f82b549755ef0ef991d47f82228ceba224b478d464ee5032fbb6bfce44e37a4f12b264797f3d05793aa4915943ec370a5121f711eb27a34e4dcce44106e9629e67bc95875b602689ee16c0c31cc26d93fe0dcb49f5b7c11197bad0307bb7695a96fe9b59bcf4aa14071fc6a6d5b7cc449fc679d92f623704ca3ba406a0d39a93c3955a14b8edd08535eee2bf535452c8625cc911c93685f84f124f19e42d4baadc25319d1e59ef11f80595ba1ea7443670ad4c7e927c7748d17f5cb93ba11083f2366a362e9f27c0b013c4228cdf57063d173f994089bb94e5abcdb50dbd984482bdadd24541e35f0e391d433753d662891036d977406bb4f159327ad8e907603dd2cc1b60637636378bb5b663df1c32dd749da4a0a6b7efc34670df8c0816e26ee3cbb9e80a40227e833971ac39afe242556f66d4e725c29ba9a27bde25d75b84b4d0e0c67307429ae97cd596c6c75086e2bb02b2aa604d73bf2d70a6ac679ca91d71da307a752951bfb8797df15ed179c3a68dc68992b3d62d3d1cc50ea53d6932e9376cd070b9ed290f13f86a8e0e40badac9739a0a5b06dd33ddd9232f05ad8f083e2cc451ae84aa0150b108c5aad0b7f4434b118f00fac955068b0fe72ed1b4b04ba399812a650cc7554f28247a8616a938348436bff05fa6e1f3071675fc90acf1aef5acac582a9b26be1be7592c6a0a06c5aabc664739b39821b4c4bca8680ed45ec7e56d3d4a440f05905b2bf67564a0aa81f623f829e19357edd0949a832890fd28ab2890f3a63cf19e4b42f631c7017d53aa531d5cf28f6eafb37e8ba5f51d3672b38634d7ae868a5f5d1aa510b1ec3ea7b8fcda1128f42f51223defb501e5e155448de7fe25eb4c3359bb6b7bd027ed3ee02fd2f1faf27b73f056cdd7cbce86befc794e781bffdfe65ea46941aba71e0648bac5e91bc0c4e7df0e1867909139a1f52b79e70c6f52782026cd7efb619453da4351e47957a5ae1421f52bfccc9f80e42f70f96735fce44bbe2e55cd5e49abdbee3f60ef80881e8b5914f3bf6248150f66c7abf6d99cdbbe857170de0dd5bfa8a557ea672a1ecd25a25bfb12c9751d0ef917206429fbeec706439429218694f456ae608a139c91016d09af0d53a2b54aef86087b9e38089c1c30dafe00787680ae16e0d98ffc7be6b6309d202a4f58b6c06fd67bf92b6b4970ac62193f1ded973ceec5595b49d32af17ec0ee9613ab21d95dc2d915e47d64b308dfe786a7948ff92498d4e9b8397e7d355e1d445a6bc4e0ede6433f9df7f1391008ac225ca22020b04f679f0b69afb8d0b77bc988e1ccd41bb9564c06d61ebabae03496923e92b47ad486a5df927f63e0834dfa3660f35f5808c88efa34d1bc39c90cf273e06d93a6be2d7350f3676cffbc41a54487fc9eb0bef45e07a4e86b2c3f58619b637b8737743319b42a39b10c701e04a747337f09123d07fabc938c38f225e2a8b86841c9fdd0cd1df21034e02a0f162ca10273c1987172436b5e6ff618be93ca2cfd542c4329627b834a34577b5568a512abc73fff35959dfdb4b920e54eb8f43dc49965c4310e2a03b9c5aa50a2bd6b461684d7298cd15ac31a0fd5f4ac60b990a889df04cc768f28f4da83d3d37e0c0d7b0e8f51c60fe6838929e8fb0655c3686e1ab9fd80be70bb14133a7b27ad1e86cc9c8e21ac40c247479b5d0d763038c1090b89a19112fcb80c3d57e5a11f8c1912762e2e246f4b0efb263c68a797d7459d596a69bc85e19902eae10411f6a86a76e2c7693281826d159710a48802dabe77cf49d41154a5c7b4cc5dff1ab0295f05734727f70c360fecd64a84c91fe509182f2ed93ef1f0257515b22aa97f8ef10783b7ce477977dd1ba71a16e0b966884df21175f5519fc2b49ca445b146bbc1e048e91f1a4d360dd8f096ac7897d5adfbf2c31a21e4240840835647d4c82c542f8d8811d102e31c29d636b2e15e474d9a27a65cd11954607f249d4b1212ef8e841756ecd0d72da11492782831a75647b27ac7050d1b58c2623399b352d20e880cfce514bd6fe8a44057f7dc9ef4abfe787e124797c8c12dad99df3236c594bcea7c8750cc68d36bd093fa310f2317d33055de6a11de8df6c2583cb8841877ac96a41fa47f05c13def2762c3186487bcec53830b03f167a5934dc4543b876f40fde2553ddfdf71e2dc1b9c4558687f87be89510e3440f7136d1c039b82e18dbe466d1c88a925e9488e8a30c56e6e518dbcde0a7f15870d6b2e07eb154d6e875c193d6f573b2347a6b61ab19e19899647fda84ac7918fdbca2f2196be0b01aac7517ac49f8e1fe1642ee11f377ff6e489933b0e7bd47ccbf1b38225aa0f57e8fd8d72488d9f92873ce06e618386f4f942e3896b6b4329479a170e42549080acf08f20b4ab2e9bbe29c1b5bf67594d6fce2b8f58b6690c40e62a0d4a7c16bc3433dd6b77abce233748823667427bf45985030866b9c033da182a1bd6db55a176425dde9d7e7a4dd804fa5776a1e623b64f07d5570de9278dc7be2af3bf7efcad1d9f8d97640e87e2338af6024134f54c192e50d49c2b1f76d86e3e188b30847cd5c63e03ea51cd3bbc46eece37e7943f2675592b589b58b831745b5fd724a89bcaa6cc96acef9926c785a7c5c464afca098345d0b11cfe7556d79dbf9ecf6cdaa5aca810ba499529bab1f013734ce42576e3c94b60de4849b2b6b2510aa77f0c3ce0a7484e4167f7570c6fe91434954070c1ed2b19ce1761308abe18776cb93dcf40da20c1bea296987bde67abaf86183b6f63c0f21624bfd86f6ccdaa43f5fe996a53f2fe67e1daa63c0f678140e4705add49e7572c06aa0c7298137201fff853bbf554e8ebbebae3fc9f703bd2c3aa891cedb9e5bf2bdc360eefe004f41246d96b9bf1aec7444b14181ac069af439ed616f4fd668c48c344db9664dc5a2700589c7a61d9f08e733b0e07a6466639b37ff7851800651a145e8e93568c7711ad1b28279319497ef7636f1e071dc16704f473f6091efccbe49fa1b654f9c3812fd910f4006dc9a150139e49075b0b971e0bc1d3512ec02631cd5fe9435b00fa4d6337517a1d1ccae1f3aefa42d5b25bffcbfc955a1df189b9980430f018701df4f750a91d790a0ee614ea0374ab402ff9556838bf027786d21f773c1cd7e0a897dd31aadd6bcc1e718a19cd1ef5cf36a05856607454bf3fb1a72c57f68625e091bcc242a9d96564adc08fb8937fa8ddd87365fe1f9f6820a6ec637ced5cbdd7d07ce53ec7f63feb608acac6aac3fb73cbbb5810df94d340808d19326ca56e523c3b91753a523c6c33bb5a5a6d1c9218126b5c9d9488722115bf31a3232a3e057f5f1fb6c88988d7dd817b8739ac8fe2aafe781847bdc95a1da9ff9b5ab274bb2e7fb1f1c7a9b9645876452e6ef79292b2429d6813bc8a1db81f6ce0109d4083407b0f3671ec43868b2ad94012d745727b3365295c794dc514b71db87d183400768fa186bec5ef3ae097c6d4aa4c0178771f74efa6f3a0a43b9a0a8e6bf402215402b8d86afb3577dfed2b0901ac6aae6d75490741a8ed41352f83b144055439468d77bc5069c85bd4a455b4d4603fd633fa39548c1bfea9c1dab268bf92e7abedf485da7e66934fe661973e956994eb96b9a5ec9f2282295289804523e116410487f42d8161e82a9137e397d6aa65140ffdda65f4e6b72f805473c769b97fecf67c070b9b1ee0229d2ce9d1b1670c9c70216daac0adfe6cd48f4111b4f08ff1aa7b8aefea81dcb206de8248ae45df49c619742b27251df170aae5f8ecc76d168972be50e3e1f6da86c8db659d0c34a496c9c34b362133a0b698084ec39b6693f6834f5488a10268ea1da02b1ca7c5c4c570d38dfcb5741e305b25cbdf01b50d57116e6c7f87db23d9dcb71bd3755d788bad872af34e275c98510559c0012947eac9dccc3c87985d938cfceab7145003312dcd54836059151104deb6dac798e0d360f0e378e025c720d6c223e427c29ce3e5cce22fff057fbd5682ddde9dd9dc3d2a9e001b0b9660efbf46b906d39ef2d020e7ea8d0511a0583310adce475460967b62b60ebe9835ea54d2d622578457f87aebb887f3ef69ad1cd84a97af75fe87d282928cfdd4395f3befa469469a014d92b5eeff6763b18f7591d71bf393b2ec5ce6af23e86b1d08fdb807456bfc10f685d94f0b2f287a1339400ef78a7e92e8e1325fef17019ed6974b280fbc5f40a884c4b0545bf77d74699d0a4a081105e504de15ef30e4964349d1047884fc392f10ce595d42e02c3f4b01813e7f1f154259ff9c2244b0012e6c03e58f66d6d983f25c2369956de65882abe1b2eed95684b6980ecb7708f533cc654cbb2fdad0473875f6862dd888a4d49002a0ce63ca6a34975c8b461dbfd3344a1041c00963970190b63101ac5881641d9fc4c4f86e735ac69ea771d421290c6cd0908c688a17fcd70b41982b3b4b742d2f86deef4b2aaebf6142f9719f05a22974740eaa260cb4a823b0768d71789989cb621febac8d001a86160dcc2fd5ada8b41ff1b16dde6257b5df709a6e4ead2011cce20f88e1ac8388d618b8b69a293828077b9431a42a903251bf078cebb04fdac1023d30b1ec84ce7df99d7af039aba384c3aa0d1b92db45a389bfd10e00f0feb358e19bf159cff66586b4d099574d88c186aa9cb06037b8c29837c7bc4012089bf0a4f785edff06fa137fec0338a3007e572793a4ae8a6675a659145d27f7ff2e6925639fbaeade561c1c4b7fcd511dfb6b7c0be881498bf4de32eccfd43d62313751f5112ba9945935c5407d4ab02e4fe7e304f28cf59191971079739a91a1d6626001d6de2b9a10845b2cce08c2175266da0717898a69ae693b52fff47da4332e5a84afb6c0281e344139f0e0c1cbf0ccf781426e218c972703d65cda26ae57b2bd8074dc20adc1bab571d8bc26d977fb42bdec7578a9c8fa9c18fa4e2d2a87ff13a4819bf48a7fc919f494a54d9afc4dac6f754b7e305a28e854988a380282ac0222dbb94359ea675b11f84844d891467e82ea839df31269a96db04d1191ca093fba5af39fe4c8d1a2df0325aa8811b71a0ca038b7f7d2740b74da392fd72b78dab93186aa1a8f7c3c48f95540a947b5d09968a533d48c80c65a2784846807a7846143d389ddf81baf656afafabe74708a172c44f2d8ebd12144997975ee1a718bf1f062d8e6f9b220144c7b8651588bfac3b1ef9a07ad1a9f93999867b183250804983f861f607230a4ee9326220bc0d32e368be03f2627d00801caa8decc010184e65b2ffa75e5bb61d64cba27a51544e7857ccf667e0eabf2e41617b802d1e5e0f83aa87cb8baaa7ec4a9e52122f36f7350166ed3452b090e32d22b6bb06a1c0c457c98c254d459e42f3ca13512bd26dd063cdcb04d0ea18fa88d67c0e1089a0707e80e9beb91c36a47a18bb2a95cdeef6debb4ae60a65e98d01485dd4bfbfe71e3c4b120ab7947a0c3eaa2bd5ab2e6966b66a21f9bf35063cc79cc697c02a430cf6be0703808aca3763c44487230746f9922b38b747ae745811e4be416f7eaa98b52b4a8826abc65b4fa013a9a5ee8ad7ff90655b0a9928f598b20dd161e01fd3aacc70d50c1a44e52d51bb334f4de149ed2678f607c8eaa818cf6d8cdc59d17fa48846ba6a677d3a6db8c49b30764cb930bb8e594ef3127ed3ee97c35a1a06b59b428ee3cad6fb4c428ac884cd9198140036011b86e72ed20d82381b0a8a818e29bad04c8ef5f2fb2362a5a99e58cc2b79025ca16804f138919022104f2c46020cfcd5bc688108e54ae7b3d8929d27911c07304e410b00a62aa651d63f52e294a662ac00df9ec2463801ab9f87a878364d2eb998743d823a2bcf8cf8259db0867d265f73d15f16052f1c2647d360d24cd37e9d26f6ca7d14e8a4bc25ff50b616bb7ebe42eb99d0b5b67dff09be47ede35ac446b7d19068673b6a4669007709a3ae51dbcb330dd3d719a9f0080543bd65f4c79804a12781f60038fea30fd0e8c14975185c7fda5ffde7d32a5759370652941806921a42cbc29839827b4797efe9a27ff39dfb49edbe726ad9a0de72f98c926345c1805bc95f6af9101e75140fe37227e7faa7e13bc152a4c058ace7252b2a5d296a2db64deb5ebd2c299dfe370598340946d7cba8f6e2286a0e523645e4fc385da10eaafc1560f39db976aedd3c96004615b18df688c2c3918a4e88af3d8db2075026435a03e3ada62be920bde813875b49b20d06865329c493963a800cc5a596bc0b307d095b30795a95c991e75706f6662aea397f3ecb61c91258b5267037352b6400c181c28b433e4e35a297d22f908dbb1f7ec8eebc77d71fe4d3f9bd8dae4a71b311ed144b62a09a7c4e1d95e8f80adeff2de911a820620df5da44c218bf388396aaa7d22f8c3d33860a01d799a0c45e77521e1bd15f6ba29e8f62f56a16877f73624983fe081688196e18711110f2daa4f282c22ba8a296ac6b68b4a18bd05f0fdf982f5b45dc3bc144b963f22aee47bf7090837f8101152db9ddbf5d461cb1f849a9e2b5556aa47dc7684db51f376c4c2d2e1c9cfd5440cba4f5b84bde8216a660532f473ae74c476a94f638270f65a7ea74109eefd7acf95006aa3cb347c4e4f9bbaa1cf6cc7361e764c9e2759221d7aa9f264317cee1ec336e7fceffde05975a036d35cb508c7c7267534f0081e4b40161ea4eb224dc654a3889a46827b6c2f38994ae2dc7bba83d9cc792f56cc66215f92bff25798d4ce996fa2f0a74c9ef6370c1ff3f7d5e18ba747a0911793112c7f57b90b28a5a1a38bc6b0847e2c3d6d5199847ea2981b23e6f66b82554661abe7bb2d262089a149eae59d4d8dc3e5f168144a8de886875fe48ab3d85a9f95e4f546ccda9e01b57ac76a3c1e59b68eefb21f1b31cea09a978320a5124d051067bc1867460b49dae4e6b0e8e1ce88305f9114fe9c5808fe1cc0d68d49e1c29807a46a56c15d355434d70c11f19656330f4a316405504d9d19c8151747ddc12dc9828afdfe0326b1369b2c9ad932df343bf9c7cc58bc7f8ed659673d85eabef6f4f694f612e2a7c3d9dcb96781c9ab0ecc78ec048a4c0b4dd7ca71e64e68477cee05f75e32e4e181b4f417c1266a12c8ddb6ca317a01e08bf14accb8692b0b60dece5d4bae4bc452b77fd3338605f8c6c18c5eacabeefa238fc3f929cdc668c5db23f63b3fb45facc0cbb5839a5f60b35665ede22730d645cfa5eb25e44d92cee0886dd34df59a5c93e5deaf0fb2d75c20f24cbf366fae659f5780de428199f26315d4177c062a6af42d0cd4df0e1ac4058648422609ff1004d60a93191333f2b113152c77e2fd1fcc4614a6bc4a0279a2568ddb018dc05141397305b46ba3cb4860417dba364f01844768d393c8d6e361a5330da5bb1d46a0bab7133e1dc1a34ce1e5c36e67b3f20e01f26b605f39f08b80cd93ffa61c5e49da3dd8cad26314e3887309fe3b6ee7d696289b4bfcdeced66acba256748722b24000a0a85f02c9da74c65a2058ea356b8df8e36e1e11b5c7883b8be10472a453d68347e03988bc9900b1428c290f5c2963ef15403ed056082693b89c5a970f710fbb7ddb69721f076021618aa60f2d9c7ddd3b74fe117ecab60b2bbb80679f9ac1d96be2cae96581e4a8b0ef86c9a8bf54b379f1516d476c4000dc1f72db2f6e5c3f768ff5be57bef7357209158614b8f8c867bc7d550e9405941c5627e39616672a5774423df5a44e6a0afa980b18ae3680c16e3b7b7dd7723c8517a075f14d5a38d08ff1ca7249acb525080ee6603feeb784986c3c42db72f1efa93b72cc73dce417d77ab352de14e9bbce01a50d214af604ab26d4ad10cf145184876db4e250178cb9a4ad333652c6fd9604eb4618ecbbb7f7f24af0cddec42992a7359b1f3f78c5dc3c1a2f9075405cb8915cc23ea1e65ebc33e6cef9f9c9ed92021ca079e87fa828d441628c87657195f34421d160c9e22eed58e226001e591e64e0531ba81e67099627687cedea6e4f5c0b93ffb0c8bd616463807d5c12ad3938d1354668294d25c005d857bdef5290e9144944a36b4ec8ace1f25322d8113369eb332aea1f0e965f53c0b2f788917e0f2ed35d546842750130ce905e6844aceefd94b58ac0740b256d5a4c49d6f718fbd301cf9facd5e660e5eb3c149cf1d464f2bce445b8ce5fae5c1f6fd8bf605f7217db5ec234148c7558536c5e2841d2ecb835ac8fb54431899ec8455533032be48b951f371facf667988250754c81057757096ac1eda7adfae14c9f3947676eab6bd5cc4f7f200b6a28032b5364452981cb48ec02ebc561b514d99c0d7e11a5fa6d668af2c8c7d6a8d1b5d6553a53c5551c7e922433bcb82557fdeca9ed2e3fcfb4309479a0a888c671a91b2791ca7930753eaaf1cbf06cf49e69a80976ad65349bb7c9c71149b0d25d3945efade71b5f1b6413d0151125399924071cb130d1954e42756fb37926959af475371a522273f83b28d122002b744e55794bef59bd2f1dddf2a35636214b8ad301d1e2d9195c2018326d2fdb5b85618764ec881856ba2b5048cf66d62b6f2de5cb982b8a37ca3aabf70bede2914fbb583aec2eabea138f16b88a58b2379cae78dd0618b1b21a7ad4dd0585e56f5de1e539d60a744800b0a1b32dcdad9e6cf82b8b97e6f7147cd6dcd9a6f3ba1954c0587f918f33e57a0edd1105edc541e7bfdd2ddb230c23975004d183ad7dde645f2c8d9994d36e47879656b64f2875dfcb9f3560521cbee7fb1caf7afb9dd6dbcc14f6f24f8579cb504ea7197e6a22463acbfe47297f663ec7f87e1880991aee621b642077cca4a88d7ad920164ba7380df2890fd69787c3b9c29117c17b7cb9d1621c5a923127507ad0384e97c00e536f17c986c777af780eeae21abd41e3ca077b66f417d8537cf38ddccc6228da5c193c383de20594f67912f759e5777b7907063eb55ddd18b009c35d673aeb68ed90a6d6cf0caef93945270e2dc59b0bc8a02f3faaed98f2b9cf24bcf575dfae185b150e6c65df591ce364592f3b9ea53307e742124cde780eac7adee81ce7469d474fb14b6c868d9f4f1c336b6faf8ed260ef23e0b5946579e9a11da9685eafeaa554ecd9f7b0d75677046069bc06f83132c779db0df203ea461013f006b60bb62ea6cdc5fecf764b9503d2459574655482967285806cacf1c0455e6054c4451e3ddfbcdc7122a2e9e64d2615b2c07f180a723c8c43a564ed4e17ccc56572553836bafcbbced3f11da325b802c51905a3b1f031c28299048a6479c0810a2fc6808e6297003fc2bba9c779b5fbdfd637d775d970caa47fd38a0fb738c7ea405b6c0332aa726c5037b169fd7c1480a8947e8ff43f06c4bf25062b61c07b0b926f1d44d0af5af50dc63484db78fa376fb0fecf9243c10b0b7e131a4917466a2e9f1a0c08dbf98acb6c907d9f7c5fbe2ac2af41345fb3835be156de60a24290204b4162e007275697c0eeecdee76631615cc5d692486945de3eb9311283ffde26f13eecea3965c1d0cbc7568dc89087b529e20ea8e341ff0c5a6e6adea1bc72d14c3a9e86f3ff5e05544d61b0e22a59fdaa921dbc20336782a22aeb880e37435fd3f485a1f5869cf87f8470ed1d787b5ba736b51e76a1fc56fc09e20df57da2c25c3cd168fbb318c4a093a9c342d8e12687306bad2d7446a13e26a4c2cc294accc73b2a16c26d3bc0da2acd29ce88eb12042af55218e4b3d46198694fa536530635ca6963461ac88647151f4243ffdb0db2532b59be298db908b4ec452852f98ffe30a21813be71d72304df9d1f800d1c9d9c542ed0c932188334e9e8e3930a968cef785a832772c66fb740a95f8dafa65b659b7aa091db491f4095403b5118bad04a097abddd16a098daa071ed230b5159b6da5a846617ab8b2e0127cad37494ea870407478b6115aaf8a027e57c5b1593bb4efa113fc1f91e0d07284fffd54f43253fe6328eb5e3873f9c19948373f8eb1724c2e11fc912e35970583d2ab01bba4116332d44f11230138406c8e9ad53b794ac90818fc85267c7dd1a3358c060803fa951ba907f00315182d19ac238ff732dd44a652cff0a5b15cce927ff401f4a984cd5ea7c3430c77916bcf4fa8a9d3d383f21b83d58e95dcc96806fbfff14232efd80cd06959a103768f7b2d6b06602225d955af125ece5821001aaa6fbbeced739926ce6d02591441664a8d84ac3aa311579dad92235e83286b782a6ca6353d04850b353114065c076dfb373c463057ad996f4b76e5dbfa49715604dfdf563e322538aeaae7d4875c5703abd4a1ecec9925a408456ecce5044f3deeb7f6b699449754b064d877379c8b7ebe9a2f3b480651e3a0c3ce16f10336a5cfb95fb26c450e93999dc9631e64a4f3268887d780c2c96cdd9cd888f874ca5f8c5af3f3943b4e5e47f49f1c6035efe57c6ae3cdbab90d2e699fa26b8ba6a3d2e2d76c5ddea330588595c3917923f037b44ba06b7a7df028a1300928bfa4cf01e7e2ec7fd5ad24a8ed4fa28a492fdd5d2dccc1bf55a01a2a9bd92bfb018b4e6ae42a77a440b6aa99144d2d230a6d2160ca396dab25b887cfdc80eabadf8495acb09f746481f7d88a19705a584d5cdbadb1726d82180207df7cf870aaea030c07b97a30d2606ed72af782a1a44ee95cbfa80daf3b48cdbceca805a65e3a8590a054fd5b31088066082d6d7fac2b67ad8830d5c531b6029e51c9ebbbb2325df1a2255a883f280456709ca7f6fad57207bccd5d6773ce5bfa71bdd2a3cc84647525936eb10c91f40c9cb2020bcecf1658dc2663eca3d41aef53ea1495319c0d53e7a5c8b263bc2902303a9d47f305b8c51fe2a2d56bdc62f085159f8ceae95d39dad1f4c9c20c3a450a6e9b37b4584c22226d1f43792f9f45554611c8b8bf82c77c76361de4c2c7f86027c7edd2a51b7c6718107c1043c48954273d4a5aad3d1205209d34d6eb47d03041c37c9665d490ae30476a2c9f962d32a2f35bde9130225bd3df7aa4c99297fb8ae57fe72c0d511300821b2f598ef4deafd0050ad32574e3ee86c18f785caad6e41b937ca6646501e1e942220460750497d998cc6ccd78196ab4bcd6d20a7bc95e7ad816d551a9f6cc08b58738ae9dcb124f27c4ca0b14fa7d49820ed53b0f7c753174ceb05ea9151197edb915e92af31b0a09d29de31f3e0040110b05b68035c6b4106f71f7298812d389dc5eeb30364e1758bf1f38e764fbccc9579d6a7c2ad4cb59e417319fb14c87cb5c15779802240a75f17621ac8e4d49ed3f7fa7c41bb91f80b608eab531f37d1902b34d9c7f82ae822e2c51222758ec26672d95ae44db99bb96c96fccb6e1e47d8e65424de44f54e671e410f35f0a1cfff150a3a4990291c1fb336574a0c30f26efed4e0d1e0eeecdd0d0b93b7bd0746a3e8b94a356675352ceaefcf5719d19e5fc046615c7b3a0a66e861f0ae631b3392c9670bddd9315ad2541baca142222b1cc6778f06c3d30a381304de6222858a6f5f4c197e533af181490d921eb7d462390ede3fe26b1e93c674e2046847838cb97b72aecf72ad85c8319245cb28100fb05494ef27c8e48acc86fc018b79a262bcb128a08408cc946213e7c9235574a997a57bf559de49a72cfa0af3b1df68d288ccea24da94d3f285ceca10ed029c084581fa901e48854d269783306f87f258a33cd70b14dd0d8556ffebdcfbf6cfce748e06da6b02797529ffa22c06204d7fe1e2d223e3498bfa87f9d110748a9960fe4d6de488d29b23df5c0b9251da49794e9c6f6915fcd4cfec73bbf9da3fe7feef19520bfa4a60223e31aede725513541340a1f5c2c601fb7d5f702abc7bdf39b3a175c3589e2a8575718e42b25540c5bfe7a11e5ffeab539d57a5800f6cad5d0e6e5a5ac4a0afe704bb09f08a7242f208e51b48446ab286deea3fc9e1faf236b70048f76dd2e92c86875940c261eca2fe9fe2629c22b1140b192f13d178310ed2270e5bbd0b5bf00bd8af3b6e5db730cdd97edd3287a062492e22bc7931e7ffe2b6444f654ba8e7a7ecaa4fd9c45aaa19768be1a1302568c7629d8da0235d1e73bbe36789218b8dee05080c7f096f3b8cf3238a63a67ca73510bb8492b4a6d16b626d8e44f1d1596f9dc2973beebf9827dd855b508f962d6cf746e9b9fa8f09e71de13b1e813ae51b4b90c50361b7f1323758a997499d73515cf328a00c4bdb40954daac932ce783d7205b23c6eb35e3a4270f383231a616883ecb860fb17a33bee2e873f97400e4184aa0a5d3e9644eb20e128b300b3082ae3ede30919d1e19e45c09fa1add3aed41986803476bb615be39241f68b11e861a2da4dfff716008e643010a8882795e6496bf5ce589c0db86907a97f924e1b46695c11e0e07b4c6d4cfc2bde5bb23bb1eb7c7477b1e9fa92ff353279c8b939f42509b2cf99886bd8728d404c59e61caf0077c4ad706716be8141d1b5cac0c628fc7c57aab62167b4d724b21c9f98916a04ac0649440a97126d3b84ea9d51d1a8cf14831af8a14332c90302d1efdbd6fac264084b4a2ebef6c0baab3b5064b6712d552aaf0cb3b3bb2bd8f933f0b3c68d464420f0b409c7da531bad0237662f0e2a89af35084298c56620a930e6ce8d8a966815e77bc5f9708291e3e05d063dc01e026510813124569c03dc038dce75a364c4e3def1e8a1e9621092a29c5185923b560b8d8b05c289461e982ee32edccaf79c06e59eae0d51d7c13d7bac5991828076055102cce1ceb625995e99708d43c6f7724388724e5d7f6d91a3001bbcfa99822055c32ada98c023b88c3035c56c924818823488c598da4bfdd870507b69704f2db6912367fd210ac409c0416ffea5b4b381493bfa35070cb9cd8977d0be3f9939e5b1fc7ef11270872100179bed59922c37df9dd15c62f30eb2ea0c68e3b90004809206a70ecc5b02c8073824560bba52e3949d769fc852cedbb42ea05dcc742881374c21c30bdcf4ca5d7fa8c1855c1723fe0ab3ad51896de5380e8b96686d741c6d8f230487fdd077a44544f68513afb33cd2c88fdda918b3cf8bbf7d1a25709cbf7c0903d4287646fecc28bc97e8b2abf867a38766cb1d54ba56c9164d279abab29184047106bbff3fd67050b00ded5b843d092acd3eb3256b0d85ac28881a5241610ecea290247499e3cc3a4d030c2223e21c12211ae2cedb1c2ae081d00ab471cc761ad5bfc7facf8a7901ccf572ff36aac57a84f8ee06dfd85e7fac565226eacb311532941c0ca9b507c7aff564daf70f2c622b3027f5fcf8ae93e3f40a6fbfd8a94b0f0c5b6889fc65acdf7c2c0d5e668e7e507dbd021793597a9292d84f0ca7e210b666adf184d1941bfa83b211928dd779cd422acebe3945b9b7876404cfb5e19090c17106243480c3af4ca7c6a41b895c0907f81190586a26c7e0711406a1f7d32896befb551c5da1bc4ecd2d3c73c46a40115d0cb1d5b5eea69e960312f5d7301fd6479d782e98efb924a98229f66f2090078b0d5df5682e246be4d8c14c2c582b6867e5112554ffd98c03762fb4be44c283e48fbd1748ac0d3c12a6626906186ee39201d46af0ab70e178a2627becd19374758808d09f039beaffdef8232da5f674b58986620eb2438f663a6d86f41b714f3b106afbeb80a198f02b9d66be53614a871cc4e2de8ad290005a61f1638ded015b8bc944fe5c11ccb27c12e9edde729bc8b044f51363879a7ab3136d08f2211a1e7db4335019e85318f5b0ab340743b2219b45bd0d14d4d4e0028bea185ebb3a84c770f219979206710e1d65d300344a263adc2c0f9507c75a69435f23efca99e099adabebfc75823b5323fcef371c0da05a8e038afc0ad47afdaabd3438c4860d2b50fb987a0d90b3c0cf96a74743a506e1791e23d8daf9827af014a00f095f57261a7618add93599826fad8bf45e709625152f3ab7c718588e33deb45d152b14667d8b46646bb88702a3f6688e83b54790458ad4a9f583d4300c1f8c6f7c1b6c0234ba33bcd8c359f728eeaa5f798bc9efe051b2dd4dc213eaf61809ba170c8e533eab22fdbefefb29ee053900670db90438dabab5da25551f6bb2bc06b81a9d073aa0eecac44406df5585fe691840c6473a5b4df858108c8413d2396ca3b492d4de40e1dbff14f4697f772ea7f2ac701819ca228532e4ae43eb7d16112e266be55181df44a82a8e8806f270331a4e2a2b836cda94c72f15a868364c70f105ada3d3997a7d26744b25dcad4392002b55816197dca4e2a32d216829b57302432e90ed5ffeebdb0bc362ac45fbc1326a586ecb7aab56f7ad0699f7cdb003b756de9b9b759870646b7baa608995dddcb7a63da0365daf3e97b2f9ab87c9698561fecf5e006b3f481d9ba99bcba13abb9717b124f9b6b5259c1aa36c2fe502c2d7a986ee7e3b6eb316b64e2fcf378e779d72ef1243be149042f5214ba214cbc1659a54223a25a4655861a5b3d7d4aaa40c530e30d30750402ba13cdafe40aeae59263d239946c432b28f48bb163eab8de59079c79d8a84cf530ce4fd30fedba749631dee4393e0262b83b2d2915e016e4b1919c49f0bbd1de8bd70a8740beb08f0e07f50ed9248f78a3ef790ab9552654be7b09b6c6387c433578e69c642872fb11ed329f5bf7ffa5754252548e97588d04cad186d267d218fd6d0f48313d0357b2824f8e7a95a0d77b1b2ed2d9996e46445625db5cd96c294267918d69ef8ddc9276fc1ef85e2f985095dfeb6a7049c3fa4a3bf907e17ae30289c13db798ba428e0f94534cb929f2e27d25bb60d74aa3bca668e06c1657c3f2ee78c07073984059a817fbaf8d289f75d70d51a4ac45eb69bd8697e7d32bcc65211f3ee52016767d2e7eefe3c84c16cd5928558070fe2c52b7a971efb7a7c0dfa384efaf240abbfea2525f6bdcbb4b43ee8868d9cb3bee781027c30526c20d59688d9e2266cb167b99a23c313d2c33c0349af6cd0767b14c17ecc05ac58f99d75aaba10eb459e29bbf3c2bbae48157a6ffbf5def90bc414d702484c50227e8cdd528dc123c16d73c4f3f8815cf7a199bd4c999d97a0c255093306c91899448cf29438d1c130c0cc49df664b97e6b67b26e35daa9fb0a554c4bec58f0d0dffb8b1c15f8f7b2c823c48c0b8f56780b00ee3d41aeb7ec30a2d8374577968c1f88b465512ea573c42c281802007bc4519230e2ceb0ff4c2c62d24c219a213a9ea95732cd87a4185bf6d6ce074e8a70614cbdb515dee1bde04bf451955973970e948aa3da90954554dcf14f12f82c0e86ab1c3f25fd3005f8a27f616b721228d075af4c73795201fc4a91d14da7d832409fc7c037c7138f02157c6df91ffdb3436f7ab7324f2939cb7d279ddbbf7cf561514aaad4b6e3e727ea7cb8476a13c42f70e9e0208cf33da03a8092e0daaf753b25a823c3a80842676b4c5987a2652935adbfb74cc49341878baaa1e303f453d7bfaa88ccb8cbf367a058bcd8874077539fb9a1367cd0de12b9f74f7cd3c833472b6ee54e043ff7d9c63e2162cec5837dbf9af80a729a8e4407a13651c14b3f0067ec7d9f3ca36a66255d1cb6023de93d706a86ace38b3305f79384664718a547f782483d332710301ce5138a030e886bc7b10e8f9bd5902d0e5b7abcb0f214af456d70d3c978cde39481c3bc8b8303ee2950c461ceddce1e6817ee3dad8943a1e4f6d30bf0612d593448bcac86094292eb88cf89138cf9ea9005c9fe04446bfe07b984319997ddc2ef55e0de2898efee6440ce6c029d810d6d168aca04a1c8c8c48e4aa3d3f3306fe729e8f40662fa5831fb508b3e5fbab32fbbc2027e2b1be1e90b20166c8f9b18a98bdff3a4a816e886165a6bfcea5c95a12196cd73602bd3832ab3a7c69239c63b8ca5da37d0398bdadce652493c035d3ac44094cf333fb25d93e7c0d720473c97fb6d889368202d428e5ed29f97b0a0ce5f8ed1b60ea505115e53c86672a9fc687e3ff37ee6c8e84630251f9347466ad41662305c3c2fc57665c0a4041364d7484a77aee835f64d19fd0e3e9b110e5080c830fa65bbb1658b55ad0f6034220bbf7044c1b522b0b55996e3fd4bb7331d3d6883d5435384f51768ceb7e137b1f5bd8b2acd24d3c2a6e6b3dfc18078470a407078d40d9e0649b25d8933bae1845471908084ff333b4a63e3341c47d2bc853b6040d3c6701837e6a077c3cb2330158587f3701444edef6711873892a56c8c7297a3261cad9fe599a9e9e41912f0b545ec010ab3a1f0a28e016f1601881292aebf789afc100326ffa661b4a85d22363c7e7f1b249a1fcecd8ef9934140cff9d96c2ec0a009b2e1a32e1420f6a5c8962763147c584099f0d2892748da56a61e418b478ddee89e96732f6fea760c08eb7591bb1348bd41624f4f6c2d6533ffebbbb4d749e21cbbe3bbaf8f7cc1b8acf89e9d4532bb213f2869bc311c85752806428b09cfa633822586edc7885067a368022fd535787e7dd9c1fb54152018cf82abc59a15c7847122d8501e7d07b07e872b9362810fed2b93c5c1a45ca8748931a0b15c14835589c7ad3fcec5e26cf4959c2038c3bf803cfd33f366637e6b4f74f78bb5ee112ccff4bd4bc7df7d8c5ea9835c778b2ccce75e155dd382b5cdfca70a371d739bd0cb595c62293b59a73c1cfb209332e1c526c38d199786c5a3d01cbc84a4e9722b0c620a9fceed09e2ae8eb753d20fda5a3a2d40795407f313f09e348069326dc9a1318921be35bd01fb764517d1ff8deb25dd33cd1d95787ae38e99e124346c50a1b17ed0b8cbb91b0e4238c3003b32452ea46d39fbb1babc168a3d1c9d9a7997a5acff41b005c9f3f303ed59217c32666149afcc6c9c100059a30d4632e50a6749fb901b4bc9b1f05fb8c2a4cd7617820dfe0e76dfe9ebb3612b3d6d55c5481faec0711b644e2f892613ea99ef9d554644e2581539f1684e440972cf0ccd73a3fbb640a58bb10d2fc2e02e31463abe565e996ccf53059231ffa2f3cb706dc0f2d78b4e1c81565609d3f65c57e7d08c5576ee0804797fdfeef3559e582e4544c8f14c2f8ebe1ab6419ab42242bad94a90eb88b7beec99be85647f9d3709bfce7479e45c30eb5787447c139300f8c50398e1b0ca40611a2949f9142e2a5600c7e6a4a5fcfb68b629168547a9c6b35683a0be239f4e81cc97cf3fcdebe27e27697d2be91943c7cf91cbe2ef6f1c4e43987fadf8933e67ccd9af26d86a887fdafcd5ccb9e7724fa13a4766d7adcb0130958a1e956a6425a19ad48227202f6c25df3ac890db567acee29606453a2156f4895d44b100583f27a1df8b47dacfe8a879bd6322b31877b3bfb15ddc5ad9af31efcc956c96c22d4b116d5dc74ce6af18814d683ab7e9a94710e2290ecdd8bd39bedf4e7212d2de933a06793170110e0a1551a3a8cdb925d039d8cc185da60a452fb5ed2df62d307dbd3a4394b8c566129b5a643d2ca13862d840cb982c7371f997a6b50ff44d79a211a6829a645fad356f9a02d6bea9df356dba53a90a62a04024cb2de1595e01b9b69ee23367a9eca4c393567992754ec89432af947fa89d6e6340a129c172855a9aeb75cdad3bc2cc496d3c84d7d76aceee05d3146e163eb8e33fa0a2b7a3b69f7c232e1ac5e9dfb37eef16e64cd64ef721b9d4236c8baff955177cbc51d8b88a5d49656b1ed98aa9b4e3486d26b1ca7ea5c46e5c35e3f0ccf38dcd32d968a4413dd0569977bc1c443410bd23c07fdf8f3ab87dead8ec55f0211feeb0097c0619b96fa17b272083af0e7f60bbb0a844773fee840b851204fd88b77f868dfc5f6e4f1acbf150a9c04b7b16a40a0dfce4a54622291f12727a6d1e4fe16bac48a45254f5bc7b3ea8699bdacafd98ee7e5e839b81b647af4807f4d7cfbd565e4abd04e169406268642882b8db653b8f0784109f379a9a52be4d2103367d5e347a073c4845866fe71639d3679ed8c08ba1dc59260be6e0ce4fc55a7bbcd2b0c96bd342d966a437569ef02f1152d8ae1f5222ba445dd1e7b0503a2138342c96aee6e4e0fba710f1629531364f5ae90d6c3cc4ec2bbd356146404ba7ed5b4586ff3af515ef8228dd939bf6feb10616461b5665f00b500f5470f7edb7b929974c1a7531a4b47bac40004ecdecc3be6b0bf4d45ab91c7f021d2307e7ec167ee13c2350b96af3753eecffa357ca6903785a2d3e30b43bb9d5feb5f9553590a4a6774c4b2290daf1e9541322ca38b837d48495882418c798f142648b26acee5bad3e1112f47c4fa1973c869b706e988c984dde12a909a169e4e9a1589ebedbdc8259d77b2ca6f0e59aea8e092645d6bbe015a047e68c84dee0eb25f3d4a2317bf489a8c3ba27b78f24f4eb54de9871784e19e6a8354816c03c09ccc8351e740b9510f63c042f41a3ce9442cd1df64c9b87ba55a5a6165b83f22ab0c9ff9b2b2b3d4198b661350f061597bf6f7e98931cb3df42097a6a7e0020532545c7931ce887277cf19f0a3eaed8ccbc0c2db970db015f4316a87f12f6871d6a07f43f9507533bb10c7eaf875adc176dd26c2df20e217b134c5b5e34a00fd03c5c41a44b5c4225c98c330095e64802d1c0115530fcc86fddb571ad3d6e41fbb03c3fe4852e3d93bbb0e62eea0629e7751106591537300e361ffe54eecccbaae898d0e986b7ef1cc01a340ef896efaac1abc8b95d44956960ecc7f0370e00269360ae5b79164638d06fad2b1cabee03cd54e92dacecb993aa71c81215b3554053a7e2e352f2f63dc37457ba9947de520e688fd0caf16069f58dae5516bfe5396f044dc66931f67d365c294dd5f45c0b578cf29f7320d56eb9fc5e3f8f48ee2f6c1722c7b6cc0064b36c91615d6867ace506e14b3aea64bc1a4c6cf38c2b521d77ed6a61fdc915acc5e2efb98921e3488e043e5471ccddfadda3a5b500a1176bbddd7f4d54d5f8a6f3f61888bb2719a03b6f7d7724ca18705092863cc87ee81017559157c8c7ae8eca3bd367880f35c64aac297182286b1b75e4c2d37d109145a4f3248613a604eb701c5f295a0bc75c83ee6008506e35e20827bf4e3acc86bf40519090a24709067120ec6b4d13435bae9c526e3e6057cc2fce19cbb2a15d85eeb780a562e38f70adbd1d08591f81670dacc5ec3e55b650dd291e435c454f4e9a2573811135ae96b1ed8c4a08063dbe34b494e42dc7bbb1493d51f07ea4bb72dbf03ed509cb4264d06f46fe51d198ab09f02b1c6f75d2690648e87d63a2a46c917e89fcc55168f9c29d4b4756429593e7550d5e55c8eea7834f4e0b045a2ee880904d04935f056fb9fc0f4d0dcc9d8a2d6f4f676f6504dc1840a1feea62246452d75c012e583fab0f41fcb43084fc7db69d1a26140e8b53e24c35a729037562949cd9b6457d0146184feeece96861ecfd0b2c48c8f202e6050e0fb090cbb328a38bbc8c1a267c7dafdfb5450fe1622ef39a5819579f6ab1307d6a6294d6921098da4fd6b665a13a88d397ddf98bf64ebdbe01b2b884c8e65f5836b886c56f68a256b368791ca72565eccb5a3e4df973f161a3751fefa5a646a3943e11a3c7e36b215c81ec8e8bcaaf97fe75d2ffabd6fd944be1c6e78eede2f75bc81805bb9b6a3f91fc22218bcd1fb2d2546963314ccb0519aa5d1b9490131796f07423939f4271eddb15c3aa2f64b05bb410a6135ed7f9c52b255fcc4941b2046d251c37159934e11cbcef30a30065a0e35863bcf248cb182720d8cfd46cb79730ef48b8e9fa322fdfd6dd27f0d0af208e9111fe85c1b76ed0ea183c1b3481f55d8b5dc511b9d770dbaba6df68e4bf4a56e59c8bf1ec253b2e16c43271a02cfa09d200365adc3f902928b46a6ea33403405e5f7dc5116583c72062d6e1cffe34ce8ab685c892394d5725bd2105715724eb1cbcce3024505fa26623d38bcb34662bcd3a508bb892bbcecaf31d793adbfa9d4c63e1791d2c7f92a237d50d1dd006bc1ae3d97a5e88c28c45cfbe12a70bc51f9eabf8069a8fa3d7da3d0d03f5f2be369d34862970c39e27500728dbd9193963537dbbf6ff1f210cd310b08ff426ee4032a26184dbf05f2545edc170f740ff002602b748b07663635ddd78fdeb7928112f509803dcad67a2b54bb5ebe1d0358292acdc95048f65382501216820b4b3e105cffe6a4b33ee47be5a72d2dcc9ea7a5230ff581bb43beccca9ed79ea0b0a3337f9891a1ae5819294242c1e0b98a3740fb556c7b4038914798d2138c0a25ade3884d2ee50ad7f6806eb5a4ff9a9d9a898e3ff38a24109fa225f86dffbc707f83c5f98b13ed49b00e6bb3792a511798b256d79218ae509674cd2e9d0f175278202ae3d1ab3d95d189c6742f3b71b62256f5328980203eac5ee1a9b8d27be05ef1909475e69ada17a5a7abea3dcccea3eaa87d57044eaa28fbfd7f1c3bde1a07347b0e051048716d6a8ad334e72815a5aac6d2ce4f8253b0a243ec56b5fa3292aed8657183e88bfe34585eb7afe7f6d7ec56f3dc8e3c852576e30f3f247f88904a7059d642d4676dd966f76041a2bd5d01817fc586cd499d23da0dd79329ed88e82c7c949c25064441fcf269cc7a3b6007e0bc19046df55c01c40e81f4444e7817cfc959bdcd18bf7bac7945e6619298135f5c910bf09e04bb510fd5f43e5b7252ed6dede9d673c9a94871978b2b8bb93f979b3996bbb28d637c7087daea90084d4f627cad86fa14a120956d98527eb2236760314429c2e94cc637dfe8228ab6a1b061756c01434a832f8adfb4abfaf6c7122a22858b9897d2a90ce3cc825583e56d2f65d388d462a147bc5b55344f07c2f0c5c69cdcbe08aad87f6fd2efed99c10d034d0692d79c6a01a092086ac0978daa86009a2267344865bf12158c7b5cf205de36e7c1646e797ed2a8911a44cb579d0c4257ce693a0dc5e415f94cca60ea6e73820988e79b27075997a1de37da9419dff9d9d9c263200686b0f2f781b929cfc0ecf8f4caf9fce510ecda41355a146046d7c8cd424a7ff5c780b96e9b775f14c62dbd74cdf5e820c04cdeefa004cdcfacfee2f821c9741337598f070d06a40ebd81aaa17ce0e51c53a6f58d69f156c23c8ce639cb0a1f822f363f7e8f13aa55f356979ba99c3fb7133955f5fc751cccb61ba44e614dd8c5087901f70581a4bb2e2c816192f5d41bcb76122b70136627e85bcb62f939454974bd26a5279caa33870132aa5d5add444509dc48d48a498868685e8230a5736725b9b6e0d798c70c40e3ae0fca0f08037ce2a6d368ec575909633d5126b550e3859586438b3e306cf1516f16bfe8ff6a9c38bcdfc377459fa4fab06013c11f102eabc54c237287b5e7dc95ecc2e3cfa33087565fd9b762e872c801aaf155ba5a23720b06846e99aad65af90cec351f08c3673f4f5888998de0d6dcb3826a1efeb6de9e580d71fe1128fdcab422590febf2e9fcbffbf3ae9afb75c8161ae8d888f3d0ccd2f1631ce3de12f4b970f203eb59262f1e97393e55b5202aaa285f5d8645d95eff1dfc04da5e5f2f86312eab763494c49f5cd92a6c0e9015c969316d5bd04470be8475414ed490a0c80113d25fdfff431096a781e22eda80667562691ea724559b314c41e1b60b6cad8c3c4aec9a2f34a13dbde0c31b33630836130698c66d36ecd407fbdb1a0e3f4f335d02337e6e1542923a66be1f1b484f2d744d6b9a61ec92f7a9dd525220b18ce45e863d4c2705d303dae9e184560b74ff4f64a3d7b1c56cfa4c141b425a34e8e28b6f48ef18ca9409461f03aaea0f898842bb16a32768ce856cc7c4c8c1f4d5be439fe8d73930fba890f2547119202bf6a3763209c85e4585a5e00225b82de77d75027730996b300f1162f7eb51cfe181b4eba898e61c44a2e2b01793d7c32af2e8c0c9fbcaf572694e04d8cc79dc2a920408c2262fa3049851b736e011d9f036f574b545669b258afa921c8d71f32719889324c7546d668c63f7fce1914b884f06e5b39e72d7dc9731e7e635923b4dab3b0f47da77e38948b92d5871981dd2b5da6b0c642cf2ce984c4055926f710b838f4efbbde6a2031248b84ed3e54a4a036ffdea37d1a86397a35d878f8a02f1e004ad68883be9445128040c4e53ebad04e0fbbd3757c80b16329dd35f15578e778ad1ef80385f2fa8cd9440b0f3427594db7b0d447b628a83f5176bc1583dd9523be80df4f9ef6ddfd13398ce3780ed92f29ca87d8a175808301a26acb65cdcc16aed5675c4bca828392c3802c455168c33e21c64f0641dc97acd8f860348ea17b80b866a4ca64447241b407d7f3b4962e20b509957cd6f0582d2f8284d6c68e0e987ffba404d4aecf08f1b677c36e8a653ade73dc63cab396e18721ca2d36eea39569e35c483ec4d60e8e52c126370fb685dac815e60afb9794dc082ceeda799e8617dad217afb475cabb9410a546a9401c2cad780c5d579339ebce86060e7c7963ae248f0401d1cee574fde24ade097620c48e00e4b7643576cf2e1699510442de3917209c7679b9f015d458aa3d959ff33329ecb12f8820fd529c0384d6ac1a812afd9664d4883fe348e0ba6b280459bc5e814038639768b8feded379fa3ab71c094f06e90d452070eee2f16d5d8d123d658a420a9db115c4365df2a940abe386b9880ad6d72e4e27ef820c77a16d8efac562fdf01aa7a438ebdf32f98607faa8e6443f26b12170681e35bc743f1764b2eb3dc15f2da785c5a75e46ca79bc70de717bc55e3516602599a1d74c20cc8121a49ba1f820929e1b0cd34556880149a3ffe1c2dbc980ad744a2cd83ddce7a31a3964f3202438c627f7292e95db4c9f92fb76df2cf8b61af47f915dcf67a9deec25ddd4a59a024b1def275eb611bb20b5ad30c98107fe1dfbb7faa8523ede1b1aa32fa27091016d50907d1b29c0c88e1f3ba3b126a7e5619d138b1ff32b6b945d8267804b441be0e00c580d35feb93de1ab31cd10bc59447d1626cd5619515a021566d5b5e7274e340771bf227a9297425007d57aa3665a6e9e1edece7a76cf891642cdc82818d340510023f4da8e9b531fa886917c03e8e73c8f271845302ca2d5f2d62b15e17fa75af90bad70a65acae85f23304b566a475c589bab893ffc6c15f225195dccd89e57adb12b75ba7a317439efac05ce0de3da23d79e1cbb9f1561b52f7221f855ad6a4230915fbeb366e76fb4b5df1e35ec05599714e626c8b7cb7c30e4bf45e4335b6f083a0c5354690e7e3f3c64a5f9211e9f3e3dc1cc009656faa71c4fb365c8a2929e46bb04be785e08e17230f5a253d06753e70a4521a077c2d80dbd1f2c60db8ab9b3279ae882cedfefd8616030b34bfefe9f41ffdb497a4b4943c1c5834ad8ad060339a9dae2de4443570915d5f7dfc28f63598532b1b47e4546154e25fbf3da967311f4326f6a63ba6c350677504d8ef8dda426fe14cb835c12a535c5a45cec5bca7ae7a2d81ab9b46a6536322630b34e3b76b1699b7b7be199a96885a369baaeaaf3f16f589ab997c17721d4ae32b74b88d9e47568ac546a5adf5f7fb7437bcc7edf50f4aedc8c4c5d65f4604feea8cfa20a4e7404b6c354014bc1400f6a8854f09a5f1d721935c1115cf98ccea6ea5bba88578e1224a93d203e824722de7acaf0766aedab51c365170a1f425749659460e9693e5766e288f18dcc8b5b001e1852dc85f8c87a82ae972cca224b595ac629cd20d50e2c94dc2c2e75f29367f008ef19f0e9d6a82a9649b330ffe4b4765edd97c0f693637ba5eba1a6db5c3dc9cb639f12fe12d23e1a1e0b565eab5b5b6f36ce4b185618b7929df47d951ae9bf7556a64d87c805b1bafc6160fab2a08c2e343bd10820a9ca150d2dbde5ee13a37e4f8c576a7f30cafd8ff56643b1729b76fa3ece64ae104de6736c6284734f2342225f1fa27ac71bea21bf09d9dea3674542e9ca20963ad7819f2be79f44e95482e55dd0bb86f5f28f880e1b16aa5b8d3d5ac1a7057b9e48a3254827565bb553e17b70ca5818235e7d22e66382391c6b24b75d6f2d969b66d1a8d3733d38d9a269acd721aebaf3564ae329145cbe05b164142de0898c4e30d12cd721dddde15903cb977e06ce120c0e70f3bf189741158c24134d5b95dbfd2e7b7cf9349bae4f02f15f023e966997e64b9de3db41bf9ccdd1bae5bcf066a7b8974f4631a6fa3a99c5ef31499998a6751457c8011fade27d0ec0f117ae357d02458aed39868f2f60d63dbdaa4dcebc5ece544b980357ec9835130cacc2b0cfe3989bdba54e6af6d37fe067fd1855becb41eb79e29b54623afb37f60e704423f5a05d4e42a95d7ed3657b416f9e7267e9662b2dd79d317b26ed412da5fa55f11917abfdcfb0fa09237c33d4415d722969e2cecfa1cbf97e4283b0042db0c904f12547e8829bcaceec9e6bed499ff5a9019287411ec6528e19c08cad353ed315653d49978435237139bb4b2b70b7e2c9e928045b61af0d4357616a3aa1580a461ff77efe702b20277c87d48735908daa5fdc3bee309d5ad351a02e6329b0fd820e0b76bcd8248b5407cc81b0288af3a02320d33e88db079c7b82be85d838bea2e7532061c0aebc20943bbd1770aa2468fb72abd615ff7659efb9f6228dc01c439fe3438e21f6bfdebedba3534619342d313bf04abbc731e2ed158fe17dd59311f22729396752431f85fddf8b78f0494010b332fe10d348e95583cbf2affc1727e01e3911f49f1febcec5996ee759b04f6ae5662cdf1ee6292f9d1c8f7f3848902a9b7d139b6a80f4e145c06209fef51215bad395a65bbd6023cd11231bdfb8efd998359f25e8f683e9232d7467c27f35691248ee180f44a301fc3eaf09c15265b8a1eff3cfc2018678d364c420d82321c4f526ce9d86dbf73bd2f7cf9f9f008bd541dcddcab3d364005ef520651aa80206ce1c43cd99568d668802dc8af32464048c4a79baed62495abbb5befbbc3d0315b48f46f93c8593bd47a48b480392925cae806238570bf643ba67ffbc4a543b5acc1c50a2e3af819e1aa9a3ad49fe00b896625b50954dacda787e9516f45d5443b3b4f2ffb22c8b0a6d4932622c2f7837a7986c04e67476246d0b508a2d5f28bff928f37c84781d291d0f0661025441bc7a28ccc7ca2dbd89fd13572e9e63efc5b13c8f36b87d86c41b1c297b6a4b0d6eb9b15f0283574854a9d1a62c5e32b4cd0a8abc7fd7f24cc99c7455d2f1ccd539fdc08492569aa936c19e264185dbda55fecefe6007fb57cbd72e895f0ab1524cc6eae548b08c96c3af91ce3e09f97c5d0c7315124b72be8058aa1b6d51d1ea997fa087680871e7f3d108ed8becbc40eb07582884968ff941df30f71c263bbd5993f1e32a9fd6c6a3dfa8c39fbc261988f3474cd9b0c6418dd1a2e4df8fae7c858faae03d07a71d12e48f618960fa0ec2ed912fe7e61310863a1129fe74a35c5e5a84a73f806a6e64c6bed66a3752cba82da87fb88d1b19725b670f15214f3ce57655ec4621cd212262fb9af886e61d510fd1200c55c79a3bcc855a931b6491635977f95ad3aebdb82fad48fd39642255303da1d6694b80f02b71063c4e8651e3cbd1eef81b489ff67c769ad6ee6cf9529c1469bb68bdb342617631a87bad3eb3623efc91b72d9890358cf0f5551a4368094d099620a7ef086b6680c105f087e700360408043d3d9e3b0e8160e01eaabe245bb3f7243f86bbc04bd3490470a5d66cfaff383bbbcd1d50e2bc2fbeddd7fbee10549f3031dffa423baa52ab64b39bf4adb26c7d31586b8bd360112d141bcd283b04055820e008bc222cc4017a5595220bb5e5abcf29cf65f820c816eee366cfcf81d40b4d0f49f0b65bdae70059e781aea7581360a4ef4fa1daa8ff9ff9f9a8bf2c6beb0803c93ee3a8a56da9e1f97224666de6154e57db51bf1c45e0f642e1bc925b67e29bb5d15cb78879c1e9f50f2d694188c04df97286f922acd92bfbb588eded33b29adf5e3be5babe31444b21e822e5a62d8da8a348e2ca3f717d68339a179a8bf45e3e78b9d6c703b31b2d22db03dc25c46a9bf4d3fcba7ff93acc003063904118fd6c6c7e0e0fb9f51f13550304a1d8a13af14fcd93addeac2cf13c1f7034a4ad6726b7136446dfb52e39e865ff1f0dc6d627fbce01ef90894ea56af1949a2f9f19d00168fcf23df54b1c2ad0f137e61225a31f4b65e3aa68c4376d23b00f10de8aeeb38142f1e9d52901ceb9213d862fc92de306be7d8f6a95fe94973e90742cbcac13c340f01bcf556e407b967b09952f7010b038c9ae12a6d2bb8c6450b1ef5157f661a5f456365eaf0b4acaad5050be7e4f4fbb6294ac399171ac2e36323409e200f5aed5de56e8524cad64849b423f49ee989bfb45d4fc9c3802b15c3d4dcd62783838be7e91bcab355cee23f3ea862b395ec6daf13b3c57d2edd19185ba5792a26c1caf9f3e4351a6b8dba56402f25f63a18558ed0874ac9b627fd88c3d0f50b6ef37fbae4cca9fcc57ff950b759385ff0d81620362d589f905c5e7d648ce1e5cf55acad4d43034db4a7274ec81d32208d88afb1209b95dd5feb9a9eb3254a2be7d9e98fa1f4373cd1944369f0bd01d784349b8fd19379f298885bd29d767262beeadb421d626043ca2d0c5c96305447356d342e64845479e98c9f4688e1d1942edc1c20952b451414c6e7d6a1ba6c5fe77e5d8be39ce5335319bd66ca9458cb7643b3a27537f0a6e4743aef2a18fb549fd68ca27cb2d440725d01e27d7c3b5a3ca07e6e9879ea2cdc1741e31bdf88d85e7a7ff9d6e5f9e0f6cd23aca20736f63143a6853aaf6cffa4a8f840c24cea74e54ac70f9e7f46b095359ccab6545b808f58db2dd28eb0e44d5fb0e0ec630c5a462f9aa3b0e9db95b1a612bf78080335b49dd8cb195db1ce00691dcbb89b08b738e0150ae679b1716d679e32f8356a468d3e9112d56c27e32cdd482c38bad00abc47c9751bb121cfda00e3184a99976a5a73f32ba4c9efa1f644e8af428c111e8b106c99af16de1a6749687effcf7389ded5e31f5760e1c73435df00a5d2f0ead0d3cc382de8381a738b80e2dc3fd1b33d6cd2823baabb250a465a44940282b2ae4e376e4ce4ba0cdda4b1f7a2b197672e92d80f8573a50bc90c70ce5ad1001962090692bf319e16e82cac928e1fc43ef0df27aafc5c1cd2caf017f3d5d200a16da86355201646fc430304f026e0a9fb6ebdcaa6edff6c4303c95cbe9f762283725b40831a8ff75576089a77996e04dcf8c0176ffb1291423e4bcaf91f6901ef66bda231caea5a67d7567fbad19c5344a5d9a9bd4541561ef6ecc62984e4415588e355cd2d445b6e5113f2c3d7f64dde2ecaca9608e8591e66f1b0a973ac419934d4b9dbbdc60de339d434ae6dc4df62f141b82bc3cc34fa36bb146a7a7029ac6c3b16377412f5cae94ab1dfcbda3d1635f74df9dbc1d8bfe2586a57d116dec43ea2a3fbb89d4f1f97369a0a796b6e59ce094cb9dc8b4f7130a0d2d54d7e1c76670925881444061e6484d80fa6ca04cc6cbe025cf8adb8c56deeed5a45372c7fd64c1e8860da7f64a4433a1d1a18444087eb623a5da0a03b536490ab44099ed4274b9bb1a33affef2d95b998703caaec8d282ca29e15d5dce56872eeb33341c64bc1fb33bd785489a414a33779480923be8bd77849d015c3676ec14033ade9d9b7a4d4607a612abf96a8eee4daf279983b5f859d003d507ca983386fedd409bd81203fe777b6980e3b6af7c2e73349162140ef442b0b42a146d3dbff42490a8f73318f873926a2370070643a3a10bed79207c9fa26892d3c1e2a0f1ab48ad368b1a5a662b173b753af9aedf60589d431b0ee5070de685d6266b17c1033b5b1f3434270dc736e15dac57f59ed85074cca8dab8aa0da1794bd2152ac62f3c871e8aa53dc86606d8425b1e71029b8fd5e78578135d049af30b33fb380dc20de7549474a00370dbe0937499de438aad80969758edc7db57bf364ca7f298858c15c4d1596d402cefb03f3a772bcbdc24bcff5473d6e30f97ebaf797695da28bbe5d6d179fb96b7675b3d8fdc80b8ef4b9cec673396820463a39e4416e13db887dbd85c89a12c3f20810694ce215de9e7de4cdde334c7ab93e7ed479c729ce8d598782c1e10c38fca60165383cdc12b8148b0e58325a97ce912cc24e561c93198944b342e432af443db6e7d6bf51e97e32bce25228174b941602e872d5b08b901a14a7affabc76337611537077f639c74a70297218748069d5f493a171c920b1b9d507f0a5b1501678892f3d7f9b31f492fc8f709e0984ff2631a4d8c2f14a9432d9d37919f20e836b87462012ae42a252e43ccc572ad000879df4632002d5e6a7d5693ecc80b4d53f6ca6b6b880170cfe2baee6ff6218acd5d9b6b5fddf36e06df0297d2738aea8b5dab3c77e1c99b622215b012cd6438ef549510c45a6f911b8c0e04171468c03e32b063998b2d7886536488fa1d3b5a9e5ad9003a871cb8d2f74a91a8390322ecd875fd6ac7d5debac958577e983cb7c773b5f16bd36cac71dc6bb3cc65cb14ce2c1cf103bb9c7b1ea3c8345fc2525632583e0747254379bba587f5db23c6fe8cd5c93cb022105f5b6e2ed121373f9440aec96868817aa503ee9ce1007f0fa56b4427525241f360a329286603c8158a4d6c72e5f8e75d3e7e830979bbdc527a84f2e18204d3bd52e69ef7366cfebcc3e0b898a8a87e2db296d2123d2bba523df2522a7dcbc41702acbc03a1011d704632d05ffebce59f7a57a160c761c864e7fdac36d86b3c610b3c4e54bcb95d40e7b80a2c2862a25c972cbf7ff23f6af1eaabbbbeb0b40b2d7cfd601b8c92d590f1bc1d2d41b3dc7fd88aab5f929fa4f8c142818055d102c14538b827bfce18981d2914cf322a4c1af9453dd4bccb2789cca436bd0374b5997fa2eb7100da74e2d6134b46b96911b1899f0316a289374b7f979fbab3eb2ee479633091d73657d0d2baf208789368bdaa587142f533ddf7e151563ff576c102a076574519184313f7ea31521e9c932a9750e1d6e4aafdda5decd11bdc65950c2b983ff1e7878935900e0fa29b4f18d9fe792b39a31aa357dc8b049efcdcdc4ca425d41a443ed211d85baf3b64f7711f3131d0317fda086335626f1d784b99c0379cb5ea2c896555ccdd51a4c5d4a244173db76a8ce6bd07eedd737119e6af9cd69ed3b050e811075551a9294be1a505ff041ff6dbb580e246a37a7881b9a2c529ae935c4d3e7afdba10dd5832879d1335c59fc8446f4da59a2842936325a45654fc9a0781b993636e878686ef43c0926fcc1538bcbe75940c104827d2d2e21f8606f5696ad61c391de87548c266709b080cdd823ecd7f0c8798c91c9b77dc215ede1b61991de1d3191fe6fa595da0ba08850746471df8f709c04861b4f83d131d4d5a712f7faf57113b0d3b8a40a170015c1f09da4d585949f1dc65b8bd57e0a73a1b40f06d034212c6a36f0f93bdb2b79d94b31a06a3c79b56d7a0724775275a02fd16e21b83e4e2c8123c63648e689efe2d10768b5beb382c6c087c5b77baa89fea637e7a9fdfa772750da149cdef201fb34f5ac40d02c8ab239ce756e81f94dc0f3872e0d4acda9e80927ade8198bd1e8e867fa9b15d3e6bceddfe796212ebeb38ccee76451590b3af3e3cc0cd26f087512bc067d3e30d499a500e3f88015d1911f889d0a8bc0e92cbc8e1344654ecdee69c81b48f8ea33faefd410eff8e5c79bfbcae4bd693b593fdab3af0be4d285da999ac1622ea35ba64f391e0d411d2c293b89d22826232cd25a51ea9a532b7a3d7c53526f999e344d5c2bea379149ebcd0b3fd4a1f450812193bb2709298736e9628360403d121b2dfff5d71fdd5ebe82418fc863a2b6672c034bbfd7c07fa9135af938d2adc7a0f54c3f6ea94c753580d74fd490d584d2dd11a055e1b7c73ce87ab390acc979c03242c2e4d7d11cece31fadd5279e30751f9bcd5bf4ae72f41e54ee15a3ef3b66fc3db030c3a0d75a4c4ffc11d1839ef83eaaf714507ae107fdf316ae76b782a6eff751e0aceca170c147d768f8b9882afa1c8b0146429c3a1c5d1c2cfdcbd86089c2328bd028b9ca9c594617cc795cd87a7a3a2142924cbd1d50d612182f1d83efa113bd1074633a2a80503ed9d971e29cb20430b38605d1761aa4a1308554a3ae1f25d1db6265890a5b5044272590d4605e03e0d9f110a7c35cfad8a73c00ec5467a10fb880aa6051730db99996cd19fc7ccc7714a6137c75989096a551aa3619ce3e752f1037984c024f61999b2e8c2f98f79bc9cec6b5f8548e66cece15b9bb7693bf0fdda601bade180fd24e40d4249174e2fcf42691ac6601e9224a7436ae5cee0ed7487630c7ae0b28b7d0e7fe94018a2f6e1691606758ab656819149c419d7f84d62bb0f2af539b057890e94a4cf8949210f593a74f2604643a6dabfb575cccb0ed0575fd4812bfa6bd618a50f8524b4d6277d06d3a0e4f08d5f4e2a9b8ffcb54ed4f369bf6a986f437e3441f0ceea217dff38711c3df9ecd2c2cf5c56023724516258e7ed2186ddb1c2bfb40df09de7c10c5e60e602e89d253ed4e998c952a07653068289739f1f1e1ce6df233e45c3b5b4b7a35d01dd3bfc31e5e09ddaa7ed79edaff982dbb2d0af5b2e5dea71ac406f487fbfb5a5680cb80020ddec39923584c3ba152481308b5276eff76979e22de599e986d7c6fd2acc54b7630088f543ea2fc167fdd6afb9b087d4721a4ab91ff3309786586d74e1c4bc7092e99fb4d3a4cc13ded9806bf7879e5c9e82a54906ba95243f052a8990b1a2231e4b6c3aebd5403326a2ecc000f9ed5cbf54a06ed1ced99a2f880c5d28b31240a14588f348ed7157df59feb133b5117b4541014525e985fcaff732f330b1ba463a2f9bd0df3da7ea9ca04a64a02b2db5d1f939b31e0456be9b547ab462770b4d7a309fc66316770ab9609ea4a917d0d98c1ed2de2723ba47cc430feccebd697da3206c4fe6ae640af795fd5e3513b50bce0f99b1dc2ce676638c7d4a98ddeb95373bf1e7827deef1f555d6246d0ea14211ded85cff8d571ae62464643b343765d68881901bc46cfa7284e0ad0ecfe4cb3dd211d27c961b7926d922316777ae546c15784e256988125cdd05534cd943c43c487b4a81c2cdcafed2ad8d657b48dbb04d42ac846d425eb23eb9933d644ea2dfd5a3bf9c6139bbdb8f32b8132e1507f51d90367a917cb23c5c5791df3b8eac16f80f70f74dc6eb160d61d76ac8acfb41ac02fd9efab31a0a478691a5b2407d77c0a36096a55c712135fb729878836cc7c73316f1ec2655c4720c7f9904ba86133df9d7afb737537ed7c3f4a60662239a67591bf0e8ee55d22243680ccef8899e9482df0f9834108db5052fb635127fc2d219a8c9c0b0c04a691bffd677621fe5107cc88c0a8517246eb2d5c3e3a3f09a4b5edf95766472b621a8192abb1b3393913fa48bb8534dfb518800042a8e7d7e5813e5a3f55ef9a2914231ef9ef2854a2180cb94e2d28ce66ac5abc9ff553fc703cf62d6f837170599aae5b890592909a75159f8ff621ee03fad36ff2152e41cad460510b05e446b9cf676437b8505e0eda5ab82fefa46e31f8ee62e419a2d134657feaff62f2a0093c24c85fc5a56f97c15e64014c0b796fd01621bb82d70181424831e2d29275de2d0704f1d792beff95f705555c71bc725de37e84ce416b451794b690763ce2cf23a117e2c5ae9710f0d75dc7f4f8db15aa455d2bec91e15493116f0e2d7669da16200b99f35c53e12fc63e0af5d1f1e1e4f9178221b98f0c1d32321751969a3081133c41b084d66de7d6e5eed8b554a340221b44e3b2bb0dc08b745e501070c2f92456006e9e0e2a6c90d5bc604a8a3a97f2301dc9991f0b4c19d5ea39ca15fa328f4ba439f317fb13a7b06671b0552e540167778b61550652aa1108efb4e941be7a26f0139c80c39ca37f1e1ab4b9292ba5e5192201b8d469214a139ed599089d9d617b14481eaefa584509a73d1e06aa1c4079b9199f483784b026a91c07c4d6ab86b942b0adbdc98ea5202deddf32afdf4f6640696205fd420f01199b7e76f1b98f27c18692b8c39b3841f562d863c76fe985d0ab206bd816f1c699723b70dff6743a1c77529cf756f44870972f1de91d64da63d9e56d6739a6beb2920eb5fd53cd5a99658ea83217047c52dd198d87fd4b34d7d9f2825f1064153e57c30095ad05f572e13611fa34f2e5e456023fbb335902bfb0ffce9a49cdbe0e53943931502cc6429fac4f3b56529e095af8604c598472101dc05e2c349c280990f2146fb55b4862e34486d7f53adb3fc3ce1a6f181e6c01108cf08db7e40a3dae70bc3366d75aa0d3c1ebfe17a379e94fd24c13bd9b99c9627237f20b0f2d6ba615c0dd096ced69263d2ba0b8422292adb9112416c77c152e44ef147d962786c4f24eb373d1250eb4beecbc2d98a5e513100f3d769f61c5e7cae16edf5b4089338a1c76174e6e1ab6df051c92b438e0b51fbd9fde677d384418c24a08663fde1d67e81cb729570c19492d210ebd80c50ffabbed45a7fc583184f4e81110c1b5a98e9ceb611ee33d76060be1cd1a81e77f4929a43213bc8c1fbf8ac219f4bada5217121e34fb43d08c59dc1175703817a5c13994dfc7c52d379f527113dab2d0cc7ba334acda12d04897ddba23f61433b58cdbd5a8e42a04c3138391a7c9c2b361504abbc53f63429c9a7b55209a8e2807dc80b7ce0cd8e245aaba6adf1858782497576bf4a98cb777410f6247e7ed831546e772cdd4db3303eee8a69b6df52fed643d6b540c5b8aece1d85f428b1105ad8542d2fd7166e11bb6347f8e85fe728e3a4343768525150ef1e0219d7a6f6effbd8f7f2006bfc3ac19039bd2737078ecb8f3a6b177d0dcc4212e0ea1de50ced2189cd51f2d2caa6d6ca4de6195d18e89c50ca69484bd88907bce4dad3a4403ba25fd29a28068a1e9536c982e6ecccec98eac9e7197cba1ed10c042992766b2c4dcd55948263c8002a16e530bd91ca1eb64ae7ec4c08c38408d8d10b3bf7b4ade093978ac5f911d5d86715cd4e0323ff214ac0e9c7324fca67da03477094c62c91705d8f1920d90373d4144f4f92afc1b88018491429144f7f10bec4186103318896a3c5899ea98ce6ed0faaf8c4a1378de70682e2338c4f335da3c2dff935ff62f9f1f3876668a3afbd89168603dbfb664b45c48277a9313a80e488b379663ab067209f65dba1b35ea3d3a5bb54dd0c3f8f0b936a44f0bfa15cc76e487eca587675939edcaa28671a8332605c2a67e8c6be2006b6f75a42468f6025953c01f0ac363c72893587f31b440b78b23d0ceddef00bf4a26ba92e5e5579de55a50d50c0c9e4a16b870520319fb04d0a7c5d3e1dfa8efb11f8fdfbefc2dbea8799c0a013b2931467e0452c3c3dac18350372a84defd43d0903ea7f57497fd8ef2e85b97702109ec4ccb9fdb1259d0c082ee307ee77fe9d35214c1dc38d4fee9304c137b757d0f7afcd71c01c7d05b9ddb08d8bb3f0f58562c6a1f7b98f87203ea73aec0fa3def9b89109769893a13411c6a9bd015eb5830286ae4f8f1fdb3d00063894b0c47a2f54bdb2c35943225e846a0ca2732e688dace39a28f1a4e822abf646f73ef685d25943a0ae229f641d1caaa35f58cd125e9ab3ec565f35ad3658cae1ee510501d0844d54dccff0801942fc7fdb3305aa27290bfb24acfaf44fe0f16191f75d27b7f6b4925acd074bc963b0fc633a32c4ca5cc1bfca80e9016964b2f2b530e5f05bb30afae89dd71d1d706ad90ad9444edf5a7f2811d7c7e233c6e9754b71a304852230853c55660c425eaf56952c94ee1cec60499b808334b72de38c88223f6634907f77bb1e0bd227a781a7f98880ff1c0025137a9fd84798853b37cf204768f9ad8475beb7fc1b84c80d4a39f2e54b0328ee6ee12c48e59cfdd5b93a3c4dad410c45cc79f02f0607c1661908a65ef7551c93e10f725e293c87e0bf32b9d041cea71829503086e55598522a1892553c30347f18bc904933cb5be8e70ad2f818495a124476f04bb92ad626c512d8e8e906ee2202a6fbbf9fef74fe2eaa321f767664f83e7d3e07dea708b50e3f509ccb686ef4533bfa360a8711eceb717a2a0da5e9ccba8f3b96db883f47329703dc6480f9ff9f9929690e2036774c20beb8e3ce72e6e5eb9d9d685a91ac1e95b14eaa9f79085c9af72c847628b78636081a3d546a98046b2e47fd4c965528504cf8a2c9fc377cff289bef21f578307fd41a1b59a36b36b54b508f86eb80229d7b2c1b013560834953855fcaeab36ead929e1d95d0e6791665685111b277c1c21851d31efaca2a3a643c34c51a0eefb1280acbd408e730c884df8fa610da57fcb270d414c49a03891ca788f0de70dd4e6d7e8b824a88a7e8bfa4049eaefb40750c9dd4cf32bbb3d98ca8370150ad47a8afe2e04cf39d5f48c5943c3b39508a9f9c21d55a8661b0959ed6b73cce30a10a2ebfa56649bb22ab5718e86be3e7adc80d866484261d98e58c8047c57dc958e59fe75cedf4cb1c19cb1231cbdffb6f97bd602e081c788ea867052334c47ab203a9f5dbb87f3c81628b207067e88a31ae40f9c22a97273bf2917abf3acd6157626b93da36dcb27c069425db58bb054a05dbbac0c868cc4e4a43a2436907aa4d9cf49530fcdd567544f82b07b1980b3ab10977c9158643afa20832b905a6914acecae7cc64bcaadb3c5c9257acc536c9b0fa77edaa8a86adbb4069b014227e90fb6443aff294f30dad7a8ab4570bf9600f0f63760f341ce7779ef74f51b420cb73b0bd6e1be5311000a0e7220e378836205feb3b9ae418b573ab330bd8dcaa9b758e2017db14aa1a24303d174b9ada15d73654ec6421af4a0e41a178b4dd12c74d521567b2e8fc40d31e4d9e4f8ab3df4b90c3f20d1650e5f410c802583f68387f461fb9ad0ed0b3c375c6b401dfbf0c46a264e530105cb02a1c5a6d3c4d384914256621b197065f82d253683e76c2c745525aa5d001633e7a3caa689a95020216a2508a8d7589e690e7f99b90b2d070e0ba819a6900f5b9379d72ad296bbd444adfeed95101a043befac589dff69e9b6ea904b505c702303d3eeb5a55656a13c6f6346ae278d8849763cc5b312cdddaf921bc1e7734ce95147230912ce0ba649574055e207980723c1177760f41a3ea10da62c6d1c86a6c5561f9819c7ac438b6d90b9dd188ad19da06244e73a6ed0ba9be972e572bce2356869e712e96c5dfe8196780098fd57f8bd713e263d129a37b6bb02a4ba6709f7332706299dbf9a4631e247a0958f700672da83695bad26b5fb45b7393a77d7e5b085d64f4b57e4f4c4388417014531a0d46f2686c5e1dd3f420143d97419409f87fe8c23bd3472bf6da2b4e15d7b2a323749135c440b54b9d6a623a8fa917e8d663718b28a7238c47a8e4ab1d1943b9c69de10cafe388ac1dffefb359ba0fff2555c8250fe9cffc55648071ae36fbd71eb9790e3d51a6ec7b8369a0f172991bac4616f996141e8c3c3b4f6420ef95eef958fa85fd9727cea04c31e6da73e74a75001357a2e827ea6b4f7e92bfe819657b192cc38c462f4a06e5e1303183d201459d8b27abe69347383342eef028f25cb5346e6700f4f4cf438da0048a0cfa75420e390e2ed7e9283571d1330f9b96ab43f174826db9e1a899b63ff9859c74cabd95e6047b46f79f03042fa46f93c451cf2f581815b3bc13b5863147c06610f25e4be8a36701449d93dec45ec6434771b7def1eafc82e7e8c6594a10c7c02369899be192ec9c964b7d63ce6391435003fb858ca0dbccaad9ae3d530eeaa3ed2842c5dbdbaced88a703ec9289480f60d1e4bde1a148ba929c6d746c91f82e86766f5cac1ac3912cc5854670eecf88be72e9b368491179db9848f63ff87a245f6fdcc8abc2f566bf75a030b5b1117183509daaf43d6ebbede209ec030c8f69547504c5bbf4a00f703f06e04bfdb2f32ef2a677a3129533eb9b8f364dea51884cdc4ce29d9f397432d91f7f34aa8f19d21418031c86cb1c4b066ee6b166ad30697bfd039ae44a3fa49cdba8cf090755c74ea6cd1cfbb2b386e1bfc33b0e72b2c703fbe074fa335f01a0aeedf89d2bf9fa41d2655a04fcb8d5de60c7aa36e285d13e0084b608ba89286aae52f1c996bfc39e2af2ad1d13f2fa40b6a187c335c31c96d5ce40b5b6b2af72d6d019c6f8424b797ead93eca0a820f9d934068b29a9dc86d0f3355ec99608e000d37d607c8286b30064f9a1e928c5d27416b884601be2e2b6fa2e3af635b535d6bd2d54bd64be7d14f85c573043b780d4120f2c381d2c01fc3ec2d88b508ce4fb6169415f30a82fb9df3a8144cf229dd2a7afc0b45b084030f059bd7cf00def15889a904a110efc51a3ccd04824adeef186934e55a2c37a65935a0e98e0c713c4701fca33990741d460171f94a0a184af17fca7f264ea543d7e9992b12eca2f9f47e52c593ac2763d4a4a3b46232e7c65f534bb4739197d505e2377d6ae2bcb5fb4d28d51ced9fe8f256db6cb93af80456d26ee64585d49a0b1529721779e01c34f02ca5e0f41567ccb5e06155a0e59e104b8691b22254fce4b36419f6314397724cd55f51fba6b4aaa239ab6e32a1470ee027f6098c0d8e7d547b0f59373585635a5b21102df1c8d4384b980205aa67e975490c4e0715aad4972b834e95a7077f5bfd58320ba1ba8acfb495f07f209031e01285cc40d496078685b448df6072ecd90c98fc4eebe360ff6d27a10e634d9d50527e5322cf44b844b42e769e47fe19a1314229f717ef0295f5ba5b9737589c37b3585bde8457066a1552bad283dc32de7ab5d45d11ebecc80fa1602df07d822dade391a338aef699bed6f4b328ececa378678ae0ecd505d31365ff23ef705e10804f6a4af9f22adac54de7cef7b29aa7907b3b705adb256528839105a9bdb22438d73d9273481a570964e39f2f8f179f3e0b59f659cf6c59ea5a4ea92458dbdc985f3db8aeedd99e1d417c2a420bfd81825c98a392c63ccc95f3591e4ee4abc650b82f07da8d025df9d381b8e78a2dcb49c26010113331fed3c1f1beff8d3ddbabbd6037d198bb804fb988aa665418de4a6207058994b89471ed6201454b8136a8995208b95be16d035e51bbc47b368e12df6a731c317674b907d3ea39c0805042387fc72c1abd7178aa51ce7ec2cde9b7af35a9c370d2bfd9d93961601178ecb555b6a975eefe5d140c4a10e4f26d325f1eea11e293edaa141664c5f03933b4816abe7539021022aeda8017dcd931fedff47799dc0c18fbdcceb0a4267bad0a8183b0fed3ce740e8c56c5784540010c6cb4d40d5ccaaf661e1877dc3df91c4f522f325116ca787275571023325d2e6c5625a3d62b8bad1ccd61fd7a44d18c013839990e8c4b0125cf8cf25182fc856ed7ffe165908fd7756a3a24cf0a02f2396522558b68d3df2a9eaad27182eca08a32951576fe5fd50b0a5d19595af8681617265ad08cf6e8a8bd37d3551fe7919feb4d5f2b3715c5a73e7a8701693271f1e68cd60797c0911c8139dbb0fd8909ae0f771bad7ec0fa7feb23e1d435f6e797a877468fec47a13ba4a88efd265f70ee2b39de605e9d4dda59653e2064414bd3d11b75fcaec6af0e5cd174661e6b3f009844b954c12deb42f2f1589446cab4d2a327403bd52f05ce00cd2fdeccc3d2b5ad70a44954a127ca453c7ddc22b6041b00b97b5638346dd841b6791489182a029c289592d1cd8946c7c2031294e14e36f3074fd897bc7507cdcd5472ba2eba44eb0ec9cdec4acf4be7f27d80b99f1318c3e88045a7cc765138690a585ab017f194269b8975b8ba45ffd49ae08d3605ecd814f180d13de1e617b33f7e5a2ddee1ede30bfa4d27642ae13348df3e1ea5193c7412c2c361954bdb306cbec4b74a1d2c1fea377d84f810438abd912d2e92498ce7855609a9132872a8f75d126edbef19a8cbe00d97da4644c4ff56bd817a682fc2a4ed3a0d9b83b11eb8cf6faa15cbdf3c74b97a1d807784caecc1fa2fada4843eff51f81ca39dcbd906b8e6f180905fce1ea7169ae97dd2b8849d782e1766260b2ccd29045dda48f4db14f64434501793a20af40b854c8bf79de3f54ad65cbdf60787aca992013440fc139fc9d04fee5b5d4ed274dd6edcd86019818e145d68c8c4648f65f513c761743698c3e30d50f46d475522ac5c49a24ab4bb28aeace3abfa14016ca147442b6a1fce0d32539b54b4ef054b560139177d7a0426bd96c0fc09dfbf794e142488e8b088a9b34cff5fe57b042b3f7cddc6f09740167ce15b9cb70f50d0582ac84b1739c22c4201a9a3b688bfb0d71451352c404a0ac36f03aa3f36ef29999c6be9b12d7c35aa3347ee5db412c67c7a5420213d28834b6c5386025de356e189f802ce10a16d7ea5ba9987277c3e687c4021901878e30a2b5ec30a8ee5a8bc672d647a1f2b195154adc7fd13bdde8523f616321f7dbc486b73079421222d4c1334eb2d4f5c314b960a0fbff2267ed5eeac2ef062b37eba1ed45595ea18689f75ff111417d23935da3213be9edfe71f48e1433cc7ce9b165c74346888b0fd9ab2733bb745750c600825d07dfc2cd2cf3f9e4228ec4de1ff9f35833f5975555f7e30c163b2d08b8917370c815f661754b5a425aed94cde7b72448c6f935e1b344ddc2f42a06668076600c3c2462c98683ef748090877abcae9fca348eddc1add3610b2b18ddbd7d06dd616b86506eac3508f1319e99688820a2c2b3d4ff806a372c9211a044a6df0f34062e1df278598c501a9d45988803059367d48b87526fd9191267a11be2d65041a0eeac67b7a0cc70b2dd379db9218705d6c69ae9a4a673317f2dbf511c80001c66755c5a4e81cbfb0ce3289b2c9d848bad3c8cc572b696f9fab6dfbba7ab4691b5333924b40270ad625651fafc6f1058a6910e16f885241f8d13aff8b4f8be6e51ebb388b8283bf9dd87f0449068f0b148f373f1ac85d66bda751b65b056fa9c0d931efd9a5ebde83ae2c6e38e241f36307c30daa706b70c54f2d920bae3ff09f409328171161b4a14c697ea87a64dea849a609fc9b0a6289931df226a4bc4632c818b0762008f2e38f7aef4916a5b1f94a440cd54f1d9c6044ce75d523db6a230842a6e706be7b89df756117b56e023b331b4add20d5505a209f2f4f04e3764182ef206e317043cd6c462c05922a7c6d5a8c1d86761769f002fc27f04a11a15056a2cb07f015da9136ea6fe90de2fa982791155fa2c6ec4a3545e5f74ec29ecf813037d236e794f1ee27b62990c29620f9f7248cb4cbe3d050492223f2fa0b4a26e09ee76db78e8d3253f482158fe6f4e6157386618bee5667a6cfa200eaf68e8a9b1b9c03c8bf809ddd30e565e47fb18c155da07ac1b6eec7ec03ee423fb9b3a25d2241958787cedb01b64681953695ea2a774dedc5376b72ea5028ee31db6faaf2aeb7ff817e839a881a19d76a4bea390abcec5233bf2ff7ef6b8d86621fd7d49d9b79618d774e1f67338805572d11cee63b160dc7ae0627ad3e8ae7e097077c9e22d02203ac00024e12e01af264cc978f5f7b1500b51e1eb1df2979f4871d268ad80b3cb54ba37a6c0ab9cebe07f3f542c30972bbfbb493ffde148d04841485a889c9c5f50e4c13f8993d37ff3060f32f4cac616b8a605dc5d57cb94e4483a8121df904eebdee774ba348cbe6337e5c5e1dc337bf09c85246d77ececee339bdc0d60549bf748a47054042c716e65dd6da96ef994b074c59120f2e5e0aadbf06a45c91bd4daed958c5b6a7c2d00f6a6daa55d2f4e19e6a217ac1673c35101b923a4bffeaf0c44997a5a9eac913d416b8e55cc4a9e9e71001c0ef8c34490d8ba216adb1e049c3ba3bfdc930287fb449d3cd922ec7d8896eecf84a100ae06620f41bc3085fcac5cb7c8f4f60c6c45271d70789f3cd9715955a7105b4e21c995ea422168f842f0351364b638688fd98859601d773d4dc91ad800fcfd8886e25d6f0006674d04341be9d1bbab68b4aba75889d585aae655bdedcc515922e1cc6018553c88f492d33344f1a1b03b736051d36d528f528baa1c67285ea6d927f99b7f307564c5bb40d9ef4689f25126d4a5cbe56b0f0731b6d3dd6b370d3d5b4dce8eaeca2a4bc081457cbd97b324bf94a9497f9a9a85873853c52633392784a1b2622c38891350ae91ba067629a84c65a827c27ccefc44434818da6efdaa77410a6b0f1e25c2c877044a78d1e9fc35bb67189b55d20ed7bf52dc0b45091fba6f77915bc0a3ea7a9cb01016db66322c432951cd896773d4e80bf679dcac3b9fde277144c742f3af7263b93ec87b2c9e597d810d248a9b2dcd5c07c89bad7cd1374fe99cbf0082b365e390175209fe0992e5025453a1f8c4d2245201ad2a39bf9771946798553631707e5c6635a24adf34476a07e93fc9c92f30d9ac809123080f7eeed1267bb1cda6e80301b24781c6b92de5dbdb748dea6e7e39ff47a223ea23b93393a1452f00ad6a285c1036020950dd0ca7c4ab8436f0d8f5ea7b84bcd84c7742ff268c31d83e60030b17c181865c3519f3621dd74f69b92e6d56eb70de76a7091d33210089a706263493403a1cf3629dcf17d04c626080007a564ad723822d4eb72f5bff4a499bf417d70cbfa2606338396928b42cb0fb0159c01950fcc50cd1ade02c1f6119caf6c6378b82afa156e37482095a4d0a3d9d171b2b9024876220c4f2cde4d6236c570f8c4a6117e9a1c7e6b08535ec71c03cf4b10d717386309dca77f3d0d902962d7ab42fc4c71fe2c63fe61ea9cfbce2864a1183b91970f77f45629824676af668ea10b22bec5eae1e583a97fbe217a821968f03d0b16c21e6a40b5646659f847b100528367e732ad2b06551ea3782d2b896c35289cc923c32b8ae4c4a26fb7e1a6f7b23734e6269c3604641f7965148407d0624855c6e054946eb9b5ebf6cb9b01e61de954ce29fa6255f6c54c4aacaac4ff8ceca5d8141759b476b1e97f33b5cd627b7d855dc26396c56fa8eb90afc9c5dfd13985bc069fc6caa820d0b2631910242bda318ef4d666675d55b36c0b6acb5bbf093021325aea9e072be12ae24bcdaab4dc8aceffd43b12bdb273571b36c089d84d7c1d792f8ad184e6555ca917d7861bfe357622b11a0899c4d02927f384b53057f995d654bd968f0d83ccbc158ece21fbb950219a0fcc6ae12eff1c364ba50c3b49969ccd3b146d8442f96faef2cb6ffa1e43d6ad6f0bc8bcedb2ddb7f8f4b3e6841b32fdb9a108f0d3f25fd2787e44e3e06b8052dd86802dd1e39b89eddbe4923e069b952a186a1a94e06d4cce67b493b5dc8c759eb6d373ea0dd1cf08a6a41af5aabb055094b2871dcdaf191e80b74bdd0f7048d139235065c3520104cd14d7c360ea4ac1667e0a568d79f872729a8a92685dcecb5400efedf3005d6dabbb8fc9b1a649b01c7d335ae47bc5fa1ef301116e55a38f3058a18c31261965fb2516614cccd8328bc91fab407c91b5e79f7546b3b6cbcaa13699c87f291132985e28b231565275678f7761a094afec069bfd177e59e048bc13326d33d85965cc9b3c08258bf9163948855ccd273d909637327afefb5f19d099be36931cee93c5321f8adf0bdf5938d5729d6fc29159792816dc49d0b20090969aae4630c3104bf3e93a8a89807c8427e33d2b54d066a2148e6d1e5c3c72e8201cdab3aa2d611ec8b8e5b41b89d0d78262f033f5c7148c3910316f2ce80f65c72ce5a71bb095b7eb901b3ef60a21f5622661b6e5d52972c22ce98a2bb94c82014585399a386a15b7d23addc2ca021e914903b2d2244b49652029d095ac8b17cba12f0946ca3f12f7743e1a4567341a12a3ec2f9d220243dbe7318ec2dc738c374457a1be5da4de8246ca1d8d3e9f0d261d51a64ceb566e3fe898f47b19aa96ade5bbf3adf4f3b3ae79ebd7b3f5c18356359d994d7a4a04d79e897c866d7fe8cffb5e5cfc602181b16dc1b889489fa64ea8916c194cc95c33993f651bc691b67bd63ea0e88b3c0482569cc69b83f8161be142eba5dd29f94e022c67abd2cbbdddaad03ffc5a911bfd806fe81d59a510f3adeb6615aa765909ed9510c96b45bf4888efefe60dd3a4389093aa485e555b864a2cb2af1221a8c41ab5a87e4f66157877b8f3b4d39b5dc78859c9acc6362859a7080a0850cf1e2508a4b9ddcbaecd2d4237938b9f2e354370151a0e2923909c5c3afe1862e4bee398c7ab539fb16d9ef025e4e842e12ba166078e6cea77bb72339201dce4cd3928cb6f46901a4e802a7eb0b28056f8ae3aff6c011d256fc67a427621a4d1867b347877a081656d78679ec12452084fae476fb65bba02d91d5cb99aab30c7a30b9358a4315991a84c4872f837aaef733995fc5ffee6d0aaa222e6c5f547bcfc413598dd7c51d3056bf13b8bf6e33309e22928a8aadc579ec517792fe800bf278b16846cc85ab5bae9b911f6e1de4c35c602f914d6c37059acb03c5884c22245a885c7b7e739067b12348b4ad56fdb5417c2504d993d0bcc0dc08199ee1553d65120a00eee003ba1346819bea3d6a98206114de24fe668514334d4509fdfbafa6cbd01abcd4982de3964ad9d3c9bacbfc3d429cf77fb3f5d66671958c720842e7b55622ec8a809507c8c55f35476a57da04a0ab1f5b3ccc626cc8cd61a63b936ad554666eef9c9715360988b9d57514aeedddc1b6c90f48c721c0810412a1ca0db373b5ad2763c61a609096dfe8422407f38f949a774eee5ec5d99e8cc35d05c6de371250098e243d663c2dc7c7d5ed905562a082048686747d322e15dcce601766fe681b9ea07c6390e4ccca0d581b7a165ef29e87db57d8d19b8e6912f8b99e60095977a538369fc776c8452bef51227e3d25780706f1be2c44a9792e427c31669c6255123193bb19a84b4ce3e29d2d97d004dd0019056260efe2e38f89196814290c618b947e293835578ece13cd41b0718906e41e27a31fbfcb39a57c05a18c8bd039ea5f577afcb2d418d7c1313fde891dbf98836e5f838bcf82774a4eabf356e820be1461bfdcee232abea287bb76255f46f34e4e3a87cb68e61ea12c51f23140f5c91bc46e79dfc3d99748f5e29598cfde422f29658b0d985548fc24ec36432e9083f747e21425f9e448d863a89833236fc7536c50d4ffa181b6439405efadb8959546311f131a948c0e10a75ba407236535173b420909566cbeb9c1c7551e7f936096ed5980733812f89d2f511fbb5214367af585b7705f64c939d0ac1f6699d9740577938971c80d6bc64144346ecc1ee56d2347ce17634ed6c6286a0a29fdd019b699c101a0d5859c5aea8154af041354ee8e3123c1ebb1f669389058993cb3c910852ede26397019ff2bb8b07f684d08ed969fece9661fce609bb74e44b06fb3d6521fb9aa350241c21e7ac0670759780b05774732b42a189c0f5eb4ee5d3a3a046e5c51bdc401c702fc26bf9bbb7e9125f0d3b3550964228ec8c659812eb9748303ea08def11b33a650e72c3082ee35ac754894b32c6f4d49fe4a8d054504acaee619640a651e609fcfe04a5ef5f2b7cf53c7b36748978feed188a5b188b6e1a2932390de7ed4ffc47e96a0d81aeb607aae46bcf2d703f26be1c77b05b41b4562399ad845a83213f837a87b2ff85aee1a89c7bf727201138b24bcecf67a21bec6f56b30bbb76c749ab8c967459f3f103fbfb5b06b73a7a34fed88582e9a116844ad90ae198e8e4c55b9d6bad3a4f7ebfd8583e71fc481eaa525872453e142107c28320cfd4c309c2fc85e09ff327d9832c0faa17847cc3f6124db3b688adfbb9d61e227b2c8e9b8f4dee0b1fb2963a386affd7d7eaa3b918ab357893870971d9b2b6882b7173bc7eaef334fc200038d4ccc57ff619b45e1fe21857fd3f594232a9dc5c4cd61ba44d9e24648d4578d4c2acece1014a958c55d7ae49219b1536a97e95e35985079805fbc774210703bc6932fdb7c6e4d7ae74739b0bc582a08c568919345cdc3be1d9be93ea996f7b35915b64e72ece34f84ed1c6dfaf84220bacf14af06f7aa63941eead02bbeded1566ec9b608f38eadeeece796cc38150406ec91d1adc3265cb037d2a53c182760817ba377b5a94d640a813196b7f95ea715def85315e6533811865f8b9385de0993f1a274d562c42ed3ff9cf5c69cc9ab8aa9bf363b8661b2abe19903ab5ab8b1b8e74a992994794ad5a8127e05efa0ccbde73f5dc341d5b144913a374394f6a01232b9bd545f8981b2c3d37a0526cb0c384a28b372bc1e86f9d053b0df1b9581348c9d305faa1127a10e84e75cec13a83aedabdcb1c0dc7cb9a8f266441ce9e3a793fba735c8d8ceea7c82b3217e1c19347a59bd11f07562c812b566006626246892417928b1f0566b452b9774d5829d4e1ac4f4c103e7ed3e728e79dfe37ce068197ec06acb58301641dd30f4e61182e338686b1a9de892865934d1771fc0d40b6bbe8d9543e0b17199dc4047ee0c290016762d14a6ceb7dfa0ed9d9ed5cadcaab5df4624f5caa614c76ce496cae72ce9286c1cce41c3d6deccbddeee9a1013111e5d2bf7e2fa382fe0bba10e6bfe399552ab730a4d3fa4eac4267c48900f7d019ae44ed33fa0cc013779ef604b1d3a2de06eb7ae6ee2eebfd9faeb4d27947baf9abc6ee006b261624831a44100ed34915dd26844b80c8fec1bf931e7f60041438744bd2924b1953afac862ebd392d8d237cfc47ad6db6655022e0ebe9f0ce45a071a1e202d786e072ab2aa9a7218f6b92f5ce7a3d16d25b160528fc4c0a741851dad5417a919ad5b8bb3ab10a76c5d3f9c18e7355e8b3a0daea20caafbfcc4c8114d56c7e90e865cd65d5e12270f6d137d2de149bd1b2a479be8bf6809bd581b2cf847cd733942434688abe96fb959175d4e781f2d043993f9b0d5b9de2839ed3e78af28f7787add676e9ee2b296aae30404fd97e9543ffaf0e7ce9ce08b1a9c019606bdd7d7550d3849b6ced1dca641fdaa50b8bce545d686557cd528181cfd3a6d2ed345907048927d6d836bd879afe1cf972c1fc4775874b4b169da564bdbbb2b3897e66bd817efb9f559f8bda2e082d3fbc2e814da024d5d0b26869e107029c597990c40d999729df9adf6d1dd3bd9000fec904b2f2df5bfc6189f41b9ed97651c4e80882afe4ac2ed6127ba145bc77ee13effd864856825bb15ff6678f8f4acf98cd8626d0d5f451c5ada090c8dacc778f5ebb3ec87d073f5337bbea32942fdc310636cd09f4c251f014b5b7455c790266ed05c6e0aebee564c8883a58c9f6581fb9c441d21b712efc30c88bde9674b2faa673f4db3c02edc81ef7f192226f4d7513bb66916e68b059187d28ab4f2a94bd1be939c7fabc6deb49200cf5f9278f179c3c82493b35d52618412efd5b2d2d3abd5203b3dad56b90c41eef5adbe01e4c0b33c3ec2cae3edabc936a89d7c2ace28cf82fb111601b3759b7c91e8ed9f4dd63b34b55f36a282ecc7ad691520e1aedab1d6eff37a7efc1d092167e1e535594e850af13e3f1262265687e575aba95076b8ed292efc49d6f9bbc304dbd96291238c9be5c39abc195e7e61acae7d489257326a83e1db9fac3ec55c251125cfbd2e877e2a68e9fa261d5a722ce228e10ffbf3674b81644813e8396faf2ed56586b1e0f4da3b85fa18f0fe4010e6242ea284579209551f6910366714c5d30445bfcfbe8f4a5da0da09e87adffdc7510ca937cdc9e0f95ad6122b1789e114066f0f111cce5884b3ffd81be1b73f424a04aa00fcba7ddc019f450fe56eccfb5c861be26f3574793cf6f921663e304a86bb76ed7109e8c2c0ccafeda1333f048a1e7d14e7a62b9bcc7efc978c1a5a854d77e2afe4effe427d92b413c95075a0a46b965a2cf3825b679d2ba061991ed0791b091c0278e4481c631594045584b2c55ac1cbc0ee1dbe30c6c25fc97a5cb7094f4dafd0ab1c9598aa8cc9c1e94414425d7066e488bbde6b81417edb6b01fe82b07e06a062b03a692375cbd546ca13b57096880ea76869c92057aa4fc0a81b25440c63898b35213802b7fb31c6e1efda2d1377f6c648200660b914fa3c6ab8eb85c22c80173984e871617ba889d85d3be8eedb2ba9d05ad90afaf15705c43661c9576cf2e42874ed19ecb3c064d105a428ea3f3f86d57e330219fb2bfe1a2541d1f44ff94e8653f0a819cc9b7c4903730c43957a90e18ccc3a21ef2a37a5cdeac8faaa1942dc5ac79dd938e94f066ab1539aaf29c4d495028f980db82db2a9a309837094f8ad14bcc85428eb188cbcfd2791c77248f73e087eeb9bb1fa2ce7a955783e47c055e1213f85148bbb677346e60ff8bee24842633247624dbde4e91673b4d01c6c95743cbb57377eb10b7c547525c2b23e07edba69852f05d59fc6915040890d536c5576a259117aa6bbb725f3158ab60c1ba1f617e75393bc3ec9d11db0f0affea060e72b64e378b6067817c37e170f395a55acdf5b24ff973bf1f001982d59eb4e452b618a360e809c09e1466d1686bd5311dfb9fd7ab9c7a3708e594190cdfbb20688f3cc55cb7cdd265ecce498a2cfa7730d673933c912412dc1a61b0b8182637b641fbcceb351637f297a978f716dc52d9083d5af073a0842da9cdfb367021bd10e183df4c109e23907458554de8a44844859ab546d060b7ef7f1fd4356093f07d3b51d607b6c2f6d1f38cb249b61fad39ec86d0b6e241ce365e0be98f2c556706160fe6c95e2f1a8089a2c9e99a55306d1e24bc1655e0b29d4816a36343bb733856f5fb7a99a746aa2b8c64613a0761f910f96e71408e13a556eedc17433c5ce2a7c4ca4fadf62a7bf65ef0622732db5f3d7cdf32cadc7b43249b08510554f8fb65b35da47d5b849a16e75a8e8079f70aeb0b1ddec54636a8f25c4ef96faac1aabbf01c5b2050cab4098595d4b696b8ea65de7a3cdec2de3d9ec18128bb080e69fb35113b37d6a1f6aea9d39388dd661cfc8e0c53eac10d90e312e24b47a37bf87732a391b5e736aa753f8b47fce4acf586678c97283dabccb1492fefd42a045475404ec2c1bf843faef0c2a3d99a2d12d808bb83be7632d31338d9ee913416c9bb84ba8bdd969d7667c535ccf0b57f4c2028a9ff78b288395b18da88d0062fb4f4cec2d6b9c92484ec1f2ee608ee7db34a58c108de1df4907e53ee126dc1f0dc6ff6afcdf329e2999fdabe700a38cbab686039e776225be9f35beb338233b92ca7d68de271d4304b29c67334b708edd509b7864e4079253a52909ad3db8c1cfbc15235e14d5efd44fc11324a1c8651fef81327fde74c0317ec29300e85524da0454b44ab12f3d8b106f4cedf1af2474bf9dbd8f8baa95b17295f102f2d8c21fdac25335c9c88a8de35cb42613a2815fe08c823a7857d0e13f4a9faf7ec37cde598dddf879aa963344bafc4ba91b477c5f569aa9f41351067a6945230a9c5daaedfe382dd9a2154a4471593da027d7f887e9010a811dc614bfa44021ea090feb011900b3a8f9cd9166af86bf33f3e81381c8270c4a636538b902d78f5ed1545d0cb9f62d1b787a3e49bf93fa87aaa4a53cf88f66b5f5274ff19844f83111798fe2087582a8f4c77a207d5ef9d11fc897b58ff350fe2a8a6c71bdb509ea6339656033e65ef2d413e000f0092e10ff8c657e80d207e20a2c5637da571488c677975e97e1b0b8372e02fad1c1eb52909fa39f72e74e5cd3cd07774ce590d966ac30f9f2312adeb846e40011ccea944a9375c6cd4ee873a80c2eadf9739658bbd70f264153c57c01577faa9240c623b9e815c3497b1f17c1f3ae8184d9669c867e699b438d3a0a96d240b6c4be7f9875e65057a0434008a3ee1d7a4babe059a80b4506f3d5898c941f8668c41ffa5f383d09553a6e1dda3fe9467c9bbb0cf4ddcdfe904f1476de546027b526737fd341adb50cf22089fc0473a720c0f8929cd4a9c5b94b3107041d62eb39ab8b39e19da9de0b4584dfd8308af4d4dbbd42042f831d79cba1088f5b1910096400ba440444a12b8fba7cfefe4c92ceb1f88e9b60515db8f1b987131af0c5431cce744f57822fef2805415f7d2e1dcdcb020b6380cf3218362758ac994faf8407b44141039d4f328392129c1c75e2aca5aff44b75b81a07fd63918f4b3a661a04fedb30c08bdb279af959614db965c9c8dca7281e8be927acd40fb3977ff911faad658478b43ea859d883d3bcd2dd2f01c4252d57e448087583f080230f661121dde0f95586fdcfcc63820b0223b3a1166b96fffe963127501d179c8a35230237bdb73f37492bee32fa49a3ce740767b3cfc3585dcc754be2e7acb4bb18988bf1d8341d1070f2c253f05352f4b62bf162d99b348da1362a46e5996c6b9ea25d3412082bf64a110eade41d9ad1b2254dd2aeae92cce86d5df43f0e4c4f03124bd663c71bdc0b596d53dca882f77d3166bcc6b5c6d3ef65aa4366fdc512ce2c34ff9b69943daf2f8ba04ef8661acf3d182cf00859966e3e983bf29e4c387529c1681bcb943d800e9d080e97d19f8e6c12fe9826770f0c6b56b397ed755803b5ec0b252c70f99d0232b1ad12695bf39489cccc31f4fb3834f3f6d727307141715e0571b055121e2d51a39c7bec4c3cc0baaec16fd9a37a35e26c27510637737295ba84e068af2645e8b2b0e53f71a0ae3d764bca8615a2ddd2f586b1749a7dc0e289c9286a7aa0148a7544ec88f85d51275439516374d6f0d60050534df363d8338f7a58ef58eff77ce25c2a5b73ea50fc0f75b51d3dcb06d98d17852c84642bad4749242ce47660197684c3f4c82586733ab6cd7ca1f5096398195bfd47a19d141e08a44ae18d5578f22ada8a081a800806bf12c05d16bbb4a4932c8e3b2e060c2ac1d5533ceaee71176219a66742025eaf632390a9f72e2a69d212359592b41bac5e15a8477ddaebebc02e8fff8b82709f10437f26d14af2cd7b6e849c46e78c1072ab07422edb77721048cb1b43ab98b11ed619ee5d4a15bdcb630f147c541483b53d2b65df4542e3259ea82be8dc5d4708e88621533fcb7c0f563e678ba34c5d9b57ecfeaf8350c5f7e8daa877a718147da6b89c8f8b228ea874330eb4f100fa9debfd567c920f818ce42785085265ca65e22caf0f68f649452cbfd97a4f47b709cc346332843246dad223f1c459661524933dfc695f35b6cab16419d5416b31aa31608cb0ffe05e11f9fd8d29ead687be5301e55cd1774da0796ecd7b3fa8001b39b2058abc354a13205d5c2767ed6a33dfbb1dbe72e6b2abc012573637b4837b61b8783a080d380a154cfa3ce80d97e09bde50f0c8708c4f06a858a8091a81ec0fe407094623c02d2a3602dcb64cc0c90b99f1dcb053fd2d8de9b7320a64a98d0ba3e9186a83eec2b3f39c77d1c0e0895bf99f52daef7a44dc4bf4c3821644a800081eec7f45ff4e89e698696ba6aae7d89cc09248f0f5333e6143082e7a9153000301eb239d63c58a2698736b512c5875f029cbd3c0912d444e2546be36ab26fd29bb590638ea3216be2702ecef0f3647010933a65464093f4e635858bded7a5111d3826fec240994f6d17fbb1c211709dd5f84c13cf881c747aaa213833459373461c4b6b765b6ebb47df6dc4102759982bf95770e8b6c377133927d0b736b4f6da89bcb0ceda709e6acf505cb3bd179621feaf019420b2e052d3816c374331eff14c1ae72232d60fb6b3421280f984f6ff426a870cf430f07d5cfd3a9cd568c2ce4e4f572f8f3647704aece9fb74865bee982ee3b419a8217788e9bcd45076461f6a249d8c0ff0e8ac408dff102d52ab8dc696663f54cf158c6efcd94496ed7ea8dd2e83c2e0d5cbd6deedcc96bbdafd8fec48883ebd30c6430cdb9d82889f93ffc6c25e9394fceb11c9e7d01202a2a003f901e34ef52454c3ef322d02e1343da7fe4e4011d52ebeabb6733b39c2476535ca8ca9e544355b41294c3c9dcf10f9ed4ea1f07b09abaab53f19f1cca2092ac44077e6541b7b5f28beac6b6d1161fd3385563a2cb4949e3c81e1951c1371e9ba0f601d9bb1d2646b59d4e8528f217ade80153c584a42a29dd342abca5d1e1f4ae1a717ffa5b2a1a7af8ef4a575ffe63526124185ee3f1c9815812743cff45f6d199bceaad65885bcdd5303fd96dc1dc848b20b8c813b7e3cfdb435c2b6fd9f26f0f25df3e3bcbdcb63510862d86b0e19a9823468e289a9237e2e3170abece95096bc5c93a5ac4caf8cb7ecaf432ffea24492145fe8e3b2db8c54eccaedb7bb2a7560887683904313f7de0a837454777d3e99ec8f8bf3e91334f93b36063daa402422c793f5f638e0bac8de91f2202f4e3c33473304dcd7f2e44f27eda0f084205bac5eebafe7c79ce6a538baec71236125a11c53ddc160a9004648946e7c8588d463cd9c3cb2e55e124f29d387d3a82102876ba5d5ac80d32f313da9e5601c28ba24bd3aae51c1552149eecb433a325c89839baf5749ac1542cddf61a373c01e6c482776c4b2e12b3e681782451599ee46d44d4360cc551479dd58695a32775bbdac606ba4a0eef604736c39f01cc536be113507ae6848cd7e8c2c413971418f005cd5e00c0ac8cf0a150e9d22f50df61603a8b31649b9e5aa49fc1d8887ad01e6da340e7cabb0eb753d18cf2f59de4c4dbdd278355cedf60611977ae9d735155ec27e702d031f09dafb38f73af4f7a5153378bef5b65af66a814aa4e913d8b3b808eedb13dcb27b5ab639e0fd36722e36b13ac9673ae601481279d152eb9ab8857e085618f875c35cc408ae063c85268995631f9587b37df641b936804efaee75076ffb177272ae4e321749c17bb8dafa273e04e81a0741d816f217a16887fad8d829d35efb5750c8eccc63c476b0a8f0bf55bcc447672dffdd752565853a702ac87bdc322f9d17cda80019a5e6aed2840f93172ab5bd11f97b9996037c08f622ddd4d9ae105f43d806c52c6c62b114e32b13a3f0630b41c36ae92add7685292882f94c738aa37f30f35013136855e4178e246e01fd90cec600797e25883197168fc43965e0034170b74a9dce836b55de2661e3759c1f89c46461f853f701044a319e5f5ede25f8679364532825e6460ebacce5277532d78e6a0f5e31231e45f882d8a19b76fc609937a073b4100335a5d3349b341827431518238045becd3513c33d7c6178bcbd356b6064bbf84f888031252f25042391c4b092d3c6d6b51eafdfc570fe35c00217753b766a838c59b4773be2b970c24b5a688e165e19d31cb58aa266e5dcd076fd32c36edbbca9a23271303bf3c5ec7128706a0d31c136d5b7c36e283b70e8bfbd7136351ebcfb43204c4124465395c0f5abd30701b83704228ecf4eabe113e7d7d4dcbeb9b40616c72ec8ccd51a18e3dc29decb48249fdcce1ea2ade310ff4485010642fe8f8680748043cd21e215afad8c69f5f15e199dd6fa498ab3f02c454da0c15cb3b370885e819e4570d44f62d29123c12d26e924aed63d12d45283dcb07df1282cd22771ef54d6139e01dd38d83885b46623789cb1bc16dc5c186ab20a29f09c54840022b4d5716a257c0a57155ea923e022497d8032ee28cd6636cdcc955175670feb2008fffaa183ec6848d7b2894dfb545fc1c586fa5c05ec852886b7c9681a22d881118a31ab3cbce1423a2eb209b714b605f8519a795d5071c780886b8b5ee7f3e47d9b6124e5df6c47b240bcdd6d90da301d21a16f8ca31f45ad057f082db0da9df323ba1e19e661bbe051991785e053d7a723177ec9d9e0ac9f4c82c4f13d4994b714e334d51c511700dd62c83c3d12f6902710b8d9069363f5425e345ed335ad2729be334c5c281384aba59ec9ab2862a64c286dd0ef2aa3a16b0e94e2f6eb3fb73e518cafd8ca1b13d6ecd16cf106708a36016ef2e5abc66961c2216752e8702ff8174992f5a905ebc520c9a20f4b06e165ab70e060ab40e0912f46d5ffff7d180d810b8f8e5f2151df80b42658c2fc2ae14ddf76b2cb54597af97960ed1214f14e90fea40e99f73aba7a57069aa59bd06c567452a30b1764d043034717862f1aac4799c29a85c2371d9d84a9046a2748efaea9a63496c4e1b95b5fda02c32ebd7106bccd666a91652bddd5bb2f85864e711444033ee913150dbb06edd0a8c652985933523ee9df727b60798457e1a2a53bf80292359d9b073c2c405b490e68f29730462830bd66a01d977e98c3cd1cbe88b15a51b0b3aad152b09da8c25bc86d73a4f7574106ef2e9739fb068b745ae1e50642add46301e366b3591218fa352a6d0f3ccd4510f84a78192e264193f9d19bf9202ea9211ac30cb9a005c7af881d63e1fd06da80c24ab372aafccb133871bdbb0c502387190ac06ef02b9f8131f4d23ba88c7f18e170a7af7d8de7089ce5e7b2fe6fdca946eedcde64c93fc1405e12fc7df178ed17fb5650529b96c6652a5cba6c4cf99f8150646a04aa9de38d575a91197c0e36e704ec86ba834601191c4cbec050e3de460da89dd4fc8dac30e22ea2b5a58dbbcd2e4a4b189b72ae28582ce7b2516120fa191220fa5c690790b0ce0bd80ac6139a8a7b0ffebf44cc22429fd287e44b5544c17922e3bdd86a5e29f8c235c82e8067e0dd722e2ad6d3d9550d22a43568a79db8bce681001a1b3743e845b2a20e4782344b85e67cad5218f829d6f232639ff0c14be988f13b058218c724508cf4fb0f5c625102c8cf4b07a83034491702d09fe48bf9174a0e14aea1393307d98254852d3a41f6430db5f36407949e8311451cba7223aff664a8a040a38ba797be8110313f1430111c127a499cdbceb7d622bacc3ab757f1b61391a9748fce3351ce2b43c7a1403397f6660899e0c5765cd9bb9a912e083a58405bf3bbc0b0b89cc6ccb9ae2ebc66a154f4465dfbf7a9bd279d3d98557359e731fd98922c79b90033224617e9a81ca23ea955958ac1f132fa555742457a9f9d1c300a81cf5f05c547a9a7adbe84cba70a6078c257d2ab7674a8fc084213595a65318d1deb2d88253635eff36ea72f86779e9bb3589b9b841372efc2dbb0bdcdffc9e48b23229bc1afc70d5021fe1bb958f2d9eccf9b6a9493f10781cb5b0d2cdf27f0a77cabe05c571d7146667ed5d2d8d22a6014119c04eb02c6342c709a1a23660d31e52bde0f64b57a9bcc5d61b845e056641e04b2be2d68748023b1922f7efacfc2cd22e7e52b9cd5314f1ab9d9598cc34ca7e7a5ade926231b725ab174955ec0d3c8259a501ec739dafb7813b7d69cf503150b86fdbfb17912c737f5f772413d37a1767163286a2878431236d00192a49ddca3de1b9155b9c22c0baee46abe03d286337049516e6c2bec2a56b0319021289ae36771c95c671ce04a867dd5f83561d417801dfa476003bee8acf0fa60bcac65ada69eab3f085570f15d54909080640d65c66494e64810ff859e1d5f7f2e17675c860ce1575195cced375fa775593121f8ec512f20a5fff57db65a5018b0852e1e379b8bca61b6d6b2a8a44ceb64122ce2e80f8ed9e2807fc5feaf5c2e3f86604264b5b0ddcc08d353cc4e058369e967a0ceac3eae459d45abef8e027aa09905e2408aee3863fb75bb55368f74aafa81e58b8bbb866df4b56ef25a4797327047042916cb78a9b56774384de149a6827e67fa62c3cb75400ee74a1235fd6b5caefc93794d08223cbe6a48d2530d07af24c0456e96997e9c0c1f4c6636d73ad3e52636fe98bea47eaf7588387f4d1d5818d626fc6530ee30864b0360e484f2f909fa87a72af59c07de23a492de2c7f95c5f6ef31d45c67d8b7cc524f35120b0429acc5dfbce4687c0929111aa86c681a105b57d4aef408fafba5fe283ed71d0ad35900793c00111e3435e307145152982adc3f12fa6b4a31098461f544dbff07c5c00ae0c21d8468ceaf3fe5ab055eac51c6baeb1aca47efcea7005a2d4e7922e07b6d17fe8953b526f212221700dbe42b05aeb399186d4f648881bc9079fa498a29237c50ed44243b978c4e7bc54ec69aaac56339a06cc343986cecc0cbae061c6326efe3fc7105e887c3daf66abdbb9d13d619242bd552137d59dd1bb7c8f853b91210ea180cc1a20bf2de26d36c54a5feae94ac667b1db849f28a33f4810d35294941ba4d28adec13b4fcc2be8bc443d0a21d5bef587b6cd35c62f464dc16f8b7f1511ed4b7c86f774181c0b550a6695c68eafcffdd9b798b7e607c1230c508983271e46fa34e5ad21d868d036e580af2220da626ba2198b6734e2356a98c35be66836a4e7d83d1f731ea772e046f91fd2ff5b757775cc7a55511a9fcee7e6137ef2903b83a4c88d3d20b58324a8494636c9bb733e94f15048182cdc22e92eab770a27a4683c33ce8d3fd2287031801b1d55862685e55fbc117b3cb25e62e139a4893a0e376c1ea2750c23a31c19be501bf9cfae7e0421b4b5738e5cb16b9d7dc63fcc866a809de218e0306839aab9bd9b93ab92a51ef6c90f010ead0498cfaf9af8244c6933ba7a45ab64ca50b43a1ffe27b1d9f9a9d04ce0d2c9bc93d13dac92804e32373af03120b19131e9f29f255f1f81393615553b6b1c722c77637d67802d991781d9b146b0ad69e3c4515bd3e37b3a52ce7361061300def448237bb5a8fc1869f28fe2d85357065c22d1722ba26d01fbc7cf8223992988c74130f75ff84c21b706cf5a24674163367f33fe2f81c1819ec13b7b6fee770eff7147058d5599d059c9ef668ba8e5e0a49f8cac30aa9366a7b7f7c260bd0ab21ff83e8b75475c8525350d48712301c279dc3f3f696588e1fc5afb010a18a3d9e756d4c66b6e73622f2632b3e4ab80b0bff9f90cf07b8f278f0a0198ecf3098ff04c9cc53186eecea10f55511a35f037e207b97df478dff2f3c1bc199b5d1a02decf8cec9fec32f4a0e7ef3db78cbf476611038f4d6467fe128f42cb2b8e2003200d4c739be6c1453ffb9e89eb44b6b53297025358d06e8de260c0297b4c7a88429229e55c1dbdf2819c15ba5cd79fb7681d5e7026557de4334197603e44c82ccefe68a2060e7a7275dce347e04a906bcc4a469ffcd2ebcc8f4b90d4e53c8baeb8e14f5d8b65120252c3fc1d06e62050bd5c642e2116b31123f3619b4f5abb6e65a43a9ee482e420b0b8a81e73b8abcabef1087efab52406bb69fa004ad1c2f335a5d64099996410cd0d949d0b05dca2906c39857d493c00d2390c02e6b94867aae381f4932e7457dfdbf5e3edd6e084d771004dec4a20d7ab652ad299e9631912e0babd49e9b2427ba85fae3c4b2e805542b473e4443b68829d595933ff20facb907d7230f3e0600782a2adb959018ab2f3bba9bd220f15c25e5caf9a0ac221178f6440855f780441865a053026c9fad4c9ba3438be8543560e28a5647ac14773dd6725635518c4d0041ecfae24300dca32ef6e7b040bda0560e13c35396d4c91e91c7629f639fdeeaf0197939abe623e270145644c2ec9df9c762cf224e2b0d3ab6d5a323aec4c188d1fdf6446f77d86f171ba23b8e180b79a6e5ec5494b1a5f06d74cd93d0116d297129a7c385e47379d5d642dbcaf75b176cb72ef8a8bd5bac5609dd1b82c017f48e5b18226118c4e9144eb752568a0df64f03a6aa3e34e01e5abefcc9910794371c581b7c3777ceb16228d0139d7feed26523d5ba8b997a0f7a5bb71001a2cfa22ec5b0ee8192a97ce2a9cc2c61211dffb5935567762e7aadaaacca10f5e8e388c8c031890d8101d562cfdc749ca5ed81a4b916fbab018b70f20c210525b5663044932bdff9d89f3a0adaabb6fd0eefe0a2bf41e6c18285163df912aaba1ffd2b4a114c991185634c59d31b1a1c5cd636aa5b4f10469b8fac018ff490ee84808920ccb43fe3a1a253f95344468648f00f6a35c0dbd7b90bb56ad293f7604b4f096eaea9c210cde4fed6be706c571c6c3e4db2a828bb619426a68fe25d78f0b3b745afaa58ec78d2b472c9540dbbc8dade7e1926dcdefe19381e4c28c04bdd7bb25fdf85c756f7954903a1cfc81ea00fc606eb9ecbe111b4ec15d8deac50ee8e11f1dd586a8b7d4540add6c669902c167a45bfade2fd81c76a22cca659326d13a074df519cca038fd66300b7d3dd67570529065781e26dfd96126b8eab4da6807247fb178f631204dfdf9940c305f45b920783ba421bc8200cbaaec91bd1f4ae003cbd57b4e7e6ceb82b733ff132a5e75a1e57337cd8bc7aa40b9cd569d16546afb92224d708be12e4cc22bfb53b671e4db3739f3797f94e32401171ec3bd2b1b7a7fcd11a3bca7b6545a5051ce7733dfc76669571b5173a00284590c0959b50d62d2fe64291ec99292f38d3ba0cfde73fe2918450df613f21a0a772c65a19ee6d5e852a2364bb9fc552e606baae2af9231c50c710339c5c4375c28669832d5c82e5e5a0053b0c99fb77959e8a8ad66ca3c263fa684560031e6ef78c4557a0c5a0c271a7b389bb271577d9f3ef817c914e1e860d89bd3dd5b7a75480c9ca13bd7b0278b8e72e0111bee0d6afd610f21b37d845106a9519be77e81c9a23b861d391b3d19c14adee5ef729e8a858ae8ba1a5860aaec7bd51cf4715d05c4c2dfb168916c25fecb4b1378d8d5de27da5868f144cb358822d367aff1e556094a18ba838cf184c0e691e287a12fde93fb5ffd19c4db706815532476ba3eed3fdb364031392efe0c00647fe8d05313964960d4d0e10d0ed2abb02384180f4c8f6c760d06fe16d03c75ec7a90f5209926c67649d86e0c76b101c5d534afebccefa9c931f9b98d2a98de28486c5539a3c774dc3fb56173425db9ccd1d3b78c18f106997fe8ac45b2c01a01bfb67842f73332bc98fb7281c22843fa51fd1972b0d0d27d0d2d3c3500ec6c3b9ce197ec6e5d6371c0aa469f77c69471b28effa068e0489ab83f054f20ee37af000eae4576bb1595239ab45a987a7a5df826c638e63cd7739e6df037131420ffef1432d290e96a98b3f501f5901dece9473770b727d415e2a29c35f44dce9db2d01fb863d29569ec63ca1deb7dee0f326ba3f7e7fabb27baeb1f8511382b4bbef0d0fdab65bf8de0aea232efb335d59b51f2239f83d8805b659cc6a8b0217669fffb22190845b27210331fa337b750ae8c0ec69dbad249283efd1fae86abc10691ee109e8bc32d448c16a80345f5442bd1967b29ea5edc406a78366afeafdf249e4852a855c43cc9259b74dccb4280177bbe5b2f32d3118f20a3dba350beadb30265ddaadf3b1391649e28cdeba5fa6807be2f0e070e5e4b5c9698f52a983e19fe51935337582f36d8792d607d8add4499d31878b0acf0aa5b23c9062c8c9a59b55975b77e9fc71f92fffb738a44df1276d3c535c9915653211839e46ba04043b01ad37f6a5e6ebea586f9bfd2629c2e88489af7c1bb5585f6937580ee8cb2095a30f368c5664457ac073a8e47d1d8aadd2469cb5b6bfdade46b4478348695d6856bf830ec1d55c24449b9db90cbd26d2802a53f319a24323b9ff393add731a1e49a056c50dbf5b98d1cddf0879f11e93ff227b72cc1d0d50edc72223c4e5b0b8fe3e190f896427aada9522cbb3f5ad29bdff4f20def3e16b4136937bc720c1a82a99ff7fee711794dcc982aefa5b38edb7d9461e82e892a471fb80977943e5f1d0808720d53faef1a80c9ac9905a57341caef55a43e22242874202cb0a3c891a5dacc9beae842cb455d74a164ce179e331ccae17c95a1d579e8f61d1bdc4e9fc254c3fee834d95104259c7aae7e87e1bbc53cb280ba99bba1871ebe603f8dfbff2aa9ad727ba6830f5e298c0b46693d0844d6f615eb7220cc76b87e9bdf864f4e4b36068548debc23016486c077f559ebff3e0e7111841969e93bd4dff963b281257de1334e20a68235464049cdbcc85b9e856d200be4c8aa25e83eaee00845d283db97219387da711dbaedd378b328f1e074f9823fad840799c27983b6af605cf3fde309f100f6b9b2148ec2079cd86d1695d34a86ad21bbfc92ce48f80e889fbcb7de39e382ef28b35fd72d15fc952f1bbb6e005ebca4468a8f4ae0d7d6f1006cb10313a500bc0d9d44235dcc0442bee946998072310be93fab939e668fd246ea2f6d8ba03238bebbaaea523b190945bb730d7a7335b02d35b86acc8f21831e25763bac2c8e4015445a2d3e75dc5411b85b02f03ae7115cffcf7a26e394409947836a139c06b0ef8036bb0785f1431438912aba438f5e0626b4f25c2fcc88a9822f2f729b71b7ac0fe1b4c92fd7dd65936f8705705b3f7ea7188993ec4a07a765e9520fe0a8a0b22cd8c1528789dcbe82857ad01f5dcb5b8d0af9e5764d9cd0c695eb4226c399ea0f626aa54cd3b0fd0fbb886d97c36af790e4b7dc18be47c33b543bfa7ffe954159d7bb78227959a316155506b68cb7f3cf83a2fbe5d0a805222a7a39f335ab298d1edeb58fa8c05854387316fc2516b190aea3356550527d37d6c99368fc9315a16a89fcd1549665090ed4ece1b7d5d916dfe1740be56af8c24e9ab3e9b62700988e5b20806b0938292cb92c7e1525d587e4d61386e1efa64cac53d72f50abe72e78e4a6fc0a55e41ae34d4d7c8a0e54df0bd065d55d789be682304f825fd64a99a3e149b824d29e09133f1b6301facbf3c2b92c37ab854f05ecd101e5dc49af4d9a887844352141c52aed362b3ceaef8ae7c522e16a451ee8c23ce896bcfe1fe2cef0d635fc0acb32f21d922519c73c7e3470738bd128c991d59d91e00be4a8f867a5bad65deade4c0266f6311e8c71ef7ea041cbe1dbf4500c699c32697dd93bcc27ada9d8cc40b40cdc7d45c41f128db52e1f3da7f6a6d8c9254194f1d3486b01b4eebb38fa5bd0540a17413dede5e6d3d8977fbc39cbe80581c861fd74107830e8f1c7723fbd7ffc7c0918ae1775d23bcfa4fda546b586e40b105b468b4bb1e008db27d12b995806be6946174392df26583889cb8b97c5cb63090251589d00bc7b0898dc6a45792f0aa397657ccfdc21afb8c51a8b091f3a5f3a493375a936eeba86c9aa88bae8028cf73c65bf036cc4317b629cb9875bdf403b92124b9967717397c47cb91787c874f83391f6c9a6161f4e2586f5f20abae03cfcf2249a57d9b8331bd7b01f8e31dd0efdf81500d356abf2c493f70d8d3b317d02b2155df76f3984eb7d2fb6a1e4f1f5a1b61f4b2711ee9d93b03301aab484d46a46ae98f0b42567b2feb267704b923c0caf75919fbb3c75f93b54d9ba8c7d2a849f298342920ef2edb19ce1e34332c7ab96d97ee147d818bf72da076205a2feb4bd445ceed755e88f5e3975e196814e6d74e101315d701728c775ddd38c22e059de72e3b3d0ec4740e94d9a9a5616db001d74cc742ce376dd315315afe07ff7f3d47ededd0105bb6fb9306a6d861950706016d74a10cd2ea8c5fc4a6583647ca7ebf3961e6807283abe022255aebfdf05e46ede2c6befacfb0f617d3346333d0ae5d9597cc39e24193d4ea6ea3b299082e26bdea475324f50104190aae9821b42f968f64dc4e17966d42cfaf4d220bea44ce39c91ee09ed4dd092cec716fd8c73e85b44472bb2a8ae5b19ca89ef0f9afe035b1e7bdf504fc6e65d619d32dd19807c6f9b952e3661d38bbde3bd7b6ca71c2ae42ff7e644b07f6f36db8ace99e1141470580cb6e90dfe985eb7e53ad43cfcbd99df1dbb2542cf41c2ae05b719150911ef5e61402544622807de652c0505d20160010ed621a90370a3b4f1e2337a0c445b9079832057d04b30901348e4832063f7ac817ea57d9f59baa789c51feaa5afc058c51967c7176d762b2536ce871edf52bb729ed5cd63daf0aad7c4e9d3813ce523adce6dcb3953dab3b2e47fbb6d1d674dcf19fc972a60a7bebdd6f5b61039d1e30d5c77cf6bab294dc61cff1921bb54453e97ef5191f16b4e8e8618a975be138cc5aa3ff0e9bf6dc3fc780d711380e5cbf3ec0c63736fdaa434e5d4d6c4543c974fe8f4809946aa03b65fdae88d78d1c995a32caa349b6471ed25dcfa917014817103de887b71c9a0d5e2da743e2d266e30411bf7dbab47498fe901e7cea31c4df761ae41efaa4d4f13a7e8617e7377af3a4e7f8efd7b2424637a7602fa9bb2fe7fe1ee9ac4a7446cdb340bcfe88f36c1aa46c4a8759a86df8c7a3ec59c470e1e5a7514b61eb90273bf54993141a5a9a01ae995f1f2c725b903c78d3e1abdf53b70f3d46b268860867659b2cfa9a9828cfc95b30a51abd4d61a91e18ecdbca06445e20ac38ca590ee6d7969452a5c0287dfb06708c3c6dec099f0736c78e8c5b0015a017edd962592e9995f0286f4e8d8c335bbf3cdf70ee06470e9a0010a35b78e4a518fa14b8c81b42df2ca6287338a7ff49148130cb709b657e7888303b317c4b8919b5124126f61099835bf58caee32243878eb34d8eee4b19796aa4205f0a3c4fc7d18f5882f1b4f7f2db996d114cd408e67d063fba7bf56fecf63d13b68a78ad3c565aebe3e05d40174a4364356a064eced97d95f317375684ddb5d52291b32bb34509549382ca10f1c71eed5ce06900a587e72e5ea03642ebfcad331de8bba8541c8359d600672410c6284fadb1691b7e900797f1956b575e41761f5b9425ad9979a78f71d8452df8213efe5a0677dec5288090c64c6d79f14c3ff16f0d17ff19542877877b0bec98cd1ff3385e5efd63ee350235752be97b725dfd03bb1c844cc8c67a39ee1e5dd8d3e91abb4b67cc8c9902fd1e450563fcb80469258ea7e33850979986479f31fbf4974129d2f0d9604db0b33debacbd362dbcadf88d56f02394f3e96be357fb0ab7595cc72d715d673c1dca27c03de3d2131f2570fe62d4e160d1cb046118754b26e1437ac7cd8988eb3b76fdd80c7e9c3f09ddeb7860fd381edf735bcb3942188f1474d845924aa431b6b237e6479f094cad6224e067dde8e48e1fa8072f0b1b301e82a7b48462872b7effbc5432e12f7ced3cb23945ffe8aa62d841ae1031f1070d86bd2081b4070c6ba8e7a309540e1dc569b8d4cc38b7212b32db3f14de24fb14d3f1393752a85003b834861173d5b60b8bc6455fe7d793c0a7b99a58aa772044641867d4b1b6e620af1416afa1d03613c49860aef8b866c0221bf4df00c52e990d2bd7059afdbc79e35570561638be08ac3543a2301b344b1cd3a5ba4481ae7deb409ac3189f2558304e46a6ca3398965ed3272fad4cf53c858c5bfc9accaa29325029ae63acab5640c233a00bb66acf4e30a5b1582dd771ad13edeca0db545548f0275c34df11e7acab4f1eadeff9045e0c925a4d493107bcf270bc12003348c2faafbc435e731150d1cf874df0712d452e1076666dc016192269d1b02301362ba5d35c442a1a262354334986e138d3952c6c76bc75786f7a8858de8368b20d71cc046852d07b3a57ff435623fcc205b7e7159ef62d5d1865fb2a860a5b8d70afa41561cb3757d787860ee4263713bb18ae08ad207de835eb2c04e99332fe9dc658c805acd3e0fdb4c9bf849605279829b94c0969c2deaab47e5c37df5ba8067ac17dd347b24531bd21e72941956d32b8311c2dfee3013e6d3fa107215fbdb0bab979257b8e2cbdff943636dc9761dd0b56196d3be89b0b957fe7341ede3300b5d89fb5637a31edfe5ccb7e2fa40d5087b9270e91e8fc99ed993603a173ce4e5c2abda30ae876d0ef65dc7d0a65540727e33acf900ce3d82987f109a992110fb387f9f0f09258250fbfd6da656ebda2c61dbd9a05182172d382da4a9b0815a22a7cfba81a304c8ef2f99b463754b16ae57a2db475320ae53132ad32e269f1b3ab0230397bc20176db6810995c554677a30a6116302ce9876b2a82c129794d4e32d4d2996b66c4e6d26e9084d49f6a4a2598896ba2ce670ff61fee75c82ccf5e8d1de3c3c574abecf1e6ad55ec7b8b61e9cec8bcd8d776443052545f07e85f501bcae40b829146337eb7e005b7f33935f4dfd76a2b2c498558f3d7d987f53b6f92f58cfd45797ef900a0703118c958eb2a8e6ac969fc35cd3fd06435d9f9f3d675dbbcf01cc93a75fcbc84597ea1ff94fdb5acffe329e2b144d67d3318a23ba77577a3930323c0adb41eab91b1aa70d2f0f0c59aa07367f67a0eb9566386fda82f07de9b179bc4c27937901ffce1730f969383a9c2a9b724ac43f4d7e5d6873632a6e868fceaea432f0e527fc41ec7bb68619858a4f9534bf43b6d7489dc376ce513d75069da56201a282ea5e3ab8a20d6a702af74f1f4a3085c57f65548e3922a89ddd2016a3dc723808918a10a01a315204c6f3a8e6a089c687dc8e83a80a68b484be99d8a228c9431356538cde9cd30c1c7be25bce71715b39425237441982f1af127fd50fa77d00a45fecb040f4bdae07e1c50e6df3ca43bfc214986aabbf941b054444495d2c049e476c3ea71be0a194fff1888edcec0b1ebe87a876a451958d35357e2720a0494a342aef89acf7ff9a5b30b1b0b635eb0003ef9a975b59f20b0d81e56f8e49f1d380753d709d25197213a9028500e840337fda8f51c28b726122469060dbaaaacbf569cc79500dd7780b2306732078e22a803583fcdaa2bd9eae594c29698202a591e264d6f156668d2a6dbd1627b6297a83cd26427f17bd9411b8b46f33bec038e1ccd54c26af3198a60217bc617d545e97b26ba576dda65b66d17dcb09821842e85eedb6099ec200613c70e7bcd392344b1386f7dc1bf2ce2724d24a9acaabe399f12e807dcf8d3353a1e4cff6a213fe2f7649dfd81bbb0ce5d794eb4b774b1ee181df2cc7a609230b28a9dea1757be2e872d55ba2e7c8f9054aa425e9c4eb5b391a81d17e37afc4377bfa32f7e173abcb4cad39d9537cba9fbec25e1a837ce8d6a6db97cdfdae904593351e798c6d4511117f9c2b6d6d3d59a79f74b08e33735ff63f3cfcef33030b378aa965ec4144961a117d4c8461af5f329838bf5a5f9232e9c79251c3081e8535570df93b1d5e2b1d07283a5291036b132aef8792063b4211f5fe407e54e8a36aa839803efcec751a72bbd4eeeb72d2b8bfd0331e714c7b4435fbe8b1ece826e17e503bc6146e60e268aac49320f5b05e71885e143604bee38295e1f46cad89a383281024b3041b01393eb165becd19b292b87062918866d88cef5a79dc46000e86cc0ceb71f5ab3c1a11c7bda6fc5cf66876ca35935f658a90bd8bd82bca83b3aefbb9b1342c1004b1938ead63c95bde31c8bd6f32f6e75056ca6f6d3ed2ee27a0a63dbbf9b6eb71168812b7b140ed8bb72c59ae6a1e911f8f74d6d883fa2941d7754db26945cac48e8856f3b0b052670a1302b455894172282bc1885f6368a17c43f1df07b0ef6e917e1d21bf2bbcc09d61df379f5070b909f6115dbd34749c819e15880871b81f482a0056f109dd6df0ef1369c97013c914ed89c33b140bca5248ee551e258a68349fd34b816590d51e0ac9ae7748180c31c017e544b24ad7a2b92802031054df3dc55f84479e8d1b38f1086f5c1c6c7e9f2e76be493e2d69d09aee9c1a969fe004d865bd88d82c5ef45a69e6759594afd38f1a3e13ed1522324bb82554c33053f8e7f66ef2793b3876ed855afd3fd84f944b73c1c6786d1c245eef5a55c4360f57561a4e9face0f815c84a31cb0af7093461768bcc9d4e6c0a1961eb126c0ccbf75cc40d62e19143d1f90eb7f9ca72ab49e17f0e409d427a9cf8807331b088af6c861cd8614b170ade077f9d3fb767dd6c728023f3bd0d49b52a7bf0ee2bdff5d932143a4960a0120c6a577dd2eef4ef22cd7b8856c58bf8940f1793df9b1031a1154d7be55de87b140eefe4a0ed347a553f5740cb849c17f8c0691c7c62eb24d5b64f9c19c06af1b2d591bd5a1bc6d0622bf8adf9492097a987582e5b069c4c44f0117575cca7816811ab110e3ee3941686b284cc6b04703c62eb39f2b1cd72ca74cdad96087948140ec07d15020cde9e5a07e896c35f4e6a846ff5e5b15afd8345268cb6c0755f22863ad6b4793dc0e043b354be2d9fd32cd5698445f98cce6f3aa1ce6c8367c6ed2b03cc0796ba3065f50c2dfa0bc241076d59bb869feedd067f6a10bda3ce351620ec99d5b1648b75b4b302dcc1a6a11e1d4a29bd5caaea52146c6ff9b8760df780eb047406a43ae5da8df7dc3a67b6aee636d1500f7ce9174cb46ee21d1bd120d625392335e043745417d09d62c54f227f3cbd6c3a3110b6502c4fb1721be5b2a3c84d33c488baac26009160a9a7cd95d39bd57883b9a0849a9e586718407db7dcb479d398ad5b9be31ac20386a5e6d2818ca53535c7d5877a0dcdd1b88eef2f69f942a28027d4c9359bb0f0f2a303e55bdff77bbcff928e9459802fbd2edd53a81d33f5aa50736f5ba44a7fe981c23de77075352cbcbaf660384e4ad55de3a1e73bda552c4d4ce3a6276e4bedd47101e16bafdebb594b91a97ae8237374c6c4edeb2ae17ce307f9fb12c5d882b5977bb75b3fc6431aa6610fa3b70a50fa48fc72fd780df8e4e81754cf88abb39bd5eb0b0fe747c194a13d85ccc708e6ca20ada202a5da6026c5893f0fc7ad8c4bbbd3354ada75d9b549a6d3e0fb23f449bcf79eaa3e975708f5b55ded01529dd15aaebf499cfd4f506f8b151f01d4fda7c9b9faeba734e58f7bbae45a45657e8faf82e7141b998f3d690e3af2bc67c836b22a40ff829bf70ee91b1ede0bec45582a1220a0f207260ea9c286172fd1e1cd7b576c29f590de5cba12e8a08cb6119df47c91bf0160464a055d10150274173fc21e6f568884cc9e365334cf4c9283a9bc1594e9ba7f4642db3c45004420fcdabaf1ad83b50d5aa00d0b87450e2040f01cc738c9da8f206f6abc639401586805748b7efa61f705bc38367b8f755e7067f0dcc0a06ecdf2620bc0ff98bd5bf7d9c203b05ad976ac53e05a3e3601eb42f5253c227c54487d49248e7f98fe3e86e0901f03750e9314d94732125f2cd466ece41389339fdda9f8fc93a1e66c73bad17b84acf52cd0646602c3cbb9d698919814dbd43d8878ff90d45df3f63ace796bf981d3dec5eaa9e6f1f654bf4b9afdda98fd1453d98f2daedab25803d2086e55717615d320cd53ced2c52a4083d7e6d6d5f412dff7e88627ee778902fd228915ff7202307cf0b66356a3df4275410eae4ca7c643fce47f6043b691ee0bda7d14cea4a0f8450b8b970dfe98329b59394d63d3e1eb7eff342954e5505ba99d41b24137e68f97446c6da642905df814b248a9f9442d05b2e02ebb61fa5c5c08906a5bd642437e245bf43d0593c3432fc5c82bb387fb37a268fcdccc95bef0e6680911b514a5da1f3bcfc8a884340d334386aaa0736a4edcd18a80eb7e883f478fef84ff30b7e0ed564dd41ad7bef77c01d7bf27880056dec661b97be5d611dc096752ed60e582ccd5122200176e636958ca4d0378d942641348c5644c001841a307603ce0cf51784b51e0fc615920ada755c244aa98f1372c84bf950c0c2f4f6c2beab8e0e59ae32b908099e7010593cc9004c4b82b85c3a7ac4be2cf786ebe3673b79b06d0cfa74d056fa36f018279af021d24f15ccac7bd089a2e1753b8c81a5ba9f3e9aa80c36d7d2ccfd2088d74b8fdea82d8358b63ce806746b69bc55cf1de1a0497117376acd48ccf7d2e7d69540c79a2a331fc8bda1edbcc54fee8b6db2ebf7d10f89ff40dff1b0cf38cb253736dc2dabd3fad31081f63cdedd701e2bc73f2bbc8552238f9a0eb9e483123a20da1fb6a4496a8902290f397508d59b8baa3aebc29a06071bc374b48a85927c79804b0d18b54a995178448bda1316579c166965d0f15fb7305d22c95ce031f25947f46ab99f593d579d00d32d77ca5eeff0ac8844ad548066a58388b8dcbca7b0040bf36a9929a4ffd5e0eda3f121f6768896a401fcf6d28e265cfcb4b1972dbe186bc08a8f5b615fd0dcdfef7162586339a2694c778533f49b0834581a030ecc28428a5ba7b6402f920297f741870ff5ad9fd9fef5a0e8fdf00c2393c2e05092f460ab0b6c7c3d51141f0d7fc42bbdf1efb3108376b7a97c9bcb3929fc77b4739b05b26a544926f8d0d807f2de861ee82102e0ab33618b58ffd98435f180d06f58cf29747789f5e563cd9707455b709cbdba3766ddc74df9c391db445318d04fda7ceab8e25aaa97a4ac62c97fa121d06354fdde0d7a67dc27c6805b096435bedfa5e50203fcf88abbcf7e92ce0ca74827e11937f9ba910b330ef55109f86dee7e98fd9d9a9f4c1c1ef37271f6e96c1512957df2cfba1e2897542076c21f49d1090b4f647cfd97d3479185530821312cc49f989c16655013f0a636fdd73a137101c9dda2c00b8b6a217bbd672d667660c3c0d378bf45d8935c5584d11badca8963c6c2800a79cd44f33982bceb738477258547ac93be5aeb09c10cfc983591fd29cfd376d4ae7a6a0ee64ae7e0c73f61fb83d5031ffefff573fc3f45bbbe20ef970ef0cd15f95ad9fc67af792aa9d657c09acb66ca78413b73c66a430e4eb78c512a1ebbfed45907ac3629b6efeaf1ab474f173968d3638c0bde9cd47a99be4f2adb8cf7efe1eb4043966b04a01a7913590b3b6bf15e0bb47cd4497b1bb29ffc2fc012888e2fe1c33174740b17f52763365a91d6c999515823092a51301aa3d7a14b8230d43a329a0ca818d03b01447258465e216221b928fcfbf3e27129f22e3418c8d6e04b0450aadbaddf3188e8e46299e56a9f36622edad922d3b09eefacaf5fba8c2f8bf5fd305394d09c86fe71571a59f07e7fa9200730108b0a00dff80c1c7c65462e9cc819a910920d8ed6ad59c03a083941ec2918227b67ca18ac65a639d4d224660463fcfe233e9478cff0e67654b674e44624ca552dea9a13be532e346c4608e20d9595744956720403b0a6850356eeb22754141ed28d312be5ae4bef002f3fcc9f2c3754c4271eb1e31598a4f074a614ef364224725aea01636d2265911f7ed173293cdcc44347a16904d8f89af1f2f59030dd37ef67edf8e70614afa5f3aea9e4483c22865aefb66ed7fa3f3840698c8ba79840dd69e4a2a8c7ab481fabe09bae67069e7363463d9f2480392528bad65a24787b7e7fa924cf30ab8260a3b26d20ddd08639eed1eec6d49af7837302ab51efb53e3d0943d6b7082ecb17e9add68607129b81f541e70eae4307e8de81ba06c7e2399030292e45557ba47fd7b64916274365669b9285098c06ed2949c5e97199c17adb3eed8551783f74744b028c12856aed3b6c1837cb94991eb76aae6bbbd85f3d5fa95ea0a270294d40bc04322f629e3e7dae2e934ba2df77a4f60dbd5454c64b2c6490d61e35656d10a65bdd1e6224bacf9e8d02a63e0395c4e8581244a6bd9fec9ef23374104a86e300e9eb3a91c61873e7300364a1942b0b1d1f550c63ded7dd0822cc5a9157291525ed1c65814156323767895c3536c964b71b70d06835d55838e0e75339609aa89abd822b2aecc1031baa7f61a4dbd358384022dc1e093e1e1b5b996f6182ccc32804d094faff3fc7a59f2bcc88a260845a0fa37315dbe41712e9409c0300c1a191b34b5f9811c947a438843add2da99224da5d061e5771e6b413935cdf86dd497ef1dd2edb2b0fb58bc8b1319afb22ef688b4681cca006d02cc87eb8d8cd3a19e231cc5a275310028dc87488ef1a0ffba422117973e07312bc1000ea28eb9de61128231ba1f085b050e379db42b3702efdf95967ddbff7e30a575106aa3e30829c97763d0abe6b1a59199daee333a6cbfb8a8b6021c0e41ca1307b38af4b8971d8d5c8a3737b8f14efa5ba35da646657599e6c967e27c805237738db5aeb0d33452f9ec198521e7dbb08dd5e06185981443addaceefc6353054b445e182ce7e4f4483811a7b9136fd6fa7fcd5097098e1ebd5b03b6e2fe18b3fef8bdd262f6072426e934ea3e1158ec6e18de784a54692b92ff25e69ea6de8e1b135d8d1a4048b5e0f6156ab86697d99dbe83d7eceb13e4bcae72552d52149b88112fac363468c5e0fdb6de650277e9f9056c8e5911bc52f10b2107bbf9b2356ba53bbbbbe6dce3eadef89cabc206ce49f80216e9918386cb1f5ff9d42227be1bba1f07ff3fc86acd00bfa70d3961449e21ac80ea6fc19fa5d4b82552bc528926938db580779dc8becbb90189b39dcff50b90181b4049d4550fca8a271138236f8a4b793b3c19271b19609a217758e103c0cc3c631f1dbaea7d51269c16746b00cff5f0162ca8c2890db3d15db2d7cd6d0fc65a03f02030a931c2bf1920df9752ab7977739c668300c6fbc1c264ff282f063cb170988ad214bed9167d3c0940e7254804f3a194c3cde1e858398ccfa965655c3f526795030dd8e425c1d4ad399afbb87e66aa08cb1e657fabf71f94c6b0f393c4a14c16668c585534281391a49b9d9d91c1423452af0b7976461574cac3e2dc6e9b238386c596f1bf2dd017ce21dcb00d70dff0af641259face73ef7d9356a6de8df7a80d702f01c28c9f6223e23dbe7801b62eb980256b9f74503b1c6daa2cb241807efb4493e5b0508efe9ca14f4e68458a28e466af17945ff73e5195e9b75ba2c647604af14a08d978ddc09e25ad5d4b487e06bc5b4d2bee8dd9dcf4170978f0735a43c5714cb274573d7100dd063658198e4264746c42acaed41b7af47a7ca7f71c8c484e27920d7da8608e96f27b10cbb6dc9ab9f06798e16e9f51f6793553e358679e28a3728c56190b028eccf354fbe485aab3af63d045dd3814fe7b55fb2d6842b9ef0e8d380ffcad9bcf8fcf1a79b09153c69ce2b2eabdaa6868025dc15385c2053585b194e6d06e8020608eba88313e8a4831c9e230df0832f29b0038284838fc454b1d6ab80095743a2e0acf307a4f55fd662148179028dbc80e9cf13cbfd2668a0e94b4c3a1d33801ccbc125f4a114cd7915af6807ff0bdf403c7f202abc85c0ade29b9d8bb09f93426a3bd5a7b04eb47d76b412b4f4990d2fdb177a7c31c187f80c4fe2145f519e54fe2f9d03916398125a0fee19c8a65a48c3ddc3ba5fe2a96175d2d95deb10c6872c373a3b2945d99a86ce50bb4df59a21bedcd682bb640f20f0f6f84a8b3c44b2f3f0b61ea59ba6cd37a2b8c21320dcb5786436779eba3710f46e32d13b46c4faab7aa8ac003fc25547619b5a9e102b1d50889468a5c6a36c25524f2aaf3312a510fb7afff6c01296a086c7fe5b86aae56a9e667b43631039a69ed70bcf1d19565c1ccee7bfe1057ef0af54692196f90813c389bb07dc80ea01b28aa2bab23169718ae1c53e18c397f51e24fd8e27eab70955f7cf8e711916f1d367549eb3c030e176117445102eba6f3af1cf5b748776bb7789c0ded9c93041a9468bc176253c661663545627b908720bf2b5248d6c42d090cffff6bbc7a9e3bfff09ad65f8fc0e2221d3e0f1072bc5c107f107d76abd90ccf22ab334d9e98607258e5a7d9965e75788f04bb361e61a2d7f6508888096fe99aa31bb546f0123534ac0f4d00e5b69f883a342e8f3820f456176ed2c1fab4b2c41d81fa0900f93ddddb4cc0333145d487a279ec0e4a658a553eb1623c29a90faa7c56e9293ababc0907fd0d133c01b112987fa9c35910c0909828620d5c6403f9c8f7d14a9db3d7c4f9bfc86600e582092f6799375de9fd4410d33abeaf8de7adb76e70937621d76ca28f8844871a9c6f7cd7bf14341138d5c4393a04229e3ef67c53dc5026c90758e454ac129371859e93714b2a2d8cd5c769e30aea01f9724dd00378f2be98526adfd5c47afd1d1b15fe4e10b190ecc911bf0fcda72e8ec64d462bd26f51a8f9af599d0b4ffe6fdabe95277e2a5251e1e888a17f94758f73f594999396220e0c3bc4c78b71b0666a9e885ed5182e92c187821a9399617ba086e9198ee9e8b8afa357fb7998c184311dd305e27b41bde3a88c47f98d1f07b56a00d805c3b4abc7c5b41ddb162eb0ccac2b3f36670977d6126951e6bd25aa383ad8ac810366a0ce8669e89ef836999c27d75f5c64d4c4311121a07d98b796a303714258cd685c6c3d9d71e524a61326a566fb731477d69ee6c521c5e120f65bf876b14c357e0b4f415c9be7272ef893886fb9b458eed09445bea2149f216e8d866e24b9f627d204886f55af759e99e24d43867d52de563813433843dd605e0e4fd0b9e7c58bd9def5603ec1f8ee0b32b4195fb687c37c0b543c1c7b47de78795ccf51baa6d48c3fdbda4fb3caa9974d0c45137b95eb5e31918d1397703d5c05cadda93ee935218ead3314a3486104796191113355ab5e38565d6bc27747d7ef2e9813c0135825e12fc747f00b5638e8799c35180779b3bf774d6d6b8b4badad05fbc5010bd03db36dd6b842d534157b02a820af0f48a3513257079f0b86ce7b6b4b19a3af59369fae9fe595e25af7ea23b2a1510c9ab139e7ab355ed091543289bef72152e8bf36579f1fec70648e5f3cfccea1ff5adea02c12af09c9cecc9ec266d832a3a335c636f8c3db4a748aabb9c42db8fa774c9ce3ab71343f86d7a8d31f4b27438f2124675c507009c05bb17357791862e139d336223b4f8ac8dc9dbcea2f9e52e144341c2e45e9eb9a43caa463dc060ba853b88b98ccb271a1b3069d17683e2743d08ec73eba114c7337717e6bd792bf0cf22c62b07400f8503b00e5f1572c2edcf25c3763c84fb7976f288ebd423294c6bc50cfd1b69467f716d659540c35213cd7ea7fe49dc80c505662a5fec3352542fb01c4b065f319d023d4c3ead5d54d0fef25b8f49f0e6789af7aff528ddcf9a1d71dc1dcfd78d7c8d3568942a0afb2a7155089530e5022e9d03ca9cf9a38090bbe9d707abf8e91a32e9a0174e2b70bf86e7b98c7b7abe875555b6175c5a7727e4a2ba563b2c297caee69e71155a510a3223e0bc814b96c05245b0ab68607b453bcbd7d394c005a13189526a30aa2d831da6cf7d57651e89e7ad78dcf6248606adc4a5142eca87cd26ea6eece43c0987ccbe4012811e7a36d306d5386dca47cfa2883d5b178b911fb3fdea19bff5de12ff73ce0ff8c3e44072420e370e84a12fd8b5df061e685575df7f81707f98184ee2dd7a5745dd29121038712154b82a95f9cd6b94bd47dba3a85d33fef85318e5d74f269eb17f2c243480cf122e35adcd7604e92e00117efd6fb2c2a5d1c1", + "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" + ] + } +} \ No newline at end of file diff --git a/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockContentsEIP7594.json b/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockContentsEIP7594.json deleted file mode 100644 index 1cda2c0e689..00000000000 --- a/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockContentsEIP7594.json +++ /dev/null @@ -1 +0,0 @@ -{"version":"eip7594","execution_payload_blinded":false,"execution_payload_value":"18191970007912226669631394668547651071148255645822697200640823429642410377933","consensus_block_value":"61453013339935582189619461221462653003808078281923085412032520595023747176323","data":{"block":{"slot":"1","proposer_index":"4666673844721362956","parent_root":"0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef","state_root":"0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e","body":{"randao_reveal":"0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71","eth1_data":{"deposit_root":"0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f","deposit_count":"4658411424342975020","block_hash":"0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379"},"graffiti":"0x0000000000000000000000000000000000000000000000000000000000000000","proposer_slashings":[{"signed_header_1":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b","state_root":"0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb","body_root":"0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486"},"signature":"0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483"},"signed_header_2":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6","state_root":"0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26","body_root":"0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1"},"signature":"0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1"}}],"attester_slashings":[{"attestation_1":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4580744678799082634","index":"4579092195582398506","beacon_block_root":"0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c","source":{"epoch":"533461240","root":"0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565"},"target":{"epoch":"538462976","root":"0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650"}},"signature":"0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc"},"attestation_2":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4620404293179370891","index":"4618751809962686763","beacon_block_root":"0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b","source":{"epoch":"538078227","root":"0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb"},"target":{"epoch":"536923980","root":"0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5"}},"signature":"0xa32991816eb9f297553b4732309a4cdba7b33287264611715b0ab3319bca19e581da6e2659912a4e0e94aafc01c488e30ffc96ed14e2a726b9d3c618405ee0bf54bf6ae7f2097465cb27ab8132ec24eb93d3c9159475304082f7f0e452b93b65"}}],"attestations":[{"aggregation_bits":"0xfa79cdb89d0d51c5cdd001b7425c6d726750a9d5f89ade6ed9890ce3a706140c399a5e10c90a819094b65322dac7501f7c75471e69d4567358d8ca75f7c1b3133ebecf006b369a1f36efc5f2b706d5922ff98c58a1825a53a864376658f816600cf021cea843d4396502bb9c74d1510afe26036f89f783b4f5c7bacb6649c46f217a6af835f312d6fa253d2bbc83c07993f4f10de2ed2d952689379dbe4f794c1a1055a6b364d68e038deec9667f576b3b9eca5fcadd6298f181e1edb876efc3d0975ae14ae9a0ad2f1836d4c3f1080a96d8ab7c43b34bb2eda895ff66be698b363cfa4be33da3ec94a1a7a90672fd12c4a59916bb937e78476e4f08e4f4031001","data":{"slot":"4605531939934246443","index":"4610489389584298827","beacon_block_root":"0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b","source":{"epoch":"529421377","root":"0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2"},"target":{"epoch":"529806126","root":"0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd"}},"signature":"0x8f8d16b39e14569aab1b712e5c19ed51afe3600a6b017e8ab432f43a02ee720a733c33ef087d2f3653a9701e8d8a836301655b9195c0373b775c88ba1368e5d55354a70a3096bd26dee29dddbe7a4820e2b1653e84122beacbc01af7d93e6bdc"},{"aggregation_bits":"0x4ac567b296efbf7cf3209e87096a7a1a50fd523400113f917f6584a5a306f06b2d8da9ae858d47ff2594010089838efe41f19a78d9aae27c2ffde26f278b8681db9d091eb72e7cab3e449dfccd46a270693e1f88f197324e57bfd45573315cf9fb60d770937b32f7c0c6ce1581ec51e6b60f71acfde304dc917f2e0aa7872038b7d9140d15f7927c23a0490a74c2b0aca2773fed9217067e4444f9ca93874e4ff8407111c3efdb138b97c6d4957b6a70ec1debb283e3d0eb1cfef068adcffbf057d20fdc339eae03f0fa2613abdde8158a7fc40c3cfd1117eb6f8c4ae21d6b2ab4b57ae9a8653a34451aee6418c0c3609dc937293f5f5b346a7ab1a0d144185101","data":{"slot":"4544390030852162633","index":"4542737547635478505","beacon_block_root":"0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd","source":{"epoch":"527690007","root":"0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8"},"target":{"epoch":"528074756","root":"0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8"}},"signature":"0x90309dd491ae6ed51917dc305a3d4ae68d0a0d4792c7eb59c193bd03605bd94e61cab37502de0ad3e6162bc02427bba80a798b3670d5de82a854094016cc298b265371345c0e3ac49fd44bbb9ba0d4fcea0c1a80cecb60e93921d907e8c48120"},{"aggregation_bits":"0xe8c9759f0840f980ae956b15fc383d992e7d4420d12ba5bf32f669f446ac6fa388e20e5ce96e9266dd98840179d2cde3cabd9a8bafab5dec9c2e89f7f78c989e690548603984803b80c82d7b76443194576a1ce49da5cfe56f56e83b745fb01b5f18ccc86d88f5a22d927e64ff0b8e880893abcddec45b268531c4a0697537dae643a24b1a36432f37d42962553bd39af71f37e0429b81470c11316aa39db074aa3f1df4124e7cb203debed60b885ffb9b27e46a1434e81bbd56566632d0729c0822ac415cbb67f25973667d88e58df9c2f058a0ae7f118c98cc448453b6fbe590363bd17ed62c2f808df61f2a9e593235eeb56db74b9dd15980189a5271468301","data":{"slot":"4529517677607038185","index":"4574134745932346122","beacon_block_root":"0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947","source":{"epoch":"532884117","root":"0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31"},"target":{"epoch":"531729870","root":"0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672"}},"signature":"0x8c40f51a99fce6ebb9a4db5e80d715fff319e7ae523e46afb5d03c000d427e23c7a39e77e2af53851706283c8ca91d680997cb459386fbdff52c4d0ecf498e173717a838a792b210bdffaf476538628584a133899bf30dd5ce7056463b8cd683"}],"deposits":[{"proof":["0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c"],"data":{"pubkey":"0xb1f8f6e731dbf6b4e3265fb857c7190adbfc7e6cc95ce2e8bda72be8b6ea3459f862310a2484c3b0ee33b30920f18c1d","withdrawal_credentials":"0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c","amount":"32000000000","signature":"0xb594382214f5bdd375de66c45e1c61a526c7b73fb166c72433bbd9c2a7ad6881244e61cc6427e0206a50b762a129d8830e8708c55761d61ce9e3b19c1bee13bc55daa13bdb07118efdbf57a588b8a64e6392d14f935e53b68933e3355b35acdb"}}],"voluntary_exits":[{"message":{"epoch":"4562567354825622634","validator_index":"4564219838042306762"},"signature":"0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e"}],"sync_aggregate":{"sync_committee_bits":"0x01000000","sync_committee_signature":"0x919ee45cc18456f6e85da6bc21c2e40f44f9a887932c73ea9ad354f88e56d4ec0a8c396ed143082c8e31d697b877a2a215d2966d91c7beb156bf7ab5777e210012f70dcd5f7657808a82cba51e194be994f917150ebdb9e5c57476f1edb47206"},"execution_payload":{"parent_hash":"0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be","fee_recipient":"0xf8eb5a3ea82ccf3c1be1ac153e3f77f273a07343","state_root":"0xbf886c3ec849316e3b187793c3a4398b6097768d06bd968a54e8d2652d2a75a9","receipts_root":"0xd2a9663e689510b3305bdebe972d4e58669a751fbc85bf448269162e078b2c34","logs_bloom":"0x324f493e880f6d0bfaa9e297b9d9b45986a970f94c718be767ef67174b6fc1e9f770a36a743c8a3abab61dc439ddc0604dd5015b1ed3835787d9565dee0f3e64b25de4c097defe3001f483a4b6feac22b992cada114bfc709d483b4d94f07bb0a1c4fb9e93ca3c31f4b9683753ba33ffd971777e301367f1edfe6809da491535c711a7877b4c97fd1a756136c412b4f3c4471ba439607333623558a63030f2cb6bc2ba885822672de14ea697d44fbcde134b6909208466be0b4c981658ba30f999c991aca746c3331766af1ee10cbe69624066708ae086999a0a3853eb777b3f9f0455cfd98a98c7719710515b97c596d2b662d353a90206e470c523d4374853","prev_randao":"0x4570433e285b4c50f0ec49c38d62c9268cac6f8b023ab4a19570abdf25d07874","block_number":"4491510546443434056","gas_limit":"4489858063226749928","gas_used":"4481595642848361992","timestamp":"4479943159631677864","extra_data":"0x58913d3ec8a62b95e52fb1ee60ebddf392af6e1db902dd5bc3f1eea7003130ff","base_fee_per_gas":"48712354854557871613352262057776104244427151172201944877932608112921551169417","block_hash":"0xcb571a3e876c6732a4c11cf3562059c2b8c16889ffb6d1b8d5f883591e767c3f","transactions":["0xb736203ee72088","0xc7dab83ea972da","0xa198c43e69db1b","0x135fa13e28a157","0xed1cad3ee80999","0x60e3893ea8cfd4","0x39a1953e683816","0xac67723e28fe51"],"withdrawals":[{"index":"4864971916622804241","validator_index":"2164897","address":"0x09988f43d11dcf2aa7811c9997eb4119e8f153ce","amount":"4866624404134455665"}],"blob_gas_used":"4858361979461100433","excess_blob_gas":"4856709496244416305"},"bls_to_execution_changes":[{"message":{"validator_index":"625901","from_bls_pubkey":"0x8b772ee4cbcc67f534f33102671346cc3d0ddecc1a81f0350f68dd3210681c9e4bf907b49211cbd390bfadc7f285214a","to_execution_address":"0xb5c15a4371c6a89646dcbd1f07bbfa4e210d4bf0"},"signature":"0x85cc5356a9646f0ffd512b7d2e7d3242c81303a415e61b490d28635896aef1f2db03ae8a1439908d03cc131515ef83f003dd7b36ce480c43f4495ffd339b2b9d1e5461309a02ce193202f27d216a4f0e13f7b47295f3e1a44c8f0e8ae8e1e5a8"},{"message":{"validator_index":"241152","from_bls_pubkey":"0x8183f3f5071394e20f83599fe297dfda37f77a040362da8f8fe926a451eb9cfd917e953c51b81619f8e4925fa6177b49","to_execution_address":"0x10eadb43b24678ab331bde64d7f836af97ca6064"},"signature":"0xa19b99131e621d31846245039e99d6540418acc08844a3996544cca2d9965f8a24cc49cf695bd78959a784e1b5646b480b88aec749a62ea934ed3001af50bb8babfb15bb9df1f3d57abd738f65de02b77398c82302f500218675cd96ee3b2357"},{"message":{"validator_index":"1473390","from_bls_pubkey":"0xa83cbdf40e5c4bdb4e9802d94d765c70150d9926521b0ec4d273e788b83a9f304694e75d2e381ce631b24121ffecc9d4","to_execution_address":"0x372cd043f2dd36351da1acbb7f0a6049a4d05e88"},"signature":"0x998cb975f863e95fd53ee74c5beb85c19b8b3858773432a371e6a3f229f67b653165adf3bbaa6015dec12a1d13cc9d5c080915c55c921fb056fd32e9da643d96dcbe83ccd456b3072dce2610d7b96e69488468c83d26b7251a466571a5424351"},{"message":{"validator_index":"1088641","from_bls_pubkey":"0xa7f8aff7b912b6363efb810f2b661643624ab914b034e78d72397ef84fa04862dee94c9b2f46b872fe852f197f558fce","to_execution_address":"0xf676954331d2efe5b23eb56dc3622d4ce2ee543c"},"signature":"0x94773ae9e3d605ba2612dbea934955e7af438154f7572136c97bc3f858144ab833aa7bf6caee2a2c4ad066d36b1d0c3501359ff577de486f81a5210258cf63ff45bb0cf91526eca949dfee984c6757a957f9c7ddfb8b599d3cfbec0b778e9396"},{"message":{"validator_index":"2008914","from_bls_pubkey":"0xa6c59055cc0bed5baf1a815f59d9d1cbd7aba1a4fb8d83de7310ad85640524318110a6a16f5bc141a81c34e103d9b7be","to_execution_address":"0x7fdbcd4270dd970b44236c31de8ee788b75533a0"},"signature":"0xa28a524424e49283f416545acfa1dc063866bfe9892c60370705cd8133fa949d724421b1ffff5a757d573391ab2cd9fb043022aa8354e4e93c91d126cb40f9ca7f7be8e8293be5a97b0eeb79df9c051f90e4d97c9157efd9b64125cddfc257f3"},{"message":{"validator_index":"1624165","from_bls_pubkey":"0x83190d18858cb148b28aa89911959562dca6653f220f8b4878a5d580958dbb3ca184d97880f7c2bf0fa970cd41b70dce","to_execution_address":"0x3e269342afd150bcd8c074e323e7b48bf5732954"},"signature":"0xb469d5c6626f1c42e7e914ecaf79388360d2ad196f2edc1f7b6088422b4f32f43f36b12898bcccc46c5ed15285ff0cd503f0ba5f6def9b4c1e523e941f1de95263bcdb014637c359464eb2cb974e06faa164827b21ee15dd68b2375b7e76a700"},{"message":{"validator_index":"2700421","from_bls_pubkey":"0xb7ff61729743df75a8b0b7e5b95617b9aa407e2e6a30cd8101c6a4c851b2cc366cb80e68a19a23e19625a596fdd1ec61","to_execution_address":"0x64688742ef680f46c246433acaf8dd25027a2778"},"signature":"0xb29e4c2b22ba8da0947be521fd1710125a95d9465632c3d2b5cffafe6e7070f4a6bd71385760b2b1670add9981225a18060be73e5f486535919fd3577b7ed850b3108dfa0fcc9215cd9d526295616e09619e07977ac7208edc5a2af93835a18a"},{"message":{"validator_index":"2471654","from_bls_pubkey":"0xab0a4039f2f00ce09018af228a696b7b87c7bfc111e7782bf7a3ffb423c681c04fe335152668abc7d20b6e9a9bc4933d","to_execution_address":"0xc090084330e9de5aaf85637f9a361a8678373dec"},"signature":"0x90f650befec00b055e261a38b4ea0bc65a0d71fd735b46f8387f565fb0d31494f90645c40dc07b0f3ee26d7807b82bd914d4d7c81b3ffeaf9a32730ab7cba7265dd09a0e0f94ccdf2ff3bc53d49fe99a488cf7238200ae12e6c59960e71d5877"},{"message":{"validator_index":"547910","from_bls_pubkey":"0x83e4d3825bf069cd0b19ca5072eda2f7d141de02c9e65f9c0733c18252c1552cda074eb613e1f435a880262de2a4672f","to_execution_address":"0xe6d2fc4270809de49a0b32d641484320853d3b10"},"signature":"0xb9b292bb598db604142750cb641cc511a9081656efb8271132d7e0de30554dfed4b16e418100d9085951c1502d6ab657179da8804cb08f1c69b1210ce94bdf6a0b66976233a34a0acfb4b947cdc192cdbb8576a3453e50143e7afecc8cbd264e"},{"message":{"validator_index":"163161","from_bls_pubkey":"0x86c03ea323e3551ef39c8c4e5355c4d3a2cceea3c8acb3d947b39e245d2ffcab53b4479c670d8b268828fd4fee89eae7","to_execution_address":"0x08400642aee83f31d60723f5fabaa1c58bbc1104"},"signature":"0xb58eaaba3ba51d7098d65fbec3829ace78576a2276fd9c97c293aabdb634a2c50f52611f48088da5d4a5b5fa2c5f4c0513d8dd91c8534b50a7b8ae0072583612610ada0c81a261641c66ac542428cedf20f1b954ad03505fc058b40ce0bf4182"},{"message":{"validator_index":"1083434","from_bls_pubkey":"0xb54bda7a570f90c2d38e836a3a256a6a2230a6384a29af7dacac3eff1a981d3f50918e2b546b3d78e72a545870b5ec9e","to_execution_address":"0x2f82fa41ee7ffebac08df14ba1ccca5f98c20f28"},"signature":"0xb851b39a32955a7f05acd7707c6859df4ee2b1472996d6a805a61e14415db550a92a7eaaff14a67e858a9d3633306efb12a62ed84f76387a84deefe726afcf2fb744f616f67d144411689343e6e0dea7a88b57449b2cdecb43cf0b5a80887550"},{"message":{"validator_index":"698685","from_bls_pubkey":"0xaa3588a5cb0b5d8eadd316046b661044c97559a4350464e338456c5b728880b4750b94af5fcaf478e3bbc86ac3e12d0b","to_execution_address":"0xeeccbf412e74b76b542bfafde5249862d6e005dc"},"signature":"0xb99cdab802f2f2683fabc52c8ea095386730c43694a9a5f7a42033e6dea53f4896092b207f56b1402c5c69937a3e2fb41958e001895bb43c2ee1e360da601e1ac56ffa8bd5371b1dcfe85518f297f94c02cd4981a5961201d2c2fb4d2a15c888"},{"message":{"validator_index":"1930923","from_bls_pubkey":"0xa55017fe14158ad9caf1d11f971b71b1941799466d063c6c77d7e41e20d5b74fd7fbf969243f3f507f8c04a5f76c3722","to_execution_address":"0xb1ec6f426f978c599752e0e7181c305a1b8623c0"},"signature":"0x917311e1a5f7a689ceee1af61f06519a3e4c6d68a4af6f4d24da0f57a2246c963c964d0e576607222856258c0e34b0b1014b68dfe481454ceaf521bc6f87c15e6a21f6db1c303b2042d5857ad4506f00dcfdfc5e65bbaf1b4ee9fe7ddf7b738e"},{"message":{"validator_index":"1546174","from_bls_pubkey":"0xaa865744dac51436c21adc2a1373eb6b8d407fda20bc67492d80a43812dd2aedee636192b1fa742570ffc2833ec58b29","to_execution_address":"0x70373542af8b450a2cf0e8995d74fd5c59a41974"},"signature":"0xb875609f4aa01bb03c08b4f13459fa7696b969fc5e8440c89f690478820b8b5b4ad75e7fbf03c4b0e919cdc80b07857604bd81f75128f2bbc61861d0b5a7744e21eb4ad008f05b46be2c2780900a7913abc2cd3591390f29e05e2d5b2dba570b"},{"message":{"validator_index":"2622430","from_bls_pubkey":"0x99c16f59ffb2e2138feb9b6f1804752cdbfe3796e20c52a3ae489f8348df4c1a9614cb6ce6860bed51544aaa1d22cc80","to_execution_address":"0x96792942ef2204941676b7f0048626f766aa1798"},"signature":"0xb9196e6383fe7a9eac1809c48fe10e45ddf57d6ee7946c22d48873b45064a39e66f861d7b36d82699f4b1858c3ef093f13fd758af1ff4deb2b7e1ffc7a7179306726cc556abddafee546ed2a6d7c4b17a1498494d994ff4188a2edf3c261a683"},{"message":{"validator_index":"2081698","from_bls_pubkey":"0x9786334738ef86988505249871273257e40b3e3c47995e751a40a52bc46f915fbaab7e2b1802ca3dcbf2db0567e8c9ae","to_execution_address":"0xb8e632412d8ba6e05272a80fbcf8849c6c29ee8b"},"signature":"0xafeb0dbcb7463673415ae2897857e5b13c4299ee60273bbc406c38f4e805cf7bc147ad40d7873740f3d261bd592574e618efe8f93cf439d13db8b86ff91918c57578b1080c6e51cf121d816eb3e5a2003ad57799d24f1ddbe495724d9e5a292d"}],"blob_kzg_commitments":["0xf14921410d6e44af323bde913793c2037f32eb41f938cabb3c5db5168485eeb88923ac822543db013af49d53be186cc8","0x046b1b41adb923f4277e45bd0b1cd7d08535ead3b001f37569def8de5fe6a543214372e11fa4bbef810ce1ff85e0cfae"]}},"kzg_proofs":["0x3ece09418d9cc1c206477b3f86b61438983ee789d35b6da4f361c337ee08cce3e8a1c4fd0fc75cb95755aa04da37fb61","0x51ef03412de8a007fc89e26a593f29059e41e61b8924965e21e30600c869836e7fc18a5c09283da79e6dedb0a2ff5e48"],"blobs":["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","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"]}} \ No newline at end of file diff --git a/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockContentsELECTRA.json b/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockContentsELECTRA.json new file mode 100644 index 00000000000..845045854af --- /dev/null +++ b/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockContentsELECTRA.json @@ -0,0 +1,421 @@ +{ + "version": "electra", + "execution_payload_blinded": false, + "execution_payload_value": "108477972351052331695947002912406997250600692969108946699443471459098753735725", + "consensus_block_value": "1339858616463813965601097196322078011440769170848634627274135136300100178872", + "data": { + "block": { + "slot": "1", + "proposer_index": "4666673844721362956", + "parent_root": "0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef", + "state_root": "0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e", + "body": { + "randao_reveal": "0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71", + "eth1_data": { + "deposit_root": "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f", + "deposit_count": "4658411424342975020", + "block_hash": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + }, + "graffiti": "0x0000000000000000000000000000000000000000000000000000000000000000", + "proposer_slashings": [ + { + "signed_header_1": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b", + "state_root": "0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb", + "body_root": "0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486" + }, + "signature": "0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483" + }, + "signed_header_2": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6", + "state_root": "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "body_root": "0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1" + }, + "signature": "0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1" + } + } + ], + "attester_slashings": [ + { + "attestation_1": { + "attesting_indices": [ + "4585702132744102314", + "4590659586689121994", + "4589007099177470570" + ], + "data": { + "slot": "1", + "index": "4580744678799082634", + "beacon_block_root": "0x17348c3f2ad0733f4b47b34442744b4a2e03a79b1f52c8e8922ee71060a05b1c", + "source": { + "epoch": "533653615", + "root": "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06" + }, + "target": { + "epoch": "538655350", + "root": "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0" + } + }, + "signature": "0xaffb36fe3e48b5c29794f85515b9a3adcd4206fec6dddac6926d0e985d96a9ade0e427f911d56dd90f2644af13e9740509147d149defa9b0763eecba616e0815e9a91c25178860be7d4196a9814781a4576ba7bc6398ef16b9bd5f88c4143bfb" + }, + "attestation_2": { + "attesting_indices": [ + "4585702132744102314", + "4590659586689121994", + "4589007099177470570" + ], + "data": { + "slot": "1", + "index": "4628666713557758827", + "beacon_block_root": "0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390", + "source": { + "epoch": "537693478", + "root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b" + }, + "target": { + "epoch": "538078227", + "root": "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb" + } + }, + "signature": "0xb7720f152c38d7172a82186892a68440bc4d285cc8aa92c1f017f93d5f61a29cf51670e4f944648bd8df82d4d6eae00615073d439389cdf35fbd7670a07ef8407c7c71a16be062fff16f351737ac99f006817ba43a295fe5286dfb4ba7116e07" + } + } + ], + "attestations": [ + { + "aggregation_bits": "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", + "data": { + "slot": "1", + "index": "4615446843529318507", + "beacon_block_root": "0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6", + "source": { + "epoch": "536154483", + "root": "0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0" + }, + "target": { + "epoch": "536539231", + "root": "0x82a81c3f096d065c7e3f5d7df79bd182a53c9471a737cfb9f7c4e9ed95d0f767" + } + }, + "signature": "0xa9aef1e37252740dedc5fc9886810459f7484555aa59fb3876803fc4924149cb471ffbbd9be5324d952efafc3de4c5f705dd02134916b2afa02194fe90a8d1e8f58ebcfe0d33d0b8a97e71a3f7591cb82c37ba531c059a684b581d3857f05e3c", + "committee_bits": "0x0a" + }, + { + "aggregation_bits": "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", + "data": { + "slot": "1", + "index": "4541085068713761673", + "beacon_block_root": "0xe24dff3e29e762b4488e615619483884c44b8f4b37239b5cdc4a3bd7d9b48c1d", + "source": { + "epoch": "529036628", + "root": "0xbb0b0b3fe94fa42a5e0893ff71360feab7459127ca9149e88148b44625f31d08" + }, + "target": { + "epoch": "527882381", + "root": "0x2ed2e73ea915e0c71d9afe03676b8ab8dd578b9311463e45934f49f843386a48" + } + }, + "signature": "0x958ab38cce5390fd750e87806f32ed8993a175bc3ccdab7ce2a40c23ac6117b603d5ae98d44a9780cca1f32d28bf5176058ef667b17fd95f13e047cd9cdebbf19f5270ec5a154e2ce2283da513c9ad05c26f10b0a65755eab4b1ed6f42175027", + "committee_bits": "0x04" + }, + { + "aggregation_bits": "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", + "data": { + "slot": "1", + "index": "4526212706878702633", + "beacon_block_root": "0x41f3e13e4961bf0c12dd652f3bf49e85e35a8a25c70e67ffc1d08cc01d9921d3", + "source": { + "epoch": "527305258", + "root": "0x51977a3f0ab3110e2a10e9c6bd0e89b1410ca45142ac42171bb2b169efc281bc" + }, + "target": { + "epoch": "532306994", + "root": "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7" + } + }, + "signature": "0x8ce27ee66d80548b04b029a68bf714f7918fe9b91c706050317b117786daa0dde1ea1ef9a8cc79bb41d6b7a4d661e30d0023df755b5f24daddfe6eda547945d49ab8796bdc3e63d75fcefabc8dda7f9b4d78292e8827948a5ebfa1f662db6ed9", + "committee_bits": "0x08" + } + ], + "deposits": [ + { + "proof": [ + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672", + "0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672" + ], + "data": { + "pubkey": "0xb94235fc2765496162b52009ab14fa6d0d0ed1debc25fbbd1fa6da8c64b58e5edaf39419489b556cb563cdd1d08c2eb0", + "withdrawal_credentials": "0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c", + "amount": "32000000000", + "signature": "0xa8d1b8a3f2e7d1f9cacf864d93be09c810406e24e9074c43a1a4323b16b045d428d23fa0762b8bbf203b452d9c8495340e065df1fabb6d1b56b3435d227afb2470f722aeba88fe4542eb8abc2329a6bbb965502fc5ee6ed7837ef9c938573fc3" + } + } + ], + "voluntary_exits": [ + { + "message": { + "epoch": "4559262388392254378", + "validator_index": "4560914871608938506" + }, + "signature": "0x8166b2ed13e982e6b9f05d30f42681b826099135a533d2614ef5f4f59811714245db0e1821a644859559f97ec1e614bf08b2edb294fa2edc1527f46596399534af23c98613e1b74c01871bf1dd2af9618bc0ba23ddfce8026b897cdbba8c1bce" + } + ], + "sync_aggregate": { + "sync_committee_bits": "0x01000000", + "sync_committee_signature": "0x8077d47ad0fe431af45ca6ed24efda0fa9c84364ee8af5f9e83f53b3e5934961197cb31b062dcc3d5dc793ec6de565960924b65d0535f3833ecc51567572959e2849e470be8b6a1f21e2c735552595e9765e66a599d645d33fa3746d409fa122" + }, + "execution_payload": { + "parent_hash": "0x10e23f3f49a7cabebfadf178016756b47f2a9a056183da5ce5bd543c778bab27", + "fee_recipient": "0x23033a3fe9f2a903b4f058a4d4ef6a81852d9997", + "state_root": "0xe5ca603e08e1eff7259e45ea6bb662256d9d74b1724ee8feb0ea59f6e2ebe3be", + "receipts_root": "0xf8eb5a3ea82ccf3c1be1ac153e3f77f273a07343291711b9de6b9dbebc4c9b49", + "logs_bloom": "0xbf886c3ec849316e3b187793c3a4398b6097768d06bd968a54e8d2652d2a75a96ab3fe3195f647a70f258bba8e2e6afac13b68e2faa5061068306ca2a652ccf6becd6c58dcb63addb97feaaafc56cf440e920f1f1ee6ced53f0d6efd1209f3f0daf37dbc30149935d6dd2451da4f84d128262214a2e844c3079f5133690bbe15801b8e32f99a0c4144a1d705eabbeb18d2d32bd6c6f4f48b71b21578d4239b6197240a4ff3e0fe9aa69c35af5f59090c355feb7b601c1284334d2e5933fbca40a7792d1daddb890ce4e7124d627c763c5d9d79b5597a8580854a297498bb127e6040a3260c87ac53a8c4e69591597b0fb92cfdf430c136b9a5079a5dca820f58", + "prev_randao": "0xd2a9663e689510b3305bdebe972d4e58669a751fbc85bf448269162e078b2c34", + "block_number": "4488205580010065800", + "gas_limit": "4486553096793381672", + "gas_used": "4491510546443434056", + "timestamp": "4489858063226749928", + "extra_data": "0x7ed3313e083eea1ecfb57f4508fd068e9fb56c4125942ed01ef47538b5f29e14", + "base_fee_per_gas": "66016772192738304600348427229332912155053403334447944293225380805794998736543", + "block_hash": "0x58913d3ec8a62b95e52fb1ee60ebddf392af6e1db902dd5bc3f1eea7003130ff", + "transactions": [ + "0xde78143e27b846", + "0xb736203ee72088", + "0xc7dab83ea972da", + "0xa198c43e69db1b" + ], + "withdrawals": [ + { + "index": "4517950290795281992", + "validator_index": "766262", + "address": "0x4dc28f3e0884f5d07b860b8fce6fbebc3b857c21", + "amount": "4506382903983525800" + } + ], + "blob_gas_used": "4511340353633578184", + "excess_blob_gas": "4509687866121926760" + }, + "bls_to_execution_changes": [ + { + "message": { + "validator_index": "2227267", + "from_bls_pubkey": "0xaf8e9748b8dae2368d451ff7e57388b5a9de96c48d5421573713a104bd1d7d19a8fedc6c40cc0c63f030cd788d4b79c7", + "to_execution_address": "0x42fb7d43b1006df9874a521b12867f80fbfa5084" + }, + "signature": "0xa8709cb09f500debf2bbb6855e09542e63ef41d16f12fd72cffe162f228a3bd53079d54205623296544d6a4e803d7cbd03b452f30def23fd44a939ec651d16f8b2380c6c05ed8de42f6332456e214a3327bf9081373cd174c5fd88c73f7067be" + }, + { + "message": { + "validator_index": "1395399", + "from_bls_pubkey": "0x849eaedbe546193c419188b4aa3f2d222b377a136c5defe659dfa84b5ff83153490a330f25a7ca39243bcd11ebace030", + "to_execution_address": "0x683d7243f1972b8371d02072b997a81a08014fa8" + }, + "signature": "0x860ddd021623b0457093e3e33cec56fe571fbbe8a52a68ec6660579165513eeea8dc706ba31cdd09c5c7ab60765182cd084061dcb29dde1dd5d5956b404b389f599a34da02cd3a50385a148dd804110335507c0f05bdfdc495e4a4953dafac94" + }, + { + "message": { + "validator_index": "1010650", + "from_bls_pubkey": "0x8485b34d0bf20fc4d60d681351091329d0897bac95042cb32b979891d0d5f7f752df602f71f63b1d466017ad2a09b8a0", + "to_execution_address": "0x27883743308ce433056e2924fdef751d461f455c" + }, + "signature": "0x98536cd2647e9ae4add0f9ee0897f9c2bc423061a913bb3f1d5b79d2e3ac3090728c5023a892b7440c6cfc2fff73dd4210b61a2c7ad48282924dfe7c6c6f4884353d98d629b374df14b429a91ee58d18a80defab79fdf5cb71224fec86c022f9" + }, + { + "message": { + "validator_index": "2242888", + "from_bls_pubkey": "0xb62392bd8fa27ebbf0cf05be5bda4d08cc63c65e26ee59edc9a002682513972e9e5810163d19e720b078ad5e45dea8ad", + "to_execution_address": "0xeaa7e74372afb92149950f0e30e70d158bc46240" + }, + "signature": "0x895d52f7e0948110bfcd91fa281928e1c76841a86ae348b51e1c0bb9d10bce59917d950c415ac89c1099eecf840f62f0015790d194a97cabb85ba45d5ca678a2c7acfb4d86f22f430c7292bec30f1f0a24125aedf3132afd0a76b6ae0abef7a7" + }, + { + "message": { + "validator_index": "1858139", + "from_bls_pubkey": "0xae7908cd2718d6801bc1045d733f3c8367e3125c163784df4d34f356f899dad12024a9219f126e63dacb03ac068101ea", + "to_execution_address": "0xa9f2ac43b1a372d2dd3218c0743fdb17c9e258f4" + }, + "signature": "0x9846a460e26f9b19bc8a79f50838489e2764fcceed280b9f8729d38d13b6154bb69a8ab360a7cbe0c80a3bc7e92f5fee0212311895f198f7ca04e838530bd79c2814c2d0b4417c3f760727b92d279c91ccd6c94a08924d7402dbda81a2872ba2" + }, + { + "message": { + "validator_index": "2934395", + "from_bls_pubkey": "0xaa7ec4a37dae722143cee2fabacc1e11964fda925d7dc00efc1c3b3a537f414237ee98b5af27a6231ae5097e4a133529", + "to_execution_address": "0xcf34a143f13a315cc7b8e6161c5104b2d6e85618" + }, + "signature": "0x86c8e92840bfb3b3ab773a6c3f4bbdc36416746bc710630dec288404296db89f63eb25d648a0795e30e6870ea5a6f5b70bf684cbe96b72671398e89a8510991dca3110bff970cf1abec6c3bb3bfd7ba1b37ac1b973ac024bcbad0287d47aa65d" + }, + { + "message": { + "validator_index": "2393663", + "from_bls_pubkey": "0xb4de3568fdbb0af339856e6106dfd7808879d0564325ec1deab8e8932c4d173a8d7b04a546a9de867619730b512748b1", + "to_execution_address": "0xf2a1aa4230a3d3a803b5d735d4c36257dc672d0c" + }, + "signature": "0x8a5025a2a1543e6fa0fd574add3bcb06f96df170dbd82f51995a261559948009eefc0c8fc2c474c387cf52a8c5a698940eeb1fff88b70b5331be065192f46e47c765cbb3678d19a6a84f713e9c9464730649720a6182ea2964188a8dec26c2b4" + }, + { + "message": { + "validator_index": "469919", + "from_bls_pubkey": "0x8678ff3eff860e3ea75396d0bb0d548326928ecc62c8c9b30b58f8f3be02e3099ef80f47a13c7fd828412ba9f990c25d", + "to_execution_address": "0x18e49e426f3a9232ed3aa68c7bd58bf1e96d2b30" + }, + "signature": "0xb47bdd50d8e3ee31806068b3555ea1fc6771e2caf4b06d07394444468feec69e9d153e52ced5b5cbb5f8d44f2e981a060a691dd8cd0d86c4d7928bb908eabca9c2520e9033cfb4e5f13a80d30d4e8de24eb5a09a0e0b734a55811f13edd2fe6a" + }, + { + "message": { + "validator_index": "85170", + "from_bls_pubkey": "0x82b07707a61c37b860d0d290ec1c330ad73d0f5970b72c198aaa567ecbd2d2d08e884f2322519c2e17ab2cc3e9bb26de", + "to_execution_address": "0x740c2043b0ba6147da79c6d14c13c8515f2b41a4" + }, + "signature": "0x8008c559949fc9cab7b9b663aeecf3583273f07c7081afc5327ea39297f5adc1f1d8bb8d9485f1fb157a8bcc291625fd087e435b653ef0020f3fb8e4dc7ba04b6ebc64368aed53b868638cc39a536c0c077d6a08a4831f06e9145d328a52774e" + }, + { + "message": { + "validator_index": "1317408", + "from_bls_pubkey": "0x8a5997a79613125f1de5bd526981865c391f914492bf08bea98d89e0b212f554bab770783c094dc2ef1229e5cf6febc0", + "to_execution_address": "0x9a4e1443f05120d1c5ff9428f324f1eb6c313fc8" + }, + "signature": "0x877005ef02509214e9ede55f546c2b003c0209b7d885ea680d76369fc415180ef4fbbce332fce18608d3533b8d6d284603e52bc79193b0b2128c624332fe1bb1d1e1956361333e0ab171f1bdeee927a169d2ab78498189a9e8f4036cb47b77cf" + }, + { + "message": { + "validator_index": "932659", + "from_bls_pubkey": "0x8af5874a9623513bbb3200f80c2679f001ca294967e33f1e201f6720e30f3c8ab69492f3dab696b485436280bd5da4b3", + "to_execution_address": "0x5999d9423046d981599d9dda377dbeeeaa4f357c" + }, + "signature": "0xb21c09e06746c9cafbb504cf0aced08a807b87f62d57b526d28277802395a420321c8510b91b5e835a9fa47e6cc27d240d0991f1a05798ec502acd18dd8566ae675a05579e71bc8ba327ffb5f92c66c1f58ed89bf2804863cf50b958e79add78" + }, + { + "message": { + "validator_index": "1852932", + "from_bls_pubkey": "0x95e6bd6d5246d58b9d56e43c1490b8dfabe87ffc399721bd63de8a38a7a6bcab8399085f3ed777a668f857f591154b73", + "to_execution_address": "0xe2fd11426e5181a7eb81549e52a9782b7fb613e0" + }, + "signature": "0xb33229dc7bb509bee6290ece9d436db0477fc49ec3cc26e1e298eb72d62d0b4d28e72b271c0c3a9b9f86c44c883086680dc51747dd535a7b0b693302eadd8bf44f802fac281dc91025509a5c6df8bbe7455a3f30d32b2cc27c2322c7f00212d0" + }, + { + "message": { + "validator_index": "1468183", + "from_bls_pubkey": "0x98b245d4ae533c7648fd14a7858d17a792e7919a81c31f1db0dd1c0beedaf0fe7c7fc60be0b446238fd5e5c94220a538", + "to_execution_address": "0xa148d741ae453a587f1f5d509701462ebdd40994" + }, + "signature": "0xb6df5347cf18c72adf3ee1e2e5e942d8b3b7ab160b1f66d4991bab95e7050f302d723406d3410b9275700b3b998f2cd517c4da35e0294235f656d5c53cabc553f02b6a8f0e14a74571029f380c52a935c0230f4507ac486e4cf01ede4d04270f" + }, + { + "message": { + "validator_index": "2544439", + "from_bls_pubkey": "0x9866c028838d222cfed5b1ff8215618a8d6a81c3e96a34759e78172fd2d18521fdf686d1601a860a38d3c1fd8c9e22af", + "to_execution_address": "0xc78acb41eedcf8e16aa52ba73e136fc8cada07b8" + }, + "signature": "0x98ffde69b4d92a4510b5d42ae9bcc05315ed0a20fab2ff6fc8e416678f150d7bfb961da6774e86213ee711a2b065c3d300a13fcf630d7f303c59d848ec47905d2b439e7bb4f3348b6ddc448aa00f7c6eb6f64513182a3d335e2753f66cbec83e" + }, + { + "message": { + "validator_index": "2315672", + "from_bls_pubkey": "0x84768946243cfa8d15223bd7222c94a5ce4a610b7aea979ac29d5b6f30e721213ed5b3cef3b4d2e700251be6a3d4dbfa", + "to_execution_address": "0x23b34c422f5dc8f657e44bec0e51ab2840981d2c" + }, + "signature": "0xb9014738ce2ebfe44a8255a53e34b604f223702435a966b81276bd7967cc1e172a4dbace09be70a1f73b300d83a7a8ec161cdc911b167a8a6489def11edca95a3587eab704e98325ce29eb4f86a477755421b480ca39020c82f07e4977d9e859" + }, + { + "message": { + "validator_index": "391928", + "from_bls_pubkey": "0x8b37bcb9abb306bad986453fe618bd0161b29c9f5f1eee2aa91f44ad2ecf75604c38975532425ca87de0e7cdf3cbe44e", + "to_execution_address": "0x49f540426ff48680416a1a43b562d4c24d9e1b50" + }, + "signature": "0x954da68af7adf486693e9213a63a082fcf1b1ed99c320314b73e64c322470329df27c891348c17b92dc7972dbc7d9b4215c7746c756c1aa2194c7217ab902459290981a0905683fa8563a2a7241f2bc3a3d6e4fca48d9fce1c6c322c4835dc1b" + } + ], + "blob_kzg_commitments": [ + "0x83582f424fd7244f213350c530fd112a5fa71806352876480227941a471efbcb4c76127b24d689436e978f5ff3327e62", + "0x96792942ef2204941676b7f0048626f766aa1798ecf09e0230a8d7e2217fb256e395d8d91f376a31b5afd20bbafae148", + "0x594150410d114a888823a4369a4c1e9b4d1af3b146f383eace5399d4b17e3363cc267b8c513bd892003285f184da4d95", + "0x6c624a41ad5c29cd7d660b626ed53268531df243fdbbaca4fbd4dc9c8cdfeaed644641eb4c9cb880484ac89d4ba2b17b", + "0x32ff5b41cd798bfe9d9dd5dff33af5004014f58dda61327672511244fcbcc44d9de7eece5c7917b77201ff98f64a86c8" + ], + "execution_requests": { + "deposits": [ + { + "pubkey": "0xaacb0e7f3717c59e23c32cb07ce03be33c2bb8366da2d27a9954b77f2c9198a1b5f3aea585faffcdfa4800b592c4d5d8", + "withdrawal_credentials": "0x0100000000000000000000007f8344414da8081272a9728d415e47355920f1d5", + "amount": "4701376009451598829", + "signature": "0xa9bf2689fe47ca9ac1fb90da3b08259115adab480b4f387669f209ee7747f7451af8f61e4a9c057bc33ffc18f0b08c3407be0a59b8c61c741572f5d28e2a1f6af0fc17db7c3f48901c9267606c3d7831a3d3647b885946fc95fb5689d24f7b8d", + "index": "4691461101561559469" + }, + { + "pubkey": "0xb8fa03e47468016f15b89212a91f203194684e0cbbac07b6cd428fc7e10cb7d8a363985b46972eedd7bc434fc701c4b3", + "withdrawal_credentials": "0x0100000000000000000000003ece09418d9cc1c206477b3f86b61438983ee789", + "amount": "4684851168694822957", + "signature": "0xa529495633ab9ab138c0756646074fc7753fafbb44389490ddd46048f29267f6b85e46abbc1fe71c42fc98513ed0f6f800ebc9eaa04b484e29af7d7bb0c38b5e088435aee8583a812545b3057c184a4634957604ec0647d1fa81da2d15a5f198", + "index": "4688156139423158509" + } + ], + "withdrawals": [ + { + "source_address": "0x01eeb941cebf96b04a6e6129b9adac2fdce3046e", + "validator_pubkey": "0x97995c0a4cf28bb77bfea20753ecd1e3b3469492921c9542d99a1e81355f6d09ea4cbcb35e3b8f1240e8261d20da657b", + "amount": "4726163266291795342" + } + ], + "consolidations": [ + { + "source_address": "0x60939c41ee39f30814bd6502db591331fcf2ff47", + "source_pubkey": "0xa4a90125ab79fbbe706de307f1de84a6b0dc21adef413c6a5e91ab58e575164bd13c0517a318394a56adab9326607e82", + "target_pubkey": "0x83feea64397a7a9d3fbac0b9a16ccbfd63c4d4fa5d0fd8bbfa13739148e752ce1e9b1e01654b56cb56a196fd8d64db3f" + } + ] + } + } + }, + "kzg_proofs": [ + "0xf99b6d41ed96ed2fbed49f5d78a0b7992e0bf8d7b707b847e9cd47eb6d9a9eadd6889cb26d5676ed9cb83594a0f35a15", + "0xa250734616e5e744f48c493c6d932629d574d0f2b953d406c14b88999cbfbe0227821f9f2e60836eaef3cf363a0cfffd", + "0xb5716d46b630c789e9cfb067411c3bf6db77cf84701cfdc0efcccb617720768dbea1e5fd28c1635cf50b13e301d462e4", + "0x7c0e7f46d64d29bb09077be5c681fd8ec96ed2ce4dc2829266490109e8fd4fedf74293e1399ec2921fc349deac7c3731", + "0x8f2f794676990800ff49e2109a0a125ccf71d160038bab4c93ca44d1c25e07788f62594033ffa28067db8c8a73449b17" + ], + "blobs": [ + "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", + "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", + "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", + "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", + "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" + ] + } +} \ No newline at end of file diff --git a/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockPHASE0.json b/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockPHASE0.json index 6e2889bd77b..2ddcb9e837f 100644 --- a/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockPHASE0.json +++ b/validator/remote/src/integration-test/resources/responses/produce_block_responses/newBlockPHASE0.json @@ -1 +1,198 @@ -{"version":"phase0","execution_payload_blinded":false,"execution_payload_value":"12345","consensus_block_value":"123000000000","data":{"slot":"1","proposer_index":"4666673844721362956","parent_root":"0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef","state_root":"0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e","body":{"randao_reveal":"0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71","eth1_data":{"deposit_root":"0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f","deposit_count":"4658411424342975020","block_hash":"0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379"},"graffiti":"0x0000000000000000000000000000000000000000000000000000000000000000","proposer_slashings":[{"signed_header_1":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b","state_root":"0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb","body_root":"0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486"},"signature":"0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483"},"signed_header_2":{"message":{"slot":"4661716390776343276","proposer_index":"4600574485989226763","parent_root":"0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6","state_root":"0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26","body_root":"0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1"},"signature":"0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1"}}],"attester_slashings":[{"attestation_1":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4580744678799082634","index":"4579092195582398506","beacon_block_root":"0xded09d3f4aedd5706b7e7dc2c7d90de31bfaa9e5fcf74dba08ab1cb8d17d357c","source":{"epoch":"533461240","root":"0xed7436400b3f287283b1005a48f4f70e79abc311779529d2628c4161a3a79565"},"target":{"epoch":"538462976","root":"0xc7324240cba769e8982b3203a1e2ce746ca5c5ed0a04d85d078abad0efe52650"}},"signature":"0xab7a632a4707b1f8280944e479d239726caec1c6a73e8cc29eb98aa9cbeaa97d4c4921bdb8cd977f07a172062b8143be0d2db585dd2e8356897ae04f59234c800f2a6a2607a9491de5c57a92fbd8ad6e3f5e525618a1481b1f1446623e8765fc"},"attestation_2":{"attesting_indices":["4585702132744102314","4590659586689121994","4589007099177470570"],"data":{"slot":"4620404293179370891","index":"4618751809962686763","beacon_block_root":"0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b","source":{"epoch":"538078227","root":"0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb"},"target":{"epoch":"536923980","root":"0x603b1340cb04640f42436c5e3e2973dd9ebdbd7dbd491e2f7593d612c2ece1a5"}},"signature":"0xa32991816eb9f297553b4732309a4cdba7b33287264611715b0ab3319bca19e581da6e2659912a4e0e94aafc01c488e30ffc96ed14e2a726b9d3c618405ee0bf54bf6ae7f2097465cb27ab8132ec24eb93d3c9159475304082f7f0e452b93b65"}}],"attestations":[{"aggregation_bits":"0xfa79cdb89d0d51c5cdd001b7425c6d726750a9d5f89ade6ed9890ce3a706140c399a5e10c90a819094b65322dac7501f7c75471e69d4567358d8ca75f7c1b3133ebecf006b369a1f36efc5f2b706d5922ff98c58a1825a53a864376658f816600cf021cea843d4396502bb9c74d1510afe26036f89f783b4f5c7bacb6649c46f217a6af835f312d6fa253d2bbc83c07993f4f10de2ed2d952689379dbe4f794c1a1055a6b364d68e038deec9667f576b3b9eca5fcadd6298f181e1edb876efc3d0975ae14ae9a0ad2f1836d4c3f1080a96d8ab7c43b34bb2eda895ff66be698b363cfa4be33da3ec94a1a7a90672fd12c4a59916bb937e78476e4f08e4f4031001","data":{"slot":"4605531939934246443","index":"4610489389584298827","beacon_block_root":"0xbfe0f53feb7ec0670c92703760d5d9debdccb8574d35ead15a1928fc05d1765b","source":{"epoch":"529421377","root":"0x95c9163fa9b8e5a07382c4a8ca24e64fab3f93035e00f87325462db67031aff2"},"target":{"epoch":"529806126","root":"0x6f87223f6921271789fcf5512313bdb59e3995dff16ea6ffca43a625bb6f40dd"}},"signature":"0x8f8d16b39e14569aab1b712e5c19ed51afe3600a6b017e8ab432f43a02ee720a733c33ef087d2f3653a9701e8d8a836301655b9195c0373b775c88ba1368e5d55354a70a3096bd26dee29dddbe7a4820e2b1653e84122beacbc01af7d93e6bdc"},{"aggregation_bits":"0x4ac567b296efbf7cf3209e87096a7a1a50fd523400113f917f6584a5a306f06b2d8da9ae858d47ff2594010089838efe41f19a78d9aae27c2ffde26f278b8681db9d091eb72e7cab3e449dfccd46a270693e1f88f197324e57bfd45573315cf9fb60d770937b32f7c0c6ce1581ec51e6b60f71acfde304dc917f2e0aa7872038b7d9140d15f7927c23a0490a74c2b0aca2773fed9217067e4444f9ca93874e4ff8407111c3efdb138b97c6d4957b6a70ec1debb283e3d0eb1cfef068adcffbf057d20fdc339eae03f0fa2613abdde8158a7fc40c3cfd1117eb6f8c4ae21d6b2ab4b57ae9a8653a34451aee6418c0c3609dc937293f5f5b346a7ab1a0d144185101","data":{"slot":"4544390030852162633","index":"4542737547635478505","beacon_block_root":"0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd","source":{"epoch":"527690007","root":"0xf56ef93ec93242f93dd1c881ecd04c51ca4e8eddeeebc3160acc7e9fb41544a8"},"target":{"epoch":"528074756","root":"0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8"}},"signature":"0x90309dd491ae6ed51917dc305a3d4ae68d0a0d4792c7eb59c193bd03605bd94e61cab37502de0ad3e6162bc02427bba80a798b3670d5de82a854094016cc298b265371345c0e3ac49fd44bbb9ba0d4fcea0c1a80cecb60e93921d907e8c48120"},{"aggregation_bits":"0xe8c9759f0840f980ae956b15fc383d992e7d4420d12ba5bf32f669f446ac6fa388e20e5ce96e9266dd98840179d2cde3cabd9a8bafab5dec9c2e89f7f78c989e690548603984803b80c82d7b76443194576a1ce49da5cfe56f56e83b745fb01b5f18ccc86d88f5a22d927e64ff0b8e880893abcddec45b268531c4a0697537dae643a24b1a36432f37d42962553bd39af71f37e0429b81470c11316aa39db074aa3f1df4124e7cb203debed60b885ffb9b27e46a1434e81bbd56566632d0729c0822ac415cbb67f25973667d88e58df9c2f058a0ae7f118c98cc448453b6fbe590363bd17ed62c2f808df61f2a9e593235eeb56db74b9dd15980189a5271468301","data":{"slot":"4529517677607038185","index":"4574134745932346122","beacon_block_root":"0x64b8743faafef0521f5350f290979d7e470fa3e3f8746bd14933f531ca233947","source":{"epoch":"532884117","root":"0x3d76803f6a6732c935cd819be98574e43a09a5bf8ce3195ded306ea11562ca31"},"target":{"epoch":"531729870","root":"0xb03c5d3f2a2d6e66f45eed9fdfbaefb2601b9f2bd2970eba0038035333a71672"}},"signature":"0x8c40f51a99fce6ebb9a4db5e80d715fff319e7ae523e46afb5d03c000d427e23c7a39e77e2af53851706283c8ca91d680997cb459386fbdff52c4d0ecf498e173717a838a792b210bdffaf476538628584a133899bf30dd5ce7056463b8cd683"}],"deposits":[{"proof":["0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c","0x8afa683fea95afdc0ad91e4937a9c6185315a1076506bd45a4357cc27fe5a75c"],"data":{"pubkey":"0xb1f8f6e731dbf6b4e3265fb857c7190adbfc7e6cc95ce2e8bda72be8b6ea3459f862310a2484c3b0ee33b30920f18c1d","withdrawal_credentials":"0xfcc0453faa5beb79c96a8a4d2dde41e779279b73abbab1a2b73c11749d2af49c","amount":"32000000000","signature":"0xb594382214f5bdd375de66c45e1c61a526c7b73fb166c72433bbd9c2a7ad6881244e61cc6427e0206a50b762a129d8830e8708c55761d61ce9e3b19c1bee13bc55daa13bdb07118efdbf57a588b8a64e6392d14f935e53b68933e3355b35acdb"}}],"voluntary_exits":[{"message":{"epoch":"4562567354825622634","validator_index":"4564219838042306762"},"signature":"0xb86aecf4e9673e9ac774883f03c46c2cfe59320e441abfc2e2bbaeda2193f58c57a3aec0ae63ba17d3b1cb81bd548689004773c1867cf047e1a2d5c3c51973fca33040cae49bee51bf4d2e23786f51dc5672bff5e9df8f7bc5fadae6be5c146e"}]}}} \ No newline at end of file +{ + "version":"phase0", + "execution_payload_blinded":false, + "execution_payload_value":"12345", + "consensus_block_value":"123000000000", + "data": { + "slot": "1", + "proposer_index": "4666673844721362956", + "parent_root": "0x367cbd40ac7318427aadb97345a91fa2e965daf3158d7f1846f1306305f41bef", + "state_root": "0xfd18cf40cc907a739be483f1ca0ee23ad65cdd3df23205eabc6d660a75d1f54e", + "body": { + "randao_reveal": "0x9005ed0936f527d416609285b355fe6b9610d730c18b9d2f4942ba7d0eb95ba304ff46b6a2fb86f0c756bf09274db8e11399b7642f9fc5ae50b5bd9c1d87654277a19bfc3df78d36da16f44a48630d9550774a4ca9f3a5b55bbf33345ad2ec71", + "eth1_data": { + "deposit_root": "0x6fdfab408c56b6105a76eff5c0435d09fc6ed7a938e7f946cf74fbbb9416428f", + "deposit_count": "4658411424342975020", + "block_hash": "0x499db7404cbff78670f0209f1932346fef68d985cb55a8d27472742bdf54d379" + }, + "graffiti": "0x0000000000000000000000000000000000000000000000000000000000000000", + "proposer_slashings": [ + { + "signed_header_1": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x32a7d23faa44fc04cc23dc3b560a55ade3deb2c393e9de2e6d20bdad2416c39b", + "state_root": "0xf943e43fcb615e36ec5aa6b9db6f1746d0d5b50d708f6400e39cf25495f39cfb", + "body_root": "0x0c65de3f6bad3d7be19d0de5aff82b13d6d8b49f26588dba111e361d6f545486" + }, + "signature": "0xb520c40e02457e0d3d61ebba3b04912f7db82a9a74132fedf190d94b32738dc62744644455959b4b4dc7aaf1e54064fa0f4aefe30696b7ed758c921d266402360e9abc003374800cd2aa6ffaa0c11a5cbfb3798b1816bac7be1e0c67c3305483" + }, + "signed_header_2": { + "message": { + "slot": "4661716390776343276", + "proposer_index": "4600574485989226763", + "parent_root": "0x7e2bbb3f2a737918a12f79e9a52da7e1fceaae0b6c0c82172425cbce8d99a0c6", + "state_root": "0x45c8cc3f4a90db49c16643672a93697ae9e1b15549b207e99aa10076fe767a26", + "body_root": "0x58e9c63feadbba8eb6a9aa92fd1b7e47efe4b0e7ff7a30a3c822443ed8d731b1" + }, + "signature": "0xa01cb4e18fb43a400024b67cd091680b8412ea66ed4a0d41f7ee611a87476d153e18879e22a5dbc98df9ea4ecd016c1801f1ee9411e103383c73c06cb5331b8377ef8f2f4ab67a4975135a59d9121279f9d979625d78f339f71aaaec565911b1" + } + } + ], + "attester_slashings": [ + { + "attestation_1": { + "attesting_indices": [ + "4585702132744102314", + "4590659586689121994", + "4589007099177470570" + ], + "data": { + "slot": "1", + "index": "4580744678799082634", + "beacon_block_root": "0x17348c3f2ad0733f4b47b34442744b4a2e03a79b1f52c8e8922ee71060a05b1c", + "source": { + "epoch": "533653615", + "root": "0xf1f1973fea38b5b560c1e4ed9a6222b021fda877b2c07674362c6080acdeec06" + }, + "target": { + "epoch": "538655350", + "root": "0x00963040ab8a07b778f467851c7d0cdc7faec2a32d5e528c900d85297e084df0" + } + }, + "signature": "0xaffb36fe3e48b5c29794f85515b9a3adcd4206fec6dddac6926d0e985d96a9ade0e427f911d56dd90f2644af13e9740509147d149defa9b0763eecba616e0815e9a91c25178860be7d4196a9814781a4576ba7bc6398ef16b9bd5f88c4143bfb" + }, + "attestation_2": { + "attesting_indices": [ + "4585702132744102314", + "4590659586689121994", + "4589007099177470570" + ], + "data": { + "slot": "1", + "index": "4628666713557758827", + "beacon_block_root": "0x3af91e408b6da58558bd9d0797174a4392b7bf5950b8ccba1a914f820d2b7390", + "source": { + "epoch": "537693478", + "root": "0x14b72a404bd6e6fb6d37cfb0f00521a985b1c135e4267b46be8ec8f15869047b" + }, + "target": { + "epoch": "538078227", + "root": "0x867d07400b9c22992dc93ab5e53a9c77abc3bba12adb6fa3d1955da376ae50bb" + } + }, + "signature": "0xb7720f152c38d7172a82186892a68440bc4d285cc8aa92c1f017f93d5f61a29cf51670e4f944648bd8df82d4d6eae00615073d439389cdf35fbd7670a07ef8407c7c71a16be062fff16f351737ac99f006817ba43a295fe5286dfb4ba7116e07" + } + } + ], + "attestations": [ + { + "aggregation_bits": "0x88e3aeac2cb7509e753b73880be4e95da67b35193a1a8d916d3a5f3b61c59b6d90d866ae7ee81a10a9ea025ade39ad5b978bd20bd2d2031d61e8aa7b5090b08248dbcac0698c25ea7b858ae37e5347010aa764962e4f70513d9e2488a9808d0510dcb3dc9385cc9c28ba4a1eae314e5c3372b3d2387836dc0750553f84b1b490b7fffcb2824b614596050fa2ffed45b30b7db4e67cd782cf0446b5448ed43cb01991cde29c15b0a29dcafdbf29840045c4a3d7e58b93ff391e3ae281185e49aeeed12188548d0dc8e904edc1c8a9831577d08b0c708dbb1784cef981e8363efb46d26f039c2561792d1a2e81218eec593aefaa25bb280fbdd25f8103381a51c601", + "data": { + "slot": "1", + "index": "4615446843529318507", + "beacon_block_root": "0xd301f03f8bca9fac02d5d762345eeeabc4cfb7e903fe128c889a6bc4e0312ee6", + "source": { + "epoch": "536154483", + "root": "0xacbffb3f4b33e122174f090c8d4cc511b7c9b9c5966cc1172c98e4332b70bfd0" + }, + "target": { + "epoch": "536539231", + "root": "0x82a81c3f096d065c7e3f5d7df79bd182a53c9471a737cfb9f7c4e9ed95d0f767" + } + }, + "signature": "0xa9aef1e37252740dedc5fc9886810459f7484555aa59fb3876803fc4924149cb471ffbbd9be5324d952efafc3de4c5f705dd02134916b2afa02194fe90a8d1e8f58ebcfe0d33d0b8a97e71a3f7591cb82c37ba531c059a684b581d3857f05e3c" + }, + { + "aggregation_bits": "0x0aa2e4365aad4ec5115dbc42fc6bcda2a0739e4b8c6c07334b99338ec990c7dc93162171b1ed0afe8b1f151348438523b428076a646db8375993d417cd79f1854f796992a8aea702eb3180373e7ff4b4c53ef3b306a5af7f82ba3a4a362af88084e7d166dd0ed5026019cd4f2c4fad16566f927d0dceb14203e8abc293267466c487eb2b108ae043792ff8e8c56e9fbb26d98381ad35e70558cc74f74d1d5a7de764645e15298f90a9a4292e58188deba564756775d54bad38de697be7659cde395c60f403933083c4e71881c26d15c83a61359fbecd1c12d8f31c0d440c128c416e09ee2d3fe64b8a4c737c2f604756d08d8c1f77d4623404e031805797412b01", + "data": { + "slot": "1", + "index": "4549347484797182313", + "beacon_block_root": "0xcf2c053f899b836f534bfa2a45bf23b7be4890b9815a72a2aec9f70eff53d592", + "source": { + "epoch": "528459505", + "root": "0xa8ea103f4904c5e568c52bd49eadfa1cb142929514c9202e53c7707e4a92667d" + }, + "target": { + "epoch": "528844253", + "root": "0x1bb1ed3e09ca0083285797d894e275ebd7548c015a7d158b66ce053068d7b2bd" + } + }, + "signature": "0x8f5c34de9e22ceaa7e8d165fc0553b32f02188539e89e2cc91e2eb9077645986550d872ee3403204ae5d554eae3cac12124e18d2324bccc814775316aaef352abc0450812b3ca9fde96ecafa911b3b8bfddca8db4027f08e29c22a9c370ad933" + }, + { + "aggregation_bits": "0xd664cfc4f928592f21ca9fae84cd2a15d4acf76e0d2cbb493324ae9cb25757559fc4b060414cbfd84de047d4f04da4aa6669e83b9b8418d348bfc46b3fef684ffbf0162da3c6258f690b14c94cf448280b646c140b24928defd2d12434dbbbd0afbea5e5661fcac8116699ec8a059acf084ab956ab0eaf508ab7d3e4bd352a80f6b8ff73b4b24753a865991c45c9d9f0e1675e7327ccaaeb146bc3d0a4db2d7e607930579fc38a41d5019f222166cea9ebebfe0dd7b875fa612ecb7bb80f83718702da59fd2687d445048ac99f25b5f088fe931ec4bbf9ecdfc169844c00bc69fe38c0110fc59105233b29f6ddecb7968065fd7ef787e41d3545fefe30314fa401", + "data": { + "slot": "1", + "index": "4536127614768741993", + "beacon_block_root": "0x6735d63e89f87d96fd623486e205c81ff060884934a0b8731dd31351d25a90e8", + "source": { + "epoch": "526920509", + "root": "0x41f3e13e4961bf0c12dd652f3bf49e85e35a8a25c70e67ffc1d08cc01d9921d3" + }, + "target": { + "epoch": "527305258", + "root": "0x51977a3f0ab3110e2a10e9c6bd0e89b1410ca45142ac42171bb2b169efc281bc" + } + }, + "signature": "0xa17225b5e5319618e77f5b93350430acfadd8ae12a279f1a4176cc7ad1de7ecfc8670988519713fbac8f702cca29bddb14ff1463dae3abb53ddb0c025cd69c8cfb0f5298ab241c06ddb840c7a260f3dbd37120826b13b17e22d086148ebdbab1" + } + ], + "deposits": [ + { + "proof": [ + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7", + "0x2a55863fca1b5384408a1a7015fd5f173406a62dd51af1a2c0af2ad93b0113a7" + ], + "data": { + "pubkey": "0x90b2ffa8992560bca2080afa9b3adc904ce9085a8c2cc897282f20378bdf3cdc0a74100f226ea698e07d4afe50d8ff54", + "withdrawal_credentials": "0x9d1b633f8ae18e21ff1b86740b32dbe55a18a0991bcfe5ffd2b6bf8a59465fe7", + "amount": "32000000000", + "signature": "0x978f1439422f6e539e93927a7754e7f9866fbe5832da066bb8fec5041a6818bbfe7e79747a963eec57f76924aeb591d0133ffae96de0793f02d13a13e1f7286a7940e48093ceb832b58e9d6bff9adfc1e8f59367d905633d743cd62ccbd2b27c" + } + } + ], + "voluntary_exits": [ + { + "message": { + "epoch": "4570829775204010570", + "validator_index": "4565872325553958186" + }, + "signature": "0x8c2c3b368bc00b3853e6df352e816dd910016db953ac77cc1565e3c22f1c0b24c59f24ea9e8ca406aa95b23368d163e80baa6de3f8f7ac19ee78c976d2ae5a21c86fa1762cc959bc734379055cb7aa1de36eae00541936b8c2ee908c770d41ff" + } + ] + } + } +} \ No newline at end of file diff --git a/validator/remote/src/integration-test/resources/responses/state_validators_response.json b/validator/remote/src/integration-test/resources/responses/state_validators_response.json new file mode 100644 index 00000000000..9bbca604544 --- /dev/null +++ b/validator/remote/src/integration-test/resources/responses/state_validators_response.json @@ -0,0 +1,21 @@ +{ + "execution_optimistic": false, + "finalized": false, + "data": [ + { + "index": "1", + "balance": "1", + "status": "active_ongoing", + "validator": { + "pubkey": "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a", + "withdrawal_credentials": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", + "effective_balance": "1", + "slashed": false, + "activation_eligibility_epoch": "1", + "activation_epoch": "1", + "exit_epoch": "1", + "withdrawable_epoch": "1" + } + } + ] +} \ No newline at end of file diff --git a/validator/remote/src/integration-test/resources/tech/pegasys/teku/validator/remote/typedef/handlers/getGenesisRequest_200.json b/validator/remote/src/integration-test/resources/tech/pegasys/teku/validator/remote/typedef/handlers/getGenesisRequest_200.json new file mode 100644 index 00000000000..eb88d9de719 --- /dev/null +++ b/validator/remote/src/integration-test/resources/tech/pegasys/teku/validator/remote/typedef/handlers/getGenesisRequest_200.json @@ -0,0 +1,7 @@ +{ + "data": { + "genesis_time": "1590832934", + "genesis_validators_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", + "genesis_fork_version": "0x00000000" + } +} \ No newline at end of file diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/BeaconNodeReadinessChannel.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/BeaconNodeReadinessChannel.java index 5f81beab75b..a9effabfa3f 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/BeaconNodeReadinessChannel.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/BeaconNodeReadinessChannel.java @@ -25,5 +25,5 @@ public interface BeaconNodeReadinessChannel extends VoidReturningChannelInterfac void onFailoverNodeNotReady(RemoteValidatorApiChannel failoverNotReady); - void onPrimaryNodeBackReady(); + void onPrimaryNodeReady(); } diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/BeaconNodeReadinessManager.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/BeaconNodeReadinessManager.java index f4822ea111f..124a982e3f5 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/BeaconNodeReadinessManager.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/BeaconNodeReadinessManager.java @@ -14,11 +14,13 @@ package tech.pegasys.teku.validator.remote; import com.google.common.collect.Maps; +import com.google.common.collect.Streams; import java.time.Duration; import java.util.Comparator; import java.util.Iterator; import java.util.List; import java.util.Map; +import java.util.Optional; import java.util.concurrent.atomic.AtomicBoolean; import java.util.stream.Stream; import okhttp3.HttpUrl; @@ -27,6 +29,7 @@ import org.apache.tuweni.bytes.Bytes32; import tech.pegasys.teku.api.response.v1.beacon.ValidatorStatus; import tech.pegasys.teku.bls.BLSPublicKey; +import tech.pegasys.teku.ethereum.json.types.node.PeerCount; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.logging.ValidatorLogger; import tech.pegasys.teku.infrastructure.unsigned.UInt64; @@ -45,8 +48,8 @@ public class BeaconNodeReadinessManager extends Service implements ValidatorTimi private static final Logger LOG = LogManager.getLogger(); private static final Duration SYNCING_STATUS_CALL_TIMEOUT = Duration.ofSeconds(10); - - private final Map readinessStatusCache = + private static final UInt64 MIN_REQUIRED_CONNECTED_PEER_COUNT = UInt64.valueOf(50); + private final Map readinessStatusCache = Maps.newConcurrentMap(); private final AtomicBoolean latestPrimaryNodeReadiness = new AtomicBoolean(true); @@ -68,15 +71,29 @@ public BeaconNodeReadinessManager( } public boolean isReady(final RemoteValidatorApiChannel beaconNodeApi) { - return readinessStatusCache.getOrDefault(beaconNodeApi, true); + final ReadinessStatus readinessStatus = + readinessStatusCache.getOrDefault(beaconNodeApi, ReadinessStatus.READY); + return readinessStatus.isReady(); + } + + public ReadinessStatus getReadinessStatus(final RemoteValidatorApiChannel beaconNodeApi) { + return readinessStatusCache.getOrDefault(beaconNodeApi, ReadinessStatus.READY); + } + + public int getReadinessStatusWeight(final RemoteValidatorApiChannel beaconNodeApi) { + return readinessStatusCache.getOrDefault(beaconNodeApi, ReadinessStatus.READY).weight; } public Iterator getFailoversInOrderOfReadiness() { return failoverBeaconNodeApis.stream() - .sorted(Comparator.comparing(this::isReady).reversed()) + .sorted(Comparator.comparing(this::getReadinessStatusWeight).reversed()) .iterator(); } + public SafeFuture performPrimaryReadinessCheck() { + return performReadinessCheck(primaryBeaconNodeApi, true); + } + @Override protected SafeFuture doStart() { return performReadinessCheckAgainstAllNodes(); @@ -133,11 +150,8 @@ private SafeFuture performReadinessCheckAgainstAllNodes() { final SafeFuture primaryReadinessCheck = performPrimaryReadinessCheck(); final Stream> failoverReadinessChecks = failoverBeaconNodeApis.stream().map(this::performFailoverReadinessCheck); - return SafeFuture.allOf(primaryReadinessCheck, SafeFuture.allOf(failoverReadinessChecks)); - } - - private SafeFuture performPrimaryReadinessCheck() { - return performReadinessCheck(primaryBeaconNodeApi, true); + return SafeFuture.allOf( + Streams.concat(Stream.of(primaryReadinessCheck), failoverReadinessChecks)); } private SafeFuture performFailoverReadinessCheck(final RemoteValidatorApiChannel failover) { @@ -149,16 +163,24 @@ private SafeFuture performReadinessCheck( final HttpUrl beaconNodeApiEndpoint = beaconNodeApi.getEndpoint(); return beaconNodeApi .getSyncingStatus() - .thenApply( - syncingStatus -> { + .thenCombine( + beaconNodeApi.getPeerCount(), + (syncingStatus, peerCount) -> { if (syncingStatus.isReady()) { LOG.debug( "{} is ready to accept requests: {}", beaconNodeApiEndpoint, syncingStatus); - return true; + final boolean optimistic = syncingStatus.getIsOptimistic().orElse(false); + if (optimistic) { + return ReadinessStatus.READY_OPTIMISTIC; + } + if (!hasEnoughConnectedPeers(peerCount)) { + return ReadinessStatus.READY_NOT_ENOUGH_PEERS; + } + return ReadinessStatus.READY; } LOG.debug( "{} is NOT ready to accept requests: {}", beaconNodeApiEndpoint, syncingStatus); - return false; + return ReadinessStatus.NOT_READY; }) .orTimeout(SYNCING_STATUS_CALL_TIMEOUT) .exceptionally( @@ -167,12 +189,12 @@ private SafeFuture performReadinessCheck( String.format( "%s is NOT ready to accept requests because the syncing status request failed: %s", beaconNodeApiEndpoint, throwable)); - return false; + return ReadinessStatus.NOT_READY; }) .thenAccept( - isReady -> { - readinessStatusCache.put(beaconNodeApi, isReady); - if (isReady) { + readinessStatus -> { + readinessStatusCache.put(beaconNodeApi, readinessStatus); + if (readinessStatus.isReady()) { processReadyResult(isPrimaryNode); } else { processNotReadyResult(beaconNodeApi, isPrimaryNode); @@ -180,13 +202,21 @@ private SafeFuture performReadinessCheck( }); } + private static boolean hasEnoughConnectedPeers(final Optional peerCount) { + return peerCount + .map(PeerCount::getConnected) + .orElse(UInt64.ZERO) + .isGreaterThanOrEqualTo(MIN_REQUIRED_CONNECTED_PEER_COUNT); + } + private void processReadyResult(final boolean isPrimaryNode) { if (!isPrimaryNode) { return; } + // Filtering of duplicates if needed happens on receiver's side + beaconNodeReadinessChannel.onPrimaryNodeReady(); if (latestPrimaryNodeReadiness.compareAndSet(false, true)) { validatorLogger.primaryBeaconNodeIsBackAndReady(); - beaconNodeReadinessChannel.onPrimaryNodeBackReady(); } } @@ -201,4 +231,21 @@ private void processNotReadyResult( beaconNodeReadinessChannel.onFailoverNodeNotReady(beaconNodeApi); } } + + public enum ReadinessStatus { + NOT_READY(0), + READY_OPTIMISTIC(1), + READY_NOT_ENOUGH_PEERS(2), + READY(3); + + private final int weight; + + ReadinessStatus(final int weight) { + this.weight = weight; + } + + boolean isReady() { + return this.weight > 0; + } + } } diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/FailoverValidatorApiHandler.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/FailoverValidatorApiHandler.java index b912854ed95..5a91550b170 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/FailoverValidatorApiHandler.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/FailoverValidatorApiHandler.java @@ -33,11 +33,13 @@ import tech.pegasys.teku.api.response.v1.beacon.ValidatorStatus; import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.bls.BLSSignature; +import tech.pegasys.teku.ethereum.json.types.node.PeerCount; import tech.pegasys.teku.ethereum.json.types.validator.AttesterDuties; import tech.pegasys.teku.ethereum.json.types.validator.BeaconCommitteeSelectionProof; import tech.pegasys.teku.ethereum.json.types.validator.ProposerDuties; import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeDuties; import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSelectionProof; +import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.collections.LimitedMap; import tech.pegasys.teku.infrastructure.metrics.TekuMetricCategory; @@ -45,6 +47,7 @@ import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.datastructures.blocks.BlockContainer; import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockContainer; +import tech.pegasys.teku.spec.datastructures.blocks.SlotAndBlockRoot; import tech.pegasys.teku.spec.datastructures.builder.SignedValidatorRegistration; import tech.pegasys.teku.spec.datastructures.genesis.GenesisData; import tech.pegasys.teku.spec.datastructures.metadata.BlockContainerAndMetaData; @@ -54,13 +57,12 @@ import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SignedContributionAndProof; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeContribution; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeMessage; -import tech.pegasys.teku.spec.datastructures.operations.versions.bellatrix.BeaconPreparableProposer; +import tech.pegasys.teku.spec.datastructures.validator.BeaconPreparableProposer; import tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel; import tech.pegasys.teku.spec.datastructures.validator.SubnetSubscription; import tech.pegasys.teku.validator.api.CommitteeSubscriptionRequest; import tech.pegasys.teku.validator.api.SendSignedBlockResult; import tech.pegasys.teku.validator.api.SubmitDataError; -import tech.pegasys.teku.validator.api.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.validator.api.ValidatorApiChannel; import tech.pegasys.teku.validator.beaconnode.metrics.BeaconNodeRequestLabels; @@ -71,7 +73,7 @@ public class FailoverValidatorApiHandler implements ValidatorApiChannel { static final String REMOTE_BEACON_NODES_REQUESTS_COUNTER_NAME = "remote_beacon_nodes_requests_total"; - private final Map blindedBlockCreatorCache = + private final Map blindedBlockCreatorCache = LimitedMap.createSynchronizedLRU(2); private final BeaconNodeReadinessManager beaconNodeReadinessManager; @@ -148,18 +150,22 @@ public SafeFuture> getProposerDuties(final UInt64 epoch BeaconNodeRequestLabels.GET_PROPOSER_DUTIES_REQUESTS_METHOD); } + @Override + public SafeFuture> getPeerCount() { + return tryRequestUntilSuccess( + ValidatorApiChannel::getPeerCount, BeaconNodeRequestLabels.GET_PEER_COUNT_METHOD); + } + @Override public SafeFuture> createUnsignedBlock( final UInt64 slot, final BLSSignature randaoReveal, final Optional graffiti, - final Optional requestedBlinded, final Optional requestedBuilderBoostFactor) { final ValidatorApiChannelRequest> request = apiChannel -> apiChannel - .createUnsignedBlock( - slot, randaoReveal, graffiti, requestedBlinded, requestedBuilderBoostFactor) + .createUnsignedBlock(slot, randaoReveal, graffiti, requestedBuilderBoostFactor) .thenPeek( blockContainerAndMetaData -> { if (!failoverDelegates.isEmpty() @@ -167,7 +173,13 @@ public SafeFuture> createUnsignedBlock( .map(BlockContainerAndMetaData::blockContainer) .map(BlockContainer::isBlinded) .orElse(false)) { - blindedBlockCreatorCache.put(slot, apiChannel); + final SlotAndBlockRoot slotAndBlockRoot = + blockContainerAndMetaData + .orElseThrow() + .blockContainer() + .getBlock() + .getSlotAndBlockRoot(); + blindedBlockCreatorCache.put(slotAndBlockRoot, apiChannel); } }); return tryRequestUntilSuccess(request, BeaconNodeRequestLabels.CREATE_UNSIGNED_BLOCK_METHOD); @@ -183,9 +195,11 @@ public SafeFuture> createAttestationData( @Override public SafeFuture> createAggregate( - final UInt64 slot, final Bytes32 attestationHashTreeRoot) { + final UInt64 slot, + final Bytes32 attestationHashTreeRoot, + final Optional committeeIndex) { return tryRequestUntilSuccess( - apiChannel -> apiChannel.createAggregate(slot, attestationHashTreeRoot), + apiChannel -> apiChannel.createAggregate(slot, attestationHashTreeRoot, committeeIndex), BeaconNodeRequestLabels.CREATE_AGGREGATE_METHOD); } @@ -199,7 +213,8 @@ public SafeFuture> createSyncCommitteeContri } @Override - public SafeFuture subscribeToBeaconCommittee(List requests) { + public SafeFuture subscribeToBeaconCommittee( + final List requests) { return relayRequest( apiChannel -> apiChannel.subscribeToBeaconCommittee(requests), BeaconNodeRequestLabels.BEACON_COMMITTEE_SUBSCRIPTION_METHOD, @@ -208,7 +223,7 @@ public SafeFuture subscribeToBeaconCommittee(List subscribeToSyncCommitteeSubnets( - Collection subscriptions) { + final Collection subscriptions) { return relayRequest( apiChannel -> apiChannel.subscribeToSyncCommitteeSubnets(subscriptions), BeaconNodeRequestLabels.SYNC_COMMITTEE_SUBNET_SUBSCRIPTION_METHOD, @@ -217,7 +232,7 @@ public SafeFuture subscribeToSyncCommitteeSubnets( @Override public SafeFuture subscribeToPersistentSubnets( - Set subnetSubscriptions) { + final Set subnetSubscriptions) { return relayRequest( apiChannel -> apiChannel.subscribeToPersistentSubnets(subnetSubscriptions), BeaconNodeRequestLabels.PERSISTENT_SUBNETS_SUBSCRIPTION_METHOD, @@ -225,7 +240,8 @@ public SafeFuture subscribeToPersistentSubnets( } @Override - public SafeFuture> sendSignedAttestations(List attestations) { + public SafeFuture> sendSignedAttestations( + final List attestations) { return relayRequest( apiChannel -> apiChannel.sendSignedAttestations(attestations), BeaconNodeRequestLabels.PUBLISH_ATTESTATION_METHOD, @@ -245,12 +261,14 @@ public SafeFuture> sendAggregateAndProofs( public SafeFuture sendSignedBlock( final SignedBlockContainer blockContainer, final BroadcastValidationLevel broadcastValidationLevel) { - final UInt64 slot = blockContainer.getSlot(); - if (blockContainer.isBlinded() && blindedBlockCreatorCache.containsKey(slot)) { - final ValidatorApiChannel blockCreatorApiChannel = blindedBlockCreatorCache.remove(slot); + final SlotAndBlockRoot slotAndBlockRoot = blockContainer.getSignedBlock().getSlotAndBlockRoot(); + if (blockContainer.isBlinded() && blindedBlockCreatorCache.containsKey(slotAndBlockRoot)) { + final ValidatorApiChannel blockCreatorApiChannel = + blindedBlockCreatorCache.remove(slotAndBlockRoot); LOG.info( - "Block for slot {} was blinded and will only be sent to the beacon node which created it.", - slot); + "Block for slot {} and root {} was blinded and will only be sent to the beacon node which created it.", + slotAndBlockRoot.getSlot(), + slotAndBlockRoot.getBlockRoot().toHexString()); return blockCreatorApiChannel.sendSignedBlock(blockContainer, broadcastValidationLevel); } return relayRequest( diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/RemoteBeaconNodeApi.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/RemoteBeaconNodeApi.java index f41fb814bbe..ae5b531471c 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/RemoteBeaconNodeApi.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/RemoteBeaconNodeApi.java @@ -86,7 +86,8 @@ public static BeaconNodeApi create( spec, validatorConfig.isValidatorClientUseSszBlocksEnabled(), validatorConfig.isValidatorClientUsePostValidatorsEndpointEnabled(), - asyncRunner); + asyncRunner, + validatorConfig.isAttestationsV2ApisEnabled()); final List failoverValidatorApis = failoverEndpoints.stream() .map( @@ -97,7 +98,8 @@ public static BeaconNodeApi create( spec, validatorConfig.isValidatorClientUseSszBlocksEnabled(), validatorConfig.isValidatorClientUsePostValidatorsEndpointEnabled(), - asyncRunner)) + asyncRunner, + validatorConfig.isAttestationsV2ApisEnabled())) .toList(); final EventChannels eventChannels = serviceConfig.getEventChannels(); diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/RemoteValidatorApiHandler.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/RemoteValidatorApiHandler.java index 1fb1d8b2f2a..87a93ab83a3 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/RemoteValidatorApiHandler.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/RemoteValidatorApiHandler.java @@ -13,7 +13,6 @@ package tech.pegasys.teku.validator.remote; -import static java.util.Collections.emptyList; import static java.util.Collections.emptyMap; import static java.util.stream.Collectors.toMap; @@ -29,25 +28,23 @@ import java.util.Set; import java.util.concurrent.atomic.AtomicBoolean; import java.util.function.Function; -import java.util.stream.Collectors; import okhttp3.HttpUrl; import okhttp3.OkHttpClient; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.apache.tuweni.bytes.Bytes32; import tech.pegasys.teku.api.migrated.ValidatorLivenessAtEpoch; -import tech.pegasys.teku.api.response.v1.beacon.PostDataFailureResponse; import tech.pegasys.teku.api.response.v1.beacon.ValidatorStatus; -import tech.pegasys.teku.api.response.v1.validator.PostValidatorLivenessResponse; -import tech.pegasys.teku.api.schema.altair.ContributionAndProof; import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.ethereum.json.types.beacon.StateValidatorData; +import tech.pegasys.teku.ethereum.json.types.node.PeerCount; import tech.pegasys.teku.ethereum.json.types.validator.AttesterDuties; import tech.pegasys.teku.ethereum.json.types.validator.BeaconCommitteeSelectionProof; import tech.pegasys.teku.ethereum.json.types.validator.ProposerDuties; import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeDuties; import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSelectionProof; +import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.infrastructure.async.AsyncRunner; import tech.pegasys.teku.infrastructure.async.ExceptionThrowingRunnable; import tech.pegasys.teku.infrastructure.async.ExceptionThrowingSupplier; @@ -59,24 +56,22 @@ import tech.pegasys.teku.spec.datastructures.builder.SignedValidatorRegistration; import tech.pegasys.teku.spec.datastructures.genesis.GenesisData; import tech.pegasys.teku.spec.datastructures.metadata.BlockContainerAndMetaData; +import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SignedContributionAndProof; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeContribution; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeMessage; -import tech.pegasys.teku.spec.datastructures.operations.versions.bellatrix.BeaconPreparableProposer; +import tech.pegasys.teku.spec.datastructures.validator.BeaconPreparableProposer; import tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel; import tech.pegasys.teku.spec.datastructures.validator.SubnetSubscription; import tech.pegasys.teku.validator.api.CommitteeSubscriptionRequest; import tech.pegasys.teku.validator.api.SendSignedBlockResult; import tech.pegasys.teku.validator.api.SubmitDataError; -import tech.pegasys.teku.validator.api.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.validator.api.required.SyncingStatus; -import tech.pegasys.teku.validator.remote.apiclient.OkHttpValidatorRestApiClient; import tech.pegasys.teku.validator.remote.apiclient.PostStateValidatorsNotExistingException; import tech.pegasys.teku.validator.remote.apiclient.RateLimitedException; -import tech.pegasys.teku.validator.remote.apiclient.ValidatorRestApiClient; import tech.pegasys.teku.validator.remote.typedef.OkHttpValidatorTypeDefClient; public class RemoteValidatorApiHandler implements RemoteValidatorApiChannel { @@ -87,22 +82,16 @@ public class RemoteValidatorApiHandler implements RemoteValidatorApiChannel { static final int MAX_RATE_LIMITING_RETRIES = 3; private final HttpUrl endpoint; - private final Spec spec; - private final ValidatorRestApiClient apiClient; private final OkHttpValidatorTypeDefClient typeDefClient; private final AsyncRunner asyncRunner; private final AtomicBoolean usePostValidatorsEndpoint; public RemoteValidatorApiHandler( final HttpUrl endpoint, - final Spec spec, - final ValidatorRestApiClient apiClient, final OkHttpValidatorTypeDefClient typeDefClient, final AsyncRunner asyncRunner, final boolean usePostValidatorsEndpoint) { this.endpoint = endpoint; - this.spec = spec; - this.apiClient = apiClient; this.asyncRunner = asyncRunner; this.typeDefClient = typeDefClient; this.usePostValidatorsEndpoint = new AtomicBoolean(usePostValidatorsEndpoint); @@ -189,7 +178,7 @@ private Optional> makeBatchedValidatorRequest( } private Optional> requestValidatorObject( - final List batch, Function valueExtractor) { + final List batch, final Function valueExtractor) { return typeDefClient .getStateValidators(convertPublicKeysToValidatorIds(batch)) .map(responses -> convertToValidatorMapTypeDef(responses, valueExtractor)); @@ -218,6 +207,11 @@ public SafeFuture> getProposerDuties(final UInt64 epoch return sendRequest(() -> typeDefClient.getProposerDuties(epoch)); } + @Override + public SafeFuture> getPeerCount() { + return sendRequest(typeDefClient::getPeerCount); + } + @Override public SafeFuture> createAttestationData( final UInt64 slot, final int committeeIndex) { @@ -227,31 +221,15 @@ public SafeFuture> createAttestationData( @Override public SafeFuture> sendSignedAttestations( final List attestations) { - final List schemaAttestations = - attestations.stream().map(tech.pegasys.teku.api.schema.Attestation::new).toList(); - - return sendRequest( - () -> - apiClient - .sendSignedAttestations(schemaAttestations) - .map(this::convertPostDataFailureResponseToSubmitDataErrors) - .orElse(emptyList())); + return sendRequest(() -> typeDefClient.sendSignedAttestations(attestations)); } @Override - @SuppressWarnings("deprecation") public SafeFuture> createUnsignedBlock( final UInt64 slot, final BLSSignature randaoReveal, final Optional graffiti, - final Optional requestedBlinded, final Optional requestedBuilderBoostFactor) { - if (requestedBlinded.isPresent()) { - return sendRequest( - () -> - typeDefClient.createUnsignedBlock( - slot, randaoReveal, graffiti, requestedBlinded.get())); - } return sendRequest( () -> typeDefClient.createUnsignedBlock( @@ -262,85 +240,32 @@ public SafeFuture> createUnsignedBlock( public SafeFuture sendSignedBlock( final SignedBlockContainer blockContainer, final BroadcastValidationLevel broadcastValidationLevel) { - // we are not going to use V2 to send blocks. If V1 will be deprecated we won't specify a - // validation level in any case - if (broadcastValidationLevel != BroadcastValidationLevel.NOT_REQUIRED) { - LOG.warn("broadcastValidationLevel has been requested but will be ignored."); - } - return sendRequest(() -> typeDefClient.sendSignedBlock(blockContainer)); + return sendRequest( + () -> typeDefClient.sendSignedBlock(blockContainer, broadcastValidationLevel)); } @Override public SafeFuture> sendSyncCommitteeMessages( final List syncCommitteeMessages) { - return sendRequest( - () -> - apiClient - .sendSyncCommitteeMessages( - syncCommitteeMessages.stream() - .map( - signature -> - new tech.pegasys.teku.api.schema.altair.SyncCommitteeMessage( - signature.getSlot(), - signature.getBeaconBlockRoot(), - signature.getValidatorIndex(), - new tech.pegasys.teku.api.schema.BLSSignature( - signature.getSignature()))) - .toList()) - .map(this::convertPostDataFailureResponseToSubmitDataErrors) - .orElse(emptyList())); + return sendRequest(() -> typeDefClient.sendSyncCommitteeMessages(syncCommitteeMessages)); } @Override public SafeFuture sendSignedContributionAndProofs( final Collection signedContributionAndProofs) { - final List - signedContributionsRestSchema = - signedContributionAndProofs.stream().map(this::asSignedContributionAndProofs).toList(); - return sendRequest(() -> apiClient.sendContributionAndProofs(signedContributionsRestSchema)); - } - - private tech.pegasys.teku.api.schema.altair.SignedContributionAndProof - asSignedContributionAndProofs(final SignedContributionAndProof signedContributionAndProof) { - return new tech.pegasys.teku.api.schema.altair.SignedContributionAndProof( - asContributionAndProof(signedContributionAndProof.getMessage()), - new tech.pegasys.teku.api.schema.BLSSignature(signedContributionAndProof.getSignature())); - } - - private ContributionAndProof asContributionAndProof( - final tech.pegasys.teku.spec.datastructures.operations.versions.altair.ContributionAndProof - message) { - return new ContributionAndProof( - message.getAggregatorIndex(), - new tech.pegasys.teku.api.schema.BLSSignature(message.getSelectionProof()), - asSyncCommitteeContribution(message.getContribution())); - } - - private tech.pegasys.teku.api.schema.altair.SyncCommitteeContribution asSyncCommitteeContribution( - final SyncCommitteeContribution contribution) { - return new tech.pegasys.teku.api.schema.altair.SyncCommitteeContribution( - contribution.getSlot(), - contribution.getBeaconBlockRoot(), - contribution.getSubcommitteeIndex(), - contribution.getAggregationBits().sszSerialize(), - new tech.pegasys.teku.api.schema.BLSSignature(contribution.getSignature())); - } - - private List convertPostDataFailureResponseToSubmitDataErrors( - final PostDataFailureResponse postDataFailureResponse) { - return postDataFailureResponse.failures.stream() - .map(i -> new SubmitDataError(i.index, i.message)) - .toList(); + return sendRequest(() -> typeDefClient.sendContributionAndProofs(signedContributionAndProofs)); } @Override public SafeFuture> createAggregate( - final UInt64 slot, final Bytes32 attestationHashTreeRoot) { + final UInt64 slot, + final Bytes32 attestationHashTreeRoot, + final Optional committeeIndex) { return sendRequest( () -> - apiClient - .createAggregate(slot, attestationHashTreeRoot) - .map(attestation -> attestation.asInternalAttestation(spec))); + typeDefClient + .createAggregate(slot, attestationHashTreeRoot, committeeIndex) + .map(ObjectAndMetaData::getData)); } @Override @@ -348,80 +273,39 @@ public SafeFuture> createSyncCommitteeContri final UInt64 slot, final int subcommitteeIndex, final Bytes32 beaconBlockRoot) { return sendRequest( () -> - apiClient - .createSyncCommitteeContribution(slot, subcommitteeIndex, beaconBlockRoot) - .map( - contribution -> - tech.pegasys.teku.api.schema.altair.SyncCommitteeContribution - .asInternalSyncCommitteeContribution(spec, contribution))); + typeDefClient.createSyncCommitteeContribution( + slot, subcommitteeIndex, beaconBlockRoot)); } @Override public SafeFuture> sendAggregateAndProofs( final List aggregateAndProofs) { - return sendRequest( - () -> - apiClient - .sendAggregateAndProofs( - aggregateAndProofs.stream() - .map(tech.pegasys.teku.api.schema.SignedAggregateAndProof::new) - .toList()) - .map(this::convertPostDataFailureResponseToSubmitDataErrors) - .orElse(emptyList())); + return sendRequest(() -> typeDefClient.sendAggregateAndProofs(aggregateAndProofs)); } @Override public SafeFuture subscribeToBeaconCommittee( final List requests) { - return sendRequest(() -> apiClient.subscribeToBeaconCommittee(requests)); + return sendRequest(() -> typeDefClient.subscribeToBeaconCommittee(requests)); } @Override public SafeFuture subscribeToSyncCommitteeSubnets( final Collection subscriptions) { - return sendRequest( - () -> - apiClient.subscribeToSyncCommitteeSubnets( - subscriptions.stream() - .map( - subscription -> - new tech.pegasys.teku.api.schema.altair.SyncCommitteeSubnetSubscription( - UInt64.valueOf(subscription.getValidatorIndex()), - subscription - .getSyncCommitteeIndices() - .intStream() - .mapToObj(UInt64::valueOf) - .toList(), - subscription.getUntilEpoch())) - .toList())); + return sendRequest(() -> typeDefClient.subscribeToSyncCommitteeSubnets(subscriptions)); } @Override public SafeFuture subscribeToPersistentSubnets( final Set subnetSubscriptions) { - final Set schemaSubscriptions = - subnetSubscriptions.stream() - .map( - s -> - new tech.pegasys.teku.api.schema.SubnetSubscription( - s.getSubnetId(), s.getUnsubscriptionSlot())) - .collect(Collectors.toSet()); - - return sendRequest(() -> apiClient.subscribeToPersistentSubnets(schemaSubscriptions)); + return sendRequest(() -> typeDefClient.subscribeToPersistentSubnets(subnetSubscriptions)); } @Override public SafeFuture prepareBeaconProposer( final Collection beaconPreparableProposers) { return sendRequest( - () -> - apiClient.prepareBeaconProposer( - beaconPreparableProposers.stream() - .map( - proposer -> - new tech.pegasys.teku.api.schema.bellatrix.BeaconPreparableProposer( - proposer.getValidatorIndex(), proposer.getFeeRecipient())) - .toList())); + () -> typeDefClient.prepareBeaconProposer(new ArrayList<>(beaconPreparableProposers))); } @Override @@ -433,11 +317,7 @@ public SafeFuture registerValidators( @Override public SafeFuture>> getValidatorsLiveness( final List validatorIndices, final UInt64 epoch) { - return sendRequest( - () -> - apiClient - .sendValidatorsLiveness(epoch, validatorIndices) - .map(this::responseToValidatorsLivenessResult)); + return sendRequest(() -> typeDefClient.sendValidatorsLiveness(epoch, validatorIndices)); } @Override @@ -452,16 +332,6 @@ public SafeFuture>> getSyncCommitteeS return sendRequest(() -> typeDefClient.getSyncCommitteeSelectionProof(requests)); } - private List responseToValidatorsLivenessResult( - final PostValidatorLivenessResponse response) { - return response.data.stream() - .map( - validatorLivenessAtEpoch -> - new ValidatorLivenessAtEpoch( - validatorLivenessAtEpoch.index, validatorLivenessAtEpoch.isLive)) - .toList(); - } - private SafeFuture sendRequest(final ExceptionThrowingRunnable requestExecutor) { return sendRequest( () -> { @@ -496,12 +366,12 @@ public static RemoteValidatorApiHandler create( final Spec spec, final boolean preferSszBlockEncoding, final boolean usePostValidatorsEndpoint, - final AsyncRunner asyncRunner) { - final OkHttpValidatorRestApiClient apiClient = - new OkHttpValidatorRestApiClient(endpoint, httpClient); + final AsyncRunner asyncRunner, + final boolean attestationsV2ApisEnabled) { final OkHttpValidatorTypeDefClient typeDefClient = - new OkHttpValidatorTypeDefClient(httpClient, endpoint, spec, preferSszBlockEncoding); + new OkHttpValidatorTypeDefClient( + httpClient, endpoint, spec, preferSszBlockEncoding, attestationsV2ApisEnabled); return new RemoteValidatorApiHandler( - endpoint, spec, apiClient, typeDefClient, asyncRunner, usePostValidatorsEndpoint); + endpoint, typeDefClient, asyncRunner, usePostValidatorsEndpoint); } } diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/apiclient/OkHttpValidatorRestApiClient.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/apiclient/OkHttpValidatorRestApiClient.java deleted file mode 100644 index 6a2a7565f0f..00000000000 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/apiclient/OkHttpValidatorRestApiClient.java +++ /dev/null @@ -1,373 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.validator.remote.apiclient; - -import static java.util.Collections.emptyMap; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; -import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.GET_AGGREGATE; -import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.GET_BLOCK_HEADER; -import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.GET_GENESIS; -import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.GET_PROPOSER_DUTIES; -import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.GET_SYNC_COMMITTEE_CONTRIBUTION; -import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.GET_VALIDATORS; -import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.PREPARE_BEACON_PROPOSER; -import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.SEND_CONTRIBUTION_AND_PROOF; -import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.SEND_SIGNED_AGGREGATE_AND_PROOF; -import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.SEND_SIGNED_ATTESTATION; -import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.SEND_SIGNED_VOLUNTARY_EXIT; -import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.SEND_SYNC_COMMITTEE_MESSAGES; -import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.SEND_VALIDATOR_LIVENESS; -import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.SUBSCRIBE_TO_BEACON_COMMITTEE_SUBNET; -import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.SUBSCRIBE_TO_PERSISTENT_SUBNETS; -import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.SUBSCRIBE_TO_SYNC_COMMITTEE_SUBNET; - -import com.fasterxml.jackson.core.JsonProcessingException; -import java.io.IOException; -import java.io.UncheckedIOException; -import java.net.URI; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Set; -import okhttp3.Credentials; -import okhttp3.HttpUrl; -import okhttp3.MediaType; -import okhttp3.OkHttpClient; -import okhttp3.Request; -import okhttp3.RequestBody; -import okhttp3.Response; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; -import org.apache.tuweni.bytes.Bytes32; -import tech.pegasys.teku.api.request.v1.validator.BeaconCommitteeSubscriptionRequest; -import tech.pegasys.teku.api.response.v1.beacon.GetBlockHeaderResponse; -import tech.pegasys.teku.api.response.v1.beacon.GetGenesisResponse; -import tech.pegasys.teku.api.response.v1.beacon.GetStateValidatorsResponse; -import tech.pegasys.teku.api.response.v1.beacon.PostDataFailureResponse; -import tech.pegasys.teku.api.response.v1.beacon.ValidatorResponse; -import tech.pegasys.teku.api.response.v1.validator.GetAggregatedAttestationResponse; -import tech.pegasys.teku.api.response.v1.validator.GetProposerDutiesResponse; -import tech.pegasys.teku.api.response.v1.validator.GetSyncCommitteeContributionResponse; -import tech.pegasys.teku.api.response.v1.validator.PostValidatorLivenessResponse; -import tech.pegasys.teku.api.schema.Attestation; -import tech.pegasys.teku.api.schema.SignedAggregateAndProof; -import tech.pegasys.teku.api.schema.SignedVoluntaryExit; -import tech.pegasys.teku.api.schema.SubnetSubscription; -import tech.pegasys.teku.api.schema.altair.SignedContributionAndProof; -import tech.pegasys.teku.api.schema.altair.SyncCommitteeContribution; -import tech.pegasys.teku.api.schema.altair.SyncCommitteeMessage; -import tech.pegasys.teku.api.schema.altair.SyncCommitteeSubnetSubscription; -import tech.pegasys.teku.api.schema.bellatrix.BeaconPreparableProposer; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.provider.JsonProvider; -import tech.pegasys.teku.validator.api.CommitteeSubscriptionRequest; - -public class OkHttpValidatorRestApiClient implements ValidatorRestApiClient { - - private static final Logger LOG = LogManager.getLogger(); - - private static final MediaType APPLICATION_JSON = - MediaType.parse("application/json; charset=utf-8"); - private static final Map EMPTY_MAP = emptyMap(); - - private final JsonProvider jsonProvider = new JsonProvider(); - private final OkHttpClient httpClient; - private final HttpUrl baseEndpoint; - - public OkHttpValidatorRestApiClient(final HttpUrl baseEndpoint, final OkHttpClient okHttpClient) { - this.baseEndpoint = baseEndpoint; - this.httpClient = okHttpClient; - } - - @Override - public Optional getGenesis() { - return get(GET_GENESIS, EMPTY_MAP, createHandler(GetGenesisResponse.class)); - } - - public Optional getBlockHeader(final String blockId) { - return get( - GET_BLOCK_HEADER, - Map.of("block_id", blockId), - EMPTY_MAP, - EMPTY_MAP, - createHandler(GetBlockHeaderResponse.class)); - } - - /** - * GET - * Get validators from state - */ - @Override - public Optional> getValidators(final List validatorIds) { - final Map queryParams = new HashMap<>(); - queryParams.put("id", String.join(",", validatorIds)); - return get( - GET_VALIDATORS, - EMPTY_MAP, - EMPTY_MAP, - queryParams, - createHandler(GetStateValidatorsResponse.class)) - .map(response -> response.data); - } - - @Override - public Optional getProposerDuties(final UInt64 epoch) { - return get( - GET_PROPOSER_DUTIES, - Map.of("epoch", epoch.toString()), - EMPTY_MAP, - EMPTY_MAP, - createHandler(GetProposerDutiesResponse.class)); - } - - @Override - public Optional sendSignedAttestations( - final List attestations) { - return post( - SEND_SIGNED_ATTESTATION, - attestations, - ResponseHandler.createForEmptyOkAndContentInBadResponse( - jsonProvider, PostDataFailureResponse.class)); - } - - @Override - public Optional sendVoluntaryExit( - final SignedVoluntaryExit voluntaryExit) { - return post( - SEND_SIGNED_VOLUNTARY_EXIT, - voluntaryExit, - ResponseHandler.createForEmptyOkAndContentInBadResponse( - jsonProvider, PostDataFailureResponse.class)); - } - - @Override - public Optional createAggregate( - final UInt64 slot, final Bytes32 attestationHashTreeRoot) { - final Map queryParams = new HashMap<>(); - queryParams.put("slot", encodeQueryParam(slot)); - queryParams.put("attestation_data_root", encodeQueryParam(attestationHashTreeRoot)); - - return get( - GET_AGGREGATE, - queryParams, - createHandler(GetAggregatedAttestationResponse.class) - .withHandler(SC_NOT_FOUND, (request, response) -> Optional.empty())) - .map(result -> result.data); - } - - @Override - public Optional sendAggregateAndProofs( - final List signedAggregateAndProof) { - return post( - SEND_SIGNED_AGGREGATE_AND_PROOF, - signedAggregateAndProof, - ResponseHandler.createForEmptyOkAndContentInBadResponse( - jsonProvider, PostDataFailureResponse.class)); - } - - @Override - public void subscribeToBeaconCommittee(List requests) { - final BeaconCommitteeSubscriptionRequest[] body = - requests.stream() - .map( - request -> - new BeaconCommitteeSubscriptionRequest( - String.valueOf(request.getValidatorIndex()), - String.valueOf(request.getCommitteeIndex()), - request.getCommitteesAtSlot(), - request.getSlot(), - request.isAggregator())) - .toArray(BeaconCommitteeSubscriptionRequest[]::new); - post(SUBSCRIBE_TO_BEACON_COMMITTEE_SUBNET, body, createHandler()); - } - - @Override - public void subscribeToPersistentSubnets(final Set subnetSubscriptions) { - post(SUBSCRIBE_TO_PERSISTENT_SUBNETS, subnetSubscriptions, createHandler()); - } - - @Override - public Optional sendSyncCommitteeMessages( - final List syncCommitteeMessages) { - return post( - SEND_SYNC_COMMITTEE_MESSAGES, - syncCommitteeMessages, - ResponseHandler.createForEmptyOkAndContentInBadResponse( - jsonProvider, PostDataFailureResponse.class)); - } - - @Override - public void subscribeToSyncCommitteeSubnets( - final List subnetSubscriptions) { - post(SUBSCRIBE_TO_SYNC_COMMITTEE_SUBNET, subnetSubscriptions, createHandler()); - } - - @Override - public void sendContributionAndProofs( - final List signedContributionAndProofs) { - post(SEND_CONTRIBUTION_AND_PROOF, signedContributionAndProofs, createHandler()); - } - - @Override - public Optional createSyncCommitteeContribution( - final UInt64 slot, final int subcommitteeIndex, final Bytes32 beaconBlockRoot) { - final Map pathParams = Map.of(); - final Map queryParams = - Map.of( - "slot", - slot.toString(), - "subcommittee_index", - Integer.toString(subcommitteeIndex), - "beacon_block_root", - beaconBlockRoot.toHexString()); - return get( - GET_SYNC_COMMITTEE_CONTRIBUTION, - pathParams, - queryParams, - EMPTY_MAP, - createHandler(GetSyncCommitteeContributionResponse.class) - .withHandler(SC_NOT_FOUND, (request, response) -> Optional.empty())) - .map(response -> response.data); - } - - @Override - public void prepareBeaconProposer(List beaconPreparableProposers) { - post(PREPARE_BEACON_PROPOSER, beaconPreparableProposers, createHandler()); - } - - @Override - public Optional sendValidatorsLiveness( - UInt64 epoch, List validatorsIndices) { - return post( - SEND_VALIDATOR_LIVENESS, - Map.of("epoch", epoch.toString()), - validatorsIndices, - createHandler(PostValidatorLivenessResponse.class)); - } - - private ResponseHandler createHandler() { - return createHandler(null); - } - - private ResponseHandler createHandler(final Class responseClass) { - return new ResponseHandler<>(jsonProvider, responseClass); - } - - public Optional get( - final ValidatorApiMethod apiMethod, - final Map queryParams, - final ResponseHandler responseHandler) { - return get(apiMethod, EMPTY_MAP, queryParams, EMPTY_MAP, responseHandler); - } - - public Optional get( - final ValidatorApiMethod apiMethod, - final Map urlParams, - final Map queryParams, - final Map encodedQueryParams, - final ResponseHandler responseHandler) { - final HttpUrl.Builder httpUrlBuilder = urlBuilder(apiMethod, urlParams); - if (queryParams != null && !queryParams.isEmpty()) { - queryParams.forEach(httpUrlBuilder::addQueryParameter); - } - // The encodedQueryParams are considered to be encoded already - // and should not be encoded again. This is useful to prevent - // the comma in an array of values (e.g. id=1,2,3) from being - // encoded. - if (encodedQueryParams != null && !encodedQueryParams.isEmpty()) { - encodedQueryParams.forEach(httpUrlBuilder::addEncodedQueryParameter); - } - - final Request request = requestBuilder().url(httpUrlBuilder.build()).build(); - return executeCall(request, responseHandler); - } - - public URI getBaseEndpoint() { - return baseEndpoint.uri(); - } - - private Optional post( - final ValidatorApiMethod apiMethod, - final Map urlParams, - final Object requestBodyObj, - final ResponseHandler responseHandler) { - final HttpUrl.Builder httpUrlBuilder = urlBuilder(apiMethod, urlParams); - final String requestBody; - try { - requestBody = jsonProvider.objectToJSON(requestBodyObj); - } catch (JsonProcessingException e) { - throw new RuntimeException(e); - } - - final Request request = - requestBuilder() - .url(httpUrlBuilder.build()) - .post(RequestBody.create(requestBody, APPLICATION_JSON)) - .build(); - - return executeCall(request, responseHandler); - } - - private Request.Builder requestBuilder() { - final Request.Builder builder = new Request.Builder(); - if (!baseEndpoint.username().isEmpty()) { - builder.header( - "Authorization", - Credentials.basic(baseEndpoint.encodedUsername(), baseEndpoint.encodedPassword())); - } - return builder; - } - - private Optional post( - final ValidatorApiMethod apiMethod, - final Object requestBodyObj, - final ResponseHandler responseHandler) { - return post(apiMethod, EMPTY_MAP, requestBodyObj, responseHandler); - } - - private HttpUrl.Builder urlBuilder( - final ValidatorApiMethod apiMethod, final Map urlParams) { - return baseEndpoint.resolve(apiMethod.getPath(urlParams)).newBuilder(); - } - - private Optional executeCall( - final Request request, final ResponseHandler responseHandler) { - try (final Response response = httpClient.newCall(request).execute()) { - LOG.trace("{} {} {}", request.method(), request.url(), response.code()); - return responseHandler.handleResponse(request, response); - } catch (IOException e) { - throw new UncheckedIOException( - "Error communicating with Beacon Node API: " + e.getMessage(), e); - } - } - - private String encodeQueryParam(final Object value) { - try { - return removeQuotesIfPresent(jsonProvider.objectToJSON(value)); - } catch (JsonProcessingException e) { - throw new RuntimeException( - "Can't encode param of type " + value.getClass().getSimpleName(), e); - } - } - - private String removeQuotesIfPresent(final String value) { - if (value.startsWith("\"") && value.endsWith("\"")) { - return value.substring(1, value.length() - 1); - } else { - return value; - } - } -} diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/apiclient/ResponseHandler.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/apiclient/ResponseHandler.java deleted file mode 100644 index 81e12d6b3b1..00000000000 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/apiclient/ResponseHandler.java +++ /dev/null @@ -1,139 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.validator.remote.apiclient; - -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_ACCEPTED; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_GATEWAY; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_GATEWAY_TIMEOUT; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_TOO_MANY_REQUESTS; - -import it.unimi.dsi.fastutil.ints.Int2ObjectMap; -import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap; -import java.io.IOException; -import java.util.Optional; -import okhttp3.Request; -import okhttp3.Response; -import okhttp3.ResponseBody; -import tech.pegasys.teku.api.exceptions.RemoteServiceNotAvailableException; -import tech.pegasys.teku.provider.JsonProvider; - -public class ResponseHandler { - - private final Int2ObjectMap> handlers = new Int2ObjectOpenHashMap<>(); - private final JsonProvider jsonProvider; - private final Class responseClass; - private Class badRequestResponseClass; - - public ResponseHandler(final JsonProvider jsonProvider, final Class responseClass) { - this.jsonProvider = jsonProvider; - this.responseClass = responseClass; - withHandler(SC_OK, this::defaultOkHandler); - withHandler(SC_ACCEPTED, this::noValueHandler); - withHandler(SC_NO_CONTENT, this::noValueHandler); - withHandler(SC_SERVICE_UNAVAILABLE, this::serviceErrorHandler); - withHandler(SC_BAD_GATEWAY, this::serviceErrorHandler); - withHandler(SC_BAD_REQUEST, this::defaultBadRequestHandler); - withHandler(SC_GATEWAY_TIMEOUT, this::serviceErrorHandler); - withHandler(SC_TOO_MANY_REQUESTS, this::defaultTooManyRequestsHandler); - } - - public static ResponseHandler createForEmptyOkAndContentInBadResponse( - final JsonProvider jsonProvider, final Class badRequestResponseClass) { - final ResponseHandler handler = new ResponseHandler<>(jsonProvider, null); - handler.badRequestResponseClass = badRequestResponseClass; - return handler; - } - - public ResponseHandler withHandler(final int responseCode, final Handler handler) { - handlers.put(responseCode, handler); - return this; - } - - public ResponseHandler withHandler(final Handler handler, final int... responseCodes) { - for (final int responseCode : responseCodes) { - handlers.put(responseCode, handler); - } - return this; - } - - public Optional handleResponse(final Request request, final Response response) - throws IOException { - return handlers - .getOrDefault(response.code(), this::unknownResponseCodeHandler) - .handleResponse(request, response); - } - - private Optional unknownResponseCodeHandler(final Request request, final Response response) { - final String errorMessage = BeaconNodeApiErrorUtils.getErrorMessage(response); - final String exceptionMessage = - String.format( - "Unexpected response from Beacon Node API (url = %s, status = %s, message = %s)", - request.url(), response.code(), errorMessage); - throw new RuntimeException(exceptionMessage); - } - - private Optional noValueHandler(final Request request, final Response response) { - return Optional.empty(); - } - - private Optional serviceErrorHandler(final Request request, final Response response) { - final String errorMessage = BeaconNodeApiErrorUtils.getErrorMessage(response); - throw new RemoteServiceNotAvailableException( - String.format( - "Server error from Beacon Node API (url = %s, status = %s, message = %s)", - request.url(), response.code(), errorMessage)); - } - - private Optional defaultTooManyRequestsHandler( - final Request request, final Response response) { - throw new RateLimitedException(request.url().toString()); - } - - private Optional defaultBadRequestHandler(final Request request, final Response response) - throws IOException { - if (badRequestResponseClass != null) { - return parseResponse(response, badRequestResponseClass); - } - final String errorMessage = BeaconNodeApiErrorUtils.getErrorMessage(response); - final String exceptionMessage = - String.format( - "Invalid params response from Beacon Node API (url = %s, status = %s, message = %s)", - request.url(), response.code(), errorMessage); - throw new IllegalArgumentException(exceptionMessage); - } - - private Optional defaultOkHandler(final Request request, final Response response) - throws IOException { - return parseResponse(response, responseClass); - } - - private Optional parseResponse(final Response response, final Class responseClass) - throws IOException { - final ResponseBody responseBody = response.body(); - if (responseClass != null && responseBody != null) { - final T responseObj = jsonProvider.jsonToObject(responseBody.string(), responseClass); - return Optional.of(responseObj); - } else { - return Optional.empty(); - } - } - - public interface Handler { - Optional handleResponse(Request request, Response response) throws IOException; - } -} diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/apiclient/ValidatorApiMethod.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/apiclient/ValidatorApiMethod.java index e7c8dd8c0b6..06464c87e46 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/apiclient/ValidatorApiMethod.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/apiclient/ValidatorApiMethod.java @@ -22,18 +22,18 @@ public enum ValidatorApiMethod { GET_SYNCING_STATUS("/eth/v1/node/syncing"), GET_GENESIS("eth/v1/beacon/genesis"), GET_VALIDATORS("eth/v1/beacon/states/head/validators"), - GET_DUTIES("validator/duties"), - GET_UNSIGNED_BLOCK_V2("eth/v2/validator/blocks/:slot"), - GET_UNSIGNED_BLINDED_BLOCK("eth/v1/validator/blinded_blocks/:slot"), GET_UNSIGNED_BLOCK_V3("eth/v3/validator/blocks/:slot"), - SEND_SIGNED_BLOCK("eth/v1/beacon/blocks"), - SEND_SIGNED_BLINDED_BLOCK("eth/v1/beacon/blinded_blocks"), + SEND_SIGNED_BLOCK_V2("eth/v2/beacon/blocks"), + SEND_SIGNED_BLINDED_BLOCK_V2("eth/v2/beacon/blinded_blocks"), GET_ATTESTATION_DATA("eth/v1/validator/attestation_data"), SEND_SIGNED_ATTESTATION("eth/v1/beacon/pool/attestations"), + SEND_SIGNED_ATTESTATION_V2("eth/v2/beacon/pool/attestations"), SEND_SIGNED_VOLUNTARY_EXIT("eth/v1/beacon/pool/voluntary_exits"), SEND_SYNC_COMMITTEE_MESSAGES("eth/v1/beacon/pool/sync_committees"), GET_AGGREGATE("eth/v1/validator/aggregate_attestation"), - SEND_SIGNED_AGGREGATE_AND_PROOF("/eth/v1/validator/aggregate_and_proofs"), + GET_AGGREGATE_V2("eth/v2/validator/aggregate_attestation"), + SEND_SIGNED_AGGREGATE_AND_PROOFS("/eth/v1/validator/aggregate_and_proofs"), + SEND_SIGNED_AGGREGATE_AND_PROOFS_V2("/eth/v2/validator/aggregate_and_proofs"), SEND_CONTRIBUTION_AND_PROOF("eth/v1/validator/contribution_and_proofs"), SUBSCRIBE_TO_BEACON_COMMITTEE_SUBNET("eth/v1/validator/beacon_committee_subscriptions"), SUBSCRIBE_TO_PERSISTENT_SUBNETS("validator/persistent_subnets_subscription"), @@ -42,6 +42,7 @@ public enum ValidatorApiMethod { GET_SYNC_COMMITTEE_DUTIES("eth/v1/validator/duties/sync/:epoch"), GET_SYNC_COMMITTEE_CONTRIBUTION("eth/v1/validator/sync_committee_contribution"), GET_PROPOSER_DUTIES("eth/v1/validator/duties/proposer/:epoch"), + GET_PEER_COUNT("eth/v1/node/peer_count"), PREPARE_BEACON_PROPOSER("/eth/v1/validator/prepare_beacon_proposer"), REGISTER_VALIDATOR("/eth/v1/validator/register_validator"), GET_BLOCK_HEADER("eth/v1/beacon/headers/:block_id"), diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/apiclient/ValidatorRestApiClient.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/apiclient/ValidatorRestApiClient.java deleted file mode 100644 index 72235d17381..00000000000 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/apiclient/ValidatorRestApiClient.java +++ /dev/null @@ -1,73 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.validator.remote.apiclient; - -import java.util.List; -import java.util.Optional; -import java.util.Set; -import org.apache.tuweni.bytes.Bytes32; -import tech.pegasys.teku.api.response.v1.beacon.GetGenesisResponse; -import tech.pegasys.teku.api.response.v1.beacon.PostDataFailureResponse; -import tech.pegasys.teku.api.response.v1.beacon.ValidatorResponse; -import tech.pegasys.teku.api.response.v1.validator.GetProposerDutiesResponse; -import tech.pegasys.teku.api.response.v1.validator.PostValidatorLivenessResponse; -import tech.pegasys.teku.api.schema.Attestation; -import tech.pegasys.teku.api.schema.SignedAggregateAndProof; -import tech.pegasys.teku.api.schema.SignedVoluntaryExit; -import tech.pegasys.teku.api.schema.SubnetSubscription; -import tech.pegasys.teku.api.schema.altair.SignedContributionAndProof; -import tech.pegasys.teku.api.schema.altair.SyncCommitteeContribution; -import tech.pegasys.teku.api.schema.altair.SyncCommitteeMessage; -import tech.pegasys.teku.api.schema.altair.SyncCommitteeSubnetSubscription; -import tech.pegasys.teku.api.schema.bellatrix.BeaconPreparableProposer; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.validator.api.CommitteeSubscriptionRequest; - -public interface ValidatorRestApiClient { - - Optional getGenesis(); - - Optional> getValidators(List validatorIds); - - Optional getProposerDuties(final UInt64 epoch); - - Optional sendSignedAttestations(List attestation); - - Optional sendVoluntaryExit(SignedVoluntaryExit voluntaryExit); - - Optional createAggregate(UInt64 slot, Bytes32 attestationHashTreeRoot); - - Optional sendAggregateAndProofs( - List signedAggregateAndProof); - - void subscribeToBeaconCommittee(List requests); - - void subscribeToPersistentSubnets(Set subnetSubscriptions); - - Optional sendSyncCommitteeMessages( - List syncCommitteeMessages); - - void subscribeToSyncCommitteeSubnets(List subnetSubscriptions); - - void sendContributionAndProofs( - final List signedContributionAndProofs); - - Optional createSyncCommitteeContribution( - UInt64 slot, int subcommitteeIndex, Bytes32 beaconBlockRoot); - - void prepareBeaconProposer(final List beaconPreparableProposers); - - Optional sendValidatorsLiveness( - UInt64 epoch, List validatorsIndices); -} diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/eventsource/EventSourceBeaconChainEventAdapter.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/eventsource/EventSourceBeaconChainEventAdapter.java index dd3abeddd3c..3515253d90a 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/eventsource/EventSourceBeaconChainEventAdapter.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/eventsource/EventSourceBeaconChainEventAdapter.java @@ -14,6 +14,7 @@ package tech.pegasys.teku.validator.remote.eventsource; import static java.util.Collections.emptyMap; +import static tech.pegasys.teku.validator.remote.BeaconNodeReadinessManager.ReadinessStatus.READY; import com.google.common.annotations.VisibleForTesting; import com.google.common.base.Preconditions; @@ -24,8 +25,10 @@ import com.launchdarkly.eventsource.background.ConnectionErrorHandler.Action; import java.time.Duration; import java.util.ArrayList; +import java.util.Comparator; import java.util.List; import java.util.Objects; +import java.util.Optional; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; import okhttp3.HttpUrl; @@ -54,7 +57,7 @@ public class EventSourceBeaconChainEventAdapter private final CountDownLatch runningLatch = new CountDownLatch(1); private volatile BackgroundEventSource eventSource; - private volatile RemoteValidatorApiChannel currentBeaconNodeUsedForEventStreaming; + @VisibleForTesting volatile RemoteValidatorApiChannel currentBeaconNodeUsedForEventStreaming; private final BeaconNodeReadinessManager beaconNodeReadinessManager; private final RemoteValidatorApiChannel primaryBeaconNodeApi; @@ -120,14 +123,19 @@ public void onPrimaryNodeNotReady() { } @Override + @SuppressWarnings("FutureReturnValueIgnored") public void onFailoverNodeNotReady(final RemoteValidatorApiChannel failoverNotInSync) { if (currentEventStreamHasSameEndpoint(failoverNotInSync)) { - switchToFailoverEventStreamIfAvailable(); + if (failoverBeaconNodeApis.size() == 1 || !switchToFailoverEventStreamIfAvailable()) { + // No failover switching is available, and we are currently connected to a failover node + // with issues, so trigger the readiness check against the primary BN immediately + beaconNodeReadinessManager.performPrimaryReadinessCheck(); + } } } @Override - public void onPrimaryNodeBackReady() { + public void onPrimaryNodeReady() { if (!currentEventStreamHasSameEndpoint(primaryBeaconNodeApi)) { switchBackToPrimaryEventStream(); } @@ -170,26 +178,34 @@ private HttpUrl createEventStreamSourceUrl( } // synchronized because of the ConnectionErrorHandler and the BeaconNodeReadinessChannel callbacks - private synchronized void switchToFailoverEventStreamIfAvailable() { + private synchronized boolean switchToFailoverEventStreamIfAvailable() { if (failoverBeaconNodeApis.isEmpty()) { - return; + return false; + } + // No need to change anything if current node is READY + if (beaconNodeReadinessManager + .getReadinessStatus(currentBeaconNodeUsedForEventStreaming) + .equals(READY)) { + return false; } - findReadyFailoverAndSwitch(); + return findReadyFailoverAndSwitch(); } - private void findReadyFailoverAndSwitch() { - failoverBeaconNodeApis.stream() - .filter(beaconNodeReadinessManager::isReady) - .findFirst() - .ifPresentOrElse( - this::switchToFailoverEventStream, - validatorLogger::noFailoverBeaconNodesAvailableForEventStreaming); + private boolean findReadyFailoverAndSwitch() { + final Optional readyFailover = + failoverBeaconNodeApis.stream() + .filter(beaconNodeReadinessManager::isReady) + .filter(failover -> !currentEventStreamHasSameEndpoint(failover)) + .max(Comparator.comparing(beaconNodeReadinessManager::getReadinessStatusWeight)); + if (readyFailover.isPresent()) { + switchToFailoverEventStream(readyFailover.get()); + return true; + } + validatorLogger.noFailoverBeaconNodesAvailableForEventStreaming(); + return false; } private void switchToFailoverEventStream(final RemoteValidatorApiChannel beaconNodeApi) { - if (currentEventStreamHasSameEndpoint(beaconNodeApi)) { - return; - } eventSource.close(); eventSource = createEventSource(beaconNodeApi); currentBeaconNodeUsedForEventStreaming = beaconNodeApi; diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/eventsource/EventSourceHandler.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/eventsource/EventSourceHandler.java index 9409daf582d..05e063d5f88 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/eventsource/EventSourceHandler.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/eventsource/EventSourceHandler.java @@ -26,11 +26,9 @@ import org.hyperledger.besu.plugin.services.metrics.Counter; import org.hyperledger.besu.plugin.services.metrics.LabelledMetric; import tech.pegasys.teku.api.response.v1.EventType; -import tech.pegasys.teku.api.response.v1.HeadEvent; import tech.pegasys.teku.infrastructure.json.JsonUtil; import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; import tech.pegasys.teku.infrastructure.metrics.TekuMetricCategory; -import tech.pegasys.teku.provider.JsonProvider; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; import tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing; @@ -40,8 +38,6 @@ class EventSourceHandler implements BackgroundEventHandler { private static final Logger LOG = LogManager.getLogger(); - private final JsonProvider jsonProvider = new JsonProvider(); - private final ValidatorTimingChannel validatorTimingChannel; private final Counter disconnectCounter; private final Counter invalidEventCounter; @@ -112,14 +108,14 @@ public void onMessage(final String event, final MessageEvent messageEvent) { } private void handleHeadEvent(final String data) throws JsonProcessingException { - final HeadEvent headEvent = jsonProvider.jsonToObject(data, HeadEvent.class); + final HeadEvent headEvent = JsonUtil.parse(data, HeadEvent.TYPE_DEFINITION); validatorTimingChannel.onHeadUpdate( - headEvent.slot, - headEvent.previousDutyDependentRoot, - headEvent.currentDutyDependentRoot, - headEvent.block); + headEvent.slot(), + headEvent.previousDutyDependentRoot(), + headEvent.currentDutyDependentRoot(), + headEvent.block()); if (generateEarlyAttestations) { - validatorTimingChannel.onAttestationCreationDue(headEvent.slot); + validatorTimingChannel.onAttestationCreationDue(headEvent.slot()); } } diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/eventsource/HeadEvent.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/eventsource/HeadEvent.java new file mode 100644 index 00000000000..2670ae10b5d --- /dev/null +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/eventsource/HeadEvent.java @@ -0,0 +1,117 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.eventsource; + +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.BOOLEAN_TYPE; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.BYTES32_TYPE; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; + +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; + +record HeadEvent( + UInt64 slot, + Bytes32 block, + Bytes32 state, + boolean epochTransition, + Bytes32 previousDutyDependentRoot, + Bytes32 currentDutyDependentRoot, + Boolean executionOptimistic) { + + static final DeserializableTypeDefinition TYPE_DEFINITION = + DeserializableTypeDefinition.object(HeadEvent.class, HeadEventBuilder.class) + .initializer(HeadEventBuilder::new) + .finisher(HeadEventBuilder::build) + .withField("slot", UINT64_TYPE, HeadEvent::slot, HeadEventBuilder::slot) + .withField("block", BYTES32_TYPE, HeadEvent::block, HeadEventBuilder::block) + .withField("state", BYTES32_TYPE, HeadEvent::state, HeadEventBuilder::state) + .withField( + "epoch_transition", + BOOLEAN_TYPE, + HeadEvent::epochTransition, + HeadEventBuilder::epochTransition) + .withField( + "previous_duty_dependent_root", + BYTES32_TYPE, + HeadEvent::previousDutyDependentRoot, + HeadEventBuilder::previousDutyDependentRoot) + .withField( + "current_duty_dependent_root", + BYTES32_TYPE, + HeadEvent::currentDutyDependentRoot, + HeadEventBuilder::currentDutyDependentRoot) + .withField( + "execution_optimistic", + BOOLEAN_TYPE, + HeadEvent::executionOptimistic, + HeadEventBuilder::executionOptimistic) + .build(); + + private static class HeadEventBuilder { + private UInt64 slot; + private Bytes32 block; + private Bytes32 state; + private boolean epochTransition; + private Bytes32 previousDutyDependentRoot; + private Bytes32 currentDutyDependentRoot; + private boolean executionOptimistic; + + HeadEventBuilder slot(final UInt64 slot) { + this.slot = slot; + return this; + } + + HeadEventBuilder block(final Bytes32 block) { + this.block = block; + return this; + } + + HeadEventBuilder state(final Bytes32 state) { + this.state = state; + return this; + } + + HeadEventBuilder epochTransition(final boolean epochTransition) { + this.epochTransition = epochTransition; + return this; + } + + HeadEventBuilder previousDutyDependentRoot(final Bytes32 previousDutyDependentRoot) { + this.previousDutyDependentRoot = previousDutyDependentRoot; + return this; + } + + HeadEventBuilder currentDutyDependentRoot(final Bytes32 currentDutyDependentRoot) { + this.currentDutyDependentRoot = currentDutyDependentRoot; + return this; + } + + HeadEventBuilder executionOptimistic(final boolean executionOptimistic) { + this.executionOptimistic = executionOptimistic; + return this; + } + + HeadEvent build() { + return new HeadEvent( + slot, + block, + state, + epochTransition, + previousDutyDependentRoot, + currentDutyDependentRoot, + executionOptimistic); + } + } +} diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/sentry/SentryBeaconNodeApi.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/sentry/SentryBeaconNodeApi.java index 9e37d53cec7..20b10f46cce 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/sentry/SentryBeaconNodeApi.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/sentry/SentryBeaconNodeApi.java @@ -182,7 +182,8 @@ private static RemoteValidatorApiChannel createPrimaryValidatorApiChannel( spec, validatorConfig.isValidatorClientUseSszBlocksEnabled(), validatorConfig.isValidatorClientUsePostValidatorsEndpointEnabled(), - asyncRunner); + asyncRunner, + validatorConfig.isAttestationsV2ApisEnabled()); } private static List createFailoverValidatorApiChannel( @@ -201,7 +202,8 @@ private static List createFailoverValidator spec, validatorConfig.isValidatorClientUseSszBlocksEnabled(), validatorConfig.isValidatorClientUsePostValidatorsEndpointEnabled(), - asyncRunner)) + asyncRunner, + validatorConfig.isAttestationsV2ApisEnabled())) .toList(); if (!remoteBeaconNodeEndpoints.getFailoverEndpoints().isEmpty()) { diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/sentry/SentryValidatorApiChannel.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/sentry/SentryValidatorApiChannel.java index 8cc7cc7108c..b632e81e2cb 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/sentry/SentryValidatorApiChannel.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/sentry/SentryValidatorApiChannel.java @@ -24,11 +24,13 @@ import tech.pegasys.teku.api.response.v1.beacon.ValidatorStatus; import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.bls.BLSSignature; +import tech.pegasys.teku.ethereum.json.types.node.PeerCount; import tech.pegasys.teku.ethereum.json.types.validator.AttesterDuties; import tech.pegasys.teku.ethereum.json.types.validator.BeaconCommitteeSelectionProof; import tech.pegasys.teku.ethereum.json.types.validator.ProposerDuties; import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeDuties; import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSelectionProof; +import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.unsigned.UInt64; @@ -42,13 +44,12 @@ import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SignedContributionAndProof; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeContribution; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeMessage; -import tech.pegasys.teku.spec.datastructures.operations.versions.bellatrix.BeaconPreparableProposer; +import tech.pegasys.teku.spec.datastructures.validator.BeaconPreparableProposer; import tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel; import tech.pegasys.teku.spec.datastructures.validator.SubnetSubscription; import tech.pegasys.teku.validator.api.CommitteeSubscriptionRequest; import tech.pegasys.teku.validator.api.SendSignedBlockResult; import tech.pegasys.teku.validator.api.SubmitDataError; -import tech.pegasys.teku.validator.api.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.validator.api.ValidatorApiChannel; public class SentryValidatorApiChannel implements ValidatorApiChannel { @@ -100,17 +101,20 @@ public SafeFuture> getProposerDuties(final UInt64 epoch return dutiesProviderChannel.getProposerDuties(epoch); } + @Override + public SafeFuture> getPeerCount() { + return dutiesProviderChannel.getPeerCount(); + } + @Override public SafeFuture> createUnsignedBlock( final UInt64 slot, final BLSSignature randaoReveal, final Optional graffiti, - final Optional requestedBlinded, final Optional requestedBuilderBoostFactor) { return blockHandlerChannel .orElse(dutiesProviderChannel) - .createUnsignedBlock( - slot, randaoReveal, graffiti, requestedBlinded, requestedBuilderBoostFactor); + .createUnsignedBlock(slot, randaoReveal, graffiti, requestedBuilderBoostFactor); } @Override @@ -121,10 +125,12 @@ public SafeFuture> createAttestationData( @Override public SafeFuture> createAggregate( - final UInt64 slot, final Bytes32 attestationHashTreeRoot) { + final UInt64 slot, + final Bytes32 attestationHashTreeRoot, + final Optional committeeIndex) { return attestationPublisherChannel .orElse(dutiesProviderChannel) - .createAggregate(slot, attestationHashTreeRoot); + .createAggregate(slot, attestationHashTreeRoot, committeeIndex); } @Override @@ -218,7 +224,7 @@ public SafeFuture registerValidators( @Override public SafeFuture>> getValidatorsLiveness( - List validatorIndices, UInt64 epoch) { + final List validatorIndices, final UInt64 epoch) { return dutiesProviderChannel.getValidatorsLiveness(validatorIndices, epoch); } diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/FailureListResponse.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/FailureListResponse.java new file mode 100644 index 00000000000..8d6f1c6053e --- /dev/null +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/FailureListResponse.java @@ -0,0 +1,74 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef; + +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.INTEGER_TYPE; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.STRING_TYPE; + +import java.io.IOException; +import java.util.List; +import java.util.Optional; +import okhttp3.Request; +import okhttp3.Response; +import okhttp3.ResponseBody; +import tech.pegasys.teku.infrastructure.json.JsonUtil; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.validator.api.SubmitDataError; + +public record FailureListResponse(int code, String message, List failures) { + public static DeserializableTypeDefinition getJsonTypeDefinition() { + return DeserializableTypeDefinition.object( + FailureListResponse.class, FailureListResponseBuilder.class) + .initializer(FailureListResponseBuilder::new) + .finisher(FailureListResponseBuilder::build) + .withField( + "code", INTEGER_TYPE, FailureListResponse::code, FailureListResponseBuilder::code) + .withField( + "message", + STRING_TYPE, + FailureListResponse::message, + FailureListResponseBuilder::message) + .withField( + "failures", + DeserializableTypeDefinition.listOf(SubmitDataError.getJsonTypeDefinition()), + FailureListResponse::failures, + FailureListResponseBuilder::failures) + .build(); + } + + public static ResponseHandler getFailureListResponseResponseHandler() { + return new ResponseHandler<>(FailureListResponse.getJsonTypeDefinition()) + .withHandler(SC_OK, FailureListResponse::empty) + .withHandler(SC_BAD_REQUEST, FailureListResponse::onError); + } + + private static Optional empty( + final Request request, final Response response) { + return Optional.empty(); + } + + private static Optional onError( + final Request request, final Response response) { + try { + final ResponseBody responseBody = response.body(); + return Optional.of( + JsonUtil.parse(responseBody.string(), FailureListResponse.getJsonTypeDefinition())); + + } catch (IOException ex) { + throw new IllegalArgumentException("Failed to parse response body", ex); + } + } +} diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/FailureListResponseBuilder.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/FailureListResponseBuilder.java new file mode 100644 index 00000000000..b130acaf5c8 --- /dev/null +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/FailureListResponseBuilder.java @@ -0,0 +1,42 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef; + +import java.util.List; +import tech.pegasys.teku.validator.api.SubmitDataError; + +public class FailureListResponseBuilder { + private int code; + private String message; + private List failures; + + public FailureListResponseBuilder code(final int code) { + this.code = code; + return this; + } + + public FailureListResponseBuilder message(final String message) { + this.message = message; + return this; + } + + public FailureListResponseBuilder failures(final List failures) { + this.failures = failures; + return this; + } + + public FailureListResponse build() { + return new FailureListResponse(code, message, failures); + } +} diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/OkHttpValidatorMinimalTypeDefClient.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/OkHttpValidatorMinimalTypeDefClient.java index e48190d3ca1..a79de7e8cae 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/OkHttpValidatorMinimalTypeDefClient.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/OkHttpValidatorMinimalTypeDefClient.java @@ -13,27 +13,34 @@ package tech.pegasys.teku.validator.remote.typedef; +import java.util.List; import java.util.Map; import java.util.Optional; import okhttp3.HttpUrl; import okhttp3.OkHttpClient; +import tech.pegasys.teku.ethereum.json.types.beacon.StateValidatorData; +import tech.pegasys.teku.infrastructure.json.exceptions.BadRequestException; +import tech.pegasys.teku.spec.datastructures.genesis.GenesisData; +import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; +import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; +import tech.pegasys.teku.validator.remote.typedef.handlers.GetGenesisRequest; import tech.pegasys.teku.validator.remote.typedef.handlers.GetSpecRequest; +import tech.pegasys.teku.validator.remote.typedef.handlers.PostStateValidatorsRequest; +import tech.pegasys.teku.validator.remote.typedef.handlers.PostVoluntaryExitRequest; public class OkHttpValidatorMinimalTypeDefClient { private final OkHttpClient okHttpClient; private final HttpUrl baseEndpoint; - private final GetSpecRequest getSpecRequest; - public OkHttpValidatorMinimalTypeDefClient( - final OkHttpClient okHttpClient, final HttpUrl baseEndpoint) { + final HttpUrl baseEndpoint, final OkHttpClient okHttpClient) { this.okHttpClient = okHttpClient; this.baseEndpoint = baseEndpoint; - this.getSpecRequest = new GetSpecRequest(baseEndpoint, okHttpClient); } public Optional> getSpec() { - return getSpecRequest.getSpec(); + final GetSpecRequest request = new GetSpecRequest(baseEndpoint, okHttpClient); + return request.submit(); } public OkHttpClient getOkHttpClient() { @@ -43,4 +50,26 @@ public OkHttpClient getOkHttpClient() { public HttpUrl getBaseEndpoint() { return baseEndpoint; } + + public Optional getGenesis() { + final GetGenesisRequest request = new GetGenesisRequest(baseEndpoint, okHttpClient); + return request + .submit() + .map( + response -> + new GenesisData(response.getGenesisTime(), response.getGenesisValidatorsRoot())); + } + + public Optional> postStateValidators(final List validatorIds) { + final PostStateValidatorsRequest request = + new PostStateValidatorsRequest(baseEndpoint, okHttpClient); + return request.submit(validatorIds).map(ObjectAndMetaData::getData); + } + + public void sendVoluntaryExit(final SignedVoluntaryExit signedVoluntaryExit) + throws BadRequestException { + final PostVoluntaryExitRequest request = + new PostVoluntaryExitRequest(baseEndpoint, okHttpClient); + request.submit(signedVoluntaryExit); + } } diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/OkHttpValidatorTypeDefClient.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/OkHttpValidatorTypeDefClient.java index dd2942bf816..47538113e45 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/OkHttpValidatorTypeDefClient.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/OkHttpValidatorTypeDefClient.java @@ -13,45 +13,69 @@ package tech.pegasys.teku.validator.remote.typedef; +import java.util.ArrayList; import java.util.Collection; import java.util.List; import java.util.Optional; +import java.util.Set; import okhttp3.HttpUrl; import okhttp3.OkHttpClient; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.api.migrated.ValidatorLivenessAtEpoch; import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.ethereum.json.types.beacon.StateValidatorData; +import tech.pegasys.teku.ethereum.json.types.node.PeerCount; import tech.pegasys.teku.ethereum.json.types.validator.AttesterDuties; import tech.pegasys.teku.ethereum.json.types.validator.BeaconCommitteeSelectionProof; import tech.pegasys.teku.ethereum.json.types.validator.ProposerDuties; import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeDuties; import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSelectionProof; +import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.infrastructure.ssz.SszList; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockContainer; import tech.pegasys.teku.spec.datastructures.builder.SignedValidatorRegistration; -import tech.pegasys.teku.spec.datastructures.genesis.GenesisData; import tech.pegasys.teku.spec.datastructures.metadata.BlockContainerAndMetaData; import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; +import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof; +import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SignedContributionAndProof; +import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeContribution; +import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeMessage; +import tech.pegasys.teku.spec.datastructures.validator.BeaconPreparableProposer; +import tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel; +import tech.pegasys.teku.spec.datastructures.validator.SubnetSubscription; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; +import tech.pegasys.teku.validator.api.CommitteeSubscriptionRequest; import tech.pegasys.teku.validator.api.SendSignedBlockResult; +import tech.pegasys.teku.validator.api.SubmitDataError; import tech.pegasys.teku.validator.api.required.SyncingStatus; import tech.pegasys.teku.validator.remote.typedef.handlers.BeaconCommitteeSelectionsRequest; +import tech.pegasys.teku.validator.remote.typedef.handlers.CreateAggregateAttestationRequest; import tech.pegasys.teku.validator.remote.typedef.handlers.CreateAttestationDataRequest; -import tech.pegasys.teku.validator.remote.typedef.handlers.CreateBlockRequest; -import tech.pegasys.teku.validator.remote.typedef.handlers.GetGenesisRequest; +import tech.pegasys.teku.validator.remote.typedef.handlers.CreateSyncCommitteeContributionRequest; +import tech.pegasys.teku.validator.remote.typedef.handlers.GetPeerCountRequest; import tech.pegasys.teku.validator.remote.typedef.handlers.GetProposerDutiesRequest; import tech.pegasys.teku.validator.remote.typedef.handlers.GetStateValidatorsRequest; import tech.pegasys.teku.validator.remote.typedef.handlers.GetSyncingStatusRequest; import tech.pegasys.teku.validator.remote.typedef.handlers.PostAttesterDutiesRequest; -import tech.pegasys.teku.validator.remote.typedef.handlers.PostStateValidatorsRequest; import tech.pegasys.teku.validator.remote.typedef.handlers.PostSyncDutiesRequest; +import tech.pegasys.teku.validator.remote.typedef.handlers.PrepareBeaconProposersRequest; import tech.pegasys.teku.validator.remote.typedef.handlers.ProduceBlockRequest; import tech.pegasys.teku.validator.remote.typedef.handlers.RegisterValidatorsRequest; +import tech.pegasys.teku.validator.remote.typedef.handlers.SendAggregateAndProofsRequest; +import tech.pegasys.teku.validator.remote.typedef.handlers.SendContributionAndProofsRequest; +import tech.pegasys.teku.validator.remote.typedef.handlers.SendSignedAttestationsRequest; import tech.pegasys.teku.validator.remote.typedef.handlers.SendSignedBlockRequest; +import tech.pegasys.teku.validator.remote.typedef.handlers.SendSubscribeToSyncCommitteeSubnetsRequest; +import tech.pegasys.teku.validator.remote.typedef.handlers.SendSyncCommitteeMessagesRequest; +import tech.pegasys.teku.validator.remote.typedef.handlers.SendValidatorLivenessRequest; +import tech.pegasys.teku.validator.remote.typedef.handlers.SubscribeToBeaconCommitteeRequest; +import tech.pegasys.teku.validator.remote.typedef.handlers.SubscribeToPersistentSubnetsRequest; import tech.pegasys.teku.validator.remote.typedef.handlers.SyncCommitteeSelectionsRequest; public class OkHttpValidatorTypeDefClient extends OkHttpValidatorMinimalTypeDefClient { @@ -60,105 +84,67 @@ public class OkHttpValidatorTypeDefClient extends OkHttpValidatorMinimalTypeDefC private final Spec spec; private final boolean preferSszBlockEncoding; - private final GetSyncingStatusRequest getSyncingStatusRequest; - private final GetGenesisRequest getGenesisRequest; - private final GetProposerDutiesRequest getProposerDutiesRequest; - private final GetStateValidatorsRequest getStateValidatorsRequest; - private final PostAttesterDutiesRequest postAttesterDutiesRequest; - private final PostStateValidatorsRequest postStateValidatorsRequest; - private final PostSyncDutiesRequest postSyncDutiesRequest; - private final SendSignedBlockRequest sendSignedBlockRequest; - private final RegisterValidatorsRequest registerValidatorsRequest; - private final CreateAttestationDataRequest createAttestationDataRequest; - private final BeaconCommitteeSelectionsRequest beaconCommitteeSelectionsRequest; - private final SyncCommitteeSelectionsRequest syncCommitteeSelectionsRequest; + private final SchemaDefinitionCache schemaDefinitionCache; + private final boolean attestationsV2ApisEnabled; public OkHttpValidatorTypeDefClient( final OkHttpClient okHttpClient, final HttpUrl baseEndpoint, final Spec spec, - final boolean preferSszBlockEncoding) { - super(okHttpClient, baseEndpoint); + final boolean preferSszBlockEncoding, + final boolean attestationsV2ApisEnabled) { + super(baseEndpoint, okHttpClient); this.spec = spec; + schemaDefinitionCache = new SchemaDefinitionCache(spec); this.preferSszBlockEncoding = preferSszBlockEncoding; - this.getSyncingStatusRequest = new GetSyncingStatusRequest(okHttpClient, baseEndpoint); - this.getGenesisRequest = new GetGenesisRequest(okHttpClient, baseEndpoint); - this.getProposerDutiesRequest = new GetProposerDutiesRequest(baseEndpoint, okHttpClient); - this.getStateValidatorsRequest = new GetStateValidatorsRequest(baseEndpoint, okHttpClient); - this.postStateValidatorsRequest = new PostStateValidatorsRequest(baseEndpoint, okHttpClient); - this.postSyncDutiesRequest = new PostSyncDutiesRequest(baseEndpoint, okHttpClient); - this.postAttesterDutiesRequest = new PostAttesterDutiesRequest(baseEndpoint, okHttpClient); - this.sendSignedBlockRequest = - new SendSignedBlockRequest(spec, baseEndpoint, okHttpClient, preferSszBlockEncoding); - this.registerValidatorsRequest = - new RegisterValidatorsRequest(baseEndpoint, okHttpClient, false); - this.createAttestationDataRequest = - new CreateAttestationDataRequest(baseEndpoint, okHttpClient); - this.beaconCommitteeSelectionsRequest = - new BeaconCommitteeSelectionsRequest(baseEndpoint, okHttpClient); - this.syncCommitteeSelectionsRequest = - new SyncCommitteeSelectionsRequest(baseEndpoint, okHttpClient); + this.attestationsV2ApisEnabled = attestationsV2ApisEnabled; } public SyncingStatus getSyncingStatus() { - return getSyncingStatusRequest.getSyncingStatus(); - } - - public Optional getGenesis() { - return getGenesisRequest - .getGenesisData() - .map( - response -> - new GenesisData(response.getGenesisTime(), response.getGenesisValidatorsRoot())); + final GetSyncingStatusRequest getSyncingStatusRequest = + new GetSyncingStatusRequest(getBaseEndpoint(), getOkHttpClient()); + return getSyncingStatusRequest.submit(); } public Optional getProposerDuties(final UInt64 epoch) { - return getProposerDutiesRequest.getProposerDuties(epoch); + final GetProposerDutiesRequest getProposerDutiesRequest = + new GetProposerDutiesRequest(getBaseEndpoint(), getOkHttpClient()); + return getProposerDutiesRequest.submit(epoch); } - public Optional> getStateValidators(final List validatorIds) { - return getStateValidatorsRequest - .getStateValidators(validatorIds) - .map(ObjectAndMetaData::getData); + public Optional getPeerCount() { + final GetPeerCountRequest getPeerCountRequest = + new GetPeerCountRequest(getBaseEndpoint(), getOkHttpClient()); + return getPeerCountRequest.submit(); } - public Optional> postStateValidators(final List validatorIds) { - return postStateValidatorsRequest - .postStateValidators(validatorIds) - .map(ObjectAndMetaData::getData); + public Optional> getStateValidators(final List validatorIds) { + final GetStateValidatorsRequest getStateValidatorsRequest = + new GetStateValidatorsRequest(getBaseEndpoint(), getOkHttpClient()); + return getStateValidatorsRequest.submit(validatorIds).map(ObjectAndMetaData::getData); } public Optional postSyncDuties( final UInt64 epoch, final Collection validatorIndices) { - return postSyncDutiesRequest.postSyncDuties(epoch, validatorIndices); + final PostSyncDutiesRequest postSyncDutiesRequest = + new PostSyncDutiesRequest(getBaseEndpoint(), getOkHttpClient()); + return postSyncDutiesRequest.submit(epoch, validatorIndices); } public Optional postAttesterDuties( final UInt64 epoch, final Collection validatorIndices) { - return postAttesterDutiesRequest.postAttesterDuties(epoch, validatorIndices); - } - - public SendSignedBlockResult sendSignedBlock(final SignedBlockContainer blockContainer) { - return sendSignedBlockRequest.sendSignedBlock(blockContainer); + final PostAttesterDutiesRequest postAttesterDutiesRequest = + new PostAttesterDutiesRequest(getBaseEndpoint(), getOkHttpClient()); + return postAttesterDutiesRequest.submit(epoch, validatorIndices); } - @Deprecated - public Optional createUnsignedBlock( - final UInt64 slot, - final BLSSignature randaoReveal, - final Optional graffiti, - final boolean blinded) { - final CreateBlockRequest createBlockRequest = - new CreateBlockRequest( - getBaseEndpoint(), getOkHttpClient(), spec, slot, blinded, preferSszBlockEncoding); - try { - return createBlockRequest.createUnsignedBlock(randaoReveal, graffiti); - } catch (final BlindedBlockEndpointNotAvailableException ex) { - LOG.warn( - "Beacon Node {} does not support blinded block production. Falling back to normal block production.", - getBaseEndpoint()); - return createUnsignedBlock(slot, randaoReveal, graffiti, false); - } + public SendSignedBlockResult sendSignedBlock( + final SignedBlockContainer blockContainer, + final BroadcastValidationLevel broadcastValidationLevel) { + final SendSignedBlockRequest sendSignedBlockRequest = + new SendSignedBlockRequest( + spec, getBaseEndpoint(), getOkHttpClient(), preferSszBlockEncoding); + return sendSignedBlockRequest.submit(blockContainer, broadcastValidationLevel); } public Optional createUnsignedBlock( @@ -168,36 +154,137 @@ public Optional createUnsignedBlock( final Optional requestedBuilderBoostFactor) { final ProduceBlockRequest produceBlockRequest = new ProduceBlockRequest( - getBaseEndpoint(), getOkHttpClient(), spec, slot, preferSszBlockEncoding); - try { - return produceBlockRequest.createUnsignedBlock( - randaoReveal, graffiti, requestedBuilderBoostFactor); - } catch (final BlockProductionV3FailedException ex) { - LOG.warn("Produce Block V3 request failed at slot {}. Retrying with Block V2", slot); - - // Falling back to V2, we have to request a blinded block to be able to support both local and - // builder flow. - return createUnsignedBlock(slot, randaoReveal, graffiti, true); - } + getBaseEndpoint(), + getOkHttpClient(), + schemaDefinitionCache, + slot, + preferSszBlockEncoding); + return produceBlockRequest.submit(randaoReveal, graffiti, requestedBuilderBoostFactor); } public void registerValidators( final SszList validatorRegistrations) { - registerValidatorsRequest.registerValidators(validatorRegistrations); + final RegisterValidatorsRequest registerValidatorsRequest = + new RegisterValidatorsRequest(getBaseEndpoint(), getOkHttpClient(), false); + registerValidatorsRequest.submit(validatorRegistrations); } public Optional createAttestationData( final UInt64 slot, final int committeeIndex) { - return createAttestationDataRequest.createAttestationData(slot, committeeIndex); + + final CreateAttestationDataRequest createAttestationDataRequest = + new CreateAttestationDataRequest(getBaseEndpoint(), getOkHttpClient()); + return createAttestationDataRequest.submit(slot, committeeIndex); } public Optional> getBeaconCommitteeSelectionProof( final List validatorsPartialProofs) { - return beaconCommitteeSelectionsRequest.getSelectionProof(validatorsPartialProofs); + + final BeaconCommitteeSelectionsRequest beaconCommitteeSelectionsRequest = + new BeaconCommitteeSelectionsRequest(getBaseEndpoint(), getOkHttpClient()); + return beaconCommitteeSelectionsRequest.submit(validatorsPartialProofs); } public Optional> getSyncCommitteeSelectionProof( final List validatorsPartialProofs) { - return syncCommitteeSelectionsRequest.getSelectionProof(validatorsPartialProofs); + + final SyncCommitteeSelectionsRequest syncCommitteeSelectionsRequest = + new SyncCommitteeSelectionsRequest(getBaseEndpoint(), getOkHttpClient()); + return syncCommitteeSelectionsRequest.submit(validatorsPartialProofs); + } + + public void subscribeToSyncCommitteeSubnets( + final Collection subscriptions) { + LOG.debug("Subscribing to sync committee subnets {}", subscriptions); + + final SendSubscribeToSyncCommitteeSubnetsRequest subscribeToSyncCommitteeSubnetsRequest = + new SendSubscribeToSyncCommitteeSubnetsRequest(getBaseEndpoint(), getOkHttpClient()); + subscribeToSyncCommitteeSubnetsRequest.submit(subscriptions); + } + + public Optional createSyncCommitteeContribution( + final UInt64 slot, final int subcommitteeIndex, final Bytes32 beaconBlockRoot) { + LOG.debug( + "Create Sync committee contribution for slot {}, subcommitteeIndex {}, root {}", + slot, + subcommitteeIndex, + beaconBlockRoot); + + final CreateSyncCommitteeContributionRequest createSyncCommitteeContributionRequest = + new CreateSyncCommitteeContributionRequest(getBaseEndpoint(), getOkHttpClient(), spec); + return createSyncCommitteeContributionRequest.submit(slot, subcommitteeIndex, beaconBlockRoot); + } + + public void subscribeToPersistentSubnets(final Set subnetSubscriptions) { + final SubscribeToPersistentSubnetsRequest subscribeToPersistentSubnetsRequest = + new SubscribeToPersistentSubnetsRequest(getBaseEndpoint(), getOkHttpClient()); + subscribeToPersistentSubnetsRequest.submit(new ArrayList<>(subnetSubscriptions)); + } + + public void sendContributionAndProofs( + final Collection signedContributionAndProofs) { + + final SendContributionAndProofsRequest sendContributionAndProofsRequest = + new SendContributionAndProofsRequest(getBaseEndpoint(), getOkHttpClient()); + sendContributionAndProofsRequest.submit(signedContributionAndProofs); + } + + public void subscribeToBeaconCommittee(final List subscriptions) { + final SubscribeToBeaconCommitteeRequest subscribeToBeaconCommitteeRequest = + new SubscribeToBeaconCommitteeRequest(getBaseEndpoint(), getOkHttpClient()); + subscribeToBeaconCommitteeRequest.submit(subscriptions); + } + + public void prepareBeaconProposer( + final List beaconPreparableProposers) { + final PrepareBeaconProposersRequest prepareBeaconProposersRequest = + new PrepareBeaconProposersRequest(getBaseEndpoint(), getOkHttpClient()); + prepareBeaconProposersRequest.submit(beaconPreparableProposers); + } + + public Optional> createAggregate( + final UInt64 slot, + final Bytes32 attestationHashTreeRoot, + final Optional committeeIndex) { + final CreateAggregateAttestationRequest createAggregateAttestationRequest = + new CreateAggregateAttestationRequest( + getBaseEndpoint(), + getOkHttpClient(), + schemaDefinitionCache, + slot, + attestationHashTreeRoot, + committeeIndex, + attestationsV2ApisEnabled, + spec); + return createAggregateAttestationRequest.submit(); + } + + public Optional> sendValidatorsLiveness( + final UInt64 epoch, final List validatorIndices) { + final SendValidatorLivenessRequest sendValidatorLivenessRequest = + new SendValidatorLivenessRequest(getBaseEndpoint(), getOkHttpClient()); + return sendValidatorLivenessRequest.submit(epoch, validatorIndices); + } + + public List sendSyncCommitteeMessages( + final List syncCommitteeMessages) { + final SendSyncCommitteeMessagesRequest sendSyncCommitteeMessagesRequest = + new SendSyncCommitteeMessagesRequest(getBaseEndpoint(), getOkHttpClient()); + return sendSyncCommitteeMessagesRequest.submit(syncCommitteeMessages); + } + + public List sendAggregateAndProofs( + final List aggregateAndProofs) { + final SendAggregateAndProofsRequest sendAggregateAndProofsRequest = + new SendAggregateAndProofsRequest( + getBaseEndpoint(), getOkHttpClient(), attestationsV2ApisEnabled, spec); + return sendAggregateAndProofsRequest.submit(aggregateAndProofs); + } + + public List sendSignedAttestations(final List attestations) { + final SendSignedAttestationsRequest sendSignedAttestationsRequest = + new SendSignedAttestationsRequest( + getBaseEndpoint(), getOkHttpClient(), attestationsV2ApisEnabled, spec); + return sendSignedAttestationsRequest.submit(attestations); } } diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/ResponseHandler.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/ResponseHandler.java index 5934fb4c9e7..a38e12469f0 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/ResponseHandler.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/ResponseHandler.java @@ -18,6 +18,7 @@ import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_GATEWAY_TIMEOUT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR; +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NO_CONTENT; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_SERVICE_UNAVAILABLE; @@ -53,6 +54,7 @@ public ResponseHandler(final Optional> maybe withHandler(SC_ACCEPTED, this::noValueHandler); withHandler(SC_NO_CONTENT, this::noValueHandler); withHandler(SC_BAD_REQUEST, this::defaultBadRequestHandler); + withHandler(SC_NOT_FOUND, this::notFoundHandler); withHandler(SC_TOO_MANY_REQUESTS, this::defaultTooManyRequestsHandler); withHandler(SC_INTERNAL_SERVER_ERROR, this::serviceErrorHandler); withHandler(SC_BAD_GATEWAY, this::serviceErrorHandler); @@ -60,6 +62,11 @@ public ResponseHandler(final Optional> maybe withHandler(SC_GATEWAY_TIMEOUT, this::serviceErrorHandler); } + private Optional notFoundHandler(final Request request, final Response response) { + LOG.debug("Request to {} responded with status code {}", request.url(), response.code()); + return Optional.empty(); + } + public ResponseHandler(final DeserializableTypeDefinition typeDefinition) { this(Optional.of(typeDefinition)); } diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/AbstractTypeDefRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/AbstractTypeDefRequest.java index 0a17e1cc0a6..fc211664a33 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/AbstractTypeDefRequest.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/AbstractTypeDefRequest.java @@ -120,13 +120,36 @@ protected Optional postJson( final TObject requestBodyObj, final SerializableTypeDefinition objectTypeDefinition, final ResponseHandler responseHandler) { + return postJson( + apiMethod, + urlParams, + emptyMap(), + emptyMap(), + requestBodyObj, + objectTypeDefinition, + responseHandler); + } + + protected Optional postJson( + final ValidatorApiMethod apiMethod, + final Map urlParams, + final Map queryParams, + final Map headers, + final TObject requestBodyObj, + final SerializableTypeDefinition objectTypeDefinition, + final ResponseHandler responseHandler) { final HttpUrl.Builder httpUrlBuilder = urlBuilder(apiMethod, urlParams); + if (queryParams != null && !queryParams.isEmpty()) { + queryParams.forEach(httpUrlBuilder::addQueryParameter); + } final String requestBody; final Request request; try { + final Request.Builder builder = requestBuilder(); + headers.forEach(builder::addHeader); requestBody = JsonUtil.serialize(requestBodyObj, objectTypeDefinition); request = - requestBuilder() + builder .url(httpUrlBuilder.build()) .post(RequestBody.create(requestBody, APPLICATION_JSON)) .build(); @@ -142,7 +165,20 @@ protected Optional postOctetStream( final Map headers, final byte[] objectBytes, final ResponseHandler responseHandler) { + return postOctetStream(apiMethod, urlParams, emptyMap(), headers, objectBytes, responseHandler); + } + + protected Optional postOctetStream( + final ValidatorApiMethod apiMethod, + final Map urlParams, + final Map queryParams, + final Map headers, + final byte[] objectBytes, + final ResponseHandler responseHandler) { final HttpUrl.Builder httpUrlBuilder = urlBuilder(apiMethod, urlParams); + if (queryParams != null && !queryParams.isEmpty()) { + queryParams.forEach(httpUrlBuilder::addQueryParameter); + } final Request.Builder builder = requestBuilder(); headers.forEach(builder::addHeader); final Request request = diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/BeaconCommitteeSelectionsRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/BeaconCommitteeSelectionsRequest.java index 02c64f85c37..c8517dcd007 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/BeaconCommitteeSelectionsRequest.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/BeaconCommitteeSelectionsRequest.java @@ -35,7 +35,7 @@ public BeaconCommitteeSelectionsRequest( super(baseEndpoint, okHttpClient); } - public Optional> getSelectionProof( + public Optional> submit( final List validatorsPartialProof) { return postJson( ValidatorApiMethod.BEACON_COMMITTEE_SELECTIONS, diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateAggregateAttestationRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateAggregateAttestationRequest.java new file mode 100644 index 00000000000..9e721af7f6e --- /dev/null +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateAggregateAttestationRequest.java @@ -0,0 +1,183 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.ATTESTATION_DATA_ROOT; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.COMMITTEE_INDEX; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.SLOT; +import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.GET_AGGREGATE; +import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.GET_AGGREGATE_V2; + +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; +import okhttp3.HttpUrl; +import okhttp3.OkHttpClient; +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.spec.datastructures.operations.AttestationSchema; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; +import tech.pegasys.teku.validator.remote.typedef.ResponseHandler; + +public class CreateAggregateAttestationRequest extends AbstractTypeDefRequest { + private final SchemaDefinitionCache schemaDefinitionCache; + private final SpecMilestone specMilestone; + private final UInt64 slot; + final Bytes32 attestationHashTreeRoot; + final Optional committeeIndex; + final boolean attestationsV2ApisEnabled; + + public CreateAggregateAttestationRequest( + final HttpUrl baseEndpoint, + final OkHttpClient okHttpClient, + final SchemaDefinitionCache schemaDefinitionCache, + final UInt64 slot, + final Bytes32 attestationHashTreeRoot, + final Optional committeeIndex, + final boolean attestationsV2ApisEnabled, + final Spec spec) { + super(baseEndpoint, okHttpClient); + this.schemaDefinitionCache = schemaDefinitionCache; + this.specMilestone = spec.atSlot(slot).getMilestone(); + this.slot = slot; + this.attestationHashTreeRoot = attestationHashTreeRoot; + this.committeeIndex = committeeIndex; + this.attestationsV2ApisEnabled = attestationsV2ApisEnabled; + } + + public Optional> submit() { + final AttestationSchema attestationSchema = + schemaDefinitionCache.atSlot(slot).getAttestationSchema().castTypeToAttestationSchema(); + + // Use attestation v2 api post Electra only. This logic can be removed once we reach the Electra + // milestone + if (attestationsV2ApisEnabled || specMilestone.isGreaterThanOrEqualTo(SpecMilestone.ELECTRA)) { + if (committeeIndex.isEmpty()) { + throw new IllegalArgumentException("Missing required parameter: committee index"); + } + return submitPostElectra( + slot, attestationHashTreeRoot, committeeIndex.get(), attestationSchema); + } + + return submitPreElectra(slot, attestationHashTreeRoot, attestationSchema, specMilestone); + } + + private Optional> submitPostElectra( + final UInt64 slot, + final Bytes32 attestationHashTreeRoot, + final UInt64 committeeIndex, + final AttestationSchema attestationSchema) { + final DeserializableTypeDefinition + getAggregateAttestationTypeDef = + DeserializableTypeDefinition.object(GetAggregateAttestationResponseV2.class) + .initializer(GetAggregateAttestationResponseV2::new) + .withField( + "version", + DeserializableTypeDefinition.enumOf(SpecMilestone.class), + GetAggregateAttestationResponseV2::getSpecMilestone, + GetAggregateAttestationResponseV2::setSpecMilestone) + .withField( + "data", + attestationSchema.getJsonTypeDefinition(), + GetAggregateAttestationResponse::getData, + GetAggregateAttestationResponse::setData) + .build(); + final ResponseHandler responseHandler = + new ResponseHandler<>(getAggregateAttestationTypeDef); + final Map queryParams = new HashMap<>(); + queryParams.put(SLOT, slot.toString()); + queryParams.put(ATTESTATION_DATA_ROOT, attestationHashTreeRoot.toHexString()); + queryParams.put(COMMITTEE_INDEX, committeeIndex.toString()); + + return get(GET_AGGREGATE_V2, queryParams, responseHandler) + .map( + getAggregateAttestationResponse -> + new ObjectAndMetaData<>( + getAggregateAttestationResponse.getData(), + getAggregateAttestationResponse.getSpecMilestone(), + false, + false, + false)); + } + + private Optional> submitPreElectra( + final UInt64 slot, + final Bytes32 attestationHashTreeRoot, + final AttestationSchema attestationSchema, + final SpecMilestone specMilestone) { + final DeserializableTypeDefinition + getAggregateAttestationTypeDef = + DeserializableTypeDefinition.object(GetAggregateAttestationResponse.class) + .initializer(GetAggregateAttestationResponse::new) + .withField( + "data", + attestationSchema.getJsonTypeDefinition(), + GetAggregateAttestationResponse::getData, + GetAggregateAttestationResponse::setData) + .build(); + final ResponseHandler responseHandler = + new ResponseHandler<>(getAggregateAttestationTypeDef); + final Map queryParams = + Map.of(SLOT, slot.toString(), ATTESTATION_DATA_ROOT, attestationHashTreeRoot.toString()); + + return get(GET_AGGREGATE, queryParams, responseHandler) + .map( + getAggregateAttestationResponse -> + new ObjectAndMetaData<>( + getAggregateAttestationResponse.getData(), specMilestone, false, false, false)); + } + + public static class GetAggregateAttestationResponse { + + private Attestation data; + + public GetAggregateAttestationResponse() {} + + public GetAggregateAttestationResponse(final Attestation data) { + this.data = data; + } + + public Attestation getData() { + return data; + } + + public void setData(final Attestation data) { + this.data = data; + } + } + + public static class GetAggregateAttestationResponseV2 extends GetAggregateAttestationResponse { + + private SpecMilestone specMilestone; + + public GetAggregateAttestationResponseV2() {} + + public GetAggregateAttestationResponseV2(final Attestation data) { + super(data); + } + + public SpecMilestone getSpecMilestone() { + return specMilestone; + } + + public void setSpecMilestone(final SpecMilestone specMilestone) { + this.specMilestone = specMilestone; + } + } +} diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateAttestationDataRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateAttestationDataRequest.java index ca86116d9e9..5a62b43ec36 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateAttestationDataRequest.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateAttestationDataRequest.java @@ -14,6 +14,8 @@ package tech.pegasys.teku.validator.remote.typedef.handlers; import static tech.pegasys.teku.ethereum.json.types.SharedApiTypes.withDataWrapper; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.COMMITTEE_INDEX; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.SLOT; import java.util.HashMap; import java.util.Map; @@ -31,11 +33,10 @@ public CreateAttestationDataRequest(final HttpUrl baseEndpoint, final OkHttpClie super(baseEndpoint, okHttpClient); } - public Optional createAttestationData( - final UInt64 slot, final int committeeIndex) { + public Optional submit(final UInt64 slot, final int committeeIndex) { final Map queryParams = new HashMap<>(); - queryParams.put("slot", slot.toString()); - queryParams.put("committee_index", Integer.toString(committeeIndex)); + queryParams.put(SLOT, slot.toString()); + queryParams.put(COMMITTEE_INDEX, Integer.toString(committeeIndex)); return get( ValidatorApiMethod.GET_ATTESTATION_DATA, queryParams, diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateBlockRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateBlockRequest.java deleted file mode 100644 index 402b65fa03c..00000000000 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateBlockRequest.java +++ /dev/null @@ -1,169 +0,0 @@ -/* - * Copyright Consensys Software Inc., 2022 - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package tech.pegasys.teku.validator.remote.typedef.handlers; - -import static java.util.Collections.emptyMap; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; -import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.GET_UNSIGNED_BLINDED_BLOCK; -import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.GET_UNSIGNED_BLOCK_V2; - -import com.google.common.net.MediaType; -import java.io.IOException; -import java.util.HashMap; -import java.util.Map; -import java.util.Optional; -import okhttp3.HttpUrl; -import okhttp3.OkHttpClient; -import okhttp3.Request; -import okhttp3.Response; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; -import org.apache.tuweni.bytes.Bytes; -import org.apache.tuweni.bytes.Bytes32; -import org.apache.tuweni.units.bigints.UInt256; -import tech.pegasys.teku.bls.BLSSignature; -import tech.pegasys.teku.infrastructure.json.JsonUtil; -import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; -import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.Spec; -import tech.pegasys.teku.spec.SpecMilestone; -import tech.pegasys.teku.spec.datastructures.blocks.BlockContainer; -import tech.pegasys.teku.spec.datastructures.blocks.BlockContainerSchema; -import tech.pegasys.teku.spec.datastructures.metadata.BlockContainerAndMetaData; -import tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod; -import tech.pegasys.teku.validator.remote.typedef.BlindedBlockEndpointNotAvailableException; -import tech.pegasys.teku.validator.remote.typedef.ResponseHandler; - -public class CreateBlockRequest extends AbstractTypeDefRequest { - - private static final Logger LOG = LogManager.getLogger(); - - private final UInt64 slot; - private final boolean preferSszBlockEncoding; - private final ValidatorApiMethod apiMethod; - private final BlockContainerSchema blockContainerSchema; - private final DeserializableTypeDefinition getBlockResponseDefinition; - private final ResponseHandler responseHandler; - - public CreateBlockRequest( - final HttpUrl baseEndpoint, - final OkHttpClient okHttpClient, - final Spec spec, - final UInt64 slot, - final boolean blinded, - final boolean preferSszBlockEncoding) { - super(baseEndpoint, okHttpClient); - this.slot = slot; - this.preferSszBlockEncoding = preferSszBlockEncoding; - apiMethod = blinded ? GET_UNSIGNED_BLINDED_BLOCK : GET_UNSIGNED_BLOCK_V2; - blockContainerSchema = - blinded - ? spec.atSlot(slot).getSchemaDefinitions().getBlindedBlockContainerSchema() - : spec.atSlot(slot).getSchemaDefinitions().getBlockContainerSchema(); - getBlockResponseDefinition = - DeserializableTypeDefinition.object(GetBlockResponse.class) - .initializer(GetBlockResponse::new) - .withField( - "data", - blockContainerSchema.getJsonTypeDefinition(), - GetBlockResponse::getData, - GetBlockResponse::setData) - .withField( - "version", - DeserializableTypeDefinition.enumOf(SpecMilestone.class), - GetBlockResponse::getSpecMilestone, - GetBlockResponse::setSpecMilestone) - .build(); - final ResponseHandler responseHandler = - new ResponseHandler<>(getBlockResponseDefinition) - .withHandler(SC_OK, this::handleBlockContainerResult); - this.responseHandler = - blinded - ? responseHandler.withHandler( - SC_NOT_FOUND, - (__, ___) -> { - throw new BlindedBlockEndpointNotAvailableException(); - }) - : responseHandler; - } - - public Optional createUnsignedBlock( - final BLSSignature randaoReveal, final Optional graffiti) { - final Map queryParams = new HashMap<>(); - queryParams.put("randao_reveal", randaoReveal.toString()); - final Map headers = new HashMap<>(); - graffiti.ifPresent(bytes32 -> queryParams.put("graffiti", bytes32.toHexString())); - - if (preferSszBlockEncoding) { - // application/octet-stream is preferred, but will accept application/json - headers.put("Accept", "application/octet-stream;q=0.9, application/json;q=0.4"); - } - return get( - apiMethod, - Map.of("slot", slot.toString()), - queryParams, - emptyMap(), - headers, - responseHandler) - .map( - response -> - new BlockContainerAndMetaData( - response.getData(), response.getSpecMilestone(), UInt256.ZERO, UInt256.ZERO)); - } - - private Optional handleBlockContainerResult( - final Request request, final Response response) { - try { - final String responseContentType = response.header("Content-Type"); - if (responseContentType != null - && MediaType.parse(responseContentType).is(MediaType.OCTET_STREAM)) { - return Optional.of( - new GetBlockResponse( - blockContainerSchema.sszDeserialize(Bytes.of(response.body().bytes())))); - } - return Optional.of(JsonUtil.parse(response.body().string(), getBlockResponseDefinition)); - } catch (final IOException ex) { - LOG.trace("Failed to parse response object creating block", ex); - } - return Optional.empty(); - } - - static class GetBlockResponse { - private BlockContainer data; - private SpecMilestone specMilestone; - - public GetBlockResponse() {} - - public GetBlockResponse(final BlockContainer data) { - this.data = data; - } - - public BlockContainer getData() { - return data; - } - - public void setData(final BlockContainer data) { - this.data = data; - } - - public SpecMilestone getSpecMilestone() { - return specMilestone; - } - - public void setSpecMilestone(final SpecMilestone specMilestone) { - this.specMilestone = specMilestone; - } - } -} diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateSyncCommitteeContributionRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateSyncCommitteeContributionRequest.java new file mode 100644 index 00000000000..a72d6296c0b --- /dev/null +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/CreateSyncCommitteeContributionRequest.java @@ -0,0 +1,65 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static tech.pegasys.teku.ethereum.json.types.SharedApiTypes.withDataWrapper; +import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.GET_SYNC_COMMITTEE_CONTRIBUTION; + +import java.util.Collections; +import java.util.Map; +import java.util.Optional; +import okhttp3.HttpUrl; +import okhttp3.OkHttpClient; +import org.apache.tuweni.bytes.Bytes32; +import tech.pegasys.teku.infrastructure.http.RestApiConstants; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeContribution; +import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeContributionSchema; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionsAltair; +import tech.pegasys.teku.validator.remote.typedef.ResponseHandler; + +public class CreateSyncCommitteeContributionRequest extends AbstractTypeDefRequest { + private final Spec spec; + + public CreateSyncCommitteeContributionRequest( + final HttpUrl baseEndpoint, final OkHttpClient okHttpClient, final Spec spec) { + super(baseEndpoint, okHttpClient); + this.spec = spec; + } + + public Optional submit( + final UInt64 slot, final int subcommitteeIndex, final Bytes32 beaconBlockRoot) { + if (spec.atSlot(slot).getMilestone().equals(SpecMilestone.PHASE0)) { + return Optional.empty(); + } + final SyncCommitteeContributionSchema syncCommitteeContributionSchema = + SchemaDefinitionsAltair.required(spec.atSlot(slot).getSchemaDefinitions()) + .getSyncCommitteeContributionSchema(); + final Map queryParams = + Map.of( + RestApiConstants.SLOT, + slot.toString(), + RestApiConstants.SUBCOMMITTEE_INDEX, + Integer.toString(subcommitteeIndex), + RestApiConstants.BEACON_BLOCK_ROOT, + beaconBlockRoot.toHexString()); + return get( + GET_SYNC_COMMITTEE_CONTRIBUTION, + Collections.emptyMap(), + queryParams, + new ResponseHandler<>(withDataWrapper(syncCommitteeContributionSchema))); + } +} diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetGenesisRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetGenesisRequest.java index 530d0606332..8a0145d60fc 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetGenesisRequest.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetGenesisRequest.java @@ -24,11 +24,11 @@ public class GetGenesisRequest extends AbstractTypeDefRequest { - public GetGenesisRequest(final OkHttpClient okHttpClient, final HttpUrl baseEndpoint) { + public GetGenesisRequest(final HttpUrl baseEndpoint, final OkHttpClient okHttpClient) { super(baseEndpoint, okHttpClient); } - public Optional getGenesisData() { + public Optional submit() { return get(GET_GENESIS, new ResponseHandler<>(GET_GENESIS_API_DATA_TYPE)); } } diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetPeerCountRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetPeerCountRequest.java new file mode 100644 index 00000000000..27f39639100 --- /dev/null +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetPeerCountRequest.java @@ -0,0 +1,33 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import java.util.Optional; +import okhttp3.HttpUrl; +import okhttp3.OkHttpClient; +import tech.pegasys.teku.ethereum.json.types.node.PeerCount; +import tech.pegasys.teku.ethereum.json.types.node.PeerCountBuilder; +import tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod; +import tech.pegasys.teku.validator.remote.typedef.ResponseHandler; + +public class GetPeerCountRequest extends AbstractTypeDefRequest { + public GetPeerCountRequest(final HttpUrl baseEndpoint, final OkHttpClient okHttpClient) { + super(baseEndpoint, okHttpClient); + } + + public Optional submit() { + return get( + ValidatorApiMethod.GET_PEER_COUNT, new ResponseHandler<>(PeerCountBuilder.PEER_COUNT_TYPE)); + } +} diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetProposerDutiesRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetProposerDutiesRequest.java index b89360e3510..7d718b33015 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetProposerDutiesRequest.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetProposerDutiesRequest.java @@ -30,7 +30,7 @@ public GetProposerDutiesRequest(final HttpUrl baseEndpoint, final OkHttpClient o super(baseEndpoint, okHttpClient); } - public Optional getProposerDuties(final UInt64 epoch) { + public Optional submit(final UInt64 epoch) { return get( GET_PROPOSER_DUTIES, Map.of(EPOCH, epoch.toString()), diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetSpecRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetSpecRequest.java index 96605114cf5..11929be378a 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetSpecRequest.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetSpecRequest.java @@ -28,7 +28,7 @@ public GetSpecRequest(final HttpUrl baseEndpoint, final OkHttpClient okHttpClien super(baseEndpoint, okHttpClient); } - public Optional> getSpec() { + public Optional> submit() { return get(GET_CONFIG_SPEC, Map.of(), Map.of(), new ResponseHandler<>(GET_SPEC_RESPONSE_TYPE)); } } diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetStateValidatorsRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetStateValidatorsRequest.java index 63ae05f54cb..37eed51c1f1 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetStateValidatorsRequest.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetStateValidatorsRequest.java @@ -32,7 +32,7 @@ public GetStateValidatorsRequest(final HttpUrl baseEndpoint, final OkHttpClient super(baseEndpoint, okHttpClient); } - public Optional>> getStateValidators( + public Optional>> submit( final List validatorIds) { return get( GET_VALIDATORS, diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetSyncingStatusRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetSyncingStatusRequest.java index a566fcbb20c..c422ffb554c 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetSyncingStatusRequest.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/GetSyncingStatusRequest.java @@ -23,11 +23,11 @@ public class GetSyncingStatusRequest extends AbstractTypeDefRequest { - public GetSyncingStatusRequest(final OkHttpClient okHttpClient, final HttpUrl baseEndpoint) { + public GetSyncingStatusRequest(final HttpUrl baseEndpoint, final OkHttpClient okHttpClient) { super(baseEndpoint, okHttpClient); } - public SyncingStatus getSyncingStatus() { + public SyncingStatus submit() { return get( GET_SYNCING_STATUS, new ResponseHandler<>(ValidatorRequiredApiTypes.SYNCING_STATUS_RESPONSE)) diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostAttesterDutiesRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostAttesterDutiesRequest.java index fdad8bce7b6..3407b7dce5f 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostAttesterDutiesRequest.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostAttesterDutiesRequest.java @@ -23,6 +23,7 @@ import okhttp3.HttpUrl; import okhttp3.OkHttpClient; import tech.pegasys.teku.ethereum.json.types.validator.AttesterDuties; +import tech.pegasys.teku.infrastructure.http.RestApiConstants; import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.validator.remote.typedef.ResponseHandler; @@ -32,11 +33,11 @@ public PostAttesterDutiesRequest(final HttpUrl baseEndpoint, final OkHttpClient super(baseEndpoint, okHttpClient); } - public Optional postAttesterDuties( + public Optional submit( final UInt64 epoch, final Collection validatorIndices) { return postJson( GET_ATTESTATION_DUTIES, - Map.of("epoch", epoch.toString()), + Map.of(RestApiConstants.EPOCH, epoch.toString()), validatorIndices.stream().toList(), DeserializableTypeDefinition.listOf(INTEGER_TYPE, 1), new ResponseHandler<>(ATTESTER_DUTIES_RESPONSE_TYPE)); diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostStateValidatorsRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostStateValidatorsRequest.java index d1cccf58c32..d86ad07b6d2 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostStateValidatorsRequest.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostStateValidatorsRequest.java @@ -36,7 +36,7 @@ public PostStateValidatorsRequest(final HttpUrl baseEndpoint, final OkHttpClient super(baseEndpoint, okHttpClient); } - public Optional>> postStateValidators( + public Optional>> submit( final List validatorIds) { return postJson( GET_VALIDATORS, diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostSyncDutiesRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostSyncDutiesRequest.java index 36916748bfe..023110760d7 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostSyncDutiesRequest.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostSyncDutiesRequest.java @@ -24,6 +24,7 @@ import okhttp3.HttpUrl; import okhttp3.OkHttpClient; import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeDuties; +import tech.pegasys.teku.infrastructure.http.RestApiConstants; import tech.pegasys.teku.infrastructure.unsigned.UInt64; import tech.pegasys.teku.validator.remote.typedef.ResponseHandler; @@ -32,11 +33,11 @@ public PostSyncDutiesRequest(final HttpUrl baseEndpoint, final OkHttpClient okHt super(baseEndpoint, okHttpClient); } - public Optional postSyncDuties( + public Optional submit( final UInt64 epoch, final Collection validatorIndices) { return postJson( GET_SYNC_COMMITTEE_DUTIES, - Map.of("epoch", epoch.toString()), + Map.of(RestApiConstants.EPOCH, epoch.toString()), validatorIndices.stream().toList(), listOf(INTEGER_TYPE, 1), new ResponseHandler<>(SYNC_COMMITTEE_DUTIES_TYPE)); diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostVoluntaryExitRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostVoluntaryExitRequest.java new file mode 100644 index 00000000000..f8dc5dce8b1 --- /dev/null +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/PostVoluntaryExitRequest.java @@ -0,0 +1,50 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; +import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.SEND_SIGNED_VOLUNTARY_EXIT; + +import java.util.Map; +import okhttp3.HttpUrl; +import okhttp3.OkHttpClient; +import tech.pegasys.teku.infrastructure.json.exceptions.BadRequestException; +import tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit; +import tech.pegasys.teku.validator.remote.apiclient.BeaconNodeApiErrorUtils; +import tech.pegasys.teku.validator.remote.typedef.ResponseHandler; + +public class PostVoluntaryExitRequest extends AbstractTypeDefRequest { + public PostVoluntaryExitRequest(final HttpUrl baseEndpoint, final OkHttpClient okHttpClient) { + super(baseEndpoint, okHttpClient); + } + + public void submit(final SignedVoluntaryExit voluntaryExit) throws BadRequestException { + try { + postJson( + SEND_SIGNED_VOLUNTARY_EXIT, + Map.of(), + voluntaryExit, + SignedVoluntaryExit.SSZ_SCHEMA.getJsonTypeDefinition(), + new ResponseHandler<>() + .withHandler( + SC_BAD_REQUEST, + (request, response) -> { + throw new IllegalArgumentException( + BeaconNodeApiErrorUtils.getErrorMessage(response)); + })); + } catch (final IllegalArgumentException e) { + throw new BadRequestException(e.getMessage()); + } + } +} diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/PrepareBeaconProposersRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/PrepareBeaconProposersRequest.java new file mode 100644 index 00000000000..8fe7251a6ca --- /dev/null +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/PrepareBeaconProposersRequest.java @@ -0,0 +1,48 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition.listOf; +import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.PREPARE_BEACON_PROPOSER; + +import java.util.Collections; +import java.util.List; +import okhttp3.HttpUrl; +import okhttp3.OkHttpClient; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import tech.pegasys.teku.spec.datastructures.validator.BeaconPreparableProposer; +import tech.pegasys.teku.validator.remote.typedef.ResponseHandler; + +public class PrepareBeaconProposersRequest extends AbstractTypeDefRequest { + private static final Logger LOG = LogManager.getLogger(); + + public PrepareBeaconProposersRequest( + final HttpUrl baseEndpoint, final OkHttpClient okHttpClient) { + super(baseEndpoint, okHttpClient); + } + + public void submit(final List requestData) { + if (requestData == null || requestData.isEmpty()) { + LOG.warn("No request data was present for a call to PrepareBeaconProposers"); + return; + } + postJson( + PREPARE_BEACON_PROPOSER, + Collections.emptyMap(), + requestData, + listOf(BeaconPreparableProposer.SSZ_DATA), + new ResponseHandler<>()); + } +} diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/ProduceBlockRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/ProduceBlockRequest.java index 6f8981041a0..5427ea80642 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/ProduceBlockRequest.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/ProduceBlockRequest.java @@ -14,7 +14,6 @@ package tech.pegasys.teku.validator.remote.typedef.handlers; import static java.util.Collections.emptyMap; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.BUILDER_BOOST_FACTOR; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.CONSENSUS_BLOCK_VALUE; @@ -49,12 +48,11 @@ import tech.pegasys.teku.infrastructure.json.types.DeserializableOneOfTypeDefinition; import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.datastructures.blocks.BlockContainer; import tech.pegasys.teku.spec.datastructures.blocks.BlockContainerSchema; import tech.pegasys.teku.spec.datastructures.metadata.BlockContainerAndMetaData; -import tech.pegasys.teku.validator.remote.typedef.BlockProductionV3FailedException; +import tech.pegasys.teku.spec.schemas.SchemaDefinitionCache; import tech.pegasys.teku.validator.remote.typedef.ResponseHandler; public class ProduceBlockRequest extends AbstractTypeDefRequest { @@ -72,15 +70,15 @@ public class ProduceBlockRequest extends AbstractTypeDefRequest { public ProduceBlockRequest( final HttpUrl baseEndpoint, final OkHttpClient okHttpClient, - final Spec spec, + final SchemaDefinitionCache schemaDefinitionCache, final UInt64 slot, final boolean preferSszBlockEncoding) { super(baseEndpoint, okHttpClient); this.slot = slot; this.preferSszBlockEncoding = preferSszBlockEncoding; - this.blockContainerSchema = spec.atSlot(slot).getSchemaDefinitions().getBlockContainerSchema(); + this.blockContainerSchema = schemaDefinitionCache.atSlot(slot).getBlockContainerSchema(); this.blindedBlockContainerSchema = - spec.atSlot(slot).getSchemaDefinitions().getBlindedBlockContainerSchema(); + schemaDefinitionCache.atSlot(slot).getBlindedBlockContainerSchema(); final DeserializableTypeDefinition produceBlockResponseDefinition = buildDeserializableTypeDefinition(blockContainerSchema.getJsonTypeDefinition()); @@ -99,15 +97,10 @@ public ProduceBlockRequest( this.responseHandler = new ResponseHandler<>(produceBlockTypeDefinition) - .withHandler(SC_OK, this::handleBlockContainerResult) - .withHandler( - SC_NOT_FOUND, - (__, ___) -> { - throw new BlockProductionV3FailedException(); - }); + .withHandler(SC_OK, this::handleBlockContainerResult); } - public Optional createUnsignedBlock( + public Optional submit( final BLSSignature randaoReveal, final Optional graffiti, final Optional requestedBuilderBoostFactor) { @@ -254,7 +247,7 @@ public Boolean getExecutionPayloadBlinded() { return executionPayloadBlinded; } - public void setExecutionPayloadBlinded(Boolean executionPayloadBlinded) { + public void setExecutionPayloadBlinded(final Boolean executionPayloadBlinded) { this.executionPayloadBlinded = executionPayloadBlinded; } @@ -262,7 +255,7 @@ public UInt256 getConsensusBlockValue() { return consensusBlockValue; } - public void setConsensusBlockValue(UInt256 consensusBlockValue) { + public void setConsensusBlockValue(final UInt256 consensusBlockValue) { this.consensusBlockValue = consensusBlockValue; } @@ -270,7 +263,7 @@ public UInt256 getExecutionPayloadValue() { return executionPayloadValue; } - public void setExecutionPayloadValue(UInt256 executionPayloadValue) { + public void setExecutionPayloadValue(final UInt256 executionPayloadValue) { this.executionPayloadValue = executionPayloadValue; } diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/RegisterValidatorsRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/RegisterValidatorsRequest.java index fc56ab09c69..0702c4febe5 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/RegisterValidatorsRequest.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/RegisterValidatorsRequest.java @@ -44,8 +44,7 @@ public RegisterValidatorsRequest( this.preferSszEncoding = new AtomicBoolean(preferSszEncoding); } - public void registerValidators( - final SszList validatorRegistrations) { + public void submit(final SszList validatorRegistrations) { if (preferSszEncoding.get()) { sendValidatorRegistrationsAsSszOrFallback(validatorRegistrations); } else { diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendAggregateAndProofsRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendAggregateAndProofsRequest.java new file mode 100644 index 00000000000..f751dd7dfc8 --- /dev/null +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendAggregateAndProofsRequest.java @@ -0,0 +1,96 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition.listOf; +import static tech.pegasys.teku.validator.remote.typedef.FailureListResponse.getFailureListResponseResponseHandler; + +import java.util.Collections; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import okhttp3.HttpUrl; +import okhttp3.OkHttpClient; +import tech.pegasys.teku.infrastructure.http.RestApiConstants; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof; +import tech.pegasys.teku.validator.api.SubmitDataError; +import tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod; +import tech.pegasys.teku.validator.remote.typedef.FailureListResponse; + +public class SendAggregateAndProofsRequest extends AbstractTypeDefRequest { + + private final boolean attestationsV2ApisEnabled; + private final Spec spec; + + public SendAggregateAndProofsRequest( + final HttpUrl baseEndpoint, + final OkHttpClient okHttpClient, + final boolean attestationsV2ApisEnabled, + final Spec spec) { + super(baseEndpoint, okHttpClient); + this.attestationsV2ApisEnabled = attestationsV2ApisEnabled; + this.spec = spec; + } + + public List submit(final List aggregateAndProofs) { + if (aggregateAndProofs.isEmpty()) { + return Collections.emptyList(); + } + + final SpecMilestone specMilestone = + spec.atSlot(aggregateAndProofs.getFirst().getMessage().getAggregate().getData().getSlot()) + .getMilestone(); + + if (attestationsV2ApisEnabled || specMilestone.isGreaterThanOrEqualTo(SpecMilestone.ELECTRA)) { + return submitPostElectra(aggregateAndProofs, specMilestone); + } + return submitPreElectra(aggregateAndProofs); + } + + private List submitPreElectra( + final List aggregateAndProofs) { + return postJson( + ValidatorApiMethod.SEND_SIGNED_AGGREGATE_AND_PROOFS, + Collections.emptyMap(), + aggregateAndProofs, + listOf(getTypeDefinition(aggregateAndProofs)), + getFailureListResponseResponseHandler()) + .map(FailureListResponse::failures) + .orElse(Collections.emptyList()); + } + + private List submitPostElectra( + final List aggregateAndProofs, final SpecMilestone specMilestone) { + return postJson( + ValidatorApiMethod.SEND_SIGNED_AGGREGATE_AND_PROOFS_V2, + Collections.emptyMap(), + Collections.emptyMap(), + Map.of( + RestApiConstants.HEADER_CONSENSUS_VERSION, + specMilestone.name().toLowerCase(Locale.ROOT)), + aggregateAndProofs, + listOf(getTypeDefinition(aggregateAndProofs)), + getFailureListResponseResponseHandler()) + .map(FailureListResponse::failures) + .orElse(Collections.emptyList()); + } + + private static DeserializableTypeDefinition getTypeDefinition( + final List aggregateAndProofs) { + return aggregateAndProofs.getFirst().getSchema().getJsonTypeDefinition(); + } +} diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendContributionAndProofsRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendContributionAndProofsRequest.java new file mode 100644 index 00000000000..779ec0557ed --- /dev/null +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendContributionAndProofsRequest.java @@ -0,0 +1,52 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition.listOf; +import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.SEND_CONTRIBUTION_AND_PROOF; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import okhttp3.HttpUrl; +import okhttp3.OkHttpClient; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SignedContributionAndProof; +import tech.pegasys.teku.validator.remote.typedef.ResponseHandler; + +public class SendContributionAndProofsRequest extends AbstractTypeDefRequest { + private static final Logger LOG = LogManager.getLogger(); + + public SendContributionAndProofsRequest( + final HttpUrl baseEndpoint, final OkHttpClient okHttpClient) { + super(baseEndpoint, okHttpClient); + } + + public void submit(final Collection signedContributionAndProofs) { + if (signedContributionAndProofs == null || signedContributionAndProofs.isEmpty()) { + LOG.warn("Submitted no contribution and proofs"); + return; + } + final List requestData = + new ArrayList<>(signedContributionAndProofs); + postJson( + SEND_CONTRIBUTION_AND_PROOF, + Collections.emptyMap(), + requestData, + listOf(requestData.getFirst().getSchema().getJsonTypeDefinition()), + new ResponseHandler<>()); + } +} diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSignedAttestationsRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSignedAttestationsRequest.java new file mode 100644 index 00000000000..f9f0bc105c5 --- /dev/null +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSignedAttestationsRequest.java @@ -0,0 +1,96 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static java.util.Collections.emptyMap; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; +import static tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition.listOf; +import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.SEND_SIGNED_ATTESTATION_V2; +import static tech.pegasys.teku.validator.remote.typedef.FailureListResponse.getFailureListResponseResponseHandler; + +import java.util.Collections; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import okhttp3.HttpUrl; +import okhttp3.OkHttpClient; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.spec.Spec; +import tech.pegasys.teku.spec.SpecMilestone; +import tech.pegasys.teku.spec.datastructures.operations.Attestation; +import tech.pegasys.teku.validator.api.SubmitDataError; +import tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod; +import tech.pegasys.teku.validator.remote.typedef.FailureListResponse; + +public class SendSignedAttestationsRequest extends AbstractTypeDefRequest { + + private final boolean attestationsV2ApisEnabled; + private final Spec spec; + + public SendSignedAttestationsRequest( + final HttpUrl baseEndpoint, + final OkHttpClient okHttpClient, + final boolean attestationsV2ApisEnabled, + final Spec spec) { + super(baseEndpoint, okHttpClient); + this.attestationsV2ApisEnabled = attestationsV2ApisEnabled; + this.spec = spec; + } + + public List submit(final List attestations) { + if (attestations.isEmpty()) { + return Collections.emptyList(); + } + // Use attestation v2 api post Electra only. This logic can be removed once we reach the Electra + // milestone + final SpecMilestone specMilestone = + spec.atSlot(attestations.getFirst().getData().getSlot()).getMilestone(); + if (attestationsV2ApisEnabled || specMilestone.isGreaterThanOrEqualTo(SpecMilestone.ELECTRA)) { + return submitPostElectra(attestations, specMilestone); + } + return submitPreElectra(attestations); + } + + private List submitPreElectra(final List attestations) { + return postJson( + ValidatorApiMethod.SEND_SIGNED_ATTESTATION, + Collections.emptyMap(), + attestations, + listOf(getJsonTypeDefinition(attestations)), + getFailureListResponseResponseHandler()) + .map(FailureListResponse::failures) + .orElse(Collections.emptyList()); + } + + private List submitPostElectra( + final List attestations, final SpecMilestone specMilestone) { + return postJson( + SEND_SIGNED_ATTESTATION_V2, + emptyMap(), + emptyMap(), + Map.of(HEADER_CONSENSUS_VERSION, specMilestone.name().toLowerCase(Locale.ROOT)), + attestations, + listOf(getJsonTypeDefinition(attestations)), + getFailureListResponseResponseHandler()) + .map(FailureListResponse::failures) + .orElse(Collections.emptyList()); + } + + @SuppressWarnings("unchecked") + private DeserializableTypeDefinition getJsonTypeDefinition( + final List attestations) { + return (DeserializableTypeDefinition) + attestations.getFirst().getSchema().getJsonTypeDefinition(); + } +} diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSignedBlockRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSignedBlockRequest.java index b39d334aad4..bb70aa7ef79 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSignedBlockRequest.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSignedBlockRequest.java @@ -13,12 +13,13 @@ package tech.pegasys.teku.validator.remote.typedef.handlers; +import static java.util.Collections.emptyMap; import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_UNSUPPORTED_MEDIA_TYPE; import static tech.pegasys.teku.infrastructure.http.RestApiConstants.HEADER_CONSENSUS_VERSION; -import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.SEND_SIGNED_BLINDED_BLOCK; -import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.SEND_SIGNED_BLOCK; +import static tech.pegasys.teku.infrastructure.http.RestApiConstants.PARAM_BROADCAST_VALIDATION; +import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.SEND_SIGNED_BLINDED_BLOCK_V2; +import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.SEND_SIGNED_BLOCK_V2; -import java.util.Collections; import java.util.Locale; import java.util.Map; import java.util.Optional; @@ -31,6 +32,7 @@ import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.SpecMilestone; import tech.pegasys.teku.spec.datastructures.blocks.SignedBlockContainer; +import tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel; import tech.pegasys.teku.spec.schemas.SchemaDefinitions; import tech.pegasys.teku.validator.api.SendSignedBlockResult; import tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod; @@ -55,33 +57,42 @@ public SendSignedBlockRequest( this.preferSszBlockEncoding = new AtomicBoolean(preferSszBlockEncoding); } - public SendSignedBlockResult sendSignedBlock(final SignedBlockContainer signedBlockContainer) { + public SendSignedBlockResult submit( + final SignedBlockContainer signedBlockContainer, + final BroadcastValidationLevel broadcastValidationLevel) { final boolean blinded = signedBlockContainer.isBlinded(); - final ValidatorApiMethod apiMethod = blinded ? SEND_SIGNED_BLINDED_BLOCK : SEND_SIGNED_BLOCK; + final ValidatorApiMethod apiMethod = + blinded ? SEND_SIGNED_BLINDED_BLOCK_V2 : SEND_SIGNED_BLOCK_V2; final SchemaDefinitions schemaDefinitions = spec.atSlot(signedBlockContainer.getSlot()).getSchemaDefinitions(); + final SpecMilestone milestone = spec.atSlot(signedBlockContainer.getSlot()).getMilestone(); + final Map headers = + Map.of(HEADER_CONSENSUS_VERSION, milestone.name().toLowerCase(Locale.ROOT)); final DeserializableTypeDefinition typeDefinition = blinded ? schemaDefinitions.getSignedBlindedBlockContainerSchema().getJsonTypeDefinition() : schemaDefinitions.getSignedBlockContainerSchema().getJsonTypeDefinition(); - return preferSszBlockEncoding.get() - ? sendSignedBlockAsSszOrFallback(apiMethod, signedBlockContainer, typeDefinition) - : sendSignedBlockAsJson(apiMethod, signedBlockContainer, typeDefinition); + ? sendSignedBlockAsSszOrFallback( + apiMethod, signedBlockContainer, broadcastValidationLevel, typeDefinition, headers) + : sendSignedBlockAsJson( + apiMethod, signedBlockContainer, broadcastValidationLevel, typeDefinition, headers); } private SendSignedBlockResult sendSignedBlockAsSszOrFallback( final ValidatorApiMethod apiMethod, final SignedBlockContainer signedBlockContainer, - final DeserializableTypeDefinition typeDefinition) { - final SpecMilestone milestone = spec.atSlot(signedBlockContainer.getSlot()).getMilestone(); + final BroadcastValidationLevel broadcastValidationLevel, + final DeserializableTypeDefinition typeDefinition, + final Map headers) { final SendSignedBlockResult result = - sendSignedBlockAsSsz(apiMethod, signedBlockContainer, milestone); + sendSignedBlockAsSsz(apiMethod, signedBlockContainer, broadcastValidationLevel, headers); if (!result.isPublished() && !preferSszBlockEncoding.get()) { - return sendSignedBlockAsJson(apiMethod, signedBlockContainer, typeDefinition); + return sendSignedBlockAsJson( + apiMethod, signedBlockContainer, broadcastValidationLevel, typeDefinition, headers); } return result; } @@ -89,11 +100,15 @@ private SendSignedBlockResult sendSignedBlockAsSszOrFallback( private SendSignedBlockResult sendSignedBlockAsSsz( final ValidatorApiMethod apiMethod, final SignedBlockContainer signedBlockContainer, - final SpecMilestone milestone) { + final BroadcastValidationLevel broadcastValidationLevel, + final Map headers) { return postOctetStream( apiMethod, - Collections.emptyMap(), - Map.of(HEADER_CONSENSUS_VERSION, milestone.name().toLowerCase(Locale.ROOT)), + emptyMap(), + Map.of( + PARAM_BROADCAST_VALIDATION, + broadcastValidationLevel.name().toLowerCase(Locale.ROOT)), + headers, signedBlockContainer.sszSerialize().toArray(), sszResponseHandler) .map(__ -> SendSignedBlockResult.success(signedBlockContainer.getRoot())) @@ -103,10 +118,16 @@ private SendSignedBlockResult sendSignedBlockAsSsz( private SendSignedBlockResult sendSignedBlockAsJson( final ValidatorApiMethod apiMethod, final SignedBlockContainer signedBlockContainer, - final DeserializableTypeDefinition typeDefinition) { + final BroadcastValidationLevel broadcastValidationLevel, + final DeserializableTypeDefinition typeDefinition, + final Map headers) { return postJson( apiMethod, - Collections.emptyMap(), + emptyMap(), + Map.of( + PARAM_BROADCAST_VALIDATION, + broadcastValidationLevel.name().toLowerCase(Locale.ROOT)), + headers, signedBlockContainer, typeDefinition, new ResponseHandler<>()) diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSubscribeToSyncCommitteeSubnetsRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSubscribeToSyncCommitteeSubnetsRequest.java new file mode 100644 index 00000000000..a2cc53ecb2d --- /dev/null +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSubscribeToSyncCommitteeSubnetsRequest.java @@ -0,0 +1,46 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static tech.pegasys.teku.ethereum.json.types.validator.PostSyncCommitteeData.SYNC_COMMITTEE_SUBSCRIPTION; +import static tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition.listOf; +import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.SUBSCRIBE_TO_SYNC_COMMITTEE_SUBNET; + +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import okhttp3.HttpUrl; +import okhttp3.OkHttpClient; +import tech.pegasys.teku.ethereum.json.types.validator.PostSyncCommitteeData; +import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSubnetSubscription; +import tech.pegasys.teku.validator.remote.typedef.ResponseHandler; + +public class SendSubscribeToSyncCommitteeSubnetsRequest extends AbstractTypeDefRequest { + + public SendSubscribeToSyncCommitteeSubnetsRequest( + final HttpUrl baseEndpoint, final OkHttpClient okHttpClient) { + super(baseEndpoint, okHttpClient); + } + + public void submit(final Collection subscriptions) { + final List requestData = + subscriptions.stream().map(PostSyncCommitteeData::new).toList(); + postJson( + SUBSCRIBE_TO_SYNC_COMMITTEE_SUBNET, + Collections.emptyMap(), + requestData, + listOf(SYNC_COMMITTEE_SUBSCRIPTION), + new ResponseHandler<>()); + } +} diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSyncCommitteeMessagesRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSyncCommitteeMessagesRequest.java new file mode 100644 index 00000000000..293de5190e3 --- /dev/null +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendSyncCommitteeMessagesRequest.java @@ -0,0 +1,50 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition.listOf; +import static tech.pegasys.teku.validator.remote.typedef.FailureListResponse.getFailureListResponseResponseHandler; + +import java.util.Collections; +import java.util.List; +import okhttp3.HttpUrl; +import okhttp3.OkHttpClient; +import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition; +import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeMessage; +import tech.pegasys.teku.validator.api.SubmitDataError; +import tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod; +import tech.pegasys.teku.validator.remote.typedef.FailureListResponse; + +public class SendSyncCommitteeMessagesRequest extends AbstractTypeDefRequest { + public SendSyncCommitteeMessagesRequest( + final HttpUrl baseEndpoint, final OkHttpClient okHttpClient) { + super(baseEndpoint, okHttpClient); + } + + public List submit(final List syncCommitteeMessages) { + if (syncCommitteeMessages.isEmpty()) { + return Collections.emptyList(); + } + final DeserializableTypeDefinition jsonTypeDefinition = + syncCommitteeMessages.getFirst().getSchema().getJsonTypeDefinition(); + return postJson( + ValidatorApiMethod.SEND_SYNC_COMMITTEE_MESSAGES, + Collections.emptyMap(), + syncCommitteeMessages, + listOf(jsonTypeDefinition), + getFailureListResponseResponseHandler()) + .map(FailureListResponse::failures) + .orElse(Collections.emptyList()); + } +} diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendValidatorLivenessRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendValidatorLivenessRequest.java new file mode 100644 index 00000000000..4daabcb531c --- /dev/null +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SendValidatorLivenessRequest.java @@ -0,0 +1,52 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static tech.pegasys.teku.ethereum.json.types.SharedApiTypes.withDataWrapper; +import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.UINT64_TYPE; +import static tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition.listOf; +import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.SEND_VALIDATOR_LIVENESS; + +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import okhttp3.HttpUrl; +import okhttp3.OkHttpClient; +import tech.pegasys.teku.api.migrated.ValidatorLivenessAtEpoch; +import tech.pegasys.teku.infrastructure.http.RestApiConstants; +import tech.pegasys.teku.infrastructure.unsigned.UInt64; +import tech.pegasys.teku.validator.remote.typedef.ResponseHandler; + +public class SendValidatorLivenessRequest extends AbstractTypeDefRequest { + + public SendValidatorLivenessRequest(final HttpUrl baseEndpoint, final OkHttpClient okHttpClient) { + super(baseEndpoint, okHttpClient); + } + + public Optional> submit( + final UInt64 epoch, final List validatorIndices) { + return postJson( + SEND_VALIDATOR_LIVENESS, + Map.of(RestApiConstants.EPOCH, epoch.toString()), + Collections.emptyMap(), + Collections.emptyMap(), + validatorIndices, + listOf(UINT64_TYPE), + new ResponseHandler<>( + withDataWrapper( + "SendValidatorLivenessResponse", + listOf(ValidatorLivenessAtEpoch.getJsonTypeDefinition())))); + } +} diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SubscribeToBeaconCommitteeRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SubscribeToBeaconCommitteeRequest.java new file mode 100644 index 00000000000..f8684c0bebf --- /dev/null +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SubscribeToBeaconCommitteeRequest.java @@ -0,0 +1,43 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition.listOf; +import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.SUBSCRIBE_TO_BEACON_COMMITTEE_SUBNET; + +import java.util.Collections; +import java.util.List; +import okhttp3.HttpUrl; +import okhttp3.OkHttpClient; +import tech.pegasys.teku.validator.api.CommitteeSubscriptionData; +import tech.pegasys.teku.validator.api.CommitteeSubscriptionRequest; +import tech.pegasys.teku.validator.remote.typedef.ResponseHandler; + +public class SubscribeToBeaconCommitteeRequest extends AbstractTypeDefRequest { + public SubscribeToBeaconCommitteeRequest( + final HttpUrl baseEndpoint, final OkHttpClient okHttpClient) { + super(baseEndpoint, okHttpClient); + } + + public void submit(final List subscriptions) { + final List request = + subscriptions.stream().map(CommitteeSubscriptionData::create).toList(); + postJson( + SUBSCRIBE_TO_BEACON_COMMITTEE_SUBNET, + Collections.emptyMap(), + request, + listOf(CommitteeSubscriptionData.SSZ_DATA), + new ResponseHandler<>()); + } +} diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SubscribeToPersistentSubnetsRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SubscribeToPersistentSubnetsRequest.java new file mode 100644 index 00000000000..d938538af45 --- /dev/null +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SubscribeToPersistentSubnetsRequest.java @@ -0,0 +1,41 @@ +/* + * Copyright Consensys Software Inc., 2024 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package tech.pegasys.teku.validator.remote.typedef.handlers; + +import static tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition.listOf; +import static tech.pegasys.teku.validator.remote.apiclient.ValidatorApiMethod.SUBSCRIBE_TO_PERSISTENT_SUBNETS; + +import java.util.Collections; +import java.util.List; +import okhttp3.HttpUrl; +import okhttp3.OkHttpClient; +import tech.pegasys.teku.spec.datastructures.validator.SubnetSubscription; +import tech.pegasys.teku.validator.remote.typedef.ResponseHandler; + +public class SubscribeToPersistentSubnetsRequest extends AbstractTypeDefRequest { + + public SubscribeToPersistentSubnetsRequest( + final HttpUrl baseEndpoint, final OkHttpClient okHttpClient) { + super(baseEndpoint, okHttpClient); + } + + public void submit(final List subnetSubscriptions) { + postJson( + SUBSCRIBE_TO_PERSISTENT_SUBNETS, + Collections.emptyMap(), + subnetSubscriptions, + listOf(SubnetSubscription.SSZ_DATA), + new ResponseHandler<>()); + } +} diff --git a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SyncCommitteeSelectionsRequest.java b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SyncCommitteeSelectionsRequest.java index c3facbae2bb..69f6d4f968c 100644 --- a/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SyncCommitteeSelectionsRequest.java +++ b/validator/remote/src/main/java/tech/pegasys/teku/validator/remote/typedef/handlers/SyncCommitteeSelectionsRequest.java @@ -35,7 +35,7 @@ public SyncCommitteeSelectionsRequest( super(baseEndpoint, okHttpClient); } - public Optional> getSelectionProof( + public Optional> submit( final List validatorsPartialProof) { return postJson( ValidatorApiMethod.SYNC_COMMITTEE_SELECTIONS, diff --git a/validator/remote/src/test/java/tech/pegasys/teku/validator/remote/BeaconNodeReadinessManagerTest.java b/validator/remote/src/test/java/tech/pegasys/teku/validator/remote/BeaconNodeReadinessManagerTest.java index fac3a91736c..56277f2b03a 100644 --- a/validator/remote/src/test/java/tech/pegasys/teku/validator/remote/BeaconNodeReadinessManagerTest.java +++ b/validator/remote/src/test/java/tech/pegasys/teku/validator/remote/BeaconNodeReadinessManagerTest.java @@ -15,13 +15,18 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoInteractions; import static org.mockito.Mockito.when; import java.util.List; import java.util.Optional; +import org.assertj.core.api.InstanceOfAssertFactories; +import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import tech.pegasys.teku.ethereum.json.types.node.PeerCount; +import tech.pegasys.teku.ethereum.json.types.node.PeerCountBuilder; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.logging.ValidatorLogger; import tech.pegasys.teku.infrastructure.unsigned.UInt64; @@ -29,8 +34,11 @@ public class BeaconNodeReadinessManagerTest { - private static final SyncingStatus SYNCED_STATUS = - new SyncingStatus(UInt64.ONE, UInt64.ZERO, false, Optional.empty(), Optional.empty()); + private static final SyncingStatus SYNCED_OPTIMISTIC_STATUS = + new SyncingStatus(UInt64.ONE, UInt64.ZERO, false, Optional.of(true), Optional.empty()); + + private static final SyncingStatus SYNCED_NON_OPTIMISTIC_STATUS = + new SyncingStatus(UInt64.ONE, UInt64.ZERO, false, Optional.of(false), Optional.empty()); private static final SyncingStatus SYNCING_STATUS = new SyncingStatus(UInt64.ONE, UInt64.ZERO, true, Optional.empty(), Optional.empty()); @@ -41,6 +49,11 @@ public class BeaconNodeReadinessManagerTest { private static final SyncingStatus EL_OFFLINE_STATUS = new SyncingStatus(UInt64.ONE, UInt64.ZERO, true, Optional.of(true), Optional.of(true)); + private final PeerCount notEnoughPeers = + new PeerCountBuilder().connected(UInt64.valueOf(2)).disconnected(UInt64.valueOf(60)).build(); + private final PeerCount enoughPeers = + new PeerCountBuilder().connected(UInt64.valueOf(51)).disconnected(UInt64.valueOf(60)).build(); + private final RemoteValidatorApiChannel beaconNodeApi = mock(RemoteValidatorApiChannel.class); private final RemoteValidatorApiChannel failoverBeaconNodeApi = mock(RemoteValidatorApiChannel.class); @@ -57,6 +70,13 @@ public class BeaconNodeReadinessManagerTest { validatorLogger, beaconNodeReadinessChannel); + @BeforeEach + public void setup() { + when(beaconNodeApi.getPeerCount()).thenReturn(SafeFuture.completedFuture(Optional.empty())); + when(failoverBeaconNodeApi.getPeerCount()) + .thenReturn(SafeFuture.completedFuture(Optional.empty())); + } + @Test public void performsReadinessCheckOnStartup() { // default to true if never started @@ -89,7 +109,8 @@ public void retrievesReadinessAndPublishesToAChannel() { verifyNoInteractions(validatorLogger, beaconNodeReadinessChannel); - when(beaconNodeApi.getSyncingStatus()).thenReturn(SafeFuture.completedFuture(SYNCED_STATUS)); + when(beaconNodeApi.getSyncingStatus()) + .thenReturn(SafeFuture.completedFuture(SYNCED_OPTIMISTIC_STATUS)); when(failoverBeaconNodeApi.getSyncingStatus()) .thenReturn(SafeFuture.completedFuture(SYNCING_STATUS)); @@ -115,14 +136,16 @@ public void retrievesReadinessAndPublishesToAChannel() { verify(beaconNodeReadinessChannel).onPrimaryNodeNotReady(); // primary node recovers - when(beaconNodeApi.getSyncingStatus()).thenReturn(SafeFuture.completedFuture(SYNCED_STATUS)); + when(beaconNodeApi.getSyncingStatus()) + .thenReturn(SafeFuture.completedFuture(SYNCED_OPTIMISTIC_STATUS)); advanceToNextQueryPeriod(beaconNodeReadinessManager); assertThat(beaconNodeReadinessManager.isReady(beaconNodeApi)).isTrue(); verify(validatorLogger).primaryBeaconNodeIsBackAndReady(); - verify(beaconNodeReadinessChannel).onPrimaryNodeBackReady(); + // call it every time we check, channel will filter it + verify(beaconNodeReadinessChannel, times(2)).onPrimaryNodeReady(); } @Test @@ -136,7 +159,7 @@ public void shouldFallbackToFailoverNodeWhenElGoesOffline() { when(beaconNodeApi.getSyncingStatus()) .thenReturn(SafeFuture.completedFuture(EL_OFFLINE_STATUS)); when(failoverBeaconNodeApi.getSyncingStatus()) - .thenReturn(SafeFuture.completedFuture(SYNCED_STATUS)); + .thenReturn(SafeFuture.completedFuture(SYNCED_OPTIMISTIC_STATUS)); advanceToNextQueryPeriod(beaconNodeReadinessManager); @@ -148,30 +171,73 @@ public void shouldFallbackToFailoverNodeWhenElGoesOffline() { } @Test - public void ordersFailoversByReadiness() { - final RemoteValidatorApiChannel anotherFailover = mock(RemoteValidatorApiChannel.class); - final RemoteValidatorApiChannel yetAnotherFailover = mock(RemoteValidatorApiChannel.class); + public void ordersFailoversByReadinessStatus() { + + // Primary BN, synced optimistic + final RemoteValidatorApiChannel primaryBeaconNodeApi = mock(RemoteValidatorApiChannel.class); + when(primaryBeaconNodeApi.getSyncingStatus()) + .thenReturn(SafeFuture.completedFuture(SYNCED_OPTIMISTIC_STATUS)); + // Since the BN is optimistic, the peer count won't be checked + when(primaryBeaconNodeApi.getPeerCount()) + .thenReturn(SafeFuture.completedFuture(Optional.of(enoughPeers))); + + // Failover BN, syncing + final RemoteValidatorApiChannel syncingFailover = mock(RemoteValidatorApiChannel.class); + when(syncingFailover.getSyncingStatus()).thenReturn(SafeFuture.completedFuture(SYNCING_STATUS)); + // Since the BN is syncing/not ready, the peer count won't be checked + when(syncingFailover.getPeerCount()) + .thenReturn(SafeFuture.completedFuture(Optional.of(enoughPeers))); + + // Failover BN, synced optimistic + final RemoteValidatorApiChannel syncedOptimisticFailover = + mock(RemoteValidatorApiChannel.class); + when(syncedOptimisticFailover.getSyncingStatus()) + .thenReturn(SafeFuture.completedFuture(SYNCED_OPTIMISTIC_STATUS)); + // Since the BN is optimistic, the peer count won't be checked + when(syncedOptimisticFailover.getPeerCount()) + .thenReturn(SafeFuture.completedFuture(Optional.of(enoughPeers))); + + // Failover BN synced and non-optimistic/ready + final RemoteValidatorApiChannel syncedNonOptimisticNotEnoughPeersFailover = + mock(RemoteValidatorApiChannel.class); + when(syncedNonOptimisticNotEnoughPeersFailover.getSyncingStatus()) + .thenReturn(SafeFuture.completedFuture(SYNCED_NON_OPTIMISTIC_STATUS)); + // Failover BN doesn't have enough connected peers + when(syncedNonOptimisticNotEnoughPeersFailover.getPeerCount()) + .thenReturn(SafeFuture.completedFuture(Optional.of(notEnoughPeers))); + + // Failover BN synced and non-optimistic/ready + final RemoteValidatorApiChannel syncedNonOptimisticEnoughPeersFailover = + mock(RemoteValidatorApiChannel.class); + when(syncedNonOptimisticEnoughPeersFailover.getSyncingStatus()) + .thenReturn(SafeFuture.completedFuture(SYNCED_NON_OPTIMISTIC_STATUS)); + // Failover BN has enough connected peers + when(syncedNonOptimisticEnoughPeersFailover.getPeerCount()) + .thenReturn(SafeFuture.completedFuture(Optional.of(enoughPeers))); + final BeaconNodeReadinessManager beaconNodeReadinessManager = new BeaconNodeReadinessManager( - beaconNodeApi, - List.of(failoverBeaconNodeApi, anotherFailover, yetAnotherFailover), + primaryBeaconNodeApi, + List.of( + syncingFailover, + syncedOptimisticFailover, + syncedNonOptimisticNotEnoughPeersFailover, + syncedNonOptimisticEnoughPeersFailover), validatorLogger, beaconNodeReadinessChannel); - when(beaconNodeApi.getSyncingStatus()).thenReturn(SafeFuture.completedFuture(SYNCED_STATUS)); - - when(failoverBeaconNodeApi.getSyncingStatus()) - .thenReturn(SafeFuture.completedFuture(SYNCING_STATUS)); - when(anotherFailover.getSyncingStatus()).thenReturn(SafeFuture.completedFuture(SYNCED_STATUS)); - when(yetAnotherFailover.getSyncingStatus()) - .thenReturn(SafeFuture.completedFuture(SYNCING_STATUS)); - advanceToNextQueryPeriod(beaconNodeReadinessManager); + // The expected order should be: ready/non-optimistic with enough peers -> ready/non-optimistic + // without enough peers -> optimistic -> syncing/not ready assertThat(beaconNodeReadinessManager.getFailoversInOrderOfReadiness()) .toIterable() - .asList() - .containsExactly(anotherFailover, failoverBeaconNodeApi, yetAnotherFailover); + .asInstanceOf(InstanceOfAssertFactories.LIST) + .containsExactly( + syncedNonOptimisticEnoughPeersFailover, + syncedNonOptimisticNotEnoughPeersFailover, + syncedOptimisticFailover, + syncingFailover); } private void advanceToNextQueryPeriod( diff --git a/validator/remote/src/test/java/tech/pegasys/teku/validator/remote/FailoverValidatorApiHandlerTest.java b/validator/remote/src/test/java/tech/pegasys/teku/validator/remote/FailoverValidatorApiHandlerTest.java index 5ab9a07ce31..1ace735c94d 100644 --- a/validator/remote/src/test/java/tech/pegasys/teku/validator/remote/FailoverValidatorApiHandlerTest.java +++ b/validator/remote/src/test/java/tech/pegasys/teku/validator/remote/FailoverValidatorApiHandlerTest.java @@ -51,6 +51,7 @@ import tech.pegasys.teku.ethereum.json.types.validator.AttesterDuties; import tech.pegasys.teku.ethereum.json.types.validator.ProposerDuties; import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeDuties; +import tech.pegasys.teku.ethereum.json.types.validator.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.async.SafeFutureAssert; import tech.pegasys.teku.infrastructure.metrics.StubMetricsSystem; @@ -69,14 +70,13 @@ import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SignedContributionAndProof; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeContribution; import tech.pegasys.teku.spec.datastructures.operations.versions.altair.SyncCommitteeMessage; -import tech.pegasys.teku.spec.datastructures.operations.versions.bellatrix.BeaconPreparableProposer; +import tech.pegasys.teku.spec.datastructures.validator.BeaconPreparableProposer; import tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel; import tech.pegasys.teku.spec.datastructures.validator.SubnetSubscription; import tech.pegasys.teku.spec.util.DataStructureUtil; import tech.pegasys.teku.validator.api.CommitteeSubscriptionRequest; import tech.pegasys.teku.validator.api.SendSignedBlockResult; import tech.pegasys.teku.validator.api.SubmitDataError; -import tech.pegasys.teku.validator.api.SyncCommitteeSubnetSubscription; import tech.pegasys.teku.validator.api.ValidatorApiChannel; import tech.pegasys.teku.validator.beaconnode.metrics.BeaconNodeRequestLabels; import tech.pegasys.teku.validator.remote.FailoverValidatorApiHandler.RequestOutcome; @@ -584,8 +584,7 @@ public void publishesBlindedBlockOnlyToTheBeaconNodeWhichCreatedIt() { final ValidatorApiChannelRequest> creationRequest = apiChannel -> - apiChannel.createUnsignedBlock( - slot, randaoReveal, Optional.empty(), Optional.of(true), Optional.empty()); + apiChannel.createUnsignedBlock(slot, randaoReveal, Optional.empty(), Optional.empty()); setupFailures(creationRequest, primaryApiChannel); setupSuccesses(creationRequest, Optional.of(blindedBlock), failoverApiChannel1); @@ -593,7 +592,7 @@ public void publishesBlindedBlockOnlyToTheBeaconNodeWhichCreatedIt() { SafeFutureAssert.assertThatSafeFuture(creationRequest.run(failoverApiHandler)).isCompleted(); final SignedBeaconBlock blindedSignedBlock = - DATA_STRUCTURE_UTIL.randomSignedBlindedBeaconBlock(UInt64.ONE); + DATA_STRUCTURE_UTIL.signedBlock(blindedBlock.blockContainer().getBlock()); final ValidatorApiChannelRequest publishingRequest = apiChannel -> @@ -687,7 +686,7 @@ private static Stream getRequestsUsingFailover() { "createUnsignedBlock", apiChannel -> apiChannel.createUnsignedBlock( - slot, randaoReveal, Optional.empty(), Optional.of(false), Optional.empty()), + slot, randaoReveal, Optional.empty(), Optional.empty()), BeaconNodeRequestLabels.CREATE_UNSIGNED_BLOCK_METHOD, Optional.of(mock(BlockContainerAndMetaData.class))), getArguments( @@ -697,7 +696,7 @@ private static Stream getRequestsUsingFailover() { Optional.of(mock(AttestationData.class))), getArguments( "createAggregate", - apiChannel -> apiChannel.createAggregate(slot, randomBytes32), + apiChannel -> apiChannel.createAggregate(slot, randomBytes32, Optional.empty()), BeaconNodeRequestLabels.CREATE_AGGREGATE_METHOD, Optional.of(attestation)), getArguments( diff --git a/validator/remote/src/test/java/tech/pegasys/teku/validator/remote/RemoteValidatorApiHandlerTest.java b/validator/remote/src/test/java/tech/pegasys/teku/validator/remote/RemoteValidatorApiHandlerTest.java index 73ef31d0afc..4e47f2a5428 100644 --- a/validator/remote/src/test/java/tech/pegasys/teku/validator/remote/RemoteValidatorApiHandlerTest.java +++ b/validator/remote/src/test/java/tech/pegasys/teku/validator/remote/RemoteValidatorApiHandlerTest.java @@ -21,13 +21,13 @@ import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyInt; import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import static tech.pegasys.teku.infrastructure.async.SafeFutureAssert.assertThatSafeFuture; import static tech.pegasys.teku.infrastructure.async.SafeFutureAssert.safeJoin; -import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST; import static tech.pegasys.teku.infrastructure.ssz.SszDataAssert.assertThatSszData; import static tech.pegasys.teku.infrastructure.unsigned.UInt64.ONE; import static tech.pegasys.teku.spec.config.SpecConfig.FAR_FUTURE_EPOCH; @@ -48,14 +48,12 @@ import org.junit.jupiter.api.Test; import org.mockito.ArgumentCaptor; import tech.pegasys.teku.api.migrated.ValidatorLivenessAtEpoch; -import tech.pegasys.teku.api.response.v1.beacon.PostDataFailure; -import tech.pegasys.teku.api.response.v1.beacon.PostDataFailureResponse; import tech.pegasys.teku.api.response.v1.beacon.ValidatorStatus; -import tech.pegasys.teku.api.response.v1.validator.PostValidatorLivenessResponse; -import tech.pegasys.teku.api.response.v1.validator.ValidatorLiveness; import tech.pegasys.teku.bls.BLSPublicKey; import tech.pegasys.teku.bls.BLSSignature; import tech.pegasys.teku.ethereum.json.types.beacon.StateValidatorData; +import tech.pegasys.teku.ethereum.json.types.node.PeerCount; +import tech.pegasys.teku.ethereum.json.types.node.PeerCountBuilder; import tech.pegasys.teku.ethereum.json.types.validator.AttesterDuties; import tech.pegasys.teku.ethereum.json.types.validator.AttesterDuty; import tech.pegasys.teku.ethereum.json.types.validator.BeaconCommitteeSelectionProof; @@ -74,21 +72,18 @@ import tech.pegasys.teku.spec.datastructures.builder.SignedValidatorRegistration; import tech.pegasys.teku.spec.datastructures.genesis.GenesisData; import tech.pegasys.teku.spec.datastructures.metadata.BlockContainerAndMetaData; -import tech.pegasys.teku.spec.datastructures.operations.AggregateAndProof; +import tech.pegasys.teku.spec.datastructures.metadata.ObjectAndMetaData; import tech.pegasys.teku.spec.datastructures.operations.Attestation; import tech.pegasys.teku.spec.datastructures.operations.AttestationData; -import tech.pegasys.teku.spec.datastructures.operations.SignedAggregateAndProof; import tech.pegasys.teku.spec.datastructures.state.Validator; import tech.pegasys.teku.spec.datastructures.validator.BroadcastValidationLevel; import tech.pegasys.teku.spec.datastructures.validator.SubnetSubscription; import tech.pegasys.teku.spec.util.DataStructureUtil; import tech.pegasys.teku.validator.api.CommitteeSubscriptionRequest; import tech.pegasys.teku.validator.api.SendSignedBlockResult; -import tech.pegasys.teku.validator.api.SubmitDataError; import tech.pegasys.teku.validator.api.required.SyncingStatus; import tech.pegasys.teku.validator.remote.apiclient.PostStateValidatorsNotExistingException; import tech.pegasys.teku.validator.remote.apiclient.RateLimitedException; -import tech.pegasys.teku.validator.remote.apiclient.ValidatorRestApiClient; import tech.pegasys.teku.validator.remote.typedef.OkHttpValidatorTypeDefClient; class RemoteValidatorApiHandlerTest { @@ -98,8 +93,6 @@ class RemoteValidatorApiHandlerTest { private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); private final StubAsyncRunner asyncRunner = new StubAsyncRunner(); - private final ValidatorRestApiClient apiClient = mock(ValidatorRestApiClient.class); - private final OkHttpValidatorTypeDefClient typeDefClient = mock(OkHttpValidatorTypeDefClient.class); @@ -107,8 +100,7 @@ class RemoteValidatorApiHandlerTest { @BeforeEach public void beforeEach() { - apiHandler = - new RemoteValidatorApiHandler(endpoint, spec, apiClient, typeDefClient, asyncRunner, true); + apiHandler = new RemoteValidatorApiHandler(endpoint, typeDefClient, asyncRunner, true); } @Test @@ -439,6 +431,19 @@ public void getProposerDuties_WhenFound_ReturnsDuties() { assertThat(validatorDuties.getDependentRoot()).isEqualTo(response.getDependentRoot()); } + @Test + public void getPeerCount_WhenAvailable_ReturnPeerCount() { + final PeerCount response = + new PeerCountBuilder() + .connected(UInt64.valueOf(10)) + .disconnected(UInt64.valueOf(5)) + .build(); + when(typeDefClient.getPeerCount()).thenReturn(Optional.of(response)); + final SafeFuture> peerCountFuture = apiHandler.getPeerCount(); + PeerCount peerCount = unwrapToValue(peerCountFuture); + assertThat(peerCount).isEqualTo(response); + } + @Test public void createAttestationData_WhenNone_ReturnsEmpty() { when(typeDefClient.createAttestationData(any(), anyInt())).thenReturn(Optional.empty()); @@ -460,40 +465,13 @@ public void createAttestationData_WhenFound_ReturnsAttestation() { assertThatSszData(unwrapToValue(future)).isEqualByAllMeansTo(attestation.getData()); } - @Test - public void sendSignedAttestation_InvokeApiWithCorrectRequest() { - final Attestation attestation = dataStructureUtil.randomAttestation(); - - final PostDataFailureResponse failureResponse = - new PostDataFailureResponse( - SC_BAD_REQUEST, "Oh no", List.of(new PostDataFailure(UInt64.ZERO, "Bad"))); - when(apiClient.sendSignedAttestations(any())).thenReturn(Optional.of(failureResponse)); - - final tech.pegasys.teku.api.schema.Attestation schemaAttestation = - new tech.pegasys.teku.api.schema.Attestation(attestation); - - @SuppressWarnings("unchecked") - ArgumentCaptor> argumentCaptor = - ArgumentCaptor.forClass(List.class); - - final SafeFuture> result = - apiHandler.sendSignedAttestations(List.of(attestation)); - asyncRunner.executeQueuedActions(); - - verify(apiClient).sendSignedAttestations(argumentCaptor.capture()); - assertThat(argumentCaptor.getValue()) - .usingRecursiveComparison() - .isEqualTo(List.of(schemaAttestation)); - assertThat(result).isCompletedWithValue(List.of(new SubmitDataError(UInt64.ZERO, "Bad"))); - } - @Test public void createUnsignedBlock_WhenNoneFound_ReturnsEmpty() { final BLSSignature blsSignature = dataStructureUtil.randomSignature(); SafeFuture> future = apiHandler.createUnsignedBlock( - ONE, blsSignature, Optional.of(Bytes32.random()), Optional.of(false), Optional.empty()); + ONE, blsSignature, Optional.of(Bytes32.random()), Optional.empty()); assertThat(unwrapToOptional(future)).isEmpty(); } @@ -509,12 +487,11 @@ public void createUnsignedBlock_WhenFound_ReturnsBlock() { eq(blockContainerAndMetaData.blockContainer().getSlot()), eq(blsSignature), eq(graffiti), - eq(false))) + eq(Optional.empty()))) .thenReturn(Optional.of(blockContainerAndMetaData)); SafeFuture> future = - apiHandler.createUnsignedBlock( - ONE, blsSignature, graffiti, Optional.of(false), Optional.empty()); + apiHandler.createUnsignedBlock(ONE, blsSignature, graffiti, Optional.empty()); final BlockContainerAndMetaData resultValue = unwrapToValue(future); assertThat(resultValue).isEqualTo(blockContainerAndMetaData); @@ -539,8 +516,7 @@ public void createUnsignedBlock_viaBlockV3_WhenFound_ReturnsBlock() { .thenReturn(Optional.of(blockContainerAndMetaData)); SafeFuture> future = - apiHandler.createUnsignedBlock( - ONE, blsSignature, graffiti, Optional.empty(), Optional.of(ONE)); + apiHandler.createUnsignedBlock(ONE, blsSignature, graffiti, Optional.of(ONE)); final BlockContainerAndMetaData resultValue = unwrapToValue(future); assertThat(resultValue).isEqualTo(blockContainerAndMetaData); @@ -561,12 +537,11 @@ public void createUnsignedBlock_WhenFound_ReturnsBlockContents() { eq(blockContentsAndMetaData.blockContainer().getSlot()), eq(blsSignature), eq(graffiti), - eq(false))) + eq(Optional.empty()))) .thenReturn(Optional.of(blockContentsAndMetaData)); SafeFuture> future = - apiHandler.createUnsignedBlock( - ONE, blsSignature, graffiti, Optional.of(false), Optional.empty()); + apiHandler.createUnsignedBlock(ONE, blsSignature, graffiti, Optional.empty()); final BlockContainerAndMetaData resultValue = unwrapToValue(future); assertThat(resultValue).isEqualTo(blockContentsAndMetaData); @@ -582,16 +557,17 @@ public void sendSignedBlock_InvokeApiWithCorrectRequest() { dataStructureUtil.signedBlock(beaconBlock, signature); final SendSignedBlockResult expectedResult = SendSignedBlockResult.success(Bytes32.ZERO); - when(typeDefClient.sendSignedBlock(any())).thenReturn(expectedResult); + when(typeDefClient.sendSignedBlock(any(), any())).thenReturn(expectedResult); ArgumentCaptor argumentCaptor = ArgumentCaptor.forClass(SignedBeaconBlock.class); final SafeFuture result = - apiHandler.sendSignedBlock(signedBeaconBlock, BroadcastValidationLevel.NOT_REQUIRED); + apiHandler.sendSignedBlock(signedBeaconBlock, BroadcastValidationLevel.GOSSIP); asyncRunner.executeQueuedActions(); - verify(typeDefClient).sendSignedBlock(argumentCaptor.capture()); + verify(typeDefClient) + .sendSignedBlock(argumentCaptor.capture(), eq(BroadcastValidationLevel.GOSSIP)); assertThat(argumentCaptor.getValue()).isEqualTo(signedBeaconBlock); assertThat(result).isCompletedWithValue(expectedResult); } @@ -601,9 +577,12 @@ public void createAggregate_WhenNotFound_ReturnsEmpty() { final UInt64 slot = dataStructureUtil.randomUInt64(); final Bytes32 attHashTreeRoot = Bytes32.random(); - when(apiClient.createAggregate(eq(slot), eq(attHashTreeRoot))).thenReturn(Optional.empty()); + doReturn(Optional.empty()) + .when(typeDefClient) + .createAggregate(slot, attHashTreeRoot, Optional.empty()); - SafeFuture> future = apiHandler.createAggregate(slot, attHashTreeRoot); + SafeFuture> future = + apiHandler.createAggregate(slot, attHashTreeRoot, Optional.of(ONE)); assertThat(unwrapToOptional(future)).isEmpty(); } @@ -614,44 +593,19 @@ public void createAggregate_WhenFound_ReturnsAttestation() { final Bytes32 attHashTreeRoot = Bytes32.random(); final Attestation attestation = dataStructureUtil.randomAttestation(); - final tech.pegasys.teku.api.schema.Attestation schemaAttestation = - new tech.pegasys.teku.api.schema.Attestation(attestation); + final ObjectAndMetaData attestationAndMetaData = + new ObjectAndMetaData<>(attestation, spec.atSlot(slot).getMilestone(), false, true, true); - when(apiClient.createAggregate(eq(slot), eq(attHashTreeRoot))) - .thenReturn(Optional.of(schemaAttestation)); + doReturn(Optional.of(attestationAndMetaData)) + .when(typeDefClient) + .createAggregate(slot, attHashTreeRoot, Optional.of(ONE)); - SafeFuture> future = apiHandler.createAggregate(slot, attHashTreeRoot); + SafeFuture> future = + apiHandler.createAggregate(slot, attHashTreeRoot, Optional.of(ONE)); assertThatSszData(unwrapToValue(future)).isEqualByAllMeansTo(attestation); } - @SuppressWarnings("unchecked") - @Test - public void sendsAggregateAndProof_InvokeApiWithCorrectRequest() { - final AggregateAndProof aggregateAndProof = dataStructureUtil.randomAggregateAndProof(); - final BLSSignature signature = dataStructureUtil.randomSignature(); - final SignedAggregateAndProof signedAggregateAndProof = - spec.getGenesisSchemaDefinitions() - .getSignedAggregateAndProofSchema() - .create(aggregateAndProof, signature); - - tech.pegasys.teku.api.schema.SignedAggregateAndProof schemaSignedAggAndProof = - new tech.pegasys.teku.api.schema.SignedAggregateAndProof(signedAggregateAndProof); - - ArgumentCaptor> argumentCaptor = - ArgumentCaptor.forClass(List.class); - - final SafeFuture> result = - apiHandler.sendAggregateAndProofs(List.of(signedAggregateAndProof)); - asyncRunner.executeQueuedActions(); - - verify(apiClient).sendAggregateAndProofs(argumentCaptor.capture()); - assertThat(argumentCaptor.getValue()) - .usingRecursiveComparison() - .isEqualTo(List.of(schemaSignedAggAndProof)); - assertThat(result).isCompletedWithValue(emptyList()); - } - @Test public void subscribeToBeaconCommitteeForAggregation_InvokeApi() { final int validatorIndex = 3; @@ -668,7 +622,7 @@ public void subscribeToBeaconCommitteeForAggregation_InvokeApi() { asyncRunner.executeQueuedActions(); assertThat(result).isCompleted(); - verify(apiClient).subscribeToBeaconCommittee(requests); + verify(typeDefClient).subscribeToBeaconCommittee(requests); } @Test @@ -678,10 +632,8 @@ public void subscribeToPersistentSubnets_InvokeApi() { final UInt64 slot = ONE; final SubnetSubscription subnetSubscription = new SubnetSubscription(subnetId, slot); - final tech.pegasys.teku.api.schema.SubnetSubscription schemaSubnetSubscription = - new tech.pegasys.teku.api.schema.SubnetSubscription(subnetId, slot); - final ArgumentCaptor> argumentCaptor = + final ArgumentCaptor> argumentCaptor = ArgumentCaptor.forClass(Set.class); final SafeFuture result = @@ -689,13 +641,11 @@ public void subscribeToPersistentSubnets_InvokeApi() { asyncRunner.executeQueuedActions(); assertThat(result).isCompleted(); - verify(apiClient).subscribeToPersistentSubnets(argumentCaptor.capture()); + verify(typeDefClient).subscribeToPersistentSubnets(argumentCaptor.capture()); - final Set request = argumentCaptor.getValue(); + final Set request = argumentCaptor.getValue(); assertThat(request).hasSize(1); - assertThat(request.stream().findFirst().orElseThrow()) - .usingRecursiveComparison() - .isEqualTo(schemaSubnetSubscription); + assertThat(request.stream().findFirst().orElseThrow()).isEqualTo(subnetSubscription); } @Test @@ -715,7 +665,7 @@ void shouldRetryAfterDelayWhenRequestRateLimited() { } @Test - public void registerValidators_InvokeApiWithCorrectRequest() { + public void registerValidators_invokeApiWithCorrectRequest() { final SszList validatorRegistrations = dataStructureUtil.randomSignedValidatorRegistrations(5); @@ -727,7 +677,7 @@ public void registerValidators_InvokeApiWithCorrectRequest() { } @Test - public void checkValidatorsDoppelganger_InvokeApiWithCorrectRequest() + public void checkValidatorsDoppelganger_invokeApiWithCorrectRequest() throws ExecutionException, InterruptedException { final List validatorIndices = List.of( @@ -741,7 +691,7 @@ public void checkValidatorsDoppelganger_InvokeApiWithCorrectRequest() assertThat(result).isCompleted(); assertThat(result.get()).isEmpty(); - verify(apiClient).sendValidatorsLiveness(epoch, validatorIndices); + verify(typeDefClient).sendValidatorsLiveness(epoch, validatorIndices); } @Test @@ -755,15 +705,13 @@ public void checkValidatorsDoppelgangerShouldReturnDoppelgangerDetectionResult() List validatorIndices = List.of(firstIndex, secondIndex, thirdIndex); - List validatorLivenesses = + List validatorLivenesses = List.of( - new ValidatorLiveness(firstIndex, false), - new ValidatorLiveness(secondIndex, true), - new ValidatorLiveness(thirdIndex, true)); - PostValidatorLivenessResponse postValidatorLivenessResponse = - new PostValidatorLivenessResponse(validatorLivenesses); - when(apiClient.sendValidatorsLiveness(any(), any())) - .thenReturn(Optional.of(postValidatorLivenessResponse)); + new ValidatorLivenessAtEpoch(firstIndex, false), + new ValidatorLivenessAtEpoch(secondIndex, true), + new ValidatorLivenessAtEpoch(thirdIndex, true)); + when(typeDefClient.sendValidatorsLiveness(any(), any())) + .thenReturn(Optional.of(validatorLivenesses)); final SafeFuture>> result = apiHandler.getValidatorsLiveness(validatorIndices, epoch); @@ -775,19 +723,20 @@ public void checkValidatorsDoppelgangerShouldReturnDoppelgangerDetectionResult() assertThat(validatorIsLive(validatorLivenessAtEpochesResult, firstIndex)).isFalse(); assertThat(validatorIsLive(validatorLivenessAtEpochesResult, secondIndex)).isTrue(); assertThat(validatorIsLive(validatorLivenessAtEpochesResult, thirdIndex)).isTrue(); - verify(apiClient).sendValidatorsLiveness(epoch, validatorIndices); + verify(typeDefClient).sendValidatorsLiveness(epoch, validatorIndices); } private boolean validatorIsLive( - List validatorLivenessAtEpoches, UInt64 validatorIndex) { + final List validatorLivenessAtEpoches, + final UInt64 validatorIndex) { return validatorLivenessAtEpoches.stream() .anyMatch( validatorLivenessAtEpoch -> - validatorLivenessAtEpoch.getIndex().equals(validatorIndex) + validatorLivenessAtEpoch.index().equals(validatorIndex) && validatorLivenessAtEpoch.isLive()); } - private Optional unwrapToOptional(SafeFuture> future) { + private Optional unwrapToOptional(final SafeFuture> future) { try { asyncRunner.executeQueuedActions(); return Waiter.waitFor(future); @@ -797,7 +746,7 @@ private Optional unwrapToOptional(SafeFuture> future) { } } - private T unwrapToValue(SafeFuture> future) { + private T unwrapToValue(final SafeFuture> future) { try { asyncRunner.executeQueuedActions(); return Waiter.waitFor(future).orElseThrow(); diff --git a/validator/remote/src/test/java/tech/pegasys/teku/validator/remote/eventsource/EventSourceBeaconChainEventAdapterTest.java b/validator/remote/src/test/java/tech/pegasys/teku/validator/remote/eventsource/EventSourceBeaconChainEventAdapterTest.java index 8702ba74a03..df1a5b0b39f 100644 --- a/validator/remote/src/test/java/tech/pegasys/teku/validator/remote/eventsource/EventSourceBeaconChainEventAdapterTest.java +++ b/validator/remote/src/test/java/tech/pegasys/teku/validator/remote/eventsource/EventSourceBeaconChainEventAdapterTest.java @@ -16,11 +16,13 @@ import static java.util.Collections.emptyMap; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import java.net.URI; import java.util.ArrayList; +import java.util.List; import java.util.stream.Stream; import okhttp3.HttpUrl; import okhttp3.OkHttpClient; @@ -28,12 +30,15 @@ import org.hyperledger.besu.plugin.services.metrics.Counter; import org.hyperledger.besu.plugin.services.metrics.LabelledMetric; import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.ValueSource; import tech.pegasys.teku.api.response.v1.EventType; +import tech.pegasys.teku.infrastructure.async.SafeFuture; import tech.pegasys.teku.infrastructure.logging.ValidatorLogger; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.validator.api.ValidatorTimingChannel; +import tech.pegasys.teku.validator.api.required.SyncingStatus; import tech.pegasys.teku.validator.beaconnode.BeaconChainEventAdapter; import tech.pegasys.teku.validator.remote.BeaconNodeReadinessManager; import tech.pegasys.teku.validator.remote.RemoteValidatorApiChannel; @@ -69,6 +74,71 @@ public void shouldSubscribeToSlashingEvents(final boolean shutdownWhenValidatorS verifyEventSourceSubscriptionUrl(httpUrlMock, shutdownWhenValidatorSlashedEnabled); } + @Test + public void performsPrimaryReadinessCheckWhenFailoverNotReadyAndNoOtherFailoversAvailable() { + final BeaconNodeReadinessManager beaconNodeReadinessManager = + mock(BeaconNodeReadinessManager.class); + final RemoteValidatorApiChannel failover = mock(RemoteValidatorApiChannel.class); + final EventSourceBeaconChainEventAdapter eventSourceBeaconChainEventAdapter = + new EventSourceBeaconChainEventAdapter( + beaconNodeReadinessManager, + mock(RemoteValidatorApiChannel.class), + List.of(failover), + mock(OkHttpClient.class), + mock(ValidatorLogger.class), + mock(BeaconChainEventAdapter.class), + mock(ValidatorTimingChannel.class), + metricsSystemMock, + true, + false, + mock(Spec.class)); + + eventSourceBeaconChainEventAdapter.currentBeaconNodeUsedForEventStreaming = failover; + + eventSourceBeaconChainEventAdapter.onFailoverNodeNotReady(failover); + + verify(beaconNodeReadinessManager).performPrimaryReadinessCheck(); + } + + @Test + public void doNotSwitchToFailoverWhenCurrentBeaconNodeIsReady() { + final BeaconNodeReadinessManager beaconNodeReadinessManager = + mock(BeaconNodeReadinessManager.class); + final RemoteValidatorApiChannel primaryNode = mock(RemoteValidatorApiChannel.class); + final RemoteValidatorApiChannel failover1 = mock(RemoteValidatorApiChannel.class); + final RemoteValidatorApiChannel failover2 = mock(RemoteValidatorApiChannel.class); + final EventSourceBeaconChainEventAdapter eventSourceBeaconChainEventAdapter = + new EventSourceBeaconChainEventAdapter( + beaconNodeReadinessManager, + primaryNode, + List.of(failover1, failover2), + mock(OkHttpClient.class), + mock(ValidatorLogger.class), + mock(BeaconChainEventAdapter.class), + mock(ValidatorTimingChannel.class), + metricsSystemMock, + true, + false, + mock(Spec.class)); + + eventSourceBeaconChainEventAdapter.currentBeaconNodeUsedForEventStreaming = failover1; + + when(beaconNodeReadinessManager.getReadinessStatus(failover1)) + .thenReturn(BeaconNodeReadinessManager.ReadinessStatus.READY); + final SafeFuture someFuture = new SafeFuture<>(); + when(primaryNode.getSyncingStatus()).thenReturn(someFuture); + eventSourceBeaconChainEventAdapter.onFailoverNodeNotReady(failover1); + + verify(beaconNodeReadinessManager).getReadinessStatus(failover1); + // Shouldn't try failover2 when failover1 is good + verify(beaconNodeReadinessManager, never()).getReadinessStatus(failover2); + verify(beaconNodeReadinessManager, never()).getReadinessStatusWeight(failover2); + verify(beaconNodeReadinessManager, never()).isReady(any()); + + // But will try to return to primaryNode when it's possible + verify(beaconNodeReadinessManager).performPrimaryReadinessCheck(); + } + private EventSourceBeaconChainEventAdapter initEventSourceBeaconChainEventAdapter( final boolean shutdownWhenValidatorSlashedEnabled) { return new EventSourceBeaconChainEventAdapter( diff --git a/validator/remote/src/test/java/tech/pegasys/teku/validator/remote/eventsource/EventSourceHandlerTest.java b/validator/remote/src/test/java/tech/pegasys/teku/validator/remote/eventsource/EventSourceHandlerTest.java index d6e9189549a..3838c12355d 100644 --- a/validator/remote/src/test/java/tech/pegasys/teku/validator/remote/eventsource/EventSourceHandlerTest.java +++ b/validator/remote/src/test/java/tech/pegasys/teku/validator/remote/eventsource/EventSourceHandlerTest.java @@ -24,15 +24,14 @@ import org.apache.tuweni.bytes.Bytes32; import org.junit.jupiter.api.Test; import tech.pegasys.teku.api.response.v1.EventType; -import tech.pegasys.teku.api.response.v1.HeadEvent; import tech.pegasys.teku.infrastructure.json.JsonUtil; import tech.pegasys.teku.infrastructure.metrics.StubMetricsSystem; import tech.pegasys.teku.infrastructure.unsigned.UInt64; -import tech.pegasys.teku.provider.JsonProvider; import tech.pegasys.teku.spec.Spec; import tech.pegasys.teku.spec.TestSpecFactory; import tech.pegasys.teku.spec.datastructures.blocks.SignedBeaconBlockHeader; import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashing; +import tech.pegasys.teku.spec.datastructures.operations.AttesterSlashingSchema; import tech.pegasys.teku.spec.datastructures.operations.IndexedAttestation; import tech.pegasys.teku.spec.datastructures.operations.ProposerSlashing; import tech.pegasys.teku.spec.util.DataStructureUtil; @@ -42,7 +41,6 @@ class EventSourceHandlerTest { final Spec spec = TestSpecFactory.createDefault(); private final DataStructureUtil dataStructureUtil = new DataStructureUtil(spec); - private final JsonProvider jsonProvider = new JsonProvider(); private final ValidatorTimingChannel validatorTimingChannel = mock(ValidatorTimingChannel.class); final StubMetricsSystem metricsSystem = new StubMetricsSystem(); @@ -68,10 +66,12 @@ void onMessage_shouldHandleHeadEvent() throws Exception { blockRoot, dataStructureUtil.randomBytes32(), false, - false, previousDutyDependentRoot, - currentDutyDependentRoot); - handler.onMessage(EventType.head.name(), new MessageEvent(jsonProvider.objectToJSON(event))); + currentDutyDependentRoot, + false); + handler.onMessage( + EventType.head.name(), + new MessageEvent(JsonUtil.serialize(event, HeadEvent.TYPE_DEFINITION))); verify(validatorTimingChannel) .onHeadUpdate( @@ -84,7 +84,7 @@ void onMessage_shouldHandleHeadEvent() throws Exception { void onMessage_shouldHandleAttesterSlashingEvent() throws Exception { final IndexedAttestation indexedAttestation1 = dataStructureUtil.randomIndexedAttestation(); final IndexedAttestation indexedAttestation2 = dataStructureUtil.randomIndexedAttestation(); - final AttesterSlashing.AttesterSlashingSchema attesterSlashingSchema = + final AttesterSlashingSchema attesterSlashingSchema = spec.getGenesisSchemaDefinitions().getAttesterSlashingSchema(); final AttesterSlashing attesterSlashing = attesterSlashingSchema.create(indexedAttestation1, indexedAttestation2); @@ -125,11 +125,12 @@ void onMessage_shouldHandleInvalidMessage() throws Exception { dataStructureUtil.randomBytes32(), dataStructureUtil.randomBytes32(), false, - false, dataStructureUtil.randomBytes32(), - dataStructureUtil.randomBytes32()); + dataStructureUtil.randomBytes32(), + false); // Head message with a reorg type - final MessageEvent messageEvent = new MessageEvent(jsonProvider.objectToJSON(event)); + final MessageEvent messageEvent = + new MessageEvent(JsonUtil.serialize(event, HeadEvent.TYPE_DEFINITION)); assertDoesNotThrow(() -> handler.onMessage(EventType.chain_reorg.name(), messageEvent)); verifyNoInteractions(validatorTimingChannel); } @@ -157,11 +158,13 @@ void onHeadEvent_shouldNotGenerateEarlyAttestationsIfNotEnabled() throws Excepti blockRoot, dataStructureUtil.randomBytes32(), false, - false, previousDutyDependentRoot, - currentDutyDependentRoot); - onTimeHandler.onMessage( - EventType.head.name(), new MessageEvent(jsonProvider.objectToJSON(event))); + currentDutyDependentRoot, + false); + + final MessageEvent messageEvent = + new MessageEvent(JsonUtil.serialize(event, HeadEvent.TYPE_DEFINITION)); + onTimeHandler.onMessage(EventType.head.name(), messageEvent); verify(validatorTimingChannel) .onHeadUpdate( diff --git a/validator/remote/src/test/java/tech/pegasys/teku/validator/remote/sentry/SentryValidatorApiChannelTest.java b/validator/remote/src/test/java/tech/pegasys/teku/validator/remote/sentry/SentryValidatorApiChannelTest.java index 90206644958..4a743704c81 100644 --- a/validator/remote/src/test/java/tech/pegasys/teku/validator/remote/sentry/SentryValidatorApiChannelTest.java +++ b/validator/remote/src/test/java/tech/pegasys/teku/validator/remote/sentry/SentryValidatorApiChannelTest.java @@ -124,15 +124,11 @@ void getProposerDutiesShouldUseDutiesProviderChannel() { @Test void createUnsignedBlockShouldUseBlockHandlerChannelWhenAvailable() { sentryValidatorApiChannel.createUnsignedBlock( - UInt64.ZERO, BLSSignature.empty(), Optional.empty(), Optional.of(false), Optional.of(ONE)); + UInt64.ZERO, BLSSignature.empty(), Optional.empty(), Optional.of(ONE)); verify(blockHandlerChannel) .createUnsignedBlock( - eq(UInt64.ZERO), - eq(BLSSignature.empty()), - eq(Optional.empty()), - eq(Optional.of(false)), - eq(Optional.of(ONE))); + eq(UInt64.ZERO), eq(BLSSignature.empty()), eq(Optional.empty()), eq(Optional.of(ONE))); verifyNoInteractions(dutiesProviderChannel); verifyNoInteractions(attestationPublisherChannel); } @@ -144,15 +140,11 @@ void createUnsignedBlockShouldFallbackToDutiesProviderChannel() { dutiesProviderChannel, Optional.empty(), Optional.of(attestationPublisherChannel)); sentryValidatorApiChannel.createUnsignedBlock( - UInt64.ZERO, BLSSignature.empty(), Optional.empty(), Optional.of(false), Optional.of(ONE)); + UInt64.ZERO, BLSSignature.empty(), Optional.empty(), Optional.of(ONE)); verify(dutiesProviderChannel) .createUnsignedBlock( - eq(UInt64.ZERO), - eq(BLSSignature.empty()), - eq(Optional.empty()), - eq(Optional.of(false)), - eq(Optional.of(ONE))); + eq(UInt64.ZERO), eq(BLSSignature.empty()), eq(Optional.empty()), eq(Optional.of(ONE))); verifyNoInteractions(blockHandlerChannel); verifyNoInteractions(attestationPublisherChannel); } @@ -168,9 +160,10 @@ void createAttestationDataShouldUseDutiesProviderChannel() { @Test void createAggregateShouldUseAttestationPublisherChannelWhenAvailable() { - sentryValidatorApiChannel.createAggregate(UInt64.ZERO, Bytes32.ZERO); + sentryValidatorApiChannel.createAggregate(UInt64.ZERO, Bytes32.ZERO, Optional.of(ONE)); - verify(attestationPublisherChannel).createAggregate(eq(UInt64.ZERO), eq(Bytes32.ZERO)); + verify(attestationPublisherChannel) + .createAggregate(eq(UInt64.ZERO), eq(Bytes32.ZERO), eq(Optional.of(ONE))); verifyNoInteractions(blockHandlerChannel); verifyNoInteractions(dutiesProviderChannel); } @@ -181,9 +174,10 @@ void createAggregateShouldFallbackToDutiesProviderChannel() { new SentryValidatorApiChannel( dutiesProviderChannel, Optional.of(blockHandlerChannel), Optional.empty()); - sentryValidatorApiChannel.createAggregate(UInt64.ZERO, Bytes32.ZERO); + sentryValidatorApiChannel.createAggregate(UInt64.ZERO, Bytes32.ZERO, Optional.of(ONE)); - verify(dutiesProviderChannel).createAggregate(eq(UInt64.ZERO), eq(Bytes32.ZERO)); + verify(dutiesProviderChannel) + .createAggregate(eq(UInt64.ZERO), eq(Bytes32.ZERO), eq(Optional.of(ONE))); verifyNoInteractions(blockHandlerChannel); verifyNoInteractions(attestationPublisherChannel); }